From cdc515bc137e07340fc94013c274cc1f794fe1e1 Mon Sep 17 00:00:00 2001 From: Jeremy Koritzinsky Date: Wed, 12 Aug 2026 16:51:56 -0700 Subject: [PATCH 01/16] Compile IL incrementally with ANTLR parser actions Use an unbuffered token stream and disable whole-document parse-tree construction. Retain only bounded declaration and member subtrees while semantic actions compile them, and stream byte arrays directly. Split the compiler actions by IL feature to keep the implementation maintainable and add error-recovery and large-input coverage. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: c986c103-8383-4db4-9b11-9be49dc68a05 --- src/tools/ilasm/README.md | 64 +- .../ILAssembler/Actions/CILParser.Actions.cs | 59 + .../Actions/GrammarActions.BuildImage.cs | 582 ++ .../Actions/GrammarActions.Bytes.cs | 88 + .../Actions/GrammarActions.Conversions.cs | 225 + .../GrammarActions.CustomAttributes.cs | 738 ++ .../Actions/GrammarActions.Data.cs | 156 + .../Actions/GrammarActions.Debug.cs | 176 + .../Actions/GrammarActions.Declarations.cs | 228 + .../Actions/GrammarActions.Instructions.cs | 474 ++ .../Actions/GrammarActions.Literals.cs | 273 + .../Actions/GrammarActions.Manifest.cs | 673 ++ .../Actions/GrammarActions.Marshalling.cs | 526 ++ .../Actions/GrammarActions.Members.cs | 638 ++ .../Actions/GrammarActions.MethodBodies.cs | 867 +++ .../Actions/GrammarActions.Security.cs | 122 + .../Actions/GrammarActions.Signatures.cs | 763 ++ .../Actions/GrammarActions.Types.cs | 715 ++ .../src/ILAssembler/Actions/GrammarActions.cs | 29 + .../ilasm/src/ILAssembler/DocumentCompiler.cs | 38 +- .../ilasm/src/ILAssembler/GrammarVisitor.cs | 6618 ----------------- .../ILAssembler/PreprocessedTokenSource.cs | 12 +- .../ilasm/src/ILAssembler/StringCharStream.cs | 68 + src/tools/ilasm/src/ILAssembler/gen/CIL.g4 | 103 +- .../ilasm/src/ILAssembler/gen/CIL.interp | 2 +- .../ilasm/src/ILAssembler/gen/CILParser.cs | 1725 ++--- .../ILAssembler/gen/ilasm-generator.csproj | 8 +- .../tests/ILAssembler.Tests/DataTests.cs | 44 + .../DocumentCompilerTests.cs | 123 + .../ExceptionHandlingTests.cs | 60 + .../tests/ILAssembler.Tests/FieldTests.cs | 84 + .../tests/ILAssembler.Tests/InteropTests.cs | 21 + .../tests/ILAssembler.Tests/SyntaxTests.cs | 59 + 33 files changed, 8848 insertions(+), 7513 deletions(-) create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/CILParser.Actions.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.BuildImage.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Bytes.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Data.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Debug.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Marshalling.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs delete mode 100644 src/tools/ilasm/src/ILAssembler/GrammarVisitor.cs create mode 100644 src/tools/ilasm/src/ILAssembler/StringCharStream.cs diff --git a/src/tools/ilasm/README.md b/src/tools/ilasm/README.md index 203eaecda412cf..f93dd514a93ba6 100644 --- a/src/tools/ilasm/README.md +++ b/src/tools/ilasm/README.md @@ -1,25 +1,65 @@ -# ILAssembler Build Workflow +# ILAssembler -This directory contains the ILAssembler tool and its build instructions. +ILAssembler compiles declarations while ANTLR parses the input. The parser uses +`UnbufferedTokenStream` with parse-tree construction disabled. Grammar actions retain bounded +subtrees only while `GrammarActions` processes a declaration or method-body item, so a complete +document or method body is never retained. Rules such as `bytes` stream their content into an +accumulator instead of building a subtree at all. -## Build Instructions +`GrammarActions` is a single `internal sealed partial class` split across +`src/ILAssembler/Actions/GrammarActions.*.cs`: -### Regular Builds -For everyday development and regular builds, simply run: +| File | Contents | +| ---- | -------- | +| `GrammarActions.cs` | Per-document lifecycle. | +| `GrammarActions.BuildImage.cs` | PE and portable PDB construction. | +| `GrammarActions.Bytes.cs` | `bytearray` accumulation. | +| `GrammarActions.Conversions.cs` | `GrammarResult`, shared state and core visitor plumbing. | +| `GrammarActions.CustomAttributes.cs` | Custom attribute values and serialization. | +| `GrammarActions.Data.cs` | Data and blob declarations. | +| `GrammarActions.Debug.cs` | Source and debug directives. | +| `GrammarActions.Declarations.cs` | Top-level `decl` dispatch and conversion. | +| `GrammarActions.Instructions.cs` | Instruction dispatch and conversion. | +| `GrammarActions.Literals.cs` | Literals, names and strings. | +| `GrammarActions.Manifest.cs` | Assembly, module, resource, vtable and typedef directives. | +| `GrammarActions.Marshalling.cs` | Native type and marshalling conversion. | +| `GrammarActions.Members.cs` | Class member dispatch and conversion. | +| `GrammarActions.MethodBodies.cs` | Method, lexical scope and exception-handling state and conversion. | +| `GrammarActions.Security.cs` | Declarative security conversion. | +| `GrammarActions.Signatures.cs` | Signature and type encoding. | +| `GrammarActions.Types.cs` | Namespace and type scopes and declaration conversion. | + +`CILParser.Actions.cs` holds the parse-tree mode helpers the grammar calls. + +## Rules for grammar actions + +Parser actions in `src/ILAssembler/gen/CIL.g4` must remain thin; they call a single `Actions` method +and nothing else. Compilation orchestration belongs in the `GrammarActions` partial-class files. + +Semantic state that a rule pushes must be released from that rule's `finally` clause and be keyed on +the owning context, because ANTLR skips `@after` actions and the remainder of an alternative once a +rule reports a syntax error. Inline actions placed after a subrule reference are not a substitute: +they run only when the alternative completes. + +Only the parser actions walk the structural rules. The recursive `ICILVisitor` entry points for +`decls`, `classDecls`, `methodDecls`, `scopeBlock` and the SEH rules throw `UnreachableException` so +that there is exactly one live traversal algorithm. + +## Build ``` ./dotnet.sh build src/tools/ilasm/src/ILAssembler ``` -### Updating Generated Files -If you modify any `.g4` grammar files (rare), you must regenerate the parser and related files: +On Windows, use `.\dotnet.cmd` instead of `./dotnet.sh`. + +## Updating generated parser files + +After modifying `CIL.g4`, regenerate the checked-in ANTLR output before building ILAssembler: ``` ./dotnet.sh build src/tools/ilasm/src/ILAssembler/gen +./dotnet.sh build src/tools/ilasm/src/ILAssembler ``` -This will update the generated files before building the main project. - ---- - -For more details, see the main repository README or contact the maintainers. +Do not edit generated `CIL*.cs` or `.interp` files manually. diff --git a/src/tools/ilasm/src/ILAssembler/Actions/CILParser.Actions.cs b/src/tools/ilasm/src/ILAssembler/Actions/CILParser.Actions.cs new file mode 100644 index 00000000000000..e0f12ccb9274a3 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/CILParser.Actions.cs @@ -0,0 +1,59 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Generic; +using System.Diagnostics; +using Antlr4.Runtime; + +namespace ILAssembler; + +public partial class CILParser +{ + private readonly Stack _parseTreeModes = new(); + private bool _detachNextOuterAlternative; + + internal GrammarActions Actions { get; set; } = null!; + + private void BeginSubtree() + { + bool previousMode = BuildParseTree; + _parseTreeModes.Push(previousMode); + BuildParseTree = true; + _detachNextOuterAlternative = !previousMode; + } + + private void BeginStreaming() + { + _parseTreeModes.Push(BuildParseTree); + BuildParseTree = false; + } + + private void EndParseTreeMode() + { + Debug.Assert(_parseTreeModes.Count > 0); + _detachNextOuterAlternative = false; + BuildParseTree = _parseTreeModes.Pop(); + } + + public override void EnterOuterAlt(ParserRuleContext localContext, int alternativeNumber) + { + if (!_detachNextOuterAlternative) + { + base.EnterOuterAlt(localContext, alternativeNumber); + return; + } + + _detachNextOuterAlternative = false; + BuildParseTree = false; + try + { + base.EnterOuterAlt(localContext, alternativeNumber); + } + finally + { + BuildParseTree = true; + } + } + + internal void VerifyParseTreeModesBalanced() => Debug.Assert(_parseTreeModes.Count == 0); +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.BuildImage.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.BuildImage.cs new file mode 100644 index 00000000000000..25988748f5794b --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.BuildImage.cs @@ -0,0 +1,582 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Buffers.Binary; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using System.Reflection.PortableExecutable; +using System.Runtime.InteropServices; +using System.Security.Cryptography; +using System.Text; +using Antlr4.Runtime; +using Antlr4.Runtime.Misc; +using Antlr4.Runtime.Tree; + +namespace ILAssembler +{ +#pragma warning disable CA1822 // Mark members as static + internal sealed partial class GrammarActions : ICILVisitor + { + public (ImmutableArray Diagnostics, CompilationResult? Image) BuildImage() + { + // Default module name to output filename if no .module directive was provided + if (_entityRegistry.Module.Name is null && _options.OutputFileName is not null) + { + _entityRegistry.Module.Name = _options.OutputFileName; + } + + // Apply DebuggableAttribute AFTER all source declarations have been processed, + // so that GetCoreLibAssemblyReference() can find the correct corelib assembly ref + // declared in the source (e.g., System.Runtime) instead of creating a fallback mscorlib. + if (_entityRegistry.Assembly is not null && (_options.Debug || _options.DebugMode is not null)) + { + ApplyDebuggableAttribute(); + } + + // Return early if there are structural errors that prevent building valid metadata. + // However, allow errors in method bodies (ILA0016-0019) to pass through so we can + // emit the assembly with the errors reported. + // In error-tolerant mode, continue despite errors. + var structuralErrors = _diagnostics.Where(d => d.Severity == DiagnosticSeverity.Error && !IsRecoverableError(d.Id)); + if (structuralErrors.Any() && !_options.ErrorTolerant) + { + return (_diagnostics.ToImmutable(), null); + } + + // Check for vtable fixups and exports - collect export info + var exports = ImmutableArray.CreateBuilder(); + foreach (EntityRegistry.MethodDefinitionEntity method in GetParsedMethods()) + { + if (method.ExportOrdinal >= 0) + { + exports.Add(new VTableExportPEBuilder.ExportInfo( + method.ExportOrdinal, + method.ExportAlias ?? method.Name, + MetadataTokens.GetToken(method.Handle), + method.VTableEntry, + method.VTableSlot)); + } + } + + BlobBuilder ilStream = new(); + PseudoCustomAttributes.Lower(_entityRegistry, _diagnostics); + Blob mvidFixup = _entityRegistry.WriteContentTo(_metadataBuilder, ilStream, _mappedFieldDataNames, _options.Deterministic); + MetadataRootBuilder rootBuilder = new(_metadataBuilder, _options.MetadataVersion); + + // Compute metadata size from the MetadataSizes + // We need this for data label fixup RVA calculations + var sizes = rootBuilder.Sizes; + int metadataSize = ComputeMetadataSize(sizes); + + // Apply command-line overrides + Subsystem subsystem = _options.Subsystem ?? _subsystem; + int fileAlignment = _options.FileAlignment ?? _alignment; + long imageBase = _options.ImageBase ?? _imageBase; + ushort majorSubsystemVersion = _options.SubsystemVersion?.Major ?? 4; + ushort minorSubsystemVersion = _options.SubsystemVersion?.Minor ?? 0; + Machine machine = _options.Machine ?? Machine.I386; + + // Build DllCharacteristics from options + DllCharacteristics dllCharacteristics = DllCharacteristics.DynamicBase | DllCharacteristics.NxCompatible | DllCharacteristics.NoSeh | DllCharacteristics.TerminalServerAware; + if (_options.AppContainer) + { + dllCharacteristics |= DllCharacteristics.AppContainer; + } + if (_options.HighEntropyVA) + { + dllCharacteristics |= DllCharacteristics.HighEntropyVirtualAddressSpace; + } + if (_options.StripReloc) + { + dllCharacteristics &= ~DllCharacteristics.DynamicBase; + } + + Characteristics imageCharacteristics = Characteristics.ExecutableImage; + if (_options.Dll) + { + imageCharacteristics |= Characteristics.Dll; + } + if (machine is Machine.I386 or Machine.Arm) + { + imageCharacteristics |= Characteristics.Bit32Machine; + } + else if (machine is Machine.Amd64 or Machine.Arm64) + { + imageCharacteristics |= Characteristics.LargeAddressAware; + } + + // Compute stack reserve: command-line option overrides directive, which overrides default + ulong sizeOfStackReserve = (ulong)(_options.StackReserve ?? (_stackReserve != 0 ? _stackReserve : 0x00100000)); + + PEHeaderBuilder header = new( + machine: machine, + fileAlignment: fileAlignment, + imageBase: (ulong)imageBase, + subsystem: subsystem, + majorSubsystemVersion: majorSubsystemVersion, + minorSubsystemVersion: minorSubsystemVersion, + dllCharacteristics: dllCharacteristics, + imageCharacteristics: imageCharacteristics, + sizeOfStackReserve: sizeOfStackReserve); + + MethodDefinitionHandle entryPoint = default; + if (_entityRegistry.EntryPoint is not null) + { + entryPoint = (MethodDefinitionHandle)_entityRegistry.EntryPoint.Handle; + } + + // Build debug directory if we have any debug info + DebugDirectoryBuilder? debugDirectoryBuilder = BuildDebugDirectory(entryPoint, out int debugDataSize); + + // Use custom PE builder if we have vtable fixups, exports, or data label reference fixups + if (_vtableFixups.Count > 0 || exports.Count > 0 || _mappedFieldDataReferenceFixups.Count > 0) + { + var vtableFixupInfos = BuildVTableFixupInfos(); + + // Apply CorFlags from options or directive + CorFlags corFlags = _options.CorFlags ?? _corflags; + if (_options.Prefer32Bit) + { + corFlags |= CorFlags.Prefers32Bit; + } + + VTableExportPEBuilder peBuilder = new( + header, + rootBuilder, + ilStream, + _mappedFieldData, + _manifestResources, + debugDirectoryBuilder: debugDirectoryBuilder, + entryPoint: entryPoint, + flags: corFlags, + vtableFixups: vtableFixupInfos, + exports: exports.ToImmutable(), + mappedFieldDataOffsets: _mappedFieldDataNames, + dataLabelFixups: _mappedFieldDataReferenceFixups, + metadataSize: metadataSize, + debugDataSize: debugDataSize); + + return (_diagnostics.ToImmutable(), new CompilationResult(peBuilder, mvidFixup)); + } + + // Apply CorFlags from options or directive + CorFlags standardCorFlags = _options.CorFlags ?? _corflags; + if (_options.Prefer32Bit) + { + standardCorFlags |= CorFlags.Prefers32Bit; + } + + // Deterministic ID provider for reproducible builds + Func, BlobContentId>? deterministicIdProvider = _options.Deterministic + ? GetDeterministicContentId + : null; + + ManagedPEBuilder standardBuilder = new( + header, + rootBuilder, + ilStream, + _mappedFieldData, + _manifestResources, + flags: standardCorFlags, + entryPoint: entryPoint, + debugDirectoryBuilder: debugDirectoryBuilder, + deterministicIdProvider: deterministicIdProvider); + + return (_diagnostics.ToImmutable(), new CompilationResult(standardBuilder, mvidFixup)); + } + + private static BlobContentId GetDeterministicContentId(IEnumerable content) + { + using IncrementalHash hash = IncrementalHash.CreateHash(HashAlgorithmName.SHA256); + foreach (Blob blob in content) + { + hash.AppendData(blob.GetBytes()); + } + + return BlobContentId.FromHash(hash.GetHashAndReset()); + } + + private ImmutableArray BuildVTableFixupInfos() + { + if (_vtableFixups.Count == 0) + return ImmutableArray.Empty; + + var builder = ImmutableArray.CreateBuilder(_vtableFixups.Count); + + for (int entryIndex = 0; entryIndex < _vtableFixups.Count; entryIndex++) + { + var vtf = _vtableFixups[entryIndex]; + var methodTokens = ImmutableArray.CreateBuilder(vtf.SlotCount); + + // Initialize with zeros + for (int i = 0; i < vtf.SlotCount; i++) + { + methodTokens.Add(0); + } + + // Find methods that reference this vtable entry + foreach (EntityRegistry.MethodDefinitionEntity method in GetParsedMethods()) + { + if (method.VTableEntry == entryIndex + 1 && // 1-based + method.VTableSlot > 0 && + method.VTableSlot <= vtf.SlotCount) + { + methodTokens[method.VTableSlot - 1] = MetadataTokens.GetToken(method.Handle); + } + } + + builder.Add(new VTableExportPEBuilder.VTableFixupInfo( + vtf.DataLabel, + vtf.SlotCount, + vtf.Flags, + methodTokens.ToImmutable())); + } + + return builder.ToImmutable(); + } + + private IEnumerable GetParsedMethods() + { + foreach (EntityRegistry.TypeDefinitionEntity type in _entityRegistry.GetSeenEntities(TableIndex.TypeDef)) + { + foreach (EntityRegistry.MethodDefinitionEntity method in type.Methods) + { + yield return method; + } + } + } + + private DebugDirectoryBuilder? BuildDebugDirectory(MethodDefinitionHandle entryPoint, out int debugDataSize) + { + debugDataSize = 0; + + // Check if we have any methods with debug info + bool hasDebugInfo = false; + foreach (var entity in _entityRegistry.GetSeenEntities(TableIndex.MethodDef)) + { + if (entity is EntityRegistry.MethodDefinitionEntity method && + method.DebugInfo.SequencePoints.Count > 0) + { + hasDebugInfo = true; + break; + } + } + + // Generate PDB if we have debug info OR if --debug/--pdb options are set + bool generatePdb = hasDebugInfo || _options.Debug || _options.Pdb; + if (!generatePdb) + { + return null; + } + + // Build PDB metadata + BuildPdbMetadata(); + + // Get row counts from main metadata for the portable PDB + var typeSystemRowCounts = _metadataBuilder.GetRowCounts(); + + // Create the portable PDB + var pdbBuilder = new PortablePdbBuilder( + _pdbBuilder, + typeSystemRowCounts, + entryPoint, + idProvider: _options.Deterministic ? GetDeterministicContentId : null); + + var pdbBlob = new BlobBuilder(); + var pdbContentId = pdbBuilder.Serialize(pdbBlob); + + // Create debug directory with embedded PDB + var debugDirectoryBuilder = new DebugDirectoryBuilder(); + debugDirectoryBuilder.AddCodeViewEntry( + $"assembly.pdb", + pdbContentId, + pdbBuilder.FormatVersion); + debugDirectoryBuilder.AddEmbeddedPortablePdbEntry(pdbBlob, pdbBuilder.FormatVersion); + + // Calculate debug data size: + // 2 debug directory entries (28 bytes each) + CodeView data (~24 bytes) + Embedded PDB data (compressed pdbBlob + 8 header) + // CodeView entry: signature (4) + guid (16) + age (4) + path (variable, ~12 for "assembly.pdb\0") + const int debugDirEntrySize = 28; + int codeViewDataSize = 4 + 16 + 4 + "assembly.pdb".Length + 1; // signature + guid + age + path + null + int embeddedPdbHeaderSize = 8; // MPDB signature (4) + uncompressed size (4) + // The embedded PDB is compressed, estimate conservatively as same size + int embeddedPdbDataSize = embeddedPdbHeaderSize + pdbBlob.Count; + + debugDataSize = (2 * debugDirEntrySize) + codeViewDataSize + embeddedPdbDataSize; + + return debugDirectoryBuilder; + } + + private void BuildPdbMetadata() + { + // Add documents and sequence points to the PDB metadata builder + foreach (var entity in _entityRegistry.GetSeenEntities(TableIndex.MethodDef)) + { + if (entity is not EntityRegistry.MethodDefinitionEntity method) + { + continue; + } + + var debugInfo = method.DebugInfo; + if (debugInfo.SequencePoints.Count == 0) + { + // Add empty debug info entry for methods without sequence points + _pdbBuilder.AddMethodDebugInformation(default, default); + continue; + } + + // Get or create document handle + DocumentHandle documentHandle = default; + if (debugInfo.DocumentPath is not null) + { + if (!_documentHandles.TryGetValue(debugInfo.DocumentPath, out documentHandle)) + { + var nameHandle = _pdbBuilder.GetOrAddDocumentName(debugInfo.DocumentPath); + var languageGuidHandle = _currentLanguageGuid != Guid.Empty + ? _pdbBuilder.GetOrAddGuid(_currentLanguageGuid) + : default; + documentHandle = _pdbBuilder.AddDocument( + nameHandle, + default, // hash algorithm + default, // hash + languageGuidHandle); + _documentHandles[debugInfo.DocumentPath] = documentHandle; + } + } + + // Encode sequence points + var sequencePointsBlob = EncodeSequencePoints(debugInfo.SequencePoints); + var sequencePointsBlobHandle = _pdbBuilder.GetOrAddBlob(sequencePointsBlob); + + _pdbBuilder.AddMethodDebugInformation(documentHandle, sequencePointsBlobHandle); + } + } + + private static BlobBuilder EncodeSequencePoints(List sequencePoints) + { + var builder = new BlobBuilder(); + + if (sequencePoints.Count == 0) + { + return builder; + } + + // LocalSignature (not used here, write 0) + builder.WriteCompressedInteger(0); + + int previousOffset = 0; + int previousStartLine = -1; + int previousStartColumn = -1; + + foreach (var sp in sequencePoints) + { + // IL offset delta + int offsetDelta = sp.ILOffset - previousOffset; + builder.WriteCompressedInteger(offsetDelta); + previousOffset = sp.ILOffset; + + if (sp.IsHidden) + { + // Hidden sequence point: delta lines = 0, delta columns = 0 + builder.WriteCompressedInteger(0); + builder.WriteCompressedInteger(0); + } + else + { + // Delta lines + int deltaLines = sp.EndLine - sp.StartLine; + builder.WriteCompressedInteger(deltaLines); + + // Delta columns + int deltaColumns = sp.EndColumn - sp.StartColumn; + if (deltaLines == 0) + { + builder.WriteCompressedInteger(deltaColumns); + } + else + { + builder.WriteCompressedSignedInteger(deltaColumns); + } + + // Start line delta (signed) + if (previousStartLine < 0) + { + builder.WriteCompressedInteger(sp.StartLine); + } + else + { + builder.WriteCompressedSignedInteger(sp.StartLine - previousStartLine); + } + + // Start column delta (signed) + if (previousStartColumn < 0) + { + builder.WriteCompressedInteger(sp.StartColumn); + } + else + { + builder.WriteCompressedSignedInteger(sp.StartColumn - previousStartColumn); + } + + previousStartLine = sp.StartLine; + previousStartColumn = sp.StartColumn; + } + } + + return builder; + } + + /// + /// Add DebuggableAttribute to the assembly based on debug options. + /// - /DEBUG: 0x101 = Default | DisableOptimizations + /// - /DEBUG=OPT: 0x03 = Default | IgnoreSymbolStoreSequencePoints + /// - /DEBUG=IMPL: 0x103 = Default | DisableOptimizations | EnableEditAndContinue + /// + private void ApplyDebuggableAttribute() + { + if (_entityRegistry.Assembly is null) + { + return; + } + + // DebuggingModes enum values from System.Diagnostics.DebuggableAttribute: + // None = 0x00, Default = 0x01, IgnoreSymbolStoreSequencePoints = 0x02, + // EnableEditAndContinue = 0x04, DisableOptimizations = 0x100 + const int DebuggingModesDefault = 0x101; // Default | DisableOptimizations + const int DebuggingModesOpt = 0x03; // Default | IgnoreSymbolStoreSequencePoints + const int DebuggingModesImpl = 0x103; // Default | DisableOptimizations | EnableEditAndContinue + + int debuggingModes = _options.DebugMode switch + { + DebugMode.Opt => DebuggingModesOpt, + DebugMode.Impl => DebuggingModesImpl, + _ => DebuggingModesDefault + }; + + // Get reference to core library + var coreAsmRef = _entityRegistry.GetCoreLibAssemblyReference(); + + // Create reference to System.Diagnostics.DebuggableAttribute + var debuggableAttrType = _entityRegistry.GetOrCreateTypeReference( + coreAsmRef, + new TypeName(null, "System.Diagnostics.DebuggableAttribute")); + + // Create reference to nested type DebuggingModes + var debuggingModesType = _entityRegistry.GetOrCreateTypeReference( + debuggableAttrType, + new TypeName(null, "DebuggingModes")); + + // Create constructor signature: .ctor(DebuggingModes) + BlobBuilder ctorSig = new(); + var sigEncoder = new BlobEncoder(ctorSig); + sigEncoder.MethodSignature(SignatureCallingConvention.Default, 0, isInstanceMethod: true) + .Parameters(1, + returnType => returnType.Void(), + parameters => parameters.AddParameter().Type().Type(debuggingModesType.Handle, isValueType: true)); + + var ctor = _entityRegistry.CreateLazilyRecordedMemberReference(debuggableAttrType, ".ctor", ctorSig); + + // Create custom attribute blob: prolog (0x0001) + int32 value + named args count (0x0000) + BlobBuilder attrValue = new(); + attrValue.WriteUInt16(0x0001); // Prolog + attrValue.WriteInt32(debuggingModes); // DebuggingModes value + attrValue.WriteUInt16(0x0000); // No named arguments + + // Create and attach the custom attribute + var customAttr = _entityRegistry.CreateCustomAttribute(ctor, attrValue); + customAttr.Owner = _entityRegistry.Assembly; + } + + /// + /// Computes the total metadata size from MetadataSizes. + /// This replicates the internal MetadataSizes.MetadataSize calculation. + /// + private static int ComputeMetadataSize(MetadataSizes sizes) + { + // Metadata header size (fixed structure): + // - signature (4) + // - major/minor version (4) + // - reserved (4) + // - version string length (4) + // - version string padded to 4 bytes ("v4.0.30319" = 12 bytes padded) + // - storage header (4) + // - 5 stream headers (#~, #Strings, #US, #GUID, #Blob) = 76 bytes + // Total header: ~108 bytes + const int metadataHeaderSize = 108; + + // Stream storage: heaps (#Strings, #US, #GUID, #Blob) - we can get aligned sizes + int heapStorageSize = 0; + heapStorageSize += sizes.GetAlignedHeapSize(HeapIndex.String); + heapStorageSize += sizes.GetAlignedHeapSize(HeapIndex.UserString); + heapStorageSize += sizes.GetAlignedHeapSize(HeapIndex.Guid); + heapStorageSize += sizes.GetAlignedHeapSize(HeapIndex.Blob); + + // Table stream (#~): header + table data + // Header: Reserved(4) + Version(2) + HeapSizes(1) + RowIdBitWidth(1) + ValidMask(8) + SortedMask(8) + // + 4 bytes per present table for row counts + int tableStreamSize = 24; // base header + var rowCounts = sizes.RowCounts; + + // Count present tables and add 4 bytes each for row count + for (int i = 0; i < rowCounts.Length; i++) + { + if (rowCounts[i] > 0) + { + tableStreamSize += 4; + } + } + + // Add table data size with estimated row sizes + // Row sizes depend on index sizes (2 or 4 bytes) which we don't have access to + // For small assemblies, all indexes are 2 bytes + tableStreamSize += rowCounts[(int)TableIndex.Module] * 10; // 2+2+2+2+2 + tableStreamSize += rowCounts[(int)TableIndex.TypeRef] * 6; // 2+2+2 + tableStreamSize += rowCounts[(int)TableIndex.TypeDef] * 14; // 4+2+2+2+2+2 + tableStreamSize += rowCounts[(int)TableIndex.Field] * 6; // 2+2+2 + tableStreamSize += rowCounts[(int)TableIndex.MethodDef] * 14; // 4+2+2+2+2+2 + tableStreamSize += rowCounts[(int)TableIndex.Param] * 6; // 2+2+2 + tableStreamSize += rowCounts[(int)TableIndex.InterfaceImpl] * 4; // 2+2 + tableStreamSize += rowCounts[(int)TableIndex.MemberRef] * 6; // 2+2+2 + tableStreamSize += rowCounts[(int)TableIndex.Constant] * 6; // 2+2+2 + tableStreamSize += rowCounts[(int)TableIndex.CustomAttribute] * 6; // 2+2+2 + tableStreamSize += rowCounts[(int)TableIndex.FieldMarshal] * 4; // 2+2 + tableStreamSize += rowCounts[(int)TableIndex.DeclSecurity] * 6; // 2+2+2 + tableStreamSize += rowCounts[(int)TableIndex.ClassLayout] * 8; // 2+4+2 + tableStreamSize += rowCounts[(int)TableIndex.FieldLayout] * 6; // 4+2 + tableStreamSize += rowCounts[(int)TableIndex.StandAloneSig] * 2; // 2 + tableStreamSize += rowCounts[(int)TableIndex.EventMap] * 4; // 2+2 + tableStreamSize += rowCounts[(int)TableIndex.Event] * 6; // 2+2+2 + tableStreamSize += rowCounts[(int)TableIndex.PropertyMap] * 4; // 2+2 + tableStreamSize += rowCounts[(int)TableIndex.Property] * 6; // 2+2+2 + tableStreamSize += rowCounts[(int)TableIndex.MethodSemantics] * 6; // 2+2+2 + tableStreamSize += rowCounts[(int)TableIndex.MethodImpl] * 6; // 2+2+2 + tableStreamSize += rowCounts[(int)TableIndex.ModuleRef] * 2; // 2 + tableStreamSize += rowCounts[(int)TableIndex.TypeSpec] * 2; // 2 + tableStreamSize += rowCounts[(int)TableIndex.ImplMap] * 8; // 2+2+2+2 + tableStreamSize += rowCounts[(int)TableIndex.FieldRva] * 6; // 4+2 + tableStreamSize += rowCounts[(int)TableIndex.Assembly] * 22; // 16+2+2+2 + tableStreamSize += rowCounts[(int)TableIndex.AssemblyRef] * 20; // 12+2+2+2+2 + tableStreamSize += rowCounts[(int)TableIndex.File] * 8; // 4+2+2 + tableStreamSize += rowCounts[(int)TableIndex.ExportedType] * 14; // 8+2+2+2 + tableStreamSize += rowCounts[(int)TableIndex.ManifestResource] * 12; // 8+2+2 + tableStreamSize += rowCounts[(int)TableIndex.NestedClass] * 4; // 2+2 + tableStreamSize += rowCounts[(int)TableIndex.GenericParam] * 8; // 4+2+2 + tableStreamSize += rowCounts[(int)TableIndex.MethodSpec] * 4; // 2+2 + tableStreamSize += rowCounts[(int)TableIndex.GenericParamConstraint] * 4; // 2+2 + + // Align table stream to 4 bytes (includes +1 for terminating 0 byte) + tableStreamSize = ((tableStreamSize + 1) + 3) & ~3; + + return metadataHeaderSize + heapStorageSize + tableStreamSize; + } + + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Bytes.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Bytes.cs new file mode 100644 index 00000000000000..dec3f6b41e252c --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Bytes.cs @@ -0,0 +1,88 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Buffers.Binary; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using System.Reflection.PortableExecutable; +using System.Runtime.InteropServices; +using System.Security.Cryptography; +using System.Text; +using Antlr4.Runtime; +using Antlr4.Runtime.Misc; +using Antlr4.Runtime.Tree; + +namespace ILAssembler; + +internal sealed partial class GrammarActions +{ + private ImmutableArray.Builder? _byteAccumulator; + + /// + /// Starts accumulating the bytes of a bytearray literal. + /// + /// + /// The bytes rule disables parse-tree construction for its children, so the individual + /// hexbyte contexts and terminals are collectable as soon as they are matched. The bytes + /// themselves stream into this accumulator, which keeps a single byte array alive instead of a + /// context and a terminal node per byte. + /// + internal void BeginBytes() => _byteAccumulator = ImmutableArray.CreateBuilder(); + + internal void AddByte(byte value) => _byteAccumulator?.Add(value); + + internal ImmutableArray EndBytes() + { + ImmutableArray.Builder? accumulator = _byteAccumulator; + _byteAccumulator = null; + return accumulator?.DrainToImmutable() ?? ImmutableArray.Empty; + } + + /// + /// Parses a single hexbyte token. + /// + internal static byte ParseHexbyte(IToken token) + { + // hexbyte can be HEXBYTE, INT32, or ID token (due to lexer ambiguity). + // Validate the text is 1-2 hex characters to avoid FormatException + // from non-hex ID tokens or values > 0xFF from longer INT32 tokens. + string text = token.Text; + if (text.Length <= 2 && byte.TryParse(text, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out byte value)) + { + return value; + } + + // For invalid hex values, mask to byte (matching native ilasm tolerance). + return int.TryParse(text, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out int intValue) + ? (byte)(intValue & 0xFF) + : (byte)0; + } + +#pragma warning disable CA1822 // Mark members as static + GrammarResult ICILVisitor.VisitBytes(CILParser.BytesContext context) => new GrammarResult.Sequence(VisitBytes(context)); + + /// + /// Returns the bytes the parser accumulated while matching . + /// + /// + /// The bytes rule streams its content into an accumulator instead of building a + /// parse subtree, so the value is read off the context rather than recomputed from children. + /// + public static ImmutableArray VisitBytes(CILParser.BytesContext context) + => context.Value.IsDefault ? ImmutableArray.Empty : context.Value; + + GrammarResult ICILVisitor.VisitHexbyte(CILParser.HexbyteContext context) + { + return new GrammarResult.Literal(context.Value); + } + +#pragma warning restore CA1822 // Mark members as static +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs new file mode 100644 index 00000000000000..8b1d0110120322 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs @@ -0,0 +1,225 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Buffers.Binary; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using System.Reflection.PortableExecutable; +using System.Runtime.InteropServices; +using System.Security.Cryptography; +using System.Text; +using Antlr4.Runtime; +using Antlr4.Runtime.Misc; +using Antlr4.Runtime.Tree; + +namespace ILAssembler +{ + internal abstract record GrammarResult + { + protected GrammarResult() { } + + public sealed record String(string Value) : GrammarResult; + + public sealed record Literal(T Value) : GrammarResult; + + public sealed record Sequence(ImmutableArray Value) : GrammarResult; + + /// + /// A formatted blob of bytes. + /// + /// The bytes of the blob. + public sealed record FormattedBlob(BlobBuilder Value) : GrammarResult; + + public sealed record SentinelValue + { + public static SentinelValue Instance { get; } = new(); + + public static Literal Result { get; } = new(Instance); + } + + public sealed record Flag(T Value, bool ShouldAppend = true) : GrammarResult + where T : struct, Enum + { + private readonly T _groupMask; + public Flag(T value, bool shouldAppend, T groupMask) + : this(value, shouldAppend) + { + _groupMask = groupMask; + } + public Flag(T value, T groupMask) + : this(value) + { + _groupMask = groupMask; + } + + public static T operator |(T lhs, Flag rhs) + { + if (!rhs.ShouldAppend) + { + return rhs.Value; + } + int lhsInt = Convert.ToInt32(lhs); + int maskInt = Convert.ToInt32(rhs._groupMask); + int valueInt = Convert.ToInt32(rhs.Value); + return (T)Enum.ToObject(typeof(T), (lhsInt & ~maskInt) | valueInt); + } + } + } + +#pragma warning disable CA1822 // Mark members as static + internal sealed partial class GrammarActions : ICILVisitor + { + private const string NodeShouldNeverBeDirectlyVisited = "This node should never be directly visited. It should be directly processed by its parent node."; + private const string StructuralNodeIsDrivenByParserActions = "This node is processed incrementally by the parser semantic actions and must never be visited recursively."; + private readonly ImmutableArray.Builder _diagnostics = ImmutableArray.CreateBuilder(); + private readonly EntityRegistry _entityRegistry = new(); + private readonly IReadOnlyDictionary _documents; + private readonly Options _options; + private readonly MetadataBuilder _metadataBuilder = new(); + private readonly Func _resourceLocator; + + // Record the mapped field data directly into the blob to ensure we preserve ordering + private readonly BlobBuilder _mappedFieldData = new(); + private readonly Dictionary _mappedFieldDataNames = new(); + private readonly Dictionary> _mappedFieldDataReferenceFixups = new(); + private readonly BlobBuilder _manifestResources = new(); + + // Typedef aliases - maps alias name to the resolved entity + private readonly Dictionary _typedefs = new(); + + // Debug info tracking + private Guid _currentLanguageGuid = Guid.Empty; + private Guid _currentLanguageVendorGuid = Guid.Empty; + private Guid _currentDocumentTypeGuid = Guid.Empty; + private string? _currentDocumentPath; + private readonly Dictionary _documentHandles = new(); + private readonly MetadataBuilder _pdbBuilder = new(); + + // VTable fixup tracking - uses types from VTableFixupSupport + private readonly List _vtableFixups = new(); + + internal GrammarActions(IReadOnlyDictionary documents, Options options, Func resourceLocator) + { + _documents = documents; + _options = options; + _resourceLocator = resourceLocator; + } + /// + /// Represents a typedef alias entry. + /// + private abstract record TypedefEntry + { + public sealed record Type(EntityRegistry.TypeEntity Entity) : TypedefEntry; + public sealed record TypeBlob(BlobBuilder Blob) : TypedefEntry; + public sealed record Member(EntityRegistry.EntityBase Entity) : TypedefEntry; + public sealed record CustomAttribute(EntityRegistry.EntityBase Constructor, BlobBuilder Value) : TypedefEntry; + } + + private void ReportDiagnostic(DiagnosticSeverity severity, string id, string message, Antlr4.Runtime.ParserRuleContext context) + { + var location = Location.From(context.Start, _documents); + _diagnostics.Add(new Diagnostic(id, severity, message, location)); + } + + private void ReportError(string id, string message, Antlr4.Runtime.ParserRuleContext context) + => ReportDiagnostic(DiagnosticSeverity.Error, id, message, context); + + private void ReportWarning(string id, string message, Antlr4.Runtime.ParserRuleContext context) + => ReportDiagnostic(DiagnosticSeverity.Warning, id, message, context); + + private static bool IsRecoverableError(string diagnosticId) + { + // Method body and signature diagnostics are recoverable - we emit the assembly but report the error. + // This matches native ilasm behavior where errors during method/field emission don't prevent + // the assembly from being written when the /ERR (OnErrGo) flag is set. + return diagnosticId is DiagnosticIds.ByteArrayTooShort + or DiagnosticIds.ArgumentNotFound + or DiagnosticIds.LocalNotFound + or DiagnosticIds.LabelNotFound + or DiagnosticIds.GenericParameterIndexOutOfRange + or DiagnosticIds.ParameterIndexOutOfRange + or DiagnosticIds.GenericParameterNotFound + or DiagnosticIds.UnknownGenericParameter + or DiagnosticIds.MissingInstanceCallConv; + } + + public GrammarResult Visit(IParseTree tree) => tree.Accept(this); + + private EntityRegistry.AssemblyOrRefEntity? _currentAssemblyOrRef; + + public GrammarResult VisitChildren(IRuleNode node) + { + for (int i = 0; i < node.ChildCount; i++) + { + node.GetChild(i).Accept(this); + } + return GrammarResult.SentinelValue.Result; + } + + private sealed class CurrentMethodContext + { + public CurrentMethodContext(EntityRegistry.MethodDefinitionEntity definition) + { + Definition = definition; + // Populate argument names from the method's parameter definitions + foreach (var param in definition.Parameters) + { + if (param.Name is not null && param.Sequence > 0) + { + ArgumentNames[param.Name] = param.Sequence - 1; + } + } + } + + public EntityRegistry.MethodDefinitionEntity Definition { get; } + + public Dictionary Labels { get; } = new(); + + public HashSet DeclaredLabels { get; } = new(); + + public Dictionary UndefinedLabelReferences { get; } = new(); + + public Dictionary ArgumentNames { get; } = new(); + + public List> LocalsScopes { get; } = new(); + + public List AllLocals { get; } = new(); + } + + private CurrentMethodContext? _currentMethod; + private EntityRegistry.FieldDefinitionEntity? _lastFieldDefinition; + private EntityRegistry.EntityBase? _pendingClassCustomAttributeOwner; + + private const ushort CustomAttributeBlobFormatVersion = 1; + + private readonly Stack _currentNamespace = new(); + + private readonly Stack _currentTypeDefinition = new(); + + public GrammarResult VisitErrorNode(IErrorNode node) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + + // Sentinel to distinguish "no constant" from "constant is null" + private sealed class NoConstantSentinel + { + public static readonly NoConstantSentinel Instance = new(); + private NoConstantSentinel() { } + } + + private bool _expectInstance; + private Subsystem _subsystem = Subsystem.WindowsCui; + private CorFlags _corflags = CorFlags.ILOnly; + private int _alignment = 0x200; + private long _imageBase = 0x00400000; + private long _stackReserve; + + public GrammarResult VisitTerminal(ITerminalNode node) => throw new UnreachableException(); + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.cs new file mode 100644 index 00000000000000..3ed52eb7da6486 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.cs @@ -0,0 +1,738 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Buffers.Binary; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using System.Reflection.PortableExecutable; +using System.Runtime.InteropServices; +using System.Security.Cryptography; +using System.Text; +using Antlr4.Runtime; +using Antlr4.Runtime.Misc; +using Antlr4.Runtime.Tree; + +namespace ILAssembler +{ +#pragma warning disable CA1822 // Mark members as static + internal sealed partial class GrammarActions : ICILVisitor + { + GrammarResult ICILVisitor.VisitBoolSeq(CILParser.BoolSeqContext context) => VisitBoolSeq(context); + public static GrammarResult.FormattedBlob VisitBoolSeq(CILParser.BoolSeqContext context) + { + var builder = ImmutableArray.CreateBuilder(); + + foreach (var item in context.truefalse()) + { + builder.AddRange(VisitTruefalse(item).Value); + } + + return new(builder.ToImmutable().SerializeSequence()); + } + + GrammarResult ICILVisitor.VisitCaValue(CILParser.CaValueContext context) => VisitCaValue(context); + public GrammarResult.FormattedBlob VisitCaValue(CILParser.CaValueContext context) + { + BlobBuilder blob = new(); + if (context.truefalse() is CILParser.TruefalseContext truefalse) + { + blob.WriteByte((byte)SerializationTypeCode.Boolean); + blob.WriteBoolean(VisitTruefalse(truefalse).Value); + } + else if (context.compQstring() is CILParser.CompQstringContext str) + { + blob.WriteUTF8(VisitCompQstring(str).Value); + blob.WriteByte(0); + } + else if (context.className() is CILParser.ClassNameContext className) + { + var name = VisitClassName(className).Value; + blob.WriteByte((byte)SerializationTypeCode.Enum); + blob.WriteUTF8((name as EntityRegistry.IHasReflectionNotation)?.ReflectionNotation ?? ""); + blob.WriteByte(0); + byte size = 4; + if (context.INT8() is not null) + { + size = 1; + } + else if (context.INT16() is not null) + { + size = 2; + } + blob.WriteByte(size); + blob.WriteInt32(VisitInt32(context.int32()).Value); + } + else + { + blob.WriteByte((byte)SerializationTypeCode.Int32); + blob.WriteInt32(VisitInt32(context.int32()).Value); + } + return new(blob); + } + + GrammarResult ICILVisitor.VisitCustomAttrDecl(CILParser.CustomAttrDeclContext context) => VisitCustomAttrDecl(context); + public GrammarResult.Literal VisitCustomAttrDecl(CILParser.CustomAttrDeclContext context) + { + if (context.dottedName() is { } dottedName) + { + // This is a typedef reference for a custom attribute + string alias = VisitDottedName(dottedName).Value; + var resolved = TryResolveTypedefAsCustomAttribute(alias); + if (resolved is not null) + { + var typedefAttribute = _entityRegistry.CreateCustomAttribute(resolved.Value.Constructor, resolved.Value.Value); + typedefAttribute.Location = Location.From(context.Start, _documents); + return new(typedefAttribute); + } + // Typedef not found - could report diagnostic here + return new(null); + } + if (context.customDescrWithOwner() is {} descrWithOwner) + { + // Visit the custom attribute descriptor to record it, + // but don't return it as it will already have its owner recorded. + _ = VisitCustomDescrWithOwner(descrWithOwner); + return new(null); + } + if (context.customDescr() is {} descr) + { +#nullable disable // Disable nullability to work around lack of variance. + return VisitCustomDescr(descr); +#nullable restore + } + throw new UnreachableException(); + } + + GrammarResult ICILVisitor.VisitCustomDescrInMethodBody(CILParser.CustomDescrInMethodBodyContext context) => VisitCustomDescrInMethodBody(context); + public GrammarResult.Literal VisitCustomDescrInMethodBody(CILParser.CustomDescrInMethodBodyContext context) + { + if (context.customDescrWithOwner() is {} descrWithOwner) + { + // Visit the custom attribute descriptor to record it, + // but don't return it as it will already have its owner recorded. + _ = VisitCustomDescrWithOwner(descrWithOwner); + return new(null); + } + if (context.customDescr() is {} descr) + { +#nullable disable // Disable nullability to work around lack of variance. + return VisitCustomDescr(descr); +#nullable restore + } + throw new UnreachableException(); + } + + GrammarResult ICILVisitor.VisitCustomBlobArgs(CILParser.CustomBlobArgsContext context) => VisitCustomBlobArgs(context); + public GrammarResult.FormattedBlob VisitCustomBlobArgs(CILParser.CustomBlobArgsContext context) + { + BlobBuilder blob = new(); + foreach (var item in context.serInit()) + { + VisitSerInit(item).Value.WriteContentTo(blob); + } + return new(blob); + } + + GrammarResult ICILVisitor.VisitCustomBlobDescr(CILParser.CustomBlobDescrContext context) => VisitCustomBlobDescr(context); + public GrammarResult.FormattedBlob VisitCustomBlobDescr(CILParser.CustomBlobDescrContext context) + { + var blob = new BlobBuilder(); + // Custom attribute blob prolog is a 2-byte unsigned integer (ECMA-335 II.23.3) + blob.WriteUInt16(CustomAttributeBlobFormatVersion); + VisitCustomBlobArgs(context.customBlobArgs()).Value.WriteContentTo(blob); + VisitCustomBlobNVPairs(context.customBlobNVPairs()).Value.WriteContentTo(blob); + return new(blob); + } + + GrammarResult ICILVisitor.VisitCustomBlobNVPairs(CILParser.CustomBlobNVPairsContext context) => VisitCustomBlobNVPairs(context); + public GrammarResult.FormattedBlob VisitCustomBlobNVPairs(CILParser.CustomBlobNVPairsContext context) + { + var blob = new BlobBuilder(); + var fieldOrProps = context.fieldOrProp(); + var types = context.serializType(); + var names = context.dottedName(); + var values = context.serInit(); + + blob.WriteInt16((short)fieldOrProps.Length); + + for (int i = 0; i < fieldOrProps.Length; i++) + { + var fieldOrProp = fieldOrProps[i].GetText() == "field" ? CustomAttributeNamedArgumentKind.Field : CustomAttributeNamedArgumentKind.Property; + var type = VisitSerializType(types[i]).Value; + var name = VisitDottedName(names[i]).Value; + var value = VisitSerInit(values[i]).Value; + blob.WriteByte((byte)fieldOrProp); + type.WriteContentTo(blob); + blob.WriteSerializedString(name); + value.WriteContentTo(blob); + } + return new(blob); + } + + GrammarResult ICILVisitor.VisitCustomDescr(CILParser.CustomDescrContext context) => VisitCustomDescr(context); + public GrammarResult.Literal VisitCustomDescr(CILParser.CustomDescrContext context) + { + var ctor = VisitCustomType(context.customType()).Value; + BlobBuilder value; + if (context.customBlobDescr() is {} customBlobDescr) + { + value = VisitCustomBlobDescr(customBlobDescr).Value; + } + else if (context.bytes() is {} bytes) + { + value = new(); + value.WriteBytes(VisitBytes(bytes)); + } + else if (context.compQstring() is {} str) + { + value = new(); + value.WriteUTF8(VisitCompQstring(str).Value); + // COMPAT: We treat this string as a string-reprensentation of a blob, + // so we don't emit the null terminator. + } + else + { + value = new(); + value.WriteUInt16(CustomAttributeBlobFormatVersion); + value.WriteUInt16(0); + } + + var attribute = _entityRegistry.CreateCustomAttribute(ctor, value); + attribute.Location = Location.From(context.Start, _documents); + return new(attribute); + } + + GrammarResult ICILVisitor.VisitCustomDescrWithOwner(CILParser.CustomDescrWithOwnerContext context) => VisitCustomDescrWithOwner(context); + + public GrammarResult.Literal VisitCustomDescrWithOwner(CILParser.CustomDescrWithOwnerContext context) + { + var ctor = VisitCustomType(context.customType()).Value; + BlobBuilder value; + if (context.customBlobDescr() is {} customBlobDescr) + { + value = VisitCustomBlobDescr(customBlobDescr).Value; + } + else if (context.bytes() is {} bytes) + { + value = new(); + value.WriteBytes(VisitBytes(bytes)); + } + else if (context.compQstring() is {} str) + { + value = new(); + value.WriteUTF8(VisitCompQstring(str).Value); + // COMPAT: We treat this string as a string-reprensentation of a blob, + // so we don't emit the null terminator. + } + else + { + value = new(); + value.WriteUInt16(CustomAttributeBlobFormatVersion); + value.WriteUInt16(0); + } + + var attr = _entityRegistry.CreateCustomAttribute(ctor, value); + + attr.Location = Location.From(context.Start, _documents); + attr.Owner = VisitOwnerType(context.ownerType()).Value; + + return new(attr); + } + + GrammarResult ICILVisitor.VisitCustomType(CILParser.CustomTypeContext context) => VisitCustomType(context); + public GrammarResult.Literal VisitCustomType(CILParser.CustomTypeContext context) => VisitMethodRef(context.methodRef()); + + GrammarResult ICILVisitor.VisitF32seq(CILParser.F32seqContext context) => VisitF32seq(context); + public GrammarResult.FormattedBlob VisitF32seq(CILParser.F32seqContext context) + { + var builder = ImmutableArray.CreateBuilder(context.ChildCount); + + foreach (var item in context.children ?? []) + { + builder.Add((float)(item switch + { + CILParser.Int32Context int32 => VisitInt32(int32).Value, + CILParser.Float64Context float64 => VisitFloat64(float64).Value, + _ => throw new UnreachableException() + })); + } + return new(builder.ToImmutable().SerializeSequence()); + } + GrammarResult ICILVisitor.VisitF64seq(CILParser.F64seqContext context) => VisitF64seq(context); + public GrammarResult.FormattedBlob VisitF64seq(CILParser.F64seqContext context) + { + var builder = ImmutableArray.CreateBuilder(context.ChildCount); + + foreach (var item in context.children ?? []) + { + builder.Add((double)(item switch + { + CILParser.Int64Context int64 => VisitInt64(int64).Value, + CILParser.Float64Context float64 => VisitFloat64(float64).Value, + _ => throw new UnreachableException() + })); + } + return new(builder.ToImmutable().SerializeSequence()); + } + + private static object? ExtractConstantFromSerInit(BlobBuilder blob) + { + var bytes = blob.ToImmutableArray(); + if (bytes.Length == 0) + { + return null; + } + + var typeCode = (SerializationTypeCode)bytes[0]; + var valueBytes = bytes.AsSpan().Slice(1); + + return typeCode switch + { + SerializationTypeCode.Boolean => valueBytes.Length >= 1 && valueBytes[0] != 0, + SerializationTypeCode.Char => valueBytes.Length >= 2 ? BitConverter.ToChar(valueBytes) : '\0', + SerializationTypeCode.SByte => valueBytes.Length >= 1 ? (sbyte)valueBytes[0] : (sbyte)0, + SerializationTypeCode.Byte => valueBytes.Length >= 1 ? valueBytes[0] : (byte)0, + SerializationTypeCode.Int16 => valueBytes.Length >= 2 ? BitConverter.ToInt16(valueBytes) : (short)0, + SerializationTypeCode.UInt16 => valueBytes.Length >= 2 ? BitConverter.ToUInt16(valueBytes) : (ushort)0, + SerializationTypeCode.Int32 => valueBytes.Length >= 4 ? BitConverter.ToInt32(valueBytes) : 0, + SerializationTypeCode.UInt32 => valueBytes.Length >= 4 ? BitConverter.ToUInt32(valueBytes) : 0u, + SerializationTypeCode.Int64 => valueBytes.Length >= 8 ? BitConverter.ToInt64(valueBytes) : 0L, + SerializationTypeCode.UInt64 => valueBytes.Length >= 8 ? BitConverter.ToUInt64(valueBytes) : 0uL, + SerializationTypeCode.Single => valueBytes.Length >= 4 ? BitConverter.ToSingle(valueBytes) : 0f, + SerializationTypeCode.Double => valueBytes.Length >= 8 ? BitConverter.ToDouble(valueBytes) : 0d, + SerializationTypeCode.String => Encoding.Unicode.GetString(valueBytes), + // Type is encoded as a SerString (compressed length followed by UTF-8 type name) + SerializationTypeCode.Type => ExtractSerString(valueBytes), + // SZArray: element type followed by element count followed by elements + // Return the raw bytes for arrays since we can't easily represent them + SerializationTypeCode.SZArray => valueBytes.ToArray(), + // TaggedObject: type tag followed by value - return raw bytes + SerializationTypeCode.TaggedObject => valueBytes.ToArray(), + // Enum: type name (SerString) followed by underlying value - return raw bytes + SerializationTypeCode.Enum => valueBytes.ToArray(), + // For unknown/future type codes, return the raw bytes to preserve the data + _ => bytes.AsSpan().ToArray() + }; + } + + /// + /// Extracts a SerString (compressed length + UTF-8 string) from the given bytes. + /// Returns null if the first byte is 0xFF (null string marker). + /// + private static string? ExtractSerString(ReadOnlySpan bytes) + { + if (bytes.Length == 0) + { + return null; + } + // 0xFF indicates null string + if (bytes[0] == 0xFF) + { + return null; + } + // Decode compressed length + int length; + int bytesRead; + if ((bytes[0] & 0x80) == 0) + { + // 1-byte length + length = bytes[0]; + bytesRead = 1; + } + else if ((bytes[0] & 0xC0) == 0x80) + { + // 2-byte length + if (bytes.Length < 2) return null; + length = ((bytes[0] & 0x3F) << 8) | bytes[1]; + bytesRead = 2; + } + else + { + // 4-byte length + if (bytes.Length < 4) return null; + length = ((bytes[0] & 0x1F) << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]; + bytesRead = 4; + } + if (bytes.Length < bytesRead + length) + { + return null; + } + return Encoding.UTF8.GetString(bytes.Slice(bytesRead, length)); + } + + GrammarResult ICILVisitor.VisitFieldSerInit(CILParser.FieldSerInitContext context) => VisitFieldSerInit(context); + public GrammarResult.FormattedBlob VisitFieldSerInit(CILParser.FieldSerInitContext context) + { + // The max length for the majority of the blobs is 9 bytes. 1 for the type of blob, 8 for the max 64-bit value. + // Byte arrays can be larger, so we handle that case separately. + const int CommonMaxBlobLength = 9; + BlobBuilder builder; + var bytesNode = context.bytes(); + if (bytesNode is not null) + { + ImmutableArray bytesResult = VisitBytes(bytesNode); + // Our blob length is the number of bytes in the byte array + the code for the byte array. + builder = new BlobBuilder(bytesResult.Length + 1); + builder.WriteByte((byte)SerializationTypeCode.String); + builder.WriteBytes(bytesResult); + return new(builder); + } + builder = new BlobBuilder(CommonMaxBlobLength); + + int tokenType = ((ITerminalNode)context.GetChild(0)).Symbol.Type; + + builder.WriteByte((byte)GetTypeCodeForToken(tokenType)); + + switch (tokenType) + { + case CILParser.BOOL: + builder.WriteBoolean(VisitTruefalse(context.truefalse()).Value); + break; + case CILParser.INT8: + case CILParser.UINT8: + builder.WriteByte((byte)VisitInt32(context.int32()).Value); + break; + case CILParser.CHAR: + case CILParser.INT16: + case CILParser.UINT16: + builder.WriteInt16((short)VisitInt32(context.int32()).Value); + break; + case CILParser.INT32_: + case CILParser.UINT32: + builder.WriteInt32(VisitInt32(context.int32()).Value); + break; + case CILParser.INT64_: + case CILParser.UINT64: + builder.WriteInt64(VisitInt64(context.int64()).Value); + break; + case CILParser.FLOAT32: + { + if (context.float64() is CILParser.Float64Context float64) + { + string text = float64.GetText(); + if (!text.Contains('.') && + text.IndexOf('e') < 0 && + text.IndexOf('E') < 0 && + ParseIntegerValue(text.AsSpan(), out long rawValue)) + { + builder.WriteSingle(BitConverter.Int32BitsToSingle((int)rawValue)); + } + else + { + builder.WriteSingle((float)VisitFloat64(float64).Value); + } + } + if (context.int32() is CILParser.Int32Context int32) + { + int value = VisitInt32(int32).Value; + builder.WriteSingle(BitConverter.Int32BitsToSingle(value)); + } + break; + } + case CILParser.FLOAT64_: + { + if (context.float64() is CILParser.Float64Context float64) + { + string text = float64.GetText(); + if (!text.Contains('.') && + text.IndexOf('e') < 0 && + text.IndexOf('E') < 0 && + ParseIntegerValue(text.AsSpan(), out long rawValue)) + { + builder.WriteDouble(BitConverter.Int64BitsToDouble(rawValue)); + } + else + { + builder.WriteDouble(VisitFloat64(float64).Value); + } + } + if (context.int64() is CILParser.Int64Context int64) + { + long value = VisitInt64(int64).Value; + builder.WriteDouble(BitConverter.Int64BitsToDouble(value)); + } + break; + } + } + + return new(builder); + } + GrammarResult ICILVisitor.VisitI16seq(CILParser.I16seqContext context) => VisitI16seq(context); + public GrammarResult.FormattedBlob VisitI16seq(CILParser.I16seqContext context) + { + var values = context.int32(); + var builder = ImmutableArray.CreateBuilder(values.Length); + foreach (var value in values) + { + builder.Add((short)VisitInt32(value).Value); + } + return new(builder.MoveToImmutable().SerializeSequence()); + } + GrammarResult ICILVisitor.VisitI32seq(CILParser.I32seqContext context) => VisitI32seq(context); + public GrammarResult.FormattedBlob VisitI32seq(CILParser.I32seqContext context) + { + var values = context.int32(); + var builder = ImmutableArray.CreateBuilder(values.Length); + foreach (var value in values) + { + builder.Add(VisitInt32(value).Value); + } + return new(builder.MoveToImmutable().SerializeSequence()); + } + + GrammarResult ICILVisitor.VisitI8seq(CILParser.I8seqContext context) => VisitI8seq(context); + public GrammarResult.FormattedBlob VisitI8seq(CILParser.I8seqContext context) + { + var values = context.int32(); + var builder = ImmutableArray.CreateBuilder(values.Length); + foreach (var value in values) + { + builder.Add((byte)VisitInt32(value).Value); + } + return new(builder.MoveToImmutable().SerializeSequence()); + } + + GrammarResult ICILVisitor.VisitI64seq(CILParser.I64seqContext context) => VisitI64seq(context); + public GrammarResult.FormattedBlob VisitI64seq(CILParser.I64seqContext context) + { + var values = context.int64(); + var builder = ImmutableArray.CreateBuilder(values.Length); + foreach (var value in values) + { + builder.Add(VisitInt64(value).Value); + } + return new(builder.MoveToImmutable().SerializeSequence()); + } + + GrammarResult ICILVisitor.VisitNameValPair(CILParser.NameValPairContext context) => VisitNameValPair(context); + public GrammarResult.Literal> VisitNameValPair(CILParser.NameValPairContext context) + { + return new(new(VisitCompQstring(context.compQstring()).Value, VisitCaValue(context.caValue()).Value)); + } + + GrammarResult ICILVisitor.VisitNameValPairs(CILParser.NameValPairsContext context) => VisitNameValPairs(context); + public GrammarResult.Sequence> VisitNameValPairs(CILParser.NameValPairsContext context) => new(context.nameValPair().Select(pair => VisitNameValPair(pair).Value).ToImmutableArray()); + + GrammarResult ICILVisitor.VisitObjSeq(CILParser.ObjSeqContext context) => VisitObjSeq(context); + public GrammarResult.FormattedBlob VisitObjSeq(CILParser.ObjSeqContext context) + { + BlobBuilder objSeqBlob = new(); + foreach (var item in context.serInit()) + { + // Each element in object[] is encoded as FieldOrPropType + value, + // where FieldOrPropType is the concrete type (bool, int32, string, etc.), + // NOT TaggedObject (0x51). The object(...) wrapper is used to explicitly + // box a value but does not change the element's concrete type in the encoding. + // Unwrap any object(...) wrappers to get the actual typed inner element. + CILParser.SerInitContext actualItem = item; + while (actualItem.serInit() is { } inner) + { + actualItem = inner; + } + WriteCustomAttributeFieldOrPropType(objSeqBlob, actualItem); + objSeqBlob.LinkSuffix(VisitSerInit(actualItem).Value); + } + return new(objSeqBlob); + } + + GrammarResult ICILVisitor.VisitOwnerType(CILParser.OwnerTypeContext context) => VisitOwnerType(context); + public GrammarResult.Literal VisitOwnerType(CILParser.OwnerTypeContext context) + { + if (context.memberRef() is CILParser.MemberRefContext memberRef) + { + return VisitMemberRef(memberRef); + } + if (context.typeSpec() is CILParser.TypeSpecContext typeSpec) + { + return new(VisitTypeSpec(typeSpec).Value); + } + throw new UnreachableException(); + } + GrammarResult ICILVisitor.VisitSerializType(CILParser.SerializTypeContext context) => VisitSerializType(context); + public GrammarResult.FormattedBlob VisitSerializType(CILParser.SerializTypeContext context) + { + var blob = new BlobBuilder(); + if (context.ARRAY_TYPE_NO_BOUNDS() is not null) + { + blob.WriteByte((byte)SerializationTypeCode.SZArray); + } + VisitSerializTypeElement(context.serializTypeElement()).Value.WriteContentTo(blob); + return new(blob); + } + + GrammarResult ICILVisitor.VisitSerializTypeElement(CILParser.SerializTypeElementContext context) => VisitSerializTypeElement(context); + public GrammarResult.FormattedBlob VisitSerializTypeElement(CILParser.SerializTypeElementContext context) + { + if (context.simpleType() is CILParser.SimpleTypeContext simpleType) + { + BlobBuilder blob = new(1); + blob.WriteByte((byte)VisitSimpleType(simpleType).Value); + return new(blob); + } + if (context.dottedName() is CILParser.DottedNameContext dottedName) + { + // Serialization type typedefs are not yet fully supported + string alias = VisitDottedName(dottedName).Value; + ReportError(DiagnosticIds.TypedefNotFound, string.Format(DiagnosticMessageTemplates.TypedefNotFound, alias), context); + return new(new BlobBuilder(1)); + } + if (context.TYPE() is not null) + { + BlobBuilder blob = new BlobBuilder(1); + blob.WriteByte((byte)SerializationTypeCode.Type); + return new(blob); + } + if (context.OBJECT() is not null) + { + BlobBuilder blob = new BlobBuilder(1); + blob.WriteByte((byte)SerializationTypeCode.TaggedObject); + return new(blob); + } + if (context.ENUM() is not null) + { + BlobBuilder blob = new BlobBuilder(); + blob.WriteByte((byte)SerializationTypeCode.Enum); + if (context.SQSTRING() is ITerminalNode sqString) + { + blob.WriteSerializedString(StringHelpers.ParseQuotedString(sqString.GetText())); + } + else + { + Debug.Assert(context.className() is not null); + blob.WriteSerializedString((VisitClassName(context.className()).Value as EntityRegistry.IHasReflectionNotation)?.ReflectionNotation ?? ""); + } + return new(blob); + } + throw new UnreachableException(); + } + + GrammarResult ICILVisitor.VisitSerInit(CILParser.SerInitContext context) => VisitSerInit(context); + public GrammarResult.FormattedBlob VisitSerInit(CILParser.SerInitContext context) + { + if (context.fieldSerInit() is CILParser.FieldSerInitContext fieldSerInit) + { + if (fieldSerInit.bytes() is not null) + { + ReportError( + DiagnosticIds.InvalidMetadataToken, + "bytearray is not a valid structured custom attribute value", + context); + var invalidValue = new BlobBuilder(); + invalidValue.WriteSerializedString(null); + return new(invalidValue); + } + + ImmutableArray encodedValue = VisitFieldSerInit(fieldSerInit).Value.ToImmutableArray(); + var value = new BlobBuilder(Math.Max(0, encodedValue.Length - 1)); + if (encodedValue.Length > 1) + { + value.WriteBytes(encodedValue.AsSpan().Slice(1).ToArray()); + } + return new(value); + } + + if (context.serInit() is CILParser.SerInitContext serInit) + { + Debug.Assert(context.OBJECT() is not null); + BlobBuilder taggedObjectBlob = new(); + WriteCustomAttributeFieldOrPropType(taggedObjectBlob, serInit); + taggedObjectBlob.LinkSuffix(VisitSerInit(serInit).Value); + return new(taggedObjectBlob); + } + + if (context.int32() is not CILParser.Int32Context arrLength) + { + BlobBuilder blob = new(); + if (context.className() is CILParser.ClassNameContext className) + { + blob.WriteSerializedString(VisitClassName(className).Value is EntityRegistry.IHasReflectionNotation reflection ? reflection.ReflectionNotation : string.Empty); + } + else + { + blob.WriteSerializedString( + context.SQSTRING() is { } stringNode + ? StringHelpers.ParseQuotedString(stringNode.Symbol.Text) + : null); + } + return new(blob); + } + + BlobBuilder arrayHeader = new(sizeof(int)); + arrayHeader.WriteInt32(VisitInt32(arrLength).Value); + var sequenceResult = (GrammarResult.FormattedBlob)Visit(context.GetRuleContext(1)); + arrayHeader.LinkSuffix(sequenceResult.Value); + return new(arrayHeader); + } + + private static void WriteCustomAttributeFieldOrPropType( + BlobBuilder builder, + CILParser.SerInitContext context) + { + int tokenType = context.fieldSerInit() is { } fieldSerInit + ? ((ITerminalNode)fieldSerInit.GetChild(0)).Symbol.Type + : ((ITerminalNode)context.GetChild(0)).Symbol.Type; + if (context.fieldSerInit()?.bytes() is not null) + { + builder.WriteByte((byte)SerializationTypeCode.String); + return; + } + if (context.int32() is not null) + { + builder.WriteByte((byte)SerializationTypeCode.SZArray); + } + + builder.WriteByte((byte)GetTypeCodeForToken(tokenType)); + } + + private static SerializationTypeCode GetTypeCodeForToken(int tokenType) + { + return tokenType switch + { + CILParser.INT8 => SerializationTypeCode.SByte, + CILParser.UINT8 => SerializationTypeCode.Byte, + CILParser.INT16 => SerializationTypeCode.Int16, + CILParser.UINT16 => SerializationTypeCode.UInt16, + CILParser.INT32_ => SerializationTypeCode.Int32, + CILParser.UINT32 => SerializationTypeCode.UInt32, + CILParser.INT64_ => SerializationTypeCode.Int64, + CILParser.UINT64 => SerializationTypeCode.UInt64, + CILParser.FLOAT32 => SerializationTypeCode.Single, + CILParser.FLOAT64_ => SerializationTypeCode.Double, + CILParser.CHAR => SerializationTypeCode.Char, + CILParser.BOOL => SerializationTypeCode.Boolean, + CILParser.STRING => SerializationTypeCode.String, + CILParser.TYPE => SerializationTypeCode.Type, + CILParser.OBJECT => SerializationTypeCode.TaggedObject, + _ => throw new UnreachableException() + }; + } + + GrammarResult ICILVisitor.VisitSqstringSeq(CILParser.SqstringSeqContext context) => VisitSqstringSeq(context); + + public static GrammarResult.FormattedBlob VisitSqstringSeq(CILParser.SqstringSeqContext context) + { + var strings = ImmutableArray.CreateBuilder(context.ChildCount); + foreach (var child in context.children ?? []) + { + string? str = null; + + if (child is ITerminalNode { Symbol: { Type: CILParser.SQSTRING, Text: string stringValue } }) + { + str = StringHelpers.ParseQuotedString(stringValue); + } + + strings.Add(str); + } + return new(strings.MoveToImmutable().SerializeSequence()); + } + + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Data.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Data.cs new file mode 100644 index 00000000000000..16091973c4bc2b --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Data.cs @@ -0,0 +1,156 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Buffers.Binary; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using System.Reflection.PortableExecutable; +using System.Runtime.InteropServices; +using System.Security.Cryptography; +using System.Text; +using Antlr4.Runtime; +using Antlr4.Runtime.Misc; +using Antlr4.Runtime.Tree; + +namespace ILAssembler +{ +#pragma warning disable CA1822 // Mark members as static + internal sealed partial class GrammarActions : ICILVisitor + { + GrammarResult ICILVisitor.VisitAtOpt(CILParser.AtOptContext context) => VisitAtOpt(context); + public GrammarResult.Literal VisitAtOpt(CILParser.AtOptContext context) + => context.id() is { } id ? new(VisitId(id).Value) + : context.int32() is { } i ? new(VisitInt32(i).Value.ToString()) + : new(null); + + public GrammarResult VisitDataDecl(CILParser.DataDeclContext context) + { + _ = VisitDdHead(context.ddHead()); + _ = VisitDdBody(context.ddBody()); + return GrammarResult.SentinelValue.Result; + } + public GrammarResult VisitDdBody(CILParser.DdBodyContext context) + { + if (context.ddItemList() is CILParser.DdItemListContext ddItemList) + { + _ = VisitDdItemList(ddItemList); + } + else + { + foreach (var item in context.ddItem()) + { + _ = VisitDdItem(item); + } + } + return GrammarResult.SentinelValue.Result; + } + public GrammarResult VisitDdHead(CILParser.DdHeadContext context) + { + if (context.id() is CILParser.IdContext id) + { + string name = VisitId(id).Value; + if (!_mappedFieldDataNames.ContainsKey(name)) + { + _mappedFieldDataNames.Add(name, _mappedFieldData.Count); + } + } + return GrammarResult.SentinelValue.Result; + } + public GrammarResult VisitDdItem(CILParser.DdItemContext context) + { + if (context.compQstring() is CILParser.CompQstringContext str) + { + var value = VisitCompQstring(str).Value; + _mappedFieldData.WriteUTF16(value); + return GrammarResult.SentinelValue.Result; + } + else if (context.id() is CILParser.IdContext id) + { + // Reference to another data label - this will be patched with the target's RVA + // during PE serialization by VTableExportPEBuilder.ApplyDataLabelFixups() + string name = VisitId(id).Value; + if (!_mappedFieldDataReferenceFixups.TryGetValue(name, out var fixups)) + { + _mappedFieldDataReferenceFixups[name] = fixups = new(); + } + + // Reserve 4 bytes for the RVA that will be patched later + fixups.Add(_mappedFieldData.ReserveBytes(4)); + return GrammarResult.SentinelValue.Result; + } + else if (context.bytes() is CILParser.BytesContext bytes) + { + _mappedFieldData.WriteBytes(VisitBytes(bytes)); + return GrammarResult.SentinelValue.Result; + } + + int itemCount = VisitDdItemCount(context.ddItemCount()).Value; + + if (context.INT8() is not null) + { + _mappedFieldData.WriteBytes(context.int32() is CILParser.Int32Context int32 ? (byte)VisitInt32(int32).Value : (byte)0, itemCount); + } + else if (context.INT16() is not null) + { + for (int i = 0; i < itemCount; i++) + { + _mappedFieldData.WriteInt16(context.int32() is CILParser.Int32Context int32 ? (short)VisitInt32(int32).Value : (short)0); + } + } + else if (context.INT32_() is not null) + { + for (int i = 0; i < itemCount; i++) + { + _mappedFieldData.WriteInt32(context.int32() is CILParser.Int32Context int32 ? VisitInt32(int32).Value : 0); + } + } + else if (context.INT64_() is not null) + { + for (int i = 0; i < itemCount; i++) + { + _mappedFieldData.WriteInt64(context.int64() is CILParser.Int64Context int64 ? VisitInt64(int64).Value : 0); + } + } + else if (context.FLOAT32() is not null) + { + for (int i = 0; i < itemCount; i++) + { + _mappedFieldData.WriteSingle(context.float64() is CILParser.Float64Context float64 ? (float)VisitFloat64(float64).Value : 0); + } + } + else if (context.FLOAT64_() is not null) + { + for (int i = 0; i < itemCount; i++) + { + _mappedFieldData.WriteDouble(context.float64() is CILParser.Float64Context float64 ? VisitFloat64(float64).Value : 0); + } + } + return GrammarResult.SentinelValue.Result; + } + GrammarResult ICILVisitor.VisitDdItemCount(CILParser.DdItemCountContext context) => VisitDdItemCount(context); + public GrammarResult.Literal VisitDdItemCount(CILParser.DdItemCountContext context) => new(context.int32() is CILParser.Int32Context ? VisitInt32(context.int32()).Value : 1); + public GrammarResult VisitDdItemList(CILParser.DdItemListContext context) + { + foreach (var item in context.ddItem()) + { + VisitDdItem(item); + } + return GrammarResult.SentinelValue.Result; + } + public GrammarResult VisitTls(CILParser.TlsContext context) + { + // TODO-SRM: System.Reflection.Metadata doesn't provide APIs to point a data declaration at a TLS slot or into the IL stream. + // We have tests for the TLS case (CoreCLR only supports it on Win-x86), but not for the IL case. + return GrammarResult.SentinelValue.Result; + } + + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Debug.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Debug.cs new file mode 100644 index 00000000000000..6079a0816c9a27 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Debug.cs @@ -0,0 +1,176 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Buffers.Binary; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using System.Reflection.PortableExecutable; +using System.Runtime.InteropServices; +using System.Security.Cryptography; +using System.Text; +using Antlr4.Runtime; +using Antlr4.Runtime.Misc; +using Antlr4.Runtime.Tree; + +namespace ILAssembler +{ +#pragma warning disable CA1822 // Mark members as static + internal sealed partial class GrammarActions : ICILVisitor + { + public GrammarResult VisitCompControl(CILParser.CompControlContext context) + { + // All compilation control directives that need special handling will be handled + // directly in the token stream before parsing. + // Any that reach here can be ignored. + return GrammarResult.SentinelValue.Result; + } + + // esHead is '.line' or '#line' - this is just the keyword, actual parsing is in VisitExtSourceSpec. + public GrammarResult VisitEsHead(CILParser.EsHeadContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + + public GrammarResult VisitExtSourceSpec(CILParser.ExtSourceSpecContext context) + { + // Parse .line directive to extract source location info + // Grammar: esHead int32 (',' int32)? (':' int32 (',' int32)?)? (SQSTRING | QSTRING)? + var int32s = context.int32(); + var sqstring = context.SQSTRING(); + var qstring = context.QSTRING(); + + // Extract line/column info based on number of int32s + int startLine = 0, endLine = 0, startColumn = 0, endColumn = 0; + + if (int32s.Length >= 1) + { + startLine = VisitInt32(int32s[0]).Value; + endLine = startLine; + } + if (int32s.Length >= 2) + { + // Could be endLine or startColumn depending on separator + string contextText = context.GetText(); + if (contextText.Contains(',') && contextText.IndexOf(',') < contextText.IndexOf(':')) + { + // Format: startLine,endLine:... + endLine = VisitInt32(int32s[1]).Value; + } + else + { + // Format: line:column... + startColumn = VisitInt32(int32s[1]).Value; + endColumn = startColumn; + } + } + if (int32s.Length >= 3) + { + startColumn = VisitInt32(int32s[2]).Value; + endColumn = startColumn; + } + if (int32s.Length >= 4) + { + endColumn = VisitInt32(int32s[3]).Value; + } + + // Extract filename if present + string? filePath = null; + if (sqstring is not null) + { + filePath = StringHelpers.ParseQuotedString(sqstring.GetText()); + } + else if (qstring is not null) + { + filePath = StringHelpers.ParseQuotedString(qstring.GetText()); + } + + // Update current document path if specified + if (filePath is not null) + { + _currentDocumentPath = filePath; + } + + // If we're in a method, record the sequence point + if (_currentMethod is not null && _currentDocumentPath is not null) + { + int ilOffset = _currentMethod.Definition.MethodBody.Offset; + _currentMethod.Definition.DebugInfo.DocumentPath ??= _currentDocumentPath; + + // 0xFEEFEE indicates a hidden sequence point + if (startLine == 0xFEEFEE) + { + AddSequencePoint(EntityRegistry.SequencePoint.Hidden(ilOffset)); + } + else + { + if (endLine == startLine && endColumn == startColumn) + { + endColumn++; + } + + AddSequencePoint( + new EntityRegistry.SequencePoint( + ilOffset, + startLine, + startColumn, + endLine, + endColumn)); + } + + void AddSequencePoint(EntityRegistry.SequencePoint sequencePoint) + { + List sequencePoints = + _currentMethod.Definition.DebugInfo.SequencePoints; + if (sequencePoints.Count > 0 && sequencePoints[^1].ILOffset == ilOffset) + { + sequencePoints[^1] = sequencePoint; + } + else + { + sequencePoints.Add(sequencePoint); + } + } + } + + return GrammarResult.SentinelValue.Result; + } + + public GrammarResult VisitLanguageDecl(CILParser.LanguageDeclContext context) + { + // .language languageString (',' languageString (',' languageString)?)? + // First GUID: language (e.g., C#, VB, IL) + // Second GUID: vendor (optional) + // Third GUID: document type (optional) + var strings = context.languageString(); + if (strings.Length >= 1 && Guid.TryParse(VisitLanguageString(strings[0]).Value, out var languageGuid)) + { + _currentLanguageGuid = languageGuid; + } + if (strings.Length >= 2 && Guid.TryParse(VisitLanguageString(strings[1]).Value, out var vendorGuid)) + { + _currentLanguageVendorGuid = vendorGuid; + } + if (strings.Length >= 3 && Guid.TryParse(VisitLanguageString(strings[2]).Value, out var docTypeGuid)) + { + _currentDocumentTypeGuid = docTypeGuid; + } + return GrammarResult.SentinelValue.Result; + } + + GrammarResult ICILVisitor.VisitLanguageString(CILParser.LanguageStringContext context) => VisitLanguageString(context); + public GrammarResult.String VisitLanguageString(CILParser.LanguageStringContext context) + { + if (context.SQSTRING() is not null) + { + return new(StringHelpers.ParseQuotedString(context.SQSTRING().GetText())); + } + return new(StringHelpers.ParseQuotedString(context.QSTRING().GetText())); + } + + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.cs new file mode 100644 index 00000000000000..fbfc3de421517d --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.cs @@ -0,0 +1,228 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Buffers.Binary; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using System.Reflection.PortableExecutable; +using System.Runtime.InteropServices; +using System.Security.Cryptography; +using System.Text; +using Antlr4.Runtime; +using Antlr4.Runtime.Misc; +using Antlr4.Runtime.Tree; + +namespace ILAssembler; + +internal sealed partial class GrammarActions +{ + internal void OnDeclaration(CILParser.DeclContext context) + { + if (context.classHead() is not null || + context.nameSpaceHead() is not null || + context.methodHead() is not null) + { + return; + } + + VisitDecl(context); + } + + public GrammarResult VisitDecl(CILParser.DeclContext context) + { + bool isTrailingCustomAttribute = context.customAttrDecl() is not null; + if (context.fieldDecl() is null && !isTrailingCustomAttribute) + { + _lastFieldDefinition = null; + } + + if (context.nameSpaceHead() is not null || + context.classHead() is not null || + context.methodHead() is not null) + { + throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + } + + if (context.fieldDecl() is { } fieldDecl) + { + _ = VisitFieldDecl(fieldDecl); + return GrammarResult.SentinelValue.Result; + } + if (context.dataDecl() is { } dataDecl) + { + _ = VisitDataDecl(dataDecl); + return GrammarResult.SentinelValue.Result; + } + if (context.vtableDecl() is { } vtable) + { + _ = VisitVtableDecl(vtable); + return GrammarResult.SentinelValue.Result; + } + if (context.vtfixupDecl() is { } vtFixup) + { + _ = VisitVtfixupDecl(vtFixup); + return GrammarResult.SentinelValue.Result; + } + if (context.extSourceSpec() is { } extSourceSpec) + { + _ = VisitExtSourceSpec(extSourceSpec); + return GrammarResult.SentinelValue.Result; + } + if (context.fileDecl() is { } fileDecl) + { + _ = VisitFileDecl(fileDecl); + return GrammarResult.SentinelValue.Result; + } + if (context.assemblyBlock() is { } assemblyBlock) + { + _ = VisitAssemblyBlock(assemblyBlock); + return GrammarResult.SentinelValue.Result; + } + if (context.assemblyRefHead() is { } assemblyRef) + { + var asmRef = VisitAssemblyRefHead(assemblyRef).Value; + _currentAssemblyOrRef = asmRef; + foreach (var decl in context.assemblyRefDecls().assemblyRefDecl()) + { + _ = VisitAssemblyRefDecl(decl); + } + _currentAssemblyOrRef = null; + } + if (context.exptypeHead() is { } exptypeHead) + { + var (attrs, dottedName) = VisitExptypeHead(exptypeHead).Value; + (string typeNamespace, string name) = NameHelpers.SplitDottedNameToNamespaceAndName(dottedName); + var (impl, typeDefId, customAttrs) = VisitExptypeDecls(context.exptypeDecls()).Value; + if (impl is null) + { + // COMPAT: Like native ilasm, warn and skip the exported type when implementation is not specified + ReportWarning(DiagnosticIds.MissingExportedTypeImplementation, + string.Format(DiagnosticMessageTemplates.MissingExportedTypeImplementation, dottedName), + exptypeHead); + return GrammarResult.SentinelValue.Result; + } + var exp = _entityRegistry.GetOrCreateExportedType(impl, typeNamespace, name, exp => + { + exp.Attributes = attrs; + exp.TypeDefinitionId = typeDefId; + }); + foreach (var attr in customAttrs) + { + attr.Owner = exp; + } + return GrammarResult.SentinelValue.Result; + } + if (context.manifestResHead() is { } manifestResHead) + { + var (name, alias, flags) = VisitManifestResHead(manifestResHead).Value; + var (implementation, offset, attrs) = VisitManifestResDecls(context.manifestResDecls()).Value; + if (implementation is null) + { + offset = (uint)_manifestResources.Count; + byte[] resourceData = _resourceLocator(alias); + if (resourceData is null) + { + ReportError(DiagnosticIds.FileNotFound, + string.Format(DiagnosticMessageTemplates.FileNotFound, alias), + context); + } + else + { + // ECMA-335: Each resource is prefixed with a 4-byte length + _manifestResources.WriteInt32(resourceData.Length); + _manifestResources.WriteBytes(resourceData); + } + } + var res = _entityRegistry.CreateManifestResource(name, offset); + res.Attributes = flags; + res.Implementation = implementation; + foreach (var attr in attrs) + { + attr.Owner = res; + } + return GrammarResult.SentinelValue.Result; + } + if (context.moduleHead() is { } moduleHead) + { + if (moduleHead.dottedName() is null) + { + _entityRegistry.Module.Name = null; + } + else if (moduleHead.ChildCount == 2) + { + _entityRegistry.Module.Name = VisitDottedName(moduleHead.dottedName()).Value; + } + else + { + var name = VisitDottedName(moduleHead.dottedName()).Value; + _entityRegistry.GetOrCreateModuleReference(name, _ => { }); + } + return GrammarResult.SentinelValue.Result; + } + if (context.subsystem() is { } subsystem) + { + _subsystem = (Subsystem)VisitSubsystem(subsystem).Value; + } + if (context.corflags() is { } corflags) + { + _corflags = (CorFlags)VisitCorflags(corflags).Value; + } + if (context.alignment() is { } alignment) + { + _alignment = VisitAlignment(alignment).Value; + } + if (context.imagebase() is { } imagebase) + { + _imageBase = VisitImagebase(imagebase).Value; + } + if (context.stackreserve() is { } stackreserve) + { + _stackReserve = VisitStackreserve(stackreserve).Value; + } + if (context.languageDecl() is { } languageDecl) + { + VisitLanguageDecl(languageDecl); + } + if (context.customAttrDecl() is { } topLevelCustomAttr) + { + if (VisitCustomAttrDecl(topLevelCustomAttr).Value is { } customAttr) + { + customAttr.Owner = (EntityRegistry.EntityBase?)_lastFieldDefinition ?? _entityRegistry.Module; + } + } + if (context.secDecl() is { } topSecDecl) + { + var declarativeSecurity = VisitSecDecl(topSecDecl).Value; + declarativeSecurity?.Parent = _entityRegistry.Assembly; + } + if (context.typedefDecl() is { } typedefDecl) + { + VisitTypedefDecl(typedefDecl); + } + if (context.typelist() is { } typelist) + { + foreach (var name in typelist.className()) + { + _ = VisitClassName(name); + } + } + if (context.mscorlib() is { } mscorlib) + { + VisitMscorlib(mscorlib); + } + return GrammarResult.SentinelValue.Result; + } + +#pragma warning disable CA1822 // Mark members as static + public GrammarResult VisitDecls(CILParser.DeclsContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + +#pragma warning restore CA1822 // Mark members as static +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs new file mode 100644 index 00000000000000..daa9ab6d014daa --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs @@ -0,0 +1,474 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Buffers.Binary; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using System.Reflection.PortableExecutable; +using System.Runtime.InteropServices; +using System.Security.Cryptography; +using System.Text; +using Antlr4.Runtime; +using Antlr4.Runtime.Misc; +using Antlr4.Runtime.Tree; + +namespace ILAssembler; + +internal sealed partial class GrammarActions +{ + private bool TryProcessInstruction(CILParser.MethodDeclContext context) + { + if (context.instr() is null) + { + return false; + } + + VisitMethodDecl(context); + return true; + } + +#pragma warning disable CA1822 // Mark members as static + public GrammarResult VisitInstr(CILParser.InstrContext context) + { + var instrContext = context.GetRuleContext(0); + ILOpCode opcode = ((GrammarResult.Literal)instrContext.Accept(this)).Value; + if (opcode == ILOpCode.Localloc) + { + _currentMethod!.Definition.HasDynamicStackAllocation = true; + } + switch (instrContext.RuleIndex) + { + case CILParser.RULE_instr_brtarget: + { + ParserRuleContext argument = context.GetRuleContext(1); + if (argument is CILParser.IdContext id) + { + string label = VisitId(id).Value; + if (!_currentMethod!.Labels.TryGetValue(label, out var handle)) + { + handle = _currentMethod.Definition.MethodBody.DefineLabel(); + _currentMethod.Labels[label] = handle; + // Track undefined label references for later validation + if (!_currentMethod.UndefinedLabelReferences.ContainsKey(label)) + { + _currentMethod.UndefinedLabelReferences[label] = context; + } + } + _currentMethod.Definition.MethodBody.Branch(opcode, handle); + } + if (argument is CILParser.Int32Context int32) + { + int offset = VisitInt32(int32).Value; + LabelHandle label = _currentMethod!.Definition.MethodBody.DefineLabel(); + _currentMethod.Definition.MethodBody.Branch(opcode, label); + _currentMethod.Definition.MethodBody.MarkLabel(label, _currentMethod.Definition.MethodBody.Offset + offset); + } + } + break; + case CILParser.RULE_instr_field: + { + _currentMethod!.Definition.MethodBody.OpCode(opcode); + if (context.mdtoken() is CILParser.MdtokenContext mdtoken) + { + var entity = VisitMdtoken(mdtoken).Value; + if (entity is EntityRegistry.TypeReferenceEntity mdTokenTypeRef) + { + mdTokenTypeRef.RecordBlobToWriteResolvedToken(_currentMethod.Definition.MethodBody.CodeBuilder.ReserveBytes(4)); + } + else + { + _currentMethod.Definition.MethodBody.Token(entity.Handle); + } + } + else + { + var fieldRef = VisitFieldRef(context.fieldRef()).Value; + if (fieldRef is EntityRegistry.MemberReferenceEntity memberRef) + { + memberRef.RecordBlobToWriteResolvedHandle(_currentMethod.Definition.MethodBody.CodeBuilder.ReserveBytes(4)); + } + else + { + _currentMethod.Definition.MethodBody.Token(fieldRef.Handle); + } + } + } + break; + case CILParser.RULE_instr_i: + { + int arg = VisitInt32(context.int32()).Value; + if (opcode == ILOpCode.Ldc_i4 || opcode == ILOpCode.Ldc_i4_s) + { + _currentMethod!.Definition.MethodBody.LoadConstantI4(arg); + } + else + { + _currentMethod!.Definition.MethodBody.OpCode(opcode); + _currentMethod.Definition.MethodBody.CodeBuilder.WriteByte((byte)arg); + } + } + break; + case CILParser.RULE_instr_i8: + Debug.Assert(opcode == ILOpCode.Ldc_i8); + _currentMethod!.Definition.MethodBody.LoadConstantI8(VisitInt64(context.int64()).Value); + break; + case CILParser.RULE_instr_method: + { + if (opcode == ILOpCode.Callvirt || opcode == ILOpCode.Newobj) + { + _expectInstance = true; + } + _currentMethod!.Definition.MethodBody.OpCode(opcode); + var methodRef = VisitMethodRef(context.methodRef()).Value; + if (methodRef is EntityRegistry.MemberReferenceEntity memberRef) + { + memberRef.RecordBlobToWriteResolvedHandle(_currentMethod.Definition.MethodBody.CodeBuilder.ReserveBytes(4)); + } + else + { + _currentMethod.Definition.MethodBody.Token(methodRef.Handle); + } + // Reset the instance flag for the next instruction. + if (opcode == ILOpCode.Callvirt || opcode == ILOpCode.Newobj) + { + _expectInstance = false; + } + } + break; + case CILParser.RULE_instr_none: + _currentMethod!.Definition.MethodBody.OpCode(opcode); + break; + case CILParser.RULE_instr_r: + { + double value; + ParserRuleContext argument = context.GetRuleContext(1); + if (argument is CILParser.Float64Context float64) + { + value = VisitFloat64(float64).Value; + } + else if (argument is CILParser.Int64Context int64) + { + long intValue = VisitInt64(int64).Value; + value = intValue; + } + else if (argument is CILParser.BytesContext bytesContext) + { + var bytes = VisitBytes(bytesContext).ToArray(); + if (bytes.Length >= 8) + { + value = BitConverter.ToDouble(bytes, 0); + } + else if (bytes.Length >= 4) + { + value = BitConverter.ToSingle(bytes, 0); + } + else + { + ReportError(DiagnosticIds.ByteArrayTooShort, DiagnosticMessageTemplates.ByteArrayTooShort, bytesContext); + value = 0.0d; + } + } + else + { + throw new UnreachableException(); + } + if (opcode == ILOpCode.Ldc_r4) + { + _currentMethod!.Definition.MethodBody.LoadConstantR4((float)value); + } + else + { + _currentMethod!.Definition.MethodBody.LoadConstantR8(value); + } + } + break; + case CILParser.RULE_instr_sig: + { + Debug.Assert(opcode == ILOpCode.Calli); + BlobBuilder signature = new(); + byte callConv = VisitCallConv(context.callConv()).Value; + signature.WriteByte(callConv); + var args = VisitSigArgs(context.sigArgs()).Value; + signature.WriteCompressedInteger(args.Count(arg => !arg.IsSentinel)); + // Write return type + VisitType(context.type()).Value.WriteContentTo(signature); + // Write arg signatures + foreach (var arg in args) + { + arg.SignatureBlob.WriteContentTo(signature); + } + _currentMethod!.Definition.MethodBody.OpCode(opcode); + _currentMethod!.Definition.MethodBody.Token(_entityRegistry.GetOrCreateStandaloneSignature(signature).Handle); + } + break; + case CILParser.RULE_instr_string: + Debug.Assert(opcode == ILOpCode.Ldstr); + string str; + if (context.bytes() is CILParser.BytesContext rawBytes) + { + ReadOnlySpan bytes = VisitBytes(rawBytes).AsSpan(); + ReadOnlySpan bytesAsChars = MemoryMarshal.Cast(bytes); + if (!BitConverter.IsLittleEndian) + { + for (int i = 0; i < bytesAsChars.Length; i++) + { + BinaryPrimitives.ReverseEndianness(bytesAsChars[i]); + } + } + str = bytesAsChars.ToString(); + } + else + { + var userString = context.compQstring(); + Debug.Assert(userString is not null); + str = VisitCompQstring(userString!).Value; + if (context.ANSI() is not null) + { + // Emit the string not as a UTF-16 string (as per the spec), but directly as an ANSI string. + // Although the string is marked as ANSI, this always used the UTF-8 code page + // so we can emit this as UTF-8 bytes. + int byteCount = Encoding.UTF8.GetByteCount(str); + // Ensure we have an even number of bytes. + if ((byteCount % 1) != 0) + { + byteCount++; + } + + Span utf8Bytes = new byte[byteCount]; + Encoding.UTF8.GetBytes(str, utf8Bytes); + + str = new string(MemoryMarshal.Cast(utf8Bytes)); + } + } + _currentMethod!.Definition.MethodBody.LoadString(_metadataBuilder.GetOrAddUserString(str)); + break; + case CILParser.RULE_instr_switch: + { + var labels = new List<(LabelHandle Label, int? Offset)>(); + if (context.labels()?.children is { } labelChildren) + { + foreach (var label in labelChildren) + { + if (label is CILParser.IdContext id) + { + string labelName = VisitId(id).Value; + if (!_currentMethod!.Labels.TryGetValue(labelName, out var handle)) + { + handle = _currentMethod.Definition.MethodBody.DefineLabel(); + _currentMethod.Labels[labelName] = handle; + // Track undefined label references for later validation + if (!_currentMethod.UndefinedLabelReferences.ContainsKey(labelName)) + { + _currentMethod.UndefinedLabelReferences[labelName] = context; + } + } + labels.Add((handle, null)); + } + else if (label is CILParser.Int32Context int32) + { + int offset = VisitInt32(int32).Value; + LabelHandle labelHandle = _currentMethod!.Definition.MethodBody.DefineLabel(); + labels.Add((labelHandle, offset)); + } + } + } + if (labels.Count > 0) + { + var switchEncoder = _currentMethod!.Definition.MethodBody.Switch(labels.Count); + foreach (var label in labels) + { + switchEncoder.Branch(label.Label); + } + } + else + { + // Empty switch: emit opcode + 0 count manually + _currentMethod!.Definition.MethodBody.OpCode(ILOpCode.Switch); + _currentMethod.Definition.MethodBody.CodeBuilder.WriteInt32(0); + } + // Now that we've emitted the switch instruction, we can go back and mark the offset-based target labels + foreach (var label in labels) + { + if (label.Offset is int offset) + { + _currentMethod.Definition.MethodBody.MarkLabel(label.Label, _currentMethod.Definition.MethodBody.Offset + offset); + } + } + } + break; + case CILParser.RULE_instr_tok: + _currentMethod!.Definition.MethodBody.OpCode(opcode); + if (context.int32() is { } tokenValue) + { + _currentMethod.Definition.MethodBody.CodeBuilder.WriteInt32(VisitInt32(tokenValue).Value); + break; + } + + var tok = VisitOwnerType(context.ownerType()).Value; + if (tok is EntityRegistry.TypeReferenceEntity tokTypeRef) + { + tokTypeRef.RecordBlobToWriteResolvedToken(_currentMethod.Definition.MethodBody.CodeBuilder.ReserveBytes(4)); + } + else if (tok is EntityRegistry.MemberReferenceEntity tokMemberRef) + { + tokMemberRef.RecordBlobToWriteResolvedHandle(_currentMethod.Definition.MethodBody.CodeBuilder.ReserveBytes(4)); + } + else + { + _currentMethod.Definition.MethodBody.Token(tok.Handle); + } + break; + case CILParser.RULE_instr_type: + { + var arg = VisitTypeSpec(context.typeSpec()).Value; + _currentMethod!.Definition.MethodBody.OpCode(opcode); + if (arg is EntityRegistry.TypeReferenceEntity argTypeRef) + { + argTypeRef.RecordBlobToWriteResolvedToken(_currentMethod.Definition.MethodBody.CodeBuilder.ReserveBytes(4)); + } + else + { + _currentMethod.Definition.MethodBody.Token(arg.Handle); + } + } + break; + case CILParser.RULE_instr_var: + { + string instrName = opcode.ToString(); + bool isShortForm = instrName.EndsWith("_s"); + _currentMethod!.Definition.MethodBody.OpCode(opcode); + if (context.int32() is CILParser.Int32Context int32) + { + int value = VisitInt32(int32).Value; + if (isShortForm) + { + // Emit a byte instead of the int for the short form + _currentMethod.Definition.MethodBody.CodeBuilder.WriteByte((byte)value); + } + else + { + _currentMethod.Definition.MethodBody.CodeBuilder.WriteInt32(value); + } + } + else + { + Debug.Assert(context.id() is not null); + string varName = VisitId(context.id()!).Value; + int? index = null; + if (instrName.Contains("arg")) + { + if (_currentMethod!.ArgumentNames.TryGetValue(varName, out var argIndex)) + { + index = argIndex; + + if (_currentMethod.Definition.SignatureHeader.IsInstance) + { + index++; + } + } + else + { + ReportError(DiagnosticIds.ArgumentNotFound, string.Format(DiagnosticMessageTemplates.ArgumentNotFound, varName), context); + } + } + else + { + for (int i = _currentMethod!.LocalsScopes.Count - 1; i >= 0 ; i--) + { + if (_currentMethod.LocalsScopes[i].TryGetValue(varName, out var localIndex)) + { + index = localIndex; + break; + } + } + if (index is null) + { + ReportError(DiagnosticIds.LocalNotFound, string.Format(DiagnosticMessageTemplates.LocalNotFound, varName), context); + } + } + + index ??= -1; + + if (isShortForm) + { + // Emit a byte instead of the int for the short form + _currentMethod.Definition.MethodBody.CodeBuilder.WriteByte((byte)index.Value); + } + else + { + _currentMethod.Definition.MethodBody.CodeBuilder.WriteInt32(index.Value); + } + } + } + break; + } + return GrammarResult.SentinelValue.Result; + } + + public GrammarResult.Literal VisitInstr_brtarget(CILParser.Instr_brtargetContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); + public GrammarResult.Literal VisitInstr_field(CILParser.Instr_fieldContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); + public GrammarResult.Literal VisitInstr_i(CILParser.Instr_iContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); + public GrammarResult.Literal VisitInstr_i8(CILParser.Instr_i8Context context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); + public GrammarResult.Literal VisitInstr_method(CILParser.Instr_methodContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); + public GrammarResult.Literal VisitInstr_none(CILParser.Instr_noneContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); + public GrammarResult.Literal VisitInstr_r(CILParser.Instr_rContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); + public GrammarResult.Literal VisitInstr_sig(CILParser.Instr_sigContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); + public GrammarResult.Literal VisitInstr_string(CILParser.Instr_stringContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); + public GrammarResult.Literal VisitInstr_switch(CILParser.Instr_switchContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); + public GrammarResult.Literal VisitInstr_tok(CILParser.Instr_tokContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); + public GrammarResult.Literal VisitInstr_type(CILParser.Instr_typeContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); + public GrammarResult.Literal VisitInstr_var(CILParser.Instr_varContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); + private static ILOpCode ParseOpCodeFromToken(IToken token) + { + string text = token.Text.TrimEnd('.'); + if (text == "unused") + { + // Native ilasm's keyword index uses the last matching opcode.def entry, CEE_UNUSED70. + return ILOpCode.Unused; + } + + string normalized = text.Replace('.', '_'); + + // Handle instruction aliases that don't directly map to ILOpCode enum names + normalized = normalized switch + { + "ldelem_u8" => "ldelem_i8", + "ldind_u8" => "ldind_i8", + "endfault" => "endfinally", + _ => normalized + }; + + return (ILOpCode)Enum.Parse(typeof(ILOpCode), normalized, ignoreCase: true); + } + + GrammarResult ICILVisitor.VisitInstr(CILParser.InstrContext context) => VisitInstr(context); + GrammarResult ICILVisitor.VisitInstr_brtarget(CILParser.Instr_brtargetContext context) => VisitInstr_brtarget(context); + GrammarResult ICILVisitor.VisitInstr_field(CILParser.Instr_fieldContext context) => VisitInstr_field(context); + GrammarResult ICILVisitor.VisitInstr_i(CILParser.Instr_iContext context) => VisitInstr_i(context); + GrammarResult ICILVisitor.VisitInstr_i8(CILParser.Instr_i8Context context) => VisitInstr_i8(context); + GrammarResult ICILVisitor.VisitInstr_method(CILParser.Instr_methodContext context) => VisitInstr_method(context); + GrammarResult ICILVisitor.VisitInstr_none(CILParser.Instr_noneContext context) => VisitInstr_none(context); + GrammarResult ICILVisitor.VisitInstr_r(CILParser.Instr_rContext context) => VisitInstr_r(context); + GrammarResult ICILVisitor.VisitInstr_sig(CILParser.Instr_sigContext context) => VisitInstr_sig(context); + GrammarResult ICILVisitor.VisitInstr_string(CILParser.Instr_stringContext context) => VisitInstr_string(context); + GrammarResult ICILVisitor.VisitInstr_switch(CILParser.Instr_switchContext context) => VisitInstr_switch(context); + GrammarResult ICILVisitor.VisitInstr_tok(CILParser.Instr_tokContext context) => VisitInstr_tok(context); + GrammarResult ICILVisitor.VisitInstr_type(CILParser.Instr_typeContext context) => VisitInstr_type(context); + GrammarResult ICILVisitor.VisitInstr_var(CILParser.Instr_varContext context) => VisitInstr_var(context); + + GrammarResult ICILVisitor.VisitMdtoken(ILAssembler.CILParser.MdtokenContext context) => VisitMdtoken(context); + public GrammarResult.Literal VisitMdtoken(CILParser.MdtokenContext context) + { + return new(_entityRegistry.ResolveHandleToEntity(MetadataTokens.EntityHandle(VisitInt32(context.int32()).Value))); + } + +#pragma warning restore CA1822 // Mark members as static +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs new file mode 100644 index 00000000000000..0895489eb2c878 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs @@ -0,0 +1,273 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Buffers.Binary; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using System.Reflection.PortableExecutable; +using System.Runtime.InteropServices; +using System.Security.Cryptography; +using System.Text; +using Antlr4.Runtime; +using Antlr4.Runtime.Misc; +using Antlr4.Runtime.Tree; + +namespace ILAssembler +{ +#pragma warning disable CA1822 // Mark members as static + internal sealed partial class GrammarActions : ICILVisitor + { + GrammarResult ICILVisitor.VisitCompQstring(CILParser.CompQstringContext context) + { + return VisitCompQstring(context); + } + + private static GrammarResult.String VisitCompQstring(CILParser.CompQstringContext context) + { + StringBuilder builder = new(); + foreach (var item in context.QSTRING()) + { + builder.Append(StringHelpers.ParseQuotedString(item.Symbol.Text)); + } + return new(builder.ToString()); + } + + GrammarResult ICILVisitor.VisitDottedName(CILParser.DottedNameContext context) + { + return VisitDottedName(context); + } + + public static GrammarResult.String VisitDottedName(CILParser.DottedNameContext context) + { + CILParser.DottedNamePartContext[] parts = context.dottedNamePart(); + if (parts.Length > 0) + { + StringBuilder builder = new(); + for (int i = 0; i < parts.Length; i++) + { + if (i > 0) + { + builder.Append('.'); + } + + CILParser.DottedNamePartContext part = parts[i]; + builder.Append(part.SQSTRING() is { } quotedPart + ? StringHelpers.ParseQuotedString(quotedPart.GetText()) + : part.GetText()); + } + + return new(builder.ToString()); + } + + string text = context.GetText(); + if (context.SQSTRING() is not null && text.Length >= 2 && text[0] == '\'') + { + text = text.Substring(1, text.Length - 2); + } + return new(text); + } + + GrammarResult ICILVisitor.VisitDottedNamePart(CILParser.DottedNamePartContext context) => throw new UnreachableException(); + + GrammarResult ICILVisitor.VisitFloat64(CILParser.Float64Context context) => VisitFloat64(context); + public GrammarResult.Literal VisitFloat64(CILParser.Float64Context context) + { + if (context.FLOAT64() is ITerminalNode float64) + { + string text = float64.Symbol.Text; + bool neg = text.StartsWith('-'); + if (!double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out double result)) + { + result = neg ? double.MaxValue : double.MinValue; + } + return new(result); + } + else if (context.int32() is CILParser.Int32Context int32) + { + IToken node = int32.INT32().Symbol; + if (!ParseIntegerValue(node.Text.AsSpan(), out long intValue)) + { + _diagnostics.Add(new Diagnostic( + DiagnosticIds.LiteralOutOfRange, + DiagnosticSeverity.Error, + string.Format(DiagnosticMessageTemplates.LiteralOutOfRange, node.Text), + Location.From(node, _documents))); + intValue = 0; + } + + if (context.FLOAT32() is not null) + { + // FLOAT32 '(' int32 ')' — hex bits reinterpreted as float32 + return new(BitConverter.Int32BitsToSingle((int)intValue)); + } + // int32 or int32 '.' — plain integer or trailing-dot float + return new((double)intValue); + } + else if (context.int64() is CILParser.Int64Context int64) + { + // FLOAT64_ '(' int64 ')' — hex bits reinterpreted as float64 + long value = VisitInt64(int64).Value; + return new(BitConverter.Int64BitsToDouble(value)); + } + throw new UnreachableException(); + } + GrammarResult ICILVisitor.VisitId(CILParser.IdContext context) => VisitId(context); + public static GrammarResult.String VisitId(CILParser.IdContext context) + { + string text = context.GetText(); + if (context.SQSTRING() is not null && text.Length >= 2 && text[0] == '\'') + { + text = text.Substring(1, text.Length - 2); + } + return new GrammarResult.String(text); + } + + private static bool ParseIntegerValue(ReadOnlySpan value, out long result) + { + NumberStyles parseStyle = NumberStyles.None; + bool negate = false; + if (value.StartsWith("-".AsSpan())) + { + negate = true; + value = value.Slice(1); + } + + if (value.StartsWith("0x".AsSpan())) + { + parseStyle = NumberStyles.AllowHexSpecifier; + value = value.Slice(2); + } + else if (value.StartsWith("0".AsSpan())) + { + // Octal support isn't built-in, so we'll do it manually. + result = 0; + for (int i = 0; i < value.Length; i++, result *= 8) + { + int digitValue = value[i] - '0'; + if (digitValue < 0 || digitValue > 7) + { + // COMPAT: native ilasm skips invalid digits silently + continue; + } + result += digitValue; + } + if (negate) result = -result; + return true; + } + + bool success = long.TryParse(value.ToString(), parseStyle, CultureInfo.InvariantCulture, out result); + if (!success) + { + // Try parsing as unsigned — handles values like: + // - Decimal overflow with negation: 9223372036854775808 (= -Int64.MinValue) + // - Large unsigned decimal: 18444492274432737280 + if (ulong.TryParse(value.ToString(), parseStyle, CultureInfo.InvariantCulture, out ulong uresult)) + { + result = unchecked((long)uresult); + if (negate) result = unchecked(-result); + return true; + } + // Handle oversized hex values (>64 bits) by truncating to low 64 bits, + // matching native ilasm behavior for values like 0x94188556b24089e8b90c9c61f9f3088 + if (parseStyle == NumberStyles.AllowHexSpecifier && value.Length > 16) + { + var truncated = value.Slice(value.Length - 16); + if (ulong.TryParse(truncated.ToString(), parseStyle, CultureInfo.InvariantCulture, out uresult)) + { + result = unchecked((long)uresult); + if (negate) result = unchecked(-result); + return true; + } + } + return false; + } + + if (negate) result = -result; + return true; + } + + GrammarResult ICILVisitor.VisitInt32(CILParser.Int32Context context) + { + return VisitInt32(context); + } + + public GrammarResult.Literal VisitInt32(CILParser.Int32Context context) + { + IToken node = context.INT32().Symbol; + + ReadOnlySpan value = node.Text.AsSpan(); + + if (!ParseIntegerValue(value, out long num)) + { + _diagnostics.Add(new Diagnostic( + DiagnosticIds.LiteralOutOfRange, + DiagnosticSeverity.Error, + string.Format(DiagnosticMessageTemplates.LiteralOutOfRange, node.Text), + Location.From(node, _documents))); + return new GrammarResult.Literal(0); + } + + return new GrammarResult.Literal((int)num); + } + + + GrammarResult ICILVisitor.VisitInt64(CILParser.Int64Context context) + { + return VisitInt64(context); + } + + public GrammarResult.Literal VisitInt64(CILParser.Int64Context context) + { + IToken node = context.GetChild(0).Symbol; + + ReadOnlySpan value = node.Text.AsSpan(); + + if (!ParseIntegerValue(value, out long num)) + { + _diagnostics.Add(new Diagnostic( + DiagnosticIds.LiteralOutOfRange, + DiagnosticSeverity.Error, + string.Format(DiagnosticMessageTemplates.LiteralOutOfRange, node.Text), + Location.From(node, _documents))); + return new GrammarResult.Literal(0); + } + + return new GrammarResult.Literal(num); + } + + GrammarResult ICILVisitor.VisitIntOrWildcard(CILParser.IntOrWildcardContext context) => VisitIntOrWildcard(context); + public GrammarResult.Literal VisitIntOrWildcard(CILParser.IntOrWildcardContext context) => context.int32() is {} int32 ? new(VisitInt32(int32).Value) : new(null); + + GrammarResult ICILVisitor.VisitSlashedName(CILParser.SlashedNameContext context) + { + return VisitSlashedName(context); + } + + public static GrammarResult.Literal VisitSlashedName(CILParser.SlashedNameContext context) + { + TypeName? currentTypeName = null; + foreach (var item in context.dottedName()) + { + currentTypeName = new TypeName(currentTypeName, VisitDottedName(item).Value); + } + // We'll always have at least one dottedName, so the value here will be non-null + return new(currentTypeName!); + } + + GrammarResult ICILVisitor.VisitTruefalse(CILParser.TruefalseContext context) => VisitTruefalse(context); + + public static GrammarResult.Literal VisitTruefalse(CILParser.TruefalseContext context) + { + return new(bool.Parse(context.GetText())); + } + + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.cs new file mode 100644 index 00000000000000..971007a1836309 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.cs @@ -0,0 +1,673 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Buffers.Binary; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using System.Reflection.PortableExecutable; +using System.Runtime.InteropServices; +using System.Security.Cryptography; +using System.Text; +using Antlr4.Runtime; +using Antlr4.Runtime.Misc; +using Antlr4.Runtime.Tree; + +namespace ILAssembler +{ +#pragma warning disable CA1822 // Mark members as static + internal sealed partial class GrammarActions : ICILVisitor + { + GrammarResult ICILVisitor.VisitAlignment(CILParser.AlignmentContext context) => VisitAlignment(context); + public GrammarResult.Literal VisitAlignment(CILParser.AlignmentContext context) + { + return VisitInt32(context.int32()); + } + + GrammarResult ICILVisitor.VisitAsmAttr(CILParser.AsmAttrContext context) => VisitAsmAttr(context); + public GrammarResult.Literal VisitAsmAttr(CILParser.AsmAttrContext context) + => new(context.asmAttrAny().Select(VisitAsmAttrAny).Aggregate((AssemblyFlags)0, (lhs, rhs) => lhs | rhs)); + GrammarResult ICILVisitor.VisitAsmAttrAny(CILParser.AsmAttrAnyContext context) => VisitAsmAttrAny(context); + public GrammarResult.Flag VisitAsmAttrAny(CILParser.AsmAttrAnyContext context) + { + return context.GetText() switch + { + "retargetable" => new(AssemblyFlags.Retargetable), + "windowsruntime" => new(AssemblyFlags.WindowsRuntime), + "noplatform" => new(AssemblyFlags.NoPlatform), + "legacy library" => new(0), + "cil" => new(GetFlagForArch(ProcessorArchitecture.MSIL), AssemblyFlags.ArchitectureMask), + "x86" => new(GetFlagForArch(ProcessorArchitecture.X86), AssemblyFlags.ArchitectureMask), + "amd64" => new(GetFlagForArch(ProcessorArchitecture.Amd64), AssemblyFlags.ArchitectureMask), + "arm" => new(GetFlagForArch(ProcessorArchitecture.Arm), AssemblyFlags.ArchitectureMask), + "arm64" => new(GetFlagForArch((ProcessorArchitecture)6), AssemblyFlags.ArchitectureMask), + _ => throw new UnreachableException() + }; + } + + private static AssemblyFlags GetFlagForArch(ProcessorArchitecture arch) + { + return (AssemblyFlags)((int)arch << 4); + } + + private static (ProcessorArchitecture, AssemblyFlags) GetArchAndFlags(AssemblyFlags flags) + { + var arch = (ProcessorArchitecture)(((int)flags & 0xF0) >> 4); + var newFlags = flags & ~((AssemblyFlags)((int)arch << 4)); + return (arch, newFlags); + } + public GrammarResult VisitAsmOrRefDecl(CILParser.AsmOrRefDeclContext context) + { + Debug.Assert(_currentAssemblyOrRef is not null); + + if (context.customAttrDecl() is { } attr) + { + var customAttr = VisitCustomAttrDecl(attr).Value; + customAttr?.Owner = _currentAssemblyOrRef; + return GrammarResult.SentinelValue.Result; + } + + string decl = context.GetChild(0).GetText(); + if (decl is ".publickey" or ".publicKey") + { + BlobBuilder blob = new(); + blob.WriteBytes(VisitBytes(context.bytes())); + // COMPAT: Native ilasm gives a public key token precedence regardless of declaration order. + if (_currentAssemblyOrRef is not EntityRegistry.AssemblyReferenceEntity assemblyReference + || assemblyReference.PublicKeyOrToken is null + || assemblyReference.Flags.HasFlag(AssemblyFlags.PublicKey)) + { + _currentAssemblyOrRef!.PublicKeyOrToken = blob; + _currentAssemblyOrRef.Flags |= AssemblyFlags.PublicKey; + } + } + else if (decl == ".ver") + { + var versionComponents = context.intOrWildcard(); + _currentAssemblyOrRef!.Version = new Version( + VisitIntOrWildcard(versionComponents[0]).Value ?? 0, + VisitIntOrWildcard(versionComponents[1]).Value ?? 0, + VisitIntOrWildcard(versionComponents[2]).Value ?? 0, + VisitIntOrWildcard(versionComponents[3]).Value ?? 0); + } + else if (decl == ".locale") + { + _currentAssemblyOrRef!.Culture = context.compQstring() is { } compQstring + ? VisitCompQstring(compQstring).Value + : Encoding.Unicode.GetString([.. VisitBytes(context.bytes())]); + } + return GrammarResult.SentinelValue.Result; + } + + GrammarResult ICILVisitor.VisitAssemblyBlock(CILParser.AssemblyBlockContext context) => VisitAssemblyBlock(context); + public GrammarResult VisitAssemblyBlock(CILParser.AssemblyBlockContext context) + { + // Use command-line override if specified, otherwise use the name from the .assembly directive + string assemblyName = _options.AssemblyName ?? VisitDottedName(context.dottedName()).Value; + _entityRegistry.Assembly ??= new EntityRegistry.AssemblyEntity(assemblyName); + var attr = VisitAsmAttr(context.asmAttr()).Value; + (_entityRegistry.Assembly.ProcessorArchitecture, _entityRegistry.Assembly.Flags) = GetArchAndFlags(attr); + foreach (var decl in context.assemblyDecls().assemblyDecl()) + { + VisitAssemblyDecl(decl); + } + + // Apply command-line key file override (overrides .publickey directive) + if (_options.KeyFile is not null) + { + ApplyKeyFile(_options.KeyFile); + } + + // DebuggableAttribute is applied in BuildImage() after all source declarations + // have been processed, so the correct corelib assembly ref can be found. + + return GrammarResult.SentinelValue.Result; + } + + private void ApplyKeyFile(string keyFilePath) + { + if (_entityRegistry.Assembly is null) + { + return; + } + + try + { + byte[] keyBytes = File.ReadAllBytes(keyFilePath); + BlobBuilder blob = new(); + blob.WriteBytes(keyBytes); + _entityRegistry.Assembly.PublicKeyOrToken = blob; + _entityRegistry.Assembly.Flags |= AssemblyFlags.PublicKey; + } + catch (Exception ex) + { + // Create a location pointing to the first document (if available) + var firstDoc = _documents.Values.FirstOrDefault(); + var location = firstDoc is not null + ? new Location(new SourceSpan(0, 0), firstDoc) + : new Location(new SourceSpan(0, 0), new SourceText(string.Empty, keyFilePath)); + _diagnostics.Add(new Diagnostic(DiagnosticIds.KeyFileError, DiagnosticSeverity.Error, $"Failed to read key file '{keyFilePath}': {ex.Message}", location)); + } + } + + GrammarResult ICILVisitor.VisitAssemblyDecl(CILParser.AssemblyDeclContext context) => VisitAssemblyDecl(context); + public GrammarResult VisitAssemblyDecl(CILParser.AssemblyDeclContext context) + { + if (context.secDecl() is { } secDecl) + { + var declarativeSecurity = VisitSecDecl(secDecl); + if (declarativeSecurity.Value is { } sec) + { + sec.Parent = _entityRegistry.Assembly; + } + } + else if (context.int32() is { } hashAlg) + { + _entityRegistry.Assembly!.HashAlgorithm = (AssemblyHashAlgorithm)VisitInt32(hashAlg).Value; + } + else if (context.asmOrRefDecl() is { } asmOrRef) + { + _currentAssemblyOrRef = _entityRegistry.Assembly; + VisitAsmOrRefDecl(asmOrRef); + _currentAssemblyOrRef = null; + } + return GrammarResult.SentinelValue.Result; + } + public GrammarResult VisitAssemblyDecls(CILParser.AssemblyDeclsContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + public GrammarResult VisitAssemblyRefDecl(CILParser.AssemblyRefDeclContext context) + { + if (context.asmOrRefDecl() is { } asmOrRef) + { + VisitAsmOrRefDecl(asmOrRef); + } + string decl = context.GetChild(0).GetText(); + if (decl == ".hash") + { + var blob = new BlobBuilder(); + blob.WriteBytes(VisitBytes(context.bytes())); + ((EntityRegistry.AssemblyReferenceEntity)_currentAssemblyOrRef!).Hash = blob; + } + if (decl == ".publickeytoken") + { + var blob = new BlobBuilder(); + blob.WriteBytes(VisitBytes(context.bytes())); + _currentAssemblyOrRef!.PublicKeyOrToken = blob; + _currentAssemblyOrRef.Flags &= ~AssemblyFlags.PublicKey; + } + return GrammarResult.SentinelValue.Result; + } + public GrammarResult VisitAssemblyRefDecls(CILParser.AssemblyRefDeclsContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + GrammarResult ICILVisitor.VisitAssemblyRefHead(CILParser.AssemblyRefHeadContext context) => VisitAssemblyRefHead(context); + public GrammarResult.Literal VisitAssemblyRefHead(CILParser.AssemblyRefHeadContext context) + { + var (arch, flags) = GetArchAndFlags(VisitAsmAttr(context.asmAttr()).Value); + var dottedNames = context.dottedName(); + string name = VisitDottedName(dottedNames[0]).Value; + string alias = name; + if (dottedNames.Length > 1) + { + alias = VisitDottedName(dottedNames[1]).Value; + } + return new(_entityRegistry.GetOrCreateAssemblyReference(alias, asmref => + { + asmref.Name = name; + asmref.Flags = flags; + asmref.ProcessorArchitecture = arch; + })); + } + + GrammarResult ICILVisitor.VisitCorflags(CILParser.CorflagsContext context) => VisitCorflags(context); + public GrammarResult.Literal VisitCorflags(CILParser.CorflagsContext context) => VisitInt32(context.int32()); + + public GrammarResult VisitExportHead(CILParser.ExportHeadContext context) => throw new NotImplementedException("Obsolete syntax"); + GrammarResult ICILVisitor.VisitExptAttr(CILParser.ExptAttrContext context) => VisitExptAttr(context); + public static GrammarResult.Flag VisitExptAttr(CILParser.ExptAttrContext context) + { + return context.GetText() switch + { + "private" => new(TypeAttributes.NotPublic, TypeAttributes.VisibilityMask), + "public" => new(TypeAttributes.Public, TypeAttributes.VisibilityMask), + "forwarder" => new(TypeAttributes.Forwarder), + "nestedpublic" => new(TypeAttributes.NestedPublic, TypeAttributes.VisibilityMask), + "nestedprivate" => new(TypeAttributes.NestedPrivate, TypeAttributes.VisibilityMask), + "nestedfamily" => new(TypeAttributes.NestedFamily, TypeAttributes.VisibilityMask), + "nestedassembly" => new(TypeAttributes.NestedAssembly, TypeAttributes.VisibilityMask), + "nestedfamandassem" => new(TypeAttributes.NestedFamANDAssem, TypeAttributes.VisibilityMask), + "nestedfamorassem" => new(TypeAttributes.NestedFamORAssem, TypeAttributes.VisibilityMask), + _ => throw new UnreachableException(), + }; + } + + // Type exports and forwarders are implemented via VisitExptypeDecls + public GrammarResult VisitExptypeDecl(CILParser.ExptypeDeclContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + + GrammarResult ICILVisitor.VisitExptypeDecls(CILParser.ExptypeDeclsContext context) => VisitExptypeDecls(context); + public GrammarResult.Literal<(EntityRegistry.EntityBase? implementation, int typedefId, ImmutableArray attrs)> VisitExptypeDecls(CILParser.ExptypeDeclsContext context) + { + // COMPAT: The following order specifies the precedence of the various export kinds. + // File, Assembly, Class (enclosing type), invalid token. + // We'll process through all of the options here and then return the one that is valid. + // We'll also record custom attributes here. + EntityRegistry.EntityBase? implementationEntity = null; + int typedefId = 0; + var attrs = ImmutableArray.CreateBuilder(); + var declarations = context.exptypeDecl(); + for (int i = 0; i < declarations.Length; i++) + { + if (declarations[i].customAttrDecl() is { } attr) + { + if (VisitCustomAttrDecl(attr).Value is EntityRegistry.CustomAttributeEntity customAttribute) + { + attrs.Add(customAttribute); + } + continue; + } + if (declarations[i].mdtoken() is { } mdToken) + { + var entity = VisitMdtoken(mdToken).Value; + if (entity is null or EntityRegistry.FakeTypeEntity) + { + ReportError(DiagnosticIds.InvalidMetadataToken, DiagnosticMessageTemplates.InvalidMetadataToken, declarations[i]); + } + implementationEntity = ResolveBetterEntity(entity); + continue; + } + string kind = declarations[i].GetText(); + if (kind.StartsWith(".file")) + { + string fileName = VisitDottedName(declarations[i].dottedName()).Value; + implementationEntity = _entityRegistry.FindFile(fileName); + if (implementationEntity is null) + { + ReportError(DiagnosticIds.FileNotFound, string.Format(DiagnosticMessageTemplates.FileNotFound, fileName), declarations[i]); + } + } + else if (kind.StartsWith(".assembly")) + { + string assemblyName = VisitDottedName(declarations[i].dottedName()).Value; + implementationEntity = _entityRegistry.FindAssemblyReference(assemblyName); + if (implementationEntity is null) + { + ReportError(DiagnosticIds.AssemblyNotFound, string.Format(DiagnosticMessageTemplates.AssemblyNotFound, assemblyName), declarations[i]); + } + } + else if (kind.StartsWith(".class")) + { + if (declarations[i].int32() is CILParser.Int32Context int32) + { + typedefId = VisitInt32(int32).Value; + } + else + { + _ = VisitSlashedName(declarations[i].slashedName()); + var containing = ResolveExportedType(declarations[i].slashedName()); + if (containing is null) + { + ReportError(DiagnosticIds.ExportedTypeNotFound, string.Format(DiagnosticMessageTemplates.ExportedTypeNotFound, declarations[i].slashedName().GetText()), declarations[i]); + } + else + { + implementationEntity = ResolveBetterEntity(containing); + } + } + } + } + + return new((implementationEntity, typedefId, attrs.ToImmutable())); + + EntityRegistry.EntityBase? ResolveBetterEntity(EntityRegistry.EntityBase? newImplementation) + { + return (implementationEntity, newImplementation) switch + { + (null, _) => newImplementation, + (_, null) => implementationEntity, + (_, EntityRegistry.FileEntity) => newImplementation, + (EntityRegistry.FileEntity, _) => implementationEntity, + (_, EntityRegistry.AssemblyEntity) => newImplementation, + (EntityRegistry.AssemblyEntity, _) => implementationEntity, + (_, EntityRegistry.TypeEntity) => newImplementation, + (EntityRegistry.TypeEntity, _) => implementationEntity, + _ => throw new UnreachableException(), + }; + } + + // Resolve ExportedType reference + EntityRegistry.ExportedTypeEntity? ResolveExportedType(CILParser.SlashedNameContext slashedName) + { + TypeName typeName = VisitSlashedName(slashedName).Value; + if (typeName.ContainingTypeName is null) + { + // Check for typedef - typedefs resolve to TypeEntity, not ExportedTypeEntity + // so we skip the typedef check for exported type resolution + } + Stack containingTypes = new(); + for (TypeName? containingType = typeName; containingType is not null; containingType = containingType.ContainingTypeName) + { + containingTypes.Push(containingType); + } + EntityRegistry.ExportedTypeEntity? exportedType = null; + while (containingTypes.Count != 0) + { + TypeName containingType = containingTypes.Pop(); + + (string ns, string name) = NameHelpers.SplitDottedNameToNamespaceAndName(containingType.DottedName); + + exportedType = _entityRegistry.FindExportedType( + exportedType, + ns, + name); + + if (exportedType is null) + { + ReportError(DiagnosticIds.ExportedTypeNotFound, string.Format(DiagnosticMessageTemplates.ExportedTypeNotFound, containingType.DottedName), slashedName); + return null; + } + } + + return exportedType!; + } + } + GrammarResult ICILVisitor.VisitExptypeHead(CILParser.ExptypeHeadContext context) => VisitExptypeHead(context); + public GrammarResult.Literal<(TypeAttributes attrs, string dottedName)> VisitExptypeHead(CILParser.ExptypeHeadContext context) + { + var attrs = context.exptAttr().Select(VisitExptAttr).Aggregate((TypeAttributes)0, (a, b) => a | b); + return new((attrs, VisitDottedName(context.dottedName()).Value)); + } + + GrammarResult ICILVisitor.VisitFileAttr(CILParser.FileAttrContext context) => VisitFileAttr(context); + public GrammarResult.Literal VisitFileAttr(CILParser.FileAttrContext context) + => context.ChildCount != 0 ? new(false) : new(true); + GrammarResult ICILVisitor.VisitFileDecl(CILParser.FileDeclContext context) => VisitFileDecl(context); + public GrammarResult.Literal VisitFileDecl(CILParser.FileDeclContext context) + { + string dottedName = VisitDottedName(context.dottedName()).Value; + ImmutableArray? hash = context.HASH() is not null ? VisitBytes(context.bytes()) : null; + var hashBlob = hash is not null ? new BlobBuilder() : null; + hashBlob?.WriteBytes(hash!.Value); + + bool hasMetadata = context.fileAttr().Aggregate(true, (acc, attr) => acc && VisitFileAttr(attr).Value); + bool isEntrypoint = context.fileEntry().Aggregate(false, (acc, attr) => acc || VisitFileEntry(attr).Value); + var entity = _entityRegistry.GetOrCreateFile(dottedName, hasMetadata, hashBlob); + if (isEntrypoint) + { + _entityRegistry.EntryPoint = entity; + } + return new(entity); + } + GrammarResult ICILVisitor.VisitFileEntry(CILParser.FileEntryContext context) => VisitFileEntry(context); + public GrammarResult.Literal VisitFileEntry(CILParser.FileEntryContext context) + => context.ChildCount != 0 ? new(true) : new(false); + + GrammarResult ICILVisitor.VisitImagebase(CILParser.ImagebaseContext context) => VisitImagebase(context); + public GrammarResult.Literal VisitImagebase(CILParser.ImagebaseContext context) => VisitInt64(context.int64()); + + public GrammarResult VisitManifestResDecl(CILParser.ManifestResDeclContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + GrammarResult ICILVisitor.VisitManifestResDecls(CILParser.ManifestResDeclsContext context) => VisitManifestResDecls(context); + public GrammarResult.Literal<(EntityRegistry.EntityBase? implementation, uint offset, ImmutableArray attributes)> VisitManifestResDecls(CILParser.ManifestResDeclsContext context) + { + EntityRegistry.EntityBase? implementation = null; + uint offset = 0; + var attributes = ImmutableArray.CreateBuilder(); + // COMPAT: Priority order for implementation is the following + // AssemblyRef, File, nil + foreach (var decl in context.manifestResDecl()) + { + if (decl.customAttrDecl() is CILParser.CustomAttrDeclContext customAttrDecl) + { + if (VisitCustomAttrDecl(customAttrDecl).Value is { } attr) + { + attributes.Add(attr); + } + } + string kind = decl.GetChild(0).GetText(); + if (kind == ".file" && implementation is not EntityRegistry.AssemblyReferenceEntity) + { + string fileName = VisitDottedName(decl.dottedName()).Value; + var file = _entityRegistry.FindFile(fileName); + if (file is null) + { + ReportError(DiagnosticIds.FileNotFound, string.Format(DiagnosticMessageTemplates.FileNotFound, fileName), decl); + } + else + { + implementation = file; + offset = (uint)VisitInt32(decl.int32()).Value; + } + } + else if (kind == ".assembly") + { + string assemblyName = VisitDottedName(decl.dottedName()).Value; + implementation = _entityRegistry.GetOrCreateAssemblyReference(assemblyName, _ => { }); + } + } + + return new((implementation, offset, attributes.ToImmutable())); + } + GrammarResult ICILVisitor.VisitManifestResHead(CILParser.ManifestResHeadContext context) => VisitManifestResHead(context); + public GrammarResult.Literal<(string name, string alias, ManifestResourceAttributes attr)> VisitManifestResHead(CILParser.ManifestResHeadContext context) + { + var dottedNames = context.dottedName(); + string name = VisitDottedName(dottedNames[0]).Value; + string alias = dottedNames.Length == 2 ? VisitDottedName(dottedNames[1]).Value : name; + ManifestResourceAttributes attr = 0; + foreach (var attrContext in context.manresAttr()) + { + attr |= VisitManresAttr(attrContext).Value; + } + + return new((name, alias, attr)); + } + + GrammarResult ICILVisitor.VisitManresAttr(CILParser.ManresAttrContext context) => VisitManresAttr(context); + public GrammarResult.Flag VisitManresAttr(CILParser.ManresAttrContext context) + { + return context.GetText() switch + { + "public" => new(ManifestResourceAttributes.Public), + "private" => new(ManifestResourceAttributes.Private), + _ => throw new UnreachableException() + }; + } + + public GrammarResult VisitModuleHead(CILParser.ModuleHeadContext context) + { + if (context.ChildCount > 2) + { + _ = _entityRegistry.GetOrCreateModuleReference(VisitDottedName(context.dottedName()).Value, _ => { }); + return GrammarResult.SentinelValue.Result; + } + + if (context.dottedName() is { } moduleName) + { + _entityRegistry.Module.Name = VisitDottedName(moduleName).Value; + } + return GrammarResult.SentinelValue.Result; + } + + // .mscorlib directive indicates the assembly being compiled is mscorlib itself. + // This is currently a no-op; the flag would be used to affect type resolution + // when support for compiling mscorlib is added. + public GrammarResult VisitMscorlib(CILParser.MscorlibContext context) => GrammarResult.SentinelValue.Result; + + GrammarResult ICILVisitor.VisitStackreserve(CILParser.StackreserveContext context) => VisitStackreserve(context); + public GrammarResult.Literal VisitStackreserve(CILParser.StackreserveContext context) => VisitInt64(context.int64()); + + GrammarResult ICILVisitor.VisitSubsystem(CILParser.SubsystemContext context) => VisitSubsystem(context); + public GrammarResult.Literal VisitSubsystem(CILParser.SubsystemContext context) => VisitInt32(context.int32()); + + public GrammarResult VisitTypedefDecl(CILParser.TypedefDeclContext context) + { + string alias = VisitDottedName(context.dottedName()).Value; + + if (context.type() is CILParser.TypeContext type) + { + // .typedef type as alias + // This creates an alias for a complete type signature (blob) + var typeBlob = VisitType(type).Value; + // Create a copy of the blob to avoid issues with linked BlobBuilders + var copy = new BlobBuilder(typeBlob.Count); + typeBlob.WriteContentTo(copy); + _typedefs[alias] = new TypedefEntry.TypeBlob(copy); + } + else if (context.className() is CILParser.ClassNameContext className) + { + // .typedef className as alias + var typeEntity = VisitClassName(className).Value; + _typedefs[alias] = new TypedefEntry.Type(typeEntity); + } + else if (context.memberRef() is CILParser.MemberRefContext memberRef) + { + // .typedef memberRef as alias + var member = VisitMemberRef(memberRef).Value; + _typedefs[alias] = new TypedefEntry.Member(member); + } + else if (context.customDescr() is CILParser.CustomDescrContext customDescr) + { + // .typedef customDescr as alias + var attr = VisitCustomDescr(customDescr).Value; + if (attr is not null) + { + _typedefs[alias] = new TypedefEntry.CustomAttribute(attr.Constructor, attr.Value); + } + } + else if (context.customDescrWithOwner() is CILParser.CustomDescrWithOwnerContext customDescrWithOwner) + { + // .typedef customDescrWithOwner as alias + var attr = VisitCustomDescrWithOwner(customDescrWithOwner).Value; + if (attr is not null) + { + _typedefs[alias] = new TypedefEntry.CustomAttribute(attr.Constructor, attr.Value); + } + } + + return GrammarResult.SentinelValue.Result; + } + + /// + /// Tries to resolve a typedef alias to a type entity. + /// + private EntityRegistry.TypeEntity? TryResolveTypedefAsType(string alias) + { + if (_typedefs.TryGetValue(alias, out var entry) && entry is TypedefEntry.Type typeEntry) + { + return typeEntry.Entity; + } + return null; + } + + /// + /// Tries to resolve a typedef alias to a type blob (complete type signature). + /// + private BlobBuilder? TryResolveTypedefAsTypeBlob(string alias) + { + if (_typedefs.TryGetValue(alias, out var entry)) + { + if (entry is TypedefEntry.TypeBlob blobEntry) + { + return blobEntry.Blob; + } + if (entry is TypedefEntry.Type typeEntry) + { + // Encode the type entity as a CLASS reference for the blob + var blob = new BlobBuilder(5); + blob.WriteByte((byte)SignatureTypeKind.Class); + blob.WriteTypeEntity(typeEntry.Entity); + return blob; + } + } + return null; + } + + /// + /// Tries to resolve a typedef alias to a member reference. + /// + private EntityRegistry.EntityBase? TryResolveTypedefAsMember(string alias) + { + if (_typedefs.TryGetValue(alias, out var entry) && entry is TypedefEntry.Member memberEntry) + { + return memberEntry.Entity; + } + return null; + } + + /// + /// Tries to resolve a typedef alias to a custom attribute. + /// + private (EntityRegistry.EntityBase Constructor, BlobBuilder Value)? TryResolveTypedefAsCustomAttribute(string alias) + { + if (_typedefs.TryGetValue(alias, out var entry) && entry is TypedefEntry.CustomAttribute attrEntry) + { + return (attrEntry.Constructor, attrEntry.Value); + } + return null; + } + + public GrammarResult VisitTypelist(CILParser.TypelistContext context) + { + foreach (var name in context.className()) + { + // We don't do anything with the class names here. + // We just go through the name resolution process to ensure that the names are valid + // and to provide TypeReference table rows. + _ = VisitClassName(name); + } + return GrammarResult.SentinelValue.Result; + } + + public GrammarResult VisitVtableDecl(CILParser.VtableDeclContext context) + { + // Raw .vtable directive with bytes - not commonly used + // For now, we don't support this legacy syntax + throw new NotImplementedException("raw vtable fixups blob (.vtable) not supported - use .vtfixup instead"); + } + + GrammarResult ICILVisitor.VisitVtfixupAttr(CILParser.VtfixupAttrContext context) => VisitVtfixupAttr(context); + public GrammarResult.Literal VisitVtfixupAttr(CILParser.VtfixupAttrContext context) + { + // vtfixupAttr: | vtfixupAttr INT32_ | vtfixupAttr INT64_ | vtfixupAttr 'fromunmanaged' | vtfixupAttr 'callmostderived' | vtfixupAttr 'retainappdomain' + ushort flags = 0; + foreach (var child in context.children ?? []) + { + string text = child.GetText(); + flags |= text switch + { + "int32" => VTableFixupSupport.COR_VTABLE_32BIT, + "int64" => VTableFixupSupport.COR_VTABLE_64BIT, + "fromunmanaged" => VTableFixupSupport.COR_VTABLE_FROM_UNMANAGED, + "callmostderived" => VTableFixupSupport.COR_VTABLE_CALL_MOST_DERIVED, + "retainappdomain" => VTableFixupSupport.COR_VTABLE_FROM_UNMANAGED_RETAIN_APPDOMAIN, + _ => 0 + }; + } + + // Default to 32-bit if neither 32 nor 64 is specified + if ((flags & (VTableFixupSupport.COR_VTABLE_32BIT | VTableFixupSupport.COR_VTABLE_64BIT)) == 0) + { + flags |= VTableFixupSupport.COR_VTABLE_32BIT; + } + + return new(flags); + } + + GrammarResult ICILVisitor.VisitVtfixupDecl(CILParser.VtfixupDeclContext context) => VisitVtfixupDecl(context); + public GrammarResult VisitVtfixupDecl(CILParser.VtfixupDeclContext context) + { + // vtfixupDecl: '.vtfixup' '[' int32 ']' vtfixupAttr 'at' id; + int slotCount = VisitInt32(context.int32()).Value; + ushort flags = VisitVtfixupAttr(context.vtfixupAttr()).Value; + string dataLabel = VisitId(context.id()).Value; + + _vtableFixups.Add(new VTableFixupSupport.VTableFixupEntry(slotCount, flags, dataLabel)); + + return GrammarResult.SentinelValue.Result; + } + + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Marshalling.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Marshalling.cs new file mode 100644 index 00000000000000..8a4920b7f1b7d9 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Marshalling.cs @@ -0,0 +1,526 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Buffers.Binary; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using System.Reflection.PortableExecutable; +using System.Runtime.InteropServices; +using System.Security.Cryptography; +using System.Text; +using Antlr4.Runtime; +using Antlr4.Runtime.Misc; +using Antlr4.Runtime.Tree; + +namespace ILAssembler +{ +#pragma warning disable CA1822 // Mark members as static + internal sealed partial class GrammarActions : ICILVisitor + { + GrammarResult ICILVisitor.VisitIidParamIndex(CILParser.IidParamIndexContext context) => VisitIidParamIndex(context); + public GrammarResult.Literal VisitIidParamIndex(CILParser.IidParamIndexContext context) + => context.int32() is CILParser.Int32Context int32 ? new(VisitInt32(int32).Value) : new(null); + + GrammarResult ICILVisitor.VisitMarshalBlob(CILParser.MarshalBlobContext context) => VisitMarshalBlob(context); + public GrammarResult.FormattedBlob VisitMarshalBlob(CILParser.MarshalBlobContext context) + { + var hexBytes = context.hexbyte(); + if (hexBytes.Length > 0) + { + var blob = new BlobBuilder(hexBytes.Length); + foreach (var hb in hexBytes) + { + blob.WriteByte(hb.Value); + } + return new(blob); + } + + return VisitNativeType(context.nativeType()); + } + + GrammarResult ICILVisitor.VisitMarshalClause(CILParser.MarshalClauseContext context) => VisitMarshalClause(context); + public GrammarResult.FormattedBlob VisitMarshalClause(CILParser.MarshalClauseContext context) + { + if (context.ChildCount == 0) + { + return new(new BlobBuilder(0)); + } + + return VisitMarshalBlob(context.marshalBlob()); + } + + GrammarResult ICILVisitor.VisitNativeType(CILParser.NativeTypeContext context) => VisitNativeType(context); + public GrammarResult.FormattedBlob VisitNativeType(CILParser.NativeTypeContext context) + { + if (context.nativeTypeElement() is not CILParser.NativeTypeElementContext element) + { + return new(new BlobBuilder()); + } + + CILParser.NativeTypeArrayPointerInfoContext[] arrayPointerInfo = context.nativeTypeArrayPointerInfo(); + if (arrayPointerInfo.Length == 0) + { + return VisitNativeTypeElement(element); + } + var prefix = new BlobBuilder(arrayPointerInfo.Length); + var elementType = VisitNativeTypeElement(element).Value; + var suffix = new BlobBuilder(); + + for (int i = arrayPointerInfo.Length - 1; i >= 0; i--) + { + if (arrayPointerInfo[i] is CILParser.PointerNativeTypeContext) + { + ReportWarning(DiagnosticIds.DeprecatedNativeType, + string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "pointer in array"), + context); + const int NATIVE_TYPE_PTR = 0x10; + prefix.WriteByte(NATIVE_TYPE_PTR); + } + else + { + prefix.WriteByte((byte)UnmanagedType.LPArray); + if (elementType.Count == 0) + { + // We need to have an element type for arrays, + // so write the invalid NATIVE_TYPE_MAX value so we have something parsable. + const int NATIVE_TYPE_MAX = 0x50; + elementType.WriteByte(NATIVE_TYPE_MAX); + } + } + } + + for (int i = 0; i < arrayPointerInfo.Length; i++) + { + if (arrayPointerInfo[i] is CILParser.PointerArrayTypeSizeContext size) + { + suffix.WriteCompressedInteger(0); + suffix.WriteCompressedInteger(VisitInt32(size.int32()).Value); + suffix.WriteCompressedInteger(0); + } + else if (arrayPointerInfo[i] is CILParser.PointerArrayTypeSizeParamIndexContext sizeParamIndex) + { + var ints = sizeParamIndex.int32(); + suffix.WriteCompressedInteger(VisitInt32(ints[1]).Value); + suffix.WriteCompressedInteger(VisitInt32(ints[0]).Value); + suffix.WriteCompressedInteger(1); // Write that the paramIndex parameter was specified + } + else if (arrayPointerInfo[i] is CILParser.PointerArrayTypeParamIndexContext paramIndex) + { + suffix.WriteCompressedInteger(VisitInt32(paramIndex.int32()).Value); + } + } + + prefix.LinkSuffix(elementType); + prefix.LinkSuffix(suffix); + return new(prefix); + } + + GrammarResult ICILVisitor.VisitNativeTypeElement(CILParser.NativeTypeElementContext context) => VisitNativeTypeElement(context); + public GrammarResult.FormattedBlob VisitNativeTypeElement(CILParser.NativeTypeElementContext context) + { + var blob = new BlobBuilder(); + if (context.dottedName() is CILParser.DottedNameContext typedef) + { + // Native type typedefs are not yet fully supported + // For now, report an error and return empty blob + string alias = VisitDottedName(typedef).Value; + ReportError(DiagnosticIds.TypedefNotFound, string.Format(DiagnosticMessageTemplates.TypedefNotFound, alias), context); + return new(blob); + } + + if (context.marshalType is null) + { + if (context.marshalBool is not null) + { + blob.WriteByte((byte)UnmanagedType.VariantBool); + } + else if (context.unsignedMarshalType is not null) + { + blob.WriteByte(context.unsignedMarshalType.Type switch + { + CILParser.INT8 => (byte)UnmanagedType.U1, + CILParser.INT16 => (byte)UnmanagedType.U2, + CILParser.INT32_ => (byte)UnmanagedType.U4, + CILParser.INT64_ => (byte)UnmanagedType.U8, + _ => throw new UnreachableException(), + }); + } + return new(blob); + } + + switch (context.marshalType.Type) + { + case CILParser.CUSTOM: + { + blob.WriteByte((byte)UnmanagedType.CustomMarshaler); + CILParser.CompQstringContext[] strings = context.compQstring(); + if (strings.Length == 4) + { + ReportWarning(DiagnosticIds.DeprecatedCustomMarshaller, + DiagnosticMessageTemplates.DeprecatedCustomMarshaller, + context); + blob.WriteSerializedString(VisitCompQstring(strings[0]).Value); + blob.WriteSerializedString(VisitCompQstring(strings[1]).Value); + blob.WriteSerializedString(VisitCompQstring(strings[2]).Value); + blob.WriteSerializedString(VisitCompQstring(strings[3]).Value); + } + else + { + Debug.Assert(strings.Length == 2); + blob.WriteCompressedInteger(0); + blob.WriteCompressedInteger(0); + blob.WriteSerializedString(VisitCompQstring(strings[0]).Value); + blob.WriteSerializedString(VisitCompQstring(strings[1]).Value); + } + break; + } + case CILParser.SYSSTRING: + blob.WriteByte((byte)UnmanagedType.ByValTStr); + blob.WriteCompressedInteger(VisitInt32(context.int32()).Value); + break; + case CILParser.ARRAY: + blob.WriteByte((byte)UnmanagedType.ByValArray); + blob.WriteCompressedInteger(VisitInt32(context.int32()).Value); + VisitNativeType(context.nativeType()).Value.WriteContentTo(blob); + break; + case CILParser.VARIANT: + ReportWarning(DiagnosticIds.DeprecatedNativeType, + string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "VARIANT"), + context); + const int NATIVE_TYPE_VARIANT = 0xe; + blob.WriteByte(NATIVE_TYPE_VARIANT); + break; +#pragma warning disable CS0618 // Type or member is obsolete + case CILParser.CURRENCY: + blob.WriteByte((byte)UnmanagedType.Currency); + break; +#pragma warning restore CS0618 // Type or member is obsolete + case CILParser.SYSCHAR: + ReportWarning(DiagnosticIds.DeprecatedNativeType, + string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "SYSCHAR"), + context); + const int NATIVE_TYPE_SYSCHAR = 0xd; + blob.WriteByte(NATIVE_TYPE_SYSCHAR); + break; + case CILParser.VOID: + ReportWarning(DiagnosticIds.DeprecatedNativeType, + string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "VOID"), + context); + const int NATIVE_TYPE_VOID = 0x1; + blob.WriteByte(NATIVE_TYPE_VOID); + break; + case CILParser.BOOL: + blob.WriteByte((byte)UnmanagedType.Bool); + break; + case CILParser.INT8: + blob.WriteByte((byte)UnmanagedType.I1); + break; + case CILParser.INT16: + blob.WriteByte((byte)UnmanagedType.I2); + break; + case CILParser.INT32_: + blob.WriteByte((byte)UnmanagedType.I4); + break; + case CILParser.INT64_: + blob.WriteByte((byte)UnmanagedType.I8); + break; + case CILParser.FLOAT32: + blob.WriteByte((byte)UnmanagedType.R4); + break; + case CILParser.FLOAT64_: + blob.WriteByte((byte)UnmanagedType.R8); + break; + case CILParser.ERROR: + blob.WriteByte((byte)UnmanagedType.Error); + break; + case CILParser.UINT8: + blob.WriteByte((byte)UnmanagedType.U1); + break; + case CILParser.UINT16: + blob.WriteByte((byte)UnmanagedType.U2); + break; + case CILParser.UINT32: + blob.WriteByte((byte)UnmanagedType.U4); + break; + case CILParser.UINT64: + blob.WriteByte((byte)UnmanagedType.U8); + break; + case CILParser.DECIMAL: + ReportWarning(DiagnosticIds.DeprecatedNativeType, + string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "DECIMAL"), + context); + const int NATIVE_TYPE_DECIMAL = 0x11; + blob.WriteByte(NATIVE_TYPE_DECIMAL); + break; + case CILParser.DATE: + ReportWarning(DiagnosticIds.DeprecatedNativeType, + string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "DATE"), + context); + const int NATIVE_TYPE_DATE = 0x12; + blob.WriteByte(NATIVE_TYPE_DATE); + break; + case CILParser.BSTR: + // Distinguish 'ansi bstr' (AnsiBStr) from plain 'bstr' (BStr) + if (context.ANSI() is not null) + { +#pragma warning disable CS0618 // Type or member is obsolete + blob.WriteByte((byte)UnmanagedType.AnsiBStr); +#pragma warning restore CS0618 + } + else + { + blob.WriteByte((byte)UnmanagedType.BStr); + } + break; + case CILParser.LPSTR: + blob.WriteByte((byte)UnmanagedType.LPStr); + break; + case CILParser.LPWSTR: + blob.WriteByte((byte)UnmanagedType.LPWStr); + break; + case CILParser.LPTSTR: + blob.WriteByte((byte)UnmanagedType.LPTStr); + break; + case CILParser.OBJECTREF: + ReportWarning(DiagnosticIds.DeprecatedNativeType, + string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "OBJECTREF"), + context); + const int NATIVE_TYPE_OBJECTREF = 0x18; + blob.WriteByte(NATIVE_TYPE_OBJECTREF); + break; + case CILParser.IUNKNOWN: + { + blob.WriteByte((byte)UnmanagedType.IUnknown); + if (VisitIidParamIndex(context.iidParamIndex()) is { Value: int index }) + { + blob.WriteCompressedInteger(index); + } + break; + } + case CILParser.IDISPATCH: + { + blob.WriteByte((byte)UnmanagedType.IDispatch); + if (VisitIidParamIndex(context.iidParamIndex()) is { Value: int index }) + { + blob.WriteCompressedInteger(index); + } + break; + } + case CILParser.STRUCT: + // Distinguish 'nested struct' from plain 'struct' + if (context.GetChild(0)?.GetText() == "nested") + { + ReportWarning(DiagnosticIds.DeprecatedNativeType, + string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "NESTEDSTRUCT"), + context); + const int NATIVE_TYPE_NESTEDSTRUCT = 0x21; + blob.WriteByte(NATIVE_TYPE_NESTEDSTRUCT); + } + else + { + blob.WriteByte((byte)UnmanagedType.Struct); + } + break; + case CILParser.INTERFACE: + { + blob.WriteByte((byte)UnmanagedType.Interface); + if (VisitIidParamIndex(context.iidParamIndex()) is { Value: int index }) + { + blob.WriteCompressedInteger(index); + } + break; + } + case CILParser.SAFEARRAY: + blob.WriteByte((byte)UnmanagedType.SafeArray); + blob.WriteCompressedInteger((int)VisitVariantType(context.variantType()).Value); + if (context.compQstring() is { Length: 1 } safeArrayCustomType) + { + string str = VisitCompQstring(safeArrayCustomType[0]).Value; + blob.WriteSerializedString(str); + } + else + { + blob.WriteCompressedInteger(0); + } + break; + case CILParser.INT: + blob.WriteByte((byte)UnmanagedType.SysInt); + break; + case CILParser.UINT: + blob.WriteByte((byte)UnmanagedType.SysUInt); + break; +#pragma warning disable CS0618 // Type or member is obsolete + case CILParser.BYVALSTR: + blob.WriteByte((byte)UnmanagedType.VBByRefStr); + break; + case CILParser.TBSTR: + blob.WriteByte((byte)UnmanagedType.TBStr); + break; +#pragma warning restore CS0618 // Type or member is obsolete + case CILParser.METHOD: + blob.WriteByte((byte)UnmanagedType.FunctionPtr); + break; + case CILParser.LPSTRUCT: + blob.WriteByte((byte)UnmanagedType.LPStruct); + break; +#pragma warning disable CS0618 // Type or member is obsolete + case CILParser.ANY: + blob.WriteByte((byte)UnmanagedType.AsAny); + break; +#pragma warning restore CS0618 // Type or member is obsolete + } + + return new(blob); + } + + GrammarResult ICILVisitor.VisitPinvAttr(CILParser.PinvAttrContext context) => VisitPinvAttr(context); + public GrammarResult.Flag VisitPinvAttr(CILParser.PinvAttrContext context) + { + if (context.int32() is CILParser.Int32Context int32) + { + return new((MethodImportAttributes)VisitInt32(int32).Value, ShouldAppend: false); + } + switch (context.GetText()) + { + case "nomangle": + return new(MethodImportAttributes.ExactSpelling); + case "ansi": + return new(MethodImportAttributes.CharSetAnsi); + case "unicode": + return new(MethodImportAttributes.CharSetUnicode); + case "autochar": + return new(MethodImportAttributes.CharSetAuto); + case "lasterr": + return new(MethodImportAttributes.SetLastError); + case "winapi": + return new(MethodImportAttributes.CallingConventionWinApi); + case "cdecl": + return new(MethodImportAttributes.CallingConventionCDecl); + case "stdcall": + return new(MethodImportAttributes.CallingConventionStdCall); + case "thiscall": + return new(MethodImportAttributes.CallingConventionThisCall); + case "fastcall": + return new(MethodImportAttributes.CallingConventionFastCall); + case "bestfit:on": + return new(MethodImportAttributes.BestFitMappingEnable); + case "bestfit:off": + return new(MethodImportAttributes.BestFitMappingDisable); + case "charmaperror:on": + return new(MethodImportAttributes.ThrowOnUnmappableCharEnable); + case "charmaperror:off": + return new(MethodImportAttributes.ThrowOnUnmappableCharDisable); + default: + throw new UnreachableException(); + } + } + + GrammarResult ICILVisitor.VisitPinvImpl(CILParser.PinvImplContext context) => VisitPinvImpl(context); + public GrammarResult.Literal<(string? ModuleName, string? EntryPointName, MethodImportAttributes Attributes)> VisitPinvImpl(CILParser.PinvImplContext context) + { + MethodImportAttributes attrs = MethodImportAttributes.None; + foreach (var attr in context.pinvAttr()) + { + attrs |= VisitPinvAttr(attr); + } + var names = context.compQstring(); + string? moduleName = names.Length > 0 ? VisitCompQstring(names[0]).Value : null; + string? entryPointName = names.Length > 1 ? VisitCompQstring(names[1]).Value : null; + return new((moduleName, entryPointName, attrs)); + } + + + GrammarResult ICILVisitor.VisitVariantType(CILParser.VariantTypeContext context) => VisitVariantType(context); + public GrammarResult.Literal VisitVariantType(CILParser.VariantTypeContext context) + { + if (context.variantTypeElement() is not CILParser.VariantTypeElementContext element) + { + return new(VarEnum.VT_EMPTY); + } + + VarEnum variant = VisitVariantTypeElement(element).Value; + // The 0th child is the variant element type. + for (int i = 1; i < context.ChildCount; i++) + { + ITerminalNode childToken = (ITerminalNode)context.children[i]; + if (childToken.Symbol.Type == CILParser.ARRAY_TYPE_NO_BOUNDS) + { + variant |= VarEnum.VT_ARRAY; + } + else if (childToken.Symbol.Type == CILParser.VECTOR) + { + variant |= VarEnum.VT_VECTOR; + } + else + { + Debug.Assert(childToken.Symbol.Type == CILParser.REF); + variant |= VarEnum.VT_BYREF; + } + } + return new(variant); + } + + GrammarResult ICILVisitor.VisitVariantTypeElement(CILParser.VariantTypeElementContext context) => VisitVariantTypeElement(context); + public GrammarResult.Literal VisitVariantTypeElement(CILParser.VariantTypeElementContext context) + { + return new(context.GetChild(0).Symbol.Type switch + { + CILParser.VARIANT => VarEnum.VT_VARIANT, + CILParser.CURRENCY => VarEnum.VT_CY, + CILParser.VOID => VarEnum.VT_VOID, + CILParser.BOOL => VarEnum.VT_BOOL, + CILParser.INT8 => VarEnum.VT_I1, + CILParser.INT16 => VarEnum.VT_I2, + CILParser.INT32_ => VarEnum.VT_I4, + CILParser.INT64_ => VarEnum.VT_I8, + CILParser.FLOAT32 => VarEnum.VT_R4, + CILParser.FLOAT64_ => VarEnum.VT_R8, + CILParser.UINT8 => VarEnum.VT_UI1, + CILParser.UINT16 => VarEnum.VT_UI2, + CILParser.UINT32 => VarEnum.VT_UI4, + CILParser.UINT64 => VarEnum.VT_UI8, + CILParser.PTR => VarEnum.VT_PTR, + CILParser.DECIMAL => VarEnum.VT_DECIMAL, + CILParser.DATE => VarEnum.VT_DATE, + CILParser.BSTR => VarEnum.VT_BSTR, + CILParser.LPSTR => VarEnum.VT_LPSTR, + CILParser.LPWSTR => VarEnum.VT_LPWSTR, + CILParser.IUNKNOWN => VarEnum.VT_UNKNOWN, + CILParser.IDISPATCH => VarEnum.VT_DISPATCH, + CILParser.SAFEARRAY => VarEnum.VT_SAFEARRAY, + CILParser.INT => VarEnum.VT_INT, + CILParser.UINT => VarEnum.VT_UINT, + CILParser.ERROR => VarEnum.VT_ERROR, + CILParser.HRESULT => VarEnum.VT_HRESULT, + CILParser.CARRAY => VarEnum.VT_CARRAY, + CILParser.USERDEFINED => VarEnum.VT_USERDEFINED, + CILParser.RECORD => VarEnum.VT_RECORD, + CILParser.FILETIME => VarEnum.VT_FILETIME, + CILParser.BLOB => VarEnum.VT_BLOB, + CILParser.STREAM => VarEnum.VT_STREAM, + CILParser.STORAGE => VarEnum.VT_STORAGE, + CILParser.STREAMED_OBJECT => VarEnum.VT_STREAMED_OBJECT, + CILParser.STORED_OBJECT => VarEnum.VT_STORED_OBJECT, + CILParser.BLOB_OBJECT => VarEnum.VT_BLOB_OBJECT, + CILParser.CF => VarEnum.VT_CF, + CILParser.CLSID => VarEnum.VT_CLSID, + _ => throw new UnreachableException() + }); + } + public GrammarResult VisitNativeTypeArrayPointerInfo(CILParser.NativeTypeArrayPointerInfoContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + public GrammarResult VisitPointerArrayTypeSize(CILParser.PointerArrayTypeSizeContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + public GrammarResult VisitPointerArrayTypeParamIndex(CILParser.PointerArrayTypeParamIndexContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + public GrammarResult VisitPointerNativeType(CILParser.PointerNativeTypeContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + public GrammarResult VisitPointerArrayTypeSizeParamIndex(CILParser.PointerArrayTypeSizeParamIndexContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + public GrammarResult VisitPointerArrayTypeNoSizeData(CILParser.PointerArrayTypeNoSizeDataContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.cs new file mode 100644 index 00000000000000..024546c663d1f4 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.cs @@ -0,0 +1,638 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Buffers.Binary; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using System.Reflection.PortableExecutable; +using System.Runtime.InteropServices; +using System.Security.Cryptography; +using System.Text; +using Antlr4.Runtime; +using Antlr4.Runtime.Misc; +using Antlr4.Runtime.Tree; + +namespace ILAssembler; + +internal sealed partial class GrammarActions +{ + internal void OnClassDeclaration(CILParser.ClassDeclContext context) + { + if (context.classHead() is not null || context.methodHead() is not null) + { + return; + } + + VisitClassDecl(context); + } + + public GrammarResult VisitClassDecl(CILParser.ClassDeclContext context) + { + bool isStandaloneCustomAttribute = + context.customAttrDecl().Length == 1 && + context.PARAM() is null; + if (!isStandaloneCustomAttribute) + { + _pendingClassCustomAttributeOwner = null; + } + + if (context.classHead() is not null || context.methodHead() is not null) + { + throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + } + + if (context.secDecl() is {} secDecl) + { + var declarativeSecurity = VisitSecDecl(secDecl).Value; + declarativeSecurity?.Parent = _currentTypeDefinition.PeekOrDefault(); + } + else if (context.TYPE() is not null && + context.typeSpec().Length == 1 && + context.customDescr() is { } interfaceAttribute) + { + var currentType = _currentTypeDefinition.PeekOrDefault(); + if (currentType is not null) + { + EntityRegistry.TypeEntity interfaceType = VisitTypeSpec(context.typeSpec()[0]).Value; + EntityRegistry.InterfaceImplementationEntity? implementation = + currentType.InterfaceImplementations.FirstOrDefault( + candidate => candidate.InterfaceType == interfaceType); + if (implementation is null) + { + implementation = + EntityRegistry.CreateUnrecordedInterfaceImplementation(currentType, interfaceType); + currentType.InterfaceImplementations.Add(implementation); + } + + VisitCustomDescr(interfaceAttribute).Value.Owner = implementation; + } + } + else if (context.fieldDecl() is {} fieldDecl) + { + _ = VisitFieldDecl(fieldDecl); + } + else if (context.dataDecl() is { } dataDecl) + { + _ = VisitDataDecl(dataDecl); + } + else if (context.extSourceSpec() is { } extSourceSpec) + { + _ = VisitExtSourceSpec(extSourceSpec); + } + else if (context.languageDecl() is { } languageDecl) + { + _ = VisitLanguageDecl(languageDecl); + } + else if (context.OVERRIDE() is not null) + { + var currentType = _currentTypeDefinition.PeekOrDefault(); + if (currentType is not null) + { + var typeSpecs = context.typeSpec(); + var methodNames = context.methodName(); + var callConventions = context.callConv(); + var returnTypes = context.type(); + var signatureArguments = context.sigArgs(); + var genericArities = context.genArity(); + + int bodySignatureIndex = context.METHOD().Length == 0 ? 0 : 1; + BlobBuilder declarationSignature = BuildMethodReferenceSignature( + callConventions[0], + returnTypes[0], + signatureArguments[0], + genericArities.Length > 0 ? VisitGenArity(genericArities[0]).Value : 0); + BlobBuilder bodySignature = context.METHOD().Length == 0 + ? declarationSignature + : BuildMethodReferenceSignature( + callConventions[bodySignatureIndex], + returnTypes[bodySignatureIndex], + signatureArguments[bodySignatureIndex], + genericArities.Length > bodySignatureIndex + ? VisitGenArity(genericArities[bodySignatureIndex]).Value + : 0); + + string bodyName = VisitMethodName(methodNames[1]).Value; + EntityRegistry.MethodDefinitionEntity[] bodyMethods = currentType.Methods + .Where(method => + method.Name == bodyName && + method.MethodSignature is not null && + method.MethodSignature.ContentEquals(bodySignature)) + .Take(2) + .ToArray(); + if (bodyMethods.Length != 1) + { + ReportError( + DiagnosticIds.InvalidMetadataToken, + $"Override body method '{bodyName}' could not be resolved uniquely", + context); + return GrammarResult.SentinelValue.Result; + } + + EntityRegistry.MethodDefinitionEntity bodyMethod = bodyMethods[0]; + EntityRegistry.MemberReferenceEntity declaration = + _entityRegistry.CreateLazilyRecordedMemberReference( + VisitTypeSpec(typeSpecs[0]).Value, + VisitMethodName(methodNames[0]).Value, + declarationSignature); + currentType.MethodImplementations.Add( + EntityRegistry.CreateUnrecordedMethodImplementation(bodyMethod, declaration)); + } + } + else if (context.int32() is {} int32) + { + // .pack or .size + string keyword = context.GetChild(0).GetText(); + int value = VisitInt32(int32).Value; + var currentType = _currentTypeDefinition.PeekOrDefault(); + if (currentType is not null) + { + if (keyword == ".pack") + { + currentType.PackingSize = value; + } + else if (keyword == ".size") + { + currentType.ClassSize = value; + } + } + } + else if (context.propHead() is CILParser.PropHeadContext propHead) + { + var property = VisitPropHead(propHead).Value; + var currentType = _currentTypeDefinition.PeekOrDefault(); + if (currentType is not null) + { + currentType.Properties.Add(property); + foreach (var propDecl in context.propDecls().propDecl()) + { + if (propDecl.customAttrDecl() is { } customAttrDecl) + { + var customAttr = VisitCustomAttrDecl(customAttrDecl).Value; + if (customAttr is not null) + { + customAttr.Owner = property; + } + } + else if (VisitPropDecl(propDecl).Value is { } accessor) + { + property.Accessors.Add(accessor); + } + } + } + } + else if (context.eventHead() is CILParser.EventHeadContext eventHead) + { + var evt = VisitEventHead(eventHead).Value; + var currentType = _currentTypeDefinition.PeekOrDefault(); + if (currentType is not null) + { + currentType.Events.Add(evt); + foreach (var eventDecl in context.eventDecls().eventDecl()) + { + if (eventDecl.customAttrDecl() is { } customAttrDecl) + { + var customAttr = VisitCustomAttrDecl(customAttrDecl).Value; + if (customAttr is not null) + { + customAttr.Owner = evt; + } + } + else if (VisitEventDecl(eventDecl).Value is { } accessor) + { + evt.Accessors.Add(accessor); + } + } + } + } + else if (context.OVERRIDE() is not null) + { + var currentType = _currentTypeDefinition.PeekOrDefault(); + if (currentType is null) + { + throw new UnreachableException(); + } + + CILParser.CallConvContext[] callConvs = context.callConv(); + CILParser.TypeContext[] returnTypes = context.type(); + CILParser.TypeSpecContext[] owners = context.typeSpec(); + CILParser.MethodNameContext[] methodNames = context.methodName(); + CILParser.GenArityContext[] genericArities = context.genArity(); + CILParser.SigArgsContext[] parameterLists = context.sigArgs(); + + EntityRegistry.MemberReferenceEntity declaration; + EntityRegistry.MemberReferenceEntity body; + if (callConvs.Length == 2) + { + declaration = CreateExplicitMethodReference( + callConvs[0], returnTypes[0], owners[0], methodNames[0], genericArities[0], parameterLists[0]); + body = CreateExplicitMethodReference( + callConvs[1], returnTypes[1], owners[1], methodNames[1], genericArities[1], parameterLists[1]); + } + else + { + EntityRegistry.TypeEntity declarationOwner = VisitTypeSpec(owners[0]).Value; + string declarationName = VisitMethodName(methodNames[0]).Value; + EntityRegistry.TypeEntity bodyOwner = VisitTypeSpec(owners[1]).Value; + string bodyName = VisitMethodName(methodNames[1]).Value; + BlobBuilder bodySignature = CreateExplicitMethodSignature( + callConvs[0], returnTypes[0], genericArity: null, parameterLists[0]); + BlobBuilder declarationSignature = new(); + bodySignature.WriteContentTo(declarationSignature); + declaration = _entityRegistry.CreateLazilyRecordedMemberReference( + declarationOwner, declarationName, declarationSignature); + body = _entityRegistry.CreateLazilyRecordedMemberReference( + bodyOwner, bodyName, bodySignature); + } + + currentType.MethodImplementations.Add(EntityRegistry.CreateUnrecordedMethodImplementation(currentType, body, declaration)); + } + else if (isStandaloneCustomAttribute) + { + if (VisitCustomAttrDecl(context.customAttrDecl()[0]).Value is { } customAttr) + { + customAttr.Owner = + _pendingClassCustomAttributeOwner ?? + _currentTypeDefinition.PeekOrDefault(); + } + } + else if (context.PARAM() is not null) + { + var customAttrDeclarations = context.customAttrDecl(); + var currentType = _currentTypeDefinition.PeekOrDefault(); + if (currentType is not null && context.TYPE() is not null) + { + EntityRegistry.GenericParameterEntity? param = null; + if (context.int32() is { } int32ctx) + { + int index = VisitInt32(int32ctx).Value; + if (index >= 0 && index < currentType.GenericParameters.Count) + { + param = currentType.GenericParameters[index]; + } + else + { + ReportError( + DiagnosticIds.GenericParameterIndexOutOfRange, + string.Format(DiagnosticMessageTemplates.GenericParameterIndexOutOfRange, index), + context); + } + } + else if (context.dottedName() is { } dn) + { + string name = VisitDottedName(dn).Value; + foreach (var genericParam in currentType.GenericParameters) + { + if (genericParam.Name == name) + { + param = genericParam; + break; + } + } + } + if (param is not null) + { + foreach (var attr in customAttrDeclarations ?? Array.Empty()) + { + var customAttrDecl = VisitCustomAttrDecl(attr).Value; + customAttrDecl?.Owner = param; + } + _pendingClassCustomAttributeOwner = param; + } + } + else if (currentType is not null && context.CONSTRAINT() is not null) + { + EntityRegistry.GenericParameterEntity? param = null; + if (context.int32() is { } int32ctx) + { + int index = VisitInt32(int32ctx).Value; + if (index >= 0 && index < currentType.GenericParameters.Count) + { + param = currentType.GenericParameters[index]; + } + else + { + ReportError( + DiagnosticIds.GenericParameterIndexOutOfRange, + string.Format(DiagnosticMessageTemplates.GenericParameterIndexOutOfRange, index), + context); + } + } + else if (context.dottedName() is { } dn) + { + string name = VisitDottedName(dn).Value; + foreach (var genericParam in currentType.GenericParameters) + { + if (genericParam.Name == name) + { + param = genericParam; + break; + } + } + } + if (param is not null) + { + var baseType = VisitTypeSpec(context.typeSpec()[0]).Value; + EntityRegistry.GenericParameterConstraintEntity? constraint = + param.Constraints.FirstOrDefault(entity => entity.BaseType == baseType); + if (constraint is null) + { + constraint = EntityRegistry.CreateGenericConstraint(baseType); + constraint.Owner = param; + param.Constraints.Add(constraint); + currentType.GenericParameterConstraints.Add(constraint); + } + foreach (var attr in customAttrDeclarations ?? Array.Empty()) + { + var customAttrDecl = VisitCustomAttrDecl(attr).Value; + customAttrDecl?.Owner = constraint; + } + _pendingClassCustomAttributeOwner = constraint; + } + } + } + + return GrammarResult.SentinelValue.Result; + } + +#pragma warning disable CA1822 // Mark members as static + GrammarResult ICILVisitor.VisitEventAttr(CILParser.EventAttrContext context) => VisitEventAttr(context); + public GrammarResult.Flag VisitEventAttr(CILParser.EventAttrContext context) + { + return context.GetText() switch + { + "specialname" => new(EventAttributes.SpecialName), + "rtspecialname" => new(0), // COMPAT: Ignore + _ => throw new UnreachableException(), + }; + } + + GrammarResult ICILVisitor.VisitEventDecl(CILParser.EventDeclContext context) => VisitEventDecl(context); + public GrammarResult.Literal<(MethodSemanticsAttributes, EntityRegistry.EntityBase)?> VisitEventDecl(CILParser.EventDeclContext context) + { + if (context.ChildCount != 2) + { + return new(null); + } + string accessor = context.GetChild(0).GetText(); + EntityRegistry.EntityBase memberReference = VisitMethodRef(context.methodRef()).Value; + MethodSemanticsAttributes methodSemanticsAttributes = accessor switch + { + ".addon" => MethodSemanticsAttributes.Adder, + ".removeon" => MethodSemanticsAttributes.Remover, + ".fire" => MethodSemanticsAttributes.Raiser, + ".other" => MethodSemanticsAttributes.Other, + _ => throw new UnreachableException(), + }; + return new((methodSemanticsAttributes, memberReference)); + } + + GrammarResult ICILVisitor.VisitEventDecls(CILParser.EventDeclsContext context) => VisitEventDecls(context); + public GrammarResult.Sequence<(MethodSemanticsAttributes, EntityRegistry.EntityBase)> VisitEventDecls(CILParser.EventDeclsContext context) + => new( + context.eventDecl() + .Select(decl => VisitEventDecl(decl).Value) + .Where(decl => decl is not null) + .Select(decl => decl!.Value).ToImmutableArray()); + + GrammarResult ICILVisitor.VisitEventHead(CILParser.EventHeadContext context) => VisitEventHead(context); + public GrammarResult.Literal VisitEventHead(CILParser.EventHeadContext context) + { + string name = VisitDottedName(context.dottedName()).Value; + EventAttributes eventAttributes = context.eventAttr().Select(attr => VisitEventAttr(attr).Value).Aggregate((EventAttributes)0, (a, b) => a | b); + return new(new EntityRegistry.EventEntity(eventAttributes, VisitTypeSpec(context.typeSpec()).Value, name)); + } + + GrammarResult ICILVisitor.VisitFieldAttr(CILParser.FieldAttrContext context) => VisitFieldAttr(context); + public GrammarResult.Flag VisitFieldAttr(CILParser.FieldAttrContext context) + { + if (context.int32() is { } int32) + { + return new((FieldAttributes)VisitInt32(int32).Value, ShouldAppend: false); + } + + return context.GetText() switch + { + "static" => new(FieldAttributes.Static), + "public" => new(FieldAttributes.Public, FieldAttributes.FieldAccessMask), + "private" => new(FieldAttributes.Private, FieldAttributes.FieldAccessMask), + "family" => new(FieldAttributes.Family, FieldAttributes.FieldAccessMask), + "initonly" => new(FieldAttributes.InitOnly), + "rtspecialname" => new(FieldAttributes.RTSpecialName), + "specialname" => new(FieldAttributes.SpecialName), + "assembly" => new(FieldAttributes.Assembly, FieldAttributes.FieldAccessMask), + "famandassem" => new(FieldAttributes.FamANDAssem, FieldAttributes.FieldAccessMask), + "famorassem" => new(FieldAttributes.FamORAssem, FieldAttributes.FieldAccessMask), + "privatescope" => new(FieldAttributes.PrivateScope, FieldAttributes.FieldAccessMask), + "literal" => new(FieldAttributes.Literal), +#pragma warning disable SYSLIB0050 // FieldAttributes.NotSeralized is obsolete + "notserialized" => new(FieldAttributes.NotSerialized), +#pragma warning restore SYSLIB0050 // FieldAttributes.NotSeralized is obsolete + "volatile" => new(0), // COMPAT: volatile is not a field attribute; accepted for compatibility + _ => throw new UnreachableException() + }; + } + GrammarResult ICILVisitor.VisitFieldDecl(CILParser.FieldDeclContext context) => VisitFieldDecl(context); + public GrammarResult VisitFieldDecl(CILParser.FieldDeclContext context) + { + var fieldAttrs = context.fieldAttr().Select(VisitFieldAttr).Aggregate((FieldAttributes)0, (a, b) => a | b); + // COMPAT: Native ilasm implicitly adds SpecialName when RTSpecialName is set + if (fieldAttrs.HasFlag(FieldAttributes.RTSpecialName)) + { + fieldAttrs |= FieldAttributes.SpecialName; + } + var fieldType = VisitType(context.type()).Value; + var marshalBlobs = context.marshalBlob(); + var marshalBlob = marshalBlobs.Length > 0 ? VisitMarshalBlob(marshalBlobs[marshalBlobs.Length - 1]).Value : null; + string name = VisitDottedName(context.dottedName()).Value; + var rvaOffset = VisitAtOpt(context.atOpt()).Value; + var fieldOffset = VisitRepeatOpt(context.repeatOpt()).Value; + var constantValue = VisitInitOpt(context.initOpt()).Value; + + var signature = new BlobEncoder(new BlobBuilder()); + _ = signature.Field(); + fieldType.WriteContentTo(signature.Builder); + + var field = EntityRegistry.CreateUnrecordedFieldDefinition(fieldAttrs, _currentTypeDefinition.PeekOrDefault() ?? _entityRegistry.ModuleType, name, signature.Builder); + _lastFieldDefinition = field; + _pendingClassCustomAttributeOwner = field; + + if (field is not null) + { + field.MarshallingDescriptor = marshalBlob; + field.DataDeclarationName = rvaOffset; + field.Offset = fieldOffset; + if (constantValue is not NoConstantSentinel) + { + field.ConstantValue = constantValue; + field.HasConstant = true; + } + } + + return GrammarResult.SentinelValue.Result; + } + + GrammarResult ICILVisitor.VisitFieldInit(CILParser.FieldInitContext context) => VisitFieldInit(context); + public GrammarResult.Literal VisitFieldInit(CILParser.FieldInitContext context) + { + // fieldInit: fieldSerInit | compQstring | NULLREF; + if (context.NULLREF() is not null) + { + return new(null); + } + if (context.compQstring() is CILParser.CompQstringContext compQstring) + { + return new(VisitCompQstring(compQstring).Value); + } + if (context.fieldSerInit() is CILParser.FieldSerInitContext fieldSerInit) + { + // fieldSerInit returns a blob with type byte prefix - extract the actual value + var blob = VisitFieldSerInit(fieldSerInit).Value; + return new(ExtractConstantFromSerInit(blob)); + } + return new(null); + } + + public GrammarResult VisitFieldOrProp(CILParser.FieldOrPropContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + + GrammarResult ICILVisitor.VisitFieldRef(CILParser.FieldRefContext context) => VisitFieldRef(context); + public GrammarResult.Literal VisitFieldRef(CILParser.FieldRefContext context) + { + if (context.type() is not CILParser.TypeContext type) + { + // This is a typedef reference for a field member + string alias = VisitDottedName(context.dottedName()).Value; + var resolved = TryResolveTypedefAsMember(alias); + if (resolved is not null) + { + return new(resolved); + } + ReportError(DiagnosticIds.TypedefNotFound, string.Format(DiagnosticMessageTemplates.TypedefNotFound, alias), context); + return new(_entityRegistry.CreateLazilyRecordedMemberReference(_entityRegistry.ModuleType, alias, new BlobBuilder())); + } + + var fieldTypeSig = VisitType(type).Value; + EntityRegistry.TypeEntity definingType = _entityRegistry.ModuleType; + if (context.typeSpec() is CILParser.TypeSpecContext typeSpec) + { + definingType = VisitTypeSpec(typeSpec).Value; + } + + string name = VisitDottedName(context.dottedName()).Value; + + var fieldSig = new BlobBuilder(fieldTypeSig.Count + 1); + fieldSig.WriteByte((byte)SignatureKind.Field); + fieldTypeSig.WriteContentTo(fieldSig); + return new(_entityRegistry.CreateLazilyRecordedMemberReference(definingType, name, fieldSig)); + } + + GrammarResult ICILVisitor.VisitInitOpt(CILParser.InitOptContext context) => VisitInitOpt(context); + public GrammarResult.Literal VisitInitOpt(CILParser.InitOptContext context) + { + if (context.fieldInit() is CILParser.FieldInitContext fieldInit) + { + return VisitFieldInit(fieldInit); + } + // No initializer - return a sentinel indicating no constant + return new(NoConstantSentinel.Instance); + } + + GrammarResult ICILVisitor.VisitMemberRef(CILParser.MemberRefContext context) => VisitMemberRef(context); + public GrammarResult.Literal VisitMemberRef(CILParser.MemberRefContext context) + { + if (context.mdtoken() is CILParser.MdtokenContext mdToken) + { + return VisitMdtoken(mdToken); + } + + if (context.methodRef() is CILParser.MethodRefContext methodRef) + { + return VisitMethodRef(methodRef); + } + if (context.fieldRef() is CILParser.FieldRefContext fieldRef) + { + return VisitFieldRef(fieldRef); + } + + throw new UnreachableException(); + } + + GrammarResult ICILVisitor.VisitPropAttr(CILParser.PropAttrContext context) => VisitPropAttr(context); + public static GrammarResult.Flag VisitPropAttr(CILParser.PropAttrContext context) + { + return context.GetText() switch + { + "specialname" => new(PropertyAttributes.SpecialName), + "rtspecialname" => new(0), // COMPAT: Ignore + _ => throw new UnreachableException(), + }; + } + + GrammarResult ICILVisitor.VisitPropDecl(CILParser.PropDeclContext context) => VisitPropDecl(context); + public GrammarResult.Literal<(MethodSemanticsAttributes, EntityRegistry.EntityBase)?> VisitPropDecl(CILParser.PropDeclContext context) + { + if (context.ChildCount != 2) + { + return new(null); + } + string accessor = context.GetChild(0).GetText(); + EntityRegistry.EntityBase memberReference = VisitMethodRef(context.methodRef()).Value; + MethodSemanticsAttributes methodSemanticsAttributes = accessor switch + { + ".set" => MethodSemanticsAttributes.Setter, + ".get" => MethodSemanticsAttributes.Getter, + ".other" => MethodSemanticsAttributes.Other, + _ => throw new UnreachableException(), + }; + return new((methodSemanticsAttributes, memberReference)); + } + + GrammarResult ICILVisitor.VisitPropDecls(CILParser.PropDeclsContext context) => VisitPropDecls(context); + public GrammarResult.Sequence<(MethodSemanticsAttributes, EntityRegistry.EntityBase)> VisitPropDecls(CILParser.PropDeclsContext context) + => new( + context.propDecl() + .Select(decl => VisitPropDecl(decl).Value) + .Where(decl => decl is not null) + .Select(decl => decl!.Value).ToImmutableArray()); + + GrammarResult ICILVisitor.VisitPropHead(ILAssembler.CILParser.PropHeadContext context) => VisitPropHead(context); + public GrammarResult.Literal VisitPropHead(CILParser.PropHeadContext context) + { + var propAttrs = context.propAttr().Select(VisitPropAttr).Aggregate((PropertyAttributes)0, (a, b) => a | b); + var name = VisitDottedName(context.dottedName()).Value; + + var signature = new BlobBuilder(); + byte callConv = (byte)(VisitCallConv(context.callConv()).Value | (byte)SignatureKind.Property); + signature.WriteByte(callConv); + var args = VisitSigArgs(context.sigArgs()).Value; + signature.WriteCompressedInteger(args.Length); + VisitType(context.type()).Value.WriteContentTo(signature); + foreach (var arg in args) + { + arg.SignatureBlob.WriteContentTo(signature); + } + + // Handle initOpt to set the Constant table entry if a constant value is provided. + var constantValue = VisitInitOpt(context.initOpt()).Value; + var property = new EntityRegistry.PropertyEntity(propAttrs, signature, name); + if (constantValue is not NoConstantSentinel) + { + property.ConstantValue = constantValue; + property.HasConstant = true; + property.Attributes |= PropertyAttributes.HasDefault; + } + return new(property); + } + + GrammarResult ICILVisitor.VisitRepeatOpt(CILParser.RepeatOptContext context) => VisitRepeatOpt(context); + public GrammarResult.Literal VisitRepeatOpt(CILParser.RepeatOptContext context) => context.int32() is {} int32 ? new(VisitInt32(int32).Value) : new(null); + +#pragma warning restore CA1822 // Mark members as static +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs new file mode 100644 index 00000000000000..e8fc42f3c0912b --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs @@ -0,0 +1,867 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Buffers.Binary; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using System.Reflection.PortableExecutable; +using System.Runtime.InteropServices; +using System.Security.Cryptography; +using System.Text; +using Antlr4.Runtime; +using Antlr4.Runtime.Misc; +using Antlr4.Runtime.Tree; + +namespace ILAssembler; + +internal sealed partial class GrammarActions +{ + private readonly Dictionary _scopeRanges = new(); + private readonly Stack _scopeStack = new(); + private readonly Dictionary _catchTypes = new(); + private RuleContext? _methodOwner; + + internal void BeginMethod(CILParser.MethodHeadContext context) + { + ClearPendingCustomAttributeOwners(); + ResetMethodBodyState(); + _currentMethod = new CurrentMethodContext(VisitMethodHead(context).Value); + _methodOwner = context.Parent; + } + + private void EndMethod() + { + _methodOwner = null; + if (_currentMethod is not null) + { + if (_currentMethod.AllLocals.Count > 0) + { + BlobBuilder localsSignature = new(); + BlobEncoder encoder = new(localsSignature); + LocalVariablesEncoder localsEncoder = encoder.LocalVariableSignature(_currentMethod.AllLocals.Count); + foreach (SignatureArg local in _currentMethod.AllLocals) + { + local.SignatureBlob.WriteContentTo(localsEncoder.AddVariable().Builder); + } + + _currentMethod.Definition.LocalsSignature = _entityRegistry.GetOrCreateStandaloneSignature(localsSignature); + } + + ValidateLabelReferences(); + _currentMethod = null; + } + + ResetMethodBodyState(); + ClearPendingCustomAttributeOwners(); + } + + private void ResetMethodBodyState() + { + _scopeRanges.Clear(); + _scopeStack.Clear(); + _catchTypes.Clear(); + } + + internal void OnMethodDeclaration(CILParser.MethodDeclContext context) + { + // A method header that failed to parse never opened a method, so its body items have + // nothing to attach to. + if (_currentMethod is null) + { + return; + } + + if (TryProcessInstruction(context) || + context.scopeBlock() is not null || + context.sehBlock() is not null) + { + return; + } + + VisitMethodDecl(context); + } + + internal void BeginScope(CILParser.ScopeBlockContext context) + { + if (_currentMethod is null) + { + return; + } + + _scopeStack.Push(new ScopeFrame(context, CurrentMethodBodyOffset, _currentMethod.LocalsScopes.Count)); + } + + /// + /// Closes the lexical scope opened for , if one was opened. + /// + /// + /// This runs from the scopeBlock rule's finally block. It is keyed on the owning + /// context so that it is idempotent and so that an unopened scope (for example when the opening + /// brace failed to match) cannot pop a frame belonging to an enclosing scope. + /// + internal void EndScope(CILParser.ScopeBlockContext context) + { + if (_scopeStack.Count == 0 || !ReferenceEquals(_scopeStack.Peek().Context, context)) + { + return; + } + + ScopeFrame frame = _scopeStack.Pop(); + if (_currentMethod is not null && frame.LocalsScopeCount < _currentMethod.LocalsScopes.Count) + { + _currentMethod.LocalsScopes.RemoveRange( + frame.LocalsScopeCount, + _currentMethod.LocalsScopes.Count - frame.LocalsScopeCount); + } + + _scopeRanges[context] = (frame.Start, CurrentMethodBodyOffset); + } + + /// + /// Resolves the type of a catch clause before its handler body is parsed. + /// + /// + /// Native ilasm resolves the caught type as soon as it is parsed, so the type reference it + /// creates precedes any reference created by the handler body. Resolving the type when the + /// exception regions are recorded instead would reorder the emitted TypeRef rows. + /// + internal void OnCatchClause(CILParser.CatchClauseContext context) + { + if (_currentMethod is null) + { + return; + } + + _catchTypes[context] = VisitTypeSpec(context.typeSpec()).Value; + } + + internal void EndExceptionBlock(CILParser.SehBlockContext context) + { + if (_currentMethod is null || context.sehClauses() is not CILParser.SehClausesContext clauses) + { + return; + } + + (LabelHandle TryStart, LabelHandle TryEnd) tryRange = GetTryRange(context.tryBlock()); + + foreach (CILParser.SehClauseContext clause in clauses.sehClause()) + { + (LabelHandle HandlerStart, LabelHandle HandlerEnd) handlerRange = GetHandlerRange(clause.handlerBlock()); + if (clause.finallyClause() is not null) + { + AddExceptionRegion(new EntityRegistry.ExceptionRegion.FinallyRegion( + tryRange.TryStart, + tryRange.TryEnd, + handlerRange.HandlerStart, + handlerRange.HandlerEnd)); + } + else if (clause.faultClause() is not null) + { + AddExceptionRegion(new EntityRegistry.ExceptionRegion.FaultRegion( + tryRange.TryStart, + tryRange.TryEnd, + handlerRange.HandlerStart, + handlerRange.HandlerEnd)); + } + else if (clause.catchClause() is CILParser.CatchClauseContext catchClause) + { + if (_catchTypes.Remove(catchClause, out EntityRegistry.TypeEntity? catchType)) + { + AddExceptionRegion(new EntityRegistry.ExceptionRegion.CatchRegion( + tryRange.TryStart, + tryRange.TryEnd, + handlerRange.HandlerStart, + handlerRange.HandlerEnd, + catchType)); + } + } + else if (clause.filterClause() is CILParser.FilterClauseContext filterClause) + { + AddExceptionRegion(new EntityRegistry.ExceptionRegion.FilterRegion( + tryRange.TryStart, + tryRange.TryEnd, + handlerRange.HandlerStart, + handlerRange.HandlerEnd, + GetFilterStart(filterClause))); + } + } + } + + private void AddExceptionRegion(EntityRegistry.ExceptionRegion region) + { + Debug.Assert(_currentMethod is not null); + _currentMethod.Definition.ExceptionRegions.Add(region); + } + + private int CurrentMethodBodyOffset => _currentMethod?.Definition.MethodBody.Offset ?? 0; + + private LabelHandle GetOrCreateMethodLabel(CILParser.IdContext context) + { + Debug.Assert(_currentMethod is not null); + string name = VisitId(context).Value; + if (!_currentMethod.Labels.TryGetValue(name, out LabelHandle label)) + { + label = _currentMethod.Definition.MethodBody.DefineLabel(); + _currentMethod.Labels[name] = label; + } + + return label; + } + + private LabelHandle DefineMethodLabelAtOffset(int offset) + { + Debug.Assert(_currentMethod is not null); + LabelHandle label = _currentMethod.Definition.MethodBody.DefineLabel(); + _currentMethod.Definition.MethodBody.MarkLabel(label, offset); + return label; + } + + private (LabelHandle Start, LabelHandle End) GetTryRange(CILParser.TryBlockContext? context) + => context?.scopeBlock() is CILParser.ScopeBlockContext scope + ? GetScopeRange(scope) + : GetExplicitRange(context?.id(), context?.int32()); + + private (LabelHandle Start, LabelHandle End) GetHandlerRange(CILParser.HandlerBlockContext? context) + => context?.scopeBlock() is CILParser.ScopeBlockContext scope + ? GetScopeRange(scope) + : GetExplicitRange(context?.id(), context?.int32()); + + private LabelHandle GetFilterStart(CILParser.FilterClauseContext context) + { + if (context.scopeBlock() is CILParser.ScopeBlockContext scope) + { + return GetScopeRange(scope).Start; + } + + if (context.id() is CILParser.IdContext id) + { + return GetOrCreateMethodLabel(id); + } + + return context.int32() is CILParser.Int32Context offset + ? DefineMethodLabelAtOffset(VisitInt32(offset).Value) + : DefineMethodLabelAtOffset(CurrentMethodBodyOffset); + } + + private (LabelHandle Start, LabelHandle End) GetScopeRange(CILParser.ScopeBlockContext context) + { + if (!_scopeRanges.TryGetValue(context, out (int Start, int End) range)) + { + int offset = CurrentMethodBodyOffset; + range = (offset, offset); + } + + return ( + DefineMethodLabelAtOffset(range.Start), + DefineMethodLabelAtOffset(range.End)); + } + + /// + /// Resolves an explicit label or offset range, falling back to an empty range at the current + /// offset when error recovery left the range unmatched. + /// + private (LabelHandle Start, LabelHandle End) GetExplicitRange( + CILParser.IdContext[]? ids, + CILParser.Int32Context[]? offsets) + { + if (ids is { Length: 2 }) + { + return (GetOrCreateMethodLabel(ids[0]), GetOrCreateMethodLabel(ids[1])); + } + + if (offsets is { Length: 2 }) + { + return ( + DefineMethodLabelAtOffset(VisitInt32(offsets[0]).Value), + DefineMethodLabelAtOffset(VisitInt32(offsets[1]).Value)); + } + + int currentOffset = CurrentMethodBodyOffset; + return ( + DefineMethodLabelAtOffset(currentOffset), + DefineMethodLabelAtOffset(currentOffset)); + } + + private readonly record struct ScopeFrame(CILParser.ScopeBlockContext Context, int Start, int LocalsScopeCount); + + public GrammarResult VisitMethodDecl(CILParser.MethodDeclContext context) + { + Debug.Assert(_currentMethod is not null); + var currentMethod = _currentMethod!; + + if (context.EMITBYTE() is not null) + { + currentMethod.Definition.MethodBody.CodeBuilder.WriteByte((byte)VisitInt32(context.GetChild(0)).Value); + } + else if (context.ENTRYPOINT() is not null) + { + _entityRegistry.EntryPoint = currentMethod.Definition; + } + else if (context.ZEROINIT() is not null) + { + currentMethod.Definition.BodyAttributes = MethodBodyAttributes.InitLocals; + } + else if (context.MAXSTACK() is not null) + { + currentMethod.Definition.MaxStack = VisitInt32(context.GetChild(0)).Value; + } + else if (context.LOCALS() is not null) + { + if (context.ChildCount == 3) + { + // init keyword specified + currentMethod.Definition.BodyAttributes = MethodBodyAttributes.InitLocals; + } + Dictionary localsScope; + if (currentMethod.LocalsScopes.Count != 0) + { + localsScope = currentMethod.LocalsScopes[currentMethod.LocalsScopes.Count - 1]; + } + else + { + localsScope = new(); + currentMethod.LocalsScopes.Add(localsScope); + } + var newLocals = VisitSigArgs(context.sigArgs()).Value; + foreach (var loc in newLocals) + { + // BREAK-COMPAT: We don't allow specifying a local's slot via the [in], [out], or [opt] parameter attributes, or the custom int override. + // This only worked in ilasm due to how ilasm reused fields. + // We're only going to support allowing this tool to determine the slot numbers. + // This blocks two different locals in two different scopes from resuing the same slot + // but that is a very rare scenario (even using more than one .locals block in a method in IL is quite rare) + + // If the local is named, add it to our name-lookup dictionary. + // Otherwise, it will only be accessible via its index. + if (loc.Name is not null) + { + localsScope.TryAdd(loc.Name, currentMethod.AllLocals.Count); + } + currentMethod.AllLocals.Add(loc); + } + } + else if (context.labelDecl() is CILParser.LabelDeclContext labelDecl) + { + var labelId = labelDecl.id(); + string labelName = VisitId(labelId).Value; + currentMethod.DeclaredLabels.Add(labelName); + if (!currentMethod.Labels.TryGetValue(labelName, out var label)) + { + label = currentMethod.Definition.MethodBody.DefineLabel(); + currentMethod.Labels[labelName] = label; + } + currentMethod.Definition.MethodBody.MarkLabel(label); + } + else if (context.EXPORT() is not null) + { + // .export [ordinal] or .export [ordinal] as alias + int ordinal = VisitInt32(context.int32()[0]).Value; + string? alias = context.id() is { } aliasId ? VisitId(aliasId).Value : null; + + currentMethod.Definition.ExportOrdinal = ordinal; + currentMethod.Definition.ExportAlias = alias; + } + else if (context.VTENTRY() is not null) + { + // .vtentry vtableIndex : slotIndex + int vtableEntry = VisitInt32(context.int32()[0]).Value; + int vtableSlot = VisitInt32(context.int32()[1]).Value; + + currentMethod.Definition.VTableEntry = vtableEntry; + currentMethod.Definition.VTableSlot = vtableSlot; + } + else if (context.OVERRIDE() is not null) + { + EntityRegistry.TypeDefinitionEntity? currentType = _currentTypeDefinition.PeekOrDefault(); + if (currentType is null) + { + return GrammarResult.SentinelValue.Result; + } + + BlobBuilder signature = currentMethod.Definition.MethodSignature!; + if (context.callConv() is {} callConv) + { + // We have an explicitly specified signature, so we need to parse it. + signature = new(); + var callConvByte = VisitCallConv(callConv).Value; + var arity = VisitGenArity(context.genArity()).Value; + if (arity > 0) + { + callConvByte |= (byte)SignatureAttributes.Generic; + } + signature.WriteByte(callConvByte); + if (arity > 0) + { + signature.WriteCompressedInteger(arity); + } + var args = VisitSigArgs(context.sigArgs()).Value; + signature.WriteCompressedInteger(args.Length); + VisitType(context.type()).Value.WriteContentTo(signature); + foreach (var arg in args) + { + arg.SignatureBlob.WriteContentTo(signature); + } + } + + var ownerType = VisitTypeSpec(context.typeSpec()).Value; + var methodName = VisitMethodName(context.methodName()).Value; + var methodRef = _entityRegistry.CreateLazilyRecordedMemberReference(ownerType, methodName, signature); + currentType.MethodImplementations.Add(EntityRegistry.CreateUnrecordedMethodImplementation(currentMethod.Definition, methodRef)); + } + else if (context.PARAM() is not null) + { + // BREAK-COMPAT: We require attributes on parameters, generic parameters, and constraints + // to be specified directly after the .param directive, not at any point later in the method. + // This matches the IL outputted by ILDASM, ILSpy, and other tools in the ecosystem. + // Attributes not specified directly after the .param directive are applied to the method itself. + var customAttrDeclarations = context.customAttrDecl(); + if (context.TYPE() is not null) + { + // Type parameters + EntityRegistry.GenericParameterEntity? param = null; + if (context.int32() is { Length: > 0 } int32) + { + int index = VisitInt32(int32[0]).Value; + if (index < 0 || index >= currentMethod.Definition.GenericParameters.Count) + { + ReportError(DiagnosticIds.GenericParameterIndexOutOfRange, + string.Format(DiagnosticMessageTemplates.GenericParameterIndexOutOfRange, index), + context); + return GrammarResult.SentinelValue.Result; + } + param = currentMethod.Definition.GenericParameters[index]; + } + else + { + string name = VisitDottedName(context.dottedName()).Value; + foreach (var genericParam in currentMethod.Definition.GenericParameters) + { + if (genericParam.Name == name) + { + param = genericParam; + break; + } + } + if (param is null) + { + ReportError(DiagnosticIds.UnknownGenericParameter, + string.Format(DiagnosticMessageTemplates.UnknownGenericParameter, name), + context); + return GrammarResult.SentinelValue.Result; + } + } + foreach (var attr in customAttrDeclarations ?? Array.Empty()) + { + var customAttrDecl = VisitCustomAttrDecl(attr).Value; + customAttrDecl?.Owner = param; + } + } + else if (context.CONSTRAINT() is not null) + { + // constraints + EntityRegistry.GenericParameterEntity? param = null; + if (context.int32() is { Length: > 0 } int32) + { + int index = VisitInt32(int32[0]).Value; + if (index < 0 || index >= currentMethod.Definition.GenericParameters.Count) + { + ReportError(DiagnosticIds.GenericParameterIndexOutOfRange, + string.Format(DiagnosticMessageTemplates.GenericParameterIndexOutOfRange, index), + context); + return GrammarResult.SentinelValue.Result; + } + param = currentMethod.Definition.GenericParameters[index]; + } + else + { + string name = VisitDottedName(context.dottedName()).Value; + foreach (var genericParam in currentMethod.Definition.GenericParameters) + { + if (genericParam.Name == name) + { + param = genericParam; + break; + } + } + if (param is null) + { + ReportError(DiagnosticIds.UnknownGenericParameter, + string.Format(DiagnosticMessageTemplates.UnknownGenericParameter, name), + context); + return GrammarResult.SentinelValue.Result; + } + } + EntityRegistry.GenericParameterConstraintEntity? constraint = null; + var baseType = VisitTypeSpec(context.typeSpec()).Value; + foreach (var constraintEntity in param.Constraints) + { + if (constraintEntity.BaseType == baseType) + { + constraint = constraintEntity; + break; + } + } + if (constraint is null) + { + constraint = EntityRegistry.CreateGenericConstraint(baseType); + constraint.Owner = param; + param.Constraints.Add(constraint); + currentMethod.Definition.GenericParameterConstraints.Add(constraint); + } + foreach (var attr in customAttrDeclarations ?? Array.Empty()) + { + var customAttrDecl = VisitCustomAttrDecl(attr).Value; + customAttrDecl?.Owner = constraint; + } + } + else + { + // Adding attributes to parameters. + int index = VisitInt32(context.int32()[0]).Value; + if (index < 0 || index >= currentMethod.Definition.Parameters.Count) + { + ReportError(DiagnosticIds.ParameterIndexOutOfRange, + string.Format(DiagnosticMessageTemplates.ParameterIndexOutOfRange, index), + context); + return GrammarResult.SentinelValue.Result; + } + + // Handle initOpt to get the Constant table entry if a constant value is provided. + var constantValue = VisitInitOpt(context.initOpt()).Value; + var param = currentMethod.Definition.Parameters[index]; + if (constantValue is not NoConstantSentinel) + { + param.ConstantValue = constantValue; + param.HasConstant = true; + } + foreach (var attr in customAttrDeclarations ?? Array.Empty()) + { + var customAttrDecl = VisitCustomAttrDecl(attr).Value; + if (customAttrDecl is not null) + { + customAttrDecl.Owner = param; + param.HasCustomAttributes = true; + } + } + } + } + else if (context.secDecl() is {} secDecl) + { + var declarativeSecurity = VisitSecDecl(secDecl).Value; + declarativeSecurity?.Parent = currentMethod.Definition; + } + else if (context.customDescrInMethodBody() is {} customDescrInMethod) + { + var customAttr = VisitCustomDescrInMethodBody(customDescrInMethod).Value; + if (customAttr is not null) + { + customAttr.Owner = currentMethod.Definition; + } + } + else if (context.GetChild(0) is CILParser.InstrContext instr) + { + _ = VisitInstr(instr); + } + else + { + // Handle other methodDecl alternatives + var child = context.children[0]; + _ = child.Accept(this); + } + return GrammarResult.SentinelValue.Result; + } + +#pragma warning disable CA1822 // Mark members as static + GrammarResult ICILVisitor.VisitCatchClause(CILParser.CatchClauseContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + public GrammarResult VisitFaultClause(CILParser.FaultClauseContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + + GrammarResult ICILVisitor.VisitFilterClause(CILParser.FilterClauseContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + public GrammarResult VisitFinallyClause(CILParser.FinallyClauseContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + + GrammarResult ICILVisitor.VisitHandlerBlock(CILParser.HandlerBlockContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitImplAttr(ILAssembler.CILParser.ImplAttrContext context) => VisitImplAttr(context); + public GrammarResult.Flag VisitImplAttr(CILParser.ImplAttrContext context) + { + if (context.int32() is CILParser.Int32Context int32) + { + return new((MethodImplAttributes)VisitInt32(int32).Value, ShouldAppend: false); + } + string attribute = context.GetText(); + return attribute switch + { + "native" => new(MethodImplAttributes.Native, MethodImplAttributes.CodeTypeMask), + "cil" or "il" => new(MethodImplAttributes.IL, MethodImplAttributes.CodeTypeMask), + "optil" => new(MethodImplAttributes.OPTIL, MethodImplAttributes.CodeTypeMask), + "managed" => new(MethodImplAttributes.Managed, MethodImplAttributes.ManagedMask), + "unmanaged" => new(MethodImplAttributes.Unmanaged, MethodImplAttributes.ManagedMask), + "forwardref" => new(MethodImplAttributes.ForwardRef), + "preservesig" => new(MethodImplAttributes.PreserveSig), + "runtime" => new(MethodImplAttributes.Runtime, MethodImplAttributes.CodeTypeMask), + "internalcall" => new(MethodImplAttributes.InternalCall), + "synchronized" => new(MethodImplAttributes.Synchronized), + "noinlining" => new(MethodImplAttributes.NoInlining), + "aggressiveinlining" => new(MethodImplAttributes.AggressiveInlining), + "nooptimization" => new(MethodImplAttributes.NoOptimization), + "aggressiveoptimization" => new(MethodImplAttributes.AggressiveOptimization), + "async" => new(MethodImplAttributes.Async), + _ => throw new UnreachableException(), + }; + } + + GrammarResult ICILVisitor.VisitImplClause(CILParser.ImplClauseContext context) => VisitImplClause(context); + public GrammarResult.Sequence VisitImplClause(CILParser.ImplClauseContext context) => context.implList() is {} implList ? VisitImplList(implList) : new(ImmutableArray.Empty); + + GrammarResult ICILVisitor.VisitImplList(CILParser.ImplListContext context) => VisitImplList(context); + public GrammarResult.Sequence VisitImplList(CILParser.ImplListContext context) + { + var builder = ImmutableArray.CreateBuilder(); + foreach (var impl in context.typeSpec()) + { + builder.Add(EntityRegistry.CreateUnrecordedInterfaceImplementation(_currentTypeDefinition.PeekOrDefault()!, VisitTypeSpec(impl).Value)); + } + return new(builder.ToImmutable()); + } + + private void ValidateLabelReferences() + { + if (_currentMethod is null) + { + return; + } + + // Report errors for any labels that were referenced but never declared + foreach (var undefinedLabel in _currentMethod.UndefinedLabelReferences) + { + string labelName = undefinedLabel.Key; + ParserRuleContext context = undefinedLabel.Value; + + // Only report if the label was never declared + if (!_currentMethod.DeclaredLabels.Contains(labelName)) + { + ReportError(DiagnosticIds.LabelNotFound, + string.Format(DiagnosticMessageTemplates.LabelNotFound, labelName), + context); + } + } + } + + public GrammarResult VisitLabels(CILParser.LabelsContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + + GrammarResult ICILVisitor.VisitLabelDecl(CILParser.LabelDeclContext context) => VisitLabelDecl(context); + public GrammarResult VisitLabelDecl(CILParser.LabelDeclContext context) + { + var labelId = context.id(); + string labelName = VisitId(labelId).Value; + _currentMethod!.DeclaredLabels.Add(labelName); + if (!_currentMethod!.Labels.TryGetValue(labelName, out var label)) + { + label = _currentMethod.Definition.MethodBody.DefineLabel(); + _currentMethod.Labels[labelName] = label; + } + _currentMethod.Definition.MethodBody.MarkLabel(label); + return GrammarResult.SentinelValue.Result; + } + + GrammarResult ICILVisitor.VisitMethAttr(CILParser.MethAttrContext context) => VisitMethAttr(context); + public GrammarResult.Flag VisitMethAttr(CILParser.MethAttrContext context) + { + if (context.int32() is CILParser.Int32Context int32) + { + return new((MethodAttributes)VisitInt32(int32).Value, ShouldAppend: false); + } + string attribute = context.GetText(); + return attribute switch + { + "static" => new(MethodAttributes.Static), + "public" => new(MethodAttributes.Public, MethodAttributes.MemberAccessMask), + "private" => new(MethodAttributes.Private, MethodAttributes.MemberAccessMask), + "family" => new(MethodAttributes.Family, MethodAttributes.MemberAccessMask), + "final" => new(MethodAttributes.Final), + "specialname" => new(MethodAttributes.SpecialName), + "virtual" => new(MethodAttributes.Virtual), + "strict" => new(MethodAttributes.CheckAccessOnOverride), + "abstract" => new(MethodAttributes.Abstract), + "assembly" => new(MethodAttributes.Assembly, MethodAttributes.MemberAccessMask), + "famandassem" => new(MethodAttributes.FamANDAssem, MethodAttributes.MemberAccessMask), + "famorassem" => new(MethodAttributes.FamORAssem, MethodAttributes.MemberAccessMask), + "privatescope" => new(MethodAttributes.PrivateScope, MethodAttributes.MemberAccessMask), + "hidebysig" => new(MethodAttributes.HideBySig), + "newslot" => new(MethodAttributes.NewSlot), + "rtspecialname" => new(MethodAttributes.RTSpecialName), + "unmanagedexp" => new(MethodAttributes.UnmanagedExport), + "reqsecobj" => new(MethodAttributes.RequireSecObject), + _ => throw new UnreachableException(), + }; + } + + + public GrammarResult VisitMethodDecls(CILParser.MethodDeclsContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitMethodHead(CILParser.MethodHeadContext context) => VisitMethodHead(context); + public GrammarResult.Literal VisitMethodHead(CILParser.MethodHeadContext context) + { + string name = VisitMethodName(context.methodName()).Value; + var containingType = _currentTypeDefinition.PeekOrDefault() ?? _entityRegistry.ModuleType; + var methodDefinition = EntityRegistry.CreateUnrecordedMethodDefinition(containingType, name); + + BlobBuilder methodSignature = new(); + byte sigHeader = VisitCallConv(context.callConv()).Value; + + // Two-pass generic parameter processing for method params: + // Pass 1: Register all parameter names (without resolving constraints) + _currentMethod = new(methodDefinition); + var typarContexts = context.typarsClause()?.typars()?.typar() ?? Array.Empty(); + for (int i = 0; i < typarContexts.Length; i++) + { + var attributes = VisitTyparAttribs(typarContexts[i].typarAttribs()).Value; + var param = EntityRegistry.CreateGenericParameter(attributes, VisitDottedName(typarContexts[i].dottedName()).Value); + param.Owner = methodDefinition; + param.Index = i; + methodDefinition.GenericParameters.Add(param); + } + if (typarContexts.Length != 0) + { + sigHeader |= (byte)SignatureAttributes.Generic; + } + methodDefinition.MethodAttributes = context.methAttr().Aggregate((MethodAttributes)0, (acc, attr) => acc | VisitMethAttr(attr)); + + // COMPAT: Native ilasm implicitly adds RTSpecialName + SpecialName for .ctor/.cctor methods + if (name is ".ctor" or ".cctor") + { + methodDefinition.MethodAttributes |= MethodAttributes.RTSpecialName | MethodAttributes.SpecialName; + } + // COMPAT: Native ilasm implicitly adds SpecialName when RTSpecialName is set + else if (methodDefinition.MethodAttributes.HasFlag(MethodAttributes.RTSpecialName)) + { + methodDefinition.MethodAttributes |= MethodAttributes.SpecialName; + } + + if (methodDefinition.MethodAttributes.HasFlag(MethodAttributes.Abstract) && !methodDefinition.ContainingType.Attributes.HasFlag(TypeAttributes.Abstract)) + { + ReportWarning(DiagnosticIds.AbstractMethodNotInAbstractType, + string.Format(DiagnosticMessageTemplates.AbstractMethodNotInAbstractType, methodDefinition.Name), + context); + } + + (EntityRegistry.ModuleReferenceEntity Module, string? EntryPoint, MethodImportAttributes Attributes)? pInvokeInformation = null; + foreach (var pInvokeInfo in context.pinvImpl()) + { + var (moduleName, entryPoint, attributes) = VisitPinvImpl(pInvokeInfo).Value; + if (moduleName is null) + { + ReportError(DiagnosticIds.InvalidPInvokeSignature, + DiagnosticMessageTemplates.InvalidPInvokeSignature, + pInvokeInfo); + continue; + } + pInvokeInformation = (_entityRegistry.GetOrCreateModuleReference(moduleName, _ => { }), entryPoint ?? name, attributes); + } + methodDefinition.MethodImportInformation = pInvokeInformation; + + SignatureHeader parsedHeader = new(sigHeader); + if (methodDefinition.MethodAttributes.HasFlag(MethodAttributes.Static) && (parsedHeader.IsInstance || parsedHeader.HasExplicitThis)) + { + // Error on static + instance. + } + // COMPAT: Native ilasm auto-adds instance calling convention for non-static methods in class context + if (!methodDefinition.MethodAttributes.HasFlag(MethodAttributes.Static) + && !parsedHeader.IsInstance + && _currentTypeDefinition.Count > 0) + { + sigHeader |= (byte)SignatureAttributes.Instance; + parsedHeader = new(sigHeader); + } + if (parsedHeader.HasExplicitThis && !parsedHeader.IsInstance) + { + // Warn on explicit-this + non-instance + parsedHeader = new(sigHeader |= (byte)SignatureAttributes.Instance); + } + methodSignature.WriteByte(sigHeader); + if (typarContexts.Length != 0) + { + methodSignature.WriteCompressedInteger(typarContexts.Length); + } + // Pass 2: Resolve constraints (now all params are registered) + for (int i = 0; i < typarContexts.Length; i++) + { + var param = methodDefinition.GenericParameters[i]; + foreach (var constraint in VisitTyBound(typarContexts[i].tyBound()).Value) + { + constraint.Owner = param; + param.Constraints.Add(constraint); + methodDefinition.GenericParameterConstraints.Add(constraint); + } + } + + var args = VisitSigArgs(context.sigArgs()).Value; + methodSignature.WriteCompressedInteger(args.Length); + + SignatureArg returnValue = new(VisitParamAttr(context.paramAttr()).Value, VisitType(context.type()).Value, VisitMarshalClause(context.marshalClause()).Value, null); + + returnValue.SignatureBlob.WriteContentTo(methodSignature); + methodDefinition.Parameters.Add(EntityRegistry.CreateParameter(returnValue.Attributes, returnValue.Name, returnValue.MarshallingDescriptor, 0)); + for (int i = 0; i < args.Length; i++) + { + SignatureArg? arg = args[i]; + arg.SignatureBlob.WriteContentTo(methodSignature); + // COMPAT: Native ilasm auto-generates A_N names for unnamed parameters + string? paramName = arg.Name ?? $"A_{i}"; + methodDefinition.Parameters.Add(EntityRegistry.CreateParameter(arg.Attributes, paramName, arg.MarshallingDescriptor, i + 1)); + } + // We've parsed all signature information. We can reset the current method now (the caller will handle setting/unsetting it for the method body). + _currentMethod = null; + methodDefinition.SignatureHeader = parsedHeader; + methodDefinition.MethodSignature = methodSignature; + + methodDefinition.ImplementationAttributes = context.implAttr().Aggregate((MethodImplAttributes)0, (acc, attr) => acc | VisitImplAttr(attr)); + if (!EntityRegistry.TryAddMethodDefinitionToContainingType(methodDefinition)) + { + ReportError(DiagnosticIds.DuplicateMethod, + DiagnosticMessageTemplates.DuplicateMethod, + context); + } + + return new(methodDefinition); + } + + GrammarResult ICILVisitor.VisitMethodName(CILParser.MethodNameContext context) => VisitMethodName(context); + public GrammarResult.String VisitMethodName(CILParser.MethodNameContext context) + { + // Error recovery in a malformed method header can leave the name unmatched. + if (context.ChildCount == 0) + { + return new(string.Empty); + } + + IParseTree child = context.GetChild(0); + return child switch + { + ITerminalNode terminal => new(terminal.Symbol.Text), + CILParser.DottedNameContext dottedName => VisitDottedName(dottedName), + _ => new(context.GetText()), + }; + } + + public GrammarResult VisitScopeBlock(CILParser.ScopeBlockContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + public GrammarResult VisitSehBlock(CILParser.SehBlockContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitSehClause(CILParser.SehClauseContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitSehClauses(CILParser.SehClausesContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitTryBlock(CILParser.TryBlockContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + +#pragma warning restore CA1822 // Mark members as static +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs new file mode 100644 index 00000000000000..d3d1af7f621adf --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs @@ -0,0 +1,122 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Buffers.Binary; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using System.Reflection.PortableExecutable; +using System.Runtime.InteropServices; +using System.Security.Cryptography; +using System.Text; +using Antlr4.Runtime; +using Antlr4.Runtime.Misc; +using Antlr4.Runtime.Tree; + +namespace ILAssembler +{ +#pragma warning disable CA1822 // Mark members as static + internal sealed partial class GrammarActions : ICILVisitor + { + GrammarResult ICILVisitor.VisitSecAction(CILParser.SecActionContext context) => VisitSecAction(context); + public static GrammarResult.Literal VisitSecAction(CILParser.SecActionContext context) + { + return context.GetText() switch + { + "request" => new(DeclarativeSecurityAction.Request), + "demand" => new(DeclarativeSecurityAction.Demand), + "assert" => new(DeclarativeSecurityAction.Assert), + "deny" => new(DeclarativeSecurityAction.Deny), + "permitonly" => new(DeclarativeSecurityAction.PermitOnly), + "linkcheck" => new(DeclarativeSecurityAction.LinkDemand), + "inheritcheck" => new(DeclarativeSecurityAction.InheritanceDemand), + "reqmin" => new(DeclarativeSecurityAction.RequestMinimum), + "reqopt" => new(DeclarativeSecurityAction.RequestOptional), + "reqrefuse" => new(DeclarativeSecurityAction.RequestRefuse), + "prejitgrant" => new(DeclarativeSecurityAction.PrejitGrant), + "prejitdeny" => new(DeclarativeSecurityAction.PrejitDeny), + "noncasdemand" => new(DeclarativeSecurityAction.NonCasDemand), + "noncaslinkdemand" => new(DeclarativeSecurityAction.NonCasLinkDemand), + "noncasinheritance" => new(DeclarativeSecurityAction.NonCasInheritanceDemand), + _ => throw new UnreachableException() + }; + } + GrammarResult ICILVisitor.VisitSecAttrBlob(CILParser.SecAttrBlobContext context) => VisitSecAttrBlob(context); + public GrammarResult.FormattedBlob VisitSecAttrBlob(CILParser.SecAttrBlobContext context) + { + var blob = new BlobBuilder(); + + string attributeName = string.Empty; + + if (context.typeSpec() is CILParser.TypeSpecContext typeSpec && VisitTypeSpec(typeSpec).Value is EntityRegistry.IHasReflectionNotation reflectionNotation) + { + attributeName = reflectionNotation.ReflectionNotation; + } + else if (context.SQSTRING() is { } sqstring) + { + attributeName = StringHelpers.ParseQuotedString(sqstring.GetText()); + } + + blob.WriteSerializedString(attributeName); + VisitCustomBlobNVPairs(context.customBlobNVPairs()).Value.WriteContentTo(blob); + + return new(blob); + } + + GrammarResult ICILVisitor.VisitSecAttrSetBlob(CILParser.SecAttrSetBlobContext context) => VisitSecAttrSetBlob(context); + public GrammarResult.FormattedBlob VisitSecAttrSetBlob(CILParser.SecAttrSetBlobContext context) + { + BlobBuilder blob = new(); + var secAttributes = context.secAttrBlob(); + blob.WriteByte((byte)'.'); + blob.WriteCompressedInteger(secAttributes.Length); + foreach (var secAttribute in secAttributes) + { + VisitSecAttrBlob(secAttribute).Value.WriteContentTo(blob); + } + return new(blob); + } + + GrammarResult ICILVisitor.VisitSecDecl(CILParser.SecDeclContext context) => VisitSecDecl(context); + public GrammarResult.Literal VisitSecDecl(CILParser.SecDeclContext context) + { + if (context.PERMISSION() is not null) + { + ReportError(DiagnosticIds.UnsupportedSecurityDeclaration, + DiagnosticMessageTemplates.UnsupportedSecurityDeclaration, + context); + return new(null); + } + DeclarativeSecurityAction action = VisitSecAction(context.secAction()).Value; + BlobBuilder value; + if (context.secAttrSetBlob() is CILParser.SecAttrSetBlobContext setBlob) + { + value = VisitSecAttrSetBlob(setBlob).Value; + } + else if (context.bytes() is CILParser.BytesContext bytes) + { + value = new(); + value.WriteBytes(VisitBytes(bytes)); + } + else if (context.compQstring() is CILParser.CompQstringContext str) + { + value = new BlobBuilder(); + value.WriteUTF16(VisitCompQstring(str).Value); + value.WriteUTF16("\0"); + } + else + { + throw new UnreachableException(); + } + return new(_entityRegistry.CreateDeclarativeSecurityAttribute(action, value)); + } + + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.cs new file mode 100644 index 00000000000000..c5318c6ac47799 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.cs @@ -0,0 +1,763 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Buffers.Binary; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using System.Reflection.PortableExecutable; +using System.Runtime.InteropServices; +using System.Security.Cryptography; +using System.Text; +using Antlr4.Runtime; +using Antlr4.Runtime.Misc; +using Antlr4.Runtime.Tree; + +namespace ILAssembler +{ +#pragma warning disable CA1822 // Mark members as static + internal sealed partial class GrammarActions : ICILVisitor + { + GrammarResult ICILVisitor.VisitBound(CILParser.BoundContext context) => VisitBound(context); + public GrammarResult.Literal<(int? Lower, int? Upper)> VisitBound(CILParser.BoundContext context) + { + bool hasEllipsis = context.ELLIPSIS() is not null; + var indices = context.int32(); + + if (indices.Length == 0) + { + // Empty or standalone "..." + return new((null, null)); + } + + int firstValue = VisitInt32(indices[0]).Value; + + return (indices.Length, hasEllipsis) switch + { + (1, false) => new((0, firstValue)), + (1, true) => new((firstValue, null)), + (2, _) => new((firstValue, VisitInt32(indices[1]).Value - firstValue + 1)), + _ => throw new UnreachableException() + }; + } + + GrammarResult ICILVisitor.VisitBounds(CILParser.BoundsContext context) => VisitBounds(context); + public GrammarResult.Sequence<(int? Lower, int? Upper)> VisitBounds(CILParser.BoundsContext context) + { + return new(context.bound().Select(bound => VisitBound(bound).Value).ToImmutableArray()); + } + + GrammarResult ICILVisitor.VisitCallConv(CILParser.CallConvContext context) => VisitCallConv(context); + public GrammarResult.Literal VisitCallConv(CILParser.CallConvContext context) + { + if (context.callKind() is CILParser.CallKindContext callKind) + { + return new((byte)VisitCallKind(callKind).Value); + } + else if (context.int32() is CILParser.Int32Context int32) + { + return new((byte)VisitInt32(int32).Value); + } + else if (context.INSTANCE() is not null) + { + return new((byte)(VisitCallConv(context.callConv()).Value | (byte)SignatureAttributes.Instance)); + } + else if (context.EXPLICIT() is not null) + { + return new((byte)( + VisitCallConv(context.callConv()).Value | + (byte)(SignatureAttributes.ExplicitThis | SignatureAttributes.Instance))); + } + return new(0); + } + GrammarResult ICILVisitor.VisitCallKind(CILParser.CallKindContext context) => VisitCallKind(context); + public GrammarResult.Literal VisitCallKind(CILParser.CallKindContext context) + { + // callKind can be empty (/* EMPTY */) - return Default in that case + if (context.ChildCount == 0) + { + return new(SignatureCallingConvention.Default); + } + int childType = context.GetChild(context.ChildCount - 1).Symbol.Type; + return new(childType switch + { + CILParser.DEFAULT => SignatureCallingConvention.Default, + CILParser.VARARG => SignatureCallingConvention.VarArgs, + CILParser.CDECL => SignatureCallingConvention.CDecl, + CILParser.STDCALL => SignatureCallingConvention.StdCall, + CILParser.THISCALL => SignatureCallingConvention.ThisCall, + CILParser.FASTCALL => SignatureCallingConvention.FastCall, + CILParser.UNMANAGED => SignatureCallingConvention.Unmanaged, + _ => throw new UnreachableException() + }); + } + + private BlobBuilder BuildMethodReferenceSignature( + CILParser.CallConvContext callConvention, + CILParser.TypeContext returnType, + CILParser.SigArgsContext signatureArguments, + int genericArity) + { + var signature = new BlobBuilder(); + byte header = VisitCallConv(callConvention).Value; + if (genericArity > 0) + { + header |= (byte)SignatureAttributes.Generic; + } + + signature.WriteByte(header); + if (genericArity > 0) + { + signature.WriteCompressedInteger(genericArity); + } + + ImmutableArray arguments = VisitSigArgs(signatureArguments).Value; + signature.WriteCompressedInteger(arguments.Count(argument => !argument.IsSentinel)); + VisitType(returnType).Value.WriteContentTo(signature); + foreach (SignatureArg argument in arguments) + { + argument.SignatureBlob.WriteContentTo(signature); + } + + return signature; + } + GrammarResult ICILVisitor.VisitElementType(CILParser.ElementTypeContext context) => VisitElementType(context); + public GrammarResult.FormattedBlob VisitElementType(CILParser.ElementTypeContext context) + { + BlobBuilder blob = new(5); + if (context.OBJECT() is not null) + { + blob.WriteByte((byte)SignatureTypeCode.Object); + } + else if (context.className() is CILParser.ClassNameContext className) + { + EntityRegistry.TypeEntity typeEntity = VisitClassName(className).Value; + if (context.VALUE() is not null || context.VALUETYPE() is not null) + { + // Check for well-known value types that should use primitive type codes + if (TryGetPrimitiveTypeCode(typeEntity, isValueType: true) is { } vtPrimCode) + { + blob.WriteByte((byte)vtPrimCode); + } + else + { + blob.WriteByte((byte)SignatureTypeKind.ValueType); + blob.WriteTypeEntity(typeEntity); + } + } + else + { + // Check for well-known class types that should use primitive type codes + if (TryGetPrimitiveTypeCode(typeEntity, isValueType: false) is { } clsPrimCode) + { + blob.WriteByte((byte)clsPrimCode); + } + else + { + blob.WriteByte((byte)SignatureTypeKind.Class); + blob.WriteTypeEntity(typeEntity); + } + } + } + else if (context.callConv() is CILParser.CallConvContext callConv) + { + // Emit function pointer signature. + blob.WriteByte((byte)SignatureTypeCode.FunctionPointer); + byte sigCallConv = VisitCallConv(callConv).Value; + blob.WriteByte(sigCallConv); + var signatureArgs = VisitSigArgs(context.sigArgs()).Value; + int numArgs = signatureArgs.Count(arg => !arg.IsSentinel); + blob.WriteCompressedInteger(numArgs); + blob.LinkSuffix(VisitType(context.type()).Value); + foreach (var arg in signatureArgs) + { + blob.LinkSuffix(arg.SignatureBlob); + } + } + else if (context.ELLIPSIS() is not null) + { + blob.WriteByte((byte)SignatureTypeCode.Sentinel); + blob.LinkSuffix(VisitType(context.type()).Value); + } + else if (context.METHOD_TYPE_PARAMETER() is not null) + { + if (context.int32() is CILParser.Int32Context int32) + { + // COMPAT: Always write a reference to a generic method parameter by index + // even if we aren't in a method or the index is out of range. We want to be able to write invalid IL like this. + blob.WriteByte((byte)SignatureTypeCode.GenericMethodParameter); + blob.WriteCompressedInteger(VisitInt32(int32).Value); + } + else + { + string dottedName = VisitDottedName(context.dottedName()).Value; + if (_currentMethod is null) + { + ReportError(DiagnosticIds.MethodTypeParameterOutsideMethod, string.Format(DiagnosticMessageTemplates.MethodTypeParameterOutsideMethod, dottedName), context); + blob.WriteByte((byte)SignatureTypeCode.GenericMethodParameter); + blob.WriteCompressedInteger(0); + } + else + { + blob.WriteByte((byte)SignatureTypeCode.GenericMethodParameter); + bool foundParameter = false; + for (int i = 0; i < _currentMethod.Definition.GenericParameters.Count; i++) + { + EntityRegistry.GenericParameterEntity? genericParameter = _currentMethod.Definition.GenericParameters[i]; + if (genericParameter.Name == dottedName) + { + foundParameter = true; + blob.WriteCompressedInteger(i); + break; + } + } + if (!foundParameter) + { + // BREAK-COMPAT: ILASM would silently emit an invalid signature when a method uses an invalid method type parameter but doesn't have method type parameters. + // The signature used completely invalid undocumented codes (that were really sentinel values for how ilasm later detected errors due to how the parsing model worked with a YACC-based parser) + // and when a method had no type parameters, it didn't run the code to process out these values and emit errors. + // This seems like a scenario that doesn't need to be brought forward. + // Instead, we'll just emit a reference to "generic method parameter" 0 and report an error. + + ReportError(DiagnosticIds.GenericParameterNotFound, string.Format(DiagnosticMessageTemplates.GenericParameterNotFound, dottedName), context); + blob.WriteCompressedInteger(0); + } + } + } + } + else if (context.TYPE_PARAMETER() is not null) + { + if (context.int32() is CILParser.Int32Context int32) + { + // COMPAT: Always write a reference to a generic type parameter by index + // even if we aren't in a type or the index is out of range. We want to be able to write invalid IL like this. + blob.WriteByte((byte)SignatureTypeCode.GenericTypeParameter); + blob.WriteCompressedInteger(VisitInt32(int32).Value); + } + else + { + string dottedName = VisitDottedName(context.dottedName()).Value; + if (_currentTypeDefinition.Count == 0) + { + ReportError(DiagnosticIds.TypeParameterOutsideType, string.Format(DiagnosticMessageTemplates.TypeParameterOutsideType, dottedName), context); + blob.WriteByte((byte)SignatureTypeCode.GenericTypeParameter); + blob.WriteCompressedInteger(0); + } + else + { + blob.WriteByte((byte)SignatureTypeCode.GenericTypeParameter); + bool foundParameter = false; + for (int i = 0; i < _currentTypeDefinition.Peek().GenericParameters.Count; i++) + { + EntityRegistry.GenericParameterEntity? genericParameter = _currentTypeDefinition.Peek().GenericParameters[i]; + if (genericParameter.Name == dottedName) + { + foundParameter = true; + blob.WriteCompressedInteger(i); + break; + } + } + if (!foundParameter) + { + // BREAK-COMPAT: ILASM would silently emit an invalid signature when a type uses an invalid method type parameter but doesn't have any type parameters. + // The signature used completely invalid undocumented codes (that were really sentinel values for how ilasm later detected errors due to how the parsing model worked with a YACC-based parser) + // and when a method had no type parameters, it didn't run the code to process out these values and emit errors. + // This seems like a scenario that doesn't need to be brought forward. + // Instead, we'll just emit a reference to "generic method parameter" 0 and report an error. + + ReportError(DiagnosticIds.GenericParameterNotFound, string.Format(DiagnosticMessageTemplates.GenericParameterNotFound, dottedName), context); + blob.WriteCompressedInteger(0); + } + } + } + } + else if (context.TYPEDREF() is not null) + { + blob.WriteByte((byte)SignatureTypeCode.TypedReference); + } + else if (context.VOID() is not null) + { + blob.WriteByte((byte)SignatureTypeCode.Void); + } + else if (context.nativeInt() is not null) + { + blob.WriteByte((byte)SignatureTypeCode.IntPtr); + } + else if (context.nativeUint() is not null) + { + blob.WriteByte((byte)SignatureTypeCode.UIntPtr); + } + else if (context.simpleType() is CILParser.SimpleTypeContext simpleType) + { + blob.WriteByte((byte)VisitSimpleType(simpleType).Value); + } + else if (context.dottedName() is CILParser.DottedNameContext dottedName) + { + // Typedef reference - resolve and write the type blob + string alias = VisitDottedName(dottedName).Value; + var resolved = TryResolveTypedefAsTypeBlob(alias); + if (resolved is not null) + { + // Copy the content to avoid modifying the stored blob + resolved.WriteContentTo(blob); + } + else + { + ReportError(DiagnosticIds.TypedefNotFound, string.Format(DiagnosticMessageTemplates.TypedefNotFound, alias), context); + } + } + else + { + throw new UnreachableException(); + } + return new(blob); + } + GrammarResult ICILVisitor.VisitGenArity(CILParser.GenArityContext context) => VisitGenArity(context); + public GrammarResult.Literal VisitGenArity(CILParser.GenArityContext context) + => context.genArityNotEmpty() is CILParser.GenArityNotEmptyContext genArity ? VisitGenArityNotEmpty(genArity) : new(0); + + GrammarResult ICILVisitor.VisitGenArityNotEmpty(CILParser.GenArityNotEmptyContext context) => VisitGenArityNotEmpty(context); + public GrammarResult.Literal VisitGenArityNotEmpty(CILParser.GenArityNotEmptyContext context) => VisitInt32(context.int32()); + + GrammarResult ICILVisitor.VisitNativeInt(CILParser.NativeIntContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + GrammarResult ICILVisitor.VisitNativeUint(CILParser.NativeUintContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + + GrammarResult ICILVisitor.VisitMethodRef(CILParser.MethodRefContext context) => VisitMethodRef(context); + public GrammarResult.Literal VisitMethodRef(CILParser.MethodRefContext context) + { + if (context.mdtoken() is CILParser.MdtokenContext token) + { + return new(VisitMdtoken(token).Value); + } + if (context.dottedName() is CILParser.DottedNameContext dottedName) + { + // This is a typedef reference for a method member + string alias = VisitDottedName(dottedName).Value; + var resolved = TryResolveTypedefAsMember(alias); + if (resolved is not null) + { + return new(resolved); + } + ReportError(DiagnosticIds.TypedefNotFound, string.Format(DiagnosticMessageTemplates.TypedefNotFound, alias), context); + return new(_entityRegistry.CreateLazilyRecordedMemberReference(_entityRegistry.ModuleType, alias, new BlobBuilder())); + } + BlobBuilder methodRefSignature = new(); + if (context.callConv() is not CILParser.CallConvContext callConvCtx) + { + // Parse error recovery - callConv is missing + return new(_entityRegistry.CreateLazilyRecordedMemberReference(_entityRegistry.ModuleType, "", methodRefSignature)); + } + byte callConv = VisitCallConv(callConvCtx).Value; + EntityRegistry.TypeEntity owner = _entityRegistry.ModuleType; + if (context.typeSpec() is CILParser.TypeSpecContext typeSpec) + { + owner = VisitTypeSpec(typeSpec).Value; + } + string name = VisitMethodName(context.methodName()).Value; + BlobBuilder? methodSpecSignature = null; + int numGenericParameters = 0; + if (context.typeArgs() is CILParser.TypeArgsContext typeArgs) + { + var types = typeArgs.type(); + numGenericParameters = types.Length; + if (types.Length != 0) + { + methodSpecSignature = new(); + methodSpecSignature.WriteByte((byte)SignatureKind.MethodSpecification); + VisitTypeArgs(typeArgs).Value.WriteContentTo(methodSpecSignature); + } + } + else if (context.genArityNotEmpty() is CILParser.GenArityNotEmptyContext genArityNotEmpty) + { + numGenericParameters = VisitGenArityNotEmpty(genArityNotEmpty).Value; + } + if (numGenericParameters != 0) + { + callConv |= (byte)SignatureAttributes.Generic; + } + if (_expectInstance && (callConv & (byte)SignatureAttributes.Instance) == 0) + { + ReportWarning(DiagnosticIds.MissingInstanceCallConv, + DiagnosticMessageTemplates.MissingInstanceCallConv, + context); + callConv |= (byte)SignatureAttributes.Instance; + } + methodRefSignature.WriteByte(callConv); + if (numGenericParameters != 0) + { + methodRefSignature.WriteCompressedInteger(numGenericParameters); + } + var args = VisitSigArgs(context.sigArgs()).Value; + methodRefSignature.WriteCompressedInteger(args.Count(arg => !arg.IsSentinel)); + // Write return type + VisitType(context.type()).Value.WriteContentTo(methodRefSignature); + // Write arg signatures + foreach (var arg in args) + { + arg.SignatureBlob.WriteContentTo(methodRefSignature); + } + + var memberRef = _entityRegistry.CreateLazilyRecordedMemberReference(owner, name, methodRefSignature); + + if (methodSpecSignature is not null) + { + return new(_entityRegistry.GetOrCreateMethodSpecification(memberRef, methodSpecSignature)); + } + + return new(memberRef); + } + + private EntityRegistry.MemberReferenceEntity CreateExplicitMethodReference( + CILParser.CallConvContext callConv, + CILParser.TypeContext returnType, + CILParser.TypeSpecContext owner, + CILParser.MethodNameContext methodName, + CILParser.GenArityContext? genericArity, + CILParser.SigArgsContext parameterList) + { + EntityRegistry.TypeEntity ownerType = VisitTypeSpec(owner).Value; + string name = VisitMethodName(methodName).Value; + return _entityRegistry.CreateLazilyRecordedMemberReference( + ownerType, + name, + CreateExplicitMethodSignature(callConv, returnType, genericArity, parameterList)); + } + + private BlobBuilder CreateExplicitMethodSignature( + CILParser.CallConvContext callConv, + CILParser.TypeContext returnType, + CILParser.GenArityContext? genericArity, + CILParser.SigArgsContext parameterList) + { + BlobBuilder signature = new(); + byte signatureHeader = VisitCallConv(callConv).Value; + int arity = genericArity is null ? 0 : VisitGenArity(genericArity).Value; + if (arity != 0) + { + signatureHeader |= (byte)SignatureAttributes.Generic; + } + + signature.WriteByte(signatureHeader); + if (arity != 0) + { + signature.WriteCompressedInteger(arity); + } + + ImmutableArray parameters = VisitSigArgs(parameterList).Value; + signature.WriteCompressedInteger(parameters.Count(parameter => !parameter.IsSentinel)); + VisitType(returnType).Value.WriteContentTo(signature); + foreach (SignatureArg parameter in parameters) + { + parameter.SignatureBlob.WriteContentTo(signature); + } + + return signature; + } + GrammarResult ICILVisitor.VisitParamAttr(CILParser.ParamAttrContext context) => VisitParamAttr(context); + public GrammarResult.Literal VisitParamAttr(CILParser.ParamAttrContext context) + { + ParameterAttributes attributes = 0; + foreach (var element in context.paramAttrElement()) + { + attributes |= VisitParamAttrElement(element); + } + return new(attributes); + } + + GrammarResult ICILVisitor.VisitParamAttrElement(CILParser.ParamAttrElementContext context) => VisitParamAttrElement(context); + public GrammarResult.Flag VisitParamAttrElement(CILParser.ParamAttrElementContext context) + { + if (context.int32() is CILParser.Int32Context int32) + { + return new((ParameterAttributes)(VisitInt32(int32).Value + 1), ShouldAppend: false); + } + return context switch + { + { @in: not null } => new(ParameterAttributes.In), + { @out: not null } => new(ParameterAttributes.Out), + { opt: not null } => new(ParameterAttributes.Optional), + _ => throw new UnreachableException() + }; + } + + /// + /// Checks if a type entity is a well-known corelib type and returns its primitive type code. + /// Native ilasm uses primitive type codes for well-known types like System.String and System.Object + /// in signature blobs instead of class/valuetype TypeRef references. + /// + private static SignatureTypeCode? TryGetPrimitiveTypeCode(EntityRegistry.TypeEntity typeEntity, bool isValueType) + { + if (typeEntity is not EntityRegistry.TypeReferenceEntity typeRef) + { + return null; + } + + string name = typeRef.Name; + string ns = typeRef.Namespace; + + if (ns != "System") + { + return null; + } + + if (isValueType) + { + return name switch + { + "Boolean" => SignatureTypeCode.Boolean, + "Char" => SignatureTypeCode.Char, + "SByte" => SignatureTypeCode.SByte, + "Byte" => SignatureTypeCode.Byte, + "Int16" => SignatureTypeCode.Int16, + "UInt16" => SignatureTypeCode.UInt16, + "Int32" => SignatureTypeCode.Int32, + "UInt32" => SignatureTypeCode.UInt32, + "Int64" => SignatureTypeCode.Int64, + "UInt64" => SignatureTypeCode.UInt64, + "Single" => SignatureTypeCode.Single, + "Double" => SignatureTypeCode.Double, + "IntPtr" => SignatureTypeCode.IntPtr, + "UIntPtr" => SignatureTypeCode.UIntPtr, + "TypedReference" => SignatureTypeCode.TypedReference, + _ => null + }; + } + + return name switch + { + "String" => SignatureTypeCode.String, + "Object" => SignatureTypeCode.Object, + _ => null + }; + } + + GrammarResult ICILVisitor.VisitSigArg(CILParser.SigArgContext context) => VisitSigArg(context); + public GrammarResult.Literal VisitSigArg(CILParser.SigArgContext context) + { + if (context.ELLIPSIS() is not null) + { + return new(SignatureArg.CreateSentinelArgument()); + } + string? name = context.id() is CILParser.IdContext id ? VisitId(id).Value : null; + return new(new SignatureArg( + VisitParamAttr(context.paramAttr()).Value, + VisitType(context.type()).Value, + VisitMarshalClause(context.marshalClause()).Value, + name)); + } + + GrammarResult ICILVisitor.VisitSigArgs(CILParser.SigArgsContext context) => VisitSigArgs(context); + public GrammarResult.Sequence VisitSigArgs(CILParser.SigArgsContext context) => new([.. context.sigArg().Select(arg => VisitSigArg(arg).Value)]); + GrammarResult ICILVisitor.VisitSimpleType(CILParser.SimpleTypeContext context) => VisitSimpleType(context); + public GrammarResult.Literal VisitSimpleType(CILParser.SimpleTypeContext context) + { + // Handle 'unsigned intN' forms (2 children: 'unsigned' + intN keyword) + if (context.ChildCount == 2) + { + return new(context.GetChild(1).Symbol.Type switch + { + CILParser.INT8 => SignatureTypeCode.Byte, + CILParser.INT16 => SignatureTypeCode.UInt16, + CILParser.INT32_ => SignatureTypeCode.UInt32, + CILParser.INT64_ => SignatureTypeCode.UInt64, + _ => throw new UnreachableException() + }); + } + + return new(context.GetChild(0).Symbol.Type switch + { + CILParser.CHAR => SignatureTypeCode.Char, + CILParser.STRING => SignatureTypeCode.String, + CILParser.BOOL => SignatureTypeCode.Boolean, + CILParser.INT8 => SignatureTypeCode.SByte, + CILParser.INT16 => SignatureTypeCode.Int16, + CILParser.INT32_ => SignatureTypeCode.Int32, + CILParser.INT64_ => SignatureTypeCode.Int64, + CILParser.FLOAT32 => SignatureTypeCode.Single, + CILParser.FLOAT64_ => SignatureTypeCode.Double, + CILParser.UINT8 => SignatureTypeCode.Byte, + CILParser.UINT16 => SignatureTypeCode.UInt16, + CILParser.UINT32 => SignatureTypeCode.UInt32, + CILParser.UINT64 => SignatureTypeCode.UInt64, + _ => throw new UnreachableException() + }); + } + + GrammarResult ICILVisitor.VisitType(CILParser.TypeContext context) => VisitType(context); + public GrammarResult.FormattedBlob VisitType(CILParser.TypeContext context) + { + // These blobs will likely be very small, so use a smaller default size. + const int DefaultSignatureElementBlobSize = 10; + BlobBuilder prefix = new(DefaultSignatureElementBlobSize); + BlobBuilder suffix = new(DefaultSignatureElementBlobSize); + BlobBuilder elementType = VisitElementType(context.elementType()).Value; + + // Prefix blob writes outer modifiers first. + // Suffix blob writes inner modifiers first. + // Since all blobs are prefix blobs and only some have suffix data, + // We will go in reverse order to write the prefixes + // and then go in forward order to write the suffixes. + CILParser.TypeModifiersContext[] typeModifiers = context.typeModifiers(); + for (int i = typeModifiers.Length - 1; i >= 0; i--) + { + CILParser.TypeModifiersContext? modifier = typeModifiers[i]; + switch (modifier) + { + case CILParser.SZArrayModifierContext: + prefix.WriteByte((byte)SignatureTypeCode.SZArray); + break; + case CILParser.ArrayModifierContext: + prefix.WriteByte((byte)SignatureTypeCode.Array); + break; + case CILParser.ByRefModifierContext: + prefix.WriteByte((byte)SignatureTypeCode.ByReference); + break; + case CILParser.PtrModifierContext: + prefix.WriteByte((byte)SignatureTypeCode.Pointer); + break; + case CILParser.PinnedModifierContext: + prefix.WriteByte((byte)SignatureTypeCode.Pinned); + break; + case CILParser.RequiredModifierContext modreq: + prefix.WriteByte((byte)SignatureTypeCode.RequiredModifier); + prefix.WriteTypeEntity(VisitTypeSpec(modreq.typeSpec()).Value); + break; + case CILParser.OptionalModifierContext modopt: + prefix.WriteByte((byte)SignatureTypeCode.OptionalModifier); + prefix.WriteTypeEntity(VisitTypeSpec(modopt.typeSpec()).Value); + break; + case CILParser.GenericArgumentsModifierContext: + prefix.WriteByte((byte)SignatureTypeCode.GenericTypeInstance); + break; + } + } + + foreach (var modifier in typeModifiers) + { + switch (modifier) + { + case CILParser.ArrayModifierContext arr: + var bounds = VisitBounds(arr.bounds()).Value; + suffix.WriteCompressedInteger(bounds.Length); + // Count contiguous sizes from the start (stop at first null) + int numSizes = 0; + for (int bIdx = 0; bIdx < bounds.Length; bIdx++) + { + if (bounds[bIdx].Upper is null) + break; + numSizes++; + } + // Count contiguous lower bounds from the start (stop at first null) + int numLoBounds = 0; + for (int bIdx = 0; bIdx < bounds.Length; bIdx++) + { + if (bounds[bIdx].Lower is null) + break; + numLoBounds++; + } + suffix.WriteCompressedInteger(numSizes); + for (int bIdx = 0; bIdx < numSizes; bIdx++) + { + suffix.WriteCompressedInteger(bounds[bIdx].Upper.GetValueOrDefault()); + } + suffix.WriteCompressedInteger(numLoBounds); + for (int bIdx = 0; bIdx < numLoBounds; bIdx++) + { + suffix.WriteCompressedSignedInteger(bounds[bIdx].Lower.GetValueOrDefault()); + } + break; + case CILParser.GenericArgumentsModifierContext genericArgs: + VisitTypeArgs(genericArgs.typeArgs()).Value.WriteContentTo(suffix); + break; + } + } + + // Work around https://github.com/dotnet/runtime/issues/127243 + // by writing to a separate blob. + BlobBuilder fullBlob = new(elementType.Count + prefix.Count + suffix.Count); + prefix.WriteContentTo(fullBlob); + elementType.WriteContentTo(fullBlob); + suffix.WriteContentTo(fullBlob); + return new(fullBlob); + } + + GrammarResult ICILVisitor.VisitTypeArgs(CILParser.TypeArgsContext context) => VisitTypeArgs(context); + + public GrammarResult.FormattedBlob VisitTypeArgs(CILParser.TypeArgsContext context) + { + BlobBuilder blob = new(4); + var types = context.type(); + blob.WriteCompressedInteger(types.Length); + foreach (var type in types) + { + blob.LinkSuffix(VisitType(type).Value); + } + return new(blob); + } + + GrammarResult ICILVisitor.VisitTypeList(CILParser.TypeListContext context) => VisitTypeList(context); + public GrammarResult.Sequence VisitTypeList(CILParser.TypeListContext context) + { + CILParser.TypeSpecContext[] bounds = context.typeSpec(); + ImmutableArray.Builder builder = ImmutableArray.CreateBuilder(bounds.Length); + foreach (var typeSpec in bounds) + { + builder.Add(VisitTypeSpec(typeSpec).Value); + } + return new(builder.MoveToImmutable()); + } + + GrammarResult ICILVisitor.VisitTypeSpec(CILParser.TypeSpecContext context) => VisitTypeSpec(context); + public GrammarResult.Literal VisitTypeSpec(CILParser.TypeSpecContext context) + { + if (context.className() is CILParser.ClassNameContext className) + { + return new(VisitClassName(className).Value); + } + else if (context.dottedName() is CILParser.DottedNameContext dottedName) + { + string nameToResolve = VisitDottedName(dottedName).Value; + if (context.MODULE() is not null) + { + EntityRegistry.ModuleReferenceEntity? module = _entityRegistry.FindModuleReference(nameToResolve); + if (module is null) + { + // report error + return new(new EntityRegistry.FakeTypeEntity(MetadataTokens.ModuleReferenceHandle(0))); + } + return new(new EntityRegistry.FakeTypeEntity(module.Handle)); + } + else + { + return new(new EntityRegistry.FakeTypeEntity( + _entityRegistry.GetOrCreateAssemblyReference(nameToResolve, newRef => + { + // Report warning on implicit assembly reference creation. + }).Handle)); + } + } + else + { + Debug.Assert(context.type() != null); + return new(_entityRegistry.GetOrCreateTypeSpec(VisitType(context.type()).Value)); + } + } + + GrammarResult ICILVisitor.VisitOptionalModifier(CILParser.OptionalModifierContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + GrammarResult ICILVisitor.VisitSZArrayModifier(CILParser.SZArrayModifierContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + GrammarResult ICILVisitor.VisitRequiredModifier(CILParser.RequiredModifierContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + GrammarResult ICILVisitor.VisitPtrModifier(CILParser.PtrModifierContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + GrammarResult ICILVisitor.VisitPinnedModifier(CILParser.PinnedModifierContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + GrammarResult ICILVisitor.VisitGenericArgumentsModifier(CILParser.GenericArgumentsModifierContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + GrammarResult ICILVisitor.VisitByRefModifier(CILParser.ByRefModifierContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + GrammarResult ICILVisitor.VisitArrayModifier(CILParser.ArrayModifierContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs new file mode 100644 index 00000000000000..db3a860121559c --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs @@ -0,0 +1,715 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Buffers.Binary; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using System.Reflection.PortableExecutable; +using System.Runtime.InteropServices; +using System.Security.Cryptography; +using System.Text; +using Antlr4.Runtime; +using Antlr4.Runtime.Misc; +using Antlr4.Runtime.Tree; + +namespace ILAssembler; + +internal sealed partial class GrammarActions +{ + private readonly Stack _namespaceOwners = new(); + private readonly Stack _typeOwners = new(); + + internal void BeginNamespace(CILParser.NameSpaceHeadContext context) + { + ClearPendingCustomAttributeOwners(); + string namespaceName = VisitNameSpaceHead(context).Value; + string? outerNamespace = _currentNamespace.PeekOrDefault(); + _currentNamespace.Push(string.IsNullOrEmpty(outerNamespace) ? namespaceName : $"{outerNamespace}.{namespaceName}"); + _namespaceOwners.Push(context.Parent); + } + + internal void BeginType(CILParser.ClassHeadContext context) + { + ClearPendingCustomAttributeOwners(); + _currentTypeDefinition.Push(VisitClassHead(context).Value); + _typeOwners.Push(context.Parent); + } + + /// + /// Releases the namespace, type and method state that a top-level declaration introduced. + /// + /// + /// This runs from the decl rule's finally block so that a syntax error inside the + /// declaration body cannot leak a namespace, type or method scope into the following declarations. + /// + internal void EndDeclaration(CILParser.DeclContext context) + { + EndScopesOwnedBy(context); + if (context.nameSpaceHead() is not null || + context.classHead() is not null || + context.methodHead() is not null) + { + ClearPendingCustomAttributeOwners(); + } + } + + /// + /// Releases the type and method state that a class member declaration introduced. + /// + internal void EndClassDeclaration(CILParser.ClassDeclContext context) + { + EndScopesOwnedBy(context); + if (context.classHead() is not null || context.methodHead() is not null) + { + ClearPendingCustomAttributeOwners(); + } + } + + private void EndScopesOwnedBy(RuleContext owner) + { + if (ReferenceEquals(_methodOwner, owner)) + { + EndMethod(); + } + + if (_typeOwners.Count > 0 && ReferenceEquals(_typeOwners.Peek(), owner)) + { + EndType(); + } + + if (_namespaceOwners.Count > 0 && ReferenceEquals(_namespaceOwners.Peek(), owner)) + { + EndNamespace(); + } + } + + private void EndType() + { + _typeOwners.Pop(); + _currentTypeDefinition.Pop(); + ClearPendingCustomAttributeOwners(); + } + + private void EndNamespace() + { + _namespaceOwners.Pop(); + _currentNamespace.Pop(); + ClearPendingCustomAttributeOwners(); + } + + private void ResetTypeScopes() + { + _typeOwners.Clear(); + _currentTypeDefinition.Clear(); + _namespaceOwners.Clear(); + _currentNamespace.Clear(); + } + + /// + /// Drops the owners that a trailing .custom directive would bind to. + /// + /// + /// A trailing custom attribute only binds to the preceding field, generic parameter or generic + /// constraint within the same type body, so the pending owners must be dropped whenever a + /// namespace, type or method boundary is crossed. + /// + private void ClearPendingCustomAttributeOwners() + { + _lastFieldDefinition = null; + _pendingClassCustomAttributeOwner = null; + } + +#pragma warning disable CA1822 // Mark members as static + GrammarResult ICILVisitor.VisitClassAttr(CILParser.ClassAttrContext context) => VisitClassAttr(context); + + public GrammarResult.Literal<(GrammarResult.Flag Attribute, EntityRegistry.WellKnownBaseType? FallbackBase, bool RequireSealed)> VisitClassAttr(CILParser.ClassAttrContext context) + { + if (context.int32() is CILParser.Int32Context int32) + { + int value = VisitInt32(int32).Value; + // COMPAT: The VALUE and ENUM keywords use sentinel values to pass through the fallback base type + // in ILASM. These sentinel values can be provided through the "pass the value of the flag" feature, + // so we detect those old flags here and provide the correct fallback type. + bool requireSealed = false; + EntityRegistry.WellKnownBaseType? fallbackBase = null; + if ((value & 0x80000000) != 0) + { + requireSealed = true; + fallbackBase = EntityRegistry.WellKnownBaseType.System_ValueType; + } + if ((value & 0x40000000) != 0) + { + fallbackBase = EntityRegistry.WellKnownBaseType.System_Enum; + } + // Mask off the sentinel bits + value &= unchecked((int)~0xC0000000); + // COMPAT: When explicit flags are provided they always supercede previously set flags + // (other than the sentinel values) + return new((new((TypeAttributes)value, ShouldAppend: false), fallbackBase, requireSealed)); + } + + if (context.ENUM() is not null) + { + // COMPAT: ilasm implies the Sealed flag when using the 'value' keyword in a type declaration + // even when the 'enum' keyword is used. + return new((new(context.VALUE() is not null ? TypeAttributes.Sealed : 0), EntityRegistry.WellKnownBaseType.System_Enum, false)); + } + else if (context.VALUE() is not null) + { + // COMPAT: ilasm implies the Sealed flag when using the 'value' keyword in a type declaration + return new((new(TypeAttributes.Sealed), EntityRegistry.WellKnownBaseType.System_ValueType, true)); + } + else if (context.EXPLICIT() is not null) + { + return new((new(TypeAttributes.ExplicitLayout), null, false)); + } + else if (context.INTERFACE() is not null) + { + // COMPAT: interface implies abstract + return new((new(TypeAttributes.Interface | TypeAttributes.Abstract), null, false)); + } + + switch (context.GetText()) + { + case "public": + return new((new(TypeAttributes.Public, TypeAttributes.VisibilityMask), null, false)); + case "private": + return new((new(TypeAttributes.NotPublic, TypeAttributes.VisibilityMask), null, false)); + case "nestedpublic": + return new((new(TypeAttributes.NestedPublic, TypeAttributes.VisibilityMask), null, false)); + case "nestedprivate": + return new((new(TypeAttributes.NestedPrivate, TypeAttributes.VisibilityMask), null, false)); + case "nestedfamily": + return new((new(TypeAttributes.NestedFamily, TypeAttributes.VisibilityMask), null, false)); + case "nestedassembly": + return new((new(TypeAttributes.NestedAssembly, TypeAttributes.VisibilityMask), null, false)); + case "nestedfamandassem": + return new((new(TypeAttributes.NestedFamANDAssem, TypeAttributes.VisibilityMask), null, false)); + case "nestedfamorassem": + return new((new(TypeAttributes.NestedFamORAssem, TypeAttributes.VisibilityMask), null, false)); + case "ansi": + return new((new(TypeAttributes.AnsiClass, TypeAttributes.StringFormatMask), null, false)); + case "autochar": + return new((new(TypeAttributes.AutoClass, TypeAttributes.StringFormatMask), null, false)); + case "unicode": + return new((new(TypeAttributes.UnicodeClass, TypeAttributes.StringFormatMask), null, false)); + case "auto": + return new((new(TypeAttributes.AutoLayout, TypeAttributes.LayoutMask), null, false)); + case "sequential": + return new((new(TypeAttributes.SequentialLayout, TypeAttributes.LayoutMask), null, false)); + case "extended": + return new((new(TypeAttributes.ExtendedLayout, TypeAttributes.LayoutMask), null, false)); + case "sealed": + return new((new(TypeAttributes.Sealed), null, false)); + case "abstract": + return new((new(TypeAttributes.Abstract), null, false)); + case "import": + return new((new(TypeAttributes.Import), null, false)); + case "serializable": +#pragma warning disable SYSLIB0050 + return new((new(TypeAttributes.Serializable), null, false)); +#pragma warning restore SYSLIB0050 + case "windowsruntime": + return new((new(TypeAttributes.WindowsRuntime), null, false)); + case "beforefieldinit": + return new((new(TypeAttributes.BeforeFieldInit), null, false)); + case "specialname": + return new((new(TypeAttributes.SpecialName), null, false)); + case "rtspecialname": + return new((new(TypeAttributes.RTSpecialName), null, false)); + default: + return new((new((TypeAttributes)Enum.Parse(typeof(TypeAttributes), context.GetText(), true)), null, false)); + } + } + + public GrammarResult VisitClassDecls(CILParser.ClassDeclsContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + + GrammarResult ICILVisitor.VisitClassHead(CILParser.ClassHeadContext context) => VisitClassHead(context); + public GrammarResult.Literal VisitClassHead(CILParser.ClassHeadContext context) + { + string typeFullName = VisitDottedName(context.dottedName()).Value; + int typeFullNameLastDot = typeFullName.LastIndexOf('.'); + // A dot at position 0 is part of the name (e.g., ".GlobalStruct"), not a namespace separator + if (typeFullNameLastDot == 0) + { + typeFullNameLastDot = -1; + } + string typeNS; + if (_currentTypeDefinition.Count != 0) + { + if (typeFullNameLastDot == -1) + { + typeNS = string.Empty; + } + else + { + typeNS = typeFullName.Substring(0, typeFullNameLastDot); + } + } + else + { + if (typeFullNameLastDot == -1) + { + typeNS = _currentNamespace.PeekOrDefault() ?? string.Empty; + } + else + { + typeNS = $"{_currentNamespace.PeekOrDefault()}{typeFullName.Substring(0, typeFullNameLastDot)}"; + } + } + + bool isNewType = false; + + var typeDefinition = _entityRegistry.GetOrCreateTypeDefinition( + _currentTypeDefinition.PeekOrDefault(), + typeNS, + typeFullNameLastDot != -1 + ? typeFullName.Substring(typeFullNameLastDot + 1) + : typeFullName, + (newTypeDef) => + { + isNewType = true; + EntityRegistry.WellKnownBaseType? fallbackBase = _options.NoAutoInherit ? null : EntityRegistry.WellKnownBaseType.System_Object; + bool requireSealed = false; + var classAttrs = context.classAttr(); + newTypeDef.Attributes = classAttrs.Select(VisitClassAttr).Aggregate( + (TypeAttributes)0, + (acc, result) => + { + var (attribute, implicitBase, attrRequireSealed) = result.Value; + if (implicitBase is not null) + { + fallbackBase = implicitBase; + } + if (!attribute.ShouldAppend) + { + requireSealed = attrRequireSealed; + return attribute.Value; + } + requireSealed |= attrRequireSealed; + if (attribute.Value == TypeAttributes.RTSpecialName) + { + // COMPAT: ILASM ignores the rtspecialname directive on a type. + return acc; + } + if ((attribute.Value & TypeAttributes.Interface) != 0) + { + // COMPAT: interface implies abstract + return acc | TypeAttributes.Interface | TypeAttributes.Abstract; + } + // Use the Flag's | operator which handles group masks + // (visibility, layout, string format) correctly. + return acc | attribute; + }); + + + // Two-pass generic parameter processing: + // Pass 1: Register all parameter names (without resolving constraints) + var typarContexts = context.typarsClause()?.typars()?.typar() ?? Array.Empty(); + for (int i = 0; i < typarContexts.Length; i++) + { + var attributes = VisitTyparAttribs(typarContexts[i].typarAttribs()).Value; + var param = EntityRegistry.CreateGenericParameter(attributes, VisitDottedName(typarContexts[i].dottedName()).Value); + param.Owner = newTypeDef; + param.Index = i; + newTypeDef.GenericParameters.Add(param); + } + + // Push the type so that !T references in constraints, extends, and implements can resolve + _currentTypeDefinition.Push(newTypeDef); + + // Pass 2: Resolve constraints (now all params are registered and type is on stack) + for (int i = 0; i < typarContexts.Length; i++) + { + var param = newTypeDef.GenericParameters[i]; + foreach (var constraint in VisitTyBound(typarContexts[i].tyBound()).Value) + { + constraint.Owner = param; + param.Constraints.Add(constraint); + newTypeDef.GenericParameterConstraints.Add(constraint); + } + } + + if (context.extendsClause() is CILParser.ExtendsClauseContext extends) + { + newTypeDef.BaseType = VisitExtendsClause(context.extendsClause()).Value; + } + + if (context.implClause() is CILParser.ImplClauseContext impl) + { + newTypeDef.InterfaceImplementations.AddRange(VisitImplClause(context.implClause()).Value); + } + + _currentTypeDefinition.Pop(); + + // Interfaces should not have an implicit base type + if (newTypeDef.Attributes.HasFlag(TypeAttributes.Interface)) + { + fallbackBase = null; + } + + newTypeDef.BaseType ??= _entityRegistry.ResolveImplicitBaseType(fallbackBase); + + // When the user has provided a type definition for a type that directly inherits + // System.ValueType but has not sealed it, emit a warning and add the 'sealed' modifier. + if (!newTypeDef.Attributes.HasFlag(TypeAttributes.Sealed) && + (requireSealed // COMPAT: when both the sentinel values for 'value' and 'enum' are explicitly + // specified, the sealed modifier is required even though + // the base type isn't System.ValueType. + || _entityRegistry.SystemValueTypeType.Equals(newTypeDef.BaseType))) + { + _diagnostics.Add( + new Diagnostic( + DiagnosticIds.UnsealedValueType, + DiagnosticSeverity.Error, + string.Format(DiagnosticMessageTemplates.UnsealedValueType, newTypeDef.Name), + Location.From(context.dottedName().Stop, _documents))); + newTypeDef.Attributes |= TypeAttributes.Sealed; + } + }); + + if (!isNewType) + { + // Type was forward-referenced. Apply attributes, generic params, + // base type, and interface implementations that were deferred. + var classAttrs = context.classAttr(); + typeDefinition.Attributes = classAttrs.Select(VisitClassAttr).Aggregate( + typeDefinition.Attributes, + (acc, result) => + { + var (attribute, _, _) = result.Value; + if (!attribute.ShouldAppend) + return attribute.Value; + if ((attribute.Value & TypeAttributes.Interface) != 0) + return acc | TypeAttributes.Interface | TypeAttributes.Abstract; + return acc | attribute.Value; + }); + + if (typeDefinition.GenericParameters.Count == 0) + { + // Two-pass generic parameter processing for forward-referenced types + var typarContexts = context.typarsClause()?.typars()?.typar() ?? Array.Empty(); + for (int i = 0; i < typarContexts.Length; i++) + { + var attributes = VisitTyparAttribs(typarContexts[i].typarAttribs()).Value; + var param = EntityRegistry.CreateGenericParameter(attributes, VisitDottedName(typarContexts[i].dottedName()).Value); + param.Owner = typeDefinition; + param.Index = i; + typeDefinition.GenericParameters.Add(param); + } + + _currentTypeDefinition.Push(typeDefinition); + + // Pass 2: Resolve constraints + for (int i = 0; i < typarContexts.Length; i++) + { + var param = typeDefinition.GenericParameters[i]; + foreach (var constraint in VisitTyBound(typarContexts[i].tyBound()).Value) + { + constraint.Owner = param; + param.Constraints.Add(constraint); + typeDefinition.GenericParameterConstraints.Add(constraint); + } + } + } + else + { + _ = context.typarsClause().Accept(this); + _currentTypeDefinition.Push(typeDefinition); + } + + if (context.extendsClause() is CILParser.ExtendsClauseContext extends && typeDefinition.BaseType is null) + { + typeDefinition.BaseType = VisitExtendsClause(extends).Value; + } + else + { + _ = context.extendsClause()?.Accept(this); + } + + if (context.implClause() is CILParser.ImplClauseContext impl) + { + typeDefinition.InterfaceImplementations.AddRange(VisitImplClause(impl).Value); + } + + _currentTypeDefinition.Pop(); + } + + return new(typeDefinition); + } + + GrammarResult ICILVisitor.VisitClassName(CILParser.ClassNameContext context) => VisitClassName(context); + public GrammarResult.Literal VisitClassName(CILParser.ClassNameContext context) + { + if (context.THIS() is not null) + { + if (_currentTypeDefinition.Count == 0) + { + ReportError(DiagnosticIds.ThisOutsideClass, DiagnosticMessageTemplates.ThisOutsideClass, context); + return new(new EntityRegistry.FakeTypeEntity(default(TypeDefinitionHandle))); + } + var thisType = _currentTypeDefinition.Peek(); + return new(thisType); + } + else if (context.BASE() is not null) + { + if (_currentTypeDefinition.Count == 0) + { + ReportError(DiagnosticIds.BaseOutsideClass, DiagnosticMessageTemplates.BaseOutsideClass, context); + return new(new EntityRegistry.FakeTypeEntity(default(TypeDefinitionHandle))); + } + var baseType = _currentTypeDefinition.Peek().BaseType; + if (baseType is null) + { + ReportError(DiagnosticIds.NoBaseType, DiagnosticMessageTemplates.NoBaseType, context); + return new(new EntityRegistry.FakeTypeEntity(default(TypeDefinitionHandle))); + } + return new(baseType); + } + else if (context.NESTER() is not null) + { + if (_currentTypeDefinition.Count < 2) + { + ReportError(DiagnosticIds.NesterOutsideNestedClass, DiagnosticMessageTemplates.NesterOutsideNestedClass, context); + return new(new EntityRegistry.FakeTypeEntity(default(TypeDefinitionHandle))); + } + var nesterType = _currentTypeDefinition.Peek().ContainingType!; + return new(nesterType); + } + else if (context.slashedName() is CILParser.SlashedNameContext slashedName) + { + EntityRegistry.EntityBase? resolutionContext = null; + if (context.dottedName() is CILParser.DottedNameContext dottedAssemblyOrModuleName) + { + if (context.MODULE() is not null) + { + string moduleName = VisitDottedName(dottedAssemblyOrModuleName).Value; + resolutionContext = _entityRegistry.FindModuleReference(moduleName); + if (resolutionContext is null) + { + ReportError(DiagnosticIds.ModuleNotFound, string.Format(DiagnosticMessageTemplates.ModuleNotFound, moduleName), context); + return new(new EntityRegistry.FakeTypeEntity(default(TypeDefinitionHandle))); + } + } + else + { + resolutionContext = _entityRegistry.GetOrCreateAssemblyReference(VisitDottedName(dottedAssemblyOrModuleName).Value, newRef => { }); + } + } + else if (context.mdtoken() is CILParser.MdtokenContext typeRefScope) + { + resolutionContext = VisitMdtoken(typeRefScope).Value; + } + else if (context.PTR() is not null) + { + resolutionContext = new EntityRegistry.FakeTypeEntity(default(ModuleDefinitionHandle)); + } + + if (resolutionContext is not null) + { + EntityRegistry.TypeReferenceEntity typeRef = _entityRegistry.GetOrCreateTypeReference(resolutionContext, VisitSlashedName(slashedName).Value); + return new(typeRef); + } + + Debug.Assert(resolutionContext is null); + + return new(ResolveTypeDef()); + + // Resolve typedef references + EntityRegistry.TypeEntity ResolveTypeDef() + { + TypeName typeName = VisitSlashedName(slashedName).Value; + if (typeName.ContainingTypeName is null) + { + // Check for typedef. + var typedefResult = TryResolveTypedefAsType(typeName.DottedName); + if (typedefResult is not null) + { + return typedefResult; + } + } + + // COMPAT: Before creating a forward-reference TypeDef, check if the type + // matches a well-known corelib type. Native ilasm resolves unqualified + // references to types like System.String as TypeRefs from the corelib. + if (typeName.ContainingTypeName is null) + { + var (ns, nm) = NameHelpers.SplitDottedNameToNamespaceAndName(typeName.DottedName); + if (ns == "System" && nm is "String" or "Object" or "ValueType" or "Enum" + or "Type" or "Array" or "Delegate" or "MulticastDelegate" + or "Exception" or "Attribute") + { + var coreLib = _entityRegistry.GetCoreLibAssemblyReference(); + return _entityRegistry.GetOrCreateTypeReference(coreLib, typeName); + } + } + + Stack containingTypes = new(); + for (TypeName? containingType = typeName; containingType is not null; containingType = containingType.ContainingTypeName) + { + containingTypes.Push(containingType); + } + EntityRegistry.TypeDefinitionEntity? typeDef = null; + while (containingTypes.Count != 0) + { + TypeName containingType = containingTypes.Pop(); + + (string ns, string name) = NameHelpers.SplitDottedNameToNamespaceAndName(containingType.DottedName); + + typeDef = _entityRegistry.GetOrCreateTypeDefinition( + typeDef, + ns, + name, + _ => { }); + } + + return typeDef!; + } + } + else if (context.mdtoken() is CILParser.MdtokenContext typeToken) + { + EntityRegistry.EntityBase resolvedToken = VisitMdtoken(typeToken).Value; + + if (resolvedToken is not EntityRegistry.TypeEntity type) + { + return new(new EntityRegistry.FakeTypeEntity(resolvedToken.Handle)); + } + return new(type); + } + + throw new UnreachableException(); + } + + GrammarResult ICILVisitor.VisitClassSeq(CILParser.ClassSeqContext context) => VisitClassSeq(context); + public GrammarResult.FormattedBlob VisitClassSeq(CILParser.ClassSeqContext context) + { + BlobBuilder objSeqBlob = new(0); + foreach (var item in context.classSeqElement()) + { + objSeqBlob.LinkSuffix(VisitClassSeqElement(item).Value); + } + return new(objSeqBlob); + } + + GrammarResult ICILVisitor.VisitClassSeqElement(CILParser.ClassSeqElementContext context) => VisitClassSeqElement(context); + + public GrammarResult.FormattedBlob VisitClassSeqElement(CILParser.ClassSeqElementContext context) + { + BlobBuilder blob = new(); + if (context.className() is CILParser.ClassNameContext className) + { + if (VisitClassName(className).Value is EntityRegistry.IHasReflectionNotation notation) + { + blob.WriteSerializedString(notation.ReflectionNotation); + } + else + { + blob.WriteSerializedString(""); + } + return new(blob); + } + + blob.WriteSerializedString( + context.SQSTRING() is { } stringNode + ? StringHelpers.ParseQuotedString(stringNode.Symbol.Text) + : null); + return new(blob); + } + GrammarResult ICILVisitor.VisitExtendsClause(CILParser.ExtendsClauseContext context) => VisitExtendsClause(context); + + public GrammarResult.Literal VisitExtendsClause(CILParser.ExtendsClauseContext context) + { + if (context.typeSpec() is CILParser.TypeSpecContext typeSpec) + { + return new(VisitTypeSpec(typeSpec).Value); + } + else + { + return new(null); + } + } + + GrammarResult ICILVisitor.VisitNameSpaceHead(CILParser.NameSpaceHeadContext context) => VisitNameSpaceHead(context); + + public static GrammarResult.String VisitNameSpaceHead(CILParser.NameSpaceHeadContext context) => VisitDottedName(context.dottedName()); + + GrammarResult ICILVisitor.VisitTyBound(CILParser.TyBoundContext context) => VisitTyBound(context); + public GrammarResult.Sequence VisitTyBound(CILParser.TyBoundContext? context) + { + // context or typeList can be null when there are no constraints + if (context?.typeList() is not CILParser.TypeListContext typeList) + { + return new(ImmutableArray.Empty); + } + // Filter out null types (from unresolved type parameters) before creating constraints + return new(VisitTypeList(typeList).Value + .Where(t => t is not null) + .Select(EntityRegistry.CreateGenericConstraint) + .ToImmutableArray()); + } + + GrammarResult ICILVisitor.VisitTypar(CILParser.TyparContext context) => VisitTypar(context); + + public GrammarResult.Literal VisitTypar(CILParser.TyparContext context) + { + GenericParameterAttributes attributes = VisitTyparAttribs(context.typarAttribs()).Value; + EntityRegistry.GenericParameterEntity genericParameter = EntityRegistry.CreateGenericParameter(attributes, VisitDottedName(context.dottedName()).Value); + + foreach (var constraint in VisitTyBound(context.tyBound()).Value) + { + genericParameter.Constraints.Add(constraint); + } + + return new(genericParameter); + } + + GrammarResult ICILVisitor.VisitTyparAttrib(CILParser.TyparAttribContext context) => VisitTyparAttrib(context); + public GrammarResult.Flag VisitTyparAttrib(CILParser.TyparAttribContext context) + { + return context switch + { + { covariant: not null } => new(GenericParameterAttributes.Covariant), + { contravariant: not null } => new(GenericParameterAttributes.Contravariant), + { @class: not null } => new(GenericParameterAttributes.ReferenceTypeConstraint), + { valuetype: not null } => new(GenericParameterAttributes.NotNullableValueTypeConstraint), + { byrefLike: not null } => new(GenericParameterAttributes.AllowByRefLike), + { ctor: not null } => new(GenericParameterAttributes.DefaultConstructorConstraint), + { flags: CILParser.Int32Context int32 } => new((GenericParameterAttributes)VisitInt32(int32).Value), + _ => throw new UnreachableException() + }; + } + GrammarResult ICILVisitor.VisitTyparAttribs(CILParser.TyparAttribsContext context) => VisitTyparAttribs(context); + + public GrammarResult.Literal VisitTyparAttribs(CILParser.TyparAttribsContext context) => + new(context.typarAttrib() + .Select(VisitTyparAttrib) + .Aggregate( + (GenericParameterAttributes)0, (agg, attr) => agg | attr)); + + GrammarResult ICILVisitor.VisitTypars(CILParser.TyparsContext context) => VisitTypars(context); + public GrammarResult.Sequence VisitTypars(CILParser.TyparsContext context) + { + CILParser.TyparContext[] typeParameters = context.typar(); + ImmutableArray.Builder builder = ImmutableArray.CreateBuilder(typeParameters.Length); + + foreach (var typeParameter in typeParameters) + { + builder.Add(VisitTypar(typeParameter).Value); + } + return new(builder.MoveToImmutable()); + } + + GrammarResult ICILVisitor.VisitTyparsClause(CILParser.TyparsClauseContext context) => VisitTyparsClause(context); + public GrammarResult.Sequence VisitTyparsClause(CILParser.TyparsClauseContext context) => context.typars() is null ? new(ImmutableArray.Empty) : VisitTypars(context.typars()); + +#pragma warning restore CA1822 // Mark members as static +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs new file mode 100644 index 00000000000000..cb800b1da7030d --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs @@ -0,0 +1,29 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; + +namespace ILAssembler; + +internal sealed partial class GrammarActions +{ + /// + /// Resets the semantic state that must not flow from one document to the next. + /// + /// + /// The same instance compiles every document of a compilation so + /// that they share an entity registry. Every rule that introduces namespace, type, method or + /// scope state releases it from its own finally block, so this is only a safety net for + /// release builds. + /// + internal void BeginDocument() + { + Debug.Assert( + _currentMethod is null && _typeOwners.Count == 0 && _namespaceOwners.Count == 0 && _scopeStack.Count == 0, + "Namespace, type, method and scope state must be released by the owning rule's finally block."); + + EndMethod(); + ResetTypeScopes(); + ClearPendingCustomAttributeOwners(); + } +} diff --git a/src/tools/ilasm/src/ILAssembler/DocumentCompiler.cs b/src/tools/ilasm/src/ILAssembler/DocumentCompiler.cs index f499c616e418e2..412220f87aa4de 100644 --- a/src/tools/ilasm/src/ILAssembler/DocumentCompiler.cs +++ b/src/tools/ilasm/src/ILAssembler/DocumentCompiler.cs @@ -22,28 +22,22 @@ public sealed class DocumentCompiler Dictionary loadedDocuments = new(); ImmutableArray.Builder diagnostics = ImmutableArray.CreateBuilder(); - GrammarVisitor? visitor = null; + GrammarActions? actions = null; IReadOnlyDictionary? definedVariables = null; foreach (var document in documents) { loadedDocuments[document.Path!] = document; - var inputSource = new AntlrInputStream(document.Text) - { - name = document.Path - }; + StringCharStream inputSource = new(document.Text, document.Path); CILLexer lexer = new(inputSource); PreprocessedTokenSource preprocessor = new(lexer, path => { - var includedDocument = includedDocumentLoader(path); - var includedSource = new AntlrInputStream(includedDocument.Text) - { - name = includedDocument.Path - }; + SourceText includedDocument = includedDocumentLoader(path); + StringCharStream includedSource = new(includedDocument.Text, includedDocument.Path); loadedDocuments[includedDocument.Path!] = includedDocument; return new CILLexer(includedSource); - }, text => new CILLexer(new AntlrInputStream(text)), definedVariables); + }, text => new CILLexer(new StringCharStream(text)), definedVariables); preprocessor.OnPreprocessorSyntaxError += (source, start, length, msg) => { @@ -57,29 +51,33 @@ public sealed class DocumentCompiler } }; - CILParser parser = new(new CommonTokenStream(preprocessor)); + actions ??= new GrammarActions(loadedDocuments, options, resourceLocator); + actions.BeginDocument(); + + CILParser parser = new(new UnbufferedTokenStream(preprocessor)) + { + Actions = actions, + BuildParseTree = false + }; parser.RemoveErrorListeners(); - var parserDiagnostics = ImmutableArray.CreateBuilder(); + ImmutableArray.Builder parserDiagnostics = ImmutableArray.CreateBuilder(); parser.AddErrorListener(new ParserErrorListener(parserDiagnostics, loadedDocuments)); - var result = parser.decls(); + _ = parser.decls(); + parser.VerifyParseTreeModesBalanced(); // Add parser diagnostics to the main list diagnostics.AddRange(parserDiagnostics); - visitor ??= new GrammarVisitor(loadedDocuments, options, resourceLocator); - - _ = result.Accept(visitor); - // Transfer defined constants to the next document definedVariables = preprocessor.DefinedVariables; } - if (visitor is null) + if (actions is null) { return (diagnostics.ToImmutable(), null); } - var image = visitor.BuildImage(); + var image = actions.BuildImage(); bool anyErrors = diagnostics.Any(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error); anyErrors |= image.Diagnostics.Any(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error); diff --git a/src/tools/ilasm/src/ILAssembler/GrammarVisitor.cs b/src/tools/ilasm/src/ILAssembler/GrammarVisitor.cs deleted file mode 100644 index 58808cd5be510e..00000000000000 --- a/src/tools/ilasm/src/ILAssembler/GrammarVisitor.cs +++ /dev/null @@ -1,6618 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System; -using System.Buffers.Binary; -using System.Collections.Generic; -using System.Collections.Immutable; -using System.Diagnostics; -using System.Globalization; -using System.IO; -using System.Linq; -using System.Reflection; -using System.Reflection.Metadata; -using System.Reflection.Metadata.Ecma335; -using System.Reflection.PortableExecutable; -using System.Runtime.InteropServices; -using System.Security.Cryptography; -using System.Text; -using Antlr4.Runtime; -using Antlr4.Runtime.Misc; -using Antlr4.Runtime.Tree; - -namespace ILAssembler -{ - internal abstract record GrammarResult - { - protected GrammarResult() { } - - public sealed record String(string Value) : GrammarResult; - - public sealed record Literal(T Value) : GrammarResult; - - public sealed record Sequence(ImmutableArray Value) : GrammarResult; - - /// - /// A formatted blob of bytes. - /// - /// The bytes of the blob. - public sealed record FormattedBlob(BlobBuilder Value) : GrammarResult; - - public sealed record SentinelValue - { - public static SentinelValue Instance { get; } = new(); - - public static Literal Result { get; } = new(Instance); - } - - public sealed record Flag(T Value, bool ShouldAppend = true) : GrammarResult - where T : struct, Enum - { - private readonly T _groupMask; - public Flag(T value, bool shouldAppend, T groupMask) - : this(value, shouldAppend) - { - _groupMask = groupMask; - } - public Flag(T value, T groupMask) - : this(value) - { - _groupMask = groupMask; - } - - public static T operator |(T lhs, Flag rhs) - { - if (!rhs.ShouldAppend) - { - return rhs.Value; - } - int lhsInt = Convert.ToInt32(lhs); - int maskInt = Convert.ToInt32(rhs._groupMask); - int valueInt = Convert.ToInt32(rhs.Value); - return (T)Enum.ToObject(typeof(T), (lhsInt & ~maskInt) | valueInt); - } - } - } - -#pragma warning disable CA1822 // Mark members as static - internal sealed class GrammarVisitor : ICILVisitor - { - private const string NodeShouldNeverBeDirectlyVisited = "This node should never be directly visited. It should be directly processed by its parent node."; - private readonly ImmutableArray.Builder _diagnostics = ImmutableArray.CreateBuilder(); - private readonly EntityRegistry _entityRegistry = new(); - private readonly IReadOnlyDictionary _documents; - private readonly Options _options; - private readonly MetadataBuilder _metadataBuilder = new(); - private readonly Func _resourceLocator; - - // Record the mapped field data directly into the blob to ensure we preserve ordering - private readonly BlobBuilder _mappedFieldData = new(); - private readonly Dictionary _mappedFieldDataNames = new(); - private readonly Dictionary> _mappedFieldDataReferenceFixups = new(); - private readonly BlobBuilder _manifestResources = new(); - - // Typedef aliases - maps alias name to the resolved entity - private readonly Dictionary _typedefs = new(); - - // Debug info tracking - private Guid _currentLanguageGuid = Guid.Empty; - private Guid _currentLanguageVendorGuid = Guid.Empty; - private Guid _currentDocumentTypeGuid = Guid.Empty; - private string? _currentDocumentPath; - private readonly Dictionary _documentHandles = new(); - private readonly MetadataBuilder _pdbBuilder = new(); - - // VTable fixup tracking - uses types from VTableFixupSupport - private readonly List _vtableFixups = new(); - - public GrammarVisitor(IReadOnlyDictionary documents, Options options, Func resourceLocator) - { - _documents = documents; - _options = options; - _resourceLocator = resourceLocator; - } - /// - /// Represents a typedef alias entry. - /// - private abstract record TypedefEntry - { - public sealed record Type(EntityRegistry.TypeEntity Entity) : TypedefEntry; - public sealed record TypeBlob(BlobBuilder Blob) : TypedefEntry; - public sealed record Member(EntityRegistry.EntityBase Entity) : TypedefEntry; - public sealed record CustomAttribute(EntityRegistry.EntityBase Constructor, BlobBuilder Value) : TypedefEntry; - } - - private void ReportDiagnostic(DiagnosticSeverity severity, string id, string message, Antlr4.Runtime.ParserRuleContext context) - { - var location = Location.From(context.Start, _documents); - _diagnostics.Add(new Diagnostic(id, severity, message, location)); - } - - private void ReportError(string id, string message, Antlr4.Runtime.ParserRuleContext context) - => ReportDiagnostic(DiagnosticSeverity.Error, id, message, context); - - private void ReportWarning(string id, string message, Antlr4.Runtime.ParserRuleContext context) - => ReportDiagnostic(DiagnosticSeverity.Warning, id, message, context); - - public (ImmutableArray Diagnostics, CompilationResult? Image) BuildImage() - { - // Default module name to output filename if no .module directive was provided - if (_entityRegistry.Module.Name is null && _options.OutputFileName is not null) - { - _entityRegistry.Module.Name = _options.OutputFileName; - } - - // Apply DebuggableAttribute AFTER all source declarations have been processed, - // so that GetCoreLibAssemblyReference() can find the correct corelib assembly ref - // declared in the source (e.g., System.Runtime) instead of creating a fallback mscorlib. - if (_entityRegistry.Assembly is not null && (_options.Debug || _options.DebugMode is not null)) - { - ApplyDebuggableAttribute(); - } - - // Return early if there are structural errors that prevent building valid metadata. - // However, allow errors in method bodies (ILA0016-0019) to pass through so we can - // emit the assembly with the errors reported. - // In error-tolerant mode, continue despite errors. - var structuralErrors = _diagnostics.Where(d => d.Severity == DiagnosticSeverity.Error && !IsRecoverableError(d.Id)); - if (structuralErrors.Any() && !_options.ErrorTolerant) - { - return (_diagnostics.ToImmutable(), null); - } - - // Check for vtable fixups and exports - collect export info - var exports = ImmutableArray.CreateBuilder(); - foreach (EntityRegistry.MethodDefinitionEntity method in GetParsedMethods()) - { - if (method.ExportOrdinal >= 0) - { - exports.Add(new VTableExportPEBuilder.ExportInfo( - method.ExportOrdinal, - method.ExportAlias ?? method.Name, - MetadataTokens.GetToken(method.Handle), - method.VTableEntry, - method.VTableSlot)); - } - } - - BlobBuilder ilStream = new(); - PseudoCustomAttributes.Lower(_entityRegistry, _diagnostics); - Blob mvidFixup = _entityRegistry.WriteContentTo(_metadataBuilder, ilStream, _mappedFieldDataNames, _options.Deterministic); - MetadataRootBuilder rootBuilder = new(_metadataBuilder, _options.MetadataVersion); - - // Compute metadata size from the MetadataSizes - // We need this for data label fixup RVA calculations - var sizes = rootBuilder.Sizes; - int metadataSize = ComputeMetadataSize(sizes); - - // Apply command-line overrides - Subsystem subsystem = _options.Subsystem ?? _subsystem; - int fileAlignment = _options.FileAlignment ?? _alignment; - long imageBase = _options.ImageBase ?? _imageBase; - ushort majorSubsystemVersion = _options.SubsystemVersion?.Major ?? 4; - ushort minorSubsystemVersion = _options.SubsystemVersion?.Minor ?? 0; - Machine machine = _options.Machine ?? Machine.I386; - - // Build DllCharacteristics from options - DllCharacteristics dllCharacteristics = DllCharacteristics.DynamicBase | DllCharacteristics.NxCompatible | DllCharacteristics.NoSeh | DllCharacteristics.TerminalServerAware; - if (_options.AppContainer) - { - dllCharacteristics |= DllCharacteristics.AppContainer; - } - if (_options.HighEntropyVA) - { - dllCharacteristics |= DllCharacteristics.HighEntropyVirtualAddressSpace; - } - if (_options.StripReloc) - { - dllCharacteristics &= ~DllCharacteristics.DynamicBase; - } - - Characteristics imageCharacteristics = Characteristics.ExecutableImage; - if (_options.Dll) - { - imageCharacteristics |= Characteristics.Dll; - } - if (machine is Machine.I386 or Machine.Arm) - { - imageCharacteristics |= Characteristics.Bit32Machine; - } - else if (machine is Machine.Amd64 or Machine.Arm64) - { - imageCharacteristics |= Characteristics.LargeAddressAware; - } - - // Compute stack reserve: command-line option overrides directive, which overrides default - ulong sizeOfStackReserve = (ulong)(_options.StackReserve ?? (_stackReserve != 0 ? _stackReserve : 0x00100000)); - - PEHeaderBuilder header = new( - machine: machine, - fileAlignment: fileAlignment, - imageBase: (ulong)imageBase, - subsystem: subsystem, - majorSubsystemVersion: majorSubsystemVersion, - minorSubsystemVersion: minorSubsystemVersion, - dllCharacteristics: dllCharacteristics, - imageCharacteristics: imageCharacteristics, - sizeOfStackReserve: sizeOfStackReserve); - - MethodDefinitionHandle entryPoint = default; - if (_entityRegistry.EntryPoint is not null) - { - entryPoint = (MethodDefinitionHandle)_entityRegistry.EntryPoint.Handle; - } - - // Build debug directory if we have any debug info - DebugDirectoryBuilder? debugDirectoryBuilder = BuildDebugDirectory(entryPoint, out int debugDataSize); - - // Use custom PE builder if we have vtable fixups, exports, or data label reference fixups - if (_vtableFixups.Count > 0 || exports.Count > 0 || _mappedFieldDataReferenceFixups.Count > 0) - { - var vtableFixupInfos = BuildVTableFixupInfos(); - - // Apply CorFlags from options or directive - CorFlags corFlags = _options.CorFlags ?? _corflags; - if (_options.Prefer32Bit) - { - corFlags |= CorFlags.Prefers32Bit; - } - - VTableExportPEBuilder peBuilder = new( - header, - rootBuilder, - ilStream, - _mappedFieldData, - _manifestResources, - debugDirectoryBuilder: debugDirectoryBuilder, - entryPoint: entryPoint, - flags: corFlags, - vtableFixups: vtableFixupInfos, - exports: exports.ToImmutable(), - mappedFieldDataOffsets: _mappedFieldDataNames, - dataLabelFixups: _mappedFieldDataReferenceFixups, - metadataSize: metadataSize, - debugDataSize: debugDataSize); - - return (_diagnostics.ToImmutable(), new CompilationResult(peBuilder, mvidFixup)); - } - - // Apply CorFlags from options or directive - CorFlags standardCorFlags = _options.CorFlags ?? _corflags; - if (_options.Prefer32Bit) - { - standardCorFlags |= CorFlags.Prefers32Bit; - } - - // Deterministic ID provider for reproducible builds - Func, BlobContentId>? deterministicIdProvider = _options.Deterministic - ? GetDeterministicContentId - : null; - - ManagedPEBuilder standardBuilder = new( - header, - rootBuilder, - ilStream, - _mappedFieldData, - _manifestResources, - flags: standardCorFlags, - entryPoint: entryPoint, - debugDirectoryBuilder: debugDirectoryBuilder, - deterministicIdProvider: deterministicIdProvider); - - return (_diagnostics.ToImmutable(), new CompilationResult(standardBuilder, mvidFixup)); - } - - private static BlobContentId GetDeterministicContentId(IEnumerable content) - { - using IncrementalHash hash = IncrementalHash.CreateHash(HashAlgorithmName.SHA256); - foreach (Blob blob in content) - { - hash.AppendData(blob.GetBytes()); - } - - return BlobContentId.FromHash(hash.GetHashAndReset()); - } - - private ImmutableArray BuildVTableFixupInfos() - { - if (_vtableFixups.Count == 0) - return ImmutableArray.Empty; - - var builder = ImmutableArray.CreateBuilder(_vtableFixups.Count); - - for (int entryIndex = 0; entryIndex < _vtableFixups.Count; entryIndex++) - { - var vtf = _vtableFixups[entryIndex]; - var methodTokens = ImmutableArray.CreateBuilder(vtf.SlotCount); - - // Initialize with zeros - for (int i = 0; i < vtf.SlotCount; i++) - { - methodTokens.Add(0); - } - - // Find methods that reference this vtable entry - foreach (EntityRegistry.MethodDefinitionEntity method in GetParsedMethods()) - { - if (method.VTableEntry == entryIndex + 1 && // 1-based - method.VTableSlot > 0 && - method.VTableSlot <= vtf.SlotCount) - { - methodTokens[method.VTableSlot - 1] = MetadataTokens.GetToken(method.Handle); - } - } - - builder.Add(new VTableExportPEBuilder.VTableFixupInfo( - vtf.DataLabel, - vtf.SlotCount, - vtf.Flags, - methodTokens.ToImmutable())); - } - - return builder.ToImmutable(); - } - - private IEnumerable GetParsedMethods() - { - foreach (EntityRegistry.TypeDefinitionEntity type in _entityRegistry.GetSeenEntities(TableIndex.TypeDef)) - { - foreach (EntityRegistry.MethodDefinitionEntity method in type.Methods) - { - yield return method; - } - } - } - - private DebugDirectoryBuilder? BuildDebugDirectory(MethodDefinitionHandle entryPoint, out int debugDataSize) - { - debugDataSize = 0; - - // Check if we have any methods with debug info - bool hasDebugInfo = false; - foreach (var entity in _entityRegistry.GetSeenEntities(TableIndex.MethodDef)) - { - if (entity is EntityRegistry.MethodDefinitionEntity method && - method.DebugInfo.SequencePoints.Count > 0) - { - hasDebugInfo = true; - break; - } - } - - // Generate PDB if we have debug info OR if --debug/--pdb options are set - bool generatePdb = hasDebugInfo || _options.Debug || _options.Pdb; - if (!generatePdb) - { - return null; - } - - // Build PDB metadata - BuildPdbMetadata(); - - // Get row counts from main metadata for the portable PDB - var typeSystemRowCounts = _metadataBuilder.GetRowCounts(); - - // Create the portable PDB - var pdbBuilder = new PortablePdbBuilder( - _pdbBuilder, - typeSystemRowCounts, - entryPoint, - idProvider: _options.Deterministic ? GetDeterministicContentId : null); - - var pdbBlob = new BlobBuilder(); - var pdbContentId = pdbBuilder.Serialize(pdbBlob); - - // Create debug directory with embedded PDB - var debugDirectoryBuilder = new DebugDirectoryBuilder(); - debugDirectoryBuilder.AddCodeViewEntry( - $"assembly.pdb", - pdbContentId, - pdbBuilder.FormatVersion); - debugDirectoryBuilder.AddEmbeddedPortablePdbEntry(pdbBlob, pdbBuilder.FormatVersion); - - // Calculate debug data size: - // 2 debug directory entries (28 bytes each) + CodeView data (~24 bytes) + Embedded PDB data (compressed pdbBlob + 8 header) - // CodeView entry: signature (4) + guid (16) + age (4) + path (variable, ~12 for "assembly.pdb\0") - const int debugDirEntrySize = 28; - int codeViewDataSize = 4 + 16 + 4 + "assembly.pdb".Length + 1; // signature + guid + age + path + null - int embeddedPdbHeaderSize = 8; // MPDB signature (4) + uncompressed size (4) - // The embedded PDB is compressed, estimate conservatively as same size - int embeddedPdbDataSize = embeddedPdbHeaderSize + pdbBlob.Count; - - debugDataSize = (2 * debugDirEntrySize) + codeViewDataSize + embeddedPdbDataSize; - - return debugDirectoryBuilder; - } - - private void BuildPdbMetadata() - { - // Add documents and sequence points to the PDB metadata builder - foreach (var entity in _entityRegistry.GetSeenEntities(TableIndex.MethodDef)) - { - if (entity is not EntityRegistry.MethodDefinitionEntity method) - { - continue; - } - - var debugInfo = method.DebugInfo; - if (debugInfo.SequencePoints.Count == 0) - { - // Add empty debug info entry for methods without sequence points - _pdbBuilder.AddMethodDebugInformation(default, default); - continue; - } - - // Get or create document handle - DocumentHandle documentHandle = default; - if (debugInfo.DocumentPath is not null) - { - if (!_documentHandles.TryGetValue(debugInfo.DocumentPath, out documentHandle)) - { - var nameHandle = _pdbBuilder.GetOrAddDocumentName(debugInfo.DocumentPath); - var languageGuidHandle = _currentLanguageGuid != Guid.Empty - ? _pdbBuilder.GetOrAddGuid(_currentLanguageGuid) - : default; - documentHandle = _pdbBuilder.AddDocument( - nameHandle, - default, // hash algorithm - default, // hash - languageGuidHandle); - _documentHandles[debugInfo.DocumentPath] = documentHandle; - } - } - - // Encode sequence points - var sequencePointsBlob = EncodeSequencePoints(debugInfo.SequencePoints); - var sequencePointsBlobHandle = _pdbBuilder.GetOrAddBlob(sequencePointsBlob); - - _pdbBuilder.AddMethodDebugInformation(documentHandle, sequencePointsBlobHandle); - } - } - - private static BlobBuilder EncodeSequencePoints(List sequencePoints) - { - var builder = new BlobBuilder(); - - if (sequencePoints.Count == 0) - { - return builder; - } - - // LocalSignature (not used here, write 0) - builder.WriteCompressedInteger(0); - - int previousOffset = 0; - int previousStartLine = -1; - int previousStartColumn = -1; - - foreach (var sp in sequencePoints) - { - // IL offset delta - int offsetDelta = sp.ILOffset - previousOffset; - builder.WriteCompressedInteger(offsetDelta); - previousOffset = sp.ILOffset; - - if (sp.IsHidden) - { - // Hidden sequence point: delta lines = 0, delta columns = 0 - builder.WriteCompressedInteger(0); - builder.WriteCompressedInteger(0); - } - else - { - // Delta lines - int deltaLines = sp.EndLine - sp.StartLine; - builder.WriteCompressedInteger(deltaLines); - - // Delta columns - int deltaColumns = sp.EndColumn - sp.StartColumn; - if (deltaLines == 0) - { - builder.WriteCompressedInteger(deltaColumns); - } - else - { - builder.WriteCompressedSignedInteger(deltaColumns); - } - - // Start line delta (signed) - if (previousStartLine < 0) - { - builder.WriteCompressedInteger(sp.StartLine); - } - else - { - builder.WriteCompressedSignedInteger(sp.StartLine - previousStartLine); - } - - // Start column delta (signed) - if (previousStartColumn < 0) - { - builder.WriteCompressedInteger(sp.StartColumn); - } - else - { - builder.WriteCompressedSignedInteger(sp.StartColumn - previousStartColumn); - } - - previousStartLine = sp.StartLine; - previousStartColumn = sp.StartColumn; - } - } - - return builder; - } - - private static bool IsRecoverableError(string diagnosticId) - { - // Method body and signature diagnostics are recoverable - we emit the assembly but report the error. - // This matches native ilasm behavior where errors during method/field emission don't prevent - // the assembly from being written when the /ERR (OnErrGo) flag is set. - return diagnosticId is DiagnosticIds.ByteArrayTooShort - or DiagnosticIds.ArgumentNotFound - or DiagnosticIds.LocalNotFound - or DiagnosticIds.LabelNotFound - or DiagnosticIds.GenericParameterIndexOutOfRange - or DiagnosticIds.ParameterIndexOutOfRange - or DiagnosticIds.GenericParameterNotFound - or DiagnosticIds.UnknownGenericParameter - or DiagnosticIds.MissingInstanceCallConv; - } - - public GrammarResult Visit(IParseTree tree) => tree.Accept(this); - - GrammarResult ICILVisitor.VisitAlignment(CILParser.AlignmentContext context) => VisitAlignment(context); - public GrammarResult.Literal VisitAlignment(CILParser.AlignmentContext context) - { - return VisitInt32(context.int32()); - } - - GrammarResult ICILVisitor.VisitAsmAttr(CILParser.AsmAttrContext context) => VisitAsmAttr(context); - public GrammarResult.Literal VisitAsmAttr(CILParser.AsmAttrContext context) - => new(context.asmAttrAny().Select(VisitAsmAttrAny).Aggregate((AssemblyFlags)0, (lhs, rhs) => lhs | rhs)); - GrammarResult ICILVisitor.VisitAsmAttrAny(CILParser.AsmAttrAnyContext context) => VisitAsmAttrAny(context); - public GrammarResult.Flag VisitAsmAttrAny(CILParser.AsmAttrAnyContext context) - { - return context.GetText() switch - { - "retargetable" => new(AssemblyFlags.Retargetable), - "windowsruntime" => new(AssemblyFlags.WindowsRuntime), - "noplatform" => new(AssemblyFlags.NoPlatform), - "legacy library" => new(0), - "cil" => new(GetFlagForArch(ProcessorArchitecture.MSIL), AssemblyFlags.ArchitectureMask), - "x86" => new(GetFlagForArch(ProcessorArchitecture.X86), AssemblyFlags.ArchitectureMask), - "amd64" => new(GetFlagForArch(ProcessorArchitecture.Amd64), AssemblyFlags.ArchitectureMask), - "arm" => new(GetFlagForArch(ProcessorArchitecture.Arm), AssemblyFlags.ArchitectureMask), - "arm64" => new(GetFlagForArch((ProcessorArchitecture)6), AssemblyFlags.ArchitectureMask), - _ => throw new UnreachableException() - }; - } - - private static AssemblyFlags GetFlagForArch(ProcessorArchitecture arch) - { - return (AssemblyFlags)((int)arch << 4); - } - - private static (ProcessorArchitecture, AssemblyFlags) GetArchAndFlags(AssemblyFlags flags) - { - var arch = (ProcessorArchitecture)(((int)flags & 0xF0) >> 4); - var newFlags = flags & ~((AssemblyFlags)((int)arch << 4)); - return (arch, newFlags); - } - - private EntityRegistry.AssemblyOrRefEntity? _currentAssemblyOrRef; - public GrammarResult VisitAsmOrRefDecl(CILParser.AsmOrRefDeclContext context) - { - Debug.Assert(_currentAssemblyOrRef is not null); - - if (context.customAttrDecl() is { } attr) - { - var customAttr = VisitCustomAttrDecl(attr).Value; - customAttr?.Owner = _currentAssemblyOrRef; - return GrammarResult.SentinelValue.Result; - } - - string decl = context.GetChild(0).GetText(); - if (decl is ".publickey" or ".publicKey") - { - BlobBuilder blob = new(); - blob.WriteBytes(VisitBytes(context.bytes()).Value); - // COMPAT: Native ilasm gives a public key token precedence regardless of declaration order. - if (_currentAssemblyOrRef is not EntityRegistry.AssemblyReferenceEntity assemblyReference - || assemblyReference.PublicKeyOrToken is null - || assemblyReference.Flags.HasFlag(AssemblyFlags.PublicKey)) - { - _currentAssemblyOrRef!.PublicKeyOrToken = blob; - _currentAssemblyOrRef.Flags |= AssemblyFlags.PublicKey; - } - } - else if (decl == ".ver") - { - var versionComponents = context.intOrWildcard(); - _currentAssemblyOrRef!.Version = new Version( - VisitIntOrWildcard(versionComponents[0]).Value ?? 0, - VisitIntOrWildcard(versionComponents[1]).Value ?? 0, - VisitIntOrWildcard(versionComponents[2]).Value ?? 0, - VisitIntOrWildcard(versionComponents[3]).Value ?? 0); - } - else if (decl == ".locale") - { - _currentAssemblyOrRef!.Culture = context.compQstring() is { } compQstring - ? VisitCompQstring(compQstring).Value - : Encoding.Unicode.GetString([.. VisitBytes(context.bytes()).Value]); - } - return GrammarResult.SentinelValue.Result; - } - - GrammarResult ICILVisitor.VisitAssemblyBlock(CILParser.AssemblyBlockContext context) => VisitAssemblyBlock(context); - public GrammarResult VisitAssemblyBlock(CILParser.AssemblyBlockContext context) - { - // Use command-line override if specified, otherwise use the name from the .assembly directive - string assemblyName = _options.AssemblyName ?? VisitDottedName(context.dottedName()).Value; - _entityRegistry.Assembly ??= new EntityRegistry.AssemblyEntity(assemblyName); - var attr = VisitAsmAttr(context.asmAttr()).Value; - (_entityRegistry.Assembly.ProcessorArchitecture, _entityRegistry.Assembly.Flags) = GetArchAndFlags(attr); - foreach (var decl in context.assemblyDecls().assemblyDecl()) - { - VisitAssemblyDecl(decl); - } - - // Apply command-line key file override (overrides .publickey directive) - if (_options.KeyFile is not null) - { - ApplyKeyFile(_options.KeyFile); - } - - // DebuggableAttribute is applied in BuildImage() after all source declarations - // have been processed, so the correct corelib assembly ref can be found. - - return GrammarResult.SentinelValue.Result; - } - - /// - /// Add DebuggableAttribute to the assembly based on debug options. - /// - /DEBUG: 0x101 = Default | DisableOptimizations - /// - /DEBUG=OPT: 0x03 = Default | IgnoreSymbolStoreSequencePoints - /// - /DEBUG=IMPL: 0x103 = Default | DisableOptimizations | EnableEditAndContinue - /// - private void ApplyDebuggableAttribute() - { - if (_entityRegistry.Assembly is null) - { - return; - } - - // DebuggingModes enum values from System.Diagnostics.DebuggableAttribute: - // None = 0x00, Default = 0x01, IgnoreSymbolStoreSequencePoints = 0x02, - // EnableEditAndContinue = 0x04, DisableOptimizations = 0x100 - const int DebuggingModesDefault = 0x101; // Default | DisableOptimizations - const int DebuggingModesOpt = 0x03; // Default | IgnoreSymbolStoreSequencePoints - const int DebuggingModesImpl = 0x103; // Default | DisableOptimizations | EnableEditAndContinue - - int debuggingModes = _options.DebugMode switch - { - DebugMode.Opt => DebuggingModesOpt, - DebugMode.Impl => DebuggingModesImpl, - _ => DebuggingModesDefault - }; - - // Get reference to core library - var coreAsmRef = _entityRegistry.GetCoreLibAssemblyReference(); - - // Create reference to System.Diagnostics.DebuggableAttribute - var debuggableAttrType = _entityRegistry.GetOrCreateTypeReference( - coreAsmRef, - new TypeName(null, "System.Diagnostics.DebuggableAttribute")); - - // Create reference to nested type DebuggingModes - var debuggingModesType = _entityRegistry.GetOrCreateTypeReference( - debuggableAttrType, - new TypeName(null, "DebuggingModes")); - - // Create constructor signature: .ctor(DebuggingModes) - BlobBuilder ctorSig = new(); - var sigEncoder = new BlobEncoder(ctorSig); - sigEncoder.MethodSignature(SignatureCallingConvention.Default, 0, isInstanceMethod: true) - .Parameters(1, - returnType => returnType.Void(), - parameters => parameters.AddParameter().Type().Type(debuggingModesType.Handle, isValueType: true)); - - var ctor = _entityRegistry.CreateLazilyRecordedMemberReference(debuggableAttrType, ".ctor", ctorSig); - - // Create custom attribute blob: prolog (0x0001) + int32 value + named args count (0x0000) - BlobBuilder attrValue = new(); - attrValue.WriteUInt16(0x0001); // Prolog - attrValue.WriteInt32(debuggingModes); // DebuggingModes value - attrValue.WriteUInt16(0x0000); // No named arguments - - // Create and attach the custom attribute - var customAttr = _entityRegistry.CreateCustomAttribute(ctor, attrValue); - customAttr.Owner = _entityRegistry.Assembly; - } - - private void ApplyKeyFile(string keyFilePath) - { - if (_entityRegistry.Assembly is null) - { - return; - } - - try - { - byte[] keyBytes = File.ReadAllBytes(keyFilePath); - BlobBuilder blob = new(); - blob.WriteBytes(keyBytes); - _entityRegistry.Assembly.PublicKeyOrToken = blob; - _entityRegistry.Assembly.Flags |= AssemblyFlags.PublicKey; - } - catch (Exception ex) - { - // Create a location pointing to the first document (if available) - var firstDoc = _documents.Values.FirstOrDefault(); - var location = firstDoc is not null - ? new Location(new SourceSpan(0, 0), firstDoc) - : new Location(new SourceSpan(0, 0), new SourceText(string.Empty, keyFilePath)); - _diagnostics.Add(new Diagnostic(DiagnosticIds.KeyFileError, DiagnosticSeverity.Error, $"Failed to read key file '{keyFilePath}': {ex.Message}", location)); - } - } - - GrammarResult ICILVisitor.VisitAssemblyDecl(CILParser.AssemblyDeclContext context) => VisitAssemblyDecl(context); - public GrammarResult VisitAssemblyDecl(CILParser.AssemblyDeclContext context) - { - if (context.secDecl() is { } secDecl) - { - var declarativeSecurity = VisitSecDecl(secDecl); - if (declarativeSecurity.Value is { } sec) - { - sec.Parent = _entityRegistry.Assembly; - } - } - else if (context.int32() is { } hashAlg) - { - _entityRegistry.Assembly!.HashAlgorithm = (AssemblyHashAlgorithm)VisitInt32(hashAlg).Value; - } - else if (context.asmOrRefDecl() is { } asmOrRef) - { - _currentAssemblyOrRef = _entityRegistry.Assembly; - VisitAsmOrRefDecl(asmOrRef); - _currentAssemblyOrRef = null; - } - return GrammarResult.SentinelValue.Result; - } - public GrammarResult VisitAssemblyDecls(CILParser.AssemblyDeclsContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - public GrammarResult VisitAssemblyRefDecl(CILParser.AssemblyRefDeclContext context) - { - if (context.asmOrRefDecl() is { } asmOrRef) - { - VisitAsmOrRefDecl(asmOrRef); - } - string decl = context.GetChild(0).GetText(); - if (decl == ".hash") - { - var blob = new BlobBuilder(); - blob.WriteBytes(VisitBytes(context.bytes()).Value); - ((EntityRegistry.AssemblyReferenceEntity)_currentAssemblyOrRef!).Hash = blob; - } - if (decl == ".publickeytoken") - { - var blob = new BlobBuilder(); - blob.WriteBytes(VisitBytes(context.bytes()).Value); - _currentAssemblyOrRef!.PublicKeyOrToken = blob; - _currentAssemblyOrRef.Flags &= ~AssemblyFlags.PublicKey; - } - return GrammarResult.SentinelValue.Result; - } - public GrammarResult VisitAssemblyRefDecls(CILParser.AssemblyRefDeclsContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - GrammarResult ICILVisitor.VisitAssemblyRefHead(CILParser.AssemblyRefHeadContext context) => VisitAssemblyRefHead(context); - public GrammarResult.Literal VisitAssemblyRefHead(CILParser.AssemblyRefHeadContext context) - { - var (arch, flags) = GetArchAndFlags(VisitAsmAttr(context.asmAttr()).Value); - var dottedNames = context.dottedName(); - string name = VisitDottedName(dottedNames[0]).Value; - string alias = name; - if (dottedNames.Length > 1) - { - alias = VisitDottedName(dottedNames[1]).Value; - } - return new(_entityRegistry.GetOrCreateAssemblyReference(alias, asmref => - { - asmref.Name = name; - asmref.Flags = flags; - asmref.ProcessorArchitecture = arch; - })); - } - - GrammarResult ICILVisitor.VisitAtOpt(CILParser.AtOptContext context) => VisitAtOpt(context); - public GrammarResult.Literal VisitAtOpt(CILParser.AtOptContext context) - => context.id() is { } id ? new(VisitId(id).Value) - : context.int32() is { } i ? new(VisitInt32(i).Value.ToString()) - : new(null); - - GrammarResult ICILVisitor.VisitBoolSeq(CILParser.BoolSeqContext context) => VisitBoolSeq(context); - public static GrammarResult.FormattedBlob VisitBoolSeq(CILParser.BoolSeqContext context) - { - var builder = ImmutableArray.CreateBuilder(); - - foreach (var item in context.truefalse()) - { - builder.AddRange(VisitTruefalse(item).Value); - } - - return new(builder.ToImmutable().SerializeSequence()); - } - GrammarResult ICILVisitor.VisitBound(CILParser.BoundContext context) => VisitBound(context); - public GrammarResult.Literal<(int? Lower, int? Upper)> VisitBound(CILParser.BoundContext context) - { - bool hasEllipsis = context.ELLIPSIS() is not null; - var indices = context.int32(); - - if (indices.Length == 0) - { - // Empty or standalone "..." - return new((null, null)); - } - - int firstValue = VisitInt32(indices[0]).Value; - - return (indices.Length, hasEllipsis) switch - { - (1, false) => new((0, firstValue)), - (1, true) => new((firstValue, null)), - (2, _) => new((firstValue, VisitInt32(indices[1]).Value - firstValue + 1)), - _ => throw new UnreachableException() - }; - } - - GrammarResult ICILVisitor.VisitBounds(CILParser.BoundsContext context) => VisitBounds(context); - public GrammarResult.Sequence<(int? Lower, int? Upper)> VisitBounds(CILParser.BoundsContext context) - { - return new(context.bound().Select(bound => VisitBound(bound).Value).ToImmutableArray()); - } - - GrammarResult ICILVisitor.VisitBytes(CILParser.BytesContext context) => VisitBytes(context); - public static GrammarResult.Sequence VisitBytes(CILParser.BytesContext context) - { - var builder = ImmutableArray.CreateBuilder(); - - foreach (var item in context.hexbyte()) - { - builder.Add(VisitHexbyte(item)); - } - - return new(builder.ToImmutable()); - } - GrammarResult ICILVisitor.VisitCallConv(CILParser.CallConvContext context) => VisitCallConv(context); - public GrammarResult.Literal VisitCallConv(CILParser.CallConvContext context) - { - if (context.callKind() is CILParser.CallKindContext callKind) - { - return new((byte)VisitCallKind(callKind).Value); - } - else if (context.int32() is CILParser.Int32Context int32) - { - return new((byte)VisitInt32(int32).Value); - } - else if (context.INSTANCE() is not null) - { - return new((byte)(VisitCallConv(context.callConv()).Value | (byte)SignatureAttributes.Instance)); - } - else if (context.EXPLICIT() is not null) - { - return new((byte)( - VisitCallConv(context.callConv()).Value | - (byte)(SignatureAttributes.ExplicitThis | SignatureAttributes.Instance))); - } - return new(0); - } - GrammarResult ICILVisitor.VisitCallKind(CILParser.CallKindContext context) => VisitCallKind(context); - public GrammarResult.Literal VisitCallKind(CILParser.CallKindContext context) - { - // callKind can be empty (/* EMPTY */) - return Default in that case - if (context.ChildCount == 0) - { - return new(SignatureCallingConvention.Default); - } - int childType = context.GetChild(context.ChildCount - 1).Symbol.Type; - return new(childType switch - { - CILParser.DEFAULT => SignatureCallingConvention.Default, - CILParser.VARARG => SignatureCallingConvention.VarArgs, - CILParser.CDECL => SignatureCallingConvention.CDecl, - CILParser.STDCALL => SignatureCallingConvention.StdCall, - CILParser.THISCALL => SignatureCallingConvention.ThisCall, - CILParser.FASTCALL => SignatureCallingConvention.FastCall, - CILParser.UNMANAGED => SignatureCallingConvention.Unmanaged, - _ => throw new UnreachableException() - }); - } - - GrammarResult ICILVisitor.VisitCatchClause(CILParser.CatchClauseContext context) => VisitCatchClause(context); - public GrammarResult.Literal VisitCatchClause(CILParser.CatchClauseContext context) => VisitTypeSpec(context.typeSpec()); - - GrammarResult ICILVisitor.VisitCaValue(CILParser.CaValueContext context) => VisitCaValue(context); - public GrammarResult.FormattedBlob VisitCaValue(CILParser.CaValueContext context) - { - BlobBuilder blob = new(); - if (context.truefalse() is CILParser.TruefalseContext truefalse) - { - blob.WriteByte((byte)SerializationTypeCode.Boolean); - blob.WriteBoolean(VisitTruefalse(truefalse).Value); - } - else if (context.compQstring() is CILParser.CompQstringContext str) - { - blob.WriteUTF8(VisitCompQstring(str).Value); - blob.WriteByte(0); - } - else if (context.className() is CILParser.ClassNameContext className) - { - var name = VisitClassName(className).Value; - blob.WriteByte((byte)SerializationTypeCode.Enum); - blob.WriteUTF8((name as EntityRegistry.IHasReflectionNotation)?.ReflectionNotation ?? ""); - blob.WriteByte(0); - byte size = 4; - if (context.INT8() is not null) - { - size = 1; - } - else if (context.INT16() is not null) - { - size = 2; - } - blob.WriteByte(size); - blob.WriteInt32(VisitInt32(context.int32()).Value); - } - else - { - blob.WriteByte((byte)SerializationTypeCode.Int32); - blob.WriteInt32(VisitInt32(context.int32()).Value); - } - return new(blob); - } - - public GrammarResult VisitChildren(IRuleNode node) - { - for (int i = 0; i < node.ChildCount; i++) - { - node.GetChild(i).Accept(this); - } - return GrammarResult.SentinelValue.Result; - } - GrammarResult ICILVisitor.VisitClassAttr(CILParser.ClassAttrContext context) => VisitClassAttr(context); - - public GrammarResult.Literal<(GrammarResult.Flag Attribute, EntityRegistry.WellKnownBaseType? FallbackBase, bool RequireSealed)> VisitClassAttr(CILParser.ClassAttrContext context) - { - if (context.int32() is CILParser.Int32Context int32) - { - int value = VisitInt32(int32).Value; - // COMPAT: The VALUE and ENUM keywords use sentinel values to pass through the fallback base type - // in ILASM. These sentinel values can be provided through the "pass the value of the flag" feature, - // so we detect those old flags here and provide the correct fallback type. - bool requireSealed = false; - EntityRegistry.WellKnownBaseType? fallbackBase = null; - if ((value & 0x80000000) != 0) - { - requireSealed = true; - fallbackBase = EntityRegistry.WellKnownBaseType.System_ValueType; - } - if ((value & 0x40000000) != 0) - { - fallbackBase = EntityRegistry.WellKnownBaseType.System_Enum; - } - // Mask off the sentinel bits - value &= unchecked((int)~0xC0000000); - // COMPAT: When explicit flags are provided they always supercede previously set flags - // (other than the sentinel values) - return new((new((TypeAttributes)value, ShouldAppend: false), fallbackBase, requireSealed)); - } - - if (context.ENUM() is not null) - { - // COMPAT: ilasm implies the Sealed flag when using the 'value' keyword in a type declaration - // even when the 'enum' keyword is used. - return new((new(context.VALUE() is not null ? TypeAttributes.Sealed : 0), EntityRegistry.WellKnownBaseType.System_Enum, false)); - } - else if (context.VALUE() is not null) - { - // COMPAT: ilasm implies the Sealed flag when using the 'value' keyword in a type declaration - return new((new(TypeAttributes.Sealed), EntityRegistry.WellKnownBaseType.System_ValueType, true)); - } - else if (context.EXPLICIT() is not null) - { - return new((new(TypeAttributes.ExplicitLayout), null, false)); - } - else if (context.INTERFACE() is not null) - { - // COMPAT: interface implies abstract - return new((new(TypeAttributes.Interface | TypeAttributes.Abstract), null, false)); - } - - switch (context.GetText()) - { - case "public": - return new((new(TypeAttributes.Public, TypeAttributes.VisibilityMask), null, false)); - case "private": - return new((new(TypeAttributes.NotPublic, TypeAttributes.VisibilityMask), null, false)); - case "nestedpublic": - return new((new(TypeAttributes.NestedPublic, TypeAttributes.VisibilityMask), null, false)); - case "nestedprivate": - return new((new(TypeAttributes.NestedPrivate, TypeAttributes.VisibilityMask), null, false)); - case "nestedfamily": - return new((new(TypeAttributes.NestedFamily, TypeAttributes.VisibilityMask), null, false)); - case "nestedassembly": - return new((new(TypeAttributes.NestedAssembly, TypeAttributes.VisibilityMask), null, false)); - case "nestedfamandassem": - return new((new(TypeAttributes.NestedFamANDAssem, TypeAttributes.VisibilityMask), null, false)); - case "nestedfamorassem": - return new((new(TypeAttributes.NestedFamORAssem, TypeAttributes.VisibilityMask), null, false)); - case "ansi": - return new((new(TypeAttributes.AnsiClass, TypeAttributes.StringFormatMask), null, false)); - case "autochar": - return new((new(TypeAttributes.AutoClass, TypeAttributes.StringFormatMask), null, false)); - case "unicode": - return new((new(TypeAttributes.UnicodeClass, TypeAttributes.StringFormatMask), null, false)); - case "auto": - return new((new(TypeAttributes.AutoLayout, TypeAttributes.LayoutMask), null, false)); - case "sequential": - return new((new(TypeAttributes.SequentialLayout, TypeAttributes.LayoutMask), null, false)); - case "extended": - return new((new(TypeAttributes.ExtendedLayout, TypeAttributes.LayoutMask), null, false)); - case "sealed": - return new((new(TypeAttributes.Sealed), null, false)); - case "abstract": - return new((new(TypeAttributes.Abstract), null, false)); - case "import": - return new((new(TypeAttributes.Import), null, false)); - case "serializable": -#pragma warning disable SYSLIB0050 - return new((new(TypeAttributes.Serializable), null, false)); -#pragma warning restore SYSLIB0050 - case "windowsruntime": - return new((new(TypeAttributes.WindowsRuntime), null, false)); - case "beforefieldinit": - return new((new(TypeAttributes.BeforeFieldInit), null, false)); - case "specialname": - return new((new(TypeAttributes.SpecialName), null, false)); - case "rtspecialname": - return new((new(TypeAttributes.RTSpecialName), null, false)); - default: - return new((new((TypeAttributes)Enum.Parse(typeof(TypeAttributes), context.GetText(), true)), null, false)); - } - } - - private sealed class CurrentMethodContext - { - public CurrentMethodContext(EntityRegistry.MethodDefinitionEntity definition) - { - Definition = definition; - // Populate argument names from the method's parameter definitions - foreach (var param in definition.Parameters) - { - if (param.Name is not null && param.Sequence > 0) - { - ArgumentNames[param.Name] = param.Sequence - 1; - } - } - } - - public EntityRegistry.MethodDefinitionEntity Definition { get; } - - public Dictionary Labels { get; } = new(); - - public HashSet DeclaredLabels { get; } = new(); - - public Dictionary UndefinedLabelReferences { get; } = new(); - - public Dictionary ArgumentNames { get; } = new(); - - public List> LocalsScopes { get; } = new(); - - public List AllLocals { get; } = new(); - } - - private CurrentMethodContext? _currentMethod; - private EntityRegistry.EntityBase? _pendingClassCustomAttributeOwner; - - public GrammarResult VisitClassDecl(CILParser.ClassDeclContext context) - { - bool isStandaloneCustomAttribute = - context.customAttrDecl().Length == 1 && - context.PARAM() is null; - bool isTrailingCustomAttribute = - isStandaloneCustomAttribute && - context.customAttrDecl()[0].dottedName() is null; - if (!isTrailingCustomAttribute) - { - _pendingClassCustomAttributeOwner = null; - } - - if (context.classHead() is CILParser.ClassHeadContext classHead) - { - _currentTypeDefinition.Push(VisitClassHead(classHead).Value); - VisitClassDecls(context.classDecls()); - _currentTypeDefinition.Pop(); - _pendingClassCustomAttributeOwner = null; - } - else if (context.methodHead() is CILParser.MethodHeadContext methodHead) - { - _currentMethod = new(VisitMethodHead(methodHead).Value); - VisitMethodDecls(context.methodDecls()); - // Build the locals signature from parsed local variable declarations - if (_currentMethod.AllLocals.Count > 0) - { - var localsSig = new BlobBuilder(); - var encoder = new BlobEncoder(localsSig); - var localsEncoder = encoder.LocalVariableSignature(_currentMethod.AllLocals.Count); - foreach (var local in _currentMethod.AllLocals) - { - local.SignatureBlob.WriteContentTo(localsEncoder.AddVariable().Builder); - } - _currentMethod.Definition.LocalsSignature = _entityRegistry.GetOrCreateStandaloneSignature(localsSig); - } - // Validate that all referenced labels were declared - ValidateLabelReferences(); - _currentMethod = null; - } - else if (context.secDecl() is {} secDecl) - { - var declarativeSecurity = VisitSecDecl(secDecl).Value; - declarativeSecurity?.Parent = _currentTypeDefinition.PeekOrDefault(); - } - else if (context.TYPE() is not null && - context.typeSpec().Length == 1 && - context.customDescr() is { } interfaceAttribute) - { - var currentType = _currentTypeDefinition.PeekOrDefault(); - if (currentType is not null) - { - EntityRegistry.TypeEntity interfaceType = VisitTypeSpec(context.typeSpec()[0]).Value; - EntityRegistry.InterfaceImplementationEntity? implementation = - currentType.InterfaceImplementations.FirstOrDefault( - candidate => candidate.InterfaceType == interfaceType); - if (implementation is null) - { - implementation = - EntityRegistry.CreateUnrecordedInterfaceImplementation(currentType, interfaceType); - currentType.InterfaceImplementations.Add(implementation); - } - - VisitCustomDescr(interfaceAttribute).Value.Owner = implementation; - } - } - else if (context.fieldDecl() is {} fieldDecl) - { - _ = VisitFieldDecl(fieldDecl); - } - else if (context.dataDecl() is { } dataDecl) - { - _ = VisitDataDecl(dataDecl); - } - else if (context.extSourceSpec() is { } extSourceSpec) - { - _ = VisitExtSourceSpec(extSourceSpec); - } - else if (context.languageDecl() is { } languageDecl) - { - _ = VisitLanguageDecl(languageDecl); - } - else if (context.OVERRIDE() is not null) - { - var currentType = _currentTypeDefinition.PeekOrDefault(); - if (currentType is not null) - { - var typeSpecs = context.typeSpec(); - var methodNames = context.methodName(); - var callConventions = context.callConv(); - var returnTypes = context.type(); - var signatureArguments = context.sigArgs(); - var genericArities = context.genArity(); - - int bodySignatureIndex = context.METHOD().Length == 0 ? 0 : 1; - BlobBuilder declarationSignature = BuildMethodReferenceSignature( - callConventions[0], - returnTypes[0], - signatureArguments[0], - genericArities.Length > 0 ? VisitGenArity(genericArities[0]).Value : 0); - BlobBuilder bodySignature = context.METHOD().Length == 0 - ? declarationSignature - : BuildMethodReferenceSignature( - callConventions[bodySignatureIndex], - returnTypes[bodySignatureIndex], - signatureArguments[bodySignatureIndex], - genericArities.Length > bodySignatureIndex - ? VisitGenArity(genericArities[bodySignatureIndex]).Value - : 0); - - EntityRegistry.TypeEntity bodyOwner = VisitTypeSpec(typeSpecs[1]).Value; - string bodyName = VisitMethodName(methodNames[1]).Value; - EntityRegistry.MemberReferenceEntity declaration = - _entityRegistry.CreateLazilyRecordedMemberReference( - VisitTypeSpec(typeSpecs[0]).Value, - VisitMethodName(methodNames[0]).Value, - declarationSignature); - - if (ReferenceEquals(bodyOwner, currentType)) - { - EntityRegistry.MethodDefinitionEntity[] bodyMethods = currentType.Methods - .Where(method => - method.Name == bodyName && - method.MethodSignature is not null && - method.MethodSignature.ContentEquals(bodySignature)) - .Take(2) - .ToArray(); - if (bodyMethods.Length != 1) - { - ReportError( - DiagnosticIds.InvalidMetadataToken, - $"Override body method '{bodyName}' could not be resolved uniquely", - context); - return GrammarResult.SentinelValue.Result; - } - - currentType.MethodImplementations.Add( - EntityRegistry.CreateUnrecordedMethodImplementation(bodyMethods[0], declaration)); - } - else - { - EntityRegistry.MemberReferenceEntity body = - _entityRegistry.CreateLazilyRecordedMemberReference( - bodyOwner, - bodyName, - bodySignature); - currentType.MethodImplementations.Add( - EntityRegistry.CreateUnrecordedMethodImplementation(currentType, body, declaration)); - } - } - } - else if (context.int32() is {} int32) - { - // .pack or .size - string keyword = context.GetChild(0).GetText(); - int value = VisitInt32(int32).Value; - var currentType = _currentTypeDefinition.PeekOrDefault(); - if (currentType is not null) - { - if (keyword == ".pack") - { - currentType.PackingSize = value; - } - else if (keyword == ".size") - { - currentType.ClassSize = value; - } - } - } - else if (context.propHead() is CILParser.PropHeadContext propHead) - { - var property = VisitPropHead(propHead).Value; - var currentType = _currentTypeDefinition.PeekOrDefault(); - if (currentType is not null) - { - currentType.Properties.Add(property); - foreach (var propDecl in context.propDecls().propDecl()) - { - if (propDecl.customAttrDecl() is { } customAttrDecl) - { - var customAttr = VisitCustomAttrDecl(customAttrDecl).Value; - if (customAttr is not null) - { - customAttr.Owner = property; - } - } - else if (VisitPropDecl(propDecl).Value is { } accessor) - { - property.Accessors.Add(accessor); - } - } - } - } - else if (context.eventHead() is CILParser.EventHeadContext eventHead) - { - var evt = VisitEventHead(eventHead).Value; - var currentType = _currentTypeDefinition.PeekOrDefault(); - if (currentType is not null) - { - currentType.Events.Add(evt); - foreach (var eventDecl in context.eventDecls().eventDecl()) - { - if (eventDecl.customAttrDecl() is { } customAttrDecl) - { - var customAttr = VisitCustomAttrDecl(customAttrDecl).Value; - if (customAttr is not null) - { - customAttr.Owner = evt; - } - } - else if (VisitEventDecl(eventDecl).Value is { } accessor) - { - evt.Accessors.Add(accessor); - } - } - } - } - else if (context.OVERRIDE() is not null) - { - var currentType = _currentTypeDefinition.PeekOrDefault(); - if (currentType is null) - { - throw new UnreachableException(); - } - - CILParser.CallConvContext[] callConvs = context.callConv(); - CILParser.TypeContext[] returnTypes = context.type(); - CILParser.TypeSpecContext[] owners = context.typeSpec(); - CILParser.MethodNameContext[] methodNames = context.methodName(); - CILParser.GenArityContext[] genericArities = context.genArity(); - CILParser.SigArgsContext[] parameterLists = context.sigArgs(); - - EntityRegistry.MemberReferenceEntity declaration; - EntityRegistry.MemberReferenceEntity body; - if (callConvs.Length == 2) - { - declaration = CreateExplicitMethodReference( - callConvs[0], returnTypes[0], owners[0], methodNames[0], genericArities[0], parameterLists[0]); - body = CreateExplicitMethodReference( - callConvs[1], returnTypes[1], owners[1], methodNames[1], genericArities[1], parameterLists[1]); - } - else - { - EntityRegistry.TypeEntity declarationOwner = VisitTypeSpec(owners[0]).Value; - string declarationName = VisitMethodName(methodNames[0]).Value; - EntityRegistry.TypeEntity bodyOwner = VisitTypeSpec(owners[1]).Value; - string bodyName = VisitMethodName(methodNames[1]).Value; - BlobBuilder bodySignature = CreateExplicitMethodSignature( - callConvs[0], returnTypes[0], genericArity: null, parameterLists[0]); - BlobBuilder declarationSignature = new(); - bodySignature.WriteContentTo(declarationSignature); - declaration = _entityRegistry.CreateLazilyRecordedMemberReference( - declarationOwner, declarationName, declarationSignature); - body = _entityRegistry.CreateLazilyRecordedMemberReference( - bodyOwner, bodyName, bodySignature); - } - - currentType.MethodImplementations.Add(EntityRegistry.CreateUnrecordedMethodImplementation(currentType, body, declaration)); - } - else if (isStandaloneCustomAttribute) - { - if (VisitCustomAttrDecl(context.customAttrDecl()[0]).Value is { } customAttr) - { - customAttr.Owner = - _pendingClassCustomAttributeOwner ?? - _currentTypeDefinition.PeekOrDefault(); - } - } - else if (context.PARAM() is not null) - { - var customAttrDeclarations = context.customAttrDecl(); - var currentType = _currentTypeDefinition.PeekOrDefault(); - if (currentType is not null && context.TYPE() is not null) - { - EntityRegistry.GenericParameterEntity? param = null; - if (context.int32() is { } int32ctx) - { - int index = VisitInt32(int32ctx).Value; - if (index >= 0 && index < currentType.GenericParameters.Count) - { - param = currentType.GenericParameters[index]; - } - else - { - ReportError( - DiagnosticIds.GenericParameterIndexOutOfRange, - string.Format(DiagnosticMessageTemplates.GenericParameterIndexOutOfRange, index), - context); - } - } - else if (context.dottedName() is { } dn) - { - string name = VisitDottedName(dn).Value; - foreach (var genericParam in currentType.GenericParameters) - { - if (genericParam.Name == name) - { - param = genericParam; - break; - } - } - } - if (param is not null) - { - foreach (var attr in customAttrDeclarations ?? Array.Empty()) - { - var customAttrDecl = VisitCustomAttrDecl(attr).Value; - customAttrDecl?.Owner = param; - } - _pendingClassCustomAttributeOwner = param; - } - } - else if (currentType is not null && context.CONSTRAINT() is not null) - { - EntityRegistry.GenericParameterEntity? param = null; - if (context.int32() is { } int32ctx) - { - int index = VisitInt32(int32ctx).Value; - if (index >= 0 && index < currentType.GenericParameters.Count) - { - param = currentType.GenericParameters[index]; - } - else - { - ReportError( - DiagnosticIds.GenericParameterIndexOutOfRange, - string.Format(DiagnosticMessageTemplates.GenericParameterIndexOutOfRange, index), - context); - } - } - else if (context.dottedName() is { } dn) - { - string name = VisitDottedName(dn).Value; - foreach (var genericParam in currentType.GenericParameters) - { - if (genericParam.Name == name) - { - param = genericParam; - break; - } - } - } - if (param is not null) - { - var baseType = VisitTypeSpec(context.typeSpec()[0]).Value; - EntityRegistry.GenericParameterConstraintEntity? constraint = - param.Constraints.FirstOrDefault(entity => entity.BaseType == baseType); - if (constraint is null) - { - constraint = EntityRegistry.CreateGenericConstraint(baseType); - constraint.Owner = param; - param.Constraints.Add(constraint); - currentType.GenericParameterConstraints.Add(constraint); - } - foreach (var attr in customAttrDeclarations ?? Array.Empty()) - { - var customAttrDecl = VisitCustomAttrDecl(attr).Value; - customAttrDecl?.Owner = constraint; - } - _pendingClassCustomAttributeOwner = constraint; - } - } - } - - return GrammarResult.SentinelValue.Result; - } - - private BlobBuilder BuildMethodReferenceSignature( - CILParser.CallConvContext callConvention, - CILParser.TypeContext returnType, - CILParser.SigArgsContext signatureArguments, - int genericArity) - { - var signature = new BlobBuilder(); - byte header = VisitCallConv(callConvention).Value; - if (genericArity > 0) - { - header |= (byte)SignatureAttributes.Generic; - } - - signature.WriteByte(header); - if (genericArity > 0) - { - signature.WriteCompressedInteger(genericArity); - } - - ImmutableArray arguments = VisitSigArgs(signatureArguments).Value; - signature.WriteCompressedInteger(arguments.Count(argument => !argument.IsSentinel)); - VisitType(returnType).Value.WriteContentTo(signature); - foreach (SignatureArg argument in arguments) - { - argument.SignatureBlob.WriteContentTo(signature); - } - - return signature; - } - - public GrammarResult VisitClassDecls(CILParser.ClassDeclsContext context) - { - CILParser.ClassDeclContext[] declarations = context.classDecl(); - foreach (CILParser.ClassDeclContext declaration in declarations) - { - if (declaration.OVERRIDE() is null) - { - VisitClassDecl(declaration); - } - else - { - _pendingClassCustomAttributeOwner = null; - } - } - - foreach (CILParser.ClassDeclContext declaration in declarations) - { - if (declaration.OVERRIDE() is not null) - { - VisitClassDecl(declaration); - } - } - - return GrammarResult.SentinelValue.Result; - } - - - GrammarResult ICILVisitor.VisitClassHead(CILParser.ClassHeadContext context) => VisitClassHead(context); - public GrammarResult.Literal VisitClassHead(CILParser.ClassHeadContext context) - { - string typeFullName = VisitDottedName(context.dottedName()).Value; - int typeFullNameLastDot = typeFullName.LastIndexOf('.'); - // A dot at position 0 is part of the name (e.g., ".GlobalStruct"), not a namespace separator - if (typeFullNameLastDot == 0) - { - typeFullNameLastDot = -1; - } - string typeNS; - if (_currentTypeDefinition.Count != 0) - { - if (typeFullNameLastDot == -1) - { - typeNS = string.Empty; - } - else - { - typeNS = typeFullName.Substring(0, typeFullNameLastDot); - } - } - else - { - if (typeFullNameLastDot == -1) - { - typeNS = _currentNamespace.PeekOrDefault() ?? string.Empty; - } - else - { - typeNS = $"{_currentNamespace.PeekOrDefault()}{typeFullName.Substring(0, typeFullNameLastDot)}"; - } - } - - bool isNewType = false; - - var typeDefinition = _entityRegistry.GetOrCreateTypeDefinition( - _currentTypeDefinition.PeekOrDefault(), - typeNS, - typeFullNameLastDot != -1 - ? typeFullName.Substring(typeFullNameLastDot + 1) - : typeFullName, - (newTypeDef) => - { - isNewType = true; - EntityRegistry.WellKnownBaseType? fallbackBase = _options.NoAutoInherit ? null : EntityRegistry.WellKnownBaseType.System_Object; - bool requireSealed = false; - var classAttrs = context.classAttr(); - newTypeDef.Attributes = classAttrs.Select(VisitClassAttr).Aggregate( - (TypeAttributes)0, - (acc, result) => - { - var (attribute, implicitBase, attrRequireSealed) = result.Value; - if (implicitBase is not null) - { - fallbackBase = implicitBase; - } - if (!attribute.ShouldAppend) - { - requireSealed = attrRequireSealed; - return attribute.Value; - } - requireSealed |= attrRequireSealed; - if (attribute.Value == TypeAttributes.RTSpecialName) - { - // COMPAT: ILASM ignores the rtspecialname directive on a type. - return acc; - } - if ((attribute.Value & TypeAttributes.Interface) != 0) - { - // COMPAT: interface implies abstract - return acc | TypeAttributes.Interface | TypeAttributes.Abstract; - } - // Use the Flag's | operator which handles group masks - // (visibility, layout, string format) correctly. - return acc | attribute; - }); - - - // Two-pass generic parameter processing: - // Pass 1: Register all parameter names (without resolving constraints) - var typarContexts = context.typarsClause()?.typars()?.typar() ?? Array.Empty(); - for (int i = 0; i < typarContexts.Length; i++) - { - var attributes = VisitTyparAttribs(typarContexts[i].typarAttribs()).Value; - var param = EntityRegistry.CreateGenericParameter(attributes, VisitDottedName(typarContexts[i].dottedName()).Value); - param.Owner = newTypeDef; - param.Index = i; - newTypeDef.GenericParameters.Add(param); - } - - // Push the type so that !T references in constraints, extends, and implements can resolve - _currentTypeDefinition.Push(newTypeDef); - - // Pass 2: Resolve constraints (now all params are registered and type is on stack) - for (int i = 0; i < typarContexts.Length; i++) - { - var param = newTypeDef.GenericParameters[i]; - foreach (var constraint in VisitTyBound(typarContexts[i].tyBound()).Value) - { - constraint.Owner = param; - param.Constraints.Add(constraint); - newTypeDef.GenericParameterConstraints.Add(constraint); - } - } - - if (context.extendsClause() is CILParser.ExtendsClauseContext extends) - { - newTypeDef.BaseType = VisitExtendsClause(context.extendsClause()).Value; - } - - if (context.implClause() is CILParser.ImplClauseContext impl) - { - newTypeDef.InterfaceImplementations.AddRange(VisitImplClause(context.implClause()).Value); - } - - _currentTypeDefinition.Pop(); - - // Interfaces should not have an implicit base type - if (newTypeDef.Attributes.HasFlag(TypeAttributes.Interface)) - { - fallbackBase = null; - } - - newTypeDef.BaseType ??= _entityRegistry.ResolveImplicitBaseType(fallbackBase); - - // When the user has provided a type definition for a type that directly inherits - // System.ValueType but has not sealed it, emit a warning and add the 'sealed' modifier. - if (!newTypeDef.Attributes.HasFlag(TypeAttributes.Sealed) && - (requireSealed // COMPAT: when both the sentinel values for 'value' and 'enum' are explicitly - // specified, the sealed modifier is required even though - // the base type isn't System.ValueType. - || _entityRegistry.SystemValueTypeType.Equals(newTypeDef.BaseType))) - { - _diagnostics.Add( - new Diagnostic( - DiagnosticIds.UnsealedValueType, - DiagnosticSeverity.Error, - string.Format(DiagnosticMessageTemplates.UnsealedValueType, newTypeDef.Name), - Location.From(context.dottedName().Stop, _documents))); - newTypeDef.Attributes |= TypeAttributes.Sealed; - } - }); - - if (!isNewType) - { - // Type was forward-referenced. Apply attributes, generic params, - // base type, and interface implementations that were deferred. - var classAttrs = context.classAttr(); - typeDefinition.Attributes = classAttrs.Select(VisitClassAttr).Aggregate( - typeDefinition.Attributes, - (acc, result) => - { - var (attribute, _, _) = result.Value; - if (!attribute.ShouldAppend) - return attribute.Value; - if ((attribute.Value & TypeAttributes.Interface) != 0) - return acc | TypeAttributes.Interface | TypeAttributes.Abstract; - return acc | attribute.Value; - }); - - if (typeDefinition.GenericParameters.Count == 0) - { - // Two-pass generic parameter processing for forward-referenced types - var typarContexts = context.typarsClause()?.typars()?.typar() ?? Array.Empty(); - for (int i = 0; i < typarContexts.Length; i++) - { - var attributes = VisitTyparAttribs(typarContexts[i].typarAttribs()).Value; - var param = EntityRegistry.CreateGenericParameter(attributes, VisitDottedName(typarContexts[i].dottedName()).Value); - param.Owner = typeDefinition; - param.Index = i; - typeDefinition.GenericParameters.Add(param); - } - - _currentTypeDefinition.Push(typeDefinition); - - // Pass 2: Resolve constraints - for (int i = 0; i < typarContexts.Length; i++) - { - var param = typeDefinition.GenericParameters[i]; - foreach (var constraint in VisitTyBound(typarContexts[i].tyBound()).Value) - { - constraint.Owner = param; - param.Constraints.Add(constraint); - typeDefinition.GenericParameterConstraints.Add(constraint); - } - } - } - else - { - _ = context.typarsClause().Accept(this); - _currentTypeDefinition.Push(typeDefinition); - } - - if (context.extendsClause() is CILParser.ExtendsClauseContext extends && typeDefinition.BaseType is null) - { - typeDefinition.BaseType = VisitExtendsClause(extends).Value; - } - else - { - _ = context.extendsClause()?.Accept(this); - } - - if (context.implClause() is CILParser.ImplClauseContext impl) - { - typeDefinition.InterfaceImplementations.AddRange(VisitImplClause(impl).Value); - } - - _currentTypeDefinition.Pop(); - } - - return new(typeDefinition); - } - - GrammarResult ICILVisitor.VisitClassName(CILParser.ClassNameContext context) => VisitClassName(context); - public GrammarResult.Literal VisitClassName(CILParser.ClassNameContext context) - { - if (context.THIS() is not null) - { - if (_currentTypeDefinition.Count == 0) - { - ReportError(DiagnosticIds.ThisOutsideClass, DiagnosticMessageTemplates.ThisOutsideClass, context); - return new(new EntityRegistry.FakeTypeEntity(default(TypeDefinitionHandle))); - } - var thisType = _currentTypeDefinition.Peek(); - return new(thisType); - } - else if (context.BASE() is not null) - { - if (_currentTypeDefinition.Count == 0) - { - ReportError(DiagnosticIds.BaseOutsideClass, DiagnosticMessageTemplates.BaseOutsideClass, context); - return new(new EntityRegistry.FakeTypeEntity(default(TypeDefinitionHandle))); - } - var baseType = _currentTypeDefinition.Peek().BaseType; - if (baseType is null) - { - ReportError(DiagnosticIds.NoBaseType, DiagnosticMessageTemplates.NoBaseType, context); - return new(new EntityRegistry.FakeTypeEntity(default(TypeDefinitionHandle))); - } - return new(baseType); - } - else if (context.NESTER() is not null) - { - if (_currentTypeDefinition.Count < 2) - { - ReportError(DiagnosticIds.NesterOutsideNestedClass, DiagnosticMessageTemplates.NesterOutsideNestedClass, context); - return new(new EntityRegistry.FakeTypeEntity(default(TypeDefinitionHandle))); - } - var nesterType = _currentTypeDefinition.Peek().ContainingType!; - return new(nesterType); - } - else if (context.slashedName() is CILParser.SlashedNameContext slashedName) - { - EntityRegistry.EntityBase? resolutionContext = null; - if (context.dottedName() is CILParser.DottedNameContext dottedAssemblyOrModuleName) - { - if (context.MODULE() is not null) - { - string moduleName = VisitDottedName(dottedAssemblyOrModuleName).Value; - resolutionContext = _entityRegistry.FindModuleReference(moduleName); - if (resolutionContext is null) - { - ReportError(DiagnosticIds.ModuleNotFound, string.Format(DiagnosticMessageTemplates.ModuleNotFound, moduleName), context); - return new(new EntityRegistry.FakeTypeEntity(default(TypeDefinitionHandle))); - } - } - else - { - resolutionContext = _entityRegistry.GetOrCreateAssemblyReference(VisitDottedName(dottedAssemblyOrModuleName).Value, newRef => { }); - } - } - else if (context.mdtoken() is CILParser.MdtokenContext typeRefScope) - { - resolutionContext = VisitMdtoken(typeRefScope).Value; - } - else if (context.PTR() is not null) - { - resolutionContext = new EntityRegistry.FakeTypeEntity(default(ModuleDefinitionHandle)); - } - - if (resolutionContext is not null) - { - EntityRegistry.TypeReferenceEntity typeRef = _entityRegistry.GetOrCreateTypeReference(resolutionContext, VisitSlashedName(slashedName).Value); - return new(typeRef); - } - - Debug.Assert(resolutionContext is null); - - return new(ResolveTypeDef()); - - // Resolve typedef references - EntityRegistry.TypeEntity ResolveTypeDef() - { - TypeName typeName = VisitSlashedName(slashedName).Value; - if (typeName.ContainingTypeName is null) - { - // Check for typedef. - var typedefResult = TryResolveTypedefAsType(typeName.DottedName); - if (typedefResult is not null) - { - return typedefResult; - } - } - - // COMPAT: Before creating a forward-reference TypeDef, check if the type - // matches a well-known corelib type. Native ilasm resolves unqualified - // references to types like System.String as TypeRefs from the corelib. - if (typeName.ContainingTypeName is null) - { - var (ns, nm) = NameHelpers.SplitDottedNameToNamespaceAndName(typeName.DottedName); - if (ns == "System" && nm is "String" or "Object" or "ValueType" or "Enum" - or "Type" or "Array" or "Delegate" or "MulticastDelegate" - or "Exception" or "Attribute") - { - var coreLib = _entityRegistry.GetCoreLibAssemblyReference(); - return _entityRegistry.GetOrCreateTypeReference(coreLib, typeName); - } - } - - Stack containingTypes = new(); - for (TypeName? containingType = typeName; containingType is not null; containingType = containingType.ContainingTypeName) - { - containingTypes.Push(containingType); - } - EntityRegistry.TypeDefinitionEntity? typeDef = null; - while (containingTypes.Count != 0) - { - TypeName containingType = containingTypes.Pop(); - - (string ns, string name) = NameHelpers.SplitDottedNameToNamespaceAndName(containingType.DottedName); - - typeDef = _entityRegistry.GetOrCreateTypeDefinition( - typeDef, - ns, - name, - _ => { }); - } - - return typeDef!; - } - } - else if (context.mdtoken() is CILParser.MdtokenContext typeToken) - { - EntityRegistry.EntityBase resolvedToken = VisitMdtoken(typeToken).Value; - - if (resolvedToken is not EntityRegistry.TypeEntity type) - { - return new(new EntityRegistry.FakeTypeEntity(resolvedToken.Handle)); - } - return new(type); - } - - throw new UnreachableException(); - } - - GrammarResult ICILVisitor.VisitClassSeq(CILParser.ClassSeqContext context) => VisitClassSeq(context); - public GrammarResult.FormattedBlob VisitClassSeq(CILParser.ClassSeqContext context) - { - BlobBuilder objSeqBlob = new(0); - foreach (var item in context.classSeqElement()) - { - objSeqBlob.LinkSuffix(VisitClassSeqElement(item).Value); - } - return new(objSeqBlob); - } - - GrammarResult ICILVisitor.VisitClassSeqElement(CILParser.ClassSeqElementContext context) => VisitClassSeqElement(context); - - public GrammarResult.FormattedBlob VisitClassSeqElement(CILParser.ClassSeqElementContext context) - { - BlobBuilder blob = new(); - if (context.className() is CILParser.ClassNameContext className) - { - if (VisitClassName(className).Value is EntityRegistry.IHasReflectionNotation notation) - { - blob.WriteSerializedString(notation.ReflectionNotation); - } - else - { - blob.WriteSerializedString(""); - } - return new(blob); - } - - blob.WriteSerializedString( - context.SQSTRING() is { } stringNode - ? StringHelpers.ParseQuotedString(stringNode.Symbol.Text) - : null); - return new(blob); - } - public GrammarResult VisitCompControl(CILParser.CompControlContext context) - { - // All compilation control directives that need special handling will be handled - // directly in the token stream before parsing. - // Any that reach here can be ignored. - return GrammarResult.SentinelValue.Result; - } - - GrammarResult ICILVisitor.VisitCompQstring(CILParser.CompQstringContext context) - { - return VisitCompQstring(context); - } - - private static GrammarResult.String VisitCompQstring(CILParser.CompQstringContext context) - { - StringBuilder builder = new(); - foreach (var item in context.QSTRING()) - { - builder.Append(StringHelpers.ParseQuotedString(item.Symbol.Text)); - } - return new(builder.ToString()); - } - - GrammarResult ICILVisitor.VisitCorflags(CILParser.CorflagsContext context) => VisitCorflags(context); - public GrammarResult.Literal VisitCorflags(CILParser.CorflagsContext context) => VisitInt32(context.int32()); - - GrammarResult ICILVisitor.VisitCustomAttrDecl(CILParser.CustomAttrDeclContext context) => VisitCustomAttrDecl(context); - public GrammarResult.Literal VisitCustomAttrDecl(CILParser.CustomAttrDeclContext context) - { - if (context.dottedName() is { } dottedName) - { - // This is a typedef reference for a custom attribute - string alias = VisitDottedName(dottedName).Value; - var resolved = TryResolveTypedefAsCustomAttribute(alias); - if (resolved is not null) - { - var typedefAttribute = _entityRegistry.CreateCustomAttribute(resolved.Value.Constructor, resolved.Value.Value); - typedefAttribute.Location = Location.From(context.Start, _documents); - return new(typedefAttribute); - } - // Typedef not found - could report diagnostic here - return new(null); - } - if (context.customDescrWithOwner() is {} descrWithOwner) - { - // Visit the custom attribute descriptor to record it, - // but don't return it as it will already have its owner recorded. - _ = VisitCustomDescrWithOwner(descrWithOwner); - return new(null); - } - if (context.customDescr() is {} descr) - { -#nullable disable // Disable nullability to work around lack of variance. - return VisitCustomDescr(descr); -#nullable restore - } - throw new UnreachableException(); - } - - GrammarResult ICILVisitor.VisitCustomDescrInMethodBody(CILParser.CustomDescrInMethodBodyContext context) => VisitCustomDescrInMethodBody(context); - public GrammarResult.Literal VisitCustomDescrInMethodBody(CILParser.CustomDescrInMethodBodyContext context) - { - if (context.customDescrWithOwner() is {} descrWithOwner) - { - // Visit the custom attribute descriptor to record it, - // but don't return it as it will already have its owner recorded. - _ = VisitCustomDescrWithOwner(descrWithOwner); - return new(null); - } - if (context.customDescr() is {} descr) - { -#nullable disable // Disable nullability to work around lack of variance. - return VisitCustomDescr(descr); -#nullable restore - } - throw new UnreachableException(); - } - - GrammarResult ICILVisitor.VisitCustomBlobArgs(CILParser.CustomBlobArgsContext context) => VisitCustomBlobArgs(context); - public GrammarResult.FormattedBlob VisitCustomBlobArgs(CILParser.CustomBlobArgsContext context) - { - BlobBuilder blob = new(); - foreach (var item in context.serInit()) - { - VisitSerInit(item).Value.WriteContentTo(blob); - } - return new(blob); - } - - private const ushort CustomAttributeBlobFormatVersion = 1; - - GrammarResult ICILVisitor.VisitCustomBlobDescr(CILParser.CustomBlobDescrContext context) => VisitCustomBlobDescr(context); - public GrammarResult.FormattedBlob VisitCustomBlobDescr(CILParser.CustomBlobDescrContext context) - { - var blob = new BlobBuilder(); - // Custom attribute blob prolog is a 2-byte unsigned integer (ECMA-335 II.23.3) - blob.WriteUInt16(CustomAttributeBlobFormatVersion); - VisitCustomBlobArgs(context.customBlobArgs()).Value.WriteContentTo(blob); - VisitCustomBlobNVPairs(context.customBlobNVPairs()).Value.WriteContentTo(blob); - return new(blob); - } - - GrammarResult ICILVisitor.VisitCustomBlobNVPairs(CILParser.CustomBlobNVPairsContext context) => VisitCustomBlobNVPairs(context); - public GrammarResult.FormattedBlob VisitCustomBlobNVPairs(CILParser.CustomBlobNVPairsContext context) - { - var blob = new BlobBuilder(); - var fieldOrProps = context.fieldOrProp(); - var types = context.serializType(); - var names = context.dottedName(); - var values = context.serInit(); - - blob.WriteInt16((short)fieldOrProps.Length); - - for (int i = 0; i < fieldOrProps.Length; i++) - { - var fieldOrProp = fieldOrProps[i].GetText() == "field" ? CustomAttributeNamedArgumentKind.Field : CustomAttributeNamedArgumentKind.Property; - var type = VisitSerializType(types[i]).Value; - var name = VisitDottedName(names[i]).Value; - var value = VisitSerInit(values[i]).Value; - blob.WriteByte((byte)fieldOrProp); - type.WriteContentTo(blob); - blob.WriteSerializedString(name); - value.WriteContentTo(blob); - } - return new(blob); - } - - GrammarResult ICILVisitor.VisitCustomDescr(CILParser.CustomDescrContext context) => VisitCustomDescr(context); - public GrammarResult.Literal VisitCustomDescr(CILParser.CustomDescrContext context) - { - var ctor = VisitCustomType(context.customType()).Value; - BlobBuilder value; - if (context.customBlobDescr() is {} customBlobDescr) - { - value = VisitCustomBlobDescr(customBlobDescr).Value; - } - else if (context.bytes() is {} bytes) - { - value = new(); - value.WriteBytes(VisitBytes(bytes).Value); - } - else if (context.compQstring() is {} str) - { - value = new(); - value.WriteUTF8(VisitCompQstring(str).Value); - // COMPAT: We treat this string as a string-reprensentation of a blob, - // so we don't emit the null terminator. - } - else - { - value = new(); - value.WriteUInt16(CustomAttributeBlobFormatVersion); - value.WriteUInt16(0); - } - - var attribute = _entityRegistry.CreateCustomAttribute(ctor, value); - attribute.Location = Location.From(context.Start, _documents); - return new(attribute); - } - - GrammarResult ICILVisitor.VisitCustomDescrWithOwner(CILParser.CustomDescrWithOwnerContext context) => VisitCustomDescrWithOwner(context); - - public GrammarResult.Literal VisitCustomDescrWithOwner(CILParser.CustomDescrWithOwnerContext context) - { - var ctor = VisitCustomType(context.customType()).Value; - BlobBuilder value; - if (context.customBlobDescr() is {} customBlobDescr) - { - value = VisitCustomBlobDescr(customBlobDescr).Value; - } - else if (context.bytes() is {} bytes) - { - value = new(); - value.WriteBytes(VisitBytes(bytes).Value); - } - else if (context.compQstring() is {} str) - { - value = new(); - value.WriteUTF8(VisitCompQstring(str).Value); - // COMPAT: We treat this string as a string-reprensentation of a blob, - // so we don't emit the null terminator. - } - else - { - value = new(); - value.WriteUInt16(CustomAttributeBlobFormatVersion); - value.WriteUInt16(0); - } - - var attr = _entityRegistry.CreateCustomAttribute(ctor, value); - - attr.Location = Location.From(context.Start, _documents); - attr.Owner = VisitOwnerType(context.ownerType()).Value; - - return new(attr); - } - - GrammarResult ICILVisitor.VisitCustomType(CILParser.CustomTypeContext context) => VisitCustomType(context); - public GrammarResult.Literal VisitCustomType(CILParser.CustomTypeContext context) => VisitMethodRef(context.methodRef()); - - public GrammarResult VisitDataDecl(CILParser.DataDeclContext context) - { - _ = VisitDdHead(context.ddHead()); - _ = VisitDdBody(context.ddBody()); - return GrammarResult.SentinelValue.Result; - } - public GrammarResult VisitDdBody(CILParser.DdBodyContext context) - { - if (context.ddItemList() is CILParser.DdItemListContext ddItemList) - { - _ = VisitDdItemList(ddItemList); - } - else - { - foreach (var item in context.ddItem()) - { - _ = VisitDdItem(item); - } - } - return GrammarResult.SentinelValue.Result; - } - public GrammarResult VisitDdHead(CILParser.DdHeadContext context) - { - if (context.id() is CILParser.IdContext id) - { - string name = VisitId(id).Value; - if (!_mappedFieldDataNames.ContainsKey(name)) - { - _mappedFieldDataNames.Add(name, _mappedFieldData.Count); - } - } - return GrammarResult.SentinelValue.Result; - } - public GrammarResult VisitDdItem(CILParser.DdItemContext context) - { - if (context.compQstring() is CILParser.CompQstringContext str) - { - var value = VisitCompQstring(str).Value; - _mappedFieldData.WriteUTF16(value); - return GrammarResult.SentinelValue.Result; - } - else if (context.id() is CILParser.IdContext id) - { - // Reference to another data label - this will be patched with the target's RVA - // during PE serialization by VTableExportPEBuilder.ApplyDataLabelFixups() - string name = VisitId(id).Value; - if (!_mappedFieldDataReferenceFixups.TryGetValue(name, out var fixups)) - { - _mappedFieldDataReferenceFixups[name] = fixups = new(); - } - - // Reserve 4 bytes for the RVA that will be patched later - fixups.Add(_mappedFieldData.ReserveBytes(4)); - return GrammarResult.SentinelValue.Result; - } - else if (context.bytes() is CILParser.BytesContext bytes) - { - _mappedFieldData.WriteBytes(VisitBytes(bytes).Value); - return GrammarResult.SentinelValue.Result; - } - - int itemCount = VisitDdItemCount(context.ddItemCount()).Value; - - if (context.INT8() is not null) - { - _mappedFieldData.WriteBytes(context.int32() is CILParser.Int32Context int32 ? (byte)VisitInt32(int32).Value : (byte)0, itemCount); - } - else if (context.INT16() is not null) - { - for (int i = 0; i < itemCount; i++) - { - _mappedFieldData.WriteInt16(context.int32() is CILParser.Int32Context int32 ? (short)VisitInt32(int32).Value : (short)0); - } - } - else if (context.INT32_() is not null) - { - for (int i = 0; i < itemCount; i++) - { - _mappedFieldData.WriteInt32(context.int32() is CILParser.Int32Context int32 ? VisitInt32(int32).Value : 0); - } - } - else if (context.INT64_() is not null) - { - for (int i = 0; i < itemCount; i++) - { - _mappedFieldData.WriteInt64(context.int64() is CILParser.Int64Context int64 ? VisitInt64(int64).Value : 0); - } - } - else if (context.FLOAT32() is not null) - { - for (int i = 0; i < itemCount; i++) - { - _mappedFieldData.WriteSingle(context.float64() is CILParser.Float64Context float64 ? (float)VisitFloat64(float64).Value : 0); - } - } - else if (context.FLOAT64_() is not null) - { - for (int i = 0; i < itemCount; i++) - { - _mappedFieldData.WriteDouble(context.float64() is CILParser.Float64Context float64 ? VisitFloat64(float64).Value : 0); - } - } - return GrammarResult.SentinelValue.Result; - } - GrammarResult ICILVisitor.VisitDdItemCount(CILParser.DdItemCountContext context) => VisitDdItemCount(context); - public GrammarResult.Literal VisitDdItemCount(CILParser.DdItemCountContext context) => new(context.int32() is CILParser.Int32Context ? VisitInt32(context.int32()).Value : 1); - public GrammarResult VisitDdItemList(CILParser.DdItemListContext context) - { - foreach (var item in context.ddItem()) - { - VisitDdItem(item); - } - return GrammarResult.SentinelValue.Result; - } - - private readonly Stack _currentNamespace = new(); - - private readonly Stack _currentTypeDefinition = new(); - - public GrammarResult VisitDecl(CILParser.DeclContext context) - { - bool isTrailingCustomAttribute = - context.customAttrDecl() is { } customAttribute && - customAttribute.dottedName() is null; - if (context.fieldDecl() is null && !isTrailingCustomAttribute) - { - _pendingClassCustomAttributeOwner = null; - } - - if (context.nameSpaceHead() is CILParser.NameSpaceHeadContext ns) - { - string namespaceName = VisitNameSpaceHead(ns).Value; - string? outer = _currentNamespace.PeekOrDefault(); - _currentNamespace.Push(string.IsNullOrEmpty(outer) ? namespaceName : $"{outer}.{namespaceName}"); - VisitDecls(context.decls()); - _currentNamespace.Pop(); - _pendingClassCustomAttributeOwner = null; - return GrammarResult.SentinelValue.Result; - } - if (context.classHead() is CILParser.ClassHeadContext classHead) - { - _currentTypeDefinition.Push(VisitClassHead(classHead).Value); - VisitClassDecls(context.classDecls()); - _currentTypeDefinition.Pop(); - _pendingClassCustomAttributeOwner = null; - return GrammarResult.SentinelValue.Result; - } - if (context.methodHead() is CILParser.MethodHeadContext methodHead) - { - _currentMethod = new(VisitMethodHead(methodHead).Value); - VisitMethodDecls(context.methodDecls()); - if (_currentMethod.AllLocals.Count > 0) - { - var localsSig = new BlobBuilder(); - var encoder = new BlobEncoder(localsSig); - var localsEncoder = encoder.LocalVariableSignature(_currentMethod.AllLocals.Count); - foreach (var local in _currentMethod.AllLocals) - { - local.SignatureBlob.WriteContentTo(localsEncoder.AddVariable().Builder); - } - _currentMethod.Definition.LocalsSignature = _entityRegistry.GetOrCreateStandaloneSignature(localsSig); - } - _currentMethod = null; - return GrammarResult.SentinelValue.Result; - } - if (context.fieldDecl() is { } fieldDecl) - { - _ = VisitFieldDecl(fieldDecl); - return GrammarResult.SentinelValue.Result; - } - if (context.dataDecl() is { } dataDecl) - { - _ = VisitDataDecl(dataDecl); - return GrammarResult.SentinelValue.Result; - } - if (context.vtableDecl() is { } vtable) - { - _ = VisitVtableDecl(vtable); - return GrammarResult.SentinelValue.Result; - } - if (context.vtfixupDecl() is { } vtFixup) - { - _ = VisitVtfixupDecl(vtFixup); - return GrammarResult.SentinelValue.Result; - } - if (context.extSourceSpec() is { } extSourceSpec) - { - _ = VisitExtSourceSpec(extSourceSpec); - return GrammarResult.SentinelValue.Result; - } - if (context.fileDecl() is { } fileDecl) - { - _ = VisitFileDecl(fileDecl); - return GrammarResult.SentinelValue.Result; - } - if (context.assemblyBlock() is { } assemblyBlock) - { - _ = VisitAssemblyBlock(assemblyBlock); - return GrammarResult.SentinelValue.Result; - } - if (context.assemblyRefHead() is { } assemblyRef) - { - var asmRef = VisitAssemblyRefHead(assemblyRef).Value; - _currentAssemblyOrRef = asmRef; - foreach (var decl in context.assemblyRefDecls().assemblyRefDecl()) - { - _ = VisitAssemblyRefDecl(decl); - } - _currentAssemblyOrRef = null; - } - if (context.exptypeHead() is { } exptypeHead) - { - var (attrs, dottedName) = VisitExptypeHead(exptypeHead).Value; - (string typeNamespace, string name) = NameHelpers.SplitDottedNameToNamespaceAndName(dottedName); - var (impl, typeDefId, customAttrs) = VisitExptypeDecls(context.exptypeDecls()).Value; - if (impl is null) - { - // COMPAT: Like native ilasm, warn and skip the exported type when implementation is not specified - ReportWarning(DiagnosticIds.MissingExportedTypeImplementation, - string.Format(DiagnosticMessageTemplates.MissingExportedTypeImplementation, dottedName), - exptypeHead); - return GrammarResult.SentinelValue.Result; - } - var exp = _entityRegistry.GetOrCreateExportedType(impl, typeNamespace, name, exp => - { - exp.Attributes = attrs; - exp.TypeDefinitionId = typeDefId; - }); - foreach (var attr in customAttrs) - { - attr.Owner = exp; - } - return GrammarResult.SentinelValue.Result; - } - if (context.manifestResHead() is { } manifestResHead) - { - var (name, alias, flags) = VisitManifestResHead(manifestResHead).Value; - var (implementation, offset, attrs) = VisitManifestResDecls(context.manifestResDecls()).Value; - if (implementation is null) - { - offset = (uint)_manifestResources.Count; - byte[] resourceData = _resourceLocator(alias); - if (resourceData is null) - { - ReportError(DiagnosticIds.FileNotFound, - string.Format(DiagnosticMessageTemplates.FileNotFound, alias), - context); - } - else - { - // ECMA-335: Each resource is prefixed with a 4-byte length - _manifestResources.WriteInt32(resourceData.Length); - _manifestResources.WriteBytes(resourceData); - } - } - var res = _entityRegistry.CreateManifestResource(name, offset); - res.Attributes = flags; - res.Implementation = implementation; - foreach (var attr in attrs) - { - attr.Owner = res; - } - return GrammarResult.SentinelValue.Result; - } - if (context.moduleHead() is { } moduleHead) - { - if (moduleHead.dottedName() is null) - { - _entityRegistry.Module.Name = null; - } - else if (moduleHead.ChildCount == 2) - { - _entityRegistry.Module.Name = VisitDottedName(moduleHead.dottedName()).Value; - } - else - { - var name = VisitDottedName(moduleHead.dottedName()).Value; - _entityRegistry.GetOrCreateModuleReference(name, _ => { }); - } - return GrammarResult.SentinelValue.Result; - } - if (context.subsystem() is { } subsystem) - { - _subsystem = (Subsystem)VisitSubsystem(subsystem).Value; - } - if (context.corflags() is { } corflags) - { - _corflags = (CorFlags)VisitCorflags(corflags).Value; - } - if (context.alignment() is { } alignment) - { - _alignment = VisitAlignment(alignment).Value; - } - if (context.imagebase() is { } imagebase) - { - _imageBase = VisitImagebase(imagebase).Value; - } - if (context.stackreserve() is { } stackreserve) - { - _stackReserve = VisitStackreserve(stackreserve).Value; - } - if (context.languageDecl() is { } languageDecl) - { - VisitLanguageDecl(languageDecl); - } - if (context.customAttrDecl() is { } topLevelCustomAttr) - { - if (VisitCustomAttrDecl(topLevelCustomAttr).Value is { } customAttr) - { - customAttr.Owner = (EntityRegistry.EntityBase?)_pendingClassCustomAttributeOwner ?? _entityRegistry.Module; - } - } - if (context.secDecl() is { } topSecDecl) - { - var declarativeSecurity = VisitSecDecl(topSecDecl).Value; - declarativeSecurity?.Parent = _entityRegistry.Assembly; - } - if (context.typedefDecl() is { } typedefDecl) - { - VisitTypedefDecl(typedefDecl); - } - if (context.typelist() is { } typelist) - { - foreach (var name in typelist.className()) - { - _ = VisitClassName(name); - } - } - if (context.mscorlib() is { } mscorlib) - { - VisitMscorlib(mscorlib); - } - return GrammarResult.SentinelValue.Result; - } - - public GrammarResult VisitDecls(CILParser.DeclsContext context) - { - foreach (var decl in context.decl()) - { - _ = VisitDecl(decl); - } - return GrammarResult.SentinelValue.Result; - } - - GrammarResult ICILVisitor.VisitDottedName(CILParser.DottedNameContext context) - { - return VisitDottedName(context); - } - - public static GrammarResult.String VisitDottedName(CILParser.DottedNameContext context) - { - CILParser.DottedNamePartContext[] parts = context.dottedNamePart(); - if (parts.Length > 0) - { - StringBuilder builder = new(); - for (int i = 0; i < parts.Length; i++) - { - if (i > 0) - { - builder.Append('.'); - } - - CILParser.DottedNamePartContext part = parts[i]; - builder.Append(part.SQSTRING() is { } quotedPart - ? StringHelpers.ParseQuotedString(quotedPart.GetText()) - : part.GetText()); - } - - return new(builder.ToString()); - } - - string text = context.GetText(); - if (context.SQSTRING() is not null && text.Length >= 2 && text[0] == '\'') - { - text = text.Substring(1, text.Length - 2); - } - return new(text); - } - - GrammarResult ICILVisitor.VisitDottedNamePart(CILParser.DottedNamePartContext context) => throw new UnreachableException(); - GrammarResult ICILVisitor.VisitElementType(CILParser.ElementTypeContext context) => VisitElementType(context); - public GrammarResult.FormattedBlob VisitElementType(CILParser.ElementTypeContext context) - { - BlobBuilder blob = new(5); - if (context.OBJECT() is not null) - { - blob.WriteByte((byte)SignatureTypeCode.Object); - } - else if (context.className() is CILParser.ClassNameContext className) - { - EntityRegistry.TypeEntity typeEntity = VisitClassName(className).Value; - if (context.VALUE() is not null || context.VALUETYPE() is not null) - { - // Check for well-known value types that should use primitive type codes - if (TryGetPrimitiveTypeCode(typeEntity, isValueType: true) is { } vtPrimCode) - { - blob.WriteByte((byte)vtPrimCode); - } - else - { - blob.WriteByte((byte)SignatureTypeKind.ValueType); - blob.WriteTypeEntity(typeEntity); - } - } - else - { - // Check for well-known class types that should use primitive type codes - if (TryGetPrimitiveTypeCode(typeEntity, isValueType: false) is { } clsPrimCode) - { - blob.WriteByte((byte)clsPrimCode); - } - else - { - blob.WriteByte((byte)SignatureTypeKind.Class); - blob.WriteTypeEntity(typeEntity); - } - } - } - else if (context.callConv() is CILParser.CallConvContext callConv) - { - // Emit function pointer signature. - blob.WriteByte((byte)SignatureTypeCode.FunctionPointer); - byte sigCallConv = VisitCallConv(callConv).Value; - blob.WriteByte(sigCallConv); - var signatureArgs = VisitSigArgs(context.sigArgs()).Value; - int numArgs = signatureArgs.Count(arg => !arg.IsSentinel); - blob.WriteCompressedInteger(numArgs); - blob.LinkSuffix(VisitType(context.type()).Value); - foreach (var arg in signatureArgs) - { - blob.LinkSuffix(arg.SignatureBlob); - } - } - else if (context.ELLIPSIS() is not null) - { - blob.WriteByte((byte)SignatureTypeCode.Sentinel); - blob.LinkSuffix(VisitType(context.type()).Value); - } - else if (context.METHOD_TYPE_PARAMETER() is not null) - { - if (context.int32() is CILParser.Int32Context int32) - { - // COMPAT: Always write a reference to a generic method parameter by index - // even if we aren't in a method or the index is out of range. We want to be able to write invalid IL like this. - blob.WriteByte((byte)SignatureTypeCode.GenericMethodParameter); - blob.WriteCompressedInteger(VisitInt32(int32).Value); - } - else - { - string dottedName = VisitDottedName(context.dottedName()).Value; - if (_currentMethod is null) - { - ReportError(DiagnosticIds.MethodTypeParameterOutsideMethod, string.Format(DiagnosticMessageTemplates.MethodTypeParameterOutsideMethod, dottedName), context); - blob.WriteByte((byte)SignatureTypeCode.GenericMethodParameter); - blob.WriteCompressedInteger(0); - } - else - { - blob.WriteByte((byte)SignatureTypeCode.GenericMethodParameter); - bool foundParameter = false; - for (int i = 0; i < _currentMethod.Definition.GenericParameters.Count; i++) - { - EntityRegistry.GenericParameterEntity? genericParameter = _currentMethod.Definition.GenericParameters[i]; - if (genericParameter.Name == dottedName) - { - foundParameter = true; - blob.WriteCompressedInteger(i); - break; - } - } - if (!foundParameter) - { - // BREAK-COMPAT: ILASM would silently emit an invalid signature when a method uses an invalid method type parameter but doesn't have method type parameters. - // The signature used completely invalid undocumented codes (that were really sentinel values for how ilasm later detected errors due to how the parsing model worked with a YACC-based parser) - // and when a method had no type parameters, it didn't run the code to process out these values and emit errors. - // This seems like a scenario that doesn't need to be brought forward. - // Instead, we'll just emit a reference to "generic method parameter" 0 and report an error. - - ReportError(DiagnosticIds.GenericParameterNotFound, string.Format(DiagnosticMessageTemplates.GenericParameterNotFound, dottedName), context); - blob.WriteCompressedInteger(0); - } - } - } - } - else if (context.TYPE_PARAMETER() is not null) - { - if (context.int32() is CILParser.Int32Context int32) - { - // COMPAT: Always write a reference to a generic type parameter by index - // even if we aren't in a type or the index is out of range. We want to be able to write invalid IL like this. - blob.WriteByte((byte)SignatureTypeCode.GenericTypeParameter); - blob.WriteCompressedInteger(VisitInt32(int32).Value); - } - else - { - string dottedName = VisitDottedName(context.dottedName()).Value; - if (_currentTypeDefinition.Count == 0) - { - ReportError(DiagnosticIds.TypeParameterOutsideType, string.Format(DiagnosticMessageTemplates.TypeParameterOutsideType, dottedName), context); - blob.WriteByte((byte)SignatureTypeCode.GenericTypeParameter); - blob.WriteCompressedInteger(0); - } - else - { - blob.WriteByte((byte)SignatureTypeCode.GenericTypeParameter); - bool foundParameter = false; - for (int i = 0; i < _currentTypeDefinition.Peek().GenericParameters.Count; i++) - { - EntityRegistry.GenericParameterEntity? genericParameter = _currentTypeDefinition.Peek().GenericParameters[i]; - if (genericParameter.Name == dottedName) - { - foundParameter = true; - blob.WriteCompressedInteger(i); - break; - } - } - if (!foundParameter) - { - // BREAK-COMPAT: ILASM would silently emit an invalid signature when a type uses an invalid method type parameter but doesn't have any type parameters. - // The signature used completely invalid undocumented codes (that were really sentinel values for how ilasm later detected errors due to how the parsing model worked with a YACC-based parser) - // and when a method had no type parameters, it didn't run the code to process out these values and emit errors. - // This seems like a scenario that doesn't need to be brought forward. - // Instead, we'll just emit a reference to "generic method parameter" 0 and report an error. - - ReportError(DiagnosticIds.GenericParameterNotFound, string.Format(DiagnosticMessageTemplates.GenericParameterNotFound, dottedName), context); - blob.WriteCompressedInteger(0); - } - } - } - } - else if (context.TYPEDREF() is not null) - { - blob.WriteByte((byte)SignatureTypeCode.TypedReference); - } - else if (context.VOID() is not null) - { - blob.WriteByte((byte)SignatureTypeCode.Void); - } - else if (context.nativeInt() is not null) - { - blob.WriteByte((byte)SignatureTypeCode.IntPtr); - } - else if (context.nativeUint() is not null) - { - blob.WriteByte((byte)SignatureTypeCode.UIntPtr); - } - else if (context.simpleType() is CILParser.SimpleTypeContext simpleType) - { - blob.WriteByte((byte)VisitSimpleType(simpleType).Value); - } - else if (context.dottedName() is CILParser.DottedNameContext dottedName) - { - // Typedef reference - resolve and write the type blob - string alias = VisitDottedName(dottedName).Value; - var resolved = TryResolveTypedefAsTypeBlob(alias); - if (resolved is not null) - { - // Copy the content to avoid modifying the stored blob - resolved.WriteContentTo(blob); - } - else - { - ReportError(DiagnosticIds.TypedefNotFound, string.Format(DiagnosticMessageTemplates.TypedefNotFound, alias), context); - } - } - else - { - throw new UnreachableException(); - } - return new(blob); - } - - public GrammarResult VisitErrorNode(IErrorNode node) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - - // esHead is '.line' or '#line' - this is just the keyword, actual parsing is in VisitExtSourceSpec. - public GrammarResult VisitEsHead(CILParser.EsHeadContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - - GrammarResult ICILVisitor.VisitEventAttr(CILParser.EventAttrContext context) => VisitEventAttr(context); - public GrammarResult.Flag VisitEventAttr(CILParser.EventAttrContext context) - { - return context.GetText() switch - { - "specialname" => new(EventAttributes.SpecialName), - "rtspecialname" => new(0), // COMPAT: Ignore - _ => throw new UnreachableException(), - }; - } - - GrammarResult ICILVisitor.VisitEventDecl(CILParser.EventDeclContext context) => VisitEventDecl(context); - public GrammarResult.Literal<(MethodSemanticsAttributes, EntityRegistry.EntityBase)?> VisitEventDecl(CILParser.EventDeclContext context) - { - if (context.ChildCount != 2) - { - return new(null); - } - string accessor = context.GetChild(0).GetText(); - EntityRegistry.EntityBase memberReference = VisitMethodRef(context.methodRef()).Value; - MethodSemanticsAttributes methodSemanticsAttributes = accessor switch - { - ".addon" => MethodSemanticsAttributes.Adder, - ".removeon" => MethodSemanticsAttributes.Remover, - ".fire" => MethodSemanticsAttributes.Raiser, - ".other" => MethodSemanticsAttributes.Other, - _ => throw new UnreachableException(), - }; - return new((methodSemanticsAttributes, memberReference)); - } - - GrammarResult ICILVisitor.VisitEventDecls(CILParser.EventDeclsContext context) => VisitEventDecls(context); - public GrammarResult.Sequence<(MethodSemanticsAttributes, EntityRegistry.EntityBase)> VisitEventDecls(CILParser.EventDeclsContext context) - => new( - context.eventDecl() - .Select(decl => VisitEventDecl(decl).Value) - .Where(decl => decl is not null) - .Select(decl => decl!.Value).ToImmutableArray()); - - GrammarResult ICILVisitor.VisitEventHead(CILParser.EventHeadContext context) => VisitEventHead(context); - public GrammarResult.Literal VisitEventHead(CILParser.EventHeadContext context) - { - string name = VisitDottedName(context.dottedName()).Value; - EventAttributes eventAttributes = context.eventAttr().Select(attr => VisitEventAttr(attr).Value).Aggregate((EventAttributes)0, (a, b) => a | b); - return new(new EntityRegistry.EventEntity(eventAttributes, VisitTypeSpec(context.typeSpec()).Value, name)); - } - - public GrammarResult VisitExportHead(CILParser.ExportHeadContext context) => throw new NotImplementedException("Obsolete syntax"); - GrammarResult ICILVisitor.VisitExptAttr(CILParser.ExptAttrContext context) => VisitExptAttr(context); - public static GrammarResult.Flag VisitExptAttr(CILParser.ExptAttrContext context) - { - return context.GetText() switch - { - "private" => new(TypeAttributes.NotPublic, TypeAttributes.VisibilityMask), - "public" => new(TypeAttributes.Public, TypeAttributes.VisibilityMask), - "forwarder" => new(TypeAttributes.Forwarder), - "nestedpublic" => new(TypeAttributes.NestedPublic, TypeAttributes.VisibilityMask), - "nestedprivate" => new(TypeAttributes.NestedPrivate, TypeAttributes.VisibilityMask), - "nestedfamily" => new(TypeAttributes.NestedFamily, TypeAttributes.VisibilityMask), - "nestedassembly" => new(TypeAttributes.NestedAssembly, TypeAttributes.VisibilityMask), - "nestedfamandassem" => new(TypeAttributes.NestedFamANDAssem, TypeAttributes.VisibilityMask), - "nestedfamorassem" => new(TypeAttributes.NestedFamORAssem, TypeAttributes.VisibilityMask), - _ => throw new UnreachableException(), - }; - } - - // Type exports and forwarders are implemented via VisitExptypeDecls - public GrammarResult VisitExptypeDecl(CILParser.ExptypeDeclContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - - GrammarResult ICILVisitor.VisitExptypeDecls(CILParser.ExptypeDeclsContext context) => VisitExptypeDecls(context); - public GrammarResult.Literal<(EntityRegistry.EntityBase? implementation, int typedefId, ImmutableArray attrs)> VisitExptypeDecls(CILParser.ExptypeDeclsContext context) - { - // COMPAT: The following order specifies the precedence of the various export kinds. - // File, Assembly, Class (enclosing type), invalid token. - // We'll process through all of the options here and then return the one that is valid. - // We'll also record custom attributes here. - EntityRegistry.EntityBase? implementationEntity = null; - int typedefId = 0; - var attrs = ImmutableArray.CreateBuilder(); - var declarations = context.exptypeDecl(); - for (int i = 0; i < declarations.Length; i++) - { - if (declarations[i].customAttrDecl() is { } attr) - { - if (VisitCustomAttrDecl(attr).Value is EntityRegistry.CustomAttributeEntity customAttribute) - { - attrs.Add(customAttribute); - } - continue; - } - if (declarations[i].mdtoken() is { } mdToken) - { - var entity = VisitMdtoken(mdToken).Value; - if (entity is null or EntityRegistry.FakeTypeEntity) - { - ReportError(DiagnosticIds.InvalidMetadataToken, DiagnosticMessageTemplates.InvalidMetadataToken, declarations[i]); - } - implementationEntity = ResolveBetterEntity(entity); - continue; - } - string kind = declarations[i].GetText(); - if (kind.StartsWith(".file")) - { - string fileName = VisitDottedName(declarations[i].dottedName()).Value; - implementationEntity = _entityRegistry.FindFile(fileName); - if (implementationEntity is null) - { - ReportError(DiagnosticIds.FileNotFound, string.Format(DiagnosticMessageTemplates.FileNotFound, fileName), declarations[i]); - } - } - else if (kind.StartsWith(".assembly")) - { - string assemblyName = VisitDottedName(declarations[i].dottedName()).Value; - implementationEntity = _entityRegistry.FindAssemblyReference(assemblyName); - if (implementationEntity is null) - { - ReportError(DiagnosticIds.AssemblyNotFound, string.Format(DiagnosticMessageTemplates.AssemblyNotFound, assemblyName), declarations[i]); - } - } - else if (kind.StartsWith(".class")) - { - if (declarations[i].int32() is CILParser.Int32Context int32) - { - typedefId = VisitInt32(int32).Value; - } - else - { - _ = VisitSlashedName(declarations[i].slashedName()); - var containing = ResolveExportedType(declarations[i].slashedName()); - if (containing is null) - { - ReportError(DiagnosticIds.ExportedTypeNotFound, string.Format(DiagnosticMessageTemplates.ExportedTypeNotFound, declarations[i].slashedName().GetText()), declarations[i]); - } - else - { - implementationEntity = ResolveBetterEntity(containing); - } - } - } - } - - return new((implementationEntity, typedefId, attrs.ToImmutable())); - - EntityRegistry.EntityBase? ResolveBetterEntity(EntityRegistry.EntityBase? newImplementation) - { - return (implementationEntity, newImplementation) switch - { - (null, _) => newImplementation, - (_, null) => implementationEntity, - (_, EntityRegistry.FileEntity) => newImplementation, - (EntityRegistry.FileEntity, _) => implementationEntity, - (_, EntityRegistry.AssemblyEntity) => newImplementation, - (EntityRegistry.AssemblyEntity, _) => implementationEntity, - (_, EntityRegistry.TypeEntity) => newImplementation, - (EntityRegistry.TypeEntity, _) => implementationEntity, - _ => throw new UnreachableException(), - }; - } - - // Resolve ExportedType reference - EntityRegistry.ExportedTypeEntity? ResolveExportedType(CILParser.SlashedNameContext slashedName) - { - TypeName typeName = VisitSlashedName(slashedName).Value; - if (typeName.ContainingTypeName is null) - { - // Check for typedef - typedefs resolve to TypeEntity, not ExportedTypeEntity - // so we skip the typedef check for exported type resolution - } - Stack containingTypes = new(); - for (TypeName? containingType = typeName; containingType is not null; containingType = containingType.ContainingTypeName) - { - containingTypes.Push(containingType); - } - EntityRegistry.ExportedTypeEntity? exportedType = null; - while (containingTypes.Count != 0) - { - TypeName containingType = containingTypes.Pop(); - - (string ns, string name) = NameHelpers.SplitDottedNameToNamespaceAndName(containingType.DottedName); - - exportedType = _entityRegistry.FindExportedType( - exportedType, - ns, - name); - - if (exportedType is null) - { - ReportError(DiagnosticIds.ExportedTypeNotFound, string.Format(DiagnosticMessageTemplates.ExportedTypeNotFound, containingType.DottedName), slashedName); - return null; - } - } - - return exportedType!; - } - } - GrammarResult ICILVisitor.VisitExptypeHead(CILParser.ExptypeHeadContext context) => VisitExptypeHead(context); - public GrammarResult.Literal<(TypeAttributes attrs, string dottedName)> VisitExptypeHead(CILParser.ExptypeHeadContext context) - { - var attrs = context.exptAttr().Select(VisitExptAttr).Aggregate((TypeAttributes)0, (a, b) => a | b); - return new((attrs, VisitDottedName(context.dottedName()).Value)); - } - GrammarResult ICILVisitor.VisitExtendsClause(CILParser.ExtendsClauseContext context) => VisitExtendsClause(context); - - public GrammarResult.Literal VisitExtendsClause(CILParser.ExtendsClauseContext context) - { - if (context.typeSpec() is CILParser.TypeSpecContext typeSpec) - { - return new(VisitTypeSpec(typeSpec).Value); - } - else - { - return new(null); - } - } - - public GrammarResult VisitExtSourceSpec(CILParser.ExtSourceSpecContext context) - { - // Parse .line directive to extract source location info - // Grammar: esHead int32 (',' int32)? (':' int32 (',' int32)?)? (SQSTRING | QSTRING)? - var int32s = context.int32(); - var sqstring = context.SQSTRING(); - var qstring = context.QSTRING(); - - // Extract line/column info based on number of int32s - int startLine = 0, endLine = 0, startColumn = 0, endColumn = 0; - - if (int32s.Length >= 1) - { - startLine = VisitInt32(int32s[0]).Value; - endLine = startLine; - } - if (int32s.Length >= 2) - { - // Could be endLine or startColumn depending on separator - string contextText = context.GetText(); - if (contextText.Contains(',') && contextText.IndexOf(',') < contextText.IndexOf(':')) - { - // Format: startLine,endLine:... - endLine = VisitInt32(int32s[1]).Value; - } - else - { - // Format: line:column... - startColumn = VisitInt32(int32s[1]).Value; - endColumn = startColumn; - } - } - if (int32s.Length >= 3) - { - startColumn = VisitInt32(int32s[2]).Value; - endColumn = startColumn; - } - if (int32s.Length >= 4) - { - endColumn = VisitInt32(int32s[3]).Value; - } - - // Extract filename if present - string? filePath = null; - if (sqstring is not null) - { - filePath = StringHelpers.ParseQuotedString(sqstring.GetText()); - } - else if (qstring is not null) - { - filePath = StringHelpers.ParseQuotedString(qstring.GetText()); - } - - // Update current document path if specified - if (filePath is not null) - { - _currentDocumentPath = filePath; - } - - // If we're in a method, record the sequence point - if (_currentMethod is not null && _currentDocumentPath is not null) - { - int ilOffset = _currentMethod.Definition.MethodBody.Offset; - _currentMethod.Definition.DebugInfo.DocumentPath ??= _currentDocumentPath; - - // 0xFEEFEE indicates a hidden sequence point - if (startLine == 0xFEEFEE) - { - AddSequencePoint(EntityRegistry.SequencePoint.Hidden(ilOffset)); - } - else - { - if (endLine == startLine && endColumn == startColumn) - { - endColumn++; - } - - AddSequencePoint( - new EntityRegistry.SequencePoint( - ilOffset, - startLine, - startColumn, - endLine, - endColumn)); - } - - void AddSequencePoint(EntityRegistry.SequencePoint sequencePoint) - { - List sequencePoints = - _currentMethod.Definition.DebugInfo.SequencePoints; - if (sequencePoints.Count > 0 && sequencePoints[^1].ILOffset == ilOffset) - { - sequencePoints[^1] = sequencePoint; - } - else - { - sequencePoints.Add(sequencePoint); - } - } - } - - return GrammarResult.SentinelValue.Result; - } - - GrammarResult ICILVisitor.VisitF32seq(CILParser.F32seqContext context) => VisitF32seq(context); - public GrammarResult.FormattedBlob VisitF32seq(CILParser.F32seqContext context) - { - var builder = ImmutableArray.CreateBuilder(context.ChildCount); - - foreach (var item in context.children ?? []) - { - builder.Add((float)(item switch - { - CILParser.Int32Context int32 => VisitInt32(int32).Value, - CILParser.Float64Context float64 => VisitFloat64(float64).Value, - _ => throw new UnreachableException() - })); - } - return new(builder.ToImmutable().SerializeSequence()); - } - GrammarResult ICILVisitor.VisitF64seq(CILParser.F64seqContext context) => VisitF64seq(context); - public GrammarResult.FormattedBlob VisitF64seq(CILParser.F64seqContext context) - { - var builder = ImmutableArray.CreateBuilder(context.ChildCount); - - foreach (var item in context.children ?? []) - { - builder.Add((double)(item switch - { - CILParser.Int64Context int64 => VisitInt64(int64).Value, - CILParser.Float64Context float64 => VisitFloat64(float64).Value, - _ => throw new UnreachableException() - })); - } - return new(builder.ToImmutable().SerializeSequence()); - } - - public GrammarResult VisitFaultClause(CILParser.FaultClauseContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - - GrammarResult ICILVisitor.VisitFieldAttr(CILParser.FieldAttrContext context) => VisitFieldAttr(context); - public GrammarResult.Flag VisitFieldAttr(CILParser.FieldAttrContext context) - { - if (context.int32() is { } int32) - { - return new((FieldAttributes)VisitInt32(int32).Value, ShouldAppend: false); - } - - return context.GetText() switch - { - "static" => new(FieldAttributes.Static), - "public" => new(FieldAttributes.Public, FieldAttributes.FieldAccessMask), - "private" => new(FieldAttributes.Private, FieldAttributes.FieldAccessMask), - "family" => new(FieldAttributes.Family, FieldAttributes.FieldAccessMask), - "initonly" => new(FieldAttributes.InitOnly), - "rtspecialname" => new(FieldAttributes.RTSpecialName), - "specialname" => new(FieldAttributes.SpecialName), - "assembly" => new(FieldAttributes.Assembly, FieldAttributes.FieldAccessMask), - "famandassem" => new(FieldAttributes.FamANDAssem, FieldAttributes.FieldAccessMask), - "famorassem" => new(FieldAttributes.FamORAssem, FieldAttributes.FieldAccessMask), - "privatescope" => new(FieldAttributes.PrivateScope, FieldAttributes.FieldAccessMask), - "literal" => new(FieldAttributes.Literal), -#pragma warning disable SYSLIB0050 // FieldAttributes.NotSeralized is obsolete - "notserialized" => new(FieldAttributes.NotSerialized), -#pragma warning restore SYSLIB0050 // FieldAttributes.NotSeralized is obsolete - "volatile" => new(0), // COMPAT: volatile is not a field attribute; accepted for compatibility - _ => throw new UnreachableException() - }; - } - GrammarResult ICILVisitor.VisitFieldDecl(CILParser.FieldDeclContext context) => VisitFieldDecl(context); - public GrammarResult VisitFieldDecl(CILParser.FieldDeclContext context) - { - var fieldAttrs = context.fieldAttr().Select(VisitFieldAttr).Aggregate((FieldAttributes)0, (a, b) => a | b); - // COMPAT: Native ilasm implicitly adds SpecialName when RTSpecialName is set - if (fieldAttrs.HasFlag(FieldAttributes.RTSpecialName)) - { - fieldAttrs |= FieldAttributes.SpecialName; - } - var fieldType = VisitType(context.type()).Value; - var marshalBlobs = context.marshalBlob(); - var marshalBlob = marshalBlobs.Length > 0 ? VisitMarshalBlob(marshalBlobs[marshalBlobs.Length - 1]).Value : null; - string name = VisitDottedName(context.dottedName()).Value; - var rvaOffset = VisitAtOpt(context.atOpt()).Value; - var fieldOffset = VisitRepeatOpt(context.repeatOpt()).Value; - var constantValue = VisitInitOpt(context.initOpt()).Value; - - var signature = new BlobEncoder(new BlobBuilder()); - _ = signature.Field(); - fieldType.WriteContentTo(signature.Builder); - - var field = EntityRegistry.CreateUnrecordedFieldDefinition(fieldAttrs, _currentTypeDefinition.PeekOrDefault() ?? _entityRegistry.ModuleType, name, signature.Builder); - _pendingClassCustomAttributeOwner = field; - - if (field is not null) - { - field.MarshallingDescriptor = marshalBlob; - field.DataDeclarationName = rvaOffset; - field.Offset = fieldOffset; - if (constantValue is not NoConstantSentinel) - { - field.ConstantValue = constantValue; - field.HasConstant = true; - } - } - - return GrammarResult.SentinelValue.Result; - } - - GrammarResult ICILVisitor.VisitFieldInit(CILParser.FieldInitContext context) => VisitFieldInit(context); - public GrammarResult.Literal VisitFieldInit(CILParser.FieldInitContext context) - { - // fieldInit: fieldSerInit | compQstring | NULLREF; - if (context.NULLREF() is not null) - { - return new(null); - } - if (context.compQstring() is CILParser.CompQstringContext compQstring) - { - return new(VisitCompQstring(compQstring).Value); - } - if (context.fieldSerInit() is CILParser.FieldSerInitContext fieldSerInit) - { - // fieldSerInit returns a blob with type byte prefix - extract the actual value - var blob = VisitFieldSerInit(fieldSerInit).Value; - return new(ExtractConstantFromSerInit(blob)); - } - return new(null); - } - - private static object? ExtractConstantFromSerInit(BlobBuilder blob) - { - var bytes = blob.ToImmutableArray(); - if (bytes.Length == 0) - { - return null; - } - - var typeCode = (SerializationTypeCode)bytes[0]; - var valueBytes = bytes.AsSpan().Slice(1); - - return typeCode switch - { - SerializationTypeCode.Boolean => valueBytes.Length >= 1 && valueBytes[0] != 0, - SerializationTypeCode.Char => valueBytes.Length >= 2 ? BitConverter.ToChar(valueBytes) : '\0', - SerializationTypeCode.SByte => valueBytes.Length >= 1 ? (sbyte)valueBytes[0] : (sbyte)0, - SerializationTypeCode.Byte => valueBytes.Length >= 1 ? valueBytes[0] : (byte)0, - SerializationTypeCode.Int16 => valueBytes.Length >= 2 ? BitConverter.ToInt16(valueBytes) : (short)0, - SerializationTypeCode.UInt16 => valueBytes.Length >= 2 ? BitConverter.ToUInt16(valueBytes) : (ushort)0, - SerializationTypeCode.Int32 => valueBytes.Length >= 4 ? BitConverter.ToInt32(valueBytes) : 0, - SerializationTypeCode.UInt32 => valueBytes.Length >= 4 ? BitConverter.ToUInt32(valueBytes) : 0u, - SerializationTypeCode.Int64 => valueBytes.Length >= 8 ? BitConverter.ToInt64(valueBytes) : 0L, - SerializationTypeCode.UInt64 => valueBytes.Length >= 8 ? BitConverter.ToUInt64(valueBytes) : 0uL, - SerializationTypeCode.Single => valueBytes.Length >= 4 ? BitConverter.ToSingle(valueBytes) : 0f, - SerializationTypeCode.Double => valueBytes.Length >= 8 ? BitConverter.ToDouble(valueBytes) : 0d, - SerializationTypeCode.String => Encoding.Unicode.GetString(valueBytes), - // Type is encoded as a SerString (compressed length followed by UTF-8 type name) - SerializationTypeCode.Type => ExtractSerString(valueBytes), - // SZArray: element type followed by element count followed by elements - // Return the raw bytes for arrays since we can't easily represent them - SerializationTypeCode.SZArray => valueBytes.ToArray(), - // TaggedObject: type tag followed by value - return raw bytes - SerializationTypeCode.TaggedObject => valueBytes.ToArray(), - // Enum: type name (SerString) followed by underlying value - return raw bytes - SerializationTypeCode.Enum => valueBytes.ToArray(), - // For unknown/future type codes, return the raw bytes to preserve the data - _ => bytes.AsSpan().ToArray() - }; - } - - /// - /// Extracts a SerString (compressed length + UTF-8 string) from the given bytes. - /// Returns null if the first byte is 0xFF (null string marker). - /// - private static string? ExtractSerString(ReadOnlySpan bytes) - { - if (bytes.Length == 0) - { - return null; - } - // 0xFF indicates null string - if (bytes[0] == 0xFF) - { - return null; - } - // Decode compressed length - int length; - int bytesRead; - if ((bytes[0] & 0x80) == 0) - { - // 1-byte length - length = bytes[0]; - bytesRead = 1; - } - else if ((bytes[0] & 0xC0) == 0x80) - { - // 2-byte length - if (bytes.Length < 2) return null; - length = ((bytes[0] & 0x3F) << 8) | bytes[1]; - bytesRead = 2; - } - else - { - // 4-byte length - if (bytes.Length < 4) return null; - length = ((bytes[0] & 0x1F) << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]; - bytesRead = 4; - } - if (bytes.Length < bytesRead + length) - { - return null; - } - return Encoding.UTF8.GetString(bytes.Slice(bytesRead, length)); - } - - public GrammarResult VisitFieldOrProp(CILParser.FieldOrPropContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - - GrammarResult ICILVisitor.VisitFieldRef(CILParser.FieldRefContext context) => VisitFieldRef(context); - public GrammarResult.Literal VisitFieldRef(CILParser.FieldRefContext context) - { - if (context.type() is not CILParser.TypeContext type) - { - // This is a typedef reference for a field member - string alias = VisitDottedName(context.dottedName()).Value; - var resolved = TryResolveTypedefAsMember(alias); - if (resolved is not null) - { - return new(resolved); - } - ReportError(DiagnosticIds.TypedefNotFound, string.Format(DiagnosticMessageTemplates.TypedefNotFound, alias), context); - return new(_entityRegistry.CreateLazilyRecordedMemberReference(_entityRegistry.ModuleType, alias, new BlobBuilder())); - } - - var fieldTypeSig = VisitType(type).Value; - EntityRegistry.TypeEntity definingType = _entityRegistry.ModuleType; - if (context.typeSpec() is CILParser.TypeSpecContext typeSpec) - { - definingType = VisitTypeSpec(typeSpec).Value; - } - - string name = VisitDottedName(context.dottedName()).Value; - - var fieldSig = new BlobBuilder(fieldTypeSig.Count + 1); - fieldSig.WriteByte((byte)SignatureKind.Field); - fieldTypeSig.WriteContentTo(fieldSig); - return new(_entityRegistry.CreateLazilyRecordedMemberReference(definingType, name, fieldSig)); - } - - GrammarResult ICILVisitor.VisitFieldSerInit(CILParser.FieldSerInitContext context) => VisitFieldSerInit(context); - public GrammarResult.FormattedBlob VisitFieldSerInit(CILParser.FieldSerInitContext context) - { - // The max length for the majority of the blobs is 9 bytes. 1 for the type of blob, 8 for the max 64-bit value. - // Byte arrays can be larger, so we handle that case separately. - const int CommonMaxBlobLength = 9; - BlobBuilder builder; - var bytesNode = context.bytes(); - if (bytesNode is not null) - { - var bytesResult = VisitBytes(bytesNode); - // Our blob length is the number of bytes in the byte array + the code for the byte array. - builder = new BlobBuilder(bytesResult.Value.Length + 1); - builder.WriteByte((byte)SerializationTypeCode.String); - builder.WriteBytes(bytesResult.Value); - return new(builder); - } - builder = new BlobBuilder(CommonMaxBlobLength); - - int tokenType = ((ITerminalNode)context.GetChild(0)).Symbol.Type; - - builder.WriteByte((byte)GetTypeCodeForToken(tokenType)); - - switch (tokenType) - { - case CILParser.BOOL: - builder.WriteBoolean(VisitTruefalse(context.truefalse()).Value); - break; - case CILParser.INT8: - case CILParser.UINT8: - builder.WriteByte((byte)VisitInt32(context.int32()).Value); - break; - case CILParser.CHAR: - case CILParser.INT16: - case CILParser.UINT16: - builder.WriteInt16((short)VisitInt32(context.int32()).Value); - break; - case CILParser.INT32_: - case CILParser.UINT32: - builder.WriteInt32(VisitInt32(context.int32()).Value); - break; - case CILParser.INT64_: - case CILParser.UINT64: - builder.WriteInt64(VisitInt64(context.int64()).Value); - break; - case CILParser.FLOAT32: - { - if (context.float64() is CILParser.Float64Context float64) - { - string text = float64.GetText(); - if (!text.Contains('.') && - text.IndexOf('e') < 0 && - text.IndexOf('E') < 0 && - ParseIntegerValue(text.AsSpan(), out long rawValue)) - { - builder.WriteSingle(BitConverter.Int32BitsToSingle((int)rawValue)); - } - else - { - builder.WriteSingle((float)VisitFloat64(float64).Value); - } - } - if (context.int32() is CILParser.Int32Context int32) - { - int value = VisitInt32(int32).Value; - builder.WriteSingle(BitConverter.Int32BitsToSingle(value)); - } - break; - } - case CILParser.FLOAT64_: - { - if (context.float64() is CILParser.Float64Context float64) - { - string text = float64.GetText(); - if (!text.Contains('.') && - text.IndexOf('e') < 0 && - text.IndexOf('E') < 0 && - ParseIntegerValue(text.AsSpan(), out long rawValue)) - { - builder.WriteDouble(BitConverter.Int64BitsToDouble(rawValue)); - } - else - { - builder.WriteDouble(VisitFloat64(float64).Value); - } - } - if (context.int64() is CILParser.Int64Context int64) - { - long value = VisitInt64(int64).Value; - builder.WriteDouble(BitConverter.Int64BitsToDouble(value)); - } - break; - } - } - - return new(builder); - } - - GrammarResult ICILVisitor.VisitFileAttr(CILParser.FileAttrContext context) => VisitFileAttr(context); - public GrammarResult.Literal VisitFileAttr(CILParser.FileAttrContext context) - => context.ChildCount != 0 ? new(false) : new(true); - GrammarResult ICILVisitor.VisitFileDecl(CILParser.FileDeclContext context) => VisitFileDecl(context); - public GrammarResult.Literal VisitFileDecl(CILParser.FileDeclContext context) - { - string dottedName = VisitDottedName(context.dottedName()).Value; - ImmutableArray? hash = context.HASH() is not null ? VisitBytes(context.bytes()).Value : null; - var hashBlob = hash is not null ? new BlobBuilder() : null; - hashBlob?.WriteBytes(hash!.Value); - - bool hasMetadata = context.fileAttr().Aggregate(true, (acc, attr) => acc && VisitFileAttr(attr).Value); - bool isEntrypoint = context.fileEntry().Aggregate(false, (acc, attr) => acc || VisitFileEntry(attr).Value); - var entity = _entityRegistry.GetOrCreateFile(dottedName, hasMetadata, hashBlob); - if (isEntrypoint) - { - _entityRegistry.EntryPoint = entity; - } - return new(entity); - } - GrammarResult ICILVisitor.VisitFileEntry(CILParser.FileEntryContext context) => VisitFileEntry(context); - public GrammarResult.Literal VisitFileEntry(CILParser.FileEntryContext context) - => context.ChildCount != 0 ? new(true) : new(false); - - GrammarResult ICILVisitor.VisitFilterClause(CILParser.FilterClauseContext context) => VisitFilterClause(context); - public GrammarResult.Literal VisitFilterClause(CILParser.FilterClauseContext context) - { - if (context.scopeBlock() is CILParser.ScopeBlockContext scopeBlock) - { - LabelHandle start = _currentMethod!.Definition.MethodBody.DefineLabel(); - _currentMethod.Definition.MethodBody.MarkLabel(start); - _ = VisitScopeBlock(scopeBlock); - return new(start); - } - if (context.id() is CILParser.IdContext id) - { - var start = _currentMethod!.Labels.TryGetValue(VisitId(id).Value, out LabelHandle startLabel) ? startLabel : _currentMethod.Labels[VisitId(id).Value] = _currentMethod.Definition.MethodBody.DefineLabel(); - return new(start); - } - if (context.int32() is CILParser.Int32Context offset) - { - var start = _currentMethod!.Definition.MethodBody.DefineLabel(); - _currentMethod.Definition.MethodBody.MarkLabel(start, VisitInt32(offset).Value); - return new(start); - } - throw new UnreachableException(); - } - - public GrammarResult VisitFinallyClause(CILParser.FinallyClauseContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - - GrammarResult ICILVisitor.VisitFloat64(CILParser.Float64Context context) => VisitFloat64(context); - public GrammarResult.Literal VisitFloat64(CILParser.Float64Context context) - { - if (context.FLOAT64() is ITerminalNode float64) - { - string text = float64.Symbol.Text; - bool neg = text.StartsWith('-'); - if (!double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out double result)) - { - result = neg ? double.MaxValue : double.MinValue; - } - return new(result); - } - else if (context.int32() is CILParser.Int32Context int32) - { - IToken node = int32.INT32().Symbol; - if (!ParseIntegerValue(node.Text.AsSpan(), out long intValue)) - { - _diagnostics.Add(new Diagnostic( - DiagnosticIds.LiteralOutOfRange, - DiagnosticSeverity.Error, - string.Format(DiagnosticMessageTemplates.LiteralOutOfRange, node.Text), - Location.From(node, _documents))); - intValue = 0; - } - - if (context.FLOAT32() is not null) - { - // FLOAT32 '(' int32 ')' — hex bits reinterpreted as float32 - return new(BitConverter.Int32BitsToSingle((int)intValue)); - } - // int32 or int32 '.' — plain integer or trailing-dot float - return new((double)intValue); - } - else if (context.int64() is CILParser.Int64Context int64) - { - // FLOAT64_ '(' int64 ')' — hex bits reinterpreted as float64 - long value = VisitInt64(int64).Value; - return new(BitConverter.Int64BitsToDouble(value)); - } - throw new UnreachableException(); - } - GrammarResult ICILVisitor.VisitGenArity(CILParser.GenArityContext context) => VisitGenArity(context); - public GrammarResult.Literal VisitGenArity(CILParser.GenArityContext context) - => context.genArityNotEmpty() is CILParser.GenArityNotEmptyContext genArity ? VisitGenArityNotEmpty(genArity) : new(0); - - GrammarResult ICILVisitor.VisitGenArityNotEmpty(CILParser.GenArityNotEmptyContext context) => VisitGenArityNotEmpty(context); - public GrammarResult.Literal VisitGenArityNotEmpty(CILParser.GenArityNotEmptyContext context) => VisitInt32(context.int32()); - - GrammarResult ICILVisitor.VisitHandlerBlock(CILParser.HandlerBlockContext context) => VisitHandlerBlock(context); - - public GrammarResult.Literal<(LabelHandle Start, LabelHandle End)> VisitHandlerBlock(CILParser.HandlerBlockContext context) - { - if (context.scopeBlock() is CILParser.ScopeBlockContext scopeBlock) - { - LabelHandle start = _currentMethod!.Definition.MethodBody.DefineLabel(); - _currentMethod.Definition.MethodBody.MarkLabel(start); - _ = VisitScopeBlock(scopeBlock); - LabelHandle end = _currentMethod.Definition.MethodBody.DefineLabel(); - _currentMethod.Definition.MethodBody.MarkLabel(end); - return new((start, end)); - } - var ids = context.id(); - if (ids.Length == 2) - { - var start = _currentMethod!.Labels.TryGetValue(VisitId(ids[0]).Value, out LabelHandle startLabel) ? startLabel : _currentMethod.Labels[VisitId(ids[0]).Value] = _currentMethod.Definition.MethodBody.DefineLabel(); - var end = _currentMethod!.Labels.TryGetValue(VisitId(ids[1]).Value, out LabelHandle endLabel) ? endLabel : _currentMethod.Labels[VisitId(ids[1]).Value] = _currentMethod.Definition.MethodBody.DefineLabel(); - return new((start, end)); - } - var offsets = context.int32(); - if (offsets.Length == 2) - { - var start = _currentMethod!.Definition.MethodBody.DefineLabel(); - var end = _currentMethod.Definition.MethodBody.DefineLabel(); - _currentMethod.Definition.MethodBody.MarkLabel(start, VisitInt32(offsets[0]).Value); - _currentMethod.Definition.MethodBody.MarkLabel(end, VisitInt32(offsets[1]).Value); - return new((start, end)); - } - throw new UnreachableException(); - } - - GrammarResult ICILVisitor.VisitHexbyte(CILParser.HexbyteContext context) - { - return new GrammarResult.Literal(VisitHexbyte(context)); - } - - public static byte VisitHexbyte(CILParser.HexbyteContext context) - { - // hexbyte can be HEXBYTE, INT32, or ID token (due to lexer ambiguity). - // Validate the text is 1-2 hex characters to avoid FormatException - // from non-hex ID tokens or values > 0xFF from longer INT32 tokens. - string text = context.GetText(); - if (text.Length <= 2 && byte.TryParse(text, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out byte value)) - { - return value; - } - // For invalid hex values, mask to byte (matching native ilasm tolerance). - if (int.TryParse(text, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out int intValue)) - { - return (byte)(intValue & 0xFF); - } - return 0; - } - - GrammarResult ICILVisitor.VisitNativeInt(CILParser.NativeIntContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - GrammarResult ICILVisitor.VisitNativeUint(CILParser.NativeUintContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - GrammarResult ICILVisitor.VisitI16seq(CILParser.I16seqContext context) => VisitI16seq(context); - public GrammarResult.FormattedBlob VisitI16seq(CILParser.I16seqContext context) - { - var values = context.int32(); - var builder = ImmutableArray.CreateBuilder(values.Length); - foreach (var value in values) - { - builder.Add((short)VisitInt32(value).Value); - } - return new(builder.MoveToImmutable().SerializeSequence()); - } - GrammarResult ICILVisitor.VisitI32seq(CILParser.I32seqContext context) => VisitI32seq(context); - public GrammarResult.FormattedBlob VisitI32seq(CILParser.I32seqContext context) - { - var values = context.int32(); - var builder = ImmutableArray.CreateBuilder(values.Length); - foreach (var value in values) - { - builder.Add(VisitInt32(value).Value); - } - return new(builder.MoveToImmutable().SerializeSequence()); - } - - GrammarResult ICILVisitor.VisitI8seq(CILParser.I8seqContext context) => VisitI8seq(context); - public GrammarResult.FormattedBlob VisitI8seq(CILParser.I8seqContext context) - { - var values = context.int32(); - var builder = ImmutableArray.CreateBuilder(values.Length); - foreach (var value in values) - { - builder.Add((byte)VisitInt32(value).Value); - } - return new(builder.MoveToImmutable().SerializeSequence()); - } - - GrammarResult ICILVisitor.VisitI64seq(CILParser.I64seqContext context) => VisitI64seq(context); - public GrammarResult.FormattedBlob VisitI64seq(CILParser.I64seqContext context) - { - var values = context.int64(); - var builder = ImmutableArray.CreateBuilder(values.Length); - foreach (var value in values) - { - builder.Add(VisitInt64(value).Value); - } - return new(builder.MoveToImmutable().SerializeSequence()); - } - GrammarResult ICILVisitor.VisitId(CILParser.IdContext context) => VisitId(context); - public static GrammarResult.String VisitId(CILParser.IdContext context) - { - string text = context.GetText(); - if (context.SQSTRING() is not null && text.Length >= 2 && text[0] == '\'') - { - text = text.Substring(1, text.Length - 2); - } - return new GrammarResult.String(text); - } - - GrammarResult ICILVisitor.VisitIidParamIndex(CILParser.IidParamIndexContext context) => VisitIidParamIndex(context); - public GrammarResult.Literal VisitIidParamIndex(CILParser.IidParamIndexContext context) - => context.int32() is CILParser.Int32Context int32 ? new(VisitInt32(int32).Value) : new(null); - - GrammarResult ICILVisitor.VisitImagebase(CILParser.ImagebaseContext context) => VisitImagebase(context); - public GrammarResult.Literal VisitImagebase(CILParser.ImagebaseContext context) => VisitInt64(context.int64()); - - GrammarResult ICILVisitor.VisitImplAttr(ILAssembler.CILParser.ImplAttrContext context) => VisitImplAttr(context); - public GrammarResult.Flag VisitImplAttr(CILParser.ImplAttrContext context) - { - if (context.int32() is CILParser.Int32Context int32) - { - return new((MethodImplAttributes)VisitInt32(int32).Value, ShouldAppend: false); - } - string attribute = context.GetText(); - return attribute switch - { - "native" => new(MethodImplAttributes.Native, MethodImplAttributes.CodeTypeMask), - "cil" or "il" => new(MethodImplAttributes.IL, MethodImplAttributes.CodeTypeMask), - "optil" => new(MethodImplAttributes.OPTIL, MethodImplAttributes.CodeTypeMask), - "managed" => new(MethodImplAttributes.Managed, MethodImplAttributes.ManagedMask), - "unmanaged" => new(MethodImplAttributes.Unmanaged, MethodImplAttributes.ManagedMask), - "forwardref" => new(MethodImplAttributes.ForwardRef), - "preservesig" => new(MethodImplAttributes.PreserveSig), - "runtime" => new(MethodImplAttributes.Runtime, MethodImplAttributes.CodeTypeMask), - "internalcall" => new(MethodImplAttributes.InternalCall), - "synchronized" => new(MethodImplAttributes.Synchronized), - "noinlining" => new(MethodImplAttributes.NoInlining), - "aggressiveinlining" => new(MethodImplAttributes.AggressiveInlining), - "nooptimization" => new(MethodImplAttributes.NoOptimization), - "aggressiveoptimization" => new(MethodImplAttributes.AggressiveOptimization), - "async" => new(MethodImplAttributes.Async), - _ => throw new UnreachableException(), - }; - } - - GrammarResult ICILVisitor.VisitImplClause(CILParser.ImplClauseContext context) => VisitImplClause(context); - public GrammarResult.Sequence VisitImplClause(CILParser.ImplClauseContext context) => context.implList() is {} implList ? VisitImplList(implList) : new(ImmutableArray.Empty); - - GrammarResult ICILVisitor.VisitImplList(CILParser.ImplListContext context) => VisitImplList(context); - public GrammarResult.Sequence VisitImplList(CILParser.ImplListContext context) - { - var builder = ImmutableArray.CreateBuilder(); - foreach (var impl in context.typeSpec()) - { - builder.Add(EntityRegistry.CreateUnrecordedInterfaceImplementation(_currentTypeDefinition.PeekOrDefault()!, VisitTypeSpec(impl).Value)); - } - return new(builder.ToImmutable()); - } - - GrammarResult ICILVisitor.VisitInitOpt(CILParser.InitOptContext context) => VisitInitOpt(context); - public GrammarResult.Literal VisitInitOpt(CILParser.InitOptContext context) - { - if (context.fieldInit() is CILParser.FieldInitContext fieldInit) - { - return VisitFieldInit(fieldInit); - } - // No initializer - return a sentinel indicating no constant - return new(NoConstantSentinel.Instance); - } - - // Sentinel to distinguish "no constant" from "constant is null" - private sealed class NoConstantSentinel - { - public static readonly NoConstantSentinel Instance = new(); - private NoConstantSentinel() { } - } - - public GrammarResult VisitInstr(CILParser.InstrContext context) - { - var instrContext = context.GetRuleContext(0); - ILOpCode opcode = ((GrammarResult.Literal)instrContext.Accept(this)).Value; - if (opcode == ILOpCode.Localloc) - { - _currentMethod!.Definition.HasDynamicStackAllocation = true; - } - switch (instrContext.RuleIndex) - { - case CILParser.RULE_instr_brtarget: - { - ParserRuleContext argument = context.GetRuleContext(1); - if (argument is CILParser.IdContext id) - { - string label = VisitId(id).Value; - if (!_currentMethod!.Labels.TryGetValue(label, out var handle)) - { - handle = _currentMethod.Definition.MethodBody.DefineLabel(); - _currentMethod.Labels[label] = handle; - // Track undefined label references for later validation - if (!_currentMethod.UndefinedLabelReferences.ContainsKey(label)) - { - _currentMethod.UndefinedLabelReferences[label] = context; - } - } - _currentMethod.Definition.MethodBody.Branch(opcode, handle); - } - if (argument is CILParser.Int32Context int32) - { - int offset = VisitInt32(int32).Value; - LabelHandle label = _currentMethod!.Definition.MethodBody.DefineLabel(); - _currentMethod.Definition.MethodBody.Branch(opcode, label); - _currentMethod.Definition.MethodBody.MarkLabel(label, _currentMethod.Definition.MethodBody.Offset + offset); - } - } - break; - case CILParser.RULE_instr_field: - { - _currentMethod!.Definition.MethodBody.OpCode(opcode); - if (context.mdtoken() is CILParser.MdtokenContext mdtoken) - { - var entity = VisitMdtoken(mdtoken).Value; - if (entity is EntityRegistry.TypeReferenceEntity mdTokenTypeRef) - { - mdTokenTypeRef.RecordBlobToWriteResolvedToken(_currentMethod.Definition.MethodBody.CodeBuilder.ReserveBytes(4)); - } - else - { - _currentMethod.Definition.MethodBody.Token(entity.Handle); - } - } - else - { - var fieldRef = VisitFieldRef(context.fieldRef()).Value; - if (fieldRef is EntityRegistry.MemberReferenceEntity memberRef) - { - memberRef.RecordBlobToWriteResolvedHandle(_currentMethod.Definition.MethodBody.CodeBuilder.ReserveBytes(4)); - } - else - { - _currentMethod.Definition.MethodBody.Token(fieldRef.Handle); - } - } - } - break; - case CILParser.RULE_instr_i: - { - int arg = VisitInt32(context.int32()).Value; - if (opcode == ILOpCode.Ldc_i4 || opcode == ILOpCode.Ldc_i4_s) - { - _currentMethod!.Definition.MethodBody.LoadConstantI4(arg); - } - else - { - _currentMethod!.Definition.MethodBody.OpCode(opcode); - _currentMethod.Definition.MethodBody.CodeBuilder.WriteByte((byte)arg); - } - } - break; - case CILParser.RULE_instr_i8: - Debug.Assert(opcode == ILOpCode.Ldc_i8); - _currentMethod!.Definition.MethodBody.LoadConstantI8(VisitInt64(context.int64()).Value); - break; - case CILParser.RULE_instr_method: - { - if (opcode == ILOpCode.Callvirt || opcode == ILOpCode.Newobj) - { - _expectInstance = true; - } - _currentMethod!.Definition.MethodBody.OpCode(opcode); - var methodRef = VisitMethodRef(context.methodRef()).Value; - if (methodRef is EntityRegistry.MemberReferenceEntity memberRef) - { - memberRef.RecordBlobToWriteResolvedHandle(_currentMethod.Definition.MethodBody.CodeBuilder.ReserveBytes(4)); - } - else - { - _currentMethod.Definition.MethodBody.Token(methodRef.Handle); - } - // Reset the instance flag for the next instruction. - if (opcode == ILOpCode.Callvirt || opcode == ILOpCode.Newobj) - { - _expectInstance = false; - } - } - break; - case CILParser.RULE_instr_none: - _currentMethod!.Definition.MethodBody.OpCode(opcode); - break; - case CILParser.RULE_instr_r: - { - double value; - ParserRuleContext argument = context.GetRuleContext(1); - if (argument is CILParser.Float64Context float64) - { - value = VisitFloat64(float64).Value; - } - else if (argument is CILParser.Int64Context int64) - { - long intValue = VisitInt64(int64).Value; - value = intValue; - } - else if (argument is CILParser.BytesContext bytesContext) - { - var bytes = VisitBytes(bytesContext).Value.ToArray(); - if (bytes.Length >= 8) - { - value = BitConverter.ToDouble(bytes, 0); - } - else if (bytes.Length >= 4) - { - value = BitConverter.ToSingle(bytes, 0); - } - else - { - ReportError(DiagnosticIds.ByteArrayTooShort, DiagnosticMessageTemplates.ByteArrayTooShort, bytesContext); - value = 0.0d; - } - } - else - { - throw new UnreachableException(); - } - if (opcode == ILOpCode.Ldc_r4) - { - _currentMethod!.Definition.MethodBody.LoadConstantR4((float)value); - } - else - { - _currentMethod!.Definition.MethodBody.LoadConstantR8(value); - } - } - break; - case CILParser.RULE_instr_sig: - { - Debug.Assert(opcode == ILOpCode.Calli); - BlobBuilder signature = new(); - byte callConv = VisitCallConv(context.callConv()).Value; - signature.WriteByte(callConv); - var args = VisitSigArgs(context.sigArgs()).Value; - signature.WriteCompressedInteger(args.Count(arg => !arg.IsSentinel)); - // Write return type - VisitType(context.type()).Value.WriteContentTo(signature); - // Write arg signatures - foreach (var arg in args) - { - arg.SignatureBlob.WriteContentTo(signature); - } - _currentMethod!.Definition.MethodBody.OpCode(opcode); - _currentMethod!.Definition.MethodBody.Token(_entityRegistry.GetOrCreateStandaloneSignature(signature).Handle); - } - break; - case CILParser.RULE_instr_string: - Debug.Assert(opcode == ILOpCode.Ldstr); - string str; - if (context.bytes() is CILParser.BytesContext rawBytes) - { - ReadOnlySpan bytes = VisitBytes(rawBytes).Value.AsSpan(); - ReadOnlySpan bytesAsChars = MemoryMarshal.Cast(bytes); - if (!BitConverter.IsLittleEndian) - { - for (int i = 0; i < bytesAsChars.Length; i++) - { - BinaryPrimitives.ReverseEndianness(bytesAsChars[i]); - } - } - str = bytesAsChars.ToString(); - } - else - { - var userString = context.compQstring(); - Debug.Assert(userString is not null); - str = VisitCompQstring(userString!).Value; - if (context.ANSI() is not null) - { - // Emit the string not as a UTF-16 string (as per the spec), but directly as an ANSI string. - // Although the string is marked as ANSI, this always used the UTF-8 code page - // so we can emit this as UTF-8 bytes. - int byteCount = Encoding.UTF8.GetByteCount(str); - // Ensure we have an even number of bytes. - if ((byteCount % 1) != 0) - { - byteCount++; - } - - Span utf8Bytes = new byte[byteCount]; - Encoding.UTF8.GetBytes(str, utf8Bytes); - - str = new string(MemoryMarshal.Cast(utf8Bytes)); - } - } - _currentMethod!.Definition.MethodBody.LoadString(_metadataBuilder.GetOrAddUserString(str)); - break; - case CILParser.RULE_instr_switch: - { - var labels = new List<(LabelHandle Label, int? Offset)>(); - if (context.labels()?.children is { } labelChildren) - { - foreach (var label in labelChildren) - { - if (label is CILParser.IdContext id) - { - string labelName = VisitId(id).Value; - if (!_currentMethod!.Labels.TryGetValue(labelName, out var handle)) - { - handle = _currentMethod.Definition.MethodBody.DefineLabel(); - _currentMethod.Labels[labelName] = handle; - // Track undefined label references for later validation - if (!_currentMethod.UndefinedLabelReferences.ContainsKey(labelName)) - { - _currentMethod.UndefinedLabelReferences[labelName] = context; - } - } - labels.Add((handle, null)); - } - else if (label is CILParser.Int32Context int32) - { - int offset = VisitInt32(int32).Value; - LabelHandle labelHandle = _currentMethod!.Definition.MethodBody.DefineLabel(); - labels.Add((labelHandle, offset)); - } - } - } - if (labels.Count > 0) - { - var switchEncoder = _currentMethod!.Definition.MethodBody.Switch(labels.Count); - foreach (var label in labels) - { - switchEncoder.Branch(label.Label); - } - } - else - { - // Empty switch: emit opcode + 0 count manually - _currentMethod!.Definition.MethodBody.OpCode(ILOpCode.Switch); - _currentMethod.Definition.MethodBody.CodeBuilder.WriteInt32(0); - } - // Now that we've emitted the switch instruction, we can go back and mark the offset-based target labels - foreach (var label in labels) - { - if (label.Offset is int offset) - { - _currentMethod.Definition.MethodBody.MarkLabel(label.Label, _currentMethod.Definition.MethodBody.Offset + offset); - } - } - } - break; - case CILParser.RULE_instr_tok: - _currentMethod!.Definition.MethodBody.OpCode(opcode); - if (context.int32() is { } tokenValue) - { - _currentMethod.Definition.MethodBody.CodeBuilder.WriteInt32(VisitInt32(tokenValue).Value); - break; - } - - var tok = VisitOwnerType(context.ownerType()).Value; - if (tok is EntityRegistry.TypeReferenceEntity tokTypeRef) - { - tokTypeRef.RecordBlobToWriteResolvedToken(_currentMethod.Definition.MethodBody.CodeBuilder.ReserveBytes(4)); - } - else if (tok is EntityRegistry.MemberReferenceEntity tokMemberRef) - { - tokMemberRef.RecordBlobToWriteResolvedHandle(_currentMethod.Definition.MethodBody.CodeBuilder.ReserveBytes(4)); - } - else - { - _currentMethod.Definition.MethodBody.Token(tok.Handle); - } - break; - case CILParser.RULE_instr_type: - { - var arg = VisitTypeSpec(context.typeSpec()).Value; - _currentMethod!.Definition.MethodBody.OpCode(opcode); - if (arg is EntityRegistry.TypeReferenceEntity argTypeRef) - { - argTypeRef.RecordBlobToWriteResolvedToken(_currentMethod.Definition.MethodBody.CodeBuilder.ReserveBytes(4)); - } - else - { - _currentMethod.Definition.MethodBody.Token(arg.Handle); - } - } - break; - case CILParser.RULE_instr_var: - { - string instrName = opcode.ToString(); - bool isShortForm = instrName.EndsWith("_s"); - _currentMethod!.Definition.MethodBody.OpCode(opcode); - if (context.int32() is CILParser.Int32Context int32) - { - int value = VisitInt32(int32).Value; - if (isShortForm) - { - // Emit a byte instead of the int for the short form - _currentMethod.Definition.MethodBody.CodeBuilder.WriteByte((byte)value); - } - else - { - _currentMethod.Definition.MethodBody.CodeBuilder.WriteInt32(value); - } - } - else - { - Debug.Assert(context.id() is not null); - string varName = VisitId(context.id()!).Value; - int? index = null; - if (instrName.Contains("arg")) - { - if (_currentMethod!.ArgumentNames.TryGetValue(varName, out var argIndex)) - { - index = argIndex; - - if (_currentMethod.Definition.SignatureHeader.IsInstance) - { - index++; - } - } - else - { - ReportError(DiagnosticIds.ArgumentNotFound, string.Format(DiagnosticMessageTemplates.ArgumentNotFound, varName), context); - } - } - else - { - for (int i = _currentMethod!.LocalsScopes.Count - 1; i >= 0 ; i--) - { - if (_currentMethod.LocalsScopes[i].TryGetValue(varName, out var localIndex)) - { - index = localIndex; - break; - } - } - if (index is null) - { - ReportError(DiagnosticIds.LocalNotFound, string.Format(DiagnosticMessageTemplates.LocalNotFound, varName), context); - } - } - - index ??= -1; - - if (isShortForm) - { - // Emit a byte instead of the int for the short form - _currentMethod.Definition.MethodBody.CodeBuilder.WriteByte((byte)index.Value); - } - else - { - _currentMethod.Definition.MethodBody.CodeBuilder.WriteInt32(index.Value); - } - } - } - break; - } - return GrammarResult.SentinelValue.Result; - } - - public GrammarResult.Literal VisitInstr_brtarget(CILParser.Instr_brtargetContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - public GrammarResult.Literal VisitInstr_field(CILParser.Instr_fieldContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - public GrammarResult.Literal VisitInstr_i(CILParser.Instr_iContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - public GrammarResult.Literal VisitInstr_i8(CILParser.Instr_i8Context context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - public GrammarResult.Literal VisitInstr_method(CILParser.Instr_methodContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - public GrammarResult.Literal VisitInstr_none(CILParser.Instr_noneContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - public GrammarResult.Literal VisitInstr_r(CILParser.Instr_rContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - public GrammarResult.Literal VisitInstr_sig(CILParser.Instr_sigContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - public GrammarResult.Literal VisitInstr_string(CILParser.Instr_stringContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - public GrammarResult.Literal VisitInstr_switch(CILParser.Instr_switchContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - public GrammarResult.Literal VisitInstr_tok(CILParser.Instr_tokContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - public GrammarResult.Literal VisitInstr_type(CILParser.Instr_typeContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - public GrammarResult.Literal VisitInstr_var(CILParser.Instr_varContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - private static ILOpCode ParseOpCodeFromToken(IToken token) - { - string text = token.Text.TrimEnd('.'); - if (text == "unused") - { - // Native ilasm's keyword index uses the last matching opcode.def entry, CEE_UNUSED70. - return ILOpCode.Unused; - } - - string normalized = text.Replace('.', '_'); - - // Handle instruction aliases that don't directly map to ILOpCode enum names - normalized = normalized switch - { - "ldelem_u8" => "ldelem_i8", - "ldind_u8" => "ldind_i8", - "endfault" => "endfinally", - _ => normalized - }; - - return (ILOpCode)Enum.Parse(typeof(ILOpCode), normalized, ignoreCase: true); - } - - GrammarResult ICILVisitor.VisitInstr(CILParser.InstrContext context) => VisitInstr(context); - GrammarResult ICILVisitor.VisitInstr_brtarget(CILParser.Instr_brtargetContext context) => VisitInstr_brtarget(context); - GrammarResult ICILVisitor.VisitInstr_field(CILParser.Instr_fieldContext context) => VisitInstr_field(context); - GrammarResult ICILVisitor.VisitInstr_i(CILParser.Instr_iContext context) => VisitInstr_i(context); - GrammarResult ICILVisitor.VisitInstr_i8(CILParser.Instr_i8Context context) => VisitInstr_i8(context); - GrammarResult ICILVisitor.VisitInstr_method(CILParser.Instr_methodContext context) => VisitInstr_method(context); - GrammarResult ICILVisitor.VisitInstr_none(CILParser.Instr_noneContext context) => VisitInstr_none(context); - GrammarResult ICILVisitor.VisitInstr_r(CILParser.Instr_rContext context) => VisitInstr_r(context); - GrammarResult ICILVisitor.VisitInstr_sig(CILParser.Instr_sigContext context) => VisitInstr_sig(context); - GrammarResult ICILVisitor.VisitInstr_string(CILParser.Instr_stringContext context) => VisitInstr_string(context); - GrammarResult ICILVisitor.VisitInstr_switch(CILParser.Instr_switchContext context) => VisitInstr_switch(context); - GrammarResult ICILVisitor.VisitInstr_tok(CILParser.Instr_tokContext context) => VisitInstr_tok(context); - GrammarResult ICILVisitor.VisitInstr_type(CILParser.Instr_typeContext context) => VisitInstr_type(context); - GrammarResult ICILVisitor.VisitInstr_var(CILParser.Instr_varContext context) => VisitInstr_var(context); - - private static bool ParseIntegerValue(ReadOnlySpan value, out long result) - { - NumberStyles parseStyle = NumberStyles.None; - bool negate = false; - if (value.StartsWith("-".AsSpan())) - { - negate = true; - value = value.Slice(1); - } - - if (value.StartsWith("0x".AsSpan())) - { - parseStyle = NumberStyles.AllowHexSpecifier; - value = value.Slice(2); - } - else if (value.StartsWith("0".AsSpan())) - { - // Octal support isn't built-in, so we'll do it manually. - result = 0; - for (int i = 0; i < value.Length; i++, result *= 8) - { - int digitValue = value[i] - '0'; - if (digitValue < 0 || digitValue > 7) - { - // COMPAT: native ilasm skips invalid digits silently - continue; - } - result += digitValue; - } - if (negate) result = -result; - return true; - } - - bool success = long.TryParse(value.ToString(), parseStyle, CultureInfo.InvariantCulture, out result); - if (!success) - { - // Try parsing as unsigned — handles values like: - // - Decimal overflow with negation: 9223372036854775808 (= -Int64.MinValue) - // - Large unsigned decimal: 18444492274432737280 - if (ulong.TryParse(value.ToString(), parseStyle, CultureInfo.InvariantCulture, out ulong uresult)) - { - result = unchecked((long)uresult); - if (negate) result = unchecked(-result); - return true; - } - // Handle oversized hex values (>64 bits) by truncating to low 64 bits, - // matching native ilasm behavior for values like 0x94188556b24089e8b90c9c61f9f3088 - if (parseStyle == NumberStyles.AllowHexSpecifier && value.Length > 16) - { - var truncated = value.Slice(value.Length - 16); - if (ulong.TryParse(truncated.ToString(), parseStyle, CultureInfo.InvariantCulture, out uresult)) - { - result = unchecked((long)uresult); - if (negate) result = unchecked(-result); - return true; - } - } - return false; - } - - if (negate) result = -result; - return true; - } - - GrammarResult ICILVisitor.VisitInt32(CILParser.Int32Context context) - { - return VisitInt32(context); - } - - public GrammarResult.Literal VisitInt32(CILParser.Int32Context context) - { - IToken node = context.INT32().Symbol; - - ReadOnlySpan value = node.Text.AsSpan(); - - if (!ParseIntegerValue(value, out long num)) - { - _diagnostics.Add(new Diagnostic( - DiagnosticIds.LiteralOutOfRange, - DiagnosticSeverity.Error, - string.Format(DiagnosticMessageTemplates.LiteralOutOfRange, node.Text), - Location.From(node, _documents))); - return new GrammarResult.Literal(0); - } - - return new GrammarResult.Literal((int)num); - } - - - GrammarResult ICILVisitor.VisitInt64(CILParser.Int64Context context) - { - return VisitInt64(context); - } - - public GrammarResult.Literal VisitInt64(CILParser.Int64Context context) - { - IToken node = context.GetChild(0).Symbol; - - ReadOnlySpan value = node.Text.AsSpan(); - - if (!ParseIntegerValue(value, out long num)) - { - _diagnostics.Add(new Diagnostic( - DiagnosticIds.LiteralOutOfRange, - DiagnosticSeverity.Error, - string.Format(DiagnosticMessageTemplates.LiteralOutOfRange, node.Text), - Location.From(node, _documents))); - return new GrammarResult.Literal(0); - } - - return new GrammarResult.Literal(num); - } - - GrammarResult ICILVisitor.VisitIntOrWildcard(CILParser.IntOrWildcardContext context) => VisitIntOrWildcard(context); - public GrammarResult.Literal VisitIntOrWildcard(CILParser.IntOrWildcardContext context) => context.int32() is {} int32 ? new(VisitInt32(int32).Value) : new(null); - - private void ValidateLabelReferences() - { - if (_currentMethod is null) - { - return; - } - - // Report errors for any labels that were referenced but never declared - foreach (var undefinedLabel in _currentMethod.UndefinedLabelReferences) - { - string labelName = undefinedLabel.Key; - ParserRuleContext context = undefinedLabel.Value; - - // Only report if the label was never declared - if (!_currentMethod.DeclaredLabels.Contains(labelName)) - { - ReportError(DiagnosticIds.LabelNotFound, - string.Format(DiagnosticMessageTemplates.LabelNotFound, labelName), - context); - } - } - } - - public GrammarResult VisitLabels(CILParser.LabelsContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - - GrammarResult ICILVisitor.VisitLabelDecl(CILParser.LabelDeclContext context) => VisitLabelDecl(context); - public GrammarResult VisitLabelDecl(CILParser.LabelDeclContext context) - { - var labelId = context.id(); - string labelName = VisitId(labelId).Value; - _currentMethod!.DeclaredLabels.Add(labelName); - if (!_currentMethod!.Labels.TryGetValue(labelName, out var label)) - { - label = _currentMethod.Definition.MethodBody.DefineLabel(); - _currentMethod.Labels[labelName] = label; - } - _currentMethod.Definition.MethodBody.MarkLabel(label); - return GrammarResult.SentinelValue.Result; - } - - public GrammarResult VisitLanguageDecl(CILParser.LanguageDeclContext context) - { - // .language languageString (',' languageString (',' languageString)?)? - // First GUID: language (e.g., C#, VB, IL) - // Second GUID: vendor (optional) - // Third GUID: document type (optional) - var strings = context.languageString(); - if (strings.Length >= 1 && Guid.TryParse(VisitLanguageString(strings[0]).Value, out var languageGuid)) - { - _currentLanguageGuid = languageGuid; - } - if (strings.Length >= 2 && Guid.TryParse(VisitLanguageString(strings[1]).Value, out var vendorGuid)) - { - _currentLanguageVendorGuid = vendorGuid; - } - if (strings.Length >= 3 && Guid.TryParse(VisitLanguageString(strings[2]).Value, out var docTypeGuid)) - { - _currentDocumentTypeGuid = docTypeGuid; - } - return GrammarResult.SentinelValue.Result; - } - - GrammarResult ICILVisitor.VisitLanguageString(CILParser.LanguageStringContext context) => VisitLanguageString(context); - public GrammarResult.String VisitLanguageString(CILParser.LanguageStringContext context) - { - if (context.SQSTRING() is not null) - { - return new(StringHelpers.ParseQuotedString(context.SQSTRING().GetText())); - } - return new(StringHelpers.ParseQuotedString(context.QSTRING().GetText())); - } - - public GrammarResult VisitManifestResDecl(CILParser.ManifestResDeclContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - GrammarResult ICILVisitor.VisitManifestResDecls(CILParser.ManifestResDeclsContext context) => VisitManifestResDecls(context); - public GrammarResult.Literal<(EntityRegistry.EntityBase? implementation, uint offset, ImmutableArray attributes)> VisitManifestResDecls(CILParser.ManifestResDeclsContext context) - { - EntityRegistry.EntityBase? implementation = null; - uint offset = 0; - var attributes = ImmutableArray.CreateBuilder(); - // COMPAT: Priority order for implementation is the following - // AssemblyRef, File, nil - foreach (var decl in context.manifestResDecl()) - { - if (decl.customAttrDecl() is CILParser.CustomAttrDeclContext customAttrDecl) - { - if (VisitCustomAttrDecl(customAttrDecl).Value is { } attr) - { - attributes.Add(attr); - } - } - string kind = decl.GetChild(0).GetText(); - if (kind == ".file" && implementation is not EntityRegistry.AssemblyReferenceEntity) - { - string fileName = VisitDottedName(decl.dottedName()).Value; - var file = _entityRegistry.FindFile(fileName); - if (file is null) - { - ReportError(DiagnosticIds.FileNotFound, string.Format(DiagnosticMessageTemplates.FileNotFound, fileName), decl); - } - else - { - implementation = file; - offset = (uint)VisitInt32(decl.int32()).Value; - } - } - else if (kind == ".assembly") - { - string assemblyName = VisitDottedName(decl.dottedName()).Value; - implementation = _entityRegistry.GetOrCreateAssemblyReference(assemblyName, _ => { }); - } - } - - return new((implementation, offset, attributes.ToImmutable())); - } - GrammarResult ICILVisitor.VisitManifestResHead(CILParser.ManifestResHeadContext context) => VisitManifestResHead(context); - public GrammarResult.Literal<(string name, string alias, ManifestResourceAttributes attr)> VisitManifestResHead(CILParser.ManifestResHeadContext context) - { - var dottedNames = context.dottedName(); - string name = VisitDottedName(dottedNames[0]).Value; - string alias = dottedNames.Length == 2 ? VisitDottedName(dottedNames[1]).Value : name; - ManifestResourceAttributes attr = 0; - foreach (var attrContext in context.manresAttr()) - { - attr |= VisitManresAttr(attrContext).Value; - } - - return new((name, alias, attr)); - } - - GrammarResult ICILVisitor.VisitManresAttr(CILParser.ManresAttrContext context) => VisitManresAttr(context); - public GrammarResult.Flag VisitManresAttr(CILParser.ManresAttrContext context) - { - return context.GetText() switch - { - "public" => new(ManifestResourceAttributes.Public), - "private" => new(ManifestResourceAttributes.Private), - _ => throw new UnreachableException() - }; - } - - GrammarResult ICILVisitor.VisitMarshalBlob(CILParser.MarshalBlobContext context) => VisitMarshalBlob(context); - public GrammarResult.FormattedBlob VisitMarshalBlob(CILParser.MarshalBlobContext context) - { - var hexBytes = context.hexbyte(); - if (hexBytes.Length > 0) - { - var blob = new BlobBuilder(hexBytes.Length); - foreach (var hb in hexBytes) - { - blob.WriteByte(VisitHexbyte(hb)); - } - return new(blob); - } - - return VisitNativeType(context.nativeType()); - } - - GrammarResult ICILVisitor.VisitMarshalClause(CILParser.MarshalClauseContext context) => VisitMarshalClause(context); - public GrammarResult.FormattedBlob VisitMarshalClause(CILParser.MarshalClauseContext context) - { - if (context.ChildCount == 0) - { - return new(new BlobBuilder(0)); - } - - return VisitMarshalBlob(context.marshalBlob()); - } - - GrammarResult ICILVisitor.VisitMdtoken(ILAssembler.CILParser.MdtokenContext context) => VisitMdtoken(context); - public GrammarResult.Literal VisitMdtoken(CILParser.MdtokenContext context) - { - return new(_entityRegistry.ResolveHandleToEntity(MetadataTokens.EntityHandle(VisitInt32(context.int32()).Value))); - } - - GrammarResult ICILVisitor.VisitMemberRef(CILParser.MemberRefContext context) => VisitMemberRef(context); - public GrammarResult.Literal VisitMemberRef(CILParser.MemberRefContext context) - { - if (context.mdtoken() is CILParser.MdtokenContext mdToken) - { - return VisitMdtoken(mdToken); - } - - if (context.methodRef() is CILParser.MethodRefContext methodRef) - { - return VisitMethodRef(methodRef); - } - if (context.fieldRef() is CILParser.FieldRefContext fieldRef) - { - return VisitFieldRef(fieldRef); - } - - throw new UnreachableException(); - } - - GrammarResult ICILVisitor.VisitMethAttr(CILParser.MethAttrContext context) => VisitMethAttr(context); - public GrammarResult.Flag VisitMethAttr(CILParser.MethAttrContext context) - { - if (context.int32() is CILParser.Int32Context int32) - { - return new((MethodAttributes)VisitInt32(int32).Value, ShouldAppend: false); - } - string attribute = context.GetText(); - return attribute switch - { - "static" => new(MethodAttributes.Static), - "public" => new(MethodAttributes.Public, MethodAttributes.MemberAccessMask), - "private" => new(MethodAttributes.Private, MethodAttributes.MemberAccessMask), - "family" => new(MethodAttributes.Family, MethodAttributes.MemberAccessMask), - "final" => new(MethodAttributes.Final), - "specialname" => new(MethodAttributes.SpecialName), - "virtual" => new(MethodAttributes.Virtual), - "strict" => new(MethodAttributes.CheckAccessOnOverride), - "abstract" => new(MethodAttributes.Abstract), - "assembly" => new(MethodAttributes.Assembly, MethodAttributes.MemberAccessMask), - "famandassem" => new(MethodAttributes.FamANDAssem, MethodAttributes.MemberAccessMask), - "famorassem" => new(MethodAttributes.FamORAssem, MethodAttributes.MemberAccessMask), - "privatescope" => new(MethodAttributes.PrivateScope, MethodAttributes.MemberAccessMask), - "hidebysig" => new(MethodAttributes.HideBySig), - "newslot" => new(MethodAttributes.NewSlot), - "rtspecialname" => new(MethodAttributes.RTSpecialName), - "unmanagedexp" => new(MethodAttributes.UnmanagedExport), - "reqsecobj" => new(MethodAttributes.RequireSecObject), - _ => throw new UnreachableException(), - }; - } - public GrammarResult VisitMethodDecl(CILParser.MethodDeclContext context) - { - Debug.Assert(_currentMethod is not null); - var currentMethod = _currentMethod!; - - if (context.EMITBYTE() is not null) - { - currentMethod.Definition.MethodBody.CodeBuilder.WriteByte((byte)VisitInt32(context.GetChild(0)).Value); - } - else if (context.ENTRYPOINT() is not null) - { - _entityRegistry.EntryPoint = currentMethod.Definition; - } - else if (context.ZEROINIT() is not null) - { - currentMethod.Definition.BodyAttributes = MethodBodyAttributes.InitLocals; - } - else if (context.MAXSTACK() is not null) - { - currentMethod.Definition.MaxStack = VisitInt32(context.GetChild(0)).Value; - } - else if (context.LOCALS() is not null) - { - if (context.ChildCount == 3) - { - // init keyword specified - currentMethod.Definition.BodyAttributes = MethodBodyAttributes.InitLocals; - } - Dictionary localsScope; - if (currentMethod.LocalsScopes.Count != 0) - { - localsScope = currentMethod.LocalsScopes[currentMethod.LocalsScopes.Count - 1]; - } - else - { - localsScope = new(); - currentMethod.LocalsScopes.Add(localsScope); - } - var newLocals = VisitSigArgs(context.sigArgs()).Value; - foreach (var loc in newLocals) - { - // BREAK-COMPAT: We don't allow specifying a local's slot via the [in], [out], or [opt] parameter attributes, or the custom int override. - // This only worked in ilasm due to how ilasm reused fields. - // We're only going to support allowing this tool to determine the slot numbers. - // This blocks two different locals in two different scopes from resuing the same slot - // but that is a very rare scenario (even using more than one .locals block in a method in IL is quite rare) - - // If the local is named, add it to our name-lookup dictionary. - // Otherwise, it will only be accessible via its index. - if (loc.Name is not null) - { - localsScope.TryAdd(loc.Name, currentMethod.AllLocals.Count); - } - currentMethod.AllLocals.Add(loc); - } - } - else if (context.labelDecl() is CILParser.LabelDeclContext labelDecl) - { - var labelId = labelDecl.id(); - string labelName = VisitId(labelId).Value; - currentMethod.DeclaredLabels.Add(labelName); - if (!currentMethod.Labels.TryGetValue(labelName, out var label)) - { - label = currentMethod.Definition.MethodBody.DefineLabel(); - currentMethod.Labels[labelName] = label; - } - currentMethod.Definition.MethodBody.MarkLabel(label); - } - else if (context.EXPORT() is not null) - { - // .export [ordinal] or .export [ordinal] as alias - int ordinal = VisitInt32(context.int32()[0]).Value; - string? alias = context.id() is { } aliasId ? VisitId(aliasId).Value : null; - - currentMethod.Definition.ExportOrdinal = ordinal; - currentMethod.Definition.ExportAlias = alias; - } - else if (context.VTENTRY() is not null) - { - // .vtentry vtableIndex : slotIndex - int vtableEntry = VisitInt32(context.int32()[0]).Value; - int vtableSlot = VisitInt32(context.int32()[1]).Value; - - currentMethod.Definition.VTableEntry = vtableEntry; - currentMethod.Definition.VTableSlot = vtableSlot; - } - else if (context.OVERRIDE() is not null) - { - BlobBuilder signature = currentMethod.Definition.MethodSignature!; - if (context.callConv() is {} callConv) - { - // We have an explicitly specified signature, so we need to parse it. - signature = new(); - var callConvByte = VisitCallConv(callConv).Value; - var arity = VisitGenArity(context.genArity()).Value; - if (arity > 0) - { - callConvByte |= (byte)SignatureAttributes.Generic; - } - signature.WriteByte(callConvByte); - if (arity > 0) - { - signature.WriteCompressedInteger(arity); - } - var args = VisitSigArgs(context.sigArgs()).Value; - signature.WriteCompressedInteger(args.Length); - VisitType(context.type()).Value.WriteContentTo(signature); - foreach (var arg in args) - { - arg.SignatureBlob.WriteContentTo(signature); - } - } - - var ownerType = VisitTypeSpec(context.typeSpec()).Value; - var methodName = VisitMethodName(context.methodName()).Value; - var methodRef = _entityRegistry.CreateLazilyRecordedMemberReference(ownerType, methodName, signature); - _currentTypeDefinition.PeekOrDefault()!.MethodImplementations.Add(EntityRegistry.CreateUnrecordedMethodImplementation(currentMethod.Definition, methodRef)); - } - else if (context.PARAM() is not null) - { - // BREAK-COMPAT: We require attributes on parameters, generic parameters, and constraints - // to be specified directly after the .param directive, not at any point later in the method. - // This matches the IL outputted by ILDASM, ILSpy, and other tools in the ecosystem. - // Attributes not specified directly after the .param directive are applied to the method itself. - var customAttrDeclarations = context.customAttrDecl(); - if (context.TYPE() is not null) - { - // Type parameters - EntityRegistry.GenericParameterEntity? param = null; - if (context.int32() is { Length: > 0 } int32) - { - int index = VisitInt32(int32[0]).Value; - if (index < 0 || index >= currentMethod.Definition.GenericParameters.Count) - { - ReportError(DiagnosticIds.GenericParameterIndexOutOfRange, - string.Format(DiagnosticMessageTemplates.GenericParameterIndexOutOfRange, index), - context); - return GrammarResult.SentinelValue.Result; - } - param = currentMethod.Definition.GenericParameters[index]; - } - else - { - string name = VisitDottedName(context.dottedName()).Value; - foreach (var genericParam in currentMethod.Definition.GenericParameters) - { - if (genericParam.Name == name) - { - param = genericParam; - break; - } - } - if (param is null) - { - ReportError(DiagnosticIds.UnknownGenericParameter, - string.Format(DiagnosticMessageTemplates.UnknownGenericParameter, name), - context); - return GrammarResult.SentinelValue.Result; - } - } - foreach (var attr in customAttrDeclarations ?? Array.Empty()) - { - var customAttrDecl = VisitCustomAttrDecl(attr).Value; - customAttrDecl?.Owner = param; - } - } - else if (context.CONSTRAINT() is not null) - { - // constraints - EntityRegistry.GenericParameterEntity? param = null; - if (context.int32() is { Length: > 0 } int32) - { - int index = VisitInt32(int32[0]).Value; - if (index < 0 || index >= currentMethod.Definition.GenericParameters.Count) - { - ReportError(DiagnosticIds.GenericParameterIndexOutOfRange, - string.Format(DiagnosticMessageTemplates.GenericParameterIndexOutOfRange, index), - context); - return GrammarResult.SentinelValue.Result; - } - param = currentMethod.Definition.GenericParameters[index]; - } - else - { - string name = VisitDottedName(context.dottedName()).Value; - foreach (var genericParam in currentMethod.Definition.GenericParameters) - { - if (genericParam.Name == name) - { - param = genericParam; - break; - } - } - if (param is null) - { - ReportError(DiagnosticIds.UnknownGenericParameter, - string.Format(DiagnosticMessageTemplates.UnknownGenericParameter, name), - context); - return GrammarResult.SentinelValue.Result; - } - } - EntityRegistry.GenericParameterConstraintEntity? constraint = null; - var baseType = VisitTypeSpec(context.typeSpec()).Value; - foreach (var constraintEntity in param.Constraints) - { - if (constraintEntity.BaseType == baseType) - { - constraint = constraintEntity; - break; - } - } - if (constraint is null) - { - constraint = EntityRegistry.CreateGenericConstraint(baseType); - constraint.Owner = param; - param.Constraints.Add(constraint); - currentMethod.Definition.GenericParameterConstraints.Add(constraint); - } - foreach (var attr in customAttrDeclarations ?? Array.Empty()) - { - var customAttrDecl = VisitCustomAttrDecl(attr).Value; - customAttrDecl?.Owner = constraint; - } - } - else - { - // Adding attributes to parameters. - int index = VisitInt32(context.int32()[0]).Value; - if (index < 0 || index >= currentMethod.Definition.Parameters.Count) - { - ReportError(DiagnosticIds.ParameterIndexOutOfRange, - string.Format(DiagnosticMessageTemplates.ParameterIndexOutOfRange, index), - context); - return GrammarResult.SentinelValue.Result; - } - - // Handle initOpt to get the Constant table entry if a constant value is provided. - var constantValue = VisitInitOpt(context.initOpt()).Value; - var param = currentMethod.Definition.Parameters[index]; - if (constantValue is not NoConstantSentinel) - { - param.ConstantValue = constantValue; - param.HasConstant = true; - } - foreach (var attr in customAttrDeclarations ?? Array.Empty()) - { - var customAttrDecl = VisitCustomAttrDecl(attr).Value; - if (customAttrDecl is not null) - { - customAttrDecl.Owner = param; - param.HasCustomAttributes = true; - } - } - } - } - else if (context.secDecl() is {} secDecl) - { - var declarativeSecurity = VisitSecDecl(secDecl).Value; - declarativeSecurity?.Parent = currentMethod.Definition; - } - else if (context.customDescrInMethodBody() is {} customDescrInMethod) - { - var customAttr = VisitCustomDescrInMethodBody(customDescrInMethod).Value; - if (customAttr is not null) - { - customAttr.Owner = currentMethod.Definition; - } - } - else if (context.GetChild(0) is CILParser.InstrContext instr) - { - _ = VisitInstr(instr); - } - else - { - // Handle other methodDecl alternatives - var child = context.children[0]; - _ = child.Accept(this); - } - return GrammarResult.SentinelValue.Result; - } - - - public GrammarResult VisitMethodDecls(CILParser.MethodDeclsContext context) - { - foreach (var decl in context.methodDecl()) - { - VisitMethodDecl(decl); - } - return GrammarResult.SentinelValue.Result; - } - - GrammarResult ICILVisitor.VisitMethodHead(CILParser.MethodHeadContext context) => VisitMethodHead(context); - public GrammarResult.Literal VisitMethodHead(CILParser.MethodHeadContext context) - { - string name = VisitMethodName(context.methodName()).Value; - var containingType = _currentTypeDefinition.PeekOrDefault() ?? _entityRegistry.ModuleType; - var methodDefinition = EntityRegistry.CreateUnrecordedMethodDefinition(containingType, name); - - BlobBuilder methodSignature = new(); - byte sigHeader = VisitCallConv(context.callConv()).Value; - - // Two-pass generic parameter processing for method params: - // Pass 1: Register all parameter names (without resolving constraints) - _currentMethod = new(methodDefinition); - var typarContexts = context.typarsClause()?.typars()?.typar() ?? Array.Empty(); - for (int i = 0; i < typarContexts.Length; i++) - { - var attributes = VisitTyparAttribs(typarContexts[i].typarAttribs()).Value; - var param = EntityRegistry.CreateGenericParameter(attributes, VisitDottedName(typarContexts[i].dottedName()).Value); - param.Owner = methodDefinition; - param.Index = i; - methodDefinition.GenericParameters.Add(param); - } - if (typarContexts.Length != 0) - { - sigHeader |= (byte)SignatureAttributes.Generic; - } - methodDefinition.MethodAttributes = context.methAttr().Aggregate((MethodAttributes)0, (acc, attr) => acc | VisitMethAttr(attr)); - - // COMPAT: Native ilasm implicitly adds RTSpecialName + SpecialName for .ctor/.cctor methods - if (name is ".ctor" or ".cctor") - { - methodDefinition.MethodAttributes |= MethodAttributes.RTSpecialName | MethodAttributes.SpecialName; - } - // COMPAT: Native ilasm implicitly adds SpecialName when RTSpecialName is set - else if (methodDefinition.MethodAttributes.HasFlag(MethodAttributes.RTSpecialName)) - { - methodDefinition.MethodAttributes |= MethodAttributes.SpecialName; - } - - if (methodDefinition.MethodAttributes.HasFlag(MethodAttributes.Abstract) && !methodDefinition.ContainingType.Attributes.HasFlag(TypeAttributes.Abstract)) - { - ReportWarning(DiagnosticIds.AbstractMethodNotInAbstractType, - string.Format(DiagnosticMessageTemplates.AbstractMethodNotInAbstractType, methodDefinition.Name), - context); - } - - (EntityRegistry.ModuleReferenceEntity Module, string? EntryPoint, MethodImportAttributes Attributes)? pInvokeInformation = null; - foreach (var pInvokeInfo in context.pinvImpl()) - { - var (moduleName, entryPoint, attributes) = VisitPinvImpl(pInvokeInfo).Value; - if (moduleName is null) - { - ReportError(DiagnosticIds.InvalidPInvokeSignature, - DiagnosticMessageTemplates.InvalidPInvokeSignature, - pInvokeInfo); - continue; - } - pInvokeInformation = (_entityRegistry.GetOrCreateModuleReference(moduleName, _ => { }), entryPoint ?? name, attributes); - } - methodDefinition.MethodImportInformation = pInvokeInformation; - - SignatureHeader parsedHeader = new(sigHeader); - if (methodDefinition.MethodAttributes.HasFlag(MethodAttributes.Static) && (parsedHeader.IsInstance || parsedHeader.HasExplicitThis)) - { - // Error on static + instance. - } - // COMPAT: Native ilasm auto-adds instance calling convention for non-static methods in class context - if (!methodDefinition.MethodAttributes.HasFlag(MethodAttributes.Static) - && !parsedHeader.IsInstance - && _currentTypeDefinition.Count > 0) - { - sigHeader |= (byte)SignatureAttributes.Instance; - parsedHeader = new(sigHeader); - } - if (parsedHeader.HasExplicitThis && !parsedHeader.IsInstance) - { - // Warn on explicit-this + non-instance - parsedHeader = new(sigHeader |= (byte)SignatureAttributes.Instance); - } - methodSignature.WriteByte(sigHeader); - if (typarContexts.Length != 0) - { - methodSignature.WriteCompressedInteger(typarContexts.Length); - } - // Pass 2: Resolve constraints (now all params are registered) - for (int i = 0; i < typarContexts.Length; i++) - { - var param = methodDefinition.GenericParameters[i]; - foreach (var constraint in VisitTyBound(typarContexts[i].tyBound()).Value) - { - constraint.Owner = param; - param.Constraints.Add(constraint); - methodDefinition.GenericParameterConstraints.Add(constraint); - } - } - - var args = VisitSigArgs(context.sigArgs()).Value; - methodSignature.WriteCompressedInteger(args.Length); - - SignatureArg returnValue = new(VisitParamAttr(context.paramAttr()).Value, VisitType(context.type()).Value, VisitMarshalClause(context.marshalClause()).Value, null); - - returnValue.SignatureBlob.WriteContentTo(methodSignature); - methodDefinition.Parameters.Add(EntityRegistry.CreateParameter(returnValue.Attributes, returnValue.Name, returnValue.MarshallingDescriptor, 0)); - for (int i = 0; i < args.Length; i++) - { - SignatureArg? arg = args[i]; - arg.SignatureBlob.WriteContentTo(methodSignature); - // COMPAT: Native ilasm auto-generates A_N names for unnamed parameters - string? paramName = arg.Name ?? $"A_{i}"; - methodDefinition.Parameters.Add(EntityRegistry.CreateParameter(arg.Attributes, paramName, arg.MarshallingDescriptor, i + 1)); - } - // We've parsed all signature information. We can reset the current method now (the caller will handle setting/unsetting it for the method body). - _currentMethod = null; - methodDefinition.SignatureHeader = parsedHeader; - methodDefinition.MethodSignature = methodSignature; - - methodDefinition.ImplementationAttributes = context.implAttr().Aggregate((MethodImplAttributes)0, (acc, attr) => acc | VisitImplAttr(attr)); - if (!EntityRegistry.TryAddMethodDefinitionToContainingType(methodDefinition)) - { - ReportError(DiagnosticIds.DuplicateMethod, - DiagnosticMessageTemplates.DuplicateMethod, - context); - } - - return new(methodDefinition); - } - - GrammarResult ICILVisitor.VisitMethodName(CILParser.MethodNameContext context) => VisitMethodName(context); - public GrammarResult.String VisitMethodName(CILParser.MethodNameContext context) - { - IParseTree child = context.GetChild(0); - if (child is ITerminalNode terminal) - { - return new(terminal.Symbol.Text); - } - Debug.Assert(child is CILParser.DottedNameContext); - return (GrammarResult.String)child.Accept(this); - } - - private bool _expectInstance; - private Subsystem _subsystem = Subsystem.WindowsCui; - private CorFlags _corflags = CorFlags.ILOnly; - private int _alignment = 0x200; - private long _imageBase = 0x00400000; - private long _stackReserve; - - GrammarResult ICILVisitor.VisitMethodRef(CILParser.MethodRefContext context) => VisitMethodRef(context); - public GrammarResult.Literal VisitMethodRef(CILParser.MethodRefContext context) - { - if (context.mdtoken() is CILParser.MdtokenContext token) - { - return new(VisitMdtoken(token).Value); - } - if (context.dottedName() is CILParser.DottedNameContext dottedName) - { - // This is a typedef reference for a method member - string alias = VisitDottedName(dottedName).Value; - var resolved = TryResolveTypedefAsMember(alias); - if (resolved is not null) - { - return new(resolved); - } - ReportError(DiagnosticIds.TypedefNotFound, string.Format(DiagnosticMessageTemplates.TypedefNotFound, alias), context); - return new(_entityRegistry.CreateLazilyRecordedMemberReference(_entityRegistry.ModuleType, alias, new BlobBuilder())); - } - BlobBuilder methodRefSignature = new(); - if (context.callConv() is not CILParser.CallConvContext callConvCtx) - { - // Parse error recovery - callConv is missing - return new(_entityRegistry.CreateLazilyRecordedMemberReference(_entityRegistry.ModuleType, "", methodRefSignature)); - } - byte callConv = VisitCallConv(callConvCtx).Value; - EntityRegistry.TypeEntity owner = _entityRegistry.ModuleType; - if (context.typeSpec() is CILParser.TypeSpecContext typeSpec) - { - owner = VisitTypeSpec(typeSpec).Value; - } - string name = VisitMethodName(context.methodName()).Value; - BlobBuilder? methodSpecSignature = null; - int numGenericParameters = 0; - if (context.typeArgs() is CILParser.TypeArgsContext typeArgs) - { - var types = typeArgs.type(); - numGenericParameters = types.Length; - if (types.Length != 0) - { - methodSpecSignature = new(); - methodSpecSignature.WriteByte((byte)SignatureKind.MethodSpecification); - VisitTypeArgs(typeArgs).Value.WriteContentTo(methodSpecSignature); - } - } - else if (context.genArityNotEmpty() is CILParser.GenArityNotEmptyContext genArityNotEmpty) - { - numGenericParameters = VisitGenArityNotEmpty(genArityNotEmpty).Value; - } - if (numGenericParameters != 0) - { - callConv |= (byte)SignatureAttributes.Generic; - } - if (_expectInstance && (callConv & (byte)SignatureAttributes.Instance) == 0) - { - ReportWarning(DiagnosticIds.MissingInstanceCallConv, - DiagnosticMessageTemplates.MissingInstanceCallConv, - context); - callConv |= (byte)SignatureAttributes.Instance; - } - methodRefSignature.WriteByte(callConv); - if (numGenericParameters != 0) - { - methodRefSignature.WriteCompressedInteger(numGenericParameters); - } - var args = VisitSigArgs(context.sigArgs()).Value; - methodRefSignature.WriteCompressedInteger(args.Count(arg => !arg.IsSentinel)); - // Write return type - VisitType(context.type()).Value.WriteContentTo(methodRefSignature); - // Write arg signatures - foreach (var arg in args) - { - arg.SignatureBlob.WriteContentTo(methodRefSignature); - } - - var memberRef = _entityRegistry.CreateLazilyRecordedMemberReference(owner, name, methodRefSignature); - - if (methodSpecSignature is not null) - { - return new(_entityRegistry.GetOrCreateMethodSpecification(memberRef, methodSpecSignature)); - } - - return new(memberRef); - } - - private EntityRegistry.MemberReferenceEntity CreateExplicitMethodReference( - CILParser.CallConvContext callConv, - CILParser.TypeContext returnType, - CILParser.TypeSpecContext owner, - CILParser.MethodNameContext methodName, - CILParser.GenArityContext? genericArity, - CILParser.SigArgsContext parameterList) - { - EntityRegistry.TypeEntity ownerType = VisitTypeSpec(owner).Value; - string name = VisitMethodName(methodName).Value; - return _entityRegistry.CreateLazilyRecordedMemberReference( - ownerType, - name, - CreateExplicitMethodSignature(callConv, returnType, genericArity, parameterList)); - } - - private BlobBuilder CreateExplicitMethodSignature( - CILParser.CallConvContext callConv, - CILParser.TypeContext returnType, - CILParser.GenArityContext? genericArity, - CILParser.SigArgsContext parameterList) - { - BlobBuilder signature = new(); - byte signatureHeader = VisitCallConv(callConv).Value; - int arity = genericArity is null ? 0 : VisitGenArity(genericArity).Value; - if (arity != 0) - { - signatureHeader |= (byte)SignatureAttributes.Generic; - } - - signature.WriteByte(signatureHeader); - if (arity != 0) - { - signature.WriteCompressedInteger(arity); - } - - ImmutableArray parameters = VisitSigArgs(parameterList).Value; - signature.WriteCompressedInteger(parameters.Count(parameter => !parameter.IsSentinel)); - VisitType(returnType).Value.WriteContentTo(signature); - foreach (SignatureArg parameter in parameters) - { - parameter.SignatureBlob.WriteContentTo(signature); - } - - return signature; - } - - public GrammarResult VisitModuleHead(CILParser.ModuleHeadContext context) - { - if (context.ChildCount > 2) - { - _ = _entityRegistry.GetOrCreateModuleReference(VisitDottedName(context.dottedName()).Value, _ => { }); - return GrammarResult.SentinelValue.Result; - } - - if (context.dottedName() is { } moduleName) - { - _entityRegistry.Module.Name = VisitDottedName(moduleName).Value; - } - return GrammarResult.SentinelValue.Result; - } - - // .mscorlib directive indicates the assembly being compiled is mscorlib itself. - // This is currently a no-op; the flag would be used to affect type resolution - // when support for compiling mscorlib is added. - public GrammarResult VisitMscorlib(CILParser.MscorlibContext context) => GrammarResult.SentinelValue.Result; - - GrammarResult ICILVisitor.VisitNameSpaceHead(CILParser.NameSpaceHeadContext context) => VisitNameSpaceHead(context); - - public static GrammarResult.String VisitNameSpaceHead(CILParser.NameSpaceHeadContext context) => VisitDottedName(context.dottedName()); - - GrammarResult ICILVisitor.VisitNameValPair(CILParser.NameValPairContext context) => VisitNameValPair(context); - public GrammarResult.Literal> VisitNameValPair(CILParser.NameValPairContext context) - { - return new(new(VisitCompQstring(context.compQstring()).Value, VisitCaValue(context.caValue()).Value)); - } - - GrammarResult ICILVisitor.VisitNameValPairs(CILParser.NameValPairsContext context) => VisitNameValPairs(context); - public GrammarResult.Sequence> VisitNameValPairs(CILParser.NameValPairsContext context) => new(context.nameValPair().Select(pair => VisitNameValPair(pair).Value).ToImmutableArray()); - - GrammarResult ICILVisitor.VisitNativeType(CILParser.NativeTypeContext context) => VisitNativeType(context); - public GrammarResult.FormattedBlob VisitNativeType(CILParser.NativeTypeContext context) - { - if (context.nativeTypeElement() is not CILParser.NativeTypeElementContext element) - { - return new(new BlobBuilder()); - } - - CILParser.NativeTypeArrayPointerInfoContext[] arrayPointerInfo = context.nativeTypeArrayPointerInfo(); - if (arrayPointerInfo.Length == 0) - { - return VisitNativeTypeElement(element); - } - var prefix = new BlobBuilder(arrayPointerInfo.Length); - var elementType = VisitNativeTypeElement(element).Value; - var suffix = new BlobBuilder(); - - for (int i = arrayPointerInfo.Length - 1; i >= 0; i--) - { - if (arrayPointerInfo[i] is CILParser.PointerNativeTypeContext) - { - ReportWarning(DiagnosticIds.DeprecatedNativeType, - string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "pointer in array"), - context); - const int NATIVE_TYPE_PTR = 0x10; - prefix.WriteByte(NATIVE_TYPE_PTR); - } - else - { - prefix.WriteByte((byte)UnmanagedType.LPArray); - if (elementType.Count == 0) - { - // We need to have an element type for arrays, - // so write the invalid NATIVE_TYPE_MAX value so we have something parsable. - const int NATIVE_TYPE_MAX = 0x50; - elementType.WriteByte(NATIVE_TYPE_MAX); - } - } - } - - for (int i = 0; i < arrayPointerInfo.Length; i++) - { - if (arrayPointerInfo[i] is CILParser.PointerArrayTypeSizeContext size) - { - suffix.WriteCompressedInteger(0); - suffix.WriteCompressedInteger(VisitInt32(size.int32()).Value); - suffix.WriteCompressedInteger(0); - } - else if (arrayPointerInfo[i] is CILParser.PointerArrayTypeSizeParamIndexContext sizeParamIndex) - { - var ints = sizeParamIndex.int32(); - suffix.WriteCompressedInteger(VisitInt32(ints[1]).Value); - suffix.WriteCompressedInteger(VisitInt32(ints[0]).Value); - suffix.WriteCompressedInteger(1); // Write that the paramIndex parameter was specified - } - else if (arrayPointerInfo[i] is CILParser.PointerArrayTypeParamIndexContext paramIndex) - { - suffix.WriteCompressedInteger(VisitInt32(paramIndex.int32()).Value); - } - } - - prefix.LinkSuffix(elementType); - prefix.LinkSuffix(suffix); - return new(prefix); - } - - GrammarResult ICILVisitor.VisitNativeTypeElement(CILParser.NativeTypeElementContext context) => VisitNativeTypeElement(context); - public GrammarResult.FormattedBlob VisitNativeTypeElement(CILParser.NativeTypeElementContext context) - { - var blob = new BlobBuilder(); - if (context.dottedName() is CILParser.DottedNameContext typedef) - { - // Native type typedefs are not yet fully supported - // For now, report an error and return empty blob - string alias = VisitDottedName(typedef).Value; - ReportError(DiagnosticIds.TypedefNotFound, string.Format(DiagnosticMessageTemplates.TypedefNotFound, alias), context); - return new(blob); - } - - if (context.marshalType is null) - { - if (context.marshalBool is not null) - { - blob.WriteByte((byte)UnmanagedType.VariantBool); - } - else if (context.unsignedMarshalType is not null) - { - blob.WriteByte(context.unsignedMarshalType.Type switch - { - CILParser.INT8 => (byte)UnmanagedType.U1, - CILParser.INT16 => (byte)UnmanagedType.U2, - CILParser.INT32_ => (byte)UnmanagedType.U4, - CILParser.INT64_ => (byte)UnmanagedType.U8, - _ => throw new UnreachableException(), - }); - } - return new(blob); - } - - switch (context.marshalType.Type) - { - case CILParser.CUSTOM: - { - blob.WriteByte((byte)UnmanagedType.CustomMarshaler); - CILParser.CompQstringContext[] strings = context.compQstring(); - if (strings.Length == 4) - { - ReportWarning(DiagnosticIds.DeprecatedCustomMarshaller, - DiagnosticMessageTemplates.DeprecatedCustomMarshaller, - context); - blob.WriteSerializedString(VisitCompQstring(strings[0]).Value); - blob.WriteSerializedString(VisitCompQstring(strings[1]).Value); - blob.WriteSerializedString(VisitCompQstring(strings[2]).Value); - blob.WriteSerializedString(VisitCompQstring(strings[3]).Value); - } - else - { - Debug.Assert(strings.Length == 2); - blob.WriteCompressedInteger(0); - blob.WriteCompressedInteger(0); - blob.WriteSerializedString(VisitCompQstring(strings[0]).Value); - blob.WriteSerializedString(VisitCompQstring(strings[1]).Value); - } - break; - } - case CILParser.SYSSTRING: - blob.WriteByte((byte)UnmanagedType.ByValTStr); - blob.WriteCompressedInteger(VisitInt32(context.int32()).Value); - break; - case CILParser.ARRAY: - blob.WriteByte((byte)UnmanagedType.ByValArray); - blob.WriteCompressedInteger(VisitInt32(context.int32()).Value); - VisitNativeType(context.nativeType()).Value.WriteContentTo(blob); - break; - case CILParser.VARIANT: - ReportWarning(DiagnosticIds.DeprecatedNativeType, - string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "VARIANT"), - context); - const int NATIVE_TYPE_VARIANT = 0xe; - blob.WriteByte(NATIVE_TYPE_VARIANT); - break; -#pragma warning disable CS0618 // Type or member is obsolete - case CILParser.CURRENCY: - blob.WriteByte((byte)UnmanagedType.Currency); - break; -#pragma warning restore CS0618 // Type or member is obsolete - case CILParser.SYSCHAR: - ReportWarning(DiagnosticIds.DeprecatedNativeType, - string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "SYSCHAR"), - context); - const int NATIVE_TYPE_SYSCHAR = 0xd; - blob.WriteByte(NATIVE_TYPE_SYSCHAR); - break; - case CILParser.VOID: - ReportWarning(DiagnosticIds.DeprecatedNativeType, - string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "VOID"), - context); - const int NATIVE_TYPE_VOID = 0x1; - blob.WriteByte(NATIVE_TYPE_VOID); - break; - case CILParser.BOOL: - blob.WriteByte((byte)UnmanagedType.Bool); - break; - case CILParser.INT8: - blob.WriteByte((byte)UnmanagedType.I1); - break; - case CILParser.INT16: - blob.WriteByte((byte)UnmanagedType.I2); - break; - case CILParser.INT32_: - blob.WriteByte((byte)UnmanagedType.I4); - break; - case CILParser.INT64_: - blob.WriteByte((byte)UnmanagedType.I8); - break; - case CILParser.FLOAT32: - blob.WriteByte((byte)UnmanagedType.R4); - break; - case CILParser.FLOAT64_: - blob.WriteByte((byte)UnmanagedType.R8); - break; - case CILParser.ERROR: - blob.WriteByte((byte)UnmanagedType.Error); - break; - case CILParser.UINT8: - blob.WriteByte((byte)UnmanagedType.U1); - break; - case CILParser.UINT16: - blob.WriteByte((byte)UnmanagedType.U2); - break; - case CILParser.UINT32: - blob.WriteByte((byte)UnmanagedType.U4); - break; - case CILParser.UINT64: - blob.WriteByte((byte)UnmanagedType.U8); - break; - case CILParser.DECIMAL: - ReportWarning(DiagnosticIds.DeprecatedNativeType, - string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "DECIMAL"), - context); - const int NATIVE_TYPE_DECIMAL = 0x11; - blob.WriteByte(NATIVE_TYPE_DECIMAL); - break; - case CILParser.DATE: - ReportWarning(DiagnosticIds.DeprecatedNativeType, - string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "DATE"), - context); - const int NATIVE_TYPE_DATE = 0x12; - blob.WriteByte(NATIVE_TYPE_DATE); - break; - case CILParser.BSTR: - // Distinguish 'ansi bstr' (AnsiBStr) from plain 'bstr' (BStr) - if (context.ANSI() is not null) - { -#pragma warning disable CS0618 // Type or member is obsolete - blob.WriteByte((byte)UnmanagedType.AnsiBStr); -#pragma warning restore CS0618 - } - else - { - blob.WriteByte((byte)UnmanagedType.BStr); - } - break; - case CILParser.LPSTR: - blob.WriteByte((byte)UnmanagedType.LPStr); - break; - case CILParser.LPWSTR: - blob.WriteByte((byte)UnmanagedType.LPWStr); - break; - case CILParser.LPTSTR: - blob.WriteByte((byte)UnmanagedType.LPTStr); - break; - case CILParser.OBJECTREF: - ReportWarning(DiagnosticIds.DeprecatedNativeType, - string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "OBJECTREF"), - context); - const int NATIVE_TYPE_OBJECTREF = 0x18; - blob.WriteByte(NATIVE_TYPE_OBJECTREF); - break; - case CILParser.IUNKNOWN: - { - blob.WriteByte((byte)UnmanagedType.IUnknown); - if (VisitIidParamIndex(context.iidParamIndex()) is { Value: int index }) - { - blob.WriteCompressedInteger(index); - } - break; - } - case CILParser.IDISPATCH: - { - blob.WriteByte((byte)UnmanagedType.IDispatch); - if (VisitIidParamIndex(context.iidParamIndex()) is { Value: int index }) - { - blob.WriteCompressedInteger(index); - } - break; - } - case CILParser.STRUCT: - // Distinguish 'nested struct' from plain 'struct' - if (context.GetChild(0)?.GetText() == "nested") - { - ReportWarning(DiagnosticIds.DeprecatedNativeType, - string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "NESTEDSTRUCT"), - context); - const int NATIVE_TYPE_NESTEDSTRUCT = 0x21; - blob.WriteByte(NATIVE_TYPE_NESTEDSTRUCT); - } - else - { - blob.WriteByte((byte)UnmanagedType.Struct); - } - break; - case CILParser.INTERFACE: - { - blob.WriteByte((byte)UnmanagedType.Interface); - if (VisitIidParamIndex(context.iidParamIndex()) is { Value: int index }) - { - blob.WriteCompressedInteger(index); - } - break; - } - case CILParser.SAFEARRAY: - blob.WriteByte((byte)UnmanagedType.SafeArray); - blob.WriteCompressedInteger((int)VisitVariantType(context.variantType()).Value); - if (context.compQstring() is { Length: 1 } safeArrayCustomType) - { - string str = VisitCompQstring(safeArrayCustomType[0]).Value; - blob.WriteSerializedString(str); - } - else - { - blob.WriteCompressedInteger(0); - } - break; - case CILParser.INT: - blob.WriteByte((byte)UnmanagedType.SysInt); - break; - case CILParser.UINT: - blob.WriteByte((byte)UnmanagedType.SysUInt); - break; -#pragma warning disable CS0618 // Type or member is obsolete - case CILParser.BYVALSTR: - blob.WriteByte((byte)UnmanagedType.VBByRefStr); - break; - case CILParser.TBSTR: - blob.WriteByte((byte)UnmanagedType.TBStr); - break; -#pragma warning restore CS0618 // Type or member is obsolete - case CILParser.METHOD: - blob.WriteByte((byte)UnmanagedType.FunctionPtr); - break; - case CILParser.LPSTRUCT: - blob.WriteByte((byte)UnmanagedType.LPStruct); - break; -#pragma warning disable CS0618 // Type or member is obsolete - case CILParser.ANY: - blob.WriteByte((byte)UnmanagedType.AsAny); - break; -#pragma warning restore CS0618 // Type or member is obsolete - } - - return new(blob); - } - - GrammarResult ICILVisitor.VisitObjSeq(CILParser.ObjSeqContext context) => VisitObjSeq(context); - public GrammarResult.FormattedBlob VisitObjSeq(CILParser.ObjSeqContext context) - { - BlobBuilder objSeqBlob = new(); - foreach (var item in context.serInit()) - { - // Each element in object[] is encoded as FieldOrPropType + value, - // where FieldOrPropType is the concrete type (bool, int32, string, etc.), - // NOT TaggedObject (0x51). The object(...) wrapper is used to explicitly - // box a value but does not change the element's concrete type in the encoding. - // Unwrap any object(...) wrappers to get the actual typed inner element. - CILParser.SerInitContext actualItem = item; - while (actualItem.serInit() is { } inner) - { - actualItem = inner; - } - WriteCustomAttributeFieldOrPropType(objSeqBlob, actualItem); - objSeqBlob.LinkSuffix(VisitSerInit(actualItem).Value); - } - return new(objSeqBlob); - } - - GrammarResult ICILVisitor.VisitOwnerType(CILParser.OwnerTypeContext context) => VisitOwnerType(context); - public GrammarResult.Literal VisitOwnerType(CILParser.OwnerTypeContext context) - { - if (context.memberRef() is CILParser.MemberRefContext memberRef) - { - return VisitMemberRef(memberRef); - } - if (context.typeSpec() is CILParser.TypeSpecContext typeSpec) - { - return new(VisitTypeSpec(typeSpec).Value); - } - throw new UnreachableException(); - } - GrammarResult ICILVisitor.VisitParamAttr(CILParser.ParamAttrContext context) => VisitParamAttr(context); - public GrammarResult.Literal VisitParamAttr(CILParser.ParamAttrContext context) - { - ParameterAttributes attributes = 0; - foreach (var element in context.paramAttrElement()) - { - attributes |= VisitParamAttrElement(element); - } - return new(attributes); - } - - GrammarResult ICILVisitor.VisitParamAttrElement(CILParser.ParamAttrElementContext context) => VisitParamAttrElement(context); - public GrammarResult.Flag VisitParamAttrElement(CILParser.ParamAttrElementContext context) - { - if (context.int32() is CILParser.Int32Context int32) - { - return new((ParameterAttributes)(VisitInt32(int32).Value + 1), ShouldAppend: false); - } - return context switch - { - { @in: not null } => new(ParameterAttributes.In), - { @out: not null } => new(ParameterAttributes.Out), - { opt: not null } => new(ParameterAttributes.Optional), - _ => throw new UnreachableException() - }; - } - - GrammarResult ICILVisitor.VisitPinvAttr(CILParser.PinvAttrContext context) => VisitPinvAttr(context); - public GrammarResult.Flag VisitPinvAttr(CILParser.PinvAttrContext context) - { - if (context.int32() is CILParser.Int32Context int32) - { - return new((MethodImportAttributes)VisitInt32(int32).Value, ShouldAppend: false); - } - switch (context.GetText()) - { - case "nomangle": - return new(MethodImportAttributes.ExactSpelling); - case "ansi": - return new(MethodImportAttributes.CharSetAnsi); - case "unicode": - return new(MethodImportAttributes.CharSetUnicode); - case "autochar": - return new(MethodImportAttributes.CharSetAuto); - case "lasterr": - return new(MethodImportAttributes.SetLastError); - case "winapi": - return new(MethodImportAttributes.CallingConventionWinApi); - case "cdecl": - return new(MethodImportAttributes.CallingConventionCDecl); - case "stdcall": - return new(MethodImportAttributes.CallingConventionStdCall); - case "thiscall": - return new(MethodImportAttributes.CallingConventionThisCall); - case "fastcall": - return new(MethodImportAttributes.CallingConventionFastCall); - case "bestfit:on": - return new(MethodImportAttributes.BestFitMappingEnable); - case "bestfit:off": - return new(MethodImportAttributes.BestFitMappingDisable); - case "charmaperror:on": - return new(MethodImportAttributes.ThrowOnUnmappableCharEnable); - case "charmaperror:off": - return new(MethodImportAttributes.ThrowOnUnmappableCharDisable); - default: - throw new UnreachableException(); - } - } - - GrammarResult ICILVisitor.VisitPinvImpl(CILParser.PinvImplContext context) => VisitPinvImpl(context); - public GrammarResult.Literal<(string? ModuleName, string? EntryPointName, MethodImportAttributes Attributes)> VisitPinvImpl(CILParser.PinvImplContext context) - { - MethodImportAttributes attrs = MethodImportAttributes.None; - foreach (var attr in context.pinvAttr()) - { - attrs |= VisitPinvAttr(attr); - } - var names = context.compQstring(); - string? moduleName = names.Length > 0 ? VisitCompQstring(names[0]).Value : null; - string? entryPointName = names.Length > 1 ? VisitCompQstring(names[1]).Value : null; - return new((moduleName, entryPointName, attrs)); - } - - GrammarResult ICILVisitor.VisitPropAttr(CILParser.PropAttrContext context) => VisitPropAttr(context); - public static GrammarResult.Flag VisitPropAttr(CILParser.PropAttrContext context) - { - return context.GetText() switch - { - "specialname" => new(PropertyAttributes.SpecialName), - "rtspecialname" => new(0), // COMPAT: Ignore - _ => throw new UnreachableException(), - }; - } - - GrammarResult ICILVisitor.VisitPropDecl(CILParser.PropDeclContext context) => VisitPropDecl(context); - public GrammarResult.Literal<(MethodSemanticsAttributes, EntityRegistry.EntityBase)?> VisitPropDecl(CILParser.PropDeclContext context) - { - if (context.ChildCount != 2) - { - return new(null); - } - string accessor = context.GetChild(0).GetText(); - EntityRegistry.EntityBase memberReference = VisitMethodRef(context.methodRef()).Value; - MethodSemanticsAttributes methodSemanticsAttributes = accessor switch - { - ".set" => MethodSemanticsAttributes.Setter, - ".get" => MethodSemanticsAttributes.Getter, - ".other" => MethodSemanticsAttributes.Other, - _ => throw new UnreachableException(), - }; - return new((methodSemanticsAttributes, memberReference)); - } - - GrammarResult ICILVisitor.VisitPropDecls(CILParser.PropDeclsContext context) => VisitPropDecls(context); - public GrammarResult.Sequence<(MethodSemanticsAttributes, EntityRegistry.EntityBase)> VisitPropDecls(CILParser.PropDeclsContext context) - => new( - context.propDecl() - .Select(decl => VisitPropDecl(decl).Value) - .Where(decl => decl is not null) - .Select(decl => decl!.Value).ToImmutableArray()); - - GrammarResult ICILVisitor.VisitPropHead(ILAssembler.CILParser.PropHeadContext context) => VisitPropHead(context); - public GrammarResult.Literal VisitPropHead(CILParser.PropHeadContext context) - { - var propAttrs = context.propAttr().Select(VisitPropAttr).Aggregate((PropertyAttributes)0, (a, b) => a | b); - var name = VisitDottedName(context.dottedName()).Value; - - var signature = new BlobBuilder(); - byte callConv = (byte)(VisitCallConv(context.callConv()).Value | (byte)SignatureKind.Property); - signature.WriteByte(callConv); - var args = VisitSigArgs(context.sigArgs()).Value; - signature.WriteCompressedInteger(args.Length); - VisitType(context.type()).Value.WriteContentTo(signature); - foreach (var arg in args) - { - arg.SignatureBlob.WriteContentTo(signature); - } - - // Handle initOpt to set the Constant table entry if a constant value is provided. - var constantValue = VisitInitOpt(context.initOpt()).Value; - var property = new EntityRegistry.PropertyEntity(propAttrs, signature, name); - if (constantValue is not NoConstantSentinel) - { - property.ConstantValue = constantValue; - property.HasConstant = true; - property.Attributes |= PropertyAttributes.HasDefault; - } - return new(property); - } - - GrammarResult ICILVisitor.VisitRepeatOpt(CILParser.RepeatOptContext context) => VisitRepeatOpt(context); - public GrammarResult.Literal VisitRepeatOpt(CILParser.RepeatOptContext context) => context.int32() is {} int32 ? new(VisitInt32(int32).Value) : new(null); - - public GrammarResult VisitScopeBlock(CILParser.ScopeBlockContext context) - { - int numLocalsScopes = _currentMethod!.LocalsScopes.Count; - _ = VisitMethodDecls(context.methodDecls()); - _currentMethod.LocalsScopes.RemoveRange(numLocalsScopes, _currentMethod.LocalsScopes.Count - numLocalsScopes); - return GrammarResult.SentinelValue.Result; - } - - GrammarResult ICILVisitor.VisitSecAction(CILParser.SecActionContext context) => VisitSecAction(context); - public static GrammarResult.Literal VisitSecAction(CILParser.SecActionContext context) - { - return context.GetText() switch - { - "request" => new(DeclarativeSecurityAction.Request), - "demand" => new(DeclarativeSecurityAction.Demand), - "assert" => new(DeclarativeSecurityAction.Assert), - "deny" => new(DeclarativeSecurityAction.Deny), - "permitonly" => new(DeclarativeSecurityAction.PermitOnly), - "linkcheck" => new(DeclarativeSecurityAction.LinkDemand), - "inheritcheck" => new(DeclarativeSecurityAction.InheritanceDemand), - "reqmin" => new(DeclarativeSecurityAction.RequestMinimum), - "reqopt" => new(DeclarativeSecurityAction.RequestOptional), - "reqrefuse" => new(DeclarativeSecurityAction.RequestRefuse), - "prejitgrant" => new(DeclarativeSecurityAction.PrejitGrant), - "prejitdeny" => new(DeclarativeSecurityAction.PrejitDeny), - "noncasdemand" => new(DeclarativeSecurityAction.NonCasDemand), - "noncaslinkdemand" => new(DeclarativeSecurityAction.NonCasLinkDemand), - "noncasinheritance" => new(DeclarativeSecurityAction.NonCasInheritanceDemand), - _ => throw new UnreachableException() - }; - } - GrammarResult ICILVisitor.VisitSecAttrBlob(CILParser.SecAttrBlobContext context) => VisitSecAttrBlob(context); - public GrammarResult.FormattedBlob VisitSecAttrBlob(CILParser.SecAttrBlobContext context) - { - var blob = new BlobBuilder(); - - string attributeName = string.Empty; - - if (context.typeSpec() is CILParser.TypeSpecContext typeSpec && VisitTypeSpec(typeSpec).Value is EntityRegistry.IHasReflectionNotation reflectionNotation) - { - attributeName = reflectionNotation.ReflectionNotation; - } - else if (context.SQSTRING() is { } sqstring) - { - attributeName = StringHelpers.ParseQuotedString(sqstring.GetText()); - } - - blob.WriteSerializedString(attributeName); - VisitCustomBlobNVPairs(context.customBlobNVPairs()).Value.WriteContentTo(blob); - - return new(blob); - } - - GrammarResult ICILVisitor.VisitSecAttrSetBlob(CILParser.SecAttrSetBlobContext context) => VisitSecAttrSetBlob(context); - public GrammarResult.FormattedBlob VisitSecAttrSetBlob(CILParser.SecAttrSetBlobContext context) - { - BlobBuilder blob = new(); - var secAttributes = context.secAttrBlob(); - blob.WriteByte((byte)'.'); - blob.WriteCompressedInteger(secAttributes.Length); - foreach (var secAttribute in secAttributes) - { - VisitSecAttrBlob(secAttribute).Value.WriteContentTo(blob); - } - return new(blob); - } - - GrammarResult ICILVisitor.VisitSecDecl(CILParser.SecDeclContext context) => VisitSecDecl(context); - public GrammarResult.Literal VisitSecDecl(CILParser.SecDeclContext context) - { - if (context.PERMISSION() is not null) - { - ReportError(DiagnosticIds.UnsupportedSecurityDeclaration, - DiagnosticMessageTemplates.UnsupportedSecurityDeclaration, - context); - return new(null); - } - DeclarativeSecurityAction action = VisitSecAction(context.secAction()).Value; - BlobBuilder value; - if (context.secAttrSetBlob() is CILParser.SecAttrSetBlobContext setBlob) - { - value = VisitSecAttrSetBlob(setBlob).Value; - } - else if (context.bytes() is CILParser.BytesContext bytes) - { - value = new(); - value.WriteBytes(VisitBytes(bytes).Value); - } - else if (context.compQstring() is CILParser.CompQstringContext str) - { - value = new BlobBuilder(); - value.WriteUTF16(VisitCompQstring(str).Value); - value.WriteUTF16("\0"); - } - else - { - throw new UnreachableException(); - } - return new(_entityRegistry.CreateDeclarativeSecurityAttribute(action, value)); - } - - internal abstract record ExceptionClause(LabelHandle Start, LabelHandle End) - { - internal sealed record Catch(EntityRegistry.TypeEntity Type, LabelHandle Start, LabelHandle End) : ExceptionClause(Start, End); - - internal sealed record Filter(LabelHandle FilterStart, LabelHandle Start, LabelHandle End) : ExceptionClause(Start, End); - - internal sealed record Finally(LabelHandle Start, LabelHandle End) : ExceptionClause(Start, End); - - internal sealed record Fault(LabelHandle Start, LabelHandle End) : ExceptionClause(Start, End); - } - - public GrammarResult VisitSehBlock(CILParser.SehBlockContext context) - { - var (tryStart, tryEnd) = VisitTryBlock(context.tryBlock()).Value; - foreach (var clause in VisitSehClauses(context.sehClauses()).Value) - { - switch (clause) - { - case ExceptionClause.Finally finallyClause: - _currentMethod!.Definition.ExceptionRegions.Add(new EntityRegistry.ExceptionRegion.FinallyRegion(tryStart, tryEnd, finallyClause.Start, finallyClause.End)); - break; - case ExceptionClause.Fault faultClause: - _currentMethod!.Definition.ExceptionRegions.Add(new EntityRegistry.ExceptionRegion.FaultRegion(tryStart, tryEnd, faultClause.Start, faultClause.End)); - break; - case ExceptionClause.Catch catchClause: - _currentMethod!.Definition.ExceptionRegions.Add(new EntityRegistry.ExceptionRegion.CatchRegion(tryStart, tryEnd, catchClause.Start, catchClause.End, catchClause.Type)); - break; - case ExceptionClause.Filter filterClause: - _currentMethod!.Definition.ExceptionRegions.Add(new EntityRegistry.ExceptionRegion.FilterRegion(tryStart, tryEnd, filterClause.Start, filterClause.End, filterClause.FilterStart)); - break; - default: - throw new UnreachableException(); - } - } - return GrammarResult.SentinelValue.Result; - } - GrammarResult ICILVisitor.VisitSehClause(CILParser.SehClauseContext context) => VisitSehClause(context); - public GrammarResult.Literal VisitSehClause(CILParser.SehClauseContext context) - { - var (start, end) = VisitHandlerBlock(context.handlerBlock()).Value; - - if (context.finallyClause() is not null) - { - return new(new ExceptionClause.Finally(start, end)); - } - if (context.faultClause() is not null) - { - return new(new ExceptionClause.Fault(start, end)); - } - if (context.catchClause() is CILParser.CatchClauseContext catchClause) - { - return new(new ExceptionClause.Catch(VisitCatchClause(catchClause).Value, start, end)); - } - if (context.filterClause() is CILParser.FilterClauseContext filterClause) - { - return new(new ExceptionClause.Filter(VisitFilterClause(filterClause).Value, start, end)); - } - - throw new UnreachableException(); - } - - GrammarResult ICILVisitor.VisitSehClauses(CILParser.SehClausesContext context) => VisitSehClauses(context); - public GrammarResult.Sequence VisitSehClauses(CILParser.SehClausesContext context) => new(context.sehClause().Select(clause => VisitSehClause(clause).Value).ToImmutableArray()); - - GrammarResult ICILVisitor.VisitSerializType(CILParser.SerializTypeContext context) => VisitSerializType(context); - public GrammarResult.FormattedBlob VisitSerializType(CILParser.SerializTypeContext context) - { - var blob = new BlobBuilder(); - if (context.ARRAY_TYPE_NO_BOUNDS() is not null) - { - blob.WriteByte((byte)SerializationTypeCode.SZArray); - } - VisitSerializTypeElement(context.serializTypeElement()).Value.WriteContentTo(blob); - return new(blob); - } - - GrammarResult ICILVisitor.VisitSerializTypeElement(CILParser.SerializTypeElementContext context) => VisitSerializTypeElement(context); - public GrammarResult.FormattedBlob VisitSerializTypeElement(CILParser.SerializTypeElementContext context) - { - if (context.simpleType() is CILParser.SimpleTypeContext simpleType) - { - BlobBuilder blob = new(1); - blob.WriteByte((byte)VisitSimpleType(simpleType).Value); - return new(blob); - } - if (context.dottedName() is CILParser.DottedNameContext dottedName) - { - // Serialization type typedefs are not yet fully supported - string alias = VisitDottedName(dottedName).Value; - ReportError(DiagnosticIds.TypedefNotFound, string.Format(DiagnosticMessageTemplates.TypedefNotFound, alias), context); - return new(new BlobBuilder(1)); - } - if (context.TYPE() is not null) - { - BlobBuilder blob = new BlobBuilder(1); - blob.WriteByte((byte)SerializationTypeCode.Type); - return new(blob); - } - if (context.OBJECT() is not null) - { - BlobBuilder blob = new BlobBuilder(1); - blob.WriteByte((byte)SerializationTypeCode.TaggedObject); - return new(blob); - } - if (context.ENUM() is not null) - { - BlobBuilder blob = new BlobBuilder(); - blob.WriteByte((byte)SerializationTypeCode.Enum); - if (context.SQSTRING() is ITerminalNode sqString) - { - blob.WriteSerializedString(StringHelpers.ParseQuotedString(sqString.GetText())); - } - else - { - Debug.Assert(context.className() is not null); - blob.WriteSerializedString((VisitClassName(context.className()).Value as EntityRegistry.IHasReflectionNotation)?.ReflectionNotation ?? ""); - } - return new(blob); - } - throw new UnreachableException(); - } - - GrammarResult ICILVisitor.VisitSerInit(CILParser.SerInitContext context) => VisitSerInit(context); - public GrammarResult.FormattedBlob VisitSerInit(CILParser.SerInitContext context) - { - if (context.fieldSerInit() is CILParser.FieldSerInitContext fieldSerInit) - { - if (fieldSerInit.bytes() is not null) - { - ReportError( - DiagnosticIds.InvalidMetadataToken, - "bytearray is not a valid structured custom attribute value", - context); - var invalidValue = new BlobBuilder(); - invalidValue.WriteSerializedString(null); - return new(invalidValue); - } - - ImmutableArray encodedValue = VisitFieldSerInit(fieldSerInit).Value.ToImmutableArray(); - var value = new BlobBuilder(Math.Max(0, encodedValue.Length - 1)); - if (encodedValue.Length > 1) - { - value.WriteBytes(encodedValue.AsSpan().Slice(1).ToArray()); - } - return new(value); - } - - if (context.serInit() is CILParser.SerInitContext serInit) - { - Debug.Assert(context.OBJECT() is not null); - BlobBuilder taggedObjectBlob = new(); - WriteCustomAttributeFieldOrPropType(taggedObjectBlob, serInit); - taggedObjectBlob.LinkSuffix(VisitSerInit(serInit).Value); - return new(taggedObjectBlob); - } - - if (context.int32() is not CILParser.Int32Context arrLength) - { - BlobBuilder blob = new(); - if (context.className() is CILParser.ClassNameContext className) - { - blob.WriteSerializedString(VisitClassName(className).Value is EntityRegistry.IHasReflectionNotation reflection ? reflection.ReflectionNotation : string.Empty); - } - else - { - blob.WriteSerializedString( - context.SQSTRING() is { } stringNode - ? StringHelpers.ParseQuotedString(stringNode.Symbol.Text) - : null); - } - return new(blob); - } - - BlobBuilder arrayHeader = new(sizeof(int)); - arrayHeader.WriteInt32(VisitInt32(arrLength).Value); - var sequenceResult = (GrammarResult.FormattedBlob)Visit(context.GetRuleContext(1)); - arrayHeader.LinkSuffix(sequenceResult.Value); - return new(arrayHeader); - } - - private static void WriteCustomAttributeFieldOrPropType( - BlobBuilder builder, - CILParser.SerInitContext context) - { - int tokenType = context.fieldSerInit() is { } fieldSerInit - ? ((ITerminalNode)fieldSerInit.GetChild(0)).Symbol.Type - : ((ITerminalNode)context.GetChild(0)).Symbol.Type; - if (context.fieldSerInit()?.bytes() is not null) - { - builder.WriteByte((byte)SerializationTypeCode.String); - return; - } - if (context.int32() is not null) - { - builder.WriteByte((byte)SerializationTypeCode.SZArray); - } - - builder.WriteByte((byte)GetTypeCodeForToken(tokenType)); - } - - private static SerializationTypeCode GetTypeCodeForToken(int tokenType) - { - return tokenType switch - { - CILParser.INT8 => SerializationTypeCode.SByte, - CILParser.UINT8 => SerializationTypeCode.Byte, - CILParser.INT16 => SerializationTypeCode.Int16, - CILParser.UINT16 => SerializationTypeCode.UInt16, - CILParser.INT32_ => SerializationTypeCode.Int32, - CILParser.UINT32 => SerializationTypeCode.UInt32, - CILParser.INT64_ => SerializationTypeCode.Int64, - CILParser.UINT64 => SerializationTypeCode.UInt64, - CILParser.FLOAT32 => SerializationTypeCode.Single, - CILParser.FLOAT64_ => SerializationTypeCode.Double, - CILParser.CHAR => SerializationTypeCode.Char, - CILParser.BOOL => SerializationTypeCode.Boolean, - CILParser.STRING => SerializationTypeCode.String, - CILParser.TYPE => SerializationTypeCode.Type, - CILParser.OBJECT => SerializationTypeCode.TaggedObject, - _ => throw new UnreachableException() - }; - } - - /// - /// Checks if a type entity is a well-known corelib type and returns its primitive type code. - /// Native ilasm uses primitive type codes for well-known types like System.String and System.Object - /// in signature blobs instead of class/valuetype TypeRef references. - /// - private static SignatureTypeCode? TryGetPrimitiveTypeCode(EntityRegistry.TypeEntity typeEntity, bool isValueType) - { - if (typeEntity is not EntityRegistry.TypeReferenceEntity typeRef) - { - return null; - } - - string name = typeRef.Name; - string ns = typeRef.Namespace; - - if (ns != "System") - { - return null; - } - - if (isValueType) - { - return name switch - { - "Boolean" => SignatureTypeCode.Boolean, - "Char" => SignatureTypeCode.Char, - "SByte" => SignatureTypeCode.SByte, - "Byte" => SignatureTypeCode.Byte, - "Int16" => SignatureTypeCode.Int16, - "UInt16" => SignatureTypeCode.UInt16, - "Int32" => SignatureTypeCode.Int32, - "UInt32" => SignatureTypeCode.UInt32, - "Int64" => SignatureTypeCode.Int64, - "UInt64" => SignatureTypeCode.UInt64, - "Single" => SignatureTypeCode.Single, - "Double" => SignatureTypeCode.Double, - "IntPtr" => SignatureTypeCode.IntPtr, - "UIntPtr" => SignatureTypeCode.UIntPtr, - "TypedReference" => SignatureTypeCode.TypedReference, - _ => null - }; - } - - return name switch - { - "String" => SignatureTypeCode.String, - "Object" => SignatureTypeCode.Object, - _ => null - }; - } - - GrammarResult ICILVisitor.VisitSigArg(CILParser.SigArgContext context) => VisitSigArg(context); - public GrammarResult.Literal VisitSigArg(CILParser.SigArgContext context) - { - if (context.ELLIPSIS() is not null) - { - return new(SignatureArg.CreateSentinelArgument()); - } - string? name = context.id() is CILParser.IdContext id ? VisitId(id).Value : null; - return new(new SignatureArg( - VisitParamAttr(context.paramAttr()).Value, - VisitType(context.type()).Value, - VisitMarshalClause(context.marshalClause()).Value, - name)); - } - - GrammarResult ICILVisitor.VisitSigArgs(CILParser.SigArgsContext context) => VisitSigArgs(context); - public GrammarResult.Sequence VisitSigArgs(CILParser.SigArgsContext context) => new([.. context.sigArg().Select(arg => VisitSigArg(arg).Value)]); - GrammarResult ICILVisitor.VisitSimpleType(CILParser.SimpleTypeContext context) => VisitSimpleType(context); - public GrammarResult.Literal VisitSimpleType(CILParser.SimpleTypeContext context) - { - // Handle 'unsigned intN' forms (2 children: 'unsigned' + intN keyword) - if (context.ChildCount == 2) - { - return new(context.GetChild(1).Symbol.Type switch - { - CILParser.INT8 => SignatureTypeCode.Byte, - CILParser.INT16 => SignatureTypeCode.UInt16, - CILParser.INT32_ => SignatureTypeCode.UInt32, - CILParser.INT64_ => SignatureTypeCode.UInt64, - _ => throw new UnreachableException() - }); - } - - return new(context.GetChild(0).Symbol.Type switch - { - CILParser.CHAR => SignatureTypeCode.Char, - CILParser.STRING => SignatureTypeCode.String, - CILParser.BOOL => SignatureTypeCode.Boolean, - CILParser.INT8 => SignatureTypeCode.SByte, - CILParser.INT16 => SignatureTypeCode.Int16, - CILParser.INT32_ => SignatureTypeCode.Int32, - CILParser.INT64_ => SignatureTypeCode.Int64, - CILParser.FLOAT32 => SignatureTypeCode.Single, - CILParser.FLOAT64_ => SignatureTypeCode.Double, - CILParser.UINT8 => SignatureTypeCode.Byte, - CILParser.UINT16 => SignatureTypeCode.UInt16, - CILParser.UINT32 => SignatureTypeCode.UInt32, - CILParser.UINT64 => SignatureTypeCode.UInt64, - _ => throw new UnreachableException() - }); - } - - GrammarResult ICILVisitor.VisitSlashedName(CILParser.SlashedNameContext context) - { - return VisitSlashedName(context); - } - - public static GrammarResult.Literal VisitSlashedName(CILParser.SlashedNameContext context) - { - TypeName? currentTypeName = null; - foreach (var item in context.dottedName()) - { - currentTypeName = new TypeName(currentTypeName, VisitDottedName(item).Value); - } - // We'll always have at least one dottedName, so the value here will be non-null - return new(currentTypeName!); - } - - GrammarResult ICILVisitor.VisitSqstringSeq(CILParser.SqstringSeqContext context) => VisitSqstringSeq(context); - - public static GrammarResult.FormattedBlob VisitSqstringSeq(CILParser.SqstringSeqContext context) - { - var strings = ImmutableArray.CreateBuilder(context.ChildCount); - foreach (var child in context.children ?? []) - { - string? str = null; - - if (child is ITerminalNode { Symbol: { Type: CILParser.SQSTRING, Text: string stringValue } }) - { - str = StringHelpers.ParseQuotedString(stringValue); - } - - strings.Add(str); - } - return new(strings.MoveToImmutable().SerializeSequence()); - } - - GrammarResult ICILVisitor.VisitStackreserve(CILParser.StackreserveContext context) => VisitStackreserve(context); - public GrammarResult.Literal VisitStackreserve(CILParser.StackreserveContext context) => VisitInt64(context.int64()); - - GrammarResult ICILVisitor.VisitSubsystem(CILParser.SubsystemContext context) => VisitSubsystem(context); - public GrammarResult.Literal VisitSubsystem(CILParser.SubsystemContext context) => VisitInt32(context.int32()); - - public GrammarResult VisitTerminal(ITerminalNode node) => throw new UnreachableException(); - public GrammarResult VisitTls(CILParser.TlsContext context) - { - // TODO-SRM: System.Reflection.Metadata doesn't provide APIs to point a data declaration at a TLS slot or into the IL stream. - // We have tests for the TLS case (CoreCLR only supports it on Win-x86), but not for the IL case. - return GrammarResult.SentinelValue.Result; - } - - GrammarResult ICILVisitor.VisitTruefalse(CILParser.TruefalseContext context) => VisitTruefalse(context); - - public static GrammarResult.Literal VisitTruefalse(CILParser.TruefalseContext context) - { - return new(bool.Parse(context.GetText())); - } - - GrammarResult ICILVisitor.VisitTryBlock(CILParser.TryBlockContext context) => VisitTryBlock(context); - - public GrammarResult.Literal<(LabelHandle Start, LabelHandle End)> VisitTryBlock(CILParser.TryBlockContext context) - { - if (context.scopeBlock() is CILParser.ScopeBlockContext scopeBlock) - { - LabelHandle start = _currentMethod!.Definition.MethodBody.DefineLabel(); - _currentMethod.Definition.MethodBody.MarkLabel(start); - _ = VisitScopeBlock(scopeBlock); - LabelHandle end = _currentMethod.Definition.MethodBody.DefineLabel(); - _currentMethod.Definition.MethodBody.MarkLabel(end); - return new((start, end)); - } - var ids = context.id(); - if (ids.Length == 2) - { - var start = _currentMethod!.Labels.TryGetValue(VisitId(ids[0]).Value, out LabelHandle startLabel) ? startLabel : _currentMethod.Labels[VisitId(ids[0]).Value] = _currentMethod.Definition.MethodBody.DefineLabel(); - var end = _currentMethod!.Labels.TryGetValue(VisitId(ids[1]).Value, out LabelHandle endLabel) ? endLabel : _currentMethod.Labels[VisitId(ids[1]).Value] = _currentMethod.Definition.MethodBody.DefineLabel(); - return new((start, end)); - } - var offsets = context.int32(); - if (offsets.Length == 2) - { - var start = _currentMethod!.Definition.MethodBody.DefineLabel(); - var end = _currentMethod.Definition.MethodBody.DefineLabel(); - _currentMethod.Definition.MethodBody.MarkLabel(start, VisitInt32(offsets[0]).Value); - _currentMethod.Definition.MethodBody.MarkLabel(end, VisitInt32(offsets[1]).Value); - return new((start, end)); - } - throw new UnreachableException(); - } - - GrammarResult ICILVisitor.VisitTyBound(CILParser.TyBoundContext context) => VisitTyBound(context); - public GrammarResult.Sequence VisitTyBound(CILParser.TyBoundContext? context) - { - // context or typeList can be null when there are no constraints - if (context?.typeList() is not CILParser.TypeListContext typeList) - { - return new(ImmutableArray.Empty); - } - // Filter out null types (from unresolved type parameters) before creating constraints - return new(VisitTypeList(typeList).Value - .Where(t => t is not null) - .Select(EntityRegistry.CreateGenericConstraint) - .ToImmutableArray()); - } - - GrammarResult ICILVisitor.VisitTypar(CILParser.TyparContext context) => VisitTypar(context); - - public GrammarResult.Literal VisitTypar(CILParser.TyparContext context) - { - GenericParameterAttributes attributes = VisitTyparAttribs(context.typarAttribs()).Value; - EntityRegistry.GenericParameterEntity genericParameter = EntityRegistry.CreateGenericParameter(attributes, VisitDottedName(context.dottedName()).Value); - - foreach (var constraint in VisitTyBound(context.tyBound()).Value) - { - genericParameter.Constraints.Add(constraint); - } - - return new(genericParameter); - } - - GrammarResult ICILVisitor.VisitTyparAttrib(CILParser.TyparAttribContext context) => VisitTyparAttrib(context); - public GrammarResult.Flag VisitTyparAttrib(CILParser.TyparAttribContext context) - { - return context switch - { - { covariant: not null } => new(GenericParameterAttributes.Covariant), - { contravariant: not null } => new(GenericParameterAttributes.Contravariant), - { @class: not null } => new(GenericParameterAttributes.ReferenceTypeConstraint), - { valuetype: not null } => new(GenericParameterAttributes.NotNullableValueTypeConstraint), - { byrefLike: not null } => new(GenericParameterAttributes.AllowByRefLike), - { ctor: not null } => new(GenericParameterAttributes.DefaultConstructorConstraint), - { flags: CILParser.Int32Context int32 } => new((GenericParameterAttributes)VisitInt32(int32).Value), - _ => throw new UnreachableException() - }; - } - GrammarResult ICILVisitor.VisitTyparAttribs(CILParser.TyparAttribsContext context) => VisitTyparAttribs(context); - - public GrammarResult.Literal VisitTyparAttribs(CILParser.TyparAttribsContext context) => - new(context.typarAttrib() - .Select(VisitTyparAttrib) - .Aggregate( - (GenericParameterAttributes)0, (agg, attr) => agg | attr)); - - GrammarResult ICILVisitor.VisitTypars(CILParser.TyparsContext context) => VisitTypars(context); - public GrammarResult.Sequence VisitTypars(CILParser.TyparsContext context) - { - CILParser.TyparContext[] typeParameters = context.typar(); - ImmutableArray.Builder builder = ImmutableArray.CreateBuilder(typeParameters.Length); - - foreach (var typeParameter in typeParameters) - { - builder.Add(VisitTypar(typeParameter).Value); - } - return new(builder.MoveToImmutable()); - } - - GrammarResult ICILVisitor.VisitTyparsClause(CILParser.TyparsClauseContext context) => VisitTyparsClause(context); - public GrammarResult.Sequence VisitTyparsClause(CILParser.TyparsClauseContext context) => context.typars() is null ? new(ImmutableArray.Empty) : VisitTypars(context.typars()); - - GrammarResult ICILVisitor.VisitType(CILParser.TypeContext context) => VisitType(context); - public GrammarResult.FormattedBlob VisitType(CILParser.TypeContext context) - { - // These blobs will likely be very small, so use a smaller default size. - const int DefaultSignatureElementBlobSize = 10; - BlobBuilder prefix = new(DefaultSignatureElementBlobSize); - BlobBuilder suffix = new(DefaultSignatureElementBlobSize); - BlobBuilder elementType = VisitElementType(context.elementType()).Value; - - // Prefix blob writes outer modifiers first. - // Suffix blob writes inner modifiers first. - // Since all blobs are prefix blobs and only some have suffix data, - // We will go in reverse order to write the prefixes - // and then go in forward order to write the suffixes. - CILParser.TypeModifiersContext[] typeModifiers = context.typeModifiers(); - for (int i = typeModifiers.Length - 1; i >= 0; i--) - { - CILParser.TypeModifiersContext? modifier = typeModifiers[i]; - switch (modifier) - { - case CILParser.SZArrayModifierContext: - prefix.WriteByte((byte)SignatureTypeCode.SZArray); - break; - case CILParser.ArrayModifierContext: - prefix.WriteByte((byte)SignatureTypeCode.Array); - break; - case CILParser.ByRefModifierContext: - prefix.WriteByte((byte)SignatureTypeCode.ByReference); - break; - case CILParser.PtrModifierContext: - prefix.WriteByte((byte)SignatureTypeCode.Pointer); - break; - case CILParser.PinnedModifierContext: - prefix.WriteByte((byte)SignatureTypeCode.Pinned); - break; - case CILParser.RequiredModifierContext modreq: - prefix.WriteByte((byte)SignatureTypeCode.RequiredModifier); - prefix.WriteTypeEntity(VisitTypeSpec(modreq.typeSpec()).Value); - break; - case CILParser.OptionalModifierContext modopt: - prefix.WriteByte((byte)SignatureTypeCode.OptionalModifier); - prefix.WriteTypeEntity(VisitTypeSpec(modopt.typeSpec()).Value); - break; - case CILParser.GenericArgumentsModifierContext: - prefix.WriteByte((byte)SignatureTypeCode.GenericTypeInstance); - break; - } - } - - foreach (var modifier in typeModifiers) - { - switch (modifier) - { - case CILParser.ArrayModifierContext arr: - var bounds = VisitBounds(arr.bounds()).Value; - suffix.WriteCompressedInteger(bounds.Length); - // Count contiguous sizes from the start (stop at first null) - int numSizes = 0; - for (int bIdx = 0; bIdx < bounds.Length; bIdx++) - { - if (bounds[bIdx].Upper is null) - break; - numSizes++; - } - // Count contiguous lower bounds from the start (stop at first null) - int numLoBounds = 0; - for (int bIdx = 0; bIdx < bounds.Length; bIdx++) - { - if (bounds[bIdx].Lower is null) - break; - numLoBounds++; - } - suffix.WriteCompressedInteger(numSizes); - for (int bIdx = 0; bIdx < numSizes; bIdx++) - { - suffix.WriteCompressedInteger(bounds[bIdx].Upper.GetValueOrDefault()); - } - suffix.WriteCompressedInteger(numLoBounds); - for (int bIdx = 0; bIdx < numLoBounds; bIdx++) - { - suffix.WriteCompressedSignedInteger(bounds[bIdx].Lower.GetValueOrDefault()); - } - break; - case CILParser.GenericArgumentsModifierContext genericArgs: - VisitTypeArgs(genericArgs.typeArgs()).Value.WriteContentTo(suffix); - break; - } - } - - // Work around https://github.com/dotnet/runtime/issues/127243 - // by writing to a separate blob. - BlobBuilder fullBlob = new(elementType.Count + prefix.Count + suffix.Count); - prefix.WriteContentTo(fullBlob); - elementType.WriteContentTo(fullBlob); - suffix.WriteContentTo(fullBlob); - return new(fullBlob); - } - - GrammarResult ICILVisitor.VisitTypeArgs(CILParser.TypeArgsContext context) => VisitTypeArgs(context); - - public GrammarResult.FormattedBlob VisitTypeArgs(CILParser.TypeArgsContext context) - { - BlobBuilder blob = new(4); - var types = context.type(); - blob.WriteCompressedInteger(types.Length); - foreach (var type in types) - { - blob.LinkSuffix(VisitType(type).Value); - } - return new(blob); - } - - public GrammarResult VisitTypedefDecl(CILParser.TypedefDeclContext context) - { - string alias = VisitDottedName(context.dottedName()).Value; - - if (context.type() is CILParser.TypeContext type) - { - // .typedef type as alias - // This creates an alias for a complete type signature (blob) - var typeBlob = VisitType(type).Value; - // Create a copy of the blob to avoid issues with linked BlobBuilders - var copy = new BlobBuilder(typeBlob.Count); - typeBlob.WriteContentTo(copy); - _typedefs[alias] = new TypedefEntry.TypeBlob(copy); - } - else if (context.className() is CILParser.ClassNameContext className) - { - // .typedef className as alias - var typeEntity = VisitClassName(className).Value; - _typedefs[alias] = new TypedefEntry.Type(typeEntity); - } - else if (context.memberRef() is CILParser.MemberRefContext memberRef) - { - // .typedef memberRef as alias - var member = VisitMemberRef(memberRef).Value; - _typedefs[alias] = new TypedefEntry.Member(member); - } - else if (context.customDescr() is CILParser.CustomDescrContext customDescr) - { - // .typedef customDescr as alias - var attr = VisitCustomDescr(customDescr).Value; - if (attr is not null) - { - _typedefs[alias] = new TypedefEntry.CustomAttribute(attr.Constructor, attr.Value); - } - } - else if (context.customDescrWithOwner() is CILParser.CustomDescrWithOwnerContext customDescrWithOwner) - { - // .typedef customDescrWithOwner as alias - var attr = VisitCustomDescrWithOwner(customDescrWithOwner).Value; - if (attr is not null) - { - _typedefs[alias] = new TypedefEntry.CustomAttribute(attr.Constructor, attr.Value); - } - } - - return GrammarResult.SentinelValue.Result; - } - - /// - /// Tries to resolve a typedef alias to a type entity. - /// - private EntityRegistry.TypeEntity? TryResolveTypedefAsType(string alias) - { - if (_typedefs.TryGetValue(alias, out var entry) && entry is TypedefEntry.Type typeEntry) - { - return typeEntry.Entity; - } - return null; - } - - /// - /// Tries to resolve a typedef alias to a type blob (complete type signature). - /// - private BlobBuilder? TryResolveTypedefAsTypeBlob(string alias) - { - if (_typedefs.TryGetValue(alias, out var entry)) - { - if (entry is TypedefEntry.TypeBlob blobEntry) - { - return blobEntry.Blob; - } - if (entry is TypedefEntry.Type typeEntry) - { - // Encode the type entity as a CLASS reference for the blob - var blob = new BlobBuilder(5); - blob.WriteByte((byte)SignatureTypeKind.Class); - blob.WriteTypeEntity(typeEntry.Entity); - return blob; - } - } - return null; - } - - /// - /// Tries to resolve a typedef alias to a member reference. - /// - private EntityRegistry.EntityBase? TryResolveTypedefAsMember(string alias) - { - if (_typedefs.TryGetValue(alias, out var entry) && entry is TypedefEntry.Member memberEntry) - { - return memberEntry.Entity; - } - return null; - } - - /// - /// Tries to resolve a typedef alias to a custom attribute. - /// - private (EntityRegistry.EntityBase Constructor, BlobBuilder Value)? TryResolveTypedefAsCustomAttribute(string alias) - { - if (_typedefs.TryGetValue(alias, out var entry) && entry is TypedefEntry.CustomAttribute attrEntry) - { - return (attrEntry.Constructor, attrEntry.Value); - } - return null; - } - - public GrammarResult VisitTypelist(CILParser.TypelistContext context) - { - foreach (var name in context.className()) - { - // We don't do anything with the class names here. - // We just go through the name resolution process to ensure that the names are valid - // and to provide TypeReference table rows. - _ = VisitClassName(name); - } - return GrammarResult.SentinelValue.Result; - } - - GrammarResult ICILVisitor.VisitTypeList(CILParser.TypeListContext context) => VisitTypeList(context); - public GrammarResult.Sequence VisitTypeList(CILParser.TypeListContext context) - { - CILParser.TypeSpecContext[] bounds = context.typeSpec(); - ImmutableArray.Builder builder = ImmutableArray.CreateBuilder(bounds.Length); - foreach (var typeSpec in bounds) - { - builder.Add(VisitTypeSpec(typeSpec).Value); - } - return new(builder.MoveToImmutable()); - } - - GrammarResult ICILVisitor.VisitTypeSpec(CILParser.TypeSpecContext context) => VisitTypeSpec(context); - public GrammarResult.Literal VisitTypeSpec(CILParser.TypeSpecContext context) - { - if (context.className() is CILParser.ClassNameContext className) - { - return new(VisitClassName(className).Value); - } - else if (context.dottedName() is CILParser.DottedNameContext dottedName) - { - string nameToResolve = VisitDottedName(dottedName).Value; - if (context.MODULE() is not null) - { - EntityRegistry.ModuleReferenceEntity? module = _entityRegistry.FindModuleReference(nameToResolve); - if (module is null) - { - // report error - return new(new EntityRegistry.FakeTypeEntity(MetadataTokens.ModuleReferenceHandle(0))); - } - return new(new EntityRegistry.FakeTypeEntity(module.Handle)); - } - else - { - return new(new EntityRegistry.FakeTypeEntity( - _entityRegistry.GetOrCreateAssemblyReference(nameToResolve, newRef => - { - // Report warning on implicit assembly reference creation. - }).Handle)); - } - } - else - { - Debug.Assert(context.type() != null); - return new(_entityRegistry.GetOrCreateTypeSpec(VisitType(context.type()).Value)); - } - } - - - GrammarResult ICILVisitor.VisitVariantType(CILParser.VariantTypeContext context) => VisitVariantType(context); - public GrammarResult.Literal VisitVariantType(CILParser.VariantTypeContext context) - { - if (context.variantTypeElement() is not CILParser.VariantTypeElementContext element) - { - return new(VarEnum.VT_EMPTY); - } - - VarEnum variant = VisitVariantTypeElement(element).Value; - // The 0th child is the variant element type. - for (int i = 1; i < context.ChildCount; i++) - { - ITerminalNode childToken = (ITerminalNode)context.children[i]; - if (childToken.Symbol.Type == CILParser.ARRAY_TYPE_NO_BOUNDS) - { - variant |= VarEnum.VT_ARRAY; - } - else if (childToken.Symbol.Type == CILParser.VECTOR) - { - variant |= VarEnum.VT_VECTOR; - } - else - { - Debug.Assert(childToken.Symbol.Type == CILParser.REF); - variant |= VarEnum.VT_BYREF; - } - } - return new(variant); - } - - GrammarResult ICILVisitor.VisitVariantTypeElement(CILParser.VariantTypeElementContext context) => VisitVariantTypeElement(context); - public GrammarResult.Literal VisitVariantTypeElement(CILParser.VariantTypeElementContext context) - { - return new(context.GetChild(0).Symbol.Type switch - { - CILParser.VARIANT => VarEnum.VT_VARIANT, - CILParser.CURRENCY => VarEnum.VT_CY, - CILParser.VOID => VarEnum.VT_VOID, - CILParser.BOOL => VarEnum.VT_BOOL, - CILParser.INT8 => VarEnum.VT_I1, - CILParser.INT16 => VarEnum.VT_I2, - CILParser.INT32_ => VarEnum.VT_I4, - CILParser.INT64_ => VarEnum.VT_I8, - CILParser.FLOAT32 => VarEnum.VT_R4, - CILParser.FLOAT64_ => VarEnum.VT_R8, - CILParser.UINT8 => VarEnum.VT_UI1, - CILParser.UINT16 => VarEnum.VT_UI2, - CILParser.UINT32 => VarEnum.VT_UI4, - CILParser.UINT64 => VarEnum.VT_UI8, - CILParser.PTR => VarEnum.VT_PTR, - CILParser.DECIMAL => VarEnum.VT_DECIMAL, - CILParser.DATE => VarEnum.VT_DATE, - CILParser.BSTR => VarEnum.VT_BSTR, - CILParser.LPSTR => VarEnum.VT_LPSTR, - CILParser.LPWSTR => VarEnum.VT_LPWSTR, - CILParser.IUNKNOWN => VarEnum.VT_UNKNOWN, - CILParser.IDISPATCH => VarEnum.VT_DISPATCH, - CILParser.SAFEARRAY => VarEnum.VT_SAFEARRAY, - CILParser.INT => VarEnum.VT_INT, - CILParser.UINT => VarEnum.VT_UINT, - CILParser.ERROR => VarEnum.VT_ERROR, - CILParser.HRESULT => VarEnum.VT_HRESULT, - CILParser.CARRAY => VarEnum.VT_CARRAY, - CILParser.USERDEFINED => VarEnum.VT_USERDEFINED, - CILParser.RECORD => VarEnum.VT_RECORD, - CILParser.FILETIME => VarEnum.VT_FILETIME, - CILParser.BLOB => VarEnum.VT_BLOB, - CILParser.STREAM => VarEnum.VT_STREAM, - CILParser.STORAGE => VarEnum.VT_STORAGE, - CILParser.STREAMED_OBJECT => VarEnum.VT_STREAMED_OBJECT, - CILParser.STORED_OBJECT => VarEnum.VT_STORED_OBJECT, - CILParser.BLOB_OBJECT => VarEnum.VT_BLOB_OBJECT, - CILParser.CF => VarEnum.VT_CF, - CILParser.CLSID => VarEnum.VT_CLSID, - _ => throw new UnreachableException() - }); - } - - public GrammarResult VisitVtableDecl(CILParser.VtableDeclContext context) - { - // Raw .vtable directive with bytes - not commonly used - // For now, we don't support this legacy syntax - throw new NotImplementedException("raw vtable fixups blob (.vtable) not supported - use .vtfixup instead"); - } - - GrammarResult ICILVisitor.VisitVtfixupAttr(CILParser.VtfixupAttrContext context) => VisitVtfixupAttr(context); - public GrammarResult.Literal VisitVtfixupAttr(CILParser.VtfixupAttrContext context) - { - // vtfixupAttr: | vtfixupAttr INT32_ | vtfixupAttr INT64_ | vtfixupAttr 'fromunmanaged' | vtfixupAttr 'callmostderived' | vtfixupAttr 'retainappdomain' - ushort flags = 0; - foreach (var child in context.children ?? []) - { - string text = child.GetText(); - flags |= text switch - { - "int32" => VTableFixupSupport.COR_VTABLE_32BIT, - "int64" => VTableFixupSupport.COR_VTABLE_64BIT, - "fromunmanaged" => VTableFixupSupport.COR_VTABLE_FROM_UNMANAGED, - "callmostderived" => VTableFixupSupport.COR_VTABLE_CALL_MOST_DERIVED, - "retainappdomain" => VTableFixupSupport.COR_VTABLE_FROM_UNMANAGED_RETAIN_APPDOMAIN, - _ => 0 - }; - } - - // Default to 32-bit if neither 32 nor 64 is specified - if ((flags & (VTableFixupSupport.COR_VTABLE_32BIT | VTableFixupSupport.COR_VTABLE_64BIT)) == 0) - { - flags |= VTableFixupSupport.COR_VTABLE_32BIT; - } - - return new(flags); - } - - GrammarResult ICILVisitor.VisitVtfixupDecl(CILParser.VtfixupDeclContext context) => VisitVtfixupDecl(context); - public GrammarResult VisitVtfixupDecl(CILParser.VtfixupDeclContext context) - { - // vtfixupDecl: '.vtfixup' '[' int32 ']' vtfixupAttr 'at' id; - int slotCount = VisitInt32(context.int32()).Value; - ushort flags = VisitVtfixupAttr(context.vtfixupAttr()).Value; - string dataLabel = VisitId(context.id()).Value; - - _vtableFixups.Add(new VTableFixupSupport.VTableFixupEntry(slotCount, flags, dataLabel)); - - return GrammarResult.SentinelValue.Result; - } - - /// - /// Computes the total metadata size from MetadataSizes. - /// This replicates the internal MetadataSizes.MetadataSize calculation. - /// - private static int ComputeMetadataSize(MetadataSizes sizes) - { - // Metadata header size (fixed structure): - // - signature (4) - // - major/minor version (4) - // - reserved (4) - // - version string length (4) - // - version string padded to 4 bytes ("v4.0.30319" = 12 bytes padded) - // - storage header (4) - // - 5 stream headers (#~, #Strings, #US, #GUID, #Blob) = 76 bytes - // Total header: ~108 bytes - const int metadataHeaderSize = 108; - - // Stream storage: heaps (#Strings, #US, #GUID, #Blob) - we can get aligned sizes - int heapStorageSize = 0; - heapStorageSize += sizes.GetAlignedHeapSize(HeapIndex.String); - heapStorageSize += sizes.GetAlignedHeapSize(HeapIndex.UserString); - heapStorageSize += sizes.GetAlignedHeapSize(HeapIndex.Guid); - heapStorageSize += sizes.GetAlignedHeapSize(HeapIndex.Blob); - - // Table stream (#~): header + table data - // Header: Reserved(4) + Version(2) + HeapSizes(1) + RowIdBitWidth(1) + ValidMask(8) + SortedMask(8) - // + 4 bytes per present table for row counts - int tableStreamSize = 24; // base header - var rowCounts = sizes.RowCounts; - - // Count present tables and add 4 bytes each for row count - for (int i = 0; i < rowCounts.Length; i++) - { - if (rowCounts[i] > 0) - { - tableStreamSize += 4; - } - } - - // Add table data size with estimated row sizes - // Row sizes depend on index sizes (2 or 4 bytes) which we don't have access to - // For small assemblies, all indexes are 2 bytes - tableStreamSize += rowCounts[(int)TableIndex.Module] * 10; // 2+2+2+2+2 - tableStreamSize += rowCounts[(int)TableIndex.TypeRef] * 6; // 2+2+2 - tableStreamSize += rowCounts[(int)TableIndex.TypeDef] * 14; // 4+2+2+2+2+2 - tableStreamSize += rowCounts[(int)TableIndex.Field] * 6; // 2+2+2 - tableStreamSize += rowCounts[(int)TableIndex.MethodDef] * 14; // 4+2+2+2+2+2 - tableStreamSize += rowCounts[(int)TableIndex.Param] * 6; // 2+2+2 - tableStreamSize += rowCounts[(int)TableIndex.InterfaceImpl] * 4; // 2+2 - tableStreamSize += rowCounts[(int)TableIndex.MemberRef] * 6; // 2+2+2 - tableStreamSize += rowCounts[(int)TableIndex.Constant] * 6; // 2+2+2 - tableStreamSize += rowCounts[(int)TableIndex.CustomAttribute] * 6; // 2+2+2 - tableStreamSize += rowCounts[(int)TableIndex.FieldMarshal] * 4; // 2+2 - tableStreamSize += rowCounts[(int)TableIndex.DeclSecurity] * 6; // 2+2+2 - tableStreamSize += rowCounts[(int)TableIndex.ClassLayout] * 8; // 2+4+2 - tableStreamSize += rowCounts[(int)TableIndex.FieldLayout] * 6; // 4+2 - tableStreamSize += rowCounts[(int)TableIndex.StandAloneSig] * 2; // 2 - tableStreamSize += rowCounts[(int)TableIndex.EventMap] * 4; // 2+2 - tableStreamSize += rowCounts[(int)TableIndex.Event] * 6; // 2+2+2 - tableStreamSize += rowCounts[(int)TableIndex.PropertyMap] * 4; // 2+2 - tableStreamSize += rowCounts[(int)TableIndex.Property] * 6; // 2+2+2 - tableStreamSize += rowCounts[(int)TableIndex.MethodSemantics] * 6; // 2+2+2 - tableStreamSize += rowCounts[(int)TableIndex.MethodImpl] * 6; // 2+2+2 - tableStreamSize += rowCounts[(int)TableIndex.ModuleRef] * 2; // 2 - tableStreamSize += rowCounts[(int)TableIndex.TypeSpec] * 2; // 2 - tableStreamSize += rowCounts[(int)TableIndex.ImplMap] * 8; // 2+2+2+2 - tableStreamSize += rowCounts[(int)TableIndex.FieldRva] * 6; // 4+2 - tableStreamSize += rowCounts[(int)TableIndex.Assembly] * 22; // 16+2+2+2 - tableStreamSize += rowCounts[(int)TableIndex.AssemblyRef] * 20; // 12+2+2+2+2 - tableStreamSize += rowCounts[(int)TableIndex.File] * 8; // 4+2+2 - tableStreamSize += rowCounts[(int)TableIndex.ExportedType] * 14; // 8+2+2+2 - tableStreamSize += rowCounts[(int)TableIndex.ManifestResource] * 12; // 8+2+2 - tableStreamSize += rowCounts[(int)TableIndex.NestedClass] * 4; // 2+2 - tableStreamSize += rowCounts[(int)TableIndex.GenericParam] * 8; // 4+2+2 - tableStreamSize += rowCounts[(int)TableIndex.MethodSpec] * 4; // 2+2 - tableStreamSize += rowCounts[(int)TableIndex.GenericParamConstraint] * 4; // 2+2 - - // Align table stream to 4 bytes (includes +1 for terminating 0 byte) - tableStreamSize = ((tableStreamSize + 1) + 3) & ~3; - - return metadataHeaderSize + heapStorageSize + tableStreamSize; - } - - GrammarResult ICILVisitor.VisitOptionalModifier(CILParser.OptionalModifierContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - GrammarResult ICILVisitor.VisitSZArrayModifier(CILParser.SZArrayModifierContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - GrammarResult ICILVisitor.VisitRequiredModifier(CILParser.RequiredModifierContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - GrammarResult ICILVisitor.VisitPtrModifier(CILParser.PtrModifierContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - GrammarResult ICILVisitor.VisitPinnedModifier(CILParser.PinnedModifierContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - GrammarResult ICILVisitor.VisitGenericArgumentsModifier(CILParser.GenericArgumentsModifierContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - GrammarResult ICILVisitor.VisitByRefModifier(CILParser.ByRefModifierContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - GrammarResult ICILVisitor.VisitArrayModifier(CILParser.ArrayModifierContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - public GrammarResult VisitNativeTypeArrayPointerInfo(CILParser.NativeTypeArrayPointerInfoContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - public GrammarResult VisitPointerArrayTypeSize(CILParser.PointerArrayTypeSizeContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - public GrammarResult VisitPointerArrayTypeParamIndex(CILParser.PointerArrayTypeParamIndexContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - public GrammarResult VisitPointerNativeType(CILParser.PointerNativeTypeContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - public GrammarResult VisitPointerArrayTypeSizeParamIndex(CILParser.PointerArrayTypeSizeParamIndexContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - public GrammarResult VisitPointerArrayTypeNoSizeData(CILParser.PointerArrayTypeNoSizeDataContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - } -} diff --git a/src/tools/ilasm/src/ILAssembler/PreprocessedTokenSource.cs b/src/tools/ilasm/src/ILAssembler/PreprocessedTokenSource.cs index 9e4ac307fb2d37..096d9a05d9e2db 100644 --- a/src/tools/ilasm/src/ILAssembler/PreprocessedTokenSource.cs +++ b/src/tools/ilasm/src/ILAssembler/PreprocessedTokenSource.cs @@ -99,12 +99,18 @@ private IToken NextTokenWithoutNestedEof(bool errorOnEof = false) { ReportPreprocessorSyntaxError(nextToken); } - _includeSourceStack.Pop(); - if (_includeSourceStack.Count == 0) + + if (_includeSourceStack.Count == 1) { - // If we hit EOF of our entry file, return the EOF token. + // If we hit EOF of our entry file, return the EOF token. The root source is + // deliberately left on the stack so that the accessors below (Line, Column, + // InputStream, SourceName and TokenFactory) keep working after EOF. The parser's + // error recovery queries them while synthesizing missing tokens for a truncated + // document, which would otherwise fault on an empty stack. return nextToken; } + + _includeSourceStack.Pop(); nextToken = CurrentTokenSource.NextToken(); } return nextToken; diff --git a/src/tools/ilasm/src/ILAssembler/StringCharStream.cs b/src/tools/ilasm/src/ILAssembler/StringCharStream.cs new file mode 100644 index 00000000000000..c45c43db4010df --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/StringCharStream.cs @@ -0,0 +1,68 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using Antlr4.Runtime; +using Antlr4.Runtime.Misc; + +namespace ILAssembler; + +internal sealed class StringCharStream : ICharStream +{ + private readonly string _text; + private int _position; + + internal StringCharStream(string text, string? sourceName = null) + { + _text = text; + SourceName = sourceName ?? string.Empty; + } + + public int Index => _position; + + public int Size => _text.Length; + + public string SourceName { get; } + + public void Consume() + { + if (_position >= _text.Length) + { + throw new InvalidOperationException("Cannot consume past the end of the character stream."); + } + + _position++; + } + + public int LA(int i) + { + if (i == 0) + { + return 0; + } + + int offset = i < 0 ? i : i - 1; + int position = _position + offset; + return (uint)position >= (uint)_text.Length ? TokenConstants.EOF : _text[position]; + } + + public int Mark() => -1; + + public void Release(int marker) + { + } + + public void Seek(int index) + { + ArgumentOutOfRangeException.ThrowIfNegative(index); + ArgumentOutOfRangeException.ThrowIfGreaterThan(index, _text.Length); + _position = index; + } + + public string GetText(Interval interval) + { + int start = Math.Max(0, interval.a); + int end = Math.Min(_text.Length - 1, interval.b); + return start > end ? string.Empty : _text.Substring(start, end - start + 1); + } +} diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 index c36609d01cf657..b907a5b2f0510e 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 @@ -418,9 +418,17 @@ WS: [ \t\r\n] -> skip; SINGLE_LINE_COMMENT: '//' ~[\r\n]* -> skip; COMMENT: '/*' .*? '*/' -> skip; -decls: decl*; - -decl: +decls +@init {BeginStreaming();} +: + decl* +; +finally {EndParseTreeMode();} + +decl +@init {BeginSubtree();} +@after {Actions.OnDeclaration(_localctx);} +: classHead '{' classDecls '}' | nameSpaceHead '{' decls '}' | methodHead '{' methodDecls '}' @@ -447,6 +455,7 @@ decl: | compControl | typelist | mscorlib; +finally {EndParseTreeMode(); Actions.EndDeclaration(_localctx);} subsystem: '.subsystem' int32; @@ -564,10 +573,20 @@ vtfixupAttr: vtableDecl: '.vtable' '=' '(' bytes ')' /* deprecated */; /* Namespace and class declaration */ -nameSpaceHead: '.namespace' dottedName; - -classHead: +nameSpaceHead +@init {BeginSubtree();} +@after {Actions.BeginNamespace(_localctx);} +: + '.namespace' dottedName +; +finally {EndParseTreeMode();} + +classHead +@init {BeginSubtree();} +@after {Actions.BeginType(_localctx);} +: '.class' classAttr* dottedName typarsClause extendsClause implClause; +finally {EndParseTreeMode();} classAttr: @@ -603,7 +622,12 @@ extendsClause: /* EMPTY */ | 'extends' typeSpec; implClause: /* EMPTY */ | 'implements' implList; -classDecls: classDecl*; +classDecls +@init {BeginStreaming();} +: + classDecl* +; +finally {EndParseTreeMode();} implList: (typeSpec ',')* typeSpec; @@ -1030,7 +1054,10 @@ genArity: /* EMPTY */ | genArityNotEmpty; genArityNotEmpty: '<' '[' int32 ']' '>'; /* Class body declarations */ -classDecl: +classDecl +@init {BeginSubtree();} +@after {Actions.OnClassDeclaration(_localctx);} +: methodHead '{' methodDecls '}' | classHead '{' classDecls '}' | eventHead '{' eventDecls '}' @@ -1053,6 +1080,7 @@ classDecl: | PARAM CONSTRAINT '[' int32 ']' ',' typeSpec customAttrDecl* | PARAM CONSTRAINT dottedName ',' typeSpec customAttrDecl* | '.interfaceimpl' TYPE typeSpec customDescr; +finally {EndParseTreeMode(); Actions.EndClassDeclaration(_localctx);} /* Field declaration */ fieldDecl: @@ -1135,9 +1163,13 @@ paramAttrElement: | '[' opt = 'opt' ']' | '[' int32 ']'; -methodHead: +methodHead +@init {BeginSubtree();} +@after {Actions.BeginMethod(_localctx);} +: '.method' (methAttr | pinvImpl)* callConv paramAttr type marshalClause methodName typarsClause sigArgs implAttr*; +finally {EndParseTreeMode();} methAttr: 'static' | 'public' @@ -1208,9 +1240,17 @@ EXPORT: '.export'; OVERRIDE: '.override'; VTENTRY: '.vtentry'; -methodDecls: methodDecl*; - -methodDecl: +methodDecls +@init {BeginStreaming();} +: + methodDecl* +; +finally {EndParseTreeMode();} + +methodDecl +@init {BeginSubtree();} +@after {Actions.OnMethodDeclaration(_localctx);} +: instr // MOVED TO TOP - instructions must be matched first! | EMITBYTE int32 | sehBlock @@ -1237,6 +1277,7 @@ methodDecl: | PARAM CONSTRAINT '[' int32 ']' ',' typeSpec customAttrDecl* | PARAM CONSTRAINT dottedName ',' typeSpec customAttrDecl* | PARAM '[' int32 ']' initOpt customAttrDecl*; +finally {EndParseTreeMode();} labelDecl: id ':'; @@ -1244,10 +1285,19 @@ customDescrInMethodBody: customDescr | customDescrWithOwner; -scopeBlock: '{' methodDecls '}'; +scopeBlock +@init {Actions.BeginScope(_localctx);} +: + '{' methodDecls '}' +; +finally {Actions.EndScope(_localctx);} /* Structured exception handling directives */ -sehBlock: tryBlock sehClauses; +sehBlock +@after {Actions.EndExceptionBlock(_localctx);} +: + tryBlock sehClauses +; sehClauses: sehClause+; @@ -1267,7 +1317,11 @@ filterClause: | 'filter' id | 'filter' int32; -catchClause: 'catch' typeSpec; +catchClause +@after {Actions.OnCatchClause(_localctx);} +: + 'catch' typeSpec +; finallyClause: 'finally'; @@ -1327,9 +1381,22 @@ fieldSerInit: | BOOL '(' truefalse ')' | 'bytearray' '(' bytes ')'; -bytes: hexbyte*; - -hexbyte: INT32 | ID | HEXBYTE; +bytes +returns [System.Collections.Immutable.ImmutableArray Value] +@init {BeginStreaming(); Actions.BeginBytes();} +: + (b = hexbyte {Actions.AddByte($b.Value);})* +; +finally {_localctx.Value = Actions.EndBytes(); EndParseTreeMode();} + +hexbyte +returns [byte Value] +@after {_localctx.Value = GrammarActions.ParseHexbyte(_localctx.Start);} +: + INT32 + | ID + | HEXBYTE +; /* Field/parameter initialization */ fieldInit: fieldSerInit | compQstring | NULLREF; diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.interp b/src/tools/ilasm/src/ILAssembler/gen/CIL.interp index efb796a93425a6..f06280432cb855 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.interp +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.interp @@ -803,4 +803,4 @@ manifestResDecl atn: -[4, 1, 305, 2908, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 377, 8, 1, 10, 1, 12, 1, 380, 9, 1, 1, 1, 1, 1, 3, 1, 384, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 5, 3, 390, 8, 3, 10, 3, 12, 3, 393, 9, 3, 1, 3, 1, 3, 1, 4, 5, 4, 398, 8, 4, 10, 4, 12, 4, 401, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 453, 8, 5, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 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, 494, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 5, 15, 501, 8, 15, 10, 15, 12, 15, 504, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 527, 8, 18, 1, 19, 1, 19, 3, 19, 531, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 549, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 576, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 599, 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, 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, 635, 8, 23, 1, 24, 1, 24, 1, 25, 1, 25, 3, 25, 641, 8, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 5, 27, 648, 8, 27, 10, 27, 12, 27, 651, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 660, 8, 28, 10, 28, 12, 28, 663, 9, 28, 1, 29, 1, 29, 1, 30, 1, 30, 3, 30, 669, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 680, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 688, 8, 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, 34, 1, 34, 1, 34, 1, 34, 5, 34, 709, 8, 34, 10, 34, 12, 34, 712, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 5, 37, 725, 8, 37, 10, 37, 12, 37, 728, 9, 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, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 772, 8, 38, 1, 39, 1, 39, 1, 39, 3, 39, 777, 8, 39, 1, 40, 1, 40, 1, 40, 3, 40, 782, 8, 40, 1, 41, 5, 41, 785, 8, 41, 10, 41, 12, 41, 788, 9, 41, 1, 42, 1, 42, 1, 42, 5, 42, 793, 8, 42, 10, 42, 12, 42, 796, 9, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 905, 8, 44, 1, 45, 1, 45, 5, 45, 909, 8, 45, 10, 45, 12, 45, 912, 9, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 925, 8, 45, 10, 45, 12, 45, 928, 9, 45, 1, 45, 1, 45, 1, 45, 3, 45, 933, 8, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 939, 8, 47, 1, 48, 1, 48, 1, 49, 5, 49, 944, 8, 49, 10, 49, 12, 49, 947, 9, 49, 1, 50, 1, 50, 1, 51, 1, 51, 1, 52, 1, 52, 1, 53, 1, 53, 1, 54, 1, 54, 1, 55, 1, 55, 1, 56, 1, 56, 1, 57, 1, 57, 1, 58, 1, 58, 1, 59, 1, 59, 1, 60, 1, 60, 1, 61, 1, 61, 1, 62, 1, 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, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 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, 1057, 8, 63, 1, 64, 1, 64, 1, 64, 3, 64, 1062, 8, 64, 1, 64, 1, 64, 5, 64, 1066, 8, 64, 10, 64, 12, 64, 1069, 9, 64, 1, 64, 1, 64, 3, 64, 1073, 8, 64, 3, 64, 1075, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 5, 65, 1081, 8, 65, 10, 65, 12, 65, 1084, 9, 65, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 66, 5, 66, 1093, 8, 66, 10, 66, 12, 66, 1096, 9, 66, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 5, 67, 1105, 8, 67, 10, 67, 12, 67, 1108, 9, 67, 1, 67, 1, 67, 1, 67, 1, 67, 3, 67, 1114, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1121, 8, 68, 3, 68, 1123, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 3, 69, 1150, 8, 69, 1, 70, 1, 70, 1, 70, 5, 70, 1155, 8, 70, 10, 70, 12, 70, 1158, 9, 70, 1, 70, 1, 70, 1, 71, 5, 71, 1163, 8, 71, 10, 71, 12, 71, 1166, 9, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1173, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1186, 8, 73, 1, 74, 1, 74, 1, 74, 5, 74, 1191, 8, 74, 10, 74, 12, 74, 1194, 9, 74, 3, 74, 1196, 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, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1215, 8, 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, 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, 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, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 3, 76, 1309, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 1318, 8, 77, 1, 78, 1, 78, 1, 78, 5, 78, 1323, 8, 78, 10, 78, 12, 78, 1326, 9, 78, 3, 78, 1328, 8, 78, 1, 79, 1, 79, 1, 80, 1, 80, 5, 80, 1334, 8, 80, 10, 80, 12, 80, 1337, 9, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 3, 81, 1357, 8, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1389, 8, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 3, 83, 1412, 8, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1424, 8, 84, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1433, 8, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 1458, 8, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 1482, 8, 87, 1, 88, 1, 88, 1, 88, 1, 88, 5, 88, 1488, 8, 88, 10, 88, 12, 88, 1491, 9, 88, 1, 88, 3, 88, 1494, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1509, 8, 89, 1, 90, 1, 90, 1, 90, 5, 90, 1514, 8, 90, 10, 90, 12, 90, 1517, 9, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 3, 93, 1561, 8, 93, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 3, 95, 1571, 8, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 3, 95, 1587, 8, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 3, 95, 1599, 8, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 3, 96, 1611, 8, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 3, 97, 1625, 8, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 1637, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 3, 100, 1648, 8, 100, 1, 101, 1, 101, 1, 101, 5, 101, 1653, 8, 101, 10, 101, 12, 101, 1656, 9, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 1665, 8, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 3, 103, 1678, 8, 103, 1, 104, 5, 104, 1681, 8, 104, 10, 104, 12, 104, 1684, 9, 104, 1, 105, 1, 105, 3, 105, 1688, 8, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 5, 106, 1695, 8, 106, 10, 106, 12, 106, 1698, 9, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 108, 1, 108, 3, 108, 1708, 8, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 5, 110, 1789, 8, 110, 10, 110, 12, 110, 1792, 9, 110, 1, 110, 1, 110, 1, 110, 1, 110, 5, 110, 1798, 8, 110, 10, 110, 12, 110, 1801, 9, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 5, 110, 1811, 8, 110, 10, 110, 12, 110, 1814, 9, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 5, 110, 1822, 8, 110, 10, 110, 12, 110, 1825, 9, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 1832, 8, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 5, 111, 1842, 8, 111, 10, 111, 12, 111, 1845, 9, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 1871, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 1878, 8, 113, 1, 114, 1, 114, 1, 114, 3, 114, 1883, 8, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 3, 115, 1890, 8, 115, 1, 116, 1, 116, 5, 116, 1894, 8, 116, 10, 116, 12, 116, 1897, 9, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 5, 116, 1904, 8, 116, 10, 116, 12, 116, 1907, 9, 116, 1, 116, 3, 116, 1910, 8, 116, 1, 117, 1, 117, 1, 118, 5, 118, 1915, 8, 118, 10, 118, 12, 118, 1918, 9, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 1932, 8, 119, 1, 120, 1, 120, 5, 120, 1936, 8, 120, 10, 120, 12, 120, 1939, 9, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 122, 5, 122, 1950, 8, 122, 10, 122, 12, 122, 1953, 9, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 3, 123, 1965, 8, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 1973, 8, 124, 1, 125, 1, 125, 1, 125, 4, 125, 1978, 8, 125, 11, 125, 12, 125, 1979, 1, 125, 1, 125, 3, 125, 1984, 8, 125, 1, 126, 5, 126, 1987, 8, 126, 10, 126, 12, 126, 1990, 9, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 3, 127, 2005, 8, 127, 1, 128, 1, 128, 1, 128, 5, 128, 2010, 8, 128, 10, 128, 12, 128, 2013, 9, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 5, 128, 2023, 8, 128, 10, 128, 12, 128, 2026, 9, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 3, 129, 2051, 8, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 3, 130, 2058, 8, 130, 3, 130, 2060, 8, 130, 1, 130, 5, 130, 2063, 8, 130, 10, 130, 12, 130, 2066, 9, 130, 1, 130, 1, 130, 1, 130, 3, 130, 2071, 8, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 2100, 8, 131, 1, 132, 1, 132, 1, 132, 3, 132, 2105, 8, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 2128, 8, 133, 1, 134, 5, 134, 2131, 8, 134, 10, 134, 12, 134, 2134, 9, 134, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 5, 135, 2195, 8, 135, 10, 135, 12, 135, 2198, 9, 135, 1, 135, 1, 135, 1, 135, 1, 135, 5, 135, 2204, 8, 135, 10, 135, 12, 135, 2207, 9, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 5, 135, 2217, 8, 135, 10, 135, 12, 135, 2220, 9, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 5, 135, 2228, 8, 135, 10, 135, 12, 135, 2231, 9, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 5, 135, 2239, 8, 135, 10, 135, 12, 135, 2242, 9, 135, 3, 135, 2244, 8, 135, 1, 136, 1, 136, 1, 136, 1, 137, 1, 137, 3, 137, 2251, 8, 137, 1, 138, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 140, 4, 140, 2261, 8, 140, 11, 140, 12, 140, 2262, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 2277, 8, 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, 3, 142, 2291, 8, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 2299, 8, 143, 1, 144, 1, 144, 1, 144, 1, 145, 1, 145, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 2319, 8, 147, 1, 148, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 2331, 8, 149, 1, 150, 1, 150, 1, 150, 3, 150, 2336, 8, 150, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 4, 151, 2343, 8, 151, 11, 151, 12, 151, 2344, 3, 151, 2347, 8, 151, 1, 152, 1, 152, 1, 152, 5, 152, 2352, 8, 152, 10, 152, 12, 152, 2355, 9, 152, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 3, 153, 2364, 8, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 2432, 8, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 3, 155, 2509, 8, 155, 1, 156, 5, 156, 2512, 8, 156, 10, 156, 12, 156, 2515, 9, 156, 1, 157, 1, 157, 1, 158, 1, 158, 1, 158, 3, 158, 2522, 8, 158, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 3, 159, 2672, 8, 159, 1, 160, 1, 160, 5, 160, 2676, 8, 160, 10, 160, 12, 160, 2679, 9, 160, 1, 161, 1, 161, 5, 161, 2683, 8, 161, 10, 161, 12, 161, 2686, 9, 161, 1, 162, 5, 162, 2689, 8, 162, 10, 162, 12, 162, 2692, 9, 162, 1, 163, 5, 163, 2695, 8, 163, 10, 163, 12, 163, 2698, 9, 163, 1, 164, 5, 164, 2701, 8, 164, 10, 164, 12, 164, 2704, 9, 164, 1, 165, 5, 165, 2707, 8, 165, 10, 165, 12, 165, 2710, 9, 165, 1, 166, 5, 166, 2713, 8, 166, 10, 166, 12, 166, 2716, 9, 166, 1, 167, 5, 167, 2719, 8, 167, 10, 167, 12, 167, 2722, 9, 167, 1, 168, 5, 168, 2725, 8, 168, 10, 168, 12, 168, 2728, 9, 168, 1, 169, 1, 169, 1, 169, 1, 169, 3, 169, 2734, 8, 169, 1, 170, 5, 170, 2737, 8, 170, 10, 170, 12, 170, 2740, 9, 170, 1, 171, 1, 171, 1, 171, 3, 171, 2745, 8, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, 172, 2772, 8, 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, 3, 173, 2786, 8, 173, 1, 174, 5, 174, 2789, 8, 174, 10, 174, 12, 174, 2792, 9, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 3, 175, 2808, 8, 175, 1, 176, 1, 176, 1, 176, 5, 176, 2813, 8, 176, 10, 176, 12, 176, 2816, 9, 176, 1, 176, 1, 176, 1, 177, 1, 177, 5, 177, 2822, 8, 177, 10, 177, 12, 177, 2825, 9, 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, 178, 1, 178, 1, 178, 1, 178, 3, 178, 2844, 8, 178, 1, 179, 5, 179, 2847, 8, 179, 10, 179, 12, 179, 2850, 9, 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, 3, 180, 2865, 8, 180, 1, 181, 1, 181, 5, 181, 2869, 8, 181, 10, 181, 12, 181, 2872, 9, 181, 1, 181, 1, 181, 1, 181, 5, 181, 2877, 8, 181, 10, 181, 12, 181, 2880, 9, 181, 1, 181, 1, 181, 1, 181, 1, 181, 3, 181, 2886, 8, 181, 1, 182, 1, 182, 1, 183, 5, 183, 2891, 8, 183, 10, 183, 12, 183, 2894, 9, 183, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 3, 184, 2906, 8, 184, 1, 184, 0, 1, 68, 185, 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, 0, 16, 6, 0, 1, 15, 199, 199, 243, 243, 247, 247, 264, 264, 289, 289, 5, 0, 16, 16, 199, 199, 243, 243, 264, 264, 288, 289, 1, 0, 263, 264, 1, 0, 173, 174, 1, 0, 37, 38, 1, 0, 73, 74, 3, 0, 2, 2, 61, 61, 77, 83, 2, 0, 229, 229, 260, 261, 9, 0, 178, 178, 183, 195, 201, 201, 207, 208, 210, 215, 218, 219, 222, 222, 230, 242, 262, 262, 1, 0, 95, 96, 1, 0, 97, 111, 1, 0, 68, 69, 2, 0, 173, 173, 289, 290, 2, 0, 179, 179, 264, 264, 1, 0, 167, 168, 1, 0, 51, 52, 3325, 0, 370, 1, 0, 0, 0, 2, 383, 1, 0, 0, 0, 4, 385, 1, 0, 0, 0, 6, 391, 1, 0, 0, 0, 8, 399, 1, 0, 0, 0, 10, 452, 1, 0, 0, 0, 12, 454, 1, 0, 0, 0, 14, 457, 1, 0, 0, 0, 16, 460, 1, 0, 0, 0, 18, 464, 1, 0, 0, 0, 20, 467, 1, 0, 0, 0, 22, 470, 1, 0, 0, 0, 24, 477, 1, 0, 0, 0, 26, 493, 1, 0, 0, 0, 28, 495, 1, 0, 0, 0, 30, 497, 1, 0, 0, 0, 32, 507, 1, 0, 0, 0, 34, 509, 1, 0, 0, 0, 36, 526, 1, 0, 0, 0, 38, 530, 1, 0, 0, 0, 40, 548, 1, 0, 0, 0, 42, 575, 1, 0, 0, 0, 44, 598, 1, 0, 0, 0, 46, 634, 1, 0, 0, 0, 48, 636, 1, 0, 0, 0, 50, 640, 1, 0, 0, 0, 52, 642, 1, 0, 0, 0, 54, 649, 1, 0, 0, 0, 56, 661, 1, 0, 0, 0, 58, 664, 1, 0, 0, 0, 60, 666, 1, 0, 0, 0, 62, 679, 1, 0, 0, 0, 64, 687, 1, 0, 0, 0, 66, 689, 1, 0, 0, 0, 68, 697, 1, 0, 0, 0, 70, 713, 1, 0, 0, 0, 72, 719, 1, 0, 0, 0, 74, 722, 1, 0, 0, 0, 76, 771, 1, 0, 0, 0, 78, 776, 1, 0, 0, 0, 80, 781, 1, 0, 0, 0, 82, 786, 1, 0, 0, 0, 84, 794, 1, 0, 0, 0, 86, 799, 1, 0, 0, 0, 88, 904, 1, 0, 0, 0, 90, 932, 1, 0, 0, 0, 92, 934, 1, 0, 0, 0, 94, 938, 1, 0, 0, 0, 96, 940, 1, 0, 0, 0, 98, 945, 1, 0, 0, 0, 100, 948, 1, 0, 0, 0, 102, 950, 1, 0, 0, 0, 104, 952, 1, 0, 0, 0, 106, 954, 1, 0, 0, 0, 108, 956, 1, 0, 0, 0, 110, 958, 1, 0, 0, 0, 112, 960, 1, 0, 0, 0, 114, 962, 1, 0, 0, 0, 116, 964, 1, 0, 0, 0, 118, 966, 1, 0, 0, 0, 120, 968, 1, 0, 0, 0, 122, 970, 1, 0, 0, 0, 124, 972, 1, 0, 0, 0, 126, 1056, 1, 0, 0, 0, 128, 1074, 1, 0, 0, 0, 130, 1076, 1, 0, 0, 0, 132, 1088, 1, 0, 0, 0, 134, 1113, 1, 0, 0, 0, 136, 1122, 1, 0, 0, 0, 138, 1149, 1, 0, 0, 0, 140, 1156, 1, 0, 0, 0, 142, 1164, 1, 0, 0, 0, 144, 1172, 1, 0, 0, 0, 146, 1185, 1, 0, 0, 0, 148, 1195, 1, 0, 0, 0, 150, 1214, 1, 0, 0, 0, 152, 1308, 1, 0, 0, 0, 154, 1317, 1, 0, 0, 0, 156, 1327, 1, 0, 0, 0, 158, 1329, 1, 0, 0, 0, 160, 1331, 1, 0, 0, 0, 162, 1356, 1, 0, 0, 0, 164, 1388, 1, 0, 0, 0, 166, 1411, 1, 0, 0, 0, 168, 1423, 1, 0, 0, 0, 170, 1425, 1, 0, 0, 0, 172, 1428, 1, 0, 0, 0, 174, 1481, 1, 0, 0, 0, 176, 1493, 1, 0, 0, 0, 178, 1508, 1, 0, 0, 0, 180, 1515, 1, 0, 0, 0, 182, 1520, 1, 0, 0, 0, 184, 1524, 1, 0, 0, 0, 186, 1560, 1, 0, 0, 0, 188, 1562, 1, 0, 0, 0, 190, 1598, 1, 0, 0, 0, 192, 1610, 1, 0, 0, 0, 194, 1624, 1, 0, 0, 0, 196, 1626, 1, 0, 0, 0, 198, 1636, 1, 0, 0, 0, 200, 1647, 1, 0, 0, 0, 202, 1654, 1, 0, 0, 0, 204, 1664, 1, 0, 0, 0, 206, 1677, 1, 0, 0, 0, 208, 1682, 1, 0, 0, 0, 210, 1685, 1, 0, 0, 0, 212, 1696, 1, 0, 0, 0, 214, 1701, 1, 0, 0, 0, 216, 1707, 1, 0, 0, 0, 218, 1709, 1, 0, 0, 0, 220, 1831, 1, 0, 0, 0, 222, 1833, 1, 0, 0, 0, 224, 1870, 1, 0, 0, 0, 226, 1877, 1, 0, 0, 0, 228, 1882, 1, 0, 0, 0, 230, 1889, 1, 0, 0, 0, 232, 1909, 1, 0, 0, 0, 234, 1911, 1, 0, 0, 0, 236, 1916, 1, 0, 0, 0, 238, 1931, 1, 0, 0, 0, 240, 1933, 1, 0, 0, 0, 242, 1946, 1, 0, 0, 0, 244, 1951, 1, 0, 0, 0, 246, 1964, 1, 0, 0, 0, 248, 1972, 1, 0, 0, 0, 250, 1983, 1, 0, 0, 0, 252, 1988, 1, 0, 0, 0, 254, 2004, 1, 0, 0, 0, 256, 2006, 1, 0, 0, 0, 258, 2050, 1, 0, 0, 0, 260, 2070, 1, 0, 0, 0, 262, 2099, 1, 0, 0, 0, 264, 2104, 1, 0, 0, 0, 266, 2127, 1, 0, 0, 0, 268, 2132, 1, 0, 0, 0, 270, 2243, 1, 0, 0, 0, 272, 2245, 1, 0, 0, 0, 274, 2250, 1, 0, 0, 0, 276, 2252, 1, 0, 0, 0, 278, 2256, 1, 0, 0, 0, 280, 2260, 1, 0, 0, 0, 282, 2276, 1, 0, 0, 0, 284, 2290, 1, 0, 0, 0, 286, 2298, 1, 0, 0, 0, 288, 2300, 1, 0, 0, 0, 290, 2303, 1, 0, 0, 0, 292, 2305, 1, 0, 0, 0, 294, 2318, 1, 0, 0, 0, 296, 2320, 1, 0, 0, 0, 298, 2330, 1, 0, 0, 0, 300, 2335, 1, 0, 0, 0, 302, 2346, 1, 0, 0, 0, 304, 2353, 1, 0, 0, 0, 306, 2363, 1, 0, 0, 0, 308, 2431, 1, 0, 0, 0, 310, 2508, 1, 0, 0, 0, 312, 2513, 1, 0, 0, 0, 314, 2516, 1, 0, 0, 0, 316, 2521, 1, 0, 0, 0, 318, 2671, 1, 0, 0, 0, 320, 2677, 1, 0, 0, 0, 322, 2684, 1, 0, 0, 0, 324, 2690, 1, 0, 0, 0, 326, 2696, 1, 0, 0, 0, 328, 2702, 1, 0, 0, 0, 330, 2708, 1, 0, 0, 0, 332, 2714, 1, 0, 0, 0, 334, 2720, 1, 0, 0, 0, 336, 2726, 1, 0, 0, 0, 338, 2733, 1, 0, 0, 0, 340, 2738, 1, 0, 0, 0, 342, 2744, 1, 0, 0, 0, 344, 2771, 1, 0, 0, 0, 346, 2785, 1, 0, 0, 0, 348, 2790, 1, 0, 0, 0, 350, 2807, 1, 0, 0, 0, 352, 2809, 1, 0, 0, 0, 354, 2819, 1, 0, 0, 0, 356, 2843, 1, 0, 0, 0, 358, 2848, 1, 0, 0, 0, 360, 2864, 1, 0, 0, 0, 362, 2885, 1, 0, 0, 0, 364, 2887, 1, 0, 0, 0, 366, 2892, 1, 0, 0, 0, 368, 2905, 1, 0, 0, 0, 370, 371, 7, 0, 0, 0, 371, 1, 1, 0, 0, 0, 372, 384, 5, 288, 0, 0, 373, 374, 3, 4, 2, 0, 374, 375, 5, 265, 0, 0, 375, 377, 1, 0, 0, 0, 376, 373, 1, 0, 0, 0, 377, 380, 1, 0, 0, 0, 378, 376, 1, 0, 0, 0, 378, 379, 1, 0, 0, 0, 379, 381, 1, 0, 0, 0, 380, 378, 1, 0, 0, 0, 381, 384, 3, 4, 2, 0, 382, 384, 5, 264, 0, 0, 383, 372, 1, 0, 0, 0, 383, 378, 1, 0, 0, 0, 383, 382, 1, 0, 0, 0, 384, 3, 1, 0, 0, 0, 385, 386, 7, 1, 0, 0, 386, 5, 1, 0, 0, 0, 387, 388, 5, 263, 0, 0, 388, 390, 5, 266, 0, 0, 389, 387, 1, 0, 0, 0, 390, 393, 1, 0, 0, 0, 391, 389, 1, 0, 0, 0, 391, 392, 1, 0, 0, 0, 392, 394, 1, 0, 0, 0, 393, 391, 1, 0, 0, 0, 394, 395, 5, 263, 0, 0, 395, 7, 1, 0, 0, 0, 396, 398, 3, 10, 5, 0, 397, 396, 1, 0, 0, 0, 398, 401, 1, 0, 0, 0, 399, 397, 1, 0, 0, 0, 399, 400, 1, 0, 0, 0, 400, 9, 1, 0, 0, 0, 401, 399, 1, 0, 0, 0, 402, 403, 3, 74, 37, 0, 403, 404, 5, 17, 0, 0, 404, 405, 3, 82, 41, 0, 405, 406, 5, 18, 0, 0, 406, 453, 1, 0, 0, 0, 407, 408, 3, 72, 36, 0, 408, 409, 5, 17, 0, 0, 409, 410, 3, 8, 4, 0, 410, 411, 5, 18, 0, 0, 411, 453, 1, 0, 0, 0, 412, 413, 3, 256, 128, 0, 413, 414, 5, 17, 0, 0, 414, 415, 3, 268, 134, 0, 415, 416, 5, 18, 0, 0, 416, 453, 1, 0, 0, 0, 417, 453, 3, 222, 111, 0, 418, 453, 3, 296, 148, 0, 419, 453, 3, 70, 35, 0, 420, 453, 3, 66, 33, 0, 421, 453, 3, 88, 44, 0, 422, 453, 3, 90, 45, 0, 423, 453, 3, 22, 11, 0, 424, 425, 3, 346, 173, 0, 425, 426, 5, 17, 0, 0, 426, 427, 3, 348, 174, 0, 427, 428, 5, 18, 0, 0, 428, 453, 1, 0, 0, 0, 429, 430, 3, 352, 176, 0, 430, 431, 5, 17, 0, 0, 431, 432, 3, 358, 179, 0, 432, 433, 5, 18, 0, 0, 433, 453, 1, 0, 0, 0, 434, 435, 3, 362, 181, 0, 435, 436, 5, 17, 0, 0, 436, 437, 3, 366, 183, 0, 437, 438, 5, 18, 0, 0, 438, 453, 1, 0, 0, 0, 439, 453, 3, 64, 32, 0, 440, 453, 3, 174, 87, 0, 441, 453, 3, 342, 171, 0, 442, 453, 3, 12, 6, 0, 443, 453, 3, 14, 7, 0, 444, 453, 3, 16, 8, 0, 445, 453, 3, 18, 9, 0, 446, 453, 3, 20, 10, 0, 447, 453, 3, 26, 13, 0, 448, 453, 3, 42, 21, 0, 449, 453, 3, 40, 20, 0, 450, 453, 3, 30, 15, 0, 451, 453, 3, 24, 12, 0, 452, 402, 1, 0, 0, 0, 452, 407, 1, 0, 0, 0, 452, 412, 1, 0, 0, 0, 452, 417, 1, 0, 0, 0, 452, 418, 1, 0, 0, 0, 452, 419, 1, 0, 0, 0, 452, 420, 1, 0, 0, 0, 452, 421, 1, 0, 0, 0, 452, 422, 1, 0, 0, 0, 452, 423, 1, 0, 0, 0, 452, 424, 1, 0, 0, 0, 452, 429, 1, 0, 0, 0, 452, 434, 1, 0, 0, 0, 452, 439, 1, 0, 0, 0, 452, 440, 1, 0, 0, 0, 452, 441, 1, 0, 0, 0, 452, 442, 1, 0, 0, 0, 452, 443, 1, 0, 0, 0, 452, 444, 1, 0, 0, 0, 452, 445, 1, 0, 0, 0, 452, 446, 1, 0, 0, 0, 452, 447, 1, 0, 0, 0, 452, 448, 1, 0, 0, 0, 452, 449, 1, 0, 0, 0, 452, 450, 1, 0, 0, 0, 452, 451, 1, 0, 0, 0, 453, 11, 1, 0, 0, 0, 454, 455, 5, 19, 0, 0, 455, 456, 3, 32, 16, 0, 456, 13, 1, 0, 0, 0, 457, 458, 5, 20, 0, 0, 458, 459, 3, 32, 16, 0, 459, 15, 1, 0, 0, 0, 460, 461, 5, 21, 0, 0, 461, 462, 5, 22, 0, 0, 462, 463, 3, 32, 16, 0, 463, 17, 1, 0, 0, 0, 464, 465, 5, 23, 0, 0, 465, 466, 3, 34, 17, 0, 466, 19, 1, 0, 0, 0, 467, 468, 5, 24, 0, 0, 468, 469, 3, 34, 17, 0, 469, 21, 1, 0, 0, 0, 470, 471, 5, 25, 0, 0, 471, 472, 3, 98, 49, 0, 472, 473, 3, 2, 1, 0, 473, 474, 5, 17, 0, 0, 474, 475, 3, 142, 71, 0, 475, 476, 5, 18, 0, 0, 476, 23, 1, 0, 0, 0, 477, 478, 5, 26, 0, 0, 478, 25, 1, 0, 0, 0, 479, 480, 5, 27, 0, 0, 480, 494, 3, 28, 14, 0, 481, 482, 5, 27, 0, 0, 482, 483, 3, 28, 14, 0, 483, 484, 5, 28, 0, 0, 484, 485, 3, 28, 14, 0, 485, 494, 1, 0, 0, 0, 486, 487, 5, 27, 0, 0, 487, 488, 3, 28, 14, 0, 488, 489, 5, 28, 0, 0, 489, 490, 3, 28, 14, 0, 490, 491, 5, 28, 0, 0, 491, 492, 3, 28, 14, 0, 492, 494, 1, 0, 0, 0, 493, 479, 1, 0, 0, 0, 493, 481, 1, 0, 0, 0, 493, 486, 1, 0, 0, 0, 494, 27, 1, 0, 0, 0, 495, 496, 7, 2, 0, 0, 496, 29, 1, 0, 0, 0, 497, 498, 5, 29, 0, 0, 498, 502, 5, 17, 0, 0, 499, 501, 3, 138, 69, 0, 500, 499, 1, 0, 0, 0, 501, 504, 1, 0, 0, 0, 502, 500, 1, 0, 0, 0, 502, 503, 1, 0, 0, 0, 503, 505, 1, 0, 0, 0, 504, 502, 1, 0, 0, 0, 505, 506, 5, 18, 0, 0, 506, 31, 1, 0, 0, 0, 507, 508, 5, 173, 0, 0, 508, 33, 1, 0, 0, 0, 509, 510, 7, 3, 0, 0, 510, 35, 1, 0, 0, 0, 511, 527, 5, 175, 0, 0, 512, 513, 3, 32, 16, 0, 513, 514, 5, 265, 0, 0, 514, 527, 1, 0, 0, 0, 515, 527, 3, 32, 16, 0, 516, 517, 5, 188, 0, 0, 517, 518, 5, 30, 0, 0, 518, 519, 3, 32, 16, 0, 519, 520, 5, 31, 0, 0, 520, 527, 1, 0, 0, 0, 521, 522, 5, 189, 0, 0, 522, 523, 5, 30, 0, 0, 523, 524, 3, 34, 17, 0, 524, 525, 5, 31, 0, 0, 525, 527, 1, 0, 0, 0, 526, 511, 1, 0, 0, 0, 526, 512, 1, 0, 0, 0, 526, 515, 1, 0, 0, 0, 526, 516, 1, 0, 0, 0, 526, 521, 1, 0, 0, 0, 527, 37, 1, 0, 0, 0, 528, 531, 3, 32, 16, 0, 529, 531, 5, 262, 0, 0, 530, 528, 1, 0, 0, 0, 530, 529, 1, 0, 0, 0, 531, 39, 1, 0, 0, 0, 532, 533, 5, 267, 0, 0, 533, 549, 5, 289, 0, 0, 534, 535, 5, 267, 0, 0, 535, 536, 5, 289, 0, 0, 536, 549, 5, 263, 0, 0, 537, 538, 5, 268, 0, 0, 538, 549, 5, 289, 0, 0, 539, 540, 5, 269, 0, 0, 540, 549, 5, 289, 0, 0, 541, 542, 5, 270, 0, 0, 542, 549, 5, 289, 0, 0, 543, 549, 5, 271, 0, 0, 544, 549, 5, 272, 0, 0, 545, 546, 5, 273, 0, 0, 546, 549, 5, 263, 0, 0, 547, 549, 5, 32, 0, 0, 548, 532, 1, 0, 0, 0, 548, 534, 1, 0, 0, 0, 548, 537, 1, 0, 0, 0, 548, 539, 1, 0, 0, 0, 548, 541, 1, 0, 0, 0, 548, 543, 1, 0, 0, 0, 548, 544, 1, 0, 0, 0, 548, 545, 1, 0, 0, 0, 548, 547, 1, 0, 0, 0, 549, 41, 1, 0, 0, 0, 550, 551, 5, 33, 0, 0, 551, 552, 3, 160, 80, 0, 552, 553, 5, 34, 0, 0, 553, 554, 3, 2, 1, 0, 554, 576, 1, 0, 0, 0, 555, 556, 5, 33, 0, 0, 556, 557, 3, 138, 69, 0, 557, 558, 5, 34, 0, 0, 558, 559, 3, 2, 1, 0, 559, 576, 1, 0, 0, 0, 560, 561, 5, 33, 0, 0, 561, 562, 3, 198, 99, 0, 562, 563, 5, 34, 0, 0, 563, 564, 3, 2, 1, 0, 564, 576, 1, 0, 0, 0, 565, 566, 5, 33, 0, 0, 566, 567, 3, 44, 22, 0, 567, 568, 5, 34, 0, 0, 568, 569, 3, 2, 1, 0, 569, 576, 1, 0, 0, 0, 570, 571, 5, 33, 0, 0, 571, 572, 3, 46, 23, 0, 572, 573, 5, 34, 0, 0, 573, 574, 3, 2, 1, 0, 574, 576, 1, 0, 0, 0, 575, 550, 1, 0, 0, 0, 575, 555, 1, 0, 0, 0, 575, 560, 1, 0, 0, 0, 575, 565, 1, 0, 0, 0, 575, 570, 1, 0, 0, 0, 576, 43, 1, 0, 0, 0, 577, 578, 5, 35, 0, 0, 578, 599, 3, 48, 24, 0, 579, 580, 5, 35, 0, 0, 580, 581, 3, 48, 24, 0, 581, 582, 5, 36, 0, 0, 582, 583, 3, 6, 3, 0, 583, 599, 1, 0, 0, 0, 584, 585, 5, 35, 0, 0, 585, 586, 3, 48, 24, 0, 586, 587, 5, 36, 0, 0, 587, 588, 5, 17, 0, 0, 588, 589, 3, 52, 26, 0, 589, 590, 5, 18, 0, 0, 590, 599, 1, 0, 0, 0, 591, 592, 5, 35, 0, 0, 592, 593, 3, 48, 24, 0, 593, 594, 5, 36, 0, 0, 594, 595, 5, 30, 0, 0, 595, 596, 3, 312, 156, 0, 596, 597, 5, 31, 0, 0, 597, 599, 1, 0, 0, 0, 598, 577, 1, 0, 0, 0, 598, 579, 1, 0, 0, 0, 598, 584, 1, 0, 0, 0, 598, 591, 1, 0, 0, 0, 599, 45, 1, 0, 0, 0, 600, 601, 5, 35, 0, 0, 601, 602, 5, 30, 0, 0, 602, 603, 3, 50, 25, 0, 603, 604, 5, 31, 0, 0, 604, 605, 3, 48, 24, 0, 605, 635, 1, 0, 0, 0, 606, 607, 5, 35, 0, 0, 607, 608, 5, 30, 0, 0, 608, 609, 3, 50, 25, 0, 609, 610, 5, 31, 0, 0, 610, 611, 3, 48, 24, 0, 611, 612, 5, 36, 0, 0, 612, 613, 3, 6, 3, 0, 613, 635, 1, 0, 0, 0, 614, 615, 5, 35, 0, 0, 615, 616, 5, 30, 0, 0, 616, 617, 3, 50, 25, 0, 617, 618, 5, 31, 0, 0, 618, 619, 3, 48, 24, 0, 619, 620, 5, 36, 0, 0, 620, 621, 5, 17, 0, 0, 621, 622, 3, 52, 26, 0, 622, 623, 5, 18, 0, 0, 623, 635, 1, 0, 0, 0, 624, 625, 5, 35, 0, 0, 625, 626, 5, 30, 0, 0, 626, 627, 3, 50, 25, 0, 627, 628, 5, 31, 0, 0, 628, 629, 3, 48, 24, 0, 629, 630, 5, 36, 0, 0, 630, 631, 5, 30, 0, 0, 631, 632, 3, 312, 156, 0, 632, 633, 5, 31, 0, 0, 633, 635, 1, 0, 0, 0, 634, 600, 1, 0, 0, 0, 634, 606, 1, 0, 0, 0, 634, 614, 1, 0, 0, 0, 634, 624, 1, 0, 0, 0, 635, 47, 1, 0, 0, 0, 636, 637, 3, 190, 95, 0, 637, 49, 1, 0, 0, 0, 638, 641, 3, 146, 73, 0, 639, 641, 3, 198, 99, 0, 640, 638, 1, 0, 0, 0, 640, 639, 1, 0, 0, 0, 641, 51, 1, 0, 0, 0, 642, 643, 3, 54, 27, 0, 643, 644, 3, 56, 28, 0, 644, 53, 1, 0, 0, 0, 645, 648, 3, 318, 159, 0, 646, 648, 3, 40, 20, 0, 647, 645, 1, 0, 0, 0, 647, 646, 1, 0, 0, 0, 648, 651, 1, 0, 0, 0, 649, 647, 1, 0, 0, 0, 649, 650, 1, 0, 0, 0, 650, 55, 1, 0, 0, 0, 651, 649, 1, 0, 0, 0, 652, 653, 3, 58, 29, 0, 653, 654, 3, 60, 30, 0, 654, 655, 3, 2, 1, 0, 655, 656, 5, 36, 0, 0, 656, 657, 3, 318, 159, 0, 657, 660, 1, 0, 0, 0, 658, 660, 3, 40, 20, 0, 659, 652, 1, 0, 0, 0, 659, 658, 1, 0, 0, 0, 660, 663, 1, 0, 0, 0, 661, 659, 1, 0, 0, 0, 661, 662, 1, 0, 0, 0, 662, 57, 1, 0, 0, 0, 663, 661, 1, 0, 0, 0, 664, 665, 7, 4, 0, 0, 665, 59, 1, 0, 0, 0, 666, 668, 3, 62, 31, 0, 667, 669, 5, 261, 0, 0, 668, 667, 1, 0, 0, 0, 668, 669, 1, 0, 0, 0, 669, 61, 1, 0, 0, 0, 670, 680, 3, 166, 83, 0, 671, 680, 3, 2, 1, 0, 672, 680, 5, 196, 0, 0, 673, 680, 5, 197, 0, 0, 674, 675, 5, 202, 0, 0, 675, 676, 5, 39, 0, 0, 676, 680, 5, 264, 0, 0, 677, 678, 5, 202, 0, 0, 678, 680, 3, 138, 69, 0, 679, 670, 1, 0, 0, 0, 679, 671, 1, 0, 0, 0, 679, 672, 1, 0, 0, 0, 679, 673, 1, 0, 0, 0, 679, 674, 1, 0, 0, 0, 679, 677, 1, 0, 0, 0, 680, 63, 1, 0, 0, 0, 681, 682, 5, 198, 0, 0, 682, 683, 5, 40, 0, 0, 683, 688, 3, 2, 1, 0, 684, 685, 5, 198, 0, 0, 685, 688, 3, 2, 1, 0, 686, 688, 5, 198, 0, 0, 687, 681, 1, 0, 0, 0, 687, 684, 1, 0, 0, 0, 687, 686, 1, 0, 0, 0, 688, 65, 1, 0, 0, 0, 689, 690, 5, 41, 0, 0, 690, 691, 5, 42, 0, 0, 691, 692, 3, 32, 16, 0, 692, 693, 5, 43, 0, 0, 693, 694, 3, 68, 34, 0, 694, 695, 5, 44, 0, 0, 695, 696, 3, 0, 0, 0, 696, 67, 1, 0, 0, 0, 697, 710, 6, 34, -1, 0, 698, 699, 10, 5, 0, 0, 699, 709, 5, 186, 0, 0, 700, 701, 10, 4, 0, 0, 701, 709, 5, 187, 0, 0, 702, 703, 10, 3, 0, 0, 703, 709, 5, 45, 0, 0, 704, 705, 10, 2, 0, 0, 705, 709, 5, 46, 0, 0, 706, 707, 10, 1, 0, 0, 707, 709, 5, 47, 0, 0, 708, 698, 1, 0, 0, 0, 708, 700, 1, 0, 0, 0, 708, 702, 1, 0, 0, 0, 708, 704, 1, 0, 0, 0, 708, 706, 1, 0, 0, 0, 709, 712, 1, 0, 0, 0, 710, 708, 1, 0, 0, 0, 710, 711, 1, 0, 0, 0, 711, 69, 1, 0, 0, 0, 712, 710, 1, 0, 0, 0, 713, 714, 5, 48, 0, 0, 714, 715, 5, 36, 0, 0, 715, 716, 5, 30, 0, 0, 716, 717, 3, 312, 156, 0, 717, 718, 5, 31, 0, 0, 718, 71, 1, 0, 0, 0, 719, 720, 5, 49, 0, 0, 720, 721, 3, 2, 1, 0, 721, 73, 1, 0, 0, 0, 722, 726, 5, 50, 0, 0, 723, 725, 3, 76, 38, 0, 724, 723, 1, 0, 0, 0, 725, 728, 1, 0, 0, 0, 726, 724, 1, 0, 0, 0, 726, 727, 1, 0, 0, 0, 727, 729, 1, 0, 0, 0, 728, 726, 1, 0, 0, 0, 729, 730, 3, 2, 1, 0, 730, 731, 3, 204, 102, 0, 731, 732, 3, 78, 39, 0, 732, 733, 3, 80, 40, 0, 733, 75, 1, 0, 0, 0, 734, 772, 5, 51, 0, 0, 735, 772, 5, 52, 0, 0, 736, 772, 5, 199, 0, 0, 737, 772, 5, 202, 0, 0, 738, 772, 5, 221, 0, 0, 739, 772, 5, 53, 0, 0, 740, 772, 5, 54, 0, 0, 741, 772, 5, 55, 0, 0, 742, 772, 5, 56, 0, 0, 743, 772, 5, 244, 0, 0, 744, 772, 5, 15, 0, 0, 745, 772, 5, 224, 0, 0, 746, 772, 5, 57, 0, 0, 747, 772, 5, 58, 0, 0, 748, 772, 5, 59, 0, 0, 749, 772, 5, 60, 0, 0, 750, 772, 5, 61, 0, 0, 751, 752, 5, 62, 0, 0, 752, 772, 5, 51, 0, 0, 753, 754, 5, 62, 0, 0, 754, 772, 5, 52, 0, 0, 755, 756, 5, 62, 0, 0, 756, 772, 5, 63, 0, 0, 757, 758, 5, 62, 0, 0, 758, 772, 5, 64, 0, 0, 759, 760, 5, 62, 0, 0, 760, 772, 5, 65, 0, 0, 761, 762, 5, 62, 0, 0, 762, 772, 5, 66, 0, 0, 763, 772, 5, 67, 0, 0, 764, 772, 5, 68, 0, 0, 765, 772, 5, 69, 0, 0, 766, 767, 5, 70, 0, 0, 767, 768, 5, 30, 0, 0, 768, 769, 3, 32, 16, 0, 769, 770, 5, 31, 0, 0, 770, 772, 1, 0, 0, 0, 771, 734, 1, 0, 0, 0, 771, 735, 1, 0, 0, 0, 771, 736, 1, 0, 0, 0, 771, 737, 1, 0, 0, 0, 771, 738, 1, 0, 0, 0, 771, 739, 1, 0, 0, 0, 771, 740, 1, 0, 0, 0, 771, 741, 1, 0, 0, 0, 771, 742, 1, 0, 0, 0, 771, 743, 1, 0, 0, 0, 771, 744, 1, 0, 0, 0, 771, 745, 1, 0, 0, 0, 771, 746, 1, 0, 0, 0, 771, 747, 1, 0, 0, 0, 771, 748, 1, 0, 0, 0, 771, 749, 1, 0, 0, 0, 771, 750, 1, 0, 0, 0, 771, 751, 1, 0, 0, 0, 771, 753, 1, 0, 0, 0, 771, 755, 1, 0, 0, 0, 771, 757, 1, 0, 0, 0, 771, 759, 1, 0, 0, 0, 771, 761, 1, 0, 0, 0, 771, 763, 1, 0, 0, 0, 771, 764, 1, 0, 0, 0, 771, 765, 1, 0, 0, 0, 771, 766, 1, 0, 0, 0, 772, 77, 1, 0, 0, 0, 773, 777, 1, 0, 0, 0, 774, 775, 5, 71, 0, 0, 775, 777, 3, 146, 73, 0, 776, 773, 1, 0, 0, 0, 776, 774, 1, 0, 0, 0, 777, 79, 1, 0, 0, 0, 778, 782, 1, 0, 0, 0, 779, 780, 5, 72, 0, 0, 780, 782, 3, 84, 42, 0, 781, 778, 1, 0, 0, 0, 781, 779, 1, 0, 0, 0, 782, 81, 1, 0, 0, 0, 783, 785, 3, 220, 110, 0, 784, 783, 1, 0, 0, 0, 785, 788, 1, 0, 0, 0, 786, 784, 1, 0, 0, 0, 786, 787, 1, 0, 0, 0, 787, 83, 1, 0, 0, 0, 788, 786, 1, 0, 0, 0, 789, 790, 3, 146, 73, 0, 790, 791, 5, 28, 0, 0, 791, 793, 1, 0, 0, 0, 792, 789, 1, 0, 0, 0, 793, 796, 1, 0, 0, 0, 794, 792, 1, 0, 0, 0, 794, 795, 1, 0, 0, 0, 795, 797, 1, 0, 0, 0, 796, 794, 1, 0, 0, 0, 797, 798, 3, 146, 73, 0, 798, 85, 1, 0, 0, 0, 799, 800, 7, 5, 0, 0, 800, 87, 1, 0, 0, 0, 801, 802, 3, 86, 43, 0, 802, 803, 3, 32, 16, 0, 803, 804, 5, 264, 0, 0, 804, 905, 1, 0, 0, 0, 805, 806, 3, 86, 43, 0, 806, 807, 3, 32, 16, 0, 807, 905, 1, 0, 0, 0, 808, 809, 3, 86, 43, 0, 809, 810, 3, 32, 16, 0, 810, 811, 5, 75, 0, 0, 811, 812, 3, 32, 16, 0, 812, 813, 5, 264, 0, 0, 813, 905, 1, 0, 0, 0, 814, 815, 3, 86, 43, 0, 815, 816, 3, 32, 16, 0, 816, 817, 5, 75, 0, 0, 817, 818, 3, 32, 16, 0, 818, 905, 1, 0, 0, 0, 819, 820, 3, 86, 43, 0, 820, 821, 3, 32, 16, 0, 821, 822, 5, 75, 0, 0, 822, 823, 3, 32, 16, 0, 823, 824, 5, 28, 0, 0, 824, 825, 3, 32, 16, 0, 825, 826, 5, 264, 0, 0, 826, 905, 1, 0, 0, 0, 827, 828, 3, 86, 43, 0, 828, 829, 3, 32, 16, 0, 829, 830, 5, 75, 0, 0, 830, 831, 3, 32, 16, 0, 831, 832, 5, 28, 0, 0, 832, 833, 3, 32, 16, 0, 833, 905, 1, 0, 0, 0, 834, 835, 3, 86, 43, 0, 835, 836, 3, 32, 16, 0, 836, 837, 5, 28, 0, 0, 837, 838, 3, 32, 16, 0, 838, 839, 5, 75, 0, 0, 839, 840, 3, 32, 16, 0, 840, 841, 5, 264, 0, 0, 841, 905, 1, 0, 0, 0, 842, 843, 3, 86, 43, 0, 843, 844, 3, 32, 16, 0, 844, 845, 5, 28, 0, 0, 845, 846, 3, 32, 16, 0, 846, 847, 5, 75, 0, 0, 847, 848, 3, 32, 16, 0, 848, 905, 1, 0, 0, 0, 849, 850, 3, 86, 43, 0, 850, 851, 3, 32, 16, 0, 851, 852, 5, 28, 0, 0, 852, 853, 3, 32, 16, 0, 853, 854, 5, 75, 0, 0, 854, 855, 3, 32, 16, 0, 855, 856, 5, 28, 0, 0, 856, 857, 3, 32, 16, 0, 857, 858, 5, 264, 0, 0, 858, 905, 1, 0, 0, 0, 859, 860, 3, 86, 43, 0, 860, 861, 3, 32, 16, 0, 861, 862, 5, 28, 0, 0, 862, 863, 3, 32, 16, 0, 863, 864, 5, 75, 0, 0, 864, 865, 3, 32, 16, 0, 865, 866, 5, 28, 0, 0, 866, 867, 3, 32, 16, 0, 867, 905, 1, 0, 0, 0, 868, 869, 3, 86, 43, 0, 869, 870, 3, 32, 16, 0, 870, 871, 5, 263, 0, 0, 871, 905, 1, 0, 0, 0, 872, 873, 3, 86, 43, 0, 873, 874, 3, 32, 16, 0, 874, 875, 5, 75, 0, 0, 875, 876, 3, 32, 16, 0, 876, 877, 5, 263, 0, 0, 877, 905, 1, 0, 0, 0, 878, 879, 3, 86, 43, 0, 879, 880, 3, 32, 16, 0, 880, 881, 5, 75, 0, 0, 881, 882, 3, 32, 16, 0, 882, 883, 5, 28, 0, 0, 883, 884, 3, 32, 16, 0, 884, 885, 5, 263, 0, 0, 885, 905, 1, 0, 0, 0, 886, 887, 3, 86, 43, 0, 887, 888, 3, 32, 16, 0, 888, 889, 5, 28, 0, 0, 889, 890, 3, 32, 16, 0, 890, 891, 5, 75, 0, 0, 891, 892, 3, 32, 16, 0, 892, 893, 5, 263, 0, 0, 893, 905, 1, 0, 0, 0, 894, 895, 3, 86, 43, 0, 895, 896, 3, 32, 16, 0, 896, 897, 5, 28, 0, 0, 897, 898, 3, 32, 16, 0, 898, 899, 5, 75, 0, 0, 899, 900, 3, 32, 16, 0, 900, 901, 5, 28, 0, 0, 901, 902, 3, 32, 16, 0, 902, 903, 5, 263, 0, 0, 903, 905, 1, 0, 0, 0, 904, 801, 1, 0, 0, 0, 904, 805, 1, 0, 0, 0, 904, 808, 1, 0, 0, 0, 904, 814, 1, 0, 0, 0, 904, 819, 1, 0, 0, 0, 904, 827, 1, 0, 0, 0, 904, 834, 1, 0, 0, 0, 904, 842, 1, 0, 0, 0, 904, 849, 1, 0, 0, 0, 904, 859, 1, 0, 0, 0, 904, 868, 1, 0, 0, 0, 904, 872, 1, 0, 0, 0, 904, 878, 1, 0, 0, 0, 904, 886, 1, 0, 0, 0, 904, 894, 1, 0, 0, 0, 905, 89, 1, 0, 0, 0, 906, 910, 5, 21, 0, 0, 907, 909, 3, 92, 46, 0, 908, 907, 1, 0, 0, 0, 909, 912, 1, 0, 0, 0, 910, 908, 1, 0, 0, 0, 910, 911, 1, 0, 0, 0, 911, 913, 1, 0, 0, 0, 912, 910, 1, 0, 0, 0, 913, 914, 3, 2, 1, 0, 914, 915, 3, 94, 47, 0, 915, 916, 5, 180, 0, 0, 916, 917, 5, 36, 0, 0, 917, 918, 5, 30, 0, 0, 918, 919, 3, 312, 156, 0, 919, 920, 5, 31, 0, 0, 920, 921, 3, 94, 47, 0, 921, 933, 1, 0, 0, 0, 922, 926, 5, 21, 0, 0, 923, 925, 3, 92, 46, 0, 924, 923, 1, 0, 0, 0, 925, 928, 1, 0, 0, 0, 926, 924, 1, 0, 0, 0, 926, 927, 1, 0, 0, 0, 927, 929, 1, 0, 0, 0, 928, 926, 1, 0, 0, 0, 929, 930, 3, 2, 1, 0, 930, 931, 3, 94, 47, 0, 931, 933, 1, 0, 0, 0, 932, 906, 1, 0, 0, 0, 932, 922, 1, 0, 0, 0, 933, 91, 1, 0, 0, 0, 934, 935, 5, 76, 0, 0, 935, 93, 1, 0, 0, 0, 936, 939, 1, 0, 0, 0, 937, 939, 5, 298, 0, 0, 938, 936, 1, 0, 0, 0, 938, 937, 1, 0, 0, 0, 939, 95, 1, 0, 0, 0, 940, 941, 7, 6, 0, 0, 941, 97, 1, 0, 0, 0, 942, 944, 3, 96, 48, 0, 943, 942, 1, 0, 0, 0, 944, 947, 1, 0, 0, 0, 945, 943, 1, 0, 0, 0, 945, 946, 1, 0, 0, 0, 946, 99, 1, 0, 0, 0, 947, 945, 1, 0, 0, 0, 948, 949, 5, 275, 0, 0, 949, 101, 1, 0, 0, 0, 950, 951, 5, 276, 0, 0, 951, 103, 1, 0, 0, 0, 952, 953, 5, 277, 0, 0, 953, 105, 1, 0, 0, 0, 954, 955, 5, 278, 0, 0, 955, 107, 1, 0, 0, 0, 956, 957, 5, 279, 0, 0, 957, 109, 1, 0, 0, 0, 958, 959, 5, 282, 0, 0, 959, 111, 1, 0, 0, 0, 960, 961, 5, 280, 0, 0, 961, 113, 1, 0, 0, 0, 962, 963, 5, 286, 0, 0, 963, 115, 1, 0, 0, 0, 964, 965, 5, 284, 0, 0, 965, 117, 1, 0, 0, 0, 966, 967, 5, 285, 0, 0, 967, 119, 1, 0, 0, 0, 968, 969, 5, 281, 0, 0, 969, 121, 1, 0, 0, 0, 970, 971, 5, 287, 0, 0, 971, 123, 1, 0, 0, 0, 972, 973, 5, 283, 0, 0, 973, 125, 1, 0, 0, 0, 974, 1057, 3, 100, 50, 0, 975, 976, 3, 102, 51, 0, 976, 977, 3, 32, 16, 0, 977, 1057, 1, 0, 0, 0, 978, 979, 3, 102, 51, 0, 979, 980, 3, 0, 0, 0, 980, 1057, 1, 0, 0, 0, 981, 982, 3, 104, 52, 0, 982, 983, 3, 32, 16, 0, 983, 1057, 1, 0, 0, 0, 984, 985, 3, 106, 53, 0, 985, 986, 3, 34, 17, 0, 986, 1057, 1, 0, 0, 0, 987, 988, 3, 108, 54, 0, 988, 989, 3, 36, 18, 0, 989, 1057, 1, 0, 0, 0, 990, 991, 3, 108, 54, 0, 991, 992, 3, 34, 17, 0, 992, 1057, 1, 0, 0, 0, 993, 994, 3, 108, 54, 0, 994, 995, 5, 30, 0, 0, 995, 996, 3, 312, 156, 0, 996, 997, 5, 31, 0, 0, 997, 1057, 1, 0, 0, 0, 998, 999, 3, 108, 54, 0, 999, 1000, 5, 84, 0, 0, 1000, 1001, 5, 30, 0, 0, 1001, 1002, 3, 312, 156, 0, 1002, 1003, 5, 31, 0, 0, 1003, 1057, 1, 0, 0, 0, 1004, 1005, 3, 110, 55, 0, 1005, 1006, 3, 32, 16, 0, 1006, 1057, 1, 0, 0, 0, 1007, 1008, 3, 110, 55, 0, 1008, 1009, 3, 0, 0, 0, 1009, 1057, 1, 0, 0, 0, 1010, 1011, 3, 112, 56, 0, 1011, 1012, 3, 190, 95, 0, 1012, 1057, 1, 0, 0, 0, 1013, 1014, 3, 114, 57, 0, 1014, 1015, 3, 200, 100, 0, 1015, 1057, 1, 0, 0, 0, 1016, 1017, 3, 114, 57, 0, 1017, 1018, 3, 196, 98, 0, 1018, 1057, 1, 0, 0, 0, 1019, 1020, 3, 116, 58, 0, 1020, 1021, 3, 146, 73, 0, 1021, 1057, 1, 0, 0, 0, 1022, 1023, 3, 118, 59, 0, 1023, 1024, 3, 6, 3, 0, 1024, 1057, 1, 0, 0, 0, 1025, 1026, 3, 118, 59, 0, 1026, 1027, 5, 224, 0, 0, 1027, 1028, 5, 30, 0, 0, 1028, 1029, 3, 6, 3, 0, 1029, 1030, 5, 31, 0, 0, 1030, 1057, 1, 0, 0, 0, 1031, 1032, 3, 118, 59, 0, 1032, 1033, 5, 84, 0, 0, 1033, 1034, 5, 30, 0, 0, 1034, 1035, 3, 312, 156, 0, 1035, 1036, 5, 31, 0, 0, 1036, 1057, 1, 0, 0, 0, 1037, 1038, 3, 120, 60, 0, 1038, 1039, 3, 192, 96, 0, 1039, 1040, 3, 160, 80, 0, 1040, 1041, 3, 134, 67, 0, 1041, 1057, 1, 0, 0, 0, 1042, 1043, 3, 122, 61, 0, 1043, 1044, 3, 50, 25, 0, 1044, 1057, 1, 0, 0, 0, 1045, 1046, 3, 122, 61, 0, 1046, 1047, 3, 32, 16, 0, 1047, 1057, 1, 0, 0, 0, 1048, 1049, 3, 124, 62, 0, 1049, 1050, 5, 30, 0, 0, 1050, 1051, 3, 128, 64, 0, 1051, 1052, 5, 31, 0, 0, 1052, 1057, 1, 0, 0, 0, 1053, 1054, 3, 124, 62, 0, 1054, 1055, 5, 85, 0, 0, 1055, 1057, 1, 0, 0, 0, 1056, 974, 1, 0, 0, 0, 1056, 975, 1, 0, 0, 0, 1056, 978, 1, 0, 0, 0, 1056, 981, 1, 0, 0, 0, 1056, 984, 1, 0, 0, 0, 1056, 987, 1, 0, 0, 0, 1056, 990, 1, 0, 0, 0, 1056, 993, 1, 0, 0, 0, 1056, 998, 1, 0, 0, 0, 1056, 1004, 1, 0, 0, 0, 1056, 1007, 1, 0, 0, 0, 1056, 1010, 1, 0, 0, 0, 1056, 1013, 1, 0, 0, 0, 1056, 1016, 1, 0, 0, 0, 1056, 1019, 1, 0, 0, 0, 1056, 1022, 1, 0, 0, 0, 1056, 1025, 1, 0, 0, 0, 1056, 1031, 1, 0, 0, 0, 1056, 1037, 1, 0, 0, 0, 1056, 1042, 1, 0, 0, 0, 1056, 1045, 1, 0, 0, 0, 1056, 1048, 1, 0, 0, 0, 1056, 1053, 1, 0, 0, 0, 1057, 127, 1, 0, 0, 0, 1058, 1075, 1, 0, 0, 0, 1059, 1062, 3, 0, 0, 0, 1060, 1062, 3, 32, 16, 0, 1061, 1059, 1, 0, 0, 0, 1061, 1060, 1, 0, 0, 0, 1062, 1063, 1, 0, 0, 0, 1063, 1064, 5, 28, 0, 0, 1064, 1066, 1, 0, 0, 0, 1065, 1061, 1, 0, 0, 0, 1066, 1069, 1, 0, 0, 0, 1067, 1065, 1, 0, 0, 0, 1067, 1068, 1, 0, 0, 0, 1068, 1072, 1, 0, 0, 0, 1069, 1067, 1, 0, 0, 0, 1070, 1073, 3, 0, 0, 0, 1071, 1073, 3, 32, 16, 0, 1072, 1070, 1, 0, 0, 0, 1072, 1071, 1, 0, 0, 0, 1073, 1075, 1, 0, 0, 0, 1074, 1058, 1, 0, 0, 0, 1074, 1067, 1, 0, 0, 0, 1075, 129, 1, 0, 0, 0, 1076, 1082, 5, 86, 0, 0, 1077, 1078, 3, 160, 80, 0, 1078, 1079, 5, 28, 0, 0, 1079, 1081, 1, 0, 0, 0, 1080, 1077, 1, 0, 0, 0, 1081, 1084, 1, 0, 0, 0, 1082, 1080, 1, 0, 0, 0, 1082, 1083, 1, 0, 0, 0, 1083, 1085, 1, 0, 0, 0, 1084, 1082, 1, 0, 0, 0, 1085, 1086, 3, 160, 80, 0, 1086, 1087, 5, 87, 0, 0, 1087, 131, 1, 0, 0, 0, 1088, 1094, 5, 42, 0, 0, 1089, 1090, 3, 168, 84, 0, 1090, 1091, 5, 28, 0, 0, 1091, 1093, 1, 0, 0, 0, 1092, 1089, 1, 0, 0, 0, 1093, 1096, 1, 0, 0, 0, 1094, 1092, 1, 0, 0, 0, 1094, 1095, 1, 0, 0, 0, 1095, 1097, 1, 0, 0, 0, 1096, 1094, 1, 0, 0, 0, 1097, 1098, 3, 168, 84, 0, 1098, 1099, 5, 43, 0, 0, 1099, 133, 1, 0, 0, 0, 1100, 1106, 5, 30, 0, 0, 1101, 1102, 3, 136, 68, 0, 1102, 1103, 5, 28, 0, 0, 1103, 1105, 1, 0, 0, 0, 1104, 1101, 1, 0, 0, 0, 1105, 1108, 1, 0, 0, 0, 1106, 1104, 1, 0, 0, 0, 1106, 1107, 1, 0, 0, 0, 1107, 1109, 1, 0, 0, 0, 1108, 1106, 1, 0, 0, 0, 1109, 1110, 3, 136, 68, 0, 1110, 1111, 5, 31, 0, 0, 1111, 1114, 1, 0, 0, 0, 1112, 1114, 5, 85, 0, 0, 1113, 1100, 1, 0, 0, 0, 1113, 1112, 1, 0, 0, 0, 1114, 135, 1, 0, 0, 0, 1115, 1123, 5, 177, 0, 0, 1116, 1117, 3, 252, 126, 0, 1117, 1118, 3, 160, 80, 0, 1118, 1120, 3, 248, 124, 0, 1119, 1121, 3, 0, 0, 0, 1120, 1119, 1, 0, 0, 0, 1120, 1121, 1, 0, 0, 0, 1121, 1123, 1, 0, 0, 0, 1122, 1115, 1, 0, 0, 0, 1122, 1116, 1, 0, 0, 0, 1123, 137, 1, 0, 0, 0, 1124, 1125, 5, 42, 0, 0, 1125, 1126, 3, 2, 1, 0, 1126, 1127, 5, 43, 0, 0, 1127, 1128, 3, 140, 70, 0, 1128, 1150, 1, 0, 0, 0, 1129, 1130, 5, 42, 0, 0, 1130, 1131, 3, 196, 98, 0, 1131, 1132, 5, 43, 0, 0, 1132, 1133, 3, 140, 70, 0, 1133, 1150, 1, 0, 0, 0, 1134, 1135, 5, 42, 0, 0, 1135, 1136, 5, 262, 0, 0, 1136, 1137, 5, 43, 0, 0, 1137, 1150, 3, 140, 70, 0, 1138, 1139, 5, 42, 0, 0, 1139, 1140, 5, 198, 0, 0, 1140, 1141, 3, 2, 1, 0, 1141, 1142, 5, 43, 0, 0, 1142, 1143, 3, 140, 70, 0, 1143, 1150, 1, 0, 0, 0, 1144, 1150, 3, 140, 70, 0, 1145, 1150, 3, 196, 98, 0, 1146, 1150, 5, 257, 0, 0, 1147, 1150, 5, 258, 0, 0, 1148, 1150, 5, 259, 0, 0, 1149, 1124, 1, 0, 0, 0, 1149, 1129, 1, 0, 0, 0, 1149, 1134, 1, 0, 0, 0, 1149, 1138, 1, 0, 0, 0, 1149, 1144, 1, 0, 0, 0, 1149, 1145, 1, 0, 0, 0, 1149, 1146, 1, 0, 0, 0, 1149, 1147, 1, 0, 0, 0, 1149, 1148, 1, 0, 0, 0, 1150, 139, 1, 0, 0, 0, 1151, 1152, 3, 2, 1, 0, 1152, 1153, 5, 88, 0, 0, 1153, 1155, 1, 0, 0, 0, 1154, 1151, 1, 0, 0, 0, 1155, 1158, 1, 0, 0, 0, 1156, 1154, 1, 0, 0, 0, 1156, 1157, 1, 0, 0, 0, 1157, 1159, 1, 0, 0, 0, 1158, 1156, 1, 0, 0, 0, 1159, 1160, 3, 2, 1, 0, 1160, 141, 1, 0, 0, 0, 1161, 1163, 3, 144, 72, 0, 1162, 1161, 1, 0, 0, 0, 1163, 1166, 1, 0, 0, 0, 1164, 1162, 1, 0, 0, 0, 1164, 1165, 1, 0, 0, 0, 1165, 143, 1, 0, 0, 0, 1166, 1164, 1, 0, 0, 0, 1167, 1168, 5, 180, 0, 0, 1168, 1169, 5, 89, 0, 0, 1169, 1173, 3, 32, 16, 0, 1170, 1173, 3, 174, 87, 0, 1171, 1173, 3, 344, 172, 0, 1172, 1167, 1, 0, 0, 0, 1172, 1170, 1, 0, 0, 0, 1172, 1171, 1, 0, 0, 0, 1173, 145, 1, 0, 0, 0, 1174, 1186, 3, 138, 69, 0, 1175, 1176, 5, 42, 0, 0, 1176, 1177, 3, 2, 1, 0, 1177, 1178, 5, 43, 0, 0, 1178, 1186, 1, 0, 0, 0, 1179, 1180, 5, 42, 0, 0, 1180, 1181, 5, 198, 0, 0, 1181, 1182, 3, 2, 1, 0, 1182, 1183, 5, 43, 0, 0, 1183, 1186, 1, 0, 0, 0, 1184, 1186, 3, 160, 80, 0, 1185, 1174, 1, 0, 0, 0, 1185, 1175, 1, 0, 0, 0, 1185, 1179, 1, 0, 0, 0, 1185, 1184, 1, 0, 0, 0, 1186, 147, 1, 0, 0, 0, 1187, 1196, 1, 0, 0, 0, 1188, 1192, 3, 152, 76, 0, 1189, 1191, 3, 150, 75, 0, 1190, 1189, 1, 0, 0, 0, 1191, 1194, 1, 0, 0, 0, 1192, 1190, 1, 0, 0, 0, 1192, 1193, 1, 0, 0, 0, 1193, 1196, 1, 0, 0, 0, 1194, 1192, 1, 0, 0, 0, 1195, 1187, 1, 0, 0, 0, 1195, 1188, 1, 0, 0, 0, 1196, 149, 1, 0, 0, 0, 1197, 1215, 5, 262, 0, 0, 1198, 1215, 5, 261, 0, 0, 1199, 1200, 5, 42, 0, 0, 1200, 1201, 3, 32, 16, 0, 1201, 1202, 5, 43, 0, 0, 1202, 1215, 1, 0, 0, 0, 1203, 1204, 5, 42, 0, 0, 1204, 1205, 3, 32, 16, 0, 1205, 1206, 5, 266, 0, 0, 1206, 1207, 3, 32, 16, 0, 1207, 1208, 5, 43, 0, 0, 1208, 1215, 1, 0, 0, 0, 1209, 1210, 5, 42, 0, 0, 1210, 1211, 5, 266, 0, 0, 1211, 1212, 3, 32, 16, 0, 1212, 1213, 5, 43, 0, 0, 1213, 1215, 1, 0, 0, 0, 1214, 1197, 1, 0, 0, 0, 1214, 1198, 1, 0, 0, 0, 1214, 1199, 1, 0, 0, 0, 1214, 1203, 1, 0, 0, 0, 1214, 1209, 1, 0, 0, 0, 1215, 151, 1, 0, 0, 0, 1216, 1309, 1, 0, 0, 0, 1217, 1218, 5, 203, 0, 0, 1218, 1219, 5, 30, 0, 0, 1219, 1220, 3, 6, 3, 0, 1220, 1221, 5, 28, 0, 0, 1221, 1222, 3, 6, 3, 0, 1222, 1223, 5, 28, 0, 0, 1223, 1224, 3, 6, 3, 0, 1224, 1225, 5, 28, 0, 0, 1225, 1226, 3, 6, 3, 0, 1226, 1227, 5, 31, 0, 0, 1227, 1309, 1, 0, 0, 0, 1228, 1229, 5, 203, 0, 0, 1229, 1230, 5, 30, 0, 0, 1230, 1231, 3, 6, 3, 0, 1231, 1232, 5, 28, 0, 0, 1232, 1233, 3, 6, 3, 0, 1233, 1234, 5, 31, 0, 0, 1234, 1309, 1, 0, 0, 0, 1235, 1236, 5, 204, 0, 0, 1236, 1237, 5, 205, 0, 0, 1237, 1238, 5, 42, 0, 0, 1238, 1239, 3, 32, 16, 0, 1239, 1240, 5, 43, 0, 0, 1240, 1309, 1, 0, 0, 0, 1241, 1242, 5, 204, 0, 0, 1242, 1243, 5, 206, 0, 0, 1243, 1244, 5, 42, 0, 0, 1244, 1245, 3, 32, 16, 0, 1245, 1246, 5, 43, 0, 0, 1246, 1247, 3, 148, 74, 0, 1247, 1309, 1, 0, 0, 0, 1248, 1309, 5, 207, 0, 0, 1249, 1309, 5, 208, 0, 0, 1250, 1309, 5, 209, 0, 0, 1251, 1309, 5, 201, 0, 0, 1252, 1309, 5, 183, 0, 0, 1253, 1309, 5, 184, 0, 0, 1254, 1309, 5, 185, 0, 0, 1255, 1309, 5, 186, 0, 0, 1256, 1309, 5, 187, 0, 0, 1257, 1309, 5, 188, 0, 0, 1258, 1309, 5, 189, 0, 0, 1259, 1309, 5, 210, 0, 0, 1260, 1309, 5, 190, 0, 0, 1261, 1309, 5, 191, 0, 0, 1262, 1309, 5, 192, 0, 0, 1263, 1309, 5, 193, 0, 0, 1264, 1309, 5, 211, 0, 0, 1265, 1309, 5, 212, 0, 0, 1266, 1309, 5, 213, 0, 0, 1267, 1309, 5, 214, 0, 0, 1268, 1309, 5, 215, 0, 0, 1269, 1309, 5, 216, 0, 0, 1270, 1309, 5, 217, 0, 0, 1271, 1272, 5, 218, 0, 0, 1272, 1309, 3, 154, 77, 0, 1273, 1274, 5, 219, 0, 0, 1274, 1309, 3, 154, 77, 0, 1275, 1309, 5, 220, 0, 0, 1276, 1277, 5, 221, 0, 0, 1277, 1309, 3, 154, 77, 0, 1278, 1279, 5, 222, 0, 0, 1279, 1309, 3, 156, 78, 0, 1280, 1281, 5, 222, 0, 0, 1281, 1282, 3, 156, 78, 0, 1282, 1283, 5, 28, 0, 0, 1283, 1284, 3, 6, 3, 0, 1284, 1309, 1, 0, 0, 0, 1285, 1309, 5, 194, 0, 0, 1286, 1309, 5, 195, 0, 0, 1287, 1288, 5, 90, 0, 0, 1288, 1309, 5, 184, 0, 0, 1289, 1290, 5, 90, 0, 0, 1290, 1309, 5, 185, 0, 0, 1291, 1292, 5, 90, 0, 0, 1292, 1309, 5, 186, 0, 0, 1293, 1294, 5, 90, 0, 0, 1294, 1309, 5, 187, 0, 0, 1295, 1296, 5, 62, 0, 0, 1296, 1309, 5, 220, 0, 0, 1297, 1309, 5, 223, 0, 0, 1298, 1299, 5, 224, 0, 0, 1299, 1309, 5, 213, 0, 0, 1300, 1309, 5, 225, 0, 0, 1301, 1302, 5, 207, 0, 0, 1302, 1309, 5, 183, 0, 0, 1303, 1309, 5, 226, 0, 0, 1304, 1309, 5, 228, 0, 0, 1305, 1306, 5, 34, 0, 0, 1306, 1309, 5, 227, 0, 0, 1307, 1309, 3, 2, 1, 0, 1308, 1216, 1, 0, 0, 0, 1308, 1217, 1, 0, 0, 0, 1308, 1228, 1, 0, 0, 0, 1308, 1235, 1, 0, 0, 0, 1308, 1241, 1, 0, 0, 0, 1308, 1248, 1, 0, 0, 0, 1308, 1249, 1, 0, 0, 0, 1308, 1250, 1, 0, 0, 0, 1308, 1251, 1, 0, 0, 0, 1308, 1252, 1, 0, 0, 0, 1308, 1253, 1, 0, 0, 0, 1308, 1254, 1, 0, 0, 0, 1308, 1255, 1, 0, 0, 0, 1308, 1256, 1, 0, 0, 0, 1308, 1257, 1, 0, 0, 0, 1308, 1258, 1, 0, 0, 0, 1308, 1259, 1, 0, 0, 0, 1308, 1260, 1, 0, 0, 0, 1308, 1261, 1, 0, 0, 0, 1308, 1262, 1, 0, 0, 0, 1308, 1263, 1, 0, 0, 0, 1308, 1264, 1, 0, 0, 0, 1308, 1265, 1, 0, 0, 0, 1308, 1266, 1, 0, 0, 0, 1308, 1267, 1, 0, 0, 0, 1308, 1268, 1, 0, 0, 0, 1308, 1269, 1, 0, 0, 0, 1308, 1270, 1, 0, 0, 0, 1308, 1271, 1, 0, 0, 0, 1308, 1273, 1, 0, 0, 0, 1308, 1275, 1, 0, 0, 0, 1308, 1276, 1, 0, 0, 0, 1308, 1278, 1, 0, 0, 0, 1308, 1280, 1, 0, 0, 0, 1308, 1285, 1, 0, 0, 0, 1308, 1286, 1, 0, 0, 0, 1308, 1287, 1, 0, 0, 0, 1308, 1289, 1, 0, 0, 0, 1308, 1291, 1, 0, 0, 0, 1308, 1293, 1, 0, 0, 0, 1308, 1295, 1, 0, 0, 0, 1308, 1297, 1, 0, 0, 0, 1308, 1298, 1, 0, 0, 0, 1308, 1300, 1, 0, 0, 0, 1308, 1301, 1, 0, 0, 0, 1308, 1303, 1, 0, 0, 0, 1308, 1304, 1, 0, 0, 0, 1308, 1305, 1, 0, 0, 0, 1308, 1307, 1, 0, 0, 0, 1309, 153, 1, 0, 0, 0, 1310, 1318, 1, 0, 0, 0, 1311, 1312, 5, 30, 0, 0, 1312, 1313, 5, 91, 0, 0, 1313, 1314, 5, 36, 0, 0, 1314, 1315, 3, 32, 16, 0, 1315, 1316, 5, 31, 0, 0, 1316, 1318, 1, 0, 0, 0, 1317, 1310, 1, 0, 0, 0, 1317, 1311, 1, 0, 0, 0, 1318, 155, 1, 0, 0, 0, 1319, 1328, 1, 0, 0, 0, 1320, 1324, 3, 158, 79, 0, 1321, 1323, 7, 7, 0, 0, 1322, 1321, 1, 0, 0, 0, 1323, 1326, 1, 0, 0, 0, 1324, 1322, 1, 0, 0, 0, 1324, 1325, 1, 0, 0, 0, 1325, 1328, 1, 0, 0, 0, 1326, 1324, 1, 0, 0, 0, 1327, 1319, 1, 0, 0, 0, 1327, 1320, 1, 0, 0, 0, 1328, 157, 1, 0, 0, 0, 1329, 1330, 7, 8, 0, 0, 1330, 159, 1, 0, 0, 0, 1331, 1335, 3, 164, 82, 0, 1332, 1334, 3, 162, 81, 0, 1333, 1332, 1, 0, 0, 0, 1334, 1337, 1, 0, 0, 0, 1335, 1333, 1, 0, 0, 0, 1335, 1336, 1, 0, 0, 0, 1336, 161, 1, 0, 0, 0, 1337, 1335, 1, 0, 0, 0, 1338, 1357, 5, 261, 0, 0, 1339, 1340, 5, 42, 0, 0, 1340, 1357, 5, 43, 0, 0, 1341, 1357, 3, 132, 66, 0, 1342, 1357, 5, 260, 0, 0, 1343, 1357, 5, 262, 0, 0, 1344, 1357, 5, 92, 0, 0, 1345, 1346, 5, 93, 0, 0, 1346, 1347, 5, 30, 0, 0, 1347, 1348, 3, 146, 73, 0, 1348, 1349, 5, 31, 0, 0, 1349, 1357, 1, 0, 0, 0, 1350, 1351, 5, 94, 0, 0, 1351, 1352, 5, 30, 0, 0, 1352, 1353, 3, 146, 73, 0, 1353, 1354, 5, 31, 0, 0, 1354, 1357, 1, 0, 0, 0, 1355, 1357, 3, 130, 65, 0, 1356, 1338, 1, 0, 0, 0, 1356, 1339, 1, 0, 0, 0, 1356, 1341, 1, 0, 0, 0, 1356, 1342, 1, 0, 0, 0, 1356, 1343, 1, 0, 0, 0, 1356, 1344, 1, 0, 0, 0, 1356, 1345, 1, 0, 0, 0, 1356, 1350, 1, 0, 0, 0, 1356, 1355, 1, 0, 0, 0, 1357, 163, 1, 0, 0, 0, 1358, 1359, 5, 39, 0, 0, 1359, 1389, 3, 138, 69, 0, 1360, 1389, 5, 197, 0, 0, 1361, 1362, 5, 199, 0, 0, 1362, 1363, 5, 39, 0, 0, 1363, 1389, 3, 138, 69, 0, 1364, 1365, 5, 200, 0, 0, 1365, 1389, 3, 138, 69, 0, 1366, 1367, 5, 226, 0, 0, 1367, 1368, 3, 192, 96, 0, 1368, 1369, 3, 160, 80, 0, 1369, 1370, 5, 262, 0, 0, 1370, 1371, 3, 134, 67, 0, 1371, 1389, 1, 0, 0, 0, 1372, 1373, 5, 253, 0, 0, 1373, 1389, 3, 32, 16, 0, 1374, 1375, 5, 252, 0, 0, 1375, 1389, 3, 32, 16, 0, 1376, 1377, 5, 253, 0, 0, 1377, 1389, 3, 2, 1, 0, 1378, 1379, 5, 252, 0, 0, 1379, 1389, 3, 2, 1, 0, 1380, 1389, 5, 254, 0, 0, 1381, 1389, 5, 201, 0, 0, 1382, 1389, 3, 170, 85, 0, 1383, 1389, 3, 172, 86, 0, 1384, 1389, 3, 166, 83, 0, 1385, 1389, 3, 2, 1, 0, 1386, 1387, 5, 177, 0, 0, 1387, 1389, 3, 160, 80, 0, 1388, 1358, 1, 0, 0, 0, 1388, 1360, 1, 0, 0, 0, 1388, 1361, 1, 0, 0, 0, 1388, 1364, 1, 0, 0, 0, 1388, 1366, 1, 0, 0, 0, 1388, 1372, 1, 0, 0, 0, 1388, 1374, 1, 0, 0, 0, 1388, 1376, 1, 0, 0, 0, 1388, 1378, 1, 0, 0, 0, 1388, 1380, 1, 0, 0, 0, 1388, 1381, 1, 0, 0, 0, 1388, 1382, 1, 0, 0, 0, 1388, 1383, 1, 0, 0, 0, 1388, 1384, 1, 0, 0, 0, 1388, 1385, 1, 0, 0, 0, 1388, 1386, 1, 0, 0, 0, 1389, 165, 1, 0, 0, 0, 1390, 1412, 5, 181, 0, 0, 1391, 1412, 5, 182, 0, 0, 1392, 1412, 5, 183, 0, 0, 1393, 1412, 5, 184, 0, 0, 1394, 1412, 5, 185, 0, 0, 1395, 1412, 5, 186, 0, 0, 1396, 1412, 5, 187, 0, 0, 1397, 1412, 5, 188, 0, 0, 1398, 1412, 5, 189, 0, 0, 1399, 1412, 5, 190, 0, 0, 1400, 1412, 5, 191, 0, 0, 1401, 1412, 5, 192, 0, 0, 1402, 1412, 5, 193, 0, 0, 1403, 1404, 5, 90, 0, 0, 1404, 1412, 5, 184, 0, 0, 1405, 1406, 5, 90, 0, 0, 1406, 1412, 5, 185, 0, 0, 1407, 1408, 5, 90, 0, 0, 1408, 1412, 5, 186, 0, 0, 1409, 1410, 5, 90, 0, 0, 1410, 1412, 5, 187, 0, 0, 1411, 1390, 1, 0, 0, 0, 1411, 1391, 1, 0, 0, 0, 1411, 1392, 1, 0, 0, 0, 1411, 1393, 1, 0, 0, 0, 1411, 1394, 1, 0, 0, 0, 1411, 1395, 1, 0, 0, 0, 1411, 1396, 1, 0, 0, 0, 1411, 1397, 1, 0, 0, 0, 1411, 1398, 1, 0, 0, 0, 1411, 1399, 1, 0, 0, 0, 1411, 1400, 1, 0, 0, 0, 1411, 1401, 1, 0, 0, 0, 1411, 1402, 1, 0, 0, 0, 1411, 1403, 1, 0, 0, 0, 1411, 1405, 1, 0, 0, 0, 1411, 1407, 1, 0, 0, 0, 1411, 1409, 1, 0, 0, 0, 1412, 167, 1, 0, 0, 0, 1413, 1424, 1, 0, 0, 0, 1414, 1424, 5, 177, 0, 0, 1415, 1424, 3, 32, 16, 0, 1416, 1417, 3, 32, 16, 0, 1417, 1418, 5, 177, 0, 0, 1418, 1419, 3, 32, 16, 0, 1419, 1424, 1, 0, 0, 0, 1420, 1421, 3, 32, 16, 0, 1421, 1422, 5, 177, 0, 0, 1422, 1424, 1, 0, 0, 0, 1423, 1413, 1, 0, 0, 0, 1423, 1414, 1, 0, 0, 0, 1423, 1415, 1, 0, 0, 0, 1423, 1416, 1, 0, 0, 0, 1423, 1420, 1, 0, 0, 0, 1424, 169, 1, 0, 0, 0, 1425, 1426, 5, 1, 0, 0, 1426, 1427, 5, 194, 0, 0, 1427, 171, 1, 0, 0, 0, 1428, 1432, 5, 1, 0, 0, 1429, 1430, 5, 90, 0, 0, 1430, 1433, 5, 194, 0, 0, 1431, 1433, 5, 195, 0, 0, 1432, 1429, 1, 0, 0, 0, 1432, 1431, 1, 0, 0, 0, 1433, 173, 1, 0, 0, 0, 1434, 1435, 5, 294, 0, 0, 1435, 1436, 3, 188, 94, 0, 1436, 1437, 3, 146, 73, 0, 1437, 1438, 5, 30, 0, 0, 1438, 1439, 3, 180, 90, 0, 1439, 1440, 5, 31, 0, 0, 1440, 1482, 1, 0, 0, 0, 1441, 1442, 5, 294, 0, 0, 1442, 1443, 3, 188, 94, 0, 1443, 1444, 3, 146, 73, 0, 1444, 1445, 5, 36, 0, 0, 1445, 1446, 5, 17, 0, 0, 1446, 1447, 3, 52, 26, 0, 1447, 1448, 5, 18, 0, 0, 1448, 1482, 1, 0, 0, 0, 1449, 1450, 5, 294, 0, 0, 1450, 1451, 3, 188, 94, 0, 1451, 1452, 3, 146, 73, 0, 1452, 1482, 1, 0, 0, 0, 1453, 1454, 5, 295, 0, 0, 1454, 1455, 3, 188, 94, 0, 1455, 1457, 5, 36, 0, 0, 1456, 1458, 5, 84, 0, 0, 1457, 1456, 1, 0, 0, 0, 1457, 1458, 1, 0, 0, 0, 1458, 1459, 1, 0, 0, 0, 1459, 1460, 5, 30, 0, 0, 1460, 1461, 3, 312, 156, 0, 1461, 1462, 5, 31, 0, 0, 1462, 1482, 1, 0, 0, 0, 1463, 1464, 5, 295, 0, 0, 1464, 1465, 3, 188, 94, 0, 1465, 1466, 5, 84, 0, 0, 1466, 1467, 5, 30, 0, 0, 1467, 1468, 3, 312, 156, 0, 1468, 1469, 5, 31, 0, 0, 1469, 1482, 1, 0, 0, 0, 1470, 1471, 5, 295, 0, 0, 1471, 1472, 3, 188, 94, 0, 1472, 1473, 3, 6, 3, 0, 1473, 1482, 1, 0, 0, 0, 1474, 1475, 5, 295, 0, 0, 1475, 1476, 3, 188, 94, 0, 1476, 1477, 5, 36, 0, 0, 1477, 1478, 5, 17, 0, 0, 1478, 1479, 3, 176, 88, 0, 1479, 1480, 5, 18, 0, 0, 1480, 1482, 1, 0, 0, 0, 1481, 1434, 1, 0, 0, 0, 1481, 1441, 1, 0, 0, 0, 1481, 1449, 1, 0, 0, 0, 1481, 1453, 1, 0, 0, 0, 1481, 1463, 1, 0, 0, 0, 1481, 1470, 1, 0, 0, 0, 1481, 1474, 1, 0, 0, 0, 1482, 175, 1, 0, 0, 0, 1483, 1494, 1, 0, 0, 0, 1484, 1485, 3, 178, 89, 0, 1485, 1486, 5, 28, 0, 0, 1486, 1488, 1, 0, 0, 0, 1487, 1484, 1, 0, 0, 0, 1488, 1491, 1, 0, 0, 0, 1489, 1487, 1, 0, 0, 0, 1489, 1490, 1, 0, 0, 0, 1490, 1492, 1, 0, 0, 0, 1491, 1489, 1, 0, 0, 0, 1492, 1494, 3, 178, 89, 0, 1493, 1483, 1, 0, 0, 0, 1493, 1489, 1, 0, 0, 0, 1494, 177, 1, 0, 0, 0, 1495, 1496, 5, 39, 0, 0, 1496, 1497, 5, 264, 0, 0, 1497, 1498, 5, 36, 0, 0, 1498, 1499, 5, 17, 0, 0, 1499, 1500, 3, 56, 28, 0, 1500, 1501, 5, 18, 0, 0, 1501, 1509, 1, 0, 0, 0, 1502, 1503, 3, 146, 73, 0, 1503, 1504, 5, 36, 0, 0, 1504, 1505, 5, 17, 0, 0, 1505, 1506, 3, 56, 28, 0, 1506, 1507, 5, 18, 0, 0, 1507, 1509, 1, 0, 0, 0, 1508, 1495, 1, 0, 0, 0, 1508, 1502, 1, 0, 0, 0, 1509, 179, 1, 0, 0, 0, 1510, 1511, 3, 182, 91, 0, 1511, 1512, 5, 28, 0, 0, 1512, 1514, 1, 0, 0, 0, 1513, 1510, 1, 0, 0, 0, 1514, 1517, 1, 0, 0, 0, 1515, 1513, 1, 0, 0, 0, 1515, 1516, 1, 0, 0, 0, 1516, 1518, 1, 0, 0, 0, 1517, 1515, 1, 0, 0, 0, 1518, 1519, 3, 182, 91, 0, 1519, 181, 1, 0, 0, 0, 1520, 1521, 3, 6, 3, 0, 1521, 1522, 5, 36, 0, 0, 1522, 1523, 3, 186, 93, 0, 1523, 183, 1, 0, 0, 0, 1524, 1525, 7, 9, 0, 0, 1525, 185, 1, 0, 0, 0, 1526, 1561, 3, 184, 92, 0, 1527, 1561, 3, 32, 16, 0, 1528, 1529, 5, 186, 0, 0, 1529, 1530, 5, 30, 0, 0, 1530, 1531, 3, 32, 16, 0, 1531, 1532, 5, 31, 0, 0, 1532, 1561, 1, 0, 0, 0, 1533, 1561, 3, 6, 3, 0, 1534, 1535, 3, 138, 69, 0, 1535, 1536, 5, 30, 0, 0, 1536, 1537, 5, 184, 0, 0, 1537, 1538, 5, 75, 0, 0, 1538, 1539, 3, 32, 16, 0, 1539, 1540, 5, 31, 0, 0, 1540, 1561, 1, 0, 0, 0, 1541, 1542, 3, 138, 69, 0, 1542, 1543, 5, 30, 0, 0, 1543, 1544, 5, 185, 0, 0, 1544, 1545, 5, 75, 0, 0, 1545, 1546, 3, 32, 16, 0, 1546, 1547, 5, 31, 0, 0, 1547, 1561, 1, 0, 0, 0, 1548, 1549, 3, 138, 69, 0, 1549, 1550, 5, 30, 0, 0, 1550, 1551, 5, 186, 0, 0, 1551, 1552, 5, 75, 0, 0, 1552, 1553, 3, 32, 16, 0, 1553, 1554, 5, 31, 0, 0, 1554, 1561, 1, 0, 0, 0, 1555, 1556, 3, 138, 69, 0, 1556, 1557, 5, 30, 0, 0, 1557, 1558, 3, 32, 16, 0, 1558, 1559, 5, 31, 0, 0, 1559, 1561, 1, 0, 0, 0, 1560, 1526, 1, 0, 0, 0, 1560, 1527, 1, 0, 0, 0, 1560, 1528, 1, 0, 0, 0, 1560, 1533, 1, 0, 0, 0, 1560, 1534, 1, 0, 0, 0, 1560, 1541, 1, 0, 0, 0, 1560, 1548, 1, 0, 0, 0, 1560, 1555, 1, 0, 0, 0, 1561, 187, 1, 0, 0, 0, 1562, 1563, 7, 10, 0, 0, 1563, 189, 1, 0, 0, 0, 1564, 1565, 3, 192, 96, 0, 1565, 1566, 3, 160, 80, 0, 1566, 1567, 3, 146, 73, 0, 1567, 1568, 5, 176, 0, 0, 1568, 1570, 3, 264, 132, 0, 1569, 1571, 3, 130, 65, 0, 1570, 1569, 1, 0, 0, 0, 1570, 1571, 1, 0, 0, 0, 1571, 1572, 1, 0, 0, 0, 1572, 1573, 3, 134, 67, 0, 1573, 1599, 1, 0, 0, 0, 1574, 1575, 3, 192, 96, 0, 1575, 1576, 3, 160, 80, 0, 1576, 1577, 3, 146, 73, 0, 1577, 1578, 5, 176, 0, 0, 1578, 1579, 3, 264, 132, 0, 1579, 1580, 3, 218, 109, 0, 1580, 1581, 3, 134, 67, 0, 1581, 1599, 1, 0, 0, 0, 1582, 1583, 3, 192, 96, 0, 1583, 1584, 3, 160, 80, 0, 1584, 1586, 3, 264, 132, 0, 1585, 1587, 3, 130, 65, 0, 1586, 1585, 1, 0, 0, 0, 1586, 1587, 1, 0, 0, 0, 1587, 1588, 1, 0, 0, 0, 1588, 1589, 3, 134, 67, 0, 1589, 1599, 1, 0, 0, 0, 1590, 1591, 3, 192, 96, 0, 1591, 1592, 3, 160, 80, 0, 1592, 1593, 3, 264, 132, 0, 1593, 1594, 3, 218, 109, 0, 1594, 1595, 3, 134, 67, 0, 1595, 1599, 1, 0, 0, 0, 1596, 1599, 3, 196, 98, 0, 1597, 1599, 3, 2, 1, 0, 1598, 1564, 1, 0, 0, 0, 1598, 1574, 1, 0, 0, 0, 1598, 1582, 1, 0, 0, 0, 1598, 1590, 1, 0, 0, 0, 1598, 1596, 1, 0, 0, 0, 1598, 1597, 1, 0, 0, 0, 1599, 191, 1, 0, 0, 0, 1600, 1601, 5, 243, 0, 0, 1601, 1611, 3, 192, 96, 0, 1602, 1603, 5, 244, 0, 0, 1603, 1611, 3, 192, 96, 0, 1604, 1611, 3, 194, 97, 0, 1605, 1606, 5, 112, 0, 0, 1606, 1607, 5, 30, 0, 0, 1607, 1608, 3, 32, 16, 0, 1608, 1609, 5, 31, 0, 0, 1609, 1611, 1, 0, 0, 0, 1610, 1600, 1, 0, 0, 0, 1610, 1602, 1, 0, 0, 0, 1610, 1604, 1, 0, 0, 0, 1610, 1605, 1, 0, 0, 0, 1611, 193, 1, 0, 0, 0, 1612, 1625, 1, 0, 0, 0, 1613, 1625, 5, 245, 0, 0, 1614, 1625, 5, 246, 0, 0, 1615, 1616, 5, 247, 0, 0, 1616, 1625, 5, 248, 0, 0, 1617, 1618, 5, 247, 0, 0, 1618, 1625, 5, 249, 0, 0, 1619, 1620, 5, 247, 0, 0, 1620, 1625, 5, 250, 0, 0, 1621, 1622, 5, 247, 0, 0, 1622, 1625, 5, 251, 0, 0, 1623, 1625, 5, 247, 0, 0, 1624, 1612, 1, 0, 0, 0, 1624, 1613, 1, 0, 0, 0, 1624, 1614, 1, 0, 0, 0, 1624, 1615, 1, 0, 0, 0, 1624, 1617, 1, 0, 0, 0, 1624, 1619, 1, 0, 0, 0, 1624, 1621, 1, 0, 0, 0, 1624, 1623, 1, 0, 0, 0, 1625, 195, 1, 0, 0, 0, 1626, 1627, 5, 113, 0, 0, 1627, 1628, 5, 30, 0, 0, 1628, 1629, 3, 32, 16, 0, 1629, 1630, 5, 31, 0, 0, 1630, 197, 1, 0, 0, 0, 1631, 1632, 5, 226, 0, 0, 1632, 1637, 3, 190, 95, 0, 1633, 1634, 5, 37, 0, 0, 1634, 1637, 3, 200, 100, 0, 1635, 1637, 3, 196, 98, 0, 1636, 1631, 1, 0, 0, 0, 1636, 1633, 1, 0, 0, 0, 1636, 1635, 1, 0, 0, 0, 1637, 199, 1, 0, 0, 0, 1638, 1639, 3, 160, 80, 0, 1639, 1640, 3, 146, 73, 0, 1640, 1641, 5, 176, 0, 0, 1641, 1642, 3, 2, 1, 0, 1642, 1648, 1, 0, 0, 0, 1643, 1644, 3, 160, 80, 0, 1644, 1645, 3, 2, 1, 0, 1645, 1648, 1, 0, 0, 0, 1646, 1648, 3, 2, 1, 0, 1647, 1638, 1, 0, 0, 0, 1647, 1643, 1, 0, 0, 0, 1647, 1646, 1, 0, 0, 0, 1648, 201, 1, 0, 0, 0, 1649, 1650, 3, 146, 73, 0, 1650, 1651, 5, 28, 0, 0, 1651, 1653, 1, 0, 0, 0, 1652, 1649, 1, 0, 0, 0, 1653, 1656, 1, 0, 0, 0, 1654, 1652, 1, 0, 0, 0, 1654, 1655, 1, 0, 0, 0, 1655, 1657, 1, 0, 0, 0, 1656, 1654, 1, 0, 0, 0, 1657, 1658, 3, 146, 73, 0, 1658, 203, 1, 0, 0, 0, 1659, 1665, 1, 0, 0, 0, 1660, 1661, 5, 86, 0, 0, 1661, 1662, 3, 212, 106, 0, 1662, 1663, 5, 87, 0, 0, 1663, 1665, 1, 0, 0, 0, 1664, 1659, 1, 0, 0, 0, 1664, 1660, 1, 0, 0, 0, 1665, 205, 1, 0, 0, 0, 1666, 1678, 5, 266, 0, 0, 1667, 1678, 5, 114, 0, 0, 1668, 1678, 5, 39, 0, 0, 1669, 1678, 5, 200, 0, 0, 1670, 1678, 5, 115, 0, 0, 1671, 1678, 5, 116, 0, 0, 1672, 1673, 5, 70, 0, 0, 1673, 1674, 5, 30, 0, 0, 1674, 1675, 3, 32, 16, 0, 1675, 1676, 5, 31, 0, 0, 1676, 1678, 1, 0, 0, 0, 1677, 1666, 1, 0, 0, 0, 1677, 1667, 1, 0, 0, 0, 1677, 1668, 1, 0, 0, 0, 1677, 1669, 1, 0, 0, 0, 1677, 1670, 1, 0, 0, 0, 1677, 1671, 1, 0, 0, 0, 1677, 1672, 1, 0, 0, 0, 1678, 207, 1, 0, 0, 0, 1679, 1681, 3, 206, 103, 0, 1680, 1679, 1, 0, 0, 0, 1681, 1684, 1, 0, 0, 0, 1682, 1680, 1, 0, 0, 0, 1682, 1683, 1, 0, 0, 0, 1683, 209, 1, 0, 0, 0, 1684, 1682, 1, 0, 0, 0, 1685, 1687, 3, 208, 104, 0, 1686, 1688, 3, 214, 107, 0, 1687, 1686, 1, 0, 0, 0, 1687, 1688, 1, 0, 0, 0, 1688, 1689, 1, 0, 0, 0, 1689, 1690, 3, 2, 1, 0, 1690, 211, 1, 0, 0, 0, 1691, 1692, 3, 210, 105, 0, 1692, 1693, 5, 28, 0, 0, 1693, 1695, 1, 0, 0, 0, 1694, 1691, 1, 0, 0, 0, 1695, 1698, 1, 0, 0, 0, 1696, 1694, 1, 0, 0, 0, 1696, 1697, 1, 0, 0, 0, 1697, 1699, 1, 0, 0, 0, 1698, 1696, 1, 0, 0, 0, 1699, 1700, 3, 210, 105, 0, 1700, 213, 1, 0, 0, 0, 1701, 1702, 5, 30, 0, 0, 1702, 1703, 3, 202, 101, 0, 1703, 1704, 5, 31, 0, 0, 1704, 215, 1, 0, 0, 0, 1705, 1708, 1, 0, 0, 0, 1706, 1708, 3, 218, 109, 0, 1707, 1705, 1, 0, 0, 0, 1707, 1706, 1, 0, 0, 0, 1708, 217, 1, 0, 0, 0, 1709, 1710, 5, 86, 0, 0, 1710, 1711, 5, 42, 0, 0, 1711, 1712, 3, 32, 16, 0, 1712, 1713, 5, 43, 0, 0, 1713, 1714, 5, 87, 0, 0, 1714, 219, 1, 0, 0, 0, 1715, 1716, 3, 256, 128, 0, 1716, 1717, 5, 17, 0, 0, 1717, 1718, 3, 268, 134, 0, 1718, 1719, 5, 18, 0, 0, 1719, 1832, 1, 0, 0, 0, 1720, 1721, 3, 74, 37, 0, 1721, 1722, 5, 17, 0, 0, 1722, 1723, 3, 82, 41, 0, 1723, 1724, 5, 18, 0, 0, 1724, 1832, 1, 0, 0, 0, 1725, 1726, 3, 232, 116, 0, 1726, 1727, 5, 17, 0, 0, 1727, 1728, 3, 236, 118, 0, 1728, 1729, 5, 18, 0, 0, 1729, 1832, 1, 0, 0, 0, 1730, 1731, 3, 240, 120, 0, 1731, 1732, 5, 17, 0, 0, 1732, 1733, 3, 244, 122, 0, 1733, 1734, 5, 18, 0, 0, 1734, 1832, 1, 0, 0, 0, 1735, 1832, 3, 222, 111, 0, 1736, 1832, 3, 296, 148, 0, 1737, 1832, 3, 174, 87, 0, 1738, 1832, 3, 88, 44, 0, 1739, 1832, 3, 342, 171, 0, 1740, 1741, 5, 117, 0, 0, 1741, 1832, 3, 32, 16, 0, 1742, 1743, 5, 118, 0, 0, 1743, 1832, 3, 32, 16, 0, 1744, 1745, 3, 354, 177, 0, 1745, 1746, 5, 17, 0, 0, 1746, 1747, 3, 358, 179, 0, 1747, 1748, 5, 18, 0, 0, 1748, 1832, 1, 0, 0, 0, 1749, 1750, 5, 302, 0, 0, 1750, 1751, 3, 146, 73, 0, 1751, 1752, 5, 176, 0, 0, 1752, 1753, 3, 264, 132, 0, 1753, 1754, 5, 119, 0, 0, 1754, 1755, 3, 192, 96, 0, 1755, 1756, 3, 160, 80, 0, 1756, 1757, 3, 146, 73, 0, 1757, 1758, 5, 176, 0, 0, 1758, 1759, 3, 264, 132, 0, 1759, 1760, 3, 134, 67, 0, 1760, 1832, 1, 0, 0, 0, 1761, 1762, 5, 302, 0, 0, 1762, 1763, 5, 226, 0, 0, 1763, 1764, 3, 192, 96, 0, 1764, 1765, 3, 160, 80, 0, 1765, 1766, 3, 146, 73, 0, 1766, 1767, 5, 176, 0, 0, 1767, 1768, 3, 264, 132, 0, 1768, 1769, 3, 216, 108, 0, 1769, 1770, 3, 134, 67, 0, 1770, 1771, 5, 119, 0, 0, 1771, 1772, 5, 226, 0, 0, 1772, 1773, 3, 192, 96, 0, 1773, 1774, 3, 160, 80, 0, 1774, 1775, 3, 146, 73, 0, 1775, 1776, 5, 176, 0, 0, 1776, 1777, 3, 264, 132, 0, 1777, 1778, 3, 216, 108, 0, 1778, 1779, 3, 134, 67, 0, 1779, 1832, 1, 0, 0, 0, 1780, 1832, 3, 26, 13, 0, 1781, 1832, 3, 40, 20, 0, 1782, 1783, 5, 255, 0, 0, 1783, 1784, 5, 196, 0, 0, 1784, 1785, 5, 42, 0, 0, 1785, 1786, 3, 32, 16, 0, 1786, 1790, 5, 43, 0, 0, 1787, 1789, 3, 342, 171, 0, 1788, 1787, 1, 0, 0, 0, 1789, 1792, 1, 0, 0, 0, 1790, 1788, 1, 0, 0, 0, 1790, 1791, 1, 0, 0, 0, 1791, 1832, 1, 0, 0, 0, 1792, 1790, 1, 0, 0, 0, 1793, 1794, 5, 255, 0, 0, 1794, 1795, 5, 196, 0, 0, 1795, 1799, 3, 2, 1, 0, 1796, 1798, 3, 342, 171, 0, 1797, 1796, 1, 0, 0, 0, 1798, 1801, 1, 0, 0, 0, 1799, 1797, 1, 0, 0, 0, 1799, 1800, 1, 0, 0, 0, 1800, 1832, 1, 0, 0, 0, 1801, 1799, 1, 0, 0, 0, 1802, 1803, 5, 255, 0, 0, 1803, 1804, 5, 256, 0, 0, 1804, 1805, 5, 42, 0, 0, 1805, 1806, 3, 32, 16, 0, 1806, 1807, 5, 43, 0, 0, 1807, 1808, 5, 28, 0, 0, 1808, 1812, 3, 146, 73, 0, 1809, 1811, 3, 342, 171, 0, 1810, 1809, 1, 0, 0, 0, 1811, 1814, 1, 0, 0, 0, 1812, 1810, 1, 0, 0, 0, 1812, 1813, 1, 0, 0, 0, 1813, 1832, 1, 0, 0, 0, 1814, 1812, 1, 0, 0, 0, 1815, 1816, 5, 255, 0, 0, 1816, 1817, 5, 256, 0, 0, 1817, 1818, 3, 2, 1, 0, 1818, 1819, 5, 28, 0, 0, 1819, 1823, 3, 146, 73, 0, 1820, 1822, 3, 342, 171, 0, 1821, 1820, 1, 0, 0, 0, 1822, 1825, 1, 0, 0, 0, 1823, 1821, 1, 0, 0, 0, 1823, 1824, 1, 0, 0, 0, 1824, 1832, 1, 0, 0, 0, 1825, 1823, 1, 0, 0, 0, 1826, 1827, 5, 120, 0, 0, 1827, 1828, 5, 196, 0, 0, 1828, 1829, 3, 146, 73, 0, 1829, 1830, 3, 44, 22, 0, 1830, 1832, 1, 0, 0, 0, 1831, 1715, 1, 0, 0, 0, 1831, 1720, 1, 0, 0, 0, 1831, 1725, 1, 0, 0, 0, 1831, 1730, 1, 0, 0, 0, 1831, 1735, 1, 0, 0, 0, 1831, 1736, 1, 0, 0, 0, 1831, 1737, 1, 0, 0, 0, 1831, 1738, 1, 0, 0, 0, 1831, 1739, 1, 0, 0, 0, 1831, 1740, 1, 0, 0, 0, 1831, 1742, 1, 0, 0, 0, 1831, 1744, 1, 0, 0, 0, 1831, 1749, 1, 0, 0, 0, 1831, 1761, 1, 0, 0, 0, 1831, 1780, 1, 0, 0, 0, 1831, 1781, 1, 0, 0, 0, 1831, 1782, 1, 0, 0, 0, 1831, 1793, 1, 0, 0, 0, 1831, 1802, 1, 0, 0, 0, 1831, 1815, 1, 0, 0, 0, 1831, 1826, 1, 0, 0, 0, 1832, 221, 1, 0, 0, 0, 1833, 1834, 5, 121, 0, 0, 1834, 1843, 3, 230, 115, 0, 1835, 1842, 3, 224, 112, 0, 1836, 1837, 5, 122, 0, 0, 1837, 1838, 5, 30, 0, 0, 1838, 1839, 3, 250, 125, 0, 1839, 1840, 5, 31, 0, 0, 1840, 1842, 1, 0, 0, 0, 1841, 1835, 1, 0, 0, 0, 1841, 1836, 1, 0, 0, 0, 1842, 1845, 1, 0, 0, 0, 1843, 1841, 1, 0, 0, 0, 1843, 1844, 1, 0, 0, 0, 1844, 1846, 1, 0, 0, 0, 1845, 1843, 1, 0, 0, 0, 1846, 1847, 3, 160, 80, 0, 1847, 1848, 3, 2, 1, 0, 1848, 1849, 3, 226, 113, 0, 1849, 1850, 3, 228, 114, 0, 1850, 223, 1, 0, 0, 0, 1851, 1871, 5, 123, 0, 0, 1852, 1871, 5, 51, 0, 0, 1853, 1871, 5, 52, 0, 0, 1854, 1871, 5, 63, 0, 0, 1855, 1871, 5, 124, 0, 0, 1856, 1871, 5, 69, 0, 0, 1857, 1871, 5, 68, 0, 0, 1858, 1871, 5, 64, 0, 0, 1859, 1871, 5, 65, 0, 0, 1860, 1871, 5, 66, 0, 0, 1861, 1871, 5, 125, 0, 0, 1862, 1871, 5, 126, 0, 0, 1863, 1871, 5, 127, 0, 0, 1864, 1871, 5, 16, 0, 0, 1865, 1866, 5, 70, 0, 0, 1866, 1867, 5, 30, 0, 0, 1867, 1868, 3, 32, 16, 0, 1868, 1869, 5, 31, 0, 0, 1869, 1871, 1, 0, 0, 0, 1870, 1851, 1, 0, 0, 0, 1870, 1852, 1, 0, 0, 0, 1870, 1853, 1, 0, 0, 0, 1870, 1854, 1, 0, 0, 0, 1870, 1855, 1, 0, 0, 0, 1870, 1856, 1, 0, 0, 0, 1870, 1857, 1, 0, 0, 0, 1870, 1858, 1, 0, 0, 0, 1870, 1859, 1, 0, 0, 0, 1870, 1860, 1, 0, 0, 0, 1870, 1861, 1, 0, 0, 0, 1870, 1862, 1, 0, 0, 0, 1870, 1863, 1, 0, 0, 0, 1870, 1864, 1, 0, 0, 0, 1870, 1865, 1, 0, 0, 0, 1871, 225, 1, 0, 0, 0, 1872, 1878, 1, 0, 0, 0, 1873, 1874, 5, 44, 0, 0, 1874, 1878, 3, 0, 0, 0, 1875, 1876, 5, 44, 0, 0, 1876, 1878, 3, 32, 16, 0, 1877, 1872, 1, 0, 0, 0, 1877, 1873, 1, 0, 0, 0, 1877, 1875, 1, 0, 0, 0, 1878, 227, 1, 0, 0, 0, 1879, 1883, 1, 0, 0, 0, 1880, 1881, 5, 36, 0, 0, 1881, 1883, 3, 316, 158, 0, 1882, 1879, 1, 0, 0, 0, 1882, 1880, 1, 0, 0, 0, 1883, 229, 1, 0, 0, 0, 1884, 1890, 1, 0, 0, 0, 1885, 1886, 5, 42, 0, 0, 1886, 1887, 3, 32, 16, 0, 1887, 1888, 5, 43, 0, 0, 1888, 1890, 1, 0, 0, 0, 1889, 1884, 1, 0, 0, 0, 1889, 1885, 1, 0, 0, 0, 1890, 231, 1, 0, 0, 0, 1891, 1895, 5, 128, 0, 0, 1892, 1894, 3, 234, 117, 0, 1893, 1892, 1, 0, 0, 0, 1894, 1897, 1, 0, 0, 0, 1895, 1893, 1, 0, 0, 0, 1895, 1896, 1, 0, 0, 0, 1896, 1898, 1, 0, 0, 0, 1897, 1895, 1, 0, 0, 0, 1898, 1899, 3, 146, 73, 0, 1899, 1900, 3, 2, 1, 0, 1900, 1910, 1, 0, 0, 0, 1901, 1905, 5, 128, 0, 0, 1902, 1904, 3, 234, 117, 0, 1903, 1902, 1, 0, 0, 0, 1904, 1907, 1, 0, 0, 0, 1905, 1903, 1, 0, 0, 0, 1905, 1906, 1, 0, 0, 0, 1906, 1908, 1, 0, 0, 0, 1907, 1905, 1, 0, 0, 0, 1908, 1910, 3, 2, 1, 0, 1909, 1891, 1, 0, 0, 0, 1909, 1901, 1, 0, 0, 0, 1910, 233, 1, 0, 0, 0, 1911, 1912, 7, 11, 0, 0, 1912, 235, 1, 0, 0, 0, 1913, 1915, 3, 238, 119, 0, 1914, 1913, 1, 0, 0, 0, 1915, 1918, 1, 0, 0, 0, 1916, 1914, 1, 0, 0, 0, 1916, 1917, 1, 0, 0, 0, 1917, 237, 1, 0, 0, 0, 1918, 1916, 1, 0, 0, 0, 1919, 1920, 5, 129, 0, 0, 1920, 1932, 3, 190, 95, 0, 1921, 1922, 5, 130, 0, 0, 1922, 1932, 3, 190, 95, 0, 1923, 1924, 5, 131, 0, 0, 1924, 1932, 3, 190, 95, 0, 1925, 1926, 5, 132, 0, 0, 1926, 1932, 3, 190, 95, 0, 1927, 1932, 3, 88, 44, 0, 1928, 1932, 3, 342, 171, 0, 1929, 1932, 3, 26, 13, 0, 1930, 1932, 3, 40, 20, 0, 1931, 1919, 1, 0, 0, 0, 1931, 1921, 1, 0, 0, 0, 1931, 1923, 1, 0, 0, 0, 1931, 1925, 1, 0, 0, 0, 1931, 1927, 1, 0, 0, 0, 1931, 1928, 1, 0, 0, 0, 1931, 1929, 1, 0, 0, 0, 1931, 1930, 1, 0, 0, 0, 1932, 239, 1, 0, 0, 0, 1933, 1937, 5, 133, 0, 0, 1934, 1936, 3, 242, 121, 0, 1935, 1934, 1, 0, 0, 0, 1936, 1939, 1, 0, 0, 0, 1937, 1935, 1, 0, 0, 0, 1937, 1938, 1, 0, 0, 0, 1938, 1940, 1, 0, 0, 0, 1939, 1937, 1, 0, 0, 0, 1940, 1941, 3, 192, 96, 0, 1941, 1942, 3, 160, 80, 0, 1942, 1943, 3, 2, 1, 0, 1943, 1944, 3, 134, 67, 0, 1944, 1945, 3, 228, 114, 0, 1945, 241, 1, 0, 0, 0, 1946, 1947, 7, 11, 0, 0, 1947, 243, 1, 0, 0, 0, 1948, 1950, 3, 246, 123, 0, 1949, 1948, 1, 0, 0, 0, 1950, 1953, 1, 0, 0, 0, 1951, 1949, 1, 0, 0, 0, 1951, 1952, 1, 0, 0, 0, 1952, 245, 1, 0, 0, 0, 1953, 1951, 1, 0, 0, 0, 1954, 1955, 5, 134, 0, 0, 1955, 1965, 3, 190, 95, 0, 1956, 1957, 5, 135, 0, 0, 1957, 1965, 3, 190, 95, 0, 1958, 1959, 5, 132, 0, 0, 1959, 1965, 3, 190, 95, 0, 1960, 1965, 3, 342, 171, 0, 1961, 1965, 3, 88, 44, 0, 1962, 1965, 3, 26, 13, 0, 1963, 1965, 3, 40, 20, 0, 1964, 1954, 1, 0, 0, 0, 1964, 1956, 1, 0, 0, 0, 1964, 1958, 1, 0, 0, 0, 1964, 1960, 1, 0, 0, 0, 1964, 1961, 1, 0, 0, 0, 1964, 1962, 1, 0, 0, 0, 1964, 1963, 1, 0, 0, 0, 1965, 247, 1, 0, 0, 0, 1966, 1973, 1, 0, 0, 0, 1967, 1968, 5, 122, 0, 0, 1968, 1969, 5, 30, 0, 0, 1969, 1970, 3, 250, 125, 0, 1970, 1971, 5, 31, 0, 0, 1971, 1973, 1, 0, 0, 0, 1972, 1966, 1, 0, 0, 0, 1972, 1967, 1, 0, 0, 0, 1973, 249, 1, 0, 0, 0, 1974, 1984, 3, 148, 74, 0, 1975, 1977, 5, 17, 0, 0, 1976, 1978, 3, 314, 157, 0, 1977, 1976, 1, 0, 0, 0, 1978, 1979, 1, 0, 0, 0, 1979, 1977, 1, 0, 0, 0, 1979, 1980, 1, 0, 0, 0, 1980, 1981, 1, 0, 0, 0, 1981, 1982, 5, 18, 0, 0, 1982, 1984, 1, 0, 0, 0, 1983, 1974, 1, 0, 0, 0, 1983, 1975, 1, 0, 0, 0, 1984, 251, 1, 0, 0, 0, 1985, 1987, 3, 254, 127, 0, 1986, 1985, 1, 0, 0, 0, 1987, 1990, 1, 0, 0, 0, 1988, 1986, 1, 0, 0, 0, 1988, 1989, 1, 0, 0, 0, 1989, 253, 1, 0, 0, 0, 1990, 1988, 1, 0, 0, 0, 1991, 1992, 5, 42, 0, 0, 1992, 1993, 5, 136, 0, 0, 1993, 2005, 5, 43, 0, 0, 1994, 1995, 5, 42, 0, 0, 1995, 1996, 5, 137, 0, 0, 1996, 2005, 5, 43, 0, 0, 1997, 1998, 5, 42, 0, 0, 1998, 1999, 5, 138, 0, 0, 1999, 2005, 5, 43, 0, 0, 2000, 2001, 5, 42, 0, 0, 2001, 2002, 3, 32, 16, 0, 2002, 2003, 5, 43, 0, 0, 2003, 2005, 1, 0, 0, 0, 2004, 1991, 1, 0, 0, 0, 2004, 1994, 1, 0, 0, 0, 2004, 1997, 1, 0, 0, 0, 2004, 2000, 1, 0, 0, 0, 2005, 255, 1, 0, 0, 0, 2006, 2011, 5, 139, 0, 0, 2007, 2010, 3, 258, 129, 0, 2008, 2010, 3, 260, 130, 0, 2009, 2007, 1, 0, 0, 0, 2009, 2008, 1, 0, 0, 0, 2010, 2013, 1, 0, 0, 0, 2011, 2009, 1, 0, 0, 0, 2011, 2012, 1, 0, 0, 0, 2012, 2014, 1, 0, 0, 0, 2013, 2011, 1, 0, 0, 0, 2014, 2015, 3, 192, 96, 0, 2015, 2016, 3, 252, 126, 0, 2016, 2017, 3, 160, 80, 0, 2017, 2018, 3, 248, 124, 0, 2018, 2019, 3, 264, 132, 0, 2019, 2020, 3, 204, 102, 0, 2020, 2024, 3, 134, 67, 0, 2021, 2023, 3, 266, 133, 0, 2022, 2021, 1, 0, 0, 0, 2023, 2026, 1, 0, 0, 0, 2024, 2022, 1, 0, 0, 0, 2024, 2025, 1, 0, 0, 0, 2025, 257, 1, 0, 0, 0, 2026, 2024, 1, 0, 0, 0, 2027, 2051, 5, 123, 0, 0, 2028, 2051, 5, 51, 0, 0, 2029, 2051, 5, 52, 0, 0, 2030, 2051, 5, 63, 0, 0, 2031, 2051, 5, 140, 0, 0, 2032, 2051, 5, 68, 0, 0, 2033, 2051, 5, 141, 0, 0, 2034, 2051, 5, 142, 0, 0, 2035, 2051, 5, 54, 0, 0, 2036, 2051, 5, 64, 0, 0, 2037, 2051, 5, 65, 0, 0, 2038, 2051, 5, 66, 0, 0, 2039, 2051, 5, 125, 0, 0, 2040, 2051, 5, 143, 0, 0, 2041, 2051, 5, 144, 0, 0, 2042, 2051, 5, 69, 0, 0, 2043, 2051, 5, 145, 0, 0, 2044, 2051, 5, 146, 0, 0, 2045, 2046, 5, 70, 0, 0, 2046, 2047, 5, 30, 0, 0, 2047, 2048, 3, 32, 16, 0, 2048, 2049, 5, 31, 0, 0, 2049, 2051, 1, 0, 0, 0, 2050, 2027, 1, 0, 0, 0, 2050, 2028, 1, 0, 0, 0, 2050, 2029, 1, 0, 0, 0, 2050, 2030, 1, 0, 0, 0, 2050, 2031, 1, 0, 0, 0, 2050, 2032, 1, 0, 0, 0, 2050, 2033, 1, 0, 0, 0, 2050, 2034, 1, 0, 0, 0, 2050, 2035, 1, 0, 0, 0, 2050, 2036, 1, 0, 0, 0, 2050, 2037, 1, 0, 0, 0, 2050, 2038, 1, 0, 0, 0, 2050, 2039, 1, 0, 0, 0, 2050, 2040, 1, 0, 0, 0, 2050, 2041, 1, 0, 0, 0, 2050, 2042, 1, 0, 0, 0, 2050, 2043, 1, 0, 0, 0, 2050, 2044, 1, 0, 0, 0, 2050, 2045, 1, 0, 0, 0, 2051, 259, 1, 0, 0, 0, 2052, 2053, 5, 147, 0, 0, 2053, 2059, 5, 30, 0, 0, 2054, 2057, 3, 6, 3, 0, 2055, 2056, 5, 34, 0, 0, 2056, 2058, 3, 6, 3, 0, 2057, 2055, 1, 0, 0, 0, 2057, 2058, 1, 0, 0, 0, 2058, 2060, 1, 0, 0, 0, 2059, 2054, 1, 0, 0, 0, 2059, 2060, 1, 0, 0, 0, 2060, 2064, 1, 0, 0, 0, 2061, 2063, 3, 262, 131, 0, 2062, 2061, 1, 0, 0, 0, 2063, 2066, 1, 0, 0, 0, 2064, 2062, 1, 0, 0, 0, 2064, 2065, 1, 0, 0, 0, 2065, 2067, 1, 0, 0, 0, 2066, 2064, 1, 0, 0, 0, 2067, 2071, 5, 31, 0, 0, 2068, 2069, 5, 147, 0, 0, 2069, 2071, 5, 85, 0, 0, 2070, 2052, 1, 0, 0, 0, 2070, 2068, 1, 0, 0, 0, 2071, 261, 1, 0, 0, 0, 2072, 2100, 5, 148, 0, 0, 2073, 2100, 5, 224, 0, 0, 2074, 2100, 5, 57, 0, 0, 2075, 2100, 5, 58, 0, 0, 2076, 2100, 5, 149, 0, 0, 2077, 2100, 5, 150, 0, 0, 2078, 2100, 5, 248, 0, 0, 2079, 2100, 5, 249, 0, 0, 2080, 2100, 5, 250, 0, 0, 2081, 2100, 5, 251, 0, 0, 2082, 2083, 5, 151, 0, 0, 2083, 2084, 5, 75, 0, 0, 2084, 2100, 5, 152, 0, 0, 2085, 2086, 5, 151, 0, 0, 2086, 2087, 5, 75, 0, 0, 2087, 2100, 5, 153, 0, 0, 2088, 2089, 5, 154, 0, 0, 2089, 2090, 5, 75, 0, 0, 2090, 2100, 5, 152, 0, 0, 2091, 2092, 5, 154, 0, 0, 2092, 2093, 5, 75, 0, 0, 2093, 2100, 5, 153, 0, 0, 2094, 2095, 5, 70, 0, 0, 2095, 2096, 5, 30, 0, 0, 2096, 2097, 3, 32, 16, 0, 2097, 2098, 5, 31, 0, 0, 2098, 2100, 1, 0, 0, 0, 2099, 2072, 1, 0, 0, 0, 2099, 2073, 1, 0, 0, 0, 2099, 2074, 1, 0, 0, 0, 2099, 2075, 1, 0, 0, 0, 2099, 2076, 1, 0, 0, 0, 2099, 2077, 1, 0, 0, 0, 2099, 2078, 1, 0, 0, 0, 2099, 2079, 1, 0, 0, 0, 2099, 2080, 1, 0, 0, 0, 2099, 2081, 1, 0, 0, 0, 2099, 2082, 1, 0, 0, 0, 2099, 2085, 1, 0, 0, 0, 2099, 2088, 1, 0, 0, 0, 2099, 2091, 1, 0, 0, 0, 2099, 2094, 1, 0, 0, 0, 2100, 263, 1, 0, 0, 0, 2101, 2105, 5, 116, 0, 0, 2102, 2105, 5, 155, 0, 0, 2103, 2105, 3, 2, 1, 0, 2104, 2101, 1, 0, 0, 0, 2104, 2102, 1, 0, 0, 0, 2104, 2103, 1, 0, 0, 0, 2105, 265, 1, 0, 0, 0, 2106, 2128, 5, 1, 0, 0, 2107, 2128, 5, 2, 0, 0, 2108, 2128, 5, 156, 0, 0, 2109, 2128, 5, 3, 0, 0, 2110, 2128, 5, 4, 0, 0, 2111, 2128, 5, 247, 0, 0, 2112, 2128, 5, 5, 0, 0, 2113, 2128, 5, 6, 0, 0, 2114, 2128, 5, 7, 0, 0, 2115, 2128, 5, 8, 0, 0, 2116, 2128, 5, 9, 0, 0, 2117, 2128, 5, 10, 0, 0, 2118, 2128, 5, 11, 0, 0, 2119, 2128, 5, 12, 0, 0, 2120, 2128, 5, 13, 0, 0, 2121, 2128, 5, 14, 0, 0, 2122, 2123, 5, 70, 0, 0, 2123, 2124, 5, 30, 0, 0, 2124, 2125, 3, 32, 16, 0, 2125, 2126, 5, 31, 0, 0, 2126, 2128, 1, 0, 0, 0, 2127, 2106, 1, 0, 0, 0, 2127, 2107, 1, 0, 0, 0, 2127, 2108, 1, 0, 0, 0, 2127, 2109, 1, 0, 0, 0, 2127, 2110, 1, 0, 0, 0, 2127, 2111, 1, 0, 0, 0, 2127, 2112, 1, 0, 0, 0, 2127, 2113, 1, 0, 0, 0, 2127, 2114, 1, 0, 0, 0, 2127, 2115, 1, 0, 0, 0, 2127, 2116, 1, 0, 0, 0, 2127, 2117, 1, 0, 0, 0, 2127, 2118, 1, 0, 0, 0, 2127, 2119, 1, 0, 0, 0, 2127, 2120, 1, 0, 0, 0, 2127, 2121, 1, 0, 0, 0, 2127, 2122, 1, 0, 0, 0, 2128, 267, 1, 0, 0, 0, 2129, 2131, 3, 270, 135, 0, 2130, 2129, 1, 0, 0, 0, 2131, 2134, 1, 0, 0, 0, 2132, 2130, 1, 0, 0, 0, 2132, 2133, 1, 0, 0, 0, 2133, 269, 1, 0, 0, 0, 2134, 2132, 1, 0, 0, 0, 2135, 2244, 3, 126, 63, 0, 2136, 2137, 5, 296, 0, 0, 2137, 2244, 3, 32, 16, 0, 2138, 2244, 3, 278, 139, 0, 2139, 2140, 5, 297, 0, 0, 2140, 2244, 3, 32, 16, 0, 2141, 2142, 5, 300, 0, 0, 2142, 2244, 3, 134, 67, 0, 2143, 2144, 5, 300, 0, 0, 2144, 2145, 5, 157, 0, 0, 2145, 2244, 3, 134, 67, 0, 2146, 2244, 5, 298, 0, 0, 2147, 2244, 5, 299, 0, 0, 2148, 2244, 3, 296, 148, 0, 2149, 2244, 3, 272, 136, 0, 2150, 2244, 3, 174, 87, 0, 2151, 2244, 3, 88, 44, 0, 2152, 2244, 3, 26, 13, 0, 2153, 2244, 3, 274, 137, 0, 2154, 2244, 3, 40, 20, 0, 2155, 2156, 5, 301, 0, 0, 2156, 2157, 5, 42, 0, 0, 2157, 2158, 3, 32, 16, 0, 2158, 2159, 5, 43, 0, 0, 2159, 2244, 1, 0, 0, 0, 2160, 2161, 5, 301, 0, 0, 2161, 2162, 5, 42, 0, 0, 2162, 2163, 3, 32, 16, 0, 2163, 2164, 5, 43, 0, 0, 2164, 2165, 5, 34, 0, 0, 2165, 2166, 3, 0, 0, 0, 2166, 2244, 1, 0, 0, 0, 2167, 2168, 5, 303, 0, 0, 2168, 2169, 3, 32, 16, 0, 2169, 2170, 5, 75, 0, 0, 2170, 2171, 3, 32, 16, 0, 2171, 2244, 1, 0, 0, 0, 2172, 2173, 5, 302, 0, 0, 2173, 2174, 3, 146, 73, 0, 2174, 2175, 5, 176, 0, 0, 2175, 2176, 3, 264, 132, 0, 2176, 2244, 1, 0, 0, 0, 2177, 2178, 5, 302, 0, 0, 2178, 2179, 5, 226, 0, 0, 2179, 2180, 3, 192, 96, 0, 2180, 2181, 3, 160, 80, 0, 2181, 2182, 3, 146, 73, 0, 2182, 2183, 5, 176, 0, 0, 2183, 2184, 3, 264, 132, 0, 2184, 2185, 3, 216, 108, 0, 2185, 2186, 3, 134, 67, 0, 2186, 2244, 1, 0, 0, 0, 2187, 2244, 3, 276, 138, 0, 2188, 2189, 5, 255, 0, 0, 2189, 2190, 5, 196, 0, 0, 2190, 2191, 5, 42, 0, 0, 2191, 2192, 3, 32, 16, 0, 2192, 2196, 5, 43, 0, 0, 2193, 2195, 3, 342, 171, 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, 2244, 1, 0, 0, 0, 2198, 2196, 1, 0, 0, 0, 2199, 2200, 5, 255, 0, 0, 2200, 2201, 5, 196, 0, 0, 2201, 2205, 3, 2, 1, 0, 2202, 2204, 3, 342, 171, 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, 2244, 1, 0, 0, 0, 2207, 2205, 1, 0, 0, 0, 2208, 2209, 5, 255, 0, 0, 2209, 2210, 5, 256, 0, 0, 2210, 2211, 5, 42, 0, 0, 2211, 2212, 3, 32, 16, 0, 2212, 2213, 5, 43, 0, 0, 2213, 2214, 5, 28, 0, 0, 2214, 2218, 3, 146, 73, 0, 2215, 2217, 3, 342, 171, 0, 2216, 2215, 1, 0, 0, 0, 2217, 2220, 1, 0, 0, 0, 2218, 2216, 1, 0, 0, 0, 2218, 2219, 1, 0, 0, 0, 2219, 2244, 1, 0, 0, 0, 2220, 2218, 1, 0, 0, 0, 2221, 2222, 5, 255, 0, 0, 2222, 2223, 5, 256, 0, 0, 2223, 2224, 3, 2, 1, 0, 2224, 2225, 5, 28, 0, 0, 2225, 2229, 3, 146, 73, 0, 2226, 2228, 3, 342, 171, 0, 2227, 2226, 1, 0, 0, 0, 2228, 2231, 1, 0, 0, 0, 2229, 2227, 1, 0, 0, 0, 2229, 2230, 1, 0, 0, 0, 2230, 2244, 1, 0, 0, 0, 2231, 2229, 1, 0, 0, 0, 2232, 2233, 5, 255, 0, 0, 2233, 2234, 5, 42, 0, 0, 2234, 2235, 3, 32, 16, 0, 2235, 2236, 5, 43, 0, 0, 2236, 2240, 3, 228, 114, 0, 2237, 2239, 3, 342, 171, 0, 2238, 2237, 1, 0, 0, 0, 2239, 2242, 1, 0, 0, 0, 2240, 2238, 1, 0, 0, 0, 2240, 2241, 1, 0, 0, 0, 2241, 2244, 1, 0, 0, 0, 2242, 2240, 1, 0, 0, 0, 2243, 2135, 1, 0, 0, 0, 2243, 2136, 1, 0, 0, 0, 2243, 2138, 1, 0, 0, 0, 2243, 2139, 1, 0, 0, 0, 2243, 2141, 1, 0, 0, 0, 2243, 2143, 1, 0, 0, 0, 2243, 2146, 1, 0, 0, 0, 2243, 2147, 1, 0, 0, 0, 2243, 2148, 1, 0, 0, 0, 2243, 2149, 1, 0, 0, 0, 2243, 2150, 1, 0, 0, 0, 2243, 2151, 1, 0, 0, 0, 2243, 2152, 1, 0, 0, 0, 2243, 2153, 1, 0, 0, 0, 2243, 2154, 1, 0, 0, 0, 2243, 2155, 1, 0, 0, 0, 2243, 2160, 1, 0, 0, 0, 2243, 2167, 1, 0, 0, 0, 2243, 2172, 1, 0, 0, 0, 2243, 2177, 1, 0, 0, 0, 2243, 2187, 1, 0, 0, 0, 2243, 2188, 1, 0, 0, 0, 2243, 2199, 1, 0, 0, 0, 2243, 2208, 1, 0, 0, 0, 2243, 2221, 1, 0, 0, 0, 2243, 2232, 1, 0, 0, 0, 2244, 271, 1, 0, 0, 0, 2245, 2246, 3, 0, 0, 0, 2246, 2247, 5, 75, 0, 0, 2247, 273, 1, 0, 0, 0, 2248, 2251, 3, 44, 22, 0, 2249, 2251, 3, 46, 23, 0, 2250, 2248, 1, 0, 0, 0, 2250, 2249, 1, 0, 0, 0, 2251, 275, 1, 0, 0, 0, 2252, 2253, 5, 17, 0, 0, 2253, 2254, 3, 268, 134, 0, 2254, 2255, 5, 18, 0, 0, 2255, 277, 1, 0, 0, 0, 2256, 2257, 3, 282, 141, 0, 2257, 2258, 3, 280, 140, 0, 2258, 279, 1, 0, 0, 0, 2259, 2261, 3, 284, 142, 0, 2260, 2259, 1, 0, 0, 0, 2261, 2262, 1, 0, 0, 0, 2262, 2260, 1, 0, 0, 0, 2262, 2263, 1, 0, 0, 0, 2263, 281, 1, 0, 0, 0, 2264, 2265, 5, 158, 0, 0, 2265, 2277, 3, 276, 138, 0, 2266, 2267, 5, 158, 0, 0, 2267, 2268, 3, 0, 0, 0, 2268, 2269, 5, 159, 0, 0, 2269, 2270, 3, 0, 0, 0, 2270, 2277, 1, 0, 0, 0, 2271, 2272, 5, 158, 0, 0, 2272, 2273, 3, 32, 16, 0, 2273, 2274, 5, 159, 0, 0, 2274, 2275, 3, 32, 16, 0, 2275, 2277, 1, 0, 0, 0, 2276, 2264, 1, 0, 0, 0, 2276, 2266, 1, 0, 0, 0, 2276, 2271, 1, 0, 0, 0, 2277, 283, 1, 0, 0, 0, 2278, 2279, 3, 288, 144, 0, 2279, 2280, 3, 294, 147, 0, 2280, 2291, 1, 0, 0, 0, 2281, 2282, 3, 286, 143, 0, 2282, 2283, 3, 294, 147, 0, 2283, 2291, 1, 0, 0, 0, 2284, 2285, 3, 290, 145, 0, 2285, 2286, 3, 294, 147, 0, 2286, 2291, 1, 0, 0, 0, 2287, 2288, 3, 292, 146, 0, 2288, 2289, 3, 294, 147, 0, 2289, 2291, 1, 0, 0, 0, 2290, 2278, 1, 0, 0, 0, 2290, 2281, 1, 0, 0, 0, 2290, 2284, 1, 0, 0, 0, 2290, 2287, 1, 0, 0, 0, 2291, 285, 1, 0, 0, 0, 2292, 2293, 5, 160, 0, 0, 2293, 2299, 3, 276, 138, 0, 2294, 2295, 5, 160, 0, 0, 2295, 2299, 3, 0, 0, 0, 2296, 2297, 5, 160, 0, 0, 2297, 2299, 3, 32, 16, 0, 2298, 2292, 1, 0, 0, 0, 2298, 2294, 1, 0, 0, 0, 2298, 2296, 1, 0, 0, 0, 2299, 287, 1, 0, 0, 0, 2300, 2301, 5, 161, 0, 0, 2301, 2302, 3, 146, 73, 0, 2302, 289, 1, 0, 0, 0, 2303, 2304, 5, 162, 0, 0, 2304, 291, 1, 0, 0, 0, 2305, 2306, 5, 163, 0, 0, 2306, 293, 1, 0, 0, 0, 2307, 2319, 3, 276, 138, 0, 2308, 2309, 5, 164, 0, 0, 2309, 2310, 3, 0, 0, 0, 2310, 2311, 5, 159, 0, 0, 2311, 2312, 3, 0, 0, 0, 2312, 2319, 1, 0, 0, 0, 2313, 2314, 5, 164, 0, 0, 2314, 2315, 3, 32, 16, 0, 2315, 2316, 5, 159, 0, 0, 2316, 2317, 3, 32, 16, 0, 2317, 2319, 1, 0, 0, 0, 2318, 2307, 1, 0, 0, 0, 2318, 2308, 1, 0, 0, 0, 2318, 2313, 1, 0, 0, 0, 2319, 295, 1, 0, 0, 0, 2320, 2321, 3, 298, 149, 0, 2321, 2322, 3, 302, 151, 0, 2322, 297, 1, 0, 0, 0, 2323, 2324, 5, 165, 0, 0, 2324, 2325, 3, 300, 150, 0, 2325, 2326, 3, 0, 0, 0, 2326, 2327, 5, 36, 0, 0, 2327, 2331, 1, 0, 0, 0, 2328, 2329, 5, 165, 0, 0, 2329, 2331, 3, 300, 150, 0, 2330, 2323, 1, 0, 0, 0, 2330, 2328, 1, 0, 0, 0, 2331, 299, 1, 0, 0, 0, 2332, 2336, 1, 0, 0, 0, 2333, 2336, 5, 166, 0, 0, 2334, 2336, 5, 2, 0, 0, 2335, 2332, 1, 0, 0, 0, 2335, 2333, 1, 0, 0, 0, 2335, 2334, 1, 0, 0, 0, 2336, 301, 1, 0, 0, 0, 2337, 2338, 5, 17, 0, 0, 2338, 2339, 3, 304, 152, 0, 2339, 2340, 5, 18, 0, 0, 2340, 2347, 1, 0, 0, 0, 2341, 2343, 3, 308, 154, 0, 2342, 2341, 1, 0, 0, 0, 2343, 2344, 1, 0, 0, 0, 2344, 2342, 1, 0, 0, 0, 2344, 2345, 1, 0, 0, 0, 2345, 2347, 1, 0, 0, 0, 2346, 2337, 1, 0, 0, 0, 2346, 2342, 1, 0, 0, 0, 2347, 303, 1, 0, 0, 0, 2348, 2349, 3, 308, 154, 0, 2349, 2350, 5, 28, 0, 0, 2350, 2352, 1, 0, 0, 0, 2351, 2348, 1, 0, 0, 0, 2352, 2355, 1, 0, 0, 0, 2353, 2351, 1, 0, 0, 0, 2353, 2354, 1, 0, 0, 0, 2354, 2356, 1, 0, 0, 0, 2355, 2353, 1, 0, 0, 0, 2356, 2357, 3, 308, 154, 0, 2357, 305, 1, 0, 0, 0, 2358, 2364, 1, 0, 0, 0, 2359, 2360, 5, 42, 0, 0, 2360, 2361, 3, 32, 16, 0, 2361, 2362, 5, 43, 0, 0, 2362, 2364, 1, 0, 0, 0, 2363, 2358, 1, 0, 0, 0, 2363, 2359, 1, 0, 0, 0, 2364, 307, 1, 0, 0, 0, 2365, 2366, 5, 181, 0, 0, 2366, 2367, 5, 262, 0, 0, 2367, 2368, 5, 30, 0, 0, 2368, 2369, 3, 6, 3, 0, 2369, 2370, 5, 31, 0, 0, 2370, 2432, 1, 0, 0, 0, 2371, 2372, 5, 260, 0, 0, 2372, 2373, 5, 30, 0, 0, 2373, 2374, 3, 0, 0, 0, 2374, 2375, 5, 31, 0, 0, 2375, 2432, 1, 0, 0, 0, 2376, 2377, 5, 260, 0, 0, 2377, 2432, 3, 0, 0, 0, 2378, 2379, 5, 84, 0, 0, 2379, 2380, 5, 30, 0, 0, 2380, 2381, 3, 312, 156, 0, 2381, 2382, 5, 31, 0, 0, 2382, 2432, 1, 0, 0, 0, 2383, 2384, 5, 188, 0, 0, 2384, 2385, 5, 30, 0, 0, 2385, 2386, 3, 36, 18, 0, 2386, 2387, 5, 31, 0, 0, 2387, 2388, 3, 306, 153, 0, 2388, 2432, 1, 0, 0, 0, 2389, 2390, 5, 189, 0, 0, 2390, 2391, 5, 30, 0, 0, 2391, 2392, 3, 36, 18, 0, 2392, 2393, 5, 31, 0, 0, 2393, 2394, 3, 306, 153, 0, 2394, 2432, 1, 0, 0, 0, 2395, 2396, 5, 187, 0, 0, 2396, 2397, 5, 30, 0, 0, 2397, 2398, 3, 34, 17, 0, 2398, 2399, 5, 31, 0, 0, 2399, 2400, 3, 306, 153, 0, 2400, 2432, 1, 0, 0, 0, 2401, 2402, 5, 186, 0, 0, 2402, 2403, 5, 30, 0, 0, 2403, 2404, 3, 32, 16, 0, 2404, 2405, 5, 31, 0, 0, 2405, 2406, 3, 306, 153, 0, 2406, 2432, 1, 0, 0, 0, 2407, 2408, 5, 185, 0, 0, 2408, 2409, 5, 30, 0, 0, 2409, 2410, 3, 32, 16, 0, 2410, 2411, 5, 31, 0, 0, 2411, 2412, 3, 306, 153, 0, 2412, 2432, 1, 0, 0, 0, 2413, 2414, 5, 184, 0, 0, 2414, 2415, 5, 30, 0, 0, 2415, 2416, 3, 32, 16, 0, 2416, 2417, 5, 31, 0, 0, 2417, 2418, 3, 306, 153, 0, 2418, 2432, 1, 0, 0, 0, 2419, 2420, 5, 188, 0, 0, 2420, 2432, 3, 306, 153, 0, 2421, 2422, 5, 189, 0, 0, 2422, 2432, 3, 306, 153, 0, 2423, 2424, 5, 187, 0, 0, 2424, 2432, 3, 306, 153, 0, 2425, 2426, 5, 186, 0, 0, 2426, 2432, 3, 306, 153, 0, 2427, 2428, 5, 185, 0, 0, 2428, 2432, 3, 306, 153, 0, 2429, 2430, 5, 184, 0, 0, 2430, 2432, 3, 306, 153, 0, 2431, 2365, 1, 0, 0, 0, 2431, 2371, 1, 0, 0, 0, 2431, 2376, 1, 0, 0, 0, 2431, 2378, 1, 0, 0, 0, 2431, 2383, 1, 0, 0, 0, 2431, 2389, 1, 0, 0, 0, 2431, 2395, 1, 0, 0, 0, 2431, 2401, 1, 0, 0, 0, 2431, 2407, 1, 0, 0, 0, 2431, 2413, 1, 0, 0, 0, 2431, 2419, 1, 0, 0, 0, 2431, 2421, 1, 0, 0, 0, 2431, 2423, 1, 0, 0, 0, 2431, 2425, 1, 0, 0, 0, 2431, 2427, 1, 0, 0, 0, 2431, 2429, 1, 0, 0, 0, 2432, 309, 1, 0, 0, 0, 2433, 2434, 5, 188, 0, 0, 2434, 2435, 5, 30, 0, 0, 2435, 2436, 3, 36, 18, 0, 2436, 2437, 5, 31, 0, 0, 2437, 2509, 1, 0, 0, 0, 2438, 2439, 5, 189, 0, 0, 2439, 2440, 5, 30, 0, 0, 2440, 2441, 3, 36, 18, 0, 2441, 2442, 5, 31, 0, 0, 2442, 2509, 1, 0, 0, 0, 2443, 2444, 5, 188, 0, 0, 2444, 2445, 5, 30, 0, 0, 2445, 2446, 3, 32, 16, 0, 2446, 2447, 5, 31, 0, 0, 2447, 2509, 1, 0, 0, 0, 2448, 2449, 5, 189, 0, 0, 2449, 2450, 5, 30, 0, 0, 2450, 2451, 3, 34, 17, 0, 2451, 2452, 5, 31, 0, 0, 2452, 2509, 1, 0, 0, 0, 2453, 2454, 5, 187, 0, 0, 2454, 2455, 5, 30, 0, 0, 2455, 2456, 3, 34, 17, 0, 2456, 2457, 5, 31, 0, 0, 2457, 2509, 1, 0, 0, 0, 2458, 2459, 5, 186, 0, 0, 2459, 2460, 5, 30, 0, 0, 2460, 2461, 3, 32, 16, 0, 2461, 2462, 5, 31, 0, 0, 2462, 2509, 1, 0, 0, 0, 2463, 2464, 5, 185, 0, 0, 2464, 2465, 5, 30, 0, 0, 2465, 2466, 3, 32, 16, 0, 2466, 2467, 5, 31, 0, 0, 2467, 2509, 1, 0, 0, 0, 2468, 2469, 5, 184, 0, 0, 2469, 2470, 5, 30, 0, 0, 2470, 2471, 3, 32, 16, 0, 2471, 2472, 5, 31, 0, 0, 2472, 2509, 1, 0, 0, 0, 2473, 2474, 5, 193, 0, 0, 2474, 2475, 5, 30, 0, 0, 2475, 2476, 3, 34, 17, 0, 2476, 2477, 5, 31, 0, 0, 2477, 2509, 1, 0, 0, 0, 2478, 2479, 5, 192, 0, 0, 2479, 2480, 5, 30, 0, 0, 2480, 2481, 3, 32, 16, 0, 2481, 2482, 5, 31, 0, 0, 2482, 2509, 1, 0, 0, 0, 2483, 2484, 5, 191, 0, 0, 2484, 2485, 5, 30, 0, 0, 2485, 2486, 3, 32, 16, 0, 2486, 2487, 5, 31, 0, 0, 2487, 2509, 1, 0, 0, 0, 2488, 2489, 5, 190, 0, 0, 2489, 2490, 5, 30, 0, 0, 2490, 2491, 3, 32, 16, 0, 2491, 2492, 5, 31, 0, 0, 2492, 2509, 1, 0, 0, 0, 2493, 2494, 5, 181, 0, 0, 2494, 2495, 5, 30, 0, 0, 2495, 2496, 3, 32, 16, 0, 2496, 2497, 5, 31, 0, 0, 2497, 2509, 1, 0, 0, 0, 2498, 2499, 5, 183, 0, 0, 2499, 2500, 5, 30, 0, 0, 2500, 2501, 3, 184, 92, 0, 2501, 2502, 5, 31, 0, 0, 2502, 2509, 1, 0, 0, 0, 2503, 2504, 5, 84, 0, 0, 2504, 2505, 5, 30, 0, 0, 2505, 2506, 3, 312, 156, 0, 2506, 2507, 5, 31, 0, 0, 2507, 2509, 1, 0, 0, 0, 2508, 2433, 1, 0, 0, 0, 2508, 2438, 1, 0, 0, 0, 2508, 2443, 1, 0, 0, 0, 2508, 2448, 1, 0, 0, 0, 2508, 2453, 1, 0, 0, 0, 2508, 2458, 1, 0, 0, 0, 2508, 2463, 1, 0, 0, 0, 2508, 2468, 1, 0, 0, 0, 2508, 2473, 1, 0, 0, 0, 2508, 2478, 1, 0, 0, 0, 2508, 2483, 1, 0, 0, 0, 2508, 2488, 1, 0, 0, 0, 2508, 2493, 1, 0, 0, 0, 2508, 2498, 1, 0, 0, 0, 2508, 2503, 1, 0, 0, 0, 2509, 311, 1, 0, 0, 0, 2510, 2512, 3, 314, 157, 0, 2511, 2510, 1, 0, 0, 0, 2512, 2515, 1, 0, 0, 0, 2513, 2511, 1, 0, 0, 0, 2513, 2514, 1, 0, 0, 0, 2514, 313, 1, 0, 0, 0, 2515, 2513, 1, 0, 0, 0, 2516, 2517, 7, 12, 0, 0, 2517, 315, 1, 0, 0, 0, 2518, 2522, 3, 310, 155, 0, 2519, 2522, 3, 6, 3, 0, 2520, 2522, 5, 179, 0, 0, 2521, 2518, 1, 0, 0, 0, 2521, 2519, 1, 0, 0, 0, 2521, 2520, 1, 0, 0, 0, 2522, 317, 1, 0, 0, 0, 2523, 2672, 3, 310, 155, 0, 2524, 2525, 5, 182, 0, 0, 2525, 2526, 5, 30, 0, 0, 2526, 2527, 5, 179, 0, 0, 2527, 2672, 5, 31, 0, 0, 2528, 2529, 5, 182, 0, 0, 2529, 2530, 5, 30, 0, 0, 2530, 2531, 5, 264, 0, 0, 2531, 2672, 5, 31, 0, 0, 2532, 2533, 5, 196, 0, 0, 2533, 2534, 5, 30, 0, 0, 2534, 2535, 5, 39, 0, 0, 2535, 2536, 5, 264, 0, 0, 2536, 2672, 5, 31, 0, 0, 2537, 2538, 5, 196, 0, 0, 2538, 2539, 5, 30, 0, 0, 2539, 2540, 3, 138, 69, 0, 2540, 2541, 5, 31, 0, 0, 2541, 2672, 1, 0, 0, 0, 2542, 2543, 5, 196, 0, 0, 2543, 2544, 5, 30, 0, 0, 2544, 2545, 5, 179, 0, 0, 2545, 2672, 5, 31, 0, 0, 2546, 2547, 5, 197, 0, 0, 2547, 2548, 5, 30, 0, 0, 2548, 2549, 3, 318, 159, 0, 2549, 2550, 5, 31, 0, 0, 2550, 2672, 1, 0, 0, 0, 2551, 2552, 5, 188, 0, 0, 2552, 2553, 5, 42, 0, 0, 2553, 2554, 3, 32, 16, 0, 2554, 2555, 5, 43, 0, 0, 2555, 2556, 5, 30, 0, 0, 2556, 2557, 3, 320, 160, 0, 2557, 2558, 5, 31, 0, 0, 2558, 2672, 1, 0, 0, 0, 2559, 2560, 5, 189, 0, 0, 2560, 2561, 5, 42, 0, 0, 2561, 2562, 3, 32, 16, 0, 2562, 2563, 5, 43, 0, 0, 2563, 2564, 5, 30, 0, 0, 2564, 2565, 3, 322, 161, 0, 2565, 2566, 5, 31, 0, 0, 2566, 2672, 1, 0, 0, 0, 2567, 2568, 5, 187, 0, 0, 2568, 2569, 5, 42, 0, 0, 2569, 2570, 3, 32, 16, 0, 2570, 2571, 5, 43, 0, 0, 2571, 2572, 5, 30, 0, 0, 2572, 2573, 3, 324, 162, 0, 2573, 2574, 5, 31, 0, 0, 2574, 2672, 1, 0, 0, 0, 2575, 2576, 5, 186, 0, 0, 2576, 2577, 5, 42, 0, 0, 2577, 2578, 3, 32, 16, 0, 2578, 2579, 5, 43, 0, 0, 2579, 2580, 5, 30, 0, 0, 2580, 2581, 3, 326, 163, 0, 2581, 2582, 5, 31, 0, 0, 2582, 2672, 1, 0, 0, 0, 2583, 2584, 5, 185, 0, 0, 2584, 2585, 5, 42, 0, 0, 2585, 2586, 3, 32, 16, 0, 2586, 2587, 5, 43, 0, 0, 2587, 2588, 5, 30, 0, 0, 2588, 2589, 3, 328, 164, 0, 2589, 2590, 5, 31, 0, 0, 2590, 2672, 1, 0, 0, 0, 2591, 2592, 5, 184, 0, 0, 2592, 2593, 5, 42, 0, 0, 2593, 2594, 3, 32, 16, 0, 2594, 2595, 5, 43, 0, 0, 2595, 2596, 5, 30, 0, 0, 2596, 2597, 3, 330, 165, 0, 2597, 2598, 5, 31, 0, 0, 2598, 2672, 1, 0, 0, 0, 2599, 2600, 5, 193, 0, 0, 2600, 2601, 5, 42, 0, 0, 2601, 2602, 3, 32, 16, 0, 2602, 2603, 5, 43, 0, 0, 2603, 2604, 5, 30, 0, 0, 2604, 2605, 3, 324, 162, 0, 2605, 2606, 5, 31, 0, 0, 2606, 2672, 1, 0, 0, 0, 2607, 2608, 5, 192, 0, 0, 2608, 2609, 5, 42, 0, 0, 2609, 2610, 3, 32, 16, 0, 2610, 2611, 5, 43, 0, 0, 2611, 2612, 5, 30, 0, 0, 2612, 2613, 3, 326, 163, 0, 2613, 2614, 5, 31, 0, 0, 2614, 2672, 1, 0, 0, 0, 2615, 2616, 5, 191, 0, 0, 2616, 2617, 5, 42, 0, 0, 2617, 2618, 3, 32, 16, 0, 2618, 2619, 5, 43, 0, 0, 2619, 2620, 5, 30, 0, 0, 2620, 2621, 3, 328, 164, 0, 2621, 2622, 5, 31, 0, 0, 2622, 2672, 1, 0, 0, 0, 2623, 2624, 5, 190, 0, 0, 2624, 2625, 5, 42, 0, 0, 2625, 2626, 3, 32, 16, 0, 2626, 2627, 5, 43, 0, 0, 2627, 2628, 5, 30, 0, 0, 2628, 2629, 3, 330, 165, 0, 2629, 2630, 5, 31, 0, 0, 2630, 2672, 1, 0, 0, 0, 2631, 2632, 5, 181, 0, 0, 2632, 2633, 5, 42, 0, 0, 2633, 2634, 3, 32, 16, 0, 2634, 2635, 5, 43, 0, 0, 2635, 2636, 5, 30, 0, 0, 2636, 2637, 3, 328, 164, 0, 2637, 2638, 5, 31, 0, 0, 2638, 2672, 1, 0, 0, 0, 2639, 2640, 5, 183, 0, 0, 2640, 2641, 5, 42, 0, 0, 2641, 2642, 3, 32, 16, 0, 2642, 2643, 5, 43, 0, 0, 2643, 2644, 5, 30, 0, 0, 2644, 2645, 3, 332, 166, 0, 2645, 2646, 5, 31, 0, 0, 2646, 2672, 1, 0, 0, 0, 2647, 2648, 5, 182, 0, 0, 2648, 2649, 5, 42, 0, 0, 2649, 2650, 3, 32, 16, 0, 2650, 2651, 5, 43, 0, 0, 2651, 2652, 5, 30, 0, 0, 2652, 2653, 3, 334, 167, 0, 2653, 2654, 5, 31, 0, 0, 2654, 2672, 1, 0, 0, 0, 2655, 2656, 5, 196, 0, 0, 2656, 2657, 5, 42, 0, 0, 2657, 2658, 3, 32, 16, 0, 2658, 2659, 5, 43, 0, 0, 2659, 2660, 5, 30, 0, 0, 2660, 2661, 3, 336, 168, 0, 2661, 2662, 5, 31, 0, 0, 2662, 2672, 1, 0, 0, 0, 2663, 2664, 5, 197, 0, 0, 2664, 2665, 5, 42, 0, 0, 2665, 2666, 3, 32, 16, 0, 2666, 2667, 5, 43, 0, 0, 2667, 2668, 5, 30, 0, 0, 2668, 2669, 3, 340, 170, 0, 2669, 2670, 5, 31, 0, 0, 2670, 2672, 1, 0, 0, 0, 2671, 2523, 1, 0, 0, 0, 2671, 2524, 1, 0, 0, 0, 2671, 2528, 1, 0, 0, 0, 2671, 2532, 1, 0, 0, 0, 2671, 2537, 1, 0, 0, 0, 2671, 2542, 1, 0, 0, 0, 2671, 2546, 1, 0, 0, 0, 2671, 2551, 1, 0, 0, 0, 2671, 2559, 1, 0, 0, 0, 2671, 2567, 1, 0, 0, 0, 2671, 2575, 1, 0, 0, 0, 2671, 2583, 1, 0, 0, 0, 2671, 2591, 1, 0, 0, 0, 2671, 2599, 1, 0, 0, 0, 2671, 2607, 1, 0, 0, 0, 2671, 2615, 1, 0, 0, 0, 2671, 2623, 1, 0, 0, 0, 2671, 2631, 1, 0, 0, 0, 2671, 2639, 1, 0, 0, 0, 2671, 2647, 1, 0, 0, 0, 2671, 2655, 1, 0, 0, 0, 2671, 2663, 1, 0, 0, 0, 2672, 319, 1, 0, 0, 0, 2673, 2676, 3, 36, 18, 0, 2674, 2676, 3, 32, 16, 0, 2675, 2673, 1, 0, 0, 0, 2675, 2674, 1, 0, 0, 0, 2676, 2679, 1, 0, 0, 0, 2677, 2675, 1, 0, 0, 0, 2677, 2678, 1, 0, 0, 0, 2678, 321, 1, 0, 0, 0, 2679, 2677, 1, 0, 0, 0, 2680, 2683, 3, 36, 18, 0, 2681, 2683, 3, 34, 17, 0, 2682, 2680, 1, 0, 0, 0, 2682, 2681, 1, 0, 0, 0, 2683, 2686, 1, 0, 0, 0, 2684, 2682, 1, 0, 0, 0, 2684, 2685, 1, 0, 0, 0, 2685, 323, 1, 0, 0, 0, 2686, 2684, 1, 0, 0, 0, 2687, 2689, 3, 34, 17, 0, 2688, 2687, 1, 0, 0, 0, 2689, 2692, 1, 0, 0, 0, 2690, 2688, 1, 0, 0, 0, 2690, 2691, 1, 0, 0, 0, 2691, 325, 1, 0, 0, 0, 2692, 2690, 1, 0, 0, 0, 2693, 2695, 3, 32, 16, 0, 2694, 2693, 1, 0, 0, 0, 2695, 2698, 1, 0, 0, 0, 2696, 2694, 1, 0, 0, 0, 2696, 2697, 1, 0, 0, 0, 2697, 327, 1, 0, 0, 0, 2698, 2696, 1, 0, 0, 0, 2699, 2701, 3, 32, 16, 0, 2700, 2699, 1, 0, 0, 0, 2701, 2704, 1, 0, 0, 0, 2702, 2700, 1, 0, 0, 0, 2702, 2703, 1, 0, 0, 0, 2703, 329, 1, 0, 0, 0, 2704, 2702, 1, 0, 0, 0, 2705, 2707, 3, 32, 16, 0, 2706, 2705, 1, 0, 0, 0, 2707, 2710, 1, 0, 0, 0, 2708, 2706, 1, 0, 0, 0, 2708, 2709, 1, 0, 0, 0, 2709, 331, 1, 0, 0, 0, 2710, 2708, 1, 0, 0, 0, 2711, 2713, 3, 184, 92, 0, 2712, 2711, 1, 0, 0, 0, 2713, 2716, 1, 0, 0, 0, 2714, 2712, 1, 0, 0, 0, 2714, 2715, 1, 0, 0, 0, 2715, 333, 1, 0, 0, 0, 2716, 2714, 1, 0, 0, 0, 2717, 2719, 7, 13, 0, 0, 2718, 2717, 1, 0, 0, 0, 2719, 2722, 1, 0, 0, 0, 2720, 2718, 1, 0, 0, 0, 2720, 2721, 1, 0, 0, 0, 2721, 335, 1, 0, 0, 0, 2722, 2720, 1, 0, 0, 0, 2723, 2725, 3, 338, 169, 0, 2724, 2723, 1, 0, 0, 0, 2725, 2728, 1, 0, 0, 0, 2726, 2724, 1, 0, 0, 0, 2726, 2727, 1, 0, 0, 0, 2727, 337, 1, 0, 0, 0, 2728, 2726, 1, 0, 0, 0, 2729, 2734, 5, 179, 0, 0, 2730, 2731, 5, 39, 0, 0, 2731, 2734, 5, 264, 0, 0, 2732, 2734, 3, 138, 69, 0, 2733, 2729, 1, 0, 0, 0, 2733, 2730, 1, 0, 0, 0, 2733, 2732, 1, 0, 0, 0, 2734, 339, 1, 0, 0, 0, 2735, 2737, 3, 318, 159, 0, 2736, 2735, 1, 0, 0, 0, 2737, 2740, 1, 0, 0, 0, 2738, 2736, 1, 0, 0, 0, 2738, 2739, 1, 0, 0, 0, 2739, 341, 1, 0, 0, 0, 2740, 2738, 1, 0, 0, 0, 2741, 2745, 3, 44, 22, 0, 2742, 2745, 3, 46, 23, 0, 2743, 2745, 3, 2, 1, 0, 2744, 2741, 1, 0, 0, 0, 2744, 2742, 1, 0, 0, 0, 2744, 2743, 1, 0, 0, 0, 2745, 343, 1, 0, 0, 0, 2746, 2747, 7, 14, 0, 0, 2747, 2748, 5, 36, 0, 0, 2748, 2749, 5, 30, 0, 0, 2749, 2750, 3, 312, 156, 0, 2750, 2751, 5, 31, 0, 0, 2751, 2772, 1, 0, 0, 0, 2752, 2753, 5, 169, 0, 0, 2753, 2754, 3, 38, 19, 0, 2754, 2755, 5, 75, 0, 0, 2755, 2756, 3, 38, 19, 0, 2756, 2757, 5, 75, 0, 0, 2757, 2758, 3, 38, 19, 0, 2758, 2759, 5, 75, 0, 0, 2759, 2760, 3, 38, 19, 0, 2760, 2772, 1, 0, 0, 0, 2761, 2762, 5, 170, 0, 0, 2762, 2772, 3, 6, 3, 0, 2763, 2764, 5, 170, 0, 0, 2764, 2765, 5, 36, 0, 0, 2765, 2766, 5, 30, 0, 0, 2766, 2767, 3, 312, 156, 0, 2767, 2768, 5, 31, 0, 0, 2768, 2772, 1, 0, 0, 0, 2769, 2772, 3, 342, 171, 0, 2770, 2772, 3, 40, 20, 0, 2771, 2746, 1, 0, 0, 0, 2771, 2752, 1, 0, 0, 0, 2771, 2761, 1, 0, 0, 0, 2771, 2763, 1, 0, 0, 0, 2771, 2769, 1, 0, 0, 0, 2771, 2770, 1, 0, 0, 0, 2772, 345, 1, 0, 0, 0, 2773, 2774, 5, 25, 0, 0, 2774, 2775, 5, 40, 0, 0, 2775, 2776, 3, 98, 49, 0, 2776, 2777, 3, 2, 1, 0, 2777, 2786, 1, 0, 0, 0, 2778, 2779, 5, 25, 0, 0, 2779, 2780, 5, 40, 0, 0, 2780, 2781, 3, 98, 49, 0, 2781, 2782, 3, 2, 1, 0, 2782, 2783, 5, 34, 0, 0, 2783, 2784, 3, 2, 1, 0, 2784, 2786, 1, 0, 0, 0, 2785, 2773, 1, 0, 0, 0, 2785, 2778, 1, 0, 0, 0, 2786, 347, 1, 0, 0, 0, 2787, 2789, 3, 350, 175, 0, 2788, 2787, 1, 0, 0, 0, 2789, 2792, 1, 0, 0, 0, 2790, 2788, 1, 0, 0, 0, 2790, 2791, 1, 0, 0, 0, 2791, 349, 1, 0, 0, 0, 2792, 2790, 1, 0, 0, 0, 2793, 2794, 5, 180, 0, 0, 2794, 2795, 5, 36, 0, 0, 2795, 2796, 5, 30, 0, 0, 2796, 2797, 3, 312, 156, 0, 2797, 2798, 5, 31, 0, 0, 2798, 2808, 1, 0, 0, 0, 2799, 2808, 3, 344, 172, 0, 2800, 2801, 5, 171, 0, 0, 2801, 2802, 5, 36, 0, 0, 2802, 2803, 5, 30, 0, 0, 2803, 2804, 3, 312, 156, 0, 2804, 2805, 5, 31, 0, 0, 2805, 2808, 1, 0, 0, 0, 2806, 2808, 5, 55, 0, 0, 2807, 2793, 1, 0, 0, 0, 2807, 2799, 1, 0, 0, 0, 2807, 2800, 1, 0, 0, 0, 2807, 2806, 1, 0, 0, 0, 2808, 351, 1, 0, 0, 0, 2809, 2810, 5, 50, 0, 0, 2810, 2814, 5, 40, 0, 0, 2811, 2813, 3, 356, 178, 0, 2812, 2811, 1, 0, 0, 0, 2813, 2816, 1, 0, 0, 0, 2814, 2812, 1, 0, 0, 0, 2814, 2815, 1, 0, 0, 0, 2815, 2817, 1, 0, 0, 0, 2816, 2814, 1, 0, 0, 0, 2817, 2818, 3, 2, 1, 0, 2818, 353, 1, 0, 0, 0, 2819, 2823, 5, 301, 0, 0, 2820, 2822, 3, 356, 178, 0, 2821, 2820, 1, 0, 0, 0, 2822, 2825, 1, 0, 0, 0, 2823, 2821, 1, 0, 0, 0, 2823, 2824, 1, 0, 0, 0, 2824, 2826, 1, 0, 0, 0, 2825, 2823, 1, 0, 0, 0, 2826, 2827, 3, 2, 1, 0, 2827, 355, 1, 0, 0, 0, 2828, 2844, 5, 52, 0, 0, 2829, 2844, 5, 51, 0, 0, 2830, 2844, 5, 172, 0, 0, 2831, 2832, 5, 62, 0, 0, 2832, 2844, 5, 51, 0, 0, 2833, 2834, 5, 62, 0, 0, 2834, 2844, 5, 52, 0, 0, 2835, 2836, 5, 62, 0, 0, 2836, 2844, 5, 63, 0, 0, 2837, 2838, 5, 62, 0, 0, 2838, 2844, 5, 64, 0, 0, 2839, 2840, 5, 62, 0, 0, 2840, 2844, 5, 65, 0, 0, 2841, 2842, 5, 62, 0, 0, 2842, 2844, 5, 66, 0, 0, 2843, 2828, 1, 0, 0, 0, 2843, 2829, 1, 0, 0, 0, 2843, 2830, 1, 0, 0, 0, 2843, 2831, 1, 0, 0, 0, 2843, 2833, 1, 0, 0, 0, 2843, 2835, 1, 0, 0, 0, 2843, 2837, 1, 0, 0, 0, 2843, 2839, 1, 0, 0, 0, 2843, 2841, 1, 0, 0, 0, 2844, 357, 1, 0, 0, 0, 2845, 2847, 3, 360, 180, 0, 2846, 2845, 1, 0, 0, 0, 2847, 2850, 1, 0, 0, 0, 2848, 2846, 1, 0, 0, 0, 2848, 2849, 1, 0, 0, 0, 2849, 359, 1, 0, 0, 0, 2850, 2848, 1, 0, 0, 0, 2851, 2852, 5, 21, 0, 0, 2852, 2865, 3, 2, 1, 0, 2853, 2854, 5, 50, 0, 0, 2854, 2855, 5, 40, 0, 0, 2855, 2865, 3, 140, 70, 0, 2856, 2857, 5, 25, 0, 0, 2857, 2858, 5, 40, 0, 0, 2858, 2865, 3, 2, 1, 0, 2859, 2865, 3, 196, 98, 0, 2860, 2861, 5, 50, 0, 0, 2861, 2865, 3, 32, 16, 0, 2862, 2865, 3, 342, 171, 0, 2863, 2865, 3, 40, 20, 0, 2864, 2851, 1, 0, 0, 0, 2864, 2853, 1, 0, 0, 0, 2864, 2856, 1, 0, 0, 0, 2864, 2859, 1, 0, 0, 0, 2864, 2860, 1, 0, 0, 0, 2864, 2862, 1, 0, 0, 0, 2864, 2863, 1, 0, 0, 0, 2865, 361, 1, 0, 0, 0, 2866, 2870, 5, 274, 0, 0, 2867, 2869, 3, 364, 182, 0, 2868, 2867, 1, 0, 0, 0, 2869, 2872, 1, 0, 0, 0, 2870, 2868, 1, 0, 0, 0, 2870, 2871, 1, 0, 0, 0, 2871, 2873, 1, 0, 0, 0, 2872, 2870, 1, 0, 0, 0, 2873, 2886, 3, 2, 1, 0, 2874, 2878, 5, 274, 0, 0, 2875, 2877, 3, 364, 182, 0, 2876, 2875, 1, 0, 0, 0, 2877, 2880, 1, 0, 0, 0, 2878, 2876, 1, 0, 0, 0, 2878, 2879, 1, 0, 0, 0, 2879, 2881, 1, 0, 0, 0, 2880, 2878, 1, 0, 0, 0, 2881, 2882, 3, 2, 1, 0, 2882, 2883, 5, 34, 0, 0, 2883, 2884, 3, 2, 1, 0, 2884, 2886, 1, 0, 0, 0, 2885, 2866, 1, 0, 0, 0, 2885, 2874, 1, 0, 0, 0, 2886, 363, 1, 0, 0, 0, 2887, 2888, 7, 15, 0, 0, 2888, 365, 1, 0, 0, 0, 2889, 2891, 3, 368, 184, 0, 2890, 2889, 1, 0, 0, 0, 2891, 2894, 1, 0, 0, 0, 2892, 2890, 1, 0, 0, 0, 2892, 2893, 1, 0, 0, 0, 2893, 367, 1, 0, 0, 0, 2894, 2892, 1, 0, 0, 0, 2895, 2896, 5, 21, 0, 0, 2896, 2897, 3, 2, 1, 0, 2897, 2898, 5, 44, 0, 0, 2898, 2899, 3, 32, 16, 0, 2899, 2906, 1, 0, 0, 0, 2900, 2901, 5, 25, 0, 0, 2901, 2902, 5, 40, 0, 0, 2902, 2906, 3, 2, 1, 0, 2903, 2906, 3, 342, 171, 0, 2904, 2906, 3, 40, 20, 0, 2905, 2895, 1, 0, 0, 0, 2905, 2900, 1, 0, 0, 0, 2905, 2903, 1, 0, 0, 0, 2905, 2904, 1, 0, 0, 0, 2906, 369, 1, 0, 0, 0, 172, 378, 383, 391, 399, 452, 493, 502, 526, 530, 548, 575, 598, 634, 640, 647, 649, 659, 661, 668, 679, 687, 708, 710, 726, 771, 776, 781, 786, 794, 904, 910, 926, 932, 938, 945, 1056, 1061, 1067, 1072, 1074, 1082, 1094, 1106, 1113, 1120, 1122, 1149, 1156, 1164, 1172, 1185, 1192, 1195, 1214, 1308, 1317, 1324, 1327, 1335, 1356, 1388, 1411, 1423, 1432, 1457, 1481, 1489, 1493, 1508, 1515, 1560, 1570, 1586, 1598, 1610, 1624, 1636, 1647, 1654, 1664, 1677, 1682, 1687, 1696, 1707, 1790, 1799, 1812, 1823, 1831, 1841, 1843, 1870, 1877, 1882, 1889, 1895, 1905, 1909, 1916, 1931, 1937, 1951, 1964, 1972, 1979, 1983, 1988, 2004, 2009, 2011, 2024, 2050, 2057, 2059, 2064, 2070, 2099, 2104, 2127, 2132, 2196, 2205, 2218, 2229, 2240, 2243, 2250, 2262, 2276, 2290, 2298, 2318, 2330, 2335, 2344, 2346, 2353, 2363, 2431, 2508, 2513, 2521, 2671, 2675, 2677, 2682, 2684, 2690, 2696, 2702, 2708, 2714, 2720, 2726, 2733, 2738, 2744, 2771, 2785, 2790, 2807, 2814, 2823, 2843, 2848, 2864, 2870, 2878, 2885, 2892, 2905] \ No newline at end of file +[4, 1, 305, 2910, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 377, 8, 1, 10, 1, 12, 1, 380, 9, 1, 1, 1, 1, 1, 3, 1, 384, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 5, 3, 390, 8, 3, 10, 3, 12, 3, 393, 9, 3, 1, 3, 1, 3, 1, 4, 5, 4, 398, 8, 4, 10, 4, 12, 4, 401, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 453, 8, 5, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 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, 494, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 5, 15, 501, 8, 15, 10, 15, 12, 15, 504, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 527, 8, 18, 1, 19, 1, 19, 3, 19, 531, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 549, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 576, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 599, 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, 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, 635, 8, 23, 1, 24, 1, 24, 1, 25, 1, 25, 3, 25, 641, 8, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 5, 27, 648, 8, 27, 10, 27, 12, 27, 651, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 660, 8, 28, 10, 28, 12, 28, 663, 9, 28, 1, 29, 1, 29, 1, 30, 1, 30, 3, 30, 669, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 680, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 688, 8, 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, 34, 1, 34, 1, 34, 1, 34, 5, 34, 709, 8, 34, 10, 34, 12, 34, 712, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 5, 37, 725, 8, 37, 10, 37, 12, 37, 728, 9, 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, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 772, 8, 38, 1, 39, 1, 39, 1, 39, 3, 39, 777, 8, 39, 1, 40, 1, 40, 1, 40, 3, 40, 782, 8, 40, 1, 41, 5, 41, 785, 8, 41, 10, 41, 12, 41, 788, 9, 41, 1, 42, 1, 42, 1, 42, 5, 42, 793, 8, 42, 10, 42, 12, 42, 796, 9, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 905, 8, 44, 1, 45, 1, 45, 5, 45, 909, 8, 45, 10, 45, 12, 45, 912, 9, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 925, 8, 45, 10, 45, 12, 45, 928, 9, 45, 1, 45, 1, 45, 1, 45, 3, 45, 933, 8, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 939, 8, 47, 1, 48, 1, 48, 1, 49, 5, 49, 944, 8, 49, 10, 49, 12, 49, 947, 9, 49, 1, 50, 1, 50, 1, 51, 1, 51, 1, 52, 1, 52, 1, 53, 1, 53, 1, 54, 1, 54, 1, 55, 1, 55, 1, 56, 1, 56, 1, 57, 1, 57, 1, 58, 1, 58, 1, 59, 1, 59, 1, 60, 1, 60, 1, 61, 1, 61, 1, 62, 1, 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, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 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, 1057, 8, 63, 1, 64, 1, 64, 1, 64, 3, 64, 1062, 8, 64, 1, 64, 1, 64, 5, 64, 1066, 8, 64, 10, 64, 12, 64, 1069, 9, 64, 1, 64, 1, 64, 3, 64, 1073, 8, 64, 3, 64, 1075, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 5, 65, 1081, 8, 65, 10, 65, 12, 65, 1084, 9, 65, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 66, 5, 66, 1093, 8, 66, 10, 66, 12, 66, 1096, 9, 66, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 5, 67, 1105, 8, 67, 10, 67, 12, 67, 1108, 9, 67, 1, 67, 1, 67, 1, 67, 1, 67, 3, 67, 1114, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1121, 8, 68, 3, 68, 1123, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 3, 69, 1150, 8, 69, 1, 70, 1, 70, 1, 70, 5, 70, 1155, 8, 70, 10, 70, 12, 70, 1158, 9, 70, 1, 70, 1, 70, 1, 71, 5, 71, 1163, 8, 71, 10, 71, 12, 71, 1166, 9, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1173, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1186, 8, 73, 1, 74, 1, 74, 1, 74, 5, 74, 1191, 8, 74, 10, 74, 12, 74, 1194, 9, 74, 3, 74, 1196, 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, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1215, 8, 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, 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, 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, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 3, 76, 1309, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 1318, 8, 77, 1, 78, 1, 78, 1, 78, 5, 78, 1323, 8, 78, 10, 78, 12, 78, 1326, 9, 78, 3, 78, 1328, 8, 78, 1, 79, 1, 79, 1, 80, 1, 80, 5, 80, 1334, 8, 80, 10, 80, 12, 80, 1337, 9, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 3, 81, 1357, 8, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1389, 8, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 3, 83, 1412, 8, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1424, 8, 84, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1433, 8, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 1458, 8, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 1482, 8, 87, 1, 88, 1, 88, 1, 88, 1, 88, 5, 88, 1488, 8, 88, 10, 88, 12, 88, 1491, 9, 88, 1, 88, 3, 88, 1494, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1509, 8, 89, 1, 90, 1, 90, 1, 90, 5, 90, 1514, 8, 90, 10, 90, 12, 90, 1517, 9, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 3, 93, 1561, 8, 93, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 3, 95, 1571, 8, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 3, 95, 1587, 8, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 3, 95, 1599, 8, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 3, 96, 1611, 8, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 3, 97, 1625, 8, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 1637, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 3, 100, 1648, 8, 100, 1, 101, 1, 101, 1, 101, 5, 101, 1653, 8, 101, 10, 101, 12, 101, 1656, 9, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 1665, 8, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 3, 103, 1678, 8, 103, 1, 104, 5, 104, 1681, 8, 104, 10, 104, 12, 104, 1684, 9, 104, 1, 105, 1, 105, 3, 105, 1688, 8, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 5, 106, 1695, 8, 106, 10, 106, 12, 106, 1698, 9, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 108, 1, 108, 3, 108, 1708, 8, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 5, 110, 1789, 8, 110, 10, 110, 12, 110, 1792, 9, 110, 1, 110, 1, 110, 1, 110, 1, 110, 5, 110, 1798, 8, 110, 10, 110, 12, 110, 1801, 9, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 5, 110, 1811, 8, 110, 10, 110, 12, 110, 1814, 9, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 5, 110, 1822, 8, 110, 10, 110, 12, 110, 1825, 9, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 1832, 8, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 5, 111, 1842, 8, 111, 10, 111, 12, 111, 1845, 9, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 1871, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 1878, 8, 113, 1, 114, 1, 114, 1, 114, 3, 114, 1883, 8, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 3, 115, 1890, 8, 115, 1, 116, 1, 116, 5, 116, 1894, 8, 116, 10, 116, 12, 116, 1897, 9, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 5, 116, 1904, 8, 116, 10, 116, 12, 116, 1907, 9, 116, 1, 116, 3, 116, 1910, 8, 116, 1, 117, 1, 117, 1, 118, 5, 118, 1915, 8, 118, 10, 118, 12, 118, 1918, 9, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 1932, 8, 119, 1, 120, 1, 120, 5, 120, 1936, 8, 120, 10, 120, 12, 120, 1939, 9, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 122, 5, 122, 1950, 8, 122, 10, 122, 12, 122, 1953, 9, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 3, 123, 1965, 8, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 1973, 8, 124, 1, 125, 1, 125, 1, 125, 4, 125, 1978, 8, 125, 11, 125, 12, 125, 1979, 1, 125, 1, 125, 3, 125, 1984, 8, 125, 1, 126, 5, 126, 1987, 8, 126, 10, 126, 12, 126, 1990, 9, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 3, 127, 2005, 8, 127, 1, 128, 1, 128, 1, 128, 5, 128, 2010, 8, 128, 10, 128, 12, 128, 2013, 9, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 5, 128, 2023, 8, 128, 10, 128, 12, 128, 2026, 9, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 3, 129, 2051, 8, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 3, 130, 2058, 8, 130, 3, 130, 2060, 8, 130, 1, 130, 5, 130, 2063, 8, 130, 10, 130, 12, 130, 2066, 9, 130, 1, 130, 1, 130, 1, 130, 3, 130, 2071, 8, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 2100, 8, 131, 1, 132, 1, 132, 1, 132, 3, 132, 2105, 8, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 2128, 8, 133, 1, 134, 5, 134, 2131, 8, 134, 10, 134, 12, 134, 2134, 9, 134, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 5, 135, 2195, 8, 135, 10, 135, 12, 135, 2198, 9, 135, 1, 135, 1, 135, 1, 135, 1, 135, 5, 135, 2204, 8, 135, 10, 135, 12, 135, 2207, 9, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 5, 135, 2217, 8, 135, 10, 135, 12, 135, 2220, 9, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 5, 135, 2228, 8, 135, 10, 135, 12, 135, 2231, 9, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 5, 135, 2239, 8, 135, 10, 135, 12, 135, 2242, 9, 135, 3, 135, 2244, 8, 135, 1, 136, 1, 136, 1, 136, 1, 137, 1, 137, 3, 137, 2251, 8, 137, 1, 138, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 140, 4, 140, 2261, 8, 140, 11, 140, 12, 140, 2262, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 2277, 8, 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, 3, 142, 2291, 8, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 2299, 8, 143, 1, 144, 1, 144, 1, 144, 1, 145, 1, 145, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 2319, 8, 147, 1, 148, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 2331, 8, 149, 1, 150, 1, 150, 1, 150, 3, 150, 2336, 8, 150, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 4, 151, 2343, 8, 151, 11, 151, 12, 151, 2344, 3, 151, 2347, 8, 151, 1, 152, 1, 152, 1, 152, 5, 152, 2352, 8, 152, 10, 152, 12, 152, 2355, 9, 152, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 3, 153, 2364, 8, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 2432, 8, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 3, 155, 2509, 8, 155, 1, 156, 1, 156, 1, 156, 5, 156, 2514, 8, 156, 10, 156, 12, 156, 2517, 9, 156, 1, 157, 1, 157, 1, 158, 1, 158, 1, 158, 3, 158, 2524, 8, 158, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 3, 159, 2674, 8, 159, 1, 160, 1, 160, 5, 160, 2678, 8, 160, 10, 160, 12, 160, 2681, 9, 160, 1, 161, 1, 161, 5, 161, 2685, 8, 161, 10, 161, 12, 161, 2688, 9, 161, 1, 162, 5, 162, 2691, 8, 162, 10, 162, 12, 162, 2694, 9, 162, 1, 163, 5, 163, 2697, 8, 163, 10, 163, 12, 163, 2700, 9, 163, 1, 164, 5, 164, 2703, 8, 164, 10, 164, 12, 164, 2706, 9, 164, 1, 165, 5, 165, 2709, 8, 165, 10, 165, 12, 165, 2712, 9, 165, 1, 166, 5, 166, 2715, 8, 166, 10, 166, 12, 166, 2718, 9, 166, 1, 167, 5, 167, 2721, 8, 167, 10, 167, 12, 167, 2724, 9, 167, 1, 168, 5, 168, 2727, 8, 168, 10, 168, 12, 168, 2730, 9, 168, 1, 169, 1, 169, 1, 169, 1, 169, 3, 169, 2736, 8, 169, 1, 170, 5, 170, 2739, 8, 170, 10, 170, 12, 170, 2742, 9, 170, 1, 171, 1, 171, 1, 171, 3, 171, 2747, 8, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, 172, 2774, 8, 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, 3, 173, 2788, 8, 173, 1, 174, 5, 174, 2791, 8, 174, 10, 174, 12, 174, 2794, 9, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 3, 175, 2810, 8, 175, 1, 176, 1, 176, 1, 176, 5, 176, 2815, 8, 176, 10, 176, 12, 176, 2818, 9, 176, 1, 176, 1, 176, 1, 177, 1, 177, 5, 177, 2824, 8, 177, 10, 177, 12, 177, 2827, 9, 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, 178, 1, 178, 1, 178, 1, 178, 3, 178, 2846, 8, 178, 1, 179, 5, 179, 2849, 8, 179, 10, 179, 12, 179, 2852, 9, 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, 3, 180, 2867, 8, 180, 1, 181, 1, 181, 5, 181, 2871, 8, 181, 10, 181, 12, 181, 2874, 9, 181, 1, 181, 1, 181, 1, 181, 5, 181, 2879, 8, 181, 10, 181, 12, 181, 2882, 9, 181, 1, 181, 1, 181, 1, 181, 1, 181, 3, 181, 2888, 8, 181, 1, 182, 1, 182, 1, 183, 5, 183, 2893, 8, 183, 10, 183, 12, 183, 2896, 9, 183, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 3, 184, 2908, 8, 184, 1, 184, 0, 1, 68, 185, 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, 0, 16, 6, 0, 1, 15, 199, 199, 243, 243, 247, 247, 264, 264, 289, 289, 5, 0, 16, 16, 199, 199, 243, 243, 264, 264, 288, 289, 1, 0, 263, 264, 1, 0, 173, 174, 1, 0, 37, 38, 1, 0, 73, 74, 3, 0, 2, 2, 61, 61, 77, 83, 2, 0, 229, 229, 260, 261, 9, 0, 178, 178, 183, 195, 201, 201, 207, 208, 210, 215, 218, 219, 222, 222, 230, 242, 262, 262, 1, 0, 95, 96, 1, 0, 97, 111, 1, 0, 68, 69, 2, 0, 173, 173, 289, 290, 2, 0, 179, 179, 264, 264, 1, 0, 167, 168, 1, 0, 51, 52, 3327, 0, 370, 1, 0, 0, 0, 2, 383, 1, 0, 0, 0, 4, 385, 1, 0, 0, 0, 6, 391, 1, 0, 0, 0, 8, 399, 1, 0, 0, 0, 10, 452, 1, 0, 0, 0, 12, 454, 1, 0, 0, 0, 14, 457, 1, 0, 0, 0, 16, 460, 1, 0, 0, 0, 18, 464, 1, 0, 0, 0, 20, 467, 1, 0, 0, 0, 22, 470, 1, 0, 0, 0, 24, 477, 1, 0, 0, 0, 26, 493, 1, 0, 0, 0, 28, 495, 1, 0, 0, 0, 30, 497, 1, 0, 0, 0, 32, 507, 1, 0, 0, 0, 34, 509, 1, 0, 0, 0, 36, 526, 1, 0, 0, 0, 38, 530, 1, 0, 0, 0, 40, 548, 1, 0, 0, 0, 42, 575, 1, 0, 0, 0, 44, 598, 1, 0, 0, 0, 46, 634, 1, 0, 0, 0, 48, 636, 1, 0, 0, 0, 50, 640, 1, 0, 0, 0, 52, 642, 1, 0, 0, 0, 54, 649, 1, 0, 0, 0, 56, 661, 1, 0, 0, 0, 58, 664, 1, 0, 0, 0, 60, 666, 1, 0, 0, 0, 62, 679, 1, 0, 0, 0, 64, 687, 1, 0, 0, 0, 66, 689, 1, 0, 0, 0, 68, 697, 1, 0, 0, 0, 70, 713, 1, 0, 0, 0, 72, 719, 1, 0, 0, 0, 74, 722, 1, 0, 0, 0, 76, 771, 1, 0, 0, 0, 78, 776, 1, 0, 0, 0, 80, 781, 1, 0, 0, 0, 82, 786, 1, 0, 0, 0, 84, 794, 1, 0, 0, 0, 86, 799, 1, 0, 0, 0, 88, 904, 1, 0, 0, 0, 90, 932, 1, 0, 0, 0, 92, 934, 1, 0, 0, 0, 94, 938, 1, 0, 0, 0, 96, 940, 1, 0, 0, 0, 98, 945, 1, 0, 0, 0, 100, 948, 1, 0, 0, 0, 102, 950, 1, 0, 0, 0, 104, 952, 1, 0, 0, 0, 106, 954, 1, 0, 0, 0, 108, 956, 1, 0, 0, 0, 110, 958, 1, 0, 0, 0, 112, 960, 1, 0, 0, 0, 114, 962, 1, 0, 0, 0, 116, 964, 1, 0, 0, 0, 118, 966, 1, 0, 0, 0, 120, 968, 1, 0, 0, 0, 122, 970, 1, 0, 0, 0, 124, 972, 1, 0, 0, 0, 126, 1056, 1, 0, 0, 0, 128, 1074, 1, 0, 0, 0, 130, 1076, 1, 0, 0, 0, 132, 1088, 1, 0, 0, 0, 134, 1113, 1, 0, 0, 0, 136, 1122, 1, 0, 0, 0, 138, 1149, 1, 0, 0, 0, 140, 1156, 1, 0, 0, 0, 142, 1164, 1, 0, 0, 0, 144, 1172, 1, 0, 0, 0, 146, 1185, 1, 0, 0, 0, 148, 1195, 1, 0, 0, 0, 150, 1214, 1, 0, 0, 0, 152, 1308, 1, 0, 0, 0, 154, 1317, 1, 0, 0, 0, 156, 1327, 1, 0, 0, 0, 158, 1329, 1, 0, 0, 0, 160, 1331, 1, 0, 0, 0, 162, 1356, 1, 0, 0, 0, 164, 1388, 1, 0, 0, 0, 166, 1411, 1, 0, 0, 0, 168, 1423, 1, 0, 0, 0, 170, 1425, 1, 0, 0, 0, 172, 1428, 1, 0, 0, 0, 174, 1481, 1, 0, 0, 0, 176, 1493, 1, 0, 0, 0, 178, 1508, 1, 0, 0, 0, 180, 1515, 1, 0, 0, 0, 182, 1520, 1, 0, 0, 0, 184, 1524, 1, 0, 0, 0, 186, 1560, 1, 0, 0, 0, 188, 1562, 1, 0, 0, 0, 190, 1598, 1, 0, 0, 0, 192, 1610, 1, 0, 0, 0, 194, 1624, 1, 0, 0, 0, 196, 1626, 1, 0, 0, 0, 198, 1636, 1, 0, 0, 0, 200, 1647, 1, 0, 0, 0, 202, 1654, 1, 0, 0, 0, 204, 1664, 1, 0, 0, 0, 206, 1677, 1, 0, 0, 0, 208, 1682, 1, 0, 0, 0, 210, 1685, 1, 0, 0, 0, 212, 1696, 1, 0, 0, 0, 214, 1701, 1, 0, 0, 0, 216, 1707, 1, 0, 0, 0, 218, 1709, 1, 0, 0, 0, 220, 1831, 1, 0, 0, 0, 222, 1833, 1, 0, 0, 0, 224, 1870, 1, 0, 0, 0, 226, 1877, 1, 0, 0, 0, 228, 1882, 1, 0, 0, 0, 230, 1889, 1, 0, 0, 0, 232, 1909, 1, 0, 0, 0, 234, 1911, 1, 0, 0, 0, 236, 1916, 1, 0, 0, 0, 238, 1931, 1, 0, 0, 0, 240, 1933, 1, 0, 0, 0, 242, 1946, 1, 0, 0, 0, 244, 1951, 1, 0, 0, 0, 246, 1964, 1, 0, 0, 0, 248, 1972, 1, 0, 0, 0, 250, 1983, 1, 0, 0, 0, 252, 1988, 1, 0, 0, 0, 254, 2004, 1, 0, 0, 0, 256, 2006, 1, 0, 0, 0, 258, 2050, 1, 0, 0, 0, 260, 2070, 1, 0, 0, 0, 262, 2099, 1, 0, 0, 0, 264, 2104, 1, 0, 0, 0, 266, 2127, 1, 0, 0, 0, 268, 2132, 1, 0, 0, 0, 270, 2243, 1, 0, 0, 0, 272, 2245, 1, 0, 0, 0, 274, 2250, 1, 0, 0, 0, 276, 2252, 1, 0, 0, 0, 278, 2256, 1, 0, 0, 0, 280, 2260, 1, 0, 0, 0, 282, 2276, 1, 0, 0, 0, 284, 2290, 1, 0, 0, 0, 286, 2298, 1, 0, 0, 0, 288, 2300, 1, 0, 0, 0, 290, 2303, 1, 0, 0, 0, 292, 2305, 1, 0, 0, 0, 294, 2318, 1, 0, 0, 0, 296, 2320, 1, 0, 0, 0, 298, 2330, 1, 0, 0, 0, 300, 2335, 1, 0, 0, 0, 302, 2346, 1, 0, 0, 0, 304, 2353, 1, 0, 0, 0, 306, 2363, 1, 0, 0, 0, 308, 2431, 1, 0, 0, 0, 310, 2508, 1, 0, 0, 0, 312, 2515, 1, 0, 0, 0, 314, 2518, 1, 0, 0, 0, 316, 2523, 1, 0, 0, 0, 318, 2673, 1, 0, 0, 0, 320, 2679, 1, 0, 0, 0, 322, 2686, 1, 0, 0, 0, 324, 2692, 1, 0, 0, 0, 326, 2698, 1, 0, 0, 0, 328, 2704, 1, 0, 0, 0, 330, 2710, 1, 0, 0, 0, 332, 2716, 1, 0, 0, 0, 334, 2722, 1, 0, 0, 0, 336, 2728, 1, 0, 0, 0, 338, 2735, 1, 0, 0, 0, 340, 2740, 1, 0, 0, 0, 342, 2746, 1, 0, 0, 0, 344, 2773, 1, 0, 0, 0, 346, 2787, 1, 0, 0, 0, 348, 2792, 1, 0, 0, 0, 350, 2809, 1, 0, 0, 0, 352, 2811, 1, 0, 0, 0, 354, 2821, 1, 0, 0, 0, 356, 2845, 1, 0, 0, 0, 358, 2850, 1, 0, 0, 0, 360, 2866, 1, 0, 0, 0, 362, 2887, 1, 0, 0, 0, 364, 2889, 1, 0, 0, 0, 366, 2894, 1, 0, 0, 0, 368, 2907, 1, 0, 0, 0, 370, 371, 7, 0, 0, 0, 371, 1, 1, 0, 0, 0, 372, 384, 5, 288, 0, 0, 373, 374, 3, 4, 2, 0, 374, 375, 5, 265, 0, 0, 375, 377, 1, 0, 0, 0, 376, 373, 1, 0, 0, 0, 377, 380, 1, 0, 0, 0, 378, 376, 1, 0, 0, 0, 378, 379, 1, 0, 0, 0, 379, 381, 1, 0, 0, 0, 380, 378, 1, 0, 0, 0, 381, 384, 3, 4, 2, 0, 382, 384, 5, 264, 0, 0, 383, 372, 1, 0, 0, 0, 383, 378, 1, 0, 0, 0, 383, 382, 1, 0, 0, 0, 384, 3, 1, 0, 0, 0, 385, 386, 7, 1, 0, 0, 386, 5, 1, 0, 0, 0, 387, 388, 5, 263, 0, 0, 388, 390, 5, 266, 0, 0, 389, 387, 1, 0, 0, 0, 390, 393, 1, 0, 0, 0, 391, 389, 1, 0, 0, 0, 391, 392, 1, 0, 0, 0, 392, 394, 1, 0, 0, 0, 393, 391, 1, 0, 0, 0, 394, 395, 5, 263, 0, 0, 395, 7, 1, 0, 0, 0, 396, 398, 3, 10, 5, 0, 397, 396, 1, 0, 0, 0, 398, 401, 1, 0, 0, 0, 399, 397, 1, 0, 0, 0, 399, 400, 1, 0, 0, 0, 400, 9, 1, 0, 0, 0, 401, 399, 1, 0, 0, 0, 402, 403, 3, 74, 37, 0, 403, 404, 5, 17, 0, 0, 404, 405, 3, 82, 41, 0, 405, 406, 5, 18, 0, 0, 406, 453, 1, 0, 0, 0, 407, 408, 3, 72, 36, 0, 408, 409, 5, 17, 0, 0, 409, 410, 3, 8, 4, 0, 410, 411, 5, 18, 0, 0, 411, 453, 1, 0, 0, 0, 412, 413, 3, 256, 128, 0, 413, 414, 5, 17, 0, 0, 414, 415, 3, 268, 134, 0, 415, 416, 5, 18, 0, 0, 416, 453, 1, 0, 0, 0, 417, 453, 3, 222, 111, 0, 418, 453, 3, 296, 148, 0, 419, 453, 3, 70, 35, 0, 420, 453, 3, 66, 33, 0, 421, 453, 3, 88, 44, 0, 422, 453, 3, 90, 45, 0, 423, 453, 3, 22, 11, 0, 424, 425, 3, 346, 173, 0, 425, 426, 5, 17, 0, 0, 426, 427, 3, 348, 174, 0, 427, 428, 5, 18, 0, 0, 428, 453, 1, 0, 0, 0, 429, 430, 3, 352, 176, 0, 430, 431, 5, 17, 0, 0, 431, 432, 3, 358, 179, 0, 432, 433, 5, 18, 0, 0, 433, 453, 1, 0, 0, 0, 434, 435, 3, 362, 181, 0, 435, 436, 5, 17, 0, 0, 436, 437, 3, 366, 183, 0, 437, 438, 5, 18, 0, 0, 438, 453, 1, 0, 0, 0, 439, 453, 3, 64, 32, 0, 440, 453, 3, 174, 87, 0, 441, 453, 3, 342, 171, 0, 442, 453, 3, 12, 6, 0, 443, 453, 3, 14, 7, 0, 444, 453, 3, 16, 8, 0, 445, 453, 3, 18, 9, 0, 446, 453, 3, 20, 10, 0, 447, 453, 3, 26, 13, 0, 448, 453, 3, 42, 21, 0, 449, 453, 3, 40, 20, 0, 450, 453, 3, 30, 15, 0, 451, 453, 3, 24, 12, 0, 452, 402, 1, 0, 0, 0, 452, 407, 1, 0, 0, 0, 452, 412, 1, 0, 0, 0, 452, 417, 1, 0, 0, 0, 452, 418, 1, 0, 0, 0, 452, 419, 1, 0, 0, 0, 452, 420, 1, 0, 0, 0, 452, 421, 1, 0, 0, 0, 452, 422, 1, 0, 0, 0, 452, 423, 1, 0, 0, 0, 452, 424, 1, 0, 0, 0, 452, 429, 1, 0, 0, 0, 452, 434, 1, 0, 0, 0, 452, 439, 1, 0, 0, 0, 452, 440, 1, 0, 0, 0, 452, 441, 1, 0, 0, 0, 452, 442, 1, 0, 0, 0, 452, 443, 1, 0, 0, 0, 452, 444, 1, 0, 0, 0, 452, 445, 1, 0, 0, 0, 452, 446, 1, 0, 0, 0, 452, 447, 1, 0, 0, 0, 452, 448, 1, 0, 0, 0, 452, 449, 1, 0, 0, 0, 452, 450, 1, 0, 0, 0, 452, 451, 1, 0, 0, 0, 453, 11, 1, 0, 0, 0, 454, 455, 5, 19, 0, 0, 455, 456, 3, 32, 16, 0, 456, 13, 1, 0, 0, 0, 457, 458, 5, 20, 0, 0, 458, 459, 3, 32, 16, 0, 459, 15, 1, 0, 0, 0, 460, 461, 5, 21, 0, 0, 461, 462, 5, 22, 0, 0, 462, 463, 3, 32, 16, 0, 463, 17, 1, 0, 0, 0, 464, 465, 5, 23, 0, 0, 465, 466, 3, 34, 17, 0, 466, 19, 1, 0, 0, 0, 467, 468, 5, 24, 0, 0, 468, 469, 3, 34, 17, 0, 469, 21, 1, 0, 0, 0, 470, 471, 5, 25, 0, 0, 471, 472, 3, 98, 49, 0, 472, 473, 3, 2, 1, 0, 473, 474, 5, 17, 0, 0, 474, 475, 3, 142, 71, 0, 475, 476, 5, 18, 0, 0, 476, 23, 1, 0, 0, 0, 477, 478, 5, 26, 0, 0, 478, 25, 1, 0, 0, 0, 479, 480, 5, 27, 0, 0, 480, 494, 3, 28, 14, 0, 481, 482, 5, 27, 0, 0, 482, 483, 3, 28, 14, 0, 483, 484, 5, 28, 0, 0, 484, 485, 3, 28, 14, 0, 485, 494, 1, 0, 0, 0, 486, 487, 5, 27, 0, 0, 487, 488, 3, 28, 14, 0, 488, 489, 5, 28, 0, 0, 489, 490, 3, 28, 14, 0, 490, 491, 5, 28, 0, 0, 491, 492, 3, 28, 14, 0, 492, 494, 1, 0, 0, 0, 493, 479, 1, 0, 0, 0, 493, 481, 1, 0, 0, 0, 493, 486, 1, 0, 0, 0, 494, 27, 1, 0, 0, 0, 495, 496, 7, 2, 0, 0, 496, 29, 1, 0, 0, 0, 497, 498, 5, 29, 0, 0, 498, 502, 5, 17, 0, 0, 499, 501, 3, 138, 69, 0, 500, 499, 1, 0, 0, 0, 501, 504, 1, 0, 0, 0, 502, 500, 1, 0, 0, 0, 502, 503, 1, 0, 0, 0, 503, 505, 1, 0, 0, 0, 504, 502, 1, 0, 0, 0, 505, 506, 5, 18, 0, 0, 506, 31, 1, 0, 0, 0, 507, 508, 5, 173, 0, 0, 508, 33, 1, 0, 0, 0, 509, 510, 7, 3, 0, 0, 510, 35, 1, 0, 0, 0, 511, 527, 5, 175, 0, 0, 512, 513, 3, 32, 16, 0, 513, 514, 5, 265, 0, 0, 514, 527, 1, 0, 0, 0, 515, 527, 3, 32, 16, 0, 516, 517, 5, 188, 0, 0, 517, 518, 5, 30, 0, 0, 518, 519, 3, 32, 16, 0, 519, 520, 5, 31, 0, 0, 520, 527, 1, 0, 0, 0, 521, 522, 5, 189, 0, 0, 522, 523, 5, 30, 0, 0, 523, 524, 3, 34, 17, 0, 524, 525, 5, 31, 0, 0, 525, 527, 1, 0, 0, 0, 526, 511, 1, 0, 0, 0, 526, 512, 1, 0, 0, 0, 526, 515, 1, 0, 0, 0, 526, 516, 1, 0, 0, 0, 526, 521, 1, 0, 0, 0, 527, 37, 1, 0, 0, 0, 528, 531, 3, 32, 16, 0, 529, 531, 5, 262, 0, 0, 530, 528, 1, 0, 0, 0, 530, 529, 1, 0, 0, 0, 531, 39, 1, 0, 0, 0, 532, 533, 5, 267, 0, 0, 533, 549, 5, 289, 0, 0, 534, 535, 5, 267, 0, 0, 535, 536, 5, 289, 0, 0, 536, 549, 5, 263, 0, 0, 537, 538, 5, 268, 0, 0, 538, 549, 5, 289, 0, 0, 539, 540, 5, 269, 0, 0, 540, 549, 5, 289, 0, 0, 541, 542, 5, 270, 0, 0, 542, 549, 5, 289, 0, 0, 543, 549, 5, 271, 0, 0, 544, 549, 5, 272, 0, 0, 545, 546, 5, 273, 0, 0, 546, 549, 5, 263, 0, 0, 547, 549, 5, 32, 0, 0, 548, 532, 1, 0, 0, 0, 548, 534, 1, 0, 0, 0, 548, 537, 1, 0, 0, 0, 548, 539, 1, 0, 0, 0, 548, 541, 1, 0, 0, 0, 548, 543, 1, 0, 0, 0, 548, 544, 1, 0, 0, 0, 548, 545, 1, 0, 0, 0, 548, 547, 1, 0, 0, 0, 549, 41, 1, 0, 0, 0, 550, 551, 5, 33, 0, 0, 551, 552, 3, 160, 80, 0, 552, 553, 5, 34, 0, 0, 553, 554, 3, 2, 1, 0, 554, 576, 1, 0, 0, 0, 555, 556, 5, 33, 0, 0, 556, 557, 3, 138, 69, 0, 557, 558, 5, 34, 0, 0, 558, 559, 3, 2, 1, 0, 559, 576, 1, 0, 0, 0, 560, 561, 5, 33, 0, 0, 561, 562, 3, 198, 99, 0, 562, 563, 5, 34, 0, 0, 563, 564, 3, 2, 1, 0, 564, 576, 1, 0, 0, 0, 565, 566, 5, 33, 0, 0, 566, 567, 3, 44, 22, 0, 567, 568, 5, 34, 0, 0, 568, 569, 3, 2, 1, 0, 569, 576, 1, 0, 0, 0, 570, 571, 5, 33, 0, 0, 571, 572, 3, 46, 23, 0, 572, 573, 5, 34, 0, 0, 573, 574, 3, 2, 1, 0, 574, 576, 1, 0, 0, 0, 575, 550, 1, 0, 0, 0, 575, 555, 1, 0, 0, 0, 575, 560, 1, 0, 0, 0, 575, 565, 1, 0, 0, 0, 575, 570, 1, 0, 0, 0, 576, 43, 1, 0, 0, 0, 577, 578, 5, 35, 0, 0, 578, 599, 3, 48, 24, 0, 579, 580, 5, 35, 0, 0, 580, 581, 3, 48, 24, 0, 581, 582, 5, 36, 0, 0, 582, 583, 3, 6, 3, 0, 583, 599, 1, 0, 0, 0, 584, 585, 5, 35, 0, 0, 585, 586, 3, 48, 24, 0, 586, 587, 5, 36, 0, 0, 587, 588, 5, 17, 0, 0, 588, 589, 3, 52, 26, 0, 589, 590, 5, 18, 0, 0, 590, 599, 1, 0, 0, 0, 591, 592, 5, 35, 0, 0, 592, 593, 3, 48, 24, 0, 593, 594, 5, 36, 0, 0, 594, 595, 5, 30, 0, 0, 595, 596, 3, 312, 156, 0, 596, 597, 5, 31, 0, 0, 597, 599, 1, 0, 0, 0, 598, 577, 1, 0, 0, 0, 598, 579, 1, 0, 0, 0, 598, 584, 1, 0, 0, 0, 598, 591, 1, 0, 0, 0, 599, 45, 1, 0, 0, 0, 600, 601, 5, 35, 0, 0, 601, 602, 5, 30, 0, 0, 602, 603, 3, 50, 25, 0, 603, 604, 5, 31, 0, 0, 604, 605, 3, 48, 24, 0, 605, 635, 1, 0, 0, 0, 606, 607, 5, 35, 0, 0, 607, 608, 5, 30, 0, 0, 608, 609, 3, 50, 25, 0, 609, 610, 5, 31, 0, 0, 610, 611, 3, 48, 24, 0, 611, 612, 5, 36, 0, 0, 612, 613, 3, 6, 3, 0, 613, 635, 1, 0, 0, 0, 614, 615, 5, 35, 0, 0, 615, 616, 5, 30, 0, 0, 616, 617, 3, 50, 25, 0, 617, 618, 5, 31, 0, 0, 618, 619, 3, 48, 24, 0, 619, 620, 5, 36, 0, 0, 620, 621, 5, 17, 0, 0, 621, 622, 3, 52, 26, 0, 622, 623, 5, 18, 0, 0, 623, 635, 1, 0, 0, 0, 624, 625, 5, 35, 0, 0, 625, 626, 5, 30, 0, 0, 626, 627, 3, 50, 25, 0, 627, 628, 5, 31, 0, 0, 628, 629, 3, 48, 24, 0, 629, 630, 5, 36, 0, 0, 630, 631, 5, 30, 0, 0, 631, 632, 3, 312, 156, 0, 632, 633, 5, 31, 0, 0, 633, 635, 1, 0, 0, 0, 634, 600, 1, 0, 0, 0, 634, 606, 1, 0, 0, 0, 634, 614, 1, 0, 0, 0, 634, 624, 1, 0, 0, 0, 635, 47, 1, 0, 0, 0, 636, 637, 3, 190, 95, 0, 637, 49, 1, 0, 0, 0, 638, 641, 3, 146, 73, 0, 639, 641, 3, 198, 99, 0, 640, 638, 1, 0, 0, 0, 640, 639, 1, 0, 0, 0, 641, 51, 1, 0, 0, 0, 642, 643, 3, 54, 27, 0, 643, 644, 3, 56, 28, 0, 644, 53, 1, 0, 0, 0, 645, 648, 3, 318, 159, 0, 646, 648, 3, 40, 20, 0, 647, 645, 1, 0, 0, 0, 647, 646, 1, 0, 0, 0, 648, 651, 1, 0, 0, 0, 649, 647, 1, 0, 0, 0, 649, 650, 1, 0, 0, 0, 650, 55, 1, 0, 0, 0, 651, 649, 1, 0, 0, 0, 652, 653, 3, 58, 29, 0, 653, 654, 3, 60, 30, 0, 654, 655, 3, 2, 1, 0, 655, 656, 5, 36, 0, 0, 656, 657, 3, 318, 159, 0, 657, 660, 1, 0, 0, 0, 658, 660, 3, 40, 20, 0, 659, 652, 1, 0, 0, 0, 659, 658, 1, 0, 0, 0, 660, 663, 1, 0, 0, 0, 661, 659, 1, 0, 0, 0, 661, 662, 1, 0, 0, 0, 662, 57, 1, 0, 0, 0, 663, 661, 1, 0, 0, 0, 664, 665, 7, 4, 0, 0, 665, 59, 1, 0, 0, 0, 666, 668, 3, 62, 31, 0, 667, 669, 5, 261, 0, 0, 668, 667, 1, 0, 0, 0, 668, 669, 1, 0, 0, 0, 669, 61, 1, 0, 0, 0, 670, 680, 3, 166, 83, 0, 671, 680, 3, 2, 1, 0, 672, 680, 5, 196, 0, 0, 673, 680, 5, 197, 0, 0, 674, 675, 5, 202, 0, 0, 675, 676, 5, 39, 0, 0, 676, 680, 5, 264, 0, 0, 677, 678, 5, 202, 0, 0, 678, 680, 3, 138, 69, 0, 679, 670, 1, 0, 0, 0, 679, 671, 1, 0, 0, 0, 679, 672, 1, 0, 0, 0, 679, 673, 1, 0, 0, 0, 679, 674, 1, 0, 0, 0, 679, 677, 1, 0, 0, 0, 680, 63, 1, 0, 0, 0, 681, 682, 5, 198, 0, 0, 682, 683, 5, 40, 0, 0, 683, 688, 3, 2, 1, 0, 684, 685, 5, 198, 0, 0, 685, 688, 3, 2, 1, 0, 686, 688, 5, 198, 0, 0, 687, 681, 1, 0, 0, 0, 687, 684, 1, 0, 0, 0, 687, 686, 1, 0, 0, 0, 688, 65, 1, 0, 0, 0, 689, 690, 5, 41, 0, 0, 690, 691, 5, 42, 0, 0, 691, 692, 3, 32, 16, 0, 692, 693, 5, 43, 0, 0, 693, 694, 3, 68, 34, 0, 694, 695, 5, 44, 0, 0, 695, 696, 3, 0, 0, 0, 696, 67, 1, 0, 0, 0, 697, 710, 6, 34, -1, 0, 698, 699, 10, 5, 0, 0, 699, 709, 5, 186, 0, 0, 700, 701, 10, 4, 0, 0, 701, 709, 5, 187, 0, 0, 702, 703, 10, 3, 0, 0, 703, 709, 5, 45, 0, 0, 704, 705, 10, 2, 0, 0, 705, 709, 5, 46, 0, 0, 706, 707, 10, 1, 0, 0, 707, 709, 5, 47, 0, 0, 708, 698, 1, 0, 0, 0, 708, 700, 1, 0, 0, 0, 708, 702, 1, 0, 0, 0, 708, 704, 1, 0, 0, 0, 708, 706, 1, 0, 0, 0, 709, 712, 1, 0, 0, 0, 710, 708, 1, 0, 0, 0, 710, 711, 1, 0, 0, 0, 711, 69, 1, 0, 0, 0, 712, 710, 1, 0, 0, 0, 713, 714, 5, 48, 0, 0, 714, 715, 5, 36, 0, 0, 715, 716, 5, 30, 0, 0, 716, 717, 3, 312, 156, 0, 717, 718, 5, 31, 0, 0, 718, 71, 1, 0, 0, 0, 719, 720, 5, 49, 0, 0, 720, 721, 3, 2, 1, 0, 721, 73, 1, 0, 0, 0, 722, 726, 5, 50, 0, 0, 723, 725, 3, 76, 38, 0, 724, 723, 1, 0, 0, 0, 725, 728, 1, 0, 0, 0, 726, 724, 1, 0, 0, 0, 726, 727, 1, 0, 0, 0, 727, 729, 1, 0, 0, 0, 728, 726, 1, 0, 0, 0, 729, 730, 3, 2, 1, 0, 730, 731, 3, 204, 102, 0, 731, 732, 3, 78, 39, 0, 732, 733, 3, 80, 40, 0, 733, 75, 1, 0, 0, 0, 734, 772, 5, 51, 0, 0, 735, 772, 5, 52, 0, 0, 736, 772, 5, 199, 0, 0, 737, 772, 5, 202, 0, 0, 738, 772, 5, 221, 0, 0, 739, 772, 5, 53, 0, 0, 740, 772, 5, 54, 0, 0, 741, 772, 5, 55, 0, 0, 742, 772, 5, 56, 0, 0, 743, 772, 5, 244, 0, 0, 744, 772, 5, 15, 0, 0, 745, 772, 5, 224, 0, 0, 746, 772, 5, 57, 0, 0, 747, 772, 5, 58, 0, 0, 748, 772, 5, 59, 0, 0, 749, 772, 5, 60, 0, 0, 750, 772, 5, 61, 0, 0, 751, 752, 5, 62, 0, 0, 752, 772, 5, 51, 0, 0, 753, 754, 5, 62, 0, 0, 754, 772, 5, 52, 0, 0, 755, 756, 5, 62, 0, 0, 756, 772, 5, 63, 0, 0, 757, 758, 5, 62, 0, 0, 758, 772, 5, 64, 0, 0, 759, 760, 5, 62, 0, 0, 760, 772, 5, 65, 0, 0, 761, 762, 5, 62, 0, 0, 762, 772, 5, 66, 0, 0, 763, 772, 5, 67, 0, 0, 764, 772, 5, 68, 0, 0, 765, 772, 5, 69, 0, 0, 766, 767, 5, 70, 0, 0, 767, 768, 5, 30, 0, 0, 768, 769, 3, 32, 16, 0, 769, 770, 5, 31, 0, 0, 770, 772, 1, 0, 0, 0, 771, 734, 1, 0, 0, 0, 771, 735, 1, 0, 0, 0, 771, 736, 1, 0, 0, 0, 771, 737, 1, 0, 0, 0, 771, 738, 1, 0, 0, 0, 771, 739, 1, 0, 0, 0, 771, 740, 1, 0, 0, 0, 771, 741, 1, 0, 0, 0, 771, 742, 1, 0, 0, 0, 771, 743, 1, 0, 0, 0, 771, 744, 1, 0, 0, 0, 771, 745, 1, 0, 0, 0, 771, 746, 1, 0, 0, 0, 771, 747, 1, 0, 0, 0, 771, 748, 1, 0, 0, 0, 771, 749, 1, 0, 0, 0, 771, 750, 1, 0, 0, 0, 771, 751, 1, 0, 0, 0, 771, 753, 1, 0, 0, 0, 771, 755, 1, 0, 0, 0, 771, 757, 1, 0, 0, 0, 771, 759, 1, 0, 0, 0, 771, 761, 1, 0, 0, 0, 771, 763, 1, 0, 0, 0, 771, 764, 1, 0, 0, 0, 771, 765, 1, 0, 0, 0, 771, 766, 1, 0, 0, 0, 772, 77, 1, 0, 0, 0, 773, 777, 1, 0, 0, 0, 774, 775, 5, 71, 0, 0, 775, 777, 3, 146, 73, 0, 776, 773, 1, 0, 0, 0, 776, 774, 1, 0, 0, 0, 777, 79, 1, 0, 0, 0, 778, 782, 1, 0, 0, 0, 779, 780, 5, 72, 0, 0, 780, 782, 3, 84, 42, 0, 781, 778, 1, 0, 0, 0, 781, 779, 1, 0, 0, 0, 782, 81, 1, 0, 0, 0, 783, 785, 3, 220, 110, 0, 784, 783, 1, 0, 0, 0, 785, 788, 1, 0, 0, 0, 786, 784, 1, 0, 0, 0, 786, 787, 1, 0, 0, 0, 787, 83, 1, 0, 0, 0, 788, 786, 1, 0, 0, 0, 789, 790, 3, 146, 73, 0, 790, 791, 5, 28, 0, 0, 791, 793, 1, 0, 0, 0, 792, 789, 1, 0, 0, 0, 793, 796, 1, 0, 0, 0, 794, 792, 1, 0, 0, 0, 794, 795, 1, 0, 0, 0, 795, 797, 1, 0, 0, 0, 796, 794, 1, 0, 0, 0, 797, 798, 3, 146, 73, 0, 798, 85, 1, 0, 0, 0, 799, 800, 7, 5, 0, 0, 800, 87, 1, 0, 0, 0, 801, 802, 3, 86, 43, 0, 802, 803, 3, 32, 16, 0, 803, 804, 5, 264, 0, 0, 804, 905, 1, 0, 0, 0, 805, 806, 3, 86, 43, 0, 806, 807, 3, 32, 16, 0, 807, 905, 1, 0, 0, 0, 808, 809, 3, 86, 43, 0, 809, 810, 3, 32, 16, 0, 810, 811, 5, 75, 0, 0, 811, 812, 3, 32, 16, 0, 812, 813, 5, 264, 0, 0, 813, 905, 1, 0, 0, 0, 814, 815, 3, 86, 43, 0, 815, 816, 3, 32, 16, 0, 816, 817, 5, 75, 0, 0, 817, 818, 3, 32, 16, 0, 818, 905, 1, 0, 0, 0, 819, 820, 3, 86, 43, 0, 820, 821, 3, 32, 16, 0, 821, 822, 5, 75, 0, 0, 822, 823, 3, 32, 16, 0, 823, 824, 5, 28, 0, 0, 824, 825, 3, 32, 16, 0, 825, 826, 5, 264, 0, 0, 826, 905, 1, 0, 0, 0, 827, 828, 3, 86, 43, 0, 828, 829, 3, 32, 16, 0, 829, 830, 5, 75, 0, 0, 830, 831, 3, 32, 16, 0, 831, 832, 5, 28, 0, 0, 832, 833, 3, 32, 16, 0, 833, 905, 1, 0, 0, 0, 834, 835, 3, 86, 43, 0, 835, 836, 3, 32, 16, 0, 836, 837, 5, 28, 0, 0, 837, 838, 3, 32, 16, 0, 838, 839, 5, 75, 0, 0, 839, 840, 3, 32, 16, 0, 840, 841, 5, 264, 0, 0, 841, 905, 1, 0, 0, 0, 842, 843, 3, 86, 43, 0, 843, 844, 3, 32, 16, 0, 844, 845, 5, 28, 0, 0, 845, 846, 3, 32, 16, 0, 846, 847, 5, 75, 0, 0, 847, 848, 3, 32, 16, 0, 848, 905, 1, 0, 0, 0, 849, 850, 3, 86, 43, 0, 850, 851, 3, 32, 16, 0, 851, 852, 5, 28, 0, 0, 852, 853, 3, 32, 16, 0, 853, 854, 5, 75, 0, 0, 854, 855, 3, 32, 16, 0, 855, 856, 5, 28, 0, 0, 856, 857, 3, 32, 16, 0, 857, 858, 5, 264, 0, 0, 858, 905, 1, 0, 0, 0, 859, 860, 3, 86, 43, 0, 860, 861, 3, 32, 16, 0, 861, 862, 5, 28, 0, 0, 862, 863, 3, 32, 16, 0, 863, 864, 5, 75, 0, 0, 864, 865, 3, 32, 16, 0, 865, 866, 5, 28, 0, 0, 866, 867, 3, 32, 16, 0, 867, 905, 1, 0, 0, 0, 868, 869, 3, 86, 43, 0, 869, 870, 3, 32, 16, 0, 870, 871, 5, 263, 0, 0, 871, 905, 1, 0, 0, 0, 872, 873, 3, 86, 43, 0, 873, 874, 3, 32, 16, 0, 874, 875, 5, 75, 0, 0, 875, 876, 3, 32, 16, 0, 876, 877, 5, 263, 0, 0, 877, 905, 1, 0, 0, 0, 878, 879, 3, 86, 43, 0, 879, 880, 3, 32, 16, 0, 880, 881, 5, 75, 0, 0, 881, 882, 3, 32, 16, 0, 882, 883, 5, 28, 0, 0, 883, 884, 3, 32, 16, 0, 884, 885, 5, 263, 0, 0, 885, 905, 1, 0, 0, 0, 886, 887, 3, 86, 43, 0, 887, 888, 3, 32, 16, 0, 888, 889, 5, 28, 0, 0, 889, 890, 3, 32, 16, 0, 890, 891, 5, 75, 0, 0, 891, 892, 3, 32, 16, 0, 892, 893, 5, 263, 0, 0, 893, 905, 1, 0, 0, 0, 894, 895, 3, 86, 43, 0, 895, 896, 3, 32, 16, 0, 896, 897, 5, 28, 0, 0, 897, 898, 3, 32, 16, 0, 898, 899, 5, 75, 0, 0, 899, 900, 3, 32, 16, 0, 900, 901, 5, 28, 0, 0, 901, 902, 3, 32, 16, 0, 902, 903, 5, 263, 0, 0, 903, 905, 1, 0, 0, 0, 904, 801, 1, 0, 0, 0, 904, 805, 1, 0, 0, 0, 904, 808, 1, 0, 0, 0, 904, 814, 1, 0, 0, 0, 904, 819, 1, 0, 0, 0, 904, 827, 1, 0, 0, 0, 904, 834, 1, 0, 0, 0, 904, 842, 1, 0, 0, 0, 904, 849, 1, 0, 0, 0, 904, 859, 1, 0, 0, 0, 904, 868, 1, 0, 0, 0, 904, 872, 1, 0, 0, 0, 904, 878, 1, 0, 0, 0, 904, 886, 1, 0, 0, 0, 904, 894, 1, 0, 0, 0, 905, 89, 1, 0, 0, 0, 906, 910, 5, 21, 0, 0, 907, 909, 3, 92, 46, 0, 908, 907, 1, 0, 0, 0, 909, 912, 1, 0, 0, 0, 910, 908, 1, 0, 0, 0, 910, 911, 1, 0, 0, 0, 911, 913, 1, 0, 0, 0, 912, 910, 1, 0, 0, 0, 913, 914, 3, 2, 1, 0, 914, 915, 3, 94, 47, 0, 915, 916, 5, 180, 0, 0, 916, 917, 5, 36, 0, 0, 917, 918, 5, 30, 0, 0, 918, 919, 3, 312, 156, 0, 919, 920, 5, 31, 0, 0, 920, 921, 3, 94, 47, 0, 921, 933, 1, 0, 0, 0, 922, 926, 5, 21, 0, 0, 923, 925, 3, 92, 46, 0, 924, 923, 1, 0, 0, 0, 925, 928, 1, 0, 0, 0, 926, 924, 1, 0, 0, 0, 926, 927, 1, 0, 0, 0, 927, 929, 1, 0, 0, 0, 928, 926, 1, 0, 0, 0, 929, 930, 3, 2, 1, 0, 930, 931, 3, 94, 47, 0, 931, 933, 1, 0, 0, 0, 932, 906, 1, 0, 0, 0, 932, 922, 1, 0, 0, 0, 933, 91, 1, 0, 0, 0, 934, 935, 5, 76, 0, 0, 935, 93, 1, 0, 0, 0, 936, 939, 1, 0, 0, 0, 937, 939, 5, 298, 0, 0, 938, 936, 1, 0, 0, 0, 938, 937, 1, 0, 0, 0, 939, 95, 1, 0, 0, 0, 940, 941, 7, 6, 0, 0, 941, 97, 1, 0, 0, 0, 942, 944, 3, 96, 48, 0, 943, 942, 1, 0, 0, 0, 944, 947, 1, 0, 0, 0, 945, 943, 1, 0, 0, 0, 945, 946, 1, 0, 0, 0, 946, 99, 1, 0, 0, 0, 947, 945, 1, 0, 0, 0, 948, 949, 5, 275, 0, 0, 949, 101, 1, 0, 0, 0, 950, 951, 5, 276, 0, 0, 951, 103, 1, 0, 0, 0, 952, 953, 5, 277, 0, 0, 953, 105, 1, 0, 0, 0, 954, 955, 5, 278, 0, 0, 955, 107, 1, 0, 0, 0, 956, 957, 5, 279, 0, 0, 957, 109, 1, 0, 0, 0, 958, 959, 5, 282, 0, 0, 959, 111, 1, 0, 0, 0, 960, 961, 5, 280, 0, 0, 961, 113, 1, 0, 0, 0, 962, 963, 5, 286, 0, 0, 963, 115, 1, 0, 0, 0, 964, 965, 5, 284, 0, 0, 965, 117, 1, 0, 0, 0, 966, 967, 5, 285, 0, 0, 967, 119, 1, 0, 0, 0, 968, 969, 5, 281, 0, 0, 969, 121, 1, 0, 0, 0, 970, 971, 5, 287, 0, 0, 971, 123, 1, 0, 0, 0, 972, 973, 5, 283, 0, 0, 973, 125, 1, 0, 0, 0, 974, 1057, 3, 100, 50, 0, 975, 976, 3, 102, 51, 0, 976, 977, 3, 32, 16, 0, 977, 1057, 1, 0, 0, 0, 978, 979, 3, 102, 51, 0, 979, 980, 3, 0, 0, 0, 980, 1057, 1, 0, 0, 0, 981, 982, 3, 104, 52, 0, 982, 983, 3, 32, 16, 0, 983, 1057, 1, 0, 0, 0, 984, 985, 3, 106, 53, 0, 985, 986, 3, 34, 17, 0, 986, 1057, 1, 0, 0, 0, 987, 988, 3, 108, 54, 0, 988, 989, 3, 36, 18, 0, 989, 1057, 1, 0, 0, 0, 990, 991, 3, 108, 54, 0, 991, 992, 3, 34, 17, 0, 992, 1057, 1, 0, 0, 0, 993, 994, 3, 108, 54, 0, 994, 995, 5, 30, 0, 0, 995, 996, 3, 312, 156, 0, 996, 997, 5, 31, 0, 0, 997, 1057, 1, 0, 0, 0, 998, 999, 3, 108, 54, 0, 999, 1000, 5, 84, 0, 0, 1000, 1001, 5, 30, 0, 0, 1001, 1002, 3, 312, 156, 0, 1002, 1003, 5, 31, 0, 0, 1003, 1057, 1, 0, 0, 0, 1004, 1005, 3, 110, 55, 0, 1005, 1006, 3, 32, 16, 0, 1006, 1057, 1, 0, 0, 0, 1007, 1008, 3, 110, 55, 0, 1008, 1009, 3, 0, 0, 0, 1009, 1057, 1, 0, 0, 0, 1010, 1011, 3, 112, 56, 0, 1011, 1012, 3, 190, 95, 0, 1012, 1057, 1, 0, 0, 0, 1013, 1014, 3, 114, 57, 0, 1014, 1015, 3, 200, 100, 0, 1015, 1057, 1, 0, 0, 0, 1016, 1017, 3, 114, 57, 0, 1017, 1018, 3, 196, 98, 0, 1018, 1057, 1, 0, 0, 0, 1019, 1020, 3, 116, 58, 0, 1020, 1021, 3, 146, 73, 0, 1021, 1057, 1, 0, 0, 0, 1022, 1023, 3, 118, 59, 0, 1023, 1024, 3, 6, 3, 0, 1024, 1057, 1, 0, 0, 0, 1025, 1026, 3, 118, 59, 0, 1026, 1027, 5, 224, 0, 0, 1027, 1028, 5, 30, 0, 0, 1028, 1029, 3, 6, 3, 0, 1029, 1030, 5, 31, 0, 0, 1030, 1057, 1, 0, 0, 0, 1031, 1032, 3, 118, 59, 0, 1032, 1033, 5, 84, 0, 0, 1033, 1034, 5, 30, 0, 0, 1034, 1035, 3, 312, 156, 0, 1035, 1036, 5, 31, 0, 0, 1036, 1057, 1, 0, 0, 0, 1037, 1038, 3, 120, 60, 0, 1038, 1039, 3, 192, 96, 0, 1039, 1040, 3, 160, 80, 0, 1040, 1041, 3, 134, 67, 0, 1041, 1057, 1, 0, 0, 0, 1042, 1043, 3, 122, 61, 0, 1043, 1044, 3, 50, 25, 0, 1044, 1057, 1, 0, 0, 0, 1045, 1046, 3, 122, 61, 0, 1046, 1047, 3, 32, 16, 0, 1047, 1057, 1, 0, 0, 0, 1048, 1049, 3, 124, 62, 0, 1049, 1050, 5, 30, 0, 0, 1050, 1051, 3, 128, 64, 0, 1051, 1052, 5, 31, 0, 0, 1052, 1057, 1, 0, 0, 0, 1053, 1054, 3, 124, 62, 0, 1054, 1055, 5, 85, 0, 0, 1055, 1057, 1, 0, 0, 0, 1056, 974, 1, 0, 0, 0, 1056, 975, 1, 0, 0, 0, 1056, 978, 1, 0, 0, 0, 1056, 981, 1, 0, 0, 0, 1056, 984, 1, 0, 0, 0, 1056, 987, 1, 0, 0, 0, 1056, 990, 1, 0, 0, 0, 1056, 993, 1, 0, 0, 0, 1056, 998, 1, 0, 0, 0, 1056, 1004, 1, 0, 0, 0, 1056, 1007, 1, 0, 0, 0, 1056, 1010, 1, 0, 0, 0, 1056, 1013, 1, 0, 0, 0, 1056, 1016, 1, 0, 0, 0, 1056, 1019, 1, 0, 0, 0, 1056, 1022, 1, 0, 0, 0, 1056, 1025, 1, 0, 0, 0, 1056, 1031, 1, 0, 0, 0, 1056, 1037, 1, 0, 0, 0, 1056, 1042, 1, 0, 0, 0, 1056, 1045, 1, 0, 0, 0, 1056, 1048, 1, 0, 0, 0, 1056, 1053, 1, 0, 0, 0, 1057, 127, 1, 0, 0, 0, 1058, 1075, 1, 0, 0, 0, 1059, 1062, 3, 0, 0, 0, 1060, 1062, 3, 32, 16, 0, 1061, 1059, 1, 0, 0, 0, 1061, 1060, 1, 0, 0, 0, 1062, 1063, 1, 0, 0, 0, 1063, 1064, 5, 28, 0, 0, 1064, 1066, 1, 0, 0, 0, 1065, 1061, 1, 0, 0, 0, 1066, 1069, 1, 0, 0, 0, 1067, 1065, 1, 0, 0, 0, 1067, 1068, 1, 0, 0, 0, 1068, 1072, 1, 0, 0, 0, 1069, 1067, 1, 0, 0, 0, 1070, 1073, 3, 0, 0, 0, 1071, 1073, 3, 32, 16, 0, 1072, 1070, 1, 0, 0, 0, 1072, 1071, 1, 0, 0, 0, 1073, 1075, 1, 0, 0, 0, 1074, 1058, 1, 0, 0, 0, 1074, 1067, 1, 0, 0, 0, 1075, 129, 1, 0, 0, 0, 1076, 1082, 5, 86, 0, 0, 1077, 1078, 3, 160, 80, 0, 1078, 1079, 5, 28, 0, 0, 1079, 1081, 1, 0, 0, 0, 1080, 1077, 1, 0, 0, 0, 1081, 1084, 1, 0, 0, 0, 1082, 1080, 1, 0, 0, 0, 1082, 1083, 1, 0, 0, 0, 1083, 1085, 1, 0, 0, 0, 1084, 1082, 1, 0, 0, 0, 1085, 1086, 3, 160, 80, 0, 1086, 1087, 5, 87, 0, 0, 1087, 131, 1, 0, 0, 0, 1088, 1094, 5, 42, 0, 0, 1089, 1090, 3, 168, 84, 0, 1090, 1091, 5, 28, 0, 0, 1091, 1093, 1, 0, 0, 0, 1092, 1089, 1, 0, 0, 0, 1093, 1096, 1, 0, 0, 0, 1094, 1092, 1, 0, 0, 0, 1094, 1095, 1, 0, 0, 0, 1095, 1097, 1, 0, 0, 0, 1096, 1094, 1, 0, 0, 0, 1097, 1098, 3, 168, 84, 0, 1098, 1099, 5, 43, 0, 0, 1099, 133, 1, 0, 0, 0, 1100, 1106, 5, 30, 0, 0, 1101, 1102, 3, 136, 68, 0, 1102, 1103, 5, 28, 0, 0, 1103, 1105, 1, 0, 0, 0, 1104, 1101, 1, 0, 0, 0, 1105, 1108, 1, 0, 0, 0, 1106, 1104, 1, 0, 0, 0, 1106, 1107, 1, 0, 0, 0, 1107, 1109, 1, 0, 0, 0, 1108, 1106, 1, 0, 0, 0, 1109, 1110, 3, 136, 68, 0, 1110, 1111, 5, 31, 0, 0, 1111, 1114, 1, 0, 0, 0, 1112, 1114, 5, 85, 0, 0, 1113, 1100, 1, 0, 0, 0, 1113, 1112, 1, 0, 0, 0, 1114, 135, 1, 0, 0, 0, 1115, 1123, 5, 177, 0, 0, 1116, 1117, 3, 252, 126, 0, 1117, 1118, 3, 160, 80, 0, 1118, 1120, 3, 248, 124, 0, 1119, 1121, 3, 0, 0, 0, 1120, 1119, 1, 0, 0, 0, 1120, 1121, 1, 0, 0, 0, 1121, 1123, 1, 0, 0, 0, 1122, 1115, 1, 0, 0, 0, 1122, 1116, 1, 0, 0, 0, 1123, 137, 1, 0, 0, 0, 1124, 1125, 5, 42, 0, 0, 1125, 1126, 3, 2, 1, 0, 1126, 1127, 5, 43, 0, 0, 1127, 1128, 3, 140, 70, 0, 1128, 1150, 1, 0, 0, 0, 1129, 1130, 5, 42, 0, 0, 1130, 1131, 3, 196, 98, 0, 1131, 1132, 5, 43, 0, 0, 1132, 1133, 3, 140, 70, 0, 1133, 1150, 1, 0, 0, 0, 1134, 1135, 5, 42, 0, 0, 1135, 1136, 5, 262, 0, 0, 1136, 1137, 5, 43, 0, 0, 1137, 1150, 3, 140, 70, 0, 1138, 1139, 5, 42, 0, 0, 1139, 1140, 5, 198, 0, 0, 1140, 1141, 3, 2, 1, 0, 1141, 1142, 5, 43, 0, 0, 1142, 1143, 3, 140, 70, 0, 1143, 1150, 1, 0, 0, 0, 1144, 1150, 3, 140, 70, 0, 1145, 1150, 3, 196, 98, 0, 1146, 1150, 5, 257, 0, 0, 1147, 1150, 5, 258, 0, 0, 1148, 1150, 5, 259, 0, 0, 1149, 1124, 1, 0, 0, 0, 1149, 1129, 1, 0, 0, 0, 1149, 1134, 1, 0, 0, 0, 1149, 1138, 1, 0, 0, 0, 1149, 1144, 1, 0, 0, 0, 1149, 1145, 1, 0, 0, 0, 1149, 1146, 1, 0, 0, 0, 1149, 1147, 1, 0, 0, 0, 1149, 1148, 1, 0, 0, 0, 1150, 139, 1, 0, 0, 0, 1151, 1152, 3, 2, 1, 0, 1152, 1153, 5, 88, 0, 0, 1153, 1155, 1, 0, 0, 0, 1154, 1151, 1, 0, 0, 0, 1155, 1158, 1, 0, 0, 0, 1156, 1154, 1, 0, 0, 0, 1156, 1157, 1, 0, 0, 0, 1157, 1159, 1, 0, 0, 0, 1158, 1156, 1, 0, 0, 0, 1159, 1160, 3, 2, 1, 0, 1160, 141, 1, 0, 0, 0, 1161, 1163, 3, 144, 72, 0, 1162, 1161, 1, 0, 0, 0, 1163, 1166, 1, 0, 0, 0, 1164, 1162, 1, 0, 0, 0, 1164, 1165, 1, 0, 0, 0, 1165, 143, 1, 0, 0, 0, 1166, 1164, 1, 0, 0, 0, 1167, 1168, 5, 180, 0, 0, 1168, 1169, 5, 89, 0, 0, 1169, 1173, 3, 32, 16, 0, 1170, 1173, 3, 174, 87, 0, 1171, 1173, 3, 344, 172, 0, 1172, 1167, 1, 0, 0, 0, 1172, 1170, 1, 0, 0, 0, 1172, 1171, 1, 0, 0, 0, 1173, 145, 1, 0, 0, 0, 1174, 1186, 3, 138, 69, 0, 1175, 1176, 5, 42, 0, 0, 1176, 1177, 3, 2, 1, 0, 1177, 1178, 5, 43, 0, 0, 1178, 1186, 1, 0, 0, 0, 1179, 1180, 5, 42, 0, 0, 1180, 1181, 5, 198, 0, 0, 1181, 1182, 3, 2, 1, 0, 1182, 1183, 5, 43, 0, 0, 1183, 1186, 1, 0, 0, 0, 1184, 1186, 3, 160, 80, 0, 1185, 1174, 1, 0, 0, 0, 1185, 1175, 1, 0, 0, 0, 1185, 1179, 1, 0, 0, 0, 1185, 1184, 1, 0, 0, 0, 1186, 147, 1, 0, 0, 0, 1187, 1196, 1, 0, 0, 0, 1188, 1192, 3, 152, 76, 0, 1189, 1191, 3, 150, 75, 0, 1190, 1189, 1, 0, 0, 0, 1191, 1194, 1, 0, 0, 0, 1192, 1190, 1, 0, 0, 0, 1192, 1193, 1, 0, 0, 0, 1193, 1196, 1, 0, 0, 0, 1194, 1192, 1, 0, 0, 0, 1195, 1187, 1, 0, 0, 0, 1195, 1188, 1, 0, 0, 0, 1196, 149, 1, 0, 0, 0, 1197, 1215, 5, 262, 0, 0, 1198, 1215, 5, 261, 0, 0, 1199, 1200, 5, 42, 0, 0, 1200, 1201, 3, 32, 16, 0, 1201, 1202, 5, 43, 0, 0, 1202, 1215, 1, 0, 0, 0, 1203, 1204, 5, 42, 0, 0, 1204, 1205, 3, 32, 16, 0, 1205, 1206, 5, 266, 0, 0, 1206, 1207, 3, 32, 16, 0, 1207, 1208, 5, 43, 0, 0, 1208, 1215, 1, 0, 0, 0, 1209, 1210, 5, 42, 0, 0, 1210, 1211, 5, 266, 0, 0, 1211, 1212, 3, 32, 16, 0, 1212, 1213, 5, 43, 0, 0, 1213, 1215, 1, 0, 0, 0, 1214, 1197, 1, 0, 0, 0, 1214, 1198, 1, 0, 0, 0, 1214, 1199, 1, 0, 0, 0, 1214, 1203, 1, 0, 0, 0, 1214, 1209, 1, 0, 0, 0, 1215, 151, 1, 0, 0, 0, 1216, 1309, 1, 0, 0, 0, 1217, 1218, 5, 203, 0, 0, 1218, 1219, 5, 30, 0, 0, 1219, 1220, 3, 6, 3, 0, 1220, 1221, 5, 28, 0, 0, 1221, 1222, 3, 6, 3, 0, 1222, 1223, 5, 28, 0, 0, 1223, 1224, 3, 6, 3, 0, 1224, 1225, 5, 28, 0, 0, 1225, 1226, 3, 6, 3, 0, 1226, 1227, 5, 31, 0, 0, 1227, 1309, 1, 0, 0, 0, 1228, 1229, 5, 203, 0, 0, 1229, 1230, 5, 30, 0, 0, 1230, 1231, 3, 6, 3, 0, 1231, 1232, 5, 28, 0, 0, 1232, 1233, 3, 6, 3, 0, 1233, 1234, 5, 31, 0, 0, 1234, 1309, 1, 0, 0, 0, 1235, 1236, 5, 204, 0, 0, 1236, 1237, 5, 205, 0, 0, 1237, 1238, 5, 42, 0, 0, 1238, 1239, 3, 32, 16, 0, 1239, 1240, 5, 43, 0, 0, 1240, 1309, 1, 0, 0, 0, 1241, 1242, 5, 204, 0, 0, 1242, 1243, 5, 206, 0, 0, 1243, 1244, 5, 42, 0, 0, 1244, 1245, 3, 32, 16, 0, 1245, 1246, 5, 43, 0, 0, 1246, 1247, 3, 148, 74, 0, 1247, 1309, 1, 0, 0, 0, 1248, 1309, 5, 207, 0, 0, 1249, 1309, 5, 208, 0, 0, 1250, 1309, 5, 209, 0, 0, 1251, 1309, 5, 201, 0, 0, 1252, 1309, 5, 183, 0, 0, 1253, 1309, 5, 184, 0, 0, 1254, 1309, 5, 185, 0, 0, 1255, 1309, 5, 186, 0, 0, 1256, 1309, 5, 187, 0, 0, 1257, 1309, 5, 188, 0, 0, 1258, 1309, 5, 189, 0, 0, 1259, 1309, 5, 210, 0, 0, 1260, 1309, 5, 190, 0, 0, 1261, 1309, 5, 191, 0, 0, 1262, 1309, 5, 192, 0, 0, 1263, 1309, 5, 193, 0, 0, 1264, 1309, 5, 211, 0, 0, 1265, 1309, 5, 212, 0, 0, 1266, 1309, 5, 213, 0, 0, 1267, 1309, 5, 214, 0, 0, 1268, 1309, 5, 215, 0, 0, 1269, 1309, 5, 216, 0, 0, 1270, 1309, 5, 217, 0, 0, 1271, 1272, 5, 218, 0, 0, 1272, 1309, 3, 154, 77, 0, 1273, 1274, 5, 219, 0, 0, 1274, 1309, 3, 154, 77, 0, 1275, 1309, 5, 220, 0, 0, 1276, 1277, 5, 221, 0, 0, 1277, 1309, 3, 154, 77, 0, 1278, 1279, 5, 222, 0, 0, 1279, 1309, 3, 156, 78, 0, 1280, 1281, 5, 222, 0, 0, 1281, 1282, 3, 156, 78, 0, 1282, 1283, 5, 28, 0, 0, 1283, 1284, 3, 6, 3, 0, 1284, 1309, 1, 0, 0, 0, 1285, 1309, 5, 194, 0, 0, 1286, 1309, 5, 195, 0, 0, 1287, 1288, 5, 90, 0, 0, 1288, 1309, 5, 184, 0, 0, 1289, 1290, 5, 90, 0, 0, 1290, 1309, 5, 185, 0, 0, 1291, 1292, 5, 90, 0, 0, 1292, 1309, 5, 186, 0, 0, 1293, 1294, 5, 90, 0, 0, 1294, 1309, 5, 187, 0, 0, 1295, 1296, 5, 62, 0, 0, 1296, 1309, 5, 220, 0, 0, 1297, 1309, 5, 223, 0, 0, 1298, 1299, 5, 224, 0, 0, 1299, 1309, 5, 213, 0, 0, 1300, 1309, 5, 225, 0, 0, 1301, 1302, 5, 207, 0, 0, 1302, 1309, 5, 183, 0, 0, 1303, 1309, 5, 226, 0, 0, 1304, 1309, 5, 228, 0, 0, 1305, 1306, 5, 34, 0, 0, 1306, 1309, 5, 227, 0, 0, 1307, 1309, 3, 2, 1, 0, 1308, 1216, 1, 0, 0, 0, 1308, 1217, 1, 0, 0, 0, 1308, 1228, 1, 0, 0, 0, 1308, 1235, 1, 0, 0, 0, 1308, 1241, 1, 0, 0, 0, 1308, 1248, 1, 0, 0, 0, 1308, 1249, 1, 0, 0, 0, 1308, 1250, 1, 0, 0, 0, 1308, 1251, 1, 0, 0, 0, 1308, 1252, 1, 0, 0, 0, 1308, 1253, 1, 0, 0, 0, 1308, 1254, 1, 0, 0, 0, 1308, 1255, 1, 0, 0, 0, 1308, 1256, 1, 0, 0, 0, 1308, 1257, 1, 0, 0, 0, 1308, 1258, 1, 0, 0, 0, 1308, 1259, 1, 0, 0, 0, 1308, 1260, 1, 0, 0, 0, 1308, 1261, 1, 0, 0, 0, 1308, 1262, 1, 0, 0, 0, 1308, 1263, 1, 0, 0, 0, 1308, 1264, 1, 0, 0, 0, 1308, 1265, 1, 0, 0, 0, 1308, 1266, 1, 0, 0, 0, 1308, 1267, 1, 0, 0, 0, 1308, 1268, 1, 0, 0, 0, 1308, 1269, 1, 0, 0, 0, 1308, 1270, 1, 0, 0, 0, 1308, 1271, 1, 0, 0, 0, 1308, 1273, 1, 0, 0, 0, 1308, 1275, 1, 0, 0, 0, 1308, 1276, 1, 0, 0, 0, 1308, 1278, 1, 0, 0, 0, 1308, 1280, 1, 0, 0, 0, 1308, 1285, 1, 0, 0, 0, 1308, 1286, 1, 0, 0, 0, 1308, 1287, 1, 0, 0, 0, 1308, 1289, 1, 0, 0, 0, 1308, 1291, 1, 0, 0, 0, 1308, 1293, 1, 0, 0, 0, 1308, 1295, 1, 0, 0, 0, 1308, 1297, 1, 0, 0, 0, 1308, 1298, 1, 0, 0, 0, 1308, 1300, 1, 0, 0, 0, 1308, 1301, 1, 0, 0, 0, 1308, 1303, 1, 0, 0, 0, 1308, 1304, 1, 0, 0, 0, 1308, 1305, 1, 0, 0, 0, 1308, 1307, 1, 0, 0, 0, 1309, 153, 1, 0, 0, 0, 1310, 1318, 1, 0, 0, 0, 1311, 1312, 5, 30, 0, 0, 1312, 1313, 5, 91, 0, 0, 1313, 1314, 5, 36, 0, 0, 1314, 1315, 3, 32, 16, 0, 1315, 1316, 5, 31, 0, 0, 1316, 1318, 1, 0, 0, 0, 1317, 1310, 1, 0, 0, 0, 1317, 1311, 1, 0, 0, 0, 1318, 155, 1, 0, 0, 0, 1319, 1328, 1, 0, 0, 0, 1320, 1324, 3, 158, 79, 0, 1321, 1323, 7, 7, 0, 0, 1322, 1321, 1, 0, 0, 0, 1323, 1326, 1, 0, 0, 0, 1324, 1322, 1, 0, 0, 0, 1324, 1325, 1, 0, 0, 0, 1325, 1328, 1, 0, 0, 0, 1326, 1324, 1, 0, 0, 0, 1327, 1319, 1, 0, 0, 0, 1327, 1320, 1, 0, 0, 0, 1328, 157, 1, 0, 0, 0, 1329, 1330, 7, 8, 0, 0, 1330, 159, 1, 0, 0, 0, 1331, 1335, 3, 164, 82, 0, 1332, 1334, 3, 162, 81, 0, 1333, 1332, 1, 0, 0, 0, 1334, 1337, 1, 0, 0, 0, 1335, 1333, 1, 0, 0, 0, 1335, 1336, 1, 0, 0, 0, 1336, 161, 1, 0, 0, 0, 1337, 1335, 1, 0, 0, 0, 1338, 1357, 5, 261, 0, 0, 1339, 1340, 5, 42, 0, 0, 1340, 1357, 5, 43, 0, 0, 1341, 1357, 3, 132, 66, 0, 1342, 1357, 5, 260, 0, 0, 1343, 1357, 5, 262, 0, 0, 1344, 1357, 5, 92, 0, 0, 1345, 1346, 5, 93, 0, 0, 1346, 1347, 5, 30, 0, 0, 1347, 1348, 3, 146, 73, 0, 1348, 1349, 5, 31, 0, 0, 1349, 1357, 1, 0, 0, 0, 1350, 1351, 5, 94, 0, 0, 1351, 1352, 5, 30, 0, 0, 1352, 1353, 3, 146, 73, 0, 1353, 1354, 5, 31, 0, 0, 1354, 1357, 1, 0, 0, 0, 1355, 1357, 3, 130, 65, 0, 1356, 1338, 1, 0, 0, 0, 1356, 1339, 1, 0, 0, 0, 1356, 1341, 1, 0, 0, 0, 1356, 1342, 1, 0, 0, 0, 1356, 1343, 1, 0, 0, 0, 1356, 1344, 1, 0, 0, 0, 1356, 1345, 1, 0, 0, 0, 1356, 1350, 1, 0, 0, 0, 1356, 1355, 1, 0, 0, 0, 1357, 163, 1, 0, 0, 0, 1358, 1359, 5, 39, 0, 0, 1359, 1389, 3, 138, 69, 0, 1360, 1389, 5, 197, 0, 0, 1361, 1362, 5, 199, 0, 0, 1362, 1363, 5, 39, 0, 0, 1363, 1389, 3, 138, 69, 0, 1364, 1365, 5, 200, 0, 0, 1365, 1389, 3, 138, 69, 0, 1366, 1367, 5, 226, 0, 0, 1367, 1368, 3, 192, 96, 0, 1368, 1369, 3, 160, 80, 0, 1369, 1370, 5, 262, 0, 0, 1370, 1371, 3, 134, 67, 0, 1371, 1389, 1, 0, 0, 0, 1372, 1373, 5, 253, 0, 0, 1373, 1389, 3, 32, 16, 0, 1374, 1375, 5, 252, 0, 0, 1375, 1389, 3, 32, 16, 0, 1376, 1377, 5, 253, 0, 0, 1377, 1389, 3, 2, 1, 0, 1378, 1379, 5, 252, 0, 0, 1379, 1389, 3, 2, 1, 0, 1380, 1389, 5, 254, 0, 0, 1381, 1389, 5, 201, 0, 0, 1382, 1389, 3, 170, 85, 0, 1383, 1389, 3, 172, 86, 0, 1384, 1389, 3, 166, 83, 0, 1385, 1389, 3, 2, 1, 0, 1386, 1387, 5, 177, 0, 0, 1387, 1389, 3, 160, 80, 0, 1388, 1358, 1, 0, 0, 0, 1388, 1360, 1, 0, 0, 0, 1388, 1361, 1, 0, 0, 0, 1388, 1364, 1, 0, 0, 0, 1388, 1366, 1, 0, 0, 0, 1388, 1372, 1, 0, 0, 0, 1388, 1374, 1, 0, 0, 0, 1388, 1376, 1, 0, 0, 0, 1388, 1378, 1, 0, 0, 0, 1388, 1380, 1, 0, 0, 0, 1388, 1381, 1, 0, 0, 0, 1388, 1382, 1, 0, 0, 0, 1388, 1383, 1, 0, 0, 0, 1388, 1384, 1, 0, 0, 0, 1388, 1385, 1, 0, 0, 0, 1388, 1386, 1, 0, 0, 0, 1389, 165, 1, 0, 0, 0, 1390, 1412, 5, 181, 0, 0, 1391, 1412, 5, 182, 0, 0, 1392, 1412, 5, 183, 0, 0, 1393, 1412, 5, 184, 0, 0, 1394, 1412, 5, 185, 0, 0, 1395, 1412, 5, 186, 0, 0, 1396, 1412, 5, 187, 0, 0, 1397, 1412, 5, 188, 0, 0, 1398, 1412, 5, 189, 0, 0, 1399, 1412, 5, 190, 0, 0, 1400, 1412, 5, 191, 0, 0, 1401, 1412, 5, 192, 0, 0, 1402, 1412, 5, 193, 0, 0, 1403, 1404, 5, 90, 0, 0, 1404, 1412, 5, 184, 0, 0, 1405, 1406, 5, 90, 0, 0, 1406, 1412, 5, 185, 0, 0, 1407, 1408, 5, 90, 0, 0, 1408, 1412, 5, 186, 0, 0, 1409, 1410, 5, 90, 0, 0, 1410, 1412, 5, 187, 0, 0, 1411, 1390, 1, 0, 0, 0, 1411, 1391, 1, 0, 0, 0, 1411, 1392, 1, 0, 0, 0, 1411, 1393, 1, 0, 0, 0, 1411, 1394, 1, 0, 0, 0, 1411, 1395, 1, 0, 0, 0, 1411, 1396, 1, 0, 0, 0, 1411, 1397, 1, 0, 0, 0, 1411, 1398, 1, 0, 0, 0, 1411, 1399, 1, 0, 0, 0, 1411, 1400, 1, 0, 0, 0, 1411, 1401, 1, 0, 0, 0, 1411, 1402, 1, 0, 0, 0, 1411, 1403, 1, 0, 0, 0, 1411, 1405, 1, 0, 0, 0, 1411, 1407, 1, 0, 0, 0, 1411, 1409, 1, 0, 0, 0, 1412, 167, 1, 0, 0, 0, 1413, 1424, 1, 0, 0, 0, 1414, 1424, 5, 177, 0, 0, 1415, 1424, 3, 32, 16, 0, 1416, 1417, 3, 32, 16, 0, 1417, 1418, 5, 177, 0, 0, 1418, 1419, 3, 32, 16, 0, 1419, 1424, 1, 0, 0, 0, 1420, 1421, 3, 32, 16, 0, 1421, 1422, 5, 177, 0, 0, 1422, 1424, 1, 0, 0, 0, 1423, 1413, 1, 0, 0, 0, 1423, 1414, 1, 0, 0, 0, 1423, 1415, 1, 0, 0, 0, 1423, 1416, 1, 0, 0, 0, 1423, 1420, 1, 0, 0, 0, 1424, 169, 1, 0, 0, 0, 1425, 1426, 5, 1, 0, 0, 1426, 1427, 5, 194, 0, 0, 1427, 171, 1, 0, 0, 0, 1428, 1432, 5, 1, 0, 0, 1429, 1430, 5, 90, 0, 0, 1430, 1433, 5, 194, 0, 0, 1431, 1433, 5, 195, 0, 0, 1432, 1429, 1, 0, 0, 0, 1432, 1431, 1, 0, 0, 0, 1433, 173, 1, 0, 0, 0, 1434, 1435, 5, 294, 0, 0, 1435, 1436, 3, 188, 94, 0, 1436, 1437, 3, 146, 73, 0, 1437, 1438, 5, 30, 0, 0, 1438, 1439, 3, 180, 90, 0, 1439, 1440, 5, 31, 0, 0, 1440, 1482, 1, 0, 0, 0, 1441, 1442, 5, 294, 0, 0, 1442, 1443, 3, 188, 94, 0, 1443, 1444, 3, 146, 73, 0, 1444, 1445, 5, 36, 0, 0, 1445, 1446, 5, 17, 0, 0, 1446, 1447, 3, 52, 26, 0, 1447, 1448, 5, 18, 0, 0, 1448, 1482, 1, 0, 0, 0, 1449, 1450, 5, 294, 0, 0, 1450, 1451, 3, 188, 94, 0, 1451, 1452, 3, 146, 73, 0, 1452, 1482, 1, 0, 0, 0, 1453, 1454, 5, 295, 0, 0, 1454, 1455, 3, 188, 94, 0, 1455, 1457, 5, 36, 0, 0, 1456, 1458, 5, 84, 0, 0, 1457, 1456, 1, 0, 0, 0, 1457, 1458, 1, 0, 0, 0, 1458, 1459, 1, 0, 0, 0, 1459, 1460, 5, 30, 0, 0, 1460, 1461, 3, 312, 156, 0, 1461, 1462, 5, 31, 0, 0, 1462, 1482, 1, 0, 0, 0, 1463, 1464, 5, 295, 0, 0, 1464, 1465, 3, 188, 94, 0, 1465, 1466, 5, 84, 0, 0, 1466, 1467, 5, 30, 0, 0, 1467, 1468, 3, 312, 156, 0, 1468, 1469, 5, 31, 0, 0, 1469, 1482, 1, 0, 0, 0, 1470, 1471, 5, 295, 0, 0, 1471, 1472, 3, 188, 94, 0, 1472, 1473, 3, 6, 3, 0, 1473, 1482, 1, 0, 0, 0, 1474, 1475, 5, 295, 0, 0, 1475, 1476, 3, 188, 94, 0, 1476, 1477, 5, 36, 0, 0, 1477, 1478, 5, 17, 0, 0, 1478, 1479, 3, 176, 88, 0, 1479, 1480, 5, 18, 0, 0, 1480, 1482, 1, 0, 0, 0, 1481, 1434, 1, 0, 0, 0, 1481, 1441, 1, 0, 0, 0, 1481, 1449, 1, 0, 0, 0, 1481, 1453, 1, 0, 0, 0, 1481, 1463, 1, 0, 0, 0, 1481, 1470, 1, 0, 0, 0, 1481, 1474, 1, 0, 0, 0, 1482, 175, 1, 0, 0, 0, 1483, 1494, 1, 0, 0, 0, 1484, 1485, 3, 178, 89, 0, 1485, 1486, 5, 28, 0, 0, 1486, 1488, 1, 0, 0, 0, 1487, 1484, 1, 0, 0, 0, 1488, 1491, 1, 0, 0, 0, 1489, 1487, 1, 0, 0, 0, 1489, 1490, 1, 0, 0, 0, 1490, 1492, 1, 0, 0, 0, 1491, 1489, 1, 0, 0, 0, 1492, 1494, 3, 178, 89, 0, 1493, 1483, 1, 0, 0, 0, 1493, 1489, 1, 0, 0, 0, 1494, 177, 1, 0, 0, 0, 1495, 1496, 5, 39, 0, 0, 1496, 1497, 5, 264, 0, 0, 1497, 1498, 5, 36, 0, 0, 1498, 1499, 5, 17, 0, 0, 1499, 1500, 3, 56, 28, 0, 1500, 1501, 5, 18, 0, 0, 1501, 1509, 1, 0, 0, 0, 1502, 1503, 3, 146, 73, 0, 1503, 1504, 5, 36, 0, 0, 1504, 1505, 5, 17, 0, 0, 1505, 1506, 3, 56, 28, 0, 1506, 1507, 5, 18, 0, 0, 1507, 1509, 1, 0, 0, 0, 1508, 1495, 1, 0, 0, 0, 1508, 1502, 1, 0, 0, 0, 1509, 179, 1, 0, 0, 0, 1510, 1511, 3, 182, 91, 0, 1511, 1512, 5, 28, 0, 0, 1512, 1514, 1, 0, 0, 0, 1513, 1510, 1, 0, 0, 0, 1514, 1517, 1, 0, 0, 0, 1515, 1513, 1, 0, 0, 0, 1515, 1516, 1, 0, 0, 0, 1516, 1518, 1, 0, 0, 0, 1517, 1515, 1, 0, 0, 0, 1518, 1519, 3, 182, 91, 0, 1519, 181, 1, 0, 0, 0, 1520, 1521, 3, 6, 3, 0, 1521, 1522, 5, 36, 0, 0, 1522, 1523, 3, 186, 93, 0, 1523, 183, 1, 0, 0, 0, 1524, 1525, 7, 9, 0, 0, 1525, 185, 1, 0, 0, 0, 1526, 1561, 3, 184, 92, 0, 1527, 1561, 3, 32, 16, 0, 1528, 1529, 5, 186, 0, 0, 1529, 1530, 5, 30, 0, 0, 1530, 1531, 3, 32, 16, 0, 1531, 1532, 5, 31, 0, 0, 1532, 1561, 1, 0, 0, 0, 1533, 1561, 3, 6, 3, 0, 1534, 1535, 3, 138, 69, 0, 1535, 1536, 5, 30, 0, 0, 1536, 1537, 5, 184, 0, 0, 1537, 1538, 5, 75, 0, 0, 1538, 1539, 3, 32, 16, 0, 1539, 1540, 5, 31, 0, 0, 1540, 1561, 1, 0, 0, 0, 1541, 1542, 3, 138, 69, 0, 1542, 1543, 5, 30, 0, 0, 1543, 1544, 5, 185, 0, 0, 1544, 1545, 5, 75, 0, 0, 1545, 1546, 3, 32, 16, 0, 1546, 1547, 5, 31, 0, 0, 1547, 1561, 1, 0, 0, 0, 1548, 1549, 3, 138, 69, 0, 1549, 1550, 5, 30, 0, 0, 1550, 1551, 5, 186, 0, 0, 1551, 1552, 5, 75, 0, 0, 1552, 1553, 3, 32, 16, 0, 1553, 1554, 5, 31, 0, 0, 1554, 1561, 1, 0, 0, 0, 1555, 1556, 3, 138, 69, 0, 1556, 1557, 5, 30, 0, 0, 1557, 1558, 3, 32, 16, 0, 1558, 1559, 5, 31, 0, 0, 1559, 1561, 1, 0, 0, 0, 1560, 1526, 1, 0, 0, 0, 1560, 1527, 1, 0, 0, 0, 1560, 1528, 1, 0, 0, 0, 1560, 1533, 1, 0, 0, 0, 1560, 1534, 1, 0, 0, 0, 1560, 1541, 1, 0, 0, 0, 1560, 1548, 1, 0, 0, 0, 1560, 1555, 1, 0, 0, 0, 1561, 187, 1, 0, 0, 0, 1562, 1563, 7, 10, 0, 0, 1563, 189, 1, 0, 0, 0, 1564, 1565, 3, 192, 96, 0, 1565, 1566, 3, 160, 80, 0, 1566, 1567, 3, 146, 73, 0, 1567, 1568, 5, 176, 0, 0, 1568, 1570, 3, 264, 132, 0, 1569, 1571, 3, 130, 65, 0, 1570, 1569, 1, 0, 0, 0, 1570, 1571, 1, 0, 0, 0, 1571, 1572, 1, 0, 0, 0, 1572, 1573, 3, 134, 67, 0, 1573, 1599, 1, 0, 0, 0, 1574, 1575, 3, 192, 96, 0, 1575, 1576, 3, 160, 80, 0, 1576, 1577, 3, 146, 73, 0, 1577, 1578, 5, 176, 0, 0, 1578, 1579, 3, 264, 132, 0, 1579, 1580, 3, 218, 109, 0, 1580, 1581, 3, 134, 67, 0, 1581, 1599, 1, 0, 0, 0, 1582, 1583, 3, 192, 96, 0, 1583, 1584, 3, 160, 80, 0, 1584, 1586, 3, 264, 132, 0, 1585, 1587, 3, 130, 65, 0, 1586, 1585, 1, 0, 0, 0, 1586, 1587, 1, 0, 0, 0, 1587, 1588, 1, 0, 0, 0, 1588, 1589, 3, 134, 67, 0, 1589, 1599, 1, 0, 0, 0, 1590, 1591, 3, 192, 96, 0, 1591, 1592, 3, 160, 80, 0, 1592, 1593, 3, 264, 132, 0, 1593, 1594, 3, 218, 109, 0, 1594, 1595, 3, 134, 67, 0, 1595, 1599, 1, 0, 0, 0, 1596, 1599, 3, 196, 98, 0, 1597, 1599, 3, 2, 1, 0, 1598, 1564, 1, 0, 0, 0, 1598, 1574, 1, 0, 0, 0, 1598, 1582, 1, 0, 0, 0, 1598, 1590, 1, 0, 0, 0, 1598, 1596, 1, 0, 0, 0, 1598, 1597, 1, 0, 0, 0, 1599, 191, 1, 0, 0, 0, 1600, 1601, 5, 243, 0, 0, 1601, 1611, 3, 192, 96, 0, 1602, 1603, 5, 244, 0, 0, 1603, 1611, 3, 192, 96, 0, 1604, 1611, 3, 194, 97, 0, 1605, 1606, 5, 112, 0, 0, 1606, 1607, 5, 30, 0, 0, 1607, 1608, 3, 32, 16, 0, 1608, 1609, 5, 31, 0, 0, 1609, 1611, 1, 0, 0, 0, 1610, 1600, 1, 0, 0, 0, 1610, 1602, 1, 0, 0, 0, 1610, 1604, 1, 0, 0, 0, 1610, 1605, 1, 0, 0, 0, 1611, 193, 1, 0, 0, 0, 1612, 1625, 1, 0, 0, 0, 1613, 1625, 5, 245, 0, 0, 1614, 1625, 5, 246, 0, 0, 1615, 1616, 5, 247, 0, 0, 1616, 1625, 5, 248, 0, 0, 1617, 1618, 5, 247, 0, 0, 1618, 1625, 5, 249, 0, 0, 1619, 1620, 5, 247, 0, 0, 1620, 1625, 5, 250, 0, 0, 1621, 1622, 5, 247, 0, 0, 1622, 1625, 5, 251, 0, 0, 1623, 1625, 5, 247, 0, 0, 1624, 1612, 1, 0, 0, 0, 1624, 1613, 1, 0, 0, 0, 1624, 1614, 1, 0, 0, 0, 1624, 1615, 1, 0, 0, 0, 1624, 1617, 1, 0, 0, 0, 1624, 1619, 1, 0, 0, 0, 1624, 1621, 1, 0, 0, 0, 1624, 1623, 1, 0, 0, 0, 1625, 195, 1, 0, 0, 0, 1626, 1627, 5, 113, 0, 0, 1627, 1628, 5, 30, 0, 0, 1628, 1629, 3, 32, 16, 0, 1629, 1630, 5, 31, 0, 0, 1630, 197, 1, 0, 0, 0, 1631, 1632, 5, 226, 0, 0, 1632, 1637, 3, 190, 95, 0, 1633, 1634, 5, 37, 0, 0, 1634, 1637, 3, 200, 100, 0, 1635, 1637, 3, 196, 98, 0, 1636, 1631, 1, 0, 0, 0, 1636, 1633, 1, 0, 0, 0, 1636, 1635, 1, 0, 0, 0, 1637, 199, 1, 0, 0, 0, 1638, 1639, 3, 160, 80, 0, 1639, 1640, 3, 146, 73, 0, 1640, 1641, 5, 176, 0, 0, 1641, 1642, 3, 2, 1, 0, 1642, 1648, 1, 0, 0, 0, 1643, 1644, 3, 160, 80, 0, 1644, 1645, 3, 2, 1, 0, 1645, 1648, 1, 0, 0, 0, 1646, 1648, 3, 2, 1, 0, 1647, 1638, 1, 0, 0, 0, 1647, 1643, 1, 0, 0, 0, 1647, 1646, 1, 0, 0, 0, 1648, 201, 1, 0, 0, 0, 1649, 1650, 3, 146, 73, 0, 1650, 1651, 5, 28, 0, 0, 1651, 1653, 1, 0, 0, 0, 1652, 1649, 1, 0, 0, 0, 1653, 1656, 1, 0, 0, 0, 1654, 1652, 1, 0, 0, 0, 1654, 1655, 1, 0, 0, 0, 1655, 1657, 1, 0, 0, 0, 1656, 1654, 1, 0, 0, 0, 1657, 1658, 3, 146, 73, 0, 1658, 203, 1, 0, 0, 0, 1659, 1665, 1, 0, 0, 0, 1660, 1661, 5, 86, 0, 0, 1661, 1662, 3, 212, 106, 0, 1662, 1663, 5, 87, 0, 0, 1663, 1665, 1, 0, 0, 0, 1664, 1659, 1, 0, 0, 0, 1664, 1660, 1, 0, 0, 0, 1665, 205, 1, 0, 0, 0, 1666, 1678, 5, 266, 0, 0, 1667, 1678, 5, 114, 0, 0, 1668, 1678, 5, 39, 0, 0, 1669, 1678, 5, 200, 0, 0, 1670, 1678, 5, 115, 0, 0, 1671, 1678, 5, 116, 0, 0, 1672, 1673, 5, 70, 0, 0, 1673, 1674, 5, 30, 0, 0, 1674, 1675, 3, 32, 16, 0, 1675, 1676, 5, 31, 0, 0, 1676, 1678, 1, 0, 0, 0, 1677, 1666, 1, 0, 0, 0, 1677, 1667, 1, 0, 0, 0, 1677, 1668, 1, 0, 0, 0, 1677, 1669, 1, 0, 0, 0, 1677, 1670, 1, 0, 0, 0, 1677, 1671, 1, 0, 0, 0, 1677, 1672, 1, 0, 0, 0, 1678, 207, 1, 0, 0, 0, 1679, 1681, 3, 206, 103, 0, 1680, 1679, 1, 0, 0, 0, 1681, 1684, 1, 0, 0, 0, 1682, 1680, 1, 0, 0, 0, 1682, 1683, 1, 0, 0, 0, 1683, 209, 1, 0, 0, 0, 1684, 1682, 1, 0, 0, 0, 1685, 1687, 3, 208, 104, 0, 1686, 1688, 3, 214, 107, 0, 1687, 1686, 1, 0, 0, 0, 1687, 1688, 1, 0, 0, 0, 1688, 1689, 1, 0, 0, 0, 1689, 1690, 3, 2, 1, 0, 1690, 211, 1, 0, 0, 0, 1691, 1692, 3, 210, 105, 0, 1692, 1693, 5, 28, 0, 0, 1693, 1695, 1, 0, 0, 0, 1694, 1691, 1, 0, 0, 0, 1695, 1698, 1, 0, 0, 0, 1696, 1694, 1, 0, 0, 0, 1696, 1697, 1, 0, 0, 0, 1697, 1699, 1, 0, 0, 0, 1698, 1696, 1, 0, 0, 0, 1699, 1700, 3, 210, 105, 0, 1700, 213, 1, 0, 0, 0, 1701, 1702, 5, 30, 0, 0, 1702, 1703, 3, 202, 101, 0, 1703, 1704, 5, 31, 0, 0, 1704, 215, 1, 0, 0, 0, 1705, 1708, 1, 0, 0, 0, 1706, 1708, 3, 218, 109, 0, 1707, 1705, 1, 0, 0, 0, 1707, 1706, 1, 0, 0, 0, 1708, 217, 1, 0, 0, 0, 1709, 1710, 5, 86, 0, 0, 1710, 1711, 5, 42, 0, 0, 1711, 1712, 3, 32, 16, 0, 1712, 1713, 5, 43, 0, 0, 1713, 1714, 5, 87, 0, 0, 1714, 219, 1, 0, 0, 0, 1715, 1716, 3, 256, 128, 0, 1716, 1717, 5, 17, 0, 0, 1717, 1718, 3, 268, 134, 0, 1718, 1719, 5, 18, 0, 0, 1719, 1832, 1, 0, 0, 0, 1720, 1721, 3, 74, 37, 0, 1721, 1722, 5, 17, 0, 0, 1722, 1723, 3, 82, 41, 0, 1723, 1724, 5, 18, 0, 0, 1724, 1832, 1, 0, 0, 0, 1725, 1726, 3, 232, 116, 0, 1726, 1727, 5, 17, 0, 0, 1727, 1728, 3, 236, 118, 0, 1728, 1729, 5, 18, 0, 0, 1729, 1832, 1, 0, 0, 0, 1730, 1731, 3, 240, 120, 0, 1731, 1732, 5, 17, 0, 0, 1732, 1733, 3, 244, 122, 0, 1733, 1734, 5, 18, 0, 0, 1734, 1832, 1, 0, 0, 0, 1735, 1832, 3, 222, 111, 0, 1736, 1832, 3, 296, 148, 0, 1737, 1832, 3, 174, 87, 0, 1738, 1832, 3, 88, 44, 0, 1739, 1832, 3, 342, 171, 0, 1740, 1741, 5, 117, 0, 0, 1741, 1832, 3, 32, 16, 0, 1742, 1743, 5, 118, 0, 0, 1743, 1832, 3, 32, 16, 0, 1744, 1745, 3, 354, 177, 0, 1745, 1746, 5, 17, 0, 0, 1746, 1747, 3, 358, 179, 0, 1747, 1748, 5, 18, 0, 0, 1748, 1832, 1, 0, 0, 0, 1749, 1750, 5, 302, 0, 0, 1750, 1751, 3, 146, 73, 0, 1751, 1752, 5, 176, 0, 0, 1752, 1753, 3, 264, 132, 0, 1753, 1754, 5, 119, 0, 0, 1754, 1755, 3, 192, 96, 0, 1755, 1756, 3, 160, 80, 0, 1756, 1757, 3, 146, 73, 0, 1757, 1758, 5, 176, 0, 0, 1758, 1759, 3, 264, 132, 0, 1759, 1760, 3, 134, 67, 0, 1760, 1832, 1, 0, 0, 0, 1761, 1762, 5, 302, 0, 0, 1762, 1763, 5, 226, 0, 0, 1763, 1764, 3, 192, 96, 0, 1764, 1765, 3, 160, 80, 0, 1765, 1766, 3, 146, 73, 0, 1766, 1767, 5, 176, 0, 0, 1767, 1768, 3, 264, 132, 0, 1768, 1769, 3, 216, 108, 0, 1769, 1770, 3, 134, 67, 0, 1770, 1771, 5, 119, 0, 0, 1771, 1772, 5, 226, 0, 0, 1772, 1773, 3, 192, 96, 0, 1773, 1774, 3, 160, 80, 0, 1774, 1775, 3, 146, 73, 0, 1775, 1776, 5, 176, 0, 0, 1776, 1777, 3, 264, 132, 0, 1777, 1778, 3, 216, 108, 0, 1778, 1779, 3, 134, 67, 0, 1779, 1832, 1, 0, 0, 0, 1780, 1832, 3, 26, 13, 0, 1781, 1832, 3, 40, 20, 0, 1782, 1783, 5, 255, 0, 0, 1783, 1784, 5, 196, 0, 0, 1784, 1785, 5, 42, 0, 0, 1785, 1786, 3, 32, 16, 0, 1786, 1790, 5, 43, 0, 0, 1787, 1789, 3, 342, 171, 0, 1788, 1787, 1, 0, 0, 0, 1789, 1792, 1, 0, 0, 0, 1790, 1788, 1, 0, 0, 0, 1790, 1791, 1, 0, 0, 0, 1791, 1832, 1, 0, 0, 0, 1792, 1790, 1, 0, 0, 0, 1793, 1794, 5, 255, 0, 0, 1794, 1795, 5, 196, 0, 0, 1795, 1799, 3, 2, 1, 0, 1796, 1798, 3, 342, 171, 0, 1797, 1796, 1, 0, 0, 0, 1798, 1801, 1, 0, 0, 0, 1799, 1797, 1, 0, 0, 0, 1799, 1800, 1, 0, 0, 0, 1800, 1832, 1, 0, 0, 0, 1801, 1799, 1, 0, 0, 0, 1802, 1803, 5, 255, 0, 0, 1803, 1804, 5, 256, 0, 0, 1804, 1805, 5, 42, 0, 0, 1805, 1806, 3, 32, 16, 0, 1806, 1807, 5, 43, 0, 0, 1807, 1808, 5, 28, 0, 0, 1808, 1812, 3, 146, 73, 0, 1809, 1811, 3, 342, 171, 0, 1810, 1809, 1, 0, 0, 0, 1811, 1814, 1, 0, 0, 0, 1812, 1810, 1, 0, 0, 0, 1812, 1813, 1, 0, 0, 0, 1813, 1832, 1, 0, 0, 0, 1814, 1812, 1, 0, 0, 0, 1815, 1816, 5, 255, 0, 0, 1816, 1817, 5, 256, 0, 0, 1817, 1818, 3, 2, 1, 0, 1818, 1819, 5, 28, 0, 0, 1819, 1823, 3, 146, 73, 0, 1820, 1822, 3, 342, 171, 0, 1821, 1820, 1, 0, 0, 0, 1822, 1825, 1, 0, 0, 0, 1823, 1821, 1, 0, 0, 0, 1823, 1824, 1, 0, 0, 0, 1824, 1832, 1, 0, 0, 0, 1825, 1823, 1, 0, 0, 0, 1826, 1827, 5, 120, 0, 0, 1827, 1828, 5, 196, 0, 0, 1828, 1829, 3, 146, 73, 0, 1829, 1830, 3, 44, 22, 0, 1830, 1832, 1, 0, 0, 0, 1831, 1715, 1, 0, 0, 0, 1831, 1720, 1, 0, 0, 0, 1831, 1725, 1, 0, 0, 0, 1831, 1730, 1, 0, 0, 0, 1831, 1735, 1, 0, 0, 0, 1831, 1736, 1, 0, 0, 0, 1831, 1737, 1, 0, 0, 0, 1831, 1738, 1, 0, 0, 0, 1831, 1739, 1, 0, 0, 0, 1831, 1740, 1, 0, 0, 0, 1831, 1742, 1, 0, 0, 0, 1831, 1744, 1, 0, 0, 0, 1831, 1749, 1, 0, 0, 0, 1831, 1761, 1, 0, 0, 0, 1831, 1780, 1, 0, 0, 0, 1831, 1781, 1, 0, 0, 0, 1831, 1782, 1, 0, 0, 0, 1831, 1793, 1, 0, 0, 0, 1831, 1802, 1, 0, 0, 0, 1831, 1815, 1, 0, 0, 0, 1831, 1826, 1, 0, 0, 0, 1832, 221, 1, 0, 0, 0, 1833, 1834, 5, 121, 0, 0, 1834, 1843, 3, 230, 115, 0, 1835, 1842, 3, 224, 112, 0, 1836, 1837, 5, 122, 0, 0, 1837, 1838, 5, 30, 0, 0, 1838, 1839, 3, 250, 125, 0, 1839, 1840, 5, 31, 0, 0, 1840, 1842, 1, 0, 0, 0, 1841, 1835, 1, 0, 0, 0, 1841, 1836, 1, 0, 0, 0, 1842, 1845, 1, 0, 0, 0, 1843, 1841, 1, 0, 0, 0, 1843, 1844, 1, 0, 0, 0, 1844, 1846, 1, 0, 0, 0, 1845, 1843, 1, 0, 0, 0, 1846, 1847, 3, 160, 80, 0, 1847, 1848, 3, 2, 1, 0, 1848, 1849, 3, 226, 113, 0, 1849, 1850, 3, 228, 114, 0, 1850, 223, 1, 0, 0, 0, 1851, 1871, 5, 123, 0, 0, 1852, 1871, 5, 51, 0, 0, 1853, 1871, 5, 52, 0, 0, 1854, 1871, 5, 63, 0, 0, 1855, 1871, 5, 124, 0, 0, 1856, 1871, 5, 69, 0, 0, 1857, 1871, 5, 68, 0, 0, 1858, 1871, 5, 64, 0, 0, 1859, 1871, 5, 65, 0, 0, 1860, 1871, 5, 66, 0, 0, 1861, 1871, 5, 125, 0, 0, 1862, 1871, 5, 126, 0, 0, 1863, 1871, 5, 127, 0, 0, 1864, 1871, 5, 16, 0, 0, 1865, 1866, 5, 70, 0, 0, 1866, 1867, 5, 30, 0, 0, 1867, 1868, 3, 32, 16, 0, 1868, 1869, 5, 31, 0, 0, 1869, 1871, 1, 0, 0, 0, 1870, 1851, 1, 0, 0, 0, 1870, 1852, 1, 0, 0, 0, 1870, 1853, 1, 0, 0, 0, 1870, 1854, 1, 0, 0, 0, 1870, 1855, 1, 0, 0, 0, 1870, 1856, 1, 0, 0, 0, 1870, 1857, 1, 0, 0, 0, 1870, 1858, 1, 0, 0, 0, 1870, 1859, 1, 0, 0, 0, 1870, 1860, 1, 0, 0, 0, 1870, 1861, 1, 0, 0, 0, 1870, 1862, 1, 0, 0, 0, 1870, 1863, 1, 0, 0, 0, 1870, 1864, 1, 0, 0, 0, 1870, 1865, 1, 0, 0, 0, 1871, 225, 1, 0, 0, 0, 1872, 1878, 1, 0, 0, 0, 1873, 1874, 5, 44, 0, 0, 1874, 1878, 3, 0, 0, 0, 1875, 1876, 5, 44, 0, 0, 1876, 1878, 3, 32, 16, 0, 1877, 1872, 1, 0, 0, 0, 1877, 1873, 1, 0, 0, 0, 1877, 1875, 1, 0, 0, 0, 1878, 227, 1, 0, 0, 0, 1879, 1883, 1, 0, 0, 0, 1880, 1881, 5, 36, 0, 0, 1881, 1883, 3, 316, 158, 0, 1882, 1879, 1, 0, 0, 0, 1882, 1880, 1, 0, 0, 0, 1883, 229, 1, 0, 0, 0, 1884, 1890, 1, 0, 0, 0, 1885, 1886, 5, 42, 0, 0, 1886, 1887, 3, 32, 16, 0, 1887, 1888, 5, 43, 0, 0, 1888, 1890, 1, 0, 0, 0, 1889, 1884, 1, 0, 0, 0, 1889, 1885, 1, 0, 0, 0, 1890, 231, 1, 0, 0, 0, 1891, 1895, 5, 128, 0, 0, 1892, 1894, 3, 234, 117, 0, 1893, 1892, 1, 0, 0, 0, 1894, 1897, 1, 0, 0, 0, 1895, 1893, 1, 0, 0, 0, 1895, 1896, 1, 0, 0, 0, 1896, 1898, 1, 0, 0, 0, 1897, 1895, 1, 0, 0, 0, 1898, 1899, 3, 146, 73, 0, 1899, 1900, 3, 2, 1, 0, 1900, 1910, 1, 0, 0, 0, 1901, 1905, 5, 128, 0, 0, 1902, 1904, 3, 234, 117, 0, 1903, 1902, 1, 0, 0, 0, 1904, 1907, 1, 0, 0, 0, 1905, 1903, 1, 0, 0, 0, 1905, 1906, 1, 0, 0, 0, 1906, 1908, 1, 0, 0, 0, 1907, 1905, 1, 0, 0, 0, 1908, 1910, 3, 2, 1, 0, 1909, 1891, 1, 0, 0, 0, 1909, 1901, 1, 0, 0, 0, 1910, 233, 1, 0, 0, 0, 1911, 1912, 7, 11, 0, 0, 1912, 235, 1, 0, 0, 0, 1913, 1915, 3, 238, 119, 0, 1914, 1913, 1, 0, 0, 0, 1915, 1918, 1, 0, 0, 0, 1916, 1914, 1, 0, 0, 0, 1916, 1917, 1, 0, 0, 0, 1917, 237, 1, 0, 0, 0, 1918, 1916, 1, 0, 0, 0, 1919, 1920, 5, 129, 0, 0, 1920, 1932, 3, 190, 95, 0, 1921, 1922, 5, 130, 0, 0, 1922, 1932, 3, 190, 95, 0, 1923, 1924, 5, 131, 0, 0, 1924, 1932, 3, 190, 95, 0, 1925, 1926, 5, 132, 0, 0, 1926, 1932, 3, 190, 95, 0, 1927, 1932, 3, 88, 44, 0, 1928, 1932, 3, 342, 171, 0, 1929, 1932, 3, 26, 13, 0, 1930, 1932, 3, 40, 20, 0, 1931, 1919, 1, 0, 0, 0, 1931, 1921, 1, 0, 0, 0, 1931, 1923, 1, 0, 0, 0, 1931, 1925, 1, 0, 0, 0, 1931, 1927, 1, 0, 0, 0, 1931, 1928, 1, 0, 0, 0, 1931, 1929, 1, 0, 0, 0, 1931, 1930, 1, 0, 0, 0, 1932, 239, 1, 0, 0, 0, 1933, 1937, 5, 133, 0, 0, 1934, 1936, 3, 242, 121, 0, 1935, 1934, 1, 0, 0, 0, 1936, 1939, 1, 0, 0, 0, 1937, 1935, 1, 0, 0, 0, 1937, 1938, 1, 0, 0, 0, 1938, 1940, 1, 0, 0, 0, 1939, 1937, 1, 0, 0, 0, 1940, 1941, 3, 192, 96, 0, 1941, 1942, 3, 160, 80, 0, 1942, 1943, 3, 2, 1, 0, 1943, 1944, 3, 134, 67, 0, 1944, 1945, 3, 228, 114, 0, 1945, 241, 1, 0, 0, 0, 1946, 1947, 7, 11, 0, 0, 1947, 243, 1, 0, 0, 0, 1948, 1950, 3, 246, 123, 0, 1949, 1948, 1, 0, 0, 0, 1950, 1953, 1, 0, 0, 0, 1951, 1949, 1, 0, 0, 0, 1951, 1952, 1, 0, 0, 0, 1952, 245, 1, 0, 0, 0, 1953, 1951, 1, 0, 0, 0, 1954, 1955, 5, 134, 0, 0, 1955, 1965, 3, 190, 95, 0, 1956, 1957, 5, 135, 0, 0, 1957, 1965, 3, 190, 95, 0, 1958, 1959, 5, 132, 0, 0, 1959, 1965, 3, 190, 95, 0, 1960, 1965, 3, 342, 171, 0, 1961, 1965, 3, 88, 44, 0, 1962, 1965, 3, 26, 13, 0, 1963, 1965, 3, 40, 20, 0, 1964, 1954, 1, 0, 0, 0, 1964, 1956, 1, 0, 0, 0, 1964, 1958, 1, 0, 0, 0, 1964, 1960, 1, 0, 0, 0, 1964, 1961, 1, 0, 0, 0, 1964, 1962, 1, 0, 0, 0, 1964, 1963, 1, 0, 0, 0, 1965, 247, 1, 0, 0, 0, 1966, 1973, 1, 0, 0, 0, 1967, 1968, 5, 122, 0, 0, 1968, 1969, 5, 30, 0, 0, 1969, 1970, 3, 250, 125, 0, 1970, 1971, 5, 31, 0, 0, 1971, 1973, 1, 0, 0, 0, 1972, 1966, 1, 0, 0, 0, 1972, 1967, 1, 0, 0, 0, 1973, 249, 1, 0, 0, 0, 1974, 1984, 3, 148, 74, 0, 1975, 1977, 5, 17, 0, 0, 1976, 1978, 3, 314, 157, 0, 1977, 1976, 1, 0, 0, 0, 1978, 1979, 1, 0, 0, 0, 1979, 1977, 1, 0, 0, 0, 1979, 1980, 1, 0, 0, 0, 1980, 1981, 1, 0, 0, 0, 1981, 1982, 5, 18, 0, 0, 1982, 1984, 1, 0, 0, 0, 1983, 1974, 1, 0, 0, 0, 1983, 1975, 1, 0, 0, 0, 1984, 251, 1, 0, 0, 0, 1985, 1987, 3, 254, 127, 0, 1986, 1985, 1, 0, 0, 0, 1987, 1990, 1, 0, 0, 0, 1988, 1986, 1, 0, 0, 0, 1988, 1989, 1, 0, 0, 0, 1989, 253, 1, 0, 0, 0, 1990, 1988, 1, 0, 0, 0, 1991, 1992, 5, 42, 0, 0, 1992, 1993, 5, 136, 0, 0, 1993, 2005, 5, 43, 0, 0, 1994, 1995, 5, 42, 0, 0, 1995, 1996, 5, 137, 0, 0, 1996, 2005, 5, 43, 0, 0, 1997, 1998, 5, 42, 0, 0, 1998, 1999, 5, 138, 0, 0, 1999, 2005, 5, 43, 0, 0, 2000, 2001, 5, 42, 0, 0, 2001, 2002, 3, 32, 16, 0, 2002, 2003, 5, 43, 0, 0, 2003, 2005, 1, 0, 0, 0, 2004, 1991, 1, 0, 0, 0, 2004, 1994, 1, 0, 0, 0, 2004, 1997, 1, 0, 0, 0, 2004, 2000, 1, 0, 0, 0, 2005, 255, 1, 0, 0, 0, 2006, 2011, 5, 139, 0, 0, 2007, 2010, 3, 258, 129, 0, 2008, 2010, 3, 260, 130, 0, 2009, 2007, 1, 0, 0, 0, 2009, 2008, 1, 0, 0, 0, 2010, 2013, 1, 0, 0, 0, 2011, 2009, 1, 0, 0, 0, 2011, 2012, 1, 0, 0, 0, 2012, 2014, 1, 0, 0, 0, 2013, 2011, 1, 0, 0, 0, 2014, 2015, 3, 192, 96, 0, 2015, 2016, 3, 252, 126, 0, 2016, 2017, 3, 160, 80, 0, 2017, 2018, 3, 248, 124, 0, 2018, 2019, 3, 264, 132, 0, 2019, 2020, 3, 204, 102, 0, 2020, 2024, 3, 134, 67, 0, 2021, 2023, 3, 266, 133, 0, 2022, 2021, 1, 0, 0, 0, 2023, 2026, 1, 0, 0, 0, 2024, 2022, 1, 0, 0, 0, 2024, 2025, 1, 0, 0, 0, 2025, 257, 1, 0, 0, 0, 2026, 2024, 1, 0, 0, 0, 2027, 2051, 5, 123, 0, 0, 2028, 2051, 5, 51, 0, 0, 2029, 2051, 5, 52, 0, 0, 2030, 2051, 5, 63, 0, 0, 2031, 2051, 5, 140, 0, 0, 2032, 2051, 5, 68, 0, 0, 2033, 2051, 5, 141, 0, 0, 2034, 2051, 5, 142, 0, 0, 2035, 2051, 5, 54, 0, 0, 2036, 2051, 5, 64, 0, 0, 2037, 2051, 5, 65, 0, 0, 2038, 2051, 5, 66, 0, 0, 2039, 2051, 5, 125, 0, 0, 2040, 2051, 5, 143, 0, 0, 2041, 2051, 5, 144, 0, 0, 2042, 2051, 5, 69, 0, 0, 2043, 2051, 5, 145, 0, 0, 2044, 2051, 5, 146, 0, 0, 2045, 2046, 5, 70, 0, 0, 2046, 2047, 5, 30, 0, 0, 2047, 2048, 3, 32, 16, 0, 2048, 2049, 5, 31, 0, 0, 2049, 2051, 1, 0, 0, 0, 2050, 2027, 1, 0, 0, 0, 2050, 2028, 1, 0, 0, 0, 2050, 2029, 1, 0, 0, 0, 2050, 2030, 1, 0, 0, 0, 2050, 2031, 1, 0, 0, 0, 2050, 2032, 1, 0, 0, 0, 2050, 2033, 1, 0, 0, 0, 2050, 2034, 1, 0, 0, 0, 2050, 2035, 1, 0, 0, 0, 2050, 2036, 1, 0, 0, 0, 2050, 2037, 1, 0, 0, 0, 2050, 2038, 1, 0, 0, 0, 2050, 2039, 1, 0, 0, 0, 2050, 2040, 1, 0, 0, 0, 2050, 2041, 1, 0, 0, 0, 2050, 2042, 1, 0, 0, 0, 2050, 2043, 1, 0, 0, 0, 2050, 2044, 1, 0, 0, 0, 2050, 2045, 1, 0, 0, 0, 2051, 259, 1, 0, 0, 0, 2052, 2053, 5, 147, 0, 0, 2053, 2059, 5, 30, 0, 0, 2054, 2057, 3, 6, 3, 0, 2055, 2056, 5, 34, 0, 0, 2056, 2058, 3, 6, 3, 0, 2057, 2055, 1, 0, 0, 0, 2057, 2058, 1, 0, 0, 0, 2058, 2060, 1, 0, 0, 0, 2059, 2054, 1, 0, 0, 0, 2059, 2060, 1, 0, 0, 0, 2060, 2064, 1, 0, 0, 0, 2061, 2063, 3, 262, 131, 0, 2062, 2061, 1, 0, 0, 0, 2063, 2066, 1, 0, 0, 0, 2064, 2062, 1, 0, 0, 0, 2064, 2065, 1, 0, 0, 0, 2065, 2067, 1, 0, 0, 0, 2066, 2064, 1, 0, 0, 0, 2067, 2071, 5, 31, 0, 0, 2068, 2069, 5, 147, 0, 0, 2069, 2071, 5, 85, 0, 0, 2070, 2052, 1, 0, 0, 0, 2070, 2068, 1, 0, 0, 0, 2071, 261, 1, 0, 0, 0, 2072, 2100, 5, 148, 0, 0, 2073, 2100, 5, 224, 0, 0, 2074, 2100, 5, 57, 0, 0, 2075, 2100, 5, 58, 0, 0, 2076, 2100, 5, 149, 0, 0, 2077, 2100, 5, 150, 0, 0, 2078, 2100, 5, 248, 0, 0, 2079, 2100, 5, 249, 0, 0, 2080, 2100, 5, 250, 0, 0, 2081, 2100, 5, 251, 0, 0, 2082, 2083, 5, 151, 0, 0, 2083, 2084, 5, 75, 0, 0, 2084, 2100, 5, 152, 0, 0, 2085, 2086, 5, 151, 0, 0, 2086, 2087, 5, 75, 0, 0, 2087, 2100, 5, 153, 0, 0, 2088, 2089, 5, 154, 0, 0, 2089, 2090, 5, 75, 0, 0, 2090, 2100, 5, 152, 0, 0, 2091, 2092, 5, 154, 0, 0, 2092, 2093, 5, 75, 0, 0, 2093, 2100, 5, 153, 0, 0, 2094, 2095, 5, 70, 0, 0, 2095, 2096, 5, 30, 0, 0, 2096, 2097, 3, 32, 16, 0, 2097, 2098, 5, 31, 0, 0, 2098, 2100, 1, 0, 0, 0, 2099, 2072, 1, 0, 0, 0, 2099, 2073, 1, 0, 0, 0, 2099, 2074, 1, 0, 0, 0, 2099, 2075, 1, 0, 0, 0, 2099, 2076, 1, 0, 0, 0, 2099, 2077, 1, 0, 0, 0, 2099, 2078, 1, 0, 0, 0, 2099, 2079, 1, 0, 0, 0, 2099, 2080, 1, 0, 0, 0, 2099, 2081, 1, 0, 0, 0, 2099, 2082, 1, 0, 0, 0, 2099, 2085, 1, 0, 0, 0, 2099, 2088, 1, 0, 0, 0, 2099, 2091, 1, 0, 0, 0, 2099, 2094, 1, 0, 0, 0, 2100, 263, 1, 0, 0, 0, 2101, 2105, 5, 116, 0, 0, 2102, 2105, 5, 155, 0, 0, 2103, 2105, 3, 2, 1, 0, 2104, 2101, 1, 0, 0, 0, 2104, 2102, 1, 0, 0, 0, 2104, 2103, 1, 0, 0, 0, 2105, 265, 1, 0, 0, 0, 2106, 2128, 5, 1, 0, 0, 2107, 2128, 5, 2, 0, 0, 2108, 2128, 5, 156, 0, 0, 2109, 2128, 5, 3, 0, 0, 2110, 2128, 5, 4, 0, 0, 2111, 2128, 5, 247, 0, 0, 2112, 2128, 5, 5, 0, 0, 2113, 2128, 5, 6, 0, 0, 2114, 2128, 5, 7, 0, 0, 2115, 2128, 5, 8, 0, 0, 2116, 2128, 5, 9, 0, 0, 2117, 2128, 5, 10, 0, 0, 2118, 2128, 5, 11, 0, 0, 2119, 2128, 5, 12, 0, 0, 2120, 2128, 5, 13, 0, 0, 2121, 2128, 5, 14, 0, 0, 2122, 2123, 5, 70, 0, 0, 2123, 2124, 5, 30, 0, 0, 2124, 2125, 3, 32, 16, 0, 2125, 2126, 5, 31, 0, 0, 2126, 2128, 1, 0, 0, 0, 2127, 2106, 1, 0, 0, 0, 2127, 2107, 1, 0, 0, 0, 2127, 2108, 1, 0, 0, 0, 2127, 2109, 1, 0, 0, 0, 2127, 2110, 1, 0, 0, 0, 2127, 2111, 1, 0, 0, 0, 2127, 2112, 1, 0, 0, 0, 2127, 2113, 1, 0, 0, 0, 2127, 2114, 1, 0, 0, 0, 2127, 2115, 1, 0, 0, 0, 2127, 2116, 1, 0, 0, 0, 2127, 2117, 1, 0, 0, 0, 2127, 2118, 1, 0, 0, 0, 2127, 2119, 1, 0, 0, 0, 2127, 2120, 1, 0, 0, 0, 2127, 2121, 1, 0, 0, 0, 2127, 2122, 1, 0, 0, 0, 2128, 267, 1, 0, 0, 0, 2129, 2131, 3, 270, 135, 0, 2130, 2129, 1, 0, 0, 0, 2131, 2134, 1, 0, 0, 0, 2132, 2130, 1, 0, 0, 0, 2132, 2133, 1, 0, 0, 0, 2133, 269, 1, 0, 0, 0, 2134, 2132, 1, 0, 0, 0, 2135, 2244, 3, 126, 63, 0, 2136, 2137, 5, 296, 0, 0, 2137, 2244, 3, 32, 16, 0, 2138, 2244, 3, 278, 139, 0, 2139, 2140, 5, 297, 0, 0, 2140, 2244, 3, 32, 16, 0, 2141, 2142, 5, 300, 0, 0, 2142, 2244, 3, 134, 67, 0, 2143, 2144, 5, 300, 0, 0, 2144, 2145, 5, 157, 0, 0, 2145, 2244, 3, 134, 67, 0, 2146, 2244, 5, 298, 0, 0, 2147, 2244, 5, 299, 0, 0, 2148, 2244, 3, 296, 148, 0, 2149, 2244, 3, 272, 136, 0, 2150, 2244, 3, 174, 87, 0, 2151, 2244, 3, 88, 44, 0, 2152, 2244, 3, 26, 13, 0, 2153, 2244, 3, 274, 137, 0, 2154, 2244, 3, 40, 20, 0, 2155, 2156, 5, 301, 0, 0, 2156, 2157, 5, 42, 0, 0, 2157, 2158, 3, 32, 16, 0, 2158, 2159, 5, 43, 0, 0, 2159, 2244, 1, 0, 0, 0, 2160, 2161, 5, 301, 0, 0, 2161, 2162, 5, 42, 0, 0, 2162, 2163, 3, 32, 16, 0, 2163, 2164, 5, 43, 0, 0, 2164, 2165, 5, 34, 0, 0, 2165, 2166, 3, 0, 0, 0, 2166, 2244, 1, 0, 0, 0, 2167, 2168, 5, 303, 0, 0, 2168, 2169, 3, 32, 16, 0, 2169, 2170, 5, 75, 0, 0, 2170, 2171, 3, 32, 16, 0, 2171, 2244, 1, 0, 0, 0, 2172, 2173, 5, 302, 0, 0, 2173, 2174, 3, 146, 73, 0, 2174, 2175, 5, 176, 0, 0, 2175, 2176, 3, 264, 132, 0, 2176, 2244, 1, 0, 0, 0, 2177, 2178, 5, 302, 0, 0, 2178, 2179, 5, 226, 0, 0, 2179, 2180, 3, 192, 96, 0, 2180, 2181, 3, 160, 80, 0, 2181, 2182, 3, 146, 73, 0, 2182, 2183, 5, 176, 0, 0, 2183, 2184, 3, 264, 132, 0, 2184, 2185, 3, 216, 108, 0, 2185, 2186, 3, 134, 67, 0, 2186, 2244, 1, 0, 0, 0, 2187, 2244, 3, 276, 138, 0, 2188, 2189, 5, 255, 0, 0, 2189, 2190, 5, 196, 0, 0, 2190, 2191, 5, 42, 0, 0, 2191, 2192, 3, 32, 16, 0, 2192, 2196, 5, 43, 0, 0, 2193, 2195, 3, 342, 171, 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, 2244, 1, 0, 0, 0, 2198, 2196, 1, 0, 0, 0, 2199, 2200, 5, 255, 0, 0, 2200, 2201, 5, 196, 0, 0, 2201, 2205, 3, 2, 1, 0, 2202, 2204, 3, 342, 171, 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, 2244, 1, 0, 0, 0, 2207, 2205, 1, 0, 0, 0, 2208, 2209, 5, 255, 0, 0, 2209, 2210, 5, 256, 0, 0, 2210, 2211, 5, 42, 0, 0, 2211, 2212, 3, 32, 16, 0, 2212, 2213, 5, 43, 0, 0, 2213, 2214, 5, 28, 0, 0, 2214, 2218, 3, 146, 73, 0, 2215, 2217, 3, 342, 171, 0, 2216, 2215, 1, 0, 0, 0, 2217, 2220, 1, 0, 0, 0, 2218, 2216, 1, 0, 0, 0, 2218, 2219, 1, 0, 0, 0, 2219, 2244, 1, 0, 0, 0, 2220, 2218, 1, 0, 0, 0, 2221, 2222, 5, 255, 0, 0, 2222, 2223, 5, 256, 0, 0, 2223, 2224, 3, 2, 1, 0, 2224, 2225, 5, 28, 0, 0, 2225, 2229, 3, 146, 73, 0, 2226, 2228, 3, 342, 171, 0, 2227, 2226, 1, 0, 0, 0, 2228, 2231, 1, 0, 0, 0, 2229, 2227, 1, 0, 0, 0, 2229, 2230, 1, 0, 0, 0, 2230, 2244, 1, 0, 0, 0, 2231, 2229, 1, 0, 0, 0, 2232, 2233, 5, 255, 0, 0, 2233, 2234, 5, 42, 0, 0, 2234, 2235, 3, 32, 16, 0, 2235, 2236, 5, 43, 0, 0, 2236, 2240, 3, 228, 114, 0, 2237, 2239, 3, 342, 171, 0, 2238, 2237, 1, 0, 0, 0, 2239, 2242, 1, 0, 0, 0, 2240, 2238, 1, 0, 0, 0, 2240, 2241, 1, 0, 0, 0, 2241, 2244, 1, 0, 0, 0, 2242, 2240, 1, 0, 0, 0, 2243, 2135, 1, 0, 0, 0, 2243, 2136, 1, 0, 0, 0, 2243, 2138, 1, 0, 0, 0, 2243, 2139, 1, 0, 0, 0, 2243, 2141, 1, 0, 0, 0, 2243, 2143, 1, 0, 0, 0, 2243, 2146, 1, 0, 0, 0, 2243, 2147, 1, 0, 0, 0, 2243, 2148, 1, 0, 0, 0, 2243, 2149, 1, 0, 0, 0, 2243, 2150, 1, 0, 0, 0, 2243, 2151, 1, 0, 0, 0, 2243, 2152, 1, 0, 0, 0, 2243, 2153, 1, 0, 0, 0, 2243, 2154, 1, 0, 0, 0, 2243, 2155, 1, 0, 0, 0, 2243, 2160, 1, 0, 0, 0, 2243, 2167, 1, 0, 0, 0, 2243, 2172, 1, 0, 0, 0, 2243, 2177, 1, 0, 0, 0, 2243, 2187, 1, 0, 0, 0, 2243, 2188, 1, 0, 0, 0, 2243, 2199, 1, 0, 0, 0, 2243, 2208, 1, 0, 0, 0, 2243, 2221, 1, 0, 0, 0, 2243, 2232, 1, 0, 0, 0, 2244, 271, 1, 0, 0, 0, 2245, 2246, 3, 0, 0, 0, 2246, 2247, 5, 75, 0, 0, 2247, 273, 1, 0, 0, 0, 2248, 2251, 3, 44, 22, 0, 2249, 2251, 3, 46, 23, 0, 2250, 2248, 1, 0, 0, 0, 2250, 2249, 1, 0, 0, 0, 2251, 275, 1, 0, 0, 0, 2252, 2253, 5, 17, 0, 0, 2253, 2254, 3, 268, 134, 0, 2254, 2255, 5, 18, 0, 0, 2255, 277, 1, 0, 0, 0, 2256, 2257, 3, 282, 141, 0, 2257, 2258, 3, 280, 140, 0, 2258, 279, 1, 0, 0, 0, 2259, 2261, 3, 284, 142, 0, 2260, 2259, 1, 0, 0, 0, 2261, 2262, 1, 0, 0, 0, 2262, 2260, 1, 0, 0, 0, 2262, 2263, 1, 0, 0, 0, 2263, 281, 1, 0, 0, 0, 2264, 2265, 5, 158, 0, 0, 2265, 2277, 3, 276, 138, 0, 2266, 2267, 5, 158, 0, 0, 2267, 2268, 3, 0, 0, 0, 2268, 2269, 5, 159, 0, 0, 2269, 2270, 3, 0, 0, 0, 2270, 2277, 1, 0, 0, 0, 2271, 2272, 5, 158, 0, 0, 2272, 2273, 3, 32, 16, 0, 2273, 2274, 5, 159, 0, 0, 2274, 2275, 3, 32, 16, 0, 2275, 2277, 1, 0, 0, 0, 2276, 2264, 1, 0, 0, 0, 2276, 2266, 1, 0, 0, 0, 2276, 2271, 1, 0, 0, 0, 2277, 283, 1, 0, 0, 0, 2278, 2279, 3, 288, 144, 0, 2279, 2280, 3, 294, 147, 0, 2280, 2291, 1, 0, 0, 0, 2281, 2282, 3, 286, 143, 0, 2282, 2283, 3, 294, 147, 0, 2283, 2291, 1, 0, 0, 0, 2284, 2285, 3, 290, 145, 0, 2285, 2286, 3, 294, 147, 0, 2286, 2291, 1, 0, 0, 0, 2287, 2288, 3, 292, 146, 0, 2288, 2289, 3, 294, 147, 0, 2289, 2291, 1, 0, 0, 0, 2290, 2278, 1, 0, 0, 0, 2290, 2281, 1, 0, 0, 0, 2290, 2284, 1, 0, 0, 0, 2290, 2287, 1, 0, 0, 0, 2291, 285, 1, 0, 0, 0, 2292, 2293, 5, 160, 0, 0, 2293, 2299, 3, 276, 138, 0, 2294, 2295, 5, 160, 0, 0, 2295, 2299, 3, 0, 0, 0, 2296, 2297, 5, 160, 0, 0, 2297, 2299, 3, 32, 16, 0, 2298, 2292, 1, 0, 0, 0, 2298, 2294, 1, 0, 0, 0, 2298, 2296, 1, 0, 0, 0, 2299, 287, 1, 0, 0, 0, 2300, 2301, 5, 161, 0, 0, 2301, 2302, 3, 146, 73, 0, 2302, 289, 1, 0, 0, 0, 2303, 2304, 5, 162, 0, 0, 2304, 291, 1, 0, 0, 0, 2305, 2306, 5, 163, 0, 0, 2306, 293, 1, 0, 0, 0, 2307, 2319, 3, 276, 138, 0, 2308, 2309, 5, 164, 0, 0, 2309, 2310, 3, 0, 0, 0, 2310, 2311, 5, 159, 0, 0, 2311, 2312, 3, 0, 0, 0, 2312, 2319, 1, 0, 0, 0, 2313, 2314, 5, 164, 0, 0, 2314, 2315, 3, 32, 16, 0, 2315, 2316, 5, 159, 0, 0, 2316, 2317, 3, 32, 16, 0, 2317, 2319, 1, 0, 0, 0, 2318, 2307, 1, 0, 0, 0, 2318, 2308, 1, 0, 0, 0, 2318, 2313, 1, 0, 0, 0, 2319, 295, 1, 0, 0, 0, 2320, 2321, 3, 298, 149, 0, 2321, 2322, 3, 302, 151, 0, 2322, 297, 1, 0, 0, 0, 2323, 2324, 5, 165, 0, 0, 2324, 2325, 3, 300, 150, 0, 2325, 2326, 3, 0, 0, 0, 2326, 2327, 5, 36, 0, 0, 2327, 2331, 1, 0, 0, 0, 2328, 2329, 5, 165, 0, 0, 2329, 2331, 3, 300, 150, 0, 2330, 2323, 1, 0, 0, 0, 2330, 2328, 1, 0, 0, 0, 2331, 299, 1, 0, 0, 0, 2332, 2336, 1, 0, 0, 0, 2333, 2336, 5, 166, 0, 0, 2334, 2336, 5, 2, 0, 0, 2335, 2332, 1, 0, 0, 0, 2335, 2333, 1, 0, 0, 0, 2335, 2334, 1, 0, 0, 0, 2336, 301, 1, 0, 0, 0, 2337, 2338, 5, 17, 0, 0, 2338, 2339, 3, 304, 152, 0, 2339, 2340, 5, 18, 0, 0, 2340, 2347, 1, 0, 0, 0, 2341, 2343, 3, 308, 154, 0, 2342, 2341, 1, 0, 0, 0, 2343, 2344, 1, 0, 0, 0, 2344, 2342, 1, 0, 0, 0, 2344, 2345, 1, 0, 0, 0, 2345, 2347, 1, 0, 0, 0, 2346, 2337, 1, 0, 0, 0, 2346, 2342, 1, 0, 0, 0, 2347, 303, 1, 0, 0, 0, 2348, 2349, 3, 308, 154, 0, 2349, 2350, 5, 28, 0, 0, 2350, 2352, 1, 0, 0, 0, 2351, 2348, 1, 0, 0, 0, 2352, 2355, 1, 0, 0, 0, 2353, 2351, 1, 0, 0, 0, 2353, 2354, 1, 0, 0, 0, 2354, 2356, 1, 0, 0, 0, 2355, 2353, 1, 0, 0, 0, 2356, 2357, 3, 308, 154, 0, 2357, 305, 1, 0, 0, 0, 2358, 2364, 1, 0, 0, 0, 2359, 2360, 5, 42, 0, 0, 2360, 2361, 3, 32, 16, 0, 2361, 2362, 5, 43, 0, 0, 2362, 2364, 1, 0, 0, 0, 2363, 2358, 1, 0, 0, 0, 2363, 2359, 1, 0, 0, 0, 2364, 307, 1, 0, 0, 0, 2365, 2366, 5, 181, 0, 0, 2366, 2367, 5, 262, 0, 0, 2367, 2368, 5, 30, 0, 0, 2368, 2369, 3, 6, 3, 0, 2369, 2370, 5, 31, 0, 0, 2370, 2432, 1, 0, 0, 0, 2371, 2372, 5, 260, 0, 0, 2372, 2373, 5, 30, 0, 0, 2373, 2374, 3, 0, 0, 0, 2374, 2375, 5, 31, 0, 0, 2375, 2432, 1, 0, 0, 0, 2376, 2377, 5, 260, 0, 0, 2377, 2432, 3, 0, 0, 0, 2378, 2379, 5, 84, 0, 0, 2379, 2380, 5, 30, 0, 0, 2380, 2381, 3, 312, 156, 0, 2381, 2382, 5, 31, 0, 0, 2382, 2432, 1, 0, 0, 0, 2383, 2384, 5, 188, 0, 0, 2384, 2385, 5, 30, 0, 0, 2385, 2386, 3, 36, 18, 0, 2386, 2387, 5, 31, 0, 0, 2387, 2388, 3, 306, 153, 0, 2388, 2432, 1, 0, 0, 0, 2389, 2390, 5, 189, 0, 0, 2390, 2391, 5, 30, 0, 0, 2391, 2392, 3, 36, 18, 0, 2392, 2393, 5, 31, 0, 0, 2393, 2394, 3, 306, 153, 0, 2394, 2432, 1, 0, 0, 0, 2395, 2396, 5, 187, 0, 0, 2396, 2397, 5, 30, 0, 0, 2397, 2398, 3, 34, 17, 0, 2398, 2399, 5, 31, 0, 0, 2399, 2400, 3, 306, 153, 0, 2400, 2432, 1, 0, 0, 0, 2401, 2402, 5, 186, 0, 0, 2402, 2403, 5, 30, 0, 0, 2403, 2404, 3, 32, 16, 0, 2404, 2405, 5, 31, 0, 0, 2405, 2406, 3, 306, 153, 0, 2406, 2432, 1, 0, 0, 0, 2407, 2408, 5, 185, 0, 0, 2408, 2409, 5, 30, 0, 0, 2409, 2410, 3, 32, 16, 0, 2410, 2411, 5, 31, 0, 0, 2411, 2412, 3, 306, 153, 0, 2412, 2432, 1, 0, 0, 0, 2413, 2414, 5, 184, 0, 0, 2414, 2415, 5, 30, 0, 0, 2415, 2416, 3, 32, 16, 0, 2416, 2417, 5, 31, 0, 0, 2417, 2418, 3, 306, 153, 0, 2418, 2432, 1, 0, 0, 0, 2419, 2420, 5, 188, 0, 0, 2420, 2432, 3, 306, 153, 0, 2421, 2422, 5, 189, 0, 0, 2422, 2432, 3, 306, 153, 0, 2423, 2424, 5, 187, 0, 0, 2424, 2432, 3, 306, 153, 0, 2425, 2426, 5, 186, 0, 0, 2426, 2432, 3, 306, 153, 0, 2427, 2428, 5, 185, 0, 0, 2428, 2432, 3, 306, 153, 0, 2429, 2430, 5, 184, 0, 0, 2430, 2432, 3, 306, 153, 0, 2431, 2365, 1, 0, 0, 0, 2431, 2371, 1, 0, 0, 0, 2431, 2376, 1, 0, 0, 0, 2431, 2378, 1, 0, 0, 0, 2431, 2383, 1, 0, 0, 0, 2431, 2389, 1, 0, 0, 0, 2431, 2395, 1, 0, 0, 0, 2431, 2401, 1, 0, 0, 0, 2431, 2407, 1, 0, 0, 0, 2431, 2413, 1, 0, 0, 0, 2431, 2419, 1, 0, 0, 0, 2431, 2421, 1, 0, 0, 0, 2431, 2423, 1, 0, 0, 0, 2431, 2425, 1, 0, 0, 0, 2431, 2427, 1, 0, 0, 0, 2431, 2429, 1, 0, 0, 0, 2432, 309, 1, 0, 0, 0, 2433, 2434, 5, 188, 0, 0, 2434, 2435, 5, 30, 0, 0, 2435, 2436, 3, 36, 18, 0, 2436, 2437, 5, 31, 0, 0, 2437, 2509, 1, 0, 0, 0, 2438, 2439, 5, 189, 0, 0, 2439, 2440, 5, 30, 0, 0, 2440, 2441, 3, 36, 18, 0, 2441, 2442, 5, 31, 0, 0, 2442, 2509, 1, 0, 0, 0, 2443, 2444, 5, 188, 0, 0, 2444, 2445, 5, 30, 0, 0, 2445, 2446, 3, 32, 16, 0, 2446, 2447, 5, 31, 0, 0, 2447, 2509, 1, 0, 0, 0, 2448, 2449, 5, 189, 0, 0, 2449, 2450, 5, 30, 0, 0, 2450, 2451, 3, 34, 17, 0, 2451, 2452, 5, 31, 0, 0, 2452, 2509, 1, 0, 0, 0, 2453, 2454, 5, 187, 0, 0, 2454, 2455, 5, 30, 0, 0, 2455, 2456, 3, 34, 17, 0, 2456, 2457, 5, 31, 0, 0, 2457, 2509, 1, 0, 0, 0, 2458, 2459, 5, 186, 0, 0, 2459, 2460, 5, 30, 0, 0, 2460, 2461, 3, 32, 16, 0, 2461, 2462, 5, 31, 0, 0, 2462, 2509, 1, 0, 0, 0, 2463, 2464, 5, 185, 0, 0, 2464, 2465, 5, 30, 0, 0, 2465, 2466, 3, 32, 16, 0, 2466, 2467, 5, 31, 0, 0, 2467, 2509, 1, 0, 0, 0, 2468, 2469, 5, 184, 0, 0, 2469, 2470, 5, 30, 0, 0, 2470, 2471, 3, 32, 16, 0, 2471, 2472, 5, 31, 0, 0, 2472, 2509, 1, 0, 0, 0, 2473, 2474, 5, 193, 0, 0, 2474, 2475, 5, 30, 0, 0, 2475, 2476, 3, 34, 17, 0, 2476, 2477, 5, 31, 0, 0, 2477, 2509, 1, 0, 0, 0, 2478, 2479, 5, 192, 0, 0, 2479, 2480, 5, 30, 0, 0, 2480, 2481, 3, 32, 16, 0, 2481, 2482, 5, 31, 0, 0, 2482, 2509, 1, 0, 0, 0, 2483, 2484, 5, 191, 0, 0, 2484, 2485, 5, 30, 0, 0, 2485, 2486, 3, 32, 16, 0, 2486, 2487, 5, 31, 0, 0, 2487, 2509, 1, 0, 0, 0, 2488, 2489, 5, 190, 0, 0, 2489, 2490, 5, 30, 0, 0, 2490, 2491, 3, 32, 16, 0, 2491, 2492, 5, 31, 0, 0, 2492, 2509, 1, 0, 0, 0, 2493, 2494, 5, 181, 0, 0, 2494, 2495, 5, 30, 0, 0, 2495, 2496, 3, 32, 16, 0, 2496, 2497, 5, 31, 0, 0, 2497, 2509, 1, 0, 0, 0, 2498, 2499, 5, 183, 0, 0, 2499, 2500, 5, 30, 0, 0, 2500, 2501, 3, 184, 92, 0, 2501, 2502, 5, 31, 0, 0, 2502, 2509, 1, 0, 0, 0, 2503, 2504, 5, 84, 0, 0, 2504, 2505, 5, 30, 0, 0, 2505, 2506, 3, 312, 156, 0, 2506, 2507, 5, 31, 0, 0, 2507, 2509, 1, 0, 0, 0, 2508, 2433, 1, 0, 0, 0, 2508, 2438, 1, 0, 0, 0, 2508, 2443, 1, 0, 0, 0, 2508, 2448, 1, 0, 0, 0, 2508, 2453, 1, 0, 0, 0, 2508, 2458, 1, 0, 0, 0, 2508, 2463, 1, 0, 0, 0, 2508, 2468, 1, 0, 0, 0, 2508, 2473, 1, 0, 0, 0, 2508, 2478, 1, 0, 0, 0, 2508, 2483, 1, 0, 0, 0, 2508, 2488, 1, 0, 0, 0, 2508, 2493, 1, 0, 0, 0, 2508, 2498, 1, 0, 0, 0, 2508, 2503, 1, 0, 0, 0, 2509, 311, 1, 0, 0, 0, 2510, 2511, 3, 314, 157, 0, 2511, 2512, 6, 156, -1, 0, 2512, 2514, 1, 0, 0, 0, 2513, 2510, 1, 0, 0, 0, 2514, 2517, 1, 0, 0, 0, 2515, 2513, 1, 0, 0, 0, 2515, 2516, 1, 0, 0, 0, 2516, 313, 1, 0, 0, 0, 2517, 2515, 1, 0, 0, 0, 2518, 2519, 7, 12, 0, 0, 2519, 315, 1, 0, 0, 0, 2520, 2524, 3, 310, 155, 0, 2521, 2524, 3, 6, 3, 0, 2522, 2524, 5, 179, 0, 0, 2523, 2520, 1, 0, 0, 0, 2523, 2521, 1, 0, 0, 0, 2523, 2522, 1, 0, 0, 0, 2524, 317, 1, 0, 0, 0, 2525, 2674, 3, 310, 155, 0, 2526, 2527, 5, 182, 0, 0, 2527, 2528, 5, 30, 0, 0, 2528, 2529, 5, 179, 0, 0, 2529, 2674, 5, 31, 0, 0, 2530, 2531, 5, 182, 0, 0, 2531, 2532, 5, 30, 0, 0, 2532, 2533, 5, 264, 0, 0, 2533, 2674, 5, 31, 0, 0, 2534, 2535, 5, 196, 0, 0, 2535, 2536, 5, 30, 0, 0, 2536, 2537, 5, 39, 0, 0, 2537, 2538, 5, 264, 0, 0, 2538, 2674, 5, 31, 0, 0, 2539, 2540, 5, 196, 0, 0, 2540, 2541, 5, 30, 0, 0, 2541, 2542, 3, 138, 69, 0, 2542, 2543, 5, 31, 0, 0, 2543, 2674, 1, 0, 0, 0, 2544, 2545, 5, 196, 0, 0, 2545, 2546, 5, 30, 0, 0, 2546, 2547, 5, 179, 0, 0, 2547, 2674, 5, 31, 0, 0, 2548, 2549, 5, 197, 0, 0, 2549, 2550, 5, 30, 0, 0, 2550, 2551, 3, 318, 159, 0, 2551, 2552, 5, 31, 0, 0, 2552, 2674, 1, 0, 0, 0, 2553, 2554, 5, 188, 0, 0, 2554, 2555, 5, 42, 0, 0, 2555, 2556, 3, 32, 16, 0, 2556, 2557, 5, 43, 0, 0, 2557, 2558, 5, 30, 0, 0, 2558, 2559, 3, 320, 160, 0, 2559, 2560, 5, 31, 0, 0, 2560, 2674, 1, 0, 0, 0, 2561, 2562, 5, 189, 0, 0, 2562, 2563, 5, 42, 0, 0, 2563, 2564, 3, 32, 16, 0, 2564, 2565, 5, 43, 0, 0, 2565, 2566, 5, 30, 0, 0, 2566, 2567, 3, 322, 161, 0, 2567, 2568, 5, 31, 0, 0, 2568, 2674, 1, 0, 0, 0, 2569, 2570, 5, 187, 0, 0, 2570, 2571, 5, 42, 0, 0, 2571, 2572, 3, 32, 16, 0, 2572, 2573, 5, 43, 0, 0, 2573, 2574, 5, 30, 0, 0, 2574, 2575, 3, 324, 162, 0, 2575, 2576, 5, 31, 0, 0, 2576, 2674, 1, 0, 0, 0, 2577, 2578, 5, 186, 0, 0, 2578, 2579, 5, 42, 0, 0, 2579, 2580, 3, 32, 16, 0, 2580, 2581, 5, 43, 0, 0, 2581, 2582, 5, 30, 0, 0, 2582, 2583, 3, 326, 163, 0, 2583, 2584, 5, 31, 0, 0, 2584, 2674, 1, 0, 0, 0, 2585, 2586, 5, 185, 0, 0, 2586, 2587, 5, 42, 0, 0, 2587, 2588, 3, 32, 16, 0, 2588, 2589, 5, 43, 0, 0, 2589, 2590, 5, 30, 0, 0, 2590, 2591, 3, 328, 164, 0, 2591, 2592, 5, 31, 0, 0, 2592, 2674, 1, 0, 0, 0, 2593, 2594, 5, 184, 0, 0, 2594, 2595, 5, 42, 0, 0, 2595, 2596, 3, 32, 16, 0, 2596, 2597, 5, 43, 0, 0, 2597, 2598, 5, 30, 0, 0, 2598, 2599, 3, 330, 165, 0, 2599, 2600, 5, 31, 0, 0, 2600, 2674, 1, 0, 0, 0, 2601, 2602, 5, 193, 0, 0, 2602, 2603, 5, 42, 0, 0, 2603, 2604, 3, 32, 16, 0, 2604, 2605, 5, 43, 0, 0, 2605, 2606, 5, 30, 0, 0, 2606, 2607, 3, 324, 162, 0, 2607, 2608, 5, 31, 0, 0, 2608, 2674, 1, 0, 0, 0, 2609, 2610, 5, 192, 0, 0, 2610, 2611, 5, 42, 0, 0, 2611, 2612, 3, 32, 16, 0, 2612, 2613, 5, 43, 0, 0, 2613, 2614, 5, 30, 0, 0, 2614, 2615, 3, 326, 163, 0, 2615, 2616, 5, 31, 0, 0, 2616, 2674, 1, 0, 0, 0, 2617, 2618, 5, 191, 0, 0, 2618, 2619, 5, 42, 0, 0, 2619, 2620, 3, 32, 16, 0, 2620, 2621, 5, 43, 0, 0, 2621, 2622, 5, 30, 0, 0, 2622, 2623, 3, 328, 164, 0, 2623, 2624, 5, 31, 0, 0, 2624, 2674, 1, 0, 0, 0, 2625, 2626, 5, 190, 0, 0, 2626, 2627, 5, 42, 0, 0, 2627, 2628, 3, 32, 16, 0, 2628, 2629, 5, 43, 0, 0, 2629, 2630, 5, 30, 0, 0, 2630, 2631, 3, 330, 165, 0, 2631, 2632, 5, 31, 0, 0, 2632, 2674, 1, 0, 0, 0, 2633, 2634, 5, 181, 0, 0, 2634, 2635, 5, 42, 0, 0, 2635, 2636, 3, 32, 16, 0, 2636, 2637, 5, 43, 0, 0, 2637, 2638, 5, 30, 0, 0, 2638, 2639, 3, 328, 164, 0, 2639, 2640, 5, 31, 0, 0, 2640, 2674, 1, 0, 0, 0, 2641, 2642, 5, 183, 0, 0, 2642, 2643, 5, 42, 0, 0, 2643, 2644, 3, 32, 16, 0, 2644, 2645, 5, 43, 0, 0, 2645, 2646, 5, 30, 0, 0, 2646, 2647, 3, 332, 166, 0, 2647, 2648, 5, 31, 0, 0, 2648, 2674, 1, 0, 0, 0, 2649, 2650, 5, 182, 0, 0, 2650, 2651, 5, 42, 0, 0, 2651, 2652, 3, 32, 16, 0, 2652, 2653, 5, 43, 0, 0, 2653, 2654, 5, 30, 0, 0, 2654, 2655, 3, 334, 167, 0, 2655, 2656, 5, 31, 0, 0, 2656, 2674, 1, 0, 0, 0, 2657, 2658, 5, 196, 0, 0, 2658, 2659, 5, 42, 0, 0, 2659, 2660, 3, 32, 16, 0, 2660, 2661, 5, 43, 0, 0, 2661, 2662, 5, 30, 0, 0, 2662, 2663, 3, 336, 168, 0, 2663, 2664, 5, 31, 0, 0, 2664, 2674, 1, 0, 0, 0, 2665, 2666, 5, 197, 0, 0, 2666, 2667, 5, 42, 0, 0, 2667, 2668, 3, 32, 16, 0, 2668, 2669, 5, 43, 0, 0, 2669, 2670, 5, 30, 0, 0, 2670, 2671, 3, 340, 170, 0, 2671, 2672, 5, 31, 0, 0, 2672, 2674, 1, 0, 0, 0, 2673, 2525, 1, 0, 0, 0, 2673, 2526, 1, 0, 0, 0, 2673, 2530, 1, 0, 0, 0, 2673, 2534, 1, 0, 0, 0, 2673, 2539, 1, 0, 0, 0, 2673, 2544, 1, 0, 0, 0, 2673, 2548, 1, 0, 0, 0, 2673, 2553, 1, 0, 0, 0, 2673, 2561, 1, 0, 0, 0, 2673, 2569, 1, 0, 0, 0, 2673, 2577, 1, 0, 0, 0, 2673, 2585, 1, 0, 0, 0, 2673, 2593, 1, 0, 0, 0, 2673, 2601, 1, 0, 0, 0, 2673, 2609, 1, 0, 0, 0, 2673, 2617, 1, 0, 0, 0, 2673, 2625, 1, 0, 0, 0, 2673, 2633, 1, 0, 0, 0, 2673, 2641, 1, 0, 0, 0, 2673, 2649, 1, 0, 0, 0, 2673, 2657, 1, 0, 0, 0, 2673, 2665, 1, 0, 0, 0, 2674, 319, 1, 0, 0, 0, 2675, 2678, 3, 36, 18, 0, 2676, 2678, 3, 32, 16, 0, 2677, 2675, 1, 0, 0, 0, 2677, 2676, 1, 0, 0, 0, 2678, 2681, 1, 0, 0, 0, 2679, 2677, 1, 0, 0, 0, 2679, 2680, 1, 0, 0, 0, 2680, 321, 1, 0, 0, 0, 2681, 2679, 1, 0, 0, 0, 2682, 2685, 3, 36, 18, 0, 2683, 2685, 3, 34, 17, 0, 2684, 2682, 1, 0, 0, 0, 2684, 2683, 1, 0, 0, 0, 2685, 2688, 1, 0, 0, 0, 2686, 2684, 1, 0, 0, 0, 2686, 2687, 1, 0, 0, 0, 2687, 323, 1, 0, 0, 0, 2688, 2686, 1, 0, 0, 0, 2689, 2691, 3, 34, 17, 0, 2690, 2689, 1, 0, 0, 0, 2691, 2694, 1, 0, 0, 0, 2692, 2690, 1, 0, 0, 0, 2692, 2693, 1, 0, 0, 0, 2693, 325, 1, 0, 0, 0, 2694, 2692, 1, 0, 0, 0, 2695, 2697, 3, 32, 16, 0, 2696, 2695, 1, 0, 0, 0, 2697, 2700, 1, 0, 0, 0, 2698, 2696, 1, 0, 0, 0, 2698, 2699, 1, 0, 0, 0, 2699, 327, 1, 0, 0, 0, 2700, 2698, 1, 0, 0, 0, 2701, 2703, 3, 32, 16, 0, 2702, 2701, 1, 0, 0, 0, 2703, 2706, 1, 0, 0, 0, 2704, 2702, 1, 0, 0, 0, 2704, 2705, 1, 0, 0, 0, 2705, 329, 1, 0, 0, 0, 2706, 2704, 1, 0, 0, 0, 2707, 2709, 3, 32, 16, 0, 2708, 2707, 1, 0, 0, 0, 2709, 2712, 1, 0, 0, 0, 2710, 2708, 1, 0, 0, 0, 2710, 2711, 1, 0, 0, 0, 2711, 331, 1, 0, 0, 0, 2712, 2710, 1, 0, 0, 0, 2713, 2715, 3, 184, 92, 0, 2714, 2713, 1, 0, 0, 0, 2715, 2718, 1, 0, 0, 0, 2716, 2714, 1, 0, 0, 0, 2716, 2717, 1, 0, 0, 0, 2717, 333, 1, 0, 0, 0, 2718, 2716, 1, 0, 0, 0, 2719, 2721, 7, 13, 0, 0, 2720, 2719, 1, 0, 0, 0, 2721, 2724, 1, 0, 0, 0, 2722, 2720, 1, 0, 0, 0, 2722, 2723, 1, 0, 0, 0, 2723, 335, 1, 0, 0, 0, 2724, 2722, 1, 0, 0, 0, 2725, 2727, 3, 338, 169, 0, 2726, 2725, 1, 0, 0, 0, 2727, 2730, 1, 0, 0, 0, 2728, 2726, 1, 0, 0, 0, 2728, 2729, 1, 0, 0, 0, 2729, 337, 1, 0, 0, 0, 2730, 2728, 1, 0, 0, 0, 2731, 2736, 5, 179, 0, 0, 2732, 2733, 5, 39, 0, 0, 2733, 2736, 5, 264, 0, 0, 2734, 2736, 3, 138, 69, 0, 2735, 2731, 1, 0, 0, 0, 2735, 2732, 1, 0, 0, 0, 2735, 2734, 1, 0, 0, 0, 2736, 339, 1, 0, 0, 0, 2737, 2739, 3, 318, 159, 0, 2738, 2737, 1, 0, 0, 0, 2739, 2742, 1, 0, 0, 0, 2740, 2738, 1, 0, 0, 0, 2740, 2741, 1, 0, 0, 0, 2741, 341, 1, 0, 0, 0, 2742, 2740, 1, 0, 0, 0, 2743, 2747, 3, 44, 22, 0, 2744, 2747, 3, 46, 23, 0, 2745, 2747, 3, 2, 1, 0, 2746, 2743, 1, 0, 0, 0, 2746, 2744, 1, 0, 0, 0, 2746, 2745, 1, 0, 0, 0, 2747, 343, 1, 0, 0, 0, 2748, 2749, 7, 14, 0, 0, 2749, 2750, 5, 36, 0, 0, 2750, 2751, 5, 30, 0, 0, 2751, 2752, 3, 312, 156, 0, 2752, 2753, 5, 31, 0, 0, 2753, 2774, 1, 0, 0, 0, 2754, 2755, 5, 169, 0, 0, 2755, 2756, 3, 38, 19, 0, 2756, 2757, 5, 75, 0, 0, 2757, 2758, 3, 38, 19, 0, 2758, 2759, 5, 75, 0, 0, 2759, 2760, 3, 38, 19, 0, 2760, 2761, 5, 75, 0, 0, 2761, 2762, 3, 38, 19, 0, 2762, 2774, 1, 0, 0, 0, 2763, 2764, 5, 170, 0, 0, 2764, 2774, 3, 6, 3, 0, 2765, 2766, 5, 170, 0, 0, 2766, 2767, 5, 36, 0, 0, 2767, 2768, 5, 30, 0, 0, 2768, 2769, 3, 312, 156, 0, 2769, 2770, 5, 31, 0, 0, 2770, 2774, 1, 0, 0, 0, 2771, 2774, 3, 342, 171, 0, 2772, 2774, 3, 40, 20, 0, 2773, 2748, 1, 0, 0, 0, 2773, 2754, 1, 0, 0, 0, 2773, 2763, 1, 0, 0, 0, 2773, 2765, 1, 0, 0, 0, 2773, 2771, 1, 0, 0, 0, 2773, 2772, 1, 0, 0, 0, 2774, 345, 1, 0, 0, 0, 2775, 2776, 5, 25, 0, 0, 2776, 2777, 5, 40, 0, 0, 2777, 2778, 3, 98, 49, 0, 2778, 2779, 3, 2, 1, 0, 2779, 2788, 1, 0, 0, 0, 2780, 2781, 5, 25, 0, 0, 2781, 2782, 5, 40, 0, 0, 2782, 2783, 3, 98, 49, 0, 2783, 2784, 3, 2, 1, 0, 2784, 2785, 5, 34, 0, 0, 2785, 2786, 3, 2, 1, 0, 2786, 2788, 1, 0, 0, 0, 2787, 2775, 1, 0, 0, 0, 2787, 2780, 1, 0, 0, 0, 2788, 347, 1, 0, 0, 0, 2789, 2791, 3, 350, 175, 0, 2790, 2789, 1, 0, 0, 0, 2791, 2794, 1, 0, 0, 0, 2792, 2790, 1, 0, 0, 0, 2792, 2793, 1, 0, 0, 0, 2793, 349, 1, 0, 0, 0, 2794, 2792, 1, 0, 0, 0, 2795, 2796, 5, 180, 0, 0, 2796, 2797, 5, 36, 0, 0, 2797, 2798, 5, 30, 0, 0, 2798, 2799, 3, 312, 156, 0, 2799, 2800, 5, 31, 0, 0, 2800, 2810, 1, 0, 0, 0, 2801, 2810, 3, 344, 172, 0, 2802, 2803, 5, 171, 0, 0, 2803, 2804, 5, 36, 0, 0, 2804, 2805, 5, 30, 0, 0, 2805, 2806, 3, 312, 156, 0, 2806, 2807, 5, 31, 0, 0, 2807, 2810, 1, 0, 0, 0, 2808, 2810, 5, 55, 0, 0, 2809, 2795, 1, 0, 0, 0, 2809, 2801, 1, 0, 0, 0, 2809, 2802, 1, 0, 0, 0, 2809, 2808, 1, 0, 0, 0, 2810, 351, 1, 0, 0, 0, 2811, 2812, 5, 50, 0, 0, 2812, 2816, 5, 40, 0, 0, 2813, 2815, 3, 356, 178, 0, 2814, 2813, 1, 0, 0, 0, 2815, 2818, 1, 0, 0, 0, 2816, 2814, 1, 0, 0, 0, 2816, 2817, 1, 0, 0, 0, 2817, 2819, 1, 0, 0, 0, 2818, 2816, 1, 0, 0, 0, 2819, 2820, 3, 2, 1, 0, 2820, 353, 1, 0, 0, 0, 2821, 2825, 5, 301, 0, 0, 2822, 2824, 3, 356, 178, 0, 2823, 2822, 1, 0, 0, 0, 2824, 2827, 1, 0, 0, 0, 2825, 2823, 1, 0, 0, 0, 2825, 2826, 1, 0, 0, 0, 2826, 2828, 1, 0, 0, 0, 2827, 2825, 1, 0, 0, 0, 2828, 2829, 3, 2, 1, 0, 2829, 355, 1, 0, 0, 0, 2830, 2846, 5, 52, 0, 0, 2831, 2846, 5, 51, 0, 0, 2832, 2846, 5, 172, 0, 0, 2833, 2834, 5, 62, 0, 0, 2834, 2846, 5, 51, 0, 0, 2835, 2836, 5, 62, 0, 0, 2836, 2846, 5, 52, 0, 0, 2837, 2838, 5, 62, 0, 0, 2838, 2846, 5, 63, 0, 0, 2839, 2840, 5, 62, 0, 0, 2840, 2846, 5, 64, 0, 0, 2841, 2842, 5, 62, 0, 0, 2842, 2846, 5, 65, 0, 0, 2843, 2844, 5, 62, 0, 0, 2844, 2846, 5, 66, 0, 0, 2845, 2830, 1, 0, 0, 0, 2845, 2831, 1, 0, 0, 0, 2845, 2832, 1, 0, 0, 0, 2845, 2833, 1, 0, 0, 0, 2845, 2835, 1, 0, 0, 0, 2845, 2837, 1, 0, 0, 0, 2845, 2839, 1, 0, 0, 0, 2845, 2841, 1, 0, 0, 0, 2845, 2843, 1, 0, 0, 0, 2846, 357, 1, 0, 0, 0, 2847, 2849, 3, 360, 180, 0, 2848, 2847, 1, 0, 0, 0, 2849, 2852, 1, 0, 0, 0, 2850, 2848, 1, 0, 0, 0, 2850, 2851, 1, 0, 0, 0, 2851, 359, 1, 0, 0, 0, 2852, 2850, 1, 0, 0, 0, 2853, 2854, 5, 21, 0, 0, 2854, 2867, 3, 2, 1, 0, 2855, 2856, 5, 50, 0, 0, 2856, 2857, 5, 40, 0, 0, 2857, 2867, 3, 140, 70, 0, 2858, 2859, 5, 25, 0, 0, 2859, 2860, 5, 40, 0, 0, 2860, 2867, 3, 2, 1, 0, 2861, 2867, 3, 196, 98, 0, 2862, 2863, 5, 50, 0, 0, 2863, 2867, 3, 32, 16, 0, 2864, 2867, 3, 342, 171, 0, 2865, 2867, 3, 40, 20, 0, 2866, 2853, 1, 0, 0, 0, 2866, 2855, 1, 0, 0, 0, 2866, 2858, 1, 0, 0, 0, 2866, 2861, 1, 0, 0, 0, 2866, 2862, 1, 0, 0, 0, 2866, 2864, 1, 0, 0, 0, 2866, 2865, 1, 0, 0, 0, 2867, 361, 1, 0, 0, 0, 2868, 2872, 5, 274, 0, 0, 2869, 2871, 3, 364, 182, 0, 2870, 2869, 1, 0, 0, 0, 2871, 2874, 1, 0, 0, 0, 2872, 2870, 1, 0, 0, 0, 2872, 2873, 1, 0, 0, 0, 2873, 2875, 1, 0, 0, 0, 2874, 2872, 1, 0, 0, 0, 2875, 2888, 3, 2, 1, 0, 2876, 2880, 5, 274, 0, 0, 2877, 2879, 3, 364, 182, 0, 2878, 2877, 1, 0, 0, 0, 2879, 2882, 1, 0, 0, 0, 2880, 2878, 1, 0, 0, 0, 2880, 2881, 1, 0, 0, 0, 2881, 2883, 1, 0, 0, 0, 2882, 2880, 1, 0, 0, 0, 2883, 2884, 3, 2, 1, 0, 2884, 2885, 5, 34, 0, 0, 2885, 2886, 3, 2, 1, 0, 2886, 2888, 1, 0, 0, 0, 2887, 2868, 1, 0, 0, 0, 2887, 2876, 1, 0, 0, 0, 2888, 363, 1, 0, 0, 0, 2889, 2890, 7, 15, 0, 0, 2890, 365, 1, 0, 0, 0, 2891, 2893, 3, 368, 184, 0, 2892, 2891, 1, 0, 0, 0, 2893, 2896, 1, 0, 0, 0, 2894, 2892, 1, 0, 0, 0, 2894, 2895, 1, 0, 0, 0, 2895, 367, 1, 0, 0, 0, 2896, 2894, 1, 0, 0, 0, 2897, 2898, 5, 21, 0, 0, 2898, 2899, 3, 2, 1, 0, 2899, 2900, 5, 44, 0, 0, 2900, 2901, 3, 32, 16, 0, 2901, 2908, 1, 0, 0, 0, 2902, 2903, 5, 25, 0, 0, 2903, 2904, 5, 40, 0, 0, 2904, 2908, 3, 2, 1, 0, 2905, 2908, 3, 342, 171, 0, 2906, 2908, 3, 40, 20, 0, 2907, 2897, 1, 0, 0, 0, 2907, 2902, 1, 0, 0, 0, 2907, 2905, 1, 0, 0, 0, 2907, 2906, 1, 0, 0, 0, 2908, 369, 1, 0, 0, 0, 172, 378, 383, 391, 399, 452, 493, 502, 526, 530, 548, 575, 598, 634, 640, 647, 649, 659, 661, 668, 679, 687, 708, 710, 726, 771, 776, 781, 786, 794, 904, 910, 926, 932, 938, 945, 1056, 1061, 1067, 1072, 1074, 1082, 1094, 1106, 1113, 1120, 1122, 1149, 1156, 1164, 1172, 1185, 1192, 1195, 1214, 1308, 1317, 1324, 1327, 1335, 1356, 1388, 1411, 1423, 1432, 1457, 1481, 1489, 1493, 1508, 1515, 1560, 1570, 1586, 1598, 1610, 1624, 1636, 1647, 1654, 1664, 1677, 1682, 1687, 1696, 1707, 1790, 1799, 1812, 1823, 1831, 1841, 1843, 1870, 1877, 1882, 1889, 1895, 1905, 1909, 1916, 1931, 1937, 1951, 1964, 1972, 1979, 1983, 1988, 2004, 2009, 2011, 2024, 2050, 2057, 2059, 2064, 2070, 2099, 2104, 2127, 2132, 2196, 2205, 2218, 2229, 2240, 2243, 2250, 2262, 2276, 2290, 2298, 2318, 2330, 2335, 2344, 2346, 2353, 2363, 2431, 2508, 2515, 2523, 2673, 2677, 2679, 2684, 2686, 2692, 2698, 2704, 2710, 2716, 2722, 2728, 2735, 2740, 2746, 2773, 2787, 2792, 2809, 2816, 2825, 2845, 2850, 2866, 2872, 2880, 2887, 2894, 2907] \ No newline at end of file diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs index 0f956c8e6f6b69..b1fa36806bdf55 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs @@ -572,6 +572,7 @@ public override TResult Accept(IParseTreeVisitor visitor) { public DeclsContext decls() { DeclsContext _localctx = new DeclsContext(Context, State); EnterRule(_localctx, 8, RULE_decls); + BeginStreaming(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -598,6 +599,7 @@ public DeclsContext decls() { ErrorHandler.Recover(this, re); } finally { + EndParseTreeMode(); ExitRule(); } return _localctx; @@ -717,6 +719,7 @@ public override TResult Accept(IParseTreeVisitor visitor) { public DeclContext decl() { DeclContext _localctx = new DeclContext(Context, State); EnterRule(_localctx, 10, RULE_decl); + BeginSubtree(); try { State = 452; ErrorHandler.Sync(this); @@ -940,6 +943,8 @@ public DeclContext decl() { } break; } + Context.Stop = TokenStream.LT(-1); + Actions.OnDeclaration(_localctx); } catch (RecognitionException re) { _localctx.exception = re; @@ -947,6 +952,7 @@ public DeclContext decl() { ErrorHandler.Recover(this, re); } finally { + EndParseTreeMode(); Actions.EndDeclaration(_localctx); ExitRule(); } return _localctx; @@ -2989,6 +2995,7 @@ public override TResult Accept(IParseTreeVisitor visitor) { public NameSpaceHeadContext nameSpaceHead() { NameSpaceHeadContext _localctx = new NameSpaceHeadContext(Context, State); EnterRule(_localctx, 72, RULE_nameSpaceHead); + BeginSubtree(); try { EnterOuterAlt(_localctx, 1); { @@ -2997,6 +3004,8 @@ public NameSpaceHeadContext nameSpaceHead() { State = 720; dottedName(); } + Context.Stop = TokenStream.LT(-1); + Actions.BeginNamespace(_localctx); } catch (RecognitionException re) { _localctx.exception = re; @@ -3004,6 +3013,7 @@ public NameSpaceHeadContext nameSpaceHead() { ErrorHandler.Recover(this, re); } finally { + EndParseTreeMode(); ExitRule(); } return _localctx; @@ -3045,6 +3055,7 @@ public override TResult Accept(IParseTreeVisitor visitor) { public ClassHeadContext classHead() { ClassHeadContext _localctx = new ClassHeadContext(Context, State); EnterRule(_localctx, 74, RULE_classHead); + BeginSubtree(); try { int _alt; EnterOuterAlt(_localctx, 1); @@ -3076,6 +3087,8 @@ public ClassHeadContext classHead() { State = 732; implClause(); } + Context.Stop = TokenStream.LT(-1); + Actions.BeginType(_localctx); } catch (RecognitionException re) { _localctx.exception = re; @@ -3083,6 +3096,7 @@ public ClassHeadContext classHead() { ErrorHandler.Recover(this, re); } finally { + EndParseTreeMode(); ExitRule(); } return _localctx; @@ -3471,6 +3485,7 @@ public override TResult Accept(IParseTreeVisitor visitor) { public ClassDeclsContext classDecls() { ClassDeclsContext _localctx = new ClassDeclsContext(Context, State); EnterRule(_localctx, 82, RULE_classDecls); + BeginStreaming(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -3497,6 +3512,7 @@ public ClassDeclsContext classDecls() { ErrorHandler.Recover(this, re); } finally { + EndParseTreeMode(); ExitRule(); } return _localctx; @@ -9691,6 +9707,7 @@ public override TResult Accept(IParseTreeVisitor visitor) { public ClassDeclContext classDecl() { ClassDeclContext _localctx = new ClassDeclContext(Context, State); EnterRule(_localctx, 220, RULE_classDecl); + BeginSubtree(); try { int _alt; State = 1831; @@ -10034,6 +10051,8 @@ public ClassDeclContext classDecl() { } break; } + Context.Stop = TokenStream.LT(-1); + Actions.OnClassDeclaration(_localctx); } catch (RecognitionException re) { _localctx.exception = re; @@ -10041,6 +10060,7 @@ public ClassDeclContext classDecl() { ErrorHandler.Recover(this, re); } finally { + EndParseTreeMode(); Actions.EndClassDeclaration(_localctx); ExitRule(); } return _localctx; @@ -11655,6 +11675,7 @@ public override TResult Accept(IParseTreeVisitor visitor) { public MethodHeadContext methodHead() { MethodHeadContext _localctx = new MethodHeadContext(Context, State); EnterRule(_localctx, 256, RULE_methodHead); + BeginSubtree(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -11736,6 +11757,8 @@ public MethodHeadContext methodHead() { _la = TokenStream.LA(1); } } + Context.Stop = TokenStream.LT(-1); + Actions.BeginMethod(_localctx); } catch (RecognitionException re) { _localctx.exception = re; @@ -11743,6 +11766,7 @@ public MethodHeadContext methodHead() { ErrorHandler.Recover(this, re); } finally { + EndParseTreeMode(); ExitRule(); } return _localctx; @@ -12457,6 +12481,7 @@ public override TResult Accept(IParseTreeVisitor visitor) { public MethodDeclsContext methodDecls() { MethodDeclsContext _localctx = new MethodDeclsContext(Context, State); EnterRule(_localctx, 268, RULE_methodDecls); + BeginStreaming(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -12483,6 +12508,7 @@ public MethodDeclsContext methodDecls() { ErrorHandler.Recover(this, re); } finally { + EndParseTreeMode(); ExitRule(); } return _localctx; @@ -12588,6 +12614,7 @@ public override TResult Accept(IParseTreeVisitor visitor) { public MethodDeclContext methodDecl() { MethodDeclContext _localctx = new MethodDeclContext(Context, State); EnterRule(_localctx, 270, RULE_methodDecl); + BeginSubtree(); try { int _alt; State = 2243; @@ -12950,6 +12977,8 @@ public MethodDeclContext methodDecl() { } break; } + Context.Stop = TokenStream.LT(-1); + Actions.OnMethodDeclaration(_localctx); } catch (RecognitionException re) { _localctx.exception = re; @@ -12957,6 +12986,7 @@ public MethodDeclContext methodDecl() { ErrorHandler.Recover(this, re); } finally { + EndParseTreeMode(); ExitRule(); } return _localctx; @@ -13079,6 +13109,7 @@ public override TResult Accept(IParseTreeVisitor visitor) { public ScopeBlockContext scopeBlock() { ScopeBlockContext _localctx = new ScopeBlockContext(Context, State); EnterRule(_localctx, 276, RULE_scopeBlock); + Actions.BeginScope(_localctx); try { EnterOuterAlt(_localctx, 1); { @@ -13096,6 +13127,7 @@ public ScopeBlockContext scopeBlock() { ErrorHandler.Recover(this, re); } finally { + Actions.EndScope(_localctx); ExitRule(); } return _localctx; @@ -13133,6 +13165,8 @@ public SehBlockContext sehBlock() { State = 2257; sehClauses(); } + Context.Stop = TokenStream.LT(-1); + Actions.EndExceptionBlock(_localctx); } catch (RecognitionException re) { _localctx.exception = re; @@ -13473,6 +13507,8 @@ public CatchClauseContext catchClause() { State = 2301; typeSpec(); } + Context.Stop = TokenStream.LT(-1); + Actions.OnCatchClause(_localctx); } catch (RecognitionException re) { _localctx.exception = re; @@ -14613,6 +14649,8 @@ public FieldSerInitContext fieldSerInit() { } public partial class BytesContext : ParserRuleContext { + public System.Collections.Immutable.ImmutableArray Value; + public HexbyteContext b; [System.Diagnostics.DebuggerNonUserCode] public HexbyteContext[] hexbyte() { return GetRuleContexts(); } @@ -14636,21 +14674,23 @@ public override TResult Accept(IParseTreeVisitor visitor) { public BytesContext bytes() { BytesContext _localctx = new BytesContext(Context, State); EnterRule(_localctx, 312, RULE_bytes); + BeginStreaming(); Actions.BeginBytes(); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2513; + State = 2515; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32 || _la==ID || _la==HEXBYTE) { { { State = 2510; - hexbyte(); + _localctx.b = hexbyte(); + Actions.AddByte(_localctx.b.Value); } } - State = 2515; + State = 2517; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -14662,12 +14702,14 @@ public BytesContext bytes() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndBytes(); EndParseTreeMode(); ExitRule(); } return _localctx; } public partial class HexbyteContext : ParserRuleContext { + public byte Value; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT32() { return GetToken(CILParser.INT32, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ID() { return GetToken(CILParser.ID, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode HEXBYTE() { return GetToken(CILParser.HEXBYTE, 0); } @@ -14692,7 +14734,7 @@ public HexbyteContext hexbyte() { try { EnterOuterAlt(_localctx, 1); { - State = 2516; + State = 2518; _la = TokenStream.LA(1); if ( !(_la==INT32 || _la==ID || _la==HEXBYTE) ) { ErrorHandler.RecoverInline(this); @@ -14702,6 +14744,8 @@ public HexbyteContext hexbyte() { Consume(); } } + Context.Stop = TokenStream.LT(-1); + _localctx.Value = GrammarActions.ParseHexbyte(_localctx.Start); } catch (RecognitionException re) { _localctx.exception = re; @@ -14740,7 +14784,7 @@ public FieldInitContext fieldInit() { FieldInitContext _localctx = new FieldInitContext(Context, State); EnterRule(_localctx, 316, RULE_fieldInit); try { - State = 2521; + State = 2523; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__83: @@ -14758,21 +14802,21 @@ public FieldInitContext fieldInit() { case UINT64: EnterOuterAlt(_localctx, 1); { - State = 2518; + State = 2520; fieldSerInit(); } break; case QSTRING: EnterOuterAlt(_localctx, 2); { - State = 2519; + State = 2521; compQstring(); } break; case NULLREF: EnterOuterAlt(_localctx, 3); { - State = 2520; + State = 2522; Match(NULLREF); } break; @@ -14869,378 +14913,378 @@ public SerInitContext serInit() { SerInitContext _localctx = new SerInitContext(Context, State); EnterRule(_localctx, 318, RULE_serInit); try { - State = 2671; + State = 2673; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,143,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2523; + State = 2525; fieldSerInit(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2524; + State = 2526; Match(STRING); - State = 2525; + State = 2527; Match(T__29); - State = 2526; + State = 2528; Match(NULLREF); - State = 2527; + State = 2529; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2528; + State = 2530; Match(STRING); - State = 2529; + State = 2531; Match(T__29); - State = 2530; + State = 2532; Match(SQSTRING); - State = 2531; + State = 2533; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2532; + State = 2534; Match(TYPE); - State = 2533; + State = 2535; Match(T__29); - State = 2534; + State = 2536; Match(T__38); - State = 2535; + State = 2537; Match(SQSTRING); - State = 2536; + State = 2538; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2537; + State = 2539; Match(TYPE); - State = 2538; + State = 2540; Match(T__29); - State = 2539; + State = 2541; className(); - State = 2540; + State = 2542; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2542; + State = 2544; Match(TYPE); - State = 2543; + State = 2545; Match(T__29); - State = 2544; + State = 2546; Match(NULLREF); - State = 2545; + State = 2547; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2546; + State = 2548; Match(OBJECT); - State = 2547; + State = 2549; Match(T__29); - State = 2548; + State = 2550; serInit(); - State = 2549; + State = 2551; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2551; + State = 2553; Match(FLOAT32); - State = 2552; + State = 2554; Match(T__41); - State = 2553; + State = 2555; int32(); - State = 2554; + State = 2556; Match(T__42); - State = 2555; + State = 2557; Match(T__29); - State = 2556; + State = 2558; f32seq(); - State = 2557; + State = 2559; Match(T__30); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2559; + State = 2561; Match(FLOAT64_); - State = 2560; + State = 2562; Match(T__41); - State = 2561; + State = 2563; int32(); - State = 2562; + State = 2564; Match(T__42); - State = 2563; + State = 2565; Match(T__29); - State = 2564; + State = 2566; f64seq(); - State = 2565; + State = 2567; Match(T__30); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2567; + State = 2569; Match(INT64_); - State = 2568; + State = 2570; Match(T__41); - State = 2569; + State = 2571; int32(); - State = 2570; + State = 2572; Match(T__42); - State = 2571; + State = 2573; Match(T__29); - State = 2572; + State = 2574; i64seq(); - State = 2573; + State = 2575; Match(T__30); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2575; + State = 2577; Match(INT32_); - State = 2576; + State = 2578; Match(T__41); - State = 2577; + State = 2579; int32(); - State = 2578; + State = 2580; Match(T__42); - State = 2579; + State = 2581; Match(T__29); - State = 2580; + State = 2582; i32seq(); - State = 2581; + State = 2583; Match(T__30); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2583; + State = 2585; Match(INT16); - State = 2584; + State = 2586; Match(T__41); - State = 2585; + State = 2587; int32(); - State = 2586; + State = 2588; Match(T__42); - State = 2587; + State = 2589; Match(T__29); - State = 2588; + State = 2590; i16seq(); - State = 2589; + State = 2591; Match(T__30); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2591; + State = 2593; Match(INT8); - State = 2592; + State = 2594; Match(T__41); - State = 2593; + State = 2595; int32(); - State = 2594; + State = 2596; Match(T__42); - State = 2595; + State = 2597; Match(T__29); - State = 2596; + State = 2598; i8seq(); - State = 2597; + State = 2599; Match(T__30); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2599; + State = 2601; Match(UINT64); - State = 2600; + State = 2602; Match(T__41); - State = 2601; + State = 2603; int32(); - State = 2602; + State = 2604; Match(T__42); - State = 2603; + State = 2605; Match(T__29); - State = 2604; + State = 2606; i64seq(); - State = 2605; + State = 2607; Match(T__30); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2607; + State = 2609; Match(UINT32); - State = 2608; + State = 2610; Match(T__41); - State = 2609; + State = 2611; int32(); - State = 2610; + State = 2612; Match(T__42); - State = 2611; + State = 2613; Match(T__29); - State = 2612; + State = 2614; i32seq(); - State = 2613; + State = 2615; Match(T__30); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 2615; + State = 2617; Match(UINT16); - State = 2616; + State = 2618; Match(T__41); - State = 2617; + State = 2619; int32(); - State = 2618; + State = 2620; Match(T__42); - State = 2619; + State = 2621; Match(T__29); - State = 2620; + State = 2622; i16seq(); - State = 2621; + State = 2623; Match(T__30); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 2623; + State = 2625; Match(UINT8); - State = 2624; + State = 2626; Match(T__41); - State = 2625; + State = 2627; int32(); - State = 2626; + State = 2628; Match(T__42); - State = 2627; + State = 2629; Match(T__29); - State = 2628; + State = 2630; i8seq(); - State = 2629; + State = 2631; Match(T__30); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 2631; + State = 2633; Match(CHAR); - State = 2632; + State = 2634; Match(T__41); - State = 2633; + State = 2635; int32(); - State = 2634; + State = 2636; Match(T__42); - State = 2635; + State = 2637; Match(T__29); - State = 2636; + State = 2638; i16seq(); - State = 2637; + State = 2639; Match(T__30); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 2639; + State = 2641; Match(BOOL); - State = 2640; + State = 2642; Match(T__41); - State = 2641; + State = 2643; int32(); - State = 2642; + State = 2644; Match(T__42); - State = 2643; + State = 2645; Match(T__29); - State = 2644; + State = 2646; boolSeq(); - State = 2645; + State = 2647; Match(T__30); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 2647; + State = 2649; Match(STRING); - State = 2648; + State = 2650; Match(T__41); - State = 2649; + State = 2651; int32(); - State = 2650; + State = 2652; Match(T__42); - State = 2651; + State = 2653; Match(T__29); - State = 2652; + State = 2654; sqstringSeq(); - State = 2653; + State = 2655; Match(T__30); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 2655; + State = 2657; Match(TYPE); - State = 2656; + State = 2658; Match(T__41); - State = 2657; + State = 2659; int32(); - State = 2658; + State = 2660; Match(T__42); - State = 2659; + State = 2661; Match(T__29); - State = 2660; + State = 2662; classSeq(); - State = 2661; + State = 2663; Match(T__30); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 2663; + State = 2665; Match(OBJECT); - State = 2664; + State = 2666; Match(T__41); - State = 2665; + State = 2667; int32(); - State = 2666; + State = 2668; Match(T__42); - State = 2667; + State = 2669; Match(T__29); - State = 2668; + State = 2670; objSeq(); - State = 2669; + State = 2671; Match(T__30); } break; @@ -15291,29 +15335,29 @@ public F32seqContext f32seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2677; + State = 2679; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 98309L) != 0)) { { - State = 2675; + State = 2677; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,144,Context) ) { case 1: { - State = 2673; + State = 2675; float64(); } break; case 2: { - State = 2674; + State = 2676; int32(); } break; } } - State = 2679; + State = 2681; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15364,29 +15408,29 @@ public F64seqContext f64seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2684; + State = 2686; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 98311L) != 0)) { { - State = 2682; + State = 2684; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,146,Context) ) { case 1: { - State = 2680; + State = 2682; float64(); } break; case 2: { - State = 2681; + State = 2683; int64(); } break; } } - State = 2686; + State = 2688; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15431,17 +15475,17 @@ public I64seqContext i64seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2690; + State = 2692; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32 || _la==INT64) { { { - State = 2687; + State = 2689; int64(); } } - State = 2692; + State = 2694; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15486,17 +15530,17 @@ public I32seqContext i32seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2696; + State = 2698; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 2693; + State = 2695; int32(); } } - State = 2698; + State = 2700; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15541,17 +15585,17 @@ public I16seqContext i16seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2702; + State = 2704; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 2699; + State = 2701; int32(); } } - State = 2704; + State = 2706; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15596,17 +15640,17 @@ public I8seqContext i8seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2708; + State = 2710; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 2705; + State = 2707; int32(); } } - State = 2710; + State = 2712; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15651,17 +15695,17 @@ public BoolSeqContext boolSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 2714; + State = 2716; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__94 || _la==T__95) { { { - State = 2711; + State = 2713; truefalse(); } } - State = 2716; + State = 2718; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15708,13 +15752,13 @@ public SqstringSeqContext sqstringSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 2720; + State = 2722; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==NULLREF || _la==SQSTRING) { { { - State = 2717; + State = 2719; _la = TokenStream.LA(1); if ( !(_la==NULLREF || _la==SQSTRING) ) { ErrorHandler.RecoverInline(this); @@ -15725,7 +15769,7 @@ public SqstringSeqContext sqstringSeq() { } } } - State = 2722; + State = 2724; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15770,17 +15814,17 @@ public ClassSeqContext classSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 2726; + State = 2728; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4947802390528L) != 0) || _la==T__112 || _la==NULLREF || _la==VALUE || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 105553118478337L) != 0)) { { { - State = 2723; + State = 2725; classSeqElement(); } } - State = 2728; + State = 2730; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15821,22 +15865,22 @@ public ClassSeqElementContext classSeqElement() { ClassSeqElementContext _localctx = new ClassSeqElementContext(Context, State); EnterRule(_localctx, 338, RULE_classSeqElement); try { - State = 2733; + State = 2735; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case NULLREF: EnterOuterAlt(_localctx, 1); { - State = 2729; + State = 2731; Match(NULLREF); } break; case T__38: EnterOuterAlt(_localctx, 2); { - State = 2730; + State = 2732; Match(T__38); - State = 2731; + State = 2733; Match(SQSTRING); } break; @@ -15853,7 +15897,7 @@ public ClassSeqElementContext classSeqElement() { case ID: EnterOuterAlt(_localctx, 3); { - State = 2732; + State = 2734; className(); } break; @@ -15900,17 +15944,17 @@ public ObjSeqContext objSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 2738; + State = 2740; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__83 || ((((_la - 181)) & ~0x3f) == 0 && ((1L << (_la - 181)) & 106495L) != 0)) { { { - State = 2735; + State = 2737; serInit(); } } - State = 2740; + State = 2742; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15955,27 +15999,27 @@ public CustomAttrDeclContext customAttrDecl() { CustomAttrDeclContext _localctx = new CustomAttrDeclContext(Context, State); EnterRule(_localctx, 342, RULE_customAttrDecl); try { - State = 2744; + State = 2746; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,157,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2741; + State = 2743; customDescr(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2742; + State = 2744; customDescrWithOwner(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2743; + State = 2745; dottedName(); } break; @@ -16030,13 +16074,13 @@ public AsmOrRefDeclContext asmOrRefDecl() { EnterRule(_localctx, 344, RULE_asmOrRefDecl); int _la; try { - State = 2771; + State = 2773; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,158,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2746; + State = 2748; _la = TokenStream.LA(1); if ( !(_la==T__166 || _la==T__167) ) { ErrorHandler.RecoverInline(this); @@ -16045,25 +16089,21 @@ public AsmOrRefDeclContext asmOrRefDecl() { ErrorHandler.ReportMatch(this); Consume(); } - State = 2747; + State = 2749; Match(T__35); - State = 2748; + State = 2750; Match(T__29); - State = 2749; + State = 2751; bytes(); - State = 2750; + State = 2752; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2752; - Match(T__168); - State = 2753; - intOrWildcard(); State = 2754; - Match(T__74); + Match(T__168); State = 2755; intOrWildcard(); State = 2756; @@ -16074,43 +16114,47 @@ public AsmOrRefDeclContext asmOrRefDecl() { Match(T__74); State = 2759; intOrWildcard(); + State = 2760; + Match(T__74); + State = 2761; + intOrWildcard(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2761; + State = 2763; Match(T__169); - State = 2762; + State = 2764; compQstring(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2763; + State = 2765; Match(T__169); - State = 2764; + State = 2766; Match(T__35); - State = 2765; + State = 2767; Match(T__29); - State = 2766; + State = 2768; bytes(); - State = 2767; + State = 2769; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2769; + State = 2771; customAttrDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2770; + State = 2772; compControl(); } break; @@ -16155,36 +16199,36 @@ public AssemblyRefHeadContext assemblyRefHead() { AssemblyRefHeadContext _localctx = new AssemblyRefHeadContext(Context, State); EnterRule(_localctx, 346, RULE_assemblyRefHead); try { - State = 2785; + State = 2787; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,159,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2773; + State = 2775; Match(T__24); - State = 2774; + State = 2776; Match(T__39); - State = 2775; + State = 2777; asmAttr(); - State = 2776; + State = 2778; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2778; + State = 2780; Match(T__24); - State = 2779; + State = 2781; Match(T__39); - State = 2780; + State = 2782; asmAttr(); - State = 2781; + State = 2783; dottedName(); - State = 2782; + State = 2784; Match(T__33); - State = 2783; + State = 2785; dottedName(); } break; @@ -16229,17 +16273,17 @@ public AssemblyRefDeclsContext assemblyRefDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2790; + State = 2792; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 36028835673735168L) != 0) || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & 4294975519L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 105555249070081L) != 0)) { { { - State = 2787; + State = 2789; assemblyRefDecl(); } } - State = 2792; + State = 2794; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16282,21 +16326,21 @@ public AssemblyRefDeclContext assemblyRefDecl() { AssemblyRefDeclContext _localctx = new AssemblyRefDeclContext(Context, State); EnterRule(_localctx, 350, RULE_assemblyRefDecl); try { - State = 2807; + State = 2809; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case HASH: EnterOuterAlt(_localctx, 1); { - State = 2793; + State = 2795; Match(HASH); - State = 2794; + State = 2796; Match(T__35); - State = 2795; + State = 2797; Match(T__29); - State = 2796; + State = 2798; bytes(); - State = 2797; + State = 2799; Match(T__30); } break; @@ -16321,29 +16365,29 @@ public AssemblyRefDeclContext assemblyRefDecl() { case ID: EnterOuterAlt(_localctx, 2); { - State = 2799; + State = 2801; asmOrRefDecl(); } break; case T__170: EnterOuterAlt(_localctx, 3); { - State = 2800; + State = 2802; Match(T__170); - State = 2801; + State = 2803; Match(T__35); - State = 2802; + State = 2804; Match(T__29); - State = 2803; + State = 2805; bytes(); - State = 2804; + State = 2806; Match(T__30); } break; case T__54: EnterOuterAlt(_localctx, 4); { - State = 2806; + State = 2808; Match(T__54); } break; @@ -16393,25 +16437,25 @@ public ExptypeHeadContext exptypeHead() { try { EnterOuterAlt(_localctx, 1); { - State = 2809; + State = 2811; Match(T__49); - State = 2810; + State = 2812; Match(T__39); - State = 2814; + State = 2816; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4618441417868443648L) != 0) || _la==T__171) { { { - State = 2811; + State = 2813; exptAttr(); } } - State = 2816; + State = 2818; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2817; + State = 2819; dottedName(); } } @@ -16458,23 +16502,23 @@ public ExportHeadContext exportHead() { try { EnterOuterAlt(_localctx, 1); { - State = 2819; + State = 2821; Match(EXPORT); - State = 2823; + State = 2825; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4618441417868443648L) != 0) || _la==T__171) { { { - State = 2820; + State = 2822; exptAttr(); } } - State = 2825; + State = 2827; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2826; + State = 2828; dottedName(); } } @@ -16508,81 +16552,81 @@ public ExptAttrContext exptAttr() { ExptAttrContext _localctx = new ExptAttrContext(Context, State); EnterRule(_localctx, 356, RULE_exptAttr); try { - State = 2843; + State = 2845; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,164,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2828; + State = 2830; Match(T__51); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2829; + State = 2831; Match(T__50); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2830; + State = 2832; Match(T__171); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2831; + State = 2833; Match(T__61); - State = 2832; + State = 2834; Match(T__50); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2833; + State = 2835; Match(T__61); - State = 2834; + State = 2836; Match(T__51); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2835; + State = 2837; Match(T__61); - State = 2836; + State = 2838; Match(T__62); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2837; + State = 2839; Match(T__61); - State = 2838; + State = 2840; Match(T__63); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2839; + State = 2841; Match(T__61); - State = 2840; + State = 2842; Match(T__64); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2841; + State = 2843; Match(T__61); - State = 2842; + State = 2844; Match(T__65); } break; @@ -16627,17 +16671,17 @@ public ExptypeDeclsContext exptypeDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2848; + State = 2850; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1125938597265408L) != 0) || _la==T__112 || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 2845; + State = 2847; exptypeDecl(); } } - State = 2850; + State = 2852; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16691,67 +16735,67 @@ public ExptypeDeclContext exptypeDecl() { ExptypeDeclContext _localctx = new ExptypeDeclContext(Context, State); EnterRule(_localctx, 360, RULE_exptypeDecl); try { - State = 2864; + State = 2866; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,166,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2851; + State = 2853; Match(T__20); - State = 2852; + State = 2854; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2853; + State = 2855; Match(T__49); - State = 2854; + State = 2856; Match(T__39); - State = 2855; + State = 2857; slashedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2856; + State = 2858; Match(T__24); - State = 2857; + State = 2859; Match(T__39); - State = 2858; + State = 2860; dottedName(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2859; + State = 2861; mdtoken(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2860; + State = 2862; Match(T__49); - State = 2861; + State = 2863; int32(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2862; + State = 2864; customAttrDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2863; + State = 2865; compControl(); } break; @@ -16801,56 +16845,56 @@ public ManifestResHeadContext manifestResHead() { EnterRule(_localctx, 362, RULE_manifestResHead); int _la; try { - State = 2885; + State = 2887; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,169,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2866; + State = 2868; Match(MRESOURCE); - State = 2870; + State = 2872; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__50 || _la==T__51) { { { - State = 2867; + State = 2869; manresAttr(); } } - State = 2872; + State = 2874; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2873; + State = 2875; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2874; + State = 2876; Match(MRESOURCE); - State = 2878; + State = 2880; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__50 || _la==T__51) { { { - State = 2875; + State = 2877; manresAttr(); } } - State = 2880; + State = 2882; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2881; + State = 2883; dottedName(); - State = 2882; + State = 2884; Match(T__33); - State = 2883; + State = 2885; dottedName(); } break; @@ -16889,7 +16933,7 @@ public ManresAttrContext manresAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 2887; + State = 2889; _la = TokenStream.LA(1); if ( !(_la==T__50 || _la==T__51) ) { ErrorHandler.RecoverInline(this); @@ -16939,17 +16983,17 @@ public ManifestResDeclsContext manifestResDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2892; + State = 2894; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38690422784L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 2889; + State = 2891; manifestResDecl(); } } - State = 2894; + State = 2896; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16997,30 +17041,30 @@ public ManifestResDeclContext manifestResDecl() { ManifestResDeclContext _localctx = new ManifestResDeclContext(Context, State); EnterRule(_localctx, 368, RULE_manifestResDecl); try { - State = 2905; + State = 2907; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__20: EnterOuterAlt(_localctx, 1); { - State = 2895; + State = 2897; Match(T__20); - State = 2896; + State = 2898; dottedName(); - State = 2897; + State = 2899; Match(T__43); - State = 2898; + State = 2900; int32(); } break; case T__24: EnterOuterAlt(_localctx, 2); { - State = 2900; + State = 2902; Match(T__24); - State = 2901; + State = 2903; Match(T__39); - State = 2902; + State = 2904; dottedName(); } break; @@ -17033,7 +17077,7 @@ public ManifestResDeclContext manifestResDecl() { case ID: EnterOuterAlt(_localctx, 3); { - State = 2903; + State = 2905; customAttrDecl(); } break; @@ -17047,7 +17091,7 @@ public ManifestResDeclContext manifestResDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 4); { - State = 2904; + State = 2906; compControl(); } break; @@ -17084,7 +17128,7 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { } private static int[] _serializedATN = { - 4,1,305,2908,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, + 4,1,305,2910,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, @@ -17288,8 +17332,8 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155, 1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155, 1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,3,155,2509, - 8,155,1,156,5,156,2512,8,156,10,156,12,156,2515,9,156,1,157,1,157,1,158, - 1,158,1,158,3,158,2522,8,158,1,159,1,159,1,159,1,159,1,159,1,159,1,159, + 8,155,1,156,1,156,1,156,5,156,2514,8,156,10,156,12,156,2517,9,156,1,157, + 1,157,1,158,1,158,1,158,3,158,2524,8,158,1,159,1,159,1,159,1,159,1,159, 1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159, 1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159, 1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159, @@ -17301,406 +17345,406 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159, 1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159, 1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159, - 1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,3,159,2672,8,159, - 1,160,1,160,5,160,2676,8,160,10,160,12,160,2679,9,160,1,161,1,161,5,161, - 2683,8,161,10,161,12,161,2686,9,161,1,162,5,162,2689,8,162,10,162,12,162, - 2692,9,162,1,163,5,163,2695,8,163,10,163,12,163,2698,9,163,1,164,5,164, - 2701,8,164,10,164,12,164,2704,9,164,1,165,5,165,2707,8,165,10,165,12,165, - 2710,9,165,1,166,5,166,2713,8,166,10,166,12,166,2716,9,166,1,167,5,167, - 2719,8,167,10,167,12,167,2722,9,167,1,168,5,168,2725,8,168,10,168,12,168, - 2728,9,168,1,169,1,169,1,169,1,169,3,169,2734,8,169,1,170,5,170,2737,8, - 170,10,170,12,170,2740,9,170,1,171,1,171,1,171,3,171,2745,8,171,1,172, - 1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172, + 1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,3,159, + 2674,8,159,1,160,1,160,5,160,2678,8,160,10,160,12,160,2681,9,160,1,161, + 1,161,5,161,2685,8,161,10,161,12,161,2688,9,161,1,162,5,162,2691,8,162, + 10,162,12,162,2694,9,162,1,163,5,163,2697,8,163,10,163,12,163,2700,9,163, + 1,164,5,164,2703,8,164,10,164,12,164,2706,9,164,1,165,5,165,2709,8,165, + 10,165,12,165,2712,9,165,1,166,5,166,2715,8,166,10,166,12,166,2718,9,166, + 1,167,5,167,2721,8,167,10,167,12,167,2724,9,167,1,168,5,168,2727,8,168, + 10,168,12,168,2730,9,168,1,169,1,169,1,169,1,169,3,169,2736,8,169,1,170, + 5,170,2739,8,170,10,170,12,170,2742,9,170,1,171,1,171,1,171,3,171,2747, + 8,171,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172, 1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172, - 3,172,2772,8,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,3,173,2786,8,173,1,174,5,174,2789,8,174,10,174,12,174, - 2792,9,174,1,175,1,175,1,175,1,175,1,175,1,175,1,175,1,175,1,175,1,175, - 1,175,1,175,1,175,1,175,3,175,2808,8,175,1,176,1,176,1,176,5,176,2813, - 8,176,10,176,12,176,2816,9,176,1,176,1,176,1,177,1,177,5,177,2822,8,177, - 10,177,12,177,2825,9,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,178,1,178,1,178,1,178,3,178,2844,8,178, - 1,179,5,179,2847,8,179,10,179,12,179,2850,9,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,3,180,2865,8,180, - 1,181,1,181,5,181,2869,8,181,10,181,12,181,2872,9,181,1,181,1,181,1,181, - 5,181,2877,8,181,10,181,12,181,2880,9,181,1,181,1,181,1,181,1,181,3,181, - 2886,8,181,1,182,1,182,1,183,5,183,2891,8,183,10,183,12,183,2894,9,183, - 1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,3,184,2906, - 8,184,1,184,0,1,68,185,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,0,16,6,0,1, - 15,199,199,243,243,247,247,264,264,289,289,5,0,16,16,199,199,243,243,264, - 264,288,289,1,0,263,264,1,0,173,174,1,0,37,38,1,0,73,74,3,0,2,2,61,61, - 77,83,2,0,229,229,260,261,9,0,178,178,183,195,201,201,207,208,210,215, - 218,219,222,222,230,242,262,262,1,0,95,96,1,0,97,111,1,0,68,69,2,0,173, - 173,289,290,2,0,179,179,264,264,1,0,167,168,1,0,51,52,3325,0,370,1,0,0, - 0,2,383,1,0,0,0,4,385,1,0,0,0,6,391,1,0,0,0,8,399,1,0,0,0,10,452,1,0,0, - 0,12,454,1,0,0,0,14,457,1,0,0,0,16,460,1,0,0,0,18,464,1,0,0,0,20,467,1, - 0,0,0,22,470,1,0,0,0,24,477,1,0,0,0,26,493,1,0,0,0,28,495,1,0,0,0,30,497, - 1,0,0,0,32,507,1,0,0,0,34,509,1,0,0,0,36,526,1,0,0,0,38,530,1,0,0,0,40, - 548,1,0,0,0,42,575,1,0,0,0,44,598,1,0,0,0,46,634,1,0,0,0,48,636,1,0,0, - 0,50,640,1,0,0,0,52,642,1,0,0,0,54,649,1,0,0,0,56,661,1,0,0,0,58,664,1, - 0,0,0,60,666,1,0,0,0,62,679,1,0,0,0,64,687,1,0,0,0,66,689,1,0,0,0,68,697, - 1,0,0,0,70,713,1,0,0,0,72,719,1,0,0,0,74,722,1,0,0,0,76,771,1,0,0,0,78, - 776,1,0,0,0,80,781,1,0,0,0,82,786,1,0,0,0,84,794,1,0,0,0,86,799,1,0,0, - 0,88,904,1,0,0,0,90,932,1,0,0,0,92,934,1,0,0,0,94,938,1,0,0,0,96,940,1, - 0,0,0,98,945,1,0,0,0,100,948,1,0,0,0,102,950,1,0,0,0,104,952,1,0,0,0,106, - 954,1,0,0,0,108,956,1,0,0,0,110,958,1,0,0,0,112,960,1,0,0,0,114,962,1, - 0,0,0,116,964,1,0,0,0,118,966,1,0,0,0,120,968,1,0,0,0,122,970,1,0,0,0, - 124,972,1,0,0,0,126,1056,1,0,0,0,128,1074,1,0,0,0,130,1076,1,0,0,0,132, - 1088,1,0,0,0,134,1113,1,0,0,0,136,1122,1,0,0,0,138,1149,1,0,0,0,140,1156, - 1,0,0,0,142,1164,1,0,0,0,144,1172,1,0,0,0,146,1185,1,0,0,0,148,1195,1, - 0,0,0,150,1214,1,0,0,0,152,1308,1,0,0,0,154,1317,1,0,0,0,156,1327,1,0, - 0,0,158,1329,1,0,0,0,160,1331,1,0,0,0,162,1356,1,0,0,0,164,1388,1,0,0, - 0,166,1411,1,0,0,0,168,1423,1,0,0,0,170,1425,1,0,0,0,172,1428,1,0,0,0, - 174,1481,1,0,0,0,176,1493,1,0,0,0,178,1508,1,0,0,0,180,1515,1,0,0,0,182, - 1520,1,0,0,0,184,1524,1,0,0,0,186,1560,1,0,0,0,188,1562,1,0,0,0,190,1598, - 1,0,0,0,192,1610,1,0,0,0,194,1624,1,0,0,0,196,1626,1,0,0,0,198,1636,1, - 0,0,0,200,1647,1,0,0,0,202,1654,1,0,0,0,204,1664,1,0,0,0,206,1677,1,0, - 0,0,208,1682,1,0,0,0,210,1685,1,0,0,0,212,1696,1,0,0,0,214,1701,1,0,0, - 0,216,1707,1,0,0,0,218,1709,1,0,0,0,220,1831,1,0,0,0,222,1833,1,0,0,0, - 224,1870,1,0,0,0,226,1877,1,0,0,0,228,1882,1,0,0,0,230,1889,1,0,0,0,232, - 1909,1,0,0,0,234,1911,1,0,0,0,236,1916,1,0,0,0,238,1931,1,0,0,0,240,1933, - 1,0,0,0,242,1946,1,0,0,0,244,1951,1,0,0,0,246,1964,1,0,0,0,248,1972,1, - 0,0,0,250,1983,1,0,0,0,252,1988,1,0,0,0,254,2004,1,0,0,0,256,2006,1,0, - 0,0,258,2050,1,0,0,0,260,2070,1,0,0,0,262,2099,1,0,0,0,264,2104,1,0,0, - 0,266,2127,1,0,0,0,268,2132,1,0,0,0,270,2243,1,0,0,0,272,2245,1,0,0,0, - 274,2250,1,0,0,0,276,2252,1,0,0,0,278,2256,1,0,0,0,280,2260,1,0,0,0,282, - 2276,1,0,0,0,284,2290,1,0,0,0,286,2298,1,0,0,0,288,2300,1,0,0,0,290,2303, - 1,0,0,0,292,2305,1,0,0,0,294,2318,1,0,0,0,296,2320,1,0,0,0,298,2330,1, - 0,0,0,300,2335,1,0,0,0,302,2346,1,0,0,0,304,2353,1,0,0,0,306,2363,1,0, - 0,0,308,2431,1,0,0,0,310,2508,1,0,0,0,312,2513,1,0,0,0,314,2516,1,0,0, - 0,316,2521,1,0,0,0,318,2671,1,0,0,0,320,2677,1,0,0,0,322,2684,1,0,0,0, - 324,2690,1,0,0,0,326,2696,1,0,0,0,328,2702,1,0,0,0,330,2708,1,0,0,0,332, - 2714,1,0,0,0,334,2720,1,0,0,0,336,2726,1,0,0,0,338,2733,1,0,0,0,340,2738, - 1,0,0,0,342,2744,1,0,0,0,344,2771,1,0,0,0,346,2785,1,0,0,0,348,2790,1, - 0,0,0,350,2807,1,0,0,0,352,2809,1,0,0,0,354,2819,1,0,0,0,356,2843,1,0, - 0,0,358,2848,1,0,0,0,360,2864,1,0,0,0,362,2885,1,0,0,0,364,2887,1,0,0, - 0,366,2892,1,0,0,0,368,2905,1,0,0,0,370,371,7,0,0,0,371,1,1,0,0,0,372, - 384,5,288,0,0,373,374,3,4,2,0,374,375,5,265,0,0,375,377,1,0,0,0,376,373, - 1,0,0,0,377,380,1,0,0,0,378,376,1,0,0,0,378,379,1,0,0,0,379,381,1,0,0, - 0,380,378,1,0,0,0,381,384,3,4,2,0,382,384,5,264,0,0,383,372,1,0,0,0,383, - 378,1,0,0,0,383,382,1,0,0,0,384,3,1,0,0,0,385,386,7,1,0,0,386,5,1,0,0, - 0,387,388,5,263,0,0,388,390,5,266,0,0,389,387,1,0,0,0,390,393,1,0,0,0, - 391,389,1,0,0,0,391,392,1,0,0,0,392,394,1,0,0,0,393,391,1,0,0,0,394,395, - 5,263,0,0,395,7,1,0,0,0,396,398,3,10,5,0,397,396,1,0,0,0,398,401,1,0,0, - 0,399,397,1,0,0,0,399,400,1,0,0,0,400,9,1,0,0,0,401,399,1,0,0,0,402,403, - 3,74,37,0,403,404,5,17,0,0,404,405,3,82,41,0,405,406,5,18,0,0,406,453, - 1,0,0,0,407,408,3,72,36,0,408,409,5,17,0,0,409,410,3,8,4,0,410,411,5,18, - 0,0,411,453,1,0,0,0,412,413,3,256,128,0,413,414,5,17,0,0,414,415,3,268, - 134,0,415,416,5,18,0,0,416,453,1,0,0,0,417,453,3,222,111,0,418,453,3,296, - 148,0,419,453,3,70,35,0,420,453,3,66,33,0,421,453,3,88,44,0,422,453,3, - 90,45,0,423,453,3,22,11,0,424,425,3,346,173,0,425,426,5,17,0,0,426,427, - 3,348,174,0,427,428,5,18,0,0,428,453,1,0,0,0,429,430,3,352,176,0,430,431, - 5,17,0,0,431,432,3,358,179,0,432,433,5,18,0,0,433,453,1,0,0,0,434,435, - 3,362,181,0,435,436,5,17,0,0,436,437,3,366,183,0,437,438,5,18,0,0,438, - 453,1,0,0,0,439,453,3,64,32,0,440,453,3,174,87,0,441,453,3,342,171,0,442, - 453,3,12,6,0,443,453,3,14,7,0,444,453,3,16,8,0,445,453,3,18,9,0,446,453, - 3,20,10,0,447,453,3,26,13,0,448,453,3,42,21,0,449,453,3,40,20,0,450,453, - 3,30,15,0,451,453,3,24,12,0,452,402,1,0,0,0,452,407,1,0,0,0,452,412,1, - 0,0,0,452,417,1,0,0,0,452,418,1,0,0,0,452,419,1,0,0,0,452,420,1,0,0,0, - 452,421,1,0,0,0,452,422,1,0,0,0,452,423,1,0,0,0,452,424,1,0,0,0,452,429, - 1,0,0,0,452,434,1,0,0,0,452,439,1,0,0,0,452,440,1,0,0,0,452,441,1,0,0, - 0,452,442,1,0,0,0,452,443,1,0,0,0,452,444,1,0,0,0,452,445,1,0,0,0,452, - 446,1,0,0,0,452,447,1,0,0,0,452,448,1,0,0,0,452,449,1,0,0,0,452,450,1, - 0,0,0,452,451,1,0,0,0,453,11,1,0,0,0,454,455,5,19,0,0,455,456,3,32,16, - 0,456,13,1,0,0,0,457,458,5,20,0,0,458,459,3,32,16,0,459,15,1,0,0,0,460, - 461,5,21,0,0,461,462,5,22,0,0,462,463,3,32,16,0,463,17,1,0,0,0,464,465, - 5,23,0,0,465,466,3,34,17,0,466,19,1,0,0,0,467,468,5,24,0,0,468,469,3,34, - 17,0,469,21,1,0,0,0,470,471,5,25,0,0,471,472,3,98,49,0,472,473,3,2,1,0, - 473,474,5,17,0,0,474,475,3,142,71,0,475,476,5,18,0,0,476,23,1,0,0,0,477, - 478,5,26,0,0,478,25,1,0,0,0,479,480,5,27,0,0,480,494,3,28,14,0,481,482, - 5,27,0,0,482,483,3,28,14,0,483,484,5,28,0,0,484,485,3,28,14,0,485,494, - 1,0,0,0,486,487,5,27,0,0,487,488,3,28,14,0,488,489,5,28,0,0,489,490,3, - 28,14,0,490,491,5,28,0,0,491,492,3,28,14,0,492,494,1,0,0,0,493,479,1,0, - 0,0,493,481,1,0,0,0,493,486,1,0,0,0,494,27,1,0,0,0,495,496,7,2,0,0,496, - 29,1,0,0,0,497,498,5,29,0,0,498,502,5,17,0,0,499,501,3,138,69,0,500,499, - 1,0,0,0,501,504,1,0,0,0,502,500,1,0,0,0,502,503,1,0,0,0,503,505,1,0,0, - 0,504,502,1,0,0,0,505,506,5,18,0,0,506,31,1,0,0,0,507,508,5,173,0,0,508, - 33,1,0,0,0,509,510,7,3,0,0,510,35,1,0,0,0,511,527,5,175,0,0,512,513,3, - 32,16,0,513,514,5,265,0,0,514,527,1,0,0,0,515,527,3,32,16,0,516,517,5, - 188,0,0,517,518,5,30,0,0,518,519,3,32,16,0,519,520,5,31,0,0,520,527,1, - 0,0,0,521,522,5,189,0,0,522,523,5,30,0,0,523,524,3,34,17,0,524,525,5,31, - 0,0,525,527,1,0,0,0,526,511,1,0,0,0,526,512,1,0,0,0,526,515,1,0,0,0,526, - 516,1,0,0,0,526,521,1,0,0,0,527,37,1,0,0,0,528,531,3,32,16,0,529,531,5, - 262,0,0,530,528,1,0,0,0,530,529,1,0,0,0,531,39,1,0,0,0,532,533,5,267,0, - 0,533,549,5,289,0,0,534,535,5,267,0,0,535,536,5,289,0,0,536,549,5,263, - 0,0,537,538,5,268,0,0,538,549,5,289,0,0,539,540,5,269,0,0,540,549,5,289, - 0,0,541,542,5,270,0,0,542,549,5,289,0,0,543,549,5,271,0,0,544,549,5,272, - 0,0,545,546,5,273,0,0,546,549,5,263,0,0,547,549,5,32,0,0,548,532,1,0,0, - 0,548,534,1,0,0,0,548,537,1,0,0,0,548,539,1,0,0,0,548,541,1,0,0,0,548, - 543,1,0,0,0,548,544,1,0,0,0,548,545,1,0,0,0,548,547,1,0,0,0,549,41,1,0, - 0,0,550,551,5,33,0,0,551,552,3,160,80,0,552,553,5,34,0,0,553,554,3,2,1, - 0,554,576,1,0,0,0,555,556,5,33,0,0,556,557,3,138,69,0,557,558,5,34,0,0, - 558,559,3,2,1,0,559,576,1,0,0,0,560,561,5,33,0,0,561,562,3,198,99,0,562, - 563,5,34,0,0,563,564,3,2,1,0,564,576,1,0,0,0,565,566,5,33,0,0,566,567, - 3,44,22,0,567,568,5,34,0,0,568,569,3,2,1,0,569,576,1,0,0,0,570,571,5,33, - 0,0,571,572,3,46,23,0,572,573,5,34,0,0,573,574,3,2,1,0,574,576,1,0,0,0, - 575,550,1,0,0,0,575,555,1,0,0,0,575,560,1,0,0,0,575,565,1,0,0,0,575,570, - 1,0,0,0,576,43,1,0,0,0,577,578,5,35,0,0,578,599,3,48,24,0,579,580,5,35, - 0,0,580,581,3,48,24,0,581,582,5,36,0,0,582,583,3,6,3,0,583,599,1,0,0,0, - 584,585,5,35,0,0,585,586,3,48,24,0,586,587,5,36,0,0,587,588,5,17,0,0,588, - 589,3,52,26,0,589,590,5,18,0,0,590,599,1,0,0,0,591,592,5,35,0,0,592,593, - 3,48,24,0,593,594,5,36,0,0,594,595,5,30,0,0,595,596,3,312,156,0,596,597, - 5,31,0,0,597,599,1,0,0,0,598,577,1,0,0,0,598,579,1,0,0,0,598,584,1,0,0, - 0,598,591,1,0,0,0,599,45,1,0,0,0,600,601,5,35,0,0,601,602,5,30,0,0,602, - 603,3,50,25,0,603,604,5,31,0,0,604,605,3,48,24,0,605,635,1,0,0,0,606,607, - 5,35,0,0,607,608,5,30,0,0,608,609,3,50,25,0,609,610,5,31,0,0,610,611,3, - 48,24,0,611,612,5,36,0,0,612,613,3,6,3,0,613,635,1,0,0,0,614,615,5,35, - 0,0,615,616,5,30,0,0,616,617,3,50,25,0,617,618,5,31,0,0,618,619,3,48,24, - 0,619,620,5,36,0,0,620,621,5,17,0,0,621,622,3,52,26,0,622,623,5,18,0,0, - 623,635,1,0,0,0,624,625,5,35,0,0,625,626,5,30,0,0,626,627,3,50,25,0,627, - 628,5,31,0,0,628,629,3,48,24,0,629,630,5,36,0,0,630,631,5,30,0,0,631,632, - 3,312,156,0,632,633,5,31,0,0,633,635,1,0,0,0,634,600,1,0,0,0,634,606,1, - 0,0,0,634,614,1,0,0,0,634,624,1,0,0,0,635,47,1,0,0,0,636,637,3,190,95, - 0,637,49,1,0,0,0,638,641,3,146,73,0,639,641,3,198,99,0,640,638,1,0,0,0, - 640,639,1,0,0,0,641,51,1,0,0,0,642,643,3,54,27,0,643,644,3,56,28,0,644, - 53,1,0,0,0,645,648,3,318,159,0,646,648,3,40,20,0,647,645,1,0,0,0,647,646, - 1,0,0,0,648,651,1,0,0,0,649,647,1,0,0,0,649,650,1,0,0,0,650,55,1,0,0,0, - 651,649,1,0,0,0,652,653,3,58,29,0,653,654,3,60,30,0,654,655,3,2,1,0,655, - 656,5,36,0,0,656,657,3,318,159,0,657,660,1,0,0,0,658,660,3,40,20,0,659, - 652,1,0,0,0,659,658,1,0,0,0,660,663,1,0,0,0,661,659,1,0,0,0,661,662,1, - 0,0,0,662,57,1,0,0,0,663,661,1,0,0,0,664,665,7,4,0,0,665,59,1,0,0,0,666, - 668,3,62,31,0,667,669,5,261,0,0,668,667,1,0,0,0,668,669,1,0,0,0,669,61, - 1,0,0,0,670,680,3,166,83,0,671,680,3,2,1,0,672,680,5,196,0,0,673,680,5, - 197,0,0,674,675,5,202,0,0,675,676,5,39,0,0,676,680,5,264,0,0,677,678,5, - 202,0,0,678,680,3,138,69,0,679,670,1,0,0,0,679,671,1,0,0,0,679,672,1,0, - 0,0,679,673,1,0,0,0,679,674,1,0,0,0,679,677,1,0,0,0,680,63,1,0,0,0,681, - 682,5,198,0,0,682,683,5,40,0,0,683,688,3,2,1,0,684,685,5,198,0,0,685,688, - 3,2,1,0,686,688,5,198,0,0,687,681,1,0,0,0,687,684,1,0,0,0,687,686,1,0, - 0,0,688,65,1,0,0,0,689,690,5,41,0,0,690,691,5,42,0,0,691,692,3,32,16,0, - 692,693,5,43,0,0,693,694,3,68,34,0,694,695,5,44,0,0,695,696,3,0,0,0,696, - 67,1,0,0,0,697,710,6,34,-1,0,698,699,10,5,0,0,699,709,5,186,0,0,700,701, - 10,4,0,0,701,709,5,187,0,0,702,703,10,3,0,0,703,709,5,45,0,0,704,705,10, - 2,0,0,705,709,5,46,0,0,706,707,10,1,0,0,707,709,5,47,0,0,708,698,1,0,0, - 0,708,700,1,0,0,0,708,702,1,0,0,0,708,704,1,0,0,0,708,706,1,0,0,0,709, - 712,1,0,0,0,710,708,1,0,0,0,710,711,1,0,0,0,711,69,1,0,0,0,712,710,1,0, - 0,0,713,714,5,48,0,0,714,715,5,36,0,0,715,716,5,30,0,0,716,717,3,312,156, - 0,717,718,5,31,0,0,718,71,1,0,0,0,719,720,5,49,0,0,720,721,3,2,1,0,721, - 73,1,0,0,0,722,726,5,50,0,0,723,725,3,76,38,0,724,723,1,0,0,0,725,728, - 1,0,0,0,726,724,1,0,0,0,726,727,1,0,0,0,727,729,1,0,0,0,728,726,1,0,0, - 0,729,730,3,2,1,0,730,731,3,204,102,0,731,732,3,78,39,0,732,733,3,80,40, - 0,733,75,1,0,0,0,734,772,5,51,0,0,735,772,5,52,0,0,736,772,5,199,0,0,737, - 772,5,202,0,0,738,772,5,221,0,0,739,772,5,53,0,0,740,772,5,54,0,0,741, - 772,5,55,0,0,742,772,5,56,0,0,743,772,5,244,0,0,744,772,5,15,0,0,745,772, - 5,224,0,0,746,772,5,57,0,0,747,772,5,58,0,0,748,772,5,59,0,0,749,772,5, - 60,0,0,750,772,5,61,0,0,751,752,5,62,0,0,752,772,5,51,0,0,753,754,5,62, - 0,0,754,772,5,52,0,0,755,756,5,62,0,0,756,772,5,63,0,0,757,758,5,62,0, - 0,758,772,5,64,0,0,759,760,5,62,0,0,760,772,5,65,0,0,761,762,5,62,0,0, - 762,772,5,66,0,0,763,772,5,67,0,0,764,772,5,68,0,0,765,772,5,69,0,0,766, - 767,5,70,0,0,767,768,5,30,0,0,768,769,3,32,16,0,769,770,5,31,0,0,770,772, - 1,0,0,0,771,734,1,0,0,0,771,735,1,0,0,0,771,736,1,0,0,0,771,737,1,0,0, - 0,771,738,1,0,0,0,771,739,1,0,0,0,771,740,1,0,0,0,771,741,1,0,0,0,771, - 742,1,0,0,0,771,743,1,0,0,0,771,744,1,0,0,0,771,745,1,0,0,0,771,746,1, - 0,0,0,771,747,1,0,0,0,771,748,1,0,0,0,771,749,1,0,0,0,771,750,1,0,0,0, - 771,751,1,0,0,0,771,753,1,0,0,0,771,755,1,0,0,0,771,757,1,0,0,0,771,759, - 1,0,0,0,771,761,1,0,0,0,771,763,1,0,0,0,771,764,1,0,0,0,771,765,1,0,0, - 0,771,766,1,0,0,0,772,77,1,0,0,0,773,777,1,0,0,0,774,775,5,71,0,0,775, - 777,3,146,73,0,776,773,1,0,0,0,776,774,1,0,0,0,777,79,1,0,0,0,778,782, - 1,0,0,0,779,780,5,72,0,0,780,782,3,84,42,0,781,778,1,0,0,0,781,779,1,0, - 0,0,782,81,1,0,0,0,783,785,3,220,110,0,784,783,1,0,0,0,785,788,1,0,0,0, - 786,784,1,0,0,0,786,787,1,0,0,0,787,83,1,0,0,0,788,786,1,0,0,0,789,790, - 3,146,73,0,790,791,5,28,0,0,791,793,1,0,0,0,792,789,1,0,0,0,793,796,1, - 0,0,0,794,792,1,0,0,0,794,795,1,0,0,0,795,797,1,0,0,0,796,794,1,0,0,0, - 797,798,3,146,73,0,798,85,1,0,0,0,799,800,7,5,0,0,800,87,1,0,0,0,801,802, - 3,86,43,0,802,803,3,32,16,0,803,804,5,264,0,0,804,905,1,0,0,0,805,806, - 3,86,43,0,806,807,3,32,16,0,807,905,1,0,0,0,808,809,3,86,43,0,809,810, - 3,32,16,0,810,811,5,75,0,0,811,812,3,32,16,0,812,813,5,264,0,0,813,905, - 1,0,0,0,814,815,3,86,43,0,815,816,3,32,16,0,816,817,5,75,0,0,817,818,3, - 32,16,0,818,905,1,0,0,0,819,820,3,86,43,0,820,821,3,32,16,0,821,822,5, - 75,0,0,822,823,3,32,16,0,823,824,5,28,0,0,824,825,3,32,16,0,825,826,5, - 264,0,0,826,905,1,0,0,0,827,828,3,86,43,0,828,829,3,32,16,0,829,830,5, - 75,0,0,830,831,3,32,16,0,831,832,5,28,0,0,832,833,3,32,16,0,833,905,1, - 0,0,0,834,835,3,86,43,0,835,836,3,32,16,0,836,837,5,28,0,0,837,838,3,32, - 16,0,838,839,5,75,0,0,839,840,3,32,16,0,840,841,5,264,0,0,841,905,1,0, - 0,0,842,843,3,86,43,0,843,844,3,32,16,0,844,845,5,28,0,0,845,846,3,32, - 16,0,846,847,5,75,0,0,847,848,3,32,16,0,848,905,1,0,0,0,849,850,3,86,43, - 0,850,851,3,32,16,0,851,852,5,28,0,0,852,853,3,32,16,0,853,854,5,75,0, - 0,854,855,3,32,16,0,855,856,5,28,0,0,856,857,3,32,16,0,857,858,5,264,0, - 0,858,905,1,0,0,0,859,860,3,86,43,0,860,861,3,32,16,0,861,862,5,28,0,0, - 862,863,3,32,16,0,863,864,5,75,0,0,864,865,3,32,16,0,865,866,5,28,0,0, - 866,867,3,32,16,0,867,905,1,0,0,0,868,869,3,86,43,0,869,870,3,32,16,0, - 870,871,5,263,0,0,871,905,1,0,0,0,872,873,3,86,43,0,873,874,3,32,16,0, - 874,875,5,75,0,0,875,876,3,32,16,0,876,877,5,263,0,0,877,905,1,0,0,0,878, - 879,3,86,43,0,879,880,3,32,16,0,880,881,5,75,0,0,881,882,3,32,16,0,882, - 883,5,28,0,0,883,884,3,32,16,0,884,885,5,263,0,0,885,905,1,0,0,0,886,887, - 3,86,43,0,887,888,3,32,16,0,888,889,5,28,0,0,889,890,3,32,16,0,890,891, - 5,75,0,0,891,892,3,32,16,0,892,893,5,263,0,0,893,905,1,0,0,0,894,895,3, - 86,43,0,895,896,3,32,16,0,896,897,5,28,0,0,897,898,3,32,16,0,898,899,5, - 75,0,0,899,900,3,32,16,0,900,901,5,28,0,0,901,902,3,32,16,0,902,903,5, - 263,0,0,903,905,1,0,0,0,904,801,1,0,0,0,904,805,1,0,0,0,904,808,1,0,0, - 0,904,814,1,0,0,0,904,819,1,0,0,0,904,827,1,0,0,0,904,834,1,0,0,0,904, - 842,1,0,0,0,904,849,1,0,0,0,904,859,1,0,0,0,904,868,1,0,0,0,904,872,1, - 0,0,0,904,878,1,0,0,0,904,886,1,0,0,0,904,894,1,0,0,0,905,89,1,0,0,0,906, - 910,5,21,0,0,907,909,3,92,46,0,908,907,1,0,0,0,909,912,1,0,0,0,910,908, - 1,0,0,0,910,911,1,0,0,0,911,913,1,0,0,0,912,910,1,0,0,0,913,914,3,2,1, - 0,914,915,3,94,47,0,915,916,5,180,0,0,916,917,5,36,0,0,917,918,5,30,0, - 0,918,919,3,312,156,0,919,920,5,31,0,0,920,921,3,94,47,0,921,933,1,0,0, - 0,922,926,5,21,0,0,923,925,3,92,46,0,924,923,1,0,0,0,925,928,1,0,0,0,926, - 924,1,0,0,0,926,927,1,0,0,0,927,929,1,0,0,0,928,926,1,0,0,0,929,930,3, - 2,1,0,930,931,3,94,47,0,931,933,1,0,0,0,932,906,1,0,0,0,932,922,1,0,0, - 0,933,91,1,0,0,0,934,935,5,76,0,0,935,93,1,0,0,0,936,939,1,0,0,0,937,939, - 5,298,0,0,938,936,1,0,0,0,938,937,1,0,0,0,939,95,1,0,0,0,940,941,7,6,0, - 0,941,97,1,0,0,0,942,944,3,96,48,0,943,942,1,0,0,0,944,947,1,0,0,0,945, - 943,1,0,0,0,945,946,1,0,0,0,946,99,1,0,0,0,947,945,1,0,0,0,948,949,5,275, - 0,0,949,101,1,0,0,0,950,951,5,276,0,0,951,103,1,0,0,0,952,953,5,277,0, - 0,953,105,1,0,0,0,954,955,5,278,0,0,955,107,1,0,0,0,956,957,5,279,0,0, - 957,109,1,0,0,0,958,959,5,282,0,0,959,111,1,0,0,0,960,961,5,280,0,0,961, - 113,1,0,0,0,962,963,5,286,0,0,963,115,1,0,0,0,964,965,5,284,0,0,965,117, - 1,0,0,0,966,967,5,285,0,0,967,119,1,0,0,0,968,969,5,281,0,0,969,121,1, - 0,0,0,970,971,5,287,0,0,971,123,1,0,0,0,972,973,5,283,0,0,973,125,1,0, - 0,0,974,1057,3,100,50,0,975,976,3,102,51,0,976,977,3,32,16,0,977,1057, - 1,0,0,0,978,979,3,102,51,0,979,980,3,0,0,0,980,1057,1,0,0,0,981,982,3, - 104,52,0,982,983,3,32,16,0,983,1057,1,0,0,0,984,985,3,106,53,0,985,986, - 3,34,17,0,986,1057,1,0,0,0,987,988,3,108,54,0,988,989,3,36,18,0,989,1057, - 1,0,0,0,990,991,3,108,54,0,991,992,3,34,17,0,992,1057,1,0,0,0,993,994, - 3,108,54,0,994,995,5,30,0,0,995,996,3,312,156,0,996,997,5,31,0,0,997,1057, - 1,0,0,0,998,999,3,108,54,0,999,1000,5,84,0,0,1000,1001,5,30,0,0,1001,1002, - 3,312,156,0,1002,1003,5,31,0,0,1003,1057,1,0,0,0,1004,1005,3,110,55,0, - 1005,1006,3,32,16,0,1006,1057,1,0,0,0,1007,1008,3,110,55,0,1008,1009,3, - 0,0,0,1009,1057,1,0,0,0,1010,1011,3,112,56,0,1011,1012,3,190,95,0,1012, - 1057,1,0,0,0,1013,1014,3,114,57,0,1014,1015,3,200,100,0,1015,1057,1,0, - 0,0,1016,1017,3,114,57,0,1017,1018,3,196,98,0,1018,1057,1,0,0,0,1019,1020, - 3,116,58,0,1020,1021,3,146,73,0,1021,1057,1,0,0,0,1022,1023,3,118,59,0, - 1023,1024,3,6,3,0,1024,1057,1,0,0,0,1025,1026,3,118,59,0,1026,1027,5,224, - 0,0,1027,1028,5,30,0,0,1028,1029,3,6,3,0,1029,1030,5,31,0,0,1030,1057, - 1,0,0,0,1031,1032,3,118,59,0,1032,1033,5,84,0,0,1033,1034,5,30,0,0,1034, - 1035,3,312,156,0,1035,1036,5,31,0,0,1036,1057,1,0,0,0,1037,1038,3,120, - 60,0,1038,1039,3,192,96,0,1039,1040,3,160,80,0,1040,1041,3,134,67,0,1041, - 1057,1,0,0,0,1042,1043,3,122,61,0,1043,1044,3,50,25,0,1044,1057,1,0,0, - 0,1045,1046,3,122,61,0,1046,1047,3,32,16,0,1047,1057,1,0,0,0,1048,1049, - 3,124,62,0,1049,1050,5,30,0,0,1050,1051,3,128,64,0,1051,1052,5,31,0,0, - 1052,1057,1,0,0,0,1053,1054,3,124,62,0,1054,1055,5,85,0,0,1055,1057,1, - 0,0,0,1056,974,1,0,0,0,1056,975,1,0,0,0,1056,978,1,0,0,0,1056,981,1,0, - 0,0,1056,984,1,0,0,0,1056,987,1,0,0,0,1056,990,1,0,0,0,1056,993,1,0,0, - 0,1056,998,1,0,0,0,1056,1004,1,0,0,0,1056,1007,1,0,0,0,1056,1010,1,0,0, - 0,1056,1013,1,0,0,0,1056,1016,1,0,0,0,1056,1019,1,0,0,0,1056,1022,1,0, - 0,0,1056,1025,1,0,0,0,1056,1031,1,0,0,0,1056,1037,1,0,0,0,1056,1042,1, - 0,0,0,1056,1045,1,0,0,0,1056,1048,1,0,0,0,1056,1053,1,0,0,0,1057,127,1, - 0,0,0,1058,1075,1,0,0,0,1059,1062,3,0,0,0,1060,1062,3,32,16,0,1061,1059, - 1,0,0,0,1061,1060,1,0,0,0,1062,1063,1,0,0,0,1063,1064,5,28,0,0,1064,1066, - 1,0,0,0,1065,1061,1,0,0,0,1066,1069,1,0,0,0,1067,1065,1,0,0,0,1067,1068, - 1,0,0,0,1068,1072,1,0,0,0,1069,1067,1,0,0,0,1070,1073,3,0,0,0,1071,1073, - 3,32,16,0,1072,1070,1,0,0,0,1072,1071,1,0,0,0,1073,1075,1,0,0,0,1074,1058, - 1,0,0,0,1074,1067,1,0,0,0,1075,129,1,0,0,0,1076,1082,5,86,0,0,1077,1078, - 3,160,80,0,1078,1079,5,28,0,0,1079,1081,1,0,0,0,1080,1077,1,0,0,0,1081, - 1084,1,0,0,0,1082,1080,1,0,0,0,1082,1083,1,0,0,0,1083,1085,1,0,0,0,1084, - 1082,1,0,0,0,1085,1086,3,160,80,0,1086,1087,5,87,0,0,1087,131,1,0,0,0, - 1088,1094,5,42,0,0,1089,1090,3,168,84,0,1090,1091,5,28,0,0,1091,1093,1, - 0,0,0,1092,1089,1,0,0,0,1093,1096,1,0,0,0,1094,1092,1,0,0,0,1094,1095, - 1,0,0,0,1095,1097,1,0,0,0,1096,1094,1,0,0,0,1097,1098,3,168,84,0,1098, - 1099,5,43,0,0,1099,133,1,0,0,0,1100,1106,5,30,0,0,1101,1102,3,136,68,0, - 1102,1103,5,28,0,0,1103,1105,1,0,0,0,1104,1101,1,0,0,0,1105,1108,1,0,0, - 0,1106,1104,1,0,0,0,1106,1107,1,0,0,0,1107,1109,1,0,0,0,1108,1106,1,0, - 0,0,1109,1110,3,136,68,0,1110,1111,5,31,0,0,1111,1114,1,0,0,0,1112,1114, - 5,85,0,0,1113,1100,1,0,0,0,1113,1112,1,0,0,0,1114,135,1,0,0,0,1115,1123, - 5,177,0,0,1116,1117,3,252,126,0,1117,1118,3,160,80,0,1118,1120,3,248,124, - 0,1119,1121,3,0,0,0,1120,1119,1,0,0,0,1120,1121,1,0,0,0,1121,1123,1,0, - 0,0,1122,1115,1,0,0,0,1122,1116,1,0,0,0,1123,137,1,0,0,0,1124,1125,5,42, - 0,0,1125,1126,3,2,1,0,1126,1127,5,43,0,0,1127,1128,3,140,70,0,1128,1150, - 1,0,0,0,1129,1130,5,42,0,0,1130,1131,3,196,98,0,1131,1132,5,43,0,0,1132, - 1133,3,140,70,0,1133,1150,1,0,0,0,1134,1135,5,42,0,0,1135,1136,5,262,0, - 0,1136,1137,5,43,0,0,1137,1150,3,140,70,0,1138,1139,5,42,0,0,1139,1140, - 5,198,0,0,1140,1141,3,2,1,0,1141,1142,5,43,0,0,1142,1143,3,140,70,0,1143, - 1150,1,0,0,0,1144,1150,3,140,70,0,1145,1150,3,196,98,0,1146,1150,5,257, - 0,0,1147,1150,5,258,0,0,1148,1150,5,259,0,0,1149,1124,1,0,0,0,1149,1129, - 1,0,0,0,1149,1134,1,0,0,0,1149,1138,1,0,0,0,1149,1144,1,0,0,0,1149,1145, - 1,0,0,0,1149,1146,1,0,0,0,1149,1147,1,0,0,0,1149,1148,1,0,0,0,1150,139, - 1,0,0,0,1151,1152,3,2,1,0,1152,1153,5,88,0,0,1153,1155,1,0,0,0,1154,1151, - 1,0,0,0,1155,1158,1,0,0,0,1156,1154,1,0,0,0,1156,1157,1,0,0,0,1157,1159, - 1,0,0,0,1158,1156,1,0,0,0,1159,1160,3,2,1,0,1160,141,1,0,0,0,1161,1163, - 3,144,72,0,1162,1161,1,0,0,0,1163,1166,1,0,0,0,1164,1162,1,0,0,0,1164, - 1165,1,0,0,0,1165,143,1,0,0,0,1166,1164,1,0,0,0,1167,1168,5,180,0,0,1168, - 1169,5,89,0,0,1169,1173,3,32,16,0,1170,1173,3,174,87,0,1171,1173,3,344, - 172,0,1172,1167,1,0,0,0,1172,1170,1,0,0,0,1172,1171,1,0,0,0,1173,145,1, - 0,0,0,1174,1186,3,138,69,0,1175,1176,5,42,0,0,1176,1177,3,2,1,0,1177,1178, - 5,43,0,0,1178,1186,1,0,0,0,1179,1180,5,42,0,0,1180,1181,5,198,0,0,1181, - 1182,3,2,1,0,1182,1183,5,43,0,0,1183,1186,1,0,0,0,1184,1186,3,160,80,0, - 1185,1174,1,0,0,0,1185,1175,1,0,0,0,1185,1179,1,0,0,0,1185,1184,1,0,0, - 0,1186,147,1,0,0,0,1187,1196,1,0,0,0,1188,1192,3,152,76,0,1189,1191,3, - 150,75,0,1190,1189,1,0,0,0,1191,1194,1,0,0,0,1192,1190,1,0,0,0,1192,1193, - 1,0,0,0,1193,1196,1,0,0,0,1194,1192,1,0,0,0,1195,1187,1,0,0,0,1195,1188, - 1,0,0,0,1196,149,1,0,0,0,1197,1215,5,262,0,0,1198,1215,5,261,0,0,1199, - 1200,5,42,0,0,1200,1201,3,32,16,0,1201,1202,5,43,0,0,1202,1215,1,0,0,0, - 1203,1204,5,42,0,0,1204,1205,3,32,16,0,1205,1206,5,266,0,0,1206,1207,3, - 32,16,0,1207,1208,5,43,0,0,1208,1215,1,0,0,0,1209,1210,5,42,0,0,1210,1211, - 5,266,0,0,1211,1212,3,32,16,0,1212,1213,5,43,0,0,1213,1215,1,0,0,0,1214, - 1197,1,0,0,0,1214,1198,1,0,0,0,1214,1199,1,0,0,0,1214,1203,1,0,0,0,1214, - 1209,1,0,0,0,1215,151,1,0,0,0,1216,1309,1,0,0,0,1217,1218,5,203,0,0,1218, - 1219,5,30,0,0,1219,1220,3,6,3,0,1220,1221,5,28,0,0,1221,1222,3,6,3,0,1222, - 1223,5,28,0,0,1223,1224,3,6,3,0,1224,1225,5,28,0,0,1225,1226,3,6,3,0,1226, - 1227,5,31,0,0,1227,1309,1,0,0,0,1228,1229,5,203,0,0,1229,1230,5,30,0,0, - 1230,1231,3,6,3,0,1231,1232,5,28,0,0,1232,1233,3,6,3,0,1233,1234,5,31, - 0,0,1234,1309,1,0,0,0,1235,1236,5,204,0,0,1236,1237,5,205,0,0,1237,1238, - 5,42,0,0,1238,1239,3,32,16,0,1239,1240,5,43,0,0,1240,1309,1,0,0,0,1241, - 1242,5,204,0,0,1242,1243,5,206,0,0,1243,1244,5,42,0,0,1244,1245,3,32,16, - 0,1245,1246,5,43,0,0,1246,1247,3,148,74,0,1247,1309,1,0,0,0,1248,1309, - 5,207,0,0,1249,1309,5,208,0,0,1250,1309,5,209,0,0,1251,1309,5,201,0,0, - 1252,1309,5,183,0,0,1253,1309,5,184,0,0,1254,1309,5,185,0,0,1255,1309, - 5,186,0,0,1256,1309,5,187,0,0,1257,1309,5,188,0,0,1258,1309,5,189,0,0, - 1259,1309,5,210,0,0,1260,1309,5,190,0,0,1261,1309,5,191,0,0,1262,1309, - 5,192,0,0,1263,1309,5,193,0,0,1264,1309,5,211,0,0,1265,1309,5,212,0,0, - 1266,1309,5,213,0,0,1267,1309,5,214,0,0,1268,1309,5,215,0,0,1269,1309, - 5,216,0,0,1270,1309,5,217,0,0,1271,1272,5,218,0,0,1272,1309,3,154,77,0, - 1273,1274,5,219,0,0,1274,1309,3,154,77,0,1275,1309,5,220,0,0,1276,1277, - 5,221,0,0,1277,1309,3,154,77,0,1278,1279,5,222,0,0,1279,1309,3,156,78, - 0,1280,1281,5,222,0,0,1281,1282,3,156,78,0,1282,1283,5,28,0,0,1283,1284, - 3,6,3,0,1284,1309,1,0,0,0,1285,1309,5,194,0,0,1286,1309,5,195,0,0,1287, - 1288,5,90,0,0,1288,1309,5,184,0,0,1289,1290,5,90,0,0,1290,1309,5,185,0, - 0,1291,1292,5,90,0,0,1292,1309,5,186,0,0,1293,1294,5,90,0,0,1294,1309, - 5,187,0,0,1295,1296,5,62,0,0,1296,1309,5,220,0,0,1297,1309,5,223,0,0,1298, - 1299,5,224,0,0,1299,1309,5,213,0,0,1300,1309,5,225,0,0,1301,1302,5,207, - 0,0,1302,1309,5,183,0,0,1303,1309,5,226,0,0,1304,1309,5,228,0,0,1305,1306, - 5,34,0,0,1306,1309,5,227,0,0,1307,1309,3,2,1,0,1308,1216,1,0,0,0,1308, - 1217,1,0,0,0,1308,1228,1,0,0,0,1308,1235,1,0,0,0,1308,1241,1,0,0,0,1308, - 1248,1,0,0,0,1308,1249,1,0,0,0,1308,1250,1,0,0,0,1308,1251,1,0,0,0,1308, - 1252,1,0,0,0,1308,1253,1,0,0,0,1308,1254,1,0,0,0,1308,1255,1,0,0,0,1308, - 1256,1,0,0,0,1308,1257,1,0,0,0,1308,1258,1,0,0,0,1308,1259,1,0,0,0,1308, - 1260,1,0,0,0,1308,1261,1,0,0,0,1308,1262,1,0,0,0,1308,1263,1,0,0,0,1308, - 1264,1,0,0,0,1308,1265,1,0,0,0,1308,1266,1,0,0,0,1308,1267,1,0,0,0,1308, - 1268,1,0,0,0,1308,1269,1,0,0,0,1308,1270,1,0,0,0,1308,1271,1,0,0,0,1308, - 1273,1,0,0,0,1308,1275,1,0,0,0,1308,1276,1,0,0,0,1308,1278,1,0,0,0,1308, - 1280,1,0,0,0,1308,1285,1,0,0,0,1308,1286,1,0,0,0,1308,1287,1,0,0,0,1308, - 1289,1,0,0,0,1308,1291,1,0,0,0,1308,1293,1,0,0,0,1308,1295,1,0,0,0,1308, - 1297,1,0,0,0,1308,1298,1,0,0,0,1308,1300,1,0,0,0,1308,1301,1,0,0,0,1308, - 1303,1,0,0,0,1308,1304,1,0,0,0,1308,1305,1,0,0,0,1308,1307,1,0,0,0,1309, - 153,1,0,0,0,1310,1318,1,0,0,0,1311,1312,5,30,0,0,1312,1313,5,91,0,0,1313, - 1314,5,36,0,0,1314,1315,3,32,16,0,1315,1316,5,31,0,0,1316,1318,1,0,0,0, - 1317,1310,1,0,0,0,1317,1311,1,0,0,0,1318,155,1,0,0,0,1319,1328,1,0,0,0, - 1320,1324,3,158,79,0,1321,1323,7,7,0,0,1322,1321,1,0,0,0,1323,1326,1,0, - 0,0,1324,1322,1,0,0,0,1324,1325,1,0,0,0,1325,1328,1,0,0,0,1326,1324,1, - 0,0,0,1327,1319,1,0,0,0,1327,1320,1,0,0,0,1328,157,1,0,0,0,1329,1330,7, - 8,0,0,1330,159,1,0,0,0,1331,1335,3,164,82,0,1332,1334,3,162,81,0,1333, - 1332,1,0,0,0,1334,1337,1,0,0,0,1335,1333,1,0,0,0,1335,1336,1,0,0,0,1336, - 161,1,0,0,0,1337,1335,1,0,0,0,1338,1357,5,261,0,0,1339,1340,5,42,0,0,1340, - 1357,5,43,0,0,1341,1357,3,132,66,0,1342,1357,5,260,0,0,1343,1357,5,262, - 0,0,1344,1357,5,92,0,0,1345,1346,5,93,0,0,1346,1347,5,30,0,0,1347,1348, - 3,146,73,0,1348,1349,5,31,0,0,1349,1357,1,0,0,0,1350,1351,5,94,0,0,1351, - 1352,5,30,0,0,1352,1353,3,146,73,0,1353,1354,5,31,0,0,1354,1357,1,0,0, - 0,1355,1357,3,130,65,0,1356,1338,1,0,0,0,1356,1339,1,0,0,0,1356,1341,1, - 0,0,0,1356,1342,1,0,0,0,1356,1343,1,0,0,0,1356,1344,1,0,0,0,1356,1345, - 1,0,0,0,1356,1350,1,0,0,0,1356,1355,1,0,0,0,1357,163,1,0,0,0,1358,1359, - 5,39,0,0,1359,1389,3,138,69,0,1360,1389,5,197,0,0,1361,1362,5,199,0,0, - 1362,1363,5,39,0,0,1363,1389,3,138,69,0,1364,1365,5,200,0,0,1365,1389, - 3,138,69,0,1366,1367,5,226,0,0,1367,1368,3,192,96,0,1368,1369,3,160,80, - 0,1369,1370,5,262,0,0,1370,1371,3,134,67,0,1371,1389,1,0,0,0,1372,1373, - 5,253,0,0,1373,1389,3,32,16,0,1374,1375,5,252,0,0,1375,1389,3,32,16,0, - 1376,1377,5,253,0,0,1377,1389,3,2,1,0,1378,1379,5,252,0,0,1379,1389,3, - 2,1,0,1380,1389,5,254,0,0,1381,1389,5,201,0,0,1382,1389,3,170,85,0,1383, - 1389,3,172,86,0,1384,1389,3,166,83,0,1385,1389,3,2,1,0,1386,1387,5,177, - 0,0,1387,1389,3,160,80,0,1388,1358,1,0,0,0,1388,1360,1,0,0,0,1388,1361, - 1,0,0,0,1388,1364,1,0,0,0,1388,1366,1,0,0,0,1388,1372,1,0,0,0,1388,1374, - 1,0,0,0,1388,1376,1,0,0,0,1388,1378,1,0,0,0,1388,1380,1,0,0,0,1388,1381, - 1,0,0,0,1388,1382,1,0,0,0,1388,1383,1,0,0,0,1388,1384,1,0,0,0,1388,1385, - 1,0,0,0,1388,1386,1,0,0,0,1389,165,1,0,0,0,1390,1412,5,181,0,0,1391,1412, - 5,182,0,0,1392,1412,5,183,0,0,1393,1412,5,184,0,0,1394,1412,5,185,0,0, - 1395,1412,5,186,0,0,1396,1412,5,187,0,0,1397,1412,5,188,0,0,1398,1412, + 1,172,1,172,3,172,2774,8,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,3,173,2788,8,173,1,174,5,174,2791,8,174, + 10,174,12,174,2794,9,174,1,175,1,175,1,175,1,175,1,175,1,175,1,175,1,175, + 1,175,1,175,1,175,1,175,1,175,1,175,3,175,2810,8,175,1,176,1,176,1,176, + 5,176,2815,8,176,10,176,12,176,2818,9,176,1,176,1,176,1,177,1,177,5,177, + 2824,8,177,10,177,12,177,2827,9,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,178,1,178,1,178,1,178,3,178, + 2846,8,178,1,179,5,179,2849,8,179,10,179,12,179,2852,9,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,3,180, + 2867,8,180,1,181,1,181,5,181,2871,8,181,10,181,12,181,2874,9,181,1,181, + 1,181,1,181,5,181,2879,8,181,10,181,12,181,2882,9,181,1,181,1,181,1,181, + 1,181,3,181,2888,8,181,1,182,1,182,1,183,5,183,2893,8,183,10,183,12,183, + 2896,9,183,1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184, + 3,184,2908,8,184,1,184,0,1,68,185,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, + 0,16,6,0,1,15,199,199,243,243,247,247,264,264,289,289,5,0,16,16,199,199, + 243,243,264,264,288,289,1,0,263,264,1,0,173,174,1,0,37,38,1,0,73,74,3, + 0,2,2,61,61,77,83,2,0,229,229,260,261,9,0,178,178,183,195,201,201,207, + 208,210,215,218,219,222,222,230,242,262,262,1,0,95,96,1,0,97,111,1,0,68, + 69,2,0,173,173,289,290,2,0,179,179,264,264,1,0,167,168,1,0,51,52,3327, + 0,370,1,0,0,0,2,383,1,0,0,0,4,385,1,0,0,0,6,391,1,0,0,0,8,399,1,0,0,0, + 10,452,1,0,0,0,12,454,1,0,0,0,14,457,1,0,0,0,16,460,1,0,0,0,18,464,1,0, + 0,0,20,467,1,0,0,0,22,470,1,0,0,0,24,477,1,0,0,0,26,493,1,0,0,0,28,495, + 1,0,0,0,30,497,1,0,0,0,32,507,1,0,0,0,34,509,1,0,0,0,36,526,1,0,0,0,38, + 530,1,0,0,0,40,548,1,0,0,0,42,575,1,0,0,0,44,598,1,0,0,0,46,634,1,0,0, + 0,48,636,1,0,0,0,50,640,1,0,0,0,52,642,1,0,0,0,54,649,1,0,0,0,56,661,1, + 0,0,0,58,664,1,0,0,0,60,666,1,0,0,0,62,679,1,0,0,0,64,687,1,0,0,0,66,689, + 1,0,0,0,68,697,1,0,0,0,70,713,1,0,0,0,72,719,1,0,0,0,74,722,1,0,0,0,76, + 771,1,0,0,0,78,776,1,0,0,0,80,781,1,0,0,0,82,786,1,0,0,0,84,794,1,0,0, + 0,86,799,1,0,0,0,88,904,1,0,0,0,90,932,1,0,0,0,92,934,1,0,0,0,94,938,1, + 0,0,0,96,940,1,0,0,0,98,945,1,0,0,0,100,948,1,0,0,0,102,950,1,0,0,0,104, + 952,1,0,0,0,106,954,1,0,0,0,108,956,1,0,0,0,110,958,1,0,0,0,112,960,1, + 0,0,0,114,962,1,0,0,0,116,964,1,0,0,0,118,966,1,0,0,0,120,968,1,0,0,0, + 122,970,1,0,0,0,124,972,1,0,0,0,126,1056,1,0,0,0,128,1074,1,0,0,0,130, + 1076,1,0,0,0,132,1088,1,0,0,0,134,1113,1,0,0,0,136,1122,1,0,0,0,138,1149, + 1,0,0,0,140,1156,1,0,0,0,142,1164,1,0,0,0,144,1172,1,0,0,0,146,1185,1, + 0,0,0,148,1195,1,0,0,0,150,1214,1,0,0,0,152,1308,1,0,0,0,154,1317,1,0, + 0,0,156,1327,1,0,0,0,158,1329,1,0,0,0,160,1331,1,0,0,0,162,1356,1,0,0, + 0,164,1388,1,0,0,0,166,1411,1,0,0,0,168,1423,1,0,0,0,170,1425,1,0,0,0, + 172,1428,1,0,0,0,174,1481,1,0,0,0,176,1493,1,0,0,0,178,1508,1,0,0,0,180, + 1515,1,0,0,0,182,1520,1,0,0,0,184,1524,1,0,0,0,186,1560,1,0,0,0,188,1562, + 1,0,0,0,190,1598,1,0,0,0,192,1610,1,0,0,0,194,1624,1,0,0,0,196,1626,1, + 0,0,0,198,1636,1,0,0,0,200,1647,1,0,0,0,202,1654,1,0,0,0,204,1664,1,0, + 0,0,206,1677,1,0,0,0,208,1682,1,0,0,0,210,1685,1,0,0,0,212,1696,1,0,0, + 0,214,1701,1,0,0,0,216,1707,1,0,0,0,218,1709,1,0,0,0,220,1831,1,0,0,0, + 222,1833,1,0,0,0,224,1870,1,0,0,0,226,1877,1,0,0,0,228,1882,1,0,0,0,230, + 1889,1,0,0,0,232,1909,1,0,0,0,234,1911,1,0,0,0,236,1916,1,0,0,0,238,1931, + 1,0,0,0,240,1933,1,0,0,0,242,1946,1,0,0,0,244,1951,1,0,0,0,246,1964,1, + 0,0,0,248,1972,1,0,0,0,250,1983,1,0,0,0,252,1988,1,0,0,0,254,2004,1,0, + 0,0,256,2006,1,0,0,0,258,2050,1,0,0,0,260,2070,1,0,0,0,262,2099,1,0,0, + 0,264,2104,1,0,0,0,266,2127,1,0,0,0,268,2132,1,0,0,0,270,2243,1,0,0,0, + 272,2245,1,0,0,0,274,2250,1,0,0,0,276,2252,1,0,0,0,278,2256,1,0,0,0,280, + 2260,1,0,0,0,282,2276,1,0,0,0,284,2290,1,0,0,0,286,2298,1,0,0,0,288,2300, + 1,0,0,0,290,2303,1,0,0,0,292,2305,1,0,0,0,294,2318,1,0,0,0,296,2320,1, + 0,0,0,298,2330,1,0,0,0,300,2335,1,0,0,0,302,2346,1,0,0,0,304,2353,1,0, + 0,0,306,2363,1,0,0,0,308,2431,1,0,0,0,310,2508,1,0,0,0,312,2515,1,0,0, + 0,314,2518,1,0,0,0,316,2523,1,0,0,0,318,2673,1,0,0,0,320,2679,1,0,0,0, + 322,2686,1,0,0,0,324,2692,1,0,0,0,326,2698,1,0,0,0,328,2704,1,0,0,0,330, + 2710,1,0,0,0,332,2716,1,0,0,0,334,2722,1,0,0,0,336,2728,1,0,0,0,338,2735, + 1,0,0,0,340,2740,1,0,0,0,342,2746,1,0,0,0,344,2773,1,0,0,0,346,2787,1, + 0,0,0,348,2792,1,0,0,0,350,2809,1,0,0,0,352,2811,1,0,0,0,354,2821,1,0, + 0,0,356,2845,1,0,0,0,358,2850,1,0,0,0,360,2866,1,0,0,0,362,2887,1,0,0, + 0,364,2889,1,0,0,0,366,2894,1,0,0,0,368,2907,1,0,0,0,370,371,7,0,0,0,371, + 1,1,0,0,0,372,384,5,288,0,0,373,374,3,4,2,0,374,375,5,265,0,0,375,377, + 1,0,0,0,376,373,1,0,0,0,377,380,1,0,0,0,378,376,1,0,0,0,378,379,1,0,0, + 0,379,381,1,0,0,0,380,378,1,0,0,0,381,384,3,4,2,0,382,384,5,264,0,0,383, + 372,1,0,0,0,383,378,1,0,0,0,383,382,1,0,0,0,384,3,1,0,0,0,385,386,7,1, + 0,0,386,5,1,0,0,0,387,388,5,263,0,0,388,390,5,266,0,0,389,387,1,0,0,0, + 390,393,1,0,0,0,391,389,1,0,0,0,391,392,1,0,0,0,392,394,1,0,0,0,393,391, + 1,0,0,0,394,395,5,263,0,0,395,7,1,0,0,0,396,398,3,10,5,0,397,396,1,0,0, + 0,398,401,1,0,0,0,399,397,1,0,0,0,399,400,1,0,0,0,400,9,1,0,0,0,401,399, + 1,0,0,0,402,403,3,74,37,0,403,404,5,17,0,0,404,405,3,82,41,0,405,406,5, + 18,0,0,406,453,1,0,0,0,407,408,3,72,36,0,408,409,5,17,0,0,409,410,3,8, + 4,0,410,411,5,18,0,0,411,453,1,0,0,0,412,413,3,256,128,0,413,414,5,17, + 0,0,414,415,3,268,134,0,415,416,5,18,0,0,416,453,1,0,0,0,417,453,3,222, + 111,0,418,453,3,296,148,0,419,453,3,70,35,0,420,453,3,66,33,0,421,453, + 3,88,44,0,422,453,3,90,45,0,423,453,3,22,11,0,424,425,3,346,173,0,425, + 426,5,17,0,0,426,427,3,348,174,0,427,428,5,18,0,0,428,453,1,0,0,0,429, + 430,3,352,176,0,430,431,5,17,0,0,431,432,3,358,179,0,432,433,5,18,0,0, + 433,453,1,0,0,0,434,435,3,362,181,0,435,436,5,17,0,0,436,437,3,366,183, + 0,437,438,5,18,0,0,438,453,1,0,0,0,439,453,3,64,32,0,440,453,3,174,87, + 0,441,453,3,342,171,0,442,453,3,12,6,0,443,453,3,14,7,0,444,453,3,16,8, + 0,445,453,3,18,9,0,446,453,3,20,10,0,447,453,3,26,13,0,448,453,3,42,21, + 0,449,453,3,40,20,0,450,453,3,30,15,0,451,453,3,24,12,0,452,402,1,0,0, + 0,452,407,1,0,0,0,452,412,1,0,0,0,452,417,1,0,0,0,452,418,1,0,0,0,452, + 419,1,0,0,0,452,420,1,0,0,0,452,421,1,0,0,0,452,422,1,0,0,0,452,423,1, + 0,0,0,452,424,1,0,0,0,452,429,1,0,0,0,452,434,1,0,0,0,452,439,1,0,0,0, + 452,440,1,0,0,0,452,441,1,0,0,0,452,442,1,0,0,0,452,443,1,0,0,0,452,444, + 1,0,0,0,452,445,1,0,0,0,452,446,1,0,0,0,452,447,1,0,0,0,452,448,1,0,0, + 0,452,449,1,0,0,0,452,450,1,0,0,0,452,451,1,0,0,0,453,11,1,0,0,0,454,455, + 5,19,0,0,455,456,3,32,16,0,456,13,1,0,0,0,457,458,5,20,0,0,458,459,3,32, + 16,0,459,15,1,0,0,0,460,461,5,21,0,0,461,462,5,22,0,0,462,463,3,32,16, + 0,463,17,1,0,0,0,464,465,5,23,0,0,465,466,3,34,17,0,466,19,1,0,0,0,467, + 468,5,24,0,0,468,469,3,34,17,0,469,21,1,0,0,0,470,471,5,25,0,0,471,472, + 3,98,49,0,472,473,3,2,1,0,473,474,5,17,0,0,474,475,3,142,71,0,475,476, + 5,18,0,0,476,23,1,0,0,0,477,478,5,26,0,0,478,25,1,0,0,0,479,480,5,27,0, + 0,480,494,3,28,14,0,481,482,5,27,0,0,482,483,3,28,14,0,483,484,5,28,0, + 0,484,485,3,28,14,0,485,494,1,0,0,0,486,487,5,27,0,0,487,488,3,28,14,0, + 488,489,5,28,0,0,489,490,3,28,14,0,490,491,5,28,0,0,491,492,3,28,14,0, + 492,494,1,0,0,0,493,479,1,0,0,0,493,481,1,0,0,0,493,486,1,0,0,0,494,27, + 1,0,0,0,495,496,7,2,0,0,496,29,1,0,0,0,497,498,5,29,0,0,498,502,5,17,0, + 0,499,501,3,138,69,0,500,499,1,0,0,0,501,504,1,0,0,0,502,500,1,0,0,0,502, + 503,1,0,0,0,503,505,1,0,0,0,504,502,1,0,0,0,505,506,5,18,0,0,506,31,1, + 0,0,0,507,508,5,173,0,0,508,33,1,0,0,0,509,510,7,3,0,0,510,35,1,0,0,0, + 511,527,5,175,0,0,512,513,3,32,16,0,513,514,5,265,0,0,514,527,1,0,0,0, + 515,527,3,32,16,0,516,517,5,188,0,0,517,518,5,30,0,0,518,519,3,32,16,0, + 519,520,5,31,0,0,520,527,1,0,0,0,521,522,5,189,0,0,522,523,5,30,0,0,523, + 524,3,34,17,0,524,525,5,31,0,0,525,527,1,0,0,0,526,511,1,0,0,0,526,512, + 1,0,0,0,526,515,1,0,0,0,526,516,1,0,0,0,526,521,1,0,0,0,527,37,1,0,0,0, + 528,531,3,32,16,0,529,531,5,262,0,0,530,528,1,0,0,0,530,529,1,0,0,0,531, + 39,1,0,0,0,532,533,5,267,0,0,533,549,5,289,0,0,534,535,5,267,0,0,535,536, + 5,289,0,0,536,549,5,263,0,0,537,538,5,268,0,0,538,549,5,289,0,0,539,540, + 5,269,0,0,540,549,5,289,0,0,541,542,5,270,0,0,542,549,5,289,0,0,543,549, + 5,271,0,0,544,549,5,272,0,0,545,546,5,273,0,0,546,549,5,263,0,0,547,549, + 5,32,0,0,548,532,1,0,0,0,548,534,1,0,0,0,548,537,1,0,0,0,548,539,1,0,0, + 0,548,541,1,0,0,0,548,543,1,0,0,0,548,544,1,0,0,0,548,545,1,0,0,0,548, + 547,1,0,0,0,549,41,1,0,0,0,550,551,5,33,0,0,551,552,3,160,80,0,552,553, + 5,34,0,0,553,554,3,2,1,0,554,576,1,0,0,0,555,556,5,33,0,0,556,557,3,138, + 69,0,557,558,5,34,0,0,558,559,3,2,1,0,559,576,1,0,0,0,560,561,5,33,0,0, + 561,562,3,198,99,0,562,563,5,34,0,0,563,564,3,2,1,0,564,576,1,0,0,0,565, + 566,5,33,0,0,566,567,3,44,22,0,567,568,5,34,0,0,568,569,3,2,1,0,569,576, + 1,0,0,0,570,571,5,33,0,0,571,572,3,46,23,0,572,573,5,34,0,0,573,574,3, + 2,1,0,574,576,1,0,0,0,575,550,1,0,0,0,575,555,1,0,0,0,575,560,1,0,0,0, + 575,565,1,0,0,0,575,570,1,0,0,0,576,43,1,0,0,0,577,578,5,35,0,0,578,599, + 3,48,24,0,579,580,5,35,0,0,580,581,3,48,24,0,581,582,5,36,0,0,582,583, + 3,6,3,0,583,599,1,0,0,0,584,585,5,35,0,0,585,586,3,48,24,0,586,587,5,36, + 0,0,587,588,5,17,0,0,588,589,3,52,26,0,589,590,5,18,0,0,590,599,1,0,0, + 0,591,592,5,35,0,0,592,593,3,48,24,0,593,594,5,36,0,0,594,595,5,30,0,0, + 595,596,3,312,156,0,596,597,5,31,0,0,597,599,1,0,0,0,598,577,1,0,0,0,598, + 579,1,0,0,0,598,584,1,0,0,0,598,591,1,0,0,0,599,45,1,0,0,0,600,601,5,35, + 0,0,601,602,5,30,0,0,602,603,3,50,25,0,603,604,5,31,0,0,604,605,3,48,24, + 0,605,635,1,0,0,0,606,607,5,35,0,0,607,608,5,30,0,0,608,609,3,50,25,0, + 609,610,5,31,0,0,610,611,3,48,24,0,611,612,5,36,0,0,612,613,3,6,3,0,613, + 635,1,0,0,0,614,615,5,35,0,0,615,616,5,30,0,0,616,617,3,50,25,0,617,618, + 5,31,0,0,618,619,3,48,24,0,619,620,5,36,0,0,620,621,5,17,0,0,621,622,3, + 52,26,0,622,623,5,18,0,0,623,635,1,0,0,0,624,625,5,35,0,0,625,626,5,30, + 0,0,626,627,3,50,25,0,627,628,5,31,0,0,628,629,3,48,24,0,629,630,5,36, + 0,0,630,631,5,30,0,0,631,632,3,312,156,0,632,633,5,31,0,0,633,635,1,0, + 0,0,634,600,1,0,0,0,634,606,1,0,0,0,634,614,1,0,0,0,634,624,1,0,0,0,635, + 47,1,0,0,0,636,637,3,190,95,0,637,49,1,0,0,0,638,641,3,146,73,0,639,641, + 3,198,99,0,640,638,1,0,0,0,640,639,1,0,0,0,641,51,1,0,0,0,642,643,3,54, + 27,0,643,644,3,56,28,0,644,53,1,0,0,0,645,648,3,318,159,0,646,648,3,40, + 20,0,647,645,1,0,0,0,647,646,1,0,0,0,648,651,1,0,0,0,649,647,1,0,0,0,649, + 650,1,0,0,0,650,55,1,0,0,0,651,649,1,0,0,0,652,653,3,58,29,0,653,654,3, + 60,30,0,654,655,3,2,1,0,655,656,5,36,0,0,656,657,3,318,159,0,657,660,1, + 0,0,0,658,660,3,40,20,0,659,652,1,0,0,0,659,658,1,0,0,0,660,663,1,0,0, + 0,661,659,1,0,0,0,661,662,1,0,0,0,662,57,1,0,0,0,663,661,1,0,0,0,664,665, + 7,4,0,0,665,59,1,0,0,0,666,668,3,62,31,0,667,669,5,261,0,0,668,667,1,0, + 0,0,668,669,1,0,0,0,669,61,1,0,0,0,670,680,3,166,83,0,671,680,3,2,1,0, + 672,680,5,196,0,0,673,680,5,197,0,0,674,675,5,202,0,0,675,676,5,39,0,0, + 676,680,5,264,0,0,677,678,5,202,0,0,678,680,3,138,69,0,679,670,1,0,0,0, + 679,671,1,0,0,0,679,672,1,0,0,0,679,673,1,0,0,0,679,674,1,0,0,0,679,677, + 1,0,0,0,680,63,1,0,0,0,681,682,5,198,0,0,682,683,5,40,0,0,683,688,3,2, + 1,0,684,685,5,198,0,0,685,688,3,2,1,0,686,688,5,198,0,0,687,681,1,0,0, + 0,687,684,1,0,0,0,687,686,1,0,0,0,688,65,1,0,0,0,689,690,5,41,0,0,690, + 691,5,42,0,0,691,692,3,32,16,0,692,693,5,43,0,0,693,694,3,68,34,0,694, + 695,5,44,0,0,695,696,3,0,0,0,696,67,1,0,0,0,697,710,6,34,-1,0,698,699, + 10,5,0,0,699,709,5,186,0,0,700,701,10,4,0,0,701,709,5,187,0,0,702,703, + 10,3,0,0,703,709,5,45,0,0,704,705,10,2,0,0,705,709,5,46,0,0,706,707,10, + 1,0,0,707,709,5,47,0,0,708,698,1,0,0,0,708,700,1,0,0,0,708,702,1,0,0,0, + 708,704,1,0,0,0,708,706,1,0,0,0,709,712,1,0,0,0,710,708,1,0,0,0,710,711, + 1,0,0,0,711,69,1,0,0,0,712,710,1,0,0,0,713,714,5,48,0,0,714,715,5,36,0, + 0,715,716,5,30,0,0,716,717,3,312,156,0,717,718,5,31,0,0,718,71,1,0,0,0, + 719,720,5,49,0,0,720,721,3,2,1,0,721,73,1,0,0,0,722,726,5,50,0,0,723,725, + 3,76,38,0,724,723,1,0,0,0,725,728,1,0,0,0,726,724,1,0,0,0,726,727,1,0, + 0,0,727,729,1,0,0,0,728,726,1,0,0,0,729,730,3,2,1,0,730,731,3,204,102, + 0,731,732,3,78,39,0,732,733,3,80,40,0,733,75,1,0,0,0,734,772,5,51,0,0, + 735,772,5,52,0,0,736,772,5,199,0,0,737,772,5,202,0,0,738,772,5,221,0,0, + 739,772,5,53,0,0,740,772,5,54,0,0,741,772,5,55,0,0,742,772,5,56,0,0,743, + 772,5,244,0,0,744,772,5,15,0,0,745,772,5,224,0,0,746,772,5,57,0,0,747, + 772,5,58,0,0,748,772,5,59,0,0,749,772,5,60,0,0,750,772,5,61,0,0,751,752, + 5,62,0,0,752,772,5,51,0,0,753,754,5,62,0,0,754,772,5,52,0,0,755,756,5, + 62,0,0,756,772,5,63,0,0,757,758,5,62,0,0,758,772,5,64,0,0,759,760,5,62, + 0,0,760,772,5,65,0,0,761,762,5,62,0,0,762,772,5,66,0,0,763,772,5,67,0, + 0,764,772,5,68,0,0,765,772,5,69,0,0,766,767,5,70,0,0,767,768,5,30,0,0, + 768,769,3,32,16,0,769,770,5,31,0,0,770,772,1,0,0,0,771,734,1,0,0,0,771, + 735,1,0,0,0,771,736,1,0,0,0,771,737,1,0,0,0,771,738,1,0,0,0,771,739,1, + 0,0,0,771,740,1,0,0,0,771,741,1,0,0,0,771,742,1,0,0,0,771,743,1,0,0,0, + 771,744,1,0,0,0,771,745,1,0,0,0,771,746,1,0,0,0,771,747,1,0,0,0,771,748, + 1,0,0,0,771,749,1,0,0,0,771,750,1,0,0,0,771,751,1,0,0,0,771,753,1,0,0, + 0,771,755,1,0,0,0,771,757,1,0,0,0,771,759,1,0,0,0,771,761,1,0,0,0,771, + 763,1,0,0,0,771,764,1,0,0,0,771,765,1,0,0,0,771,766,1,0,0,0,772,77,1,0, + 0,0,773,777,1,0,0,0,774,775,5,71,0,0,775,777,3,146,73,0,776,773,1,0,0, + 0,776,774,1,0,0,0,777,79,1,0,0,0,778,782,1,0,0,0,779,780,5,72,0,0,780, + 782,3,84,42,0,781,778,1,0,0,0,781,779,1,0,0,0,782,81,1,0,0,0,783,785,3, + 220,110,0,784,783,1,0,0,0,785,788,1,0,0,0,786,784,1,0,0,0,786,787,1,0, + 0,0,787,83,1,0,0,0,788,786,1,0,0,0,789,790,3,146,73,0,790,791,5,28,0,0, + 791,793,1,0,0,0,792,789,1,0,0,0,793,796,1,0,0,0,794,792,1,0,0,0,794,795, + 1,0,0,0,795,797,1,0,0,0,796,794,1,0,0,0,797,798,3,146,73,0,798,85,1,0, + 0,0,799,800,7,5,0,0,800,87,1,0,0,0,801,802,3,86,43,0,802,803,3,32,16,0, + 803,804,5,264,0,0,804,905,1,0,0,0,805,806,3,86,43,0,806,807,3,32,16,0, + 807,905,1,0,0,0,808,809,3,86,43,0,809,810,3,32,16,0,810,811,5,75,0,0,811, + 812,3,32,16,0,812,813,5,264,0,0,813,905,1,0,0,0,814,815,3,86,43,0,815, + 816,3,32,16,0,816,817,5,75,0,0,817,818,3,32,16,0,818,905,1,0,0,0,819,820, + 3,86,43,0,820,821,3,32,16,0,821,822,5,75,0,0,822,823,3,32,16,0,823,824, + 5,28,0,0,824,825,3,32,16,0,825,826,5,264,0,0,826,905,1,0,0,0,827,828,3, + 86,43,0,828,829,3,32,16,0,829,830,5,75,0,0,830,831,3,32,16,0,831,832,5, + 28,0,0,832,833,3,32,16,0,833,905,1,0,0,0,834,835,3,86,43,0,835,836,3,32, + 16,0,836,837,5,28,0,0,837,838,3,32,16,0,838,839,5,75,0,0,839,840,3,32, + 16,0,840,841,5,264,0,0,841,905,1,0,0,0,842,843,3,86,43,0,843,844,3,32, + 16,0,844,845,5,28,0,0,845,846,3,32,16,0,846,847,5,75,0,0,847,848,3,32, + 16,0,848,905,1,0,0,0,849,850,3,86,43,0,850,851,3,32,16,0,851,852,5,28, + 0,0,852,853,3,32,16,0,853,854,5,75,0,0,854,855,3,32,16,0,855,856,5,28, + 0,0,856,857,3,32,16,0,857,858,5,264,0,0,858,905,1,0,0,0,859,860,3,86,43, + 0,860,861,3,32,16,0,861,862,5,28,0,0,862,863,3,32,16,0,863,864,5,75,0, + 0,864,865,3,32,16,0,865,866,5,28,0,0,866,867,3,32,16,0,867,905,1,0,0,0, + 868,869,3,86,43,0,869,870,3,32,16,0,870,871,5,263,0,0,871,905,1,0,0,0, + 872,873,3,86,43,0,873,874,3,32,16,0,874,875,5,75,0,0,875,876,3,32,16,0, + 876,877,5,263,0,0,877,905,1,0,0,0,878,879,3,86,43,0,879,880,3,32,16,0, + 880,881,5,75,0,0,881,882,3,32,16,0,882,883,5,28,0,0,883,884,3,32,16,0, + 884,885,5,263,0,0,885,905,1,0,0,0,886,887,3,86,43,0,887,888,3,32,16,0, + 888,889,5,28,0,0,889,890,3,32,16,0,890,891,5,75,0,0,891,892,3,32,16,0, + 892,893,5,263,0,0,893,905,1,0,0,0,894,895,3,86,43,0,895,896,3,32,16,0, + 896,897,5,28,0,0,897,898,3,32,16,0,898,899,5,75,0,0,899,900,3,32,16,0, + 900,901,5,28,0,0,901,902,3,32,16,0,902,903,5,263,0,0,903,905,1,0,0,0,904, + 801,1,0,0,0,904,805,1,0,0,0,904,808,1,0,0,0,904,814,1,0,0,0,904,819,1, + 0,0,0,904,827,1,0,0,0,904,834,1,0,0,0,904,842,1,0,0,0,904,849,1,0,0,0, + 904,859,1,0,0,0,904,868,1,0,0,0,904,872,1,0,0,0,904,878,1,0,0,0,904,886, + 1,0,0,0,904,894,1,0,0,0,905,89,1,0,0,0,906,910,5,21,0,0,907,909,3,92,46, + 0,908,907,1,0,0,0,909,912,1,0,0,0,910,908,1,0,0,0,910,911,1,0,0,0,911, + 913,1,0,0,0,912,910,1,0,0,0,913,914,3,2,1,0,914,915,3,94,47,0,915,916, + 5,180,0,0,916,917,5,36,0,0,917,918,5,30,0,0,918,919,3,312,156,0,919,920, + 5,31,0,0,920,921,3,94,47,0,921,933,1,0,0,0,922,926,5,21,0,0,923,925,3, + 92,46,0,924,923,1,0,0,0,925,928,1,0,0,0,926,924,1,0,0,0,926,927,1,0,0, + 0,927,929,1,0,0,0,928,926,1,0,0,0,929,930,3,2,1,0,930,931,3,94,47,0,931, + 933,1,0,0,0,932,906,1,0,0,0,932,922,1,0,0,0,933,91,1,0,0,0,934,935,5,76, + 0,0,935,93,1,0,0,0,936,939,1,0,0,0,937,939,5,298,0,0,938,936,1,0,0,0,938, + 937,1,0,0,0,939,95,1,0,0,0,940,941,7,6,0,0,941,97,1,0,0,0,942,944,3,96, + 48,0,943,942,1,0,0,0,944,947,1,0,0,0,945,943,1,0,0,0,945,946,1,0,0,0,946, + 99,1,0,0,0,947,945,1,0,0,0,948,949,5,275,0,0,949,101,1,0,0,0,950,951,5, + 276,0,0,951,103,1,0,0,0,952,953,5,277,0,0,953,105,1,0,0,0,954,955,5,278, + 0,0,955,107,1,0,0,0,956,957,5,279,0,0,957,109,1,0,0,0,958,959,5,282,0, + 0,959,111,1,0,0,0,960,961,5,280,0,0,961,113,1,0,0,0,962,963,5,286,0,0, + 963,115,1,0,0,0,964,965,5,284,0,0,965,117,1,0,0,0,966,967,5,285,0,0,967, + 119,1,0,0,0,968,969,5,281,0,0,969,121,1,0,0,0,970,971,5,287,0,0,971,123, + 1,0,0,0,972,973,5,283,0,0,973,125,1,0,0,0,974,1057,3,100,50,0,975,976, + 3,102,51,0,976,977,3,32,16,0,977,1057,1,0,0,0,978,979,3,102,51,0,979,980, + 3,0,0,0,980,1057,1,0,0,0,981,982,3,104,52,0,982,983,3,32,16,0,983,1057, + 1,0,0,0,984,985,3,106,53,0,985,986,3,34,17,0,986,1057,1,0,0,0,987,988, + 3,108,54,0,988,989,3,36,18,0,989,1057,1,0,0,0,990,991,3,108,54,0,991,992, + 3,34,17,0,992,1057,1,0,0,0,993,994,3,108,54,0,994,995,5,30,0,0,995,996, + 3,312,156,0,996,997,5,31,0,0,997,1057,1,0,0,0,998,999,3,108,54,0,999,1000, + 5,84,0,0,1000,1001,5,30,0,0,1001,1002,3,312,156,0,1002,1003,5,31,0,0,1003, + 1057,1,0,0,0,1004,1005,3,110,55,0,1005,1006,3,32,16,0,1006,1057,1,0,0, + 0,1007,1008,3,110,55,0,1008,1009,3,0,0,0,1009,1057,1,0,0,0,1010,1011,3, + 112,56,0,1011,1012,3,190,95,0,1012,1057,1,0,0,0,1013,1014,3,114,57,0,1014, + 1015,3,200,100,0,1015,1057,1,0,0,0,1016,1017,3,114,57,0,1017,1018,3,196, + 98,0,1018,1057,1,0,0,0,1019,1020,3,116,58,0,1020,1021,3,146,73,0,1021, + 1057,1,0,0,0,1022,1023,3,118,59,0,1023,1024,3,6,3,0,1024,1057,1,0,0,0, + 1025,1026,3,118,59,0,1026,1027,5,224,0,0,1027,1028,5,30,0,0,1028,1029, + 3,6,3,0,1029,1030,5,31,0,0,1030,1057,1,0,0,0,1031,1032,3,118,59,0,1032, + 1033,5,84,0,0,1033,1034,5,30,0,0,1034,1035,3,312,156,0,1035,1036,5,31, + 0,0,1036,1057,1,0,0,0,1037,1038,3,120,60,0,1038,1039,3,192,96,0,1039,1040, + 3,160,80,0,1040,1041,3,134,67,0,1041,1057,1,0,0,0,1042,1043,3,122,61,0, + 1043,1044,3,50,25,0,1044,1057,1,0,0,0,1045,1046,3,122,61,0,1046,1047,3, + 32,16,0,1047,1057,1,0,0,0,1048,1049,3,124,62,0,1049,1050,5,30,0,0,1050, + 1051,3,128,64,0,1051,1052,5,31,0,0,1052,1057,1,0,0,0,1053,1054,3,124,62, + 0,1054,1055,5,85,0,0,1055,1057,1,0,0,0,1056,974,1,0,0,0,1056,975,1,0,0, + 0,1056,978,1,0,0,0,1056,981,1,0,0,0,1056,984,1,0,0,0,1056,987,1,0,0,0, + 1056,990,1,0,0,0,1056,993,1,0,0,0,1056,998,1,0,0,0,1056,1004,1,0,0,0,1056, + 1007,1,0,0,0,1056,1010,1,0,0,0,1056,1013,1,0,0,0,1056,1016,1,0,0,0,1056, + 1019,1,0,0,0,1056,1022,1,0,0,0,1056,1025,1,0,0,0,1056,1031,1,0,0,0,1056, + 1037,1,0,0,0,1056,1042,1,0,0,0,1056,1045,1,0,0,0,1056,1048,1,0,0,0,1056, + 1053,1,0,0,0,1057,127,1,0,0,0,1058,1075,1,0,0,0,1059,1062,3,0,0,0,1060, + 1062,3,32,16,0,1061,1059,1,0,0,0,1061,1060,1,0,0,0,1062,1063,1,0,0,0,1063, + 1064,5,28,0,0,1064,1066,1,0,0,0,1065,1061,1,0,0,0,1066,1069,1,0,0,0,1067, + 1065,1,0,0,0,1067,1068,1,0,0,0,1068,1072,1,0,0,0,1069,1067,1,0,0,0,1070, + 1073,3,0,0,0,1071,1073,3,32,16,0,1072,1070,1,0,0,0,1072,1071,1,0,0,0,1073, + 1075,1,0,0,0,1074,1058,1,0,0,0,1074,1067,1,0,0,0,1075,129,1,0,0,0,1076, + 1082,5,86,0,0,1077,1078,3,160,80,0,1078,1079,5,28,0,0,1079,1081,1,0,0, + 0,1080,1077,1,0,0,0,1081,1084,1,0,0,0,1082,1080,1,0,0,0,1082,1083,1,0, + 0,0,1083,1085,1,0,0,0,1084,1082,1,0,0,0,1085,1086,3,160,80,0,1086,1087, + 5,87,0,0,1087,131,1,0,0,0,1088,1094,5,42,0,0,1089,1090,3,168,84,0,1090, + 1091,5,28,0,0,1091,1093,1,0,0,0,1092,1089,1,0,0,0,1093,1096,1,0,0,0,1094, + 1092,1,0,0,0,1094,1095,1,0,0,0,1095,1097,1,0,0,0,1096,1094,1,0,0,0,1097, + 1098,3,168,84,0,1098,1099,5,43,0,0,1099,133,1,0,0,0,1100,1106,5,30,0,0, + 1101,1102,3,136,68,0,1102,1103,5,28,0,0,1103,1105,1,0,0,0,1104,1101,1, + 0,0,0,1105,1108,1,0,0,0,1106,1104,1,0,0,0,1106,1107,1,0,0,0,1107,1109, + 1,0,0,0,1108,1106,1,0,0,0,1109,1110,3,136,68,0,1110,1111,5,31,0,0,1111, + 1114,1,0,0,0,1112,1114,5,85,0,0,1113,1100,1,0,0,0,1113,1112,1,0,0,0,1114, + 135,1,0,0,0,1115,1123,5,177,0,0,1116,1117,3,252,126,0,1117,1118,3,160, + 80,0,1118,1120,3,248,124,0,1119,1121,3,0,0,0,1120,1119,1,0,0,0,1120,1121, + 1,0,0,0,1121,1123,1,0,0,0,1122,1115,1,0,0,0,1122,1116,1,0,0,0,1123,137, + 1,0,0,0,1124,1125,5,42,0,0,1125,1126,3,2,1,0,1126,1127,5,43,0,0,1127,1128, + 3,140,70,0,1128,1150,1,0,0,0,1129,1130,5,42,0,0,1130,1131,3,196,98,0,1131, + 1132,5,43,0,0,1132,1133,3,140,70,0,1133,1150,1,0,0,0,1134,1135,5,42,0, + 0,1135,1136,5,262,0,0,1136,1137,5,43,0,0,1137,1150,3,140,70,0,1138,1139, + 5,42,0,0,1139,1140,5,198,0,0,1140,1141,3,2,1,0,1141,1142,5,43,0,0,1142, + 1143,3,140,70,0,1143,1150,1,0,0,0,1144,1150,3,140,70,0,1145,1150,3,196, + 98,0,1146,1150,5,257,0,0,1147,1150,5,258,0,0,1148,1150,5,259,0,0,1149, + 1124,1,0,0,0,1149,1129,1,0,0,0,1149,1134,1,0,0,0,1149,1138,1,0,0,0,1149, + 1144,1,0,0,0,1149,1145,1,0,0,0,1149,1146,1,0,0,0,1149,1147,1,0,0,0,1149, + 1148,1,0,0,0,1150,139,1,0,0,0,1151,1152,3,2,1,0,1152,1153,5,88,0,0,1153, + 1155,1,0,0,0,1154,1151,1,0,0,0,1155,1158,1,0,0,0,1156,1154,1,0,0,0,1156, + 1157,1,0,0,0,1157,1159,1,0,0,0,1158,1156,1,0,0,0,1159,1160,3,2,1,0,1160, + 141,1,0,0,0,1161,1163,3,144,72,0,1162,1161,1,0,0,0,1163,1166,1,0,0,0,1164, + 1162,1,0,0,0,1164,1165,1,0,0,0,1165,143,1,0,0,0,1166,1164,1,0,0,0,1167, + 1168,5,180,0,0,1168,1169,5,89,0,0,1169,1173,3,32,16,0,1170,1173,3,174, + 87,0,1171,1173,3,344,172,0,1172,1167,1,0,0,0,1172,1170,1,0,0,0,1172,1171, + 1,0,0,0,1173,145,1,0,0,0,1174,1186,3,138,69,0,1175,1176,5,42,0,0,1176, + 1177,3,2,1,0,1177,1178,5,43,0,0,1178,1186,1,0,0,0,1179,1180,5,42,0,0,1180, + 1181,5,198,0,0,1181,1182,3,2,1,0,1182,1183,5,43,0,0,1183,1186,1,0,0,0, + 1184,1186,3,160,80,0,1185,1174,1,0,0,0,1185,1175,1,0,0,0,1185,1179,1,0, + 0,0,1185,1184,1,0,0,0,1186,147,1,0,0,0,1187,1196,1,0,0,0,1188,1192,3,152, + 76,0,1189,1191,3,150,75,0,1190,1189,1,0,0,0,1191,1194,1,0,0,0,1192,1190, + 1,0,0,0,1192,1193,1,0,0,0,1193,1196,1,0,0,0,1194,1192,1,0,0,0,1195,1187, + 1,0,0,0,1195,1188,1,0,0,0,1196,149,1,0,0,0,1197,1215,5,262,0,0,1198,1215, + 5,261,0,0,1199,1200,5,42,0,0,1200,1201,3,32,16,0,1201,1202,5,43,0,0,1202, + 1215,1,0,0,0,1203,1204,5,42,0,0,1204,1205,3,32,16,0,1205,1206,5,266,0, + 0,1206,1207,3,32,16,0,1207,1208,5,43,0,0,1208,1215,1,0,0,0,1209,1210,5, + 42,0,0,1210,1211,5,266,0,0,1211,1212,3,32,16,0,1212,1213,5,43,0,0,1213, + 1215,1,0,0,0,1214,1197,1,0,0,0,1214,1198,1,0,0,0,1214,1199,1,0,0,0,1214, + 1203,1,0,0,0,1214,1209,1,0,0,0,1215,151,1,0,0,0,1216,1309,1,0,0,0,1217, + 1218,5,203,0,0,1218,1219,5,30,0,0,1219,1220,3,6,3,0,1220,1221,5,28,0,0, + 1221,1222,3,6,3,0,1222,1223,5,28,0,0,1223,1224,3,6,3,0,1224,1225,5,28, + 0,0,1225,1226,3,6,3,0,1226,1227,5,31,0,0,1227,1309,1,0,0,0,1228,1229,5, + 203,0,0,1229,1230,5,30,0,0,1230,1231,3,6,3,0,1231,1232,5,28,0,0,1232,1233, + 3,6,3,0,1233,1234,5,31,0,0,1234,1309,1,0,0,0,1235,1236,5,204,0,0,1236, + 1237,5,205,0,0,1237,1238,5,42,0,0,1238,1239,3,32,16,0,1239,1240,5,43,0, + 0,1240,1309,1,0,0,0,1241,1242,5,204,0,0,1242,1243,5,206,0,0,1243,1244, + 5,42,0,0,1244,1245,3,32,16,0,1245,1246,5,43,0,0,1246,1247,3,148,74,0,1247, + 1309,1,0,0,0,1248,1309,5,207,0,0,1249,1309,5,208,0,0,1250,1309,5,209,0, + 0,1251,1309,5,201,0,0,1252,1309,5,183,0,0,1253,1309,5,184,0,0,1254,1309, + 5,185,0,0,1255,1309,5,186,0,0,1256,1309,5,187,0,0,1257,1309,5,188,0,0, + 1258,1309,5,189,0,0,1259,1309,5,210,0,0,1260,1309,5,190,0,0,1261,1309, + 5,191,0,0,1262,1309,5,192,0,0,1263,1309,5,193,0,0,1264,1309,5,211,0,0, + 1265,1309,5,212,0,0,1266,1309,5,213,0,0,1267,1309,5,214,0,0,1268,1309, + 5,215,0,0,1269,1309,5,216,0,0,1270,1309,5,217,0,0,1271,1272,5,218,0,0, + 1272,1309,3,154,77,0,1273,1274,5,219,0,0,1274,1309,3,154,77,0,1275,1309, + 5,220,0,0,1276,1277,5,221,0,0,1277,1309,3,154,77,0,1278,1279,5,222,0,0, + 1279,1309,3,156,78,0,1280,1281,5,222,0,0,1281,1282,3,156,78,0,1282,1283, + 5,28,0,0,1283,1284,3,6,3,0,1284,1309,1,0,0,0,1285,1309,5,194,0,0,1286, + 1309,5,195,0,0,1287,1288,5,90,0,0,1288,1309,5,184,0,0,1289,1290,5,90,0, + 0,1290,1309,5,185,0,0,1291,1292,5,90,0,0,1292,1309,5,186,0,0,1293,1294, + 5,90,0,0,1294,1309,5,187,0,0,1295,1296,5,62,0,0,1296,1309,5,220,0,0,1297, + 1309,5,223,0,0,1298,1299,5,224,0,0,1299,1309,5,213,0,0,1300,1309,5,225, + 0,0,1301,1302,5,207,0,0,1302,1309,5,183,0,0,1303,1309,5,226,0,0,1304,1309, + 5,228,0,0,1305,1306,5,34,0,0,1306,1309,5,227,0,0,1307,1309,3,2,1,0,1308, + 1216,1,0,0,0,1308,1217,1,0,0,0,1308,1228,1,0,0,0,1308,1235,1,0,0,0,1308, + 1241,1,0,0,0,1308,1248,1,0,0,0,1308,1249,1,0,0,0,1308,1250,1,0,0,0,1308, + 1251,1,0,0,0,1308,1252,1,0,0,0,1308,1253,1,0,0,0,1308,1254,1,0,0,0,1308, + 1255,1,0,0,0,1308,1256,1,0,0,0,1308,1257,1,0,0,0,1308,1258,1,0,0,0,1308, + 1259,1,0,0,0,1308,1260,1,0,0,0,1308,1261,1,0,0,0,1308,1262,1,0,0,0,1308, + 1263,1,0,0,0,1308,1264,1,0,0,0,1308,1265,1,0,0,0,1308,1266,1,0,0,0,1308, + 1267,1,0,0,0,1308,1268,1,0,0,0,1308,1269,1,0,0,0,1308,1270,1,0,0,0,1308, + 1271,1,0,0,0,1308,1273,1,0,0,0,1308,1275,1,0,0,0,1308,1276,1,0,0,0,1308, + 1278,1,0,0,0,1308,1280,1,0,0,0,1308,1285,1,0,0,0,1308,1286,1,0,0,0,1308, + 1287,1,0,0,0,1308,1289,1,0,0,0,1308,1291,1,0,0,0,1308,1293,1,0,0,0,1308, + 1295,1,0,0,0,1308,1297,1,0,0,0,1308,1298,1,0,0,0,1308,1300,1,0,0,0,1308, + 1301,1,0,0,0,1308,1303,1,0,0,0,1308,1304,1,0,0,0,1308,1305,1,0,0,0,1308, + 1307,1,0,0,0,1309,153,1,0,0,0,1310,1318,1,0,0,0,1311,1312,5,30,0,0,1312, + 1313,5,91,0,0,1313,1314,5,36,0,0,1314,1315,3,32,16,0,1315,1316,5,31,0, + 0,1316,1318,1,0,0,0,1317,1310,1,0,0,0,1317,1311,1,0,0,0,1318,155,1,0,0, + 0,1319,1328,1,0,0,0,1320,1324,3,158,79,0,1321,1323,7,7,0,0,1322,1321,1, + 0,0,0,1323,1326,1,0,0,0,1324,1322,1,0,0,0,1324,1325,1,0,0,0,1325,1328, + 1,0,0,0,1326,1324,1,0,0,0,1327,1319,1,0,0,0,1327,1320,1,0,0,0,1328,157, + 1,0,0,0,1329,1330,7,8,0,0,1330,159,1,0,0,0,1331,1335,3,164,82,0,1332,1334, + 3,162,81,0,1333,1332,1,0,0,0,1334,1337,1,0,0,0,1335,1333,1,0,0,0,1335, + 1336,1,0,0,0,1336,161,1,0,0,0,1337,1335,1,0,0,0,1338,1357,5,261,0,0,1339, + 1340,5,42,0,0,1340,1357,5,43,0,0,1341,1357,3,132,66,0,1342,1357,5,260, + 0,0,1343,1357,5,262,0,0,1344,1357,5,92,0,0,1345,1346,5,93,0,0,1346,1347, + 5,30,0,0,1347,1348,3,146,73,0,1348,1349,5,31,0,0,1349,1357,1,0,0,0,1350, + 1351,5,94,0,0,1351,1352,5,30,0,0,1352,1353,3,146,73,0,1353,1354,5,31,0, + 0,1354,1357,1,0,0,0,1355,1357,3,130,65,0,1356,1338,1,0,0,0,1356,1339,1, + 0,0,0,1356,1341,1,0,0,0,1356,1342,1,0,0,0,1356,1343,1,0,0,0,1356,1344, + 1,0,0,0,1356,1345,1,0,0,0,1356,1350,1,0,0,0,1356,1355,1,0,0,0,1357,163, + 1,0,0,0,1358,1359,5,39,0,0,1359,1389,3,138,69,0,1360,1389,5,197,0,0,1361, + 1362,5,199,0,0,1362,1363,5,39,0,0,1363,1389,3,138,69,0,1364,1365,5,200, + 0,0,1365,1389,3,138,69,0,1366,1367,5,226,0,0,1367,1368,3,192,96,0,1368, + 1369,3,160,80,0,1369,1370,5,262,0,0,1370,1371,3,134,67,0,1371,1389,1,0, + 0,0,1372,1373,5,253,0,0,1373,1389,3,32,16,0,1374,1375,5,252,0,0,1375,1389, + 3,32,16,0,1376,1377,5,253,0,0,1377,1389,3,2,1,0,1378,1379,5,252,0,0,1379, + 1389,3,2,1,0,1380,1389,5,254,0,0,1381,1389,5,201,0,0,1382,1389,3,170,85, + 0,1383,1389,3,172,86,0,1384,1389,3,166,83,0,1385,1389,3,2,1,0,1386,1387, + 5,177,0,0,1387,1389,3,160,80,0,1388,1358,1,0,0,0,1388,1360,1,0,0,0,1388, + 1361,1,0,0,0,1388,1364,1,0,0,0,1388,1366,1,0,0,0,1388,1372,1,0,0,0,1388, + 1374,1,0,0,0,1388,1376,1,0,0,0,1388,1378,1,0,0,0,1388,1380,1,0,0,0,1388, + 1381,1,0,0,0,1388,1382,1,0,0,0,1388,1383,1,0,0,0,1388,1384,1,0,0,0,1388, + 1385,1,0,0,0,1388,1386,1,0,0,0,1389,165,1,0,0,0,1390,1412,5,181,0,0,1391, + 1412,5,182,0,0,1392,1412,5,183,0,0,1393,1412,5,184,0,0,1394,1412,5,185, + 0,0,1395,1412,5,186,0,0,1396,1412,5,187,0,0,1397,1412,5,188,0,0,1398,1412, 5,189,0,0,1399,1412,5,190,0,0,1400,1412,5,191,0,0,1401,1412,5,192,0,0, 1402,1412,5,193,0,0,1403,1404,5,90,0,0,1404,1412,5,184,0,0,1405,1406,5, 90,0,0,1406,1412,5,185,0,0,1407,1408,5,90,0,0,1408,1412,5,186,0,0,1409, @@ -18071,143 +18115,144 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 0,2508,2438,1,0,0,0,2508,2443,1,0,0,0,2508,2448,1,0,0,0,2508,2453,1,0, 0,0,2508,2458,1,0,0,0,2508,2463,1,0,0,0,2508,2468,1,0,0,0,2508,2473,1, 0,0,0,2508,2478,1,0,0,0,2508,2483,1,0,0,0,2508,2488,1,0,0,0,2508,2493, - 1,0,0,0,2508,2498,1,0,0,0,2508,2503,1,0,0,0,2509,311,1,0,0,0,2510,2512, - 3,314,157,0,2511,2510,1,0,0,0,2512,2515,1,0,0,0,2513,2511,1,0,0,0,2513, - 2514,1,0,0,0,2514,313,1,0,0,0,2515,2513,1,0,0,0,2516,2517,7,12,0,0,2517, - 315,1,0,0,0,2518,2522,3,310,155,0,2519,2522,3,6,3,0,2520,2522,5,179,0, - 0,2521,2518,1,0,0,0,2521,2519,1,0,0,0,2521,2520,1,0,0,0,2522,317,1,0,0, - 0,2523,2672,3,310,155,0,2524,2525,5,182,0,0,2525,2526,5,30,0,0,2526,2527, - 5,179,0,0,2527,2672,5,31,0,0,2528,2529,5,182,0,0,2529,2530,5,30,0,0,2530, - 2531,5,264,0,0,2531,2672,5,31,0,0,2532,2533,5,196,0,0,2533,2534,5,30,0, - 0,2534,2535,5,39,0,0,2535,2536,5,264,0,0,2536,2672,5,31,0,0,2537,2538, - 5,196,0,0,2538,2539,5,30,0,0,2539,2540,3,138,69,0,2540,2541,5,31,0,0,2541, - 2672,1,0,0,0,2542,2543,5,196,0,0,2543,2544,5,30,0,0,2544,2545,5,179,0, - 0,2545,2672,5,31,0,0,2546,2547,5,197,0,0,2547,2548,5,30,0,0,2548,2549, - 3,318,159,0,2549,2550,5,31,0,0,2550,2672,1,0,0,0,2551,2552,5,188,0,0,2552, - 2553,5,42,0,0,2553,2554,3,32,16,0,2554,2555,5,43,0,0,2555,2556,5,30,0, - 0,2556,2557,3,320,160,0,2557,2558,5,31,0,0,2558,2672,1,0,0,0,2559,2560, - 5,189,0,0,2560,2561,5,42,0,0,2561,2562,3,32,16,0,2562,2563,5,43,0,0,2563, - 2564,5,30,0,0,2564,2565,3,322,161,0,2565,2566,5,31,0,0,2566,2672,1,0,0, - 0,2567,2568,5,187,0,0,2568,2569,5,42,0,0,2569,2570,3,32,16,0,2570,2571, - 5,43,0,0,2571,2572,5,30,0,0,2572,2573,3,324,162,0,2573,2574,5,31,0,0,2574, - 2672,1,0,0,0,2575,2576,5,186,0,0,2576,2577,5,42,0,0,2577,2578,3,32,16, - 0,2578,2579,5,43,0,0,2579,2580,5,30,0,0,2580,2581,3,326,163,0,2581,2582, - 5,31,0,0,2582,2672,1,0,0,0,2583,2584,5,185,0,0,2584,2585,5,42,0,0,2585, - 2586,3,32,16,0,2586,2587,5,43,0,0,2587,2588,5,30,0,0,2588,2589,3,328,164, - 0,2589,2590,5,31,0,0,2590,2672,1,0,0,0,2591,2592,5,184,0,0,2592,2593,5, - 42,0,0,2593,2594,3,32,16,0,2594,2595,5,43,0,0,2595,2596,5,30,0,0,2596, - 2597,3,330,165,0,2597,2598,5,31,0,0,2598,2672,1,0,0,0,2599,2600,5,193, - 0,0,2600,2601,5,42,0,0,2601,2602,3,32,16,0,2602,2603,5,43,0,0,2603,2604, - 5,30,0,0,2604,2605,3,324,162,0,2605,2606,5,31,0,0,2606,2672,1,0,0,0,2607, - 2608,5,192,0,0,2608,2609,5,42,0,0,2609,2610,3,32,16,0,2610,2611,5,43,0, - 0,2611,2612,5,30,0,0,2612,2613,3,326,163,0,2613,2614,5,31,0,0,2614,2672, - 1,0,0,0,2615,2616,5,191,0,0,2616,2617,5,42,0,0,2617,2618,3,32,16,0,2618, - 2619,5,43,0,0,2619,2620,5,30,0,0,2620,2621,3,328,164,0,2621,2622,5,31, - 0,0,2622,2672,1,0,0,0,2623,2624,5,190,0,0,2624,2625,5,42,0,0,2625,2626, - 3,32,16,0,2626,2627,5,43,0,0,2627,2628,5,30,0,0,2628,2629,3,330,165,0, - 2629,2630,5,31,0,0,2630,2672,1,0,0,0,2631,2632,5,181,0,0,2632,2633,5,42, - 0,0,2633,2634,3,32,16,0,2634,2635,5,43,0,0,2635,2636,5,30,0,0,2636,2637, - 3,328,164,0,2637,2638,5,31,0,0,2638,2672,1,0,0,0,2639,2640,5,183,0,0,2640, - 2641,5,42,0,0,2641,2642,3,32,16,0,2642,2643,5,43,0,0,2643,2644,5,30,0, - 0,2644,2645,3,332,166,0,2645,2646,5,31,0,0,2646,2672,1,0,0,0,2647,2648, - 5,182,0,0,2648,2649,5,42,0,0,2649,2650,3,32,16,0,2650,2651,5,43,0,0,2651, - 2652,5,30,0,0,2652,2653,3,334,167,0,2653,2654,5,31,0,0,2654,2672,1,0,0, - 0,2655,2656,5,196,0,0,2656,2657,5,42,0,0,2657,2658,3,32,16,0,2658,2659, - 5,43,0,0,2659,2660,5,30,0,0,2660,2661,3,336,168,0,2661,2662,5,31,0,0,2662, - 2672,1,0,0,0,2663,2664,5,197,0,0,2664,2665,5,42,0,0,2665,2666,3,32,16, - 0,2666,2667,5,43,0,0,2667,2668,5,30,0,0,2668,2669,3,340,170,0,2669,2670, - 5,31,0,0,2670,2672,1,0,0,0,2671,2523,1,0,0,0,2671,2524,1,0,0,0,2671,2528, - 1,0,0,0,2671,2532,1,0,0,0,2671,2537,1,0,0,0,2671,2542,1,0,0,0,2671,2546, - 1,0,0,0,2671,2551,1,0,0,0,2671,2559,1,0,0,0,2671,2567,1,0,0,0,2671,2575, - 1,0,0,0,2671,2583,1,0,0,0,2671,2591,1,0,0,0,2671,2599,1,0,0,0,2671,2607, - 1,0,0,0,2671,2615,1,0,0,0,2671,2623,1,0,0,0,2671,2631,1,0,0,0,2671,2639, - 1,0,0,0,2671,2647,1,0,0,0,2671,2655,1,0,0,0,2671,2663,1,0,0,0,2672,319, - 1,0,0,0,2673,2676,3,36,18,0,2674,2676,3,32,16,0,2675,2673,1,0,0,0,2675, - 2674,1,0,0,0,2676,2679,1,0,0,0,2677,2675,1,0,0,0,2677,2678,1,0,0,0,2678, - 321,1,0,0,0,2679,2677,1,0,0,0,2680,2683,3,36,18,0,2681,2683,3,34,17,0, - 2682,2680,1,0,0,0,2682,2681,1,0,0,0,2683,2686,1,0,0,0,2684,2682,1,0,0, - 0,2684,2685,1,0,0,0,2685,323,1,0,0,0,2686,2684,1,0,0,0,2687,2689,3,34, - 17,0,2688,2687,1,0,0,0,2689,2692,1,0,0,0,2690,2688,1,0,0,0,2690,2691,1, - 0,0,0,2691,325,1,0,0,0,2692,2690,1,0,0,0,2693,2695,3,32,16,0,2694,2693, - 1,0,0,0,2695,2698,1,0,0,0,2696,2694,1,0,0,0,2696,2697,1,0,0,0,2697,327, - 1,0,0,0,2698,2696,1,0,0,0,2699,2701,3,32,16,0,2700,2699,1,0,0,0,2701,2704, - 1,0,0,0,2702,2700,1,0,0,0,2702,2703,1,0,0,0,2703,329,1,0,0,0,2704,2702, - 1,0,0,0,2705,2707,3,32,16,0,2706,2705,1,0,0,0,2707,2710,1,0,0,0,2708,2706, - 1,0,0,0,2708,2709,1,0,0,0,2709,331,1,0,0,0,2710,2708,1,0,0,0,2711,2713, - 3,184,92,0,2712,2711,1,0,0,0,2713,2716,1,0,0,0,2714,2712,1,0,0,0,2714, - 2715,1,0,0,0,2715,333,1,0,0,0,2716,2714,1,0,0,0,2717,2719,7,13,0,0,2718, - 2717,1,0,0,0,2719,2722,1,0,0,0,2720,2718,1,0,0,0,2720,2721,1,0,0,0,2721, - 335,1,0,0,0,2722,2720,1,0,0,0,2723,2725,3,338,169,0,2724,2723,1,0,0,0, - 2725,2728,1,0,0,0,2726,2724,1,0,0,0,2726,2727,1,0,0,0,2727,337,1,0,0,0, - 2728,2726,1,0,0,0,2729,2734,5,179,0,0,2730,2731,5,39,0,0,2731,2734,5,264, - 0,0,2732,2734,3,138,69,0,2733,2729,1,0,0,0,2733,2730,1,0,0,0,2733,2732, - 1,0,0,0,2734,339,1,0,0,0,2735,2737,3,318,159,0,2736,2735,1,0,0,0,2737, - 2740,1,0,0,0,2738,2736,1,0,0,0,2738,2739,1,0,0,0,2739,341,1,0,0,0,2740, - 2738,1,0,0,0,2741,2745,3,44,22,0,2742,2745,3,46,23,0,2743,2745,3,2,1,0, - 2744,2741,1,0,0,0,2744,2742,1,0,0,0,2744,2743,1,0,0,0,2745,343,1,0,0,0, - 2746,2747,7,14,0,0,2747,2748,5,36,0,0,2748,2749,5,30,0,0,2749,2750,3,312, - 156,0,2750,2751,5,31,0,0,2751,2772,1,0,0,0,2752,2753,5,169,0,0,2753,2754, - 3,38,19,0,2754,2755,5,75,0,0,2755,2756,3,38,19,0,2756,2757,5,75,0,0,2757, - 2758,3,38,19,0,2758,2759,5,75,0,0,2759,2760,3,38,19,0,2760,2772,1,0,0, - 0,2761,2762,5,170,0,0,2762,2772,3,6,3,0,2763,2764,5,170,0,0,2764,2765, - 5,36,0,0,2765,2766,5,30,0,0,2766,2767,3,312,156,0,2767,2768,5,31,0,0,2768, - 2772,1,0,0,0,2769,2772,3,342,171,0,2770,2772,3,40,20,0,2771,2746,1,0,0, - 0,2771,2752,1,0,0,0,2771,2761,1,0,0,0,2771,2763,1,0,0,0,2771,2769,1,0, - 0,0,2771,2770,1,0,0,0,2772,345,1,0,0,0,2773,2774,5,25,0,0,2774,2775,5, - 40,0,0,2775,2776,3,98,49,0,2776,2777,3,2,1,0,2777,2786,1,0,0,0,2778,2779, - 5,25,0,0,2779,2780,5,40,0,0,2780,2781,3,98,49,0,2781,2782,3,2,1,0,2782, - 2783,5,34,0,0,2783,2784,3,2,1,0,2784,2786,1,0,0,0,2785,2773,1,0,0,0,2785, - 2778,1,0,0,0,2786,347,1,0,0,0,2787,2789,3,350,175,0,2788,2787,1,0,0,0, - 2789,2792,1,0,0,0,2790,2788,1,0,0,0,2790,2791,1,0,0,0,2791,349,1,0,0,0, - 2792,2790,1,0,0,0,2793,2794,5,180,0,0,2794,2795,5,36,0,0,2795,2796,5,30, - 0,0,2796,2797,3,312,156,0,2797,2798,5,31,0,0,2798,2808,1,0,0,0,2799,2808, - 3,344,172,0,2800,2801,5,171,0,0,2801,2802,5,36,0,0,2802,2803,5,30,0,0, - 2803,2804,3,312,156,0,2804,2805,5,31,0,0,2805,2808,1,0,0,0,2806,2808,5, - 55,0,0,2807,2793,1,0,0,0,2807,2799,1,0,0,0,2807,2800,1,0,0,0,2807,2806, - 1,0,0,0,2808,351,1,0,0,0,2809,2810,5,50,0,0,2810,2814,5,40,0,0,2811,2813, - 3,356,178,0,2812,2811,1,0,0,0,2813,2816,1,0,0,0,2814,2812,1,0,0,0,2814, - 2815,1,0,0,0,2815,2817,1,0,0,0,2816,2814,1,0,0,0,2817,2818,3,2,1,0,2818, - 353,1,0,0,0,2819,2823,5,301,0,0,2820,2822,3,356,178,0,2821,2820,1,0,0, - 0,2822,2825,1,0,0,0,2823,2821,1,0,0,0,2823,2824,1,0,0,0,2824,2826,1,0, - 0,0,2825,2823,1,0,0,0,2826,2827,3,2,1,0,2827,355,1,0,0,0,2828,2844,5,52, - 0,0,2829,2844,5,51,0,0,2830,2844,5,172,0,0,2831,2832,5,62,0,0,2832,2844, - 5,51,0,0,2833,2834,5,62,0,0,2834,2844,5,52,0,0,2835,2836,5,62,0,0,2836, - 2844,5,63,0,0,2837,2838,5,62,0,0,2838,2844,5,64,0,0,2839,2840,5,62,0,0, - 2840,2844,5,65,0,0,2841,2842,5,62,0,0,2842,2844,5,66,0,0,2843,2828,1,0, - 0,0,2843,2829,1,0,0,0,2843,2830,1,0,0,0,2843,2831,1,0,0,0,2843,2833,1, - 0,0,0,2843,2835,1,0,0,0,2843,2837,1,0,0,0,2843,2839,1,0,0,0,2843,2841, - 1,0,0,0,2844,357,1,0,0,0,2845,2847,3,360,180,0,2846,2845,1,0,0,0,2847, - 2850,1,0,0,0,2848,2846,1,0,0,0,2848,2849,1,0,0,0,2849,359,1,0,0,0,2850, - 2848,1,0,0,0,2851,2852,5,21,0,0,2852,2865,3,2,1,0,2853,2854,5,50,0,0,2854, - 2855,5,40,0,0,2855,2865,3,140,70,0,2856,2857,5,25,0,0,2857,2858,5,40,0, - 0,2858,2865,3,2,1,0,2859,2865,3,196,98,0,2860,2861,5,50,0,0,2861,2865, - 3,32,16,0,2862,2865,3,342,171,0,2863,2865,3,40,20,0,2864,2851,1,0,0,0, - 2864,2853,1,0,0,0,2864,2856,1,0,0,0,2864,2859,1,0,0,0,2864,2860,1,0,0, - 0,2864,2862,1,0,0,0,2864,2863,1,0,0,0,2865,361,1,0,0,0,2866,2870,5,274, - 0,0,2867,2869,3,364,182,0,2868,2867,1,0,0,0,2869,2872,1,0,0,0,2870,2868, - 1,0,0,0,2870,2871,1,0,0,0,2871,2873,1,0,0,0,2872,2870,1,0,0,0,2873,2886, - 3,2,1,0,2874,2878,5,274,0,0,2875,2877,3,364,182,0,2876,2875,1,0,0,0,2877, - 2880,1,0,0,0,2878,2876,1,0,0,0,2878,2879,1,0,0,0,2879,2881,1,0,0,0,2880, - 2878,1,0,0,0,2881,2882,3,2,1,0,2882,2883,5,34,0,0,2883,2884,3,2,1,0,2884, - 2886,1,0,0,0,2885,2866,1,0,0,0,2885,2874,1,0,0,0,2886,363,1,0,0,0,2887, - 2888,7,15,0,0,2888,365,1,0,0,0,2889,2891,3,368,184,0,2890,2889,1,0,0,0, - 2891,2894,1,0,0,0,2892,2890,1,0,0,0,2892,2893,1,0,0,0,2893,367,1,0,0,0, - 2894,2892,1,0,0,0,2895,2896,5,21,0,0,2896,2897,3,2,1,0,2897,2898,5,44, - 0,0,2898,2899,3,32,16,0,2899,2906,1,0,0,0,2900,2901,5,25,0,0,2901,2902, - 5,40,0,0,2902,2906,3,2,1,0,2903,2906,3,342,171,0,2904,2906,3,40,20,0,2905, - 2895,1,0,0,0,2905,2900,1,0,0,0,2905,2903,1,0,0,0,2905,2904,1,0,0,0,2906, - 369,1,0,0,0,172,378,383,391,399,452,493,502,526,530,548,575,598,634,640, - 647,649,659,661,668,679,687,708,710,726,771,776,781,786,794,904,910,926, - 932,938,945,1056,1061,1067,1072,1074,1082,1094,1106,1113,1120,1122,1149, - 1156,1164,1172,1185,1192,1195,1214,1308,1317,1324,1327,1335,1356,1388, - 1411,1423,1432,1457,1481,1489,1493,1508,1515,1560,1570,1586,1598,1610, - 1624,1636,1647,1654,1664,1677,1682,1687,1696,1707,1790,1799,1812,1823, - 1831,1841,1843,1870,1877,1882,1889,1895,1905,1909,1916,1931,1937,1951, - 1964,1972,1979,1983,1988,2004,2009,2011,2024,2050,2057,2059,2064,2070, - 2099,2104,2127,2132,2196,2205,2218,2229,2240,2243,2250,2262,2276,2290, - 2298,2318,2330,2335,2344,2346,2353,2363,2431,2508,2513,2521,2671,2675, - 2677,2682,2684,2690,2696,2702,2708,2714,2720,2726,2733,2738,2744,2771, - 2785,2790,2807,2814,2823,2843,2848,2864,2870,2878,2885,2892,2905 + 1,0,0,0,2508,2498,1,0,0,0,2508,2503,1,0,0,0,2509,311,1,0,0,0,2510,2511, + 3,314,157,0,2511,2512,6,156,-1,0,2512,2514,1,0,0,0,2513,2510,1,0,0,0,2514, + 2517,1,0,0,0,2515,2513,1,0,0,0,2515,2516,1,0,0,0,2516,313,1,0,0,0,2517, + 2515,1,0,0,0,2518,2519,7,12,0,0,2519,315,1,0,0,0,2520,2524,3,310,155,0, + 2521,2524,3,6,3,0,2522,2524,5,179,0,0,2523,2520,1,0,0,0,2523,2521,1,0, + 0,0,2523,2522,1,0,0,0,2524,317,1,0,0,0,2525,2674,3,310,155,0,2526,2527, + 5,182,0,0,2527,2528,5,30,0,0,2528,2529,5,179,0,0,2529,2674,5,31,0,0,2530, + 2531,5,182,0,0,2531,2532,5,30,0,0,2532,2533,5,264,0,0,2533,2674,5,31,0, + 0,2534,2535,5,196,0,0,2535,2536,5,30,0,0,2536,2537,5,39,0,0,2537,2538, + 5,264,0,0,2538,2674,5,31,0,0,2539,2540,5,196,0,0,2540,2541,5,30,0,0,2541, + 2542,3,138,69,0,2542,2543,5,31,0,0,2543,2674,1,0,0,0,2544,2545,5,196,0, + 0,2545,2546,5,30,0,0,2546,2547,5,179,0,0,2547,2674,5,31,0,0,2548,2549, + 5,197,0,0,2549,2550,5,30,0,0,2550,2551,3,318,159,0,2551,2552,5,31,0,0, + 2552,2674,1,0,0,0,2553,2554,5,188,0,0,2554,2555,5,42,0,0,2555,2556,3,32, + 16,0,2556,2557,5,43,0,0,2557,2558,5,30,0,0,2558,2559,3,320,160,0,2559, + 2560,5,31,0,0,2560,2674,1,0,0,0,2561,2562,5,189,0,0,2562,2563,5,42,0,0, + 2563,2564,3,32,16,0,2564,2565,5,43,0,0,2565,2566,5,30,0,0,2566,2567,3, + 322,161,0,2567,2568,5,31,0,0,2568,2674,1,0,0,0,2569,2570,5,187,0,0,2570, + 2571,5,42,0,0,2571,2572,3,32,16,0,2572,2573,5,43,0,0,2573,2574,5,30,0, + 0,2574,2575,3,324,162,0,2575,2576,5,31,0,0,2576,2674,1,0,0,0,2577,2578, + 5,186,0,0,2578,2579,5,42,0,0,2579,2580,3,32,16,0,2580,2581,5,43,0,0,2581, + 2582,5,30,0,0,2582,2583,3,326,163,0,2583,2584,5,31,0,0,2584,2674,1,0,0, + 0,2585,2586,5,185,0,0,2586,2587,5,42,0,0,2587,2588,3,32,16,0,2588,2589, + 5,43,0,0,2589,2590,5,30,0,0,2590,2591,3,328,164,0,2591,2592,5,31,0,0,2592, + 2674,1,0,0,0,2593,2594,5,184,0,0,2594,2595,5,42,0,0,2595,2596,3,32,16, + 0,2596,2597,5,43,0,0,2597,2598,5,30,0,0,2598,2599,3,330,165,0,2599,2600, + 5,31,0,0,2600,2674,1,0,0,0,2601,2602,5,193,0,0,2602,2603,5,42,0,0,2603, + 2604,3,32,16,0,2604,2605,5,43,0,0,2605,2606,5,30,0,0,2606,2607,3,324,162, + 0,2607,2608,5,31,0,0,2608,2674,1,0,0,0,2609,2610,5,192,0,0,2610,2611,5, + 42,0,0,2611,2612,3,32,16,0,2612,2613,5,43,0,0,2613,2614,5,30,0,0,2614, + 2615,3,326,163,0,2615,2616,5,31,0,0,2616,2674,1,0,0,0,2617,2618,5,191, + 0,0,2618,2619,5,42,0,0,2619,2620,3,32,16,0,2620,2621,5,43,0,0,2621,2622, + 5,30,0,0,2622,2623,3,328,164,0,2623,2624,5,31,0,0,2624,2674,1,0,0,0,2625, + 2626,5,190,0,0,2626,2627,5,42,0,0,2627,2628,3,32,16,0,2628,2629,5,43,0, + 0,2629,2630,5,30,0,0,2630,2631,3,330,165,0,2631,2632,5,31,0,0,2632,2674, + 1,0,0,0,2633,2634,5,181,0,0,2634,2635,5,42,0,0,2635,2636,3,32,16,0,2636, + 2637,5,43,0,0,2637,2638,5,30,0,0,2638,2639,3,328,164,0,2639,2640,5,31, + 0,0,2640,2674,1,0,0,0,2641,2642,5,183,0,0,2642,2643,5,42,0,0,2643,2644, + 3,32,16,0,2644,2645,5,43,0,0,2645,2646,5,30,0,0,2646,2647,3,332,166,0, + 2647,2648,5,31,0,0,2648,2674,1,0,0,0,2649,2650,5,182,0,0,2650,2651,5,42, + 0,0,2651,2652,3,32,16,0,2652,2653,5,43,0,0,2653,2654,5,30,0,0,2654,2655, + 3,334,167,0,2655,2656,5,31,0,0,2656,2674,1,0,0,0,2657,2658,5,196,0,0,2658, + 2659,5,42,0,0,2659,2660,3,32,16,0,2660,2661,5,43,0,0,2661,2662,5,30,0, + 0,2662,2663,3,336,168,0,2663,2664,5,31,0,0,2664,2674,1,0,0,0,2665,2666, + 5,197,0,0,2666,2667,5,42,0,0,2667,2668,3,32,16,0,2668,2669,5,43,0,0,2669, + 2670,5,30,0,0,2670,2671,3,340,170,0,2671,2672,5,31,0,0,2672,2674,1,0,0, + 0,2673,2525,1,0,0,0,2673,2526,1,0,0,0,2673,2530,1,0,0,0,2673,2534,1,0, + 0,0,2673,2539,1,0,0,0,2673,2544,1,0,0,0,2673,2548,1,0,0,0,2673,2553,1, + 0,0,0,2673,2561,1,0,0,0,2673,2569,1,0,0,0,2673,2577,1,0,0,0,2673,2585, + 1,0,0,0,2673,2593,1,0,0,0,2673,2601,1,0,0,0,2673,2609,1,0,0,0,2673,2617, + 1,0,0,0,2673,2625,1,0,0,0,2673,2633,1,0,0,0,2673,2641,1,0,0,0,2673,2649, + 1,0,0,0,2673,2657,1,0,0,0,2673,2665,1,0,0,0,2674,319,1,0,0,0,2675,2678, + 3,36,18,0,2676,2678,3,32,16,0,2677,2675,1,0,0,0,2677,2676,1,0,0,0,2678, + 2681,1,0,0,0,2679,2677,1,0,0,0,2679,2680,1,0,0,0,2680,321,1,0,0,0,2681, + 2679,1,0,0,0,2682,2685,3,36,18,0,2683,2685,3,34,17,0,2684,2682,1,0,0,0, + 2684,2683,1,0,0,0,2685,2688,1,0,0,0,2686,2684,1,0,0,0,2686,2687,1,0,0, + 0,2687,323,1,0,0,0,2688,2686,1,0,0,0,2689,2691,3,34,17,0,2690,2689,1,0, + 0,0,2691,2694,1,0,0,0,2692,2690,1,0,0,0,2692,2693,1,0,0,0,2693,325,1,0, + 0,0,2694,2692,1,0,0,0,2695,2697,3,32,16,0,2696,2695,1,0,0,0,2697,2700, + 1,0,0,0,2698,2696,1,0,0,0,2698,2699,1,0,0,0,2699,327,1,0,0,0,2700,2698, + 1,0,0,0,2701,2703,3,32,16,0,2702,2701,1,0,0,0,2703,2706,1,0,0,0,2704,2702, + 1,0,0,0,2704,2705,1,0,0,0,2705,329,1,0,0,0,2706,2704,1,0,0,0,2707,2709, + 3,32,16,0,2708,2707,1,0,0,0,2709,2712,1,0,0,0,2710,2708,1,0,0,0,2710,2711, + 1,0,0,0,2711,331,1,0,0,0,2712,2710,1,0,0,0,2713,2715,3,184,92,0,2714,2713, + 1,0,0,0,2715,2718,1,0,0,0,2716,2714,1,0,0,0,2716,2717,1,0,0,0,2717,333, + 1,0,0,0,2718,2716,1,0,0,0,2719,2721,7,13,0,0,2720,2719,1,0,0,0,2721,2724, + 1,0,0,0,2722,2720,1,0,0,0,2722,2723,1,0,0,0,2723,335,1,0,0,0,2724,2722, + 1,0,0,0,2725,2727,3,338,169,0,2726,2725,1,0,0,0,2727,2730,1,0,0,0,2728, + 2726,1,0,0,0,2728,2729,1,0,0,0,2729,337,1,0,0,0,2730,2728,1,0,0,0,2731, + 2736,5,179,0,0,2732,2733,5,39,0,0,2733,2736,5,264,0,0,2734,2736,3,138, + 69,0,2735,2731,1,0,0,0,2735,2732,1,0,0,0,2735,2734,1,0,0,0,2736,339,1, + 0,0,0,2737,2739,3,318,159,0,2738,2737,1,0,0,0,2739,2742,1,0,0,0,2740,2738, + 1,0,0,0,2740,2741,1,0,0,0,2741,341,1,0,0,0,2742,2740,1,0,0,0,2743,2747, + 3,44,22,0,2744,2747,3,46,23,0,2745,2747,3,2,1,0,2746,2743,1,0,0,0,2746, + 2744,1,0,0,0,2746,2745,1,0,0,0,2747,343,1,0,0,0,2748,2749,7,14,0,0,2749, + 2750,5,36,0,0,2750,2751,5,30,0,0,2751,2752,3,312,156,0,2752,2753,5,31, + 0,0,2753,2774,1,0,0,0,2754,2755,5,169,0,0,2755,2756,3,38,19,0,2756,2757, + 5,75,0,0,2757,2758,3,38,19,0,2758,2759,5,75,0,0,2759,2760,3,38,19,0,2760, + 2761,5,75,0,0,2761,2762,3,38,19,0,2762,2774,1,0,0,0,2763,2764,5,170,0, + 0,2764,2774,3,6,3,0,2765,2766,5,170,0,0,2766,2767,5,36,0,0,2767,2768,5, + 30,0,0,2768,2769,3,312,156,0,2769,2770,5,31,0,0,2770,2774,1,0,0,0,2771, + 2774,3,342,171,0,2772,2774,3,40,20,0,2773,2748,1,0,0,0,2773,2754,1,0,0, + 0,2773,2763,1,0,0,0,2773,2765,1,0,0,0,2773,2771,1,0,0,0,2773,2772,1,0, + 0,0,2774,345,1,0,0,0,2775,2776,5,25,0,0,2776,2777,5,40,0,0,2777,2778,3, + 98,49,0,2778,2779,3,2,1,0,2779,2788,1,0,0,0,2780,2781,5,25,0,0,2781,2782, + 5,40,0,0,2782,2783,3,98,49,0,2783,2784,3,2,1,0,2784,2785,5,34,0,0,2785, + 2786,3,2,1,0,2786,2788,1,0,0,0,2787,2775,1,0,0,0,2787,2780,1,0,0,0,2788, + 347,1,0,0,0,2789,2791,3,350,175,0,2790,2789,1,0,0,0,2791,2794,1,0,0,0, + 2792,2790,1,0,0,0,2792,2793,1,0,0,0,2793,349,1,0,0,0,2794,2792,1,0,0,0, + 2795,2796,5,180,0,0,2796,2797,5,36,0,0,2797,2798,5,30,0,0,2798,2799,3, + 312,156,0,2799,2800,5,31,0,0,2800,2810,1,0,0,0,2801,2810,3,344,172,0,2802, + 2803,5,171,0,0,2803,2804,5,36,0,0,2804,2805,5,30,0,0,2805,2806,3,312,156, + 0,2806,2807,5,31,0,0,2807,2810,1,0,0,0,2808,2810,5,55,0,0,2809,2795,1, + 0,0,0,2809,2801,1,0,0,0,2809,2802,1,0,0,0,2809,2808,1,0,0,0,2810,351,1, + 0,0,0,2811,2812,5,50,0,0,2812,2816,5,40,0,0,2813,2815,3,356,178,0,2814, + 2813,1,0,0,0,2815,2818,1,0,0,0,2816,2814,1,0,0,0,2816,2817,1,0,0,0,2817, + 2819,1,0,0,0,2818,2816,1,0,0,0,2819,2820,3,2,1,0,2820,353,1,0,0,0,2821, + 2825,5,301,0,0,2822,2824,3,356,178,0,2823,2822,1,0,0,0,2824,2827,1,0,0, + 0,2825,2823,1,0,0,0,2825,2826,1,0,0,0,2826,2828,1,0,0,0,2827,2825,1,0, + 0,0,2828,2829,3,2,1,0,2829,355,1,0,0,0,2830,2846,5,52,0,0,2831,2846,5, + 51,0,0,2832,2846,5,172,0,0,2833,2834,5,62,0,0,2834,2846,5,51,0,0,2835, + 2836,5,62,0,0,2836,2846,5,52,0,0,2837,2838,5,62,0,0,2838,2846,5,63,0,0, + 2839,2840,5,62,0,0,2840,2846,5,64,0,0,2841,2842,5,62,0,0,2842,2846,5,65, + 0,0,2843,2844,5,62,0,0,2844,2846,5,66,0,0,2845,2830,1,0,0,0,2845,2831, + 1,0,0,0,2845,2832,1,0,0,0,2845,2833,1,0,0,0,2845,2835,1,0,0,0,2845,2837, + 1,0,0,0,2845,2839,1,0,0,0,2845,2841,1,0,0,0,2845,2843,1,0,0,0,2846,357, + 1,0,0,0,2847,2849,3,360,180,0,2848,2847,1,0,0,0,2849,2852,1,0,0,0,2850, + 2848,1,0,0,0,2850,2851,1,0,0,0,2851,359,1,0,0,0,2852,2850,1,0,0,0,2853, + 2854,5,21,0,0,2854,2867,3,2,1,0,2855,2856,5,50,0,0,2856,2857,5,40,0,0, + 2857,2867,3,140,70,0,2858,2859,5,25,0,0,2859,2860,5,40,0,0,2860,2867,3, + 2,1,0,2861,2867,3,196,98,0,2862,2863,5,50,0,0,2863,2867,3,32,16,0,2864, + 2867,3,342,171,0,2865,2867,3,40,20,0,2866,2853,1,0,0,0,2866,2855,1,0,0, + 0,2866,2858,1,0,0,0,2866,2861,1,0,0,0,2866,2862,1,0,0,0,2866,2864,1,0, + 0,0,2866,2865,1,0,0,0,2867,361,1,0,0,0,2868,2872,5,274,0,0,2869,2871,3, + 364,182,0,2870,2869,1,0,0,0,2871,2874,1,0,0,0,2872,2870,1,0,0,0,2872,2873, + 1,0,0,0,2873,2875,1,0,0,0,2874,2872,1,0,0,0,2875,2888,3,2,1,0,2876,2880, + 5,274,0,0,2877,2879,3,364,182,0,2878,2877,1,0,0,0,2879,2882,1,0,0,0,2880, + 2878,1,0,0,0,2880,2881,1,0,0,0,2881,2883,1,0,0,0,2882,2880,1,0,0,0,2883, + 2884,3,2,1,0,2884,2885,5,34,0,0,2885,2886,3,2,1,0,2886,2888,1,0,0,0,2887, + 2868,1,0,0,0,2887,2876,1,0,0,0,2888,363,1,0,0,0,2889,2890,7,15,0,0,2890, + 365,1,0,0,0,2891,2893,3,368,184,0,2892,2891,1,0,0,0,2893,2896,1,0,0,0, + 2894,2892,1,0,0,0,2894,2895,1,0,0,0,2895,367,1,0,0,0,2896,2894,1,0,0,0, + 2897,2898,5,21,0,0,2898,2899,3,2,1,0,2899,2900,5,44,0,0,2900,2901,3,32, + 16,0,2901,2908,1,0,0,0,2902,2903,5,25,0,0,2903,2904,5,40,0,0,2904,2908, + 3,2,1,0,2905,2908,3,342,171,0,2906,2908,3,40,20,0,2907,2897,1,0,0,0,2907, + 2902,1,0,0,0,2907,2905,1,0,0,0,2907,2906,1,0,0,0,2908,369,1,0,0,0,172, + 378,383,391,399,452,493,502,526,530,548,575,598,634,640,647,649,659,661, + 668,679,687,708,710,726,771,776,781,786,794,904,910,926,932,938,945,1056, + 1061,1067,1072,1074,1082,1094,1106,1113,1120,1122,1149,1156,1164,1172, + 1185,1192,1195,1214,1308,1317,1324,1327,1335,1356,1388,1411,1423,1432, + 1457,1481,1489,1493,1508,1515,1560,1570,1586,1598,1610,1624,1636,1647, + 1654,1664,1677,1682,1687,1696,1707,1790,1799,1812,1823,1831,1841,1843, + 1870,1877,1882,1889,1895,1905,1909,1916,1931,1937,1951,1964,1972,1979, + 1983,1988,2004,2009,2011,2024,2050,2057,2059,2064,2070,2099,2104,2127, + 2132,2196,2205,2218,2229,2240,2243,2250,2262,2276,2290,2298,2318,2330, + 2335,2344,2346,2353,2363,2431,2508,2515,2523,2673,2677,2679,2684,2686, + 2692,2698,2704,2710,2716,2722,2728,2735,2740,2746,2773,2787,2792,2809, + 2816,2825,2845,2850,2866,2872,2880,2887,2894,2907 }; public static readonly ATN _ATN = diff --git a/src/tools/ilasm/src/ILAssembler/gen/ilasm-generator.csproj b/src/tools/ilasm/src/ILAssembler/gen/ilasm-generator.csproj index e4b7699a7e0634..1b0d358d59b2d0 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/ilasm-generator.csproj +++ b/src/tools/ilasm/src/ILAssembler/gen/ilasm-generator.csproj @@ -2,7 +2,7 @@ $(NetCoreAppToolCurrent) - true + false enable $(NoWarn);CS3021 true @@ -44,4 +44,10 @@ + + + + + + diff --git a/src/tools/ilasm/tests/ILAssembler.Tests/DataTests.cs b/src/tools/ilasm/tests/ILAssembler.Tests/DataTests.cs index 59f867a02114f2..70dea69be5c691 100644 --- a/src/tools/ilasm/tests/ILAssembler.Tests/DataTests.cs +++ b/src/tools/ilasm/tests/ILAssembler.Tests/DataTests.cs @@ -6,6 +6,7 @@ using System.Buffers.Binary; using System.Collections.Generic; using System.Collections.Immutable; +using System.Globalization; using System.Linq; using System.Reflection; using System.Reflection.Metadata; @@ -196,6 +197,49 @@ .field public static float64 Value at D Assert.Equal(4503599627370496d, BitConverter.Int64BitsToDouble(BinaryPrimitives.ReadInt64LittleEndian(data))); } + [Fact] + public void LargeByteArray_StreamsIntoDataSectionWithoutLosingBytes() + { + const int Length = 64 * 1024; + byte[] expected = new byte[Length]; + for (int i = 0; i < Length; i++) + { + expected[i] = (byte)((i * 31) + 7); + } + + StringBuilder literal = new(Length * 3); + for (int i = 0; i < Length; i++) + { + if (i > 0) + { + literal.Append(i % 32 == 0 ? '\n' : ' '); + } + + literal.Append(expected[i].ToString("X2", CultureInfo.InvariantCulture)); + } + + string source = $$""" + .assembly extern mscorlib { } + .assembly test { } + + .data D_LARGE = bytearray ({{literal}}) + + .class public explicit ansi sealed DataHolder extends [mscorlib]System.ValueType + { + .size 8 + .field [0] public static int8 LargeData at D_LARGE + } + """; + + using var pe = DocumentCompilerTestHelpers.CompileAndGetReader(source, new Options()); + var reader = pe.GetMetadataReader(); + var field = reader.FieldDefinitions + .Select(reader.GetFieldDefinition) + .Single(definition => reader.GetString(definition.Name) == "LargeData"); + + Assert.Equal(expected, ReadData(pe, field, Length)); + } + private static byte[] ReadData(PEReader pe, FieldDefinition field, int length) { int rva = field.GetRelativeVirtualAddress(); diff --git a/src/tools/ilasm/tests/ILAssembler.Tests/DocumentCompilerTests.cs b/src/tools/ilasm/tests/ILAssembler.Tests/DocumentCompilerTests.cs index 9ccf33c124cf93..a20843d6c19ce5 100644 --- a/src/tools/ilasm/tests/ILAssembler.Tests/DocumentCompilerTests.cs +++ b/src/tools/ilasm/tests/ILAssembler.Tests/DocumentCompilerTests.cs @@ -55,5 +55,128 @@ .method public static void M(int32 int32 int32) cil managed Assert.Contains("ValidFromDoc1", typeNames); } + + [Fact] + public void TruncatedDocument_DoesNotLeakScopesIntoTheNextDocument() + { + var documents = ImmutableArray.Create( + new SourceText(""" + .assembly extern mscorlib { } + .assembly test { } + .namespace Leaky + { + .class public auto ansi Unterminated + { + .method public static void M() cil managed + { + ret + """, "truncated.il"), + new SourceText(""" + .class public auto ansi AfterTruncation + { + } + """, "next.il")); + + var compiler = new DocumentCompiler(); + var (diagnostics, image) = compiler.Compile( + documents, + _ => throw new InvalidOperationException("Unexpected include"), + _ => throw new InvalidOperationException("Unexpected resource"), + new Options { ErrorTolerant = true }); + + Assert.Contains(diagnostics, diagnostic => diagnostic.Severity == DiagnosticSeverity.Error); + Assert.NotNull(image); + + var imageBuilder = new BlobBuilder(); + image!.Serialize(imageBuilder); + using var pe = new PEReader(imageBuilder.ToImmutableArray()); + var reader = pe.GetMetadataReader(); + var afterTruncation = reader.TypeDefinitions + .Select(reader.GetTypeDefinition) + .Single(type => reader.GetString(type.Name) == "AfterTruncation"); + + Assert.Equal(string.Empty, reader.GetString(afterTruncation.Namespace)); + Assert.True(afterTruncation.GetDeclaringType().IsNil); + } + + [Theory] + [InlineData(""" + .assembly extern mscorlib { } + .assembly test { } + .class public auto ansi Broken + { + .method public static void M(int32 int32 int32) cil managed + { + ret + } + } + .class public auto ansi Following + { + } + """)] + [InlineData(""" + .assembly extern mscorlib { } + .assembly test { } + .namespace Broken + { + .class public auto ansi Nested + { + .method public static void M(int32 int32 int32) cil managed + { + ret + } + } + } + .class public auto ansi Following + { + } + """)] + [InlineData(""" + .assembly extern mscorlib { } + .assembly test { } + .class public auto ansi Broken + { + .method public static void M() cil managed + { + .try + { + { + nop nop nop int32 + } + } + finally + { + endfinally + } + ret + } + } + .class public auto ansi Following + { + } + """)] + public void SyntaxErrorInDeclarationBody_DoesNotLeakScopesIntoFollowingDeclarations(string source) + { + var compiler = new DocumentCompiler(); + var (diagnostics, image) = compiler.Compile( + new SourceText(source, "test.il"), + _ => throw new InvalidOperationException("Unexpected include"), + _ => throw new InvalidOperationException("Unexpected resource"), + new Options { ErrorTolerant = true }); + + Assert.Contains(diagnostics, diagnostic => diagnostic.Severity == DiagnosticSeverity.Error); + Assert.NotNull(image); + + var imageBuilder = new BlobBuilder(); + image!.Serialize(imageBuilder); + using var pe = new PEReader(imageBuilder.ToImmutableArray()); + var reader = pe.GetMetadataReader(); + var following = reader.TypeDefinitions + .Select(reader.GetTypeDefinition) + .Single(type => reader.GetString(type.Name) == "Following"); + + Assert.Equal(string.Empty, reader.GetString(following.Namespace)); + Assert.True(following.GetDeclaringType().IsNil); + } } } diff --git a/src/tools/ilasm/tests/ILAssembler.Tests/ExceptionHandlingTests.cs b/src/tools/ilasm/tests/ILAssembler.Tests/ExceptionHandlingTests.cs index 892136bf565412..8cf84b76494a55 100644 --- a/src/tools/ilasm/tests/ILAssembler.Tests/ExceptionHandlingTests.cs +++ b/src/tools/ilasm/tests/ILAssembler.Tests/ExceptionHandlingTests.cs @@ -441,5 +441,65 @@ leave.s DONE Assert.True(region.HandlerLength > 0); } + [Fact] + public void MultipleCatchClauses_ResolveCatchTypesBeforeTheirHandlerBodies() + { + string source = """ + .assembly extern mscorlib { } + .assembly test { } + .class public auto ansi beforefieldinit Test extends [mscorlib]System.Object + { + .method public static void M() cil managed + { + .maxstack 1 + .try + { + leave.s DONE + } + catch [mscorlib]System.ArgumentException + { + castclass [mscorlib]System.IO.Stream + pop + leave.s DONE + } + catch [mscorlib]System.NotSupportedException + { + castclass [mscorlib]System.Text.StringBuilder + pop + leave.s DONE + } + DONE: + ret + } + } + """; + + using var pe = DocumentCompilerTestHelpers.CompileAndGetReader(source, new Options()); + var reader = pe.GetMetadataReader(); + + // Native ilasm resolves a catch type as soon as the clause is parsed, so each catch type + // precedes every type its handler body references. + Assert.Equal( + ["System.Object", "System.ValueType", "System.ArgumentException", "System.IO.Stream", "System.NotSupportedException", "System.Text.StringBuilder"], + reader.TypeReferences + .Select(reader.GetTypeReference) + .Select(reference => reader.GetString(reference.Namespace) + "." + reader.GetString(reference.Name)) + .ToArray()); + + var method = reader.MethodDefinitions + .Select(reader.GetMethodDefinition) + .First(definition => reader.GetString(definition.Name) == "M"); + var body = pe.GetMethodBody(method.RelativeVirtualAddress); + + Assert.Equal(2, body.ExceptionRegions.Length); + Assert.All(body.ExceptionRegions, region => Assert.Equal(ExceptionRegionKind.Catch, region.Kind)); + Assert.Equal( + ["System.ArgumentException", "System.NotSupportedException"], + body.ExceptionRegions + .Select(region => reader.GetTypeReference((TypeReferenceHandle)region.CatchType)) + .Select(reference => reader.GetString(reference.Namespace) + "." + reader.GetString(reference.Name)) + .ToArray()); + } + } } diff --git a/src/tools/ilasm/tests/ILAssembler.Tests/FieldTests.cs b/src/tools/ilasm/tests/ILAssembler.Tests/FieldTests.cs index 0a50dd1e58fe48..a140129e4a2ea8 100644 --- a/src/tools/ilasm/tests/ILAssembler.Tests/FieldTests.cs +++ b/src/tools/ilasm/tests/ILAssembler.Tests/FieldTests.cs @@ -72,6 +72,90 @@ .class public auto ansi B Assert.Single(typeB.GetCustomAttributes()); } + [Fact] + public void TrailingFieldCustomAttribute_DoesNotLeakAcrossNamespaces() + { + string source = """ + .assembly extern mscorlib { } + .assembly test { } + .namespace First + { + .class public auto ansi A + { + .field public static int32 Value + } + } + .class public auto ansi B + { + .custom instance void [mscorlib]System.ObsoleteAttribute::.ctor() = (01 00 00 00) + } + """; + + using var pe = DocumentCompilerTestHelpers.CompileAndGetReader(source, new Options()); + var reader = pe.GetMetadataReader(); + var field = reader.GetFieldDefinition(MetadataTokens.FieldDefinitionHandle(1)); + var typeB = reader.TypeDefinitions + .Select(reader.GetTypeDefinition) + .Single(type => reader.GetString(type.Name) == "B"); + + Assert.Empty(field.GetCustomAttributes()); + Assert.Single(typeB.GetCustomAttributes()); + } + + [Fact] + public void TrailingFieldCustomAttribute_BindsToFieldWithinTheSameNamespacedType() + { + string source = """ + .assembly extern mscorlib { } + .assembly test { } + .namespace First + { + .class public auto ansi A + { + .field public static int32 Value + .custom instance void [mscorlib]System.ThreadStaticAttribute::.ctor() = (01 00 00 00) + } + } + """; + + using var pe = DocumentCompilerTestHelpers.CompileAndGetReader(source, new Options()); + var reader = pe.GetMetadataReader(); + var field = reader.GetFieldDefinition(MetadataTokens.FieldDefinitionHandle(1)); + var typeA = reader.TypeDefinitions + .Select(reader.GetTypeDefinition) + .Single(type => reader.GetString(type.Name) == "A"); + + Assert.Single(field.GetCustomAttributes()); + Assert.Empty(typeA.GetCustomAttributes()); + } + + [Fact] + public void TrailingFieldCustomAttribute_DoesNotLeakOutOfNestedClass() + { + string source = """ + .assembly extern mscorlib { } + .assembly test { } + .class public auto ansi Outer + { + .class nested public auto ansi Inner + { + .field public static int32 Value + } + .custom instance void [mscorlib]System.ObsoleteAttribute::.ctor() = (01 00 00 00) + } + """; + + using var pe = DocumentCompilerTestHelpers.CompileAndGetReader(source, new Options()); + var reader = pe.GetMetadataReader(); + var field = reader.GetFieldDefinition(MetadataTokens.FieldDefinitionHandle(1)); + var outer = reader.TypeDefinitions + .Select(reader.GetTypeDefinition) + .Single(type => reader.GetString(type.Name) == "Outer"); + + Assert.Empty(field.GetCustomAttributes()); + Assert.Single(outer.GetCustomAttributes()); + } + [Fact] public void GlobalFieldTrailingCustomAttribute_AttachesToField() { diff --git a/src/tools/ilasm/tests/ILAssembler.Tests/InteropTests.cs b/src/tools/ilasm/tests/ILAssembler.Tests/InteropTests.cs index b89648399f5008..66b01d758db456 100644 --- a/src/tools/ilasm/tests/ILAssembler.Tests/InteropTests.cs +++ b/src/tools/ilasm/tests/ILAssembler.Tests/InteropTests.cs @@ -184,6 +184,27 @@ .field public marshal({{sizeSyntax}}) int32[] Values Assert.Equal(Convert.FromHexString(expectedHex), reader.GetBlobBytes(field.GetMarshallingDescriptor())); } + [Theory] + [InlineData("{ 2A 50 }", "2A50")] + [InlineData("{ 1E }", "1E")] + [InlineData("{ 00 0A FF }", "000AFF")] + public void RawMarshalBlob_EmitsSuppliedBytes(string blob, string expectedHex) + { + string source = $$""" + .assembly test { } + .class public auto ansi Test + { + .field public marshal({{blob}}) int32[] Values + } + """; + + using var pe = DocumentCompilerTestHelpers.CompileAndGetReader(source, new Options()); + var reader = pe.GetMetadataReader(); + var field = reader.GetFieldDefinition(MetadataTokens.FieldDefinitionHandle(1)); + + Assert.Equal(Convert.FromHexString(expectedHex), reader.GetBlobBytes(field.GetMarshallingDescriptor())); + } + [Theory] [InlineData("int8", UnmanagedType.U1)] [InlineData("int16", UnmanagedType.U2)] diff --git a/src/tools/ilasm/tests/ILAssembler.Tests/SyntaxTests.cs b/src/tools/ilasm/tests/ILAssembler.Tests/SyntaxTests.cs index 7d2d2ae89a4bb9..979f69200ca730 100644 --- a/src/tools/ilasm/tests/ILAssembler.Tests/SyntaxTests.cs +++ b/src/tools/ilasm/tests/ILAssembler.Tests/SyntaxTests.cs @@ -191,6 +191,65 @@ .method public static int64 M() cil managed } + [Theory] + [InlineData(""" + .assembly extern mscorlib { } + .assembly test { } + .class public auto ansi Test + { + """)] + [InlineData(""" + .assembly extern mscorlib { } + .assembly test { } + .namespace NS + { + .class public auto ansi Test + { + .method public static void M() cil managed + { + """)] + [InlineData(".class public auto ansi")] + [InlineData(".method public static void")] + [InlineData(""" + .assembly extern mscorlib { } + .assembly test { } + .class public auto ansi Test + { + .method public static void M() cil managed + { + .try + """)] + [InlineData(""" + .assembly extern mscorlib { } + .assembly test { } + .class public auto ansi Test + { + .method public static void M(int32 .method cil managed + { + .maxstack 2 + ret + } + } + """)] + [InlineData(""" + .assembly extern mscorlib { } + .assembly test { } + .class public auto ansi + { + .method public instance void M() cil managed + { + .override [mscorlib]System.Object::ToString + ret + } + } + """)] + public void TruncatedDocument_ReportsDiagnosticsInsteadOfThrowing(string source) + { + var diagnostics = DocumentCompilerTestHelpers.CompileAndGetDiagnostics(source, new Options()); + + Assert.Contains(diagnostics, diagnostic => diagnostic.Severity == DiagnosticSeverity.Error); + } + [Fact] public void ParserErrorListener_ReportsSyntaxErrors() { From 7827109d06425df2510323928a8d8639ea097ade Mon Sep 17 00:00:00 2001 From: Jeremy Koritzinsky Date: Wed, 12 Aug 2026 17:49:21 -0700 Subject: [PATCH 02/16] Compile common IL instructions during parsing Emit common instruction and method-body forms directly from thin parser actions without constructing temporary parse subtrees. Keep complex operands in isolated bounded subtrees for subsequent stack layers. Preserve instruction diagnostics and deterministic output while reducing large-method assembly time. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: c986c103-8383-4db4-9b11-9be49dc68a05 --- src/tools/ilasm/README.md | 7 +- .../Actions/GrammarActions.Conversions.cs | 13 +- .../GrammarActions.Instructions.Islands.cs | 225 + .../Actions/GrammarActions.Instructions.cs | 714 +- .../Actions/GrammarActions.Literals.cs | 47 +- .../Actions/GrammarActions.MethodBodies.cs | 94 +- src/tools/ilasm/src/ILAssembler/gen/CIL.g4 | 116 +- .../ilasm/src/ILAssembler/gen/CIL.interp | 18 +- .../src/ILAssembler/gen/CILBaseVisitor.cs | 132 +- .../ilasm/src/ILAssembler/gen/CILParser.cs | 7678 ++++++++--------- .../ilasm/src/ILAssembler/gen/CILVisitor.cs | 84 +- .../ILAssembler.Tests/InstructionTests.cs | 52 + 12 files changed, 4394 insertions(+), 4786 deletions(-) create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.Islands.cs diff --git a/src/tools/ilasm/README.md b/src/tools/ilasm/README.md index f93dd514a93ba6..138d95683de432 100644 --- a/src/tools/ilasm/README.md +++ b/src/tools/ilasm/README.md @@ -19,7 +19,8 @@ accumulator instead of building a subtree at all. | `GrammarActions.Data.cs` | Data and blob declarations. | | `GrammarActions.Debug.cs` | Source and debug directives. | | `GrammarActions.Declarations.cs` | Top-level `decl` dispatch and conversion. | -| `GrammarActions.Instructions.cs` | Instruction dispatch and conversion. | +| `GrammarActions.Instructions.cs` | Tree-free common instruction and method-item actions. | +| `GrammarActions.Instructions.Islands.cs` | Complex instruction-island conversion. | | `GrammarActions.Literals.cs` | Literals, names and strings. | | `GrammarActions.Manifest.cs` | Assembly, module, resource, vtable and typedef directives. | | `GrammarActions.Marshalling.cs` | Native type and marshalling conversion. | @@ -36,6 +37,10 @@ accumulator instead of building a subtree at all. Parser actions in `src/ILAssembler/gen/CIL.g4` must remain thin; they call a single `Actions` method and nothing else. Compilation orchestration belongs in the `GrammarActions` partial-class files. +The common instruction forms and labels run entirely with parse-tree construction disabled. +Instructions with complex type, member, signature, string, floating-point, or switch operands +temporarily retain only their own bounded `instructionIsland` subtree. + Semantic state that a rule pushes must be released from that rule's `finally` clause and be keyed on the owning context, because ANTLR skips `@after` actions and the remainder of an alternative once a rule reports a syntax error. Inline actions placed after a subrule reference are not a substitute: diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs index 8b1d0110120322..83bb363933c4b0 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs @@ -132,6 +132,15 @@ private void ReportDiagnostic(DiagnosticSeverity severity, string id, string mes private void ReportError(string id, string message, Antlr4.Runtime.ParserRuleContext context) => ReportDiagnostic(DiagnosticSeverity.Error, id, message, context); + private void ReportError(string id, string message, IToken token) + { + _diagnostics.Add(new Diagnostic( + id, + DiagnosticSeverity.Error, + message, + Location.From(token, _documents))); + } + private void ReportWarning(string id, string message, Antlr4.Runtime.ParserRuleContext context) => ReportDiagnostic(DiagnosticSeverity.Warning, id, message, context); @@ -183,9 +192,7 @@ public CurrentMethodContext(EntityRegistry.MethodDefinitionEntity definition) public Dictionary Labels { get; } = new(); - public HashSet DeclaredLabels { get; } = new(); - - public Dictionary UndefinedLabelReferences { get; } = new(); + public Dictionary UndefinedLabelReferences { get; } = new(); public Dictionary ArgumentNames { get; } = new(); diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.Islands.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.Islands.cs new file mode 100644 index 00000000000000..8dacce6ba8c470 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.Islands.cs @@ -0,0 +1,225 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Linq; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using System.Runtime.InteropServices; +using System.Text; +using Antlr4.Runtime; +using Antlr4.Runtime.Tree; + +namespace ILAssembler; + +internal sealed partial class GrammarActions +{ + internal void ProcessInstructionIsland(CILParser.InstructionIslandContext context) + { + if (StartInstruction(context.Start) is not { } instruction) + { + return; + } + + ILOpCode opcode = instruction.OpCode; + CurrentMethodContext method = instruction.Method; + + if (context.methodRef() is CILParser.MethodRefContext methodRef) + { + EmitMethodReferenceInstruction(method, opcode, methodRef); + } + else if (context.fieldRef() is CILParser.FieldRefContext fieldRef) + { + method.Definition.MethodBody.OpCode(opcode); + WriteInstructionToken(method, VisitFieldRef(fieldRef).Value); + } + else if (context.mdtoken() is CILParser.MdtokenContext mdtoken) + { + method.Definition.MethodBody.OpCode(opcode); + WriteInstructionToken(method, VisitMdtoken(mdtoken).Value); + } + else if (context.typeSpec() is CILParser.TypeSpecContext typeSpec) + { + method.Definition.MethodBody.OpCode(opcode); + WriteInstructionToken(method, VisitTypeSpec(typeSpec).Value); + } + else if (context.compQstring() is CILParser.CompQstringContext userString) + { + EmitComposedStringInstruction(method, context, userString); + } + else if (context.callConv() is CILParser.CallConvContext callConv) + { + EmitCalliInstruction(method, opcode, context, callConv); + } + else if (context.ownerType() is CILParser.OwnerTypeContext ownerType) + { + method.Definition.MethodBody.OpCode(opcode); + WriteInstructionToken(method, VisitOwnerType(ownerType).Value); + } + else if (opcode == ILOpCode.Switch) + { + EmitSwitchInstruction(method, context, context.labels()); + } + else + { + EmitParsedFloatingInstruction(method, opcode, context); + } + } + + private void EmitMethodReferenceInstruction( + CurrentMethodContext method, + ILOpCode opcode, + CILParser.MethodRefContext context) + { + bool expectInstance = opcode is ILOpCode.Callvirt or ILOpCode.Newobj; + _expectInstance = expectInstance; + try + { + method.Definition.MethodBody.OpCode(opcode); + WriteInstructionToken(method, VisitMethodRef(context).Value); + } + finally + { + if (expectInstance) + { + _expectInstance = false; + } + } + } + + private void EmitParsedFloatingInstruction( + CurrentMethodContext method, + ILOpCode opcode, + CILParser.InstructionIslandContext context) + { + double value = context.float64() is CILParser.Float64Context float64 + ? VisitFloat64(float64).Value + : VisitInt64(context.int64()).Value; + + if (opcode == ILOpCode.Ldc_r4) + { + method.Definition.MethodBody.LoadConstantR4((float)value); + } + else + { + method.Definition.MethodBody.LoadConstantR8(value); + } + } + + private void EmitComposedStringInstruction( + CurrentMethodContext method, + CILParser.InstructionIslandContext context, + CILParser.CompQstringContext userString) + { + string value = VisitCompQstring(userString).Value; + if (context.ANSI() is not null) + { + int byteCount = Encoding.UTF8.GetByteCount(value); + if ((byteCount % 1) != 0) + { + byteCount++; + } + + Span utf8Bytes = new byte[byteCount]; + Encoding.UTF8.GetBytes(value, utf8Bytes); + value = new string(MemoryMarshal.Cast(utf8Bytes)); + } + + method.Definition.MethodBody.LoadString(_metadataBuilder.GetOrAddUserString(value)); + } + + private void EmitCalliInstruction( + CurrentMethodContext method, + ILOpCode opcode, + CILParser.InstructionIslandContext context, + CILParser.CallConvContext callConv) + { + Debug.Assert(opcode == ILOpCode.Calli); + BlobBuilder signature = new(); + signature.WriteByte(VisitCallConv(callConv).Value); + ImmutableArray arguments = VisitSigArgs(context.sigArgs()).Value; + signature.WriteCompressedInteger(arguments.Count(argument => !argument.IsSentinel)); + VisitType(context.type()).Value.WriteContentTo(signature); + foreach (SignatureArg argument in arguments) + { + argument.SignatureBlob.WriteContentTo(signature); + } + + method.Definition.MethodBody.OpCode(opcode); + method.Definition.MethodBody.Token(_entityRegistry.GetOrCreateStandaloneSignature(signature).Handle); + } + + private void EmitSwitchInstruction( + CurrentMethodContext method, + CILParser.InstructionIslandContext context, + CILParser.LabelsContext? labelsContext) + { + List<(LabelHandle Label, int? Offset)> labels = new(); + if (labelsContext?.children is { } labelChildren) + { + foreach (IParseTree label in labelChildren) + { + if (label is CILParser.IdContext id) + { + string labelName = VisitId(id).Value; + if (!method.Labels.TryGetValue(labelName, out LabelHandle handle)) + { + handle = method.Definition.MethodBody.DefineLabel(); + method.Labels[labelName] = handle; + method.UndefinedLabelReferences.TryAdd(labelName, context.Start); + } + labels.Add((handle, null)); + } + else if (label is CILParser.Int32Context int32) + { + labels.Add((method.Definition.MethodBody.DefineLabel(), VisitInt32(int32).Value)); + } + } + } + + if (labels.Count > 0) + { + SwitchInstructionEncoder switchEncoder = method.Definition.MethodBody.Switch(labels.Count); + foreach ((LabelHandle label, _) in labels) + { + switchEncoder.Branch(label); + } + } + else + { + method.Definition.MethodBody.OpCode(ILOpCode.Switch); + method.Definition.MethodBody.CodeBuilder.WriteInt32(0); + } + + foreach ((LabelHandle label, int? offset) in labels) + { + if (offset is int value) + { + method.Definition.MethodBody.MarkLabel( + label, + method.Definition.MethodBody.Offset + value); + } + } + } + + private static void WriteInstructionToken(CurrentMethodContext method, EntityRegistry.EntityBase entity) + { + if (entity is EntityRegistry.TypeReferenceEntity typeReference) + { + typeReference.RecordBlobToWriteResolvedToken( + method.Definition.MethodBody.CodeBuilder.ReserveBytes(sizeof(int))); + } + else if (entity is EntityRegistry.MemberReferenceEntity memberReference) + { + memberReference.RecordBlobToWriteResolvedHandle( + method.Definition.MethodBody.CodeBuilder.ReserveBytes(sizeof(int))); + } + else + { + method.Definition.MethodBody.Token(entity.Handle); + } + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs index daa9ab6d014daa..f29301adfec44d 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs @@ -2,473 +2,317 @@ // The .NET Foundation licenses this file to you under the MIT license. using System; -using System.Buffers.Binary; -using System.Collections.Generic; using System.Collections.Immutable; using System.Diagnostics; -using System.Globalization; -using System.IO; -using System.Linq; -using System.Reflection; using System.Reflection.Metadata; using System.Reflection.Metadata.Ecma335; -using System.Reflection.PortableExecutable; using System.Runtime.InteropServices; -using System.Security.Cryptography; -using System.Text; using Antlr4.Runtime; -using Antlr4.Runtime.Misc; -using Antlr4.Runtime.Tree; namespace ILAssembler; internal sealed partial class GrammarActions { - private bool TryProcessInstruction(CILParser.MethodDeclContext context) + internal void EmitNoOperandInstruction(IToken opcodeToken) { - if (context.instr() is null) + if (StartInstruction(opcodeToken) is not { } instruction) { - return false; + return; } - VisitMethodDecl(context); - return true; + instruction.Method.Definition.MethodBody.OpCode(instruction.OpCode); } -#pragma warning disable CA1822 // Mark members as static - public GrammarResult VisitInstr(CILParser.InstrContext context) + internal void EmitVariableIndexInstruction(IToken opcodeToken, IToken indexToken) + { + if (StartInstruction(opcodeToken) is not { } instruction) + { + return; + } + + WriteVariableIndex(instruction.Method, instruction.OpCode, ParseInt32(indexToken)); + } + + internal void EmitVariableNameInstruction(IToken opcodeToken, IToken nameToken) + { + if (StartInstruction(opcodeToken) is not { } instruction) + { + return; + } + + CurrentMethodContext method = instruction.Method; + ILOpCode opcode = instruction.OpCode; + string instructionName = opcode.ToString(); + string variableName = ParseIdentifier(nameToken); + int? index = null; + + if (instructionName.Contains("arg", StringComparison.Ordinal)) { - var instrContext = context.GetRuleContext(0); - ILOpCode opcode = ((GrammarResult.Literal)instrContext.Accept(this)).Value; - if (opcode == ILOpCode.Localloc) + if (method.ArgumentNames.TryGetValue(variableName, out int argumentIndex)) { - _currentMethod!.Definition.HasDynamicStackAllocation = true; + index = method.Definition.SignatureHeader.IsInstance ? argumentIndex + 1 : argumentIndex; } - switch (instrContext.RuleIndex) + else { - case CILParser.RULE_instr_brtarget: - { - ParserRuleContext argument = context.GetRuleContext(1); - if (argument is CILParser.IdContext id) - { - string label = VisitId(id).Value; - if (!_currentMethod!.Labels.TryGetValue(label, out var handle)) - { - handle = _currentMethod.Definition.MethodBody.DefineLabel(); - _currentMethod.Labels[label] = handle; - // Track undefined label references for later validation - if (!_currentMethod.UndefinedLabelReferences.ContainsKey(label)) - { - _currentMethod.UndefinedLabelReferences[label] = context; - } - } - _currentMethod.Definition.MethodBody.Branch(opcode, handle); - } - if (argument is CILParser.Int32Context int32) - { - int offset = VisitInt32(int32).Value; - LabelHandle label = _currentMethod!.Definition.MethodBody.DefineLabel(); - _currentMethod.Definition.MethodBody.Branch(opcode, label); - _currentMethod.Definition.MethodBody.MarkLabel(label, _currentMethod.Definition.MethodBody.Offset + offset); - } - } - break; - case CILParser.RULE_instr_field: - { - _currentMethod!.Definition.MethodBody.OpCode(opcode); - if (context.mdtoken() is CILParser.MdtokenContext mdtoken) - { - var entity = VisitMdtoken(mdtoken).Value; - if (entity is EntityRegistry.TypeReferenceEntity mdTokenTypeRef) - { - mdTokenTypeRef.RecordBlobToWriteResolvedToken(_currentMethod.Definition.MethodBody.CodeBuilder.ReserveBytes(4)); - } - else - { - _currentMethod.Definition.MethodBody.Token(entity.Handle); - } - } - else - { - var fieldRef = VisitFieldRef(context.fieldRef()).Value; - if (fieldRef is EntityRegistry.MemberReferenceEntity memberRef) - { - memberRef.RecordBlobToWriteResolvedHandle(_currentMethod.Definition.MethodBody.CodeBuilder.ReserveBytes(4)); - } - else - { - _currentMethod.Definition.MethodBody.Token(fieldRef.Handle); - } - } - } - break; - case CILParser.RULE_instr_i: - { - int arg = VisitInt32(context.int32()).Value; - if (opcode == ILOpCode.Ldc_i4 || opcode == ILOpCode.Ldc_i4_s) - { - _currentMethod!.Definition.MethodBody.LoadConstantI4(arg); - } - else - { - _currentMethod!.Definition.MethodBody.OpCode(opcode); - _currentMethod.Definition.MethodBody.CodeBuilder.WriteByte((byte)arg); - } - } - break; - case CILParser.RULE_instr_i8: - Debug.Assert(opcode == ILOpCode.Ldc_i8); - _currentMethod!.Definition.MethodBody.LoadConstantI8(VisitInt64(context.int64()).Value); - break; - case CILParser.RULE_instr_method: - { - if (opcode == ILOpCode.Callvirt || opcode == ILOpCode.Newobj) - { - _expectInstance = true; - } - _currentMethod!.Definition.MethodBody.OpCode(opcode); - var methodRef = VisitMethodRef(context.methodRef()).Value; - if (methodRef is EntityRegistry.MemberReferenceEntity memberRef) - { - memberRef.RecordBlobToWriteResolvedHandle(_currentMethod.Definition.MethodBody.CodeBuilder.ReserveBytes(4)); - } - else - { - _currentMethod.Definition.MethodBody.Token(methodRef.Handle); - } - // Reset the instance flag for the next instruction. - if (opcode == ILOpCode.Callvirt || opcode == ILOpCode.Newobj) - { - _expectInstance = false; - } - } - break; - case CILParser.RULE_instr_none: - _currentMethod!.Definition.MethodBody.OpCode(opcode); - break; - case CILParser.RULE_instr_r: - { - double value; - ParserRuleContext argument = context.GetRuleContext(1); - if (argument is CILParser.Float64Context float64) - { - value = VisitFloat64(float64).Value; - } - else if (argument is CILParser.Int64Context int64) - { - long intValue = VisitInt64(int64).Value; - value = intValue; - } - else if (argument is CILParser.BytesContext bytesContext) - { - var bytes = VisitBytes(bytesContext).ToArray(); - if (bytes.Length >= 8) - { - value = BitConverter.ToDouble(bytes, 0); - } - else if (bytes.Length >= 4) - { - value = BitConverter.ToSingle(bytes, 0); - } - else - { - ReportError(DiagnosticIds.ByteArrayTooShort, DiagnosticMessageTemplates.ByteArrayTooShort, bytesContext); - value = 0.0d; - } - } - else - { - throw new UnreachableException(); - } - if (opcode == ILOpCode.Ldc_r4) - { - _currentMethod!.Definition.MethodBody.LoadConstantR4((float)value); - } - else - { - _currentMethod!.Definition.MethodBody.LoadConstantR8(value); - } - } - break; - case CILParser.RULE_instr_sig: - { - Debug.Assert(opcode == ILOpCode.Calli); - BlobBuilder signature = new(); - byte callConv = VisitCallConv(context.callConv()).Value; - signature.WriteByte(callConv); - var args = VisitSigArgs(context.sigArgs()).Value; - signature.WriteCompressedInteger(args.Count(arg => !arg.IsSentinel)); - // Write return type - VisitType(context.type()).Value.WriteContentTo(signature); - // Write arg signatures - foreach (var arg in args) - { - arg.SignatureBlob.WriteContentTo(signature); - } - _currentMethod!.Definition.MethodBody.OpCode(opcode); - _currentMethod!.Definition.MethodBody.Token(_entityRegistry.GetOrCreateStandaloneSignature(signature).Handle); - } - break; - case CILParser.RULE_instr_string: - Debug.Assert(opcode == ILOpCode.Ldstr); - string str; - if (context.bytes() is CILParser.BytesContext rawBytes) - { - ReadOnlySpan bytes = VisitBytes(rawBytes).AsSpan(); - ReadOnlySpan bytesAsChars = MemoryMarshal.Cast(bytes); - if (!BitConverter.IsLittleEndian) - { - for (int i = 0; i < bytesAsChars.Length; i++) - { - BinaryPrimitives.ReverseEndianness(bytesAsChars[i]); - } - } - str = bytesAsChars.ToString(); - } - else - { - var userString = context.compQstring(); - Debug.Assert(userString is not null); - str = VisitCompQstring(userString!).Value; - if (context.ANSI() is not null) - { - // Emit the string not as a UTF-16 string (as per the spec), but directly as an ANSI string. - // Although the string is marked as ANSI, this always used the UTF-8 code page - // so we can emit this as UTF-8 bytes. - int byteCount = Encoding.UTF8.GetByteCount(str); - // Ensure we have an even number of bytes. - if ((byteCount % 1) != 0) - { - byteCount++; - } - - Span utf8Bytes = new byte[byteCount]; - Encoding.UTF8.GetBytes(str, utf8Bytes); - - str = new string(MemoryMarshal.Cast(utf8Bytes)); - } - } - _currentMethod!.Definition.MethodBody.LoadString(_metadataBuilder.GetOrAddUserString(str)); - break; - case CILParser.RULE_instr_switch: - { - var labels = new List<(LabelHandle Label, int? Offset)>(); - if (context.labels()?.children is { } labelChildren) - { - foreach (var label in labelChildren) - { - if (label is CILParser.IdContext id) - { - string labelName = VisitId(id).Value; - if (!_currentMethod!.Labels.TryGetValue(labelName, out var handle)) - { - handle = _currentMethod.Definition.MethodBody.DefineLabel(); - _currentMethod.Labels[labelName] = handle; - // Track undefined label references for later validation - if (!_currentMethod.UndefinedLabelReferences.ContainsKey(labelName)) - { - _currentMethod.UndefinedLabelReferences[labelName] = context; - } - } - labels.Add((handle, null)); - } - else if (label is CILParser.Int32Context int32) - { - int offset = VisitInt32(int32).Value; - LabelHandle labelHandle = _currentMethod!.Definition.MethodBody.DefineLabel(); - labels.Add((labelHandle, offset)); - } - } - } - if (labels.Count > 0) - { - var switchEncoder = _currentMethod!.Definition.MethodBody.Switch(labels.Count); - foreach (var label in labels) - { - switchEncoder.Branch(label.Label); - } - } - else - { - // Empty switch: emit opcode + 0 count manually - _currentMethod!.Definition.MethodBody.OpCode(ILOpCode.Switch); - _currentMethod.Definition.MethodBody.CodeBuilder.WriteInt32(0); - } - // Now that we've emitted the switch instruction, we can go back and mark the offset-based target labels - foreach (var label in labels) - { - if (label.Offset is int offset) - { - _currentMethod.Definition.MethodBody.MarkLabel(label.Label, _currentMethod.Definition.MethodBody.Offset + offset); - } - } - } - break; - case CILParser.RULE_instr_tok: - _currentMethod!.Definition.MethodBody.OpCode(opcode); - if (context.int32() is { } tokenValue) - { - _currentMethod.Definition.MethodBody.CodeBuilder.WriteInt32(VisitInt32(tokenValue).Value); - break; - } - - var tok = VisitOwnerType(context.ownerType()).Value; - if (tok is EntityRegistry.TypeReferenceEntity tokTypeRef) - { - tokTypeRef.RecordBlobToWriteResolvedToken(_currentMethod.Definition.MethodBody.CodeBuilder.ReserveBytes(4)); - } - else if (tok is EntityRegistry.MemberReferenceEntity tokMemberRef) - { - tokMemberRef.RecordBlobToWriteResolvedHandle(_currentMethod.Definition.MethodBody.CodeBuilder.ReserveBytes(4)); - } - else - { - _currentMethod.Definition.MethodBody.Token(tok.Handle); - } - break; - case CILParser.RULE_instr_type: - { - var arg = VisitTypeSpec(context.typeSpec()).Value; - _currentMethod!.Definition.MethodBody.OpCode(opcode); - if (arg is EntityRegistry.TypeReferenceEntity argTypeRef) - { - argTypeRef.RecordBlobToWriteResolvedToken(_currentMethod.Definition.MethodBody.CodeBuilder.ReserveBytes(4)); - } - else - { - _currentMethod.Definition.MethodBody.Token(arg.Handle); - } - } - break; - case CILParser.RULE_instr_var: - { - string instrName = opcode.ToString(); - bool isShortForm = instrName.EndsWith("_s"); - _currentMethod!.Definition.MethodBody.OpCode(opcode); - if (context.int32() is CILParser.Int32Context int32) - { - int value = VisitInt32(int32).Value; - if (isShortForm) - { - // Emit a byte instead of the int for the short form - _currentMethod.Definition.MethodBody.CodeBuilder.WriteByte((byte)value); - } - else - { - _currentMethod.Definition.MethodBody.CodeBuilder.WriteInt32(value); - } - } - else - { - Debug.Assert(context.id() is not null); - string varName = VisitId(context.id()!).Value; - int? index = null; - if (instrName.Contains("arg")) - { - if (_currentMethod!.ArgumentNames.TryGetValue(varName, out var argIndex)) - { - index = argIndex; - - if (_currentMethod.Definition.SignatureHeader.IsInstance) - { - index++; - } - } - else - { - ReportError(DiagnosticIds.ArgumentNotFound, string.Format(DiagnosticMessageTemplates.ArgumentNotFound, varName), context); - } - } - else - { - for (int i = _currentMethod!.LocalsScopes.Count - 1; i >= 0 ; i--) - { - if (_currentMethod.LocalsScopes[i].TryGetValue(varName, out var localIndex)) - { - index = localIndex; - break; - } - } - if (index is null) - { - ReportError(DiagnosticIds.LocalNotFound, string.Format(DiagnosticMessageTemplates.LocalNotFound, varName), context); - } - } - - index ??= -1; - - if (isShortForm) - { - // Emit a byte instead of the int for the short form - _currentMethod.Definition.MethodBody.CodeBuilder.WriteByte((byte)index.Value); - } - else - { - _currentMethod.Definition.MethodBody.CodeBuilder.WriteInt32(index.Value); - } - } - } - break; + ReportError( + DiagnosticIds.ArgumentNotFound, + string.Format(DiagnosticMessageTemplates.ArgumentNotFound, variableName), + opcodeToken); } - return GrammarResult.SentinelValue.Result; } - - public GrammarResult.Literal VisitInstr_brtarget(CILParser.Instr_brtargetContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - public GrammarResult.Literal VisitInstr_field(CILParser.Instr_fieldContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - public GrammarResult.Literal VisitInstr_i(CILParser.Instr_iContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - public GrammarResult.Literal VisitInstr_i8(CILParser.Instr_i8Context context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - public GrammarResult.Literal VisitInstr_method(CILParser.Instr_methodContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - public GrammarResult.Literal VisitInstr_none(CILParser.Instr_noneContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - public GrammarResult.Literal VisitInstr_r(CILParser.Instr_rContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - public GrammarResult.Literal VisitInstr_sig(CILParser.Instr_sigContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - public GrammarResult.Literal VisitInstr_string(CILParser.Instr_stringContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - public GrammarResult.Literal VisitInstr_switch(CILParser.Instr_switchContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - public GrammarResult.Literal VisitInstr_tok(CILParser.Instr_tokContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - public GrammarResult.Literal VisitInstr_type(CILParser.Instr_typeContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - public GrammarResult.Literal VisitInstr_var(CILParser.Instr_varContext context) => new(ParseOpCodeFromToken(((ITerminalNode)context.children[0]).Symbol)); - private static ILOpCode ParseOpCodeFromToken(IToken token) + else { - string text = token.Text.TrimEnd('.'); - if (text == "unused") + for (int i = method.LocalsScopes.Count - 1; i >= 0; i--) { - // Native ilasm's keyword index uses the last matching opcode.def entry, CEE_UNUSED70. - return ILOpCode.Unused; + if (method.LocalsScopes[i].TryGetValue(variableName, out int localIndex)) + { + index = localIndex; + break; + } } - string normalized = text.Replace('.', '_'); - - // Handle instruction aliases that don't directly map to ILOpCode enum names - normalized = normalized switch + if (index is null) { - "ldelem_u8" => "ldelem_i8", - "ldind_u8" => "ldind_i8", - "endfault" => "endfinally", - _ => normalized - }; + ReportError( + DiagnosticIds.LocalNotFound, + string.Format(DiagnosticMessageTemplates.LocalNotFound, variableName), + opcodeToken); + } + } + + WriteVariableIndex(method, opcode, index ?? -1); + } + + internal void EmitInt32Instruction(IToken opcodeToken, IToken valueToken) + { + if (StartInstruction(opcodeToken) is not { } instruction) + { + return; + } + + int value = ParseInt32(valueToken); + if (instruction.OpCode is ILOpCode.Ldc_i4 or ILOpCode.Ldc_i4_s) + { + instruction.Method.Definition.MethodBody.LoadConstantI4(value); + return; + } + + instruction.Method.Definition.MethodBody.OpCode(instruction.OpCode); + instruction.Method.Definition.MethodBody.CodeBuilder.WriteByte((byte)value); + } + + internal void EmitInt64Instruction(IToken opcodeToken, IToken valueToken) + { + if (StartInstruction(opcodeToken) is not { } instruction) + { + return; + } + + Debug.Assert(instruction.OpCode == ILOpCode.Ldc_i8); + instruction.Method.Definition.MethodBody.LoadConstantI8(ParseInt64(valueToken)); + } + + internal void EmitBranchOffsetInstruction(IToken opcodeToken, IToken offsetToken) + { + if (StartInstruction(opcodeToken) is not { } instruction) + { + return; + } + + InstructionEncoder body = instruction.Method.Definition.MethodBody; + LabelHandle label = body.DefineLabel(); + body.Branch(instruction.OpCode, label); + body.MarkLabel(label, body.Offset + ParseInt32(offsetToken)); + } + + internal void EmitBranchLabelInstruction(IToken opcodeToken, IToken labelToken) + { + if (StartInstruction(opcodeToken) is not { } instruction) + { + return; + } + + CurrentMethodContext method = instruction.Method; + string labelName = ParseIdentifier(labelToken); + if (!method.Labels.TryGetValue(labelName, out LabelHandle label)) + { + label = method.Definition.MethodBody.DefineLabel(); + method.Labels[labelName] = label; + method.UndefinedLabelReferences.TryAdd(labelName, opcodeToken); + } + + method.Definition.MethodBody.Branch(instruction.OpCode, label); + } + + internal void EmitRawFloatingInstruction( + IToken opcodeToken, + ImmutableArray bytes, + IToken bytesToken) + { + if (StartInstruction(opcodeToken) is not { } instruction) + { + return; + } + + double value; + ReadOnlySpan byteSpan = bytes.AsSpan(); + if (byteSpan.Length >= sizeof(double)) + { + value = BitConverter.ToDouble(byteSpan); + } + else if (byteSpan.Length >= sizeof(float)) + { + value = BitConverter.ToSingle(byteSpan); + } + else + { + ReportError( + DiagnosticIds.ByteArrayTooShort, + DiagnosticMessageTemplates.ByteArrayTooShort, + bytesToken); + value = 0; + } + + if (instruction.OpCode == ILOpCode.Ldc_r4) + { + instruction.Method.Definition.MethodBody.LoadConstantR4((float)value); + } + else + { + instruction.Method.Definition.MethodBody.LoadConstantR8(value); + } + } + + internal void EmitRawStringInstruction(IToken opcodeToken, ImmutableArray bytes) + { + if (StartInstruction(opcodeToken) is not { } instruction) + { + return; + } + + string value = MemoryMarshal.Cast(bytes.AsSpan()).ToString(); + instruction.Method.Definition.MethodBody.LoadString(_metadataBuilder.GetOrAddUserString(value)); + } + + internal void EmitRawTokenInstruction(IToken opcodeToken, IToken valueToken) + { + if (StartInstruction(opcodeToken) is not { } instruction) + { + return; + } + + instruction.Method.Definition.MethodBody.OpCode(instruction.OpCode); + instruction.Method.Definition.MethodBody.CodeBuilder.WriteInt32(ParseInt32(valueToken)); + } + + internal void EmitByte(IToken valueToken) + { + _currentMethod?.Definition.MethodBody.CodeBuilder.WriteByte((byte)ParseInt32(valueToken)); + } + + internal void SetMaxStack(IToken valueToken) + { + if (_currentMethod is not null) + { + _currentMethod.Definition.MaxStack = ParseInt32(valueToken); + } + } + + internal void SetEntryPoint() + { + if (_currentMethod is not null) + { + _entityRegistry.EntryPoint = _currentMethod.Definition; + } + } + + internal void SetZeroInit() + { + if (_currentMethod is not null) + { + _currentMethod.Definition.BodyAttributes = MethodBodyAttributes.InitLocals; + } + } + + internal void DefineLabel(IToken nameToken) + { + if (_currentMethod is not { } method) + { + return; + } + + string labelName = ParseIdentifier(nameToken); + method.UndefinedLabelReferences.Remove(labelName); + if (!method.Labels.TryGetValue(labelName, out LabelHandle label)) + { + label = method.Definition.MethodBody.DefineLabel(); + method.Labels[labelName] = label; + } + + method.Definition.MethodBody.MarkLabel(label); + } - return (ILOpCode)Enum.Parse(typeof(ILOpCode), normalized, ignoreCase: true); + private (CurrentMethodContext Method, ILOpCode OpCode)? StartInstruction(IToken opcodeToken) + { + if (_currentMethod is not { } method) + { + return null; } - GrammarResult ICILVisitor.VisitInstr(CILParser.InstrContext context) => VisitInstr(context); - GrammarResult ICILVisitor.VisitInstr_brtarget(CILParser.Instr_brtargetContext context) => VisitInstr_brtarget(context); - GrammarResult ICILVisitor.VisitInstr_field(CILParser.Instr_fieldContext context) => VisitInstr_field(context); - GrammarResult ICILVisitor.VisitInstr_i(CILParser.Instr_iContext context) => VisitInstr_i(context); - GrammarResult ICILVisitor.VisitInstr_i8(CILParser.Instr_i8Context context) => VisitInstr_i8(context); - GrammarResult ICILVisitor.VisitInstr_method(CILParser.Instr_methodContext context) => VisitInstr_method(context); - GrammarResult ICILVisitor.VisitInstr_none(CILParser.Instr_noneContext context) => VisitInstr_none(context); - GrammarResult ICILVisitor.VisitInstr_r(CILParser.Instr_rContext context) => VisitInstr_r(context); - GrammarResult ICILVisitor.VisitInstr_sig(CILParser.Instr_sigContext context) => VisitInstr_sig(context); - GrammarResult ICILVisitor.VisitInstr_string(CILParser.Instr_stringContext context) => VisitInstr_string(context); - GrammarResult ICILVisitor.VisitInstr_switch(CILParser.Instr_switchContext context) => VisitInstr_switch(context); - GrammarResult ICILVisitor.VisitInstr_tok(CILParser.Instr_tokContext context) => VisitInstr_tok(context); - GrammarResult ICILVisitor.VisitInstr_type(CILParser.Instr_typeContext context) => VisitInstr_type(context); - GrammarResult ICILVisitor.VisitInstr_var(CILParser.Instr_varContext context) => VisitInstr_var(context); - - GrammarResult ICILVisitor.VisitMdtoken(ILAssembler.CILParser.MdtokenContext context) => VisitMdtoken(context); - public GrammarResult.Literal VisitMdtoken(CILParser.MdtokenContext context) + ILOpCode opcode = ParseOpCodeFromToken(opcodeToken); + if (opcode == ILOpCode.Localloc) { - return new(_entityRegistry.ResolveHandleToEntity(MetadataTokens.EntityHandle(VisitInt32(context.int32()).Value))); + method.Definition.HasDynamicStackAllocation = true; } -#pragma warning restore CA1822 // Mark members as static + return (method, opcode); + } + + private static void WriteVariableIndex(CurrentMethodContext method, ILOpCode opcode, int index) + { + method.Definition.MethodBody.OpCode(opcode); + if (opcode.ToString().EndsWith("_s", StringComparison.Ordinal)) + { + method.Definition.MethodBody.CodeBuilder.WriteByte((byte)index); + } + else + { + method.Definition.MethodBody.CodeBuilder.WriteInt32(index); + } + } + + private static ILOpCode ParseOpCodeFromToken(IToken token) + { + string text = token.Text.TrimEnd('.'); + if (text == "unused") + { + return ILOpCode.Unused; + } + + string normalized = text.Replace('.', '_'); + normalized = normalized switch + { + "ldelem_u8" => "ldelem_i8", + "ldind_u8" => "ldind_i8", + "endfault" => "endfinally", + _ => normalized + }; + + return (ILOpCode)Enum.Parse(typeof(ILOpCode), normalized, ignoreCase: true); + } + + GrammarResult ICILVisitor.VisitInstr(CILParser.InstrContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitSimpleInstr(CILParser.SimpleInstrContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitInstructionIsland(CILParser.InstructionIslandContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitMdtoken(CILParser.MdtokenContext context) => VisitMdtoken(context); + + public GrammarResult.Literal VisitMdtoken(CILParser.MdtokenContext context) + => new(_entityRegistry.ResolveHandleToEntity( + MetadataTokens.EntityHandle(VisitInt32(context.int32()).Value))); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs index 0895489eb2c878..5530d41769f15d 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs @@ -122,12 +122,15 @@ public GrammarResult.Literal VisitFloat64(CILParser.Float64Context conte GrammarResult ICILVisitor.VisitId(CILParser.IdContext context) => VisitId(context); public static GrammarResult.String VisitId(CILParser.IdContext context) { - string text = context.GetText(); - if (context.SQSTRING() is not null && text.Length >= 2 && text[0] == '\'') - { - text = text.Substring(1, text.Length - 2); - } - return new GrammarResult.String(text); + return new GrammarResult.String(ParseIdentifier(context.Start)); + } + + private static string ParseIdentifier(IToken token) + { + string text = token.Text; + return text.Length >= 2 && text[0] == '\'' + ? text.Substring(1, text.Length - 2) + : text; } private static bool ParseIntegerValue(ReadOnlySpan value, out long result) @@ -201,21 +204,23 @@ GrammarResult ICILVisitor.VisitInt32(CILParser.Int32Context conte public GrammarResult.Literal VisitInt32(CILParser.Int32Context context) { - IToken node = context.INT32().Symbol; - - ReadOnlySpan value = node.Text.AsSpan(); + return new(ParseInt32(context.INT32().Symbol)); + } + private int ParseInt32(IToken token) + { + ReadOnlySpan value = token.Text.AsSpan(); if (!ParseIntegerValue(value, out long num)) { _diagnostics.Add(new Diagnostic( DiagnosticIds.LiteralOutOfRange, DiagnosticSeverity.Error, - string.Format(DiagnosticMessageTemplates.LiteralOutOfRange, node.Text), - Location.From(node, _documents))); - return new GrammarResult.Literal(0); + string.Format(DiagnosticMessageTemplates.LiteralOutOfRange, token.Text), + Location.From(token, _documents))); + return 0; } - return new GrammarResult.Literal((int)num); + return (int)num; } @@ -226,21 +231,23 @@ GrammarResult ICILVisitor.VisitInt64(CILParser.Int64Context conte public GrammarResult.Literal VisitInt64(CILParser.Int64Context context) { - IToken node = context.GetChild(0).Symbol; - - ReadOnlySpan value = node.Text.AsSpan(); + return new(ParseInt64(context.Start)); + } + private long ParseInt64(IToken token) + { + ReadOnlySpan value = token.Text.AsSpan(); if (!ParseIntegerValue(value, out long num)) { _diagnostics.Add(new Diagnostic( DiagnosticIds.LiteralOutOfRange, DiagnosticSeverity.Error, - string.Format(DiagnosticMessageTemplates.LiteralOutOfRange, node.Text), - Location.From(node, _documents))); - return new GrammarResult.Literal(0); + string.Format(DiagnosticMessageTemplates.LiteralOutOfRange, token.Text), + Location.From(token, _documents))); + return 0; } - return new GrammarResult.Literal(num); + return num; } GrammarResult ICILVisitor.VisitIntOrWildcard(CILParser.IntOrWildcardContext context) => VisitIntOrWildcard(context); diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs index e8fc42f3c0912b..fb0d8ce15803d8 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs @@ -70,25 +70,6 @@ private void ResetMethodBodyState() _catchTypes.Clear(); } - internal void OnMethodDeclaration(CILParser.MethodDeclContext context) - { - // A method header that failed to parse never opened a method, so its body items have - // nothing to attach to. - if (_currentMethod is null) - { - return; - } - - if (TryProcessInstruction(context) || - context.scopeBlock() is not null || - context.sehBlock() is not null) - { - return; - } - - VisitMethodDecl(context); - } - internal void BeginScope(CILParser.ScopeBlockContext context) { if (_currentMethod is null) @@ -292,28 +273,16 @@ private LabelHandle GetFilterStart(CILParser.FilterClauseContext context) private readonly record struct ScopeFrame(CILParser.ScopeBlockContext Context, int Start, int LocalsScopeCount); - public GrammarResult VisitMethodDecl(CILParser.MethodDeclContext context) + internal GrammarResult ProcessMethodDeclarationIsland(CILParser.MethodDeclIslandContext context) { - Debug.Assert(_currentMethod is not null); - var currentMethod = _currentMethod!; - - if (context.EMITBYTE() is not null) - { - currentMethod.Definition.MethodBody.CodeBuilder.WriteByte((byte)VisitInt32(context.GetChild(0)).Value); - } - else if (context.ENTRYPOINT() is not null) - { - _entityRegistry.EntryPoint = currentMethod.Definition; - } - else if (context.ZEROINIT() is not null) - { - currentMethod.Definition.BodyAttributes = MethodBodyAttributes.InitLocals; - } - else if (context.MAXSTACK() is not null) + if (_currentMethod is null) { - currentMethod.Definition.MaxStack = VisitInt32(context.GetChild(0)).Value; + return GrammarResult.SentinelValue.Result; } - else if (context.LOCALS() is not null) + + var currentMethod = _currentMethod!; + + if (context.LOCALS() is not null) { if (context.ChildCount == 3) { @@ -348,18 +317,6 @@ public GrammarResult VisitMethodDecl(CILParser.MethodDeclContext context) currentMethod.AllLocals.Add(loc); } } - else if (context.labelDecl() is CILParser.LabelDeclContext labelDecl) - { - var labelId = labelDecl.id(); - string labelName = VisitId(labelId).Value; - currentMethod.DeclaredLabels.Add(labelName); - if (!currentMethod.Labels.TryGetValue(labelName, out var label)) - { - label = currentMethod.Definition.MethodBody.DefineLabel(); - currentMethod.Labels[labelName] = label; - } - currentMethod.Definition.MethodBody.MarkLabel(label); - } else if (context.EXPORT() is not null) { // .export [ordinal] or .export [ordinal] as alias @@ -566,10 +523,6 @@ public GrammarResult VisitMethodDecl(CILParser.MethodDeclContext context) customAttr.Owner = currentMethod.Definition; } } - else if (context.GetChild(0) is CILParser.InstrContext instr) - { - _ = VisitInstr(instr); - } else { // Handle other methodDecl alternatives @@ -643,35 +596,16 @@ private void ValidateLabelReferences() // Report errors for any labels that were referenced but never declared foreach (var undefinedLabel in _currentMethod.UndefinedLabelReferences) { - string labelName = undefinedLabel.Key; - ParserRuleContext context = undefinedLabel.Value; - - // Only report if the label was never declared - if (!_currentMethod.DeclaredLabels.Contains(labelName)) - { - ReportError(DiagnosticIds.LabelNotFound, - string.Format(DiagnosticMessageTemplates.LabelNotFound, labelName), - context); - } + ReportError( + DiagnosticIds.LabelNotFound, + string.Format(DiagnosticMessageTemplates.LabelNotFound, undefinedLabel.Key), + undefinedLabel.Value); } } public GrammarResult VisitLabels(CILParser.LabelsContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - GrammarResult ICILVisitor.VisitLabelDecl(CILParser.LabelDeclContext context) => VisitLabelDecl(context); - public GrammarResult VisitLabelDecl(CILParser.LabelDeclContext context) - { - var labelId = context.id(); - string labelName = VisitId(labelId).Value; - _currentMethod!.DeclaredLabels.Add(labelName); - if (!_currentMethod!.Labels.TryGetValue(labelName, out var label)) - { - label = _currentMethod.Definition.MethodBody.DefineLabel(); - _currentMethod.Labels[labelName] = label; - } - _currentMethod.Definition.MethodBody.MarkLabel(label); - return GrammarResult.SentinelValue.Result; - } + GrammarResult ICILVisitor.VisitLabelDecl(CILParser.LabelDeclContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); GrammarResult ICILVisitor.VisitMethAttr(CILParser.MethAttrContext context) => VisitMethAttr(context); public GrammarResult.Flag VisitMethAttr(CILParser.MethAttrContext context) @@ -708,6 +642,10 @@ public GrammarResult.Flag VisitMethAttr(CILParser.MethAttrCont public GrammarResult VisitMethodDecls(CILParser.MethodDeclsContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + GrammarResult ICILVisitor.VisitMethodDecl(CILParser.MethodDeclContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitMethodDeclIsland(CILParser.MethodDeclIslandContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + GrammarResult ICILVisitor.VisitMethodHead(CILParser.MethodHeadContext context) => VisitMethodHead(context); public GrammarResult.Literal VisitMethodHead(CILParser.MethodHeadContext context) { diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 index b907a5b2f0510e..644cf905fcc604 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 @@ -674,56 +674,41 @@ asmAttrAny: asmAttr: asmAttrAny*; /* IL instructions and associated definitions */ -instr_none: INSTR_NONE; - -instr_var: INSTR_VAR; - -instr_i: INSTR_I; - -instr_i8: INSTR_I8; - -instr_r: INSTR_R; - -instr_brtarget: INSTR_BRTARGET; - -instr_method: INSTR_METHOD; - -instr_field: INSTR_FIELD; - -instr_type: INSTR_TYPE; - -instr_string: INSTR_STRING; - -instr_sig: INSTR_SIG; - -instr_tok: INSTR_TOK; - -instr_switch: INSTR_SWITCH; - instr: - instr_none - | instr_var int32 - | instr_var id - | instr_i int32 - | instr_i8 int64 - | instr_r float64 - | instr_r int64 - | instr_r '(' bytes ')' - | instr_r 'bytearray' '(' bytes ')' // Support bytearray syntax for floating point instructions - | instr_brtarget int32 - | instr_brtarget id - | instr_method methodRef - | instr_field fieldRef - | instr_field mdtoken - | instr_type typeSpec - | instr_string compQstring - | instr_string ANSI '(' compQstring ')' - | instr_string 'bytearray' '(' bytes ')' - | instr_sig callConv type sigArgs - | instr_tok ownerType /* ownerType ::= memberRef | typeSpec */ - | instr_tok int32 - | instr_switch '(' labels ')' - | instr_switch '()'; + simpleInstr + | instructionIsland; + +simpleInstr: + op = INSTR_NONE {Actions.EmitNoOperandInstruction($op);} + | op = INSTR_VAR index = int32 {Actions.EmitVariableIndexInstruction($op, $index.start);} + | op = INSTR_VAR name = id {Actions.EmitVariableNameInstruction($op, $name.start);} + | op = INSTR_I value32 = int32 {Actions.EmitInt32Instruction($op, $value32.start);} + | op = INSTR_I8 value64 = int64 {Actions.EmitInt64Instruction($op, $value64.start);} + | op = INSTR_R '(' rawFloat = bytes ')' {Actions.EmitRawFloatingInstruction($op, $rawFloat.Value, $rawFloat.start);} + | op = INSTR_R 'bytearray' '(' rawFloat = bytes ')' {Actions.EmitRawFloatingInstruction($op, $rawFloat.Value, $rawFloat.start);} + | op = INSTR_BRTARGET offset = int32 {Actions.EmitBranchOffsetInstruction($op, $offset.start);} + | op = INSTR_BRTARGET label = id {Actions.EmitBranchLabelInstruction($op, $label.start);} + | op = INSTR_STRING 'bytearray' '(' rawString = bytes ')' {Actions.EmitRawStringInstruction($op, $rawString.Value);} + | op = INSTR_TOK rawToken = int32 {Actions.EmitRawTokenInstruction($op, $rawToken.start);}; + +instructionIsland +@init {BeginSubtree();} +@after {Actions.ProcessInstructionIsland(_localctx);} +: + INSTR_R float64 + | INSTR_R int64 + | INSTR_METHOD methodRef + | INSTR_FIELD fieldRef + | INSTR_FIELD mdtoken + | INSTR_TYPE typeSpec + | INSTR_STRING compQstring + | INSTR_STRING ANSI '(' compQstring ')' + | INSTR_SIG callConv type sigArgs + | INSTR_TOK ownerType /* ownerType ::= memberRef | typeSpec */ + | INSTR_SWITCH '(' labels ')' + | INSTR_SWITCH '()' +; +finally {EndParseTreeMode();} labels: /* empty */ @@ -1247,20 +1232,24 @@ methodDecls ; finally {EndParseTreeMode();} -methodDecl +methodDecl: + instr + | EMITBYTE value = int32 {Actions.EmitByte($value.start);} + | sehBlock + | MAXSTACK value = int32 {Actions.SetMaxStack($value.start);} + | ENTRYPOINT {Actions.SetEntryPoint();} + | ZEROINIT {Actions.SetZeroInit();} + | labelDecl + | scopeBlock + | methodDeclIsland; + +methodDeclIsland @init {BeginSubtree();} -@after {Actions.OnMethodDeclaration(_localctx);} +@after {Actions.ProcessMethodDeclarationIsland(_localctx);} : - instr // MOVED TO TOP - instructions must be matched first! - | EMITBYTE int32 - | sehBlock - | MAXSTACK int32 - | LOCALS sigArgs + LOCALS sigArgs | LOCALS 'init' sigArgs - | ENTRYPOINT - | ZEROINIT | dataDecl - | labelDecl | secDecl | extSourceSpec | languageDecl @@ -1271,15 +1260,16 @@ methodDecl | VTENTRY int32 ':' int32 | OVERRIDE typeSpec '::' methodName | OVERRIDE 'method' callConv type typeSpec '::' methodName genArity sigArgs - | scopeBlock | PARAM TYPE '[' int32 ']' customAttrDecl* | PARAM TYPE dottedName customAttrDecl* | PARAM CONSTRAINT '[' int32 ']' ',' typeSpec customAttrDecl* | PARAM CONSTRAINT dottedName ',' typeSpec customAttrDecl* - | PARAM '[' int32 ']' initOpt customAttrDecl*; + | PARAM '[' int32 ']' initOpt customAttrDecl* +; finally {EndParseTreeMode();} -labelDecl: id ':'; +labelDecl: + name = id ':' {Actions.DefineLabel($name.start);}; customDescrInMethodBody: customDescr @@ -1294,10 +1284,12 @@ finally {Actions.EndScope(_localctx);} /* Structured exception handling directives */ sehBlock +@init {BeginSubtree();} @after {Actions.EndExceptionBlock(_localctx);} : tryBlock sehClauses ; +finally {EndParseTreeMode();} sehClauses: sehClause+; diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.interp b/src/tools/ilasm/src/ILAssembler/gen/CIL.interp index f06280432cb855..44c235b4c009a1 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.interp +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.interp @@ -665,20 +665,9 @@ fileAttr fileEntry asmAttrAny asmAttr -instr_none -instr_var -instr_i -instr_i8 -instr_r -instr_brtarget -instr_method -instr_field -instr_type -instr_string -instr_sig -instr_tok -instr_switch instr +simpleInstr +instructionIsland labels typeArgs bounds @@ -751,6 +740,7 @@ methodName implAttr methodDecls methodDecl +methodDeclIsland labelDecl customDescrInMethodBody scopeBlock @@ -803,4 +793,4 @@ manifestResDecl atn: -[4, 1, 305, 2910, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 377, 8, 1, 10, 1, 12, 1, 380, 9, 1, 1, 1, 1, 1, 3, 1, 384, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 5, 3, 390, 8, 3, 10, 3, 12, 3, 393, 9, 3, 1, 3, 1, 3, 1, 4, 5, 4, 398, 8, 4, 10, 4, 12, 4, 401, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 453, 8, 5, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 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, 494, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 5, 15, 501, 8, 15, 10, 15, 12, 15, 504, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 527, 8, 18, 1, 19, 1, 19, 3, 19, 531, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 549, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 576, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 599, 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, 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, 635, 8, 23, 1, 24, 1, 24, 1, 25, 1, 25, 3, 25, 641, 8, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 5, 27, 648, 8, 27, 10, 27, 12, 27, 651, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 660, 8, 28, 10, 28, 12, 28, 663, 9, 28, 1, 29, 1, 29, 1, 30, 1, 30, 3, 30, 669, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 680, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 688, 8, 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, 34, 1, 34, 1, 34, 1, 34, 5, 34, 709, 8, 34, 10, 34, 12, 34, 712, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 5, 37, 725, 8, 37, 10, 37, 12, 37, 728, 9, 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, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 772, 8, 38, 1, 39, 1, 39, 1, 39, 3, 39, 777, 8, 39, 1, 40, 1, 40, 1, 40, 3, 40, 782, 8, 40, 1, 41, 5, 41, 785, 8, 41, 10, 41, 12, 41, 788, 9, 41, 1, 42, 1, 42, 1, 42, 5, 42, 793, 8, 42, 10, 42, 12, 42, 796, 9, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 905, 8, 44, 1, 45, 1, 45, 5, 45, 909, 8, 45, 10, 45, 12, 45, 912, 9, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 925, 8, 45, 10, 45, 12, 45, 928, 9, 45, 1, 45, 1, 45, 1, 45, 3, 45, 933, 8, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 939, 8, 47, 1, 48, 1, 48, 1, 49, 5, 49, 944, 8, 49, 10, 49, 12, 49, 947, 9, 49, 1, 50, 1, 50, 1, 51, 1, 51, 1, 52, 1, 52, 1, 53, 1, 53, 1, 54, 1, 54, 1, 55, 1, 55, 1, 56, 1, 56, 1, 57, 1, 57, 1, 58, 1, 58, 1, 59, 1, 59, 1, 60, 1, 60, 1, 61, 1, 61, 1, 62, 1, 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, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 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, 1057, 8, 63, 1, 64, 1, 64, 1, 64, 3, 64, 1062, 8, 64, 1, 64, 1, 64, 5, 64, 1066, 8, 64, 10, 64, 12, 64, 1069, 9, 64, 1, 64, 1, 64, 3, 64, 1073, 8, 64, 3, 64, 1075, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 5, 65, 1081, 8, 65, 10, 65, 12, 65, 1084, 9, 65, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 66, 5, 66, 1093, 8, 66, 10, 66, 12, 66, 1096, 9, 66, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 5, 67, 1105, 8, 67, 10, 67, 12, 67, 1108, 9, 67, 1, 67, 1, 67, 1, 67, 1, 67, 3, 67, 1114, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1121, 8, 68, 3, 68, 1123, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 3, 69, 1150, 8, 69, 1, 70, 1, 70, 1, 70, 5, 70, 1155, 8, 70, 10, 70, 12, 70, 1158, 9, 70, 1, 70, 1, 70, 1, 71, 5, 71, 1163, 8, 71, 10, 71, 12, 71, 1166, 9, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1173, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1186, 8, 73, 1, 74, 1, 74, 1, 74, 5, 74, 1191, 8, 74, 10, 74, 12, 74, 1194, 9, 74, 3, 74, 1196, 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, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1215, 8, 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, 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, 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, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 3, 76, 1309, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 1318, 8, 77, 1, 78, 1, 78, 1, 78, 5, 78, 1323, 8, 78, 10, 78, 12, 78, 1326, 9, 78, 3, 78, 1328, 8, 78, 1, 79, 1, 79, 1, 80, 1, 80, 5, 80, 1334, 8, 80, 10, 80, 12, 80, 1337, 9, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 3, 81, 1357, 8, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1389, 8, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 3, 83, 1412, 8, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1424, 8, 84, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1433, 8, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 1458, 8, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 1482, 8, 87, 1, 88, 1, 88, 1, 88, 1, 88, 5, 88, 1488, 8, 88, 10, 88, 12, 88, 1491, 9, 88, 1, 88, 3, 88, 1494, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1509, 8, 89, 1, 90, 1, 90, 1, 90, 5, 90, 1514, 8, 90, 10, 90, 12, 90, 1517, 9, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 3, 93, 1561, 8, 93, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 3, 95, 1571, 8, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 3, 95, 1587, 8, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 3, 95, 1599, 8, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 3, 96, 1611, 8, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 3, 97, 1625, 8, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 1637, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 3, 100, 1648, 8, 100, 1, 101, 1, 101, 1, 101, 5, 101, 1653, 8, 101, 10, 101, 12, 101, 1656, 9, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 1665, 8, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 3, 103, 1678, 8, 103, 1, 104, 5, 104, 1681, 8, 104, 10, 104, 12, 104, 1684, 9, 104, 1, 105, 1, 105, 3, 105, 1688, 8, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 5, 106, 1695, 8, 106, 10, 106, 12, 106, 1698, 9, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 108, 1, 108, 3, 108, 1708, 8, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 5, 110, 1789, 8, 110, 10, 110, 12, 110, 1792, 9, 110, 1, 110, 1, 110, 1, 110, 1, 110, 5, 110, 1798, 8, 110, 10, 110, 12, 110, 1801, 9, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 5, 110, 1811, 8, 110, 10, 110, 12, 110, 1814, 9, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 5, 110, 1822, 8, 110, 10, 110, 12, 110, 1825, 9, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 1832, 8, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 5, 111, 1842, 8, 111, 10, 111, 12, 111, 1845, 9, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 1871, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 1878, 8, 113, 1, 114, 1, 114, 1, 114, 3, 114, 1883, 8, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 3, 115, 1890, 8, 115, 1, 116, 1, 116, 5, 116, 1894, 8, 116, 10, 116, 12, 116, 1897, 9, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 5, 116, 1904, 8, 116, 10, 116, 12, 116, 1907, 9, 116, 1, 116, 3, 116, 1910, 8, 116, 1, 117, 1, 117, 1, 118, 5, 118, 1915, 8, 118, 10, 118, 12, 118, 1918, 9, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 1932, 8, 119, 1, 120, 1, 120, 5, 120, 1936, 8, 120, 10, 120, 12, 120, 1939, 9, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 122, 5, 122, 1950, 8, 122, 10, 122, 12, 122, 1953, 9, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 3, 123, 1965, 8, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 1973, 8, 124, 1, 125, 1, 125, 1, 125, 4, 125, 1978, 8, 125, 11, 125, 12, 125, 1979, 1, 125, 1, 125, 3, 125, 1984, 8, 125, 1, 126, 5, 126, 1987, 8, 126, 10, 126, 12, 126, 1990, 9, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 3, 127, 2005, 8, 127, 1, 128, 1, 128, 1, 128, 5, 128, 2010, 8, 128, 10, 128, 12, 128, 2013, 9, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 5, 128, 2023, 8, 128, 10, 128, 12, 128, 2026, 9, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 3, 129, 2051, 8, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 3, 130, 2058, 8, 130, 3, 130, 2060, 8, 130, 1, 130, 5, 130, 2063, 8, 130, 10, 130, 12, 130, 2066, 9, 130, 1, 130, 1, 130, 1, 130, 3, 130, 2071, 8, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 2100, 8, 131, 1, 132, 1, 132, 1, 132, 3, 132, 2105, 8, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 2128, 8, 133, 1, 134, 5, 134, 2131, 8, 134, 10, 134, 12, 134, 2134, 9, 134, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 5, 135, 2195, 8, 135, 10, 135, 12, 135, 2198, 9, 135, 1, 135, 1, 135, 1, 135, 1, 135, 5, 135, 2204, 8, 135, 10, 135, 12, 135, 2207, 9, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 5, 135, 2217, 8, 135, 10, 135, 12, 135, 2220, 9, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 5, 135, 2228, 8, 135, 10, 135, 12, 135, 2231, 9, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 5, 135, 2239, 8, 135, 10, 135, 12, 135, 2242, 9, 135, 3, 135, 2244, 8, 135, 1, 136, 1, 136, 1, 136, 1, 137, 1, 137, 3, 137, 2251, 8, 137, 1, 138, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 140, 4, 140, 2261, 8, 140, 11, 140, 12, 140, 2262, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 2277, 8, 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, 3, 142, 2291, 8, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 2299, 8, 143, 1, 144, 1, 144, 1, 144, 1, 145, 1, 145, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 2319, 8, 147, 1, 148, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 2331, 8, 149, 1, 150, 1, 150, 1, 150, 3, 150, 2336, 8, 150, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 4, 151, 2343, 8, 151, 11, 151, 12, 151, 2344, 3, 151, 2347, 8, 151, 1, 152, 1, 152, 1, 152, 5, 152, 2352, 8, 152, 10, 152, 12, 152, 2355, 9, 152, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 3, 153, 2364, 8, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 2432, 8, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 3, 155, 2509, 8, 155, 1, 156, 1, 156, 1, 156, 5, 156, 2514, 8, 156, 10, 156, 12, 156, 2517, 9, 156, 1, 157, 1, 157, 1, 158, 1, 158, 1, 158, 3, 158, 2524, 8, 158, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 3, 159, 2674, 8, 159, 1, 160, 1, 160, 5, 160, 2678, 8, 160, 10, 160, 12, 160, 2681, 9, 160, 1, 161, 1, 161, 5, 161, 2685, 8, 161, 10, 161, 12, 161, 2688, 9, 161, 1, 162, 5, 162, 2691, 8, 162, 10, 162, 12, 162, 2694, 9, 162, 1, 163, 5, 163, 2697, 8, 163, 10, 163, 12, 163, 2700, 9, 163, 1, 164, 5, 164, 2703, 8, 164, 10, 164, 12, 164, 2706, 9, 164, 1, 165, 5, 165, 2709, 8, 165, 10, 165, 12, 165, 2712, 9, 165, 1, 166, 5, 166, 2715, 8, 166, 10, 166, 12, 166, 2718, 9, 166, 1, 167, 5, 167, 2721, 8, 167, 10, 167, 12, 167, 2724, 9, 167, 1, 168, 5, 168, 2727, 8, 168, 10, 168, 12, 168, 2730, 9, 168, 1, 169, 1, 169, 1, 169, 1, 169, 3, 169, 2736, 8, 169, 1, 170, 5, 170, 2739, 8, 170, 10, 170, 12, 170, 2742, 9, 170, 1, 171, 1, 171, 1, 171, 3, 171, 2747, 8, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, 172, 2774, 8, 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, 3, 173, 2788, 8, 173, 1, 174, 5, 174, 2791, 8, 174, 10, 174, 12, 174, 2794, 9, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 3, 175, 2810, 8, 175, 1, 176, 1, 176, 1, 176, 5, 176, 2815, 8, 176, 10, 176, 12, 176, 2818, 9, 176, 1, 176, 1, 176, 1, 177, 1, 177, 5, 177, 2824, 8, 177, 10, 177, 12, 177, 2827, 9, 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, 178, 1, 178, 1, 178, 1, 178, 3, 178, 2846, 8, 178, 1, 179, 5, 179, 2849, 8, 179, 10, 179, 12, 179, 2852, 9, 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, 3, 180, 2867, 8, 180, 1, 181, 1, 181, 5, 181, 2871, 8, 181, 10, 181, 12, 181, 2874, 9, 181, 1, 181, 1, 181, 1, 181, 5, 181, 2879, 8, 181, 10, 181, 12, 181, 2882, 9, 181, 1, 181, 1, 181, 1, 181, 1, 181, 3, 181, 2888, 8, 181, 1, 182, 1, 182, 1, 183, 5, 183, 2893, 8, 183, 10, 183, 12, 183, 2896, 9, 183, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 3, 184, 2908, 8, 184, 1, 184, 0, 1, 68, 185, 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, 0, 16, 6, 0, 1, 15, 199, 199, 243, 243, 247, 247, 264, 264, 289, 289, 5, 0, 16, 16, 199, 199, 243, 243, 264, 264, 288, 289, 1, 0, 263, 264, 1, 0, 173, 174, 1, 0, 37, 38, 1, 0, 73, 74, 3, 0, 2, 2, 61, 61, 77, 83, 2, 0, 229, 229, 260, 261, 9, 0, 178, 178, 183, 195, 201, 201, 207, 208, 210, 215, 218, 219, 222, 222, 230, 242, 262, 262, 1, 0, 95, 96, 1, 0, 97, 111, 1, 0, 68, 69, 2, 0, 173, 173, 289, 290, 2, 0, 179, 179, 264, 264, 1, 0, 167, 168, 1, 0, 51, 52, 3327, 0, 370, 1, 0, 0, 0, 2, 383, 1, 0, 0, 0, 4, 385, 1, 0, 0, 0, 6, 391, 1, 0, 0, 0, 8, 399, 1, 0, 0, 0, 10, 452, 1, 0, 0, 0, 12, 454, 1, 0, 0, 0, 14, 457, 1, 0, 0, 0, 16, 460, 1, 0, 0, 0, 18, 464, 1, 0, 0, 0, 20, 467, 1, 0, 0, 0, 22, 470, 1, 0, 0, 0, 24, 477, 1, 0, 0, 0, 26, 493, 1, 0, 0, 0, 28, 495, 1, 0, 0, 0, 30, 497, 1, 0, 0, 0, 32, 507, 1, 0, 0, 0, 34, 509, 1, 0, 0, 0, 36, 526, 1, 0, 0, 0, 38, 530, 1, 0, 0, 0, 40, 548, 1, 0, 0, 0, 42, 575, 1, 0, 0, 0, 44, 598, 1, 0, 0, 0, 46, 634, 1, 0, 0, 0, 48, 636, 1, 0, 0, 0, 50, 640, 1, 0, 0, 0, 52, 642, 1, 0, 0, 0, 54, 649, 1, 0, 0, 0, 56, 661, 1, 0, 0, 0, 58, 664, 1, 0, 0, 0, 60, 666, 1, 0, 0, 0, 62, 679, 1, 0, 0, 0, 64, 687, 1, 0, 0, 0, 66, 689, 1, 0, 0, 0, 68, 697, 1, 0, 0, 0, 70, 713, 1, 0, 0, 0, 72, 719, 1, 0, 0, 0, 74, 722, 1, 0, 0, 0, 76, 771, 1, 0, 0, 0, 78, 776, 1, 0, 0, 0, 80, 781, 1, 0, 0, 0, 82, 786, 1, 0, 0, 0, 84, 794, 1, 0, 0, 0, 86, 799, 1, 0, 0, 0, 88, 904, 1, 0, 0, 0, 90, 932, 1, 0, 0, 0, 92, 934, 1, 0, 0, 0, 94, 938, 1, 0, 0, 0, 96, 940, 1, 0, 0, 0, 98, 945, 1, 0, 0, 0, 100, 948, 1, 0, 0, 0, 102, 950, 1, 0, 0, 0, 104, 952, 1, 0, 0, 0, 106, 954, 1, 0, 0, 0, 108, 956, 1, 0, 0, 0, 110, 958, 1, 0, 0, 0, 112, 960, 1, 0, 0, 0, 114, 962, 1, 0, 0, 0, 116, 964, 1, 0, 0, 0, 118, 966, 1, 0, 0, 0, 120, 968, 1, 0, 0, 0, 122, 970, 1, 0, 0, 0, 124, 972, 1, 0, 0, 0, 126, 1056, 1, 0, 0, 0, 128, 1074, 1, 0, 0, 0, 130, 1076, 1, 0, 0, 0, 132, 1088, 1, 0, 0, 0, 134, 1113, 1, 0, 0, 0, 136, 1122, 1, 0, 0, 0, 138, 1149, 1, 0, 0, 0, 140, 1156, 1, 0, 0, 0, 142, 1164, 1, 0, 0, 0, 144, 1172, 1, 0, 0, 0, 146, 1185, 1, 0, 0, 0, 148, 1195, 1, 0, 0, 0, 150, 1214, 1, 0, 0, 0, 152, 1308, 1, 0, 0, 0, 154, 1317, 1, 0, 0, 0, 156, 1327, 1, 0, 0, 0, 158, 1329, 1, 0, 0, 0, 160, 1331, 1, 0, 0, 0, 162, 1356, 1, 0, 0, 0, 164, 1388, 1, 0, 0, 0, 166, 1411, 1, 0, 0, 0, 168, 1423, 1, 0, 0, 0, 170, 1425, 1, 0, 0, 0, 172, 1428, 1, 0, 0, 0, 174, 1481, 1, 0, 0, 0, 176, 1493, 1, 0, 0, 0, 178, 1508, 1, 0, 0, 0, 180, 1515, 1, 0, 0, 0, 182, 1520, 1, 0, 0, 0, 184, 1524, 1, 0, 0, 0, 186, 1560, 1, 0, 0, 0, 188, 1562, 1, 0, 0, 0, 190, 1598, 1, 0, 0, 0, 192, 1610, 1, 0, 0, 0, 194, 1624, 1, 0, 0, 0, 196, 1626, 1, 0, 0, 0, 198, 1636, 1, 0, 0, 0, 200, 1647, 1, 0, 0, 0, 202, 1654, 1, 0, 0, 0, 204, 1664, 1, 0, 0, 0, 206, 1677, 1, 0, 0, 0, 208, 1682, 1, 0, 0, 0, 210, 1685, 1, 0, 0, 0, 212, 1696, 1, 0, 0, 0, 214, 1701, 1, 0, 0, 0, 216, 1707, 1, 0, 0, 0, 218, 1709, 1, 0, 0, 0, 220, 1831, 1, 0, 0, 0, 222, 1833, 1, 0, 0, 0, 224, 1870, 1, 0, 0, 0, 226, 1877, 1, 0, 0, 0, 228, 1882, 1, 0, 0, 0, 230, 1889, 1, 0, 0, 0, 232, 1909, 1, 0, 0, 0, 234, 1911, 1, 0, 0, 0, 236, 1916, 1, 0, 0, 0, 238, 1931, 1, 0, 0, 0, 240, 1933, 1, 0, 0, 0, 242, 1946, 1, 0, 0, 0, 244, 1951, 1, 0, 0, 0, 246, 1964, 1, 0, 0, 0, 248, 1972, 1, 0, 0, 0, 250, 1983, 1, 0, 0, 0, 252, 1988, 1, 0, 0, 0, 254, 2004, 1, 0, 0, 0, 256, 2006, 1, 0, 0, 0, 258, 2050, 1, 0, 0, 0, 260, 2070, 1, 0, 0, 0, 262, 2099, 1, 0, 0, 0, 264, 2104, 1, 0, 0, 0, 266, 2127, 1, 0, 0, 0, 268, 2132, 1, 0, 0, 0, 270, 2243, 1, 0, 0, 0, 272, 2245, 1, 0, 0, 0, 274, 2250, 1, 0, 0, 0, 276, 2252, 1, 0, 0, 0, 278, 2256, 1, 0, 0, 0, 280, 2260, 1, 0, 0, 0, 282, 2276, 1, 0, 0, 0, 284, 2290, 1, 0, 0, 0, 286, 2298, 1, 0, 0, 0, 288, 2300, 1, 0, 0, 0, 290, 2303, 1, 0, 0, 0, 292, 2305, 1, 0, 0, 0, 294, 2318, 1, 0, 0, 0, 296, 2320, 1, 0, 0, 0, 298, 2330, 1, 0, 0, 0, 300, 2335, 1, 0, 0, 0, 302, 2346, 1, 0, 0, 0, 304, 2353, 1, 0, 0, 0, 306, 2363, 1, 0, 0, 0, 308, 2431, 1, 0, 0, 0, 310, 2508, 1, 0, 0, 0, 312, 2515, 1, 0, 0, 0, 314, 2518, 1, 0, 0, 0, 316, 2523, 1, 0, 0, 0, 318, 2673, 1, 0, 0, 0, 320, 2679, 1, 0, 0, 0, 322, 2686, 1, 0, 0, 0, 324, 2692, 1, 0, 0, 0, 326, 2698, 1, 0, 0, 0, 328, 2704, 1, 0, 0, 0, 330, 2710, 1, 0, 0, 0, 332, 2716, 1, 0, 0, 0, 334, 2722, 1, 0, 0, 0, 336, 2728, 1, 0, 0, 0, 338, 2735, 1, 0, 0, 0, 340, 2740, 1, 0, 0, 0, 342, 2746, 1, 0, 0, 0, 344, 2773, 1, 0, 0, 0, 346, 2787, 1, 0, 0, 0, 348, 2792, 1, 0, 0, 0, 350, 2809, 1, 0, 0, 0, 352, 2811, 1, 0, 0, 0, 354, 2821, 1, 0, 0, 0, 356, 2845, 1, 0, 0, 0, 358, 2850, 1, 0, 0, 0, 360, 2866, 1, 0, 0, 0, 362, 2887, 1, 0, 0, 0, 364, 2889, 1, 0, 0, 0, 366, 2894, 1, 0, 0, 0, 368, 2907, 1, 0, 0, 0, 370, 371, 7, 0, 0, 0, 371, 1, 1, 0, 0, 0, 372, 384, 5, 288, 0, 0, 373, 374, 3, 4, 2, 0, 374, 375, 5, 265, 0, 0, 375, 377, 1, 0, 0, 0, 376, 373, 1, 0, 0, 0, 377, 380, 1, 0, 0, 0, 378, 376, 1, 0, 0, 0, 378, 379, 1, 0, 0, 0, 379, 381, 1, 0, 0, 0, 380, 378, 1, 0, 0, 0, 381, 384, 3, 4, 2, 0, 382, 384, 5, 264, 0, 0, 383, 372, 1, 0, 0, 0, 383, 378, 1, 0, 0, 0, 383, 382, 1, 0, 0, 0, 384, 3, 1, 0, 0, 0, 385, 386, 7, 1, 0, 0, 386, 5, 1, 0, 0, 0, 387, 388, 5, 263, 0, 0, 388, 390, 5, 266, 0, 0, 389, 387, 1, 0, 0, 0, 390, 393, 1, 0, 0, 0, 391, 389, 1, 0, 0, 0, 391, 392, 1, 0, 0, 0, 392, 394, 1, 0, 0, 0, 393, 391, 1, 0, 0, 0, 394, 395, 5, 263, 0, 0, 395, 7, 1, 0, 0, 0, 396, 398, 3, 10, 5, 0, 397, 396, 1, 0, 0, 0, 398, 401, 1, 0, 0, 0, 399, 397, 1, 0, 0, 0, 399, 400, 1, 0, 0, 0, 400, 9, 1, 0, 0, 0, 401, 399, 1, 0, 0, 0, 402, 403, 3, 74, 37, 0, 403, 404, 5, 17, 0, 0, 404, 405, 3, 82, 41, 0, 405, 406, 5, 18, 0, 0, 406, 453, 1, 0, 0, 0, 407, 408, 3, 72, 36, 0, 408, 409, 5, 17, 0, 0, 409, 410, 3, 8, 4, 0, 410, 411, 5, 18, 0, 0, 411, 453, 1, 0, 0, 0, 412, 413, 3, 256, 128, 0, 413, 414, 5, 17, 0, 0, 414, 415, 3, 268, 134, 0, 415, 416, 5, 18, 0, 0, 416, 453, 1, 0, 0, 0, 417, 453, 3, 222, 111, 0, 418, 453, 3, 296, 148, 0, 419, 453, 3, 70, 35, 0, 420, 453, 3, 66, 33, 0, 421, 453, 3, 88, 44, 0, 422, 453, 3, 90, 45, 0, 423, 453, 3, 22, 11, 0, 424, 425, 3, 346, 173, 0, 425, 426, 5, 17, 0, 0, 426, 427, 3, 348, 174, 0, 427, 428, 5, 18, 0, 0, 428, 453, 1, 0, 0, 0, 429, 430, 3, 352, 176, 0, 430, 431, 5, 17, 0, 0, 431, 432, 3, 358, 179, 0, 432, 433, 5, 18, 0, 0, 433, 453, 1, 0, 0, 0, 434, 435, 3, 362, 181, 0, 435, 436, 5, 17, 0, 0, 436, 437, 3, 366, 183, 0, 437, 438, 5, 18, 0, 0, 438, 453, 1, 0, 0, 0, 439, 453, 3, 64, 32, 0, 440, 453, 3, 174, 87, 0, 441, 453, 3, 342, 171, 0, 442, 453, 3, 12, 6, 0, 443, 453, 3, 14, 7, 0, 444, 453, 3, 16, 8, 0, 445, 453, 3, 18, 9, 0, 446, 453, 3, 20, 10, 0, 447, 453, 3, 26, 13, 0, 448, 453, 3, 42, 21, 0, 449, 453, 3, 40, 20, 0, 450, 453, 3, 30, 15, 0, 451, 453, 3, 24, 12, 0, 452, 402, 1, 0, 0, 0, 452, 407, 1, 0, 0, 0, 452, 412, 1, 0, 0, 0, 452, 417, 1, 0, 0, 0, 452, 418, 1, 0, 0, 0, 452, 419, 1, 0, 0, 0, 452, 420, 1, 0, 0, 0, 452, 421, 1, 0, 0, 0, 452, 422, 1, 0, 0, 0, 452, 423, 1, 0, 0, 0, 452, 424, 1, 0, 0, 0, 452, 429, 1, 0, 0, 0, 452, 434, 1, 0, 0, 0, 452, 439, 1, 0, 0, 0, 452, 440, 1, 0, 0, 0, 452, 441, 1, 0, 0, 0, 452, 442, 1, 0, 0, 0, 452, 443, 1, 0, 0, 0, 452, 444, 1, 0, 0, 0, 452, 445, 1, 0, 0, 0, 452, 446, 1, 0, 0, 0, 452, 447, 1, 0, 0, 0, 452, 448, 1, 0, 0, 0, 452, 449, 1, 0, 0, 0, 452, 450, 1, 0, 0, 0, 452, 451, 1, 0, 0, 0, 453, 11, 1, 0, 0, 0, 454, 455, 5, 19, 0, 0, 455, 456, 3, 32, 16, 0, 456, 13, 1, 0, 0, 0, 457, 458, 5, 20, 0, 0, 458, 459, 3, 32, 16, 0, 459, 15, 1, 0, 0, 0, 460, 461, 5, 21, 0, 0, 461, 462, 5, 22, 0, 0, 462, 463, 3, 32, 16, 0, 463, 17, 1, 0, 0, 0, 464, 465, 5, 23, 0, 0, 465, 466, 3, 34, 17, 0, 466, 19, 1, 0, 0, 0, 467, 468, 5, 24, 0, 0, 468, 469, 3, 34, 17, 0, 469, 21, 1, 0, 0, 0, 470, 471, 5, 25, 0, 0, 471, 472, 3, 98, 49, 0, 472, 473, 3, 2, 1, 0, 473, 474, 5, 17, 0, 0, 474, 475, 3, 142, 71, 0, 475, 476, 5, 18, 0, 0, 476, 23, 1, 0, 0, 0, 477, 478, 5, 26, 0, 0, 478, 25, 1, 0, 0, 0, 479, 480, 5, 27, 0, 0, 480, 494, 3, 28, 14, 0, 481, 482, 5, 27, 0, 0, 482, 483, 3, 28, 14, 0, 483, 484, 5, 28, 0, 0, 484, 485, 3, 28, 14, 0, 485, 494, 1, 0, 0, 0, 486, 487, 5, 27, 0, 0, 487, 488, 3, 28, 14, 0, 488, 489, 5, 28, 0, 0, 489, 490, 3, 28, 14, 0, 490, 491, 5, 28, 0, 0, 491, 492, 3, 28, 14, 0, 492, 494, 1, 0, 0, 0, 493, 479, 1, 0, 0, 0, 493, 481, 1, 0, 0, 0, 493, 486, 1, 0, 0, 0, 494, 27, 1, 0, 0, 0, 495, 496, 7, 2, 0, 0, 496, 29, 1, 0, 0, 0, 497, 498, 5, 29, 0, 0, 498, 502, 5, 17, 0, 0, 499, 501, 3, 138, 69, 0, 500, 499, 1, 0, 0, 0, 501, 504, 1, 0, 0, 0, 502, 500, 1, 0, 0, 0, 502, 503, 1, 0, 0, 0, 503, 505, 1, 0, 0, 0, 504, 502, 1, 0, 0, 0, 505, 506, 5, 18, 0, 0, 506, 31, 1, 0, 0, 0, 507, 508, 5, 173, 0, 0, 508, 33, 1, 0, 0, 0, 509, 510, 7, 3, 0, 0, 510, 35, 1, 0, 0, 0, 511, 527, 5, 175, 0, 0, 512, 513, 3, 32, 16, 0, 513, 514, 5, 265, 0, 0, 514, 527, 1, 0, 0, 0, 515, 527, 3, 32, 16, 0, 516, 517, 5, 188, 0, 0, 517, 518, 5, 30, 0, 0, 518, 519, 3, 32, 16, 0, 519, 520, 5, 31, 0, 0, 520, 527, 1, 0, 0, 0, 521, 522, 5, 189, 0, 0, 522, 523, 5, 30, 0, 0, 523, 524, 3, 34, 17, 0, 524, 525, 5, 31, 0, 0, 525, 527, 1, 0, 0, 0, 526, 511, 1, 0, 0, 0, 526, 512, 1, 0, 0, 0, 526, 515, 1, 0, 0, 0, 526, 516, 1, 0, 0, 0, 526, 521, 1, 0, 0, 0, 527, 37, 1, 0, 0, 0, 528, 531, 3, 32, 16, 0, 529, 531, 5, 262, 0, 0, 530, 528, 1, 0, 0, 0, 530, 529, 1, 0, 0, 0, 531, 39, 1, 0, 0, 0, 532, 533, 5, 267, 0, 0, 533, 549, 5, 289, 0, 0, 534, 535, 5, 267, 0, 0, 535, 536, 5, 289, 0, 0, 536, 549, 5, 263, 0, 0, 537, 538, 5, 268, 0, 0, 538, 549, 5, 289, 0, 0, 539, 540, 5, 269, 0, 0, 540, 549, 5, 289, 0, 0, 541, 542, 5, 270, 0, 0, 542, 549, 5, 289, 0, 0, 543, 549, 5, 271, 0, 0, 544, 549, 5, 272, 0, 0, 545, 546, 5, 273, 0, 0, 546, 549, 5, 263, 0, 0, 547, 549, 5, 32, 0, 0, 548, 532, 1, 0, 0, 0, 548, 534, 1, 0, 0, 0, 548, 537, 1, 0, 0, 0, 548, 539, 1, 0, 0, 0, 548, 541, 1, 0, 0, 0, 548, 543, 1, 0, 0, 0, 548, 544, 1, 0, 0, 0, 548, 545, 1, 0, 0, 0, 548, 547, 1, 0, 0, 0, 549, 41, 1, 0, 0, 0, 550, 551, 5, 33, 0, 0, 551, 552, 3, 160, 80, 0, 552, 553, 5, 34, 0, 0, 553, 554, 3, 2, 1, 0, 554, 576, 1, 0, 0, 0, 555, 556, 5, 33, 0, 0, 556, 557, 3, 138, 69, 0, 557, 558, 5, 34, 0, 0, 558, 559, 3, 2, 1, 0, 559, 576, 1, 0, 0, 0, 560, 561, 5, 33, 0, 0, 561, 562, 3, 198, 99, 0, 562, 563, 5, 34, 0, 0, 563, 564, 3, 2, 1, 0, 564, 576, 1, 0, 0, 0, 565, 566, 5, 33, 0, 0, 566, 567, 3, 44, 22, 0, 567, 568, 5, 34, 0, 0, 568, 569, 3, 2, 1, 0, 569, 576, 1, 0, 0, 0, 570, 571, 5, 33, 0, 0, 571, 572, 3, 46, 23, 0, 572, 573, 5, 34, 0, 0, 573, 574, 3, 2, 1, 0, 574, 576, 1, 0, 0, 0, 575, 550, 1, 0, 0, 0, 575, 555, 1, 0, 0, 0, 575, 560, 1, 0, 0, 0, 575, 565, 1, 0, 0, 0, 575, 570, 1, 0, 0, 0, 576, 43, 1, 0, 0, 0, 577, 578, 5, 35, 0, 0, 578, 599, 3, 48, 24, 0, 579, 580, 5, 35, 0, 0, 580, 581, 3, 48, 24, 0, 581, 582, 5, 36, 0, 0, 582, 583, 3, 6, 3, 0, 583, 599, 1, 0, 0, 0, 584, 585, 5, 35, 0, 0, 585, 586, 3, 48, 24, 0, 586, 587, 5, 36, 0, 0, 587, 588, 5, 17, 0, 0, 588, 589, 3, 52, 26, 0, 589, 590, 5, 18, 0, 0, 590, 599, 1, 0, 0, 0, 591, 592, 5, 35, 0, 0, 592, 593, 3, 48, 24, 0, 593, 594, 5, 36, 0, 0, 594, 595, 5, 30, 0, 0, 595, 596, 3, 312, 156, 0, 596, 597, 5, 31, 0, 0, 597, 599, 1, 0, 0, 0, 598, 577, 1, 0, 0, 0, 598, 579, 1, 0, 0, 0, 598, 584, 1, 0, 0, 0, 598, 591, 1, 0, 0, 0, 599, 45, 1, 0, 0, 0, 600, 601, 5, 35, 0, 0, 601, 602, 5, 30, 0, 0, 602, 603, 3, 50, 25, 0, 603, 604, 5, 31, 0, 0, 604, 605, 3, 48, 24, 0, 605, 635, 1, 0, 0, 0, 606, 607, 5, 35, 0, 0, 607, 608, 5, 30, 0, 0, 608, 609, 3, 50, 25, 0, 609, 610, 5, 31, 0, 0, 610, 611, 3, 48, 24, 0, 611, 612, 5, 36, 0, 0, 612, 613, 3, 6, 3, 0, 613, 635, 1, 0, 0, 0, 614, 615, 5, 35, 0, 0, 615, 616, 5, 30, 0, 0, 616, 617, 3, 50, 25, 0, 617, 618, 5, 31, 0, 0, 618, 619, 3, 48, 24, 0, 619, 620, 5, 36, 0, 0, 620, 621, 5, 17, 0, 0, 621, 622, 3, 52, 26, 0, 622, 623, 5, 18, 0, 0, 623, 635, 1, 0, 0, 0, 624, 625, 5, 35, 0, 0, 625, 626, 5, 30, 0, 0, 626, 627, 3, 50, 25, 0, 627, 628, 5, 31, 0, 0, 628, 629, 3, 48, 24, 0, 629, 630, 5, 36, 0, 0, 630, 631, 5, 30, 0, 0, 631, 632, 3, 312, 156, 0, 632, 633, 5, 31, 0, 0, 633, 635, 1, 0, 0, 0, 634, 600, 1, 0, 0, 0, 634, 606, 1, 0, 0, 0, 634, 614, 1, 0, 0, 0, 634, 624, 1, 0, 0, 0, 635, 47, 1, 0, 0, 0, 636, 637, 3, 190, 95, 0, 637, 49, 1, 0, 0, 0, 638, 641, 3, 146, 73, 0, 639, 641, 3, 198, 99, 0, 640, 638, 1, 0, 0, 0, 640, 639, 1, 0, 0, 0, 641, 51, 1, 0, 0, 0, 642, 643, 3, 54, 27, 0, 643, 644, 3, 56, 28, 0, 644, 53, 1, 0, 0, 0, 645, 648, 3, 318, 159, 0, 646, 648, 3, 40, 20, 0, 647, 645, 1, 0, 0, 0, 647, 646, 1, 0, 0, 0, 648, 651, 1, 0, 0, 0, 649, 647, 1, 0, 0, 0, 649, 650, 1, 0, 0, 0, 650, 55, 1, 0, 0, 0, 651, 649, 1, 0, 0, 0, 652, 653, 3, 58, 29, 0, 653, 654, 3, 60, 30, 0, 654, 655, 3, 2, 1, 0, 655, 656, 5, 36, 0, 0, 656, 657, 3, 318, 159, 0, 657, 660, 1, 0, 0, 0, 658, 660, 3, 40, 20, 0, 659, 652, 1, 0, 0, 0, 659, 658, 1, 0, 0, 0, 660, 663, 1, 0, 0, 0, 661, 659, 1, 0, 0, 0, 661, 662, 1, 0, 0, 0, 662, 57, 1, 0, 0, 0, 663, 661, 1, 0, 0, 0, 664, 665, 7, 4, 0, 0, 665, 59, 1, 0, 0, 0, 666, 668, 3, 62, 31, 0, 667, 669, 5, 261, 0, 0, 668, 667, 1, 0, 0, 0, 668, 669, 1, 0, 0, 0, 669, 61, 1, 0, 0, 0, 670, 680, 3, 166, 83, 0, 671, 680, 3, 2, 1, 0, 672, 680, 5, 196, 0, 0, 673, 680, 5, 197, 0, 0, 674, 675, 5, 202, 0, 0, 675, 676, 5, 39, 0, 0, 676, 680, 5, 264, 0, 0, 677, 678, 5, 202, 0, 0, 678, 680, 3, 138, 69, 0, 679, 670, 1, 0, 0, 0, 679, 671, 1, 0, 0, 0, 679, 672, 1, 0, 0, 0, 679, 673, 1, 0, 0, 0, 679, 674, 1, 0, 0, 0, 679, 677, 1, 0, 0, 0, 680, 63, 1, 0, 0, 0, 681, 682, 5, 198, 0, 0, 682, 683, 5, 40, 0, 0, 683, 688, 3, 2, 1, 0, 684, 685, 5, 198, 0, 0, 685, 688, 3, 2, 1, 0, 686, 688, 5, 198, 0, 0, 687, 681, 1, 0, 0, 0, 687, 684, 1, 0, 0, 0, 687, 686, 1, 0, 0, 0, 688, 65, 1, 0, 0, 0, 689, 690, 5, 41, 0, 0, 690, 691, 5, 42, 0, 0, 691, 692, 3, 32, 16, 0, 692, 693, 5, 43, 0, 0, 693, 694, 3, 68, 34, 0, 694, 695, 5, 44, 0, 0, 695, 696, 3, 0, 0, 0, 696, 67, 1, 0, 0, 0, 697, 710, 6, 34, -1, 0, 698, 699, 10, 5, 0, 0, 699, 709, 5, 186, 0, 0, 700, 701, 10, 4, 0, 0, 701, 709, 5, 187, 0, 0, 702, 703, 10, 3, 0, 0, 703, 709, 5, 45, 0, 0, 704, 705, 10, 2, 0, 0, 705, 709, 5, 46, 0, 0, 706, 707, 10, 1, 0, 0, 707, 709, 5, 47, 0, 0, 708, 698, 1, 0, 0, 0, 708, 700, 1, 0, 0, 0, 708, 702, 1, 0, 0, 0, 708, 704, 1, 0, 0, 0, 708, 706, 1, 0, 0, 0, 709, 712, 1, 0, 0, 0, 710, 708, 1, 0, 0, 0, 710, 711, 1, 0, 0, 0, 711, 69, 1, 0, 0, 0, 712, 710, 1, 0, 0, 0, 713, 714, 5, 48, 0, 0, 714, 715, 5, 36, 0, 0, 715, 716, 5, 30, 0, 0, 716, 717, 3, 312, 156, 0, 717, 718, 5, 31, 0, 0, 718, 71, 1, 0, 0, 0, 719, 720, 5, 49, 0, 0, 720, 721, 3, 2, 1, 0, 721, 73, 1, 0, 0, 0, 722, 726, 5, 50, 0, 0, 723, 725, 3, 76, 38, 0, 724, 723, 1, 0, 0, 0, 725, 728, 1, 0, 0, 0, 726, 724, 1, 0, 0, 0, 726, 727, 1, 0, 0, 0, 727, 729, 1, 0, 0, 0, 728, 726, 1, 0, 0, 0, 729, 730, 3, 2, 1, 0, 730, 731, 3, 204, 102, 0, 731, 732, 3, 78, 39, 0, 732, 733, 3, 80, 40, 0, 733, 75, 1, 0, 0, 0, 734, 772, 5, 51, 0, 0, 735, 772, 5, 52, 0, 0, 736, 772, 5, 199, 0, 0, 737, 772, 5, 202, 0, 0, 738, 772, 5, 221, 0, 0, 739, 772, 5, 53, 0, 0, 740, 772, 5, 54, 0, 0, 741, 772, 5, 55, 0, 0, 742, 772, 5, 56, 0, 0, 743, 772, 5, 244, 0, 0, 744, 772, 5, 15, 0, 0, 745, 772, 5, 224, 0, 0, 746, 772, 5, 57, 0, 0, 747, 772, 5, 58, 0, 0, 748, 772, 5, 59, 0, 0, 749, 772, 5, 60, 0, 0, 750, 772, 5, 61, 0, 0, 751, 752, 5, 62, 0, 0, 752, 772, 5, 51, 0, 0, 753, 754, 5, 62, 0, 0, 754, 772, 5, 52, 0, 0, 755, 756, 5, 62, 0, 0, 756, 772, 5, 63, 0, 0, 757, 758, 5, 62, 0, 0, 758, 772, 5, 64, 0, 0, 759, 760, 5, 62, 0, 0, 760, 772, 5, 65, 0, 0, 761, 762, 5, 62, 0, 0, 762, 772, 5, 66, 0, 0, 763, 772, 5, 67, 0, 0, 764, 772, 5, 68, 0, 0, 765, 772, 5, 69, 0, 0, 766, 767, 5, 70, 0, 0, 767, 768, 5, 30, 0, 0, 768, 769, 3, 32, 16, 0, 769, 770, 5, 31, 0, 0, 770, 772, 1, 0, 0, 0, 771, 734, 1, 0, 0, 0, 771, 735, 1, 0, 0, 0, 771, 736, 1, 0, 0, 0, 771, 737, 1, 0, 0, 0, 771, 738, 1, 0, 0, 0, 771, 739, 1, 0, 0, 0, 771, 740, 1, 0, 0, 0, 771, 741, 1, 0, 0, 0, 771, 742, 1, 0, 0, 0, 771, 743, 1, 0, 0, 0, 771, 744, 1, 0, 0, 0, 771, 745, 1, 0, 0, 0, 771, 746, 1, 0, 0, 0, 771, 747, 1, 0, 0, 0, 771, 748, 1, 0, 0, 0, 771, 749, 1, 0, 0, 0, 771, 750, 1, 0, 0, 0, 771, 751, 1, 0, 0, 0, 771, 753, 1, 0, 0, 0, 771, 755, 1, 0, 0, 0, 771, 757, 1, 0, 0, 0, 771, 759, 1, 0, 0, 0, 771, 761, 1, 0, 0, 0, 771, 763, 1, 0, 0, 0, 771, 764, 1, 0, 0, 0, 771, 765, 1, 0, 0, 0, 771, 766, 1, 0, 0, 0, 772, 77, 1, 0, 0, 0, 773, 777, 1, 0, 0, 0, 774, 775, 5, 71, 0, 0, 775, 777, 3, 146, 73, 0, 776, 773, 1, 0, 0, 0, 776, 774, 1, 0, 0, 0, 777, 79, 1, 0, 0, 0, 778, 782, 1, 0, 0, 0, 779, 780, 5, 72, 0, 0, 780, 782, 3, 84, 42, 0, 781, 778, 1, 0, 0, 0, 781, 779, 1, 0, 0, 0, 782, 81, 1, 0, 0, 0, 783, 785, 3, 220, 110, 0, 784, 783, 1, 0, 0, 0, 785, 788, 1, 0, 0, 0, 786, 784, 1, 0, 0, 0, 786, 787, 1, 0, 0, 0, 787, 83, 1, 0, 0, 0, 788, 786, 1, 0, 0, 0, 789, 790, 3, 146, 73, 0, 790, 791, 5, 28, 0, 0, 791, 793, 1, 0, 0, 0, 792, 789, 1, 0, 0, 0, 793, 796, 1, 0, 0, 0, 794, 792, 1, 0, 0, 0, 794, 795, 1, 0, 0, 0, 795, 797, 1, 0, 0, 0, 796, 794, 1, 0, 0, 0, 797, 798, 3, 146, 73, 0, 798, 85, 1, 0, 0, 0, 799, 800, 7, 5, 0, 0, 800, 87, 1, 0, 0, 0, 801, 802, 3, 86, 43, 0, 802, 803, 3, 32, 16, 0, 803, 804, 5, 264, 0, 0, 804, 905, 1, 0, 0, 0, 805, 806, 3, 86, 43, 0, 806, 807, 3, 32, 16, 0, 807, 905, 1, 0, 0, 0, 808, 809, 3, 86, 43, 0, 809, 810, 3, 32, 16, 0, 810, 811, 5, 75, 0, 0, 811, 812, 3, 32, 16, 0, 812, 813, 5, 264, 0, 0, 813, 905, 1, 0, 0, 0, 814, 815, 3, 86, 43, 0, 815, 816, 3, 32, 16, 0, 816, 817, 5, 75, 0, 0, 817, 818, 3, 32, 16, 0, 818, 905, 1, 0, 0, 0, 819, 820, 3, 86, 43, 0, 820, 821, 3, 32, 16, 0, 821, 822, 5, 75, 0, 0, 822, 823, 3, 32, 16, 0, 823, 824, 5, 28, 0, 0, 824, 825, 3, 32, 16, 0, 825, 826, 5, 264, 0, 0, 826, 905, 1, 0, 0, 0, 827, 828, 3, 86, 43, 0, 828, 829, 3, 32, 16, 0, 829, 830, 5, 75, 0, 0, 830, 831, 3, 32, 16, 0, 831, 832, 5, 28, 0, 0, 832, 833, 3, 32, 16, 0, 833, 905, 1, 0, 0, 0, 834, 835, 3, 86, 43, 0, 835, 836, 3, 32, 16, 0, 836, 837, 5, 28, 0, 0, 837, 838, 3, 32, 16, 0, 838, 839, 5, 75, 0, 0, 839, 840, 3, 32, 16, 0, 840, 841, 5, 264, 0, 0, 841, 905, 1, 0, 0, 0, 842, 843, 3, 86, 43, 0, 843, 844, 3, 32, 16, 0, 844, 845, 5, 28, 0, 0, 845, 846, 3, 32, 16, 0, 846, 847, 5, 75, 0, 0, 847, 848, 3, 32, 16, 0, 848, 905, 1, 0, 0, 0, 849, 850, 3, 86, 43, 0, 850, 851, 3, 32, 16, 0, 851, 852, 5, 28, 0, 0, 852, 853, 3, 32, 16, 0, 853, 854, 5, 75, 0, 0, 854, 855, 3, 32, 16, 0, 855, 856, 5, 28, 0, 0, 856, 857, 3, 32, 16, 0, 857, 858, 5, 264, 0, 0, 858, 905, 1, 0, 0, 0, 859, 860, 3, 86, 43, 0, 860, 861, 3, 32, 16, 0, 861, 862, 5, 28, 0, 0, 862, 863, 3, 32, 16, 0, 863, 864, 5, 75, 0, 0, 864, 865, 3, 32, 16, 0, 865, 866, 5, 28, 0, 0, 866, 867, 3, 32, 16, 0, 867, 905, 1, 0, 0, 0, 868, 869, 3, 86, 43, 0, 869, 870, 3, 32, 16, 0, 870, 871, 5, 263, 0, 0, 871, 905, 1, 0, 0, 0, 872, 873, 3, 86, 43, 0, 873, 874, 3, 32, 16, 0, 874, 875, 5, 75, 0, 0, 875, 876, 3, 32, 16, 0, 876, 877, 5, 263, 0, 0, 877, 905, 1, 0, 0, 0, 878, 879, 3, 86, 43, 0, 879, 880, 3, 32, 16, 0, 880, 881, 5, 75, 0, 0, 881, 882, 3, 32, 16, 0, 882, 883, 5, 28, 0, 0, 883, 884, 3, 32, 16, 0, 884, 885, 5, 263, 0, 0, 885, 905, 1, 0, 0, 0, 886, 887, 3, 86, 43, 0, 887, 888, 3, 32, 16, 0, 888, 889, 5, 28, 0, 0, 889, 890, 3, 32, 16, 0, 890, 891, 5, 75, 0, 0, 891, 892, 3, 32, 16, 0, 892, 893, 5, 263, 0, 0, 893, 905, 1, 0, 0, 0, 894, 895, 3, 86, 43, 0, 895, 896, 3, 32, 16, 0, 896, 897, 5, 28, 0, 0, 897, 898, 3, 32, 16, 0, 898, 899, 5, 75, 0, 0, 899, 900, 3, 32, 16, 0, 900, 901, 5, 28, 0, 0, 901, 902, 3, 32, 16, 0, 902, 903, 5, 263, 0, 0, 903, 905, 1, 0, 0, 0, 904, 801, 1, 0, 0, 0, 904, 805, 1, 0, 0, 0, 904, 808, 1, 0, 0, 0, 904, 814, 1, 0, 0, 0, 904, 819, 1, 0, 0, 0, 904, 827, 1, 0, 0, 0, 904, 834, 1, 0, 0, 0, 904, 842, 1, 0, 0, 0, 904, 849, 1, 0, 0, 0, 904, 859, 1, 0, 0, 0, 904, 868, 1, 0, 0, 0, 904, 872, 1, 0, 0, 0, 904, 878, 1, 0, 0, 0, 904, 886, 1, 0, 0, 0, 904, 894, 1, 0, 0, 0, 905, 89, 1, 0, 0, 0, 906, 910, 5, 21, 0, 0, 907, 909, 3, 92, 46, 0, 908, 907, 1, 0, 0, 0, 909, 912, 1, 0, 0, 0, 910, 908, 1, 0, 0, 0, 910, 911, 1, 0, 0, 0, 911, 913, 1, 0, 0, 0, 912, 910, 1, 0, 0, 0, 913, 914, 3, 2, 1, 0, 914, 915, 3, 94, 47, 0, 915, 916, 5, 180, 0, 0, 916, 917, 5, 36, 0, 0, 917, 918, 5, 30, 0, 0, 918, 919, 3, 312, 156, 0, 919, 920, 5, 31, 0, 0, 920, 921, 3, 94, 47, 0, 921, 933, 1, 0, 0, 0, 922, 926, 5, 21, 0, 0, 923, 925, 3, 92, 46, 0, 924, 923, 1, 0, 0, 0, 925, 928, 1, 0, 0, 0, 926, 924, 1, 0, 0, 0, 926, 927, 1, 0, 0, 0, 927, 929, 1, 0, 0, 0, 928, 926, 1, 0, 0, 0, 929, 930, 3, 2, 1, 0, 930, 931, 3, 94, 47, 0, 931, 933, 1, 0, 0, 0, 932, 906, 1, 0, 0, 0, 932, 922, 1, 0, 0, 0, 933, 91, 1, 0, 0, 0, 934, 935, 5, 76, 0, 0, 935, 93, 1, 0, 0, 0, 936, 939, 1, 0, 0, 0, 937, 939, 5, 298, 0, 0, 938, 936, 1, 0, 0, 0, 938, 937, 1, 0, 0, 0, 939, 95, 1, 0, 0, 0, 940, 941, 7, 6, 0, 0, 941, 97, 1, 0, 0, 0, 942, 944, 3, 96, 48, 0, 943, 942, 1, 0, 0, 0, 944, 947, 1, 0, 0, 0, 945, 943, 1, 0, 0, 0, 945, 946, 1, 0, 0, 0, 946, 99, 1, 0, 0, 0, 947, 945, 1, 0, 0, 0, 948, 949, 5, 275, 0, 0, 949, 101, 1, 0, 0, 0, 950, 951, 5, 276, 0, 0, 951, 103, 1, 0, 0, 0, 952, 953, 5, 277, 0, 0, 953, 105, 1, 0, 0, 0, 954, 955, 5, 278, 0, 0, 955, 107, 1, 0, 0, 0, 956, 957, 5, 279, 0, 0, 957, 109, 1, 0, 0, 0, 958, 959, 5, 282, 0, 0, 959, 111, 1, 0, 0, 0, 960, 961, 5, 280, 0, 0, 961, 113, 1, 0, 0, 0, 962, 963, 5, 286, 0, 0, 963, 115, 1, 0, 0, 0, 964, 965, 5, 284, 0, 0, 965, 117, 1, 0, 0, 0, 966, 967, 5, 285, 0, 0, 967, 119, 1, 0, 0, 0, 968, 969, 5, 281, 0, 0, 969, 121, 1, 0, 0, 0, 970, 971, 5, 287, 0, 0, 971, 123, 1, 0, 0, 0, 972, 973, 5, 283, 0, 0, 973, 125, 1, 0, 0, 0, 974, 1057, 3, 100, 50, 0, 975, 976, 3, 102, 51, 0, 976, 977, 3, 32, 16, 0, 977, 1057, 1, 0, 0, 0, 978, 979, 3, 102, 51, 0, 979, 980, 3, 0, 0, 0, 980, 1057, 1, 0, 0, 0, 981, 982, 3, 104, 52, 0, 982, 983, 3, 32, 16, 0, 983, 1057, 1, 0, 0, 0, 984, 985, 3, 106, 53, 0, 985, 986, 3, 34, 17, 0, 986, 1057, 1, 0, 0, 0, 987, 988, 3, 108, 54, 0, 988, 989, 3, 36, 18, 0, 989, 1057, 1, 0, 0, 0, 990, 991, 3, 108, 54, 0, 991, 992, 3, 34, 17, 0, 992, 1057, 1, 0, 0, 0, 993, 994, 3, 108, 54, 0, 994, 995, 5, 30, 0, 0, 995, 996, 3, 312, 156, 0, 996, 997, 5, 31, 0, 0, 997, 1057, 1, 0, 0, 0, 998, 999, 3, 108, 54, 0, 999, 1000, 5, 84, 0, 0, 1000, 1001, 5, 30, 0, 0, 1001, 1002, 3, 312, 156, 0, 1002, 1003, 5, 31, 0, 0, 1003, 1057, 1, 0, 0, 0, 1004, 1005, 3, 110, 55, 0, 1005, 1006, 3, 32, 16, 0, 1006, 1057, 1, 0, 0, 0, 1007, 1008, 3, 110, 55, 0, 1008, 1009, 3, 0, 0, 0, 1009, 1057, 1, 0, 0, 0, 1010, 1011, 3, 112, 56, 0, 1011, 1012, 3, 190, 95, 0, 1012, 1057, 1, 0, 0, 0, 1013, 1014, 3, 114, 57, 0, 1014, 1015, 3, 200, 100, 0, 1015, 1057, 1, 0, 0, 0, 1016, 1017, 3, 114, 57, 0, 1017, 1018, 3, 196, 98, 0, 1018, 1057, 1, 0, 0, 0, 1019, 1020, 3, 116, 58, 0, 1020, 1021, 3, 146, 73, 0, 1021, 1057, 1, 0, 0, 0, 1022, 1023, 3, 118, 59, 0, 1023, 1024, 3, 6, 3, 0, 1024, 1057, 1, 0, 0, 0, 1025, 1026, 3, 118, 59, 0, 1026, 1027, 5, 224, 0, 0, 1027, 1028, 5, 30, 0, 0, 1028, 1029, 3, 6, 3, 0, 1029, 1030, 5, 31, 0, 0, 1030, 1057, 1, 0, 0, 0, 1031, 1032, 3, 118, 59, 0, 1032, 1033, 5, 84, 0, 0, 1033, 1034, 5, 30, 0, 0, 1034, 1035, 3, 312, 156, 0, 1035, 1036, 5, 31, 0, 0, 1036, 1057, 1, 0, 0, 0, 1037, 1038, 3, 120, 60, 0, 1038, 1039, 3, 192, 96, 0, 1039, 1040, 3, 160, 80, 0, 1040, 1041, 3, 134, 67, 0, 1041, 1057, 1, 0, 0, 0, 1042, 1043, 3, 122, 61, 0, 1043, 1044, 3, 50, 25, 0, 1044, 1057, 1, 0, 0, 0, 1045, 1046, 3, 122, 61, 0, 1046, 1047, 3, 32, 16, 0, 1047, 1057, 1, 0, 0, 0, 1048, 1049, 3, 124, 62, 0, 1049, 1050, 5, 30, 0, 0, 1050, 1051, 3, 128, 64, 0, 1051, 1052, 5, 31, 0, 0, 1052, 1057, 1, 0, 0, 0, 1053, 1054, 3, 124, 62, 0, 1054, 1055, 5, 85, 0, 0, 1055, 1057, 1, 0, 0, 0, 1056, 974, 1, 0, 0, 0, 1056, 975, 1, 0, 0, 0, 1056, 978, 1, 0, 0, 0, 1056, 981, 1, 0, 0, 0, 1056, 984, 1, 0, 0, 0, 1056, 987, 1, 0, 0, 0, 1056, 990, 1, 0, 0, 0, 1056, 993, 1, 0, 0, 0, 1056, 998, 1, 0, 0, 0, 1056, 1004, 1, 0, 0, 0, 1056, 1007, 1, 0, 0, 0, 1056, 1010, 1, 0, 0, 0, 1056, 1013, 1, 0, 0, 0, 1056, 1016, 1, 0, 0, 0, 1056, 1019, 1, 0, 0, 0, 1056, 1022, 1, 0, 0, 0, 1056, 1025, 1, 0, 0, 0, 1056, 1031, 1, 0, 0, 0, 1056, 1037, 1, 0, 0, 0, 1056, 1042, 1, 0, 0, 0, 1056, 1045, 1, 0, 0, 0, 1056, 1048, 1, 0, 0, 0, 1056, 1053, 1, 0, 0, 0, 1057, 127, 1, 0, 0, 0, 1058, 1075, 1, 0, 0, 0, 1059, 1062, 3, 0, 0, 0, 1060, 1062, 3, 32, 16, 0, 1061, 1059, 1, 0, 0, 0, 1061, 1060, 1, 0, 0, 0, 1062, 1063, 1, 0, 0, 0, 1063, 1064, 5, 28, 0, 0, 1064, 1066, 1, 0, 0, 0, 1065, 1061, 1, 0, 0, 0, 1066, 1069, 1, 0, 0, 0, 1067, 1065, 1, 0, 0, 0, 1067, 1068, 1, 0, 0, 0, 1068, 1072, 1, 0, 0, 0, 1069, 1067, 1, 0, 0, 0, 1070, 1073, 3, 0, 0, 0, 1071, 1073, 3, 32, 16, 0, 1072, 1070, 1, 0, 0, 0, 1072, 1071, 1, 0, 0, 0, 1073, 1075, 1, 0, 0, 0, 1074, 1058, 1, 0, 0, 0, 1074, 1067, 1, 0, 0, 0, 1075, 129, 1, 0, 0, 0, 1076, 1082, 5, 86, 0, 0, 1077, 1078, 3, 160, 80, 0, 1078, 1079, 5, 28, 0, 0, 1079, 1081, 1, 0, 0, 0, 1080, 1077, 1, 0, 0, 0, 1081, 1084, 1, 0, 0, 0, 1082, 1080, 1, 0, 0, 0, 1082, 1083, 1, 0, 0, 0, 1083, 1085, 1, 0, 0, 0, 1084, 1082, 1, 0, 0, 0, 1085, 1086, 3, 160, 80, 0, 1086, 1087, 5, 87, 0, 0, 1087, 131, 1, 0, 0, 0, 1088, 1094, 5, 42, 0, 0, 1089, 1090, 3, 168, 84, 0, 1090, 1091, 5, 28, 0, 0, 1091, 1093, 1, 0, 0, 0, 1092, 1089, 1, 0, 0, 0, 1093, 1096, 1, 0, 0, 0, 1094, 1092, 1, 0, 0, 0, 1094, 1095, 1, 0, 0, 0, 1095, 1097, 1, 0, 0, 0, 1096, 1094, 1, 0, 0, 0, 1097, 1098, 3, 168, 84, 0, 1098, 1099, 5, 43, 0, 0, 1099, 133, 1, 0, 0, 0, 1100, 1106, 5, 30, 0, 0, 1101, 1102, 3, 136, 68, 0, 1102, 1103, 5, 28, 0, 0, 1103, 1105, 1, 0, 0, 0, 1104, 1101, 1, 0, 0, 0, 1105, 1108, 1, 0, 0, 0, 1106, 1104, 1, 0, 0, 0, 1106, 1107, 1, 0, 0, 0, 1107, 1109, 1, 0, 0, 0, 1108, 1106, 1, 0, 0, 0, 1109, 1110, 3, 136, 68, 0, 1110, 1111, 5, 31, 0, 0, 1111, 1114, 1, 0, 0, 0, 1112, 1114, 5, 85, 0, 0, 1113, 1100, 1, 0, 0, 0, 1113, 1112, 1, 0, 0, 0, 1114, 135, 1, 0, 0, 0, 1115, 1123, 5, 177, 0, 0, 1116, 1117, 3, 252, 126, 0, 1117, 1118, 3, 160, 80, 0, 1118, 1120, 3, 248, 124, 0, 1119, 1121, 3, 0, 0, 0, 1120, 1119, 1, 0, 0, 0, 1120, 1121, 1, 0, 0, 0, 1121, 1123, 1, 0, 0, 0, 1122, 1115, 1, 0, 0, 0, 1122, 1116, 1, 0, 0, 0, 1123, 137, 1, 0, 0, 0, 1124, 1125, 5, 42, 0, 0, 1125, 1126, 3, 2, 1, 0, 1126, 1127, 5, 43, 0, 0, 1127, 1128, 3, 140, 70, 0, 1128, 1150, 1, 0, 0, 0, 1129, 1130, 5, 42, 0, 0, 1130, 1131, 3, 196, 98, 0, 1131, 1132, 5, 43, 0, 0, 1132, 1133, 3, 140, 70, 0, 1133, 1150, 1, 0, 0, 0, 1134, 1135, 5, 42, 0, 0, 1135, 1136, 5, 262, 0, 0, 1136, 1137, 5, 43, 0, 0, 1137, 1150, 3, 140, 70, 0, 1138, 1139, 5, 42, 0, 0, 1139, 1140, 5, 198, 0, 0, 1140, 1141, 3, 2, 1, 0, 1141, 1142, 5, 43, 0, 0, 1142, 1143, 3, 140, 70, 0, 1143, 1150, 1, 0, 0, 0, 1144, 1150, 3, 140, 70, 0, 1145, 1150, 3, 196, 98, 0, 1146, 1150, 5, 257, 0, 0, 1147, 1150, 5, 258, 0, 0, 1148, 1150, 5, 259, 0, 0, 1149, 1124, 1, 0, 0, 0, 1149, 1129, 1, 0, 0, 0, 1149, 1134, 1, 0, 0, 0, 1149, 1138, 1, 0, 0, 0, 1149, 1144, 1, 0, 0, 0, 1149, 1145, 1, 0, 0, 0, 1149, 1146, 1, 0, 0, 0, 1149, 1147, 1, 0, 0, 0, 1149, 1148, 1, 0, 0, 0, 1150, 139, 1, 0, 0, 0, 1151, 1152, 3, 2, 1, 0, 1152, 1153, 5, 88, 0, 0, 1153, 1155, 1, 0, 0, 0, 1154, 1151, 1, 0, 0, 0, 1155, 1158, 1, 0, 0, 0, 1156, 1154, 1, 0, 0, 0, 1156, 1157, 1, 0, 0, 0, 1157, 1159, 1, 0, 0, 0, 1158, 1156, 1, 0, 0, 0, 1159, 1160, 3, 2, 1, 0, 1160, 141, 1, 0, 0, 0, 1161, 1163, 3, 144, 72, 0, 1162, 1161, 1, 0, 0, 0, 1163, 1166, 1, 0, 0, 0, 1164, 1162, 1, 0, 0, 0, 1164, 1165, 1, 0, 0, 0, 1165, 143, 1, 0, 0, 0, 1166, 1164, 1, 0, 0, 0, 1167, 1168, 5, 180, 0, 0, 1168, 1169, 5, 89, 0, 0, 1169, 1173, 3, 32, 16, 0, 1170, 1173, 3, 174, 87, 0, 1171, 1173, 3, 344, 172, 0, 1172, 1167, 1, 0, 0, 0, 1172, 1170, 1, 0, 0, 0, 1172, 1171, 1, 0, 0, 0, 1173, 145, 1, 0, 0, 0, 1174, 1186, 3, 138, 69, 0, 1175, 1176, 5, 42, 0, 0, 1176, 1177, 3, 2, 1, 0, 1177, 1178, 5, 43, 0, 0, 1178, 1186, 1, 0, 0, 0, 1179, 1180, 5, 42, 0, 0, 1180, 1181, 5, 198, 0, 0, 1181, 1182, 3, 2, 1, 0, 1182, 1183, 5, 43, 0, 0, 1183, 1186, 1, 0, 0, 0, 1184, 1186, 3, 160, 80, 0, 1185, 1174, 1, 0, 0, 0, 1185, 1175, 1, 0, 0, 0, 1185, 1179, 1, 0, 0, 0, 1185, 1184, 1, 0, 0, 0, 1186, 147, 1, 0, 0, 0, 1187, 1196, 1, 0, 0, 0, 1188, 1192, 3, 152, 76, 0, 1189, 1191, 3, 150, 75, 0, 1190, 1189, 1, 0, 0, 0, 1191, 1194, 1, 0, 0, 0, 1192, 1190, 1, 0, 0, 0, 1192, 1193, 1, 0, 0, 0, 1193, 1196, 1, 0, 0, 0, 1194, 1192, 1, 0, 0, 0, 1195, 1187, 1, 0, 0, 0, 1195, 1188, 1, 0, 0, 0, 1196, 149, 1, 0, 0, 0, 1197, 1215, 5, 262, 0, 0, 1198, 1215, 5, 261, 0, 0, 1199, 1200, 5, 42, 0, 0, 1200, 1201, 3, 32, 16, 0, 1201, 1202, 5, 43, 0, 0, 1202, 1215, 1, 0, 0, 0, 1203, 1204, 5, 42, 0, 0, 1204, 1205, 3, 32, 16, 0, 1205, 1206, 5, 266, 0, 0, 1206, 1207, 3, 32, 16, 0, 1207, 1208, 5, 43, 0, 0, 1208, 1215, 1, 0, 0, 0, 1209, 1210, 5, 42, 0, 0, 1210, 1211, 5, 266, 0, 0, 1211, 1212, 3, 32, 16, 0, 1212, 1213, 5, 43, 0, 0, 1213, 1215, 1, 0, 0, 0, 1214, 1197, 1, 0, 0, 0, 1214, 1198, 1, 0, 0, 0, 1214, 1199, 1, 0, 0, 0, 1214, 1203, 1, 0, 0, 0, 1214, 1209, 1, 0, 0, 0, 1215, 151, 1, 0, 0, 0, 1216, 1309, 1, 0, 0, 0, 1217, 1218, 5, 203, 0, 0, 1218, 1219, 5, 30, 0, 0, 1219, 1220, 3, 6, 3, 0, 1220, 1221, 5, 28, 0, 0, 1221, 1222, 3, 6, 3, 0, 1222, 1223, 5, 28, 0, 0, 1223, 1224, 3, 6, 3, 0, 1224, 1225, 5, 28, 0, 0, 1225, 1226, 3, 6, 3, 0, 1226, 1227, 5, 31, 0, 0, 1227, 1309, 1, 0, 0, 0, 1228, 1229, 5, 203, 0, 0, 1229, 1230, 5, 30, 0, 0, 1230, 1231, 3, 6, 3, 0, 1231, 1232, 5, 28, 0, 0, 1232, 1233, 3, 6, 3, 0, 1233, 1234, 5, 31, 0, 0, 1234, 1309, 1, 0, 0, 0, 1235, 1236, 5, 204, 0, 0, 1236, 1237, 5, 205, 0, 0, 1237, 1238, 5, 42, 0, 0, 1238, 1239, 3, 32, 16, 0, 1239, 1240, 5, 43, 0, 0, 1240, 1309, 1, 0, 0, 0, 1241, 1242, 5, 204, 0, 0, 1242, 1243, 5, 206, 0, 0, 1243, 1244, 5, 42, 0, 0, 1244, 1245, 3, 32, 16, 0, 1245, 1246, 5, 43, 0, 0, 1246, 1247, 3, 148, 74, 0, 1247, 1309, 1, 0, 0, 0, 1248, 1309, 5, 207, 0, 0, 1249, 1309, 5, 208, 0, 0, 1250, 1309, 5, 209, 0, 0, 1251, 1309, 5, 201, 0, 0, 1252, 1309, 5, 183, 0, 0, 1253, 1309, 5, 184, 0, 0, 1254, 1309, 5, 185, 0, 0, 1255, 1309, 5, 186, 0, 0, 1256, 1309, 5, 187, 0, 0, 1257, 1309, 5, 188, 0, 0, 1258, 1309, 5, 189, 0, 0, 1259, 1309, 5, 210, 0, 0, 1260, 1309, 5, 190, 0, 0, 1261, 1309, 5, 191, 0, 0, 1262, 1309, 5, 192, 0, 0, 1263, 1309, 5, 193, 0, 0, 1264, 1309, 5, 211, 0, 0, 1265, 1309, 5, 212, 0, 0, 1266, 1309, 5, 213, 0, 0, 1267, 1309, 5, 214, 0, 0, 1268, 1309, 5, 215, 0, 0, 1269, 1309, 5, 216, 0, 0, 1270, 1309, 5, 217, 0, 0, 1271, 1272, 5, 218, 0, 0, 1272, 1309, 3, 154, 77, 0, 1273, 1274, 5, 219, 0, 0, 1274, 1309, 3, 154, 77, 0, 1275, 1309, 5, 220, 0, 0, 1276, 1277, 5, 221, 0, 0, 1277, 1309, 3, 154, 77, 0, 1278, 1279, 5, 222, 0, 0, 1279, 1309, 3, 156, 78, 0, 1280, 1281, 5, 222, 0, 0, 1281, 1282, 3, 156, 78, 0, 1282, 1283, 5, 28, 0, 0, 1283, 1284, 3, 6, 3, 0, 1284, 1309, 1, 0, 0, 0, 1285, 1309, 5, 194, 0, 0, 1286, 1309, 5, 195, 0, 0, 1287, 1288, 5, 90, 0, 0, 1288, 1309, 5, 184, 0, 0, 1289, 1290, 5, 90, 0, 0, 1290, 1309, 5, 185, 0, 0, 1291, 1292, 5, 90, 0, 0, 1292, 1309, 5, 186, 0, 0, 1293, 1294, 5, 90, 0, 0, 1294, 1309, 5, 187, 0, 0, 1295, 1296, 5, 62, 0, 0, 1296, 1309, 5, 220, 0, 0, 1297, 1309, 5, 223, 0, 0, 1298, 1299, 5, 224, 0, 0, 1299, 1309, 5, 213, 0, 0, 1300, 1309, 5, 225, 0, 0, 1301, 1302, 5, 207, 0, 0, 1302, 1309, 5, 183, 0, 0, 1303, 1309, 5, 226, 0, 0, 1304, 1309, 5, 228, 0, 0, 1305, 1306, 5, 34, 0, 0, 1306, 1309, 5, 227, 0, 0, 1307, 1309, 3, 2, 1, 0, 1308, 1216, 1, 0, 0, 0, 1308, 1217, 1, 0, 0, 0, 1308, 1228, 1, 0, 0, 0, 1308, 1235, 1, 0, 0, 0, 1308, 1241, 1, 0, 0, 0, 1308, 1248, 1, 0, 0, 0, 1308, 1249, 1, 0, 0, 0, 1308, 1250, 1, 0, 0, 0, 1308, 1251, 1, 0, 0, 0, 1308, 1252, 1, 0, 0, 0, 1308, 1253, 1, 0, 0, 0, 1308, 1254, 1, 0, 0, 0, 1308, 1255, 1, 0, 0, 0, 1308, 1256, 1, 0, 0, 0, 1308, 1257, 1, 0, 0, 0, 1308, 1258, 1, 0, 0, 0, 1308, 1259, 1, 0, 0, 0, 1308, 1260, 1, 0, 0, 0, 1308, 1261, 1, 0, 0, 0, 1308, 1262, 1, 0, 0, 0, 1308, 1263, 1, 0, 0, 0, 1308, 1264, 1, 0, 0, 0, 1308, 1265, 1, 0, 0, 0, 1308, 1266, 1, 0, 0, 0, 1308, 1267, 1, 0, 0, 0, 1308, 1268, 1, 0, 0, 0, 1308, 1269, 1, 0, 0, 0, 1308, 1270, 1, 0, 0, 0, 1308, 1271, 1, 0, 0, 0, 1308, 1273, 1, 0, 0, 0, 1308, 1275, 1, 0, 0, 0, 1308, 1276, 1, 0, 0, 0, 1308, 1278, 1, 0, 0, 0, 1308, 1280, 1, 0, 0, 0, 1308, 1285, 1, 0, 0, 0, 1308, 1286, 1, 0, 0, 0, 1308, 1287, 1, 0, 0, 0, 1308, 1289, 1, 0, 0, 0, 1308, 1291, 1, 0, 0, 0, 1308, 1293, 1, 0, 0, 0, 1308, 1295, 1, 0, 0, 0, 1308, 1297, 1, 0, 0, 0, 1308, 1298, 1, 0, 0, 0, 1308, 1300, 1, 0, 0, 0, 1308, 1301, 1, 0, 0, 0, 1308, 1303, 1, 0, 0, 0, 1308, 1304, 1, 0, 0, 0, 1308, 1305, 1, 0, 0, 0, 1308, 1307, 1, 0, 0, 0, 1309, 153, 1, 0, 0, 0, 1310, 1318, 1, 0, 0, 0, 1311, 1312, 5, 30, 0, 0, 1312, 1313, 5, 91, 0, 0, 1313, 1314, 5, 36, 0, 0, 1314, 1315, 3, 32, 16, 0, 1315, 1316, 5, 31, 0, 0, 1316, 1318, 1, 0, 0, 0, 1317, 1310, 1, 0, 0, 0, 1317, 1311, 1, 0, 0, 0, 1318, 155, 1, 0, 0, 0, 1319, 1328, 1, 0, 0, 0, 1320, 1324, 3, 158, 79, 0, 1321, 1323, 7, 7, 0, 0, 1322, 1321, 1, 0, 0, 0, 1323, 1326, 1, 0, 0, 0, 1324, 1322, 1, 0, 0, 0, 1324, 1325, 1, 0, 0, 0, 1325, 1328, 1, 0, 0, 0, 1326, 1324, 1, 0, 0, 0, 1327, 1319, 1, 0, 0, 0, 1327, 1320, 1, 0, 0, 0, 1328, 157, 1, 0, 0, 0, 1329, 1330, 7, 8, 0, 0, 1330, 159, 1, 0, 0, 0, 1331, 1335, 3, 164, 82, 0, 1332, 1334, 3, 162, 81, 0, 1333, 1332, 1, 0, 0, 0, 1334, 1337, 1, 0, 0, 0, 1335, 1333, 1, 0, 0, 0, 1335, 1336, 1, 0, 0, 0, 1336, 161, 1, 0, 0, 0, 1337, 1335, 1, 0, 0, 0, 1338, 1357, 5, 261, 0, 0, 1339, 1340, 5, 42, 0, 0, 1340, 1357, 5, 43, 0, 0, 1341, 1357, 3, 132, 66, 0, 1342, 1357, 5, 260, 0, 0, 1343, 1357, 5, 262, 0, 0, 1344, 1357, 5, 92, 0, 0, 1345, 1346, 5, 93, 0, 0, 1346, 1347, 5, 30, 0, 0, 1347, 1348, 3, 146, 73, 0, 1348, 1349, 5, 31, 0, 0, 1349, 1357, 1, 0, 0, 0, 1350, 1351, 5, 94, 0, 0, 1351, 1352, 5, 30, 0, 0, 1352, 1353, 3, 146, 73, 0, 1353, 1354, 5, 31, 0, 0, 1354, 1357, 1, 0, 0, 0, 1355, 1357, 3, 130, 65, 0, 1356, 1338, 1, 0, 0, 0, 1356, 1339, 1, 0, 0, 0, 1356, 1341, 1, 0, 0, 0, 1356, 1342, 1, 0, 0, 0, 1356, 1343, 1, 0, 0, 0, 1356, 1344, 1, 0, 0, 0, 1356, 1345, 1, 0, 0, 0, 1356, 1350, 1, 0, 0, 0, 1356, 1355, 1, 0, 0, 0, 1357, 163, 1, 0, 0, 0, 1358, 1359, 5, 39, 0, 0, 1359, 1389, 3, 138, 69, 0, 1360, 1389, 5, 197, 0, 0, 1361, 1362, 5, 199, 0, 0, 1362, 1363, 5, 39, 0, 0, 1363, 1389, 3, 138, 69, 0, 1364, 1365, 5, 200, 0, 0, 1365, 1389, 3, 138, 69, 0, 1366, 1367, 5, 226, 0, 0, 1367, 1368, 3, 192, 96, 0, 1368, 1369, 3, 160, 80, 0, 1369, 1370, 5, 262, 0, 0, 1370, 1371, 3, 134, 67, 0, 1371, 1389, 1, 0, 0, 0, 1372, 1373, 5, 253, 0, 0, 1373, 1389, 3, 32, 16, 0, 1374, 1375, 5, 252, 0, 0, 1375, 1389, 3, 32, 16, 0, 1376, 1377, 5, 253, 0, 0, 1377, 1389, 3, 2, 1, 0, 1378, 1379, 5, 252, 0, 0, 1379, 1389, 3, 2, 1, 0, 1380, 1389, 5, 254, 0, 0, 1381, 1389, 5, 201, 0, 0, 1382, 1389, 3, 170, 85, 0, 1383, 1389, 3, 172, 86, 0, 1384, 1389, 3, 166, 83, 0, 1385, 1389, 3, 2, 1, 0, 1386, 1387, 5, 177, 0, 0, 1387, 1389, 3, 160, 80, 0, 1388, 1358, 1, 0, 0, 0, 1388, 1360, 1, 0, 0, 0, 1388, 1361, 1, 0, 0, 0, 1388, 1364, 1, 0, 0, 0, 1388, 1366, 1, 0, 0, 0, 1388, 1372, 1, 0, 0, 0, 1388, 1374, 1, 0, 0, 0, 1388, 1376, 1, 0, 0, 0, 1388, 1378, 1, 0, 0, 0, 1388, 1380, 1, 0, 0, 0, 1388, 1381, 1, 0, 0, 0, 1388, 1382, 1, 0, 0, 0, 1388, 1383, 1, 0, 0, 0, 1388, 1384, 1, 0, 0, 0, 1388, 1385, 1, 0, 0, 0, 1388, 1386, 1, 0, 0, 0, 1389, 165, 1, 0, 0, 0, 1390, 1412, 5, 181, 0, 0, 1391, 1412, 5, 182, 0, 0, 1392, 1412, 5, 183, 0, 0, 1393, 1412, 5, 184, 0, 0, 1394, 1412, 5, 185, 0, 0, 1395, 1412, 5, 186, 0, 0, 1396, 1412, 5, 187, 0, 0, 1397, 1412, 5, 188, 0, 0, 1398, 1412, 5, 189, 0, 0, 1399, 1412, 5, 190, 0, 0, 1400, 1412, 5, 191, 0, 0, 1401, 1412, 5, 192, 0, 0, 1402, 1412, 5, 193, 0, 0, 1403, 1404, 5, 90, 0, 0, 1404, 1412, 5, 184, 0, 0, 1405, 1406, 5, 90, 0, 0, 1406, 1412, 5, 185, 0, 0, 1407, 1408, 5, 90, 0, 0, 1408, 1412, 5, 186, 0, 0, 1409, 1410, 5, 90, 0, 0, 1410, 1412, 5, 187, 0, 0, 1411, 1390, 1, 0, 0, 0, 1411, 1391, 1, 0, 0, 0, 1411, 1392, 1, 0, 0, 0, 1411, 1393, 1, 0, 0, 0, 1411, 1394, 1, 0, 0, 0, 1411, 1395, 1, 0, 0, 0, 1411, 1396, 1, 0, 0, 0, 1411, 1397, 1, 0, 0, 0, 1411, 1398, 1, 0, 0, 0, 1411, 1399, 1, 0, 0, 0, 1411, 1400, 1, 0, 0, 0, 1411, 1401, 1, 0, 0, 0, 1411, 1402, 1, 0, 0, 0, 1411, 1403, 1, 0, 0, 0, 1411, 1405, 1, 0, 0, 0, 1411, 1407, 1, 0, 0, 0, 1411, 1409, 1, 0, 0, 0, 1412, 167, 1, 0, 0, 0, 1413, 1424, 1, 0, 0, 0, 1414, 1424, 5, 177, 0, 0, 1415, 1424, 3, 32, 16, 0, 1416, 1417, 3, 32, 16, 0, 1417, 1418, 5, 177, 0, 0, 1418, 1419, 3, 32, 16, 0, 1419, 1424, 1, 0, 0, 0, 1420, 1421, 3, 32, 16, 0, 1421, 1422, 5, 177, 0, 0, 1422, 1424, 1, 0, 0, 0, 1423, 1413, 1, 0, 0, 0, 1423, 1414, 1, 0, 0, 0, 1423, 1415, 1, 0, 0, 0, 1423, 1416, 1, 0, 0, 0, 1423, 1420, 1, 0, 0, 0, 1424, 169, 1, 0, 0, 0, 1425, 1426, 5, 1, 0, 0, 1426, 1427, 5, 194, 0, 0, 1427, 171, 1, 0, 0, 0, 1428, 1432, 5, 1, 0, 0, 1429, 1430, 5, 90, 0, 0, 1430, 1433, 5, 194, 0, 0, 1431, 1433, 5, 195, 0, 0, 1432, 1429, 1, 0, 0, 0, 1432, 1431, 1, 0, 0, 0, 1433, 173, 1, 0, 0, 0, 1434, 1435, 5, 294, 0, 0, 1435, 1436, 3, 188, 94, 0, 1436, 1437, 3, 146, 73, 0, 1437, 1438, 5, 30, 0, 0, 1438, 1439, 3, 180, 90, 0, 1439, 1440, 5, 31, 0, 0, 1440, 1482, 1, 0, 0, 0, 1441, 1442, 5, 294, 0, 0, 1442, 1443, 3, 188, 94, 0, 1443, 1444, 3, 146, 73, 0, 1444, 1445, 5, 36, 0, 0, 1445, 1446, 5, 17, 0, 0, 1446, 1447, 3, 52, 26, 0, 1447, 1448, 5, 18, 0, 0, 1448, 1482, 1, 0, 0, 0, 1449, 1450, 5, 294, 0, 0, 1450, 1451, 3, 188, 94, 0, 1451, 1452, 3, 146, 73, 0, 1452, 1482, 1, 0, 0, 0, 1453, 1454, 5, 295, 0, 0, 1454, 1455, 3, 188, 94, 0, 1455, 1457, 5, 36, 0, 0, 1456, 1458, 5, 84, 0, 0, 1457, 1456, 1, 0, 0, 0, 1457, 1458, 1, 0, 0, 0, 1458, 1459, 1, 0, 0, 0, 1459, 1460, 5, 30, 0, 0, 1460, 1461, 3, 312, 156, 0, 1461, 1462, 5, 31, 0, 0, 1462, 1482, 1, 0, 0, 0, 1463, 1464, 5, 295, 0, 0, 1464, 1465, 3, 188, 94, 0, 1465, 1466, 5, 84, 0, 0, 1466, 1467, 5, 30, 0, 0, 1467, 1468, 3, 312, 156, 0, 1468, 1469, 5, 31, 0, 0, 1469, 1482, 1, 0, 0, 0, 1470, 1471, 5, 295, 0, 0, 1471, 1472, 3, 188, 94, 0, 1472, 1473, 3, 6, 3, 0, 1473, 1482, 1, 0, 0, 0, 1474, 1475, 5, 295, 0, 0, 1475, 1476, 3, 188, 94, 0, 1476, 1477, 5, 36, 0, 0, 1477, 1478, 5, 17, 0, 0, 1478, 1479, 3, 176, 88, 0, 1479, 1480, 5, 18, 0, 0, 1480, 1482, 1, 0, 0, 0, 1481, 1434, 1, 0, 0, 0, 1481, 1441, 1, 0, 0, 0, 1481, 1449, 1, 0, 0, 0, 1481, 1453, 1, 0, 0, 0, 1481, 1463, 1, 0, 0, 0, 1481, 1470, 1, 0, 0, 0, 1481, 1474, 1, 0, 0, 0, 1482, 175, 1, 0, 0, 0, 1483, 1494, 1, 0, 0, 0, 1484, 1485, 3, 178, 89, 0, 1485, 1486, 5, 28, 0, 0, 1486, 1488, 1, 0, 0, 0, 1487, 1484, 1, 0, 0, 0, 1488, 1491, 1, 0, 0, 0, 1489, 1487, 1, 0, 0, 0, 1489, 1490, 1, 0, 0, 0, 1490, 1492, 1, 0, 0, 0, 1491, 1489, 1, 0, 0, 0, 1492, 1494, 3, 178, 89, 0, 1493, 1483, 1, 0, 0, 0, 1493, 1489, 1, 0, 0, 0, 1494, 177, 1, 0, 0, 0, 1495, 1496, 5, 39, 0, 0, 1496, 1497, 5, 264, 0, 0, 1497, 1498, 5, 36, 0, 0, 1498, 1499, 5, 17, 0, 0, 1499, 1500, 3, 56, 28, 0, 1500, 1501, 5, 18, 0, 0, 1501, 1509, 1, 0, 0, 0, 1502, 1503, 3, 146, 73, 0, 1503, 1504, 5, 36, 0, 0, 1504, 1505, 5, 17, 0, 0, 1505, 1506, 3, 56, 28, 0, 1506, 1507, 5, 18, 0, 0, 1507, 1509, 1, 0, 0, 0, 1508, 1495, 1, 0, 0, 0, 1508, 1502, 1, 0, 0, 0, 1509, 179, 1, 0, 0, 0, 1510, 1511, 3, 182, 91, 0, 1511, 1512, 5, 28, 0, 0, 1512, 1514, 1, 0, 0, 0, 1513, 1510, 1, 0, 0, 0, 1514, 1517, 1, 0, 0, 0, 1515, 1513, 1, 0, 0, 0, 1515, 1516, 1, 0, 0, 0, 1516, 1518, 1, 0, 0, 0, 1517, 1515, 1, 0, 0, 0, 1518, 1519, 3, 182, 91, 0, 1519, 181, 1, 0, 0, 0, 1520, 1521, 3, 6, 3, 0, 1521, 1522, 5, 36, 0, 0, 1522, 1523, 3, 186, 93, 0, 1523, 183, 1, 0, 0, 0, 1524, 1525, 7, 9, 0, 0, 1525, 185, 1, 0, 0, 0, 1526, 1561, 3, 184, 92, 0, 1527, 1561, 3, 32, 16, 0, 1528, 1529, 5, 186, 0, 0, 1529, 1530, 5, 30, 0, 0, 1530, 1531, 3, 32, 16, 0, 1531, 1532, 5, 31, 0, 0, 1532, 1561, 1, 0, 0, 0, 1533, 1561, 3, 6, 3, 0, 1534, 1535, 3, 138, 69, 0, 1535, 1536, 5, 30, 0, 0, 1536, 1537, 5, 184, 0, 0, 1537, 1538, 5, 75, 0, 0, 1538, 1539, 3, 32, 16, 0, 1539, 1540, 5, 31, 0, 0, 1540, 1561, 1, 0, 0, 0, 1541, 1542, 3, 138, 69, 0, 1542, 1543, 5, 30, 0, 0, 1543, 1544, 5, 185, 0, 0, 1544, 1545, 5, 75, 0, 0, 1545, 1546, 3, 32, 16, 0, 1546, 1547, 5, 31, 0, 0, 1547, 1561, 1, 0, 0, 0, 1548, 1549, 3, 138, 69, 0, 1549, 1550, 5, 30, 0, 0, 1550, 1551, 5, 186, 0, 0, 1551, 1552, 5, 75, 0, 0, 1552, 1553, 3, 32, 16, 0, 1553, 1554, 5, 31, 0, 0, 1554, 1561, 1, 0, 0, 0, 1555, 1556, 3, 138, 69, 0, 1556, 1557, 5, 30, 0, 0, 1557, 1558, 3, 32, 16, 0, 1558, 1559, 5, 31, 0, 0, 1559, 1561, 1, 0, 0, 0, 1560, 1526, 1, 0, 0, 0, 1560, 1527, 1, 0, 0, 0, 1560, 1528, 1, 0, 0, 0, 1560, 1533, 1, 0, 0, 0, 1560, 1534, 1, 0, 0, 0, 1560, 1541, 1, 0, 0, 0, 1560, 1548, 1, 0, 0, 0, 1560, 1555, 1, 0, 0, 0, 1561, 187, 1, 0, 0, 0, 1562, 1563, 7, 10, 0, 0, 1563, 189, 1, 0, 0, 0, 1564, 1565, 3, 192, 96, 0, 1565, 1566, 3, 160, 80, 0, 1566, 1567, 3, 146, 73, 0, 1567, 1568, 5, 176, 0, 0, 1568, 1570, 3, 264, 132, 0, 1569, 1571, 3, 130, 65, 0, 1570, 1569, 1, 0, 0, 0, 1570, 1571, 1, 0, 0, 0, 1571, 1572, 1, 0, 0, 0, 1572, 1573, 3, 134, 67, 0, 1573, 1599, 1, 0, 0, 0, 1574, 1575, 3, 192, 96, 0, 1575, 1576, 3, 160, 80, 0, 1576, 1577, 3, 146, 73, 0, 1577, 1578, 5, 176, 0, 0, 1578, 1579, 3, 264, 132, 0, 1579, 1580, 3, 218, 109, 0, 1580, 1581, 3, 134, 67, 0, 1581, 1599, 1, 0, 0, 0, 1582, 1583, 3, 192, 96, 0, 1583, 1584, 3, 160, 80, 0, 1584, 1586, 3, 264, 132, 0, 1585, 1587, 3, 130, 65, 0, 1586, 1585, 1, 0, 0, 0, 1586, 1587, 1, 0, 0, 0, 1587, 1588, 1, 0, 0, 0, 1588, 1589, 3, 134, 67, 0, 1589, 1599, 1, 0, 0, 0, 1590, 1591, 3, 192, 96, 0, 1591, 1592, 3, 160, 80, 0, 1592, 1593, 3, 264, 132, 0, 1593, 1594, 3, 218, 109, 0, 1594, 1595, 3, 134, 67, 0, 1595, 1599, 1, 0, 0, 0, 1596, 1599, 3, 196, 98, 0, 1597, 1599, 3, 2, 1, 0, 1598, 1564, 1, 0, 0, 0, 1598, 1574, 1, 0, 0, 0, 1598, 1582, 1, 0, 0, 0, 1598, 1590, 1, 0, 0, 0, 1598, 1596, 1, 0, 0, 0, 1598, 1597, 1, 0, 0, 0, 1599, 191, 1, 0, 0, 0, 1600, 1601, 5, 243, 0, 0, 1601, 1611, 3, 192, 96, 0, 1602, 1603, 5, 244, 0, 0, 1603, 1611, 3, 192, 96, 0, 1604, 1611, 3, 194, 97, 0, 1605, 1606, 5, 112, 0, 0, 1606, 1607, 5, 30, 0, 0, 1607, 1608, 3, 32, 16, 0, 1608, 1609, 5, 31, 0, 0, 1609, 1611, 1, 0, 0, 0, 1610, 1600, 1, 0, 0, 0, 1610, 1602, 1, 0, 0, 0, 1610, 1604, 1, 0, 0, 0, 1610, 1605, 1, 0, 0, 0, 1611, 193, 1, 0, 0, 0, 1612, 1625, 1, 0, 0, 0, 1613, 1625, 5, 245, 0, 0, 1614, 1625, 5, 246, 0, 0, 1615, 1616, 5, 247, 0, 0, 1616, 1625, 5, 248, 0, 0, 1617, 1618, 5, 247, 0, 0, 1618, 1625, 5, 249, 0, 0, 1619, 1620, 5, 247, 0, 0, 1620, 1625, 5, 250, 0, 0, 1621, 1622, 5, 247, 0, 0, 1622, 1625, 5, 251, 0, 0, 1623, 1625, 5, 247, 0, 0, 1624, 1612, 1, 0, 0, 0, 1624, 1613, 1, 0, 0, 0, 1624, 1614, 1, 0, 0, 0, 1624, 1615, 1, 0, 0, 0, 1624, 1617, 1, 0, 0, 0, 1624, 1619, 1, 0, 0, 0, 1624, 1621, 1, 0, 0, 0, 1624, 1623, 1, 0, 0, 0, 1625, 195, 1, 0, 0, 0, 1626, 1627, 5, 113, 0, 0, 1627, 1628, 5, 30, 0, 0, 1628, 1629, 3, 32, 16, 0, 1629, 1630, 5, 31, 0, 0, 1630, 197, 1, 0, 0, 0, 1631, 1632, 5, 226, 0, 0, 1632, 1637, 3, 190, 95, 0, 1633, 1634, 5, 37, 0, 0, 1634, 1637, 3, 200, 100, 0, 1635, 1637, 3, 196, 98, 0, 1636, 1631, 1, 0, 0, 0, 1636, 1633, 1, 0, 0, 0, 1636, 1635, 1, 0, 0, 0, 1637, 199, 1, 0, 0, 0, 1638, 1639, 3, 160, 80, 0, 1639, 1640, 3, 146, 73, 0, 1640, 1641, 5, 176, 0, 0, 1641, 1642, 3, 2, 1, 0, 1642, 1648, 1, 0, 0, 0, 1643, 1644, 3, 160, 80, 0, 1644, 1645, 3, 2, 1, 0, 1645, 1648, 1, 0, 0, 0, 1646, 1648, 3, 2, 1, 0, 1647, 1638, 1, 0, 0, 0, 1647, 1643, 1, 0, 0, 0, 1647, 1646, 1, 0, 0, 0, 1648, 201, 1, 0, 0, 0, 1649, 1650, 3, 146, 73, 0, 1650, 1651, 5, 28, 0, 0, 1651, 1653, 1, 0, 0, 0, 1652, 1649, 1, 0, 0, 0, 1653, 1656, 1, 0, 0, 0, 1654, 1652, 1, 0, 0, 0, 1654, 1655, 1, 0, 0, 0, 1655, 1657, 1, 0, 0, 0, 1656, 1654, 1, 0, 0, 0, 1657, 1658, 3, 146, 73, 0, 1658, 203, 1, 0, 0, 0, 1659, 1665, 1, 0, 0, 0, 1660, 1661, 5, 86, 0, 0, 1661, 1662, 3, 212, 106, 0, 1662, 1663, 5, 87, 0, 0, 1663, 1665, 1, 0, 0, 0, 1664, 1659, 1, 0, 0, 0, 1664, 1660, 1, 0, 0, 0, 1665, 205, 1, 0, 0, 0, 1666, 1678, 5, 266, 0, 0, 1667, 1678, 5, 114, 0, 0, 1668, 1678, 5, 39, 0, 0, 1669, 1678, 5, 200, 0, 0, 1670, 1678, 5, 115, 0, 0, 1671, 1678, 5, 116, 0, 0, 1672, 1673, 5, 70, 0, 0, 1673, 1674, 5, 30, 0, 0, 1674, 1675, 3, 32, 16, 0, 1675, 1676, 5, 31, 0, 0, 1676, 1678, 1, 0, 0, 0, 1677, 1666, 1, 0, 0, 0, 1677, 1667, 1, 0, 0, 0, 1677, 1668, 1, 0, 0, 0, 1677, 1669, 1, 0, 0, 0, 1677, 1670, 1, 0, 0, 0, 1677, 1671, 1, 0, 0, 0, 1677, 1672, 1, 0, 0, 0, 1678, 207, 1, 0, 0, 0, 1679, 1681, 3, 206, 103, 0, 1680, 1679, 1, 0, 0, 0, 1681, 1684, 1, 0, 0, 0, 1682, 1680, 1, 0, 0, 0, 1682, 1683, 1, 0, 0, 0, 1683, 209, 1, 0, 0, 0, 1684, 1682, 1, 0, 0, 0, 1685, 1687, 3, 208, 104, 0, 1686, 1688, 3, 214, 107, 0, 1687, 1686, 1, 0, 0, 0, 1687, 1688, 1, 0, 0, 0, 1688, 1689, 1, 0, 0, 0, 1689, 1690, 3, 2, 1, 0, 1690, 211, 1, 0, 0, 0, 1691, 1692, 3, 210, 105, 0, 1692, 1693, 5, 28, 0, 0, 1693, 1695, 1, 0, 0, 0, 1694, 1691, 1, 0, 0, 0, 1695, 1698, 1, 0, 0, 0, 1696, 1694, 1, 0, 0, 0, 1696, 1697, 1, 0, 0, 0, 1697, 1699, 1, 0, 0, 0, 1698, 1696, 1, 0, 0, 0, 1699, 1700, 3, 210, 105, 0, 1700, 213, 1, 0, 0, 0, 1701, 1702, 5, 30, 0, 0, 1702, 1703, 3, 202, 101, 0, 1703, 1704, 5, 31, 0, 0, 1704, 215, 1, 0, 0, 0, 1705, 1708, 1, 0, 0, 0, 1706, 1708, 3, 218, 109, 0, 1707, 1705, 1, 0, 0, 0, 1707, 1706, 1, 0, 0, 0, 1708, 217, 1, 0, 0, 0, 1709, 1710, 5, 86, 0, 0, 1710, 1711, 5, 42, 0, 0, 1711, 1712, 3, 32, 16, 0, 1712, 1713, 5, 43, 0, 0, 1713, 1714, 5, 87, 0, 0, 1714, 219, 1, 0, 0, 0, 1715, 1716, 3, 256, 128, 0, 1716, 1717, 5, 17, 0, 0, 1717, 1718, 3, 268, 134, 0, 1718, 1719, 5, 18, 0, 0, 1719, 1832, 1, 0, 0, 0, 1720, 1721, 3, 74, 37, 0, 1721, 1722, 5, 17, 0, 0, 1722, 1723, 3, 82, 41, 0, 1723, 1724, 5, 18, 0, 0, 1724, 1832, 1, 0, 0, 0, 1725, 1726, 3, 232, 116, 0, 1726, 1727, 5, 17, 0, 0, 1727, 1728, 3, 236, 118, 0, 1728, 1729, 5, 18, 0, 0, 1729, 1832, 1, 0, 0, 0, 1730, 1731, 3, 240, 120, 0, 1731, 1732, 5, 17, 0, 0, 1732, 1733, 3, 244, 122, 0, 1733, 1734, 5, 18, 0, 0, 1734, 1832, 1, 0, 0, 0, 1735, 1832, 3, 222, 111, 0, 1736, 1832, 3, 296, 148, 0, 1737, 1832, 3, 174, 87, 0, 1738, 1832, 3, 88, 44, 0, 1739, 1832, 3, 342, 171, 0, 1740, 1741, 5, 117, 0, 0, 1741, 1832, 3, 32, 16, 0, 1742, 1743, 5, 118, 0, 0, 1743, 1832, 3, 32, 16, 0, 1744, 1745, 3, 354, 177, 0, 1745, 1746, 5, 17, 0, 0, 1746, 1747, 3, 358, 179, 0, 1747, 1748, 5, 18, 0, 0, 1748, 1832, 1, 0, 0, 0, 1749, 1750, 5, 302, 0, 0, 1750, 1751, 3, 146, 73, 0, 1751, 1752, 5, 176, 0, 0, 1752, 1753, 3, 264, 132, 0, 1753, 1754, 5, 119, 0, 0, 1754, 1755, 3, 192, 96, 0, 1755, 1756, 3, 160, 80, 0, 1756, 1757, 3, 146, 73, 0, 1757, 1758, 5, 176, 0, 0, 1758, 1759, 3, 264, 132, 0, 1759, 1760, 3, 134, 67, 0, 1760, 1832, 1, 0, 0, 0, 1761, 1762, 5, 302, 0, 0, 1762, 1763, 5, 226, 0, 0, 1763, 1764, 3, 192, 96, 0, 1764, 1765, 3, 160, 80, 0, 1765, 1766, 3, 146, 73, 0, 1766, 1767, 5, 176, 0, 0, 1767, 1768, 3, 264, 132, 0, 1768, 1769, 3, 216, 108, 0, 1769, 1770, 3, 134, 67, 0, 1770, 1771, 5, 119, 0, 0, 1771, 1772, 5, 226, 0, 0, 1772, 1773, 3, 192, 96, 0, 1773, 1774, 3, 160, 80, 0, 1774, 1775, 3, 146, 73, 0, 1775, 1776, 5, 176, 0, 0, 1776, 1777, 3, 264, 132, 0, 1777, 1778, 3, 216, 108, 0, 1778, 1779, 3, 134, 67, 0, 1779, 1832, 1, 0, 0, 0, 1780, 1832, 3, 26, 13, 0, 1781, 1832, 3, 40, 20, 0, 1782, 1783, 5, 255, 0, 0, 1783, 1784, 5, 196, 0, 0, 1784, 1785, 5, 42, 0, 0, 1785, 1786, 3, 32, 16, 0, 1786, 1790, 5, 43, 0, 0, 1787, 1789, 3, 342, 171, 0, 1788, 1787, 1, 0, 0, 0, 1789, 1792, 1, 0, 0, 0, 1790, 1788, 1, 0, 0, 0, 1790, 1791, 1, 0, 0, 0, 1791, 1832, 1, 0, 0, 0, 1792, 1790, 1, 0, 0, 0, 1793, 1794, 5, 255, 0, 0, 1794, 1795, 5, 196, 0, 0, 1795, 1799, 3, 2, 1, 0, 1796, 1798, 3, 342, 171, 0, 1797, 1796, 1, 0, 0, 0, 1798, 1801, 1, 0, 0, 0, 1799, 1797, 1, 0, 0, 0, 1799, 1800, 1, 0, 0, 0, 1800, 1832, 1, 0, 0, 0, 1801, 1799, 1, 0, 0, 0, 1802, 1803, 5, 255, 0, 0, 1803, 1804, 5, 256, 0, 0, 1804, 1805, 5, 42, 0, 0, 1805, 1806, 3, 32, 16, 0, 1806, 1807, 5, 43, 0, 0, 1807, 1808, 5, 28, 0, 0, 1808, 1812, 3, 146, 73, 0, 1809, 1811, 3, 342, 171, 0, 1810, 1809, 1, 0, 0, 0, 1811, 1814, 1, 0, 0, 0, 1812, 1810, 1, 0, 0, 0, 1812, 1813, 1, 0, 0, 0, 1813, 1832, 1, 0, 0, 0, 1814, 1812, 1, 0, 0, 0, 1815, 1816, 5, 255, 0, 0, 1816, 1817, 5, 256, 0, 0, 1817, 1818, 3, 2, 1, 0, 1818, 1819, 5, 28, 0, 0, 1819, 1823, 3, 146, 73, 0, 1820, 1822, 3, 342, 171, 0, 1821, 1820, 1, 0, 0, 0, 1822, 1825, 1, 0, 0, 0, 1823, 1821, 1, 0, 0, 0, 1823, 1824, 1, 0, 0, 0, 1824, 1832, 1, 0, 0, 0, 1825, 1823, 1, 0, 0, 0, 1826, 1827, 5, 120, 0, 0, 1827, 1828, 5, 196, 0, 0, 1828, 1829, 3, 146, 73, 0, 1829, 1830, 3, 44, 22, 0, 1830, 1832, 1, 0, 0, 0, 1831, 1715, 1, 0, 0, 0, 1831, 1720, 1, 0, 0, 0, 1831, 1725, 1, 0, 0, 0, 1831, 1730, 1, 0, 0, 0, 1831, 1735, 1, 0, 0, 0, 1831, 1736, 1, 0, 0, 0, 1831, 1737, 1, 0, 0, 0, 1831, 1738, 1, 0, 0, 0, 1831, 1739, 1, 0, 0, 0, 1831, 1740, 1, 0, 0, 0, 1831, 1742, 1, 0, 0, 0, 1831, 1744, 1, 0, 0, 0, 1831, 1749, 1, 0, 0, 0, 1831, 1761, 1, 0, 0, 0, 1831, 1780, 1, 0, 0, 0, 1831, 1781, 1, 0, 0, 0, 1831, 1782, 1, 0, 0, 0, 1831, 1793, 1, 0, 0, 0, 1831, 1802, 1, 0, 0, 0, 1831, 1815, 1, 0, 0, 0, 1831, 1826, 1, 0, 0, 0, 1832, 221, 1, 0, 0, 0, 1833, 1834, 5, 121, 0, 0, 1834, 1843, 3, 230, 115, 0, 1835, 1842, 3, 224, 112, 0, 1836, 1837, 5, 122, 0, 0, 1837, 1838, 5, 30, 0, 0, 1838, 1839, 3, 250, 125, 0, 1839, 1840, 5, 31, 0, 0, 1840, 1842, 1, 0, 0, 0, 1841, 1835, 1, 0, 0, 0, 1841, 1836, 1, 0, 0, 0, 1842, 1845, 1, 0, 0, 0, 1843, 1841, 1, 0, 0, 0, 1843, 1844, 1, 0, 0, 0, 1844, 1846, 1, 0, 0, 0, 1845, 1843, 1, 0, 0, 0, 1846, 1847, 3, 160, 80, 0, 1847, 1848, 3, 2, 1, 0, 1848, 1849, 3, 226, 113, 0, 1849, 1850, 3, 228, 114, 0, 1850, 223, 1, 0, 0, 0, 1851, 1871, 5, 123, 0, 0, 1852, 1871, 5, 51, 0, 0, 1853, 1871, 5, 52, 0, 0, 1854, 1871, 5, 63, 0, 0, 1855, 1871, 5, 124, 0, 0, 1856, 1871, 5, 69, 0, 0, 1857, 1871, 5, 68, 0, 0, 1858, 1871, 5, 64, 0, 0, 1859, 1871, 5, 65, 0, 0, 1860, 1871, 5, 66, 0, 0, 1861, 1871, 5, 125, 0, 0, 1862, 1871, 5, 126, 0, 0, 1863, 1871, 5, 127, 0, 0, 1864, 1871, 5, 16, 0, 0, 1865, 1866, 5, 70, 0, 0, 1866, 1867, 5, 30, 0, 0, 1867, 1868, 3, 32, 16, 0, 1868, 1869, 5, 31, 0, 0, 1869, 1871, 1, 0, 0, 0, 1870, 1851, 1, 0, 0, 0, 1870, 1852, 1, 0, 0, 0, 1870, 1853, 1, 0, 0, 0, 1870, 1854, 1, 0, 0, 0, 1870, 1855, 1, 0, 0, 0, 1870, 1856, 1, 0, 0, 0, 1870, 1857, 1, 0, 0, 0, 1870, 1858, 1, 0, 0, 0, 1870, 1859, 1, 0, 0, 0, 1870, 1860, 1, 0, 0, 0, 1870, 1861, 1, 0, 0, 0, 1870, 1862, 1, 0, 0, 0, 1870, 1863, 1, 0, 0, 0, 1870, 1864, 1, 0, 0, 0, 1870, 1865, 1, 0, 0, 0, 1871, 225, 1, 0, 0, 0, 1872, 1878, 1, 0, 0, 0, 1873, 1874, 5, 44, 0, 0, 1874, 1878, 3, 0, 0, 0, 1875, 1876, 5, 44, 0, 0, 1876, 1878, 3, 32, 16, 0, 1877, 1872, 1, 0, 0, 0, 1877, 1873, 1, 0, 0, 0, 1877, 1875, 1, 0, 0, 0, 1878, 227, 1, 0, 0, 0, 1879, 1883, 1, 0, 0, 0, 1880, 1881, 5, 36, 0, 0, 1881, 1883, 3, 316, 158, 0, 1882, 1879, 1, 0, 0, 0, 1882, 1880, 1, 0, 0, 0, 1883, 229, 1, 0, 0, 0, 1884, 1890, 1, 0, 0, 0, 1885, 1886, 5, 42, 0, 0, 1886, 1887, 3, 32, 16, 0, 1887, 1888, 5, 43, 0, 0, 1888, 1890, 1, 0, 0, 0, 1889, 1884, 1, 0, 0, 0, 1889, 1885, 1, 0, 0, 0, 1890, 231, 1, 0, 0, 0, 1891, 1895, 5, 128, 0, 0, 1892, 1894, 3, 234, 117, 0, 1893, 1892, 1, 0, 0, 0, 1894, 1897, 1, 0, 0, 0, 1895, 1893, 1, 0, 0, 0, 1895, 1896, 1, 0, 0, 0, 1896, 1898, 1, 0, 0, 0, 1897, 1895, 1, 0, 0, 0, 1898, 1899, 3, 146, 73, 0, 1899, 1900, 3, 2, 1, 0, 1900, 1910, 1, 0, 0, 0, 1901, 1905, 5, 128, 0, 0, 1902, 1904, 3, 234, 117, 0, 1903, 1902, 1, 0, 0, 0, 1904, 1907, 1, 0, 0, 0, 1905, 1903, 1, 0, 0, 0, 1905, 1906, 1, 0, 0, 0, 1906, 1908, 1, 0, 0, 0, 1907, 1905, 1, 0, 0, 0, 1908, 1910, 3, 2, 1, 0, 1909, 1891, 1, 0, 0, 0, 1909, 1901, 1, 0, 0, 0, 1910, 233, 1, 0, 0, 0, 1911, 1912, 7, 11, 0, 0, 1912, 235, 1, 0, 0, 0, 1913, 1915, 3, 238, 119, 0, 1914, 1913, 1, 0, 0, 0, 1915, 1918, 1, 0, 0, 0, 1916, 1914, 1, 0, 0, 0, 1916, 1917, 1, 0, 0, 0, 1917, 237, 1, 0, 0, 0, 1918, 1916, 1, 0, 0, 0, 1919, 1920, 5, 129, 0, 0, 1920, 1932, 3, 190, 95, 0, 1921, 1922, 5, 130, 0, 0, 1922, 1932, 3, 190, 95, 0, 1923, 1924, 5, 131, 0, 0, 1924, 1932, 3, 190, 95, 0, 1925, 1926, 5, 132, 0, 0, 1926, 1932, 3, 190, 95, 0, 1927, 1932, 3, 88, 44, 0, 1928, 1932, 3, 342, 171, 0, 1929, 1932, 3, 26, 13, 0, 1930, 1932, 3, 40, 20, 0, 1931, 1919, 1, 0, 0, 0, 1931, 1921, 1, 0, 0, 0, 1931, 1923, 1, 0, 0, 0, 1931, 1925, 1, 0, 0, 0, 1931, 1927, 1, 0, 0, 0, 1931, 1928, 1, 0, 0, 0, 1931, 1929, 1, 0, 0, 0, 1931, 1930, 1, 0, 0, 0, 1932, 239, 1, 0, 0, 0, 1933, 1937, 5, 133, 0, 0, 1934, 1936, 3, 242, 121, 0, 1935, 1934, 1, 0, 0, 0, 1936, 1939, 1, 0, 0, 0, 1937, 1935, 1, 0, 0, 0, 1937, 1938, 1, 0, 0, 0, 1938, 1940, 1, 0, 0, 0, 1939, 1937, 1, 0, 0, 0, 1940, 1941, 3, 192, 96, 0, 1941, 1942, 3, 160, 80, 0, 1942, 1943, 3, 2, 1, 0, 1943, 1944, 3, 134, 67, 0, 1944, 1945, 3, 228, 114, 0, 1945, 241, 1, 0, 0, 0, 1946, 1947, 7, 11, 0, 0, 1947, 243, 1, 0, 0, 0, 1948, 1950, 3, 246, 123, 0, 1949, 1948, 1, 0, 0, 0, 1950, 1953, 1, 0, 0, 0, 1951, 1949, 1, 0, 0, 0, 1951, 1952, 1, 0, 0, 0, 1952, 245, 1, 0, 0, 0, 1953, 1951, 1, 0, 0, 0, 1954, 1955, 5, 134, 0, 0, 1955, 1965, 3, 190, 95, 0, 1956, 1957, 5, 135, 0, 0, 1957, 1965, 3, 190, 95, 0, 1958, 1959, 5, 132, 0, 0, 1959, 1965, 3, 190, 95, 0, 1960, 1965, 3, 342, 171, 0, 1961, 1965, 3, 88, 44, 0, 1962, 1965, 3, 26, 13, 0, 1963, 1965, 3, 40, 20, 0, 1964, 1954, 1, 0, 0, 0, 1964, 1956, 1, 0, 0, 0, 1964, 1958, 1, 0, 0, 0, 1964, 1960, 1, 0, 0, 0, 1964, 1961, 1, 0, 0, 0, 1964, 1962, 1, 0, 0, 0, 1964, 1963, 1, 0, 0, 0, 1965, 247, 1, 0, 0, 0, 1966, 1973, 1, 0, 0, 0, 1967, 1968, 5, 122, 0, 0, 1968, 1969, 5, 30, 0, 0, 1969, 1970, 3, 250, 125, 0, 1970, 1971, 5, 31, 0, 0, 1971, 1973, 1, 0, 0, 0, 1972, 1966, 1, 0, 0, 0, 1972, 1967, 1, 0, 0, 0, 1973, 249, 1, 0, 0, 0, 1974, 1984, 3, 148, 74, 0, 1975, 1977, 5, 17, 0, 0, 1976, 1978, 3, 314, 157, 0, 1977, 1976, 1, 0, 0, 0, 1978, 1979, 1, 0, 0, 0, 1979, 1977, 1, 0, 0, 0, 1979, 1980, 1, 0, 0, 0, 1980, 1981, 1, 0, 0, 0, 1981, 1982, 5, 18, 0, 0, 1982, 1984, 1, 0, 0, 0, 1983, 1974, 1, 0, 0, 0, 1983, 1975, 1, 0, 0, 0, 1984, 251, 1, 0, 0, 0, 1985, 1987, 3, 254, 127, 0, 1986, 1985, 1, 0, 0, 0, 1987, 1990, 1, 0, 0, 0, 1988, 1986, 1, 0, 0, 0, 1988, 1989, 1, 0, 0, 0, 1989, 253, 1, 0, 0, 0, 1990, 1988, 1, 0, 0, 0, 1991, 1992, 5, 42, 0, 0, 1992, 1993, 5, 136, 0, 0, 1993, 2005, 5, 43, 0, 0, 1994, 1995, 5, 42, 0, 0, 1995, 1996, 5, 137, 0, 0, 1996, 2005, 5, 43, 0, 0, 1997, 1998, 5, 42, 0, 0, 1998, 1999, 5, 138, 0, 0, 1999, 2005, 5, 43, 0, 0, 2000, 2001, 5, 42, 0, 0, 2001, 2002, 3, 32, 16, 0, 2002, 2003, 5, 43, 0, 0, 2003, 2005, 1, 0, 0, 0, 2004, 1991, 1, 0, 0, 0, 2004, 1994, 1, 0, 0, 0, 2004, 1997, 1, 0, 0, 0, 2004, 2000, 1, 0, 0, 0, 2005, 255, 1, 0, 0, 0, 2006, 2011, 5, 139, 0, 0, 2007, 2010, 3, 258, 129, 0, 2008, 2010, 3, 260, 130, 0, 2009, 2007, 1, 0, 0, 0, 2009, 2008, 1, 0, 0, 0, 2010, 2013, 1, 0, 0, 0, 2011, 2009, 1, 0, 0, 0, 2011, 2012, 1, 0, 0, 0, 2012, 2014, 1, 0, 0, 0, 2013, 2011, 1, 0, 0, 0, 2014, 2015, 3, 192, 96, 0, 2015, 2016, 3, 252, 126, 0, 2016, 2017, 3, 160, 80, 0, 2017, 2018, 3, 248, 124, 0, 2018, 2019, 3, 264, 132, 0, 2019, 2020, 3, 204, 102, 0, 2020, 2024, 3, 134, 67, 0, 2021, 2023, 3, 266, 133, 0, 2022, 2021, 1, 0, 0, 0, 2023, 2026, 1, 0, 0, 0, 2024, 2022, 1, 0, 0, 0, 2024, 2025, 1, 0, 0, 0, 2025, 257, 1, 0, 0, 0, 2026, 2024, 1, 0, 0, 0, 2027, 2051, 5, 123, 0, 0, 2028, 2051, 5, 51, 0, 0, 2029, 2051, 5, 52, 0, 0, 2030, 2051, 5, 63, 0, 0, 2031, 2051, 5, 140, 0, 0, 2032, 2051, 5, 68, 0, 0, 2033, 2051, 5, 141, 0, 0, 2034, 2051, 5, 142, 0, 0, 2035, 2051, 5, 54, 0, 0, 2036, 2051, 5, 64, 0, 0, 2037, 2051, 5, 65, 0, 0, 2038, 2051, 5, 66, 0, 0, 2039, 2051, 5, 125, 0, 0, 2040, 2051, 5, 143, 0, 0, 2041, 2051, 5, 144, 0, 0, 2042, 2051, 5, 69, 0, 0, 2043, 2051, 5, 145, 0, 0, 2044, 2051, 5, 146, 0, 0, 2045, 2046, 5, 70, 0, 0, 2046, 2047, 5, 30, 0, 0, 2047, 2048, 3, 32, 16, 0, 2048, 2049, 5, 31, 0, 0, 2049, 2051, 1, 0, 0, 0, 2050, 2027, 1, 0, 0, 0, 2050, 2028, 1, 0, 0, 0, 2050, 2029, 1, 0, 0, 0, 2050, 2030, 1, 0, 0, 0, 2050, 2031, 1, 0, 0, 0, 2050, 2032, 1, 0, 0, 0, 2050, 2033, 1, 0, 0, 0, 2050, 2034, 1, 0, 0, 0, 2050, 2035, 1, 0, 0, 0, 2050, 2036, 1, 0, 0, 0, 2050, 2037, 1, 0, 0, 0, 2050, 2038, 1, 0, 0, 0, 2050, 2039, 1, 0, 0, 0, 2050, 2040, 1, 0, 0, 0, 2050, 2041, 1, 0, 0, 0, 2050, 2042, 1, 0, 0, 0, 2050, 2043, 1, 0, 0, 0, 2050, 2044, 1, 0, 0, 0, 2050, 2045, 1, 0, 0, 0, 2051, 259, 1, 0, 0, 0, 2052, 2053, 5, 147, 0, 0, 2053, 2059, 5, 30, 0, 0, 2054, 2057, 3, 6, 3, 0, 2055, 2056, 5, 34, 0, 0, 2056, 2058, 3, 6, 3, 0, 2057, 2055, 1, 0, 0, 0, 2057, 2058, 1, 0, 0, 0, 2058, 2060, 1, 0, 0, 0, 2059, 2054, 1, 0, 0, 0, 2059, 2060, 1, 0, 0, 0, 2060, 2064, 1, 0, 0, 0, 2061, 2063, 3, 262, 131, 0, 2062, 2061, 1, 0, 0, 0, 2063, 2066, 1, 0, 0, 0, 2064, 2062, 1, 0, 0, 0, 2064, 2065, 1, 0, 0, 0, 2065, 2067, 1, 0, 0, 0, 2066, 2064, 1, 0, 0, 0, 2067, 2071, 5, 31, 0, 0, 2068, 2069, 5, 147, 0, 0, 2069, 2071, 5, 85, 0, 0, 2070, 2052, 1, 0, 0, 0, 2070, 2068, 1, 0, 0, 0, 2071, 261, 1, 0, 0, 0, 2072, 2100, 5, 148, 0, 0, 2073, 2100, 5, 224, 0, 0, 2074, 2100, 5, 57, 0, 0, 2075, 2100, 5, 58, 0, 0, 2076, 2100, 5, 149, 0, 0, 2077, 2100, 5, 150, 0, 0, 2078, 2100, 5, 248, 0, 0, 2079, 2100, 5, 249, 0, 0, 2080, 2100, 5, 250, 0, 0, 2081, 2100, 5, 251, 0, 0, 2082, 2083, 5, 151, 0, 0, 2083, 2084, 5, 75, 0, 0, 2084, 2100, 5, 152, 0, 0, 2085, 2086, 5, 151, 0, 0, 2086, 2087, 5, 75, 0, 0, 2087, 2100, 5, 153, 0, 0, 2088, 2089, 5, 154, 0, 0, 2089, 2090, 5, 75, 0, 0, 2090, 2100, 5, 152, 0, 0, 2091, 2092, 5, 154, 0, 0, 2092, 2093, 5, 75, 0, 0, 2093, 2100, 5, 153, 0, 0, 2094, 2095, 5, 70, 0, 0, 2095, 2096, 5, 30, 0, 0, 2096, 2097, 3, 32, 16, 0, 2097, 2098, 5, 31, 0, 0, 2098, 2100, 1, 0, 0, 0, 2099, 2072, 1, 0, 0, 0, 2099, 2073, 1, 0, 0, 0, 2099, 2074, 1, 0, 0, 0, 2099, 2075, 1, 0, 0, 0, 2099, 2076, 1, 0, 0, 0, 2099, 2077, 1, 0, 0, 0, 2099, 2078, 1, 0, 0, 0, 2099, 2079, 1, 0, 0, 0, 2099, 2080, 1, 0, 0, 0, 2099, 2081, 1, 0, 0, 0, 2099, 2082, 1, 0, 0, 0, 2099, 2085, 1, 0, 0, 0, 2099, 2088, 1, 0, 0, 0, 2099, 2091, 1, 0, 0, 0, 2099, 2094, 1, 0, 0, 0, 2100, 263, 1, 0, 0, 0, 2101, 2105, 5, 116, 0, 0, 2102, 2105, 5, 155, 0, 0, 2103, 2105, 3, 2, 1, 0, 2104, 2101, 1, 0, 0, 0, 2104, 2102, 1, 0, 0, 0, 2104, 2103, 1, 0, 0, 0, 2105, 265, 1, 0, 0, 0, 2106, 2128, 5, 1, 0, 0, 2107, 2128, 5, 2, 0, 0, 2108, 2128, 5, 156, 0, 0, 2109, 2128, 5, 3, 0, 0, 2110, 2128, 5, 4, 0, 0, 2111, 2128, 5, 247, 0, 0, 2112, 2128, 5, 5, 0, 0, 2113, 2128, 5, 6, 0, 0, 2114, 2128, 5, 7, 0, 0, 2115, 2128, 5, 8, 0, 0, 2116, 2128, 5, 9, 0, 0, 2117, 2128, 5, 10, 0, 0, 2118, 2128, 5, 11, 0, 0, 2119, 2128, 5, 12, 0, 0, 2120, 2128, 5, 13, 0, 0, 2121, 2128, 5, 14, 0, 0, 2122, 2123, 5, 70, 0, 0, 2123, 2124, 5, 30, 0, 0, 2124, 2125, 3, 32, 16, 0, 2125, 2126, 5, 31, 0, 0, 2126, 2128, 1, 0, 0, 0, 2127, 2106, 1, 0, 0, 0, 2127, 2107, 1, 0, 0, 0, 2127, 2108, 1, 0, 0, 0, 2127, 2109, 1, 0, 0, 0, 2127, 2110, 1, 0, 0, 0, 2127, 2111, 1, 0, 0, 0, 2127, 2112, 1, 0, 0, 0, 2127, 2113, 1, 0, 0, 0, 2127, 2114, 1, 0, 0, 0, 2127, 2115, 1, 0, 0, 0, 2127, 2116, 1, 0, 0, 0, 2127, 2117, 1, 0, 0, 0, 2127, 2118, 1, 0, 0, 0, 2127, 2119, 1, 0, 0, 0, 2127, 2120, 1, 0, 0, 0, 2127, 2121, 1, 0, 0, 0, 2127, 2122, 1, 0, 0, 0, 2128, 267, 1, 0, 0, 0, 2129, 2131, 3, 270, 135, 0, 2130, 2129, 1, 0, 0, 0, 2131, 2134, 1, 0, 0, 0, 2132, 2130, 1, 0, 0, 0, 2132, 2133, 1, 0, 0, 0, 2133, 269, 1, 0, 0, 0, 2134, 2132, 1, 0, 0, 0, 2135, 2244, 3, 126, 63, 0, 2136, 2137, 5, 296, 0, 0, 2137, 2244, 3, 32, 16, 0, 2138, 2244, 3, 278, 139, 0, 2139, 2140, 5, 297, 0, 0, 2140, 2244, 3, 32, 16, 0, 2141, 2142, 5, 300, 0, 0, 2142, 2244, 3, 134, 67, 0, 2143, 2144, 5, 300, 0, 0, 2144, 2145, 5, 157, 0, 0, 2145, 2244, 3, 134, 67, 0, 2146, 2244, 5, 298, 0, 0, 2147, 2244, 5, 299, 0, 0, 2148, 2244, 3, 296, 148, 0, 2149, 2244, 3, 272, 136, 0, 2150, 2244, 3, 174, 87, 0, 2151, 2244, 3, 88, 44, 0, 2152, 2244, 3, 26, 13, 0, 2153, 2244, 3, 274, 137, 0, 2154, 2244, 3, 40, 20, 0, 2155, 2156, 5, 301, 0, 0, 2156, 2157, 5, 42, 0, 0, 2157, 2158, 3, 32, 16, 0, 2158, 2159, 5, 43, 0, 0, 2159, 2244, 1, 0, 0, 0, 2160, 2161, 5, 301, 0, 0, 2161, 2162, 5, 42, 0, 0, 2162, 2163, 3, 32, 16, 0, 2163, 2164, 5, 43, 0, 0, 2164, 2165, 5, 34, 0, 0, 2165, 2166, 3, 0, 0, 0, 2166, 2244, 1, 0, 0, 0, 2167, 2168, 5, 303, 0, 0, 2168, 2169, 3, 32, 16, 0, 2169, 2170, 5, 75, 0, 0, 2170, 2171, 3, 32, 16, 0, 2171, 2244, 1, 0, 0, 0, 2172, 2173, 5, 302, 0, 0, 2173, 2174, 3, 146, 73, 0, 2174, 2175, 5, 176, 0, 0, 2175, 2176, 3, 264, 132, 0, 2176, 2244, 1, 0, 0, 0, 2177, 2178, 5, 302, 0, 0, 2178, 2179, 5, 226, 0, 0, 2179, 2180, 3, 192, 96, 0, 2180, 2181, 3, 160, 80, 0, 2181, 2182, 3, 146, 73, 0, 2182, 2183, 5, 176, 0, 0, 2183, 2184, 3, 264, 132, 0, 2184, 2185, 3, 216, 108, 0, 2185, 2186, 3, 134, 67, 0, 2186, 2244, 1, 0, 0, 0, 2187, 2244, 3, 276, 138, 0, 2188, 2189, 5, 255, 0, 0, 2189, 2190, 5, 196, 0, 0, 2190, 2191, 5, 42, 0, 0, 2191, 2192, 3, 32, 16, 0, 2192, 2196, 5, 43, 0, 0, 2193, 2195, 3, 342, 171, 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, 2244, 1, 0, 0, 0, 2198, 2196, 1, 0, 0, 0, 2199, 2200, 5, 255, 0, 0, 2200, 2201, 5, 196, 0, 0, 2201, 2205, 3, 2, 1, 0, 2202, 2204, 3, 342, 171, 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, 2244, 1, 0, 0, 0, 2207, 2205, 1, 0, 0, 0, 2208, 2209, 5, 255, 0, 0, 2209, 2210, 5, 256, 0, 0, 2210, 2211, 5, 42, 0, 0, 2211, 2212, 3, 32, 16, 0, 2212, 2213, 5, 43, 0, 0, 2213, 2214, 5, 28, 0, 0, 2214, 2218, 3, 146, 73, 0, 2215, 2217, 3, 342, 171, 0, 2216, 2215, 1, 0, 0, 0, 2217, 2220, 1, 0, 0, 0, 2218, 2216, 1, 0, 0, 0, 2218, 2219, 1, 0, 0, 0, 2219, 2244, 1, 0, 0, 0, 2220, 2218, 1, 0, 0, 0, 2221, 2222, 5, 255, 0, 0, 2222, 2223, 5, 256, 0, 0, 2223, 2224, 3, 2, 1, 0, 2224, 2225, 5, 28, 0, 0, 2225, 2229, 3, 146, 73, 0, 2226, 2228, 3, 342, 171, 0, 2227, 2226, 1, 0, 0, 0, 2228, 2231, 1, 0, 0, 0, 2229, 2227, 1, 0, 0, 0, 2229, 2230, 1, 0, 0, 0, 2230, 2244, 1, 0, 0, 0, 2231, 2229, 1, 0, 0, 0, 2232, 2233, 5, 255, 0, 0, 2233, 2234, 5, 42, 0, 0, 2234, 2235, 3, 32, 16, 0, 2235, 2236, 5, 43, 0, 0, 2236, 2240, 3, 228, 114, 0, 2237, 2239, 3, 342, 171, 0, 2238, 2237, 1, 0, 0, 0, 2239, 2242, 1, 0, 0, 0, 2240, 2238, 1, 0, 0, 0, 2240, 2241, 1, 0, 0, 0, 2241, 2244, 1, 0, 0, 0, 2242, 2240, 1, 0, 0, 0, 2243, 2135, 1, 0, 0, 0, 2243, 2136, 1, 0, 0, 0, 2243, 2138, 1, 0, 0, 0, 2243, 2139, 1, 0, 0, 0, 2243, 2141, 1, 0, 0, 0, 2243, 2143, 1, 0, 0, 0, 2243, 2146, 1, 0, 0, 0, 2243, 2147, 1, 0, 0, 0, 2243, 2148, 1, 0, 0, 0, 2243, 2149, 1, 0, 0, 0, 2243, 2150, 1, 0, 0, 0, 2243, 2151, 1, 0, 0, 0, 2243, 2152, 1, 0, 0, 0, 2243, 2153, 1, 0, 0, 0, 2243, 2154, 1, 0, 0, 0, 2243, 2155, 1, 0, 0, 0, 2243, 2160, 1, 0, 0, 0, 2243, 2167, 1, 0, 0, 0, 2243, 2172, 1, 0, 0, 0, 2243, 2177, 1, 0, 0, 0, 2243, 2187, 1, 0, 0, 0, 2243, 2188, 1, 0, 0, 0, 2243, 2199, 1, 0, 0, 0, 2243, 2208, 1, 0, 0, 0, 2243, 2221, 1, 0, 0, 0, 2243, 2232, 1, 0, 0, 0, 2244, 271, 1, 0, 0, 0, 2245, 2246, 3, 0, 0, 0, 2246, 2247, 5, 75, 0, 0, 2247, 273, 1, 0, 0, 0, 2248, 2251, 3, 44, 22, 0, 2249, 2251, 3, 46, 23, 0, 2250, 2248, 1, 0, 0, 0, 2250, 2249, 1, 0, 0, 0, 2251, 275, 1, 0, 0, 0, 2252, 2253, 5, 17, 0, 0, 2253, 2254, 3, 268, 134, 0, 2254, 2255, 5, 18, 0, 0, 2255, 277, 1, 0, 0, 0, 2256, 2257, 3, 282, 141, 0, 2257, 2258, 3, 280, 140, 0, 2258, 279, 1, 0, 0, 0, 2259, 2261, 3, 284, 142, 0, 2260, 2259, 1, 0, 0, 0, 2261, 2262, 1, 0, 0, 0, 2262, 2260, 1, 0, 0, 0, 2262, 2263, 1, 0, 0, 0, 2263, 281, 1, 0, 0, 0, 2264, 2265, 5, 158, 0, 0, 2265, 2277, 3, 276, 138, 0, 2266, 2267, 5, 158, 0, 0, 2267, 2268, 3, 0, 0, 0, 2268, 2269, 5, 159, 0, 0, 2269, 2270, 3, 0, 0, 0, 2270, 2277, 1, 0, 0, 0, 2271, 2272, 5, 158, 0, 0, 2272, 2273, 3, 32, 16, 0, 2273, 2274, 5, 159, 0, 0, 2274, 2275, 3, 32, 16, 0, 2275, 2277, 1, 0, 0, 0, 2276, 2264, 1, 0, 0, 0, 2276, 2266, 1, 0, 0, 0, 2276, 2271, 1, 0, 0, 0, 2277, 283, 1, 0, 0, 0, 2278, 2279, 3, 288, 144, 0, 2279, 2280, 3, 294, 147, 0, 2280, 2291, 1, 0, 0, 0, 2281, 2282, 3, 286, 143, 0, 2282, 2283, 3, 294, 147, 0, 2283, 2291, 1, 0, 0, 0, 2284, 2285, 3, 290, 145, 0, 2285, 2286, 3, 294, 147, 0, 2286, 2291, 1, 0, 0, 0, 2287, 2288, 3, 292, 146, 0, 2288, 2289, 3, 294, 147, 0, 2289, 2291, 1, 0, 0, 0, 2290, 2278, 1, 0, 0, 0, 2290, 2281, 1, 0, 0, 0, 2290, 2284, 1, 0, 0, 0, 2290, 2287, 1, 0, 0, 0, 2291, 285, 1, 0, 0, 0, 2292, 2293, 5, 160, 0, 0, 2293, 2299, 3, 276, 138, 0, 2294, 2295, 5, 160, 0, 0, 2295, 2299, 3, 0, 0, 0, 2296, 2297, 5, 160, 0, 0, 2297, 2299, 3, 32, 16, 0, 2298, 2292, 1, 0, 0, 0, 2298, 2294, 1, 0, 0, 0, 2298, 2296, 1, 0, 0, 0, 2299, 287, 1, 0, 0, 0, 2300, 2301, 5, 161, 0, 0, 2301, 2302, 3, 146, 73, 0, 2302, 289, 1, 0, 0, 0, 2303, 2304, 5, 162, 0, 0, 2304, 291, 1, 0, 0, 0, 2305, 2306, 5, 163, 0, 0, 2306, 293, 1, 0, 0, 0, 2307, 2319, 3, 276, 138, 0, 2308, 2309, 5, 164, 0, 0, 2309, 2310, 3, 0, 0, 0, 2310, 2311, 5, 159, 0, 0, 2311, 2312, 3, 0, 0, 0, 2312, 2319, 1, 0, 0, 0, 2313, 2314, 5, 164, 0, 0, 2314, 2315, 3, 32, 16, 0, 2315, 2316, 5, 159, 0, 0, 2316, 2317, 3, 32, 16, 0, 2317, 2319, 1, 0, 0, 0, 2318, 2307, 1, 0, 0, 0, 2318, 2308, 1, 0, 0, 0, 2318, 2313, 1, 0, 0, 0, 2319, 295, 1, 0, 0, 0, 2320, 2321, 3, 298, 149, 0, 2321, 2322, 3, 302, 151, 0, 2322, 297, 1, 0, 0, 0, 2323, 2324, 5, 165, 0, 0, 2324, 2325, 3, 300, 150, 0, 2325, 2326, 3, 0, 0, 0, 2326, 2327, 5, 36, 0, 0, 2327, 2331, 1, 0, 0, 0, 2328, 2329, 5, 165, 0, 0, 2329, 2331, 3, 300, 150, 0, 2330, 2323, 1, 0, 0, 0, 2330, 2328, 1, 0, 0, 0, 2331, 299, 1, 0, 0, 0, 2332, 2336, 1, 0, 0, 0, 2333, 2336, 5, 166, 0, 0, 2334, 2336, 5, 2, 0, 0, 2335, 2332, 1, 0, 0, 0, 2335, 2333, 1, 0, 0, 0, 2335, 2334, 1, 0, 0, 0, 2336, 301, 1, 0, 0, 0, 2337, 2338, 5, 17, 0, 0, 2338, 2339, 3, 304, 152, 0, 2339, 2340, 5, 18, 0, 0, 2340, 2347, 1, 0, 0, 0, 2341, 2343, 3, 308, 154, 0, 2342, 2341, 1, 0, 0, 0, 2343, 2344, 1, 0, 0, 0, 2344, 2342, 1, 0, 0, 0, 2344, 2345, 1, 0, 0, 0, 2345, 2347, 1, 0, 0, 0, 2346, 2337, 1, 0, 0, 0, 2346, 2342, 1, 0, 0, 0, 2347, 303, 1, 0, 0, 0, 2348, 2349, 3, 308, 154, 0, 2349, 2350, 5, 28, 0, 0, 2350, 2352, 1, 0, 0, 0, 2351, 2348, 1, 0, 0, 0, 2352, 2355, 1, 0, 0, 0, 2353, 2351, 1, 0, 0, 0, 2353, 2354, 1, 0, 0, 0, 2354, 2356, 1, 0, 0, 0, 2355, 2353, 1, 0, 0, 0, 2356, 2357, 3, 308, 154, 0, 2357, 305, 1, 0, 0, 0, 2358, 2364, 1, 0, 0, 0, 2359, 2360, 5, 42, 0, 0, 2360, 2361, 3, 32, 16, 0, 2361, 2362, 5, 43, 0, 0, 2362, 2364, 1, 0, 0, 0, 2363, 2358, 1, 0, 0, 0, 2363, 2359, 1, 0, 0, 0, 2364, 307, 1, 0, 0, 0, 2365, 2366, 5, 181, 0, 0, 2366, 2367, 5, 262, 0, 0, 2367, 2368, 5, 30, 0, 0, 2368, 2369, 3, 6, 3, 0, 2369, 2370, 5, 31, 0, 0, 2370, 2432, 1, 0, 0, 0, 2371, 2372, 5, 260, 0, 0, 2372, 2373, 5, 30, 0, 0, 2373, 2374, 3, 0, 0, 0, 2374, 2375, 5, 31, 0, 0, 2375, 2432, 1, 0, 0, 0, 2376, 2377, 5, 260, 0, 0, 2377, 2432, 3, 0, 0, 0, 2378, 2379, 5, 84, 0, 0, 2379, 2380, 5, 30, 0, 0, 2380, 2381, 3, 312, 156, 0, 2381, 2382, 5, 31, 0, 0, 2382, 2432, 1, 0, 0, 0, 2383, 2384, 5, 188, 0, 0, 2384, 2385, 5, 30, 0, 0, 2385, 2386, 3, 36, 18, 0, 2386, 2387, 5, 31, 0, 0, 2387, 2388, 3, 306, 153, 0, 2388, 2432, 1, 0, 0, 0, 2389, 2390, 5, 189, 0, 0, 2390, 2391, 5, 30, 0, 0, 2391, 2392, 3, 36, 18, 0, 2392, 2393, 5, 31, 0, 0, 2393, 2394, 3, 306, 153, 0, 2394, 2432, 1, 0, 0, 0, 2395, 2396, 5, 187, 0, 0, 2396, 2397, 5, 30, 0, 0, 2397, 2398, 3, 34, 17, 0, 2398, 2399, 5, 31, 0, 0, 2399, 2400, 3, 306, 153, 0, 2400, 2432, 1, 0, 0, 0, 2401, 2402, 5, 186, 0, 0, 2402, 2403, 5, 30, 0, 0, 2403, 2404, 3, 32, 16, 0, 2404, 2405, 5, 31, 0, 0, 2405, 2406, 3, 306, 153, 0, 2406, 2432, 1, 0, 0, 0, 2407, 2408, 5, 185, 0, 0, 2408, 2409, 5, 30, 0, 0, 2409, 2410, 3, 32, 16, 0, 2410, 2411, 5, 31, 0, 0, 2411, 2412, 3, 306, 153, 0, 2412, 2432, 1, 0, 0, 0, 2413, 2414, 5, 184, 0, 0, 2414, 2415, 5, 30, 0, 0, 2415, 2416, 3, 32, 16, 0, 2416, 2417, 5, 31, 0, 0, 2417, 2418, 3, 306, 153, 0, 2418, 2432, 1, 0, 0, 0, 2419, 2420, 5, 188, 0, 0, 2420, 2432, 3, 306, 153, 0, 2421, 2422, 5, 189, 0, 0, 2422, 2432, 3, 306, 153, 0, 2423, 2424, 5, 187, 0, 0, 2424, 2432, 3, 306, 153, 0, 2425, 2426, 5, 186, 0, 0, 2426, 2432, 3, 306, 153, 0, 2427, 2428, 5, 185, 0, 0, 2428, 2432, 3, 306, 153, 0, 2429, 2430, 5, 184, 0, 0, 2430, 2432, 3, 306, 153, 0, 2431, 2365, 1, 0, 0, 0, 2431, 2371, 1, 0, 0, 0, 2431, 2376, 1, 0, 0, 0, 2431, 2378, 1, 0, 0, 0, 2431, 2383, 1, 0, 0, 0, 2431, 2389, 1, 0, 0, 0, 2431, 2395, 1, 0, 0, 0, 2431, 2401, 1, 0, 0, 0, 2431, 2407, 1, 0, 0, 0, 2431, 2413, 1, 0, 0, 0, 2431, 2419, 1, 0, 0, 0, 2431, 2421, 1, 0, 0, 0, 2431, 2423, 1, 0, 0, 0, 2431, 2425, 1, 0, 0, 0, 2431, 2427, 1, 0, 0, 0, 2431, 2429, 1, 0, 0, 0, 2432, 309, 1, 0, 0, 0, 2433, 2434, 5, 188, 0, 0, 2434, 2435, 5, 30, 0, 0, 2435, 2436, 3, 36, 18, 0, 2436, 2437, 5, 31, 0, 0, 2437, 2509, 1, 0, 0, 0, 2438, 2439, 5, 189, 0, 0, 2439, 2440, 5, 30, 0, 0, 2440, 2441, 3, 36, 18, 0, 2441, 2442, 5, 31, 0, 0, 2442, 2509, 1, 0, 0, 0, 2443, 2444, 5, 188, 0, 0, 2444, 2445, 5, 30, 0, 0, 2445, 2446, 3, 32, 16, 0, 2446, 2447, 5, 31, 0, 0, 2447, 2509, 1, 0, 0, 0, 2448, 2449, 5, 189, 0, 0, 2449, 2450, 5, 30, 0, 0, 2450, 2451, 3, 34, 17, 0, 2451, 2452, 5, 31, 0, 0, 2452, 2509, 1, 0, 0, 0, 2453, 2454, 5, 187, 0, 0, 2454, 2455, 5, 30, 0, 0, 2455, 2456, 3, 34, 17, 0, 2456, 2457, 5, 31, 0, 0, 2457, 2509, 1, 0, 0, 0, 2458, 2459, 5, 186, 0, 0, 2459, 2460, 5, 30, 0, 0, 2460, 2461, 3, 32, 16, 0, 2461, 2462, 5, 31, 0, 0, 2462, 2509, 1, 0, 0, 0, 2463, 2464, 5, 185, 0, 0, 2464, 2465, 5, 30, 0, 0, 2465, 2466, 3, 32, 16, 0, 2466, 2467, 5, 31, 0, 0, 2467, 2509, 1, 0, 0, 0, 2468, 2469, 5, 184, 0, 0, 2469, 2470, 5, 30, 0, 0, 2470, 2471, 3, 32, 16, 0, 2471, 2472, 5, 31, 0, 0, 2472, 2509, 1, 0, 0, 0, 2473, 2474, 5, 193, 0, 0, 2474, 2475, 5, 30, 0, 0, 2475, 2476, 3, 34, 17, 0, 2476, 2477, 5, 31, 0, 0, 2477, 2509, 1, 0, 0, 0, 2478, 2479, 5, 192, 0, 0, 2479, 2480, 5, 30, 0, 0, 2480, 2481, 3, 32, 16, 0, 2481, 2482, 5, 31, 0, 0, 2482, 2509, 1, 0, 0, 0, 2483, 2484, 5, 191, 0, 0, 2484, 2485, 5, 30, 0, 0, 2485, 2486, 3, 32, 16, 0, 2486, 2487, 5, 31, 0, 0, 2487, 2509, 1, 0, 0, 0, 2488, 2489, 5, 190, 0, 0, 2489, 2490, 5, 30, 0, 0, 2490, 2491, 3, 32, 16, 0, 2491, 2492, 5, 31, 0, 0, 2492, 2509, 1, 0, 0, 0, 2493, 2494, 5, 181, 0, 0, 2494, 2495, 5, 30, 0, 0, 2495, 2496, 3, 32, 16, 0, 2496, 2497, 5, 31, 0, 0, 2497, 2509, 1, 0, 0, 0, 2498, 2499, 5, 183, 0, 0, 2499, 2500, 5, 30, 0, 0, 2500, 2501, 3, 184, 92, 0, 2501, 2502, 5, 31, 0, 0, 2502, 2509, 1, 0, 0, 0, 2503, 2504, 5, 84, 0, 0, 2504, 2505, 5, 30, 0, 0, 2505, 2506, 3, 312, 156, 0, 2506, 2507, 5, 31, 0, 0, 2507, 2509, 1, 0, 0, 0, 2508, 2433, 1, 0, 0, 0, 2508, 2438, 1, 0, 0, 0, 2508, 2443, 1, 0, 0, 0, 2508, 2448, 1, 0, 0, 0, 2508, 2453, 1, 0, 0, 0, 2508, 2458, 1, 0, 0, 0, 2508, 2463, 1, 0, 0, 0, 2508, 2468, 1, 0, 0, 0, 2508, 2473, 1, 0, 0, 0, 2508, 2478, 1, 0, 0, 0, 2508, 2483, 1, 0, 0, 0, 2508, 2488, 1, 0, 0, 0, 2508, 2493, 1, 0, 0, 0, 2508, 2498, 1, 0, 0, 0, 2508, 2503, 1, 0, 0, 0, 2509, 311, 1, 0, 0, 0, 2510, 2511, 3, 314, 157, 0, 2511, 2512, 6, 156, -1, 0, 2512, 2514, 1, 0, 0, 0, 2513, 2510, 1, 0, 0, 0, 2514, 2517, 1, 0, 0, 0, 2515, 2513, 1, 0, 0, 0, 2515, 2516, 1, 0, 0, 0, 2516, 313, 1, 0, 0, 0, 2517, 2515, 1, 0, 0, 0, 2518, 2519, 7, 12, 0, 0, 2519, 315, 1, 0, 0, 0, 2520, 2524, 3, 310, 155, 0, 2521, 2524, 3, 6, 3, 0, 2522, 2524, 5, 179, 0, 0, 2523, 2520, 1, 0, 0, 0, 2523, 2521, 1, 0, 0, 0, 2523, 2522, 1, 0, 0, 0, 2524, 317, 1, 0, 0, 0, 2525, 2674, 3, 310, 155, 0, 2526, 2527, 5, 182, 0, 0, 2527, 2528, 5, 30, 0, 0, 2528, 2529, 5, 179, 0, 0, 2529, 2674, 5, 31, 0, 0, 2530, 2531, 5, 182, 0, 0, 2531, 2532, 5, 30, 0, 0, 2532, 2533, 5, 264, 0, 0, 2533, 2674, 5, 31, 0, 0, 2534, 2535, 5, 196, 0, 0, 2535, 2536, 5, 30, 0, 0, 2536, 2537, 5, 39, 0, 0, 2537, 2538, 5, 264, 0, 0, 2538, 2674, 5, 31, 0, 0, 2539, 2540, 5, 196, 0, 0, 2540, 2541, 5, 30, 0, 0, 2541, 2542, 3, 138, 69, 0, 2542, 2543, 5, 31, 0, 0, 2543, 2674, 1, 0, 0, 0, 2544, 2545, 5, 196, 0, 0, 2545, 2546, 5, 30, 0, 0, 2546, 2547, 5, 179, 0, 0, 2547, 2674, 5, 31, 0, 0, 2548, 2549, 5, 197, 0, 0, 2549, 2550, 5, 30, 0, 0, 2550, 2551, 3, 318, 159, 0, 2551, 2552, 5, 31, 0, 0, 2552, 2674, 1, 0, 0, 0, 2553, 2554, 5, 188, 0, 0, 2554, 2555, 5, 42, 0, 0, 2555, 2556, 3, 32, 16, 0, 2556, 2557, 5, 43, 0, 0, 2557, 2558, 5, 30, 0, 0, 2558, 2559, 3, 320, 160, 0, 2559, 2560, 5, 31, 0, 0, 2560, 2674, 1, 0, 0, 0, 2561, 2562, 5, 189, 0, 0, 2562, 2563, 5, 42, 0, 0, 2563, 2564, 3, 32, 16, 0, 2564, 2565, 5, 43, 0, 0, 2565, 2566, 5, 30, 0, 0, 2566, 2567, 3, 322, 161, 0, 2567, 2568, 5, 31, 0, 0, 2568, 2674, 1, 0, 0, 0, 2569, 2570, 5, 187, 0, 0, 2570, 2571, 5, 42, 0, 0, 2571, 2572, 3, 32, 16, 0, 2572, 2573, 5, 43, 0, 0, 2573, 2574, 5, 30, 0, 0, 2574, 2575, 3, 324, 162, 0, 2575, 2576, 5, 31, 0, 0, 2576, 2674, 1, 0, 0, 0, 2577, 2578, 5, 186, 0, 0, 2578, 2579, 5, 42, 0, 0, 2579, 2580, 3, 32, 16, 0, 2580, 2581, 5, 43, 0, 0, 2581, 2582, 5, 30, 0, 0, 2582, 2583, 3, 326, 163, 0, 2583, 2584, 5, 31, 0, 0, 2584, 2674, 1, 0, 0, 0, 2585, 2586, 5, 185, 0, 0, 2586, 2587, 5, 42, 0, 0, 2587, 2588, 3, 32, 16, 0, 2588, 2589, 5, 43, 0, 0, 2589, 2590, 5, 30, 0, 0, 2590, 2591, 3, 328, 164, 0, 2591, 2592, 5, 31, 0, 0, 2592, 2674, 1, 0, 0, 0, 2593, 2594, 5, 184, 0, 0, 2594, 2595, 5, 42, 0, 0, 2595, 2596, 3, 32, 16, 0, 2596, 2597, 5, 43, 0, 0, 2597, 2598, 5, 30, 0, 0, 2598, 2599, 3, 330, 165, 0, 2599, 2600, 5, 31, 0, 0, 2600, 2674, 1, 0, 0, 0, 2601, 2602, 5, 193, 0, 0, 2602, 2603, 5, 42, 0, 0, 2603, 2604, 3, 32, 16, 0, 2604, 2605, 5, 43, 0, 0, 2605, 2606, 5, 30, 0, 0, 2606, 2607, 3, 324, 162, 0, 2607, 2608, 5, 31, 0, 0, 2608, 2674, 1, 0, 0, 0, 2609, 2610, 5, 192, 0, 0, 2610, 2611, 5, 42, 0, 0, 2611, 2612, 3, 32, 16, 0, 2612, 2613, 5, 43, 0, 0, 2613, 2614, 5, 30, 0, 0, 2614, 2615, 3, 326, 163, 0, 2615, 2616, 5, 31, 0, 0, 2616, 2674, 1, 0, 0, 0, 2617, 2618, 5, 191, 0, 0, 2618, 2619, 5, 42, 0, 0, 2619, 2620, 3, 32, 16, 0, 2620, 2621, 5, 43, 0, 0, 2621, 2622, 5, 30, 0, 0, 2622, 2623, 3, 328, 164, 0, 2623, 2624, 5, 31, 0, 0, 2624, 2674, 1, 0, 0, 0, 2625, 2626, 5, 190, 0, 0, 2626, 2627, 5, 42, 0, 0, 2627, 2628, 3, 32, 16, 0, 2628, 2629, 5, 43, 0, 0, 2629, 2630, 5, 30, 0, 0, 2630, 2631, 3, 330, 165, 0, 2631, 2632, 5, 31, 0, 0, 2632, 2674, 1, 0, 0, 0, 2633, 2634, 5, 181, 0, 0, 2634, 2635, 5, 42, 0, 0, 2635, 2636, 3, 32, 16, 0, 2636, 2637, 5, 43, 0, 0, 2637, 2638, 5, 30, 0, 0, 2638, 2639, 3, 328, 164, 0, 2639, 2640, 5, 31, 0, 0, 2640, 2674, 1, 0, 0, 0, 2641, 2642, 5, 183, 0, 0, 2642, 2643, 5, 42, 0, 0, 2643, 2644, 3, 32, 16, 0, 2644, 2645, 5, 43, 0, 0, 2645, 2646, 5, 30, 0, 0, 2646, 2647, 3, 332, 166, 0, 2647, 2648, 5, 31, 0, 0, 2648, 2674, 1, 0, 0, 0, 2649, 2650, 5, 182, 0, 0, 2650, 2651, 5, 42, 0, 0, 2651, 2652, 3, 32, 16, 0, 2652, 2653, 5, 43, 0, 0, 2653, 2654, 5, 30, 0, 0, 2654, 2655, 3, 334, 167, 0, 2655, 2656, 5, 31, 0, 0, 2656, 2674, 1, 0, 0, 0, 2657, 2658, 5, 196, 0, 0, 2658, 2659, 5, 42, 0, 0, 2659, 2660, 3, 32, 16, 0, 2660, 2661, 5, 43, 0, 0, 2661, 2662, 5, 30, 0, 0, 2662, 2663, 3, 336, 168, 0, 2663, 2664, 5, 31, 0, 0, 2664, 2674, 1, 0, 0, 0, 2665, 2666, 5, 197, 0, 0, 2666, 2667, 5, 42, 0, 0, 2667, 2668, 3, 32, 16, 0, 2668, 2669, 5, 43, 0, 0, 2669, 2670, 5, 30, 0, 0, 2670, 2671, 3, 340, 170, 0, 2671, 2672, 5, 31, 0, 0, 2672, 2674, 1, 0, 0, 0, 2673, 2525, 1, 0, 0, 0, 2673, 2526, 1, 0, 0, 0, 2673, 2530, 1, 0, 0, 0, 2673, 2534, 1, 0, 0, 0, 2673, 2539, 1, 0, 0, 0, 2673, 2544, 1, 0, 0, 0, 2673, 2548, 1, 0, 0, 0, 2673, 2553, 1, 0, 0, 0, 2673, 2561, 1, 0, 0, 0, 2673, 2569, 1, 0, 0, 0, 2673, 2577, 1, 0, 0, 0, 2673, 2585, 1, 0, 0, 0, 2673, 2593, 1, 0, 0, 0, 2673, 2601, 1, 0, 0, 0, 2673, 2609, 1, 0, 0, 0, 2673, 2617, 1, 0, 0, 0, 2673, 2625, 1, 0, 0, 0, 2673, 2633, 1, 0, 0, 0, 2673, 2641, 1, 0, 0, 0, 2673, 2649, 1, 0, 0, 0, 2673, 2657, 1, 0, 0, 0, 2673, 2665, 1, 0, 0, 0, 2674, 319, 1, 0, 0, 0, 2675, 2678, 3, 36, 18, 0, 2676, 2678, 3, 32, 16, 0, 2677, 2675, 1, 0, 0, 0, 2677, 2676, 1, 0, 0, 0, 2678, 2681, 1, 0, 0, 0, 2679, 2677, 1, 0, 0, 0, 2679, 2680, 1, 0, 0, 0, 2680, 321, 1, 0, 0, 0, 2681, 2679, 1, 0, 0, 0, 2682, 2685, 3, 36, 18, 0, 2683, 2685, 3, 34, 17, 0, 2684, 2682, 1, 0, 0, 0, 2684, 2683, 1, 0, 0, 0, 2685, 2688, 1, 0, 0, 0, 2686, 2684, 1, 0, 0, 0, 2686, 2687, 1, 0, 0, 0, 2687, 323, 1, 0, 0, 0, 2688, 2686, 1, 0, 0, 0, 2689, 2691, 3, 34, 17, 0, 2690, 2689, 1, 0, 0, 0, 2691, 2694, 1, 0, 0, 0, 2692, 2690, 1, 0, 0, 0, 2692, 2693, 1, 0, 0, 0, 2693, 325, 1, 0, 0, 0, 2694, 2692, 1, 0, 0, 0, 2695, 2697, 3, 32, 16, 0, 2696, 2695, 1, 0, 0, 0, 2697, 2700, 1, 0, 0, 0, 2698, 2696, 1, 0, 0, 0, 2698, 2699, 1, 0, 0, 0, 2699, 327, 1, 0, 0, 0, 2700, 2698, 1, 0, 0, 0, 2701, 2703, 3, 32, 16, 0, 2702, 2701, 1, 0, 0, 0, 2703, 2706, 1, 0, 0, 0, 2704, 2702, 1, 0, 0, 0, 2704, 2705, 1, 0, 0, 0, 2705, 329, 1, 0, 0, 0, 2706, 2704, 1, 0, 0, 0, 2707, 2709, 3, 32, 16, 0, 2708, 2707, 1, 0, 0, 0, 2709, 2712, 1, 0, 0, 0, 2710, 2708, 1, 0, 0, 0, 2710, 2711, 1, 0, 0, 0, 2711, 331, 1, 0, 0, 0, 2712, 2710, 1, 0, 0, 0, 2713, 2715, 3, 184, 92, 0, 2714, 2713, 1, 0, 0, 0, 2715, 2718, 1, 0, 0, 0, 2716, 2714, 1, 0, 0, 0, 2716, 2717, 1, 0, 0, 0, 2717, 333, 1, 0, 0, 0, 2718, 2716, 1, 0, 0, 0, 2719, 2721, 7, 13, 0, 0, 2720, 2719, 1, 0, 0, 0, 2721, 2724, 1, 0, 0, 0, 2722, 2720, 1, 0, 0, 0, 2722, 2723, 1, 0, 0, 0, 2723, 335, 1, 0, 0, 0, 2724, 2722, 1, 0, 0, 0, 2725, 2727, 3, 338, 169, 0, 2726, 2725, 1, 0, 0, 0, 2727, 2730, 1, 0, 0, 0, 2728, 2726, 1, 0, 0, 0, 2728, 2729, 1, 0, 0, 0, 2729, 337, 1, 0, 0, 0, 2730, 2728, 1, 0, 0, 0, 2731, 2736, 5, 179, 0, 0, 2732, 2733, 5, 39, 0, 0, 2733, 2736, 5, 264, 0, 0, 2734, 2736, 3, 138, 69, 0, 2735, 2731, 1, 0, 0, 0, 2735, 2732, 1, 0, 0, 0, 2735, 2734, 1, 0, 0, 0, 2736, 339, 1, 0, 0, 0, 2737, 2739, 3, 318, 159, 0, 2738, 2737, 1, 0, 0, 0, 2739, 2742, 1, 0, 0, 0, 2740, 2738, 1, 0, 0, 0, 2740, 2741, 1, 0, 0, 0, 2741, 341, 1, 0, 0, 0, 2742, 2740, 1, 0, 0, 0, 2743, 2747, 3, 44, 22, 0, 2744, 2747, 3, 46, 23, 0, 2745, 2747, 3, 2, 1, 0, 2746, 2743, 1, 0, 0, 0, 2746, 2744, 1, 0, 0, 0, 2746, 2745, 1, 0, 0, 0, 2747, 343, 1, 0, 0, 0, 2748, 2749, 7, 14, 0, 0, 2749, 2750, 5, 36, 0, 0, 2750, 2751, 5, 30, 0, 0, 2751, 2752, 3, 312, 156, 0, 2752, 2753, 5, 31, 0, 0, 2753, 2774, 1, 0, 0, 0, 2754, 2755, 5, 169, 0, 0, 2755, 2756, 3, 38, 19, 0, 2756, 2757, 5, 75, 0, 0, 2757, 2758, 3, 38, 19, 0, 2758, 2759, 5, 75, 0, 0, 2759, 2760, 3, 38, 19, 0, 2760, 2761, 5, 75, 0, 0, 2761, 2762, 3, 38, 19, 0, 2762, 2774, 1, 0, 0, 0, 2763, 2764, 5, 170, 0, 0, 2764, 2774, 3, 6, 3, 0, 2765, 2766, 5, 170, 0, 0, 2766, 2767, 5, 36, 0, 0, 2767, 2768, 5, 30, 0, 0, 2768, 2769, 3, 312, 156, 0, 2769, 2770, 5, 31, 0, 0, 2770, 2774, 1, 0, 0, 0, 2771, 2774, 3, 342, 171, 0, 2772, 2774, 3, 40, 20, 0, 2773, 2748, 1, 0, 0, 0, 2773, 2754, 1, 0, 0, 0, 2773, 2763, 1, 0, 0, 0, 2773, 2765, 1, 0, 0, 0, 2773, 2771, 1, 0, 0, 0, 2773, 2772, 1, 0, 0, 0, 2774, 345, 1, 0, 0, 0, 2775, 2776, 5, 25, 0, 0, 2776, 2777, 5, 40, 0, 0, 2777, 2778, 3, 98, 49, 0, 2778, 2779, 3, 2, 1, 0, 2779, 2788, 1, 0, 0, 0, 2780, 2781, 5, 25, 0, 0, 2781, 2782, 5, 40, 0, 0, 2782, 2783, 3, 98, 49, 0, 2783, 2784, 3, 2, 1, 0, 2784, 2785, 5, 34, 0, 0, 2785, 2786, 3, 2, 1, 0, 2786, 2788, 1, 0, 0, 0, 2787, 2775, 1, 0, 0, 0, 2787, 2780, 1, 0, 0, 0, 2788, 347, 1, 0, 0, 0, 2789, 2791, 3, 350, 175, 0, 2790, 2789, 1, 0, 0, 0, 2791, 2794, 1, 0, 0, 0, 2792, 2790, 1, 0, 0, 0, 2792, 2793, 1, 0, 0, 0, 2793, 349, 1, 0, 0, 0, 2794, 2792, 1, 0, 0, 0, 2795, 2796, 5, 180, 0, 0, 2796, 2797, 5, 36, 0, 0, 2797, 2798, 5, 30, 0, 0, 2798, 2799, 3, 312, 156, 0, 2799, 2800, 5, 31, 0, 0, 2800, 2810, 1, 0, 0, 0, 2801, 2810, 3, 344, 172, 0, 2802, 2803, 5, 171, 0, 0, 2803, 2804, 5, 36, 0, 0, 2804, 2805, 5, 30, 0, 0, 2805, 2806, 3, 312, 156, 0, 2806, 2807, 5, 31, 0, 0, 2807, 2810, 1, 0, 0, 0, 2808, 2810, 5, 55, 0, 0, 2809, 2795, 1, 0, 0, 0, 2809, 2801, 1, 0, 0, 0, 2809, 2802, 1, 0, 0, 0, 2809, 2808, 1, 0, 0, 0, 2810, 351, 1, 0, 0, 0, 2811, 2812, 5, 50, 0, 0, 2812, 2816, 5, 40, 0, 0, 2813, 2815, 3, 356, 178, 0, 2814, 2813, 1, 0, 0, 0, 2815, 2818, 1, 0, 0, 0, 2816, 2814, 1, 0, 0, 0, 2816, 2817, 1, 0, 0, 0, 2817, 2819, 1, 0, 0, 0, 2818, 2816, 1, 0, 0, 0, 2819, 2820, 3, 2, 1, 0, 2820, 353, 1, 0, 0, 0, 2821, 2825, 5, 301, 0, 0, 2822, 2824, 3, 356, 178, 0, 2823, 2822, 1, 0, 0, 0, 2824, 2827, 1, 0, 0, 0, 2825, 2823, 1, 0, 0, 0, 2825, 2826, 1, 0, 0, 0, 2826, 2828, 1, 0, 0, 0, 2827, 2825, 1, 0, 0, 0, 2828, 2829, 3, 2, 1, 0, 2829, 355, 1, 0, 0, 0, 2830, 2846, 5, 52, 0, 0, 2831, 2846, 5, 51, 0, 0, 2832, 2846, 5, 172, 0, 0, 2833, 2834, 5, 62, 0, 0, 2834, 2846, 5, 51, 0, 0, 2835, 2836, 5, 62, 0, 0, 2836, 2846, 5, 52, 0, 0, 2837, 2838, 5, 62, 0, 0, 2838, 2846, 5, 63, 0, 0, 2839, 2840, 5, 62, 0, 0, 2840, 2846, 5, 64, 0, 0, 2841, 2842, 5, 62, 0, 0, 2842, 2846, 5, 65, 0, 0, 2843, 2844, 5, 62, 0, 0, 2844, 2846, 5, 66, 0, 0, 2845, 2830, 1, 0, 0, 0, 2845, 2831, 1, 0, 0, 0, 2845, 2832, 1, 0, 0, 0, 2845, 2833, 1, 0, 0, 0, 2845, 2835, 1, 0, 0, 0, 2845, 2837, 1, 0, 0, 0, 2845, 2839, 1, 0, 0, 0, 2845, 2841, 1, 0, 0, 0, 2845, 2843, 1, 0, 0, 0, 2846, 357, 1, 0, 0, 0, 2847, 2849, 3, 360, 180, 0, 2848, 2847, 1, 0, 0, 0, 2849, 2852, 1, 0, 0, 0, 2850, 2848, 1, 0, 0, 0, 2850, 2851, 1, 0, 0, 0, 2851, 359, 1, 0, 0, 0, 2852, 2850, 1, 0, 0, 0, 2853, 2854, 5, 21, 0, 0, 2854, 2867, 3, 2, 1, 0, 2855, 2856, 5, 50, 0, 0, 2856, 2857, 5, 40, 0, 0, 2857, 2867, 3, 140, 70, 0, 2858, 2859, 5, 25, 0, 0, 2859, 2860, 5, 40, 0, 0, 2860, 2867, 3, 2, 1, 0, 2861, 2867, 3, 196, 98, 0, 2862, 2863, 5, 50, 0, 0, 2863, 2867, 3, 32, 16, 0, 2864, 2867, 3, 342, 171, 0, 2865, 2867, 3, 40, 20, 0, 2866, 2853, 1, 0, 0, 0, 2866, 2855, 1, 0, 0, 0, 2866, 2858, 1, 0, 0, 0, 2866, 2861, 1, 0, 0, 0, 2866, 2862, 1, 0, 0, 0, 2866, 2864, 1, 0, 0, 0, 2866, 2865, 1, 0, 0, 0, 2867, 361, 1, 0, 0, 0, 2868, 2872, 5, 274, 0, 0, 2869, 2871, 3, 364, 182, 0, 2870, 2869, 1, 0, 0, 0, 2871, 2874, 1, 0, 0, 0, 2872, 2870, 1, 0, 0, 0, 2872, 2873, 1, 0, 0, 0, 2873, 2875, 1, 0, 0, 0, 2874, 2872, 1, 0, 0, 0, 2875, 2888, 3, 2, 1, 0, 2876, 2880, 5, 274, 0, 0, 2877, 2879, 3, 364, 182, 0, 2878, 2877, 1, 0, 0, 0, 2879, 2882, 1, 0, 0, 0, 2880, 2878, 1, 0, 0, 0, 2880, 2881, 1, 0, 0, 0, 2881, 2883, 1, 0, 0, 0, 2882, 2880, 1, 0, 0, 0, 2883, 2884, 3, 2, 1, 0, 2884, 2885, 5, 34, 0, 0, 2885, 2886, 3, 2, 1, 0, 2886, 2888, 1, 0, 0, 0, 2887, 2868, 1, 0, 0, 0, 2887, 2876, 1, 0, 0, 0, 2888, 363, 1, 0, 0, 0, 2889, 2890, 7, 15, 0, 0, 2890, 365, 1, 0, 0, 0, 2891, 2893, 3, 368, 184, 0, 2892, 2891, 1, 0, 0, 0, 2893, 2896, 1, 0, 0, 0, 2894, 2892, 1, 0, 0, 0, 2894, 2895, 1, 0, 0, 0, 2895, 367, 1, 0, 0, 0, 2896, 2894, 1, 0, 0, 0, 2897, 2898, 5, 21, 0, 0, 2898, 2899, 3, 2, 1, 0, 2899, 2900, 5, 44, 0, 0, 2900, 2901, 3, 32, 16, 0, 2901, 2908, 1, 0, 0, 0, 2902, 2903, 5, 25, 0, 0, 2903, 2904, 5, 40, 0, 0, 2904, 2908, 3, 2, 1, 0, 2905, 2908, 3, 342, 171, 0, 2906, 2908, 3, 40, 20, 0, 2907, 2897, 1, 0, 0, 0, 2907, 2902, 1, 0, 0, 0, 2907, 2905, 1, 0, 0, 0, 2907, 2906, 1, 0, 0, 0, 2908, 369, 1, 0, 0, 0, 172, 378, 383, 391, 399, 452, 493, 502, 526, 530, 548, 575, 598, 634, 640, 647, 649, 659, 661, 668, 679, 687, 708, 710, 726, 771, 776, 781, 786, 794, 904, 910, 926, 932, 938, 945, 1056, 1061, 1067, 1072, 1074, 1082, 1094, 1106, 1113, 1120, 1122, 1149, 1156, 1164, 1172, 1185, 1192, 1195, 1214, 1308, 1317, 1324, 1327, 1335, 1356, 1388, 1411, 1423, 1432, 1457, 1481, 1489, 1493, 1508, 1515, 1560, 1570, 1586, 1598, 1610, 1624, 1636, 1647, 1654, 1664, 1677, 1682, 1687, 1696, 1707, 1790, 1799, 1812, 1823, 1831, 1841, 1843, 1870, 1877, 1882, 1889, 1895, 1905, 1909, 1916, 1931, 1937, 1951, 1964, 1972, 1979, 1983, 1988, 2004, 2009, 2011, 2024, 2050, 2057, 2059, 2064, 2070, 2099, 2104, 2127, 2132, 2196, 2205, 2218, 2229, 2240, 2243, 2250, 2262, 2276, 2290, 2298, 2318, 2330, 2335, 2344, 2346, 2353, 2363, 2431, 2508, 2515, 2523, 2673, 2677, 2679, 2684, 2686, 2692, 2698, 2704, 2710, 2716, 2722, 2728, 2735, 2740, 2746, 2773, 2787, 2792, 2809, 2816, 2825, 2845, 2850, 2866, 2872, 2880, 2887, 2894, 2907] \ No newline at end of file +[4, 1, 305, 2882, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 357, 8, 1, 10, 1, 12, 1, 360, 9, 1, 1, 1, 1, 1, 3, 1, 364, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 5, 3, 370, 8, 3, 10, 3, 12, 3, 373, 9, 3, 1, 3, 1, 3, 1, 4, 5, 4, 378, 8, 4, 10, 4, 12, 4, 381, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 433, 8, 5, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 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, 474, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 5, 15, 481, 8, 15, 10, 15, 12, 15, 484, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 507, 8, 18, 1, 19, 1, 19, 3, 19, 511, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 529, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 556, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 579, 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, 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, 615, 8, 23, 1, 24, 1, 24, 1, 25, 1, 25, 3, 25, 621, 8, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 5, 27, 628, 8, 27, 10, 27, 12, 27, 631, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 640, 8, 28, 10, 28, 12, 28, 643, 9, 28, 1, 29, 1, 29, 1, 30, 1, 30, 3, 30, 649, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 660, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 668, 8, 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, 34, 1, 34, 1, 34, 1, 34, 5, 34, 689, 8, 34, 10, 34, 12, 34, 692, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 5, 37, 705, 8, 37, 10, 37, 12, 37, 708, 9, 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, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 752, 8, 38, 1, 39, 1, 39, 1, 39, 3, 39, 757, 8, 39, 1, 40, 1, 40, 1, 40, 3, 40, 762, 8, 40, 1, 41, 5, 41, 765, 8, 41, 10, 41, 12, 41, 768, 9, 41, 1, 42, 1, 42, 1, 42, 5, 42, 773, 8, 42, 10, 42, 12, 42, 776, 9, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 885, 8, 44, 1, 45, 1, 45, 5, 45, 889, 8, 45, 10, 45, 12, 45, 892, 9, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 905, 8, 45, 10, 45, 12, 45, 908, 9, 45, 1, 45, 1, 45, 1, 45, 3, 45, 913, 8, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 919, 8, 47, 1, 48, 1, 48, 1, 49, 5, 49, 924, 8, 49, 10, 49, 12, 49, 927, 9, 49, 1, 50, 1, 50, 3, 50, 931, 8, 50, 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, 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, 983, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 1019, 8, 52, 1, 53, 1, 53, 1, 53, 3, 53, 1024, 8, 53, 1, 53, 1, 53, 5, 53, 1028, 8, 53, 10, 53, 12, 53, 1031, 9, 53, 1, 53, 1, 53, 3, 53, 1035, 8, 53, 3, 53, 1037, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1043, 8, 54, 10, 54, 12, 54, 1046, 9, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1055, 8, 55, 10, 55, 12, 55, 1058, 9, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 5, 56, 1067, 8, 56, 10, 56, 12, 56, 1070, 9, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1076, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 1083, 8, 57, 3, 57, 1085, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1112, 8, 58, 1, 59, 1, 59, 1, 59, 5, 59, 1117, 8, 59, 10, 59, 12, 59, 1120, 9, 59, 1, 59, 1, 59, 1, 60, 5, 60, 1125, 8, 60, 10, 60, 12, 60, 1128, 9, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1135, 8, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 3, 62, 1148, 8, 62, 1, 63, 1, 63, 1, 63, 5, 63, 1153, 8, 63, 10, 63, 12, 63, 1156, 9, 63, 3, 63, 1158, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 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, 1177, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1271, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1280, 8, 66, 1, 67, 1, 67, 1, 67, 5, 67, 1285, 8, 67, 10, 67, 12, 67, 1288, 9, 67, 3, 67, 1290, 8, 67, 1, 68, 1, 68, 1, 69, 1, 69, 5, 69, 1296, 8, 69, 10, 69, 12, 69, 1299, 9, 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, 1, 70, 1, 70, 1, 70, 3, 70, 1319, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1351, 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, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1374, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1386, 8, 73, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1395, 8, 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, 3, 76, 1420, 8, 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, 1444, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 5, 77, 1450, 8, 77, 10, 77, 12, 77, 1453, 9, 77, 1, 77, 3, 77, 1456, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1471, 8, 78, 1, 79, 1, 79, 1, 79, 5, 79, 1476, 8, 79, 10, 79, 12, 79, 1479, 9, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1523, 8, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1533, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1549, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1561, 8, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1573, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1587, 8, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 1599, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1610, 8, 89, 1, 90, 1, 90, 1, 90, 5, 90, 1615, 8, 90, 10, 90, 12, 90, 1618, 9, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 1627, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 1640, 8, 92, 1, 93, 5, 93, 1643, 8, 93, 10, 93, 12, 93, 1646, 9, 93, 1, 94, 1, 94, 3, 94, 1650, 8, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 5, 95, 1657, 8, 95, 10, 95, 12, 95, 1660, 9, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 3, 97, 1670, 8, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1751, 8, 99, 10, 99, 12, 99, 1754, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1760, 8, 99, 10, 99, 12, 99, 1763, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1773, 8, 99, 10, 99, 12, 99, 1776, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1784, 8, 99, 10, 99, 12, 99, 1787, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 1794, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 1804, 8, 100, 10, 100, 12, 100, 1807, 9, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 1833, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 1840, 8, 102, 1, 103, 1, 103, 1, 103, 3, 103, 1845, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 1852, 8, 104, 1, 105, 1, 105, 5, 105, 1856, 8, 105, 10, 105, 12, 105, 1859, 9, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 1866, 8, 105, 10, 105, 12, 105, 1869, 9, 105, 1, 105, 3, 105, 1872, 8, 105, 1, 106, 1, 106, 1, 107, 5, 107, 1877, 8, 107, 10, 107, 12, 107, 1880, 9, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 1894, 8, 108, 1, 109, 1, 109, 5, 109, 1898, 8, 109, 10, 109, 12, 109, 1901, 9, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 111, 5, 111, 1912, 8, 111, 10, 111, 12, 111, 1915, 9, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 1927, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 1935, 8, 113, 1, 114, 1, 114, 1, 114, 4, 114, 1940, 8, 114, 11, 114, 12, 114, 1941, 1, 114, 1, 114, 3, 114, 1946, 8, 114, 1, 115, 5, 115, 1949, 8, 115, 10, 115, 12, 115, 1952, 9, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 1967, 8, 116, 1, 117, 1, 117, 1, 117, 5, 117, 1972, 8, 117, 10, 117, 12, 117, 1975, 9, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 1985, 8, 117, 10, 117, 12, 117, 1988, 9, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2013, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2020, 8, 119, 3, 119, 2022, 8, 119, 1, 119, 5, 119, 2025, 8, 119, 10, 119, 12, 119, 2028, 9, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2033, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2062, 8, 120, 1, 121, 1, 121, 1, 121, 3, 121, 2067, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2090, 8, 122, 1, 123, 5, 123, 2093, 8, 123, 10, 123, 12, 123, 2096, 9, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2115, 8, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2166, 8, 125, 10, 125, 12, 125, 2169, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2175, 8, 125, 10, 125, 12, 125, 2178, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2188, 8, 125, 10, 125, 12, 125, 2191, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2199, 8, 125, 10, 125, 12, 125, 2202, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2210, 8, 125, 10, 125, 12, 125, 2213, 9, 125, 3, 125, 2215, 8, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 3, 127, 2223, 8, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 130, 4, 130, 2233, 8, 130, 11, 130, 12, 130, 2234, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 2249, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 3, 132, 2263, 8, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 2271, 8, 133, 1, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 2291, 8, 137, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 2303, 8, 139, 1, 140, 1, 140, 1, 140, 3, 140, 2308, 8, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 4, 141, 2315, 8, 141, 11, 141, 12, 141, 2316, 3, 141, 2319, 8, 141, 1, 142, 1, 142, 1, 142, 5, 142, 2324, 8, 142, 10, 142, 12, 142, 2327, 9, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 2336, 8, 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, 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, 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, 2404, 8, 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, 145, 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, 145, 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, 145, 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, 145, 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, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 3, 145, 2481, 8, 145, 1, 146, 1, 146, 1, 146, 5, 146, 2486, 8, 146, 10, 146, 12, 146, 2489, 9, 146, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 3, 148, 2496, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 2646, 8, 149, 1, 150, 1, 150, 5, 150, 2650, 8, 150, 10, 150, 12, 150, 2653, 9, 150, 1, 151, 1, 151, 5, 151, 2657, 8, 151, 10, 151, 12, 151, 2660, 9, 151, 1, 152, 5, 152, 2663, 8, 152, 10, 152, 12, 152, 2666, 9, 152, 1, 153, 5, 153, 2669, 8, 153, 10, 153, 12, 153, 2672, 9, 153, 1, 154, 5, 154, 2675, 8, 154, 10, 154, 12, 154, 2678, 9, 154, 1, 155, 5, 155, 2681, 8, 155, 10, 155, 12, 155, 2684, 9, 155, 1, 156, 5, 156, 2687, 8, 156, 10, 156, 12, 156, 2690, 9, 156, 1, 157, 5, 157, 2693, 8, 157, 10, 157, 12, 157, 2696, 9, 157, 1, 158, 5, 158, 2699, 8, 158, 10, 158, 12, 158, 2702, 9, 158, 1, 159, 1, 159, 1, 159, 1, 159, 3, 159, 2708, 8, 159, 1, 160, 5, 160, 2711, 8, 160, 10, 160, 12, 160, 2714, 9, 160, 1, 161, 1, 161, 1, 161, 3, 161, 2719, 8, 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, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 3, 162, 2746, 8, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 2760, 8, 163, 1, 164, 5, 164, 2763, 8, 164, 10, 164, 12, 164, 2766, 9, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 3, 165, 2782, 8, 165, 1, 166, 1, 166, 1, 166, 5, 166, 2787, 8, 166, 10, 166, 12, 166, 2790, 9, 166, 1, 166, 1, 166, 1, 167, 1, 167, 5, 167, 2796, 8, 167, 10, 167, 12, 167, 2799, 9, 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, 168, 1, 168, 1, 168, 1, 168, 3, 168, 2818, 8, 168, 1, 169, 5, 169, 2821, 8, 169, 10, 169, 12, 169, 2824, 9, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 2839, 8, 170, 1, 171, 1, 171, 5, 171, 2843, 8, 171, 10, 171, 12, 171, 2846, 9, 171, 1, 171, 1, 171, 1, 171, 5, 171, 2851, 8, 171, 10, 171, 12, 171, 2854, 9, 171, 1, 171, 1, 171, 1, 171, 1, 171, 3, 171, 2860, 8, 171, 1, 172, 1, 172, 1, 173, 5, 173, 2865, 8, 173, 10, 173, 12, 173, 2868, 9, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 2880, 8, 174, 1, 174, 0, 1, 68, 175, 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, 0, 16, 6, 0, 1, 15, 199, 199, 243, 243, 247, 247, 264, 264, 289, 289, 5, 0, 16, 16, 199, 199, 243, 243, 264, 264, 288, 289, 1, 0, 263, 264, 1, 0, 173, 174, 1, 0, 37, 38, 1, 0, 73, 74, 3, 0, 2, 2, 61, 61, 77, 83, 2, 0, 229, 229, 260, 261, 9, 0, 178, 178, 183, 195, 201, 201, 207, 208, 210, 215, 218, 219, 222, 222, 230, 242, 262, 262, 1, 0, 95, 96, 1, 0, 97, 111, 1, 0, 68, 69, 2, 0, 173, 173, 289, 290, 2, 0, 179, 179, 264, 264, 1, 0, 167, 168, 1, 0, 51, 52, 3309, 0, 350, 1, 0, 0, 0, 2, 363, 1, 0, 0, 0, 4, 365, 1, 0, 0, 0, 6, 371, 1, 0, 0, 0, 8, 379, 1, 0, 0, 0, 10, 432, 1, 0, 0, 0, 12, 434, 1, 0, 0, 0, 14, 437, 1, 0, 0, 0, 16, 440, 1, 0, 0, 0, 18, 444, 1, 0, 0, 0, 20, 447, 1, 0, 0, 0, 22, 450, 1, 0, 0, 0, 24, 457, 1, 0, 0, 0, 26, 473, 1, 0, 0, 0, 28, 475, 1, 0, 0, 0, 30, 477, 1, 0, 0, 0, 32, 487, 1, 0, 0, 0, 34, 489, 1, 0, 0, 0, 36, 506, 1, 0, 0, 0, 38, 510, 1, 0, 0, 0, 40, 528, 1, 0, 0, 0, 42, 555, 1, 0, 0, 0, 44, 578, 1, 0, 0, 0, 46, 614, 1, 0, 0, 0, 48, 616, 1, 0, 0, 0, 50, 620, 1, 0, 0, 0, 52, 622, 1, 0, 0, 0, 54, 629, 1, 0, 0, 0, 56, 641, 1, 0, 0, 0, 58, 644, 1, 0, 0, 0, 60, 646, 1, 0, 0, 0, 62, 659, 1, 0, 0, 0, 64, 667, 1, 0, 0, 0, 66, 669, 1, 0, 0, 0, 68, 677, 1, 0, 0, 0, 70, 693, 1, 0, 0, 0, 72, 699, 1, 0, 0, 0, 74, 702, 1, 0, 0, 0, 76, 751, 1, 0, 0, 0, 78, 756, 1, 0, 0, 0, 80, 761, 1, 0, 0, 0, 82, 766, 1, 0, 0, 0, 84, 774, 1, 0, 0, 0, 86, 779, 1, 0, 0, 0, 88, 884, 1, 0, 0, 0, 90, 912, 1, 0, 0, 0, 92, 914, 1, 0, 0, 0, 94, 918, 1, 0, 0, 0, 96, 920, 1, 0, 0, 0, 98, 925, 1, 0, 0, 0, 100, 930, 1, 0, 0, 0, 102, 982, 1, 0, 0, 0, 104, 1018, 1, 0, 0, 0, 106, 1036, 1, 0, 0, 0, 108, 1038, 1, 0, 0, 0, 110, 1050, 1, 0, 0, 0, 112, 1075, 1, 0, 0, 0, 114, 1084, 1, 0, 0, 0, 116, 1111, 1, 0, 0, 0, 118, 1118, 1, 0, 0, 0, 120, 1126, 1, 0, 0, 0, 122, 1134, 1, 0, 0, 0, 124, 1147, 1, 0, 0, 0, 126, 1157, 1, 0, 0, 0, 128, 1176, 1, 0, 0, 0, 130, 1270, 1, 0, 0, 0, 132, 1279, 1, 0, 0, 0, 134, 1289, 1, 0, 0, 0, 136, 1291, 1, 0, 0, 0, 138, 1293, 1, 0, 0, 0, 140, 1318, 1, 0, 0, 0, 142, 1350, 1, 0, 0, 0, 144, 1373, 1, 0, 0, 0, 146, 1385, 1, 0, 0, 0, 148, 1387, 1, 0, 0, 0, 150, 1390, 1, 0, 0, 0, 152, 1443, 1, 0, 0, 0, 154, 1455, 1, 0, 0, 0, 156, 1470, 1, 0, 0, 0, 158, 1477, 1, 0, 0, 0, 160, 1482, 1, 0, 0, 0, 162, 1486, 1, 0, 0, 0, 164, 1522, 1, 0, 0, 0, 166, 1524, 1, 0, 0, 0, 168, 1560, 1, 0, 0, 0, 170, 1572, 1, 0, 0, 0, 172, 1586, 1, 0, 0, 0, 174, 1588, 1, 0, 0, 0, 176, 1598, 1, 0, 0, 0, 178, 1609, 1, 0, 0, 0, 180, 1616, 1, 0, 0, 0, 182, 1626, 1, 0, 0, 0, 184, 1639, 1, 0, 0, 0, 186, 1644, 1, 0, 0, 0, 188, 1647, 1, 0, 0, 0, 190, 1658, 1, 0, 0, 0, 192, 1663, 1, 0, 0, 0, 194, 1669, 1, 0, 0, 0, 196, 1671, 1, 0, 0, 0, 198, 1793, 1, 0, 0, 0, 200, 1795, 1, 0, 0, 0, 202, 1832, 1, 0, 0, 0, 204, 1839, 1, 0, 0, 0, 206, 1844, 1, 0, 0, 0, 208, 1851, 1, 0, 0, 0, 210, 1871, 1, 0, 0, 0, 212, 1873, 1, 0, 0, 0, 214, 1878, 1, 0, 0, 0, 216, 1893, 1, 0, 0, 0, 218, 1895, 1, 0, 0, 0, 220, 1908, 1, 0, 0, 0, 222, 1913, 1, 0, 0, 0, 224, 1926, 1, 0, 0, 0, 226, 1934, 1, 0, 0, 0, 228, 1945, 1, 0, 0, 0, 230, 1950, 1, 0, 0, 0, 232, 1966, 1, 0, 0, 0, 234, 1968, 1, 0, 0, 0, 236, 2012, 1, 0, 0, 0, 238, 2032, 1, 0, 0, 0, 240, 2061, 1, 0, 0, 0, 242, 2066, 1, 0, 0, 0, 244, 2089, 1, 0, 0, 0, 246, 2094, 1, 0, 0, 0, 248, 2114, 1, 0, 0, 0, 250, 2214, 1, 0, 0, 0, 252, 2216, 1, 0, 0, 0, 254, 2222, 1, 0, 0, 0, 256, 2224, 1, 0, 0, 0, 258, 2228, 1, 0, 0, 0, 260, 2232, 1, 0, 0, 0, 262, 2248, 1, 0, 0, 0, 264, 2262, 1, 0, 0, 0, 266, 2270, 1, 0, 0, 0, 268, 2272, 1, 0, 0, 0, 270, 2275, 1, 0, 0, 0, 272, 2277, 1, 0, 0, 0, 274, 2290, 1, 0, 0, 0, 276, 2292, 1, 0, 0, 0, 278, 2302, 1, 0, 0, 0, 280, 2307, 1, 0, 0, 0, 282, 2318, 1, 0, 0, 0, 284, 2325, 1, 0, 0, 0, 286, 2335, 1, 0, 0, 0, 288, 2403, 1, 0, 0, 0, 290, 2480, 1, 0, 0, 0, 292, 2487, 1, 0, 0, 0, 294, 2490, 1, 0, 0, 0, 296, 2495, 1, 0, 0, 0, 298, 2645, 1, 0, 0, 0, 300, 2651, 1, 0, 0, 0, 302, 2658, 1, 0, 0, 0, 304, 2664, 1, 0, 0, 0, 306, 2670, 1, 0, 0, 0, 308, 2676, 1, 0, 0, 0, 310, 2682, 1, 0, 0, 0, 312, 2688, 1, 0, 0, 0, 314, 2694, 1, 0, 0, 0, 316, 2700, 1, 0, 0, 0, 318, 2707, 1, 0, 0, 0, 320, 2712, 1, 0, 0, 0, 322, 2718, 1, 0, 0, 0, 324, 2745, 1, 0, 0, 0, 326, 2759, 1, 0, 0, 0, 328, 2764, 1, 0, 0, 0, 330, 2781, 1, 0, 0, 0, 332, 2783, 1, 0, 0, 0, 334, 2793, 1, 0, 0, 0, 336, 2817, 1, 0, 0, 0, 338, 2822, 1, 0, 0, 0, 340, 2838, 1, 0, 0, 0, 342, 2859, 1, 0, 0, 0, 344, 2861, 1, 0, 0, 0, 346, 2866, 1, 0, 0, 0, 348, 2879, 1, 0, 0, 0, 350, 351, 7, 0, 0, 0, 351, 1, 1, 0, 0, 0, 352, 364, 5, 288, 0, 0, 353, 354, 3, 4, 2, 0, 354, 355, 5, 265, 0, 0, 355, 357, 1, 0, 0, 0, 356, 353, 1, 0, 0, 0, 357, 360, 1, 0, 0, 0, 358, 356, 1, 0, 0, 0, 358, 359, 1, 0, 0, 0, 359, 361, 1, 0, 0, 0, 360, 358, 1, 0, 0, 0, 361, 364, 3, 4, 2, 0, 362, 364, 5, 264, 0, 0, 363, 352, 1, 0, 0, 0, 363, 358, 1, 0, 0, 0, 363, 362, 1, 0, 0, 0, 364, 3, 1, 0, 0, 0, 365, 366, 7, 1, 0, 0, 366, 5, 1, 0, 0, 0, 367, 368, 5, 263, 0, 0, 368, 370, 5, 266, 0, 0, 369, 367, 1, 0, 0, 0, 370, 373, 1, 0, 0, 0, 371, 369, 1, 0, 0, 0, 371, 372, 1, 0, 0, 0, 372, 374, 1, 0, 0, 0, 373, 371, 1, 0, 0, 0, 374, 375, 5, 263, 0, 0, 375, 7, 1, 0, 0, 0, 376, 378, 3, 10, 5, 0, 377, 376, 1, 0, 0, 0, 378, 381, 1, 0, 0, 0, 379, 377, 1, 0, 0, 0, 379, 380, 1, 0, 0, 0, 380, 9, 1, 0, 0, 0, 381, 379, 1, 0, 0, 0, 382, 383, 3, 74, 37, 0, 383, 384, 5, 17, 0, 0, 384, 385, 3, 82, 41, 0, 385, 386, 5, 18, 0, 0, 386, 433, 1, 0, 0, 0, 387, 388, 3, 72, 36, 0, 388, 389, 5, 17, 0, 0, 389, 390, 3, 8, 4, 0, 390, 391, 5, 18, 0, 0, 391, 433, 1, 0, 0, 0, 392, 393, 3, 234, 117, 0, 393, 394, 5, 17, 0, 0, 394, 395, 3, 246, 123, 0, 395, 396, 5, 18, 0, 0, 396, 433, 1, 0, 0, 0, 397, 433, 3, 200, 100, 0, 398, 433, 3, 276, 138, 0, 399, 433, 3, 70, 35, 0, 400, 433, 3, 66, 33, 0, 401, 433, 3, 88, 44, 0, 402, 433, 3, 90, 45, 0, 403, 433, 3, 22, 11, 0, 404, 405, 3, 326, 163, 0, 405, 406, 5, 17, 0, 0, 406, 407, 3, 328, 164, 0, 407, 408, 5, 18, 0, 0, 408, 433, 1, 0, 0, 0, 409, 410, 3, 332, 166, 0, 410, 411, 5, 17, 0, 0, 411, 412, 3, 338, 169, 0, 412, 413, 5, 18, 0, 0, 413, 433, 1, 0, 0, 0, 414, 415, 3, 342, 171, 0, 415, 416, 5, 17, 0, 0, 416, 417, 3, 346, 173, 0, 417, 418, 5, 18, 0, 0, 418, 433, 1, 0, 0, 0, 419, 433, 3, 64, 32, 0, 420, 433, 3, 152, 76, 0, 421, 433, 3, 322, 161, 0, 422, 433, 3, 12, 6, 0, 423, 433, 3, 14, 7, 0, 424, 433, 3, 16, 8, 0, 425, 433, 3, 18, 9, 0, 426, 433, 3, 20, 10, 0, 427, 433, 3, 26, 13, 0, 428, 433, 3, 42, 21, 0, 429, 433, 3, 40, 20, 0, 430, 433, 3, 30, 15, 0, 431, 433, 3, 24, 12, 0, 432, 382, 1, 0, 0, 0, 432, 387, 1, 0, 0, 0, 432, 392, 1, 0, 0, 0, 432, 397, 1, 0, 0, 0, 432, 398, 1, 0, 0, 0, 432, 399, 1, 0, 0, 0, 432, 400, 1, 0, 0, 0, 432, 401, 1, 0, 0, 0, 432, 402, 1, 0, 0, 0, 432, 403, 1, 0, 0, 0, 432, 404, 1, 0, 0, 0, 432, 409, 1, 0, 0, 0, 432, 414, 1, 0, 0, 0, 432, 419, 1, 0, 0, 0, 432, 420, 1, 0, 0, 0, 432, 421, 1, 0, 0, 0, 432, 422, 1, 0, 0, 0, 432, 423, 1, 0, 0, 0, 432, 424, 1, 0, 0, 0, 432, 425, 1, 0, 0, 0, 432, 426, 1, 0, 0, 0, 432, 427, 1, 0, 0, 0, 432, 428, 1, 0, 0, 0, 432, 429, 1, 0, 0, 0, 432, 430, 1, 0, 0, 0, 432, 431, 1, 0, 0, 0, 433, 11, 1, 0, 0, 0, 434, 435, 5, 19, 0, 0, 435, 436, 3, 32, 16, 0, 436, 13, 1, 0, 0, 0, 437, 438, 5, 20, 0, 0, 438, 439, 3, 32, 16, 0, 439, 15, 1, 0, 0, 0, 440, 441, 5, 21, 0, 0, 441, 442, 5, 22, 0, 0, 442, 443, 3, 32, 16, 0, 443, 17, 1, 0, 0, 0, 444, 445, 5, 23, 0, 0, 445, 446, 3, 34, 17, 0, 446, 19, 1, 0, 0, 0, 447, 448, 5, 24, 0, 0, 448, 449, 3, 34, 17, 0, 449, 21, 1, 0, 0, 0, 450, 451, 5, 25, 0, 0, 451, 452, 3, 98, 49, 0, 452, 453, 3, 2, 1, 0, 453, 454, 5, 17, 0, 0, 454, 455, 3, 120, 60, 0, 455, 456, 5, 18, 0, 0, 456, 23, 1, 0, 0, 0, 457, 458, 5, 26, 0, 0, 458, 25, 1, 0, 0, 0, 459, 460, 5, 27, 0, 0, 460, 474, 3, 28, 14, 0, 461, 462, 5, 27, 0, 0, 462, 463, 3, 28, 14, 0, 463, 464, 5, 28, 0, 0, 464, 465, 3, 28, 14, 0, 465, 474, 1, 0, 0, 0, 466, 467, 5, 27, 0, 0, 467, 468, 3, 28, 14, 0, 468, 469, 5, 28, 0, 0, 469, 470, 3, 28, 14, 0, 470, 471, 5, 28, 0, 0, 471, 472, 3, 28, 14, 0, 472, 474, 1, 0, 0, 0, 473, 459, 1, 0, 0, 0, 473, 461, 1, 0, 0, 0, 473, 466, 1, 0, 0, 0, 474, 27, 1, 0, 0, 0, 475, 476, 7, 2, 0, 0, 476, 29, 1, 0, 0, 0, 477, 478, 5, 29, 0, 0, 478, 482, 5, 17, 0, 0, 479, 481, 3, 116, 58, 0, 480, 479, 1, 0, 0, 0, 481, 484, 1, 0, 0, 0, 482, 480, 1, 0, 0, 0, 482, 483, 1, 0, 0, 0, 483, 485, 1, 0, 0, 0, 484, 482, 1, 0, 0, 0, 485, 486, 5, 18, 0, 0, 486, 31, 1, 0, 0, 0, 487, 488, 5, 173, 0, 0, 488, 33, 1, 0, 0, 0, 489, 490, 7, 3, 0, 0, 490, 35, 1, 0, 0, 0, 491, 507, 5, 175, 0, 0, 492, 493, 3, 32, 16, 0, 493, 494, 5, 265, 0, 0, 494, 507, 1, 0, 0, 0, 495, 507, 3, 32, 16, 0, 496, 497, 5, 188, 0, 0, 497, 498, 5, 30, 0, 0, 498, 499, 3, 32, 16, 0, 499, 500, 5, 31, 0, 0, 500, 507, 1, 0, 0, 0, 501, 502, 5, 189, 0, 0, 502, 503, 5, 30, 0, 0, 503, 504, 3, 34, 17, 0, 504, 505, 5, 31, 0, 0, 505, 507, 1, 0, 0, 0, 506, 491, 1, 0, 0, 0, 506, 492, 1, 0, 0, 0, 506, 495, 1, 0, 0, 0, 506, 496, 1, 0, 0, 0, 506, 501, 1, 0, 0, 0, 507, 37, 1, 0, 0, 0, 508, 511, 3, 32, 16, 0, 509, 511, 5, 262, 0, 0, 510, 508, 1, 0, 0, 0, 510, 509, 1, 0, 0, 0, 511, 39, 1, 0, 0, 0, 512, 513, 5, 267, 0, 0, 513, 529, 5, 289, 0, 0, 514, 515, 5, 267, 0, 0, 515, 516, 5, 289, 0, 0, 516, 529, 5, 263, 0, 0, 517, 518, 5, 268, 0, 0, 518, 529, 5, 289, 0, 0, 519, 520, 5, 269, 0, 0, 520, 529, 5, 289, 0, 0, 521, 522, 5, 270, 0, 0, 522, 529, 5, 289, 0, 0, 523, 529, 5, 271, 0, 0, 524, 529, 5, 272, 0, 0, 525, 526, 5, 273, 0, 0, 526, 529, 5, 263, 0, 0, 527, 529, 5, 32, 0, 0, 528, 512, 1, 0, 0, 0, 528, 514, 1, 0, 0, 0, 528, 517, 1, 0, 0, 0, 528, 519, 1, 0, 0, 0, 528, 521, 1, 0, 0, 0, 528, 523, 1, 0, 0, 0, 528, 524, 1, 0, 0, 0, 528, 525, 1, 0, 0, 0, 528, 527, 1, 0, 0, 0, 529, 41, 1, 0, 0, 0, 530, 531, 5, 33, 0, 0, 531, 532, 3, 138, 69, 0, 532, 533, 5, 34, 0, 0, 533, 534, 3, 2, 1, 0, 534, 556, 1, 0, 0, 0, 535, 536, 5, 33, 0, 0, 536, 537, 3, 116, 58, 0, 537, 538, 5, 34, 0, 0, 538, 539, 3, 2, 1, 0, 539, 556, 1, 0, 0, 0, 540, 541, 5, 33, 0, 0, 541, 542, 3, 176, 88, 0, 542, 543, 5, 34, 0, 0, 543, 544, 3, 2, 1, 0, 544, 556, 1, 0, 0, 0, 545, 546, 5, 33, 0, 0, 546, 547, 3, 44, 22, 0, 547, 548, 5, 34, 0, 0, 548, 549, 3, 2, 1, 0, 549, 556, 1, 0, 0, 0, 550, 551, 5, 33, 0, 0, 551, 552, 3, 46, 23, 0, 552, 553, 5, 34, 0, 0, 553, 554, 3, 2, 1, 0, 554, 556, 1, 0, 0, 0, 555, 530, 1, 0, 0, 0, 555, 535, 1, 0, 0, 0, 555, 540, 1, 0, 0, 0, 555, 545, 1, 0, 0, 0, 555, 550, 1, 0, 0, 0, 556, 43, 1, 0, 0, 0, 557, 558, 5, 35, 0, 0, 558, 579, 3, 48, 24, 0, 559, 560, 5, 35, 0, 0, 560, 561, 3, 48, 24, 0, 561, 562, 5, 36, 0, 0, 562, 563, 3, 6, 3, 0, 563, 579, 1, 0, 0, 0, 564, 565, 5, 35, 0, 0, 565, 566, 3, 48, 24, 0, 566, 567, 5, 36, 0, 0, 567, 568, 5, 17, 0, 0, 568, 569, 3, 52, 26, 0, 569, 570, 5, 18, 0, 0, 570, 579, 1, 0, 0, 0, 571, 572, 5, 35, 0, 0, 572, 573, 3, 48, 24, 0, 573, 574, 5, 36, 0, 0, 574, 575, 5, 30, 0, 0, 575, 576, 3, 292, 146, 0, 576, 577, 5, 31, 0, 0, 577, 579, 1, 0, 0, 0, 578, 557, 1, 0, 0, 0, 578, 559, 1, 0, 0, 0, 578, 564, 1, 0, 0, 0, 578, 571, 1, 0, 0, 0, 579, 45, 1, 0, 0, 0, 580, 581, 5, 35, 0, 0, 581, 582, 5, 30, 0, 0, 582, 583, 3, 50, 25, 0, 583, 584, 5, 31, 0, 0, 584, 585, 3, 48, 24, 0, 585, 615, 1, 0, 0, 0, 586, 587, 5, 35, 0, 0, 587, 588, 5, 30, 0, 0, 588, 589, 3, 50, 25, 0, 589, 590, 5, 31, 0, 0, 590, 591, 3, 48, 24, 0, 591, 592, 5, 36, 0, 0, 592, 593, 3, 6, 3, 0, 593, 615, 1, 0, 0, 0, 594, 595, 5, 35, 0, 0, 595, 596, 5, 30, 0, 0, 596, 597, 3, 50, 25, 0, 597, 598, 5, 31, 0, 0, 598, 599, 3, 48, 24, 0, 599, 600, 5, 36, 0, 0, 600, 601, 5, 17, 0, 0, 601, 602, 3, 52, 26, 0, 602, 603, 5, 18, 0, 0, 603, 615, 1, 0, 0, 0, 604, 605, 5, 35, 0, 0, 605, 606, 5, 30, 0, 0, 606, 607, 3, 50, 25, 0, 607, 608, 5, 31, 0, 0, 608, 609, 3, 48, 24, 0, 609, 610, 5, 36, 0, 0, 610, 611, 5, 30, 0, 0, 611, 612, 3, 292, 146, 0, 612, 613, 5, 31, 0, 0, 613, 615, 1, 0, 0, 0, 614, 580, 1, 0, 0, 0, 614, 586, 1, 0, 0, 0, 614, 594, 1, 0, 0, 0, 614, 604, 1, 0, 0, 0, 615, 47, 1, 0, 0, 0, 616, 617, 3, 168, 84, 0, 617, 49, 1, 0, 0, 0, 618, 621, 3, 124, 62, 0, 619, 621, 3, 176, 88, 0, 620, 618, 1, 0, 0, 0, 620, 619, 1, 0, 0, 0, 621, 51, 1, 0, 0, 0, 622, 623, 3, 54, 27, 0, 623, 624, 3, 56, 28, 0, 624, 53, 1, 0, 0, 0, 625, 628, 3, 298, 149, 0, 626, 628, 3, 40, 20, 0, 627, 625, 1, 0, 0, 0, 627, 626, 1, 0, 0, 0, 628, 631, 1, 0, 0, 0, 629, 627, 1, 0, 0, 0, 629, 630, 1, 0, 0, 0, 630, 55, 1, 0, 0, 0, 631, 629, 1, 0, 0, 0, 632, 633, 3, 58, 29, 0, 633, 634, 3, 60, 30, 0, 634, 635, 3, 2, 1, 0, 635, 636, 5, 36, 0, 0, 636, 637, 3, 298, 149, 0, 637, 640, 1, 0, 0, 0, 638, 640, 3, 40, 20, 0, 639, 632, 1, 0, 0, 0, 639, 638, 1, 0, 0, 0, 640, 643, 1, 0, 0, 0, 641, 639, 1, 0, 0, 0, 641, 642, 1, 0, 0, 0, 642, 57, 1, 0, 0, 0, 643, 641, 1, 0, 0, 0, 644, 645, 7, 4, 0, 0, 645, 59, 1, 0, 0, 0, 646, 648, 3, 62, 31, 0, 647, 649, 5, 261, 0, 0, 648, 647, 1, 0, 0, 0, 648, 649, 1, 0, 0, 0, 649, 61, 1, 0, 0, 0, 650, 660, 3, 144, 72, 0, 651, 660, 3, 2, 1, 0, 652, 660, 5, 196, 0, 0, 653, 660, 5, 197, 0, 0, 654, 655, 5, 202, 0, 0, 655, 656, 5, 39, 0, 0, 656, 660, 5, 264, 0, 0, 657, 658, 5, 202, 0, 0, 658, 660, 3, 116, 58, 0, 659, 650, 1, 0, 0, 0, 659, 651, 1, 0, 0, 0, 659, 652, 1, 0, 0, 0, 659, 653, 1, 0, 0, 0, 659, 654, 1, 0, 0, 0, 659, 657, 1, 0, 0, 0, 660, 63, 1, 0, 0, 0, 661, 662, 5, 198, 0, 0, 662, 663, 5, 40, 0, 0, 663, 668, 3, 2, 1, 0, 664, 665, 5, 198, 0, 0, 665, 668, 3, 2, 1, 0, 666, 668, 5, 198, 0, 0, 667, 661, 1, 0, 0, 0, 667, 664, 1, 0, 0, 0, 667, 666, 1, 0, 0, 0, 668, 65, 1, 0, 0, 0, 669, 670, 5, 41, 0, 0, 670, 671, 5, 42, 0, 0, 671, 672, 3, 32, 16, 0, 672, 673, 5, 43, 0, 0, 673, 674, 3, 68, 34, 0, 674, 675, 5, 44, 0, 0, 675, 676, 3, 0, 0, 0, 676, 67, 1, 0, 0, 0, 677, 690, 6, 34, -1, 0, 678, 679, 10, 5, 0, 0, 679, 689, 5, 186, 0, 0, 680, 681, 10, 4, 0, 0, 681, 689, 5, 187, 0, 0, 682, 683, 10, 3, 0, 0, 683, 689, 5, 45, 0, 0, 684, 685, 10, 2, 0, 0, 685, 689, 5, 46, 0, 0, 686, 687, 10, 1, 0, 0, 687, 689, 5, 47, 0, 0, 688, 678, 1, 0, 0, 0, 688, 680, 1, 0, 0, 0, 688, 682, 1, 0, 0, 0, 688, 684, 1, 0, 0, 0, 688, 686, 1, 0, 0, 0, 689, 692, 1, 0, 0, 0, 690, 688, 1, 0, 0, 0, 690, 691, 1, 0, 0, 0, 691, 69, 1, 0, 0, 0, 692, 690, 1, 0, 0, 0, 693, 694, 5, 48, 0, 0, 694, 695, 5, 36, 0, 0, 695, 696, 5, 30, 0, 0, 696, 697, 3, 292, 146, 0, 697, 698, 5, 31, 0, 0, 698, 71, 1, 0, 0, 0, 699, 700, 5, 49, 0, 0, 700, 701, 3, 2, 1, 0, 701, 73, 1, 0, 0, 0, 702, 706, 5, 50, 0, 0, 703, 705, 3, 76, 38, 0, 704, 703, 1, 0, 0, 0, 705, 708, 1, 0, 0, 0, 706, 704, 1, 0, 0, 0, 706, 707, 1, 0, 0, 0, 707, 709, 1, 0, 0, 0, 708, 706, 1, 0, 0, 0, 709, 710, 3, 2, 1, 0, 710, 711, 3, 182, 91, 0, 711, 712, 3, 78, 39, 0, 712, 713, 3, 80, 40, 0, 713, 75, 1, 0, 0, 0, 714, 752, 5, 51, 0, 0, 715, 752, 5, 52, 0, 0, 716, 752, 5, 199, 0, 0, 717, 752, 5, 202, 0, 0, 718, 752, 5, 221, 0, 0, 719, 752, 5, 53, 0, 0, 720, 752, 5, 54, 0, 0, 721, 752, 5, 55, 0, 0, 722, 752, 5, 56, 0, 0, 723, 752, 5, 244, 0, 0, 724, 752, 5, 15, 0, 0, 725, 752, 5, 224, 0, 0, 726, 752, 5, 57, 0, 0, 727, 752, 5, 58, 0, 0, 728, 752, 5, 59, 0, 0, 729, 752, 5, 60, 0, 0, 730, 752, 5, 61, 0, 0, 731, 732, 5, 62, 0, 0, 732, 752, 5, 51, 0, 0, 733, 734, 5, 62, 0, 0, 734, 752, 5, 52, 0, 0, 735, 736, 5, 62, 0, 0, 736, 752, 5, 63, 0, 0, 737, 738, 5, 62, 0, 0, 738, 752, 5, 64, 0, 0, 739, 740, 5, 62, 0, 0, 740, 752, 5, 65, 0, 0, 741, 742, 5, 62, 0, 0, 742, 752, 5, 66, 0, 0, 743, 752, 5, 67, 0, 0, 744, 752, 5, 68, 0, 0, 745, 752, 5, 69, 0, 0, 746, 747, 5, 70, 0, 0, 747, 748, 5, 30, 0, 0, 748, 749, 3, 32, 16, 0, 749, 750, 5, 31, 0, 0, 750, 752, 1, 0, 0, 0, 751, 714, 1, 0, 0, 0, 751, 715, 1, 0, 0, 0, 751, 716, 1, 0, 0, 0, 751, 717, 1, 0, 0, 0, 751, 718, 1, 0, 0, 0, 751, 719, 1, 0, 0, 0, 751, 720, 1, 0, 0, 0, 751, 721, 1, 0, 0, 0, 751, 722, 1, 0, 0, 0, 751, 723, 1, 0, 0, 0, 751, 724, 1, 0, 0, 0, 751, 725, 1, 0, 0, 0, 751, 726, 1, 0, 0, 0, 751, 727, 1, 0, 0, 0, 751, 728, 1, 0, 0, 0, 751, 729, 1, 0, 0, 0, 751, 730, 1, 0, 0, 0, 751, 731, 1, 0, 0, 0, 751, 733, 1, 0, 0, 0, 751, 735, 1, 0, 0, 0, 751, 737, 1, 0, 0, 0, 751, 739, 1, 0, 0, 0, 751, 741, 1, 0, 0, 0, 751, 743, 1, 0, 0, 0, 751, 744, 1, 0, 0, 0, 751, 745, 1, 0, 0, 0, 751, 746, 1, 0, 0, 0, 752, 77, 1, 0, 0, 0, 753, 757, 1, 0, 0, 0, 754, 755, 5, 71, 0, 0, 755, 757, 3, 124, 62, 0, 756, 753, 1, 0, 0, 0, 756, 754, 1, 0, 0, 0, 757, 79, 1, 0, 0, 0, 758, 762, 1, 0, 0, 0, 759, 760, 5, 72, 0, 0, 760, 762, 3, 84, 42, 0, 761, 758, 1, 0, 0, 0, 761, 759, 1, 0, 0, 0, 762, 81, 1, 0, 0, 0, 763, 765, 3, 198, 99, 0, 764, 763, 1, 0, 0, 0, 765, 768, 1, 0, 0, 0, 766, 764, 1, 0, 0, 0, 766, 767, 1, 0, 0, 0, 767, 83, 1, 0, 0, 0, 768, 766, 1, 0, 0, 0, 769, 770, 3, 124, 62, 0, 770, 771, 5, 28, 0, 0, 771, 773, 1, 0, 0, 0, 772, 769, 1, 0, 0, 0, 773, 776, 1, 0, 0, 0, 774, 772, 1, 0, 0, 0, 774, 775, 1, 0, 0, 0, 775, 777, 1, 0, 0, 0, 776, 774, 1, 0, 0, 0, 777, 778, 3, 124, 62, 0, 778, 85, 1, 0, 0, 0, 779, 780, 7, 5, 0, 0, 780, 87, 1, 0, 0, 0, 781, 782, 3, 86, 43, 0, 782, 783, 3, 32, 16, 0, 783, 784, 5, 264, 0, 0, 784, 885, 1, 0, 0, 0, 785, 786, 3, 86, 43, 0, 786, 787, 3, 32, 16, 0, 787, 885, 1, 0, 0, 0, 788, 789, 3, 86, 43, 0, 789, 790, 3, 32, 16, 0, 790, 791, 5, 75, 0, 0, 791, 792, 3, 32, 16, 0, 792, 793, 5, 264, 0, 0, 793, 885, 1, 0, 0, 0, 794, 795, 3, 86, 43, 0, 795, 796, 3, 32, 16, 0, 796, 797, 5, 75, 0, 0, 797, 798, 3, 32, 16, 0, 798, 885, 1, 0, 0, 0, 799, 800, 3, 86, 43, 0, 800, 801, 3, 32, 16, 0, 801, 802, 5, 75, 0, 0, 802, 803, 3, 32, 16, 0, 803, 804, 5, 28, 0, 0, 804, 805, 3, 32, 16, 0, 805, 806, 5, 264, 0, 0, 806, 885, 1, 0, 0, 0, 807, 808, 3, 86, 43, 0, 808, 809, 3, 32, 16, 0, 809, 810, 5, 75, 0, 0, 810, 811, 3, 32, 16, 0, 811, 812, 5, 28, 0, 0, 812, 813, 3, 32, 16, 0, 813, 885, 1, 0, 0, 0, 814, 815, 3, 86, 43, 0, 815, 816, 3, 32, 16, 0, 816, 817, 5, 28, 0, 0, 817, 818, 3, 32, 16, 0, 818, 819, 5, 75, 0, 0, 819, 820, 3, 32, 16, 0, 820, 821, 5, 264, 0, 0, 821, 885, 1, 0, 0, 0, 822, 823, 3, 86, 43, 0, 823, 824, 3, 32, 16, 0, 824, 825, 5, 28, 0, 0, 825, 826, 3, 32, 16, 0, 826, 827, 5, 75, 0, 0, 827, 828, 3, 32, 16, 0, 828, 885, 1, 0, 0, 0, 829, 830, 3, 86, 43, 0, 830, 831, 3, 32, 16, 0, 831, 832, 5, 28, 0, 0, 832, 833, 3, 32, 16, 0, 833, 834, 5, 75, 0, 0, 834, 835, 3, 32, 16, 0, 835, 836, 5, 28, 0, 0, 836, 837, 3, 32, 16, 0, 837, 838, 5, 264, 0, 0, 838, 885, 1, 0, 0, 0, 839, 840, 3, 86, 43, 0, 840, 841, 3, 32, 16, 0, 841, 842, 5, 28, 0, 0, 842, 843, 3, 32, 16, 0, 843, 844, 5, 75, 0, 0, 844, 845, 3, 32, 16, 0, 845, 846, 5, 28, 0, 0, 846, 847, 3, 32, 16, 0, 847, 885, 1, 0, 0, 0, 848, 849, 3, 86, 43, 0, 849, 850, 3, 32, 16, 0, 850, 851, 5, 263, 0, 0, 851, 885, 1, 0, 0, 0, 852, 853, 3, 86, 43, 0, 853, 854, 3, 32, 16, 0, 854, 855, 5, 75, 0, 0, 855, 856, 3, 32, 16, 0, 856, 857, 5, 263, 0, 0, 857, 885, 1, 0, 0, 0, 858, 859, 3, 86, 43, 0, 859, 860, 3, 32, 16, 0, 860, 861, 5, 75, 0, 0, 861, 862, 3, 32, 16, 0, 862, 863, 5, 28, 0, 0, 863, 864, 3, 32, 16, 0, 864, 865, 5, 263, 0, 0, 865, 885, 1, 0, 0, 0, 866, 867, 3, 86, 43, 0, 867, 868, 3, 32, 16, 0, 868, 869, 5, 28, 0, 0, 869, 870, 3, 32, 16, 0, 870, 871, 5, 75, 0, 0, 871, 872, 3, 32, 16, 0, 872, 873, 5, 263, 0, 0, 873, 885, 1, 0, 0, 0, 874, 875, 3, 86, 43, 0, 875, 876, 3, 32, 16, 0, 876, 877, 5, 28, 0, 0, 877, 878, 3, 32, 16, 0, 878, 879, 5, 75, 0, 0, 879, 880, 3, 32, 16, 0, 880, 881, 5, 28, 0, 0, 881, 882, 3, 32, 16, 0, 882, 883, 5, 263, 0, 0, 883, 885, 1, 0, 0, 0, 884, 781, 1, 0, 0, 0, 884, 785, 1, 0, 0, 0, 884, 788, 1, 0, 0, 0, 884, 794, 1, 0, 0, 0, 884, 799, 1, 0, 0, 0, 884, 807, 1, 0, 0, 0, 884, 814, 1, 0, 0, 0, 884, 822, 1, 0, 0, 0, 884, 829, 1, 0, 0, 0, 884, 839, 1, 0, 0, 0, 884, 848, 1, 0, 0, 0, 884, 852, 1, 0, 0, 0, 884, 858, 1, 0, 0, 0, 884, 866, 1, 0, 0, 0, 884, 874, 1, 0, 0, 0, 885, 89, 1, 0, 0, 0, 886, 890, 5, 21, 0, 0, 887, 889, 3, 92, 46, 0, 888, 887, 1, 0, 0, 0, 889, 892, 1, 0, 0, 0, 890, 888, 1, 0, 0, 0, 890, 891, 1, 0, 0, 0, 891, 893, 1, 0, 0, 0, 892, 890, 1, 0, 0, 0, 893, 894, 3, 2, 1, 0, 894, 895, 3, 94, 47, 0, 895, 896, 5, 180, 0, 0, 896, 897, 5, 36, 0, 0, 897, 898, 5, 30, 0, 0, 898, 899, 3, 292, 146, 0, 899, 900, 5, 31, 0, 0, 900, 901, 3, 94, 47, 0, 901, 913, 1, 0, 0, 0, 902, 906, 5, 21, 0, 0, 903, 905, 3, 92, 46, 0, 904, 903, 1, 0, 0, 0, 905, 908, 1, 0, 0, 0, 906, 904, 1, 0, 0, 0, 906, 907, 1, 0, 0, 0, 907, 909, 1, 0, 0, 0, 908, 906, 1, 0, 0, 0, 909, 910, 3, 2, 1, 0, 910, 911, 3, 94, 47, 0, 911, 913, 1, 0, 0, 0, 912, 886, 1, 0, 0, 0, 912, 902, 1, 0, 0, 0, 913, 91, 1, 0, 0, 0, 914, 915, 5, 76, 0, 0, 915, 93, 1, 0, 0, 0, 916, 919, 1, 0, 0, 0, 917, 919, 5, 298, 0, 0, 918, 916, 1, 0, 0, 0, 918, 917, 1, 0, 0, 0, 919, 95, 1, 0, 0, 0, 920, 921, 7, 6, 0, 0, 921, 97, 1, 0, 0, 0, 922, 924, 3, 96, 48, 0, 923, 922, 1, 0, 0, 0, 924, 927, 1, 0, 0, 0, 925, 923, 1, 0, 0, 0, 925, 926, 1, 0, 0, 0, 926, 99, 1, 0, 0, 0, 927, 925, 1, 0, 0, 0, 928, 931, 3, 102, 51, 0, 929, 931, 3, 104, 52, 0, 930, 928, 1, 0, 0, 0, 930, 929, 1, 0, 0, 0, 931, 101, 1, 0, 0, 0, 932, 933, 5, 275, 0, 0, 933, 983, 6, 51, -1, 0, 934, 935, 5, 276, 0, 0, 935, 936, 3, 32, 16, 0, 936, 937, 6, 51, -1, 0, 937, 983, 1, 0, 0, 0, 938, 939, 5, 276, 0, 0, 939, 940, 3, 0, 0, 0, 940, 941, 6, 51, -1, 0, 941, 983, 1, 0, 0, 0, 942, 943, 5, 277, 0, 0, 943, 944, 3, 32, 16, 0, 944, 945, 6, 51, -1, 0, 945, 983, 1, 0, 0, 0, 946, 947, 5, 278, 0, 0, 947, 948, 3, 34, 17, 0, 948, 949, 6, 51, -1, 0, 949, 983, 1, 0, 0, 0, 950, 951, 5, 279, 0, 0, 951, 952, 5, 30, 0, 0, 952, 953, 3, 292, 146, 0, 953, 954, 5, 31, 0, 0, 954, 955, 6, 51, -1, 0, 955, 983, 1, 0, 0, 0, 956, 957, 5, 279, 0, 0, 957, 958, 5, 84, 0, 0, 958, 959, 5, 30, 0, 0, 959, 960, 3, 292, 146, 0, 960, 961, 5, 31, 0, 0, 961, 962, 6, 51, -1, 0, 962, 983, 1, 0, 0, 0, 963, 964, 5, 282, 0, 0, 964, 965, 3, 32, 16, 0, 965, 966, 6, 51, -1, 0, 966, 983, 1, 0, 0, 0, 967, 968, 5, 282, 0, 0, 968, 969, 3, 0, 0, 0, 969, 970, 6, 51, -1, 0, 970, 983, 1, 0, 0, 0, 971, 972, 5, 285, 0, 0, 972, 973, 5, 84, 0, 0, 973, 974, 5, 30, 0, 0, 974, 975, 3, 292, 146, 0, 975, 976, 5, 31, 0, 0, 976, 977, 6, 51, -1, 0, 977, 983, 1, 0, 0, 0, 978, 979, 5, 287, 0, 0, 979, 980, 3, 32, 16, 0, 980, 981, 6, 51, -1, 0, 981, 983, 1, 0, 0, 0, 982, 932, 1, 0, 0, 0, 982, 934, 1, 0, 0, 0, 982, 938, 1, 0, 0, 0, 982, 942, 1, 0, 0, 0, 982, 946, 1, 0, 0, 0, 982, 950, 1, 0, 0, 0, 982, 956, 1, 0, 0, 0, 982, 963, 1, 0, 0, 0, 982, 967, 1, 0, 0, 0, 982, 971, 1, 0, 0, 0, 982, 978, 1, 0, 0, 0, 983, 103, 1, 0, 0, 0, 984, 985, 5, 279, 0, 0, 985, 1019, 3, 36, 18, 0, 986, 987, 5, 279, 0, 0, 987, 1019, 3, 34, 17, 0, 988, 989, 5, 280, 0, 0, 989, 1019, 3, 168, 84, 0, 990, 991, 5, 286, 0, 0, 991, 1019, 3, 178, 89, 0, 992, 993, 5, 286, 0, 0, 993, 1019, 3, 174, 87, 0, 994, 995, 5, 284, 0, 0, 995, 1019, 3, 124, 62, 0, 996, 997, 5, 285, 0, 0, 997, 1019, 3, 6, 3, 0, 998, 999, 5, 285, 0, 0, 999, 1000, 5, 224, 0, 0, 1000, 1001, 5, 30, 0, 0, 1001, 1002, 3, 6, 3, 0, 1002, 1003, 5, 31, 0, 0, 1003, 1019, 1, 0, 0, 0, 1004, 1005, 5, 281, 0, 0, 1005, 1006, 3, 170, 85, 0, 1006, 1007, 3, 138, 69, 0, 1007, 1008, 3, 112, 56, 0, 1008, 1019, 1, 0, 0, 0, 1009, 1010, 5, 287, 0, 0, 1010, 1019, 3, 50, 25, 0, 1011, 1012, 5, 283, 0, 0, 1012, 1013, 5, 30, 0, 0, 1013, 1014, 3, 106, 53, 0, 1014, 1015, 5, 31, 0, 0, 1015, 1019, 1, 0, 0, 0, 1016, 1017, 5, 283, 0, 0, 1017, 1019, 5, 85, 0, 0, 1018, 984, 1, 0, 0, 0, 1018, 986, 1, 0, 0, 0, 1018, 988, 1, 0, 0, 0, 1018, 990, 1, 0, 0, 0, 1018, 992, 1, 0, 0, 0, 1018, 994, 1, 0, 0, 0, 1018, 996, 1, 0, 0, 0, 1018, 998, 1, 0, 0, 0, 1018, 1004, 1, 0, 0, 0, 1018, 1009, 1, 0, 0, 0, 1018, 1011, 1, 0, 0, 0, 1018, 1016, 1, 0, 0, 0, 1019, 105, 1, 0, 0, 0, 1020, 1037, 1, 0, 0, 0, 1021, 1024, 3, 0, 0, 0, 1022, 1024, 3, 32, 16, 0, 1023, 1021, 1, 0, 0, 0, 1023, 1022, 1, 0, 0, 0, 1024, 1025, 1, 0, 0, 0, 1025, 1026, 5, 28, 0, 0, 1026, 1028, 1, 0, 0, 0, 1027, 1023, 1, 0, 0, 0, 1028, 1031, 1, 0, 0, 0, 1029, 1027, 1, 0, 0, 0, 1029, 1030, 1, 0, 0, 0, 1030, 1034, 1, 0, 0, 0, 1031, 1029, 1, 0, 0, 0, 1032, 1035, 3, 0, 0, 0, 1033, 1035, 3, 32, 16, 0, 1034, 1032, 1, 0, 0, 0, 1034, 1033, 1, 0, 0, 0, 1035, 1037, 1, 0, 0, 0, 1036, 1020, 1, 0, 0, 0, 1036, 1029, 1, 0, 0, 0, 1037, 107, 1, 0, 0, 0, 1038, 1044, 5, 86, 0, 0, 1039, 1040, 3, 138, 69, 0, 1040, 1041, 5, 28, 0, 0, 1041, 1043, 1, 0, 0, 0, 1042, 1039, 1, 0, 0, 0, 1043, 1046, 1, 0, 0, 0, 1044, 1042, 1, 0, 0, 0, 1044, 1045, 1, 0, 0, 0, 1045, 1047, 1, 0, 0, 0, 1046, 1044, 1, 0, 0, 0, 1047, 1048, 3, 138, 69, 0, 1048, 1049, 5, 87, 0, 0, 1049, 109, 1, 0, 0, 0, 1050, 1056, 5, 42, 0, 0, 1051, 1052, 3, 146, 73, 0, 1052, 1053, 5, 28, 0, 0, 1053, 1055, 1, 0, 0, 0, 1054, 1051, 1, 0, 0, 0, 1055, 1058, 1, 0, 0, 0, 1056, 1054, 1, 0, 0, 0, 1056, 1057, 1, 0, 0, 0, 1057, 1059, 1, 0, 0, 0, 1058, 1056, 1, 0, 0, 0, 1059, 1060, 3, 146, 73, 0, 1060, 1061, 5, 43, 0, 0, 1061, 111, 1, 0, 0, 0, 1062, 1068, 5, 30, 0, 0, 1063, 1064, 3, 114, 57, 0, 1064, 1065, 5, 28, 0, 0, 1065, 1067, 1, 0, 0, 0, 1066, 1063, 1, 0, 0, 0, 1067, 1070, 1, 0, 0, 0, 1068, 1066, 1, 0, 0, 0, 1068, 1069, 1, 0, 0, 0, 1069, 1071, 1, 0, 0, 0, 1070, 1068, 1, 0, 0, 0, 1071, 1072, 3, 114, 57, 0, 1072, 1073, 5, 31, 0, 0, 1073, 1076, 1, 0, 0, 0, 1074, 1076, 5, 85, 0, 0, 1075, 1062, 1, 0, 0, 0, 1075, 1074, 1, 0, 0, 0, 1076, 113, 1, 0, 0, 0, 1077, 1085, 5, 177, 0, 0, 1078, 1079, 3, 230, 115, 0, 1079, 1080, 3, 138, 69, 0, 1080, 1082, 3, 226, 113, 0, 1081, 1083, 3, 0, 0, 0, 1082, 1081, 1, 0, 0, 0, 1082, 1083, 1, 0, 0, 0, 1083, 1085, 1, 0, 0, 0, 1084, 1077, 1, 0, 0, 0, 1084, 1078, 1, 0, 0, 0, 1085, 115, 1, 0, 0, 0, 1086, 1087, 5, 42, 0, 0, 1087, 1088, 3, 2, 1, 0, 1088, 1089, 5, 43, 0, 0, 1089, 1090, 3, 118, 59, 0, 1090, 1112, 1, 0, 0, 0, 1091, 1092, 5, 42, 0, 0, 1092, 1093, 3, 174, 87, 0, 1093, 1094, 5, 43, 0, 0, 1094, 1095, 3, 118, 59, 0, 1095, 1112, 1, 0, 0, 0, 1096, 1097, 5, 42, 0, 0, 1097, 1098, 5, 262, 0, 0, 1098, 1099, 5, 43, 0, 0, 1099, 1112, 3, 118, 59, 0, 1100, 1101, 5, 42, 0, 0, 1101, 1102, 5, 198, 0, 0, 1102, 1103, 3, 2, 1, 0, 1103, 1104, 5, 43, 0, 0, 1104, 1105, 3, 118, 59, 0, 1105, 1112, 1, 0, 0, 0, 1106, 1112, 3, 118, 59, 0, 1107, 1112, 3, 174, 87, 0, 1108, 1112, 5, 257, 0, 0, 1109, 1112, 5, 258, 0, 0, 1110, 1112, 5, 259, 0, 0, 1111, 1086, 1, 0, 0, 0, 1111, 1091, 1, 0, 0, 0, 1111, 1096, 1, 0, 0, 0, 1111, 1100, 1, 0, 0, 0, 1111, 1106, 1, 0, 0, 0, 1111, 1107, 1, 0, 0, 0, 1111, 1108, 1, 0, 0, 0, 1111, 1109, 1, 0, 0, 0, 1111, 1110, 1, 0, 0, 0, 1112, 117, 1, 0, 0, 0, 1113, 1114, 3, 2, 1, 0, 1114, 1115, 5, 88, 0, 0, 1115, 1117, 1, 0, 0, 0, 1116, 1113, 1, 0, 0, 0, 1117, 1120, 1, 0, 0, 0, 1118, 1116, 1, 0, 0, 0, 1118, 1119, 1, 0, 0, 0, 1119, 1121, 1, 0, 0, 0, 1120, 1118, 1, 0, 0, 0, 1121, 1122, 3, 2, 1, 0, 1122, 119, 1, 0, 0, 0, 1123, 1125, 3, 122, 61, 0, 1124, 1123, 1, 0, 0, 0, 1125, 1128, 1, 0, 0, 0, 1126, 1124, 1, 0, 0, 0, 1126, 1127, 1, 0, 0, 0, 1127, 121, 1, 0, 0, 0, 1128, 1126, 1, 0, 0, 0, 1129, 1130, 5, 180, 0, 0, 1130, 1131, 5, 89, 0, 0, 1131, 1135, 3, 32, 16, 0, 1132, 1135, 3, 152, 76, 0, 1133, 1135, 3, 324, 162, 0, 1134, 1129, 1, 0, 0, 0, 1134, 1132, 1, 0, 0, 0, 1134, 1133, 1, 0, 0, 0, 1135, 123, 1, 0, 0, 0, 1136, 1148, 3, 116, 58, 0, 1137, 1138, 5, 42, 0, 0, 1138, 1139, 3, 2, 1, 0, 1139, 1140, 5, 43, 0, 0, 1140, 1148, 1, 0, 0, 0, 1141, 1142, 5, 42, 0, 0, 1142, 1143, 5, 198, 0, 0, 1143, 1144, 3, 2, 1, 0, 1144, 1145, 5, 43, 0, 0, 1145, 1148, 1, 0, 0, 0, 1146, 1148, 3, 138, 69, 0, 1147, 1136, 1, 0, 0, 0, 1147, 1137, 1, 0, 0, 0, 1147, 1141, 1, 0, 0, 0, 1147, 1146, 1, 0, 0, 0, 1148, 125, 1, 0, 0, 0, 1149, 1158, 1, 0, 0, 0, 1150, 1154, 3, 130, 65, 0, 1151, 1153, 3, 128, 64, 0, 1152, 1151, 1, 0, 0, 0, 1153, 1156, 1, 0, 0, 0, 1154, 1152, 1, 0, 0, 0, 1154, 1155, 1, 0, 0, 0, 1155, 1158, 1, 0, 0, 0, 1156, 1154, 1, 0, 0, 0, 1157, 1149, 1, 0, 0, 0, 1157, 1150, 1, 0, 0, 0, 1158, 127, 1, 0, 0, 0, 1159, 1177, 5, 262, 0, 0, 1160, 1177, 5, 261, 0, 0, 1161, 1162, 5, 42, 0, 0, 1162, 1163, 3, 32, 16, 0, 1163, 1164, 5, 43, 0, 0, 1164, 1177, 1, 0, 0, 0, 1165, 1166, 5, 42, 0, 0, 1166, 1167, 3, 32, 16, 0, 1167, 1168, 5, 266, 0, 0, 1168, 1169, 3, 32, 16, 0, 1169, 1170, 5, 43, 0, 0, 1170, 1177, 1, 0, 0, 0, 1171, 1172, 5, 42, 0, 0, 1172, 1173, 5, 266, 0, 0, 1173, 1174, 3, 32, 16, 0, 1174, 1175, 5, 43, 0, 0, 1175, 1177, 1, 0, 0, 0, 1176, 1159, 1, 0, 0, 0, 1176, 1160, 1, 0, 0, 0, 1176, 1161, 1, 0, 0, 0, 1176, 1165, 1, 0, 0, 0, 1176, 1171, 1, 0, 0, 0, 1177, 129, 1, 0, 0, 0, 1178, 1271, 1, 0, 0, 0, 1179, 1180, 5, 203, 0, 0, 1180, 1181, 5, 30, 0, 0, 1181, 1182, 3, 6, 3, 0, 1182, 1183, 5, 28, 0, 0, 1183, 1184, 3, 6, 3, 0, 1184, 1185, 5, 28, 0, 0, 1185, 1186, 3, 6, 3, 0, 1186, 1187, 5, 28, 0, 0, 1187, 1188, 3, 6, 3, 0, 1188, 1189, 5, 31, 0, 0, 1189, 1271, 1, 0, 0, 0, 1190, 1191, 5, 203, 0, 0, 1191, 1192, 5, 30, 0, 0, 1192, 1193, 3, 6, 3, 0, 1193, 1194, 5, 28, 0, 0, 1194, 1195, 3, 6, 3, 0, 1195, 1196, 5, 31, 0, 0, 1196, 1271, 1, 0, 0, 0, 1197, 1198, 5, 204, 0, 0, 1198, 1199, 5, 205, 0, 0, 1199, 1200, 5, 42, 0, 0, 1200, 1201, 3, 32, 16, 0, 1201, 1202, 5, 43, 0, 0, 1202, 1271, 1, 0, 0, 0, 1203, 1204, 5, 204, 0, 0, 1204, 1205, 5, 206, 0, 0, 1205, 1206, 5, 42, 0, 0, 1206, 1207, 3, 32, 16, 0, 1207, 1208, 5, 43, 0, 0, 1208, 1209, 3, 126, 63, 0, 1209, 1271, 1, 0, 0, 0, 1210, 1271, 5, 207, 0, 0, 1211, 1271, 5, 208, 0, 0, 1212, 1271, 5, 209, 0, 0, 1213, 1271, 5, 201, 0, 0, 1214, 1271, 5, 183, 0, 0, 1215, 1271, 5, 184, 0, 0, 1216, 1271, 5, 185, 0, 0, 1217, 1271, 5, 186, 0, 0, 1218, 1271, 5, 187, 0, 0, 1219, 1271, 5, 188, 0, 0, 1220, 1271, 5, 189, 0, 0, 1221, 1271, 5, 210, 0, 0, 1222, 1271, 5, 190, 0, 0, 1223, 1271, 5, 191, 0, 0, 1224, 1271, 5, 192, 0, 0, 1225, 1271, 5, 193, 0, 0, 1226, 1271, 5, 211, 0, 0, 1227, 1271, 5, 212, 0, 0, 1228, 1271, 5, 213, 0, 0, 1229, 1271, 5, 214, 0, 0, 1230, 1271, 5, 215, 0, 0, 1231, 1271, 5, 216, 0, 0, 1232, 1271, 5, 217, 0, 0, 1233, 1234, 5, 218, 0, 0, 1234, 1271, 3, 132, 66, 0, 1235, 1236, 5, 219, 0, 0, 1236, 1271, 3, 132, 66, 0, 1237, 1271, 5, 220, 0, 0, 1238, 1239, 5, 221, 0, 0, 1239, 1271, 3, 132, 66, 0, 1240, 1241, 5, 222, 0, 0, 1241, 1271, 3, 134, 67, 0, 1242, 1243, 5, 222, 0, 0, 1243, 1244, 3, 134, 67, 0, 1244, 1245, 5, 28, 0, 0, 1245, 1246, 3, 6, 3, 0, 1246, 1271, 1, 0, 0, 0, 1247, 1271, 5, 194, 0, 0, 1248, 1271, 5, 195, 0, 0, 1249, 1250, 5, 90, 0, 0, 1250, 1271, 5, 184, 0, 0, 1251, 1252, 5, 90, 0, 0, 1252, 1271, 5, 185, 0, 0, 1253, 1254, 5, 90, 0, 0, 1254, 1271, 5, 186, 0, 0, 1255, 1256, 5, 90, 0, 0, 1256, 1271, 5, 187, 0, 0, 1257, 1258, 5, 62, 0, 0, 1258, 1271, 5, 220, 0, 0, 1259, 1271, 5, 223, 0, 0, 1260, 1261, 5, 224, 0, 0, 1261, 1271, 5, 213, 0, 0, 1262, 1271, 5, 225, 0, 0, 1263, 1264, 5, 207, 0, 0, 1264, 1271, 5, 183, 0, 0, 1265, 1271, 5, 226, 0, 0, 1266, 1271, 5, 228, 0, 0, 1267, 1268, 5, 34, 0, 0, 1268, 1271, 5, 227, 0, 0, 1269, 1271, 3, 2, 1, 0, 1270, 1178, 1, 0, 0, 0, 1270, 1179, 1, 0, 0, 0, 1270, 1190, 1, 0, 0, 0, 1270, 1197, 1, 0, 0, 0, 1270, 1203, 1, 0, 0, 0, 1270, 1210, 1, 0, 0, 0, 1270, 1211, 1, 0, 0, 0, 1270, 1212, 1, 0, 0, 0, 1270, 1213, 1, 0, 0, 0, 1270, 1214, 1, 0, 0, 0, 1270, 1215, 1, 0, 0, 0, 1270, 1216, 1, 0, 0, 0, 1270, 1217, 1, 0, 0, 0, 1270, 1218, 1, 0, 0, 0, 1270, 1219, 1, 0, 0, 0, 1270, 1220, 1, 0, 0, 0, 1270, 1221, 1, 0, 0, 0, 1270, 1222, 1, 0, 0, 0, 1270, 1223, 1, 0, 0, 0, 1270, 1224, 1, 0, 0, 0, 1270, 1225, 1, 0, 0, 0, 1270, 1226, 1, 0, 0, 0, 1270, 1227, 1, 0, 0, 0, 1270, 1228, 1, 0, 0, 0, 1270, 1229, 1, 0, 0, 0, 1270, 1230, 1, 0, 0, 0, 1270, 1231, 1, 0, 0, 0, 1270, 1232, 1, 0, 0, 0, 1270, 1233, 1, 0, 0, 0, 1270, 1235, 1, 0, 0, 0, 1270, 1237, 1, 0, 0, 0, 1270, 1238, 1, 0, 0, 0, 1270, 1240, 1, 0, 0, 0, 1270, 1242, 1, 0, 0, 0, 1270, 1247, 1, 0, 0, 0, 1270, 1248, 1, 0, 0, 0, 1270, 1249, 1, 0, 0, 0, 1270, 1251, 1, 0, 0, 0, 1270, 1253, 1, 0, 0, 0, 1270, 1255, 1, 0, 0, 0, 1270, 1257, 1, 0, 0, 0, 1270, 1259, 1, 0, 0, 0, 1270, 1260, 1, 0, 0, 0, 1270, 1262, 1, 0, 0, 0, 1270, 1263, 1, 0, 0, 0, 1270, 1265, 1, 0, 0, 0, 1270, 1266, 1, 0, 0, 0, 1270, 1267, 1, 0, 0, 0, 1270, 1269, 1, 0, 0, 0, 1271, 131, 1, 0, 0, 0, 1272, 1280, 1, 0, 0, 0, 1273, 1274, 5, 30, 0, 0, 1274, 1275, 5, 91, 0, 0, 1275, 1276, 5, 36, 0, 0, 1276, 1277, 3, 32, 16, 0, 1277, 1278, 5, 31, 0, 0, 1278, 1280, 1, 0, 0, 0, 1279, 1272, 1, 0, 0, 0, 1279, 1273, 1, 0, 0, 0, 1280, 133, 1, 0, 0, 0, 1281, 1290, 1, 0, 0, 0, 1282, 1286, 3, 136, 68, 0, 1283, 1285, 7, 7, 0, 0, 1284, 1283, 1, 0, 0, 0, 1285, 1288, 1, 0, 0, 0, 1286, 1284, 1, 0, 0, 0, 1286, 1287, 1, 0, 0, 0, 1287, 1290, 1, 0, 0, 0, 1288, 1286, 1, 0, 0, 0, 1289, 1281, 1, 0, 0, 0, 1289, 1282, 1, 0, 0, 0, 1290, 135, 1, 0, 0, 0, 1291, 1292, 7, 8, 0, 0, 1292, 137, 1, 0, 0, 0, 1293, 1297, 3, 142, 71, 0, 1294, 1296, 3, 140, 70, 0, 1295, 1294, 1, 0, 0, 0, 1296, 1299, 1, 0, 0, 0, 1297, 1295, 1, 0, 0, 0, 1297, 1298, 1, 0, 0, 0, 1298, 139, 1, 0, 0, 0, 1299, 1297, 1, 0, 0, 0, 1300, 1319, 5, 261, 0, 0, 1301, 1302, 5, 42, 0, 0, 1302, 1319, 5, 43, 0, 0, 1303, 1319, 3, 110, 55, 0, 1304, 1319, 5, 260, 0, 0, 1305, 1319, 5, 262, 0, 0, 1306, 1319, 5, 92, 0, 0, 1307, 1308, 5, 93, 0, 0, 1308, 1309, 5, 30, 0, 0, 1309, 1310, 3, 124, 62, 0, 1310, 1311, 5, 31, 0, 0, 1311, 1319, 1, 0, 0, 0, 1312, 1313, 5, 94, 0, 0, 1313, 1314, 5, 30, 0, 0, 1314, 1315, 3, 124, 62, 0, 1315, 1316, 5, 31, 0, 0, 1316, 1319, 1, 0, 0, 0, 1317, 1319, 3, 108, 54, 0, 1318, 1300, 1, 0, 0, 0, 1318, 1301, 1, 0, 0, 0, 1318, 1303, 1, 0, 0, 0, 1318, 1304, 1, 0, 0, 0, 1318, 1305, 1, 0, 0, 0, 1318, 1306, 1, 0, 0, 0, 1318, 1307, 1, 0, 0, 0, 1318, 1312, 1, 0, 0, 0, 1318, 1317, 1, 0, 0, 0, 1319, 141, 1, 0, 0, 0, 1320, 1321, 5, 39, 0, 0, 1321, 1351, 3, 116, 58, 0, 1322, 1351, 5, 197, 0, 0, 1323, 1324, 5, 199, 0, 0, 1324, 1325, 5, 39, 0, 0, 1325, 1351, 3, 116, 58, 0, 1326, 1327, 5, 200, 0, 0, 1327, 1351, 3, 116, 58, 0, 1328, 1329, 5, 226, 0, 0, 1329, 1330, 3, 170, 85, 0, 1330, 1331, 3, 138, 69, 0, 1331, 1332, 5, 262, 0, 0, 1332, 1333, 3, 112, 56, 0, 1333, 1351, 1, 0, 0, 0, 1334, 1335, 5, 253, 0, 0, 1335, 1351, 3, 32, 16, 0, 1336, 1337, 5, 252, 0, 0, 1337, 1351, 3, 32, 16, 0, 1338, 1339, 5, 253, 0, 0, 1339, 1351, 3, 2, 1, 0, 1340, 1341, 5, 252, 0, 0, 1341, 1351, 3, 2, 1, 0, 1342, 1351, 5, 254, 0, 0, 1343, 1351, 5, 201, 0, 0, 1344, 1351, 3, 148, 74, 0, 1345, 1351, 3, 150, 75, 0, 1346, 1351, 3, 144, 72, 0, 1347, 1351, 3, 2, 1, 0, 1348, 1349, 5, 177, 0, 0, 1349, 1351, 3, 138, 69, 0, 1350, 1320, 1, 0, 0, 0, 1350, 1322, 1, 0, 0, 0, 1350, 1323, 1, 0, 0, 0, 1350, 1326, 1, 0, 0, 0, 1350, 1328, 1, 0, 0, 0, 1350, 1334, 1, 0, 0, 0, 1350, 1336, 1, 0, 0, 0, 1350, 1338, 1, 0, 0, 0, 1350, 1340, 1, 0, 0, 0, 1350, 1342, 1, 0, 0, 0, 1350, 1343, 1, 0, 0, 0, 1350, 1344, 1, 0, 0, 0, 1350, 1345, 1, 0, 0, 0, 1350, 1346, 1, 0, 0, 0, 1350, 1347, 1, 0, 0, 0, 1350, 1348, 1, 0, 0, 0, 1351, 143, 1, 0, 0, 0, 1352, 1374, 5, 181, 0, 0, 1353, 1374, 5, 182, 0, 0, 1354, 1374, 5, 183, 0, 0, 1355, 1374, 5, 184, 0, 0, 1356, 1374, 5, 185, 0, 0, 1357, 1374, 5, 186, 0, 0, 1358, 1374, 5, 187, 0, 0, 1359, 1374, 5, 188, 0, 0, 1360, 1374, 5, 189, 0, 0, 1361, 1374, 5, 190, 0, 0, 1362, 1374, 5, 191, 0, 0, 1363, 1374, 5, 192, 0, 0, 1364, 1374, 5, 193, 0, 0, 1365, 1366, 5, 90, 0, 0, 1366, 1374, 5, 184, 0, 0, 1367, 1368, 5, 90, 0, 0, 1368, 1374, 5, 185, 0, 0, 1369, 1370, 5, 90, 0, 0, 1370, 1374, 5, 186, 0, 0, 1371, 1372, 5, 90, 0, 0, 1372, 1374, 5, 187, 0, 0, 1373, 1352, 1, 0, 0, 0, 1373, 1353, 1, 0, 0, 0, 1373, 1354, 1, 0, 0, 0, 1373, 1355, 1, 0, 0, 0, 1373, 1356, 1, 0, 0, 0, 1373, 1357, 1, 0, 0, 0, 1373, 1358, 1, 0, 0, 0, 1373, 1359, 1, 0, 0, 0, 1373, 1360, 1, 0, 0, 0, 1373, 1361, 1, 0, 0, 0, 1373, 1362, 1, 0, 0, 0, 1373, 1363, 1, 0, 0, 0, 1373, 1364, 1, 0, 0, 0, 1373, 1365, 1, 0, 0, 0, 1373, 1367, 1, 0, 0, 0, 1373, 1369, 1, 0, 0, 0, 1373, 1371, 1, 0, 0, 0, 1374, 145, 1, 0, 0, 0, 1375, 1386, 1, 0, 0, 0, 1376, 1386, 5, 177, 0, 0, 1377, 1386, 3, 32, 16, 0, 1378, 1379, 3, 32, 16, 0, 1379, 1380, 5, 177, 0, 0, 1380, 1381, 3, 32, 16, 0, 1381, 1386, 1, 0, 0, 0, 1382, 1383, 3, 32, 16, 0, 1383, 1384, 5, 177, 0, 0, 1384, 1386, 1, 0, 0, 0, 1385, 1375, 1, 0, 0, 0, 1385, 1376, 1, 0, 0, 0, 1385, 1377, 1, 0, 0, 0, 1385, 1378, 1, 0, 0, 0, 1385, 1382, 1, 0, 0, 0, 1386, 147, 1, 0, 0, 0, 1387, 1388, 5, 1, 0, 0, 1388, 1389, 5, 194, 0, 0, 1389, 149, 1, 0, 0, 0, 1390, 1394, 5, 1, 0, 0, 1391, 1392, 5, 90, 0, 0, 1392, 1395, 5, 194, 0, 0, 1393, 1395, 5, 195, 0, 0, 1394, 1391, 1, 0, 0, 0, 1394, 1393, 1, 0, 0, 0, 1395, 151, 1, 0, 0, 0, 1396, 1397, 5, 294, 0, 0, 1397, 1398, 3, 166, 83, 0, 1398, 1399, 3, 124, 62, 0, 1399, 1400, 5, 30, 0, 0, 1400, 1401, 3, 158, 79, 0, 1401, 1402, 5, 31, 0, 0, 1402, 1444, 1, 0, 0, 0, 1403, 1404, 5, 294, 0, 0, 1404, 1405, 3, 166, 83, 0, 1405, 1406, 3, 124, 62, 0, 1406, 1407, 5, 36, 0, 0, 1407, 1408, 5, 17, 0, 0, 1408, 1409, 3, 52, 26, 0, 1409, 1410, 5, 18, 0, 0, 1410, 1444, 1, 0, 0, 0, 1411, 1412, 5, 294, 0, 0, 1412, 1413, 3, 166, 83, 0, 1413, 1414, 3, 124, 62, 0, 1414, 1444, 1, 0, 0, 0, 1415, 1416, 5, 295, 0, 0, 1416, 1417, 3, 166, 83, 0, 1417, 1419, 5, 36, 0, 0, 1418, 1420, 5, 84, 0, 0, 1419, 1418, 1, 0, 0, 0, 1419, 1420, 1, 0, 0, 0, 1420, 1421, 1, 0, 0, 0, 1421, 1422, 5, 30, 0, 0, 1422, 1423, 3, 292, 146, 0, 1423, 1424, 5, 31, 0, 0, 1424, 1444, 1, 0, 0, 0, 1425, 1426, 5, 295, 0, 0, 1426, 1427, 3, 166, 83, 0, 1427, 1428, 5, 84, 0, 0, 1428, 1429, 5, 30, 0, 0, 1429, 1430, 3, 292, 146, 0, 1430, 1431, 5, 31, 0, 0, 1431, 1444, 1, 0, 0, 0, 1432, 1433, 5, 295, 0, 0, 1433, 1434, 3, 166, 83, 0, 1434, 1435, 3, 6, 3, 0, 1435, 1444, 1, 0, 0, 0, 1436, 1437, 5, 295, 0, 0, 1437, 1438, 3, 166, 83, 0, 1438, 1439, 5, 36, 0, 0, 1439, 1440, 5, 17, 0, 0, 1440, 1441, 3, 154, 77, 0, 1441, 1442, 5, 18, 0, 0, 1442, 1444, 1, 0, 0, 0, 1443, 1396, 1, 0, 0, 0, 1443, 1403, 1, 0, 0, 0, 1443, 1411, 1, 0, 0, 0, 1443, 1415, 1, 0, 0, 0, 1443, 1425, 1, 0, 0, 0, 1443, 1432, 1, 0, 0, 0, 1443, 1436, 1, 0, 0, 0, 1444, 153, 1, 0, 0, 0, 1445, 1456, 1, 0, 0, 0, 1446, 1447, 3, 156, 78, 0, 1447, 1448, 5, 28, 0, 0, 1448, 1450, 1, 0, 0, 0, 1449, 1446, 1, 0, 0, 0, 1450, 1453, 1, 0, 0, 0, 1451, 1449, 1, 0, 0, 0, 1451, 1452, 1, 0, 0, 0, 1452, 1454, 1, 0, 0, 0, 1453, 1451, 1, 0, 0, 0, 1454, 1456, 3, 156, 78, 0, 1455, 1445, 1, 0, 0, 0, 1455, 1451, 1, 0, 0, 0, 1456, 155, 1, 0, 0, 0, 1457, 1458, 5, 39, 0, 0, 1458, 1459, 5, 264, 0, 0, 1459, 1460, 5, 36, 0, 0, 1460, 1461, 5, 17, 0, 0, 1461, 1462, 3, 56, 28, 0, 1462, 1463, 5, 18, 0, 0, 1463, 1471, 1, 0, 0, 0, 1464, 1465, 3, 124, 62, 0, 1465, 1466, 5, 36, 0, 0, 1466, 1467, 5, 17, 0, 0, 1467, 1468, 3, 56, 28, 0, 1468, 1469, 5, 18, 0, 0, 1469, 1471, 1, 0, 0, 0, 1470, 1457, 1, 0, 0, 0, 1470, 1464, 1, 0, 0, 0, 1471, 157, 1, 0, 0, 0, 1472, 1473, 3, 160, 80, 0, 1473, 1474, 5, 28, 0, 0, 1474, 1476, 1, 0, 0, 0, 1475, 1472, 1, 0, 0, 0, 1476, 1479, 1, 0, 0, 0, 1477, 1475, 1, 0, 0, 0, 1477, 1478, 1, 0, 0, 0, 1478, 1480, 1, 0, 0, 0, 1479, 1477, 1, 0, 0, 0, 1480, 1481, 3, 160, 80, 0, 1481, 159, 1, 0, 0, 0, 1482, 1483, 3, 6, 3, 0, 1483, 1484, 5, 36, 0, 0, 1484, 1485, 3, 164, 82, 0, 1485, 161, 1, 0, 0, 0, 1486, 1487, 7, 9, 0, 0, 1487, 163, 1, 0, 0, 0, 1488, 1523, 3, 162, 81, 0, 1489, 1523, 3, 32, 16, 0, 1490, 1491, 5, 186, 0, 0, 1491, 1492, 5, 30, 0, 0, 1492, 1493, 3, 32, 16, 0, 1493, 1494, 5, 31, 0, 0, 1494, 1523, 1, 0, 0, 0, 1495, 1523, 3, 6, 3, 0, 1496, 1497, 3, 116, 58, 0, 1497, 1498, 5, 30, 0, 0, 1498, 1499, 5, 184, 0, 0, 1499, 1500, 5, 75, 0, 0, 1500, 1501, 3, 32, 16, 0, 1501, 1502, 5, 31, 0, 0, 1502, 1523, 1, 0, 0, 0, 1503, 1504, 3, 116, 58, 0, 1504, 1505, 5, 30, 0, 0, 1505, 1506, 5, 185, 0, 0, 1506, 1507, 5, 75, 0, 0, 1507, 1508, 3, 32, 16, 0, 1508, 1509, 5, 31, 0, 0, 1509, 1523, 1, 0, 0, 0, 1510, 1511, 3, 116, 58, 0, 1511, 1512, 5, 30, 0, 0, 1512, 1513, 5, 186, 0, 0, 1513, 1514, 5, 75, 0, 0, 1514, 1515, 3, 32, 16, 0, 1515, 1516, 5, 31, 0, 0, 1516, 1523, 1, 0, 0, 0, 1517, 1518, 3, 116, 58, 0, 1518, 1519, 5, 30, 0, 0, 1519, 1520, 3, 32, 16, 0, 1520, 1521, 5, 31, 0, 0, 1521, 1523, 1, 0, 0, 0, 1522, 1488, 1, 0, 0, 0, 1522, 1489, 1, 0, 0, 0, 1522, 1490, 1, 0, 0, 0, 1522, 1495, 1, 0, 0, 0, 1522, 1496, 1, 0, 0, 0, 1522, 1503, 1, 0, 0, 0, 1522, 1510, 1, 0, 0, 0, 1522, 1517, 1, 0, 0, 0, 1523, 165, 1, 0, 0, 0, 1524, 1525, 7, 10, 0, 0, 1525, 167, 1, 0, 0, 0, 1526, 1527, 3, 170, 85, 0, 1527, 1528, 3, 138, 69, 0, 1528, 1529, 3, 124, 62, 0, 1529, 1530, 5, 176, 0, 0, 1530, 1532, 3, 242, 121, 0, 1531, 1533, 3, 108, 54, 0, 1532, 1531, 1, 0, 0, 0, 1532, 1533, 1, 0, 0, 0, 1533, 1534, 1, 0, 0, 0, 1534, 1535, 3, 112, 56, 0, 1535, 1561, 1, 0, 0, 0, 1536, 1537, 3, 170, 85, 0, 1537, 1538, 3, 138, 69, 0, 1538, 1539, 3, 124, 62, 0, 1539, 1540, 5, 176, 0, 0, 1540, 1541, 3, 242, 121, 0, 1541, 1542, 3, 196, 98, 0, 1542, 1543, 3, 112, 56, 0, 1543, 1561, 1, 0, 0, 0, 1544, 1545, 3, 170, 85, 0, 1545, 1546, 3, 138, 69, 0, 1546, 1548, 3, 242, 121, 0, 1547, 1549, 3, 108, 54, 0, 1548, 1547, 1, 0, 0, 0, 1548, 1549, 1, 0, 0, 0, 1549, 1550, 1, 0, 0, 0, 1550, 1551, 3, 112, 56, 0, 1551, 1561, 1, 0, 0, 0, 1552, 1553, 3, 170, 85, 0, 1553, 1554, 3, 138, 69, 0, 1554, 1555, 3, 242, 121, 0, 1555, 1556, 3, 196, 98, 0, 1556, 1557, 3, 112, 56, 0, 1557, 1561, 1, 0, 0, 0, 1558, 1561, 3, 174, 87, 0, 1559, 1561, 3, 2, 1, 0, 1560, 1526, 1, 0, 0, 0, 1560, 1536, 1, 0, 0, 0, 1560, 1544, 1, 0, 0, 0, 1560, 1552, 1, 0, 0, 0, 1560, 1558, 1, 0, 0, 0, 1560, 1559, 1, 0, 0, 0, 1561, 169, 1, 0, 0, 0, 1562, 1563, 5, 243, 0, 0, 1563, 1573, 3, 170, 85, 0, 1564, 1565, 5, 244, 0, 0, 1565, 1573, 3, 170, 85, 0, 1566, 1573, 3, 172, 86, 0, 1567, 1568, 5, 112, 0, 0, 1568, 1569, 5, 30, 0, 0, 1569, 1570, 3, 32, 16, 0, 1570, 1571, 5, 31, 0, 0, 1571, 1573, 1, 0, 0, 0, 1572, 1562, 1, 0, 0, 0, 1572, 1564, 1, 0, 0, 0, 1572, 1566, 1, 0, 0, 0, 1572, 1567, 1, 0, 0, 0, 1573, 171, 1, 0, 0, 0, 1574, 1587, 1, 0, 0, 0, 1575, 1587, 5, 245, 0, 0, 1576, 1587, 5, 246, 0, 0, 1577, 1578, 5, 247, 0, 0, 1578, 1587, 5, 248, 0, 0, 1579, 1580, 5, 247, 0, 0, 1580, 1587, 5, 249, 0, 0, 1581, 1582, 5, 247, 0, 0, 1582, 1587, 5, 250, 0, 0, 1583, 1584, 5, 247, 0, 0, 1584, 1587, 5, 251, 0, 0, 1585, 1587, 5, 247, 0, 0, 1586, 1574, 1, 0, 0, 0, 1586, 1575, 1, 0, 0, 0, 1586, 1576, 1, 0, 0, 0, 1586, 1577, 1, 0, 0, 0, 1586, 1579, 1, 0, 0, 0, 1586, 1581, 1, 0, 0, 0, 1586, 1583, 1, 0, 0, 0, 1586, 1585, 1, 0, 0, 0, 1587, 173, 1, 0, 0, 0, 1588, 1589, 5, 113, 0, 0, 1589, 1590, 5, 30, 0, 0, 1590, 1591, 3, 32, 16, 0, 1591, 1592, 5, 31, 0, 0, 1592, 175, 1, 0, 0, 0, 1593, 1594, 5, 226, 0, 0, 1594, 1599, 3, 168, 84, 0, 1595, 1596, 5, 37, 0, 0, 1596, 1599, 3, 178, 89, 0, 1597, 1599, 3, 174, 87, 0, 1598, 1593, 1, 0, 0, 0, 1598, 1595, 1, 0, 0, 0, 1598, 1597, 1, 0, 0, 0, 1599, 177, 1, 0, 0, 0, 1600, 1601, 3, 138, 69, 0, 1601, 1602, 3, 124, 62, 0, 1602, 1603, 5, 176, 0, 0, 1603, 1604, 3, 2, 1, 0, 1604, 1610, 1, 0, 0, 0, 1605, 1606, 3, 138, 69, 0, 1606, 1607, 3, 2, 1, 0, 1607, 1610, 1, 0, 0, 0, 1608, 1610, 3, 2, 1, 0, 1609, 1600, 1, 0, 0, 0, 1609, 1605, 1, 0, 0, 0, 1609, 1608, 1, 0, 0, 0, 1610, 179, 1, 0, 0, 0, 1611, 1612, 3, 124, 62, 0, 1612, 1613, 5, 28, 0, 0, 1613, 1615, 1, 0, 0, 0, 1614, 1611, 1, 0, 0, 0, 1615, 1618, 1, 0, 0, 0, 1616, 1614, 1, 0, 0, 0, 1616, 1617, 1, 0, 0, 0, 1617, 1619, 1, 0, 0, 0, 1618, 1616, 1, 0, 0, 0, 1619, 1620, 3, 124, 62, 0, 1620, 181, 1, 0, 0, 0, 1621, 1627, 1, 0, 0, 0, 1622, 1623, 5, 86, 0, 0, 1623, 1624, 3, 190, 95, 0, 1624, 1625, 5, 87, 0, 0, 1625, 1627, 1, 0, 0, 0, 1626, 1621, 1, 0, 0, 0, 1626, 1622, 1, 0, 0, 0, 1627, 183, 1, 0, 0, 0, 1628, 1640, 5, 266, 0, 0, 1629, 1640, 5, 114, 0, 0, 1630, 1640, 5, 39, 0, 0, 1631, 1640, 5, 200, 0, 0, 1632, 1640, 5, 115, 0, 0, 1633, 1640, 5, 116, 0, 0, 1634, 1635, 5, 70, 0, 0, 1635, 1636, 5, 30, 0, 0, 1636, 1637, 3, 32, 16, 0, 1637, 1638, 5, 31, 0, 0, 1638, 1640, 1, 0, 0, 0, 1639, 1628, 1, 0, 0, 0, 1639, 1629, 1, 0, 0, 0, 1639, 1630, 1, 0, 0, 0, 1639, 1631, 1, 0, 0, 0, 1639, 1632, 1, 0, 0, 0, 1639, 1633, 1, 0, 0, 0, 1639, 1634, 1, 0, 0, 0, 1640, 185, 1, 0, 0, 0, 1641, 1643, 3, 184, 92, 0, 1642, 1641, 1, 0, 0, 0, 1643, 1646, 1, 0, 0, 0, 1644, 1642, 1, 0, 0, 0, 1644, 1645, 1, 0, 0, 0, 1645, 187, 1, 0, 0, 0, 1646, 1644, 1, 0, 0, 0, 1647, 1649, 3, 186, 93, 0, 1648, 1650, 3, 192, 96, 0, 1649, 1648, 1, 0, 0, 0, 1649, 1650, 1, 0, 0, 0, 1650, 1651, 1, 0, 0, 0, 1651, 1652, 3, 2, 1, 0, 1652, 189, 1, 0, 0, 0, 1653, 1654, 3, 188, 94, 0, 1654, 1655, 5, 28, 0, 0, 1655, 1657, 1, 0, 0, 0, 1656, 1653, 1, 0, 0, 0, 1657, 1660, 1, 0, 0, 0, 1658, 1656, 1, 0, 0, 0, 1658, 1659, 1, 0, 0, 0, 1659, 1661, 1, 0, 0, 0, 1660, 1658, 1, 0, 0, 0, 1661, 1662, 3, 188, 94, 0, 1662, 191, 1, 0, 0, 0, 1663, 1664, 5, 30, 0, 0, 1664, 1665, 3, 180, 90, 0, 1665, 1666, 5, 31, 0, 0, 1666, 193, 1, 0, 0, 0, 1667, 1670, 1, 0, 0, 0, 1668, 1670, 3, 196, 98, 0, 1669, 1667, 1, 0, 0, 0, 1669, 1668, 1, 0, 0, 0, 1670, 195, 1, 0, 0, 0, 1671, 1672, 5, 86, 0, 0, 1672, 1673, 5, 42, 0, 0, 1673, 1674, 3, 32, 16, 0, 1674, 1675, 5, 43, 0, 0, 1675, 1676, 5, 87, 0, 0, 1676, 197, 1, 0, 0, 0, 1677, 1678, 3, 234, 117, 0, 1678, 1679, 5, 17, 0, 0, 1679, 1680, 3, 246, 123, 0, 1680, 1681, 5, 18, 0, 0, 1681, 1794, 1, 0, 0, 0, 1682, 1683, 3, 74, 37, 0, 1683, 1684, 5, 17, 0, 0, 1684, 1685, 3, 82, 41, 0, 1685, 1686, 5, 18, 0, 0, 1686, 1794, 1, 0, 0, 0, 1687, 1688, 3, 210, 105, 0, 1688, 1689, 5, 17, 0, 0, 1689, 1690, 3, 214, 107, 0, 1690, 1691, 5, 18, 0, 0, 1691, 1794, 1, 0, 0, 0, 1692, 1693, 3, 218, 109, 0, 1693, 1694, 5, 17, 0, 0, 1694, 1695, 3, 222, 111, 0, 1695, 1696, 5, 18, 0, 0, 1696, 1794, 1, 0, 0, 0, 1697, 1794, 3, 200, 100, 0, 1698, 1794, 3, 276, 138, 0, 1699, 1794, 3, 152, 76, 0, 1700, 1794, 3, 88, 44, 0, 1701, 1794, 3, 322, 161, 0, 1702, 1703, 5, 117, 0, 0, 1703, 1794, 3, 32, 16, 0, 1704, 1705, 5, 118, 0, 0, 1705, 1794, 3, 32, 16, 0, 1706, 1707, 3, 334, 167, 0, 1707, 1708, 5, 17, 0, 0, 1708, 1709, 3, 338, 169, 0, 1709, 1710, 5, 18, 0, 0, 1710, 1794, 1, 0, 0, 0, 1711, 1712, 5, 302, 0, 0, 1712, 1713, 3, 124, 62, 0, 1713, 1714, 5, 176, 0, 0, 1714, 1715, 3, 242, 121, 0, 1715, 1716, 5, 119, 0, 0, 1716, 1717, 3, 170, 85, 0, 1717, 1718, 3, 138, 69, 0, 1718, 1719, 3, 124, 62, 0, 1719, 1720, 5, 176, 0, 0, 1720, 1721, 3, 242, 121, 0, 1721, 1722, 3, 112, 56, 0, 1722, 1794, 1, 0, 0, 0, 1723, 1724, 5, 302, 0, 0, 1724, 1725, 5, 226, 0, 0, 1725, 1726, 3, 170, 85, 0, 1726, 1727, 3, 138, 69, 0, 1727, 1728, 3, 124, 62, 0, 1728, 1729, 5, 176, 0, 0, 1729, 1730, 3, 242, 121, 0, 1730, 1731, 3, 194, 97, 0, 1731, 1732, 3, 112, 56, 0, 1732, 1733, 5, 119, 0, 0, 1733, 1734, 5, 226, 0, 0, 1734, 1735, 3, 170, 85, 0, 1735, 1736, 3, 138, 69, 0, 1736, 1737, 3, 124, 62, 0, 1737, 1738, 5, 176, 0, 0, 1738, 1739, 3, 242, 121, 0, 1739, 1740, 3, 194, 97, 0, 1740, 1741, 3, 112, 56, 0, 1741, 1794, 1, 0, 0, 0, 1742, 1794, 3, 26, 13, 0, 1743, 1794, 3, 40, 20, 0, 1744, 1745, 5, 255, 0, 0, 1745, 1746, 5, 196, 0, 0, 1746, 1747, 5, 42, 0, 0, 1747, 1748, 3, 32, 16, 0, 1748, 1752, 5, 43, 0, 0, 1749, 1751, 3, 322, 161, 0, 1750, 1749, 1, 0, 0, 0, 1751, 1754, 1, 0, 0, 0, 1752, 1750, 1, 0, 0, 0, 1752, 1753, 1, 0, 0, 0, 1753, 1794, 1, 0, 0, 0, 1754, 1752, 1, 0, 0, 0, 1755, 1756, 5, 255, 0, 0, 1756, 1757, 5, 196, 0, 0, 1757, 1761, 3, 2, 1, 0, 1758, 1760, 3, 322, 161, 0, 1759, 1758, 1, 0, 0, 0, 1760, 1763, 1, 0, 0, 0, 1761, 1759, 1, 0, 0, 0, 1761, 1762, 1, 0, 0, 0, 1762, 1794, 1, 0, 0, 0, 1763, 1761, 1, 0, 0, 0, 1764, 1765, 5, 255, 0, 0, 1765, 1766, 5, 256, 0, 0, 1766, 1767, 5, 42, 0, 0, 1767, 1768, 3, 32, 16, 0, 1768, 1769, 5, 43, 0, 0, 1769, 1770, 5, 28, 0, 0, 1770, 1774, 3, 124, 62, 0, 1771, 1773, 3, 322, 161, 0, 1772, 1771, 1, 0, 0, 0, 1773, 1776, 1, 0, 0, 0, 1774, 1772, 1, 0, 0, 0, 1774, 1775, 1, 0, 0, 0, 1775, 1794, 1, 0, 0, 0, 1776, 1774, 1, 0, 0, 0, 1777, 1778, 5, 255, 0, 0, 1778, 1779, 5, 256, 0, 0, 1779, 1780, 3, 2, 1, 0, 1780, 1781, 5, 28, 0, 0, 1781, 1785, 3, 124, 62, 0, 1782, 1784, 3, 322, 161, 0, 1783, 1782, 1, 0, 0, 0, 1784, 1787, 1, 0, 0, 0, 1785, 1783, 1, 0, 0, 0, 1785, 1786, 1, 0, 0, 0, 1786, 1794, 1, 0, 0, 0, 1787, 1785, 1, 0, 0, 0, 1788, 1789, 5, 120, 0, 0, 1789, 1790, 5, 196, 0, 0, 1790, 1791, 3, 124, 62, 0, 1791, 1792, 3, 44, 22, 0, 1792, 1794, 1, 0, 0, 0, 1793, 1677, 1, 0, 0, 0, 1793, 1682, 1, 0, 0, 0, 1793, 1687, 1, 0, 0, 0, 1793, 1692, 1, 0, 0, 0, 1793, 1697, 1, 0, 0, 0, 1793, 1698, 1, 0, 0, 0, 1793, 1699, 1, 0, 0, 0, 1793, 1700, 1, 0, 0, 0, 1793, 1701, 1, 0, 0, 0, 1793, 1702, 1, 0, 0, 0, 1793, 1704, 1, 0, 0, 0, 1793, 1706, 1, 0, 0, 0, 1793, 1711, 1, 0, 0, 0, 1793, 1723, 1, 0, 0, 0, 1793, 1742, 1, 0, 0, 0, 1793, 1743, 1, 0, 0, 0, 1793, 1744, 1, 0, 0, 0, 1793, 1755, 1, 0, 0, 0, 1793, 1764, 1, 0, 0, 0, 1793, 1777, 1, 0, 0, 0, 1793, 1788, 1, 0, 0, 0, 1794, 199, 1, 0, 0, 0, 1795, 1796, 5, 121, 0, 0, 1796, 1805, 3, 208, 104, 0, 1797, 1804, 3, 202, 101, 0, 1798, 1799, 5, 122, 0, 0, 1799, 1800, 5, 30, 0, 0, 1800, 1801, 3, 228, 114, 0, 1801, 1802, 5, 31, 0, 0, 1802, 1804, 1, 0, 0, 0, 1803, 1797, 1, 0, 0, 0, 1803, 1798, 1, 0, 0, 0, 1804, 1807, 1, 0, 0, 0, 1805, 1803, 1, 0, 0, 0, 1805, 1806, 1, 0, 0, 0, 1806, 1808, 1, 0, 0, 0, 1807, 1805, 1, 0, 0, 0, 1808, 1809, 3, 138, 69, 0, 1809, 1810, 3, 2, 1, 0, 1810, 1811, 3, 204, 102, 0, 1811, 1812, 3, 206, 103, 0, 1812, 201, 1, 0, 0, 0, 1813, 1833, 5, 123, 0, 0, 1814, 1833, 5, 51, 0, 0, 1815, 1833, 5, 52, 0, 0, 1816, 1833, 5, 63, 0, 0, 1817, 1833, 5, 124, 0, 0, 1818, 1833, 5, 69, 0, 0, 1819, 1833, 5, 68, 0, 0, 1820, 1833, 5, 64, 0, 0, 1821, 1833, 5, 65, 0, 0, 1822, 1833, 5, 66, 0, 0, 1823, 1833, 5, 125, 0, 0, 1824, 1833, 5, 126, 0, 0, 1825, 1833, 5, 127, 0, 0, 1826, 1833, 5, 16, 0, 0, 1827, 1828, 5, 70, 0, 0, 1828, 1829, 5, 30, 0, 0, 1829, 1830, 3, 32, 16, 0, 1830, 1831, 5, 31, 0, 0, 1831, 1833, 1, 0, 0, 0, 1832, 1813, 1, 0, 0, 0, 1832, 1814, 1, 0, 0, 0, 1832, 1815, 1, 0, 0, 0, 1832, 1816, 1, 0, 0, 0, 1832, 1817, 1, 0, 0, 0, 1832, 1818, 1, 0, 0, 0, 1832, 1819, 1, 0, 0, 0, 1832, 1820, 1, 0, 0, 0, 1832, 1821, 1, 0, 0, 0, 1832, 1822, 1, 0, 0, 0, 1832, 1823, 1, 0, 0, 0, 1832, 1824, 1, 0, 0, 0, 1832, 1825, 1, 0, 0, 0, 1832, 1826, 1, 0, 0, 0, 1832, 1827, 1, 0, 0, 0, 1833, 203, 1, 0, 0, 0, 1834, 1840, 1, 0, 0, 0, 1835, 1836, 5, 44, 0, 0, 1836, 1840, 3, 0, 0, 0, 1837, 1838, 5, 44, 0, 0, 1838, 1840, 3, 32, 16, 0, 1839, 1834, 1, 0, 0, 0, 1839, 1835, 1, 0, 0, 0, 1839, 1837, 1, 0, 0, 0, 1840, 205, 1, 0, 0, 0, 1841, 1845, 1, 0, 0, 0, 1842, 1843, 5, 36, 0, 0, 1843, 1845, 3, 296, 148, 0, 1844, 1841, 1, 0, 0, 0, 1844, 1842, 1, 0, 0, 0, 1845, 207, 1, 0, 0, 0, 1846, 1852, 1, 0, 0, 0, 1847, 1848, 5, 42, 0, 0, 1848, 1849, 3, 32, 16, 0, 1849, 1850, 5, 43, 0, 0, 1850, 1852, 1, 0, 0, 0, 1851, 1846, 1, 0, 0, 0, 1851, 1847, 1, 0, 0, 0, 1852, 209, 1, 0, 0, 0, 1853, 1857, 5, 128, 0, 0, 1854, 1856, 3, 212, 106, 0, 1855, 1854, 1, 0, 0, 0, 1856, 1859, 1, 0, 0, 0, 1857, 1855, 1, 0, 0, 0, 1857, 1858, 1, 0, 0, 0, 1858, 1860, 1, 0, 0, 0, 1859, 1857, 1, 0, 0, 0, 1860, 1861, 3, 124, 62, 0, 1861, 1862, 3, 2, 1, 0, 1862, 1872, 1, 0, 0, 0, 1863, 1867, 5, 128, 0, 0, 1864, 1866, 3, 212, 106, 0, 1865, 1864, 1, 0, 0, 0, 1866, 1869, 1, 0, 0, 0, 1867, 1865, 1, 0, 0, 0, 1867, 1868, 1, 0, 0, 0, 1868, 1870, 1, 0, 0, 0, 1869, 1867, 1, 0, 0, 0, 1870, 1872, 3, 2, 1, 0, 1871, 1853, 1, 0, 0, 0, 1871, 1863, 1, 0, 0, 0, 1872, 211, 1, 0, 0, 0, 1873, 1874, 7, 11, 0, 0, 1874, 213, 1, 0, 0, 0, 1875, 1877, 3, 216, 108, 0, 1876, 1875, 1, 0, 0, 0, 1877, 1880, 1, 0, 0, 0, 1878, 1876, 1, 0, 0, 0, 1878, 1879, 1, 0, 0, 0, 1879, 215, 1, 0, 0, 0, 1880, 1878, 1, 0, 0, 0, 1881, 1882, 5, 129, 0, 0, 1882, 1894, 3, 168, 84, 0, 1883, 1884, 5, 130, 0, 0, 1884, 1894, 3, 168, 84, 0, 1885, 1886, 5, 131, 0, 0, 1886, 1894, 3, 168, 84, 0, 1887, 1888, 5, 132, 0, 0, 1888, 1894, 3, 168, 84, 0, 1889, 1894, 3, 88, 44, 0, 1890, 1894, 3, 322, 161, 0, 1891, 1894, 3, 26, 13, 0, 1892, 1894, 3, 40, 20, 0, 1893, 1881, 1, 0, 0, 0, 1893, 1883, 1, 0, 0, 0, 1893, 1885, 1, 0, 0, 0, 1893, 1887, 1, 0, 0, 0, 1893, 1889, 1, 0, 0, 0, 1893, 1890, 1, 0, 0, 0, 1893, 1891, 1, 0, 0, 0, 1893, 1892, 1, 0, 0, 0, 1894, 217, 1, 0, 0, 0, 1895, 1899, 5, 133, 0, 0, 1896, 1898, 3, 220, 110, 0, 1897, 1896, 1, 0, 0, 0, 1898, 1901, 1, 0, 0, 0, 1899, 1897, 1, 0, 0, 0, 1899, 1900, 1, 0, 0, 0, 1900, 1902, 1, 0, 0, 0, 1901, 1899, 1, 0, 0, 0, 1902, 1903, 3, 170, 85, 0, 1903, 1904, 3, 138, 69, 0, 1904, 1905, 3, 2, 1, 0, 1905, 1906, 3, 112, 56, 0, 1906, 1907, 3, 206, 103, 0, 1907, 219, 1, 0, 0, 0, 1908, 1909, 7, 11, 0, 0, 1909, 221, 1, 0, 0, 0, 1910, 1912, 3, 224, 112, 0, 1911, 1910, 1, 0, 0, 0, 1912, 1915, 1, 0, 0, 0, 1913, 1911, 1, 0, 0, 0, 1913, 1914, 1, 0, 0, 0, 1914, 223, 1, 0, 0, 0, 1915, 1913, 1, 0, 0, 0, 1916, 1917, 5, 134, 0, 0, 1917, 1927, 3, 168, 84, 0, 1918, 1919, 5, 135, 0, 0, 1919, 1927, 3, 168, 84, 0, 1920, 1921, 5, 132, 0, 0, 1921, 1927, 3, 168, 84, 0, 1922, 1927, 3, 322, 161, 0, 1923, 1927, 3, 88, 44, 0, 1924, 1927, 3, 26, 13, 0, 1925, 1927, 3, 40, 20, 0, 1926, 1916, 1, 0, 0, 0, 1926, 1918, 1, 0, 0, 0, 1926, 1920, 1, 0, 0, 0, 1926, 1922, 1, 0, 0, 0, 1926, 1923, 1, 0, 0, 0, 1926, 1924, 1, 0, 0, 0, 1926, 1925, 1, 0, 0, 0, 1927, 225, 1, 0, 0, 0, 1928, 1935, 1, 0, 0, 0, 1929, 1930, 5, 122, 0, 0, 1930, 1931, 5, 30, 0, 0, 1931, 1932, 3, 228, 114, 0, 1932, 1933, 5, 31, 0, 0, 1933, 1935, 1, 0, 0, 0, 1934, 1928, 1, 0, 0, 0, 1934, 1929, 1, 0, 0, 0, 1935, 227, 1, 0, 0, 0, 1936, 1946, 3, 126, 63, 0, 1937, 1939, 5, 17, 0, 0, 1938, 1940, 3, 294, 147, 0, 1939, 1938, 1, 0, 0, 0, 1940, 1941, 1, 0, 0, 0, 1941, 1939, 1, 0, 0, 0, 1941, 1942, 1, 0, 0, 0, 1942, 1943, 1, 0, 0, 0, 1943, 1944, 5, 18, 0, 0, 1944, 1946, 1, 0, 0, 0, 1945, 1936, 1, 0, 0, 0, 1945, 1937, 1, 0, 0, 0, 1946, 229, 1, 0, 0, 0, 1947, 1949, 3, 232, 116, 0, 1948, 1947, 1, 0, 0, 0, 1949, 1952, 1, 0, 0, 0, 1950, 1948, 1, 0, 0, 0, 1950, 1951, 1, 0, 0, 0, 1951, 231, 1, 0, 0, 0, 1952, 1950, 1, 0, 0, 0, 1953, 1954, 5, 42, 0, 0, 1954, 1955, 5, 136, 0, 0, 1955, 1967, 5, 43, 0, 0, 1956, 1957, 5, 42, 0, 0, 1957, 1958, 5, 137, 0, 0, 1958, 1967, 5, 43, 0, 0, 1959, 1960, 5, 42, 0, 0, 1960, 1961, 5, 138, 0, 0, 1961, 1967, 5, 43, 0, 0, 1962, 1963, 5, 42, 0, 0, 1963, 1964, 3, 32, 16, 0, 1964, 1965, 5, 43, 0, 0, 1965, 1967, 1, 0, 0, 0, 1966, 1953, 1, 0, 0, 0, 1966, 1956, 1, 0, 0, 0, 1966, 1959, 1, 0, 0, 0, 1966, 1962, 1, 0, 0, 0, 1967, 233, 1, 0, 0, 0, 1968, 1973, 5, 139, 0, 0, 1969, 1972, 3, 236, 118, 0, 1970, 1972, 3, 238, 119, 0, 1971, 1969, 1, 0, 0, 0, 1971, 1970, 1, 0, 0, 0, 1972, 1975, 1, 0, 0, 0, 1973, 1971, 1, 0, 0, 0, 1973, 1974, 1, 0, 0, 0, 1974, 1976, 1, 0, 0, 0, 1975, 1973, 1, 0, 0, 0, 1976, 1977, 3, 170, 85, 0, 1977, 1978, 3, 230, 115, 0, 1978, 1979, 3, 138, 69, 0, 1979, 1980, 3, 226, 113, 0, 1980, 1981, 3, 242, 121, 0, 1981, 1982, 3, 182, 91, 0, 1982, 1986, 3, 112, 56, 0, 1983, 1985, 3, 244, 122, 0, 1984, 1983, 1, 0, 0, 0, 1985, 1988, 1, 0, 0, 0, 1986, 1984, 1, 0, 0, 0, 1986, 1987, 1, 0, 0, 0, 1987, 235, 1, 0, 0, 0, 1988, 1986, 1, 0, 0, 0, 1989, 2013, 5, 123, 0, 0, 1990, 2013, 5, 51, 0, 0, 1991, 2013, 5, 52, 0, 0, 1992, 2013, 5, 63, 0, 0, 1993, 2013, 5, 140, 0, 0, 1994, 2013, 5, 68, 0, 0, 1995, 2013, 5, 141, 0, 0, 1996, 2013, 5, 142, 0, 0, 1997, 2013, 5, 54, 0, 0, 1998, 2013, 5, 64, 0, 0, 1999, 2013, 5, 65, 0, 0, 2000, 2013, 5, 66, 0, 0, 2001, 2013, 5, 125, 0, 0, 2002, 2013, 5, 143, 0, 0, 2003, 2013, 5, 144, 0, 0, 2004, 2013, 5, 69, 0, 0, 2005, 2013, 5, 145, 0, 0, 2006, 2013, 5, 146, 0, 0, 2007, 2008, 5, 70, 0, 0, 2008, 2009, 5, 30, 0, 0, 2009, 2010, 3, 32, 16, 0, 2010, 2011, 5, 31, 0, 0, 2011, 2013, 1, 0, 0, 0, 2012, 1989, 1, 0, 0, 0, 2012, 1990, 1, 0, 0, 0, 2012, 1991, 1, 0, 0, 0, 2012, 1992, 1, 0, 0, 0, 2012, 1993, 1, 0, 0, 0, 2012, 1994, 1, 0, 0, 0, 2012, 1995, 1, 0, 0, 0, 2012, 1996, 1, 0, 0, 0, 2012, 1997, 1, 0, 0, 0, 2012, 1998, 1, 0, 0, 0, 2012, 1999, 1, 0, 0, 0, 2012, 2000, 1, 0, 0, 0, 2012, 2001, 1, 0, 0, 0, 2012, 2002, 1, 0, 0, 0, 2012, 2003, 1, 0, 0, 0, 2012, 2004, 1, 0, 0, 0, 2012, 2005, 1, 0, 0, 0, 2012, 2006, 1, 0, 0, 0, 2012, 2007, 1, 0, 0, 0, 2013, 237, 1, 0, 0, 0, 2014, 2015, 5, 147, 0, 0, 2015, 2021, 5, 30, 0, 0, 2016, 2019, 3, 6, 3, 0, 2017, 2018, 5, 34, 0, 0, 2018, 2020, 3, 6, 3, 0, 2019, 2017, 1, 0, 0, 0, 2019, 2020, 1, 0, 0, 0, 2020, 2022, 1, 0, 0, 0, 2021, 2016, 1, 0, 0, 0, 2021, 2022, 1, 0, 0, 0, 2022, 2026, 1, 0, 0, 0, 2023, 2025, 3, 240, 120, 0, 2024, 2023, 1, 0, 0, 0, 2025, 2028, 1, 0, 0, 0, 2026, 2024, 1, 0, 0, 0, 2026, 2027, 1, 0, 0, 0, 2027, 2029, 1, 0, 0, 0, 2028, 2026, 1, 0, 0, 0, 2029, 2033, 5, 31, 0, 0, 2030, 2031, 5, 147, 0, 0, 2031, 2033, 5, 85, 0, 0, 2032, 2014, 1, 0, 0, 0, 2032, 2030, 1, 0, 0, 0, 2033, 239, 1, 0, 0, 0, 2034, 2062, 5, 148, 0, 0, 2035, 2062, 5, 224, 0, 0, 2036, 2062, 5, 57, 0, 0, 2037, 2062, 5, 58, 0, 0, 2038, 2062, 5, 149, 0, 0, 2039, 2062, 5, 150, 0, 0, 2040, 2062, 5, 248, 0, 0, 2041, 2062, 5, 249, 0, 0, 2042, 2062, 5, 250, 0, 0, 2043, 2062, 5, 251, 0, 0, 2044, 2045, 5, 151, 0, 0, 2045, 2046, 5, 75, 0, 0, 2046, 2062, 5, 152, 0, 0, 2047, 2048, 5, 151, 0, 0, 2048, 2049, 5, 75, 0, 0, 2049, 2062, 5, 153, 0, 0, 2050, 2051, 5, 154, 0, 0, 2051, 2052, 5, 75, 0, 0, 2052, 2062, 5, 152, 0, 0, 2053, 2054, 5, 154, 0, 0, 2054, 2055, 5, 75, 0, 0, 2055, 2062, 5, 153, 0, 0, 2056, 2057, 5, 70, 0, 0, 2057, 2058, 5, 30, 0, 0, 2058, 2059, 3, 32, 16, 0, 2059, 2060, 5, 31, 0, 0, 2060, 2062, 1, 0, 0, 0, 2061, 2034, 1, 0, 0, 0, 2061, 2035, 1, 0, 0, 0, 2061, 2036, 1, 0, 0, 0, 2061, 2037, 1, 0, 0, 0, 2061, 2038, 1, 0, 0, 0, 2061, 2039, 1, 0, 0, 0, 2061, 2040, 1, 0, 0, 0, 2061, 2041, 1, 0, 0, 0, 2061, 2042, 1, 0, 0, 0, 2061, 2043, 1, 0, 0, 0, 2061, 2044, 1, 0, 0, 0, 2061, 2047, 1, 0, 0, 0, 2061, 2050, 1, 0, 0, 0, 2061, 2053, 1, 0, 0, 0, 2061, 2056, 1, 0, 0, 0, 2062, 241, 1, 0, 0, 0, 2063, 2067, 5, 116, 0, 0, 2064, 2067, 5, 155, 0, 0, 2065, 2067, 3, 2, 1, 0, 2066, 2063, 1, 0, 0, 0, 2066, 2064, 1, 0, 0, 0, 2066, 2065, 1, 0, 0, 0, 2067, 243, 1, 0, 0, 0, 2068, 2090, 5, 1, 0, 0, 2069, 2090, 5, 2, 0, 0, 2070, 2090, 5, 156, 0, 0, 2071, 2090, 5, 3, 0, 0, 2072, 2090, 5, 4, 0, 0, 2073, 2090, 5, 247, 0, 0, 2074, 2090, 5, 5, 0, 0, 2075, 2090, 5, 6, 0, 0, 2076, 2090, 5, 7, 0, 0, 2077, 2090, 5, 8, 0, 0, 2078, 2090, 5, 9, 0, 0, 2079, 2090, 5, 10, 0, 0, 2080, 2090, 5, 11, 0, 0, 2081, 2090, 5, 12, 0, 0, 2082, 2090, 5, 13, 0, 0, 2083, 2090, 5, 14, 0, 0, 2084, 2085, 5, 70, 0, 0, 2085, 2086, 5, 30, 0, 0, 2086, 2087, 3, 32, 16, 0, 2087, 2088, 5, 31, 0, 0, 2088, 2090, 1, 0, 0, 0, 2089, 2068, 1, 0, 0, 0, 2089, 2069, 1, 0, 0, 0, 2089, 2070, 1, 0, 0, 0, 2089, 2071, 1, 0, 0, 0, 2089, 2072, 1, 0, 0, 0, 2089, 2073, 1, 0, 0, 0, 2089, 2074, 1, 0, 0, 0, 2089, 2075, 1, 0, 0, 0, 2089, 2076, 1, 0, 0, 0, 2089, 2077, 1, 0, 0, 0, 2089, 2078, 1, 0, 0, 0, 2089, 2079, 1, 0, 0, 0, 2089, 2080, 1, 0, 0, 0, 2089, 2081, 1, 0, 0, 0, 2089, 2082, 1, 0, 0, 0, 2089, 2083, 1, 0, 0, 0, 2089, 2084, 1, 0, 0, 0, 2090, 245, 1, 0, 0, 0, 2091, 2093, 3, 248, 124, 0, 2092, 2091, 1, 0, 0, 0, 2093, 2096, 1, 0, 0, 0, 2094, 2092, 1, 0, 0, 0, 2094, 2095, 1, 0, 0, 0, 2095, 247, 1, 0, 0, 0, 2096, 2094, 1, 0, 0, 0, 2097, 2115, 3, 100, 50, 0, 2098, 2099, 5, 296, 0, 0, 2099, 2100, 3, 32, 16, 0, 2100, 2101, 6, 124, -1, 0, 2101, 2115, 1, 0, 0, 0, 2102, 2115, 3, 258, 129, 0, 2103, 2104, 5, 297, 0, 0, 2104, 2105, 3, 32, 16, 0, 2105, 2106, 6, 124, -1, 0, 2106, 2115, 1, 0, 0, 0, 2107, 2108, 5, 298, 0, 0, 2108, 2115, 6, 124, -1, 0, 2109, 2110, 5, 299, 0, 0, 2110, 2115, 6, 124, -1, 0, 2111, 2115, 3, 252, 126, 0, 2112, 2115, 3, 256, 128, 0, 2113, 2115, 3, 250, 125, 0, 2114, 2097, 1, 0, 0, 0, 2114, 2098, 1, 0, 0, 0, 2114, 2102, 1, 0, 0, 0, 2114, 2103, 1, 0, 0, 0, 2114, 2107, 1, 0, 0, 0, 2114, 2109, 1, 0, 0, 0, 2114, 2111, 1, 0, 0, 0, 2114, 2112, 1, 0, 0, 0, 2114, 2113, 1, 0, 0, 0, 2115, 249, 1, 0, 0, 0, 2116, 2117, 5, 300, 0, 0, 2117, 2215, 3, 112, 56, 0, 2118, 2119, 5, 300, 0, 0, 2119, 2120, 5, 157, 0, 0, 2120, 2215, 3, 112, 56, 0, 2121, 2215, 3, 276, 138, 0, 2122, 2215, 3, 152, 76, 0, 2123, 2215, 3, 88, 44, 0, 2124, 2215, 3, 26, 13, 0, 2125, 2215, 3, 254, 127, 0, 2126, 2215, 3, 40, 20, 0, 2127, 2128, 5, 301, 0, 0, 2128, 2129, 5, 42, 0, 0, 2129, 2130, 3, 32, 16, 0, 2130, 2131, 5, 43, 0, 0, 2131, 2215, 1, 0, 0, 0, 2132, 2133, 5, 301, 0, 0, 2133, 2134, 5, 42, 0, 0, 2134, 2135, 3, 32, 16, 0, 2135, 2136, 5, 43, 0, 0, 2136, 2137, 5, 34, 0, 0, 2137, 2138, 3, 0, 0, 0, 2138, 2215, 1, 0, 0, 0, 2139, 2140, 5, 303, 0, 0, 2140, 2141, 3, 32, 16, 0, 2141, 2142, 5, 75, 0, 0, 2142, 2143, 3, 32, 16, 0, 2143, 2215, 1, 0, 0, 0, 2144, 2145, 5, 302, 0, 0, 2145, 2146, 3, 124, 62, 0, 2146, 2147, 5, 176, 0, 0, 2147, 2148, 3, 242, 121, 0, 2148, 2215, 1, 0, 0, 0, 2149, 2150, 5, 302, 0, 0, 2150, 2151, 5, 226, 0, 0, 2151, 2152, 3, 170, 85, 0, 2152, 2153, 3, 138, 69, 0, 2153, 2154, 3, 124, 62, 0, 2154, 2155, 5, 176, 0, 0, 2155, 2156, 3, 242, 121, 0, 2156, 2157, 3, 194, 97, 0, 2157, 2158, 3, 112, 56, 0, 2158, 2215, 1, 0, 0, 0, 2159, 2160, 5, 255, 0, 0, 2160, 2161, 5, 196, 0, 0, 2161, 2162, 5, 42, 0, 0, 2162, 2163, 3, 32, 16, 0, 2163, 2167, 5, 43, 0, 0, 2164, 2166, 3, 322, 161, 0, 2165, 2164, 1, 0, 0, 0, 2166, 2169, 1, 0, 0, 0, 2167, 2165, 1, 0, 0, 0, 2167, 2168, 1, 0, 0, 0, 2168, 2215, 1, 0, 0, 0, 2169, 2167, 1, 0, 0, 0, 2170, 2171, 5, 255, 0, 0, 2171, 2172, 5, 196, 0, 0, 2172, 2176, 3, 2, 1, 0, 2173, 2175, 3, 322, 161, 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, 2215, 1, 0, 0, 0, 2178, 2176, 1, 0, 0, 0, 2179, 2180, 5, 255, 0, 0, 2180, 2181, 5, 256, 0, 0, 2181, 2182, 5, 42, 0, 0, 2182, 2183, 3, 32, 16, 0, 2183, 2184, 5, 43, 0, 0, 2184, 2185, 5, 28, 0, 0, 2185, 2189, 3, 124, 62, 0, 2186, 2188, 3, 322, 161, 0, 2187, 2186, 1, 0, 0, 0, 2188, 2191, 1, 0, 0, 0, 2189, 2187, 1, 0, 0, 0, 2189, 2190, 1, 0, 0, 0, 2190, 2215, 1, 0, 0, 0, 2191, 2189, 1, 0, 0, 0, 2192, 2193, 5, 255, 0, 0, 2193, 2194, 5, 256, 0, 0, 2194, 2195, 3, 2, 1, 0, 2195, 2196, 5, 28, 0, 0, 2196, 2200, 3, 124, 62, 0, 2197, 2199, 3, 322, 161, 0, 2198, 2197, 1, 0, 0, 0, 2199, 2202, 1, 0, 0, 0, 2200, 2198, 1, 0, 0, 0, 2200, 2201, 1, 0, 0, 0, 2201, 2215, 1, 0, 0, 0, 2202, 2200, 1, 0, 0, 0, 2203, 2204, 5, 255, 0, 0, 2204, 2205, 5, 42, 0, 0, 2205, 2206, 3, 32, 16, 0, 2206, 2207, 5, 43, 0, 0, 2207, 2211, 3, 206, 103, 0, 2208, 2210, 3, 322, 161, 0, 2209, 2208, 1, 0, 0, 0, 2210, 2213, 1, 0, 0, 0, 2211, 2209, 1, 0, 0, 0, 2211, 2212, 1, 0, 0, 0, 2212, 2215, 1, 0, 0, 0, 2213, 2211, 1, 0, 0, 0, 2214, 2116, 1, 0, 0, 0, 2214, 2118, 1, 0, 0, 0, 2214, 2121, 1, 0, 0, 0, 2214, 2122, 1, 0, 0, 0, 2214, 2123, 1, 0, 0, 0, 2214, 2124, 1, 0, 0, 0, 2214, 2125, 1, 0, 0, 0, 2214, 2126, 1, 0, 0, 0, 2214, 2127, 1, 0, 0, 0, 2214, 2132, 1, 0, 0, 0, 2214, 2139, 1, 0, 0, 0, 2214, 2144, 1, 0, 0, 0, 2214, 2149, 1, 0, 0, 0, 2214, 2159, 1, 0, 0, 0, 2214, 2170, 1, 0, 0, 0, 2214, 2179, 1, 0, 0, 0, 2214, 2192, 1, 0, 0, 0, 2214, 2203, 1, 0, 0, 0, 2215, 251, 1, 0, 0, 0, 2216, 2217, 3, 0, 0, 0, 2217, 2218, 5, 75, 0, 0, 2218, 2219, 6, 126, -1, 0, 2219, 253, 1, 0, 0, 0, 2220, 2223, 3, 44, 22, 0, 2221, 2223, 3, 46, 23, 0, 2222, 2220, 1, 0, 0, 0, 2222, 2221, 1, 0, 0, 0, 2223, 255, 1, 0, 0, 0, 2224, 2225, 5, 17, 0, 0, 2225, 2226, 3, 246, 123, 0, 2226, 2227, 5, 18, 0, 0, 2227, 257, 1, 0, 0, 0, 2228, 2229, 3, 262, 131, 0, 2229, 2230, 3, 260, 130, 0, 2230, 259, 1, 0, 0, 0, 2231, 2233, 3, 264, 132, 0, 2232, 2231, 1, 0, 0, 0, 2233, 2234, 1, 0, 0, 0, 2234, 2232, 1, 0, 0, 0, 2234, 2235, 1, 0, 0, 0, 2235, 261, 1, 0, 0, 0, 2236, 2237, 5, 158, 0, 0, 2237, 2249, 3, 256, 128, 0, 2238, 2239, 5, 158, 0, 0, 2239, 2240, 3, 0, 0, 0, 2240, 2241, 5, 159, 0, 0, 2241, 2242, 3, 0, 0, 0, 2242, 2249, 1, 0, 0, 0, 2243, 2244, 5, 158, 0, 0, 2244, 2245, 3, 32, 16, 0, 2245, 2246, 5, 159, 0, 0, 2246, 2247, 3, 32, 16, 0, 2247, 2249, 1, 0, 0, 0, 2248, 2236, 1, 0, 0, 0, 2248, 2238, 1, 0, 0, 0, 2248, 2243, 1, 0, 0, 0, 2249, 263, 1, 0, 0, 0, 2250, 2251, 3, 268, 134, 0, 2251, 2252, 3, 274, 137, 0, 2252, 2263, 1, 0, 0, 0, 2253, 2254, 3, 266, 133, 0, 2254, 2255, 3, 274, 137, 0, 2255, 2263, 1, 0, 0, 0, 2256, 2257, 3, 270, 135, 0, 2257, 2258, 3, 274, 137, 0, 2258, 2263, 1, 0, 0, 0, 2259, 2260, 3, 272, 136, 0, 2260, 2261, 3, 274, 137, 0, 2261, 2263, 1, 0, 0, 0, 2262, 2250, 1, 0, 0, 0, 2262, 2253, 1, 0, 0, 0, 2262, 2256, 1, 0, 0, 0, 2262, 2259, 1, 0, 0, 0, 2263, 265, 1, 0, 0, 0, 2264, 2265, 5, 160, 0, 0, 2265, 2271, 3, 256, 128, 0, 2266, 2267, 5, 160, 0, 0, 2267, 2271, 3, 0, 0, 0, 2268, 2269, 5, 160, 0, 0, 2269, 2271, 3, 32, 16, 0, 2270, 2264, 1, 0, 0, 0, 2270, 2266, 1, 0, 0, 0, 2270, 2268, 1, 0, 0, 0, 2271, 267, 1, 0, 0, 0, 2272, 2273, 5, 161, 0, 0, 2273, 2274, 3, 124, 62, 0, 2274, 269, 1, 0, 0, 0, 2275, 2276, 5, 162, 0, 0, 2276, 271, 1, 0, 0, 0, 2277, 2278, 5, 163, 0, 0, 2278, 273, 1, 0, 0, 0, 2279, 2291, 3, 256, 128, 0, 2280, 2281, 5, 164, 0, 0, 2281, 2282, 3, 0, 0, 0, 2282, 2283, 5, 159, 0, 0, 2283, 2284, 3, 0, 0, 0, 2284, 2291, 1, 0, 0, 0, 2285, 2286, 5, 164, 0, 0, 2286, 2287, 3, 32, 16, 0, 2287, 2288, 5, 159, 0, 0, 2288, 2289, 3, 32, 16, 0, 2289, 2291, 1, 0, 0, 0, 2290, 2279, 1, 0, 0, 0, 2290, 2280, 1, 0, 0, 0, 2290, 2285, 1, 0, 0, 0, 2291, 275, 1, 0, 0, 0, 2292, 2293, 3, 278, 139, 0, 2293, 2294, 3, 282, 141, 0, 2294, 277, 1, 0, 0, 0, 2295, 2296, 5, 165, 0, 0, 2296, 2297, 3, 280, 140, 0, 2297, 2298, 3, 0, 0, 0, 2298, 2299, 5, 36, 0, 0, 2299, 2303, 1, 0, 0, 0, 2300, 2301, 5, 165, 0, 0, 2301, 2303, 3, 280, 140, 0, 2302, 2295, 1, 0, 0, 0, 2302, 2300, 1, 0, 0, 0, 2303, 279, 1, 0, 0, 0, 2304, 2308, 1, 0, 0, 0, 2305, 2308, 5, 166, 0, 0, 2306, 2308, 5, 2, 0, 0, 2307, 2304, 1, 0, 0, 0, 2307, 2305, 1, 0, 0, 0, 2307, 2306, 1, 0, 0, 0, 2308, 281, 1, 0, 0, 0, 2309, 2310, 5, 17, 0, 0, 2310, 2311, 3, 284, 142, 0, 2311, 2312, 5, 18, 0, 0, 2312, 2319, 1, 0, 0, 0, 2313, 2315, 3, 288, 144, 0, 2314, 2313, 1, 0, 0, 0, 2315, 2316, 1, 0, 0, 0, 2316, 2314, 1, 0, 0, 0, 2316, 2317, 1, 0, 0, 0, 2317, 2319, 1, 0, 0, 0, 2318, 2309, 1, 0, 0, 0, 2318, 2314, 1, 0, 0, 0, 2319, 283, 1, 0, 0, 0, 2320, 2321, 3, 288, 144, 0, 2321, 2322, 5, 28, 0, 0, 2322, 2324, 1, 0, 0, 0, 2323, 2320, 1, 0, 0, 0, 2324, 2327, 1, 0, 0, 0, 2325, 2323, 1, 0, 0, 0, 2325, 2326, 1, 0, 0, 0, 2326, 2328, 1, 0, 0, 0, 2327, 2325, 1, 0, 0, 0, 2328, 2329, 3, 288, 144, 0, 2329, 285, 1, 0, 0, 0, 2330, 2336, 1, 0, 0, 0, 2331, 2332, 5, 42, 0, 0, 2332, 2333, 3, 32, 16, 0, 2333, 2334, 5, 43, 0, 0, 2334, 2336, 1, 0, 0, 0, 2335, 2330, 1, 0, 0, 0, 2335, 2331, 1, 0, 0, 0, 2336, 287, 1, 0, 0, 0, 2337, 2338, 5, 181, 0, 0, 2338, 2339, 5, 262, 0, 0, 2339, 2340, 5, 30, 0, 0, 2340, 2341, 3, 6, 3, 0, 2341, 2342, 5, 31, 0, 0, 2342, 2404, 1, 0, 0, 0, 2343, 2344, 5, 260, 0, 0, 2344, 2345, 5, 30, 0, 0, 2345, 2346, 3, 0, 0, 0, 2346, 2347, 5, 31, 0, 0, 2347, 2404, 1, 0, 0, 0, 2348, 2349, 5, 260, 0, 0, 2349, 2404, 3, 0, 0, 0, 2350, 2351, 5, 84, 0, 0, 2351, 2352, 5, 30, 0, 0, 2352, 2353, 3, 292, 146, 0, 2353, 2354, 5, 31, 0, 0, 2354, 2404, 1, 0, 0, 0, 2355, 2356, 5, 188, 0, 0, 2356, 2357, 5, 30, 0, 0, 2357, 2358, 3, 36, 18, 0, 2358, 2359, 5, 31, 0, 0, 2359, 2360, 3, 286, 143, 0, 2360, 2404, 1, 0, 0, 0, 2361, 2362, 5, 189, 0, 0, 2362, 2363, 5, 30, 0, 0, 2363, 2364, 3, 36, 18, 0, 2364, 2365, 5, 31, 0, 0, 2365, 2366, 3, 286, 143, 0, 2366, 2404, 1, 0, 0, 0, 2367, 2368, 5, 187, 0, 0, 2368, 2369, 5, 30, 0, 0, 2369, 2370, 3, 34, 17, 0, 2370, 2371, 5, 31, 0, 0, 2371, 2372, 3, 286, 143, 0, 2372, 2404, 1, 0, 0, 0, 2373, 2374, 5, 186, 0, 0, 2374, 2375, 5, 30, 0, 0, 2375, 2376, 3, 32, 16, 0, 2376, 2377, 5, 31, 0, 0, 2377, 2378, 3, 286, 143, 0, 2378, 2404, 1, 0, 0, 0, 2379, 2380, 5, 185, 0, 0, 2380, 2381, 5, 30, 0, 0, 2381, 2382, 3, 32, 16, 0, 2382, 2383, 5, 31, 0, 0, 2383, 2384, 3, 286, 143, 0, 2384, 2404, 1, 0, 0, 0, 2385, 2386, 5, 184, 0, 0, 2386, 2387, 5, 30, 0, 0, 2387, 2388, 3, 32, 16, 0, 2388, 2389, 5, 31, 0, 0, 2389, 2390, 3, 286, 143, 0, 2390, 2404, 1, 0, 0, 0, 2391, 2392, 5, 188, 0, 0, 2392, 2404, 3, 286, 143, 0, 2393, 2394, 5, 189, 0, 0, 2394, 2404, 3, 286, 143, 0, 2395, 2396, 5, 187, 0, 0, 2396, 2404, 3, 286, 143, 0, 2397, 2398, 5, 186, 0, 0, 2398, 2404, 3, 286, 143, 0, 2399, 2400, 5, 185, 0, 0, 2400, 2404, 3, 286, 143, 0, 2401, 2402, 5, 184, 0, 0, 2402, 2404, 3, 286, 143, 0, 2403, 2337, 1, 0, 0, 0, 2403, 2343, 1, 0, 0, 0, 2403, 2348, 1, 0, 0, 0, 2403, 2350, 1, 0, 0, 0, 2403, 2355, 1, 0, 0, 0, 2403, 2361, 1, 0, 0, 0, 2403, 2367, 1, 0, 0, 0, 2403, 2373, 1, 0, 0, 0, 2403, 2379, 1, 0, 0, 0, 2403, 2385, 1, 0, 0, 0, 2403, 2391, 1, 0, 0, 0, 2403, 2393, 1, 0, 0, 0, 2403, 2395, 1, 0, 0, 0, 2403, 2397, 1, 0, 0, 0, 2403, 2399, 1, 0, 0, 0, 2403, 2401, 1, 0, 0, 0, 2404, 289, 1, 0, 0, 0, 2405, 2406, 5, 188, 0, 0, 2406, 2407, 5, 30, 0, 0, 2407, 2408, 3, 36, 18, 0, 2408, 2409, 5, 31, 0, 0, 2409, 2481, 1, 0, 0, 0, 2410, 2411, 5, 189, 0, 0, 2411, 2412, 5, 30, 0, 0, 2412, 2413, 3, 36, 18, 0, 2413, 2414, 5, 31, 0, 0, 2414, 2481, 1, 0, 0, 0, 2415, 2416, 5, 188, 0, 0, 2416, 2417, 5, 30, 0, 0, 2417, 2418, 3, 32, 16, 0, 2418, 2419, 5, 31, 0, 0, 2419, 2481, 1, 0, 0, 0, 2420, 2421, 5, 189, 0, 0, 2421, 2422, 5, 30, 0, 0, 2422, 2423, 3, 34, 17, 0, 2423, 2424, 5, 31, 0, 0, 2424, 2481, 1, 0, 0, 0, 2425, 2426, 5, 187, 0, 0, 2426, 2427, 5, 30, 0, 0, 2427, 2428, 3, 34, 17, 0, 2428, 2429, 5, 31, 0, 0, 2429, 2481, 1, 0, 0, 0, 2430, 2431, 5, 186, 0, 0, 2431, 2432, 5, 30, 0, 0, 2432, 2433, 3, 32, 16, 0, 2433, 2434, 5, 31, 0, 0, 2434, 2481, 1, 0, 0, 0, 2435, 2436, 5, 185, 0, 0, 2436, 2437, 5, 30, 0, 0, 2437, 2438, 3, 32, 16, 0, 2438, 2439, 5, 31, 0, 0, 2439, 2481, 1, 0, 0, 0, 2440, 2441, 5, 184, 0, 0, 2441, 2442, 5, 30, 0, 0, 2442, 2443, 3, 32, 16, 0, 2443, 2444, 5, 31, 0, 0, 2444, 2481, 1, 0, 0, 0, 2445, 2446, 5, 193, 0, 0, 2446, 2447, 5, 30, 0, 0, 2447, 2448, 3, 34, 17, 0, 2448, 2449, 5, 31, 0, 0, 2449, 2481, 1, 0, 0, 0, 2450, 2451, 5, 192, 0, 0, 2451, 2452, 5, 30, 0, 0, 2452, 2453, 3, 32, 16, 0, 2453, 2454, 5, 31, 0, 0, 2454, 2481, 1, 0, 0, 0, 2455, 2456, 5, 191, 0, 0, 2456, 2457, 5, 30, 0, 0, 2457, 2458, 3, 32, 16, 0, 2458, 2459, 5, 31, 0, 0, 2459, 2481, 1, 0, 0, 0, 2460, 2461, 5, 190, 0, 0, 2461, 2462, 5, 30, 0, 0, 2462, 2463, 3, 32, 16, 0, 2463, 2464, 5, 31, 0, 0, 2464, 2481, 1, 0, 0, 0, 2465, 2466, 5, 181, 0, 0, 2466, 2467, 5, 30, 0, 0, 2467, 2468, 3, 32, 16, 0, 2468, 2469, 5, 31, 0, 0, 2469, 2481, 1, 0, 0, 0, 2470, 2471, 5, 183, 0, 0, 2471, 2472, 5, 30, 0, 0, 2472, 2473, 3, 162, 81, 0, 2473, 2474, 5, 31, 0, 0, 2474, 2481, 1, 0, 0, 0, 2475, 2476, 5, 84, 0, 0, 2476, 2477, 5, 30, 0, 0, 2477, 2478, 3, 292, 146, 0, 2478, 2479, 5, 31, 0, 0, 2479, 2481, 1, 0, 0, 0, 2480, 2405, 1, 0, 0, 0, 2480, 2410, 1, 0, 0, 0, 2480, 2415, 1, 0, 0, 0, 2480, 2420, 1, 0, 0, 0, 2480, 2425, 1, 0, 0, 0, 2480, 2430, 1, 0, 0, 0, 2480, 2435, 1, 0, 0, 0, 2480, 2440, 1, 0, 0, 0, 2480, 2445, 1, 0, 0, 0, 2480, 2450, 1, 0, 0, 0, 2480, 2455, 1, 0, 0, 0, 2480, 2460, 1, 0, 0, 0, 2480, 2465, 1, 0, 0, 0, 2480, 2470, 1, 0, 0, 0, 2480, 2475, 1, 0, 0, 0, 2481, 291, 1, 0, 0, 0, 2482, 2483, 3, 294, 147, 0, 2483, 2484, 6, 146, -1, 0, 2484, 2486, 1, 0, 0, 0, 2485, 2482, 1, 0, 0, 0, 2486, 2489, 1, 0, 0, 0, 2487, 2485, 1, 0, 0, 0, 2487, 2488, 1, 0, 0, 0, 2488, 293, 1, 0, 0, 0, 2489, 2487, 1, 0, 0, 0, 2490, 2491, 7, 12, 0, 0, 2491, 295, 1, 0, 0, 0, 2492, 2496, 3, 290, 145, 0, 2493, 2496, 3, 6, 3, 0, 2494, 2496, 5, 179, 0, 0, 2495, 2492, 1, 0, 0, 0, 2495, 2493, 1, 0, 0, 0, 2495, 2494, 1, 0, 0, 0, 2496, 297, 1, 0, 0, 0, 2497, 2646, 3, 290, 145, 0, 2498, 2499, 5, 182, 0, 0, 2499, 2500, 5, 30, 0, 0, 2500, 2501, 5, 179, 0, 0, 2501, 2646, 5, 31, 0, 0, 2502, 2503, 5, 182, 0, 0, 2503, 2504, 5, 30, 0, 0, 2504, 2505, 5, 264, 0, 0, 2505, 2646, 5, 31, 0, 0, 2506, 2507, 5, 196, 0, 0, 2507, 2508, 5, 30, 0, 0, 2508, 2509, 5, 39, 0, 0, 2509, 2510, 5, 264, 0, 0, 2510, 2646, 5, 31, 0, 0, 2511, 2512, 5, 196, 0, 0, 2512, 2513, 5, 30, 0, 0, 2513, 2514, 3, 116, 58, 0, 2514, 2515, 5, 31, 0, 0, 2515, 2646, 1, 0, 0, 0, 2516, 2517, 5, 196, 0, 0, 2517, 2518, 5, 30, 0, 0, 2518, 2519, 5, 179, 0, 0, 2519, 2646, 5, 31, 0, 0, 2520, 2521, 5, 197, 0, 0, 2521, 2522, 5, 30, 0, 0, 2522, 2523, 3, 298, 149, 0, 2523, 2524, 5, 31, 0, 0, 2524, 2646, 1, 0, 0, 0, 2525, 2526, 5, 188, 0, 0, 2526, 2527, 5, 42, 0, 0, 2527, 2528, 3, 32, 16, 0, 2528, 2529, 5, 43, 0, 0, 2529, 2530, 5, 30, 0, 0, 2530, 2531, 3, 300, 150, 0, 2531, 2532, 5, 31, 0, 0, 2532, 2646, 1, 0, 0, 0, 2533, 2534, 5, 189, 0, 0, 2534, 2535, 5, 42, 0, 0, 2535, 2536, 3, 32, 16, 0, 2536, 2537, 5, 43, 0, 0, 2537, 2538, 5, 30, 0, 0, 2538, 2539, 3, 302, 151, 0, 2539, 2540, 5, 31, 0, 0, 2540, 2646, 1, 0, 0, 0, 2541, 2542, 5, 187, 0, 0, 2542, 2543, 5, 42, 0, 0, 2543, 2544, 3, 32, 16, 0, 2544, 2545, 5, 43, 0, 0, 2545, 2546, 5, 30, 0, 0, 2546, 2547, 3, 304, 152, 0, 2547, 2548, 5, 31, 0, 0, 2548, 2646, 1, 0, 0, 0, 2549, 2550, 5, 186, 0, 0, 2550, 2551, 5, 42, 0, 0, 2551, 2552, 3, 32, 16, 0, 2552, 2553, 5, 43, 0, 0, 2553, 2554, 5, 30, 0, 0, 2554, 2555, 3, 306, 153, 0, 2555, 2556, 5, 31, 0, 0, 2556, 2646, 1, 0, 0, 0, 2557, 2558, 5, 185, 0, 0, 2558, 2559, 5, 42, 0, 0, 2559, 2560, 3, 32, 16, 0, 2560, 2561, 5, 43, 0, 0, 2561, 2562, 5, 30, 0, 0, 2562, 2563, 3, 308, 154, 0, 2563, 2564, 5, 31, 0, 0, 2564, 2646, 1, 0, 0, 0, 2565, 2566, 5, 184, 0, 0, 2566, 2567, 5, 42, 0, 0, 2567, 2568, 3, 32, 16, 0, 2568, 2569, 5, 43, 0, 0, 2569, 2570, 5, 30, 0, 0, 2570, 2571, 3, 310, 155, 0, 2571, 2572, 5, 31, 0, 0, 2572, 2646, 1, 0, 0, 0, 2573, 2574, 5, 193, 0, 0, 2574, 2575, 5, 42, 0, 0, 2575, 2576, 3, 32, 16, 0, 2576, 2577, 5, 43, 0, 0, 2577, 2578, 5, 30, 0, 0, 2578, 2579, 3, 304, 152, 0, 2579, 2580, 5, 31, 0, 0, 2580, 2646, 1, 0, 0, 0, 2581, 2582, 5, 192, 0, 0, 2582, 2583, 5, 42, 0, 0, 2583, 2584, 3, 32, 16, 0, 2584, 2585, 5, 43, 0, 0, 2585, 2586, 5, 30, 0, 0, 2586, 2587, 3, 306, 153, 0, 2587, 2588, 5, 31, 0, 0, 2588, 2646, 1, 0, 0, 0, 2589, 2590, 5, 191, 0, 0, 2590, 2591, 5, 42, 0, 0, 2591, 2592, 3, 32, 16, 0, 2592, 2593, 5, 43, 0, 0, 2593, 2594, 5, 30, 0, 0, 2594, 2595, 3, 308, 154, 0, 2595, 2596, 5, 31, 0, 0, 2596, 2646, 1, 0, 0, 0, 2597, 2598, 5, 190, 0, 0, 2598, 2599, 5, 42, 0, 0, 2599, 2600, 3, 32, 16, 0, 2600, 2601, 5, 43, 0, 0, 2601, 2602, 5, 30, 0, 0, 2602, 2603, 3, 310, 155, 0, 2603, 2604, 5, 31, 0, 0, 2604, 2646, 1, 0, 0, 0, 2605, 2606, 5, 181, 0, 0, 2606, 2607, 5, 42, 0, 0, 2607, 2608, 3, 32, 16, 0, 2608, 2609, 5, 43, 0, 0, 2609, 2610, 5, 30, 0, 0, 2610, 2611, 3, 308, 154, 0, 2611, 2612, 5, 31, 0, 0, 2612, 2646, 1, 0, 0, 0, 2613, 2614, 5, 183, 0, 0, 2614, 2615, 5, 42, 0, 0, 2615, 2616, 3, 32, 16, 0, 2616, 2617, 5, 43, 0, 0, 2617, 2618, 5, 30, 0, 0, 2618, 2619, 3, 312, 156, 0, 2619, 2620, 5, 31, 0, 0, 2620, 2646, 1, 0, 0, 0, 2621, 2622, 5, 182, 0, 0, 2622, 2623, 5, 42, 0, 0, 2623, 2624, 3, 32, 16, 0, 2624, 2625, 5, 43, 0, 0, 2625, 2626, 5, 30, 0, 0, 2626, 2627, 3, 314, 157, 0, 2627, 2628, 5, 31, 0, 0, 2628, 2646, 1, 0, 0, 0, 2629, 2630, 5, 196, 0, 0, 2630, 2631, 5, 42, 0, 0, 2631, 2632, 3, 32, 16, 0, 2632, 2633, 5, 43, 0, 0, 2633, 2634, 5, 30, 0, 0, 2634, 2635, 3, 316, 158, 0, 2635, 2636, 5, 31, 0, 0, 2636, 2646, 1, 0, 0, 0, 2637, 2638, 5, 197, 0, 0, 2638, 2639, 5, 42, 0, 0, 2639, 2640, 3, 32, 16, 0, 2640, 2641, 5, 43, 0, 0, 2641, 2642, 5, 30, 0, 0, 2642, 2643, 3, 320, 160, 0, 2643, 2644, 5, 31, 0, 0, 2644, 2646, 1, 0, 0, 0, 2645, 2497, 1, 0, 0, 0, 2645, 2498, 1, 0, 0, 0, 2645, 2502, 1, 0, 0, 0, 2645, 2506, 1, 0, 0, 0, 2645, 2511, 1, 0, 0, 0, 2645, 2516, 1, 0, 0, 0, 2645, 2520, 1, 0, 0, 0, 2645, 2525, 1, 0, 0, 0, 2645, 2533, 1, 0, 0, 0, 2645, 2541, 1, 0, 0, 0, 2645, 2549, 1, 0, 0, 0, 2645, 2557, 1, 0, 0, 0, 2645, 2565, 1, 0, 0, 0, 2645, 2573, 1, 0, 0, 0, 2645, 2581, 1, 0, 0, 0, 2645, 2589, 1, 0, 0, 0, 2645, 2597, 1, 0, 0, 0, 2645, 2605, 1, 0, 0, 0, 2645, 2613, 1, 0, 0, 0, 2645, 2621, 1, 0, 0, 0, 2645, 2629, 1, 0, 0, 0, 2645, 2637, 1, 0, 0, 0, 2646, 299, 1, 0, 0, 0, 2647, 2650, 3, 36, 18, 0, 2648, 2650, 3, 32, 16, 0, 2649, 2647, 1, 0, 0, 0, 2649, 2648, 1, 0, 0, 0, 2650, 2653, 1, 0, 0, 0, 2651, 2649, 1, 0, 0, 0, 2651, 2652, 1, 0, 0, 0, 2652, 301, 1, 0, 0, 0, 2653, 2651, 1, 0, 0, 0, 2654, 2657, 3, 36, 18, 0, 2655, 2657, 3, 34, 17, 0, 2656, 2654, 1, 0, 0, 0, 2656, 2655, 1, 0, 0, 0, 2657, 2660, 1, 0, 0, 0, 2658, 2656, 1, 0, 0, 0, 2658, 2659, 1, 0, 0, 0, 2659, 303, 1, 0, 0, 0, 2660, 2658, 1, 0, 0, 0, 2661, 2663, 3, 34, 17, 0, 2662, 2661, 1, 0, 0, 0, 2663, 2666, 1, 0, 0, 0, 2664, 2662, 1, 0, 0, 0, 2664, 2665, 1, 0, 0, 0, 2665, 305, 1, 0, 0, 0, 2666, 2664, 1, 0, 0, 0, 2667, 2669, 3, 32, 16, 0, 2668, 2667, 1, 0, 0, 0, 2669, 2672, 1, 0, 0, 0, 2670, 2668, 1, 0, 0, 0, 2670, 2671, 1, 0, 0, 0, 2671, 307, 1, 0, 0, 0, 2672, 2670, 1, 0, 0, 0, 2673, 2675, 3, 32, 16, 0, 2674, 2673, 1, 0, 0, 0, 2675, 2678, 1, 0, 0, 0, 2676, 2674, 1, 0, 0, 0, 2676, 2677, 1, 0, 0, 0, 2677, 309, 1, 0, 0, 0, 2678, 2676, 1, 0, 0, 0, 2679, 2681, 3, 32, 16, 0, 2680, 2679, 1, 0, 0, 0, 2681, 2684, 1, 0, 0, 0, 2682, 2680, 1, 0, 0, 0, 2682, 2683, 1, 0, 0, 0, 2683, 311, 1, 0, 0, 0, 2684, 2682, 1, 0, 0, 0, 2685, 2687, 3, 162, 81, 0, 2686, 2685, 1, 0, 0, 0, 2687, 2690, 1, 0, 0, 0, 2688, 2686, 1, 0, 0, 0, 2688, 2689, 1, 0, 0, 0, 2689, 313, 1, 0, 0, 0, 2690, 2688, 1, 0, 0, 0, 2691, 2693, 7, 13, 0, 0, 2692, 2691, 1, 0, 0, 0, 2693, 2696, 1, 0, 0, 0, 2694, 2692, 1, 0, 0, 0, 2694, 2695, 1, 0, 0, 0, 2695, 315, 1, 0, 0, 0, 2696, 2694, 1, 0, 0, 0, 2697, 2699, 3, 318, 159, 0, 2698, 2697, 1, 0, 0, 0, 2699, 2702, 1, 0, 0, 0, 2700, 2698, 1, 0, 0, 0, 2700, 2701, 1, 0, 0, 0, 2701, 317, 1, 0, 0, 0, 2702, 2700, 1, 0, 0, 0, 2703, 2708, 5, 179, 0, 0, 2704, 2705, 5, 39, 0, 0, 2705, 2708, 5, 264, 0, 0, 2706, 2708, 3, 116, 58, 0, 2707, 2703, 1, 0, 0, 0, 2707, 2704, 1, 0, 0, 0, 2707, 2706, 1, 0, 0, 0, 2708, 319, 1, 0, 0, 0, 2709, 2711, 3, 298, 149, 0, 2710, 2709, 1, 0, 0, 0, 2711, 2714, 1, 0, 0, 0, 2712, 2710, 1, 0, 0, 0, 2712, 2713, 1, 0, 0, 0, 2713, 321, 1, 0, 0, 0, 2714, 2712, 1, 0, 0, 0, 2715, 2719, 3, 44, 22, 0, 2716, 2719, 3, 46, 23, 0, 2717, 2719, 3, 2, 1, 0, 2718, 2715, 1, 0, 0, 0, 2718, 2716, 1, 0, 0, 0, 2718, 2717, 1, 0, 0, 0, 2719, 323, 1, 0, 0, 0, 2720, 2721, 7, 14, 0, 0, 2721, 2722, 5, 36, 0, 0, 2722, 2723, 5, 30, 0, 0, 2723, 2724, 3, 292, 146, 0, 2724, 2725, 5, 31, 0, 0, 2725, 2746, 1, 0, 0, 0, 2726, 2727, 5, 169, 0, 0, 2727, 2728, 3, 38, 19, 0, 2728, 2729, 5, 75, 0, 0, 2729, 2730, 3, 38, 19, 0, 2730, 2731, 5, 75, 0, 0, 2731, 2732, 3, 38, 19, 0, 2732, 2733, 5, 75, 0, 0, 2733, 2734, 3, 38, 19, 0, 2734, 2746, 1, 0, 0, 0, 2735, 2736, 5, 170, 0, 0, 2736, 2746, 3, 6, 3, 0, 2737, 2738, 5, 170, 0, 0, 2738, 2739, 5, 36, 0, 0, 2739, 2740, 5, 30, 0, 0, 2740, 2741, 3, 292, 146, 0, 2741, 2742, 5, 31, 0, 0, 2742, 2746, 1, 0, 0, 0, 2743, 2746, 3, 322, 161, 0, 2744, 2746, 3, 40, 20, 0, 2745, 2720, 1, 0, 0, 0, 2745, 2726, 1, 0, 0, 0, 2745, 2735, 1, 0, 0, 0, 2745, 2737, 1, 0, 0, 0, 2745, 2743, 1, 0, 0, 0, 2745, 2744, 1, 0, 0, 0, 2746, 325, 1, 0, 0, 0, 2747, 2748, 5, 25, 0, 0, 2748, 2749, 5, 40, 0, 0, 2749, 2750, 3, 98, 49, 0, 2750, 2751, 3, 2, 1, 0, 2751, 2760, 1, 0, 0, 0, 2752, 2753, 5, 25, 0, 0, 2753, 2754, 5, 40, 0, 0, 2754, 2755, 3, 98, 49, 0, 2755, 2756, 3, 2, 1, 0, 2756, 2757, 5, 34, 0, 0, 2757, 2758, 3, 2, 1, 0, 2758, 2760, 1, 0, 0, 0, 2759, 2747, 1, 0, 0, 0, 2759, 2752, 1, 0, 0, 0, 2760, 327, 1, 0, 0, 0, 2761, 2763, 3, 330, 165, 0, 2762, 2761, 1, 0, 0, 0, 2763, 2766, 1, 0, 0, 0, 2764, 2762, 1, 0, 0, 0, 2764, 2765, 1, 0, 0, 0, 2765, 329, 1, 0, 0, 0, 2766, 2764, 1, 0, 0, 0, 2767, 2768, 5, 180, 0, 0, 2768, 2769, 5, 36, 0, 0, 2769, 2770, 5, 30, 0, 0, 2770, 2771, 3, 292, 146, 0, 2771, 2772, 5, 31, 0, 0, 2772, 2782, 1, 0, 0, 0, 2773, 2782, 3, 324, 162, 0, 2774, 2775, 5, 171, 0, 0, 2775, 2776, 5, 36, 0, 0, 2776, 2777, 5, 30, 0, 0, 2777, 2778, 3, 292, 146, 0, 2778, 2779, 5, 31, 0, 0, 2779, 2782, 1, 0, 0, 0, 2780, 2782, 5, 55, 0, 0, 2781, 2767, 1, 0, 0, 0, 2781, 2773, 1, 0, 0, 0, 2781, 2774, 1, 0, 0, 0, 2781, 2780, 1, 0, 0, 0, 2782, 331, 1, 0, 0, 0, 2783, 2784, 5, 50, 0, 0, 2784, 2788, 5, 40, 0, 0, 2785, 2787, 3, 336, 168, 0, 2786, 2785, 1, 0, 0, 0, 2787, 2790, 1, 0, 0, 0, 2788, 2786, 1, 0, 0, 0, 2788, 2789, 1, 0, 0, 0, 2789, 2791, 1, 0, 0, 0, 2790, 2788, 1, 0, 0, 0, 2791, 2792, 3, 2, 1, 0, 2792, 333, 1, 0, 0, 0, 2793, 2797, 5, 301, 0, 0, 2794, 2796, 3, 336, 168, 0, 2795, 2794, 1, 0, 0, 0, 2796, 2799, 1, 0, 0, 0, 2797, 2795, 1, 0, 0, 0, 2797, 2798, 1, 0, 0, 0, 2798, 2800, 1, 0, 0, 0, 2799, 2797, 1, 0, 0, 0, 2800, 2801, 3, 2, 1, 0, 2801, 335, 1, 0, 0, 0, 2802, 2818, 5, 52, 0, 0, 2803, 2818, 5, 51, 0, 0, 2804, 2818, 5, 172, 0, 0, 2805, 2806, 5, 62, 0, 0, 2806, 2818, 5, 51, 0, 0, 2807, 2808, 5, 62, 0, 0, 2808, 2818, 5, 52, 0, 0, 2809, 2810, 5, 62, 0, 0, 2810, 2818, 5, 63, 0, 0, 2811, 2812, 5, 62, 0, 0, 2812, 2818, 5, 64, 0, 0, 2813, 2814, 5, 62, 0, 0, 2814, 2818, 5, 65, 0, 0, 2815, 2816, 5, 62, 0, 0, 2816, 2818, 5, 66, 0, 0, 2817, 2802, 1, 0, 0, 0, 2817, 2803, 1, 0, 0, 0, 2817, 2804, 1, 0, 0, 0, 2817, 2805, 1, 0, 0, 0, 2817, 2807, 1, 0, 0, 0, 2817, 2809, 1, 0, 0, 0, 2817, 2811, 1, 0, 0, 0, 2817, 2813, 1, 0, 0, 0, 2817, 2815, 1, 0, 0, 0, 2818, 337, 1, 0, 0, 0, 2819, 2821, 3, 340, 170, 0, 2820, 2819, 1, 0, 0, 0, 2821, 2824, 1, 0, 0, 0, 2822, 2820, 1, 0, 0, 0, 2822, 2823, 1, 0, 0, 0, 2823, 339, 1, 0, 0, 0, 2824, 2822, 1, 0, 0, 0, 2825, 2826, 5, 21, 0, 0, 2826, 2839, 3, 2, 1, 0, 2827, 2828, 5, 50, 0, 0, 2828, 2829, 5, 40, 0, 0, 2829, 2839, 3, 118, 59, 0, 2830, 2831, 5, 25, 0, 0, 2831, 2832, 5, 40, 0, 0, 2832, 2839, 3, 2, 1, 0, 2833, 2839, 3, 174, 87, 0, 2834, 2835, 5, 50, 0, 0, 2835, 2839, 3, 32, 16, 0, 2836, 2839, 3, 322, 161, 0, 2837, 2839, 3, 40, 20, 0, 2838, 2825, 1, 0, 0, 0, 2838, 2827, 1, 0, 0, 0, 2838, 2830, 1, 0, 0, 0, 2838, 2833, 1, 0, 0, 0, 2838, 2834, 1, 0, 0, 0, 2838, 2836, 1, 0, 0, 0, 2838, 2837, 1, 0, 0, 0, 2839, 341, 1, 0, 0, 0, 2840, 2844, 5, 274, 0, 0, 2841, 2843, 3, 344, 172, 0, 2842, 2841, 1, 0, 0, 0, 2843, 2846, 1, 0, 0, 0, 2844, 2842, 1, 0, 0, 0, 2844, 2845, 1, 0, 0, 0, 2845, 2847, 1, 0, 0, 0, 2846, 2844, 1, 0, 0, 0, 2847, 2860, 3, 2, 1, 0, 2848, 2852, 5, 274, 0, 0, 2849, 2851, 3, 344, 172, 0, 2850, 2849, 1, 0, 0, 0, 2851, 2854, 1, 0, 0, 0, 2852, 2850, 1, 0, 0, 0, 2852, 2853, 1, 0, 0, 0, 2853, 2855, 1, 0, 0, 0, 2854, 2852, 1, 0, 0, 0, 2855, 2856, 3, 2, 1, 0, 2856, 2857, 5, 34, 0, 0, 2857, 2858, 3, 2, 1, 0, 2858, 2860, 1, 0, 0, 0, 2859, 2840, 1, 0, 0, 0, 2859, 2848, 1, 0, 0, 0, 2860, 343, 1, 0, 0, 0, 2861, 2862, 7, 15, 0, 0, 2862, 345, 1, 0, 0, 0, 2863, 2865, 3, 348, 174, 0, 2864, 2863, 1, 0, 0, 0, 2865, 2868, 1, 0, 0, 0, 2866, 2864, 1, 0, 0, 0, 2866, 2867, 1, 0, 0, 0, 2867, 347, 1, 0, 0, 0, 2868, 2866, 1, 0, 0, 0, 2869, 2870, 5, 21, 0, 0, 2870, 2871, 3, 2, 1, 0, 2871, 2872, 5, 44, 0, 0, 2872, 2873, 3, 32, 16, 0, 2873, 2880, 1, 0, 0, 0, 2874, 2875, 5, 25, 0, 0, 2875, 2876, 5, 40, 0, 0, 2876, 2880, 3, 2, 1, 0, 2877, 2880, 3, 322, 161, 0, 2878, 2880, 3, 40, 20, 0, 2879, 2869, 1, 0, 0, 0, 2879, 2874, 1, 0, 0, 0, 2879, 2877, 1, 0, 0, 0, 2879, 2878, 1, 0, 0, 0, 2880, 349, 1, 0, 0, 0, 175, 358, 363, 371, 379, 432, 473, 482, 506, 510, 528, 555, 578, 614, 620, 627, 629, 639, 641, 648, 659, 667, 688, 690, 706, 751, 756, 761, 766, 774, 884, 890, 906, 912, 918, 925, 930, 982, 1018, 1023, 1029, 1034, 1036, 1044, 1056, 1068, 1075, 1082, 1084, 1111, 1118, 1126, 1134, 1147, 1154, 1157, 1176, 1270, 1279, 1286, 1289, 1297, 1318, 1350, 1373, 1385, 1394, 1419, 1443, 1451, 1455, 1470, 1477, 1522, 1532, 1548, 1560, 1572, 1586, 1598, 1609, 1616, 1626, 1639, 1644, 1649, 1658, 1669, 1752, 1761, 1774, 1785, 1793, 1803, 1805, 1832, 1839, 1844, 1851, 1857, 1867, 1871, 1878, 1893, 1899, 1913, 1926, 1934, 1941, 1945, 1950, 1966, 1971, 1973, 1986, 2012, 2019, 2021, 2026, 2032, 2061, 2066, 2089, 2094, 2114, 2167, 2176, 2189, 2200, 2211, 2214, 2222, 2234, 2248, 2262, 2270, 2290, 2302, 2307, 2316, 2318, 2325, 2335, 2403, 2480, 2487, 2495, 2645, 2649, 2651, 2656, 2658, 2664, 2670, 2676, 2682, 2688, 2694, 2700, 2707, 2712, 2718, 2745, 2759, 2764, 2781, 2788, 2797, 2817, 2822, 2838, 2844, 2852, 2859, 2866, 2879] \ No newline at end of file diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILBaseVisitor.cs b/src/tools/ilasm/src/ILAssembler/gen/CILBaseVisitor.cs index c63f1eb59ad7f8..d7bf5587d2bfbb 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILBaseVisitor.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILBaseVisitor.cs @@ -536,117 +536,7 @@ public partial class CILBaseVisitor : AbstractParseTreeVisitor, /// The visitor result. public virtual Result VisitAsmAttr([NotNull] CILParser.AsmAttrContext context) { return VisitChildren(context); } /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitInstr_none([NotNull] CILParser.Instr_noneContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitInstr_var([NotNull] CILParser.Instr_varContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitInstr_i([NotNull] CILParser.Instr_iContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitInstr_i8([NotNull] CILParser.Instr_i8Context context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitInstr_r([NotNull] CILParser.Instr_rContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitInstr_brtarget([NotNull] CILParser.Instr_brtargetContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitInstr_method([NotNull] CILParser.Instr_methodContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitInstr_field([NotNull] CILParser.Instr_fieldContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitInstr_type([NotNull] CILParser.Instr_typeContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitInstr_string([NotNull] CILParser.Instr_stringContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitInstr_sig([NotNull] CILParser.Instr_sigContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . + /// Visit a parse tree produced by . /// /// The default implementation returns the result of calling /// on . @@ -654,9 +544,9 @@ public partial class CILBaseVisitor : AbstractParseTreeVisitor, /// /// The parse tree. /// The visitor result. - public virtual Result VisitInstr_tok([NotNull] CILParser.Instr_tokContext context) { return VisitChildren(context); } + public virtual Result VisitInstr([NotNull] CILParser.InstrContext context) { return VisitChildren(context); } /// - /// Visit a parse tree produced by . + /// Visit a parse tree produced by . /// /// The default implementation returns the result of calling /// on . @@ -664,9 +554,9 @@ public partial class CILBaseVisitor : AbstractParseTreeVisitor, /// /// The parse tree. /// The visitor result. - public virtual Result VisitInstr_switch([NotNull] CILParser.Instr_switchContext context) { return VisitChildren(context); } + public virtual Result VisitSimpleInstr([NotNull] CILParser.SimpleInstrContext context) { return VisitChildren(context); } /// - /// Visit a parse tree produced by . + /// Visit a parse tree produced by . /// /// The default implementation returns the result of calling /// on . @@ -674,7 +564,7 @@ public partial class CILBaseVisitor : AbstractParseTreeVisitor, /// /// The parse tree. /// The visitor result. - public virtual Result VisitInstr([NotNull] CILParser.InstrContext context) { return VisitChildren(context); } + public virtual Result VisitInstructionIsland([NotNull] CILParser.InstructionIslandContext context) { return VisitChildren(context); } /// /// Visit a parse tree produced by . /// @@ -1519,6 +1409,16 @@ public partial class CILBaseVisitor : AbstractParseTreeVisitor, /// The visitor result. public virtual Result VisitMethodDecl([NotNull] CILParser.MethodDeclContext context) { return VisitChildren(context); } /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitMethodDeclIsland([NotNull] CILParser.MethodDeclIslandContext context) { return VisitChildren(context); } + /// /// Visit a parse tree produced by . /// /// The default implementation returns the result of calling diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs index b1fa36806bdf55..e746b430def880 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs @@ -102,44 +102,42 @@ public const int RULE_classHead = 37, RULE_classAttr = 38, RULE_extendsClause = 39, RULE_implClause = 40, RULE_classDecls = 41, RULE_implList = 42, RULE_esHead = 43, RULE_extSourceSpec = 44, RULE_fileDecl = 45, RULE_fileAttr = 46, RULE_fileEntry = 47, RULE_asmAttrAny = 48, - RULE_asmAttr = 49, RULE_instr_none = 50, RULE_instr_var = 51, RULE_instr_i = 52, - RULE_instr_i8 = 53, RULE_instr_r = 54, RULE_instr_brtarget = 55, RULE_instr_method = 56, - RULE_instr_field = 57, RULE_instr_type = 58, RULE_instr_string = 59, RULE_instr_sig = 60, - RULE_instr_tok = 61, RULE_instr_switch = 62, RULE_instr = 63, RULE_labels = 64, - RULE_typeArgs = 65, RULE_bounds = 66, RULE_sigArgs = 67, RULE_sigArg = 68, - RULE_className = 69, RULE_slashedName = 70, RULE_assemblyDecls = 71, RULE_assemblyDecl = 72, - RULE_typeSpec = 73, RULE_nativeType = 74, RULE_nativeTypeArrayPointerInfo = 75, - RULE_nativeTypeElement = 76, RULE_iidParamIndex = 77, RULE_variantType = 78, - RULE_variantTypeElement = 79, RULE_type = 80, RULE_typeModifiers = 81, - RULE_elementType = 82, RULE_simpleType = 83, RULE_bound = 84, RULE_nativeInt = 85, - RULE_nativeUint = 86, RULE_secDecl = 87, RULE_secAttrSetBlob = 88, RULE_secAttrBlob = 89, - RULE_nameValPairs = 90, RULE_nameValPair = 91, RULE_truefalse = 92, RULE_caValue = 93, - RULE_secAction = 94, RULE_methodRef = 95, RULE_callConv = 96, RULE_callKind = 97, - RULE_mdtoken = 98, RULE_memberRef = 99, RULE_fieldRef = 100, RULE_typeList = 101, - RULE_typarsClause = 102, RULE_typarAttrib = 103, RULE_typarAttribs = 104, - RULE_typar = 105, RULE_typars = 106, RULE_tyBound = 107, RULE_genArity = 108, - RULE_genArityNotEmpty = 109, RULE_classDecl = 110, RULE_fieldDecl = 111, - RULE_fieldAttr = 112, RULE_atOpt = 113, RULE_initOpt = 114, RULE_repeatOpt = 115, - RULE_eventHead = 116, RULE_eventAttr = 117, RULE_eventDecls = 118, RULE_eventDecl = 119, - RULE_propHead = 120, RULE_propAttr = 121, RULE_propDecls = 122, RULE_propDecl = 123, - RULE_marshalClause = 124, RULE_marshalBlob = 125, RULE_paramAttr = 126, - RULE_paramAttrElement = 127, RULE_methodHead = 128, RULE_methAttr = 129, - RULE_pinvImpl = 130, RULE_pinvAttr = 131, RULE_methodName = 132, RULE_implAttr = 133, - RULE_methodDecls = 134, RULE_methodDecl = 135, RULE_labelDecl = 136, RULE_customDescrInMethodBody = 137, - RULE_scopeBlock = 138, RULE_sehBlock = 139, RULE_sehClauses = 140, RULE_tryBlock = 141, - RULE_sehClause = 142, RULE_filterClause = 143, RULE_catchClause = 144, - RULE_finallyClause = 145, RULE_faultClause = 146, RULE_handlerBlock = 147, - RULE_dataDecl = 148, RULE_ddHead = 149, RULE_tls = 150, RULE_ddBody = 151, - RULE_ddItemList = 152, RULE_ddItemCount = 153, RULE_ddItem = 154, RULE_fieldSerInit = 155, - RULE_bytes = 156, RULE_hexbyte = 157, RULE_fieldInit = 158, RULE_serInit = 159, - RULE_f32seq = 160, RULE_f64seq = 161, RULE_i64seq = 162, RULE_i32seq = 163, - RULE_i16seq = 164, RULE_i8seq = 165, RULE_boolSeq = 166, RULE_sqstringSeq = 167, - RULE_classSeq = 168, RULE_classSeqElement = 169, RULE_objSeq = 170, RULE_customAttrDecl = 171, - RULE_asmOrRefDecl = 172, RULE_assemblyRefHead = 173, RULE_assemblyRefDecls = 174, - RULE_assemblyRefDecl = 175, RULE_exptypeHead = 176, RULE_exportHead = 177, - RULE_exptAttr = 178, RULE_exptypeDecls = 179, RULE_exptypeDecl = 180, - RULE_manifestResHead = 181, RULE_manresAttr = 182, RULE_manifestResDecls = 183, - RULE_manifestResDecl = 184; + RULE_asmAttr = 49, RULE_instr = 50, RULE_simpleInstr = 51, RULE_instructionIsland = 52, + RULE_labels = 53, RULE_typeArgs = 54, RULE_bounds = 55, RULE_sigArgs = 56, + RULE_sigArg = 57, RULE_className = 58, RULE_slashedName = 59, RULE_assemblyDecls = 60, + RULE_assemblyDecl = 61, RULE_typeSpec = 62, RULE_nativeType = 63, RULE_nativeTypeArrayPointerInfo = 64, + RULE_nativeTypeElement = 65, RULE_iidParamIndex = 66, RULE_variantType = 67, + RULE_variantTypeElement = 68, RULE_type = 69, RULE_typeModifiers = 70, + RULE_elementType = 71, RULE_simpleType = 72, RULE_bound = 73, RULE_nativeInt = 74, + RULE_nativeUint = 75, RULE_secDecl = 76, RULE_secAttrSetBlob = 77, RULE_secAttrBlob = 78, + RULE_nameValPairs = 79, RULE_nameValPair = 80, RULE_truefalse = 81, RULE_caValue = 82, + RULE_secAction = 83, RULE_methodRef = 84, RULE_callConv = 85, RULE_callKind = 86, + RULE_mdtoken = 87, RULE_memberRef = 88, RULE_fieldRef = 89, RULE_typeList = 90, + RULE_typarsClause = 91, RULE_typarAttrib = 92, RULE_typarAttribs = 93, + RULE_typar = 94, RULE_typars = 95, RULE_tyBound = 96, RULE_genArity = 97, + RULE_genArityNotEmpty = 98, RULE_classDecl = 99, RULE_fieldDecl = 100, + RULE_fieldAttr = 101, RULE_atOpt = 102, RULE_initOpt = 103, RULE_repeatOpt = 104, + RULE_eventHead = 105, RULE_eventAttr = 106, RULE_eventDecls = 107, RULE_eventDecl = 108, + RULE_propHead = 109, RULE_propAttr = 110, RULE_propDecls = 111, RULE_propDecl = 112, + RULE_marshalClause = 113, RULE_marshalBlob = 114, RULE_paramAttr = 115, + RULE_paramAttrElement = 116, RULE_methodHead = 117, RULE_methAttr = 118, + RULE_pinvImpl = 119, RULE_pinvAttr = 120, RULE_methodName = 121, RULE_implAttr = 122, + RULE_methodDecls = 123, RULE_methodDecl = 124, RULE_methodDeclIsland = 125, + RULE_labelDecl = 126, RULE_customDescrInMethodBody = 127, RULE_scopeBlock = 128, + RULE_sehBlock = 129, RULE_sehClauses = 130, RULE_tryBlock = 131, RULE_sehClause = 132, + RULE_filterClause = 133, RULE_catchClause = 134, RULE_finallyClause = 135, + RULE_faultClause = 136, RULE_handlerBlock = 137, RULE_dataDecl = 138, + RULE_ddHead = 139, RULE_tls = 140, RULE_ddBody = 141, RULE_ddItemList = 142, + RULE_ddItemCount = 143, RULE_ddItem = 144, RULE_fieldSerInit = 145, RULE_bytes = 146, + RULE_hexbyte = 147, RULE_fieldInit = 148, RULE_serInit = 149, RULE_f32seq = 150, + RULE_f64seq = 151, RULE_i64seq = 152, RULE_i32seq = 153, RULE_i16seq = 154, + RULE_i8seq = 155, RULE_boolSeq = 156, RULE_sqstringSeq = 157, RULE_classSeq = 158, + RULE_classSeqElement = 159, RULE_objSeq = 160, RULE_customAttrDecl = 161, + RULE_asmOrRefDecl = 162, RULE_assemblyRefHead = 163, RULE_assemblyRefDecls = 164, + RULE_assemblyRefDecl = 165, RULE_exptypeHead = 166, RULE_exportHead = 167, + RULE_exptAttr = 168, RULE_exptypeDecls = 169, RULE_exptypeDecl = 170, + RULE_manifestResHead = 171, RULE_manresAttr = 172, RULE_manifestResDecls = 173, + RULE_manifestResDecl = 174; public static readonly string[] ruleNames = { "id", "dottedName", "dottedNamePart", "compQstring", "decls", "decl", "subsystem", "corflags", "alignment", "imagebase", "stackreserve", "assemblyBlock", @@ -150,22 +148,20 @@ public const int "serializTypeElement", "moduleHead", "vtfixupDecl", "vtfixupAttr", "vtableDecl", "nameSpaceHead", "classHead", "classAttr", "extendsClause", "implClause", "classDecls", "implList", "esHead", "extSourceSpec", "fileDecl", "fileAttr", - "fileEntry", "asmAttrAny", "asmAttr", "instr_none", "instr_var", "instr_i", - "instr_i8", "instr_r", "instr_brtarget", "instr_method", "instr_field", - "instr_type", "instr_string", "instr_sig", "instr_tok", "instr_switch", - "instr", "labels", "typeArgs", "bounds", "sigArgs", "sigArg", "className", - "slashedName", "assemblyDecls", "assemblyDecl", "typeSpec", "nativeType", - "nativeTypeArrayPointerInfo", "nativeTypeElement", "iidParamIndex", "variantType", - "variantTypeElement", "type", "typeModifiers", "elementType", "simpleType", - "bound", "nativeInt", "nativeUint", "secDecl", "secAttrSetBlob", "secAttrBlob", - "nameValPairs", "nameValPair", "truefalse", "caValue", "secAction", "methodRef", - "callConv", "callKind", "mdtoken", "memberRef", "fieldRef", "typeList", - "typarsClause", "typarAttrib", "typarAttribs", "typar", "typars", "tyBound", - "genArity", "genArityNotEmpty", "classDecl", "fieldDecl", "fieldAttr", - "atOpt", "initOpt", "repeatOpt", "eventHead", "eventAttr", "eventDecls", - "eventDecl", "propHead", "propAttr", "propDecls", "propDecl", "marshalClause", - "marshalBlob", "paramAttr", "paramAttrElement", "methodHead", "methAttr", - "pinvImpl", "pinvAttr", "methodName", "implAttr", "methodDecls", "methodDecl", + "fileEntry", "asmAttrAny", "asmAttr", "instr", "simpleInstr", "instructionIsland", + "labels", "typeArgs", "bounds", "sigArgs", "sigArg", "className", "slashedName", + "assemblyDecls", "assemblyDecl", "typeSpec", "nativeType", "nativeTypeArrayPointerInfo", + "nativeTypeElement", "iidParamIndex", "variantType", "variantTypeElement", + "type", "typeModifiers", "elementType", "simpleType", "bound", "nativeInt", + "nativeUint", "secDecl", "secAttrSetBlob", "secAttrBlob", "nameValPairs", + "nameValPair", "truefalse", "caValue", "secAction", "methodRef", "callConv", + "callKind", "mdtoken", "memberRef", "fieldRef", "typeList", "typarsClause", + "typarAttrib", "typarAttribs", "typar", "typars", "tyBound", "genArity", + "genArityNotEmpty", "classDecl", "fieldDecl", "fieldAttr", "atOpt", "initOpt", + "repeatOpt", "eventHead", "eventAttr", "eventDecls", "eventDecl", "propHead", + "propAttr", "propDecls", "propDecl", "marshalClause", "marshalBlob", "paramAttr", + "paramAttrElement", "methodHead", "methAttr", "pinvImpl", "pinvAttr", + "methodName", "implAttr", "methodDecls", "methodDecl", "methodDeclIsland", "labelDecl", "customDescrInMethodBody", "scopeBlock", "sehBlock", "sehClauses", "tryBlock", "sehClause", "filterClause", "catchClause", "finallyClause", "faultClause", "handlerBlock", "dataDecl", "ddHead", "tls", "ddBody", @@ -325,7 +321,7 @@ public IdContext id() { try { EnterOuterAlt(_localctx, 1); { - State = 370; + State = 350; _la = TokenStream.LA(1); if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 65534L) != 0) || ((((_la - 199)) & ~0x3f) == 0 && ((1L << (_la - 199)) & 299067162755073L) != 0) || _la==SQSTRING || _la==ID) ) { ErrorHandler.RecoverInline(this); @@ -379,13 +375,13 @@ public DottedNameContext dottedName() { EnterRule(_localctx, 2, RULE_dottedName); try { int _alt; - State = 383; + State = 363; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,1,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 372; + State = 352; Match(DOTTEDNAME); } break; @@ -393,25 +389,25 @@ public DottedNameContext dottedName() { EnterOuterAlt(_localctx, 2); { { - State = 378; + State = 358; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,0,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 373; + State = 353; dottedNamePart(); - State = 374; + State = 354; Match(DOT); } } } - State = 380; + State = 360; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,0,Context); } - State = 381; + State = 361; dottedNamePart(); } } @@ -419,7 +415,7 @@ public DottedNameContext dottedName() { case 3: EnterOuterAlt(_localctx, 3); { - State = 382; + State = 362; Match(SQSTRING); } break; @@ -463,7 +459,7 @@ public DottedNamePartContext dottedNamePart() { try { EnterOuterAlt(_localctx, 1); { - State = 385; + State = 365; _la = TokenStream.LA(1); if ( !(_la==T__15 || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50331649L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -515,25 +511,25 @@ public CompQstringContext compQstring() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 391; + State = 371; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,2,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 387; + State = 367; Match(QSTRING); - State = 388; + State = 368; Match(PLUS); } } } - State = 393; + State = 373; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,2,Context); } - State = 394; + State = 374; Match(QSTRING); } } @@ -577,17 +573,17 @@ public DeclsContext decls() { try { EnterOuterAlt(_localctx, 1); { - State = 399; + State = 379; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1972571905523712L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 281474976710659L) != 0) || ((((_la - 139)) & ~0x3f) == 0 && ((1L << (_la - 139)) & 1729382256977379329L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 6860956837609473L) != 0)) { { { - State = 396; + State = 376; decl(); } } - State = 401; + State = 381; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -721,224 +717,224 @@ public DeclContext decl() { EnterRule(_localctx, 10, RULE_decl); BeginSubtree(); try { - State = 452; + State = 432; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,4,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 402; + State = 382; classHead(); - State = 403; + State = 383; Match(T__16); - State = 404; + State = 384; classDecls(); - State = 405; + State = 385; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 407; + State = 387; nameSpaceHead(); - State = 408; + State = 388; Match(T__16); - State = 409; + State = 389; decls(); - State = 410; + State = 390; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 412; + State = 392; methodHead(); - State = 413; + State = 393; Match(T__16); - State = 414; + State = 394; methodDecls(); - State = 415; + State = 395; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 417; + State = 397; fieldDecl(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 418; + State = 398; dataDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 419; + State = 399; vtableDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 420; + State = 400; vtfixupDecl(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 421; + State = 401; extSourceSpec(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 422; + State = 402; fileDecl(); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 423; + State = 403; assemblyBlock(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 424; + State = 404; assemblyRefHead(); - State = 425; + State = 405; Match(T__16); - State = 426; + State = 406; assemblyRefDecls(); - State = 427; + State = 407; Match(T__17); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 429; + State = 409; exptypeHead(); - State = 430; + State = 410; Match(T__16); - State = 431; + State = 411; exptypeDecls(); - State = 432; + State = 412; Match(T__17); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 434; + State = 414; manifestResHead(); - State = 435; + State = 415; Match(T__16); - State = 436; + State = 416; manifestResDecls(); - State = 437; + State = 417; Match(T__17); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 439; + State = 419; moduleHead(); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 440; + State = 420; secDecl(); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 441; + State = 421; customAttrDecl(); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 442; + State = 422; subsystem(); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 443; + State = 423; corflags(); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 444; + State = 424; alignment(); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 445; + State = 425; imagebase(); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 446; + State = 426; stackreserve(); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 447; + State = 427; languageDecl(); } break; case 23: EnterOuterAlt(_localctx, 23); { - State = 448; + State = 428; typedefDecl(); } break; case 24: EnterOuterAlt(_localctx, 24); { - State = 449; + State = 429; compControl(); } break; case 25: EnterOuterAlt(_localctx, 25); { - State = 450; + State = 430; typelist(); } break; case 26: EnterOuterAlt(_localctx, 26); { - State = 451; + State = 431; mscorlib(); } break; @@ -982,9 +978,9 @@ public SubsystemContext subsystem() { try { EnterOuterAlt(_localctx, 1); { - State = 454; + State = 434; Match(T__18); - State = 455; + State = 435; int32(); } } @@ -1023,9 +1019,9 @@ public CorflagsContext corflags() { try { EnterOuterAlt(_localctx, 1); { - State = 457; + State = 437; Match(T__19); - State = 458; + State = 438; int32(); } } @@ -1064,11 +1060,11 @@ public AlignmentContext alignment() { try { EnterOuterAlt(_localctx, 1); { - State = 460; + State = 440; Match(T__20); - State = 461; + State = 441; Match(T__21); - State = 462; + State = 442; int32(); } } @@ -1107,9 +1103,9 @@ public ImagebaseContext imagebase() { try { EnterOuterAlt(_localctx, 1); { - State = 464; + State = 444; Match(T__22); - State = 465; + State = 445; int64(); } } @@ -1148,9 +1144,9 @@ public StackreserveContext stackreserve() { try { EnterOuterAlt(_localctx, 1); { - State = 467; + State = 447; Match(T__23); - State = 468; + State = 448; int64(); } } @@ -1195,17 +1191,17 @@ public AssemblyBlockContext assemblyBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 470; + State = 450; Match(T__24); - State = 471; + State = 451; asmAttr(); - State = 472; + State = 452; dottedName(); - State = 473; + State = 453; Match(T__16); - State = 474; + State = 454; assemblyDecls(); - State = 475; + State = 455; Match(T__17); } } @@ -1241,7 +1237,7 @@ public MscorlibContext mscorlib() { try { EnterOuterAlt(_localctx, 1); { - State = 477; + State = 457; Match(T__25); } } @@ -1281,45 +1277,45 @@ public LanguageDeclContext languageDecl() { LanguageDeclContext _localctx = new LanguageDeclContext(Context, State); EnterRule(_localctx, 26, RULE_languageDecl); try { - State = 493; + State = 473; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,5,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 479; + State = 459; Match(T__26); - State = 480; + State = 460; languageString(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 481; + State = 461; Match(T__26); - State = 482; + State = 462; languageString(); - State = 483; + State = 463; Match(T__27); - State = 484; + State = 464; languageString(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 486; + State = 466; Match(T__26); - State = 487; + State = 467; languageString(); - State = 488; + State = 468; Match(T__27); - State = 489; + State = 469; languageString(); - State = 490; + State = 470; Match(T__27); - State = 491; + State = 471; languageString(); } break; @@ -1360,7 +1356,7 @@ public LanguageStringContext languageString() { try { EnterOuterAlt(_localctx, 1); { - State = 495; + State = 475; _la = TokenStream.LA(1); if ( !(_la==QSTRING || _la==SQSTRING) ) { ErrorHandler.RecoverInline(this); @@ -1410,25 +1406,25 @@ public TypelistContext typelist() { try { EnterOuterAlt(_localctx, 1); { - State = 497; + State = 477; Match(T__28); - State = 498; + State = 478; Match(T__16); - State = 502; + State = 482; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__15 || _la==T__41 || _la==T__112 || ((((_la - 199)) & ~0x3f) == 0 && ((1L << (_la - 199)) & 2017630225248026625L) != 0) || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50331649L) != 0)) { { { - State = 499; + State = 479; className(); } } - State = 504; + State = 484; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 505; + State = 485; Match(T__17); } } @@ -1465,7 +1461,7 @@ public Int32Context int32() { try { EnterOuterAlt(_localctx, 1); { - State = 507; + State = 487; Match(INT32); } } @@ -1504,7 +1500,7 @@ public Int64Context int64() { try { EnterOuterAlt(_localctx, 1); { - State = 509; + State = 489; _la = TokenStream.LA(1); if ( !(_la==INT32 || _la==INT64) ) { ErrorHandler.RecoverInline(this); @@ -1555,55 +1551,55 @@ public Float64Context float64() { Float64Context _localctx = new Float64Context(Context, State); EnterRule(_localctx, 36, RULE_float64); try { - State = 526; + State = 506; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,7,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 511; + State = 491; Match(FLOAT64); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 512; + State = 492; int32(); - State = 513; + State = 493; Match(DOT); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 515; + State = 495; int32(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 516; + State = 496; Match(FLOAT32); - State = 517; + State = 497; Match(T__29); - State = 518; + State = 498; int32(); - State = 519; + State = 499; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 521; + State = 501; Match(FLOAT64_); - State = 522; + State = 502; Match(T__29); - State = 523; + State = 503; int64(); - State = 524; + State = 504; Match(T__30); } break; @@ -1643,20 +1639,20 @@ public IntOrWildcardContext intOrWildcard() { IntOrWildcardContext _localctx = new IntOrWildcardContext(Context, State); EnterRule(_localctx, 38, RULE_intOrWildcard); try { - State = 530; + State = 510; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case INT32: EnterOuterAlt(_localctx, 1); { - State = 528; + State = 508; int32(); } break; case PTR: EnterOuterAlt(_localctx, 2); { - State = 529; + State = 509; Match(PTR); } break; @@ -1703,83 +1699,83 @@ public CompControlContext compControl() { CompControlContext _localctx = new CompControlContext(Context, State); EnterRule(_localctx, 40, RULE_compControl); try { - State = 548; + State = 528; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,9,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 532; + State = 512; Match(PP_DEFINE); - State = 533; + State = 513; Match(ID); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 534; + State = 514; Match(PP_DEFINE); - State = 535; + State = 515; Match(ID); - State = 536; + State = 516; Match(QSTRING); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 537; + State = 517; Match(PP_UNDEF); - State = 538; + State = 518; Match(ID); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 539; + State = 519; Match(PP_IFDEF); - State = 540; + State = 520; Match(ID); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 541; + State = 521; Match(PP_IFNDEF); - State = 542; + State = 522; Match(ID); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 543; + State = 523; Match(PP_ELSE); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 544; + State = 524; Match(PP_ENDIF); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 545; + State = 525; Match(PP_INCLUDE); - State = 546; + State = 526; Match(QSTRING); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 547; + State = 527; Match(T__31); } break; @@ -1833,71 +1829,71 @@ public TypedefDeclContext typedefDecl() { TypedefDeclContext _localctx = new TypedefDeclContext(Context, State); EnterRule(_localctx, 42, RULE_typedefDecl); try { - State = 575; + State = 555; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,10,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 550; + State = 530; Match(T__32); - State = 551; + State = 531; type(); - State = 552; + State = 532; Match(T__33); - State = 553; + State = 533; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 555; + State = 535; Match(T__32); - State = 556; + State = 536; className(); - State = 557; + State = 537; Match(T__33); - State = 558; + State = 538; dottedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 560; + State = 540; Match(T__32); - State = 561; + State = 541; memberRef(); - State = 562; + State = 542; Match(T__33); - State = 563; + State = 543; dottedName(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 565; + State = 545; Match(T__32); - State = 566; + State = 546; customDescr(); - State = 567; + State = 547; Match(T__33); - State = 568; + State = 548; dottedName(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 570; + State = 550; Match(T__32); - State = 571; + State = 551; customDescrWithOwner(); - State = 572; + State = 552; Match(T__33); - State = 573; + State = 553; dottedName(); } break; @@ -1945,62 +1941,62 @@ public CustomDescrContext customDescr() { CustomDescrContext _localctx = new CustomDescrContext(Context, State); EnterRule(_localctx, 44, RULE_customDescr); try { - State = 598; + State = 578; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,11,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 577; + State = 557; Match(T__34); - State = 578; + State = 558; customType(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 579; + State = 559; Match(T__34); - State = 580; + State = 560; customType(); - State = 581; + State = 561; Match(T__35); - State = 582; + State = 562; compQstring(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 584; + State = 564; Match(T__34); - State = 585; + State = 565; customType(); - State = 586; + State = 566; Match(T__35); - State = 587; + State = 567; Match(T__16); - State = 588; + State = 568; customBlobDescr(); - State = 589; + State = 569; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 591; + State = 571; Match(T__34); - State = 592; + State = 572; customType(); - State = 593; + State = 573; Match(T__35); - State = 594; + State = 574; Match(T__29); - State = 595; + State = 575; bytes(); - State = 596; + State = 576; Match(T__30); } break; @@ -2051,86 +2047,86 @@ public CustomDescrWithOwnerContext customDescrWithOwner() { CustomDescrWithOwnerContext _localctx = new CustomDescrWithOwnerContext(Context, State); EnterRule(_localctx, 46, RULE_customDescrWithOwner); try { - State = 634; + State = 614; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,12,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 600; + State = 580; Match(T__34); - State = 601; + State = 581; Match(T__29); - State = 602; + State = 582; ownerType(); - State = 603; + State = 583; Match(T__30); - State = 604; + State = 584; customType(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 606; + State = 586; Match(T__34); - State = 607; + State = 587; Match(T__29); - State = 608; + State = 588; ownerType(); - State = 609; + State = 589; Match(T__30); - State = 610; + State = 590; customType(); - State = 611; + State = 591; Match(T__35); - State = 612; + State = 592; compQstring(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 614; + State = 594; Match(T__34); - State = 615; + State = 595; Match(T__29); - State = 616; + State = 596; ownerType(); - State = 617; + State = 597; Match(T__30); - State = 618; + State = 598; customType(); - State = 619; + State = 599; Match(T__35); - State = 620; + State = 600; Match(T__16); - State = 621; + State = 601; customBlobDescr(); - State = 622; + State = 602; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 624; + State = 604; Match(T__34); - State = 625; + State = 605; Match(T__29); - State = 626; + State = 606; ownerType(); - State = 627; + State = 607; Match(T__30); - State = 628; + State = 608; customType(); - State = 629; + State = 609; Match(T__35); - State = 630; + State = 610; Match(T__29); - State = 631; + State = 611; bytes(); - State = 632; + State = 612; Match(T__30); } break; @@ -2171,7 +2167,7 @@ public CustomTypeContext customType() { try { EnterOuterAlt(_localctx, 1); { - State = 636; + State = 616; methodRef(); } } @@ -2211,20 +2207,20 @@ public OwnerTypeContext ownerType() { OwnerTypeContext _localctx = new OwnerTypeContext(Context, State); EnterRule(_localctx, 50, RULE_ownerType); try { - State = 640; + State = 620; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,13,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 638; + State = 618; typeSpec(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 639; + State = 619; memberRef(); } break; @@ -2268,9 +2264,9 @@ public CustomBlobDescrContext customBlobDescr() { try { EnterOuterAlt(_localctx, 1); { - State = 642; + State = 622; customBlobArgs(); - State = 643; + State = 623; customBlobNVPairs(); } } @@ -2319,13 +2315,13 @@ public CustomBlobArgsContext customBlobArgs() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 649; + State = 629; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,15,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { - State = 647; + State = 627; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__83: @@ -2345,7 +2341,7 @@ public CustomBlobArgsContext customBlobArgs() { case TYPE: case OBJECT: { - State = 645; + State = 625; serInit(); } break; @@ -2358,7 +2354,7 @@ public CustomBlobArgsContext customBlobArgs() { case PP_ENDIF: case PP_INCLUDE: { - State = 646; + State = 626; compControl(); } break; @@ -2367,7 +2363,7 @@ public CustomBlobArgsContext customBlobArgs() { } } } - State = 651; + State = 631; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,15,Context); } @@ -2436,26 +2432,26 @@ public CustomBlobNVPairsContext customBlobNVPairs() { try { EnterOuterAlt(_localctx, 1); { - State = 661; + State = 641; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 416611827712L) != 0) || ((((_la - 267)) & ~0x3f) == 0 && ((1L << (_la - 267)) & 127L) != 0)) { { - State = 659; + State = 639; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__36: case T__37: { - State = 652; + State = 632; fieldOrProp(); - State = 653; + State = 633; serializType(); - State = 654; + State = 634; dottedName(); - State = 655; + State = 635; Match(T__35); - State = 656; + State = 636; serInit(); } break; @@ -2468,7 +2464,7 @@ public CustomBlobNVPairsContext customBlobNVPairs() { case PP_ENDIF: case PP_INCLUDE: { - State = 658; + State = 638; compControl(); } break; @@ -2476,7 +2472,7 @@ public CustomBlobNVPairsContext customBlobNVPairs() { throw new NoViableAltException(this); } } - State = 663; + State = 643; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -2515,7 +2511,7 @@ public FieldOrPropContext fieldOrProp() { try { EnterOuterAlt(_localctx, 1); { - State = 664; + State = 644; _la = TokenStream.LA(1); if ( !(_la==T__36 || _la==T__37) ) { ErrorHandler.RecoverInline(this); @@ -2563,14 +2559,14 @@ public SerializTypeContext serializType() { try { EnterOuterAlt(_localctx, 1); { - State = 666; + State = 646; serializTypeElement(); - State = 668; + State = 648; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==ARRAY_TYPE_NO_BOUNDS) { { - State = 667; + State = 647; Match(ARRAY_TYPE_NO_BOUNDS); } } @@ -2620,54 +2616,54 @@ public SerializTypeElementContext serializTypeElement() { SerializTypeElementContext _localctx = new SerializTypeElementContext(Context, State); EnterRule(_localctx, 62, RULE_serializTypeElement); try { - State = 679; + State = 659; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,19,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 670; + State = 650; simpleType(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 671; + State = 651; dottedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 672; + State = 652; Match(TYPE); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 673; + State = 653; Match(OBJECT); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 674; + State = 654; Match(ENUM); - State = 675; + State = 655; Match(T__38); - State = 676; + State = 656; Match(SQSTRING); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 677; + State = 657; Match(ENUM); - State = 678; + State = 658; className(); } break; @@ -2707,33 +2703,33 @@ public ModuleHeadContext moduleHead() { ModuleHeadContext _localctx = new ModuleHeadContext(Context, State); EnterRule(_localctx, 64, RULE_moduleHead); try { - State = 687; + State = 667; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,20,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 681; + State = 661; Match(MODULE); - State = 682; + State = 662; Match(T__39); - State = 683; + State = 663; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 684; + State = 664; Match(MODULE); - State = 685; + State = 665; dottedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 686; + State = 666; Match(MODULE); } break; @@ -2780,19 +2776,19 @@ public VtfixupDeclContext vtfixupDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 689; + State = 669; Match(T__40); - State = 690; + State = 670; Match(T__41); - State = 691; + State = 671; int32(); - State = 692; + State = 672; Match(T__42); - State = 693; + State = 673; vtfixupAttr(0); - State = 694; + State = 674; Match(T__43); - State = 695; + State = 675; id(); } } @@ -2845,7 +2841,7 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { } Context.Stop = TokenStream.LT(-1); - State = 710; + State = 690; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,22,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { @@ -2854,16 +2850,16 @@ private VtfixupAttrContext vtfixupAttr(int _p) { TriggerExitRuleEvent(); _prevctx = _localctx; { - State = 708; + State = 688; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,21,Context) ) { case 1: { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 698; + State = 678; if (!(Precpred(Context, 5))) throw new FailedPredicateException(this, "Precpred(Context, 5)"); - State = 699; + State = 679; Match(INT32_); } break; @@ -2871,9 +2867,9 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 700; + State = 680; if (!(Precpred(Context, 4))) throw new FailedPredicateException(this, "Precpred(Context, 4)"); - State = 701; + State = 681; Match(INT64_); } break; @@ -2881,9 +2877,9 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 702; + State = 682; if (!(Precpred(Context, 3))) throw new FailedPredicateException(this, "Precpred(Context, 3)"); - State = 703; + State = 683; Match(T__44); } break; @@ -2891,9 +2887,9 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 704; + State = 684; if (!(Precpred(Context, 2))) throw new FailedPredicateException(this, "Precpred(Context, 2)"); - State = 705; + State = 685; Match(T__45); } break; @@ -2901,16 +2897,16 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 706; + State = 686; if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)"); - State = 707; + State = 687; Match(T__46); } break; } } } - State = 712; + State = 692; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,22,Context); } @@ -2951,15 +2947,15 @@ public VtableDeclContext vtableDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 713; + State = 693; Match(T__47); - State = 714; + State = 694; Match(T__35); - State = 715; + State = 695; Match(T__29); - State = 716; + State = 696; bytes(); - State = 717; + State = 697; Match(T__30); } } @@ -2999,9 +2995,9 @@ public NameSpaceHeadContext nameSpaceHead() { try { EnterOuterAlt(_localctx, 1); { - State = 719; + State = 699; Match(T__48); - State = 720; + State = 700; dottedName(); } Context.Stop = TokenStream.LT(-1); @@ -3060,31 +3056,31 @@ public ClassHeadContext classHead() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 722; + State = 702; Match(T__49); - State = 726; + State = 706; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,23,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 723; + State = 703; classAttr(); } } } - State = 728; + State = 708; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,23,Context); } - State = 729; + State = 709; dottedName(); - State = 730; + State = 710; typarsClause(); - State = 731; + State = 711; extendsClause(); - State = 732; + State = 712; implClause(); } Context.Stop = TokenStream.LT(-1); @@ -3129,213 +3125,213 @@ public ClassAttrContext classAttr() { ClassAttrContext _localctx = new ClassAttrContext(Context, State); EnterRule(_localctx, 76, RULE_classAttr); try { - State = 771; + State = 751; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,24,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 734; + State = 714; Match(T__50); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 735; + State = 715; Match(T__51); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 736; + State = 716; Match(VALUE); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 737; + State = 717; Match(ENUM); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 738; + State = 718; Match(INTERFACE); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 739; + State = 719; Match(T__52); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 740; + State = 720; Match(T__53); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 741; + State = 721; Match(T__54); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 742; + State = 722; Match(T__55); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 743; + State = 723; Match(EXPLICIT); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 744; + State = 724; Match(T__14); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 745; + State = 725; Match(ANSI); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 746; + State = 726; Match(T__56); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 747; + State = 727; Match(T__57); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 748; + State = 728; Match(T__58); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 749; + State = 729; Match(T__59); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 750; + State = 730; Match(T__60); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 751; + State = 731; Match(T__61); - State = 752; + State = 732; Match(T__50); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 753; + State = 733; Match(T__61); - State = 754; + State = 734; Match(T__51); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 755; + State = 735; Match(T__61); - State = 756; + State = 736; Match(T__62); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 757; + State = 737; Match(T__61); - State = 758; + State = 738; Match(T__63); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 759; + State = 739; Match(T__61); - State = 760; + State = 740; Match(T__64); } break; case 23: EnterOuterAlt(_localctx, 23); { - State = 761; + State = 741; Match(T__61); - State = 762; + State = 742; Match(T__65); } break; case 24: EnterOuterAlt(_localctx, 24); { - State = 763; + State = 743; Match(T__66); } break; case 25: EnterOuterAlt(_localctx, 25); { - State = 764; + State = 744; Match(T__67); } break; case 26: EnterOuterAlt(_localctx, 26); { - State = 765; + State = 745; Match(T__68); } break; case 27: EnterOuterAlt(_localctx, 27); { - State = 766; + State = 746; Match(T__69); - State = 767; + State = 747; Match(T__29); - State = 768; + State = 748; int32(); - State = 769; + State = 749; Match(T__30); } break; @@ -3374,7 +3370,7 @@ public ExtendsClauseContext extendsClause() { ExtendsClauseContext _localctx = new ExtendsClauseContext(Context, State); EnterRule(_localctx, 78, RULE_extendsClause); try { - State = 776; + State = 756; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -3386,9 +3382,9 @@ public ExtendsClauseContext extendsClause() { case T__70: EnterOuterAlt(_localctx, 2); { - State = 774; + State = 754; Match(T__70); - State = 775; + State = 755; typeSpec(); } break; @@ -3429,7 +3425,7 @@ public ImplClauseContext implClause() { ImplClauseContext _localctx = new ImplClauseContext(Context, State); EnterRule(_localctx, 80, RULE_implClause); try { - State = 781; + State = 761; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -3440,9 +3436,9 @@ public ImplClauseContext implClause() { case T__71: EnterOuterAlt(_localctx, 2); { - State = 779; + State = 759; Match(T__71); - State = 780; + State = 760; implList(); } break; @@ -3490,17 +3486,17 @@ public ClassDeclsContext classDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 786; + State = 766; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1125938695831552L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 1189425290649010179L) != 0) || ((((_la - 139)) & ~0x3f) == 0 && ((1L << (_la - 139)) & 1152921504673955841L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 871552083145265153L) != 0)) { { { - State = 783; + State = 763; classDecl(); } } - State = 788; + State = 768; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -3546,25 +3542,25 @@ public ImplListContext implList() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 794; + State = 774; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,28,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 789; + State = 769; typeSpec(); - State = 790; + State = 770; Match(T__27); } } } - State = 796; + State = 776; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,28,Context); } - State = 797; + State = 777; typeSpec(); } } @@ -3601,7 +3597,7 @@ public EsHeadContext esHead() { try { EnterOuterAlt(_localctx, 1); { - State = 799; + State = 779; _la = TokenStream.LA(1); if ( !(_la==T__72 || _la==T__73) ) { ErrorHandler.RecoverInline(this); @@ -3653,257 +3649,257 @@ public ExtSourceSpecContext extSourceSpec() { ExtSourceSpecContext _localctx = new ExtSourceSpecContext(Context, State); EnterRule(_localctx, 88, RULE_extSourceSpec); try { - State = 904; + State = 884; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,29,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 801; + State = 781; esHead(); - State = 802; + State = 782; int32(); - State = 803; + State = 783; Match(SQSTRING); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 805; + State = 785; esHead(); - State = 806; + State = 786; int32(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 808; + State = 788; esHead(); - State = 809; + State = 789; int32(); - State = 810; + State = 790; Match(T__74); - State = 811; + State = 791; int32(); - State = 812; + State = 792; Match(SQSTRING); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 814; + State = 794; esHead(); - State = 815; + State = 795; int32(); - State = 816; + State = 796; Match(T__74); - State = 817; + State = 797; int32(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 819; + State = 799; esHead(); - State = 820; + State = 800; int32(); - State = 821; + State = 801; Match(T__74); - State = 822; + State = 802; int32(); - State = 823; + State = 803; Match(T__27); - State = 824; + State = 804; int32(); - State = 825; + State = 805; Match(SQSTRING); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 827; + State = 807; esHead(); - State = 828; + State = 808; int32(); - State = 829; + State = 809; Match(T__74); - State = 830; + State = 810; int32(); - State = 831; + State = 811; Match(T__27); - State = 832; + State = 812; int32(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 834; + State = 814; esHead(); - State = 835; + State = 815; int32(); - State = 836; + State = 816; Match(T__27); - State = 837; + State = 817; int32(); - State = 838; + State = 818; Match(T__74); - State = 839; + State = 819; int32(); - State = 840; + State = 820; Match(SQSTRING); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 842; + State = 822; esHead(); - State = 843; + State = 823; int32(); - State = 844; + State = 824; Match(T__27); - State = 845; + State = 825; int32(); - State = 846; + State = 826; Match(T__74); - State = 847; + State = 827; int32(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 849; + State = 829; esHead(); - State = 850; + State = 830; int32(); - State = 851; + State = 831; Match(T__27); - State = 852; + State = 832; int32(); - State = 853; + State = 833; Match(T__74); - State = 854; + State = 834; int32(); - State = 855; + State = 835; Match(T__27); - State = 856; + State = 836; int32(); - State = 857; + State = 837; Match(SQSTRING); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 859; + State = 839; esHead(); - State = 860; + State = 840; int32(); - State = 861; + State = 841; Match(T__27); - State = 862; + State = 842; int32(); - State = 863; + State = 843; Match(T__74); - State = 864; + State = 844; int32(); - State = 865; + State = 845; Match(T__27); - State = 866; + State = 846; int32(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 868; + State = 848; esHead(); - State = 869; + State = 849; int32(); - State = 870; + State = 850; Match(QSTRING); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 872; + State = 852; esHead(); - State = 873; + State = 853; int32(); - State = 874; + State = 854; Match(T__74); - State = 875; + State = 855; int32(); - State = 876; + State = 856; Match(QSTRING); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 878; + State = 858; esHead(); - State = 879; + State = 859; int32(); - State = 880; + State = 860; Match(T__74); - State = 881; + State = 861; int32(); - State = 882; + State = 862; Match(T__27); - State = 883; + State = 863; int32(); - State = 884; + State = 864; Match(QSTRING); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 886; + State = 866; esHead(); - State = 887; + State = 867; int32(); - State = 888; + State = 868; Match(T__27); - State = 889; + State = 869; int32(); - State = 890; + State = 870; Match(T__74); - State = 891; + State = 871; int32(); - State = 892; + State = 872; Match(QSTRING); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 894; + State = 874; esHead(); - State = 895; + State = 875; int32(); - State = 896; + State = 876; Match(T__27); - State = 897; + State = 877; int32(); - State = 898; + State = 878; Match(T__74); - State = 899; + State = 879; int32(); - State = 900; + State = 880; Match(T__27); - State = 901; + State = 881; int32(); - State = 902; + State = 882; Match(QSTRING); } break; @@ -3959,68 +3955,68 @@ public FileDeclContext fileDecl() { EnterRule(_localctx, 90, RULE_fileDecl); int _la; try { - State = 932; + State = 912; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,32,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 906; + State = 886; Match(T__20); - State = 910; + State = 890; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__75) { { { - State = 907; + State = 887; fileAttr(); } } - State = 912; + State = 892; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 913; + State = 893; dottedName(); - State = 914; + State = 894; fileEntry(); - State = 915; + State = 895; Match(HASH); - State = 916; + State = 896; Match(T__35); - State = 917; + State = 897; Match(T__29); - State = 918; + State = 898; bytes(); - State = 919; + State = 899; Match(T__30); - State = 920; + State = 900; fileEntry(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 922; + State = 902; Match(T__20); - State = 926; + State = 906; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__75) { { { - State = 923; + State = 903; fileAttr(); } } - State = 928; + State = 908; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 929; + State = 909; dottedName(); - State = 930; + State = 910; fileEntry(); } break; @@ -4058,7 +4054,7 @@ public FileAttrContext fileAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 934; + State = 914; Match(T__75); } } @@ -4093,7 +4089,7 @@ public FileEntryContext fileEntry() { FileEntryContext _localctx = new FileEntryContext(Context, State); EnterRule(_localctx, 94, RULE_fileEntry); try { - State = 938; + State = 918; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -4143,7 +4139,7 @@ public FileEntryContext fileEntry() { case ENTRYPOINT: EnterOuterAlt(_localctx, 2); { - State = 937; + State = 917; Match(ENTRYPOINT); } break; @@ -4184,7 +4180,7 @@ public AsmAttrAnyContext asmAttrAny() { try { EnterOuterAlt(_localctx, 1); { - State = 940; + State = 920; _la = TokenStream.LA(1); if ( !(_la==T__1 || _la==T__60 || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 127L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -4234,17 +4230,17 @@ public AsmAttrContext asmAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 945; + State = 925; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__1 || _la==T__60 || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 127L) != 0)) { { { - State = 942; + State = 922; asmAttrAny(); } } - State = 947; + State = 927; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -4261,30 +4257,48 @@ public AsmAttrContext asmAttr() { return _localctx; } - public partial class Instr_noneContext : ParserRuleContext { - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_NONE() { return GetToken(CILParser.INSTR_NONE, 0); } - public Instr_noneContext(ParserRuleContext parent, int invokingState) + public partial class InstrContext : ParserRuleContext { + [System.Diagnostics.DebuggerNonUserCode] public SimpleInstrContext simpleInstr() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public InstructionIslandContext instructionIsland() { + return GetRuleContext(0); + } + public InstrContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { } - public override int RuleIndex { get { return RULE_instr_none; } } + public override int RuleIndex { get { return RULE_instr; } } [System.Diagnostics.DebuggerNonUserCode] public override TResult Accept(IParseTreeVisitor visitor) { ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitInstr_none(this); + if (typedVisitor != null) return typedVisitor.VisitInstr(this); else return visitor.VisitChildren(this); } } [RuleVersion(0)] - public Instr_noneContext instr_none() { - Instr_noneContext _localctx = new Instr_noneContext(Context, State); - EnterRule(_localctx, 100, RULE_instr_none); + public InstrContext instr() { + InstrContext _localctx = new InstrContext(Context, State); + EnterRule(_localctx, 100, RULE_instr); try { - EnterOuterAlt(_localctx, 1); - { - State = 948; - Match(INSTR_NONE); + State = 930; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,35,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 928; + simpleInstr(); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 929; + instructionIsland(); + } + break; } } catch (RecognitionException re) { @@ -4298,104 +4312,182 @@ public Instr_noneContext instr_none() { return _localctx; } - public partial class Instr_varContext : ParserRuleContext { + public partial class SimpleInstrContext : ParserRuleContext { + public IToken op; + public Int32Context index; + public IdContext name; + public Int32Context value32; + public Int64Context value64; + public BytesContext rawFloat; + public Int32Context offset; + public IdContext label; + public BytesContext rawString; + public Int32Context rawToken; + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_NONE() { return GetToken(CILParser.INSTR_NONE, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_VAR() { return GetToken(CILParser.INSTR_VAR, 0); } - public Instr_varContext(ParserRuleContext parent, int invokingState) - : base(parent, invokingState) - { - } - public override int RuleIndex { get { return RULE_instr_var; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitInstr_var(this); - else return visitor.VisitChildren(this); + [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { + return GetRuleContext(0); } - } - - [RuleVersion(0)] - public Instr_varContext instr_var() { - Instr_varContext _localctx = new Instr_varContext(Context, State); - EnterRule(_localctx, 102, RULE_instr_var); - try { - EnterOuterAlt(_localctx, 1); - { - State = 950; - Match(INSTR_VAR); - } + [System.Diagnostics.DebuggerNonUserCode] public IdContext id() { + return GetRuleContext(0); } - catch (RecognitionException re) { - _localctx.exception = re; - ErrorHandler.ReportError(this, re); - ErrorHandler.Recover(this, re); + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_I() { return GetToken(CILParser.INSTR_I, 0); } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_I8() { return GetToken(CILParser.INSTR_I8, 0); } + [System.Diagnostics.DebuggerNonUserCode] public Int64Context int64() { + return GetRuleContext(0); } - finally { - ExitRule(); + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_R() { return GetToken(CILParser.INSTR_R, 0); } + [System.Diagnostics.DebuggerNonUserCode] public BytesContext bytes() { + return GetRuleContext(0); } - return _localctx; - } - - public partial class Instr_iContext : ParserRuleContext { - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_I() { return GetToken(CILParser.INSTR_I, 0); } - public Instr_iContext(ParserRuleContext parent, int invokingState) + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_BRTARGET() { return GetToken(CILParser.INSTR_BRTARGET, 0); } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_STRING() { return GetToken(CILParser.INSTR_STRING, 0); } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_TOK() { return GetToken(CILParser.INSTR_TOK, 0); } + public SimpleInstrContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { } - public override int RuleIndex { get { return RULE_instr_i; } } + public override int RuleIndex { get { return RULE_simpleInstr; } } [System.Diagnostics.DebuggerNonUserCode] public override TResult Accept(IParseTreeVisitor visitor) { ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitInstr_i(this); + if (typedVisitor != null) return typedVisitor.VisitSimpleInstr(this); else return visitor.VisitChildren(this); } } [RuleVersion(0)] - public Instr_iContext instr_i() { - Instr_iContext _localctx = new Instr_iContext(Context, State); - EnterRule(_localctx, 104, RULE_instr_i); + public SimpleInstrContext simpleInstr() { + SimpleInstrContext _localctx = new SimpleInstrContext(Context, State); + EnterRule(_localctx, 102, RULE_simpleInstr); try { - EnterOuterAlt(_localctx, 1); - { - State = 952; - Match(INSTR_I); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - ErrorHandler.ReportError(this, re); - ErrorHandler.Recover(this, re); - } - finally { - ExitRule(); - } - return _localctx; - } - - public partial class Instr_i8Context : ParserRuleContext { - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_I8() { return GetToken(CILParser.INSTR_I8, 0); } - public Instr_i8Context(ParserRuleContext parent, int invokingState) - : base(parent, invokingState) - { - } - public override int RuleIndex { get { return RULE_instr_i8; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitInstr_i8(this); - else return visitor.VisitChildren(this); - } - } - - [RuleVersion(0)] - public Instr_i8Context instr_i8() { - Instr_i8Context _localctx = new Instr_i8Context(Context, State); - EnterRule(_localctx, 106, RULE_instr_i8); - try { - EnterOuterAlt(_localctx, 1); - { - State = 954; - Match(INSTR_I8); + State = 982; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,36,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); + { + State = 932; + _localctx.op = Match(INSTR_NONE); + Actions.EmitNoOperandInstruction(_localctx.op); + } + break; + case 2: + EnterOuterAlt(_localctx, 2); + { + State = 934; + _localctx.op = Match(INSTR_VAR); + State = 935; + _localctx.index = int32(); + Actions.EmitVariableIndexInstruction(_localctx.op, (_localctx.index!=null?(_localctx.index.Start):null)); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 938; + _localctx.op = Match(INSTR_VAR); + State = 939; + _localctx.name = id(); + Actions.EmitVariableNameInstruction(_localctx.op, (_localctx.name!=null?(_localctx.name.Start):null)); + } + break; + case 4: + EnterOuterAlt(_localctx, 4); + { + State = 942; + _localctx.op = Match(INSTR_I); + State = 943; + _localctx.value32 = int32(); + Actions.EmitInt32Instruction(_localctx.op, (_localctx.value32!=null?(_localctx.value32.Start):null)); + } + break; + case 5: + EnterOuterAlt(_localctx, 5); + { + State = 946; + _localctx.op = Match(INSTR_I8); + State = 947; + _localctx.value64 = int64(); + Actions.EmitInt64Instruction(_localctx.op, (_localctx.value64!=null?(_localctx.value64.Start):null)); + } + break; + case 6: + EnterOuterAlt(_localctx, 6); + { + State = 950; + _localctx.op = Match(INSTR_R); + State = 951; + Match(T__29); + State = 952; + _localctx.rawFloat = bytes(); + State = 953; + Match(T__30); + Actions.EmitRawFloatingInstruction(_localctx.op, _localctx.rawFloat.Value, (_localctx.rawFloat!=null?(_localctx.rawFloat.Start):null)); + } + break; + case 7: + EnterOuterAlt(_localctx, 7); + { + State = 956; + _localctx.op = Match(INSTR_R); + State = 957; + Match(T__83); + State = 958; + Match(T__29); + State = 959; + _localctx.rawFloat = bytes(); + State = 960; + Match(T__30); + Actions.EmitRawFloatingInstruction(_localctx.op, _localctx.rawFloat.Value, (_localctx.rawFloat!=null?(_localctx.rawFloat.Start):null)); + } + break; + case 8: + EnterOuterAlt(_localctx, 8); + { + State = 963; + _localctx.op = Match(INSTR_BRTARGET); + State = 964; + _localctx.offset = int32(); + Actions.EmitBranchOffsetInstruction(_localctx.op, (_localctx.offset!=null?(_localctx.offset.Start):null)); + } + break; + case 9: + EnterOuterAlt(_localctx, 9); + { + State = 967; + _localctx.op = Match(INSTR_BRTARGET); + State = 968; + _localctx.label = id(); + Actions.EmitBranchLabelInstruction(_localctx.op, (_localctx.label!=null?(_localctx.label.Start):null)); + } + break; + case 10: + EnterOuterAlt(_localctx, 10); + { + State = 971; + _localctx.op = Match(INSTR_STRING); + State = 972; + Match(T__83); + State = 973; + Match(T__29); + State = 974; + _localctx.rawString = bytes(); + State = 975; + Match(T__30); + Actions.EmitRawStringInstruction(_localctx.op, _localctx.rawString.Value); + } + break; + case 11: + EnterOuterAlt(_localctx, 11); + { + State = 978; + _localctx.op = Match(INSTR_TOK); + State = 979; + _localctx.rawToken = int32(); + Actions.EmitRawTokenInstruction(_localctx.op, (_localctx.rawToken!=null?(_localctx.rawToken.Start):null)); + } + break; } } catch (RecognitionException re) { @@ -4409,404 +4501,35 @@ public Instr_i8Context instr_i8() { return _localctx; } - public partial class Instr_rContext : ParserRuleContext { + public partial class InstructionIslandContext : ParserRuleContext { [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_R() { return GetToken(CILParser.INSTR_R, 0); } - public Instr_rContext(ParserRuleContext parent, int invokingState) - : base(parent, invokingState) - { - } - public override int RuleIndex { get { return RULE_instr_r; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitInstr_r(this); - else return visitor.VisitChildren(this); - } - } - - [RuleVersion(0)] - public Instr_rContext instr_r() { - Instr_rContext _localctx = new Instr_rContext(Context, State); - EnterRule(_localctx, 108, RULE_instr_r); - try { - EnterOuterAlt(_localctx, 1); - { - State = 956; - Match(INSTR_R); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - ErrorHandler.ReportError(this, re); - ErrorHandler.Recover(this, re); - } - finally { - ExitRule(); - } - return _localctx; - } - - public partial class Instr_brtargetContext : ParserRuleContext { - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_BRTARGET() { return GetToken(CILParser.INSTR_BRTARGET, 0); } - public Instr_brtargetContext(ParserRuleContext parent, int invokingState) - : base(parent, invokingState) - { - } - public override int RuleIndex { get { return RULE_instr_brtarget; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitInstr_brtarget(this); - else return visitor.VisitChildren(this); - } - } - - [RuleVersion(0)] - public Instr_brtargetContext instr_brtarget() { - Instr_brtargetContext _localctx = new Instr_brtargetContext(Context, State); - EnterRule(_localctx, 110, RULE_instr_brtarget); - try { - EnterOuterAlt(_localctx, 1); - { - State = 958; - Match(INSTR_BRTARGET); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - ErrorHandler.ReportError(this, re); - ErrorHandler.Recover(this, re); - } - finally { - ExitRule(); - } - return _localctx; - } - - public partial class Instr_methodContext : ParserRuleContext { - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_METHOD() { return GetToken(CILParser.INSTR_METHOD, 0); } - public Instr_methodContext(ParserRuleContext parent, int invokingState) - : base(parent, invokingState) - { - } - public override int RuleIndex { get { return RULE_instr_method; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitInstr_method(this); - else return visitor.VisitChildren(this); - } - } - - [RuleVersion(0)] - public Instr_methodContext instr_method() { - Instr_methodContext _localctx = new Instr_methodContext(Context, State); - EnterRule(_localctx, 112, RULE_instr_method); - try { - EnterOuterAlt(_localctx, 1); - { - State = 960; - Match(INSTR_METHOD); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - ErrorHandler.ReportError(this, re); - ErrorHandler.Recover(this, re); - } - finally { - ExitRule(); - } - return _localctx; - } - - public partial class Instr_fieldContext : ParserRuleContext { - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_FIELD() { return GetToken(CILParser.INSTR_FIELD, 0); } - public Instr_fieldContext(ParserRuleContext parent, int invokingState) - : base(parent, invokingState) - { - } - public override int RuleIndex { get { return RULE_instr_field; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitInstr_field(this); - else return visitor.VisitChildren(this); - } - } - - [RuleVersion(0)] - public Instr_fieldContext instr_field() { - Instr_fieldContext _localctx = new Instr_fieldContext(Context, State); - EnterRule(_localctx, 114, RULE_instr_field); - try { - EnterOuterAlt(_localctx, 1); - { - State = 962; - Match(INSTR_FIELD); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - ErrorHandler.ReportError(this, re); - ErrorHandler.Recover(this, re); - } - finally { - ExitRule(); - } - return _localctx; - } - - public partial class Instr_typeContext : ParserRuleContext { - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_TYPE() { return GetToken(CILParser.INSTR_TYPE, 0); } - public Instr_typeContext(ParserRuleContext parent, int invokingState) - : base(parent, invokingState) - { - } - public override int RuleIndex { get { return RULE_instr_type; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitInstr_type(this); - else return visitor.VisitChildren(this); - } - } - - [RuleVersion(0)] - public Instr_typeContext instr_type() { - Instr_typeContext _localctx = new Instr_typeContext(Context, State); - EnterRule(_localctx, 116, RULE_instr_type); - try { - EnterOuterAlt(_localctx, 1); - { - State = 964; - Match(INSTR_TYPE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - ErrorHandler.ReportError(this, re); - ErrorHandler.Recover(this, re); - } - finally { - ExitRule(); - } - return _localctx; - } - - public partial class Instr_stringContext : ParserRuleContext { - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_STRING() { return GetToken(CILParser.INSTR_STRING, 0); } - public Instr_stringContext(ParserRuleContext parent, int invokingState) - : base(parent, invokingState) - { - } - public override int RuleIndex { get { return RULE_instr_string; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitInstr_string(this); - else return visitor.VisitChildren(this); - } - } - - [RuleVersion(0)] - public Instr_stringContext instr_string() { - Instr_stringContext _localctx = new Instr_stringContext(Context, State); - EnterRule(_localctx, 118, RULE_instr_string); - try { - EnterOuterAlt(_localctx, 1); - { - State = 966; - Match(INSTR_STRING); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - ErrorHandler.ReportError(this, re); - ErrorHandler.Recover(this, re); - } - finally { - ExitRule(); - } - return _localctx; - } - - public partial class Instr_sigContext : ParserRuleContext { - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_SIG() { return GetToken(CILParser.INSTR_SIG, 0); } - public Instr_sigContext(ParserRuleContext parent, int invokingState) - : base(parent, invokingState) - { - } - public override int RuleIndex { get { return RULE_instr_sig; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitInstr_sig(this); - else return visitor.VisitChildren(this); - } - } - - [RuleVersion(0)] - public Instr_sigContext instr_sig() { - Instr_sigContext _localctx = new Instr_sigContext(Context, State); - EnterRule(_localctx, 120, RULE_instr_sig); - try { - EnterOuterAlt(_localctx, 1); - { - State = 968; - Match(INSTR_SIG); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - ErrorHandler.ReportError(this, re); - ErrorHandler.Recover(this, re); - } - finally { - ExitRule(); - } - return _localctx; - } - - public partial class Instr_tokContext : ParserRuleContext { - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_TOK() { return GetToken(CILParser.INSTR_TOK, 0); } - public Instr_tokContext(ParserRuleContext parent, int invokingState) - : base(parent, invokingState) - { - } - public override int RuleIndex { get { return RULE_instr_tok; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitInstr_tok(this); - else return visitor.VisitChildren(this); - } - } - - [RuleVersion(0)] - public Instr_tokContext instr_tok() { - Instr_tokContext _localctx = new Instr_tokContext(Context, State); - EnterRule(_localctx, 122, RULE_instr_tok); - try { - EnterOuterAlt(_localctx, 1); - { - State = 970; - Match(INSTR_TOK); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - ErrorHandler.ReportError(this, re); - ErrorHandler.Recover(this, re); - } - finally { - ExitRule(); - } - return _localctx; - } - - public partial class Instr_switchContext : ParserRuleContext { - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_SWITCH() { return GetToken(CILParser.INSTR_SWITCH, 0); } - public Instr_switchContext(ParserRuleContext parent, int invokingState) - : base(parent, invokingState) - { - } - public override int RuleIndex { get { return RULE_instr_switch; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitInstr_switch(this); - else return visitor.VisitChildren(this); - } - } - - [RuleVersion(0)] - public Instr_switchContext instr_switch() { - Instr_switchContext _localctx = new Instr_switchContext(Context, State); - EnterRule(_localctx, 124, RULE_instr_switch); - try { - EnterOuterAlt(_localctx, 1); - { - State = 972; - Match(INSTR_SWITCH); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - ErrorHandler.ReportError(this, re); - ErrorHandler.Recover(this, re); - } - finally { - ExitRule(); - } - return _localctx; - } - - public partial class InstrContext : ParserRuleContext { - [System.Diagnostics.DebuggerNonUserCode] public Instr_noneContext instr_none() { - return GetRuleContext(0); - } - [System.Diagnostics.DebuggerNonUserCode] public Instr_varContext instr_var() { - return GetRuleContext(0); - } - [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { - return GetRuleContext(0); - } - [System.Diagnostics.DebuggerNonUserCode] public IdContext id() { - return GetRuleContext(0); - } - [System.Diagnostics.DebuggerNonUserCode] public Instr_iContext instr_i() { - return GetRuleContext(0); - } - [System.Diagnostics.DebuggerNonUserCode] public Instr_i8Context instr_i8() { - return GetRuleContext(0); - } - [System.Diagnostics.DebuggerNonUserCode] public Int64Context int64() { - return GetRuleContext(0); - } - [System.Diagnostics.DebuggerNonUserCode] public Instr_rContext instr_r() { - return GetRuleContext(0); - } [System.Diagnostics.DebuggerNonUserCode] public Float64Context float64() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public BytesContext bytes() { - return GetRuleContext(0); - } - [System.Diagnostics.DebuggerNonUserCode] public Instr_brtargetContext instr_brtarget() { - return GetRuleContext(0); - } - [System.Diagnostics.DebuggerNonUserCode] public Instr_methodContext instr_method() { - return GetRuleContext(0); + [System.Diagnostics.DebuggerNonUserCode] public Int64Context int64() { + return GetRuleContext(0); } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_METHOD() { return GetToken(CILParser.INSTR_METHOD, 0); } [System.Diagnostics.DebuggerNonUserCode] public MethodRefContext methodRef() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public Instr_fieldContext instr_field() { - return GetRuleContext(0); - } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_FIELD() { return GetToken(CILParser.INSTR_FIELD, 0); } [System.Diagnostics.DebuggerNonUserCode] public FieldRefContext fieldRef() { return GetRuleContext(0); } [System.Diagnostics.DebuggerNonUserCode] public MdtokenContext mdtoken() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public Instr_typeContext instr_type() { - return GetRuleContext(0); - } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_TYPE() { return GetToken(CILParser.INSTR_TYPE, 0); } [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public Instr_stringContext instr_string() { - return GetRuleContext(0); - } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_STRING() { return GetToken(CILParser.INSTR_STRING, 0); } [System.Diagnostics.DebuggerNonUserCode] public CompQstringContext compQstring() { return GetRuleContext(0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ANSI() { return GetToken(CILParser.ANSI, 0); } - [System.Diagnostics.DebuggerNonUserCode] public Instr_sigContext instr_sig() { - return GetRuleContext(0); - } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_SIG() { return GetToken(CILParser.INSTR_SIG, 0); } [System.Diagnostics.DebuggerNonUserCode] public CallConvContext callConv() { return GetRuleContext(0); } @@ -4816,275 +4539,161 @@ [System.Diagnostics.DebuggerNonUserCode] public TypeContext type() { [System.Diagnostics.DebuggerNonUserCode] public SigArgsContext sigArgs() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public Instr_tokContext instr_tok() { - return GetRuleContext(0); - } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_TOK() { return GetToken(CILParser.INSTR_TOK, 0); } [System.Diagnostics.DebuggerNonUserCode] public OwnerTypeContext ownerType() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public Instr_switchContext instr_switch() { - return GetRuleContext(0); - } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_SWITCH() { return GetToken(CILParser.INSTR_SWITCH, 0); } [System.Diagnostics.DebuggerNonUserCode] public LabelsContext labels() { return GetRuleContext(0); } - public InstrContext(ParserRuleContext parent, int invokingState) + public InstructionIslandContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { } - public override int RuleIndex { get { return RULE_instr; } } + public override int RuleIndex { get { return RULE_instructionIsland; } } [System.Diagnostics.DebuggerNonUserCode] public override TResult Accept(IParseTreeVisitor visitor) { ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitInstr(this); + if (typedVisitor != null) return typedVisitor.VisitInstructionIsland(this); else return visitor.VisitChildren(this); } } [RuleVersion(0)] - public InstrContext instr() { - InstrContext _localctx = new InstrContext(Context, State); - EnterRule(_localctx, 126, RULE_instr); + public InstructionIslandContext instructionIsland() { + InstructionIslandContext _localctx = new InstructionIslandContext(Context, State); + EnterRule(_localctx, 104, RULE_instructionIsland); + BeginSubtree(); try { - State = 1056; + State = 1018; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,35,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,37,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 974; - instr_none(); + State = 984; + Match(INSTR_R); + State = 985; + float64(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 975; - instr_var(); - State = 976; - int32(); + State = 986; + Match(INSTR_R); + State = 987; + int64(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 978; - instr_var(); - State = 979; - id(); + State = 988; + Match(INSTR_METHOD); + State = 989; + methodRef(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 981; - instr_i(); - State = 982; - int32(); + State = 990; + Match(INSTR_FIELD); + State = 991; + fieldRef(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 984; - instr_i8(); - State = 985; - int64(); + State = 992; + Match(INSTR_FIELD); + State = 993; + mdtoken(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 987; - instr_r(); - State = 988; - float64(); + State = 994; + Match(INSTR_TYPE); + State = 995; + typeSpec(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 990; - instr_r(); - State = 991; - int64(); + State = 996; + Match(INSTR_STRING); + State = 997; + compQstring(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 993; - instr_r(); - State = 994; - Match(T__29); - State = 995; - bytes(); - State = 996; - Match(T__30); - } - break; - case 9: - EnterOuterAlt(_localctx, 9); - { State = 998; - instr_r(); + Match(INSTR_STRING); State = 999; - Match(T__83); + Match(ANSI); State = 1000; Match(T__29); State = 1001; - bytes(); + compQstring(); State = 1002; Match(T__30); } break; - case 10: - EnterOuterAlt(_localctx, 10); + case 9: + EnterOuterAlt(_localctx, 9); { State = 1004; - instr_brtarget(); + Match(INSTR_SIG); State = 1005; - int32(); - } - break; - case 11: - EnterOuterAlt(_localctx, 11); - { - State = 1007; - instr_brtarget(); - State = 1008; - id(); - } - break; - case 12: - EnterOuterAlt(_localctx, 12); - { - State = 1010; - instr_method(); - State = 1011; - methodRef(); - } - break; - case 13: - EnterOuterAlt(_localctx, 13); - { - State = 1013; - instr_field(); - State = 1014; - fieldRef(); - } - break; - case 14: - EnterOuterAlt(_localctx, 14); - { - State = 1016; - instr_field(); - State = 1017; - mdtoken(); - } - break; - case 15: - EnterOuterAlt(_localctx, 15); - { - State = 1019; - instr_type(); - State = 1020; - typeSpec(); - } - break; - case 16: - EnterOuterAlt(_localctx, 16); - { - State = 1022; - instr_string(); - State = 1023; - compQstring(); - } - break; - case 17: - EnterOuterAlt(_localctx, 17); - { - State = 1025; - instr_string(); - State = 1026; - Match(ANSI); - State = 1027; - Match(T__29); - State = 1028; - compQstring(); - State = 1029; - Match(T__30); - } - break; - case 18: - EnterOuterAlt(_localctx, 18); - { - State = 1031; - instr_string(); - State = 1032; - Match(T__83); - State = 1033; - Match(T__29); - State = 1034; - bytes(); - State = 1035; - Match(T__30); - } - break; - case 19: - EnterOuterAlt(_localctx, 19); - { - State = 1037; - instr_sig(); - State = 1038; callConv(); - State = 1039; + State = 1006; type(); - State = 1040; + State = 1007; sigArgs(); } break; - case 20: - EnterOuterAlt(_localctx, 20); + case 10: + EnterOuterAlt(_localctx, 10); { - State = 1042; - instr_tok(); - State = 1043; + State = 1009; + Match(INSTR_TOK); + State = 1010; ownerType(); } break; - case 21: - EnterOuterAlt(_localctx, 21); - { - State = 1045; - instr_tok(); - State = 1046; - int32(); - } - break; - case 22: - EnterOuterAlt(_localctx, 22); + case 11: + EnterOuterAlt(_localctx, 11); { - State = 1048; - instr_switch(); - State = 1049; + State = 1011; + Match(INSTR_SWITCH); + State = 1012; Match(T__29); - State = 1050; + State = 1013; labels(); - State = 1051; + State = 1014; Match(T__30); } break; - case 23: - EnterOuterAlt(_localctx, 23); + case 12: + EnterOuterAlt(_localctx, 12); { - State = 1053; - instr_switch(); - State = 1054; + State = 1016; + Match(INSTR_SWITCH); + State = 1017; Match(T__84); } break; } + Context.Stop = TokenStream.LT(-1); + Actions.ProcessInstructionIsland(_localctx); } catch (RecognitionException re) { _localctx.exception = re; @@ -5092,6 +4701,7 @@ public InstrContext instr() { ErrorHandler.Recover(this, re); } finally { + EndParseTreeMode(); ExitRule(); } return _localctx; @@ -5126,10 +4736,10 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public LabelsContext labels() { LabelsContext _localctx = new LabelsContext(Context, State); - EnterRule(_localctx, 128, RULE_labels); + EnterRule(_localctx, 106, RULE_labels); try { int _alt; - State = 1074; + State = 1036; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__30: @@ -5160,14 +4770,14 @@ public LabelsContext labels() { case ID: EnterOuterAlt(_localctx, 2); { - State = 1067; + State = 1029; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,37,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,39,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1061; + State = 1023; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -5191,29 +4801,29 @@ public LabelsContext labels() { case SQSTRING: case ID: { - State = 1059; + State = 1021; id(); } break; case INT32: { - State = 1060; + State = 1022; int32(); } break; default: throw new NoViableAltException(this); } - State = 1063; + State = 1025; Match(T__27); } } } - State = 1069; + State = 1031; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,37,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,39,Context); } - State = 1072; + State = 1034; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -5237,13 +4847,13 @@ public LabelsContext labels() { case SQSTRING: case ID: { - State = 1070; + State = 1032; id(); } break; case INT32: { - State = 1071; + State = 1033; int32(); } break; @@ -5290,34 +4900,34 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TypeArgsContext typeArgs() { TypeArgsContext _localctx = new TypeArgsContext(Context, State); - EnterRule(_localctx, 130, RULE_typeArgs); + EnterRule(_localctx, 108, RULE_typeArgs); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1076; + State = 1038; Match(T__85); - State = 1082; + State = 1044; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,40,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,42,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1077; + State = 1039; type(); - State = 1078; + State = 1040; Match(T__27); } } } - State = 1084; + State = 1046; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,40,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,42,Context); } - State = 1085; + State = 1047; type(); - State = 1086; + State = 1048; Match(T__86); } } @@ -5355,34 +4965,34 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public BoundsContext bounds() { BoundsContext _localctx = new BoundsContext(Context, State); - EnterRule(_localctx, 132, RULE_bounds); + EnterRule(_localctx, 110, RULE_bounds); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1088; + State = 1050; Match(T__41); - State = 1094; + State = 1056; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,41,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,43,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1089; + State = 1051; bound(); - State = 1090; + State = 1052; Match(T__27); } } } - State = 1096; + State = 1058; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,41,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,43,Context); } - State = 1097; + State = 1059; bound(); - State = 1098; + State = 1060; Match(T__42); } } @@ -5420,45 +5030,45 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SigArgsContext sigArgs() { SigArgsContext _localctx = new SigArgsContext(Context, State); - EnterRule(_localctx, 134, RULE_sigArgs); + EnterRule(_localctx, 112, RULE_sigArgs); try { int _alt; - State = 1113; + State = 1075; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__29: EnterOuterAlt(_localctx, 1); { - State = 1100; + State = 1062; Match(T__29); - State = 1106; + State = 1068; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,42,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,44,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1101; + State = 1063; sigArg(); - State = 1102; + State = 1064; Match(T__27); } } } - State = 1108; + State = 1070; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,42,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,44,Context); } - State = 1109; + State = 1071; sigArg(); - State = 1110; + State = 1072; Match(T__30); } break; case T__84: EnterOuterAlt(_localctx, 2); { - State = 1112; + State = 1074; Match(T__84); } break; @@ -5507,34 +5117,34 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SigArgContext sigArg() { SigArgContext _localctx = new SigArgContext(Context, State); - EnterRule(_localctx, 136, RULE_sigArg); + EnterRule(_localctx, 114, RULE_sigArg); int _la; try { - State = 1122; + State = 1084; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,45,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,47,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1115; + State = 1077; Match(ELLIPSIS); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1116; + State = 1078; paramAttr(); - State = 1117; + State = 1079; type(); - State = 1118; + State = 1080; marshalClause(); - State = 1120; + State = 1082; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 65534L) != 0) || ((((_la - 199)) & ~0x3f) == 0 && ((1L << (_la - 199)) & 299067162755073L) != 0) || _la==SQSTRING || _la==ID) { { - State = 1119; + State = 1081; id(); } } @@ -5585,97 +5195,97 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ClassNameContext className() { ClassNameContext _localctx = new ClassNameContext(Context, State); - EnterRule(_localctx, 138, RULE_className); + EnterRule(_localctx, 116, RULE_className); try { - State = 1149; + State = 1111; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,46,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,48,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1124; + State = 1086; Match(T__41); - State = 1125; + State = 1087; dottedName(); - State = 1126; + State = 1088; Match(T__42); - State = 1127; + State = 1089; slashedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1129; + State = 1091; Match(T__41); - State = 1130; + State = 1092; mdtoken(); - State = 1131; + State = 1093; Match(T__42); - State = 1132; + State = 1094; slashedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1134; + State = 1096; Match(T__41); - State = 1135; + State = 1097; Match(PTR); - State = 1136; + State = 1098; Match(T__42); - State = 1137; + State = 1099; slashedName(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1138; + State = 1100; Match(T__41); - State = 1139; + State = 1101; Match(MODULE); - State = 1140; + State = 1102; dottedName(); - State = 1141; + State = 1103; Match(T__42); - State = 1142; + State = 1104; slashedName(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1144; + State = 1106; slashedName(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1145; + State = 1107; mdtoken(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1146; + State = 1108; Match(THIS); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1147; + State = 1109; Match(BASE); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 1148; + State = 1110; Match(NESTER); } break; @@ -5715,30 +5325,30 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SlashedNameContext slashedName() { SlashedNameContext _localctx = new SlashedNameContext(Context, State); - EnterRule(_localctx, 140, RULE_slashedName); + EnterRule(_localctx, 118, RULE_slashedName); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1156; + State = 1118; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,47,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,49,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1151; + State = 1113; dottedName(); - State = 1152; + State = 1114; Match(T__87); } } } - State = 1158; + State = 1120; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,47,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,49,Context); } - State = 1159; + State = 1121; dottedName(); } } @@ -5776,22 +5386,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public AssemblyDeclsContext assemblyDecls() { AssemblyDeclsContext _localctx = new AssemblyDeclsContext(Context, State); - EnterRule(_localctx, 142, RULE_assemblyDecls); + EnterRule(_localctx, 120, RULE_assemblyDecls); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 1164; + State = 1126; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38654771200L) != 0) || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & 4294975503L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 6860954690125825L) != 0)) { { { - State = 1161; + State = 1123; assemblyDecl(); } } - State = 1166; + State = 1128; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -5835,20 +5445,20 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public AssemblyDeclContext assemblyDecl() { AssemblyDeclContext _localctx = new AssemblyDeclContext(Context, State); - EnterRule(_localctx, 144, RULE_assemblyDecl); + EnterRule(_localctx, 122, RULE_assemblyDecl); try { - State = 1172; + State = 1134; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case HASH: EnterOuterAlt(_localctx, 1); { { - State = 1167; + State = 1129; Match(HASH); - State = 1168; + State = 1130; Match(T__88); - State = 1169; + State = 1131; int32(); } } @@ -5857,7 +5467,7 @@ public AssemblyDeclContext assemblyDecl() { case PERMISSIONSET: EnterOuterAlt(_localctx, 2); { - State = 1170; + State = 1132; secDecl(); } break; @@ -5882,7 +5492,7 @@ public AssemblyDeclContext assemblyDecl() { case ID: EnterOuterAlt(_localctx, 3); { - State = 1171; + State = 1133; asmOrRefDecl(); } break; @@ -5928,46 +5538,46 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TypeSpecContext typeSpec() { TypeSpecContext _localctx = new TypeSpecContext(Context, State); - EnterRule(_localctx, 146, RULE_typeSpec); + EnterRule(_localctx, 124, RULE_typeSpec); try { - State = 1185; + State = 1147; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,50,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,52,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1174; + State = 1136; className(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1175; + State = 1137; Match(T__41); - State = 1176; + State = 1138; dottedName(); - State = 1177; + State = 1139; Match(T__42); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1179; + State = 1141; Match(T__41); - State = 1180; + State = 1142; Match(MODULE); - State = 1181; + State = 1143; dottedName(); - State = 1182; + State = 1144; Match(T__42); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1184; + State = 1146; type(); } break; @@ -6010,12 +5620,12 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public NativeTypeContext nativeType() { NativeTypeContext _localctx = new NativeTypeContext(Context, State); - EnterRule(_localctx, 148, RULE_nativeType); + EnterRule(_localctx, 126, RULE_nativeType); try { int _alt; - State = 1195; + State = 1157; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,52,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,54,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -6024,23 +5634,23 @@ public NativeTypeContext nativeType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1188; + State = 1150; nativeTypeElement(); - State = 1192; + State = 1154; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,51,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,53,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1189; + State = 1151; nativeTypeArrayPointerInfo(); } } } - State = 1194; + State = 1156; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,51,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,53,Context); } } break; @@ -6134,16 +5744,16 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { NativeTypeArrayPointerInfoContext _localctx = new NativeTypeArrayPointerInfoContext(Context, State); - EnterRule(_localctx, 150, RULE_nativeTypeArrayPointerInfo); + EnterRule(_localctx, 128, RULE_nativeTypeArrayPointerInfo); try { - State = 1214; + State = 1176; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,53,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,55,Context) ) { case 1: _localctx = new PointerNativeTypeContext(_localctx); EnterOuterAlt(_localctx, 1); { - State = 1197; + State = 1159; Match(PTR); } break; @@ -6151,7 +5761,7 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeNoSizeDataContext(_localctx); EnterOuterAlt(_localctx, 2); { - State = 1198; + State = 1160; Match(ARRAY_TYPE_NO_BOUNDS); } break; @@ -6159,11 +5769,11 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeSizeContext(_localctx); EnterOuterAlt(_localctx, 3); { - State = 1199; + State = 1161; Match(T__41); - State = 1200; + State = 1162; int32(); - State = 1201; + State = 1163; Match(T__42); } break; @@ -6171,15 +5781,15 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeSizeParamIndexContext(_localctx); EnterOuterAlt(_localctx, 4); { - State = 1203; + State = 1165; Match(T__41); - State = 1204; + State = 1166; int32(); - State = 1205; + State = 1167; Match(PLUS); - State = 1206; + State = 1168; int32(); - State = 1207; + State = 1169; Match(T__42); } break; @@ -6187,13 +5797,13 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeParamIndexContext(_localctx); EnterOuterAlt(_localctx, 5); { - State = 1209; + State = 1171; Match(T__41); - State = 1210; + State = 1172; Match(PLUS); - State = 1211; + State = 1173; int32(); - State = 1212; + State = 1174; Match(T__42); } break; @@ -6291,11 +5901,11 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public NativeTypeElementContext nativeTypeElement() { NativeTypeElementContext _localctx = new NativeTypeElementContext(Context, State); - EnterRule(_localctx, 152, RULE_nativeTypeElement); + EnterRule(_localctx, 130, RULE_nativeTypeElement); try { - State = 1308; + State = 1270; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,54,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,56,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -6304,412 +5914,412 @@ public NativeTypeElementContext nativeTypeElement() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1217; + State = 1179; _localctx.marshalType = Match(CUSTOM); - State = 1218; + State = 1180; Match(T__29); - State = 1219; + State = 1181; compQstring(); - State = 1220; + State = 1182; Match(T__27); - State = 1221; + State = 1183; compQstring(); - State = 1222; + State = 1184; Match(T__27); - State = 1223; + State = 1185; compQstring(); - State = 1224; + State = 1186; Match(T__27); - State = 1225; + State = 1187; compQstring(); - State = 1226; + State = 1188; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1228; + State = 1190; _localctx.marshalType = Match(CUSTOM); - State = 1229; + State = 1191; Match(T__29); - State = 1230; + State = 1192; compQstring(); - State = 1231; + State = 1193; Match(T__27); - State = 1232; + State = 1194; compQstring(); - State = 1233; + State = 1195; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1235; + State = 1197; Match(FIXED); - State = 1236; + State = 1198; _localctx.marshalType = Match(SYSSTRING); - State = 1237; + State = 1199; Match(T__41); - State = 1238; + State = 1200; int32(); - State = 1239; + State = 1201; Match(T__42); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1241; + State = 1203; Match(FIXED); - State = 1242; + State = 1204; _localctx.marshalType = Match(ARRAY); - State = 1243; + State = 1205; Match(T__41); - State = 1244; + State = 1206; int32(); - State = 1245; + State = 1207; Match(T__42); - State = 1246; + State = 1208; nativeType(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1248; + State = 1210; _localctx.marshalType = Match(VARIANT); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1249; + State = 1211; _localctx.marshalType = Match(CURRENCY); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1250; + State = 1212; _localctx.marshalType = Match(SYSCHAR); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 1251; + State = 1213; _localctx.marshalType = Match(VOID); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 1252; + State = 1214; _localctx.marshalType = Match(BOOL); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 1253; + State = 1215; _localctx.marshalType = Match(INT8); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 1254; + State = 1216; _localctx.marshalType = Match(INT16); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 1255; + State = 1217; _localctx.marshalType = Match(INT32_); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 1256; + State = 1218; _localctx.marshalType = Match(INT64_); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 1257; + State = 1219; _localctx.marshalType = Match(FLOAT32); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 1258; + State = 1220; _localctx.marshalType = Match(FLOAT64_); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 1259; + State = 1221; _localctx.marshalType = Match(ERROR); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 1260; + State = 1222; _localctx.marshalType = Match(UINT8); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 1261; + State = 1223; _localctx.marshalType = Match(UINT16); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 1262; + State = 1224; _localctx.marshalType = Match(UINT32); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 1263; + State = 1225; _localctx.marshalType = Match(UINT64); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 1264; + State = 1226; _localctx.marshalType = Match(DECIMAL); } break; case 23: EnterOuterAlt(_localctx, 23); { - State = 1265; + State = 1227; _localctx.marshalType = Match(DATE); } break; case 24: EnterOuterAlt(_localctx, 24); { - State = 1266; + State = 1228; _localctx.marshalType = Match(BSTR); } break; case 25: EnterOuterAlt(_localctx, 25); { - State = 1267; + State = 1229; _localctx.marshalType = Match(LPSTR); } break; case 26: EnterOuterAlt(_localctx, 26); { - State = 1268; + State = 1230; _localctx.marshalType = Match(LPWSTR); } break; case 27: EnterOuterAlt(_localctx, 27); { - State = 1269; + State = 1231; _localctx.marshalType = Match(LPTSTR); } break; case 28: EnterOuterAlt(_localctx, 28); { - State = 1270; + State = 1232; _localctx.marshalType = Match(OBJECTREF); } break; case 29: EnterOuterAlt(_localctx, 29); { - State = 1271; + State = 1233; _localctx.marshalType = Match(IUNKNOWN); - State = 1272; + State = 1234; iidParamIndex(); } break; case 30: EnterOuterAlt(_localctx, 30); { - State = 1273; + State = 1235; _localctx.marshalType = Match(IDISPATCH); - State = 1274; + State = 1236; iidParamIndex(); } break; case 31: EnterOuterAlt(_localctx, 31); { - State = 1275; + State = 1237; _localctx.marshalType = Match(STRUCT); } break; case 32: EnterOuterAlt(_localctx, 32); { - State = 1276; + State = 1238; _localctx.marshalType = Match(INTERFACE); - State = 1277; + State = 1239; iidParamIndex(); } break; case 33: EnterOuterAlt(_localctx, 33); { - State = 1278; + State = 1240; _localctx.marshalType = Match(SAFEARRAY); - State = 1279; + State = 1241; variantType(); } break; case 34: EnterOuterAlt(_localctx, 34); { - State = 1280; + State = 1242; _localctx.marshalType = Match(SAFEARRAY); - State = 1281; + State = 1243; variantType(); - State = 1282; + State = 1244; Match(T__27); - State = 1283; + State = 1245; compQstring(); } break; case 35: EnterOuterAlt(_localctx, 35); { - State = 1285; + State = 1247; _localctx.marshalType = Match(INT); } break; case 36: EnterOuterAlt(_localctx, 36); { - State = 1286; + State = 1248; _localctx.marshalType = Match(UINT); } break; case 37: EnterOuterAlt(_localctx, 37); { - State = 1287; + State = 1249; Match(T__89); - State = 1288; + State = 1250; _localctx.unsignedMarshalType = Match(INT8); } break; case 38: EnterOuterAlt(_localctx, 38); { - State = 1289; + State = 1251; Match(T__89); - State = 1290; + State = 1252; _localctx.unsignedMarshalType = Match(INT16); } break; case 39: EnterOuterAlt(_localctx, 39); { - State = 1291; + State = 1253; Match(T__89); - State = 1292; + State = 1254; _localctx.unsignedMarshalType = Match(INT32_); } break; case 40: EnterOuterAlt(_localctx, 40); { - State = 1293; + State = 1255; Match(T__89); - State = 1294; + State = 1256; _localctx.unsignedMarshalType = Match(INT64_); } break; case 41: EnterOuterAlt(_localctx, 41); { - State = 1295; + State = 1257; Match(T__61); - State = 1296; + State = 1258; _localctx.marshalType = Match(STRUCT); } break; case 42: EnterOuterAlt(_localctx, 42); { - State = 1297; + State = 1259; _localctx.marshalType = Match(BYVALSTR); } break; case 43: EnterOuterAlt(_localctx, 43); { - State = 1298; + State = 1260; Match(ANSI); - State = 1299; + State = 1261; _localctx.marshalType = Match(BSTR); } break; case 44: EnterOuterAlt(_localctx, 44); { - State = 1300; + State = 1262; _localctx.marshalType = Match(TBSTR); } break; case 45: EnterOuterAlt(_localctx, 45); { - State = 1301; + State = 1263; Match(VARIANT); - State = 1302; + State = 1264; _localctx.marshalBool = Match(BOOL); } break; case 46: EnterOuterAlt(_localctx, 46); { - State = 1303; + State = 1265; _localctx.marshalType = Match(METHOD); } break; case 47: EnterOuterAlt(_localctx, 47); { - State = 1304; + State = 1266; _localctx.marshalType = Match(LPSTRUCT); } break; case 48: EnterOuterAlt(_localctx, 48); { - State = 1305; + State = 1267; Match(T__33); - State = 1306; + State = 1268; _localctx.marshalType = Match(ANY); } break; case 49: EnterOuterAlt(_localctx, 49); { - State = 1307; + State = 1269; dottedName(); } break; @@ -6746,9 +6356,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public IidParamIndexContext iidParamIndex() { IidParamIndexContext _localctx = new IidParamIndexContext(Context, State); - EnterRule(_localctx, 154, RULE_iidParamIndex); + EnterRule(_localctx, 132, RULE_iidParamIndex); try { - State = 1317; + State = 1279; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__30: @@ -6762,15 +6372,15 @@ public IidParamIndexContext iidParamIndex() { case T__29: EnterOuterAlt(_localctx, 2); { - State = 1311; + State = 1273; Match(T__29); - State = 1312; + State = 1274; Match(T__90); - State = 1313; + State = 1275; Match(T__35); - State = 1314; + State = 1276; int32(); - State = 1315; + State = 1277; Match(T__30); } break; @@ -6821,13 +6431,13 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public VariantTypeContext variantType() { VariantTypeContext _localctx = new VariantTypeContext(Context, State); - EnterRule(_localctx, 156, RULE_variantType); + EnterRule(_localctx, 134, RULE_variantType); int _la; try { int _alt; - State = 1327; + State = 1289; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,57,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,59,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -6836,16 +6446,16 @@ public VariantTypeContext variantType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1320; + State = 1282; variantTypeElement(); - State = 1324; + State = 1286; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,56,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,58,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1321; + State = 1283; _la = TokenStream.LA(1); if ( !(((((_la - 229)) & ~0x3f) == 0 && ((1L << (_la - 229)) & 6442450945L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -6857,9 +6467,9 @@ public VariantTypeContext variantType() { } } } - State = 1326; + State = 1288; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,56,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,58,Context); } } break; @@ -6933,12 +6543,12 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public VariantTypeElementContext variantTypeElement() { VariantTypeElementContext _localctx = new VariantTypeElementContext(Context, State); - EnterRule(_localctx, 158, RULE_variantTypeElement); + EnterRule(_localctx, 136, RULE_variantTypeElement); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 1329; + State = 1291; _la = TokenStream.LA(1); if ( !(((((_la - 178)) & ~0x3f) == 0 && ((1L << (_la - 178)) & -4482436704239647L) != 0) || _la==CLSID || _la==PTR) ) { ErrorHandler.RecoverInline(this); @@ -6986,28 +6596,28 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TypeContext type() { TypeContext _localctx = new TypeContext(Context, State); - EnterRule(_localctx, 160, RULE_type); + EnterRule(_localctx, 138, RULE_type); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1331; + State = 1293; elementType(); - State = 1335; + State = 1297; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,58,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,60,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1332; + State = 1294; typeModifiers(); } } } - State = 1337; + State = 1299; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,58,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,60,Context); } } } @@ -7125,16 +6735,16 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TypeModifiersContext typeModifiers() { TypeModifiersContext _localctx = new TypeModifiersContext(Context, State); - EnterRule(_localctx, 162, RULE_typeModifiers); + EnterRule(_localctx, 140, RULE_typeModifiers); try { - State = 1356; + State = 1318; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,59,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,61,Context) ) { case 1: _localctx = new SZArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 1); { - State = 1338; + State = 1300; Match(ARRAY_TYPE_NO_BOUNDS); } break; @@ -7142,9 +6752,9 @@ public TypeModifiersContext typeModifiers() { _localctx = new SZArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 2); { - State = 1339; + State = 1301; Match(T__41); - State = 1340; + State = 1302; Match(T__42); } break; @@ -7152,7 +6762,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new ArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 3); { - State = 1341; + State = 1303; bounds(); } break; @@ -7160,7 +6770,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new ByRefModifierContext(_localctx); EnterOuterAlt(_localctx, 4); { - State = 1342; + State = 1304; Match(REF); } break; @@ -7168,7 +6778,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new PtrModifierContext(_localctx); EnterOuterAlt(_localctx, 5); { - State = 1343; + State = 1305; Match(PTR); } break; @@ -7176,7 +6786,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new PinnedModifierContext(_localctx); EnterOuterAlt(_localctx, 6); { - State = 1344; + State = 1306; Match(T__91); } break; @@ -7184,13 +6794,13 @@ public TypeModifiersContext typeModifiers() { _localctx = new RequiredModifierContext(_localctx); EnterOuterAlt(_localctx, 7); { - State = 1345; + State = 1307; Match(T__92); - State = 1346; + State = 1308; Match(T__29); - State = 1347; + State = 1309; typeSpec(); - State = 1348; + State = 1310; Match(T__30); } break; @@ -7198,13 +6808,13 @@ public TypeModifiersContext typeModifiers() { _localctx = new OptionalModifierContext(_localctx); EnterOuterAlt(_localctx, 8); { - State = 1350; + State = 1312; Match(T__93); - State = 1351; + State = 1313; Match(T__29); - State = 1352; + State = 1314; typeSpec(); - State = 1353; + State = 1315; Match(T__30); } break; @@ -7212,7 +6822,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new GenericArgumentsModifierContext(_localctx); EnterOuterAlt(_localctx, 9); { - State = 1355; + State = 1317; typeArgs(); } break; @@ -7283,146 +6893,146 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ElementTypeContext elementType() { ElementTypeContext _localctx = new ElementTypeContext(Context, State); - EnterRule(_localctx, 164, RULE_elementType); + EnterRule(_localctx, 142, RULE_elementType); try { - State = 1388; + State = 1350; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,60,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,62,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1358; + State = 1320; Match(T__38); - State = 1359; + State = 1321; className(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1360; + State = 1322; Match(OBJECT); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1361; + State = 1323; Match(VALUE); - State = 1362; + State = 1324; Match(T__38); - State = 1363; + State = 1325; className(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1364; + State = 1326; Match(VALUETYPE); - State = 1365; + State = 1327; className(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1366; + State = 1328; Match(METHOD); - State = 1367; + State = 1329; callConv(); - State = 1368; + State = 1330; type(); - State = 1369; + State = 1331; Match(PTR); - State = 1370; + State = 1332; sigArgs(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1372; + State = 1334; Match(METHOD_TYPE_PARAMETER); - State = 1373; + State = 1335; int32(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1374; + State = 1336; Match(TYPE_PARAMETER); - State = 1375; + State = 1337; int32(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1376; + State = 1338; Match(METHOD_TYPE_PARAMETER); - State = 1377; + State = 1339; dottedName(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 1378; + State = 1340; Match(TYPE_PARAMETER); - State = 1379; + State = 1341; dottedName(); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 1380; + State = 1342; Match(TYPEDREF); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 1381; + State = 1343; Match(VOID); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 1382; + State = 1344; nativeInt(); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 1383; + State = 1345; nativeUint(); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 1384; + State = 1346; simpleType(); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 1385; + State = 1347; dottedName(); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 1386; + State = 1348; Match(ELLIPSIS); - State = 1387; + State = 1349; type(); } break; @@ -7469,135 +7079,135 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SimpleTypeContext simpleType() { SimpleTypeContext _localctx = new SimpleTypeContext(Context, State); - EnterRule(_localctx, 166, RULE_simpleType); + EnterRule(_localctx, 144, RULE_simpleType); try { - State = 1411; + State = 1373; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,61,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,63,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1390; + State = 1352; Match(CHAR); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1391; + State = 1353; Match(STRING); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1392; + State = 1354; Match(BOOL); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1393; + State = 1355; Match(INT8); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1394; + State = 1356; Match(INT16); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1395; + State = 1357; Match(INT32_); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1396; + State = 1358; Match(INT64_); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1397; + State = 1359; Match(FLOAT32); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 1398; + State = 1360; Match(FLOAT64_); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 1399; + State = 1361; Match(UINT8); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 1400; + State = 1362; Match(UINT16); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 1401; + State = 1363; Match(UINT32); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 1402; + State = 1364; Match(UINT64); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 1403; + State = 1365; Match(T__89); - State = 1404; + State = 1366; Match(INT8); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 1405; + State = 1367; Match(T__89); - State = 1406; + State = 1368; Match(INT16); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 1407; + State = 1369; Match(T__89); - State = 1408; + State = 1370; Match(INT32_); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 1409; + State = 1371; Match(T__89); - State = 1410; + State = 1372; Match(INT64_); } break; @@ -7638,11 +7248,11 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public BoundContext bound() { BoundContext _localctx = new BoundContext(Context, State); - EnterRule(_localctx, 168, RULE_bound); + EnterRule(_localctx, 146, RULE_bound); try { - State = 1423; + State = 1385; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,62,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,64,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -7651,34 +7261,34 @@ public BoundContext bound() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1414; + State = 1376; Match(ELLIPSIS); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1415; + State = 1377; int32(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1416; + State = 1378; int32(); - State = 1417; + State = 1379; Match(ELLIPSIS); - State = 1418; + State = 1380; int32(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1420; + State = 1382; int32(); - State = 1421; + State = 1383; Match(ELLIPSIS); } break; @@ -7713,13 +7323,13 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public NativeIntContext nativeInt() { NativeIntContext _localctx = new NativeIntContext(Context, State); - EnterRule(_localctx, 170, RULE_nativeInt); + EnterRule(_localctx, 148, RULE_nativeInt); try { EnterOuterAlt(_localctx, 1); { - State = 1425; + State = 1387; Match(T__0); - State = 1426; + State = 1388; Match(INT); } } @@ -7753,26 +7363,26 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public NativeUintContext nativeUint() { NativeUintContext _localctx = new NativeUintContext(Context, State); - EnterRule(_localctx, 172, RULE_nativeUint); + EnterRule(_localctx, 150, RULE_nativeUint); try { EnterOuterAlt(_localctx, 1); { - State = 1428; + State = 1390; Match(T__0); - State = 1432; + State = 1394; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__89: { - State = 1429; + State = 1391; Match(T__89); - State = 1430; + State = 1392; Match(INT); } break; case UINT: { - State = 1431; + State = 1393; Match(UINT); } break; @@ -7832,128 +7442,128 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SecDeclContext secDecl() { SecDeclContext _localctx = new SecDeclContext(Context, State); - EnterRule(_localctx, 174, RULE_secDecl); + EnterRule(_localctx, 152, RULE_secDecl); int _la; try { - State = 1481; + State = 1443; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,65,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,67,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1434; + State = 1396; Match(PERMISSION); - State = 1435; + State = 1397; secAction(); - State = 1436; + State = 1398; typeSpec(); - State = 1437; + State = 1399; Match(T__29); - State = 1438; + State = 1400; nameValPairs(); - State = 1439; + State = 1401; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1441; + State = 1403; Match(PERMISSION); - State = 1442; + State = 1404; secAction(); - State = 1443; + State = 1405; typeSpec(); - State = 1444; + State = 1406; Match(T__35); - State = 1445; + State = 1407; Match(T__16); - State = 1446; + State = 1408; customBlobDescr(); - State = 1447; + State = 1409; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1449; + State = 1411; Match(PERMISSION); - State = 1450; + State = 1412; secAction(); - State = 1451; + State = 1413; typeSpec(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1453; + State = 1415; Match(PERMISSIONSET); - State = 1454; + State = 1416; secAction(); - State = 1455; + State = 1417; Match(T__35); - State = 1457; + State = 1419; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__83) { { - State = 1456; + State = 1418; Match(T__83); } } - State = 1459; + State = 1421; Match(T__29); - State = 1460; + State = 1422; bytes(); - State = 1461; + State = 1423; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1463; + State = 1425; Match(PERMISSIONSET); - State = 1464; + State = 1426; secAction(); - State = 1465; + State = 1427; Match(T__83); - State = 1466; + State = 1428; Match(T__29); - State = 1467; + State = 1429; bytes(); - State = 1468; + State = 1430; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1470; + State = 1432; Match(PERMISSIONSET); - State = 1471; + State = 1433; secAction(); - State = 1472; + State = 1434; compQstring(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1474; + State = 1436; Match(PERMISSIONSET); - State = 1475; + State = 1437; secAction(); - State = 1476; + State = 1438; Match(T__35); - State = 1477; + State = 1439; Match(T__16); - State = 1478; + State = 1440; secAttrSetBlob(); - State = 1479; + State = 1441; Match(T__17); } break; @@ -7993,10 +7603,10 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SecAttrSetBlobContext secAttrSetBlob() { SecAttrSetBlobContext _localctx = new SecAttrSetBlobContext(Context, State); - EnterRule(_localctx, 176, RULE_secAttrSetBlob); + EnterRule(_localctx, 154, RULE_secAttrSetBlob); try { int _alt; - State = 1493; + State = 1455; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__17: @@ -8041,25 +7651,25 @@ public SecAttrSetBlobContext secAttrSetBlob() { case ID: EnterOuterAlt(_localctx, 2); { - State = 1489; + State = 1451; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,66,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,68,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1484; + State = 1446; secAttrBlob(); - State = 1485; + State = 1447; Match(T__27); } } } - State = 1491; + State = 1453; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,66,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,68,Context); } - State = 1492; + State = 1454; secAttrBlob(); } break; @@ -8102,40 +7712,40 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SecAttrBlobContext secAttrBlob() { SecAttrBlobContext _localctx = new SecAttrBlobContext(Context, State); - EnterRule(_localctx, 178, RULE_secAttrBlob); + EnterRule(_localctx, 156, RULE_secAttrBlob); try { - State = 1508; + State = 1470; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,68,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,70,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1495; + State = 1457; Match(T__38); - State = 1496; + State = 1458; Match(SQSTRING); - State = 1497; + State = 1459; Match(T__35); - State = 1498; + State = 1460; Match(T__16); - State = 1499; + State = 1461; customBlobNVPairs(); - State = 1500; + State = 1462; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1502; + State = 1464; typeSpec(); - State = 1503; + State = 1465; Match(T__35); - State = 1504; + State = 1466; Match(T__16); - State = 1505; + State = 1467; customBlobNVPairs(); - State = 1506; + State = 1468; Match(T__17); } break; @@ -8175,30 +7785,30 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public NameValPairsContext nameValPairs() { NameValPairsContext _localctx = new NameValPairsContext(Context, State); - EnterRule(_localctx, 180, RULE_nameValPairs); + EnterRule(_localctx, 158, RULE_nameValPairs); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1515; + State = 1477; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,69,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,71,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1510; + State = 1472; nameValPair(); - State = 1511; + State = 1473; Match(T__27); } } } - State = 1517; + State = 1479; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,69,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,71,Context); } - State = 1518; + State = 1480; nameValPair(); } } @@ -8236,15 +7846,15 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public NameValPairContext nameValPair() { NameValPairContext _localctx = new NameValPairContext(Context, State); - EnterRule(_localctx, 182, RULE_nameValPair); + EnterRule(_localctx, 160, RULE_nameValPair); try { EnterOuterAlt(_localctx, 1); { - State = 1520; + State = 1482; compQstring(); - State = 1521; + State = 1483; Match(T__35); - State = 1522; + State = 1484; caValue(); } } @@ -8276,12 +7886,12 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TruefalseContext truefalse() { TruefalseContext _localctx = new TruefalseContext(Context, State); - EnterRule(_localctx, 184, RULE_truefalse); + EnterRule(_localctx, 162, RULE_truefalse); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 1524; + State = 1486; _la = TokenStream.LA(1); if ( !(_la==T__94 || _la==T__95) ) { ErrorHandler.RecoverInline(this); @@ -8335,106 +7945,106 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public CaValueContext caValue() { CaValueContext _localctx = new CaValueContext(Context, State); - EnterRule(_localctx, 186, RULE_caValue); + EnterRule(_localctx, 164, RULE_caValue); try { - State = 1560; + State = 1522; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,70,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,72,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1526; + State = 1488; truefalse(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1527; + State = 1489; int32(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1528; + State = 1490; Match(INT32_); - State = 1529; + State = 1491; Match(T__29); - State = 1530; + State = 1492; int32(); - State = 1531; + State = 1493; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1533; + State = 1495; compQstring(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1534; + State = 1496; className(); - State = 1535; + State = 1497; Match(T__29); - State = 1536; + State = 1498; Match(INT8); - State = 1537; + State = 1499; Match(T__74); - State = 1538; + State = 1500; int32(); - State = 1539; + State = 1501; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1541; + State = 1503; className(); - State = 1542; + State = 1504; Match(T__29); - State = 1543; + State = 1505; Match(INT16); - State = 1544; + State = 1506; Match(T__74); - State = 1545; + State = 1507; int32(); - State = 1546; + State = 1508; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1548; + State = 1510; className(); - State = 1549; + State = 1511; Match(T__29); - State = 1550; + State = 1512; Match(INT32_); - State = 1551; + State = 1513; Match(T__74); - State = 1552; + State = 1514; int32(); - State = 1553; + State = 1515; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1555; + State = 1517; className(); - State = 1556; + State = 1518; Match(T__29); - State = 1557; + State = 1519; int32(); - State = 1558; + State = 1520; Match(T__30); } break; @@ -8468,12 +8078,12 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SecActionContext secAction() { SecActionContext _localctx = new SecActionContext(Context, State); - EnterRule(_localctx, 188, RULE_secAction); + EnterRule(_localctx, 166, RULE_secAction); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 1562; + State = 1524; _la = TokenStream.LA(1); if ( !(((((_la - 97)) & ~0x3f) == 0 && ((1L << (_la - 97)) & 32767L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -8540,107 +8150,107 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public MethodRefContext methodRef() { MethodRefContext _localctx = new MethodRefContext(Context, State); - EnterRule(_localctx, 190, RULE_methodRef); + EnterRule(_localctx, 168, RULE_methodRef); int _la; try { - State = 1598; + State = 1560; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,73,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,75,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1564; + State = 1526; callConv(); - State = 1565; + State = 1527; type(); - State = 1566; + State = 1528; typeSpec(); - State = 1567; + State = 1529; Match(DCOLON); - State = 1568; + State = 1530; methodName(); - State = 1570; + State = 1532; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 1569; + State = 1531; typeArgs(); } } - State = 1572; + State = 1534; sigArgs(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1574; + State = 1536; callConv(); - State = 1575; + State = 1537; type(); - State = 1576; + State = 1538; typeSpec(); - State = 1577; + State = 1539; Match(DCOLON); - State = 1578; + State = 1540; methodName(); - State = 1579; + State = 1541; genArityNotEmpty(); - State = 1580; + State = 1542; sigArgs(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1582; + State = 1544; callConv(); - State = 1583; + State = 1545; type(); - State = 1584; + State = 1546; methodName(); - State = 1586; + State = 1548; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 1585; + State = 1547; typeArgs(); } } - State = 1588; + State = 1550; sigArgs(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1590; + State = 1552; callConv(); - State = 1591; + State = 1553; type(); - State = 1592; + State = 1554; methodName(); - State = 1593; + State = 1555; genArityNotEmpty(); - State = 1594; + State = 1556; sigArgs(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1596; + State = 1558; mdtoken(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1597; + State = 1559; dottedName(); } break; @@ -8685,46 +8295,46 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public CallConvContext callConv() { CallConvContext _localctx = new CallConvContext(Context, State); - EnterRule(_localctx, 192, RULE_callConv); + EnterRule(_localctx, 170, RULE_callConv); try { - State = 1610; + State = 1572; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,74,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,76,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1600; + State = 1562; Match(INSTANCE); - State = 1601; + State = 1563; callConv(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1602; + State = 1564; Match(EXPLICIT); - State = 1603; + State = 1565; callConv(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1604; + State = 1566; callKind(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1605; + State = 1567; Match(T__111); - State = 1606; + State = 1568; Match(T__29); - State = 1607; + State = 1569; int32(); - State = 1608; + State = 1570; Match(T__30); } break; @@ -8765,11 +8375,11 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public CallKindContext callKind() { CallKindContext _localctx = new CallKindContext(Context, State); - EnterRule(_localctx, 194, RULE_callKind); + EnterRule(_localctx, 172, RULE_callKind); try { - State = 1624; + State = 1586; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,75,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,77,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -8778,57 +8388,57 @@ public CallKindContext callKind() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1613; + State = 1575; Match(DEFAULT); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1614; + State = 1576; Match(VARARG); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1615; + State = 1577; Match(UNMANAGED); - State = 1616; + State = 1578; Match(CDECL); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1617; + State = 1579; Match(UNMANAGED); - State = 1618; + State = 1580; Match(STDCALL); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1619; + State = 1581; Match(UNMANAGED); - State = 1620; + State = 1582; Match(THISCALL); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1621; + State = 1583; Match(UNMANAGED); - State = 1622; + State = 1584; Match(FASTCALL); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1623; + State = 1585; Match(UNMANAGED); } break; @@ -8865,17 +8475,17 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public MdtokenContext mdtoken() { MdtokenContext _localctx = new MdtokenContext(Context, State); - EnterRule(_localctx, 196, RULE_mdtoken); + EnterRule(_localctx, 174, RULE_mdtoken); try { EnterOuterAlt(_localctx, 1); { - State = 1626; + State = 1588; Match(T__112); - State = 1627; + State = 1589; Match(T__29); - State = 1628; + State = 1590; int32(); - State = 1629; + State = 1591; Match(T__30); } } @@ -8917,33 +8527,33 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public MemberRefContext memberRef() { MemberRefContext _localctx = new MemberRefContext(Context, State); - EnterRule(_localctx, 198, RULE_memberRef); + EnterRule(_localctx, 176, RULE_memberRef); try { - State = 1636; + State = 1598; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case METHOD: EnterOuterAlt(_localctx, 1); { - State = 1631; + State = 1593; Match(METHOD); - State = 1632; + State = 1594; methodRef(); } break; case T__36: EnterOuterAlt(_localctx, 2); { - State = 1633; + State = 1595; Match(T__36); - State = 1634; + State = 1596; fieldRef(); } break; case T__112: EnterOuterAlt(_localctx, 3); { - State = 1635; + State = 1597; mdtoken(); } break; @@ -8989,37 +8599,37 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public FieldRefContext fieldRef() { FieldRefContext _localctx = new FieldRefContext(Context, State); - EnterRule(_localctx, 200, RULE_fieldRef); + EnterRule(_localctx, 178, RULE_fieldRef); try { - State = 1647; + State = 1609; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,77,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,79,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1638; + State = 1600; type(); - State = 1639; + State = 1601; typeSpec(); - State = 1640; + State = 1602; Match(DCOLON); - State = 1641; + State = 1603; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1643; + State = 1605; type(); - State = 1644; + State = 1606; dottedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1646; + State = 1608; dottedName(); } break; @@ -9059,30 +8669,30 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TypeListContext typeList() { TypeListContext _localctx = new TypeListContext(Context, State); - EnterRule(_localctx, 202, RULE_typeList); + EnterRule(_localctx, 180, RULE_typeList); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1654; + State = 1616; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,78,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,80,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1649; + State = 1611; typeSpec(); - State = 1650; + State = 1612; Match(T__27); } } } - State = 1656; + State = 1618; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,78,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,80,Context); } - State = 1657; + State = 1619; typeSpec(); } } @@ -9117,9 +8727,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TyparsClauseContext typarsClause() { TyparsClauseContext _localctx = new TyparsClauseContext(Context, State); - EnterRule(_localctx, 204, RULE_typarsClause); + EnterRule(_localctx, 182, RULE_typarsClause); try { - State = 1664; + State = 1626; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -9134,11 +8744,11 @@ public TyparsClauseContext typarsClause() { case T__85: EnterOuterAlt(_localctx, 2); { - State = 1660; + State = 1622; Match(T__85); - State = 1661; + State = 1623; typars(); - State = 1662; + State = 1624; Match(T__86); } break; @@ -9186,63 +8796,63 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TyparAttribContext typarAttrib() { TyparAttribContext _localctx = new TyparAttribContext(Context, State); - EnterRule(_localctx, 206, RULE_typarAttrib); + EnterRule(_localctx, 184, RULE_typarAttrib); try { - State = 1677; + State = 1639; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case PLUS: EnterOuterAlt(_localctx, 1); { - State = 1666; + State = 1628; _localctx.covariant = Match(PLUS); } break; case T__113: EnterOuterAlt(_localctx, 2); { - State = 1667; + State = 1629; _localctx.contravariant = Match(T__113); } break; case T__38: EnterOuterAlt(_localctx, 3); { - State = 1668; + State = 1630; _localctx.@class = Match(T__38); } break; case VALUETYPE: EnterOuterAlt(_localctx, 4); { - State = 1669; + State = 1631; _localctx.valuetype = Match(VALUETYPE); } break; case T__114: EnterOuterAlt(_localctx, 5); { - State = 1670; + State = 1632; _localctx.byrefLike = Match(T__114); } break; case T__115: EnterOuterAlt(_localctx, 6); { - State = 1671; + State = 1633; _localctx.ctor = Match(T__115); } break; case T__69: EnterOuterAlt(_localctx, 7); { - State = 1672; + State = 1634; Match(T__69); - State = 1673; + State = 1635; Match(T__29); - State = 1674; + State = 1636; _localctx.flags = int32(); - State = 1675; + State = 1637; Match(T__30); } break; @@ -9284,22 +8894,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TyparAttribsContext typarAttribs() { TyparAttribsContext _localctx = new TyparAttribsContext(Context, State); - EnterRule(_localctx, 208, RULE_typarAttribs); + EnterRule(_localctx, 186, RULE_typarAttribs); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 1682; + State = 1644; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__38 || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & 123145302310913L) != 0) || _la==VALUETYPE || _la==PLUS) { { { - State = 1679; + State = 1641; typarAttrib(); } } - State = 1684; + State = 1646; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -9342,24 +8952,24 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TyparContext typar() { TyparContext _localctx = new TyparContext(Context, State); - EnterRule(_localctx, 210, RULE_typar); + EnterRule(_localctx, 188, RULE_typar); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 1685; + State = 1647; typarAttribs(); - State = 1687; + State = 1649; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__29) { { - State = 1686; + State = 1648; tyBound(); } } - State = 1689; + State = 1651; dottedName(); } } @@ -9397,30 +9007,30 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TyparsContext typars() { TyparsContext _localctx = new TyparsContext(Context, State); - EnterRule(_localctx, 212, RULE_typars); + EnterRule(_localctx, 190, RULE_typars); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1696; + State = 1658; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,83,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,85,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1691; + State = 1653; typar(); - State = 1692; + State = 1654; Match(T__27); } } } - State = 1698; + State = 1660; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,83,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,85,Context); } - State = 1699; + State = 1661; typar(); } } @@ -9455,15 +9065,15 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TyBoundContext tyBound() { TyBoundContext _localctx = new TyBoundContext(Context, State); - EnterRule(_localctx, 214, RULE_tyBound); + EnterRule(_localctx, 192, RULE_tyBound); try { EnterOuterAlt(_localctx, 1); { - State = 1701; + State = 1663; Match(T__29); - State = 1702; + State = 1664; typeList(); - State = 1703; + State = 1665; Match(T__30); } } @@ -9498,9 +9108,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public GenArityContext genArity() { GenArityContext _localctx = new GenArityContext(Context, State); - EnterRule(_localctx, 216, RULE_genArity); + EnterRule(_localctx, 194, RULE_genArity); try { - State = 1707; + State = 1669; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__29: @@ -9512,7 +9122,7 @@ public GenArityContext genArity() { case T__85: EnterOuterAlt(_localctx, 2); { - State = 1706; + State = 1668; genArityNotEmpty(); } break; @@ -9551,19 +9161,19 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public GenArityNotEmptyContext genArityNotEmpty() { GenArityNotEmptyContext _localctx = new GenArityNotEmptyContext(Context, State); - EnterRule(_localctx, 218, RULE_genArityNotEmpty); + EnterRule(_localctx, 196, RULE_genArityNotEmpty); try { EnterOuterAlt(_localctx, 1); { - State = 1709; + State = 1671; Match(T__85); - State = 1710; + State = 1672; Match(T__41); - State = 1711; + State = 1673; int32(); - State = 1712; + State = 1674; Match(T__42); - State = 1713; + State = 1675; Match(T__86); } } @@ -9706,347 +9316,347 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ClassDeclContext classDecl() { ClassDeclContext _localctx = new ClassDeclContext(Context, State); - EnterRule(_localctx, 220, RULE_classDecl); + EnterRule(_localctx, 198, RULE_classDecl); BeginSubtree(); try { int _alt; - State = 1831; + State = 1793; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,89,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,91,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1715; + State = 1677; methodHead(); - State = 1716; + State = 1678; Match(T__16); - State = 1717; + State = 1679; methodDecls(); - State = 1718; + State = 1680; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1720; + State = 1682; classHead(); - State = 1721; + State = 1683; Match(T__16); - State = 1722; + State = 1684; classDecls(); - State = 1723; + State = 1685; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1725; + State = 1687; eventHead(); - State = 1726; + State = 1688; Match(T__16); - State = 1727; + State = 1689; eventDecls(); - State = 1728; + State = 1690; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1730; + State = 1692; propHead(); - State = 1731; + State = 1693; Match(T__16); - State = 1732; + State = 1694; propDecls(); - State = 1733; + State = 1695; Match(T__17); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1735; + State = 1697; fieldDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1736; + State = 1698; dataDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1737; + State = 1699; secDecl(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1738; + State = 1700; extSourceSpec(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 1739; + State = 1701; customAttrDecl(); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 1740; + State = 1702; Match(T__116); - State = 1741; + State = 1703; int32(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 1742; + State = 1704; Match(T__117); - State = 1743; + State = 1705; int32(); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 1744; + State = 1706; exportHead(); - State = 1745; + State = 1707; Match(T__16); - State = 1746; + State = 1708; exptypeDecls(); - State = 1747; + State = 1709; Match(T__17); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 1749; + State = 1711; Match(OVERRIDE); - State = 1750; + State = 1712; typeSpec(); - State = 1751; + State = 1713; Match(DCOLON); - State = 1752; + State = 1714; methodName(); - State = 1753; + State = 1715; Match(T__118); - State = 1754; + State = 1716; callConv(); - State = 1755; + State = 1717; type(); - State = 1756; + State = 1718; typeSpec(); - State = 1757; + State = 1719; Match(DCOLON); - State = 1758; + State = 1720; methodName(); - State = 1759; + State = 1721; sigArgs(); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 1761; + State = 1723; Match(OVERRIDE); - State = 1762; + State = 1724; Match(METHOD); - State = 1763; + State = 1725; callConv(); - State = 1764; + State = 1726; type(); - State = 1765; + State = 1727; typeSpec(); - State = 1766; + State = 1728; Match(DCOLON); - State = 1767; + State = 1729; methodName(); - State = 1768; + State = 1730; genArity(); - State = 1769; + State = 1731; sigArgs(); - State = 1770; + State = 1732; Match(T__118); - State = 1771; + State = 1733; Match(METHOD); - State = 1772; + State = 1734; callConv(); - State = 1773; + State = 1735; type(); - State = 1774; + State = 1736; typeSpec(); - State = 1775; + State = 1737; Match(DCOLON); - State = 1776; + State = 1738; methodName(); - State = 1777; + State = 1739; genArity(); - State = 1778; + State = 1740; sigArgs(); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 1780; + State = 1742; languageDecl(); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 1781; + State = 1743; compControl(); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 1782; + State = 1744; Match(PARAM); - State = 1783; + State = 1745; Match(TYPE); - State = 1784; + State = 1746; Match(T__41); - State = 1785; + State = 1747; int32(); - State = 1786; + State = 1748; Match(T__42); - State = 1790; + State = 1752; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,85,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,87,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1787; + State = 1749; customAttrDecl(); } } } - State = 1792; + State = 1754; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,85,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,87,Context); } } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 1793; + State = 1755; Match(PARAM); - State = 1794; + State = 1756; Match(TYPE); - State = 1795; + State = 1757; dottedName(); - State = 1799; + State = 1761; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,86,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1796; + State = 1758; customAttrDecl(); } } } - State = 1801; + State = 1763; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,86,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); } } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 1802; + State = 1764; Match(PARAM); - State = 1803; + State = 1765; Match(CONSTRAINT); - State = 1804; + State = 1766; Match(T__41); - State = 1805; + State = 1767; int32(); - State = 1806; + State = 1768; Match(T__42); - State = 1807; + State = 1769; Match(T__27); - State = 1808; + State = 1770; typeSpec(); - State = 1812; + State = 1774; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,87,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1809; + State = 1771; customAttrDecl(); } } } - State = 1814; + State = 1776; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,87,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); } } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 1815; + State = 1777; Match(PARAM); - State = 1816; + State = 1778; Match(CONSTRAINT); - State = 1817; + State = 1779; dottedName(); - State = 1818; + State = 1780; Match(T__27); - State = 1819; + State = 1781; typeSpec(); - State = 1823; + State = 1785; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1820; + State = 1782; customAttrDecl(); } } } - State = 1825; + State = 1787; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); } } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 1826; + State = 1788; Match(T__119); - State = 1827; + State = 1789; Match(TYPE); - State = 1828; + State = 1790; typeSpec(); - State = 1829; + State = 1791; customDescr(); } break; @@ -10110,22 +9720,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public FieldDeclContext fieldDecl() { FieldDeclContext _localctx = new FieldDeclContext(Context, State); - EnterRule(_localctx, 222, RULE_fieldDecl); + EnterRule(_localctx, 200, RULE_fieldDecl); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1833; + State = 1795; Match(T__120); - State = 1834; + State = 1796; repeatOpt(); - State = 1843; + State = 1805; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,93,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { - State = 1841; + State = 1803; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -10144,19 +9754,19 @@ public FieldDeclContext fieldDecl() { case T__125: case T__126: { - State = 1835; + State = 1797; fieldAttr(); } break; case T__121: { - State = 1836; + State = 1798; Match(T__121); - State = 1837; + State = 1799; Match(T__29); - State = 1838; + State = 1800; marshalBlob(); - State = 1839; + State = 1801; Match(T__30); } break; @@ -10165,17 +9775,17 @@ public FieldDeclContext fieldDecl() { } } } - State = 1845; + State = 1807; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,93,Context); } - State = 1846; + State = 1808; type(); - State = 1847; + State = 1809; dottedName(); - State = 1848; + State = 1810; atOpt(); - State = 1849; + State = 1811; initOpt(); } } @@ -10210,119 +9820,119 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public FieldAttrContext fieldAttr() { FieldAttrContext _localctx = new FieldAttrContext(Context, State); - EnterRule(_localctx, 224, RULE_fieldAttr); + EnterRule(_localctx, 202, RULE_fieldAttr); try { - State = 1870; + State = 1832; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__122: EnterOuterAlt(_localctx, 1); { - State = 1851; + State = 1813; Match(T__122); } break; case T__50: EnterOuterAlt(_localctx, 2); { - State = 1852; + State = 1814; Match(T__50); } break; case T__51: EnterOuterAlt(_localctx, 3); { - State = 1853; + State = 1815; Match(T__51); } break; case T__62: EnterOuterAlt(_localctx, 4); { - State = 1854; + State = 1816; Match(T__62); } break; case T__123: EnterOuterAlt(_localctx, 5); { - State = 1855; + State = 1817; Match(T__123); } break; case T__68: EnterOuterAlt(_localctx, 6); { - State = 1856; + State = 1818; Match(T__68); } break; case T__67: EnterOuterAlt(_localctx, 7); { - State = 1857; + State = 1819; Match(T__67); } break; case T__63: EnterOuterAlt(_localctx, 8); { - State = 1858; + State = 1820; Match(T__63); } break; case T__64: EnterOuterAlt(_localctx, 9); { - State = 1859; + State = 1821; Match(T__64); } break; case T__65: EnterOuterAlt(_localctx, 10); { - State = 1860; + State = 1822; Match(T__65); } break; case T__124: EnterOuterAlt(_localctx, 11); { - State = 1861; + State = 1823; Match(T__124); } break; case T__125: EnterOuterAlt(_localctx, 12); { - State = 1862; + State = 1824; Match(T__125); } break; case T__126: EnterOuterAlt(_localctx, 13); { - State = 1863; + State = 1825; Match(T__126); } break; case T__15: EnterOuterAlt(_localctx, 14); { - State = 1864; + State = 1826; Match(T__15); } break; case T__69: EnterOuterAlt(_localctx, 15); { - State = 1865; + State = 1827; Match(T__69); - State = 1866; + State = 1828; Match(T__29); - State = 1867; + State = 1829; int32(); - State = 1868; + State = 1830; Match(T__30); } break; @@ -10364,11 +9974,11 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public AtOptContext atOpt() { AtOptContext _localctx = new AtOptContext(Context, State); - EnterRule(_localctx, 226, RULE_atOpt); + EnterRule(_localctx, 204, RULE_atOpt); try { - State = 1877; + State = 1839; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,93,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,95,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -10377,18 +9987,18 @@ public AtOptContext atOpt() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1873; + State = 1835; Match(T__43); - State = 1874; + State = 1836; id(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1875; + State = 1837; Match(T__43); - State = 1876; + State = 1838; int32(); } break; @@ -10425,9 +10035,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public InitOptContext initOpt() { InitOptContext _localctx = new InitOptContext(Context, State); - EnterRule(_localctx, 228, RULE_initOpt); + EnterRule(_localctx, 206, RULE_initOpt); try { - State = 1882; + State = 1844; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -10521,9 +10131,9 @@ public InitOptContext initOpt() { case T__35: EnterOuterAlt(_localctx, 2); { - State = 1880; + State = 1842; Match(T__35); - State = 1881; + State = 1843; fieldInit(); } break; @@ -10562,9 +10172,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public RepeatOptContext repeatOpt() { RepeatOptContext _localctx = new RepeatOptContext(Context, State); - EnterRule(_localctx, 230, RULE_repeatOpt); + EnterRule(_localctx, 208, RULE_repeatOpt); try { - State = 1889; + State = 1851; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -10619,11 +10229,11 @@ public RepeatOptContext repeatOpt() { case T__41: EnterOuterAlt(_localctx, 2); { - State = 1885; + State = 1847; Match(T__41); - State = 1886; + State = 1848; int32(); - State = 1887; + State = 1849; Match(T__42); } break; @@ -10671,57 +10281,57 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public EventHeadContext eventHead() { EventHeadContext _localctx = new EventHeadContext(Context, State); - EnterRule(_localctx, 232, RULE_eventHead); + EnterRule(_localctx, 210, RULE_eventHead); int _la; try { - State = 1909; + State = 1871; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,98,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,100,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1891; + State = 1853; Match(T__127); - State = 1895; + State = 1857; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 1892; + State = 1854; eventAttr(); } } - State = 1897; + State = 1859; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 1898; + State = 1860; typeSpec(); - State = 1899; + State = 1861; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1901; + State = 1863; Match(T__127); - State = 1905; + State = 1867; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 1902; + State = 1864; eventAttr(); } } - State = 1907; + State = 1869; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 1908; + State = 1870; dottedName(); } break; @@ -10755,12 +10365,12 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public EventAttrContext eventAttr() { EventAttrContext _localctx = new EventAttrContext(Context, State); - EnterRule(_localctx, 234, RULE_eventAttr); + EnterRule(_localctx, 212, RULE_eventAttr); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 1911; + State = 1873; _la = TokenStream.LA(1); if ( !(_la==T__67 || _la==T__68) ) { ErrorHandler.RecoverInline(this); @@ -10805,22 +10415,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public EventDeclsContext eventDecls() { EventDeclsContext _localctx = new EventDeclsContext(Context, State); - EnterRule(_localctx, 236, RULE_eventDecls); + EnterRule(_localctx, 214, RULE_eventDecls); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 1916; + State = 1878; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38788988928L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 1080863910568919043L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 1913; + State = 1875; eventDecl(); } } - State = 1918; + State = 1880; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -10869,44 +10479,44 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public EventDeclContext eventDecl() { EventDeclContext _localctx = new EventDeclContext(Context, State); - EnterRule(_localctx, 238, RULE_eventDecl); + EnterRule(_localctx, 216, RULE_eventDecl); try { - State = 1931; + State = 1893; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__128: EnterOuterAlt(_localctx, 1); { - State = 1919; + State = 1881; Match(T__128); - State = 1920; + State = 1882; methodRef(); } break; case T__129: EnterOuterAlt(_localctx, 2); { - State = 1921; + State = 1883; Match(T__129); - State = 1922; + State = 1884; methodRef(); } break; case T__130: EnterOuterAlt(_localctx, 3); { - State = 1923; + State = 1885; Match(T__130); - State = 1924; + State = 1886; methodRef(); } break; case T__131: EnterOuterAlt(_localctx, 4); { - State = 1925; + State = 1887; Match(T__131); - State = 1926; + State = 1888; methodRef(); } break; @@ -10914,7 +10524,7 @@ public EventDeclContext eventDecl() { case T__73: EnterOuterAlt(_localctx, 5); { - State = 1927; + State = 1889; extSourceSpec(); } break; @@ -10927,14 +10537,14 @@ public EventDeclContext eventDecl() { case ID: EnterOuterAlt(_localctx, 6); { - State = 1928; + State = 1890; customAttrDecl(); } break; case T__26: EnterOuterAlt(_localctx, 7); { - State = 1929; + State = 1891; languageDecl(); } break; @@ -10948,7 +10558,7 @@ public EventDeclContext eventDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 8); { - State = 1930; + State = 1892; compControl(); } break; @@ -11005,36 +10615,36 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public PropHeadContext propHead() { PropHeadContext _localctx = new PropHeadContext(Context, State); - EnterRule(_localctx, 240, RULE_propHead); + EnterRule(_localctx, 218, RULE_propHead); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 1933; + State = 1895; Match(T__132); - State = 1937; + State = 1899; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 1934; + State = 1896; propAttr(); } } - State = 1939; + State = 1901; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 1940; + State = 1902; callConv(); - State = 1941; + State = 1903; type(); - State = 1942; + State = 1904; dottedName(); - State = 1943; + State = 1905; sigArgs(); - State = 1944; + State = 1906; initOpt(); } } @@ -11066,12 +10676,12 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public PropAttrContext propAttr() { PropAttrContext _localctx = new PropAttrContext(Context, State); - EnterRule(_localctx, 242, RULE_propAttr); + EnterRule(_localctx, 220, RULE_propAttr); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 1946; + State = 1908; _la = TokenStream.LA(1); if ( !(_la==T__67 || _la==T__68) ) { ErrorHandler.RecoverInline(this); @@ -11116,22 +10726,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public PropDeclsContext propDecls() { PropDeclsContext _localctx = new PropDeclsContext(Context, State); - EnterRule(_localctx, 244, RULE_propDecls); + EnterRule(_localctx, 222, RULE_propDecls); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 1951; + State = 1913; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38788988928L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 7493989779944505347L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 1948; + State = 1910; propDecl(); } } - State = 1953; + State = 1915; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11180,35 +10790,35 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public PropDeclContext propDecl() { PropDeclContext _localctx = new PropDeclContext(Context, State); - EnterRule(_localctx, 246, RULE_propDecl); + EnterRule(_localctx, 224, RULE_propDecl); try { - State = 1964; + State = 1926; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__133: EnterOuterAlt(_localctx, 1); { - State = 1954; + State = 1916; Match(T__133); - State = 1955; + State = 1917; methodRef(); } break; case T__134: EnterOuterAlt(_localctx, 2); { - State = 1956; + State = 1918; Match(T__134); - State = 1957; + State = 1919; methodRef(); } break; case T__131: EnterOuterAlt(_localctx, 3); { - State = 1958; + State = 1920; Match(T__131); - State = 1959; + State = 1921; methodRef(); } break; @@ -11221,7 +10831,7 @@ public PropDeclContext propDecl() { case ID: EnterOuterAlt(_localctx, 4); { - State = 1960; + State = 1922; customAttrDecl(); } break; @@ -11229,14 +10839,14 @@ public PropDeclContext propDecl() { case T__73: EnterOuterAlt(_localctx, 5); { - State = 1961; + State = 1923; extSourceSpec(); } break; case T__26: EnterOuterAlt(_localctx, 6); { - State = 1962; + State = 1924; languageDecl(); } break; @@ -11250,7 +10860,7 @@ public PropDeclContext propDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 7); { - State = 1963; + State = 1925; compControl(); } break; @@ -11289,9 +10899,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public MarshalClauseContext marshalClause() { MarshalClauseContext _localctx = new MarshalClauseContext(Context, State); - EnterRule(_localctx, 248, RULE_marshalClause); + EnterRule(_localctx, 226, RULE_marshalClause); try { - State = 1972; + State = 1934; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -11327,13 +10937,13 @@ public MarshalClauseContext marshalClause() { case T__121: EnterOuterAlt(_localctx, 2); { - State = 1967; + State = 1929; Match(T__121); - State = 1968; + State = 1930; Match(T__29); - State = 1969; + State = 1931; marshalBlob(); - State = 1970; + State = 1932; Match(T__30); } break; @@ -11378,10 +10988,10 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public MarshalBlobContext marshalBlob() { MarshalBlobContext _localctx = new MarshalBlobContext(Context, State); - EnterRule(_localctx, 250, RULE_marshalBlob); + EnterRule(_localctx, 228, RULE_marshalBlob); int _la; try { - State = 1983; + State = 1945; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -11436,30 +11046,30 @@ public MarshalBlobContext marshalBlob() { case ID: EnterOuterAlt(_localctx, 1); { - State = 1974; + State = 1936; nativeType(); } break; case T__16: EnterOuterAlt(_localctx, 2); { - State = 1975; + State = 1937; Match(T__16); - State = 1977; + State = 1939; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 1976; + State = 1938; hexbyte(); } } - State = 1979; + State = 1941; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( _la==INT32 || _la==ID || _la==HEXBYTE ); - State = 1981; + State = 1943; Match(T__17); } break; @@ -11501,22 +11111,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ParamAttrContext paramAttr() { ParamAttrContext _localctx = new ParamAttrContext(Context, State); - EnterRule(_localctx, 252, RULE_paramAttr); + EnterRule(_localctx, 230, RULE_paramAttr); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 1988; + State = 1950; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__41) { { { - State = 1985; + State = 1947; paramAttrElement(); } } - State = 1990; + State = 1952; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11556,52 +11166,52 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ParamAttrElementContext paramAttrElement() { ParamAttrElementContext _localctx = new ParamAttrElementContext(Context, State); - EnterRule(_localctx, 254, RULE_paramAttrElement); + EnterRule(_localctx, 232, RULE_paramAttrElement); try { - State = 2004; + State = 1966; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,108,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,110,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1991; + State = 1953; Match(T__41); - State = 1992; + State = 1954; _localctx.@in = Match(T__135); - State = 1993; + State = 1955; Match(T__42); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1994; + State = 1956; Match(T__41); - State = 1995; + State = 1957; _localctx.@out = Match(T__136); - State = 1996; + State = 1958; Match(T__42); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1997; + State = 1959; Match(T__41); - State = 1998; + State = 1960; _localctx.opt = Match(T__137); - State = 1999; + State = 1961; Match(T__42); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2000; + State = 1962; Match(T__41); - State = 2001; + State = 1963; int32(); - State = 2002; + State = 1964; Match(T__42); } break; @@ -11674,20 +11284,20 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public MethodHeadContext methodHead() { MethodHeadContext _localctx = new MethodHeadContext(Context, State); - EnterRule(_localctx, 256, RULE_methodHead); + EnterRule(_localctx, 234, RULE_methodHead); BeginSubtree(); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2006; + State = 1968; Match(T__138); - State = 2011; + State = 1973; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & 978955L) != 0) || ((((_la - 123)) & ~0x3f) == 0 && ((1L << (_la - 123)) & 33423365L) != 0)) { { - State = 2009; + State = 1971; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__50: @@ -11710,13 +11320,13 @@ public MethodHeadContext methodHead() { case T__144: case T__145: { - State = 2007; + State = 1969; methAttr(); } break; case T__146: { - State = 2008; + State = 1970; pinvImpl(); } break; @@ -11724,35 +11334,35 @@ public MethodHeadContext methodHead() { throw new NoViableAltException(this); } } - State = 2013; + State = 1975; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2014; + State = 1976; callConv(); - State = 2015; + State = 1977; paramAttr(); - State = 2016; + State = 1978; type(); - State = 2017; + State = 1979; marshalClause(); - State = 2018; + State = 1980; methodName(); - State = 2019; + State = 1981; typarsClause(); - State = 2020; + State = 1982; sigArgs(); - State = 2024; + State = 1986; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 32766L) != 0) || _la==T__69 || _la==T__155 || _la==UNMANAGED) { { { - State = 2021; + State = 1983; implAttr(); } } - State = 2026; + State = 1988; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11792,147 +11402,147 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public MethAttrContext methAttr() { MethAttrContext _localctx = new MethAttrContext(Context, State); - EnterRule(_localctx, 258, RULE_methAttr); + EnterRule(_localctx, 236, RULE_methAttr); try { - State = 2050; + State = 2012; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__122: EnterOuterAlt(_localctx, 1); { - State = 2027; + State = 1989; Match(T__122); } break; case T__50: EnterOuterAlt(_localctx, 2); { - State = 2028; + State = 1990; Match(T__50); } break; case T__51: EnterOuterAlt(_localctx, 3); { - State = 2029; + State = 1991; Match(T__51); } break; case T__62: EnterOuterAlt(_localctx, 4); { - State = 2030; + State = 1992; Match(T__62); } break; case T__139: EnterOuterAlt(_localctx, 5); { - State = 2031; + State = 1993; Match(T__139); } break; case T__67: EnterOuterAlt(_localctx, 6); { - State = 2032; + State = 1994; Match(T__67); } break; case T__140: EnterOuterAlt(_localctx, 7); { - State = 2033; + State = 1995; Match(T__140); } break; case T__141: EnterOuterAlt(_localctx, 8); { - State = 2034; + State = 1996; Match(T__141); } break; case T__53: EnterOuterAlt(_localctx, 9); { - State = 2035; + State = 1997; Match(T__53); } break; case T__63: EnterOuterAlt(_localctx, 10); { - State = 2036; + State = 1998; Match(T__63); } break; case T__64: EnterOuterAlt(_localctx, 11); { - State = 2037; + State = 1999; Match(T__64); } break; case T__65: EnterOuterAlt(_localctx, 12); { - State = 2038; + State = 2000; Match(T__65); } break; case T__124: EnterOuterAlt(_localctx, 13); { - State = 2039; + State = 2001; Match(T__124); } break; case T__142: EnterOuterAlt(_localctx, 14); { - State = 2040; + State = 2002; Match(T__142); } break; case T__143: EnterOuterAlt(_localctx, 15); { - State = 2041; + State = 2003; Match(T__143); } break; case T__68: EnterOuterAlt(_localctx, 16); { - State = 2042; + State = 2004; Match(T__68); } break; case T__144: EnterOuterAlt(_localctx, 17); { - State = 2043; + State = 2005; Match(T__144); } break; case T__145: EnterOuterAlt(_localctx, 18); { - State = 2044; + State = 2006; Match(T__145); } break; case T__69: EnterOuterAlt(_localctx, 19); { - State = 2045; + State = 2007; Match(T__69); - State = 2046; + State = 2008; Match(T__29); - State = 2047; + State = 2009; int32(); - State = 2048; + State = 2010; Match(T__30); } break; @@ -11980,34 +11590,34 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public PinvImplContext pinvImpl() { PinvImplContext _localctx = new PinvImplContext(Context, State); - EnterRule(_localctx, 260, RULE_pinvImpl); + EnterRule(_localctx, 238, RULE_pinvImpl); int _la; try { - State = 2070; + State = 2032; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,116,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,118,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2052; + State = 2014; Match(T__146); - State = 2053; + State = 2015; Match(T__29); - State = 2059; + State = 2021; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==QSTRING) { { - State = 2054; + State = 2016; compQstring(); - State = 2057; + State = 2019; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__33) { { - State = 2055; + State = 2017; Match(T__33); - State = 2056; + State = 2018; compQstring(); } } @@ -12015,30 +11625,30 @@ public PinvImplContext pinvImpl() { } } - State = 2064; + State = 2026; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 57)) & ~0x3f) == 0 && ((1L << (_la - 57)) & 8195L) != 0) || ((((_la - 148)) & ~0x3f) == 0 && ((1L << (_la - 148)) & 79L) != 0) || ((((_la - 224)) & ~0x3f) == 0 && ((1L << (_la - 224)) & 251658241L) != 0)) { { { - State = 2061; + State = 2023; pinvAttr(); } } - State = 2066; + State = 2028; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2067; + State = 2029; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2068; + State = 2030; Match(T__146); - State = 2069; + State = 2031; Match(T__84); } break; @@ -12080,135 +11690,135 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public PinvAttrContext pinvAttr() { PinvAttrContext _localctx = new PinvAttrContext(Context, State); - EnterRule(_localctx, 262, RULE_pinvAttr); + EnterRule(_localctx, 240, RULE_pinvAttr); try { - State = 2099; + State = 2061; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,117,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,119,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2072; + State = 2034; Match(T__147); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2073; + State = 2035; Match(ANSI); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2074; + State = 2036; Match(T__56); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2075; + State = 2037; Match(T__57); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2076; + State = 2038; Match(T__148); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2077; + State = 2039; Match(T__149); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2078; + State = 2040; Match(CDECL); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2079; + State = 2041; Match(STDCALL); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2080; + State = 2042; Match(THISCALL); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2081; + State = 2043; Match(FASTCALL); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2082; + State = 2044; Match(T__150); - State = 2083; + State = 2045; Match(T__74); - State = 2084; + State = 2046; Match(T__151); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2085; + State = 2047; Match(T__150); - State = 2086; + State = 2048; Match(T__74); - State = 2087; + State = 2049; Match(T__152); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2088; + State = 2050; Match(T__153); - State = 2089; + State = 2051; Match(T__74); - State = 2090; + State = 2052; Match(T__151); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2091; + State = 2053; Match(T__153); - State = 2092; + State = 2054; Match(T__74); - State = 2093; + State = 2055; Match(T__152); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2094; + State = 2056; Match(T__69); - State = 2095; + State = 2057; Match(T__29); - State = 2096; + State = 2058; int32(); - State = 2097; + State = 2059; Match(T__30); } break; @@ -12245,22 +11855,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public MethodNameContext methodName() { MethodNameContext _localctx = new MethodNameContext(Context, State); - EnterRule(_localctx, 264, RULE_methodName); + EnterRule(_localctx, 242, RULE_methodName); try { - State = 2104; + State = 2066; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__115: EnterOuterAlt(_localctx, 1); { - State = 2101; + State = 2063; Match(T__115); } break; case T__154: EnterOuterAlt(_localctx, 2); { - State = 2102; + State = 2064; Match(T__154); } break; @@ -12272,7 +11882,7 @@ public MethodNameContext methodName() { case ID: EnterOuterAlt(_localctx, 3); { - State = 2103; + State = 2065; dottedName(); } break; @@ -12312,133 +11922,133 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ImplAttrContext implAttr() { ImplAttrContext _localctx = new ImplAttrContext(Context, State); - EnterRule(_localctx, 266, RULE_implAttr); + EnterRule(_localctx, 244, RULE_implAttr); try { - State = 2127; + State = 2089; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: EnterOuterAlt(_localctx, 1); { - State = 2106; + State = 2068; Match(T__0); } break; case T__1: EnterOuterAlt(_localctx, 2); { - State = 2107; + State = 2069; Match(T__1); } break; case T__155: EnterOuterAlt(_localctx, 3); { - State = 2108; + State = 2070; Match(T__155); } break; case T__2: EnterOuterAlt(_localctx, 4); { - State = 2109; + State = 2071; Match(T__2); } break; case T__3: EnterOuterAlt(_localctx, 5); { - State = 2110; + State = 2072; Match(T__3); } break; case UNMANAGED: EnterOuterAlt(_localctx, 6); { - State = 2111; + State = 2073; Match(UNMANAGED); } break; case T__4: EnterOuterAlt(_localctx, 7); { - State = 2112; + State = 2074; Match(T__4); } break; case T__5: EnterOuterAlt(_localctx, 8); { - State = 2113; + State = 2075; Match(T__5); } break; case T__6: EnterOuterAlt(_localctx, 9); { - State = 2114; + State = 2076; Match(T__6); } break; case T__7: EnterOuterAlt(_localctx, 10); { - State = 2115; + State = 2077; Match(T__7); } break; case T__8: EnterOuterAlt(_localctx, 11); { - State = 2116; + State = 2078; Match(T__8); } break; case T__9: EnterOuterAlt(_localctx, 12); { - State = 2117; + State = 2079; Match(T__9); } break; case T__10: EnterOuterAlt(_localctx, 13); { - State = 2118; + State = 2080; Match(T__10); } break; case T__11: EnterOuterAlt(_localctx, 14); { - State = 2119; + State = 2081; Match(T__11); } break; case T__12: EnterOuterAlt(_localctx, 15); { - State = 2120; + State = 2082; Match(T__12); } break; case T__13: EnterOuterAlt(_localctx, 16); { - State = 2121; + State = 2083; Match(T__13); } break; case T__69: EnterOuterAlt(_localctx, 17); { - State = 2122; + State = 2084; Match(T__69); - State = 2123; + State = 2085; Match(T__29); - State = 2124; + State = 2086; int32(); - State = 2125; + State = 2087; Match(T__30); } break; @@ -12480,23 +12090,23 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public MethodDeclsContext methodDecls() { MethodDeclsContext _localctx = new MethodDeclsContext(Context, State); - EnterRule(_localctx, 268, RULE_methodDecls); + EnterRule(_localctx, 246, RULE_methodDecls); BeginStreaming(); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2132; + State = 2094; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38789119998L) != 0) || _la==T__72 || _la==T__73 || ((((_la - 158)) & ~0x3f) == 0 && ((1L << (_la - 158)) & 2199023255681L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 2303696760354115601L) != 0)) { { { - State = 2129; + State = 2091; methodDecl(); } } - State = 2134; + State = 2096; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -12515,32 +12125,194 @@ public MethodDeclsContext methodDecls() { } public partial class MethodDeclContext : ParserRuleContext { + public Int32Context value; [System.Diagnostics.DebuggerNonUserCode] public InstrContext instr() { return GetRuleContext(0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode EMITBYTE() { return GetToken(CILParser.EMITBYTE, 0); } - [System.Diagnostics.DebuggerNonUserCode] public Int32Context[] int32() { - return GetRuleContexts(); - } - [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32(int i) { - return GetRuleContext(i); + [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { + return GetRuleContext(0); } [System.Diagnostics.DebuggerNonUserCode] public SehBlockContext sehBlock() { return GetRuleContext(0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode MAXSTACK() { return GetToken(CILParser.MAXSTACK, 0); } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ENTRYPOINT() { return GetToken(CILParser.ENTRYPOINT, 0); } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ZEROINIT() { return GetToken(CILParser.ZEROINIT, 0); } + [System.Diagnostics.DebuggerNonUserCode] public LabelDeclContext labelDecl() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public ScopeBlockContext scopeBlock() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public MethodDeclIslandContext methodDeclIsland() { + return GetRuleContext(0); + } + public MethodDeclContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_methodDecl; } } + [System.Diagnostics.DebuggerNonUserCode] + public override TResult Accept(IParseTreeVisitor visitor) { + ICILVisitor typedVisitor = visitor as ICILVisitor; + if (typedVisitor != null) return typedVisitor.VisitMethodDecl(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public MethodDeclContext methodDecl() { + MethodDeclContext _localctx = new MethodDeclContext(Context, State); + EnterRule(_localctx, 248, RULE_methodDecl); + try { + State = 2114; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case INSTR_NONE: + case INSTR_VAR: + case INSTR_I: + case INSTR_I8: + case INSTR_R: + case INSTR_METHOD: + case INSTR_SIG: + case INSTR_BRTARGET: + case INSTR_SWITCH: + case INSTR_TYPE: + case INSTR_STRING: + case INSTR_FIELD: + case INSTR_TOK: + EnterOuterAlt(_localctx, 1); + { + State = 2097; + instr(); + } + break; + case EMITBYTE: + EnterOuterAlt(_localctx, 2); + { + State = 2098; + Match(EMITBYTE); + State = 2099; + _localctx.value = int32(); + Actions.EmitByte((_localctx.value!=null?(_localctx.value.Start):null)); + } + break; + case T__157: + EnterOuterAlt(_localctx, 3); + { + State = 2102; + sehBlock(); + } + break; + case MAXSTACK: + EnterOuterAlt(_localctx, 4); + { + State = 2103; + Match(MAXSTACK); + State = 2104; + _localctx.value = int32(); + Actions.SetMaxStack((_localctx.value!=null?(_localctx.value.Start):null)); + } + break; + case ENTRYPOINT: + EnterOuterAlt(_localctx, 5); + { + State = 2107; + Match(ENTRYPOINT); + Actions.SetEntryPoint(); + } + break; + case ZEROINIT: + EnterOuterAlt(_localctx, 6); + { + State = 2109; + Match(ZEROINIT); + Actions.SetZeroInit(); + } + break; + case T__0: + case T__1: + case T__2: + case T__3: + case T__4: + case T__5: + case T__6: + case T__7: + case T__8: + case T__9: + case T__10: + case T__11: + case T__12: + case T__13: + case T__14: + case VALUE: + case INSTANCE: + case UNMANAGED: + case SQSTRING: + case ID: + EnterOuterAlt(_localctx, 7); + { + State = 2111; + labelDecl(); + } + break; + case T__16: + EnterOuterAlt(_localctx, 8); + { + State = 2112; + scopeBlock(); + } + break; + case T__26: + case T__31: + case T__34: + case T__72: + case T__73: + case T__164: + case PARAM: + case PP_DEFINE: + case PP_UNDEF: + case PP_IFDEF: + case PP_IFNDEF: + case PP_ELSE: + case PP_ENDIF: + case PP_INCLUDE: + case PERMISSION: + case PERMISSIONSET: + case LOCALS: + case EXPORT: + case OVERRIDE: + case VTENTRY: + EnterOuterAlt(_localctx, 9); + { + State = 2113; + methodDeclIsland(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class MethodDeclIslandContext : ParserRuleContext { [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LOCALS() { return GetToken(CILParser.LOCALS, 0); } [System.Diagnostics.DebuggerNonUserCode] public SigArgsContext sigArgs() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ENTRYPOINT() { return GetToken(CILParser.ENTRYPOINT, 0); } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ZEROINIT() { return GetToken(CILParser.ZEROINIT, 0); } [System.Diagnostics.DebuggerNonUserCode] public DataDeclContext dataDecl() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public LabelDeclContext labelDecl() { - return GetRuleContext(0); - } [System.Diagnostics.DebuggerNonUserCode] public SecDeclContext secDecl() { return GetRuleContext(0); } @@ -12557,6 +12329,12 @@ [System.Diagnostics.DebuggerNonUserCode] public CompControlContext compControl() return GetRuleContext(0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode EXPORT() { return GetToken(CILParser.EXPORT, 0); } + [System.Diagnostics.DebuggerNonUserCode] public Int32Context[] int32() { + return GetRuleContexts(); + } + [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32(int i) { + return GetRuleContext(i); + } [System.Diagnostics.DebuggerNonUserCode] public IdContext id() { return GetRuleContext(0); } @@ -12579,9 +12357,6 @@ [System.Diagnostics.DebuggerNonUserCode] public TypeContext type() { [System.Diagnostics.DebuggerNonUserCode] public GenArityContext genArity() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public ScopeBlockContext scopeBlock() { - return GetRuleContext(0); - } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PARAM() { return GetToken(CILParser.PARAM, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TYPE() { return GetToken(CILParser.TYPE, 0); } [System.Diagnostics.DebuggerNonUserCode] public CustomAttrDeclContext[] customAttrDecl() { @@ -12597,388 +12372,328 @@ [System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() { [System.Diagnostics.DebuggerNonUserCode] public InitOptContext initOpt() { return GetRuleContext(0); } - public MethodDeclContext(ParserRuleContext parent, int invokingState) + public MethodDeclIslandContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { } - public override int RuleIndex { get { return RULE_methodDecl; } } + public override int RuleIndex { get { return RULE_methodDeclIsland; } } [System.Diagnostics.DebuggerNonUserCode] public override TResult Accept(IParseTreeVisitor visitor) { ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitMethodDecl(this); + if (typedVisitor != null) return typedVisitor.VisitMethodDeclIsland(this); else return visitor.VisitChildren(this); } } [RuleVersion(0)] - public MethodDeclContext methodDecl() { - MethodDeclContext _localctx = new MethodDeclContext(Context, State); - EnterRule(_localctx, 270, RULE_methodDecl); + public MethodDeclIslandContext methodDeclIsland() { + MethodDeclIslandContext _localctx = new MethodDeclIslandContext(Context, State); + EnterRule(_localctx, 250, RULE_methodDeclIsland); BeginSubtree(); try { int _alt; - State = 2243; + State = 2214; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,126,Context) ) { - case 1: - EnterOuterAlt(_localctx, 1); - { - State = 2135; - instr(); - } - break; - case 2: - EnterOuterAlt(_localctx, 2); - { - State = 2136; - Match(EMITBYTE); - State = 2137; - int32(); - } - break; - case 3: - EnterOuterAlt(_localctx, 3); - { - State = 2138; - sehBlock(); - } - break; - case 4: - EnterOuterAlt(_localctx, 4); - { - State = 2139; - Match(MAXSTACK); - State = 2140; - int32(); - } - break; - case 5: - EnterOuterAlt(_localctx, 5); + switch ( Interpreter.AdaptivePredict(TokenStream,129,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); { - State = 2141; + State = 2116; Match(LOCALS); - State = 2142; + State = 2117; sigArgs(); } break; - case 6: - EnterOuterAlt(_localctx, 6); + case 2: + EnterOuterAlt(_localctx, 2); { - State = 2143; + State = 2118; Match(LOCALS); - State = 2144; + State = 2119; Match(T__156); - State = 2145; + State = 2120; sigArgs(); } break; - case 7: - EnterOuterAlt(_localctx, 7); - { - State = 2146; - Match(ENTRYPOINT); - } - break; - case 8: - EnterOuterAlt(_localctx, 8); - { - State = 2147; - Match(ZEROINIT); - } - break; - case 9: - EnterOuterAlt(_localctx, 9); + case 3: + EnterOuterAlt(_localctx, 3); { - State = 2148; + State = 2121; dataDecl(); } break; - case 10: - EnterOuterAlt(_localctx, 10); - { - State = 2149; - labelDecl(); - } - break; - case 11: - EnterOuterAlt(_localctx, 11); + case 4: + EnterOuterAlt(_localctx, 4); { - State = 2150; + State = 2122; secDecl(); } break; - case 12: - EnterOuterAlt(_localctx, 12); + case 5: + EnterOuterAlt(_localctx, 5); { - State = 2151; + State = 2123; extSourceSpec(); } break; - case 13: - EnterOuterAlt(_localctx, 13); + case 6: + EnterOuterAlt(_localctx, 6); { - State = 2152; + State = 2124; languageDecl(); } break; - case 14: - EnterOuterAlt(_localctx, 14); + case 7: + EnterOuterAlt(_localctx, 7); { - State = 2153; + State = 2125; customDescrInMethodBody(); } break; - case 15: - EnterOuterAlt(_localctx, 15); + case 8: + EnterOuterAlt(_localctx, 8); { - State = 2154; + State = 2126; compControl(); } break; - case 16: - EnterOuterAlt(_localctx, 16); + case 9: + EnterOuterAlt(_localctx, 9); { - State = 2155; + State = 2127; Match(EXPORT); - State = 2156; + State = 2128; Match(T__41); - State = 2157; + State = 2129; int32(); - State = 2158; + State = 2130; Match(T__42); } break; - case 17: - EnterOuterAlt(_localctx, 17); + case 10: + EnterOuterAlt(_localctx, 10); { - State = 2160; + State = 2132; Match(EXPORT); - State = 2161; + State = 2133; Match(T__41); - State = 2162; + State = 2134; int32(); - State = 2163; + State = 2135; Match(T__42); - State = 2164; + State = 2136; Match(T__33); - State = 2165; + State = 2137; id(); } break; - case 18: - EnterOuterAlt(_localctx, 18); + case 11: + EnterOuterAlt(_localctx, 11); { - State = 2167; + State = 2139; Match(VTENTRY); - State = 2168; + State = 2140; int32(); - State = 2169; + State = 2141; Match(T__74); - State = 2170; + State = 2142; int32(); } break; - case 19: - EnterOuterAlt(_localctx, 19); + case 12: + EnterOuterAlt(_localctx, 12); { - State = 2172; + State = 2144; Match(OVERRIDE); - State = 2173; + State = 2145; typeSpec(); - State = 2174; + State = 2146; Match(DCOLON); - State = 2175; + State = 2147; methodName(); } break; - case 20: - EnterOuterAlt(_localctx, 20); + case 13: + EnterOuterAlt(_localctx, 13); { - State = 2177; + State = 2149; Match(OVERRIDE); - State = 2178; + State = 2150; Match(METHOD); - State = 2179; + State = 2151; callConv(); - State = 2180; + State = 2152; type(); - State = 2181; + State = 2153; typeSpec(); - State = 2182; + State = 2154; Match(DCOLON); - State = 2183; + State = 2155; methodName(); - State = 2184; + State = 2156; genArity(); - State = 2185; + State = 2157; sigArgs(); } break; - case 21: - EnterOuterAlt(_localctx, 21); - { - State = 2187; - scopeBlock(); - } - break; - case 22: - EnterOuterAlt(_localctx, 22); + case 14: + EnterOuterAlt(_localctx, 14); { - State = 2188; + State = 2159; Match(PARAM); - State = 2189; + State = 2160; Match(TYPE); - State = 2190; + State = 2161; Match(T__41); - State = 2191; + State = 2162; int32(); - State = 2192; + State = 2163; Match(T__42); - State = 2196; + State = 2167; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,121,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,124,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2193; + State = 2164; customAttrDecl(); } } } - State = 2198; + State = 2169; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,121,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,124,Context); } } break; - case 23: - EnterOuterAlt(_localctx, 23); + case 15: + EnterOuterAlt(_localctx, 15); { - State = 2199; + State = 2170; Match(PARAM); - State = 2200; + State = 2171; Match(TYPE); - State = 2201; + State = 2172; dottedName(); - State = 2205; + State = 2176; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,122,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,125,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2202; + State = 2173; customAttrDecl(); } } } - State = 2207; + State = 2178; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,122,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,125,Context); } } break; - case 24: - EnterOuterAlt(_localctx, 24); + case 16: + EnterOuterAlt(_localctx, 16); { - State = 2208; + State = 2179; Match(PARAM); - State = 2209; + State = 2180; Match(CONSTRAINT); - State = 2210; + State = 2181; Match(T__41); - State = 2211; + State = 2182; int32(); - State = 2212; + State = 2183; Match(T__42); - State = 2213; + State = 2184; Match(T__27); - State = 2214; + State = 2185; typeSpec(); - State = 2218; + State = 2189; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,123,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,126,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2215; + State = 2186; customAttrDecl(); } } } - State = 2220; + State = 2191; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,123,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,126,Context); } } break; - case 25: - EnterOuterAlt(_localctx, 25); + case 17: + EnterOuterAlt(_localctx, 17); { - State = 2221; + State = 2192; Match(PARAM); - State = 2222; + State = 2193; Match(CONSTRAINT); - State = 2223; + State = 2194; dottedName(); - State = 2224; + State = 2195; Match(T__27); - State = 2225; + State = 2196; typeSpec(); - State = 2229; + State = 2200; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,124,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,127,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2226; + State = 2197; customAttrDecl(); } } } - State = 2231; + State = 2202; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,124,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,127,Context); } } break; - case 26: - EnterOuterAlt(_localctx, 26); + case 18: + EnterOuterAlt(_localctx, 18); { - State = 2232; + State = 2203; Match(PARAM); - State = 2233; + State = 2204; Match(T__41); - State = 2234; + State = 2205; int32(); - State = 2235; + State = 2206; Match(T__42); - State = 2236; + State = 2207; initOpt(); - State = 2240; + State = 2211; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,125,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,128,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2237; + State = 2208; customAttrDecl(); } } } - State = 2242; + State = 2213; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,125,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,128,Context); } } break; } Context.Stop = TokenStream.LT(-1); - Actions.OnMethodDeclaration(_localctx); + Actions.ProcessMethodDeclarationIsland(_localctx); } catch (RecognitionException re) { _localctx.exception = re; @@ -12993,6 +12708,7 @@ public MethodDeclContext methodDecl() { } public partial class LabelDeclContext : ParserRuleContext { + public IdContext name; [System.Diagnostics.DebuggerNonUserCode] public IdContext id() { return GetRuleContext(0); } @@ -13012,14 +12728,15 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public LabelDeclContext labelDecl() { LabelDeclContext _localctx = new LabelDeclContext(Context, State); - EnterRule(_localctx, 272, RULE_labelDecl); + EnterRule(_localctx, 252, RULE_labelDecl); try { EnterOuterAlt(_localctx, 1); { - State = 2245; - id(); - State = 2246; + State = 2216; + _localctx.name = id(); + State = 2217; Match(T__74); + Actions.DefineLabel((_localctx.name!=null?(_localctx.name.Start):null)); } } catch (RecognitionException re) { @@ -13056,22 +12773,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public CustomDescrInMethodBodyContext customDescrInMethodBody() { CustomDescrInMethodBodyContext _localctx = new CustomDescrInMethodBodyContext(Context, State); - EnterRule(_localctx, 274, RULE_customDescrInMethodBody); + EnterRule(_localctx, 254, RULE_customDescrInMethodBody); try { - State = 2250; + State = 2222; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,127,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,130,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2248; + State = 2220; customDescr(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2249; + State = 2221; customDescrWithOwner(); } break; @@ -13108,16 +12825,16 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ScopeBlockContext scopeBlock() { ScopeBlockContext _localctx = new ScopeBlockContext(Context, State); - EnterRule(_localctx, 276, RULE_scopeBlock); + EnterRule(_localctx, 256, RULE_scopeBlock); Actions.BeginScope(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 2252; + State = 2224; Match(T__16); - State = 2253; + State = 2225; methodDecls(); - State = 2254; + State = 2226; Match(T__17); } } @@ -13156,13 +12873,14 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SehBlockContext sehBlock() { SehBlockContext _localctx = new SehBlockContext(Context, State); - EnterRule(_localctx, 278, RULE_sehBlock); + EnterRule(_localctx, 258, RULE_sehBlock); + BeginSubtree(); try { EnterOuterAlt(_localctx, 1); { - State = 2256; + State = 2228; tryBlock(); - State = 2257; + State = 2229; sehClauses(); } Context.Stop = TokenStream.LT(-1); @@ -13174,6 +12892,7 @@ public SehBlockContext sehBlock() { ErrorHandler.Recover(this, re); } finally { + EndParseTreeMode(); ExitRule(); } return _localctx; @@ -13202,22 +12921,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SehClausesContext sehClauses() { SehClausesContext _localctx = new SehClausesContext(Context, State); - EnterRule(_localctx, 280, RULE_sehClauses); + EnterRule(_localctx, 260, RULE_sehClauses); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2260; + State = 2232; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2259; + State = 2231; sehClause(); } } - State = 2262; + State = 2234; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( ((((_la - 160)) & ~0x3f) == 0 && ((1L << (_la - 160)) & 15L) != 0) ); @@ -13266,43 +12985,43 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TryBlockContext tryBlock() { TryBlockContext _localctx = new TryBlockContext(Context, State); - EnterRule(_localctx, 282, RULE_tryBlock); + EnterRule(_localctx, 262, RULE_tryBlock); try { - State = 2276; + State = 2248; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,129,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,132,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2264; + State = 2236; Match(T__157); - State = 2265; + State = 2237; scopeBlock(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2266; + State = 2238; Match(T__157); - State = 2267; + State = 2239; id(); - State = 2268; + State = 2240; Match(T__158); - State = 2269; + State = 2241; id(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2271; + State = 2243; Match(T__157); - State = 2272; + State = 2244; int32(); - State = 2273; + State = 2245; Match(T__158); - State = 2274; + State = 2246; int32(); } break; @@ -13351,44 +13070,44 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SehClauseContext sehClause() { SehClauseContext _localctx = new SehClauseContext(Context, State); - EnterRule(_localctx, 284, RULE_sehClause); + EnterRule(_localctx, 264, RULE_sehClause); try { - State = 2290; + State = 2262; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__160: EnterOuterAlt(_localctx, 1); { - State = 2278; + State = 2250; catchClause(); - State = 2279; + State = 2251; handlerBlock(); } break; case T__159: EnterOuterAlt(_localctx, 2); { - State = 2281; + State = 2253; filterClause(); - State = 2282; + State = 2254; handlerBlock(); } break; case T__161: EnterOuterAlt(_localctx, 3); { - State = 2284; + State = 2256; finallyClause(); - State = 2285; + State = 2257; handlerBlock(); } break; case T__162: EnterOuterAlt(_localctx, 4); { - State = 2287; + State = 2259; faultClause(); - State = 2288; + State = 2260; handlerBlock(); } break; @@ -13433,35 +13152,35 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public FilterClauseContext filterClause() { FilterClauseContext _localctx = new FilterClauseContext(Context, State); - EnterRule(_localctx, 286, RULE_filterClause); + EnterRule(_localctx, 266, RULE_filterClause); try { - State = 2298; + State = 2270; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,131,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,134,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2292; + State = 2264; Match(T__159); - State = 2293; + State = 2265; scopeBlock(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2294; + State = 2266; Match(T__159); - State = 2295; + State = 2267; id(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2296; + State = 2268; Match(T__159); - State = 2297; + State = 2269; int32(); } break; @@ -13498,13 +13217,13 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public CatchClauseContext catchClause() { CatchClauseContext _localctx = new CatchClauseContext(Context, State); - EnterRule(_localctx, 288, RULE_catchClause); + EnterRule(_localctx, 268, RULE_catchClause); try { EnterOuterAlt(_localctx, 1); { - State = 2300; + State = 2272; Match(T__160); - State = 2301; + State = 2273; typeSpec(); } Context.Stop = TokenStream.LT(-1); @@ -13538,11 +13257,11 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public FinallyClauseContext finallyClause() { FinallyClauseContext _localctx = new FinallyClauseContext(Context, State); - EnterRule(_localctx, 290, RULE_finallyClause); + EnterRule(_localctx, 270, RULE_finallyClause); try { EnterOuterAlt(_localctx, 1); { - State = 2303; + State = 2275; Match(T__161); } } @@ -13574,11 +13293,11 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public FaultClauseContext faultClause() { FaultClauseContext _localctx = new FaultClauseContext(Context, State); - EnterRule(_localctx, 292, RULE_faultClause); + EnterRule(_localctx, 272, RULE_faultClause); try { EnterOuterAlt(_localctx, 1); { - State = 2305; + State = 2277; Match(T__162); } } @@ -13625,41 +13344,41 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public HandlerBlockContext handlerBlock() { HandlerBlockContext _localctx = new HandlerBlockContext(Context, State); - EnterRule(_localctx, 294, RULE_handlerBlock); + EnterRule(_localctx, 274, RULE_handlerBlock); try { - State = 2318; + State = 2290; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,132,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,135,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2307; + State = 2279; scopeBlock(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2308; + State = 2280; Match(T__163); - State = 2309; + State = 2281; id(); - State = 2310; + State = 2282; Match(T__158); - State = 2311; + State = 2283; id(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2313; + State = 2285; Match(T__163); - State = 2314; + State = 2286; int32(); - State = 2315; + State = 2287; Match(T__158); - State = 2316; + State = 2288; int32(); } break; @@ -13699,13 +13418,13 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public DataDeclContext dataDecl() { DataDeclContext _localctx = new DataDeclContext(Context, State); - EnterRule(_localctx, 296, RULE_dataDecl); + EnterRule(_localctx, 276, RULE_dataDecl); try { EnterOuterAlt(_localctx, 1); { - State = 2320; + State = 2292; ddHead(); - State = 2321; + State = 2293; ddBody(); } } @@ -13743,30 +13462,30 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public DdHeadContext ddHead() { DdHeadContext _localctx = new DdHeadContext(Context, State); - EnterRule(_localctx, 298, RULE_ddHead); + EnterRule(_localctx, 278, RULE_ddHead); try { - State = 2330; + State = 2302; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,133,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,136,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2323; + State = 2295; Match(T__164); - State = 2324; + State = 2296; tls(); - State = 2325; + State = 2297; id(); - State = 2326; + State = 2298; Match(T__35); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2328; + State = 2300; Match(T__164); - State = 2329; + State = 2301; tls(); } break; @@ -13800,11 +13519,11 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TlsContext tls() { TlsContext _localctx = new TlsContext(Context, State); - EnterRule(_localctx, 300, RULE_tls); + EnterRule(_localctx, 280, RULE_tls); try { - State = 2335; + State = 2307; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,134,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,137,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -13813,14 +13532,14 @@ public TlsContext tls() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2333; + State = 2305; Match(T__165); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2334; + State = 2306; Match(T__1); } break; @@ -13863,20 +13582,20 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public DdBodyContext ddBody() { DdBodyContext _localctx = new DdBodyContext(Context, State); - EnterRule(_localctx, 302, RULE_ddBody); + EnterRule(_localctx, 282, RULE_ddBody); int _la; try { - State = 2346; + State = 2318; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: EnterOuterAlt(_localctx, 1); { - State = 2337; + State = 2309; Match(T__16); - State = 2338; + State = 2310; ddItemList(); - State = 2339; + State = 2311; Match(T__17); } break; @@ -13891,17 +13610,17 @@ public DdBodyContext ddBody() { case REF: EnterOuterAlt(_localctx, 2); { - State = 2342; + State = 2314; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2341; + State = 2313; ddItem(); } } - State = 2344; + State = 2316; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( _la==T__83 || ((((_la - 181)) & ~0x3f) == 0 && ((1L << (_la - 181)) & 505L) != 0) || _la==REF ); @@ -13945,30 +13664,30 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public DdItemListContext ddItemList() { DdItemListContext _localctx = new DdItemListContext(Context, State); - EnterRule(_localctx, 304, RULE_ddItemList); + EnterRule(_localctx, 284, RULE_ddItemList); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 2353; + State = 2325; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,137,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,140,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2348; + State = 2320; ddItem(); - State = 2349; + State = 2321; Match(T__27); } } } - State = 2355; + State = 2327; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,137,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,140,Context); } - State = 2356; + State = 2328; ddItem(); } } @@ -14003,9 +13722,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public DdItemCountContext ddItemCount() { DdItemCountContext _localctx = new DdItemCountContext(Context, State); - EnterRule(_localctx, 306, RULE_ddItemCount); + EnterRule(_localctx, 286, RULE_ddItemCount); try { - State = 2363; + State = 2335; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -14109,11 +13828,11 @@ public DdItemCountContext ddItemCount() { case T__41: EnterOuterAlt(_localctx, 2); { - State = 2359; + State = 2331; Match(T__41); - State = 2360; + State = 2332; int32(); - State = 2361; + State = 2333; Match(T__42); } break; @@ -14179,202 +13898,202 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public DdItemContext ddItem() { DdItemContext _localctx = new DdItemContext(Context, State); - EnterRule(_localctx, 308, RULE_ddItem); + EnterRule(_localctx, 288, RULE_ddItem); try { - State = 2431; + State = 2403; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,139,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,142,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2365; + State = 2337; Match(CHAR); - State = 2366; + State = 2338; Match(PTR); - State = 2367; + State = 2339; Match(T__29); - State = 2368; + State = 2340; compQstring(); - State = 2369; + State = 2341; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2371; + State = 2343; Match(REF); - State = 2372; + State = 2344; Match(T__29); - State = 2373; + State = 2345; id(); - State = 2374; + State = 2346; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2376; + State = 2348; Match(REF); - State = 2377; + State = 2349; id(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2378; + State = 2350; Match(T__83); - State = 2379; + State = 2351; Match(T__29); - State = 2380; + State = 2352; bytes(); - State = 2381; + State = 2353; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2383; + State = 2355; Match(FLOAT32); - State = 2384; + State = 2356; Match(T__29); - State = 2385; + State = 2357; float64(); - State = 2386; + State = 2358; Match(T__30); - State = 2387; + State = 2359; ddItemCount(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2389; + State = 2361; Match(FLOAT64_); - State = 2390; + State = 2362; Match(T__29); - State = 2391; + State = 2363; float64(); - State = 2392; + State = 2364; Match(T__30); - State = 2393; + State = 2365; ddItemCount(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2395; + State = 2367; Match(INT64_); - State = 2396; + State = 2368; Match(T__29); - State = 2397; + State = 2369; int64(); - State = 2398; + State = 2370; Match(T__30); - State = 2399; + State = 2371; ddItemCount(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2401; + State = 2373; Match(INT32_); - State = 2402; + State = 2374; Match(T__29); - State = 2403; + State = 2375; int32(); - State = 2404; + State = 2376; Match(T__30); - State = 2405; + State = 2377; ddItemCount(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2407; + State = 2379; Match(INT16); - State = 2408; + State = 2380; Match(T__29); - State = 2409; + State = 2381; int32(); - State = 2410; + State = 2382; Match(T__30); - State = 2411; + State = 2383; ddItemCount(); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2413; + State = 2385; Match(INT8); - State = 2414; + State = 2386; Match(T__29); - State = 2415; + State = 2387; int32(); - State = 2416; + State = 2388; Match(T__30); - State = 2417; + State = 2389; ddItemCount(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2419; + State = 2391; Match(FLOAT32); - State = 2420; + State = 2392; ddItemCount(); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2421; + State = 2393; Match(FLOAT64_); - State = 2422; + State = 2394; ddItemCount(); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2423; + State = 2395; Match(INT64_); - State = 2424; + State = 2396; ddItemCount(); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2425; + State = 2397; Match(INT32_); - State = 2426; + State = 2398; ddItemCount(); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2427; + State = 2399; Match(INT16); - State = 2428; + State = 2400; ddItemCount(); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 2429; + State = 2401; Match(INT8); - State = 2430; + State = 2402; ddItemCount(); } break; @@ -14435,203 +14154,203 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public FieldSerInitContext fieldSerInit() { FieldSerInitContext _localctx = new FieldSerInitContext(Context, State); - EnterRule(_localctx, 310, RULE_fieldSerInit); + EnterRule(_localctx, 290, RULE_fieldSerInit); try { - State = 2508; + State = 2480; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,140,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,143,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2433; + State = 2405; Match(FLOAT32); - State = 2434; + State = 2406; Match(T__29); - State = 2435; + State = 2407; float64(); - State = 2436; + State = 2408; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2438; + State = 2410; Match(FLOAT64_); - State = 2439; + State = 2411; Match(T__29); - State = 2440; + State = 2412; float64(); - State = 2441; + State = 2413; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2443; + State = 2415; Match(FLOAT32); - State = 2444; + State = 2416; Match(T__29); - State = 2445; + State = 2417; int32(); - State = 2446; + State = 2418; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2448; + State = 2420; Match(FLOAT64_); - State = 2449; + State = 2421; Match(T__29); - State = 2450; + State = 2422; int64(); - State = 2451; + State = 2423; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2453; + State = 2425; Match(INT64_); - State = 2454; + State = 2426; Match(T__29); - State = 2455; + State = 2427; int64(); - State = 2456; + State = 2428; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2458; + State = 2430; Match(INT32_); - State = 2459; + State = 2431; Match(T__29); - State = 2460; + State = 2432; int32(); - State = 2461; + State = 2433; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2463; + State = 2435; Match(INT16); - State = 2464; + State = 2436; Match(T__29); - State = 2465; + State = 2437; int32(); - State = 2466; + State = 2438; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2468; + State = 2440; Match(INT8); - State = 2469; + State = 2441; Match(T__29); - State = 2470; + State = 2442; int32(); - State = 2471; + State = 2443; Match(T__30); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2473; + State = 2445; Match(UINT64); - State = 2474; + State = 2446; Match(T__29); - State = 2475; + State = 2447; int64(); - State = 2476; + State = 2448; Match(T__30); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2478; + State = 2450; Match(UINT32); - State = 2479; + State = 2451; Match(T__29); - State = 2480; + State = 2452; int32(); - State = 2481; + State = 2453; Match(T__30); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2483; + State = 2455; Match(UINT16); - State = 2484; + State = 2456; Match(T__29); - State = 2485; + State = 2457; int32(); - State = 2486; + State = 2458; Match(T__30); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2488; + State = 2460; Match(UINT8); - State = 2489; + State = 2461; Match(T__29); - State = 2490; + State = 2462; int32(); - State = 2491; + State = 2463; Match(T__30); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2493; + State = 2465; Match(CHAR); - State = 2494; + State = 2466; Match(T__29); - State = 2495; + State = 2467; int32(); - State = 2496; + State = 2468; Match(T__30); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2498; + State = 2470; Match(BOOL); - State = 2499; + State = 2471; Match(T__29); - State = 2500; + State = 2472; truefalse(); - State = 2501; + State = 2473; Match(T__30); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2503; + State = 2475; Match(T__83); - State = 2504; + State = 2476; Match(T__29); - State = 2505; + State = 2477; bytes(); - State = 2506; + State = 2478; Match(T__30); } break; @@ -14673,24 +14392,24 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public BytesContext bytes() { BytesContext _localctx = new BytesContext(Context, State); - EnterRule(_localctx, 312, RULE_bytes); + EnterRule(_localctx, 292, RULE_bytes); BeginStreaming(); Actions.BeginBytes(); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2515; + State = 2487; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32 || _la==ID || _la==HEXBYTE) { { { - State = 2510; + State = 2482; _localctx.b = hexbyte(); Actions.AddByte(_localctx.b.Value); } } - State = 2517; + State = 2489; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -14729,12 +14448,12 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public HexbyteContext hexbyte() { HexbyteContext _localctx = new HexbyteContext(Context, State); - EnterRule(_localctx, 314, RULE_hexbyte); + EnterRule(_localctx, 294, RULE_hexbyte); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2518; + State = 2490; _la = TokenStream.LA(1); if ( !(_la==INT32 || _la==ID || _la==HEXBYTE) ) { ErrorHandler.RecoverInline(this); @@ -14782,9 +14501,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public FieldInitContext fieldInit() { FieldInitContext _localctx = new FieldInitContext(Context, State); - EnterRule(_localctx, 316, RULE_fieldInit); + EnterRule(_localctx, 296, RULE_fieldInit); try { - State = 2523; + State = 2495; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__83: @@ -14802,21 +14521,21 @@ public FieldInitContext fieldInit() { case UINT64: EnterOuterAlt(_localctx, 1); { - State = 2520; + State = 2492; fieldSerInit(); } break; case QSTRING: EnterOuterAlt(_localctx, 2); { - State = 2521; + State = 2493; compQstring(); } break; case NULLREF: EnterOuterAlt(_localctx, 3); { - State = 2522; + State = 2494; Match(NULLREF); } break; @@ -14911,380 +14630,380 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SerInitContext serInit() { SerInitContext _localctx = new SerInitContext(Context, State); - EnterRule(_localctx, 318, RULE_serInit); + EnterRule(_localctx, 298, RULE_serInit); try { - State = 2673; + State = 2645; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,143,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,146,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2525; + State = 2497; fieldSerInit(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2526; + State = 2498; Match(STRING); - State = 2527; + State = 2499; Match(T__29); - State = 2528; + State = 2500; Match(NULLREF); - State = 2529; + State = 2501; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2530; + State = 2502; Match(STRING); - State = 2531; + State = 2503; Match(T__29); - State = 2532; + State = 2504; Match(SQSTRING); - State = 2533; + State = 2505; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2534; + State = 2506; Match(TYPE); - State = 2535; + State = 2507; Match(T__29); - State = 2536; + State = 2508; Match(T__38); - State = 2537; + State = 2509; Match(SQSTRING); - State = 2538; + State = 2510; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2539; + State = 2511; Match(TYPE); - State = 2540; + State = 2512; Match(T__29); - State = 2541; + State = 2513; className(); - State = 2542; + State = 2514; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2544; + State = 2516; Match(TYPE); - State = 2545; + State = 2517; Match(T__29); - State = 2546; + State = 2518; Match(NULLREF); - State = 2547; + State = 2519; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2548; + State = 2520; Match(OBJECT); - State = 2549; + State = 2521; Match(T__29); - State = 2550; + State = 2522; serInit(); - State = 2551; + State = 2523; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2553; + State = 2525; Match(FLOAT32); - State = 2554; + State = 2526; Match(T__41); - State = 2555; + State = 2527; int32(); - State = 2556; + State = 2528; Match(T__42); - State = 2557; + State = 2529; Match(T__29); - State = 2558; + State = 2530; f32seq(); - State = 2559; + State = 2531; Match(T__30); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2561; + State = 2533; Match(FLOAT64_); - State = 2562; + State = 2534; Match(T__41); - State = 2563; + State = 2535; int32(); - State = 2564; + State = 2536; Match(T__42); - State = 2565; + State = 2537; Match(T__29); - State = 2566; + State = 2538; f64seq(); - State = 2567; + State = 2539; Match(T__30); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2569; + State = 2541; Match(INT64_); - State = 2570; + State = 2542; Match(T__41); - State = 2571; + State = 2543; int32(); - State = 2572; + State = 2544; Match(T__42); - State = 2573; + State = 2545; Match(T__29); - State = 2574; + State = 2546; i64seq(); - State = 2575; + State = 2547; Match(T__30); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2577; + State = 2549; Match(INT32_); - State = 2578; + State = 2550; Match(T__41); - State = 2579; + State = 2551; int32(); - State = 2580; + State = 2552; Match(T__42); - State = 2581; + State = 2553; Match(T__29); - State = 2582; + State = 2554; i32seq(); - State = 2583; + State = 2555; Match(T__30); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2585; + State = 2557; Match(INT16); - State = 2586; + State = 2558; Match(T__41); - State = 2587; + State = 2559; int32(); - State = 2588; + State = 2560; Match(T__42); - State = 2589; + State = 2561; Match(T__29); - State = 2590; + State = 2562; i16seq(); - State = 2591; + State = 2563; Match(T__30); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2593; + State = 2565; Match(INT8); - State = 2594; + State = 2566; Match(T__41); - State = 2595; + State = 2567; int32(); - State = 2596; + State = 2568; Match(T__42); - State = 2597; + State = 2569; Match(T__29); - State = 2598; + State = 2570; i8seq(); - State = 2599; + State = 2571; Match(T__30); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2601; + State = 2573; Match(UINT64); - State = 2602; + State = 2574; Match(T__41); - State = 2603; + State = 2575; int32(); - State = 2604; + State = 2576; Match(T__42); - State = 2605; + State = 2577; Match(T__29); - State = 2606; + State = 2578; i64seq(); - State = 2607; + State = 2579; Match(T__30); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2609; + State = 2581; Match(UINT32); - State = 2610; + State = 2582; Match(T__41); - State = 2611; + State = 2583; int32(); - State = 2612; + State = 2584; Match(T__42); - State = 2613; + State = 2585; Match(T__29); - State = 2614; + State = 2586; i32seq(); - State = 2615; + State = 2587; Match(T__30); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 2617; + State = 2589; Match(UINT16); - State = 2618; + State = 2590; Match(T__41); - State = 2619; + State = 2591; int32(); - State = 2620; + State = 2592; Match(T__42); - State = 2621; + State = 2593; Match(T__29); - State = 2622; + State = 2594; i16seq(); - State = 2623; + State = 2595; Match(T__30); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 2625; + State = 2597; Match(UINT8); - State = 2626; + State = 2598; Match(T__41); - State = 2627; + State = 2599; int32(); - State = 2628; + State = 2600; Match(T__42); - State = 2629; + State = 2601; Match(T__29); - State = 2630; + State = 2602; i8seq(); - State = 2631; + State = 2603; Match(T__30); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 2633; + State = 2605; Match(CHAR); - State = 2634; + State = 2606; Match(T__41); - State = 2635; + State = 2607; int32(); - State = 2636; + State = 2608; Match(T__42); - State = 2637; + State = 2609; Match(T__29); - State = 2638; + State = 2610; i16seq(); - State = 2639; + State = 2611; Match(T__30); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 2641; + State = 2613; Match(BOOL); - State = 2642; + State = 2614; Match(T__41); - State = 2643; + State = 2615; int32(); - State = 2644; + State = 2616; Match(T__42); - State = 2645; + State = 2617; Match(T__29); - State = 2646; + State = 2618; boolSeq(); - State = 2647; + State = 2619; Match(T__30); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 2649; + State = 2621; Match(STRING); - State = 2650; + State = 2622; Match(T__41); - State = 2651; + State = 2623; int32(); - State = 2652; + State = 2624; Match(T__42); - State = 2653; + State = 2625; Match(T__29); - State = 2654; + State = 2626; sqstringSeq(); - State = 2655; + State = 2627; Match(T__30); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 2657; + State = 2629; Match(TYPE); - State = 2658; + State = 2630; Match(T__41); - State = 2659; + State = 2631; int32(); - State = 2660; + State = 2632; Match(T__42); - State = 2661; + State = 2633; Match(T__29); - State = 2662; + State = 2634; classSeq(); - State = 2663; + State = 2635; Match(T__30); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 2665; + State = 2637; Match(OBJECT); - State = 2666; + State = 2638; Match(T__41); - State = 2667; + State = 2639; int32(); - State = 2668; + State = 2640; Match(T__42); - State = 2669; + State = 2641; Match(T__29); - State = 2670; + State = 2642; objSeq(); - State = 2671; + State = 2643; Match(T__30); } break; @@ -15330,34 +15049,34 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public F32seqContext f32seq() { F32seqContext _localctx = new F32seqContext(Context, State); - EnterRule(_localctx, 320, RULE_f32seq); + EnterRule(_localctx, 300, RULE_f32seq); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2679; + State = 2651; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 98309L) != 0)) { { - State = 2677; + State = 2649; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,144,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,147,Context) ) { case 1: { - State = 2675; + State = 2647; float64(); } break; case 2: { - State = 2676; + State = 2648; int32(); } break; } } - State = 2681; + State = 2653; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15403,34 +15122,34 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public F64seqContext f64seq() { F64seqContext _localctx = new F64seqContext(Context, State); - EnterRule(_localctx, 322, RULE_f64seq); + EnterRule(_localctx, 302, RULE_f64seq); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2686; + State = 2658; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 98311L) != 0)) { { - State = 2684; + State = 2656; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,146,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,149,Context) ) { case 1: { - State = 2682; + State = 2654; float64(); } break; case 2: { - State = 2683; + State = 2655; int64(); } break; } } - State = 2688; + State = 2660; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15470,22 +15189,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public I64seqContext i64seq() { I64seqContext _localctx = new I64seqContext(Context, State); - EnterRule(_localctx, 324, RULE_i64seq); + EnterRule(_localctx, 304, RULE_i64seq); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2692; + State = 2664; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32 || _la==INT64) { { { - State = 2689; + State = 2661; int64(); } } - State = 2694; + State = 2666; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15525,22 +15244,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public I32seqContext i32seq() { I32seqContext _localctx = new I32seqContext(Context, State); - EnterRule(_localctx, 326, RULE_i32seq); + EnterRule(_localctx, 306, RULE_i32seq); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2698; + State = 2670; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 2695; + State = 2667; int32(); } } - State = 2700; + State = 2672; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15580,22 +15299,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public I16seqContext i16seq() { I16seqContext _localctx = new I16seqContext(Context, State); - EnterRule(_localctx, 328, RULE_i16seq); + EnterRule(_localctx, 308, RULE_i16seq); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2704; + State = 2676; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 2701; + State = 2673; int32(); } } - State = 2706; + State = 2678; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15635,22 +15354,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public I8seqContext i8seq() { I8seqContext _localctx = new I8seqContext(Context, State); - EnterRule(_localctx, 330, RULE_i8seq); + EnterRule(_localctx, 310, RULE_i8seq); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2710; + State = 2682; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 2707; + State = 2679; int32(); } } - State = 2712; + State = 2684; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15690,22 +15409,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public BoolSeqContext boolSeq() { BoolSeqContext _localctx = new BoolSeqContext(Context, State); - EnterRule(_localctx, 332, RULE_boolSeq); + EnterRule(_localctx, 312, RULE_boolSeq); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2716; + State = 2688; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__94 || _la==T__95) { { { - State = 2713; + State = 2685; truefalse(); } } - State = 2718; + State = 2690; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15747,18 +15466,18 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SqstringSeqContext sqstringSeq() { SqstringSeqContext _localctx = new SqstringSeqContext(Context, State); - EnterRule(_localctx, 334, RULE_sqstringSeq); + EnterRule(_localctx, 314, RULE_sqstringSeq); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2722; + State = 2694; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==NULLREF || _la==SQSTRING) { { { - State = 2719; + State = 2691; _la = TokenStream.LA(1); if ( !(_la==NULLREF || _la==SQSTRING) ) { ErrorHandler.RecoverInline(this); @@ -15769,7 +15488,7 @@ public SqstringSeqContext sqstringSeq() { } } } - State = 2724; + State = 2696; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15809,22 +15528,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ClassSeqContext classSeq() { ClassSeqContext _localctx = new ClassSeqContext(Context, State); - EnterRule(_localctx, 336, RULE_classSeq); + EnterRule(_localctx, 316, RULE_classSeq); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2728; + State = 2700; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4947802390528L) != 0) || _la==T__112 || _la==NULLREF || _la==VALUE || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 105553118478337L) != 0)) { { { - State = 2725; + State = 2697; classSeqElement(); } } - State = 2730; + State = 2702; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15863,24 +15582,24 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ClassSeqElementContext classSeqElement() { ClassSeqElementContext _localctx = new ClassSeqElementContext(Context, State); - EnterRule(_localctx, 338, RULE_classSeqElement); + EnterRule(_localctx, 318, RULE_classSeqElement); try { - State = 2735; + State = 2707; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case NULLREF: EnterOuterAlt(_localctx, 1); { - State = 2731; + State = 2703; Match(NULLREF); } break; case T__38: EnterOuterAlt(_localctx, 2); { - State = 2732; + State = 2704; Match(T__38); - State = 2733; + State = 2705; Match(SQSTRING); } break; @@ -15897,7 +15616,7 @@ public ClassSeqElementContext classSeqElement() { case ID: EnterOuterAlt(_localctx, 3); { - State = 2734; + State = 2706; className(); } break; @@ -15939,22 +15658,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ObjSeqContext objSeq() { ObjSeqContext _localctx = new ObjSeqContext(Context, State); - EnterRule(_localctx, 340, RULE_objSeq); + EnterRule(_localctx, 320, RULE_objSeq); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2740; + State = 2712; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__83 || ((((_la - 181)) & ~0x3f) == 0 && ((1L << (_la - 181)) & 106495L) != 0)) { { { - State = 2737; + State = 2709; serInit(); } } - State = 2742; + State = 2714; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15997,29 +15716,29 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public CustomAttrDeclContext customAttrDecl() { CustomAttrDeclContext _localctx = new CustomAttrDeclContext(Context, State); - EnterRule(_localctx, 342, RULE_customAttrDecl); + EnterRule(_localctx, 322, RULE_customAttrDecl); try { - State = 2746; + State = 2718; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,157,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,160,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2743; + State = 2715; customDescr(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2744; + State = 2716; customDescrWithOwner(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2745; + State = 2717; dottedName(); } break; @@ -16071,16 +15790,16 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public AsmOrRefDeclContext asmOrRefDecl() { AsmOrRefDeclContext _localctx = new AsmOrRefDeclContext(Context, State); - EnterRule(_localctx, 344, RULE_asmOrRefDecl); + EnterRule(_localctx, 324, RULE_asmOrRefDecl); int _la; try { - State = 2773; + State = 2745; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,158,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,161,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2748; + State = 2720; _la = TokenStream.LA(1); if ( !(_la==T__166 || _la==T__167) ) { ErrorHandler.RecoverInline(this); @@ -16089,72 +15808,72 @@ public AsmOrRefDeclContext asmOrRefDecl() { ErrorHandler.ReportMatch(this); Consume(); } - State = 2749; + State = 2721; Match(T__35); - State = 2750; + State = 2722; Match(T__29); - State = 2751; + State = 2723; bytes(); - State = 2752; + State = 2724; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2754; + State = 2726; Match(T__168); - State = 2755; + State = 2727; intOrWildcard(); - State = 2756; + State = 2728; Match(T__74); - State = 2757; + State = 2729; intOrWildcard(); - State = 2758; + State = 2730; Match(T__74); - State = 2759; + State = 2731; intOrWildcard(); - State = 2760; + State = 2732; Match(T__74); - State = 2761; + State = 2733; intOrWildcard(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2763; + State = 2735; Match(T__169); - State = 2764; + State = 2736; compQstring(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2765; + State = 2737; Match(T__169); - State = 2766; + State = 2738; Match(T__35); - State = 2767; + State = 2739; Match(T__29); - State = 2768; + State = 2740; bytes(); - State = 2769; + State = 2741; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2771; + State = 2743; customAttrDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2772; + State = 2744; compControl(); } break; @@ -16197,38 +15916,38 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public AssemblyRefHeadContext assemblyRefHead() { AssemblyRefHeadContext _localctx = new AssemblyRefHeadContext(Context, State); - EnterRule(_localctx, 346, RULE_assemblyRefHead); + EnterRule(_localctx, 326, RULE_assemblyRefHead); try { - State = 2787; + State = 2759; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,159,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,162,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2775; + State = 2747; Match(T__24); - State = 2776; + State = 2748; Match(T__39); - State = 2777; + State = 2749; asmAttr(); - State = 2778; + State = 2750; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2780; + State = 2752; Match(T__24); - State = 2781; + State = 2753; Match(T__39); - State = 2782; + State = 2754; asmAttr(); - State = 2783; + State = 2755; dottedName(); - State = 2784; + State = 2756; Match(T__33); - State = 2785; + State = 2757; dottedName(); } break; @@ -16268,22 +15987,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public AssemblyRefDeclsContext assemblyRefDecls() { AssemblyRefDeclsContext _localctx = new AssemblyRefDeclsContext(Context, State); - EnterRule(_localctx, 348, RULE_assemblyRefDecls); + EnterRule(_localctx, 328, RULE_assemblyRefDecls); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2792; + State = 2764; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 36028835673735168L) != 0) || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & 4294975519L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 105555249070081L) != 0)) { { { - State = 2789; + State = 2761; assemblyRefDecl(); } } - State = 2794; + State = 2766; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16324,23 +16043,23 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public AssemblyRefDeclContext assemblyRefDecl() { AssemblyRefDeclContext _localctx = new AssemblyRefDeclContext(Context, State); - EnterRule(_localctx, 350, RULE_assemblyRefDecl); + EnterRule(_localctx, 330, RULE_assemblyRefDecl); try { - State = 2809; + State = 2781; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case HASH: EnterOuterAlt(_localctx, 1); { - State = 2795; + State = 2767; Match(HASH); - State = 2796; + State = 2768; Match(T__35); - State = 2797; + State = 2769; Match(T__29); - State = 2798; + State = 2770; bytes(); - State = 2799; + State = 2771; Match(T__30); } break; @@ -16365,29 +16084,29 @@ public AssemblyRefDeclContext assemblyRefDecl() { case ID: EnterOuterAlt(_localctx, 2); { - State = 2801; + State = 2773; asmOrRefDecl(); } break; case T__170: EnterOuterAlt(_localctx, 3); { - State = 2802; + State = 2774; Match(T__170); - State = 2803; + State = 2775; Match(T__35); - State = 2804; + State = 2776; Match(T__29); - State = 2805; + State = 2777; bytes(); - State = 2806; + State = 2778; Match(T__30); } break; case T__54: EnterOuterAlt(_localctx, 4); { - State = 2808; + State = 2780; Match(T__54); } break; @@ -16432,30 +16151,30 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ExptypeHeadContext exptypeHead() { ExptypeHeadContext _localctx = new ExptypeHeadContext(Context, State); - EnterRule(_localctx, 352, RULE_exptypeHead); + EnterRule(_localctx, 332, RULE_exptypeHead); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2811; + State = 2783; Match(T__49); - State = 2812; + State = 2784; Match(T__39); - State = 2816; + State = 2788; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4618441417868443648L) != 0) || _la==T__171) { { { - State = 2813; + State = 2785; exptAttr(); } } - State = 2818; + State = 2790; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2819; + State = 2791; dottedName(); } } @@ -16497,28 +16216,28 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ExportHeadContext exportHead() { ExportHeadContext _localctx = new ExportHeadContext(Context, State); - EnterRule(_localctx, 354, RULE_exportHead); + EnterRule(_localctx, 334, RULE_exportHead); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2821; + State = 2793; Match(EXPORT); - State = 2825; + State = 2797; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4618441417868443648L) != 0) || _la==T__171) { { { - State = 2822; + State = 2794; exptAttr(); } } - State = 2827; + State = 2799; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2828; + State = 2800; dottedName(); } } @@ -16550,83 +16269,83 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ExptAttrContext exptAttr() { ExptAttrContext _localctx = new ExptAttrContext(Context, State); - EnterRule(_localctx, 356, RULE_exptAttr); + EnterRule(_localctx, 336, RULE_exptAttr); try { - State = 2845; + State = 2817; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,164,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,167,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2830; + State = 2802; Match(T__51); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2831; + State = 2803; Match(T__50); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2832; + State = 2804; Match(T__171); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2833; + State = 2805; Match(T__61); - State = 2834; + State = 2806; Match(T__50); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2835; + State = 2807; Match(T__61); - State = 2836; + State = 2808; Match(T__51); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2837; + State = 2809; Match(T__61); - State = 2838; + State = 2810; Match(T__62); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2839; + State = 2811; Match(T__61); - State = 2840; + State = 2812; Match(T__63); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2841; + State = 2813; Match(T__61); - State = 2842; + State = 2814; Match(T__64); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2843; + State = 2815; Match(T__61); - State = 2844; + State = 2816; Match(T__65); } break; @@ -16666,22 +16385,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ExptypeDeclsContext exptypeDecls() { ExptypeDeclsContext _localctx = new ExptypeDeclsContext(Context, State); - EnterRule(_localctx, 358, RULE_exptypeDecls); + EnterRule(_localctx, 338, RULE_exptypeDecls); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2850; + State = 2822; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1125938597265408L) != 0) || _la==T__112 || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 2847; + State = 2819; exptypeDecl(); } } - State = 2852; + State = 2824; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16733,69 +16452,69 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ExptypeDeclContext exptypeDecl() { ExptypeDeclContext _localctx = new ExptypeDeclContext(Context, State); - EnterRule(_localctx, 360, RULE_exptypeDecl); + EnterRule(_localctx, 340, RULE_exptypeDecl); try { - State = 2866; + State = 2838; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,166,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,169,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2853; + State = 2825; Match(T__20); - State = 2854; + State = 2826; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2855; + State = 2827; Match(T__49); - State = 2856; + State = 2828; Match(T__39); - State = 2857; + State = 2829; slashedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2858; + State = 2830; Match(T__24); - State = 2859; + State = 2831; Match(T__39); - State = 2860; + State = 2832; dottedName(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2861; + State = 2833; mdtoken(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2862; + State = 2834; Match(T__49); - State = 2863; + State = 2835; int32(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2864; + State = 2836; customAttrDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2865; + State = 2837; compControl(); } break; @@ -16842,59 +16561,59 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ManifestResHeadContext manifestResHead() { ManifestResHeadContext _localctx = new ManifestResHeadContext(Context, State); - EnterRule(_localctx, 362, RULE_manifestResHead); + EnterRule(_localctx, 342, RULE_manifestResHead); int _la; try { - State = 2887; + State = 2859; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,169,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,172,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2868; + State = 2840; Match(MRESOURCE); - State = 2872; + State = 2844; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__50 || _la==T__51) { { { - State = 2869; + State = 2841; manresAttr(); } } - State = 2874; + State = 2846; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2875; + State = 2847; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2876; + State = 2848; Match(MRESOURCE); - State = 2880; + State = 2852; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__50 || _la==T__51) { { { - State = 2877; + State = 2849; manresAttr(); } } - State = 2882; + State = 2854; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2883; + State = 2855; dottedName(); - State = 2884; + State = 2856; Match(T__33); - State = 2885; + State = 2857; dottedName(); } break; @@ -16928,12 +16647,12 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ManresAttrContext manresAttr() { ManresAttrContext _localctx = new ManresAttrContext(Context, State); - EnterRule(_localctx, 364, RULE_manresAttr); + EnterRule(_localctx, 344, RULE_manresAttr); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2889; + State = 2861; _la = TokenStream.LA(1); if ( !(_la==T__50 || _la==T__51) ) { ErrorHandler.RecoverInline(this); @@ -16978,22 +16697,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ManifestResDeclsContext manifestResDecls() { ManifestResDeclsContext _localctx = new ManifestResDeclsContext(Context, State); - EnterRule(_localctx, 366, RULE_manifestResDecls); + EnterRule(_localctx, 346, RULE_manifestResDecls); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2894; + State = 2866; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38690422784L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 2891; + State = 2863; manifestResDecl(); } } - State = 2896; + State = 2868; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17039,32 +16758,32 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ManifestResDeclContext manifestResDecl() { ManifestResDeclContext _localctx = new ManifestResDeclContext(Context, State); - EnterRule(_localctx, 368, RULE_manifestResDecl); + EnterRule(_localctx, 348, RULE_manifestResDecl); try { - State = 2907; + State = 2879; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__20: EnterOuterAlt(_localctx, 1); { - State = 2897; + State = 2869; Match(T__20); - State = 2898; + State = 2870; dottedName(); - State = 2899; + State = 2871; Match(T__43); - State = 2900; + State = 2872; int32(); } break; case T__24: EnterOuterAlt(_localctx, 2); { - State = 2902; + State = 2874; Match(T__24); - State = 2903; + State = 2875; Match(T__39); - State = 2904; + State = 2876; dottedName(); } break; @@ -17077,7 +16796,7 @@ public ManifestResDeclContext manifestResDecl() { case ID: EnterOuterAlt(_localctx, 3); { - State = 2905; + State = 2877; customAttrDecl(); } break; @@ -17091,7 +16810,7 @@ public ManifestResDeclContext manifestResDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 4); { - State = 2906; + State = 2878; compControl(); } break; @@ -17128,7 +16847,7 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { } private static int[] _serializedATN = { - 4,1,305,2910,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, + 4,1,305,2882,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, @@ -17154,1105 +16873,1094 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 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,1,0,1,0,1,1,1,1,1,1,1,1,5,1,377,8,1,10,1,12,1, - 380,9,1,1,1,1,1,3,1,384,8,1,1,2,1,2,1,3,1,3,5,3,390,8,3,10,3,12,3,393, - 9,3,1,3,1,3,1,4,5,4,398,8,4,10,4,12,4,401,9,4,1,5,1,5,1,5,1,5,1,5,1,5, + 2,171,7,171,2,172,7,172,2,173,7,173,2,174,7,174,1,0,1,0,1,1,1,1,1,1,1, + 1,5,1,357,8,1,10,1,12,1,360,9,1,1,1,1,1,3,1,364,8,1,1,2,1,2,1,3,1,3,5, + 3,370,8,3,10,3,12,3,373,9,3,1,3,1,3,1,4,5,4,378,8,4,10,4,12,4,381,9,4, 1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1, 5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5, - 1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,453,8,5,1,6,1,6,1,6,1,7,1,7,1, - 7,1,8,1,8,1,8,1,8,1,9,1,9,1,9,1,10,1,10,1,10,1,11,1,11,1,11,1,11,1,11, - 1,11,1,11,1,12,1,12,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,494,8,13,1,14,1,14,1,15,1,15,1,15,5,15,501,8, - 15,10,15,12,15,504,9,15,1,15,1,15,1,16,1,16,1,17,1,17,1,18,1,18,1,18,1, - 18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,3,18,527,8,18, - 1,19,1,19,3,19,531,8,19,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1, - 20,1,20,1,20,1,20,1,20,1,20,1,20,3,20,549,8,20,1,21,1,21,1,21,1,21,1,21, + 1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,433,8, + 5,1,6,1,6,1,6,1,7,1,7,1,7,1,8,1,8,1,8,1,8,1,9,1,9,1,9,1,10,1,10,1,10,1, + 11,1,11,1,11,1,11,1,11,1,11,1,11,1,12,1,12,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,474,8,13,1,14,1,14,1,15, + 1,15,1,15,5,15,481,8,15,10,15,12,15,484,9,15,1,15,1,15,1,16,1,16,1,17, + 1,17,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18, + 1,18,1,18,3,18,507,8,18,1,19,1,19,3,19,511,8,19,1,20,1,20,1,20,1,20,1, + 20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,3,20,529,8,20, 1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21, - 1,21,1,21,1,21,1,21,1,21,1,21,3,21,576,8,21,1,22,1,22,1,22,1,22,1,22,1, + 1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,3,21,556,8,21,1, 22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1, - 22,1,22,3,22,599,8,22,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23, + 22,1,22,1,22,1,22,1,22,1,22,1,22,3,22,579,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,1,23,1,23,1,23,1,23,1,23,1,23,1,23,3,23,635,8,23,1,24,1, - 24,1,25,1,25,3,25,641,8,25,1,26,1,26,1,26,1,27,1,27,5,27,648,8,27,10,27, - 12,27,651,9,27,1,28,1,28,1,28,1,28,1,28,1,28,1,28,5,28,660,8,28,10,28, - 12,28,663,9,28,1,29,1,29,1,30,1,30,3,30,669,8,30,1,31,1,31,1,31,1,31,1, - 31,1,31,1,31,1,31,1,31,3,31,680,8,31,1,32,1,32,1,32,1,32,1,32,1,32,3,32, - 688,8,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,34,1,34,1,34,1,34,5,34,709,8,34,10,34,12,34,712,9,34,1, - 35,1,35,1,35,1,35,1,35,1,35,1,36,1,36,1,36,1,37,1,37,5,37,725,8,37,10, - 37,12,37,728,9,37,1,37,1,37,1,37,1,37,1,37,1,38,1,38,1,38,1,38,1,38,1, + 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,615,8,23,1,24,1,24,1,25,1,25,3,25,621,8,25,1,26,1,26,1,26,1, + 27,1,27,5,27,628,8,27,10,27,12,27,631,9,27,1,28,1,28,1,28,1,28,1,28,1, + 28,1,28,5,28,640,8,28,10,28,12,28,643,9,28,1,29,1,29,1,30,1,30,3,30,649, + 8,30,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,3,31,660,8,31,1,32,1, + 32,1,32,1,32,1,32,1,32,3,32,668,8,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,34,1,34,1,34,1,34,5,34,689,8, + 34,10,34,12,34,692,9,34,1,35,1,35,1,35,1,35,1,35,1,35,1,36,1,36,1,36,1, + 37,1,37,5,37,705,8,37,10,37,12,37,708,9,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,38,1,38,1,38,1,38,1,38,1,38,1,38,1, 38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1, - 38,1,38,1,38,1,38,3,38,772,8,38,1,39,1,39,1,39,3,39,777,8,39,1,40,1,40, - 1,40,3,40,782,8,40,1,41,5,41,785,8,41,10,41,12,41,788,9,41,1,42,1,42,1, - 42,5,42,793,8,42,10,42,12,42,796,9,42,1,42,1,42,1,43,1,43,1,44,1,44,1, - 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, - 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, - 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, - 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, - 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, - 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, - 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, - 44,1,44,1,44,3,44,905,8,44,1,45,1,45,5,45,909,8,45,10,45,12,45,912,9,45, - 1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,5,45,925,8,45,10, - 45,12,45,928,9,45,1,45,1,45,1,45,3,45,933,8,45,1,46,1,46,1,47,1,47,3,47, - 939,8,47,1,48,1,48,1,49,5,49,944,8,49,10,49,12,49,947,9,49,1,50,1,50,1, - 51,1,51,1,52,1,52,1,53,1,53,1,54,1,54,1,55,1,55,1,56,1,56,1,57,1,57,1, - 58,1,58,1,59,1,59,1,60,1,60,1,61,1,61,1,62,1,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,1,63,1,63,1,63,1,63,1,63,1,63,1, - 63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1, - 63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1, - 63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1, - 63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,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,1057,8,63,1,64,1,64,1,64,3, - 64,1062,8,64,1,64,1,64,5,64,1066,8,64,10,64,12,64,1069,9,64,1,64,1,64, - 3,64,1073,8,64,3,64,1075,8,64,1,65,1,65,1,65,1,65,5,65,1081,8,65,10,65, - 12,65,1084,9,65,1,65,1,65,1,65,1,66,1,66,1,66,1,66,5,66,1093,8,66,10,66, - 12,66,1096,9,66,1,66,1,66,1,66,1,67,1,67,1,67,1,67,5,67,1105,8,67,10,67, - 12,67,1108,9,67,1,67,1,67,1,67,1,67,3,67,1114,8,67,1,68,1,68,1,68,1,68, - 1,68,3,68,1121,8,68,3,68,1123,8,68,1,69,1,69,1,69,1,69,1,69,1,69,1,69, - 1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69, - 1,69,1,69,1,69,1,69,3,69,1150,8,69,1,70,1,70,1,70,5,70,1155,8,70,10,70, - 12,70,1158,9,70,1,70,1,70,1,71,5,71,1163,8,71,10,71,12,71,1166,9,71,1, - 72,1,72,1,72,1,72,1,72,3,72,1173,8,72,1,73,1,73,1,73,1,73,1,73,1,73,1, - 73,1,73,1,73,1,73,1,73,3,73,1186,8,73,1,74,1,74,1,74,5,74,1191,8,74,10, - 74,12,74,1194,9,74,3,74,1196,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,1,75,1,75,1,75,1,75,3,75,1215,8,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,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,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,1,76,1,76,1,76,1,76,1, - 76,1,76,1,76,1,76,1,76,1,76,1,76,3,76,1309,8,76,1,77,1,77,1,77,1,77,1, - 77,1,77,1,77,3,77,1318,8,77,1,78,1,78,1,78,5,78,1323,8,78,10,78,12,78, - 1326,9,78,3,78,1328,8,78,1,79,1,79,1,80,1,80,5,80,1334,8,80,10,80,12,80, - 1337,9,80,1,81,1,81,1,81,1,81,1,81,1,81,1,81,1,81,1,81,1,81,1,81,1,81, - 1,81,1,81,1,81,1,81,1,81,1,81,3,81,1357,8,81,1,82,1,82,1,82,1,82,1,82, + 38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,3,38,752,8,38,1,39,1,39,1,39, + 3,39,757,8,39,1,40,1,40,1,40,3,40,762,8,40,1,41,5,41,765,8,41,10,41,12, + 41,768,9,41,1,42,1,42,1,42,5,42,773,8,42,10,42,12,42,776,9,42,1,42,1,42, + 1,43,1,43,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, + 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, + 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, + 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, + 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, + 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, + 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, + 1,44,1,44,1,44,1,44,1,44,1,44,1,44,3,44,885,8,44,1,45,1,45,5,45,889,8, + 45,10,45,12,45,892,9,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1, + 45,1,45,5,45,905,8,45,10,45,12,45,908,9,45,1,45,1,45,1,45,3,45,913,8,45, + 1,46,1,46,1,47,1,47,3,47,919,8,47,1,48,1,48,1,49,5,49,924,8,49,10,49,12, + 49,927,9,49,1,50,1,50,3,50,931,8,50,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,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,983,8,51,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1, + 52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1, + 52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,3,52,1019,8,52,1,53,1, + 53,1,53,3,53,1024,8,53,1,53,1,53,5,53,1028,8,53,10,53,12,53,1031,9,53, + 1,53,1,53,3,53,1035,8,53,3,53,1037,8,53,1,54,1,54,1,54,1,54,5,54,1043, + 8,54,10,54,12,54,1046,9,54,1,54,1,54,1,54,1,55,1,55,1,55,1,55,5,55,1055, + 8,55,10,55,12,55,1058,9,55,1,55,1,55,1,55,1,56,1,56,1,56,1,56,5,56,1067, + 8,56,10,56,12,56,1070,9,56,1,56,1,56,1,56,1,56,3,56,1076,8,56,1,57,1,57, + 1,57,1,57,1,57,3,57,1083,8,57,3,57,1085,8,57,1,58,1,58,1,58,1,58,1,58, + 1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58, + 1,58,1,58,1,58,1,58,1,58,1,58,3,58,1112,8,58,1,59,1,59,1,59,5,59,1117, + 8,59,10,59,12,59,1120,9,59,1,59,1,59,1,60,5,60,1125,8,60,10,60,12,60,1128, + 9,60,1,61,1,61,1,61,1,61,1,61,3,61,1135,8,61,1,62,1,62,1,62,1,62,1,62, + 1,62,1,62,1,62,1,62,1,62,1,62,3,62,1148,8,62,1,63,1,63,1,63,5,63,1153, + 8,63,10,63,12,63,1156,9,63,3,63,1158,8,63,1,64,1,64,1,64,1,64,1,64,1,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,1177,8,64, + 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, + 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, + 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, + 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, + 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, + 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, + 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,3,65,1271,8,65,1,66,1,66,1,66, + 1,66,1,66,1,66,1,66,3,66,1280,8,66,1,67,1,67,1,67,5,67,1285,8,67,10,67, + 12,67,1288,9,67,3,67,1290,8,67,1,68,1,68,1,69,1,69,5,69,1296,8,69,10,69, + 12,69,1299,9,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,1,70,1,70,1,70,3,70,1319,8,70,1,71,1,71,1,71,1,71, + 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, + 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,3,71,1351, + 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,1,72,1,72,1,72,1,72,1,72,1,72,3,72,1374,8,72,1,73,1,73,1,73, + 1,73,1,73,1,73,1,73,1,73,1,73,1,73,3,73,1386,8,73,1,74,1,74,1,74,1,75, + 1,75,1,75,1,75,3,75,1395,8,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,3,76,1420,8,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,1444, + 8,76,1,77,1,77,1,77,1,77,5,77,1450,8,77,10,77,12,77,1453,9,77,1,77,3,77, + 1456,8,77,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78, + 1,78,3,78,1471,8,78,1,79,1,79,1,79,5,79,1476,8,79,10,79,12,79,1479,9,79, + 1,79,1,79,1,80,1,80,1,80,1,80,1,81,1,81,1,82,1,82,1,82,1,82,1,82,1,82, + 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, - 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,3,82,1389,8,82, - 1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83, - 1,83,1,83,1,83,1,83,1,83,1,83,1,83,3,83,1412,8,83,1,84,1,84,1,84,1,84, - 1,84,1,84,1,84,1,84,1,84,1,84,3,84,1424,8,84,1,85,1,85,1,85,1,86,1,86, - 1,86,1,86,3,86,1433,8,86,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87, - 1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87, - 3,87,1458,8,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87, - 1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,3,87,1482,8,87, - 1,88,1,88,1,88,1,88,5,88,1488,8,88,10,88,12,88,1491,9,88,1,88,3,88,1494, - 8,88,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89, - 3,89,1509,8,89,1,90,1,90,1,90,5,90,1514,8,90,10,90,12,90,1517,9,90,1,90, - 1,90,1,91,1,91,1,91,1,91,1,92,1,92,1,93,1,93,1,93,1,93,1,93,1,93,1,93, - 1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93, - 1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,3,93, - 1561,8,93,1,94,1,94,1,95,1,95,1,95,1,95,1,95,1,95,3,95,1571,8,95,1,95, - 1,95,1,95,1,95,1,95,1,95,1,95,1,95,1,95,1,95,1,95,1,95,1,95,1,95,3,95, - 1587,8,95,1,95,1,95,1,95,1,95,1,95,1,95,1,95,1,95,1,95,1,95,3,95,1599, - 8,95,1,96,1,96,1,96,1,96,1,96,1,96,1,96,1,96,1,96,1,96,3,96,1611,8,96, - 1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,3,97,1625, - 8,97,1,98,1,98,1,98,1,98,1,98,1,99,1,99,1,99,1,99,1,99,3,99,1637,8,99, - 1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,3,100,1648,8,100, - 1,101,1,101,1,101,5,101,1653,8,101,10,101,12,101,1656,9,101,1,101,1,101, - 1,102,1,102,1,102,1,102,1,102,3,102,1665,8,102,1,103,1,103,1,103,1,103, - 1,103,1,103,1,103,1,103,1,103,1,103,1,103,3,103,1678,8,103,1,104,5,104, - 1681,8,104,10,104,12,104,1684,9,104,1,105,1,105,3,105,1688,8,105,1,105, - 1,105,1,106,1,106,1,106,5,106,1695,8,106,10,106,12,106,1698,9,106,1,106, - 1,106,1,107,1,107,1,107,1,107,1,108,1,108,3,108,1708,8,108,1,109,1,109, - 1,109,1,109,1,109,1,109,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110, - 1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110, - 1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110, - 1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110, - 1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110, - 1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110, - 1,110,1,110,1,110,1,110,1,110,5,110,1789,8,110,10,110,12,110,1792,9,110, - 1,110,1,110,1,110,1,110,5,110,1798,8,110,10,110,12,110,1801,9,110,1,110, - 1,110,1,110,1,110,1,110,1,110,1,110,1,110,5,110,1811,8,110,10,110,12,110, - 1814,9,110,1,110,1,110,1,110,1,110,1,110,1,110,5,110,1822,8,110,10,110, - 12,110,1825,9,110,1,110,1,110,1,110,1,110,1,110,3,110,1832,8,110,1,111, - 1,111,1,111,1,111,1,111,1,111,1,111,1,111,5,111,1842,8,111,10,111,12,111, - 1845,9,111,1,111,1,111,1,111,1,111,1,111,1,112,1,112,1,112,1,112,1,112, - 1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112, - 1,112,1,112,3,112,1871,8,112,1,113,1,113,1,113,1,113,1,113,3,113,1878, - 8,113,1,114,1,114,1,114,3,114,1883,8,114,1,115,1,115,1,115,1,115,1,115, - 3,115,1890,8,115,1,116,1,116,5,116,1894,8,116,10,116,12,116,1897,9,116, - 1,116,1,116,1,116,1,116,1,116,5,116,1904,8,116,10,116,12,116,1907,9,116, - 1,116,3,116,1910,8,116,1,117,1,117,1,118,5,118,1915,8,118,10,118,12,118, - 1918,9,118,1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119, - 1,119,1,119,3,119,1932,8,119,1,120,1,120,5,120,1936,8,120,10,120,12,120, - 1939,9,120,1,120,1,120,1,120,1,120,1,120,1,120,1,121,1,121,1,122,5,122, - 1950,8,122,10,122,12,122,1953,9,122,1,123,1,123,1,123,1,123,1,123,1,123, - 1,123,1,123,1,123,1,123,3,123,1965,8,123,1,124,1,124,1,124,1,124,1,124, - 1,124,3,124,1973,8,124,1,125,1,125,1,125,4,125,1978,8,125,11,125,12,125, - 1979,1,125,1,125,3,125,1984,8,125,1,126,5,126,1987,8,126,10,126,12,126, - 1990,9,126,1,127,1,127,1,127,1,127,1,127,1,127,1,127,1,127,1,127,1,127, - 1,127,1,127,1,127,3,127,2005,8,127,1,128,1,128,1,128,5,128,2010,8,128, - 10,128,12,128,2013,9,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128, - 5,128,2023,8,128,10,128,12,128,2026,9,128,1,129,1,129,1,129,1,129,1,129, - 1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129, - 1,129,1,129,1,129,1,129,1,129,1,129,3,129,2051,8,129,1,130,1,130,1,130, - 1,130,1,130,3,130,2058,8,130,3,130,2060,8,130,1,130,5,130,2063,8,130,10, - 130,12,130,2066,9,130,1,130,1,130,1,130,3,130,2071,8,130,1,131,1,131,1, - 131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131, - 1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131, - 1,131,3,131,2100,8,131,1,132,1,132,1,132,3,132,2105,8,132,1,133,1,133, - 1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133, - 1,133,1,133,1,133,1,133,1,133,1,133,1,133,3,133,2128,8,133,1,134,5,134, - 2131,8,134,10,134,12,134,2134,9,134,1,135,1,135,1,135,1,135,1,135,1,135, - 1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135, - 1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135, - 1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135, - 1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135, - 1,135,1,135,1,135,1,135,1,135,5,135,2195,8,135,10,135,12,135,2198,9,135, - 1,135,1,135,1,135,1,135,5,135,2204,8,135,10,135,12,135,2207,9,135,1,135, - 1,135,1,135,1,135,1,135,1,135,1,135,1,135,5,135,2217,8,135,10,135,12,135, - 2220,9,135,1,135,1,135,1,135,1,135,1,135,1,135,5,135,2228,8,135,10,135, - 12,135,2231,9,135,1,135,1,135,1,135,1,135,1,135,1,135,5,135,2239,8,135, - 10,135,12,135,2242,9,135,3,135,2244,8,135,1,136,1,136,1,136,1,137,1,137, - 3,137,2251,8,137,1,138,1,138,1,138,1,138,1,139,1,139,1,139,1,140,4,140, - 2261,8,140,11,140,12,140,2262,1,141,1,141,1,141,1,141,1,141,1,141,1,141, - 1,141,1,141,1,141,1,141,1,141,3,141,2277,8,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,3,142,2291,8,142,1,143, - 1,143,1,143,1,143,1,143,1,143,3,143,2299,8,143,1,144,1,144,1,144,1,145, - 1,145,1,146,1,146,1,147,1,147,1,147,1,147,1,147,1,147,1,147,1,147,1,147, - 1,147,1,147,3,147,2319,8,147,1,148,1,148,1,148,1,149,1,149,1,149,1,149, - 1,149,1,149,1,149,3,149,2331,8,149,1,150,1,150,1,150,3,150,2336,8,150, - 1,151,1,151,1,151,1,151,1,151,4,151,2343,8,151,11,151,12,151,2344,3,151, - 2347,8,151,1,152,1,152,1,152,5,152,2352,8,152,10,152,12,152,2355,9,152, - 1,152,1,152,1,153,1,153,1,153,1,153,1,153,3,153,2364,8,153,1,154,1,154, - 1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154, - 1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154, - 1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154, - 1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154, - 1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154, - 1,154,1,154,1,154,1,154,3,154,2432,8,154,1,155,1,155,1,155,1,155,1,155, - 1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155, - 1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155, - 1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155, - 1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155, - 1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155, - 1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,3,155,2509, - 8,155,1,156,1,156,1,156,5,156,2514,8,156,10,156,12,156,2517,9,156,1,157, - 1,157,1,158,1,158,1,158,3,158,2524,8,158,1,159,1,159,1,159,1,159,1,159, - 1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159, - 1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159, - 1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159, - 1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159, - 1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159, - 1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159, - 1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159, - 1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159, - 1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159, - 1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159, - 1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159, - 1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,3,159, - 2674,8,159,1,160,1,160,5,160,2678,8,160,10,160,12,160,2681,9,160,1,161, - 1,161,5,161,2685,8,161,10,161,12,161,2688,9,161,1,162,5,162,2691,8,162, - 10,162,12,162,2694,9,162,1,163,5,163,2697,8,163,10,163,12,163,2700,9,163, - 1,164,5,164,2703,8,164,10,164,12,164,2706,9,164,1,165,5,165,2709,8,165, - 10,165,12,165,2712,9,165,1,166,5,166,2715,8,166,10,166,12,166,2718,9,166, - 1,167,5,167,2721,8,167,10,167,12,167,2724,9,167,1,168,5,168,2727,8,168, - 10,168,12,168,2730,9,168,1,169,1,169,1,169,1,169,3,169,2736,8,169,1,170, - 5,170,2739,8,170,10,170,12,170,2742,9,170,1,171,1,171,1,171,3,171,2747, - 8,171,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172, - 1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172, - 1,172,1,172,3,172,2774,8,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,3,173,2788,8,173,1,174,5,174,2791,8,174, - 10,174,12,174,2794,9,174,1,175,1,175,1,175,1,175,1,175,1,175,1,175,1,175, - 1,175,1,175,1,175,1,175,1,175,1,175,3,175,2810,8,175,1,176,1,176,1,176, - 5,176,2815,8,176,10,176,12,176,2818,9,176,1,176,1,176,1,177,1,177,5,177, - 2824,8,177,10,177,12,177,2827,9,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,178,1,178,1,178,1,178,3,178, - 2846,8,178,1,179,5,179,2849,8,179,10,179,12,179,2852,9,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,3,180, - 2867,8,180,1,181,1,181,5,181,2871,8,181,10,181,12,181,2874,9,181,1,181, - 1,181,1,181,5,181,2879,8,181,10,181,12,181,2882,9,181,1,181,1,181,1,181, - 1,181,3,181,2888,8,181,1,182,1,182,1,183,5,183,2893,8,183,10,183,12,183, - 2896,9,183,1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184, - 3,184,2908,8,184,1,184,0,1,68,185,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, + 3,82,1523,8,82,1,83,1,83,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1533,8,84, + 1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84, + 3,84,1549,8,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,3,84, + 1561,8,84,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,3,85,1573, + 8,85,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,3,86, + 1587,8,86,1,87,1,87,1,87,1,87,1,87,1,88,1,88,1,88,1,88,1,88,3,88,1599, + 8,88,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,3,89,1610,8,89,1,90, + 1,90,1,90,5,90,1615,8,90,10,90,12,90,1618,9,90,1,90,1,90,1,91,1,91,1,91, + 1,91,1,91,3,91,1627,8,91,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92, + 1,92,1,92,3,92,1640,8,92,1,93,5,93,1643,8,93,10,93,12,93,1646,9,93,1,94, + 1,94,3,94,1650,8,94,1,94,1,94,1,95,1,95,1,95,5,95,1657,8,95,10,95,12,95, + 1660,9,95,1,95,1,95,1,96,1,96,1,96,1,96,1,97,1,97,3,97,1670,8,97,1,98, + 1,98,1,98,1,98,1,98,1,98,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, + 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, + 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, + 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, + 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, + 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,1751,8,99,10,99,12,99,1754, + 9,99,1,99,1,99,1,99,1,99,5,99,1760,8,99,10,99,12,99,1763,9,99,1,99,1,99, + 1,99,1,99,1,99,1,99,1,99,1,99,5,99,1773,8,99,10,99,12,99,1776,9,99,1,99, + 1,99,1,99,1,99,1,99,1,99,5,99,1784,8,99,10,99,12,99,1787,9,99,1,99,1,99, + 1,99,1,99,1,99,3,99,1794,8,99,1,100,1,100,1,100,1,100,1,100,1,100,1,100, + 1,100,5,100,1804,8,100,10,100,12,100,1807,9,100,1,100,1,100,1,100,1,100, + 1,100,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101, + 1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,3,101,1833,8,101,1,102, + 1,102,1,102,1,102,1,102,3,102,1840,8,102,1,103,1,103,1,103,3,103,1845, + 8,103,1,104,1,104,1,104,1,104,1,104,3,104,1852,8,104,1,105,1,105,5,105, + 1856,8,105,10,105,12,105,1859,9,105,1,105,1,105,1,105,1,105,1,105,5,105, + 1866,8,105,10,105,12,105,1869,9,105,1,105,3,105,1872,8,105,1,106,1,106, + 1,107,5,107,1877,8,107,10,107,12,107,1880,9,107,1,108,1,108,1,108,1,108, + 1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,3,108,1894,8,108,1,109, + 1,109,5,109,1898,8,109,10,109,12,109,1901,9,109,1,109,1,109,1,109,1,109, + 1,109,1,109,1,110,1,110,1,111,5,111,1912,8,111,10,111,12,111,1915,9,111, + 1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,3,112,1927, + 8,112,1,113,1,113,1,113,1,113,1,113,1,113,3,113,1935,8,113,1,114,1,114, + 1,114,4,114,1940,8,114,11,114,12,114,1941,1,114,1,114,3,114,1946,8,114, + 1,115,5,115,1949,8,115,10,115,12,115,1952,9,115,1,116,1,116,1,116,1,116, + 1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,3,116,1967,8,116, + 1,117,1,117,1,117,5,117,1972,8,117,10,117,12,117,1975,9,117,1,117,1,117, + 1,117,1,117,1,117,1,117,1,117,1,117,5,117,1985,8,117,10,117,12,117,1988, + 9,117,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, + 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, + 3,118,2013,8,118,1,119,1,119,1,119,1,119,1,119,3,119,2020,8,119,3,119, + 2022,8,119,1,119,5,119,2025,8,119,10,119,12,119,2028,9,119,1,119,1,119, + 1,119,3,119,2033,8,119,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, + 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, + 1,120,1,120,1,120,1,120,1,120,1,120,1,120,3,120,2062,8,120,1,121,1,121, + 1,121,3,121,2067,8,121,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, + 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, + 1,122,3,122,2090,8,122,1,123,5,123,2093,8,123,10,123,12,123,2096,9,123, + 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, + 1,124,1,124,1,124,1,124,1,124,3,124,2115,8,124,1,125,1,125,1,125,1,125, + 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, + 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, + 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, + 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,5,125,2166,8,125, + 10,125,12,125,2169,9,125,1,125,1,125,1,125,1,125,5,125,2175,8,125,10,125, + 12,125,2178,9,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,5,125, + 2188,8,125,10,125,12,125,2191,9,125,1,125,1,125,1,125,1,125,1,125,1,125, + 5,125,2199,8,125,10,125,12,125,2202,9,125,1,125,1,125,1,125,1,125,1,125, + 1,125,5,125,2210,8,125,10,125,12,125,2213,9,125,3,125,2215,8,125,1,126, + 1,126,1,126,1,126,1,127,1,127,3,127,2223,8,127,1,128,1,128,1,128,1,128, + 1,129,1,129,1,129,1,130,4,130,2233,8,130,11,130,12,130,2234,1,131,1,131, + 1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,3,131,2249, + 8,131,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132, + 1,132,3,132,2263,8,132,1,133,1,133,1,133,1,133,1,133,1,133,3,133,2271, + 8,133,1,134,1,134,1,134,1,135,1,135,1,136,1,136,1,137,1,137,1,137,1,137, + 1,137,1,137,1,137,1,137,1,137,1,137,1,137,3,137,2291,8,137,1,138,1,138, + 1,138,1,139,1,139,1,139,1,139,1,139,1,139,1,139,3,139,2303,8,139,1,140, + 1,140,1,140,3,140,2308,8,140,1,141,1,141,1,141,1,141,1,141,4,141,2315, + 8,141,11,141,12,141,2316,3,141,2319,8,141,1,142,1,142,1,142,5,142,2324, + 8,142,10,142,12,142,2327,9,142,1,142,1,142,1,143,1,143,1,143,1,143,1,143, + 3,143,2336,8,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,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,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,2404,8,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,145,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,145,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,145,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,145,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,145,1,145,1,145,1,145,1,145,1,145,1,145,1,145, + 1,145,1,145,1,145,3,145,2481,8,145,1,146,1,146,1,146,5,146,2486,8,146, + 10,146,12,146,2489,9,146,1,147,1,147,1,148,1,148,1,148,3,148,2496,8,148, + 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, + 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, + 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, + 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, + 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, + 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, + 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, + 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, + 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, + 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, + 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, + 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, + 1,149,1,149,1,149,1,149,3,149,2646,8,149,1,150,1,150,5,150,2650,8,150, + 10,150,12,150,2653,9,150,1,151,1,151,5,151,2657,8,151,10,151,12,151,2660, + 9,151,1,152,5,152,2663,8,152,10,152,12,152,2666,9,152,1,153,5,153,2669, + 8,153,10,153,12,153,2672,9,153,1,154,5,154,2675,8,154,10,154,12,154,2678, + 9,154,1,155,5,155,2681,8,155,10,155,12,155,2684,9,155,1,156,5,156,2687, + 8,156,10,156,12,156,2690,9,156,1,157,5,157,2693,8,157,10,157,12,157,2696, + 9,157,1,158,5,158,2699,8,158,10,158,12,158,2702,9,158,1,159,1,159,1,159, + 1,159,3,159,2708,8,159,1,160,5,160,2711,8,160,10,160,12,160,2714,9,160, + 1,161,1,161,1,161,3,161,2719,8,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,162,1,162,1,162,1,162,1,162,1,162, + 1,162,1,162,1,162,1,162,1,162,1,162,1,162,3,162,2746,8,162,1,163,1,163, + 1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,3,163,2760, + 8,163,1,164,5,164,2763,8,164,10,164,12,164,2766,9,164,1,165,1,165,1,165, + 1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,3,165, + 2782,8,165,1,166,1,166,1,166,5,166,2787,8,166,10,166,12,166,2790,9,166, + 1,166,1,166,1,167,1,167,5,167,2796,8,167,10,167,12,167,2799,9,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,168,1,168,1,168,1,168,3,168,2818,8,168,1,169,5,169,2821,8,169,10,169, + 12,169,2824,9,169,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170, + 1,170,1,170,1,170,1,170,3,170,2839,8,170,1,171,1,171,5,171,2843,8,171, + 10,171,12,171,2846,9,171,1,171,1,171,1,171,5,171,2851,8,171,10,171,12, + 171,2854,9,171,1,171,1,171,1,171,1,171,3,171,2860,8,171,1,172,1,172,1, + 173,5,173,2865,8,173,10,173,12,173,2868,9,173,1,174,1,174,1,174,1,174, + 1,174,1,174,1,174,1,174,1,174,1,174,3,174,2880,8,174,1,174,0,1,68,175, + 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, 0,16,6,0,1,15,199,199,243,243,247,247,264,264,289,289,5,0,16,16,199,199, 243,243,264,264,288,289,1,0,263,264,1,0,173,174,1,0,37,38,1,0,73,74,3, 0,2,2,61,61,77,83,2,0,229,229,260,261,9,0,178,178,183,195,201,201,207, 208,210,215,218,219,222,222,230,242,262,262,1,0,95,96,1,0,97,111,1,0,68, - 69,2,0,173,173,289,290,2,0,179,179,264,264,1,0,167,168,1,0,51,52,3327, - 0,370,1,0,0,0,2,383,1,0,0,0,4,385,1,0,0,0,6,391,1,0,0,0,8,399,1,0,0,0, - 10,452,1,0,0,0,12,454,1,0,0,0,14,457,1,0,0,0,16,460,1,0,0,0,18,464,1,0, - 0,0,20,467,1,0,0,0,22,470,1,0,0,0,24,477,1,0,0,0,26,493,1,0,0,0,28,495, - 1,0,0,0,30,497,1,0,0,0,32,507,1,0,0,0,34,509,1,0,0,0,36,526,1,0,0,0,38, - 530,1,0,0,0,40,548,1,0,0,0,42,575,1,0,0,0,44,598,1,0,0,0,46,634,1,0,0, - 0,48,636,1,0,0,0,50,640,1,0,0,0,52,642,1,0,0,0,54,649,1,0,0,0,56,661,1, - 0,0,0,58,664,1,0,0,0,60,666,1,0,0,0,62,679,1,0,0,0,64,687,1,0,0,0,66,689, - 1,0,0,0,68,697,1,0,0,0,70,713,1,0,0,0,72,719,1,0,0,0,74,722,1,0,0,0,76, - 771,1,0,0,0,78,776,1,0,0,0,80,781,1,0,0,0,82,786,1,0,0,0,84,794,1,0,0, - 0,86,799,1,0,0,0,88,904,1,0,0,0,90,932,1,0,0,0,92,934,1,0,0,0,94,938,1, - 0,0,0,96,940,1,0,0,0,98,945,1,0,0,0,100,948,1,0,0,0,102,950,1,0,0,0,104, - 952,1,0,0,0,106,954,1,0,0,0,108,956,1,0,0,0,110,958,1,0,0,0,112,960,1, - 0,0,0,114,962,1,0,0,0,116,964,1,0,0,0,118,966,1,0,0,0,120,968,1,0,0,0, - 122,970,1,0,0,0,124,972,1,0,0,0,126,1056,1,0,0,0,128,1074,1,0,0,0,130, - 1076,1,0,0,0,132,1088,1,0,0,0,134,1113,1,0,0,0,136,1122,1,0,0,0,138,1149, - 1,0,0,0,140,1156,1,0,0,0,142,1164,1,0,0,0,144,1172,1,0,0,0,146,1185,1, - 0,0,0,148,1195,1,0,0,0,150,1214,1,0,0,0,152,1308,1,0,0,0,154,1317,1,0, - 0,0,156,1327,1,0,0,0,158,1329,1,0,0,0,160,1331,1,0,0,0,162,1356,1,0,0, - 0,164,1388,1,0,0,0,166,1411,1,0,0,0,168,1423,1,0,0,0,170,1425,1,0,0,0, - 172,1428,1,0,0,0,174,1481,1,0,0,0,176,1493,1,0,0,0,178,1508,1,0,0,0,180, - 1515,1,0,0,0,182,1520,1,0,0,0,184,1524,1,0,0,0,186,1560,1,0,0,0,188,1562, - 1,0,0,0,190,1598,1,0,0,0,192,1610,1,0,0,0,194,1624,1,0,0,0,196,1626,1, - 0,0,0,198,1636,1,0,0,0,200,1647,1,0,0,0,202,1654,1,0,0,0,204,1664,1,0, - 0,0,206,1677,1,0,0,0,208,1682,1,0,0,0,210,1685,1,0,0,0,212,1696,1,0,0, - 0,214,1701,1,0,0,0,216,1707,1,0,0,0,218,1709,1,0,0,0,220,1831,1,0,0,0, - 222,1833,1,0,0,0,224,1870,1,0,0,0,226,1877,1,0,0,0,228,1882,1,0,0,0,230, - 1889,1,0,0,0,232,1909,1,0,0,0,234,1911,1,0,0,0,236,1916,1,0,0,0,238,1931, - 1,0,0,0,240,1933,1,0,0,0,242,1946,1,0,0,0,244,1951,1,0,0,0,246,1964,1, - 0,0,0,248,1972,1,0,0,0,250,1983,1,0,0,0,252,1988,1,0,0,0,254,2004,1,0, - 0,0,256,2006,1,0,0,0,258,2050,1,0,0,0,260,2070,1,0,0,0,262,2099,1,0,0, - 0,264,2104,1,0,0,0,266,2127,1,0,0,0,268,2132,1,0,0,0,270,2243,1,0,0,0, - 272,2245,1,0,0,0,274,2250,1,0,0,0,276,2252,1,0,0,0,278,2256,1,0,0,0,280, - 2260,1,0,0,0,282,2276,1,0,0,0,284,2290,1,0,0,0,286,2298,1,0,0,0,288,2300, - 1,0,0,0,290,2303,1,0,0,0,292,2305,1,0,0,0,294,2318,1,0,0,0,296,2320,1, - 0,0,0,298,2330,1,0,0,0,300,2335,1,0,0,0,302,2346,1,0,0,0,304,2353,1,0, - 0,0,306,2363,1,0,0,0,308,2431,1,0,0,0,310,2508,1,0,0,0,312,2515,1,0,0, - 0,314,2518,1,0,0,0,316,2523,1,0,0,0,318,2673,1,0,0,0,320,2679,1,0,0,0, - 322,2686,1,0,0,0,324,2692,1,0,0,0,326,2698,1,0,0,0,328,2704,1,0,0,0,330, - 2710,1,0,0,0,332,2716,1,0,0,0,334,2722,1,0,0,0,336,2728,1,0,0,0,338,2735, - 1,0,0,0,340,2740,1,0,0,0,342,2746,1,0,0,0,344,2773,1,0,0,0,346,2787,1, - 0,0,0,348,2792,1,0,0,0,350,2809,1,0,0,0,352,2811,1,0,0,0,354,2821,1,0, - 0,0,356,2845,1,0,0,0,358,2850,1,0,0,0,360,2866,1,0,0,0,362,2887,1,0,0, - 0,364,2889,1,0,0,0,366,2894,1,0,0,0,368,2907,1,0,0,0,370,371,7,0,0,0,371, - 1,1,0,0,0,372,384,5,288,0,0,373,374,3,4,2,0,374,375,5,265,0,0,375,377, - 1,0,0,0,376,373,1,0,0,0,377,380,1,0,0,0,378,376,1,0,0,0,378,379,1,0,0, - 0,379,381,1,0,0,0,380,378,1,0,0,0,381,384,3,4,2,0,382,384,5,264,0,0,383, - 372,1,0,0,0,383,378,1,0,0,0,383,382,1,0,0,0,384,3,1,0,0,0,385,386,7,1, - 0,0,386,5,1,0,0,0,387,388,5,263,0,0,388,390,5,266,0,0,389,387,1,0,0,0, - 390,393,1,0,0,0,391,389,1,0,0,0,391,392,1,0,0,0,392,394,1,0,0,0,393,391, - 1,0,0,0,394,395,5,263,0,0,395,7,1,0,0,0,396,398,3,10,5,0,397,396,1,0,0, - 0,398,401,1,0,0,0,399,397,1,0,0,0,399,400,1,0,0,0,400,9,1,0,0,0,401,399, - 1,0,0,0,402,403,3,74,37,0,403,404,5,17,0,0,404,405,3,82,41,0,405,406,5, - 18,0,0,406,453,1,0,0,0,407,408,3,72,36,0,408,409,5,17,0,0,409,410,3,8, - 4,0,410,411,5,18,0,0,411,453,1,0,0,0,412,413,3,256,128,0,413,414,5,17, - 0,0,414,415,3,268,134,0,415,416,5,18,0,0,416,453,1,0,0,0,417,453,3,222, - 111,0,418,453,3,296,148,0,419,453,3,70,35,0,420,453,3,66,33,0,421,453, - 3,88,44,0,422,453,3,90,45,0,423,453,3,22,11,0,424,425,3,346,173,0,425, - 426,5,17,0,0,426,427,3,348,174,0,427,428,5,18,0,0,428,453,1,0,0,0,429, - 430,3,352,176,0,430,431,5,17,0,0,431,432,3,358,179,0,432,433,5,18,0,0, - 433,453,1,0,0,0,434,435,3,362,181,0,435,436,5,17,0,0,436,437,3,366,183, - 0,437,438,5,18,0,0,438,453,1,0,0,0,439,453,3,64,32,0,440,453,3,174,87, - 0,441,453,3,342,171,0,442,453,3,12,6,0,443,453,3,14,7,0,444,453,3,16,8, - 0,445,453,3,18,9,0,446,453,3,20,10,0,447,453,3,26,13,0,448,453,3,42,21, - 0,449,453,3,40,20,0,450,453,3,30,15,0,451,453,3,24,12,0,452,402,1,0,0, - 0,452,407,1,0,0,0,452,412,1,0,0,0,452,417,1,0,0,0,452,418,1,0,0,0,452, - 419,1,0,0,0,452,420,1,0,0,0,452,421,1,0,0,0,452,422,1,0,0,0,452,423,1, - 0,0,0,452,424,1,0,0,0,452,429,1,0,0,0,452,434,1,0,0,0,452,439,1,0,0,0, - 452,440,1,0,0,0,452,441,1,0,0,0,452,442,1,0,0,0,452,443,1,0,0,0,452,444, - 1,0,0,0,452,445,1,0,0,0,452,446,1,0,0,0,452,447,1,0,0,0,452,448,1,0,0, - 0,452,449,1,0,0,0,452,450,1,0,0,0,452,451,1,0,0,0,453,11,1,0,0,0,454,455, - 5,19,0,0,455,456,3,32,16,0,456,13,1,0,0,0,457,458,5,20,0,0,458,459,3,32, - 16,0,459,15,1,0,0,0,460,461,5,21,0,0,461,462,5,22,0,0,462,463,3,32,16, - 0,463,17,1,0,0,0,464,465,5,23,0,0,465,466,3,34,17,0,466,19,1,0,0,0,467, - 468,5,24,0,0,468,469,3,34,17,0,469,21,1,0,0,0,470,471,5,25,0,0,471,472, - 3,98,49,0,472,473,3,2,1,0,473,474,5,17,0,0,474,475,3,142,71,0,475,476, - 5,18,0,0,476,23,1,0,0,0,477,478,5,26,0,0,478,25,1,0,0,0,479,480,5,27,0, - 0,480,494,3,28,14,0,481,482,5,27,0,0,482,483,3,28,14,0,483,484,5,28,0, - 0,484,485,3,28,14,0,485,494,1,0,0,0,486,487,5,27,0,0,487,488,3,28,14,0, - 488,489,5,28,0,0,489,490,3,28,14,0,490,491,5,28,0,0,491,492,3,28,14,0, - 492,494,1,0,0,0,493,479,1,0,0,0,493,481,1,0,0,0,493,486,1,0,0,0,494,27, - 1,0,0,0,495,496,7,2,0,0,496,29,1,0,0,0,497,498,5,29,0,0,498,502,5,17,0, - 0,499,501,3,138,69,0,500,499,1,0,0,0,501,504,1,0,0,0,502,500,1,0,0,0,502, - 503,1,0,0,0,503,505,1,0,0,0,504,502,1,0,0,0,505,506,5,18,0,0,506,31,1, - 0,0,0,507,508,5,173,0,0,508,33,1,0,0,0,509,510,7,3,0,0,510,35,1,0,0,0, - 511,527,5,175,0,0,512,513,3,32,16,0,513,514,5,265,0,0,514,527,1,0,0,0, - 515,527,3,32,16,0,516,517,5,188,0,0,517,518,5,30,0,0,518,519,3,32,16,0, - 519,520,5,31,0,0,520,527,1,0,0,0,521,522,5,189,0,0,522,523,5,30,0,0,523, - 524,3,34,17,0,524,525,5,31,0,0,525,527,1,0,0,0,526,511,1,0,0,0,526,512, - 1,0,0,0,526,515,1,0,0,0,526,516,1,0,0,0,526,521,1,0,0,0,527,37,1,0,0,0, - 528,531,3,32,16,0,529,531,5,262,0,0,530,528,1,0,0,0,530,529,1,0,0,0,531, - 39,1,0,0,0,532,533,5,267,0,0,533,549,5,289,0,0,534,535,5,267,0,0,535,536, - 5,289,0,0,536,549,5,263,0,0,537,538,5,268,0,0,538,549,5,289,0,0,539,540, - 5,269,0,0,540,549,5,289,0,0,541,542,5,270,0,0,542,549,5,289,0,0,543,549, - 5,271,0,0,544,549,5,272,0,0,545,546,5,273,0,0,546,549,5,263,0,0,547,549, - 5,32,0,0,548,532,1,0,0,0,548,534,1,0,0,0,548,537,1,0,0,0,548,539,1,0,0, - 0,548,541,1,0,0,0,548,543,1,0,0,0,548,544,1,0,0,0,548,545,1,0,0,0,548, - 547,1,0,0,0,549,41,1,0,0,0,550,551,5,33,0,0,551,552,3,160,80,0,552,553, - 5,34,0,0,553,554,3,2,1,0,554,576,1,0,0,0,555,556,5,33,0,0,556,557,3,138, - 69,0,557,558,5,34,0,0,558,559,3,2,1,0,559,576,1,0,0,0,560,561,5,33,0,0, - 561,562,3,198,99,0,562,563,5,34,0,0,563,564,3,2,1,0,564,576,1,0,0,0,565, - 566,5,33,0,0,566,567,3,44,22,0,567,568,5,34,0,0,568,569,3,2,1,0,569,576, - 1,0,0,0,570,571,5,33,0,0,571,572,3,46,23,0,572,573,5,34,0,0,573,574,3, - 2,1,0,574,576,1,0,0,0,575,550,1,0,0,0,575,555,1,0,0,0,575,560,1,0,0,0, - 575,565,1,0,0,0,575,570,1,0,0,0,576,43,1,0,0,0,577,578,5,35,0,0,578,599, - 3,48,24,0,579,580,5,35,0,0,580,581,3,48,24,0,581,582,5,36,0,0,582,583, - 3,6,3,0,583,599,1,0,0,0,584,585,5,35,0,0,585,586,3,48,24,0,586,587,5,36, - 0,0,587,588,5,17,0,0,588,589,3,52,26,0,589,590,5,18,0,0,590,599,1,0,0, - 0,591,592,5,35,0,0,592,593,3,48,24,0,593,594,5,36,0,0,594,595,5,30,0,0, - 595,596,3,312,156,0,596,597,5,31,0,0,597,599,1,0,0,0,598,577,1,0,0,0,598, - 579,1,0,0,0,598,584,1,0,0,0,598,591,1,0,0,0,599,45,1,0,0,0,600,601,5,35, - 0,0,601,602,5,30,0,0,602,603,3,50,25,0,603,604,5,31,0,0,604,605,3,48,24, - 0,605,635,1,0,0,0,606,607,5,35,0,0,607,608,5,30,0,0,608,609,3,50,25,0, - 609,610,5,31,0,0,610,611,3,48,24,0,611,612,5,36,0,0,612,613,3,6,3,0,613, - 635,1,0,0,0,614,615,5,35,0,0,615,616,5,30,0,0,616,617,3,50,25,0,617,618, - 5,31,0,0,618,619,3,48,24,0,619,620,5,36,0,0,620,621,5,17,0,0,621,622,3, - 52,26,0,622,623,5,18,0,0,623,635,1,0,0,0,624,625,5,35,0,0,625,626,5,30, - 0,0,626,627,3,50,25,0,627,628,5,31,0,0,628,629,3,48,24,0,629,630,5,36, - 0,0,630,631,5,30,0,0,631,632,3,312,156,0,632,633,5,31,0,0,633,635,1,0, - 0,0,634,600,1,0,0,0,634,606,1,0,0,0,634,614,1,0,0,0,634,624,1,0,0,0,635, - 47,1,0,0,0,636,637,3,190,95,0,637,49,1,0,0,0,638,641,3,146,73,0,639,641, - 3,198,99,0,640,638,1,0,0,0,640,639,1,0,0,0,641,51,1,0,0,0,642,643,3,54, - 27,0,643,644,3,56,28,0,644,53,1,0,0,0,645,648,3,318,159,0,646,648,3,40, - 20,0,647,645,1,0,0,0,647,646,1,0,0,0,648,651,1,0,0,0,649,647,1,0,0,0,649, - 650,1,0,0,0,650,55,1,0,0,0,651,649,1,0,0,0,652,653,3,58,29,0,653,654,3, - 60,30,0,654,655,3,2,1,0,655,656,5,36,0,0,656,657,3,318,159,0,657,660,1, - 0,0,0,658,660,3,40,20,0,659,652,1,0,0,0,659,658,1,0,0,0,660,663,1,0,0, - 0,661,659,1,0,0,0,661,662,1,0,0,0,662,57,1,0,0,0,663,661,1,0,0,0,664,665, - 7,4,0,0,665,59,1,0,0,0,666,668,3,62,31,0,667,669,5,261,0,0,668,667,1,0, - 0,0,668,669,1,0,0,0,669,61,1,0,0,0,670,680,3,166,83,0,671,680,3,2,1,0, - 672,680,5,196,0,0,673,680,5,197,0,0,674,675,5,202,0,0,675,676,5,39,0,0, - 676,680,5,264,0,0,677,678,5,202,0,0,678,680,3,138,69,0,679,670,1,0,0,0, - 679,671,1,0,0,0,679,672,1,0,0,0,679,673,1,0,0,0,679,674,1,0,0,0,679,677, - 1,0,0,0,680,63,1,0,0,0,681,682,5,198,0,0,682,683,5,40,0,0,683,688,3,2, - 1,0,684,685,5,198,0,0,685,688,3,2,1,0,686,688,5,198,0,0,687,681,1,0,0, - 0,687,684,1,0,0,0,687,686,1,0,0,0,688,65,1,0,0,0,689,690,5,41,0,0,690, - 691,5,42,0,0,691,692,3,32,16,0,692,693,5,43,0,0,693,694,3,68,34,0,694, - 695,5,44,0,0,695,696,3,0,0,0,696,67,1,0,0,0,697,710,6,34,-1,0,698,699, - 10,5,0,0,699,709,5,186,0,0,700,701,10,4,0,0,701,709,5,187,0,0,702,703, - 10,3,0,0,703,709,5,45,0,0,704,705,10,2,0,0,705,709,5,46,0,0,706,707,10, - 1,0,0,707,709,5,47,0,0,708,698,1,0,0,0,708,700,1,0,0,0,708,702,1,0,0,0, - 708,704,1,0,0,0,708,706,1,0,0,0,709,712,1,0,0,0,710,708,1,0,0,0,710,711, - 1,0,0,0,711,69,1,0,0,0,712,710,1,0,0,0,713,714,5,48,0,0,714,715,5,36,0, - 0,715,716,5,30,0,0,716,717,3,312,156,0,717,718,5,31,0,0,718,71,1,0,0,0, - 719,720,5,49,0,0,720,721,3,2,1,0,721,73,1,0,0,0,722,726,5,50,0,0,723,725, - 3,76,38,0,724,723,1,0,0,0,725,728,1,0,0,0,726,724,1,0,0,0,726,727,1,0, - 0,0,727,729,1,0,0,0,728,726,1,0,0,0,729,730,3,2,1,0,730,731,3,204,102, - 0,731,732,3,78,39,0,732,733,3,80,40,0,733,75,1,0,0,0,734,772,5,51,0,0, - 735,772,5,52,0,0,736,772,5,199,0,0,737,772,5,202,0,0,738,772,5,221,0,0, - 739,772,5,53,0,0,740,772,5,54,0,0,741,772,5,55,0,0,742,772,5,56,0,0,743, - 772,5,244,0,0,744,772,5,15,0,0,745,772,5,224,0,0,746,772,5,57,0,0,747, - 772,5,58,0,0,748,772,5,59,0,0,749,772,5,60,0,0,750,772,5,61,0,0,751,752, - 5,62,0,0,752,772,5,51,0,0,753,754,5,62,0,0,754,772,5,52,0,0,755,756,5, - 62,0,0,756,772,5,63,0,0,757,758,5,62,0,0,758,772,5,64,0,0,759,760,5,62, - 0,0,760,772,5,65,0,0,761,762,5,62,0,0,762,772,5,66,0,0,763,772,5,67,0, - 0,764,772,5,68,0,0,765,772,5,69,0,0,766,767,5,70,0,0,767,768,5,30,0,0, - 768,769,3,32,16,0,769,770,5,31,0,0,770,772,1,0,0,0,771,734,1,0,0,0,771, - 735,1,0,0,0,771,736,1,0,0,0,771,737,1,0,0,0,771,738,1,0,0,0,771,739,1, - 0,0,0,771,740,1,0,0,0,771,741,1,0,0,0,771,742,1,0,0,0,771,743,1,0,0,0, - 771,744,1,0,0,0,771,745,1,0,0,0,771,746,1,0,0,0,771,747,1,0,0,0,771,748, - 1,0,0,0,771,749,1,0,0,0,771,750,1,0,0,0,771,751,1,0,0,0,771,753,1,0,0, - 0,771,755,1,0,0,0,771,757,1,0,0,0,771,759,1,0,0,0,771,761,1,0,0,0,771, - 763,1,0,0,0,771,764,1,0,0,0,771,765,1,0,0,0,771,766,1,0,0,0,772,77,1,0, - 0,0,773,777,1,0,0,0,774,775,5,71,0,0,775,777,3,146,73,0,776,773,1,0,0, - 0,776,774,1,0,0,0,777,79,1,0,0,0,778,782,1,0,0,0,779,780,5,72,0,0,780, - 782,3,84,42,0,781,778,1,0,0,0,781,779,1,0,0,0,782,81,1,0,0,0,783,785,3, - 220,110,0,784,783,1,0,0,0,785,788,1,0,0,0,786,784,1,0,0,0,786,787,1,0, - 0,0,787,83,1,0,0,0,788,786,1,0,0,0,789,790,3,146,73,0,790,791,5,28,0,0, - 791,793,1,0,0,0,792,789,1,0,0,0,793,796,1,0,0,0,794,792,1,0,0,0,794,795, - 1,0,0,0,795,797,1,0,0,0,796,794,1,0,0,0,797,798,3,146,73,0,798,85,1,0, - 0,0,799,800,7,5,0,0,800,87,1,0,0,0,801,802,3,86,43,0,802,803,3,32,16,0, - 803,804,5,264,0,0,804,905,1,0,0,0,805,806,3,86,43,0,806,807,3,32,16,0, - 807,905,1,0,0,0,808,809,3,86,43,0,809,810,3,32,16,0,810,811,5,75,0,0,811, - 812,3,32,16,0,812,813,5,264,0,0,813,905,1,0,0,0,814,815,3,86,43,0,815, - 816,3,32,16,0,816,817,5,75,0,0,817,818,3,32,16,0,818,905,1,0,0,0,819,820, - 3,86,43,0,820,821,3,32,16,0,821,822,5,75,0,0,822,823,3,32,16,0,823,824, - 5,28,0,0,824,825,3,32,16,0,825,826,5,264,0,0,826,905,1,0,0,0,827,828,3, - 86,43,0,828,829,3,32,16,0,829,830,5,75,0,0,830,831,3,32,16,0,831,832,5, - 28,0,0,832,833,3,32,16,0,833,905,1,0,0,0,834,835,3,86,43,0,835,836,3,32, - 16,0,836,837,5,28,0,0,837,838,3,32,16,0,838,839,5,75,0,0,839,840,3,32, - 16,0,840,841,5,264,0,0,841,905,1,0,0,0,842,843,3,86,43,0,843,844,3,32, - 16,0,844,845,5,28,0,0,845,846,3,32,16,0,846,847,5,75,0,0,847,848,3,32, - 16,0,848,905,1,0,0,0,849,850,3,86,43,0,850,851,3,32,16,0,851,852,5,28, - 0,0,852,853,3,32,16,0,853,854,5,75,0,0,854,855,3,32,16,0,855,856,5,28, - 0,0,856,857,3,32,16,0,857,858,5,264,0,0,858,905,1,0,0,0,859,860,3,86,43, - 0,860,861,3,32,16,0,861,862,5,28,0,0,862,863,3,32,16,0,863,864,5,75,0, - 0,864,865,3,32,16,0,865,866,5,28,0,0,866,867,3,32,16,0,867,905,1,0,0,0, - 868,869,3,86,43,0,869,870,3,32,16,0,870,871,5,263,0,0,871,905,1,0,0,0, - 872,873,3,86,43,0,873,874,3,32,16,0,874,875,5,75,0,0,875,876,3,32,16,0, - 876,877,5,263,0,0,877,905,1,0,0,0,878,879,3,86,43,0,879,880,3,32,16,0, - 880,881,5,75,0,0,881,882,3,32,16,0,882,883,5,28,0,0,883,884,3,32,16,0, - 884,885,5,263,0,0,885,905,1,0,0,0,886,887,3,86,43,0,887,888,3,32,16,0, - 888,889,5,28,0,0,889,890,3,32,16,0,890,891,5,75,0,0,891,892,3,32,16,0, - 892,893,5,263,0,0,893,905,1,0,0,0,894,895,3,86,43,0,895,896,3,32,16,0, - 896,897,5,28,0,0,897,898,3,32,16,0,898,899,5,75,0,0,899,900,3,32,16,0, - 900,901,5,28,0,0,901,902,3,32,16,0,902,903,5,263,0,0,903,905,1,0,0,0,904, - 801,1,0,0,0,904,805,1,0,0,0,904,808,1,0,0,0,904,814,1,0,0,0,904,819,1, - 0,0,0,904,827,1,0,0,0,904,834,1,0,0,0,904,842,1,0,0,0,904,849,1,0,0,0, - 904,859,1,0,0,0,904,868,1,0,0,0,904,872,1,0,0,0,904,878,1,0,0,0,904,886, - 1,0,0,0,904,894,1,0,0,0,905,89,1,0,0,0,906,910,5,21,0,0,907,909,3,92,46, - 0,908,907,1,0,0,0,909,912,1,0,0,0,910,908,1,0,0,0,910,911,1,0,0,0,911, - 913,1,0,0,0,912,910,1,0,0,0,913,914,3,2,1,0,914,915,3,94,47,0,915,916, - 5,180,0,0,916,917,5,36,0,0,917,918,5,30,0,0,918,919,3,312,156,0,919,920, - 5,31,0,0,920,921,3,94,47,0,921,933,1,0,0,0,922,926,5,21,0,0,923,925,3, - 92,46,0,924,923,1,0,0,0,925,928,1,0,0,0,926,924,1,0,0,0,926,927,1,0,0, - 0,927,929,1,0,0,0,928,926,1,0,0,0,929,930,3,2,1,0,930,931,3,94,47,0,931, - 933,1,0,0,0,932,906,1,0,0,0,932,922,1,0,0,0,933,91,1,0,0,0,934,935,5,76, - 0,0,935,93,1,0,0,0,936,939,1,0,0,0,937,939,5,298,0,0,938,936,1,0,0,0,938, - 937,1,0,0,0,939,95,1,0,0,0,940,941,7,6,0,0,941,97,1,0,0,0,942,944,3,96, - 48,0,943,942,1,0,0,0,944,947,1,0,0,0,945,943,1,0,0,0,945,946,1,0,0,0,946, - 99,1,0,0,0,947,945,1,0,0,0,948,949,5,275,0,0,949,101,1,0,0,0,950,951,5, - 276,0,0,951,103,1,0,0,0,952,953,5,277,0,0,953,105,1,0,0,0,954,955,5,278, - 0,0,955,107,1,0,0,0,956,957,5,279,0,0,957,109,1,0,0,0,958,959,5,282,0, - 0,959,111,1,0,0,0,960,961,5,280,0,0,961,113,1,0,0,0,962,963,5,286,0,0, - 963,115,1,0,0,0,964,965,5,284,0,0,965,117,1,0,0,0,966,967,5,285,0,0,967, - 119,1,0,0,0,968,969,5,281,0,0,969,121,1,0,0,0,970,971,5,287,0,0,971,123, - 1,0,0,0,972,973,5,283,0,0,973,125,1,0,0,0,974,1057,3,100,50,0,975,976, - 3,102,51,0,976,977,3,32,16,0,977,1057,1,0,0,0,978,979,3,102,51,0,979,980, - 3,0,0,0,980,1057,1,0,0,0,981,982,3,104,52,0,982,983,3,32,16,0,983,1057, - 1,0,0,0,984,985,3,106,53,0,985,986,3,34,17,0,986,1057,1,0,0,0,987,988, - 3,108,54,0,988,989,3,36,18,0,989,1057,1,0,0,0,990,991,3,108,54,0,991,992, - 3,34,17,0,992,1057,1,0,0,0,993,994,3,108,54,0,994,995,5,30,0,0,995,996, - 3,312,156,0,996,997,5,31,0,0,997,1057,1,0,0,0,998,999,3,108,54,0,999,1000, - 5,84,0,0,1000,1001,5,30,0,0,1001,1002,3,312,156,0,1002,1003,5,31,0,0,1003, - 1057,1,0,0,0,1004,1005,3,110,55,0,1005,1006,3,32,16,0,1006,1057,1,0,0, - 0,1007,1008,3,110,55,0,1008,1009,3,0,0,0,1009,1057,1,0,0,0,1010,1011,3, - 112,56,0,1011,1012,3,190,95,0,1012,1057,1,0,0,0,1013,1014,3,114,57,0,1014, - 1015,3,200,100,0,1015,1057,1,0,0,0,1016,1017,3,114,57,0,1017,1018,3,196, - 98,0,1018,1057,1,0,0,0,1019,1020,3,116,58,0,1020,1021,3,146,73,0,1021, - 1057,1,0,0,0,1022,1023,3,118,59,0,1023,1024,3,6,3,0,1024,1057,1,0,0,0, - 1025,1026,3,118,59,0,1026,1027,5,224,0,0,1027,1028,5,30,0,0,1028,1029, - 3,6,3,0,1029,1030,5,31,0,0,1030,1057,1,0,0,0,1031,1032,3,118,59,0,1032, - 1033,5,84,0,0,1033,1034,5,30,0,0,1034,1035,3,312,156,0,1035,1036,5,31, - 0,0,1036,1057,1,0,0,0,1037,1038,3,120,60,0,1038,1039,3,192,96,0,1039,1040, - 3,160,80,0,1040,1041,3,134,67,0,1041,1057,1,0,0,0,1042,1043,3,122,61,0, - 1043,1044,3,50,25,0,1044,1057,1,0,0,0,1045,1046,3,122,61,0,1046,1047,3, - 32,16,0,1047,1057,1,0,0,0,1048,1049,3,124,62,0,1049,1050,5,30,0,0,1050, - 1051,3,128,64,0,1051,1052,5,31,0,0,1052,1057,1,0,0,0,1053,1054,3,124,62, - 0,1054,1055,5,85,0,0,1055,1057,1,0,0,0,1056,974,1,0,0,0,1056,975,1,0,0, - 0,1056,978,1,0,0,0,1056,981,1,0,0,0,1056,984,1,0,0,0,1056,987,1,0,0,0, - 1056,990,1,0,0,0,1056,993,1,0,0,0,1056,998,1,0,0,0,1056,1004,1,0,0,0,1056, - 1007,1,0,0,0,1056,1010,1,0,0,0,1056,1013,1,0,0,0,1056,1016,1,0,0,0,1056, - 1019,1,0,0,0,1056,1022,1,0,0,0,1056,1025,1,0,0,0,1056,1031,1,0,0,0,1056, - 1037,1,0,0,0,1056,1042,1,0,0,0,1056,1045,1,0,0,0,1056,1048,1,0,0,0,1056, - 1053,1,0,0,0,1057,127,1,0,0,0,1058,1075,1,0,0,0,1059,1062,3,0,0,0,1060, - 1062,3,32,16,0,1061,1059,1,0,0,0,1061,1060,1,0,0,0,1062,1063,1,0,0,0,1063, - 1064,5,28,0,0,1064,1066,1,0,0,0,1065,1061,1,0,0,0,1066,1069,1,0,0,0,1067, - 1065,1,0,0,0,1067,1068,1,0,0,0,1068,1072,1,0,0,0,1069,1067,1,0,0,0,1070, - 1073,3,0,0,0,1071,1073,3,32,16,0,1072,1070,1,0,0,0,1072,1071,1,0,0,0,1073, - 1075,1,0,0,0,1074,1058,1,0,0,0,1074,1067,1,0,0,0,1075,129,1,0,0,0,1076, - 1082,5,86,0,0,1077,1078,3,160,80,0,1078,1079,5,28,0,0,1079,1081,1,0,0, - 0,1080,1077,1,0,0,0,1081,1084,1,0,0,0,1082,1080,1,0,0,0,1082,1083,1,0, - 0,0,1083,1085,1,0,0,0,1084,1082,1,0,0,0,1085,1086,3,160,80,0,1086,1087, - 5,87,0,0,1087,131,1,0,0,0,1088,1094,5,42,0,0,1089,1090,3,168,84,0,1090, - 1091,5,28,0,0,1091,1093,1,0,0,0,1092,1089,1,0,0,0,1093,1096,1,0,0,0,1094, - 1092,1,0,0,0,1094,1095,1,0,0,0,1095,1097,1,0,0,0,1096,1094,1,0,0,0,1097, - 1098,3,168,84,0,1098,1099,5,43,0,0,1099,133,1,0,0,0,1100,1106,5,30,0,0, - 1101,1102,3,136,68,0,1102,1103,5,28,0,0,1103,1105,1,0,0,0,1104,1101,1, - 0,0,0,1105,1108,1,0,0,0,1106,1104,1,0,0,0,1106,1107,1,0,0,0,1107,1109, - 1,0,0,0,1108,1106,1,0,0,0,1109,1110,3,136,68,0,1110,1111,5,31,0,0,1111, - 1114,1,0,0,0,1112,1114,5,85,0,0,1113,1100,1,0,0,0,1113,1112,1,0,0,0,1114, - 135,1,0,0,0,1115,1123,5,177,0,0,1116,1117,3,252,126,0,1117,1118,3,160, - 80,0,1118,1120,3,248,124,0,1119,1121,3,0,0,0,1120,1119,1,0,0,0,1120,1121, - 1,0,0,0,1121,1123,1,0,0,0,1122,1115,1,0,0,0,1122,1116,1,0,0,0,1123,137, - 1,0,0,0,1124,1125,5,42,0,0,1125,1126,3,2,1,0,1126,1127,5,43,0,0,1127,1128, - 3,140,70,0,1128,1150,1,0,0,0,1129,1130,5,42,0,0,1130,1131,3,196,98,0,1131, - 1132,5,43,0,0,1132,1133,3,140,70,0,1133,1150,1,0,0,0,1134,1135,5,42,0, - 0,1135,1136,5,262,0,0,1136,1137,5,43,0,0,1137,1150,3,140,70,0,1138,1139, - 5,42,0,0,1139,1140,5,198,0,0,1140,1141,3,2,1,0,1141,1142,5,43,0,0,1142, - 1143,3,140,70,0,1143,1150,1,0,0,0,1144,1150,3,140,70,0,1145,1150,3,196, - 98,0,1146,1150,5,257,0,0,1147,1150,5,258,0,0,1148,1150,5,259,0,0,1149, - 1124,1,0,0,0,1149,1129,1,0,0,0,1149,1134,1,0,0,0,1149,1138,1,0,0,0,1149, - 1144,1,0,0,0,1149,1145,1,0,0,0,1149,1146,1,0,0,0,1149,1147,1,0,0,0,1149, - 1148,1,0,0,0,1150,139,1,0,0,0,1151,1152,3,2,1,0,1152,1153,5,88,0,0,1153, - 1155,1,0,0,0,1154,1151,1,0,0,0,1155,1158,1,0,0,0,1156,1154,1,0,0,0,1156, - 1157,1,0,0,0,1157,1159,1,0,0,0,1158,1156,1,0,0,0,1159,1160,3,2,1,0,1160, - 141,1,0,0,0,1161,1163,3,144,72,0,1162,1161,1,0,0,0,1163,1166,1,0,0,0,1164, - 1162,1,0,0,0,1164,1165,1,0,0,0,1165,143,1,0,0,0,1166,1164,1,0,0,0,1167, - 1168,5,180,0,0,1168,1169,5,89,0,0,1169,1173,3,32,16,0,1170,1173,3,174, - 87,0,1171,1173,3,344,172,0,1172,1167,1,0,0,0,1172,1170,1,0,0,0,1172,1171, - 1,0,0,0,1173,145,1,0,0,0,1174,1186,3,138,69,0,1175,1176,5,42,0,0,1176, - 1177,3,2,1,0,1177,1178,5,43,0,0,1178,1186,1,0,0,0,1179,1180,5,42,0,0,1180, - 1181,5,198,0,0,1181,1182,3,2,1,0,1182,1183,5,43,0,0,1183,1186,1,0,0,0, - 1184,1186,3,160,80,0,1185,1174,1,0,0,0,1185,1175,1,0,0,0,1185,1179,1,0, - 0,0,1185,1184,1,0,0,0,1186,147,1,0,0,0,1187,1196,1,0,0,0,1188,1192,3,152, - 76,0,1189,1191,3,150,75,0,1190,1189,1,0,0,0,1191,1194,1,0,0,0,1192,1190, - 1,0,0,0,1192,1193,1,0,0,0,1193,1196,1,0,0,0,1194,1192,1,0,0,0,1195,1187, - 1,0,0,0,1195,1188,1,0,0,0,1196,149,1,0,0,0,1197,1215,5,262,0,0,1198,1215, - 5,261,0,0,1199,1200,5,42,0,0,1200,1201,3,32,16,0,1201,1202,5,43,0,0,1202, - 1215,1,0,0,0,1203,1204,5,42,0,0,1204,1205,3,32,16,0,1205,1206,5,266,0, - 0,1206,1207,3,32,16,0,1207,1208,5,43,0,0,1208,1215,1,0,0,0,1209,1210,5, - 42,0,0,1210,1211,5,266,0,0,1211,1212,3,32,16,0,1212,1213,5,43,0,0,1213, - 1215,1,0,0,0,1214,1197,1,0,0,0,1214,1198,1,0,0,0,1214,1199,1,0,0,0,1214, - 1203,1,0,0,0,1214,1209,1,0,0,0,1215,151,1,0,0,0,1216,1309,1,0,0,0,1217, - 1218,5,203,0,0,1218,1219,5,30,0,0,1219,1220,3,6,3,0,1220,1221,5,28,0,0, - 1221,1222,3,6,3,0,1222,1223,5,28,0,0,1223,1224,3,6,3,0,1224,1225,5,28, - 0,0,1225,1226,3,6,3,0,1226,1227,5,31,0,0,1227,1309,1,0,0,0,1228,1229,5, - 203,0,0,1229,1230,5,30,0,0,1230,1231,3,6,3,0,1231,1232,5,28,0,0,1232,1233, - 3,6,3,0,1233,1234,5,31,0,0,1234,1309,1,0,0,0,1235,1236,5,204,0,0,1236, - 1237,5,205,0,0,1237,1238,5,42,0,0,1238,1239,3,32,16,0,1239,1240,5,43,0, - 0,1240,1309,1,0,0,0,1241,1242,5,204,0,0,1242,1243,5,206,0,0,1243,1244, - 5,42,0,0,1244,1245,3,32,16,0,1245,1246,5,43,0,0,1246,1247,3,148,74,0,1247, - 1309,1,0,0,0,1248,1309,5,207,0,0,1249,1309,5,208,0,0,1250,1309,5,209,0, - 0,1251,1309,5,201,0,0,1252,1309,5,183,0,0,1253,1309,5,184,0,0,1254,1309, - 5,185,0,0,1255,1309,5,186,0,0,1256,1309,5,187,0,0,1257,1309,5,188,0,0, - 1258,1309,5,189,0,0,1259,1309,5,210,0,0,1260,1309,5,190,0,0,1261,1309, - 5,191,0,0,1262,1309,5,192,0,0,1263,1309,5,193,0,0,1264,1309,5,211,0,0, - 1265,1309,5,212,0,0,1266,1309,5,213,0,0,1267,1309,5,214,0,0,1268,1309, - 5,215,0,0,1269,1309,5,216,0,0,1270,1309,5,217,0,0,1271,1272,5,218,0,0, - 1272,1309,3,154,77,0,1273,1274,5,219,0,0,1274,1309,3,154,77,0,1275,1309, - 5,220,0,0,1276,1277,5,221,0,0,1277,1309,3,154,77,0,1278,1279,5,222,0,0, - 1279,1309,3,156,78,0,1280,1281,5,222,0,0,1281,1282,3,156,78,0,1282,1283, - 5,28,0,0,1283,1284,3,6,3,0,1284,1309,1,0,0,0,1285,1309,5,194,0,0,1286, - 1309,5,195,0,0,1287,1288,5,90,0,0,1288,1309,5,184,0,0,1289,1290,5,90,0, - 0,1290,1309,5,185,0,0,1291,1292,5,90,0,0,1292,1309,5,186,0,0,1293,1294, - 5,90,0,0,1294,1309,5,187,0,0,1295,1296,5,62,0,0,1296,1309,5,220,0,0,1297, - 1309,5,223,0,0,1298,1299,5,224,0,0,1299,1309,5,213,0,0,1300,1309,5,225, - 0,0,1301,1302,5,207,0,0,1302,1309,5,183,0,0,1303,1309,5,226,0,0,1304,1309, - 5,228,0,0,1305,1306,5,34,0,0,1306,1309,5,227,0,0,1307,1309,3,2,1,0,1308, - 1216,1,0,0,0,1308,1217,1,0,0,0,1308,1228,1,0,0,0,1308,1235,1,0,0,0,1308, - 1241,1,0,0,0,1308,1248,1,0,0,0,1308,1249,1,0,0,0,1308,1250,1,0,0,0,1308, - 1251,1,0,0,0,1308,1252,1,0,0,0,1308,1253,1,0,0,0,1308,1254,1,0,0,0,1308, - 1255,1,0,0,0,1308,1256,1,0,0,0,1308,1257,1,0,0,0,1308,1258,1,0,0,0,1308, - 1259,1,0,0,0,1308,1260,1,0,0,0,1308,1261,1,0,0,0,1308,1262,1,0,0,0,1308, - 1263,1,0,0,0,1308,1264,1,0,0,0,1308,1265,1,0,0,0,1308,1266,1,0,0,0,1308, - 1267,1,0,0,0,1308,1268,1,0,0,0,1308,1269,1,0,0,0,1308,1270,1,0,0,0,1308, - 1271,1,0,0,0,1308,1273,1,0,0,0,1308,1275,1,0,0,0,1308,1276,1,0,0,0,1308, - 1278,1,0,0,0,1308,1280,1,0,0,0,1308,1285,1,0,0,0,1308,1286,1,0,0,0,1308, - 1287,1,0,0,0,1308,1289,1,0,0,0,1308,1291,1,0,0,0,1308,1293,1,0,0,0,1308, - 1295,1,0,0,0,1308,1297,1,0,0,0,1308,1298,1,0,0,0,1308,1300,1,0,0,0,1308, - 1301,1,0,0,0,1308,1303,1,0,0,0,1308,1304,1,0,0,0,1308,1305,1,0,0,0,1308, - 1307,1,0,0,0,1309,153,1,0,0,0,1310,1318,1,0,0,0,1311,1312,5,30,0,0,1312, - 1313,5,91,0,0,1313,1314,5,36,0,0,1314,1315,3,32,16,0,1315,1316,5,31,0, - 0,1316,1318,1,0,0,0,1317,1310,1,0,0,0,1317,1311,1,0,0,0,1318,155,1,0,0, - 0,1319,1328,1,0,0,0,1320,1324,3,158,79,0,1321,1323,7,7,0,0,1322,1321,1, - 0,0,0,1323,1326,1,0,0,0,1324,1322,1,0,0,0,1324,1325,1,0,0,0,1325,1328, - 1,0,0,0,1326,1324,1,0,0,0,1327,1319,1,0,0,0,1327,1320,1,0,0,0,1328,157, - 1,0,0,0,1329,1330,7,8,0,0,1330,159,1,0,0,0,1331,1335,3,164,82,0,1332,1334, - 3,162,81,0,1333,1332,1,0,0,0,1334,1337,1,0,0,0,1335,1333,1,0,0,0,1335, - 1336,1,0,0,0,1336,161,1,0,0,0,1337,1335,1,0,0,0,1338,1357,5,261,0,0,1339, - 1340,5,42,0,0,1340,1357,5,43,0,0,1341,1357,3,132,66,0,1342,1357,5,260, - 0,0,1343,1357,5,262,0,0,1344,1357,5,92,0,0,1345,1346,5,93,0,0,1346,1347, - 5,30,0,0,1347,1348,3,146,73,0,1348,1349,5,31,0,0,1349,1357,1,0,0,0,1350, - 1351,5,94,0,0,1351,1352,5,30,0,0,1352,1353,3,146,73,0,1353,1354,5,31,0, - 0,1354,1357,1,0,0,0,1355,1357,3,130,65,0,1356,1338,1,0,0,0,1356,1339,1, - 0,0,0,1356,1341,1,0,0,0,1356,1342,1,0,0,0,1356,1343,1,0,0,0,1356,1344, - 1,0,0,0,1356,1345,1,0,0,0,1356,1350,1,0,0,0,1356,1355,1,0,0,0,1357,163, - 1,0,0,0,1358,1359,5,39,0,0,1359,1389,3,138,69,0,1360,1389,5,197,0,0,1361, - 1362,5,199,0,0,1362,1363,5,39,0,0,1363,1389,3,138,69,0,1364,1365,5,200, - 0,0,1365,1389,3,138,69,0,1366,1367,5,226,0,0,1367,1368,3,192,96,0,1368, - 1369,3,160,80,0,1369,1370,5,262,0,0,1370,1371,3,134,67,0,1371,1389,1,0, - 0,0,1372,1373,5,253,0,0,1373,1389,3,32,16,0,1374,1375,5,252,0,0,1375,1389, - 3,32,16,0,1376,1377,5,253,0,0,1377,1389,3,2,1,0,1378,1379,5,252,0,0,1379, - 1389,3,2,1,0,1380,1389,5,254,0,0,1381,1389,5,201,0,0,1382,1389,3,170,85, - 0,1383,1389,3,172,86,0,1384,1389,3,166,83,0,1385,1389,3,2,1,0,1386,1387, - 5,177,0,0,1387,1389,3,160,80,0,1388,1358,1,0,0,0,1388,1360,1,0,0,0,1388, - 1361,1,0,0,0,1388,1364,1,0,0,0,1388,1366,1,0,0,0,1388,1372,1,0,0,0,1388, - 1374,1,0,0,0,1388,1376,1,0,0,0,1388,1378,1,0,0,0,1388,1380,1,0,0,0,1388, - 1381,1,0,0,0,1388,1382,1,0,0,0,1388,1383,1,0,0,0,1388,1384,1,0,0,0,1388, - 1385,1,0,0,0,1388,1386,1,0,0,0,1389,165,1,0,0,0,1390,1412,5,181,0,0,1391, - 1412,5,182,0,0,1392,1412,5,183,0,0,1393,1412,5,184,0,0,1394,1412,5,185, - 0,0,1395,1412,5,186,0,0,1396,1412,5,187,0,0,1397,1412,5,188,0,0,1398,1412, - 5,189,0,0,1399,1412,5,190,0,0,1400,1412,5,191,0,0,1401,1412,5,192,0,0, - 1402,1412,5,193,0,0,1403,1404,5,90,0,0,1404,1412,5,184,0,0,1405,1406,5, - 90,0,0,1406,1412,5,185,0,0,1407,1408,5,90,0,0,1408,1412,5,186,0,0,1409, - 1410,5,90,0,0,1410,1412,5,187,0,0,1411,1390,1,0,0,0,1411,1391,1,0,0,0, - 1411,1392,1,0,0,0,1411,1393,1,0,0,0,1411,1394,1,0,0,0,1411,1395,1,0,0, - 0,1411,1396,1,0,0,0,1411,1397,1,0,0,0,1411,1398,1,0,0,0,1411,1399,1,0, - 0,0,1411,1400,1,0,0,0,1411,1401,1,0,0,0,1411,1402,1,0,0,0,1411,1403,1, - 0,0,0,1411,1405,1,0,0,0,1411,1407,1,0,0,0,1411,1409,1,0,0,0,1412,167,1, - 0,0,0,1413,1424,1,0,0,0,1414,1424,5,177,0,0,1415,1424,3,32,16,0,1416,1417, - 3,32,16,0,1417,1418,5,177,0,0,1418,1419,3,32,16,0,1419,1424,1,0,0,0,1420, - 1421,3,32,16,0,1421,1422,5,177,0,0,1422,1424,1,0,0,0,1423,1413,1,0,0,0, - 1423,1414,1,0,0,0,1423,1415,1,0,0,0,1423,1416,1,0,0,0,1423,1420,1,0,0, - 0,1424,169,1,0,0,0,1425,1426,5,1,0,0,1426,1427,5,194,0,0,1427,171,1,0, - 0,0,1428,1432,5,1,0,0,1429,1430,5,90,0,0,1430,1433,5,194,0,0,1431,1433, - 5,195,0,0,1432,1429,1,0,0,0,1432,1431,1,0,0,0,1433,173,1,0,0,0,1434,1435, - 5,294,0,0,1435,1436,3,188,94,0,1436,1437,3,146,73,0,1437,1438,5,30,0,0, - 1438,1439,3,180,90,0,1439,1440,5,31,0,0,1440,1482,1,0,0,0,1441,1442,5, - 294,0,0,1442,1443,3,188,94,0,1443,1444,3,146,73,0,1444,1445,5,36,0,0,1445, - 1446,5,17,0,0,1446,1447,3,52,26,0,1447,1448,5,18,0,0,1448,1482,1,0,0,0, - 1449,1450,5,294,0,0,1450,1451,3,188,94,0,1451,1452,3,146,73,0,1452,1482, - 1,0,0,0,1453,1454,5,295,0,0,1454,1455,3,188,94,0,1455,1457,5,36,0,0,1456, - 1458,5,84,0,0,1457,1456,1,0,0,0,1457,1458,1,0,0,0,1458,1459,1,0,0,0,1459, - 1460,5,30,0,0,1460,1461,3,312,156,0,1461,1462,5,31,0,0,1462,1482,1,0,0, - 0,1463,1464,5,295,0,0,1464,1465,3,188,94,0,1465,1466,5,84,0,0,1466,1467, - 5,30,0,0,1467,1468,3,312,156,0,1468,1469,5,31,0,0,1469,1482,1,0,0,0,1470, - 1471,5,295,0,0,1471,1472,3,188,94,0,1472,1473,3,6,3,0,1473,1482,1,0,0, - 0,1474,1475,5,295,0,0,1475,1476,3,188,94,0,1476,1477,5,36,0,0,1477,1478, - 5,17,0,0,1478,1479,3,176,88,0,1479,1480,5,18,0,0,1480,1482,1,0,0,0,1481, - 1434,1,0,0,0,1481,1441,1,0,0,0,1481,1449,1,0,0,0,1481,1453,1,0,0,0,1481, - 1463,1,0,0,0,1481,1470,1,0,0,0,1481,1474,1,0,0,0,1482,175,1,0,0,0,1483, - 1494,1,0,0,0,1484,1485,3,178,89,0,1485,1486,5,28,0,0,1486,1488,1,0,0,0, - 1487,1484,1,0,0,0,1488,1491,1,0,0,0,1489,1487,1,0,0,0,1489,1490,1,0,0, - 0,1490,1492,1,0,0,0,1491,1489,1,0,0,0,1492,1494,3,178,89,0,1493,1483,1, - 0,0,0,1493,1489,1,0,0,0,1494,177,1,0,0,0,1495,1496,5,39,0,0,1496,1497, - 5,264,0,0,1497,1498,5,36,0,0,1498,1499,5,17,0,0,1499,1500,3,56,28,0,1500, - 1501,5,18,0,0,1501,1509,1,0,0,0,1502,1503,3,146,73,0,1503,1504,5,36,0, - 0,1504,1505,5,17,0,0,1505,1506,3,56,28,0,1506,1507,5,18,0,0,1507,1509, - 1,0,0,0,1508,1495,1,0,0,0,1508,1502,1,0,0,0,1509,179,1,0,0,0,1510,1511, - 3,182,91,0,1511,1512,5,28,0,0,1512,1514,1,0,0,0,1513,1510,1,0,0,0,1514, - 1517,1,0,0,0,1515,1513,1,0,0,0,1515,1516,1,0,0,0,1516,1518,1,0,0,0,1517, - 1515,1,0,0,0,1518,1519,3,182,91,0,1519,181,1,0,0,0,1520,1521,3,6,3,0,1521, - 1522,5,36,0,0,1522,1523,3,186,93,0,1523,183,1,0,0,0,1524,1525,7,9,0,0, - 1525,185,1,0,0,0,1526,1561,3,184,92,0,1527,1561,3,32,16,0,1528,1529,5, - 186,0,0,1529,1530,5,30,0,0,1530,1531,3,32,16,0,1531,1532,5,31,0,0,1532, - 1561,1,0,0,0,1533,1561,3,6,3,0,1534,1535,3,138,69,0,1535,1536,5,30,0,0, - 1536,1537,5,184,0,0,1537,1538,5,75,0,0,1538,1539,3,32,16,0,1539,1540,5, - 31,0,0,1540,1561,1,0,0,0,1541,1542,3,138,69,0,1542,1543,5,30,0,0,1543, - 1544,5,185,0,0,1544,1545,5,75,0,0,1545,1546,3,32,16,0,1546,1547,5,31,0, - 0,1547,1561,1,0,0,0,1548,1549,3,138,69,0,1549,1550,5,30,0,0,1550,1551, - 5,186,0,0,1551,1552,5,75,0,0,1552,1553,3,32,16,0,1553,1554,5,31,0,0,1554, - 1561,1,0,0,0,1555,1556,3,138,69,0,1556,1557,5,30,0,0,1557,1558,3,32,16, - 0,1558,1559,5,31,0,0,1559,1561,1,0,0,0,1560,1526,1,0,0,0,1560,1527,1,0, - 0,0,1560,1528,1,0,0,0,1560,1533,1,0,0,0,1560,1534,1,0,0,0,1560,1541,1, - 0,0,0,1560,1548,1,0,0,0,1560,1555,1,0,0,0,1561,187,1,0,0,0,1562,1563,7, - 10,0,0,1563,189,1,0,0,0,1564,1565,3,192,96,0,1565,1566,3,160,80,0,1566, - 1567,3,146,73,0,1567,1568,5,176,0,0,1568,1570,3,264,132,0,1569,1571,3, - 130,65,0,1570,1569,1,0,0,0,1570,1571,1,0,0,0,1571,1572,1,0,0,0,1572,1573, - 3,134,67,0,1573,1599,1,0,0,0,1574,1575,3,192,96,0,1575,1576,3,160,80,0, - 1576,1577,3,146,73,0,1577,1578,5,176,0,0,1578,1579,3,264,132,0,1579,1580, - 3,218,109,0,1580,1581,3,134,67,0,1581,1599,1,0,0,0,1582,1583,3,192,96, - 0,1583,1584,3,160,80,0,1584,1586,3,264,132,0,1585,1587,3,130,65,0,1586, - 1585,1,0,0,0,1586,1587,1,0,0,0,1587,1588,1,0,0,0,1588,1589,3,134,67,0, - 1589,1599,1,0,0,0,1590,1591,3,192,96,0,1591,1592,3,160,80,0,1592,1593, - 3,264,132,0,1593,1594,3,218,109,0,1594,1595,3,134,67,0,1595,1599,1,0,0, - 0,1596,1599,3,196,98,0,1597,1599,3,2,1,0,1598,1564,1,0,0,0,1598,1574,1, - 0,0,0,1598,1582,1,0,0,0,1598,1590,1,0,0,0,1598,1596,1,0,0,0,1598,1597, - 1,0,0,0,1599,191,1,0,0,0,1600,1601,5,243,0,0,1601,1611,3,192,96,0,1602, - 1603,5,244,0,0,1603,1611,3,192,96,0,1604,1611,3,194,97,0,1605,1606,5,112, - 0,0,1606,1607,5,30,0,0,1607,1608,3,32,16,0,1608,1609,5,31,0,0,1609,1611, - 1,0,0,0,1610,1600,1,0,0,0,1610,1602,1,0,0,0,1610,1604,1,0,0,0,1610,1605, - 1,0,0,0,1611,193,1,0,0,0,1612,1625,1,0,0,0,1613,1625,5,245,0,0,1614,1625, - 5,246,0,0,1615,1616,5,247,0,0,1616,1625,5,248,0,0,1617,1618,5,247,0,0, - 1618,1625,5,249,0,0,1619,1620,5,247,0,0,1620,1625,5,250,0,0,1621,1622, - 5,247,0,0,1622,1625,5,251,0,0,1623,1625,5,247,0,0,1624,1612,1,0,0,0,1624, - 1613,1,0,0,0,1624,1614,1,0,0,0,1624,1615,1,0,0,0,1624,1617,1,0,0,0,1624, - 1619,1,0,0,0,1624,1621,1,0,0,0,1624,1623,1,0,0,0,1625,195,1,0,0,0,1626, - 1627,5,113,0,0,1627,1628,5,30,0,0,1628,1629,3,32,16,0,1629,1630,5,31,0, - 0,1630,197,1,0,0,0,1631,1632,5,226,0,0,1632,1637,3,190,95,0,1633,1634, - 5,37,0,0,1634,1637,3,200,100,0,1635,1637,3,196,98,0,1636,1631,1,0,0,0, - 1636,1633,1,0,0,0,1636,1635,1,0,0,0,1637,199,1,0,0,0,1638,1639,3,160,80, - 0,1639,1640,3,146,73,0,1640,1641,5,176,0,0,1641,1642,3,2,1,0,1642,1648, - 1,0,0,0,1643,1644,3,160,80,0,1644,1645,3,2,1,0,1645,1648,1,0,0,0,1646, - 1648,3,2,1,0,1647,1638,1,0,0,0,1647,1643,1,0,0,0,1647,1646,1,0,0,0,1648, - 201,1,0,0,0,1649,1650,3,146,73,0,1650,1651,5,28,0,0,1651,1653,1,0,0,0, - 1652,1649,1,0,0,0,1653,1656,1,0,0,0,1654,1652,1,0,0,0,1654,1655,1,0,0, - 0,1655,1657,1,0,0,0,1656,1654,1,0,0,0,1657,1658,3,146,73,0,1658,203,1, - 0,0,0,1659,1665,1,0,0,0,1660,1661,5,86,0,0,1661,1662,3,212,106,0,1662, - 1663,5,87,0,0,1663,1665,1,0,0,0,1664,1659,1,0,0,0,1664,1660,1,0,0,0,1665, - 205,1,0,0,0,1666,1678,5,266,0,0,1667,1678,5,114,0,0,1668,1678,5,39,0,0, - 1669,1678,5,200,0,0,1670,1678,5,115,0,0,1671,1678,5,116,0,0,1672,1673, - 5,70,0,0,1673,1674,5,30,0,0,1674,1675,3,32,16,0,1675,1676,5,31,0,0,1676, - 1678,1,0,0,0,1677,1666,1,0,0,0,1677,1667,1,0,0,0,1677,1668,1,0,0,0,1677, - 1669,1,0,0,0,1677,1670,1,0,0,0,1677,1671,1,0,0,0,1677,1672,1,0,0,0,1678, - 207,1,0,0,0,1679,1681,3,206,103,0,1680,1679,1,0,0,0,1681,1684,1,0,0,0, - 1682,1680,1,0,0,0,1682,1683,1,0,0,0,1683,209,1,0,0,0,1684,1682,1,0,0,0, - 1685,1687,3,208,104,0,1686,1688,3,214,107,0,1687,1686,1,0,0,0,1687,1688, - 1,0,0,0,1688,1689,1,0,0,0,1689,1690,3,2,1,0,1690,211,1,0,0,0,1691,1692, - 3,210,105,0,1692,1693,5,28,0,0,1693,1695,1,0,0,0,1694,1691,1,0,0,0,1695, - 1698,1,0,0,0,1696,1694,1,0,0,0,1696,1697,1,0,0,0,1697,1699,1,0,0,0,1698, - 1696,1,0,0,0,1699,1700,3,210,105,0,1700,213,1,0,0,0,1701,1702,5,30,0,0, - 1702,1703,3,202,101,0,1703,1704,5,31,0,0,1704,215,1,0,0,0,1705,1708,1, - 0,0,0,1706,1708,3,218,109,0,1707,1705,1,0,0,0,1707,1706,1,0,0,0,1708,217, - 1,0,0,0,1709,1710,5,86,0,0,1710,1711,5,42,0,0,1711,1712,3,32,16,0,1712, - 1713,5,43,0,0,1713,1714,5,87,0,0,1714,219,1,0,0,0,1715,1716,3,256,128, - 0,1716,1717,5,17,0,0,1717,1718,3,268,134,0,1718,1719,5,18,0,0,1719,1832, - 1,0,0,0,1720,1721,3,74,37,0,1721,1722,5,17,0,0,1722,1723,3,82,41,0,1723, - 1724,5,18,0,0,1724,1832,1,0,0,0,1725,1726,3,232,116,0,1726,1727,5,17,0, - 0,1727,1728,3,236,118,0,1728,1729,5,18,0,0,1729,1832,1,0,0,0,1730,1731, - 3,240,120,0,1731,1732,5,17,0,0,1732,1733,3,244,122,0,1733,1734,5,18,0, - 0,1734,1832,1,0,0,0,1735,1832,3,222,111,0,1736,1832,3,296,148,0,1737,1832, - 3,174,87,0,1738,1832,3,88,44,0,1739,1832,3,342,171,0,1740,1741,5,117,0, - 0,1741,1832,3,32,16,0,1742,1743,5,118,0,0,1743,1832,3,32,16,0,1744,1745, - 3,354,177,0,1745,1746,5,17,0,0,1746,1747,3,358,179,0,1747,1748,5,18,0, - 0,1748,1832,1,0,0,0,1749,1750,5,302,0,0,1750,1751,3,146,73,0,1751,1752, - 5,176,0,0,1752,1753,3,264,132,0,1753,1754,5,119,0,0,1754,1755,3,192,96, - 0,1755,1756,3,160,80,0,1756,1757,3,146,73,0,1757,1758,5,176,0,0,1758,1759, - 3,264,132,0,1759,1760,3,134,67,0,1760,1832,1,0,0,0,1761,1762,5,302,0,0, - 1762,1763,5,226,0,0,1763,1764,3,192,96,0,1764,1765,3,160,80,0,1765,1766, - 3,146,73,0,1766,1767,5,176,0,0,1767,1768,3,264,132,0,1768,1769,3,216,108, - 0,1769,1770,3,134,67,0,1770,1771,5,119,0,0,1771,1772,5,226,0,0,1772,1773, - 3,192,96,0,1773,1774,3,160,80,0,1774,1775,3,146,73,0,1775,1776,5,176,0, - 0,1776,1777,3,264,132,0,1777,1778,3,216,108,0,1778,1779,3,134,67,0,1779, - 1832,1,0,0,0,1780,1832,3,26,13,0,1781,1832,3,40,20,0,1782,1783,5,255,0, - 0,1783,1784,5,196,0,0,1784,1785,5,42,0,0,1785,1786,3,32,16,0,1786,1790, - 5,43,0,0,1787,1789,3,342,171,0,1788,1787,1,0,0,0,1789,1792,1,0,0,0,1790, - 1788,1,0,0,0,1790,1791,1,0,0,0,1791,1832,1,0,0,0,1792,1790,1,0,0,0,1793, - 1794,5,255,0,0,1794,1795,5,196,0,0,1795,1799,3,2,1,0,1796,1798,3,342,171, - 0,1797,1796,1,0,0,0,1798,1801,1,0,0,0,1799,1797,1,0,0,0,1799,1800,1,0, - 0,0,1800,1832,1,0,0,0,1801,1799,1,0,0,0,1802,1803,5,255,0,0,1803,1804, - 5,256,0,0,1804,1805,5,42,0,0,1805,1806,3,32,16,0,1806,1807,5,43,0,0,1807, - 1808,5,28,0,0,1808,1812,3,146,73,0,1809,1811,3,342,171,0,1810,1809,1,0, - 0,0,1811,1814,1,0,0,0,1812,1810,1,0,0,0,1812,1813,1,0,0,0,1813,1832,1, - 0,0,0,1814,1812,1,0,0,0,1815,1816,5,255,0,0,1816,1817,5,256,0,0,1817,1818, - 3,2,1,0,1818,1819,5,28,0,0,1819,1823,3,146,73,0,1820,1822,3,342,171,0, - 1821,1820,1,0,0,0,1822,1825,1,0,0,0,1823,1821,1,0,0,0,1823,1824,1,0,0, - 0,1824,1832,1,0,0,0,1825,1823,1,0,0,0,1826,1827,5,120,0,0,1827,1828,5, - 196,0,0,1828,1829,3,146,73,0,1829,1830,3,44,22,0,1830,1832,1,0,0,0,1831, - 1715,1,0,0,0,1831,1720,1,0,0,0,1831,1725,1,0,0,0,1831,1730,1,0,0,0,1831, - 1735,1,0,0,0,1831,1736,1,0,0,0,1831,1737,1,0,0,0,1831,1738,1,0,0,0,1831, - 1739,1,0,0,0,1831,1740,1,0,0,0,1831,1742,1,0,0,0,1831,1744,1,0,0,0,1831, - 1749,1,0,0,0,1831,1761,1,0,0,0,1831,1780,1,0,0,0,1831,1781,1,0,0,0,1831, - 1782,1,0,0,0,1831,1793,1,0,0,0,1831,1802,1,0,0,0,1831,1815,1,0,0,0,1831, - 1826,1,0,0,0,1832,221,1,0,0,0,1833,1834,5,121,0,0,1834,1843,3,230,115, - 0,1835,1842,3,224,112,0,1836,1837,5,122,0,0,1837,1838,5,30,0,0,1838,1839, - 3,250,125,0,1839,1840,5,31,0,0,1840,1842,1,0,0,0,1841,1835,1,0,0,0,1841, - 1836,1,0,0,0,1842,1845,1,0,0,0,1843,1841,1,0,0,0,1843,1844,1,0,0,0,1844, - 1846,1,0,0,0,1845,1843,1,0,0,0,1846,1847,3,160,80,0,1847,1848,3,2,1,0, - 1848,1849,3,226,113,0,1849,1850,3,228,114,0,1850,223,1,0,0,0,1851,1871, - 5,123,0,0,1852,1871,5,51,0,0,1853,1871,5,52,0,0,1854,1871,5,63,0,0,1855, - 1871,5,124,0,0,1856,1871,5,69,0,0,1857,1871,5,68,0,0,1858,1871,5,64,0, - 0,1859,1871,5,65,0,0,1860,1871,5,66,0,0,1861,1871,5,125,0,0,1862,1871, - 5,126,0,0,1863,1871,5,127,0,0,1864,1871,5,16,0,0,1865,1866,5,70,0,0,1866, - 1867,5,30,0,0,1867,1868,3,32,16,0,1868,1869,5,31,0,0,1869,1871,1,0,0,0, - 1870,1851,1,0,0,0,1870,1852,1,0,0,0,1870,1853,1,0,0,0,1870,1854,1,0,0, - 0,1870,1855,1,0,0,0,1870,1856,1,0,0,0,1870,1857,1,0,0,0,1870,1858,1,0, - 0,0,1870,1859,1,0,0,0,1870,1860,1,0,0,0,1870,1861,1,0,0,0,1870,1862,1, - 0,0,0,1870,1863,1,0,0,0,1870,1864,1,0,0,0,1870,1865,1,0,0,0,1871,225,1, - 0,0,0,1872,1878,1,0,0,0,1873,1874,5,44,0,0,1874,1878,3,0,0,0,1875,1876, - 5,44,0,0,1876,1878,3,32,16,0,1877,1872,1,0,0,0,1877,1873,1,0,0,0,1877, - 1875,1,0,0,0,1878,227,1,0,0,0,1879,1883,1,0,0,0,1880,1881,5,36,0,0,1881, - 1883,3,316,158,0,1882,1879,1,0,0,0,1882,1880,1,0,0,0,1883,229,1,0,0,0, - 1884,1890,1,0,0,0,1885,1886,5,42,0,0,1886,1887,3,32,16,0,1887,1888,5,43, - 0,0,1888,1890,1,0,0,0,1889,1884,1,0,0,0,1889,1885,1,0,0,0,1890,231,1,0, - 0,0,1891,1895,5,128,0,0,1892,1894,3,234,117,0,1893,1892,1,0,0,0,1894,1897, - 1,0,0,0,1895,1893,1,0,0,0,1895,1896,1,0,0,0,1896,1898,1,0,0,0,1897,1895, - 1,0,0,0,1898,1899,3,146,73,0,1899,1900,3,2,1,0,1900,1910,1,0,0,0,1901, - 1905,5,128,0,0,1902,1904,3,234,117,0,1903,1902,1,0,0,0,1904,1907,1,0,0, - 0,1905,1903,1,0,0,0,1905,1906,1,0,0,0,1906,1908,1,0,0,0,1907,1905,1,0, - 0,0,1908,1910,3,2,1,0,1909,1891,1,0,0,0,1909,1901,1,0,0,0,1910,233,1,0, - 0,0,1911,1912,7,11,0,0,1912,235,1,0,0,0,1913,1915,3,238,119,0,1914,1913, - 1,0,0,0,1915,1918,1,0,0,0,1916,1914,1,0,0,0,1916,1917,1,0,0,0,1917,237, - 1,0,0,0,1918,1916,1,0,0,0,1919,1920,5,129,0,0,1920,1932,3,190,95,0,1921, - 1922,5,130,0,0,1922,1932,3,190,95,0,1923,1924,5,131,0,0,1924,1932,3,190, - 95,0,1925,1926,5,132,0,0,1926,1932,3,190,95,0,1927,1932,3,88,44,0,1928, - 1932,3,342,171,0,1929,1932,3,26,13,0,1930,1932,3,40,20,0,1931,1919,1,0, - 0,0,1931,1921,1,0,0,0,1931,1923,1,0,0,0,1931,1925,1,0,0,0,1931,1927,1, - 0,0,0,1931,1928,1,0,0,0,1931,1929,1,0,0,0,1931,1930,1,0,0,0,1932,239,1, - 0,0,0,1933,1937,5,133,0,0,1934,1936,3,242,121,0,1935,1934,1,0,0,0,1936, - 1939,1,0,0,0,1937,1935,1,0,0,0,1937,1938,1,0,0,0,1938,1940,1,0,0,0,1939, - 1937,1,0,0,0,1940,1941,3,192,96,0,1941,1942,3,160,80,0,1942,1943,3,2,1, - 0,1943,1944,3,134,67,0,1944,1945,3,228,114,0,1945,241,1,0,0,0,1946,1947, - 7,11,0,0,1947,243,1,0,0,0,1948,1950,3,246,123,0,1949,1948,1,0,0,0,1950, - 1953,1,0,0,0,1951,1949,1,0,0,0,1951,1952,1,0,0,0,1952,245,1,0,0,0,1953, - 1951,1,0,0,0,1954,1955,5,134,0,0,1955,1965,3,190,95,0,1956,1957,5,135, - 0,0,1957,1965,3,190,95,0,1958,1959,5,132,0,0,1959,1965,3,190,95,0,1960, - 1965,3,342,171,0,1961,1965,3,88,44,0,1962,1965,3,26,13,0,1963,1965,3,40, - 20,0,1964,1954,1,0,0,0,1964,1956,1,0,0,0,1964,1958,1,0,0,0,1964,1960,1, - 0,0,0,1964,1961,1,0,0,0,1964,1962,1,0,0,0,1964,1963,1,0,0,0,1965,247,1, - 0,0,0,1966,1973,1,0,0,0,1967,1968,5,122,0,0,1968,1969,5,30,0,0,1969,1970, - 3,250,125,0,1970,1971,5,31,0,0,1971,1973,1,0,0,0,1972,1966,1,0,0,0,1972, - 1967,1,0,0,0,1973,249,1,0,0,0,1974,1984,3,148,74,0,1975,1977,5,17,0,0, - 1976,1978,3,314,157,0,1977,1976,1,0,0,0,1978,1979,1,0,0,0,1979,1977,1, - 0,0,0,1979,1980,1,0,0,0,1980,1981,1,0,0,0,1981,1982,5,18,0,0,1982,1984, - 1,0,0,0,1983,1974,1,0,0,0,1983,1975,1,0,0,0,1984,251,1,0,0,0,1985,1987, - 3,254,127,0,1986,1985,1,0,0,0,1987,1990,1,0,0,0,1988,1986,1,0,0,0,1988, - 1989,1,0,0,0,1989,253,1,0,0,0,1990,1988,1,0,0,0,1991,1992,5,42,0,0,1992, - 1993,5,136,0,0,1993,2005,5,43,0,0,1994,1995,5,42,0,0,1995,1996,5,137,0, - 0,1996,2005,5,43,0,0,1997,1998,5,42,0,0,1998,1999,5,138,0,0,1999,2005, - 5,43,0,0,2000,2001,5,42,0,0,2001,2002,3,32,16,0,2002,2003,5,43,0,0,2003, - 2005,1,0,0,0,2004,1991,1,0,0,0,2004,1994,1,0,0,0,2004,1997,1,0,0,0,2004, - 2000,1,0,0,0,2005,255,1,0,0,0,2006,2011,5,139,0,0,2007,2010,3,258,129, - 0,2008,2010,3,260,130,0,2009,2007,1,0,0,0,2009,2008,1,0,0,0,2010,2013, - 1,0,0,0,2011,2009,1,0,0,0,2011,2012,1,0,0,0,2012,2014,1,0,0,0,2013,2011, - 1,0,0,0,2014,2015,3,192,96,0,2015,2016,3,252,126,0,2016,2017,3,160,80, - 0,2017,2018,3,248,124,0,2018,2019,3,264,132,0,2019,2020,3,204,102,0,2020, - 2024,3,134,67,0,2021,2023,3,266,133,0,2022,2021,1,0,0,0,2023,2026,1,0, - 0,0,2024,2022,1,0,0,0,2024,2025,1,0,0,0,2025,257,1,0,0,0,2026,2024,1,0, - 0,0,2027,2051,5,123,0,0,2028,2051,5,51,0,0,2029,2051,5,52,0,0,2030,2051, - 5,63,0,0,2031,2051,5,140,0,0,2032,2051,5,68,0,0,2033,2051,5,141,0,0,2034, - 2051,5,142,0,0,2035,2051,5,54,0,0,2036,2051,5,64,0,0,2037,2051,5,65,0, - 0,2038,2051,5,66,0,0,2039,2051,5,125,0,0,2040,2051,5,143,0,0,2041,2051, - 5,144,0,0,2042,2051,5,69,0,0,2043,2051,5,145,0,0,2044,2051,5,146,0,0,2045, - 2046,5,70,0,0,2046,2047,5,30,0,0,2047,2048,3,32,16,0,2048,2049,5,31,0, - 0,2049,2051,1,0,0,0,2050,2027,1,0,0,0,2050,2028,1,0,0,0,2050,2029,1,0, - 0,0,2050,2030,1,0,0,0,2050,2031,1,0,0,0,2050,2032,1,0,0,0,2050,2033,1, - 0,0,0,2050,2034,1,0,0,0,2050,2035,1,0,0,0,2050,2036,1,0,0,0,2050,2037, - 1,0,0,0,2050,2038,1,0,0,0,2050,2039,1,0,0,0,2050,2040,1,0,0,0,2050,2041, - 1,0,0,0,2050,2042,1,0,0,0,2050,2043,1,0,0,0,2050,2044,1,0,0,0,2050,2045, - 1,0,0,0,2051,259,1,0,0,0,2052,2053,5,147,0,0,2053,2059,5,30,0,0,2054,2057, - 3,6,3,0,2055,2056,5,34,0,0,2056,2058,3,6,3,0,2057,2055,1,0,0,0,2057,2058, - 1,0,0,0,2058,2060,1,0,0,0,2059,2054,1,0,0,0,2059,2060,1,0,0,0,2060,2064, - 1,0,0,0,2061,2063,3,262,131,0,2062,2061,1,0,0,0,2063,2066,1,0,0,0,2064, - 2062,1,0,0,0,2064,2065,1,0,0,0,2065,2067,1,0,0,0,2066,2064,1,0,0,0,2067, - 2071,5,31,0,0,2068,2069,5,147,0,0,2069,2071,5,85,0,0,2070,2052,1,0,0,0, - 2070,2068,1,0,0,0,2071,261,1,0,0,0,2072,2100,5,148,0,0,2073,2100,5,224, - 0,0,2074,2100,5,57,0,0,2075,2100,5,58,0,0,2076,2100,5,149,0,0,2077,2100, - 5,150,0,0,2078,2100,5,248,0,0,2079,2100,5,249,0,0,2080,2100,5,250,0,0, - 2081,2100,5,251,0,0,2082,2083,5,151,0,0,2083,2084,5,75,0,0,2084,2100,5, - 152,0,0,2085,2086,5,151,0,0,2086,2087,5,75,0,0,2087,2100,5,153,0,0,2088, - 2089,5,154,0,0,2089,2090,5,75,0,0,2090,2100,5,152,0,0,2091,2092,5,154, - 0,0,2092,2093,5,75,0,0,2093,2100,5,153,0,0,2094,2095,5,70,0,0,2095,2096, - 5,30,0,0,2096,2097,3,32,16,0,2097,2098,5,31,0,0,2098,2100,1,0,0,0,2099, - 2072,1,0,0,0,2099,2073,1,0,0,0,2099,2074,1,0,0,0,2099,2075,1,0,0,0,2099, - 2076,1,0,0,0,2099,2077,1,0,0,0,2099,2078,1,0,0,0,2099,2079,1,0,0,0,2099, - 2080,1,0,0,0,2099,2081,1,0,0,0,2099,2082,1,0,0,0,2099,2085,1,0,0,0,2099, - 2088,1,0,0,0,2099,2091,1,0,0,0,2099,2094,1,0,0,0,2100,263,1,0,0,0,2101, - 2105,5,116,0,0,2102,2105,5,155,0,0,2103,2105,3,2,1,0,2104,2101,1,0,0,0, - 2104,2102,1,0,0,0,2104,2103,1,0,0,0,2105,265,1,0,0,0,2106,2128,5,1,0,0, - 2107,2128,5,2,0,0,2108,2128,5,156,0,0,2109,2128,5,3,0,0,2110,2128,5,4, - 0,0,2111,2128,5,247,0,0,2112,2128,5,5,0,0,2113,2128,5,6,0,0,2114,2128, - 5,7,0,0,2115,2128,5,8,0,0,2116,2128,5,9,0,0,2117,2128,5,10,0,0,2118,2128, - 5,11,0,0,2119,2128,5,12,0,0,2120,2128,5,13,0,0,2121,2128,5,14,0,0,2122, - 2123,5,70,0,0,2123,2124,5,30,0,0,2124,2125,3,32,16,0,2125,2126,5,31,0, - 0,2126,2128,1,0,0,0,2127,2106,1,0,0,0,2127,2107,1,0,0,0,2127,2108,1,0, - 0,0,2127,2109,1,0,0,0,2127,2110,1,0,0,0,2127,2111,1,0,0,0,2127,2112,1, - 0,0,0,2127,2113,1,0,0,0,2127,2114,1,0,0,0,2127,2115,1,0,0,0,2127,2116, - 1,0,0,0,2127,2117,1,0,0,0,2127,2118,1,0,0,0,2127,2119,1,0,0,0,2127,2120, - 1,0,0,0,2127,2121,1,0,0,0,2127,2122,1,0,0,0,2128,267,1,0,0,0,2129,2131, - 3,270,135,0,2130,2129,1,0,0,0,2131,2134,1,0,0,0,2132,2130,1,0,0,0,2132, - 2133,1,0,0,0,2133,269,1,0,0,0,2134,2132,1,0,0,0,2135,2244,3,126,63,0,2136, - 2137,5,296,0,0,2137,2244,3,32,16,0,2138,2244,3,278,139,0,2139,2140,5,297, - 0,0,2140,2244,3,32,16,0,2141,2142,5,300,0,0,2142,2244,3,134,67,0,2143, - 2144,5,300,0,0,2144,2145,5,157,0,0,2145,2244,3,134,67,0,2146,2244,5,298, - 0,0,2147,2244,5,299,0,0,2148,2244,3,296,148,0,2149,2244,3,272,136,0,2150, - 2244,3,174,87,0,2151,2244,3,88,44,0,2152,2244,3,26,13,0,2153,2244,3,274, - 137,0,2154,2244,3,40,20,0,2155,2156,5,301,0,0,2156,2157,5,42,0,0,2157, - 2158,3,32,16,0,2158,2159,5,43,0,0,2159,2244,1,0,0,0,2160,2161,5,301,0, - 0,2161,2162,5,42,0,0,2162,2163,3,32,16,0,2163,2164,5,43,0,0,2164,2165, - 5,34,0,0,2165,2166,3,0,0,0,2166,2244,1,0,0,0,2167,2168,5,303,0,0,2168, - 2169,3,32,16,0,2169,2170,5,75,0,0,2170,2171,3,32,16,0,2171,2244,1,0,0, - 0,2172,2173,5,302,0,0,2173,2174,3,146,73,0,2174,2175,5,176,0,0,2175,2176, - 3,264,132,0,2176,2244,1,0,0,0,2177,2178,5,302,0,0,2178,2179,5,226,0,0, - 2179,2180,3,192,96,0,2180,2181,3,160,80,0,2181,2182,3,146,73,0,2182,2183, - 5,176,0,0,2183,2184,3,264,132,0,2184,2185,3,216,108,0,2185,2186,3,134, - 67,0,2186,2244,1,0,0,0,2187,2244,3,276,138,0,2188,2189,5,255,0,0,2189, - 2190,5,196,0,0,2190,2191,5,42,0,0,2191,2192,3,32,16,0,2192,2196,5,43,0, - 0,2193,2195,3,342,171,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,2244,1,0,0,0,2198,2196,1,0,0,0,2199,2200, - 5,255,0,0,2200,2201,5,196,0,0,2201,2205,3,2,1,0,2202,2204,3,342,171,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,2244,1,0,0,0,2207,2205,1,0,0,0,2208,2209,5,255,0,0,2209,2210,5, - 256,0,0,2210,2211,5,42,0,0,2211,2212,3,32,16,0,2212,2213,5,43,0,0,2213, - 2214,5,28,0,0,2214,2218,3,146,73,0,2215,2217,3,342,171,0,2216,2215,1,0, - 0,0,2217,2220,1,0,0,0,2218,2216,1,0,0,0,2218,2219,1,0,0,0,2219,2244,1, - 0,0,0,2220,2218,1,0,0,0,2221,2222,5,255,0,0,2222,2223,5,256,0,0,2223,2224, - 3,2,1,0,2224,2225,5,28,0,0,2225,2229,3,146,73,0,2226,2228,3,342,171,0, - 2227,2226,1,0,0,0,2228,2231,1,0,0,0,2229,2227,1,0,0,0,2229,2230,1,0,0, - 0,2230,2244,1,0,0,0,2231,2229,1,0,0,0,2232,2233,5,255,0,0,2233,2234,5, - 42,0,0,2234,2235,3,32,16,0,2235,2236,5,43,0,0,2236,2240,3,228,114,0,2237, - 2239,3,342,171,0,2238,2237,1,0,0,0,2239,2242,1,0,0,0,2240,2238,1,0,0,0, - 2240,2241,1,0,0,0,2241,2244,1,0,0,0,2242,2240,1,0,0,0,2243,2135,1,0,0, - 0,2243,2136,1,0,0,0,2243,2138,1,0,0,0,2243,2139,1,0,0,0,2243,2141,1,0, - 0,0,2243,2143,1,0,0,0,2243,2146,1,0,0,0,2243,2147,1,0,0,0,2243,2148,1, - 0,0,0,2243,2149,1,0,0,0,2243,2150,1,0,0,0,2243,2151,1,0,0,0,2243,2152, - 1,0,0,0,2243,2153,1,0,0,0,2243,2154,1,0,0,0,2243,2155,1,0,0,0,2243,2160, - 1,0,0,0,2243,2167,1,0,0,0,2243,2172,1,0,0,0,2243,2177,1,0,0,0,2243,2187, - 1,0,0,0,2243,2188,1,0,0,0,2243,2199,1,0,0,0,2243,2208,1,0,0,0,2243,2221, - 1,0,0,0,2243,2232,1,0,0,0,2244,271,1,0,0,0,2245,2246,3,0,0,0,2246,2247, - 5,75,0,0,2247,273,1,0,0,0,2248,2251,3,44,22,0,2249,2251,3,46,23,0,2250, - 2248,1,0,0,0,2250,2249,1,0,0,0,2251,275,1,0,0,0,2252,2253,5,17,0,0,2253, - 2254,3,268,134,0,2254,2255,5,18,0,0,2255,277,1,0,0,0,2256,2257,3,282,141, - 0,2257,2258,3,280,140,0,2258,279,1,0,0,0,2259,2261,3,284,142,0,2260,2259, - 1,0,0,0,2261,2262,1,0,0,0,2262,2260,1,0,0,0,2262,2263,1,0,0,0,2263,281, - 1,0,0,0,2264,2265,5,158,0,0,2265,2277,3,276,138,0,2266,2267,5,158,0,0, - 2267,2268,3,0,0,0,2268,2269,5,159,0,0,2269,2270,3,0,0,0,2270,2277,1,0, - 0,0,2271,2272,5,158,0,0,2272,2273,3,32,16,0,2273,2274,5,159,0,0,2274,2275, - 3,32,16,0,2275,2277,1,0,0,0,2276,2264,1,0,0,0,2276,2266,1,0,0,0,2276,2271, - 1,0,0,0,2277,283,1,0,0,0,2278,2279,3,288,144,0,2279,2280,3,294,147,0,2280, - 2291,1,0,0,0,2281,2282,3,286,143,0,2282,2283,3,294,147,0,2283,2291,1,0, - 0,0,2284,2285,3,290,145,0,2285,2286,3,294,147,0,2286,2291,1,0,0,0,2287, - 2288,3,292,146,0,2288,2289,3,294,147,0,2289,2291,1,0,0,0,2290,2278,1,0, - 0,0,2290,2281,1,0,0,0,2290,2284,1,0,0,0,2290,2287,1,0,0,0,2291,285,1,0, - 0,0,2292,2293,5,160,0,0,2293,2299,3,276,138,0,2294,2295,5,160,0,0,2295, - 2299,3,0,0,0,2296,2297,5,160,0,0,2297,2299,3,32,16,0,2298,2292,1,0,0,0, - 2298,2294,1,0,0,0,2298,2296,1,0,0,0,2299,287,1,0,0,0,2300,2301,5,161,0, - 0,2301,2302,3,146,73,0,2302,289,1,0,0,0,2303,2304,5,162,0,0,2304,291,1, - 0,0,0,2305,2306,5,163,0,0,2306,293,1,0,0,0,2307,2319,3,276,138,0,2308, - 2309,5,164,0,0,2309,2310,3,0,0,0,2310,2311,5,159,0,0,2311,2312,3,0,0,0, - 2312,2319,1,0,0,0,2313,2314,5,164,0,0,2314,2315,3,32,16,0,2315,2316,5, - 159,0,0,2316,2317,3,32,16,0,2317,2319,1,0,0,0,2318,2307,1,0,0,0,2318,2308, - 1,0,0,0,2318,2313,1,0,0,0,2319,295,1,0,0,0,2320,2321,3,298,149,0,2321, - 2322,3,302,151,0,2322,297,1,0,0,0,2323,2324,5,165,0,0,2324,2325,3,300, - 150,0,2325,2326,3,0,0,0,2326,2327,5,36,0,0,2327,2331,1,0,0,0,2328,2329, - 5,165,0,0,2329,2331,3,300,150,0,2330,2323,1,0,0,0,2330,2328,1,0,0,0,2331, - 299,1,0,0,0,2332,2336,1,0,0,0,2333,2336,5,166,0,0,2334,2336,5,2,0,0,2335, - 2332,1,0,0,0,2335,2333,1,0,0,0,2335,2334,1,0,0,0,2336,301,1,0,0,0,2337, - 2338,5,17,0,0,2338,2339,3,304,152,0,2339,2340,5,18,0,0,2340,2347,1,0,0, - 0,2341,2343,3,308,154,0,2342,2341,1,0,0,0,2343,2344,1,0,0,0,2344,2342, - 1,0,0,0,2344,2345,1,0,0,0,2345,2347,1,0,0,0,2346,2337,1,0,0,0,2346,2342, - 1,0,0,0,2347,303,1,0,0,0,2348,2349,3,308,154,0,2349,2350,5,28,0,0,2350, - 2352,1,0,0,0,2351,2348,1,0,0,0,2352,2355,1,0,0,0,2353,2351,1,0,0,0,2353, - 2354,1,0,0,0,2354,2356,1,0,0,0,2355,2353,1,0,0,0,2356,2357,3,308,154,0, - 2357,305,1,0,0,0,2358,2364,1,0,0,0,2359,2360,5,42,0,0,2360,2361,3,32,16, - 0,2361,2362,5,43,0,0,2362,2364,1,0,0,0,2363,2358,1,0,0,0,2363,2359,1,0, - 0,0,2364,307,1,0,0,0,2365,2366,5,181,0,0,2366,2367,5,262,0,0,2367,2368, - 5,30,0,0,2368,2369,3,6,3,0,2369,2370,5,31,0,0,2370,2432,1,0,0,0,2371,2372, - 5,260,0,0,2372,2373,5,30,0,0,2373,2374,3,0,0,0,2374,2375,5,31,0,0,2375, - 2432,1,0,0,0,2376,2377,5,260,0,0,2377,2432,3,0,0,0,2378,2379,5,84,0,0, - 2379,2380,5,30,0,0,2380,2381,3,312,156,0,2381,2382,5,31,0,0,2382,2432, - 1,0,0,0,2383,2384,5,188,0,0,2384,2385,5,30,0,0,2385,2386,3,36,18,0,2386, - 2387,5,31,0,0,2387,2388,3,306,153,0,2388,2432,1,0,0,0,2389,2390,5,189, - 0,0,2390,2391,5,30,0,0,2391,2392,3,36,18,0,2392,2393,5,31,0,0,2393,2394, - 3,306,153,0,2394,2432,1,0,0,0,2395,2396,5,187,0,0,2396,2397,5,30,0,0,2397, - 2398,3,34,17,0,2398,2399,5,31,0,0,2399,2400,3,306,153,0,2400,2432,1,0, - 0,0,2401,2402,5,186,0,0,2402,2403,5,30,0,0,2403,2404,3,32,16,0,2404,2405, - 5,31,0,0,2405,2406,3,306,153,0,2406,2432,1,0,0,0,2407,2408,5,185,0,0,2408, - 2409,5,30,0,0,2409,2410,3,32,16,0,2410,2411,5,31,0,0,2411,2412,3,306,153, - 0,2412,2432,1,0,0,0,2413,2414,5,184,0,0,2414,2415,5,30,0,0,2415,2416,3, - 32,16,0,2416,2417,5,31,0,0,2417,2418,3,306,153,0,2418,2432,1,0,0,0,2419, - 2420,5,188,0,0,2420,2432,3,306,153,0,2421,2422,5,189,0,0,2422,2432,3,306, - 153,0,2423,2424,5,187,0,0,2424,2432,3,306,153,0,2425,2426,5,186,0,0,2426, - 2432,3,306,153,0,2427,2428,5,185,0,0,2428,2432,3,306,153,0,2429,2430,5, - 184,0,0,2430,2432,3,306,153,0,2431,2365,1,0,0,0,2431,2371,1,0,0,0,2431, - 2376,1,0,0,0,2431,2378,1,0,0,0,2431,2383,1,0,0,0,2431,2389,1,0,0,0,2431, - 2395,1,0,0,0,2431,2401,1,0,0,0,2431,2407,1,0,0,0,2431,2413,1,0,0,0,2431, - 2419,1,0,0,0,2431,2421,1,0,0,0,2431,2423,1,0,0,0,2431,2425,1,0,0,0,2431, - 2427,1,0,0,0,2431,2429,1,0,0,0,2432,309,1,0,0,0,2433,2434,5,188,0,0,2434, - 2435,5,30,0,0,2435,2436,3,36,18,0,2436,2437,5,31,0,0,2437,2509,1,0,0,0, - 2438,2439,5,189,0,0,2439,2440,5,30,0,0,2440,2441,3,36,18,0,2441,2442,5, - 31,0,0,2442,2509,1,0,0,0,2443,2444,5,188,0,0,2444,2445,5,30,0,0,2445,2446, - 3,32,16,0,2446,2447,5,31,0,0,2447,2509,1,0,0,0,2448,2449,5,189,0,0,2449, - 2450,5,30,0,0,2450,2451,3,34,17,0,2451,2452,5,31,0,0,2452,2509,1,0,0,0, - 2453,2454,5,187,0,0,2454,2455,5,30,0,0,2455,2456,3,34,17,0,2456,2457,5, - 31,0,0,2457,2509,1,0,0,0,2458,2459,5,186,0,0,2459,2460,5,30,0,0,2460,2461, - 3,32,16,0,2461,2462,5,31,0,0,2462,2509,1,0,0,0,2463,2464,5,185,0,0,2464, - 2465,5,30,0,0,2465,2466,3,32,16,0,2466,2467,5,31,0,0,2467,2509,1,0,0,0, - 2468,2469,5,184,0,0,2469,2470,5,30,0,0,2470,2471,3,32,16,0,2471,2472,5, - 31,0,0,2472,2509,1,0,0,0,2473,2474,5,193,0,0,2474,2475,5,30,0,0,2475,2476, - 3,34,17,0,2476,2477,5,31,0,0,2477,2509,1,0,0,0,2478,2479,5,192,0,0,2479, - 2480,5,30,0,0,2480,2481,3,32,16,0,2481,2482,5,31,0,0,2482,2509,1,0,0,0, - 2483,2484,5,191,0,0,2484,2485,5,30,0,0,2485,2486,3,32,16,0,2486,2487,5, - 31,0,0,2487,2509,1,0,0,0,2488,2489,5,190,0,0,2489,2490,5,30,0,0,2490,2491, - 3,32,16,0,2491,2492,5,31,0,0,2492,2509,1,0,0,0,2493,2494,5,181,0,0,2494, - 2495,5,30,0,0,2495,2496,3,32,16,0,2496,2497,5,31,0,0,2497,2509,1,0,0,0, - 2498,2499,5,183,0,0,2499,2500,5,30,0,0,2500,2501,3,184,92,0,2501,2502, - 5,31,0,0,2502,2509,1,0,0,0,2503,2504,5,84,0,0,2504,2505,5,30,0,0,2505, - 2506,3,312,156,0,2506,2507,5,31,0,0,2507,2509,1,0,0,0,2508,2433,1,0,0, - 0,2508,2438,1,0,0,0,2508,2443,1,0,0,0,2508,2448,1,0,0,0,2508,2453,1,0, - 0,0,2508,2458,1,0,0,0,2508,2463,1,0,0,0,2508,2468,1,0,0,0,2508,2473,1, - 0,0,0,2508,2478,1,0,0,0,2508,2483,1,0,0,0,2508,2488,1,0,0,0,2508,2493, - 1,0,0,0,2508,2498,1,0,0,0,2508,2503,1,0,0,0,2509,311,1,0,0,0,2510,2511, - 3,314,157,0,2511,2512,6,156,-1,0,2512,2514,1,0,0,0,2513,2510,1,0,0,0,2514, - 2517,1,0,0,0,2515,2513,1,0,0,0,2515,2516,1,0,0,0,2516,313,1,0,0,0,2517, - 2515,1,0,0,0,2518,2519,7,12,0,0,2519,315,1,0,0,0,2520,2524,3,310,155,0, - 2521,2524,3,6,3,0,2522,2524,5,179,0,0,2523,2520,1,0,0,0,2523,2521,1,0, - 0,0,2523,2522,1,0,0,0,2524,317,1,0,0,0,2525,2674,3,310,155,0,2526,2527, - 5,182,0,0,2527,2528,5,30,0,0,2528,2529,5,179,0,0,2529,2674,5,31,0,0,2530, - 2531,5,182,0,0,2531,2532,5,30,0,0,2532,2533,5,264,0,0,2533,2674,5,31,0, - 0,2534,2535,5,196,0,0,2535,2536,5,30,0,0,2536,2537,5,39,0,0,2537,2538, - 5,264,0,0,2538,2674,5,31,0,0,2539,2540,5,196,0,0,2540,2541,5,30,0,0,2541, - 2542,3,138,69,0,2542,2543,5,31,0,0,2543,2674,1,0,0,0,2544,2545,5,196,0, - 0,2545,2546,5,30,0,0,2546,2547,5,179,0,0,2547,2674,5,31,0,0,2548,2549, - 5,197,0,0,2549,2550,5,30,0,0,2550,2551,3,318,159,0,2551,2552,5,31,0,0, - 2552,2674,1,0,0,0,2553,2554,5,188,0,0,2554,2555,5,42,0,0,2555,2556,3,32, - 16,0,2556,2557,5,43,0,0,2557,2558,5,30,0,0,2558,2559,3,320,160,0,2559, - 2560,5,31,0,0,2560,2674,1,0,0,0,2561,2562,5,189,0,0,2562,2563,5,42,0,0, - 2563,2564,3,32,16,0,2564,2565,5,43,0,0,2565,2566,5,30,0,0,2566,2567,3, - 322,161,0,2567,2568,5,31,0,0,2568,2674,1,0,0,0,2569,2570,5,187,0,0,2570, - 2571,5,42,0,0,2571,2572,3,32,16,0,2572,2573,5,43,0,0,2573,2574,5,30,0, - 0,2574,2575,3,324,162,0,2575,2576,5,31,0,0,2576,2674,1,0,0,0,2577,2578, - 5,186,0,0,2578,2579,5,42,0,0,2579,2580,3,32,16,0,2580,2581,5,43,0,0,2581, - 2582,5,30,0,0,2582,2583,3,326,163,0,2583,2584,5,31,0,0,2584,2674,1,0,0, - 0,2585,2586,5,185,0,0,2586,2587,5,42,0,0,2587,2588,3,32,16,0,2588,2589, - 5,43,0,0,2589,2590,5,30,0,0,2590,2591,3,328,164,0,2591,2592,5,31,0,0,2592, - 2674,1,0,0,0,2593,2594,5,184,0,0,2594,2595,5,42,0,0,2595,2596,3,32,16, - 0,2596,2597,5,43,0,0,2597,2598,5,30,0,0,2598,2599,3,330,165,0,2599,2600, - 5,31,0,0,2600,2674,1,0,0,0,2601,2602,5,193,0,0,2602,2603,5,42,0,0,2603, - 2604,3,32,16,0,2604,2605,5,43,0,0,2605,2606,5,30,0,0,2606,2607,3,324,162, - 0,2607,2608,5,31,0,0,2608,2674,1,0,0,0,2609,2610,5,192,0,0,2610,2611,5, - 42,0,0,2611,2612,3,32,16,0,2612,2613,5,43,0,0,2613,2614,5,30,0,0,2614, - 2615,3,326,163,0,2615,2616,5,31,0,0,2616,2674,1,0,0,0,2617,2618,5,191, - 0,0,2618,2619,5,42,0,0,2619,2620,3,32,16,0,2620,2621,5,43,0,0,2621,2622, - 5,30,0,0,2622,2623,3,328,164,0,2623,2624,5,31,0,0,2624,2674,1,0,0,0,2625, - 2626,5,190,0,0,2626,2627,5,42,0,0,2627,2628,3,32,16,0,2628,2629,5,43,0, - 0,2629,2630,5,30,0,0,2630,2631,3,330,165,0,2631,2632,5,31,0,0,2632,2674, - 1,0,0,0,2633,2634,5,181,0,0,2634,2635,5,42,0,0,2635,2636,3,32,16,0,2636, - 2637,5,43,0,0,2637,2638,5,30,0,0,2638,2639,3,328,164,0,2639,2640,5,31, - 0,0,2640,2674,1,0,0,0,2641,2642,5,183,0,0,2642,2643,5,42,0,0,2643,2644, - 3,32,16,0,2644,2645,5,43,0,0,2645,2646,5,30,0,0,2646,2647,3,332,166,0, - 2647,2648,5,31,0,0,2648,2674,1,0,0,0,2649,2650,5,182,0,0,2650,2651,5,42, - 0,0,2651,2652,3,32,16,0,2652,2653,5,43,0,0,2653,2654,5,30,0,0,2654,2655, - 3,334,167,0,2655,2656,5,31,0,0,2656,2674,1,0,0,0,2657,2658,5,196,0,0,2658, - 2659,5,42,0,0,2659,2660,3,32,16,0,2660,2661,5,43,0,0,2661,2662,5,30,0, - 0,2662,2663,3,336,168,0,2663,2664,5,31,0,0,2664,2674,1,0,0,0,2665,2666, - 5,197,0,0,2666,2667,5,42,0,0,2667,2668,3,32,16,0,2668,2669,5,43,0,0,2669, - 2670,5,30,0,0,2670,2671,3,340,170,0,2671,2672,5,31,0,0,2672,2674,1,0,0, - 0,2673,2525,1,0,0,0,2673,2526,1,0,0,0,2673,2530,1,0,0,0,2673,2534,1,0, - 0,0,2673,2539,1,0,0,0,2673,2544,1,0,0,0,2673,2548,1,0,0,0,2673,2553,1, - 0,0,0,2673,2561,1,0,0,0,2673,2569,1,0,0,0,2673,2577,1,0,0,0,2673,2585, - 1,0,0,0,2673,2593,1,0,0,0,2673,2601,1,0,0,0,2673,2609,1,0,0,0,2673,2617, - 1,0,0,0,2673,2625,1,0,0,0,2673,2633,1,0,0,0,2673,2641,1,0,0,0,2673,2649, - 1,0,0,0,2673,2657,1,0,0,0,2673,2665,1,0,0,0,2674,319,1,0,0,0,2675,2678, - 3,36,18,0,2676,2678,3,32,16,0,2677,2675,1,0,0,0,2677,2676,1,0,0,0,2678, - 2681,1,0,0,0,2679,2677,1,0,0,0,2679,2680,1,0,0,0,2680,321,1,0,0,0,2681, - 2679,1,0,0,0,2682,2685,3,36,18,0,2683,2685,3,34,17,0,2684,2682,1,0,0,0, - 2684,2683,1,0,0,0,2685,2688,1,0,0,0,2686,2684,1,0,0,0,2686,2687,1,0,0, - 0,2687,323,1,0,0,0,2688,2686,1,0,0,0,2689,2691,3,34,17,0,2690,2689,1,0, - 0,0,2691,2694,1,0,0,0,2692,2690,1,0,0,0,2692,2693,1,0,0,0,2693,325,1,0, - 0,0,2694,2692,1,0,0,0,2695,2697,3,32,16,0,2696,2695,1,0,0,0,2697,2700, - 1,0,0,0,2698,2696,1,0,0,0,2698,2699,1,0,0,0,2699,327,1,0,0,0,2700,2698, - 1,0,0,0,2701,2703,3,32,16,0,2702,2701,1,0,0,0,2703,2706,1,0,0,0,2704,2702, - 1,0,0,0,2704,2705,1,0,0,0,2705,329,1,0,0,0,2706,2704,1,0,0,0,2707,2709, - 3,32,16,0,2708,2707,1,0,0,0,2709,2712,1,0,0,0,2710,2708,1,0,0,0,2710,2711, - 1,0,0,0,2711,331,1,0,0,0,2712,2710,1,0,0,0,2713,2715,3,184,92,0,2714,2713, - 1,0,0,0,2715,2718,1,0,0,0,2716,2714,1,0,0,0,2716,2717,1,0,0,0,2717,333, - 1,0,0,0,2718,2716,1,0,0,0,2719,2721,7,13,0,0,2720,2719,1,0,0,0,2721,2724, - 1,0,0,0,2722,2720,1,0,0,0,2722,2723,1,0,0,0,2723,335,1,0,0,0,2724,2722, - 1,0,0,0,2725,2727,3,338,169,0,2726,2725,1,0,0,0,2727,2730,1,0,0,0,2728, - 2726,1,0,0,0,2728,2729,1,0,0,0,2729,337,1,0,0,0,2730,2728,1,0,0,0,2731, - 2736,5,179,0,0,2732,2733,5,39,0,0,2733,2736,5,264,0,0,2734,2736,3,138, - 69,0,2735,2731,1,0,0,0,2735,2732,1,0,0,0,2735,2734,1,0,0,0,2736,339,1, - 0,0,0,2737,2739,3,318,159,0,2738,2737,1,0,0,0,2739,2742,1,0,0,0,2740,2738, - 1,0,0,0,2740,2741,1,0,0,0,2741,341,1,0,0,0,2742,2740,1,0,0,0,2743,2747, - 3,44,22,0,2744,2747,3,46,23,0,2745,2747,3,2,1,0,2746,2743,1,0,0,0,2746, - 2744,1,0,0,0,2746,2745,1,0,0,0,2747,343,1,0,0,0,2748,2749,7,14,0,0,2749, - 2750,5,36,0,0,2750,2751,5,30,0,0,2751,2752,3,312,156,0,2752,2753,5,31, - 0,0,2753,2774,1,0,0,0,2754,2755,5,169,0,0,2755,2756,3,38,19,0,2756,2757, - 5,75,0,0,2757,2758,3,38,19,0,2758,2759,5,75,0,0,2759,2760,3,38,19,0,2760, - 2761,5,75,0,0,2761,2762,3,38,19,0,2762,2774,1,0,0,0,2763,2764,5,170,0, - 0,2764,2774,3,6,3,0,2765,2766,5,170,0,0,2766,2767,5,36,0,0,2767,2768,5, - 30,0,0,2768,2769,3,312,156,0,2769,2770,5,31,0,0,2770,2774,1,0,0,0,2771, - 2774,3,342,171,0,2772,2774,3,40,20,0,2773,2748,1,0,0,0,2773,2754,1,0,0, - 0,2773,2763,1,0,0,0,2773,2765,1,0,0,0,2773,2771,1,0,0,0,2773,2772,1,0, - 0,0,2774,345,1,0,0,0,2775,2776,5,25,0,0,2776,2777,5,40,0,0,2777,2778,3, - 98,49,0,2778,2779,3,2,1,0,2779,2788,1,0,0,0,2780,2781,5,25,0,0,2781,2782, - 5,40,0,0,2782,2783,3,98,49,0,2783,2784,3,2,1,0,2784,2785,5,34,0,0,2785, - 2786,3,2,1,0,2786,2788,1,0,0,0,2787,2775,1,0,0,0,2787,2780,1,0,0,0,2788, - 347,1,0,0,0,2789,2791,3,350,175,0,2790,2789,1,0,0,0,2791,2794,1,0,0,0, - 2792,2790,1,0,0,0,2792,2793,1,0,0,0,2793,349,1,0,0,0,2794,2792,1,0,0,0, - 2795,2796,5,180,0,0,2796,2797,5,36,0,0,2797,2798,5,30,0,0,2798,2799,3, - 312,156,0,2799,2800,5,31,0,0,2800,2810,1,0,0,0,2801,2810,3,344,172,0,2802, - 2803,5,171,0,0,2803,2804,5,36,0,0,2804,2805,5,30,0,0,2805,2806,3,312,156, - 0,2806,2807,5,31,0,0,2807,2810,1,0,0,0,2808,2810,5,55,0,0,2809,2795,1, - 0,0,0,2809,2801,1,0,0,0,2809,2802,1,0,0,0,2809,2808,1,0,0,0,2810,351,1, - 0,0,0,2811,2812,5,50,0,0,2812,2816,5,40,0,0,2813,2815,3,356,178,0,2814, - 2813,1,0,0,0,2815,2818,1,0,0,0,2816,2814,1,0,0,0,2816,2817,1,0,0,0,2817, - 2819,1,0,0,0,2818,2816,1,0,0,0,2819,2820,3,2,1,0,2820,353,1,0,0,0,2821, - 2825,5,301,0,0,2822,2824,3,356,178,0,2823,2822,1,0,0,0,2824,2827,1,0,0, - 0,2825,2823,1,0,0,0,2825,2826,1,0,0,0,2826,2828,1,0,0,0,2827,2825,1,0, - 0,0,2828,2829,3,2,1,0,2829,355,1,0,0,0,2830,2846,5,52,0,0,2831,2846,5, - 51,0,0,2832,2846,5,172,0,0,2833,2834,5,62,0,0,2834,2846,5,51,0,0,2835, - 2836,5,62,0,0,2836,2846,5,52,0,0,2837,2838,5,62,0,0,2838,2846,5,63,0,0, - 2839,2840,5,62,0,0,2840,2846,5,64,0,0,2841,2842,5,62,0,0,2842,2846,5,65, - 0,0,2843,2844,5,62,0,0,2844,2846,5,66,0,0,2845,2830,1,0,0,0,2845,2831, - 1,0,0,0,2845,2832,1,0,0,0,2845,2833,1,0,0,0,2845,2835,1,0,0,0,2845,2837, - 1,0,0,0,2845,2839,1,0,0,0,2845,2841,1,0,0,0,2845,2843,1,0,0,0,2846,357, - 1,0,0,0,2847,2849,3,360,180,0,2848,2847,1,0,0,0,2849,2852,1,0,0,0,2850, - 2848,1,0,0,0,2850,2851,1,0,0,0,2851,359,1,0,0,0,2852,2850,1,0,0,0,2853, - 2854,5,21,0,0,2854,2867,3,2,1,0,2855,2856,5,50,0,0,2856,2857,5,40,0,0, - 2857,2867,3,140,70,0,2858,2859,5,25,0,0,2859,2860,5,40,0,0,2860,2867,3, - 2,1,0,2861,2867,3,196,98,0,2862,2863,5,50,0,0,2863,2867,3,32,16,0,2864, - 2867,3,342,171,0,2865,2867,3,40,20,0,2866,2853,1,0,0,0,2866,2855,1,0,0, - 0,2866,2858,1,0,0,0,2866,2861,1,0,0,0,2866,2862,1,0,0,0,2866,2864,1,0, - 0,0,2866,2865,1,0,0,0,2867,361,1,0,0,0,2868,2872,5,274,0,0,2869,2871,3, - 364,182,0,2870,2869,1,0,0,0,2871,2874,1,0,0,0,2872,2870,1,0,0,0,2872,2873, - 1,0,0,0,2873,2875,1,0,0,0,2874,2872,1,0,0,0,2875,2888,3,2,1,0,2876,2880, - 5,274,0,0,2877,2879,3,364,182,0,2878,2877,1,0,0,0,2879,2882,1,0,0,0,2880, - 2878,1,0,0,0,2880,2881,1,0,0,0,2881,2883,1,0,0,0,2882,2880,1,0,0,0,2883, - 2884,3,2,1,0,2884,2885,5,34,0,0,2885,2886,3,2,1,0,2886,2888,1,0,0,0,2887, - 2868,1,0,0,0,2887,2876,1,0,0,0,2888,363,1,0,0,0,2889,2890,7,15,0,0,2890, - 365,1,0,0,0,2891,2893,3,368,184,0,2892,2891,1,0,0,0,2893,2896,1,0,0,0, - 2894,2892,1,0,0,0,2894,2895,1,0,0,0,2895,367,1,0,0,0,2896,2894,1,0,0,0, - 2897,2898,5,21,0,0,2898,2899,3,2,1,0,2899,2900,5,44,0,0,2900,2901,3,32, - 16,0,2901,2908,1,0,0,0,2902,2903,5,25,0,0,2903,2904,5,40,0,0,2904,2908, - 3,2,1,0,2905,2908,3,342,171,0,2906,2908,3,40,20,0,2907,2897,1,0,0,0,2907, - 2902,1,0,0,0,2907,2905,1,0,0,0,2907,2906,1,0,0,0,2908,369,1,0,0,0,172, - 378,383,391,399,452,493,502,526,530,548,575,598,634,640,647,649,659,661, - 668,679,687,708,710,726,771,776,781,786,794,904,910,926,932,938,945,1056, - 1061,1067,1072,1074,1082,1094,1106,1113,1120,1122,1149,1156,1164,1172, - 1185,1192,1195,1214,1308,1317,1324,1327,1335,1356,1388,1411,1423,1432, - 1457,1481,1489,1493,1508,1515,1560,1570,1586,1598,1610,1624,1636,1647, - 1654,1664,1677,1682,1687,1696,1707,1790,1799,1812,1823,1831,1841,1843, - 1870,1877,1882,1889,1895,1905,1909,1916,1931,1937,1951,1964,1972,1979, - 1983,1988,2004,2009,2011,2024,2050,2057,2059,2064,2070,2099,2104,2127, - 2132,2196,2205,2218,2229,2240,2243,2250,2262,2276,2290,2298,2318,2330, - 2335,2344,2346,2353,2363,2431,2508,2515,2523,2673,2677,2679,2684,2686, - 2692,2698,2704,2710,2716,2722,2728,2735,2740,2746,2773,2787,2792,2809, - 2816,2825,2845,2850,2866,2872,2880,2887,2894,2907 + 69,2,0,173,173,289,290,2,0,179,179,264,264,1,0,167,168,1,0,51,52,3309, + 0,350,1,0,0,0,2,363,1,0,0,0,4,365,1,0,0,0,6,371,1,0,0,0,8,379,1,0,0,0, + 10,432,1,0,0,0,12,434,1,0,0,0,14,437,1,0,0,0,16,440,1,0,0,0,18,444,1,0, + 0,0,20,447,1,0,0,0,22,450,1,0,0,0,24,457,1,0,0,0,26,473,1,0,0,0,28,475, + 1,0,0,0,30,477,1,0,0,0,32,487,1,0,0,0,34,489,1,0,0,0,36,506,1,0,0,0,38, + 510,1,0,0,0,40,528,1,0,0,0,42,555,1,0,0,0,44,578,1,0,0,0,46,614,1,0,0, + 0,48,616,1,0,0,0,50,620,1,0,0,0,52,622,1,0,0,0,54,629,1,0,0,0,56,641,1, + 0,0,0,58,644,1,0,0,0,60,646,1,0,0,0,62,659,1,0,0,0,64,667,1,0,0,0,66,669, + 1,0,0,0,68,677,1,0,0,0,70,693,1,0,0,0,72,699,1,0,0,0,74,702,1,0,0,0,76, + 751,1,0,0,0,78,756,1,0,0,0,80,761,1,0,0,0,82,766,1,0,0,0,84,774,1,0,0, + 0,86,779,1,0,0,0,88,884,1,0,0,0,90,912,1,0,0,0,92,914,1,0,0,0,94,918,1, + 0,0,0,96,920,1,0,0,0,98,925,1,0,0,0,100,930,1,0,0,0,102,982,1,0,0,0,104, + 1018,1,0,0,0,106,1036,1,0,0,0,108,1038,1,0,0,0,110,1050,1,0,0,0,112,1075, + 1,0,0,0,114,1084,1,0,0,0,116,1111,1,0,0,0,118,1118,1,0,0,0,120,1126,1, + 0,0,0,122,1134,1,0,0,0,124,1147,1,0,0,0,126,1157,1,0,0,0,128,1176,1,0, + 0,0,130,1270,1,0,0,0,132,1279,1,0,0,0,134,1289,1,0,0,0,136,1291,1,0,0, + 0,138,1293,1,0,0,0,140,1318,1,0,0,0,142,1350,1,0,0,0,144,1373,1,0,0,0, + 146,1385,1,0,0,0,148,1387,1,0,0,0,150,1390,1,0,0,0,152,1443,1,0,0,0,154, + 1455,1,0,0,0,156,1470,1,0,0,0,158,1477,1,0,0,0,160,1482,1,0,0,0,162,1486, + 1,0,0,0,164,1522,1,0,0,0,166,1524,1,0,0,0,168,1560,1,0,0,0,170,1572,1, + 0,0,0,172,1586,1,0,0,0,174,1588,1,0,0,0,176,1598,1,0,0,0,178,1609,1,0, + 0,0,180,1616,1,0,0,0,182,1626,1,0,0,0,184,1639,1,0,0,0,186,1644,1,0,0, + 0,188,1647,1,0,0,0,190,1658,1,0,0,0,192,1663,1,0,0,0,194,1669,1,0,0,0, + 196,1671,1,0,0,0,198,1793,1,0,0,0,200,1795,1,0,0,0,202,1832,1,0,0,0,204, + 1839,1,0,0,0,206,1844,1,0,0,0,208,1851,1,0,0,0,210,1871,1,0,0,0,212,1873, + 1,0,0,0,214,1878,1,0,0,0,216,1893,1,0,0,0,218,1895,1,0,0,0,220,1908,1, + 0,0,0,222,1913,1,0,0,0,224,1926,1,0,0,0,226,1934,1,0,0,0,228,1945,1,0, + 0,0,230,1950,1,0,0,0,232,1966,1,0,0,0,234,1968,1,0,0,0,236,2012,1,0,0, + 0,238,2032,1,0,0,0,240,2061,1,0,0,0,242,2066,1,0,0,0,244,2089,1,0,0,0, + 246,2094,1,0,0,0,248,2114,1,0,0,0,250,2214,1,0,0,0,252,2216,1,0,0,0,254, + 2222,1,0,0,0,256,2224,1,0,0,0,258,2228,1,0,0,0,260,2232,1,0,0,0,262,2248, + 1,0,0,0,264,2262,1,0,0,0,266,2270,1,0,0,0,268,2272,1,0,0,0,270,2275,1, + 0,0,0,272,2277,1,0,0,0,274,2290,1,0,0,0,276,2292,1,0,0,0,278,2302,1,0, + 0,0,280,2307,1,0,0,0,282,2318,1,0,0,0,284,2325,1,0,0,0,286,2335,1,0,0, + 0,288,2403,1,0,0,0,290,2480,1,0,0,0,292,2487,1,0,0,0,294,2490,1,0,0,0, + 296,2495,1,0,0,0,298,2645,1,0,0,0,300,2651,1,0,0,0,302,2658,1,0,0,0,304, + 2664,1,0,0,0,306,2670,1,0,0,0,308,2676,1,0,0,0,310,2682,1,0,0,0,312,2688, + 1,0,0,0,314,2694,1,0,0,0,316,2700,1,0,0,0,318,2707,1,0,0,0,320,2712,1, + 0,0,0,322,2718,1,0,0,0,324,2745,1,0,0,0,326,2759,1,0,0,0,328,2764,1,0, + 0,0,330,2781,1,0,0,0,332,2783,1,0,0,0,334,2793,1,0,0,0,336,2817,1,0,0, + 0,338,2822,1,0,0,0,340,2838,1,0,0,0,342,2859,1,0,0,0,344,2861,1,0,0,0, + 346,2866,1,0,0,0,348,2879,1,0,0,0,350,351,7,0,0,0,351,1,1,0,0,0,352,364, + 5,288,0,0,353,354,3,4,2,0,354,355,5,265,0,0,355,357,1,0,0,0,356,353,1, + 0,0,0,357,360,1,0,0,0,358,356,1,0,0,0,358,359,1,0,0,0,359,361,1,0,0,0, + 360,358,1,0,0,0,361,364,3,4,2,0,362,364,5,264,0,0,363,352,1,0,0,0,363, + 358,1,0,0,0,363,362,1,0,0,0,364,3,1,0,0,0,365,366,7,1,0,0,366,5,1,0,0, + 0,367,368,5,263,0,0,368,370,5,266,0,0,369,367,1,0,0,0,370,373,1,0,0,0, + 371,369,1,0,0,0,371,372,1,0,0,0,372,374,1,0,0,0,373,371,1,0,0,0,374,375, + 5,263,0,0,375,7,1,0,0,0,376,378,3,10,5,0,377,376,1,0,0,0,378,381,1,0,0, + 0,379,377,1,0,0,0,379,380,1,0,0,0,380,9,1,0,0,0,381,379,1,0,0,0,382,383, + 3,74,37,0,383,384,5,17,0,0,384,385,3,82,41,0,385,386,5,18,0,0,386,433, + 1,0,0,0,387,388,3,72,36,0,388,389,5,17,0,0,389,390,3,8,4,0,390,391,5,18, + 0,0,391,433,1,0,0,0,392,393,3,234,117,0,393,394,5,17,0,0,394,395,3,246, + 123,0,395,396,5,18,0,0,396,433,1,0,0,0,397,433,3,200,100,0,398,433,3,276, + 138,0,399,433,3,70,35,0,400,433,3,66,33,0,401,433,3,88,44,0,402,433,3, + 90,45,0,403,433,3,22,11,0,404,405,3,326,163,0,405,406,5,17,0,0,406,407, + 3,328,164,0,407,408,5,18,0,0,408,433,1,0,0,0,409,410,3,332,166,0,410,411, + 5,17,0,0,411,412,3,338,169,0,412,413,5,18,0,0,413,433,1,0,0,0,414,415, + 3,342,171,0,415,416,5,17,0,0,416,417,3,346,173,0,417,418,5,18,0,0,418, + 433,1,0,0,0,419,433,3,64,32,0,420,433,3,152,76,0,421,433,3,322,161,0,422, + 433,3,12,6,0,423,433,3,14,7,0,424,433,3,16,8,0,425,433,3,18,9,0,426,433, + 3,20,10,0,427,433,3,26,13,0,428,433,3,42,21,0,429,433,3,40,20,0,430,433, + 3,30,15,0,431,433,3,24,12,0,432,382,1,0,0,0,432,387,1,0,0,0,432,392,1, + 0,0,0,432,397,1,0,0,0,432,398,1,0,0,0,432,399,1,0,0,0,432,400,1,0,0,0, + 432,401,1,0,0,0,432,402,1,0,0,0,432,403,1,0,0,0,432,404,1,0,0,0,432,409, + 1,0,0,0,432,414,1,0,0,0,432,419,1,0,0,0,432,420,1,0,0,0,432,421,1,0,0, + 0,432,422,1,0,0,0,432,423,1,0,0,0,432,424,1,0,0,0,432,425,1,0,0,0,432, + 426,1,0,0,0,432,427,1,0,0,0,432,428,1,0,0,0,432,429,1,0,0,0,432,430,1, + 0,0,0,432,431,1,0,0,0,433,11,1,0,0,0,434,435,5,19,0,0,435,436,3,32,16, + 0,436,13,1,0,0,0,437,438,5,20,0,0,438,439,3,32,16,0,439,15,1,0,0,0,440, + 441,5,21,0,0,441,442,5,22,0,0,442,443,3,32,16,0,443,17,1,0,0,0,444,445, + 5,23,0,0,445,446,3,34,17,0,446,19,1,0,0,0,447,448,5,24,0,0,448,449,3,34, + 17,0,449,21,1,0,0,0,450,451,5,25,0,0,451,452,3,98,49,0,452,453,3,2,1,0, + 453,454,5,17,0,0,454,455,3,120,60,0,455,456,5,18,0,0,456,23,1,0,0,0,457, + 458,5,26,0,0,458,25,1,0,0,0,459,460,5,27,0,0,460,474,3,28,14,0,461,462, + 5,27,0,0,462,463,3,28,14,0,463,464,5,28,0,0,464,465,3,28,14,0,465,474, + 1,0,0,0,466,467,5,27,0,0,467,468,3,28,14,0,468,469,5,28,0,0,469,470,3, + 28,14,0,470,471,5,28,0,0,471,472,3,28,14,0,472,474,1,0,0,0,473,459,1,0, + 0,0,473,461,1,0,0,0,473,466,1,0,0,0,474,27,1,0,0,0,475,476,7,2,0,0,476, + 29,1,0,0,0,477,478,5,29,0,0,478,482,5,17,0,0,479,481,3,116,58,0,480,479, + 1,0,0,0,481,484,1,0,0,0,482,480,1,0,0,0,482,483,1,0,0,0,483,485,1,0,0, + 0,484,482,1,0,0,0,485,486,5,18,0,0,486,31,1,0,0,0,487,488,5,173,0,0,488, + 33,1,0,0,0,489,490,7,3,0,0,490,35,1,0,0,0,491,507,5,175,0,0,492,493,3, + 32,16,0,493,494,5,265,0,0,494,507,1,0,0,0,495,507,3,32,16,0,496,497,5, + 188,0,0,497,498,5,30,0,0,498,499,3,32,16,0,499,500,5,31,0,0,500,507,1, + 0,0,0,501,502,5,189,0,0,502,503,5,30,0,0,503,504,3,34,17,0,504,505,5,31, + 0,0,505,507,1,0,0,0,506,491,1,0,0,0,506,492,1,0,0,0,506,495,1,0,0,0,506, + 496,1,0,0,0,506,501,1,0,0,0,507,37,1,0,0,0,508,511,3,32,16,0,509,511,5, + 262,0,0,510,508,1,0,0,0,510,509,1,0,0,0,511,39,1,0,0,0,512,513,5,267,0, + 0,513,529,5,289,0,0,514,515,5,267,0,0,515,516,5,289,0,0,516,529,5,263, + 0,0,517,518,5,268,0,0,518,529,5,289,0,0,519,520,5,269,0,0,520,529,5,289, + 0,0,521,522,5,270,0,0,522,529,5,289,0,0,523,529,5,271,0,0,524,529,5,272, + 0,0,525,526,5,273,0,0,526,529,5,263,0,0,527,529,5,32,0,0,528,512,1,0,0, + 0,528,514,1,0,0,0,528,517,1,0,0,0,528,519,1,0,0,0,528,521,1,0,0,0,528, + 523,1,0,0,0,528,524,1,0,0,0,528,525,1,0,0,0,528,527,1,0,0,0,529,41,1,0, + 0,0,530,531,5,33,0,0,531,532,3,138,69,0,532,533,5,34,0,0,533,534,3,2,1, + 0,534,556,1,0,0,0,535,536,5,33,0,0,536,537,3,116,58,0,537,538,5,34,0,0, + 538,539,3,2,1,0,539,556,1,0,0,0,540,541,5,33,0,0,541,542,3,176,88,0,542, + 543,5,34,0,0,543,544,3,2,1,0,544,556,1,0,0,0,545,546,5,33,0,0,546,547, + 3,44,22,0,547,548,5,34,0,0,548,549,3,2,1,0,549,556,1,0,0,0,550,551,5,33, + 0,0,551,552,3,46,23,0,552,553,5,34,0,0,553,554,3,2,1,0,554,556,1,0,0,0, + 555,530,1,0,0,0,555,535,1,0,0,0,555,540,1,0,0,0,555,545,1,0,0,0,555,550, + 1,0,0,0,556,43,1,0,0,0,557,558,5,35,0,0,558,579,3,48,24,0,559,560,5,35, + 0,0,560,561,3,48,24,0,561,562,5,36,0,0,562,563,3,6,3,0,563,579,1,0,0,0, + 564,565,5,35,0,0,565,566,3,48,24,0,566,567,5,36,0,0,567,568,5,17,0,0,568, + 569,3,52,26,0,569,570,5,18,0,0,570,579,1,0,0,0,571,572,5,35,0,0,572,573, + 3,48,24,0,573,574,5,36,0,0,574,575,5,30,0,0,575,576,3,292,146,0,576,577, + 5,31,0,0,577,579,1,0,0,0,578,557,1,0,0,0,578,559,1,0,0,0,578,564,1,0,0, + 0,578,571,1,0,0,0,579,45,1,0,0,0,580,581,5,35,0,0,581,582,5,30,0,0,582, + 583,3,50,25,0,583,584,5,31,0,0,584,585,3,48,24,0,585,615,1,0,0,0,586,587, + 5,35,0,0,587,588,5,30,0,0,588,589,3,50,25,0,589,590,5,31,0,0,590,591,3, + 48,24,0,591,592,5,36,0,0,592,593,3,6,3,0,593,615,1,0,0,0,594,595,5,35, + 0,0,595,596,5,30,0,0,596,597,3,50,25,0,597,598,5,31,0,0,598,599,3,48,24, + 0,599,600,5,36,0,0,600,601,5,17,0,0,601,602,3,52,26,0,602,603,5,18,0,0, + 603,615,1,0,0,0,604,605,5,35,0,0,605,606,5,30,0,0,606,607,3,50,25,0,607, + 608,5,31,0,0,608,609,3,48,24,0,609,610,5,36,0,0,610,611,5,30,0,0,611,612, + 3,292,146,0,612,613,5,31,0,0,613,615,1,0,0,0,614,580,1,0,0,0,614,586,1, + 0,0,0,614,594,1,0,0,0,614,604,1,0,0,0,615,47,1,0,0,0,616,617,3,168,84, + 0,617,49,1,0,0,0,618,621,3,124,62,0,619,621,3,176,88,0,620,618,1,0,0,0, + 620,619,1,0,0,0,621,51,1,0,0,0,622,623,3,54,27,0,623,624,3,56,28,0,624, + 53,1,0,0,0,625,628,3,298,149,0,626,628,3,40,20,0,627,625,1,0,0,0,627,626, + 1,0,0,0,628,631,1,0,0,0,629,627,1,0,0,0,629,630,1,0,0,0,630,55,1,0,0,0, + 631,629,1,0,0,0,632,633,3,58,29,0,633,634,3,60,30,0,634,635,3,2,1,0,635, + 636,5,36,0,0,636,637,3,298,149,0,637,640,1,0,0,0,638,640,3,40,20,0,639, + 632,1,0,0,0,639,638,1,0,0,0,640,643,1,0,0,0,641,639,1,0,0,0,641,642,1, + 0,0,0,642,57,1,0,0,0,643,641,1,0,0,0,644,645,7,4,0,0,645,59,1,0,0,0,646, + 648,3,62,31,0,647,649,5,261,0,0,648,647,1,0,0,0,648,649,1,0,0,0,649,61, + 1,0,0,0,650,660,3,144,72,0,651,660,3,2,1,0,652,660,5,196,0,0,653,660,5, + 197,0,0,654,655,5,202,0,0,655,656,5,39,0,0,656,660,5,264,0,0,657,658,5, + 202,0,0,658,660,3,116,58,0,659,650,1,0,0,0,659,651,1,0,0,0,659,652,1,0, + 0,0,659,653,1,0,0,0,659,654,1,0,0,0,659,657,1,0,0,0,660,63,1,0,0,0,661, + 662,5,198,0,0,662,663,5,40,0,0,663,668,3,2,1,0,664,665,5,198,0,0,665,668, + 3,2,1,0,666,668,5,198,0,0,667,661,1,0,0,0,667,664,1,0,0,0,667,666,1,0, + 0,0,668,65,1,0,0,0,669,670,5,41,0,0,670,671,5,42,0,0,671,672,3,32,16,0, + 672,673,5,43,0,0,673,674,3,68,34,0,674,675,5,44,0,0,675,676,3,0,0,0,676, + 67,1,0,0,0,677,690,6,34,-1,0,678,679,10,5,0,0,679,689,5,186,0,0,680,681, + 10,4,0,0,681,689,5,187,0,0,682,683,10,3,0,0,683,689,5,45,0,0,684,685,10, + 2,0,0,685,689,5,46,0,0,686,687,10,1,0,0,687,689,5,47,0,0,688,678,1,0,0, + 0,688,680,1,0,0,0,688,682,1,0,0,0,688,684,1,0,0,0,688,686,1,0,0,0,689, + 692,1,0,0,0,690,688,1,0,0,0,690,691,1,0,0,0,691,69,1,0,0,0,692,690,1,0, + 0,0,693,694,5,48,0,0,694,695,5,36,0,0,695,696,5,30,0,0,696,697,3,292,146, + 0,697,698,5,31,0,0,698,71,1,0,0,0,699,700,5,49,0,0,700,701,3,2,1,0,701, + 73,1,0,0,0,702,706,5,50,0,0,703,705,3,76,38,0,704,703,1,0,0,0,705,708, + 1,0,0,0,706,704,1,0,0,0,706,707,1,0,0,0,707,709,1,0,0,0,708,706,1,0,0, + 0,709,710,3,2,1,0,710,711,3,182,91,0,711,712,3,78,39,0,712,713,3,80,40, + 0,713,75,1,0,0,0,714,752,5,51,0,0,715,752,5,52,0,0,716,752,5,199,0,0,717, + 752,5,202,0,0,718,752,5,221,0,0,719,752,5,53,0,0,720,752,5,54,0,0,721, + 752,5,55,0,0,722,752,5,56,0,0,723,752,5,244,0,0,724,752,5,15,0,0,725,752, + 5,224,0,0,726,752,5,57,0,0,727,752,5,58,0,0,728,752,5,59,0,0,729,752,5, + 60,0,0,730,752,5,61,0,0,731,732,5,62,0,0,732,752,5,51,0,0,733,734,5,62, + 0,0,734,752,5,52,0,0,735,736,5,62,0,0,736,752,5,63,0,0,737,738,5,62,0, + 0,738,752,5,64,0,0,739,740,5,62,0,0,740,752,5,65,0,0,741,742,5,62,0,0, + 742,752,5,66,0,0,743,752,5,67,0,0,744,752,5,68,0,0,745,752,5,69,0,0,746, + 747,5,70,0,0,747,748,5,30,0,0,748,749,3,32,16,0,749,750,5,31,0,0,750,752, + 1,0,0,0,751,714,1,0,0,0,751,715,1,0,0,0,751,716,1,0,0,0,751,717,1,0,0, + 0,751,718,1,0,0,0,751,719,1,0,0,0,751,720,1,0,0,0,751,721,1,0,0,0,751, + 722,1,0,0,0,751,723,1,0,0,0,751,724,1,0,0,0,751,725,1,0,0,0,751,726,1, + 0,0,0,751,727,1,0,0,0,751,728,1,0,0,0,751,729,1,0,0,0,751,730,1,0,0,0, + 751,731,1,0,0,0,751,733,1,0,0,0,751,735,1,0,0,0,751,737,1,0,0,0,751,739, + 1,0,0,0,751,741,1,0,0,0,751,743,1,0,0,0,751,744,1,0,0,0,751,745,1,0,0, + 0,751,746,1,0,0,0,752,77,1,0,0,0,753,757,1,0,0,0,754,755,5,71,0,0,755, + 757,3,124,62,0,756,753,1,0,0,0,756,754,1,0,0,0,757,79,1,0,0,0,758,762, + 1,0,0,0,759,760,5,72,0,0,760,762,3,84,42,0,761,758,1,0,0,0,761,759,1,0, + 0,0,762,81,1,0,0,0,763,765,3,198,99,0,764,763,1,0,0,0,765,768,1,0,0,0, + 766,764,1,0,0,0,766,767,1,0,0,0,767,83,1,0,0,0,768,766,1,0,0,0,769,770, + 3,124,62,0,770,771,5,28,0,0,771,773,1,0,0,0,772,769,1,0,0,0,773,776,1, + 0,0,0,774,772,1,0,0,0,774,775,1,0,0,0,775,777,1,0,0,0,776,774,1,0,0,0, + 777,778,3,124,62,0,778,85,1,0,0,0,779,780,7,5,0,0,780,87,1,0,0,0,781,782, + 3,86,43,0,782,783,3,32,16,0,783,784,5,264,0,0,784,885,1,0,0,0,785,786, + 3,86,43,0,786,787,3,32,16,0,787,885,1,0,0,0,788,789,3,86,43,0,789,790, + 3,32,16,0,790,791,5,75,0,0,791,792,3,32,16,0,792,793,5,264,0,0,793,885, + 1,0,0,0,794,795,3,86,43,0,795,796,3,32,16,0,796,797,5,75,0,0,797,798,3, + 32,16,0,798,885,1,0,0,0,799,800,3,86,43,0,800,801,3,32,16,0,801,802,5, + 75,0,0,802,803,3,32,16,0,803,804,5,28,0,0,804,805,3,32,16,0,805,806,5, + 264,0,0,806,885,1,0,0,0,807,808,3,86,43,0,808,809,3,32,16,0,809,810,5, + 75,0,0,810,811,3,32,16,0,811,812,5,28,0,0,812,813,3,32,16,0,813,885,1, + 0,0,0,814,815,3,86,43,0,815,816,3,32,16,0,816,817,5,28,0,0,817,818,3,32, + 16,0,818,819,5,75,0,0,819,820,3,32,16,0,820,821,5,264,0,0,821,885,1,0, + 0,0,822,823,3,86,43,0,823,824,3,32,16,0,824,825,5,28,0,0,825,826,3,32, + 16,0,826,827,5,75,0,0,827,828,3,32,16,0,828,885,1,0,0,0,829,830,3,86,43, + 0,830,831,3,32,16,0,831,832,5,28,0,0,832,833,3,32,16,0,833,834,5,75,0, + 0,834,835,3,32,16,0,835,836,5,28,0,0,836,837,3,32,16,0,837,838,5,264,0, + 0,838,885,1,0,0,0,839,840,3,86,43,0,840,841,3,32,16,0,841,842,5,28,0,0, + 842,843,3,32,16,0,843,844,5,75,0,0,844,845,3,32,16,0,845,846,5,28,0,0, + 846,847,3,32,16,0,847,885,1,0,0,0,848,849,3,86,43,0,849,850,3,32,16,0, + 850,851,5,263,0,0,851,885,1,0,0,0,852,853,3,86,43,0,853,854,3,32,16,0, + 854,855,5,75,0,0,855,856,3,32,16,0,856,857,5,263,0,0,857,885,1,0,0,0,858, + 859,3,86,43,0,859,860,3,32,16,0,860,861,5,75,0,0,861,862,3,32,16,0,862, + 863,5,28,0,0,863,864,3,32,16,0,864,865,5,263,0,0,865,885,1,0,0,0,866,867, + 3,86,43,0,867,868,3,32,16,0,868,869,5,28,0,0,869,870,3,32,16,0,870,871, + 5,75,0,0,871,872,3,32,16,0,872,873,5,263,0,0,873,885,1,0,0,0,874,875,3, + 86,43,0,875,876,3,32,16,0,876,877,5,28,0,0,877,878,3,32,16,0,878,879,5, + 75,0,0,879,880,3,32,16,0,880,881,5,28,0,0,881,882,3,32,16,0,882,883,5, + 263,0,0,883,885,1,0,0,0,884,781,1,0,0,0,884,785,1,0,0,0,884,788,1,0,0, + 0,884,794,1,0,0,0,884,799,1,0,0,0,884,807,1,0,0,0,884,814,1,0,0,0,884, + 822,1,0,0,0,884,829,1,0,0,0,884,839,1,0,0,0,884,848,1,0,0,0,884,852,1, + 0,0,0,884,858,1,0,0,0,884,866,1,0,0,0,884,874,1,0,0,0,885,89,1,0,0,0,886, + 890,5,21,0,0,887,889,3,92,46,0,888,887,1,0,0,0,889,892,1,0,0,0,890,888, + 1,0,0,0,890,891,1,0,0,0,891,893,1,0,0,0,892,890,1,0,0,0,893,894,3,2,1, + 0,894,895,3,94,47,0,895,896,5,180,0,0,896,897,5,36,0,0,897,898,5,30,0, + 0,898,899,3,292,146,0,899,900,5,31,0,0,900,901,3,94,47,0,901,913,1,0,0, + 0,902,906,5,21,0,0,903,905,3,92,46,0,904,903,1,0,0,0,905,908,1,0,0,0,906, + 904,1,0,0,0,906,907,1,0,0,0,907,909,1,0,0,0,908,906,1,0,0,0,909,910,3, + 2,1,0,910,911,3,94,47,0,911,913,1,0,0,0,912,886,1,0,0,0,912,902,1,0,0, + 0,913,91,1,0,0,0,914,915,5,76,0,0,915,93,1,0,0,0,916,919,1,0,0,0,917,919, + 5,298,0,0,918,916,1,0,0,0,918,917,1,0,0,0,919,95,1,0,0,0,920,921,7,6,0, + 0,921,97,1,0,0,0,922,924,3,96,48,0,923,922,1,0,0,0,924,927,1,0,0,0,925, + 923,1,0,0,0,925,926,1,0,0,0,926,99,1,0,0,0,927,925,1,0,0,0,928,931,3,102, + 51,0,929,931,3,104,52,0,930,928,1,0,0,0,930,929,1,0,0,0,931,101,1,0,0, + 0,932,933,5,275,0,0,933,983,6,51,-1,0,934,935,5,276,0,0,935,936,3,32,16, + 0,936,937,6,51,-1,0,937,983,1,0,0,0,938,939,5,276,0,0,939,940,3,0,0,0, + 940,941,6,51,-1,0,941,983,1,0,0,0,942,943,5,277,0,0,943,944,3,32,16,0, + 944,945,6,51,-1,0,945,983,1,0,0,0,946,947,5,278,0,0,947,948,3,34,17,0, + 948,949,6,51,-1,0,949,983,1,0,0,0,950,951,5,279,0,0,951,952,5,30,0,0,952, + 953,3,292,146,0,953,954,5,31,0,0,954,955,6,51,-1,0,955,983,1,0,0,0,956, + 957,5,279,0,0,957,958,5,84,0,0,958,959,5,30,0,0,959,960,3,292,146,0,960, + 961,5,31,0,0,961,962,6,51,-1,0,962,983,1,0,0,0,963,964,5,282,0,0,964,965, + 3,32,16,0,965,966,6,51,-1,0,966,983,1,0,0,0,967,968,5,282,0,0,968,969, + 3,0,0,0,969,970,6,51,-1,0,970,983,1,0,0,0,971,972,5,285,0,0,972,973,5, + 84,0,0,973,974,5,30,0,0,974,975,3,292,146,0,975,976,5,31,0,0,976,977,6, + 51,-1,0,977,983,1,0,0,0,978,979,5,287,0,0,979,980,3,32,16,0,980,981,6, + 51,-1,0,981,983,1,0,0,0,982,932,1,0,0,0,982,934,1,0,0,0,982,938,1,0,0, + 0,982,942,1,0,0,0,982,946,1,0,0,0,982,950,1,0,0,0,982,956,1,0,0,0,982, + 963,1,0,0,0,982,967,1,0,0,0,982,971,1,0,0,0,982,978,1,0,0,0,983,103,1, + 0,0,0,984,985,5,279,0,0,985,1019,3,36,18,0,986,987,5,279,0,0,987,1019, + 3,34,17,0,988,989,5,280,0,0,989,1019,3,168,84,0,990,991,5,286,0,0,991, + 1019,3,178,89,0,992,993,5,286,0,0,993,1019,3,174,87,0,994,995,5,284,0, + 0,995,1019,3,124,62,0,996,997,5,285,0,0,997,1019,3,6,3,0,998,999,5,285, + 0,0,999,1000,5,224,0,0,1000,1001,5,30,0,0,1001,1002,3,6,3,0,1002,1003, + 5,31,0,0,1003,1019,1,0,0,0,1004,1005,5,281,0,0,1005,1006,3,170,85,0,1006, + 1007,3,138,69,0,1007,1008,3,112,56,0,1008,1019,1,0,0,0,1009,1010,5,287, + 0,0,1010,1019,3,50,25,0,1011,1012,5,283,0,0,1012,1013,5,30,0,0,1013,1014, + 3,106,53,0,1014,1015,5,31,0,0,1015,1019,1,0,0,0,1016,1017,5,283,0,0,1017, + 1019,5,85,0,0,1018,984,1,0,0,0,1018,986,1,0,0,0,1018,988,1,0,0,0,1018, + 990,1,0,0,0,1018,992,1,0,0,0,1018,994,1,0,0,0,1018,996,1,0,0,0,1018,998, + 1,0,0,0,1018,1004,1,0,0,0,1018,1009,1,0,0,0,1018,1011,1,0,0,0,1018,1016, + 1,0,0,0,1019,105,1,0,0,0,1020,1037,1,0,0,0,1021,1024,3,0,0,0,1022,1024, + 3,32,16,0,1023,1021,1,0,0,0,1023,1022,1,0,0,0,1024,1025,1,0,0,0,1025,1026, + 5,28,0,0,1026,1028,1,0,0,0,1027,1023,1,0,0,0,1028,1031,1,0,0,0,1029,1027, + 1,0,0,0,1029,1030,1,0,0,0,1030,1034,1,0,0,0,1031,1029,1,0,0,0,1032,1035, + 3,0,0,0,1033,1035,3,32,16,0,1034,1032,1,0,0,0,1034,1033,1,0,0,0,1035,1037, + 1,0,0,0,1036,1020,1,0,0,0,1036,1029,1,0,0,0,1037,107,1,0,0,0,1038,1044, + 5,86,0,0,1039,1040,3,138,69,0,1040,1041,5,28,0,0,1041,1043,1,0,0,0,1042, + 1039,1,0,0,0,1043,1046,1,0,0,0,1044,1042,1,0,0,0,1044,1045,1,0,0,0,1045, + 1047,1,0,0,0,1046,1044,1,0,0,0,1047,1048,3,138,69,0,1048,1049,5,87,0,0, + 1049,109,1,0,0,0,1050,1056,5,42,0,0,1051,1052,3,146,73,0,1052,1053,5,28, + 0,0,1053,1055,1,0,0,0,1054,1051,1,0,0,0,1055,1058,1,0,0,0,1056,1054,1, + 0,0,0,1056,1057,1,0,0,0,1057,1059,1,0,0,0,1058,1056,1,0,0,0,1059,1060, + 3,146,73,0,1060,1061,5,43,0,0,1061,111,1,0,0,0,1062,1068,5,30,0,0,1063, + 1064,3,114,57,0,1064,1065,5,28,0,0,1065,1067,1,0,0,0,1066,1063,1,0,0,0, + 1067,1070,1,0,0,0,1068,1066,1,0,0,0,1068,1069,1,0,0,0,1069,1071,1,0,0, + 0,1070,1068,1,0,0,0,1071,1072,3,114,57,0,1072,1073,5,31,0,0,1073,1076, + 1,0,0,0,1074,1076,5,85,0,0,1075,1062,1,0,0,0,1075,1074,1,0,0,0,1076,113, + 1,0,0,0,1077,1085,5,177,0,0,1078,1079,3,230,115,0,1079,1080,3,138,69,0, + 1080,1082,3,226,113,0,1081,1083,3,0,0,0,1082,1081,1,0,0,0,1082,1083,1, + 0,0,0,1083,1085,1,0,0,0,1084,1077,1,0,0,0,1084,1078,1,0,0,0,1085,115,1, + 0,0,0,1086,1087,5,42,0,0,1087,1088,3,2,1,0,1088,1089,5,43,0,0,1089,1090, + 3,118,59,0,1090,1112,1,0,0,0,1091,1092,5,42,0,0,1092,1093,3,174,87,0,1093, + 1094,5,43,0,0,1094,1095,3,118,59,0,1095,1112,1,0,0,0,1096,1097,5,42,0, + 0,1097,1098,5,262,0,0,1098,1099,5,43,0,0,1099,1112,3,118,59,0,1100,1101, + 5,42,0,0,1101,1102,5,198,0,0,1102,1103,3,2,1,0,1103,1104,5,43,0,0,1104, + 1105,3,118,59,0,1105,1112,1,0,0,0,1106,1112,3,118,59,0,1107,1112,3,174, + 87,0,1108,1112,5,257,0,0,1109,1112,5,258,0,0,1110,1112,5,259,0,0,1111, + 1086,1,0,0,0,1111,1091,1,0,0,0,1111,1096,1,0,0,0,1111,1100,1,0,0,0,1111, + 1106,1,0,0,0,1111,1107,1,0,0,0,1111,1108,1,0,0,0,1111,1109,1,0,0,0,1111, + 1110,1,0,0,0,1112,117,1,0,0,0,1113,1114,3,2,1,0,1114,1115,5,88,0,0,1115, + 1117,1,0,0,0,1116,1113,1,0,0,0,1117,1120,1,0,0,0,1118,1116,1,0,0,0,1118, + 1119,1,0,0,0,1119,1121,1,0,0,0,1120,1118,1,0,0,0,1121,1122,3,2,1,0,1122, + 119,1,0,0,0,1123,1125,3,122,61,0,1124,1123,1,0,0,0,1125,1128,1,0,0,0,1126, + 1124,1,0,0,0,1126,1127,1,0,0,0,1127,121,1,0,0,0,1128,1126,1,0,0,0,1129, + 1130,5,180,0,0,1130,1131,5,89,0,0,1131,1135,3,32,16,0,1132,1135,3,152, + 76,0,1133,1135,3,324,162,0,1134,1129,1,0,0,0,1134,1132,1,0,0,0,1134,1133, + 1,0,0,0,1135,123,1,0,0,0,1136,1148,3,116,58,0,1137,1138,5,42,0,0,1138, + 1139,3,2,1,0,1139,1140,5,43,0,0,1140,1148,1,0,0,0,1141,1142,5,42,0,0,1142, + 1143,5,198,0,0,1143,1144,3,2,1,0,1144,1145,5,43,0,0,1145,1148,1,0,0,0, + 1146,1148,3,138,69,0,1147,1136,1,0,0,0,1147,1137,1,0,0,0,1147,1141,1,0, + 0,0,1147,1146,1,0,0,0,1148,125,1,0,0,0,1149,1158,1,0,0,0,1150,1154,3,130, + 65,0,1151,1153,3,128,64,0,1152,1151,1,0,0,0,1153,1156,1,0,0,0,1154,1152, + 1,0,0,0,1154,1155,1,0,0,0,1155,1158,1,0,0,0,1156,1154,1,0,0,0,1157,1149, + 1,0,0,0,1157,1150,1,0,0,0,1158,127,1,0,0,0,1159,1177,5,262,0,0,1160,1177, + 5,261,0,0,1161,1162,5,42,0,0,1162,1163,3,32,16,0,1163,1164,5,43,0,0,1164, + 1177,1,0,0,0,1165,1166,5,42,0,0,1166,1167,3,32,16,0,1167,1168,5,266,0, + 0,1168,1169,3,32,16,0,1169,1170,5,43,0,0,1170,1177,1,0,0,0,1171,1172,5, + 42,0,0,1172,1173,5,266,0,0,1173,1174,3,32,16,0,1174,1175,5,43,0,0,1175, + 1177,1,0,0,0,1176,1159,1,0,0,0,1176,1160,1,0,0,0,1176,1161,1,0,0,0,1176, + 1165,1,0,0,0,1176,1171,1,0,0,0,1177,129,1,0,0,0,1178,1271,1,0,0,0,1179, + 1180,5,203,0,0,1180,1181,5,30,0,0,1181,1182,3,6,3,0,1182,1183,5,28,0,0, + 1183,1184,3,6,3,0,1184,1185,5,28,0,0,1185,1186,3,6,3,0,1186,1187,5,28, + 0,0,1187,1188,3,6,3,0,1188,1189,5,31,0,0,1189,1271,1,0,0,0,1190,1191,5, + 203,0,0,1191,1192,5,30,0,0,1192,1193,3,6,3,0,1193,1194,5,28,0,0,1194,1195, + 3,6,3,0,1195,1196,5,31,0,0,1196,1271,1,0,0,0,1197,1198,5,204,0,0,1198, + 1199,5,205,0,0,1199,1200,5,42,0,0,1200,1201,3,32,16,0,1201,1202,5,43,0, + 0,1202,1271,1,0,0,0,1203,1204,5,204,0,0,1204,1205,5,206,0,0,1205,1206, + 5,42,0,0,1206,1207,3,32,16,0,1207,1208,5,43,0,0,1208,1209,3,126,63,0,1209, + 1271,1,0,0,0,1210,1271,5,207,0,0,1211,1271,5,208,0,0,1212,1271,5,209,0, + 0,1213,1271,5,201,0,0,1214,1271,5,183,0,0,1215,1271,5,184,0,0,1216,1271, + 5,185,0,0,1217,1271,5,186,0,0,1218,1271,5,187,0,0,1219,1271,5,188,0,0, + 1220,1271,5,189,0,0,1221,1271,5,210,0,0,1222,1271,5,190,0,0,1223,1271, + 5,191,0,0,1224,1271,5,192,0,0,1225,1271,5,193,0,0,1226,1271,5,211,0,0, + 1227,1271,5,212,0,0,1228,1271,5,213,0,0,1229,1271,5,214,0,0,1230,1271, + 5,215,0,0,1231,1271,5,216,0,0,1232,1271,5,217,0,0,1233,1234,5,218,0,0, + 1234,1271,3,132,66,0,1235,1236,5,219,0,0,1236,1271,3,132,66,0,1237,1271, + 5,220,0,0,1238,1239,5,221,0,0,1239,1271,3,132,66,0,1240,1241,5,222,0,0, + 1241,1271,3,134,67,0,1242,1243,5,222,0,0,1243,1244,3,134,67,0,1244,1245, + 5,28,0,0,1245,1246,3,6,3,0,1246,1271,1,0,0,0,1247,1271,5,194,0,0,1248, + 1271,5,195,0,0,1249,1250,5,90,0,0,1250,1271,5,184,0,0,1251,1252,5,90,0, + 0,1252,1271,5,185,0,0,1253,1254,5,90,0,0,1254,1271,5,186,0,0,1255,1256, + 5,90,0,0,1256,1271,5,187,0,0,1257,1258,5,62,0,0,1258,1271,5,220,0,0,1259, + 1271,5,223,0,0,1260,1261,5,224,0,0,1261,1271,5,213,0,0,1262,1271,5,225, + 0,0,1263,1264,5,207,0,0,1264,1271,5,183,0,0,1265,1271,5,226,0,0,1266,1271, + 5,228,0,0,1267,1268,5,34,0,0,1268,1271,5,227,0,0,1269,1271,3,2,1,0,1270, + 1178,1,0,0,0,1270,1179,1,0,0,0,1270,1190,1,0,0,0,1270,1197,1,0,0,0,1270, + 1203,1,0,0,0,1270,1210,1,0,0,0,1270,1211,1,0,0,0,1270,1212,1,0,0,0,1270, + 1213,1,0,0,0,1270,1214,1,0,0,0,1270,1215,1,0,0,0,1270,1216,1,0,0,0,1270, + 1217,1,0,0,0,1270,1218,1,0,0,0,1270,1219,1,0,0,0,1270,1220,1,0,0,0,1270, + 1221,1,0,0,0,1270,1222,1,0,0,0,1270,1223,1,0,0,0,1270,1224,1,0,0,0,1270, + 1225,1,0,0,0,1270,1226,1,0,0,0,1270,1227,1,0,0,0,1270,1228,1,0,0,0,1270, + 1229,1,0,0,0,1270,1230,1,0,0,0,1270,1231,1,0,0,0,1270,1232,1,0,0,0,1270, + 1233,1,0,0,0,1270,1235,1,0,0,0,1270,1237,1,0,0,0,1270,1238,1,0,0,0,1270, + 1240,1,0,0,0,1270,1242,1,0,0,0,1270,1247,1,0,0,0,1270,1248,1,0,0,0,1270, + 1249,1,0,0,0,1270,1251,1,0,0,0,1270,1253,1,0,0,0,1270,1255,1,0,0,0,1270, + 1257,1,0,0,0,1270,1259,1,0,0,0,1270,1260,1,0,0,0,1270,1262,1,0,0,0,1270, + 1263,1,0,0,0,1270,1265,1,0,0,0,1270,1266,1,0,0,0,1270,1267,1,0,0,0,1270, + 1269,1,0,0,0,1271,131,1,0,0,0,1272,1280,1,0,0,0,1273,1274,5,30,0,0,1274, + 1275,5,91,0,0,1275,1276,5,36,0,0,1276,1277,3,32,16,0,1277,1278,5,31,0, + 0,1278,1280,1,0,0,0,1279,1272,1,0,0,0,1279,1273,1,0,0,0,1280,133,1,0,0, + 0,1281,1290,1,0,0,0,1282,1286,3,136,68,0,1283,1285,7,7,0,0,1284,1283,1, + 0,0,0,1285,1288,1,0,0,0,1286,1284,1,0,0,0,1286,1287,1,0,0,0,1287,1290, + 1,0,0,0,1288,1286,1,0,0,0,1289,1281,1,0,0,0,1289,1282,1,0,0,0,1290,135, + 1,0,0,0,1291,1292,7,8,0,0,1292,137,1,0,0,0,1293,1297,3,142,71,0,1294,1296, + 3,140,70,0,1295,1294,1,0,0,0,1296,1299,1,0,0,0,1297,1295,1,0,0,0,1297, + 1298,1,0,0,0,1298,139,1,0,0,0,1299,1297,1,0,0,0,1300,1319,5,261,0,0,1301, + 1302,5,42,0,0,1302,1319,5,43,0,0,1303,1319,3,110,55,0,1304,1319,5,260, + 0,0,1305,1319,5,262,0,0,1306,1319,5,92,0,0,1307,1308,5,93,0,0,1308,1309, + 5,30,0,0,1309,1310,3,124,62,0,1310,1311,5,31,0,0,1311,1319,1,0,0,0,1312, + 1313,5,94,0,0,1313,1314,5,30,0,0,1314,1315,3,124,62,0,1315,1316,5,31,0, + 0,1316,1319,1,0,0,0,1317,1319,3,108,54,0,1318,1300,1,0,0,0,1318,1301,1, + 0,0,0,1318,1303,1,0,0,0,1318,1304,1,0,0,0,1318,1305,1,0,0,0,1318,1306, + 1,0,0,0,1318,1307,1,0,0,0,1318,1312,1,0,0,0,1318,1317,1,0,0,0,1319,141, + 1,0,0,0,1320,1321,5,39,0,0,1321,1351,3,116,58,0,1322,1351,5,197,0,0,1323, + 1324,5,199,0,0,1324,1325,5,39,0,0,1325,1351,3,116,58,0,1326,1327,5,200, + 0,0,1327,1351,3,116,58,0,1328,1329,5,226,0,0,1329,1330,3,170,85,0,1330, + 1331,3,138,69,0,1331,1332,5,262,0,0,1332,1333,3,112,56,0,1333,1351,1,0, + 0,0,1334,1335,5,253,0,0,1335,1351,3,32,16,0,1336,1337,5,252,0,0,1337,1351, + 3,32,16,0,1338,1339,5,253,0,0,1339,1351,3,2,1,0,1340,1341,5,252,0,0,1341, + 1351,3,2,1,0,1342,1351,5,254,0,0,1343,1351,5,201,0,0,1344,1351,3,148,74, + 0,1345,1351,3,150,75,0,1346,1351,3,144,72,0,1347,1351,3,2,1,0,1348,1349, + 5,177,0,0,1349,1351,3,138,69,0,1350,1320,1,0,0,0,1350,1322,1,0,0,0,1350, + 1323,1,0,0,0,1350,1326,1,0,0,0,1350,1328,1,0,0,0,1350,1334,1,0,0,0,1350, + 1336,1,0,0,0,1350,1338,1,0,0,0,1350,1340,1,0,0,0,1350,1342,1,0,0,0,1350, + 1343,1,0,0,0,1350,1344,1,0,0,0,1350,1345,1,0,0,0,1350,1346,1,0,0,0,1350, + 1347,1,0,0,0,1350,1348,1,0,0,0,1351,143,1,0,0,0,1352,1374,5,181,0,0,1353, + 1374,5,182,0,0,1354,1374,5,183,0,0,1355,1374,5,184,0,0,1356,1374,5,185, + 0,0,1357,1374,5,186,0,0,1358,1374,5,187,0,0,1359,1374,5,188,0,0,1360,1374, + 5,189,0,0,1361,1374,5,190,0,0,1362,1374,5,191,0,0,1363,1374,5,192,0,0, + 1364,1374,5,193,0,0,1365,1366,5,90,0,0,1366,1374,5,184,0,0,1367,1368,5, + 90,0,0,1368,1374,5,185,0,0,1369,1370,5,90,0,0,1370,1374,5,186,0,0,1371, + 1372,5,90,0,0,1372,1374,5,187,0,0,1373,1352,1,0,0,0,1373,1353,1,0,0,0, + 1373,1354,1,0,0,0,1373,1355,1,0,0,0,1373,1356,1,0,0,0,1373,1357,1,0,0, + 0,1373,1358,1,0,0,0,1373,1359,1,0,0,0,1373,1360,1,0,0,0,1373,1361,1,0, + 0,0,1373,1362,1,0,0,0,1373,1363,1,0,0,0,1373,1364,1,0,0,0,1373,1365,1, + 0,0,0,1373,1367,1,0,0,0,1373,1369,1,0,0,0,1373,1371,1,0,0,0,1374,145,1, + 0,0,0,1375,1386,1,0,0,0,1376,1386,5,177,0,0,1377,1386,3,32,16,0,1378,1379, + 3,32,16,0,1379,1380,5,177,0,0,1380,1381,3,32,16,0,1381,1386,1,0,0,0,1382, + 1383,3,32,16,0,1383,1384,5,177,0,0,1384,1386,1,0,0,0,1385,1375,1,0,0,0, + 1385,1376,1,0,0,0,1385,1377,1,0,0,0,1385,1378,1,0,0,0,1385,1382,1,0,0, + 0,1386,147,1,0,0,0,1387,1388,5,1,0,0,1388,1389,5,194,0,0,1389,149,1,0, + 0,0,1390,1394,5,1,0,0,1391,1392,5,90,0,0,1392,1395,5,194,0,0,1393,1395, + 5,195,0,0,1394,1391,1,0,0,0,1394,1393,1,0,0,0,1395,151,1,0,0,0,1396,1397, + 5,294,0,0,1397,1398,3,166,83,0,1398,1399,3,124,62,0,1399,1400,5,30,0,0, + 1400,1401,3,158,79,0,1401,1402,5,31,0,0,1402,1444,1,0,0,0,1403,1404,5, + 294,0,0,1404,1405,3,166,83,0,1405,1406,3,124,62,0,1406,1407,5,36,0,0,1407, + 1408,5,17,0,0,1408,1409,3,52,26,0,1409,1410,5,18,0,0,1410,1444,1,0,0,0, + 1411,1412,5,294,0,0,1412,1413,3,166,83,0,1413,1414,3,124,62,0,1414,1444, + 1,0,0,0,1415,1416,5,295,0,0,1416,1417,3,166,83,0,1417,1419,5,36,0,0,1418, + 1420,5,84,0,0,1419,1418,1,0,0,0,1419,1420,1,0,0,0,1420,1421,1,0,0,0,1421, + 1422,5,30,0,0,1422,1423,3,292,146,0,1423,1424,5,31,0,0,1424,1444,1,0,0, + 0,1425,1426,5,295,0,0,1426,1427,3,166,83,0,1427,1428,5,84,0,0,1428,1429, + 5,30,0,0,1429,1430,3,292,146,0,1430,1431,5,31,0,0,1431,1444,1,0,0,0,1432, + 1433,5,295,0,0,1433,1434,3,166,83,0,1434,1435,3,6,3,0,1435,1444,1,0,0, + 0,1436,1437,5,295,0,0,1437,1438,3,166,83,0,1438,1439,5,36,0,0,1439,1440, + 5,17,0,0,1440,1441,3,154,77,0,1441,1442,5,18,0,0,1442,1444,1,0,0,0,1443, + 1396,1,0,0,0,1443,1403,1,0,0,0,1443,1411,1,0,0,0,1443,1415,1,0,0,0,1443, + 1425,1,0,0,0,1443,1432,1,0,0,0,1443,1436,1,0,0,0,1444,153,1,0,0,0,1445, + 1456,1,0,0,0,1446,1447,3,156,78,0,1447,1448,5,28,0,0,1448,1450,1,0,0,0, + 1449,1446,1,0,0,0,1450,1453,1,0,0,0,1451,1449,1,0,0,0,1451,1452,1,0,0, + 0,1452,1454,1,0,0,0,1453,1451,1,0,0,0,1454,1456,3,156,78,0,1455,1445,1, + 0,0,0,1455,1451,1,0,0,0,1456,155,1,0,0,0,1457,1458,5,39,0,0,1458,1459, + 5,264,0,0,1459,1460,5,36,0,0,1460,1461,5,17,0,0,1461,1462,3,56,28,0,1462, + 1463,5,18,0,0,1463,1471,1,0,0,0,1464,1465,3,124,62,0,1465,1466,5,36,0, + 0,1466,1467,5,17,0,0,1467,1468,3,56,28,0,1468,1469,5,18,0,0,1469,1471, + 1,0,0,0,1470,1457,1,0,0,0,1470,1464,1,0,0,0,1471,157,1,0,0,0,1472,1473, + 3,160,80,0,1473,1474,5,28,0,0,1474,1476,1,0,0,0,1475,1472,1,0,0,0,1476, + 1479,1,0,0,0,1477,1475,1,0,0,0,1477,1478,1,0,0,0,1478,1480,1,0,0,0,1479, + 1477,1,0,0,0,1480,1481,3,160,80,0,1481,159,1,0,0,0,1482,1483,3,6,3,0,1483, + 1484,5,36,0,0,1484,1485,3,164,82,0,1485,161,1,0,0,0,1486,1487,7,9,0,0, + 1487,163,1,0,0,0,1488,1523,3,162,81,0,1489,1523,3,32,16,0,1490,1491,5, + 186,0,0,1491,1492,5,30,0,0,1492,1493,3,32,16,0,1493,1494,5,31,0,0,1494, + 1523,1,0,0,0,1495,1523,3,6,3,0,1496,1497,3,116,58,0,1497,1498,5,30,0,0, + 1498,1499,5,184,0,0,1499,1500,5,75,0,0,1500,1501,3,32,16,0,1501,1502,5, + 31,0,0,1502,1523,1,0,0,0,1503,1504,3,116,58,0,1504,1505,5,30,0,0,1505, + 1506,5,185,0,0,1506,1507,5,75,0,0,1507,1508,3,32,16,0,1508,1509,5,31,0, + 0,1509,1523,1,0,0,0,1510,1511,3,116,58,0,1511,1512,5,30,0,0,1512,1513, + 5,186,0,0,1513,1514,5,75,0,0,1514,1515,3,32,16,0,1515,1516,5,31,0,0,1516, + 1523,1,0,0,0,1517,1518,3,116,58,0,1518,1519,5,30,0,0,1519,1520,3,32,16, + 0,1520,1521,5,31,0,0,1521,1523,1,0,0,0,1522,1488,1,0,0,0,1522,1489,1,0, + 0,0,1522,1490,1,0,0,0,1522,1495,1,0,0,0,1522,1496,1,0,0,0,1522,1503,1, + 0,0,0,1522,1510,1,0,0,0,1522,1517,1,0,0,0,1523,165,1,0,0,0,1524,1525,7, + 10,0,0,1525,167,1,0,0,0,1526,1527,3,170,85,0,1527,1528,3,138,69,0,1528, + 1529,3,124,62,0,1529,1530,5,176,0,0,1530,1532,3,242,121,0,1531,1533,3, + 108,54,0,1532,1531,1,0,0,0,1532,1533,1,0,0,0,1533,1534,1,0,0,0,1534,1535, + 3,112,56,0,1535,1561,1,0,0,0,1536,1537,3,170,85,0,1537,1538,3,138,69,0, + 1538,1539,3,124,62,0,1539,1540,5,176,0,0,1540,1541,3,242,121,0,1541,1542, + 3,196,98,0,1542,1543,3,112,56,0,1543,1561,1,0,0,0,1544,1545,3,170,85,0, + 1545,1546,3,138,69,0,1546,1548,3,242,121,0,1547,1549,3,108,54,0,1548,1547, + 1,0,0,0,1548,1549,1,0,0,0,1549,1550,1,0,0,0,1550,1551,3,112,56,0,1551, + 1561,1,0,0,0,1552,1553,3,170,85,0,1553,1554,3,138,69,0,1554,1555,3,242, + 121,0,1555,1556,3,196,98,0,1556,1557,3,112,56,0,1557,1561,1,0,0,0,1558, + 1561,3,174,87,0,1559,1561,3,2,1,0,1560,1526,1,0,0,0,1560,1536,1,0,0,0, + 1560,1544,1,0,0,0,1560,1552,1,0,0,0,1560,1558,1,0,0,0,1560,1559,1,0,0, + 0,1561,169,1,0,0,0,1562,1563,5,243,0,0,1563,1573,3,170,85,0,1564,1565, + 5,244,0,0,1565,1573,3,170,85,0,1566,1573,3,172,86,0,1567,1568,5,112,0, + 0,1568,1569,5,30,0,0,1569,1570,3,32,16,0,1570,1571,5,31,0,0,1571,1573, + 1,0,0,0,1572,1562,1,0,0,0,1572,1564,1,0,0,0,1572,1566,1,0,0,0,1572,1567, + 1,0,0,0,1573,171,1,0,0,0,1574,1587,1,0,0,0,1575,1587,5,245,0,0,1576,1587, + 5,246,0,0,1577,1578,5,247,0,0,1578,1587,5,248,0,0,1579,1580,5,247,0,0, + 1580,1587,5,249,0,0,1581,1582,5,247,0,0,1582,1587,5,250,0,0,1583,1584, + 5,247,0,0,1584,1587,5,251,0,0,1585,1587,5,247,0,0,1586,1574,1,0,0,0,1586, + 1575,1,0,0,0,1586,1576,1,0,0,0,1586,1577,1,0,0,0,1586,1579,1,0,0,0,1586, + 1581,1,0,0,0,1586,1583,1,0,0,0,1586,1585,1,0,0,0,1587,173,1,0,0,0,1588, + 1589,5,113,0,0,1589,1590,5,30,0,0,1590,1591,3,32,16,0,1591,1592,5,31,0, + 0,1592,175,1,0,0,0,1593,1594,5,226,0,0,1594,1599,3,168,84,0,1595,1596, + 5,37,0,0,1596,1599,3,178,89,0,1597,1599,3,174,87,0,1598,1593,1,0,0,0,1598, + 1595,1,0,0,0,1598,1597,1,0,0,0,1599,177,1,0,0,0,1600,1601,3,138,69,0,1601, + 1602,3,124,62,0,1602,1603,5,176,0,0,1603,1604,3,2,1,0,1604,1610,1,0,0, + 0,1605,1606,3,138,69,0,1606,1607,3,2,1,0,1607,1610,1,0,0,0,1608,1610,3, + 2,1,0,1609,1600,1,0,0,0,1609,1605,1,0,0,0,1609,1608,1,0,0,0,1610,179,1, + 0,0,0,1611,1612,3,124,62,0,1612,1613,5,28,0,0,1613,1615,1,0,0,0,1614,1611, + 1,0,0,0,1615,1618,1,0,0,0,1616,1614,1,0,0,0,1616,1617,1,0,0,0,1617,1619, + 1,0,0,0,1618,1616,1,0,0,0,1619,1620,3,124,62,0,1620,181,1,0,0,0,1621,1627, + 1,0,0,0,1622,1623,5,86,0,0,1623,1624,3,190,95,0,1624,1625,5,87,0,0,1625, + 1627,1,0,0,0,1626,1621,1,0,0,0,1626,1622,1,0,0,0,1627,183,1,0,0,0,1628, + 1640,5,266,0,0,1629,1640,5,114,0,0,1630,1640,5,39,0,0,1631,1640,5,200, + 0,0,1632,1640,5,115,0,0,1633,1640,5,116,0,0,1634,1635,5,70,0,0,1635,1636, + 5,30,0,0,1636,1637,3,32,16,0,1637,1638,5,31,0,0,1638,1640,1,0,0,0,1639, + 1628,1,0,0,0,1639,1629,1,0,0,0,1639,1630,1,0,0,0,1639,1631,1,0,0,0,1639, + 1632,1,0,0,0,1639,1633,1,0,0,0,1639,1634,1,0,0,0,1640,185,1,0,0,0,1641, + 1643,3,184,92,0,1642,1641,1,0,0,0,1643,1646,1,0,0,0,1644,1642,1,0,0,0, + 1644,1645,1,0,0,0,1645,187,1,0,0,0,1646,1644,1,0,0,0,1647,1649,3,186,93, + 0,1648,1650,3,192,96,0,1649,1648,1,0,0,0,1649,1650,1,0,0,0,1650,1651,1, + 0,0,0,1651,1652,3,2,1,0,1652,189,1,0,0,0,1653,1654,3,188,94,0,1654,1655, + 5,28,0,0,1655,1657,1,0,0,0,1656,1653,1,0,0,0,1657,1660,1,0,0,0,1658,1656, + 1,0,0,0,1658,1659,1,0,0,0,1659,1661,1,0,0,0,1660,1658,1,0,0,0,1661,1662, + 3,188,94,0,1662,191,1,0,0,0,1663,1664,5,30,0,0,1664,1665,3,180,90,0,1665, + 1666,5,31,0,0,1666,193,1,0,0,0,1667,1670,1,0,0,0,1668,1670,3,196,98,0, + 1669,1667,1,0,0,0,1669,1668,1,0,0,0,1670,195,1,0,0,0,1671,1672,5,86,0, + 0,1672,1673,5,42,0,0,1673,1674,3,32,16,0,1674,1675,5,43,0,0,1675,1676, + 5,87,0,0,1676,197,1,0,0,0,1677,1678,3,234,117,0,1678,1679,5,17,0,0,1679, + 1680,3,246,123,0,1680,1681,5,18,0,0,1681,1794,1,0,0,0,1682,1683,3,74,37, + 0,1683,1684,5,17,0,0,1684,1685,3,82,41,0,1685,1686,5,18,0,0,1686,1794, + 1,0,0,0,1687,1688,3,210,105,0,1688,1689,5,17,0,0,1689,1690,3,214,107,0, + 1690,1691,5,18,0,0,1691,1794,1,0,0,0,1692,1693,3,218,109,0,1693,1694,5, + 17,0,0,1694,1695,3,222,111,0,1695,1696,5,18,0,0,1696,1794,1,0,0,0,1697, + 1794,3,200,100,0,1698,1794,3,276,138,0,1699,1794,3,152,76,0,1700,1794, + 3,88,44,0,1701,1794,3,322,161,0,1702,1703,5,117,0,0,1703,1794,3,32,16, + 0,1704,1705,5,118,0,0,1705,1794,3,32,16,0,1706,1707,3,334,167,0,1707,1708, + 5,17,0,0,1708,1709,3,338,169,0,1709,1710,5,18,0,0,1710,1794,1,0,0,0,1711, + 1712,5,302,0,0,1712,1713,3,124,62,0,1713,1714,5,176,0,0,1714,1715,3,242, + 121,0,1715,1716,5,119,0,0,1716,1717,3,170,85,0,1717,1718,3,138,69,0,1718, + 1719,3,124,62,0,1719,1720,5,176,0,0,1720,1721,3,242,121,0,1721,1722,3, + 112,56,0,1722,1794,1,0,0,0,1723,1724,5,302,0,0,1724,1725,5,226,0,0,1725, + 1726,3,170,85,0,1726,1727,3,138,69,0,1727,1728,3,124,62,0,1728,1729,5, + 176,0,0,1729,1730,3,242,121,0,1730,1731,3,194,97,0,1731,1732,3,112,56, + 0,1732,1733,5,119,0,0,1733,1734,5,226,0,0,1734,1735,3,170,85,0,1735,1736, + 3,138,69,0,1736,1737,3,124,62,0,1737,1738,5,176,0,0,1738,1739,3,242,121, + 0,1739,1740,3,194,97,0,1740,1741,3,112,56,0,1741,1794,1,0,0,0,1742,1794, + 3,26,13,0,1743,1794,3,40,20,0,1744,1745,5,255,0,0,1745,1746,5,196,0,0, + 1746,1747,5,42,0,0,1747,1748,3,32,16,0,1748,1752,5,43,0,0,1749,1751,3, + 322,161,0,1750,1749,1,0,0,0,1751,1754,1,0,0,0,1752,1750,1,0,0,0,1752,1753, + 1,0,0,0,1753,1794,1,0,0,0,1754,1752,1,0,0,0,1755,1756,5,255,0,0,1756,1757, + 5,196,0,0,1757,1761,3,2,1,0,1758,1760,3,322,161,0,1759,1758,1,0,0,0,1760, + 1763,1,0,0,0,1761,1759,1,0,0,0,1761,1762,1,0,0,0,1762,1794,1,0,0,0,1763, + 1761,1,0,0,0,1764,1765,5,255,0,0,1765,1766,5,256,0,0,1766,1767,5,42,0, + 0,1767,1768,3,32,16,0,1768,1769,5,43,0,0,1769,1770,5,28,0,0,1770,1774, + 3,124,62,0,1771,1773,3,322,161,0,1772,1771,1,0,0,0,1773,1776,1,0,0,0,1774, + 1772,1,0,0,0,1774,1775,1,0,0,0,1775,1794,1,0,0,0,1776,1774,1,0,0,0,1777, + 1778,5,255,0,0,1778,1779,5,256,0,0,1779,1780,3,2,1,0,1780,1781,5,28,0, + 0,1781,1785,3,124,62,0,1782,1784,3,322,161,0,1783,1782,1,0,0,0,1784,1787, + 1,0,0,0,1785,1783,1,0,0,0,1785,1786,1,0,0,0,1786,1794,1,0,0,0,1787,1785, + 1,0,0,0,1788,1789,5,120,0,0,1789,1790,5,196,0,0,1790,1791,3,124,62,0,1791, + 1792,3,44,22,0,1792,1794,1,0,0,0,1793,1677,1,0,0,0,1793,1682,1,0,0,0,1793, + 1687,1,0,0,0,1793,1692,1,0,0,0,1793,1697,1,0,0,0,1793,1698,1,0,0,0,1793, + 1699,1,0,0,0,1793,1700,1,0,0,0,1793,1701,1,0,0,0,1793,1702,1,0,0,0,1793, + 1704,1,0,0,0,1793,1706,1,0,0,0,1793,1711,1,0,0,0,1793,1723,1,0,0,0,1793, + 1742,1,0,0,0,1793,1743,1,0,0,0,1793,1744,1,0,0,0,1793,1755,1,0,0,0,1793, + 1764,1,0,0,0,1793,1777,1,0,0,0,1793,1788,1,0,0,0,1794,199,1,0,0,0,1795, + 1796,5,121,0,0,1796,1805,3,208,104,0,1797,1804,3,202,101,0,1798,1799,5, + 122,0,0,1799,1800,5,30,0,0,1800,1801,3,228,114,0,1801,1802,5,31,0,0,1802, + 1804,1,0,0,0,1803,1797,1,0,0,0,1803,1798,1,0,0,0,1804,1807,1,0,0,0,1805, + 1803,1,0,0,0,1805,1806,1,0,0,0,1806,1808,1,0,0,0,1807,1805,1,0,0,0,1808, + 1809,3,138,69,0,1809,1810,3,2,1,0,1810,1811,3,204,102,0,1811,1812,3,206, + 103,0,1812,201,1,0,0,0,1813,1833,5,123,0,0,1814,1833,5,51,0,0,1815,1833, + 5,52,0,0,1816,1833,5,63,0,0,1817,1833,5,124,0,0,1818,1833,5,69,0,0,1819, + 1833,5,68,0,0,1820,1833,5,64,0,0,1821,1833,5,65,0,0,1822,1833,5,66,0,0, + 1823,1833,5,125,0,0,1824,1833,5,126,0,0,1825,1833,5,127,0,0,1826,1833, + 5,16,0,0,1827,1828,5,70,0,0,1828,1829,5,30,0,0,1829,1830,3,32,16,0,1830, + 1831,5,31,0,0,1831,1833,1,0,0,0,1832,1813,1,0,0,0,1832,1814,1,0,0,0,1832, + 1815,1,0,0,0,1832,1816,1,0,0,0,1832,1817,1,0,0,0,1832,1818,1,0,0,0,1832, + 1819,1,0,0,0,1832,1820,1,0,0,0,1832,1821,1,0,0,0,1832,1822,1,0,0,0,1832, + 1823,1,0,0,0,1832,1824,1,0,0,0,1832,1825,1,0,0,0,1832,1826,1,0,0,0,1832, + 1827,1,0,0,0,1833,203,1,0,0,0,1834,1840,1,0,0,0,1835,1836,5,44,0,0,1836, + 1840,3,0,0,0,1837,1838,5,44,0,0,1838,1840,3,32,16,0,1839,1834,1,0,0,0, + 1839,1835,1,0,0,0,1839,1837,1,0,0,0,1840,205,1,0,0,0,1841,1845,1,0,0,0, + 1842,1843,5,36,0,0,1843,1845,3,296,148,0,1844,1841,1,0,0,0,1844,1842,1, + 0,0,0,1845,207,1,0,0,0,1846,1852,1,0,0,0,1847,1848,5,42,0,0,1848,1849, + 3,32,16,0,1849,1850,5,43,0,0,1850,1852,1,0,0,0,1851,1846,1,0,0,0,1851, + 1847,1,0,0,0,1852,209,1,0,0,0,1853,1857,5,128,0,0,1854,1856,3,212,106, + 0,1855,1854,1,0,0,0,1856,1859,1,0,0,0,1857,1855,1,0,0,0,1857,1858,1,0, + 0,0,1858,1860,1,0,0,0,1859,1857,1,0,0,0,1860,1861,3,124,62,0,1861,1862, + 3,2,1,0,1862,1872,1,0,0,0,1863,1867,5,128,0,0,1864,1866,3,212,106,0,1865, + 1864,1,0,0,0,1866,1869,1,0,0,0,1867,1865,1,0,0,0,1867,1868,1,0,0,0,1868, + 1870,1,0,0,0,1869,1867,1,0,0,0,1870,1872,3,2,1,0,1871,1853,1,0,0,0,1871, + 1863,1,0,0,0,1872,211,1,0,0,0,1873,1874,7,11,0,0,1874,213,1,0,0,0,1875, + 1877,3,216,108,0,1876,1875,1,0,0,0,1877,1880,1,0,0,0,1878,1876,1,0,0,0, + 1878,1879,1,0,0,0,1879,215,1,0,0,0,1880,1878,1,0,0,0,1881,1882,5,129,0, + 0,1882,1894,3,168,84,0,1883,1884,5,130,0,0,1884,1894,3,168,84,0,1885,1886, + 5,131,0,0,1886,1894,3,168,84,0,1887,1888,5,132,0,0,1888,1894,3,168,84, + 0,1889,1894,3,88,44,0,1890,1894,3,322,161,0,1891,1894,3,26,13,0,1892,1894, + 3,40,20,0,1893,1881,1,0,0,0,1893,1883,1,0,0,0,1893,1885,1,0,0,0,1893,1887, + 1,0,0,0,1893,1889,1,0,0,0,1893,1890,1,0,0,0,1893,1891,1,0,0,0,1893,1892, + 1,0,0,0,1894,217,1,0,0,0,1895,1899,5,133,0,0,1896,1898,3,220,110,0,1897, + 1896,1,0,0,0,1898,1901,1,0,0,0,1899,1897,1,0,0,0,1899,1900,1,0,0,0,1900, + 1902,1,0,0,0,1901,1899,1,0,0,0,1902,1903,3,170,85,0,1903,1904,3,138,69, + 0,1904,1905,3,2,1,0,1905,1906,3,112,56,0,1906,1907,3,206,103,0,1907,219, + 1,0,0,0,1908,1909,7,11,0,0,1909,221,1,0,0,0,1910,1912,3,224,112,0,1911, + 1910,1,0,0,0,1912,1915,1,0,0,0,1913,1911,1,0,0,0,1913,1914,1,0,0,0,1914, + 223,1,0,0,0,1915,1913,1,0,0,0,1916,1917,5,134,0,0,1917,1927,3,168,84,0, + 1918,1919,5,135,0,0,1919,1927,3,168,84,0,1920,1921,5,132,0,0,1921,1927, + 3,168,84,0,1922,1927,3,322,161,0,1923,1927,3,88,44,0,1924,1927,3,26,13, + 0,1925,1927,3,40,20,0,1926,1916,1,0,0,0,1926,1918,1,0,0,0,1926,1920,1, + 0,0,0,1926,1922,1,0,0,0,1926,1923,1,0,0,0,1926,1924,1,0,0,0,1926,1925, + 1,0,0,0,1927,225,1,0,0,0,1928,1935,1,0,0,0,1929,1930,5,122,0,0,1930,1931, + 5,30,0,0,1931,1932,3,228,114,0,1932,1933,5,31,0,0,1933,1935,1,0,0,0,1934, + 1928,1,0,0,0,1934,1929,1,0,0,0,1935,227,1,0,0,0,1936,1946,3,126,63,0,1937, + 1939,5,17,0,0,1938,1940,3,294,147,0,1939,1938,1,0,0,0,1940,1941,1,0,0, + 0,1941,1939,1,0,0,0,1941,1942,1,0,0,0,1942,1943,1,0,0,0,1943,1944,5,18, + 0,0,1944,1946,1,0,0,0,1945,1936,1,0,0,0,1945,1937,1,0,0,0,1946,229,1,0, + 0,0,1947,1949,3,232,116,0,1948,1947,1,0,0,0,1949,1952,1,0,0,0,1950,1948, + 1,0,0,0,1950,1951,1,0,0,0,1951,231,1,0,0,0,1952,1950,1,0,0,0,1953,1954, + 5,42,0,0,1954,1955,5,136,0,0,1955,1967,5,43,0,0,1956,1957,5,42,0,0,1957, + 1958,5,137,0,0,1958,1967,5,43,0,0,1959,1960,5,42,0,0,1960,1961,5,138,0, + 0,1961,1967,5,43,0,0,1962,1963,5,42,0,0,1963,1964,3,32,16,0,1964,1965, + 5,43,0,0,1965,1967,1,0,0,0,1966,1953,1,0,0,0,1966,1956,1,0,0,0,1966,1959, + 1,0,0,0,1966,1962,1,0,0,0,1967,233,1,0,0,0,1968,1973,5,139,0,0,1969,1972, + 3,236,118,0,1970,1972,3,238,119,0,1971,1969,1,0,0,0,1971,1970,1,0,0,0, + 1972,1975,1,0,0,0,1973,1971,1,0,0,0,1973,1974,1,0,0,0,1974,1976,1,0,0, + 0,1975,1973,1,0,0,0,1976,1977,3,170,85,0,1977,1978,3,230,115,0,1978,1979, + 3,138,69,0,1979,1980,3,226,113,0,1980,1981,3,242,121,0,1981,1982,3,182, + 91,0,1982,1986,3,112,56,0,1983,1985,3,244,122,0,1984,1983,1,0,0,0,1985, + 1988,1,0,0,0,1986,1984,1,0,0,0,1986,1987,1,0,0,0,1987,235,1,0,0,0,1988, + 1986,1,0,0,0,1989,2013,5,123,0,0,1990,2013,5,51,0,0,1991,2013,5,52,0,0, + 1992,2013,5,63,0,0,1993,2013,5,140,0,0,1994,2013,5,68,0,0,1995,2013,5, + 141,0,0,1996,2013,5,142,0,0,1997,2013,5,54,0,0,1998,2013,5,64,0,0,1999, + 2013,5,65,0,0,2000,2013,5,66,0,0,2001,2013,5,125,0,0,2002,2013,5,143,0, + 0,2003,2013,5,144,0,0,2004,2013,5,69,0,0,2005,2013,5,145,0,0,2006,2013, + 5,146,0,0,2007,2008,5,70,0,0,2008,2009,5,30,0,0,2009,2010,3,32,16,0,2010, + 2011,5,31,0,0,2011,2013,1,0,0,0,2012,1989,1,0,0,0,2012,1990,1,0,0,0,2012, + 1991,1,0,0,0,2012,1992,1,0,0,0,2012,1993,1,0,0,0,2012,1994,1,0,0,0,2012, + 1995,1,0,0,0,2012,1996,1,0,0,0,2012,1997,1,0,0,0,2012,1998,1,0,0,0,2012, + 1999,1,0,0,0,2012,2000,1,0,0,0,2012,2001,1,0,0,0,2012,2002,1,0,0,0,2012, + 2003,1,0,0,0,2012,2004,1,0,0,0,2012,2005,1,0,0,0,2012,2006,1,0,0,0,2012, + 2007,1,0,0,0,2013,237,1,0,0,0,2014,2015,5,147,0,0,2015,2021,5,30,0,0,2016, + 2019,3,6,3,0,2017,2018,5,34,0,0,2018,2020,3,6,3,0,2019,2017,1,0,0,0,2019, + 2020,1,0,0,0,2020,2022,1,0,0,0,2021,2016,1,0,0,0,2021,2022,1,0,0,0,2022, + 2026,1,0,0,0,2023,2025,3,240,120,0,2024,2023,1,0,0,0,2025,2028,1,0,0,0, + 2026,2024,1,0,0,0,2026,2027,1,0,0,0,2027,2029,1,0,0,0,2028,2026,1,0,0, + 0,2029,2033,5,31,0,0,2030,2031,5,147,0,0,2031,2033,5,85,0,0,2032,2014, + 1,0,0,0,2032,2030,1,0,0,0,2033,239,1,0,0,0,2034,2062,5,148,0,0,2035,2062, + 5,224,0,0,2036,2062,5,57,0,0,2037,2062,5,58,0,0,2038,2062,5,149,0,0,2039, + 2062,5,150,0,0,2040,2062,5,248,0,0,2041,2062,5,249,0,0,2042,2062,5,250, + 0,0,2043,2062,5,251,0,0,2044,2045,5,151,0,0,2045,2046,5,75,0,0,2046,2062, + 5,152,0,0,2047,2048,5,151,0,0,2048,2049,5,75,0,0,2049,2062,5,153,0,0,2050, + 2051,5,154,0,0,2051,2052,5,75,0,0,2052,2062,5,152,0,0,2053,2054,5,154, + 0,0,2054,2055,5,75,0,0,2055,2062,5,153,0,0,2056,2057,5,70,0,0,2057,2058, + 5,30,0,0,2058,2059,3,32,16,0,2059,2060,5,31,0,0,2060,2062,1,0,0,0,2061, + 2034,1,0,0,0,2061,2035,1,0,0,0,2061,2036,1,0,0,0,2061,2037,1,0,0,0,2061, + 2038,1,0,0,0,2061,2039,1,0,0,0,2061,2040,1,0,0,0,2061,2041,1,0,0,0,2061, + 2042,1,0,0,0,2061,2043,1,0,0,0,2061,2044,1,0,0,0,2061,2047,1,0,0,0,2061, + 2050,1,0,0,0,2061,2053,1,0,0,0,2061,2056,1,0,0,0,2062,241,1,0,0,0,2063, + 2067,5,116,0,0,2064,2067,5,155,0,0,2065,2067,3,2,1,0,2066,2063,1,0,0,0, + 2066,2064,1,0,0,0,2066,2065,1,0,0,0,2067,243,1,0,0,0,2068,2090,5,1,0,0, + 2069,2090,5,2,0,0,2070,2090,5,156,0,0,2071,2090,5,3,0,0,2072,2090,5,4, + 0,0,2073,2090,5,247,0,0,2074,2090,5,5,0,0,2075,2090,5,6,0,0,2076,2090, + 5,7,0,0,2077,2090,5,8,0,0,2078,2090,5,9,0,0,2079,2090,5,10,0,0,2080,2090, + 5,11,0,0,2081,2090,5,12,0,0,2082,2090,5,13,0,0,2083,2090,5,14,0,0,2084, + 2085,5,70,0,0,2085,2086,5,30,0,0,2086,2087,3,32,16,0,2087,2088,5,31,0, + 0,2088,2090,1,0,0,0,2089,2068,1,0,0,0,2089,2069,1,0,0,0,2089,2070,1,0, + 0,0,2089,2071,1,0,0,0,2089,2072,1,0,0,0,2089,2073,1,0,0,0,2089,2074,1, + 0,0,0,2089,2075,1,0,0,0,2089,2076,1,0,0,0,2089,2077,1,0,0,0,2089,2078, + 1,0,0,0,2089,2079,1,0,0,0,2089,2080,1,0,0,0,2089,2081,1,0,0,0,2089,2082, + 1,0,0,0,2089,2083,1,0,0,0,2089,2084,1,0,0,0,2090,245,1,0,0,0,2091,2093, + 3,248,124,0,2092,2091,1,0,0,0,2093,2096,1,0,0,0,2094,2092,1,0,0,0,2094, + 2095,1,0,0,0,2095,247,1,0,0,0,2096,2094,1,0,0,0,2097,2115,3,100,50,0,2098, + 2099,5,296,0,0,2099,2100,3,32,16,0,2100,2101,6,124,-1,0,2101,2115,1,0, + 0,0,2102,2115,3,258,129,0,2103,2104,5,297,0,0,2104,2105,3,32,16,0,2105, + 2106,6,124,-1,0,2106,2115,1,0,0,0,2107,2108,5,298,0,0,2108,2115,6,124, + -1,0,2109,2110,5,299,0,0,2110,2115,6,124,-1,0,2111,2115,3,252,126,0,2112, + 2115,3,256,128,0,2113,2115,3,250,125,0,2114,2097,1,0,0,0,2114,2098,1,0, + 0,0,2114,2102,1,0,0,0,2114,2103,1,0,0,0,2114,2107,1,0,0,0,2114,2109,1, + 0,0,0,2114,2111,1,0,0,0,2114,2112,1,0,0,0,2114,2113,1,0,0,0,2115,249,1, + 0,0,0,2116,2117,5,300,0,0,2117,2215,3,112,56,0,2118,2119,5,300,0,0,2119, + 2120,5,157,0,0,2120,2215,3,112,56,0,2121,2215,3,276,138,0,2122,2215,3, + 152,76,0,2123,2215,3,88,44,0,2124,2215,3,26,13,0,2125,2215,3,254,127,0, + 2126,2215,3,40,20,0,2127,2128,5,301,0,0,2128,2129,5,42,0,0,2129,2130,3, + 32,16,0,2130,2131,5,43,0,0,2131,2215,1,0,0,0,2132,2133,5,301,0,0,2133, + 2134,5,42,0,0,2134,2135,3,32,16,0,2135,2136,5,43,0,0,2136,2137,5,34,0, + 0,2137,2138,3,0,0,0,2138,2215,1,0,0,0,2139,2140,5,303,0,0,2140,2141,3, + 32,16,0,2141,2142,5,75,0,0,2142,2143,3,32,16,0,2143,2215,1,0,0,0,2144, + 2145,5,302,0,0,2145,2146,3,124,62,0,2146,2147,5,176,0,0,2147,2148,3,242, + 121,0,2148,2215,1,0,0,0,2149,2150,5,302,0,0,2150,2151,5,226,0,0,2151,2152, + 3,170,85,0,2152,2153,3,138,69,0,2153,2154,3,124,62,0,2154,2155,5,176,0, + 0,2155,2156,3,242,121,0,2156,2157,3,194,97,0,2157,2158,3,112,56,0,2158, + 2215,1,0,0,0,2159,2160,5,255,0,0,2160,2161,5,196,0,0,2161,2162,5,42,0, + 0,2162,2163,3,32,16,0,2163,2167,5,43,0,0,2164,2166,3,322,161,0,2165,2164, + 1,0,0,0,2166,2169,1,0,0,0,2167,2165,1,0,0,0,2167,2168,1,0,0,0,2168,2215, + 1,0,0,0,2169,2167,1,0,0,0,2170,2171,5,255,0,0,2171,2172,5,196,0,0,2172, + 2176,3,2,1,0,2173,2175,3,322,161,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,2215,1,0,0,0,2178,2176,1,0,0, + 0,2179,2180,5,255,0,0,2180,2181,5,256,0,0,2181,2182,5,42,0,0,2182,2183, + 3,32,16,0,2183,2184,5,43,0,0,2184,2185,5,28,0,0,2185,2189,3,124,62,0,2186, + 2188,3,322,161,0,2187,2186,1,0,0,0,2188,2191,1,0,0,0,2189,2187,1,0,0,0, + 2189,2190,1,0,0,0,2190,2215,1,0,0,0,2191,2189,1,0,0,0,2192,2193,5,255, + 0,0,2193,2194,5,256,0,0,2194,2195,3,2,1,0,2195,2196,5,28,0,0,2196,2200, + 3,124,62,0,2197,2199,3,322,161,0,2198,2197,1,0,0,0,2199,2202,1,0,0,0,2200, + 2198,1,0,0,0,2200,2201,1,0,0,0,2201,2215,1,0,0,0,2202,2200,1,0,0,0,2203, + 2204,5,255,0,0,2204,2205,5,42,0,0,2205,2206,3,32,16,0,2206,2207,5,43,0, + 0,2207,2211,3,206,103,0,2208,2210,3,322,161,0,2209,2208,1,0,0,0,2210,2213, + 1,0,0,0,2211,2209,1,0,0,0,2211,2212,1,0,0,0,2212,2215,1,0,0,0,2213,2211, + 1,0,0,0,2214,2116,1,0,0,0,2214,2118,1,0,0,0,2214,2121,1,0,0,0,2214,2122, + 1,0,0,0,2214,2123,1,0,0,0,2214,2124,1,0,0,0,2214,2125,1,0,0,0,2214,2126, + 1,0,0,0,2214,2127,1,0,0,0,2214,2132,1,0,0,0,2214,2139,1,0,0,0,2214,2144, + 1,0,0,0,2214,2149,1,0,0,0,2214,2159,1,0,0,0,2214,2170,1,0,0,0,2214,2179, + 1,0,0,0,2214,2192,1,0,0,0,2214,2203,1,0,0,0,2215,251,1,0,0,0,2216,2217, + 3,0,0,0,2217,2218,5,75,0,0,2218,2219,6,126,-1,0,2219,253,1,0,0,0,2220, + 2223,3,44,22,0,2221,2223,3,46,23,0,2222,2220,1,0,0,0,2222,2221,1,0,0,0, + 2223,255,1,0,0,0,2224,2225,5,17,0,0,2225,2226,3,246,123,0,2226,2227,5, + 18,0,0,2227,257,1,0,0,0,2228,2229,3,262,131,0,2229,2230,3,260,130,0,2230, + 259,1,0,0,0,2231,2233,3,264,132,0,2232,2231,1,0,0,0,2233,2234,1,0,0,0, + 2234,2232,1,0,0,0,2234,2235,1,0,0,0,2235,261,1,0,0,0,2236,2237,5,158,0, + 0,2237,2249,3,256,128,0,2238,2239,5,158,0,0,2239,2240,3,0,0,0,2240,2241, + 5,159,0,0,2241,2242,3,0,0,0,2242,2249,1,0,0,0,2243,2244,5,158,0,0,2244, + 2245,3,32,16,0,2245,2246,5,159,0,0,2246,2247,3,32,16,0,2247,2249,1,0,0, + 0,2248,2236,1,0,0,0,2248,2238,1,0,0,0,2248,2243,1,0,0,0,2249,263,1,0,0, + 0,2250,2251,3,268,134,0,2251,2252,3,274,137,0,2252,2263,1,0,0,0,2253,2254, + 3,266,133,0,2254,2255,3,274,137,0,2255,2263,1,0,0,0,2256,2257,3,270,135, + 0,2257,2258,3,274,137,0,2258,2263,1,0,0,0,2259,2260,3,272,136,0,2260,2261, + 3,274,137,0,2261,2263,1,0,0,0,2262,2250,1,0,0,0,2262,2253,1,0,0,0,2262, + 2256,1,0,0,0,2262,2259,1,0,0,0,2263,265,1,0,0,0,2264,2265,5,160,0,0,2265, + 2271,3,256,128,0,2266,2267,5,160,0,0,2267,2271,3,0,0,0,2268,2269,5,160, + 0,0,2269,2271,3,32,16,0,2270,2264,1,0,0,0,2270,2266,1,0,0,0,2270,2268, + 1,0,0,0,2271,267,1,0,0,0,2272,2273,5,161,0,0,2273,2274,3,124,62,0,2274, + 269,1,0,0,0,2275,2276,5,162,0,0,2276,271,1,0,0,0,2277,2278,5,163,0,0,2278, + 273,1,0,0,0,2279,2291,3,256,128,0,2280,2281,5,164,0,0,2281,2282,3,0,0, + 0,2282,2283,5,159,0,0,2283,2284,3,0,0,0,2284,2291,1,0,0,0,2285,2286,5, + 164,0,0,2286,2287,3,32,16,0,2287,2288,5,159,0,0,2288,2289,3,32,16,0,2289, + 2291,1,0,0,0,2290,2279,1,0,0,0,2290,2280,1,0,0,0,2290,2285,1,0,0,0,2291, + 275,1,0,0,0,2292,2293,3,278,139,0,2293,2294,3,282,141,0,2294,277,1,0,0, + 0,2295,2296,5,165,0,0,2296,2297,3,280,140,0,2297,2298,3,0,0,0,2298,2299, + 5,36,0,0,2299,2303,1,0,0,0,2300,2301,5,165,0,0,2301,2303,3,280,140,0,2302, + 2295,1,0,0,0,2302,2300,1,0,0,0,2303,279,1,0,0,0,2304,2308,1,0,0,0,2305, + 2308,5,166,0,0,2306,2308,5,2,0,0,2307,2304,1,0,0,0,2307,2305,1,0,0,0,2307, + 2306,1,0,0,0,2308,281,1,0,0,0,2309,2310,5,17,0,0,2310,2311,3,284,142,0, + 2311,2312,5,18,0,0,2312,2319,1,0,0,0,2313,2315,3,288,144,0,2314,2313,1, + 0,0,0,2315,2316,1,0,0,0,2316,2314,1,0,0,0,2316,2317,1,0,0,0,2317,2319, + 1,0,0,0,2318,2309,1,0,0,0,2318,2314,1,0,0,0,2319,283,1,0,0,0,2320,2321, + 3,288,144,0,2321,2322,5,28,0,0,2322,2324,1,0,0,0,2323,2320,1,0,0,0,2324, + 2327,1,0,0,0,2325,2323,1,0,0,0,2325,2326,1,0,0,0,2326,2328,1,0,0,0,2327, + 2325,1,0,0,0,2328,2329,3,288,144,0,2329,285,1,0,0,0,2330,2336,1,0,0,0, + 2331,2332,5,42,0,0,2332,2333,3,32,16,0,2333,2334,5,43,0,0,2334,2336,1, + 0,0,0,2335,2330,1,0,0,0,2335,2331,1,0,0,0,2336,287,1,0,0,0,2337,2338,5, + 181,0,0,2338,2339,5,262,0,0,2339,2340,5,30,0,0,2340,2341,3,6,3,0,2341, + 2342,5,31,0,0,2342,2404,1,0,0,0,2343,2344,5,260,0,0,2344,2345,5,30,0,0, + 2345,2346,3,0,0,0,2346,2347,5,31,0,0,2347,2404,1,0,0,0,2348,2349,5,260, + 0,0,2349,2404,3,0,0,0,2350,2351,5,84,0,0,2351,2352,5,30,0,0,2352,2353, + 3,292,146,0,2353,2354,5,31,0,0,2354,2404,1,0,0,0,2355,2356,5,188,0,0,2356, + 2357,5,30,0,0,2357,2358,3,36,18,0,2358,2359,5,31,0,0,2359,2360,3,286,143, + 0,2360,2404,1,0,0,0,2361,2362,5,189,0,0,2362,2363,5,30,0,0,2363,2364,3, + 36,18,0,2364,2365,5,31,0,0,2365,2366,3,286,143,0,2366,2404,1,0,0,0,2367, + 2368,5,187,0,0,2368,2369,5,30,0,0,2369,2370,3,34,17,0,2370,2371,5,31,0, + 0,2371,2372,3,286,143,0,2372,2404,1,0,0,0,2373,2374,5,186,0,0,2374,2375, + 5,30,0,0,2375,2376,3,32,16,0,2376,2377,5,31,0,0,2377,2378,3,286,143,0, + 2378,2404,1,0,0,0,2379,2380,5,185,0,0,2380,2381,5,30,0,0,2381,2382,3,32, + 16,0,2382,2383,5,31,0,0,2383,2384,3,286,143,0,2384,2404,1,0,0,0,2385,2386, + 5,184,0,0,2386,2387,5,30,0,0,2387,2388,3,32,16,0,2388,2389,5,31,0,0,2389, + 2390,3,286,143,0,2390,2404,1,0,0,0,2391,2392,5,188,0,0,2392,2404,3,286, + 143,0,2393,2394,5,189,0,0,2394,2404,3,286,143,0,2395,2396,5,187,0,0,2396, + 2404,3,286,143,0,2397,2398,5,186,0,0,2398,2404,3,286,143,0,2399,2400,5, + 185,0,0,2400,2404,3,286,143,0,2401,2402,5,184,0,0,2402,2404,3,286,143, + 0,2403,2337,1,0,0,0,2403,2343,1,0,0,0,2403,2348,1,0,0,0,2403,2350,1,0, + 0,0,2403,2355,1,0,0,0,2403,2361,1,0,0,0,2403,2367,1,0,0,0,2403,2373,1, + 0,0,0,2403,2379,1,0,0,0,2403,2385,1,0,0,0,2403,2391,1,0,0,0,2403,2393, + 1,0,0,0,2403,2395,1,0,0,0,2403,2397,1,0,0,0,2403,2399,1,0,0,0,2403,2401, + 1,0,0,0,2404,289,1,0,0,0,2405,2406,5,188,0,0,2406,2407,5,30,0,0,2407,2408, + 3,36,18,0,2408,2409,5,31,0,0,2409,2481,1,0,0,0,2410,2411,5,189,0,0,2411, + 2412,5,30,0,0,2412,2413,3,36,18,0,2413,2414,5,31,0,0,2414,2481,1,0,0,0, + 2415,2416,5,188,0,0,2416,2417,5,30,0,0,2417,2418,3,32,16,0,2418,2419,5, + 31,0,0,2419,2481,1,0,0,0,2420,2421,5,189,0,0,2421,2422,5,30,0,0,2422,2423, + 3,34,17,0,2423,2424,5,31,0,0,2424,2481,1,0,0,0,2425,2426,5,187,0,0,2426, + 2427,5,30,0,0,2427,2428,3,34,17,0,2428,2429,5,31,0,0,2429,2481,1,0,0,0, + 2430,2431,5,186,0,0,2431,2432,5,30,0,0,2432,2433,3,32,16,0,2433,2434,5, + 31,0,0,2434,2481,1,0,0,0,2435,2436,5,185,0,0,2436,2437,5,30,0,0,2437,2438, + 3,32,16,0,2438,2439,5,31,0,0,2439,2481,1,0,0,0,2440,2441,5,184,0,0,2441, + 2442,5,30,0,0,2442,2443,3,32,16,0,2443,2444,5,31,0,0,2444,2481,1,0,0,0, + 2445,2446,5,193,0,0,2446,2447,5,30,0,0,2447,2448,3,34,17,0,2448,2449,5, + 31,0,0,2449,2481,1,0,0,0,2450,2451,5,192,0,0,2451,2452,5,30,0,0,2452,2453, + 3,32,16,0,2453,2454,5,31,0,0,2454,2481,1,0,0,0,2455,2456,5,191,0,0,2456, + 2457,5,30,0,0,2457,2458,3,32,16,0,2458,2459,5,31,0,0,2459,2481,1,0,0,0, + 2460,2461,5,190,0,0,2461,2462,5,30,0,0,2462,2463,3,32,16,0,2463,2464,5, + 31,0,0,2464,2481,1,0,0,0,2465,2466,5,181,0,0,2466,2467,5,30,0,0,2467,2468, + 3,32,16,0,2468,2469,5,31,0,0,2469,2481,1,0,0,0,2470,2471,5,183,0,0,2471, + 2472,5,30,0,0,2472,2473,3,162,81,0,2473,2474,5,31,0,0,2474,2481,1,0,0, + 0,2475,2476,5,84,0,0,2476,2477,5,30,0,0,2477,2478,3,292,146,0,2478,2479, + 5,31,0,0,2479,2481,1,0,0,0,2480,2405,1,0,0,0,2480,2410,1,0,0,0,2480,2415, + 1,0,0,0,2480,2420,1,0,0,0,2480,2425,1,0,0,0,2480,2430,1,0,0,0,2480,2435, + 1,0,0,0,2480,2440,1,0,0,0,2480,2445,1,0,0,0,2480,2450,1,0,0,0,2480,2455, + 1,0,0,0,2480,2460,1,0,0,0,2480,2465,1,0,0,0,2480,2470,1,0,0,0,2480,2475, + 1,0,0,0,2481,291,1,0,0,0,2482,2483,3,294,147,0,2483,2484,6,146,-1,0,2484, + 2486,1,0,0,0,2485,2482,1,0,0,0,2486,2489,1,0,0,0,2487,2485,1,0,0,0,2487, + 2488,1,0,0,0,2488,293,1,0,0,0,2489,2487,1,0,0,0,2490,2491,7,12,0,0,2491, + 295,1,0,0,0,2492,2496,3,290,145,0,2493,2496,3,6,3,0,2494,2496,5,179,0, + 0,2495,2492,1,0,0,0,2495,2493,1,0,0,0,2495,2494,1,0,0,0,2496,297,1,0,0, + 0,2497,2646,3,290,145,0,2498,2499,5,182,0,0,2499,2500,5,30,0,0,2500,2501, + 5,179,0,0,2501,2646,5,31,0,0,2502,2503,5,182,0,0,2503,2504,5,30,0,0,2504, + 2505,5,264,0,0,2505,2646,5,31,0,0,2506,2507,5,196,0,0,2507,2508,5,30,0, + 0,2508,2509,5,39,0,0,2509,2510,5,264,0,0,2510,2646,5,31,0,0,2511,2512, + 5,196,0,0,2512,2513,5,30,0,0,2513,2514,3,116,58,0,2514,2515,5,31,0,0,2515, + 2646,1,0,0,0,2516,2517,5,196,0,0,2517,2518,5,30,0,0,2518,2519,5,179,0, + 0,2519,2646,5,31,0,0,2520,2521,5,197,0,0,2521,2522,5,30,0,0,2522,2523, + 3,298,149,0,2523,2524,5,31,0,0,2524,2646,1,0,0,0,2525,2526,5,188,0,0,2526, + 2527,5,42,0,0,2527,2528,3,32,16,0,2528,2529,5,43,0,0,2529,2530,5,30,0, + 0,2530,2531,3,300,150,0,2531,2532,5,31,0,0,2532,2646,1,0,0,0,2533,2534, + 5,189,0,0,2534,2535,5,42,0,0,2535,2536,3,32,16,0,2536,2537,5,43,0,0,2537, + 2538,5,30,0,0,2538,2539,3,302,151,0,2539,2540,5,31,0,0,2540,2646,1,0,0, + 0,2541,2542,5,187,0,0,2542,2543,5,42,0,0,2543,2544,3,32,16,0,2544,2545, + 5,43,0,0,2545,2546,5,30,0,0,2546,2547,3,304,152,0,2547,2548,5,31,0,0,2548, + 2646,1,0,0,0,2549,2550,5,186,0,0,2550,2551,5,42,0,0,2551,2552,3,32,16, + 0,2552,2553,5,43,0,0,2553,2554,5,30,0,0,2554,2555,3,306,153,0,2555,2556, + 5,31,0,0,2556,2646,1,0,0,0,2557,2558,5,185,0,0,2558,2559,5,42,0,0,2559, + 2560,3,32,16,0,2560,2561,5,43,0,0,2561,2562,5,30,0,0,2562,2563,3,308,154, + 0,2563,2564,5,31,0,0,2564,2646,1,0,0,0,2565,2566,5,184,0,0,2566,2567,5, + 42,0,0,2567,2568,3,32,16,0,2568,2569,5,43,0,0,2569,2570,5,30,0,0,2570, + 2571,3,310,155,0,2571,2572,5,31,0,0,2572,2646,1,0,0,0,2573,2574,5,193, + 0,0,2574,2575,5,42,0,0,2575,2576,3,32,16,0,2576,2577,5,43,0,0,2577,2578, + 5,30,0,0,2578,2579,3,304,152,0,2579,2580,5,31,0,0,2580,2646,1,0,0,0,2581, + 2582,5,192,0,0,2582,2583,5,42,0,0,2583,2584,3,32,16,0,2584,2585,5,43,0, + 0,2585,2586,5,30,0,0,2586,2587,3,306,153,0,2587,2588,5,31,0,0,2588,2646, + 1,0,0,0,2589,2590,5,191,0,0,2590,2591,5,42,0,0,2591,2592,3,32,16,0,2592, + 2593,5,43,0,0,2593,2594,5,30,0,0,2594,2595,3,308,154,0,2595,2596,5,31, + 0,0,2596,2646,1,0,0,0,2597,2598,5,190,0,0,2598,2599,5,42,0,0,2599,2600, + 3,32,16,0,2600,2601,5,43,0,0,2601,2602,5,30,0,0,2602,2603,3,310,155,0, + 2603,2604,5,31,0,0,2604,2646,1,0,0,0,2605,2606,5,181,0,0,2606,2607,5,42, + 0,0,2607,2608,3,32,16,0,2608,2609,5,43,0,0,2609,2610,5,30,0,0,2610,2611, + 3,308,154,0,2611,2612,5,31,0,0,2612,2646,1,0,0,0,2613,2614,5,183,0,0,2614, + 2615,5,42,0,0,2615,2616,3,32,16,0,2616,2617,5,43,0,0,2617,2618,5,30,0, + 0,2618,2619,3,312,156,0,2619,2620,5,31,0,0,2620,2646,1,0,0,0,2621,2622, + 5,182,0,0,2622,2623,5,42,0,0,2623,2624,3,32,16,0,2624,2625,5,43,0,0,2625, + 2626,5,30,0,0,2626,2627,3,314,157,0,2627,2628,5,31,0,0,2628,2646,1,0,0, + 0,2629,2630,5,196,0,0,2630,2631,5,42,0,0,2631,2632,3,32,16,0,2632,2633, + 5,43,0,0,2633,2634,5,30,0,0,2634,2635,3,316,158,0,2635,2636,5,31,0,0,2636, + 2646,1,0,0,0,2637,2638,5,197,0,0,2638,2639,5,42,0,0,2639,2640,3,32,16, + 0,2640,2641,5,43,0,0,2641,2642,5,30,0,0,2642,2643,3,320,160,0,2643,2644, + 5,31,0,0,2644,2646,1,0,0,0,2645,2497,1,0,0,0,2645,2498,1,0,0,0,2645,2502, + 1,0,0,0,2645,2506,1,0,0,0,2645,2511,1,0,0,0,2645,2516,1,0,0,0,2645,2520, + 1,0,0,0,2645,2525,1,0,0,0,2645,2533,1,0,0,0,2645,2541,1,0,0,0,2645,2549, + 1,0,0,0,2645,2557,1,0,0,0,2645,2565,1,0,0,0,2645,2573,1,0,0,0,2645,2581, + 1,0,0,0,2645,2589,1,0,0,0,2645,2597,1,0,0,0,2645,2605,1,0,0,0,2645,2613, + 1,0,0,0,2645,2621,1,0,0,0,2645,2629,1,0,0,0,2645,2637,1,0,0,0,2646,299, + 1,0,0,0,2647,2650,3,36,18,0,2648,2650,3,32,16,0,2649,2647,1,0,0,0,2649, + 2648,1,0,0,0,2650,2653,1,0,0,0,2651,2649,1,0,0,0,2651,2652,1,0,0,0,2652, + 301,1,0,0,0,2653,2651,1,0,0,0,2654,2657,3,36,18,0,2655,2657,3,34,17,0, + 2656,2654,1,0,0,0,2656,2655,1,0,0,0,2657,2660,1,0,0,0,2658,2656,1,0,0, + 0,2658,2659,1,0,0,0,2659,303,1,0,0,0,2660,2658,1,0,0,0,2661,2663,3,34, + 17,0,2662,2661,1,0,0,0,2663,2666,1,0,0,0,2664,2662,1,0,0,0,2664,2665,1, + 0,0,0,2665,305,1,0,0,0,2666,2664,1,0,0,0,2667,2669,3,32,16,0,2668,2667, + 1,0,0,0,2669,2672,1,0,0,0,2670,2668,1,0,0,0,2670,2671,1,0,0,0,2671,307, + 1,0,0,0,2672,2670,1,0,0,0,2673,2675,3,32,16,0,2674,2673,1,0,0,0,2675,2678, + 1,0,0,0,2676,2674,1,0,0,0,2676,2677,1,0,0,0,2677,309,1,0,0,0,2678,2676, + 1,0,0,0,2679,2681,3,32,16,0,2680,2679,1,0,0,0,2681,2684,1,0,0,0,2682,2680, + 1,0,0,0,2682,2683,1,0,0,0,2683,311,1,0,0,0,2684,2682,1,0,0,0,2685,2687, + 3,162,81,0,2686,2685,1,0,0,0,2687,2690,1,0,0,0,2688,2686,1,0,0,0,2688, + 2689,1,0,0,0,2689,313,1,0,0,0,2690,2688,1,0,0,0,2691,2693,7,13,0,0,2692, + 2691,1,0,0,0,2693,2696,1,0,0,0,2694,2692,1,0,0,0,2694,2695,1,0,0,0,2695, + 315,1,0,0,0,2696,2694,1,0,0,0,2697,2699,3,318,159,0,2698,2697,1,0,0,0, + 2699,2702,1,0,0,0,2700,2698,1,0,0,0,2700,2701,1,0,0,0,2701,317,1,0,0,0, + 2702,2700,1,0,0,0,2703,2708,5,179,0,0,2704,2705,5,39,0,0,2705,2708,5,264, + 0,0,2706,2708,3,116,58,0,2707,2703,1,0,0,0,2707,2704,1,0,0,0,2707,2706, + 1,0,0,0,2708,319,1,0,0,0,2709,2711,3,298,149,0,2710,2709,1,0,0,0,2711, + 2714,1,0,0,0,2712,2710,1,0,0,0,2712,2713,1,0,0,0,2713,321,1,0,0,0,2714, + 2712,1,0,0,0,2715,2719,3,44,22,0,2716,2719,3,46,23,0,2717,2719,3,2,1,0, + 2718,2715,1,0,0,0,2718,2716,1,0,0,0,2718,2717,1,0,0,0,2719,323,1,0,0,0, + 2720,2721,7,14,0,0,2721,2722,5,36,0,0,2722,2723,5,30,0,0,2723,2724,3,292, + 146,0,2724,2725,5,31,0,0,2725,2746,1,0,0,0,2726,2727,5,169,0,0,2727,2728, + 3,38,19,0,2728,2729,5,75,0,0,2729,2730,3,38,19,0,2730,2731,5,75,0,0,2731, + 2732,3,38,19,0,2732,2733,5,75,0,0,2733,2734,3,38,19,0,2734,2746,1,0,0, + 0,2735,2736,5,170,0,0,2736,2746,3,6,3,0,2737,2738,5,170,0,0,2738,2739, + 5,36,0,0,2739,2740,5,30,0,0,2740,2741,3,292,146,0,2741,2742,5,31,0,0,2742, + 2746,1,0,0,0,2743,2746,3,322,161,0,2744,2746,3,40,20,0,2745,2720,1,0,0, + 0,2745,2726,1,0,0,0,2745,2735,1,0,0,0,2745,2737,1,0,0,0,2745,2743,1,0, + 0,0,2745,2744,1,0,0,0,2746,325,1,0,0,0,2747,2748,5,25,0,0,2748,2749,5, + 40,0,0,2749,2750,3,98,49,0,2750,2751,3,2,1,0,2751,2760,1,0,0,0,2752,2753, + 5,25,0,0,2753,2754,5,40,0,0,2754,2755,3,98,49,0,2755,2756,3,2,1,0,2756, + 2757,5,34,0,0,2757,2758,3,2,1,0,2758,2760,1,0,0,0,2759,2747,1,0,0,0,2759, + 2752,1,0,0,0,2760,327,1,0,0,0,2761,2763,3,330,165,0,2762,2761,1,0,0,0, + 2763,2766,1,0,0,0,2764,2762,1,0,0,0,2764,2765,1,0,0,0,2765,329,1,0,0,0, + 2766,2764,1,0,0,0,2767,2768,5,180,0,0,2768,2769,5,36,0,0,2769,2770,5,30, + 0,0,2770,2771,3,292,146,0,2771,2772,5,31,0,0,2772,2782,1,0,0,0,2773,2782, + 3,324,162,0,2774,2775,5,171,0,0,2775,2776,5,36,0,0,2776,2777,5,30,0,0, + 2777,2778,3,292,146,0,2778,2779,5,31,0,0,2779,2782,1,0,0,0,2780,2782,5, + 55,0,0,2781,2767,1,0,0,0,2781,2773,1,0,0,0,2781,2774,1,0,0,0,2781,2780, + 1,0,0,0,2782,331,1,0,0,0,2783,2784,5,50,0,0,2784,2788,5,40,0,0,2785,2787, + 3,336,168,0,2786,2785,1,0,0,0,2787,2790,1,0,0,0,2788,2786,1,0,0,0,2788, + 2789,1,0,0,0,2789,2791,1,0,0,0,2790,2788,1,0,0,0,2791,2792,3,2,1,0,2792, + 333,1,0,0,0,2793,2797,5,301,0,0,2794,2796,3,336,168,0,2795,2794,1,0,0, + 0,2796,2799,1,0,0,0,2797,2795,1,0,0,0,2797,2798,1,0,0,0,2798,2800,1,0, + 0,0,2799,2797,1,0,0,0,2800,2801,3,2,1,0,2801,335,1,0,0,0,2802,2818,5,52, + 0,0,2803,2818,5,51,0,0,2804,2818,5,172,0,0,2805,2806,5,62,0,0,2806,2818, + 5,51,0,0,2807,2808,5,62,0,0,2808,2818,5,52,0,0,2809,2810,5,62,0,0,2810, + 2818,5,63,0,0,2811,2812,5,62,0,0,2812,2818,5,64,0,0,2813,2814,5,62,0,0, + 2814,2818,5,65,0,0,2815,2816,5,62,0,0,2816,2818,5,66,0,0,2817,2802,1,0, + 0,0,2817,2803,1,0,0,0,2817,2804,1,0,0,0,2817,2805,1,0,0,0,2817,2807,1, + 0,0,0,2817,2809,1,0,0,0,2817,2811,1,0,0,0,2817,2813,1,0,0,0,2817,2815, + 1,0,0,0,2818,337,1,0,0,0,2819,2821,3,340,170,0,2820,2819,1,0,0,0,2821, + 2824,1,0,0,0,2822,2820,1,0,0,0,2822,2823,1,0,0,0,2823,339,1,0,0,0,2824, + 2822,1,0,0,0,2825,2826,5,21,0,0,2826,2839,3,2,1,0,2827,2828,5,50,0,0,2828, + 2829,5,40,0,0,2829,2839,3,118,59,0,2830,2831,5,25,0,0,2831,2832,5,40,0, + 0,2832,2839,3,2,1,0,2833,2839,3,174,87,0,2834,2835,5,50,0,0,2835,2839, + 3,32,16,0,2836,2839,3,322,161,0,2837,2839,3,40,20,0,2838,2825,1,0,0,0, + 2838,2827,1,0,0,0,2838,2830,1,0,0,0,2838,2833,1,0,0,0,2838,2834,1,0,0, + 0,2838,2836,1,0,0,0,2838,2837,1,0,0,0,2839,341,1,0,0,0,2840,2844,5,274, + 0,0,2841,2843,3,344,172,0,2842,2841,1,0,0,0,2843,2846,1,0,0,0,2844,2842, + 1,0,0,0,2844,2845,1,0,0,0,2845,2847,1,0,0,0,2846,2844,1,0,0,0,2847,2860, + 3,2,1,0,2848,2852,5,274,0,0,2849,2851,3,344,172,0,2850,2849,1,0,0,0,2851, + 2854,1,0,0,0,2852,2850,1,0,0,0,2852,2853,1,0,0,0,2853,2855,1,0,0,0,2854, + 2852,1,0,0,0,2855,2856,3,2,1,0,2856,2857,5,34,0,0,2857,2858,3,2,1,0,2858, + 2860,1,0,0,0,2859,2840,1,0,0,0,2859,2848,1,0,0,0,2860,343,1,0,0,0,2861, + 2862,7,15,0,0,2862,345,1,0,0,0,2863,2865,3,348,174,0,2864,2863,1,0,0,0, + 2865,2868,1,0,0,0,2866,2864,1,0,0,0,2866,2867,1,0,0,0,2867,347,1,0,0,0, + 2868,2866,1,0,0,0,2869,2870,5,21,0,0,2870,2871,3,2,1,0,2871,2872,5,44, + 0,0,2872,2873,3,32,16,0,2873,2880,1,0,0,0,2874,2875,5,25,0,0,2875,2876, + 5,40,0,0,2876,2880,3,2,1,0,2877,2880,3,322,161,0,2878,2880,3,40,20,0,2879, + 2869,1,0,0,0,2879,2874,1,0,0,0,2879,2877,1,0,0,0,2879,2878,1,0,0,0,2880, + 349,1,0,0,0,175,358,363,371,379,432,473,482,506,510,528,555,578,614,620, + 627,629,639,641,648,659,667,688,690,706,751,756,761,766,774,884,890,906, + 912,918,925,930,982,1018,1023,1029,1034,1036,1044,1056,1068,1075,1082, + 1084,1111,1118,1126,1134,1147,1154,1157,1176,1270,1279,1286,1289,1297, + 1318,1350,1373,1385,1394,1419,1443,1451,1455,1470,1477,1522,1532,1548, + 1560,1572,1586,1598,1609,1616,1626,1639,1644,1649,1658,1669,1752,1761, + 1774,1785,1793,1803,1805,1832,1839,1844,1851,1857,1867,1871,1878,1893, + 1899,1913,1926,1934,1941,1945,1950,1966,1971,1973,1986,2012,2019,2021, + 2026,2032,2061,2066,2089,2094,2114,2167,2176,2189,2200,2211,2214,2222, + 2234,2248,2262,2270,2290,2302,2307,2316,2318,2325,2335,2403,2480,2487, + 2495,2645,2649,2651,2656,2658,2664,2670,2676,2682,2688,2694,2700,2707, + 2712,2718,2745,2759,2764,2781,2788,2797,2817,2822,2838,2844,2852,2859, + 2866,2879 }; public static readonly ATN _ATN = diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILVisitor.cs b/src/tools/ilasm/src/ILAssembler/gen/CILVisitor.cs index d74d21a93c4052..f9cf69a1ad7003 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILVisitor.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILVisitor.cs @@ -333,89 +333,23 @@ public interface ICILVisitor : IParseTreeVisitor { /// The visitor result. Result VisitAsmAttr([NotNull] CILParser.AsmAttrContext context); /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitInstr_none([NotNull] CILParser.Instr_noneContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitInstr_var([NotNull] CILParser.Instr_varContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitInstr_i([NotNull] CILParser.Instr_iContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitInstr_i8([NotNull] CILParser.Instr_i8Context context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitInstr_r([NotNull] CILParser.Instr_rContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitInstr_brtarget([NotNull] CILParser.Instr_brtargetContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitInstr_method([NotNull] CILParser.Instr_methodContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitInstr_field([NotNull] CILParser.Instr_fieldContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitInstr_type([NotNull] CILParser.Instr_typeContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitInstr_string([NotNull] CILParser.Instr_stringContext context); - /// - /// Visit a parse tree produced by . + /// Visit a parse tree produced by . /// /// The parse tree. /// The visitor result. - Result VisitInstr_sig([NotNull] CILParser.Instr_sigContext context); + Result VisitInstr([NotNull] CILParser.InstrContext context); /// - /// Visit a parse tree produced by . + /// Visit a parse tree produced by . /// /// The parse tree. /// The visitor result. - Result VisitInstr_tok([NotNull] CILParser.Instr_tokContext context); + Result VisitSimpleInstr([NotNull] CILParser.SimpleInstrContext context); /// - /// Visit a parse tree produced by . + /// Visit a parse tree produced by . /// /// The parse tree. /// The visitor result. - Result VisitInstr_switch([NotNull] CILParser.Instr_switchContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitInstr([NotNull] CILParser.InstrContext context); + Result VisitInstructionIsland([NotNull] CILParser.InstructionIslandContext context); /// /// Visit a parse tree produced by . /// @@ -928,6 +862,12 @@ public interface ICILVisitor : IParseTreeVisitor { /// The visitor result. Result VisitMethodDecl([NotNull] CILParser.MethodDeclContext context); /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitMethodDeclIsland([NotNull] CILParser.MethodDeclIslandContext context); + /// /// Visit a parse tree produced by . /// /// The parse tree. diff --git a/src/tools/ilasm/tests/ILAssembler.Tests/InstructionTests.cs b/src/tools/ilasm/tests/ILAssembler.Tests/InstructionTests.cs index 67e4a77013ef1a..a59ce810c93dd6 100644 --- a/src/tools/ilasm/tests/ILAssembler.Tests/InstructionTests.cs +++ b/src/tools/ilasm/tests/ILAssembler.Tests/InstructionTests.cs @@ -46,6 +46,58 @@ br UndefinedLabel Assert.Equal(DiagnosticSeverity.Error, error.Severity); } + [Theory] + [InlineData("ldc.i4")] + [InlineData("ldc.i8")] + [InlineData("ldarg")] + [InlineData("br")] + [InlineData("ldtoken")] + [InlineData("ldc.r8 bytearray(00 00")] + [InlineData("ldstr bytearray(48 00")] + public void MalformedSimpleInstruction_DoesNotLeakMethodState(string malformedInstruction) + { + string source = $$""" + .assembly test { } + .class public auto ansi Test + { + .method public static void Bad() cil managed + { + {{malformedInstruction}} + } + + .method public static void Good() cil managed + { + ret + } + } + """; + + DocumentCompiler compiler = new(); + var (diagnostics, result) = compiler.Compile( + new SourceText(source, "test.il"), + _ => + { + Assert.Fail("Expected no includes"); + return default; + }, + _ => + { + Assert.Fail("Expected no resources"); + return default; + }, + new Options { ErrorTolerant = true }); + + Assert.Contains(diagnostics, diagnostic => diagnostic.Id == "Parser"); + Assert.NotNull(result); + + BlobBuilder image = new(); + result!.Serialize(image); + using PEReader pe = new(image.ToImmutableArray()); + byte[] il = GetMethodIL(pe, "Good"); + + Assert.Equal([0x2A], il); + } + [Fact] public void DataLabelReference_FixedUpCorrectly() From f073e8f69be0056c6f46ce760543f1c384c7974c Mon Sep 17 00:00:00 2001 From: Jeremy Koritzinsky Date: Wed, 12 Aug 2026 19:52:13 -0700 Subject: [PATCH 03/16] Compile value instruction operands during parsing Synthesize floating literals and composed strings directly from parser rules, and stream switch labels into an action-owned accumulator. Remove the corresponding bounded instruction subtrees while preserving output and error recovery. Also fix odd-length ANSI string padding to match native ilasm. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: c986c103-8383-4db4-9b11-9be49dc68a05 --- src/tools/ilasm/README.md | 10 +- .../GrammarActions.Instructions.Islands.cs | 108 +- .../Actions/GrammarActions.Instructions.cs | 157 +- .../Actions/GrammarActions.Literals.cs | 120 +- src/tools/ilasm/src/ILAssembler/gen/CIL.g4 | 44 +- .../ilasm/src/ILAssembler/gen/CIL.interp | 2 +- .../ilasm/src/ILAssembler/gen/CILParser.cs | 6349 +++++++++-------- .../ILAssembler.Tests/InstructionTests.cs | 141 +- 8 files changed, 3588 insertions(+), 3343 deletions(-) diff --git a/src/tools/ilasm/README.md b/src/tools/ilasm/README.md index 138d95683de432..aa4e0a854b9a65 100644 --- a/src/tools/ilasm/README.md +++ b/src/tools/ilasm/README.md @@ -19,8 +19,8 @@ accumulator instead of building a subtree at all. | `GrammarActions.Data.cs` | Data and blob declarations. | | `GrammarActions.Debug.cs` | Source and debug directives. | | `GrammarActions.Declarations.cs` | Top-level `decl` dispatch and conversion. | -| `GrammarActions.Instructions.cs` | Tree-free common instruction and method-item actions. | -| `GrammarActions.Instructions.Islands.cs` | Complex instruction-island conversion. | +| `GrammarActions.Instructions.cs` | Tree-free value instruction and method-item actions. | +| `GrammarActions.Instructions.Islands.cs` | Reference and signature instruction-island conversion. | | `GrammarActions.Literals.cs` | Literals, names and strings. | | `GrammarActions.Manifest.cs` | Assembly, module, resource, vtable and typedef directives. | | `GrammarActions.Marshalling.cs` | Native type and marshalling conversion. | @@ -37,9 +37,9 @@ accumulator instead of building a subtree at all. Parser actions in `src/ILAssembler/gen/CIL.g4` must remain thin; they call a single `Actions` method and nothing else. Compilation orchestration belongs in the `GrammarActions` partial-class files. -The common instruction forms and labels run entirely with parse-tree construction disabled. -Instructions with complex type, member, signature, string, floating-point, or switch operands -temporarily retain only their own bounded `instructionIsland` subtree. +Value instruction forms, composed strings and switch labels run entirely with parse-tree +construction disabled. Instructions with reference or signature operands temporarily retain only +their own bounded `instructionIsland` subtree. Semantic state that a rule pushes must be released from that rule's `finally` clause and be keyed on the owning context, because ANTLR skips `@after` actions and the remainder of an alternative once a diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.Islands.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.Islands.cs index 8dacce6ba8c470..63a334f890eb63 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.Islands.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.Islands.cs @@ -2,16 +2,12 @@ // The .NET Foundation licenses this file to you under the MIT license. using System; -using System.Collections.Generic; using System.Collections.Immutable; using System.Diagnostics; using System.Linq; using System.Reflection.Metadata; using System.Reflection.Metadata.Ecma335; -using System.Runtime.InteropServices; -using System.Text; using Antlr4.Runtime; -using Antlr4.Runtime.Tree; namespace ILAssembler; @@ -46,10 +42,6 @@ internal void ProcessInstructionIsland(CILParser.InstructionIslandContext contex method.Definition.MethodBody.OpCode(opcode); WriteInstructionToken(method, VisitTypeSpec(typeSpec).Value); } - else if (context.compQstring() is CILParser.CompQstringContext userString) - { - EmitComposedStringInstruction(method, context, userString); - } else if (context.callConv() is CILParser.CallConvContext callConv) { EmitCalliInstruction(method, opcode, context, callConv); @@ -59,13 +51,9 @@ internal void ProcessInstructionIsland(CILParser.InstructionIslandContext contex method.Definition.MethodBody.OpCode(opcode); WriteInstructionToken(method, VisitOwnerType(ownerType).Value); } - else if (opcode == ILOpCode.Switch) - { - EmitSwitchInstruction(method, context, context.labels()); - } else { - EmitParsedFloatingInstruction(method, opcode, context); + throw new UnreachableException(); } } @@ -90,47 +78,6 @@ private void EmitMethodReferenceInstruction( } } - private void EmitParsedFloatingInstruction( - CurrentMethodContext method, - ILOpCode opcode, - CILParser.InstructionIslandContext context) - { - double value = context.float64() is CILParser.Float64Context float64 - ? VisitFloat64(float64).Value - : VisitInt64(context.int64()).Value; - - if (opcode == ILOpCode.Ldc_r4) - { - method.Definition.MethodBody.LoadConstantR4((float)value); - } - else - { - method.Definition.MethodBody.LoadConstantR8(value); - } - } - - private void EmitComposedStringInstruction( - CurrentMethodContext method, - CILParser.InstructionIslandContext context, - CILParser.CompQstringContext userString) - { - string value = VisitCompQstring(userString).Value; - if (context.ANSI() is not null) - { - int byteCount = Encoding.UTF8.GetByteCount(value); - if ((byteCount % 1) != 0) - { - byteCount++; - } - - Span utf8Bytes = new byte[byteCount]; - Encoding.UTF8.GetBytes(value, utf8Bytes); - value = new string(MemoryMarshal.Cast(utf8Bytes)); - } - - method.Definition.MethodBody.LoadString(_metadataBuilder.GetOrAddUserString(value)); - } - private void EmitCalliInstruction( CurrentMethodContext method, ILOpCode opcode, @@ -152,59 +99,6 @@ private void EmitCalliInstruction( method.Definition.MethodBody.Token(_entityRegistry.GetOrCreateStandaloneSignature(signature).Handle); } - private void EmitSwitchInstruction( - CurrentMethodContext method, - CILParser.InstructionIslandContext context, - CILParser.LabelsContext? labelsContext) - { - List<(LabelHandle Label, int? Offset)> labels = new(); - if (labelsContext?.children is { } labelChildren) - { - foreach (IParseTree label in labelChildren) - { - if (label is CILParser.IdContext id) - { - string labelName = VisitId(id).Value; - if (!method.Labels.TryGetValue(labelName, out LabelHandle handle)) - { - handle = method.Definition.MethodBody.DefineLabel(); - method.Labels[labelName] = handle; - method.UndefinedLabelReferences.TryAdd(labelName, context.Start); - } - labels.Add((handle, null)); - } - else if (label is CILParser.Int32Context int32) - { - labels.Add((method.Definition.MethodBody.DefineLabel(), VisitInt32(int32).Value)); - } - } - } - - if (labels.Count > 0) - { - SwitchInstructionEncoder switchEncoder = method.Definition.MethodBody.Switch(labels.Count); - foreach ((LabelHandle label, _) in labels) - { - switchEncoder.Branch(label); - } - } - else - { - method.Definition.MethodBody.OpCode(ILOpCode.Switch); - method.Definition.MethodBody.CodeBuilder.WriteInt32(0); - } - - foreach ((LabelHandle label, int? offset) in labels) - { - if (offset is int value) - { - method.Definition.MethodBody.MarkLabel( - label, - method.Definition.MethodBody.Offset + value); - } - } - } - private static void WriteInstructionToken(CurrentMethodContext method, EntityRegistry.EntityBase entity) { if (entity is EntityRegistry.TypeReferenceEntity typeReference) diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs index f29301adfec44d..c9cb35bb06993c 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs @@ -2,17 +2,36 @@ // The .NET Foundation licenses this file to you under the MIT license. using System; +using System.Collections.Generic; using System.Collections.Immutable; using System.Diagnostics; using System.Reflection.Metadata; using System.Reflection.Metadata.Ecma335; using System.Runtime.InteropServices; +using System.Text; using Antlr4.Runtime; namespace ILAssembler; internal sealed partial class GrammarActions { + private sealed class SwitchInstructionAccumulator + { + internal SwitchInstructionAccumulator(CILParser.SimpleInstrContext owner, IToken opcodeToken) + { + Owner = owner; + OpcodeToken = opcodeToken; + } + + internal CILParser.SimpleInstrContext Owner { get; } + + internal IToken OpcodeToken { get; } + + internal List<(IToken Token, bool IsOffset)> Operands { get; } = new(); + } + + private SwitchInstructionAccumulator? _switchInstructionAccumulator; + internal void EmitNoOperandInstruction(IToken opcodeToken) { if (StartInstruction(opcodeToken) is not { } instruction) @@ -112,6 +131,26 @@ internal void EmitInt64Instruction(IToken opcodeToken, IToken valueToken) instruction.Method.Definition.MethodBody.LoadConstantI8(ParseInt64(valueToken)); } + internal void EmitFloatingInstruction(IToken opcodeToken, double value) + { + if (StartInstruction(opcodeToken) is not { } instruction) + { + return; + } + + WriteFloatingInstruction(instruction.Method, instruction.OpCode, value); + } + + internal void EmitFloatingInstruction(IToken opcodeToken, IToken valueToken) + { + if (StartInstruction(opcodeToken) is not { } instruction) + { + return; + } + + WriteFloatingInstruction(instruction.Method, instruction.OpCode, ParseInt64(valueToken)); + } + internal void EmitBranchOffsetInstruction(IToken opcodeToken, IToken offsetToken) { if (StartInstruction(opcodeToken) is not { } instruction) @@ -173,14 +212,7 @@ internal void EmitRawFloatingInstruction( value = 0; } - if (instruction.OpCode == ILOpCode.Ldc_r4) - { - instruction.Method.Definition.MethodBody.LoadConstantR4((float)value); - } - else - { - instruction.Method.Definition.MethodBody.LoadConstantR8(value); - } + WriteFloatingInstruction(instruction.Method, instruction.OpCode, value); } internal void EmitRawStringInstruction(IToken opcodeToken, ImmutableArray bytes) @@ -194,6 +226,29 @@ internal void EmitRawStringInstruction(IToken opcodeToken, ImmutableArray instruction.Method.Definition.MethodBody.LoadString(_metadataBuilder.GetOrAddUserString(value)); } + internal void EmitStringInstruction(IToken opcodeToken, string value) + { + if (StartInstruction(opcodeToken) is not { } instruction) + { + return; + } + + instruction.Method.Definition.MethodBody.LoadString(_metadataBuilder.GetOrAddUserString(value)); + } + + internal void EmitAnsiStringInstruction(IToken opcodeToken, string value) + { + int byteCount = Encoding.UTF8.GetByteCount(value); + if ((byteCount % 2) != 0) + { + byteCount++; + } + + Span utf8Bytes = new byte[byteCount]; + Encoding.UTF8.GetBytes(value, utf8Bytes); + EmitStringInstruction(opcodeToken, new string(MemoryMarshal.Cast(utf8Bytes))); + } + internal void EmitRawTokenInstruction(IToken opcodeToken, IToken valueToken) { if (StartInstruction(opcodeToken) is not { } instruction) @@ -252,6 +307,80 @@ internal void DefineLabel(IToken nameToken) method.Definition.MethodBody.MarkLabel(label); } + internal void BeginSwitchInstruction(CILParser.SimpleInstrContext context, IToken opcodeToken) + { + Debug.Assert(_switchInstructionAccumulator is null); + _switchInstructionAccumulator = new SwitchInstructionAccumulator(context, opcodeToken); + } + + internal void AddSwitchLabel(IToken labelToken) + => _switchInstructionAccumulator?.Operands.Add((labelToken, false)); + + internal void AddSwitchOffset(IToken offsetToken) + => _switchInstructionAccumulator?.Operands.Add((offsetToken, true)); + + internal void CompleteSimpleInstruction(CILParser.SimpleInstrContext context) + { + if (_switchInstructionAccumulator is not { } accumulator || + !ReferenceEquals(accumulator.Owner, context) || + StartInstruction(accumulator.OpcodeToken) is not { } instruction) + { + return; + } + + Debug.Assert(instruction.OpCode == ILOpCode.Switch); + CurrentMethodContext method = instruction.Method; + List<(LabelHandle Label, int? Offset)> labels = new(accumulator.Operands.Count); + foreach ((IToken token, bool isOffset) in accumulator.Operands) + { + if (isOffset) + { + labels.Add((method.Definition.MethodBody.DefineLabel(), ParseInt32(token))); + continue; + } + + string labelName = ParseIdentifier(token); + if (!method.Labels.TryGetValue(labelName, out LabelHandle label)) + { + label = method.Definition.MethodBody.DefineLabel(); + method.Labels[labelName] = label; + method.UndefinedLabelReferences.TryAdd(labelName, accumulator.OpcodeToken); + } + + labels.Add((label, null)); + } + + if (labels.Count > 0) + { + SwitchInstructionEncoder switchEncoder = method.Definition.MethodBody.Switch(labels.Count); + foreach ((LabelHandle label, _) in labels) + { + switchEncoder.Branch(label); + } + } + else + { + method.Definition.MethodBody.OpCode(ILOpCode.Switch); + method.Definition.MethodBody.CodeBuilder.WriteInt32(0); + } + + foreach ((LabelHandle label, int? offset) in labels) + { + if (offset is int value) + { + method.Definition.MethodBody.MarkLabel(label, method.Definition.MethodBody.Offset + value); + } + } + } + + internal void EndSwitchInstruction(CILParser.SimpleInstrContext context) + { + if (ReferenceEquals(_switchInstructionAccumulator?.Owner, context)) + { + _switchInstructionAccumulator = null; + } + } + private (CurrentMethodContext Method, ILOpCode OpCode)? StartInstruction(IToken opcodeToken) { if (_currentMethod is not { } method) @@ -281,6 +410,18 @@ private static void WriteVariableIndex(CurrentMethodContext method, ILOpCode opc } } + private static void WriteFloatingInstruction(CurrentMethodContext method, ILOpCode opcode, double value) + { + if (opcode == ILOpCode.Ldc_r4) + { + method.Definition.MethodBody.LoadConstantR4((float)value); + } + else + { + method.Definition.MethodBody.LoadConstantR8(value); + } + } + private static ILOpCode ParseOpCodeFromToken(IToken token) { string text = token.Text.TrimEnd('.'); diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs index 5530d41769f15d..5a90ebd78ca420 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs @@ -25,21 +25,48 @@ namespace ILAssembler #pragma warning disable CA1822 // Mark members as static internal sealed partial class GrammarActions : ICILVisitor { + private CILParser.CompQstringContext? _composedStringOwner; + private StringBuilder? _composedStringAccumulator; + GrammarResult ICILVisitor.VisitCompQstring(CILParser.CompQstringContext context) { return VisitCompQstring(context); } - private static GrammarResult.String VisitCompQstring(CILParser.CompQstringContext context) + internal void BeginComposedString(CILParser.CompQstringContext context) + { + Debug.Assert(_composedStringOwner is null); + Debug.Assert(_composedStringAccumulator is null); + _composedStringOwner = context; + _composedStringAccumulator = new StringBuilder(); + } + + internal void AddComposedStringPart(CILParser.CompQstringContext context, IToken token) { - StringBuilder builder = new(); - foreach (var item in context.QSTRING()) + if (ReferenceEquals(_composedStringOwner, context) && + _composedStringAccumulator is { } accumulator) { - builder.Append(StringHelpers.ParseQuotedString(item.Symbol.Text)); + accumulator.Append(StringHelpers.ParseQuotedString(token.Text)); } - return new(builder.ToString()); } + internal string EndComposedString(CILParser.CompQstringContext context) + { + if (!ReferenceEquals(_composedStringOwner, context)) + { + return string.Empty; + } + + string value = _composedStringAccumulator?.ToString() ?? string.Empty; + _composedStringOwner = null; + _composedStringAccumulator = null; + + return value; + } + + private static GrammarResult.String VisitCompQstring(CILParser.CompQstringContext context) + => new(context.Value ?? string.Empty); + GrammarResult ICILVisitor.VisitDottedName(CILParser.DottedNameContext context) { return VisitDottedName(context); @@ -77,48 +104,40 @@ public static GrammarResult.String VisitDottedName(CILParser.DottedNameContext c GrammarResult ICILVisitor.VisitDottedNamePart(CILParser.DottedNamePartContext context) => throw new UnreachableException(); - GrammarResult ICILVisitor.VisitFloat64(CILParser.Float64Context context) => VisitFloat64(context); - public GrammarResult.Literal VisitFloat64(CILParser.Float64Context context) + internal double ParseFloatingLiteral(IToken token) { - if (context.FLOAT64() is ITerminalNode float64) + string text = token.Text; + bool neg = text.StartsWith('-'); + if (!double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out double result)) { - string text = float64.Symbol.Text; - bool neg = text.StartsWith('-'); - if (!double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out double result)) - { - result = neg ? double.MaxValue : double.MinValue; - } - return new(result); + result = neg ? double.MaxValue : double.MinValue; } - else if (context.int32() is CILParser.Int32Context int32) - { - IToken node = int32.INT32().Symbol; - if (!ParseIntegerValue(node.Text.AsSpan(), out long intValue)) - { - _diagnostics.Add(new Diagnostic( - DiagnosticIds.LiteralOutOfRange, - DiagnosticSeverity.Error, - string.Format(DiagnosticMessageTemplates.LiteralOutOfRange, node.Text), - Location.From(node, _documents))); - intValue = 0; - } - if (context.FLOAT32() is not null) - { - // FLOAT32 '(' int32 ')' — hex bits reinterpreted as float32 - return new(BitConverter.Int32BitsToSingle((int)intValue)); - } - // int32 or int32 '.' — plain integer or trailing-dot float - return new((double)intValue); - } - else if (context.int64() is CILParser.Int64Context int64) + return result; + } + + internal double ParseFloatingInteger(IToken token) + { + if (!ParseIntegerValue(token.Text.AsSpan(), out long value)) { - // FLOAT64_ '(' int64 ')' — hex bits reinterpreted as float64 - long value = VisitInt64(int64).Value; - return new(BitConverter.Int64BitsToDouble(value)); + ReportLiteralOutOfRange(token); + value = 0; } - throw new UnreachableException(); + + return value; } + + internal double ParseFloat32Bits(IToken token) + => BitConverter.Int32BitsToSingle(ParseInt32(token)); + + internal double ParseFloat64Bits(IToken token) + => BitConverter.Int64BitsToDouble(ParseInt64(token)); + + GrammarResult ICILVisitor.VisitFloat64(CILParser.Float64Context context) => VisitFloat64(context); + + public static GrammarResult.Literal VisitFloat64(CILParser.Float64Context context) + => new(context.Value); + GrammarResult ICILVisitor.VisitId(CILParser.IdContext context) => VisitId(context); public static GrammarResult.String VisitId(CILParser.IdContext context) { @@ -212,11 +231,7 @@ private int ParseInt32(IToken token) ReadOnlySpan value = token.Text.AsSpan(); if (!ParseIntegerValue(value, out long num)) { - _diagnostics.Add(new Diagnostic( - DiagnosticIds.LiteralOutOfRange, - DiagnosticSeverity.Error, - string.Format(DiagnosticMessageTemplates.LiteralOutOfRange, token.Text), - Location.From(token, _documents))); + ReportLiteralOutOfRange(token); return 0; } @@ -239,17 +254,22 @@ private long ParseInt64(IToken token) ReadOnlySpan value = token.Text.AsSpan(); if (!ParseIntegerValue(value, out long num)) { - _diagnostics.Add(new Diagnostic( - DiagnosticIds.LiteralOutOfRange, - DiagnosticSeverity.Error, - string.Format(DiagnosticMessageTemplates.LiteralOutOfRange, token.Text), - Location.From(token, _documents))); + ReportLiteralOutOfRange(token); return 0; } return num; } + private void ReportLiteralOutOfRange(IToken token) + { + _diagnostics.Add(new Diagnostic( + DiagnosticIds.LiteralOutOfRange, + DiagnosticSeverity.Error, + string.Format(DiagnosticMessageTemplates.LiteralOutOfRange, token.Text), + Location.From(token, _documents))); + } + GrammarResult ICILVisitor.VisitIntOrWildcard(CILParser.IntOrWildcardContext context) => VisitIntOrWildcard(context); public GrammarResult.Literal VisitIntOrWildcard(CILParser.IntOrWildcardContext context) => context.int32() is {} int32 ? new(VisitInt32(int32).Value) : new(null); diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 index 644cf905fcc604..be738cfd3031b0 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 @@ -411,7 +411,13 @@ id: | SQSTRING; dottedName: DOTTEDNAME | ((dottedNamePart '.')* dottedNamePart) | SQSTRING; dottedNamePart: ID | VALUE | INSTANCE | SQSTRING | DOTTEDNAME | 'volatile'; -compQstring: (QSTRING PLUS)* QSTRING; +compQstring returns [string Value] +@init {BeginStreaming(); Actions.BeginComposedString(_localctx);} +: + (head = QSTRING {Actions.AddComposedStringPart(_localctx, $head);} PLUS)* + tail = QSTRING {Actions.AddComposedStringPart(_localctx, $tail);} +; +finally {_localctx.Value = Actions.EndComposedString(_localctx); EndParseTreeMode();} WS: [ \t\r\n] -> skip; @@ -484,12 +490,12 @@ typelist: '.typelist' '{' (className)* '}'; int32: INT32; int64: INT64 | INT32; -float64: - FLOAT64 - | int32 '.' /* trailing-dot integer as float (e.g., ldc.r8 1.) */ - | int32 - | FLOAT32 '(' int32 ')' - | FLOAT64_ '(' int64 ')'; +float64 returns [double Value]: + decimal = FLOAT64 {_localctx.Value = Actions.ParseFloatingLiteral($decimal);} + | trailing = int32 '.' {_localctx.Value = Actions.ParseFloatingInteger($trailing.start);} /* trailing-dot integer as float (e.g., ldc.r8 1.) */ + | integer = int32 {_localctx.Value = Actions.ParseFloatingInteger($integer.start);} + | FLOAT32 '(' singleBits = int32 ')' {_localctx.Value = Actions.ParseFloat32Bits($singleBits.start);} + | FLOAT64_ '(' doubleBits = int64 ')' {_localctx.Value = Actions.ParseFloat64Bits($doubleBits.start);}; intOrWildcard: int32 | PTR; @@ -678,41 +684,45 @@ instr: simpleInstr | instructionIsland; -simpleInstr: +simpleInstr +@after {Actions.CompleteSimpleInstruction(_localctx);} +: op = INSTR_NONE {Actions.EmitNoOperandInstruction($op);} | op = INSTR_VAR index = int32 {Actions.EmitVariableIndexInstruction($op, $index.start);} | op = INSTR_VAR name = id {Actions.EmitVariableNameInstruction($op, $name.start);} | op = INSTR_I value32 = int32 {Actions.EmitInt32Instruction($op, $value32.start);} | op = INSTR_I8 value64 = int64 {Actions.EmitInt64Instruction($op, $value64.start);} + | op = INSTR_R value = float64 {Actions.EmitFloatingInstruction($op, $value.Value);} + | op = INSTR_R integerValue = int64 {Actions.EmitFloatingInstruction($op, $integerValue.start);} | op = INSTR_R '(' rawFloat = bytes ')' {Actions.EmitRawFloatingInstruction($op, $rawFloat.Value, $rawFloat.start);} | op = INSTR_R 'bytearray' '(' rawFloat = bytes ')' {Actions.EmitRawFloatingInstruction($op, $rawFloat.Value, $rawFloat.start);} | op = INSTR_BRTARGET offset = int32 {Actions.EmitBranchOffsetInstruction($op, $offset.start);} | op = INSTR_BRTARGET label = id {Actions.EmitBranchLabelInstruction($op, $label.start);} + | op = INSTR_STRING userString = compQstring {Actions.EmitStringInstruction($op, $userString.Value);} + | op = INSTR_STRING ANSI '(' ansiString = compQstring ')' {Actions.EmitAnsiStringInstruction($op, $ansiString.Value);} | op = INSTR_STRING 'bytearray' '(' rawString = bytes ')' {Actions.EmitRawStringInstruction($op, $rawString.Value);} - | op = INSTR_TOK rawToken = int32 {Actions.EmitRawTokenInstruction($op, $rawToken.start);}; + | op = INSTR_TOK rawToken = int32 {Actions.EmitRawTokenInstruction($op, $rawToken.start);} + | op = INSTR_SWITCH {Actions.BeginSwitchInstruction(_localctx, $op);} ('(' labels ')' | '()') +; +finally {Actions.EndSwitchInstruction(_localctx);} instructionIsland @init {BeginSubtree();} @after {Actions.ProcessInstructionIsland(_localctx);} : - INSTR_R float64 - | INSTR_R int64 - | INSTR_METHOD methodRef + INSTR_METHOD methodRef | INSTR_FIELD fieldRef | INSTR_FIELD mdtoken | INSTR_TYPE typeSpec - | INSTR_STRING compQstring - | INSTR_STRING ANSI '(' compQstring ')' | INSTR_SIG callConv type sigArgs | INSTR_TOK ownerType /* ownerType ::= memberRef | typeSpec */ - | INSTR_SWITCH '(' labels ')' - | INSTR_SWITCH '()' ; finally {EndParseTreeMode();} labels: /* empty */ - | ((id | int32) ',')* (id | int32); + | ((headLabel = id {Actions.AddSwitchLabel($headLabel.start);} | headOffset = int32 {Actions.AddSwitchOffset($headOffset.start);}) ',')* + (tailLabel = id {Actions.AddSwitchLabel($tailLabel.start);} | tailOffset = int32 {Actions.AddSwitchOffset($tailOffset.start);}); typeArgs: '<' (type ',')* type '>'; diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.interp b/src/tools/ilasm/src/ILAssembler/gen/CIL.interp index 44c235b4c009a1..6c8b4ed14c940c 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.interp +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.interp @@ -793,4 +793,4 @@ manifestResDecl atn: -[4, 1, 305, 2882, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 357, 8, 1, 10, 1, 12, 1, 360, 9, 1, 1, 1, 1, 1, 3, 1, 364, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 5, 3, 370, 8, 3, 10, 3, 12, 3, 373, 9, 3, 1, 3, 1, 3, 1, 4, 5, 4, 378, 8, 4, 10, 4, 12, 4, 381, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 433, 8, 5, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 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, 474, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 5, 15, 481, 8, 15, 10, 15, 12, 15, 484, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 507, 8, 18, 1, 19, 1, 19, 3, 19, 511, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 529, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 556, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 579, 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, 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, 615, 8, 23, 1, 24, 1, 24, 1, 25, 1, 25, 3, 25, 621, 8, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 5, 27, 628, 8, 27, 10, 27, 12, 27, 631, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 640, 8, 28, 10, 28, 12, 28, 643, 9, 28, 1, 29, 1, 29, 1, 30, 1, 30, 3, 30, 649, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 660, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 668, 8, 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, 34, 1, 34, 1, 34, 1, 34, 5, 34, 689, 8, 34, 10, 34, 12, 34, 692, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 5, 37, 705, 8, 37, 10, 37, 12, 37, 708, 9, 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, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 752, 8, 38, 1, 39, 1, 39, 1, 39, 3, 39, 757, 8, 39, 1, 40, 1, 40, 1, 40, 3, 40, 762, 8, 40, 1, 41, 5, 41, 765, 8, 41, 10, 41, 12, 41, 768, 9, 41, 1, 42, 1, 42, 1, 42, 5, 42, 773, 8, 42, 10, 42, 12, 42, 776, 9, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 885, 8, 44, 1, 45, 1, 45, 5, 45, 889, 8, 45, 10, 45, 12, 45, 892, 9, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 905, 8, 45, 10, 45, 12, 45, 908, 9, 45, 1, 45, 1, 45, 1, 45, 3, 45, 913, 8, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 919, 8, 47, 1, 48, 1, 48, 1, 49, 5, 49, 924, 8, 49, 10, 49, 12, 49, 927, 9, 49, 1, 50, 1, 50, 3, 50, 931, 8, 50, 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, 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, 983, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 1019, 8, 52, 1, 53, 1, 53, 1, 53, 3, 53, 1024, 8, 53, 1, 53, 1, 53, 5, 53, 1028, 8, 53, 10, 53, 12, 53, 1031, 9, 53, 1, 53, 1, 53, 3, 53, 1035, 8, 53, 3, 53, 1037, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1043, 8, 54, 10, 54, 12, 54, 1046, 9, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1055, 8, 55, 10, 55, 12, 55, 1058, 9, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 5, 56, 1067, 8, 56, 10, 56, 12, 56, 1070, 9, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1076, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 1083, 8, 57, 3, 57, 1085, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1112, 8, 58, 1, 59, 1, 59, 1, 59, 5, 59, 1117, 8, 59, 10, 59, 12, 59, 1120, 9, 59, 1, 59, 1, 59, 1, 60, 5, 60, 1125, 8, 60, 10, 60, 12, 60, 1128, 9, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1135, 8, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 3, 62, 1148, 8, 62, 1, 63, 1, 63, 1, 63, 5, 63, 1153, 8, 63, 10, 63, 12, 63, 1156, 9, 63, 3, 63, 1158, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 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, 1177, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1271, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1280, 8, 66, 1, 67, 1, 67, 1, 67, 5, 67, 1285, 8, 67, 10, 67, 12, 67, 1288, 9, 67, 3, 67, 1290, 8, 67, 1, 68, 1, 68, 1, 69, 1, 69, 5, 69, 1296, 8, 69, 10, 69, 12, 69, 1299, 9, 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, 1, 70, 1, 70, 1, 70, 3, 70, 1319, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1351, 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, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1374, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1386, 8, 73, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1395, 8, 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, 3, 76, 1420, 8, 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, 1444, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 5, 77, 1450, 8, 77, 10, 77, 12, 77, 1453, 9, 77, 1, 77, 3, 77, 1456, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1471, 8, 78, 1, 79, 1, 79, 1, 79, 5, 79, 1476, 8, 79, 10, 79, 12, 79, 1479, 9, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1523, 8, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1533, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1549, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1561, 8, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1573, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1587, 8, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 1599, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1610, 8, 89, 1, 90, 1, 90, 1, 90, 5, 90, 1615, 8, 90, 10, 90, 12, 90, 1618, 9, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 1627, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 1640, 8, 92, 1, 93, 5, 93, 1643, 8, 93, 10, 93, 12, 93, 1646, 9, 93, 1, 94, 1, 94, 3, 94, 1650, 8, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 5, 95, 1657, 8, 95, 10, 95, 12, 95, 1660, 9, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 3, 97, 1670, 8, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1751, 8, 99, 10, 99, 12, 99, 1754, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1760, 8, 99, 10, 99, 12, 99, 1763, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1773, 8, 99, 10, 99, 12, 99, 1776, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1784, 8, 99, 10, 99, 12, 99, 1787, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 1794, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 1804, 8, 100, 10, 100, 12, 100, 1807, 9, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 1833, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 1840, 8, 102, 1, 103, 1, 103, 1, 103, 3, 103, 1845, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 1852, 8, 104, 1, 105, 1, 105, 5, 105, 1856, 8, 105, 10, 105, 12, 105, 1859, 9, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 1866, 8, 105, 10, 105, 12, 105, 1869, 9, 105, 1, 105, 3, 105, 1872, 8, 105, 1, 106, 1, 106, 1, 107, 5, 107, 1877, 8, 107, 10, 107, 12, 107, 1880, 9, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 1894, 8, 108, 1, 109, 1, 109, 5, 109, 1898, 8, 109, 10, 109, 12, 109, 1901, 9, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 111, 5, 111, 1912, 8, 111, 10, 111, 12, 111, 1915, 9, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 1927, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 1935, 8, 113, 1, 114, 1, 114, 1, 114, 4, 114, 1940, 8, 114, 11, 114, 12, 114, 1941, 1, 114, 1, 114, 3, 114, 1946, 8, 114, 1, 115, 5, 115, 1949, 8, 115, 10, 115, 12, 115, 1952, 9, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 1967, 8, 116, 1, 117, 1, 117, 1, 117, 5, 117, 1972, 8, 117, 10, 117, 12, 117, 1975, 9, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 1985, 8, 117, 10, 117, 12, 117, 1988, 9, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2013, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2020, 8, 119, 3, 119, 2022, 8, 119, 1, 119, 5, 119, 2025, 8, 119, 10, 119, 12, 119, 2028, 9, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2033, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2062, 8, 120, 1, 121, 1, 121, 1, 121, 3, 121, 2067, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2090, 8, 122, 1, 123, 5, 123, 2093, 8, 123, 10, 123, 12, 123, 2096, 9, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2115, 8, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2166, 8, 125, 10, 125, 12, 125, 2169, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2175, 8, 125, 10, 125, 12, 125, 2178, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2188, 8, 125, 10, 125, 12, 125, 2191, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2199, 8, 125, 10, 125, 12, 125, 2202, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2210, 8, 125, 10, 125, 12, 125, 2213, 9, 125, 3, 125, 2215, 8, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 3, 127, 2223, 8, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 130, 4, 130, 2233, 8, 130, 11, 130, 12, 130, 2234, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 2249, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 3, 132, 2263, 8, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 2271, 8, 133, 1, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 2291, 8, 137, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 2303, 8, 139, 1, 140, 1, 140, 1, 140, 3, 140, 2308, 8, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 4, 141, 2315, 8, 141, 11, 141, 12, 141, 2316, 3, 141, 2319, 8, 141, 1, 142, 1, 142, 1, 142, 5, 142, 2324, 8, 142, 10, 142, 12, 142, 2327, 9, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 2336, 8, 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, 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, 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, 2404, 8, 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, 145, 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, 145, 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, 145, 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, 145, 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, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 3, 145, 2481, 8, 145, 1, 146, 1, 146, 1, 146, 5, 146, 2486, 8, 146, 10, 146, 12, 146, 2489, 9, 146, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 3, 148, 2496, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 2646, 8, 149, 1, 150, 1, 150, 5, 150, 2650, 8, 150, 10, 150, 12, 150, 2653, 9, 150, 1, 151, 1, 151, 5, 151, 2657, 8, 151, 10, 151, 12, 151, 2660, 9, 151, 1, 152, 5, 152, 2663, 8, 152, 10, 152, 12, 152, 2666, 9, 152, 1, 153, 5, 153, 2669, 8, 153, 10, 153, 12, 153, 2672, 9, 153, 1, 154, 5, 154, 2675, 8, 154, 10, 154, 12, 154, 2678, 9, 154, 1, 155, 5, 155, 2681, 8, 155, 10, 155, 12, 155, 2684, 9, 155, 1, 156, 5, 156, 2687, 8, 156, 10, 156, 12, 156, 2690, 9, 156, 1, 157, 5, 157, 2693, 8, 157, 10, 157, 12, 157, 2696, 9, 157, 1, 158, 5, 158, 2699, 8, 158, 10, 158, 12, 158, 2702, 9, 158, 1, 159, 1, 159, 1, 159, 1, 159, 3, 159, 2708, 8, 159, 1, 160, 5, 160, 2711, 8, 160, 10, 160, 12, 160, 2714, 9, 160, 1, 161, 1, 161, 1, 161, 3, 161, 2719, 8, 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, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 3, 162, 2746, 8, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 2760, 8, 163, 1, 164, 5, 164, 2763, 8, 164, 10, 164, 12, 164, 2766, 9, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 3, 165, 2782, 8, 165, 1, 166, 1, 166, 1, 166, 5, 166, 2787, 8, 166, 10, 166, 12, 166, 2790, 9, 166, 1, 166, 1, 166, 1, 167, 1, 167, 5, 167, 2796, 8, 167, 10, 167, 12, 167, 2799, 9, 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, 168, 1, 168, 1, 168, 1, 168, 3, 168, 2818, 8, 168, 1, 169, 5, 169, 2821, 8, 169, 10, 169, 12, 169, 2824, 9, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 2839, 8, 170, 1, 171, 1, 171, 5, 171, 2843, 8, 171, 10, 171, 12, 171, 2846, 9, 171, 1, 171, 1, 171, 1, 171, 5, 171, 2851, 8, 171, 10, 171, 12, 171, 2854, 9, 171, 1, 171, 1, 171, 1, 171, 1, 171, 3, 171, 2860, 8, 171, 1, 172, 1, 172, 1, 173, 5, 173, 2865, 8, 173, 10, 173, 12, 173, 2868, 9, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 2880, 8, 174, 1, 174, 0, 1, 68, 175, 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, 0, 16, 6, 0, 1, 15, 199, 199, 243, 243, 247, 247, 264, 264, 289, 289, 5, 0, 16, 16, 199, 199, 243, 243, 264, 264, 288, 289, 1, 0, 263, 264, 1, 0, 173, 174, 1, 0, 37, 38, 1, 0, 73, 74, 3, 0, 2, 2, 61, 61, 77, 83, 2, 0, 229, 229, 260, 261, 9, 0, 178, 178, 183, 195, 201, 201, 207, 208, 210, 215, 218, 219, 222, 222, 230, 242, 262, 262, 1, 0, 95, 96, 1, 0, 97, 111, 1, 0, 68, 69, 2, 0, 173, 173, 289, 290, 2, 0, 179, 179, 264, 264, 1, 0, 167, 168, 1, 0, 51, 52, 3309, 0, 350, 1, 0, 0, 0, 2, 363, 1, 0, 0, 0, 4, 365, 1, 0, 0, 0, 6, 371, 1, 0, 0, 0, 8, 379, 1, 0, 0, 0, 10, 432, 1, 0, 0, 0, 12, 434, 1, 0, 0, 0, 14, 437, 1, 0, 0, 0, 16, 440, 1, 0, 0, 0, 18, 444, 1, 0, 0, 0, 20, 447, 1, 0, 0, 0, 22, 450, 1, 0, 0, 0, 24, 457, 1, 0, 0, 0, 26, 473, 1, 0, 0, 0, 28, 475, 1, 0, 0, 0, 30, 477, 1, 0, 0, 0, 32, 487, 1, 0, 0, 0, 34, 489, 1, 0, 0, 0, 36, 506, 1, 0, 0, 0, 38, 510, 1, 0, 0, 0, 40, 528, 1, 0, 0, 0, 42, 555, 1, 0, 0, 0, 44, 578, 1, 0, 0, 0, 46, 614, 1, 0, 0, 0, 48, 616, 1, 0, 0, 0, 50, 620, 1, 0, 0, 0, 52, 622, 1, 0, 0, 0, 54, 629, 1, 0, 0, 0, 56, 641, 1, 0, 0, 0, 58, 644, 1, 0, 0, 0, 60, 646, 1, 0, 0, 0, 62, 659, 1, 0, 0, 0, 64, 667, 1, 0, 0, 0, 66, 669, 1, 0, 0, 0, 68, 677, 1, 0, 0, 0, 70, 693, 1, 0, 0, 0, 72, 699, 1, 0, 0, 0, 74, 702, 1, 0, 0, 0, 76, 751, 1, 0, 0, 0, 78, 756, 1, 0, 0, 0, 80, 761, 1, 0, 0, 0, 82, 766, 1, 0, 0, 0, 84, 774, 1, 0, 0, 0, 86, 779, 1, 0, 0, 0, 88, 884, 1, 0, 0, 0, 90, 912, 1, 0, 0, 0, 92, 914, 1, 0, 0, 0, 94, 918, 1, 0, 0, 0, 96, 920, 1, 0, 0, 0, 98, 925, 1, 0, 0, 0, 100, 930, 1, 0, 0, 0, 102, 982, 1, 0, 0, 0, 104, 1018, 1, 0, 0, 0, 106, 1036, 1, 0, 0, 0, 108, 1038, 1, 0, 0, 0, 110, 1050, 1, 0, 0, 0, 112, 1075, 1, 0, 0, 0, 114, 1084, 1, 0, 0, 0, 116, 1111, 1, 0, 0, 0, 118, 1118, 1, 0, 0, 0, 120, 1126, 1, 0, 0, 0, 122, 1134, 1, 0, 0, 0, 124, 1147, 1, 0, 0, 0, 126, 1157, 1, 0, 0, 0, 128, 1176, 1, 0, 0, 0, 130, 1270, 1, 0, 0, 0, 132, 1279, 1, 0, 0, 0, 134, 1289, 1, 0, 0, 0, 136, 1291, 1, 0, 0, 0, 138, 1293, 1, 0, 0, 0, 140, 1318, 1, 0, 0, 0, 142, 1350, 1, 0, 0, 0, 144, 1373, 1, 0, 0, 0, 146, 1385, 1, 0, 0, 0, 148, 1387, 1, 0, 0, 0, 150, 1390, 1, 0, 0, 0, 152, 1443, 1, 0, 0, 0, 154, 1455, 1, 0, 0, 0, 156, 1470, 1, 0, 0, 0, 158, 1477, 1, 0, 0, 0, 160, 1482, 1, 0, 0, 0, 162, 1486, 1, 0, 0, 0, 164, 1522, 1, 0, 0, 0, 166, 1524, 1, 0, 0, 0, 168, 1560, 1, 0, 0, 0, 170, 1572, 1, 0, 0, 0, 172, 1586, 1, 0, 0, 0, 174, 1588, 1, 0, 0, 0, 176, 1598, 1, 0, 0, 0, 178, 1609, 1, 0, 0, 0, 180, 1616, 1, 0, 0, 0, 182, 1626, 1, 0, 0, 0, 184, 1639, 1, 0, 0, 0, 186, 1644, 1, 0, 0, 0, 188, 1647, 1, 0, 0, 0, 190, 1658, 1, 0, 0, 0, 192, 1663, 1, 0, 0, 0, 194, 1669, 1, 0, 0, 0, 196, 1671, 1, 0, 0, 0, 198, 1793, 1, 0, 0, 0, 200, 1795, 1, 0, 0, 0, 202, 1832, 1, 0, 0, 0, 204, 1839, 1, 0, 0, 0, 206, 1844, 1, 0, 0, 0, 208, 1851, 1, 0, 0, 0, 210, 1871, 1, 0, 0, 0, 212, 1873, 1, 0, 0, 0, 214, 1878, 1, 0, 0, 0, 216, 1893, 1, 0, 0, 0, 218, 1895, 1, 0, 0, 0, 220, 1908, 1, 0, 0, 0, 222, 1913, 1, 0, 0, 0, 224, 1926, 1, 0, 0, 0, 226, 1934, 1, 0, 0, 0, 228, 1945, 1, 0, 0, 0, 230, 1950, 1, 0, 0, 0, 232, 1966, 1, 0, 0, 0, 234, 1968, 1, 0, 0, 0, 236, 2012, 1, 0, 0, 0, 238, 2032, 1, 0, 0, 0, 240, 2061, 1, 0, 0, 0, 242, 2066, 1, 0, 0, 0, 244, 2089, 1, 0, 0, 0, 246, 2094, 1, 0, 0, 0, 248, 2114, 1, 0, 0, 0, 250, 2214, 1, 0, 0, 0, 252, 2216, 1, 0, 0, 0, 254, 2222, 1, 0, 0, 0, 256, 2224, 1, 0, 0, 0, 258, 2228, 1, 0, 0, 0, 260, 2232, 1, 0, 0, 0, 262, 2248, 1, 0, 0, 0, 264, 2262, 1, 0, 0, 0, 266, 2270, 1, 0, 0, 0, 268, 2272, 1, 0, 0, 0, 270, 2275, 1, 0, 0, 0, 272, 2277, 1, 0, 0, 0, 274, 2290, 1, 0, 0, 0, 276, 2292, 1, 0, 0, 0, 278, 2302, 1, 0, 0, 0, 280, 2307, 1, 0, 0, 0, 282, 2318, 1, 0, 0, 0, 284, 2325, 1, 0, 0, 0, 286, 2335, 1, 0, 0, 0, 288, 2403, 1, 0, 0, 0, 290, 2480, 1, 0, 0, 0, 292, 2487, 1, 0, 0, 0, 294, 2490, 1, 0, 0, 0, 296, 2495, 1, 0, 0, 0, 298, 2645, 1, 0, 0, 0, 300, 2651, 1, 0, 0, 0, 302, 2658, 1, 0, 0, 0, 304, 2664, 1, 0, 0, 0, 306, 2670, 1, 0, 0, 0, 308, 2676, 1, 0, 0, 0, 310, 2682, 1, 0, 0, 0, 312, 2688, 1, 0, 0, 0, 314, 2694, 1, 0, 0, 0, 316, 2700, 1, 0, 0, 0, 318, 2707, 1, 0, 0, 0, 320, 2712, 1, 0, 0, 0, 322, 2718, 1, 0, 0, 0, 324, 2745, 1, 0, 0, 0, 326, 2759, 1, 0, 0, 0, 328, 2764, 1, 0, 0, 0, 330, 2781, 1, 0, 0, 0, 332, 2783, 1, 0, 0, 0, 334, 2793, 1, 0, 0, 0, 336, 2817, 1, 0, 0, 0, 338, 2822, 1, 0, 0, 0, 340, 2838, 1, 0, 0, 0, 342, 2859, 1, 0, 0, 0, 344, 2861, 1, 0, 0, 0, 346, 2866, 1, 0, 0, 0, 348, 2879, 1, 0, 0, 0, 350, 351, 7, 0, 0, 0, 351, 1, 1, 0, 0, 0, 352, 364, 5, 288, 0, 0, 353, 354, 3, 4, 2, 0, 354, 355, 5, 265, 0, 0, 355, 357, 1, 0, 0, 0, 356, 353, 1, 0, 0, 0, 357, 360, 1, 0, 0, 0, 358, 356, 1, 0, 0, 0, 358, 359, 1, 0, 0, 0, 359, 361, 1, 0, 0, 0, 360, 358, 1, 0, 0, 0, 361, 364, 3, 4, 2, 0, 362, 364, 5, 264, 0, 0, 363, 352, 1, 0, 0, 0, 363, 358, 1, 0, 0, 0, 363, 362, 1, 0, 0, 0, 364, 3, 1, 0, 0, 0, 365, 366, 7, 1, 0, 0, 366, 5, 1, 0, 0, 0, 367, 368, 5, 263, 0, 0, 368, 370, 5, 266, 0, 0, 369, 367, 1, 0, 0, 0, 370, 373, 1, 0, 0, 0, 371, 369, 1, 0, 0, 0, 371, 372, 1, 0, 0, 0, 372, 374, 1, 0, 0, 0, 373, 371, 1, 0, 0, 0, 374, 375, 5, 263, 0, 0, 375, 7, 1, 0, 0, 0, 376, 378, 3, 10, 5, 0, 377, 376, 1, 0, 0, 0, 378, 381, 1, 0, 0, 0, 379, 377, 1, 0, 0, 0, 379, 380, 1, 0, 0, 0, 380, 9, 1, 0, 0, 0, 381, 379, 1, 0, 0, 0, 382, 383, 3, 74, 37, 0, 383, 384, 5, 17, 0, 0, 384, 385, 3, 82, 41, 0, 385, 386, 5, 18, 0, 0, 386, 433, 1, 0, 0, 0, 387, 388, 3, 72, 36, 0, 388, 389, 5, 17, 0, 0, 389, 390, 3, 8, 4, 0, 390, 391, 5, 18, 0, 0, 391, 433, 1, 0, 0, 0, 392, 393, 3, 234, 117, 0, 393, 394, 5, 17, 0, 0, 394, 395, 3, 246, 123, 0, 395, 396, 5, 18, 0, 0, 396, 433, 1, 0, 0, 0, 397, 433, 3, 200, 100, 0, 398, 433, 3, 276, 138, 0, 399, 433, 3, 70, 35, 0, 400, 433, 3, 66, 33, 0, 401, 433, 3, 88, 44, 0, 402, 433, 3, 90, 45, 0, 403, 433, 3, 22, 11, 0, 404, 405, 3, 326, 163, 0, 405, 406, 5, 17, 0, 0, 406, 407, 3, 328, 164, 0, 407, 408, 5, 18, 0, 0, 408, 433, 1, 0, 0, 0, 409, 410, 3, 332, 166, 0, 410, 411, 5, 17, 0, 0, 411, 412, 3, 338, 169, 0, 412, 413, 5, 18, 0, 0, 413, 433, 1, 0, 0, 0, 414, 415, 3, 342, 171, 0, 415, 416, 5, 17, 0, 0, 416, 417, 3, 346, 173, 0, 417, 418, 5, 18, 0, 0, 418, 433, 1, 0, 0, 0, 419, 433, 3, 64, 32, 0, 420, 433, 3, 152, 76, 0, 421, 433, 3, 322, 161, 0, 422, 433, 3, 12, 6, 0, 423, 433, 3, 14, 7, 0, 424, 433, 3, 16, 8, 0, 425, 433, 3, 18, 9, 0, 426, 433, 3, 20, 10, 0, 427, 433, 3, 26, 13, 0, 428, 433, 3, 42, 21, 0, 429, 433, 3, 40, 20, 0, 430, 433, 3, 30, 15, 0, 431, 433, 3, 24, 12, 0, 432, 382, 1, 0, 0, 0, 432, 387, 1, 0, 0, 0, 432, 392, 1, 0, 0, 0, 432, 397, 1, 0, 0, 0, 432, 398, 1, 0, 0, 0, 432, 399, 1, 0, 0, 0, 432, 400, 1, 0, 0, 0, 432, 401, 1, 0, 0, 0, 432, 402, 1, 0, 0, 0, 432, 403, 1, 0, 0, 0, 432, 404, 1, 0, 0, 0, 432, 409, 1, 0, 0, 0, 432, 414, 1, 0, 0, 0, 432, 419, 1, 0, 0, 0, 432, 420, 1, 0, 0, 0, 432, 421, 1, 0, 0, 0, 432, 422, 1, 0, 0, 0, 432, 423, 1, 0, 0, 0, 432, 424, 1, 0, 0, 0, 432, 425, 1, 0, 0, 0, 432, 426, 1, 0, 0, 0, 432, 427, 1, 0, 0, 0, 432, 428, 1, 0, 0, 0, 432, 429, 1, 0, 0, 0, 432, 430, 1, 0, 0, 0, 432, 431, 1, 0, 0, 0, 433, 11, 1, 0, 0, 0, 434, 435, 5, 19, 0, 0, 435, 436, 3, 32, 16, 0, 436, 13, 1, 0, 0, 0, 437, 438, 5, 20, 0, 0, 438, 439, 3, 32, 16, 0, 439, 15, 1, 0, 0, 0, 440, 441, 5, 21, 0, 0, 441, 442, 5, 22, 0, 0, 442, 443, 3, 32, 16, 0, 443, 17, 1, 0, 0, 0, 444, 445, 5, 23, 0, 0, 445, 446, 3, 34, 17, 0, 446, 19, 1, 0, 0, 0, 447, 448, 5, 24, 0, 0, 448, 449, 3, 34, 17, 0, 449, 21, 1, 0, 0, 0, 450, 451, 5, 25, 0, 0, 451, 452, 3, 98, 49, 0, 452, 453, 3, 2, 1, 0, 453, 454, 5, 17, 0, 0, 454, 455, 3, 120, 60, 0, 455, 456, 5, 18, 0, 0, 456, 23, 1, 0, 0, 0, 457, 458, 5, 26, 0, 0, 458, 25, 1, 0, 0, 0, 459, 460, 5, 27, 0, 0, 460, 474, 3, 28, 14, 0, 461, 462, 5, 27, 0, 0, 462, 463, 3, 28, 14, 0, 463, 464, 5, 28, 0, 0, 464, 465, 3, 28, 14, 0, 465, 474, 1, 0, 0, 0, 466, 467, 5, 27, 0, 0, 467, 468, 3, 28, 14, 0, 468, 469, 5, 28, 0, 0, 469, 470, 3, 28, 14, 0, 470, 471, 5, 28, 0, 0, 471, 472, 3, 28, 14, 0, 472, 474, 1, 0, 0, 0, 473, 459, 1, 0, 0, 0, 473, 461, 1, 0, 0, 0, 473, 466, 1, 0, 0, 0, 474, 27, 1, 0, 0, 0, 475, 476, 7, 2, 0, 0, 476, 29, 1, 0, 0, 0, 477, 478, 5, 29, 0, 0, 478, 482, 5, 17, 0, 0, 479, 481, 3, 116, 58, 0, 480, 479, 1, 0, 0, 0, 481, 484, 1, 0, 0, 0, 482, 480, 1, 0, 0, 0, 482, 483, 1, 0, 0, 0, 483, 485, 1, 0, 0, 0, 484, 482, 1, 0, 0, 0, 485, 486, 5, 18, 0, 0, 486, 31, 1, 0, 0, 0, 487, 488, 5, 173, 0, 0, 488, 33, 1, 0, 0, 0, 489, 490, 7, 3, 0, 0, 490, 35, 1, 0, 0, 0, 491, 507, 5, 175, 0, 0, 492, 493, 3, 32, 16, 0, 493, 494, 5, 265, 0, 0, 494, 507, 1, 0, 0, 0, 495, 507, 3, 32, 16, 0, 496, 497, 5, 188, 0, 0, 497, 498, 5, 30, 0, 0, 498, 499, 3, 32, 16, 0, 499, 500, 5, 31, 0, 0, 500, 507, 1, 0, 0, 0, 501, 502, 5, 189, 0, 0, 502, 503, 5, 30, 0, 0, 503, 504, 3, 34, 17, 0, 504, 505, 5, 31, 0, 0, 505, 507, 1, 0, 0, 0, 506, 491, 1, 0, 0, 0, 506, 492, 1, 0, 0, 0, 506, 495, 1, 0, 0, 0, 506, 496, 1, 0, 0, 0, 506, 501, 1, 0, 0, 0, 507, 37, 1, 0, 0, 0, 508, 511, 3, 32, 16, 0, 509, 511, 5, 262, 0, 0, 510, 508, 1, 0, 0, 0, 510, 509, 1, 0, 0, 0, 511, 39, 1, 0, 0, 0, 512, 513, 5, 267, 0, 0, 513, 529, 5, 289, 0, 0, 514, 515, 5, 267, 0, 0, 515, 516, 5, 289, 0, 0, 516, 529, 5, 263, 0, 0, 517, 518, 5, 268, 0, 0, 518, 529, 5, 289, 0, 0, 519, 520, 5, 269, 0, 0, 520, 529, 5, 289, 0, 0, 521, 522, 5, 270, 0, 0, 522, 529, 5, 289, 0, 0, 523, 529, 5, 271, 0, 0, 524, 529, 5, 272, 0, 0, 525, 526, 5, 273, 0, 0, 526, 529, 5, 263, 0, 0, 527, 529, 5, 32, 0, 0, 528, 512, 1, 0, 0, 0, 528, 514, 1, 0, 0, 0, 528, 517, 1, 0, 0, 0, 528, 519, 1, 0, 0, 0, 528, 521, 1, 0, 0, 0, 528, 523, 1, 0, 0, 0, 528, 524, 1, 0, 0, 0, 528, 525, 1, 0, 0, 0, 528, 527, 1, 0, 0, 0, 529, 41, 1, 0, 0, 0, 530, 531, 5, 33, 0, 0, 531, 532, 3, 138, 69, 0, 532, 533, 5, 34, 0, 0, 533, 534, 3, 2, 1, 0, 534, 556, 1, 0, 0, 0, 535, 536, 5, 33, 0, 0, 536, 537, 3, 116, 58, 0, 537, 538, 5, 34, 0, 0, 538, 539, 3, 2, 1, 0, 539, 556, 1, 0, 0, 0, 540, 541, 5, 33, 0, 0, 541, 542, 3, 176, 88, 0, 542, 543, 5, 34, 0, 0, 543, 544, 3, 2, 1, 0, 544, 556, 1, 0, 0, 0, 545, 546, 5, 33, 0, 0, 546, 547, 3, 44, 22, 0, 547, 548, 5, 34, 0, 0, 548, 549, 3, 2, 1, 0, 549, 556, 1, 0, 0, 0, 550, 551, 5, 33, 0, 0, 551, 552, 3, 46, 23, 0, 552, 553, 5, 34, 0, 0, 553, 554, 3, 2, 1, 0, 554, 556, 1, 0, 0, 0, 555, 530, 1, 0, 0, 0, 555, 535, 1, 0, 0, 0, 555, 540, 1, 0, 0, 0, 555, 545, 1, 0, 0, 0, 555, 550, 1, 0, 0, 0, 556, 43, 1, 0, 0, 0, 557, 558, 5, 35, 0, 0, 558, 579, 3, 48, 24, 0, 559, 560, 5, 35, 0, 0, 560, 561, 3, 48, 24, 0, 561, 562, 5, 36, 0, 0, 562, 563, 3, 6, 3, 0, 563, 579, 1, 0, 0, 0, 564, 565, 5, 35, 0, 0, 565, 566, 3, 48, 24, 0, 566, 567, 5, 36, 0, 0, 567, 568, 5, 17, 0, 0, 568, 569, 3, 52, 26, 0, 569, 570, 5, 18, 0, 0, 570, 579, 1, 0, 0, 0, 571, 572, 5, 35, 0, 0, 572, 573, 3, 48, 24, 0, 573, 574, 5, 36, 0, 0, 574, 575, 5, 30, 0, 0, 575, 576, 3, 292, 146, 0, 576, 577, 5, 31, 0, 0, 577, 579, 1, 0, 0, 0, 578, 557, 1, 0, 0, 0, 578, 559, 1, 0, 0, 0, 578, 564, 1, 0, 0, 0, 578, 571, 1, 0, 0, 0, 579, 45, 1, 0, 0, 0, 580, 581, 5, 35, 0, 0, 581, 582, 5, 30, 0, 0, 582, 583, 3, 50, 25, 0, 583, 584, 5, 31, 0, 0, 584, 585, 3, 48, 24, 0, 585, 615, 1, 0, 0, 0, 586, 587, 5, 35, 0, 0, 587, 588, 5, 30, 0, 0, 588, 589, 3, 50, 25, 0, 589, 590, 5, 31, 0, 0, 590, 591, 3, 48, 24, 0, 591, 592, 5, 36, 0, 0, 592, 593, 3, 6, 3, 0, 593, 615, 1, 0, 0, 0, 594, 595, 5, 35, 0, 0, 595, 596, 5, 30, 0, 0, 596, 597, 3, 50, 25, 0, 597, 598, 5, 31, 0, 0, 598, 599, 3, 48, 24, 0, 599, 600, 5, 36, 0, 0, 600, 601, 5, 17, 0, 0, 601, 602, 3, 52, 26, 0, 602, 603, 5, 18, 0, 0, 603, 615, 1, 0, 0, 0, 604, 605, 5, 35, 0, 0, 605, 606, 5, 30, 0, 0, 606, 607, 3, 50, 25, 0, 607, 608, 5, 31, 0, 0, 608, 609, 3, 48, 24, 0, 609, 610, 5, 36, 0, 0, 610, 611, 5, 30, 0, 0, 611, 612, 3, 292, 146, 0, 612, 613, 5, 31, 0, 0, 613, 615, 1, 0, 0, 0, 614, 580, 1, 0, 0, 0, 614, 586, 1, 0, 0, 0, 614, 594, 1, 0, 0, 0, 614, 604, 1, 0, 0, 0, 615, 47, 1, 0, 0, 0, 616, 617, 3, 168, 84, 0, 617, 49, 1, 0, 0, 0, 618, 621, 3, 124, 62, 0, 619, 621, 3, 176, 88, 0, 620, 618, 1, 0, 0, 0, 620, 619, 1, 0, 0, 0, 621, 51, 1, 0, 0, 0, 622, 623, 3, 54, 27, 0, 623, 624, 3, 56, 28, 0, 624, 53, 1, 0, 0, 0, 625, 628, 3, 298, 149, 0, 626, 628, 3, 40, 20, 0, 627, 625, 1, 0, 0, 0, 627, 626, 1, 0, 0, 0, 628, 631, 1, 0, 0, 0, 629, 627, 1, 0, 0, 0, 629, 630, 1, 0, 0, 0, 630, 55, 1, 0, 0, 0, 631, 629, 1, 0, 0, 0, 632, 633, 3, 58, 29, 0, 633, 634, 3, 60, 30, 0, 634, 635, 3, 2, 1, 0, 635, 636, 5, 36, 0, 0, 636, 637, 3, 298, 149, 0, 637, 640, 1, 0, 0, 0, 638, 640, 3, 40, 20, 0, 639, 632, 1, 0, 0, 0, 639, 638, 1, 0, 0, 0, 640, 643, 1, 0, 0, 0, 641, 639, 1, 0, 0, 0, 641, 642, 1, 0, 0, 0, 642, 57, 1, 0, 0, 0, 643, 641, 1, 0, 0, 0, 644, 645, 7, 4, 0, 0, 645, 59, 1, 0, 0, 0, 646, 648, 3, 62, 31, 0, 647, 649, 5, 261, 0, 0, 648, 647, 1, 0, 0, 0, 648, 649, 1, 0, 0, 0, 649, 61, 1, 0, 0, 0, 650, 660, 3, 144, 72, 0, 651, 660, 3, 2, 1, 0, 652, 660, 5, 196, 0, 0, 653, 660, 5, 197, 0, 0, 654, 655, 5, 202, 0, 0, 655, 656, 5, 39, 0, 0, 656, 660, 5, 264, 0, 0, 657, 658, 5, 202, 0, 0, 658, 660, 3, 116, 58, 0, 659, 650, 1, 0, 0, 0, 659, 651, 1, 0, 0, 0, 659, 652, 1, 0, 0, 0, 659, 653, 1, 0, 0, 0, 659, 654, 1, 0, 0, 0, 659, 657, 1, 0, 0, 0, 660, 63, 1, 0, 0, 0, 661, 662, 5, 198, 0, 0, 662, 663, 5, 40, 0, 0, 663, 668, 3, 2, 1, 0, 664, 665, 5, 198, 0, 0, 665, 668, 3, 2, 1, 0, 666, 668, 5, 198, 0, 0, 667, 661, 1, 0, 0, 0, 667, 664, 1, 0, 0, 0, 667, 666, 1, 0, 0, 0, 668, 65, 1, 0, 0, 0, 669, 670, 5, 41, 0, 0, 670, 671, 5, 42, 0, 0, 671, 672, 3, 32, 16, 0, 672, 673, 5, 43, 0, 0, 673, 674, 3, 68, 34, 0, 674, 675, 5, 44, 0, 0, 675, 676, 3, 0, 0, 0, 676, 67, 1, 0, 0, 0, 677, 690, 6, 34, -1, 0, 678, 679, 10, 5, 0, 0, 679, 689, 5, 186, 0, 0, 680, 681, 10, 4, 0, 0, 681, 689, 5, 187, 0, 0, 682, 683, 10, 3, 0, 0, 683, 689, 5, 45, 0, 0, 684, 685, 10, 2, 0, 0, 685, 689, 5, 46, 0, 0, 686, 687, 10, 1, 0, 0, 687, 689, 5, 47, 0, 0, 688, 678, 1, 0, 0, 0, 688, 680, 1, 0, 0, 0, 688, 682, 1, 0, 0, 0, 688, 684, 1, 0, 0, 0, 688, 686, 1, 0, 0, 0, 689, 692, 1, 0, 0, 0, 690, 688, 1, 0, 0, 0, 690, 691, 1, 0, 0, 0, 691, 69, 1, 0, 0, 0, 692, 690, 1, 0, 0, 0, 693, 694, 5, 48, 0, 0, 694, 695, 5, 36, 0, 0, 695, 696, 5, 30, 0, 0, 696, 697, 3, 292, 146, 0, 697, 698, 5, 31, 0, 0, 698, 71, 1, 0, 0, 0, 699, 700, 5, 49, 0, 0, 700, 701, 3, 2, 1, 0, 701, 73, 1, 0, 0, 0, 702, 706, 5, 50, 0, 0, 703, 705, 3, 76, 38, 0, 704, 703, 1, 0, 0, 0, 705, 708, 1, 0, 0, 0, 706, 704, 1, 0, 0, 0, 706, 707, 1, 0, 0, 0, 707, 709, 1, 0, 0, 0, 708, 706, 1, 0, 0, 0, 709, 710, 3, 2, 1, 0, 710, 711, 3, 182, 91, 0, 711, 712, 3, 78, 39, 0, 712, 713, 3, 80, 40, 0, 713, 75, 1, 0, 0, 0, 714, 752, 5, 51, 0, 0, 715, 752, 5, 52, 0, 0, 716, 752, 5, 199, 0, 0, 717, 752, 5, 202, 0, 0, 718, 752, 5, 221, 0, 0, 719, 752, 5, 53, 0, 0, 720, 752, 5, 54, 0, 0, 721, 752, 5, 55, 0, 0, 722, 752, 5, 56, 0, 0, 723, 752, 5, 244, 0, 0, 724, 752, 5, 15, 0, 0, 725, 752, 5, 224, 0, 0, 726, 752, 5, 57, 0, 0, 727, 752, 5, 58, 0, 0, 728, 752, 5, 59, 0, 0, 729, 752, 5, 60, 0, 0, 730, 752, 5, 61, 0, 0, 731, 732, 5, 62, 0, 0, 732, 752, 5, 51, 0, 0, 733, 734, 5, 62, 0, 0, 734, 752, 5, 52, 0, 0, 735, 736, 5, 62, 0, 0, 736, 752, 5, 63, 0, 0, 737, 738, 5, 62, 0, 0, 738, 752, 5, 64, 0, 0, 739, 740, 5, 62, 0, 0, 740, 752, 5, 65, 0, 0, 741, 742, 5, 62, 0, 0, 742, 752, 5, 66, 0, 0, 743, 752, 5, 67, 0, 0, 744, 752, 5, 68, 0, 0, 745, 752, 5, 69, 0, 0, 746, 747, 5, 70, 0, 0, 747, 748, 5, 30, 0, 0, 748, 749, 3, 32, 16, 0, 749, 750, 5, 31, 0, 0, 750, 752, 1, 0, 0, 0, 751, 714, 1, 0, 0, 0, 751, 715, 1, 0, 0, 0, 751, 716, 1, 0, 0, 0, 751, 717, 1, 0, 0, 0, 751, 718, 1, 0, 0, 0, 751, 719, 1, 0, 0, 0, 751, 720, 1, 0, 0, 0, 751, 721, 1, 0, 0, 0, 751, 722, 1, 0, 0, 0, 751, 723, 1, 0, 0, 0, 751, 724, 1, 0, 0, 0, 751, 725, 1, 0, 0, 0, 751, 726, 1, 0, 0, 0, 751, 727, 1, 0, 0, 0, 751, 728, 1, 0, 0, 0, 751, 729, 1, 0, 0, 0, 751, 730, 1, 0, 0, 0, 751, 731, 1, 0, 0, 0, 751, 733, 1, 0, 0, 0, 751, 735, 1, 0, 0, 0, 751, 737, 1, 0, 0, 0, 751, 739, 1, 0, 0, 0, 751, 741, 1, 0, 0, 0, 751, 743, 1, 0, 0, 0, 751, 744, 1, 0, 0, 0, 751, 745, 1, 0, 0, 0, 751, 746, 1, 0, 0, 0, 752, 77, 1, 0, 0, 0, 753, 757, 1, 0, 0, 0, 754, 755, 5, 71, 0, 0, 755, 757, 3, 124, 62, 0, 756, 753, 1, 0, 0, 0, 756, 754, 1, 0, 0, 0, 757, 79, 1, 0, 0, 0, 758, 762, 1, 0, 0, 0, 759, 760, 5, 72, 0, 0, 760, 762, 3, 84, 42, 0, 761, 758, 1, 0, 0, 0, 761, 759, 1, 0, 0, 0, 762, 81, 1, 0, 0, 0, 763, 765, 3, 198, 99, 0, 764, 763, 1, 0, 0, 0, 765, 768, 1, 0, 0, 0, 766, 764, 1, 0, 0, 0, 766, 767, 1, 0, 0, 0, 767, 83, 1, 0, 0, 0, 768, 766, 1, 0, 0, 0, 769, 770, 3, 124, 62, 0, 770, 771, 5, 28, 0, 0, 771, 773, 1, 0, 0, 0, 772, 769, 1, 0, 0, 0, 773, 776, 1, 0, 0, 0, 774, 772, 1, 0, 0, 0, 774, 775, 1, 0, 0, 0, 775, 777, 1, 0, 0, 0, 776, 774, 1, 0, 0, 0, 777, 778, 3, 124, 62, 0, 778, 85, 1, 0, 0, 0, 779, 780, 7, 5, 0, 0, 780, 87, 1, 0, 0, 0, 781, 782, 3, 86, 43, 0, 782, 783, 3, 32, 16, 0, 783, 784, 5, 264, 0, 0, 784, 885, 1, 0, 0, 0, 785, 786, 3, 86, 43, 0, 786, 787, 3, 32, 16, 0, 787, 885, 1, 0, 0, 0, 788, 789, 3, 86, 43, 0, 789, 790, 3, 32, 16, 0, 790, 791, 5, 75, 0, 0, 791, 792, 3, 32, 16, 0, 792, 793, 5, 264, 0, 0, 793, 885, 1, 0, 0, 0, 794, 795, 3, 86, 43, 0, 795, 796, 3, 32, 16, 0, 796, 797, 5, 75, 0, 0, 797, 798, 3, 32, 16, 0, 798, 885, 1, 0, 0, 0, 799, 800, 3, 86, 43, 0, 800, 801, 3, 32, 16, 0, 801, 802, 5, 75, 0, 0, 802, 803, 3, 32, 16, 0, 803, 804, 5, 28, 0, 0, 804, 805, 3, 32, 16, 0, 805, 806, 5, 264, 0, 0, 806, 885, 1, 0, 0, 0, 807, 808, 3, 86, 43, 0, 808, 809, 3, 32, 16, 0, 809, 810, 5, 75, 0, 0, 810, 811, 3, 32, 16, 0, 811, 812, 5, 28, 0, 0, 812, 813, 3, 32, 16, 0, 813, 885, 1, 0, 0, 0, 814, 815, 3, 86, 43, 0, 815, 816, 3, 32, 16, 0, 816, 817, 5, 28, 0, 0, 817, 818, 3, 32, 16, 0, 818, 819, 5, 75, 0, 0, 819, 820, 3, 32, 16, 0, 820, 821, 5, 264, 0, 0, 821, 885, 1, 0, 0, 0, 822, 823, 3, 86, 43, 0, 823, 824, 3, 32, 16, 0, 824, 825, 5, 28, 0, 0, 825, 826, 3, 32, 16, 0, 826, 827, 5, 75, 0, 0, 827, 828, 3, 32, 16, 0, 828, 885, 1, 0, 0, 0, 829, 830, 3, 86, 43, 0, 830, 831, 3, 32, 16, 0, 831, 832, 5, 28, 0, 0, 832, 833, 3, 32, 16, 0, 833, 834, 5, 75, 0, 0, 834, 835, 3, 32, 16, 0, 835, 836, 5, 28, 0, 0, 836, 837, 3, 32, 16, 0, 837, 838, 5, 264, 0, 0, 838, 885, 1, 0, 0, 0, 839, 840, 3, 86, 43, 0, 840, 841, 3, 32, 16, 0, 841, 842, 5, 28, 0, 0, 842, 843, 3, 32, 16, 0, 843, 844, 5, 75, 0, 0, 844, 845, 3, 32, 16, 0, 845, 846, 5, 28, 0, 0, 846, 847, 3, 32, 16, 0, 847, 885, 1, 0, 0, 0, 848, 849, 3, 86, 43, 0, 849, 850, 3, 32, 16, 0, 850, 851, 5, 263, 0, 0, 851, 885, 1, 0, 0, 0, 852, 853, 3, 86, 43, 0, 853, 854, 3, 32, 16, 0, 854, 855, 5, 75, 0, 0, 855, 856, 3, 32, 16, 0, 856, 857, 5, 263, 0, 0, 857, 885, 1, 0, 0, 0, 858, 859, 3, 86, 43, 0, 859, 860, 3, 32, 16, 0, 860, 861, 5, 75, 0, 0, 861, 862, 3, 32, 16, 0, 862, 863, 5, 28, 0, 0, 863, 864, 3, 32, 16, 0, 864, 865, 5, 263, 0, 0, 865, 885, 1, 0, 0, 0, 866, 867, 3, 86, 43, 0, 867, 868, 3, 32, 16, 0, 868, 869, 5, 28, 0, 0, 869, 870, 3, 32, 16, 0, 870, 871, 5, 75, 0, 0, 871, 872, 3, 32, 16, 0, 872, 873, 5, 263, 0, 0, 873, 885, 1, 0, 0, 0, 874, 875, 3, 86, 43, 0, 875, 876, 3, 32, 16, 0, 876, 877, 5, 28, 0, 0, 877, 878, 3, 32, 16, 0, 878, 879, 5, 75, 0, 0, 879, 880, 3, 32, 16, 0, 880, 881, 5, 28, 0, 0, 881, 882, 3, 32, 16, 0, 882, 883, 5, 263, 0, 0, 883, 885, 1, 0, 0, 0, 884, 781, 1, 0, 0, 0, 884, 785, 1, 0, 0, 0, 884, 788, 1, 0, 0, 0, 884, 794, 1, 0, 0, 0, 884, 799, 1, 0, 0, 0, 884, 807, 1, 0, 0, 0, 884, 814, 1, 0, 0, 0, 884, 822, 1, 0, 0, 0, 884, 829, 1, 0, 0, 0, 884, 839, 1, 0, 0, 0, 884, 848, 1, 0, 0, 0, 884, 852, 1, 0, 0, 0, 884, 858, 1, 0, 0, 0, 884, 866, 1, 0, 0, 0, 884, 874, 1, 0, 0, 0, 885, 89, 1, 0, 0, 0, 886, 890, 5, 21, 0, 0, 887, 889, 3, 92, 46, 0, 888, 887, 1, 0, 0, 0, 889, 892, 1, 0, 0, 0, 890, 888, 1, 0, 0, 0, 890, 891, 1, 0, 0, 0, 891, 893, 1, 0, 0, 0, 892, 890, 1, 0, 0, 0, 893, 894, 3, 2, 1, 0, 894, 895, 3, 94, 47, 0, 895, 896, 5, 180, 0, 0, 896, 897, 5, 36, 0, 0, 897, 898, 5, 30, 0, 0, 898, 899, 3, 292, 146, 0, 899, 900, 5, 31, 0, 0, 900, 901, 3, 94, 47, 0, 901, 913, 1, 0, 0, 0, 902, 906, 5, 21, 0, 0, 903, 905, 3, 92, 46, 0, 904, 903, 1, 0, 0, 0, 905, 908, 1, 0, 0, 0, 906, 904, 1, 0, 0, 0, 906, 907, 1, 0, 0, 0, 907, 909, 1, 0, 0, 0, 908, 906, 1, 0, 0, 0, 909, 910, 3, 2, 1, 0, 910, 911, 3, 94, 47, 0, 911, 913, 1, 0, 0, 0, 912, 886, 1, 0, 0, 0, 912, 902, 1, 0, 0, 0, 913, 91, 1, 0, 0, 0, 914, 915, 5, 76, 0, 0, 915, 93, 1, 0, 0, 0, 916, 919, 1, 0, 0, 0, 917, 919, 5, 298, 0, 0, 918, 916, 1, 0, 0, 0, 918, 917, 1, 0, 0, 0, 919, 95, 1, 0, 0, 0, 920, 921, 7, 6, 0, 0, 921, 97, 1, 0, 0, 0, 922, 924, 3, 96, 48, 0, 923, 922, 1, 0, 0, 0, 924, 927, 1, 0, 0, 0, 925, 923, 1, 0, 0, 0, 925, 926, 1, 0, 0, 0, 926, 99, 1, 0, 0, 0, 927, 925, 1, 0, 0, 0, 928, 931, 3, 102, 51, 0, 929, 931, 3, 104, 52, 0, 930, 928, 1, 0, 0, 0, 930, 929, 1, 0, 0, 0, 931, 101, 1, 0, 0, 0, 932, 933, 5, 275, 0, 0, 933, 983, 6, 51, -1, 0, 934, 935, 5, 276, 0, 0, 935, 936, 3, 32, 16, 0, 936, 937, 6, 51, -1, 0, 937, 983, 1, 0, 0, 0, 938, 939, 5, 276, 0, 0, 939, 940, 3, 0, 0, 0, 940, 941, 6, 51, -1, 0, 941, 983, 1, 0, 0, 0, 942, 943, 5, 277, 0, 0, 943, 944, 3, 32, 16, 0, 944, 945, 6, 51, -1, 0, 945, 983, 1, 0, 0, 0, 946, 947, 5, 278, 0, 0, 947, 948, 3, 34, 17, 0, 948, 949, 6, 51, -1, 0, 949, 983, 1, 0, 0, 0, 950, 951, 5, 279, 0, 0, 951, 952, 5, 30, 0, 0, 952, 953, 3, 292, 146, 0, 953, 954, 5, 31, 0, 0, 954, 955, 6, 51, -1, 0, 955, 983, 1, 0, 0, 0, 956, 957, 5, 279, 0, 0, 957, 958, 5, 84, 0, 0, 958, 959, 5, 30, 0, 0, 959, 960, 3, 292, 146, 0, 960, 961, 5, 31, 0, 0, 961, 962, 6, 51, -1, 0, 962, 983, 1, 0, 0, 0, 963, 964, 5, 282, 0, 0, 964, 965, 3, 32, 16, 0, 965, 966, 6, 51, -1, 0, 966, 983, 1, 0, 0, 0, 967, 968, 5, 282, 0, 0, 968, 969, 3, 0, 0, 0, 969, 970, 6, 51, -1, 0, 970, 983, 1, 0, 0, 0, 971, 972, 5, 285, 0, 0, 972, 973, 5, 84, 0, 0, 973, 974, 5, 30, 0, 0, 974, 975, 3, 292, 146, 0, 975, 976, 5, 31, 0, 0, 976, 977, 6, 51, -1, 0, 977, 983, 1, 0, 0, 0, 978, 979, 5, 287, 0, 0, 979, 980, 3, 32, 16, 0, 980, 981, 6, 51, -1, 0, 981, 983, 1, 0, 0, 0, 982, 932, 1, 0, 0, 0, 982, 934, 1, 0, 0, 0, 982, 938, 1, 0, 0, 0, 982, 942, 1, 0, 0, 0, 982, 946, 1, 0, 0, 0, 982, 950, 1, 0, 0, 0, 982, 956, 1, 0, 0, 0, 982, 963, 1, 0, 0, 0, 982, 967, 1, 0, 0, 0, 982, 971, 1, 0, 0, 0, 982, 978, 1, 0, 0, 0, 983, 103, 1, 0, 0, 0, 984, 985, 5, 279, 0, 0, 985, 1019, 3, 36, 18, 0, 986, 987, 5, 279, 0, 0, 987, 1019, 3, 34, 17, 0, 988, 989, 5, 280, 0, 0, 989, 1019, 3, 168, 84, 0, 990, 991, 5, 286, 0, 0, 991, 1019, 3, 178, 89, 0, 992, 993, 5, 286, 0, 0, 993, 1019, 3, 174, 87, 0, 994, 995, 5, 284, 0, 0, 995, 1019, 3, 124, 62, 0, 996, 997, 5, 285, 0, 0, 997, 1019, 3, 6, 3, 0, 998, 999, 5, 285, 0, 0, 999, 1000, 5, 224, 0, 0, 1000, 1001, 5, 30, 0, 0, 1001, 1002, 3, 6, 3, 0, 1002, 1003, 5, 31, 0, 0, 1003, 1019, 1, 0, 0, 0, 1004, 1005, 5, 281, 0, 0, 1005, 1006, 3, 170, 85, 0, 1006, 1007, 3, 138, 69, 0, 1007, 1008, 3, 112, 56, 0, 1008, 1019, 1, 0, 0, 0, 1009, 1010, 5, 287, 0, 0, 1010, 1019, 3, 50, 25, 0, 1011, 1012, 5, 283, 0, 0, 1012, 1013, 5, 30, 0, 0, 1013, 1014, 3, 106, 53, 0, 1014, 1015, 5, 31, 0, 0, 1015, 1019, 1, 0, 0, 0, 1016, 1017, 5, 283, 0, 0, 1017, 1019, 5, 85, 0, 0, 1018, 984, 1, 0, 0, 0, 1018, 986, 1, 0, 0, 0, 1018, 988, 1, 0, 0, 0, 1018, 990, 1, 0, 0, 0, 1018, 992, 1, 0, 0, 0, 1018, 994, 1, 0, 0, 0, 1018, 996, 1, 0, 0, 0, 1018, 998, 1, 0, 0, 0, 1018, 1004, 1, 0, 0, 0, 1018, 1009, 1, 0, 0, 0, 1018, 1011, 1, 0, 0, 0, 1018, 1016, 1, 0, 0, 0, 1019, 105, 1, 0, 0, 0, 1020, 1037, 1, 0, 0, 0, 1021, 1024, 3, 0, 0, 0, 1022, 1024, 3, 32, 16, 0, 1023, 1021, 1, 0, 0, 0, 1023, 1022, 1, 0, 0, 0, 1024, 1025, 1, 0, 0, 0, 1025, 1026, 5, 28, 0, 0, 1026, 1028, 1, 0, 0, 0, 1027, 1023, 1, 0, 0, 0, 1028, 1031, 1, 0, 0, 0, 1029, 1027, 1, 0, 0, 0, 1029, 1030, 1, 0, 0, 0, 1030, 1034, 1, 0, 0, 0, 1031, 1029, 1, 0, 0, 0, 1032, 1035, 3, 0, 0, 0, 1033, 1035, 3, 32, 16, 0, 1034, 1032, 1, 0, 0, 0, 1034, 1033, 1, 0, 0, 0, 1035, 1037, 1, 0, 0, 0, 1036, 1020, 1, 0, 0, 0, 1036, 1029, 1, 0, 0, 0, 1037, 107, 1, 0, 0, 0, 1038, 1044, 5, 86, 0, 0, 1039, 1040, 3, 138, 69, 0, 1040, 1041, 5, 28, 0, 0, 1041, 1043, 1, 0, 0, 0, 1042, 1039, 1, 0, 0, 0, 1043, 1046, 1, 0, 0, 0, 1044, 1042, 1, 0, 0, 0, 1044, 1045, 1, 0, 0, 0, 1045, 1047, 1, 0, 0, 0, 1046, 1044, 1, 0, 0, 0, 1047, 1048, 3, 138, 69, 0, 1048, 1049, 5, 87, 0, 0, 1049, 109, 1, 0, 0, 0, 1050, 1056, 5, 42, 0, 0, 1051, 1052, 3, 146, 73, 0, 1052, 1053, 5, 28, 0, 0, 1053, 1055, 1, 0, 0, 0, 1054, 1051, 1, 0, 0, 0, 1055, 1058, 1, 0, 0, 0, 1056, 1054, 1, 0, 0, 0, 1056, 1057, 1, 0, 0, 0, 1057, 1059, 1, 0, 0, 0, 1058, 1056, 1, 0, 0, 0, 1059, 1060, 3, 146, 73, 0, 1060, 1061, 5, 43, 0, 0, 1061, 111, 1, 0, 0, 0, 1062, 1068, 5, 30, 0, 0, 1063, 1064, 3, 114, 57, 0, 1064, 1065, 5, 28, 0, 0, 1065, 1067, 1, 0, 0, 0, 1066, 1063, 1, 0, 0, 0, 1067, 1070, 1, 0, 0, 0, 1068, 1066, 1, 0, 0, 0, 1068, 1069, 1, 0, 0, 0, 1069, 1071, 1, 0, 0, 0, 1070, 1068, 1, 0, 0, 0, 1071, 1072, 3, 114, 57, 0, 1072, 1073, 5, 31, 0, 0, 1073, 1076, 1, 0, 0, 0, 1074, 1076, 5, 85, 0, 0, 1075, 1062, 1, 0, 0, 0, 1075, 1074, 1, 0, 0, 0, 1076, 113, 1, 0, 0, 0, 1077, 1085, 5, 177, 0, 0, 1078, 1079, 3, 230, 115, 0, 1079, 1080, 3, 138, 69, 0, 1080, 1082, 3, 226, 113, 0, 1081, 1083, 3, 0, 0, 0, 1082, 1081, 1, 0, 0, 0, 1082, 1083, 1, 0, 0, 0, 1083, 1085, 1, 0, 0, 0, 1084, 1077, 1, 0, 0, 0, 1084, 1078, 1, 0, 0, 0, 1085, 115, 1, 0, 0, 0, 1086, 1087, 5, 42, 0, 0, 1087, 1088, 3, 2, 1, 0, 1088, 1089, 5, 43, 0, 0, 1089, 1090, 3, 118, 59, 0, 1090, 1112, 1, 0, 0, 0, 1091, 1092, 5, 42, 0, 0, 1092, 1093, 3, 174, 87, 0, 1093, 1094, 5, 43, 0, 0, 1094, 1095, 3, 118, 59, 0, 1095, 1112, 1, 0, 0, 0, 1096, 1097, 5, 42, 0, 0, 1097, 1098, 5, 262, 0, 0, 1098, 1099, 5, 43, 0, 0, 1099, 1112, 3, 118, 59, 0, 1100, 1101, 5, 42, 0, 0, 1101, 1102, 5, 198, 0, 0, 1102, 1103, 3, 2, 1, 0, 1103, 1104, 5, 43, 0, 0, 1104, 1105, 3, 118, 59, 0, 1105, 1112, 1, 0, 0, 0, 1106, 1112, 3, 118, 59, 0, 1107, 1112, 3, 174, 87, 0, 1108, 1112, 5, 257, 0, 0, 1109, 1112, 5, 258, 0, 0, 1110, 1112, 5, 259, 0, 0, 1111, 1086, 1, 0, 0, 0, 1111, 1091, 1, 0, 0, 0, 1111, 1096, 1, 0, 0, 0, 1111, 1100, 1, 0, 0, 0, 1111, 1106, 1, 0, 0, 0, 1111, 1107, 1, 0, 0, 0, 1111, 1108, 1, 0, 0, 0, 1111, 1109, 1, 0, 0, 0, 1111, 1110, 1, 0, 0, 0, 1112, 117, 1, 0, 0, 0, 1113, 1114, 3, 2, 1, 0, 1114, 1115, 5, 88, 0, 0, 1115, 1117, 1, 0, 0, 0, 1116, 1113, 1, 0, 0, 0, 1117, 1120, 1, 0, 0, 0, 1118, 1116, 1, 0, 0, 0, 1118, 1119, 1, 0, 0, 0, 1119, 1121, 1, 0, 0, 0, 1120, 1118, 1, 0, 0, 0, 1121, 1122, 3, 2, 1, 0, 1122, 119, 1, 0, 0, 0, 1123, 1125, 3, 122, 61, 0, 1124, 1123, 1, 0, 0, 0, 1125, 1128, 1, 0, 0, 0, 1126, 1124, 1, 0, 0, 0, 1126, 1127, 1, 0, 0, 0, 1127, 121, 1, 0, 0, 0, 1128, 1126, 1, 0, 0, 0, 1129, 1130, 5, 180, 0, 0, 1130, 1131, 5, 89, 0, 0, 1131, 1135, 3, 32, 16, 0, 1132, 1135, 3, 152, 76, 0, 1133, 1135, 3, 324, 162, 0, 1134, 1129, 1, 0, 0, 0, 1134, 1132, 1, 0, 0, 0, 1134, 1133, 1, 0, 0, 0, 1135, 123, 1, 0, 0, 0, 1136, 1148, 3, 116, 58, 0, 1137, 1138, 5, 42, 0, 0, 1138, 1139, 3, 2, 1, 0, 1139, 1140, 5, 43, 0, 0, 1140, 1148, 1, 0, 0, 0, 1141, 1142, 5, 42, 0, 0, 1142, 1143, 5, 198, 0, 0, 1143, 1144, 3, 2, 1, 0, 1144, 1145, 5, 43, 0, 0, 1145, 1148, 1, 0, 0, 0, 1146, 1148, 3, 138, 69, 0, 1147, 1136, 1, 0, 0, 0, 1147, 1137, 1, 0, 0, 0, 1147, 1141, 1, 0, 0, 0, 1147, 1146, 1, 0, 0, 0, 1148, 125, 1, 0, 0, 0, 1149, 1158, 1, 0, 0, 0, 1150, 1154, 3, 130, 65, 0, 1151, 1153, 3, 128, 64, 0, 1152, 1151, 1, 0, 0, 0, 1153, 1156, 1, 0, 0, 0, 1154, 1152, 1, 0, 0, 0, 1154, 1155, 1, 0, 0, 0, 1155, 1158, 1, 0, 0, 0, 1156, 1154, 1, 0, 0, 0, 1157, 1149, 1, 0, 0, 0, 1157, 1150, 1, 0, 0, 0, 1158, 127, 1, 0, 0, 0, 1159, 1177, 5, 262, 0, 0, 1160, 1177, 5, 261, 0, 0, 1161, 1162, 5, 42, 0, 0, 1162, 1163, 3, 32, 16, 0, 1163, 1164, 5, 43, 0, 0, 1164, 1177, 1, 0, 0, 0, 1165, 1166, 5, 42, 0, 0, 1166, 1167, 3, 32, 16, 0, 1167, 1168, 5, 266, 0, 0, 1168, 1169, 3, 32, 16, 0, 1169, 1170, 5, 43, 0, 0, 1170, 1177, 1, 0, 0, 0, 1171, 1172, 5, 42, 0, 0, 1172, 1173, 5, 266, 0, 0, 1173, 1174, 3, 32, 16, 0, 1174, 1175, 5, 43, 0, 0, 1175, 1177, 1, 0, 0, 0, 1176, 1159, 1, 0, 0, 0, 1176, 1160, 1, 0, 0, 0, 1176, 1161, 1, 0, 0, 0, 1176, 1165, 1, 0, 0, 0, 1176, 1171, 1, 0, 0, 0, 1177, 129, 1, 0, 0, 0, 1178, 1271, 1, 0, 0, 0, 1179, 1180, 5, 203, 0, 0, 1180, 1181, 5, 30, 0, 0, 1181, 1182, 3, 6, 3, 0, 1182, 1183, 5, 28, 0, 0, 1183, 1184, 3, 6, 3, 0, 1184, 1185, 5, 28, 0, 0, 1185, 1186, 3, 6, 3, 0, 1186, 1187, 5, 28, 0, 0, 1187, 1188, 3, 6, 3, 0, 1188, 1189, 5, 31, 0, 0, 1189, 1271, 1, 0, 0, 0, 1190, 1191, 5, 203, 0, 0, 1191, 1192, 5, 30, 0, 0, 1192, 1193, 3, 6, 3, 0, 1193, 1194, 5, 28, 0, 0, 1194, 1195, 3, 6, 3, 0, 1195, 1196, 5, 31, 0, 0, 1196, 1271, 1, 0, 0, 0, 1197, 1198, 5, 204, 0, 0, 1198, 1199, 5, 205, 0, 0, 1199, 1200, 5, 42, 0, 0, 1200, 1201, 3, 32, 16, 0, 1201, 1202, 5, 43, 0, 0, 1202, 1271, 1, 0, 0, 0, 1203, 1204, 5, 204, 0, 0, 1204, 1205, 5, 206, 0, 0, 1205, 1206, 5, 42, 0, 0, 1206, 1207, 3, 32, 16, 0, 1207, 1208, 5, 43, 0, 0, 1208, 1209, 3, 126, 63, 0, 1209, 1271, 1, 0, 0, 0, 1210, 1271, 5, 207, 0, 0, 1211, 1271, 5, 208, 0, 0, 1212, 1271, 5, 209, 0, 0, 1213, 1271, 5, 201, 0, 0, 1214, 1271, 5, 183, 0, 0, 1215, 1271, 5, 184, 0, 0, 1216, 1271, 5, 185, 0, 0, 1217, 1271, 5, 186, 0, 0, 1218, 1271, 5, 187, 0, 0, 1219, 1271, 5, 188, 0, 0, 1220, 1271, 5, 189, 0, 0, 1221, 1271, 5, 210, 0, 0, 1222, 1271, 5, 190, 0, 0, 1223, 1271, 5, 191, 0, 0, 1224, 1271, 5, 192, 0, 0, 1225, 1271, 5, 193, 0, 0, 1226, 1271, 5, 211, 0, 0, 1227, 1271, 5, 212, 0, 0, 1228, 1271, 5, 213, 0, 0, 1229, 1271, 5, 214, 0, 0, 1230, 1271, 5, 215, 0, 0, 1231, 1271, 5, 216, 0, 0, 1232, 1271, 5, 217, 0, 0, 1233, 1234, 5, 218, 0, 0, 1234, 1271, 3, 132, 66, 0, 1235, 1236, 5, 219, 0, 0, 1236, 1271, 3, 132, 66, 0, 1237, 1271, 5, 220, 0, 0, 1238, 1239, 5, 221, 0, 0, 1239, 1271, 3, 132, 66, 0, 1240, 1241, 5, 222, 0, 0, 1241, 1271, 3, 134, 67, 0, 1242, 1243, 5, 222, 0, 0, 1243, 1244, 3, 134, 67, 0, 1244, 1245, 5, 28, 0, 0, 1245, 1246, 3, 6, 3, 0, 1246, 1271, 1, 0, 0, 0, 1247, 1271, 5, 194, 0, 0, 1248, 1271, 5, 195, 0, 0, 1249, 1250, 5, 90, 0, 0, 1250, 1271, 5, 184, 0, 0, 1251, 1252, 5, 90, 0, 0, 1252, 1271, 5, 185, 0, 0, 1253, 1254, 5, 90, 0, 0, 1254, 1271, 5, 186, 0, 0, 1255, 1256, 5, 90, 0, 0, 1256, 1271, 5, 187, 0, 0, 1257, 1258, 5, 62, 0, 0, 1258, 1271, 5, 220, 0, 0, 1259, 1271, 5, 223, 0, 0, 1260, 1261, 5, 224, 0, 0, 1261, 1271, 5, 213, 0, 0, 1262, 1271, 5, 225, 0, 0, 1263, 1264, 5, 207, 0, 0, 1264, 1271, 5, 183, 0, 0, 1265, 1271, 5, 226, 0, 0, 1266, 1271, 5, 228, 0, 0, 1267, 1268, 5, 34, 0, 0, 1268, 1271, 5, 227, 0, 0, 1269, 1271, 3, 2, 1, 0, 1270, 1178, 1, 0, 0, 0, 1270, 1179, 1, 0, 0, 0, 1270, 1190, 1, 0, 0, 0, 1270, 1197, 1, 0, 0, 0, 1270, 1203, 1, 0, 0, 0, 1270, 1210, 1, 0, 0, 0, 1270, 1211, 1, 0, 0, 0, 1270, 1212, 1, 0, 0, 0, 1270, 1213, 1, 0, 0, 0, 1270, 1214, 1, 0, 0, 0, 1270, 1215, 1, 0, 0, 0, 1270, 1216, 1, 0, 0, 0, 1270, 1217, 1, 0, 0, 0, 1270, 1218, 1, 0, 0, 0, 1270, 1219, 1, 0, 0, 0, 1270, 1220, 1, 0, 0, 0, 1270, 1221, 1, 0, 0, 0, 1270, 1222, 1, 0, 0, 0, 1270, 1223, 1, 0, 0, 0, 1270, 1224, 1, 0, 0, 0, 1270, 1225, 1, 0, 0, 0, 1270, 1226, 1, 0, 0, 0, 1270, 1227, 1, 0, 0, 0, 1270, 1228, 1, 0, 0, 0, 1270, 1229, 1, 0, 0, 0, 1270, 1230, 1, 0, 0, 0, 1270, 1231, 1, 0, 0, 0, 1270, 1232, 1, 0, 0, 0, 1270, 1233, 1, 0, 0, 0, 1270, 1235, 1, 0, 0, 0, 1270, 1237, 1, 0, 0, 0, 1270, 1238, 1, 0, 0, 0, 1270, 1240, 1, 0, 0, 0, 1270, 1242, 1, 0, 0, 0, 1270, 1247, 1, 0, 0, 0, 1270, 1248, 1, 0, 0, 0, 1270, 1249, 1, 0, 0, 0, 1270, 1251, 1, 0, 0, 0, 1270, 1253, 1, 0, 0, 0, 1270, 1255, 1, 0, 0, 0, 1270, 1257, 1, 0, 0, 0, 1270, 1259, 1, 0, 0, 0, 1270, 1260, 1, 0, 0, 0, 1270, 1262, 1, 0, 0, 0, 1270, 1263, 1, 0, 0, 0, 1270, 1265, 1, 0, 0, 0, 1270, 1266, 1, 0, 0, 0, 1270, 1267, 1, 0, 0, 0, 1270, 1269, 1, 0, 0, 0, 1271, 131, 1, 0, 0, 0, 1272, 1280, 1, 0, 0, 0, 1273, 1274, 5, 30, 0, 0, 1274, 1275, 5, 91, 0, 0, 1275, 1276, 5, 36, 0, 0, 1276, 1277, 3, 32, 16, 0, 1277, 1278, 5, 31, 0, 0, 1278, 1280, 1, 0, 0, 0, 1279, 1272, 1, 0, 0, 0, 1279, 1273, 1, 0, 0, 0, 1280, 133, 1, 0, 0, 0, 1281, 1290, 1, 0, 0, 0, 1282, 1286, 3, 136, 68, 0, 1283, 1285, 7, 7, 0, 0, 1284, 1283, 1, 0, 0, 0, 1285, 1288, 1, 0, 0, 0, 1286, 1284, 1, 0, 0, 0, 1286, 1287, 1, 0, 0, 0, 1287, 1290, 1, 0, 0, 0, 1288, 1286, 1, 0, 0, 0, 1289, 1281, 1, 0, 0, 0, 1289, 1282, 1, 0, 0, 0, 1290, 135, 1, 0, 0, 0, 1291, 1292, 7, 8, 0, 0, 1292, 137, 1, 0, 0, 0, 1293, 1297, 3, 142, 71, 0, 1294, 1296, 3, 140, 70, 0, 1295, 1294, 1, 0, 0, 0, 1296, 1299, 1, 0, 0, 0, 1297, 1295, 1, 0, 0, 0, 1297, 1298, 1, 0, 0, 0, 1298, 139, 1, 0, 0, 0, 1299, 1297, 1, 0, 0, 0, 1300, 1319, 5, 261, 0, 0, 1301, 1302, 5, 42, 0, 0, 1302, 1319, 5, 43, 0, 0, 1303, 1319, 3, 110, 55, 0, 1304, 1319, 5, 260, 0, 0, 1305, 1319, 5, 262, 0, 0, 1306, 1319, 5, 92, 0, 0, 1307, 1308, 5, 93, 0, 0, 1308, 1309, 5, 30, 0, 0, 1309, 1310, 3, 124, 62, 0, 1310, 1311, 5, 31, 0, 0, 1311, 1319, 1, 0, 0, 0, 1312, 1313, 5, 94, 0, 0, 1313, 1314, 5, 30, 0, 0, 1314, 1315, 3, 124, 62, 0, 1315, 1316, 5, 31, 0, 0, 1316, 1319, 1, 0, 0, 0, 1317, 1319, 3, 108, 54, 0, 1318, 1300, 1, 0, 0, 0, 1318, 1301, 1, 0, 0, 0, 1318, 1303, 1, 0, 0, 0, 1318, 1304, 1, 0, 0, 0, 1318, 1305, 1, 0, 0, 0, 1318, 1306, 1, 0, 0, 0, 1318, 1307, 1, 0, 0, 0, 1318, 1312, 1, 0, 0, 0, 1318, 1317, 1, 0, 0, 0, 1319, 141, 1, 0, 0, 0, 1320, 1321, 5, 39, 0, 0, 1321, 1351, 3, 116, 58, 0, 1322, 1351, 5, 197, 0, 0, 1323, 1324, 5, 199, 0, 0, 1324, 1325, 5, 39, 0, 0, 1325, 1351, 3, 116, 58, 0, 1326, 1327, 5, 200, 0, 0, 1327, 1351, 3, 116, 58, 0, 1328, 1329, 5, 226, 0, 0, 1329, 1330, 3, 170, 85, 0, 1330, 1331, 3, 138, 69, 0, 1331, 1332, 5, 262, 0, 0, 1332, 1333, 3, 112, 56, 0, 1333, 1351, 1, 0, 0, 0, 1334, 1335, 5, 253, 0, 0, 1335, 1351, 3, 32, 16, 0, 1336, 1337, 5, 252, 0, 0, 1337, 1351, 3, 32, 16, 0, 1338, 1339, 5, 253, 0, 0, 1339, 1351, 3, 2, 1, 0, 1340, 1341, 5, 252, 0, 0, 1341, 1351, 3, 2, 1, 0, 1342, 1351, 5, 254, 0, 0, 1343, 1351, 5, 201, 0, 0, 1344, 1351, 3, 148, 74, 0, 1345, 1351, 3, 150, 75, 0, 1346, 1351, 3, 144, 72, 0, 1347, 1351, 3, 2, 1, 0, 1348, 1349, 5, 177, 0, 0, 1349, 1351, 3, 138, 69, 0, 1350, 1320, 1, 0, 0, 0, 1350, 1322, 1, 0, 0, 0, 1350, 1323, 1, 0, 0, 0, 1350, 1326, 1, 0, 0, 0, 1350, 1328, 1, 0, 0, 0, 1350, 1334, 1, 0, 0, 0, 1350, 1336, 1, 0, 0, 0, 1350, 1338, 1, 0, 0, 0, 1350, 1340, 1, 0, 0, 0, 1350, 1342, 1, 0, 0, 0, 1350, 1343, 1, 0, 0, 0, 1350, 1344, 1, 0, 0, 0, 1350, 1345, 1, 0, 0, 0, 1350, 1346, 1, 0, 0, 0, 1350, 1347, 1, 0, 0, 0, 1350, 1348, 1, 0, 0, 0, 1351, 143, 1, 0, 0, 0, 1352, 1374, 5, 181, 0, 0, 1353, 1374, 5, 182, 0, 0, 1354, 1374, 5, 183, 0, 0, 1355, 1374, 5, 184, 0, 0, 1356, 1374, 5, 185, 0, 0, 1357, 1374, 5, 186, 0, 0, 1358, 1374, 5, 187, 0, 0, 1359, 1374, 5, 188, 0, 0, 1360, 1374, 5, 189, 0, 0, 1361, 1374, 5, 190, 0, 0, 1362, 1374, 5, 191, 0, 0, 1363, 1374, 5, 192, 0, 0, 1364, 1374, 5, 193, 0, 0, 1365, 1366, 5, 90, 0, 0, 1366, 1374, 5, 184, 0, 0, 1367, 1368, 5, 90, 0, 0, 1368, 1374, 5, 185, 0, 0, 1369, 1370, 5, 90, 0, 0, 1370, 1374, 5, 186, 0, 0, 1371, 1372, 5, 90, 0, 0, 1372, 1374, 5, 187, 0, 0, 1373, 1352, 1, 0, 0, 0, 1373, 1353, 1, 0, 0, 0, 1373, 1354, 1, 0, 0, 0, 1373, 1355, 1, 0, 0, 0, 1373, 1356, 1, 0, 0, 0, 1373, 1357, 1, 0, 0, 0, 1373, 1358, 1, 0, 0, 0, 1373, 1359, 1, 0, 0, 0, 1373, 1360, 1, 0, 0, 0, 1373, 1361, 1, 0, 0, 0, 1373, 1362, 1, 0, 0, 0, 1373, 1363, 1, 0, 0, 0, 1373, 1364, 1, 0, 0, 0, 1373, 1365, 1, 0, 0, 0, 1373, 1367, 1, 0, 0, 0, 1373, 1369, 1, 0, 0, 0, 1373, 1371, 1, 0, 0, 0, 1374, 145, 1, 0, 0, 0, 1375, 1386, 1, 0, 0, 0, 1376, 1386, 5, 177, 0, 0, 1377, 1386, 3, 32, 16, 0, 1378, 1379, 3, 32, 16, 0, 1379, 1380, 5, 177, 0, 0, 1380, 1381, 3, 32, 16, 0, 1381, 1386, 1, 0, 0, 0, 1382, 1383, 3, 32, 16, 0, 1383, 1384, 5, 177, 0, 0, 1384, 1386, 1, 0, 0, 0, 1385, 1375, 1, 0, 0, 0, 1385, 1376, 1, 0, 0, 0, 1385, 1377, 1, 0, 0, 0, 1385, 1378, 1, 0, 0, 0, 1385, 1382, 1, 0, 0, 0, 1386, 147, 1, 0, 0, 0, 1387, 1388, 5, 1, 0, 0, 1388, 1389, 5, 194, 0, 0, 1389, 149, 1, 0, 0, 0, 1390, 1394, 5, 1, 0, 0, 1391, 1392, 5, 90, 0, 0, 1392, 1395, 5, 194, 0, 0, 1393, 1395, 5, 195, 0, 0, 1394, 1391, 1, 0, 0, 0, 1394, 1393, 1, 0, 0, 0, 1395, 151, 1, 0, 0, 0, 1396, 1397, 5, 294, 0, 0, 1397, 1398, 3, 166, 83, 0, 1398, 1399, 3, 124, 62, 0, 1399, 1400, 5, 30, 0, 0, 1400, 1401, 3, 158, 79, 0, 1401, 1402, 5, 31, 0, 0, 1402, 1444, 1, 0, 0, 0, 1403, 1404, 5, 294, 0, 0, 1404, 1405, 3, 166, 83, 0, 1405, 1406, 3, 124, 62, 0, 1406, 1407, 5, 36, 0, 0, 1407, 1408, 5, 17, 0, 0, 1408, 1409, 3, 52, 26, 0, 1409, 1410, 5, 18, 0, 0, 1410, 1444, 1, 0, 0, 0, 1411, 1412, 5, 294, 0, 0, 1412, 1413, 3, 166, 83, 0, 1413, 1414, 3, 124, 62, 0, 1414, 1444, 1, 0, 0, 0, 1415, 1416, 5, 295, 0, 0, 1416, 1417, 3, 166, 83, 0, 1417, 1419, 5, 36, 0, 0, 1418, 1420, 5, 84, 0, 0, 1419, 1418, 1, 0, 0, 0, 1419, 1420, 1, 0, 0, 0, 1420, 1421, 1, 0, 0, 0, 1421, 1422, 5, 30, 0, 0, 1422, 1423, 3, 292, 146, 0, 1423, 1424, 5, 31, 0, 0, 1424, 1444, 1, 0, 0, 0, 1425, 1426, 5, 295, 0, 0, 1426, 1427, 3, 166, 83, 0, 1427, 1428, 5, 84, 0, 0, 1428, 1429, 5, 30, 0, 0, 1429, 1430, 3, 292, 146, 0, 1430, 1431, 5, 31, 0, 0, 1431, 1444, 1, 0, 0, 0, 1432, 1433, 5, 295, 0, 0, 1433, 1434, 3, 166, 83, 0, 1434, 1435, 3, 6, 3, 0, 1435, 1444, 1, 0, 0, 0, 1436, 1437, 5, 295, 0, 0, 1437, 1438, 3, 166, 83, 0, 1438, 1439, 5, 36, 0, 0, 1439, 1440, 5, 17, 0, 0, 1440, 1441, 3, 154, 77, 0, 1441, 1442, 5, 18, 0, 0, 1442, 1444, 1, 0, 0, 0, 1443, 1396, 1, 0, 0, 0, 1443, 1403, 1, 0, 0, 0, 1443, 1411, 1, 0, 0, 0, 1443, 1415, 1, 0, 0, 0, 1443, 1425, 1, 0, 0, 0, 1443, 1432, 1, 0, 0, 0, 1443, 1436, 1, 0, 0, 0, 1444, 153, 1, 0, 0, 0, 1445, 1456, 1, 0, 0, 0, 1446, 1447, 3, 156, 78, 0, 1447, 1448, 5, 28, 0, 0, 1448, 1450, 1, 0, 0, 0, 1449, 1446, 1, 0, 0, 0, 1450, 1453, 1, 0, 0, 0, 1451, 1449, 1, 0, 0, 0, 1451, 1452, 1, 0, 0, 0, 1452, 1454, 1, 0, 0, 0, 1453, 1451, 1, 0, 0, 0, 1454, 1456, 3, 156, 78, 0, 1455, 1445, 1, 0, 0, 0, 1455, 1451, 1, 0, 0, 0, 1456, 155, 1, 0, 0, 0, 1457, 1458, 5, 39, 0, 0, 1458, 1459, 5, 264, 0, 0, 1459, 1460, 5, 36, 0, 0, 1460, 1461, 5, 17, 0, 0, 1461, 1462, 3, 56, 28, 0, 1462, 1463, 5, 18, 0, 0, 1463, 1471, 1, 0, 0, 0, 1464, 1465, 3, 124, 62, 0, 1465, 1466, 5, 36, 0, 0, 1466, 1467, 5, 17, 0, 0, 1467, 1468, 3, 56, 28, 0, 1468, 1469, 5, 18, 0, 0, 1469, 1471, 1, 0, 0, 0, 1470, 1457, 1, 0, 0, 0, 1470, 1464, 1, 0, 0, 0, 1471, 157, 1, 0, 0, 0, 1472, 1473, 3, 160, 80, 0, 1473, 1474, 5, 28, 0, 0, 1474, 1476, 1, 0, 0, 0, 1475, 1472, 1, 0, 0, 0, 1476, 1479, 1, 0, 0, 0, 1477, 1475, 1, 0, 0, 0, 1477, 1478, 1, 0, 0, 0, 1478, 1480, 1, 0, 0, 0, 1479, 1477, 1, 0, 0, 0, 1480, 1481, 3, 160, 80, 0, 1481, 159, 1, 0, 0, 0, 1482, 1483, 3, 6, 3, 0, 1483, 1484, 5, 36, 0, 0, 1484, 1485, 3, 164, 82, 0, 1485, 161, 1, 0, 0, 0, 1486, 1487, 7, 9, 0, 0, 1487, 163, 1, 0, 0, 0, 1488, 1523, 3, 162, 81, 0, 1489, 1523, 3, 32, 16, 0, 1490, 1491, 5, 186, 0, 0, 1491, 1492, 5, 30, 0, 0, 1492, 1493, 3, 32, 16, 0, 1493, 1494, 5, 31, 0, 0, 1494, 1523, 1, 0, 0, 0, 1495, 1523, 3, 6, 3, 0, 1496, 1497, 3, 116, 58, 0, 1497, 1498, 5, 30, 0, 0, 1498, 1499, 5, 184, 0, 0, 1499, 1500, 5, 75, 0, 0, 1500, 1501, 3, 32, 16, 0, 1501, 1502, 5, 31, 0, 0, 1502, 1523, 1, 0, 0, 0, 1503, 1504, 3, 116, 58, 0, 1504, 1505, 5, 30, 0, 0, 1505, 1506, 5, 185, 0, 0, 1506, 1507, 5, 75, 0, 0, 1507, 1508, 3, 32, 16, 0, 1508, 1509, 5, 31, 0, 0, 1509, 1523, 1, 0, 0, 0, 1510, 1511, 3, 116, 58, 0, 1511, 1512, 5, 30, 0, 0, 1512, 1513, 5, 186, 0, 0, 1513, 1514, 5, 75, 0, 0, 1514, 1515, 3, 32, 16, 0, 1515, 1516, 5, 31, 0, 0, 1516, 1523, 1, 0, 0, 0, 1517, 1518, 3, 116, 58, 0, 1518, 1519, 5, 30, 0, 0, 1519, 1520, 3, 32, 16, 0, 1520, 1521, 5, 31, 0, 0, 1521, 1523, 1, 0, 0, 0, 1522, 1488, 1, 0, 0, 0, 1522, 1489, 1, 0, 0, 0, 1522, 1490, 1, 0, 0, 0, 1522, 1495, 1, 0, 0, 0, 1522, 1496, 1, 0, 0, 0, 1522, 1503, 1, 0, 0, 0, 1522, 1510, 1, 0, 0, 0, 1522, 1517, 1, 0, 0, 0, 1523, 165, 1, 0, 0, 0, 1524, 1525, 7, 10, 0, 0, 1525, 167, 1, 0, 0, 0, 1526, 1527, 3, 170, 85, 0, 1527, 1528, 3, 138, 69, 0, 1528, 1529, 3, 124, 62, 0, 1529, 1530, 5, 176, 0, 0, 1530, 1532, 3, 242, 121, 0, 1531, 1533, 3, 108, 54, 0, 1532, 1531, 1, 0, 0, 0, 1532, 1533, 1, 0, 0, 0, 1533, 1534, 1, 0, 0, 0, 1534, 1535, 3, 112, 56, 0, 1535, 1561, 1, 0, 0, 0, 1536, 1537, 3, 170, 85, 0, 1537, 1538, 3, 138, 69, 0, 1538, 1539, 3, 124, 62, 0, 1539, 1540, 5, 176, 0, 0, 1540, 1541, 3, 242, 121, 0, 1541, 1542, 3, 196, 98, 0, 1542, 1543, 3, 112, 56, 0, 1543, 1561, 1, 0, 0, 0, 1544, 1545, 3, 170, 85, 0, 1545, 1546, 3, 138, 69, 0, 1546, 1548, 3, 242, 121, 0, 1547, 1549, 3, 108, 54, 0, 1548, 1547, 1, 0, 0, 0, 1548, 1549, 1, 0, 0, 0, 1549, 1550, 1, 0, 0, 0, 1550, 1551, 3, 112, 56, 0, 1551, 1561, 1, 0, 0, 0, 1552, 1553, 3, 170, 85, 0, 1553, 1554, 3, 138, 69, 0, 1554, 1555, 3, 242, 121, 0, 1555, 1556, 3, 196, 98, 0, 1556, 1557, 3, 112, 56, 0, 1557, 1561, 1, 0, 0, 0, 1558, 1561, 3, 174, 87, 0, 1559, 1561, 3, 2, 1, 0, 1560, 1526, 1, 0, 0, 0, 1560, 1536, 1, 0, 0, 0, 1560, 1544, 1, 0, 0, 0, 1560, 1552, 1, 0, 0, 0, 1560, 1558, 1, 0, 0, 0, 1560, 1559, 1, 0, 0, 0, 1561, 169, 1, 0, 0, 0, 1562, 1563, 5, 243, 0, 0, 1563, 1573, 3, 170, 85, 0, 1564, 1565, 5, 244, 0, 0, 1565, 1573, 3, 170, 85, 0, 1566, 1573, 3, 172, 86, 0, 1567, 1568, 5, 112, 0, 0, 1568, 1569, 5, 30, 0, 0, 1569, 1570, 3, 32, 16, 0, 1570, 1571, 5, 31, 0, 0, 1571, 1573, 1, 0, 0, 0, 1572, 1562, 1, 0, 0, 0, 1572, 1564, 1, 0, 0, 0, 1572, 1566, 1, 0, 0, 0, 1572, 1567, 1, 0, 0, 0, 1573, 171, 1, 0, 0, 0, 1574, 1587, 1, 0, 0, 0, 1575, 1587, 5, 245, 0, 0, 1576, 1587, 5, 246, 0, 0, 1577, 1578, 5, 247, 0, 0, 1578, 1587, 5, 248, 0, 0, 1579, 1580, 5, 247, 0, 0, 1580, 1587, 5, 249, 0, 0, 1581, 1582, 5, 247, 0, 0, 1582, 1587, 5, 250, 0, 0, 1583, 1584, 5, 247, 0, 0, 1584, 1587, 5, 251, 0, 0, 1585, 1587, 5, 247, 0, 0, 1586, 1574, 1, 0, 0, 0, 1586, 1575, 1, 0, 0, 0, 1586, 1576, 1, 0, 0, 0, 1586, 1577, 1, 0, 0, 0, 1586, 1579, 1, 0, 0, 0, 1586, 1581, 1, 0, 0, 0, 1586, 1583, 1, 0, 0, 0, 1586, 1585, 1, 0, 0, 0, 1587, 173, 1, 0, 0, 0, 1588, 1589, 5, 113, 0, 0, 1589, 1590, 5, 30, 0, 0, 1590, 1591, 3, 32, 16, 0, 1591, 1592, 5, 31, 0, 0, 1592, 175, 1, 0, 0, 0, 1593, 1594, 5, 226, 0, 0, 1594, 1599, 3, 168, 84, 0, 1595, 1596, 5, 37, 0, 0, 1596, 1599, 3, 178, 89, 0, 1597, 1599, 3, 174, 87, 0, 1598, 1593, 1, 0, 0, 0, 1598, 1595, 1, 0, 0, 0, 1598, 1597, 1, 0, 0, 0, 1599, 177, 1, 0, 0, 0, 1600, 1601, 3, 138, 69, 0, 1601, 1602, 3, 124, 62, 0, 1602, 1603, 5, 176, 0, 0, 1603, 1604, 3, 2, 1, 0, 1604, 1610, 1, 0, 0, 0, 1605, 1606, 3, 138, 69, 0, 1606, 1607, 3, 2, 1, 0, 1607, 1610, 1, 0, 0, 0, 1608, 1610, 3, 2, 1, 0, 1609, 1600, 1, 0, 0, 0, 1609, 1605, 1, 0, 0, 0, 1609, 1608, 1, 0, 0, 0, 1610, 179, 1, 0, 0, 0, 1611, 1612, 3, 124, 62, 0, 1612, 1613, 5, 28, 0, 0, 1613, 1615, 1, 0, 0, 0, 1614, 1611, 1, 0, 0, 0, 1615, 1618, 1, 0, 0, 0, 1616, 1614, 1, 0, 0, 0, 1616, 1617, 1, 0, 0, 0, 1617, 1619, 1, 0, 0, 0, 1618, 1616, 1, 0, 0, 0, 1619, 1620, 3, 124, 62, 0, 1620, 181, 1, 0, 0, 0, 1621, 1627, 1, 0, 0, 0, 1622, 1623, 5, 86, 0, 0, 1623, 1624, 3, 190, 95, 0, 1624, 1625, 5, 87, 0, 0, 1625, 1627, 1, 0, 0, 0, 1626, 1621, 1, 0, 0, 0, 1626, 1622, 1, 0, 0, 0, 1627, 183, 1, 0, 0, 0, 1628, 1640, 5, 266, 0, 0, 1629, 1640, 5, 114, 0, 0, 1630, 1640, 5, 39, 0, 0, 1631, 1640, 5, 200, 0, 0, 1632, 1640, 5, 115, 0, 0, 1633, 1640, 5, 116, 0, 0, 1634, 1635, 5, 70, 0, 0, 1635, 1636, 5, 30, 0, 0, 1636, 1637, 3, 32, 16, 0, 1637, 1638, 5, 31, 0, 0, 1638, 1640, 1, 0, 0, 0, 1639, 1628, 1, 0, 0, 0, 1639, 1629, 1, 0, 0, 0, 1639, 1630, 1, 0, 0, 0, 1639, 1631, 1, 0, 0, 0, 1639, 1632, 1, 0, 0, 0, 1639, 1633, 1, 0, 0, 0, 1639, 1634, 1, 0, 0, 0, 1640, 185, 1, 0, 0, 0, 1641, 1643, 3, 184, 92, 0, 1642, 1641, 1, 0, 0, 0, 1643, 1646, 1, 0, 0, 0, 1644, 1642, 1, 0, 0, 0, 1644, 1645, 1, 0, 0, 0, 1645, 187, 1, 0, 0, 0, 1646, 1644, 1, 0, 0, 0, 1647, 1649, 3, 186, 93, 0, 1648, 1650, 3, 192, 96, 0, 1649, 1648, 1, 0, 0, 0, 1649, 1650, 1, 0, 0, 0, 1650, 1651, 1, 0, 0, 0, 1651, 1652, 3, 2, 1, 0, 1652, 189, 1, 0, 0, 0, 1653, 1654, 3, 188, 94, 0, 1654, 1655, 5, 28, 0, 0, 1655, 1657, 1, 0, 0, 0, 1656, 1653, 1, 0, 0, 0, 1657, 1660, 1, 0, 0, 0, 1658, 1656, 1, 0, 0, 0, 1658, 1659, 1, 0, 0, 0, 1659, 1661, 1, 0, 0, 0, 1660, 1658, 1, 0, 0, 0, 1661, 1662, 3, 188, 94, 0, 1662, 191, 1, 0, 0, 0, 1663, 1664, 5, 30, 0, 0, 1664, 1665, 3, 180, 90, 0, 1665, 1666, 5, 31, 0, 0, 1666, 193, 1, 0, 0, 0, 1667, 1670, 1, 0, 0, 0, 1668, 1670, 3, 196, 98, 0, 1669, 1667, 1, 0, 0, 0, 1669, 1668, 1, 0, 0, 0, 1670, 195, 1, 0, 0, 0, 1671, 1672, 5, 86, 0, 0, 1672, 1673, 5, 42, 0, 0, 1673, 1674, 3, 32, 16, 0, 1674, 1675, 5, 43, 0, 0, 1675, 1676, 5, 87, 0, 0, 1676, 197, 1, 0, 0, 0, 1677, 1678, 3, 234, 117, 0, 1678, 1679, 5, 17, 0, 0, 1679, 1680, 3, 246, 123, 0, 1680, 1681, 5, 18, 0, 0, 1681, 1794, 1, 0, 0, 0, 1682, 1683, 3, 74, 37, 0, 1683, 1684, 5, 17, 0, 0, 1684, 1685, 3, 82, 41, 0, 1685, 1686, 5, 18, 0, 0, 1686, 1794, 1, 0, 0, 0, 1687, 1688, 3, 210, 105, 0, 1688, 1689, 5, 17, 0, 0, 1689, 1690, 3, 214, 107, 0, 1690, 1691, 5, 18, 0, 0, 1691, 1794, 1, 0, 0, 0, 1692, 1693, 3, 218, 109, 0, 1693, 1694, 5, 17, 0, 0, 1694, 1695, 3, 222, 111, 0, 1695, 1696, 5, 18, 0, 0, 1696, 1794, 1, 0, 0, 0, 1697, 1794, 3, 200, 100, 0, 1698, 1794, 3, 276, 138, 0, 1699, 1794, 3, 152, 76, 0, 1700, 1794, 3, 88, 44, 0, 1701, 1794, 3, 322, 161, 0, 1702, 1703, 5, 117, 0, 0, 1703, 1794, 3, 32, 16, 0, 1704, 1705, 5, 118, 0, 0, 1705, 1794, 3, 32, 16, 0, 1706, 1707, 3, 334, 167, 0, 1707, 1708, 5, 17, 0, 0, 1708, 1709, 3, 338, 169, 0, 1709, 1710, 5, 18, 0, 0, 1710, 1794, 1, 0, 0, 0, 1711, 1712, 5, 302, 0, 0, 1712, 1713, 3, 124, 62, 0, 1713, 1714, 5, 176, 0, 0, 1714, 1715, 3, 242, 121, 0, 1715, 1716, 5, 119, 0, 0, 1716, 1717, 3, 170, 85, 0, 1717, 1718, 3, 138, 69, 0, 1718, 1719, 3, 124, 62, 0, 1719, 1720, 5, 176, 0, 0, 1720, 1721, 3, 242, 121, 0, 1721, 1722, 3, 112, 56, 0, 1722, 1794, 1, 0, 0, 0, 1723, 1724, 5, 302, 0, 0, 1724, 1725, 5, 226, 0, 0, 1725, 1726, 3, 170, 85, 0, 1726, 1727, 3, 138, 69, 0, 1727, 1728, 3, 124, 62, 0, 1728, 1729, 5, 176, 0, 0, 1729, 1730, 3, 242, 121, 0, 1730, 1731, 3, 194, 97, 0, 1731, 1732, 3, 112, 56, 0, 1732, 1733, 5, 119, 0, 0, 1733, 1734, 5, 226, 0, 0, 1734, 1735, 3, 170, 85, 0, 1735, 1736, 3, 138, 69, 0, 1736, 1737, 3, 124, 62, 0, 1737, 1738, 5, 176, 0, 0, 1738, 1739, 3, 242, 121, 0, 1739, 1740, 3, 194, 97, 0, 1740, 1741, 3, 112, 56, 0, 1741, 1794, 1, 0, 0, 0, 1742, 1794, 3, 26, 13, 0, 1743, 1794, 3, 40, 20, 0, 1744, 1745, 5, 255, 0, 0, 1745, 1746, 5, 196, 0, 0, 1746, 1747, 5, 42, 0, 0, 1747, 1748, 3, 32, 16, 0, 1748, 1752, 5, 43, 0, 0, 1749, 1751, 3, 322, 161, 0, 1750, 1749, 1, 0, 0, 0, 1751, 1754, 1, 0, 0, 0, 1752, 1750, 1, 0, 0, 0, 1752, 1753, 1, 0, 0, 0, 1753, 1794, 1, 0, 0, 0, 1754, 1752, 1, 0, 0, 0, 1755, 1756, 5, 255, 0, 0, 1756, 1757, 5, 196, 0, 0, 1757, 1761, 3, 2, 1, 0, 1758, 1760, 3, 322, 161, 0, 1759, 1758, 1, 0, 0, 0, 1760, 1763, 1, 0, 0, 0, 1761, 1759, 1, 0, 0, 0, 1761, 1762, 1, 0, 0, 0, 1762, 1794, 1, 0, 0, 0, 1763, 1761, 1, 0, 0, 0, 1764, 1765, 5, 255, 0, 0, 1765, 1766, 5, 256, 0, 0, 1766, 1767, 5, 42, 0, 0, 1767, 1768, 3, 32, 16, 0, 1768, 1769, 5, 43, 0, 0, 1769, 1770, 5, 28, 0, 0, 1770, 1774, 3, 124, 62, 0, 1771, 1773, 3, 322, 161, 0, 1772, 1771, 1, 0, 0, 0, 1773, 1776, 1, 0, 0, 0, 1774, 1772, 1, 0, 0, 0, 1774, 1775, 1, 0, 0, 0, 1775, 1794, 1, 0, 0, 0, 1776, 1774, 1, 0, 0, 0, 1777, 1778, 5, 255, 0, 0, 1778, 1779, 5, 256, 0, 0, 1779, 1780, 3, 2, 1, 0, 1780, 1781, 5, 28, 0, 0, 1781, 1785, 3, 124, 62, 0, 1782, 1784, 3, 322, 161, 0, 1783, 1782, 1, 0, 0, 0, 1784, 1787, 1, 0, 0, 0, 1785, 1783, 1, 0, 0, 0, 1785, 1786, 1, 0, 0, 0, 1786, 1794, 1, 0, 0, 0, 1787, 1785, 1, 0, 0, 0, 1788, 1789, 5, 120, 0, 0, 1789, 1790, 5, 196, 0, 0, 1790, 1791, 3, 124, 62, 0, 1791, 1792, 3, 44, 22, 0, 1792, 1794, 1, 0, 0, 0, 1793, 1677, 1, 0, 0, 0, 1793, 1682, 1, 0, 0, 0, 1793, 1687, 1, 0, 0, 0, 1793, 1692, 1, 0, 0, 0, 1793, 1697, 1, 0, 0, 0, 1793, 1698, 1, 0, 0, 0, 1793, 1699, 1, 0, 0, 0, 1793, 1700, 1, 0, 0, 0, 1793, 1701, 1, 0, 0, 0, 1793, 1702, 1, 0, 0, 0, 1793, 1704, 1, 0, 0, 0, 1793, 1706, 1, 0, 0, 0, 1793, 1711, 1, 0, 0, 0, 1793, 1723, 1, 0, 0, 0, 1793, 1742, 1, 0, 0, 0, 1793, 1743, 1, 0, 0, 0, 1793, 1744, 1, 0, 0, 0, 1793, 1755, 1, 0, 0, 0, 1793, 1764, 1, 0, 0, 0, 1793, 1777, 1, 0, 0, 0, 1793, 1788, 1, 0, 0, 0, 1794, 199, 1, 0, 0, 0, 1795, 1796, 5, 121, 0, 0, 1796, 1805, 3, 208, 104, 0, 1797, 1804, 3, 202, 101, 0, 1798, 1799, 5, 122, 0, 0, 1799, 1800, 5, 30, 0, 0, 1800, 1801, 3, 228, 114, 0, 1801, 1802, 5, 31, 0, 0, 1802, 1804, 1, 0, 0, 0, 1803, 1797, 1, 0, 0, 0, 1803, 1798, 1, 0, 0, 0, 1804, 1807, 1, 0, 0, 0, 1805, 1803, 1, 0, 0, 0, 1805, 1806, 1, 0, 0, 0, 1806, 1808, 1, 0, 0, 0, 1807, 1805, 1, 0, 0, 0, 1808, 1809, 3, 138, 69, 0, 1809, 1810, 3, 2, 1, 0, 1810, 1811, 3, 204, 102, 0, 1811, 1812, 3, 206, 103, 0, 1812, 201, 1, 0, 0, 0, 1813, 1833, 5, 123, 0, 0, 1814, 1833, 5, 51, 0, 0, 1815, 1833, 5, 52, 0, 0, 1816, 1833, 5, 63, 0, 0, 1817, 1833, 5, 124, 0, 0, 1818, 1833, 5, 69, 0, 0, 1819, 1833, 5, 68, 0, 0, 1820, 1833, 5, 64, 0, 0, 1821, 1833, 5, 65, 0, 0, 1822, 1833, 5, 66, 0, 0, 1823, 1833, 5, 125, 0, 0, 1824, 1833, 5, 126, 0, 0, 1825, 1833, 5, 127, 0, 0, 1826, 1833, 5, 16, 0, 0, 1827, 1828, 5, 70, 0, 0, 1828, 1829, 5, 30, 0, 0, 1829, 1830, 3, 32, 16, 0, 1830, 1831, 5, 31, 0, 0, 1831, 1833, 1, 0, 0, 0, 1832, 1813, 1, 0, 0, 0, 1832, 1814, 1, 0, 0, 0, 1832, 1815, 1, 0, 0, 0, 1832, 1816, 1, 0, 0, 0, 1832, 1817, 1, 0, 0, 0, 1832, 1818, 1, 0, 0, 0, 1832, 1819, 1, 0, 0, 0, 1832, 1820, 1, 0, 0, 0, 1832, 1821, 1, 0, 0, 0, 1832, 1822, 1, 0, 0, 0, 1832, 1823, 1, 0, 0, 0, 1832, 1824, 1, 0, 0, 0, 1832, 1825, 1, 0, 0, 0, 1832, 1826, 1, 0, 0, 0, 1832, 1827, 1, 0, 0, 0, 1833, 203, 1, 0, 0, 0, 1834, 1840, 1, 0, 0, 0, 1835, 1836, 5, 44, 0, 0, 1836, 1840, 3, 0, 0, 0, 1837, 1838, 5, 44, 0, 0, 1838, 1840, 3, 32, 16, 0, 1839, 1834, 1, 0, 0, 0, 1839, 1835, 1, 0, 0, 0, 1839, 1837, 1, 0, 0, 0, 1840, 205, 1, 0, 0, 0, 1841, 1845, 1, 0, 0, 0, 1842, 1843, 5, 36, 0, 0, 1843, 1845, 3, 296, 148, 0, 1844, 1841, 1, 0, 0, 0, 1844, 1842, 1, 0, 0, 0, 1845, 207, 1, 0, 0, 0, 1846, 1852, 1, 0, 0, 0, 1847, 1848, 5, 42, 0, 0, 1848, 1849, 3, 32, 16, 0, 1849, 1850, 5, 43, 0, 0, 1850, 1852, 1, 0, 0, 0, 1851, 1846, 1, 0, 0, 0, 1851, 1847, 1, 0, 0, 0, 1852, 209, 1, 0, 0, 0, 1853, 1857, 5, 128, 0, 0, 1854, 1856, 3, 212, 106, 0, 1855, 1854, 1, 0, 0, 0, 1856, 1859, 1, 0, 0, 0, 1857, 1855, 1, 0, 0, 0, 1857, 1858, 1, 0, 0, 0, 1858, 1860, 1, 0, 0, 0, 1859, 1857, 1, 0, 0, 0, 1860, 1861, 3, 124, 62, 0, 1861, 1862, 3, 2, 1, 0, 1862, 1872, 1, 0, 0, 0, 1863, 1867, 5, 128, 0, 0, 1864, 1866, 3, 212, 106, 0, 1865, 1864, 1, 0, 0, 0, 1866, 1869, 1, 0, 0, 0, 1867, 1865, 1, 0, 0, 0, 1867, 1868, 1, 0, 0, 0, 1868, 1870, 1, 0, 0, 0, 1869, 1867, 1, 0, 0, 0, 1870, 1872, 3, 2, 1, 0, 1871, 1853, 1, 0, 0, 0, 1871, 1863, 1, 0, 0, 0, 1872, 211, 1, 0, 0, 0, 1873, 1874, 7, 11, 0, 0, 1874, 213, 1, 0, 0, 0, 1875, 1877, 3, 216, 108, 0, 1876, 1875, 1, 0, 0, 0, 1877, 1880, 1, 0, 0, 0, 1878, 1876, 1, 0, 0, 0, 1878, 1879, 1, 0, 0, 0, 1879, 215, 1, 0, 0, 0, 1880, 1878, 1, 0, 0, 0, 1881, 1882, 5, 129, 0, 0, 1882, 1894, 3, 168, 84, 0, 1883, 1884, 5, 130, 0, 0, 1884, 1894, 3, 168, 84, 0, 1885, 1886, 5, 131, 0, 0, 1886, 1894, 3, 168, 84, 0, 1887, 1888, 5, 132, 0, 0, 1888, 1894, 3, 168, 84, 0, 1889, 1894, 3, 88, 44, 0, 1890, 1894, 3, 322, 161, 0, 1891, 1894, 3, 26, 13, 0, 1892, 1894, 3, 40, 20, 0, 1893, 1881, 1, 0, 0, 0, 1893, 1883, 1, 0, 0, 0, 1893, 1885, 1, 0, 0, 0, 1893, 1887, 1, 0, 0, 0, 1893, 1889, 1, 0, 0, 0, 1893, 1890, 1, 0, 0, 0, 1893, 1891, 1, 0, 0, 0, 1893, 1892, 1, 0, 0, 0, 1894, 217, 1, 0, 0, 0, 1895, 1899, 5, 133, 0, 0, 1896, 1898, 3, 220, 110, 0, 1897, 1896, 1, 0, 0, 0, 1898, 1901, 1, 0, 0, 0, 1899, 1897, 1, 0, 0, 0, 1899, 1900, 1, 0, 0, 0, 1900, 1902, 1, 0, 0, 0, 1901, 1899, 1, 0, 0, 0, 1902, 1903, 3, 170, 85, 0, 1903, 1904, 3, 138, 69, 0, 1904, 1905, 3, 2, 1, 0, 1905, 1906, 3, 112, 56, 0, 1906, 1907, 3, 206, 103, 0, 1907, 219, 1, 0, 0, 0, 1908, 1909, 7, 11, 0, 0, 1909, 221, 1, 0, 0, 0, 1910, 1912, 3, 224, 112, 0, 1911, 1910, 1, 0, 0, 0, 1912, 1915, 1, 0, 0, 0, 1913, 1911, 1, 0, 0, 0, 1913, 1914, 1, 0, 0, 0, 1914, 223, 1, 0, 0, 0, 1915, 1913, 1, 0, 0, 0, 1916, 1917, 5, 134, 0, 0, 1917, 1927, 3, 168, 84, 0, 1918, 1919, 5, 135, 0, 0, 1919, 1927, 3, 168, 84, 0, 1920, 1921, 5, 132, 0, 0, 1921, 1927, 3, 168, 84, 0, 1922, 1927, 3, 322, 161, 0, 1923, 1927, 3, 88, 44, 0, 1924, 1927, 3, 26, 13, 0, 1925, 1927, 3, 40, 20, 0, 1926, 1916, 1, 0, 0, 0, 1926, 1918, 1, 0, 0, 0, 1926, 1920, 1, 0, 0, 0, 1926, 1922, 1, 0, 0, 0, 1926, 1923, 1, 0, 0, 0, 1926, 1924, 1, 0, 0, 0, 1926, 1925, 1, 0, 0, 0, 1927, 225, 1, 0, 0, 0, 1928, 1935, 1, 0, 0, 0, 1929, 1930, 5, 122, 0, 0, 1930, 1931, 5, 30, 0, 0, 1931, 1932, 3, 228, 114, 0, 1932, 1933, 5, 31, 0, 0, 1933, 1935, 1, 0, 0, 0, 1934, 1928, 1, 0, 0, 0, 1934, 1929, 1, 0, 0, 0, 1935, 227, 1, 0, 0, 0, 1936, 1946, 3, 126, 63, 0, 1937, 1939, 5, 17, 0, 0, 1938, 1940, 3, 294, 147, 0, 1939, 1938, 1, 0, 0, 0, 1940, 1941, 1, 0, 0, 0, 1941, 1939, 1, 0, 0, 0, 1941, 1942, 1, 0, 0, 0, 1942, 1943, 1, 0, 0, 0, 1943, 1944, 5, 18, 0, 0, 1944, 1946, 1, 0, 0, 0, 1945, 1936, 1, 0, 0, 0, 1945, 1937, 1, 0, 0, 0, 1946, 229, 1, 0, 0, 0, 1947, 1949, 3, 232, 116, 0, 1948, 1947, 1, 0, 0, 0, 1949, 1952, 1, 0, 0, 0, 1950, 1948, 1, 0, 0, 0, 1950, 1951, 1, 0, 0, 0, 1951, 231, 1, 0, 0, 0, 1952, 1950, 1, 0, 0, 0, 1953, 1954, 5, 42, 0, 0, 1954, 1955, 5, 136, 0, 0, 1955, 1967, 5, 43, 0, 0, 1956, 1957, 5, 42, 0, 0, 1957, 1958, 5, 137, 0, 0, 1958, 1967, 5, 43, 0, 0, 1959, 1960, 5, 42, 0, 0, 1960, 1961, 5, 138, 0, 0, 1961, 1967, 5, 43, 0, 0, 1962, 1963, 5, 42, 0, 0, 1963, 1964, 3, 32, 16, 0, 1964, 1965, 5, 43, 0, 0, 1965, 1967, 1, 0, 0, 0, 1966, 1953, 1, 0, 0, 0, 1966, 1956, 1, 0, 0, 0, 1966, 1959, 1, 0, 0, 0, 1966, 1962, 1, 0, 0, 0, 1967, 233, 1, 0, 0, 0, 1968, 1973, 5, 139, 0, 0, 1969, 1972, 3, 236, 118, 0, 1970, 1972, 3, 238, 119, 0, 1971, 1969, 1, 0, 0, 0, 1971, 1970, 1, 0, 0, 0, 1972, 1975, 1, 0, 0, 0, 1973, 1971, 1, 0, 0, 0, 1973, 1974, 1, 0, 0, 0, 1974, 1976, 1, 0, 0, 0, 1975, 1973, 1, 0, 0, 0, 1976, 1977, 3, 170, 85, 0, 1977, 1978, 3, 230, 115, 0, 1978, 1979, 3, 138, 69, 0, 1979, 1980, 3, 226, 113, 0, 1980, 1981, 3, 242, 121, 0, 1981, 1982, 3, 182, 91, 0, 1982, 1986, 3, 112, 56, 0, 1983, 1985, 3, 244, 122, 0, 1984, 1983, 1, 0, 0, 0, 1985, 1988, 1, 0, 0, 0, 1986, 1984, 1, 0, 0, 0, 1986, 1987, 1, 0, 0, 0, 1987, 235, 1, 0, 0, 0, 1988, 1986, 1, 0, 0, 0, 1989, 2013, 5, 123, 0, 0, 1990, 2013, 5, 51, 0, 0, 1991, 2013, 5, 52, 0, 0, 1992, 2013, 5, 63, 0, 0, 1993, 2013, 5, 140, 0, 0, 1994, 2013, 5, 68, 0, 0, 1995, 2013, 5, 141, 0, 0, 1996, 2013, 5, 142, 0, 0, 1997, 2013, 5, 54, 0, 0, 1998, 2013, 5, 64, 0, 0, 1999, 2013, 5, 65, 0, 0, 2000, 2013, 5, 66, 0, 0, 2001, 2013, 5, 125, 0, 0, 2002, 2013, 5, 143, 0, 0, 2003, 2013, 5, 144, 0, 0, 2004, 2013, 5, 69, 0, 0, 2005, 2013, 5, 145, 0, 0, 2006, 2013, 5, 146, 0, 0, 2007, 2008, 5, 70, 0, 0, 2008, 2009, 5, 30, 0, 0, 2009, 2010, 3, 32, 16, 0, 2010, 2011, 5, 31, 0, 0, 2011, 2013, 1, 0, 0, 0, 2012, 1989, 1, 0, 0, 0, 2012, 1990, 1, 0, 0, 0, 2012, 1991, 1, 0, 0, 0, 2012, 1992, 1, 0, 0, 0, 2012, 1993, 1, 0, 0, 0, 2012, 1994, 1, 0, 0, 0, 2012, 1995, 1, 0, 0, 0, 2012, 1996, 1, 0, 0, 0, 2012, 1997, 1, 0, 0, 0, 2012, 1998, 1, 0, 0, 0, 2012, 1999, 1, 0, 0, 0, 2012, 2000, 1, 0, 0, 0, 2012, 2001, 1, 0, 0, 0, 2012, 2002, 1, 0, 0, 0, 2012, 2003, 1, 0, 0, 0, 2012, 2004, 1, 0, 0, 0, 2012, 2005, 1, 0, 0, 0, 2012, 2006, 1, 0, 0, 0, 2012, 2007, 1, 0, 0, 0, 2013, 237, 1, 0, 0, 0, 2014, 2015, 5, 147, 0, 0, 2015, 2021, 5, 30, 0, 0, 2016, 2019, 3, 6, 3, 0, 2017, 2018, 5, 34, 0, 0, 2018, 2020, 3, 6, 3, 0, 2019, 2017, 1, 0, 0, 0, 2019, 2020, 1, 0, 0, 0, 2020, 2022, 1, 0, 0, 0, 2021, 2016, 1, 0, 0, 0, 2021, 2022, 1, 0, 0, 0, 2022, 2026, 1, 0, 0, 0, 2023, 2025, 3, 240, 120, 0, 2024, 2023, 1, 0, 0, 0, 2025, 2028, 1, 0, 0, 0, 2026, 2024, 1, 0, 0, 0, 2026, 2027, 1, 0, 0, 0, 2027, 2029, 1, 0, 0, 0, 2028, 2026, 1, 0, 0, 0, 2029, 2033, 5, 31, 0, 0, 2030, 2031, 5, 147, 0, 0, 2031, 2033, 5, 85, 0, 0, 2032, 2014, 1, 0, 0, 0, 2032, 2030, 1, 0, 0, 0, 2033, 239, 1, 0, 0, 0, 2034, 2062, 5, 148, 0, 0, 2035, 2062, 5, 224, 0, 0, 2036, 2062, 5, 57, 0, 0, 2037, 2062, 5, 58, 0, 0, 2038, 2062, 5, 149, 0, 0, 2039, 2062, 5, 150, 0, 0, 2040, 2062, 5, 248, 0, 0, 2041, 2062, 5, 249, 0, 0, 2042, 2062, 5, 250, 0, 0, 2043, 2062, 5, 251, 0, 0, 2044, 2045, 5, 151, 0, 0, 2045, 2046, 5, 75, 0, 0, 2046, 2062, 5, 152, 0, 0, 2047, 2048, 5, 151, 0, 0, 2048, 2049, 5, 75, 0, 0, 2049, 2062, 5, 153, 0, 0, 2050, 2051, 5, 154, 0, 0, 2051, 2052, 5, 75, 0, 0, 2052, 2062, 5, 152, 0, 0, 2053, 2054, 5, 154, 0, 0, 2054, 2055, 5, 75, 0, 0, 2055, 2062, 5, 153, 0, 0, 2056, 2057, 5, 70, 0, 0, 2057, 2058, 5, 30, 0, 0, 2058, 2059, 3, 32, 16, 0, 2059, 2060, 5, 31, 0, 0, 2060, 2062, 1, 0, 0, 0, 2061, 2034, 1, 0, 0, 0, 2061, 2035, 1, 0, 0, 0, 2061, 2036, 1, 0, 0, 0, 2061, 2037, 1, 0, 0, 0, 2061, 2038, 1, 0, 0, 0, 2061, 2039, 1, 0, 0, 0, 2061, 2040, 1, 0, 0, 0, 2061, 2041, 1, 0, 0, 0, 2061, 2042, 1, 0, 0, 0, 2061, 2043, 1, 0, 0, 0, 2061, 2044, 1, 0, 0, 0, 2061, 2047, 1, 0, 0, 0, 2061, 2050, 1, 0, 0, 0, 2061, 2053, 1, 0, 0, 0, 2061, 2056, 1, 0, 0, 0, 2062, 241, 1, 0, 0, 0, 2063, 2067, 5, 116, 0, 0, 2064, 2067, 5, 155, 0, 0, 2065, 2067, 3, 2, 1, 0, 2066, 2063, 1, 0, 0, 0, 2066, 2064, 1, 0, 0, 0, 2066, 2065, 1, 0, 0, 0, 2067, 243, 1, 0, 0, 0, 2068, 2090, 5, 1, 0, 0, 2069, 2090, 5, 2, 0, 0, 2070, 2090, 5, 156, 0, 0, 2071, 2090, 5, 3, 0, 0, 2072, 2090, 5, 4, 0, 0, 2073, 2090, 5, 247, 0, 0, 2074, 2090, 5, 5, 0, 0, 2075, 2090, 5, 6, 0, 0, 2076, 2090, 5, 7, 0, 0, 2077, 2090, 5, 8, 0, 0, 2078, 2090, 5, 9, 0, 0, 2079, 2090, 5, 10, 0, 0, 2080, 2090, 5, 11, 0, 0, 2081, 2090, 5, 12, 0, 0, 2082, 2090, 5, 13, 0, 0, 2083, 2090, 5, 14, 0, 0, 2084, 2085, 5, 70, 0, 0, 2085, 2086, 5, 30, 0, 0, 2086, 2087, 3, 32, 16, 0, 2087, 2088, 5, 31, 0, 0, 2088, 2090, 1, 0, 0, 0, 2089, 2068, 1, 0, 0, 0, 2089, 2069, 1, 0, 0, 0, 2089, 2070, 1, 0, 0, 0, 2089, 2071, 1, 0, 0, 0, 2089, 2072, 1, 0, 0, 0, 2089, 2073, 1, 0, 0, 0, 2089, 2074, 1, 0, 0, 0, 2089, 2075, 1, 0, 0, 0, 2089, 2076, 1, 0, 0, 0, 2089, 2077, 1, 0, 0, 0, 2089, 2078, 1, 0, 0, 0, 2089, 2079, 1, 0, 0, 0, 2089, 2080, 1, 0, 0, 0, 2089, 2081, 1, 0, 0, 0, 2089, 2082, 1, 0, 0, 0, 2089, 2083, 1, 0, 0, 0, 2089, 2084, 1, 0, 0, 0, 2090, 245, 1, 0, 0, 0, 2091, 2093, 3, 248, 124, 0, 2092, 2091, 1, 0, 0, 0, 2093, 2096, 1, 0, 0, 0, 2094, 2092, 1, 0, 0, 0, 2094, 2095, 1, 0, 0, 0, 2095, 247, 1, 0, 0, 0, 2096, 2094, 1, 0, 0, 0, 2097, 2115, 3, 100, 50, 0, 2098, 2099, 5, 296, 0, 0, 2099, 2100, 3, 32, 16, 0, 2100, 2101, 6, 124, -1, 0, 2101, 2115, 1, 0, 0, 0, 2102, 2115, 3, 258, 129, 0, 2103, 2104, 5, 297, 0, 0, 2104, 2105, 3, 32, 16, 0, 2105, 2106, 6, 124, -1, 0, 2106, 2115, 1, 0, 0, 0, 2107, 2108, 5, 298, 0, 0, 2108, 2115, 6, 124, -1, 0, 2109, 2110, 5, 299, 0, 0, 2110, 2115, 6, 124, -1, 0, 2111, 2115, 3, 252, 126, 0, 2112, 2115, 3, 256, 128, 0, 2113, 2115, 3, 250, 125, 0, 2114, 2097, 1, 0, 0, 0, 2114, 2098, 1, 0, 0, 0, 2114, 2102, 1, 0, 0, 0, 2114, 2103, 1, 0, 0, 0, 2114, 2107, 1, 0, 0, 0, 2114, 2109, 1, 0, 0, 0, 2114, 2111, 1, 0, 0, 0, 2114, 2112, 1, 0, 0, 0, 2114, 2113, 1, 0, 0, 0, 2115, 249, 1, 0, 0, 0, 2116, 2117, 5, 300, 0, 0, 2117, 2215, 3, 112, 56, 0, 2118, 2119, 5, 300, 0, 0, 2119, 2120, 5, 157, 0, 0, 2120, 2215, 3, 112, 56, 0, 2121, 2215, 3, 276, 138, 0, 2122, 2215, 3, 152, 76, 0, 2123, 2215, 3, 88, 44, 0, 2124, 2215, 3, 26, 13, 0, 2125, 2215, 3, 254, 127, 0, 2126, 2215, 3, 40, 20, 0, 2127, 2128, 5, 301, 0, 0, 2128, 2129, 5, 42, 0, 0, 2129, 2130, 3, 32, 16, 0, 2130, 2131, 5, 43, 0, 0, 2131, 2215, 1, 0, 0, 0, 2132, 2133, 5, 301, 0, 0, 2133, 2134, 5, 42, 0, 0, 2134, 2135, 3, 32, 16, 0, 2135, 2136, 5, 43, 0, 0, 2136, 2137, 5, 34, 0, 0, 2137, 2138, 3, 0, 0, 0, 2138, 2215, 1, 0, 0, 0, 2139, 2140, 5, 303, 0, 0, 2140, 2141, 3, 32, 16, 0, 2141, 2142, 5, 75, 0, 0, 2142, 2143, 3, 32, 16, 0, 2143, 2215, 1, 0, 0, 0, 2144, 2145, 5, 302, 0, 0, 2145, 2146, 3, 124, 62, 0, 2146, 2147, 5, 176, 0, 0, 2147, 2148, 3, 242, 121, 0, 2148, 2215, 1, 0, 0, 0, 2149, 2150, 5, 302, 0, 0, 2150, 2151, 5, 226, 0, 0, 2151, 2152, 3, 170, 85, 0, 2152, 2153, 3, 138, 69, 0, 2153, 2154, 3, 124, 62, 0, 2154, 2155, 5, 176, 0, 0, 2155, 2156, 3, 242, 121, 0, 2156, 2157, 3, 194, 97, 0, 2157, 2158, 3, 112, 56, 0, 2158, 2215, 1, 0, 0, 0, 2159, 2160, 5, 255, 0, 0, 2160, 2161, 5, 196, 0, 0, 2161, 2162, 5, 42, 0, 0, 2162, 2163, 3, 32, 16, 0, 2163, 2167, 5, 43, 0, 0, 2164, 2166, 3, 322, 161, 0, 2165, 2164, 1, 0, 0, 0, 2166, 2169, 1, 0, 0, 0, 2167, 2165, 1, 0, 0, 0, 2167, 2168, 1, 0, 0, 0, 2168, 2215, 1, 0, 0, 0, 2169, 2167, 1, 0, 0, 0, 2170, 2171, 5, 255, 0, 0, 2171, 2172, 5, 196, 0, 0, 2172, 2176, 3, 2, 1, 0, 2173, 2175, 3, 322, 161, 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, 2215, 1, 0, 0, 0, 2178, 2176, 1, 0, 0, 0, 2179, 2180, 5, 255, 0, 0, 2180, 2181, 5, 256, 0, 0, 2181, 2182, 5, 42, 0, 0, 2182, 2183, 3, 32, 16, 0, 2183, 2184, 5, 43, 0, 0, 2184, 2185, 5, 28, 0, 0, 2185, 2189, 3, 124, 62, 0, 2186, 2188, 3, 322, 161, 0, 2187, 2186, 1, 0, 0, 0, 2188, 2191, 1, 0, 0, 0, 2189, 2187, 1, 0, 0, 0, 2189, 2190, 1, 0, 0, 0, 2190, 2215, 1, 0, 0, 0, 2191, 2189, 1, 0, 0, 0, 2192, 2193, 5, 255, 0, 0, 2193, 2194, 5, 256, 0, 0, 2194, 2195, 3, 2, 1, 0, 2195, 2196, 5, 28, 0, 0, 2196, 2200, 3, 124, 62, 0, 2197, 2199, 3, 322, 161, 0, 2198, 2197, 1, 0, 0, 0, 2199, 2202, 1, 0, 0, 0, 2200, 2198, 1, 0, 0, 0, 2200, 2201, 1, 0, 0, 0, 2201, 2215, 1, 0, 0, 0, 2202, 2200, 1, 0, 0, 0, 2203, 2204, 5, 255, 0, 0, 2204, 2205, 5, 42, 0, 0, 2205, 2206, 3, 32, 16, 0, 2206, 2207, 5, 43, 0, 0, 2207, 2211, 3, 206, 103, 0, 2208, 2210, 3, 322, 161, 0, 2209, 2208, 1, 0, 0, 0, 2210, 2213, 1, 0, 0, 0, 2211, 2209, 1, 0, 0, 0, 2211, 2212, 1, 0, 0, 0, 2212, 2215, 1, 0, 0, 0, 2213, 2211, 1, 0, 0, 0, 2214, 2116, 1, 0, 0, 0, 2214, 2118, 1, 0, 0, 0, 2214, 2121, 1, 0, 0, 0, 2214, 2122, 1, 0, 0, 0, 2214, 2123, 1, 0, 0, 0, 2214, 2124, 1, 0, 0, 0, 2214, 2125, 1, 0, 0, 0, 2214, 2126, 1, 0, 0, 0, 2214, 2127, 1, 0, 0, 0, 2214, 2132, 1, 0, 0, 0, 2214, 2139, 1, 0, 0, 0, 2214, 2144, 1, 0, 0, 0, 2214, 2149, 1, 0, 0, 0, 2214, 2159, 1, 0, 0, 0, 2214, 2170, 1, 0, 0, 0, 2214, 2179, 1, 0, 0, 0, 2214, 2192, 1, 0, 0, 0, 2214, 2203, 1, 0, 0, 0, 2215, 251, 1, 0, 0, 0, 2216, 2217, 3, 0, 0, 0, 2217, 2218, 5, 75, 0, 0, 2218, 2219, 6, 126, -1, 0, 2219, 253, 1, 0, 0, 0, 2220, 2223, 3, 44, 22, 0, 2221, 2223, 3, 46, 23, 0, 2222, 2220, 1, 0, 0, 0, 2222, 2221, 1, 0, 0, 0, 2223, 255, 1, 0, 0, 0, 2224, 2225, 5, 17, 0, 0, 2225, 2226, 3, 246, 123, 0, 2226, 2227, 5, 18, 0, 0, 2227, 257, 1, 0, 0, 0, 2228, 2229, 3, 262, 131, 0, 2229, 2230, 3, 260, 130, 0, 2230, 259, 1, 0, 0, 0, 2231, 2233, 3, 264, 132, 0, 2232, 2231, 1, 0, 0, 0, 2233, 2234, 1, 0, 0, 0, 2234, 2232, 1, 0, 0, 0, 2234, 2235, 1, 0, 0, 0, 2235, 261, 1, 0, 0, 0, 2236, 2237, 5, 158, 0, 0, 2237, 2249, 3, 256, 128, 0, 2238, 2239, 5, 158, 0, 0, 2239, 2240, 3, 0, 0, 0, 2240, 2241, 5, 159, 0, 0, 2241, 2242, 3, 0, 0, 0, 2242, 2249, 1, 0, 0, 0, 2243, 2244, 5, 158, 0, 0, 2244, 2245, 3, 32, 16, 0, 2245, 2246, 5, 159, 0, 0, 2246, 2247, 3, 32, 16, 0, 2247, 2249, 1, 0, 0, 0, 2248, 2236, 1, 0, 0, 0, 2248, 2238, 1, 0, 0, 0, 2248, 2243, 1, 0, 0, 0, 2249, 263, 1, 0, 0, 0, 2250, 2251, 3, 268, 134, 0, 2251, 2252, 3, 274, 137, 0, 2252, 2263, 1, 0, 0, 0, 2253, 2254, 3, 266, 133, 0, 2254, 2255, 3, 274, 137, 0, 2255, 2263, 1, 0, 0, 0, 2256, 2257, 3, 270, 135, 0, 2257, 2258, 3, 274, 137, 0, 2258, 2263, 1, 0, 0, 0, 2259, 2260, 3, 272, 136, 0, 2260, 2261, 3, 274, 137, 0, 2261, 2263, 1, 0, 0, 0, 2262, 2250, 1, 0, 0, 0, 2262, 2253, 1, 0, 0, 0, 2262, 2256, 1, 0, 0, 0, 2262, 2259, 1, 0, 0, 0, 2263, 265, 1, 0, 0, 0, 2264, 2265, 5, 160, 0, 0, 2265, 2271, 3, 256, 128, 0, 2266, 2267, 5, 160, 0, 0, 2267, 2271, 3, 0, 0, 0, 2268, 2269, 5, 160, 0, 0, 2269, 2271, 3, 32, 16, 0, 2270, 2264, 1, 0, 0, 0, 2270, 2266, 1, 0, 0, 0, 2270, 2268, 1, 0, 0, 0, 2271, 267, 1, 0, 0, 0, 2272, 2273, 5, 161, 0, 0, 2273, 2274, 3, 124, 62, 0, 2274, 269, 1, 0, 0, 0, 2275, 2276, 5, 162, 0, 0, 2276, 271, 1, 0, 0, 0, 2277, 2278, 5, 163, 0, 0, 2278, 273, 1, 0, 0, 0, 2279, 2291, 3, 256, 128, 0, 2280, 2281, 5, 164, 0, 0, 2281, 2282, 3, 0, 0, 0, 2282, 2283, 5, 159, 0, 0, 2283, 2284, 3, 0, 0, 0, 2284, 2291, 1, 0, 0, 0, 2285, 2286, 5, 164, 0, 0, 2286, 2287, 3, 32, 16, 0, 2287, 2288, 5, 159, 0, 0, 2288, 2289, 3, 32, 16, 0, 2289, 2291, 1, 0, 0, 0, 2290, 2279, 1, 0, 0, 0, 2290, 2280, 1, 0, 0, 0, 2290, 2285, 1, 0, 0, 0, 2291, 275, 1, 0, 0, 0, 2292, 2293, 3, 278, 139, 0, 2293, 2294, 3, 282, 141, 0, 2294, 277, 1, 0, 0, 0, 2295, 2296, 5, 165, 0, 0, 2296, 2297, 3, 280, 140, 0, 2297, 2298, 3, 0, 0, 0, 2298, 2299, 5, 36, 0, 0, 2299, 2303, 1, 0, 0, 0, 2300, 2301, 5, 165, 0, 0, 2301, 2303, 3, 280, 140, 0, 2302, 2295, 1, 0, 0, 0, 2302, 2300, 1, 0, 0, 0, 2303, 279, 1, 0, 0, 0, 2304, 2308, 1, 0, 0, 0, 2305, 2308, 5, 166, 0, 0, 2306, 2308, 5, 2, 0, 0, 2307, 2304, 1, 0, 0, 0, 2307, 2305, 1, 0, 0, 0, 2307, 2306, 1, 0, 0, 0, 2308, 281, 1, 0, 0, 0, 2309, 2310, 5, 17, 0, 0, 2310, 2311, 3, 284, 142, 0, 2311, 2312, 5, 18, 0, 0, 2312, 2319, 1, 0, 0, 0, 2313, 2315, 3, 288, 144, 0, 2314, 2313, 1, 0, 0, 0, 2315, 2316, 1, 0, 0, 0, 2316, 2314, 1, 0, 0, 0, 2316, 2317, 1, 0, 0, 0, 2317, 2319, 1, 0, 0, 0, 2318, 2309, 1, 0, 0, 0, 2318, 2314, 1, 0, 0, 0, 2319, 283, 1, 0, 0, 0, 2320, 2321, 3, 288, 144, 0, 2321, 2322, 5, 28, 0, 0, 2322, 2324, 1, 0, 0, 0, 2323, 2320, 1, 0, 0, 0, 2324, 2327, 1, 0, 0, 0, 2325, 2323, 1, 0, 0, 0, 2325, 2326, 1, 0, 0, 0, 2326, 2328, 1, 0, 0, 0, 2327, 2325, 1, 0, 0, 0, 2328, 2329, 3, 288, 144, 0, 2329, 285, 1, 0, 0, 0, 2330, 2336, 1, 0, 0, 0, 2331, 2332, 5, 42, 0, 0, 2332, 2333, 3, 32, 16, 0, 2333, 2334, 5, 43, 0, 0, 2334, 2336, 1, 0, 0, 0, 2335, 2330, 1, 0, 0, 0, 2335, 2331, 1, 0, 0, 0, 2336, 287, 1, 0, 0, 0, 2337, 2338, 5, 181, 0, 0, 2338, 2339, 5, 262, 0, 0, 2339, 2340, 5, 30, 0, 0, 2340, 2341, 3, 6, 3, 0, 2341, 2342, 5, 31, 0, 0, 2342, 2404, 1, 0, 0, 0, 2343, 2344, 5, 260, 0, 0, 2344, 2345, 5, 30, 0, 0, 2345, 2346, 3, 0, 0, 0, 2346, 2347, 5, 31, 0, 0, 2347, 2404, 1, 0, 0, 0, 2348, 2349, 5, 260, 0, 0, 2349, 2404, 3, 0, 0, 0, 2350, 2351, 5, 84, 0, 0, 2351, 2352, 5, 30, 0, 0, 2352, 2353, 3, 292, 146, 0, 2353, 2354, 5, 31, 0, 0, 2354, 2404, 1, 0, 0, 0, 2355, 2356, 5, 188, 0, 0, 2356, 2357, 5, 30, 0, 0, 2357, 2358, 3, 36, 18, 0, 2358, 2359, 5, 31, 0, 0, 2359, 2360, 3, 286, 143, 0, 2360, 2404, 1, 0, 0, 0, 2361, 2362, 5, 189, 0, 0, 2362, 2363, 5, 30, 0, 0, 2363, 2364, 3, 36, 18, 0, 2364, 2365, 5, 31, 0, 0, 2365, 2366, 3, 286, 143, 0, 2366, 2404, 1, 0, 0, 0, 2367, 2368, 5, 187, 0, 0, 2368, 2369, 5, 30, 0, 0, 2369, 2370, 3, 34, 17, 0, 2370, 2371, 5, 31, 0, 0, 2371, 2372, 3, 286, 143, 0, 2372, 2404, 1, 0, 0, 0, 2373, 2374, 5, 186, 0, 0, 2374, 2375, 5, 30, 0, 0, 2375, 2376, 3, 32, 16, 0, 2376, 2377, 5, 31, 0, 0, 2377, 2378, 3, 286, 143, 0, 2378, 2404, 1, 0, 0, 0, 2379, 2380, 5, 185, 0, 0, 2380, 2381, 5, 30, 0, 0, 2381, 2382, 3, 32, 16, 0, 2382, 2383, 5, 31, 0, 0, 2383, 2384, 3, 286, 143, 0, 2384, 2404, 1, 0, 0, 0, 2385, 2386, 5, 184, 0, 0, 2386, 2387, 5, 30, 0, 0, 2387, 2388, 3, 32, 16, 0, 2388, 2389, 5, 31, 0, 0, 2389, 2390, 3, 286, 143, 0, 2390, 2404, 1, 0, 0, 0, 2391, 2392, 5, 188, 0, 0, 2392, 2404, 3, 286, 143, 0, 2393, 2394, 5, 189, 0, 0, 2394, 2404, 3, 286, 143, 0, 2395, 2396, 5, 187, 0, 0, 2396, 2404, 3, 286, 143, 0, 2397, 2398, 5, 186, 0, 0, 2398, 2404, 3, 286, 143, 0, 2399, 2400, 5, 185, 0, 0, 2400, 2404, 3, 286, 143, 0, 2401, 2402, 5, 184, 0, 0, 2402, 2404, 3, 286, 143, 0, 2403, 2337, 1, 0, 0, 0, 2403, 2343, 1, 0, 0, 0, 2403, 2348, 1, 0, 0, 0, 2403, 2350, 1, 0, 0, 0, 2403, 2355, 1, 0, 0, 0, 2403, 2361, 1, 0, 0, 0, 2403, 2367, 1, 0, 0, 0, 2403, 2373, 1, 0, 0, 0, 2403, 2379, 1, 0, 0, 0, 2403, 2385, 1, 0, 0, 0, 2403, 2391, 1, 0, 0, 0, 2403, 2393, 1, 0, 0, 0, 2403, 2395, 1, 0, 0, 0, 2403, 2397, 1, 0, 0, 0, 2403, 2399, 1, 0, 0, 0, 2403, 2401, 1, 0, 0, 0, 2404, 289, 1, 0, 0, 0, 2405, 2406, 5, 188, 0, 0, 2406, 2407, 5, 30, 0, 0, 2407, 2408, 3, 36, 18, 0, 2408, 2409, 5, 31, 0, 0, 2409, 2481, 1, 0, 0, 0, 2410, 2411, 5, 189, 0, 0, 2411, 2412, 5, 30, 0, 0, 2412, 2413, 3, 36, 18, 0, 2413, 2414, 5, 31, 0, 0, 2414, 2481, 1, 0, 0, 0, 2415, 2416, 5, 188, 0, 0, 2416, 2417, 5, 30, 0, 0, 2417, 2418, 3, 32, 16, 0, 2418, 2419, 5, 31, 0, 0, 2419, 2481, 1, 0, 0, 0, 2420, 2421, 5, 189, 0, 0, 2421, 2422, 5, 30, 0, 0, 2422, 2423, 3, 34, 17, 0, 2423, 2424, 5, 31, 0, 0, 2424, 2481, 1, 0, 0, 0, 2425, 2426, 5, 187, 0, 0, 2426, 2427, 5, 30, 0, 0, 2427, 2428, 3, 34, 17, 0, 2428, 2429, 5, 31, 0, 0, 2429, 2481, 1, 0, 0, 0, 2430, 2431, 5, 186, 0, 0, 2431, 2432, 5, 30, 0, 0, 2432, 2433, 3, 32, 16, 0, 2433, 2434, 5, 31, 0, 0, 2434, 2481, 1, 0, 0, 0, 2435, 2436, 5, 185, 0, 0, 2436, 2437, 5, 30, 0, 0, 2437, 2438, 3, 32, 16, 0, 2438, 2439, 5, 31, 0, 0, 2439, 2481, 1, 0, 0, 0, 2440, 2441, 5, 184, 0, 0, 2441, 2442, 5, 30, 0, 0, 2442, 2443, 3, 32, 16, 0, 2443, 2444, 5, 31, 0, 0, 2444, 2481, 1, 0, 0, 0, 2445, 2446, 5, 193, 0, 0, 2446, 2447, 5, 30, 0, 0, 2447, 2448, 3, 34, 17, 0, 2448, 2449, 5, 31, 0, 0, 2449, 2481, 1, 0, 0, 0, 2450, 2451, 5, 192, 0, 0, 2451, 2452, 5, 30, 0, 0, 2452, 2453, 3, 32, 16, 0, 2453, 2454, 5, 31, 0, 0, 2454, 2481, 1, 0, 0, 0, 2455, 2456, 5, 191, 0, 0, 2456, 2457, 5, 30, 0, 0, 2457, 2458, 3, 32, 16, 0, 2458, 2459, 5, 31, 0, 0, 2459, 2481, 1, 0, 0, 0, 2460, 2461, 5, 190, 0, 0, 2461, 2462, 5, 30, 0, 0, 2462, 2463, 3, 32, 16, 0, 2463, 2464, 5, 31, 0, 0, 2464, 2481, 1, 0, 0, 0, 2465, 2466, 5, 181, 0, 0, 2466, 2467, 5, 30, 0, 0, 2467, 2468, 3, 32, 16, 0, 2468, 2469, 5, 31, 0, 0, 2469, 2481, 1, 0, 0, 0, 2470, 2471, 5, 183, 0, 0, 2471, 2472, 5, 30, 0, 0, 2472, 2473, 3, 162, 81, 0, 2473, 2474, 5, 31, 0, 0, 2474, 2481, 1, 0, 0, 0, 2475, 2476, 5, 84, 0, 0, 2476, 2477, 5, 30, 0, 0, 2477, 2478, 3, 292, 146, 0, 2478, 2479, 5, 31, 0, 0, 2479, 2481, 1, 0, 0, 0, 2480, 2405, 1, 0, 0, 0, 2480, 2410, 1, 0, 0, 0, 2480, 2415, 1, 0, 0, 0, 2480, 2420, 1, 0, 0, 0, 2480, 2425, 1, 0, 0, 0, 2480, 2430, 1, 0, 0, 0, 2480, 2435, 1, 0, 0, 0, 2480, 2440, 1, 0, 0, 0, 2480, 2445, 1, 0, 0, 0, 2480, 2450, 1, 0, 0, 0, 2480, 2455, 1, 0, 0, 0, 2480, 2460, 1, 0, 0, 0, 2480, 2465, 1, 0, 0, 0, 2480, 2470, 1, 0, 0, 0, 2480, 2475, 1, 0, 0, 0, 2481, 291, 1, 0, 0, 0, 2482, 2483, 3, 294, 147, 0, 2483, 2484, 6, 146, -1, 0, 2484, 2486, 1, 0, 0, 0, 2485, 2482, 1, 0, 0, 0, 2486, 2489, 1, 0, 0, 0, 2487, 2485, 1, 0, 0, 0, 2487, 2488, 1, 0, 0, 0, 2488, 293, 1, 0, 0, 0, 2489, 2487, 1, 0, 0, 0, 2490, 2491, 7, 12, 0, 0, 2491, 295, 1, 0, 0, 0, 2492, 2496, 3, 290, 145, 0, 2493, 2496, 3, 6, 3, 0, 2494, 2496, 5, 179, 0, 0, 2495, 2492, 1, 0, 0, 0, 2495, 2493, 1, 0, 0, 0, 2495, 2494, 1, 0, 0, 0, 2496, 297, 1, 0, 0, 0, 2497, 2646, 3, 290, 145, 0, 2498, 2499, 5, 182, 0, 0, 2499, 2500, 5, 30, 0, 0, 2500, 2501, 5, 179, 0, 0, 2501, 2646, 5, 31, 0, 0, 2502, 2503, 5, 182, 0, 0, 2503, 2504, 5, 30, 0, 0, 2504, 2505, 5, 264, 0, 0, 2505, 2646, 5, 31, 0, 0, 2506, 2507, 5, 196, 0, 0, 2507, 2508, 5, 30, 0, 0, 2508, 2509, 5, 39, 0, 0, 2509, 2510, 5, 264, 0, 0, 2510, 2646, 5, 31, 0, 0, 2511, 2512, 5, 196, 0, 0, 2512, 2513, 5, 30, 0, 0, 2513, 2514, 3, 116, 58, 0, 2514, 2515, 5, 31, 0, 0, 2515, 2646, 1, 0, 0, 0, 2516, 2517, 5, 196, 0, 0, 2517, 2518, 5, 30, 0, 0, 2518, 2519, 5, 179, 0, 0, 2519, 2646, 5, 31, 0, 0, 2520, 2521, 5, 197, 0, 0, 2521, 2522, 5, 30, 0, 0, 2522, 2523, 3, 298, 149, 0, 2523, 2524, 5, 31, 0, 0, 2524, 2646, 1, 0, 0, 0, 2525, 2526, 5, 188, 0, 0, 2526, 2527, 5, 42, 0, 0, 2527, 2528, 3, 32, 16, 0, 2528, 2529, 5, 43, 0, 0, 2529, 2530, 5, 30, 0, 0, 2530, 2531, 3, 300, 150, 0, 2531, 2532, 5, 31, 0, 0, 2532, 2646, 1, 0, 0, 0, 2533, 2534, 5, 189, 0, 0, 2534, 2535, 5, 42, 0, 0, 2535, 2536, 3, 32, 16, 0, 2536, 2537, 5, 43, 0, 0, 2537, 2538, 5, 30, 0, 0, 2538, 2539, 3, 302, 151, 0, 2539, 2540, 5, 31, 0, 0, 2540, 2646, 1, 0, 0, 0, 2541, 2542, 5, 187, 0, 0, 2542, 2543, 5, 42, 0, 0, 2543, 2544, 3, 32, 16, 0, 2544, 2545, 5, 43, 0, 0, 2545, 2546, 5, 30, 0, 0, 2546, 2547, 3, 304, 152, 0, 2547, 2548, 5, 31, 0, 0, 2548, 2646, 1, 0, 0, 0, 2549, 2550, 5, 186, 0, 0, 2550, 2551, 5, 42, 0, 0, 2551, 2552, 3, 32, 16, 0, 2552, 2553, 5, 43, 0, 0, 2553, 2554, 5, 30, 0, 0, 2554, 2555, 3, 306, 153, 0, 2555, 2556, 5, 31, 0, 0, 2556, 2646, 1, 0, 0, 0, 2557, 2558, 5, 185, 0, 0, 2558, 2559, 5, 42, 0, 0, 2559, 2560, 3, 32, 16, 0, 2560, 2561, 5, 43, 0, 0, 2561, 2562, 5, 30, 0, 0, 2562, 2563, 3, 308, 154, 0, 2563, 2564, 5, 31, 0, 0, 2564, 2646, 1, 0, 0, 0, 2565, 2566, 5, 184, 0, 0, 2566, 2567, 5, 42, 0, 0, 2567, 2568, 3, 32, 16, 0, 2568, 2569, 5, 43, 0, 0, 2569, 2570, 5, 30, 0, 0, 2570, 2571, 3, 310, 155, 0, 2571, 2572, 5, 31, 0, 0, 2572, 2646, 1, 0, 0, 0, 2573, 2574, 5, 193, 0, 0, 2574, 2575, 5, 42, 0, 0, 2575, 2576, 3, 32, 16, 0, 2576, 2577, 5, 43, 0, 0, 2577, 2578, 5, 30, 0, 0, 2578, 2579, 3, 304, 152, 0, 2579, 2580, 5, 31, 0, 0, 2580, 2646, 1, 0, 0, 0, 2581, 2582, 5, 192, 0, 0, 2582, 2583, 5, 42, 0, 0, 2583, 2584, 3, 32, 16, 0, 2584, 2585, 5, 43, 0, 0, 2585, 2586, 5, 30, 0, 0, 2586, 2587, 3, 306, 153, 0, 2587, 2588, 5, 31, 0, 0, 2588, 2646, 1, 0, 0, 0, 2589, 2590, 5, 191, 0, 0, 2590, 2591, 5, 42, 0, 0, 2591, 2592, 3, 32, 16, 0, 2592, 2593, 5, 43, 0, 0, 2593, 2594, 5, 30, 0, 0, 2594, 2595, 3, 308, 154, 0, 2595, 2596, 5, 31, 0, 0, 2596, 2646, 1, 0, 0, 0, 2597, 2598, 5, 190, 0, 0, 2598, 2599, 5, 42, 0, 0, 2599, 2600, 3, 32, 16, 0, 2600, 2601, 5, 43, 0, 0, 2601, 2602, 5, 30, 0, 0, 2602, 2603, 3, 310, 155, 0, 2603, 2604, 5, 31, 0, 0, 2604, 2646, 1, 0, 0, 0, 2605, 2606, 5, 181, 0, 0, 2606, 2607, 5, 42, 0, 0, 2607, 2608, 3, 32, 16, 0, 2608, 2609, 5, 43, 0, 0, 2609, 2610, 5, 30, 0, 0, 2610, 2611, 3, 308, 154, 0, 2611, 2612, 5, 31, 0, 0, 2612, 2646, 1, 0, 0, 0, 2613, 2614, 5, 183, 0, 0, 2614, 2615, 5, 42, 0, 0, 2615, 2616, 3, 32, 16, 0, 2616, 2617, 5, 43, 0, 0, 2617, 2618, 5, 30, 0, 0, 2618, 2619, 3, 312, 156, 0, 2619, 2620, 5, 31, 0, 0, 2620, 2646, 1, 0, 0, 0, 2621, 2622, 5, 182, 0, 0, 2622, 2623, 5, 42, 0, 0, 2623, 2624, 3, 32, 16, 0, 2624, 2625, 5, 43, 0, 0, 2625, 2626, 5, 30, 0, 0, 2626, 2627, 3, 314, 157, 0, 2627, 2628, 5, 31, 0, 0, 2628, 2646, 1, 0, 0, 0, 2629, 2630, 5, 196, 0, 0, 2630, 2631, 5, 42, 0, 0, 2631, 2632, 3, 32, 16, 0, 2632, 2633, 5, 43, 0, 0, 2633, 2634, 5, 30, 0, 0, 2634, 2635, 3, 316, 158, 0, 2635, 2636, 5, 31, 0, 0, 2636, 2646, 1, 0, 0, 0, 2637, 2638, 5, 197, 0, 0, 2638, 2639, 5, 42, 0, 0, 2639, 2640, 3, 32, 16, 0, 2640, 2641, 5, 43, 0, 0, 2641, 2642, 5, 30, 0, 0, 2642, 2643, 3, 320, 160, 0, 2643, 2644, 5, 31, 0, 0, 2644, 2646, 1, 0, 0, 0, 2645, 2497, 1, 0, 0, 0, 2645, 2498, 1, 0, 0, 0, 2645, 2502, 1, 0, 0, 0, 2645, 2506, 1, 0, 0, 0, 2645, 2511, 1, 0, 0, 0, 2645, 2516, 1, 0, 0, 0, 2645, 2520, 1, 0, 0, 0, 2645, 2525, 1, 0, 0, 0, 2645, 2533, 1, 0, 0, 0, 2645, 2541, 1, 0, 0, 0, 2645, 2549, 1, 0, 0, 0, 2645, 2557, 1, 0, 0, 0, 2645, 2565, 1, 0, 0, 0, 2645, 2573, 1, 0, 0, 0, 2645, 2581, 1, 0, 0, 0, 2645, 2589, 1, 0, 0, 0, 2645, 2597, 1, 0, 0, 0, 2645, 2605, 1, 0, 0, 0, 2645, 2613, 1, 0, 0, 0, 2645, 2621, 1, 0, 0, 0, 2645, 2629, 1, 0, 0, 0, 2645, 2637, 1, 0, 0, 0, 2646, 299, 1, 0, 0, 0, 2647, 2650, 3, 36, 18, 0, 2648, 2650, 3, 32, 16, 0, 2649, 2647, 1, 0, 0, 0, 2649, 2648, 1, 0, 0, 0, 2650, 2653, 1, 0, 0, 0, 2651, 2649, 1, 0, 0, 0, 2651, 2652, 1, 0, 0, 0, 2652, 301, 1, 0, 0, 0, 2653, 2651, 1, 0, 0, 0, 2654, 2657, 3, 36, 18, 0, 2655, 2657, 3, 34, 17, 0, 2656, 2654, 1, 0, 0, 0, 2656, 2655, 1, 0, 0, 0, 2657, 2660, 1, 0, 0, 0, 2658, 2656, 1, 0, 0, 0, 2658, 2659, 1, 0, 0, 0, 2659, 303, 1, 0, 0, 0, 2660, 2658, 1, 0, 0, 0, 2661, 2663, 3, 34, 17, 0, 2662, 2661, 1, 0, 0, 0, 2663, 2666, 1, 0, 0, 0, 2664, 2662, 1, 0, 0, 0, 2664, 2665, 1, 0, 0, 0, 2665, 305, 1, 0, 0, 0, 2666, 2664, 1, 0, 0, 0, 2667, 2669, 3, 32, 16, 0, 2668, 2667, 1, 0, 0, 0, 2669, 2672, 1, 0, 0, 0, 2670, 2668, 1, 0, 0, 0, 2670, 2671, 1, 0, 0, 0, 2671, 307, 1, 0, 0, 0, 2672, 2670, 1, 0, 0, 0, 2673, 2675, 3, 32, 16, 0, 2674, 2673, 1, 0, 0, 0, 2675, 2678, 1, 0, 0, 0, 2676, 2674, 1, 0, 0, 0, 2676, 2677, 1, 0, 0, 0, 2677, 309, 1, 0, 0, 0, 2678, 2676, 1, 0, 0, 0, 2679, 2681, 3, 32, 16, 0, 2680, 2679, 1, 0, 0, 0, 2681, 2684, 1, 0, 0, 0, 2682, 2680, 1, 0, 0, 0, 2682, 2683, 1, 0, 0, 0, 2683, 311, 1, 0, 0, 0, 2684, 2682, 1, 0, 0, 0, 2685, 2687, 3, 162, 81, 0, 2686, 2685, 1, 0, 0, 0, 2687, 2690, 1, 0, 0, 0, 2688, 2686, 1, 0, 0, 0, 2688, 2689, 1, 0, 0, 0, 2689, 313, 1, 0, 0, 0, 2690, 2688, 1, 0, 0, 0, 2691, 2693, 7, 13, 0, 0, 2692, 2691, 1, 0, 0, 0, 2693, 2696, 1, 0, 0, 0, 2694, 2692, 1, 0, 0, 0, 2694, 2695, 1, 0, 0, 0, 2695, 315, 1, 0, 0, 0, 2696, 2694, 1, 0, 0, 0, 2697, 2699, 3, 318, 159, 0, 2698, 2697, 1, 0, 0, 0, 2699, 2702, 1, 0, 0, 0, 2700, 2698, 1, 0, 0, 0, 2700, 2701, 1, 0, 0, 0, 2701, 317, 1, 0, 0, 0, 2702, 2700, 1, 0, 0, 0, 2703, 2708, 5, 179, 0, 0, 2704, 2705, 5, 39, 0, 0, 2705, 2708, 5, 264, 0, 0, 2706, 2708, 3, 116, 58, 0, 2707, 2703, 1, 0, 0, 0, 2707, 2704, 1, 0, 0, 0, 2707, 2706, 1, 0, 0, 0, 2708, 319, 1, 0, 0, 0, 2709, 2711, 3, 298, 149, 0, 2710, 2709, 1, 0, 0, 0, 2711, 2714, 1, 0, 0, 0, 2712, 2710, 1, 0, 0, 0, 2712, 2713, 1, 0, 0, 0, 2713, 321, 1, 0, 0, 0, 2714, 2712, 1, 0, 0, 0, 2715, 2719, 3, 44, 22, 0, 2716, 2719, 3, 46, 23, 0, 2717, 2719, 3, 2, 1, 0, 2718, 2715, 1, 0, 0, 0, 2718, 2716, 1, 0, 0, 0, 2718, 2717, 1, 0, 0, 0, 2719, 323, 1, 0, 0, 0, 2720, 2721, 7, 14, 0, 0, 2721, 2722, 5, 36, 0, 0, 2722, 2723, 5, 30, 0, 0, 2723, 2724, 3, 292, 146, 0, 2724, 2725, 5, 31, 0, 0, 2725, 2746, 1, 0, 0, 0, 2726, 2727, 5, 169, 0, 0, 2727, 2728, 3, 38, 19, 0, 2728, 2729, 5, 75, 0, 0, 2729, 2730, 3, 38, 19, 0, 2730, 2731, 5, 75, 0, 0, 2731, 2732, 3, 38, 19, 0, 2732, 2733, 5, 75, 0, 0, 2733, 2734, 3, 38, 19, 0, 2734, 2746, 1, 0, 0, 0, 2735, 2736, 5, 170, 0, 0, 2736, 2746, 3, 6, 3, 0, 2737, 2738, 5, 170, 0, 0, 2738, 2739, 5, 36, 0, 0, 2739, 2740, 5, 30, 0, 0, 2740, 2741, 3, 292, 146, 0, 2741, 2742, 5, 31, 0, 0, 2742, 2746, 1, 0, 0, 0, 2743, 2746, 3, 322, 161, 0, 2744, 2746, 3, 40, 20, 0, 2745, 2720, 1, 0, 0, 0, 2745, 2726, 1, 0, 0, 0, 2745, 2735, 1, 0, 0, 0, 2745, 2737, 1, 0, 0, 0, 2745, 2743, 1, 0, 0, 0, 2745, 2744, 1, 0, 0, 0, 2746, 325, 1, 0, 0, 0, 2747, 2748, 5, 25, 0, 0, 2748, 2749, 5, 40, 0, 0, 2749, 2750, 3, 98, 49, 0, 2750, 2751, 3, 2, 1, 0, 2751, 2760, 1, 0, 0, 0, 2752, 2753, 5, 25, 0, 0, 2753, 2754, 5, 40, 0, 0, 2754, 2755, 3, 98, 49, 0, 2755, 2756, 3, 2, 1, 0, 2756, 2757, 5, 34, 0, 0, 2757, 2758, 3, 2, 1, 0, 2758, 2760, 1, 0, 0, 0, 2759, 2747, 1, 0, 0, 0, 2759, 2752, 1, 0, 0, 0, 2760, 327, 1, 0, 0, 0, 2761, 2763, 3, 330, 165, 0, 2762, 2761, 1, 0, 0, 0, 2763, 2766, 1, 0, 0, 0, 2764, 2762, 1, 0, 0, 0, 2764, 2765, 1, 0, 0, 0, 2765, 329, 1, 0, 0, 0, 2766, 2764, 1, 0, 0, 0, 2767, 2768, 5, 180, 0, 0, 2768, 2769, 5, 36, 0, 0, 2769, 2770, 5, 30, 0, 0, 2770, 2771, 3, 292, 146, 0, 2771, 2772, 5, 31, 0, 0, 2772, 2782, 1, 0, 0, 0, 2773, 2782, 3, 324, 162, 0, 2774, 2775, 5, 171, 0, 0, 2775, 2776, 5, 36, 0, 0, 2776, 2777, 5, 30, 0, 0, 2777, 2778, 3, 292, 146, 0, 2778, 2779, 5, 31, 0, 0, 2779, 2782, 1, 0, 0, 0, 2780, 2782, 5, 55, 0, 0, 2781, 2767, 1, 0, 0, 0, 2781, 2773, 1, 0, 0, 0, 2781, 2774, 1, 0, 0, 0, 2781, 2780, 1, 0, 0, 0, 2782, 331, 1, 0, 0, 0, 2783, 2784, 5, 50, 0, 0, 2784, 2788, 5, 40, 0, 0, 2785, 2787, 3, 336, 168, 0, 2786, 2785, 1, 0, 0, 0, 2787, 2790, 1, 0, 0, 0, 2788, 2786, 1, 0, 0, 0, 2788, 2789, 1, 0, 0, 0, 2789, 2791, 1, 0, 0, 0, 2790, 2788, 1, 0, 0, 0, 2791, 2792, 3, 2, 1, 0, 2792, 333, 1, 0, 0, 0, 2793, 2797, 5, 301, 0, 0, 2794, 2796, 3, 336, 168, 0, 2795, 2794, 1, 0, 0, 0, 2796, 2799, 1, 0, 0, 0, 2797, 2795, 1, 0, 0, 0, 2797, 2798, 1, 0, 0, 0, 2798, 2800, 1, 0, 0, 0, 2799, 2797, 1, 0, 0, 0, 2800, 2801, 3, 2, 1, 0, 2801, 335, 1, 0, 0, 0, 2802, 2818, 5, 52, 0, 0, 2803, 2818, 5, 51, 0, 0, 2804, 2818, 5, 172, 0, 0, 2805, 2806, 5, 62, 0, 0, 2806, 2818, 5, 51, 0, 0, 2807, 2808, 5, 62, 0, 0, 2808, 2818, 5, 52, 0, 0, 2809, 2810, 5, 62, 0, 0, 2810, 2818, 5, 63, 0, 0, 2811, 2812, 5, 62, 0, 0, 2812, 2818, 5, 64, 0, 0, 2813, 2814, 5, 62, 0, 0, 2814, 2818, 5, 65, 0, 0, 2815, 2816, 5, 62, 0, 0, 2816, 2818, 5, 66, 0, 0, 2817, 2802, 1, 0, 0, 0, 2817, 2803, 1, 0, 0, 0, 2817, 2804, 1, 0, 0, 0, 2817, 2805, 1, 0, 0, 0, 2817, 2807, 1, 0, 0, 0, 2817, 2809, 1, 0, 0, 0, 2817, 2811, 1, 0, 0, 0, 2817, 2813, 1, 0, 0, 0, 2817, 2815, 1, 0, 0, 0, 2818, 337, 1, 0, 0, 0, 2819, 2821, 3, 340, 170, 0, 2820, 2819, 1, 0, 0, 0, 2821, 2824, 1, 0, 0, 0, 2822, 2820, 1, 0, 0, 0, 2822, 2823, 1, 0, 0, 0, 2823, 339, 1, 0, 0, 0, 2824, 2822, 1, 0, 0, 0, 2825, 2826, 5, 21, 0, 0, 2826, 2839, 3, 2, 1, 0, 2827, 2828, 5, 50, 0, 0, 2828, 2829, 5, 40, 0, 0, 2829, 2839, 3, 118, 59, 0, 2830, 2831, 5, 25, 0, 0, 2831, 2832, 5, 40, 0, 0, 2832, 2839, 3, 2, 1, 0, 2833, 2839, 3, 174, 87, 0, 2834, 2835, 5, 50, 0, 0, 2835, 2839, 3, 32, 16, 0, 2836, 2839, 3, 322, 161, 0, 2837, 2839, 3, 40, 20, 0, 2838, 2825, 1, 0, 0, 0, 2838, 2827, 1, 0, 0, 0, 2838, 2830, 1, 0, 0, 0, 2838, 2833, 1, 0, 0, 0, 2838, 2834, 1, 0, 0, 0, 2838, 2836, 1, 0, 0, 0, 2838, 2837, 1, 0, 0, 0, 2839, 341, 1, 0, 0, 0, 2840, 2844, 5, 274, 0, 0, 2841, 2843, 3, 344, 172, 0, 2842, 2841, 1, 0, 0, 0, 2843, 2846, 1, 0, 0, 0, 2844, 2842, 1, 0, 0, 0, 2844, 2845, 1, 0, 0, 0, 2845, 2847, 1, 0, 0, 0, 2846, 2844, 1, 0, 0, 0, 2847, 2860, 3, 2, 1, 0, 2848, 2852, 5, 274, 0, 0, 2849, 2851, 3, 344, 172, 0, 2850, 2849, 1, 0, 0, 0, 2851, 2854, 1, 0, 0, 0, 2852, 2850, 1, 0, 0, 0, 2852, 2853, 1, 0, 0, 0, 2853, 2855, 1, 0, 0, 0, 2854, 2852, 1, 0, 0, 0, 2855, 2856, 3, 2, 1, 0, 2856, 2857, 5, 34, 0, 0, 2857, 2858, 3, 2, 1, 0, 2858, 2860, 1, 0, 0, 0, 2859, 2840, 1, 0, 0, 0, 2859, 2848, 1, 0, 0, 0, 2860, 343, 1, 0, 0, 0, 2861, 2862, 7, 15, 0, 0, 2862, 345, 1, 0, 0, 0, 2863, 2865, 3, 348, 174, 0, 2864, 2863, 1, 0, 0, 0, 2865, 2868, 1, 0, 0, 0, 2866, 2864, 1, 0, 0, 0, 2866, 2867, 1, 0, 0, 0, 2867, 347, 1, 0, 0, 0, 2868, 2866, 1, 0, 0, 0, 2869, 2870, 5, 21, 0, 0, 2870, 2871, 3, 2, 1, 0, 2871, 2872, 5, 44, 0, 0, 2872, 2873, 3, 32, 16, 0, 2873, 2880, 1, 0, 0, 0, 2874, 2875, 5, 25, 0, 0, 2875, 2876, 5, 40, 0, 0, 2876, 2880, 3, 2, 1, 0, 2877, 2880, 3, 322, 161, 0, 2878, 2880, 3, 40, 20, 0, 2879, 2869, 1, 0, 0, 0, 2879, 2874, 1, 0, 0, 0, 2879, 2877, 1, 0, 0, 0, 2879, 2878, 1, 0, 0, 0, 2880, 349, 1, 0, 0, 0, 175, 358, 363, 371, 379, 432, 473, 482, 506, 510, 528, 555, 578, 614, 620, 627, 629, 639, 641, 648, 659, 667, 688, 690, 706, 751, 756, 761, 766, 774, 884, 890, 906, 912, 918, 925, 930, 982, 1018, 1023, 1029, 1034, 1036, 1044, 1056, 1068, 1075, 1082, 1084, 1111, 1118, 1126, 1134, 1147, 1154, 1157, 1176, 1270, 1279, 1286, 1289, 1297, 1318, 1350, 1373, 1385, 1394, 1419, 1443, 1451, 1455, 1470, 1477, 1522, 1532, 1548, 1560, 1572, 1586, 1598, 1609, 1616, 1626, 1639, 1644, 1649, 1658, 1669, 1752, 1761, 1774, 1785, 1793, 1803, 1805, 1832, 1839, 1844, 1851, 1857, 1867, 1871, 1878, 1893, 1899, 1913, 1926, 1934, 1941, 1945, 1950, 1966, 1971, 1973, 1986, 2012, 2019, 2021, 2026, 2032, 2061, 2066, 2089, 2094, 2114, 2167, 2176, 2189, 2200, 2211, 2214, 2222, 2234, 2248, 2262, 2270, 2290, 2302, 2307, 2316, 2318, 2325, 2335, 2403, 2480, 2487, 2495, 2645, 2649, 2651, 2656, 2658, 2664, 2670, 2676, 2682, 2688, 2694, 2700, 2707, 2712, 2718, 2745, 2759, 2764, 2781, 2788, 2797, 2817, 2822, 2838, 2844, 2852, 2859, 2866, 2879] \ No newline at end of file +[4, 1, 305, 2907, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 357, 8, 1, 10, 1, 12, 1, 360, 9, 1, 1, 1, 1, 1, 3, 1, 364, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 5, 3, 371, 8, 3, 10, 3, 12, 3, 374, 9, 3, 1, 3, 1, 3, 1, 3, 1, 4, 5, 4, 380, 8, 4, 10, 4, 12, 4, 383, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 435, 8, 5, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 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, 476, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 5, 15, 483, 8, 15, 10, 15, 12, 15, 486, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 515, 8, 18, 1, 19, 1, 19, 3, 19, 519, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 537, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 564, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 587, 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, 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, 623, 8, 23, 1, 24, 1, 24, 1, 25, 1, 25, 3, 25, 629, 8, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 5, 27, 636, 8, 27, 10, 27, 12, 27, 639, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 648, 8, 28, 10, 28, 12, 28, 651, 9, 28, 1, 29, 1, 29, 1, 30, 1, 30, 3, 30, 657, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 668, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 676, 8, 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, 34, 1, 34, 1, 34, 1, 34, 5, 34, 697, 8, 34, 10, 34, 12, 34, 700, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 5, 37, 713, 8, 37, 10, 37, 12, 37, 716, 9, 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, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 760, 8, 38, 1, 39, 1, 39, 1, 39, 3, 39, 765, 8, 39, 1, 40, 1, 40, 1, 40, 3, 40, 770, 8, 40, 1, 41, 5, 41, 773, 8, 41, 10, 41, 12, 41, 776, 9, 41, 1, 42, 1, 42, 1, 42, 5, 42, 781, 8, 42, 10, 42, 12, 42, 784, 9, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 893, 8, 44, 1, 45, 1, 45, 5, 45, 897, 8, 45, 10, 45, 12, 45, 900, 9, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 913, 8, 45, 10, 45, 12, 45, 916, 9, 45, 1, 45, 1, 45, 1, 45, 3, 45, 921, 8, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 927, 8, 47, 1, 48, 1, 48, 1, 49, 5, 49, 932, 8, 49, 10, 49, 12, 49, 935, 9, 49, 1, 50, 1, 50, 3, 50, 939, 8, 50, 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, 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, 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, 1017, 8, 51, 3, 51, 1019, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 1036, 8, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1045, 8, 53, 1, 53, 1, 53, 5, 53, 1049, 8, 53, 10, 53, 12, 53, 1052, 9, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1060, 8, 53, 3, 53, 1062, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1068, 8, 54, 10, 54, 12, 54, 1071, 9, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1080, 8, 55, 10, 55, 12, 55, 1083, 9, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 5, 56, 1092, 8, 56, 10, 56, 12, 56, 1095, 9, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1101, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 1108, 8, 57, 3, 57, 1110, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1137, 8, 58, 1, 59, 1, 59, 1, 59, 5, 59, 1142, 8, 59, 10, 59, 12, 59, 1145, 9, 59, 1, 59, 1, 59, 1, 60, 5, 60, 1150, 8, 60, 10, 60, 12, 60, 1153, 9, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1160, 8, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 3, 62, 1173, 8, 62, 1, 63, 1, 63, 1, 63, 5, 63, 1178, 8, 63, 10, 63, 12, 63, 1181, 9, 63, 3, 63, 1183, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 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, 1202, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1296, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1305, 8, 66, 1, 67, 1, 67, 1, 67, 5, 67, 1310, 8, 67, 10, 67, 12, 67, 1313, 9, 67, 3, 67, 1315, 8, 67, 1, 68, 1, 68, 1, 69, 1, 69, 5, 69, 1321, 8, 69, 10, 69, 12, 69, 1324, 9, 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, 1, 70, 1, 70, 1, 70, 3, 70, 1344, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1376, 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, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1399, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1411, 8, 73, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1420, 8, 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, 3, 76, 1445, 8, 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, 1469, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 5, 77, 1475, 8, 77, 10, 77, 12, 77, 1478, 9, 77, 1, 77, 3, 77, 1481, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1496, 8, 78, 1, 79, 1, 79, 1, 79, 5, 79, 1501, 8, 79, 10, 79, 12, 79, 1504, 9, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1548, 8, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1558, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1574, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1586, 8, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1598, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1612, 8, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 1624, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1635, 8, 89, 1, 90, 1, 90, 1, 90, 5, 90, 1640, 8, 90, 10, 90, 12, 90, 1643, 9, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 1652, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 1665, 8, 92, 1, 93, 5, 93, 1668, 8, 93, 10, 93, 12, 93, 1671, 9, 93, 1, 94, 1, 94, 3, 94, 1675, 8, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 5, 95, 1682, 8, 95, 10, 95, 12, 95, 1685, 9, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 3, 97, 1695, 8, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1776, 8, 99, 10, 99, 12, 99, 1779, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1785, 8, 99, 10, 99, 12, 99, 1788, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1798, 8, 99, 10, 99, 12, 99, 1801, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1809, 8, 99, 10, 99, 12, 99, 1812, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 1819, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 1829, 8, 100, 10, 100, 12, 100, 1832, 9, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 1858, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 1865, 8, 102, 1, 103, 1, 103, 1, 103, 3, 103, 1870, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 1877, 8, 104, 1, 105, 1, 105, 5, 105, 1881, 8, 105, 10, 105, 12, 105, 1884, 9, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 1891, 8, 105, 10, 105, 12, 105, 1894, 9, 105, 1, 105, 3, 105, 1897, 8, 105, 1, 106, 1, 106, 1, 107, 5, 107, 1902, 8, 107, 10, 107, 12, 107, 1905, 9, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 1919, 8, 108, 1, 109, 1, 109, 5, 109, 1923, 8, 109, 10, 109, 12, 109, 1926, 9, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 111, 5, 111, 1937, 8, 111, 10, 111, 12, 111, 1940, 9, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 1952, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 1960, 8, 113, 1, 114, 1, 114, 1, 114, 4, 114, 1965, 8, 114, 11, 114, 12, 114, 1966, 1, 114, 1, 114, 3, 114, 1971, 8, 114, 1, 115, 5, 115, 1974, 8, 115, 10, 115, 12, 115, 1977, 9, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 1992, 8, 116, 1, 117, 1, 117, 1, 117, 5, 117, 1997, 8, 117, 10, 117, 12, 117, 2000, 9, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2010, 8, 117, 10, 117, 12, 117, 2013, 9, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2038, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2045, 8, 119, 3, 119, 2047, 8, 119, 1, 119, 5, 119, 2050, 8, 119, 10, 119, 12, 119, 2053, 9, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2058, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2087, 8, 120, 1, 121, 1, 121, 1, 121, 3, 121, 2092, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2115, 8, 122, 1, 123, 5, 123, 2118, 8, 123, 10, 123, 12, 123, 2121, 9, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2140, 8, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2191, 8, 125, 10, 125, 12, 125, 2194, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2200, 8, 125, 10, 125, 12, 125, 2203, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2213, 8, 125, 10, 125, 12, 125, 2216, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2224, 8, 125, 10, 125, 12, 125, 2227, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2235, 8, 125, 10, 125, 12, 125, 2238, 9, 125, 3, 125, 2240, 8, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 3, 127, 2248, 8, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 130, 4, 130, 2258, 8, 130, 11, 130, 12, 130, 2259, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 2274, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 3, 132, 2288, 8, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 2296, 8, 133, 1, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 2316, 8, 137, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 2328, 8, 139, 1, 140, 1, 140, 1, 140, 3, 140, 2333, 8, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 4, 141, 2340, 8, 141, 11, 141, 12, 141, 2341, 3, 141, 2344, 8, 141, 1, 142, 1, 142, 1, 142, 5, 142, 2349, 8, 142, 10, 142, 12, 142, 2352, 9, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 2361, 8, 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, 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, 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, 2429, 8, 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, 145, 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, 145, 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, 145, 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, 145, 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, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 3, 145, 2506, 8, 145, 1, 146, 1, 146, 1, 146, 5, 146, 2511, 8, 146, 10, 146, 12, 146, 2514, 9, 146, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 3, 148, 2521, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 2671, 8, 149, 1, 150, 1, 150, 5, 150, 2675, 8, 150, 10, 150, 12, 150, 2678, 9, 150, 1, 151, 1, 151, 5, 151, 2682, 8, 151, 10, 151, 12, 151, 2685, 9, 151, 1, 152, 5, 152, 2688, 8, 152, 10, 152, 12, 152, 2691, 9, 152, 1, 153, 5, 153, 2694, 8, 153, 10, 153, 12, 153, 2697, 9, 153, 1, 154, 5, 154, 2700, 8, 154, 10, 154, 12, 154, 2703, 9, 154, 1, 155, 5, 155, 2706, 8, 155, 10, 155, 12, 155, 2709, 9, 155, 1, 156, 5, 156, 2712, 8, 156, 10, 156, 12, 156, 2715, 9, 156, 1, 157, 5, 157, 2718, 8, 157, 10, 157, 12, 157, 2721, 9, 157, 1, 158, 5, 158, 2724, 8, 158, 10, 158, 12, 158, 2727, 9, 158, 1, 159, 1, 159, 1, 159, 1, 159, 3, 159, 2733, 8, 159, 1, 160, 5, 160, 2736, 8, 160, 10, 160, 12, 160, 2739, 9, 160, 1, 161, 1, 161, 1, 161, 3, 161, 2744, 8, 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, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 3, 162, 2771, 8, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 2785, 8, 163, 1, 164, 5, 164, 2788, 8, 164, 10, 164, 12, 164, 2791, 9, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 3, 165, 2807, 8, 165, 1, 166, 1, 166, 1, 166, 5, 166, 2812, 8, 166, 10, 166, 12, 166, 2815, 9, 166, 1, 166, 1, 166, 1, 167, 1, 167, 5, 167, 2821, 8, 167, 10, 167, 12, 167, 2824, 9, 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, 168, 1, 168, 1, 168, 1, 168, 3, 168, 2843, 8, 168, 1, 169, 5, 169, 2846, 8, 169, 10, 169, 12, 169, 2849, 9, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 2864, 8, 170, 1, 171, 1, 171, 5, 171, 2868, 8, 171, 10, 171, 12, 171, 2871, 9, 171, 1, 171, 1, 171, 1, 171, 5, 171, 2876, 8, 171, 10, 171, 12, 171, 2879, 9, 171, 1, 171, 1, 171, 1, 171, 1, 171, 3, 171, 2885, 8, 171, 1, 172, 1, 172, 1, 173, 5, 173, 2890, 8, 173, 10, 173, 12, 173, 2893, 9, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 2905, 8, 174, 1, 174, 0, 1, 68, 175, 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, 0, 16, 6, 0, 1, 15, 199, 199, 243, 243, 247, 247, 264, 264, 289, 289, 5, 0, 16, 16, 199, 199, 243, 243, 264, 264, 288, 289, 1, 0, 263, 264, 1, 0, 173, 174, 1, 0, 37, 38, 1, 0, 73, 74, 3, 0, 2, 2, 61, 61, 77, 83, 2, 0, 229, 229, 260, 261, 9, 0, 178, 178, 183, 195, 201, 201, 207, 208, 210, 215, 218, 219, 222, 222, 230, 242, 262, 262, 1, 0, 95, 96, 1, 0, 97, 111, 1, 0, 68, 69, 2, 0, 173, 173, 289, 290, 2, 0, 179, 179, 264, 264, 1, 0, 167, 168, 1, 0, 51, 52, 3334, 0, 350, 1, 0, 0, 0, 2, 363, 1, 0, 0, 0, 4, 365, 1, 0, 0, 0, 6, 372, 1, 0, 0, 0, 8, 381, 1, 0, 0, 0, 10, 434, 1, 0, 0, 0, 12, 436, 1, 0, 0, 0, 14, 439, 1, 0, 0, 0, 16, 442, 1, 0, 0, 0, 18, 446, 1, 0, 0, 0, 20, 449, 1, 0, 0, 0, 22, 452, 1, 0, 0, 0, 24, 459, 1, 0, 0, 0, 26, 475, 1, 0, 0, 0, 28, 477, 1, 0, 0, 0, 30, 479, 1, 0, 0, 0, 32, 489, 1, 0, 0, 0, 34, 491, 1, 0, 0, 0, 36, 514, 1, 0, 0, 0, 38, 518, 1, 0, 0, 0, 40, 536, 1, 0, 0, 0, 42, 563, 1, 0, 0, 0, 44, 586, 1, 0, 0, 0, 46, 622, 1, 0, 0, 0, 48, 624, 1, 0, 0, 0, 50, 628, 1, 0, 0, 0, 52, 630, 1, 0, 0, 0, 54, 637, 1, 0, 0, 0, 56, 649, 1, 0, 0, 0, 58, 652, 1, 0, 0, 0, 60, 654, 1, 0, 0, 0, 62, 667, 1, 0, 0, 0, 64, 675, 1, 0, 0, 0, 66, 677, 1, 0, 0, 0, 68, 685, 1, 0, 0, 0, 70, 701, 1, 0, 0, 0, 72, 707, 1, 0, 0, 0, 74, 710, 1, 0, 0, 0, 76, 759, 1, 0, 0, 0, 78, 764, 1, 0, 0, 0, 80, 769, 1, 0, 0, 0, 82, 774, 1, 0, 0, 0, 84, 782, 1, 0, 0, 0, 86, 787, 1, 0, 0, 0, 88, 892, 1, 0, 0, 0, 90, 920, 1, 0, 0, 0, 92, 922, 1, 0, 0, 0, 94, 926, 1, 0, 0, 0, 96, 928, 1, 0, 0, 0, 98, 933, 1, 0, 0, 0, 100, 938, 1, 0, 0, 0, 102, 1018, 1, 0, 0, 0, 104, 1035, 1, 0, 0, 0, 106, 1061, 1, 0, 0, 0, 108, 1063, 1, 0, 0, 0, 110, 1075, 1, 0, 0, 0, 112, 1100, 1, 0, 0, 0, 114, 1109, 1, 0, 0, 0, 116, 1136, 1, 0, 0, 0, 118, 1143, 1, 0, 0, 0, 120, 1151, 1, 0, 0, 0, 122, 1159, 1, 0, 0, 0, 124, 1172, 1, 0, 0, 0, 126, 1182, 1, 0, 0, 0, 128, 1201, 1, 0, 0, 0, 130, 1295, 1, 0, 0, 0, 132, 1304, 1, 0, 0, 0, 134, 1314, 1, 0, 0, 0, 136, 1316, 1, 0, 0, 0, 138, 1318, 1, 0, 0, 0, 140, 1343, 1, 0, 0, 0, 142, 1375, 1, 0, 0, 0, 144, 1398, 1, 0, 0, 0, 146, 1410, 1, 0, 0, 0, 148, 1412, 1, 0, 0, 0, 150, 1415, 1, 0, 0, 0, 152, 1468, 1, 0, 0, 0, 154, 1480, 1, 0, 0, 0, 156, 1495, 1, 0, 0, 0, 158, 1502, 1, 0, 0, 0, 160, 1507, 1, 0, 0, 0, 162, 1511, 1, 0, 0, 0, 164, 1547, 1, 0, 0, 0, 166, 1549, 1, 0, 0, 0, 168, 1585, 1, 0, 0, 0, 170, 1597, 1, 0, 0, 0, 172, 1611, 1, 0, 0, 0, 174, 1613, 1, 0, 0, 0, 176, 1623, 1, 0, 0, 0, 178, 1634, 1, 0, 0, 0, 180, 1641, 1, 0, 0, 0, 182, 1651, 1, 0, 0, 0, 184, 1664, 1, 0, 0, 0, 186, 1669, 1, 0, 0, 0, 188, 1672, 1, 0, 0, 0, 190, 1683, 1, 0, 0, 0, 192, 1688, 1, 0, 0, 0, 194, 1694, 1, 0, 0, 0, 196, 1696, 1, 0, 0, 0, 198, 1818, 1, 0, 0, 0, 200, 1820, 1, 0, 0, 0, 202, 1857, 1, 0, 0, 0, 204, 1864, 1, 0, 0, 0, 206, 1869, 1, 0, 0, 0, 208, 1876, 1, 0, 0, 0, 210, 1896, 1, 0, 0, 0, 212, 1898, 1, 0, 0, 0, 214, 1903, 1, 0, 0, 0, 216, 1918, 1, 0, 0, 0, 218, 1920, 1, 0, 0, 0, 220, 1933, 1, 0, 0, 0, 222, 1938, 1, 0, 0, 0, 224, 1951, 1, 0, 0, 0, 226, 1959, 1, 0, 0, 0, 228, 1970, 1, 0, 0, 0, 230, 1975, 1, 0, 0, 0, 232, 1991, 1, 0, 0, 0, 234, 1993, 1, 0, 0, 0, 236, 2037, 1, 0, 0, 0, 238, 2057, 1, 0, 0, 0, 240, 2086, 1, 0, 0, 0, 242, 2091, 1, 0, 0, 0, 244, 2114, 1, 0, 0, 0, 246, 2119, 1, 0, 0, 0, 248, 2139, 1, 0, 0, 0, 250, 2239, 1, 0, 0, 0, 252, 2241, 1, 0, 0, 0, 254, 2247, 1, 0, 0, 0, 256, 2249, 1, 0, 0, 0, 258, 2253, 1, 0, 0, 0, 260, 2257, 1, 0, 0, 0, 262, 2273, 1, 0, 0, 0, 264, 2287, 1, 0, 0, 0, 266, 2295, 1, 0, 0, 0, 268, 2297, 1, 0, 0, 0, 270, 2300, 1, 0, 0, 0, 272, 2302, 1, 0, 0, 0, 274, 2315, 1, 0, 0, 0, 276, 2317, 1, 0, 0, 0, 278, 2327, 1, 0, 0, 0, 280, 2332, 1, 0, 0, 0, 282, 2343, 1, 0, 0, 0, 284, 2350, 1, 0, 0, 0, 286, 2360, 1, 0, 0, 0, 288, 2428, 1, 0, 0, 0, 290, 2505, 1, 0, 0, 0, 292, 2512, 1, 0, 0, 0, 294, 2515, 1, 0, 0, 0, 296, 2520, 1, 0, 0, 0, 298, 2670, 1, 0, 0, 0, 300, 2676, 1, 0, 0, 0, 302, 2683, 1, 0, 0, 0, 304, 2689, 1, 0, 0, 0, 306, 2695, 1, 0, 0, 0, 308, 2701, 1, 0, 0, 0, 310, 2707, 1, 0, 0, 0, 312, 2713, 1, 0, 0, 0, 314, 2719, 1, 0, 0, 0, 316, 2725, 1, 0, 0, 0, 318, 2732, 1, 0, 0, 0, 320, 2737, 1, 0, 0, 0, 322, 2743, 1, 0, 0, 0, 324, 2770, 1, 0, 0, 0, 326, 2784, 1, 0, 0, 0, 328, 2789, 1, 0, 0, 0, 330, 2806, 1, 0, 0, 0, 332, 2808, 1, 0, 0, 0, 334, 2818, 1, 0, 0, 0, 336, 2842, 1, 0, 0, 0, 338, 2847, 1, 0, 0, 0, 340, 2863, 1, 0, 0, 0, 342, 2884, 1, 0, 0, 0, 344, 2886, 1, 0, 0, 0, 346, 2891, 1, 0, 0, 0, 348, 2904, 1, 0, 0, 0, 350, 351, 7, 0, 0, 0, 351, 1, 1, 0, 0, 0, 352, 364, 5, 288, 0, 0, 353, 354, 3, 4, 2, 0, 354, 355, 5, 265, 0, 0, 355, 357, 1, 0, 0, 0, 356, 353, 1, 0, 0, 0, 357, 360, 1, 0, 0, 0, 358, 356, 1, 0, 0, 0, 358, 359, 1, 0, 0, 0, 359, 361, 1, 0, 0, 0, 360, 358, 1, 0, 0, 0, 361, 364, 3, 4, 2, 0, 362, 364, 5, 264, 0, 0, 363, 352, 1, 0, 0, 0, 363, 358, 1, 0, 0, 0, 363, 362, 1, 0, 0, 0, 364, 3, 1, 0, 0, 0, 365, 366, 7, 1, 0, 0, 366, 5, 1, 0, 0, 0, 367, 368, 5, 263, 0, 0, 368, 369, 6, 3, -1, 0, 369, 371, 5, 266, 0, 0, 370, 367, 1, 0, 0, 0, 371, 374, 1, 0, 0, 0, 372, 370, 1, 0, 0, 0, 372, 373, 1, 0, 0, 0, 373, 375, 1, 0, 0, 0, 374, 372, 1, 0, 0, 0, 375, 376, 5, 263, 0, 0, 376, 377, 6, 3, -1, 0, 377, 7, 1, 0, 0, 0, 378, 380, 3, 10, 5, 0, 379, 378, 1, 0, 0, 0, 380, 383, 1, 0, 0, 0, 381, 379, 1, 0, 0, 0, 381, 382, 1, 0, 0, 0, 382, 9, 1, 0, 0, 0, 383, 381, 1, 0, 0, 0, 384, 385, 3, 74, 37, 0, 385, 386, 5, 17, 0, 0, 386, 387, 3, 82, 41, 0, 387, 388, 5, 18, 0, 0, 388, 435, 1, 0, 0, 0, 389, 390, 3, 72, 36, 0, 390, 391, 5, 17, 0, 0, 391, 392, 3, 8, 4, 0, 392, 393, 5, 18, 0, 0, 393, 435, 1, 0, 0, 0, 394, 395, 3, 234, 117, 0, 395, 396, 5, 17, 0, 0, 396, 397, 3, 246, 123, 0, 397, 398, 5, 18, 0, 0, 398, 435, 1, 0, 0, 0, 399, 435, 3, 200, 100, 0, 400, 435, 3, 276, 138, 0, 401, 435, 3, 70, 35, 0, 402, 435, 3, 66, 33, 0, 403, 435, 3, 88, 44, 0, 404, 435, 3, 90, 45, 0, 405, 435, 3, 22, 11, 0, 406, 407, 3, 326, 163, 0, 407, 408, 5, 17, 0, 0, 408, 409, 3, 328, 164, 0, 409, 410, 5, 18, 0, 0, 410, 435, 1, 0, 0, 0, 411, 412, 3, 332, 166, 0, 412, 413, 5, 17, 0, 0, 413, 414, 3, 338, 169, 0, 414, 415, 5, 18, 0, 0, 415, 435, 1, 0, 0, 0, 416, 417, 3, 342, 171, 0, 417, 418, 5, 17, 0, 0, 418, 419, 3, 346, 173, 0, 419, 420, 5, 18, 0, 0, 420, 435, 1, 0, 0, 0, 421, 435, 3, 64, 32, 0, 422, 435, 3, 152, 76, 0, 423, 435, 3, 322, 161, 0, 424, 435, 3, 12, 6, 0, 425, 435, 3, 14, 7, 0, 426, 435, 3, 16, 8, 0, 427, 435, 3, 18, 9, 0, 428, 435, 3, 20, 10, 0, 429, 435, 3, 26, 13, 0, 430, 435, 3, 42, 21, 0, 431, 435, 3, 40, 20, 0, 432, 435, 3, 30, 15, 0, 433, 435, 3, 24, 12, 0, 434, 384, 1, 0, 0, 0, 434, 389, 1, 0, 0, 0, 434, 394, 1, 0, 0, 0, 434, 399, 1, 0, 0, 0, 434, 400, 1, 0, 0, 0, 434, 401, 1, 0, 0, 0, 434, 402, 1, 0, 0, 0, 434, 403, 1, 0, 0, 0, 434, 404, 1, 0, 0, 0, 434, 405, 1, 0, 0, 0, 434, 406, 1, 0, 0, 0, 434, 411, 1, 0, 0, 0, 434, 416, 1, 0, 0, 0, 434, 421, 1, 0, 0, 0, 434, 422, 1, 0, 0, 0, 434, 423, 1, 0, 0, 0, 434, 424, 1, 0, 0, 0, 434, 425, 1, 0, 0, 0, 434, 426, 1, 0, 0, 0, 434, 427, 1, 0, 0, 0, 434, 428, 1, 0, 0, 0, 434, 429, 1, 0, 0, 0, 434, 430, 1, 0, 0, 0, 434, 431, 1, 0, 0, 0, 434, 432, 1, 0, 0, 0, 434, 433, 1, 0, 0, 0, 435, 11, 1, 0, 0, 0, 436, 437, 5, 19, 0, 0, 437, 438, 3, 32, 16, 0, 438, 13, 1, 0, 0, 0, 439, 440, 5, 20, 0, 0, 440, 441, 3, 32, 16, 0, 441, 15, 1, 0, 0, 0, 442, 443, 5, 21, 0, 0, 443, 444, 5, 22, 0, 0, 444, 445, 3, 32, 16, 0, 445, 17, 1, 0, 0, 0, 446, 447, 5, 23, 0, 0, 447, 448, 3, 34, 17, 0, 448, 19, 1, 0, 0, 0, 449, 450, 5, 24, 0, 0, 450, 451, 3, 34, 17, 0, 451, 21, 1, 0, 0, 0, 452, 453, 5, 25, 0, 0, 453, 454, 3, 98, 49, 0, 454, 455, 3, 2, 1, 0, 455, 456, 5, 17, 0, 0, 456, 457, 3, 120, 60, 0, 457, 458, 5, 18, 0, 0, 458, 23, 1, 0, 0, 0, 459, 460, 5, 26, 0, 0, 460, 25, 1, 0, 0, 0, 461, 462, 5, 27, 0, 0, 462, 476, 3, 28, 14, 0, 463, 464, 5, 27, 0, 0, 464, 465, 3, 28, 14, 0, 465, 466, 5, 28, 0, 0, 466, 467, 3, 28, 14, 0, 467, 476, 1, 0, 0, 0, 468, 469, 5, 27, 0, 0, 469, 470, 3, 28, 14, 0, 470, 471, 5, 28, 0, 0, 471, 472, 3, 28, 14, 0, 472, 473, 5, 28, 0, 0, 473, 474, 3, 28, 14, 0, 474, 476, 1, 0, 0, 0, 475, 461, 1, 0, 0, 0, 475, 463, 1, 0, 0, 0, 475, 468, 1, 0, 0, 0, 476, 27, 1, 0, 0, 0, 477, 478, 7, 2, 0, 0, 478, 29, 1, 0, 0, 0, 479, 480, 5, 29, 0, 0, 480, 484, 5, 17, 0, 0, 481, 483, 3, 116, 58, 0, 482, 481, 1, 0, 0, 0, 483, 486, 1, 0, 0, 0, 484, 482, 1, 0, 0, 0, 484, 485, 1, 0, 0, 0, 485, 487, 1, 0, 0, 0, 486, 484, 1, 0, 0, 0, 487, 488, 5, 18, 0, 0, 488, 31, 1, 0, 0, 0, 489, 490, 5, 173, 0, 0, 490, 33, 1, 0, 0, 0, 491, 492, 7, 3, 0, 0, 492, 35, 1, 0, 0, 0, 493, 494, 5, 175, 0, 0, 494, 515, 6, 18, -1, 0, 495, 496, 3, 32, 16, 0, 496, 497, 5, 265, 0, 0, 497, 498, 6, 18, -1, 0, 498, 515, 1, 0, 0, 0, 499, 500, 3, 32, 16, 0, 500, 501, 6, 18, -1, 0, 501, 515, 1, 0, 0, 0, 502, 503, 5, 188, 0, 0, 503, 504, 5, 30, 0, 0, 504, 505, 3, 32, 16, 0, 505, 506, 5, 31, 0, 0, 506, 507, 6, 18, -1, 0, 507, 515, 1, 0, 0, 0, 508, 509, 5, 189, 0, 0, 509, 510, 5, 30, 0, 0, 510, 511, 3, 34, 17, 0, 511, 512, 5, 31, 0, 0, 512, 513, 6, 18, -1, 0, 513, 515, 1, 0, 0, 0, 514, 493, 1, 0, 0, 0, 514, 495, 1, 0, 0, 0, 514, 499, 1, 0, 0, 0, 514, 502, 1, 0, 0, 0, 514, 508, 1, 0, 0, 0, 515, 37, 1, 0, 0, 0, 516, 519, 3, 32, 16, 0, 517, 519, 5, 262, 0, 0, 518, 516, 1, 0, 0, 0, 518, 517, 1, 0, 0, 0, 519, 39, 1, 0, 0, 0, 520, 521, 5, 267, 0, 0, 521, 537, 5, 289, 0, 0, 522, 523, 5, 267, 0, 0, 523, 524, 5, 289, 0, 0, 524, 537, 5, 263, 0, 0, 525, 526, 5, 268, 0, 0, 526, 537, 5, 289, 0, 0, 527, 528, 5, 269, 0, 0, 528, 537, 5, 289, 0, 0, 529, 530, 5, 270, 0, 0, 530, 537, 5, 289, 0, 0, 531, 537, 5, 271, 0, 0, 532, 537, 5, 272, 0, 0, 533, 534, 5, 273, 0, 0, 534, 537, 5, 263, 0, 0, 535, 537, 5, 32, 0, 0, 536, 520, 1, 0, 0, 0, 536, 522, 1, 0, 0, 0, 536, 525, 1, 0, 0, 0, 536, 527, 1, 0, 0, 0, 536, 529, 1, 0, 0, 0, 536, 531, 1, 0, 0, 0, 536, 532, 1, 0, 0, 0, 536, 533, 1, 0, 0, 0, 536, 535, 1, 0, 0, 0, 537, 41, 1, 0, 0, 0, 538, 539, 5, 33, 0, 0, 539, 540, 3, 138, 69, 0, 540, 541, 5, 34, 0, 0, 541, 542, 3, 2, 1, 0, 542, 564, 1, 0, 0, 0, 543, 544, 5, 33, 0, 0, 544, 545, 3, 116, 58, 0, 545, 546, 5, 34, 0, 0, 546, 547, 3, 2, 1, 0, 547, 564, 1, 0, 0, 0, 548, 549, 5, 33, 0, 0, 549, 550, 3, 176, 88, 0, 550, 551, 5, 34, 0, 0, 551, 552, 3, 2, 1, 0, 552, 564, 1, 0, 0, 0, 553, 554, 5, 33, 0, 0, 554, 555, 3, 44, 22, 0, 555, 556, 5, 34, 0, 0, 556, 557, 3, 2, 1, 0, 557, 564, 1, 0, 0, 0, 558, 559, 5, 33, 0, 0, 559, 560, 3, 46, 23, 0, 560, 561, 5, 34, 0, 0, 561, 562, 3, 2, 1, 0, 562, 564, 1, 0, 0, 0, 563, 538, 1, 0, 0, 0, 563, 543, 1, 0, 0, 0, 563, 548, 1, 0, 0, 0, 563, 553, 1, 0, 0, 0, 563, 558, 1, 0, 0, 0, 564, 43, 1, 0, 0, 0, 565, 566, 5, 35, 0, 0, 566, 587, 3, 48, 24, 0, 567, 568, 5, 35, 0, 0, 568, 569, 3, 48, 24, 0, 569, 570, 5, 36, 0, 0, 570, 571, 3, 6, 3, 0, 571, 587, 1, 0, 0, 0, 572, 573, 5, 35, 0, 0, 573, 574, 3, 48, 24, 0, 574, 575, 5, 36, 0, 0, 575, 576, 5, 17, 0, 0, 576, 577, 3, 52, 26, 0, 577, 578, 5, 18, 0, 0, 578, 587, 1, 0, 0, 0, 579, 580, 5, 35, 0, 0, 580, 581, 3, 48, 24, 0, 581, 582, 5, 36, 0, 0, 582, 583, 5, 30, 0, 0, 583, 584, 3, 292, 146, 0, 584, 585, 5, 31, 0, 0, 585, 587, 1, 0, 0, 0, 586, 565, 1, 0, 0, 0, 586, 567, 1, 0, 0, 0, 586, 572, 1, 0, 0, 0, 586, 579, 1, 0, 0, 0, 587, 45, 1, 0, 0, 0, 588, 589, 5, 35, 0, 0, 589, 590, 5, 30, 0, 0, 590, 591, 3, 50, 25, 0, 591, 592, 5, 31, 0, 0, 592, 593, 3, 48, 24, 0, 593, 623, 1, 0, 0, 0, 594, 595, 5, 35, 0, 0, 595, 596, 5, 30, 0, 0, 596, 597, 3, 50, 25, 0, 597, 598, 5, 31, 0, 0, 598, 599, 3, 48, 24, 0, 599, 600, 5, 36, 0, 0, 600, 601, 3, 6, 3, 0, 601, 623, 1, 0, 0, 0, 602, 603, 5, 35, 0, 0, 603, 604, 5, 30, 0, 0, 604, 605, 3, 50, 25, 0, 605, 606, 5, 31, 0, 0, 606, 607, 3, 48, 24, 0, 607, 608, 5, 36, 0, 0, 608, 609, 5, 17, 0, 0, 609, 610, 3, 52, 26, 0, 610, 611, 5, 18, 0, 0, 611, 623, 1, 0, 0, 0, 612, 613, 5, 35, 0, 0, 613, 614, 5, 30, 0, 0, 614, 615, 3, 50, 25, 0, 615, 616, 5, 31, 0, 0, 616, 617, 3, 48, 24, 0, 617, 618, 5, 36, 0, 0, 618, 619, 5, 30, 0, 0, 619, 620, 3, 292, 146, 0, 620, 621, 5, 31, 0, 0, 621, 623, 1, 0, 0, 0, 622, 588, 1, 0, 0, 0, 622, 594, 1, 0, 0, 0, 622, 602, 1, 0, 0, 0, 622, 612, 1, 0, 0, 0, 623, 47, 1, 0, 0, 0, 624, 625, 3, 168, 84, 0, 625, 49, 1, 0, 0, 0, 626, 629, 3, 124, 62, 0, 627, 629, 3, 176, 88, 0, 628, 626, 1, 0, 0, 0, 628, 627, 1, 0, 0, 0, 629, 51, 1, 0, 0, 0, 630, 631, 3, 54, 27, 0, 631, 632, 3, 56, 28, 0, 632, 53, 1, 0, 0, 0, 633, 636, 3, 298, 149, 0, 634, 636, 3, 40, 20, 0, 635, 633, 1, 0, 0, 0, 635, 634, 1, 0, 0, 0, 636, 639, 1, 0, 0, 0, 637, 635, 1, 0, 0, 0, 637, 638, 1, 0, 0, 0, 638, 55, 1, 0, 0, 0, 639, 637, 1, 0, 0, 0, 640, 641, 3, 58, 29, 0, 641, 642, 3, 60, 30, 0, 642, 643, 3, 2, 1, 0, 643, 644, 5, 36, 0, 0, 644, 645, 3, 298, 149, 0, 645, 648, 1, 0, 0, 0, 646, 648, 3, 40, 20, 0, 647, 640, 1, 0, 0, 0, 647, 646, 1, 0, 0, 0, 648, 651, 1, 0, 0, 0, 649, 647, 1, 0, 0, 0, 649, 650, 1, 0, 0, 0, 650, 57, 1, 0, 0, 0, 651, 649, 1, 0, 0, 0, 652, 653, 7, 4, 0, 0, 653, 59, 1, 0, 0, 0, 654, 656, 3, 62, 31, 0, 655, 657, 5, 261, 0, 0, 656, 655, 1, 0, 0, 0, 656, 657, 1, 0, 0, 0, 657, 61, 1, 0, 0, 0, 658, 668, 3, 144, 72, 0, 659, 668, 3, 2, 1, 0, 660, 668, 5, 196, 0, 0, 661, 668, 5, 197, 0, 0, 662, 663, 5, 202, 0, 0, 663, 664, 5, 39, 0, 0, 664, 668, 5, 264, 0, 0, 665, 666, 5, 202, 0, 0, 666, 668, 3, 116, 58, 0, 667, 658, 1, 0, 0, 0, 667, 659, 1, 0, 0, 0, 667, 660, 1, 0, 0, 0, 667, 661, 1, 0, 0, 0, 667, 662, 1, 0, 0, 0, 667, 665, 1, 0, 0, 0, 668, 63, 1, 0, 0, 0, 669, 670, 5, 198, 0, 0, 670, 671, 5, 40, 0, 0, 671, 676, 3, 2, 1, 0, 672, 673, 5, 198, 0, 0, 673, 676, 3, 2, 1, 0, 674, 676, 5, 198, 0, 0, 675, 669, 1, 0, 0, 0, 675, 672, 1, 0, 0, 0, 675, 674, 1, 0, 0, 0, 676, 65, 1, 0, 0, 0, 677, 678, 5, 41, 0, 0, 678, 679, 5, 42, 0, 0, 679, 680, 3, 32, 16, 0, 680, 681, 5, 43, 0, 0, 681, 682, 3, 68, 34, 0, 682, 683, 5, 44, 0, 0, 683, 684, 3, 0, 0, 0, 684, 67, 1, 0, 0, 0, 685, 698, 6, 34, -1, 0, 686, 687, 10, 5, 0, 0, 687, 697, 5, 186, 0, 0, 688, 689, 10, 4, 0, 0, 689, 697, 5, 187, 0, 0, 690, 691, 10, 3, 0, 0, 691, 697, 5, 45, 0, 0, 692, 693, 10, 2, 0, 0, 693, 697, 5, 46, 0, 0, 694, 695, 10, 1, 0, 0, 695, 697, 5, 47, 0, 0, 696, 686, 1, 0, 0, 0, 696, 688, 1, 0, 0, 0, 696, 690, 1, 0, 0, 0, 696, 692, 1, 0, 0, 0, 696, 694, 1, 0, 0, 0, 697, 700, 1, 0, 0, 0, 698, 696, 1, 0, 0, 0, 698, 699, 1, 0, 0, 0, 699, 69, 1, 0, 0, 0, 700, 698, 1, 0, 0, 0, 701, 702, 5, 48, 0, 0, 702, 703, 5, 36, 0, 0, 703, 704, 5, 30, 0, 0, 704, 705, 3, 292, 146, 0, 705, 706, 5, 31, 0, 0, 706, 71, 1, 0, 0, 0, 707, 708, 5, 49, 0, 0, 708, 709, 3, 2, 1, 0, 709, 73, 1, 0, 0, 0, 710, 714, 5, 50, 0, 0, 711, 713, 3, 76, 38, 0, 712, 711, 1, 0, 0, 0, 713, 716, 1, 0, 0, 0, 714, 712, 1, 0, 0, 0, 714, 715, 1, 0, 0, 0, 715, 717, 1, 0, 0, 0, 716, 714, 1, 0, 0, 0, 717, 718, 3, 2, 1, 0, 718, 719, 3, 182, 91, 0, 719, 720, 3, 78, 39, 0, 720, 721, 3, 80, 40, 0, 721, 75, 1, 0, 0, 0, 722, 760, 5, 51, 0, 0, 723, 760, 5, 52, 0, 0, 724, 760, 5, 199, 0, 0, 725, 760, 5, 202, 0, 0, 726, 760, 5, 221, 0, 0, 727, 760, 5, 53, 0, 0, 728, 760, 5, 54, 0, 0, 729, 760, 5, 55, 0, 0, 730, 760, 5, 56, 0, 0, 731, 760, 5, 244, 0, 0, 732, 760, 5, 15, 0, 0, 733, 760, 5, 224, 0, 0, 734, 760, 5, 57, 0, 0, 735, 760, 5, 58, 0, 0, 736, 760, 5, 59, 0, 0, 737, 760, 5, 60, 0, 0, 738, 760, 5, 61, 0, 0, 739, 740, 5, 62, 0, 0, 740, 760, 5, 51, 0, 0, 741, 742, 5, 62, 0, 0, 742, 760, 5, 52, 0, 0, 743, 744, 5, 62, 0, 0, 744, 760, 5, 63, 0, 0, 745, 746, 5, 62, 0, 0, 746, 760, 5, 64, 0, 0, 747, 748, 5, 62, 0, 0, 748, 760, 5, 65, 0, 0, 749, 750, 5, 62, 0, 0, 750, 760, 5, 66, 0, 0, 751, 760, 5, 67, 0, 0, 752, 760, 5, 68, 0, 0, 753, 760, 5, 69, 0, 0, 754, 755, 5, 70, 0, 0, 755, 756, 5, 30, 0, 0, 756, 757, 3, 32, 16, 0, 757, 758, 5, 31, 0, 0, 758, 760, 1, 0, 0, 0, 759, 722, 1, 0, 0, 0, 759, 723, 1, 0, 0, 0, 759, 724, 1, 0, 0, 0, 759, 725, 1, 0, 0, 0, 759, 726, 1, 0, 0, 0, 759, 727, 1, 0, 0, 0, 759, 728, 1, 0, 0, 0, 759, 729, 1, 0, 0, 0, 759, 730, 1, 0, 0, 0, 759, 731, 1, 0, 0, 0, 759, 732, 1, 0, 0, 0, 759, 733, 1, 0, 0, 0, 759, 734, 1, 0, 0, 0, 759, 735, 1, 0, 0, 0, 759, 736, 1, 0, 0, 0, 759, 737, 1, 0, 0, 0, 759, 738, 1, 0, 0, 0, 759, 739, 1, 0, 0, 0, 759, 741, 1, 0, 0, 0, 759, 743, 1, 0, 0, 0, 759, 745, 1, 0, 0, 0, 759, 747, 1, 0, 0, 0, 759, 749, 1, 0, 0, 0, 759, 751, 1, 0, 0, 0, 759, 752, 1, 0, 0, 0, 759, 753, 1, 0, 0, 0, 759, 754, 1, 0, 0, 0, 760, 77, 1, 0, 0, 0, 761, 765, 1, 0, 0, 0, 762, 763, 5, 71, 0, 0, 763, 765, 3, 124, 62, 0, 764, 761, 1, 0, 0, 0, 764, 762, 1, 0, 0, 0, 765, 79, 1, 0, 0, 0, 766, 770, 1, 0, 0, 0, 767, 768, 5, 72, 0, 0, 768, 770, 3, 84, 42, 0, 769, 766, 1, 0, 0, 0, 769, 767, 1, 0, 0, 0, 770, 81, 1, 0, 0, 0, 771, 773, 3, 198, 99, 0, 772, 771, 1, 0, 0, 0, 773, 776, 1, 0, 0, 0, 774, 772, 1, 0, 0, 0, 774, 775, 1, 0, 0, 0, 775, 83, 1, 0, 0, 0, 776, 774, 1, 0, 0, 0, 777, 778, 3, 124, 62, 0, 778, 779, 5, 28, 0, 0, 779, 781, 1, 0, 0, 0, 780, 777, 1, 0, 0, 0, 781, 784, 1, 0, 0, 0, 782, 780, 1, 0, 0, 0, 782, 783, 1, 0, 0, 0, 783, 785, 1, 0, 0, 0, 784, 782, 1, 0, 0, 0, 785, 786, 3, 124, 62, 0, 786, 85, 1, 0, 0, 0, 787, 788, 7, 5, 0, 0, 788, 87, 1, 0, 0, 0, 789, 790, 3, 86, 43, 0, 790, 791, 3, 32, 16, 0, 791, 792, 5, 264, 0, 0, 792, 893, 1, 0, 0, 0, 793, 794, 3, 86, 43, 0, 794, 795, 3, 32, 16, 0, 795, 893, 1, 0, 0, 0, 796, 797, 3, 86, 43, 0, 797, 798, 3, 32, 16, 0, 798, 799, 5, 75, 0, 0, 799, 800, 3, 32, 16, 0, 800, 801, 5, 264, 0, 0, 801, 893, 1, 0, 0, 0, 802, 803, 3, 86, 43, 0, 803, 804, 3, 32, 16, 0, 804, 805, 5, 75, 0, 0, 805, 806, 3, 32, 16, 0, 806, 893, 1, 0, 0, 0, 807, 808, 3, 86, 43, 0, 808, 809, 3, 32, 16, 0, 809, 810, 5, 75, 0, 0, 810, 811, 3, 32, 16, 0, 811, 812, 5, 28, 0, 0, 812, 813, 3, 32, 16, 0, 813, 814, 5, 264, 0, 0, 814, 893, 1, 0, 0, 0, 815, 816, 3, 86, 43, 0, 816, 817, 3, 32, 16, 0, 817, 818, 5, 75, 0, 0, 818, 819, 3, 32, 16, 0, 819, 820, 5, 28, 0, 0, 820, 821, 3, 32, 16, 0, 821, 893, 1, 0, 0, 0, 822, 823, 3, 86, 43, 0, 823, 824, 3, 32, 16, 0, 824, 825, 5, 28, 0, 0, 825, 826, 3, 32, 16, 0, 826, 827, 5, 75, 0, 0, 827, 828, 3, 32, 16, 0, 828, 829, 5, 264, 0, 0, 829, 893, 1, 0, 0, 0, 830, 831, 3, 86, 43, 0, 831, 832, 3, 32, 16, 0, 832, 833, 5, 28, 0, 0, 833, 834, 3, 32, 16, 0, 834, 835, 5, 75, 0, 0, 835, 836, 3, 32, 16, 0, 836, 893, 1, 0, 0, 0, 837, 838, 3, 86, 43, 0, 838, 839, 3, 32, 16, 0, 839, 840, 5, 28, 0, 0, 840, 841, 3, 32, 16, 0, 841, 842, 5, 75, 0, 0, 842, 843, 3, 32, 16, 0, 843, 844, 5, 28, 0, 0, 844, 845, 3, 32, 16, 0, 845, 846, 5, 264, 0, 0, 846, 893, 1, 0, 0, 0, 847, 848, 3, 86, 43, 0, 848, 849, 3, 32, 16, 0, 849, 850, 5, 28, 0, 0, 850, 851, 3, 32, 16, 0, 851, 852, 5, 75, 0, 0, 852, 853, 3, 32, 16, 0, 853, 854, 5, 28, 0, 0, 854, 855, 3, 32, 16, 0, 855, 893, 1, 0, 0, 0, 856, 857, 3, 86, 43, 0, 857, 858, 3, 32, 16, 0, 858, 859, 5, 263, 0, 0, 859, 893, 1, 0, 0, 0, 860, 861, 3, 86, 43, 0, 861, 862, 3, 32, 16, 0, 862, 863, 5, 75, 0, 0, 863, 864, 3, 32, 16, 0, 864, 865, 5, 263, 0, 0, 865, 893, 1, 0, 0, 0, 866, 867, 3, 86, 43, 0, 867, 868, 3, 32, 16, 0, 868, 869, 5, 75, 0, 0, 869, 870, 3, 32, 16, 0, 870, 871, 5, 28, 0, 0, 871, 872, 3, 32, 16, 0, 872, 873, 5, 263, 0, 0, 873, 893, 1, 0, 0, 0, 874, 875, 3, 86, 43, 0, 875, 876, 3, 32, 16, 0, 876, 877, 5, 28, 0, 0, 877, 878, 3, 32, 16, 0, 878, 879, 5, 75, 0, 0, 879, 880, 3, 32, 16, 0, 880, 881, 5, 263, 0, 0, 881, 893, 1, 0, 0, 0, 882, 883, 3, 86, 43, 0, 883, 884, 3, 32, 16, 0, 884, 885, 5, 28, 0, 0, 885, 886, 3, 32, 16, 0, 886, 887, 5, 75, 0, 0, 887, 888, 3, 32, 16, 0, 888, 889, 5, 28, 0, 0, 889, 890, 3, 32, 16, 0, 890, 891, 5, 263, 0, 0, 891, 893, 1, 0, 0, 0, 892, 789, 1, 0, 0, 0, 892, 793, 1, 0, 0, 0, 892, 796, 1, 0, 0, 0, 892, 802, 1, 0, 0, 0, 892, 807, 1, 0, 0, 0, 892, 815, 1, 0, 0, 0, 892, 822, 1, 0, 0, 0, 892, 830, 1, 0, 0, 0, 892, 837, 1, 0, 0, 0, 892, 847, 1, 0, 0, 0, 892, 856, 1, 0, 0, 0, 892, 860, 1, 0, 0, 0, 892, 866, 1, 0, 0, 0, 892, 874, 1, 0, 0, 0, 892, 882, 1, 0, 0, 0, 893, 89, 1, 0, 0, 0, 894, 898, 5, 21, 0, 0, 895, 897, 3, 92, 46, 0, 896, 895, 1, 0, 0, 0, 897, 900, 1, 0, 0, 0, 898, 896, 1, 0, 0, 0, 898, 899, 1, 0, 0, 0, 899, 901, 1, 0, 0, 0, 900, 898, 1, 0, 0, 0, 901, 902, 3, 2, 1, 0, 902, 903, 3, 94, 47, 0, 903, 904, 5, 180, 0, 0, 904, 905, 5, 36, 0, 0, 905, 906, 5, 30, 0, 0, 906, 907, 3, 292, 146, 0, 907, 908, 5, 31, 0, 0, 908, 909, 3, 94, 47, 0, 909, 921, 1, 0, 0, 0, 910, 914, 5, 21, 0, 0, 911, 913, 3, 92, 46, 0, 912, 911, 1, 0, 0, 0, 913, 916, 1, 0, 0, 0, 914, 912, 1, 0, 0, 0, 914, 915, 1, 0, 0, 0, 915, 917, 1, 0, 0, 0, 916, 914, 1, 0, 0, 0, 917, 918, 3, 2, 1, 0, 918, 919, 3, 94, 47, 0, 919, 921, 1, 0, 0, 0, 920, 894, 1, 0, 0, 0, 920, 910, 1, 0, 0, 0, 921, 91, 1, 0, 0, 0, 922, 923, 5, 76, 0, 0, 923, 93, 1, 0, 0, 0, 924, 927, 1, 0, 0, 0, 925, 927, 5, 298, 0, 0, 926, 924, 1, 0, 0, 0, 926, 925, 1, 0, 0, 0, 927, 95, 1, 0, 0, 0, 928, 929, 7, 6, 0, 0, 929, 97, 1, 0, 0, 0, 930, 932, 3, 96, 48, 0, 931, 930, 1, 0, 0, 0, 932, 935, 1, 0, 0, 0, 933, 931, 1, 0, 0, 0, 933, 934, 1, 0, 0, 0, 934, 99, 1, 0, 0, 0, 935, 933, 1, 0, 0, 0, 936, 939, 3, 102, 51, 0, 937, 939, 3, 104, 52, 0, 938, 936, 1, 0, 0, 0, 938, 937, 1, 0, 0, 0, 939, 101, 1, 0, 0, 0, 940, 941, 5, 275, 0, 0, 941, 1019, 6, 51, -1, 0, 942, 943, 5, 276, 0, 0, 943, 944, 3, 32, 16, 0, 944, 945, 6, 51, -1, 0, 945, 1019, 1, 0, 0, 0, 946, 947, 5, 276, 0, 0, 947, 948, 3, 0, 0, 0, 948, 949, 6, 51, -1, 0, 949, 1019, 1, 0, 0, 0, 950, 951, 5, 277, 0, 0, 951, 952, 3, 32, 16, 0, 952, 953, 6, 51, -1, 0, 953, 1019, 1, 0, 0, 0, 954, 955, 5, 278, 0, 0, 955, 956, 3, 34, 17, 0, 956, 957, 6, 51, -1, 0, 957, 1019, 1, 0, 0, 0, 958, 959, 5, 279, 0, 0, 959, 960, 3, 36, 18, 0, 960, 961, 6, 51, -1, 0, 961, 1019, 1, 0, 0, 0, 962, 963, 5, 279, 0, 0, 963, 964, 3, 34, 17, 0, 964, 965, 6, 51, -1, 0, 965, 1019, 1, 0, 0, 0, 966, 967, 5, 279, 0, 0, 967, 968, 5, 30, 0, 0, 968, 969, 3, 292, 146, 0, 969, 970, 5, 31, 0, 0, 970, 971, 6, 51, -1, 0, 971, 1019, 1, 0, 0, 0, 972, 973, 5, 279, 0, 0, 973, 974, 5, 84, 0, 0, 974, 975, 5, 30, 0, 0, 975, 976, 3, 292, 146, 0, 976, 977, 5, 31, 0, 0, 977, 978, 6, 51, -1, 0, 978, 1019, 1, 0, 0, 0, 979, 980, 5, 282, 0, 0, 980, 981, 3, 32, 16, 0, 981, 982, 6, 51, -1, 0, 982, 1019, 1, 0, 0, 0, 983, 984, 5, 282, 0, 0, 984, 985, 3, 0, 0, 0, 985, 986, 6, 51, -1, 0, 986, 1019, 1, 0, 0, 0, 987, 988, 5, 285, 0, 0, 988, 989, 3, 6, 3, 0, 989, 990, 6, 51, -1, 0, 990, 1019, 1, 0, 0, 0, 991, 992, 5, 285, 0, 0, 992, 993, 5, 224, 0, 0, 993, 994, 5, 30, 0, 0, 994, 995, 3, 6, 3, 0, 995, 996, 5, 31, 0, 0, 996, 997, 6, 51, -1, 0, 997, 1019, 1, 0, 0, 0, 998, 999, 5, 285, 0, 0, 999, 1000, 5, 84, 0, 0, 1000, 1001, 5, 30, 0, 0, 1001, 1002, 3, 292, 146, 0, 1002, 1003, 5, 31, 0, 0, 1003, 1004, 6, 51, -1, 0, 1004, 1019, 1, 0, 0, 0, 1005, 1006, 5, 287, 0, 0, 1006, 1007, 3, 32, 16, 0, 1007, 1008, 6, 51, -1, 0, 1008, 1019, 1, 0, 0, 0, 1009, 1010, 5, 283, 0, 0, 1010, 1016, 6, 51, -1, 0, 1011, 1012, 5, 30, 0, 0, 1012, 1013, 3, 106, 53, 0, 1013, 1014, 5, 31, 0, 0, 1014, 1017, 1, 0, 0, 0, 1015, 1017, 5, 85, 0, 0, 1016, 1011, 1, 0, 0, 0, 1016, 1015, 1, 0, 0, 0, 1017, 1019, 1, 0, 0, 0, 1018, 940, 1, 0, 0, 0, 1018, 942, 1, 0, 0, 0, 1018, 946, 1, 0, 0, 0, 1018, 950, 1, 0, 0, 0, 1018, 954, 1, 0, 0, 0, 1018, 958, 1, 0, 0, 0, 1018, 962, 1, 0, 0, 0, 1018, 966, 1, 0, 0, 0, 1018, 972, 1, 0, 0, 0, 1018, 979, 1, 0, 0, 0, 1018, 983, 1, 0, 0, 0, 1018, 987, 1, 0, 0, 0, 1018, 991, 1, 0, 0, 0, 1018, 998, 1, 0, 0, 0, 1018, 1005, 1, 0, 0, 0, 1018, 1009, 1, 0, 0, 0, 1019, 103, 1, 0, 0, 0, 1020, 1021, 5, 280, 0, 0, 1021, 1036, 3, 168, 84, 0, 1022, 1023, 5, 286, 0, 0, 1023, 1036, 3, 178, 89, 0, 1024, 1025, 5, 286, 0, 0, 1025, 1036, 3, 174, 87, 0, 1026, 1027, 5, 284, 0, 0, 1027, 1036, 3, 124, 62, 0, 1028, 1029, 5, 281, 0, 0, 1029, 1030, 3, 170, 85, 0, 1030, 1031, 3, 138, 69, 0, 1031, 1032, 3, 112, 56, 0, 1032, 1036, 1, 0, 0, 0, 1033, 1034, 5, 287, 0, 0, 1034, 1036, 3, 50, 25, 0, 1035, 1020, 1, 0, 0, 0, 1035, 1022, 1, 0, 0, 0, 1035, 1024, 1, 0, 0, 0, 1035, 1026, 1, 0, 0, 0, 1035, 1028, 1, 0, 0, 0, 1035, 1033, 1, 0, 0, 0, 1036, 105, 1, 0, 0, 0, 1037, 1062, 1, 0, 0, 0, 1038, 1039, 3, 0, 0, 0, 1039, 1040, 6, 53, -1, 0, 1040, 1045, 1, 0, 0, 0, 1041, 1042, 3, 32, 16, 0, 1042, 1043, 6, 53, -1, 0, 1043, 1045, 1, 0, 0, 0, 1044, 1038, 1, 0, 0, 0, 1044, 1041, 1, 0, 0, 0, 1045, 1046, 1, 0, 0, 0, 1046, 1047, 5, 28, 0, 0, 1047, 1049, 1, 0, 0, 0, 1048, 1044, 1, 0, 0, 0, 1049, 1052, 1, 0, 0, 0, 1050, 1048, 1, 0, 0, 0, 1050, 1051, 1, 0, 0, 0, 1051, 1059, 1, 0, 0, 0, 1052, 1050, 1, 0, 0, 0, 1053, 1054, 3, 0, 0, 0, 1054, 1055, 6, 53, -1, 0, 1055, 1060, 1, 0, 0, 0, 1056, 1057, 3, 32, 16, 0, 1057, 1058, 6, 53, -1, 0, 1058, 1060, 1, 0, 0, 0, 1059, 1053, 1, 0, 0, 0, 1059, 1056, 1, 0, 0, 0, 1060, 1062, 1, 0, 0, 0, 1061, 1037, 1, 0, 0, 0, 1061, 1050, 1, 0, 0, 0, 1062, 107, 1, 0, 0, 0, 1063, 1069, 5, 86, 0, 0, 1064, 1065, 3, 138, 69, 0, 1065, 1066, 5, 28, 0, 0, 1066, 1068, 1, 0, 0, 0, 1067, 1064, 1, 0, 0, 0, 1068, 1071, 1, 0, 0, 0, 1069, 1067, 1, 0, 0, 0, 1069, 1070, 1, 0, 0, 0, 1070, 1072, 1, 0, 0, 0, 1071, 1069, 1, 0, 0, 0, 1072, 1073, 3, 138, 69, 0, 1073, 1074, 5, 87, 0, 0, 1074, 109, 1, 0, 0, 0, 1075, 1081, 5, 42, 0, 0, 1076, 1077, 3, 146, 73, 0, 1077, 1078, 5, 28, 0, 0, 1078, 1080, 1, 0, 0, 0, 1079, 1076, 1, 0, 0, 0, 1080, 1083, 1, 0, 0, 0, 1081, 1079, 1, 0, 0, 0, 1081, 1082, 1, 0, 0, 0, 1082, 1084, 1, 0, 0, 0, 1083, 1081, 1, 0, 0, 0, 1084, 1085, 3, 146, 73, 0, 1085, 1086, 5, 43, 0, 0, 1086, 111, 1, 0, 0, 0, 1087, 1093, 5, 30, 0, 0, 1088, 1089, 3, 114, 57, 0, 1089, 1090, 5, 28, 0, 0, 1090, 1092, 1, 0, 0, 0, 1091, 1088, 1, 0, 0, 0, 1092, 1095, 1, 0, 0, 0, 1093, 1091, 1, 0, 0, 0, 1093, 1094, 1, 0, 0, 0, 1094, 1096, 1, 0, 0, 0, 1095, 1093, 1, 0, 0, 0, 1096, 1097, 3, 114, 57, 0, 1097, 1098, 5, 31, 0, 0, 1098, 1101, 1, 0, 0, 0, 1099, 1101, 5, 85, 0, 0, 1100, 1087, 1, 0, 0, 0, 1100, 1099, 1, 0, 0, 0, 1101, 113, 1, 0, 0, 0, 1102, 1110, 5, 177, 0, 0, 1103, 1104, 3, 230, 115, 0, 1104, 1105, 3, 138, 69, 0, 1105, 1107, 3, 226, 113, 0, 1106, 1108, 3, 0, 0, 0, 1107, 1106, 1, 0, 0, 0, 1107, 1108, 1, 0, 0, 0, 1108, 1110, 1, 0, 0, 0, 1109, 1102, 1, 0, 0, 0, 1109, 1103, 1, 0, 0, 0, 1110, 115, 1, 0, 0, 0, 1111, 1112, 5, 42, 0, 0, 1112, 1113, 3, 2, 1, 0, 1113, 1114, 5, 43, 0, 0, 1114, 1115, 3, 118, 59, 0, 1115, 1137, 1, 0, 0, 0, 1116, 1117, 5, 42, 0, 0, 1117, 1118, 3, 174, 87, 0, 1118, 1119, 5, 43, 0, 0, 1119, 1120, 3, 118, 59, 0, 1120, 1137, 1, 0, 0, 0, 1121, 1122, 5, 42, 0, 0, 1122, 1123, 5, 262, 0, 0, 1123, 1124, 5, 43, 0, 0, 1124, 1137, 3, 118, 59, 0, 1125, 1126, 5, 42, 0, 0, 1126, 1127, 5, 198, 0, 0, 1127, 1128, 3, 2, 1, 0, 1128, 1129, 5, 43, 0, 0, 1129, 1130, 3, 118, 59, 0, 1130, 1137, 1, 0, 0, 0, 1131, 1137, 3, 118, 59, 0, 1132, 1137, 3, 174, 87, 0, 1133, 1137, 5, 257, 0, 0, 1134, 1137, 5, 258, 0, 0, 1135, 1137, 5, 259, 0, 0, 1136, 1111, 1, 0, 0, 0, 1136, 1116, 1, 0, 0, 0, 1136, 1121, 1, 0, 0, 0, 1136, 1125, 1, 0, 0, 0, 1136, 1131, 1, 0, 0, 0, 1136, 1132, 1, 0, 0, 0, 1136, 1133, 1, 0, 0, 0, 1136, 1134, 1, 0, 0, 0, 1136, 1135, 1, 0, 0, 0, 1137, 117, 1, 0, 0, 0, 1138, 1139, 3, 2, 1, 0, 1139, 1140, 5, 88, 0, 0, 1140, 1142, 1, 0, 0, 0, 1141, 1138, 1, 0, 0, 0, 1142, 1145, 1, 0, 0, 0, 1143, 1141, 1, 0, 0, 0, 1143, 1144, 1, 0, 0, 0, 1144, 1146, 1, 0, 0, 0, 1145, 1143, 1, 0, 0, 0, 1146, 1147, 3, 2, 1, 0, 1147, 119, 1, 0, 0, 0, 1148, 1150, 3, 122, 61, 0, 1149, 1148, 1, 0, 0, 0, 1150, 1153, 1, 0, 0, 0, 1151, 1149, 1, 0, 0, 0, 1151, 1152, 1, 0, 0, 0, 1152, 121, 1, 0, 0, 0, 1153, 1151, 1, 0, 0, 0, 1154, 1155, 5, 180, 0, 0, 1155, 1156, 5, 89, 0, 0, 1156, 1160, 3, 32, 16, 0, 1157, 1160, 3, 152, 76, 0, 1158, 1160, 3, 324, 162, 0, 1159, 1154, 1, 0, 0, 0, 1159, 1157, 1, 0, 0, 0, 1159, 1158, 1, 0, 0, 0, 1160, 123, 1, 0, 0, 0, 1161, 1173, 3, 116, 58, 0, 1162, 1163, 5, 42, 0, 0, 1163, 1164, 3, 2, 1, 0, 1164, 1165, 5, 43, 0, 0, 1165, 1173, 1, 0, 0, 0, 1166, 1167, 5, 42, 0, 0, 1167, 1168, 5, 198, 0, 0, 1168, 1169, 3, 2, 1, 0, 1169, 1170, 5, 43, 0, 0, 1170, 1173, 1, 0, 0, 0, 1171, 1173, 3, 138, 69, 0, 1172, 1161, 1, 0, 0, 0, 1172, 1162, 1, 0, 0, 0, 1172, 1166, 1, 0, 0, 0, 1172, 1171, 1, 0, 0, 0, 1173, 125, 1, 0, 0, 0, 1174, 1183, 1, 0, 0, 0, 1175, 1179, 3, 130, 65, 0, 1176, 1178, 3, 128, 64, 0, 1177, 1176, 1, 0, 0, 0, 1178, 1181, 1, 0, 0, 0, 1179, 1177, 1, 0, 0, 0, 1179, 1180, 1, 0, 0, 0, 1180, 1183, 1, 0, 0, 0, 1181, 1179, 1, 0, 0, 0, 1182, 1174, 1, 0, 0, 0, 1182, 1175, 1, 0, 0, 0, 1183, 127, 1, 0, 0, 0, 1184, 1202, 5, 262, 0, 0, 1185, 1202, 5, 261, 0, 0, 1186, 1187, 5, 42, 0, 0, 1187, 1188, 3, 32, 16, 0, 1188, 1189, 5, 43, 0, 0, 1189, 1202, 1, 0, 0, 0, 1190, 1191, 5, 42, 0, 0, 1191, 1192, 3, 32, 16, 0, 1192, 1193, 5, 266, 0, 0, 1193, 1194, 3, 32, 16, 0, 1194, 1195, 5, 43, 0, 0, 1195, 1202, 1, 0, 0, 0, 1196, 1197, 5, 42, 0, 0, 1197, 1198, 5, 266, 0, 0, 1198, 1199, 3, 32, 16, 0, 1199, 1200, 5, 43, 0, 0, 1200, 1202, 1, 0, 0, 0, 1201, 1184, 1, 0, 0, 0, 1201, 1185, 1, 0, 0, 0, 1201, 1186, 1, 0, 0, 0, 1201, 1190, 1, 0, 0, 0, 1201, 1196, 1, 0, 0, 0, 1202, 129, 1, 0, 0, 0, 1203, 1296, 1, 0, 0, 0, 1204, 1205, 5, 203, 0, 0, 1205, 1206, 5, 30, 0, 0, 1206, 1207, 3, 6, 3, 0, 1207, 1208, 5, 28, 0, 0, 1208, 1209, 3, 6, 3, 0, 1209, 1210, 5, 28, 0, 0, 1210, 1211, 3, 6, 3, 0, 1211, 1212, 5, 28, 0, 0, 1212, 1213, 3, 6, 3, 0, 1213, 1214, 5, 31, 0, 0, 1214, 1296, 1, 0, 0, 0, 1215, 1216, 5, 203, 0, 0, 1216, 1217, 5, 30, 0, 0, 1217, 1218, 3, 6, 3, 0, 1218, 1219, 5, 28, 0, 0, 1219, 1220, 3, 6, 3, 0, 1220, 1221, 5, 31, 0, 0, 1221, 1296, 1, 0, 0, 0, 1222, 1223, 5, 204, 0, 0, 1223, 1224, 5, 205, 0, 0, 1224, 1225, 5, 42, 0, 0, 1225, 1226, 3, 32, 16, 0, 1226, 1227, 5, 43, 0, 0, 1227, 1296, 1, 0, 0, 0, 1228, 1229, 5, 204, 0, 0, 1229, 1230, 5, 206, 0, 0, 1230, 1231, 5, 42, 0, 0, 1231, 1232, 3, 32, 16, 0, 1232, 1233, 5, 43, 0, 0, 1233, 1234, 3, 126, 63, 0, 1234, 1296, 1, 0, 0, 0, 1235, 1296, 5, 207, 0, 0, 1236, 1296, 5, 208, 0, 0, 1237, 1296, 5, 209, 0, 0, 1238, 1296, 5, 201, 0, 0, 1239, 1296, 5, 183, 0, 0, 1240, 1296, 5, 184, 0, 0, 1241, 1296, 5, 185, 0, 0, 1242, 1296, 5, 186, 0, 0, 1243, 1296, 5, 187, 0, 0, 1244, 1296, 5, 188, 0, 0, 1245, 1296, 5, 189, 0, 0, 1246, 1296, 5, 210, 0, 0, 1247, 1296, 5, 190, 0, 0, 1248, 1296, 5, 191, 0, 0, 1249, 1296, 5, 192, 0, 0, 1250, 1296, 5, 193, 0, 0, 1251, 1296, 5, 211, 0, 0, 1252, 1296, 5, 212, 0, 0, 1253, 1296, 5, 213, 0, 0, 1254, 1296, 5, 214, 0, 0, 1255, 1296, 5, 215, 0, 0, 1256, 1296, 5, 216, 0, 0, 1257, 1296, 5, 217, 0, 0, 1258, 1259, 5, 218, 0, 0, 1259, 1296, 3, 132, 66, 0, 1260, 1261, 5, 219, 0, 0, 1261, 1296, 3, 132, 66, 0, 1262, 1296, 5, 220, 0, 0, 1263, 1264, 5, 221, 0, 0, 1264, 1296, 3, 132, 66, 0, 1265, 1266, 5, 222, 0, 0, 1266, 1296, 3, 134, 67, 0, 1267, 1268, 5, 222, 0, 0, 1268, 1269, 3, 134, 67, 0, 1269, 1270, 5, 28, 0, 0, 1270, 1271, 3, 6, 3, 0, 1271, 1296, 1, 0, 0, 0, 1272, 1296, 5, 194, 0, 0, 1273, 1296, 5, 195, 0, 0, 1274, 1275, 5, 90, 0, 0, 1275, 1296, 5, 184, 0, 0, 1276, 1277, 5, 90, 0, 0, 1277, 1296, 5, 185, 0, 0, 1278, 1279, 5, 90, 0, 0, 1279, 1296, 5, 186, 0, 0, 1280, 1281, 5, 90, 0, 0, 1281, 1296, 5, 187, 0, 0, 1282, 1283, 5, 62, 0, 0, 1283, 1296, 5, 220, 0, 0, 1284, 1296, 5, 223, 0, 0, 1285, 1286, 5, 224, 0, 0, 1286, 1296, 5, 213, 0, 0, 1287, 1296, 5, 225, 0, 0, 1288, 1289, 5, 207, 0, 0, 1289, 1296, 5, 183, 0, 0, 1290, 1296, 5, 226, 0, 0, 1291, 1296, 5, 228, 0, 0, 1292, 1293, 5, 34, 0, 0, 1293, 1296, 5, 227, 0, 0, 1294, 1296, 3, 2, 1, 0, 1295, 1203, 1, 0, 0, 0, 1295, 1204, 1, 0, 0, 0, 1295, 1215, 1, 0, 0, 0, 1295, 1222, 1, 0, 0, 0, 1295, 1228, 1, 0, 0, 0, 1295, 1235, 1, 0, 0, 0, 1295, 1236, 1, 0, 0, 0, 1295, 1237, 1, 0, 0, 0, 1295, 1238, 1, 0, 0, 0, 1295, 1239, 1, 0, 0, 0, 1295, 1240, 1, 0, 0, 0, 1295, 1241, 1, 0, 0, 0, 1295, 1242, 1, 0, 0, 0, 1295, 1243, 1, 0, 0, 0, 1295, 1244, 1, 0, 0, 0, 1295, 1245, 1, 0, 0, 0, 1295, 1246, 1, 0, 0, 0, 1295, 1247, 1, 0, 0, 0, 1295, 1248, 1, 0, 0, 0, 1295, 1249, 1, 0, 0, 0, 1295, 1250, 1, 0, 0, 0, 1295, 1251, 1, 0, 0, 0, 1295, 1252, 1, 0, 0, 0, 1295, 1253, 1, 0, 0, 0, 1295, 1254, 1, 0, 0, 0, 1295, 1255, 1, 0, 0, 0, 1295, 1256, 1, 0, 0, 0, 1295, 1257, 1, 0, 0, 0, 1295, 1258, 1, 0, 0, 0, 1295, 1260, 1, 0, 0, 0, 1295, 1262, 1, 0, 0, 0, 1295, 1263, 1, 0, 0, 0, 1295, 1265, 1, 0, 0, 0, 1295, 1267, 1, 0, 0, 0, 1295, 1272, 1, 0, 0, 0, 1295, 1273, 1, 0, 0, 0, 1295, 1274, 1, 0, 0, 0, 1295, 1276, 1, 0, 0, 0, 1295, 1278, 1, 0, 0, 0, 1295, 1280, 1, 0, 0, 0, 1295, 1282, 1, 0, 0, 0, 1295, 1284, 1, 0, 0, 0, 1295, 1285, 1, 0, 0, 0, 1295, 1287, 1, 0, 0, 0, 1295, 1288, 1, 0, 0, 0, 1295, 1290, 1, 0, 0, 0, 1295, 1291, 1, 0, 0, 0, 1295, 1292, 1, 0, 0, 0, 1295, 1294, 1, 0, 0, 0, 1296, 131, 1, 0, 0, 0, 1297, 1305, 1, 0, 0, 0, 1298, 1299, 5, 30, 0, 0, 1299, 1300, 5, 91, 0, 0, 1300, 1301, 5, 36, 0, 0, 1301, 1302, 3, 32, 16, 0, 1302, 1303, 5, 31, 0, 0, 1303, 1305, 1, 0, 0, 0, 1304, 1297, 1, 0, 0, 0, 1304, 1298, 1, 0, 0, 0, 1305, 133, 1, 0, 0, 0, 1306, 1315, 1, 0, 0, 0, 1307, 1311, 3, 136, 68, 0, 1308, 1310, 7, 7, 0, 0, 1309, 1308, 1, 0, 0, 0, 1310, 1313, 1, 0, 0, 0, 1311, 1309, 1, 0, 0, 0, 1311, 1312, 1, 0, 0, 0, 1312, 1315, 1, 0, 0, 0, 1313, 1311, 1, 0, 0, 0, 1314, 1306, 1, 0, 0, 0, 1314, 1307, 1, 0, 0, 0, 1315, 135, 1, 0, 0, 0, 1316, 1317, 7, 8, 0, 0, 1317, 137, 1, 0, 0, 0, 1318, 1322, 3, 142, 71, 0, 1319, 1321, 3, 140, 70, 0, 1320, 1319, 1, 0, 0, 0, 1321, 1324, 1, 0, 0, 0, 1322, 1320, 1, 0, 0, 0, 1322, 1323, 1, 0, 0, 0, 1323, 139, 1, 0, 0, 0, 1324, 1322, 1, 0, 0, 0, 1325, 1344, 5, 261, 0, 0, 1326, 1327, 5, 42, 0, 0, 1327, 1344, 5, 43, 0, 0, 1328, 1344, 3, 110, 55, 0, 1329, 1344, 5, 260, 0, 0, 1330, 1344, 5, 262, 0, 0, 1331, 1344, 5, 92, 0, 0, 1332, 1333, 5, 93, 0, 0, 1333, 1334, 5, 30, 0, 0, 1334, 1335, 3, 124, 62, 0, 1335, 1336, 5, 31, 0, 0, 1336, 1344, 1, 0, 0, 0, 1337, 1338, 5, 94, 0, 0, 1338, 1339, 5, 30, 0, 0, 1339, 1340, 3, 124, 62, 0, 1340, 1341, 5, 31, 0, 0, 1341, 1344, 1, 0, 0, 0, 1342, 1344, 3, 108, 54, 0, 1343, 1325, 1, 0, 0, 0, 1343, 1326, 1, 0, 0, 0, 1343, 1328, 1, 0, 0, 0, 1343, 1329, 1, 0, 0, 0, 1343, 1330, 1, 0, 0, 0, 1343, 1331, 1, 0, 0, 0, 1343, 1332, 1, 0, 0, 0, 1343, 1337, 1, 0, 0, 0, 1343, 1342, 1, 0, 0, 0, 1344, 141, 1, 0, 0, 0, 1345, 1346, 5, 39, 0, 0, 1346, 1376, 3, 116, 58, 0, 1347, 1376, 5, 197, 0, 0, 1348, 1349, 5, 199, 0, 0, 1349, 1350, 5, 39, 0, 0, 1350, 1376, 3, 116, 58, 0, 1351, 1352, 5, 200, 0, 0, 1352, 1376, 3, 116, 58, 0, 1353, 1354, 5, 226, 0, 0, 1354, 1355, 3, 170, 85, 0, 1355, 1356, 3, 138, 69, 0, 1356, 1357, 5, 262, 0, 0, 1357, 1358, 3, 112, 56, 0, 1358, 1376, 1, 0, 0, 0, 1359, 1360, 5, 253, 0, 0, 1360, 1376, 3, 32, 16, 0, 1361, 1362, 5, 252, 0, 0, 1362, 1376, 3, 32, 16, 0, 1363, 1364, 5, 253, 0, 0, 1364, 1376, 3, 2, 1, 0, 1365, 1366, 5, 252, 0, 0, 1366, 1376, 3, 2, 1, 0, 1367, 1376, 5, 254, 0, 0, 1368, 1376, 5, 201, 0, 0, 1369, 1376, 3, 148, 74, 0, 1370, 1376, 3, 150, 75, 0, 1371, 1376, 3, 144, 72, 0, 1372, 1376, 3, 2, 1, 0, 1373, 1374, 5, 177, 0, 0, 1374, 1376, 3, 138, 69, 0, 1375, 1345, 1, 0, 0, 0, 1375, 1347, 1, 0, 0, 0, 1375, 1348, 1, 0, 0, 0, 1375, 1351, 1, 0, 0, 0, 1375, 1353, 1, 0, 0, 0, 1375, 1359, 1, 0, 0, 0, 1375, 1361, 1, 0, 0, 0, 1375, 1363, 1, 0, 0, 0, 1375, 1365, 1, 0, 0, 0, 1375, 1367, 1, 0, 0, 0, 1375, 1368, 1, 0, 0, 0, 1375, 1369, 1, 0, 0, 0, 1375, 1370, 1, 0, 0, 0, 1375, 1371, 1, 0, 0, 0, 1375, 1372, 1, 0, 0, 0, 1375, 1373, 1, 0, 0, 0, 1376, 143, 1, 0, 0, 0, 1377, 1399, 5, 181, 0, 0, 1378, 1399, 5, 182, 0, 0, 1379, 1399, 5, 183, 0, 0, 1380, 1399, 5, 184, 0, 0, 1381, 1399, 5, 185, 0, 0, 1382, 1399, 5, 186, 0, 0, 1383, 1399, 5, 187, 0, 0, 1384, 1399, 5, 188, 0, 0, 1385, 1399, 5, 189, 0, 0, 1386, 1399, 5, 190, 0, 0, 1387, 1399, 5, 191, 0, 0, 1388, 1399, 5, 192, 0, 0, 1389, 1399, 5, 193, 0, 0, 1390, 1391, 5, 90, 0, 0, 1391, 1399, 5, 184, 0, 0, 1392, 1393, 5, 90, 0, 0, 1393, 1399, 5, 185, 0, 0, 1394, 1395, 5, 90, 0, 0, 1395, 1399, 5, 186, 0, 0, 1396, 1397, 5, 90, 0, 0, 1397, 1399, 5, 187, 0, 0, 1398, 1377, 1, 0, 0, 0, 1398, 1378, 1, 0, 0, 0, 1398, 1379, 1, 0, 0, 0, 1398, 1380, 1, 0, 0, 0, 1398, 1381, 1, 0, 0, 0, 1398, 1382, 1, 0, 0, 0, 1398, 1383, 1, 0, 0, 0, 1398, 1384, 1, 0, 0, 0, 1398, 1385, 1, 0, 0, 0, 1398, 1386, 1, 0, 0, 0, 1398, 1387, 1, 0, 0, 0, 1398, 1388, 1, 0, 0, 0, 1398, 1389, 1, 0, 0, 0, 1398, 1390, 1, 0, 0, 0, 1398, 1392, 1, 0, 0, 0, 1398, 1394, 1, 0, 0, 0, 1398, 1396, 1, 0, 0, 0, 1399, 145, 1, 0, 0, 0, 1400, 1411, 1, 0, 0, 0, 1401, 1411, 5, 177, 0, 0, 1402, 1411, 3, 32, 16, 0, 1403, 1404, 3, 32, 16, 0, 1404, 1405, 5, 177, 0, 0, 1405, 1406, 3, 32, 16, 0, 1406, 1411, 1, 0, 0, 0, 1407, 1408, 3, 32, 16, 0, 1408, 1409, 5, 177, 0, 0, 1409, 1411, 1, 0, 0, 0, 1410, 1400, 1, 0, 0, 0, 1410, 1401, 1, 0, 0, 0, 1410, 1402, 1, 0, 0, 0, 1410, 1403, 1, 0, 0, 0, 1410, 1407, 1, 0, 0, 0, 1411, 147, 1, 0, 0, 0, 1412, 1413, 5, 1, 0, 0, 1413, 1414, 5, 194, 0, 0, 1414, 149, 1, 0, 0, 0, 1415, 1419, 5, 1, 0, 0, 1416, 1417, 5, 90, 0, 0, 1417, 1420, 5, 194, 0, 0, 1418, 1420, 5, 195, 0, 0, 1419, 1416, 1, 0, 0, 0, 1419, 1418, 1, 0, 0, 0, 1420, 151, 1, 0, 0, 0, 1421, 1422, 5, 294, 0, 0, 1422, 1423, 3, 166, 83, 0, 1423, 1424, 3, 124, 62, 0, 1424, 1425, 5, 30, 0, 0, 1425, 1426, 3, 158, 79, 0, 1426, 1427, 5, 31, 0, 0, 1427, 1469, 1, 0, 0, 0, 1428, 1429, 5, 294, 0, 0, 1429, 1430, 3, 166, 83, 0, 1430, 1431, 3, 124, 62, 0, 1431, 1432, 5, 36, 0, 0, 1432, 1433, 5, 17, 0, 0, 1433, 1434, 3, 52, 26, 0, 1434, 1435, 5, 18, 0, 0, 1435, 1469, 1, 0, 0, 0, 1436, 1437, 5, 294, 0, 0, 1437, 1438, 3, 166, 83, 0, 1438, 1439, 3, 124, 62, 0, 1439, 1469, 1, 0, 0, 0, 1440, 1441, 5, 295, 0, 0, 1441, 1442, 3, 166, 83, 0, 1442, 1444, 5, 36, 0, 0, 1443, 1445, 5, 84, 0, 0, 1444, 1443, 1, 0, 0, 0, 1444, 1445, 1, 0, 0, 0, 1445, 1446, 1, 0, 0, 0, 1446, 1447, 5, 30, 0, 0, 1447, 1448, 3, 292, 146, 0, 1448, 1449, 5, 31, 0, 0, 1449, 1469, 1, 0, 0, 0, 1450, 1451, 5, 295, 0, 0, 1451, 1452, 3, 166, 83, 0, 1452, 1453, 5, 84, 0, 0, 1453, 1454, 5, 30, 0, 0, 1454, 1455, 3, 292, 146, 0, 1455, 1456, 5, 31, 0, 0, 1456, 1469, 1, 0, 0, 0, 1457, 1458, 5, 295, 0, 0, 1458, 1459, 3, 166, 83, 0, 1459, 1460, 3, 6, 3, 0, 1460, 1469, 1, 0, 0, 0, 1461, 1462, 5, 295, 0, 0, 1462, 1463, 3, 166, 83, 0, 1463, 1464, 5, 36, 0, 0, 1464, 1465, 5, 17, 0, 0, 1465, 1466, 3, 154, 77, 0, 1466, 1467, 5, 18, 0, 0, 1467, 1469, 1, 0, 0, 0, 1468, 1421, 1, 0, 0, 0, 1468, 1428, 1, 0, 0, 0, 1468, 1436, 1, 0, 0, 0, 1468, 1440, 1, 0, 0, 0, 1468, 1450, 1, 0, 0, 0, 1468, 1457, 1, 0, 0, 0, 1468, 1461, 1, 0, 0, 0, 1469, 153, 1, 0, 0, 0, 1470, 1481, 1, 0, 0, 0, 1471, 1472, 3, 156, 78, 0, 1472, 1473, 5, 28, 0, 0, 1473, 1475, 1, 0, 0, 0, 1474, 1471, 1, 0, 0, 0, 1475, 1478, 1, 0, 0, 0, 1476, 1474, 1, 0, 0, 0, 1476, 1477, 1, 0, 0, 0, 1477, 1479, 1, 0, 0, 0, 1478, 1476, 1, 0, 0, 0, 1479, 1481, 3, 156, 78, 0, 1480, 1470, 1, 0, 0, 0, 1480, 1476, 1, 0, 0, 0, 1481, 155, 1, 0, 0, 0, 1482, 1483, 5, 39, 0, 0, 1483, 1484, 5, 264, 0, 0, 1484, 1485, 5, 36, 0, 0, 1485, 1486, 5, 17, 0, 0, 1486, 1487, 3, 56, 28, 0, 1487, 1488, 5, 18, 0, 0, 1488, 1496, 1, 0, 0, 0, 1489, 1490, 3, 124, 62, 0, 1490, 1491, 5, 36, 0, 0, 1491, 1492, 5, 17, 0, 0, 1492, 1493, 3, 56, 28, 0, 1493, 1494, 5, 18, 0, 0, 1494, 1496, 1, 0, 0, 0, 1495, 1482, 1, 0, 0, 0, 1495, 1489, 1, 0, 0, 0, 1496, 157, 1, 0, 0, 0, 1497, 1498, 3, 160, 80, 0, 1498, 1499, 5, 28, 0, 0, 1499, 1501, 1, 0, 0, 0, 1500, 1497, 1, 0, 0, 0, 1501, 1504, 1, 0, 0, 0, 1502, 1500, 1, 0, 0, 0, 1502, 1503, 1, 0, 0, 0, 1503, 1505, 1, 0, 0, 0, 1504, 1502, 1, 0, 0, 0, 1505, 1506, 3, 160, 80, 0, 1506, 159, 1, 0, 0, 0, 1507, 1508, 3, 6, 3, 0, 1508, 1509, 5, 36, 0, 0, 1509, 1510, 3, 164, 82, 0, 1510, 161, 1, 0, 0, 0, 1511, 1512, 7, 9, 0, 0, 1512, 163, 1, 0, 0, 0, 1513, 1548, 3, 162, 81, 0, 1514, 1548, 3, 32, 16, 0, 1515, 1516, 5, 186, 0, 0, 1516, 1517, 5, 30, 0, 0, 1517, 1518, 3, 32, 16, 0, 1518, 1519, 5, 31, 0, 0, 1519, 1548, 1, 0, 0, 0, 1520, 1548, 3, 6, 3, 0, 1521, 1522, 3, 116, 58, 0, 1522, 1523, 5, 30, 0, 0, 1523, 1524, 5, 184, 0, 0, 1524, 1525, 5, 75, 0, 0, 1525, 1526, 3, 32, 16, 0, 1526, 1527, 5, 31, 0, 0, 1527, 1548, 1, 0, 0, 0, 1528, 1529, 3, 116, 58, 0, 1529, 1530, 5, 30, 0, 0, 1530, 1531, 5, 185, 0, 0, 1531, 1532, 5, 75, 0, 0, 1532, 1533, 3, 32, 16, 0, 1533, 1534, 5, 31, 0, 0, 1534, 1548, 1, 0, 0, 0, 1535, 1536, 3, 116, 58, 0, 1536, 1537, 5, 30, 0, 0, 1537, 1538, 5, 186, 0, 0, 1538, 1539, 5, 75, 0, 0, 1539, 1540, 3, 32, 16, 0, 1540, 1541, 5, 31, 0, 0, 1541, 1548, 1, 0, 0, 0, 1542, 1543, 3, 116, 58, 0, 1543, 1544, 5, 30, 0, 0, 1544, 1545, 3, 32, 16, 0, 1545, 1546, 5, 31, 0, 0, 1546, 1548, 1, 0, 0, 0, 1547, 1513, 1, 0, 0, 0, 1547, 1514, 1, 0, 0, 0, 1547, 1515, 1, 0, 0, 0, 1547, 1520, 1, 0, 0, 0, 1547, 1521, 1, 0, 0, 0, 1547, 1528, 1, 0, 0, 0, 1547, 1535, 1, 0, 0, 0, 1547, 1542, 1, 0, 0, 0, 1548, 165, 1, 0, 0, 0, 1549, 1550, 7, 10, 0, 0, 1550, 167, 1, 0, 0, 0, 1551, 1552, 3, 170, 85, 0, 1552, 1553, 3, 138, 69, 0, 1553, 1554, 3, 124, 62, 0, 1554, 1555, 5, 176, 0, 0, 1555, 1557, 3, 242, 121, 0, 1556, 1558, 3, 108, 54, 0, 1557, 1556, 1, 0, 0, 0, 1557, 1558, 1, 0, 0, 0, 1558, 1559, 1, 0, 0, 0, 1559, 1560, 3, 112, 56, 0, 1560, 1586, 1, 0, 0, 0, 1561, 1562, 3, 170, 85, 0, 1562, 1563, 3, 138, 69, 0, 1563, 1564, 3, 124, 62, 0, 1564, 1565, 5, 176, 0, 0, 1565, 1566, 3, 242, 121, 0, 1566, 1567, 3, 196, 98, 0, 1567, 1568, 3, 112, 56, 0, 1568, 1586, 1, 0, 0, 0, 1569, 1570, 3, 170, 85, 0, 1570, 1571, 3, 138, 69, 0, 1571, 1573, 3, 242, 121, 0, 1572, 1574, 3, 108, 54, 0, 1573, 1572, 1, 0, 0, 0, 1573, 1574, 1, 0, 0, 0, 1574, 1575, 1, 0, 0, 0, 1575, 1576, 3, 112, 56, 0, 1576, 1586, 1, 0, 0, 0, 1577, 1578, 3, 170, 85, 0, 1578, 1579, 3, 138, 69, 0, 1579, 1580, 3, 242, 121, 0, 1580, 1581, 3, 196, 98, 0, 1581, 1582, 3, 112, 56, 0, 1582, 1586, 1, 0, 0, 0, 1583, 1586, 3, 174, 87, 0, 1584, 1586, 3, 2, 1, 0, 1585, 1551, 1, 0, 0, 0, 1585, 1561, 1, 0, 0, 0, 1585, 1569, 1, 0, 0, 0, 1585, 1577, 1, 0, 0, 0, 1585, 1583, 1, 0, 0, 0, 1585, 1584, 1, 0, 0, 0, 1586, 169, 1, 0, 0, 0, 1587, 1588, 5, 243, 0, 0, 1588, 1598, 3, 170, 85, 0, 1589, 1590, 5, 244, 0, 0, 1590, 1598, 3, 170, 85, 0, 1591, 1598, 3, 172, 86, 0, 1592, 1593, 5, 112, 0, 0, 1593, 1594, 5, 30, 0, 0, 1594, 1595, 3, 32, 16, 0, 1595, 1596, 5, 31, 0, 0, 1596, 1598, 1, 0, 0, 0, 1597, 1587, 1, 0, 0, 0, 1597, 1589, 1, 0, 0, 0, 1597, 1591, 1, 0, 0, 0, 1597, 1592, 1, 0, 0, 0, 1598, 171, 1, 0, 0, 0, 1599, 1612, 1, 0, 0, 0, 1600, 1612, 5, 245, 0, 0, 1601, 1612, 5, 246, 0, 0, 1602, 1603, 5, 247, 0, 0, 1603, 1612, 5, 248, 0, 0, 1604, 1605, 5, 247, 0, 0, 1605, 1612, 5, 249, 0, 0, 1606, 1607, 5, 247, 0, 0, 1607, 1612, 5, 250, 0, 0, 1608, 1609, 5, 247, 0, 0, 1609, 1612, 5, 251, 0, 0, 1610, 1612, 5, 247, 0, 0, 1611, 1599, 1, 0, 0, 0, 1611, 1600, 1, 0, 0, 0, 1611, 1601, 1, 0, 0, 0, 1611, 1602, 1, 0, 0, 0, 1611, 1604, 1, 0, 0, 0, 1611, 1606, 1, 0, 0, 0, 1611, 1608, 1, 0, 0, 0, 1611, 1610, 1, 0, 0, 0, 1612, 173, 1, 0, 0, 0, 1613, 1614, 5, 113, 0, 0, 1614, 1615, 5, 30, 0, 0, 1615, 1616, 3, 32, 16, 0, 1616, 1617, 5, 31, 0, 0, 1617, 175, 1, 0, 0, 0, 1618, 1619, 5, 226, 0, 0, 1619, 1624, 3, 168, 84, 0, 1620, 1621, 5, 37, 0, 0, 1621, 1624, 3, 178, 89, 0, 1622, 1624, 3, 174, 87, 0, 1623, 1618, 1, 0, 0, 0, 1623, 1620, 1, 0, 0, 0, 1623, 1622, 1, 0, 0, 0, 1624, 177, 1, 0, 0, 0, 1625, 1626, 3, 138, 69, 0, 1626, 1627, 3, 124, 62, 0, 1627, 1628, 5, 176, 0, 0, 1628, 1629, 3, 2, 1, 0, 1629, 1635, 1, 0, 0, 0, 1630, 1631, 3, 138, 69, 0, 1631, 1632, 3, 2, 1, 0, 1632, 1635, 1, 0, 0, 0, 1633, 1635, 3, 2, 1, 0, 1634, 1625, 1, 0, 0, 0, 1634, 1630, 1, 0, 0, 0, 1634, 1633, 1, 0, 0, 0, 1635, 179, 1, 0, 0, 0, 1636, 1637, 3, 124, 62, 0, 1637, 1638, 5, 28, 0, 0, 1638, 1640, 1, 0, 0, 0, 1639, 1636, 1, 0, 0, 0, 1640, 1643, 1, 0, 0, 0, 1641, 1639, 1, 0, 0, 0, 1641, 1642, 1, 0, 0, 0, 1642, 1644, 1, 0, 0, 0, 1643, 1641, 1, 0, 0, 0, 1644, 1645, 3, 124, 62, 0, 1645, 181, 1, 0, 0, 0, 1646, 1652, 1, 0, 0, 0, 1647, 1648, 5, 86, 0, 0, 1648, 1649, 3, 190, 95, 0, 1649, 1650, 5, 87, 0, 0, 1650, 1652, 1, 0, 0, 0, 1651, 1646, 1, 0, 0, 0, 1651, 1647, 1, 0, 0, 0, 1652, 183, 1, 0, 0, 0, 1653, 1665, 5, 266, 0, 0, 1654, 1665, 5, 114, 0, 0, 1655, 1665, 5, 39, 0, 0, 1656, 1665, 5, 200, 0, 0, 1657, 1665, 5, 115, 0, 0, 1658, 1665, 5, 116, 0, 0, 1659, 1660, 5, 70, 0, 0, 1660, 1661, 5, 30, 0, 0, 1661, 1662, 3, 32, 16, 0, 1662, 1663, 5, 31, 0, 0, 1663, 1665, 1, 0, 0, 0, 1664, 1653, 1, 0, 0, 0, 1664, 1654, 1, 0, 0, 0, 1664, 1655, 1, 0, 0, 0, 1664, 1656, 1, 0, 0, 0, 1664, 1657, 1, 0, 0, 0, 1664, 1658, 1, 0, 0, 0, 1664, 1659, 1, 0, 0, 0, 1665, 185, 1, 0, 0, 0, 1666, 1668, 3, 184, 92, 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, 187, 1, 0, 0, 0, 1671, 1669, 1, 0, 0, 0, 1672, 1674, 3, 186, 93, 0, 1673, 1675, 3, 192, 96, 0, 1674, 1673, 1, 0, 0, 0, 1674, 1675, 1, 0, 0, 0, 1675, 1676, 1, 0, 0, 0, 1676, 1677, 3, 2, 1, 0, 1677, 189, 1, 0, 0, 0, 1678, 1679, 3, 188, 94, 0, 1679, 1680, 5, 28, 0, 0, 1680, 1682, 1, 0, 0, 0, 1681, 1678, 1, 0, 0, 0, 1682, 1685, 1, 0, 0, 0, 1683, 1681, 1, 0, 0, 0, 1683, 1684, 1, 0, 0, 0, 1684, 1686, 1, 0, 0, 0, 1685, 1683, 1, 0, 0, 0, 1686, 1687, 3, 188, 94, 0, 1687, 191, 1, 0, 0, 0, 1688, 1689, 5, 30, 0, 0, 1689, 1690, 3, 180, 90, 0, 1690, 1691, 5, 31, 0, 0, 1691, 193, 1, 0, 0, 0, 1692, 1695, 1, 0, 0, 0, 1693, 1695, 3, 196, 98, 0, 1694, 1692, 1, 0, 0, 0, 1694, 1693, 1, 0, 0, 0, 1695, 195, 1, 0, 0, 0, 1696, 1697, 5, 86, 0, 0, 1697, 1698, 5, 42, 0, 0, 1698, 1699, 3, 32, 16, 0, 1699, 1700, 5, 43, 0, 0, 1700, 1701, 5, 87, 0, 0, 1701, 197, 1, 0, 0, 0, 1702, 1703, 3, 234, 117, 0, 1703, 1704, 5, 17, 0, 0, 1704, 1705, 3, 246, 123, 0, 1705, 1706, 5, 18, 0, 0, 1706, 1819, 1, 0, 0, 0, 1707, 1708, 3, 74, 37, 0, 1708, 1709, 5, 17, 0, 0, 1709, 1710, 3, 82, 41, 0, 1710, 1711, 5, 18, 0, 0, 1711, 1819, 1, 0, 0, 0, 1712, 1713, 3, 210, 105, 0, 1713, 1714, 5, 17, 0, 0, 1714, 1715, 3, 214, 107, 0, 1715, 1716, 5, 18, 0, 0, 1716, 1819, 1, 0, 0, 0, 1717, 1718, 3, 218, 109, 0, 1718, 1719, 5, 17, 0, 0, 1719, 1720, 3, 222, 111, 0, 1720, 1721, 5, 18, 0, 0, 1721, 1819, 1, 0, 0, 0, 1722, 1819, 3, 200, 100, 0, 1723, 1819, 3, 276, 138, 0, 1724, 1819, 3, 152, 76, 0, 1725, 1819, 3, 88, 44, 0, 1726, 1819, 3, 322, 161, 0, 1727, 1728, 5, 117, 0, 0, 1728, 1819, 3, 32, 16, 0, 1729, 1730, 5, 118, 0, 0, 1730, 1819, 3, 32, 16, 0, 1731, 1732, 3, 334, 167, 0, 1732, 1733, 5, 17, 0, 0, 1733, 1734, 3, 338, 169, 0, 1734, 1735, 5, 18, 0, 0, 1735, 1819, 1, 0, 0, 0, 1736, 1737, 5, 302, 0, 0, 1737, 1738, 3, 124, 62, 0, 1738, 1739, 5, 176, 0, 0, 1739, 1740, 3, 242, 121, 0, 1740, 1741, 5, 119, 0, 0, 1741, 1742, 3, 170, 85, 0, 1742, 1743, 3, 138, 69, 0, 1743, 1744, 3, 124, 62, 0, 1744, 1745, 5, 176, 0, 0, 1745, 1746, 3, 242, 121, 0, 1746, 1747, 3, 112, 56, 0, 1747, 1819, 1, 0, 0, 0, 1748, 1749, 5, 302, 0, 0, 1749, 1750, 5, 226, 0, 0, 1750, 1751, 3, 170, 85, 0, 1751, 1752, 3, 138, 69, 0, 1752, 1753, 3, 124, 62, 0, 1753, 1754, 5, 176, 0, 0, 1754, 1755, 3, 242, 121, 0, 1755, 1756, 3, 194, 97, 0, 1756, 1757, 3, 112, 56, 0, 1757, 1758, 5, 119, 0, 0, 1758, 1759, 5, 226, 0, 0, 1759, 1760, 3, 170, 85, 0, 1760, 1761, 3, 138, 69, 0, 1761, 1762, 3, 124, 62, 0, 1762, 1763, 5, 176, 0, 0, 1763, 1764, 3, 242, 121, 0, 1764, 1765, 3, 194, 97, 0, 1765, 1766, 3, 112, 56, 0, 1766, 1819, 1, 0, 0, 0, 1767, 1819, 3, 26, 13, 0, 1768, 1819, 3, 40, 20, 0, 1769, 1770, 5, 255, 0, 0, 1770, 1771, 5, 196, 0, 0, 1771, 1772, 5, 42, 0, 0, 1772, 1773, 3, 32, 16, 0, 1773, 1777, 5, 43, 0, 0, 1774, 1776, 3, 322, 161, 0, 1775, 1774, 1, 0, 0, 0, 1776, 1779, 1, 0, 0, 0, 1777, 1775, 1, 0, 0, 0, 1777, 1778, 1, 0, 0, 0, 1778, 1819, 1, 0, 0, 0, 1779, 1777, 1, 0, 0, 0, 1780, 1781, 5, 255, 0, 0, 1781, 1782, 5, 196, 0, 0, 1782, 1786, 3, 2, 1, 0, 1783, 1785, 3, 322, 161, 0, 1784, 1783, 1, 0, 0, 0, 1785, 1788, 1, 0, 0, 0, 1786, 1784, 1, 0, 0, 0, 1786, 1787, 1, 0, 0, 0, 1787, 1819, 1, 0, 0, 0, 1788, 1786, 1, 0, 0, 0, 1789, 1790, 5, 255, 0, 0, 1790, 1791, 5, 256, 0, 0, 1791, 1792, 5, 42, 0, 0, 1792, 1793, 3, 32, 16, 0, 1793, 1794, 5, 43, 0, 0, 1794, 1795, 5, 28, 0, 0, 1795, 1799, 3, 124, 62, 0, 1796, 1798, 3, 322, 161, 0, 1797, 1796, 1, 0, 0, 0, 1798, 1801, 1, 0, 0, 0, 1799, 1797, 1, 0, 0, 0, 1799, 1800, 1, 0, 0, 0, 1800, 1819, 1, 0, 0, 0, 1801, 1799, 1, 0, 0, 0, 1802, 1803, 5, 255, 0, 0, 1803, 1804, 5, 256, 0, 0, 1804, 1805, 3, 2, 1, 0, 1805, 1806, 5, 28, 0, 0, 1806, 1810, 3, 124, 62, 0, 1807, 1809, 3, 322, 161, 0, 1808, 1807, 1, 0, 0, 0, 1809, 1812, 1, 0, 0, 0, 1810, 1808, 1, 0, 0, 0, 1810, 1811, 1, 0, 0, 0, 1811, 1819, 1, 0, 0, 0, 1812, 1810, 1, 0, 0, 0, 1813, 1814, 5, 120, 0, 0, 1814, 1815, 5, 196, 0, 0, 1815, 1816, 3, 124, 62, 0, 1816, 1817, 3, 44, 22, 0, 1817, 1819, 1, 0, 0, 0, 1818, 1702, 1, 0, 0, 0, 1818, 1707, 1, 0, 0, 0, 1818, 1712, 1, 0, 0, 0, 1818, 1717, 1, 0, 0, 0, 1818, 1722, 1, 0, 0, 0, 1818, 1723, 1, 0, 0, 0, 1818, 1724, 1, 0, 0, 0, 1818, 1725, 1, 0, 0, 0, 1818, 1726, 1, 0, 0, 0, 1818, 1727, 1, 0, 0, 0, 1818, 1729, 1, 0, 0, 0, 1818, 1731, 1, 0, 0, 0, 1818, 1736, 1, 0, 0, 0, 1818, 1748, 1, 0, 0, 0, 1818, 1767, 1, 0, 0, 0, 1818, 1768, 1, 0, 0, 0, 1818, 1769, 1, 0, 0, 0, 1818, 1780, 1, 0, 0, 0, 1818, 1789, 1, 0, 0, 0, 1818, 1802, 1, 0, 0, 0, 1818, 1813, 1, 0, 0, 0, 1819, 199, 1, 0, 0, 0, 1820, 1821, 5, 121, 0, 0, 1821, 1830, 3, 208, 104, 0, 1822, 1829, 3, 202, 101, 0, 1823, 1824, 5, 122, 0, 0, 1824, 1825, 5, 30, 0, 0, 1825, 1826, 3, 228, 114, 0, 1826, 1827, 5, 31, 0, 0, 1827, 1829, 1, 0, 0, 0, 1828, 1822, 1, 0, 0, 0, 1828, 1823, 1, 0, 0, 0, 1829, 1832, 1, 0, 0, 0, 1830, 1828, 1, 0, 0, 0, 1830, 1831, 1, 0, 0, 0, 1831, 1833, 1, 0, 0, 0, 1832, 1830, 1, 0, 0, 0, 1833, 1834, 3, 138, 69, 0, 1834, 1835, 3, 2, 1, 0, 1835, 1836, 3, 204, 102, 0, 1836, 1837, 3, 206, 103, 0, 1837, 201, 1, 0, 0, 0, 1838, 1858, 5, 123, 0, 0, 1839, 1858, 5, 51, 0, 0, 1840, 1858, 5, 52, 0, 0, 1841, 1858, 5, 63, 0, 0, 1842, 1858, 5, 124, 0, 0, 1843, 1858, 5, 69, 0, 0, 1844, 1858, 5, 68, 0, 0, 1845, 1858, 5, 64, 0, 0, 1846, 1858, 5, 65, 0, 0, 1847, 1858, 5, 66, 0, 0, 1848, 1858, 5, 125, 0, 0, 1849, 1858, 5, 126, 0, 0, 1850, 1858, 5, 127, 0, 0, 1851, 1858, 5, 16, 0, 0, 1852, 1853, 5, 70, 0, 0, 1853, 1854, 5, 30, 0, 0, 1854, 1855, 3, 32, 16, 0, 1855, 1856, 5, 31, 0, 0, 1856, 1858, 1, 0, 0, 0, 1857, 1838, 1, 0, 0, 0, 1857, 1839, 1, 0, 0, 0, 1857, 1840, 1, 0, 0, 0, 1857, 1841, 1, 0, 0, 0, 1857, 1842, 1, 0, 0, 0, 1857, 1843, 1, 0, 0, 0, 1857, 1844, 1, 0, 0, 0, 1857, 1845, 1, 0, 0, 0, 1857, 1846, 1, 0, 0, 0, 1857, 1847, 1, 0, 0, 0, 1857, 1848, 1, 0, 0, 0, 1857, 1849, 1, 0, 0, 0, 1857, 1850, 1, 0, 0, 0, 1857, 1851, 1, 0, 0, 0, 1857, 1852, 1, 0, 0, 0, 1858, 203, 1, 0, 0, 0, 1859, 1865, 1, 0, 0, 0, 1860, 1861, 5, 44, 0, 0, 1861, 1865, 3, 0, 0, 0, 1862, 1863, 5, 44, 0, 0, 1863, 1865, 3, 32, 16, 0, 1864, 1859, 1, 0, 0, 0, 1864, 1860, 1, 0, 0, 0, 1864, 1862, 1, 0, 0, 0, 1865, 205, 1, 0, 0, 0, 1866, 1870, 1, 0, 0, 0, 1867, 1868, 5, 36, 0, 0, 1868, 1870, 3, 296, 148, 0, 1869, 1866, 1, 0, 0, 0, 1869, 1867, 1, 0, 0, 0, 1870, 207, 1, 0, 0, 0, 1871, 1877, 1, 0, 0, 0, 1872, 1873, 5, 42, 0, 0, 1873, 1874, 3, 32, 16, 0, 1874, 1875, 5, 43, 0, 0, 1875, 1877, 1, 0, 0, 0, 1876, 1871, 1, 0, 0, 0, 1876, 1872, 1, 0, 0, 0, 1877, 209, 1, 0, 0, 0, 1878, 1882, 5, 128, 0, 0, 1879, 1881, 3, 212, 106, 0, 1880, 1879, 1, 0, 0, 0, 1881, 1884, 1, 0, 0, 0, 1882, 1880, 1, 0, 0, 0, 1882, 1883, 1, 0, 0, 0, 1883, 1885, 1, 0, 0, 0, 1884, 1882, 1, 0, 0, 0, 1885, 1886, 3, 124, 62, 0, 1886, 1887, 3, 2, 1, 0, 1887, 1897, 1, 0, 0, 0, 1888, 1892, 5, 128, 0, 0, 1889, 1891, 3, 212, 106, 0, 1890, 1889, 1, 0, 0, 0, 1891, 1894, 1, 0, 0, 0, 1892, 1890, 1, 0, 0, 0, 1892, 1893, 1, 0, 0, 0, 1893, 1895, 1, 0, 0, 0, 1894, 1892, 1, 0, 0, 0, 1895, 1897, 3, 2, 1, 0, 1896, 1878, 1, 0, 0, 0, 1896, 1888, 1, 0, 0, 0, 1897, 211, 1, 0, 0, 0, 1898, 1899, 7, 11, 0, 0, 1899, 213, 1, 0, 0, 0, 1900, 1902, 3, 216, 108, 0, 1901, 1900, 1, 0, 0, 0, 1902, 1905, 1, 0, 0, 0, 1903, 1901, 1, 0, 0, 0, 1903, 1904, 1, 0, 0, 0, 1904, 215, 1, 0, 0, 0, 1905, 1903, 1, 0, 0, 0, 1906, 1907, 5, 129, 0, 0, 1907, 1919, 3, 168, 84, 0, 1908, 1909, 5, 130, 0, 0, 1909, 1919, 3, 168, 84, 0, 1910, 1911, 5, 131, 0, 0, 1911, 1919, 3, 168, 84, 0, 1912, 1913, 5, 132, 0, 0, 1913, 1919, 3, 168, 84, 0, 1914, 1919, 3, 88, 44, 0, 1915, 1919, 3, 322, 161, 0, 1916, 1919, 3, 26, 13, 0, 1917, 1919, 3, 40, 20, 0, 1918, 1906, 1, 0, 0, 0, 1918, 1908, 1, 0, 0, 0, 1918, 1910, 1, 0, 0, 0, 1918, 1912, 1, 0, 0, 0, 1918, 1914, 1, 0, 0, 0, 1918, 1915, 1, 0, 0, 0, 1918, 1916, 1, 0, 0, 0, 1918, 1917, 1, 0, 0, 0, 1919, 217, 1, 0, 0, 0, 1920, 1924, 5, 133, 0, 0, 1921, 1923, 3, 220, 110, 0, 1922, 1921, 1, 0, 0, 0, 1923, 1926, 1, 0, 0, 0, 1924, 1922, 1, 0, 0, 0, 1924, 1925, 1, 0, 0, 0, 1925, 1927, 1, 0, 0, 0, 1926, 1924, 1, 0, 0, 0, 1927, 1928, 3, 170, 85, 0, 1928, 1929, 3, 138, 69, 0, 1929, 1930, 3, 2, 1, 0, 1930, 1931, 3, 112, 56, 0, 1931, 1932, 3, 206, 103, 0, 1932, 219, 1, 0, 0, 0, 1933, 1934, 7, 11, 0, 0, 1934, 221, 1, 0, 0, 0, 1935, 1937, 3, 224, 112, 0, 1936, 1935, 1, 0, 0, 0, 1937, 1940, 1, 0, 0, 0, 1938, 1936, 1, 0, 0, 0, 1938, 1939, 1, 0, 0, 0, 1939, 223, 1, 0, 0, 0, 1940, 1938, 1, 0, 0, 0, 1941, 1942, 5, 134, 0, 0, 1942, 1952, 3, 168, 84, 0, 1943, 1944, 5, 135, 0, 0, 1944, 1952, 3, 168, 84, 0, 1945, 1946, 5, 132, 0, 0, 1946, 1952, 3, 168, 84, 0, 1947, 1952, 3, 322, 161, 0, 1948, 1952, 3, 88, 44, 0, 1949, 1952, 3, 26, 13, 0, 1950, 1952, 3, 40, 20, 0, 1951, 1941, 1, 0, 0, 0, 1951, 1943, 1, 0, 0, 0, 1951, 1945, 1, 0, 0, 0, 1951, 1947, 1, 0, 0, 0, 1951, 1948, 1, 0, 0, 0, 1951, 1949, 1, 0, 0, 0, 1951, 1950, 1, 0, 0, 0, 1952, 225, 1, 0, 0, 0, 1953, 1960, 1, 0, 0, 0, 1954, 1955, 5, 122, 0, 0, 1955, 1956, 5, 30, 0, 0, 1956, 1957, 3, 228, 114, 0, 1957, 1958, 5, 31, 0, 0, 1958, 1960, 1, 0, 0, 0, 1959, 1953, 1, 0, 0, 0, 1959, 1954, 1, 0, 0, 0, 1960, 227, 1, 0, 0, 0, 1961, 1971, 3, 126, 63, 0, 1962, 1964, 5, 17, 0, 0, 1963, 1965, 3, 294, 147, 0, 1964, 1963, 1, 0, 0, 0, 1965, 1966, 1, 0, 0, 0, 1966, 1964, 1, 0, 0, 0, 1966, 1967, 1, 0, 0, 0, 1967, 1968, 1, 0, 0, 0, 1968, 1969, 5, 18, 0, 0, 1969, 1971, 1, 0, 0, 0, 1970, 1961, 1, 0, 0, 0, 1970, 1962, 1, 0, 0, 0, 1971, 229, 1, 0, 0, 0, 1972, 1974, 3, 232, 116, 0, 1973, 1972, 1, 0, 0, 0, 1974, 1977, 1, 0, 0, 0, 1975, 1973, 1, 0, 0, 0, 1975, 1976, 1, 0, 0, 0, 1976, 231, 1, 0, 0, 0, 1977, 1975, 1, 0, 0, 0, 1978, 1979, 5, 42, 0, 0, 1979, 1980, 5, 136, 0, 0, 1980, 1992, 5, 43, 0, 0, 1981, 1982, 5, 42, 0, 0, 1982, 1983, 5, 137, 0, 0, 1983, 1992, 5, 43, 0, 0, 1984, 1985, 5, 42, 0, 0, 1985, 1986, 5, 138, 0, 0, 1986, 1992, 5, 43, 0, 0, 1987, 1988, 5, 42, 0, 0, 1988, 1989, 3, 32, 16, 0, 1989, 1990, 5, 43, 0, 0, 1990, 1992, 1, 0, 0, 0, 1991, 1978, 1, 0, 0, 0, 1991, 1981, 1, 0, 0, 0, 1991, 1984, 1, 0, 0, 0, 1991, 1987, 1, 0, 0, 0, 1992, 233, 1, 0, 0, 0, 1993, 1998, 5, 139, 0, 0, 1994, 1997, 3, 236, 118, 0, 1995, 1997, 3, 238, 119, 0, 1996, 1994, 1, 0, 0, 0, 1996, 1995, 1, 0, 0, 0, 1997, 2000, 1, 0, 0, 0, 1998, 1996, 1, 0, 0, 0, 1998, 1999, 1, 0, 0, 0, 1999, 2001, 1, 0, 0, 0, 2000, 1998, 1, 0, 0, 0, 2001, 2002, 3, 170, 85, 0, 2002, 2003, 3, 230, 115, 0, 2003, 2004, 3, 138, 69, 0, 2004, 2005, 3, 226, 113, 0, 2005, 2006, 3, 242, 121, 0, 2006, 2007, 3, 182, 91, 0, 2007, 2011, 3, 112, 56, 0, 2008, 2010, 3, 244, 122, 0, 2009, 2008, 1, 0, 0, 0, 2010, 2013, 1, 0, 0, 0, 2011, 2009, 1, 0, 0, 0, 2011, 2012, 1, 0, 0, 0, 2012, 235, 1, 0, 0, 0, 2013, 2011, 1, 0, 0, 0, 2014, 2038, 5, 123, 0, 0, 2015, 2038, 5, 51, 0, 0, 2016, 2038, 5, 52, 0, 0, 2017, 2038, 5, 63, 0, 0, 2018, 2038, 5, 140, 0, 0, 2019, 2038, 5, 68, 0, 0, 2020, 2038, 5, 141, 0, 0, 2021, 2038, 5, 142, 0, 0, 2022, 2038, 5, 54, 0, 0, 2023, 2038, 5, 64, 0, 0, 2024, 2038, 5, 65, 0, 0, 2025, 2038, 5, 66, 0, 0, 2026, 2038, 5, 125, 0, 0, 2027, 2038, 5, 143, 0, 0, 2028, 2038, 5, 144, 0, 0, 2029, 2038, 5, 69, 0, 0, 2030, 2038, 5, 145, 0, 0, 2031, 2038, 5, 146, 0, 0, 2032, 2033, 5, 70, 0, 0, 2033, 2034, 5, 30, 0, 0, 2034, 2035, 3, 32, 16, 0, 2035, 2036, 5, 31, 0, 0, 2036, 2038, 1, 0, 0, 0, 2037, 2014, 1, 0, 0, 0, 2037, 2015, 1, 0, 0, 0, 2037, 2016, 1, 0, 0, 0, 2037, 2017, 1, 0, 0, 0, 2037, 2018, 1, 0, 0, 0, 2037, 2019, 1, 0, 0, 0, 2037, 2020, 1, 0, 0, 0, 2037, 2021, 1, 0, 0, 0, 2037, 2022, 1, 0, 0, 0, 2037, 2023, 1, 0, 0, 0, 2037, 2024, 1, 0, 0, 0, 2037, 2025, 1, 0, 0, 0, 2037, 2026, 1, 0, 0, 0, 2037, 2027, 1, 0, 0, 0, 2037, 2028, 1, 0, 0, 0, 2037, 2029, 1, 0, 0, 0, 2037, 2030, 1, 0, 0, 0, 2037, 2031, 1, 0, 0, 0, 2037, 2032, 1, 0, 0, 0, 2038, 237, 1, 0, 0, 0, 2039, 2040, 5, 147, 0, 0, 2040, 2046, 5, 30, 0, 0, 2041, 2044, 3, 6, 3, 0, 2042, 2043, 5, 34, 0, 0, 2043, 2045, 3, 6, 3, 0, 2044, 2042, 1, 0, 0, 0, 2044, 2045, 1, 0, 0, 0, 2045, 2047, 1, 0, 0, 0, 2046, 2041, 1, 0, 0, 0, 2046, 2047, 1, 0, 0, 0, 2047, 2051, 1, 0, 0, 0, 2048, 2050, 3, 240, 120, 0, 2049, 2048, 1, 0, 0, 0, 2050, 2053, 1, 0, 0, 0, 2051, 2049, 1, 0, 0, 0, 2051, 2052, 1, 0, 0, 0, 2052, 2054, 1, 0, 0, 0, 2053, 2051, 1, 0, 0, 0, 2054, 2058, 5, 31, 0, 0, 2055, 2056, 5, 147, 0, 0, 2056, 2058, 5, 85, 0, 0, 2057, 2039, 1, 0, 0, 0, 2057, 2055, 1, 0, 0, 0, 2058, 239, 1, 0, 0, 0, 2059, 2087, 5, 148, 0, 0, 2060, 2087, 5, 224, 0, 0, 2061, 2087, 5, 57, 0, 0, 2062, 2087, 5, 58, 0, 0, 2063, 2087, 5, 149, 0, 0, 2064, 2087, 5, 150, 0, 0, 2065, 2087, 5, 248, 0, 0, 2066, 2087, 5, 249, 0, 0, 2067, 2087, 5, 250, 0, 0, 2068, 2087, 5, 251, 0, 0, 2069, 2070, 5, 151, 0, 0, 2070, 2071, 5, 75, 0, 0, 2071, 2087, 5, 152, 0, 0, 2072, 2073, 5, 151, 0, 0, 2073, 2074, 5, 75, 0, 0, 2074, 2087, 5, 153, 0, 0, 2075, 2076, 5, 154, 0, 0, 2076, 2077, 5, 75, 0, 0, 2077, 2087, 5, 152, 0, 0, 2078, 2079, 5, 154, 0, 0, 2079, 2080, 5, 75, 0, 0, 2080, 2087, 5, 153, 0, 0, 2081, 2082, 5, 70, 0, 0, 2082, 2083, 5, 30, 0, 0, 2083, 2084, 3, 32, 16, 0, 2084, 2085, 5, 31, 0, 0, 2085, 2087, 1, 0, 0, 0, 2086, 2059, 1, 0, 0, 0, 2086, 2060, 1, 0, 0, 0, 2086, 2061, 1, 0, 0, 0, 2086, 2062, 1, 0, 0, 0, 2086, 2063, 1, 0, 0, 0, 2086, 2064, 1, 0, 0, 0, 2086, 2065, 1, 0, 0, 0, 2086, 2066, 1, 0, 0, 0, 2086, 2067, 1, 0, 0, 0, 2086, 2068, 1, 0, 0, 0, 2086, 2069, 1, 0, 0, 0, 2086, 2072, 1, 0, 0, 0, 2086, 2075, 1, 0, 0, 0, 2086, 2078, 1, 0, 0, 0, 2086, 2081, 1, 0, 0, 0, 2087, 241, 1, 0, 0, 0, 2088, 2092, 5, 116, 0, 0, 2089, 2092, 5, 155, 0, 0, 2090, 2092, 3, 2, 1, 0, 2091, 2088, 1, 0, 0, 0, 2091, 2089, 1, 0, 0, 0, 2091, 2090, 1, 0, 0, 0, 2092, 243, 1, 0, 0, 0, 2093, 2115, 5, 1, 0, 0, 2094, 2115, 5, 2, 0, 0, 2095, 2115, 5, 156, 0, 0, 2096, 2115, 5, 3, 0, 0, 2097, 2115, 5, 4, 0, 0, 2098, 2115, 5, 247, 0, 0, 2099, 2115, 5, 5, 0, 0, 2100, 2115, 5, 6, 0, 0, 2101, 2115, 5, 7, 0, 0, 2102, 2115, 5, 8, 0, 0, 2103, 2115, 5, 9, 0, 0, 2104, 2115, 5, 10, 0, 0, 2105, 2115, 5, 11, 0, 0, 2106, 2115, 5, 12, 0, 0, 2107, 2115, 5, 13, 0, 0, 2108, 2115, 5, 14, 0, 0, 2109, 2110, 5, 70, 0, 0, 2110, 2111, 5, 30, 0, 0, 2111, 2112, 3, 32, 16, 0, 2112, 2113, 5, 31, 0, 0, 2113, 2115, 1, 0, 0, 0, 2114, 2093, 1, 0, 0, 0, 2114, 2094, 1, 0, 0, 0, 2114, 2095, 1, 0, 0, 0, 2114, 2096, 1, 0, 0, 0, 2114, 2097, 1, 0, 0, 0, 2114, 2098, 1, 0, 0, 0, 2114, 2099, 1, 0, 0, 0, 2114, 2100, 1, 0, 0, 0, 2114, 2101, 1, 0, 0, 0, 2114, 2102, 1, 0, 0, 0, 2114, 2103, 1, 0, 0, 0, 2114, 2104, 1, 0, 0, 0, 2114, 2105, 1, 0, 0, 0, 2114, 2106, 1, 0, 0, 0, 2114, 2107, 1, 0, 0, 0, 2114, 2108, 1, 0, 0, 0, 2114, 2109, 1, 0, 0, 0, 2115, 245, 1, 0, 0, 0, 2116, 2118, 3, 248, 124, 0, 2117, 2116, 1, 0, 0, 0, 2118, 2121, 1, 0, 0, 0, 2119, 2117, 1, 0, 0, 0, 2119, 2120, 1, 0, 0, 0, 2120, 247, 1, 0, 0, 0, 2121, 2119, 1, 0, 0, 0, 2122, 2140, 3, 100, 50, 0, 2123, 2124, 5, 296, 0, 0, 2124, 2125, 3, 32, 16, 0, 2125, 2126, 6, 124, -1, 0, 2126, 2140, 1, 0, 0, 0, 2127, 2140, 3, 258, 129, 0, 2128, 2129, 5, 297, 0, 0, 2129, 2130, 3, 32, 16, 0, 2130, 2131, 6, 124, -1, 0, 2131, 2140, 1, 0, 0, 0, 2132, 2133, 5, 298, 0, 0, 2133, 2140, 6, 124, -1, 0, 2134, 2135, 5, 299, 0, 0, 2135, 2140, 6, 124, -1, 0, 2136, 2140, 3, 252, 126, 0, 2137, 2140, 3, 256, 128, 0, 2138, 2140, 3, 250, 125, 0, 2139, 2122, 1, 0, 0, 0, 2139, 2123, 1, 0, 0, 0, 2139, 2127, 1, 0, 0, 0, 2139, 2128, 1, 0, 0, 0, 2139, 2132, 1, 0, 0, 0, 2139, 2134, 1, 0, 0, 0, 2139, 2136, 1, 0, 0, 0, 2139, 2137, 1, 0, 0, 0, 2139, 2138, 1, 0, 0, 0, 2140, 249, 1, 0, 0, 0, 2141, 2142, 5, 300, 0, 0, 2142, 2240, 3, 112, 56, 0, 2143, 2144, 5, 300, 0, 0, 2144, 2145, 5, 157, 0, 0, 2145, 2240, 3, 112, 56, 0, 2146, 2240, 3, 276, 138, 0, 2147, 2240, 3, 152, 76, 0, 2148, 2240, 3, 88, 44, 0, 2149, 2240, 3, 26, 13, 0, 2150, 2240, 3, 254, 127, 0, 2151, 2240, 3, 40, 20, 0, 2152, 2153, 5, 301, 0, 0, 2153, 2154, 5, 42, 0, 0, 2154, 2155, 3, 32, 16, 0, 2155, 2156, 5, 43, 0, 0, 2156, 2240, 1, 0, 0, 0, 2157, 2158, 5, 301, 0, 0, 2158, 2159, 5, 42, 0, 0, 2159, 2160, 3, 32, 16, 0, 2160, 2161, 5, 43, 0, 0, 2161, 2162, 5, 34, 0, 0, 2162, 2163, 3, 0, 0, 0, 2163, 2240, 1, 0, 0, 0, 2164, 2165, 5, 303, 0, 0, 2165, 2166, 3, 32, 16, 0, 2166, 2167, 5, 75, 0, 0, 2167, 2168, 3, 32, 16, 0, 2168, 2240, 1, 0, 0, 0, 2169, 2170, 5, 302, 0, 0, 2170, 2171, 3, 124, 62, 0, 2171, 2172, 5, 176, 0, 0, 2172, 2173, 3, 242, 121, 0, 2173, 2240, 1, 0, 0, 0, 2174, 2175, 5, 302, 0, 0, 2175, 2176, 5, 226, 0, 0, 2176, 2177, 3, 170, 85, 0, 2177, 2178, 3, 138, 69, 0, 2178, 2179, 3, 124, 62, 0, 2179, 2180, 5, 176, 0, 0, 2180, 2181, 3, 242, 121, 0, 2181, 2182, 3, 194, 97, 0, 2182, 2183, 3, 112, 56, 0, 2183, 2240, 1, 0, 0, 0, 2184, 2185, 5, 255, 0, 0, 2185, 2186, 5, 196, 0, 0, 2186, 2187, 5, 42, 0, 0, 2187, 2188, 3, 32, 16, 0, 2188, 2192, 5, 43, 0, 0, 2189, 2191, 3, 322, 161, 0, 2190, 2189, 1, 0, 0, 0, 2191, 2194, 1, 0, 0, 0, 2192, 2190, 1, 0, 0, 0, 2192, 2193, 1, 0, 0, 0, 2193, 2240, 1, 0, 0, 0, 2194, 2192, 1, 0, 0, 0, 2195, 2196, 5, 255, 0, 0, 2196, 2197, 5, 196, 0, 0, 2197, 2201, 3, 2, 1, 0, 2198, 2200, 3, 322, 161, 0, 2199, 2198, 1, 0, 0, 0, 2200, 2203, 1, 0, 0, 0, 2201, 2199, 1, 0, 0, 0, 2201, 2202, 1, 0, 0, 0, 2202, 2240, 1, 0, 0, 0, 2203, 2201, 1, 0, 0, 0, 2204, 2205, 5, 255, 0, 0, 2205, 2206, 5, 256, 0, 0, 2206, 2207, 5, 42, 0, 0, 2207, 2208, 3, 32, 16, 0, 2208, 2209, 5, 43, 0, 0, 2209, 2210, 5, 28, 0, 0, 2210, 2214, 3, 124, 62, 0, 2211, 2213, 3, 322, 161, 0, 2212, 2211, 1, 0, 0, 0, 2213, 2216, 1, 0, 0, 0, 2214, 2212, 1, 0, 0, 0, 2214, 2215, 1, 0, 0, 0, 2215, 2240, 1, 0, 0, 0, 2216, 2214, 1, 0, 0, 0, 2217, 2218, 5, 255, 0, 0, 2218, 2219, 5, 256, 0, 0, 2219, 2220, 3, 2, 1, 0, 2220, 2221, 5, 28, 0, 0, 2221, 2225, 3, 124, 62, 0, 2222, 2224, 3, 322, 161, 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, 2240, 1, 0, 0, 0, 2227, 2225, 1, 0, 0, 0, 2228, 2229, 5, 255, 0, 0, 2229, 2230, 5, 42, 0, 0, 2230, 2231, 3, 32, 16, 0, 2231, 2232, 5, 43, 0, 0, 2232, 2236, 3, 206, 103, 0, 2233, 2235, 3, 322, 161, 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, 2240, 1, 0, 0, 0, 2238, 2236, 1, 0, 0, 0, 2239, 2141, 1, 0, 0, 0, 2239, 2143, 1, 0, 0, 0, 2239, 2146, 1, 0, 0, 0, 2239, 2147, 1, 0, 0, 0, 2239, 2148, 1, 0, 0, 0, 2239, 2149, 1, 0, 0, 0, 2239, 2150, 1, 0, 0, 0, 2239, 2151, 1, 0, 0, 0, 2239, 2152, 1, 0, 0, 0, 2239, 2157, 1, 0, 0, 0, 2239, 2164, 1, 0, 0, 0, 2239, 2169, 1, 0, 0, 0, 2239, 2174, 1, 0, 0, 0, 2239, 2184, 1, 0, 0, 0, 2239, 2195, 1, 0, 0, 0, 2239, 2204, 1, 0, 0, 0, 2239, 2217, 1, 0, 0, 0, 2239, 2228, 1, 0, 0, 0, 2240, 251, 1, 0, 0, 0, 2241, 2242, 3, 0, 0, 0, 2242, 2243, 5, 75, 0, 0, 2243, 2244, 6, 126, -1, 0, 2244, 253, 1, 0, 0, 0, 2245, 2248, 3, 44, 22, 0, 2246, 2248, 3, 46, 23, 0, 2247, 2245, 1, 0, 0, 0, 2247, 2246, 1, 0, 0, 0, 2248, 255, 1, 0, 0, 0, 2249, 2250, 5, 17, 0, 0, 2250, 2251, 3, 246, 123, 0, 2251, 2252, 5, 18, 0, 0, 2252, 257, 1, 0, 0, 0, 2253, 2254, 3, 262, 131, 0, 2254, 2255, 3, 260, 130, 0, 2255, 259, 1, 0, 0, 0, 2256, 2258, 3, 264, 132, 0, 2257, 2256, 1, 0, 0, 0, 2258, 2259, 1, 0, 0, 0, 2259, 2257, 1, 0, 0, 0, 2259, 2260, 1, 0, 0, 0, 2260, 261, 1, 0, 0, 0, 2261, 2262, 5, 158, 0, 0, 2262, 2274, 3, 256, 128, 0, 2263, 2264, 5, 158, 0, 0, 2264, 2265, 3, 0, 0, 0, 2265, 2266, 5, 159, 0, 0, 2266, 2267, 3, 0, 0, 0, 2267, 2274, 1, 0, 0, 0, 2268, 2269, 5, 158, 0, 0, 2269, 2270, 3, 32, 16, 0, 2270, 2271, 5, 159, 0, 0, 2271, 2272, 3, 32, 16, 0, 2272, 2274, 1, 0, 0, 0, 2273, 2261, 1, 0, 0, 0, 2273, 2263, 1, 0, 0, 0, 2273, 2268, 1, 0, 0, 0, 2274, 263, 1, 0, 0, 0, 2275, 2276, 3, 268, 134, 0, 2276, 2277, 3, 274, 137, 0, 2277, 2288, 1, 0, 0, 0, 2278, 2279, 3, 266, 133, 0, 2279, 2280, 3, 274, 137, 0, 2280, 2288, 1, 0, 0, 0, 2281, 2282, 3, 270, 135, 0, 2282, 2283, 3, 274, 137, 0, 2283, 2288, 1, 0, 0, 0, 2284, 2285, 3, 272, 136, 0, 2285, 2286, 3, 274, 137, 0, 2286, 2288, 1, 0, 0, 0, 2287, 2275, 1, 0, 0, 0, 2287, 2278, 1, 0, 0, 0, 2287, 2281, 1, 0, 0, 0, 2287, 2284, 1, 0, 0, 0, 2288, 265, 1, 0, 0, 0, 2289, 2290, 5, 160, 0, 0, 2290, 2296, 3, 256, 128, 0, 2291, 2292, 5, 160, 0, 0, 2292, 2296, 3, 0, 0, 0, 2293, 2294, 5, 160, 0, 0, 2294, 2296, 3, 32, 16, 0, 2295, 2289, 1, 0, 0, 0, 2295, 2291, 1, 0, 0, 0, 2295, 2293, 1, 0, 0, 0, 2296, 267, 1, 0, 0, 0, 2297, 2298, 5, 161, 0, 0, 2298, 2299, 3, 124, 62, 0, 2299, 269, 1, 0, 0, 0, 2300, 2301, 5, 162, 0, 0, 2301, 271, 1, 0, 0, 0, 2302, 2303, 5, 163, 0, 0, 2303, 273, 1, 0, 0, 0, 2304, 2316, 3, 256, 128, 0, 2305, 2306, 5, 164, 0, 0, 2306, 2307, 3, 0, 0, 0, 2307, 2308, 5, 159, 0, 0, 2308, 2309, 3, 0, 0, 0, 2309, 2316, 1, 0, 0, 0, 2310, 2311, 5, 164, 0, 0, 2311, 2312, 3, 32, 16, 0, 2312, 2313, 5, 159, 0, 0, 2313, 2314, 3, 32, 16, 0, 2314, 2316, 1, 0, 0, 0, 2315, 2304, 1, 0, 0, 0, 2315, 2305, 1, 0, 0, 0, 2315, 2310, 1, 0, 0, 0, 2316, 275, 1, 0, 0, 0, 2317, 2318, 3, 278, 139, 0, 2318, 2319, 3, 282, 141, 0, 2319, 277, 1, 0, 0, 0, 2320, 2321, 5, 165, 0, 0, 2321, 2322, 3, 280, 140, 0, 2322, 2323, 3, 0, 0, 0, 2323, 2324, 5, 36, 0, 0, 2324, 2328, 1, 0, 0, 0, 2325, 2326, 5, 165, 0, 0, 2326, 2328, 3, 280, 140, 0, 2327, 2320, 1, 0, 0, 0, 2327, 2325, 1, 0, 0, 0, 2328, 279, 1, 0, 0, 0, 2329, 2333, 1, 0, 0, 0, 2330, 2333, 5, 166, 0, 0, 2331, 2333, 5, 2, 0, 0, 2332, 2329, 1, 0, 0, 0, 2332, 2330, 1, 0, 0, 0, 2332, 2331, 1, 0, 0, 0, 2333, 281, 1, 0, 0, 0, 2334, 2335, 5, 17, 0, 0, 2335, 2336, 3, 284, 142, 0, 2336, 2337, 5, 18, 0, 0, 2337, 2344, 1, 0, 0, 0, 2338, 2340, 3, 288, 144, 0, 2339, 2338, 1, 0, 0, 0, 2340, 2341, 1, 0, 0, 0, 2341, 2339, 1, 0, 0, 0, 2341, 2342, 1, 0, 0, 0, 2342, 2344, 1, 0, 0, 0, 2343, 2334, 1, 0, 0, 0, 2343, 2339, 1, 0, 0, 0, 2344, 283, 1, 0, 0, 0, 2345, 2346, 3, 288, 144, 0, 2346, 2347, 5, 28, 0, 0, 2347, 2349, 1, 0, 0, 0, 2348, 2345, 1, 0, 0, 0, 2349, 2352, 1, 0, 0, 0, 2350, 2348, 1, 0, 0, 0, 2350, 2351, 1, 0, 0, 0, 2351, 2353, 1, 0, 0, 0, 2352, 2350, 1, 0, 0, 0, 2353, 2354, 3, 288, 144, 0, 2354, 285, 1, 0, 0, 0, 2355, 2361, 1, 0, 0, 0, 2356, 2357, 5, 42, 0, 0, 2357, 2358, 3, 32, 16, 0, 2358, 2359, 5, 43, 0, 0, 2359, 2361, 1, 0, 0, 0, 2360, 2355, 1, 0, 0, 0, 2360, 2356, 1, 0, 0, 0, 2361, 287, 1, 0, 0, 0, 2362, 2363, 5, 181, 0, 0, 2363, 2364, 5, 262, 0, 0, 2364, 2365, 5, 30, 0, 0, 2365, 2366, 3, 6, 3, 0, 2366, 2367, 5, 31, 0, 0, 2367, 2429, 1, 0, 0, 0, 2368, 2369, 5, 260, 0, 0, 2369, 2370, 5, 30, 0, 0, 2370, 2371, 3, 0, 0, 0, 2371, 2372, 5, 31, 0, 0, 2372, 2429, 1, 0, 0, 0, 2373, 2374, 5, 260, 0, 0, 2374, 2429, 3, 0, 0, 0, 2375, 2376, 5, 84, 0, 0, 2376, 2377, 5, 30, 0, 0, 2377, 2378, 3, 292, 146, 0, 2378, 2379, 5, 31, 0, 0, 2379, 2429, 1, 0, 0, 0, 2380, 2381, 5, 188, 0, 0, 2381, 2382, 5, 30, 0, 0, 2382, 2383, 3, 36, 18, 0, 2383, 2384, 5, 31, 0, 0, 2384, 2385, 3, 286, 143, 0, 2385, 2429, 1, 0, 0, 0, 2386, 2387, 5, 189, 0, 0, 2387, 2388, 5, 30, 0, 0, 2388, 2389, 3, 36, 18, 0, 2389, 2390, 5, 31, 0, 0, 2390, 2391, 3, 286, 143, 0, 2391, 2429, 1, 0, 0, 0, 2392, 2393, 5, 187, 0, 0, 2393, 2394, 5, 30, 0, 0, 2394, 2395, 3, 34, 17, 0, 2395, 2396, 5, 31, 0, 0, 2396, 2397, 3, 286, 143, 0, 2397, 2429, 1, 0, 0, 0, 2398, 2399, 5, 186, 0, 0, 2399, 2400, 5, 30, 0, 0, 2400, 2401, 3, 32, 16, 0, 2401, 2402, 5, 31, 0, 0, 2402, 2403, 3, 286, 143, 0, 2403, 2429, 1, 0, 0, 0, 2404, 2405, 5, 185, 0, 0, 2405, 2406, 5, 30, 0, 0, 2406, 2407, 3, 32, 16, 0, 2407, 2408, 5, 31, 0, 0, 2408, 2409, 3, 286, 143, 0, 2409, 2429, 1, 0, 0, 0, 2410, 2411, 5, 184, 0, 0, 2411, 2412, 5, 30, 0, 0, 2412, 2413, 3, 32, 16, 0, 2413, 2414, 5, 31, 0, 0, 2414, 2415, 3, 286, 143, 0, 2415, 2429, 1, 0, 0, 0, 2416, 2417, 5, 188, 0, 0, 2417, 2429, 3, 286, 143, 0, 2418, 2419, 5, 189, 0, 0, 2419, 2429, 3, 286, 143, 0, 2420, 2421, 5, 187, 0, 0, 2421, 2429, 3, 286, 143, 0, 2422, 2423, 5, 186, 0, 0, 2423, 2429, 3, 286, 143, 0, 2424, 2425, 5, 185, 0, 0, 2425, 2429, 3, 286, 143, 0, 2426, 2427, 5, 184, 0, 0, 2427, 2429, 3, 286, 143, 0, 2428, 2362, 1, 0, 0, 0, 2428, 2368, 1, 0, 0, 0, 2428, 2373, 1, 0, 0, 0, 2428, 2375, 1, 0, 0, 0, 2428, 2380, 1, 0, 0, 0, 2428, 2386, 1, 0, 0, 0, 2428, 2392, 1, 0, 0, 0, 2428, 2398, 1, 0, 0, 0, 2428, 2404, 1, 0, 0, 0, 2428, 2410, 1, 0, 0, 0, 2428, 2416, 1, 0, 0, 0, 2428, 2418, 1, 0, 0, 0, 2428, 2420, 1, 0, 0, 0, 2428, 2422, 1, 0, 0, 0, 2428, 2424, 1, 0, 0, 0, 2428, 2426, 1, 0, 0, 0, 2429, 289, 1, 0, 0, 0, 2430, 2431, 5, 188, 0, 0, 2431, 2432, 5, 30, 0, 0, 2432, 2433, 3, 36, 18, 0, 2433, 2434, 5, 31, 0, 0, 2434, 2506, 1, 0, 0, 0, 2435, 2436, 5, 189, 0, 0, 2436, 2437, 5, 30, 0, 0, 2437, 2438, 3, 36, 18, 0, 2438, 2439, 5, 31, 0, 0, 2439, 2506, 1, 0, 0, 0, 2440, 2441, 5, 188, 0, 0, 2441, 2442, 5, 30, 0, 0, 2442, 2443, 3, 32, 16, 0, 2443, 2444, 5, 31, 0, 0, 2444, 2506, 1, 0, 0, 0, 2445, 2446, 5, 189, 0, 0, 2446, 2447, 5, 30, 0, 0, 2447, 2448, 3, 34, 17, 0, 2448, 2449, 5, 31, 0, 0, 2449, 2506, 1, 0, 0, 0, 2450, 2451, 5, 187, 0, 0, 2451, 2452, 5, 30, 0, 0, 2452, 2453, 3, 34, 17, 0, 2453, 2454, 5, 31, 0, 0, 2454, 2506, 1, 0, 0, 0, 2455, 2456, 5, 186, 0, 0, 2456, 2457, 5, 30, 0, 0, 2457, 2458, 3, 32, 16, 0, 2458, 2459, 5, 31, 0, 0, 2459, 2506, 1, 0, 0, 0, 2460, 2461, 5, 185, 0, 0, 2461, 2462, 5, 30, 0, 0, 2462, 2463, 3, 32, 16, 0, 2463, 2464, 5, 31, 0, 0, 2464, 2506, 1, 0, 0, 0, 2465, 2466, 5, 184, 0, 0, 2466, 2467, 5, 30, 0, 0, 2467, 2468, 3, 32, 16, 0, 2468, 2469, 5, 31, 0, 0, 2469, 2506, 1, 0, 0, 0, 2470, 2471, 5, 193, 0, 0, 2471, 2472, 5, 30, 0, 0, 2472, 2473, 3, 34, 17, 0, 2473, 2474, 5, 31, 0, 0, 2474, 2506, 1, 0, 0, 0, 2475, 2476, 5, 192, 0, 0, 2476, 2477, 5, 30, 0, 0, 2477, 2478, 3, 32, 16, 0, 2478, 2479, 5, 31, 0, 0, 2479, 2506, 1, 0, 0, 0, 2480, 2481, 5, 191, 0, 0, 2481, 2482, 5, 30, 0, 0, 2482, 2483, 3, 32, 16, 0, 2483, 2484, 5, 31, 0, 0, 2484, 2506, 1, 0, 0, 0, 2485, 2486, 5, 190, 0, 0, 2486, 2487, 5, 30, 0, 0, 2487, 2488, 3, 32, 16, 0, 2488, 2489, 5, 31, 0, 0, 2489, 2506, 1, 0, 0, 0, 2490, 2491, 5, 181, 0, 0, 2491, 2492, 5, 30, 0, 0, 2492, 2493, 3, 32, 16, 0, 2493, 2494, 5, 31, 0, 0, 2494, 2506, 1, 0, 0, 0, 2495, 2496, 5, 183, 0, 0, 2496, 2497, 5, 30, 0, 0, 2497, 2498, 3, 162, 81, 0, 2498, 2499, 5, 31, 0, 0, 2499, 2506, 1, 0, 0, 0, 2500, 2501, 5, 84, 0, 0, 2501, 2502, 5, 30, 0, 0, 2502, 2503, 3, 292, 146, 0, 2503, 2504, 5, 31, 0, 0, 2504, 2506, 1, 0, 0, 0, 2505, 2430, 1, 0, 0, 0, 2505, 2435, 1, 0, 0, 0, 2505, 2440, 1, 0, 0, 0, 2505, 2445, 1, 0, 0, 0, 2505, 2450, 1, 0, 0, 0, 2505, 2455, 1, 0, 0, 0, 2505, 2460, 1, 0, 0, 0, 2505, 2465, 1, 0, 0, 0, 2505, 2470, 1, 0, 0, 0, 2505, 2475, 1, 0, 0, 0, 2505, 2480, 1, 0, 0, 0, 2505, 2485, 1, 0, 0, 0, 2505, 2490, 1, 0, 0, 0, 2505, 2495, 1, 0, 0, 0, 2505, 2500, 1, 0, 0, 0, 2506, 291, 1, 0, 0, 0, 2507, 2508, 3, 294, 147, 0, 2508, 2509, 6, 146, -1, 0, 2509, 2511, 1, 0, 0, 0, 2510, 2507, 1, 0, 0, 0, 2511, 2514, 1, 0, 0, 0, 2512, 2510, 1, 0, 0, 0, 2512, 2513, 1, 0, 0, 0, 2513, 293, 1, 0, 0, 0, 2514, 2512, 1, 0, 0, 0, 2515, 2516, 7, 12, 0, 0, 2516, 295, 1, 0, 0, 0, 2517, 2521, 3, 290, 145, 0, 2518, 2521, 3, 6, 3, 0, 2519, 2521, 5, 179, 0, 0, 2520, 2517, 1, 0, 0, 0, 2520, 2518, 1, 0, 0, 0, 2520, 2519, 1, 0, 0, 0, 2521, 297, 1, 0, 0, 0, 2522, 2671, 3, 290, 145, 0, 2523, 2524, 5, 182, 0, 0, 2524, 2525, 5, 30, 0, 0, 2525, 2526, 5, 179, 0, 0, 2526, 2671, 5, 31, 0, 0, 2527, 2528, 5, 182, 0, 0, 2528, 2529, 5, 30, 0, 0, 2529, 2530, 5, 264, 0, 0, 2530, 2671, 5, 31, 0, 0, 2531, 2532, 5, 196, 0, 0, 2532, 2533, 5, 30, 0, 0, 2533, 2534, 5, 39, 0, 0, 2534, 2535, 5, 264, 0, 0, 2535, 2671, 5, 31, 0, 0, 2536, 2537, 5, 196, 0, 0, 2537, 2538, 5, 30, 0, 0, 2538, 2539, 3, 116, 58, 0, 2539, 2540, 5, 31, 0, 0, 2540, 2671, 1, 0, 0, 0, 2541, 2542, 5, 196, 0, 0, 2542, 2543, 5, 30, 0, 0, 2543, 2544, 5, 179, 0, 0, 2544, 2671, 5, 31, 0, 0, 2545, 2546, 5, 197, 0, 0, 2546, 2547, 5, 30, 0, 0, 2547, 2548, 3, 298, 149, 0, 2548, 2549, 5, 31, 0, 0, 2549, 2671, 1, 0, 0, 0, 2550, 2551, 5, 188, 0, 0, 2551, 2552, 5, 42, 0, 0, 2552, 2553, 3, 32, 16, 0, 2553, 2554, 5, 43, 0, 0, 2554, 2555, 5, 30, 0, 0, 2555, 2556, 3, 300, 150, 0, 2556, 2557, 5, 31, 0, 0, 2557, 2671, 1, 0, 0, 0, 2558, 2559, 5, 189, 0, 0, 2559, 2560, 5, 42, 0, 0, 2560, 2561, 3, 32, 16, 0, 2561, 2562, 5, 43, 0, 0, 2562, 2563, 5, 30, 0, 0, 2563, 2564, 3, 302, 151, 0, 2564, 2565, 5, 31, 0, 0, 2565, 2671, 1, 0, 0, 0, 2566, 2567, 5, 187, 0, 0, 2567, 2568, 5, 42, 0, 0, 2568, 2569, 3, 32, 16, 0, 2569, 2570, 5, 43, 0, 0, 2570, 2571, 5, 30, 0, 0, 2571, 2572, 3, 304, 152, 0, 2572, 2573, 5, 31, 0, 0, 2573, 2671, 1, 0, 0, 0, 2574, 2575, 5, 186, 0, 0, 2575, 2576, 5, 42, 0, 0, 2576, 2577, 3, 32, 16, 0, 2577, 2578, 5, 43, 0, 0, 2578, 2579, 5, 30, 0, 0, 2579, 2580, 3, 306, 153, 0, 2580, 2581, 5, 31, 0, 0, 2581, 2671, 1, 0, 0, 0, 2582, 2583, 5, 185, 0, 0, 2583, 2584, 5, 42, 0, 0, 2584, 2585, 3, 32, 16, 0, 2585, 2586, 5, 43, 0, 0, 2586, 2587, 5, 30, 0, 0, 2587, 2588, 3, 308, 154, 0, 2588, 2589, 5, 31, 0, 0, 2589, 2671, 1, 0, 0, 0, 2590, 2591, 5, 184, 0, 0, 2591, 2592, 5, 42, 0, 0, 2592, 2593, 3, 32, 16, 0, 2593, 2594, 5, 43, 0, 0, 2594, 2595, 5, 30, 0, 0, 2595, 2596, 3, 310, 155, 0, 2596, 2597, 5, 31, 0, 0, 2597, 2671, 1, 0, 0, 0, 2598, 2599, 5, 193, 0, 0, 2599, 2600, 5, 42, 0, 0, 2600, 2601, 3, 32, 16, 0, 2601, 2602, 5, 43, 0, 0, 2602, 2603, 5, 30, 0, 0, 2603, 2604, 3, 304, 152, 0, 2604, 2605, 5, 31, 0, 0, 2605, 2671, 1, 0, 0, 0, 2606, 2607, 5, 192, 0, 0, 2607, 2608, 5, 42, 0, 0, 2608, 2609, 3, 32, 16, 0, 2609, 2610, 5, 43, 0, 0, 2610, 2611, 5, 30, 0, 0, 2611, 2612, 3, 306, 153, 0, 2612, 2613, 5, 31, 0, 0, 2613, 2671, 1, 0, 0, 0, 2614, 2615, 5, 191, 0, 0, 2615, 2616, 5, 42, 0, 0, 2616, 2617, 3, 32, 16, 0, 2617, 2618, 5, 43, 0, 0, 2618, 2619, 5, 30, 0, 0, 2619, 2620, 3, 308, 154, 0, 2620, 2621, 5, 31, 0, 0, 2621, 2671, 1, 0, 0, 0, 2622, 2623, 5, 190, 0, 0, 2623, 2624, 5, 42, 0, 0, 2624, 2625, 3, 32, 16, 0, 2625, 2626, 5, 43, 0, 0, 2626, 2627, 5, 30, 0, 0, 2627, 2628, 3, 310, 155, 0, 2628, 2629, 5, 31, 0, 0, 2629, 2671, 1, 0, 0, 0, 2630, 2631, 5, 181, 0, 0, 2631, 2632, 5, 42, 0, 0, 2632, 2633, 3, 32, 16, 0, 2633, 2634, 5, 43, 0, 0, 2634, 2635, 5, 30, 0, 0, 2635, 2636, 3, 308, 154, 0, 2636, 2637, 5, 31, 0, 0, 2637, 2671, 1, 0, 0, 0, 2638, 2639, 5, 183, 0, 0, 2639, 2640, 5, 42, 0, 0, 2640, 2641, 3, 32, 16, 0, 2641, 2642, 5, 43, 0, 0, 2642, 2643, 5, 30, 0, 0, 2643, 2644, 3, 312, 156, 0, 2644, 2645, 5, 31, 0, 0, 2645, 2671, 1, 0, 0, 0, 2646, 2647, 5, 182, 0, 0, 2647, 2648, 5, 42, 0, 0, 2648, 2649, 3, 32, 16, 0, 2649, 2650, 5, 43, 0, 0, 2650, 2651, 5, 30, 0, 0, 2651, 2652, 3, 314, 157, 0, 2652, 2653, 5, 31, 0, 0, 2653, 2671, 1, 0, 0, 0, 2654, 2655, 5, 196, 0, 0, 2655, 2656, 5, 42, 0, 0, 2656, 2657, 3, 32, 16, 0, 2657, 2658, 5, 43, 0, 0, 2658, 2659, 5, 30, 0, 0, 2659, 2660, 3, 316, 158, 0, 2660, 2661, 5, 31, 0, 0, 2661, 2671, 1, 0, 0, 0, 2662, 2663, 5, 197, 0, 0, 2663, 2664, 5, 42, 0, 0, 2664, 2665, 3, 32, 16, 0, 2665, 2666, 5, 43, 0, 0, 2666, 2667, 5, 30, 0, 0, 2667, 2668, 3, 320, 160, 0, 2668, 2669, 5, 31, 0, 0, 2669, 2671, 1, 0, 0, 0, 2670, 2522, 1, 0, 0, 0, 2670, 2523, 1, 0, 0, 0, 2670, 2527, 1, 0, 0, 0, 2670, 2531, 1, 0, 0, 0, 2670, 2536, 1, 0, 0, 0, 2670, 2541, 1, 0, 0, 0, 2670, 2545, 1, 0, 0, 0, 2670, 2550, 1, 0, 0, 0, 2670, 2558, 1, 0, 0, 0, 2670, 2566, 1, 0, 0, 0, 2670, 2574, 1, 0, 0, 0, 2670, 2582, 1, 0, 0, 0, 2670, 2590, 1, 0, 0, 0, 2670, 2598, 1, 0, 0, 0, 2670, 2606, 1, 0, 0, 0, 2670, 2614, 1, 0, 0, 0, 2670, 2622, 1, 0, 0, 0, 2670, 2630, 1, 0, 0, 0, 2670, 2638, 1, 0, 0, 0, 2670, 2646, 1, 0, 0, 0, 2670, 2654, 1, 0, 0, 0, 2670, 2662, 1, 0, 0, 0, 2671, 299, 1, 0, 0, 0, 2672, 2675, 3, 36, 18, 0, 2673, 2675, 3, 32, 16, 0, 2674, 2672, 1, 0, 0, 0, 2674, 2673, 1, 0, 0, 0, 2675, 2678, 1, 0, 0, 0, 2676, 2674, 1, 0, 0, 0, 2676, 2677, 1, 0, 0, 0, 2677, 301, 1, 0, 0, 0, 2678, 2676, 1, 0, 0, 0, 2679, 2682, 3, 36, 18, 0, 2680, 2682, 3, 34, 17, 0, 2681, 2679, 1, 0, 0, 0, 2681, 2680, 1, 0, 0, 0, 2682, 2685, 1, 0, 0, 0, 2683, 2681, 1, 0, 0, 0, 2683, 2684, 1, 0, 0, 0, 2684, 303, 1, 0, 0, 0, 2685, 2683, 1, 0, 0, 0, 2686, 2688, 3, 34, 17, 0, 2687, 2686, 1, 0, 0, 0, 2688, 2691, 1, 0, 0, 0, 2689, 2687, 1, 0, 0, 0, 2689, 2690, 1, 0, 0, 0, 2690, 305, 1, 0, 0, 0, 2691, 2689, 1, 0, 0, 0, 2692, 2694, 3, 32, 16, 0, 2693, 2692, 1, 0, 0, 0, 2694, 2697, 1, 0, 0, 0, 2695, 2693, 1, 0, 0, 0, 2695, 2696, 1, 0, 0, 0, 2696, 307, 1, 0, 0, 0, 2697, 2695, 1, 0, 0, 0, 2698, 2700, 3, 32, 16, 0, 2699, 2698, 1, 0, 0, 0, 2700, 2703, 1, 0, 0, 0, 2701, 2699, 1, 0, 0, 0, 2701, 2702, 1, 0, 0, 0, 2702, 309, 1, 0, 0, 0, 2703, 2701, 1, 0, 0, 0, 2704, 2706, 3, 32, 16, 0, 2705, 2704, 1, 0, 0, 0, 2706, 2709, 1, 0, 0, 0, 2707, 2705, 1, 0, 0, 0, 2707, 2708, 1, 0, 0, 0, 2708, 311, 1, 0, 0, 0, 2709, 2707, 1, 0, 0, 0, 2710, 2712, 3, 162, 81, 0, 2711, 2710, 1, 0, 0, 0, 2712, 2715, 1, 0, 0, 0, 2713, 2711, 1, 0, 0, 0, 2713, 2714, 1, 0, 0, 0, 2714, 313, 1, 0, 0, 0, 2715, 2713, 1, 0, 0, 0, 2716, 2718, 7, 13, 0, 0, 2717, 2716, 1, 0, 0, 0, 2718, 2721, 1, 0, 0, 0, 2719, 2717, 1, 0, 0, 0, 2719, 2720, 1, 0, 0, 0, 2720, 315, 1, 0, 0, 0, 2721, 2719, 1, 0, 0, 0, 2722, 2724, 3, 318, 159, 0, 2723, 2722, 1, 0, 0, 0, 2724, 2727, 1, 0, 0, 0, 2725, 2723, 1, 0, 0, 0, 2725, 2726, 1, 0, 0, 0, 2726, 317, 1, 0, 0, 0, 2727, 2725, 1, 0, 0, 0, 2728, 2733, 5, 179, 0, 0, 2729, 2730, 5, 39, 0, 0, 2730, 2733, 5, 264, 0, 0, 2731, 2733, 3, 116, 58, 0, 2732, 2728, 1, 0, 0, 0, 2732, 2729, 1, 0, 0, 0, 2732, 2731, 1, 0, 0, 0, 2733, 319, 1, 0, 0, 0, 2734, 2736, 3, 298, 149, 0, 2735, 2734, 1, 0, 0, 0, 2736, 2739, 1, 0, 0, 0, 2737, 2735, 1, 0, 0, 0, 2737, 2738, 1, 0, 0, 0, 2738, 321, 1, 0, 0, 0, 2739, 2737, 1, 0, 0, 0, 2740, 2744, 3, 44, 22, 0, 2741, 2744, 3, 46, 23, 0, 2742, 2744, 3, 2, 1, 0, 2743, 2740, 1, 0, 0, 0, 2743, 2741, 1, 0, 0, 0, 2743, 2742, 1, 0, 0, 0, 2744, 323, 1, 0, 0, 0, 2745, 2746, 7, 14, 0, 0, 2746, 2747, 5, 36, 0, 0, 2747, 2748, 5, 30, 0, 0, 2748, 2749, 3, 292, 146, 0, 2749, 2750, 5, 31, 0, 0, 2750, 2771, 1, 0, 0, 0, 2751, 2752, 5, 169, 0, 0, 2752, 2753, 3, 38, 19, 0, 2753, 2754, 5, 75, 0, 0, 2754, 2755, 3, 38, 19, 0, 2755, 2756, 5, 75, 0, 0, 2756, 2757, 3, 38, 19, 0, 2757, 2758, 5, 75, 0, 0, 2758, 2759, 3, 38, 19, 0, 2759, 2771, 1, 0, 0, 0, 2760, 2761, 5, 170, 0, 0, 2761, 2771, 3, 6, 3, 0, 2762, 2763, 5, 170, 0, 0, 2763, 2764, 5, 36, 0, 0, 2764, 2765, 5, 30, 0, 0, 2765, 2766, 3, 292, 146, 0, 2766, 2767, 5, 31, 0, 0, 2767, 2771, 1, 0, 0, 0, 2768, 2771, 3, 322, 161, 0, 2769, 2771, 3, 40, 20, 0, 2770, 2745, 1, 0, 0, 0, 2770, 2751, 1, 0, 0, 0, 2770, 2760, 1, 0, 0, 0, 2770, 2762, 1, 0, 0, 0, 2770, 2768, 1, 0, 0, 0, 2770, 2769, 1, 0, 0, 0, 2771, 325, 1, 0, 0, 0, 2772, 2773, 5, 25, 0, 0, 2773, 2774, 5, 40, 0, 0, 2774, 2775, 3, 98, 49, 0, 2775, 2776, 3, 2, 1, 0, 2776, 2785, 1, 0, 0, 0, 2777, 2778, 5, 25, 0, 0, 2778, 2779, 5, 40, 0, 0, 2779, 2780, 3, 98, 49, 0, 2780, 2781, 3, 2, 1, 0, 2781, 2782, 5, 34, 0, 0, 2782, 2783, 3, 2, 1, 0, 2783, 2785, 1, 0, 0, 0, 2784, 2772, 1, 0, 0, 0, 2784, 2777, 1, 0, 0, 0, 2785, 327, 1, 0, 0, 0, 2786, 2788, 3, 330, 165, 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, 329, 1, 0, 0, 0, 2791, 2789, 1, 0, 0, 0, 2792, 2793, 5, 180, 0, 0, 2793, 2794, 5, 36, 0, 0, 2794, 2795, 5, 30, 0, 0, 2795, 2796, 3, 292, 146, 0, 2796, 2797, 5, 31, 0, 0, 2797, 2807, 1, 0, 0, 0, 2798, 2807, 3, 324, 162, 0, 2799, 2800, 5, 171, 0, 0, 2800, 2801, 5, 36, 0, 0, 2801, 2802, 5, 30, 0, 0, 2802, 2803, 3, 292, 146, 0, 2803, 2804, 5, 31, 0, 0, 2804, 2807, 1, 0, 0, 0, 2805, 2807, 5, 55, 0, 0, 2806, 2792, 1, 0, 0, 0, 2806, 2798, 1, 0, 0, 0, 2806, 2799, 1, 0, 0, 0, 2806, 2805, 1, 0, 0, 0, 2807, 331, 1, 0, 0, 0, 2808, 2809, 5, 50, 0, 0, 2809, 2813, 5, 40, 0, 0, 2810, 2812, 3, 336, 168, 0, 2811, 2810, 1, 0, 0, 0, 2812, 2815, 1, 0, 0, 0, 2813, 2811, 1, 0, 0, 0, 2813, 2814, 1, 0, 0, 0, 2814, 2816, 1, 0, 0, 0, 2815, 2813, 1, 0, 0, 0, 2816, 2817, 3, 2, 1, 0, 2817, 333, 1, 0, 0, 0, 2818, 2822, 5, 301, 0, 0, 2819, 2821, 3, 336, 168, 0, 2820, 2819, 1, 0, 0, 0, 2821, 2824, 1, 0, 0, 0, 2822, 2820, 1, 0, 0, 0, 2822, 2823, 1, 0, 0, 0, 2823, 2825, 1, 0, 0, 0, 2824, 2822, 1, 0, 0, 0, 2825, 2826, 3, 2, 1, 0, 2826, 335, 1, 0, 0, 0, 2827, 2843, 5, 52, 0, 0, 2828, 2843, 5, 51, 0, 0, 2829, 2843, 5, 172, 0, 0, 2830, 2831, 5, 62, 0, 0, 2831, 2843, 5, 51, 0, 0, 2832, 2833, 5, 62, 0, 0, 2833, 2843, 5, 52, 0, 0, 2834, 2835, 5, 62, 0, 0, 2835, 2843, 5, 63, 0, 0, 2836, 2837, 5, 62, 0, 0, 2837, 2843, 5, 64, 0, 0, 2838, 2839, 5, 62, 0, 0, 2839, 2843, 5, 65, 0, 0, 2840, 2841, 5, 62, 0, 0, 2841, 2843, 5, 66, 0, 0, 2842, 2827, 1, 0, 0, 0, 2842, 2828, 1, 0, 0, 0, 2842, 2829, 1, 0, 0, 0, 2842, 2830, 1, 0, 0, 0, 2842, 2832, 1, 0, 0, 0, 2842, 2834, 1, 0, 0, 0, 2842, 2836, 1, 0, 0, 0, 2842, 2838, 1, 0, 0, 0, 2842, 2840, 1, 0, 0, 0, 2843, 337, 1, 0, 0, 0, 2844, 2846, 3, 340, 170, 0, 2845, 2844, 1, 0, 0, 0, 2846, 2849, 1, 0, 0, 0, 2847, 2845, 1, 0, 0, 0, 2847, 2848, 1, 0, 0, 0, 2848, 339, 1, 0, 0, 0, 2849, 2847, 1, 0, 0, 0, 2850, 2851, 5, 21, 0, 0, 2851, 2864, 3, 2, 1, 0, 2852, 2853, 5, 50, 0, 0, 2853, 2854, 5, 40, 0, 0, 2854, 2864, 3, 118, 59, 0, 2855, 2856, 5, 25, 0, 0, 2856, 2857, 5, 40, 0, 0, 2857, 2864, 3, 2, 1, 0, 2858, 2864, 3, 174, 87, 0, 2859, 2860, 5, 50, 0, 0, 2860, 2864, 3, 32, 16, 0, 2861, 2864, 3, 322, 161, 0, 2862, 2864, 3, 40, 20, 0, 2863, 2850, 1, 0, 0, 0, 2863, 2852, 1, 0, 0, 0, 2863, 2855, 1, 0, 0, 0, 2863, 2858, 1, 0, 0, 0, 2863, 2859, 1, 0, 0, 0, 2863, 2861, 1, 0, 0, 0, 2863, 2862, 1, 0, 0, 0, 2864, 341, 1, 0, 0, 0, 2865, 2869, 5, 274, 0, 0, 2866, 2868, 3, 344, 172, 0, 2867, 2866, 1, 0, 0, 0, 2868, 2871, 1, 0, 0, 0, 2869, 2867, 1, 0, 0, 0, 2869, 2870, 1, 0, 0, 0, 2870, 2872, 1, 0, 0, 0, 2871, 2869, 1, 0, 0, 0, 2872, 2885, 3, 2, 1, 0, 2873, 2877, 5, 274, 0, 0, 2874, 2876, 3, 344, 172, 0, 2875, 2874, 1, 0, 0, 0, 2876, 2879, 1, 0, 0, 0, 2877, 2875, 1, 0, 0, 0, 2877, 2878, 1, 0, 0, 0, 2878, 2880, 1, 0, 0, 0, 2879, 2877, 1, 0, 0, 0, 2880, 2881, 3, 2, 1, 0, 2881, 2882, 5, 34, 0, 0, 2882, 2883, 3, 2, 1, 0, 2883, 2885, 1, 0, 0, 0, 2884, 2865, 1, 0, 0, 0, 2884, 2873, 1, 0, 0, 0, 2885, 343, 1, 0, 0, 0, 2886, 2887, 7, 15, 0, 0, 2887, 345, 1, 0, 0, 0, 2888, 2890, 3, 348, 174, 0, 2889, 2888, 1, 0, 0, 0, 2890, 2893, 1, 0, 0, 0, 2891, 2889, 1, 0, 0, 0, 2891, 2892, 1, 0, 0, 0, 2892, 347, 1, 0, 0, 0, 2893, 2891, 1, 0, 0, 0, 2894, 2895, 5, 21, 0, 0, 2895, 2896, 3, 2, 1, 0, 2896, 2897, 5, 44, 0, 0, 2897, 2898, 3, 32, 16, 0, 2898, 2905, 1, 0, 0, 0, 2899, 2900, 5, 25, 0, 0, 2900, 2901, 5, 40, 0, 0, 2901, 2905, 3, 2, 1, 0, 2902, 2905, 3, 322, 161, 0, 2903, 2905, 3, 40, 20, 0, 2904, 2894, 1, 0, 0, 0, 2904, 2899, 1, 0, 0, 0, 2904, 2902, 1, 0, 0, 0, 2904, 2903, 1, 0, 0, 0, 2905, 349, 1, 0, 0, 0, 176, 358, 363, 372, 381, 434, 475, 484, 514, 518, 536, 563, 586, 622, 628, 635, 637, 647, 649, 656, 667, 675, 696, 698, 714, 759, 764, 769, 774, 782, 892, 898, 914, 920, 926, 933, 938, 1016, 1018, 1035, 1044, 1050, 1059, 1061, 1069, 1081, 1093, 1100, 1107, 1109, 1136, 1143, 1151, 1159, 1172, 1179, 1182, 1201, 1295, 1304, 1311, 1314, 1322, 1343, 1375, 1398, 1410, 1419, 1444, 1468, 1476, 1480, 1495, 1502, 1547, 1557, 1573, 1585, 1597, 1611, 1623, 1634, 1641, 1651, 1664, 1669, 1674, 1683, 1694, 1777, 1786, 1799, 1810, 1818, 1828, 1830, 1857, 1864, 1869, 1876, 1882, 1892, 1896, 1903, 1918, 1924, 1938, 1951, 1959, 1966, 1970, 1975, 1991, 1996, 1998, 2011, 2037, 2044, 2046, 2051, 2057, 2086, 2091, 2114, 2119, 2139, 2192, 2201, 2214, 2225, 2236, 2239, 2247, 2259, 2273, 2287, 2295, 2315, 2327, 2332, 2341, 2343, 2350, 2360, 2428, 2505, 2512, 2520, 2670, 2674, 2676, 2681, 2683, 2689, 2695, 2701, 2707, 2713, 2719, 2725, 2732, 2737, 2743, 2770, 2784, 2789, 2806, 2813, 2822, 2842, 2847, 2863, 2869, 2877, 2884, 2891, 2904] \ No newline at end of file diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs index e746b430def880..54b01dee688fb9 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs @@ -482,6 +482,9 @@ public DottedNamePartContext dottedNamePart() { } public partial class CompQstringContext : ParserRuleContext { + public string Value; + public IToken head; + public IToken tail; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] QSTRING() { return GetTokens(CILParser.QSTRING); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode QSTRING(int i) { return GetToken(CILParser.QSTRING, i); @@ -507,11 +510,12 @@ public override TResult Accept(IParseTreeVisitor visitor) { public CompQstringContext compQstring() { CompQstringContext _localctx = new CompQstringContext(Context, State); EnterRule(_localctx, 6, RULE_compQstring); + BeginStreaming(); Actions.BeginComposedString(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 371; + State = 372; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,2,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { @@ -519,18 +523,20 @@ public CompQstringContext compQstring() { { { State = 367; - Match(QSTRING); - State = 368; + _localctx.head = Match(QSTRING); + Actions.AddComposedStringPart(_localctx, _localctx.head); + State = 369; Match(PLUS); } } } - State = 373; + State = 374; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,2,Context); } - State = 374; - Match(QSTRING); + State = 375; + _localctx.tail = Match(QSTRING); + Actions.AddComposedStringPart(_localctx, _localctx.tail); } } catch (RecognitionException re) { @@ -539,6 +545,7 @@ public CompQstringContext compQstring() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndComposedString(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; @@ -573,17 +580,17 @@ public DeclsContext decls() { try { EnterOuterAlt(_localctx, 1); { - State = 379; + State = 381; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1972571905523712L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 281474976710659L) != 0) || ((((_la - 139)) & ~0x3f) == 0 && ((1L << (_la - 139)) & 1729382256977379329L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 6860956837609473L) != 0)) { { { - State = 376; + State = 378; decl(); } } - State = 381; + State = 383; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -717,224 +724,224 @@ public DeclContext decl() { EnterRule(_localctx, 10, RULE_decl); BeginSubtree(); try { - State = 432; + State = 434; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,4,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 382; + State = 384; classHead(); - State = 383; + State = 385; Match(T__16); - State = 384; + State = 386; classDecls(); - State = 385; + State = 387; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 387; + State = 389; nameSpaceHead(); - State = 388; + State = 390; Match(T__16); - State = 389; + State = 391; decls(); - State = 390; + State = 392; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 392; + State = 394; methodHead(); - State = 393; + State = 395; Match(T__16); - State = 394; + State = 396; methodDecls(); - State = 395; + State = 397; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 397; + State = 399; fieldDecl(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 398; + State = 400; dataDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 399; + State = 401; vtableDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 400; + State = 402; vtfixupDecl(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 401; + State = 403; extSourceSpec(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 402; + State = 404; fileDecl(); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 403; + State = 405; assemblyBlock(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 404; + State = 406; assemblyRefHead(); - State = 405; + State = 407; Match(T__16); - State = 406; + State = 408; assemblyRefDecls(); - State = 407; + State = 409; Match(T__17); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 409; + State = 411; exptypeHead(); - State = 410; + State = 412; Match(T__16); - State = 411; + State = 413; exptypeDecls(); - State = 412; + State = 414; Match(T__17); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 414; + State = 416; manifestResHead(); - State = 415; + State = 417; Match(T__16); - State = 416; + State = 418; manifestResDecls(); - State = 417; + State = 419; Match(T__17); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 419; + State = 421; moduleHead(); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 420; + State = 422; secDecl(); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 421; + State = 423; customAttrDecl(); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 422; + State = 424; subsystem(); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 423; + State = 425; corflags(); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 424; + State = 426; alignment(); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 425; + State = 427; imagebase(); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 426; + State = 428; stackreserve(); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 427; + State = 429; languageDecl(); } break; case 23: EnterOuterAlt(_localctx, 23); { - State = 428; + State = 430; typedefDecl(); } break; case 24: EnterOuterAlt(_localctx, 24); { - State = 429; + State = 431; compControl(); } break; case 25: EnterOuterAlt(_localctx, 25); { - State = 430; + State = 432; typelist(); } break; case 26: EnterOuterAlt(_localctx, 26); { - State = 431; + State = 433; mscorlib(); } break; @@ -978,9 +985,9 @@ public SubsystemContext subsystem() { try { EnterOuterAlt(_localctx, 1); { - State = 434; + State = 436; Match(T__18); - State = 435; + State = 437; int32(); } } @@ -1019,9 +1026,9 @@ public CorflagsContext corflags() { try { EnterOuterAlt(_localctx, 1); { - State = 437; + State = 439; Match(T__19); - State = 438; + State = 440; int32(); } } @@ -1060,11 +1067,11 @@ public AlignmentContext alignment() { try { EnterOuterAlt(_localctx, 1); { - State = 440; + State = 442; Match(T__20); - State = 441; + State = 443; Match(T__21); - State = 442; + State = 444; int32(); } } @@ -1103,9 +1110,9 @@ public ImagebaseContext imagebase() { try { EnterOuterAlt(_localctx, 1); { - State = 444; + State = 446; Match(T__22); - State = 445; + State = 447; int64(); } } @@ -1144,9 +1151,9 @@ public StackreserveContext stackreserve() { try { EnterOuterAlt(_localctx, 1); { - State = 447; + State = 449; Match(T__23); - State = 448; + State = 450; int64(); } } @@ -1191,17 +1198,17 @@ public AssemblyBlockContext assemblyBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 450; + State = 452; Match(T__24); - State = 451; + State = 453; asmAttr(); - State = 452; + State = 454; dottedName(); - State = 453; + State = 455; Match(T__16); - State = 454; + State = 456; assemblyDecls(); - State = 455; + State = 457; Match(T__17); } } @@ -1237,7 +1244,7 @@ public MscorlibContext mscorlib() { try { EnterOuterAlt(_localctx, 1); { - State = 457; + State = 459; Match(T__25); } } @@ -1277,46 +1284,46 @@ public LanguageDeclContext languageDecl() { LanguageDeclContext _localctx = new LanguageDeclContext(Context, State); EnterRule(_localctx, 26, RULE_languageDecl); try { - State = 473; + State = 475; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,5,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 459; + State = 461; Match(T__26); - State = 460; + State = 462; languageString(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 461; + State = 463; Match(T__26); - State = 462; + State = 464; languageString(); - State = 463; + State = 465; Match(T__27); - State = 464; + State = 466; languageString(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 466; - Match(T__26); - State = 467; - languageString(); State = 468; - Match(T__27); + Match(T__26); State = 469; languageString(); State = 470; Match(T__27); State = 471; languageString(); + State = 472; + Match(T__27); + State = 473; + languageString(); } break; } @@ -1356,7 +1363,7 @@ public LanguageStringContext languageString() { try { EnterOuterAlt(_localctx, 1); { - State = 475; + State = 477; _la = TokenStream.LA(1); if ( !(_la==QSTRING || _la==SQSTRING) ) { ErrorHandler.RecoverInline(this); @@ -1406,25 +1413,25 @@ public TypelistContext typelist() { try { EnterOuterAlt(_localctx, 1); { - State = 477; + State = 479; Match(T__28); - State = 478; + State = 480; Match(T__16); - State = 482; + State = 484; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__15 || _la==T__41 || _la==T__112 || ((((_la - 199)) & ~0x3f) == 0 && ((1L << (_la - 199)) & 2017630225248026625L) != 0) || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50331649L) != 0)) { { { - State = 479; + State = 481; className(); } } - State = 484; + State = 486; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 485; + State = 487; Match(T__17); } } @@ -1461,7 +1468,7 @@ public Int32Context int32() { try { EnterOuterAlt(_localctx, 1); { - State = 487; + State = 489; Match(INT32); } } @@ -1500,7 +1507,7 @@ public Int64Context int64() { try { EnterOuterAlt(_localctx, 1); { - State = 489; + State = 491; _la = TokenStream.LA(1); if ( !(_la==INT32 || _la==INT64) ) { ErrorHandler.RecoverInline(this); @@ -1523,11 +1530,17 @@ public Int64Context int64() { } public partial class Float64Context : ParserRuleContext { + public double Value; + public IToken @decimal; + public Int32Context trailing; + public Int32Context integer; + public Int32Context singleBits; + public Int64Context doubleBits; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT64() { return GetToken(CILParser.FLOAT64, 0); } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DOT() { return GetToken(CILParser.DOT, 0); } [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DOT() { return GetToken(CILParser.DOT, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT32() { return GetToken(CILParser.FLOAT32, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT64_() { return GetToken(CILParser.FLOAT64_, 0); } [System.Diagnostics.DebuggerNonUserCode] public Int64Context int64() { @@ -1551,56 +1564,61 @@ public Float64Context float64() { Float64Context _localctx = new Float64Context(Context, State); EnterRule(_localctx, 36, RULE_float64); try { - State = 506; + State = 514; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,7,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 491; - Match(FLOAT64); + State = 493; + _localctx.@decimal = Match(FLOAT64); + _localctx.Value = Actions.ParseFloatingLiteral(_localctx.@decimal); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 492; - int32(); - State = 493; + State = 495; + _localctx.trailing = int32(); + State = 496; Match(DOT); + _localctx.Value = Actions.ParseFloatingInteger((_localctx.trailing!=null?(_localctx.trailing.Start):null)); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 495; - int32(); + State = 499; + _localctx.integer = int32(); + _localctx.Value = Actions.ParseFloatingInteger((_localctx.integer!=null?(_localctx.integer.Start):null)); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 496; + State = 502; Match(FLOAT32); - State = 497; + State = 503; Match(T__29); - State = 498; - int32(); - State = 499; + State = 504; + _localctx.singleBits = int32(); + State = 505; Match(T__30); + _localctx.Value = Actions.ParseFloat32Bits((_localctx.singleBits!=null?(_localctx.singleBits.Start):null)); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 501; + State = 508; Match(FLOAT64_); - State = 502; + State = 509; Match(T__29); - State = 503; - int64(); - State = 504; + State = 510; + _localctx.doubleBits = int64(); + State = 511; Match(T__30); + _localctx.Value = Actions.ParseFloat64Bits((_localctx.doubleBits!=null?(_localctx.doubleBits.Start):null)); } break; } @@ -1639,20 +1657,20 @@ public IntOrWildcardContext intOrWildcard() { IntOrWildcardContext _localctx = new IntOrWildcardContext(Context, State); EnterRule(_localctx, 38, RULE_intOrWildcard); try { - State = 510; + State = 518; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case INT32: EnterOuterAlt(_localctx, 1); { - State = 508; + State = 516; int32(); } break; case PTR: EnterOuterAlt(_localctx, 2); { - State = 509; + State = 517; Match(PTR); } break; @@ -1699,83 +1717,83 @@ public CompControlContext compControl() { CompControlContext _localctx = new CompControlContext(Context, State); EnterRule(_localctx, 40, RULE_compControl); try { - State = 528; + State = 536; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,9,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 512; + State = 520; Match(PP_DEFINE); - State = 513; + State = 521; Match(ID); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 514; + State = 522; Match(PP_DEFINE); - State = 515; + State = 523; Match(ID); - State = 516; + State = 524; Match(QSTRING); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 517; + State = 525; Match(PP_UNDEF); - State = 518; + State = 526; Match(ID); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 519; + State = 527; Match(PP_IFDEF); - State = 520; + State = 528; Match(ID); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 521; + State = 529; Match(PP_IFNDEF); - State = 522; + State = 530; Match(ID); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 523; + State = 531; Match(PP_ELSE); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 524; + State = 532; Match(PP_ENDIF); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 525; + State = 533; Match(PP_INCLUDE); - State = 526; + State = 534; Match(QSTRING); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 527; + State = 535; Match(T__31); } break; @@ -1829,71 +1847,71 @@ public TypedefDeclContext typedefDecl() { TypedefDeclContext _localctx = new TypedefDeclContext(Context, State); EnterRule(_localctx, 42, RULE_typedefDecl); try { - State = 555; + State = 563; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,10,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 530; + State = 538; Match(T__32); - State = 531; + State = 539; type(); - State = 532; + State = 540; Match(T__33); - State = 533; + State = 541; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 535; + State = 543; Match(T__32); - State = 536; + State = 544; className(); - State = 537; + State = 545; Match(T__33); - State = 538; + State = 546; dottedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 540; + State = 548; Match(T__32); - State = 541; + State = 549; memberRef(); - State = 542; + State = 550; Match(T__33); - State = 543; + State = 551; dottedName(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 545; + State = 553; Match(T__32); - State = 546; + State = 554; customDescr(); - State = 547; + State = 555; Match(T__33); - State = 548; + State = 556; dottedName(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 550; + State = 558; Match(T__32); - State = 551; + State = 559; customDescrWithOwner(); - State = 552; + State = 560; Match(T__33); - State = 553; + State = 561; dottedName(); } break; @@ -1941,62 +1959,62 @@ public CustomDescrContext customDescr() { CustomDescrContext _localctx = new CustomDescrContext(Context, State); EnterRule(_localctx, 44, RULE_customDescr); try { - State = 578; + State = 586; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,11,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 557; + State = 565; Match(T__34); - State = 558; + State = 566; customType(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 559; + State = 567; Match(T__34); - State = 560; + State = 568; customType(); - State = 561; + State = 569; Match(T__35); - State = 562; + State = 570; compQstring(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 564; + State = 572; Match(T__34); - State = 565; + State = 573; customType(); - State = 566; + State = 574; Match(T__35); - State = 567; + State = 575; Match(T__16); - State = 568; + State = 576; customBlobDescr(); - State = 569; + State = 577; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 571; + State = 579; Match(T__34); - State = 572; + State = 580; customType(); - State = 573; + State = 581; Match(T__35); - State = 574; + State = 582; Match(T__29); - State = 575; + State = 583; bytes(); - State = 576; + State = 584; Match(T__30); } break; @@ -2047,86 +2065,86 @@ public CustomDescrWithOwnerContext customDescrWithOwner() { CustomDescrWithOwnerContext _localctx = new CustomDescrWithOwnerContext(Context, State); EnterRule(_localctx, 46, RULE_customDescrWithOwner); try { - State = 614; + State = 622; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,12,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 580; + State = 588; Match(T__34); - State = 581; + State = 589; Match(T__29); - State = 582; + State = 590; ownerType(); - State = 583; + State = 591; Match(T__30); - State = 584; + State = 592; customType(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 586; + State = 594; Match(T__34); - State = 587; + State = 595; Match(T__29); - State = 588; + State = 596; ownerType(); - State = 589; + State = 597; Match(T__30); - State = 590; + State = 598; customType(); - State = 591; + State = 599; Match(T__35); - State = 592; + State = 600; compQstring(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 594; + State = 602; Match(T__34); - State = 595; + State = 603; Match(T__29); - State = 596; + State = 604; ownerType(); - State = 597; + State = 605; Match(T__30); - State = 598; + State = 606; customType(); - State = 599; + State = 607; Match(T__35); - State = 600; + State = 608; Match(T__16); - State = 601; + State = 609; customBlobDescr(); - State = 602; + State = 610; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 604; + State = 612; Match(T__34); - State = 605; + State = 613; Match(T__29); - State = 606; + State = 614; ownerType(); - State = 607; + State = 615; Match(T__30); - State = 608; + State = 616; customType(); - State = 609; + State = 617; Match(T__35); - State = 610; + State = 618; Match(T__29); - State = 611; + State = 619; bytes(); - State = 612; + State = 620; Match(T__30); } break; @@ -2167,7 +2185,7 @@ public CustomTypeContext customType() { try { EnterOuterAlt(_localctx, 1); { - State = 616; + State = 624; methodRef(); } } @@ -2207,20 +2225,20 @@ public OwnerTypeContext ownerType() { OwnerTypeContext _localctx = new OwnerTypeContext(Context, State); EnterRule(_localctx, 50, RULE_ownerType); try { - State = 620; + State = 628; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,13,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 618; + State = 626; typeSpec(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 619; + State = 627; memberRef(); } break; @@ -2264,9 +2282,9 @@ public CustomBlobDescrContext customBlobDescr() { try { EnterOuterAlt(_localctx, 1); { - State = 622; + State = 630; customBlobArgs(); - State = 623; + State = 631; customBlobNVPairs(); } } @@ -2315,13 +2333,13 @@ public CustomBlobArgsContext customBlobArgs() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 629; + State = 637; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,15,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { - State = 627; + State = 635; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__83: @@ -2341,7 +2359,7 @@ public CustomBlobArgsContext customBlobArgs() { case TYPE: case OBJECT: { - State = 625; + State = 633; serInit(); } break; @@ -2354,7 +2372,7 @@ public CustomBlobArgsContext customBlobArgs() { case PP_ENDIF: case PP_INCLUDE: { - State = 626; + State = 634; compControl(); } break; @@ -2363,7 +2381,7 @@ public CustomBlobArgsContext customBlobArgs() { } } } - State = 631; + State = 639; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,15,Context); } @@ -2432,26 +2450,26 @@ public CustomBlobNVPairsContext customBlobNVPairs() { try { EnterOuterAlt(_localctx, 1); { - State = 641; + State = 649; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 416611827712L) != 0) || ((((_la - 267)) & ~0x3f) == 0 && ((1L << (_la - 267)) & 127L) != 0)) { { - State = 639; + State = 647; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__36: case T__37: { - State = 632; + State = 640; fieldOrProp(); - State = 633; + State = 641; serializType(); - State = 634; + State = 642; dottedName(); - State = 635; + State = 643; Match(T__35); - State = 636; + State = 644; serInit(); } break; @@ -2464,7 +2482,7 @@ public CustomBlobNVPairsContext customBlobNVPairs() { case PP_ENDIF: case PP_INCLUDE: { - State = 638; + State = 646; compControl(); } break; @@ -2472,7 +2490,7 @@ public CustomBlobNVPairsContext customBlobNVPairs() { throw new NoViableAltException(this); } } - State = 643; + State = 651; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -2511,7 +2529,7 @@ public FieldOrPropContext fieldOrProp() { try { EnterOuterAlt(_localctx, 1); { - State = 644; + State = 652; _la = TokenStream.LA(1); if ( !(_la==T__36 || _la==T__37) ) { ErrorHandler.RecoverInline(this); @@ -2559,14 +2577,14 @@ public SerializTypeContext serializType() { try { EnterOuterAlt(_localctx, 1); { - State = 646; + State = 654; serializTypeElement(); - State = 648; + State = 656; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==ARRAY_TYPE_NO_BOUNDS) { { - State = 647; + State = 655; Match(ARRAY_TYPE_NO_BOUNDS); } } @@ -2616,54 +2634,54 @@ public SerializTypeElementContext serializTypeElement() { SerializTypeElementContext _localctx = new SerializTypeElementContext(Context, State); EnterRule(_localctx, 62, RULE_serializTypeElement); try { - State = 659; + State = 667; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,19,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 650; + State = 658; simpleType(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 651; + State = 659; dottedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 652; + State = 660; Match(TYPE); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 653; + State = 661; Match(OBJECT); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 654; + State = 662; Match(ENUM); - State = 655; + State = 663; Match(T__38); - State = 656; + State = 664; Match(SQSTRING); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 657; + State = 665; Match(ENUM); - State = 658; + State = 666; className(); } break; @@ -2703,33 +2721,33 @@ public ModuleHeadContext moduleHead() { ModuleHeadContext _localctx = new ModuleHeadContext(Context, State); EnterRule(_localctx, 64, RULE_moduleHead); try { - State = 667; + State = 675; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,20,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 661; + State = 669; Match(MODULE); - State = 662; + State = 670; Match(T__39); - State = 663; + State = 671; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 664; + State = 672; Match(MODULE); - State = 665; + State = 673; dottedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 666; + State = 674; Match(MODULE); } break; @@ -2776,19 +2794,19 @@ public VtfixupDeclContext vtfixupDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 669; + State = 677; Match(T__40); - State = 670; + State = 678; Match(T__41); - State = 671; + State = 679; int32(); - State = 672; + State = 680; Match(T__42); - State = 673; + State = 681; vtfixupAttr(0); - State = 674; + State = 682; Match(T__43); - State = 675; + State = 683; id(); } } @@ -2841,7 +2859,7 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { } Context.Stop = TokenStream.LT(-1); - State = 690; + State = 698; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,22,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { @@ -2850,16 +2868,16 @@ private VtfixupAttrContext vtfixupAttr(int _p) { TriggerExitRuleEvent(); _prevctx = _localctx; { - State = 688; + State = 696; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,21,Context) ) { case 1: { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 678; + State = 686; if (!(Precpred(Context, 5))) throw new FailedPredicateException(this, "Precpred(Context, 5)"); - State = 679; + State = 687; Match(INT32_); } break; @@ -2867,9 +2885,9 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 680; + State = 688; if (!(Precpred(Context, 4))) throw new FailedPredicateException(this, "Precpred(Context, 4)"); - State = 681; + State = 689; Match(INT64_); } break; @@ -2877,9 +2895,9 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 682; + State = 690; if (!(Precpred(Context, 3))) throw new FailedPredicateException(this, "Precpred(Context, 3)"); - State = 683; + State = 691; Match(T__44); } break; @@ -2887,9 +2905,9 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 684; + State = 692; if (!(Precpred(Context, 2))) throw new FailedPredicateException(this, "Precpred(Context, 2)"); - State = 685; + State = 693; Match(T__45); } break; @@ -2897,16 +2915,16 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 686; + State = 694; if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)"); - State = 687; + State = 695; Match(T__46); } break; } } } - State = 692; + State = 700; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,22,Context); } @@ -2947,15 +2965,15 @@ public VtableDeclContext vtableDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 693; + State = 701; Match(T__47); - State = 694; + State = 702; Match(T__35); - State = 695; + State = 703; Match(T__29); - State = 696; + State = 704; bytes(); - State = 697; + State = 705; Match(T__30); } } @@ -2995,9 +3013,9 @@ public NameSpaceHeadContext nameSpaceHead() { try { EnterOuterAlt(_localctx, 1); { - State = 699; + State = 707; Match(T__48); - State = 700; + State = 708; dottedName(); } Context.Stop = TokenStream.LT(-1); @@ -3056,31 +3074,31 @@ public ClassHeadContext classHead() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 702; + State = 710; Match(T__49); - State = 706; + State = 714; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,23,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 703; + State = 711; classAttr(); } } } - State = 708; + State = 716; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,23,Context); } - State = 709; + State = 717; dottedName(); - State = 710; + State = 718; typarsClause(); - State = 711; + State = 719; extendsClause(); - State = 712; + State = 720; implClause(); } Context.Stop = TokenStream.LT(-1); @@ -3125,213 +3143,213 @@ public ClassAttrContext classAttr() { ClassAttrContext _localctx = new ClassAttrContext(Context, State); EnterRule(_localctx, 76, RULE_classAttr); try { - State = 751; + State = 759; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,24,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 714; + State = 722; Match(T__50); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 715; + State = 723; Match(T__51); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 716; + State = 724; Match(VALUE); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 717; + State = 725; Match(ENUM); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 718; + State = 726; Match(INTERFACE); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 719; + State = 727; Match(T__52); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 720; + State = 728; Match(T__53); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 721; + State = 729; Match(T__54); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 722; + State = 730; Match(T__55); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 723; + State = 731; Match(EXPLICIT); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 724; + State = 732; Match(T__14); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 725; + State = 733; Match(ANSI); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 726; + State = 734; Match(T__56); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 727; + State = 735; Match(T__57); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 728; + State = 736; Match(T__58); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 729; + State = 737; Match(T__59); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 730; + State = 738; Match(T__60); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 731; + State = 739; Match(T__61); - State = 732; + State = 740; Match(T__50); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 733; + State = 741; Match(T__61); - State = 734; + State = 742; Match(T__51); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 735; + State = 743; Match(T__61); - State = 736; + State = 744; Match(T__62); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 737; + State = 745; Match(T__61); - State = 738; + State = 746; Match(T__63); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 739; + State = 747; Match(T__61); - State = 740; + State = 748; Match(T__64); } break; case 23: EnterOuterAlt(_localctx, 23); { - State = 741; + State = 749; Match(T__61); - State = 742; + State = 750; Match(T__65); } break; case 24: EnterOuterAlt(_localctx, 24); { - State = 743; + State = 751; Match(T__66); } break; case 25: EnterOuterAlt(_localctx, 25); { - State = 744; + State = 752; Match(T__67); } break; case 26: EnterOuterAlt(_localctx, 26); { - State = 745; + State = 753; Match(T__68); } break; case 27: EnterOuterAlt(_localctx, 27); { - State = 746; + State = 754; Match(T__69); - State = 747; + State = 755; Match(T__29); - State = 748; + State = 756; int32(); - State = 749; + State = 757; Match(T__30); } break; @@ -3370,7 +3388,7 @@ public ExtendsClauseContext extendsClause() { ExtendsClauseContext _localctx = new ExtendsClauseContext(Context, State); EnterRule(_localctx, 78, RULE_extendsClause); try { - State = 756; + State = 764; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -3382,9 +3400,9 @@ public ExtendsClauseContext extendsClause() { case T__70: EnterOuterAlt(_localctx, 2); { - State = 754; + State = 762; Match(T__70); - State = 755; + State = 763; typeSpec(); } break; @@ -3425,7 +3443,7 @@ public ImplClauseContext implClause() { ImplClauseContext _localctx = new ImplClauseContext(Context, State); EnterRule(_localctx, 80, RULE_implClause); try { - State = 761; + State = 769; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -3436,9 +3454,9 @@ public ImplClauseContext implClause() { case T__71: EnterOuterAlt(_localctx, 2); { - State = 759; + State = 767; Match(T__71); - State = 760; + State = 768; implList(); } break; @@ -3486,17 +3504,17 @@ public ClassDeclsContext classDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 766; + State = 774; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1125938695831552L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 1189425290649010179L) != 0) || ((((_la - 139)) & ~0x3f) == 0 && ((1L << (_la - 139)) & 1152921504673955841L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 871552083145265153L) != 0)) { { { - State = 763; + State = 771; classDecl(); } } - State = 768; + State = 776; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -3542,25 +3560,25 @@ public ImplListContext implList() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 774; + State = 782; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,28,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 769; + State = 777; typeSpec(); - State = 770; + State = 778; Match(T__27); } } } - State = 776; + State = 784; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,28,Context); } - State = 777; + State = 785; typeSpec(); } } @@ -3597,7 +3615,7 @@ public EsHeadContext esHead() { try { EnterOuterAlt(_localctx, 1); { - State = 779; + State = 787; _la = TokenStream.LA(1); if ( !(_la==T__72 || _la==T__73) ) { ErrorHandler.RecoverInline(this); @@ -3649,257 +3667,257 @@ public ExtSourceSpecContext extSourceSpec() { ExtSourceSpecContext _localctx = new ExtSourceSpecContext(Context, State); EnterRule(_localctx, 88, RULE_extSourceSpec); try { - State = 884; + State = 892; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,29,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 781; + State = 789; esHead(); - State = 782; + State = 790; int32(); - State = 783; + State = 791; Match(SQSTRING); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 785; + State = 793; esHead(); - State = 786; + State = 794; int32(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 788; + State = 796; esHead(); - State = 789; + State = 797; int32(); - State = 790; + State = 798; Match(T__74); - State = 791; + State = 799; int32(); - State = 792; + State = 800; Match(SQSTRING); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 794; + State = 802; esHead(); - State = 795; + State = 803; int32(); - State = 796; + State = 804; Match(T__74); - State = 797; + State = 805; int32(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 799; + State = 807; esHead(); - State = 800; + State = 808; int32(); - State = 801; + State = 809; Match(T__74); - State = 802; + State = 810; int32(); - State = 803; + State = 811; Match(T__27); - State = 804; + State = 812; int32(); - State = 805; + State = 813; Match(SQSTRING); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 807; + State = 815; esHead(); - State = 808; + State = 816; int32(); - State = 809; + State = 817; Match(T__74); - State = 810; + State = 818; int32(); - State = 811; + State = 819; Match(T__27); - State = 812; + State = 820; int32(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 814; + State = 822; esHead(); - State = 815; + State = 823; int32(); - State = 816; + State = 824; Match(T__27); - State = 817; + State = 825; int32(); - State = 818; + State = 826; Match(T__74); - State = 819; + State = 827; int32(); - State = 820; + State = 828; Match(SQSTRING); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 822; + State = 830; esHead(); - State = 823; + State = 831; int32(); - State = 824; + State = 832; Match(T__27); - State = 825; + State = 833; int32(); - State = 826; + State = 834; Match(T__74); - State = 827; + State = 835; int32(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 829; + State = 837; esHead(); - State = 830; + State = 838; int32(); - State = 831; + State = 839; Match(T__27); - State = 832; + State = 840; int32(); - State = 833; + State = 841; Match(T__74); - State = 834; + State = 842; int32(); - State = 835; + State = 843; Match(T__27); - State = 836; + State = 844; int32(); - State = 837; + State = 845; Match(SQSTRING); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 839; + State = 847; esHead(); - State = 840; + State = 848; int32(); - State = 841; + State = 849; Match(T__27); - State = 842; + State = 850; int32(); - State = 843; + State = 851; Match(T__74); - State = 844; + State = 852; int32(); - State = 845; + State = 853; Match(T__27); - State = 846; + State = 854; int32(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 848; + State = 856; esHead(); - State = 849; + State = 857; int32(); - State = 850; + State = 858; Match(QSTRING); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 852; + State = 860; esHead(); - State = 853; + State = 861; int32(); - State = 854; + State = 862; Match(T__74); - State = 855; + State = 863; int32(); - State = 856; + State = 864; Match(QSTRING); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 858; + State = 866; esHead(); - State = 859; + State = 867; int32(); - State = 860; + State = 868; Match(T__74); - State = 861; + State = 869; int32(); - State = 862; + State = 870; Match(T__27); - State = 863; + State = 871; int32(); - State = 864; + State = 872; Match(QSTRING); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 866; + State = 874; esHead(); - State = 867; + State = 875; int32(); - State = 868; + State = 876; Match(T__27); - State = 869; + State = 877; int32(); - State = 870; + State = 878; Match(T__74); - State = 871; + State = 879; int32(); - State = 872; + State = 880; Match(QSTRING); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 874; + State = 882; esHead(); - State = 875; + State = 883; int32(); - State = 876; + State = 884; Match(T__27); - State = 877; + State = 885; int32(); - State = 878; + State = 886; Match(T__74); - State = 879; + State = 887; int32(); - State = 880; + State = 888; Match(T__27); - State = 881; + State = 889; int32(); - State = 882; + State = 890; Match(QSTRING); } break; @@ -3955,68 +3973,68 @@ public FileDeclContext fileDecl() { EnterRule(_localctx, 90, RULE_fileDecl); int _la; try { - State = 912; + State = 920; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,32,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 886; + State = 894; Match(T__20); - State = 890; + State = 898; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__75) { { { - State = 887; + State = 895; fileAttr(); } } - State = 892; + State = 900; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 893; + State = 901; dottedName(); - State = 894; + State = 902; fileEntry(); - State = 895; + State = 903; Match(HASH); - State = 896; + State = 904; Match(T__35); - State = 897; + State = 905; Match(T__29); - State = 898; + State = 906; bytes(); - State = 899; + State = 907; Match(T__30); - State = 900; + State = 908; fileEntry(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 902; + State = 910; Match(T__20); - State = 906; + State = 914; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__75) { { { - State = 903; + State = 911; fileAttr(); } } - State = 908; + State = 916; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 909; + State = 917; dottedName(); - State = 910; + State = 918; fileEntry(); } break; @@ -4054,7 +4072,7 @@ public FileAttrContext fileAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 914; + State = 922; Match(T__75); } } @@ -4089,7 +4107,7 @@ public FileEntryContext fileEntry() { FileEntryContext _localctx = new FileEntryContext(Context, State); EnterRule(_localctx, 94, RULE_fileEntry); try { - State = 918; + State = 926; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -4139,7 +4157,7 @@ public FileEntryContext fileEntry() { case ENTRYPOINT: EnterOuterAlt(_localctx, 2); { - State = 917; + State = 925; Match(ENTRYPOINT); } break; @@ -4180,7 +4198,7 @@ public AsmAttrAnyContext asmAttrAny() { try { EnterOuterAlt(_localctx, 1); { - State = 920; + State = 928; _la = TokenStream.LA(1); if ( !(_la==T__1 || _la==T__60 || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 127L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -4230,17 +4248,17 @@ public AsmAttrContext asmAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 925; + State = 933; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__1 || _la==T__60 || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 127L) != 0)) { { { - State = 922; + State = 930; asmAttrAny(); } } - State = 927; + State = 935; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -4282,20 +4300,20 @@ public InstrContext instr() { InstrContext _localctx = new InstrContext(Context, State); EnterRule(_localctx, 100, RULE_instr); try { - State = 930; + State = 938; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,35,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 928; + State = 936; simpleInstr(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 929; + State = 937; instructionIsland(); } break; @@ -4318,9 +4336,13 @@ public partial class SimpleInstrContext : ParserRuleContext { public IdContext name; public Int32Context value32; public Int64Context value64; + public Float64Context value; + public Int64Context integerValue; public BytesContext rawFloat; public Int32Context offset; public IdContext label; + public CompQstringContext userString; + public CompQstringContext ansiString; public BytesContext rawString; public Int32Context rawToken; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_NONE() { return GetToken(CILParser.INSTR_NONE, 0); } @@ -4337,12 +4359,23 @@ [System.Diagnostics.DebuggerNonUserCode] public Int64Context int64() { return GetRuleContext(0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_R() { return GetToken(CILParser.INSTR_R, 0); } + [System.Diagnostics.DebuggerNonUserCode] public Float64Context float64() { + return GetRuleContext(0); + } [System.Diagnostics.DebuggerNonUserCode] public BytesContext bytes() { return GetRuleContext(0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_BRTARGET() { return GetToken(CILParser.INSTR_BRTARGET, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_STRING() { return GetToken(CILParser.INSTR_STRING, 0); } + [System.Diagnostics.DebuggerNonUserCode] public CompQstringContext compQstring() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ANSI() { return GetToken(CILParser.ANSI, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_TOK() { return GetToken(CILParser.INSTR_TOK, 0); } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_SWITCH() { return GetToken(CILParser.INSTR_SWITCH, 0); } + [System.Diagnostics.DebuggerNonUserCode] public LabelsContext labels() { + return GetRuleContext(0); + } public SimpleInstrContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { @@ -4361,13 +4394,13 @@ public SimpleInstrContext simpleInstr() { SimpleInstrContext _localctx = new SimpleInstrContext(Context, State); EnterRule(_localctx, 102, RULE_simpleInstr); try { - State = 982; + State = 1018; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,36,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,37,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 932; + State = 940; _localctx.op = Match(INSTR_NONE); Actions.EmitNoOperandInstruction(_localctx.op); } @@ -4375,9 +4408,9 @@ public SimpleInstrContext simpleInstr() { case 2: EnterOuterAlt(_localctx, 2); { - State = 934; + State = 942; _localctx.op = Match(INSTR_VAR); - State = 935; + State = 943; _localctx.index = int32(); Actions.EmitVariableIndexInstruction(_localctx.op, (_localctx.index!=null?(_localctx.index.Start):null)); } @@ -4385,9 +4418,9 @@ public SimpleInstrContext simpleInstr() { case 3: EnterOuterAlt(_localctx, 3); { - State = 938; + State = 946; _localctx.op = Match(INSTR_VAR); - State = 939; + State = 947; _localctx.name = id(); Actions.EmitVariableNameInstruction(_localctx.op, (_localctx.name!=null?(_localctx.name.Start):null)); } @@ -4395,9 +4428,9 @@ public SimpleInstrContext simpleInstr() { case 4: EnterOuterAlt(_localctx, 4); { - State = 942; + State = 950; _localctx.op = Match(INSTR_I); - State = 943; + State = 951; _localctx.value32 = int32(); Actions.EmitInt32Instruction(_localctx.op, (_localctx.value32!=null?(_localctx.value32.Start):null)); } @@ -4405,9 +4438,9 @@ public SimpleInstrContext simpleInstr() { case 5: EnterOuterAlt(_localctx, 5); { - State = 946; + State = 954; _localctx.op = Match(INSTR_I8); - State = 947; + State = 955; _localctx.value64 = int64(); Actions.EmitInt64Instruction(_localctx.op, (_localctx.value64!=null?(_localctx.value64.Start):null)); } @@ -4415,80 +4448,158 @@ public SimpleInstrContext simpleInstr() { case 6: EnterOuterAlt(_localctx, 6); { - State = 950; + State = 958; _localctx.op = Match(INSTR_R); - State = 951; + State = 959; + _localctx.value = float64(); + Actions.EmitFloatingInstruction(_localctx.op, _localctx.value.Value); + } + break; + case 7: + EnterOuterAlt(_localctx, 7); + { + State = 962; + _localctx.op = Match(INSTR_R); + State = 963; + _localctx.integerValue = int64(); + Actions.EmitFloatingInstruction(_localctx.op, (_localctx.integerValue!=null?(_localctx.integerValue.Start):null)); + } + break; + case 8: + EnterOuterAlt(_localctx, 8); + { + State = 966; + _localctx.op = Match(INSTR_R); + State = 967; Match(T__29); - State = 952; + State = 968; _localctx.rawFloat = bytes(); - State = 953; + State = 969; Match(T__30); Actions.EmitRawFloatingInstruction(_localctx.op, _localctx.rawFloat.Value, (_localctx.rawFloat!=null?(_localctx.rawFloat.Start):null)); } break; - case 7: - EnterOuterAlt(_localctx, 7); + case 9: + EnterOuterAlt(_localctx, 9); { - State = 956; + State = 972; _localctx.op = Match(INSTR_R); - State = 957; + State = 973; Match(T__83); - State = 958; + State = 974; Match(T__29); - State = 959; + State = 975; _localctx.rawFloat = bytes(); - State = 960; + State = 976; Match(T__30); Actions.EmitRawFloatingInstruction(_localctx.op, _localctx.rawFloat.Value, (_localctx.rawFloat!=null?(_localctx.rawFloat.Start):null)); } break; - case 8: - EnterOuterAlt(_localctx, 8); + case 10: + EnterOuterAlt(_localctx, 10); { - State = 963; + State = 979; _localctx.op = Match(INSTR_BRTARGET); - State = 964; + State = 980; _localctx.offset = int32(); Actions.EmitBranchOffsetInstruction(_localctx.op, (_localctx.offset!=null?(_localctx.offset.Start):null)); } break; - case 9: - EnterOuterAlt(_localctx, 9); + case 11: + EnterOuterAlt(_localctx, 11); { - State = 967; + State = 983; _localctx.op = Match(INSTR_BRTARGET); - State = 968; + State = 984; _localctx.label = id(); Actions.EmitBranchLabelInstruction(_localctx.op, (_localctx.label!=null?(_localctx.label.Start):null)); } break; - case 10: - EnterOuterAlt(_localctx, 10); + case 12: + EnterOuterAlt(_localctx, 12); + { + State = 987; + _localctx.op = Match(INSTR_STRING); + State = 988; + _localctx.userString = compQstring(); + Actions.EmitStringInstruction(_localctx.op, _localctx.userString.Value); + } + break; + case 13: + EnterOuterAlt(_localctx, 13); { - State = 971; + State = 991; _localctx.op = Match(INSTR_STRING); - State = 972; + State = 992; + Match(ANSI); + State = 993; + Match(T__29); + State = 994; + _localctx.ansiString = compQstring(); + State = 995; + Match(T__30); + Actions.EmitAnsiStringInstruction(_localctx.op, _localctx.ansiString.Value); + } + break; + case 14: + EnterOuterAlt(_localctx, 14); + { + State = 998; + _localctx.op = Match(INSTR_STRING); + State = 999; Match(T__83); - State = 973; + State = 1000; Match(T__29); - State = 974; + State = 1001; _localctx.rawString = bytes(); - State = 975; + State = 1002; Match(T__30); Actions.EmitRawStringInstruction(_localctx.op, _localctx.rawString.Value); } break; - case 11: - EnterOuterAlt(_localctx, 11); + case 15: + EnterOuterAlt(_localctx, 15); { - State = 978; + State = 1005; _localctx.op = Match(INSTR_TOK); - State = 979; + State = 1006; _localctx.rawToken = int32(); Actions.EmitRawTokenInstruction(_localctx.op, (_localctx.rawToken!=null?(_localctx.rawToken.Start):null)); } break; + case 16: + EnterOuterAlt(_localctx, 16); + { + State = 1009; + _localctx.op = Match(INSTR_SWITCH); + Actions.BeginSwitchInstruction(_localctx, _localctx.op); + State = 1016; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case T__29: + { + State = 1011; + Match(T__29); + State = 1012; + labels(); + State = 1013; + Match(T__30); + } + break; + case T__84: + { + State = 1015; + Match(T__84); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; } + Context.Stop = TokenStream.LT(-1); + Actions.CompleteSimpleInstruction(_localctx); } catch (RecognitionException re) { _localctx.exception = re; @@ -4496,19 +4607,13 @@ public SimpleInstrContext simpleInstr() { ErrorHandler.Recover(this, re); } finally { + Actions.EndSwitchInstruction(_localctx); ExitRule(); } return _localctx; } public partial class InstructionIslandContext : ParserRuleContext { - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_R() { return GetToken(CILParser.INSTR_R, 0); } - [System.Diagnostics.DebuggerNonUserCode] public Float64Context float64() { - return GetRuleContext(0); - } - [System.Diagnostics.DebuggerNonUserCode] public Int64Context int64() { - return GetRuleContext(0); - } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_METHOD() { return GetToken(CILParser.INSTR_METHOD, 0); } [System.Diagnostics.DebuggerNonUserCode] public MethodRefContext methodRef() { return GetRuleContext(0); @@ -4524,11 +4629,6 @@ [System.Diagnostics.DebuggerNonUserCode] public MdtokenContext mdtoken() { [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_STRING() { return GetToken(CILParser.INSTR_STRING, 0); } - [System.Diagnostics.DebuggerNonUserCode] public CompQstringContext compQstring() { - return GetRuleContext(0); - } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ANSI() { return GetToken(CILParser.ANSI, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_SIG() { return GetToken(CILParser.INSTR_SIG, 0); } [System.Diagnostics.DebuggerNonUserCode] public CallConvContext callConv() { return GetRuleContext(0); @@ -4543,10 +4643,6 @@ [System.Diagnostics.DebuggerNonUserCode] public SigArgsContext sigArgs() { [System.Diagnostics.DebuggerNonUserCode] public OwnerTypeContext ownerType() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_SWITCH() { return GetToken(CILParser.INSTR_SWITCH, 0); } - [System.Diagnostics.DebuggerNonUserCode] public LabelsContext labels() { - return GetRuleContext(0); - } public InstructionIslandContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { @@ -4566,131 +4662,67 @@ public InstructionIslandContext instructionIsland() { EnterRule(_localctx, 104, RULE_instructionIsland); BeginSubtree(); try { - State = 1018; + State = 1035; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,37,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,38,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 984; - Match(INSTR_R); - State = 985; - float64(); - } - break; - case 2: - EnterOuterAlt(_localctx, 2); - { - State = 986; - Match(INSTR_R); - State = 987; - int64(); - } - break; - case 3: - EnterOuterAlt(_localctx, 3); - { - State = 988; + State = 1020; Match(INSTR_METHOD); - State = 989; + State = 1021; methodRef(); } break; - case 4: - EnterOuterAlt(_localctx, 4); + case 2: + EnterOuterAlt(_localctx, 2); { - State = 990; + State = 1022; Match(INSTR_FIELD); - State = 991; + State = 1023; fieldRef(); } break; - case 5: - EnterOuterAlt(_localctx, 5); + case 3: + EnterOuterAlt(_localctx, 3); { - State = 992; + State = 1024; Match(INSTR_FIELD); - State = 993; + State = 1025; mdtoken(); } break; - case 6: - EnterOuterAlt(_localctx, 6); + case 4: + EnterOuterAlt(_localctx, 4); { - State = 994; + State = 1026; Match(INSTR_TYPE); - State = 995; + State = 1027; typeSpec(); } break; - case 7: - EnterOuterAlt(_localctx, 7); - { - State = 996; - Match(INSTR_STRING); - State = 997; - compQstring(); - } - break; - case 8: - EnterOuterAlt(_localctx, 8); - { - State = 998; - Match(INSTR_STRING); - State = 999; - Match(ANSI); - State = 1000; - Match(T__29); - State = 1001; - compQstring(); - State = 1002; - Match(T__30); - } - break; - case 9: - EnterOuterAlt(_localctx, 9); + case 5: + EnterOuterAlt(_localctx, 5); { - State = 1004; + State = 1028; Match(INSTR_SIG); - State = 1005; + State = 1029; callConv(); - State = 1006; + State = 1030; type(); - State = 1007; + State = 1031; sigArgs(); } break; - case 10: - EnterOuterAlt(_localctx, 10); + case 6: + EnterOuterAlt(_localctx, 6); { - State = 1009; + State = 1033; Match(INSTR_TOK); - State = 1010; + State = 1034; ownerType(); } break; - case 11: - EnterOuterAlt(_localctx, 11); - { - State = 1011; - Match(INSTR_SWITCH); - State = 1012; - Match(T__29); - State = 1013; - labels(); - State = 1014; - Match(T__30); - } - break; - case 12: - EnterOuterAlt(_localctx, 12); - { - State = 1016; - Match(INSTR_SWITCH); - State = 1017; - Match(T__84); - } - break; } Context.Stop = TokenStream.LT(-1); Actions.ProcessInstructionIsland(_localctx); @@ -4708,6 +4740,10 @@ public InstructionIslandContext instructionIsland() { } public partial class LabelsContext : ParserRuleContext { + public IdContext headLabel; + public Int32Context headOffset; + public IdContext tailLabel; + public Int32Context tailOffset; [System.Diagnostics.DebuggerNonUserCode] public IdContext[] id() { return GetRuleContexts(); } @@ -4739,7 +4775,7 @@ public LabelsContext labels() { EnterRule(_localctx, 106, RULE_labels); try { int _alt; - State = 1036; + State = 1061; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__30: @@ -4770,14 +4806,14 @@ public LabelsContext labels() { case ID: EnterOuterAlt(_localctx, 2); { - State = 1029; + State = 1050; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,39,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,40,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1023; + State = 1044; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -4801,29 +4837,31 @@ public LabelsContext labels() { case SQSTRING: case ID: { - State = 1021; - id(); + State = 1038; + _localctx.headLabel = id(); + Actions.AddSwitchLabel((_localctx.headLabel!=null?(_localctx.headLabel.Start):null)); } break; case INT32: { - State = 1022; - int32(); + State = 1041; + _localctx.headOffset = int32(); + Actions.AddSwitchOffset((_localctx.headOffset!=null?(_localctx.headOffset.Start):null)); } break; default: throw new NoViableAltException(this); } - State = 1025; + State = 1046; Match(T__27); } } } - State = 1031; + State = 1052; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,39,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,40,Context); } - State = 1034; + State = 1059; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -4847,14 +4885,16 @@ public LabelsContext labels() { case SQSTRING: case ID: { - State = 1032; - id(); + State = 1053; + _localctx.tailLabel = id(); + Actions.AddSwitchLabel((_localctx.tailLabel!=null?(_localctx.tailLabel.Start):null)); } break; case INT32: { - State = 1033; - int32(); + State = 1056; + _localctx.tailOffset = int32(); + Actions.AddSwitchOffset((_localctx.tailOffset!=null?(_localctx.tailOffset.Start):null)); } break; default: @@ -4905,29 +4945,29 @@ public TypeArgsContext typeArgs() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1038; + State = 1063; Match(T__85); - State = 1044; + State = 1069; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,42,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,43,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1039; + State = 1064; type(); - State = 1040; + State = 1065; Match(T__27); } } } - State = 1046; + State = 1071; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,42,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,43,Context); } - State = 1047; + State = 1072; type(); - State = 1048; + State = 1073; Match(T__86); } } @@ -4970,29 +5010,29 @@ public BoundsContext bounds() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1050; + State = 1075; Match(T__41); - State = 1056; + State = 1081; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,43,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,44,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1051; + State = 1076; bound(); - State = 1052; + State = 1077; Match(T__27); } } } - State = 1058; + State = 1083; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,43,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,44,Context); } - State = 1059; + State = 1084; bound(); - State = 1060; + State = 1085; Match(T__42); } } @@ -5033,42 +5073,42 @@ public SigArgsContext sigArgs() { EnterRule(_localctx, 112, RULE_sigArgs); try { int _alt; - State = 1075; + State = 1100; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__29: EnterOuterAlt(_localctx, 1); { - State = 1062; + State = 1087; Match(T__29); - State = 1068; + State = 1093; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,44,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,45,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1063; + State = 1088; sigArg(); - State = 1064; + State = 1089; Match(T__27); } } } - State = 1070; + State = 1095; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,44,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,45,Context); } - State = 1071; + State = 1096; sigArg(); - State = 1072; + State = 1097; Match(T__30); } break; case T__84: EnterOuterAlt(_localctx, 2); { - State = 1074; + State = 1099; Match(T__84); } break; @@ -5120,31 +5160,31 @@ public SigArgContext sigArg() { EnterRule(_localctx, 114, RULE_sigArg); int _la; try { - State = 1084; + State = 1109; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,47,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,48,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1077; + State = 1102; Match(ELLIPSIS); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1078; + State = 1103; paramAttr(); - State = 1079; + State = 1104; type(); - State = 1080; + State = 1105; marshalClause(); - State = 1082; + State = 1107; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 65534L) != 0) || ((((_la - 199)) & ~0x3f) == 0 && ((1L << (_la - 199)) & 299067162755073L) != 0) || _la==SQSTRING || _la==ID) { { - State = 1081; + State = 1106; id(); } } @@ -5197,95 +5237,95 @@ public ClassNameContext className() { ClassNameContext _localctx = new ClassNameContext(Context, State); EnterRule(_localctx, 116, RULE_className); try { - State = 1111; + State = 1136; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,48,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,49,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1086; + State = 1111; Match(T__41); - State = 1087; + State = 1112; dottedName(); - State = 1088; + State = 1113; Match(T__42); - State = 1089; + State = 1114; slashedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1091; + State = 1116; Match(T__41); - State = 1092; + State = 1117; mdtoken(); - State = 1093; + State = 1118; Match(T__42); - State = 1094; + State = 1119; slashedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1096; + State = 1121; Match(T__41); - State = 1097; + State = 1122; Match(PTR); - State = 1098; + State = 1123; Match(T__42); - State = 1099; + State = 1124; slashedName(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1100; + State = 1125; Match(T__41); - State = 1101; + State = 1126; Match(MODULE); - State = 1102; + State = 1127; dottedName(); - State = 1103; + State = 1128; Match(T__42); - State = 1104; + State = 1129; slashedName(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1106; + State = 1131; slashedName(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1107; + State = 1132; mdtoken(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1108; + State = 1133; Match(THIS); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1109; + State = 1134; Match(BASE); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 1110; + State = 1135; Match(NESTER); } break; @@ -5330,25 +5370,25 @@ public SlashedNameContext slashedName() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1118; + State = 1143; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,49,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,50,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1113; + State = 1138; dottedName(); - State = 1114; + State = 1139; Match(T__87); } } } - State = 1120; + State = 1145; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,49,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,50,Context); } - State = 1121; + State = 1146; dottedName(); } } @@ -5391,17 +5431,17 @@ public AssemblyDeclsContext assemblyDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 1126; + State = 1151; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38654771200L) != 0) || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & 4294975503L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 6860954690125825L) != 0)) { { { - State = 1123; + State = 1148; assemblyDecl(); } } - State = 1128; + State = 1153; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -5447,18 +5487,18 @@ public AssemblyDeclContext assemblyDecl() { AssemblyDeclContext _localctx = new AssemblyDeclContext(Context, State); EnterRule(_localctx, 122, RULE_assemblyDecl); try { - State = 1134; + State = 1159; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case HASH: EnterOuterAlt(_localctx, 1); { { - State = 1129; + State = 1154; Match(HASH); - State = 1130; + State = 1155; Match(T__88); - State = 1131; + State = 1156; int32(); } } @@ -5467,7 +5507,7 @@ public AssemblyDeclContext assemblyDecl() { case PERMISSIONSET: EnterOuterAlt(_localctx, 2); { - State = 1132; + State = 1157; secDecl(); } break; @@ -5492,7 +5532,7 @@ public AssemblyDeclContext assemblyDecl() { case ID: EnterOuterAlt(_localctx, 3); { - State = 1133; + State = 1158; asmOrRefDecl(); } break; @@ -5540,44 +5580,44 @@ public TypeSpecContext typeSpec() { TypeSpecContext _localctx = new TypeSpecContext(Context, State); EnterRule(_localctx, 124, RULE_typeSpec); try { - State = 1147; + State = 1172; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,52,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,53,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1136; + State = 1161; className(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1137; + State = 1162; Match(T__41); - State = 1138; + State = 1163; dottedName(); - State = 1139; + State = 1164; Match(T__42); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1141; + State = 1166; Match(T__41); - State = 1142; + State = 1167; Match(MODULE); - State = 1143; + State = 1168; dottedName(); - State = 1144; + State = 1169; Match(T__42); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1146; + State = 1171; type(); } break; @@ -5623,9 +5663,9 @@ public NativeTypeContext nativeType() { EnterRule(_localctx, 126, RULE_nativeType); try { int _alt; - State = 1157; + State = 1182; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,54,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,55,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -5634,23 +5674,23 @@ public NativeTypeContext nativeType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1150; + State = 1175; nativeTypeElement(); - State = 1154; + State = 1179; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,53,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,54,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1151; + State = 1176; nativeTypeArrayPointerInfo(); } } } - State = 1156; + State = 1181; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,53,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,54,Context); } } break; @@ -5746,14 +5786,14 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { NativeTypeArrayPointerInfoContext _localctx = new NativeTypeArrayPointerInfoContext(Context, State); EnterRule(_localctx, 128, RULE_nativeTypeArrayPointerInfo); try { - State = 1176; + State = 1201; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,55,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,56,Context) ) { case 1: _localctx = new PointerNativeTypeContext(_localctx); EnterOuterAlt(_localctx, 1); { - State = 1159; + State = 1184; Match(PTR); } break; @@ -5761,7 +5801,7 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeNoSizeDataContext(_localctx); EnterOuterAlt(_localctx, 2); { - State = 1160; + State = 1185; Match(ARRAY_TYPE_NO_BOUNDS); } break; @@ -5769,11 +5809,11 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeSizeContext(_localctx); EnterOuterAlt(_localctx, 3); { - State = 1161; + State = 1186; Match(T__41); - State = 1162; + State = 1187; int32(); - State = 1163; + State = 1188; Match(T__42); } break; @@ -5781,15 +5821,15 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeSizeParamIndexContext(_localctx); EnterOuterAlt(_localctx, 4); { - State = 1165; + State = 1190; Match(T__41); - State = 1166; + State = 1191; int32(); - State = 1167; + State = 1192; Match(PLUS); - State = 1168; + State = 1193; int32(); - State = 1169; + State = 1194; Match(T__42); } break; @@ -5797,13 +5837,13 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeParamIndexContext(_localctx); EnterOuterAlt(_localctx, 5); { - State = 1171; + State = 1196; Match(T__41); - State = 1172; + State = 1197; Match(PLUS); - State = 1173; + State = 1198; int32(); - State = 1174; + State = 1199; Match(T__42); } break; @@ -5903,9 +5943,9 @@ public NativeTypeElementContext nativeTypeElement() { NativeTypeElementContext _localctx = new NativeTypeElementContext(Context, State); EnterRule(_localctx, 130, RULE_nativeTypeElement); try { - State = 1270; + State = 1295; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,56,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,57,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -5914,412 +5954,412 @@ public NativeTypeElementContext nativeTypeElement() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1179; + State = 1204; _localctx.marshalType = Match(CUSTOM); - State = 1180; + State = 1205; Match(T__29); - State = 1181; + State = 1206; compQstring(); - State = 1182; + State = 1207; Match(T__27); - State = 1183; + State = 1208; compQstring(); - State = 1184; + State = 1209; Match(T__27); - State = 1185; + State = 1210; compQstring(); - State = 1186; + State = 1211; Match(T__27); - State = 1187; + State = 1212; compQstring(); - State = 1188; + State = 1213; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1190; + State = 1215; _localctx.marshalType = Match(CUSTOM); - State = 1191; + State = 1216; Match(T__29); - State = 1192; + State = 1217; compQstring(); - State = 1193; + State = 1218; Match(T__27); - State = 1194; + State = 1219; compQstring(); - State = 1195; + State = 1220; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1197; + State = 1222; Match(FIXED); - State = 1198; + State = 1223; _localctx.marshalType = Match(SYSSTRING); - State = 1199; + State = 1224; Match(T__41); - State = 1200; + State = 1225; int32(); - State = 1201; + State = 1226; Match(T__42); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1203; + State = 1228; Match(FIXED); - State = 1204; + State = 1229; _localctx.marshalType = Match(ARRAY); - State = 1205; + State = 1230; Match(T__41); - State = 1206; + State = 1231; int32(); - State = 1207; + State = 1232; Match(T__42); - State = 1208; + State = 1233; nativeType(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1210; + State = 1235; _localctx.marshalType = Match(VARIANT); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1211; + State = 1236; _localctx.marshalType = Match(CURRENCY); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1212; + State = 1237; _localctx.marshalType = Match(SYSCHAR); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 1213; + State = 1238; _localctx.marshalType = Match(VOID); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 1214; + State = 1239; _localctx.marshalType = Match(BOOL); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 1215; + State = 1240; _localctx.marshalType = Match(INT8); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 1216; + State = 1241; _localctx.marshalType = Match(INT16); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 1217; + State = 1242; _localctx.marshalType = Match(INT32_); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 1218; + State = 1243; _localctx.marshalType = Match(INT64_); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 1219; + State = 1244; _localctx.marshalType = Match(FLOAT32); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 1220; + State = 1245; _localctx.marshalType = Match(FLOAT64_); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 1221; + State = 1246; _localctx.marshalType = Match(ERROR); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 1222; + State = 1247; _localctx.marshalType = Match(UINT8); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 1223; + State = 1248; _localctx.marshalType = Match(UINT16); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 1224; + State = 1249; _localctx.marshalType = Match(UINT32); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 1225; + State = 1250; _localctx.marshalType = Match(UINT64); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 1226; + State = 1251; _localctx.marshalType = Match(DECIMAL); } break; case 23: EnterOuterAlt(_localctx, 23); { - State = 1227; + State = 1252; _localctx.marshalType = Match(DATE); } break; case 24: EnterOuterAlt(_localctx, 24); { - State = 1228; + State = 1253; _localctx.marshalType = Match(BSTR); } break; case 25: EnterOuterAlt(_localctx, 25); { - State = 1229; + State = 1254; _localctx.marshalType = Match(LPSTR); } break; case 26: EnterOuterAlt(_localctx, 26); { - State = 1230; + State = 1255; _localctx.marshalType = Match(LPWSTR); } break; case 27: EnterOuterAlt(_localctx, 27); { - State = 1231; + State = 1256; _localctx.marshalType = Match(LPTSTR); } break; case 28: EnterOuterAlt(_localctx, 28); { - State = 1232; + State = 1257; _localctx.marshalType = Match(OBJECTREF); } break; case 29: EnterOuterAlt(_localctx, 29); { - State = 1233; + State = 1258; _localctx.marshalType = Match(IUNKNOWN); - State = 1234; + State = 1259; iidParamIndex(); } break; case 30: EnterOuterAlt(_localctx, 30); { - State = 1235; + State = 1260; _localctx.marshalType = Match(IDISPATCH); - State = 1236; + State = 1261; iidParamIndex(); } break; case 31: EnterOuterAlt(_localctx, 31); { - State = 1237; + State = 1262; _localctx.marshalType = Match(STRUCT); } break; case 32: EnterOuterAlt(_localctx, 32); { - State = 1238; + State = 1263; _localctx.marshalType = Match(INTERFACE); - State = 1239; + State = 1264; iidParamIndex(); } break; case 33: EnterOuterAlt(_localctx, 33); { - State = 1240; + State = 1265; _localctx.marshalType = Match(SAFEARRAY); - State = 1241; + State = 1266; variantType(); } break; case 34: EnterOuterAlt(_localctx, 34); { - State = 1242; + State = 1267; _localctx.marshalType = Match(SAFEARRAY); - State = 1243; + State = 1268; variantType(); - State = 1244; + State = 1269; Match(T__27); - State = 1245; + State = 1270; compQstring(); } break; case 35: EnterOuterAlt(_localctx, 35); { - State = 1247; + State = 1272; _localctx.marshalType = Match(INT); } break; case 36: EnterOuterAlt(_localctx, 36); { - State = 1248; + State = 1273; _localctx.marshalType = Match(UINT); } break; case 37: EnterOuterAlt(_localctx, 37); { - State = 1249; + State = 1274; Match(T__89); - State = 1250; + State = 1275; _localctx.unsignedMarshalType = Match(INT8); } break; case 38: EnterOuterAlt(_localctx, 38); { - State = 1251; + State = 1276; Match(T__89); - State = 1252; + State = 1277; _localctx.unsignedMarshalType = Match(INT16); } break; case 39: EnterOuterAlt(_localctx, 39); { - State = 1253; + State = 1278; Match(T__89); - State = 1254; + State = 1279; _localctx.unsignedMarshalType = Match(INT32_); } break; case 40: EnterOuterAlt(_localctx, 40); { - State = 1255; + State = 1280; Match(T__89); - State = 1256; + State = 1281; _localctx.unsignedMarshalType = Match(INT64_); } break; case 41: EnterOuterAlt(_localctx, 41); { - State = 1257; + State = 1282; Match(T__61); - State = 1258; + State = 1283; _localctx.marshalType = Match(STRUCT); } break; case 42: EnterOuterAlt(_localctx, 42); { - State = 1259; + State = 1284; _localctx.marshalType = Match(BYVALSTR); } break; case 43: EnterOuterAlt(_localctx, 43); { - State = 1260; + State = 1285; Match(ANSI); - State = 1261; + State = 1286; _localctx.marshalType = Match(BSTR); } break; case 44: EnterOuterAlt(_localctx, 44); { - State = 1262; + State = 1287; _localctx.marshalType = Match(TBSTR); } break; case 45: EnterOuterAlt(_localctx, 45); { - State = 1263; + State = 1288; Match(VARIANT); - State = 1264; + State = 1289; _localctx.marshalBool = Match(BOOL); } break; case 46: EnterOuterAlt(_localctx, 46); { - State = 1265; + State = 1290; _localctx.marshalType = Match(METHOD); } break; case 47: EnterOuterAlt(_localctx, 47); { - State = 1266; + State = 1291; _localctx.marshalType = Match(LPSTRUCT); } break; case 48: EnterOuterAlt(_localctx, 48); { - State = 1267; + State = 1292; Match(T__33); - State = 1268; + State = 1293; _localctx.marshalType = Match(ANY); } break; case 49: EnterOuterAlt(_localctx, 49); { - State = 1269; + State = 1294; dottedName(); } break; @@ -6358,7 +6398,7 @@ public IidParamIndexContext iidParamIndex() { IidParamIndexContext _localctx = new IidParamIndexContext(Context, State); EnterRule(_localctx, 132, RULE_iidParamIndex); try { - State = 1279; + State = 1304; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__30: @@ -6372,15 +6412,15 @@ public IidParamIndexContext iidParamIndex() { case T__29: EnterOuterAlt(_localctx, 2); { - State = 1273; + State = 1298; Match(T__29); - State = 1274; + State = 1299; Match(T__90); - State = 1275; + State = 1300; Match(T__35); - State = 1276; + State = 1301; int32(); - State = 1277; + State = 1302; Match(T__30); } break; @@ -6435,9 +6475,9 @@ public VariantTypeContext variantType() { int _la; try { int _alt; - State = 1289; + State = 1314; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,59,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,60,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -6446,16 +6486,16 @@ public VariantTypeContext variantType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1282; + State = 1307; variantTypeElement(); - State = 1286; + State = 1311; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,58,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,59,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1283; + State = 1308; _la = TokenStream.LA(1); if ( !(((((_la - 229)) & ~0x3f) == 0 && ((1L << (_la - 229)) & 6442450945L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -6467,9 +6507,9 @@ public VariantTypeContext variantType() { } } } - State = 1288; + State = 1313; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,58,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,59,Context); } } break; @@ -6548,7 +6588,7 @@ public VariantTypeElementContext variantTypeElement() { try { EnterOuterAlt(_localctx, 1); { - State = 1291; + State = 1316; _la = TokenStream.LA(1); if ( !(((((_la - 178)) & ~0x3f) == 0 && ((1L << (_la - 178)) & -4482436704239647L) != 0) || _la==CLSID || _la==PTR) ) { ErrorHandler.RecoverInline(this); @@ -6601,23 +6641,23 @@ public TypeContext type() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1293; + State = 1318; elementType(); - State = 1297; + State = 1322; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,60,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,61,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1294; + State = 1319; typeModifiers(); } } } - State = 1299; + State = 1324; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,60,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,61,Context); } } } @@ -6737,14 +6777,14 @@ public TypeModifiersContext typeModifiers() { TypeModifiersContext _localctx = new TypeModifiersContext(Context, State); EnterRule(_localctx, 140, RULE_typeModifiers); try { - State = 1318; + State = 1343; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,61,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,62,Context) ) { case 1: _localctx = new SZArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 1); { - State = 1300; + State = 1325; Match(ARRAY_TYPE_NO_BOUNDS); } break; @@ -6752,9 +6792,9 @@ public TypeModifiersContext typeModifiers() { _localctx = new SZArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 2); { - State = 1301; + State = 1326; Match(T__41); - State = 1302; + State = 1327; Match(T__42); } break; @@ -6762,7 +6802,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new ArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 3); { - State = 1303; + State = 1328; bounds(); } break; @@ -6770,7 +6810,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new ByRefModifierContext(_localctx); EnterOuterAlt(_localctx, 4); { - State = 1304; + State = 1329; Match(REF); } break; @@ -6778,7 +6818,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new PtrModifierContext(_localctx); EnterOuterAlt(_localctx, 5); { - State = 1305; + State = 1330; Match(PTR); } break; @@ -6786,7 +6826,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new PinnedModifierContext(_localctx); EnterOuterAlt(_localctx, 6); { - State = 1306; + State = 1331; Match(T__91); } break; @@ -6794,13 +6834,13 @@ public TypeModifiersContext typeModifiers() { _localctx = new RequiredModifierContext(_localctx); EnterOuterAlt(_localctx, 7); { - State = 1307; + State = 1332; Match(T__92); - State = 1308; + State = 1333; Match(T__29); - State = 1309; + State = 1334; typeSpec(); - State = 1310; + State = 1335; Match(T__30); } break; @@ -6808,13 +6848,13 @@ public TypeModifiersContext typeModifiers() { _localctx = new OptionalModifierContext(_localctx); EnterOuterAlt(_localctx, 8); { - State = 1312; + State = 1337; Match(T__93); - State = 1313; + State = 1338; Match(T__29); - State = 1314; + State = 1339; typeSpec(); - State = 1315; + State = 1340; Match(T__30); } break; @@ -6822,7 +6862,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new GenericArgumentsModifierContext(_localctx); EnterOuterAlt(_localctx, 9); { - State = 1317; + State = 1342; typeArgs(); } break; @@ -6895,144 +6935,144 @@ public ElementTypeContext elementType() { ElementTypeContext _localctx = new ElementTypeContext(Context, State); EnterRule(_localctx, 142, RULE_elementType); try { - State = 1350; + State = 1375; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,62,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,63,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1320; + State = 1345; Match(T__38); - State = 1321; + State = 1346; className(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1322; + State = 1347; Match(OBJECT); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1323; + State = 1348; Match(VALUE); - State = 1324; + State = 1349; Match(T__38); - State = 1325; + State = 1350; className(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1326; + State = 1351; Match(VALUETYPE); - State = 1327; + State = 1352; className(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1328; + State = 1353; Match(METHOD); - State = 1329; + State = 1354; callConv(); - State = 1330; + State = 1355; type(); - State = 1331; + State = 1356; Match(PTR); - State = 1332; + State = 1357; sigArgs(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1334; + State = 1359; Match(METHOD_TYPE_PARAMETER); - State = 1335; + State = 1360; int32(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1336; + State = 1361; Match(TYPE_PARAMETER); - State = 1337; + State = 1362; int32(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1338; + State = 1363; Match(METHOD_TYPE_PARAMETER); - State = 1339; + State = 1364; dottedName(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 1340; + State = 1365; Match(TYPE_PARAMETER); - State = 1341; + State = 1366; dottedName(); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 1342; + State = 1367; Match(TYPEDREF); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 1343; + State = 1368; Match(VOID); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 1344; + State = 1369; nativeInt(); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 1345; + State = 1370; nativeUint(); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 1346; + State = 1371; simpleType(); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 1347; + State = 1372; dottedName(); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 1348; + State = 1373; Match(ELLIPSIS); - State = 1349; + State = 1374; type(); } break; @@ -7081,133 +7121,133 @@ public SimpleTypeContext simpleType() { SimpleTypeContext _localctx = new SimpleTypeContext(Context, State); EnterRule(_localctx, 144, RULE_simpleType); try { - State = 1373; + State = 1398; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,63,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,64,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1352; + State = 1377; Match(CHAR); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1353; + State = 1378; Match(STRING); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1354; + State = 1379; Match(BOOL); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1355; + State = 1380; Match(INT8); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1356; + State = 1381; Match(INT16); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1357; + State = 1382; Match(INT32_); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1358; + State = 1383; Match(INT64_); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1359; + State = 1384; Match(FLOAT32); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 1360; + State = 1385; Match(FLOAT64_); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 1361; + State = 1386; Match(UINT8); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 1362; + State = 1387; Match(UINT16); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 1363; + State = 1388; Match(UINT32); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 1364; + State = 1389; Match(UINT64); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 1365; + State = 1390; Match(T__89); - State = 1366; + State = 1391; Match(INT8); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 1367; + State = 1392; Match(T__89); - State = 1368; + State = 1393; Match(INT16); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 1369; + State = 1394; Match(T__89); - State = 1370; + State = 1395; Match(INT32_); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 1371; + State = 1396; Match(T__89); - State = 1372; + State = 1397; Match(INT64_); } break; @@ -7250,9 +7290,9 @@ public BoundContext bound() { BoundContext _localctx = new BoundContext(Context, State); EnterRule(_localctx, 146, RULE_bound); try { - State = 1385; + State = 1410; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,64,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,65,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -7261,34 +7301,34 @@ public BoundContext bound() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1376; + State = 1401; Match(ELLIPSIS); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1377; + State = 1402; int32(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1378; + State = 1403; int32(); - State = 1379; + State = 1404; Match(ELLIPSIS); - State = 1380; + State = 1405; int32(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1382; + State = 1407; int32(); - State = 1383; + State = 1408; Match(ELLIPSIS); } break; @@ -7327,9 +7367,9 @@ public NativeIntContext nativeInt() { try { EnterOuterAlt(_localctx, 1); { - State = 1387; + State = 1412; Match(T__0); - State = 1388; + State = 1413; Match(INT); } } @@ -7367,22 +7407,22 @@ public NativeUintContext nativeUint() { try { EnterOuterAlt(_localctx, 1); { - State = 1390; + State = 1415; Match(T__0); - State = 1394; + State = 1419; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__89: { - State = 1391; + State = 1416; Match(T__89); - State = 1392; + State = 1417; Match(INT); } break; case UINT: { - State = 1393; + State = 1418; Match(UINT); } break; @@ -7445,125 +7485,125 @@ public SecDeclContext secDecl() { EnterRule(_localctx, 152, RULE_secDecl); int _la; try { - State = 1443; + State = 1468; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,67,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,68,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1396; + State = 1421; Match(PERMISSION); - State = 1397; + State = 1422; secAction(); - State = 1398; + State = 1423; typeSpec(); - State = 1399; + State = 1424; Match(T__29); - State = 1400; + State = 1425; nameValPairs(); - State = 1401; + State = 1426; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1403; + State = 1428; Match(PERMISSION); - State = 1404; + State = 1429; secAction(); - State = 1405; + State = 1430; typeSpec(); - State = 1406; + State = 1431; Match(T__35); - State = 1407; + State = 1432; Match(T__16); - State = 1408; + State = 1433; customBlobDescr(); - State = 1409; + State = 1434; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1411; + State = 1436; Match(PERMISSION); - State = 1412; + State = 1437; secAction(); - State = 1413; + State = 1438; typeSpec(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1415; + State = 1440; Match(PERMISSIONSET); - State = 1416; + State = 1441; secAction(); - State = 1417; + State = 1442; Match(T__35); - State = 1419; + State = 1444; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__83) { { - State = 1418; + State = 1443; Match(T__83); } } - State = 1421; + State = 1446; Match(T__29); - State = 1422; + State = 1447; bytes(); - State = 1423; + State = 1448; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1425; + State = 1450; Match(PERMISSIONSET); - State = 1426; + State = 1451; secAction(); - State = 1427; + State = 1452; Match(T__83); - State = 1428; + State = 1453; Match(T__29); - State = 1429; + State = 1454; bytes(); - State = 1430; + State = 1455; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1432; + State = 1457; Match(PERMISSIONSET); - State = 1433; + State = 1458; secAction(); - State = 1434; + State = 1459; compQstring(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1436; + State = 1461; Match(PERMISSIONSET); - State = 1437; + State = 1462; secAction(); - State = 1438; + State = 1463; Match(T__35); - State = 1439; + State = 1464; Match(T__16); - State = 1440; + State = 1465; secAttrSetBlob(); - State = 1441; + State = 1466; Match(T__17); } break; @@ -7606,7 +7646,7 @@ public SecAttrSetBlobContext secAttrSetBlob() { EnterRule(_localctx, 154, RULE_secAttrSetBlob); try { int _alt; - State = 1455; + State = 1480; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__17: @@ -7651,25 +7691,25 @@ public SecAttrSetBlobContext secAttrSetBlob() { case ID: EnterOuterAlt(_localctx, 2); { - State = 1451; + State = 1476; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,68,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,69,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1446; + State = 1471; secAttrBlob(); - State = 1447; + State = 1472; Match(T__27); } } } - State = 1453; + State = 1478; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,68,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,69,Context); } - State = 1454; + State = 1479; secAttrBlob(); } break; @@ -7714,38 +7754,38 @@ public SecAttrBlobContext secAttrBlob() { SecAttrBlobContext _localctx = new SecAttrBlobContext(Context, State); EnterRule(_localctx, 156, RULE_secAttrBlob); try { - State = 1470; + State = 1495; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,70,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,71,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1457; + State = 1482; Match(T__38); - State = 1458; + State = 1483; Match(SQSTRING); - State = 1459; + State = 1484; Match(T__35); - State = 1460; + State = 1485; Match(T__16); - State = 1461; + State = 1486; customBlobNVPairs(); - State = 1462; + State = 1487; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1464; + State = 1489; typeSpec(); - State = 1465; + State = 1490; Match(T__35); - State = 1466; + State = 1491; Match(T__16); - State = 1467; + State = 1492; customBlobNVPairs(); - State = 1468; + State = 1493; Match(T__17); } break; @@ -7790,25 +7830,25 @@ public NameValPairsContext nameValPairs() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1477; + State = 1502; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,71,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,72,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1472; + State = 1497; nameValPair(); - State = 1473; + State = 1498; Match(T__27); } } } - State = 1479; + State = 1504; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,71,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,72,Context); } - State = 1480; + State = 1505; nameValPair(); } } @@ -7850,11 +7890,11 @@ public NameValPairContext nameValPair() { try { EnterOuterAlt(_localctx, 1); { - State = 1482; + State = 1507; compQstring(); - State = 1483; + State = 1508; Match(T__35); - State = 1484; + State = 1509; caValue(); } } @@ -7891,7 +7931,7 @@ public TruefalseContext truefalse() { try { EnterOuterAlt(_localctx, 1); { - State = 1486; + State = 1511; _la = TokenStream.LA(1); if ( !(_la==T__94 || _la==T__95) ) { ErrorHandler.RecoverInline(this); @@ -7947,104 +7987,104 @@ public CaValueContext caValue() { CaValueContext _localctx = new CaValueContext(Context, State); EnterRule(_localctx, 164, RULE_caValue); try { - State = 1522; + State = 1547; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,72,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,73,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1488; + State = 1513; truefalse(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1489; + State = 1514; int32(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1490; + State = 1515; Match(INT32_); - State = 1491; + State = 1516; Match(T__29); - State = 1492; + State = 1517; int32(); - State = 1493; + State = 1518; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1495; + State = 1520; compQstring(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1496; + State = 1521; className(); - State = 1497; + State = 1522; Match(T__29); - State = 1498; + State = 1523; Match(INT8); - State = 1499; + State = 1524; Match(T__74); - State = 1500; + State = 1525; int32(); - State = 1501; + State = 1526; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1503; + State = 1528; className(); - State = 1504; + State = 1529; Match(T__29); - State = 1505; + State = 1530; Match(INT16); - State = 1506; + State = 1531; Match(T__74); - State = 1507; + State = 1532; int32(); - State = 1508; + State = 1533; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1510; + State = 1535; className(); - State = 1511; + State = 1536; Match(T__29); - State = 1512; + State = 1537; Match(INT32_); - State = 1513; + State = 1538; Match(T__74); - State = 1514; + State = 1539; int32(); - State = 1515; + State = 1540; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1517; + State = 1542; className(); - State = 1518; + State = 1543; Match(T__29); - State = 1519; + State = 1544; int32(); - State = 1520; + State = 1545; Match(T__30); } break; @@ -8083,7 +8123,7 @@ public SecActionContext secAction() { try { EnterOuterAlt(_localctx, 1); { - State = 1524; + State = 1549; _la = TokenStream.LA(1); if ( !(((((_la - 97)) & ~0x3f) == 0 && ((1L << (_la - 97)) & 32767L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -8153,104 +8193,104 @@ public MethodRefContext methodRef() { EnterRule(_localctx, 168, RULE_methodRef); int _la; try { - State = 1560; + State = 1585; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,75,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,76,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1526; + State = 1551; callConv(); - State = 1527; + State = 1552; type(); - State = 1528; + State = 1553; typeSpec(); - State = 1529; + State = 1554; Match(DCOLON); - State = 1530; + State = 1555; methodName(); - State = 1532; + State = 1557; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 1531; + State = 1556; typeArgs(); } } - State = 1534; + State = 1559; sigArgs(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1536; + State = 1561; callConv(); - State = 1537; + State = 1562; type(); - State = 1538; + State = 1563; typeSpec(); - State = 1539; + State = 1564; Match(DCOLON); - State = 1540; + State = 1565; methodName(); - State = 1541; + State = 1566; genArityNotEmpty(); - State = 1542; + State = 1567; sigArgs(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1544; + State = 1569; callConv(); - State = 1545; + State = 1570; type(); - State = 1546; + State = 1571; methodName(); - State = 1548; + State = 1573; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 1547; + State = 1572; typeArgs(); } } - State = 1550; + State = 1575; sigArgs(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1552; + State = 1577; callConv(); - State = 1553; + State = 1578; type(); - State = 1554; + State = 1579; methodName(); - State = 1555; + State = 1580; genArityNotEmpty(); - State = 1556; + State = 1581; sigArgs(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1558; + State = 1583; mdtoken(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1559; + State = 1584; dottedName(); } break; @@ -8297,44 +8337,44 @@ public CallConvContext callConv() { CallConvContext _localctx = new CallConvContext(Context, State); EnterRule(_localctx, 170, RULE_callConv); try { - State = 1572; + State = 1597; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,76,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,77,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1562; + State = 1587; Match(INSTANCE); - State = 1563; + State = 1588; callConv(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1564; + State = 1589; Match(EXPLICIT); - State = 1565; + State = 1590; callConv(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1566; + State = 1591; callKind(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1567; + State = 1592; Match(T__111); - State = 1568; + State = 1593; Match(T__29); - State = 1569; + State = 1594; int32(); - State = 1570; + State = 1595; Match(T__30); } break; @@ -8377,9 +8417,9 @@ public CallKindContext callKind() { CallKindContext _localctx = new CallKindContext(Context, State); EnterRule(_localctx, 172, RULE_callKind); try { - State = 1586; + State = 1611; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,77,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,78,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -8388,57 +8428,57 @@ public CallKindContext callKind() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1575; + State = 1600; Match(DEFAULT); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1576; + State = 1601; Match(VARARG); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1577; + State = 1602; Match(UNMANAGED); - State = 1578; + State = 1603; Match(CDECL); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1579; + State = 1604; Match(UNMANAGED); - State = 1580; + State = 1605; Match(STDCALL); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1581; + State = 1606; Match(UNMANAGED); - State = 1582; + State = 1607; Match(THISCALL); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1583; + State = 1608; Match(UNMANAGED); - State = 1584; + State = 1609; Match(FASTCALL); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1585; + State = 1610; Match(UNMANAGED); } break; @@ -8479,13 +8519,13 @@ public MdtokenContext mdtoken() { try { EnterOuterAlt(_localctx, 1); { - State = 1588; + State = 1613; Match(T__112); - State = 1589; + State = 1614; Match(T__29); - State = 1590; + State = 1615; int32(); - State = 1591; + State = 1616; Match(T__30); } } @@ -8529,31 +8569,31 @@ public MemberRefContext memberRef() { MemberRefContext _localctx = new MemberRefContext(Context, State); EnterRule(_localctx, 176, RULE_memberRef); try { - State = 1598; + State = 1623; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case METHOD: EnterOuterAlt(_localctx, 1); { - State = 1593; + State = 1618; Match(METHOD); - State = 1594; + State = 1619; methodRef(); } break; case T__36: EnterOuterAlt(_localctx, 2); { - State = 1595; + State = 1620; Match(T__36); - State = 1596; + State = 1621; fieldRef(); } break; case T__112: EnterOuterAlt(_localctx, 3); { - State = 1597; + State = 1622; mdtoken(); } break; @@ -8601,35 +8641,35 @@ public FieldRefContext fieldRef() { FieldRefContext _localctx = new FieldRefContext(Context, State); EnterRule(_localctx, 178, RULE_fieldRef); try { - State = 1609; + State = 1634; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,79,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,80,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1600; + State = 1625; type(); - State = 1601; + State = 1626; typeSpec(); - State = 1602; + State = 1627; Match(DCOLON); - State = 1603; + State = 1628; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1605; + State = 1630; type(); - State = 1606; + State = 1631; dottedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1608; + State = 1633; dottedName(); } break; @@ -8674,25 +8714,25 @@ public TypeListContext typeList() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1616; + State = 1641; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,80,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,81,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1611; + State = 1636; typeSpec(); - State = 1612; + State = 1637; Match(T__27); } } } - State = 1618; + State = 1643; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,80,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,81,Context); } - State = 1619; + State = 1644; typeSpec(); } } @@ -8729,7 +8769,7 @@ public TyparsClauseContext typarsClause() { TyparsClauseContext _localctx = new TyparsClauseContext(Context, State); EnterRule(_localctx, 182, RULE_typarsClause); try { - State = 1626; + State = 1651; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -8744,11 +8784,11 @@ public TyparsClauseContext typarsClause() { case T__85: EnterOuterAlt(_localctx, 2); { - State = 1622; + State = 1647; Match(T__85); - State = 1623; + State = 1648; typars(); - State = 1624; + State = 1649; Match(T__86); } break; @@ -8798,61 +8838,61 @@ public TyparAttribContext typarAttrib() { TyparAttribContext _localctx = new TyparAttribContext(Context, State); EnterRule(_localctx, 184, RULE_typarAttrib); try { - State = 1639; + State = 1664; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case PLUS: EnterOuterAlt(_localctx, 1); { - State = 1628; + State = 1653; _localctx.covariant = Match(PLUS); } break; case T__113: EnterOuterAlt(_localctx, 2); { - State = 1629; + State = 1654; _localctx.contravariant = Match(T__113); } break; case T__38: EnterOuterAlt(_localctx, 3); { - State = 1630; + State = 1655; _localctx.@class = Match(T__38); } break; case VALUETYPE: EnterOuterAlt(_localctx, 4); { - State = 1631; + State = 1656; _localctx.valuetype = Match(VALUETYPE); } break; case T__114: EnterOuterAlt(_localctx, 5); { - State = 1632; + State = 1657; _localctx.byrefLike = Match(T__114); } break; case T__115: EnterOuterAlt(_localctx, 6); { - State = 1633; + State = 1658; _localctx.ctor = Match(T__115); } break; case T__69: EnterOuterAlt(_localctx, 7); { - State = 1634; + State = 1659; Match(T__69); - State = 1635; + State = 1660; Match(T__29); - State = 1636; + State = 1661; _localctx.flags = int32(); - State = 1637; + State = 1662; Match(T__30); } break; @@ -8899,17 +8939,17 @@ public TyparAttribsContext typarAttribs() { try { EnterOuterAlt(_localctx, 1); { - State = 1644; + State = 1669; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__38 || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & 123145302310913L) != 0) || _la==VALUETYPE || _la==PLUS) { { { - State = 1641; + State = 1666; typarAttrib(); } } - State = 1646; + State = 1671; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -8957,19 +8997,19 @@ public TyparContext typar() { try { EnterOuterAlt(_localctx, 1); { - State = 1647; + State = 1672; typarAttribs(); - State = 1649; + State = 1674; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__29) { { - State = 1648; + State = 1673; tyBound(); } } - State = 1651; + State = 1676; dottedName(); } } @@ -9012,25 +9052,25 @@ public TyparsContext typars() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1658; + State = 1683; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,85,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,86,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1653; + State = 1678; typar(); - State = 1654; + State = 1679; Match(T__27); } } } - State = 1660; + State = 1685; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,85,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,86,Context); } - State = 1661; + State = 1686; typar(); } } @@ -9069,11 +9109,11 @@ public TyBoundContext tyBound() { try { EnterOuterAlt(_localctx, 1); { - State = 1663; + State = 1688; Match(T__29); - State = 1664; + State = 1689; typeList(); - State = 1665; + State = 1690; Match(T__30); } } @@ -9110,7 +9150,7 @@ public GenArityContext genArity() { GenArityContext _localctx = new GenArityContext(Context, State); EnterRule(_localctx, 194, RULE_genArity); try { - State = 1669; + State = 1694; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__29: @@ -9122,7 +9162,7 @@ public GenArityContext genArity() { case T__85: EnterOuterAlt(_localctx, 2); { - State = 1668; + State = 1693; genArityNotEmpty(); } break; @@ -9165,15 +9205,15 @@ public GenArityNotEmptyContext genArityNotEmpty() { try { EnterOuterAlt(_localctx, 1); { - State = 1671; + State = 1696; Match(T__85); - State = 1672; + State = 1697; Match(T__41); - State = 1673; + State = 1698; int32(); - State = 1674; + State = 1699; Match(T__42); - State = 1675; + State = 1700; Match(T__86); } } @@ -9320,343 +9360,343 @@ public ClassDeclContext classDecl() { BeginSubtree(); try { int _alt; - State = 1793; + State = 1818; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,91,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,92,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1677; + State = 1702; methodHead(); - State = 1678; + State = 1703; Match(T__16); - State = 1679; + State = 1704; methodDecls(); - State = 1680; + State = 1705; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1682; + State = 1707; classHead(); - State = 1683; + State = 1708; Match(T__16); - State = 1684; + State = 1709; classDecls(); - State = 1685; + State = 1710; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1687; + State = 1712; eventHead(); - State = 1688; + State = 1713; Match(T__16); - State = 1689; + State = 1714; eventDecls(); - State = 1690; + State = 1715; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1692; + State = 1717; propHead(); - State = 1693; + State = 1718; Match(T__16); - State = 1694; + State = 1719; propDecls(); - State = 1695; + State = 1720; Match(T__17); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1697; + State = 1722; fieldDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1698; + State = 1723; dataDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1699; + State = 1724; secDecl(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1700; + State = 1725; extSourceSpec(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 1701; + State = 1726; customAttrDecl(); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 1702; + State = 1727; Match(T__116); - State = 1703; + State = 1728; int32(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 1704; + State = 1729; Match(T__117); - State = 1705; + State = 1730; int32(); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 1706; + State = 1731; exportHead(); - State = 1707; + State = 1732; Match(T__16); - State = 1708; + State = 1733; exptypeDecls(); - State = 1709; + State = 1734; Match(T__17); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 1711; + State = 1736; Match(OVERRIDE); - State = 1712; + State = 1737; typeSpec(); - State = 1713; + State = 1738; Match(DCOLON); - State = 1714; + State = 1739; methodName(); - State = 1715; + State = 1740; Match(T__118); - State = 1716; + State = 1741; callConv(); - State = 1717; + State = 1742; type(); - State = 1718; + State = 1743; typeSpec(); - State = 1719; + State = 1744; Match(DCOLON); - State = 1720; + State = 1745; methodName(); - State = 1721; + State = 1746; sigArgs(); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 1723; + State = 1748; Match(OVERRIDE); - State = 1724; + State = 1749; Match(METHOD); - State = 1725; + State = 1750; callConv(); - State = 1726; + State = 1751; type(); - State = 1727; + State = 1752; typeSpec(); - State = 1728; + State = 1753; Match(DCOLON); - State = 1729; + State = 1754; methodName(); - State = 1730; + State = 1755; genArity(); - State = 1731; + State = 1756; sigArgs(); - State = 1732; + State = 1757; Match(T__118); - State = 1733; + State = 1758; Match(METHOD); - State = 1734; + State = 1759; callConv(); - State = 1735; + State = 1760; type(); - State = 1736; + State = 1761; typeSpec(); - State = 1737; + State = 1762; Match(DCOLON); - State = 1738; + State = 1763; methodName(); - State = 1739; + State = 1764; genArity(); - State = 1740; + State = 1765; sigArgs(); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 1742; + State = 1767; languageDecl(); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 1743; + State = 1768; compControl(); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 1744; + State = 1769; Match(PARAM); - State = 1745; + State = 1770; Match(TYPE); - State = 1746; + State = 1771; Match(T__41); - State = 1747; + State = 1772; int32(); - State = 1748; + State = 1773; Match(T__42); - State = 1752; + State = 1777; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,87,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1749; + State = 1774; customAttrDecl(); } } } - State = 1754; + State = 1779; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,87,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); } } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 1755; + State = 1780; Match(PARAM); - State = 1756; + State = 1781; Match(TYPE); - State = 1757; + State = 1782; dottedName(); - State = 1761; + State = 1786; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1758; + State = 1783; customAttrDecl(); } } } - State = 1763; + State = 1788; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); } } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 1764; + State = 1789; Match(PARAM); - State = 1765; + State = 1790; Match(CONSTRAINT); - State = 1766; + State = 1791; Match(T__41); - State = 1767; + State = 1792; int32(); - State = 1768; + State = 1793; Match(T__42); - State = 1769; + State = 1794; Match(T__27); - State = 1770; + State = 1795; typeSpec(); - State = 1774; + State = 1799; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1771; + State = 1796; customAttrDecl(); } } } - State = 1776; + State = 1801; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); } } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 1777; + State = 1802; Match(PARAM); - State = 1778; + State = 1803; Match(CONSTRAINT); - State = 1779; + State = 1804; dottedName(); - State = 1780; + State = 1805; Match(T__27); - State = 1781; + State = 1806; typeSpec(); - State = 1785; + State = 1810; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1782; + State = 1807; customAttrDecl(); } } } - State = 1787; + State = 1812; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); } } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 1788; + State = 1813; Match(T__119); - State = 1789; + State = 1814; Match(TYPE); - State = 1790; + State = 1815; typeSpec(); - State = 1791; + State = 1816; customDescr(); } break; @@ -9725,17 +9765,17 @@ public FieldDeclContext fieldDecl() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1795; + State = 1820; Match(T__120); - State = 1796; + State = 1821; repeatOpt(); - State = 1805; + State = 1830; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,93,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,94,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { - State = 1803; + State = 1828; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -9754,19 +9794,19 @@ public FieldDeclContext fieldDecl() { case T__125: case T__126: { - State = 1797; + State = 1822; fieldAttr(); } break; case T__121: { - State = 1798; + State = 1823; Match(T__121); - State = 1799; + State = 1824; Match(T__29); - State = 1800; + State = 1825; marshalBlob(); - State = 1801; + State = 1826; Match(T__30); } break; @@ -9775,17 +9815,17 @@ public FieldDeclContext fieldDecl() { } } } - State = 1807; + State = 1832; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,93,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,94,Context); } - State = 1808; + State = 1833; type(); - State = 1809; + State = 1834; dottedName(); - State = 1810; + State = 1835; atOpt(); - State = 1811; + State = 1836; initOpt(); } } @@ -9822,117 +9862,117 @@ public FieldAttrContext fieldAttr() { FieldAttrContext _localctx = new FieldAttrContext(Context, State); EnterRule(_localctx, 202, RULE_fieldAttr); try { - State = 1832; + State = 1857; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__122: EnterOuterAlt(_localctx, 1); { - State = 1813; + State = 1838; Match(T__122); } break; case T__50: EnterOuterAlt(_localctx, 2); { - State = 1814; + State = 1839; Match(T__50); } break; case T__51: EnterOuterAlt(_localctx, 3); { - State = 1815; + State = 1840; Match(T__51); } break; case T__62: EnterOuterAlt(_localctx, 4); { - State = 1816; + State = 1841; Match(T__62); } break; case T__123: EnterOuterAlt(_localctx, 5); { - State = 1817; + State = 1842; Match(T__123); } break; case T__68: EnterOuterAlt(_localctx, 6); { - State = 1818; + State = 1843; Match(T__68); } break; case T__67: EnterOuterAlt(_localctx, 7); { - State = 1819; + State = 1844; Match(T__67); } break; case T__63: EnterOuterAlt(_localctx, 8); { - State = 1820; + State = 1845; Match(T__63); } break; case T__64: EnterOuterAlt(_localctx, 9); { - State = 1821; + State = 1846; Match(T__64); } break; case T__65: EnterOuterAlt(_localctx, 10); { - State = 1822; + State = 1847; Match(T__65); } break; case T__124: EnterOuterAlt(_localctx, 11); { - State = 1823; + State = 1848; Match(T__124); } break; case T__125: EnterOuterAlt(_localctx, 12); { - State = 1824; + State = 1849; Match(T__125); } break; case T__126: EnterOuterAlt(_localctx, 13); { - State = 1825; + State = 1850; Match(T__126); } break; case T__15: EnterOuterAlt(_localctx, 14); { - State = 1826; + State = 1851; Match(T__15); } break; case T__69: EnterOuterAlt(_localctx, 15); { - State = 1827; + State = 1852; Match(T__69); - State = 1828; + State = 1853; Match(T__29); - State = 1829; + State = 1854; int32(); - State = 1830; + State = 1855; Match(T__30); } break; @@ -9976,9 +10016,9 @@ public AtOptContext atOpt() { AtOptContext _localctx = new AtOptContext(Context, State); EnterRule(_localctx, 204, RULE_atOpt); try { - State = 1839; + State = 1864; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,95,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,96,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -9987,18 +10027,18 @@ public AtOptContext atOpt() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1835; + State = 1860; Match(T__43); - State = 1836; + State = 1861; id(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1837; + State = 1862; Match(T__43); - State = 1838; + State = 1863; int32(); } break; @@ -10037,7 +10077,7 @@ public InitOptContext initOpt() { InitOptContext _localctx = new InitOptContext(Context, State); EnterRule(_localctx, 206, RULE_initOpt); try { - State = 1844; + State = 1869; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -10131,9 +10171,9 @@ public InitOptContext initOpt() { case T__35: EnterOuterAlt(_localctx, 2); { - State = 1842; + State = 1867; Match(T__35); - State = 1843; + State = 1868; fieldInit(); } break; @@ -10174,7 +10214,7 @@ public RepeatOptContext repeatOpt() { RepeatOptContext _localctx = new RepeatOptContext(Context, State); EnterRule(_localctx, 208, RULE_repeatOpt); try { - State = 1851; + State = 1876; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -10229,11 +10269,11 @@ public RepeatOptContext repeatOpt() { case T__41: EnterOuterAlt(_localctx, 2); { - State = 1847; + State = 1872; Match(T__41); - State = 1848; + State = 1873; int32(); - State = 1849; + State = 1874; Match(T__42); } break; @@ -10284,54 +10324,54 @@ public EventHeadContext eventHead() { EnterRule(_localctx, 210, RULE_eventHead); int _la; try { - State = 1871; + State = 1896; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,100,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,101,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1853; + State = 1878; Match(T__127); - State = 1857; + State = 1882; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 1854; + State = 1879; eventAttr(); } } - State = 1859; + State = 1884; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 1860; + State = 1885; typeSpec(); - State = 1861; + State = 1886; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1863; + State = 1888; Match(T__127); - State = 1867; + State = 1892; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 1864; + State = 1889; eventAttr(); } } - State = 1869; + State = 1894; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 1870; + State = 1895; dottedName(); } break; @@ -10370,7 +10410,7 @@ public EventAttrContext eventAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 1873; + State = 1898; _la = TokenStream.LA(1); if ( !(_la==T__67 || _la==T__68) ) { ErrorHandler.RecoverInline(this); @@ -10420,17 +10460,17 @@ public EventDeclsContext eventDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 1878; + State = 1903; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38788988928L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 1080863910568919043L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 1875; + State = 1900; eventDecl(); } } - State = 1880; + State = 1905; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -10481,42 +10521,42 @@ public EventDeclContext eventDecl() { EventDeclContext _localctx = new EventDeclContext(Context, State); EnterRule(_localctx, 216, RULE_eventDecl); try { - State = 1893; + State = 1918; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__128: EnterOuterAlt(_localctx, 1); { - State = 1881; + State = 1906; Match(T__128); - State = 1882; + State = 1907; methodRef(); } break; case T__129: EnterOuterAlt(_localctx, 2); { - State = 1883; + State = 1908; Match(T__129); - State = 1884; + State = 1909; methodRef(); } break; case T__130: EnterOuterAlt(_localctx, 3); { - State = 1885; + State = 1910; Match(T__130); - State = 1886; + State = 1911; methodRef(); } break; case T__131: EnterOuterAlt(_localctx, 4); { - State = 1887; + State = 1912; Match(T__131); - State = 1888; + State = 1913; methodRef(); } break; @@ -10524,7 +10564,7 @@ public EventDeclContext eventDecl() { case T__73: EnterOuterAlt(_localctx, 5); { - State = 1889; + State = 1914; extSourceSpec(); } break; @@ -10537,14 +10577,14 @@ public EventDeclContext eventDecl() { case ID: EnterOuterAlt(_localctx, 6); { - State = 1890; + State = 1915; customAttrDecl(); } break; case T__26: EnterOuterAlt(_localctx, 7); { - State = 1891; + State = 1916; languageDecl(); } break; @@ -10558,7 +10598,7 @@ public EventDeclContext eventDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 8); { - State = 1892; + State = 1917; compControl(); } break; @@ -10620,31 +10660,31 @@ public PropHeadContext propHead() { try { EnterOuterAlt(_localctx, 1); { - State = 1895; + State = 1920; Match(T__132); - State = 1899; + State = 1924; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 1896; + State = 1921; propAttr(); } } - State = 1901; + State = 1926; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 1902; + State = 1927; callConv(); - State = 1903; + State = 1928; type(); - State = 1904; + State = 1929; dottedName(); - State = 1905; + State = 1930; sigArgs(); - State = 1906; + State = 1931; initOpt(); } } @@ -10681,7 +10721,7 @@ public PropAttrContext propAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 1908; + State = 1933; _la = TokenStream.LA(1); if ( !(_la==T__67 || _la==T__68) ) { ErrorHandler.RecoverInline(this); @@ -10731,17 +10771,17 @@ public PropDeclsContext propDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 1913; + State = 1938; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38788988928L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 7493989779944505347L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 1910; + State = 1935; propDecl(); } } - State = 1915; + State = 1940; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -10792,33 +10832,33 @@ public PropDeclContext propDecl() { PropDeclContext _localctx = new PropDeclContext(Context, State); EnterRule(_localctx, 224, RULE_propDecl); try { - State = 1926; + State = 1951; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__133: EnterOuterAlt(_localctx, 1); { - State = 1916; + State = 1941; Match(T__133); - State = 1917; + State = 1942; methodRef(); } break; case T__134: EnterOuterAlt(_localctx, 2); { - State = 1918; + State = 1943; Match(T__134); - State = 1919; + State = 1944; methodRef(); } break; case T__131: EnterOuterAlt(_localctx, 3); { - State = 1920; + State = 1945; Match(T__131); - State = 1921; + State = 1946; methodRef(); } break; @@ -10831,7 +10871,7 @@ public PropDeclContext propDecl() { case ID: EnterOuterAlt(_localctx, 4); { - State = 1922; + State = 1947; customAttrDecl(); } break; @@ -10839,14 +10879,14 @@ public PropDeclContext propDecl() { case T__73: EnterOuterAlt(_localctx, 5); { - State = 1923; + State = 1948; extSourceSpec(); } break; case T__26: EnterOuterAlt(_localctx, 6); { - State = 1924; + State = 1949; languageDecl(); } break; @@ -10860,7 +10900,7 @@ public PropDeclContext propDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 7); { - State = 1925; + State = 1950; compControl(); } break; @@ -10901,7 +10941,7 @@ public MarshalClauseContext marshalClause() { MarshalClauseContext _localctx = new MarshalClauseContext(Context, State); EnterRule(_localctx, 226, RULE_marshalClause); try { - State = 1934; + State = 1959; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -10937,13 +10977,13 @@ public MarshalClauseContext marshalClause() { case T__121: EnterOuterAlt(_localctx, 2); { - State = 1929; + State = 1954; Match(T__121); - State = 1930; + State = 1955; Match(T__29); - State = 1931; + State = 1956; marshalBlob(); - State = 1932; + State = 1957; Match(T__30); } break; @@ -10991,7 +11031,7 @@ public MarshalBlobContext marshalBlob() { EnterRule(_localctx, 228, RULE_marshalBlob); int _la; try { - State = 1945; + State = 1970; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -11046,30 +11086,30 @@ public MarshalBlobContext marshalBlob() { case ID: EnterOuterAlt(_localctx, 1); { - State = 1936; + State = 1961; nativeType(); } break; case T__16: EnterOuterAlt(_localctx, 2); { - State = 1937; + State = 1962; Match(T__16); - State = 1939; + State = 1964; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 1938; + State = 1963; hexbyte(); } } - State = 1941; + State = 1966; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( _la==INT32 || _la==ID || _la==HEXBYTE ); - State = 1943; + State = 1968; Match(T__17); } break; @@ -11116,17 +11156,17 @@ public ParamAttrContext paramAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 1950; + State = 1975; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__41) { { { - State = 1947; + State = 1972; paramAttrElement(); } } - State = 1952; + State = 1977; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11168,50 +11208,50 @@ public ParamAttrElementContext paramAttrElement() { ParamAttrElementContext _localctx = new ParamAttrElementContext(Context, State); EnterRule(_localctx, 232, RULE_paramAttrElement); try { - State = 1966; + State = 1991; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,110,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,111,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1953; + State = 1978; Match(T__41); - State = 1954; + State = 1979; _localctx.@in = Match(T__135); - State = 1955; + State = 1980; Match(T__42); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1956; + State = 1981; Match(T__41); - State = 1957; + State = 1982; _localctx.@out = Match(T__136); - State = 1958; + State = 1983; Match(T__42); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1959; + State = 1984; Match(T__41); - State = 1960; + State = 1985; _localctx.opt = Match(T__137); - State = 1961; + State = 1986; Match(T__42); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1962; + State = 1987; Match(T__41); - State = 1963; + State = 1988; int32(); - State = 1964; + State = 1989; Match(T__42); } break; @@ -11290,14 +11330,14 @@ public MethodHeadContext methodHead() { try { EnterOuterAlt(_localctx, 1); { - State = 1968; + State = 1993; Match(T__138); - State = 1973; + State = 1998; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & 978955L) != 0) || ((((_la - 123)) & ~0x3f) == 0 && ((1L << (_la - 123)) & 33423365L) != 0)) { { - State = 1971; + State = 1996; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__50: @@ -11320,13 +11360,13 @@ public MethodHeadContext methodHead() { case T__144: case T__145: { - State = 1969; + State = 1994; methAttr(); } break; case T__146: { - State = 1970; + State = 1995; pinvImpl(); } break; @@ -11334,35 +11374,35 @@ public MethodHeadContext methodHead() { throw new NoViableAltException(this); } } - State = 1975; + State = 2000; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 1976; + State = 2001; callConv(); - State = 1977; + State = 2002; paramAttr(); - State = 1978; + State = 2003; type(); - State = 1979; + State = 2004; marshalClause(); - State = 1980; + State = 2005; methodName(); - State = 1981; + State = 2006; typarsClause(); - State = 1982; + State = 2007; sigArgs(); - State = 1986; + State = 2011; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 32766L) != 0) || _la==T__69 || _la==T__155 || _la==UNMANAGED) { { { - State = 1983; + State = 2008; implAttr(); } } - State = 1988; + State = 2013; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11404,145 +11444,145 @@ public MethAttrContext methAttr() { MethAttrContext _localctx = new MethAttrContext(Context, State); EnterRule(_localctx, 236, RULE_methAttr); try { - State = 2012; + State = 2037; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__122: EnterOuterAlt(_localctx, 1); { - State = 1989; + State = 2014; Match(T__122); } break; case T__50: EnterOuterAlt(_localctx, 2); { - State = 1990; + State = 2015; Match(T__50); } break; case T__51: EnterOuterAlt(_localctx, 3); { - State = 1991; + State = 2016; Match(T__51); } break; case T__62: EnterOuterAlt(_localctx, 4); { - State = 1992; + State = 2017; Match(T__62); } break; case T__139: EnterOuterAlt(_localctx, 5); { - State = 1993; + State = 2018; Match(T__139); } break; case T__67: EnterOuterAlt(_localctx, 6); { - State = 1994; + State = 2019; Match(T__67); } break; case T__140: EnterOuterAlt(_localctx, 7); { - State = 1995; + State = 2020; Match(T__140); } break; case T__141: EnterOuterAlt(_localctx, 8); { - State = 1996; + State = 2021; Match(T__141); } break; case T__53: EnterOuterAlt(_localctx, 9); { - State = 1997; + State = 2022; Match(T__53); } break; case T__63: EnterOuterAlt(_localctx, 10); { - State = 1998; + State = 2023; Match(T__63); } break; case T__64: EnterOuterAlt(_localctx, 11); { - State = 1999; + State = 2024; Match(T__64); } break; case T__65: EnterOuterAlt(_localctx, 12); { - State = 2000; + State = 2025; Match(T__65); } break; case T__124: EnterOuterAlt(_localctx, 13); { - State = 2001; + State = 2026; Match(T__124); } break; case T__142: EnterOuterAlt(_localctx, 14); { - State = 2002; + State = 2027; Match(T__142); } break; case T__143: EnterOuterAlt(_localctx, 15); { - State = 2003; + State = 2028; Match(T__143); } break; case T__68: EnterOuterAlt(_localctx, 16); { - State = 2004; + State = 2029; Match(T__68); } break; case T__144: EnterOuterAlt(_localctx, 17); { - State = 2005; + State = 2030; Match(T__144); } break; case T__145: EnterOuterAlt(_localctx, 18); { - State = 2006; + State = 2031; Match(T__145); } break; case T__69: EnterOuterAlt(_localctx, 19); { - State = 2007; + State = 2032; Match(T__69); - State = 2008; + State = 2033; Match(T__29); - State = 2009; + State = 2034; int32(); - State = 2010; + State = 2035; Match(T__30); } break; @@ -11593,31 +11633,31 @@ public PinvImplContext pinvImpl() { EnterRule(_localctx, 238, RULE_pinvImpl); int _la; try { - State = 2032; + State = 2057; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,118,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,119,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2014; + State = 2039; Match(T__146); - State = 2015; + State = 2040; Match(T__29); - State = 2021; + State = 2046; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==QSTRING) { { - State = 2016; + State = 2041; compQstring(); - State = 2019; + State = 2044; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__33) { { - State = 2017; + State = 2042; Match(T__33); - State = 2018; + State = 2043; compQstring(); } } @@ -11625,30 +11665,30 @@ public PinvImplContext pinvImpl() { } } - State = 2026; + State = 2051; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 57)) & ~0x3f) == 0 && ((1L << (_la - 57)) & 8195L) != 0) || ((((_la - 148)) & ~0x3f) == 0 && ((1L << (_la - 148)) & 79L) != 0) || ((((_la - 224)) & ~0x3f) == 0 && ((1L << (_la - 224)) & 251658241L) != 0)) { { { - State = 2023; + State = 2048; pinvAttr(); } } - State = 2028; + State = 2053; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2029; + State = 2054; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2030; + State = 2055; Match(T__146); - State = 2031; + State = 2056; Match(T__84); } break; @@ -11692,133 +11732,133 @@ public PinvAttrContext pinvAttr() { PinvAttrContext _localctx = new PinvAttrContext(Context, State); EnterRule(_localctx, 240, RULE_pinvAttr); try { - State = 2061; + State = 2086; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,119,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,120,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2034; + State = 2059; Match(T__147); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2035; + State = 2060; Match(ANSI); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2036; + State = 2061; Match(T__56); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2037; + State = 2062; Match(T__57); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2038; + State = 2063; Match(T__148); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2039; + State = 2064; Match(T__149); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2040; + State = 2065; Match(CDECL); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2041; + State = 2066; Match(STDCALL); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2042; + State = 2067; Match(THISCALL); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2043; + State = 2068; Match(FASTCALL); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2044; + State = 2069; Match(T__150); - State = 2045; + State = 2070; Match(T__74); - State = 2046; + State = 2071; Match(T__151); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2047; + State = 2072; Match(T__150); - State = 2048; + State = 2073; Match(T__74); - State = 2049; + State = 2074; Match(T__152); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2050; + State = 2075; Match(T__153); - State = 2051; + State = 2076; Match(T__74); - State = 2052; + State = 2077; Match(T__151); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2053; + State = 2078; Match(T__153); - State = 2054; + State = 2079; Match(T__74); - State = 2055; + State = 2080; Match(T__152); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2056; + State = 2081; Match(T__69); - State = 2057; + State = 2082; Match(T__29); - State = 2058; + State = 2083; int32(); - State = 2059; + State = 2084; Match(T__30); } break; @@ -11857,20 +11897,20 @@ public MethodNameContext methodName() { MethodNameContext _localctx = new MethodNameContext(Context, State); EnterRule(_localctx, 242, RULE_methodName); try { - State = 2066; + State = 2091; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__115: EnterOuterAlt(_localctx, 1); { - State = 2063; + State = 2088; Match(T__115); } break; case T__154: EnterOuterAlt(_localctx, 2); { - State = 2064; + State = 2089; Match(T__154); } break; @@ -11882,7 +11922,7 @@ public MethodNameContext methodName() { case ID: EnterOuterAlt(_localctx, 3); { - State = 2065; + State = 2090; dottedName(); } break; @@ -11924,131 +11964,131 @@ public ImplAttrContext implAttr() { ImplAttrContext _localctx = new ImplAttrContext(Context, State); EnterRule(_localctx, 244, RULE_implAttr); try { - State = 2089; + State = 2114; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: EnterOuterAlt(_localctx, 1); { - State = 2068; + State = 2093; Match(T__0); } break; case T__1: EnterOuterAlt(_localctx, 2); { - State = 2069; + State = 2094; Match(T__1); } break; case T__155: EnterOuterAlt(_localctx, 3); { - State = 2070; + State = 2095; Match(T__155); } break; case T__2: EnterOuterAlt(_localctx, 4); { - State = 2071; + State = 2096; Match(T__2); } break; case T__3: EnterOuterAlt(_localctx, 5); { - State = 2072; + State = 2097; Match(T__3); } break; case UNMANAGED: EnterOuterAlt(_localctx, 6); { - State = 2073; + State = 2098; Match(UNMANAGED); } break; case T__4: EnterOuterAlt(_localctx, 7); { - State = 2074; + State = 2099; Match(T__4); } break; case T__5: EnterOuterAlt(_localctx, 8); { - State = 2075; + State = 2100; Match(T__5); } break; case T__6: EnterOuterAlt(_localctx, 9); { - State = 2076; + State = 2101; Match(T__6); } break; case T__7: EnterOuterAlt(_localctx, 10); { - State = 2077; + State = 2102; Match(T__7); } break; case T__8: EnterOuterAlt(_localctx, 11); { - State = 2078; + State = 2103; Match(T__8); } break; case T__9: EnterOuterAlt(_localctx, 12); { - State = 2079; + State = 2104; Match(T__9); } break; case T__10: EnterOuterAlt(_localctx, 13); { - State = 2080; + State = 2105; Match(T__10); } break; case T__11: EnterOuterAlt(_localctx, 14); { - State = 2081; + State = 2106; Match(T__11); } break; case T__12: EnterOuterAlt(_localctx, 15); { - State = 2082; + State = 2107; Match(T__12); } break; case T__13: EnterOuterAlt(_localctx, 16); { - State = 2083; + State = 2108; Match(T__13); } break; case T__69: EnterOuterAlt(_localctx, 17); { - State = 2084; + State = 2109; Match(T__69); - State = 2085; + State = 2110; Match(T__29); - State = 2086; + State = 2111; int32(); - State = 2087; + State = 2112; Match(T__30); } break; @@ -12096,17 +12136,17 @@ public MethodDeclsContext methodDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2094; + State = 2119; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38789119998L) != 0) || _la==T__72 || _la==T__73 || ((((_la - 158)) & ~0x3f) == 0 && ((1L << (_la - 158)) & 2199023255681L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 2303696760354115601L) != 0)) { { { - State = 2091; + State = 2116; methodDecl(); } } - State = 2096; + State = 2121; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -12166,7 +12206,7 @@ public MethodDeclContext methodDecl() { MethodDeclContext _localctx = new MethodDeclContext(Context, State); EnterRule(_localctx, 248, RULE_methodDecl); try { - State = 2114; + State = 2139; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case INSTR_NONE: @@ -12184,16 +12224,16 @@ public MethodDeclContext methodDecl() { case INSTR_TOK: EnterOuterAlt(_localctx, 1); { - State = 2097; + State = 2122; instr(); } break; case EMITBYTE: EnterOuterAlt(_localctx, 2); { - State = 2098; + State = 2123; Match(EMITBYTE); - State = 2099; + State = 2124; _localctx.value = int32(); Actions.EmitByte((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -12201,16 +12241,16 @@ public MethodDeclContext methodDecl() { case T__157: EnterOuterAlt(_localctx, 3); { - State = 2102; + State = 2127; sehBlock(); } break; case MAXSTACK: EnterOuterAlt(_localctx, 4); { - State = 2103; + State = 2128; Match(MAXSTACK); - State = 2104; + State = 2129; _localctx.value = int32(); Actions.SetMaxStack((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -12218,7 +12258,7 @@ public MethodDeclContext methodDecl() { case ENTRYPOINT: EnterOuterAlt(_localctx, 5); { - State = 2107; + State = 2132; Match(ENTRYPOINT); Actions.SetEntryPoint(); } @@ -12226,7 +12266,7 @@ public MethodDeclContext methodDecl() { case ZEROINIT: EnterOuterAlt(_localctx, 6); { - State = 2109; + State = 2134; Match(ZEROINIT); Actions.SetZeroInit(); } @@ -12253,14 +12293,14 @@ public MethodDeclContext methodDecl() { case ID: EnterOuterAlt(_localctx, 7); { - State = 2111; + State = 2136; labelDecl(); } break; case T__16: EnterOuterAlt(_localctx, 8); { - State = 2112; + State = 2137; scopeBlock(); } break; @@ -12286,7 +12326,7 @@ public MethodDeclContext methodDecl() { case VTENTRY: EnterOuterAlt(_localctx, 9); { - State = 2113; + State = 2138; methodDeclIsland(); } break; @@ -12392,302 +12432,302 @@ public MethodDeclIslandContext methodDeclIsland() { BeginSubtree(); try { int _alt; - State = 2214; + State = 2239; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,129,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,130,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2116; + State = 2141; Match(LOCALS); - State = 2117; + State = 2142; sigArgs(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2118; + State = 2143; Match(LOCALS); - State = 2119; + State = 2144; Match(T__156); - State = 2120; + State = 2145; sigArgs(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2121; + State = 2146; dataDecl(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2122; + State = 2147; secDecl(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2123; + State = 2148; extSourceSpec(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2124; + State = 2149; languageDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2125; + State = 2150; customDescrInMethodBody(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2126; + State = 2151; compControl(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2127; + State = 2152; Match(EXPORT); - State = 2128; + State = 2153; Match(T__41); - State = 2129; + State = 2154; int32(); - State = 2130; + State = 2155; Match(T__42); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2132; + State = 2157; Match(EXPORT); - State = 2133; + State = 2158; Match(T__41); - State = 2134; + State = 2159; int32(); - State = 2135; + State = 2160; Match(T__42); - State = 2136; + State = 2161; Match(T__33); - State = 2137; + State = 2162; id(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2139; + State = 2164; Match(VTENTRY); - State = 2140; + State = 2165; int32(); - State = 2141; + State = 2166; Match(T__74); - State = 2142; + State = 2167; int32(); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2144; + State = 2169; Match(OVERRIDE); - State = 2145; + State = 2170; typeSpec(); - State = 2146; + State = 2171; Match(DCOLON); - State = 2147; + State = 2172; methodName(); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2149; + State = 2174; Match(OVERRIDE); - State = 2150; + State = 2175; Match(METHOD); - State = 2151; + State = 2176; callConv(); - State = 2152; + State = 2177; type(); - State = 2153; + State = 2178; typeSpec(); - State = 2154; + State = 2179; Match(DCOLON); - State = 2155; + State = 2180; methodName(); - State = 2156; + State = 2181; genArity(); - State = 2157; + State = 2182; sigArgs(); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2159; + State = 2184; Match(PARAM); - State = 2160; + State = 2185; Match(TYPE); - State = 2161; + State = 2186; Match(T__41); - State = 2162; + State = 2187; int32(); - State = 2163; + State = 2188; Match(T__42); - State = 2167; + State = 2192; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,124,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,125,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2164; + State = 2189; customAttrDecl(); } } } - State = 2169; + State = 2194; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,124,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,125,Context); } } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2170; + State = 2195; Match(PARAM); - State = 2171; + State = 2196; Match(TYPE); - State = 2172; + State = 2197; dottedName(); - State = 2176; + State = 2201; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,125,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,126,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2173; + State = 2198; customAttrDecl(); } } } - State = 2178; + State = 2203; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,125,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,126,Context); } } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 2179; + State = 2204; Match(PARAM); - State = 2180; + State = 2205; Match(CONSTRAINT); - State = 2181; + State = 2206; Match(T__41); - State = 2182; + State = 2207; int32(); - State = 2183; + State = 2208; Match(T__42); - State = 2184; + State = 2209; Match(T__27); - State = 2185; + State = 2210; typeSpec(); - State = 2189; + State = 2214; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,126,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,127,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2186; + State = 2211; customAttrDecl(); } } } - State = 2191; + State = 2216; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,126,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,127,Context); } } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 2192; + State = 2217; Match(PARAM); - State = 2193; + State = 2218; Match(CONSTRAINT); - State = 2194; + State = 2219; dottedName(); - State = 2195; + State = 2220; Match(T__27); - State = 2196; + State = 2221; typeSpec(); - State = 2200; + State = 2225; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,127,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,128,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2197; + State = 2222; customAttrDecl(); } } } - State = 2202; + State = 2227; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,127,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,128,Context); } } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 2203; + State = 2228; Match(PARAM); - State = 2204; + State = 2229; Match(T__41); - State = 2205; + State = 2230; int32(); - State = 2206; + State = 2231; Match(T__42); - State = 2207; + State = 2232; initOpt(); - State = 2211; + State = 2236; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,128,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,129,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2208; + State = 2233; customAttrDecl(); } } } - State = 2213; + State = 2238; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,128,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,129,Context); } } break; @@ -12732,9 +12772,9 @@ public LabelDeclContext labelDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2216; + State = 2241; _localctx.name = id(); - State = 2217; + State = 2242; Match(T__74); Actions.DefineLabel((_localctx.name!=null?(_localctx.name.Start):null)); } @@ -12775,20 +12815,20 @@ public CustomDescrInMethodBodyContext customDescrInMethodBody() { CustomDescrInMethodBodyContext _localctx = new CustomDescrInMethodBodyContext(Context, State); EnterRule(_localctx, 254, RULE_customDescrInMethodBody); try { - State = 2222; + State = 2247; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,130,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,131,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2220; + State = 2245; customDescr(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2221; + State = 2246; customDescrWithOwner(); } break; @@ -12830,11 +12870,11 @@ public ScopeBlockContext scopeBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 2224; + State = 2249; Match(T__16); - State = 2225; + State = 2250; methodDecls(); - State = 2226; + State = 2251; Match(T__17); } } @@ -12878,9 +12918,9 @@ public SehBlockContext sehBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 2228; + State = 2253; tryBlock(); - State = 2229; + State = 2254; sehClauses(); } Context.Stop = TokenStream.LT(-1); @@ -12926,17 +12966,17 @@ public SehClausesContext sehClauses() { try { EnterOuterAlt(_localctx, 1); { - State = 2232; + State = 2257; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2231; + State = 2256; sehClause(); } } - State = 2234; + State = 2259; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( ((((_la - 160)) & ~0x3f) == 0 && ((1L << (_la - 160)) & 15L) != 0) ); @@ -12987,41 +13027,41 @@ public TryBlockContext tryBlock() { TryBlockContext _localctx = new TryBlockContext(Context, State); EnterRule(_localctx, 262, RULE_tryBlock); try { - State = 2248; + State = 2273; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,132,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,133,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2236; + State = 2261; Match(T__157); - State = 2237; + State = 2262; scopeBlock(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2238; + State = 2263; Match(T__157); - State = 2239; + State = 2264; id(); - State = 2240; + State = 2265; Match(T__158); - State = 2241; + State = 2266; id(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2243; + State = 2268; Match(T__157); - State = 2244; + State = 2269; int32(); - State = 2245; + State = 2270; Match(T__158); - State = 2246; + State = 2271; int32(); } break; @@ -13072,42 +13112,42 @@ public SehClauseContext sehClause() { SehClauseContext _localctx = new SehClauseContext(Context, State); EnterRule(_localctx, 264, RULE_sehClause); try { - State = 2262; + State = 2287; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__160: EnterOuterAlt(_localctx, 1); { - State = 2250; + State = 2275; catchClause(); - State = 2251; + State = 2276; handlerBlock(); } break; case T__159: EnterOuterAlt(_localctx, 2); { - State = 2253; + State = 2278; filterClause(); - State = 2254; + State = 2279; handlerBlock(); } break; case T__161: EnterOuterAlt(_localctx, 3); { - State = 2256; + State = 2281; finallyClause(); - State = 2257; + State = 2282; handlerBlock(); } break; case T__162: EnterOuterAlt(_localctx, 4); { - State = 2259; + State = 2284; faultClause(); - State = 2260; + State = 2285; handlerBlock(); } break; @@ -13154,33 +13194,33 @@ public FilterClauseContext filterClause() { FilterClauseContext _localctx = new FilterClauseContext(Context, State); EnterRule(_localctx, 266, RULE_filterClause); try { - State = 2270; + State = 2295; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,134,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,135,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2264; + State = 2289; Match(T__159); - State = 2265; + State = 2290; scopeBlock(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2266; + State = 2291; Match(T__159); - State = 2267; + State = 2292; id(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2268; + State = 2293; Match(T__159); - State = 2269; + State = 2294; int32(); } break; @@ -13221,9 +13261,9 @@ public CatchClauseContext catchClause() { try { EnterOuterAlt(_localctx, 1); { - State = 2272; + State = 2297; Match(T__160); - State = 2273; + State = 2298; typeSpec(); } Context.Stop = TokenStream.LT(-1); @@ -13261,7 +13301,7 @@ public FinallyClauseContext finallyClause() { try { EnterOuterAlt(_localctx, 1); { - State = 2275; + State = 2300; Match(T__161); } } @@ -13297,7 +13337,7 @@ public FaultClauseContext faultClause() { try { EnterOuterAlt(_localctx, 1); { - State = 2277; + State = 2302; Match(T__162); } } @@ -13346,39 +13386,39 @@ public HandlerBlockContext handlerBlock() { HandlerBlockContext _localctx = new HandlerBlockContext(Context, State); EnterRule(_localctx, 274, RULE_handlerBlock); try { - State = 2290; + State = 2315; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,135,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,136,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2279; + State = 2304; scopeBlock(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2280; + State = 2305; Match(T__163); - State = 2281; + State = 2306; id(); - State = 2282; + State = 2307; Match(T__158); - State = 2283; + State = 2308; id(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2285; + State = 2310; Match(T__163); - State = 2286; + State = 2311; int32(); - State = 2287; + State = 2312; Match(T__158); - State = 2288; + State = 2313; int32(); } break; @@ -13422,9 +13462,9 @@ public DataDeclContext dataDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2292; + State = 2317; ddHead(); - State = 2293; + State = 2318; ddBody(); } } @@ -13464,28 +13504,28 @@ public DdHeadContext ddHead() { DdHeadContext _localctx = new DdHeadContext(Context, State); EnterRule(_localctx, 278, RULE_ddHead); try { - State = 2302; + State = 2327; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,136,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,137,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2295; + State = 2320; Match(T__164); - State = 2296; + State = 2321; tls(); - State = 2297; + State = 2322; id(); - State = 2298; + State = 2323; Match(T__35); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2300; + State = 2325; Match(T__164); - State = 2301; + State = 2326; tls(); } break; @@ -13521,9 +13561,9 @@ public TlsContext tls() { TlsContext _localctx = new TlsContext(Context, State); EnterRule(_localctx, 280, RULE_tls); try { - State = 2307; + State = 2332; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,137,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,138,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -13532,14 +13572,14 @@ public TlsContext tls() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2305; + State = 2330; Match(T__165); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2306; + State = 2331; Match(T__1); } break; @@ -13585,17 +13625,17 @@ public DdBodyContext ddBody() { EnterRule(_localctx, 282, RULE_ddBody); int _la; try { - State = 2318; + State = 2343; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: EnterOuterAlt(_localctx, 1); { - State = 2309; + State = 2334; Match(T__16); - State = 2310; + State = 2335; ddItemList(); - State = 2311; + State = 2336; Match(T__17); } break; @@ -13610,17 +13650,17 @@ public DdBodyContext ddBody() { case REF: EnterOuterAlt(_localctx, 2); { - State = 2314; + State = 2339; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2313; + State = 2338; ddItem(); } } - State = 2316; + State = 2341; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( _la==T__83 || ((((_la - 181)) & ~0x3f) == 0 && ((1L << (_la - 181)) & 505L) != 0) || _la==REF ); @@ -13669,25 +13709,25 @@ public DdItemListContext ddItemList() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 2325; + State = 2350; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,140,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,141,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2320; + State = 2345; ddItem(); - State = 2321; + State = 2346; Match(T__27); } } } - State = 2327; + State = 2352; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,140,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,141,Context); } - State = 2328; + State = 2353; ddItem(); } } @@ -13724,7 +13764,7 @@ public DdItemCountContext ddItemCount() { DdItemCountContext _localctx = new DdItemCountContext(Context, State); EnterRule(_localctx, 286, RULE_ddItemCount); try { - State = 2335; + State = 2360; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -13828,11 +13868,11 @@ public DdItemCountContext ddItemCount() { case T__41: EnterOuterAlt(_localctx, 2); { - State = 2331; + State = 2356; Match(T__41); - State = 2332; + State = 2357; int32(); - State = 2333; + State = 2358; Match(T__42); } break; @@ -13900,200 +13940,200 @@ public DdItemContext ddItem() { DdItemContext _localctx = new DdItemContext(Context, State); EnterRule(_localctx, 288, RULE_ddItem); try { - State = 2403; + State = 2428; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,142,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,143,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2337; + State = 2362; Match(CHAR); - State = 2338; + State = 2363; Match(PTR); - State = 2339; + State = 2364; Match(T__29); - State = 2340; + State = 2365; compQstring(); - State = 2341; + State = 2366; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2343; + State = 2368; Match(REF); - State = 2344; + State = 2369; Match(T__29); - State = 2345; + State = 2370; id(); - State = 2346; + State = 2371; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2348; + State = 2373; Match(REF); - State = 2349; + State = 2374; id(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2350; + State = 2375; Match(T__83); - State = 2351; + State = 2376; Match(T__29); - State = 2352; + State = 2377; bytes(); - State = 2353; + State = 2378; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2355; + State = 2380; Match(FLOAT32); - State = 2356; + State = 2381; Match(T__29); - State = 2357; + State = 2382; float64(); - State = 2358; + State = 2383; Match(T__30); - State = 2359; + State = 2384; ddItemCount(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2361; + State = 2386; Match(FLOAT64_); - State = 2362; + State = 2387; Match(T__29); - State = 2363; + State = 2388; float64(); - State = 2364; + State = 2389; Match(T__30); - State = 2365; + State = 2390; ddItemCount(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2367; + State = 2392; Match(INT64_); - State = 2368; + State = 2393; Match(T__29); - State = 2369; + State = 2394; int64(); - State = 2370; + State = 2395; Match(T__30); - State = 2371; + State = 2396; ddItemCount(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2373; + State = 2398; Match(INT32_); - State = 2374; + State = 2399; Match(T__29); - State = 2375; + State = 2400; int32(); - State = 2376; + State = 2401; Match(T__30); - State = 2377; + State = 2402; ddItemCount(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2379; + State = 2404; Match(INT16); - State = 2380; + State = 2405; Match(T__29); - State = 2381; + State = 2406; int32(); - State = 2382; + State = 2407; Match(T__30); - State = 2383; + State = 2408; ddItemCount(); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2385; + State = 2410; Match(INT8); - State = 2386; + State = 2411; Match(T__29); - State = 2387; + State = 2412; int32(); - State = 2388; + State = 2413; Match(T__30); - State = 2389; + State = 2414; ddItemCount(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2391; + State = 2416; Match(FLOAT32); - State = 2392; + State = 2417; ddItemCount(); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2393; + State = 2418; Match(FLOAT64_); - State = 2394; + State = 2419; ddItemCount(); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2395; + State = 2420; Match(INT64_); - State = 2396; + State = 2421; ddItemCount(); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2397; + State = 2422; Match(INT32_); - State = 2398; + State = 2423; ddItemCount(); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2399; + State = 2424; Match(INT16); - State = 2400; + State = 2425; ddItemCount(); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 2401; + State = 2426; Match(INT8); - State = 2402; + State = 2427; ddItemCount(); } break; @@ -14156,201 +14196,201 @@ public FieldSerInitContext fieldSerInit() { FieldSerInitContext _localctx = new FieldSerInitContext(Context, State); EnterRule(_localctx, 290, RULE_fieldSerInit); try { - State = 2480; + State = 2505; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,143,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,144,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2405; + State = 2430; Match(FLOAT32); - State = 2406; + State = 2431; Match(T__29); - State = 2407; + State = 2432; float64(); - State = 2408; + State = 2433; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2410; + State = 2435; Match(FLOAT64_); - State = 2411; + State = 2436; Match(T__29); - State = 2412; + State = 2437; float64(); - State = 2413; + State = 2438; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2415; + State = 2440; Match(FLOAT32); - State = 2416; + State = 2441; Match(T__29); - State = 2417; + State = 2442; int32(); - State = 2418; + State = 2443; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2420; + State = 2445; Match(FLOAT64_); - State = 2421; + State = 2446; Match(T__29); - State = 2422; + State = 2447; int64(); - State = 2423; + State = 2448; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2425; + State = 2450; Match(INT64_); - State = 2426; + State = 2451; Match(T__29); - State = 2427; + State = 2452; int64(); - State = 2428; + State = 2453; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2430; + State = 2455; Match(INT32_); - State = 2431; + State = 2456; Match(T__29); - State = 2432; + State = 2457; int32(); - State = 2433; + State = 2458; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2435; + State = 2460; Match(INT16); - State = 2436; + State = 2461; Match(T__29); - State = 2437; + State = 2462; int32(); - State = 2438; + State = 2463; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2440; + State = 2465; Match(INT8); - State = 2441; + State = 2466; Match(T__29); - State = 2442; + State = 2467; int32(); - State = 2443; + State = 2468; Match(T__30); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2445; + State = 2470; Match(UINT64); - State = 2446; + State = 2471; Match(T__29); - State = 2447; + State = 2472; int64(); - State = 2448; + State = 2473; Match(T__30); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2450; + State = 2475; Match(UINT32); - State = 2451; + State = 2476; Match(T__29); - State = 2452; + State = 2477; int32(); - State = 2453; + State = 2478; Match(T__30); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2455; + State = 2480; Match(UINT16); - State = 2456; + State = 2481; Match(T__29); - State = 2457; + State = 2482; int32(); - State = 2458; + State = 2483; Match(T__30); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2460; + State = 2485; Match(UINT8); - State = 2461; + State = 2486; Match(T__29); - State = 2462; + State = 2487; int32(); - State = 2463; + State = 2488; Match(T__30); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2465; + State = 2490; Match(CHAR); - State = 2466; + State = 2491; Match(T__29); - State = 2467; + State = 2492; int32(); - State = 2468; + State = 2493; Match(T__30); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2470; + State = 2495; Match(BOOL); - State = 2471; + State = 2496; Match(T__29); - State = 2472; + State = 2497; truefalse(); - State = 2473; + State = 2498; Match(T__30); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2475; + State = 2500; Match(T__83); - State = 2476; + State = 2501; Match(T__29); - State = 2477; + State = 2502; bytes(); - State = 2478; + State = 2503; Match(T__30); } break; @@ -14398,18 +14438,18 @@ public BytesContext bytes() { try { EnterOuterAlt(_localctx, 1); { - State = 2487; + State = 2512; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32 || _la==ID || _la==HEXBYTE) { { { - State = 2482; + State = 2507; _localctx.b = hexbyte(); Actions.AddByte(_localctx.b.Value); } } - State = 2489; + State = 2514; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -14453,7 +14493,7 @@ public HexbyteContext hexbyte() { try { EnterOuterAlt(_localctx, 1); { - State = 2490; + State = 2515; _la = TokenStream.LA(1); if ( !(_la==INT32 || _la==ID || _la==HEXBYTE) ) { ErrorHandler.RecoverInline(this); @@ -14503,7 +14543,7 @@ public FieldInitContext fieldInit() { FieldInitContext _localctx = new FieldInitContext(Context, State); EnterRule(_localctx, 296, RULE_fieldInit); try { - State = 2495; + State = 2520; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__83: @@ -14521,21 +14561,21 @@ public FieldInitContext fieldInit() { case UINT64: EnterOuterAlt(_localctx, 1); { - State = 2492; + State = 2517; fieldSerInit(); } break; case QSTRING: EnterOuterAlt(_localctx, 2); { - State = 2493; + State = 2518; compQstring(); } break; case NULLREF: EnterOuterAlt(_localctx, 3); { - State = 2494; + State = 2519; Match(NULLREF); } break; @@ -14632,378 +14672,378 @@ public SerInitContext serInit() { SerInitContext _localctx = new SerInitContext(Context, State); EnterRule(_localctx, 298, RULE_serInit); try { - State = 2645; + State = 2670; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,146,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,147,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2497; + State = 2522; fieldSerInit(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2498; + State = 2523; Match(STRING); - State = 2499; + State = 2524; Match(T__29); - State = 2500; + State = 2525; Match(NULLREF); - State = 2501; + State = 2526; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2502; + State = 2527; Match(STRING); - State = 2503; + State = 2528; Match(T__29); - State = 2504; + State = 2529; Match(SQSTRING); - State = 2505; + State = 2530; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2506; + State = 2531; Match(TYPE); - State = 2507; + State = 2532; Match(T__29); - State = 2508; + State = 2533; Match(T__38); - State = 2509; + State = 2534; Match(SQSTRING); - State = 2510; + State = 2535; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2511; + State = 2536; Match(TYPE); - State = 2512; + State = 2537; Match(T__29); - State = 2513; + State = 2538; className(); - State = 2514; + State = 2539; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2516; + State = 2541; Match(TYPE); - State = 2517; + State = 2542; Match(T__29); - State = 2518; + State = 2543; Match(NULLREF); - State = 2519; + State = 2544; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2520; + State = 2545; Match(OBJECT); - State = 2521; + State = 2546; Match(T__29); - State = 2522; + State = 2547; serInit(); - State = 2523; + State = 2548; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2525; + State = 2550; Match(FLOAT32); - State = 2526; + State = 2551; Match(T__41); - State = 2527; + State = 2552; int32(); - State = 2528; + State = 2553; Match(T__42); - State = 2529; + State = 2554; Match(T__29); - State = 2530; + State = 2555; f32seq(); - State = 2531; + State = 2556; Match(T__30); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2533; + State = 2558; Match(FLOAT64_); - State = 2534; + State = 2559; Match(T__41); - State = 2535; + State = 2560; int32(); - State = 2536; + State = 2561; Match(T__42); - State = 2537; + State = 2562; Match(T__29); - State = 2538; + State = 2563; f64seq(); - State = 2539; + State = 2564; Match(T__30); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2541; + State = 2566; Match(INT64_); - State = 2542; + State = 2567; Match(T__41); - State = 2543; + State = 2568; int32(); - State = 2544; + State = 2569; Match(T__42); - State = 2545; + State = 2570; Match(T__29); - State = 2546; + State = 2571; i64seq(); - State = 2547; + State = 2572; Match(T__30); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2549; + State = 2574; Match(INT32_); - State = 2550; + State = 2575; Match(T__41); - State = 2551; + State = 2576; int32(); - State = 2552; + State = 2577; Match(T__42); - State = 2553; + State = 2578; Match(T__29); - State = 2554; + State = 2579; i32seq(); - State = 2555; + State = 2580; Match(T__30); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2557; + State = 2582; Match(INT16); - State = 2558; + State = 2583; Match(T__41); - State = 2559; + State = 2584; int32(); - State = 2560; + State = 2585; Match(T__42); - State = 2561; + State = 2586; Match(T__29); - State = 2562; + State = 2587; i16seq(); - State = 2563; + State = 2588; Match(T__30); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2565; + State = 2590; Match(INT8); - State = 2566; + State = 2591; Match(T__41); - State = 2567; + State = 2592; int32(); - State = 2568; + State = 2593; Match(T__42); - State = 2569; + State = 2594; Match(T__29); - State = 2570; + State = 2595; i8seq(); - State = 2571; + State = 2596; Match(T__30); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2573; + State = 2598; Match(UINT64); - State = 2574; + State = 2599; Match(T__41); - State = 2575; + State = 2600; int32(); - State = 2576; + State = 2601; Match(T__42); - State = 2577; + State = 2602; Match(T__29); - State = 2578; + State = 2603; i64seq(); - State = 2579; + State = 2604; Match(T__30); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2581; + State = 2606; Match(UINT32); - State = 2582; + State = 2607; Match(T__41); - State = 2583; + State = 2608; int32(); - State = 2584; + State = 2609; Match(T__42); - State = 2585; + State = 2610; Match(T__29); - State = 2586; + State = 2611; i32seq(); - State = 2587; + State = 2612; Match(T__30); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 2589; + State = 2614; Match(UINT16); - State = 2590; + State = 2615; Match(T__41); - State = 2591; + State = 2616; int32(); - State = 2592; + State = 2617; Match(T__42); - State = 2593; + State = 2618; Match(T__29); - State = 2594; + State = 2619; i16seq(); - State = 2595; + State = 2620; Match(T__30); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 2597; + State = 2622; Match(UINT8); - State = 2598; + State = 2623; Match(T__41); - State = 2599; + State = 2624; int32(); - State = 2600; + State = 2625; Match(T__42); - State = 2601; + State = 2626; Match(T__29); - State = 2602; + State = 2627; i8seq(); - State = 2603; + State = 2628; Match(T__30); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 2605; + State = 2630; Match(CHAR); - State = 2606; + State = 2631; Match(T__41); - State = 2607; + State = 2632; int32(); - State = 2608; + State = 2633; Match(T__42); - State = 2609; + State = 2634; Match(T__29); - State = 2610; + State = 2635; i16seq(); - State = 2611; + State = 2636; Match(T__30); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 2613; + State = 2638; Match(BOOL); - State = 2614; + State = 2639; Match(T__41); - State = 2615; + State = 2640; int32(); - State = 2616; + State = 2641; Match(T__42); - State = 2617; + State = 2642; Match(T__29); - State = 2618; + State = 2643; boolSeq(); - State = 2619; + State = 2644; Match(T__30); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 2621; + State = 2646; Match(STRING); - State = 2622; + State = 2647; Match(T__41); - State = 2623; + State = 2648; int32(); - State = 2624; + State = 2649; Match(T__42); - State = 2625; + State = 2650; Match(T__29); - State = 2626; + State = 2651; sqstringSeq(); - State = 2627; + State = 2652; Match(T__30); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 2629; + State = 2654; Match(TYPE); - State = 2630; + State = 2655; Match(T__41); - State = 2631; + State = 2656; int32(); - State = 2632; + State = 2657; Match(T__42); - State = 2633; + State = 2658; Match(T__29); - State = 2634; + State = 2659; classSeq(); - State = 2635; + State = 2660; Match(T__30); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 2637; + State = 2662; Match(OBJECT); - State = 2638; + State = 2663; Match(T__41); - State = 2639; + State = 2664; int32(); - State = 2640; + State = 2665; Match(T__42); - State = 2641; + State = 2666; Match(T__29); - State = 2642; + State = 2667; objSeq(); - State = 2643; + State = 2668; Match(T__30); } break; @@ -15054,29 +15094,29 @@ public F32seqContext f32seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2651; + State = 2676; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 98309L) != 0)) { { - State = 2649; + State = 2674; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,147,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,148,Context) ) { case 1: { - State = 2647; + State = 2672; float64(); } break; case 2: { - State = 2648; + State = 2673; int32(); } break; } } - State = 2653; + State = 2678; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15127,29 +15167,29 @@ public F64seqContext f64seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2658; + State = 2683; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 98311L) != 0)) { { - State = 2656; + State = 2681; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,149,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,150,Context) ) { case 1: { - State = 2654; + State = 2679; float64(); } break; case 2: { - State = 2655; + State = 2680; int64(); } break; } } - State = 2660; + State = 2685; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15194,17 +15234,17 @@ public I64seqContext i64seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2664; + State = 2689; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32 || _la==INT64) { { { - State = 2661; + State = 2686; int64(); } } - State = 2666; + State = 2691; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15249,17 +15289,17 @@ public I32seqContext i32seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2670; + State = 2695; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 2667; + State = 2692; int32(); } } - State = 2672; + State = 2697; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15304,17 +15344,17 @@ public I16seqContext i16seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2676; + State = 2701; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 2673; + State = 2698; int32(); } } - State = 2678; + State = 2703; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15359,17 +15399,17 @@ public I8seqContext i8seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2682; + State = 2707; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 2679; + State = 2704; int32(); } } - State = 2684; + State = 2709; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15414,17 +15454,17 @@ public BoolSeqContext boolSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 2688; + State = 2713; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__94 || _la==T__95) { { { - State = 2685; + State = 2710; truefalse(); } } - State = 2690; + State = 2715; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15471,13 +15511,13 @@ public SqstringSeqContext sqstringSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 2694; + State = 2719; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==NULLREF || _la==SQSTRING) { { { - State = 2691; + State = 2716; _la = TokenStream.LA(1); if ( !(_la==NULLREF || _la==SQSTRING) ) { ErrorHandler.RecoverInline(this); @@ -15488,7 +15528,7 @@ public SqstringSeqContext sqstringSeq() { } } } - State = 2696; + State = 2721; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15533,17 +15573,17 @@ public ClassSeqContext classSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 2700; + State = 2725; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4947802390528L) != 0) || _la==T__112 || _la==NULLREF || _la==VALUE || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 105553118478337L) != 0)) { { { - State = 2697; + State = 2722; classSeqElement(); } } - State = 2702; + State = 2727; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15584,22 +15624,22 @@ public ClassSeqElementContext classSeqElement() { ClassSeqElementContext _localctx = new ClassSeqElementContext(Context, State); EnterRule(_localctx, 318, RULE_classSeqElement); try { - State = 2707; + State = 2732; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case NULLREF: EnterOuterAlt(_localctx, 1); { - State = 2703; + State = 2728; Match(NULLREF); } break; case T__38: EnterOuterAlt(_localctx, 2); { - State = 2704; + State = 2729; Match(T__38); - State = 2705; + State = 2730; Match(SQSTRING); } break; @@ -15616,7 +15656,7 @@ public ClassSeqElementContext classSeqElement() { case ID: EnterOuterAlt(_localctx, 3); { - State = 2706; + State = 2731; className(); } break; @@ -15663,17 +15703,17 @@ public ObjSeqContext objSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 2712; + State = 2737; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__83 || ((((_la - 181)) & ~0x3f) == 0 && ((1L << (_la - 181)) & 106495L) != 0)) { { { - State = 2709; + State = 2734; serInit(); } } - State = 2714; + State = 2739; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15718,27 +15758,27 @@ public CustomAttrDeclContext customAttrDecl() { CustomAttrDeclContext _localctx = new CustomAttrDeclContext(Context, State); EnterRule(_localctx, 322, RULE_customAttrDecl); try { - State = 2718; + State = 2743; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,160,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,161,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2715; + State = 2740; customDescr(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2716; + State = 2741; customDescrWithOwner(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2717; + State = 2742; dottedName(); } break; @@ -15793,13 +15833,13 @@ public AsmOrRefDeclContext asmOrRefDecl() { EnterRule(_localctx, 324, RULE_asmOrRefDecl); int _la; try { - State = 2745; + State = 2770; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,161,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,162,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2720; + State = 2745; _la = TokenStream.LA(1); if ( !(_la==T__166 || _la==T__167) ) { ErrorHandler.RecoverInline(this); @@ -15808,72 +15848,72 @@ public AsmOrRefDeclContext asmOrRefDecl() { ErrorHandler.ReportMatch(this); Consume(); } - State = 2721; + State = 2746; Match(T__35); - State = 2722; + State = 2747; Match(T__29); - State = 2723; + State = 2748; bytes(); - State = 2724; + State = 2749; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2726; + State = 2751; Match(T__168); - State = 2727; + State = 2752; intOrWildcard(); - State = 2728; + State = 2753; Match(T__74); - State = 2729; + State = 2754; intOrWildcard(); - State = 2730; + State = 2755; Match(T__74); - State = 2731; + State = 2756; intOrWildcard(); - State = 2732; + State = 2757; Match(T__74); - State = 2733; + State = 2758; intOrWildcard(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2735; + State = 2760; Match(T__169); - State = 2736; + State = 2761; compQstring(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2737; + State = 2762; Match(T__169); - State = 2738; + State = 2763; Match(T__35); - State = 2739; + State = 2764; Match(T__29); - State = 2740; + State = 2765; bytes(); - State = 2741; + State = 2766; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2743; + State = 2768; customAttrDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2744; + State = 2769; compControl(); } break; @@ -15918,36 +15958,36 @@ public AssemblyRefHeadContext assemblyRefHead() { AssemblyRefHeadContext _localctx = new AssemblyRefHeadContext(Context, State); EnterRule(_localctx, 326, RULE_assemblyRefHead); try { - State = 2759; + State = 2784; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,162,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,163,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2747; + State = 2772; Match(T__24); - State = 2748; + State = 2773; Match(T__39); - State = 2749; + State = 2774; asmAttr(); - State = 2750; + State = 2775; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2752; + State = 2777; Match(T__24); - State = 2753; + State = 2778; Match(T__39); - State = 2754; + State = 2779; asmAttr(); - State = 2755; + State = 2780; dottedName(); - State = 2756; + State = 2781; Match(T__33); - State = 2757; + State = 2782; dottedName(); } break; @@ -15992,17 +16032,17 @@ public AssemblyRefDeclsContext assemblyRefDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2764; + State = 2789; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 36028835673735168L) != 0) || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & 4294975519L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 105555249070081L) != 0)) { { { - State = 2761; + State = 2786; assemblyRefDecl(); } } - State = 2766; + State = 2791; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16045,21 +16085,21 @@ public AssemblyRefDeclContext assemblyRefDecl() { AssemblyRefDeclContext _localctx = new AssemblyRefDeclContext(Context, State); EnterRule(_localctx, 330, RULE_assemblyRefDecl); try { - State = 2781; + State = 2806; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case HASH: EnterOuterAlt(_localctx, 1); { - State = 2767; + State = 2792; Match(HASH); - State = 2768; + State = 2793; Match(T__35); - State = 2769; + State = 2794; Match(T__29); - State = 2770; + State = 2795; bytes(); - State = 2771; + State = 2796; Match(T__30); } break; @@ -16084,29 +16124,29 @@ public AssemblyRefDeclContext assemblyRefDecl() { case ID: EnterOuterAlt(_localctx, 2); { - State = 2773; + State = 2798; asmOrRefDecl(); } break; case T__170: EnterOuterAlt(_localctx, 3); { - State = 2774; + State = 2799; Match(T__170); - State = 2775; + State = 2800; Match(T__35); - State = 2776; + State = 2801; Match(T__29); - State = 2777; + State = 2802; bytes(); - State = 2778; + State = 2803; Match(T__30); } break; case T__54: EnterOuterAlt(_localctx, 4); { - State = 2780; + State = 2805; Match(T__54); } break; @@ -16156,25 +16196,25 @@ public ExptypeHeadContext exptypeHead() { try { EnterOuterAlt(_localctx, 1); { - State = 2783; + State = 2808; Match(T__49); - State = 2784; + State = 2809; Match(T__39); - State = 2788; + State = 2813; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4618441417868443648L) != 0) || _la==T__171) { { { - State = 2785; + State = 2810; exptAttr(); } } - State = 2790; + State = 2815; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2791; + State = 2816; dottedName(); } } @@ -16221,23 +16261,23 @@ public ExportHeadContext exportHead() { try { EnterOuterAlt(_localctx, 1); { - State = 2793; + State = 2818; Match(EXPORT); - State = 2797; + State = 2822; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4618441417868443648L) != 0) || _la==T__171) { { { - State = 2794; + State = 2819; exptAttr(); } } - State = 2799; + State = 2824; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2800; + State = 2825; dottedName(); } } @@ -16271,81 +16311,81 @@ public ExptAttrContext exptAttr() { ExptAttrContext _localctx = new ExptAttrContext(Context, State); EnterRule(_localctx, 336, RULE_exptAttr); try { - State = 2817; + State = 2842; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,167,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,168,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2802; + State = 2827; Match(T__51); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2803; + State = 2828; Match(T__50); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2804; + State = 2829; Match(T__171); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2805; + State = 2830; Match(T__61); - State = 2806; + State = 2831; Match(T__50); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2807; + State = 2832; Match(T__61); - State = 2808; + State = 2833; Match(T__51); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2809; + State = 2834; Match(T__61); - State = 2810; + State = 2835; Match(T__62); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2811; + State = 2836; Match(T__61); - State = 2812; + State = 2837; Match(T__63); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2813; + State = 2838; Match(T__61); - State = 2814; + State = 2839; Match(T__64); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2815; + State = 2840; Match(T__61); - State = 2816; + State = 2841; Match(T__65); } break; @@ -16390,17 +16430,17 @@ public ExptypeDeclsContext exptypeDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2822; + State = 2847; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1125938597265408L) != 0) || _la==T__112 || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 2819; + State = 2844; exptypeDecl(); } } - State = 2824; + State = 2849; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16454,67 +16494,67 @@ public ExptypeDeclContext exptypeDecl() { ExptypeDeclContext _localctx = new ExptypeDeclContext(Context, State); EnterRule(_localctx, 340, RULE_exptypeDecl); try { - State = 2838; + State = 2863; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,169,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,170,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2825; + State = 2850; Match(T__20); - State = 2826; + State = 2851; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2827; + State = 2852; Match(T__49); - State = 2828; + State = 2853; Match(T__39); - State = 2829; + State = 2854; slashedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2830; + State = 2855; Match(T__24); - State = 2831; + State = 2856; Match(T__39); - State = 2832; + State = 2857; dottedName(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2833; + State = 2858; mdtoken(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2834; + State = 2859; Match(T__49); - State = 2835; + State = 2860; int32(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2836; + State = 2861; customAttrDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2837; + State = 2862; compControl(); } break; @@ -16564,56 +16604,56 @@ public ManifestResHeadContext manifestResHead() { EnterRule(_localctx, 342, RULE_manifestResHead); int _la; try { - State = 2859; + State = 2884; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,172,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,173,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2840; + State = 2865; Match(MRESOURCE); - State = 2844; + State = 2869; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__50 || _la==T__51) { { { - State = 2841; + State = 2866; manresAttr(); } } - State = 2846; + State = 2871; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2847; + State = 2872; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2848; + State = 2873; Match(MRESOURCE); - State = 2852; + State = 2877; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__50 || _la==T__51) { { { - State = 2849; + State = 2874; manresAttr(); } } - State = 2854; + State = 2879; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2855; + State = 2880; dottedName(); - State = 2856; + State = 2881; Match(T__33); - State = 2857; + State = 2882; dottedName(); } break; @@ -16652,7 +16692,7 @@ public ManresAttrContext manresAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 2861; + State = 2886; _la = TokenStream.LA(1); if ( !(_la==T__50 || _la==T__51) ) { ErrorHandler.RecoverInline(this); @@ -16702,17 +16742,17 @@ public ManifestResDeclsContext manifestResDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2866; + State = 2891; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38690422784L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 2863; + State = 2888; manifestResDecl(); } } - State = 2868; + State = 2893; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16760,30 +16800,30 @@ public ManifestResDeclContext manifestResDecl() { ManifestResDeclContext _localctx = new ManifestResDeclContext(Context, State); EnterRule(_localctx, 348, RULE_manifestResDecl); try { - State = 2879; + State = 2904; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__20: EnterOuterAlt(_localctx, 1); { - State = 2869; + State = 2894; Match(T__20); - State = 2870; + State = 2895; dottedName(); - State = 2871; + State = 2896; Match(T__43); - State = 2872; + State = 2897; int32(); } break; case T__24: EnterOuterAlt(_localctx, 2); { - State = 2874; + State = 2899; Match(T__24); - State = 2875; + State = 2900; Match(T__39); - State = 2876; + State = 2901; dottedName(); } break; @@ -16796,7 +16836,7 @@ public ManifestResDeclContext manifestResDecl() { case ID: EnterOuterAlt(_localctx, 3); { - State = 2877; + State = 2902; customAttrDecl(); } break; @@ -16810,7 +16850,7 @@ public ManifestResDeclContext manifestResDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 4); { - State = 2878; + State = 2903; compControl(); } break; @@ -16847,7 +16887,7 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { } private static int[] _serializedATN = { - 4,1,305,2882,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, + 4,1,305,2907,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, @@ -16874,180 +16914,182 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 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,1,0,1,0,1,1,1,1,1,1,1, - 1,5,1,357,8,1,10,1,12,1,360,9,1,1,1,1,1,3,1,364,8,1,1,2,1,2,1,3,1,3,5, - 3,370,8,3,10,3,12,3,373,9,3,1,3,1,3,1,4,5,4,378,8,4,10,4,12,4,381,9,4, - 1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1, + 1,5,1,357,8,1,10,1,12,1,360,9,1,1,1,1,1,3,1,364,8,1,1,2,1,2,1,3,1,3,1, + 3,5,3,371,8,3,10,3,12,3,374,9,3,1,3,1,3,1,3,1,4,5,4,380,8,4,10,4,12,4, + 383,9,4,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1, 5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5, - 1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,433,8, - 5,1,6,1,6,1,6,1,7,1,7,1,7,1,8,1,8,1,8,1,8,1,9,1,9,1,9,1,10,1,10,1,10,1, - 11,1,11,1,11,1,11,1,11,1,11,1,11,1,12,1,12,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,474,8,13,1,14,1,14,1,15, - 1,15,1,15,5,15,481,8,15,10,15,12,15,484,9,15,1,15,1,15,1,16,1,16,1,17, - 1,17,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18, - 1,18,1,18,3,18,507,8,18,1,19,1,19,3,19,511,8,19,1,20,1,20,1,20,1,20,1, - 20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,3,20,529,8,20, + 1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,3, + 5,435,8,5,1,6,1,6,1,6,1,7,1,7,1,7,1,8,1,8,1,8,1,8,1,9,1,9,1,9,1,10,1,10, + 1,10,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,12,1,12,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,476,8,13,1,14,1, + 14,1,15,1,15,1,15,5,15,483,8,15,10,15,12,15,486,9,15,1,15,1,15,1,16,1, + 16,1,17,1,17,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1, + 18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,3,18,515,8,18,1,19,1,19, + 3,19,519,8,19,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1, + 20,1,20,1,20,1,20,1,20,3,20,537,8,20,1,21,1,21,1,21,1,21,1,21,1,21,1,21, 1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21, - 1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,3,21,556,8,21,1, - 22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1, - 22,1,22,1,22,1,22,1,22,1,22,1,22,3,22,579,8,22,1,23,1,23,1,23,1,23,1,23, + 1,21,1,21,1,21,1,21,3,21,564,8,21,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1, + 22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,3, + 22,587,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,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,615,8,23,1,24,1,24,1,25,1,25,3,25,621,8,25,1,26,1,26,1,26,1, - 27,1,27,5,27,628,8,27,10,27,12,27,631,9,27,1,28,1,28,1,28,1,28,1,28,1, - 28,1,28,5,28,640,8,28,10,28,12,28,643,9,28,1,29,1,29,1,30,1,30,3,30,649, - 8,30,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,3,31,660,8,31,1,32,1, - 32,1,32,1,32,1,32,1,32,3,32,668,8,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,34,1,34,1,34,1,34,5,34,689,8, - 34,10,34,12,34,692,9,34,1,35,1,35,1,35,1,35,1,35,1,35,1,36,1,36,1,36,1, - 37,1,37,5,37,705,8,37,10,37,12,37,708,9,37,1,37,1,37,1,37,1,37,1,37,1, + 1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,3,23,623,8,23,1,24,1,24,1,25,1, + 25,3,25,629,8,25,1,26,1,26,1,26,1,27,1,27,5,27,636,8,27,10,27,12,27,639, + 9,27,1,28,1,28,1,28,1,28,1,28,1,28,1,28,5,28,648,8,28,10,28,12,28,651, + 9,28,1,29,1,29,1,30,1,30,3,30,657,8,30,1,31,1,31,1,31,1,31,1,31,1,31,1, + 31,1,31,1,31,3,31,668,8,31,1,32,1,32,1,32,1,32,1,32,1,32,3,32,676,8,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,34,1,34,1,34,1,34,5,34,697,8,34,10,34,12,34,700,9,34,1,35,1,35, + 1,35,1,35,1,35,1,35,1,36,1,36,1,36,1,37,1,37,5,37,713,8,37,10,37,12,37, + 716,9,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, 38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1, 38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1, - 38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,3,38,752,8,38,1,39,1,39,1,39, - 3,39,757,8,39,1,40,1,40,1,40,3,40,762,8,40,1,41,5,41,765,8,41,10,41,12, - 41,768,9,41,1,42,1,42,1,42,5,42,773,8,42,10,42,12,42,776,9,42,1,42,1,42, - 1,43,1,43,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, + 38,1,38,3,38,760,8,38,1,39,1,39,1,39,3,39,765,8,39,1,40,1,40,1,40,3,40, + 770,8,40,1,41,5,41,773,8,41,10,41,12,41,776,9,41,1,42,1,42,1,42,5,42,781, + 8,42,10,42,12,42,784,9,42,1,42,1,42,1,43,1,43,1,44,1,44,1,44,1,44,1,44, + 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, - 1,44,1,44,1,44,1,44,1,44,1,44,1,44,3,44,885,8,44,1,45,1,45,5,45,889,8, - 45,10,45,12,45,892,9,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1, - 45,1,45,5,45,905,8,45,10,45,12,45,908,9,45,1,45,1,45,1,45,3,45,913,8,45, - 1,46,1,46,1,47,1,47,3,47,919,8,47,1,48,1,48,1,49,5,49,924,8,49,10,49,12, - 49,927,9,49,1,50,1,50,3,50,931,8,50,1,51,1,51,1,51,1,51,1,51,1,51,1,51, + 3,44,893,8,44,1,45,1,45,5,45,897,8,45,10,45,12,45,900,9,45,1,45,1,45,1, + 45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,5,45,913,8,45,10,45,12,45,916, + 9,45,1,45,1,45,1,45,3,45,921,8,45,1,46,1,46,1,47,1,47,3,47,927,8,47,1, + 48,1,48,1,49,5,49,932,8,49,10,49,12,49,935,9,49,1,50,1,50,3,50,939,8,50, 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,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,983,8,51,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1, - 52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1, - 52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,3,52,1019,8,52,1,53,1, - 53,1,53,3,53,1024,8,53,1,53,1,53,5,53,1028,8,53,10,53,12,53,1031,9,53, - 1,53,1,53,3,53,1035,8,53,3,53,1037,8,53,1,54,1,54,1,54,1,54,5,54,1043, - 8,54,10,54,12,54,1046,9,54,1,54,1,54,1,54,1,55,1,55,1,55,1,55,5,55,1055, - 8,55,10,55,12,55,1058,9,55,1,55,1,55,1,55,1,56,1,56,1,56,1,56,5,56,1067, - 8,56,10,56,12,56,1070,9,56,1,56,1,56,1,56,1,56,3,56,1076,8,56,1,57,1,57, - 1,57,1,57,1,57,3,57,1083,8,57,3,57,1085,8,57,1,58,1,58,1,58,1,58,1,58, + 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,1,51,1,51,1,51,1,51,3,51,1017,8,51,3,51,1019,8,51,1,52,1,52, + 1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,3,52, + 1036,8,52,1,53,1,53,1,53,1,53,1,53,1,53,1,53,3,53,1045,8,53,1,53,1,53, + 5,53,1049,8,53,10,53,12,53,1052,9,53,1,53,1,53,1,53,1,53,1,53,1,53,3,53, + 1060,8,53,3,53,1062,8,53,1,54,1,54,1,54,1,54,5,54,1068,8,54,10,54,12,54, + 1071,9,54,1,54,1,54,1,54,1,55,1,55,1,55,1,55,5,55,1080,8,55,10,55,12,55, + 1083,9,55,1,55,1,55,1,55,1,56,1,56,1,56,1,56,5,56,1092,8,56,10,56,12,56, + 1095,9,56,1,56,1,56,1,56,1,56,3,56,1101,8,56,1,57,1,57,1,57,1,57,1,57, + 3,57,1108,8,57,3,57,1110,8,57,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58, 1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58, - 1,58,1,58,1,58,1,58,1,58,1,58,3,58,1112,8,58,1,59,1,59,1,59,5,59,1117, - 8,59,10,59,12,59,1120,9,59,1,59,1,59,1,60,5,60,1125,8,60,10,60,12,60,1128, - 9,60,1,61,1,61,1,61,1,61,1,61,3,61,1135,8,61,1,62,1,62,1,62,1,62,1,62, - 1,62,1,62,1,62,1,62,1,62,1,62,3,62,1148,8,62,1,63,1,63,1,63,5,63,1153, - 8,63,10,63,12,63,1156,9,63,3,63,1158,8,63,1,64,1,64,1,64,1,64,1,64,1,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,1177,8,64, + 1,58,1,58,1,58,3,58,1137,8,58,1,59,1,59,1,59,5,59,1142,8,59,10,59,12,59, + 1145,9,59,1,59,1,59,1,60,5,60,1150,8,60,10,60,12,60,1153,9,60,1,61,1,61, + 1,61,1,61,1,61,3,61,1160,8,61,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62, + 1,62,1,62,1,62,3,62,1173,8,62,1,63,1,63,1,63,5,63,1178,8,63,10,63,12,63, + 1181,9,63,3,63,1183,8,63,1,64,1,64,1,64,1,64,1,64,1,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,1202,8,64,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, - 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,3,65,1271,8,65,1,66,1,66,1,66, - 1,66,1,66,1,66,1,66,3,66,1280,8,66,1,67,1,67,1,67,5,67,1285,8,67,10,67, - 12,67,1288,9,67,3,67,1290,8,67,1,68,1,68,1,69,1,69,5,69,1296,8,69,10,69, - 12,69,1299,9,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,1,70,1,70,1,70,3,70,1319,8,70,1,71,1,71,1,71,1,71, + 1,65,1,65,1,65,1,65,1,65,3,65,1296,8,65,1,66,1,66,1,66,1,66,1,66,1,66, + 1,66,3,66,1305,8,66,1,67,1,67,1,67,5,67,1310,8,67,10,67,12,67,1313,9,67, + 3,67,1315,8,67,1,68,1,68,1,69,1,69,5,69,1321,8,69,10,69,12,69,1324,9,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,1,70,1,70,1,70,3,70,1344,8,70,1,71,1,71,1,71,1,71,1,71,1,71,1,71, 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, - 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,3,71,1351, - 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,1,72,1,72,1,72,1,72,1,72,1,72,3,72,1374,8,72,1,73,1,73,1,73, - 1,73,1,73,1,73,1,73,1,73,1,73,1,73,3,73,1386,8,73,1,74,1,74,1,74,1,75, - 1,75,1,75,1,75,3,75,1395,8,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,3,76,1420,8,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,1444, - 8,76,1,77,1,77,1,77,1,77,5,77,1450,8,77,10,77,12,77,1453,9,77,1,77,3,77, - 1456,8,77,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78, - 1,78,3,78,1471,8,78,1,79,1,79,1,79,5,79,1476,8,79,10,79,12,79,1479,9,79, - 1,79,1,79,1,80,1,80,1,80,1,80,1,81,1,81,1,82,1,82,1,82,1,82,1,82,1,82, + 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,3,71,1376,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,1,72, + 1,72,1,72,1,72,1,72,1,72,3,72,1399,8,72,1,73,1,73,1,73,1,73,1,73,1,73, + 1,73,1,73,1,73,1,73,3,73,1411,8,73,1,74,1,74,1,74,1,75,1,75,1,75,1,75, + 3,75,1420,8,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,3,76,1445, + 8,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,1469,8,76,1,77,1,77, + 1,77,1,77,5,77,1475,8,77,10,77,12,77,1478,9,77,1,77,3,77,1481,8,77,1,78, + 1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,3,78,1496, + 8,78,1,79,1,79,1,79,5,79,1501,8,79,10,79,12,79,1504,9,79,1,79,1,79,1,80, + 1,80,1,80,1,80,1,81,1,81,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, - 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, - 3,82,1523,8,82,1,83,1,83,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1533,8,84, - 1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84, - 3,84,1549,8,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,3,84, - 1561,8,84,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,3,85,1573, - 8,85,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,3,86, - 1587,8,86,1,87,1,87,1,87,1,87,1,87,1,88,1,88,1,88,1,88,1,88,3,88,1599, - 8,88,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,3,89,1610,8,89,1,90, - 1,90,1,90,5,90,1615,8,90,10,90,12,90,1618,9,90,1,90,1,90,1,91,1,91,1,91, - 1,91,1,91,3,91,1627,8,91,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92, - 1,92,1,92,3,92,1640,8,92,1,93,5,93,1643,8,93,10,93,12,93,1646,9,93,1,94, - 1,94,3,94,1650,8,94,1,94,1,94,1,95,1,95,1,95,5,95,1657,8,95,10,95,12,95, - 1660,9,95,1,95,1,95,1,96,1,96,1,96,1,96,1,97,1,97,3,97,1670,8,97,1,98, - 1,98,1,98,1,98,1,98,1,98,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, + 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,3,82,1548,8,82, + 1,83,1,83,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1558,8,84,1,84,1,84,1,84, + 1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1574,8,84, + 1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1586,8,84,1,85, + 1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,3,85,1598,8,85,1,86,1,86, + 1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,3,86,1612,8,86,1,87, + 1,87,1,87,1,87,1,87,1,88,1,88,1,88,1,88,1,88,3,88,1624,8,88,1,89,1,89, + 1,89,1,89,1,89,1,89,1,89,1,89,1,89,3,89,1635,8,89,1,90,1,90,1,90,5,90, + 1640,8,90,10,90,12,90,1643,9,90,1,90,1,90,1,91,1,91,1,91,1,91,1,91,3,91, + 1652,8,91,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,3,92, + 1665,8,92,1,93,5,93,1668,8,93,10,93,12,93,1671,9,93,1,94,1,94,3,94,1675, + 8,94,1,94,1,94,1,95,1,95,1,95,5,95,1682,8,95,10,95,12,95,1685,9,95,1,95, + 1,95,1,96,1,96,1,96,1,96,1,97,1,97,3,97,1695,8,97,1,98,1,98,1,98,1,98, + 1,98,1,98,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, - 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,1751,8,99,10,99,12,99,1754, - 9,99,1,99,1,99,1,99,1,99,5,99,1760,8,99,10,99,12,99,1763,9,99,1,99,1,99, - 1,99,1,99,1,99,1,99,1,99,1,99,5,99,1773,8,99,10,99,12,99,1776,9,99,1,99, - 1,99,1,99,1,99,1,99,1,99,5,99,1784,8,99,10,99,12,99,1787,9,99,1,99,1,99, - 1,99,1,99,1,99,3,99,1794,8,99,1,100,1,100,1,100,1,100,1,100,1,100,1,100, - 1,100,5,100,1804,8,100,10,100,12,100,1807,9,100,1,100,1,100,1,100,1,100, - 1,100,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101, - 1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,3,101,1833,8,101,1,102, - 1,102,1,102,1,102,1,102,3,102,1840,8,102,1,103,1,103,1,103,3,103,1845, - 8,103,1,104,1,104,1,104,1,104,1,104,3,104,1852,8,104,1,105,1,105,5,105, - 1856,8,105,10,105,12,105,1859,9,105,1,105,1,105,1,105,1,105,1,105,5,105, - 1866,8,105,10,105,12,105,1869,9,105,1,105,3,105,1872,8,105,1,106,1,106, - 1,107,5,107,1877,8,107,10,107,12,107,1880,9,107,1,108,1,108,1,108,1,108, - 1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,3,108,1894,8,108,1,109, - 1,109,5,109,1898,8,109,10,109,12,109,1901,9,109,1,109,1,109,1,109,1,109, - 1,109,1,109,1,110,1,110,1,111,5,111,1912,8,111,10,111,12,111,1915,9,111, - 1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,3,112,1927, - 8,112,1,113,1,113,1,113,1,113,1,113,1,113,3,113,1935,8,113,1,114,1,114, - 1,114,4,114,1940,8,114,11,114,12,114,1941,1,114,1,114,3,114,1946,8,114, - 1,115,5,115,1949,8,115,10,115,12,115,1952,9,115,1,116,1,116,1,116,1,116, - 1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,3,116,1967,8,116, - 1,117,1,117,1,117,5,117,1972,8,117,10,117,12,117,1975,9,117,1,117,1,117, - 1,117,1,117,1,117,1,117,1,117,1,117,5,117,1985,8,117,10,117,12,117,1988, - 9,117,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, + 1,99,1,99,1,99,1,99,1,99,5,99,1776,8,99,10,99,12,99,1779,9,99,1,99,1,99, + 1,99,1,99,5,99,1785,8,99,10,99,12,99,1788,9,99,1,99,1,99,1,99,1,99,1,99, + 1,99,1,99,1,99,5,99,1798,8,99,10,99,12,99,1801,9,99,1,99,1,99,1,99,1,99, + 1,99,1,99,5,99,1809,8,99,10,99,12,99,1812,9,99,1,99,1,99,1,99,1,99,1,99, + 3,99,1819,8,99,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,5,100,1829, + 8,100,10,100,12,100,1832,9,100,1,100,1,100,1,100,1,100,1,100,1,101,1,101, + 1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101, + 1,101,1,101,1,101,1,101,1,101,3,101,1858,8,101,1,102,1,102,1,102,1,102, + 1,102,3,102,1865,8,102,1,103,1,103,1,103,3,103,1870,8,103,1,104,1,104, + 1,104,1,104,1,104,3,104,1877,8,104,1,105,1,105,5,105,1881,8,105,10,105, + 12,105,1884,9,105,1,105,1,105,1,105,1,105,1,105,5,105,1891,8,105,10,105, + 12,105,1894,9,105,1,105,3,105,1897,8,105,1,106,1,106,1,107,5,107,1902, + 8,107,10,107,12,107,1905,9,107,1,108,1,108,1,108,1,108,1,108,1,108,1,108, + 1,108,1,108,1,108,1,108,1,108,3,108,1919,8,108,1,109,1,109,5,109,1923, + 8,109,10,109,12,109,1926,9,109,1,109,1,109,1,109,1,109,1,109,1,109,1,110, + 1,110,1,111,5,111,1937,8,111,10,111,12,111,1940,9,111,1,112,1,112,1,112, + 1,112,1,112,1,112,1,112,1,112,1,112,1,112,3,112,1952,8,112,1,113,1,113, + 1,113,1,113,1,113,1,113,3,113,1960,8,113,1,114,1,114,1,114,4,114,1965, + 8,114,11,114,12,114,1966,1,114,1,114,3,114,1971,8,114,1,115,5,115,1974, + 8,115,10,115,12,115,1977,9,115,1,116,1,116,1,116,1,116,1,116,1,116,1,116, + 1,116,1,116,1,116,1,116,1,116,1,116,3,116,1992,8,116,1,117,1,117,1,117, + 5,117,1997,8,117,10,117,12,117,2000,9,117,1,117,1,117,1,117,1,117,1,117, + 1,117,1,117,1,117,5,117,2010,8,117,10,117,12,117,2013,9,117,1,118,1,118, 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, - 3,118,2013,8,118,1,119,1,119,1,119,1,119,1,119,3,119,2020,8,119,3,119, - 2022,8,119,1,119,5,119,2025,8,119,10,119,12,119,2028,9,119,1,119,1,119, - 1,119,3,119,2033,8,119,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, + 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,3,118,2038,8,118, + 1,119,1,119,1,119,1,119,1,119,3,119,2045,8,119,3,119,2047,8,119,1,119, + 5,119,2050,8,119,10,119,12,119,2053,9,119,1,119,1,119,1,119,3,119,2058, + 8,119,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, - 1,120,1,120,1,120,1,120,1,120,1,120,1,120,3,120,2062,8,120,1,121,1,121, - 1,121,3,121,2067,8,121,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, - 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, - 1,122,3,122,2090,8,122,1,123,5,123,2093,8,123,10,123,12,123,2096,9,123, + 1,120,1,120,1,120,1,120,3,120,2087,8,120,1,121,1,121,1,121,3,121,2092, + 8,121,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, + 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,3,122,2115, + 8,122,1,123,5,123,2118,8,123,10,123,12,123,2121,9,123,1,124,1,124,1,124, 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, - 1,124,1,124,1,124,1,124,1,124,3,124,2115,8,124,1,125,1,125,1,125,1,125, + 1,124,1,124,3,124,2140,8,124,1,125,1,125,1,125,1,125,1,125,1,125,1,125, 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, - 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,5,125,2166,8,125, - 10,125,12,125,2169,9,125,1,125,1,125,1,125,1,125,5,125,2175,8,125,10,125, - 12,125,2178,9,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,5,125, - 2188,8,125,10,125,12,125,2191,9,125,1,125,1,125,1,125,1,125,1,125,1,125, - 5,125,2199,8,125,10,125,12,125,2202,9,125,1,125,1,125,1,125,1,125,1,125, - 1,125,5,125,2210,8,125,10,125,12,125,2213,9,125,3,125,2215,8,125,1,126, - 1,126,1,126,1,126,1,127,1,127,3,127,2223,8,127,1,128,1,128,1,128,1,128, - 1,129,1,129,1,129,1,130,4,130,2233,8,130,11,130,12,130,2234,1,131,1,131, - 1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,3,131,2249, - 8,131,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132, - 1,132,3,132,2263,8,132,1,133,1,133,1,133,1,133,1,133,1,133,3,133,2271, - 8,133,1,134,1,134,1,134,1,135,1,135,1,136,1,136,1,137,1,137,1,137,1,137, - 1,137,1,137,1,137,1,137,1,137,1,137,1,137,3,137,2291,8,137,1,138,1,138, - 1,138,1,139,1,139,1,139,1,139,1,139,1,139,1,139,3,139,2303,8,139,1,140, - 1,140,1,140,3,140,2308,8,140,1,141,1,141,1,141,1,141,1,141,4,141,2315, - 8,141,11,141,12,141,2316,3,141,2319,8,141,1,142,1,142,1,142,5,142,2324, - 8,142,10,142,12,142,2327,9,142,1,142,1,142,1,143,1,143,1,143,1,143,1,143, - 3,143,2336,8,143,1,144,1,144,1,144,1,144,1,144,1,144,1,144,1,144,1,144, + 1,125,1,125,1,125,1,125,1,125,1,125,5,125,2191,8,125,10,125,12,125,2194, + 9,125,1,125,1,125,1,125,1,125,5,125,2200,8,125,10,125,12,125,2203,9,125, + 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,5,125,2213,8,125,10,125, + 12,125,2216,9,125,1,125,1,125,1,125,1,125,1,125,1,125,5,125,2224,8,125, + 10,125,12,125,2227,9,125,1,125,1,125,1,125,1,125,1,125,1,125,5,125,2235, + 8,125,10,125,12,125,2238,9,125,3,125,2240,8,125,1,126,1,126,1,126,1,126, + 1,127,1,127,3,127,2248,8,127,1,128,1,128,1,128,1,128,1,129,1,129,1,129, + 1,130,4,130,2258,8,130,11,130,12,130,2259,1,131,1,131,1,131,1,131,1,131, + 1,131,1,131,1,131,1,131,1,131,1,131,1,131,3,131,2274,8,131,1,132,1,132, + 1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,3,132,2288, + 8,132,1,133,1,133,1,133,1,133,1,133,1,133,3,133,2296,8,133,1,134,1,134, + 1,134,1,135,1,135,1,136,1,136,1,137,1,137,1,137,1,137,1,137,1,137,1,137, + 1,137,1,137,1,137,1,137,3,137,2316,8,137,1,138,1,138,1,138,1,139,1,139, + 1,139,1,139,1,139,1,139,1,139,3,139,2328,8,139,1,140,1,140,1,140,3,140, + 2333,8,140,1,141,1,141,1,141,1,141,1,141,4,141,2340,8,141,11,141,12,141, + 2341,3,141,2344,8,141,1,142,1,142,1,142,5,142,2349,8,142,10,142,12,142, + 2352,9,142,1,142,1,142,1,143,1,143,1,143,1,143,1,143,3,143,2361,8,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, 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, 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,2404,8,144, + 1,144,1,144,1,144,1,144,1,144,1,144,3,144,2429,8,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,145,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,145,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,145, 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,145,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,145,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,145,3,145,2481,8,145,1,146,1,146,1,146,5,146,2486,8,146, - 10,146,12,146,2489,9,146,1,147,1,147,1,148,1,148,1,148,3,148,2496,8,148, + 3,145,2506,8,145,1,146,1,146,1,146,5,146,2511,8,146,10,146,12,146,2514, + 9,146,1,147,1,147,1,148,1,148,1,148,3,148,2521,8,148,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, @@ -17060,907 +17102,914 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, - 1,149,1,149,1,149,1,149,3,149,2646,8,149,1,150,1,150,5,150,2650,8,150, - 10,150,12,150,2653,9,150,1,151,1,151,5,151,2657,8,151,10,151,12,151,2660, - 9,151,1,152,5,152,2663,8,152,10,152,12,152,2666,9,152,1,153,5,153,2669, - 8,153,10,153,12,153,2672,9,153,1,154,5,154,2675,8,154,10,154,12,154,2678, - 9,154,1,155,5,155,2681,8,155,10,155,12,155,2684,9,155,1,156,5,156,2687, - 8,156,10,156,12,156,2690,9,156,1,157,5,157,2693,8,157,10,157,12,157,2696, - 9,157,1,158,5,158,2699,8,158,10,158,12,158,2702,9,158,1,159,1,159,1,159, - 1,159,3,159,2708,8,159,1,160,5,160,2711,8,160,10,160,12,160,2714,9,160, - 1,161,1,161,1,161,3,161,2719,8,161,1,162,1,162,1,162,1,162,1,162,1,162, + 1,149,3,149,2671,8,149,1,150,1,150,5,150,2675,8,150,10,150,12,150,2678, + 9,150,1,151,1,151,5,151,2682,8,151,10,151,12,151,2685,9,151,1,152,5,152, + 2688,8,152,10,152,12,152,2691,9,152,1,153,5,153,2694,8,153,10,153,12,153, + 2697,9,153,1,154,5,154,2700,8,154,10,154,12,154,2703,9,154,1,155,5,155, + 2706,8,155,10,155,12,155,2709,9,155,1,156,5,156,2712,8,156,10,156,12,156, + 2715,9,156,1,157,5,157,2718,8,157,10,157,12,157,2721,9,157,1,158,5,158, + 2724,8,158,10,158,12,158,2727,9,158,1,159,1,159,1,159,1,159,3,159,2733, + 8,159,1,160,5,160,2736,8,160,10,160,12,160,2739,9,160,1,161,1,161,1,161, + 3,161,2744,8,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,162,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,162,1,162,1,162,3,162,2746,8,162,1,163,1,163, - 1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,3,163,2760, - 8,163,1,164,5,164,2763,8,164,10,164,12,164,2766,9,164,1,165,1,165,1,165, - 1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,3,165, - 2782,8,165,1,166,1,166,1,166,5,166,2787,8,166,10,166,12,166,2790,9,166, - 1,166,1,166,1,167,1,167,5,167,2796,8,167,10,167,12,167,2799,9,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,168,1,168,1,168,1,168,3,168,2818,8,168,1,169,5,169,2821,8,169,10,169, - 12,169,2824,9,169,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170, - 1,170,1,170,1,170,1,170,3,170,2839,8,170,1,171,1,171,5,171,2843,8,171, - 10,171,12,171,2846,9,171,1,171,1,171,1,171,5,171,2851,8,171,10,171,12, - 171,2854,9,171,1,171,1,171,1,171,1,171,3,171,2860,8,171,1,172,1,172,1, - 173,5,173,2865,8,173,10,173,12,173,2868,9,173,1,174,1,174,1,174,1,174, - 1,174,1,174,1,174,1,174,1,174,1,174,3,174,2880,8,174,1,174,0,1,68,175, - 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, - 0,16,6,0,1,15,199,199,243,243,247,247,264,264,289,289,5,0,16,16,199,199, - 243,243,264,264,288,289,1,0,263,264,1,0,173,174,1,0,37,38,1,0,73,74,3, - 0,2,2,61,61,77,83,2,0,229,229,260,261,9,0,178,178,183,195,201,201,207, - 208,210,215,218,219,222,222,230,242,262,262,1,0,95,96,1,0,97,111,1,0,68, - 69,2,0,173,173,289,290,2,0,179,179,264,264,1,0,167,168,1,0,51,52,3309, - 0,350,1,0,0,0,2,363,1,0,0,0,4,365,1,0,0,0,6,371,1,0,0,0,8,379,1,0,0,0, - 10,432,1,0,0,0,12,434,1,0,0,0,14,437,1,0,0,0,16,440,1,0,0,0,18,444,1,0, - 0,0,20,447,1,0,0,0,22,450,1,0,0,0,24,457,1,0,0,0,26,473,1,0,0,0,28,475, - 1,0,0,0,30,477,1,0,0,0,32,487,1,0,0,0,34,489,1,0,0,0,36,506,1,0,0,0,38, - 510,1,0,0,0,40,528,1,0,0,0,42,555,1,0,0,0,44,578,1,0,0,0,46,614,1,0,0, - 0,48,616,1,0,0,0,50,620,1,0,0,0,52,622,1,0,0,0,54,629,1,0,0,0,56,641,1, - 0,0,0,58,644,1,0,0,0,60,646,1,0,0,0,62,659,1,0,0,0,64,667,1,0,0,0,66,669, - 1,0,0,0,68,677,1,0,0,0,70,693,1,0,0,0,72,699,1,0,0,0,74,702,1,0,0,0,76, - 751,1,0,0,0,78,756,1,0,0,0,80,761,1,0,0,0,82,766,1,0,0,0,84,774,1,0,0, - 0,86,779,1,0,0,0,88,884,1,0,0,0,90,912,1,0,0,0,92,914,1,0,0,0,94,918,1, - 0,0,0,96,920,1,0,0,0,98,925,1,0,0,0,100,930,1,0,0,0,102,982,1,0,0,0,104, - 1018,1,0,0,0,106,1036,1,0,0,0,108,1038,1,0,0,0,110,1050,1,0,0,0,112,1075, - 1,0,0,0,114,1084,1,0,0,0,116,1111,1,0,0,0,118,1118,1,0,0,0,120,1126,1, - 0,0,0,122,1134,1,0,0,0,124,1147,1,0,0,0,126,1157,1,0,0,0,128,1176,1,0, - 0,0,130,1270,1,0,0,0,132,1279,1,0,0,0,134,1289,1,0,0,0,136,1291,1,0,0, - 0,138,1293,1,0,0,0,140,1318,1,0,0,0,142,1350,1,0,0,0,144,1373,1,0,0,0, - 146,1385,1,0,0,0,148,1387,1,0,0,0,150,1390,1,0,0,0,152,1443,1,0,0,0,154, - 1455,1,0,0,0,156,1470,1,0,0,0,158,1477,1,0,0,0,160,1482,1,0,0,0,162,1486, - 1,0,0,0,164,1522,1,0,0,0,166,1524,1,0,0,0,168,1560,1,0,0,0,170,1572,1, - 0,0,0,172,1586,1,0,0,0,174,1588,1,0,0,0,176,1598,1,0,0,0,178,1609,1,0, - 0,0,180,1616,1,0,0,0,182,1626,1,0,0,0,184,1639,1,0,0,0,186,1644,1,0,0, - 0,188,1647,1,0,0,0,190,1658,1,0,0,0,192,1663,1,0,0,0,194,1669,1,0,0,0, - 196,1671,1,0,0,0,198,1793,1,0,0,0,200,1795,1,0,0,0,202,1832,1,0,0,0,204, - 1839,1,0,0,0,206,1844,1,0,0,0,208,1851,1,0,0,0,210,1871,1,0,0,0,212,1873, - 1,0,0,0,214,1878,1,0,0,0,216,1893,1,0,0,0,218,1895,1,0,0,0,220,1908,1, - 0,0,0,222,1913,1,0,0,0,224,1926,1,0,0,0,226,1934,1,0,0,0,228,1945,1,0, - 0,0,230,1950,1,0,0,0,232,1966,1,0,0,0,234,1968,1,0,0,0,236,2012,1,0,0, - 0,238,2032,1,0,0,0,240,2061,1,0,0,0,242,2066,1,0,0,0,244,2089,1,0,0,0, - 246,2094,1,0,0,0,248,2114,1,0,0,0,250,2214,1,0,0,0,252,2216,1,0,0,0,254, - 2222,1,0,0,0,256,2224,1,0,0,0,258,2228,1,0,0,0,260,2232,1,0,0,0,262,2248, - 1,0,0,0,264,2262,1,0,0,0,266,2270,1,0,0,0,268,2272,1,0,0,0,270,2275,1, - 0,0,0,272,2277,1,0,0,0,274,2290,1,0,0,0,276,2292,1,0,0,0,278,2302,1,0, - 0,0,280,2307,1,0,0,0,282,2318,1,0,0,0,284,2325,1,0,0,0,286,2335,1,0,0, - 0,288,2403,1,0,0,0,290,2480,1,0,0,0,292,2487,1,0,0,0,294,2490,1,0,0,0, - 296,2495,1,0,0,0,298,2645,1,0,0,0,300,2651,1,0,0,0,302,2658,1,0,0,0,304, - 2664,1,0,0,0,306,2670,1,0,0,0,308,2676,1,0,0,0,310,2682,1,0,0,0,312,2688, - 1,0,0,0,314,2694,1,0,0,0,316,2700,1,0,0,0,318,2707,1,0,0,0,320,2712,1, - 0,0,0,322,2718,1,0,0,0,324,2745,1,0,0,0,326,2759,1,0,0,0,328,2764,1,0, - 0,0,330,2781,1,0,0,0,332,2783,1,0,0,0,334,2793,1,0,0,0,336,2817,1,0,0, - 0,338,2822,1,0,0,0,340,2838,1,0,0,0,342,2859,1,0,0,0,344,2861,1,0,0,0, - 346,2866,1,0,0,0,348,2879,1,0,0,0,350,351,7,0,0,0,351,1,1,0,0,0,352,364, - 5,288,0,0,353,354,3,4,2,0,354,355,5,265,0,0,355,357,1,0,0,0,356,353,1, - 0,0,0,357,360,1,0,0,0,358,356,1,0,0,0,358,359,1,0,0,0,359,361,1,0,0,0, - 360,358,1,0,0,0,361,364,3,4,2,0,362,364,5,264,0,0,363,352,1,0,0,0,363, - 358,1,0,0,0,363,362,1,0,0,0,364,3,1,0,0,0,365,366,7,1,0,0,366,5,1,0,0, - 0,367,368,5,263,0,0,368,370,5,266,0,0,369,367,1,0,0,0,370,373,1,0,0,0, - 371,369,1,0,0,0,371,372,1,0,0,0,372,374,1,0,0,0,373,371,1,0,0,0,374,375, - 5,263,0,0,375,7,1,0,0,0,376,378,3,10,5,0,377,376,1,0,0,0,378,381,1,0,0, - 0,379,377,1,0,0,0,379,380,1,0,0,0,380,9,1,0,0,0,381,379,1,0,0,0,382,383, - 3,74,37,0,383,384,5,17,0,0,384,385,3,82,41,0,385,386,5,18,0,0,386,433, - 1,0,0,0,387,388,3,72,36,0,388,389,5,17,0,0,389,390,3,8,4,0,390,391,5,18, - 0,0,391,433,1,0,0,0,392,393,3,234,117,0,393,394,5,17,0,0,394,395,3,246, - 123,0,395,396,5,18,0,0,396,433,1,0,0,0,397,433,3,200,100,0,398,433,3,276, - 138,0,399,433,3,70,35,0,400,433,3,66,33,0,401,433,3,88,44,0,402,433,3, - 90,45,0,403,433,3,22,11,0,404,405,3,326,163,0,405,406,5,17,0,0,406,407, - 3,328,164,0,407,408,5,18,0,0,408,433,1,0,0,0,409,410,3,332,166,0,410,411, - 5,17,0,0,411,412,3,338,169,0,412,413,5,18,0,0,413,433,1,0,0,0,414,415, - 3,342,171,0,415,416,5,17,0,0,416,417,3,346,173,0,417,418,5,18,0,0,418, - 433,1,0,0,0,419,433,3,64,32,0,420,433,3,152,76,0,421,433,3,322,161,0,422, - 433,3,12,6,0,423,433,3,14,7,0,424,433,3,16,8,0,425,433,3,18,9,0,426,433, - 3,20,10,0,427,433,3,26,13,0,428,433,3,42,21,0,429,433,3,40,20,0,430,433, - 3,30,15,0,431,433,3,24,12,0,432,382,1,0,0,0,432,387,1,0,0,0,432,392,1, - 0,0,0,432,397,1,0,0,0,432,398,1,0,0,0,432,399,1,0,0,0,432,400,1,0,0,0, - 432,401,1,0,0,0,432,402,1,0,0,0,432,403,1,0,0,0,432,404,1,0,0,0,432,409, - 1,0,0,0,432,414,1,0,0,0,432,419,1,0,0,0,432,420,1,0,0,0,432,421,1,0,0, - 0,432,422,1,0,0,0,432,423,1,0,0,0,432,424,1,0,0,0,432,425,1,0,0,0,432, - 426,1,0,0,0,432,427,1,0,0,0,432,428,1,0,0,0,432,429,1,0,0,0,432,430,1, - 0,0,0,432,431,1,0,0,0,433,11,1,0,0,0,434,435,5,19,0,0,435,436,3,32,16, - 0,436,13,1,0,0,0,437,438,5,20,0,0,438,439,3,32,16,0,439,15,1,0,0,0,440, - 441,5,21,0,0,441,442,5,22,0,0,442,443,3,32,16,0,443,17,1,0,0,0,444,445, - 5,23,0,0,445,446,3,34,17,0,446,19,1,0,0,0,447,448,5,24,0,0,448,449,3,34, - 17,0,449,21,1,0,0,0,450,451,5,25,0,0,451,452,3,98,49,0,452,453,3,2,1,0, - 453,454,5,17,0,0,454,455,3,120,60,0,455,456,5,18,0,0,456,23,1,0,0,0,457, - 458,5,26,0,0,458,25,1,0,0,0,459,460,5,27,0,0,460,474,3,28,14,0,461,462, - 5,27,0,0,462,463,3,28,14,0,463,464,5,28,0,0,464,465,3,28,14,0,465,474, - 1,0,0,0,466,467,5,27,0,0,467,468,3,28,14,0,468,469,5,28,0,0,469,470,3, - 28,14,0,470,471,5,28,0,0,471,472,3,28,14,0,472,474,1,0,0,0,473,459,1,0, - 0,0,473,461,1,0,0,0,473,466,1,0,0,0,474,27,1,0,0,0,475,476,7,2,0,0,476, - 29,1,0,0,0,477,478,5,29,0,0,478,482,5,17,0,0,479,481,3,116,58,0,480,479, - 1,0,0,0,481,484,1,0,0,0,482,480,1,0,0,0,482,483,1,0,0,0,483,485,1,0,0, - 0,484,482,1,0,0,0,485,486,5,18,0,0,486,31,1,0,0,0,487,488,5,173,0,0,488, - 33,1,0,0,0,489,490,7,3,0,0,490,35,1,0,0,0,491,507,5,175,0,0,492,493,3, - 32,16,0,493,494,5,265,0,0,494,507,1,0,0,0,495,507,3,32,16,0,496,497,5, - 188,0,0,497,498,5,30,0,0,498,499,3,32,16,0,499,500,5,31,0,0,500,507,1, - 0,0,0,501,502,5,189,0,0,502,503,5,30,0,0,503,504,3,34,17,0,504,505,5,31, - 0,0,505,507,1,0,0,0,506,491,1,0,0,0,506,492,1,0,0,0,506,495,1,0,0,0,506, - 496,1,0,0,0,506,501,1,0,0,0,507,37,1,0,0,0,508,511,3,32,16,0,509,511,5, - 262,0,0,510,508,1,0,0,0,510,509,1,0,0,0,511,39,1,0,0,0,512,513,5,267,0, - 0,513,529,5,289,0,0,514,515,5,267,0,0,515,516,5,289,0,0,516,529,5,263, - 0,0,517,518,5,268,0,0,518,529,5,289,0,0,519,520,5,269,0,0,520,529,5,289, - 0,0,521,522,5,270,0,0,522,529,5,289,0,0,523,529,5,271,0,0,524,529,5,272, - 0,0,525,526,5,273,0,0,526,529,5,263,0,0,527,529,5,32,0,0,528,512,1,0,0, - 0,528,514,1,0,0,0,528,517,1,0,0,0,528,519,1,0,0,0,528,521,1,0,0,0,528, - 523,1,0,0,0,528,524,1,0,0,0,528,525,1,0,0,0,528,527,1,0,0,0,529,41,1,0, - 0,0,530,531,5,33,0,0,531,532,3,138,69,0,532,533,5,34,0,0,533,534,3,2,1, - 0,534,556,1,0,0,0,535,536,5,33,0,0,536,537,3,116,58,0,537,538,5,34,0,0, - 538,539,3,2,1,0,539,556,1,0,0,0,540,541,5,33,0,0,541,542,3,176,88,0,542, - 543,5,34,0,0,543,544,3,2,1,0,544,556,1,0,0,0,545,546,5,33,0,0,546,547, - 3,44,22,0,547,548,5,34,0,0,548,549,3,2,1,0,549,556,1,0,0,0,550,551,5,33, - 0,0,551,552,3,46,23,0,552,553,5,34,0,0,553,554,3,2,1,0,554,556,1,0,0,0, - 555,530,1,0,0,0,555,535,1,0,0,0,555,540,1,0,0,0,555,545,1,0,0,0,555,550, - 1,0,0,0,556,43,1,0,0,0,557,558,5,35,0,0,558,579,3,48,24,0,559,560,5,35, - 0,0,560,561,3,48,24,0,561,562,5,36,0,0,562,563,3,6,3,0,563,579,1,0,0,0, - 564,565,5,35,0,0,565,566,3,48,24,0,566,567,5,36,0,0,567,568,5,17,0,0,568, - 569,3,52,26,0,569,570,5,18,0,0,570,579,1,0,0,0,571,572,5,35,0,0,572,573, - 3,48,24,0,573,574,5,36,0,0,574,575,5,30,0,0,575,576,3,292,146,0,576,577, - 5,31,0,0,577,579,1,0,0,0,578,557,1,0,0,0,578,559,1,0,0,0,578,564,1,0,0, - 0,578,571,1,0,0,0,579,45,1,0,0,0,580,581,5,35,0,0,581,582,5,30,0,0,582, - 583,3,50,25,0,583,584,5,31,0,0,584,585,3,48,24,0,585,615,1,0,0,0,586,587, - 5,35,0,0,587,588,5,30,0,0,588,589,3,50,25,0,589,590,5,31,0,0,590,591,3, - 48,24,0,591,592,5,36,0,0,592,593,3,6,3,0,593,615,1,0,0,0,594,595,5,35, - 0,0,595,596,5,30,0,0,596,597,3,50,25,0,597,598,5,31,0,0,598,599,3,48,24, - 0,599,600,5,36,0,0,600,601,5,17,0,0,601,602,3,52,26,0,602,603,5,18,0,0, - 603,615,1,0,0,0,604,605,5,35,0,0,605,606,5,30,0,0,606,607,3,50,25,0,607, - 608,5,31,0,0,608,609,3,48,24,0,609,610,5,36,0,0,610,611,5,30,0,0,611,612, - 3,292,146,0,612,613,5,31,0,0,613,615,1,0,0,0,614,580,1,0,0,0,614,586,1, - 0,0,0,614,594,1,0,0,0,614,604,1,0,0,0,615,47,1,0,0,0,616,617,3,168,84, - 0,617,49,1,0,0,0,618,621,3,124,62,0,619,621,3,176,88,0,620,618,1,0,0,0, - 620,619,1,0,0,0,621,51,1,0,0,0,622,623,3,54,27,0,623,624,3,56,28,0,624, - 53,1,0,0,0,625,628,3,298,149,0,626,628,3,40,20,0,627,625,1,0,0,0,627,626, - 1,0,0,0,628,631,1,0,0,0,629,627,1,0,0,0,629,630,1,0,0,0,630,55,1,0,0,0, - 631,629,1,0,0,0,632,633,3,58,29,0,633,634,3,60,30,0,634,635,3,2,1,0,635, - 636,5,36,0,0,636,637,3,298,149,0,637,640,1,0,0,0,638,640,3,40,20,0,639, - 632,1,0,0,0,639,638,1,0,0,0,640,643,1,0,0,0,641,639,1,0,0,0,641,642,1, - 0,0,0,642,57,1,0,0,0,643,641,1,0,0,0,644,645,7,4,0,0,645,59,1,0,0,0,646, - 648,3,62,31,0,647,649,5,261,0,0,648,647,1,0,0,0,648,649,1,0,0,0,649,61, - 1,0,0,0,650,660,3,144,72,0,651,660,3,2,1,0,652,660,5,196,0,0,653,660,5, - 197,0,0,654,655,5,202,0,0,655,656,5,39,0,0,656,660,5,264,0,0,657,658,5, - 202,0,0,658,660,3,116,58,0,659,650,1,0,0,0,659,651,1,0,0,0,659,652,1,0, - 0,0,659,653,1,0,0,0,659,654,1,0,0,0,659,657,1,0,0,0,660,63,1,0,0,0,661, - 662,5,198,0,0,662,663,5,40,0,0,663,668,3,2,1,0,664,665,5,198,0,0,665,668, - 3,2,1,0,666,668,5,198,0,0,667,661,1,0,0,0,667,664,1,0,0,0,667,666,1,0, - 0,0,668,65,1,0,0,0,669,670,5,41,0,0,670,671,5,42,0,0,671,672,3,32,16,0, - 672,673,5,43,0,0,673,674,3,68,34,0,674,675,5,44,0,0,675,676,3,0,0,0,676, - 67,1,0,0,0,677,690,6,34,-1,0,678,679,10,5,0,0,679,689,5,186,0,0,680,681, - 10,4,0,0,681,689,5,187,0,0,682,683,10,3,0,0,683,689,5,45,0,0,684,685,10, - 2,0,0,685,689,5,46,0,0,686,687,10,1,0,0,687,689,5,47,0,0,688,678,1,0,0, - 0,688,680,1,0,0,0,688,682,1,0,0,0,688,684,1,0,0,0,688,686,1,0,0,0,689, - 692,1,0,0,0,690,688,1,0,0,0,690,691,1,0,0,0,691,69,1,0,0,0,692,690,1,0, - 0,0,693,694,5,48,0,0,694,695,5,36,0,0,695,696,5,30,0,0,696,697,3,292,146, - 0,697,698,5,31,0,0,698,71,1,0,0,0,699,700,5,49,0,0,700,701,3,2,1,0,701, - 73,1,0,0,0,702,706,5,50,0,0,703,705,3,76,38,0,704,703,1,0,0,0,705,708, - 1,0,0,0,706,704,1,0,0,0,706,707,1,0,0,0,707,709,1,0,0,0,708,706,1,0,0, - 0,709,710,3,2,1,0,710,711,3,182,91,0,711,712,3,78,39,0,712,713,3,80,40, - 0,713,75,1,0,0,0,714,752,5,51,0,0,715,752,5,52,0,0,716,752,5,199,0,0,717, - 752,5,202,0,0,718,752,5,221,0,0,719,752,5,53,0,0,720,752,5,54,0,0,721, - 752,5,55,0,0,722,752,5,56,0,0,723,752,5,244,0,0,724,752,5,15,0,0,725,752, - 5,224,0,0,726,752,5,57,0,0,727,752,5,58,0,0,728,752,5,59,0,0,729,752,5, - 60,0,0,730,752,5,61,0,0,731,732,5,62,0,0,732,752,5,51,0,0,733,734,5,62, - 0,0,734,752,5,52,0,0,735,736,5,62,0,0,736,752,5,63,0,0,737,738,5,62,0, - 0,738,752,5,64,0,0,739,740,5,62,0,0,740,752,5,65,0,0,741,742,5,62,0,0, - 742,752,5,66,0,0,743,752,5,67,0,0,744,752,5,68,0,0,745,752,5,69,0,0,746, - 747,5,70,0,0,747,748,5,30,0,0,748,749,3,32,16,0,749,750,5,31,0,0,750,752, - 1,0,0,0,751,714,1,0,0,0,751,715,1,0,0,0,751,716,1,0,0,0,751,717,1,0,0, - 0,751,718,1,0,0,0,751,719,1,0,0,0,751,720,1,0,0,0,751,721,1,0,0,0,751, - 722,1,0,0,0,751,723,1,0,0,0,751,724,1,0,0,0,751,725,1,0,0,0,751,726,1, - 0,0,0,751,727,1,0,0,0,751,728,1,0,0,0,751,729,1,0,0,0,751,730,1,0,0,0, - 751,731,1,0,0,0,751,733,1,0,0,0,751,735,1,0,0,0,751,737,1,0,0,0,751,739, - 1,0,0,0,751,741,1,0,0,0,751,743,1,0,0,0,751,744,1,0,0,0,751,745,1,0,0, - 0,751,746,1,0,0,0,752,77,1,0,0,0,753,757,1,0,0,0,754,755,5,71,0,0,755, - 757,3,124,62,0,756,753,1,0,0,0,756,754,1,0,0,0,757,79,1,0,0,0,758,762, - 1,0,0,0,759,760,5,72,0,0,760,762,3,84,42,0,761,758,1,0,0,0,761,759,1,0, - 0,0,762,81,1,0,0,0,763,765,3,198,99,0,764,763,1,0,0,0,765,768,1,0,0,0, - 766,764,1,0,0,0,766,767,1,0,0,0,767,83,1,0,0,0,768,766,1,0,0,0,769,770, - 3,124,62,0,770,771,5,28,0,0,771,773,1,0,0,0,772,769,1,0,0,0,773,776,1, - 0,0,0,774,772,1,0,0,0,774,775,1,0,0,0,775,777,1,0,0,0,776,774,1,0,0,0, - 777,778,3,124,62,0,778,85,1,0,0,0,779,780,7,5,0,0,780,87,1,0,0,0,781,782, - 3,86,43,0,782,783,3,32,16,0,783,784,5,264,0,0,784,885,1,0,0,0,785,786, - 3,86,43,0,786,787,3,32,16,0,787,885,1,0,0,0,788,789,3,86,43,0,789,790, - 3,32,16,0,790,791,5,75,0,0,791,792,3,32,16,0,792,793,5,264,0,0,793,885, - 1,0,0,0,794,795,3,86,43,0,795,796,3,32,16,0,796,797,5,75,0,0,797,798,3, - 32,16,0,798,885,1,0,0,0,799,800,3,86,43,0,800,801,3,32,16,0,801,802,5, - 75,0,0,802,803,3,32,16,0,803,804,5,28,0,0,804,805,3,32,16,0,805,806,5, - 264,0,0,806,885,1,0,0,0,807,808,3,86,43,0,808,809,3,32,16,0,809,810,5, - 75,0,0,810,811,3,32,16,0,811,812,5,28,0,0,812,813,3,32,16,0,813,885,1, - 0,0,0,814,815,3,86,43,0,815,816,3,32,16,0,816,817,5,28,0,0,817,818,3,32, - 16,0,818,819,5,75,0,0,819,820,3,32,16,0,820,821,5,264,0,0,821,885,1,0, - 0,0,822,823,3,86,43,0,823,824,3,32,16,0,824,825,5,28,0,0,825,826,3,32, - 16,0,826,827,5,75,0,0,827,828,3,32,16,0,828,885,1,0,0,0,829,830,3,86,43, - 0,830,831,3,32,16,0,831,832,5,28,0,0,832,833,3,32,16,0,833,834,5,75,0, - 0,834,835,3,32,16,0,835,836,5,28,0,0,836,837,3,32,16,0,837,838,5,264,0, - 0,838,885,1,0,0,0,839,840,3,86,43,0,840,841,3,32,16,0,841,842,5,28,0,0, - 842,843,3,32,16,0,843,844,5,75,0,0,844,845,3,32,16,0,845,846,5,28,0,0, - 846,847,3,32,16,0,847,885,1,0,0,0,848,849,3,86,43,0,849,850,3,32,16,0, - 850,851,5,263,0,0,851,885,1,0,0,0,852,853,3,86,43,0,853,854,3,32,16,0, - 854,855,5,75,0,0,855,856,3,32,16,0,856,857,5,263,0,0,857,885,1,0,0,0,858, - 859,3,86,43,0,859,860,3,32,16,0,860,861,5,75,0,0,861,862,3,32,16,0,862, - 863,5,28,0,0,863,864,3,32,16,0,864,865,5,263,0,0,865,885,1,0,0,0,866,867, - 3,86,43,0,867,868,3,32,16,0,868,869,5,28,0,0,869,870,3,32,16,0,870,871, - 5,75,0,0,871,872,3,32,16,0,872,873,5,263,0,0,873,885,1,0,0,0,874,875,3, - 86,43,0,875,876,3,32,16,0,876,877,5,28,0,0,877,878,3,32,16,0,878,879,5, - 75,0,0,879,880,3,32,16,0,880,881,5,28,0,0,881,882,3,32,16,0,882,883,5, - 263,0,0,883,885,1,0,0,0,884,781,1,0,0,0,884,785,1,0,0,0,884,788,1,0,0, - 0,884,794,1,0,0,0,884,799,1,0,0,0,884,807,1,0,0,0,884,814,1,0,0,0,884, - 822,1,0,0,0,884,829,1,0,0,0,884,839,1,0,0,0,884,848,1,0,0,0,884,852,1, - 0,0,0,884,858,1,0,0,0,884,866,1,0,0,0,884,874,1,0,0,0,885,89,1,0,0,0,886, - 890,5,21,0,0,887,889,3,92,46,0,888,887,1,0,0,0,889,892,1,0,0,0,890,888, - 1,0,0,0,890,891,1,0,0,0,891,893,1,0,0,0,892,890,1,0,0,0,893,894,3,2,1, - 0,894,895,3,94,47,0,895,896,5,180,0,0,896,897,5,36,0,0,897,898,5,30,0, - 0,898,899,3,292,146,0,899,900,5,31,0,0,900,901,3,94,47,0,901,913,1,0,0, - 0,902,906,5,21,0,0,903,905,3,92,46,0,904,903,1,0,0,0,905,908,1,0,0,0,906, - 904,1,0,0,0,906,907,1,0,0,0,907,909,1,0,0,0,908,906,1,0,0,0,909,910,3, - 2,1,0,910,911,3,94,47,0,911,913,1,0,0,0,912,886,1,0,0,0,912,902,1,0,0, - 0,913,91,1,0,0,0,914,915,5,76,0,0,915,93,1,0,0,0,916,919,1,0,0,0,917,919, - 5,298,0,0,918,916,1,0,0,0,918,917,1,0,0,0,919,95,1,0,0,0,920,921,7,6,0, - 0,921,97,1,0,0,0,922,924,3,96,48,0,923,922,1,0,0,0,924,927,1,0,0,0,925, - 923,1,0,0,0,925,926,1,0,0,0,926,99,1,0,0,0,927,925,1,0,0,0,928,931,3,102, - 51,0,929,931,3,104,52,0,930,928,1,0,0,0,930,929,1,0,0,0,931,101,1,0,0, - 0,932,933,5,275,0,0,933,983,6,51,-1,0,934,935,5,276,0,0,935,936,3,32,16, - 0,936,937,6,51,-1,0,937,983,1,0,0,0,938,939,5,276,0,0,939,940,3,0,0,0, - 940,941,6,51,-1,0,941,983,1,0,0,0,942,943,5,277,0,0,943,944,3,32,16,0, - 944,945,6,51,-1,0,945,983,1,0,0,0,946,947,5,278,0,0,947,948,3,34,17,0, - 948,949,6,51,-1,0,949,983,1,0,0,0,950,951,5,279,0,0,951,952,5,30,0,0,952, - 953,3,292,146,0,953,954,5,31,0,0,954,955,6,51,-1,0,955,983,1,0,0,0,956, - 957,5,279,0,0,957,958,5,84,0,0,958,959,5,30,0,0,959,960,3,292,146,0,960, - 961,5,31,0,0,961,962,6,51,-1,0,962,983,1,0,0,0,963,964,5,282,0,0,964,965, - 3,32,16,0,965,966,6,51,-1,0,966,983,1,0,0,0,967,968,5,282,0,0,968,969, - 3,0,0,0,969,970,6,51,-1,0,970,983,1,0,0,0,971,972,5,285,0,0,972,973,5, - 84,0,0,973,974,5,30,0,0,974,975,3,292,146,0,975,976,5,31,0,0,976,977,6, - 51,-1,0,977,983,1,0,0,0,978,979,5,287,0,0,979,980,3,32,16,0,980,981,6, - 51,-1,0,981,983,1,0,0,0,982,932,1,0,0,0,982,934,1,0,0,0,982,938,1,0,0, - 0,982,942,1,0,0,0,982,946,1,0,0,0,982,950,1,0,0,0,982,956,1,0,0,0,982, - 963,1,0,0,0,982,967,1,0,0,0,982,971,1,0,0,0,982,978,1,0,0,0,983,103,1, - 0,0,0,984,985,5,279,0,0,985,1019,3,36,18,0,986,987,5,279,0,0,987,1019, - 3,34,17,0,988,989,5,280,0,0,989,1019,3,168,84,0,990,991,5,286,0,0,991, - 1019,3,178,89,0,992,993,5,286,0,0,993,1019,3,174,87,0,994,995,5,284,0, - 0,995,1019,3,124,62,0,996,997,5,285,0,0,997,1019,3,6,3,0,998,999,5,285, - 0,0,999,1000,5,224,0,0,1000,1001,5,30,0,0,1001,1002,3,6,3,0,1002,1003, - 5,31,0,0,1003,1019,1,0,0,0,1004,1005,5,281,0,0,1005,1006,3,170,85,0,1006, - 1007,3,138,69,0,1007,1008,3,112,56,0,1008,1019,1,0,0,0,1009,1010,5,287, - 0,0,1010,1019,3,50,25,0,1011,1012,5,283,0,0,1012,1013,5,30,0,0,1013,1014, - 3,106,53,0,1014,1015,5,31,0,0,1015,1019,1,0,0,0,1016,1017,5,283,0,0,1017, - 1019,5,85,0,0,1018,984,1,0,0,0,1018,986,1,0,0,0,1018,988,1,0,0,0,1018, - 990,1,0,0,0,1018,992,1,0,0,0,1018,994,1,0,0,0,1018,996,1,0,0,0,1018,998, - 1,0,0,0,1018,1004,1,0,0,0,1018,1009,1,0,0,0,1018,1011,1,0,0,0,1018,1016, - 1,0,0,0,1019,105,1,0,0,0,1020,1037,1,0,0,0,1021,1024,3,0,0,0,1022,1024, - 3,32,16,0,1023,1021,1,0,0,0,1023,1022,1,0,0,0,1024,1025,1,0,0,0,1025,1026, - 5,28,0,0,1026,1028,1,0,0,0,1027,1023,1,0,0,0,1028,1031,1,0,0,0,1029,1027, - 1,0,0,0,1029,1030,1,0,0,0,1030,1034,1,0,0,0,1031,1029,1,0,0,0,1032,1035, - 3,0,0,0,1033,1035,3,32,16,0,1034,1032,1,0,0,0,1034,1033,1,0,0,0,1035,1037, - 1,0,0,0,1036,1020,1,0,0,0,1036,1029,1,0,0,0,1037,107,1,0,0,0,1038,1044, - 5,86,0,0,1039,1040,3,138,69,0,1040,1041,5,28,0,0,1041,1043,1,0,0,0,1042, - 1039,1,0,0,0,1043,1046,1,0,0,0,1044,1042,1,0,0,0,1044,1045,1,0,0,0,1045, - 1047,1,0,0,0,1046,1044,1,0,0,0,1047,1048,3,138,69,0,1048,1049,5,87,0,0, - 1049,109,1,0,0,0,1050,1056,5,42,0,0,1051,1052,3,146,73,0,1052,1053,5,28, - 0,0,1053,1055,1,0,0,0,1054,1051,1,0,0,0,1055,1058,1,0,0,0,1056,1054,1, - 0,0,0,1056,1057,1,0,0,0,1057,1059,1,0,0,0,1058,1056,1,0,0,0,1059,1060, - 3,146,73,0,1060,1061,5,43,0,0,1061,111,1,0,0,0,1062,1068,5,30,0,0,1063, - 1064,3,114,57,0,1064,1065,5,28,0,0,1065,1067,1,0,0,0,1066,1063,1,0,0,0, - 1067,1070,1,0,0,0,1068,1066,1,0,0,0,1068,1069,1,0,0,0,1069,1071,1,0,0, - 0,1070,1068,1,0,0,0,1071,1072,3,114,57,0,1072,1073,5,31,0,0,1073,1076, - 1,0,0,0,1074,1076,5,85,0,0,1075,1062,1,0,0,0,1075,1074,1,0,0,0,1076,113, - 1,0,0,0,1077,1085,5,177,0,0,1078,1079,3,230,115,0,1079,1080,3,138,69,0, - 1080,1082,3,226,113,0,1081,1083,3,0,0,0,1082,1081,1,0,0,0,1082,1083,1, - 0,0,0,1083,1085,1,0,0,0,1084,1077,1,0,0,0,1084,1078,1,0,0,0,1085,115,1, - 0,0,0,1086,1087,5,42,0,0,1087,1088,3,2,1,0,1088,1089,5,43,0,0,1089,1090, - 3,118,59,0,1090,1112,1,0,0,0,1091,1092,5,42,0,0,1092,1093,3,174,87,0,1093, - 1094,5,43,0,0,1094,1095,3,118,59,0,1095,1112,1,0,0,0,1096,1097,5,42,0, - 0,1097,1098,5,262,0,0,1098,1099,5,43,0,0,1099,1112,3,118,59,0,1100,1101, - 5,42,0,0,1101,1102,5,198,0,0,1102,1103,3,2,1,0,1103,1104,5,43,0,0,1104, - 1105,3,118,59,0,1105,1112,1,0,0,0,1106,1112,3,118,59,0,1107,1112,3,174, - 87,0,1108,1112,5,257,0,0,1109,1112,5,258,0,0,1110,1112,5,259,0,0,1111, - 1086,1,0,0,0,1111,1091,1,0,0,0,1111,1096,1,0,0,0,1111,1100,1,0,0,0,1111, - 1106,1,0,0,0,1111,1107,1,0,0,0,1111,1108,1,0,0,0,1111,1109,1,0,0,0,1111, - 1110,1,0,0,0,1112,117,1,0,0,0,1113,1114,3,2,1,0,1114,1115,5,88,0,0,1115, - 1117,1,0,0,0,1116,1113,1,0,0,0,1117,1120,1,0,0,0,1118,1116,1,0,0,0,1118, - 1119,1,0,0,0,1119,1121,1,0,0,0,1120,1118,1,0,0,0,1121,1122,3,2,1,0,1122, - 119,1,0,0,0,1123,1125,3,122,61,0,1124,1123,1,0,0,0,1125,1128,1,0,0,0,1126, - 1124,1,0,0,0,1126,1127,1,0,0,0,1127,121,1,0,0,0,1128,1126,1,0,0,0,1129, - 1130,5,180,0,0,1130,1131,5,89,0,0,1131,1135,3,32,16,0,1132,1135,3,152, - 76,0,1133,1135,3,324,162,0,1134,1129,1,0,0,0,1134,1132,1,0,0,0,1134,1133, - 1,0,0,0,1135,123,1,0,0,0,1136,1148,3,116,58,0,1137,1138,5,42,0,0,1138, - 1139,3,2,1,0,1139,1140,5,43,0,0,1140,1148,1,0,0,0,1141,1142,5,42,0,0,1142, - 1143,5,198,0,0,1143,1144,3,2,1,0,1144,1145,5,43,0,0,1145,1148,1,0,0,0, - 1146,1148,3,138,69,0,1147,1136,1,0,0,0,1147,1137,1,0,0,0,1147,1141,1,0, - 0,0,1147,1146,1,0,0,0,1148,125,1,0,0,0,1149,1158,1,0,0,0,1150,1154,3,130, - 65,0,1151,1153,3,128,64,0,1152,1151,1,0,0,0,1153,1156,1,0,0,0,1154,1152, - 1,0,0,0,1154,1155,1,0,0,0,1155,1158,1,0,0,0,1156,1154,1,0,0,0,1157,1149, - 1,0,0,0,1157,1150,1,0,0,0,1158,127,1,0,0,0,1159,1177,5,262,0,0,1160,1177, - 5,261,0,0,1161,1162,5,42,0,0,1162,1163,3,32,16,0,1163,1164,5,43,0,0,1164, - 1177,1,0,0,0,1165,1166,5,42,0,0,1166,1167,3,32,16,0,1167,1168,5,266,0, - 0,1168,1169,3,32,16,0,1169,1170,5,43,0,0,1170,1177,1,0,0,0,1171,1172,5, - 42,0,0,1172,1173,5,266,0,0,1173,1174,3,32,16,0,1174,1175,5,43,0,0,1175, - 1177,1,0,0,0,1176,1159,1,0,0,0,1176,1160,1,0,0,0,1176,1161,1,0,0,0,1176, - 1165,1,0,0,0,1176,1171,1,0,0,0,1177,129,1,0,0,0,1178,1271,1,0,0,0,1179, - 1180,5,203,0,0,1180,1181,5,30,0,0,1181,1182,3,6,3,0,1182,1183,5,28,0,0, - 1183,1184,3,6,3,0,1184,1185,5,28,0,0,1185,1186,3,6,3,0,1186,1187,5,28, - 0,0,1187,1188,3,6,3,0,1188,1189,5,31,0,0,1189,1271,1,0,0,0,1190,1191,5, - 203,0,0,1191,1192,5,30,0,0,1192,1193,3,6,3,0,1193,1194,5,28,0,0,1194,1195, - 3,6,3,0,1195,1196,5,31,0,0,1196,1271,1,0,0,0,1197,1198,5,204,0,0,1198, - 1199,5,205,0,0,1199,1200,5,42,0,0,1200,1201,3,32,16,0,1201,1202,5,43,0, - 0,1202,1271,1,0,0,0,1203,1204,5,204,0,0,1204,1205,5,206,0,0,1205,1206, - 5,42,0,0,1206,1207,3,32,16,0,1207,1208,5,43,0,0,1208,1209,3,126,63,0,1209, - 1271,1,0,0,0,1210,1271,5,207,0,0,1211,1271,5,208,0,0,1212,1271,5,209,0, - 0,1213,1271,5,201,0,0,1214,1271,5,183,0,0,1215,1271,5,184,0,0,1216,1271, - 5,185,0,0,1217,1271,5,186,0,0,1218,1271,5,187,0,0,1219,1271,5,188,0,0, - 1220,1271,5,189,0,0,1221,1271,5,210,0,0,1222,1271,5,190,0,0,1223,1271, - 5,191,0,0,1224,1271,5,192,0,0,1225,1271,5,193,0,0,1226,1271,5,211,0,0, - 1227,1271,5,212,0,0,1228,1271,5,213,0,0,1229,1271,5,214,0,0,1230,1271, - 5,215,0,0,1231,1271,5,216,0,0,1232,1271,5,217,0,0,1233,1234,5,218,0,0, - 1234,1271,3,132,66,0,1235,1236,5,219,0,0,1236,1271,3,132,66,0,1237,1271, - 5,220,0,0,1238,1239,5,221,0,0,1239,1271,3,132,66,0,1240,1241,5,222,0,0, - 1241,1271,3,134,67,0,1242,1243,5,222,0,0,1243,1244,3,134,67,0,1244,1245, - 5,28,0,0,1245,1246,3,6,3,0,1246,1271,1,0,0,0,1247,1271,5,194,0,0,1248, - 1271,5,195,0,0,1249,1250,5,90,0,0,1250,1271,5,184,0,0,1251,1252,5,90,0, - 0,1252,1271,5,185,0,0,1253,1254,5,90,0,0,1254,1271,5,186,0,0,1255,1256, - 5,90,0,0,1256,1271,5,187,0,0,1257,1258,5,62,0,0,1258,1271,5,220,0,0,1259, - 1271,5,223,0,0,1260,1261,5,224,0,0,1261,1271,5,213,0,0,1262,1271,5,225, - 0,0,1263,1264,5,207,0,0,1264,1271,5,183,0,0,1265,1271,5,226,0,0,1266,1271, - 5,228,0,0,1267,1268,5,34,0,0,1268,1271,5,227,0,0,1269,1271,3,2,1,0,1270, - 1178,1,0,0,0,1270,1179,1,0,0,0,1270,1190,1,0,0,0,1270,1197,1,0,0,0,1270, - 1203,1,0,0,0,1270,1210,1,0,0,0,1270,1211,1,0,0,0,1270,1212,1,0,0,0,1270, - 1213,1,0,0,0,1270,1214,1,0,0,0,1270,1215,1,0,0,0,1270,1216,1,0,0,0,1270, - 1217,1,0,0,0,1270,1218,1,0,0,0,1270,1219,1,0,0,0,1270,1220,1,0,0,0,1270, - 1221,1,0,0,0,1270,1222,1,0,0,0,1270,1223,1,0,0,0,1270,1224,1,0,0,0,1270, - 1225,1,0,0,0,1270,1226,1,0,0,0,1270,1227,1,0,0,0,1270,1228,1,0,0,0,1270, - 1229,1,0,0,0,1270,1230,1,0,0,0,1270,1231,1,0,0,0,1270,1232,1,0,0,0,1270, - 1233,1,0,0,0,1270,1235,1,0,0,0,1270,1237,1,0,0,0,1270,1238,1,0,0,0,1270, - 1240,1,0,0,0,1270,1242,1,0,0,0,1270,1247,1,0,0,0,1270,1248,1,0,0,0,1270, - 1249,1,0,0,0,1270,1251,1,0,0,0,1270,1253,1,0,0,0,1270,1255,1,0,0,0,1270, - 1257,1,0,0,0,1270,1259,1,0,0,0,1270,1260,1,0,0,0,1270,1262,1,0,0,0,1270, - 1263,1,0,0,0,1270,1265,1,0,0,0,1270,1266,1,0,0,0,1270,1267,1,0,0,0,1270, - 1269,1,0,0,0,1271,131,1,0,0,0,1272,1280,1,0,0,0,1273,1274,5,30,0,0,1274, - 1275,5,91,0,0,1275,1276,5,36,0,0,1276,1277,3,32,16,0,1277,1278,5,31,0, - 0,1278,1280,1,0,0,0,1279,1272,1,0,0,0,1279,1273,1,0,0,0,1280,133,1,0,0, - 0,1281,1290,1,0,0,0,1282,1286,3,136,68,0,1283,1285,7,7,0,0,1284,1283,1, - 0,0,0,1285,1288,1,0,0,0,1286,1284,1,0,0,0,1286,1287,1,0,0,0,1287,1290, - 1,0,0,0,1288,1286,1,0,0,0,1289,1281,1,0,0,0,1289,1282,1,0,0,0,1290,135, - 1,0,0,0,1291,1292,7,8,0,0,1292,137,1,0,0,0,1293,1297,3,142,71,0,1294,1296, - 3,140,70,0,1295,1294,1,0,0,0,1296,1299,1,0,0,0,1297,1295,1,0,0,0,1297, - 1298,1,0,0,0,1298,139,1,0,0,0,1299,1297,1,0,0,0,1300,1319,5,261,0,0,1301, - 1302,5,42,0,0,1302,1319,5,43,0,0,1303,1319,3,110,55,0,1304,1319,5,260, - 0,0,1305,1319,5,262,0,0,1306,1319,5,92,0,0,1307,1308,5,93,0,0,1308,1309, - 5,30,0,0,1309,1310,3,124,62,0,1310,1311,5,31,0,0,1311,1319,1,0,0,0,1312, - 1313,5,94,0,0,1313,1314,5,30,0,0,1314,1315,3,124,62,0,1315,1316,5,31,0, - 0,1316,1319,1,0,0,0,1317,1319,3,108,54,0,1318,1300,1,0,0,0,1318,1301,1, - 0,0,0,1318,1303,1,0,0,0,1318,1304,1,0,0,0,1318,1305,1,0,0,0,1318,1306, - 1,0,0,0,1318,1307,1,0,0,0,1318,1312,1,0,0,0,1318,1317,1,0,0,0,1319,141, - 1,0,0,0,1320,1321,5,39,0,0,1321,1351,3,116,58,0,1322,1351,5,197,0,0,1323, - 1324,5,199,0,0,1324,1325,5,39,0,0,1325,1351,3,116,58,0,1326,1327,5,200, - 0,0,1327,1351,3,116,58,0,1328,1329,5,226,0,0,1329,1330,3,170,85,0,1330, - 1331,3,138,69,0,1331,1332,5,262,0,0,1332,1333,3,112,56,0,1333,1351,1,0, - 0,0,1334,1335,5,253,0,0,1335,1351,3,32,16,0,1336,1337,5,252,0,0,1337,1351, - 3,32,16,0,1338,1339,5,253,0,0,1339,1351,3,2,1,0,1340,1341,5,252,0,0,1341, - 1351,3,2,1,0,1342,1351,5,254,0,0,1343,1351,5,201,0,0,1344,1351,3,148,74, - 0,1345,1351,3,150,75,0,1346,1351,3,144,72,0,1347,1351,3,2,1,0,1348,1349, - 5,177,0,0,1349,1351,3,138,69,0,1350,1320,1,0,0,0,1350,1322,1,0,0,0,1350, - 1323,1,0,0,0,1350,1326,1,0,0,0,1350,1328,1,0,0,0,1350,1334,1,0,0,0,1350, - 1336,1,0,0,0,1350,1338,1,0,0,0,1350,1340,1,0,0,0,1350,1342,1,0,0,0,1350, - 1343,1,0,0,0,1350,1344,1,0,0,0,1350,1345,1,0,0,0,1350,1346,1,0,0,0,1350, - 1347,1,0,0,0,1350,1348,1,0,0,0,1351,143,1,0,0,0,1352,1374,5,181,0,0,1353, - 1374,5,182,0,0,1354,1374,5,183,0,0,1355,1374,5,184,0,0,1356,1374,5,185, - 0,0,1357,1374,5,186,0,0,1358,1374,5,187,0,0,1359,1374,5,188,0,0,1360,1374, - 5,189,0,0,1361,1374,5,190,0,0,1362,1374,5,191,0,0,1363,1374,5,192,0,0, - 1364,1374,5,193,0,0,1365,1366,5,90,0,0,1366,1374,5,184,0,0,1367,1368,5, - 90,0,0,1368,1374,5,185,0,0,1369,1370,5,90,0,0,1370,1374,5,186,0,0,1371, - 1372,5,90,0,0,1372,1374,5,187,0,0,1373,1352,1,0,0,0,1373,1353,1,0,0,0, - 1373,1354,1,0,0,0,1373,1355,1,0,0,0,1373,1356,1,0,0,0,1373,1357,1,0,0, - 0,1373,1358,1,0,0,0,1373,1359,1,0,0,0,1373,1360,1,0,0,0,1373,1361,1,0, - 0,0,1373,1362,1,0,0,0,1373,1363,1,0,0,0,1373,1364,1,0,0,0,1373,1365,1, - 0,0,0,1373,1367,1,0,0,0,1373,1369,1,0,0,0,1373,1371,1,0,0,0,1374,145,1, - 0,0,0,1375,1386,1,0,0,0,1376,1386,5,177,0,0,1377,1386,3,32,16,0,1378,1379, - 3,32,16,0,1379,1380,5,177,0,0,1380,1381,3,32,16,0,1381,1386,1,0,0,0,1382, - 1383,3,32,16,0,1383,1384,5,177,0,0,1384,1386,1,0,0,0,1385,1375,1,0,0,0, - 1385,1376,1,0,0,0,1385,1377,1,0,0,0,1385,1378,1,0,0,0,1385,1382,1,0,0, - 0,1386,147,1,0,0,0,1387,1388,5,1,0,0,1388,1389,5,194,0,0,1389,149,1,0, - 0,0,1390,1394,5,1,0,0,1391,1392,5,90,0,0,1392,1395,5,194,0,0,1393,1395, - 5,195,0,0,1394,1391,1,0,0,0,1394,1393,1,0,0,0,1395,151,1,0,0,0,1396,1397, - 5,294,0,0,1397,1398,3,166,83,0,1398,1399,3,124,62,0,1399,1400,5,30,0,0, - 1400,1401,3,158,79,0,1401,1402,5,31,0,0,1402,1444,1,0,0,0,1403,1404,5, - 294,0,0,1404,1405,3,166,83,0,1405,1406,3,124,62,0,1406,1407,5,36,0,0,1407, - 1408,5,17,0,0,1408,1409,3,52,26,0,1409,1410,5,18,0,0,1410,1444,1,0,0,0, - 1411,1412,5,294,0,0,1412,1413,3,166,83,0,1413,1414,3,124,62,0,1414,1444, - 1,0,0,0,1415,1416,5,295,0,0,1416,1417,3,166,83,0,1417,1419,5,36,0,0,1418, - 1420,5,84,0,0,1419,1418,1,0,0,0,1419,1420,1,0,0,0,1420,1421,1,0,0,0,1421, - 1422,5,30,0,0,1422,1423,3,292,146,0,1423,1424,5,31,0,0,1424,1444,1,0,0, - 0,1425,1426,5,295,0,0,1426,1427,3,166,83,0,1427,1428,5,84,0,0,1428,1429, - 5,30,0,0,1429,1430,3,292,146,0,1430,1431,5,31,0,0,1431,1444,1,0,0,0,1432, - 1433,5,295,0,0,1433,1434,3,166,83,0,1434,1435,3,6,3,0,1435,1444,1,0,0, - 0,1436,1437,5,295,0,0,1437,1438,3,166,83,0,1438,1439,5,36,0,0,1439,1440, - 5,17,0,0,1440,1441,3,154,77,0,1441,1442,5,18,0,0,1442,1444,1,0,0,0,1443, - 1396,1,0,0,0,1443,1403,1,0,0,0,1443,1411,1,0,0,0,1443,1415,1,0,0,0,1443, - 1425,1,0,0,0,1443,1432,1,0,0,0,1443,1436,1,0,0,0,1444,153,1,0,0,0,1445, - 1456,1,0,0,0,1446,1447,3,156,78,0,1447,1448,5,28,0,0,1448,1450,1,0,0,0, - 1449,1446,1,0,0,0,1450,1453,1,0,0,0,1451,1449,1,0,0,0,1451,1452,1,0,0, - 0,1452,1454,1,0,0,0,1453,1451,1,0,0,0,1454,1456,3,156,78,0,1455,1445,1, - 0,0,0,1455,1451,1,0,0,0,1456,155,1,0,0,0,1457,1458,5,39,0,0,1458,1459, - 5,264,0,0,1459,1460,5,36,0,0,1460,1461,5,17,0,0,1461,1462,3,56,28,0,1462, - 1463,5,18,0,0,1463,1471,1,0,0,0,1464,1465,3,124,62,0,1465,1466,5,36,0, - 0,1466,1467,5,17,0,0,1467,1468,3,56,28,0,1468,1469,5,18,0,0,1469,1471, - 1,0,0,0,1470,1457,1,0,0,0,1470,1464,1,0,0,0,1471,157,1,0,0,0,1472,1473, - 3,160,80,0,1473,1474,5,28,0,0,1474,1476,1,0,0,0,1475,1472,1,0,0,0,1476, - 1479,1,0,0,0,1477,1475,1,0,0,0,1477,1478,1,0,0,0,1478,1480,1,0,0,0,1479, - 1477,1,0,0,0,1480,1481,3,160,80,0,1481,159,1,0,0,0,1482,1483,3,6,3,0,1483, - 1484,5,36,0,0,1484,1485,3,164,82,0,1485,161,1,0,0,0,1486,1487,7,9,0,0, - 1487,163,1,0,0,0,1488,1523,3,162,81,0,1489,1523,3,32,16,0,1490,1491,5, - 186,0,0,1491,1492,5,30,0,0,1492,1493,3,32,16,0,1493,1494,5,31,0,0,1494, - 1523,1,0,0,0,1495,1523,3,6,3,0,1496,1497,3,116,58,0,1497,1498,5,30,0,0, - 1498,1499,5,184,0,0,1499,1500,5,75,0,0,1500,1501,3,32,16,0,1501,1502,5, - 31,0,0,1502,1523,1,0,0,0,1503,1504,3,116,58,0,1504,1505,5,30,0,0,1505, - 1506,5,185,0,0,1506,1507,5,75,0,0,1507,1508,3,32,16,0,1508,1509,5,31,0, - 0,1509,1523,1,0,0,0,1510,1511,3,116,58,0,1511,1512,5,30,0,0,1512,1513, - 5,186,0,0,1513,1514,5,75,0,0,1514,1515,3,32,16,0,1515,1516,5,31,0,0,1516, - 1523,1,0,0,0,1517,1518,3,116,58,0,1518,1519,5,30,0,0,1519,1520,3,32,16, - 0,1520,1521,5,31,0,0,1521,1523,1,0,0,0,1522,1488,1,0,0,0,1522,1489,1,0, - 0,0,1522,1490,1,0,0,0,1522,1495,1,0,0,0,1522,1496,1,0,0,0,1522,1503,1, - 0,0,0,1522,1510,1,0,0,0,1522,1517,1,0,0,0,1523,165,1,0,0,0,1524,1525,7, - 10,0,0,1525,167,1,0,0,0,1526,1527,3,170,85,0,1527,1528,3,138,69,0,1528, - 1529,3,124,62,0,1529,1530,5,176,0,0,1530,1532,3,242,121,0,1531,1533,3, - 108,54,0,1532,1531,1,0,0,0,1532,1533,1,0,0,0,1533,1534,1,0,0,0,1534,1535, - 3,112,56,0,1535,1561,1,0,0,0,1536,1537,3,170,85,0,1537,1538,3,138,69,0, - 1538,1539,3,124,62,0,1539,1540,5,176,0,0,1540,1541,3,242,121,0,1541,1542, - 3,196,98,0,1542,1543,3,112,56,0,1543,1561,1,0,0,0,1544,1545,3,170,85,0, - 1545,1546,3,138,69,0,1546,1548,3,242,121,0,1547,1549,3,108,54,0,1548,1547, - 1,0,0,0,1548,1549,1,0,0,0,1549,1550,1,0,0,0,1550,1551,3,112,56,0,1551, - 1561,1,0,0,0,1552,1553,3,170,85,0,1553,1554,3,138,69,0,1554,1555,3,242, - 121,0,1555,1556,3,196,98,0,1556,1557,3,112,56,0,1557,1561,1,0,0,0,1558, - 1561,3,174,87,0,1559,1561,3,2,1,0,1560,1526,1,0,0,0,1560,1536,1,0,0,0, - 1560,1544,1,0,0,0,1560,1552,1,0,0,0,1560,1558,1,0,0,0,1560,1559,1,0,0, - 0,1561,169,1,0,0,0,1562,1563,5,243,0,0,1563,1573,3,170,85,0,1564,1565, - 5,244,0,0,1565,1573,3,170,85,0,1566,1573,3,172,86,0,1567,1568,5,112,0, - 0,1568,1569,5,30,0,0,1569,1570,3,32,16,0,1570,1571,5,31,0,0,1571,1573, - 1,0,0,0,1572,1562,1,0,0,0,1572,1564,1,0,0,0,1572,1566,1,0,0,0,1572,1567, - 1,0,0,0,1573,171,1,0,0,0,1574,1587,1,0,0,0,1575,1587,5,245,0,0,1576,1587, - 5,246,0,0,1577,1578,5,247,0,0,1578,1587,5,248,0,0,1579,1580,5,247,0,0, - 1580,1587,5,249,0,0,1581,1582,5,247,0,0,1582,1587,5,250,0,0,1583,1584, - 5,247,0,0,1584,1587,5,251,0,0,1585,1587,5,247,0,0,1586,1574,1,0,0,0,1586, - 1575,1,0,0,0,1586,1576,1,0,0,0,1586,1577,1,0,0,0,1586,1579,1,0,0,0,1586, - 1581,1,0,0,0,1586,1583,1,0,0,0,1586,1585,1,0,0,0,1587,173,1,0,0,0,1588, - 1589,5,113,0,0,1589,1590,5,30,0,0,1590,1591,3,32,16,0,1591,1592,5,31,0, - 0,1592,175,1,0,0,0,1593,1594,5,226,0,0,1594,1599,3,168,84,0,1595,1596, - 5,37,0,0,1596,1599,3,178,89,0,1597,1599,3,174,87,0,1598,1593,1,0,0,0,1598, - 1595,1,0,0,0,1598,1597,1,0,0,0,1599,177,1,0,0,0,1600,1601,3,138,69,0,1601, - 1602,3,124,62,0,1602,1603,5,176,0,0,1603,1604,3,2,1,0,1604,1610,1,0,0, - 0,1605,1606,3,138,69,0,1606,1607,3,2,1,0,1607,1610,1,0,0,0,1608,1610,3, - 2,1,0,1609,1600,1,0,0,0,1609,1605,1,0,0,0,1609,1608,1,0,0,0,1610,179,1, - 0,0,0,1611,1612,3,124,62,0,1612,1613,5,28,0,0,1613,1615,1,0,0,0,1614,1611, - 1,0,0,0,1615,1618,1,0,0,0,1616,1614,1,0,0,0,1616,1617,1,0,0,0,1617,1619, - 1,0,0,0,1618,1616,1,0,0,0,1619,1620,3,124,62,0,1620,181,1,0,0,0,1621,1627, - 1,0,0,0,1622,1623,5,86,0,0,1623,1624,3,190,95,0,1624,1625,5,87,0,0,1625, - 1627,1,0,0,0,1626,1621,1,0,0,0,1626,1622,1,0,0,0,1627,183,1,0,0,0,1628, - 1640,5,266,0,0,1629,1640,5,114,0,0,1630,1640,5,39,0,0,1631,1640,5,200, - 0,0,1632,1640,5,115,0,0,1633,1640,5,116,0,0,1634,1635,5,70,0,0,1635,1636, - 5,30,0,0,1636,1637,3,32,16,0,1637,1638,5,31,0,0,1638,1640,1,0,0,0,1639, - 1628,1,0,0,0,1639,1629,1,0,0,0,1639,1630,1,0,0,0,1639,1631,1,0,0,0,1639, - 1632,1,0,0,0,1639,1633,1,0,0,0,1639,1634,1,0,0,0,1640,185,1,0,0,0,1641, - 1643,3,184,92,0,1642,1641,1,0,0,0,1643,1646,1,0,0,0,1644,1642,1,0,0,0, - 1644,1645,1,0,0,0,1645,187,1,0,0,0,1646,1644,1,0,0,0,1647,1649,3,186,93, - 0,1648,1650,3,192,96,0,1649,1648,1,0,0,0,1649,1650,1,0,0,0,1650,1651,1, - 0,0,0,1651,1652,3,2,1,0,1652,189,1,0,0,0,1653,1654,3,188,94,0,1654,1655, - 5,28,0,0,1655,1657,1,0,0,0,1656,1653,1,0,0,0,1657,1660,1,0,0,0,1658,1656, - 1,0,0,0,1658,1659,1,0,0,0,1659,1661,1,0,0,0,1660,1658,1,0,0,0,1661,1662, - 3,188,94,0,1662,191,1,0,0,0,1663,1664,5,30,0,0,1664,1665,3,180,90,0,1665, - 1666,5,31,0,0,1666,193,1,0,0,0,1667,1670,1,0,0,0,1668,1670,3,196,98,0, - 1669,1667,1,0,0,0,1669,1668,1,0,0,0,1670,195,1,0,0,0,1671,1672,5,86,0, - 0,1672,1673,5,42,0,0,1673,1674,3,32,16,0,1674,1675,5,43,0,0,1675,1676, - 5,87,0,0,1676,197,1,0,0,0,1677,1678,3,234,117,0,1678,1679,5,17,0,0,1679, - 1680,3,246,123,0,1680,1681,5,18,0,0,1681,1794,1,0,0,0,1682,1683,3,74,37, - 0,1683,1684,5,17,0,0,1684,1685,3,82,41,0,1685,1686,5,18,0,0,1686,1794, - 1,0,0,0,1687,1688,3,210,105,0,1688,1689,5,17,0,0,1689,1690,3,214,107,0, - 1690,1691,5,18,0,0,1691,1794,1,0,0,0,1692,1693,3,218,109,0,1693,1694,5, - 17,0,0,1694,1695,3,222,111,0,1695,1696,5,18,0,0,1696,1794,1,0,0,0,1697, - 1794,3,200,100,0,1698,1794,3,276,138,0,1699,1794,3,152,76,0,1700,1794, - 3,88,44,0,1701,1794,3,322,161,0,1702,1703,5,117,0,0,1703,1794,3,32,16, - 0,1704,1705,5,118,0,0,1705,1794,3,32,16,0,1706,1707,3,334,167,0,1707,1708, - 5,17,0,0,1708,1709,3,338,169,0,1709,1710,5,18,0,0,1710,1794,1,0,0,0,1711, - 1712,5,302,0,0,1712,1713,3,124,62,0,1713,1714,5,176,0,0,1714,1715,3,242, - 121,0,1715,1716,5,119,0,0,1716,1717,3,170,85,0,1717,1718,3,138,69,0,1718, - 1719,3,124,62,0,1719,1720,5,176,0,0,1720,1721,3,242,121,0,1721,1722,3, - 112,56,0,1722,1794,1,0,0,0,1723,1724,5,302,0,0,1724,1725,5,226,0,0,1725, - 1726,3,170,85,0,1726,1727,3,138,69,0,1727,1728,3,124,62,0,1728,1729,5, - 176,0,0,1729,1730,3,242,121,0,1730,1731,3,194,97,0,1731,1732,3,112,56, - 0,1732,1733,5,119,0,0,1733,1734,5,226,0,0,1734,1735,3,170,85,0,1735,1736, - 3,138,69,0,1736,1737,3,124,62,0,1737,1738,5,176,0,0,1738,1739,3,242,121, - 0,1739,1740,3,194,97,0,1740,1741,3,112,56,0,1741,1794,1,0,0,0,1742,1794, - 3,26,13,0,1743,1794,3,40,20,0,1744,1745,5,255,0,0,1745,1746,5,196,0,0, - 1746,1747,5,42,0,0,1747,1748,3,32,16,0,1748,1752,5,43,0,0,1749,1751,3, - 322,161,0,1750,1749,1,0,0,0,1751,1754,1,0,0,0,1752,1750,1,0,0,0,1752,1753, - 1,0,0,0,1753,1794,1,0,0,0,1754,1752,1,0,0,0,1755,1756,5,255,0,0,1756,1757, - 5,196,0,0,1757,1761,3,2,1,0,1758,1760,3,322,161,0,1759,1758,1,0,0,0,1760, - 1763,1,0,0,0,1761,1759,1,0,0,0,1761,1762,1,0,0,0,1762,1794,1,0,0,0,1763, - 1761,1,0,0,0,1764,1765,5,255,0,0,1765,1766,5,256,0,0,1766,1767,5,42,0, - 0,1767,1768,3,32,16,0,1768,1769,5,43,0,0,1769,1770,5,28,0,0,1770,1774, - 3,124,62,0,1771,1773,3,322,161,0,1772,1771,1,0,0,0,1773,1776,1,0,0,0,1774, - 1772,1,0,0,0,1774,1775,1,0,0,0,1775,1794,1,0,0,0,1776,1774,1,0,0,0,1777, - 1778,5,255,0,0,1778,1779,5,256,0,0,1779,1780,3,2,1,0,1780,1781,5,28,0, - 0,1781,1785,3,124,62,0,1782,1784,3,322,161,0,1783,1782,1,0,0,0,1784,1787, - 1,0,0,0,1785,1783,1,0,0,0,1785,1786,1,0,0,0,1786,1794,1,0,0,0,1787,1785, - 1,0,0,0,1788,1789,5,120,0,0,1789,1790,5,196,0,0,1790,1791,3,124,62,0,1791, - 1792,3,44,22,0,1792,1794,1,0,0,0,1793,1677,1,0,0,0,1793,1682,1,0,0,0,1793, - 1687,1,0,0,0,1793,1692,1,0,0,0,1793,1697,1,0,0,0,1793,1698,1,0,0,0,1793, - 1699,1,0,0,0,1793,1700,1,0,0,0,1793,1701,1,0,0,0,1793,1702,1,0,0,0,1793, - 1704,1,0,0,0,1793,1706,1,0,0,0,1793,1711,1,0,0,0,1793,1723,1,0,0,0,1793, - 1742,1,0,0,0,1793,1743,1,0,0,0,1793,1744,1,0,0,0,1793,1755,1,0,0,0,1793, - 1764,1,0,0,0,1793,1777,1,0,0,0,1793,1788,1,0,0,0,1794,199,1,0,0,0,1795, - 1796,5,121,0,0,1796,1805,3,208,104,0,1797,1804,3,202,101,0,1798,1799,5, - 122,0,0,1799,1800,5,30,0,0,1800,1801,3,228,114,0,1801,1802,5,31,0,0,1802, - 1804,1,0,0,0,1803,1797,1,0,0,0,1803,1798,1,0,0,0,1804,1807,1,0,0,0,1805, - 1803,1,0,0,0,1805,1806,1,0,0,0,1806,1808,1,0,0,0,1807,1805,1,0,0,0,1808, - 1809,3,138,69,0,1809,1810,3,2,1,0,1810,1811,3,204,102,0,1811,1812,3,206, - 103,0,1812,201,1,0,0,0,1813,1833,5,123,0,0,1814,1833,5,51,0,0,1815,1833, - 5,52,0,0,1816,1833,5,63,0,0,1817,1833,5,124,0,0,1818,1833,5,69,0,0,1819, - 1833,5,68,0,0,1820,1833,5,64,0,0,1821,1833,5,65,0,0,1822,1833,5,66,0,0, - 1823,1833,5,125,0,0,1824,1833,5,126,0,0,1825,1833,5,127,0,0,1826,1833, - 5,16,0,0,1827,1828,5,70,0,0,1828,1829,5,30,0,0,1829,1830,3,32,16,0,1830, - 1831,5,31,0,0,1831,1833,1,0,0,0,1832,1813,1,0,0,0,1832,1814,1,0,0,0,1832, - 1815,1,0,0,0,1832,1816,1,0,0,0,1832,1817,1,0,0,0,1832,1818,1,0,0,0,1832, - 1819,1,0,0,0,1832,1820,1,0,0,0,1832,1821,1,0,0,0,1832,1822,1,0,0,0,1832, - 1823,1,0,0,0,1832,1824,1,0,0,0,1832,1825,1,0,0,0,1832,1826,1,0,0,0,1832, - 1827,1,0,0,0,1833,203,1,0,0,0,1834,1840,1,0,0,0,1835,1836,5,44,0,0,1836, - 1840,3,0,0,0,1837,1838,5,44,0,0,1838,1840,3,32,16,0,1839,1834,1,0,0,0, - 1839,1835,1,0,0,0,1839,1837,1,0,0,0,1840,205,1,0,0,0,1841,1845,1,0,0,0, - 1842,1843,5,36,0,0,1843,1845,3,296,148,0,1844,1841,1,0,0,0,1844,1842,1, - 0,0,0,1845,207,1,0,0,0,1846,1852,1,0,0,0,1847,1848,5,42,0,0,1848,1849, - 3,32,16,0,1849,1850,5,43,0,0,1850,1852,1,0,0,0,1851,1846,1,0,0,0,1851, - 1847,1,0,0,0,1852,209,1,0,0,0,1853,1857,5,128,0,0,1854,1856,3,212,106, - 0,1855,1854,1,0,0,0,1856,1859,1,0,0,0,1857,1855,1,0,0,0,1857,1858,1,0, - 0,0,1858,1860,1,0,0,0,1859,1857,1,0,0,0,1860,1861,3,124,62,0,1861,1862, - 3,2,1,0,1862,1872,1,0,0,0,1863,1867,5,128,0,0,1864,1866,3,212,106,0,1865, - 1864,1,0,0,0,1866,1869,1,0,0,0,1867,1865,1,0,0,0,1867,1868,1,0,0,0,1868, - 1870,1,0,0,0,1869,1867,1,0,0,0,1870,1872,3,2,1,0,1871,1853,1,0,0,0,1871, - 1863,1,0,0,0,1872,211,1,0,0,0,1873,1874,7,11,0,0,1874,213,1,0,0,0,1875, - 1877,3,216,108,0,1876,1875,1,0,0,0,1877,1880,1,0,0,0,1878,1876,1,0,0,0, - 1878,1879,1,0,0,0,1879,215,1,0,0,0,1880,1878,1,0,0,0,1881,1882,5,129,0, - 0,1882,1894,3,168,84,0,1883,1884,5,130,0,0,1884,1894,3,168,84,0,1885,1886, - 5,131,0,0,1886,1894,3,168,84,0,1887,1888,5,132,0,0,1888,1894,3,168,84, - 0,1889,1894,3,88,44,0,1890,1894,3,322,161,0,1891,1894,3,26,13,0,1892,1894, - 3,40,20,0,1893,1881,1,0,0,0,1893,1883,1,0,0,0,1893,1885,1,0,0,0,1893,1887, - 1,0,0,0,1893,1889,1,0,0,0,1893,1890,1,0,0,0,1893,1891,1,0,0,0,1893,1892, - 1,0,0,0,1894,217,1,0,0,0,1895,1899,5,133,0,0,1896,1898,3,220,110,0,1897, - 1896,1,0,0,0,1898,1901,1,0,0,0,1899,1897,1,0,0,0,1899,1900,1,0,0,0,1900, - 1902,1,0,0,0,1901,1899,1,0,0,0,1902,1903,3,170,85,0,1903,1904,3,138,69, - 0,1904,1905,3,2,1,0,1905,1906,3,112,56,0,1906,1907,3,206,103,0,1907,219, - 1,0,0,0,1908,1909,7,11,0,0,1909,221,1,0,0,0,1910,1912,3,224,112,0,1911, - 1910,1,0,0,0,1912,1915,1,0,0,0,1913,1911,1,0,0,0,1913,1914,1,0,0,0,1914, - 223,1,0,0,0,1915,1913,1,0,0,0,1916,1917,5,134,0,0,1917,1927,3,168,84,0, - 1918,1919,5,135,0,0,1919,1927,3,168,84,0,1920,1921,5,132,0,0,1921,1927, - 3,168,84,0,1922,1927,3,322,161,0,1923,1927,3,88,44,0,1924,1927,3,26,13, - 0,1925,1927,3,40,20,0,1926,1916,1,0,0,0,1926,1918,1,0,0,0,1926,1920,1, - 0,0,0,1926,1922,1,0,0,0,1926,1923,1,0,0,0,1926,1924,1,0,0,0,1926,1925, - 1,0,0,0,1927,225,1,0,0,0,1928,1935,1,0,0,0,1929,1930,5,122,0,0,1930,1931, - 5,30,0,0,1931,1932,3,228,114,0,1932,1933,5,31,0,0,1933,1935,1,0,0,0,1934, - 1928,1,0,0,0,1934,1929,1,0,0,0,1935,227,1,0,0,0,1936,1946,3,126,63,0,1937, - 1939,5,17,0,0,1938,1940,3,294,147,0,1939,1938,1,0,0,0,1940,1941,1,0,0, - 0,1941,1939,1,0,0,0,1941,1942,1,0,0,0,1942,1943,1,0,0,0,1943,1944,5,18, - 0,0,1944,1946,1,0,0,0,1945,1936,1,0,0,0,1945,1937,1,0,0,0,1946,229,1,0, - 0,0,1947,1949,3,232,116,0,1948,1947,1,0,0,0,1949,1952,1,0,0,0,1950,1948, - 1,0,0,0,1950,1951,1,0,0,0,1951,231,1,0,0,0,1952,1950,1,0,0,0,1953,1954, - 5,42,0,0,1954,1955,5,136,0,0,1955,1967,5,43,0,0,1956,1957,5,42,0,0,1957, - 1958,5,137,0,0,1958,1967,5,43,0,0,1959,1960,5,42,0,0,1960,1961,5,138,0, - 0,1961,1967,5,43,0,0,1962,1963,5,42,0,0,1963,1964,3,32,16,0,1964,1965, - 5,43,0,0,1965,1967,1,0,0,0,1966,1953,1,0,0,0,1966,1956,1,0,0,0,1966,1959, - 1,0,0,0,1966,1962,1,0,0,0,1967,233,1,0,0,0,1968,1973,5,139,0,0,1969,1972, - 3,236,118,0,1970,1972,3,238,119,0,1971,1969,1,0,0,0,1971,1970,1,0,0,0, - 1972,1975,1,0,0,0,1973,1971,1,0,0,0,1973,1974,1,0,0,0,1974,1976,1,0,0, - 0,1975,1973,1,0,0,0,1976,1977,3,170,85,0,1977,1978,3,230,115,0,1978,1979, - 3,138,69,0,1979,1980,3,226,113,0,1980,1981,3,242,121,0,1981,1982,3,182, - 91,0,1982,1986,3,112,56,0,1983,1985,3,244,122,0,1984,1983,1,0,0,0,1985, - 1988,1,0,0,0,1986,1984,1,0,0,0,1986,1987,1,0,0,0,1987,235,1,0,0,0,1988, - 1986,1,0,0,0,1989,2013,5,123,0,0,1990,2013,5,51,0,0,1991,2013,5,52,0,0, - 1992,2013,5,63,0,0,1993,2013,5,140,0,0,1994,2013,5,68,0,0,1995,2013,5, - 141,0,0,1996,2013,5,142,0,0,1997,2013,5,54,0,0,1998,2013,5,64,0,0,1999, - 2013,5,65,0,0,2000,2013,5,66,0,0,2001,2013,5,125,0,0,2002,2013,5,143,0, - 0,2003,2013,5,144,0,0,2004,2013,5,69,0,0,2005,2013,5,145,0,0,2006,2013, - 5,146,0,0,2007,2008,5,70,0,0,2008,2009,5,30,0,0,2009,2010,3,32,16,0,2010, - 2011,5,31,0,0,2011,2013,1,0,0,0,2012,1989,1,0,0,0,2012,1990,1,0,0,0,2012, - 1991,1,0,0,0,2012,1992,1,0,0,0,2012,1993,1,0,0,0,2012,1994,1,0,0,0,2012, - 1995,1,0,0,0,2012,1996,1,0,0,0,2012,1997,1,0,0,0,2012,1998,1,0,0,0,2012, - 1999,1,0,0,0,2012,2000,1,0,0,0,2012,2001,1,0,0,0,2012,2002,1,0,0,0,2012, - 2003,1,0,0,0,2012,2004,1,0,0,0,2012,2005,1,0,0,0,2012,2006,1,0,0,0,2012, - 2007,1,0,0,0,2013,237,1,0,0,0,2014,2015,5,147,0,0,2015,2021,5,30,0,0,2016, - 2019,3,6,3,0,2017,2018,5,34,0,0,2018,2020,3,6,3,0,2019,2017,1,0,0,0,2019, - 2020,1,0,0,0,2020,2022,1,0,0,0,2021,2016,1,0,0,0,2021,2022,1,0,0,0,2022, - 2026,1,0,0,0,2023,2025,3,240,120,0,2024,2023,1,0,0,0,2025,2028,1,0,0,0, - 2026,2024,1,0,0,0,2026,2027,1,0,0,0,2027,2029,1,0,0,0,2028,2026,1,0,0, - 0,2029,2033,5,31,0,0,2030,2031,5,147,0,0,2031,2033,5,85,0,0,2032,2014, - 1,0,0,0,2032,2030,1,0,0,0,2033,239,1,0,0,0,2034,2062,5,148,0,0,2035,2062, - 5,224,0,0,2036,2062,5,57,0,0,2037,2062,5,58,0,0,2038,2062,5,149,0,0,2039, - 2062,5,150,0,0,2040,2062,5,248,0,0,2041,2062,5,249,0,0,2042,2062,5,250, - 0,0,2043,2062,5,251,0,0,2044,2045,5,151,0,0,2045,2046,5,75,0,0,2046,2062, - 5,152,0,0,2047,2048,5,151,0,0,2048,2049,5,75,0,0,2049,2062,5,153,0,0,2050, - 2051,5,154,0,0,2051,2052,5,75,0,0,2052,2062,5,152,0,0,2053,2054,5,154, - 0,0,2054,2055,5,75,0,0,2055,2062,5,153,0,0,2056,2057,5,70,0,0,2057,2058, - 5,30,0,0,2058,2059,3,32,16,0,2059,2060,5,31,0,0,2060,2062,1,0,0,0,2061, - 2034,1,0,0,0,2061,2035,1,0,0,0,2061,2036,1,0,0,0,2061,2037,1,0,0,0,2061, - 2038,1,0,0,0,2061,2039,1,0,0,0,2061,2040,1,0,0,0,2061,2041,1,0,0,0,2061, - 2042,1,0,0,0,2061,2043,1,0,0,0,2061,2044,1,0,0,0,2061,2047,1,0,0,0,2061, - 2050,1,0,0,0,2061,2053,1,0,0,0,2061,2056,1,0,0,0,2062,241,1,0,0,0,2063, - 2067,5,116,0,0,2064,2067,5,155,0,0,2065,2067,3,2,1,0,2066,2063,1,0,0,0, - 2066,2064,1,0,0,0,2066,2065,1,0,0,0,2067,243,1,0,0,0,2068,2090,5,1,0,0, - 2069,2090,5,2,0,0,2070,2090,5,156,0,0,2071,2090,5,3,0,0,2072,2090,5,4, - 0,0,2073,2090,5,247,0,0,2074,2090,5,5,0,0,2075,2090,5,6,0,0,2076,2090, - 5,7,0,0,2077,2090,5,8,0,0,2078,2090,5,9,0,0,2079,2090,5,10,0,0,2080,2090, - 5,11,0,0,2081,2090,5,12,0,0,2082,2090,5,13,0,0,2083,2090,5,14,0,0,2084, - 2085,5,70,0,0,2085,2086,5,30,0,0,2086,2087,3,32,16,0,2087,2088,5,31,0, - 0,2088,2090,1,0,0,0,2089,2068,1,0,0,0,2089,2069,1,0,0,0,2089,2070,1,0, - 0,0,2089,2071,1,0,0,0,2089,2072,1,0,0,0,2089,2073,1,0,0,0,2089,2074,1, - 0,0,0,2089,2075,1,0,0,0,2089,2076,1,0,0,0,2089,2077,1,0,0,0,2089,2078, - 1,0,0,0,2089,2079,1,0,0,0,2089,2080,1,0,0,0,2089,2081,1,0,0,0,2089,2082, - 1,0,0,0,2089,2083,1,0,0,0,2089,2084,1,0,0,0,2090,245,1,0,0,0,2091,2093, - 3,248,124,0,2092,2091,1,0,0,0,2093,2096,1,0,0,0,2094,2092,1,0,0,0,2094, - 2095,1,0,0,0,2095,247,1,0,0,0,2096,2094,1,0,0,0,2097,2115,3,100,50,0,2098, - 2099,5,296,0,0,2099,2100,3,32,16,0,2100,2101,6,124,-1,0,2101,2115,1,0, - 0,0,2102,2115,3,258,129,0,2103,2104,5,297,0,0,2104,2105,3,32,16,0,2105, - 2106,6,124,-1,0,2106,2115,1,0,0,0,2107,2108,5,298,0,0,2108,2115,6,124, - -1,0,2109,2110,5,299,0,0,2110,2115,6,124,-1,0,2111,2115,3,252,126,0,2112, - 2115,3,256,128,0,2113,2115,3,250,125,0,2114,2097,1,0,0,0,2114,2098,1,0, - 0,0,2114,2102,1,0,0,0,2114,2103,1,0,0,0,2114,2107,1,0,0,0,2114,2109,1, - 0,0,0,2114,2111,1,0,0,0,2114,2112,1,0,0,0,2114,2113,1,0,0,0,2115,249,1, - 0,0,0,2116,2117,5,300,0,0,2117,2215,3,112,56,0,2118,2119,5,300,0,0,2119, - 2120,5,157,0,0,2120,2215,3,112,56,0,2121,2215,3,276,138,0,2122,2215,3, - 152,76,0,2123,2215,3,88,44,0,2124,2215,3,26,13,0,2125,2215,3,254,127,0, - 2126,2215,3,40,20,0,2127,2128,5,301,0,0,2128,2129,5,42,0,0,2129,2130,3, - 32,16,0,2130,2131,5,43,0,0,2131,2215,1,0,0,0,2132,2133,5,301,0,0,2133, - 2134,5,42,0,0,2134,2135,3,32,16,0,2135,2136,5,43,0,0,2136,2137,5,34,0, - 0,2137,2138,3,0,0,0,2138,2215,1,0,0,0,2139,2140,5,303,0,0,2140,2141,3, - 32,16,0,2141,2142,5,75,0,0,2142,2143,3,32,16,0,2143,2215,1,0,0,0,2144, - 2145,5,302,0,0,2145,2146,3,124,62,0,2146,2147,5,176,0,0,2147,2148,3,242, - 121,0,2148,2215,1,0,0,0,2149,2150,5,302,0,0,2150,2151,5,226,0,0,2151,2152, - 3,170,85,0,2152,2153,3,138,69,0,2153,2154,3,124,62,0,2154,2155,5,176,0, - 0,2155,2156,3,242,121,0,2156,2157,3,194,97,0,2157,2158,3,112,56,0,2158, - 2215,1,0,0,0,2159,2160,5,255,0,0,2160,2161,5,196,0,0,2161,2162,5,42,0, - 0,2162,2163,3,32,16,0,2163,2167,5,43,0,0,2164,2166,3,322,161,0,2165,2164, - 1,0,0,0,2166,2169,1,0,0,0,2167,2165,1,0,0,0,2167,2168,1,0,0,0,2168,2215, - 1,0,0,0,2169,2167,1,0,0,0,2170,2171,5,255,0,0,2171,2172,5,196,0,0,2172, - 2176,3,2,1,0,2173,2175,3,322,161,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,2215,1,0,0,0,2178,2176,1,0,0, - 0,2179,2180,5,255,0,0,2180,2181,5,256,0,0,2181,2182,5,42,0,0,2182,2183, - 3,32,16,0,2183,2184,5,43,0,0,2184,2185,5,28,0,0,2185,2189,3,124,62,0,2186, - 2188,3,322,161,0,2187,2186,1,0,0,0,2188,2191,1,0,0,0,2189,2187,1,0,0,0, - 2189,2190,1,0,0,0,2190,2215,1,0,0,0,2191,2189,1,0,0,0,2192,2193,5,255, - 0,0,2193,2194,5,256,0,0,2194,2195,3,2,1,0,2195,2196,5,28,0,0,2196,2200, - 3,124,62,0,2197,2199,3,322,161,0,2198,2197,1,0,0,0,2199,2202,1,0,0,0,2200, - 2198,1,0,0,0,2200,2201,1,0,0,0,2201,2215,1,0,0,0,2202,2200,1,0,0,0,2203, - 2204,5,255,0,0,2204,2205,5,42,0,0,2205,2206,3,32,16,0,2206,2207,5,43,0, - 0,2207,2211,3,206,103,0,2208,2210,3,322,161,0,2209,2208,1,0,0,0,2210,2213, - 1,0,0,0,2211,2209,1,0,0,0,2211,2212,1,0,0,0,2212,2215,1,0,0,0,2213,2211, - 1,0,0,0,2214,2116,1,0,0,0,2214,2118,1,0,0,0,2214,2121,1,0,0,0,2214,2122, - 1,0,0,0,2214,2123,1,0,0,0,2214,2124,1,0,0,0,2214,2125,1,0,0,0,2214,2126, - 1,0,0,0,2214,2127,1,0,0,0,2214,2132,1,0,0,0,2214,2139,1,0,0,0,2214,2144, - 1,0,0,0,2214,2149,1,0,0,0,2214,2159,1,0,0,0,2214,2170,1,0,0,0,2214,2179, - 1,0,0,0,2214,2192,1,0,0,0,2214,2203,1,0,0,0,2215,251,1,0,0,0,2216,2217, - 3,0,0,0,2217,2218,5,75,0,0,2218,2219,6,126,-1,0,2219,253,1,0,0,0,2220, - 2223,3,44,22,0,2221,2223,3,46,23,0,2222,2220,1,0,0,0,2222,2221,1,0,0,0, - 2223,255,1,0,0,0,2224,2225,5,17,0,0,2225,2226,3,246,123,0,2226,2227,5, - 18,0,0,2227,257,1,0,0,0,2228,2229,3,262,131,0,2229,2230,3,260,130,0,2230, - 259,1,0,0,0,2231,2233,3,264,132,0,2232,2231,1,0,0,0,2233,2234,1,0,0,0, - 2234,2232,1,0,0,0,2234,2235,1,0,0,0,2235,261,1,0,0,0,2236,2237,5,158,0, - 0,2237,2249,3,256,128,0,2238,2239,5,158,0,0,2239,2240,3,0,0,0,2240,2241, - 5,159,0,0,2241,2242,3,0,0,0,2242,2249,1,0,0,0,2243,2244,5,158,0,0,2244, - 2245,3,32,16,0,2245,2246,5,159,0,0,2246,2247,3,32,16,0,2247,2249,1,0,0, - 0,2248,2236,1,0,0,0,2248,2238,1,0,0,0,2248,2243,1,0,0,0,2249,263,1,0,0, - 0,2250,2251,3,268,134,0,2251,2252,3,274,137,0,2252,2263,1,0,0,0,2253,2254, - 3,266,133,0,2254,2255,3,274,137,0,2255,2263,1,0,0,0,2256,2257,3,270,135, - 0,2257,2258,3,274,137,0,2258,2263,1,0,0,0,2259,2260,3,272,136,0,2260,2261, - 3,274,137,0,2261,2263,1,0,0,0,2262,2250,1,0,0,0,2262,2253,1,0,0,0,2262, - 2256,1,0,0,0,2262,2259,1,0,0,0,2263,265,1,0,0,0,2264,2265,5,160,0,0,2265, - 2271,3,256,128,0,2266,2267,5,160,0,0,2267,2271,3,0,0,0,2268,2269,5,160, - 0,0,2269,2271,3,32,16,0,2270,2264,1,0,0,0,2270,2266,1,0,0,0,2270,2268, - 1,0,0,0,2271,267,1,0,0,0,2272,2273,5,161,0,0,2273,2274,3,124,62,0,2274, - 269,1,0,0,0,2275,2276,5,162,0,0,2276,271,1,0,0,0,2277,2278,5,163,0,0,2278, - 273,1,0,0,0,2279,2291,3,256,128,0,2280,2281,5,164,0,0,2281,2282,3,0,0, - 0,2282,2283,5,159,0,0,2283,2284,3,0,0,0,2284,2291,1,0,0,0,2285,2286,5, - 164,0,0,2286,2287,3,32,16,0,2287,2288,5,159,0,0,2288,2289,3,32,16,0,2289, - 2291,1,0,0,0,2290,2279,1,0,0,0,2290,2280,1,0,0,0,2290,2285,1,0,0,0,2291, - 275,1,0,0,0,2292,2293,3,278,139,0,2293,2294,3,282,141,0,2294,277,1,0,0, - 0,2295,2296,5,165,0,0,2296,2297,3,280,140,0,2297,2298,3,0,0,0,2298,2299, - 5,36,0,0,2299,2303,1,0,0,0,2300,2301,5,165,0,0,2301,2303,3,280,140,0,2302, - 2295,1,0,0,0,2302,2300,1,0,0,0,2303,279,1,0,0,0,2304,2308,1,0,0,0,2305, - 2308,5,166,0,0,2306,2308,5,2,0,0,2307,2304,1,0,0,0,2307,2305,1,0,0,0,2307, - 2306,1,0,0,0,2308,281,1,0,0,0,2309,2310,5,17,0,0,2310,2311,3,284,142,0, - 2311,2312,5,18,0,0,2312,2319,1,0,0,0,2313,2315,3,288,144,0,2314,2313,1, - 0,0,0,2315,2316,1,0,0,0,2316,2314,1,0,0,0,2316,2317,1,0,0,0,2317,2319, - 1,0,0,0,2318,2309,1,0,0,0,2318,2314,1,0,0,0,2319,283,1,0,0,0,2320,2321, - 3,288,144,0,2321,2322,5,28,0,0,2322,2324,1,0,0,0,2323,2320,1,0,0,0,2324, - 2327,1,0,0,0,2325,2323,1,0,0,0,2325,2326,1,0,0,0,2326,2328,1,0,0,0,2327, - 2325,1,0,0,0,2328,2329,3,288,144,0,2329,285,1,0,0,0,2330,2336,1,0,0,0, - 2331,2332,5,42,0,0,2332,2333,3,32,16,0,2333,2334,5,43,0,0,2334,2336,1, - 0,0,0,2335,2330,1,0,0,0,2335,2331,1,0,0,0,2336,287,1,0,0,0,2337,2338,5, - 181,0,0,2338,2339,5,262,0,0,2339,2340,5,30,0,0,2340,2341,3,6,3,0,2341, - 2342,5,31,0,0,2342,2404,1,0,0,0,2343,2344,5,260,0,0,2344,2345,5,30,0,0, - 2345,2346,3,0,0,0,2346,2347,5,31,0,0,2347,2404,1,0,0,0,2348,2349,5,260, - 0,0,2349,2404,3,0,0,0,2350,2351,5,84,0,0,2351,2352,5,30,0,0,2352,2353, - 3,292,146,0,2353,2354,5,31,0,0,2354,2404,1,0,0,0,2355,2356,5,188,0,0,2356, - 2357,5,30,0,0,2357,2358,3,36,18,0,2358,2359,5,31,0,0,2359,2360,3,286,143, - 0,2360,2404,1,0,0,0,2361,2362,5,189,0,0,2362,2363,5,30,0,0,2363,2364,3, - 36,18,0,2364,2365,5,31,0,0,2365,2366,3,286,143,0,2366,2404,1,0,0,0,2367, - 2368,5,187,0,0,2368,2369,5,30,0,0,2369,2370,3,34,17,0,2370,2371,5,31,0, - 0,2371,2372,3,286,143,0,2372,2404,1,0,0,0,2373,2374,5,186,0,0,2374,2375, - 5,30,0,0,2375,2376,3,32,16,0,2376,2377,5,31,0,0,2377,2378,3,286,143,0, - 2378,2404,1,0,0,0,2379,2380,5,185,0,0,2380,2381,5,30,0,0,2381,2382,3,32, - 16,0,2382,2383,5,31,0,0,2383,2384,3,286,143,0,2384,2404,1,0,0,0,2385,2386, - 5,184,0,0,2386,2387,5,30,0,0,2387,2388,3,32,16,0,2388,2389,5,31,0,0,2389, - 2390,3,286,143,0,2390,2404,1,0,0,0,2391,2392,5,188,0,0,2392,2404,3,286, - 143,0,2393,2394,5,189,0,0,2394,2404,3,286,143,0,2395,2396,5,187,0,0,2396, - 2404,3,286,143,0,2397,2398,5,186,0,0,2398,2404,3,286,143,0,2399,2400,5, - 185,0,0,2400,2404,3,286,143,0,2401,2402,5,184,0,0,2402,2404,3,286,143, - 0,2403,2337,1,0,0,0,2403,2343,1,0,0,0,2403,2348,1,0,0,0,2403,2350,1,0, - 0,0,2403,2355,1,0,0,0,2403,2361,1,0,0,0,2403,2367,1,0,0,0,2403,2373,1, - 0,0,0,2403,2379,1,0,0,0,2403,2385,1,0,0,0,2403,2391,1,0,0,0,2403,2393, - 1,0,0,0,2403,2395,1,0,0,0,2403,2397,1,0,0,0,2403,2399,1,0,0,0,2403,2401, - 1,0,0,0,2404,289,1,0,0,0,2405,2406,5,188,0,0,2406,2407,5,30,0,0,2407,2408, - 3,36,18,0,2408,2409,5,31,0,0,2409,2481,1,0,0,0,2410,2411,5,189,0,0,2411, - 2412,5,30,0,0,2412,2413,3,36,18,0,2413,2414,5,31,0,0,2414,2481,1,0,0,0, - 2415,2416,5,188,0,0,2416,2417,5,30,0,0,2417,2418,3,32,16,0,2418,2419,5, - 31,0,0,2419,2481,1,0,0,0,2420,2421,5,189,0,0,2421,2422,5,30,0,0,2422,2423, - 3,34,17,0,2423,2424,5,31,0,0,2424,2481,1,0,0,0,2425,2426,5,187,0,0,2426, - 2427,5,30,0,0,2427,2428,3,34,17,0,2428,2429,5,31,0,0,2429,2481,1,0,0,0, - 2430,2431,5,186,0,0,2431,2432,5,30,0,0,2432,2433,3,32,16,0,2433,2434,5, - 31,0,0,2434,2481,1,0,0,0,2435,2436,5,185,0,0,2436,2437,5,30,0,0,2437,2438, - 3,32,16,0,2438,2439,5,31,0,0,2439,2481,1,0,0,0,2440,2441,5,184,0,0,2441, - 2442,5,30,0,0,2442,2443,3,32,16,0,2443,2444,5,31,0,0,2444,2481,1,0,0,0, - 2445,2446,5,193,0,0,2446,2447,5,30,0,0,2447,2448,3,34,17,0,2448,2449,5, - 31,0,0,2449,2481,1,0,0,0,2450,2451,5,192,0,0,2451,2452,5,30,0,0,2452,2453, - 3,32,16,0,2453,2454,5,31,0,0,2454,2481,1,0,0,0,2455,2456,5,191,0,0,2456, - 2457,5,30,0,0,2457,2458,3,32,16,0,2458,2459,5,31,0,0,2459,2481,1,0,0,0, - 2460,2461,5,190,0,0,2461,2462,5,30,0,0,2462,2463,3,32,16,0,2463,2464,5, - 31,0,0,2464,2481,1,0,0,0,2465,2466,5,181,0,0,2466,2467,5,30,0,0,2467,2468, - 3,32,16,0,2468,2469,5,31,0,0,2469,2481,1,0,0,0,2470,2471,5,183,0,0,2471, - 2472,5,30,0,0,2472,2473,3,162,81,0,2473,2474,5,31,0,0,2474,2481,1,0,0, - 0,2475,2476,5,84,0,0,2476,2477,5,30,0,0,2477,2478,3,292,146,0,2478,2479, - 5,31,0,0,2479,2481,1,0,0,0,2480,2405,1,0,0,0,2480,2410,1,0,0,0,2480,2415, - 1,0,0,0,2480,2420,1,0,0,0,2480,2425,1,0,0,0,2480,2430,1,0,0,0,2480,2435, - 1,0,0,0,2480,2440,1,0,0,0,2480,2445,1,0,0,0,2480,2450,1,0,0,0,2480,2455, - 1,0,0,0,2480,2460,1,0,0,0,2480,2465,1,0,0,0,2480,2470,1,0,0,0,2480,2475, - 1,0,0,0,2481,291,1,0,0,0,2482,2483,3,294,147,0,2483,2484,6,146,-1,0,2484, - 2486,1,0,0,0,2485,2482,1,0,0,0,2486,2489,1,0,0,0,2487,2485,1,0,0,0,2487, - 2488,1,0,0,0,2488,293,1,0,0,0,2489,2487,1,0,0,0,2490,2491,7,12,0,0,2491, - 295,1,0,0,0,2492,2496,3,290,145,0,2493,2496,3,6,3,0,2494,2496,5,179,0, - 0,2495,2492,1,0,0,0,2495,2493,1,0,0,0,2495,2494,1,0,0,0,2496,297,1,0,0, - 0,2497,2646,3,290,145,0,2498,2499,5,182,0,0,2499,2500,5,30,0,0,2500,2501, - 5,179,0,0,2501,2646,5,31,0,0,2502,2503,5,182,0,0,2503,2504,5,30,0,0,2504, - 2505,5,264,0,0,2505,2646,5,31,0,0,2506,2507,5,196,0,0,2507,2508,5,30,0, - 0,2508,2509,5,39,0,0,2509,2510,5,264,0,0,2510,2646,5,31,0,0,2511,2512, - 5,196,0,0,2512,2513,5,30,0,0,2513,2514,3,116,58,0,2514,2515,5,31,0,0,2515, - 2646,1,0,0,0,2516,2517,5,196,0,0,2517,2518,5,30,0,0,2518,2519,5,179,0, - 0,2519,2646,5,31,0,0,2520,2521,5,197,0,0,2521,2522,5,30,0,0,2522,2523, - 3,298,149,0,2523,2524,5,31,0,0,2524,2646,1,0,0,0,2525,2526,5,188,0,0,2526, - 2527,5,42,0,0,2527,2528,3,32,16,0,2528,2529,5,43,0,0,2529,2530,5,30,0, - 0,2530,2531,3,300,150,0,2531,2532,5,31,0,0,2532,2646,1,0,0,0,2533,2534, - 5,189,0,0,2534,2535,5,42,0,0,2535,2536,3,32,16,0,2536,2537,5,43,0,0,2537, - 2538,5,30,0,0,2538,2539,3,302,151,0,2539,2540,5,31,0,0,2540,2646,1,0,0, - 0,2541,2542,5,187,0,0,2542,2543,5,42,0,0,2543,2544,3,32,16,0,2544,2545, - 5,43,0,0,2545,2546,5,30,0,0,2546,2547,3,304,152,0,2547,2548,5,31,0,0,2548, - 2646,1,0,0,0,2549,2550,5,186,0,0,2550,2551,5,42,0,0,2551,2552,3,32,16, - 0,2552,2553,5,43,0,0,2553,2554,5,30,0,0,2554,2555,3,306,153,0,2555,2556, - 5,31,0,0,2556,2646,1,0,0,0,2557,2558,5,185,0,0,2558,2559,5,42,0,0,2559, - 2560,3,32,16,0,2560,2561,5,43,0,0,2561,2562,5,30,0,0,2562,2563,3,308,154, - 0,2563,2564,5,31,0,0,2564,2646,1,0,0,0,2565,2566,5,184,0,0,2566,2567,5, - 42,0,0,2567,2568,3,32,16,0,2568,2569,5,43,0,0,2569,2570,5,30,0,0,2570, - 2571,3,310,155,0,2571,2572,5,31,0,0,2572,2646,1,0,0,0,2573,2574,5,193, - 0,0,2574,2575,5,42,0,0,2575,2576,3,32,16,0,2576,2577,5,43,0,0,2577,2578, - 5,30,0,0,2578,2579,3,304,152,0,2579,2580,5,31,0,0,2580,2646,1,0,0,0,2581, - 2582,5,192,0,0,2582,2583,5,42,0,0,2583,2584,3,32,16,0,2584,2585,5,43,0, - 0,2585,2586,5,30,0,0,2586,2587,3,306,153,0,2587,2588,5,31,0,0,2588,2646, - 1,0,0,0,2589,2590,5,191,0,0,2590,2591,5,42,0,0,2591,2592,3,32,16,0,2592, - 2593,5,43,0,0,2593,2594,5,30,0,0,2594,2595,3,308,154,0,2595,2596,5,31, - 0,0,2596,2646,1,0,0,0,2597,2598,5,190,0,0,2598,2599,5,42,0,0,2599,2600, - 3,32,16,0,2600,2601,5,43,0,0,2601,2602,5,30,0,0,2602,2603,3,310,155,0, - 2603,2604,5,31,0,0,2604,2646,1,0,0,0,2605,2606,5,181,0,0,2606,2607,5,42, - 0,0,2607,2608,3,32,16,0,2608,2609,5,43,0,0,2609,2610,5,30,0,0,2610,2611, - 3,308,154,0,2611,2612,5,31,0,0,2612,2646,1,0,0,0,2613,2614,5,183,0,0,2614, - 2615,5,42,0,0,2615,2616,3,32,16,0,2616,2617,5,43,0,0,2617,2618,5,30,0, - 0,2618,2619,3,312,156,0,2619,2620,5,31,0,0,2620,2646,1,0,0,0,2621,2622, - 5,182,0,0,2622,2623,5,42,0,0,2623,2624,3,32,16,0,2624,2625,5,43,0,0,2625, - 2626,5,30,0,0,2626,2627,3,314,157,0,2627,2628,5,31,0,0,2628,2646,1,0,0, - 0,2629,2630,5,196,0,0,2630,2631,5,42,0,0,2631,2632,3,32,16,0,2632,2633, - 5,43,0,0,2633,2634,5,30,0,0,2634,2635,3,316,158,0,2635,2636,5,31,0,0,2636, - 2646,1,0,0,0,2637,2638,5,197,0,0,2638,2639,5,42,0,0,2639,2640,3,32,16, - 0,2640,2641,5,43,0,0,2641,2642,5,30,0,0,2642,2643,3,320,160,0,2643,2644, - 5,31,0,0,2644,2646,1,0,0,0,2645,2497,1,0,0,0,2645,2498,1,0,0,0,2645,2502, - 1,0,0,0,2645,2506,1,0,0,0,2645,2511,1,0,0,0,2645,2516,1,0,0,0,2645,2520, - 1,0,0,0,2645,2525,1,0,0,0,2645,2533,1,0,0,0,2645,2541,1,0,0,0,2645,2549, - 1,0,0,0,2645,2557,1,0,0,0,2645,2565,1,0,0,0,2645,2573,1,0,0,0,2645,2581, - 1,0,0,0,2645,2589,1,0,0,0,2645,2597,1,0,0,0,2645,2605,1,0,0,0,2645,2613, - 1,0,0,0,2645,2621,1,0,0,0,2645,2629,1,0,0,0,2645,2637,1,0,0,0,2646,299, - 1,0,0,0,2647,2650,3,36,18,0,2648,2650,3,32,16,0,2649,2647,1,0,0,0,2649, - 2648,1,0,0,0,2650,2653,1,0,0,0,2651,2649,1,0,0,0,2651,2652,1,0,0,0,2652, - 301,1,0,0,0,2653,2651,1,0,0,0,2654,2657,3,36,18,0,2655,2657,3,34,17,0, - 2656,2654,1,0,0,0,2656,2655,1,0,0,0,2657,2660,1,0,0,0,2658,2656,1,0,0, - 0,2658,2659,1,0,0,0,2659,303,1,0,0,0,2660,2658,1,0,0,0,2661,2663,3,34, - 17,0,2662,2661,1,0,0,0,2663,2666,1,0,0,0,2664,2662,1,0,0,0,2664,2665,1, - 0,0,0,2665,305,1,0,0,0,2666,2664,1,0,0,0,2667,2669,3,32,16,0,2668,2667, - 1,0,0,0,2669,2672,1,0,0,0,2670,2668,1,0,0,0,2670,2671,1,0,0,0,2671,307, - 1,0,0,0,2672,2670,1,0,0,0,2673,2675,3,32,16,0,2674,2673,1,0,0,0,2675,2678, - 1,0,0,0,2676,2674,1,0,0,0,2676,2677,1,0,0,0,2677,309,1,0,0,0,2678,2676, - 1,0,0,0,2679,2681,3,32,16,0,2680,2679,1,0,0,0,2681,2684,1,0,0,0,2682,2680, - 1,0,0,0,2682,2683,1,0,0,0,2683,311,1,0,0,0,2684,2682,1,0,0,0,2685,2687, - 3,162,81,0,2686,2685,1,0,0,0,2687,2690,1,0,0,0,2688,2686,1,0,0,0,2688, - 2689,1,0,0,0,2689,313,1,0,0,0,2690,2688,1,0,0,0,2691,2693,7,13,0,0,2692, - 2691,1,0,0,0,2693,2696,1,0,0,0,2694,2692,1,0,0,0,2694,2695,1,0,0,0,2695, - 315,1,0,0,0,2696,2694,1,0,0,0,2697,2699,3,318,159,0,2698,2697,1,0,0,0, - 2699,2702,1,0,0,0,2700,2698,1,0,0,0,2700,2701,1,0,0,0,2701,317,1,0,0,0, - 2702,2700,1,0,0,0,2703,2708,5,179,0,0,2704,2705,5,39,0,0,2705,2708,5,264, - 0,0,2706,2708,3,116,58,0,2707,2703,1,0,0,0,2707,2704,1,0,0,0,2707,2706, - 1,0,0,0,2708,319,1,0,0,0,2709,2711,3,298,149,0,2710,2709,1,0,0,0,2711, - 2714,1,0,0,0,2712,2710,1,0,0,0,2712,2713,1,0,0,0,2713,321,1,0,0,0,2714, - 2712,1,0,0,0,2715,2719,3,44,22,0,2716,2719,3,46,23,0,2717,2719,3,2,1,0, - 2718,2715,1,0,0,0,2718,2716,1,0,0,0,2718,2717,1,0,0,0,2719,323,1,0,0,0, - 2720,2721,7,14,0,0,2721,2722,5,36,0,0,2722,2723,5,30,0,0,2723,2724,3,292, - 146,0,2724,2725,5,31,0,0,2725,2746,1,0,0,0,2726,2727,5,169,0,0,2727,2728, - 3,38,19,0,2728,2729,5,75,0,0,2729,2730,3,38,19,0,2730,2731,5,75,0,0,2731, - 2732,3,38,19,0,2732,2733,5,75,0,0,2733,2734,3,38,19,0,2734,2746,1,0,0, - 0,2735,2736,5,170,0,0,2736,2746,3,6,3,0,2737,2738,5,170,0,0,2738,2739, - 5,36,0,0,2739,2740,5,30,0,0,2740,2741,3,292,146,0,2741,2742,5,31,0,0,2742, - 2746,1,0,0,0,2743,2746,3,322,161,0,2744,2746,3,40,20,0,2745,2720,1,0,0, - 0,2745,2726,1,0,0,0,2745,2735,1,0,0,0,2745,2737,1,0,0,0,2745,2743,1,0, - 0,0,2745,2744,1,0,0,0,2746,325,1,0,0,0,2747,2748,5,25,0,0,2748,2749,5, - 40,0,0,2749,2750,3,98,49,0,2750,2751,3,2,1,0,2751,2760,1,0,0,0,2752,2753, - 5,25,0,0,2753,2754,5,40,0,0,2754,2755,3,98,49,0,2755,2756,3,2,1,0,2756, - 2757,5,34,0,0,2757,2758,3,2,1,0,2758,2760,1,0,0,0,2759,2747,1,0,0,0,2759, - 2752,1,0,0,0,2760,327,1,0,0,0,2761,2763,3,330,165,0,2762,2761,1,0,0,0, - 2763,2766,1,0,0,0,2764,2762,1,0,0,0,2764,2765,1,0,0,0,2765,329,1,0,0,0, - 2766,2764,1,0,0,0,2767,2768,5,180,0,0,2768,2769,5,36,0,0,2769,2770,5,30, - 0,0,2770,2771,3,292,146,0,2771,2772,5,31,0,0,2772,2782,1,0,0,0,2773,2782, - 3,324,162,0,2774,2775,5,171,0,0,2775,2776,5,36,0,0,2776,2777,5,30,0,0, - 2777,2778,3,292,146,0,2778,2779,5,31,0,0,2779,2782,1,0,0,0,2780,2782,5, - 55,0,0,2781,2767,1,0,0,0,2781,2773,1,0,0,0,2781,2774,1,0,0,0,2781,2780, - 1,0,0,0,2782,331,1,0,0,0,2783,2784,5,50,0,0,2784,2788,5,40,0,0,2785,2787, - 3,336,168,0,2786,2785,1,0,0,0,2787,2790,1,0,0,0,2788,2786,1,0,0,0,2788, - 2789,1,0,0,0,2789,2791,1,0,0,0,2790,2788,1,0,0,0,2791,2792,3,2,1,0,2792, - 333,1,0,0,0,2793,2797,5,301,0,0,2794,2796,3,336,168,0,2795,2794,1,0,0, - 0,2796,2799,1,0,0,0,2797,2795,1,0,0,0,2797,2798,1,0,0,0,2798,2800,1,0, - 0,0,2799,2797,1,0,0,0,2800,2801,3,2,1,0,2801,335,1,0,0,0,2802,2818,5,52, - 0,0,2803,2818,5,51,0,0,2804,2818,5,172,0,0,2805,2806,5,62,0,0,2806,2818, - 5,51,0,0,2807,2808,5,62,0,0,2808,2818,5,52,0,0,2809,2810,5,62,0,0,2810, - 2818,5,63,0,0,2811,2812,5,62,0,0,2812,2818,5,64,0,0,2813,2814,5,62,0,0, - 2814,2818,5,65,0,0,2815,2816,5,62,0,0,2816,2818,5,66,0,0,2817,2802,1,0, - 0,0,2817,2803,1,0,0,0,2817,2804,1,0,0,0,2817,2805,1,0,0,0,2817,2807,1, - 0,0,0,2817,2809,1,0,0,0,2817,2811,1,0,0,0,2817,2813,1,0,0,0,2817,2815, - 1,0,0,0,2818,337,1,0,0,0,2819,2821,3,340,170,0,2820,2819,1,0,0,0,2821, - 2824,1,0,0,0,2822,2820,1,0,0,0,2822,2823,1,0,0,0,2823,339,1,0,0,0,2824, - 2822,1,0,0,0,2825,2826,5,21,0,0,2826,2839,3,2,1,0,2827,2828,5,50,0,0,2828, - 2829,5,40,0,0,2829,2839,3,118,59,0,2830,2831,5,25,0,0,2831,2832,5,40,0, - 0,2832,2839,3,2,1,0,2833,2839,3,174,87,0,2834,2835,5,50,0,0,2835,2839, - 3,32,16,0,2836,2839,3,322,161,0,2837,2839,3,40,20,0,2838,2825,1,0,0,0, - 2838,2827,1,0,0,0,2838,2830,1,0,0,0,2838,2833,1,0,0,0,2838,2834,1,0,0, - 0,2838,2836,1,0,0,0,2838,2837,1,0,0,0,2839,341,1,0,0,0,2840,2844,5,274, - 0,0,2841,2843,3,344,172,0,2842,2841,1,0,0,0,2843,2846,1,0,0,0,2844,2842, - 1,0,0,0,2844,2845,1,0,0,0,2845,2847,1,0,0,0,2846,2844,1,0,0,0,2847,2860, - 3,2,1,0,2848,2852,5,274,0,0,2849,2851,3,344,172,0,2850,2849,1,0,0,0,2851, - 2854,1,0,0,0,2852,2850,1,0,0,0,2852,2853,1,0,0,0,2853,2855,1,0,0,0,2854, - 2852,1,0,0,0,2855,2856,3,2,1,0,2856,2857,5,34,0,0,2857,2858,3,2,1,0,2858, - 2860,1,0,0,0,2859,2840,1,0,0,0,2859,2848,1,0,0,0,2860,343,1,0,0,0,2861, - 2862,7,15,0,0,2862,345,1,0,0,0,2863,2865,3,348,174,0,2864,2863,1,0,0,0, - 2865,2868,1,0,0,0,2866,2864,1,0,0,0,2866,2867,1,0,0,0,2867,347,1,0,0,0, - 2868,2866,1,0,0,0,2869,2870,5,21,0,0,2870,2871,3,2,1,0,2871,2872,5,44, - 0,0,2872,2873,3,32,16,0,2873,2880,1,0,0,0,2874,2875,5,25,0,0,2875,2876, - 5,40,0,0,2876,2880,3,2,1,0,2877,2880,3,322,161,0,2878,2880,3,40,20,0,2879, - 2869,1,0,0,0,2879,2874,1,0,0,0,2879,2877,1,0,0,0,2879,2878,1,0,0,0,2880, - 349,1,0,0,0,175,358,363,371,379,432,473,482,506,510,528,555,578,614,620, - 627,629,639,641,648,659,667,688,690,706,751,756,761,766,774,884,890,906, - 912,918,925,930,982,1018,1023,1029,1034,1036,1044,1056,1068,1075,1082, - 1084,1111,1118,1126,1134,1147,1154,1157,1176,1270,1279,1286,1289,1297, - 1318,1350,1373,1385,1394,1419,1443,1451,1455,1470,1477,1522,1532,1548, - 1560,1572,1586,1598,1609,1616,1626,1639,1644,1649,1658,1669,1752,1761, - 1774,1785,1793,1803,1805,1832,1839,1844,1851,1857,1867,1871,1878,1893, - 1899,1913,1926,1934,1941,1945,1950,1966,1971,1973,1986,2012,2019,2021, - 2026,2032,2061,2066,2089,2094,2114,2167,2176,2189,2200,2211,2214,2222, - 2234,2248,2262,2270,2290,2302,2307,2316,2318,2325,2335,2403,2480,2487, - 2495,2645,2649,2651,2656,2658,2664,2670,2676,2682,2688,2694,2700,2707, - 2712,2718,2745,2759,2764,2781,2788,2797,2817,2822,2838,2844,2852,2859, - 2866,2879 + 1,162,1,162,1,162,1,162,3,162,2771,8,162,1,163,1,163,1,163,1,163,1,163, + 1,163,1,163,1,163,1,163,1,163,1,163,1,163,3,163,2785,8,163,1,164,5,164, + 2788,8,164,10,164,12,164,2791,9,164,1,165,1,165,1,165,1,165,1,165,1,165, + 1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,3,165,2807,8,165,1,166, + 1,166,1,166,5,166,2812,8,166,10,166,12,166,2815,9,166,1,166,1,166,1,167, + 1,167,5,167,2821,8,167,10,167,12,167,2824,9,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,168,1,168,1,168, + 1,168,3,168,2843,8,168,1,169,5,169,2846,8,169,10,169,12,169,2849,9,169, + 1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170, + 1,170,3,170,2864,8,170,1,171,1,171,5,171,2868,8,171,10,171,12,171,2871, + 9,171,1,171,1,171,1,171,5,171,2876,8,171,10,171,12,171,2879,9,171,1,171, + 1,171,1,171,1,171,3,171,2885,8,171,1,172,1,172,1,173,5,173,2890,8,173, + 10,173,12,173,2893,9,173,1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174, + 1,174,1,174,3,174,2905,8,174,1,174,0,1,68,175,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,0,16,6,0,1,15,199,199,243, + 243,247,247,264,264,289,289,5,0,16,16,199,199,243,243,264,264,288,289, + 1,0,263,264,1,0,173,174,1,0,37,38,1,0,73,74,3,0,2,2,61,61,77,83,2,0,229, + 229,260,261,9,0,178,178,183,195,201,201,207,208,210,215,218,219,222,222, + 230,242,262,262,1,0,95,96,1,0,97,111,1,0,68,69,2,0,173,173,289,290,2,0, + 179,179,264,264,1,0,167,168,1,0,51,52,3334,0,350,1,0,0,0,2,363,1,0,0,0, + 4,365,1,0,0,0,6,372,1,0,0,0,8,381,1,0,0,0,10,434,1,0,0,0,12,436,1,0,0, + 0,14,439,1,0,0,0,16,442,1,0,0,0,18,446,1,0,0,0,20,449,1,0,0,0,22,452,1, + 0,0,0,24,459,1,0,0,0,26,475,1,0,0,0,28,477,1,0,0,0,30,479,1,0,0,0,32,489, + 1,0,0,0,34,491,1,0,0,0,36,514,1,0,0,0,38,518,1,0,0,0,40,536,1,0,0,0,42, + 563,1,0,0,0,44,586,1,0,0,0,46,622,1,0,0,0,48,624,1,0,0,0,50,628,1,0,0, + 0,52,630,1,0,0,0,54,637,1,0,0,0,56,649,1,0,0,0,58,652,1,0,0,0,60,654,1, + 0,0,0,62,667,1,0,0,0,64,675,1,0,0,0,66,677,1,0,0,0,68,685,1,0,0,0,70,701, + 1,0,0,0,72,707,1,0,0,0,74,710,1,0,0,0,76,759,1,0,0,0,78,764,1,0,0,0,80, + 769,1,0,0,0,82,774,1,0,0,0,84,782,1,0,0,0,86,787,1,0,0,0,88,892,1,0,0, + 0,90,920,1,0,0,0,92,922,1,0,0,0,94,926,1,0,0,0,96,928,1,0,0,0,98,933,1, + 0,0,0,100,938,1,0,0,0,102,1018,1,0,0,0,104,1035,1,0,0,0,106,1061,1,0,0, + 0,108,1063,1,0,0,0,110,1075,1,0,0,0,112,1100,1,0,0,0,114,1109,1,0,0,0, + 116,1136,1,0,0,0,118,1143,1,0,0,0,120,1151,1,0,0,0,122,1159,1,0,0,0,124, + 1172,1,0,0,0,126,1182,1,0,0,0,128,1201,1,0,0,0,130,1295,1,0,0,0,132,1304, + 1,0,0,0,134,1314,1,0,0,0,136,1316,1,0,0,0,138,1318,1,0,0,0,140,1343,1, + 0,0,0,142,1375,1,0,0,0,144,1398,1,0,0,0,146,1410,1,0,0,0,148,1412,1,0, + 0,0,150,1415,1,0,0,0,152,1468,1,0,0,0,154,1480,1,0,0,0,156,1495,1,0,0, + 0,158,1502,1,0,0,0,160,1507,1,0,0,0,162,1511,1,0,0,0,164,1547,1,0,0,0, + 166,1549,1,0,0,0,168,1585,1,0,0,0,170,1597,1,0,0,0,172,1611,1,0,0,0,174, + 1613,1,0,0,0,176,1623,1,0,0,0,178,1634,1,0,0,0,180,1641,1,0,0,0,182,1651, + 1,0,0,0,184,1664,1,0,0,0,186,1669,1,0,0,0,188,1672,1,0,0,0,190,1683,1, + 0,0,0,192,1688,1,0,0,0,194,1694,1,0,0,0,196,1696,1,0,0,0,198,1818,1,0, + 0,0,200,1820,1,0,0,0,202,1857,1,0,0,0,204,1864,1,0,0,0,206,1869,1,0,0, + 0,208,1876,1,0,0,0,210,1896,1,0,0,0,212,1898,1,0,0,0,214,1903,1,0,0,0, + 216,1918,1,0,0,0,218,1920,1,0,0,0,220,1933,1,0,0,0,222,1938,1,0,0,0,224, + 1951,1,0,0,0,226,1959,1,0,0,0,228,1970,1,0,0,0,230,1975,1,0,0,0,232,1991, + 1,0,0,0,234,1993,1,0,0,0,236,2037,1,0,0,0,238,2057,1,0,0,0,240,2086,1, + 0,0,0,242,2091,1,0,0,0,244,2114,1,0,0,0,246,2119,1,0,0,0,248,2139,1,0, + 0,0,250,2239,1,0,0,0,252,2241,1,0,0,0,254,2247,1,0,0,0,256,2249,1,0,0, + 0,258,2253,1,0,0,0,260,2257,1,0,0,0,262,2273,1,0,0,0,264,2287,1,0,0,0, + 266,2295,1,0,0,0,268,2297,1,0,0,0,270,2300,1,0,0,0,272,2302,1,0,0,0,274, + 2315,1,0,0,0,276,2317,1,0,0,0,278,2327,1,0,0,0,280,2332,1,0,0,0,282,2343, + 1,0,0,0,284,2350,1,0,0,0,286,2360,1,0,0,0,288,2428,1,0,0,0,290,2505,1, + 0,0,0,292,2512,1,0,0,0,294,2515,1,0,0,0,296,2520,1,0,0,0,298,2670,1,0, + 0,0,300,2676,1,0,0,0,302,2683,1,0,0,0,304,2689,1,0,0,0,306,2695,1,0,0, + 0,308,2701,1,0,0,0,310,2707,1,0,0,0,312,2713,1,0,0,0,314,2719,1,0,0,0, + 316,2725,1,0,0,0,318,2732,1,0,0,0,320,2737,1,0,0,0,322,2743,1,0,0,0,324, + 2770,1,0,0,0,326,2784,1,0,0,0,328,2789,1,0,0,0,330,2806,1,0,0,0,332,2808, + 1,0,0,0,334,2818,1,0,0,0,336,2842,1,0,0,0,338,2847,1,0,0,0,340,2863,1, + 0,0,0,342,2884,1,0,0,0,344,2886,1,0,0,0,346,2891,1,0,0,0,348,2904,1,0, + 0,0,350,351,7,0,0,0,351,1,1,0,0,0,352,364,5,288,0,0,353,354,3,4,2,0,354, + 355,5,265,0,0,355,357,1,0,0,0,356,353,1,0,0,0,357,360,1,0,0,0,358,356, + 1,0,0,0,358,359,1,0,0,0,359,361,1,0,0,0,360,358,1,0,0,0,361,364,3,4,2, + 0,362,364,5,264,0,0,363,352,1,0,0,0,363,358,1,0,0,0,363,362,1,0,0,0,364, + 3,1,0,0,0,365,366,7,1,0,0,366,5,1,0,0,0,367,368,5,263,0,0,368,369,6,3, + -1,0,369,371,5,266,0,0,370,367,1,0,0,0,371,374,1,0,0,0,372,370,1,0,0,0, + 372,373,1,0,0,0,373,375,1,0,0,0,374,372,1,0,0,0,375,376,5,263,0,0,376, + 377,6,3,-1,0,377,7,1,0,0,0,378,380,3,10,5,0,379,378,1,0,0,0,380,383,1, + 0,0,0,381,379,1,0,0,0,381,382,1,0,0,0,382,9,1,0,0,0,383,381,1,0,0,0,384, + 385,3,74,37,0,385,386,5,17,0,0,386,387,3,82,41,0,387,388,5,18,0,0,388, + 435,1,0,0,0,389,390,3,72,36,0,390,391,5,17,0,0,391,392,3,8,4,0,392,393, + 5,18,0,0,393,435,1,0,0,0,394,395,3,234,117,0,395,396,5,17,0,0,396,397, + 3,246,123,0,397,398,5,18,0,0,398,435,1,0,0,0,399,435,3,200,100,0,400,435, + 3,276,138,0,401,435,3,70,35,0,402,435,3,66,33,0,403,435,3,88,44,0,404, + 435,3,90,45,0,405,435,3,22,11,0,406,407,3,326,163,0,407,408,5,17,0,0,408, + 409,3,328,164,0,409,410,5,18,0,0,410,435,1,0,0,0,411,412,3,332,166,0,412, + 413,5,17,0,0,413,414,3,338,169,0,414,415,5,18,0,0,415,435,1,0,0,0,416, + 417,3,342,171,0,417,418,5,17,0,0,418,419,3,346,173,0,419,420,5,18,0,0, + 420,435,1,0,0,0,421,435,3,64,32,0,422,435,3,152,76,0,423,435,3,322,161, + 0,424,435,3,12,6,0,425,435,3,14,7,0,426,435,3,16,8,0,427,435,3,18,9,0, + 428,435,3,20,10,0,429,435,3,26,13,0,430,435,3,42,21,0,431,435,3,40,20, + 0,432,435,3,30,15,0,433,435,3,24,12,0,434,384,1,0,0,0,434,389,1,0,0,0, + 434,394,1,0,0,0,434,399,1,0,0,0,434,400,1,0,0,0,434,401,1,0,0,0,434,402, + 1,0,0,0,434,403,1,0,0,0,434,404,1,0,0,0,434,405,1,0,0,0,434,406,1,0,0, + 0,434,411,1,0,0,0,434,416,1,0,0,0,434,421,1,0,0,0,434,422,1,0,0,0,434, + 423,1,0,0,0,434,424,1,0,0,0,434,425,1,0,0,0,434,426,1,0,0,0,434,427,1, + 0,0,0,434,428,1,0,0,0,434,429,1,0,0,0,434,430,1,0,0,0,434,431,1,0,0,0, + 434,432,1,0,0,0,434,433,1,0,0,0,435,11,1,0,0,0,436,437,5,19,0,0,437,438, + 3,32,16,0,438,13,1,0,0,0,439,440,5,20,0,0,440,441,3,32,16,0,441,15,1,0, + 0,0,442,443,5,21,0,0,443,444,5,22,0,0,444,445,3,32,16,0,445,17,1,0,0,0, + 446,447,5,23,0,0,447,448,3,34,17,0,448,19,1,0,0,0,449,450,5,24,0,0,450, + 451,3,34,17,0,451,21,1,0,0,0,452,453,5,25,0,0,453,454,3,98,49,0,454,455, + 3,2,1,0,455,456,5,17,0,0,456,457,3,120,60,0,457,458,5,18,0,0,458,23,1, + 0,0,0,459,460,5,26,0,0,460,25,1,0,0,0,461,462,5,27,0,0,462,476,3,28,14, + 0,463,464,5,27,0,0,464,465,3,28,14,0,465,466,5,28,0,0,466,467,3,28,14, + 0,467,476,1,0,0,0,468,469,5,27,0,0,469,470,3,28,14,0,470,471,5,28,0,0, + 471,472,3,28,14,0,472,473,5,28,0,0,473,474,3,28,14,0,474,476,1,0,0,0,475, + 461,1,0,0,0,475,463,1,0,0,0,475,468,1,0,0,0,476,27,1,0,0,0,477,478,7,2, + 0,0,478,29,1,0,0,0,479,480,5,29,0,0,480,484,5,17,0,0,481,483,3,116,58, + 0,482,481,1,0,0,0,483,486,1,0,0,0,484,482,1,0,0,0,484,485,1,0,0,0,485, + 487,1,0,0,0,486,484,1,0,0,0,487,488,5,18,0,0,488,31,1,0,0,0,489,490,5, + 173,0,0,490,33,1,0,0,0,491,492,7,3,0,0,492,35,1,0,0,0,493,494,5,175,0, + 0,494,515,6,18,-1,0,495,496,3,32,16,0,496,497,5,265,0,0,497,498,6,18,-1, + 0,498,515,1,0,0,0,499,500,3,32,16,0,500,501,6,18,-1,0,501,515,1,0,0,0, + 502,503,5,188,0,0,503,504,5,30,0,0,504,505,3,32,16,0,505,506,5,31,0,0, + 506,507,6,18,-1,0,507,515,1,0,0,0,508,509,5,189,0,0,509,510,5,30,0,0,510, + 511,3,34,17,0,511,512,5,31,0,0,512,513,6,18,-1,0,513,515,1,0,0,0,514,493, + 1,0,0,0,514,495,1,0,0,0,514,499,1,0,0,0,514,502,1,0,0,0,514,508,1,0,0, + 0,515,37,1,0,0,0,516,519,3,32,16,0,517,519,5,262,0,0,518,516,1,0,0,0,518, + 517,1,0,0,0,519,39,1,0,0,0,520,521,5,267,0,0,521,537,5,289,0,0,522,523, + 5,267,0,0,523,524,5,289,0,0,524,537,5,263,0,0,525,526,5,268,0,0,526,537, + 5,289,0,0,527,528,5,269,0,0,528,537,5,289,0,0,529,530,5,270,0,0,530,537, + 5,289,0,0,531,537,5,271,0,0,532,537,5,272,0,0,533,534,5,273,0,0,534,537, + 5,263,0,0,535,537,5,32,0,0,536,520,1,0,0,0,536,522,1,0,0,0,536,525,1,0, + 0,0,536,527,1,0,0,0,536,529,1,0,0,0,536,531,1,0,0,0,536,532,1,0,0,0,536, + 533,1,0,0,0,536,535,1,0,0,0,537,41,1,0,0,0,538,539,5,33,0,0,539,540,3, + 138,69,0,540,541,5,34,0,0,541,542,3,2,1,0,542,564,1,0,0,0,543,544,5,33, + 0,0,544,545,3,116,58,0,545,546,5,34,0,0,546,547,3,2,1,0,547,564,1,0,0, + 0,548,549,5,33,0,0,549,550,3,176,88,0,550,551,5,34,0,0,551,552,3,2,1,0, + 552,564,1,0,0,0,553,554,5,33,0,0,554,555,3,44,22,0,555,556,5,34,0,0,556, + 557,3,2,1,0,557,564,1,0,0,0,558,559,5,33,0,0,559,560,3,46,23,0,560,561, + 5,34,0,0,561,562,3,2,1,0,562,564,1,0,0,0,563,538,1,0,0,0,563,543,1,0,0, + 0,563,548,1,0,0,0,563,553,1,0,0,0,563,558,1,0,0,0,564,43,1,0,0,0,565,566, + 5,35,0,0,566,587,3,48,24,0,567,568,5,35,0,0,568,569,3,48,24,0,569,570, + 5,36,0,0,570,571,3,6,3,0,571,587,1,0,0,0,572,573,5,35,0,0,573,574,3,48, + 24,0,574,575,5,36,0,0,575,576,5,17,0,0,576,577,3,52,26,0,577,578,5,18, + 0,0,578,587,1,0,0,0,579,580,5,35,0,0,580,581,3,48,24,0,581,582,5,36,0, + 0,582,583,5,30,0,0,583,584,3,292,146,0,584,585,5,31,0,0,585,587,1,0,0, + 0,586,565,1,0,0,0,586,567,1,0,0,0,586,572,1,0,0,0,586,579,1,0,0,0,587, + 45,1,0,0,0,588,589,5,35,0,0,589,590,5,30,0,0,590,591,3,50,25,0,591,592, + 5,31,0,0,592,593,3,48,24,0,593,623,1,0,0,0,594,595,5,35,0,0,595,596,5, + 30,0,0,596,597,3,50,25,0,597,598,5,31,0,0,598,599,3,48,24,0,599,600,5, + 36,0,0,600,601,3,6,3,0,601,623,1,0,0,0,602,603,5,35,0,0,603,604,5,30,0, + 0,604,605,3,50,25,0,605,606,5,31,0,0,606,607,3,48,24,0,607,608,5,36,0, + 0,608,609,5,17,0,0,609,610,3,52,26,0,610,611,5,18,0,0,611,623,1,0,0,0, + 612,613,5,35,0,0,613,614,5,30,0,0,614,615,3,50,25,0,615,616,5,31,0,0,616, + 617,3,48,24,0,617,618,5,36,0,0,618,619,5,30,0,0,619,620,3,292,146,0,620, + 621,5,31,0,0,621,623,1,0,0,0,622,588,1,0,0,0,622,594,1,0,0,0,622,602,1, + 0,0,0,622,612,1,0,0,0,623,47,1,0,0,0,624,625,3,168,84,0,625,49,1,0,0,0, + 626,629,3,124,62,0,627,629,3,176,88,0,628,626,1,0,0,0,628,627,1,0,0,0, + 629,51,1,0,0,0,630,631,3,54,27,0,631,632,3,56,28,0,632,53,1,0,0,0,633, + 636,3,298,149,0,634,636,3,40,20,0,635,633,1,0,0,0,635,634,1,0,0,0,636, + 639,1,0,0,0,637,635,1,0,0,0,637,638,1,0,0,0,638,55,1,0,0,0,639,637,1,0, + 0,0,640,641,3,58,29,0,641,642,3,60,30,0,642,643,3,2,1,0,643,644,5,36,0, + 0,644,645,3,298,149,0,645,648,1,0,0,0,646,648,3,40,20,0,647,640,1,0,0, + 0,647,646,1,0,0,0,648,651,1,0,0,0,649,647,1,0,0,0,649,650,1,0,0,0,650, + 57,1,0,0,0,651,649,1,0,0,0,652,653,7,4,0,0,653,59,1,0,0,0,654,656,3,62, + 31,0,655,657,5,261,0,0,656,655,1,0,0,0,656,657,1,0,0,0,657,61,1,0,0,0, + 658,668,3,144,72,0,659,668,3,2,1,0,660,668,5,196,0,0,661,668,5,197,0,0, + 662,663,5,202,0,0,663,664,5,39,0,0,664,668,5,264,0,0,665,666,5,202,0,0, + 666,668,3,116,58,0,667,658,1,0,0,0,667,659,1,0,0,0,667,660,1,0,0,0,667, + 661,1,0,0,0,667,662,1,0,0,0,667,665,1,0,0,0,668,63,1,0,0,0,669,670,5,198, + 0,0,670,671,5,40,0,0,671,676,3,2,1,0,672,673,5,198,0,0,673,676,3,2,1,0, + 674,676,5,198,0,0,675,669,1,0,0,0,675,672,1,0,0,0,675,674,1,0,0,0,676, + 65,1,0,0,0,677,678,5,41,0,0,678,679,5,42,0,0,679,680,3,32,16,0,680,681, + 5,43,0,0,681,682,3,68,34,0,682,683,5,44,0,0,683,684,3,0,0,0,684,67,1,0, + 0,0,685,698,6,34,-1,0,686,687,10,5,0,0,687,697,5,186,0,0,688,689,10,4, + 0,0,689,697,5,187,0,0,690,691,10,3,0,0,691,697,5,45,0,0,692,693,10,2,0, + 0,693,697,5,46,0,0,694,695,10,1,0,0,695,697,5,47,0,0,696,686,1,0,0,0,696, + 688,1,0,0,0,696,690,1,0,0,0,696,692,1,0,0,0,696,694,1,0,0,0,697,700,1, + 0,0,0,698,696,1,0,0,0,698,699,1,0,0,0,699,69,1,0,0,0,700,698,1,0,0,0,701, + 702,5,48,0,0,702,703,5,36,0,0,703,704,5,30,0,0,704,705,3,292,146,0,705, + 706,5,31,0,0,706,71,1,0,0,0,707,708,5,49,0,0,708,709,3,2,1,0,709,73,1, + 0,0,0,710,714,5,50,0,0,711,713,3,76,38,0,712,711,1,0,0,0,713,716,1,0,0, + 0,714,712,1,0,0,0,714,715,1,0,0,0,715,717,1,0,0,0,716,714,1,0,0,0,717, + 718,3,2,1,0,718,719,3,182,91,0,719,720,3,78,39,0,720,721,3,80,40,0,721, + 75,1,0,0,0,722,760,5,51,0,0,723,760,5,52,0,0,724,760,5,199,0,0,725,760, + 5,202,0,0,726,760,5,221,0,0,727,760,5,53,0,0,728,760,5,54,0,0,729,760, + 5,55,0,0,730,760,5,56,0,0,731,760,5,244,0,0,732,760,5,15,0,0,733,760,5, + 224,0,0,734,760,5,57,0,0,735,760,5,58,0,0,736,760,5,59,0,0,737,760,5,60, + 0,0,738,760,5,61,0,0,739,740,5,62,0,0,740,760,5,51,0,0,741,742,5,62,0, + 0,742,760,5,52,0,0,743,744,5,62,0,0,744,760,5,63,0,0,745,746,5,62,0,0, + 746,760,5,64,0,0,747,748,5,62,0,0,748,760,5,65,0,0,749,750,5,62,0,0,750, + 760,5,66,0,0,751,760,5,67,0,0,752,760,5,68,0,0,753,760,5,69,0,0,754,755, + 5,70,0,0,755,756,5,30,0,0,756,757,3,32,16,0,757,758,5,31,0,0,758,760,1, + 0,0,0,759,722,1,0,0,0,759,723,1,0,0,0,759,724,1,0,0,0,759,725,1,0,0,0, + 759,726,1,0,0,0,759,727,1,0,0,0,759,728,1,0,0,0,759,729,1,0,0,0,759,730, + 1,0,0,0,759,731,1,0,0,0,759,732,1,0,0,0,759,733,1,0,0,0,759,734,1,0,0, + 0,759,735,1,0,0,0,759,736,1,0,0,0,759,737,1,0,0,0,759,738,1,0,0,0,759, + 739,1,0,0,0,759,741,1,0,0,0,759,743,1,0,0,0,759,745,1,0,0,0,759,747,1, + 0,0,0,759,749,1,0,0,0,759,751,1,0,0,0,759,752,1,0,0,0,759,753,1,0,0,0, + 759,754,1,0,0,0,760,77,1,0,0,0,761,765,1,0,0,0,762,763,5,71,0,0,763,765, + 3,124,62,0,764,761,1,0,0,0,764,762,1,0,0,0,765,79,1,0,0,0,766,770,1,0, + 0,0,767,768,5,72,0,0,768,770,3,84,42,0,769,766,1,0,0,0,769,767,1,0,0,0, + 770,81,1,0,0,0,771,773,3,198,99,0,772,771,1,0,0,0,773,776,1,0,0,0,774, + 772,1,0,0,0,774,775,1,0,0,0,775,83,1,0,0,0,776,774,1,0,0,0,777,778,3,124, + 62,0,778,779,5,28,0,0,779,781,1,0,0,0,780,777,1,0,0,0,781,784,1,0,0,0, + 782,780,1,0,0,0,782,783,1,0,0,0,783,785,1,0,0,0,784,782,1,0,0,0,785,786, + 3,124,62,0,786,85,1,0,0,0,787,788,7,5,0,0,788,87,1,0,0,0,789,790,3,86, + 43,0,790,791,3,32,16,0,791,792,5,264,0,0,792,893,1,0,0,0,793,794,3,86, + 43,0,794,795,3,32,16,0,795,893,1,0,0,0,796,797,3,86,43,0,797,798,3,32, + 16,0,798,799,5,75,0,0,799,800,3,32,16,0,800,801,5,264,0,0,801,893,1,0, + 0,0,802,803,3,86,43,0,803,804,3,32,16,0,804,805,5,75,0,0,805,806,3,32, + 16,0,806,893,1,0,0,0,807,808,3,86,43,0,808,809,3,32,16,0,809,810,5,75, + 0,0,810,811,3,32,16,0,811,812,5,28,0,0,812,813,3,32,16,0,813,814,5,264, + 0,0,814,893,1,0,0,0,815,816,3,86,43,0,816,817,3,32,16,0,817,818,5,75,0, + 0,818,819,3,32,16,0,819,820,5,28,0,0,820,821,3,32,16,0,821,893,1,0,0,0, + 822,823,3,86,43,0,823,824,3,32,16,0,824,825,5,28,0,0,825,826,3,32,16,0, + 826,827,5,75,0,0,827,828,3,32,16,0,828,829,5,264,0,0,829,893,1,0,0,0,830, + 831,3,86,43,0,831,832,3,32,16,0,832,833,5,28,0,0,833,834,3,32,16,0,834, + 835,5,75,0,0,835,836,3,32,16,0,836,893,1,0,0,0,837,838,3,86,43,0,838,839, + 3,32,16,0,839,840,5,28,0,0,840,841,3,32,16,0,841,842,5,75,0,0,842,843, + 3,32,16,0,843,844,5,28,0,0,844,845,3,32,16,0,845,846,5,264,0,0,846,893, + 1,0,0,0,847,848,3,86,43,0,848,849,3,32,16,0,849,850,5,28,0,0,850,851,3, + 32,16,0,851,852,5,75,0,0,852,853,3,32,16,0,853,854,5,28,0,0,854,855,3, + 32,16,0,855,893,1,0,0,0,856,857,3,86,43,0,857,858,3,32,16,0,858,859,5, + 263,0,0,859,893,1,0,0,0,860,861,3,86,43,0,861,862,3,32,16,0,862,863,5, + 75,0,0,863,864,3,32,16,0,864,865,5,263,0,0,865,893,1,0,0,0,866,867,3,86, + 43,0,867,868,3,32,16,0,868,869,5,75,0,0,869,870,3,32,16,0,870,871,5,28, + 0,0,871,872,3,32,16,0,872,873,5,263,0,0,873,893,1,0,0,0,874,875,3,86,43, + 0,875,876,3,32,16,0,876,877,5,28,0,0,877,878,3,32,16,0,878,879,5,75,0, + 0,879,880,3,32,16,0,880,881,5,263,0,0,881,893,1,0,0,0,882,883,3,86,43, + 0,883,884,3,32,16,0,884,885,5,28,0,0,885,886,3,32,16,0,886,887,5,75,0, + 0,887,888,3,32,16,0,888,889,5,28,0,0,889,890,3,32,16,0,890,891,5,263,0, + 0,891,893,1,0,0,0,892,789,1,0,0,0,892,793,1,0,0,0,892,796,1,0,0,0,892, + 802,1,0,0,0,892,807,1,0,0,0,892,815,1,0,0,0,892,822,1,0,0,0,892,830,1, + 0,0,0,892,837,1,0,0,0,892,847,1,0,0,0,892,856,1,0,0,0,892,860,1,0,0,0, + 892,866,1,0,0,0,892,874,1,0,0,0,892,882,1,0,0,0,893,89,1,0,0,0,894,898, + 5,21,0,0,895,897,3,92,46,0,896,895,1,0,0,0,897,900,1,0,0,0,898,896,1,0, + 0,0,898,899,1,0,0,0,899,901,1,0,0,0,900,898,1,0,0,0,901,902,3,2,1,0,902, + 903,3,94,47,0,903,904,5,180,0,0,904,905,5,36,0,0,905,906,5,30,0,0,906, + 907,3,292,146,0,907,908,5,31,0,0,908,909,3,94,47,0,909,921,1,0,0,0,910, + 914,5,21,0,0,911,913,3,92,46,0,912,911,1,0,0,0,913,916,1,0,0,0,914,912, + 1,0,0,0,914,915,1,0,0,0,915,917,1,0,0,0,916,914,1,0,0,0,917,918,3,2,1, + 0,918,919,3,94,47,0,919,921,1,0,0,0,920,894,1,0,0,0,920,910,1,0,0,0,921, + 91,1,0,0,0,922,923,5,76,0,0,923,93,1,0,0,0,924,927,1,0,0,0,925,927,5,298, + 0,0,926,924,1,0,0,0,926,925,1,0,0,0,927,95,1,0,0,0,928,929,7,6,0,0,929, + 97,1,0,0,0,930,932,3,96,48,0,931,930,1,0,0,0,932,935,1,0,0,0,933,931,1, + 0,0,0,933,934,1,0,0,0,934,99,1,0,0,0,935,933,1,0,0,0,936,939,3,102,51, + 0,937,939,3,104,52,0,938,936,1,0,0,0,938,937,1,0,0,0,939,101,1,0,0,0,940, + 941,5,275,0,0,941,1019,6,51,-1,0,942,943,5,276,0,0,943,944,3,32,16,0,944, + 945,6,51,-1,0,945,1019,1,0,0,0,946,947,5,276,0,0,947,948,3,0,0,0,948,949, + 6,51,-1,0,949,1019,1,0,0,0,950,951,5,277,0,0,951,952,3,32,16,0,952,953, + 6,51,-1,0,953,1019,1,0,0,0,954,955,5,278,0,0,955,956,3,34,17,0,956,957, + 6,51,-1,0,957,1019,1,0,0,0,958,959,5,279,0,0,959,960,3,36,18,0,960,961, + 6,51,-1,0,961,1019,1,0,0,0,962,963,5,279,0,0,963,964,3,34,17,0,964,965, + 6,51,-1,0,965,1019,1,0,0,0,966,967,5,279,0,0,967,968,5,30,0,0,968,969, + 3,292,146,0,969,970,5,31,0,0,970,971,6,51,-1,0,971,1019,1,0,0,0,972,973, + 5,279,0,0,973,974,5,84,0,0,974,975,5,30,0,0,975,976,3,292,146,0,976,977, + 5,31,0,0,977,978,6,51,-1,0,978,1019,1,0,0,0,979,980,5,282,0,0,980,981, + 3,32,16,0,981,982,6,51,-1,0,982,1019,1,0,0,0,983,984,5,282,0,0,984,985, + 3,0,0,0,985,986,6,51,-1,0,986,1019,1,0,0,0,987,988,5,285,0,0,988,989,3, + 6,3,0,989,990,6,51,-1,0,990,1019,1,0,0,0,991,992,5,285,0,0,992,993,5,224, + 0,0,993,994,5,30,0,0,994,995,3,6,3,0,995,996,5,31,0,0,996,997,6,51,-1, + 0,997,1019,1,0,0,0,998,999,5,285,0,0,999,1000,5,84,0,0,1000,1001,5,30, + 0,0,1001,1002,3,292,146,0,1002,1003,5,31,0,0,1003,1004,6,51,-1,0,1004, + 1019,1,0,0,0,1005,1006,5,287,0,0,1006,1007,3,32,16,0,1007,1008,6,51,-1, + 0,1008,1019,1,0,0,0,1009,1010,5,283,0,0,1010,1016,6,51,-1,0,1011,1012, + 5,30,0,0,1012,1013,3,106,53,0,1013,1014,5,31,0,0,1014,1017,1,0,0,0,1015, + 1017,5,85,0,0,1016,1011,1,0,0,0,1016,1015,1,0,0,0,1017,1019,1,0,0,0,1018, + 940,1,0,0,0,1018,942,1,0,0,0,1018,946,1,0,0,0,1018,950,1,0,0,0,1018,954, + 1,0,0,0,1018,958,1,0,0,0,1018,962,1,0,0,0,1018,966,1,0,0,0,1018,972,1, + 0,0,0,1018,979,1,0,0,0,1018,983,1,0,0,0,1018,987,1,0,0,0,1018,991,1,0, + 0,0,1018,998,1,0,0,0,1018,1005,1,0,0,0,1018,1009,1,0,0,0,1019,103,1,0, + 0,0,1020,1021,5,280,0,0,1021,1036,3,168,84,0,1022,1023,5,286,0,0,1023, + 1036,3,178,89,0,1024,1025,5,286,0,0,1025,1036,3,174,87,0,1026,1027,5,284, + 0,0,1027,1036,3,124,62,0,1028,1029,5,281,0,0,1029,1030,3,170,85,0,1030, + 1031,3,138,69,0,1031,1032,3,112,56,0,1032,1036,1,0,0,0,1033,1034,5,287, + 0,0,1034,1036,3,50,25,0,1035,1020,1,0,0,0,1035,1022,1,0,0,0,1035,1024, + 1,0,0,0,1035,1026,1,0,0,0,1035,1028,1,0,0,0,1035,1033,1,0,0,0,1036,105, + 1,0,0,0,1037,1062,1,0,0,0,1038,1039,3,0,0,0,1039,1040,6,53,-1,0,1040,1045, + 1,0,0,0,1041,1042,3,32,16,0,1042,1043,6,53,-1,0,1043,1045,1,0,0,0,1044, + 1038,1,0,0,0,1044,1041,1,0,0,0,1045,1046,1,0,0,0,1046,1047,5,28,0,0,1047, + 1049,1,0,0,0,1048,1044,1,0,0,0,1049,1052,1,0,0,0,1050,1048,1,0,0,0,1050, + 1051,1,0,0,0,1051,1059,1,0,0,0,1052,1050,1,0,0,0,1053,1054,3,0,0,0,1054, + 1055,6,53,-1,0,1055,1060,1,0,0,0,1056,1057,3,32,16,0,1057,1058,6,53,-1, + 0,1058,1060,1,0,0,0,1059,1053,1,0,0,0,1059,1056,1,0,0,0,1060,1062,1,0, + 0,0,1061,1037,1,0,0,0,1061,1050,1,0,0,0,1062,107,1,0,0,0,1063,1069,5,86, + 0,0,1064,1065,3,138,69,0,1065,1066,5,28,0,0,1066,1068,1,0,0,0,1067,1064, + 1,0,0,0,1068,1071,1,0,0,0,1069,1067,1,0,0,0,1069,1070,1,0,0,0,1070,1072, + 1,0,0,0,1071,1069,1,0,0,0,1072,1073,3,138,69,0,1073,1074,5,87,0,0,1074, + 109,1,0,0,0,1075,1081,5,42,0,0,1076,1077,3,146,73,0,1077,1078,5,28,0,0, + 1078,1080,1,0,0,0,1079,1076,1,0,0,0,1080,1083,1,0,0,0,1081,1079,1,0,0, + 0,1081,1082,1,0,0,0,1082,1084,1,0,0,0,1083,1081,1,0,0,0,1084,1085,3,146, + 73,0,1085,1086,5,43,0,0,1086,111,1,0,0,0,1087,1093,5,30,0,0,1088,1089, + 3,114,57,0,1089,1090,5,28,0,0,1090,1092,1,0,0,0,1091,1088,1,0,0,0,1092, + 1095,1,0,0,0,1093,1091,1,0,0,0,1093,1094,1,0,0,0,1094,1096,1,0,0,0,1095, + 1093,1,0,0,0,1096,1097,3,114,57,0,1097,1098,5,31,0,0,1098,1101,1,0,0,0, + 1099,1101,5,85,0,0,1100,1087,1,0,0,0,1100,1099,1,0,0,0,1101,113,1,0,0, + 0,1102,1110,5,177,0,0,1103,1104,3,230,115,0,1104,1105,3,138,69,0,1105, + 1107,3,226,113,0,1106,1108,3,0,0,0,1107,1106,1,0,0,0,1107,1108,1,0,0,0, + 1108,1110,1,0,0,0,1109,1102,1,0,0,0,1109,1103,1,0,0,0,1110,115,1,0,0,0, + 1111,1112,5,42,0,0,1112,1113,3,2,1,0,1113,1114,5,43,0,0,1114,1115,3,118, + 59,0,1115,1137,1,0,0,0,1116,1117,5,42,0,0,1117,1118,3,174,87,0,1118,1119, + 5,43,0,0,1119,1120,3,118,59,0,1120,1137,1,0,0,0,1121,1122,5,42,0,0,1122, + 1123,5,262,0,0,1123,1124,5,43,0,0,1124,1137,3,118,59,0,1125,1126,5,42, + 0,0,1126,1127,5,198,0,0,1127,1128,3,2,1,0,1128,1129,5,43,0,0,1129,1130, + 3,118,59,0,1130,1137,1,0,0,0,1131,1137,3,118,59,0,1132,1137,3,174,87,0, + 1133,1137,5,257,0,0,1134,1137,5,258,0,0,1135,1137,5,259,0,0,1136,1111, + 1,0,0,0,1136,1116,1,0,0,0,1136,1121,1,0,0,0,1136,1125,1,0,0,0,1136,1131, + 1,0,0,0,1136,1132,1,0,0,0,1136,1133,1,0,0,0,1136,1134,1,0,0,0,1136,1135, + 1,0,0,0,1137,117,1,0,0,0,1138,1139,3,2,1,0,1139,1140,5,88,0,0,1140,1142, + 1,0,0,0,1141,1138,1,0,0,0,1142,1145,1,0,0,0,1143,1141,1,0,0,0,1143,1144, + 1,0,0,0,1144,1146,1,0,0,0,1145,1143,1,0,0,0,1146,1147,3,2,1,0,1147,119, + 1,0,0,0,1148,1150,3,122,61,0,1149,1148,1,0,0,0,1150,1153,1,0,0,0,1151, + 1149,1,0,0,0,1151,1152,1,0,0,0,1152,121,1,0,0,0,1153,1151,1,0,0,0,1154, + 1155,5,180,0,0,1155,1156,5,89,0,0,1156,1160,3,32,16,0,1157,1160,3,152, + 76,0,1158,1160,3,324,162,0,1159,1154,1,0,0,0,1159,1157,1,0,0,0,1159,1158, + 1,0,0,0,1160,123,1,0,0,0,1161,1173,3,116,58,0,1162,1163,5,42,0,0,1163, + 1164,3,2,1,0,1164,1165,5,43,0,0,1165,1173,1,0,0,0,1166,1167,5,42,0,0,1167, + 1168,5,198,0,0,1168,1169,3,2,1,0,1169,1170,5,43,0,0,1170,1173,1,0,0,0, + 1171,1173,3,138,69,0,1172,1161,1,0,0,0,1172,1162,1,0,0,0,1172,1166,1,0, + 0,0,1172,1171,1,0,0,0,1173,125,1,0,0,0,1174,1183,1,0,0,0,1175,1179,3,130, + 65,0,1176,1178,3,128,64,0,1177,1176,1,0,0,0,1178,1181,1,0,0,0,1179,1177, + 1,0,0,0,1179,1180,1,0,0,0,1180,1183,1,0,0,0,1181,1179,1,0,0,0,1182,1174, + 1,0,0,0,1182,1175,1,0,0,0,1183,127,1,0,0,0,1184,1202,5,262,0,0,1185,1202, + 5,261,0,0,1186,1187,5,42,0,0,1187,1188,3,32,16,0,1188,1189,5,43,0,0,1189, + 1202,1,0,0,0,1190,1191,5,42,0,0,1191,1192,3,32,16,0,1192,1193,5,266,0, + 0,1193,1194,3,32,16,0,1194,1195,5,43,0,0,1195,1202,1,0,0,0,1196,1197,5, + 42,0,0,1197,1198,5,266,0,0,1198,1199,3,32,16,0,1199,1200,5,43,0,0,1200, + 1202,1,0,0,0,1201,1184,1,0,0,0,1201,1185,1,0,0,0,1201,1186,1,0,0,0,1201, + 1190,1,0,0,0,1201,1196,1,0,0,0,1202,129,1,0,0,0,1203,1296,1,0,0,0,1204, + 1205,5,203,0,0,1205,1206,5,30,0,0,1206,1207,3,6,3,0,1207,1208,5,28,0,0, + 1208,1209,3,6,3,0,1209,1210,5,28,0,0,1210,1211,3,6,3,0,1211,1212,5,28, + 0,0,1212,1213,3,6,3,0,1213,1214,5,31,0,0,1214,1296,1,0,0,0,1215,1216,5, + 203,0,0,1216,1217,5,30,0,0,1217,1218,3,6,3,0,1218,1219,5,28,0,0,1219,1220, + 3,6,3,0,1220,1221,5,31,0,0,1221,1296,1,0,0,0,1222,1223,5,204,0,0,1223, + 1224,5,205,0,0,1224,1225,5,42,0,0,1225,1226,3,32,16,0,1226,1227,5,43,0, + 0,1227,1296,1,0,0,0,1228,1229,5,204,0,0,1229,1230,5,206,0,0,1230,1231, + 5,42,0,0,1231,1232,3,32,16,0,1232,1233,5,43,0,0,1233,1234,3,126,63,0,1234, + 1296,1,0,0,0,1235,1296,5,207,0,0,1236,1296,5,208,0,0,1237,1296,5,209,0, + 0,1238,1296,5,201,0,0,1239,1296,5,183,0,0,1240,1296,5,184,0,0,1241,1296, + 5,185,0,0,1242,1296,5,186,0,0,1243,1296,5,187,0,0,1244,1296,5,188,0,0, + 1245,1296,5,189,0,0,1246,1296,5,210,0,0,1247,1296,5,190,0,0,1248,1296, + 5,191,0,0,1249,1296,5,192,0,0,1250,1296,5,193,0,0,1251,1296,5,211,0,0, + 1252,1296,5,212,0,0,1253,1296,5,213,0,0,1254,1296,5,214,0,0,1255,1296, + 5,215,0,0,1256,1296,5,216,0,0,1257,1296,5,217,0,0,1258,1259,5,218,0,0, + 1259,1296,3,132,66,0,1260,1261,5,219,0,0,1261,1296,3,132,66,0,1262,1296, + 5,220,0,0,1263,1264,5,221,0,0,1264,1296,3,132,66,0,1265,1266,5,222,0,0, + 1266,1296,3,134,67,0,1267,1268,5,222,0,0,1268,1269,3,134,67,0,1269,1270, + 5,28,0,0,1270,1271,3,6,3,0,1271,1296,1,0,0,0,1272,1296,5,194,0,0,1273, + 1296,5,195,0,0,1274,1275,5,90,0,0,1275,1296,5,184,0,0,1276,1277,5,90,0, + 0,1277,1296,5,185,0,0,1278,1279,5,90,0,0,1279,1296,5,186,0,0,1280,1281, + 5,90,0,0,1281,1296,5,187,0,0,1282,1283,5,62,0,0,1283,1296,5,220,0,0,1284, + 1296,5,223,0,0,1285,1286,5,224,0,0,1286,1296,5,213,0,0,1287,1296,5,225, + 0,0,1288,1289,5,207,0,0,1289,1296,5,183,0,0,1290,1296,5,226,0,0,1291,1296, + 5,228,0,0,1292,1293,5,34,0,0,1293,1296,5,227,0,0,1294,1296,3,2,1,0,1295, + 1203,1,0,0,0,1295,1204,1,0,0,0,1295,1215,1,0,0,0,1295,1222,1,0,0,0,1295, + 1228,1,0,0,0,1295,1235,1,0,0,0,1295,1236,1,0,0,0,1295,1237,1,0,0,0,1295, + 1238,1,0,0,0,1295,1239,1,0,0,0,1295,1240,1,0,0,0,1295,1241,1,0,0,0,1295, + 1242,1,0,0,0,1295,1243,1,0,0,0,1295,1244,1,0,0,0,1295,1245,1,0,0,0,1295, + 1246,1,0,0,0,1295,1247,1,0,0,0,1295,1248,1,0,0,0,1295,1249,1,0,0,0,1295, + 1250,1,0,0,0,1295,1251,1,0,0,0,1295,1252,1,0,0,0,1295,1253,1,0,0,0,1295, + 1254,1,0,0,0,1295,1255,1,0,0,0,1295,1256,1,0,0,0,1295,1257,1,0,0,0,1295, + 1258,1,0,0,0,1295,1260,1,0,0,0,1295,1262,1,0,0,0,1295,1263,1,0,0,0,1295, + 1265,1,0,0,0,1295,1267,1,0,0,0,1295,1272,1,0,0,0,1295,1273,1,0,0,0,1295, + 1274,1,0,0,0,1295,1276,1,0,0,0,1295,1278,1,0,0,0,1295,1280,1,0,0,0,1295, + 1282,1,0,0,0,1295,1284,1,0,0,0,1295,1285,1,0,0,0,1295,1287,1,0,0,0,1295, + 1288,1,0,0,0,1295,1290,1,0,0,0,1295,1291,1,0,0,0,1295,1292,1,0,0,0,1295, + 1294,1,0,0,0,1296,131,1,0,0,0,1297,1305,1,0,0,0,1298,1299,5,30,0,0,1299, + 1300,5,91,0,0,1300,1301,5,36,0,0,1301,1302,3,32,16,0,1302,1303,5,31,0, + 0,1303,1305,1,0,0,0,1304,1297,1,0,0,0,1304,1298,1,0,0,0,1305,133,1,0,0, + 0,1306,1315,1,0,0,0,1307,1311,3,136,68,0,1308,1310,7,7,0,0,1309,1308,1, + 0,0,0,1310,1313,1,0,0,0,1311,1309,1,0,0,0,1311,1312,1,0,0,0,1312,1315, + 1,0,0,0,1313,1311,1,0,0,0,1314,1306,1,0,0,0,1314,1307,1,0,0,0,1315,135, + 1,0,0,0,1316,1317,7,8,0,0,1317,137,1,0,0,0,1318,1322,3,142,71,0,1319,1321, + 3,140,70,0,1320,1319,1,0,0,0,1321,1324,1,0,0,0,1322,1320,1,0,0,0,1322, + 1323,1,0,0,0,1323,139,1,0,0,0,1324,1322,1,0,0,0,1325,1344,5,261,0,0,1326, + 1327,5,42,0,0,1327,1344,5,43,0,0,1328,1344,3,110,55,0,1329,1344,5,260, + 0,0,1330,1344,5,262,0,0,1331,1344,5,92,0,0,1332,1333,5,93,0,0,1333,1334, + 5,30,0,0,1334,1335,3,124,62,0,1335,1336,5,31,0,0,1336,1344,1,0,0,0,1337, + 1338,5,94,0,0,1338,1339,5,30,0,0,1339,1340,3,124,62,0,1340,1341,5,31,0, + 0,1341,1344,1,0,0,0,1342,1344,3,108,54,0,1343,1325,1,0,0,0,1343,1326,1, + 0,0,0,1343,1328,1,0,0,0,1343,1329,1,0,0,0,1343,1330,1,0,0,0,1343,1331, + 1,0,0,0,1343,1332,1,0,0,0,1343,1337,1,0,0,0,1343,1342,1,0,0,0,1344,141, + 1,0,0,0,1345,1346,5,39,0,0,1346,1376,3,116,58,0,1347,1376,5,197,0,0,1348, + 1349,5,199,0,0,1349,1350,5,39,0,0,1350,1376,3,116,58,0,1351,1352,5,200, + 0,0,1352,1376,3,116,58,0,1353,1354,5,226,0,0,1354,1355,3,170,85,0,1355, + 1356,3,138,69,0,1356,1357,5,262,0,0,1357,1358,3,112,56,0,1358,1376,1,0, + 0,0,1359,1360,5,253,0,0,1360,1376,3,32,16,0,1361,1362,5,252,0,0,1362,1376, + 3,32,16,0,1363,1364,5,253,0,0,1364,1376,3,2,1,0,1365,1366,5,252,0,0,1366, + 1376,3,2,1,0,1367,1376,5,254,0,0,1368,1376,5,201,0,0,1369,1376,3,148,74, + 0,1370,1376,3,150,75,0,1371,1376,3,144,72,0,1372,1376,3,2,1,0,1373,1374, + 5,177,0,0,1374,1376,3,138,69,0,1375,1345,1,0,0,0,1375,1347,1,0,0,0,1375, + 1348,1,0,0,0,1375,1351,1,0,0,0,1375,1353,1,0,0,0,1375,1359,1,0,0,0,1375, + 1361,1,0,0,0,1375,1363,1,0,0,0,1375,1365,1,0,0,0,1375,1367,1,0,0,0,1375, + 1368,1,0,0,0,1375,1369,1,0,0,0,1375,1370,1,0,0,0,1375,1371,1,0,0,0,1375, + 1372,1,0,0,0,1375,1373,1,0,0,0,1376,143,1,0,0,0,1377,1399,5,181,0,0,1378, + 1399,5,182,0,0,1379,1399,5,183,0,0,1380,1399,5,184,0,0,1381,1399,5,185, + 0,0,1382,1399,5,186,0,0,1383,1399,5,187,0,0,1384,1399,5,188,0,0,1385,1399, + 5,189,0,0,1386,1399,5,190,0,0,1387,1399,5,191,0,0,1388,1399,5,192,0,0, + 1389,1399,5,193,0,0,1390,1391,5,90,0,0,1391,1399,5,184,0,0,1392,1393,5, + 90,0,0,1393,1399,5,185,0,0,1394,1395,5,90,0,0,1395,1399,5,186,0,0,1396, + 1397,5,90,0,0,1397,1399,5,187,0,0,1398,1377,1,0,0,0,1398,1378,1,0,0,0, + 1398,1379,1,0,0,0,1398,1380,1,0,0,0,1398,1381,1,0,0,0,1398,1382,1,0,0, + 0,1398,1383,1,0,0,0,1398,1384,1,0,0,0,1398,1385,1,0,0,0,1398,1386,1,0, + 0,0,1398,1387,1,0,0,0,1398,1388,1,0,0,0,1398,1389,1,0,0,0,1398,1390,1, + 0,0,0,1398,1392,1,0,0,0,1398,1394,1,0,0,0,1398,1396,1,0,0,0,1399,145,1, + 0,0,0,1400,1411,1,0,0,0,1401,1411,5,177,0,0,1402,1411,3,32,16,0,1403,1404, + 3,32,16,0,1404,1405,5,177,0,0,1405,1406,3,32,16,0,1406,1411,1,0,0,0,1407, + 1408,3,32,16,0,1408,1409,5,177,0,0,1409,1411,1,0,0,0,1410,1400,1,0,0,0, + 1410,1401,1,0,0,0,1410,1402,1,0,0,0,1410,1403,1,0,0,0,1410,1407,1,0,0, + 0,1411,147,1,0,0,0,1412,1413,5,1,0,0,1413,1414,5,194,0,0,1414,149,1,0, + 0,0,1415,1419,5,1,0,0,1416,1417,5,90,0,0,1417,1420,5,194,0,0,1418,1420, + 5,195,0,0,1419,1416,1,0,0,0,1419,1418,1,0,0,0,1420,151,1,0,0,0,1421,1422, + 5,294,0,0,1422,1423,3,166,83,0,1423,1424,3,124,62,0,1424,1425,5,30,0,0, + 1425,1426,3,158,79,0,1426,1427,5,31,0,0,1427,1469,1,0,0,0,1428,1429,5, + 294,0,0,1429,1430,3,166,83,0,1430,1431,3,124,62,0,1431,1432,5,36,0,0,1432, + 1433,5,17,0,0,1433,1434,3,52,26,0,1434,1435,5,18,0,0,1435,1469,1,0,0,0, + 1436,1437,5,294,0,0,1437,1438,3,166,83,0,1438,1439,3,124,62,0,1439,1469, + 1,0,0,0,1440,1441,5,295,0,0,1441,1442,3,166,83,0,1442,1444,5,36,0,0,1443, + 1445,5,84,0,0,1444,1443,1,0,0,0,1444,1445,1,0,0,0,1445,1446,1,0,0,0,1446, + 1447,5,30,0,0,1447,1448,3,292,146,0,1448,1449,5,31,0,0,1449,1469,1,0,0, + 0,1450,1451,5,295,0,0,1451,1452,3,166,83,0,1452,1453,5,84,0,0,1453,1454, + 5,30,0,0,1454,1455,3,292,146,0,1455,1456,5,31,0,0,1456,1469,1,0,0,0,1457, + 1458,5,295,0,0,1458,1459,3,166,83,0,1459,1460,3,6,3,0,1460,1469,1,0,0, + 0,1461,1462,5,295,0,0,1462,1463,3,166,83,0,1463,1464,5,36,0,0,1464,1465, + 5,17,0,0,1465,1466,3,154,77,0,1466,1467,5,18,0,0,1467,1469,1,0,0,0,1468, + 1421,1,0,0,0,1468,1428,1,0,0,0,1468,1436,1,0,0,0,1468,1440,1,0,0,0,1468, + 1450,1,0,0,0,1468,1457,1,0,0,0,1468,1461,1,0,0,0,1469,153,1,0,0,0,1470, + 1481,1,0,0,0,1471,1472,3,156,78,0,1472,1473,5,28,0,0,1473,1475,1,0,0,0, + 1474,1471,1,0,0,0,1475,1478,1,0,0,0,1476,1474,1,0,0,0,1476,1477,1,0,0, + 0,1477,1479,1,0,0,0,1478,1476,1,0,0,0,1479,1481,3,156,78,0,1480,1470,1, + 0,0,0,1480,1476,1,0,0,0,1481,155,1,0,0,0,1482,1483,5,39,0,0,1483,1484, + 5,264,0,0,1484,1485,5,36,0,0,1485,1486,5,17,0,0,1486,1487,3,56,28,0,1487, + 1488,5,18,0,0,1488,1496,1,0,0,0,1489,1490,3,124,62,0,1490,1491,5,36,0, + 0,1491,1492,5,17,0,0,1492,1493,3,56,28,0,1493,1494,5,18,0,0,1494,1496, + 1,0,0,0,1495,1482,1,0,0,0,1495,1489,1,0,0,0,1496,157,1,0,0,0,1497,1498, + 3,160,80,0,1498,1499,5,28,0,0,1499,1501,1,0,0,0,1500,1497,1,0,0,0,1501, + 1504,1,0,0,0,1502,1500,1,0,0,0,1502,1503,1,0,0,0,1503,1505,1,0,0,0,1504, + 1502,1,0,0,0,1505,1506,3,160,80,0,1506,159,1,0,0,0,1507,1508,3,6,3,0,1508, + 1509,5,36,0,0,1509,1510,3,164,82,0,1510,161,1,0,0,0,1511,1512,7,9,0,0, + 1512,163,1,0,0,0,1513,1548,3,162,81,0,1514,1548,3,32,16,0,1515,1516,5, + 186,0,0,1516,1517,5,30,0,0,1517,1518,3,32,16,0,1518,1519,5,31,0,0,1519, + 1548,1,0,0,0,1520,1548,3,6,3,0,1521,1522,3,116,58,0,1522,1523,5,30,0,0, + 1523,1524,5,184,0,0,1524,1525,5,75,0,0,1525,1526,3,32,16,0,1526,1527,5, + 31,0,0,1527,1548,1,0,0,0,1528,1529,3,116,58,0,1529,1530,5,30,0,0,1530, + 1531,5,185,0,0,1531,1532,5,75,0,0,1532,1533,3,32,16,0,1533,1534,5,31,0, + 0,1534,1548,1,0,0,0,1535,1536,3,116,58,0,1536,1537,5,30,0,0,1537,1538, + 5,186,0,0,1538,1539,5,75,0,0,1539,1540,3,32,16,0,1540,1541,5,31,0,0,1541, + 1548,1,0,0,0,1542,1543,3,116,58,0,1543,1544,5,30,0,0,1544,1545,3,32,16, + 0,1545,1546,5,31,0,0,1546,1548,1,0,0,0,1547,1513,1,0,0,0,1547,1514,1,0, + 0,0,1547,1515,1,0,0,0,1547,1520,1,0,0,0,1547,1521,1,0,0,0,1547,1528,1, + 0,0,0,1547,1535,1,0,0,0,1547,1542,1,0,0,0,1548,165,1,0,0,0,1549,1550,7, + 10,0,0,1550,167,1,0,0,0,1551,1552,3,170,85,0,1552,1553,3,138,69,0,1553, + 1554,3,124,62,0,1554,1555,5,176,0,0,1555,1557,3,242,121,0,1556,1558,3, + 108,54,0,1557,1556,1,0,0,0,1557,1558,1,0,0,0,1558,1559,1,0,0,0,1559,1560, + 3,112,56,0,1560,1586,1,0,0,0,1561,1562,3,170,85,0,1562,1563,3,138,69,0, + 1563,1564,3,124,62,0,1564,1565,5,176,0,0,1565,1566,3,242,121,0,1566,1567, + 3,196,98,0,1567,1568,3,112,56,0,1568,1586,1,0,0,0,1569,1570,3,170,85,0, + 1570,1571,3,138,69,0,1571,1573,3,242,121,0,1572,1574,3,108,54,0,1573,1572, + 1,0,0,0,1573,1574,1,0,0,0,1574,1575,1,0,0,0,1575,1576,3,112,56,0,1576, + 1586,1,0,0,0,1577,1578,3,170,85,0,1578,1579,3,138,69,0,1579,1580,3,242, + 121,0,1580,1581,3,196,98,0,1581,1582,3,112,56,0,1582,1586,1,0,0,0,1583, + 1586,3,174,87,0,1584,1586,3,2,1,0,1585,1551,1,0,0,0,1585,1561,1,0,0,0, + 1585,1569,1,0,0,0,1585,1577,1,0,0,0,1585,1583,1,0,0,0,1585,1584,1,0,0, + 0,1586,169,1,0,0,0,1587,1588,5,243,0,0,1588,1598,3,170,85,0,1589,1590, + 5,244,0,0,1590,1598,3,170,85,0,1591,1598,3,172,86,0,1592,1593,5,112,0, + 0,1593,1594,5,30,0,0,1594,1595,3,32,16,0,1595,1596,5,31,0,0,1596,1598, + 1,0,0,0,1597,1587,1,0,0,0,1597,1589,1,0,0,0,1597,1591,1,0,0,0,1597,1592, + 1,0,0,0,1598,171,1,0,0,0,1599,1612,1,0,0,0,1600,1612,5,245,0,0,1601,1612, + 5,246,0,0,1602,1603,5,247,0,0,1603,1612,5,248,0,0,1604,1605,5,247,0,0, + 1605,1612,5,249,0,0,1606,1607,5,247,0,0,1607,1612,5,250,0,0,1608,1609, + 5,247,0,0,1609,1612,5,251,0,0,1610,1612,5,247,0,0,1611,1599,1,0,0,0,1611, + 1600,1,0,0,0,1611,1601,1,0,0,0,1611,1602,1,0,0,0,1611,1604,1,0,0,0,1611, + 1606,1,0,0,0,1611,1608,1,0,0,0,1611,1610,1,0,0,0,1612,173,1,0,0,0,1613, + 1614,5,113,0,0,1614,1615,5,30,0,0,1615,1616,3,32,16,0,1616,1617,5,31,0, + 0,1617,175,1,0,0,0,1618,1619,5,226,0,0,1619,1624,3,168,84,0,1620,1621, + 5,37,0,0,1621,1624,3,178,89,0,1622,1624,3,174,87,0,1623,1618,1,0,0,0,1623, + 1620,1,0,0,0,1623,1622,1,0,0,0,1624,177,1,0,0,0,1625,1626,3,138,69,0,1626, + 1627,3,124,62,0,1627,1628,5,176,0,0,1628,1629,3,2,1,0,1629,1635,1,0,0, + 0,1630,1631,3,138,69,0,1631,1632,3,2,1,0,1632,1635,1,0,0,0,1633,1635,3, + 2,1,0,1634,1625,1,0,0,0,1634,1630,1,0,0,0,1634,1633,1,0,0,0,1635,179,1, + 0,0,0,1636,1637,3,124,62,0,1637,1638,5,28,0,0,1638,1640,1,0,0,0,1639,1636, + 1,0,0,0,1640,1643,1,0,0,0,1641,1639,1,0,0,0,1641,1642,1,0,0,0,1642,1644, + 1,0,0,0,1643,1641,1,0,0,0,1644,1645,3,124,62,0,1645,181,1,0,0,0,1646,1652, + 1,0,0,0,1647,1648,5,86,0,0,1648,1649,3,190,95,0,1649,1650,5,87,0,0,1650, + 1652,1,0,0,0,1651,1646,1,0,0,0,1651,1647,1,0,0,0,1652,183,1,0,0,0,1653, + 1665,5,266,0,0,1654,1665,5,114,0,0,1655,1665,5,39,0,0,1656,1665,5,200, + 0,0,1657,1665,5,115,0,0,1658,1665,5,116,0,0,1659,1660,5,70,0,0,1660,1661, + 5,30,0,0,1661,1662,3,32,16,0,1662,1663,5,31,0,0,1663,1665,1,0,0,0,1664, + 1653,1,0,0,0,1664,1654,1,0,0,0,1664,1655,1,0,0,0,1664,1656,1,0,0,0,1664, + 1657,1,0,0,0,1664,1658,1,0,0,0,1664,1659,1,0,0,0,1665,185,1,0,0,0,1666, + 1668,3,184,92,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,187,1,0,0,0,1671,1669,1,0,0,0,1672,1674,3,186,93, + 0,1673,1675,3,192,96,0,1674,1673,1,0,0,0,1674,1675,1,0,0,0,1675,1676,1, + 0,0,0,1676,1677,3,2,1,0,1677,189,1,0,0,0,1678,1679,3,188,94,0,1679,1680, + 5,28,0,0,1680,1682,1,0,0,0,1681,1678,1,0,0,0,1682,1685,1,0,0,0,1683,1681, + 1,0,0,0,1683,1684,1,0,0,0,1684,1686,1,0,0,0,1685,1683,1,0,0,0,1686,1687, + 3,188,94,0,1687,191,1,0,0,0,1688,1689,5,30,0,0,1689,1690,3,180,90,0,1690, + 1691,5,31,0,0,1691,193,1,0,0,0,1692,1695,1,0,0,0,1693,1695,3,196,98,0, + 1694,1692,1,0,0,0,1694,1693,1,0,0,0,1695,195,1,0,0,0,1696,1697,5,86,0, + 0,1697,1698,5,42,0,0,1698,1699,3,32,16,0,1699,1700,5,43,0,0,1700,1701, + 5,87,0,0,1701,197,1,0,0,0,1702,1703,3,234,117,0,1703,1704,5,17,0,0,1704, + 1705,3,246,123,0,1705,1706,5,18,0,0,1706,1819,1,0,0,0,1707,1708,3,74,37, + 0,1708,1709,5,17,0,0,1709,1710,3,82,41,0,1710,1711,5,18,0,0,1711,1819, + 1,0,0,0,1712,1713,3,210,105,0,1713,1714,5,17,0,0,1714,1715,3,214,107,0, + 1715,1716,5,18,0,0,1716,1819,1,0,0,0,1717,1718,3,218,109,0,1718,1719,5, + 17,0,0,1719,1720,3,222,111,0,1720,1721,5,18,0,0,1721,1819,1,0,0,0,1722, + 1819,3,200,100,0,1723,1819,3,276,138,0,1724,1819,3,152,76,0,1725,1819, + 3,88,44,0,1726,1819,3,322,161,0,1727,1728,5,117,0,0,1728,1819,3,32,16, + 0,1729,1730,5,118,0,0,1730,1819,3,32,16,0,1731,1732,3,334,167,0,1732,1733, + 5,17,0,0,1733,1734,3,338,169,0,1734,1735,5,18,0,0,1735,1819,1,0,0,0,1736, + 1737,5,302,0,0,1737,1738,3,124,62,0,1738,1739,5,176,0,0,1739,1740,3,242, + 121,0,1740,1741,5,119,0,0,1741,1742,3,170,85,0,1742,1743,3,138,69,0,1743, + 1744,3,124,62,0,1744,1745,5,176,0,0,1745,1746,3,242,121,0,1746,1747,3, + 112,56,0,1747,1819,1,0,0,0,1748,1749,5,302,0,0,1749,1750,5,226,0,0,1750, + 1751,3,170,85,0,1751,1752,3,138,69,0,1752,1753,3,124,62,0,1753,1754,5, + 176,0,0,1754,1755,3,242,121,0,1755,1756,3,194,97,0,1756,1757,3,112,56, + 0,1757,1758,5,119,0,0,1758,1759,5,226,0,0,1759,1760,3,170,85,0,1760,1761, + 3,138,69,0,1761,1762,3,124,62,0,1762,1763,5,176,0,0,1763,1764,3,242,121, + 0,1764,1765,3,194,97,0,1765,1766,3,112,56,0,1766,1819,1,0,0,0,1767,1819, + 3,26,13,0,1768,1819,3,40,20,0,1769,1770,5,255,0,0,1770,1771,5,196,0,0, + 1771,1772,5,42,0,0,1772,1773,3,32,16,0,1773,1777,5,43,0,0,1774,1776,3, + 322,161,0,1775,1774,1,0,0,0,1776,1779,1,0,0,0,1777,1775,1,0,0,0,1777,1778, + 1,0,0,0,1778,1819,1,0,0,0,1779,1777,1,0,0,0,1780,1781,5,255,0,0,1781,1782, + 5,196,0,0,1782,1786,3,2,1,0,1783,1785,3,322,161,0,1784,1783,1,0,0,0,1785, + 1788,1,0,0,0,1786,1784,1,0,0,0,1786,1787,1,0,0,0,1787,1819,1,0,0,0,1788, + 1786,1,0,0,0,1789,1790,5,255,0,0,1790,1791,5,256,0,0,1791,1792,5,42,0, + 0,1792,1793,3,32,16,0,1793,1794,5,43,0,0,1794,1795,5,28,0,0,1795,1799, + 3,124,62,0,1796,1798,3,322,161,0,1797,1796,1,0,0,0,1798,1801,1,0,0,0,1799, + 1797,1,0,0,0,1799,1800,1,0,0,0,1800,1819,1,0,0,0,1801,1799,1,0,0,0,1802, + 1803,5,255,0,0,1803,1804,5,256,0,0,1804,1805,3,2,1,0,1805,1806,5,28,0, + 0,1806,1810,3,124,62,0,1807,1809,3,322,161,0,1808,1807,1,0,0,0,1809,1812, + 1,0,0,0,1810,1808,1,0,0,0,1810,1811,1,0,0,0,1811,1819,1,0,0,0,1812,1810, + 1,0,0,0,1813,1814,5,120,0,0,1814,1815,5,196,0,0,1815,1816,3,124,62,0,1816, + 1817,3,44,22,0,1817,1819,1,0,0,0,1818,1702,1,0,0,0,1818,1707,1,0,0,0,1818, + 1712,1,0,0,0,1818,1717,1,0,0,0,1818,1722,1,0,0,0,1818,1723,1,0,0,0,1818, + 1724,1,0,0,0,1818,1725,1,0,0,0,1818,1726,1,0,0,0,1818,1727,1,0,0,0,1818, + 1729,1,0,0,0,1818,1731,1,0,0,0,1818,1736,1,0,0,0,1818,1748,1,0,0,0,1818, + 1767,1,0,0,0,1818,1768,1,0,0,0,1818,1769,1,0,0,0,1818,1780,1,0,0,0,1818, + 1789,1,0,0,0,1818,1802,1,0,0,0,1818,1813,1,0,0,0,1819,199,1,0,0,0,1820, + 1821,5,121,0,0,1821,1830,3,208,104,0,1822,1829,3,202,101,0,1823,1824,5, + 122,0,0,1824,1825,5,30,0,0,1825,1826,3,228,114,0,1826,1827,5,31,0,0,1827, + 1829,1,0,0,0,1828,1822,1,0,0,0,1828,1823,1,0,0,0,1829,1832,1,0,0,0,1830, + 1828,1,0,0,0,1830,1831,1,0,0,0,1831,1833,1,0,0,0,1832,1830,1,0,0,0,1833, + 1834,3,138,69,0,1834,1835,3,2,1,0,1835,1836,3,204,102,0,1836,1837,3,206, + 103,0,1837,201,1,0,0,0,1838,1858,5,123,0,0,1839,1858,5,51,0,0,1840,1858, + 5,52,0,0,1841,1858,5,63,0,0,1842,1858,5,124,0,0,1843,1858,5,69,0,0,1844, + 1858,5,68,0,0,1845,1858,5,64,0,0,1846,1858,5,65,0,0,1847,1858,5,66,0,0, + 1848,1858,5,125,0,0,1849,1858,5,126,0,0,1850,1858,5,127,0,0,1851,1858, + 5,16,0,0,1852,1853,5,70,0,0,1853,1854,5,30,0,0,1854,1855,3,32,16,0,1855, + 1856,5,31,0,0,1856,1858,1,0,0,0,1857,1838,1,0,0,0,1857,1839,1,0,0,0,1857, + 1840,1,0,0,0,1857,1841,1,0,0,0,1857,1842,1,0,0,0,1857,1843,1,0,0,0,1857, + 1844,1,0,0,0,1857,1845,1,0,0,0,1857,1846,1,0,0,0,1857,1847,1,0,0,0,1857, + 1848,1,0,0,0,1857,1849,1,0,0,0,1857,1850,1,0,0,0,1857,1851,1,0,0,0,1857, + 1852,1,0,0,0,1858,203,1,0,0,0,1859,1865,1,0,0,0,1860,1861,5,44,0,0,1861, + 1865,3,0,0,0,1862,1863,5,44,0,0,1863,1865,3,32,16,0,1864,1859,1,0,0,0, + 1864,1860,1,0,0,0,1864,1862,1,0,0,0,1865,205,1,0,0,0,1866,1870,1,0,0,0, + 1867,1868,5,36,0,0,1868,1870,3,296,148,0,1869,1866,1,0,0,0,1869,1867,1, + 0,0,0,1870,207,1,0,0,0,1871,1877,1,0,0,0,1872,1873,5,42,0,0,1873,1874, + 3,32,16,0,1874,1875,5,43,0,0,1875,1877,1,0,0,0,1876,1871,1,0,0,0,1876, + 1872,1,0,0,0,1877,209,1,0,0,0,1878,1882,5,128,0,0,1879,1881,3,212,106, + 0,1880,1879,1,0,0,0,1881,1884,1,0,0,0,1882,1880,1,0,0,0,1882,1883,1,0, + 0,0,1883,1885,1,0,0,0,1884,1882,1,0,0,0,1885,1886,3,124,62,0,1886,1887, + 3,2,1,0,1887,1897,1,0,0,0,1888,1892,5,128,0,0,1889,1891,3,212,106,0,1890, + 1889,1,0,0,0,1891,1894,1,0,0,0,1892,1890,1,0,0,0,1892,1893,1,0,0,0,1893, + 1895,1,0,0,0,1894,1892,1,0,0,0,1895,1897,3,2,1,0,1896,1878,1,0,0,0,1896, + 1888,1,0,0,0,1897,211,1,0,0,0,1898,1899,7,11,0,0,1899,213,1,0,0,0,1900, + 1902,3,216,108,0,1901,1900,1,0,0,0,1902,1905,1,0,0,0,1903,1901,1,0,0,0, + 1903,1904,1,0,0,0,1904,215,1,0,0,0,1905,1903,1,0,0,0,1906,1907,5,129,0, + 0,1907,1919,3,168,84,0,1908,1909,5,130,0,0,1909,1919,3,168,84,0,1910,1911, + 5,131,0,0,1911,1919,3,168,84,0,1912,1913,5,132,0,0,1913,1919,3,168,84, + 0,1914,1919,3,88,44,0,1915,1919,3,322,161,0,1916,1919,3,26,13,0,1917,1919, + 3,40,20,0,1918,1906,1,0,0,0,1918,1908,1,0,0,0,1918,1910,1,0,0,0,1918,1912, + 1,0,0,0,1918,1914,1,0,0,0,1918,1915,1,0,0,0,1918,1916,1,0,0,0,1918,1917, + 1,0,0,0,1919,217,1,0,0,0,1920,1924,5,133,0,0,1921,1923,3,220,110,0,1922, + 1921,1,0,0,0,1923,1926,1,0,0,0,1924,1922,1,0,0,0,1924,1925,1,0,0,0,1925, + 1927,1,0,0,0,1926,1924,1,0,0,0,1927,1928,3,170,85,0,1928,1929,3,138,69, + 0,1929,1930,3,2,1,0,1930,1931,3,112,56,0,1931,1932,3,206,103,0,1932,219, + 1,0,0,0,1933,1934,7,11,0,0,1934,221,1,0,0,0,1935,1937,3,224,112,0,1936, + 1935,1,0,0,0,1937,1940,1,0,0,0,1938,1936,1,0,0,0,1938,1939,1,0,0,0,1939, + 223,1,0,0,0,1940,1938,1,0,0,0,1941,1942,5,134,0,0,1942,1952,3,168,84,0, + 1943,1944,5,135,0,0,1944,1952,3,168,84,0,1945,1946,5,132,0,0,1946,1952, + 3,168,84,0,1947,1952,3,322,161,0,1948,1952,3,88,44,0,1949,1952,3,26,13, + 0,1950,1952,3,40,20,0,1951,1941,1,0,0,0,1951,1943,1,0,0,0,1951,1945,1, + 0,0,0,1951,1947,1,0,0,0,1951,1948,1,0,0,0,1951,1949,1,0,0,0,1951,1950, + 1,0,0,0,1952,225,1,0,0,0,1953,1960,1,0,0,0,1954,1955,5,122,0,0,1955,1956, + 5,30,0,0,1956,1957,3,228,114,0,1957,1958,5,31,0,0,1958,1960,1,0,0,0,1959, + 1953,1,0,0,0,1959,1954,1,0,0,0,1960,227,1,0,0,0,1961,1971,3,126,63,0,1962, + 1964,5,17,0,0,1963,1965,3,294,147,0,1964,1963,1,0,0,0,1965,1966,1,0,0, + 0,1966,1964,1,0,0,0,1966,1967,1,0,0,0,1967,1968,1,0,0,0,1968,1969,5,18, + 0,0,1969,1971,1,0,0,0,1970,1961,1,0,0,0,1970,1962,1,0,0,0,1971,229,1,0, + 0,0,1972,1974,3,232,116,0,1973,1972,1,0,0,0,1974,1977,1,0,0,0,1975,1973, + 1,0,0,0,1975,1976,1,0,0,0,1976,231,1,0,0,0,1977,1975,1,0,0,0,1978,1979, + 5,42,0,0,1979,1980,5,136,0,0,1980,1992,5,43,0,0,1981,1982,5,42,0,0,1982, + 1983,5,137,0,0,1983,1992,5,43,0,0,1984,1985,5,42,0,0,1985,1986,5,138,0, + 0,1986,1992,5,43,0,0,1987,1988,5,42,0,0,1988,1989,3,32,16,0,1989,1990, + 5,43,0,0,1990,1992,1,0,0,0,1991,1978,1,0,0,0,1991,1981,1,0,0,0,1991,1984, + 1,0,0,0,1991,1987,1,0,0,0,1992,233,1,0,0,0,1993,1998,5,139,0,0,1994,1997, + 3,236,118,0,1995,1997,3,238,119,0,1996,1994,1,0,0,0,1996,1995,1,0,0,0, + 1997,2000,1,0,0,0,1998,1996,1,0,0,0,1998,1999,1,0,0,0,1999,2001,1,0,0, + 0,2000,1998,1,0,0,0,2001,2002,3,170,85,0,2002,2003,3,230,115,0,2003,2004, + 3,138,69,0,2004,2005,3,226,113,0,2005,2006,3,242,121,0,2006,2007,3,182, + 91,0,2007,2011,3,112,56,0,2008,2010,3,244,122,0,2009,2008,1,0,0,0,2010, + 2013,1,0,0,0,2011,2009,1,0,0,0,2011,2012,1,0,0,0,2012,235,1,0,0,0,2013, + 2011,1,0,0,0,2014,2038,5,123,0,0,2015,2038,5,51,0,0,2016,2038,5,52,0,0, + 2017,2038,5,63,0,0,2018,2038,5,140,0,0,2019,2038,5,68,0,0,2020,2038,5, + 141,0,0,2021,2038,5,142,0,0,2022,2038,5,54,0,0,2023,2038,5,64,0,0,2024, + 2038,5,65,0,0,2025,2038,5,66,0,0,2026,2038,5,125,0,0,2027,2038,5,143,0, + 0,2028,2038,5,144,0,0,2029,2038,5,69,0,0,2030,2038,5,145,0,0,2031,2038, + 5,146,0,0,2032,2033,5,70,0,0,2033,2034,5,30,0,0,2034,2035,3,32,16,0,2035, + 2036,5,31,0,0,2036,2038,1,0,0,0,2037,2014,1,0,0,0,2037,2015,1,0,0,0,2037, + 2016,1,0,0,0,2037,2017,1,0,0,0,2037,2018,1,0,0,0,2037,2019,1,0,0,0,2037, + 2020,1,0,0,0,2037,2021,1,0,0,0,2037,2022,1,0,0,0,2037,2023,1,0,0,0,2037, + 2024,1,0,0,0,2037,2025,1,0,0,0,2037,2026,1,0,0,0,2037,2027,1,0,0,0,2037, + 2028,1,0,0,0,2037,2029,1,0,0,0,2037,2030,1,0,0,0,2037,2031,1,0,0,0,2037, + 2032,1,0,0,0,2038,237,1,0,0,0,2039,2040,5,147,0,0,2040,2046,5,30,0,0,2041, + 2044,3,6,3,0,2042,2043,5,34,0,0,2043,2045,3,6,3,0,2044,2042,1,0,0,0,2044, + 2045,1,0,0,0,2045,2047,1,0,0,0,2046,2041,1,0,0,0,2046,2047,1,0,0,0,2047, + 2051,1,0,0,0,2048,2050,3,240,120,0,2049,2048,1,0,0,0,2050,2053,1,0,0,0, + 2051,2049,1,0,0,0,2051,2052,1,0,0,0,2052,2054,1,0,0,0,2053,2051,1,0,0, + 0,2054,2058,5,31,0,0,2055,2056,5,147,0,0,2056,2058,5,85,0,0,2057,2039, + 1,0,0,0,2057,2055,1,0,0,0,2058,239,1,0,0,0,2059,2087,5,148,0,0,2060,2087, + 5,224,0,0,2061,2087,5,57,0,0,2062,2087,5,58,0,0,2063,2087,5,149,0,0,2064, + 2087,5,150,0,0,2065,2087,5,248,0,0,2066,2087,5,249,0,0,2067,2087,5,250, + 0,0,2068,2087,5,251,0,0,2069,2070,5,151,0,0,2070,2071,5,75,0,0,2071,2087, + 5,152,0,0,2072,2073,5,151,0,0,2073,2074,5,75,0,0,2074,2087,5,153,0,0,2075, + 2076,5,154,0,0,2076,2077,5,75,0,0,2077,2087,5,152,0,0,2078,2079,5,154, + 0,0,2079,2080,5,75,0,0,2080,2087,5,153,0,0,2081,2082,5,70,0,0,2082,2083, + 5,30,0,0,2083,2084,3,32,16,0,2084,2085,5,31,0,0,2085,2087,1,0,0,0,2086, + 2059,1,0,0,0,2086,2060,1,0,0,0,2086,2061,1,0,0,0,2086,2062,1,0,0,0,2086, + 2063,1,0,0,0,2086,2064,1,0,0,0,2086,2065,1,0,0,0,2086,2066,1,0,0,0,2086, + 2067,1,0,0,0,2086,2068,1,0,0,0,2086,2069,1,0,0,0,2086,2072,1,0,0,0,2086, + 2075,1,0,0,0,2086,2078,1,0,0,0,2086,2081,1,0,0,0,2087,241,1,0,0,0,2088, + 2092,5,116,0,0,2089,2092,5,155,0,0,2090,2092,3,2,1,0,2091,2088,1,0,0,0, + 2091,2089,1,0,0,0,2091,2090,1,0,0,0,2092,243,1,0,0,0,2093,2115,5,1,0,0, + 2094,2115,5,2,0,0,2095,2115,5,156,0,0,2096,2115,5,3,0,0,2097,2115,5,4, + 0,0,2098,2115,5,247,0,0,2099,2115,5,5,0,0,2100,2115,5,6,0,0,2101,2115, + 5,7,0,0,2102,2115,5,8,0,0,2103,2115,5,9,0,0,2104,2115,5,10,0,0,2105,2115, + 5,11,0,0,2106,2115,5,12,0,0,2107,2115,5,13,0,0,2108,2115,5,14,0,0,2109, + 2110,5,70,0,0,2110,2111,5,30,0,0,2111,2112,3,32,16,0,2112,2113,5,31,0, + 0,2113,2115,1,0,0,0,2114,2093,1,0,0,0,2114,2094,1,0,0,0,2114,2095,1,0, + 0,0,2114,2096,1,0,0,0,2114,2097,1,0,0,0,2114,2098,1,0,0,0,2114,2099,1, + 0,0,0,2114,2100,1,0,0,0,2114,2101,1,0,0,0,2114,2102,1,0,0,0,2114,2103, + 1,0,0,0,2114,2104,1,0,0,0,2114,2105,1,0,0,0,2114,2106,1,0,0,0,2114,2107, + 1,0,0,0,2114,2108,1,0,0,0,2114,2109,1,0,0,0,2115,245,1,0,0,0,2116,2118, + 3,248,124,0,2117,2116,1,0,0,0,2118,2121,1,0,0,0,2119,2117,1,0,0,0,2119, + 2120,1,0,0,0,2120,247,1,0,0,0,2121,2119,1,0,0,0,2122,2140,3,100,50,0,2123, + 2124,5,296,0,0,2124,2125,3,32,16,0,2125,2126,6,124,-1,0,2126,2140,1,0, + 0,0,2127,2140,3,258,129,0,2128,2129,5,297,0,0,2129,2130,3,32,16,0,2130, + 2131,6,124,-1,0,2131,2140,1,0,0,0,2132,2133,5,298,0,0,2133,2140,6,124, + -1,0,2134,2135,5,299,0,0,2135,2140,6,124,-1,0,2136,2140,3,252,126,0,2137, + 2140,3,256,128,0,2138,2140,3,250,125,0,2139,2122,1,0,0,0,2139,2123,1,0, + 0,0,2139,2127,1,0,0,0,2139,2128,1,0,0,0,2139,2132,1,0,0,0,2139,2134,1, + 0,0,0,2139,2136,1,0,0,0,2139,2137,1,0,0,0,2139,2138,1,0,0,0,2140,249,1, + 0,0,0,2141,2142,5,300,0,0,2142,2240,3,112,56,0,2143,2144,5,300,0,0,2144, + 2145,5,157,0,0,2145,2240,3,112,56,0,2146,2240,3,276,138,0,2147,2240,3, + 152,76,0,2148,2240,3,88,44,0,2149,2240,3,26,13,0,2150,2240,3,254,127,0, + 2151,2240,3,40,20,0,2152,2153,5,301,0,0,2153,2154,5,42,0,0,2154,2155,3, + 32,16,0,2155,2156,5,43,0,0,2156,2240,1,0,0,0,2157,2158,5,301,0,0,2158, + 2159,5,42,0,0,2159,2160,3,32,16,0,2160,2161,5,43,0,0,2161,2162,5,34,0, + 0,2162,2163,3,0,0,0,2163,2240,1,0,0,0,2164,2165,5,303,0,0,2165,2166,3, + 32,16,0,2166,2167,5,75,0,0,2167,2168,3,32,16,0,2168,2240,1,0,0,0,2169, + 2170,5,302,0,0,2170,2171,3,124,62,0,2171,2172,5,176,0,0,2172,2173,3,242, + 121,0,2173,2240,1,0,0,0,2174,2175,5,302,0,0,2175,2176,5,226,0,0,2176,2177, + 3,170,85,0,2177,2178,3,138,69,0,2178,2179,3,124,62,0,2179,2180,5,176,0, + 0,2180,2181,3,242,121,0,2181,2182,3,194,97,0,2182,2183,3,112,56,0,2183, + 2240,1,0,0,0,2184,2185,5,255,0,0,2185,2186,5,196,0,0,2186,2187,5,42,0, + 0,2187,2188,3,32,16,0,2188,2192,5,43,0,0,2189,2191,3,322,161,0,2190,2189, + 1,0,0,0,2191,2194,1,0,0,0,2192,2190,1,0,0,0,2192,2193,1,0,0,0,2193,2240, + 1,0,0,0,2194,2192,1,0,0,0,2195,2196,5,255,0,0,2196,2197,5,196,0,0,2197, + 2201,3,2,1,0,2198,2200,3,322,161,0,2199,2198,1,0,0,0,2200,2203,1,0,0,0, + 2201,2199,1,0,0,0,2201,2202,1,0,0,0,2202,2240,1,0,0,0,2203,2201,1,0,0, + 0,2204,2205,5,255,0,0,2205,2206,5,256,0,0,2206,2207,5,42,0,0,2207,2208, + 3,32,16,0,2208,2209,5,43,0,0,2209,2210,5,28,0,0,2210,2214,3,124,62,0,2211, + 2213,3,322,161,0,2212,2211,1,0,0,0,2213,2216,1,0,0,0,2214,2212,1,0,0,0, + 2214,2215,1,0,0,0,2215,2240,1,0,0,0,2216,2214,1,0,0,0,2217,2218,5,255, + 0,0,2218,2219,5,256,0,0,2219,2220,3,2,1,0,2220,2221,5,28,0,0,2221,2225, + 3,124,62,0,2222,2224,3,322,161,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,2240,1,0,0,0,2227,2225,1,0,0,0,2228, + 2229,5,255,0,0,2229,2230,5,42,0,0,2230,2231,3,32,16,0,2231,2232,5,43,0, + 0,2232,2236,3,206,103,0,2233,2235,3,322,161,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,2240,1,0,0,0,2238,2236, + 1,0,0,0,2239,2141,1,0,0,0,2239,2143,1,0,0,0,2239,2146,1,0,0,0,2239,2147, + 1,0,0,0,2239,2148,1,0,0,0,2239,2149,1,0,0,0,2239,2150,1,0,0,0,2239,2151, + 1,0,0,0,2239,2152,1,0,0,0,2239,2157,1,0,0,0,2239,2164,1,0,0,0,2239,2169, + 1,0,0,0,2239,2174,1,0,0,0,2239,2184,1,0,0,0,2239,2195,1,0,0,0,2239,2204, + 1,0,0,0,2239,2217,1,0,0,0,2239,2228,1,0,0,0,2240,251,1,0,0,0,2241,2242, + 3,0,0,0,2242,2243,5,75,0,0,2243,2244,6,126,-1,0,2244,253,1,0,0,0,2245, + 2248,3,44,22,0,2246,2248,3,46,23,0,2247,2245,1,0,0,0,2247,2246,1,0,0,0, + 2248,255,1,0,0,0,2249,2250,5,17,0,0,2250,2251,3,246,123,0,2251,2252,5, + 18,0,0,2252,257,1,0,0,0,2253,2254,3,262,131,0,2254,2255,3,260,130,0,2255, + 259,1,0,0,0,2256,2258,3,264,132,0,2257,2256,1,0,0,0,2258,2259,1,0,0,0, + 2259,2257,1,0,0,0,2259,2260,1,0,0,0,2260,261,1,0,0,0,2261,2262,5,158,0, + 0,2262,2274,3,256,128,0,2263,2264,5,158,0,0,2264,2265,3,0,0,0,2265,2266, + 5,159,0,0,2266,2267,3,0,0,0,2267,2274,1,0,0,0,2268,2269,5,158,0,0,2269, + 2270,3,32,16,0,2270,2271,5,159,0,0,2271,2272,3,32,16,0,2272,2274,1,0,0, + 0,2273,2261,1,0,0,0,2273,2263,1,0,0,0,2273,2268,1,0,0,0,2274,263,1,0,0, + 0,2275,2276,3,268,134,0,2276,2277,3,274,137,0,2277,2288,1,0,0,0,2278,2279, + 3,266,133,0,2279,2280,3,274,137,0,2280,2288,1,0,0,0,2281,2282,3,270,135, + 0,2282,2283,3,274,137,0,2283,2288,1,0,0,0,2284,2285,3,272,136,0,2285,2286, + 3,274,137,0,2286,2288,1,0,0,0,2287,2275,1,0,0,0,2287,2278,1,0,0,0,2287, + 2281,1,0,0,0,2287,2284,1,0,0,0,2288,265,1,0,0,0,2289,2290,5,160,0,0,2290, + 2296,3,256,128,0,2291,2292,5,160,0,0,2292,2296,3,0,0,0,2293,2294,5,160, + 0,0,2294,2296,3,32,16,0,2295,2289,1,0,0,0,2295,2291,1,0,0,0,2295,2293, + 1,0,0,0,2296,267,1,0,0,0,2297,2298,5,161,0,0,2298,2299,3,124,62,0,2299, + 269,1,0,0,0,2300,2301,5,162,0,0,2301,271,1,0,0,0,2302,2303,5,163,0,0,2303, + 273,1,0,0,0,2304,2316,3,256,128,0,2305,2306,5,164,0,0,2306,2307,3,0,0, + 0,2307,2308,5,159,0,0,2308,2309,3,0,0,0,2309,2316,1,0,0,0,2310,2311,5, + 164,0,0,2311,2312,3,32,16,0,2312,2313,5,159,0,0,2313,2314,3,32,16,0,2314, + 2316,1,0,0,0,2315,2304,1,0,0,0,2315,2305,1,0,0,0,2315,2310,1,0,0,0,2316, + 275,1,0,0,0,2317,2318,3,278,139,0,2318,2319,3,282,141,0,2319,277,1,0,0, + 0,2320,2321,5,165,0,0,2321,2322,3,280,140,0,2322,2323,3,0,0,0,2323,2324, + 5,36,0,0,2324,2328,1,0,0,0,2325,2326,5,165,0,0,2326,2328,3,280,140,0,2327, + 2320,1,0,0,0,2327,2325,1,0,0,0,2328,279,1,0,0,0,2329,2333,1,0,0,0,2330, + 2333,5,166,0,0,2331,2333,5,2,0,0,2332,2329,1,0,0,0,2332,2330,1,0,0,0,2332, + 2331,1,0,0,0,2333,281,1,0,0,0,2334,2335,5,17,0,0,2335,2336,3,284,142,0, + 2336,2337,5,18,0,0,2337,2344,1,0,0,0,2338,2340,3,288,144,0,2339,2338,1, + 0,0,0,2340,2341,1,0,0,0,2341,2339,1,0,0,0,2341,2342,1,0,0,0,2342,2344, + 1,0,0,0,2343,2334,1,0,0,0,2343,2339,1,0,0,0,2344,283,1,0,0,0,2345,2346, + 3,288,144,0,2346,2347,5,28,0,0,2347,2349,1,0,0,0,2348,2345,1,0,0,0,2349, + 2352,1,0,0,0,2350,2348,1,0,0,0,2350,2351,1,0,0,0,2351,2353,1,0,0,0,2352, + 2350,1,0,0,0,2353,2354,3,288,144,0,2354,285,1,0,0,0,2355,2361,1,0,0,0, + 2356,2357,5,42,0,0,2357,2358,3,32,16,0,2358,2359,5,43,0,0,2359,2361,1, + 0,0,0,2360,2355,1,0,0,0,2360,2356,1,0,0,0,2361,287,1,0,0,0,2362,2363,5, + 181,0,0,2363,2364,5,262,0,0,2364,2365,5,30,0,0,2365,2366,3,6,3,0,2366, + 2367,5,31,0,0,2367,2429,1,0,0,0,2368,2369,5,260,0,0,2369,2370,5,30,0,0, + 2370,2371,3,0,0,0,2371,2372,5,31,0,0,2372,2429,1,0,0,0,2373,2374,5,260, + 0,0,2374,2429,3,0,0,0,2375,2376,5,84,0,0,2376,2377,5,30,0,0,2377,2378, + 3,292,146,0,2378,2379,5,31,0,0,2379,2429,1,0,0,0,2380,2381,5,188,0,0,2381, + 2382,5,30,0,0,2382,2383,3,36,18,0,2383,2384,5,31,0,0,2384,2385,3,286,143, + 0,2385,2429,1,0,0,0,2386,2387,5,189,0,0,2387,2388,5,30,0,0,2388,2389,3, + 36,18,0,2389,2390,5,31,0,0,2390,2391,3,286,143,0,2391,2429,1,0,0,0,2392, + 2393,5,187,0,0,2393,2394,5,30,0,0,2394,2395,3,34,17,0,2395,2396,5,31,0, + 0,2396,2397,3,286,143,0,2397,2429,1,0,0,0,2398,2399,5,186,0,0,2399,2400, + 5,30,0,0,2400,2401,3,32,16,0,2401,2402,5,31,0,0,2402,2403,3,286,143,0, + 2403,2429,1,0,0,0,2404,2405,5,185,0,0,2405,2406,5,30,0,0,2406,2407,3,32, + 16,0,2407,2408,5,31,0,0,2408,2409,3,286,143,0,2409,2429,1,0,0,0,2410,2411, + 5,184,0,0,2411,2412,5,30,0,0,2412,2413,3,32,16,0,2413,2414,5,31,0,0,2414, + 2415,3,286,143,0,2415,2429,1,0,0,0,2416,2417,5,188,0,0,2417,2429,3,286, + 143,0,2418,2419,5,189,0,0,2419,2429,3,286,143,0,2420,2421,5,187,0,0,2421, + 2429,3,286,143,0,2422,2423,5,186,0,0,2423,2429,3,286,143,0,2424,2425,5, + 185,0,0,2425,2429,3,286,143,0,2426,2427,5,184,0,0,2427,2429,3,286,143, + 0,2428,2362,1,0,0,0,2428,2368,1,0,0,0,2428,2373,1,0,0,0,2428,2375,1,0, + 0,0,2428,2380,1,0,0,0,2428,2386,1,0,0,0,2428,2392,1,0,0,0,2428,2398,1, + 0,0,0,2428,2404,1,0,0,0,2428,2410,1,0,0,0,2428,2416,1,0,0,0,2428,2418, + 1,0,0,0,2428,2420,1,0,0,0,2428,2422,1,0,0,0,2428,2424,1,0,0,0,2428,2426, + 1,0,0,0,2429,289,1,0,0,0,2430,2431,5,188,0,0,2431,2432,5,30,0,0,2432,2433, + 3,36,18,0,2433,2434,5,31,0,0,2434,2506,1,0,0,0,2435,2436,5,189,0,0,2436, + 2437,5,30,0,0,2437,2438,3,36,18,0,2438,2439,5,31,0,0,2439,2506,1,0,0,0, + 2440,2441,5,188,0,0,2441,2442,5,30,0,0,2442,2443,3,32,16,0,2443,2444,5, + 31,0,0,2444,2506,1,0,0,0,2445,2446,5,189,0,0,2446,2447,5,30,0,0,2447,2448, + 3,34,17,0,2448,2449,5,31,0,0,2449,2506,1,0,0,0,2450,2451,5,187,0,0,2451, + 2452,5,30,0,0,2452,2453,3,34,17,0,2453,2454,5,31,0,0,2454,2506,1,0,0,0, + 2455,2456,5,186,0,0,2456,2457,5,30,0,0,2457,2458,3,32,16,0,2458,2459,5, + 31,0,0,2459,2506,1,0,0,0,2460,2461,5,185,0,0,2461,2462,5,30,0,0,2462,2463, + 3,32,16,0,2463,2464,5,31,0,0,2464,2506,1,0,0,0,2465,2466,5,184,0,0,2466, + 2467,5,30,0,0,2467,2468,3,32,16,0,2468,2469,5,31,0,0,2469,2506,1,0,0,0, + 2470,2471,5,193,0,0,2471,2472,5,30,0,0,2472,2473,3,34,17,0,2473,2474,5, + 31,0,0,2474,2506,1,0,0,0,2475,2476,5,192,0,0,2476,2477,5,30,0,0,2477,2478, + 3,32,16,0,2478,2479,5,31,0,0,2479,2506,1,0,0,0,2480,2481,5,191,0,0,2481, + 2482,5,30,0,0,2482,2483,3,32,16,0,2483,2484,5,31,0,0,2484,2506,1,0,0,0, + 2485,2486,5,190,0,0,2486,2487,5,30,0,0,2487,2488,3,32,16,0,2488,2489,5, + 31,0,0,2489,2506,1,0,0,0,2490,2491,5,181,0,0,2491,2492,5,30,0,0,2492,2493, + 3,32,16,0,2493,2494,5,31,0,0,2494,2506,1,0,0,0,2495,2496,5,183,0,0,2496, + 2497,5,30,0,0,2497,2498,3,162,81,0,2498,2499,5,31,0,0,2499,2506,1,0,0, + 0,2500,2501,5,84,0,0,2501,2502,5,30,0,0,2502,2503,3,292,146,0,2503,2504, + 5,31,0,0,2504,2506,1,0,0,0,2505,2430,1,0,0,0,2505,2435,1,0,0,0,2505,2440, + 1,0,0,0,2505,2445,1,0,0,0,2505,2450,1,0,0,0,2505,2455,1,0,0,0,2505,2460, + 1,0,0,0,2505,2465,1,0,0,0,2505,2470,1,0,0,0,2505,2475,1,0,0,0,2505,2480, + 1,0,0,0,2505,2485,1,0,0,0,2505,2490,1,0,0,0,2505,2495,1,0,0,0,2505,2500, + 1,0,0,0,2506,291,1,0,0,0,2507,2508,3,294,147,0,2508,2509,6,146,-1,0,2509, + 2511,1,0,0,0,2510,2507,1,0,0,0,2511,2514,1,0,0,0,2512,2510,1,0,0,0,2512, + 2513,1,0,0,0,2513,293,1,0,0,0,2514,2512,1,0,0,0,2515,2516,7,12,0,0,2516, + 295,1,0,0,0,2517,2521,3,290,145,0,2518,2521,3,6,3,0,2519,2521,5,179,0, + 0,2520,2517,1,0,0,0,2520,2518,1,0,0,0,2520,2519,1,0,0,0,2521,297,1,0,0, + 0,2522,2671,3,290,145,0,2523,2524,5,182,0,0,2524,2525,5,30,0,0,2525,2526, + 5,179,0,0,2526,2671,5,31,0,0,2527,2528,5,182,0,0,2528,2529,5,30,0,0,2529, + 2530,5,264,0,0,2530,2671,5,31,0,0,2531,2532,5,196,0,0,2532,2533,5,30,0, + 0,2533,2534,5,39,0,0,2534,2535,5,264,0,0,2535,2671,5,31,0,0,2536,2537, + 5,196,0,0,2537,2538,5,30,0,0,2538,2539,3,116,58,0,2539,2540,5,31,0,0,2540, + 2671,1,0,0,0,2541,2542,5,196,0,0,2542,2543,5,30,0,0,2543,2544,5,179,0, + 0,2544,2671,5,31,0,0,2545,2546,5,197,0,0,2546,2547,5,30,0,0,2547,2548, + 3,298,149,0,2548,2549,5,31,0,0,2549,2671,1,0,0,0,2550,2551,5,188,0,0,2551, + 2552,5,42,0,0,2552,2553,3,32,16,0,2553,2554,5,43,0,0,2554,2555,5,30,0, + 0,2555,2556,3,300,150,0,2556,2557,5,31,0,0,2557,2671,1,0,0,0,2558,2559, + 5,189,0,0,2559,2560,5,42,0,0,2560,2561,3,32,16,0,2561,2562,5,43,0,0,2562, + 2563,5,30,0,0,2563,2564,3,302,151,0,2564,2565,5,31,0,0,2565,2671,1,0,0, + 0,2566,2567,5,187,0,0,2567,2568,5,42,0,0,2568,2569,3,32,16,0,2569,2570, + 5,43,0,0,2570,2571,5,30,0,0,2571,2572,3,304,152,0,2572,2573,5,31,0,0,2573, + 2671,1,0,0,0,2574,2575,5,186,0,0,2575,2576,5,42,0,0,2576,2577,3,32,16, + 0,2577,2578,5,43,0,0,2578,2579,5,30,0,0,2579,2580,3,306,153,0,2580,2581, + 5,31,0,0,2581,2671,1,0,0,0,2582,2583,5,185,0,0,2583,2584,5,42,0,0,2584, + 2585,3,32,16,0,2585,2586,5,43,0,0,2586,2587,5,30,0,0,2587,2588,3,308,154, + 0,2588,2589,5,31,0,0,2589,2671,1,0,0,0,2590,2591,5,184,0,0,2591,2592,5, + 42,0,0,2592,2593,3,32,16,0,2593,2594,5,43,0,0,2594,2595,5,30,0,0,2595, + 2596,3,310,155,0,2596,2597,5,31,0,0,2597,2671,1,0,0,0,2598,2599,5,193, + 0,0,2599,2600,5,42,0,0,2600,2601,3,32,16,0,2601,2602,5,43,0,0,2602,2603, + 5,30,0,0,2603,2604,3,304,152,0,2604,2605,5,31,0,0,2605,2671,1,0,0,0,2606, + 2607,5,192,0,0,2607,2608,5,42,0,0,2608,2609,3,32,16,0,2609,2610,5,43,0, + 0,2610,2611,5,30,0,0,2611,2612,3,306,153,0,2612,2613,5,31,0,0,2613,2671, + 1,0,0,0,2614,2615,5,191,0,0,2615,2616,5,42,0,0,2616,2617,3,32,16,0,2617, + 2618,5,43,0,0,2618,2619,5,30,0,0,2619,2620,3,308,154,0,2620,2621,5,31, + 0,0,2621,2671,1,0,0,0,2622,2623,5,190,0,0,2623,2624,5,42,0,0,2624,2625, + 3,32,16,0,2625,2626,5,43,0,0,2626,2627,5,30,0,0,2627,2628,3,310,155,0, + 2628,2629,5,31,0,0,2629,2671,1,0,0,0,2630,2631,5,181,0,0,2631,2632,5,42, + 0,0,2632,2633,3,32,16,0,2633,2634,5,43,0,0,2634,2635,5,30,0,0,2635,2636, + 3,308,154,0,2636,2637,5,31,0,0,2637,2671,1,0,0,0,2638,2639,5,183,0,0,2639, + 2640,5,42,0,0,2640,2641,3,32,16,0,2641,2642,5,43,0,0,2642,2643,5,30,0, + 0,2643,2644,3,312,156,0,2644,2645,5,31,0,0,2645,2671,1,0,0,0,2646,2647, + 5,182,0,0,2647,2648,5,42,0,0,2648,2649,3,32,16,0,2649,2650,5,43,0,0,2650, + 2651,5,30,0,0,2651,2652,3,314,157,0,2652,2653,5,31,0,0,2653,2671,1,0,0, + 0,2654,2655,5,196,0,0,2655,2656,5,42,0,0,2656,2657,3,32,16,0,2657,2658, + 5,43,0,0,2658,2659,5,30,0,0,2659,2660,3,316,158,0,2660,2661,5,31,0,0,2661, + 2671,1,0,0,0,2662,2663,5,197,0,0,2663,2664,5,42,0,0,2664,2665,3,32,16, + 0,2665,2666,5,43,0,0,2666,2667,5,30,0,0,2667,2668,3,320,160,0,2668,2669, + 5,31,0,0,2669,2671,1,0,0,0,2670,2522,1,0,0,0,2670,2523,1,0,0,0,2670,2527, + 1,0,0,0,2670,2531,1,0,0,0,2670,2536,1,0,0,0,2670,2541,1,0,0,0,2670,2545, + 1,0,0,0,2670,2550,1,0,0,0,2670,2558,1,0,0,0,2670,2566,1,0,0,0,2670,2574, + 1,0,0,0,2670,2582,1,0,0,0,2670,2590,1,0,0,0,2670,2598,1,0,0,0,2670,2606, + 1,0,0,0,2670,2614,1,0,0,0,2670,2622,1,0,0,0,2670,2630,1,0,0,0,2670,2638, + 1,0,0,0,2670,2646,1,0,0,0,2670,2654,1,0,0,0,2670,2662,1,0,0,0,2671,299, + 1,0,0,0,2672,2675,3,36,18,0,2673,2675,3,32,16,0,2674,2672,1,0,0,0,2674, + 2673,1,0,0,0,2675,2678,1,0,0,0,2676,2674,1,0,0,0,2676,2677,1,0,0,0,2677, + 301,1,0,0,0,2678,2676,1,0,0,0,2679,2682,3,36,18,0,2680,2682,3,34,17,0, + 2681,2679,1,0,0,0,2681,2680,1,0,0,0,2682,2685,1,0,0,0,2683,2681,1,0,0, + 0,2683,2684,1,0,0,0,2684,303,1,0,0,0,2685,2683,1,0,0,0,2686,2688,3,34, + 17,0,2687,2686,1,0,0,0,2688,2691,1,0,0,0,2689,2687,1,0,0,0,2689,2690,1, + 0,0,0,2690,305,1,0,0,0,2691,2689,1,0,0,0,2692,2694,3,32,16,0,2693,2692, + 1,0,0,0,2694,2697,1,0,0,0,2695,2693,1,0,0,0,2695,2696,1,0,0,0,2696,307, + 1,0,0,0,2697,2695,1,0,0,0,2698,2700,3,32,16,0,2699,2698,1,0,0,0,2700,2703, + 1,0,0,0,2701,2699,1,0,0,0,2701,2702,1,0,0,0,2702,309,1,0,0,0,2703,2701, + 1,0,0,0,2704,2706,3,32,16,0,2705,2704,1,0,0,0,2706,2709,1,0,0,0,2707,2705, + 1,0,0,0,2707,2708,1,0,0,0,2708,311,1,0,0,0,2709,2707,1,0,0,0,2710,2712, + 3,162,81,0,2711,2710,1,0,0,0,2712,2715,1,0,0,0,2713,2711,1,0,0,0,2713, + 2714,1,0,0,0,2714,313,1,0,0,0,2715,2713,1,0,0,0,2716,2718,7,13,0,0,2717, + 2716,1,0,0,0,2718,2721,1,0,0,0,2719,2717,1,0,0,0,2719,2720,1,0,0,0,2720, + 315,1,0,0,0,2721,2719,1,0,0,0,2722,2724,3,318,159,0,2723,2722,1,0,0,0, + 2724,2727,1,0,0,0,2725,2723,1,0,0,0,2725,2726,1,0,0,0,2726,317,1,0,0,0, + 2727,2725,1,0,0,0,2728,2733,5,179,0,0,2729,2730,5,39,0,0,2730,2733,5,264, + 0,0,2731,2733,3,116,58,0,2732,2728,1,0,0,0,2732,2729,1,0,0,0,2732,2731, + 1,0,0,0,2733,319,1,0,0,0,2734,2736,3,298,149,0,2735,2734,1,0,0,0,2736, + 2739,1,0,0,0,2737,2735,1,0,0,0,2737,2738,1,0,0,0,2738,321,1,0,0,0,2739, + 2737,1,0,0,0,2740,2744,3,44,22,0,2741,2744,3,46,23,0,2742,2744,3,2,1,0, + 2743,2740,1,0,0,0,2743,2741,1,0,0,0,2743,2742,1,0,0,0,2744,323,1,0,0,0, + 2745,2746,7,14,0,0,2746,2747,5,36,0,0,2747,2748,5,30,0,0,2748,2749,3,292, + 146,0,2749,2750,5,31,0,0,2750,2771,1,0,0,0,2751,2752,5,169,0,0,2752,2753, + 3,38,19,0,2753,2754,5,75,0,0,2754,2755,3,38,19,0,2755,2756,5,75,0,0,2756, + 2757,3,38,19,0,2757,2758,5,75,0,0,2758,2759,3,38,19,0,2759,2771,1,0,0, + 0,2760,2761,5,170,0,0,2761,2771,3,6,3,0,2762,2763,5,170,0,0,2763,2764, + 5,36,0,0,2764,2765,5,30,0,0,2765,2766,3,292,146,0,2766,2767,5,31,0,0,2767, + 2771,1,0,0,0,2768,2771,3,322,161,0,2769,2771,3,40,20,0,2770,2745,1,0,0, + 0,2770,2751,1,0,0,0,2770,2760,1,0,0,0,2770,2762,1,0,0,0,2770,2768,1,0, + 0,0,2770,2769,1,0,0,0,2771,325,1,0,0,0,2772,2773,5,25,0,0,2773,2774,5, + 40,0,0,2774,2775,3,98,49,0,2775,2776,3,2,1,0,2776,2785,1,0,0,0,2777,2778, + 5,25,0,0,2778,2779,5,40,0,0,2779,2780,3,98,49,0,2780,2781,3,2,1,0,2781, + 2782,5,34,0,0,2782,2783,3,2,1,0,2783,2785,1,0,0,0,2784,2772,1,0,0,0,2784, + 2777,1,0,0,0,2785,327,1,0,0,0,2786,2788,3,330,165,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,329,1,0,0,0, + 2791,2789,1,0,0,0,2792,2793,5,180,0,0,2793,2794,5,36,0,0,2794,2795,5,30, + 0,0,2795,2796,3,292,146,0,2796,2797,5,31,0,0,2797,2807,1,0,0,0,2798,2807, + 3,324,162,0,2799,2800,5,171,0,0,2800,2801,5,36,0,0,2801,2802,5,30,0,0, + 2802,2803,3,292,146,0,2803,2804,5,31,0,0,2804,2807,1,0,0,0,2805,2807,5, + 55,0,0,2806,2792,1,0,0,0,2806,2798,1,0,0,0,2806,2799,1,0,0,0,2806,2805, + 1,0,0,0,2807,331,1,0,0,0,2808,2809,5,50,0,0,2809,2813,5,40,0,0,2810,2812, + 3,336,168,0,2811,2810,1,0,0,0,2812,2815,1,0,0,0,2813,2811,1,0,0,0,2813, + 2814,1,0,0,0,2814,2816,1,0,0,0,2815,2813,1,0,0,0,2816,2817,3,2,1,0,2817, + 333,1,0,0,0,2818,2822,5,301,0,0,2819,2821,3,336,168,0,2820,2819,1,0,0, + 0,2821,2824,1,0,0,0,2822,2820,1,0,0,0,2822,2823,1,0,0,0,2823,2825,1,0, + 0,0,2824,2822,1,0,0,0,2825,2826,3,2,1,0,2826,335,1,0,0,0,2827,2843,5,52, + 0,0,2828,2843,5,51,0,0,2829,2843,5,172,0,0,2830,2831,5,62,0,0,2831,2843, + 5,51,0,0,2832,2833,5,62,0,0,2833,2843,5,52,0,0,2834,2835,5,62,0,0,2835, + 2843,5,63,0,0,2836,2837,5,62,0,0,2837,2843,5,64,0,0,2838,2839,5,62,0,0, + 2839,2843,5,65,0,0,2840,2841,5,62,0,0,2841,2843,5,66,0,0,2842,2827,1,0, + 0,0,2842,2828,1,0,0,0,2842,2829,1,0,0,0,2842,2830,1,0,0,0,2842,2832,1, + 0,0,0,2842,2834,1,0,0,0,2842,2836,1,0,0,0,2842,2838,1,0,0,0,2842,2840, + 1,0,0,0,2843,337,1,0,0,0,2844,2846,3,340,170,0,2845,2844,1,0,0,0,2846, + 2849,1,0,0,0,2847,2845,1,0,0,0,2847,2848,1,0,0,0,2848,339,1,0,0,0,2849, + 2847,1,0,0,0,2850,2851,5,21,0,0,2851,2864,3,2,1,0,2852,2853,5,50,0,0,2853, + 2854,5,40,0,0,2854,2864,3,118,59,0,2855,2856,5,25,0,0,2856,2857,5,40,0, + 0,2857,2864,3,2,1,0,2858,2864,3,174,87,0,2859,2860,5,50,0,0,2860,2864, + 3,32,16,0,2861,2864,3,322,161,0,2862,2864,3,40,20,0,2863,2850,1,0,0,0, + 2863,2852,1,0,0,0,2863,2855,1,0,0,0,2863,2858,1,0,0,0,2863,2859,1,0,0, + 0,2863,2861,1,0,0,0,2863,2862,1,0,0,0,2864,341,1,0,0,0,2865,2869,5,274, + 0,0,2866,2868,3,344,172,0,2867,2866,1,0,0,0,2868,2871,1,0,0,0,2869,2867, + 1,0,0,0,2869,2870,1,0,0,0,2870,2872,1,0,0,0,2871,2869,1,0,0,0,2872,2885, + 3,2,1,0,2873,2877,5,274,0,0,2874,2876,3,344,172,0,2875,2874,1,0,0,0,2876, + 2879,1,0,0,0,2877,2875,1,0,0,0,2877,2878,1,0,0,0,2878,2880,1,0,0,0,2879, + 2877,1,0,0,0,2880,2881,3,2,1,0,2881,2882,5,34,0,0,2882,2883,3,2,1,0,2883, + 2885,1,0,0,0,2884,2865,1,0,0,0,2884,2873,1,0,0,0,2885,343,1,0,0,0,2886, + 2887,7,15,0,0,2887,345,1,0,0,0,2888,2890,3,348,174,0,2889,2888,1,0,0,0, + 2890,2893,1,0,0,0,2891,2889,1,0,0,0,2891,2892,1,0,0,0,2892,347,1,0,0,0, + 2893,2891,1,0,0,0,2894,2895,5,21,0,0,2895,2896,3,2,1,0,2896,2897,5,44, + 0,0,2897,2898,3,32,16,0,2898,2905,1,0,0,0,2899,2900,5,25,0,0,2900,2901, + 5,40,0,0,2901,2905,3,2,1,0,2902,2905,3,322,161,0,2903,2905,3,40,20,0,2904, + 2894,1,0,0,0,2904,2899,1,0,0,0,2904,2902,1,0,0,0,2904,2903,1,0,0,0,2905, + 349,1,0,0,0,176,358,363,372,381,434,475,484,514,518,536,563,586,622,628, + 635,637,647,649,656,667,675,696,698,714,759,764,769,774,782,892,898,914, + 920,926,933,938,1016,1018,1035,1044,1050,1059,1061,1069,1081,1093,1100, + 1107,1109,1136,1143,1151,1159,1172,1179,1182,1201,1295,1304,1311,1314, + 1322,1343,1375,1398,1410,1419,1444,1468,1476,1480,1495,1502,1547,1557, + 1573,1585,1597,1611,1623,1634,1641,1651,1664,1669,1674,1683,1694,1777, + 1786,1799,1810,1818,1828,1830,1857,1864,1869,1876,1882,1892,1896,1903, + 1918,1924,1938,1951,1959,1966,1970,1975,1991,1996,1998,2011,2037,2044, + 2046,2051,2057,2086,2091,2114,2119,2139,2192,2201,2214,2225,2236,2239, + 2247,2259,2273,2287,2295,2315,2327,2332,2341,2343,2350,2360,2428,2505, + 2512,2520,2670,2674,2676,2681,2683,2689,2695,2701,2707,2713,2719,2725, + 2732,2737,2743,2770,2784,2789,2806,2813,2822,2842,2847,2863,2869,2877, + 2884,2891,2904 }; public static readonly ATN _ATN = diff --git a/src/tools/ilasm/tests/ILAssembler.Tests/InstructionTests.cs b/src/tools/ilasm/tests/ILAssembler.Tests/InstructionTests.cs index a59ce810c93dd6..f0152987e338b7 100644 --- a/src/tools/ilasm/tests/ILAssembler.Tests/InstructionTests.cs +++ b/src/tools/ilasm/tests/ILAssembler.Tests/InstructionTests.cs @@ -46,14 +46,40 @@ br UndefinedLabel Assert.Equal(DiagnosticSeverity.Error, error.Severity); } + [Fact] + public void Diagnostic_SwitchLabelNotFound_PointsToInstruction() + { + string source = """ + .assembly test { } + .class public auto ansi Test + { + .method public static void M() cil managed + { + ldc.i4.0 + switch (UndefinedLabel) + ret + } + } + """; + + var diagnostics = DocumentCompilerTestHelpers.CompileAndGetDiagnostics(source, new Options()); + var error = Assert.Single(diagnostics); + Assert.Equal(DiagnosticIds.LabelNotFound, error.Id); + Assert.Equal(source.IndexOf("switch", StringComparison.Ordinal), error.Location.Span.Start); + } + [Theory] [InlineData("ldc.i4")] [InlineData("ldc.i8")] [InlineData("ldarg")] [InlineData("br")] [InlineData("ldtoken")] + [InlineData("ldc.r8 float64(")] [InlineData("ldc.r8 bytearray(00 00")] + [InlineData("ldstr \"A\" +")] + [InlineData("ldstr ansi(\"A\"")] [InlineData("ldstr bytearray(48 00")] + [InlineData("switch (L0,")] public void MalformedSimpleInstruction_DoesNotLeakMethodState(string malformedInstruction) { string source = $$""" @@ -661,7 +687,7 @@ .method public static int32 f1() cil managed [Fact] - public void SwitchInstruction_CommaLabels() + public void SwitchInstruction_NamedLabels_EmitsExpectedBranchTable() { string source = """ .assembly extern System.Runtime { } @@ -679,8 +705,54 @@ .method public static void M() cil managed } """; - var diagnostics = DocumentCompilerTestHelpers.CompileAndGetDiagnostics(source, new Options()); - Assert.Empty(diagnostics); + using var pe = DocumentCompilerTestHelpers.CompileAndGetReader(source, new Options()); + byte[] il = GetMethodIL(pe, "M"); + int switchOffset = Array.IndexOf(il, (byte)0x45); + + Assert.True(switchOffset >= 0); + Assert.Equal(3, BitConverter.ToInt32(il, switchOffset + 1)); + Assert.Equal(0, BitConverter.ToInt32(il, switchOffset + 5)); + Assert.Equal(1, BitConverter.ToInt32(il, switchOffset + 9)); + Assert.Equal(2, BitConverter.ToInt32(il, switchOffset + 13)); + } + + [Theory] + [InlineData("ldc.r4", "1.5", 1.5)] + [InlineData("ldc.r8", "1.5", 1.5)] + [InlineData("ldc.r8", ".5", 0.5)] + [InlineData("ldc.r8", "5e+1", 50.0)] + [InlineData("ldc.r8", "-1.25e-2", -0.0125)] + [InlineData("ldc.r8", "float32(0x3F800000)", 1.0)] + public void FloatingPointInstruction_TextAndFloat32BitForms_EmitExpectedValue( + string opcode, + string literal, + double expected) + { + string source = $$""" + .assembly test { } + .class public auto ansi Test + { + .method public static void M() cil managed + { + {{opcode}} {{literal}} + pop + ret + } + } + """; + + using var pe = DocumentCompilerTestHelpers.CompileAndGetReader(source, new Options()); + byte[] il = GetMethodIL(pe, "M"); + if (opcode == "ldc.r4") + { + Assert.Equal(0x22, il[0]); + Assert.Equal((float)expected, BitConverter.ToSingle(il, 1)); + } + else + { + Assert.Equal(0x23, il[0]); + Assert.Equal(expected, BitConverter.ToDouble(il, 1)); + } } [Fact] @@ -706,6 +778,27 @@ ldc.r8 float64(0x400921FB54442D18) Assert.Equal(Math.PI, BitConverter.ToDouble(il, 1), 14); } + [Fact] + public void FloatingPointInstruction_IntegerOverflow_ReportsDiagnostic() + { + string source = """ + .assembly test { } + .class public auto ansi Test + { + .method public static void M() cil managed + { + ldc.r8 99999999999999999999999999999999 + pop + ret + } + } + """; + + var diagnostics = DocumentCompilerTestHelpers.CompileAndGetDiagnostics(source, new Options()); + var error = Assert.Single(diagnostics); + Assert.Equal(DiagnosticIds.LiteralOutOfRange, error.Id); + } + [Fact] public void FloatingPointInstruction_ByteForms_EmitExpectedConstants() { @@ -818,7 +911,7 @@ .method public static void M() cil managed } [Fact] - public void LdstrInstruction_ByteArrayAndAnsiForms_EmitExpectedUserStrings() + public void LdstrInstruction_ComposedAnsiAndRawForms_EmitExpectedUserStrings() { string source = """ .assembly extern mscorlib { } @@ -833,7 +926,19 @@ ldstr bytearray(48 00 69 00) .method public static string GetAnsi() cil managed { - ldstr ansi("AB") + ldstr ansi("A" + "B") + ret + } + + .method public static string GetOddAnsi() cil managed + { + ldstr ansi("A" + "BC") + ret + } + + .method public static string GetComposed() cil managed + { + ldstr "A" + "B" ret } } @@ -844,6 +949,8 @@ ldstr ansi("AB") Assert.Equal("Hi", ReadLdstrValue(pe, reader, "GetUtf16")); Assert.Equal("\u4241", ReadLdstrValue(pe, reader, "GetAnsi")); + Assert.Equal("\u4241\u0043", ReadLdstrValue(pe, reader, "GetOddAnsi")); + Assert.Equal("AB", ReadLdstrValue(pe, reader, "GetComposed")); } [Fact] @@ -929,6 +1036,30 @@ .method public static int32 M(int32 value) cil managed Assert.Equal(6, BitConverter.ToInt32(il, switchOffset + 9)); } + [Theory] + [InlineData("switch ()")] + [InlineData("switch ( )")] + public void SwitchInstruction_Empty_EmitsEmptyBranchTable(string instruction) + { + string source = $$""" + .assembly test { } + .class public auto ansi Test + { + .method public static void M() cil managed + { + {{instruction}} + ret + } + } + """; + + using var pe = DocumentCompilerTestHelpers.CompileAndGetReader(source, new Options()); + byte[] il = GetMethodIL(pe, "M"); + + Assert.Equal(0x45, il[0]); + Assert.Equal(0, BitConverter.ToInt32(il, 1)); + } + [Fact] public void LdtokenInstruction_TypeReference_EmitsTypeReferenceToken() { From 5fd435db673b81225a78ecc6e9b77be0fc84dd0e Mon Sep 17 00:00:00 2001 From: Jeremy Koritzinsky Date: Wed, 12 Aug 2026 20:29:53 -0700 Subject: [PATCH 04/16] Dispatch reference instructions from operand actions Remove the generic instruction parse-tree island and emit reference, token, type, and calli instructions directly after their operand rules. Each complex operand now retains only its own bounded subtree, preparing the type and signature rules for independent synthesis. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: c986c103-8383-4db4-9b11-9be49dc68a05 --- src/tools/ilasm/README.md | 9 +- .../GrammarActions.Instructions.Islands.cs | 119 - .../GrammarActions.Instructions.References.cs | 145 + .../Actions/GrammarActions.Instructions.cs | 3 - src/tools/ilasm/src/ILAssembler/gen/CIL.g4 | 56 +- .../ilasm/src/ILAssembler/gen/CIL.interp | 4 +- .../src/ILAssembler/gen/CILBaseVisitor.cs | 4 +- .../ilasm/src/ILAssembler/gen/CILParser.cs | 5355 +++++++++-------- .../ilasm/src/ILAssembler/gen/CILVisitor.cs | 4 +- .../ILAssembler.Tests/InstructionTests.cs | 5 + 10 files changed, 2887 insertions(+), 2817 deletions(-) delete mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.Islands.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.References.cs diff --git a/src/tools/ilasm/README.md b/src/tools/ilasm/README.md index aa4e0a854b9a65..37f3d745551e55 100644 --- a/src/tools/ilasm/README.md +++ b/src/tools/ilasm/README.md @@ -20,7 +20,7 @@ accumulator instead of building a subtree at all. | `GrammarActions.Debug.cs` | Source and debug directives. | | `GrammarActions.Declarations.cs` | Top-level `decl` dispatch and conversion. | | `GrammarActions.Instructions.cs` | Tree-free value instruction and method-item actions. | -| `GrammarActions.Instructions.Islands.cs` | Reference and signature instruction-island conversion. | +| `GrammarActions.Instructions.References.cs` | Reference and signature instruction actions. | | `GrammarActions.Literals.cs` | Literals, names and strings. | | `GrammarActions.Manifest.cs` | Assembly, module, resource, vtable and typedef directives. | | `GrammarActions.Marshalling.cs` | Native type and marshalling conversion. | @@ -37,9 +37,10 @@ accumulator instead of building a subtree at all. Parser actions in `src/ILAssembler/gen/CIL.g4` must remain thin; they call a single `Actions` method and nothing else. Compilation orchestration belongs in the `GrammarActions` partial-class files. -Value instruction forms, composed strings and switch labels run entirely with parse-tree -construction disabled. Instructions with reference or signature operands temporarily retain only -their own bounded `instructionIsland` subtree. +Instruction dispatch and value operands run entirely with parse-tree construction disabled. +Reference and signature operand roots such as `methodRef`, `fieldRef`, `mdtoken`, `typeSpec`, +`ownerType` and `calliSignature` temporarily retain only their own bounded subtrees for semantic +conversion. Semantic state that a rule pushes must be released from that rule's `finally` clause and be keyed on the owning context, because ANTLR skips `@after` actions and the remainder of an alternative once a diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.Islands.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.Islands.cs deleted file mode 100644 index 63a334f890eb63..00000000000000 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.Islands.cs +++ /dev/null @@ -1,119 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System; -using System.Collections.Immutable; -using System.Diagnostics; -using System.Linq; -using System.Reflection.Metadata; -using System.Reflection.Metadata.Ecma335; -using Antlr4.Runtime; - -namespace ILAssembler; - -internal sealed partial class GrammarActions -{ - internal void ProcessInstructionIsland(CILParser.InstructionIslandContext context) - { - if (StartInstruction(context.Start) is not { } instruction) - { - return; - } - - ILOpCode opcode = instruction.OpCode; - CurrentMethodContext method = instruction.Method; - - if (context.methodRef() is CILParser.MethodRefContext methodRef) - { - EmitMethodReferenceInstruction(method, opcode, methodRef); - } - else if (context.fieldRef() is CILParser.FieldRefContext fieldRef) - { - method.Definition.MethodBody.OpCode(opcode); - WriteInstructionToken(method, VisitFieldRef(fieldRef).Value); - } - else if (context.mdtoken() is CILParser.MdtokenContext mdtoken) - { - method.Definition.MethodBody.OpCode(opcode); - WriteInstructionToken(method, VisitMdtoken(mdtoken).Value); - } - else if (context.typeSpec() is CILParser.TypeSpecContext typeSpec) - { - method.Definition.MethodBody.OpCode(opcode); - WriteInstructionToken(method, VisitTypeSpec(typeSpec).Value); - } - else if (context.callConv() is CILParser.CallConvContext callConv) - { - EmitCalliInstruction(method, opcode, context, callConv); - } - else if (context.ownerType() is CILParser.OwnerTypeContext ownerType) - { - method.Definition.MethodBody.OpCode(opcode); - WriteInstructionToken(method, VisitOwnerType(ownerType).Value); - } - else - { - throw new UnreachableException(); - } - } - - private void EmitMethodReferenceInstruction( - CurrentMethodContext method, - ILOpCode opcode, - CILParser.MethodRefContext context) - { - bool expectInstance = opcode is ILOpCode.Callvirt or ILOpCode.Newobj; - _expectInstance = expectInstance; - try - { - method.Definition.MethodBody.OpCode(opcode); - WriteInstructionToken(method, VisitMethodRef(context).Value); - } - finally - { - if (expectInstance) - { - _expectInstance = false; - } - } - } - - private void EmitCalliInstruction( - CurrentMethodContext method, - ILOpCode opcode, - CILParser.InstructionIslandContext context, - CILParser.CallConvContext callConv) - { - Debug.Assert(opcode == ILOpCode.Calli); - BlobBuilder signature = new(); - signature.WriteByte(VisitCallConv(callConv).Value); - ImmutableArray arguments = VisitSigArgs(context.sigArgs()).Value; - signature.WriteCompressedInteger(arguments.Count(argument => !argument.IsSentinel)); - VisitType(context.type()).Value.WriteContentTo(signature); - foreach (SignatureArg argument in arguments) - { - argument.SignatureBlob.WriteContentTo(signature); - } - - method.Definition.MethodBody.OpCode(opcode); - method.Definition.MethodBody.Token(_entityRegistry.GetOrCreateStandaloneSignature(signature).Handle); - } - - private static void WriteInstructionToken(CurrentMethodContext method, EntityRegistry.EntityBase entity) - { - if (entity is EntityRegistry.TypeReferenceEntity typeReference) - { - typeReference.RecordBlobToWriteResolvedToken( - method.Definition.MethodBody.CodeBuilder.ReserveBytes(sizeof(int))); - } - else if (entity is EntityRegistry.MemberReferenceEntity memberReference) - { - memberReference.RecordBlobToWriteResolvedHandle( - method.Definition.MethodBody.CodeBuilder.ReserveBytes(sizeof(int))); - } - else - { - method.Definition.MethodBody.Token(entity.Handle); - } - } -} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.References.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.References.cs new file mode 100644 index 00000000000000..0c43210d4d1cf7 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.References.cs @@ -0,0 +1,145 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Immutable; +using System.Diagnostics; +using System.Linq; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using Antlr4.Runtime; +using Antlr4.Runtime.Tree; + +namespace ILAssembler; + +internal sealed partial class GrammarActions +{ + internal void EmitMethodReferenceInstruction(IToken opcodeToken, CILParser.MethodRefContext context) + { + if (StartInstruction(opcodeToken) is not { } instruction || ContainsSyntaxError(context)) + { + return; + } + + ILOpCode opcode = instruction.OpCode; + CurrentMethodContext method = instruction.Method; + bool expectInstance = opcode is ILOpCode.Callvirt or ILOpCode.Newobj; + _expectInstance = expectInstance; + try + { + method.Definition.MethodBody.OpCode(opcode); + WriteInstructionToken(method, VisitMethodRef(context).Value); + } + finally + { + if (expectInstance) + { + _expectInstance = false; + } + } + } + + internal void EmitFieldReferenceInstruction(IToken opcodeToken, CILParser.FieldRefContext context) + { + if (StartInstruction(opcodeToken) is not { } instruction || ContainsSyntaxError(context)) + { + return; + } + + instruction.Method.Definition.MethodBody.OpCode(instruction.OpCode); + WriteInstructionToken(instruction.Method, VisitFieldRef(context).Value); + } + + internal void EmitMetadataTokenInstruction(IToken opcodeToken, CILParser.MdtokenContext context) + { + if (StartInstruction(opcodeToken) is not { } instruction || ContainsSyntaxError(context)) + { + return; + } + + instruction.Method.Definition.MethodBody.OpCode(instruction.OpCode); + WriteInstructionToken(instruction.Method, VisitMdtoken(context).Value); + } + + internal void EmitTypeReferenceInstruction(IToken opcodeToken, CILParser.TypeSpecContext context) + { + if (StartInstruction(opcodeToken) is not { } instruction || ContainsSyntaxError(context)) + { + return; + } + + instruction.Method.Definition.MethodBody.OpCode(instruction.OpCode); + WriteInstructionToken(instruction.Method, VisitTypeSpec(context).Value); + } + + internal void EmitCalliInstruction(IToken opcodeToken, CILParser.CalliSignatureContext context) + { + if (StartInstruction(opcodeToken) is not { } instruction || ContainsSyntaxError(context)) + { + return; + } + + Debug.Assert(instruction.OpCode == ILOpCode.Calli); + BlobBuilder signature = new(); + signature.WriteByte(VisitCallConv(context.callConv()).Value); + ImmutableArray arguments = VisitSigArgs(context.sigArgs()).Value; + signature.WriteCompressedInteger(arguments.Count(argument => !argument.IsSentinel)); + VisitType(context.type()).Value.WriteContentTo(signature); + foreach (SignatureArg argument in arguments) + { + argument.SignatureBlob.WriteContentTo(signature); + } + + instruction.Method.Definition.MethodBody.OpCode(instruction.OpCode); + instruction.Method.Definition.MethodBody.Token(_entityRegistry.GetOrCreateStandaloneSignature(signature).Handle); + } + + internal void EmitOwnerTokenInstruction(IToken opcodeToken, CILParser.OwnerTypeContext context) + { + if (StartInstruction(opcodeToken) is not { } instruction || ContainsSyntaxError(context)) + { + return; + } + + instruction.Method.Definition.MethodBody.OpCode(instruction.OpCode); + WriteInstructionToken(instruction.Method, VisitOwnerType(context).Value); + } + + private static bool ContainsSyntaxError(IParseTree tree) + { + if (tree is IErrorNode or ParserRuleContext { exception: not null }) + { + return true; + } + + for (int i = 0; i < tree.ChildCount; i++) + { + if (ContainsSyntaxError(tree.GetChild(i))) + { + return true; + } + } + + return false; + } + + private static void WriteInstructionToken(CurrentMethodContext method, EntityRegistry.EntityBase entity) + { + if (entity is EntityRegistry.TypeReferenceEntity typeReference) + { + typeReference.RecordBlobToWriteResolvedToken( + method.Definition.MethodBody.CodeBuilder.ReserveBytes(sizeof(int))); + } + else if (entity is EntityRegistry.MemberReferenceEntity memberReference) + { + memberReference.RecordBlobToWriteResolvedHandle( + method.Definition.MethodBody.CodeBuilder.ReserveBytes(sizeof(int))); + } + else + { + method.Definition.MethodBody.Token(entity.Handle); + } + } + + GrammarResult ICILVisitor.VisitCalliSignature(CILParser.CalliSignatureContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs index c9cb35bb06993c..bbead890989385 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs @@ -448,9 +448,6 @@ GrammarResult ICILVisitor.VisitInstr(CILParser.InstrContext conte GrammarResult ICILVisitor.VisitSimpleInstr(CILParser.SimpleInstrContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - GrammarResult ICILVisitor.VisitInstructionIsland(CILParser.InstructionIslandContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - GrammarResult ICILVisitor.VisitMdtoken(CILParser.MdtokenContext context) => VisitMdtoken(context); public GrammarResult.Literal VisitMdtoken(CILParser.MdtokenContext context) diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 index be738cfd3031b0..3502f26b25c80c 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 @@ -535,7 +535,13 @@ customDescrWithOwner: customType: methodRef; -ownerType: typeSpec | memberRef; +ownerType +@init {BeginSubtree();} +: + typeSpec + | memberRef +; +finally {EndParseTreeMode();} /* Verbal description of custom attribute initialization blob */ customBlobDescr: customBlobArgs customBlobNVPairs; @@ -682,7 +688,13 @@ asmAttr: asmAttrAny*; /* IL instructions and associated definitions */ instr: simpleInstr - | instructionIsland; + | op = INSTR_METHOD methodOperand = methodRef {Actions.EmitMethodReferenceInstruction($op, $methodOperand.ctx);} + | op = INSTR_FIELD fieldOperand = fieldRef {Actions.EmitFieldReferenceInstruction($op, $fieldOperand.ctx);} + | op = INSTR_FIELD metadataOperand = mdtoken {Actions.EmitMetadataTokenInstruction($op, $metadataOperand.ctx);} + | op = INSTR_TYPE typeOperand = typeSpec {Actions.EmitTypeReferenceInstruction($op, $typeOperand.ctx);} + | op = INSTR_SIG signatureOperand = calliSignature {Actions.EmitCalliInstruction($op, $signatureOperand.ctx);} + | op = INSTR_TOK ownerOperand = ownerType {Actions.EmitOwnerTokenInstruction($op, $ownerOperand.ctx);} +; simpleInstr @after {Actions.CompleteSimpleInstruction(_localctx);} @@ -706,16 +718,10 @@ simpleInstr ; finally {Actions.EndSwitchInstruction(_localctx);} -instructionIsland +calliSignature @init {BeginSubtree();} -@after {Actions.ProcessInstructionIsland(_localctx);} : - INSTR_METHOD methodRef - | INSTR_FIELD fieldRef - | INSTR_FIELD mdtoken - | INSTR_TYPE typeSpec - | INSTR_SIG callConv type sigArgs - | INSTR_TOK ownerType /* ownerType ::= memberRef | typeSpec */ + callConv type sigArgs ; finally {EndParseTreeMode();} @@ -753,11 +759,15 @@ assemblyDecls: assemblyDecl*; assemblyDecl: (HASH 'algorithm' int32) | secDecl | asmOrRefDecl; -typeSpec: +typeSpec +@init {BeginSubtree();} +: className | '[' dottedName ']' | '[' MODULE dottedName ']' - | type; + | type +; +finally {EndParseTreeMode();} /* Native types for marshaling signatures */ nativeType: @@ -985,13 +995,17 @@ secAction: | 'noncasinheritance'; /* Method referencing */ -methodRef: +methodRef +@init {BeginSubtree();} +: callConv type typeSpec '::' methodName typeArgs? sigArgs | callConv type typeSpec '::' methodName genArityNotEmpty sigArgs | callConv type methodName typeArgs? sigArgs | callConv type methodName genArityNotEmpty sigArgs | mdtoken - | dottedName /* typeDef */; + | dottedName /* typeDef */ +; +finally {EndParseTreeMode();} callConv: INSTANCE callConv @@ -1009,18 +1023,26 @@ callKind: | UNMANAGED FASTCALL | UNMANAGED; -mdtoken: 'mdtoken' '(' int32 ')'; +mdtoken +@init {BeginSubtree();} +: + 'mdtoken' '(' int32 ')' +; +finally {EndParseTreeMode();} memberRef: 'method' methodRef | 'field' fieldRef | mdtoken; -fieldRef: +fieldRef +@init {BeginSubtree();} +: type typeSpec '::' dottedName | type dottedName | dottedName // typedef - ; +; +finally {EndParseTreeMode();} /* Generic type parameters declaration */ typeList: (typeSpec ',')* typeSpec; diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.interp b/src/tools/ilasm/src/ILAssembler/gen/CIL.interp index 6c8b4ed14c940c..27aea6d5119aaa 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.interp +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.interp @@ -667,7 +667,7 @@ asmAttrAny asmAttr instr simpleInstr -instructionIsland +calliSignature labels typeArgs bounds @@ -793,4 +793,4 @@ manifestResDecl atn: -[4, 1, 305, 2907, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 357, 8, 1, 10, 1, 12, 1, 360, 9, 1, 1, 1, 1, 1, 3, 1, 364, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 5, 3, 371, 8, 3, 10, 3, 12, 3, 374, 9, 3, 1, 3, 1, 3, 1, 3, 1, 4, 5, 4, 380, 8, 4, 10, 4, 12, 4, 383, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 435, 8, 5, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 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, 476, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 5, 15, 483, 8, 15, 10, 15, 12, 15, 486, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 515, 8, 18, 1, 19, 1, 19, 3, 19, 519, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 537, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 564, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 587, 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, 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, 623, 8, 23, 1, 24, 1, 24, 1, 25, 1, 25, 3, 25, 629, 8, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 5, 27, 636, 8, 27, 10, 27, 12, 27, 639, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 648, 8, 28, 10, 28, 12, 28, 651, 9, 28, 1, 29, 1, 29, 1, 30, 1, 30, 3, 30, 657, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 668, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 676, 8, 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, 34, 1, 34, 1, 34, 1, 34, 5, 34, 697, 8, 34, 10, 34, 12, 34, 700, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 5, 37, 713, 8, 37, 10, 37, 12, 37, 716, 9, 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, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 760, 8, 38, 1, 39, 1, 39, 1, 39, 3, 39, 765, 8, 39, 1, 40, 1, 40, 1, 40, 3, 40, 770, 8, 40, 1, 41, 5, 41, 773, 8, 41, 10, 41, 12, 41, 776, 9, 41, 1, 42, 1, 42, 1, 42, 5, 42, 781, 8, 42, 10, 42, 12, 42, 784, 9, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 893, 8, 44, 1, 45, 1, 45, 5, 45, 897, 8, 45, 10, 45, 12, 45, 900, 9, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 913, 8, 45, 10, 45, 12, 45, 916, 9, 45, 1, 45, 1, 45, 1, 45, 3, 45, 921, 8, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 927, 8, 47, 1, 48, 1, 48, 1, 49, 5, 49, 932, 8, 49, 10, 49, 12, 49, 935, 9, 49, 1, 50, 1, 50, 3, 50, 939, 8, 50, 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, 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, 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, 1017, 8, 51, 3, 51, 1019, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 1036, 8, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1045, 8, 53, 1, 53, 1, 53, 5, 53, 1049, 8, 53, 10, 53, 12, 53, 1052, 9, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1060, 8, 53, 3, 53, 1062, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1068, 8, 54, 10, 54, 12, 54, 1071, 9, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1080, 8, 55, 10, 55, 12, 55, 1083, 9, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 5, 56, 1092, 8, 56, 10, 56, 12, 56, 1095, 9, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1101, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 1108, 8, 57, 3, 57, 1110, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1137, 8, 58, 1, 59, 1, 59, 1, 59, 5, 59, 1142, 8, 59, 10, 59, 12, 59, 1145, 9, 59, 1, 59, 1, 59, 1, 60, 5, 60, 1150, 8, 60, 10, 60, 12, 60, 1153, 9, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1160, 8, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 3, 62, 1173, 8, 62, 1, 63, 1, 63, 1, 63, 5, 63, 1178, 8, 63, 10, 63, 12, 63, 1181, 9, 63, 3, 63, 1183, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 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, 1202, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1296, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1305, 8, 66, 1, 67, 1, 67, 1, 67, 5, 67, 1310, 8, 67, 10, 67, 12, 67, 1313, 9, 67, 3, 67, 1315, 8, 67, 1, 68, 1, 68, 1, 69, 1, 69, 5, 69, 1321, 8, 69, 10, 69, 12, 69, 1324, 9, 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, 1, 70, 1, 70, 1, 70, 3, 70, 1344, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1376, 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, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1399, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1411, 8, 73, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1420, 8, 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, 3, 76, 1445, 8, 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, 1469, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 5, 77, 1475, 8, 77, 10, 77, 12, 77, 1478, 9, 77, 1, 77, 3, 77, 1481, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1496, 8, 78, 1, 79, 1, 79, 1, 79, 5, 79, 1501, 8, 79, 10, 79, 12, 79, 1504, 9, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1548, 8, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1558, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1574, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1586, 8, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1598, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1612, 8, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 1624, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1635, 8, 89, 1, 90, 1, 90, 1, 90, 5, 90, 1640, 8, 90, 10, 90, 12, 90, 1643, 9, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 1652, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 1665, 8, 92, 1, 93, 5, 93, 1668, 8, 93, 10, 93, 12, 93, 1671, 9, 93, 1, 94, 1, 94, 3, 94, 1675, 8, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 5, 95, 1682, 8, 95, 10, 95, 12, 95, 1685, 9, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 3, 97, 1695, 8, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1776, 8, 99, 10, 99, 12, 99, 1779, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1785, 8, 99, 10, 99, 12, 99, 1788, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1798, 8, 99, 10, 99, 12, 99, 1801, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1809, 8, 99, 10, 99, 12, 99, 1812, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 1819, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 1829, 8, 100, 10, 100, 12, 100, 1832, 9, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 1858, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 1865, 8, 102, 1, 103, 1, 103, 1, 103, 3, 103, 1870, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 1877, 8, 104, 1, 105, 1, 105, 5, 105, 1881, 8, 105, 10, 105, 12, 105, 1884, 9, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 1891, 8, 105, 10, 105, 12, 105, 1894, 9, 105, 1, 105, 3, 105, 1897, 8, 105, 1, 106, 1, 106, 1, 107, 5, 107, 1902, 8, 107, 10, 107, 12, 107, 1905, 9, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 1919, 8, 108, 1, 109, 1, 109, 5, 109, 1923, 8, 109, 10, 109, 12, 109, 1926, 9, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 111, 5, 111, 1937, 8, 111, 10, 111, 12, 111, 1940, 9, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 1952, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 1960, 8, 113, 1, 114, 1, 114, 1, 114, 4, 114, 1965, 8, 114, 11, 114, 12, 114, 1966, 1, 114, 1, 114, 3, 114, 1971, 8, 114, 1, 115, 5, 115, 1974, 8, 115, 10, 115, 12, 115, 1977, 9, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 1992, 8, 116, 1, 117, 1, 117, 1, 117, 5, 117, 1997, 8, 117, 10, 117, 12, 117, 2000, 9, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2010, 8, 117, 10, 117, 12, 117, 2013, 9, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2038, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2045, 8, 119, 3, 119, 2047, 8, 119, 1, 119, 5, 119, 2050, 8, 119, 10, 119, 12, 119, 2053, 9, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2058, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2087, 8, 120, 1, 121, 1, 121, 1, 121, 3, 121, 2092, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2115, 8, 122, 1, 123, 5, 123, 2118, 8, 123, 10, 123, 12, 123, 2121, 9, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2140, 8, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2191, 8, 125, 10, 125, 12, 125, 2194, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2200, 8, 125, 10, 125, 12, 125, 2203, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2213, 8, 125, 10, 125, 12, 125, 2216, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2224, 8, 125, 10, 125, 12, 125, 2227, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2235, 8, 125, 10, 125, 12, 125, 2238, 9, 125, 3, 125, 2240, 8, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 3, 127, 2248, 8, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 130, 4, 130, 2258, 8, 130, 11, 130, 12, 130, 2259, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 2274, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 3, 132, 2288, 8, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 2296, 8, 133, 1, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 2316, 8, 137, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 2328, 8, 139, 1, 140, 1, 140, 1, 140, 3, 140, 2333, 8, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 4, 141, 2340, 8, 141, 11, 141, 12, 141, 2341, 3, 141, 2344, 8, 141, 1, 142, 1, 142, 1, 142, 5, 142, 2349, 8, 142, 10, 142, 12, 142, 2352, 9, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 2361, 8, 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, 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, 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, 2429, 8, 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, 145, 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, 145, 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, 145, 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, 145, 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, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 3, 145, 2506, 8, 145, 1, 146, 1, 146, 1, 146, 5, 146, 2511, 8, 146, 10, 146, 12, 146, 2514, 9, 146, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 3, 148, 2521, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 2671, 8, 149, 1, 150, 1, 150, 5, 150, 2675, 8, 150, 10, 150, 12, 150, 2678, 9, 150, 1, 151, 1, 151, 5, 151, 2682, 8, 151, 10, 151, 12, 151, 2685, 9, 151, 1, 152, 5, 152, 2688, 8, 152, 10, 152, 12, 152, 2691, 9, 152, 1, 153, 5, 153, 2694, 8, 153, 10, 153, 12, 153, 2697, 9, 153, 1, 154, 5, 154, 2700, 8, 154, 10, 154, 12, 154, 2703, 9, 154, 1, 155, 5, 155, 2706, 8, 155, 10, 155, 12, 155, 2709, 9, 155, 1, 156, 5, 156, 2712, 8, 156, 10, 156, 12, 156, 2715, 9, 156, 1, 157, 5, 157, 2718, 8, 157, 10, 157, 12, 157, 2721, 9, 157, 1, 158, 5, 158, 2724, 8, 158, 10, 158, 12, 158, 2727, 9, 158, 1, 159, 1, 159, 1, 159, 1, 159, 3, 159, 2733, 8, 159, 1, 160, 5, 160, 2736, 8, 160, 10, 160, 12, 160, 2739, 9, 160, 1, 161, 1, 161, 1, 161, 3, 161, 2744, 8, 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, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 3, 162, 2771, 8, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 2785, 8, 163, 1, 164, 5, 164, 2788, 8, 164, 10, 164, 12, 164, 2791, 9, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 3, 165, 2807, 8, 165, 1, 166, 1, 166, 1, 166, 5, 166, 2812, 8, 166, 10, 166, 12, 166, 2815, 9, 166, 1, 166, 1, 166, 1, 167, 1, 167, 5, 167, 2821, 8, 167, 10, 167, 12, 167, 2824, 9, 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, 168, 1, 168, 1, 168, 1, 168, 3, 168, 2843, 8, 168, 1, 169, 5, 169, 2846, 8, 169, 10, 169, 12, 169, 2849, 9, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 2864, 8, 170, 1, 171, 1, 171, 5, 171, 2868, 8, 171, 10, 171, 12, 171, 2871, 9, 171, 1, 171, 1, 171, 1, 171, 5, 171, 2876, 8, 171, 10, 171, 12, 171, 2879, 9, 171, 1, 171, 1, 171, 1, 171, 1, 171, 3, 171, 2885, 8, 171, 1, 172, 1, 172, 1, 173, 5, 173, 2890, 8, 173, 10, 173, 12, 173, 2893, 9, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 2905, 8, 174, 1, 174, 0, 1, 68, 175, 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, 0, 16, 6, 0, 1, 15, 199, 199, 243, 243, 247, 247, 264, 264, 289, 289, 5, 0, 16, 16, 199, 199, 243, 243, 264, 264, 288, 289, 1, 0, 263, 264, 1, 0, 173, 174, 1, 0, 37, 38, 1, 0, 73, 74, 3, 0, 2, 2, 61, 61, 77, 83, 2, 0, 229, 229, 260, 261, 9, 0, 178, 178, 183, 195, 201, 201, 207, 208, 210, 215, 218, 219, 222, 222, 230, 242, 262, 262, 1, 0, 95, 96, 1, 0, 97, 111, 1, 0, 68, 69, 2, 0, 173, 173, 289, 290, 2, 0, 179, 179, 264, 264, 1, 0, 167, 168, 1, 0, 51, 52, 3334, 0, 350, 1, 0, 0, 0, 2, 363, 1, 0, 0, 0, 4, 365, 1, 0, 0, 0, 6, 372, 1, 0, 0, 0, 8, 381, 1, 0, 0, 0, 10, 434, 1, 0, 0, 0, 12, 436, 1, 0, 0, 0, 14, 439, 1, 0, 0, 0, 16, 442, 1, 0, 0, 0, 18, 446, 1, 0, 0, 0, 20, 449, 1, 0, 0, 0, 22, 452, 1, 0, 0, 0, 24, 459, 1, 0, 0, 0, 26, 475, 1, 0, 0, 0, 28, 477, 1, 0, 0, 0, 30, 479, 1, 0, 0, 0, 32, 489, 1, 0, 0, 0, 34, 491, 1, 0, 0, 0, 36, 514, 1, 0, 0, 0, 38, 518, 1, 0, 0, 0, 40, 536, 1, 0, 0, 0, 42, 563, 1, 0, 0, 0, 44, 586, 1, 0, 0, 0, 46, 622, 1, 0, 0, 0, 48, 624, 1, 0, 0, 0, 50, 628, 1, 0, 0, 0, 52, 630, 1, 0, 0, 0, 54, 637, 1, 0, 0, 0, 56, 649, 1, 0, 0, 0, 58, 652, 1, 0, 0, 0, 60, 654, 1, 0, 0, 0, 62, 667, 1, 0, 0, 0, 64, 675, 1, 0, 0, 0, 66, 677, 1, 0, 0, 0, 68, 685, 1, 0, 0, 0, 70, 701, 1, 0, 0, 0, 72, 707, 1, 0, 0, 0, 74, 710, 1, 0, 0, 0, 76, 759, 1, 0, 0, 0, 78, 764, 1, 0, 0, 0, 80, 769, 1, 0, 0, 0, 82, 774, 1, 0, 0, 0, 84, 782, 1, 0, 0, 0, 86, 787, 1, 0, 0, 0, 88, 892, 1, 0, 0, 0, 90, 920, 1, 0, 0, 0, 92, 922, 1, 0, 0, 0, 94, 926, 1, 0, 0, 0, 96, 928, 1, 0, 0, 0, 98, 933, 1, 0, 0, 0, 100, 938, 1, 0, 0, 0, 102, 1018, 1, 0, 0, 0, 104, 1035, 1, 0, 0, 0, 106, 1061, 1, 0, 0, 0, 108, 1063, 1, 0, 0, 0, 110, 1075, 1, 0, 0, 0, 112, 1100, 1, 0, 0, 0, 114, 1109, 1, 0, 0, 0, 116, 1136, 1, 0, 0, 0, 118, 1143, 1, 0, 0, 0, 120, 1151, 1, 0, 0, 0, 122, 1159, 1, 0, 0, 0, 124, 1172, 1, 0, 0, 0, 126, 1182, 1, 0, 0, 0, 128, 1201, 1, 0, 0, 0, 130, 1295, 1, 0, 0, 0, 132, 1304, 1, 0, 0, 0, 134, 1314, 1, 0, 0, 0, 136, 1316, 1, 0, 0, 0, 138, 1318, 1, 0, 0, 0, 140, 1343, 1, 0, 0, 0, 142, 1375, 1, 0, 0, 0, 144, 1398, 1, 0, 0, 0, 146, 1410, 1, 0, 0, 0, 148, 1412, 1, 0, 0, 0, 150, 1415, 1, 0, 0, 0, 152, 1468, 1, 0, 0, 0, 154, 1480, 1, 0, 0, 0, 156, 1495, 1, 0, 0, 0, 158, 1502, 1, 0, 0, 0, 160, 1507, 1, 0, 0, 0, 162, 1511, 1, 0, 0, 0, 164, 1547, 1, 0, 0, 0, 166, 1549, 1, 0, 0, 0, 168, 1585, 1, 0, 0, 0, 170, 1597, 1, 0, 0, 0, 172, 1611, 1, 0, 0, 0, 174, 1613, 1, 0, 0, 0, 176, 1623, 1, 0, 0, 0, 178, 1634, 1, 0, 0, 0, 180, 1641, 1, 0, 0, 0, 182, 1651, 1, 0, 0, 0, 184, 1664, 1, 0, 0, 0, 186, 1669, 1, 0, 0, 0, 188, 1672, 1, 0, 0, 0, 190, 1683, 1, 0, 0, 0, 192, 1688, 1, 0, 0, 0, 194, 1694, 1, 0, 0, 0, 196, 1696, 1, 0, 0, 0, 198, 1818, 1, 0, 0, 0, 200, 1820, 1, 0, 0, 0, 202, 1857, 1, 0, 0, 0, 204, 1864, 1, 0, 0, 0, 206, 1869, 1, 0, 0, 0, 208, 1876, 1, 0, 0, 0, 210, 1896, 1, 0, 0, 0, 212, 1898, 1, 0, 0, 0, 214, 1903, 1, 0, 0, 0, 216, 1918, 1, 0, 0, 0, 218, 1920, 1, 0, 0, 0, 220, 1933, 1, 0, 0, 0, 222, 1938, 1, 0, 0, 0, 224, 1951, 1, 0, 0, 0, 226, 1959, 1, 0, 0, 0, 228, 1970, 1, 0, 0, 0, 230, 1975, 1, 0, 0, 0, 232, 1991, 1, 0, 0, 0, 234, 1993, 1, 0, 0, 0, 236, 2037, 1, 0, 0, 0, 238, 2057, 1, 0, 0, 0, 240, 2086, 1, 0, 0, 0, 242, 2091, 1, 0, 0, 0, 244, 2114, 1, 0, 0, 0, 246, 2119, 1, 0, 0, 0, 248, 2139, 1, 0, 0, 0, 250, 2239, 1, 0, 0, 0, 252, 2241, 1, 0, 0, 0, 254, 2247, 1, 0, 0, 0, 256, 2249, 1, 0, 0, 0, 258, 2253, 1, 0, 0, 0, 260, 2257, 1, 0, 0, 0, 262, 2273, 1, 0, 0, 0, 264, 2287, 1, 0, 0, 0, 266, 2295, 1, 0, 0, 0, 268, 2297, 1, 0, 0, 0, 270, 2300, 1, 0, 0, 0, 272, 2302, 1, 0, 0, 0, 274, 2315, 1, 0, 0, 0, 276, 2317, 1, 0, 0, 0, 278, 2327, 1, 0, 0, 0, 280, 2332, 1, 0, 0, 0, 282, 2343, 1, 0, 0, 0, 284, 2350, 1, 0, 0, 0, 286, 2360, 1, 0, 0, 0, 288, 2428, 1, 0, 0, 0, 290, 2505, 1, 0, 0, 0, 292, 2512, 1, 0, 0, 0, 294, 2515, 1, 0, 0, 0, 296, 2520, 1, 0, 0, 0, 298, 2670, 1, 0, 0, 0, 300, 2676, 1, 0, 0, 0, 302, 2683, 1, 0, 0, 0, 304, 2689, 1, 0, 0, 0, 306, 2695, 1, 0, 0, 0, 308, 2701, 1, 0, 0, 0, 310, 2707, 1, 0, 0, 0, 312, 2713, 1, 0, 0, 0, 314, 2719, 1, 0, 0, 0, 316, 2725, 1, 0, 0, 0, 318, 2732, 1, 0, 0, 0, 320, 2737, 1, 0, 0, 0, 322, 2743, 1, 0, 0, 0, 324, 2770, 1, 0, 0, 0, 326, 2784, 1, 0, 0, 0, 328, 2789, 1, 0, 0, 0, 330, 2806, 1, 0, 0, 0, 332, 2808, 1, 0, 0, 0, 334, 2818, 1, 0, 0, 0, 336, 2842, 1, 0, 0, 0, 338, 2847, 1, 0, 0, 0, 340, 2863, 1, 0, 0, 0, 342, 2884, 1, 0, 0, 0, 344, 2886, 1, 0, 0, 0, 346, 2891, 1, 0, 0, 0, 348, 2904, 1, 0, 0, 0, 350, 351, 7, 0, 0, 0, 351, 1, 1, 0, 0, 0, 352, 364, 5, 288, 0, 0, 353, 354, 3, 4, 2, 0, 354, 355, 5, 265, 0, 0, 355, 357, 1, 0, 0, 0, 356, 353, 1, 0, 0, 0, 357, 360, 1, 0, 0, 0, 358, 356, 1, 0, 0, 0, 358, 359, 1, 0, 0, 0, 359, 361, 1, 0, 0, 0, 360, 358, 1, 0, 0, 0, 361, 364, 3, 4, 2, 0, 362, 364, 5, 264, 0, 0, 363, 352, 1, 0, 0, 0, 363, 358, 1, 0, 0, 0, 363, 362, 1, 0, 0, 0, 364, 3, 1, 0, 0, 0, 365, 366, 7, 1, 0, 0, 366, 5, 1, 0, 0, 0, 367, 368, 5, 263, 0, 0, 368, 369, 6, 3, -1, 0, 369, 371, 5, 266, 0, 0, 370, 367, 1, 0, 0, 0, 371, 374, 1, 0, 0, 0, 372, 370, 1, 0, 0, 0, 372, 373, 1, 0, 0, 0, 373, 375, 1, 0, 0, 0, 374, 372, 1, 0, 0, 0, 375, 376, 5, 263, 0, 0, 376, 377, 6, 3, -1, 0, 377, 7, 1, 0, 0, 0, 378, 380, 3, 10, 5, 0, 379, 378, 1, 0, 0, 0, 380, 383, 1, 0, 0, 0, 381, 379, 1, 0, 0, 0, 381, 382, 1, 0, 0, 0, 382, 9, 1, 0, 0, 0, 383, 381, 1, 0, 0, 0, 384, 385, 3, 74, 37, 0, 385, 386, 5, 17, 0, 0, 386, 387, 3, 82, 41, 0, 387, 388, 5, 18, 0, 0, 388, 435, 1, 0, 0, 0, 389, 390, 3, 72, 36, 0, 390, 391, 5, 17, 0, 0, 391, 392, 3, 8, 4, 0, 392, 393, 5, 18, 0, 0, 393, 435, 1, 0, 0, 0, 394, 395, 3, 234, 117, 0, 395, 396, 5, 17, 0, 0, 396, 397, 3, 246, 123, 0, 397, 398, 5, 18, 0, 0, 398, 435, 1, 0, 0, 0, 399, 435, 3, 200, 100, 0, 400, 435, 3, 276, 138, 0, 401, 435, 3, 70, 35, 0, 402, 435, 3, 66, 33, 0, 403, 435, 3, 88, 44, 0, 404, 435, 3, 90, 45, 0, 405, 435, 3, 22, 11, 0, 406, 407, 3, 326, 163, 0, 407, 408, 5, 17, 0, 0, 408, 409, 3, 328, 164, 0, 409, 410, 5, 18, 0, 0, 410, 435, 1, 0, 0, 0, 411, 412, 3, 332, 166, 0, 412, 413, 5, 17, 0, 0, 413, 414, 3, 338, 169, 0, 414, 415, 5, 18, 0, 0, 415, 435, 1, 0, 0, 0, 416, 417, 3, 342, 171, 0, 417, 418, 5, 17, 0, 0, 418, 419, 3, 346, 173, 0, 419, 420, 5, 18, 0, 0, 420, 435, 1, 0, 0, 0, 421, 435, 3, 64, 32, 0, 422, 435, 3, 152, 76, 0, 423, 435, 3, 322, 161, 0, 424, 435, 3, 12, 6, 0, 425, 435, 3, 14, 7, 0, 426, 435, 3, 16, 8, 0, 427, 435, 3, 18, 9, 0, 428, 435, 3, 20, 10, 0, 429, 435, 3, 26, 13, 0, 430, 435, 3, 42, 21, 0, 431, 435, 3, 40, 20, 0, 432, 435, 3, 30, 15, 0, 433, 435, 3, 24, 12, 0, 434, 384, 1, 0, 0, 0, 434, 389, 1, 0, 0, 0, 434, 394, 1, 0, 0, 0, 434, 399, 1, 0, 0, 0, 434, 400, 1, 0, 0, 0, 434, 401, 1, 0, 0, 0, 434, 402, 1, 0, 0, 0, 434, 403, 1, 0, 0, 0, 434, 404, 1, 0, 0, 0, 434, 405, 1, 0, 0, 0, 434, 406, 1, 0, 0, 0, 434, 411, 1, 0, 0, 0, 434, 416, 1, 0, 0, 0, 434, 421, 1, 0, 0, 0, 434, 422, 1, 0, 0, 0, 434, 423, 1, 0, 0, 0, 434, 424, 1, 0, 0, 0, 434, 425, 1, 0, 0, 0, 434, 426, 1, 0, 0, 0, 434, 427, 1, 0, 0, 0, 434, 428, 1, 0, 0, 0, 434, 429, 1, 0, 0, 0, 434, 430, 1, 0, 0, 0, 434, 431, 1, 0, 0, 0, 434, 432, 1, 0, 0, 0, 434, 433, 1, 0, 0, 0, 435, 11, 1, 0, 0, 0, 436, 437, 5, 19, 0, 0, 437, 438, 3, 32, 16, 0, 438, 13, 1, 0, 0, 0, 439, 440, 5, 20, 0, 0, 440, 441, 3, 32, 16, 0, 441, 15, 1, 0, 0, 0, 442, 443, 5, 21, 0, 0, 443, 444, 5, 22, 0, 0, 444, 445, 3, 32, 16, 0, 445, 17, 1, 0, 0, 0, 446, 447, 5, 23, 0, 0, 447, 448, 3, 34, 17, 0, 448, 19, 1, 0, 0, 0, 449, 450, 5, 24, 0, 0, 450, 451, 3, 34, 17, 0, 451, 21, 1, 0, 0, 0, 452, 453, 5, 25, 0, 0, 453, 454, 3, 98, 49, 0, 454, 455, 3, 2, 1, 0, 455, 456, 5, 17, 0, 0, 456, 457, 3, 120, 60, 0, 457, 458, 5, 18, 0, 0, 458, 23, 1, 0, 0, 0, 459, 460, 5, 26, 0, 0, 460, 25, 1, 0, 0, 0, 461, 462, 5, 27, 0, 0, 462, 476, 3, 28, 14, 0, 463, 464, 5, 27, 0, 0, 464, 465, 3, 28, 14, 0, 465, 466, 5, 28, 0, 0, 466, 467, 3, 28, 14, 0, 467, 476, 1, 0, 0, 0, 468, 469, 5, 27, 0, 0, 469, 470, 3, 28, 14, 0, 470, 471, 5, 28, 0, 0, 471, 472, 3, 28, 14, 0, 472, 473, 5, 28, 0, 0, 473, 474, 3, 28, 14, 0, 474, 476, 1, 0, 0, 0, 475, 461, 1, 0, 0, 0, 475, 463, 1, 0, 0, 0, 475, 468, 1, 0, 0, 0, 476, 27, 1, 0, 0, 0, 477, 478, 7, 2, 0, 0, 478, 29, 1, 0, 0, 0, 479, 480, 5, 29, 0, 0, 480, 484, 5, 17, 0, 0, 481, 483, 3, 116, 58, 0, 482, 481, 1, 0, 0, 0, 483, 486, 1, 0, 0, 0, 484, 482, 1, 0, 0, 0, 484, 485, 1, 0, 0, 0, 485, 487, 1, 0, 0, 0, 486, 484, 1, 0, 0, 0, 487, 488, 5, 18, 0, 0, 488, 31, 1, 0, 0, 0, 489, 490, 5, 173, 0, 0, 490, 33, 1, 0, 0, 0, 491, 492, 7, 3, 0, 0, 492, 35, 1, 0, 0, 0, 493, 494, 5, 175, 0, 0, 494, 515, 6, 18, -1, 0, 495, 496, 3, 32, 16, 0, 496, 497, 5, 265, 0, 0, 497, 498, 6, 18, -1, 0, 498, 515, 1, 0, 0, 0, 499, 500, 3, 32, 16, 0, 500, 501, 6, 18, -1, 0, 501, 515, 1, 0, 0, 0, 502, 503, 5, 188, 0, 0, 503, 504, 5, 30, 0, 0, 504, 505, 3, 32, 16, 0, 505, 506, 5, 31, 0, 0, 506, 507, 6, 18, -1, 0, 507, 515, 1, 0, 0, 0, 508, 509, 5, 189, 0, 0, 509, 510, 5, 30, 0, 0, 510, 511, 3, 34, 17, 0, 511, 512, 5, 31, 0, 0, 512, 513, 6, 18, -1, 0, 513, 515, 1, 0, 0, 0, 514, 493, 1, 0, 0, 0, 514, 495, 1, 0, 0, 0, 514, 499, 1, 0, 0, 0, 514, 502, 1, 0, 0, 0, 514, 508, 1, 0, 0, 0, 515, 37, 1, 0, 0, 0, 516, 519, 3, 32, 16, 0, 517, 519, 5, 262, 0, 0, 518, 516, 1, 0, 0, 0, 518, 517, 1, 0, 0, 0, 519, 39, 1, 0, 0, 0, 520, 521, 5, 267, 0, 0, 521, 537, 5, 289, 0, 0, 522, 523, 5, 267, 0, 0, 523, 524, 5, 289, 0, 0, 524, 537, 5, 263, 0, 0, 525, 526, 5, 268, 0, 0, 526, 537, 5, 289, 0, 0, 527, 528, 5, 269, 0, 0, 528, 537, 5, 289, 0, 0, 529, 530, 5, 270, 0, 0, 530, 537, 5, 289, 0, 0, 531, 537, 5, 271, 0, 0, 532, 537, 5, 272, 0, 0, 533, 534, 5, 273, 0, 0, 534, 537, 5, 263, 0, 0, 535, 537, 5, 32, 0, 0, 536, 520, 1, 0, 0, 0, 536, 522, 1, 0, 0, 0, 536, 525, 1, 0, 0, 0, 536, 527, 1, 0, 0, 0, 536, 529, 1, 0, 0, 0, 536, 531, 1, 0, 0, 0, 536, 532, 1, 0, 0, 0, 536, 533, 1, 0, 0, 0, 536, 535, 1, 0, 0, 0, 537, 41, 1, 0, 0, 0, 538, 539, 5, 33, 0, 0, 539, 540, 3, 138, 69, 0, 540, 541, 5, 34, 0, 0, 541, 542, 3, 2, 1, 0, 542, 564, 1, 0, 0, 0, 543, 544, 5, 33, 0, 0, 544, 545, 3, 116, 58, 0, 545, 546, 5, 34, 0, 0, 546, 547, 3, 2, 1, 0, 547, 564, 1, 0, 0, 0, 548, 549, 5, 33, 0, 0, 549, 550, 3, 176, 88, 0, 550, 551, 5, 34, 0, 0, 551, 552, 3, 2, 1, 0, 552, 564, 1, 0, 0, 0, 553, 554, 5, 33, 0, 0, 554, 555, 3, 44, 22, 0, 555, 556, 5, 34, 0, 0, 556, 557, 3, 2, 1, 0, 557, 564, 1, 0, 0, 0, 558, 559, 5, 33, 0, 0, 559, 560, 3, 46, 23, 0, 560, 561, 5, 34, 0, 0, 561, 562, 3, 2, 1, 0, 562, 564, 1, 0, 0, 0, 563, 538, 1, 0, 0, 0, 563, 543, 1, 0, 0, 0, 563, 548, 1, 0, 0, 0, 563, 553, 1, 0, 0, 0, 563, 558, 1, 0, 0, 0, 564, 43, 1, 0, 0, 0, 565, 566, 5, 35, 0, 0, 566, 587, 3, 48, 24, 0, 567, 568, 5, 35, 0, 0, 568, 569, 3, 48, 24, 0, 569, 570, 5, 36, 0, 0, 570, 571, 3, 6, 3, 0, 571, 587, 1, 0, 0, 0, 572, 573, 5, 35, 0, 0, 573, 574, 3, 48, 24, 0, 574, 575, 5, 36, 0, 0, 575, 576, 5, 17, 0, 0, 576, 577, 3, 52, 26, 0, 577, 578, 5, 18, 0, 0, 578, 587, 1, 0, 0, 0, 579, 580, 5, 35, 0, 0, 580, 581, 3, 48, 24, 0, 581, 582, 5, 36, 0, 0, 582, 583, 5, 30, 0, 0, 583, 584, 3, 292, 146, 0, 584, 585, 5, 31, 0, 0, 585, 587, 1, 0, 0, 0, 586, 565, 1, 0, 0, 0, 586, 567, 1, 0, 0, 0, 586, 572, 1, 0, 0, 0, 586, 579, 1, 0, 0, 0, 587, 45, 1, 0, 0, 0, 588, 589, 5, 35, 0, 0, 589, 590, 5, 30, 0, 0, 590, 591, 3, 50, 25, 0, 591, 592, 5, 31, 0, 0, 592, 593, 3, 48, 24, 0, 593, 623, 1, 0, 0, 0, 594, 595, 5, 35, 0, 0, 595, 596, 5, 30, 0, 0, 596, 597, 3, 50, 25, 0, 597, 598, 5, 31, 0, 0, 598, 599, 3, 48, 24, 0, 599, 600, 5, 36, 0, 0, 600, 601, 3, 6, 3, 0, 601, 623, 1, 0, 0, 0, 602, 603, 5, 35, 0, 0, 603, 604, 5, 30, 0, 0, 604, 605, 3, 50, 25, 0, 605, 606, 5, 31, 0, 0, 606, 607, 3, 48, 24, 0, 607, 608, 5, 36, 0, 0, 608, 609, 5, 17, 0, 0, 609, 610, 3, 52, 26, 0, 610, 611, 5, 18, 0, 0, 611, 623, 1, 0, 0, 0, 612, 613, 5, 35, 0, 0, 613, 614, 5, 30, 0, 0, 614, 615, 3, 50, 25, 0, 615, 616, 5, 31, 0, 0, 616, 617, 3, 48, 24, 0, 617, 618, 5, 36, 0, 0, 618, 619, 5, 30, 0, 0, 619, 620, 3, 292, 146, 0, 620, 621, 5, 31, 0, 0, 621, 623, 1, 0, 0, 0, 622, 588, 1, 0, 0, 0, 622, 594, 1, 0, 0, 0, 622, 602, 1, 0, 0, 0, 622, 612, 1, 0, 0, 0, 623, 47, 1, 0, 0, 0, 624, 625, 3, 168, 84, 0, 625, 49, 1, 0, 0, 0, 626, 629, 3, 124, 62, 0, 627, 629, 3, 176, 88, 0, 628, 626, 1, 0, 0, 0, 628, 627, 1, 0, 0, 0, 629, 51, 1, 0, 0, 0, 630, 631, 3, 54, 27, 0, 631, 632, 3, 56, 28, 0, 632, 53, 1, 0, 0, 0, 633, 636, 3, 298, 149, 0, 634, 636, 3, 40, 20, 0, 635, 633, 1, 0, 0, 0, 635, 634, 1, 0, 0, 0, 636, 639, 1, 0, 0, 0, 637, 635, 1, 0, 0, 0, 637, 638, 1, 0, 0, 0, 638, 55, 1, 0, 0, 0, 639, 637, 1, 0, 0, 0, 640, 641, 3, 58, 29, 0, 641, 642, 3, 60, 30, 0, 642, 643, 3, 2, 1, 0, 643, 644, 5, 36, 0, 0, 644, 645, 3, 298, 149, 0, 645, 648, 1, 0, 0, 0, 646, 648, 3, 40, 20, 0, 647, 640, 1, 0, 0, 0, 647, 646, 1, 0, 0, 0, 648, 651, 1, 0, 0, 0, 649, 647, 1, 0, 0, 0, 649, 650, 1, 0, 0, 0, 650, 57, 1, 0, 0, 0, 651, 649, 1, 0, 0, 0, 652, 653, 7, 4, 0, 0, 653, 59, 1, 0, 0, 0, 654, 656, 3, 62, 31, 0, 655, 657, 5, 261, 0, 0, 656, 655, 1, 0, 0, 0, 656, 657, 1, 0, 0, 0, 657, 61, 1, 0, 0, 0, 658, 668, 3, 144, 72, 0, 659, 668, 3, 2, 1, 0, 660, 668, 5, 196, 0, 0, 661, 668, 5, 197, 0, 0, 662, 663, 5, 202, 0, 0, 663, 664, 5, 39, 0, 0, 664, 668, 5, 264, 0, 0, 665, 666, 5, 202, 0, 0, 666, 668, 3, 116, 58, 0, 667, 658, 1, 0, 0, 0, 667, 659, 1, 0, 0, 0, 667, 660, 1, 0, 0, 0, 667, 661, 1, 0, 0, 0, 667, 662, 1, 0, 0, 0, 667, 665, 1, 0, 0, 0, 668, 63, 1, 0, 0, 0, 669, 670, 5, 198, 0, 0, 670, 671, 5, 40, 0, 0, 671, 676, 3, 2, 1, 0, 672, 673, 5, 198, 0, 0, 673, 676, 3, 2, 1, 0, 674, 676, 5, 198, 0, 0, 675, 669, 1, 0, 0, 0, 675, 672, 1, 0, 0, 0, 675, 674, 1, 0, 0, 0, 676, 65, 1, 0, 0, 0, 677, 678, 5, 41, 0, 0, 678, 679, 5, 42, 0, 0, 679, 680, 3, 32, 16, 0, 680, 681, 5, 43, 0, 0, 681, 682, 3, 68, 34, 0, 682, 683, 5, 44, 0, 0, 683, 684, 3, 0, 0, 0, 684, 67, 1, 0, 0, 0, 685, 698, 6, 34, -1, 0, 686, 687, 10, 5, 0, 0, 687, 697, 5, 186, 0, 0, 688, 689, 10, 4, 0, 0, 689, 697, 5, 187, 0, 0, 690, 691, 10, 3, 0, 0, 691, 697, 5, 45, 0, 0, 692, 693, 10, 2, 0, 0, 693, 697, 5, 46, 0, 0, 694, 695, 10, 1, 0, 0, 695, 697, 5, 47, 0, 0, 696, 686, 1, 0, 0, 0, 696, 688, 1, 0, 0, 0, 696, 690, 1, 0, 0, 0, 696, 692, 1, 0, 0, 0, 696, 694, 1, 0, 0, 0, 697, 700, 1, 0, 0, 0, 698, 696, 1, 0, 0, 0, 698, 699, 1, 0, 0, 0, 699, 69, 1, 0, 0, 0, 700, 698, 1, 0, 0, 0, 701, 702, 5, 48, 0, 0, 702, 703, 5, 36, 0, 0, 703, 704, 5, 30, 0, 0, 704, 705, 3, 292, 146, 0, 705, 706, 5, 31, 0, 0, 706, 71, 1, 0, 0, 0, 707, 708, 5, 49, 0, 0, 708, 709, 3, 2, 1, 0, 709, 73, 1, 0, 0, 0, 710, 714, 5, 50, 0, 0, 711, 713, 3, 76, 38, 0, 712, 711, 1, 0, 0, 0, 713, 716, 1, 0, 0, 0, 714, 712, 1, 0, 0, 0, 714, 715, 1, 0, 0, 0, 715, 717, 1, 0, 0, 0, 716, 714, 1, 0, 0, 0, 717, 718, 3, 2, 1, 0, 718, 719, 3, 182, 91, 0, 719, 720, 3, 78, 39, 0, 720, 721, 3, 80, 40, 0, 721, 75, 1, 0, 0, 0, 722, 760, 5, 51, 0, 0, 723, 760, 5, 52, 0, 0, 724, 760, 5, 199, 0, 0, 725, 760, 5, 202, 0, 0, 726, 760, 5, 221, 0, 0, 727, 760, 5, 53, 0, 0, 728, 760, 5, 54, 0, 0, 729, 760, 5, 55, 0, 0, 730, 760, 5, 56, 0, 0, 731, 760, 5, 244, 0, 0, 732, 760, 5, 15, 0, 0, 733, 760, 5, 224, 0, 0, 734, 760, 5, 57, 0, 0, 735, 760, 5, 58, 0, 0, 736, 760, 5, 59, 0, 0, 737, 760, 5, 60, 0, 0, 738, 760, 5, 61, 0, 0, 739, 740, 5, 62, 0, 0, 740, 760, 5, 51, 0, 0, 741, 742, 5, 62, 0, 0, 742, 760, 5, 52, 0, 0, 743, 744, 5, 62, 0, 0, 744, 760, 5, 63, 0, 0, 745, 746, 5, 62, 0, 0, 746, 760, 5, 64, 0, 0, 747, 748, 5, 62, 0, 0, 748, 760, 5, 65, 0, 0, 749, 750, 5, 62, 0, 0, 750, 760, 5, 66, 0, 0, 751, 760, 5, 67, 0, 0, 752, 760, 5, 68, 0, 0, 753, 760, 5, 69, 0, 0, 754, 755, 5, 70, 0, 0, 755, 756, 5, 30, 0, 0, 756, 757, 3, 32, 16, 0, 757, 758, 5, 31, 0, 0, 758, 760, 1, 0, 0, 0, 759, 722, 1, 0, 0, 0, 759, 723, 1, 0, 0, 0, 759, 724, 1, 0, 0, 0, 759, 725, 1, 0, 0, 0, 759, 726, 1, 0, 0, 0, 759, 727, 1, 0, 0, 0, 759, 728, 1, 0, 0, 0, 759, 729, 1, 0, 0, 0, 759, 730, 1, 0, 0, 0, 759, 731, 1, 0, 0, 0, 759, 732, 1, 0, 0, 0, 759, 733, 1, 0, 0, 0, 759, 734, 1, 0, 0, 0, 759, 735, 1, 0, 0, 0, 759, 736, 1, 0, 0, 0, 759, 737, 1, 0, 0, 0, 759, 738, 1, 0, 0, 0, 759, 739, 1, 0, 0, 0, 759, 741, 1, 0, 0, 0, 759, 743, 1, 0, 0, 0, 759, 745, 1, 0, 0, 0, 759, 747, 1, 0, 0, 0, 759, 749, 1, 0, 0, 0, 759, 751, 1, 0, 0, 0, 759, 752, 1, 0, 0, 0, 759, 753, 1, 0, 0, 0, 759, 754, 1, 0, 0, 0, 760, 77, 1, 0, 0, 0, 761, 765, 1, 0, 0, 0, 762, 763, 5, 71, 0, 0, 763, 765, 3, 124, 62, 0, 764, 761, 1, 0, 0, 0, 764, 762, 1, 0, 0, 0, 765, 79, 1, 0, 0, 0, 766, 770, 1, 0, 0, 0, 767, 768, 5, 72, 0, 0, 768, 770, 3, 84, 42, 0, 769, 766, 1, 0, 0, 0, 769, 767, 1, 0, 0, 0, 770, 81, 1, 0, 0, 0, 771, 773, 3, 198, 99, 0, 772, 771, 1, 0, 0, 0, 773, 776, 1, 0, 0, 0, 774, 772, 1, 0, 0, 0, 774, 775, 1, 0, 0, 0, 775, 83, 1, 0, 0, 0, 776, 774, 1, 0, 0, 0, 777, 778, 3, 124, 62, 0, 778, 779, 5, 28, 0, 0, 779, 781, 1, 0, 0, 0, 780, 777, 1, 0, 0, 0, 781, 784, 1, 0, 0, 0, 782, 780, 1, 0, 0, 0, 782, 783, 1, 0, 0, 0, 783, 785, 1, 0, 0, 0, 784, 782, 1, 0, 0, 0, 785, 786, 3, 124, 62, 0, 786, 85, 1, 0, 0, 0, 787, 788, 7, 5, 0, 0, 788, 87, 1, 0, 0, 0, 789, 790, 3, 86, 43, 0, 790, 791, 3, 32, 16, 0, 791, 792, 5, 264, 0, 0, 792, 893, 1, 0, 0, 0, 793, 794, 3, 86, 43, 0, 794, 795, 3, 32, 16, 0, 795, 893, 1, 0, 0, 0, 796, 797, 3, 86, 43, 0, 797, 798, 3, 32, 16, 0, 798, 799, 5, 75, 0, 0, 799, 800, 3, 32, 16, 0, 800, 801, 5, 264, 0, 0, 801, 893, 1, 0, 0, 0, 802, 803, 3, 86, 43, 0, 803, 804, 3, 32, 16, 0, 804, 805, 5, 75, 0, 0, 805, 806, 3, 32, 16, 0, 806, 893, 1, 0, 0, 0, 807, 808, 3, 86, 43, 0, 808, 809, 3, 32, 16, 0, 809, 810, 5, 75, 0, 0, 810, 811, 3, 32, 16, 0, 811, 812, 5, 28, 0, 0, 812, 813, 3, 32, 16, 0, 813, 814, 5, 264, 0, 0, 814, 893, 1, 0, 0, 0, 815, 816, 3, 86, 43, 0, 816, 817, 3, 32, 16, 0, 817, 818, 5, 75, 0, 0, 818, 819, 3, 32, 16, 0, 819, 820, 5, 28, 0, 0, 820, 821, 3, 32, 16, 0, 821, 893, 1, 0, 0, 0, 822, 823, 3, 86, 43, 0, 823, 824, 3, 32, 16, 0, 824, 825, 5, 28, 0, 0, 825, 826, 3, 32, 16, 0, 826, 827, 5, 75, 0, 0, 827, 828, 3, 32, 16, 0, 828, 829, 5, 264, 0, 0, 829, 893, 1, 0, 0, 0, 830, 831, 3, 86, 43, 0, 831, 832, 3, 32, 16, 0, 832, 833, 5, 28, 0, 0, 833, 834, 3, 32, 16, 0, 834, 835, 5, 75, 0, 0, 835, 836, 3, 32, 16, 0, 836, 893, 1, 0, 0, 0, 837, 838, 3, 86, 43, 0, 838, 839, 3, 32, 16, 0, 839, 840, 5, 28, 0, 0, 840, 841, 3, 32, 16, 0, 841, 842, 5, 75, 0, 0, 842, 843, 3, 32, 16, 0, 843, 844, 5, 28, 0, 0, 844, 845, 3, 32, 16, 0, 845, 846, 5, 264, 0, 0, 846, 893, 1, 0, 0, 0, 847, 848, 3, 86, 43, 0, 848, 849, 3, 32, 16, 0, 849, 850, 5, 28, 0, 0, 850, 851, 3, 32, 16, 0, 851, 852, 5, 75, 0, 0, 852, 853, 3, 32, 16, 0, 853, 854, 5, 28, 0, 0, 854, 855, 3, 32, 16, 0, 855, 893, 1, 0, 0, 0, 856, 857, 3, 86, 43, 0, 857, 858, 3, 32, 16, 0, 858, 859, 5, 263, 0, 0, 859, 893, 1, 0, 0, 0, 860, 861, 3, 86, 43, 0, 861, 862, 3, 32, 16, 0, 862, 863, 5, 75, 0, 0, 863, 864, 3, 32, 16, 0, 864, 865, 5, 263, 0, 0, 865, 893, 1, 0, 0, 0, 866, 867, 3, 86, 43, 0, 867, 868, 3, 32, 16, 0, 868, 869, 5, 75, 0, 0, 869, 870, 3, 32, 16, 0, 870, 871, 5, 28, 0, 0, 871, 872, 3, 32, 16, 0, 872, 873, 5, 263, 0, 0, 873, 893, 1, 0, 0, 0, 874, 875, 3, 86, 43, 0, 875, 876, 3, 32, 16, 0, 876, 877, 5, 28, 0, 0, 877, 878, 3, 32, 16, 0, 878, 879, 5, 75, 0, 0, 879, 880, 3, 32, 16, 0, 880, 881, 5, 263, 0, 0, 881, 893, 1, 0, 0, 0, 882, 883, 3, 86, 43, 0, 883, 884, 3, 32, 16, 0, 884, 885, 5, 28, 0, 0, 885, 886, 3, 32, 16, 0, 886, 887, 5, 75, 0, 0, 887, 888, 3, 32, 16, 0, 888, 889, 5, 28, 0, 0, 889, 890, 3, 32, 16, 0, 890, 891, 5, 263, 0, 0, 891, 893, 1, 0, 0, 0, 892, 789, 1, 0, 0, 0, 892, 793, 1, 0, 0, 0, 892, 796, 1, 0, 0, 0, 892, 802, 1, 0, 0, 0, 892, 807, 1, 0, 0, 0, 892, 815, 1, 0, 0, 0, 892, 822, 1, 0, 0, 0, 892, 830, 1, 0, 0, 0, 892, 837, 1, 0, 0, 0, 892, 847, 1, 0, 0, 0, 892, 856, 1, 0, 0, 0, 892, 860, 1, 0, 0, 0, 892, 866, 1, 0, 0, 0, 892, 874, 1, 0, 0, 0, 892, 882, 1, 0, 0, 0, 893, 89, 1, 0, 0, 0, 894, 898, 5, 21, 0, 0, 895, 897, 3, 92, 46, 0, 896, 895, 1, 0, 0, 0, 897, 900, 1, 0, 0, 0, 898, 896, 1, 0, 0, 0, 898, 899, 1, 0, 0, 0, 899, 901, 1, 0, 0, 0, 900, 898, 1, 0, 0, 0, 901, 902, 3, 2, 1, 0, 902, 903, 3, 94, 47, 0, 903, 904, 5, 180, 0, 0, 904, 905, 5, 36, 0, 0, 905, 906, 5, 30, 0, 0, 906, 907, 3, 292, 146, 0, 907, 908, 5, 31, 0, 0, 908, 909, 3, 94, 47, 0, 909, 921, 1, 0, 0, 0, 910, 914, 5, 21, 0, 0, 911, 913, 3, 92, 46, 0, 912, 911, 1, 0, 0, 0, 913, 916, 1, 0, 0, 0, 914, 912, 1, 0, 0, 0, 914, 915, 1, 0, 0, 0, 915, 917, 1, 0, 0, 0, 916, 914, 1, 0, 0, 0, 917, 918, 3, 2, 1, 0, 918, 919, 3, 94, 47, 0, 919, 921, 1, 0, 0, 0, 920, 894, 1, 0, 0, 0, 920, 910, 1, 0, 0, 0, 921, 91, 1, 0, 0, 0, 922, 923, 5, 76, 0, 0, 923, 93, 1, 0, 0, 0, 924, 927, 1, 0, 0, 0, 925, 927, 5, 298, 0, 0, 926, 924, 1, 0, 0, 0, 926, 925, 1, 0, 0, 0, 927, 95, 1, 0, 0, 0, 928, 929, 7, 6, 0, 0, 929, 97, 1, 0, 0, 0, 930, 932, 3, 96, 48, 0, 931, 930, 1, 0, 0, 0, 932, 935, 1, 0, 0, 0, 933, 931, 1, 0, 0, 0, 933, 934, 1, 0, 0, 0, 934, 99, 1, 0, 0, 0, 935, 933, 1, 0, 0, 0, 936, 939, 3, 102, 51, 0, 937, 939, 3, 104, 52, 0, 938, 936, 1, 0, 0, 0, 938, 937, 1, 0, 0, 0, 939, 101, 1, 0, 0, 0, 940, 941, 5, 275, 0, 0, 941, 1019, 6, 51, -1, 0, 942, 943, 5, 276, 0, 0, 943, 944, 3, 32, 16, 0, 944, 945, 6, 51, -1, 0, 945, 1019, 1, 0, 0, 0, 946, 947, 5, 276, 0, 0, 947, 948, 3, 0, 0, 0, 948, 949, 6, 51, -1, 0, 949, 1019, 1, 0, 0, 0, 950, 951, 5, 277, 0, 0, 951, 952, 3, 32, 16, 0, 952, 953, 6, 51, -1, 0, 953, 1019, 1, 0, 0, 0, 954, 955, 5, 278, 0, 0, 955, 956, 3, 34, 17, 0, 956, 957, 6, 51, -1, 0, 957, 1019, 1, 0, 0, 0, 958, 959, 5, 279, 0, 0, 959, 960, 3, 36, 18, 0, 960, 961, 6, 51, -1, 0, 961, 1019, 1, 0, 0, 0, 962, 963, 5, 279, 0, 0, 963, 964, 3, 34, 17, 0, 964, 965, 6, 51, -1, 0, 965, 1019, 1, 0, 0, 0, 966, 967, 5, 279, 0, 0, 967, 968, 5, 30, 0, 0, 968, 969, 3, 292, 146, 0, 969, 970, 5, 31, 0, 0, 970, 971, 6, 51, -1, 0, 971, 1019, 1, 0, 0, 0, 972, 973, 5, 279, 0, 0, 973, 974, 5, 84, 0, 0, 974, 975, 5, 30, 0, 0, 975, 976, 3, 292, 146, 0, 976, 977, 5, 31, 0, 0, 977, 978, 6, 51, -1, 0, 978, 1019, 1, 0, 0, 0, 979, 980, 5, 282, 0, 0, 980, 981, 3, 32, 16, 0, 981, 982, 6, 51, -1, 0, 982, 1019, 1, 0, 0, 0, 983, 984, 5, 282, 0, 0, 984, 985, 3, 0, 0, 0, 985, 986, 6, 51, -1, 0, 986, 1019, 1, 0, 0, 0, 987, 988, 5, 285, 0, 0, 988, 989, 3, 6, 3, 0, 989, 990, 6, 51, -1, 0, 990, 1019, 1, 0, 0, 0, 991, 992, 5, 285, 0, 0, 992, 993, 5, 224, 0, 0, 993, 994, 5, 30, 0, 0, 994, 995, 3, 6, 3, 0, 995, 996, 5, 31, 0, 0, 996, 997, 6, 51, -1, 0, 997, 1019, 1, 0, 0, 0, 998, 999, 5, 285, 0, 0, 999, 1000, 5, 84, 0, 0, 1000, 1001, 5, 30, 0, 0, 1001, 1002, 3, 292, 146, 0, 1002, 1003, 5, 31, 0, 0, 1003, 1004, 6, 51, -1, 0, 1004, 1019, 1, 0, 0, 0, 1005, 1006, 5, 287, 0, 0, 1006, 1007, 3, 32, 16, 0, 1007, 1008, 6, 51, -1, 0, 1008, 1019, 1, 0, 0, 0, 1009, 1010, 5, 283, 0, 0, 1010, 1016, 6, 51, -1, 0, 1011, 1012, 5, 30, 0, 0, 1012, 1013, 3, 106, 53, 0, 1013, 1014, 5, 31, 0, 0, 1014, 1017, 1, 0, 0, 0, 1015, 1017, 5, 85, 0, 0, 1016, 1011, 1, 0, 0, 0, 1016, 1015, 1, 0, 0, 0, 1017, 1019, 1, 0, 0, 0, 1018, 940, 1, 0, 0, 0, 1018, 942, 1, 0, 0, 0, 1018, 946, 1, 0, 0, 0, 1018, 950, 1, 0, 0, 0, 1018, 954, 1, 0, 0, 0, 1018, 958, 1, 0, 0, 0, 1018, 962, 1, 0, 0, 0, 1018, 966, 1, 0, 0, 0, 1018, 972, 1, 0, 0, 0, 1018, 979, 1, 0, 0, 0, 1018, 983, 1, 0, 0, 0, 1018, 987, 1, 0, 0, 0, 1018, 991, 1, 0, 0, 0, 1018, 998, 1, 0, 0, 0, 1018, 1005, 1, 0, 0, 0, 1018, 1009, 1, 0, 0, 0, 1019, 103, 1, 0, 0, 0, 1020, 1021, 5, 280, 0, 0, 1021, 1036, 3, 168, 84, 0, 1022, 1023, 5, 286, 0, 0, 1023, 1036, 3, 178, 89, 0, 1024, 1025, 5, 286, 0, 0, 1025, 1036, 3, 174, 87, 0, 1026, 1027, 5, 284, 0, 0, 1027, 1036, 3, 124, 62, 0, 1028, 1029, 5, 281, 0, 0, 1029, 1030, 3, 170, 85, 0, 1030, 1031, 3, 138, 69, 0, 1031, 1032, 3, 112, 56, 0, 1032, 1036, 1, 0, 0, 0, 1033, 1034, 5, 287, 0, 0, 1034, 1036, 3, 50, 25, 0, 1035, 1020, 1, 0, 0, 0, 1035, 1022, 1, 0, 0, 0, 1035, 1024, 1, 0, 0, 0, 1035, 1026, 1, 0, 0, 0, 1035, 1028, 1, 0, 0, 0, 1035, 1033, 1, 0, 0, 0, 1036, 105, 1, 0, 0, 0, 1037, 1062, 1, 0, 0, 0, 1038, 1039, 3, 0, 0, 0, 1039, 1040, 6, 53, -1, 0, 1040, 1045, 1, 0, 0, 0, 1041, 1042, 3, 32, 16, 0, 1042, 1043, 6, 53, -1, 0, 1043, 1045, 1, 0, 0, 0, 1044, 1038, 1, 0, 0, 0, 1044, 1041, 1, 0, 0, 0, 1045, 1046, 1, 0, 0, 0, 1046, 1047, 5, 28, 0, 0, 1047, 1049, 1, 0, 0, 0, 1048, 1044, 1, 0, 0, 0, 1049, 1052, 1, 0, 0, 0, 1050, 1048, 1, 0, 0, 0, 1050, 1051, 1, 0, 0, 0, 1051, 1059, 1, 0, 0, 0, 1052, 1050, 1, 0, 0, 0, 1053, 1054, 3, 0, 0, 0, 1054, 1055, 6, 53, -1, 0, 1055, 1060, 1, 0, 0, 0, 1056, 1057, 3, 32, 16, 0, 1057, 1058, 6, 53, -1, 0, 1058, 1060, 1, 0, 0, 0, 1059, 1053, 1, 0, 0, 0, 1059, 1056, 1, 0, 0, 0, 1060, 1062, 1, 0, 0, 0, 1061, 1037, 1, 0, 0, 0, 1061, 1050, 1, 0, 0, 0, 1062, 107, 1, 0, 0, 0, 1063, 1069, 5, 86, 0, 0, 1064, 1065, 3, 138, 69, 0, 1065, 1066, 5, 28, 0, 0, 1066, 1068, 1, 0, 0, 0, 1067, 1064, 1, 0, 0, 0, 1068, 1071, 1, 0, 0, 0, 1069, 1067, 1, 0, 0, 0, 1069, 1070, 1, 0, 0, 0, 1070, 1072, 1, 0, 0, 0, 1071, 1069, 1, 0, 0, 0, 1072, 1073, 3, 138, 69, 0, 1073, 1074, 5, 87, 0, 0, 1074, 109, 1, 0, 0, 0, 1075, 1081, 5, 42, 0, 0, 1076, 1077, 3, 146, 73, 0, 1077, 1078, 5, 28, 0, 0, 1078, 1080, 1, 0, 0, 0, 1079, 1076, 1, 0, 0, 0, 1080, 1083, 1, 0, 0, 0, 1081, 1079, 1, 0, 0, 0, 1081, 1082, 1, 0, 0, 0, 1082, 1084, 1, 0, 0, 0, 1083, 1081, 1, 0, 0, 0, 1084, 1085, 3, 146, 73, 0, 1085, 1086, 5, 43, 0, 0, 1086, 111, 1, 0, 0, 0, 1087, 1093, 5, 30, 0, 0, 1088, 1089, 3, 114, 57, 0, 1089, 1090, 5, 28, 0, 0, 1090, 1092, 1, 0, 0, 0, 1091, 1088, 1, 0, 0, 0, 1092, 1095, 1, 0, 0, 0, 1093, 1091, 1, 0, 0, 0, 1093, 1094, 1, 0, 0, 0, 1094, 1096, 1, 0, 0, 0, 1095, 1093, 1, 0, 0, 0, 1096, 1097, 3, 114, 57, 0, 1097, 1098, 5, 31, 0, 0, 1098, 1101, 1, 0, 0, 0, 1099, 1101, 5, 85, 0, 0, 1100, 1087, 1, 0, 0, 0, 1100, 1099, 1, 0, 0, 0, 1101, 113, 1, 0, 0, 0, 1102, 1110, 5, 177, 0, 0, 1103, 1104, 3, 230, 115, 0, 1104, 1105, 3, 138, 69, 0, 1105, 1107, 3, 226, 113, 0, 1106, 1108, 3, 0, 0, 0, 1107, 1106, 1, 0, 0, 0, 1107, 1108, 1, 0, 0, 0, 1108, 1110, 1, 0, 0, 0, 1109, 1102, 1, 0, 0, 0, 1109, 1103, 1, 0, 0, 0, 1110, 115, 1, 0, 0, 0, 1111, 1112, 5, 42, 0, 0, 1112, 1113, 3, 2, 1, 0, 1113, 1114, 5, 43, 0, 0, 1114, 1115, 3, 118, 59, 0, 1115, 1137, 1, 0, 0, 0, 1116, 1117, 5, 42, 0, 0, 1117, 1118, 3, 174, 87, 0, 1118, 1119, 5, 43, 0, 0, 1119, 1120, 3, 118, 59, 0, 1120, 1137, 1, 0, 0, 0, 1121, 1122, 5, 42, 0, 0, 1122, 1123, 5, 262, 0, 0, 1123, 1124, 5, 43, 0, 0, 1124, 1137, 3, 118, 59, 0, 1125, 1126, 5, 42, 0, 0, 1126, 1127, 5, 198, 0, 0, 1127, 1128, 3, 2, 1, 0, 1128, 1129, 5, 43, 0, 0, 1129, 1130, 3, 118, 59, 0, 1130, 1137, 1, 0, 0, 0, 1131, 1137, 3, 118, 59, 0, 1132, 1137, 3, 174, 87, 0, 1133, 1137, 5, 257, 0, 0, 1134, 1137, 5, 258, 0, 0, 1135, 1137, 5, 259, 0, 0, 1136, 1111, 1, 0, 0, 0, 1136, 1116, 1, 0, 0, 0, 1136, 1121, 1, 0, 0, 0, 1136, 1125, 1, 0, 0, 0, 1136, 1131, 1, 0, 0, 0, 1136, 1132, 1, 0, 0, 0, 1136, 1133, 1, 0, 0, 0, 1136, 1134, 1, 0, 0, 0, 1136, 1135, 1, 0, 0, 0, 1137, 117, 1, 0, 0, 0, 1138, 1139, 3, 2, 1, 0, 1139, 1140, 5, 88, 0, 0, 1140, 1142, 1, 0, 0, 0, 1141, 1138, 1, 0, 0, 0, 1142, 1145, 1, 0, 0, 0, 1143, 1141, 1, 0, 0, 0, 1143, 1144, 1, 0, 0, 0, 1144, 1146, 1, 0, 0, 0, 1145, 1143, 1, 0, 0, 0, 1146, 1147, 3, 2, 1, 0, 1147, 119, 1, 0, 0, 0, 1148, 1150, 3, 122, 61, 0, 1149, 1148, 1, 0, 0, 0, 1150, 1153, 1, 0, 0, 0, 1151, 1149, 1, 0, 0, 0, 1151, 1152, 1, 0, 0, 0, 1152, 121, 1, 0, 0, 0, 1153, 1151, 1, 0, 0, 0, 1154, 1155, 5, 180, 0, 0, 1155, 1156, 5, 89, 0, 0, 1156, 1160, 3, 32, 16, 0, 1157, 1160, 3, 152, 76, 0, 1158, 1160, 3, 324, 162, 0, 1159, 1154, 1, 0, 0, 0, 1159, 1157, 1, 0, 0, 0, 1159, 1158, 1, 0, 0, 0, 1160, 123, 1, 0, 0, 0, 1161, 1173, 3, 116, 58, 0, 1162, 1163, 5, 42, 0, 0, 1163, 1164, 3, 2, 1, 0, 1164, 1165, 5, 43, 0, 0, 1165, 1173, 1, 0, 0, 0, 1166, 1167, 5, 42, 0, 0, 1167, 1168, 5, 198, 0, 0, 1168, 1169, 3, 2, 1, 0, 1169, 1170, 5, 43, 0, 0, 1170, 1173, 1, 0, 0, 0, 1171, 1173, 3, 138, 69, 0, 1172, 1161, 1, 0, 0, 0, 1172, 1162, 1, 0, 0, 0, 1172, 1166, 1, 0, 0, 0, 1172, 1171, 1, 0, 0, 0, 1173, 125, 1, 0, 0, 0, 1174, 1183, 1, 0, 0, 0, 1175, 1179, 3, 130, 65, 0, 1176, 1178, 3, 128, 64, 0, 1177, 1176, 1, 0, 0, 0, 1178, 1181, 1, 0, 0, 0, 1179, 1177, 1, 0, 0, 0, 1179, 1180, 1, 0, 0, 0, 1180, 1183, 1, 0, 0, 0, 1181, 1179, 1, 0, 0, 0, 1182, 1174, 1, 0, 0, 0, 1182, 1175, 1, 0, 0, 0, 1183, 127, 1, 0, 0, 0, 1184, 1202, 5, 262, 0, 0, 1185, 1202, 5, 261, 0, 0, 1186, 1187, 5, 42, 0, 0, 1187, 1188, 3, 32, 16, 0, 1188, 1189, 5, 43, 0, 0, 1189, 1202, 1, 0, 0, 0, 1190, 1191, 5, 42, 0, 0, 1191, 1192, 3, 32, 16, 0, 1192, 1193, 5, 266, 0, 0, 1193, 1194, 3, 32, 16, 0, 1194, 1195, 5, 43, 0, 0, 1195, 1202, 1, 0, 0, 0, 1196, 1197, 5, 42, 0, 0, 1197, 1198, 5, 266, 0, 0, 1198, 1199, 3, 32, 16, 0, 1199, 1200, 5, 43, 0, 0, 1200, 1202, 1, 0, 0, 0, 1201, 1184, 1, 0, 0, 0, 1201, 1185, 1, 0, 0, 0, 1201, 1186, 1, 0, 0, 0, 1201, 1190, 1, 0, 0, 0, 1201, 1196, 1, 0, 0, 0, 1202, 129, 1, 0, 0, 0, 1203, 1296, 1, 0, 0, 0, 1204, 1205, 5, 203, 0, 0, 1205, 1206, 5, 30, 0, 0, 1206, 1207, 3, 6, 3, 0, 1207, 1208, 5, 28, 0, 0, 1208, 1209, 3, 6, 3, 0, 1209, 1210, 5, 28, 0, 0, 1210, 1211, 3, 6, 3, 0, 1211, 1212, 5, 28, 0, 0, 1212, 1213, 3, 6, 3, 0, 1213, 1214, 5, 31, 0, 0, 1214, 1296, 1, 0, 0, 0, 1215, 1216, 5, 203, 0, 0, 1216, 1217, 5, 30, 0, 0, 1217, 1218, 3, 6, 3, 0, 1218, 1219, 5, 28, 0, 0, 1219, 1220, 3, 6, 3, 0, 1220, 1221, 5, 31, 0, 0, 1221, 1296, 1, 0, 0, 0, 1222, 1223, 5, 204, 0, 0, 1223, 1224, 5, 205, 0, 0, 1224, 1225, 5, 42, 0, 0, 1225, 1226, 3, 32, 16, 0, 1226, 1227, 5, 43, 0, 0, 1227, 1296, 1, 0, 0, 0, 1228, 1229, 5, 204, 0, 0, 1229, 1230, 5, 206, 0, 0, 1230, 1231, 5, 42, 0, 0, 1231, 1232, 3, 32, 16, 0, 1232, 1233, 5, 43, 0, 0, 1233, 1234, 3, 126, 63, 0, 1234, 1296, 1, 0, 0, 0, 1235, 1296, 5, 207, 0, 0, 1236, 1296, 5, 208, 0, 0, 1237, 1296, 5, 209, 0, 0, 1238, 1296, 5, 201, 0, 0, 1239, 1296, 5, 183, 0, 0, 1240, 1296, 5, 184, 0, 0, 1241, 1296, 5, 185, 0, 0, 1242, 1296, 5, 186, 0, 0, 1243, 1296, 5, 187, 0, 0, 1244, 1296, 5, 188, 0, 0, 1245, 1296, 5, 189, 0, 0, 1246, 1296, 5, 210, 0, 0, 1247, 1296, 5, 190, 0, 0, 1248, 1296, 5, 191, 0, 0, 1249, 1296, 5, 192, 0, 0, 1250, 1296, 5, 193, 0, 0, 1251, 1296, 5, 211, 0, 0, 1252, 1296, 5, 212, 0, 0, 1253, 1296, 5, 213, 0, 0, 1254, 1296, 5, 214, 0, 0, 1255, 1296, 5, 215, 0, 0, 1256, 1296, 5, 216, 0, 0, 1257, 1296, 5, 217, 0, 0, 1258, 1259, 5, 218, 0, 0, 1259, 1296, 3, 132, 66, 0, 1260, 1261, 5, 219, 0, 0, 1261, 1296, 3, 132, 66, 0, 1262, 1296, 5, 220, 0, 0, 1263, 1264, 5, 221, 0, 0, 1264, 1296, 3, 132, 66, 0, 1265, 1266, 5, 222, 0, 0, 1266, 1296, 3, 134, 67, 0, 1267, 1268, 5, 222, 0, 0, 1268, 1269, 3, 134, 67, 0, 1269, 1270, 5, 28, 0, 0, 1270, 1271, 3, 6, 3, 0, 1271, 1296, 1, 0, 0, 0, 1272, 1296, 5, 194, 0, 0, 1273, 1296, 5, 195, 0, 0, 1274, 1275, 5, 90, 0, 0, 1275, 1296, 5, 184, 0, 0, 1276, 1277, 5, 90, 0, 0, 1277, 1296, 5, 185, 0, 0, 1278, 1279, 5, 90, 0, 0, 1279, 1296, 5, 186, 0, 0, 1280, 1281, 5, 90, 0, 0, 1281, 1296, 5, 187, 0, 0, 1282, 1283, 5, 62, 0, 0, 1283, 1296, 5, 220, 0, 0, 1284, 1296, 5, 223, 0, 0, 1285, 1286, 5, 224, 0, 0, 1286, 1296, 5, 213, 0, 0, 1287, 1296, 5, 225, 0, 0, 1288, 1289, 5, 207, 0, 0, 1289, 1296, 5, 183, 0, 0, 1290, 1296, 5, 226, 0, 0, 1291, 1296, 5, 228, 0, 0, 1292, 1293, 5, 34, 0, 0, 1293, 1296, 5, 227, 0, 0, 1294, 1296, 3, 2, 1, 0, 1295, 1203, 1, 0, 0, 0, 1295, 1204, 1, 0, 0, 0, 1295, 1215, 1, 0, 0, 0, 1295, 1222, 1, 0, 0, 0, 1295, 1228, 1, 0, 0, 0, 1295, 1235, 1, 0, 0, 0, 1295, 1236, 1, 0, 0, 0, 1295, 1237, 1, 0, 0, 0, 1295, 1238, 1, 0, 0, 0, 1295, 1239, 1, 0, 0, 0, 1295, 1240, 1, 0, 0, 0, 1295, 1241, 1, 0, 0, 0, 1295, 1242, 1, 0, 0, 0, 1295, 1243, 1, 0, 0, 0, 1295, 1244, 1, 0, 0, 0, 1295, 1245, 1, 0, 0, 0, 1295, 1246, 1, 0, 0, 0, 1295, 1247, 1, 0, 0, 0, 1295, 1248, 1, 0, 0, 0, 1295, 1249, 1, 0, 0, 0, 1295, 1250, 1, 0, 0, 0, 1295, 1251, 1, 0, 0, 0, 1295, 1252, 1, 0, 0, 0, 1295, 1253, 1, 0, 0, 0, 1295, 1254, 1, 0, 0, 0, 1295, 1255, 1, 0, 0, 0, 1295, 1256, 1, 0, 0, 0, 1295, 1257, 1, 0, 0, 0, 1295, 1258, 1, 0, 0, 0, 1295, 1260, 1, 0, 0, 0, 1295, 1262, 1, 0, 0, 0, 1295, 1263, 1, 0, 0, 0, 1295, 1265, 1, 0, 0, 0, 1295, 1267, 1, 0, 0, 0, 1295, 1272, 1, 0, 0, 0, 1295, 1273, 1, 0, 0, 0, 1295, 1274, 1, 0, 0, 0, 1295, 1276, 1, 0, 0, 0, 1295, 1278, 1, 0, 0, 0, 1295, 1280, 1, 0, 0, 0, 1295, 1282, 1, 0, 0, 0, 1295, 1284, 1, 0, 0, 0, 1295, 1285, 1, 0, 0, 0, 1295, 1287, 1, 0, 0, 0, 1295, 1288, 1, 0, 0, 0, 1295, 1290, 1, 0, 0, 0, 1295, 1291, 1, 0, 0, 0, 1295, 1292, 1, 0, 0, 0, 1295, 1294, 1, 0, 0, 0, 1296, 131, 1, 0, 0, 0, 1297, 1305, 1, 0, 0, 0, 1298, 1299, 5, 30, 0, 0, 1299, 1300, 5, 91, 0, 0, 1300, 1301, 5, 36, 0, 0, 1301, 1302, 3, 32, 16, 0, 1302, 1303, 5, 31, 0, 0, 1303, 1305, 1, 0, 0, 0, 1304, 1297, 1, 0, 0, 0, 1304, 1298, 1, 0, 0, 0, 1305, 133, 1, 0, 0, 0, 1306, 1315, 1, 0, 0, 0, 1307, 1311, 3, 136, 68, 0, 1308, 1310, 7, 7, 0, 0, 1309, 1308, 1, 0, 0, 0, 1310, 1313, 1, 0, 0, 0, 1311, 1309, 1, 0, 0, 0, 1311, 1312, 1, 0, 0, 0, 1312, 1315, 1, 0, 0, 0, 1313, 1311, 1, 0, 0, 0, 1314, 1306, 1, 0, 0, 0, 1314, 1307, 1, 0, 0, 0, 1315, 135, 1, 0, 0, 0, 1316, 1317, 7, 8, 0, 0, 1317, 137, 1, 0, 0, 0, 1318, 1322, 3, 142, 71, 0, 1319, 1321, 3, 140, 70, 0, 1320, 1319, 1, 0, 0, 0, 1321, 1324, 1, 0, 0, 0, 1322, 1320, 1, 0, 0, 0, 1322, 1323, 1, 0, 0, 0, 1323, 139, 1, 0, 0, 0, 1324, 1322, 1, 0, 0, 0, 1325, 1344, 5, 261, 0, 0, 1326, 1327, 5, 42, 0, 0, 1327, 1344, 5, 43, 0, 0, 1328, 1344, 3, 110, 55, 0, 1329, 1344, 5, 260, 0, 0, 1330, 1344, 5, 262, 0, 0, 1331, 1344, 5, 92, 0, 0, 1332, 1333, 5, 93, 0, 0, 1333, 1334, 5, 30, 0, 0, 1334, 1335, 3, 124, 62, 0, 1335, 1336, 5, 31, 0, 0, 1336, 1344, 1, 0, 0, 0, 1337, 1338, 5, 94, 0, 0, 1338, 1339, 5, 30, 0, 0, 1339, 1340, 3, 124, 62, 0, 1340, 1341, 5, 31, 0, 0, 1341, 1344, 1, 0, 0, 0, 1342, 1344, 3, 108, 54, 0, 1343, 1325, 1, 0, 0, 0, 1343, 1326, 1, 0, 0, 0, 1343, 1328, 1, 0, 0, 0, 1343, 1329, 1, 0, 0, 0, 1343, 1330, 1, 0, 0, 0, 1343, 1331, 1, 0, 0, 0, 1343, 1332, 1, 0, 0, 0, 1343, 1337, 1, 0, 0, 0, 1343, 1342, 1, 0, 0, 0, 1344, 141, 1, 0, 0, 0, 1345, 1346, 5, 39, 0, 0, 1346, 1376, 3, 116, 58, 0, 1347, 1376, 5, 197, 0, 0, 1348, 1349, 5, 199, 0, 0, 1349, 1350, 5, 39, 0, 0, 1350, 1376, 3, 116, 58, 0, 1351, 1352, 5, 200, 0, 0, 1352, 1376, 3, 116, 58, 0, 1353, 1354, 5, 226, 0, 0, 1354, 1355, 3, 170, 85, 0, 1355, 1356, 3, 138, 69, 0, 1356, 1357, 5, 262, 0, 0, 1357, 1358, 3, 112, 56, 0, 1358, 1376, 1, 0, 0, 0, 1359, 1360, 5, 253, 0, 0, 1360, 1376, 3, 32, 16, 0, 1361, 1362, 5, 252, 0, 0, 1362, 1376, 3, 32, 16, 0, 1363, 1364, 5, 253, 0, 0, 1364, 1376, 3, 2, 1, 0, 1365, 1366, 5, 252, 0, 0, 1366, 1376, 3, 2, 1, 0, 1367, 1376, 5, 254, 0, 0, 1368, 1376, 5, 201, 0, 0, 1369, 1376, 3, 148, 74, 0, 1370, 1376, 3, 150, 75, 0, 1371, 1376, 3, 144, 72, 0, 1372, 1376, 3, 2, 1, 0, 1373, 1374, 5, 177, 0, 0, 1374, 1376, 3, 138, 69, 0, 1375, 1345, 1, 0, 0, 0, 1375, 1347, 1, 0, 0, 0, 1375, 1348, 1, 0, 0, 0, 1375, 1351, 1, 0, 0, 0, 1375, 1353, 1, 0, 0, 0, 1375, 1359, 1, 0, 0, 0, 1375, 1361, 1, 0, 0, 0, 1375, 1363, 1, 0, 0, 0, 1375, 1365, 1, 0, 0, 0, 1375, 1367, 1, 0, 0, 0, 1375, 1368, 1, 0, 0, 0, 1375, 1369, 1, 0, 0, 0, 1375, 1370, 1, 0, 0, 0, 1375, 1371, 1, 0, 0, 0, 1375, 1372, 1, 0, 0, 0, 1375, 1373, 1, 0, 0, 0, 1376, 143, 1, 0, 0, 0, 1377, 1399, 5, 181, 0, 0, 1378, 1399, 5, 182, 0, 0, 1379, 1399, 5, 183, 0, 0, 1380, 1399, 5, 184, 0, 0, 1381, 1399, 5, 185, 0, 0, 1382, 1399, 5, 186, 0, 0, 1383, 1399, 5, 187, 0, 0, 1384, 1399, 5, 188, 0, 0, 1385, 1399, 5, 189, 0, 0, 1386, 1399, 5, 190, 0, 0, 1387, 1399, 5, 191, 0, 0, 1388, 1399, 5, 192, 0, 0, 1389, 1399, 5, 193, 0, 0, 1390, 1391, 5, 90, 0, 0, 1391, 1399, 5, 184, 0, 0, 1392, 1393, 5, 90, 0, 0, 1393, 1399, 5, 185, 0, 0, 1394, 1395, 5, 90, 0, 0, 1395, 1399, 5, 186, 0, 0, 1396, 1397, 5, 90, 0, 0, 1397, 1399, 5, 187, 0, 0, 1398, 1377, 1, 0, 0, 0, 1398, 1378, 1, 0, 0, 0, 1398, 1379, 1, 0, 0, 0, 1398, 1380, 1, 0, 0, 0, 1398, 1381, 1, 0, 0, 0, 1398, 1382, 1, 0, 0, 0, 1398, 1383, 1, 0, 0, 0, 1398, 1384, 1, 0, 0, 0, 1398, 1385, 1, 0, 0, 0, 1398, 1386, 1, 0, 0, 0, 1398, 1387, 1, 0, 0, 0, 1398, 1388, 1, 0, 0, 0, 1398, 1389, 1, 0, 0, 0, 1398, 1390, 1, 0, 0, 0, 1398, 1392, 1, 0, 0, 0, 1398, 1394, 1, 0, 0, 0, 1398, 1396, 1, 0, 0, 0, 1399, 145, 1, 0, 0, 0, 1400, 1411, 1, 0, 0, 0, 1401, 1411, 5, 177, 0, 0, 1402, 1411, 3, 32, 16, 0, 1403, 1404, 3, 32, 16, 0, 1404, 1405, 5, 177, 0, 0, 1405, 1406, 3, 32, 16, 0, 1406, 1411, 1, 0, 0, 0, 1407, 1408, 3, 32, 16, 0, 1408, 1409, 5, 177, 0, 0, 1409, 1411, 1, 0, 0, 0, 1410, 1400, 1, 0, 0, 0, 1410, 1401, 1, 0, 0, 0, 1410, 1402, 1, 0, 0, 0, 1410, 1403, 1, 0, 0, 0, 1410, 1407, 1, 0, 0, 0, 1411, 147, 1, 0, 0, 0, 1412, 1413, 5, 1, 0, 0, 1413, 1414, 5, 194, 0, 0, 1414, 149, 1, 0, 0, 0, 1415, 1419, 5, 1, 0, 0, 1416, 1417, 5, 90, 0, 0, 1417, 1420, 5, 194, 0, 0, 1418, 1420, 5, 195, 0, 0, 1419, 1416, 1, 0, 0, 0, 1419, 1418, 1, 0, 0, 0, 1420, 151, 1, 0, 0, 0, 1421, 1422, 5, 294, 0, 0, 1422, 1423, 3, 166, 83, 0, 1423, 1424, 3, 124, 62, 0, 1424, 1425, 5, 30, 0, 0, 1425, 1426, 3, 158, 79, 0, 1426, 1427, 5, 31, 0, 0, 1427, 1469, 1, 0, 0, 0, 1428, 1429, 5, 294, 0, 0, 1429, 1430, 3, 166, 83, 0, 1430, 1431, 3, 124, 62, 0, 1431, 1432, 5, 36, 0, 0, 1432, 1433, 5, 17, 0, 0, 1433, 1434, 3, 52, 26, 0, 1434, 1435, 5, 18, 0, 0, 1435, 1469, 1, 0, 0, 0, 1436, 1437, 5, 294, 0, 0, 1437, 1438, 3, 166, 83, 0, 1438, 1439, 3, 124, 62, 0, 1439, 1469, 1, 0, 0, 0, 1440, 1441, 5, 295, 0, 0, 1441, 1442, 3, 166, 83, 0, 1442, 1444, 5, 36, 0, 0, 1443, 1445, 5, 84, 0, 0, 1444, 1443, 1, 0, 0, 0, 1444, 1445, 1, 0, 0, 0, 1445, 1446, 1, 0, 0, 0, 1446, 1447, 5, 30, 0, 0, 1447, 1448, 3, 292, 146, 0, 1448, 1449, 5, 31, 0, 0, 1449, 1469, 1, 0, 0, 0, 1450, 1451, 5, 295, 0, 0, 1451, 1452, 3, 166, 83, 0, 1452, 1453, 5, 84, 0, 0, 1453, 1454, 5, 30, 0, 0, 1454, 1455, 3, 292, 146, 0, 1455, 1456, 5, 31, 0, 0, 1456, 1469, 1, 0, 0, 0, 1457, 1458, 5, 295, 0, 0, 1458, 1459, 3, 166, 83, 0, 1459, 1460, 3, 6, 3, 0, 1460, 1469, 1, 0, 0, 0, 1461, 1462, 5, 295, 0, 0, 1462, 1463, 3, 166, 83, 0, 1463, 1464, 5, 36, 0, 0, 1464, 1465, 5, 17, 0, 0, 1465, 1466, 3, 154, 77, 0, 1466, 1467, 5, 18, 0, 0, 1467, 1469, 1, 0, 0, 0, 1468, 1421, 1, 0, 0, 0, 1468, 1428, 1, 0, 0, 0, 1468, 1436, 1, 0, 0, 0, 1468, 1440, 1, 0, 0, 0, 1468, 1450, 1, 0, 0, 0, 1468, 1457, 1, 0, 0, 0, 1468, 1461, 1, 0, 0, 0, 1469, 153, 1, 0, 0, 0, 1470, 1481, 1, 0, 0, 0, 1471, 1472, 3, 156, 78, 0, 1472, 1473, 5, 28, 0, 0, 1473, 1475, 1, 0, 0, 0, 1474, 1471, 1, 0, 0, 0, 1475, 1478, 1, 0, 0, 0, 1476, 1474, 1, 0, 0, 0, 1476, 1477, 1, 0, 0, 0, 1477, 1479, 1, 0, 0, 0, 1478, 1476, 1, 0, 0, 0, 1479, 1481, 3, 156, 78, 0, 1480, 1470, 1, 0, 0, 0, 1480, 1476, 1, 0, 0, 0, 1481, 155, 1, 0, 0, 0, 1482, 1483, 5, 39, 0, 0, 1483, 1484, 5, 264, 0, 0, 1484, 1485, 5, 36, 0, 0, 1485, 1486, 5, 17, 0, 0, 1486, 1487, 3, 56, 28, 0, 1487, 1488, 5, 18, 0, 0, 1488, 1496, 1, 0, 0, 0, 1489, 1490, 3, 124, 62, 0, 1490, 1491, 5, 36, 0, 0, 1491, 1492, 5, 17, 0, 0, 1492, 1493, 3, 56, 28, 0, 1493, 1494, 5, 18, 0, 0, 1494, 1496, 1, 0, 0, 0, 1495, 1482, 1, 0, 0, 0, 1495, 1489, 1, 0, 0, 0, 1496, 157, 1, 0, 0, 0, 1497, 1498, 3, 160, 80, 0, 1498, 1499, 5, 28, 0, 0, 1499, 1501, 1, 0, 0, 0, 1500, 1497, 1, 0, 0, 0, 1501, 1504, 1, 0, 0, 0, 1502, 1500, 1, 0, 0, 0, 1502, 1503, 1, 0, 0, 0, 1503, 1505, 1, 0, 0, 0, 1504, 1502, 1, 0, 0, 0, 1505, 1506, 3, 160, 80, 0, 1506, 159, 1, 0, 0, 0, 1507, 1508, 3, 6, 3, 0, 1508, 1509, 5, 36, 0, 0, 1509, 1510, 3, 164, 82, 0, 1510, 161, 1, 0, 0, 0, 1511, 1512, 7, 9, 0, 0, 1512, 163, 1, 0, 0, 0, 1513, 1548, 3, 162, 81, 0, 1514, 1548, 3, 32, 16, 0, 1515, 1516, 5, 186, 0, 0, 1516, 1517, 5, 30, 0, 0, 1517, 1518, 3, 32, 16, 0, 1518, 1519, 5, 31, 0, 0, 1519, 1548, 1, 0, 0, 0, 1520, 1548, 3, 6, 3, 0, 1521, 1522, 3, 116, 58, 0, 1522, 1523, 5, 30, 0, 0, 1523, 1524, 5, 184, 0, 0, 1524, 1525, 5, 75, 0, 0, 1525, 1526, 3, 32, 16, 0, 1526, 1527, 5, 31, 0, 0, 1527, 1548, 1, 0, 0, 0, 1528, 1529, 3, 116, 58, 0, 1529, 1530, 5, 30, 0, 0, 1530, 1531, 5, 185, 0, 0, 1531, 1532, 5, 75, 0, 0, 1532, 1533, 3, 32, 16, 0, 1533, 1534, 5, 31, 0, 0, 1534, 1548, 1, 0, 0, 0, 1535, 1536, 3, 116, 58, 0, 1536, 1537, 5, 30, 0, 0, 1537, 1538, 5, 186, 0, 0, 1538, 1539, 5, 75, 0, 0, 1539, 1540, 3, 32, 16, 0, 1540, 1541, 5, 31, 0, 0, 1541, 1548, 1, 0, 0, 0, 1542, 1543, 3, 116, 58, 0, 1543, 1544, 5, 30, 0, 0, 1544, 1545, 3, 32, 16, 0, 1545, 1546, 5, 31, 0, 0, 1546, 1548, 1, 0, 0, 0, 1547, 1513, 1, 0, 0, 0, 1547, 1514, 1, 0, 0, 0, 1547, 1515, 1, 0, 0, 0, 1547, 1520, 1, 0, 0, 0, 1547, 1521, 1, 0, 0, 0, 1547, 1528, 1, 0, 0, 0, 1547, 1535, 1, 0, 0, 0, 1547, 1542, 1, 0, 0, 0, 1548, 165, 1, 0, 0, 0, 1549, 1550, 7, 10, 0, 0, 1550, 167, 1, 0, 0, 0, 1551, 1552, 3, 170, 85, 0, 1552, 1553, 3, 138, 69, 0, 1553, 1554, 3, 124, 62, 0, 1554, 1555, 5, 176, 0, 0, 1555, 1557, 3, 242, 121, 0, 1556, 1558, 3, 108, 54, 0, 1557, 1556, 1, 0, 0, 0, 1557, 1558, 1, 0, 0, 0, 1558, 1559, 1, 0, 0, 0, 1559, 1560, 3, 112, 56, 0, 1560, 1586, 1, 0, 0, 0, 1561, 1562, 3, 170, 85, 0, 1562, 1563, 3, 138, 69, 0, 1563, 1564, 3, 124, 62, 0, 1564, 1565, 5, 176, 0, 0, 1565, 1566, 3, 242, 121, 0, 1566, 1567, 3, 196, 98, 0, 1567, 1568, 3, 112, 56, 0, 1568, 1586, 1, 0, 0, 0, 1569, 1570, 3, 170, 85, 0, 1570, 1571, 3, 138, 69, 0, 1571, 1573, 3, 242, 121, 0, 1572, 1574, 3, 108, 54, 0, 1573, 1572, 1, 0, 0, 0, 1573, 1574, 1, 0, 0, 0, 1574, 1575, 1, 0, 0, 0, 1575, 1576, 3, 112, 56, 0, 1576, 1586, 1, 0, 0, 0, 1577, 1578, 3, 170, 85, 0, 1578, 1579, 3, 138, 69, 0, 1579, 1580, 3, 242, 121, 0, 1580, 1581, 3, 196, 98, 0, 1581, 1582, 3, 112, 56, 0, 1582, 1586, 1, 0, 0, 0, 1583, 1586, 3, 174, 87, 0, 1584, 1586, 3, 2, 1, 0, 1585, 1551, 1, 0, 0, 0, 1585, 1561, 1, 0, 0, 0, 1585, 1569, 1, 0, 0, 0, 1585, 1577, 1, 0, 0, 0, 1585, 1583, 1, 0, 0, 0, 1585, 1584, 1, 0, 0, 0, 1586, 169, 1, 0, 0, 0, 1587, 1588, 5, 243, 0, 0, 1588, 1598, 3, 170, 85, 0, 1589, 1590, 5, 244, 0, 0, 1590, 1598, 3, 170, 85, 0, 1591, 1598, 3, 172, 86, 0, 1592, 1593, 5, 112, 0, 0, 1593, 1594, 5, 30, 0, 0, 1594, 1595, 3, 32, 16, 0, 1595, 1596, 5, 31, 0, 0, 1596, 1598, 1, 0, 0, 0, 1597, 1587, 1, 0, 0, 0, 1597, 1589, 1, 0, 0, 0, 1597, 1591, 1, 0, 0, 0, 1597, 1592, 1, 0, 0, 0, 1598, 171, 1, 0, 0, 0, 1599, 1612, 1, 0, 0, 0, 1600, 1612, 5, 245, 0, 0, 1601, 1612, 5, 246, 0, 0, 1602, 1603, 5, 247, 0, 0, 1603, 1612, 5, 248, 0, 0, 1604, 1605, 5, 247, 0, 0, 1605, 1612, 5, 249, 0, 0, 1606, 1607, 5, 247, 0, 0, 1607, 1612, 5, 250, 0, 0, 1608, 1609, 5, 247, 0, 0, 1609, 1612, 5, 251, 0, 0, 1610, 1612, 5, 247, 0, 0, 1611, 1599, 1, 0, 0, 0, 1611, 1600, 1, 0, 0, 0, 1611, 1601, 1, 0, 0, 0, 1611, 1602, 1, 0, 0, 0, 1611, 1604, 1, 0, 0, 0, 1611, 1606, 1, 0, 0, 0, 1611, 1608, 1, 0, 0, 0, 1611, 1610, 1, 0, 0, 0, 1612, 173, 1, 0, 0, 0, 1613, 1614, 5, 113, 0, 0, 1614, 1615, 5, 30, 0, 0, 1615, 1616, 3, 32, 16, 0, 1616, 1617, 5, 31, 0, 0, 1617, 175, 1, 0, 0, 0, 1618, 1619, 5, 226, 0, 0, 1619, 1624, 3, 168, 84, 0, 1620, 1621, 5, 37, 0, 0, 1621, 1624, 3, 178, 89, 0, 1622, 1624, 3, 174, 87, 0, 1623, 1618, 1, 0, 0, 0, 1623, 1620, 1, 0, 0, 0, 1623, 1622, 1, 0, 0, 0, 1624, 177, 1, 0, 0, 0, 1625, 1626, 3, 138, 69, 0, 1626, 1627, 3, 124, 62, 0, 1627, 1628, 5, 176, 0, 0, 1628, 1629, 3, 2, 1, 0, 1629, 1635, 1, 0, 0, 0, 1630, 1631, 3, 138, 69, 0, 1631, 1632, 3, 2, 1, 0, 1632, 1635, 1, 0, 0, 0, 1633, 1635, 3, 2, 1, 0, 1634, 1625, 1, 0, 0, 0, 1634, 1630, 1, 0, 0, 0, 1634, 1633, 1, 0, 0, 0, 1635, 179, 1, 0, 0, 0, 1636, 1637, 3, 124, 62, 0, 1637, 1638, 5, 28, 0, 0, 1638, 1640, 1, 0, 0, 0, 1639, 1636, 1, 0, 0, 0, 1640, 1643, 1, 0, 0, 0, 1641, 1639, 1, 0, 0, 0, 1641, 1642, 1, 0, 0, 0, 1642, 1644, 1, 0, 0, 0, 1643, 1641, 1, 0, 0, 0, 1644, 1645, 3, 124, 62, 0, 1645, 181, 1, 0, 0, 0, 1646, 1652, 1, 0, 0, 0, 1647, 1648, 5, 86, 0, 0, 1648, 1649, 3, 190, 95, 0, 1649, 1650, 5, 87, 0, 0, 1650, 1652, 1, 0, 0, 0, 1651, 1646, 1, 0, 0, 0, 1651, 1647, 1, 0, 0, 0, 1652, 183, 1, 0, 0, 0, 1653, 1665, 5, 266, 0, 0, 1654, 1665, 5, 114, 0, 0, 1655, 1665, 5, 39, 0, 0, 1656, 1665, 5, 200, 0, 0, 1657, 1665, 5, 115, 0, 0, 1658, 1665, 5, 116, 0, 0, 1659, 1660, 5, 70, 0, 0, 1660, 1661, 5, 30, 0, 0, 1661, 1662, 3, 32, 16, 0, 1662, 1663, 5, 31, 0, 0, 1663, 1665, 1, 0, 0, 0, 1664, 1653, 1, 0, 0, 0, 1664, 1654, 1, 0, 0, 0, 1664, 1655, 1, 0, 0, 0, 1664, 1656, 1, 0, 0, 0, 1664, 1657, 1, 0, 0, 0, 1664, 1658, 1, 0, 0, 0, 1664, 1659, 1, 0, 0, 0, 1665, 185, 1, 0, 0, 0, 1666, 1668, 3, 184, 92, 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, 187, 1, 0, 0, 0, 1671, 1669, 1, 0, 0, 0, 1672, 1674, 3, 186, 93, 0, 1673, 1675, 3, 192, 96, 0, 1674, 1673, 1, 0, 0, 0, 1674, 1675, 1, 0, 0, 0, 1675, 1676, 1, 0, 0, 0, 1676, 1677, 3, 2, 1, 0, 1677, 189, 1, 0, 0, 0, 1678, 1679, 3, 188, 94, 0, 1679, 1680, 5, 28, 0, 0, 1680, 1682, 1, 0, 0, 0, 1681, 1678, 1, 0, 0, 0, 1682, 1685, 1, 0, 0, 0, 1683, 1681, 1, 0, 0, 0, 1683, 1684, 1, 0, 0, 0, 1684, 1686, 1, 0, 0, 0, 1685, 1683, 1, 0, 0, 0, 1686, 1687, 3, 188, 94, 0, 1687, 191, 1, 0, 0, 0, 1688, 1689, 5, 30, 0, 0, 1689, 1690, 3, 180, 90, 0, 1690, 1691, 5, 31, 0, 0, 1691, 193, 1, 0, 0, 0, 1692, 1695, 1, 0, 0, 0, 1693, 1695, 3, 196, 98, 0, 1694, 1692, 1, 0, 0, 0, 1694, 1693, 1, 0, 0, 0, 1695, 195, 1, 0, 0, 0, 1696, 1697, 5, 86, 0, 0, 1697, 1698, 5, 42, 0, 0, 1698, 1699, 3, 32, 16, 0, 1699, 1700, 5, 43, 0, 0, 1700, 1701, 5, 87, 0, 0, 1701, 197, 1, 0, 0, 0, 1702, 1703, 3, 234, 117, 0, 1703, 1704, 5, 17, 0, 0, 1704, 1705, 3, 246, 123, 0, 1705, 1706, 5, 18, 0, 0, 1706, 1819, 1, 0, 0, 0, 1707, 1708, 3, 74, 37, 0, 1708, 1709, 5, 17, 0, 0, 1709, 1710, 3, 82, 41, 0, 1710, 1711, 5, 18, 0, 0, 1711, 1819, 1, 0, 0, 0, 1712, 1713, 3, 210, 105, 0, 1713, 1714, 5, 17, 0, 0, 1714, 1715, 3, 214, 107, 0, 1715, 1716, 5, 18, 0, 0, 1716, 1819, 1, 0, 0, 0, 1717, 1718, 3, 218, 109, 0, 1718, 1719, 5, 17, 0, 0, 1719, 1720, 3, 222, 111, 0, 1720, 1721, 5, 18, 0, 0, 1721, 1819, 1, 0, 0, 0, 1722, 1819, 3, 200, 100, 0, 1723, 1819, 3, 276, 138, 0, 1724, 1819, 3, 152, 76, 0, 1725, 1819, 3, 88, 44, 0, 1726, 1819, 3, 322, 161, 0, 1727, 1728, 5, 117, 0, 0, 1728, 1819, 3, 32, 16, 0, 1729, 1730, 5, 118, 0, 0, 1730, 1819, 3, 32, 16, 0, 1731, 1732, 3, 334, 167, 0, 1732, 1733, 5, 17, 0, 0, 1733, 1734, 3, 338, 169, 0, 1734, 1735, 5, 18, 0, 0, 1735, 1819, 1, 0, 0, 0, 1736, 1737, 5, 302, 0, 0, 1737, 1738, 3, 124, 62, 0, 1738, 1739, 5, 176, 0, 0, 1739, 1740, 3, 242, 121, 0, 1740, 1741, 5, 119, 0, 0, 1741, 1742, 3, 170, 85, 0, 1742, 1743, 3, 138, 69, 0, 1743, 1744, 3, 124, 62, 0, 1744, 1745, 5, 176, 0, 0, 1745, 1746, 3, 242, 121, 0, 1746, 1747, 3, 112, 56, 0, 1747, 1819, 1, 0, 0, 0, 1748, 1749, 5, 302, 0, 0, 1749, 1750, 5, 226, 0, 0, 1750, 1751, 3, 170, 85, 0, 1751, 1752, 3, 138, 69, 0, 1752, 1753, 3, 124, 62, 0, 1753, 1754, 5, 176, 0, 0, 1754, 1755, 3, 242, 121, 0, 1755, 1756, 3, 194, 97, 0, 1756, 1757, 3, 112, 56, 0, 1757, 1758, 5, 119, 0, 0, 1758, 1759, 5, 226, 0, 0, 1759, 1760, 3, 170, 85, 0, 1760, 1761, 3, 138, 69, 0, 1761, 1762, 3, 124, 62, 0, 1762, 1763, 5, 176, 0, 0, 1763, 1764, 3, 242, 121, 0, 1764, 1765, 3, 194, 97, 0, 1765, 1766, 3, 112, 56, 0, 1766, 1819, 1, 0, 0, 0, 1767, 1819, 3, 26, 13, 0, 1768, 1819, 3, 40, 20, 0, 1769, 1770, 5, 255, 0, 0, 1770, 1771, 5, 196, 0, 0, 1771, 1772, 5, 42, 0, 0, 1772, 1773, 3, 32, 16, 0, 1773, 1777, 5, 43, 0, 0, 1774, 1776, 3, 322, 161, 0, 1775, 1774, 1, 0, 0, 0, 1776, 1779, 1, 0, 0, 0, 1777, 1775, 1, 0, 0, 0, 1777, 1778, 1, 0, 0, 0, 1778, 1819, 1, 0, 0, 0, 1779, 1777, 1, 0, 0, 0, 1780, 1781, 5, 255, 0, 0, 1781, 1782, 5, 196, 0, 0, 1782, 1786, 3, 2, 1, 0, 1783, 1785, 3, 322, 161, 0, 1784, 1783, 1, 0, 0, 0, 1785, 1788, 1, 0, 0, 0, 1786, 1784, 1, 0, 0, 0, 1786, 1787, 1, 0, 0, 0, 1787, 1819, 1, 0, 0, 0, 1788, 1786, 1, 0, 0, 0, 1789, 1790, 5, 255, 0, 0, 1790, 1791, 5, 256, 0, 0, 1791, 1792, 5, 42, 0, 0, 1792, 1793, 3, 32, 16, 0, 1793, 1794, 5, 43, 0, 0, 1794, 1795, 5, 28, 0, 0, 1795, 1799, 3, 124, 62, 0, 1796, 1798, 3, 322, 161, 0, 1797, 1796, 1, 0, 0, 0, 1798, 1801, 1, 0, 0, 0, 1799, 1797, 1, 0, 0, 0, 1799, 1800, 1, 0, 0, 0, 1800, 1819, 1, 0, 0, 0, 1801, 1799, 1, 0, 0, 0, 1802, 1803, 5, 255, 0, 0, 1803, 1804, 5, 256, 0, 0, 1804, 1805, 3, 2, 1, 0, 1805, 1806, 5, 28, 0, 0, 1806, 1810, 3, 124, 62, 0, 1807, 1809, 3, 322, 161, 0, 1808, 1807, 1, 0, 0, 0, 1809, 1812, 1, 0, 0, 0, 1810, 1808, 1, 0, 0, 0, 1810, 1811, 1, 0, 0, 0, 1811, 1819, 1, 0, 0, 0, 1812, 1810, 1, 0, 0, 0, 1813, 1814, 5, 120, 0, 0, 1814, 1815, 5, 196, 0, 0, 1815, 1816, 3, 124, 62, 0, 1816, 1817, 3, 44, 22, 0, 1817, 1819, 1, 0, 0, 0, 1818, 1702, 1, 0, 0, 0, 1818, 1707, 1, 0, 0, 0, 1818, 1712, 1, 0, 0, 0, 1818, 1717, 1, 0, 0, 0, 1818, 1722, 1, 0, 0, 0, 1818, 1723, 1, 0, 0, 0, 1818, 1724, 1, 0, 0, 0, 1818, 1725, 1, 0, 0, 0, 1818, 1726, 1, 0, 0, 0, 1818, 1727, 1, 0, 0, 0, 1818, 1729, 1, 0, 0, 0, 1818, 1731, 1, 0, 0, 0, 1818, 1736, 1, 0, 0, 0, 1818, 1748, 1, 0, 0, 0, 1818, 1767, 1, 0, 0, 0, 1818, 1768, 1, 0, 0, 0, 1818, 1769, 1, 0, 0, 0, 1818, 1780, 1, 0, 0, 0, 1818, 1789, 1, 0, 0, 0, 1818, 1802, 1, 0, 0, 0, 1818, 1813, 1, 0, 0, 0, 1819, 199, 1, 0, 0, 0, 1820, 1821, 5, 121, 0, 0, 1821, 1830, 3, 208, 104, 0, 1822, 1829, 3, 202, 101, 0, 1823, 1824, 5, 122, 0, 0, 1824, 1825, 5, 30, 0, 0, 1825, 1826, 3, 228, 114, 0, 1826, 1827, 5, 31, 0, 0, 1827, 1829, 1, 0, 0, 0, 1828, 1822, 1, 0, 0, 0, 1828, 1823, 1, 0, 0, 0, 1829, 1832, 1, 0, 0, 0, 1830, 1828, 1, 0, 0, 0, 1830, 1831, 1, 0, 0, 0, 1831, 1833, 1, 0, 0, 0, 1832, 1830, 1, 0, 0, 0, 1833, 1834, 3, 138, 69, 0, 1834, 1835, 3, 2, 1, 0, 1835, 1836, 3, 204, 102, 0, 1836, 1837, 3, 206, 103, 0, 1837, 201, 1, 0, 0, 0, 1838, 1858, 5, 123, 0, 0, 1839, 1858, 5, 51, 0, 0, 1840, 1858, 5, 52, 0, 0, 1841, 1858, 5, 63, 0, 0, 1842, 1858, 5, 124, 0, 0, 1843, 1858, 5, 69, 0, 0, 1844, 1858, 5, 68, 0, 0, 1845, 1858, 5, 64, 0, 0, 1846, 1858, 5, 65, 0, 0, 1847, 1858, 5, 66, 0, 0, 1848, 1858, 5, 125, 0, 0, 1849, 1858, 5, 126, 0, 0, 1850, 1858, 5, 127, 0, 0, 1851, 1858, 5, 16, 0, 0, 1852, 1853, 5, 70, 0, 0, 1853, 1854, 5, 30, 0, 0, 1854, 1855, 3, 32, 16, 0, 1855, 1856, 5, 31, 0, 0, 1856, 1858, 1, 0, 0, 0, 1857, 1838, 1, 0, 0, 0, 1857, 1839, 1, 0, 0, 0, 1857, 1840, 1, 0, 0, 0, 1857, 1841, 1, 0, 0, 0, 1857, 1842, 1, 0, 0, 0, 1857, 1843, 1, 0, 0, 0, 1857, 1844, 1, 0, 0, 0, 1857, 1845, 1, 0, 0, 0, 1857, 1846, 1, 0, 0, 0, 1857, 1847, 1, 0, 0, 0, 1857, 1848, 1, 0, 0, 0, 1857, 1849, 1, 0, 0, 0, 1857, 1850, 1, 0, 0, 0, 1857, 1851, 1, 0, 0, 0, 1857, 1852, 1, 0, 0, 0, 1858, 203, 1, 0, 0, 0, 1859, 1865, 1, 0, 0, 0, 1860, 1861, 5, 44, 0, 0, 1861, 1865, 3, 0, 0, 0, 1862, 1863, 5, 44, 0, 0, 1863, 1865, 3, 32, 16, 0, 1864, 1859, 1, 0, 0, 0, 1864, 1860, 1, 0, 0, 0, 1864, 1862, 1, 0, 0, 0, 1865, 205, 1, 0, 0, 0, 1866, 1870, 1, 0, 0, 0, 1867, 1868, 5, 36, 0, 0, 1868, 1870, 3, 296, 148, 0, 1869, 1866, 1, 0, 0, 0, 1869, 1867, 1, 0, 0, 0, 1870, 207, 1, 0, 0, 0, 1871, 1877, 1, 0, 0, 0, 1872, 1873, 5, 42, 0, 0, 1873, 1874, 3, 32, 16, 0, 1874, 1875, 5, 43, 0, 0, 1875, 1877, 1, 0, 0, 0, 1876, 1871, 1, 0, 0, 0, 1876, 1872, 1, 0, 0, 0, 1877, 209, 1, 0, 0, 0, 1878, 1882, 5, 128, 0, 0, 1879, 1881, 3, 212, 106, 0, 1880, 1879, 1, 0, 0, 0, 1881, 1884, 1, 0, 0, 0, 1882, 1880, 1, 0, 0, 0, 1882, 1883, 1, 0, 0, 0, 1883, 1885, 1, 0, 0, 0, 1884, 1882, 1, 0, 0, 0, 1885, 1886, 3, 124, 62, 0, 1886, 1887, 3, 2, 1, 0, 1887, 1897, 1, 0, 0, 0, 1888, 1892, 5, 128, 0, 0, 1889, 1891, 3, 212, 106, 0, 1890, 1889, 1, 0, 0, 0, 1891, 1894, 1, 0, 0, 0, 1892, 1890, 1, 0, 0, 0, 1892, 1893, 1, 0, 0, 0, 1893, 1895, 1, 0, 0, 0, 1894, 1892, 1, 0, 0, 0, 1895, 1897, 3, 2, 1, 0, 1896, 1878, 1, 0, 0, 0, 1896, 1888, 1, 0, 0, 0, 1897, 211, 1, 0, 0, 0, 1898, 1899, 7, 11, 0, 0, 1899, 213, 1, 0, 0, 0, 1900, 1902, 3, 216, 108, 0, 1901, 1900, 1, 0, 0, 0, 1902, 1905, 1, 0, 0, 0, 1903, 1901, 1, 0, 0, 0, 1903, 1904, 1, 0, 0, 0, 1904, 215, 1, 0, 0, 0, 1905, 1903, 1, 0, 0, 0, 1906, 1907, 5, 129, 0, 0, 1907, 1919, 3, 168, 84, 0, 1908, 1909, 5, 130, 0, 0, 1909, 1919, 3, 168, 84, 0, 1910, 1911, 5, 131, 0, 0, 1911, 1919, 3, 168, 84, 0, 1912, 1913, 5, 132, 0, 0, 1913, 1919, 3, 168, 84, 0, 1914, 1919, 3, 88, 44, 0, 1915, 1919, 3, 322, 161, 0, 1916, 1919, 3, 26, 13, 0, 1917, 1919, 3, 40, 20, 0, 1918, 1906, 1, 0, 0, 0, 1918, 1908, 1, 0, 0, 0, 1918, 1910, 1, 0, 0, 0, 1918, 1912, 1, 0, 0, 0, 1918, 1914, 1, 0, 0, 0, 1918, 1915, 1, 0, 0, 0, 1918, 1916, 1, 0, 0, 0, 1918, 1917, 1, 0, 0, 0, 1919, 217, 1, 0, 0, 0, 1920, 1924, 5, 133, 0, 0, 1921, 1923, 3, 220, 110, 0, 1922, 1921, 1, 0, 0, 0, 1923, 1926, 1, 0, 0, 0, 1924, 1922, 1, 0, 0, 0, 1924, 1925, 1, 0, 0, 0, 1925, 1927, 1, 0, 0, 0, 1926, 1924, 1, 0, 0, 0, 1927, 1928, 3, 170, 85, 0, 1928, 1929, 3, 138, 69, 0, 1929, 1930, 3, 2, 1, 0, 1930, 1931, 3, 112, 56, 0, 1931, 1932, 3, 206, 103, 0, 1932, 219, 1, 0, 0, 0, 1933, 1934, 7, 11, 0, 0, 1934, 221, 1, 0, 0, 0, 1935, 1937, 3, 224, 112, 0, 1936, 1935, 1, 0, 0, 0, 1937, 1940, 1, 0, 0, 0, 1938, 1936, 1, 0, 0, 0, 1938, 1939, 1, 0, 0, 0, 1939, 223, 1, 0, 0, 0, 1940, 1938, 1, 0, 0, 0, 1941, 1942, 5, 134, 0, 0, 1942, 1952, 3, 168, 84, 0, 1943, 1944, 5, 135, 0, 0, 1944, 1952, 3, 168, 84, 0, 1945, 1946, 5, 132, 0, 0, 1946, 1952, 3, 168, 84, 0, 1947, 1952, 3, 322, 161, 0, 1948, 1952, 3, 88, 44, 0, 1949, 1952, 3, 26, 13, 0, 1950, 1952, 3, 40, 20, 0, 1951, 1941, 1, 0, 0, 0, 1951, 1943, 1, 0, 0, 0, 1951, 1945, 1, 0, 0, 0, 1951, 1947, 1, 0, 0, 0, 1951, 1948, 1, 0, 0, 0, 1951, 1949, 1, 0, 0, 0, 1951, 1950, 1, 0, 0, 0, 1952, 225, 1, 0, 0, 0, 1953, 1960, 1, 0, 0, 0, 1954, 1955, 5, 122, 0, 0, 1955, 1956, 5, 30, 0, 0, 1956, 1957, 3, 228, 114, 0, 1957, 1958, 5, 31, 0, 0, 1958, 1960, 1, 0, 0, 0, 1959, 1953, 1, 0, 0, 0, 1959, 1954, 1, 0, 0, 0, 1960, 227, 1, 0, 0, 0, 1961, 1971, 3, 126, 63, 0, 1962, 1964, 5, 17, 0, 0, 1963, 1965, 3, 294, 147, 0, 1964, 1963, 1, 0, 0, 0, 1965, 1966, 1, 0, 0, 0, 1966, 1964, 1, 0, 0, 0, 1966, 1967, 1, 0, 0, 0, 1967, 1968, 1, 0, 0, 0, 1968, 1969, 5, 18, 0, 0, 1969, 1971, 1, 0, 0, 0, 1970, 1961, 1, 0, 0, 0, 1970, 1962, 1, 0, 0, 0, 1971, 229, 1, 0, 0, 0, 1972, 1974, 3, 232, 116, 0, 1973, 1972, 1, 0, 0, 0, 1974, 1977, 1, 0, 0, 0, 1975, 1973, 1, 0, 0, 0, 1975, 1976, 1, 0, 0, 0, 1976, 231, 1, 0, 0, 0, 1977, 1975, 1, 0, 0, 0, 1978, 1979, 5, 42, 0, 0, 1979, 1980, 5, 136, 0, 0, 1980, 1992, 5, 43, 0, 0, 1981, 1982, 5, 42, 0, 0, 1982, 1983, 5, 137, 0, 0, 1983, 1992, 5, 43, 0, 0, 1984, 1985, 5, 42, 0, 0, 1985, 1986, 5, 138, 0, 0, 1986, 1992, 5, 43, 0, 0, 1987, 1988, 5, 42, 0, 0, 1988, 1989, 3, 32, 16, 0, 1989, 1990, 5, 43, 0, 0, 1990, 1992, 1, 0, 0, 0, 1991, 1978, 1, 0, 0, 0, 1991, 1981, 1, 0, 0, 0, 1991, 1984, 1, 0, 0, 0, 1991, 1987, 1, 0, 0, 0, 1992, 233, 1, 0, 0, 0, 1993, 1998, 5, 139, 0, 0, 1994, 1997, 3, 236, 118, 0, 1995, 1997, 3, 238, 119, 0, 1996, 1994, 1, 0, 0, 0, 1996, 1995, 1, 0, 0, 0, 1997, 2000, 1, 0, 0, 0, 1998, 1996, 1, 0, 0, 0, 1998, 1999, 1, 0, 0, 0, 1999, 2001, 1, 0, 0, 0, 2000, 1998, 1, 0, 0, 0, 2001, 2002, 3, 170, 85, 0, 2002, 2003, 3, 230, 115, 0, 2003, 2004, 3, 138, 69, 0, 2004, 2005, 3, 226, 113, 0, 2005, 2006, 3, 242, 121, 0, 2006, 2007, 3, 182, 91, 0, 2007, 2011, 3, 112, 56, 0, 2008, 2010, 3, 244, 122, 0, 2009, 2008, 1, 0, 0, 0, 2010, 2013, 1, 0, 0, 0, 2011, 2009, 1, 0, 0, 0, 2011, 2012, 1, 0, 0, 0, 2012, 235, 1, 0, 0, 0, 2013, 2011, 1, 0, 0, 0, 2014, 2038, 5, 123, 0, 0, 2015, 2038, 5, 51, 0, 0, 2016, 2038, 5, 52, 0, 0, 2017, 2038, 5, 63, 0, 0, 2018, 2038, 5, 140, 0, 0, 2019, 2038, 5, 68, 0, 0, 2020, 2038, 5, 141, 0, 0, 2021, 2038, 5, 142, 0, 0, 2022, 2038, 5, 54, 0, 0, 2023, 2038, 5, 64, 0, 0, 2024, 2038, 5, 65, 0, 0, 2025, 2038, 5, 66, 0, 0, 2026, 2038, 5, 125, 0, 0, 2027, 2038, 5, 143, 0, 0, 2028, 2038, 5, 144, 0, 0, 2029, 2038, 5, 69, 0, 0, 2030, 2038, 5, 145, 0, 0, 2031, 2038, 5, 146, 0, 0, 2032, 2033, 5, 70, 0, 0, 2033, 2034, 5, 30, 0, 0, 2034, 2035, 3, 32, 16, 0, 2035, 2036, 5, 31, 0, 0, 2036, 2038, 1, 0, 0, 0, 2037, 2014, 1, 0, 0, 0, 2037, 2015, 1, 0, 0, 0, 2037, 2016, 1, 0, 0, 0, 2037, 2017, 1, 0, 0, 0, 2037, 2018, 1, 0, 0, 0, 2037, 2019, 1, 0, 0, 0, 2037, 2020, 1, 0, 0, 0, 2037, 2021, 1, 0, 0, 0, 2037, 2022, 1, 0, 0, 0, 2037, 2023, 1, 0, 0, 0, 2037, 2024, 1, 0, 0, 0, 2037, 2025, 1, 0, 0, 0, 2037, 2026, 1, 0, 0, 0, 2037, 2027, 1, 0, 0, 0, 2037, 2028, 1, 0, 0, 0, 2037, 2029, 1, 0, 0, 0, 2037, 2030, 1, 0, 0, 0, 2037, 2031, 1, 0, 0, 0, 2037, 2032, 1, 0, 0, 0, 2038, 237, 1, 0, 0, 0, 2039, 2040, 5, 147, 0, 0, 2040, 2046, 5, 30, 0, 0, 2041, 2044, 3, 6, 3, 0, 2042, 2043, 5, 34, 0, 0, 2043, 2045, 3, 6, 3, 0, 2044, 2042, 1, 0, 0, 0, 2044, 2045, 1, 0, 0, 0, 2045, 2047, 1, 0, 0, 0, 2046, 2041, 1, 0, 0, 0, 2046, 2047, 1, 0, 0, 0, 2047, 2051, 1, 0, 0, 0, 2048, 2050, 3, 240, 120, 0, 2049, 2048, 1, 0, 0, 0, 2050, 2053, 1, 0, 0, 0, 2051, 2049, 1, 0, 0, 0, 2051, 2052, 1, 0, 0, 0, 2052, 2054, 1, 0, 0, 0, 2053, 2051, 1, 0, 0, 0, 2054, 2058, 5, 31, 0, 0, 2055, 2056, 5, 147, 0, 0, 2056, 2058, 5, 85, 0, 0, 2057, 2039, 1, 0, 0, 0, 2057, 2055, 1, 0, 0, 0, 2058, 239, 1, 0, 0, 0, 2059, 2087, 5, 148, 0, 0, 2060, 2087, 5, 224, 0, 0, 2061, 2087, 5, 57, 0, 0, 2062, 2087, 5, 58, 0, 0, 2063, 2087, 5, 149, 0, 0, 2064, 2087, 5, 150, 0, 0, 2065, 2087, 5, 248, 0, 0, 2066, 2087, 5, 249, 0, 0, 2067, 2087, 5, 250, 0, 0, 2068, 2087, 5, 251, 0, 0, 2069, 2070, 5, 151, 0, 0, 2070, 2071, 5, 75, 0, 0, 2071, 2087, 5, 152, 0, 0, 2072, 2073, 5, 151, 0, 0, 2073, 2074, 5, 75, 0, 0, 2074, 2087, 5, 153, 0, 0, 2075, 2076, 5, 154, 0, 0, 2076, 2077, 5, 75, 0, 0, 2077, 2087, 5, 152, 0, 0, 2078, 2079, 5, 154, 0, 0, 2079, 2080, 5, 75, 0, 0, 2080, 2087, 5, 153, 0, 0, 2081, 2082, 5, 70, 0, 0, 2082, 2083, 5, 30, 0, 0, 2083, 2084, 3, 32, 16, 0, 2084, 2085, 5, 31, 0, 0, 2085, 2087, 1, 0, 0, 0, 2086, 2059, 1, 0, 0, 0, 2086, 2060, 1, 0, 0, 0, 2086, 2061, 1, 0, 0, 0, 2086, 2062, 1, 0, 0, 0, 2086, 2063, 1, 0, 0, 0, 2086, 2064, 1, 0, 0, 0, 2086, 2065, 1, 0, 0, 0, 2086, 2066, 1, 0, 0, 0, 2086, 2067, 1, 0, 0, 0, 2086, 2068, 1, 0, 0, 0, 2086, 2069, 1, 0, 0, 0, 2086, 2072, 1, 0, 0, 0, 2086, 2075, 1, 0, 0, 0, 2086, 2078, 1, 0, 0, 0, 2086, 2081, 1, 0, 0, 0, 2087, 241, 1, 0, 0, 0, 2088, 2092, 5, 116, 0, 0, 2089, 2092, 5, 155, 0, 0, 2090, 2092, 3, 2, 1, 0, 2091, 2088, 1, 0, 0, 0, 2091, 2089, 1, 0, 0, 0, 2091, 2090, 1, 0, 0, 0, 2092, 243, 1, 0, 0, 0, 2093, 2115, 5, 1, 0, 0, 2094, 2115, 5, 2, 0, 0, 2095, 2115, 5, 156, 0, 0, 2096, 2115, 5, 3, 0, 0, 2097, 2115, 5, 4, 0, 0, 2098, 2115, 5, 247, 0, 0, 2099, 2115, 5, 5, 0, 0, 2100, 2115, 5, 6, 0, 0, 2101, 2115, 5, 7, 0, 0, 2102, 2115, 5, 8, 0, 0, 2103, 2115, 5, 9, 0, 0, 2104, 2115, 5, 10, 0, 0, 2105, 2115, 5, 11, 0, 0, 2106, 2115, 5, 12, 0, 0, 2107, 2115, 5, 13, 0, 0, 2108, 2115, 5, 14, 0, 0, 2109, 2110, 5, 70, 0, 0, 2110, 2111, 5, 30, 0, 0, 2111, 2112, 3, 32, 16, 0, 2112, 2113, 5, 31, 0, 0, 2113, 2115, 1, 0, 0, 0, 2114, 2093, 1, 0, 0, 0, 2114, 2094, 1, 0, 0, 0, 2114, 2095, 1, 0, 0, 0, 2114, 2096, 1, 0, 0, 0, 2114, 2097, 1, 0, 0, 0, 2114, 2098, 1, 0, 0, 0, 2114, 2099, 1, 0, 0, 0, 2114, 2100, 1, 0, 0, 0, 2114, 2101, 1, 0, 0, 0, 2114, 2102, 1, 0, 0, 0, 2114, 2103, 1, 0, 0, 0, 2114, 2104, 1, 0, 0, 0, 2114, 2105, 1, 0, 0, 0, 2114, 2106, 1, 0, 0, 0, 2114, 2107, 1, 0, 0, 0, 2114, 2108, 1, 0, 0, 0, 2114, 2109, 1, 0, 0, 0, 2115, 245, 1, 0, 0, 0, 2116, 2118, 3, 248, 124, 0, 2117, 2116, 1, 0, 0, 0, 2118, 2121, 1, 0, 0, 0, 2119, 2117, 1, 0, 0, 0, 2119, 2120, 1, 0, 0, 0, 2120, 247, 1, 0, 0, 0, 2121, 2119, 1, 0, 0, 0, 2122, 2140, 3, 100, 50, 0, 2123, 2124, 5, 296, 0, 0, 2124, 2125, 3, 32, 16, 0, 2125, 2126, 6, 124, -1, 0, 2126, 2140, 1, 0, 0, 0, 2127, 2140, 3, 258, 129, 0, 2128, 2129, 5, 297, 0, 0, 2129, 2130, 3, 32, 16, 0, 2130, 2131, 6, 124, -1, 0, 2131, 2140, 1, 0, 0, 0, 2132, 2133, 5, 298, 0, 0, 2133, 2140, 6, 124, -1, 0, 2134, 2135, 5, 299, 0, 0, 2135, 2140, 6, 124, -1, 0, 2136, 2140, 3, 252, 126, 0, 2137, 2140, 3, 256, 128, 0, 2138, 2140, 3, 250, 125, 0, 2139, 2122, 1, 0, 0, 0, 2139, 2123, 1, 0, 0, 0, 2139, 2127, 1, 0, 0, 0, 2139, 2128, 1, 0, 0, 0, 2139, 2132, 1, 0, 0, 0, 2139, 2134, 1, 0, 0, 0, 2139, 2136, 1, 0, 0, 0, 2139, 2137, 1, 0, 0, 0, 2139, 2138, 1, 0, 0, 0, 2140, 249, 1, 0, 0, 0, 2141, 2142, 5, 300, 0, 0, 2142, 2240, 3, 112, 56, 0, 2143, 2144, 5, 300, 0, 0, 2144, 2145, 5, 157, 0, 0, 2145, 2240, 3, 112, 56, 0, 2146, 2240, 3, 276, 138, 0, 2147, 2240, 3, 152, 76, 0, 2148, 2240, 3, 88, 44, 0, 2149, 2240, 3, 26, 13, 0, 2150, 2240, 3, 254, 127, 0, 2151, 2240, 3, 40, 20, 0, 2152, 2153, 5, 301, 0, 0, 2153, 2154, 5, 42, 0, 0, 2154, 2155, 3, 32, 16, 0, 2155, 2156, 5, 43, 0, 0, 2156, 2240, 1, 0, 0, 0, 2157, 2158, 5, 301, 0, 0, 2158, 2159, 5, 42, 0, 0, 2159, 2160, 3, 32, 16, 0, 2160, 2161, 5, 43, 0, 0, 2161, 2162, 5, 34, 0, 0, 2162, 2163, 3, 0, 0, 0, 2163, 2240, 1, 0, 0, 0, 2164, 2165, 5, 303, 0, 0, 2165, 2166, 3, 32, 16, 0, 2166, 2167, 5, 75, 0, 0, 2167, 2168, 3, 32, 16, 0, 2168, 2240, 1, 0, 0, 0, 2169, 2170, 5, 302, 0, 0, 2170, 2171, 3, 124, 62, 0, 2171, 2172, 5, 176, 0, 0, 2172, 2173, 3, 242, 121, 0, 2173, 2240, 1, 0, 0, 0, 2174, 2175, 5, 302, 0, 0, 2175, 2176, 5, 226, 0, 0, 2176, 2177, 3, 170, 85, 0, 2177, 2178, 3, 138, 69, 0, 2178, 2179, 3, 124, 62, 0, 2179, 2180, 5, 176, 0, 0, 2180, 2181, 3, 242, 121, 0, 2181, 2182, 3, 194, 97, 0, 2182, 2183, 3, 112, 56, 0, 2183, 2240, 1, 0, 0, 0, 2184, 2185, 5, 255, 0, 0, 2185, 2186, 5, 196, 0, 0, 2186, 2187, 5, 42, 0, 0, 2187, 2188, 3, 32, 16, 0, 2188, 2192, 5, 43, 0, 0, 2189, 2191, 3, 322, 161, 0, 2190, 2189, 1, 0, 0, 0, 2191, 2194, 1, 0, 0, 0, 2192, 2190, 1, 0, 0, 0, 2192, 2193, 1, 0, 0, 0, 2193, 2240, 1, 0, 0, 0, 2194, 2192, 1, 0, 0, 0, 2195, 2196, 5, 255, 0, 0, 2196, 2197, 5, 196, 0, 0, 2197, 2201, 3, 2, 1, 0, 2198, 2200, 3, 322, 161, 0, 2199, 2198, 1, 0, 0, 0, 2200, 2203, 1, 0, 0, 0, 2201, 2199, 1, 0, 0, 0, 2201, 2202, 1, 0, 0, 0, 2202, 2240, 1, 0, 0, 0, 2203, 2201, 1, 0, 0, 0, 2204, 2205, 5, 255, 0, 0, 2205, 2206, 5, 256, 0, 0, 2206, 2207, 5, 42, 0, 0, 2207, 2208, 3, 32, 16, 0, 2208, 2209, 5, 43, 0, 0, 2209, 2210, 5, 28, 0, 0, 2210, 2214, 3, 124, 62, 0, 2211, 2213, 3, 322, 161, 0, 2212, 2211, 1, 0, 0, 0, 2213, 2216, 1, 0, 0, 0, 2214, 2212, 1, 0, 0, 0, 2214, 2215, 1, 0, 0, 0, 2215, 2240, 1, 0, 0, 0, 2216, 2214, 1, 0, 0, 0, 2217, 2218, 5, 255, 0, 0, 2218, 2219, 5, 256, 0, 0, 2219, 2220, 3, 2, 1, 0, 2220, 2221, 5, 28, 0, 0, 2221, 2225, 3, 124, 62, 0, 2222, 2224, 3, 322, 161, 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, 2240, 1, 0, 0, 0, 2227, 2225, 1, 0, 0, 0, 2228, 2229, 5, 255, 0, 0, 2229, 2230, 5, 42, 0, 0, 2230, 2231, 3, 32, 16, 0, 2231, 2232, 5, 43, 0, 0, 2232, 2236, 3, 206, 103, 0, 2233, 2235, 3, 322, 161, 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, 2240, 1, 0, 0, 0, 2238, 2236, 1, 0, 0, 0, 2239, 2141, 1, 0, 0, 0, 2239, 2143, 1, 0, 0, 0, 2239, 2146, 1, 0, 0, 0, 2239, 2147, 1, 0, 0, 0, 2239, 2148, 1, 0, 0, 0, 2239, 2149, 1, 0, 0, 0, 2239, 2150, 1, 0, 0, 0, 2239, 2151, 1, 0, 0, 0, 2239, 2152, 1, 0, 0, 0, 2239, 2157, 1, 0, 0, 0, 2239, 2164, 1, 0, 0, 0, 2239, 2169, 1, 0, 0, 0, 2239, 2174, 1, 0, 0, 0, 2239, 2184, 1, 0, 0, 0, 2239, 2195, 1, 0, 0, 0, 2239, 2204, 1, 0, 0, 0, 2239, 2217, 1, 0, 0, 0, 2239, 2228, 1, 0, 0, 0, 2240, 251, 1, 0, 0, 0, 2241, 2242, 3, 0, 0, 0, 2242, 2243, 5, 75, 0, 0, 2243, 2244, 6, 126, -1, 0, 2244, 253, 1, 0, 0, 0, 2245, 2248, 3, 44, 22, 0, 2246, 2248, 3, 46, 23, 0, 2247, 2245, 1, 0, 0, 0, 2247, 2246, 1, 0, 0, 0, 2248, 255, 1, 0, 0, 0, 2249, 2250, 5, 17, 0, 0, 2250, 2251, 3, 246, 123, 0, 2251, 2252, 5, 18, 0, 0, 2252, 257, 1, 0, 0, 0, 2253, 2254, 3, 262, 131, 0, 2254, 2255, 3, 260, 130, 0, 2255, 259, 1, 0, 0, 0, 2256, 2258, 3, 264, 132, 0, 2257, 2256, 1, 0, 0, 0, 2258, 2259, 1, 0, 0, 0, 2259, 2257, 1, 0, 0, 0, 2259, 2260, 1, 0, 0, 0, 2260, 261, 1, 0, 0, 0, 2261, 2262, 5, 158, 0, 0, 2262, 2274, 3, 256, 128, 0, 2263, 2264, 5, 158, 0, 0, 2264, 2265, 3, 0, 0, 0, 2265, 2266, 5, 159, 0, 0, 2266, 2267, 3, 0, 0, 0, 2267, 2274, 1, 0, 0, 0, 2268, 2269, 5, 158, 0, 0, 2269, 2270, 3, 32, 16, 0, 2270, 2271, 5, 159, 0, 0, 2271, 2272, 3, 32, 16, 0, 2272, 2274, 1, 0, 0, 0, 2273, 2261, 1, 0, 0, 0, 2273, 2263, 1, 0, 0, 0, 2273, 2268, 1, 0, 0, 0, 2274, 263, 1, 0, 0, 0, 2275, 2276, 3, 268, 134, 0, 2276, 2277, 3, 274, 137, 0, 2277, 2288, 1, 0, 0, 0, 2278, 2279, 3, 266, 133, 0, 2279, 2280, 3, 274, 137, 0, 2280, 2288, 1, 0, 0, 0, 2281, 2282, 3, 270, 135, 0, 2282, 2283, 3, 274, 137, 0, 2283, 2288, 1, 0, 0, 0, 2284, 2285, 3, 272, 136, 0, 2285, 2286, 3, 274, 137, 0, 2286, 2288, 1, 0, 0, 0, 2287, 2275, 1, 0, 0, 0, 2287, 2278, 1, 0, 0, 0, 2287, 2281, 1, 0, 0, 0, 2287, 2284, 1, 0, 0, 0, 2288, 265, 1, 0, 0, 0, 2289, 2290, 5, 160, 0, 0, 2290, 2296, 3, 256, 128, 0, 2291, 2292, 5, 160, 0, 0, 2292, 2296, 3, 0, 0, 0, 2293, 2294, 5, 160, 0, 0, 2294, 2296, 3, 32, 16, 0, 2295, 2289, 1, 0, 0, 0, 2295, 2291, 1, 0, 0, 0, 2295, 2293, 1, 0, 0, 0, 2296, 267, 1, 0, 0, 0, 2297, 2298, 5, 161, 0, 0, 2298, 2299, 3, 124, 62, 0, 2299, 269, 1, 0, 0, 0, 2300, 2301, 5, 162, 0, 0, 2301, 271, 1, 0, 0, 0, 2302, 2303, 5, 163, 0, 0, 2303, 273, 1, 0, 0, 0, 2304, 2316, 3, 256, 128, 0, 2305, 2306, 5, 164, 0, 0, 2306, 2307, 3, 0, 0, 0, 2307, 2308, 5, 159, 0, 0, 2308, 2309, 3, 0, 0, 0, 2309, 2316, 1, 0, 0, 0, 2310, 2311, 5, 164, 0, 0, 2311, 2312, 3, 32, 16, 0, 2312, 2313, 5, 159, 0, 0, 2313, 2314, 3, 32, 16, 0, 2314, 2316, 1, 0, 0, 0, 2315, 2304, 1, 0, 0, 0, 2315, 2305, 1, 0, 0, 0, 2315, 2310, 1, 0, 0, 0, 2316, 275, 1, 0, 0, 0, 2317, 2318, 3, 278, 139, 0, 2318, 2319, 3, 282, 141, 0, 2319, 277, 1, 0, 0, 0, 2320, 2321, 5, 165, 0, 0, 2321, 2322, 3, 280, 140, 0, 2322, 2323, 3, 0, 0, 0, 2323, 2324, 5, 36, 0, 0, 2324, 2328, 1, 0, 0, 0, 2325, 2326, 5, 165, 0, 0, 2326, 2328, 3, 280, 140, 0, 2327, 2320, 1, 0, 0, 0, 2327, 2325, 1, 0, 0, 0, 2328, 279, 1, 0, 0, 0, 2329, 2333, 1, 0, 0, 0, 2330, 2333, 5, 166, 0, 0, 2331, 2333, 5, 2, 0, 0, 2332, 2329, 1, 0, 0, 0, 2332, 2330, 1, 0, 0, 0, 2332, 2331, 1, 0, 0, 0, 2333, 281, 1, 0, 0, 0, 2334, 2335, 5, 17, 0, 0, 2335, 2336, 3, 284, 142, 0, 2336, 2337, 5, 18, 0, 0, 2337, 2344, 1, 0, 0, 0, 2338, 2340, 3, 288, 144, 0, 2339, 2338, 1, 0, 0, 0, 2340, 2341, 1, 0, 0, 0, 2341, 2339, 1, 0, 0, 0, 2341, 2342, 1, 0, 0, 0, 2342, 2344, 1, 0, 0, 0, 2343, 2334, 1, 0, 0, 0, 2343, 2339, 1, 0, 0, 0, 2344, 283, 1, 0, 0, 0, 2345, 2346, 3, 288, 144, 0, 2346, 2347, 5, 28, 0, 0, 2347, 2349, 1, 0, 0, 0, 2348, 2345, 1, 0, 0, 0, 2349, 2352, 1, 0, 0, 0, 2350, 2348, 1, 0, 0, 0, 2350, 2351, 1, 0, 0, 0, 2351, 2353, 1, 0, 0, 0, 2352, 2350, 1, 0, 0, 0, 2353, 2354, 3, 288, 144, 0, 2354, 285, 1, 0, 0, 0, 2355, 2361, 1, 0, 0, 0, 2356, 2357, 5, 42, 0, 0, 2357, 2358, 3, 32, 16, 0, 2358, 2359, 5, 43, 0, 0, 2359, 2361, 1, 0, 0, 0, 2360, 2355, 1, 0, 0, 0, 2360, 2356, 1, 0, 0, 0, 2361, 287, 1, 0, 0, 0, 2362, 2363, 5, 181, 0, 0, 2363, 2364, 5, 262, 0, 0, 2364, 2365, 5, 30, 0, 0, 2365, 2366, 3, 6, 3, 0, 2366, 2367, 5, 31, 0, 0, 2367, 2429, 1, 0, 0, 0, 2368, 2369, 5, 260, 0, 0, 2369, 2370, 5, 30, 0, 0, 2370, 2371, 3, 0, 0, 0, 2371, 2372, 5, 31, 0, 0, 2372, 2429, 1, 0, 0, 0, 2373, 2374, 5, 260, 0, 0, 2374, 2429, 3, 0, 0, 0, 2375, 2376, 5, 84, 0, 0, 2376, 2377, 5, 30, 0, 0, 2377, 2378, 3, 292, 146, 0, 2378, 2379, 5, 31, 0, 0, 2379, 2429, 1, 0, 0, 0, 2380, 2381, 5, 188, 0, 0, 2381, 2382, 5, 30, 0, 0, 2382, 2383, 3, 36, 18, 0, 2383, 2384, 5, 31, 0, 0, 2384, 2385, 3, 286, 143, 0, 2385, 2429, 1, 0, 0, 0, 2386, 2387, 5, 189, 0, 0, 2387, 2388, 5, 30, 0, 0, 2388, 2389, 3, 36, 18, 0, 2389, 2390, 5, 31, 0, 0, 2390, 2391, 3, 286, 143, 0, 2391, 2429, 1, 0, 0, 0, 2392, 2393, 5, 187, 0, 0, 2393, 2394, 5, 30, 0, 0, 2394, 2395, 3, 34, 17, 0, 2395, 2396, 5, 31, 0, 0, 2396, 2397, 3, 286, 143, 0, 2397, 2429, 1, 0, 0, 0, 2398, 2399, 5, 186, 0, 0, 2399, 2400, 5, 30, 0, 0, 2400, 2401, 3, 32, 16, 0, 2401, 2402, 5, 31, 0, 0, 2402, 2403, 3, 286, 143, 0, 2403, 2429, 1, 0, 0, 0, 2404, 2405, 5, 185, 0, 0, 2405, 2406, 5, 30, 0, 0, 2406, 2407, 3, 32, 16, 0, 2407, 2408, 5, 31, 0, 0, 2408, 2409, 3, 286, 143, 0, 2409, 2429, 1, 0, 0, 0, 2410, 2411, 5, 184, 0, 0, 2411, 2412, 5, 30, 0, 0, 2412, 2413, 3, 32, 16, 0, 2413, 2414, 5, 31, 0, 0, 2414, 2415, 3, 286, 143, 0, 2415, 2429, 1, 0, 0, 0, 2416, 2417, 5, 188, 0, 0, 2417, 2429, 3, 286, 143, 0, 2418, 2419, 5, 189, 0, 0, 2419, 2429, 3, 286, 143, 0, 2420, 2421, 5, 187, 0, 0, 2421, 2429, 3, 286, 143, 0, 2422, 2423, 5, 186, 0, 0, 2423, 2429, 3, 286, 143, 0, 2424, 2425, 5, 185, 0, 0, 2425, 2429, 3, 286, 143, 0, 2426, 2427, 5, 184, 0, 0, 2427, 2429, 3, 286, 143, 0, 2428, 2362, 1, 0, 0, 0, 2428, 2368, 1, 0, 0, 0, 2428, 2373, 1, 0, 0, 0, 2428, 2375, 1, 0, 0, 0, 2428, 2380, 1, 0, 0, 0, 2428, 2386, 1, 0, 0, 0, 2428, 2392, 1, 0, 0, 0, 2428, 2398, 1, 0, 0, 0, 2428, 2404, 1, 0, 0, 0, 2428, 2410, 1, 0, 0, 0, 2428, 2416, 1, 0, 0, 0, 2428, 2418, 1, 0, 0, 0, 2428, 2420, 1, 0, 0, 0, 2428, 2422, 1, 0, 0, 0, 2428, 2424, 1, 0, 0, 0, 2428, 2426, 1, 0, 0, 0, 2429, 289, 1, 0, 0, 0, 2430, 2431, 5, 188, 0, 0, 2431, 2432, 5, 30, 0, 0, 2432, 2433, 3, 36, 18, 0, 2433, 2434, 5, 31, 0, 0, 2434, 2506, 1, 0, 0, 0, 2435, 2436, 5, 189, 0, 0, 2436, 2437, 5, 30, 0, 0, 2437, 2438, 3, 36, 18, 0, 2438, 2439, 5, 31, 0, 0, 2439, 2506, 1, 0, 0, 0, 2440, 2441, 5, 188, 0, 0, 2441, 2442, 5, 30, 0, 0, 2442, 2443, 3, 32, 16, 0, 2443, 2444, 5, 31, 0, 0, 2444, 2506, 1, 0, 0, 0, 2445, 2446, 5, 189, 0, 0, 2446, 2447, 5, 30, 0, 0, 2447, 2448, 3, 34, 17, 0, 2448, 2449, 5, 31, 0, 0, 2449, 2506, 1, 0, 0, 0, 2450, 2451, 5, 187, 0, 0, 2451, 2452, 5, 30, 0, 0, 2452, 2453, 3, 34, 17, 0, 2453, 2454, 5, 31, 0, 0, 2454, 2506, 1, 0, 0, 0, 2455, 2456, 5, 186, 0, 0, 2456, 2457, 5, 30, 0, 0, 2457, 2458, 3, 32, 16, 0, 2458, 2459, 5, 31, 0, 0, 2459, 2506, 1, 0, 0, 0, 2460, 2461, 5, 185, 0, 0, 2461, 2462, 5, 30, 0, 0, 2462, 2463, 3, 32, 16, 0, 2463, 2464, 5, 31, 0, 0, 2464, 2506, 1, 0, 0, 0, 2465, 2466, 5, 184, 0, 0, 2466, 2467, 5, 30, 0, 0, 2467, 2468, 3, 32, 16, 0, 2468, 2469, 5, 31, 0, 0, 2469, 2506, 1, 0, 0, 0, 2470, 2471, 5, 193, 0, 0, 2471, 2472, 5, 30, 0, 0, 2472, 2473, 3, 34, 17, 0, 2473, 2474, 5, 31, 0, 0, 2474, 2506, 1, 0, 0, 0, 2475, 2476, 5, 192, 0, 0, 2476, 2477, 5, 30, 0, 0, 2477, 2478, 3, 32, 16, 0, 2478, 2479, 5, 31, 0, 0, 2479, 2506, 1, 0, 0, 0, 2480, 2481, 5, 191, 0, 0, 2481, 2482, 5, 30, 0, 0, 2482, 2483, 3, 32, 16, 0, 2483, 2484, 5, 31, 0, 0, 2484, 2506, 1, 0, 0, 0, 2485, 2486, 5, 190, 0, 0, 2486, 2487, 5, 30, 0, 0, 2487, 2488, 3, 32, 16, 0, 2488, 2489, 5, 31, 0, 0, 2489, 2506, 1, 0, 0, 0, 2490, 2491, 5, 181, 0, 0, 2491, 2492, 5, 30, 0, 0, 2492, 2493, 3, 32, 16, 0, 2493, 2494, 5, 31, 0, 0, 2494, 2506, 1, 0, 0, 0, 2495, 2496, 5, 183, 0, 0, 2496, 2497, 5, 30, 0, 0, 2497, 2498, 3, 162, 81, 0, 2498, 2499, 5, 31, 0, 0, 2499, 2506, 1, 0, 0, 0, 2500, 2501, 5, 84, 0, 0, 2501, 2502, 5, 30, 0, 0, 2502, 2503, 3, 292, 146, 0, 2503, 2504, 5, 31, 0, 0, 2504, 2506, 1, 0, 0, 0, 2505, 2430, 1, 0, 0, 0, 2505, 2435, 1, 0, 0, 0, 2505, 2440, 1, 0, 0, 0, 2505, 2445, 1, 0, 0, 0, 2505, 2450, 1, 0, 0, 0, 2505, 2455, 1, 0, 0, 0, 2505, 2460, 1, 0, 0, 0, 2505, 2465, 1, 0, 0, 0, 2505, 2470, 1, 0, 0, 0, 2505, 2475, 1, 0, 0, 0, 2505, 2480, 1, 0, 0, 0, 2505, 2485, 1, 0, 0, 0, 2505, 2490, 1, 0, 0, 0, 2505, 2495, 1, 0, 0, 0, 2505, 2500, 1, 0, 0, 0, 2506, 291, 1, 0, 0, 0, 2507, 2508, 3, 294, 147, 0, 2508, 2509, 6, 146, -1, 0, 2509, 2511, 1, 0, 0, 0, 2510, 2507, 1, 0, 0, 0, 2511, 2514, 1, 0, 0, 0, 2512, 2510, 1, 0, 0, 0, 2512, 2513, 1, 0, 0, 0, 2513, 293, 1, 0, 0, 0, 2514, 2512, 1, 0, 0, 0, 2515, 2516, 7, 12, 0, 0, 2516, 295, 1, 0, 0, 0, 2517, 2521, 3, 290, 145, 0, 2518, 2521, 3, 6, 3, 0, 2519, 2521, 5, 179, 0, 0, 2520, 2517, 1, 0, 0, 0, 2520, 2518, 1, 0, 0, 0, 2520, 2519, 1, 0, 0, 0, 2521, 297, 1, 0, 0, 0, 2522, 2671, 3, 290, 145, 0, 2523, 2524, 5, 182, 0, 0, 2524, 2525, 5, 30, 0, 0, 2525, 2526, 5, 179, 0, 0, 2526, 2671, 5, 31, 0, 0, 2527, 2528, 5, 182, 0, 0, 2528, 2529, 5, 30, 0, 0, 2529, 2530, 5, 264, 0, 0, 2530, 2671, 5, 31, 0, 0, 2531, 2532, 5, 196, 0, 0, 2532, 2533, 5, 30, 0, 0, 2533, 2534, 5, 39, 0, 0, 2534, 2535, 5, 264, 0, 0, 2535, 2671, 5, 31, 0, 0, 2536, 2537, 5, 196, 0, 0, 2537, 2538, 5, 30, 0, 0, 2538, 2539, 3, 116, 58, 0, 2539, 2540, 5, 31, 0, 0, 2540, 2671, 1, 0, 0, 0, 2541, 2542, 5, 196, 0, 0, 2542, 2543, 5, 30, 0, 0, 2543, 2544, 5, 179, 0, 0, 2544, 2671, 5, 31, 0, 0, 2545, 2546, 5, 197, 0, 0, 2546, 2547, 5, 30, 0, 0, 2547, 2548, 3, 298, 149, 0, 2548, 2549, 5, 31, 0, 0, 2549, 2671, 1, 0, 0, 0, 2550, 2551, 5, 188, 0, 0, 2551, 2552, 5, 42, 0, 0, 2552, 2553, 3, 32, 16, 0, 2553, 2554, 5, 43, 0, 0, 2554, 2555, 5, 30, 0, 0, 2555, 2556, 3, 300, 150, 0, 2556, 2557, 5, 31, 0, 0, 2557, 2671, 1, 0, 0, 0, 2558, 2559, 5, 189, 0, 0, 2559, 2560, 5, 42, 0, 0, 2560, 2561, 3, 32, 16, 0, 2561, 2562, 5, 43, 0, 0, 2562, 2563, 5, 30, 0, 0, 2563, 2564, 3, 302, 151, 0, 2564, 2565, 5, 31, 0, 0, 2565, 2671, 1, 0, 0, 0, 2566, 2567, 5, 187, 0, 0, 2567, 2568, 5, 42, 0, 0, 2568, 2569, 3, 32, 16, 0, 2569, 2570, 5, 43, 0, 0, 2570, 2571, 5, 30, 0, 0, 2571, 2572, 3, 304, 152, 0, 2572, 2573, 5, 31, 0, 0, 2573, 2671, 1, 0, 0, 0, 2574, 2575, 5, 186, 0, 0, 2575, 2576, 5, 42, 0, 0, 2576, 2577, 3, 32, 16, 0, 2577, 2578, 5, 43, 0, 0, 2578, 2579, 5, 30, 0, 0, 2579, 2580, 3, 306, 153, 0, 2580, 2581, 5, 31, 0, 0, 2581, 2671, 1, 0, 0, 0, 2582, 2583, 5, 185, 0, 0, 2583, 2584, 5, 42, 0, 0, 2584, 2585, 3, 32, 16, 0, 2585, 2586, 5, 43, 0, 0, 2586, 2587, 5, 30, 0, 0, 2587, 2588, 3, 308, 154, 0, 2588, 2589, 5, 31, 0, 0, 2589, 2671, 1, 0, 0, 0, 2590, 2591, 5, 184, 0, 0, 2591, 2592, 5, 42, 0, 0, 2592, 2593, 3, 32, 16, 0, 2593, 2594, 5, 43, 0, 0, 2594, 2595, 5, 30, 0, 0, 2595, 2596, 3, 310, 155, 0, 2596, 2597, 5, 31, 0, 0, 2597, 2671, 1, 0, 0, 0, 2598, 2599, 5, 193, 0, 0, 2599, 2600, 5, 42, 0, 0, 2600, 2601, 3, 32, 16, 0, 2601, 2602, 5, 43, 0, 0, 2602, 2603, 5, 30, 0, 0, 2603, 2604, 3, 304, 152, 0, 2604, 2605, 5, 31, 0, 0, 2605, 2671, 1, 0, 0, 0, 2606, 2607, 5, 192, 0, 0, 2607, 2608, 5, 42, 0, 0, 2608, 2609, 3, 32, 16, 0, 2609, 2610, 5, 43, 0, 0, 2610, 2611, 5, 30, 0, 0, 2611, 2612, 3, 306, 153, 0, 2612, 2613, 5, 31, 0, 0, 2613, 2671, 1, 0, 0, 0, 2614, 2615, 5, 191, 0, 0, 2615, 2616, 5, 42, 0, 0, 2616, 2617, 3, 32, 16, 0, 2617, 2618, 5, 43, 0, 0, 2618, 2619, 5, 30, 0, 0, 2619, 2620, 3, 308, 154, 0, 2620, 2621, 5, 31, 0, 0, 2621, 2671, 1, 0, 0, 0, 2622, 2623, 5, 190, 0, 0, 2623, 2624, 5, 42, 0, 0, 2624, 2625, 3, 32, 16, 0, 2625, 2626, 5, 43, 0, 0, 2626, 2627, 5, 30, 0, 0, 2627, 2628, 3, 310, 155, 0, 2628, 2629, 5, 31, 0, 0, 2629, 2671, 1, 0, 0, 0, 2630, 2631, 5, 181, 0, 0, 2631, 2632, 5, 42, 0, 0, 2632, 2633, 3, 32, 16, 0, 2633, 2634, 5, 43, 0, 0, 2634, 2635, 5, 30, 0, 0, 2635, 2636, 3, 308, 154, 0, 2636, 2637, 5, 31, 0, 0, 2637, 2671, 1, 0, 0, 0, 2638, 2639, 5, 183, 0, 0, 2639, 2640, 5, 42, 0, 0, 2640, 2641, 3, 32, 16, 0, 2641, 2642, 5, 43, 0, 0, 2642, 2643, 5, 30, 0, 0, 2643, 2644, 3, 312, 156, 0, 2644, 2645, 5, 31, 0, 0, 2645, 2671, 1, 0, 0, 0, 2646, 2647, 5, 182, 0, 0, 2647, 2648, 5, 42, 0, 0, 2648, 2649, 3, 32, 16, 0, 2649, 2650, 5, 43, 0, 0, 2650, 2651, 5, 30, 0, 0, 2651, 2652, 3, 314, 157, 0, 2652, 2653, 5, 31, 0, 0, 2653, 2671, 1, 0, 0, 0, 2654, 2655, 5, 196, 0, 0, 2655, 2656, 5, 42, 0, 0, 2656, 2657, 3, 32, 16, 0, 2657, 2658, 5, 43, 0, 0, 2658, 2659, 5, 30, 0, 0, 2659, 2660, 3, 316, 158, 0, 2660, 2661, 5, 31, 0, 0, 2661, 2671, 1, 0, 0, 0, 2662, 2663, 5, 197, 0, 0, 2663, 2664, 5, 42, 0, 0, 2664, 2665, 3, 32, 16, 0, 2665, 2666, 5, 43, 0, 0, 2666, 2667, 5, 30, 0, 0, 2667, 2668, 3, 320, 160, 0, 2668, 2669, 5, 31, 0, 0, 2669, 2671, 1, 0, 0, 0, 2670, 2522, 1, 0, 0, 0, 2670, 2523, 1, 0, 0, 0, 2670, 2527, 1, 0, 0, 0, 2670, 2531, 1, 0, 0, 0, 2670, 2536, 1, 0, 0, 0, 2670, 2541, 1, 0, 0, 0, 2670, 2545, 1, 0, 0, 0, 2670, 2550, 1, 0, 0, 0, 2670, 2558, 1, 0, 0, 0, 2670, 2566, 1, 0, 0, 0, 2670, 2574, 1, 0, 0, 0, 2670, 2582, 1, 0, 0, 0, 2670, 2590, 1, 0, 0, 0, 2670, 2598, 1, 0, 0, 0, 2670, 2606, 1, 0, 0, 0, 2670, 2614, 1, 0, 0, 0, 2670, 2622, 1, 0, 0, 0, 2670, 2630, 1, 0, 0, 0, 2670, 2638, 1, 0, 0, 0, 2670, 2646, 1, 0, 0, 0, 2670, 2654, 1, 0, 0, 0, 2670, 2662, 1, 0, 0, 0, 2671, 299, 1, 0, 0, 0, 2672, 2675, 3, 36, 18, 0, 2673, 2675, 3, 32, 16, 0, 2674, 2672, 1, 0, 0, 0, 2674, 2673, 1, 0, 0, 0, 2675, 2678, 1, 0, 0, 0, 2676, 2674, 1, 0, 0, 0, 2676, 2677, 1, 0, 0, 0, 2677, 301, 1, 0, 0, 0, 2678, 2676, 1, 0, 0, 0, 2679, 2682, 3, 36, 18, 0, 2680, 2682, 3, 34, 17, 0, 2681, 2679, 1, 0, 0, 0, 2681, 2680, 1, 0, 0, 0, 2682, 2685, 1, 0, 0, 0, 2683, 2681, 1, 0, 0, 0, 2683, 2684, 1, 0, 0, 0, 2684, 303, 1, 0, 0, 0, 2685, 2683, 1, 0, 0, 0, 2686, 2688, 3, 34, 17, 0, 2687, 2686, 1, 0, 0, 0, 2688, 2691, 1, 0, 0, 0, 2689, 2687, 1, 0, 0, 0, 2689, 2690, 1, 0, 0, 0, 2690, 305, 1, 0, 0, 0, 2691, 2689, 1, 0, 0, 0, 2692, 2694, 3, 32, 16, 0, 2693, 2692, 1, 0, 0, 0, 2694, 2697, 1, 0, 0, 0, 2695, 2693, 1, 0, 0, 0, 2695, 2696, 1, 0, 0, 0, 2696, 307, 1, 0, 0, 0, 2697, 2695, 1, 0, 0, 0, 2698, 2700, 3, 32, 16, 0, 2699, 2698, 1, 0, 0, 0, 2700, 2703, 1, 0, 0, 0, 2701, 2699, 1, 0, 0, 0, 2701, 2702, 1, 0, 0, 0, 2702, 309, 1, 0, 0, 0, 2703, 2701, 1, 0, 0, 0, 2704, 2706, 3, 32, 16, 0, 2705, 2704, 1, 0, 0, 0, 2706, 2709, 1, 0, 0, 0, 2707, 2705, 1, 0, 0, 0, 2707, 2708, 1, 0, 0, 0, 2708, 311, 1, 0, 0, 0, 2709, 2707, 1, 0, 0, 0, 2710, 2712, 3, 162, 81, 0, 2711, 2710, 1, 0, 0, 0, 2712, 2715, 1, 0, 0, 0, 2713, 2711, 1, 0, 0, 0, 2713, 2714, 1, 0, 0, 0, 2714, 313, 1, 0, 0, 0, 2715, 2713, 1, 0, 0, 0, 2716, 2718, 7, 13, 0, 0, 2717, 2716, 1, 0, 0, 0, 2718, 2721, 1, 0, 0, 0, 2719, 2717, 1, 0, 0, 0, 2719, 2720, 1, 0, 0, 0, 2720, 315, 1, 0, 0, 0, 2721, 2719, 1, 0, 0, 0, 2722, 2724, 3, 318, 159, 0, 2723, 2722, 1, 0, 0, 0, 2724, 2727, 1, 0, 0, 0, 2725, 2723, 1, 0, 0, 0, 2725, 2726, 1, 0, 0, 0, 2726, 317, 1, 0, 0, 0, 2727, 2725, 1, 0, 0, 0, 2728, 2733, 5, 179, 0, 0, 2729, 2730, 5, 39, 0, 0, 2730, 2733, 5, 264, 0, 0, 2731, 2733, 3, 116, 58, 0, 2732, 2728, 1, 0, 0, 0, 2732, 2729, 1, 0, 0, 0, 2732, 2731, 1, 0, 0, 0, 2733, 319, 1, 0, 0, 0, 2734, 2736, 3, 298, 149, 0, 2735, 2734, 1, 0, 0, 0, 2736, 2739, 1, 0, 0, 0, 2737, 2735, 1, 0, 0, 0, 2737, 2738, 1, 0, 0, 0, 2738, 321, 1, 0, 0, 0, 2739, 2737, 1, 0, 0, 0, 2740, 2744, 3, 44, 22, 0, 2741, 2744, 3, 46, 23, 0, 2742, 2744, 3, 2, 1, 0, 2743, 2740, 1, 0, 0, 0, 2743, 2741, 1, 0, 0, 0, 2743, 2742, 1, 0, 0, 0, 2744, 323, 1, 0, 0, 0, 2745, 2746, 7, 14, 0, 0, 2746, 2747, 5, 36, 0, 0, 2747, 2748, 5, 30, 0, 0, 2748, 2749, 3, 292, 146, 0, 2749, 2750, 5, 31, 0, 0, 2750, 2771, 1, 0, 0, 0, 2751, 2752, 5, 169, 0, 0, 2752, 2753, 3, 38, 19, 0, 2753, 2754, 5, 75, 0, 0, 2754, 2755, 3, 38, 19, 0, 2755, 2756, 5, 75, 0, 0, 2756, 2757, 3, 38, 19, 0, 2757, 2758, 5, 75, 0, 0, 2758, 2759, 3, 38, 19, 0, 2759, 2771, 1, 0, 0, 0, 2760, 2761, 5, 170, 0, 0, 2761, 2771, 3, 6, 3, 0, 2762, 2763, 5, 170, 0, 0, 2763, 2764, 5, 36, 0, 0, 2764, 2765, 5, 30, 0, 0, 2765, 2766, 3, 292, 146, 0, 2766, 2767, 5, 31, 0, 0, 2767, 2771, 1, 0, 0, 0, 2768, 2771, 3, 322, 161, 0, 2769, 2771, 3, 40, 20, 0, 2770, 2745, 1, 0, 0, 0, 2770, 2751, 1, 0, 0, 0, 2770, 2760, 1, 0, 0, 0, 2770, 2762, 1, 0, 0, 0, 2770, 2768, 1, 0, 0, 0, 2770, 2769, 1, 0, 0, 0, 2771, 325, 1, 0, 0, 0, 2772, 2773, 5, 25, 0, 0, 2773, 2774, 5, 40, 0, 0, 2774, 2775, 3, 98, 49, 0, 2775, 2776, 3, 2, 1, 0, 2776, 2785, 1, 0, 0, 0, 2777, 2778, 5, 25, 0, 0, 2778, 2779, 5, 40, 0, 0, 2779, 2780, 3, 98, 49, 0, 2780, 2781, 3, 2, 1, 0, 2781, 2782, 5, 34, 0, 0, 2782, 2783, 3, 2, 1, 0, 2783, 2785, 1, 0, 0, 0, 2784, 2772, 1, 0, 0, 0, 2784, 2777, 1, 0, 0, 0, 2785, 327, 1, 0, 0, 0, 2786, 2788, 3, 330, 165, 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, 329, 1, 0, 0, 0, 2791, 2789, 1, 0, 0, 0, 2792, 2793, 5, 180, 0, 0, 2793, 2794, 5, 36, 0, 0, 2794, 2795, 5, 30, 0, 0, 2795, 2796, 3, 292, 146, 0, 2796, 2797, 5, 31, 0, 0, 2797, 2807, 1, 0, 0, 0, 2798, 2807, 3, 324, 162, 0, 2799, 2800, 5, 171, 0, 0, 2800, 2801, 5, 36, 0, 0, 2801, 2802, 5, 30, 0, 0, 2802, 2803, 3, 292, 146, 0, 2803, 2804, 5, 31, 0, 0, 2804, 2807, 1, 0, 0, 0, 2805, 2807, 5, 55, 0, 0, 2806, 2792, 1, 0, 0, 0, 2806, 2798, 1, 0, 0, 0, 2806, 2799, 1, 0, 0, 0, 2806, 2805, 1, 0, 0, 0, 2807, 331, 1, 0, 0, 0, 2808, 2809, 5, 50, 0, 0, 2809, 2813, 5, 40, 0, 0, 2810, 2812, 3, 336, 168, 0, 2811, 2810, 1, 0, 0, 0, 2812, 2815, 1, 0, 0, 0, 2813, 2811, 1, 0, 0, 0, 2813, 2814, 1, 0, 0, 0, 2814, 2816, 1, 0, 0, 0, 2815, 2813, 1, 0, 0, 0, 2816, 2817, 3, 2, 1, 0, 2817, 333, 1, 0, 0, 0, 2818, 2822, 5, 301, 0, 0, 2819, 2821, 3, 336, 168, 0, 2820, 2819, 1, 0, 0, 0, 2821, 2824, 1, 0, 0, 0, 2822, 2820, 1, 0, 0, 0, 2822, 2823, 1, 0, 0, 0, 2823, 2825, 1, 0, 0, 0, 2824, 2822, 1, 0, 0, 0, 2825, 2826, 3, 2, 1, 0, 2826, 335, 1, 0, 0, 0, 2827, 2843, 5, 52, 0, 0, 2828, 2843, 5, 51, 0, 0, 2829, 2843, 5, 172, 0, 0, 2830, 2831, 5, 62, 0, 0, 2831, 2843, 5, 51, 0, 0, 2832, 2833, 5, 62, 0, 0, 2833, 2843, 5, 52, 0, 0, 2834, 2835, 5, 62, 0, 0, 2835, 2843, 5, 63, 0, 0, 2836, 2837, 5, 62, 0, 0, 2837, 2843, 5, 64, 0, 0, 2838, 2839, 5, 62, 0, 0, 2839, 2843, 5, 65, 0, 0, 2840, 2841, 5, 62, 0, 0, 2841, 2843, 5, 66, 0, 0, 2842, 2827, 1, 0, 0, 0, 2842, 2828, 1, 0, 0, 0, 2842, 2829, 1, 0, 0, 0, 2842, 2830, 1, 0, 0, 0, 2842, 2832, 1, 0, 0, 0, 2842, 2834, 1, 0, 0, 0, 2842, 2836, 1, 0, 0, 0, 2842, 2838, 1, 0, 0, 0, 2842, 2840, 1, 0, 0, 0, 2843, 337, 1, 0, 0, 0, 2844, 2846, 3, 340, 170, 0, 2845, 2844, 1, 0, 0, 0, 2846, 2849, 1, 0, 0, 0, 2847, 2845, 1, 0, 0, 0, 2847, 2848, 1, 0, 0, 0, 2848, 339, 1, 0, 0, 0, 2849, 2847, 1, 0, 0, 0, 2850, 2851, 5, 21, 0, 0, 2851, 2864, 3, 2, 1, 0, 2852, 2853, 5, 50, 0, 0, 2853, 2854, 5, 40, 0, 0, 2854, 2864, 3, 118, 59, 0, 2855, 2856, 5, 25, 0, 0, 2856, 2857, 5, 40, 0, 0, 2857, 2864, 3, 2, 1, 0, 2858, 2864, 3, 174, 87, 0, 2859, 2860, 5, 50, 0, 0, 2860, 2864, 3, 32, 16, 0, 2861, 2864, 3, 322, 161, 0, 2862, 2864, 3, 40, 20, 0, 2863, 2850, 1, 0, 0, 0, 2863, 2852, 1, 0, 0, 0, 2863, 2855, 1, 0, 0, 0, 2863, 2858, 1, 0, 0, 0, 2863, 2859, 1, 0, 0, 0, 2863, 2861, 1, 0, 0, 0, 2863, 2862, 1, 0, 0, 0, 2864, 341, 1, 0, 0, 0, 2865, 2869, 5, 274, 0, 0, 2866, 2868, 3, 344, 172, 0, 2867, 2866, 1, 0, 0, 0, 2868, 2871, 1, 0, 0, 0, 2869, 2867, 1, 0, 0, 0, 2869, 2870, 1, 0, 0, 0, 2870, 2872, 1, 0, 0, 0, 2871, 2869, 1, 0, 0, 0, 2872, 2885, 3, 2, 1, 0, 2873, 2877, 5, 274, 0, 0, 2874, 2876, 3, 344, 172, 0, 2875, 2874, 1, 0, 0, 0, 2876, 2879, 1, 0, 0, 0, 2877, 2875, 1, 0, 0, 0, 2877, 2878, 1, 0, 0, 0, 2878, 2880, 1, 0, 0, 0, 2879, 2877, 1, 0, 0, 0, 2880, 2881, 3, 2, 1, 0, 2881, 2882, 5, 34, 0, 0, 2882, 2883, 3, 2, 1, 0, 2883, 2885, 1, 0, 0, 0, 2884, 2865, 1, 0, 0, 0, 2884, 2873, 1, 0, 0, 0, 2885, 343, 1, 0, 0, 0, 2886, 2887, 7, 15, 0, 0, 2887, 345, 1, 0, 0, 0, 2888, 2890, 3, 348, 174, 0, 2889, 2888, 1, 0, 0, 0, 2890, 2893, 1, 0, 0, 0, 2891, 2889, 1, 0, 0, 0, 2891, 2892, 1, 0, 0, 0, 2892, 347, 1, 0, 0, 0, 2893, 2891, 1, 0, 0, 0, 2894, 2895, 5, 21, 0, 0, 2895, 2896, 3, 2, 1, 0, 2896, 2897, 5, 44, 0, 0, 2897, 2898, 3, 32, 16, 0, 2898, 2905, 1, 0, 0, 0, 2899, 2900, 5, 25, 0, 0, 2900, 2901, 5, 40, 0, 0, 2901, 2905, 3, 2, 1, 0, 2902, 2905, 3, 322, 161, 0, 2903, 2905, 3, 40, 20, 0, 2904, 2894, 1, 0, 0, 0, 2904, 2899, 1, 0, 0, 0, 2904, 2902, 1, 0, 0, 0, 2904, 2903, 1, 0, 0, 0, 2905, 349, 1, 0, 0, 0, 176, 358, 363, 372, 381, 434, 475, 484, 514, 518, 536, 563, 586, 622, 628, 635, 637, 647, 649, 656, 667, 675, 696, 698, 714, 759, 764, 769, 774, 782, 892, 898, 914, 920, 926, 933, 938, 1016, 1018, 1035, 1044, 1050, 1059, 1061, 1069, 1081, 1093, 1100, 1107, 1109, 1136, 1143, 1151, 1159, 1172, 1179, 1182, 1201, 1295, 1304, 1311, 1314, 1322, 1343, 1375, 1398, 1410, 1419, 1444, 1468, 1476, 1480, 1495, 1502, 1547, 1557, 1573, 1585, 1597, 1611, 1623, 1634, 1641, 1651, 1664, 1669, 1674, 1683, 1694, 1777, 1786, 1799, 1810, 1818, 1828, 1830, 1857, 1864, 1869, 1876, 1882, 1892, 1896, 1903, 1918, 1924, 1938, 1951, 1959, 1966, 1970, 1975, 1991, 1996, 1998, 2011, 2037, 2044, 2046, 2051, 2057, 2086, 2091, 2114, 2119, 2139, 2192, 2201, 2214, 2225, 2236, 2239, 2247, 2259, 2273, 2287, 2295, 2315, 2327, 2332, 2341, 2343, 2350, 2360, 2428, 2505, 2512, 2520, 2670, 2674, 2676, 2681, 2683, 2689, 2695, 2701, 2707, 2713, 2719, 2725, 2732, 2737, 2743, 2770, 2784, 2789, 2806, 2813, 2822, 2842, 2847, 2863, 2869, 2877, 2884, 2891, 2904] \ No newline at end of file +[4, 1, 305, 2917, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 357, 8, 1, 10, 1, 12, 1, 360, 9, 1, 1, 1, 1, 1, 3, 1, 364, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 5, 3, 371, 8, 3, 10, 3, 12, 3, 374, 9, 3, 1, 3, 1, 3, 1, 3, 1, 4, 5, 4, 380, 8, 4, 10, 4, 12, 4, 383, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 435, 8, 5, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 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, 476, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 5, 15, 483, 8, 15, 10, 15, 12, 15, 486, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 515, 8, 18, 1, 19, 1, 19, 3, 19, 519, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 537, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 564, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 587, 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, 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, 623, 8, 23, 1, 24, 1, 24, 1, 25, 1, 25, 3, 25, 629, 8, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 5, 27, 636, 8, 27, 10, 27, 12, 27, 639, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 648, 8, 28, 10, 28, 12, 28, 651, 9, 28, 1, 29, 1, 29, 1, 30, 1, 30, 3, 30, 657, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 668, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 676, 8, 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, 34, 1, 34, 1, 34, 1, 34, 5, 34, 697, 8, 34, 10, 34, 12, 34, 700, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 5, 37, 713, 8, 37, 10, 37, 12, 37, 716, 9, 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, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 760, 8, 38, 1, 39, 1, 39, 1, 39, 3, 39, 765, 8, 39, 1, 40, 1, 40, 1, 40, 3, 40, 770, 8, 40, 1, 41, 5, 41, 773, 8, 41, 10, 41, 12, 41, 776, 9, 41, 1, 42, 1, 42, 1, 42, 5, 42, 781, 8, 42, 10, 42, 12, 42, 784, 9, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 893, 8, 44, 1, 45, 1, 45, 5, 45, 897, 8, 45, 10, 45, 12, 45, 900, 9, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 913, 8, 45, 10, 45, 12, 45, 916, 9, 45, 1, 45, 1, 45, 1, 45, 3, 45, 921, 8, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 927, 8, 47, 1, 48, 1, 48, 1, 49, 5, 49, 932, 8, 49, 10, 49, 12, 49, 935, 9, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 962, 8, 50, 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, 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, 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, 1040, 8, 51, 3, 51, 1042, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1055, 8, 53, 1, 53, 1, 53, 5, 53, 1059, 8, 53, 10, 53, 12, 53, 1062, 9, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1070, 8, 53, 3, 53, 1072, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1078, 8, 54, 10, 54, 12, 54, 1081, 9, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1090, 8, 55, 10, 55, 12, 55, 1093, 9, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 5, 56, 1102, 8, 56, 10, 56, 12, 56, 1105, 9, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1111, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 1118, 8, 57, 3, 57, 1120, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1147, 8, 58, 1, 59, 1, 59, 1, 59, 5, 59, 1152, 8, 59, 10, 59, 12, 59, 1155, 9, 59, 1, 59, 1, 59, 1, 60, 5, 60, 1160, 8, 60, 10, 60, 12, 60, 1163, 9, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1170, 8, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 3, 62, 1183, 8, 62, 1, 63, 1, 63, 1, 63, 5, 63, 1188, 8, 63, 10, 63, 12, 63, 1191, 9, 63, 3, 63, 1193, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 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, 1212, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1306, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1315, 8, 66, 1, 67, 1, 67, 1, 67, 5, 67, 1320, 8, 67, 10, 67, 12, 67, 1323, 9, 67, 3, 67, 1325, 8, 67, 1, 68, 1, 68, 1, 69, 1, 69, 5, 69, 1331, 8, 69, 10, 69, 12, 69, 1334, 9, 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, 1, 70, 1, 70, 1, 70, 3, 70, 1354, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1386, 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, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1409, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1421, 8, 73, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1430, 8, 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, 3, 76, 1455, 8, 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, 1479, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 5, 77, 1485, 8, 77, 10, 77, 12, 77, 1488, 9, 77, 1, 77, 3, 77, 1491, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1506, 8, 78, 1, 79, 1, 79, 1, 79, 5, 79, 1511, 8, 79, 10, 79, 12, 79, 1514, 9, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1558, 8, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1568, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1584, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1596, 8, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1608, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1622, 8, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 1634, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1645, 8, 89, 1, 90, 1, 90, 1, 90, 5, 90, 1650, 8, 90, 10, 90, 12, 90, 1653, 9, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 1662, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 1675, 8, 92, 1, 93, 5, 93, 1678, 8, 93, 10, 93, 12, 93, 1681, 9, 93, 1, 94, 1, 94, 3, 94, 1685, 8, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 5, 95, 1692, 8, 95, 10, 95, 12, 95, 1695, 9, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 3, 97, 1705, 8, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1786, 8, 99, 10, 99, 12, 99, 1789, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1795, 8, 99, 10, 99, 12, 99, 1798, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1808, 8, 99, 10, 99, 12, 99, 1811, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1819, 8, 99, 10, 99, 12, 99, 1822, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 1829, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 1839, 8, 100, 10, 100, 12, 100, 1842, 9, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 1868, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 1875, 8, 102, 1, 103, 1, 103, 1, 103, 3, 103, 1880, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 1887, 8, 104, 1, 105, 1, 105, 5, 105, 1891, 8, 105, 10, 105, 12, 105, 1894, 9, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 1901, 8, 105, 10, 105, 12, 105, 1904, 9, 105, 1, 105, 3, 105, 1907, 8, 105, 1, 106, 1, 106, 1, 107, 5, 107, 1912, 8, 107, 10, 107, 12, 107, 1915, 9, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 1929, 8, 108, 1, 109, 1, 109, 5, 109, 1933, 8, 109, 10, 109, 12, 109, 1936, 9, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 111, 5, 111, 1947, 8, 111, 10, 111, 12, 111, 1950, 9, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 1962, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 1970, 8, 113, 1, 114, 1, 114, 1, 114, 4, 114, 1975, 8, 114, 11, 114, 12, 114, 1976, 1, 114, 1, 114, 3, 114, 1981, 8, 114, 1, 115, 5, 115, 1984, 8, 115, 10, 115, 12, 115, 1987, 9, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 2002, 8, 116, 1, 117, 1, 117, 1, 117, 5, 117, 2007, 8, 117, 10, 117, 12, 117, 2010, 9, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2020, 8, 117, 10, 117, 12, 117, 2023, 9, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2048, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2055, 8, 119, 3, 119, 2057, 8, 119, 1, 119, 5, 119, 2060, 8, 119, 10, 119, 12, 119, 2063, 9, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2068, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2097, 8, 120, 1, 121, 1, 121, 1, 121, 3, 121, 2102, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2125, 8, 122, 1, 123, 5, 123, 2128, 8, 123, 10, 123, 12, 123, 2131, 9, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2150, 8, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2201, 8, 125, 10, 125, 12, 125, 2204, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2210, 8, 125, 10, 125, 12, 125, 2213, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2223, 8, 125, 10, 125, 12, 125, 2226, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2234, 8, 125, 10, 125, 12, 125, 2237, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2245, 8, 125, 10, 125, 12, 125, 2248, 9, 125, 3, 125, 2250, 8, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 3, 127, 2258, 8, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 130, 4, 130, 2268, 8, 130, 11, 130, 12, 130, 2269, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 2284, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 3, 132, 2298, 8, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 2306, 8, 133, 1, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 2326, 8, 137, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 2338, 8, 139, 1, 140, 1, 140, 1, 140, 3, 140, 2343, 8, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 4, 141, 2350, 8, 141, 11, 141, 12, 141, 2351, 3, 141, 2354, 8, 141, 1, 142, 1, 142, 1, 142, 5, 142, 2359, 8, 142, 10, 142, 12, 142, 2362, 9, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 2371, 8, 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, 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, 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, 2439, 8, 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, 145, 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, 145, 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, 145, 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, 145, 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, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 3, 145, 2516, 8, 145, 1, 146, 1, 146, 1, 146, 5, 146, 2521, 8, 146, 10, 146, 12, 146, 2524, 9, 146, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 3, 148, 2531, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 2681, 8, 149, 1, 150, 1, 150, 5, 150, 2685, 8, 150, 10, 150, 12, 150, 2688, 9, 150, 1, 151, 1, 151, 5, 151, 2692, 8, 151, 10, 151, 12, 151, 2695, 9, 151, 1, 152, 5, 152, 2698, 8, 152, 10, 152, 12, 152, 2701, 9, 152, 1, 153, 5, 153, 2704, 8, 153, 10, 153, 12, 153, 2707, 9, 153, 1, 154, 5, 154, 2710, 8, 154, 10, 154, 12, 154, 2713, 9, 154, 1, 155, 5, 155, 2716, 8, 155, 10, 155, 12, 155, 2719, 9, 155, 1, 156, 5, 156, 2722, 8, 156, 10, 156, 12, 156, 2725, 9, 156, 1, 157, 5, 157, 2728, 8, 157, 10, 157, 12, 157, 2731, 9, 157, 1, 158, 5, 158, 2734, 8, 158, 10, 158, 12, 158, 2737, 9, 158, 1, 159, 1, 159, 1, 159, 1, 159, 3, 159, 2743, 8, 159, 1, 160, 5, 160, 2746, 8, 160, 10, 160, 12, 160, 2749, 9, 160, 1, 161, 1, 161, 1, 161, 3, 161, 2754, 8, 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, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 3, 162, 2781, 8, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 2795, 8, 163, 1, 164, 5, 164, 2798, 8, 164, 10, 164, 12, 164, 2801, 9, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 3, 165, 2817, 8, 165, 1, 166, 1, 166, 1, 166, 5, 166, 2822, 8, 166, 10, 166, 12, 166, 2825, 9, 166, 1, 166, 1, 166, 1, 167, 1, 167, 5, 167, 2831, 8, 167, 10, 167, 12, 167, 2834, 9, 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, 168, 1, 168, 1, 168, 1, 168, 3, 168, 2853, 8, 168, 1, 169, 5, 169, 2856, 8, 169, 10, 169, 12, 169, 2859, 9, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 2874, 8, 170, 1, 171, 1, 171, 5, 171, 2878, 8, 171, 10, 171, 12, 171, 2881, 9, 171, 1, 171, 1, 171, 1, 171, 5, 171, 2886, 8, 171, 10, 171, 12, 171, 2889, 9, 171, 1, 171, 1, 171, 1, 171, 1, 171, 3, 171, 2895, 8, 171, 1, 172, 1, 172, 1, 173, 5, 173, 2900, 8, 173, 10, 173, 12, 173, 2903, 9, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 2915, 8, 174, 1, 174, 0, 1, 68, 175, 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, 0, 16, 6, 0, 1, 15, 199, 199, 243, 243, 247, 247, 264, 264, 289, 289, 5, 0, 16, 16, 199, 199, 243, 243, 264, 264, 288, 289, 1, 0, 263, 264, 1, 0, 173, 174, 1, 0, 37, 38, 1, 0, 73, 74, 3, 0, 2, 2, 61, 61, 77, 83, 2, 0, 229, 229, 260, 261, 9, 0, 178, 178, 183, 195, 201, 201, 207, 208, 210, 215, 218, 219, 222, 222, 230, 242, 262, 262, 1, 0, 95, 96, 1, 0, 97, 111, 1, 0, 68, 69, 2, 0, 173, 173, 289, 290, 2, 0, 179, 179, 264, 264, 1, 0, 167, 168, 1, 0, 51, 52, 3344, 0, 350, 1, 0, 0, 0, 2, 363, 1, 0, 0, 0, 4, 365, 1, 0, 0, 0, 6, 372, 1, 0, 0, 0, 8, 381, 1, 0, 0, 0, 10, 434, 1, 0, 0, 0, 12, 436, 1, 0, 0, 0, 14, 439, 1, 0, 0, 0, 16, 442, 1, 0, 0, 0, 18, 446, 1, 0, 0, 0, 20, 449, 1, 0, 0, 0, 22, 452, 1, 0, 0, 0, 24, 459, 1, 0, 0, 0, 26, 475, 1, 0, 0, 0, 28, 477, 1, 0, 0, 0, 30, 479, 1, 0, 0, 0, 32, 489, 1, 0, 0, 0, 34, 491, 1, 0, 0, 0, 36, 514, 1, 0, 0, 0, 38, 518, 1, 0, 0, 0, 40, 536, 1, 0, 0, 0, 42, 563, 1, 0, 0, 0, 44, 586, 1, 0, 0, 0, 46, 622, 1, 0, 0, 0, 48, 624, 1, 0, 0, 0, 50, 628, 1, 0, 0, 0, 52, 630, 1, 0, 0, 0, 54, 637, 1, 0, 0, 0, 56, 649, 1, 0, 0, 0, 58, 652, 1, 0, 0, 0, 60, 654, 1, 0, 0, 0, 62, 667, 1, 0, 0, 0, 64, 675, 1, 0, 0, 0, 66, 677, 1, 0, 0, 0, 68, 685, 1, 0, 0, 0, 70, 701, 1, 0, 0, 0, 72, 707, 1, 0, 0, 0, 74, 710, 1, 0, 0, 0, 76, 759, 1, 0, 0, 0, 78, 764, 1, 0, 0, 0, 80, 769, 1, 0, 0, 0, 82, 774, 1, 0, 0, 0, 84, 782, 1, 0, 0, 0, 86, 787, 1, 0, 0, 0, 88, 892, 1, 0, 0, 0, 90, 920, 1, 0, 0, 0, 92, 922, 1, 0, 0, 0, 94, 926, 1, 0, 0, 0, 96, 928, 1, 0, 0, 0, 98, 933, 1, 0, 0, 0, 100, 961, 1, 0, 0, 0, 102, 1041, 1, 0, 0, 0, 104, 1043, 1, 0, 0, 0, 106, 1071, 1, 0, 0, 0, 108, 1073, 1, 0, 0, 0, 110, 1085, 1, 0, 0, 0, 112, 1110, 1, 0, 0, 0, 114, 1119, 1, 0, 0, 0, 116, 1146, 1, 0, 0, 0, 118, 1153, 1, 0, 0, 0, 120, 1161, 1, 0, 0, 0, 122, 1169, 1, 0, 0, 0, 124, 1182, 1, 0, 0, 0, 126, 1192, 1, 0, 0, 0, 128, 1211, 1, 0, 0, 0, 130, 1305, 1, 0, 0, 0, 132, 1314, 1, 0, 0, 0, 134, 1324, 1, 0, 0, 0, 136, 1326, 1, 0, 0, 0, 138, 1328, 1, 0, 0, 0, 140, 1353, 1, 0, 0, 0, 142, 1385, 1, 0, 0, 0, 144, 1408, 1, 0, 0, 0, 146, 1420, 1, 0, 0, 0, 148, 1422, 1, 0, 0, 0, 150, 1425, 1, 0, 0, 0, 152, 1478, 1, 0, 0, 0, 154, 1490, 1, 0, 0, 0, 156, 1505, 1, 0, 0, 0, 158, 1512, 1, 0, 0, 0, 160, 1517, 1, 0, 0, 0, 162, 1521, 1, 0, 0, 0, 164, 1557, 1, 0, 0, 0, 166, 1559, 1, 0, 0, 0, 168, 1595, 1, 0, 0, 0, 170, 1607, 1, 0, 0, 0, 172, 1621, 1, 0, 0, 0, 174, 1623, 1, 0, 0, 0, 176, 1633, 1, 0, 0, 0, 178, 1644, 1, 0, 0, 0, 180, 1651, 1, 0, 0, 0, 182, 1661, 1, 0, 0, 0, 184, 1674, 1, 0, 0, 0, 186, 1679, 1, 0, 0, 0, 188, 1682, 1, 0, 0, 0, 190, 1693, 1, 0, 0, 0, 192, 1698, 1, 0, 0, 0, 194, 1704, 1, 0, 0, 0, 196, 1706, 1, 0, 0, 0, 198, 1828, 1, 0, 0, 0, 200, 1830, 1, 0, 0, 0, 202, 1867, 1, 0, 0, 0, 204, 1874, 1, 0, 0, 0, 206, 1879, 1, 0, 0, 0, 208, 1886, 1, 0, 0, 0, 210, 1906, 1, 0, 0, 0, 212, 1908, 1, 0, 0, 0, 214, 1913, 1, 0, 0, 0, 216, 1928, 1, 0, 0, 0, 218, 1930, 1, 0, 0, 0, 220, 1943, 1, 0, 0, 0, 222, 1948, 1, 0, 0, 0, 224, 1961, 1, 0, 0, 0, 226, 1969, 1, 0, 0, 0, 228, 1980, 1, 0, 0, 0, 230, 1985, 1, 0, 0, 0, 232, 2001, 1, 0, 0, 0, 234, 2003, 1, 0, 0, 0, 236, 2047, 1, 0, 0, 0, 238, 2067, 1, 0, 0, 0, 240, 2096, 1, 0, 0, 0, 242, 2101, 1, 0, 0, 0, 244, 2124, 1, 0, 0, 0, 246, 2129, 1, 0, 0, 0, 248, 2149, 1, 0, 0, 0, 250, 2249, 1, 0, 0, 0, 252, 2251, 1, 0, 0, 0, 254, 2257, 1, 0, 0, 0, 256, 2259, 1, 0, 0, 0, 258, 2263, 1, 0, 0, 0, 260, 2267, 1, 0, 0, 0, 262, 2283, 1, 0, 0, 0, 264, 2297, 1, 0, 0, 0, 266, 2305, 1, 0, 0, 0, 268, 2307, 1, 0, 0, 0, 270, 2310, 1, 0, 0, 0, 272, 2312, 1, 0, 0, 0, 274, 2325, 1, 0, 0, 0, 276, 2327, 1, 0, 0, 0, 278, 2337, 1, 0, 0, 0, 280, 2342, 1, 0, 0, 0, 282, 2353, 1, 0, 0, 0, 284, 2360, 1, 0, 0, 0, 286, 2370, 1, 0, 0, 0, 288, 2438, 1, 0, 0, 0, 290, 2515, 1, 0, 0, 0, 292, 2522, 1, 0, 0, 0, 294, 2525, 1, 0, 0, 0, 296, 2530, 1, 0, 0, 0, 298, 2680, 1, 0, 0, 0, 300, 2686, 1, 0, 0, 0, 302, 2693, 1, 0, 0, 0, 304, 2699, 1, 0, 0, 0, 306, 2705, 1, 0, 0, 0, 308, 2711, 1, 0, 0, 0, 310, 2717, 1, 0, 0, 0, 312, 2723, 1, 0, 0, 0, 314, 2729, 1, 0, 0, 0, 316, 2735, 1, 0, 0, 0, 318, 2742, 1, 0, 0, 0, 320, 2747, 1, 0, 0, 0, 322, 2753, 1, 0, 0, 0, 324, 2780, 1, 0, 0, 0, 326, 2794, 1, 0, 0, 0, 328, 2799, 1, 0, 0, 0, 330, 2816, 1, 0, 0, 0, 332, 2818, 1, 0, 0, 0, 334, 2828, 1, 0, 0, 0, 336, 2852, 1, 0, 0, 0, 338, 2857, 1, 0, 0, 0, 340, 2873, 1, 0, 0, 0, 342, 2894, 1, 0, 0, 0, 344, 2896, 1, 0, 0, 0, 346, 2901, 1, 0, 0, 0, 348, 2914, 1, 0, 0, 0, 350, 351, 7, 0, 0, 0, 351, 1, 1, 0, 0, 0, 352, 364, 5, 288, 0, 0, 353, 354, 3, 4, 2, 0, 354, 355, 5, 265, 0, 0, 355, 357, 1, 0, 0, 0, 356, 353, 1, 0, 0, 0, 357, 360, 1, 0, 0, 0, 358, 356, 1, 0, 0, 0, 358, 359, 1, 0, 0, 0, 359, 361, 1, 0, 0, 0, 360, 358, 1, 0, 0, 0, 361, 364, 3, 4, 2, 0, 362, 364, 5, 264, 0, 0, 363, 352, 1, 0, 0, 0, 363, 358, 1, 0, 0, 0, 363, 362, 1, 0, 0, 0, 364, 3, 1, 0, 0, 0, 365, 366, 7, 1, 0, 0, 366, 5, 1, 0, 0, 0, 367, 368, 5, 263, 0, 0, 368, 369, 6, 3, -1, 0, 369, 371, 5, 266, 0, 0, 370, 367, 1, 0, 0, 0, 371, 374, 1, 0, 0, 0, 372, 370, 1, 0, 0, 0, 372, 373, 1, 0, 0, 0, 373, 375, 1, 0, 0, 0, 374, 372, 1, 0, 0, 0, 375, 376, 5, 263, 0, 0, 376, 377, 6, 3, -1, 0, 377, 7, 1, 0, 0, 0, 378, 380, 3, 10, 5, 0, 379, 378, 1, 0, 0, 0, 380, 383, 1, 0, 0, 0, 381, 379, 1, 0, 0, 0, 381, 382, 1, 0, 0, 0, 382, 9, 1, 0, 0, 0, 383, 381, 1, 0, 0, 0, 384, 385, 3, 74, 37, 0, 385, 386, 5, 17, 0, 0, 386, 387, 3, 82, 41, 0, 387, 388, 5, 18, 0, 0, 388, 435, 1, 0, 0, 0, 389, 390, 3, 72, 36, 0, 390, 391, 5, 17, 0, 0, 391, 392, 3, 8, 4, 0, 392, 393, 5, 18, 0, 0, 393, 435, 1, 0, 0, 0, 394, 395, 3, 234, 117, 0, 395, 396, 5, 17, 0, 0, 396, 397, 3, 246, 123, 0, 397, 398, 5, 18, 0, 0, 398, 435, 1, 0, 0, 0, 399, 435, 3, 200, 100, 0, 400, 435, 3, 276, 138, 0, 401, 435, 3, 70, 35, 0, 402, 435, 3, 66, 33, 0, 403, 435, 3, 88, 44, 0, 404, 435, 3, 90, 45, 0, 405, 435, 3, 22, 11, 0, 406, 407, 3, 326, 163, 0, 407, 408, 5, 17, 0, 0, 408, 409, 3, 328, 164, 0, 409, 410, 5, 18, 0, 0, 410, 435, 1, 0, 0, 0, 411, 412, 3, 332, 166, 0, 412, 413, 5, 17, 0, 0, 413, 414, 3, 338, 169, 0, 414, 415, 5, 18, 0, 0, 415, 435, 1, 0, 0, 0, 416, 417, 3, 342, 171, 0, 417, 418, 5, 17, 0, 0, 418, 419, 3, 346, 173, 0, 419, 420, 5, 18, 0, 0, 420, 435, 1, 0, 0, 0, 421, 435, 3, 64, 32, 0, 422, 435, 3, 152, 76, 0, 423, 435, 3, 322, 161, 0, 424, 435, 3, 12, 6, 0, 425, 435, 3, 14, 7, 0, 426, 435, 3, 16, 8, 0, 427, 435, 3, 18, 9, 0, 428, 435, 3, 20, 10, 0, 429, 435, 3, 26, 13, 0, 430, 435, 3, 42, 21, 0, 431, 435, 3, 40, 20, 0, 432, 435, 3, 30, 15, 0, 433, 435, 3, 24, 12, 0, 434, 384, 1, 0, 0, 0, 434, 389, 1, 0, 0, 0, 434, 394, 1, 0, 0, 0, 434, 399, 1, 0, 0, 0, 434, 400, 1, 0, 0, 0, 434, 401, 1, 0, 0, 0, 434, 402, 1, 0, 0, 0, 434, 403, 1, 0, 0, 0, 434, 404, 1, 0, 0, 0, 434, 405, 1, 0, 0, 0, 434, 406, 1, 0, 0, 0, 434, 411, 1, 0, 0, 0, 434, 416, 1, 0, 0, 0, 434, 421, 1, 0, 0, 0, 434, 422, 1, 0, 0, 0, 434, 423, 1, 0, 0, 0, 434, 424, 1, 0, 0, 0, 434, 425, 1, 0, 0, 0, 434, 426, 1, 0, 0, 0, 434, 427, 1, 0, 0, 0, 434, 428, 1, 0, 0, 0, 434, 429, 1, 0, 0, 0, 434, 430, 1, 0, 0, 0, 434, 431, 1, 0, 0, 0, 434, 432, 1, 0, 0, 0, 434, 433, 1, 0, 0, 0, 435, 11, 1, 0, 0, 0, 436, 437, 5, 19, 0, 0, 437, 438, 3, 32, 16, 0, 438, 13, 1, 0, 0, 0, 439, 440, 5, 20, 0, 0, 440, 441, 3, 32, 16, 0, 441, 15, 1, 0, 0, 0, 442, 443, 5, 21, 0, 0, 443, 444, 5, 22, 0, 0, 444, 445, 3, 32, 16, 0, 445, 17, 1, 0, 0, 0, 446, 447, 5, 23, 0, 0, 447, 448, 3, 34, 17, 0, 448, 19, 1, 0, 0, 0, 449, 450, 5, 24, 0, 0, 450, 451, 3, 34, 17, 0, 451, 21, 1, 0, 0, 0, 452, 453, 5, 25, 0, 0, 453, 454, 3, 98, 49, 0, 454, 455, 3, 2, 1, 0, 455, 456, 5, 17, 0, 0, 456, 457, 3, 120, 60, 0, 457, 458, 5, 18, 0, 0, 458, 23, 1, 0, 0, 0, 459, 460, 5, 26, 0, 0, 460, 25, 1, 0, 0, 0, 461, 462, 5, 27, 0, 0, 462, 476, 3, 28, 14, 0, 463, 464, 5, 27, 0, 0, 464, 465, 3, 28, 14, 0, 465, 466, 5, 28, 0, 0, 466, 467, 3, 28, 14, 0, 467, 476, 1, 0, 0, 0, 468, 469, 5, 27, 0, 0, 469, 470, 3, 28, 14, 0, 470, 471, 5, 28, 0, 0, 471, 472, 3, 28, 14, 0, 472, 473, 5, 28, 0, 0, 473, 474, 3, 28, 14, 0, 474, 476, 1, 0, 0, 0, 475, 461, 1, 0, 0, 0, 475, 463, 1, 0, 0, 0, 475, 468, 1, 0, 0, 0, 476, 27, 1, 0, 0, 0, 477, 478, 7, 2, 0, 0, 478, 29, 1, 0, 0, 0, 479, 480, 5, 29, 0, 0, 480, 484, 5, 17, 0, 0, 481, 483, 3, 116, 58, 0, 482, 481, 1, 0, 0, 0, 483, 486, 1, 0, 0, 0, 484, 482, 1, 0, 0, 0, 484, 485, 1, 0, 0, 0, 485, 487, 1, 0, 0, 0, 486, 484, 1, 0, 0, 0, 487, 488, 5, 18, 0, 0, 488, 31, 1, 0, 0, 0, 489, 490, 5, 173, 0, 0, 490, 33, 1, 0, 0, 0, 491, 492, 7, 3, 0, 0, 492, 35, 1, 0, 0, 0, 493, 494, 5, 175, 0, 0, 494, 515, 6, 18, -1, 0, 495, 496, 3, 32, 16, 0, 496, 497, 5, 265, 0, 0, 497, 498, 6, 18, -1, 0, 498, 515, 1, 0, 0, 0, 499, 500, 3, 32, 16, 0, 500, 501, 6, 18, -1, 0, 501, 515, 1, 0, 0, 0, 502, 503, 5, 188, 0, 0, 503, 504, 5, 30, 0, 0, 504, 505, 3, 32, 16, 0, 505, 506, 5, 31, 0, 0, 506, 507, 6, 18, -1, 0, 507, 515, 1, 0, 0, 0, 508, 509, 5, 189, 0, 0, 509, 510, 5, 30, 0, 0, 510, 511, 3, 34, 17, 0, 511, 512, 5, 31, 0, 0, 512, 513, 6, 18, -1, 0, 513, 515, 1, 0, 0, 0, 514, 493, 1, 0, 0, 0, 514, 495, 1, 0, 0, 0, 514, 499, 1, 0, 0, 0, 514, 502, 1, 0, 0, 0, 514, 508, 1, 0, 0, 0, 515, 37, 1, 0, 0, 0, 516, 519, 3, 32, 16, 0, 517, 519, 5, 262, 0, 0, 518, 516, 1, 0, 0, 0, 518, 517, 1, 0, 0, 0, 519, 39, 1, 0, 0, 0, 520, 521, 5, 267, 0, 0, 521, 537, 5, 289, 0, 0, 522, 523, 5, 267, 0, 0, 523, 524, 5, 289, 0, 0, 524, 537, 5, 263, 0, 0, 525, 526, 5, 268, 0, 0, 526, 537, 5, 289, 0, 0, 527, 528, 5, 269, 0, 0, 528, 537, 5, 289, 0, 0, 529, 530, 5, 270, 0, 0, 530, 537, 5, 289, 0, 0, 531, 537, 5, 271, 0, 0, 532, 537, 5, 272, 0, 0, 533, 534, 5, 273, 0, 0, 534, 537, 5, 263, 0, 0, 535, 537, 5, 32, 0, 0, 536, 520, 1, 0, 0, 0, 536, 522, 1, 0, 0, 0, 536, 525, 1, 0, 0, 0, 536, 527, 1, 0, 0, 0, 536, 529, 1, 0, 0, 0, 536, 531, 1, 0, 0, 0, 536, 532, 1, 0, 0, 0, 536, 533, 1, 0, 0, 0, 536, 535, 1, 0, 0, 0, 537, 41, 1, 0, 0, 0, 538, 539, 5, 33, 0, 0, 539, 540, 3, 138, 69, 0, 540, 541, 5, 34, 0, 0, 541, 542, 3, 2, 1, 0, 542, 564, 1, 0, 0, 0, 543, 544, 5, 33, 0, 0, 544, 545, 3, 116, 58, 0, 545, 546, 5, 34, 0, 0, 546, 547, 3, 2, 1, 0, 547, 564, 1, 0, 0, 0, 548, 549, 5, 33, 0, 0, 549, 550, 3, 176, 88, 0, 550, 551, 5, 34, 0, 0, 551, 552, 3, 2, 1, 0, 552, 564, 1, 0, 0, 0, 553, 554, 5, 33, 0, 0, 554, 555, 3, 44, 22, 0, 555, 556, 5, 34, 0, 0, 556, 557, 3, 2, 1, 0, 557, 564, 1, 0, 0, 0, 558, 559, 5, 33, 0, 0, 559, 560, 3, 46, 23, 0, 560, 561, 5, 34, 0, 0, 561, 562, 3, 2, 1, 0, 562, 564, 1, 0, 0, 0, 563, 538, 1, 0, 0, 0, 563, 543, 1, 0, 0, 0, 563, 548, 1, 0, 0, 0, 563, 553, 1, 0, 0, 0, 563, 558, 1, 0, 0, 0, 564, 43, 1, 0, 0, 0, 565, 566, 5, 35, 0, 0, 566, 587, 3, 48, 24, 0, 567, 568, 5, 35, 0, 0, 568, 569, 3, 48, 24, 0, 569, 570, 5, 36, 0, 0, 570, 571, 3, 6, 3, 0, 571, 587, 1, 0, 0, 0, 572, 573, 5, 35, 0, 0, 573, 574, 3, 48, 24, 0, 574, 575, 5, 36, 0, 0, 575, 576, 5, 17, 0, 0, 576, 577, 3, 52, 26, 0, 577, 578, 5, 18, 0, 0, 578, 587, 1, 0, 0, 0, 579, 580, 5, 35, 0, 0, 580, 581, 3, 48, 24, 0, 581, 582, 5, 36, 0, 0, 582, 583, 5, 30, 0, 0, 583, 584, 3, 292, 146, 0, 584, 585, 5, 31, 0, 0, 585, 587, 1, 0, 0, 0, 586, 565, 1, 0, 0, 0, 586, 567, 1, 0, 0, 0, 586, 572, 1, 0, 0, 0, 586, 579, 1, 0, 0, 0, 587, 45, 1, 0, 0, 0, 588, 589, 5, 35, 0, 0, 589, 590, 5, 30, 0, 0, 590, 591, 3, 50, 25, 0, 591, 592, 5, 31, 0, 0, 592, 593, 3, 48, 24, 0, 593, 623, 1, 0, 0, 0, 594, 595, 5, 35, 0, 0, 595, 596, 5, 30, 0, 0, 596, 597, 3, 50, 25, 0, 597, 598, 5, 31, 0, 0, 598, 599, 3, 48, 24, 0, 599, 600, 5, 36, 0, 0, 600, 601, 3, 6, 3, 0, 601, 623, 1, 0, 0, 0, 602, 603, 5, 35, 0, 0, 603, 604, 5, 30, 0, 0, 604, 605, 3, 50, 25, 0, 605, 606, 5, 31, 0, 0, 606, 607, 3, 48, 24, 0, 607, 608, 5, 36, 0, 0, 608, 609, 5, 17, 0, 0, 609, 610, 3, 52, 26, 0, 610, 611, 5, 18, 0, 0, 611, 623, 1, 0, 0, 0, 612, 613, 5, 35, 0, 0, 613, 614, 5, 30, 0, 0, 614, 615, 3, 50, 25, 0, 615, 616, 5, 31, 0, 0, 616, 617, 3, 48, 24, 0, 617, 618, 5, 36, 0, 0, 618, 619, 5, 30, 0, 0, 619, 620, 3, 292, 146, 0, 620, 621, 5, 31, 0, 0, 621, 623, 1, 0, 0, 0, 622, 588, 1, 0, 0, 0, 622, 594, 1, 0, 0, 0, 622, 602, 1, 0, 0, 0, 622, 612, 1, 0, 0, 0, 623, 47, 1, 0, 0, 0, 624, 625, 3, 168, 84, 0, 625, 49, 1, 0, 0, 0, 626, 629, 3, 124, 62, 0, 627, 629, 3, 176, 88, 0, 628, 626, 1, 0, 0, 0, 628, 627, 1, 0, 0, 0, 629, 51, 1, 0, 0, 0, 630, 631, 3, 54, 27, 0, 631, 632, 3, 56, 28, 0, 632, 53, 1, 0, 0, 0, 633, 636, 3, 298, 149, 0, 634, 636, 3, 40, 20, 0, 635, 633, 1, 0, 0, 0, 635, 634, 1, 0, 0, 0, 636, 639, 1, 0, 0, 0, 637, 635, 1, 0, 0, 0, 637, 638, 1, 0, 0, 0, 638, 55, 1, 0, 0, 0, 639, 637, 1, 0, 0, 0, 640, 641, 3, 58, 29, 0, 641, 642, 3, 60, 30, 0, 642, 643, 3, 2, 1, 0, 643, 644, 5, 36, 0, 0, 644, 645, 3, 298, 149, 0, 645, 648, 1, 0, 0, 0, 646, 648, 3, 40, 20, 0, 647, 640, 1, 0, 0, 0, 647, 646, 1, 0, 0, 0, 648, 651, 1, 0, 0, 0, 649, 647, 1, 0, 0, 0, 649, 650, 1, 0, 0, 0, 650, 57, 1, 0, 0, 0, 651, 649, 1, 0, 0, 0, 652, 653, 7, 4, 0, 0, 653, 59, 1, 0, 0, 0, 654, 656, 3, 62, 31, 0, 655, 657, 5, 261, 0, 0, 656, 655, 1, 0, 0, 0, 656, 657, 1, 0, 0, 0, 657, 61, 1, 0, 0, 0, 658, 668, 3, 144, 72, 0, 659, 668, 3, 2, 1, 0, 660, 668, 5, 196, 0, 0, 661, 668, 5, 197, 0, 0, 662, 663, 5, 202, 0, 0, 663, 664, 5, 39, 0, 0, 664, 668, 5, 264, 0, 0, 665, 666, 5, 202, 0, 0, 666, 668, 3, 116, 58, 0, 667, 658, 1, 0, 0, 0, 667, 659, 1, 0, 0, 0, 667, 660, 1, 0, 0, 0, 667, 661, 1, 0, 0, 0, 667, 662, 1, 0, 0, 0, 667, 665, 1, 0, 0, 0, 668, 63, 1, 0, 0, 0, 669, 670, 5, 198, 0, 0, 670, 671, 5, 40, 0, 0, 671, 676, 3, 2, 1, 0, 672, 673, 5, 198, 0, 0, 673, 676, 3, 2, 1, 0, 674, 676, 5, 198, 0, 0, 675, 669, 1, 0, 0, 0, 675, 672, 1, 0, 0, 0, 675, 674, 1, 0, 0, 0, 676, 65, 1, 0, 0, 0, 677, 678, 5, 41, 0, 0, 678, 679, 5, 42, 0, 0, 679, 680, 3, 32, 16, 0, 680, 681, 5, 43, 0, 0, 681, 682, 3, 68, 34, 0, 682, 683, 5, 44, 0, 0, 683, 684, 3, 0, 0, 0, 684, 67, 1, 0, 0, 0, 685, 698, 6, 34, -1, 0, 686, 687, 10, 5, 0, 0, 687, 697, 5, 186, 0, 0, 688, 689, 10, 4, 0, 0, 689, 697, 5, 187, 0, 0, 690, 691, 10, 3, 0, 0, 691, 697, 5, 45, 0, 0, 692, 693, 10, 2, 0, 0, 693, 697, 5, 46, 0, 0, 694, 695, 10, 1, 0, 0, 695, 697, 5, 47, 0, 0, 696, 686, 1, 0, 0, 0, 696, 688, 1, 0, 0, 0, 696, 690, 1, 0, 0, 0, 696, 692, 1, 0, 0, 0, 696, 694, 1, 0, 0, 0, 697, 700, 1, 0, 0, 0, 698, 696, 1, 0, 0, 0, 698, 699, 1, 0, 0, 0, 699, 69, 1, 0, 0, 0, 700, 698, 1, 0, 0, 0, 701, 702, 5, 48, 0, 0, 702, 703, 5, 36, 0, 0, 703, 704, 5, 30, 0, 0, 704, 705, 3, 292, 146, 0, 705, 706, 5, 31, 0, 0, 706, 71, 1, 0, 0, 0, 707, 708, 5, 49, 0, 0, 708, 709, 3, 2, 1, 0, 709, 73, 1, 0, 0, 0, 710, 714, 5, 50, 0, 0, 711, 713, 3, 76, 38, 0, 712, 711, 1, 0, 0, 0, 713, 716, 1, 0, 0, 0, 714, 712, 1, 0, 0, 0, 714, 715, 1, 0, 0, 0, 715, 717, 1, 0, 0, 0, 716, 714, 1, 0, 0, 0, 717, 718, 3, 2, 1, 0, 718, 719, 3, 182, 91, 0, 719, 720, 3, 78, 39, 0, 720, 721, 3, 80, 40, 0, 721, 75, 1, 0, 0, 0, 722, 760, 5, 51, 0, 0, 723, 760, 5, 52, 0, 0, 724, 760, 5, 199, 0, 0, 725, 760, 5, 202, 0, 0, 726, 760, 5, 221, 0, 0, 727, 760, 5, 53, 0, 0, 728, 760, 5, 54, 0, 0, 729, 760, 5, 55, 0, 0, 730, 760, 5, 56, 0, 0, 731, 760, 5, 244, 0, 0, 732, 760, 5, 15, 0, 0, 733, 760, 5, 224, 0, 0, 734, 760, 5, 57, 0, 0, 735, 760, 5, 58, 0, 0, 736, 760, 5, 59, 0, 0, 737, 760, 5, 60, 0, 0, 738, 760, 5, 61, 0, 0, 739, 740, 5, 62, 0, 0, 740, 760, 5, 51, 0, 0, 741, 742, 5, 62, 0, 0, 742, 760, 5, 52, 0, 0, 743, 744, 5, 62, 0, 0, 744, 760, 5, 63, 0, 0, 745, 746, 5, 62, 0, 0, 746, 760, 5, 64, 0, 0, 747, 748, 5, 62, 0, 0, 748, 760, 5, 65, 0, 0, 749, 750, 5, 62, 0, 0, 750, 760, 5, 66, 0, 0, 751, 760, 5, 67, 0, 0, 752, 760, 5, 68, 0, 0, 753, 760, 5, 69, 0, 0, 754, 755, 5, 70, 0, 0, 755, 756, 5, 30, 0, 0, 756, 757, 3, 32, 16, 0, 757, 758, 5, 31, 0, 0, 758, 760, 1, 0, 0, 0, 759, 722, 1, 0, 0, 0, 759, 723, 1, 0, 0, 0, 759, 724, 1, 0, 0, 0, 759, 725, 1, 0, 0, 0, 759, 726, 1, 0, 0, 0, 759, 727, 1, 0, 0, 0, 759, 728, 1, 0, 0, 0, 759, 729, 1, 0, 0, 0, 759, 730, 1, 0, 0, 0, 759, 731, 1, 0, 0, 0, 759, 732, 1, 0, 0, 0, 759, 733, 1, 0, 0, 0, 759, 734, 1, 0, 0, 0, 759, 735, 1, 0, 0, 0, 759, 736, 1, 0, 0, 0, 759, 737, 1, 0, 0, 0, 759, 738, 1, 0, 0, 0, 759, 739, 1, 0, 0, 0, 759, 741, 1, 0, 0, 0, 759, 743, 1, 0, 0, 0, 759, 745, 1, 0, 0, 0, 759, 747, 1, 0, 0, 0, 759, 749, 1, 0, 0, 0, 759, 751, 1, 0, 0, 0, 759, 752, 1, 0, 0, 0, 759, 753, 1, 0, 0, 0, 759, 754, 1, 0, 0, 0, 760, 77, 1, 0, 0, 0, 761, 765, 1, 0, 0, 0, 762, 763, 5, 71, 0, 0, 763, 765, 3, 124, 62, 0, 764, 761, 1, 0, 0, 0, 764, 762, 1, 0, 0, 0, 765, 79, 1, 0, 0, 0, 766, 770, 1, 0, 0, 0, 767, 768, 5, 72, 0, 0, 768, 770, 3, 84, 42, 0, 769, 766, 1, 0, 0, 0, 769, 767, 1, 0, 0, 0, 770, 81, 1, 0, 0, 0, 771, 773, 3, 198, 99, 0, 772, 771, 1, 0, 0, 0, 773, 776, 1, 0, 0, 0, 774, 772, 1, 0, 0, 0, 774, 775, 1, 0, 0, 0, 775, 83, 1, 0, 0, 0, 776, 774, 1, 0, 0, 0, 777, 778, 3, 124, 62, 0, 778, 779, 5, 28, 0, 0, 779, 781, 1, 0, 0, 0, 780, 777, 1, 0, 0, 0, 781, 784, 1, 0, 0, 0, 782, 780, 1, 0, 0, 0, 782, 783, 1, 0, 0, 0, 783, 785, 1, 0, 0, 0, 784, 782, 1, 0, 0, 0, 785, 786, 3, 124, 62, 0, 786, 85, 1, 0, 0, 0, 787, 788, 7, 5, 0, 0, 788, 87, 1, 0, 0, 0, 789, 790, 3, 86, 43, 0, 790, 791, 3, 32, 16, 0, 791, 792, 5, 264, 0, 0, 792, 893, 1, 0, 0, 0, 793, 794, 3, 86, 43, 0, 794, 795, 3, 32, 16, 0, 795, 893, 1, 0, 0, 0, 796, 797, 3, 86, 43, 0, 797, 798, 3, 32, 16, 0, 798, 799, 5, 75, 0, 0, 799, 800, 3, 32, 16, 0, 800, 801, 5, 264, 0, 0, 801, 893, 1, 0, 0, 0, 802, 803, 3, 86, 43, 0, 803, 804, 3, 32, 16, 0, 804, 805, 5, 75, 0, 0, 805, 806, 3, 32, 16, 0, 806, 893, 1, 0, 0, 0, 807, 808, 3, 86, 43, 0, 808, 809, 3, 32, 16, 0, 809, 810, 5, 75, 0, 0, 810, 811, 3, 32, 16, 0, 811, 812, 5, 28, 0, 0, 812, 813, 3, 32, 16, 0, 813, 814, 5, 264, 0, 0, 814, 893, 1, 0, 0, 0, 815, 816, 3, 86, 43, 0, 816, 817, 3, 32, 16, 0, 817, 818, 5, 75, 0, 0, 818, 819, 3, 32, 16, 0, 819, 820, 5, 28, 0, 0, 820, 821, 3, 32, 16, 0, 821, 893, 1, 0, 0, 0, 822, 823, 3, 86, 43, 0, 823, 824, 3, 32, 16, 0, 824, 825, 5, 28, 0, 0, 825, 826, 3, 32, 16, 0, 826, 827, 5, 75, 0, 0, 827, 828, 3, 32, 16, 0, 828, 829, 5, 264, 0, 0, 829, 893, 1, 0, 0, 0, 830, 831, 3, 86, 43, 0, 831, 832, 3, 32, 16, 0, 832, 833, 5, 28, 0, 0, 833, 834, 3, 32, 16, 0, 834, 835, 5, 75, 0, 0, 835, 836, 3, 32, 16, 0, 836, 893, 1, 0, 0, 0, 837, 838, 3, 86, 43, 0, 838, 839, 3, 32, 16, 0, 839, 840, 5, 28, 0, 0, 840, 841, 3, 32, 16, 0, 841, 842, 5, 75, 0, 0, 842, 843, 3, 32, 16, 0, 843, 844, 5, 28, 0, 0, 844, 845, 3, 32, 16, 0, 845, 846, 5, 264, 0, 0, 846, 893, 1, 0, 0, 0, 847, 848, 3, 86, 43, 0, 848, 849, 3, 32, 16, 0, 849, 850, 5, 28, 0, 0, 850, 851, 3, 32, 16, 0, 851, 852, 5, 75, 0, 0, 852, 853, 3, 32, 16, 0, 853, 854, 5, 28, 0, 0, 854, 855, 3, 32, 16, 0, 855, 893, 1, 0, 0, 0, 856, 857, 3, 86, 43, 0, 857, 858, 3, 32, 16, 0, 858, 859, 5, 263, 0, 0, 859, 893, 1, 0, 0, 0, 860, 861, 3, 86, 43, 0, 861, 862, 3, 32, 16, 0, 862, 863, 5, 75, 0, 0, 863, 864, 3, 32, 16, 0, 864, 865, 5, 263, 0, 0, 865, 893, 1, 0, 0, 0, 866, 867, 3, 86, 43, 0, 867, 868, 3, 32, 16, 0, 868, 869, 5, 75, 0, 0, 869, 870, 3, 32, 16, 0, 870, 871, 5, 28, 0, 0, 871, 872, 3, 32, 16, 0, 872, 873, 5, 263, 0, 0, 873, 893, 1, 0, 0, 0, 874, 875, 3, 86, 43, 0, 875, 876, 3, 32, 16, 0, 876, 877, 5, 28, 0, 0, 877, 878, 3, 32, 16, 0, 878, 879, 5, 75, 0, 0, 879, 880, 3, 32, 16, 0, 880, 881, 5, 263, 0, 0, 881, 893, 1, 0, 0, 0, 882, 883, 3, 86, 43, 0, 883, 884, 3, 32, 16, 0, 884, 885, 5, 28, 0, 0, 885, 886, 3, 32, 16, 0, 886, 887, 5, 75, 0, 0, 887, 888, 3, 32, 16, 0, 888, 889, 5, 28, 0, 0, 889, 890, 3, 32, 16, 0, 890, 891, 5, 263, 0, 0, 891, 893, 1, 0, 0, 0, 892, 789, 1, 0, 0, 0, 892, 793, 1, 0, 0, 0, 892, 796, 1, 0, 0, 0, 892, 802, 1, 0, 0, 0, 892, 807, 1, 0, 0, 0, 892, 815, 1, 0, 0, 0, 892, 822, 1, 0, 0, 0, 892, 830, 1, 0, 0, 0, 892, 837, 1, 0, 0, 0, 892, 847, 1, 0, 0, 0, 892, 856, 1, 0, 0, 0, 892, 860, 1, 0, 0, 0, 892, 866, 1, 0, 0, 0, 892, 874, 1, 0, 0, 0, 892, 882, 1, 0, 0, 0, 893, 89, 1, 0, 0, 0, 894, 898, 5, 21, 0, 0, 895, 897, 3, 92, 46, 0, 896, 895, 1, 0, 0, 0, 897, 900, 1, 0, 0, 0, 898, 896, 1, 0, 0, 0, 898, 899, 1, 0, 0, 0, 899, 901, 1, 0, 0, 0, 900, 898, 1, 0, 0, 0, 901, 902, 3, 2, 1, 0, 902, 903, 3, 94, 47, 0, 903, 904, 5, 180, 0, 0, 904, 905, 5, 36, 0, 0, 905, 906, 5, 30, 0, 0, 906, 907, 3, 292, 146, 0, 907, 908, 5, 31, 0, 0, 908, 909, 3, 94, 47, 0, 909, 921, 1, 0, 0, 0, 910, 914, 5, 21, 0, 0, 911, 913, 3, 92, 46, 0, 912, 911, 1, 0, 0, 0, 913, 916, 1, 0, 0, 0, 914, 912, 1, 0, 0, 0, 914, 915, 1, 0, 0, 0, 915, 917, 1, 0, 0, 0, 916, 914, 1, 0, 0, 0, 917, 918, 3, 2, 1, 0, 918, 919, 3, 94, 47, 0, 919, 921, 1, 0, 0, 0, 920, 894, 1, 0, 0, 0, 920, 910, 1, 0, 0, 0, 921, 91, 1, 0, 0, 0, 922, 923, 5, 76, 0, 0, 923, 93, 1, 0, 0, 0, 924, 927, 1, 0, 0, 0, 925, 927, 5, 298, 0, 0, 926, 924, 1, 0, 0, 0, 926, 925, 1, 0, 0, 0, 927, 95, 1, 0, 0, 0, 928, 929, 7, 6, 0, 0, 929, 97, 1, 0, 0, 0, 930, 932, 3, 96, 48, 0, 931, 930, 1, 0, 0, 0, 932, 935, 1, 0, 0, 0, 933, 931, 1, 0, 0, 0, 933, 934, 1, 0, 0, 0, 934, 99, 1, 0, 0, 0, 935, 933, 1, 0, 0, 0, 936, 962, 3, 102, 51, 0, 937, 938, 5, 280, 0, 0, 938, 939, 3, 168, 84, 0, 939, 940, 6, 50, -1, 0, 940, 962, 1, 0, 0, 0, 941, 942, 5, 286, 0, 0, 942, 943, 3, 178, 89, 0, 943, 944, 6, 50, -1, 0, 944, 962, 1, 0, 0, 0, 945, 946, 5, 286, 0, 0, 946, 947, 3, 174, 87, 0, 947, 948, 6, 50, -1, 0, 948, 962, 1, 0, 0, 0, 949, 950, 5, 284, 0, 0, 950, 951, 3, 124, 62, 0, 951, 952, 6, 50, -1, 0, 952, 962, 1, 0, 0, 0, 953, 954, 5, 281, 0, 0, 954, 955, 3, 104, 52, 0, 955, 956, 6, 50, -1, 0, 956, 962, 1, 0, 0, 0, 957, 958, 5, 287, 0, 0, 958, 959, 3, 50, 25, 0, 959, 960, 6, 50, -1, 0, 960, 962, 1, 0, 0, 0, 961, 936, 1, 0, 0, 0, 961, 937, 1, 0, 0, 0, 961, 941, 1, 0, 0, 0, 961, 945, 1, 0, 0, 0, 961, 949, 1, 0, 0, 0, 961, 953, 1, 0, 0, 0, 961, 957, 1, 0, 0, 0, 962, 101, 1, 0, 0, 0, 963, 964, 5, 275, 0, 0, 964, 1042, 6, 51, -1, 0, 965, 966, 5, 276, 0, 0, 966, 967, 3, 32, 16, 0, 967, 968, 6, 51, -1, 0, 968, 1042, 1, 0, 0, 0, 969, 970, 5, 276, 0, 0, 970, 971, 3, 0, 0, 0, 971, 972, 6, 51, -1, 0, 972, 1042, 1, 0, 0, 0, 973, 974, 5, 277, 0, 0, 974, 975, 3, 32, 16, 0, 975, 976, 6, 51, -1, 0, 976, 1042, 1, 0, 0, 0, 977, 978, 5, 278, 0, 0, 978, 979, 3, 34, 17, 0, 979, 980, 6, 51, -1, 0, 980, 1042, 1, 0, 0, 0, 981, 982, 5, 279, 0, 0, 982, 983, 3, 36, 18, 0, 983, 984, 6, 51, -1, 0, 984, 1042, 1, 0, 0, 0, 985, 986, 5, 279, 0, 0, 986, 987, 3, 34, 17, 0, 987, 988, 6, 51, -1, 0, 988, 1042, 1, 0, 0, 0, 989, 990, 5, 279, 0, 0, 990, 991, 5, 30, 0, 0, 991, 992, 3, 292, 146, 0, 992, 993, 5, 31, 0, 0, 993, 994, 6, 51, -1, 0, 994, 1042, 1, 0, 0, 0, 995, 996, 5, 279, 0, 0, 996, 997, 5, 84, 0, 0, 997, 998, 5, 30, 0, 0, 998, 999, 3, 292, 146, 0, 999, 1000, 5, 31, 0, 0, 1000, 1001, 6, 51, -1, 0, 1001, 1042, 1, 0, 0, 0, 1002, 1003, 5, 282, 0, 0, 1003, 1004, 3, 32, 16, 0, 1004, 1005, 6, 51, -1, 0, 1005, 1042, 1, 0, 0, 0, 1006, 1007, 5, 282, 0, 0, 1007, 1008, 3, 0, 0, 0, 1008, 1009, 6, 51, -1, 0, 1009, 1042, 1, 0, 0, 0, 1010, 1011, 5, 285, 0, 0, 1011, 1012, 3, 6, 3, 0, 1012, 1013, 6, 51, -1, 0, 1013, 1042, 1, 0, 0, 0, 1014, 1015, 5, 285, 0, 0, 1015, 1016, 5, 224, 0, 0, 1016, 1017, 5, 30, 0, 0, 1017, 1018, 3, 6, 3, 0, 1018, 1019, 5, 31, 0, 0, 1019, 1020, 6, 51, -1, 0, 1020, 1042, 1, 0, 0, 0, 1021, 1022, 5, 285, 0, 0, 1022, 1023, 5, 84, 0, 0, 1023, 1024, 5, 30, 0, 0, 1024, 1025, 3, 292, 146, 0, 1025, 1026, 5, 31, 0, 0, 1026, 1027, 6, 51, -1, 0, 1027, 1042, 1, 0, 0, 0, 1028, 1029, 5, 287, 0, 0, 1029, 1030, 3, 32, 16, 0, 1030, 1031, 6, 51, -1, 0, 1031, 1042, 1, 0, 0, 0, 1032, 1033, 5, 283, 0, 0, 1033, 1039, 6, 51, -1, 0, 1034, 1035, 5, 30, 0, 0, 1035, 1036, 3, 106, 53, 0, 1036, 1037, 5, 31, 0, 0, 1037, 1040, 1, 0, 0, 0, 1038, 1040, 5, 85, 0, 0, 1039, 1034, 1, 0, 0, 0, 1039, 1038, 1, 0, 0, 0, 1040, 1042, 1, 0, 0, 0, 1041, 963, 1, 0, 0, 0, 1041, 965, 1, 0, 0, 0, 1041, 969, 1, 0, 0, 0, 1041, 973, 1, 0, 0, 0, 1041, 977, 1, 0, 0, 0, 1041, 981, 1, 0, 0, 0, 1041, 985, 1, 0, 0, 0, 1041, 989, 1, 0, 0, 0, 1041, 995, 1, 0, 0, 0, 1041, 1002, 1, 0, 0, 0, 1041, 1006, 1, 0, 0, 0, 1041, 1010, 1, 0, 0, 0, 1041, 1014, 1, 0, 0, 0, 1041, 1021, 1, 0, 0, 0, 1041, 1028, 1, 0, 0, 0, 1041, 1032, 1, 0, 0, 0, 1042, 103, 1, 0, 0, 0, 1043, 1044, 3, 170, 85, 0, 1044, 1045, 3, 138, 69, 0, 1045, 1046, 3, 112, 56, 0, 1046, 105, 1, 0, 0, 0, 1047, 1072, 1, 0, 0, 0, 1048, 1049, 3, 0, 0, 0, 1049, 1050, 6, 53, -1, 0, 1050, 1055, 1, 0, 0, 0, 1051, 1052, 3, 32, 16, 0, 1052, 1053, 6, 53, -1, 0, 1053, 1055, 1, 0, 0, 0, 1054, 1048, 1, 0, 0, 0, 1054, 1051, 1, 0, 0, 0, 1055, 1056, 1, 0, 0, 0, 1056, 1057, 5, 28, 0, 0, 1057, 1059, 1, 0, 0, 0, 1058, 1054, 1, 0, 0, 0, 1059, 1062, 1, 0, 0, 0, 1060, 1058, 1, 0, 0, 0, 1060, 1061, 1, 0, 0, 0, 1061, 1069, 1, 0, 0, 0, 1062, 1060, 1, 0, 0, 0, 1063, 1064, 3, 0, 0, 0, 1064, 1065, 6, 53, -1, 0, 1065, 1070, 1, 0, 0, 0, 1066, 1067, 3, 32, 16, 0, 1067, 1068, 6, 53, -1, 0, 1068, 1070, 1, 0, 0, 0, 1069, 1063, 1, 0, 0, 0, 1069, 1066, 1, 0, 0, 0, 1070, 1072, 1, 0, 0, 0, 1071, 1047, 1, 0, 0, 0, 1071, 1060, 1, 0, 0, 0, 1072, 107, 1, 0, 0, 0, 1073, 1079, 5, 86, 0, 0, 1074, 1075, 3, 138, 69, 0, 1075, 1076, 5, 28, 0, 0, 1076, 1078, 1, 0, 0, 0, 1077, 1074, 1, 0, 0, 0, 1078, 1081, 1, 0, 0, 0, 1079, 1077, 1, 0, 0, 0, 1079, 1080, 1, 0, 0, 0, 1080, 1082, 1, 0, 0, 0, 1081, 1079, 1, 0, 0, 0, 1082, 1083, 3, 138, 69, 0, 1083, 1084, 5, 87, 0, 0, 1084, 109, 1, 0, 0, 0, 1085, 1091, 5, 42, 0, 0, 1086, 1087, 3, 146, 73, 0, 1087, 1088, 5, 28, 0, 0, 1088, 1090, 1, 0, 0, 0, 1089, 1086, 1, 0, 0, 0, 1090, 1093, 1, 0, 0, 0, 1091, 1089, 1, 0, 0, 0, 1091, 1092, 1, 0, 0, 0, 1092, 1094, 1, 0, 0, 0, 1093, 1091, 1, 0, 0, 0, 1094, 1095, 3, 146, 73, 0, 1095, 1096, 5, 43, 0, 0, 1096, 111, 1, 0, 0, 0, 1097, 1103, 5, 30, 0, 0, 1098, 1099, 3, 114, 57, 0, 1099, 1100, 5, 28, 0, 0, 1100, 1102, 1, 0, 0, 0, 1101, 1098, 1, 0, 0, 0, 1102, 1105, 1, 0, 0, 0, 1103, 1101, 1, 0, 0, 0, 1103, 1104, 1, 0, 0, 0, 1104, 1106, 1, 0, 0, 0, 1105, 1103, 1, 0, 0, 0, 1106, 1107, 3, 114, 57, 0, 1107, 1108, 5, 31, 0, 0, 1108, 1111, 1, 0, 0, 0, 1109, 1111, 5, 85, 0, 0, 1110, 1097, 1, 0, 0, 0, 1110, 1109, 1, 0, 0, 0, 1111, 113, 1, 0, 0, 0, 1112, 1120, 5, 177, 0, 0, 1113, 1114, 3, 230, 115, 0, 1114, 1115, 3, 138, 69, 0, 1115, 1117, 3, 226, 113, 0, 1116, 1118, 3, 0, 0, 0, 1117, 1116, 1, 0, 0, 0, 1117, 1118, 1, 0, 0, 0, 1118, 1120, 1, 0, 0, 0, 1119, 1112, 1, 0, 0, 0, 1119, 1113, 1, 0, 0, 0, 1120, 115, 1, 0, 0, 0, 1121, 1122, 5, 42, 0, 0, 1122, 1123, 3, 2, 1, 0, 1123, 1124, 5, 43, 0, 0, 1124, 1125, 3, 118, 59, 0, 1125, 1147, 1, 0, 0, 0, 1126, 1127, 5, 42, 0, 0, 1127, 1128, 3, 174, 87, 0, 1128, 1129, 5, 43, 0, 0, 1129, 1130, 3, 118, 59, 0, 1130, 1147, 1, 0, 0, 0, 1131, 1132, 5, 42, 0, 0, 1132, 1133, 5, 262, 0, 0, 1133, 1134, 5, 43, 0, 0, 1134, 1147, 3, 118, 59, 0, 1135, 1136, 5, 42, 0, 0, 1136, 1137, 5, 198, 0, 0, 1137, 1138, 3, 2, 1, 0, 1138, 1139, 5, 43, 0, 0, 1139, 1140, 3, 118, 59, 0, 1140, 1147, 1, 0, 0, 0, 1141, 1147, 3, 118, 59, 0, 1142, 1147, 3, 174, 87, 0, 1143, 1147, 5, 257, 0, 0, 1144, 1147, 5, 258, 0, 0, 1145, 1147, 5, 259, 0, 0, 1146, 1121, 1, 0, 0, 0, 1146, 1126, 1, 0, 0, 0, 1146, 1131, 1, 0, 0, 0, 1146, 1135, 1, 0, 0, 0, 1146, 1141, 1, 0, 0, 0, 1146, 1142, 1, 0, 0, 0, 1146, 1143, 1, 0, 0, 0, 1146, 1144, 1, 0, 0, 0, 1146, 1145, 1, 0, 0, 0, 1147, 117, 1, 0, 0, 0, 1148, 1149, 3, 2, 1, 0, 1149, 1150, 5, 88, 0, 0, 1150, 1152, 1, 0, 0, 0, 1151, 1148, 1, 0, 0, 0, 1152, 1155, 1, 0, 0, 0, 1153, 1151, 1, 0, 0, 0, 1153, 1154, 1, 0, 0, 0, 1154, 1156, 1, 0, 0, 0, 1155, 1153, 1, 0, 0, 0, 1156, 1157, 3, 2, 1, 0, 1157, 119, 1, 0, 0, 0, 1158, 1160, 3, 122, 61, 0, 1159, 1158, 1, 0, 0, 0, 1160, 1163, 1, 0, 0, 0, 1161, 1159, 1, 0, 0, 0, 1161, 1162, 1, 0, 0, 0, 1162, 121, 1, 0, 0, 0, 1163, 1161, 1, 0, 0, 0, 1164, 1165, 5, 180, 0, 0, 1165, 1166, 5, 89, 0, 0, 1166, 1170, 3, 32, 16, 0, 1167, 1170, 3, 152, 76, 0, 1168, 1170, 3, 324, 162, 0, 1169, 1164, 1, 0, 0, 0, 1169, 1167, 1, 0, 0, 0, 1169, 1168, 1, 0, 0, 0, 1170, 123, 1, 0, 0, 0, 1171, 1183, 3, 116, 58, 0, 1172, 1173, 5, 42, 0, 0, 1173, 1174, 3, 2, 1, 0, 1174, 1175, 5, 43, 0, 0, 1175, 1183, 1, 0, 0, 0, 1176, 1177, 5, 42, 0, 0, 1177, 1178, 5, 198, 0, 0, 1178, 1179, 3, 2, 1, 0, 1179, 1180, 5, 43, 0, 0, 1180, 1183, 1, 0, 0, 0, 1181, 1183, 3, 138, 69, 0, 1182, 1171, 1, 0, 0, 0, 1182, 1172, 1, 0, 0, 0, 1182, 1176, 1, 0, 0, 0, 1182, 1181, 1, 0, 0, 0, 1183, 125, 1, 0, 0, 0, 1184, 1193, 1, 0, 0, 0, 1185, 1189, 3, 130, 65, 0, 1186, 1188, 3, 128, 64, 0, 1187, 1186, 1, 0, 0, 0, 1188, 1191, 1, 0, 0, 0, 1189, 1187, 1, 0, 0, 0, 1189, 1190, 1, 0, 0, 0, 1190, 1193, 1, 0, 0, 0, 1191, 1189, 1, 0, 0, 0, 1192, 1184, 1, 0, 0, 0, 1192, 1185, 1, 0, 0, 0, 1193, 127, 1, 0, 0, 0, 1194, 1212, 5, 262, 0, 0, 1195, 1212, 5, 261, 0, 0, 1196, 1197, 5, 42, 0, 0, 1197, 1198, 3, 32, 16, 0, 1198, 1199, 5, 43, 0, 0, 1199, 1212, 1, 0, 0, 0, 1200, 1201, 5, 42, 0, 0, 1201, 1202, 3, 32, 16, 0, 1202, 1203, 5, 266, 0, 0, 1203, 1204, 3, 32, 16, 0, 1204, 1205, 5, 43, 0, 0, 1205, 1212, 1, 0, 0, 0, 1206, 1207, 5, 42, 0, 0, 1207, 1208, 5, 266, 0, 0, 1208, 1209, 3, 32, 16, 0, 1209, 1210, 5, 43, 0, 0, 1210, 1212, 1, 0, 0, 0, 1211, 1194, 1, 0, 0, 0, 1211, 1195, 1, 0, 0, 0, 1211, 1196, 1, 0, 0, 0, 1211, 1200, 1, 0, 0, 0, 1211, 1206, 1, 0, 0, 0, 1212, 129, 1, 0, 0, 0, 1213, 1306, 1, 0, 0, 0, 1214, 1215, 5, 203, 0, 0, 1215, 1216, 5, 30, 0, 0, 1216, 1217, 3, 6, 3, 0, 1217, 1218, 5, 28, 0, 0, 1218, 1219, 3, 6, 3, 0, 1219, 1220, 5, 28, 0, 0, 1220, 1221, 3, 6, 3, 0, 1221, 1222, 5, 28, 0, 0, 1222, 1223, 3, 6, 3, 0, 1223, 1224, 5, 31, 0, 0, 1224, 1306, 1, 0, 0, 0, 1225, 1226, 5, 203, 0, 0, 1226, 1227, 5, 30, 0, 0, 1227, 1228, 3, 6, 3, 0, 1228, 1229, 5, 28, 0, 0, 1229, 1230, 3, 6, 3, 0, 1230, 1231, 5, 31, 0, 0, 1231, 1306, 1, 0, 0, 0, 1232, 1233, 5, 204, 0, 0, 1233, 1234, 5, 205, 0, 0, 1234, 1235, 5, 42, 0, 0, 1235, 1236, 3, 32, 16, 0, 1236, 1237, 5, 43, 0, 0, 1237, 1306, 1, 0, 0, 0, 1238, 1239, 5, 204, 0, 0, 1239, 1240, 5, 206, 0, 0, 1240, 1241, 5, 42, 0, 0, 1241, 1242, 3, 32, 16, 0, 1242, 1243, 5, 43, 0, 0, 1243, 1244, 3, 126, 63, 0, 1244, 1306, 1, 0, 0, 0, 1245, 1306, 5, 207, 0, 0, 1246, 1306, 5, 208, 0, 0, 1247, 1306, 5, 209, 0, 0, 1248, 1306, 5, 201, 0, 0, 1249, 1306, 5, 183, 0, 0, 1250, 1306, 5, 184, 0, 0, 1251, 1306, 5, 185, 0, 0, 1252, 1306, 5, 186, 0, 0, 1253, 1306, 5, 187, 0, 0, 1254, 1306, 5, 188, 0, 0, 1255, 1306, 5, 189, 0, 0, 1256, 1306, 5, 210, 0, 0, 1257, 1306, 5, 190, 0, 0, 1258, 1306, 5, 191, 0, 0, 1259, 1306, 5, 192, 0, 0, 1260, 1306, 5, 193, 0, 0, 1261, 1306, 5, 211, 0, 0, 1262, 1306, 5, 212, 0, 0, 1263, 1306, 5, 213, 0, 0, 1264, 1306, 5, 214, 0, 0, 1265, 1306, 5, 215, 0, 0, 1266, 1306, 5, 216, 0, 0, 1267, 1306, 5, 217, 0, 0, 1268, 1269, 5, 218, 0, 0, 1269, 1306, 3, 132, 66, 0, 1270, 1271, 5, 219, 0, 0, 1271, 1306, 3, 132, 66, 0, 1272, 1306, 5, 220, 0, 0, 1273, 1274, 5, 221, 0, 0, 1274, 1306, 3, 132, 66, 0, 1275, 1276, 5, 222, 0, 0, 1276, 1306, 3, 134, 67, 0, 1277, 1278, 5, 222, 0, 0, 1278, 1279, 3, 134, 67, 0, 1279, 1280, 5, 28, 0, 0, 1280, 1281, 3, 6, 3, 0, 1281, 1306, 1, 0, 0, 0, 1282, 1306, 5, 194, 0, 0, 1283, 1306, 5, 195, 0, 0, 1284, 1285, 5, 90, 0, 0, 1285, 1306, 5, 184, 0, 0, 1286, 1287, 5, 90, 0, 0, 1287, 1306, 5, 185, 0, 0, 1288, 1289, 5, 90, 0, 0, 1289, 1306, 5, 186, 0, 0, 1290, 1291, 5, 90, 0, 0, 1291, 1306, 5, 187, 0, 0, 1292, 1293, 5, 62, 0, 0, 1293, 1306, 5, 220, 0, 0, 1294, 1306, 5, 223, 0, 0, 1295, 1296, 5, 224, 0, 0, 1296, 1306, 5, 213, 0, 0, 1297, 1306, 5, 225, 0, 0, 1298, 1299, 5, 207, 0, 0, 1299, 1306, 5, 183, 0, 0, 1300, 1306, 5, 226, 0, 0, 1301, 1306, 5, 228, 0, 0, 1302, 1303, 5, 34, 0, 0, 1303, 1306, 5, 227, 0, 0, 1304, 1306, 3, 2, 1, 0, 1305, 1213, 1, 0, 0, 0, 1305, 1214, 1, 0, 0, 0, 1305, 1225, 1, 0, 0, 0, 1305, 1232, 1, 0, 0, 0, 1305, 1238, 1, 0, 0, 0, 1305, 1245, 1, 0, 0, 0, 1305, 1246, 1, 0, 0, 0, 1305, 1247, 1, 0, 0, 0, 1305, 1248, 1, 0, 0, 0, 1305, 1249, 1, 0, 0, 0, 1305, 1250, 1, 0, 0, 0, 1305, 1251, 1, 0, 0, 0, 1305, 1252, 1, 0, 0, 0, 1305, 1253, 1, 0, 0, 0, 1305, 1254, 1, 0, 0, 0, 1305, 1255, 1, 0, 0, 0, 1305, 1256, 1, 0, 0, 0, 1305, 1257, 1, 0, 0, 0, 1305, 1258, 1, 0, 0, 0, 1305, 1259, 1, 0, 0, 0, 1305, 1260, 1, 0, 0, 0, 1305, 1261, 1, 0, 0, 0, 1305, 1262, 1, 0, 0, 0, 1305, 1263, 1, 0, 0, 0, 1305, 1264, 1, 0, 0, 0, 1305, 1265, 1, 0, 0, 0, 1305, 1266, 1, 0, 0, 0, 1305, 1267, 1, 0, 0, 0, 1305, 1268, 1, 0, 0, 0, 1305, 1270, 1, 0, 0, 0, 1305, 1272, 1, 0, 0, 0, 1305, 1273, 1, 0, 0, 0, 1305, 1275, 1, 0, 0, 0, 1305, 1277, 1, 0, 0, 0, 1305, 1282, 1, 0, 0, 0, 1305, 1283, 1, 0, 0, 0, 1305, 1284, 1, 0, 0, 0, 1305, 1286, 1, 0, 0, 0, 1305, 1288, 1, 0, 0, 0, 1305, 1290, 1, 0, 0, 0, 1305, 1292, 1, 0, 0, 0, 1305, 1294, 1, 0, 0, 0, 1305, 1295, 1, 0, 0, 0, 1305, 1297, 1, 0, 0, 0, 1305, 1298, 1, 0, 0, 0, 1305, 1300, 1, 0, 0, 0, 1305, 1301, 1, 0, 0, 0, 1305, 1302, 1, 0, 0, 0, 1305, 1304, 1, 0, 0, 0, 1306, 131, 1, 0, 0, 0, 1307, 1315, 1, 0, 0, 0, 1308, 1309, 5, 30, 0, 0, 1309, 1310, 5, 91, 0, 0, 1310, 1311, 5, 36, 0, 0, 1311, 1312, 3, 32, 16, 0, 1312, 1313, 5, 31, 0, 0, 1313, 1315, 1, 0, 0, 0, 1314, 1307, 1, 0, 0, 0, 1314, 1308, 1, 0, 0, 0, 1315, 133, 1, 0, 0, 0, 1316, 1325, 1, 0, 0, 0, 1317, 1321, 3, 136, 68, 0, 1318, 1320, 7, 7, 0, 0, 1319, 1318, 1, 0, 0, 0, 1320, 1323, 1, 0, 0, 0, 1321, 1319, 1, 0, 0, 0, 1321, 1322, 1, 0, 0, 0, 1322, 1325, 1, 0, 0, 0, 1323, 1321, 1, 0, 0, 0, 1324, 1316, 1, 0, 0, 0, 1324, 1317, 1, 0, 0, 0, 1325, 135, 1, 0, 0, 0, 1326, 1327, 7, 8, 0, 0, 1327, 137, 1, 0, 0, 0, 1328, 1332, 3, 142, 71, 0, 1329, 1331, 3, 140, 70, 0, 1330, 1329, 1, 0, 0, 0, 1331, 1334, 1, 0, 0, 0, 1332, 1330, 1, 0, 0, 0, 1332, 1333, 1, 0, 0, 0, 1333, 139, 1, 0, 0, 0, 1334, 1332, 1, 0, 0, 0, 1335, 1354, 5, 261, 0, 0, 1336, 1337, 5, 42, 0, 0, 1337, 1354, 5, 43, 0, 0, 1338, 1354, 3, 110, 55, 0, 1339, 1354, 5, 260, 0, 0, 1340, 1354, 5, 262, 0, 0, 1341, 1354, 5, 92, 0, 0, 1342, 1343, 5, 93, 0, 0, 1343, 1344, 5, 30, 0, 0, 1344, 1345, 3, 124, 62, 0, 1345, 1346, 5, 31, 0, 0, 1346, 1354, 1, 0, 0, 0, 1347, 1348, 5, 94, 0, 0, 1348, 1349, 5, 30, 0, 0, 1349, 1350, 3, 124, 62, 0, 1350, 1351, 5, 31, 0, 0, 1351, 1354, 1, 0, 0, 0, 1352, 1354, 3, 108, 54, 0, 1353, 1335, 1, 0, 0, 0, 1353, 1336, 1, 0, 0, 0, 1353, 1338, 1, 0, 0, 0, 1353, 1339, 1, 0, 0, 0, 1353, 1340, 1, 0, 0, 0, 1353, 1341, 1, 0, 0, 0, 1353, 1342, 1, 0, 0, 0, 1353, 1347, 1, 0, 0, 0, 1353, 1352, 1, 0, 0, 0, 1354, 141, 1, 0, 0, 0, 1355, 1356, 5, 39, 0, 0, 1356, 1386, 3, 116, 58, 0, 1357, 1386, 5, 197, 0, 0, 1358, 1359, 5, 199, 0, 0, 1359, 1360, 5, 39, 0, 0, 1360, 1386, 3, 116, 58, 0, 1361, 1362, 5, 200, 0, 0, 1362, 1386, 3, 116, 58, 0, 1363, 1364, 5, 226, 0, 0, 1364, 1365, 3, 170, 85, 0, 1365, 1366, 3, 138, 69, 0, 1366, 1367, 5, 262, 0, 0, 1367, 1368, 3, 112, 56, 0, 1368, 1386, 1, 0, 0, 0, 1369, 1370, 5, 253, 0, 0, 1370, 1386, 3, 32, 16, 0, 1371, 1372, 5, 252, 0, 0, 1372, 1386, 3, 32, 16, 0, 1373, 1374, 5, 253, 0, 0, 1374, 1386, 3, 2, 1, 0, 1375, 1376, 5, 252, 0, 0, 1376, 1386, 3, 2, 1, 0, 1377, 1386, 5, 254, 0, 0, 1378, 1386, 5, 201, 0, 0, 1379, 1386, 3, 148, 74, 0, 1380, 1386, 3, 150, 75, 0, 1381, 1386, 3, 144, 72, 0, 1382, 1386, 3, 2, 1, 0, 1383, 1384, 5, 177, 0, 0, 1384, 1386, 3, 138, 69, 0, 1385, 1355, 1, 0, 0, 0, 1385, 1357, 1, 0, 0, 0, 1385, 1358, 1, 0, 0, 0, 1385, 1361, 1, 0, 0, 0, 1385, 1363, 1, 0, 0, 0, 1385, 1369, 1, 0, 0, 0, 1385, 1371, 1, 0, 0, 0, 1385, 1373, 1, 0, 0, 0, 1385, 1375, 1, 0, 0, 0, 1385, 1377, 1, 0, 0, 0, 1385, 1378, 1, 0, 0, 0, 1385, 1379, 1, 0, 0, 0, 1385, 1380, 1, 0, 0, 0, 1385, 1381, 1, 0, 0, 0, 1385, 1382, 1, 0, 0, 0, 1385, 1383, 1, 0, 0, 0, 1386, 143, 1, 0, 0, 0, 1387, 1409, 5, 181, 0, 0, 1388, 1409, 5, 182, 0, 0, 1389, 1409, 5, 183, 0, 0, 1390, 1409, 5, 184, 0, 0, 1391, 1409, 5, 185, 0, 0, 1392, 1409, 5, 186, 0, 0, 1393, 1409, 5, 187, 0, 0, 1394, 1409, 5, 188, 0, 0, 1395, 1409, 5, 189, 0, 0, 1396, 1409, 5, 190, 0, 0, 1397, 1409, 5, 191, 0, 0, 1398, 1409, 5, 192, 0, 0, 1399, 1409, 5, 193, 0, 0, 1400, 1401, 5, 90, 0, 0, 1401, 1409, 5, 184, 0, 0, 1402, 1403, 5, 90, 0, 0, 1403, 1409, 5, 185, 0, 0, 1404, 1405, 5, 90, 0, 0, 1405, 1409, 5, 186, 0, 0, 1406, 1407, 5, 90, 0, 0, 1407, 1409, 5, 187, 0, 0, 1408, 1387, 1, 0, 0, 0, 1408, 1388, 1, 0, 0, 0, 1408, 1389, 1, 0, 0, 0, 1408, 1390, 1, 0, 0, 0, 1408, 1391, 1, 0, 0, 0, 1408, 1392, 1, 0, 0, 0, 1408, 1393, 1, 0, 0, 0, 1408, 1394, 1, 0, 0, 0, 1408, 1395, 1, 0, 0, 0, 1408, 1396, 1, 0, 0, 0, 1408, 1397, 1, 0, 0, 0, 1408, 1398, 1, 0, 0, 0, 1408, 1399, 1, 0, 0, 0, 1408, 1400, 1, 0, 0, 0, 1408, 1402, 1, 0, 0, 0, 1408, 1404, 1, 0, 0, 0, 1408, 1406, 1, 0, 0, 0, 1409, 145, 1, 0, 0, 0, 1410, 1421, 1, 0, 0, 0, 1411, 1421, 5, 177, 0, 0, 1412, 1421, 3, 32, 16, 0, 1413, 1414, 3, 32, 16, 0, 1414, 1415, 5, 177, 0, 0, 1415, 1416, 3, 32, 16, 0, 1416, 1421, 1, 0, 0, 0, 1417, 1418, 3, 32, 16, 0, 1418, 1419, 5, 177, 0, 0, 1419, 1421, 1, 0, 0, 0, 1420, 1410, 1, 0, 0, 0, 1420, 1411, 1, 0, 0, 0, 1420, 1412, 1, 0, 0, 0, 1420, 1413, 1, 0, 0, 0, 1420, 1417, 1, 0, 0, 0, 1421, 147, 1, 0, 0, 0, 1422, 1423, 5, 1, 0, 0, 1423, 1424, 5, 194, 0, 0, 1424, 149, 1, 0, 0, 0, 1425, 1429, 5, 1, 0, 0, 1426, 1427, 5, 90, 0, 0, 1427, 1430, 5, 194, 0, 0, 1428, 1430, 5, 195, 0, 0, 1429, 1426, 1, 0, 0, 0, 1429, 1428, 1, 0, 0, 0, 1430, 151, 1, 0, 0, 0, 1431, 1432, 5, 294, 0, 0, 1432, 1433, 3, 166, 83, 0, 1433, 1434, 3, 124, 62, 0, 1434, 1435, 5, 30, 0, 0, 1435, 1436, 3, 158, 79, 0, 1436, 1437, 5, 31, 0, 0, 1437, 1479, 1, 0, 0, 0, 1438, 1439, 5, 294, 0, 0, 1439, 1440, 3, 166, 83, 0, 1440, 1441, 3, 124, 62, 0, 1441, 1442, 5, 36, 0, 0, 1442, 1443, 5, 17, 0, 0, 1443, 1444, 3, 52, 26, 0, 1444, 1445, 5, 18, 0, 0, 1445, 1479, 1, 0, 0, 0, 1446, 1447, 5, 294, 0, 0, 1447, 1448, 3, 166, 83, 0, 1448, 1449, 3, 124, 62, 0, 1449, 1479, 1, 0, 0, 0, 1450, 1451, 5, 295, 0, 0, 1451, 1452, 3, 166, 83, 0, 1452, 1454, 5, 36, 0, 0, 1453, 1455, 5, 84, 0, 0, 1454, 1453, 1, 0, 0, 0, 1454, 1455, 1, 0, 0, 0, 1455, 1456, 1, 0, 0, 0, 1456, 1457, 5, 30, 0, 0, 1457, 1458, 3, 292, 146, 0, 1458, 1459, 5, 31, 0, 0, 1459, 1479, 1, 0, 0, 0, 1460, 1461, 5, 295, 0, 0, 1461, 1462, 3, 166, 83, 0, 1462, 1463, 5, 84, 0, 0, 1463, 1464, 5, 30, 0, 0, 1464, 1465, 3, 292, 146, 0, 1465, 1466, 5, 31, 0, 0, 1466, 1479, 1, 0, 0, 0, 1467, 1468, 5, 295, 0, 0, 1468, 1469, 3, 166, 83, 0, 1469, 1470, 3, 6, 3, 0, 1470, 1479, 1, 0, 0, 0, 1471, 1472, 5, 295, 0, 0, 1472, 1473, 3, 166, 83, 0, 1473, 1474, 5, 36, 0, 0, 1474, 1475, 5, 17, 0, 0, 1475, 1476, 3, 154, 77, 0, 1476, 1477, 5, 18, 0, 0, 1477, 1479, 1, 0, 0, 0, 1478, 1431, 1, 0, 0, 0, 1478, 1438, 1, 0, 0, 0, 1478, 1446, 1, 0, 0, 0, 1478, 1450, 1, 0, 0, 0, 1478, 1460, 1, 0, 0, 0, 1478, 1467, 1, 0, 0, 0, 1478, 1471, 1, 0, 0, 0, 1479, 153, 1, 0, 0, 0, 1480, 1491, 1, 0, 0, 0, 1481, 1482, 3, 156, 78, 0, 1482, 1483, 5, 28, 0, 0, 1483, 1485, 1, 0, 0, 0, 1484, 1481, 1, 0, 0, 0, 1485, 1488, 1, 0, 0, 0, 1486, 1484, 1, 0, 0, 0, 1486, 1487, 1, 0, 0, 0, 1487, 1489, 1, 0, 0, 0, 1488, 1486, 1, 0, 0, 0, 1489, 1491, 3, 156, 78, 0, 1490, 1480, 1, 0, 0, 0, 1490, 1486, 1, 0, 0, 0, 1491, 155, 1, 0, 0, 0, 1492, 1493, 5, 39, 0, 0, 1493, 1494, 5, 264, 0, 0, 1494, 1495, 5, 36, 0, 0, 1495, 1496, 5, 17, 0, 0, 1496, 1497, 3, 56, 28, 0, 1497, 1498, 5, 18, 0, 0, 1498, 1506, 1, 0, 0, 0, 1499, 1500, 3, 124, 62, 0, 1500, 1501, 5, 36, 0, 0, 1501, 1502, 5, 17, 0, 0, 1502, 1503, 3, 56, 28, 0, 1503, 1504, 5, 18, 0, 0, 1504, 1506, 1, 0, 0, 0, 1505, 1492, 1, 0, 0, 0, 1505, 1499, 1, 0, 0, 0, 1506, 157, 1, 0, 0, 0, 1507, 1508, 3, 160, 80, 0, 1508, 1509, 5, 28, 0, 0, 1509, 1511, 1, 0, 0, 0, 1510, 1507, 1, 0, 0, 0, 1511, 1514, 1, 0, 0, 0, 1512, 1510, 1, 0, 0, 0, 1512, 1513, 1, 0, 0, 0, 1513, 1515, 1, 0, 0, 0, 1514, 1512, 1, 0, 0, 0, 1515, 1516, 3, 160, 80, 0, 1516, 159, 1, 0, 0, 0, 1517, 1518, 3, 6, 3, 0, 1518, 1519, 5, 36, 0, 0, 1519, 1520, 3, 164, 82, 0, 1520, 161, 1, 0, 0, 0, 1521, 1522, 7, 9, 0, 0, 1522, 163, 1, 0, 0, 0, 1523, 1558, 3, 162, 81, 0, 1524, 1558, 3, 32, 16, 0, 1525, 1526, 5, 186, 0, 0, 1526, 1527, 5, 30, 0, 0, 1527, 1528, 3, 32, 16, 0, 1528, 1529, 5, 31, 0, 0, 1529, 1558, 1, 0, 0, 0, 1530, 1558, 3, 6, 3, 0, 1531, 1532, 3, 116, 58, 0, 1532, 1533, 5, 30, 0, 0, 1533, 1534, 5, 184, 0, 0, 1534, 1535, 5, 75, 0, 0, 1535, 1536, 3, 32, 16, 0, 1536, 1537, 5, 31, 0, 0, 1537, 1558, 1, 0, 0, 0, 1538, 1539, 3, 116, 58, 0, 1539, 1540, 5, 30, 0, 0, 1540, 1541, 5, 185, 0, 0, 1541, 1542, 5, 75, 0, 0, 1542, 1543, 3, 32, 16, 0, 1543, 1544, 5, 31, 0, 0, 1544, 1558, 1, 0, 0, 0, 1545, 1546, 3, 116, 58, 0, 1546, 1547, 5, 30, 0, 0, 1547, 1548, 5, 186, 0, 0, 1548, 1549, 5, 75, 0, 0, 1549, 1550, 3, 32, 16, 0, 1550, 1551, 5, 31, 0, 0, 1551, 1558, 1, 0, 0, 0, 1552, 1553, 3, 116, 58, 0, 1553, 1554, 5, 30, 0, 0, 1554, 1555, 3, 32, 16, 0, 1555, 1556, 5, 31, 0, 0, 1556, 1558, 1, 0, 0, 0, 1557, 1523, 1, 0, 0, 0, 1557, 1524, 1, 0, 0, 0, 1557, 1525, 1, 0, 0, 0, 1557, 1530, 1, 0, 0, 0, 1557, 1531, 1, 0, 0, 0, 1557, 1538, 1, 0, 0, 0, 1557, 1545, 1, 0, 0, 0, 1557, 1552, 1, 0, 0, 0, 1558, 165, 1, 0, 0, 0, 1559, 1560, 7, 10, 0, 0, 1560, 167, 1, 0, 0, 0, 1561, 1562, 3, 170, 85, 0, 1562, 1563, 3, 138, 69, 0, 1563, 1564, 3, 124, 62, 0, 1564, 1565, 5, 176, 0, 0, 1565, 1567, 3, 242, 121, 0, 1566, 1568, 3, 108, 54, 0, 1567, 1566, 1, 0, 0, 0, 1567, 1568, 1, 0, 0, 0, 1568, 1569, 1, 0, 0, 0, 1569, 1570, 3, 112, 56, 0, 1570, 1596, 1, 0, 0, 0, 1571, 1572, 3, 170, 85, 0, 1572, 1573, 3, 138, 69, 0, 1573, 1574, 3, 124, 62, 0, 1574, 1575, 5, 176, 0, 0, 1575, 1576, 3, 242, 121, 0, 1576, 1577, 3, 196, 98, 0, 1577, 1578, 3, 112, 56, 0, 1578, 1596, 1, 0, 0, 0, 1579, 1580, 3, 170, 85, 0, 1580, 1581, 3, 138, 69, 0, 1581, 1583, 3, 242, 121, 0, 1582, 1584, 3, 108, 54, 0, 1583, 1582, 1, 0, 0, 0, 1583, 1584, 1, 0, 0, 0, 1584, 1585, 1, 0, 0, 0, 1585, 1586, 3, 112, 56, 0, 1586, 1596, 1, 0, 0, 0, 1587, 1588, 3, 170, 85, 0, 1588, 1589, 3, 138, 69, 0, 1589, 1590, 3, 242, 121, 0, 1590, 1591, 3, 196, 98, 0, 1591, 1592, 3, 112, 56, 0, 1592, 1596, 1, 0, 0, 0, 1593, 1596, 3, 174, 87, 0, 1594, 1596, 3, 2, 1, 0, 1595, 1561, 1, 0, 0, 0, 1595, 1571, 1, 0, 0, 0, 1595, 1579, 1, 0, 0, 0, 1595, 1587, 1, 0, 0, 0, 1595, 1593, 1, 0, 0, 0, 1595, 1594, 1, 0, 0, 0, 1596, 169, 1, 0, 0, 0, 1597, 1598, 5, 243, 0, 0, 1598, 1608, 3, 170, 85, 0, 1599, 1600, 5, 244, 0, 0, 1600, 1608, 3, 170, 85, 0, 1601, 1608, 3, 172, 86, 0, 1602, 1603, 5, 112, 0, 0, 1603, 1604, 5, 30, 0, 0, 1604, 1605, 3, 32, 16, 0, 1605, 1606, 5, 31, 0, 0, 1606, 1608, 1, 0, 0, 0, 1607, 1597, 1, 0, 0, 0, 1607, 1599, 1, 0, 0, 0, 1607, 1601, 1, 0, 0, 0, 1607, 1602, 1, 0, 0, 0, 1608, 171, 1, 0, 0, 0, 1609, 1622, 1, 0, 0, 0, 1610, 1622, 5, 245, 0, 0, 1611, 1622, 5, 246, 0, 0, 1612, 1613, 5, 247, 0, 0, 1613, 1622, 5, 248, 0, 0, 1614, 1615, 5, 247, 0, 0, 1615, 1622, 5, 249, 0, 0, 1616, 1617, 5, 247, 0, 0, 1617, 1622, 5, 250, 0, 0, 1618, 1619, 5, 247, 0, 0, 1619, 1622, 5, 251, 0, 0, 1620, 1622, 5, 247, 0, 0, 1621, 1609, 1, 0, 0, 0, 1621, 1610, 1, 0, 0, 0, 1621, 1611, 1, 0, 0, 0, 1621, 1612, 1, 0, 0, 0, 1621, 1614, 1, 0, 0, 0, 1621, 1616, 1, 0, 0, 0, 1621, 1618, 1, 0, 0, 0, 1621, 1620, 1, 0, 0, 0, 1622, 173, 1, 0, 0, 0, 1623, 1624, 5, 113, 0, 0, 1624, 1625, 5, 30, 0, 0, 1625, 1626, 3, 32, 16, 0, 1626, 1627, 5, 31, 0, 0, 1627, 175, 1, 0, 0, 0, 1628, 1629, 5, 226, 0, 0, 1629, 1634, 3, 168, 84, 0, 1630, 1631, 5, 37, 0, 0, 1631, 1634, 3, 178, 89, 0, 1632, 1634, 3, 174, 87, 0, 1633, 1628, 1, 0, 0, 0, 1633, 1630, 1, 0, 0, 0, 1633, 1632, 1, 0, 0, 0, 1634, 177, 1, 0, 0, 0, 1635, 1636, 3, 138, 69, 0, 1636, 1637, 3, 124, 62, 0, 1637, 1638, 5, 176, 0, 0, 1638, 1639, 3, 2, 1, 0, 1639, 1645, 1, 0, 0, 0, 1640, 1641, 3, 138, 69, 0, 1641, 1642, 3, 2, 1, 0, 1642, 1645, 1, 0, 0, 0, 1643, 1645, 3, 2, 1, 0, 1644, 1635, 1, 0, 0, 0, 1644, 1640, 1, 0, 0, 0, 1644, 1643, 1, 0, 0, 0, 1645, 179, 1, 0, 0, 0, 1646, 1647, 3, 124, 62, 0, 1647, 1648, 5, 28, 0, 0, 1648, 1650, 1, 0, 0, 0, 1649, 1646, 1, 0, 0, 0, 1650, 1653, 1, 0, 0, 0, 1651, 1649, 1, 0, 0, 0, 1651, 1652, 1, 0, 0, 0, 1652, 1654, 1, 0, 0, 0, 1653, 1651, 1, 0, 0, 0, 1654, 1655, 3, 124, 62, 0, 1655, 181, 1, 0, 0, 0, 1656, 1662, 1, 0, 0, 0, 1657, 1658, 5, 86, 0, 0, 1658, 1659, 3, 190, 95, 0, 1659, 1660, 5, 87, 0, 0, 1660, 1662, 1, 0, 0, 0, 1661, 1656, 1, 0, 0, 0, 1661, 1657, 1, 0, 0, 0, 1662, 183, 1, 0, 0, 0, 1663, 1675, 5, 266, 0, 0, 1664, 1675, 5, 114, 0, 0, 1665, 1675, 5, 39, 0, 0, 1666, 1675, 5, 200, 0, 0, 1667, 1675, 5, 115, 0, 0, 1668, 1675, 5, 116, 0, 0, 1669, 1670, 5, 70, 0, 0, 1670, 1671, 5, 30, 0, 0, 1671, 1672, 3, 32, 16, 0, 1672, 1673, 5, 31, 0, 0, 1673, 1675, 1, 0, 0, 0, 1674, 1663, 1, 0, 0, 0, 1674, 1664, 1, 0, 0, 0, 1674, 1665, 1, 0, 0, 0, 1674, 1666, 1, 0, 0, 0, 1674, 1667, 1, 0, 0, 0, 1674, 1668, 1, 0, 0, 0, 1674, 1669, 1, 0, 0, 0, 1675, 185, 1, 0, 0, 0, 1676, 1678, 3, 184, 92, 0, 1677, 1676, 1, 0, 0, 0, 1678, 1681, 1, 0, 0, 0, 1679, 1677, 1, 0, 0, 0, 1679, 1680, 1, 0, 0, 0, 1680, 187, 1, 0, 0, 0, 1681, 1679, 1, 0, 0, 0, 1682, 1684, 3, 186, 93, 0, 1683, 1685, 3, 192, 96, 0, 1684, 1683, 1, 0, 0, 0, 1684, 1685, 1, 0, 0, 0, 1685, 1686, 1, 0, 0, 0, 1686, 1687, 3, 2, 1, 0, 1687, 189, 1, 0, 0, 0, 1688, 1689, 3, 188, 94, 0, 1689, 1690, 5, 28, 0, 0, 1690, 1692, 1, 0, 0, 0, 1691, 1688, 1, 0, 0, 0, 1692, 1695, 1, 0, 0, 0, 1693, 1691, 1, 0, 0, 0, 1693, 1694, 1, 0, 0, 0, 1694, 1696, 1, 0, 0, 0, 1695, 1693, 1, 0, 0, 0, 1696, 1697, 3, 188, 94, 0, 1697, 191, 1, 0, 0, 0, 1698, 1699, 5, 30, 0, 0, 1699, 1700, 3, 180, 90, 0, 1700, 1701, 5, 31, 0, 0, 1701, 193, 1, 0, 0, 0, 1702, 1705, 1, 0, 0, 0, 1703, 1705, 3, 196, 98, 0, 1704, 1702, 1, 0, 0, 0, 1704, 1703, 1, 0, 0, 0, 1705, 195, 1, 0, 0, 0, 1706, 1707, 5, 86, 0, 0, 1707, 1708, 5, 42, 0, 0, 1708, 1709, 3, 32, 16, 0, 1709, 1710, 5, 43, 0, 0, 1710, 1711, 5, 87, 0, 0, 1711, 197, 1, 0, 0, 0, 1712, 1713, 3, 234, 117, 0, 1713, 1714, 5, 17, 0, 0, 1714, 1715, 3, 246, 123, 0, 1715, 1716, 5, 18, 0, 0, 1716, 1829, 1, 0, 0, 0, 1717, 1718, 3, 74, 37, 0, 1718, 1719, 5, 17, 0, 0, 1719, 1720, 3, 82, 41, 0, 1720, 1721, 5, 18, 0, 0, 1721, 1829, 1, 0, 0, 0, 1722, 1723, 3, 210, 105, 0, 1723, 1724, 5, 17, 0, 0, 1724, 1725, 3, 214, 107, 0, 1725, 1726, 5, 18, 0, 0, 1726, 1829, 1, 0, 0, 0, 1727, 1728, 3, 218, 109, 0, 1728, 1729, 5, 17, 0, 0, 1729, 1730, 3, 222, 111, 0, 1730, 1731, 5, 18, 0, 0, 1731, 1829, 1, 0, 0, 0, 1732, 1829, 3, 200, 100, 0, 1733, 1829, 3, 276, 138, 0, 1734, 1829, 3, 152, 76, 0, 1735, 1829, 3, 88, 44, 0, 1736, 1829, 3, 322, 161, 0, 1737, 1738, 5, 117, 0, 0, 1738, 1829, 3, 32, 16, 0, 1739, 1740, 5, 118, 0, 0, 1740, 1829, 3, 32, 16, 0, 1741, 1742, 3, 334, 167, 0, 1742, 1743, 5, 17, 0, 0, 1743, 1744, 3, 338, 169, 0, 1744, 1745, 5, 18, 0, 0, 1745, 1829, 1, 0, 0, 0, 1746, 1747, 5, 302, 0, 0, 1747, 1748, 3, 124, 62, 0, 1748, 1749, 5, 176, 0, 0, 1749, 1750, 3, 242, 121, 0, 1750, 1751, 5, 119, 0, 0, 1751, 1752, 3, 170, 85, 0, 1752, 1753, 3, 138, 69, 0, 1753, 1754, 3, 124, 62, 0, 1754, 1755, 5, 176, 0, 0, 1755, 1756, 3, 242, 121, 0, 1756, 1757, 3, 112, 56, 0, 1757, 1829, 1, 0, 0, 0, 1758, 1759, 5, 302, 0, 0, 1759, 1760, 5, 226, 0, 0, 1760, 1761, 3, 170, 85, 0, 1761, 1762, 3, 138, 69, 0, 1762, 1763, 3, 124, 62, 0, 1763, 1764, 5, 176, 0, 0, 1764, 1765, 3, 242, 121, 0, 1765, 1766, 3, 194, 97, 0, 1766, 1767, 3, 112, 56, 0, 1767, 1768, 5, 119, 0, 0, 1768, 1769, 5, 226, 0, 0, 1769, 1770, 3, 170, 85, 0, 1770, 1771, 3, 138, 69, 0, 1771, 1772, 3, 124, 62, 0, 1772, 1773, 5, 176, 0, 0, 1773, 1774, 3, 242, 121, 0, 1774, 1775, 3, 194, 97, 0, 1775, 1776, 3, 112, 56, 0, 1776, 1829, 1, 0, 0, 0, 1777, 1829, 3, 26, 13, 0, 1778, 1829, 3, 40, 20, 0, 1779, 1780, 5, 255, 0, 0, 1780, 1781, 5, 196, 0, 0, 1781, 1782, 5, 42, 0, 0, 1782, 1783, 3, 32, 16, 0, 1783, 1787, 5, 43, 0, 0, 1784, 1786, 3, 322, 161, 0, 1785, 1784, 1, 0, 0, 0, 1786, 1789, 1, 0, 0, 0, 1787, 1785, 1, 0, 0, 0, 1787, 1788, 1, 0, 0, 0, 1788, 1829, 1, 0, 0, 0, 1789, 1787, 1, 0, 0, 0, 1790, 1791, 5, 255, 0, 0, 1791, 1792, 5, 196, 0, 0, 1792, 1796, 3, 2, 1, 0, 1793, 1795, 3, 322, 161, 0, 1794, 1793, 1, 0, 0, 0, 1795, 1798, 1, 0, 0, 0, 1796, 1794, 1, 0, 0, 0, 1796, 1797, 1, 0, 0, 0, 1797, 1829, 1, 0, 0, 0, 1798, 1796, 1, 0, 0, 0, 1799, 1800, 5, 255, 0, 0, 1800, 1801, 5, 256, 0, 0, 1801, 1802, 5, 42, 0, 0, 1802, 1803, 3, 32, 16, 0, 1803, 1804, 5, 43, 0, 0, 1804, 1805, 5, 28, 0, 0, 1805, 1809, 3, 124, 62, 0, 1806, 1808, 3, 322, 161, 0, 1807, 1806, 1, 0, 0, 0, 1808, 1811, 1, 0, 0, 0, 1809, 1807, 1, 0, 0, 0, 1809, 1810, 1, 0, 0, 0, 1810, 1829, 1, 0, 0, 0, 1811, 1809, 1, 0, 0, 0, 1812, 1813, 5, 255, 0, 0, 1813, 1814, 5, 256, 0, 0, 1814, 1815, 3, 2, 1, 0, 1815, 1816, 5, 28, 0, 0, 1816, 1820, 3, 124, 62, 0, 1817, 1819, 3, 322, 161, 0, 1818, 1817, 1, 0, 0, 0, 1819, 1822, 1, 0, 0, 0, 1820, 1818, 1, 0, 0, 0, 1820, 1821, 1, 0, 0, 0, 1821, 1829, 1, 0, 0, 0, 1822, 1820, 1, 0, 0, 0, 1823, 1824, 5, 120, 0, 0, 1824, 1825, 5, 196, 0, 0, 1825, 1826, 3, 124, 62, 0, 1826, 1827, 3, 44, 22, 0, 1827, 1829, 1, 0, 0, 0, 1828, 1712, 1, 0, 0, 0, 1828, 1717, 1, 0, 0, 0, 1828, 1722, 1, 0, 0, 0, 1828, 1727, 1, 0, 0, 0, 1828, 1732, 1, 0, 0, 0, 1828, 1733, 1, 0, 0, 0, 1828, 1734, 1, 0, 0, 0, 1828, 1735, 1, 0, 0, 0, 1828, 1736, 1, 0, 0, 0, 1828, 1737, 1, 0, 0, 0, 1828, 1739, 1, 0, 0, 0, 1828, 1741, 1, 0, 0, 0, 1828, 1746, 1, 0, 0, 0, 1828, 1758, 1, 0, 0, 0, 1828, 1777, 1, 0, 0, 0, 1828, 1778, 1, 0, 0, 0, 1828, 1779, 1, 0, 0, 0, 1828, 1790, 1, 0, 0, 0, 1828, 1799, 1, 0, 0, 0, 1828, 1812, 1, 0, 0, 0, 1828, 1823, 1, 0, 0, 0, 1829, 199, 1, 0, 0, 0, 1830, 1831, 5, 121, 0, 0, 1831, 1840, 3, 208, 104, 0, 1832, 1839, 3, 202, 101, 0, 1833, 1834, 5, 122, 0, 0, 1834, 1835, 5, 30, 0, 0, 1835, 1836, 3, 228, 114, 0, 1836, 1837, 5, 31, 0, 0, 1837, 1839, 1, 0, 0, 0, 1838, 1832, 1, 0, 0, 0, 1838, 1833, 1, 0, 0, 0, 1839, 1842, 1, 0, 0, 0, 1840, 1838, 1, 0, 0, 0, 1840, 1841, 1, 0, 0, 0, 1841, 1843, 1, 0, 0, 0, 1842, 1840, 1, 0, 0, 0, 1843, 1844, 3, 138, 69, 0, 1844, 1845, 3, 2, 1, 0, 1845, 1846, 3, 204, 102, 0, 1846, 1847, 3, 206, 103, 0, 1847, 201, 1, 0, 0, 0, 1848, 1868, 5, 123, 0, 0, 1849, 1868, 5, 51, 0, 0, 1850, 1868, 5, 52, 0, 0, 1851, 1868, 5, 63, 0, 0, 1852, 1868, 5, 124, 0, 0, 1853, 1868, 5, 69, 0, 0, 1854, 1868, 5, 68, 0, 0, 1855, 1868, 5, 64, 0, 0, 1856, 1868, 5, 65, 0, 0, 1857, 1868, 5, 66, 0, 0, 1858, 1868, 5, 125, 0, 0, 1859, 1868, 5, 126, 0, 0, 1860, 1868, 5, 127, 0, 0, 1861, 1868, 5, 16, 0, 0, 1862, 1863, 5, 70, 0, 0, 1863, 1864, 5, 30, 0, 0, 1864, 1865, 3, 32, 16, 0, 1865, 1866, 5, 31, 0, 0, 1866, 1868, 1, 0, 0, 0, 1867, 1848, 1, 0, 0, 0, 1867, 1849, 1, 0, 0, 0, 1867, 1850, 1, 0, 0, 0, 1867, 1851, 1, 0, 0, 0, 1867, 1852, 1, 0, 0, 0, 1867, 1853, 1, 0, 0, 0, 1867, 1854, 1, 0, 0, 0, 1867, 1855, 1, 0, 0, 0, 1867, 1856, 1, 0, 0, 0, 1867, 1857, 1, 0, 0, 0, 1867, 1858, 1, 0, 0, 0, 1867, 1859, 1, 0, 0, 0, 1867, 1860, 1, 0, 0, 0, 1867, 1861, 1, 0, 0, 0, 1867, 1862, 1, 0, 0, 0, 1868, 203, 1, 0, 0, 0, 1869, 1875, 1, 0, 0, 0, 1870, 1871, 5, 44, 0, 0, 1871, 1875, 3, 0, 0, 0, 1872, 1873, 5, 44, 0, 0, 1873, 1875, 3, 32, 16, 0, 1874, 1869, 1, 0, 0, 0, 1874, 1870, 1, 0, 0, 0, 1874, 1872, 1, 0, 0, 0, 1875, 205, 1, 0, 0, 0, 1876, 1880, 1, 0, 0, 0, 1877, 1878, 5, 36, 0, 0, 1878, 1880, 3, 296, 148, 0, 1879, 1876, 1, 0, 0, 0, 1879, 1877, 1, 0, 0, 0, 1880, 207, 1, 0, 0, 0, 1881, 1887, 1, 0, 0, 0, 1882, 1883, 5, 42, 0, 0, 1883, 1884, 3, 32, 16, 0, 1884, 1885, 5, 43, 0, 0, 1885, 1887, 1, 0, 0, 0, 1886, 1881, 1, 0, 0, 0, 1886, 1882, 1, 0, 0, 0, 1887, 209, 1, 0, 0, 0, 1888, 1892, 5, 128, 0, 0, 1889, 1891, 3, 212, 106, 0, 1890, 1889, 1, 0, 0, 0, 1891, 1894, 1, 0, 0, 0, 1892, 1890, 1, 0, 0, 0, 1892, 1893, 1, 0, 0, 0, 1893, 1895, 1, 0, 0, 0, 1894, 1892, 1, 0, 0, 0, 1895, 1896, 3, 124, 62, 0, 1896, 1897, 3, 2, 1, 0, 1897, 1907, 1, 0, 0, 0, 1898, 1902, 5, 128, 0, 0, 1899, 1901, 3, 212, 106, 0, 1900, 1899, 1, 0, 0, 0, 1901, 1904, 1, 0, 0, 0, 1902, 1900, 1, 0, 0, 0, 1902, 1903, 1, 0, 0, 0, 1903, 1905, 1, 0, 0, 0, 1904, 1902, 1, 0, 0, 0, 1905, 1907, 3, 2, 1, 0, 1906, 1888, 1, 0, 0, 0, 1906, 1898, 1, 0, 0, 0, 1907, 211, 1, 0, 0, 0, 1908, 1909, 7, 11, 0, 0, 1909, 213, 1, 0, 0, 0, 1910, 1912, 3, 216, 108, 0, 1911, 1910, 1, 0, 0, 0, 1912, 1915, 1, 0, 0, 0, 1913, 1911, 1, 0, 0, 0, 1913, 1914, 1, 0, 0, 0, 1914, 215, 1, 0, 0, 0, 1915, 1913, 1, 0, 0, 0, 1916, 1917, 5, 129, 0, 0, 1917, 1929, 3, 168, 84, 0, 1918, 1919, 5, 130, 0, 0, 1919, 1929, 3, 168, 84, 0, 1920, 1921, 5, 131, 0, 0, 1921, 1929, 3, 168, 84, 0, 1922, 1923, 5, 132, 0, 0, 1923, 1929, 3, 168, 84, 0, 1924, 1929, 3, 88, 44, 0, 1925, 1929, 3, 322, 161, 0, 1926, 1929, 3, 26, 13, 0, 1927, 1929, 3, 40, 20, 0, 1928, 1916, 1, 0, 0, 0, 1928, 1918, 1, 0, 0, 0, 1928, 1920, 1, 0, 0, 0, 1928, 1922, 1, 0, 0, 0, 1928, 1924, 1, 0, 0, 0, 1928, 1925, 1, 0, 0, 0, 1928, 1926, 1, 0, 0, 0, 1928, 1927, 1, 0, 0, 0, 1929, 217, 1, 0, 0, 0, 1930, 1934, 5, 133, 0, 0, 1931, 1933, 3, 220, 110, 0, 1932, 1931, 1, 0, 0, 0, 1933, 1936, 1, 0, 0, 0, 1934, 1932, 1, 0, 0, 0, 1934, 1935, 1, 0, 0, 0, 1935, 1937, 1, 0, 0, 0, 1936, 1934, 1, 0, 0, 0, 1937, 1938, 3, 170, 85, 0, 1938, 1939, 3, 138, 69, 0, 1939, 1940, 3, 2, 1, 0, 1940, 1941, 3, 112, 56, 0, 1941, 1942, 3, 206, 103, 0, 1942, 219, 1, 0, 0, 0, 1943, 1944, 7, 11, 0, 0, 1944, 221, 1, 0, 0, 0, 1945, 1947, 3, 224, 112, 0, 1946, 1945, 1, 0, 0, 0, 1947, 1950, 1, 0, 0, 0, 1948, 1946, 1, 0, 0, 0, 1948, 1949, 1, 0, 0, 0, 1949, 223, 1, 0, 0, 0, 1950, 1948, 1, 0, 0, 0, 1951, 1952, 5, 134, 0, 0, 1952, 1962, 3, 168, 84, 0, 1953, 1954, 5, 135, 0, 0, 1954, 1962, 3, 168, 84, 0, 1955, 1956, 5, 132, 0, 0, 1956, 1962, 3, 168, 84, 0, 1957, 1962, 3, 322, 161, 0, 1958, 1962, 3, 88, 44, 0, 1959, 1962, 3, 26, 13, 0, 1960, 1962, 3, 40, 20, 0, 1961, 1951, 1, 0, 0, 0, 1961, 1953, 1, 0, 0, 0, 1961, 1955, 1, 0, 0, 0, 1961, 1957, 1, 0, 0, 0, 1961, 1958, 1, 0, 0, 0, 1961, 1959, 1, 0, 0, 0, 1961, 1960, 1, 0, 0, 0, 1962, 225, 1, 0, 0, 0, 1963, 1970, 1, 0, 0, 0, 1964, 1965, 5, 122, 0, 0, 1965, 1966, 5, 30, 0, 0, 1966, 1967, 3, 228, 114, 0, 1967, 1968, 5, 31, 0, 0, 1968, 1970, 1, 0, 0, 0, 1969, 1963, 1, 0, 0, 0, 1969, 1964, 1, 0, 0, 0, 1970, 227, 1, 0, 0, 0, 1971, 1981, 3, 126, 63, 0, 1972, 1974, 5, 17, 0, 0, 1973, 1975, 3, 294, 147, 0, 1974, 1973, 1, 0, 0, 0, 1975, 1976, 1, 0, 0, 0, 1976, 1974, 1, 0, 0, 0, 1976, 1977, 1, 0, 0, 0, 1977, 1978, 1, 0, 0, 0, 1978, 1979, 5, 18, 0, 0, 1979, 1981, 1, 0, 0, 0, 1980, 1971, 1, 0, 0, 0, 1980, 1972, 1, 0, 0, 0, 1981, 229, 1, 0, 0, 0, 1982, 1984, 3, 232, 116, 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, 231, 1, 0, 0, 0, 1987, 1985, 1, 0, 0, 0, 1988, 1989, 5, 42, 0, 0, 1989, 1990, 5, 136, 0, 0, 1990, 2002, 5, 43, 0, 0, 1991, 1992, 5, 42, 0, 0, 1992, 1993, 5, 137, 0, 0, 1993, 2002, 5, 43, 0, 0, 1994, 1995, 5, 42, 0, 0, 1995, 1996, 5, 138, 0, 0, 1996, 2002, 5, 43, 0, 0, 1997, 1998, 5, 42, 0, 0, 1998, 1999, 3, 32, 16, 0, 1999, 2000, 5, 43, 0, 0, 2000, 2002, 1, 0, 0, 0, 2001, 1988, 1, 0, 0, 0, 2001, 1991, 1, 0, 0, 0, 2001, 1994, 1, 0, 0, 0, 2001, 1997, 1, 0, 0, 0, 2002, 233, 1, 0, 0, 0, 2003, 2008, 5, 139, 0, 0, 2004, 2007, 3, 236, 118, 0, 2005, 2007, 3, 238, 119, 0, 2006, 2004, 1, 0, 0, 0, 2006, 2005, 1, 0, 0, 0, 2007, 2010, 1, 0, 0, 0, 2008, 2006, 1, 0, 0, 0, 2008, 2009, 1, 0, 0, 0, 2009, 2011, 1, 0, 0, 0, 2010, 2008, 1, 0, 0, 0, 2011, 2012, 3, 170, 85, 0, 2012, 2013, 3, 230, 115, 0, 2013, 2014, 3, 138, 69, 0, 2014, 2015, 3, 226, 113, 0, 2015, 2016, 3, 242, 121, 0, 2016, 2017, 3, 182, 91, 0, 2017, 2021, 3, 112, 56, 0, 2018, 2020, 3, 244, 122, 0, 2019, 2018, 1, 0, 0, 0, 2020, 2023, 1, 0, 0, 0, 2021, 2019, 1, 0, 0, 0, 2021, 2022, 1, 0, 0, 0, 2022, 235, 1, 0, 0, 0, 2023, 2021, 1, 0, 0, 0, 2024, 2048, 5, 123, 0, 0, 2025, 2048, 5, 51, 0, 0, 2026, 2048, 5, 52, 0, 0, 2027, 2048, 5, 63, 0, 0, 2028, 2048, 5, 140, 0, 0, 2029, 2048, 5, 68, 0, 0, 2030, 2048, 5, 141, 0, 0, 2031, 2048, 5, 142, 0, 0, 2032, 2048, 5, 54, 0, 0, 2033, 2048, 5, 64, 0, 0, 2034, 2048, 5, 65, 0, 0, 2035, 2048, 5, 66, 0, 0, 2036, 2048, 5, 125, 0, 0, 2037, 2048, 5, 143, 0, 0, 2038, 2048, 5, 144, 0, 0, 2039, 2048, 5, 69, 0, 0, 2040, 2048, 5, 145, 0, 0, 2041, 2048, 5, 146, 0, 0, 2042, 2043, 5, 70, 0, 0, 2043, 2044, 5, 30, 0, 0, 2044, 2045, 3, 32, 16, 0, 2045, 2046, 5, 31, 0, 0, 2046, 2048, 1, 0, 0, 0, 2047, 2024, 1, 0, 0, 0, 2047, 2025, 1, 0, 0, 0, 2047, 2026, 1, 0, 0, 0, 2047, 2027, 1, 0, 0, 0, 2047, 2028, 1, 0, 0, 0, 2047, 2029, 1, 0, 0, 0, 2047, 2030, 1, 0, 0, 0, 2047, 2031, 1, 0, 0, 0, 2047, 2032, 1, 0, 0, 0, 2047, 2033, 1, 0, 0, 0, 2047, 2034, 1, 0, 0, 0, 2047, 2035, 1, 0, 0, 0, 2047, 2036, 1, 0, 0, 0, 2047, 2037, 1, 0, 0, 0, 2047, 2038, 1, 0, 0, 0, 2047, 2039, 1, 0, 0, 0, 2047, 2040, 1, 0, 0, 0, 2047, 2041, 1, 0, 0, 0, 2047, 2042, 1, 0, 0, 0, 2048, 237, 1, 0, 0, 0, 2049, 2050, 5, 147, 0, 0, 2050, 2056, 5, 30, 0, 0, 2051, 2054, 3, 6, 3, 0, 2052, 2053, 5, 34, 0, 0, 2053, 2055, 3, 6, 3, 0, 2054, 2052, 1, 0, 0, 0, 2054, 2055, 1, 0, 0, 0, 2055, 2057, 1, 0, 0, 0, 2056, 2051, 1, 0, 0, 0, 2056, 2057, 1, 0, 0, 0, 2057, 2061, 1, 0, 0, 0, 2058, 2060, 3, 240, 120, 0, 2059, 2058, 1, 0, 0, 0, 2060, 2063, 1, 0, 0, 0, 2061, 2059, 1, 0, 0, 0, 2061, 2062, 1, 0, 0, 0, 2062, 2064, 1, 0, 0, 0, 2063, 2061, 1, 0, 0, 0, 2064, 2068, 5, 31, 0, 0, 2065, 2066, 5, 147, 0, 0, 2066, 2068, 5, 85, 0, 0, 2067, 2049, 1, 0, 0, 0, 2067, 2065, 1, 0, 0, 0, 2068, 239, 1, 0, 0, 0, 2069, 2097, 5, 148, 0, 0, 2070, 2097, 5, 224, 0, 0, 2071, 2097, 5, 57, 0, 0, 2072, 2097, 5, 58, 0, 0, 2073, 2097, 5, 149, 0, 0, 2074, 2097, 5, 150, 0, 0, 2075, 2097, 5, 248, 0, 0, 2076, 2097, 5, 249, 0, 0, 2077, 2097, 5, 250, 0, 0, 2078, 2097, 5, 251, 0, 0, 2079, 2080, 5, 151, 0, 0, 2080, 2081, 5, 75, 0, 0, 2081, 2097, 5, 152, 0, 0, 2082, 2083, 5, 151, 0, 0, 2083, 2084, 5, 75, 0, 0, 2084, 2097, 5, 153, 0, 0, 2085, 2086, 5, 154, 0, 0, 2086, 2087, 5, 75, 0, 0, 2087, 2097, 5, 152, 0, 0, 2088, 2089, 5, 154, 0, 0, 2089, 2090, 5, 75, 0, 0, 2090, 2097, 5, 153, 0, 0, 2091, 2092, 5, 70, 0, 0, 2092, 2093, 5, 30, 0, 0, 2093, 2094, 3, 32, 16, 0, 2094, 2095, 5, 31, 0, 0, 2095, 2097, 1, 0, 0, 0, 2096, 2069, 1, 0, 0, 0, 2096, 2070, 1, 0, 0, 0, 2096, 2071, 1, 0, 0, 0, 2096, 2072, 1, 0, 0, 0, 2096, 2073, 1, 0, 0, 0, 2096, 2074, 1, 0, 0, 0, 2096, 2075, 1, 0, 0, 0, 2096, 2076, 1, 0, 0, 0, 2096, 2077, 1, 0, 0, 0, 2096, 2078, 1, 0, 0, 0, 2096, 2079, 1, 0, 0, 0, 2096, 2082, 1, 0, 0, 0, 2096, 2085, 1, 0, 0, 0, 2096, 2088, 1, 0, 0, 0, 2096, 2091, 1, 0, 0, 0, 2097, 241, 1, 0, 0, 0, 2098, 2102, 5, 116, 0, 0, 2099, 2102, 5, 155, 0, 0, 2100, 2102, 3, 2, 1, 0, 2101, 2098, 1, 0, 0, 0, 2101, 2099, 1, 0, 0, 0, 2101, 2100, 1, 0, 0, 0, 2102, 243, 1, 0, 0, 0, 2103, 2125, 5, 1, 0, 0, 2104, 2125, 5, 2, 0, 0, 2105, 2125, 5, 156, 0, 0, 2106, 2125, 5, 3, 0, 0, 2107, 2125, 5, 4, 0, 0, 2108, 2125, 5, 247, 0, 0, 2109, 2125, 5, 5, 0, 0, 2110, 2125, 5, 6, 0, 0, 2111, 2125, 5, 7, 0, 0, 2112, 2125, 5, 8, 0, 0, 2113, 2125, 5, 9, 0, 0, 2114, 2125, 5, 10, 0, 0, 2115, 2125, 5, 11, 0, 0, 2116, 2125, 5, 12, 0, 0, 2117, 2125, 5, 13, 0, 0, 2118, 2125, 5, 14, 0, 0, 2119, 2120, 5, 70, 0, 0, 2120, 2121, 5, 30, 0, 0, 2121, 2122, 3, 32, 16, 0, 2122, 2123, 5, 31, 0, 0, 2123, 2125, 1, 0, 0, 0, 2124, 2103, 1, 0, 0, 0, 2124, 2104, 1, 0, 0, 0, 2124, 2105, 1, 0, 0, 0, 2124, 2106, 1, 0, 0, 0, 2124, 2107, 1, 0, 0, 0, 2124, 2108, 1, 0, 0, 0, 2124, 2109, 1, 0, 0, 0, 2124, 2110, 1, 0, 0, 0, 2124, 2111, 1, 0, 0, 0, 2124, 2112, 1, 0, 0, 0, 2124, 2113, 1, 0, 0, 0, 2124, 2114, 1, 0, 0, 0, 2124, 2115, 1, 0, 0, 0, 2124, 2116, 1, 0, 0, 0, 2124, 2117, 1, 0, 0, 0, 2124, 2118, 1, 0, 0, 0, 2124, 2119, 1, 0, 0, 0, 2125, 245, 1, 0, 0, 0, 2126, 2128, 3, 248, 124, 0, 2127, 2126, 1, 0, 0, 0, 2128, 2131, 1, 0, 0, 0, 2129, 2127, 1, 0, 0, 0, 2129, 2130, 1, 0, 0, 0, 2130, 247, 1, 0, 0, 0, 2131, 2129, 1, 0, 0, 0, 2132, 2150, 3, 100, 50, 0, 2133, 2134, 5, 296, 0, 0, 2134, 2135, 3, 32, 16, 0, 2135, 2136, 6, 124, -1, 0, 2136, 2150, 1, 0, 0, 0, 2137, 2150, 3, 258, 129, 0, 2138, 2139, 5, 297, 0, 0, 2139, 2140, 3, 32, 16, 0, 2140, 2141, 6, 124, -1, 0, 2141, 2150, 1, 0, 0, 0, 2142, 2143, 5, 298, 0, 0, 2143, 2150, 6, 124, -1, 0, 2144, 2145, 5, 299, 0, 0, 2145, 2150, 6, 124, -1, 0, 2146, 2150, 3, 252, 126, 0, 2147, 2150, 3, 256, 128, 0, 2148, 2150, 3, 250, 125, 0, 2149, 2132, 1, 0, 0, 0, 2149, 2133, 1, 0, 0, 0, 2149, 2137, 1, 0, 0, 0, 2149, 2138, 1, 0, 0, 0, 2149, 2142, 1, 0, 0, 0, 2149, 2144, 1, 0, 0, 0, 2149, 2146, 1, 0, 0, 0, 2149, 2147, 1, 0, 0, 0, 2149, 2148, 1, 0, 0, 0, 2150, 249, 1, 0, 0, 0, 2151, 2152, 5, 300, 0, 0, 2152, 2250, 3, 112, 56, 0, 2153, 2154, 5, 300, 0, 0, 2154, 2155, 5, 157, 0, 0, 2155, 2250, 3, 112, 56, 0, 2156, 2250, 3, 276, 138, 0, 2157, 2250, 3, 152, 76, 0, 2158, 2250, 3, 88, 44, 0, 2159, 2250, 3, 26, 13, 0, 2160, 2250, 3, 254, 127, 0, 2161, 2250, 3, 40, 20, 0, 2162, 2163, 5, 301, 0, 0, 2163, 2164, 5, 42, 0, 0, 2164, 2165, 3, 32, 16, 0, 2165, 2166, 5, 43, 0, 0, 2166, 2250, 1, 0, 0, 0, 2167, 2168, 5, 301, 0, 0, 2168, 2169, 5, 42, 0, 0, 2169, 2170, 3, 32, 16, 0, 2170, 2171, 5, 43, 0, 0, 2171, 2172, 5, 34, 0, 0, 2172, 2173, 3, 0, 0, 0, 2173, 2250, 1, 0, 0, 0, 2174, 2175, 5, 303, 0, 0, 2175, 2176, 3, 32, 16, 0, 2176, 2177, 5, 75, 0, 0, 2177, 2178, 3, 32, 16, 0, 2178, 2250, 1, 0, 0, 0, 2179, 2180, 5, 302, 0, 0, 2180, 2181, 3, 124, 62, 0, 2181, 2182, 5, 176, 0, 0, 2182, 2183, 3, 242, 121, 0, 2183, 2250, 1, 0, 0, 0, 2184, 2185, 5, 302, 0, 0, 2185, 2186, 5, 226, 0, 0, 2186, 2187, 3, 170, 85, 0, 2187, 2188, 3, 138, 69, 0, 2188, 2189, 3, 124, 62, 0, 2189, 2190, 5, 176, 0, 0, 2190, 2191, 3, 242, 121, 0, 2191, 2192, 3, 194, 97, 0, 2192, 2193, 3, 112, 56, 0, 2193, 2250, 1, 0, 0, 0, 2194, 2195, 5, 255, 0, 0, 2195, 2196, 5, 196, 0, 0, 2196, 2197, 5, 42, 0, 0, 2197, 2198, 3, 32, 16, 0, 2198, 2202, 5, 43, 0, 0, 2199, 2201, 3, 322, 161, 0, 2200, 2199, 1, 0, 0, 0, 2201, 2204, 1, 0, 0, 0, 2202, 2200, 1, 0, 0, 0, 2202, 2203, 1, 0, 0, 0, 2203, 2250, 1, 0, 0, 0, 2204, 2202, 1, 0, 0, 0, 2205, 2206, 5, 255, 0, 0, 2206, 2207, 5, 196, 0, 0, 2207, 2211, 3, 2, 1, 0, 2208, 2210, 3, 322, 161, 0, 2209, 2208, 1, 0, 0, 0, 2210, 2213, 1, 0, 0, 0, 2211, 2209, 1, 0, 0, 0, 2211, 2212, 1, 0, 0, 0, 2212, 2250, 1, 0, 0, 0, 2213, 2211, 1, 0, 0, 0, 2214, 2215, 5, 255, 0, 0, 2215, 2216, 5, 256, 0, 0, 2216, 2217, 5, 42, 0, 0, 2217, 2218, 3, 32, 16, 0, 2218, 2219, 5, 43, 0, 0, 2219, 2220, 5, 28, 0, 0, 2220, 2224, 3, 124, 62, 0, 2221, 2223, 3, 322, 161, 0, 2222, 2221, 1, 0, 0, 0, 2223, 2226, 1, 0, 0, 0, 2224, 2222, 1, 0, 0, 0, 2224, 2225, 1, 0, 0, 0, 2225, 2250, 1, 0, 0, 0, 2226, 2224, 1, 0, 0, 0, 2227, 2228, 5, 255, 0, 0, 2228, 2229, 5, 256, 0, 0, 2229, 2230, 3, 2, 1, 0, 2230, 2231, 5, 28, 0, 0, 2231, 2235, 3, 124, 62, 0, 2232, 2234, 3, 322, 161, 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, 2250, 1, 0, 0, 0, 2237, 2235, 1, 0, 0, 0, 2238, 2239, 5, 255, 0, 0, 2239, 2240, 5, 42, 0, 0, 2240, 2241, 3, 32, 16, 0, 2241, 2242, 5, 43, 0, 0, 2242, 2246, 3, 206, 103, 0, 2243, 2245, 3, 322, 161, 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, 2250, 1, 0, 0, 0, 2248, 2246, 1, 0, 0, 0, 2249, 2151, 1, 0, 0, 0, 2249, 2153, 1, 0, 0, 0, 2249, 2156, 1, 0, 0, 0, 2249, 2157, 1, 0, 0, 0, 2249, 2158, 1, 0, 0, 0, 2249, 2159, 1, 0, 0, 0, 2249, 2160, 1, 0, 0, 0, 2249, 2161, 1, 0, 0, 0, 2249, 2162, 1, 0, 0, 0, 2249, 2167, 1, 0, 0, 0, 2249, 2174, 1, 0, 0, 0, 2249, 2179, 1, 0, 0, 0, 2249, 2184, 1, 0, 0, 0, 2249, 2194, 1, 0, 0, 0, 2249, 2205, 1, 0, 0, 0, 2249, 2214, 1, 0, 0, 0, 2249, 2227, 1, 0, 0, 0, 2249, 2238, 1, 0, 0, 0, 2250, 251, 1, 0, 0, 0, 2251, 2252, 3, 0, 0, 0, 2252, 2253, 5, 75, 0, 0, 2253, 2254, 6, 126, -1, 0, 2254, 253, 1, 0, 0, 0, 2255, 2258, 3, 44, 22, 0, 2256, 2258, 3, 46, 23, 0, 2257, 2255, 1, 0, 0, 0, 2257, 2256, 1, 0, 0, 0, 2258, 255, 1, 0, 0, 0, 2259, 2260, 5, 17, 0, 0, 2260, 2261, 3, 246, 123, 0, 2261, 2262, 5, 18, 0, 0, 2262, 257, 1, 0, 0, 0, 2263, 2264, 3, 262, 131, 0, 2264, 2265, 3, 260, 130, 0, 2265, 259, 1, 0, 0, 0, 2266, 2268, 3, 264, 132, 0, 2267, 2266, 1, 0, 0, 0, 2268, 2269, 1, 0, 0, 0, 2269, 2267, 1, 0, 0, 0, 2269, 2270, 1, 0, 0, 0, 2270, 261, 1, 0, 0, 0, 2271, 2272, 5, 158, 0, 0, 2272, 2284, 3, 256, 128, 0, 2273, 2274, 5, 158, 0, 0, 2274, 2275, 3, 0, 0, 0, 2275, 2276, 5, 159, 0, 0, 2276, 2277, 3, 0, 0, 0, 2277, 2284, 1, 0, 0, 0, 2278, 2279, 5, 158, 0, 0, 2279, 2280, 3, 32, 16, 0, 2280, 2281, 5, 159, 0, 0, 2281, 2282, 3, 32, 16, 0, 2282, 2284, 1, 0, 0, 0, 2283, 2271, 1, 0, 0, 0, 2283, 2273, 1, 0, 0, 0, 2283, 2278, 1, 0, 0, 0, 2284, 263, 1, 0, 0, 0, 2285, 2286, 3, 268, 134, 0, 2286, 2287, 3, 274, 137, 0, 2287, 2298, 1, 0, 0, 0, 2288, 2289, 3, 266, 133, 0, 2289, 2290, 3, 274, 137, 0, 2290, 2298, 1, 0, 0, 0, 2291, 2292, 3, 270, 135, 0, 2292, 2293, 3, 274, 137, 0, 2293, 2298, 1, 0, 0, 0, 2294, 2295, 3, 272, 136, 0, 2295, 2296, 3, 274, 137, 0, 2296, 2298, 1, 0, 0, 0, 2297, 2285, 1, 0, 0, 0, 2297, 2288, 1, 0, 0, 0, 2297, 2291, 1, 0, 0, 0, 2297, 2294, 1, 0, 0, 0, 2298, 265, 1, 0, 0, 0, 2299, 2300, 5, 160, 0, 0, 2300, 2306, 3, 256, 128, 0, 2301, 2302, 5, 160, 0, 0, 2302, 2306, 3, 0, 0, 0, 2303, 2304, 5, 160, 0, 0, 2304, 2306, 3, 32, 16, 0, 2305, 2299, 1, 0, 0, 0, 2305, 2301, 1, 0, 0, 0, 2305, 2303, 1, 0, 0, 0, 2306, 267, 1, 0, 0, 0, 2307, 2308, 5, 161, 0, 0, 2308, 2309, 3, 124, 62, 0, 2309, 269, 1, 0, 0, 0, 2310, 2311, 5, 162, 0, 0, 2311, 271, 1, 0, 0, 0, 2312, 2313, 5, 163, 0, 0, 2313, 273, 1, 0, 0, 0, 2314, 2326, 3, 256, 128, 0, 2315, 2316, 5, 164, 0, 0, 2316, 2317, 3, 0, 0, 0, 2317, 2318, 5, 159, 0, 0, 2318, 2319, 3, 0, 0, 0, 2319, 2326, 1, 0, 0, 0, 2320, 2321, 5, 164, 0, 0, 2321, 2322, 3, 32, 16, 0, 2322, 2323, 5, 159, 0, 0, 2323, 2324, 3, 32, 16, 0, 2324, 2326, 1, 0, 0, 0, 2325, 2314, 1, 0, 0, 0, 2325, 2315, 1, 0, 0, 0, 2325, 2320, 1, 0, 0, 0, 2326, 275, 1, 0, 0, 0, 2327, 2328, 3, 278, 139, 0, 2328, 2329, 3, 282, 141, 0, 2329, 277, 1, 0, 0, 0, 2330, 2331, 5, 165, 0, 0, 2331, 2332, 3, 280, 140, 0, 2332, 2333, 3, 0, 0, 0, 2333, 2334, 5, 36, 0, 0, 2334, 2338, 1, 0, 0, 0, 2335, 2336, 5, 165, 0, 0, 2336, 2338, 3, 280, 140, 0, 2337, 2330, 1, 0, 0, 0, 2337, 2335, 1, 0, 0, 0, 2338, 279, 1, 0, 0, 0, 2339, 2343, 1, 0, 0, 0, 2340, 2343, 5, 166, 0, 0, 2341, 2343, 5, 2, 0, 0, 2342, 2339, 1, 0, 0, 0, 2342, 2340, 1, 0, 0, 0, 2342, 2341, 1, 0, 0, 0, 2343, 281, 1, 0, 0, 0, 2344, 2345, 5, 17, 0, 0, 2345, 2346, 3, 284, 142, 0, 2346, 2347, 5, 18, 0, 0, 2347, 2354, 1, 0, 0, 0, 2348, 2350, 3, 288, 144, 0, 2349, 2348, 1, 0, 0, 0, 2350, 2351, 1, 0, 0, 0, 2351, 2349, 1, 0, 0, 0, 2351, 2352, 1, 0, 0, 0, 2352, 2354, 1, 0, 0, 0, 2353, 2344, 1, 0, 0, 0, 2353, 2349, 1, 0, 0, 0, 2354, 283, 1, 0, 0, 0, 2355, 2356, 3, 288, 144, 0, 2356, 2357, 5, 28, 0, 0, 2357, 2359, 1, 0, 0, 0, 2358, 2355, 1, 0, 0, 0, 2359, 2362, 1, 0, 0, 0, 2360, 2358, 1, 0, 0, 0, 2360, 2361, 1, 0, 0, 0, 2361, 2363, 1, 0, 0, 0, 2362, 2360, 1, 0, 0, 0, 2363, 2364, 3, 288, 144, 0, 2364, 285, 1, 0, 0, 0, 2365, 2371, 1, 0, 0, 0, 2366, 2367, 5, 42, 0, 0, 2367, 2368, 3, 32, 16, 0, 2368, 2369, 5, 43, 0, 0, 2369, 2371, 1, 0, 0, 0, 2370, 2365, 1, 0, 0, 0, 2370, 2366, 1, 0, 0, 0, 2371, 287, 1, 0, 0, 0, 2372, 2373, 5, 181, 0, 0, 2373, 2374, 5, 262, 0, 0, 2374, 2375, 5, 30, 0, 0, 2375, 2376, 3, 6, 3, 0, 2376, 2377, 5, 31, 0, 0, 2377, 2439, 1, 0, 0, 0, 2378, 2379, 5, 260, 0, 0, 2379, 2380, 5, 30, 0, 0, 2380, 2381, 3, 0, 0, 0, 2381, 2382, 5, 31, 0, 0, 2382, 2439, 1, 0, 0, 0, 2383, 2384, 5, 260, 0, 0, 2384, 2439, 3, 0, 0, 0, 2385, 2386, 5, 84, 0, 0, 2386, 2387, 5, 30, 0, 0, 2387, 2388, 3, 292, 146, 0, 2388, 2389, 5, 31, 0, 0, 2389, 2439, 1, 0, 0, 0, 2390, 2391, 5, 188, 0, 0, 2391, 2392, 5, 30, 0, 0, 2392, 2393, 3, 36, 18, 0, 2393, 2394, 5, 31, 0, 0, 2394, 2395, 3, 286, 143, 0, 2395, 2439, 1, 0, 0, 0, 2396, 2397, 5, 189, 0, 0, 2397, 2398, 5, 30, 0, 0, 2398, 2399, 3, 36, 18, 0, 2399, 2400, 5, 31, 0, 0, 2400, 2401, 3, 286, 143, 0, 2401, 2439, 1, 0, 0, 0, 2402, 2403, 5, 187, 0, 0, 2403, 2404, 5, 30, 0, 0, 2404, 2405, 3, 34, 17, 0, 2405, 2406, 5, 31, 0, 0, 2406, 2407, 3, 286, 143, 0, 2407, 2439, 1, 0, 0, 0, 2408, 2409, 5, 186, 0, 0, 2409, 2410, 5, 30, 0, 0, 2410, 2411, 3, 32, 16, 0, 2411, 2412, 5, 31, 0, 0, 2412, 2413, 3, 286, 143, 0, 2413, 2439, 1, 0, 0, 0, 2414, 2415, 5, 185, 0, 0, 2415, 2416, 5, 30, 0, 0, 2416, 2417, 3, 32, 16, 0, 2417, 2418, 5, 31, 0, 0, 2418, 2419, 3, 286, 143, 0, 2419, 2439, 1, 0, 0, 0, 2420, 2421, 5, 184, 0, 0, 2421, 2422, 5, 30, 0, 0, 2422, 2423, 3, 32, 16, 0, 2423, 2424, 5, 31, 0, 0, 2424, 2425, 3, 286, 143, 0, 2425, 2439, 1, 0, 0, 0, 2426, 2427, 5, 188, 0, 0, 2427, 2439, 3, 286, 143, 0, 2428, 2429, 5, 189, 0, 0, 2429, 2439, 3, 286, 143, 0, 2430, 2431, 5, 187, 0, 0, 2431, 2439, 3, 286, 143, 0, 2432, 2433, 5, 186, 0, 0, 2433, 2439, 3, 286, 143, 0, 2434, 2435, 5, 185, 0, 0, 2435, 2439, 3, 286, 143, 0, 2436, 2437, 5, 184, 0, 0, 2437, 2439, 3, 286, 143, 0, 2438, 2372, 1, 0, 0, 0, 2438, 2378, 1, 0, 0, 0, 2438, 2383, 1, 0, 0, 0, 2438, 2385, 1, 0, 0, 0, 2438, 2390, 1, 0, 0, 0, 2438, 2396, 1, 0, 0, 0, 2438, 2402, 1, 0, 0, 0, 2438, 2408, 1, 0, 0, 0, 2438, 2414, 1, 0, 0, 0, 2438, 2420, 1, 0, 0, 0, 2438, 2426, 1, 0, 0, 0, 2438, 2428, 1, 0, 0, 0, 2438, 2430, 1, 0, 0, 0, 2438, 2432, 1, 0, 0, 0, 2438, 2434, 1, 0, 0, 0, 2438, 2436, 1, 0, 0, 0, 2439, 289, 1, 0, 0, 0, 2440, 2441, 5, 188, 0, 0, 2441, 2442, 5, 30, 0, 0, 2442, 2443, 3, 36, 18, 0, 2443, 2444, 5, 31, 0, 0, 2444, 2516, 1, 0, 0, 0, 2445, 2446, 5, 189, 0, 0, 2446, 2447, 5, 30, 0, 0, 2447, 2448, 3, 36, 18, 0, 2448, 2449, 5, 31, 0, 0, 2449, 2516, 1, 0, 0, 0, 2450, 2451, 5, 188, 0, 0, 2451, 2452, 5, 30, 0, 0, 2452, 2453, 3, 32, 16, 0, 2453, 2454, 5, 31, 0, 0, 2454, 2516, 1, 0, 0, 0, 2455, 2456, 5, 189, 0, 0, 2456, 2457, 5, 30, 0, 0, 2457, 2458, 3, 34, 17, 0, 2458, 2459, 5, 31, 0, 0, 2459, 2516, 1, 0, 0, 0, 2460, 2461, 5, 187, 0, 0, 2461, 2462, 5, 30, 0, 0, 2462, 2463, 3, 34, 17, 0, 2463, 2464, 5, 31, 0, 0, 2464, 2516, 1, 0, 0, 0, 2465, 2466, 5, 186, 0, 0, 2466, 2467, 5, 30, 0, 0, 2467, 2468, 3, 32, 16, 0, 2468, 2469, 5, 31, 0, 0, 2469, 2516, 1, 0, 0, 0, 2470, 2471, 5, 185, 0, 0, 2471, 2472, 5, 30, 0, 0, 2472, 2473, 3, 32, 16, 0, 2473, 2474, 5, 31, 0, 0, 2474, 2516, 1, 0, 0, 0, 2475, 2476, 5, 184, 0, 0, 2476, 2477, 5, 30, 0, 0, 2477, 2478, 3, 32, 16, 0, 2478, 2479, 5, 31, 0, 0, 2479, 2516, 1, 0, 0, 0, 2480, 2481, 5, 193, 0, 0, 2481, 2482, 5, 30, 0, 0, 2482, 2483, 3, 34, 17, 0, 2483, 2484, 5, 31, 0, 0, 2484, 2516, 1, 0, 0, 0, 2485, 2486, 5, 192, 0, 0, 2486, 2487, 5, 30, 0, 0, 2487, 2488, 3, 32, 16, 0, 2488, 2489, 5, 31, 0, 0, 2489, 2516, 1, 0, 0, 0, 2490, 2491, 5, 191, 0, 0, 2491, 2492, 5, 30, 0, 0, 2492, 2493, 3, 32, 16, 0, 2493, 2494, 5, 31, 0, 0, 2494, 2516, 1, 0, 0, 0, 2495, 2496, 5, 190, 0, 0, 2496, 2497, 5, 30, 0, 0, 2497, 2498, 3, 32, 16, 0, 2498, 2499, 5, 31, 0, 0, 2499, 2516, 1, 0, 0, 0, 2500, 2501, 5, 181, 0, 0, 2501, 2502, 5, 30, 0, 0, 2502, 2503, 3, 32, 16, 0, 2503, 2504, 5, 31, 0, 0, 2504, 2516, 1, 0, 0, 0, 2505, 2506, 5, 183, 0, 0, 2506, 2507, 5, 30, 0, 0, 2507, 2508, 3, 162, 81, 0, 2508, 2509, 5, 31, 0, 0, 2509, 2516, 1, 0, 0, 0, 2510, 2511, 5, 84, 0, 0, 2511, 2512, 5, 30, 0, 0, 2512, 2513, 3, 292, 146, 0, 2513, 2514, 5, 31, 0, 0, 2514, 2516, 1, 0, 0, 0, 2515, 2440, 1, 0, 0, 0, 2515, 2445, 1, 0, 0, 0, 2515, 2450, 1, 0, 0, 0, 2515, 2455, 1, 0, 0, 0, 2515, 2460, 1, 0, 0, 0, 2515, 2465, 1, 0, 0, 0, 2515, 2470, 1, 0, 0, 0, 2515, 2475, 1, 0, 0, 0, 2515, 2480, 1, 0, 0, 0, 2515, 2485, 1, 0, 0, 0, 2515, 2490, 1, 0, 0, 0, 2515, 2495, 1, 0, 0, 0, 2515, 2500, 1, 0, 0, 0, 2515, 2505, 1, 0, 0, 0, 2515, 2510, 1, 0, 0, 0, 2516, 291, 1, 0, 0, 0, 2517, 2518, 3, 294, 147, 0, 2518, 2519, 6, 146, -1, 0, 2519, 2521, 1, 0, 0, 0, 2520, 2517, 1, 0, 0, 0, 2521, 2524, 1, 0, 0, 0, 2522, 2520, 1, 0, 0, 0, 2522, 2523, 1, 0, 0, 0, 2523, 293, 1, 0, 0, 0, 2524, 2522, 1, 0, 0, 0, 2525, 2526, 7, 12, 0, 0, 2526, 295, 1, 0, 0, 0, 2527, 2531, 3, 290, 145, 0, 2528, 2531, 3, 6, 3, 0, 2529, 2531, 5, 179, 0, 0, 2530, 2527, 1, 0, 0, 0, 2530, 2528, 1, 0, 0, 0, 2530, 2529, 1, 0, 0, 0, 2531, 297, 1, 0, 0, 0, 2532, 2681, 3, 290, 145, 0, 2533, 2534, 5, 182, 0, 0, 2534, 2535, 5, 30, 0, 0, 2535, 2536, 5, 179, 0, 0, 2536, 2681, 5, 31, 0, 0, 2537, 2538, 5, 182, 0, 0, 2538, 2539, 5, 30, 0, 0, 2539, 2540, 5, 264, 0, 0, 2540, 2681, 5, 31, 0, 0, 2541, 2542, 5, 196, 0, 0, 2542, 2543, 5, 30, 0, 0, 2543, 2544, 5, 39, 0, 0, 2544, 2545, 5, 264, 0, 0, 2545, 2681, 5, 31, 0, 0, 2546, 2547, 5, 196, 0, 0, 2547, 2548, 5, 30, 0, 0, 2548, 2549, 3, 116, 58, 0, 2549, 2550, 5, 31, 0, 0, 2550, 2681, 1, 0, 0, 0, 2551, 2552, 5, 196, 0, 0, 2552, 2553, 5, 30, 0, 0, 2553, 2554, 5, 179, 0, 0, 2554, 2681, 5, 31, 0, 0, 2555, 2556, 5, 197, 0, 0, 2556, 2557, 5, 30, 0, 0, 2557, 2558, 3, 298, 149, 0, 2558, 2559, 5, 31, 0, 0, 2559, 2681, 1, 0, 0, 0, 2560, 2561, 5, 188, 0, 0, 2561, 2562, 5, 42, 0, 0, 2562, 2563, 3, 32, 16, 0, 2563, 2564, 5, 43, 0, 0, 2564, 2565, 5, 30, 0, 0, 2565, 2566, 3, 300, 150, 0, 2566, 2567, 5, 31, 0, 0, 2567, 2681, 1, 0, 0, 0, 2568, 2569, 5, 189, 0, 0, 2569, 2570, 5, 42, 0, 0, 2570, 2571, 3, 32, 16, 0, 2571, 2572, 5, 43, 0, 0, 2572, 2573, 5, 30, 0, 0, 2573, 2574, 3, 302, 151, 0, 2574, 2575, 5, 31, 0, 0, 2575, 2681, 1, 0, 0, 0, 2576, 2577, 5, 187, 0, 0, 2577, 2578, 5, 42, 0, 0, 2578, 2579, 3, 32, 16, 0, 2579, 2580, 5, 43, 0, 0, 2580, 2581, 5, 30, 0, 0, 2581, 2582, 3, 304, 152, 0, 2582, 2583, 5, 31, 0, 0, 2583, 2681, 1, 0, 0, 0, 2584, 2585, 5, 186, 0, 0, 2585, 2586, 5, 42, 0, 0, 2586, 2587, 3, 32, 16, 0, 2587, 2588, 5, 43, 0, 0, 2588, 2589, 5, 30, 0, 0, 2589, 2590, 3, 306, 153, 0, 2590, 2591, 5, 31, 0, 0, 2591, 2681, 1, 0, 0, 0, 2592, 2593, 5, 185, 0, 0, 2593, 2594, 5, 42, 0, 0, 2594, 2595, 3, 32, 16, 0, 2595, 2596, 5, 43, 0, 0, 2596, 2597, 5, 30, 0, 0, 2597, 2598, 3, 308, 154, 0, 2598, 2599, 5, 31, 0, 0, 2599, 2681, 1, 0, 0, 0, 2600, 2601, 5, 184, 0, 0, 2601, 2602, 5, 42, 0, 0, 2602, 2603, 3, 32, 16, 0, 2603, 2604, 5, 43, 0, 0, 2604, 2605, 5, 30, 0, 0, 2605, 2606, 3, 310, 155, 0, 2606, 2607, 5, 31, 0, 0, 2607, 2681, 1, 0, 0, 0, 2608, 2609, 5, 193, 0, 0, 2609, 2610, 5, 42, 0, 0, 2610, 2611, 3, 32, 16, 0, 2611, 2612, 5, 43, 0, 0, 2612, 2613, 5, 30, 0, 0, 2613, 2614, 3, 304, 152, 0, 2614, 2615, 5, 31, 0, 0, 2615, 2681, 1, 0, 0, 0, 2616, 2617, 5, 192, 0, 0, 2617, 2618, 5, 42, 0, 0, 2618, 2619, 3, 32, 16, 0, 2619, 2620, 5, 43, 0, 0, 2620, 2621, 5, 30, 0, 0, 2621, 2622, 3, 306, 153, 0, 2622, 2623, 5, 31, 0, 0, 2623, 2681, 1, 0, 0, 0, 2624, 2625, 5, 191, 0, 0, 2625, 2626, 5, 42, 0, 0, 2626, 2627, 3, 32, 16, 0, 2627, 2628, 5, 43, 0, 0, 2628, 2629, 5, 30, 0, 0, 2629, 2630, 3, 308, 154, 0, 2630, 2631, 5, 31, 0, 0, 2631, 2681, 1, 0, 0, 0, 2632, 2633, 5, 190, 0, 0, 2633, 2634, 5, 42, 0, 0, 2634, 2635, 3, 32, 16, 0, 2635, 2636, 5, 43, 0, 0, 2636, 2637, 5, 30, 0, 0, 2637, 2638, 3, 310, 155, 0, 2638, 2639, 5, 31, 0, 0, 2639, 2681, 1, 0, 0, 0, 2640, 2641, 5, 181, 0, 0, 2641, 2642, 5, 42, 0, 0, 2642, 2643, 3, 32, 16, 0, 2643, 2644, 5, 43, 0, 0, 2644, 2645, 5, 30, 0, 0, 2645, 2646, 3, 308, 154, 0, 2646, 2647, 5, 31, 0, 0, 2647, 2681, 1, 0, 0, 0, 2648, 2649, 5, 183, 0, 0, 2649, 2650, 5, 42, 0, 0, 2650, 2651, 3, 32, 16, 0, 2651, 2652, 5, 43, 0, 0, 2652, 2653, 5, 30, 0, 0, 2653, 2654, 3, 312, 156, 0, 2654, 2655, 5, 31, 0, 0, 2655, 2681, 1, 0, 0, 0, 2656, 2657, 5, 182, 0, 0, 2657, 2658, 5, 42, 0, 0, 2658, 2659, 3, 32, 16, 0, 2659, 2660, 5, 43, 0, 0, 2660, 2661, 5, 30, 0, 0, 2661, 2662, 3, 314, 157, 0, 2662, 2663, 5, 31, 0, 0, 2663, 2681, 1, 0, 0, 0, 2664, 2665, 5, 196, 0, 0, 2665, 2666, 5, 42, 0, 0, 2666, 2667, 3, 32, 16, 0, 2667, 2668, 5, 43, 0, 0, 2668, 2669, 5, 30, 0, 0, 2669, 2670, 3, 316, 158, 0, 2670, 2671, 5, 31, 0, 0, 2671, 2681, 1, 0, 0, 0, 2672, 2673, 5, 197, 0, 0, 2673, 2674, 5, 42, 0, 0, 2674, 2675, 3, 32, 16, 0, 2675, 2676, 5, 43, 0, 0, 2676, 2677, 5, 30, 0, 0, 2677, 2678, 3, 320, 160, 0, 2678, 2679, 5, 31, 0, 0, 2679, 2681, 1, 0, 0, 0, 2680, 2532, 1, 0, 0, 0, 2680, 2533, 1, 0, 0, 0, 2680, 2537, 1, 0, 0, 0, 2680, 2541, 1, 0, 0, 0, 2680, 2546, 1, 0, 0, 0, 2680, 2551, 1, 0, 0, 0, 2680, 2555, 1, 0, 0, 0, 2680, 2560, 1, 0, 0, 0, 2680, 2568, 1, 0, 0, 0, 2680, 2576, 1, 0, 0, 0, 2680, 2584, 1, 0, 0, 0, 2680, 2592, 1, 0, 0, 0, 2680, 2600, 1, 0, 0, 0, 2680, 2608, 1, 0, 0, 0, 2680, 2616, 1, 0, 0, 0, 2680, 2624, 1, 0, 0, 0, 2680, 2632, 1, 0, 0, 0, 2680, 2640, 1, 0, 0, 0, 2680, 2648, 1, 0, 0, 0, 2680, 2656, 1, 0, 0, 0, 2680, 2664, 1, 0, 0, 0, 2680, 2672, 1, 0, 0, 0, 2681, 299, 1, 0, 0, 0, 2682, 2685, 3, 36, 18, 0, 2683, 2685, 3, 32, 16, 0, 2684, 2682, 1, 0, 0, 0, 2684, 2683, 1, 0, 0, 0, 2685, 2688, 1, 0, 0, 0, 2686, 2684, 1, 0, 0, 0, 2686, 2687, 1, 0, 0, 0, 2687, 301, 1, 0, 0, 0, 2688, 2686, 1, 0, 0, 0, 2689, 2692, 3, 36, 18, 0, 2690, 2692, 3, 34, 17, 0, 2691, 2689, 1, 0, 0, 0, 2691, 2690, 1, 0, 0, 0, 2692, 2695, 1, 0, 0, 0, 2693, 2691, 1, 0, 0, 0, 2693, 2694, 1, 0, 0, 0, 2694, 303, 1, 0, 0, 0, 2695, 2693, 1, 0, 0, 0, 2696, 2698, 3, 34, 17, 0, 2697, 2696, 1, 0, 0, 0, 2698, 2701, 1, 0, 0, 0, 2699, 2697, 1, 0, 0, 0, 2699, 2700, 1, 0, 0, 0, 2700, 305, 1, 0, 0, 0, 2701, 2699, 1, 0, 0, 0, 2702, 2704, 3, 32, 16, 0, 2703, 2702, 1, 0, 0, 0, 2704, 2707, 1, 0, 0, 0, 2705, 2703, 1, 0, 0, 0, 2705, 2706, 1, 0, 0, 0, 2706, 307, 1, 0, 0, 0, 2707, 2705, 1, 0, 0, 0, 2708, 2710, 3, 32, 16, 0, 2709, 2708, 1, 0, 0, 0, 2710, 2713, 1, 0, 0, 0, 2711, 2709, 1, 0, 0, 0, 2711, 2712, 1, 0, 0, 0, 2712, 309, 1, 0, 0, 0, 2713, 2711, 1, 0, 0, 0, 2714, 2716, 3, 32, 16, 0, 2715, 2714, 1, 0, 0, 0, 2716, 2719, 1, 0, 0, 0, 2717, 2715, 1, 0, 0, 0, 2717, 2718, 1, 0, 0, 0, 2718, 311, 1, 0, 0, 0, 2719, 2717, 1, 0, 0, 0, 2720, 2722, 3, 162, 81, 0, 2721, 2720, 1, 0, 0, 0, 2722, 2725, 1, 0, 0, 0, 2723, 2721, 1, 0, 0, 0, 2723, 2724, 1, 0, 0, 0, 2724, 313, 1, 0, 0, 0, 2725, 2723, 1, 0, 0, 0, 2726, 2728, 7, 13, 0, 0, 2727, 2726, 1, 0, 0, 0, 2728, 2731, 1, 0, 0, 0, 2729, 2727, 1, 0, 0, 0, 2729, 2730, 1, 0, 0, 0, 2730, 315, 1, 0, 0, 0, 2731, 2729, 1, 0, 0, 0, 2732, 2734, 3, 318, 159, 0, 2733, 2732, 1, 0, 0, 0, 2734, 2737, 1, 0, 0, 0, 2735, 2733, 1, 0, 0, 0, 2735, 2736, 1, 0, 0, 0, 2736, 317, 1, 0, 0, 0, 2737, 2735, 1, 0, 0, 0, 2738, 2743, 5, 179, 0, 0, 2739, 2740, 5, 39, 0, 0, 2740, 2743, 5, 264, 0, 0, 2741, 2743, 3, 116, 58, 0, 2742, 2738, 1, 0, 0, 0, 2742, 2739, 1, 0, 0, 0, 2742, 2741, 1, 0, 0, 0, 2743, 319, 1, 0, 0, 0, 2744, 2746, 3, 298, 149, 0, 2745, 2744, 1, 0, 0, 0, 2746, 2749, 1, 0, 0, 0, 2747, 2745, 1, 0, 0, 0, 2747, 2748, 1, 0, 0, 0, 2748, 321, 1, 0, 0, 0, 2749, 2747, 1, 0, 0, 0, 2750, 2754, 3, 44, 22, 0, 2751, 2754, 3, 46, 23, 0, 2752, 2754, 3, 2, 1, 0, 2753, 2750, 1, 0, 0, 0, 2753, 2751, 1, 0, 0, 0, 2753, 2752, 1, 0, 0, 0, 2754, 323, 1, 0, 0, 0, 2755, 2756, 7, 14, 0, 0, 2756, 2757, 5, 36, 0, 0, 2757, 2758, 5, 30, 0, 0, 2758, 2759, 3, 292, 146, 0, 2759, 2760, 5, 31, 0, 0, 2760, 2781, 1, 0, 0, 0, 2761, 2762, 5, 169, 0, 0, 2762, 2763, 3, 38, 19, 0, 2763, 2764, 5, 75, 0, 0, 2764, 2765, 3, 38, 19, 0, 2765, 2766, 5, 75, 0, 0, 2766, 2767, 3, 38, 19, 0, 2767, 2768, 5, 75, 0, 0, 2768, 2769, 3, 38, 19, 0, 2769, 2781, 1, 0, 0, 0, 2770, 2771, 5, 170, 0, 0, 2771, 2781, 3, 6, 3, 0, 2772, 2773, 5, 170, 0, 0, 2773, 2774, 5, 36, 0, 0, 2774, 2775, 5, 30, 0, 0, 2775, 2776, 3, 292, 146, 0, 2776, 2777, 5, 31, 0, 0, 2777, 2781, 1, 0, 0, 0, 2778, 2781, 3, 322, 161, 0, 2779, 2781, 3, 40, 20, 0, 2780, 2755, 1, 0, 0, 0, 2780, 2761, 1, 0, 0, 0, 2780, 2770, 1, 0, 0, 0, 2780, 2772, 1, 0, 0, 0, 2780, 2778, 1, 0, 0, 0, 2780, 2779, 1, 0, 0, 0, 2781, 325, 1, 0, 0, 0, 2782, 2783, 5, 25, 0, 0, 2783, 2784, 5, 40, 0, 0, 2784, 2785, 3, 98, 49, 0, 2785, 2786, 3, 2, 1, 0, 2786, 2795, 1, 0, 0, 0, 2787, 2788, 5, 25, 0, 0, 2788, 2789, 5, 40, 0, 0, 2789, 2790, 3, 98, 49, 0, 2790, 2791, 3, 2, 1, 0, 2791, 2792, 5, 34, 0, 0, 2792, 2793, 3, 2, 1, 0, 2793, 2795, 1, 0, 0, 0, 2794, 2782, 1, 0, 0, 0, 2794, 2787, 1, 0, 0, 0, 2795, 327, 1, 0, 0, 0, 2796, 2798, 3, 330, 165, 0, 2797, 2796, 1, 0, 0, 0, 2798, 2801, 1, 0, 0, 0, 2799, 2797, 1, 0, 0, 0, 2799, 2800, 1, 0, 0, 0, 2800, 329, 1, 0, 0, 0, 2801, 2799, 1, 0, 0, 0, 2802, 2803, 5, 180, 0, 0, 2803, 2804, 5, 36, 0, 0, 2804, 2805, 5, 30, 0, 0, 2805, 2806, 3, 292, 146, 0, 2806, 2807, 5, 31, 0, 0, 2807, 2817, 1, 0, 0, 0, 2808, 2817, 3, 324, 162, 0, 2809, 2810, 5, 171, 0, 0, 2810, 2811, 5, 36, 0, 0, 2811, 2812, 5, 30, 0, 0, 2812, 2813, 3, 292, 146, 0, 2813, 2814, 5, 31, 0, 0, 2814, 2817, 1, 0, 0, 0, 2815, 2817, 5, 55, 0, 0, 2816, 2802, 1, 0, 0, 0, 2816, 2808, 1, 0, 0, 0, 2816, 2809, 1, 0, 0, 0, 2816, 2815, 1, 0, 0, 0, 2817, 331, 1, 0, 0, 0, 2818, 2819, 5, 50, 0, 0, 2819, 2823, 5, 40, 0, 0, 2820, 2822, 3, 336, 168, 0, 2821, 2820, 1, 0, 0, 0, 2822, 2825, 1, 0, 0, 0, 2823, 2821, 1, 0, 0, 0, 2823, 2824, 1, 0, 0, 0, 2824, 2826, 1, 0, 0, 0, 2825, 2823, 1, 0, 0, 0, 2826, 2827, 3, 2, 1, 0, 2827, 333, 1, 0, 0, 0, 2828, 2832, 5, 301, 0, 0, 2829, 2831, 3, 336, 168, 0, 2830, 2829, 1, 0, 0, 0, 2831, 2834, 1, 0, 0, 0, 2832, 2830, 1, 0, 0, 0, 2832, 2833, 1, 0, 0, 0, 2833, 2835, 1, 0, 0, 0, 2834, 2832, 1, 0, 0, 0, 2835, 2836, 3, 2, 1, 0, 2836, 335, 1, 0, 0, 0, 2837, 2853, 5, 52, 0, 0, 2838, 2853, 5, 51, 0, 0, 2839, 2853, 5, 172, 0, 0, 2840, 2841, 5, 62, 0, 0, 2841, 2853, 5, 51, 0, 0, 2842, 2843, 5, 62, 0, 0, 2843, 2853, 5, 52, 0, 0, 2844, 2845, 5, 62, 0, 0, 2845, 2853, 5, 63, 0, 0, 2846, 2847, 5, 62, 0, 0, 2847, 2853, 5, 64, 0, 0, 2848, 2849, 5, 62, 0, 0, 2849, 2853, 5, 65, 0, 0, 2850, 2851, 5, 62, 0, 0, 2851, 2853, 5, 66, 0, 0, 2852, 2837, 1, 0, 0, 0, 2852, 2838, 1, 0, 0, 0, 2852, 2839, 1, 0, 0, 0, 2852, 2840, 1, 0, 0, 0, 2852, 2842, 1, 0, 0, 0, 2852, 2844, 1, 0, 0, 0, 2852, 2846, 1, 0, 0, 0, 2852, 2848, 1, 0, 0, 0, 2852, 2850, 1, 0, 0, 0, 2853, 337, 1, 0, 0, 0, 2854, 2856, 3, 340, 170, 0, 2855, 2854, 1, 0, 0, 0, 2856, 2859, 1, 0, 0, 0, 2857, 2855, 1, 0, 0, 0, 2857, 2858, 1, 0, 0, 0, 2858, 339, 1, 0, 0, 0, 2859, 2857, 1, 0, 0, 0, 2860, 2861, 5, 21, 0, 0, 2861, 2874, 3, 2, 1, 0, 2862, 2863, 5, 50, 0, 0, 2863, 2864, 5, 40, 0, 0, 2864, 2874, 3, 118, 59, 0, 2865, 2866, 5, 25, 0, 0, 2866, 2867, 5, 40, 0, 0, 2867, 2874, 3, 2, 1, 0, 2868, 2874, 3, 174, 87, 0, 2869, 2870, 5, 50, 0, 0, 2870, 2874, 3, 32, 16, 0, 2871, 2874, 3, 322, 161, 0, 2872, 2874, 3, 40, 20, 0, 2873, 2860, 1, 0, 0, 0, 2873, 2862, 1, 0, 0, 0, 2873, 2865, 1, 0, 0, 0, 2873, 2868, 1, 0, 0, 0, 2873, 2869, 1, 0, 0, 0, 2873, 2871, 1, 0, 0, 0, 2873, 2872, 1, 0, 0, 0, 2874, 341, 1, 0, 0, 0, 2875, 2879, 5, 274, 0, 0, 2876, 2878, 3, 344, 172, 0, 2877, 2876, 1, 0, 0, 0, 2878, 2881, 1, 0, 0, 0, 2879, 2877, 1, 0, 0, 0, 2879, 2880, 1, 0, 0, 0, 2880, 2882, 1, 0, 0, 0, 2881, 2879, 1, 0, 0, 0, 2882, 2895, 3, 2, 1, 0, 2883, 2887, 5, 274, 0, 0, 2884, 2886, 3, 344, 172, 0, 2885, 2884, 1, 0, 0, 0, 2886, 2889, 1, 0, 0, 0, 2887, 2885, 1, 0, 0, 0, 2887, 2888, 1, 0, 0, 0, 2888, 2890, 1, 0, 0, 0, 2889, 2887, 1, 0, 0, 0, 2890, 2891, 3, 2, 1, 0, 2891, 2892, 5, 34, 0, 0, 2892, 2893, 3, 2, 1, 0, 2893, 2895, 1, 0, 0, 0, 2894, 2875, 1, 0, 0, 0, 2894, 2883, 1, 0, 0, 0, 2895, 343, 1, 0, 0, 0, 2896, 2897, 7, 15, 0, 0, 2897, 345, 1, 0, 0, 0, 2898, 2900, 3, 348, 174, 0, 2899, 2898, 1, 0, 0, 0, 2900, 2903, 1, 0, 0, 0, 2901, 2899, 1, 0, 0, 0, 2901, 2902, 1, 0, 0, 0, 2902, 347, 1, 0, 0, 0, 2903, 2901, 1, 0, 0, 0, 2904, 2905, 5, 21, 0, 0, 2905, 2906, 3, 2, 1, 0, 2906, 2907, 5, 44, 0, 0, 2907, 2908, 3, 32, 16, 0, 2908, 2915, 1, 0, 0, 0, 2909, 2910, 5, 25, 0, 0, 2910, 2911, 5, 40, 0, 0, 2911, 2915, 3, 2, 1, 0, 2912, 2915, 3, 322, 161, 0, 2913, 2915, 3, 40, 20, 0, 2914, 2904, 1, 0, 0, 0, 2914, 2909, 1, 0, 0, 0, 2914, 2912, 1, 0, 0, 0, 2914, 2913, 1, 0, 0, 0, 2915, 349, 1, 0, 0, 0, 175, 358, 363, 372, 381, 434, 475, 484, 514, 518, 536, 563, 586, 622, 628, 635, 637, 647, 649, 656, 667, 675, 696, 698, 714, 759, 764, 769, 774, 782, 892, 898, 914, 920, 926, 933, 961, 1039, 1041, 1054, 1060, 1069, 1071, 1079, 1091, 1103, 1110, 1117, 1119, 1146, 1153, 1161, 1169, 1182, 1189, 1192, 1211, 1305, 1314, 1321, 1324, 1332, 1353, 1385, 1408, 1420, 1429, 1454, 1478, 1486, 1490, 1505, 1512, 1557, 1567, 1583, 1595, 1607, 1621, 1633, 1644, 1651, 1661, 1674, 1679, 1684, 1693, 1704, 1787, 1796, 1809, 1820, 1828, 1838, 1840, 1867, 1874, 1879, 1886, 1892, 1902, 1906, 1913, 1928, 1934, 1948, 1961, 1969, 1976, 1980, 1985, 2001, 2006, 2008, 2021, 2047, 2054, 2056, 2061, 2067, 2096, 2101, 2124, 2129, 2149, 2202, 2211, 2224, 2235, 2246, 2249, 2257, 2269, 2283, 2297, 2305, 2325, 2337, 2342, 2351, 2353, 2360, 2370, 2438, 2515, 2522, 2530, 2680, 2684, 2686, 2691, 2693, 2699, 2705, 2711, 2717, 2723, 2729, 2735, 2742, 2747, 2753, 2780, 2794, 2799, 2816, 2823, 2832, 2852, 2857, 2873, 2879, 2887, 2894, 2901, 2914] \ No newline at end of file diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILBaseVisitor.cs b/src/tools/ilasm/src/ILAssembler/gen/CILBaseVisitor.cs index d7bf5587d2bfbb..c4f366e7a7fad4 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILBaseVisitor.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILBaseVisitor.cs @@ -556,7 +556,7 @@ public partial class CILBaseVisitor : AbstractParseTreeVisitor, /// The visitor result. public virtual Result VisitSimpleInstr([NotNull] CILParser.SimpleInstrContext context) { return VisitChildren(context); } /// - /// Visit a parse tree produced by . + /// Visit a parse tree produced by . /// /// The default implementation returns the result of calling /// on . @@ -564,7 +564,7 @@ public partial class CILBaseVisitor : AbstractParseTreeVisitor, /// /// The parse tree. /// The visitor result. - public virtual Result VisitInstructionIsland([NotNull] CILParser.InstructionIslandContext context) { return VisitChildren(context); } + public virtual Result VisitCalliSignature([NotNull] CILParser.CalliSignatureContext context) { return VisitChildren(context); } /// /// Visit a parse tree produced by . /// diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs index 54b01dee688fb9..3f3536e0e21171 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs @@ -102,7 +102,7 @@ public const int RULE_classHead = 37, RULE_classAttr = 38, RULE_extendsClause = 39, RULE_implClause = 40, RULE_classDecls = 41, RULE_implList = 42, RULE_esHead = 43, RULE_extSourceSpec = 44, RULE_fileDecl = 45, RULE_fileAttr = 46, RULE_fileEntry = 47, RULE_asmAttrAny = 48, - RULE_asmAttr = 49, RULE_instr = 50, RULE_simpleInstr = 51, RULE_instructionIsland = 52, + RULE_asmAttr = 49, RULE_instr = 50, RULE_simpleInstr = 51, RULE_calliSignature = 52, RULE_labels = 53, RULE_typeArgs = 54, RULE_bounds = 55, RULE_sigArgs = 56, RULE_sigArg = 57, RULE_className = 58, RULE_slashedName = 59, RULE_assemblyDecls = 60, RULE_assemblyDecl = 61, RULE_typeSpec = 62, RULE_nativeType = 63, RULE_nativeTypeArrayPointerInfo = 64, @@ -148,7 +148,7 @@ public const int "serializTypeElement", "moduleHead", "vtfixupDecl", "vtfixupAttr", "vtableDecl", "nameSpaceHead", "classHead", "classAttr", "extendsClause", "implClause", "classDecls", "implList", "esHead", "extSourceSpec", "fileDecl", "fileAttr", - "fileEntry", "asmAttrAny", "asmAttr", "instr", "simpleInstr", "instructionIsland", + "fileEntry", "asmAttrAny", "asmAttr", "instr", "simpleInstr", "calliSignature", "labels", "typeArgs", "bounds", "sigArgs", "sigArg", "className", "slashedName", "assemblyDecls", "assemblyDecl", "typeSpec", "nativeType", "nativeTypeArrayPointerInfo", "nativeTypeElement", "iidParamIndex", "variantType", "variantTypeElement", @@ -2224,6 +2224,7 @@ public override TResult Accept(IParseTreeVisitor visitor) { public OwnerTypeContext ownerType() { OwnerTypeContext _localctx = new OwnerTypeContext(Context, State); EnterRule(_localctx, 50, RULE_ownerType); + BeginSubtree(); try { State = 628; ErrorHandler.Sync(this); @@ -2250,6 +2251,7 @@ public OwnerTypeContext ownerType() { ErrorHandler.Recover(this, re); } finally { + EndParseTreeMode(); ExitRule(); } return _localctx; @@ -4276,11 +4278,38 @@ public AsmAttrContext asmAttr() { } public partial class InstrContext : ParserRuleContext { + public IToken op; + public MethodRefContext methodOperand; + public FieldRefContext fieldOperand; + public MdtokenContext metadataOperand; + public TypeSpecContext typeOperand; + public CalliSignatureContext signatureOperand; + public OwnerTypeContext ownerOperand; [System.Diagnostics.DebuggerNonUserCode] public SimpleInstrContext simpleInstr() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public InstructionIslandContext instructionIsland() { - return GetRuleContext(0); + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_METHOD() { return GetToken(CILParser.INSTR_METHOD, 0); } + [System.Diagnostics.DebuggerNonUserCode] public MethodRefContext methodRef() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_FIELD() { return GetToken(CILParser.INSTR_FIELD, 0); } + [System.Diagnostics.DebuggerNonUserCode] public FieldRefContext fieldRef() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public MdtokenContext mdtoken() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_TYPE() { return GetToken(CILParser.INSTR_TYPE, 0); } + [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_SIG() { return GetToken(CILParser.INSTR_SIG, 0); } + [System.Diagnostics.DebuggerNonUserCode] public CalliSignatureContext calliSignature() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_TOK() { return GetToken(CILParser.INSTR_TOK, 0); } + [System.Diagnostics.DebuggerNonUserCode] public OwnerTypeContext ownerType() { + return GetRuleContext(0); } public InstrContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) @@ -4300,7 +4329,7 @@ public InstrContext instr() { InstrContext _localctx = new InstrContext(Context, State); EnterRule(_localctx, 100, RULE_instr); try { - State = 938; + State = 961; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,35,Context) ) { case 1: @@ -4314,7 +4343,60 @@ public InstrContext instr() { EnterOuterAlt(_localctx, 2); { State = 937; - instructionIsland(); + _localctx.op = Match(INSTR_METHOD); + State = 938; + _localctx.methodOperand = methodRef(); + Actions.EmitMethodReferenceInstruction(_localctx.op, _localctx.methodOperand); + } + break; + case 3: + EnterOuterAlt(_localctx, 3); + { + State = 941; + _localctx.op = Match(INSTR_FIELD); + State = 942; + _localctx.fieldOperand = fieldRef(); + Actions.EmitFieldReferenceInstruction(_localctx.op, _localctx.fieldOperand); + } + break; + case 4: + EnterOuterAlt(_localctx, 4); + { + State = 945; + _localctx.op = Match(INSTR_FIELD); + State = 946; + _localctx.metadataOperand = mdtoken(); + Actions.EmitMetadataTokenInstruction(_localctx.op, _localctx.metadataOperand); + } + break; + case 5: + EnterOuterAlt(_localctx, 5); + { + State = 949; + _localctx.op = Match(INSTR_TYPE); + State = 950; + _localctx.typeOperand = typeSpec(); + Actions.EmitTypeReferenceInstruction(_localctx.op, _localctx.typeOperand); + } + break; + case 6: + EnterOuterAlt(_localctx, 6); + { + State = 953; + _localctx.op = Match(INSTR_SIG); + State = 954; + _localctx.signatureOperand = calliSignature(); + Actions.EmitCalliInstruction(_localctx.op, _localctx.signatureOperand); + } + break; + case 7: + EnterOuterAlt(_localctx, 7); + { + State = 957; + _localctx.op = Match(INSTR_TOK); + State = 958; + _localctx.ownerOperand = ownerType(); + Actions.EmitOwnerTokenInstruction(_localctx.op, _localctx.ownerOperand); } break; } @@ -4394,13 +4476,13 @@ public SimpleInstrContext simpleInstr() { SimpleInstrContext _localctx = new SimpleInstrContext(Context, State); EnterRule(_localctx, 102, RULE_simpleInstr); try { - State = 1018; + State = 1041; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,37,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 940; + State = 963; _localctx.op = Match(INSTR_NONE); Actions.EmitNoOperandInstruction(_localctx.op); } @@ -4408,9 +4490,9 @@ public SimpleInstrContext simpleInstr() { case 2: EnterOuterAlt(_localctx, 2); { - State = 942; + State = 965; _localctx.op = Match(INSTR_VAR); - State = 943; + State = 966; _localctx.index = int32(); Actions.EmitVariableIndexInstruction(_localctx.op, (_localctx.index!=null?(_localctx.index.Start):null)); } @@ -4418,9 +4500,9 @@ public SimpleInstrContext simpleInstr() { case 3: EnterOuterAlt(_localctx, 3); { - State = 946; + State = 969; _localctx.op = Match(INSTR_VAR); - State = 947; + State = 970; _localctx.name = id(); Actions.EmitVariableNameInstruction(_localctx.op, (_localctx.name!=null?(_localctx.name.Start):null)); } @@ -4428,9 +4510,9 @@ public SimpleInstrContext simpleInstr() { case 4: EnterOuterAlt(_localctx, 4); { - State = 950; + State = 973; _localctx.op = Match(INSTR_I); - State = 951; + State = 974; _localctx.value32 = int32(); Actions.EmitInt32Instruction(_localctx.op, (_localctx.value32!=null?(_localctx.value32.Start):null)); } @@ -4438,9 +4520,9 @@ public SimpleInstrContext simpleInstr() { case 5: EnterOuterAlt(_localctx, 5); { - State = 954; + State = 977; _localctx.op = Match(INSTR_I8); - State = 955; + State = 978; _localctx.value64 = int64(); Actions.EmitInt64Instruction(_localctx.op, (_localctx.value64!=null?(_localctx.value64.Start):null)); } @@ -4448,9 +4530,9 @@ public SimpleInstrContext simpleInstr() { case 6: EnterOuterAlt(_localctx, 6); { - State = 958; + State = 981; _localctx.op = Match(INSTR_R); - State = 959; + State = 982; _localctx.value = float64(); Actions.EmitFloatingInstruction(_localctx.op, _localctx.value.Value); } @@ -4458,9 +4540,9 @@ public SimpleInstrContext simpleInstr() { case 7: EnterOuterAlt(_localctx, 7); { - State = 962; + State = 985; _localctx.op = Match(INSTR_R); - State = 963; + State = 986; _localctx.integerValue = int64(); Actions.EmitFloatingInstruction(_localctx.op, (_localctx.integerValue!=null?(_localctx.integerValue.Start):null)); } @@ -4468,13 +4550,13 @@ public SimpleInstrContext simpleInstr() { case 8: EnterOuterAlt(_localctx, 8); { - State = 966; + State = 989; _localctx.op = Match(INSTR_R); - State = 967; + State = 990; Match(T__29); - State = 968; + State = 991; _localctx.rawFloat = bytes(); - State = 969; + State = 992; Match(T__30); Actions.EmitRawFloatingInstruction(_localctx.op, _localctx.rawFloat.Value, (_localctx.rawFloat!=null?(_localctx.rawFloat.Start):null)); } @@ -4482,15 +4564,15 @@ public SimpleInstrContext simpleInstr() { case 9: EnterOuterAlt(_localctx, 9); { - State = 972; + State = 995; _localctx.op = Match(INSTR_R); - State = 973; + State = 996; Match(T__83); - State = 974; + State = 997; Match(T__29); - State = 975; + State = 998; _localctx.rawFloat = bytes(); - State = 976; + State = 999; Match(T__30); Actions.EmitRawFloatingInstruction(_localctx.op, _localctx.rawFloat.Value, (_localctx.rawFloat!=null?(_localctx.rawFloat.Start):null)); } @@ -4498,9 +4580,9 @@ public SimpleInstrContext simpleInstr() { case 10: EnterOuterAlt(_localctx, 10); { - State = 979; + State = 1002; _localctx.op = Match(INSTR_BRTARGET); - State = 980; + State = 1003; _localctx.offset = int32(); Actions.EmitBranchOffsetInstruction(_localctx.op, (_localctx.offset!=null?(_localctx.offset.Start):null)); } @@ -4508,9 +4590,9 @@ public SimpleInstrContext simpleInstr() { case 11: EnterOuterAlt(_localctx, 11); { - State = 983; + State = 1006; _localctx.op = Match(INSTR_BRTARGET); - State = 984; + State = 1007; _localctx.label = id(); Actions.EmitBranchLabelInstruction(_localctx.op, (_localctx.label!=null?(_localctx.label.Start):null)); } @@ -4518,9 +4600,9 @@ public SimpleInstrContext simpleInstr() { case 12: EnterOuterAlt(_localctx, 12); { - State = 987; + State = 1010; _localctx.op = Match(INSTR_STRING); - State = 988; + State = 1011; _localctx.userString = compQstring(); Actions.EmitStringInstruction(_localctx.op, _localctx.userString.Value); } @@ -4528,15 +4610,15 @@ public SimpleInstrContext simpleInstr() { case 13: EnterOuterAlt(_localctx, 13); { - State = 991; + State = 1014; _localctx.op = Match(INSTR_STRING); - State = 992; + State = 1015; Match(ANSI); - State = 993; + State = 1016; Match(T__29); - State = 994; + State = 1017; _localctx.ansiString = compQstring(); - State = 995; + State = 1018; Match(T__30); Actions.EmitAnsiStringInstruction(_localctx.op, _localctx.ansiString.Value); } @@ -4544,15 +4626,15 @@ public SimpleInstrContext simpleInstr() { case 14: EnterOuterAlt(_localctx, 14); { - State = 998; + State = 1021; _localctx.op = Match(INSTR_STRING); - State = 999; + State = 1022; Match(T__83); - State = 1000; + State = 1023; Match(T__29); - State = 1001; + State = 1024; _localctx.rawString = bytes(); - State = 1002; + State = 1025; Match(T__30); Actions.EmitRawStringInstruction(_localctx.op, _localctx.rawString.Value); } @@ -4560,9 +4642,9 @@ public SimpleInstrContext simpleInstr() { case 15: EnterOuterAlt(_localctx, 15); { - State = 1005; + State = 1028; _localctx.op = Match(INSTR_TOK); - State = 1006; + State = 1029; _localctx.rawToken = int32(); Actions.EmitRawTokenInstruction(_localctx.op, (_localctx.rawToken!=null?(_localctx.rawToken.Start):null)); } @@ -4570,25 +4652,25 @@ public SimpleInstrContext simpleInstr() { case 16: EnterOuterAlt(_localctx, 16); { - State = 1009; + State = 1032; _localctx.op = Match(INSTR_SWITCH); Actions.BeginSwitchInstruction(_localctx, _localctx.op); - State = 1016; + State = 1039; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__29: { - State = 1011; + State = 1034; Match(T__29); - State = 1012; + State = 1035; labels(); - State = 1013; + State = 1036; Match(T__30); } break; case T__84: { - State = 1015; + State = 1038; Match(T__84); } break; @@ -4613,23 +4695,7 @@ public SimpleInstrContext simpleInstr() { return _localctx; } - public partial class InstructionIslandContext : ParserRuleContext { - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_METHOD() { return GetToken(CILParser.INSTR_METHOD, 0); } - [System.Diagnostics.DebuggerNonUserCode] public MethodRefContext methodRef() { - return GetRuleContext(0); - } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_FIELD() { return GetToken(CILParser.INSTR_FIELD, 0); } - [System.Diagnostics.DebuggerNonUserCode] public FieldRefContext fieldRef() { - return GetRuleContext(0); - } - [System.Diagnostics.DebuggerNonUserCode] public MdtokenContext mdtoken() { - return GetRuleContext(0); - } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_TYPE() { return GetToken(CILParser.INSTR_TYPE, 0); } - [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() { - return GetRuleContext(0); - } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_SIG() { return GetToken(CILParser.INSTR_SIG, 0); } + public partial class CalliSignatureContext : ParserRuleContext { [System.Diagnostics.DebuggerNonUserCode] public CallConvContext callConv() { return GetRuleContext(0); } @@ -4639,93 +4705,34 @@ [System.Diagnostics.DebuggerNonUserCode] public TypeContext type() { [System.Diagnostics.DebuggerNonUserCode] public SigArgsContext sigArgs() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_TOK() { return GetToken(CILParser.INSTR_TOK, 0); } - [System.Diagnostics.DebuggerNonUserCode] public OwnerTypeContext ownerType() { - return GetRuleContext(0); - } - public InstructionIslandContext(ParserRuleContext parent, int invokingState) + public CalliSignatureContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { } - public override int RuleIndex { get { return RULE_instructionIsland; } } + public override int RuleIndex { get { return RULE_calliSignature; } } [System.Diagnostics.DebuggerNonUserCode] public override TResult Accept(IParseTreeVisitor visitor) { ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitInstructionIsland(this); + if (typedVisitor != null) return typedVisitor.VisitCalliSignature(this); else return visitor.VisitChildren(this); } } [RuleVersion(0)] - public InstructionIslandContext instructionIsland() { - InstructionIslandContext _localctx = new InstructionIslandContext(Context, State); - EnterRule(_localctx, 104, RULE_instructionIsland); + public CalliSignatureContext calliSignature() { + CalliSignatureContext _localctx = new CalliSignatureContext(Context, State); + EnterRule(_localctx, 104, RULE_calliSignature); BeginSubtree(); try { - State = 1035; - ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,38,Context) ) { - case 1: - EnterOuterAlt(_localctx, 1); - { - State = 1020; - Match(INSTR_METHOD); - State = 1021; - methodRef(); - } - break; - case 2: - EnterOuterAlt(_localctx, 2); - { - State = 1022; - Match(INSTR_FIELD); - State = 1023; - fieldRef(); - } - break; - case 3: - EnterOuterAlt(_localctx, 3); - { - State = 1024; - Match(INSTR_FIELD); - State = 1025; - mdtoken(); - } - break; - case 4: - EnterOuterAlt(_localctx, 4); - { - State = 1026; - Match(INSTR_TYPE); - State = 1027; - typeSpec(); - } - break; - case 5: - EnterOuterAlt(_localctx, 5); - { - State = 1028; - Match(INSTR_SIG); - State = 1029; - callConv(); - State = 1030; - type(); - State = 1031; - sigArgs(); - } - break; - case 6: - EnterOuterAlt(_localctx, 6); - { - State = 1033; - Match(INSTR_TOK); - State = 1034; - ownerType(); - } - break; + EnterOuterAlt(_localctx, 1); + { + State = 1043; + callConv(); + State = 1044; + type(); + State = 1045; + sigArgs(); } - Context.Stop = TokenStream.LT(-1); - Actions.ProcessInstructionIsland(_localctx); } catch (RecognitionException re) { _localctx.exception = re; @@ -4775,7 +4782,7 @@ public LabelsContext labels() { EnterRule(_localctx, 106, RULE_labels); try { int _alt; - State = 1061; + State = 1071; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__30: @@ -4806,14 +4813,14 @@ public LabelsContext labels() { case ID: EnterOuterAlt(_localctx, 2); { - State = 1050; + State = 1060; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,40,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,39,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1044; + State = 1054; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -4837,14 +4844,14 @@ public LabelsContext labels() { case SQSTRING: case ID: { - State = 1038; + State = 1048; _localctx.headLabel = id(); Actions.AddSwitchLabel((_localctx.headLabel!=null?(_localctx.headLabel.Start):null)); } break; case INT32: { - State = 1041; + State = 1051; _localctx.headOffset = int32(); Actions.AddSwitchOffset((_localctx.headOffset!=null?(_localctx.headOffset.Start):null)); } @@ -4852,16 +4859,16 @@ public LabelsContext labels() { default: throw new NoViableAltException(this); } - State = 1046; + State = 1056; Match(T__27); } } } - State = 1052; + State = 1062; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,40,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,39,Context); } - State = 1059; + State = 1069; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -4885,14 +4892,14 @@ public LabelsContext labels() { case SQSTRING: case ID: { - State = 1053; + State = 1063; _localctx.tailLabel = id(); Actions.AddSwitchLabel((_localctx.tailLabel!=null?(_localctx.tailLabel.Start):null)); } break; case INT32: { - State = 1056; + State = 1066; _localctx.tailOffset = int32(); Actions.AddSwitchOffset((_localctx.tailOffset!=null?(_localctx.tailOffset.Start):null)); } @@ -4945,29 +4952,29 @@ public TypeArgsContext typeArgs() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1063; + State = 1073; Match(T__85); - State = 1069; + State = 1079; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,43,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,42,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1064; + State = 1074; type(); - State = 1065; + State = 1075; Match(T__27); } } } - State = 1071; + State = 1081; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,43,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,42,Context); } - State = 1072; + State = 1082; type(); - State = 1073; + State = 1083; Match(T__86); } } @@ -5010,29 +5017,29 @@ public BoundsContext bounds() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1075; + State = 1085; Match(T__41); - State = 1081; + State = 1091; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,44,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,43,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1076; + State = 1086; bound(); - State = 1077; + State = 1087; Match(T__27); } } } - State = 1083; + State = 1093; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,44,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,43,Context); } - State = 1084; + State = 1094; bound(); - State = 1085; + State = 1095; Match(T__42); } } @@ -5073,42 +5080,42 @@ public SigArgsContext sigArgs() { EnterRule(_localctx, 112, RULE_sigArgs); try { int _alt; - State = 1100; + State = 1110; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__29: EnterOuterAlt(_localctx, 1); { - State = 1087; + State = 1097; Match(T__29); - State = 1093; + State = 1103; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,45,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,44,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1088; + State = 1098; sigArg(); - State = 1089; + State = 1099; Match(T__27); } } } - State = 1095; + State = 1105; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,45,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,44,Context); } - State = 1096; + State = 1106; sigArg(); - State = 1097; + State = 1107; Match(T__30); } break; case T__84: EnterOuterAlt(_localctx, 2); { - State = 1099; + State = 1109; Match(T__84); } break; @@ -5160,31 +5167,31 @@ public SigArgContext sigArg() { EnterRule(_localctx, 114, RULE_sigArg); int _la; try { - State = 1109; + State = 1119; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,48,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,47,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1102; + State = 1112; Match(ELLIPSIS); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1103; + State = 1113; paramAttr(); - State = 1104; + State = 1114; type(); - State = 1105; + State = 1115; marshalClause(); - State = 1107; + State = 1117; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 65534L) != 0) || ((((_la - 199)) & ~0x3f) == 0 && ((1L << (_la - 199)) & 299067162755073L) != 0) || _la==SQSTRING || _la==ID) { { - State = 1106; + State = 1116; id(); } } @@ -5237,95 +5244,95 @@ public ClassNameContext className() { ClassNameContext _localctx = new ClassNameContext(Context, State); EnterRule(_localctx, 116, RULE_className); try { - State = 1136; + State = 1146; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,49,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,48,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1111; + State = 1121; Match(T__41); - State = 1112; + State = 1122; dottedName(); - State = 1113; + State = 1123; Match(T__42); - State = 1114; + State = 1124; slashedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1116; + State = 1126; Match(T__41); - State = 1117; + State = 1127; mdtoken(); - State = 1118; + State = 1128; Match(T__42); - State = 1119; + State = 1129; slashedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1121; + State = 1131; Match(T__41); - State = 1122; + State = 1132; Match(PTR); - State = 1123; + State = 1133; Match(T__42); - State = 1124; + State = 1134; slashedName(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1125; + State = 1135; Match(T__41); - State = 1126; + State = 1136; Match(MODULE); - State = 1127; + State = 1137; dottedName(); - State = 1128; + State = 1138; Match(T__42); - State = 1129; + State = 1139; slashedName(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1131; + State = 1141; slashedName(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1132; + State = 1142; mdtoken(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1133; + State = 1143; Match(THIS); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1134; + State = 1144; Match(BASE); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 1135; + State = 1145; Match(NESTER); } break; @@ -5370,25 +5377,25 @@ public SlashedNameContext slashedName() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1143; + State = 1153; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,50,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,49,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1138; + State = 1148; dottedName(); - State = 1139; + State = 1149; Match(T__87); } } } - State = 1145; + State = 1155; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,50,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,49,Context); } - State = 1146; + State = 1156; dottedName(); } } @@ -5431,17 +5438,17 @@ public AssemblyDeclsContext assemblyDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 1151; + State = 1161; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38654771200L) != 0) || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & 4294975503L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 6860954690125825L) != 0)) { { { - State = 1148; + State = 1158; assemblyDecl(); } } - State = 1153; + State = 1163; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -5487,18 +5494,18 @@ public AssemblyDeclContext assemblyDecl() { AssemblyDeclContext _localctx = new AssemblyDeclContext(Context, State); EnterRule(_localctx, 122, RULE_assemblyDecl); try { - State = 1159; + State = 1169; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case HASH: EnterOuterAlt(_localctx, 1); { { - State = 1154; + State = 1164; Match(HASH); - State = 1155; + State = 1165; Match(T__88); - State = 1156; + State = 1166; int32(); } } @@ -5507,7 +5514,7 @@ public AssemblyDeclContext assemblyDecl() { case PERMISSIONSET: EnterOuterAlt(_localctx, 2); { - State = 1157; + State = 1167; secDecl(); } break; @@ -5532,7 +5539,7 @@ public AssemblyDeclContext assemblyDecl() { case ID: EnterOuterAlt(_localctx, 3); { - State = 1158; + State = 1168; asmOrRefDecl(); } break; @@ -5579,45 +5586,46 @@ public override TResult Accept(IParseTreeVisitor visitor) { public TypeSpecContext typeSpec() { TypeSpecContext _localctx = new TypeSpecContext(Context, State); EnterRule(_localctx, 124, RULE_typeSpec); + BeginSubtree(); try { - State = 1172; + State = 1182; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,53,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,52,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1161; + State = 1171; className(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1162; + State = 1172; Match(T__41); - State = 1163; + State = 1173; dottedName(); - State = 1164; + State = 1174; Match(T__42); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1166; + State = 1176; Match(T__41); - State = 1167; + State = 1177; Match(MODULE); - State = 1168; + State = 1178; dottedName(); - State = 1169; + State = 1179; Match(T__42); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1171; + State = 1181; type(); } break; @@ -5629,6 +5637,7 @@ public TypeSpecContext typeSpec() { ErrorHandler.Recover(this, re); } finally { + EndParseTreeMode(); ExitRule(); } return _localctx; @@ -5663,9 +5672,9 @@ public NativeTypeContext nativeType() { EnterRule(_localctx, 126, RULE_nativeType); try { int _alt; - State = 1182; + State = 1192; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,55,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,54,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -5674,23 +5683,23 @@ public NativeTypeContext nativeType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1175; + State = 1185; nativeTypeElement(); - State = 1179; + State = 1189; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,54,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,53,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1176; + State = 1186; nativeTypeArrayPointerInfo(); } } } - State = 1181; + State = 1191; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,54,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,53,Context); } } break; @@ -5786,14 +5795,14 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { NativeTypeArrayPointerInfoContext _localctx = new NativeTypeArrayPointerInfoContext(Context, State); EnterRule(_localctx, 128, RULE_nativeTypeArrayPointerInfo); try { - State = 1201; + State = 1211; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,56,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,55,Context) ) { case 1: _localctx = new PointerNativeTypeContext(_localctx); EnterOuterAlt(_localctx, 1); { - State = 1184; + State = 1194; Match(PTR); } break; @@ -5801,7 +5810,7 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeNoSizeDataContext(_localctx); EnterOuterAlt(_localctx, 2); { - State = 1185; + State = 1195; Match(ARRAY_TYPE_NO_BOUNDS); } break; @@ -5809,11 +5818,11 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeSizeContext(_localctx); EnterOuterAlt(_localctx, 3); { - State = 1186; + State = 1196; Match(T__41); - State = 1187; + State = 1197; int32(); - State = 1188; + State = 1198; Match(T__42); } break; @@ -5821,15 +5830,15 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeSizeParamIndexContext(_localctx); EnterOuterAlt(_localctx, 4); { - State = 1190; + State = 1200; Match(T__41); - State = 1191; + State = 1201; int32(); - State = 1192; + State = 1202; Match(PLUS); - State = 1193; + State = 1203; int32(); - State = 1194; + State = 1204; Match(T__42); } break; @@ -5837,13 +5846,13 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeParamIndexContext(_localctx); EnterOuterAlt(_localctx, 5); { - State = 1196; + State = 1206; Match(T__41); - State = 1197; + State = 1207; Match(PLUS); - State = 1198; + State = 1208; int32(); - State = 1199; + State = 1209; Match(T__42); } break; @@ -5943,9 +5952,9 @@ public NativeTypeElementContext nativeTypeElement() { NativeTypeElementContext _localctx = new NativeTypeElementContext(Context, State); EnterRule(_localctx, 130, RULE_nativeTypeElement); try { - State = 1295; + State = 1305; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,57,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,56,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -5954,412 +5963,412 @@ public NativeTypeElementContext nativeTypeElement() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1204; + State = 1214; _localctx.marshalType = Match(CUSTOM); - State = 1205; + State = 1215; Match(T__29); - State = 1206; + State = 1216; compQstring(); - State = 1207; + State = 1217; Match(T__27); - State = 1208; + State = 1218; compQstring(); - State = 1209; + State = 1219; Match(T__27); - State = 1210; + State = 1220; compQstring(); - State = 1211; + State = 1221; Match(T__27); - State = 1212; + State = 1222; compQstring(); - State = 1213; + State = 1223; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1215; + State = 1225; _localctx.marshalType = Match(CUSTOM); - State = 1216; + State = 1226; Match(T__29); - State = 1217; + State = 1227; compQstring(); - State = 1218; + State = 1228; Match(T__27); - State = 1219; + State = 1229; compQstring(); - State = 1220; + State = 1230; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1222; + State = 1232; Match(FIXED); - State = 1223; + State = 1233; _localctx.marshalType = Match(SYSSTRING); - State = 1224; + State = 1234; Match(T__41); - State = 1225; + State = 1235; int32(); - State = 1226; + State = 1236; Match(T__42); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1228; + State = 1238; Match(FIXED); - State = 1229; + State = 1239; _localctx.marshalType = Match(ARRAY); - State = 1230; + State = 1240; Match(T__41); - State = 1231; + State = 1241; int32(); - State = 1232; + State = 1242; Match(T__42); - State = 1233; + State = 1243; nativeType(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1235; + State = 1245; _localctx.marshalType = Match(VARIANT); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1236; + State = 1246; _localctx.marshalType = Match(CURRENCY); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1237; + State = 1247; _localctx.marshalType = Match(SYSCHAR); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 1238; + State = 1248; _localctx.marshalType = Match(VOID); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 1239; + State = 1249; _localctx.marshalType = Match(BOOL); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 1240; + State = 1250; _localctx.marshalType = Match(INT8); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 1241; + State = 1251; _localctx.marshalType = Match(INT16); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 1242; + State = 1252; _localctx.marshalType = Match(INT32_); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 1243; + State = 1253; _localctx.marshalType = Match(INT64_); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 1244; + State = 1254; _localctx.marshalType = Match(FLOAT32); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 1245; + State = 1255; _localctx.marshalType = Match(FLOAT64_); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 1246; + State = 1256; _localctx.marshalType = Match(ERROR); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 1247; + State = 1257; _localctx.marshalType = Match(UINT8); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 1248; + State = 1258; _localctx.marshalType = Match(UINT16); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 1249; + State = 1259; _localctx.marshalType = Match(UINT32); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 1250; + State = 1260; _localctx.marshalType = Match(UINT64); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 1251; + State = 1261; _localctx.marshalType = Match(DECIMAL); } break; case 23: EnterOuterAlt(_localctx, 23); { - State = 1252; + State = 1262; _localctx.marshalType = Match(DATE); } break; case 24: EnterOuterAlt(_localctx, 24); { - State = 1253; + State = 1263; _localctx.marshalType = Match(BSTR); } break; case 25: EnterOuterAlt(_localctx, 25); { - State = 1254; + State = 1264; _localctx.marshalType = Match(LPSTR); } break; case 26: EnterOuterAlt(_localctx, 26); { - State = 1255; + State = 1265; _localctx.marshalType = Match(LPWSTR); } break; case 27: EnterOuterAlt(_localctx, 27); { - State = 1256; + State = 1266; _localctx.marshalType = Match(LPTSTR); } break; case 28: EnterOuterAlt(_localctx, 28); { - State = 1257; + State = 1267; _localctx.marshalType = Match(OBJECTREF); } break; case 29: EnterOuterAlt(_localctx, 29); { - State = 1258; + State = 1268; _localctx.marshalType = Match(IUNKNOWN); - State = 1259; + State = 1269; iidParamIndex(); } break; case 30: EnterOuterAlt(_localctx, 30); { - State = 1260; + State = 1270; _localctx.marshalType = Match(IDISPATCH); - State = 1261; + State = 1271; iidParamIndex(); } break; case 31: EnterOuterAlt(_localctx, 31); { - State = 1262; + State = 1272; _localctx.marshalType = Match(STRUCT); } break; case 32: EnterOuterAlt(_localctx, 32); { - State = 1263; + State = 1273; _localctx.marshalType = Match(INTERFACE); - State = 1264; + State = 1274; iidParamIndex(); } break; case 33: EnterOuterAlt(_localctx, 33); { - State = 1265; + State = 1275; _localctx.marshalType = Match(SAFEARRAY); - State = 1266; + State = 1276; variantType(); } break; case 34: EnterOuterAlt(_localctx, 34); { - State = 1267; + State = 1277; _localctx.marshalType = Match(SAFEARRAY); - State = 1268; + State = 1278; variantType(); - State = 1269; + State = 1279; Match(T__27); - State = 1270; + State = 1280; compQstring(); } break; case 35: EnterOuterAlt(_localctx, 35); { - State = 1272; + State = 1282; _localctx.marshalType = Match(INT); } break; case 36: EnterOuterAlt(_localctx, 36); { - State = 1273; + State = 1283; _localctx.marshalType = Match(UINT); } break; case 37: EnterOuterAlt(_localctx, 37); { - State = 1274; + State = 1284; Match(T__89); - State = 1275; + State = 1285; _localctx.unsignedMarshalType = Match(INT8); } break; case 38: EnterOuterAlt(_localctx, 38); { - State = 1276; + State = 1286; Match(T__89); - State = 1277; + State = 1287; _localctx.unsignedMarshalType = Match(INT16); } break; case 39: EnterOuterAlt(_localctx, 39); { - State = 1278; + State = 1288; Match(T__89); - State = 1279; + State = 1289; _localctx.unsignedMarshalType = Match(INT32_); } break; case 40: EnterOuterAlt(_localctx, 40); { - State = 1280; + State = 1290; Match(T__89); - State = 1281; + State = 1291; _localctx.unsignedMarshalType = Match(INT64_); } break; case 41: EnterOuterAlt(_localctx, 41); { - State = 1282; + State = 1292; Match(T__61); - State = 1283; + State = 1293; _localctx.marshalType = Match(STRUCT); } break; case 42: EnterOuterAlt(_localctx, 42); { - State = 1284; + State = 1294; _localctx.marshalType = Match(BYVALSTR); } break; case 43: EnterOuterAlt(_localctx, 43); { - State = 1285; + State = 1295; Match(ANSI); - State = 1286; + State = 1296; _localctx.marshalType = Match(BSTR); } break; case 44: EnterOuterAlt(_localctx, 44); { - State = 1287; + State = 1297; _localctx.marshalType = Match(TBSTR); } break; case 45: EnterOuterAlt(_localctx, 45); { - State = 1288; + State = 1298; Match(VARIANT); - State = 1289; + State = 1299; _localctx.marshalBool = Match(BOOL); } break; case 46: EnterOuterAlt(_localctx, 46); { - State = 1290; + State = 1300; _localctx.marshalType = Match(METHOD); } break; case 47: EnterOuterAlt(_localctx, 47); { - State = 1291; + State = 1301; _localctx.marshalType = Match(LPSTRUCT); } break; case 48: EnterOuterAlt(_localctx, 48); { - State = 1292; + State = 1302; Match(T__33); - State = 1293; + State = 1303; _localctx.marshalType = Match(ANY); } break; case 49: EnterOuterAlt(_localctx, 49); { - State = 1294; + State = 1304; dottedName(); } break; @@ -6398,7 +6407,7 @@ public IidParamIndexContext iidParamIndex() { IidParamIndexContext _localctx = new IidParamIndexContext(Context, State); EnterRule(_localctx, 132, RULE_iidParamIndex); try { - State = 1304; + State = 1314; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__30: @@ -6412,15 +6421,15 @@ public IidParamIndexContext iidParamIndex() { case T__29: EnterOuterAlt(_localctx, 2); { - State = 1298; + State = 1308; Match(T__29); - State = 1299; + State = 1309; Match(T__90); - State = 1300; + State = 1310; Match(T__35); - State = 1301; + State = 1311; int32(); - State = 1302; + State = 1312; Match(T__30); } break; @@ -6475,9 +6484,9 @@ public VariantTypeContext variantType() { int _la; try { int _alt; - State = 1314; + State = 1324; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,60,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,59,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -6486,16 +6495,16 @@ public VariantTypeContext variantType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1307; + State = 1317; variantTypeElement(); - State = 1311; + State = 1321; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,59,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,58,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1308; + State = 1318; _la = TokenStream.LA(1); if ( !(((((_la - 229)) & ~0x3f) == 0 && ((1L << (_la - 229)) & 6442450945L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -6507,9 +6516,9 @@ public VariantTypeContext variantType() { } } } - State = 1313; + State = 1323; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,59,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,58,Context); } } break; @@ -6588,7 +6597,7 @@ public VariantTypeElementContext variantTypeElement() { try { EnterOuterAlt(_localctx, 1); { - State = 1316; + State = 1326; _la = TokenStream.LA(1); if ( !(((((_la - 178)) & ~0x3f) == 0 && ((1L << (_la - 178)) & -4482436704239647L) != 0) || _la==CLSID || _la==PTR) ) { ErrorHandler.RecoverInline(this); @@ -6641,23 +6650,23 @@ public TypeContext type() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1318; + State = 1328; elementType(); - State = 1322; + State = 1332; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,61,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,60,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1319; + State = 1329; typeModifiers(); } } } - State = 1324; + State = 1334; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,61,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,60,Context); } } } @@ -6777,14 +6786,14 @@ public TypeModifiersContext typeModifiers() { TypeModifiersContext _localctx = new TypeModifiersContext(Context, State); EnterRule(_localctx, 140, RULE_typeModifiers); try { - State = 1343; + State = 1353; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,62,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,61,Context) ) { case 1: _localctx = new SZArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 1); { - State = 1325; + State = 1335; Match(ARRAY_TYPE_NO_BOUNDS); } break; @@ -6792,9 +6801,9 @@ public TypeModifiersContext typeModifiers() { _localctx = new SZArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 2); { - State = 1326; + State = 1336; Match(T__41); - State = 1327; + State = 1337; Match(T__42); } break; @@ -6802,7 +6811,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new ArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 3); { - State = 1328; + State = 1338; bounds(); } break; @@ -6810,7 +6819,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new ByRefModifierContext(_localctx); EnterOuterAlt(_localctx, 4); { - State = 1329; + State = 1339; Match(REF); } break; @@ -6818,7 +6827,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new PtrModifierContext(_localctx); EnterOuterAlt(_localctx, 5); { - State = 1330; + State = 1340; Match(PTR); } break; @@ -6826,7 +6835,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new PinnedModifierContext(_localctx); EnterOuterAlt(_localctx, 6); { - State = 1331; + State = 1341; Match(T__91); } break; @@ -6834,13 +6843,13 @@ public TypeModifiersContext typeModifiers() { _localctx = new RequiredModifierContext(_localctx); EnterOuterAlt(_localctx, 7); { - State = 1332; + State = 1342; Match(T__92); - State = 1333; + State = 1343; Match(T__29); - State = 1334; + State = 1344; typeSpec(); - State = 1335; + State = 1345; Match(T__30); } break; @@ -6848,13 +6857,13 @@ public TypeModifiersContext typeModifiers() { _localctx = new OptionalModifierContext(_localctx); EnterOuterAlt(_localctx, 8); { - State = 1337; + State = 1347; Match(T__93); - State = 1338; + State = 1348; Match(T__29); - State = 1339; + State = 1349; typeSpec(); - State = 1340; + State = 1350; Match(T__30); } break; @@ -6862,7 +6871,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new GenericArgumentsModifierContext(_localctx); EnterOuterAlt(_localctx, 9); { - State = 1342; + State = 1352; typeArgs(); } break; @@ -6935,144 +6944,144 @@ public ElementTypeContext elementType() { ElementTypeContext _localctx = new ElementTypeContext(Context, State); EnterRule(_localctx, 142, RULE_elementType); try { - State = 1375; + State = 1385; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,63,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,62,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1345; + State = 1355; Match(T__38); - State = 1346; + State = 1356; className(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1347; + State = 1357; Match(OBJECT); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1348; + State = 1358; Match(VALUE); - State = 1349; + State = 1359; Match(T__38); - State = 1350; + State = 1360; className(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1351; + State = 1361; Match(VALUETYPE); - State = 1352; + State = 1362; className(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1353; + State = 1363; Match(METHOD); - State = 1354; + State = 1364; callConv(); - State = 1355; + State = 1365; type(); - State = 1356; + State = 1366; Match(PTR); - State = 1357; + State = 1367; sigArgs(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1359; + State = 1369; Match(METHOD_TYPE_PARAMETER); - State = 1360; + State = 1370; int32(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1361; + State = 1371; Match(TYPE_PARAMETER); - State = 1362; + State = 1372; int32(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1363; + State = 1373; Match(METHOD_TYPE_PARAMETER); - State = 1364; + State = 1374; dottedName(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 1365; + State = 1375; Match(TYPE_PARAMETER); - State = 1366; + State = 1376; dottedName(); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 1367; + State = 1377; Match(TYPEDREF); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 1368; + State = 1378; Match(VOID); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 1369; + State = 1379; nativeInt(); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 1370; + State = 1380; nativeUint(); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 1371; + State = 1381; simpleType(); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 1372; + State = 1382; dottedName(); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 1373; + State = 1383; Match(ELLIPSIS); - State = 1374; + State = 1384; type(); } break; @@ -7121,133 +7130,133 @@ public SimpleTypeContext simpleType() { SimpleTypeContext _localctx = new SimpleTypeContext(Context, State); EnterRule(_localctx, 144, RULE_simpleType); try { - State = 1398; + State = 1408; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,64,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,63,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1377; + State = 1387; Match(CHAR); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1378; + State = 1388; Match(STRING); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1379; + State = 1389; Match(BOOL); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1380; + State = 1390; Match(INT8); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1381; + State = 1391; Match(INT16); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1382; + State = 1392; Match(INT32_); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1383; + State = 1393; Match(INT64_); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1384; + State = 1394; Match(FLOAT32); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 1385; + State = 1395; Match(FLOAT64_); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 1386; + State = 1396; Match(UINT8); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 1387; + State = 1397; Match(UINT16); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 1388; + State = 1398; Match(UINT32); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 1389; + State = 1399; Match(UINT64); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 1390; + State = 1400; Match(T__89); - State = 1391; + State = 1401; Match(INT8); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 1392; + State = 1402; Match(T__89); - State = 1393; + State = 1403; Match(INT16); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 1394; + State = 1404; Match(T__89); - State = 1395; + State = 1405; Match(INT32_); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 1396; + State = 1406; Match(T__89); - State = 1397; + State = 1407; Match(INT64_); } break; @@ -7290,9 +7299,9 @@ public BoundContext bound() { BoundContext _localctx = new BoundContext(Context, State); EnterRule(_localctx, 146, RULE_bound); try { - State = 1410; + State = 1420; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,65,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,64,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -7301,34 +7310,34 @@ public BoundContext bound() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1401; + State = 1411; Match(ELLIPSIS); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1402; + State = 1412; int32(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1403; + State = 1413; int32(); - State = 1404; + State = 1414; Match(ELLIPSIS); - State = 1405; + State = 1415; int32(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1407; + State = 1417; int32(); - State = 1408; + State = 1418; Match(ELLIPSIS); } break; @@ -7367,9 +7376,9 @@ public NativeIntContext nativeInt() { try { EnterOuterAlt(_localctx, 1); { - State = 1412; + State = 1422; Match(T__0); - State = 1413; + State = 1423; Match(INT); } } @@ -7407,22 +7416,22 @@ public NativeUintContext nativeUint() { try { EnterOuterAlt(_localctx, 1); { - State = 1415; + State = 1425; Match(T__0); - State = 1419; + State = 1429; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__89: { - State = 1416; + State = 1426; Match(T__89); - State = 1417; + State = 1427; Match(INT); } break; case UINT: { - State = 1418; + State = 1428; Match(UINT); } break; @@ -7485,125 +7494,125 @@ public SecDeclContext secDecl() { EnterRule(_localctx, 152, RULE_secDecl); int _la; try { - State = 1468; + State = 1478; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,68,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,67,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1421; + State = 1431; Match(PERMISSION); - State = 1422; + State = 1432; secAction(); - State = 1423; + State = 1433; typeSpec(); - State = 1424; + State = 1434; Match(T__29); - State = 1425; + State = 1435; nameValPairs(); - State = 1426; + State = 1436; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1428; + State = 1438; Match(PERMISSION); - State = 1429; + State = 1439; secAction(); - State = 1430; + State = 1440; typeSpec(); - State = 1431; + State = 1441; Match(T__35); - State = 1432; + State = 1442; Match(T__16); - State = 1433; + State = 1443; customBlobDescr(); - State = 1434; + State = 1444; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1436; + State = 1446; Match(PERMISSION); - State = 1437; + State = 1447; secAction(); - State = 1438; + State = 1448; typeSpec(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1440; + State = 1450; Match(PERMISSIONSET); - State = 1441; + State = 1451; secAction(); - State = 1442; + State = 1452; Match(T__35); - State = 1444; + State = 1454; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__83) { { - State = 1443; + State = 1453; Match(T__83); } } - State = 1446; + State = 1456; Match(T__29); - State = 1447; + State = 1457; bytes(); - State = 1448; + State = 1458; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1450; + State = 1460; Match(PERMISSIONSET); - State = 1451; + State = 1461; secAction(); - State = 1452; + State = 1462; Match(T__83); - State = 1453; + State = 1463; Match(T__29); - State = 1454; + State = 1464; bytes(); - State = 1455; + State = 1465; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1457; + State = 1467; Match(PERMISSIONSET); - State = 1458; + State = 1468; secAction(); - State = 1459; + State = 1469; compQstring(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1461; + State = 1471; Match(PERMISSIONSET); - State = 1462; + State = 1472; secAction(); - State = 1463; + State = 1473; Match(T__35); - State = 1464; + State = 1474; Match(T__16); - State = 1465; + State = 1475; secAttrSetBlob(); - State = 1466; + State = 1476; Match(T__17); } break; @@ -7646,7 +7655,7 @@ public SecAttrSetBlobContext secAttrSetBlob() { EnterRule(_localctx, 154, RULE_secAttrSetBlob); try { int _alt; - State = 1480; + State = 1490; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__17: @@ -7691,25 +7700,25 @@ public SecAttrSetBlobContext secAttrSetBlob() { case ID: EnterOuterAlt(_localctx, 2); { - State = 1476; + State = 1486; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,69,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,68,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1471; + State = 1481; secAttrBlob(); - State = 1472; + State = 1482; Match(T__27); } } } - State = 1478; + State = 1488; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,69,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,68,Context); } - State = 1479; + State = 1489; secAttrBlob(); } break; @@ -7754,38 +7763,38 @@ public SecAttrBlobContext secAttrBlob() { SecAttrBlobContext _localctx = new SecAttrBlobContext(Context, State); EnterRule(_localctx, 156, RULE_secAttrBlob); try { - State = 1495; + State = 1505; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,71,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,70,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1482; + State = 1492; Match(T__38); - State = 1483; + State = 1493; Match(SQSTRING); - State = 1484; + State = 1494; Match(T__35); - State = 1485; + State = 1495; Match(T__16); - State = 1486; + State = 1496; customBlobNVPairs(); - State = 1487; + State = 1497; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1489; + State = 1499; typeSpec(); - State = 1490; + State = 1500; Match(T__35); - State = 1491; + State = 1501; Match(T__16); - State = 1492; + State = 1502; customBlobNVPairs(); - State = 1493; + State = 1503; Match(T__17); } break; @@ -7830,25 +7839,25 @@ public NameValPairsContext nameValPairs() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1502; + State = 1512; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,72,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,71,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1497; + State = 1507; nameValPair(); - State = 1498; + State = 1508; Match(T__27); } } } - State = 1504; + State = 1514; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,72,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,71,Context); } - State = 1505; + State = 1515; nameValPair(); } } @@ -7890,11 +7899,11 @@ public NameValPairContext nameValPair() { try { EnterOuterAlt(_localctx, 1); { - State = 1507; + State = 1517; compQstring(); - State = 1508; + State = 1518; Match(T__35); - State = 1509; + State = 1519; caValue(); } } @@ -7931,7 +7940,7 @@ public TruefalseContext truefalse() { try { EnterOuterAlt(_localctx, 1); { - State = 1511; + State = 1521; _la = TokenStream.LA(1); if ( !(_la==T__94 || _la==T__95) ) { ErrorHandler.RecoverInline(this); @@ -7987,104 +7996,104 @@ public CaValueContext caValue() { CaValueContext _localctx = new CaValueContext(Context, State); EnterRule(_localctx, 164, RULE_caValue); try { - State = 1547; + State = 1557; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,73,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,72,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1513; + State = 1523; truefalse(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1514; + State = 1524; int32(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1515; + State = 1525; Match(INT32_); - State = 1516; + State = 1526; Match(T__29); - State = 1517; + State = 1527; int32(); - State = 1518; + State = 1528; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1520; + State = 1530; compQstring(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1521; + State = 1531; className(); - State = 1522; + State = 1532; Match(T__29); - State = 1523; + State = 1533; Match(INT8); - State = 1524; + State = 1534; Match(T__74); - State = 1525; + State = 1535; int32(); - State = 1526; + State = 1536; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1528; + State = 1538; className(); - State = 1529; + State = 1539; Match(T__29); - State = 1530; + State = 1540; Match(INT16); - State = 1531; + State = 1541; Match(T__74); - State = 1532; + State = 1542; int32(); - State = 1533; + State = 1543; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1535; + State = 1545; className(); - State = 1536; + State = 1546; Match(T__29); - State = 1537; + State = 1547; Match(INT32_); - State = 1538; + State = 1548; Match(T__74); - State = 1539; + State = 1549; int32(); - State = 1540; + State = 1550; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1542; + State = 1552; className(); - State = 1543; + State = 1553; Match(T__29); - State = 1544; + State = 1554; int32(); - State = 1545; + State = 1555; Match(T__30); } break; @@ -8123,7 +8132,7 @@ public SecActionContext secAction() { try { EnterOuterAlt(_localctx, 1); { - State = 1549; + State = 1559; _la = TokenStream.LA(1); if ( !(((((_la - 97)) & ~0x3f) == 0 && ((1L << (_la - 97)) & 32767L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -8191,106 +8200,107 @@ public override TResult Accept(IParseTreeVisitor visitor) { public MethodRefContext methodRef() { MethodRefContext _localctx = new MethodRefContext(Context, State); EnterRule(_localctx, 168, RULE_methodRef); + BeginSubtree(); int _la; try { - State = 1585; + State = 1595; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,76,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,75,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1551; + State = 1561; callConv(); - State = 1552; + State = 1562; type(); - State = 1553; + State = 1563; typeSpec(); - State = 1554; + State = 1564; Match(DCOLON); - State = 1555; + State = 1565; methodName(); - State = 1557; + State = 1567; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 1556; + State = 1566; typeArgs(); } } - State = 1559; + State = 1569; sigArgs(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1561; + State = 1571; callConv(); - State = 1562; + State = 1572; type(); - State = 1563; + State = 1573; typeSpec(); - State = 1564; + State = 1574; Match(DCOLON); - State = 1565; + State = 1575; methodName(); - State = 1566; + State = 1576; genArityNotEmpty(); - State = 1567; + State = 1577; sigArgs(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1569; + State = 1579; callConv(); - State = 1570; + State = 1580; type(); - State = 1571; + State = 1581; methodName(); - State = 1573; + State = 1583; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 1572; + State = 1582; typeArgs(); } } - State = 1575; + State = 1585; sigArgs(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1577; + State = 1587; callConv(); - State = 1578; + State = 1588; type(); - State = 1579; + State = 1589; methodName(); - State = 1580; + State = 1590; genArityNotEmpty(); - State = 1581; + State = 1591; sigArgs(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1583; + State = 1593; mdtoken(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1584; + State = 1594; dottedName(); } break; @@ -8302,6 +8312,7 @@ public MethodRefContext methodRef() { ErrorHandler.Recover(this, re); } finally { + EndParseTreeMode(); ExitRule(); } return _localctx; @@ -8337,44 +8348,44 @@ public CallConvContext callConv() { CallConvContext _localctx = new CallConvContext(Context, State); EnterRule(_localctx, 170, RULE_callConv); try { - State = 1597; + State = 1607; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,77,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,76,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1587; + State = 1597; Match(INSTANCE); - State = 1588; + State = 1598; callConv(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1589; + State = 1599; Match(EXPLICIT); - State = 1590; + State = 1600; callConv(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1591; + State = 1601; callKind(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1592; + State = 1602; Match(T__111); - State = 1593; + State = 1603; Match(T__29); - State = 1594; + State = 1604; int32(); - State = 1595; + State = 1605; Match(T__30); } break; @@ -8417,9 +8428,9 @@ public CallKindContext callKind() { CallKindContext _localctx = new CallKindContext(Context, State); EnterRule(_localctx, 172, RULE_callKind); try { - State = 1611; + State = 1621; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,78,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,77,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -8428,57 +8439,57 @@ public CallKindContext callKind() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1600; + State = 1610; Match(DEFAULT); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1601; + State = 1611; Match(VARARG); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1602; + State = 1612; Match(UNMANAGED); - State = 1603; + State = 1613; Match(CDECL); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1604; + State = 1614; Match(UNMANAGED); - State = 1605; + State = 1615; Match(STDCALL); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1606; + State = 1616; Match(UNMANAGED); - State = 1607; + State = 1617; Match(THISCALL); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1608; + State = 1618; Match(UNMANAGED); - State = 1609; + State = 1619; Match(FASTCALL); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1610; + State = 1620; Match(UNMANAGED); } break; @@ -8516,16 +8527,17 @@ public override TResult Accept(IParseTreeVisitor visitor) { public MdtokenContext mdtoken() { MdtokenContext _localctx = new MdtokenContext(Context, State); EnterRule(_localctx, 174, RULE_mdtoken); + BeginSubtree(); try { EnterOuterAlt(_localctx, 1); { - State = 1613; + State = 1623; Match(T__112); - State = 1614; + State = 1624; Match(T__29); - State = 1615; + State = 1625; int32(); - State = 1616; + State = 1626; Match(T__30); } } @@ -8535,6 +8547,7 @@ public MdtokenContext mdtoken() { ErrorHandler.Recover(this, re); } finally { + EndParseTreeMode(); ExitRule(); } return _localctx; @@ -8569,31 +8582,31 @@ public MemberRefContext memberRef() { MemberRefContext _localctx = new MemberRefContext(Context, State); EnterRule(_localctx, 176, RULE_memberRef); try { - State = 1623; + State = 1633; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case METHOD: EnterOuterAlt(_localctx, 1); { - State = 1618; + State = 1628; Match(METHOD); - State = 1619; + State = 1629; methodRef(); } break; case T__36: EnterOuterAlt(_localctx, 2); { - State = 1620; + State = 1630; Match(T__36); - State = 1621; + State = 1631; fieldRef(); } break; case T__112: EnterOuterAlt(_localctx, 3); { - State = 1622; + State = 1632; mdtoken(); } break; @@ -8640,36 +8653,37 @@ public override TResult Accept(IParseTreeVisitor visitor) { public FieldRefContext fieldRef() { FieldRefContext _localctx = new FieldRefContext(Context, State); EnterRule(_localctx, 178, RULE_fieldRef); + BeginSubtree(); try { - State = 1634; + State = 1644; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,80,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,79,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1625; + State = 1635; type(); - State = 1626; + State = 1636; typeSpec(); - State = 1627; + State = 1637; Match(DCOLON); - State = 1628; + State = 1638; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1630; + State = 1640; type(); - State = 1631; + State = 1641; dottedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1633; + State = 1643; dottedName(); } break; @@ -8681,6 +8695,7 @@ public FieldRefContext fieldRef() { ErrorHandler.Recover(this, re); } finally { + EndParseTreeMode(); ExitRule(); } return _localctx; @@ -8714,25 +8729,25 @@ public TypeListContext typeList() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1641; + State = 1651; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,81,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,80,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1636; + State = 1646; typeSpec(); - State = 1637; + State = 1647; Match(T__27); } } } - State = 1643; + State = 1653; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,81,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,80,Context); } - State = 1644; + State = 1654; typeSpec(); } } @@ -8769,7 +8784,7 @@ public TyparsClauseContext typarsClause() { TyparsClauseContext _localctx = new TyparsClauseContext(Context, State); EnterRule(_localctx, 182, RULE_typarsClause); try { - State = 1651; + State = 1661; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -8784,11 +8799,11 @@ public TyparsClauseContext typarsClause() { case T__85: EnterOuterAlt(_localctx, 2); { - State = 1647; + State = 1657; Match(T__85); - State = 1648; + State = 1658; typars(); - State = 1649; + State = 1659; Match(T__86); } break; @@ -8838,61 +8853,61 @@ public TyparAttribContext typarAttrib() { TyparAttribContext _localctx = new TyparAttribContext(Context, State); EnterRule(_localctx, 184, RULE_typarAttrib); try { - State = 1664; + State = 1674; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case PLUS: EnterOuterAlt(_localctx, 1); { - State = 1653; + State = 1663; _localctx.covariant = Match(PLUS); } break; case T__113: EnterOuterAlt(_localctx, 2); { - State = 1654; + State = 1664; _localctx.contravariant = Match(T__113); } break; case T__38: EnterOuterAlt(_localctx, 3); { - State = 1655; + State = 1665; _localctx.@class = Match(T__38); } break; case VALUETYPE: EnterOuterAlt(_localctx, 4); { - State = 1656; + State = 1666; _localctx.valuetype = Match(VALUETYPE); } break; case T__114: EnterOuterAlt(_localctx, 5); { - State = 1657; + State = 1667; _localctx.byrefLike = Match(T__114); } break; case T__115: EnterOuterAlt(_localctx, 6); { - State = 1658; + State = 1668; _localctx.ctor = Match(T__115); } break; case T__69: EnterOuterAlt(_localctx, 7); { - State = 1659; + State = 1669; Match(T__69); - State = 1660; + State = 1670; Match(T__29); - State = 1661; + State = 1671; _localctx.flags = int32(); - State = 1662; + State = 1672; Match(T__30); } break; @@ -8939,17 +8954,17 @@ public TyparAttribsContext typarAttribs() { try { EnterOuterAlt(_localctx, 1); { - State = 1669; + State = 1679; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__38 || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & 123145302310913L) != 0) || _la==VALUETYPE || _la==PLUS) { { { - State = 1666; + State = 1676; typarAttrib(); } } - State = 1671; + State = 1681; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -8997,19 +9012,19 @@ public TyparContext typar() { try { EnterOuterAlt(_localctx, 1); { - State = 1672; + State = 1682; typarAttribs(); - State = 1674; + State = 1684; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__29) { { - State = 1673; + State = 1683; tyBound(); } } - State = 1676; + State = 1686; dottedName(); } } @@ -9052,25 +9067,25 @@ public TyparsContext typars() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1683; + State = 1693; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,86,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,85,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1678; + State = 1688; typar(); - State = 1679; + State = 1689; Match(T__27); } } } - State = 1685; + State = 1695; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,86,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,85,Context); } - State = 1686; + State = 1696; typar(); } } @@ -9109,11 +9124,11 @@ public TyBoundContext tyBound() { try { EnterOuterAlt(_localctx, 1); { - State = 1688; + State = 1698; Match(T__29); - State = 1689; + State = 1699; typeList(); - State = 1690; + State = 1700; Match(T__30); } } @@ -9150,7 +9165,7 @@ public GenArityContext genArity() { GenArityContext _localctx = new GenArityContext(Context, State); EnterRule(_localctx, 194, RULE_genArity); try { - State = 1694; + State = 1704; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__29: @@ -9162,7 +9177,7 @@ public GenArityContext genArity() { case T__85: EnterOuterAlt(_localctx, 2); { - State = 1693; + State = 1703; genArityNotEmpty(); } break; @@ -9205,15 +9220,15 @@ public GenArityNotEmptyContext genArityNotEmpty() { try { EnterOuterAlt(_localctx, 1); { - State = 1696; + State = 1706; Match(T__85); - State = 1697; + State = 1707; Match(T__41); - State = 1698; + State = 1708; int32(); - State = 1699; + State = 1709; Match(T__42); - State = 1700; + State = 1710; Match(T__86); } } @@ -9360,343 +9375,343 @@ public ClassDeclContext classDecl() { BeginSubtree(); try { int _alt; - State = 1818; + State = 1828; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,92,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,91,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1702; + State = 1712; methodHead(); - State = 1703; + State = 1713; Match(T__16); - State = 1704; + State = 1714; methodDecls(); - State = 1705; + State = 1715; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1707; + State = 1717; classHead(); - State = 1708; + State = 1718; Match(T__16); - State = 1709; + State = 1719; classDecls(); - State = 1710; + State = 1720; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1712; + State = 1722; eventHead(); - State = 1713; + State = 1723; Match(T__16); - State = 1714; + State = 1724; eventDecls(); - State = 1715; + State = 1725; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1717; + State = 1727; propHead(); - State = 1718; + State = 1728; Match(T__16); - State = 1719; + State = 1729; propDecls(); - State = 1720; + State = 1730; Match(T__17); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1722; + State = 1732; fieldDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1723; + State = 1733; dataDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1724; + State = 1734; secDecl(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1725; + State = 1735; extSourceSpec(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 1726; + State = 1736; customAttrDecl(); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 1727; + State = 1737; Match(T__116); - State = 1728; + State = 1738; int32(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 1729; + State = 1739; Match(T__117); - State = 1730; + State = 1740; int32(); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 1731; + State = 1741; exportHead(); - State = 1732; + State = 1742; Match(T__16); - State = 1733; + State = 1743; exptypeDecls(); - State = 1734; + State = 1744; Match(T__17); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 1736; + State = 1746; Match(OVERRIDE); - State = 1737; + State = 1747; typeSpec(); - State = 1738; + State = 1748; Match(DCOLON); - State = 1739; + State = 1749; methodName(); - State = 1740; + State = 1750; Match(T__118); - State = 1741; + State = 1751; callConv(); - State = 1742; + State = 1752; type(); - State = 1743; + State = 1753; typeSpec(); - State = 1744; + State = 1754; Match(DCOLON); - State = 1745; + State = 1755; methodName(); - State = 1746; + State = 1756; sigArgs(); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 1748; + State = 1758; Match(OVERRIDE); - State = 1749; + State = 1759; Match(METHOD); - State = 1750; + State = 1760; callConv(); - State = 1751; + State = 1761; type(); - State = 1752; + State = 1762; typeSpec(); - State = 1753; + State = 1763; Match(DCOLON); - State = 1754; + State = 1764; methodName(); - State = 1755; + State = 1765; genArity(); - State = 1756; + State = 1766; sigArgs(); - State = 1757; + State = 1767; Match(T__118); - State = 1758; + State = 1768; Match(METHOD); - State = 1759; + State = 1769; callConv(); - State = 1760; + State = 1770; type(); - State = 1761; + State = 1771; typeSpec(); - State = 1762; + State = 1772; Match(DCOLON); - State = 1763; + State = 1773; methodName(); - State = 1764; + State = 1774; genArity(); - State = 1765; + State = 1775; sigArgs(); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 1767; + State = 1777; languageDecl(); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 1768; + State = 1778; compControl(); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 1769; + State = 1779; Match(PARAM); - State = 1770; + State = 1780; Match(TYPE); - State = 1771; + State = 1781; Match(T__41); - State = 1772; + State = 1782; int32(); - State = 1773; + State = 1783; Match(T__42); - State = 1777; + State = 1787; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,87,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1774; + State = 1784; customAttrDecl(); } } } - State = 1779; + State = 1789; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,87,Context); } } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 1780; + State = 1790; Match(PARAM); - State = 1781; + State = 1791; Match(TYPE); - State = 1782; + State = 1792; dottedName(); - State = 1786; + State = 1796; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1783; + State = 1793; customAttrDecl(); } } } - State = 1788; + State = 1798; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); } } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 1789; + State = 1799; Match(PARAM); - State = 1790; + State = 1800; Match(CONSTRAINT); - State = 1791; + State = 1801; Match(T__41); - State = 1792; + State = 1802; int32(); - State = 1793; + State = 1803; Match(T__42); - State = 1794; + State = 1804; Match(T__27); - State = 1795; + State = 1805; typeSpec(); - State = 1799; + State = 1809; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1796; + State = 1806; customAttrDecl(); } } } - State = 1801; + State = 1811; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); } } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 1802; + State = 1812; Match(PARAM); - State = 1803; + State = 1813; Match(CONSTRAINT); - State = 1804; + State = 1814; dottedName(); - State = 1805; + State = 1815; Match(T__27); - State = 1806; + State = 1816; typeSpec(); - State = 1810; + State = 1820; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1807; + State = 1817; customAttrDecl(); } } } - State = 1812; + State = 1822; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); } } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 1813; + State = 1823; Match(T__119); - State = 1814; + State = 1824; Match(TYPE); - State = 1815; + State = 1825; typeSpec(); - State = 1816; + State = 1826; customDescr(); } break; @@ -9765,17 +9780,17 @@ public FieldDeclContext fieldDecl() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1820; + State = 1830; Match(T__120); - State = 1821; + State = 1831; repeatOpt(); - State = 1830; + State = 1840; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,94,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,93,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { - State = 1828; + State = 1838; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -9794,19 +9809,19 @@ public FieldDeclContext fieldDecl() { case T__125: case T__126: { - State = 1822; + State = 1832; fieldAttr(); } break; case T__121: { - State = 1823; + State = 1833; Match(T__121); - State = 1824; + State = 1834; Match(T__29); - State = 1825; + State = 1835; marshalBlob(); - State = 1826; + State = 1836; Match(T__30); } break; @@ -9815,17 +9830,17 @@ public FieldDeclContext fieldDecl() { } } } - State = 1832; + State = 1842; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,94,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,93,Context); } - State = 1833; + State = 1843; type(); - State = 1834; + State = 1844; dottedName(); - State = 1835; + State = 1845; atOpt(); - State = 1836; + State = 1846; initOpt(); } } @@ -9862,117 +9877,117 @@ public FieldAttrContext fieldAttr() { FieldAttrContext _localctx = new FieldAttrContext(Context, State); EnterRule(_localctx, 202, RULE_fieldAttr); try { - State = 1857; + State = 1867; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__122: EnterOuterAlt(_localctx, 1); { - State = 1838; + State = 1848; Match(T__122); } break; case T__50: EnterOuterAlt(_localctx, 2); { - State = 1839; + State = 1849; Match(T__50); } break; case T__51: EnterOuterAlt(_localctx, 3); { - State = 1840; + State = 1850; Match(T__51); } break; case T__62: EnterOuterAlt(_localctx, 4); { - State = 1841; + State = 1851; Match(T__62); } break; case T__123: EnterOuterAlt(_localctx, 5); { - State = 1842; + State = 1852; Match(T__123); } break; case T__68: EnterOuterAlt(_localctx, 6); { - State = 1843; + State = 1853; Match(T__68); } break; case T__67: EnterOuterAlt(_localctx, 7); { - State = 1844; + State = 1854; Match(T__67); } break; case T__63: EnterOuterAlt(_localctx, 8); { - State = 1845; + State = 1855; Match(T__63); } break; case T__64: EnterOuterAlt(_localctx, 9); { - State = 1846; + State = 1856; Match(T__64); } break; case T__65: EnterOuterAlt(_localctx, 10); { - State = 1847; + State = 1857; Match(T__65); } break; case T__124: EnterOuterAlt(_localctx, 11); { - State = 1848; + State = 1858; Match(T__124); } break; case T__125: EnterOuterAlt(_localctx, 12); { - State = 1849; + State = 1859; Match(T__125); } break; case T__126: EnterOuterAlt(_localctx, 13); { - State = 1850; + State = 1860; Match(T__126); } break; case T__15: EnterOuterAlt(_localctx, 14); { - State = 1851; + State = 1861; Match(T__15); } break; case T__69: EnterOuterAlt(_localctx, 15); { - State = 1852; + State = 1862; Match(T__69); - State = 1853; + State = 1863; Match(T__29); - State = 1854; + State = 1864; int32(); - State = 1855; + State = 1865; Match(T__30); } break; @@ -10016,9 +10031,9 @@ public AtOptContext atOpt() { AtOptContext _localctx = new AtOptContext(Context, State); EnterRule(_localctx, 204, RULE_atOpt); try { - State = 1864; + State = 1874; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,96,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,95,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -10027,18 +10042,18 @@ public AtOptContext atOpt() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1860; + State = 1870; Match(T__43); - State = 1861; + State = 1871; id(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1862; + State = 1872; Match(T__43); - State = 1863; + State = 1873; int32(); } break; @@ -10077,7 +10092,7 @@ public InitOptContext initOpt() { InitOptContext _localctx = new InitOptContext(Context, State); EnterRule(_localctx, 206, RULE_initOpt); try { - State = 1869; + State = 1879; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -10171,9 +10186,9 @@ public InitOptContext initOpt() { case T__35: EnterOuterAlt(_localctx, 2); { - State = 1867; + State = 1877; Match(T__35); - State = 1868; + State = 1878; fieldInit(); } break; @@ -10214,7 +10229,7 @@ public RepeatOptContext repeatOpt() { RepeatOptContext _localctx = new RepeatOptContext(Context, State); EnterRule(_localctx, 208, RULE_repeatOpt); try { - State = 1876; + State = 1886; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -10269,11 +10284,11 @@ public RepeatOptContext repeatOpt() { case T__41: EnterOuterAlt(_localctx, 2); { - State = 1872; + State = 1882; Match(T__41); - State = 1873; + State = 1883; int32(); - State = 1874; + State = 1884; Match(T__42); } break; @@ -10324,54 +10339,54 @@ public EventHeadContext eventHead() { EnterRule(_localctx, 210, RULE_eventHead); int _la; try { - State = 1896; + State = 1906; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,101,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,100,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1878; + State = 1888; Match(T__127); - State = 1882; + State = 1892; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 1879; + State = 1889; eventAttr(); } } - State = 1884; + State = 1894; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 1885; + State = 1895; typeSpec(); - State = 1886; + State = 1896; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1888; + State = 1898; Match(T__127); - State = 1892; + State = 1902; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 1889; + State = 1899; eventAttr(); } } - State = 1894; + State = 1904; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 1895; + State = 1905; dottedName(); } break; @@ -10410,7 +10425,7 @@ public EventAttrContext eventAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 1898; + State = 1908; _la = TokenStream.LA(1); if ( !(_la==T__67 || _la==T__68) ) { ErrorHandler.RecoverInline(this); @@ -10460,17 +10475,17 @@ public EventDeclsContext eventDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 1903; + State = 1913; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38788988928L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 1080863910568919043L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 1900; + State = 1910; eventDecl(); } } - State = 1905; + State = 1915; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -10521,42 +10536,42 @@ public EventDeclContext eventDecl() { EventDeclContext _localctx = new EventDeclContext(Context, State); EnterRule(_localctx, 216, RULE_eventDecl); try { - State = 1918; + State = 1928; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__128: EnterOuterAlt(_localctx, 1); { - State = 1906; + State = 1916; Match(T__128); - State = 1907; + State = 1917; methodRef(); } break; case T__129: EnterOuterAlt(_localctx, 2); { - State = 1908; + State = 1918; Match(T__129); - State = 1909; + State = 1919; methodRef(); } break; case T__130: EnterOuterAlt(_localctx, 3); { - State = 1910; + State = 1920; Match(T__130); - State = 1911; + State = 1921; methodRef(); } break; case T__131: EnterOuterAlt(_localctx, 4); { - State = 1912; + State = 1922; Match(T__131); - State = 1913; + State = 1923; methodRef(); } break; @@ -10564,7 +10579,7 @@ public EventDeclContext eventDecl() { case T__73: EnterOuterAlt(_localctx, 5); { - State = 1914; + State = 1924; extSourceSpec(); } break; @@ -10577,14 +10592,14 @@ public EventDeclContext eventDecl() { case ID: EnterOuterAlt(_localctx, 6); { - State = 1915; + State = 1925; customAttrDecl(); } break; case T__26: EnterOuterAlt(_localctx, 7); { - State = 1916; + State = 1926; languageDecl(); } break; @@ -10598,7 +10613,7 @@ public EventDeclContext eventDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 8); { - State = 1917; + State = 1927; compControl(); } break; @@ -10660,31 +10675,31 @@ public PropHeadContext propHead() { try { EnterOuterAlt(_localctx, 1); { - State = 1920; + State = 1930; Match(T__132); - State = 1924; + State = 1934; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 1921; + State = 1931; propAttr(); } } - State = 1926; + State = 1936; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 1927; + State = 1937; callConv(); - State = 1928; + State = 1938; type(); - State = 1929; + State = 1939; dottedName(); - State = 1930; + State = 1940; sigArgs(); - State = 1931; + State = 1941; initOpt(); } } @@ -10721,7 +10736,7 @@ public PropAttrContext propAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 1933; + State = 1943; _la = TokenStream.LA(1); if ( !(_la==T__67 || _la==T__68) ) { ErrorHandler.RecoverInline(this); @@ -10771,17 +10786,17 @@ public PropDeclsContext propDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 1938; + State = 1948; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38788988928L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 7493989779944505347L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 1935; + State = 1945; propDecl(); } } - State = 1940; + State = 1950; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -10832,33 +10847,33 @@ public PropDeclContext propDecl() { PropDeclContext _localctx = new PropDeclContext(Context, State); EnterRule(_localctx, 224, RULE_propDecl); try { - State = 1951; + State = 1961; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__133: EnterOuterAlt(_localctx, 1); { - State = 1941; + State = 1951; Match(T__133); - State = 1942; + State = 1952; methodRef(); } break; case T__134: EnterOuterAlt(_localctx, 2); { - State = 1943; + State = 1953; Match(T__134); - State = 1944; + State = 1954; methodRef(); } break; case T__131: EnterOuterAlt(_localctx, 3); { - State = 1945; + State = 1955; Match(T__131); - State = 1946; + State = 1956; methodRef(); } break; @@ -10871,7 +10886,7 @@ public PropDeclContext propDecl() { case ID: EnterOuterAlt(_localctx, 4); { - State = 1947; + State = 1957; customAttrDecl(); } break; @@ -10879,14 +10894,14 @@ public PropDeclContext propDecl() { case T__73: EnterOuterAlt(_localctx, 5); { - State = 1948; + State = 1958; extSourceSpec(); } break; case T__26: EnterOuterAlt(_localctx, 6); { - State = 1949; + State = 1959; languageDecl(); } break; @@ -10900,7 +10915,7 @@ public PropDeclContext propDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 7); { - State = 1950; + State = 1960; compControl(); } break; @@ -10941,7 +10956,7 @@ public MarshalClauseContext marshalClause() { MarshalClauseContext _localctx = new MarshalClauseContext(Context, State); EnterRule(_localctx, 226, RULE_marshalClause); try { - State = 1959; + State = 1969; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -10977,13 +10992,13 @@ public MarshalClauseContext marshalClause() { case T__121: EnterOuterAlt(_localctx, 2); { - State = 1954; + State = 1964; Match(T__121); - State = 1955; + State = 1965; Match(T__29); - State = 1956; + State = 1966; marshalBlob(); - State = 1957; + State = 1967; Match(T__30); } break; @@ -11031,7 +11046,7 @@ public MarshalBlobContext marshalBlob() { EnterRule(_localctx, 228, RULE_marshalBlob); int _la; try { - State = 1970; + State = 1980; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -11086,30 +11101,30 @@ public MarshalBlobContext marshalBlob() { case ID: EnterOuterAlt(_localctx, 1); { - State = 1961; + State = 1971; nativeType(); } break; case T__16: EnterOuterAlt(_localctx, 2); { - State = 1962; + State = 1972; Match(T__16); - State = 1964; + State = 1974; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 1963; + State = 1973; hexbyte(); } } - State = 1966; + State = 1976; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( _la==INT32 || _la==ID || _la==HEXBYTE ); - State = 1968; + State = 1978; Match(T__17); } break; @@ -11156,17 +11171,17 @@ public ParamAttrContext paramAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 1975; + State = 1985; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__41) { { { - State = 1972; + State = 1982; paramAttrElement(); } } - State = 1977; + State = 1987; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11208,50 +11223,50 @@ public ParamAttrElementContext paramAttrElement() { ParamAttrElementContext _localctx = new ParamAttrElementContext(Context, State); EnterRule(_localctx, 232, RULE_paramAttrElement); try { - State = 1991; + State = 2001; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,111,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,110,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1978; + State = 1988; Match(T__41); - State = 1979; + State = 1989; _localctx.@in = Match(T__135); - State = 1980; + State = 1990; Match(T__42); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1981; + State = 1991; Match(T__41); - State = 1982; + State = 1992; _localctx.@out = Match(T__136); - State = 1983; + State = 1993; Match(T__42); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1984; + State = 1994; Match(T__41); - State = 1985; + State = 1995; _localctx.opt = Match(T__137); - State = 1986; + State = 1996; Match(T__42); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1987; + State = 1997; Match(T__41); - State = 1988; + State = 1998; int32(); - State = 1989; + State = 1999; Match(T__42); } break; @@ -11330,14 +11345,14 @@ public MethodHeadContext methodHead() { try { EnterOuterAlt(_localctx, 1); { - State = 1993; + State = 2003; Match(T__138); - State = 1998; + State = 2008; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & 978955L) != 0) || ((((_la - 123)) & ~0x3f) == 0 && ((1L << (_la - 123)) & 33423365L) != 0)) { { - State = 1996; + State = 2006; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__50: @@ -11360,13 +11375,13 @@ public MethodHeadContext methodHead() { case T__144: case T__145: { - State = 1994; + State = 2004; methAttr(); } break; case T__146: { - State = 1995; + State = 2005; pinvImpl(); } break; @@ -11374,35 +11389,35 @@ public MethodHeadContext methodHead() { throw new NoViableAltException(this); } } - State = 2000; + State = 2010; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2001; + State = 2011; callConv(); - State = 2002; + State = 2012; paramAttr(); - State = 2003; + State = 2013; type(); - State = 2004; + State = 2014; marshalClause(); - State = 2005; + State = 2015; methodName(); - State = 2006; + State = 2016; typarsClause(); - State = 2007; + State = 2017; sigArgs(); - State = 2011; + State = 2021; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 32766L) != 0) || _la==T__69 || _la==T__155 || _la==UNMANAGED) { { { - State = 2008; + State = 2018; implAttr(); } } - State = 2013; + State = 2023; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11444,145 +11459,145 @@ public MethAttrContext methAttr() { MethAttrContext _localctx = new MethAttrContext(Context, State); EnterRule(_localctx, 236, RULE_methAttr); try { - State = 2037; + State = 2047; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__122: EnterOuterAlt(_localctx, 1); { - State = 2014; + State = 2024; Match(T__122); } break; case T__50: EnterOuterAlt(_localctx, 2); { - State = 2015; + State = 2025; Match(T__50); } break; case T__51: EnterOuterAlt(_localctx, 3); { - State = 2016; + State = 2026; Match(T__51); } break; case T__62: EnterOuterAlt(_localctx, 4); { - State = 2017; + State = 2027; Match(T__62); } break; case T__139: EnterOuterAlt(_localctx, 5); { - State = 2018; + State = 2028; Match(T__139); } break; case T__67: EnterOuterAlt(_localctx, 6); { - State = 2019; + State = 2029; Match(T__67); } break; case T__140: EnterOuterAlt(_localctx, 7); { - State = 2020; + State = 2030; Match(T__140); } break; case T__141: EnterOuterAlt(_localctx, 8); { - State = 2021; + State = 2031; Match(T__141); } break; case T__53: EnterOuterAlt(_localctx, 9); { - State = 2022; + State = 2032; Match(T__53); } break; case T__63: EnterOuterAlt(_localctx, 10); { - State = 2023; + State = 2033; Match(T__63); } break; case T__64: EnterOuterAlt(_localctx, 11); { - State = 2024; + State = 2034; Match(T__64); } break; case T__65: EnterOuterAlt(_localctx, 12); { - State = 2025; + State = 2035; Match(T__65); } break; case T__124: EnterOuterAlt(_localctx, 13); { - State = 2026; + State = 2036; Match(T__124); } break; case T__142: EnterOuterAlt(_localctx, 14); { - State = 2027; + State = 2037; Match(T__142); } break; case T__143: EnterOuterAlt(_localctx, 15); { - State = 2028; + State = 2038; Match(T__143); } break; case T__68: EnterOuterAlt(_localctx, 16); { - State = 2029; + State = 2039; Match(T__68); } break; case T__144: EnterOuterAlt(_localctx, 17); { - State = 2030; + State = 2040; Match(T__144); } break; case T__145: EnterOuterAlt(_localctx, 18); { - State = 2031; + State = 2041; Match(T__145); } break; case T__69: EnterOuterAlt(_localctx, 19); { - State = 2032; + State = 2042; Match(T__69); - State = 2033; + State = 2043; Match(T__29); - State = 2034; + State = 2044; int32(); - State = 2035; + State = 2045; Match(T__30); } break; @@ -11633,31 +11648,31 @@ public PinvImplContext pinvImpl() { EnterRule(_localctx, 238, RULE_pinvImpl); int _la; try { - State = 2057; + State = 2067; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,119,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,118,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2039; + State = 2049; Match(T__146); - State = 2040; + State = 2050; Match(T__29); - State = 2046; + State = 2056; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==QSTRING) { { - State = 2041; + State = 2051; compQstring(); - State = 2044; + State = 2054; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__33) { { - State = 2042; + State = 2052; Match(T__33); - State = 2043; + State = 2053; compQstring(); } } @@ -11665,30 +11680,30 @@ public PinvImplContext pinvImpl() { } } - State = 2051; + State = 2061; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 57)) & ~0x3f) == 0 && ((1L << (_la - 57)) & 8195L) != 0) || ((((_la - 148)) & ~0x3f) == 0 && ((1L << (_la - 148)) & 79L) != 0) || ((((_la - 224)) & ~0x3f) == 0 && ((1L << (_la - 224)) & 251658241L) != 0)) { { { - State = 2048; + State = 2058; pinvAttr(); } } - State = 2053; + State = 2063; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2054; + State = 2064; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2055; + State = 2065; Match(T__146); - State = 2056; + State = 2066; Match(T__84); } break; @@ -11732,133 +11747,133 @@ public PinvAttrContext pinvAttr() { PinvAttrContext _localctx = new PinvAttrContext(Context, State); EnterRule(_localctx, 240, RULE_pinvAttr); try { - State = 2086; + State = 2096; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,120,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,119,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2059; + State = 2069; Match(T__147); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2060; + State = 2070; Match(ANSI); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2061; + State = 2071; Match(T__56); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2062; + State = 2072; Match(T__57); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2063; + State = 2073; Match(T__148); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2064; + State = 2074; Match(T__149); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2065; + State = 2075; Match(CDECL); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2066; + State = 2076; Match(STDCALL); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2067; + State = 2077; Match(THISCALL); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2068; + State = 2078; Match(FASTCALL); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2069; + State = 2079; Match(T__150); - State = 2070; + State = 2080; Match(T__74); - State = 2071; + State = 2081; Match(T__151); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2072; + State = 2082; Match(T__150); - State = 2073; + State = 2083; Match(T__74); - State = 2074; + State = 2084; Match(T__152); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2075; + State = 2085; Match(T__153); - State = 2076; + State = 2086; Match(T__74); - State = 2077; + State = 2087; Match(T__151); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2078; + State = 2088; Match(T__153); - State = 2079; + State = 2089; Match(T__74); - State = 2080; + State = 2090; Match(T__152); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2081; + State = 2091; Match(T__69); - State = 2082; + State = 2092; Match(T__29); - State = 2083; + State = 2093; int32(); - State = 2084; + State = 2094; Match(T__30); } break; @@ -11897,20 +11912,20 @@ public MethodNameContext methodName() { MethodNameContext _localctx = new MethodNameContext(Context, State); EnterRule(_localctx, 242, RULE_methodName); try { - State = 2091; + State = 2101; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__115: EnterOuterAlt(_localctx, 1); { - State = 2088; + State = 2098; Match(T__115); } break; case T__154: EnterOuterAlt(_localctx, 2); { - State = 2089; + State = 2099; Match(T__154); } break; @@ -11922,7 +11937,7 @@ public MethodNameContext methodName() { case ID: EnterOuterAlt(_localctx, 3); { - State = 2090; + State = 2100; dottedName(); } break; @@ -11964,131 +11979,131 @@ public ImplAttrContext implAttr() { ImplAttrContext _localctx = new ImplAttrContext(Context, State); EnterRule(_localctx, 244, RULE_implAttr); try { - State = 2114; + State = 2124; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: EnterOuterAlt(_localctx, 1); { - State = 2093; + State = 2103; Match(T__0); } break; case T__1: EnterOuterAlt(_localctx, 2); { - State = 2094; + State = 2104; Match(T__1); } break; case T__155: EnterOuterAlt(_localctx, 3); { - State = 2095; + State = 2105; Match(T__155); } break; case T__2: EnterOuterAlt(_localctx, 4); { - State = 2096; + State = 2106; Match(T__2); } break; case T__3: EnterOuterAlt(_localctx, 5); { - State = 2097; + State = 2107; Match(T__3); } break; case UNMANAGED: EnterOuterAlt(_localctx, 6); { - State = 2098; + State = 2108; Match(UNMANAGED); } break; case T__4: EnterOuterAlt(_localctx, 7); { - State = 2099; + State = 2109; Match(T__4); } break; case T__5: EnterOuterAlt(_localctx, 8); { - State = 2100; + State = 2110; Match(T__5); } break; case T__6: EnterOuterAlt(_localctx, 9); { - State = 2101; + State = 2111; Match(T__6); } break; case T__7: EnterOuterAlt(_localctx, 10); { - State = 2102; + State = 2112; Match(T__7); } break; case T__8: EnterOuterAlt(_localctx, 11); { - State = 2103; + State = 2113; Match(T__8); } break; case T__9: EnterOuterAlt(_localctx, 12); { - State = 2104; + State = 2114; Match(T__9); } break; case T__10: EnterOuterAlt(_localctx, 13); { - State = 2105; + State = 2115; Match(T__10); } break; case T__11: EnterOuterAlt(_localctx, 14); { - State = 2106; + State = 2116; Match(T__11); } break; case T__12: EnterOuterAlt(_localctx, 15); { - State = 2107; + State = 2117; Match(T__12); } break; case T__13: EnterOuterAlt(_localctx, 16); { - State = 2108; + State = 2118; Match(T__13); } break; case T__69: EnterOuterAlt(_localctx, 17); { - State = 2109; + State = 2119; Match(T__69); - State = 2110; + State = 2120; Match(T__29); - State = 2111; + State = 2121; int32(); - State = 2112; + State = 2122; Match(T__30); } break; @@ -12136,17 +12151,17 @@ public MethodDeclsContext methodDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2119; + State = 2129; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38789119998L) != 0) || _la==T__72 || _la==T__73 || ((((_la - 158)) & ~0x3f) == 0 && ((1L << (_la - 158)) & 2199023255681L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 2303696760354115601L) != 0)) { { { - State = 2116; + State = 2126; methodDecl(); } } - State = 2121; + State = 2131; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -12206,7 +12221,7 @@ public MethodDeclContext methodDecl() { MethodDeclContext _localctx = new MethodDeclContext(Context, State); EnterRule(_localctx, 248, RULE_methodDecl); try { - State = 2139; + State = 2149; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case INSTR_NONE: @@ -12224,16 +12239,16 @@ public MethodDeclContext methodDecl() { case INSTR_TOK: EnterOuterAlt(_localctx, 1); { - State = 2122; + State = 2132; instr(); } break; case EMITBYTE: EnterOuterAlt(_localctx, 2); { - State = 2123; + State = 2133; Match(EMITBYTE); - State = 2124; + State = 2134; _localctx.value = int32(); Actions.EmitByte((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -12241,16 +12256,16 @@ public MethodDeclContext methodDecl() { case T__157: EnterOuterAlt(_localctx, 3); { - State = 2127; + State = 2137; sehBlock(); } break; case MAXSTACK: EnterOuterAlt(_localctx, 4); { - State = 2128; + State = 2138; Match(MAXSTACK); - State = 2129; + State = 2139; _localctx.value = int32(); Actions.SetMaxStack((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -12258,7 +12273,7 @@ public MethodDeclContext methodDecl() { case ENTRYPOINT: EnterOuterAlt(_localctx, 5); { - State = 2132; + State = 2142; Match(ENTRYPOINT); Actions.SetEntryPoint(); } @@ -12266,7 +12281,7 @@ public MethodDeclContext methodDecl() { case ZEROINIT: EnterOuterAlt(_localctx, 6); { - State = 2134; + State = 2144; Match(ZEROINIT); Actions.SetZeroInit(); } @@ -12293,14 +12308,14 @@ public MethodDeclContext methodDecl() { case ID: EnterOuterAlt(_localctx, 7); { - State = 2136; + State = 2146; labelDecl(); } break; case T__16: EnterOuterAlt(_localctx, 8); { - State = 2137; + State = 2147; scopeBlock(); } break; @@ -12326,7 +12341,7 @@ public MethodDeclContext methodDecl() { case VTENTRY: EnterOuterAlt(_localctx, 9); { - State = 2138; + State = 2148; methodDeclIsland(); } break; @@ -12432,302 +12447,302 @@ public MethodDeclIslandContext methodDeclIsland() { BeginSubtree(); try { int _alt; - State = 2239; + State = 2249; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,130,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,129,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2141; + State = 2151; Match(LOCALS); - State = 2142; + State = 2152; sigArgs(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2143; + State = 2153; Match(LOCALS); - State = 2144; + State = 2154; Match(T__156); - State = 2145; + State = 2155; sigArgs(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2146; + State = 2156; dataDecl(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2147; + State = 2157; secDecl(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2148; + State = 2158; extSourceSpec(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2149; + State = 2159; languageDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2150; + State = 2160; customDescrInMethodBody(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2151; + State = 2161; compControl(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2152; + State = 2162; Match(EXPORT); - State = 2153; + State = 2163; Match(T__41); - State = 2154; + State = 2164; int32(); - State = 2155; + State = 2165; Match(T__42); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2157; + State = 2167; Match(EXPORT); - State = 2158; + State = 2168; Match(T__41); - State = 2159; + State = 2169; int32(); - State = 2160; + State = 2170; Match(T__42); - State = 2161; + State = 2171; Match(T__33); - State = 2162; + State = 2172; id(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2164; + State = 2174; Match(VTENTRY); - State = 2165; + State = 2175; int32(); - State = 2166; + State = 2176; Match(T__74); - State = 2167; + State = 2177; int32(); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2169; + State = 2179; Match(OVERRIDE); - State = 2170; + State = 2180; typeSpec(); - State = 2171; + State = 2181; Match(DCOLON); - State = 2172; + State = 2182; methodName(); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2174; + State = 2184; Match(OVERRIDE); - State = 2175; + State = 2185; Match(METHOD); - State = 2176; + State = 2186; callConv(); - State = 2177; + State = 2187; type(); - State = 2178; + State = 2188; typeSpec(); - State = 2179; + State = 2189; Match(DCOLON); - State = 2180; + State = 2190; methodName(); - State = 2181; + State = 2191; genArity(); - State = 2182; + State = 2192; sigArgs(); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2184; + State = 2194; Match(PARAM); - State = 2185; + State = 2195; Match(TYPE); - State = 2186; + State = 2196; Match(T__41); - State = 2187; + State = 2197; int32(); - State = 2188; + State = 2198; Match(T__42); - State = 2192; + State = 2202; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,125,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,124,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2189; + State = 2199; customAttrDecl(); } } } - State = 2194; + State = 2204; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,125,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,124,Context); } } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2195; + State = 2205; Match(PARAM); - State = 2196; + State = 2206; Match(TYPE); - State = 2197; + State = 2207; dottedName(); - State = 2201; + State = 2211; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,126,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,125,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2198; + State = 2208; customAttrDecl(); } } } - State = 2203; + State = 2213; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,126,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,125,Context); } } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 2204; + State = 2214; Match(PARAM); - State = 2205; + State = 2215; Match(CONSTRAINT); - State = 2206; + State = 2216; Match(T__41); - State = 2207; + State = 2217; int32(); - State = 2208; + State = 2218; Match(T__42); - State = 2209; + State = 2219; Match(T__27); - State = 2210; + State = 2220; typeSpec(); - State = 2214; + State = 2224; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,127,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,126,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2211; + State = 2221; customAttrDecl(); } } } - State = 2216; + State = 2226; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,127,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,126,Context); } } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 2217; + State = 2227; Match(PARAM); - State = 2218; + State = 2228; Match(CONSTRAINT); - State = 2219; + State = 2229; dottedName(); - State = 2220; + State = 2230; Match(T__27); - State = 2221; + State = 2231; typeSpec(); - State = 2225; + State = 2235; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,128,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,127,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2222; + State = 2232; customAttrDecl(); } } } - State = 2227; + State = 2237; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,128,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,127,Context); } } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 2228; + State = 2238; Match(PARAM); - State = 2229; + State = 2239; Match(T__41); - State = 2230; + State = 2240; int32(); - State = 2231; + State = 2241; Match(T__42); - State = 2232; + State = 2242; initOpt(); - State = 2236; + State = 2246; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,129,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,128,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2233; + State = 2243; customAttrDecl(); } } } - State = 2238; + State = 2248; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,129,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,128,Context); } } break; @@ -12772,9 +12787,9 @@ public LabelDeclContext labelDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2241; + State = 2251; _localctx.name = id(); - State = 2242; + State = 2252; Match(T__74); Actions.DefineLabel((_localctx.name!=null?(_localctx.name.Start):null)); } @@ -12815,20 +12830,20 @@ public CustomDescrInMethodBodyContext customDescrInMethodBody() { CustomDescrInMethodBodyContext _localctx = new CustomDescrInMethodBodyContext(Context, State); EnterRule(_localctx, 254, RULE_customDescrInMethodBody); try { - State = 2247; + State = 2257; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,131,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,130,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2245; + State = 2255; customDescr(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2246; + State = 2256; customDescrWithOwner(); } break; @@ -12870,11 +12885,11 @@ public ScopeBlockContext scopeBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 2249; + State = 2259; Match(T__16); - State = 2250; + State = 2260; methodDecls(); - State = 2251; + State = 2261; Match(T__17); } } @@ -12918,9 +12933,9 @@ public SehBlockContext sehBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 2253; + State = 2263; tryBlock(); - State = 2254; + State = 2264; sehClauses(); } Context.Stop = TokenStream.LT(-1); @@ -12966,17 +12981,17 @@ public SehClausesContext sehClauses() { try { EnterOuterAlt(_localctx, 1); { - State = 2257; + State = 2267; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2256; + State = 2266; sehClause(); } } - State = 2259; + State = 2269; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( ((((_la - 160)) & ~0x3f) == 0 && ((1L << (_la - 160)) & 15L) != 0) ); @@ -13027,41 +13042,41 @@ public TryBlockContext tryBlock() { TryBlockContext _localctx = new TryBlockContext(Context, State); EnterRule(_localctx, 262, RULE_tryBlock); try { - State = 2273; + State = 2283; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,133,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,132,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2261; + State = 2271; Match(T__157); - State = 2262; + State = 2272; scopeBlock(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2263; + State = 2273; Match(T__157); - State = 2264; + State = 2274; id(); - State = 2265; + State = 2275; Match(T__158); - State = 2266; + State = 2276; id(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2268; + State = 2278; Match(T__157); - State = 2269; + State = 2279; int32(); - State = 2270; + State = 2280; Match(T__158); - State = 2271; + State = 2281; int32(); } break; @@ -13112,42 +13127,42 @@ public SehClauseContext sehClause() { SehClauseContext _localctx = new SehClauseContext(Context, State); EnterRule(_localctx, 264, RULE_sehClause); try { - State = 2287; + State = 2297; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__160: EnterOuterAlt(_localctx, 1); { - State = 2275; + State = 2285; catchClause(); - State = 2276; + State = 2286; handlerBlock(); } break; case T__159: EnterOuterAlt(_localctx, 2); { - State = 2278; + State = 2288; filterClause(); - State = 2279; + State = 2289; handlerBlock(); } break; case T__161: EnterOuterAlt(_localctx, 3); { - State = 2281; + State = 2291; finallyClause(); - State = 2282; + State = 2292; handlerBlock(); } break; case T__162: EnterOuterAlt(_localctx, 4); { - State = 2284; + State = 2294; faultClause(); - State = 2285; + State = 2295; handlerBlock(); } break; @@ -13194,33 +13209,33 @@ public FilterClauseContext filterClause() { FilterClauseContext _localctx = new FilterClauseContext(Context, State); EnterRule(_localctx, 266, RULE_filterClause); try { - State = 2295; + State = 2305; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,135,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,134,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2289; + State = 2299; Match(T__159); - State = 2290; + State = 2300; scopeBlock(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2291; + State = 2301; Match(T__159); - State = 2292; + State = 2302; id(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2293; + State = 2303; Match(T__159); - State = 2294; + State = 2304; int32(); } break; @@ -13261,9 +13276,9 @@ public CatchClauseContext catchClause() { try { EnterOuterAlt(_localctx, 1); { - State = 2297; + State = 2307; Match(T__160); - State = 2298; + State = 2308; typeSpec(); } Context.Stop = TokenStream.LT(-1); @@ -13301,7 +13316,7 @@ public FinallyClauseContext finallyClause() { try { EnterOuterAlt(_localctx, 1); { - State = 2300; + State = 2310; Match(T__161); } } @@ -13337,7 +13352,7 @@ public FaultClauseContext faultClause() { try { EnterOuterAlt(_localctx, 1); { - State = 2302; + State = 2312; Match(T__162); } } @@ -13386,39 +13401,39 @@ public HandlerBlockContext handlerBlock() { HandlerBlockContext _localctx = new HandlerBlockContext(Context, State); EnterRule(_localctx, 274, RULE_handlerBlock); try { - State = 2315; + State = 2325; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,136,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,135,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2304; + State = 2314; scopeBlock(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2305; + State = 2315; Match(T__163); - State = 2306; + State = 2316; id(); - State = 2307; + State = 2317; Match(T__158); - State = 2308; + State = 2318; id(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2310; + State = 2320; Match(T__163); - State = 2311; + State = 2321; int32(); - State = 2312; + State = 2322; Match(T__158); - State = 2313; + State = 2323; int32(); } break; @@ -13462,9 +13477,9 @@ public DataDeclContext dataDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2317; + State = 2327; ddHead(); - State = 2318; + State = 2328; ddBody(); } } @@ -13504,28 +13519,28 @@ public DdHeadContext ddHead() { DdHeadContext _localctx = new DdHeadContext(Context, State); EnterRule(_localctx, 278, RULE_ddHead); try { - State = 2327; + State = 2337; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,137,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,136,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2320; + State = 2330; Match(T__164); - State = 2321; + State = 2331; tls(); - State = 2322; + State = 2332; id(); - State = 2323; + State = 2333; Match(T__35); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2325; + State = 2335; Match(T__164); - State = 2326; + State = 2336; tls(); } break; @@ -13561,9 +13576,9 @@ public TlsContext tls() { TlsContext _localctx = new TlsContext(Context, State); EnterRule(_localctx, 280, RULE_tls); try { - State = 2332; + State = 2342; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,138,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,137,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -13572,14 +13587,14 @@ public TlsContext tls() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2330; + State = 2340; Match(T__165); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2331; + State = 2341; Match(T__1); } break; @@ -13625,17 +13640,17 @@ public DdBodyContext ddBody() { EnterRule(_localctx, 282, RULE_ddBody); int _la; try { - State = 2343; + State = 2353; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: EnterOuterAlt(_localctx, 1); { - State = 2334; + State = 2344; Match(T__16); - State = 2335; + State = 2345; ddItemList(); - State = 2336; + State = 2346; Match(T__17); } break; @@ -13650,17 +13665,17 @@ public DdBodyContext ddBody() { case REF: EnterOuterAlt(_localctx, 2); { - State = 2339; + State = 2349; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2338; + State = 2348; ddItem(); } } - State = 2341; + State = 2351; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( _la==T__83 || ((((_la - 181)) & ~0x3f) == 0 && ((1L << (_la - 181)) & 505L) != 0) || _la==REF ); @@ -13709,25 +13724,25 @@ public DdItemListContext ddItemList() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 2350; + State = 2360; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,141,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,140,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2345; + State = 2355; ddItem(); - State = 2346; + State = 2356; Match(T__27); } } } - State = 2352; + State = 2362; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,141,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,140,Context); } - State = 2353; + State = 2363; ddItem(); } } @@ -13764,7 +13779,7 @@ public DdItemCountContext ddItemCount() { DdItemCountContext _localctx = new DdItemCountContext(Context, State); EnterRule(_localctx, 286, RULE_ddItemCount); try { - State = 2360; + State = 2370; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -13868,11 +13883,11 @@ public DdItemCountContext ddItemCount() { case T__41: EnterOuterAlt(_localctx, 2); { - State = 2356; + State = 2366; Match(T__41); - State = 2357; + State = 2367; int32(); - State = 2358; + State = 2368; Match(T__42); } break; @@ -13940,200 +13955,200 @@ public DdItemContext ddItem() { DdItemContext _localctx = new DdItemContext(Context, State); EnterRule(_localctx, 288, RULE_ddItem); try { - State = 2428; + State = 2438; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,143,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,142,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2362; + State = 2372; Match(CHAR); - State = 2363; + State = 2373; Match(PTR); - State = 2364; + State = 2374; Match(T__29); - State = 2365; + State = 2375; compQstring(); - State = 2366; + State = 2376; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2368; + State = 2378; Match(REF); - State = 2369; + State = 2379; Match(T__29); - State = 2370; + State = 2380; id(); - State = 2371; + State = 2381; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2373; + State = 2383; Match(REF); - State = 2374; + State = 2384; id(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2375; + State = 2385; Match(T__83); - State = 2376; + State = 2386; Match(T__29); - State = 2377; + State = 2387; bytes(); - State = 2378; + State = 2388; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2380; + State = 2390; Match(FLOAT32); - State = 2381; + State = 2391; Match(T__29); - State = 2382; + State = 2392; float64(); - State = 2383; + State = 2393; Match(T__30); - State = 2384; + State = 2394; ddItemCount(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2386; + State = 2396; Match(FLOAT64_); - State = 2387; + State = 2397; Match(T__29); - State = 2388; + State = 2398; float64(); - State = 2389; + State = 2399; Match(T__30); - State = 2390; + State = 2400; ddItemCount(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2392; + State = 2402; Match(INT64_); - State = 2393; + State = 2403; Match(T__29); - State = 2394; + State = 2404; int64(); - State = 2395; + State = 2405; Match(T__30); - State = 2396; + State = 2406; ddItemCount(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2398; + State = 2408; Match(INT32_); - State = 2399; + State = 2409; Match(T__29); - State = 2400; + State = 2410; int32(); - State = 2401; + State = 2411; Match(T__30); - State = 2402; + State = 2412; ddItemCount(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2404; + State = 2414; Match(INT16); - State = 2405; + State = 2415; Match(T__29); - State = 2406; + State = 2416; int32(); - State = 2407; + State = 2417; Match(T__30); - State = 2408; + State = 2418; ddItemCount(); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2410; + State = 2420; Match(INT8); - State = 2411; + State = 2421; Match(T__29); - State = 2412; + State = 2422; int32(); - State = 2413; + State = 2423; Match(T__30); - State = 2414; + State = 2424; ddItemCount(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2416; + State = 2426; Match(FLOAT32); - State = 2417; + State = 2427; ddItemCount(); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2418; + State = 2428; Match(FLOAT64_); - State = 2419; + State = 2429; ddItemCount(); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2420; + State = 2430; Match(INT64_); - State = 2421; + State = 2431; ddItemCount(); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2422; + State = 2432; Match(INT32_); - State = 2423; + State = 2433; ddItemCount(); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2424; + State = 2434; Match(INT16); - State = 2425; + State = 2435; ddItemCount(); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 2426; + State = 2436; Match(INT8); - State = 2427; + State = 2437; ddItemCount(); } break; @@ -14196,201 +14211,201 @@ public FieldSerInitContext fieldSerInit() { FieldSerInitContext _localctx = new FieldSerInitContext(Context, State); EnterRule(_localctx, 290, RULE_fieldSerInit); try { - State = 2505; + State = 2515; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,144,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,143,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2430; + State = 2440; Match(FLOAT32); - State = 2431; + State = 2441; Match(T__29); - State = 2432; + State = 2442; float64(); - State = 2433; + State = 2443; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2435; + State = 2445; Match(FLOAT64_); - State = 2436; + State = 2446; Match(T__29); - State = 2437; + State = 2447; float64(); - State = 2438; + State = 2448; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2440; + State = 2450; Match(FLOAT32); - State = 2441; + State = 2451; Match(T__29); - State = 2442; + State = 2452; int32(); - State = 2443; + State = 2453; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2445; + State = 2455; Match(FLOAT64_); - State = 2446; + State = 2456; Match(T__29); - State = 2447; + State = 2457; int64(); - State = 2448; + State = 2458; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2450; + State = 2460; Match(INT64_); - State = 2451; + State = 2461; Match(T__29); - State = 2452; + State = 2462; int64(); - State = 2453; + State = 2463; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2455; + State = 2465; Match(INT32_); - State = 2456; + State = 2466; Match(T__29); - State = 2457; + State = 2467; int32(); - State = 2458; + State = 2468; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2460; + State = 2470; Match(INT16); - State = 2461; + State = 2471; Match(T__29); - State = 2462; + State = 2472; int32(); - State = 2463; + State = 2473; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2465; + State = 2475; Match(INT8); - State = 2466; + State = 2476; Match(T__29); - State = 2467; + State = 2477; int32(); - State = 2468; + State = 2478; Match(T__30); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2470; + State = 2480; Match(UINT64); - State = 2471; + State = 2481; Match(T__29); - State = 2472; + State = 2482; int64(); - State = 2473; + State = 2483; Match(T__30); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2475; + State = 2485; Match(UINT32); - State = 2476; + State = 2486; Match(T__29); - State = 2477; + State = 2487; int32(); - State = 2478; + State = 2488; Match(T__30); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2480; + State = 2490; Match(UINT16); - State = 2481; + State = 2491; Match(T__29); - State = 2482; + State = 2492; int32(); - State = 2483; + State = 2493; Match(T__30); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2485; + State = 2495; Match(UINT8); - State = 2486; + State = 2496; Match(T__29); - State = 2487; + State = 2497; int32(); - State = 2488; + State = 2498; Match(T__30); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2490; + State = 2500; Match(CHAR); - State = 2491; + State = 2501; Match(T__29); - State = 2492; + State = 2502; int32(); - State = 2493; + State = 2503; Match(T__30); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2495; + State = 2505; Match(BOOL); - State = 2496; + State = 2506; Match(T__29); - State = 2497; + State = 2507; truefalse(); - State = 2498; + State = 2508; Match(T__30); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2500; + State = 2510; Match(T__83); - State = 2501; + State = 2511; Match(T__29); - State = 2502; + State = 2512; bytes(); - State = 2503; + State = 2513; Match(T__30); } break; @@ -14438,18 +14453,18 @@ public BytesContext bytes() { try { EnterOuterAlt(_localctx, 1); { - State = 2512; + State = 2522; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32 || _la==ID || _la==HEXBYTE) { { { - State = 2507; + State = 2517; _localctx.b = hexbyte(); Actions.AddByte(_localctx.b.Value); } } - State = 2514; + State = 2524; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -14493,7 +14508,7 @@ public HexbyteContext hexbyte() { try { EnterOuterAlt(_localctx, 1); { - State = 2515; + State = 2525; _la = TokenStream.LA(1); if ( !(_la==INT32 || _la==ID || _la==HEXBYTE) ) { ErrorHandler.RecoverInline(this); @@ -14543,7 +14558,7 @@ public FieldInitContext fieldInit() { FieldInitContext _localctx = new FieldInitContext(Context, State); EnterRule(_localctx, 296, RULE_fieldInit); try { - State = 2520; + State = 2530; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__83: @@ -14561,21 +14576,21 @@ public FieldInitContext fieldInit() { case UINT64: EnterOuterAlt(_localctx, 1); { - State = 2517; + State = 2527; fieldSerInit(); } break; case QSTRING: EnterOuterAlt(_localctx, 2); { - State = 2518; + State = 2528; compQstring(); } break; case NULLREF: EnterOuterAlt(_localctx, 3); { - State = 2519; + State = 2529; Match(NULLREF); } break; @@ -14672,378 +14687,378 @@ public SerInitContext serInit() { SerInitContext _localctx = new SerInitContext(Context, State); EnterRule(_localctx, 298, RULE_serInit); try { - State = 2670; + State = 2680; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,147,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,146,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2522; + State = 2532; fieldSerInit(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2523; + State = 2533; Match(STRING); - State = 2524; + State = 2534; Match(T__29); - State = 2525; + State = 2535; Match(NULLREF); - State = 2526; + State = 2536; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2527; + State = 2537; Match(STRING); - State = 2528; + State = 2538; Match(T__29); - State = 2529; + State = 2539; Match(SQSTRING); - State = 2530; + State = 2540; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2531; + State = 2541; Match(TYPE); - State = 2532; + State = 2542; Match(T__29); - State = 2533; + State = 2543; Match(T__38); - State = 2534; + State = 2544; Match(SQSTRING); - State = 2535; + State = 2545; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2536; + State = 2546; Match(TYPE); - State = 2537; + State = 2547; Match(T__29); - State = 2538; + State = 2548; className(); - State = 2539; + State = 2549; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2541; + State = 2551; Match(TYPE); - State = 2542; + State = 2552; Match(T__29); - State = 2543; + State = 2553; Match(NULLREF); - State = 2544; + State = 2554; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2545; + State = 2555; Match(OBJECT); - State = 2546; + State = 2556; Match(T__29); - State = 2547; + State = 2557; serInit(); - State = 2548; + State = 2558; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2550; + State = 2560; Match(FLOAT32); - State = 2551; + State = 2561; Match(T__41); - State = 2552; + State = 2562; int32(); - State = 2553; + State = 2563; Match(T__42); - State = 2554; + State = 2564; Match(T__29); - State = 2555; + State = 2565; f32seq(); - State = 2556; + State = 2566; Match(T__30); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2558; + State = 2568; Match(FLOAT64_); - State = 2559; + State = 2569; Match(T__41); - State = 2560; + State = 2570; int32(); - State = 2561; + State = 2571; Match(T__42); - State = 2562; + State = 2572; Match(T__29); - State = 2563; + State = 2573; f64seq(); - State = 2564; + State = 2574; Match(T__30); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2566; + State = 2576; Match(INT64_); - State = 2567; + State = 2577; Match(T__41); - State = 2568; + State = 2578; int32(); - State = 2569; + State = 2579; Match(T__42); - State = 2570; + State = 2580; Match(T__29); - State = 2571; + State = 2581; i64seq(); - State = 2572; + State = 2582; Match(T__30); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2574; + State = 2584; Match(INT32_); - State = 2575; + State = 2585; Match(T__41); - State = 2576; + State = 2586; int32(); - State = 2577; + State = 2587; Match(T__42); - State = 2578; + State = 2588; Match(T__29); - State = 2579; + State = 2589; i32seq(); - State = 2580; + State = 2590; Match(T__30); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2582; + State = 2592; Match(INT16); - State = 2583; + State = 2593; Match(T__41); - State = 2584; + State = 2594; int32(); - State = 2585; + State = 2595; Match(T__42); - State = 2586; + State = 2596; Match(T__29); - State = 2587; + State = 2597; i16seq(); - State = 2588; + State = 2598; Match(T__30); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2590; + State = 2600; Match(INT8); - State = 2591; + State = 2601; Match(T__41); - State = 2592; + State = 2602; int32(); - State = 2593; + State = 2603; Match(T__42); - State = 2594; + State = 2604; Match(T__29); - State = 2595; + State = 2605; i8seq(); - State = 2596; + State = 2606; Match(T__30); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2598; + State = 2608; Match(UINT64); - State = 2599; + State = 2609; Match(T__41); - State = 2600; + State = 2610; int32(); - State = 2601; + State = 2611; Match(T__42); - State = 2602; + State = 2612; Match(T__29); - State = 2603; + State = 2613; i64seq(); - State = 2604; + State = 2614; Match(T__30); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2606; + State = 2616; Match(UINT32); - State = 2607; + State = 2617; Match(T__41); - State = 2608; + State = 2618; int32(); - State = 2609; + State = 2619; Match(T__42); - State = 2610; + State = 2620; Match(T__29); - State = 2611; + State = 2621; i32seq(); - State = 2612; + State = 2622; Match(T__30); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 2614; + State = 2624; Match(UINT16); - State = 2615; + State = 2625; Match(T__41); - State = 2616; + State = 2626; int32(); - State = 2617; + State = 2627; Match(T__42); - State = 2618; + State = 2628; Match(T__29); - State = 2619; + State = 2629; i16seq(); - State = 2620; + State = 2630; Match(T__30); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 2622; + State = 2632; Match(UINT8); - State = 2623; + State = 2633; Match(T__41); - State = 2624; + State = 2634; int32(); - State = 2625; + State = 2635; Match(T__42); - State = 2626; + State = 2636; Match(T__29); - State = 2627; + State = 2637; i8seq(); - State = 2628; + State = 2638; Match(T__30); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 2630; + State = 2640; Match(CHAR); - State = 2631; + State = 2641; Match(T__41); - State = 2632; + State = 2642; int32(); - State = 2633; + State = 2643; Match(T__42); - State = 2634; + State = 2644; Match(T__29); - State = 2635; + State = 2645; i16seq(); - State = 2636; + State = 2646; Match(T__30); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 2638; + State = 2648; Match(BOOL); - State = 2639; + State = 2649; Match(T__41); - State = 2640; + State = 2650; int32(); - State = 2641; + State = 2651; Match(T__42); - State = 2642; + State = 2652; Match(T__29); - State = 2643; + State = 2653; boolSeq(); - State = 2644; + State = 2654; Match(T__30); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 2646; + State = 2656; Match(STRING); - State = 2647; + State = 2657; Match(T__41); - State = 2648; + State = 2658; int32(); - State = 2649; + State = 2659; Match(T__42); - State = 2650; + State = 2660; Match(T__29); - State = 2651; + State = 2661; sqstringSeq(); - State = 2652; + State = 2662; Match(T__30); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 2654; + State = 2664; Match(TYPE); - State = 2655; + State = 2665; Match(T__41); - State = 2656; + State = 2666; int32(); - State = 2657; + State = 2667; Match(T__42); - State = 2658; + State = 2668; Match(T__29); - State = 2659; + State = 2669; classSeq(); - State = 2660; + State = 2670; Match(T__30); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 2662; + State = 2672; Match(OBJECT); - State = 2663; + State = 2673; Match(T__41); - State = 2664; + State = 2674; int32(); - State = 2665; + State = 2675; Match(T__42); - State = 2666; + State = 2676; Match(T__29); - State = 2667; + State = 2677; objSeq(); - State = 2668; + State = 2678; Match(T__30); } break; @@ -15094,29 +15109,29 @@ public F32seqContext f32seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2676; + State = 2686; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 98309L) != 0)) { { - State = 2674; + State = 2684; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,148,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,147,Context) ) { case 1: { - State = 2672; + State = 2682; float64(); } break; case 2: { - State = 2673; + State = 2683; int32(); } break; } } - State = 2678; + State = 2688; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15167,29 +15182,29 @@ public F64seqContext f64seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2683; + State = 2693; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 98311L) != 0)) { { - State = 2681; + State = 2691; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,150,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,149,Context) ) { case 1: { - State = 2679; + State = 2689; float64(); } break; case 2: { - State = 2680; + State = 2690; int64(); } break; } } - State = 2685; + State = 2695; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15234,17 +15249,17 @@ public I64seqContext i64seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2689; + State = 2699; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32 || _la==INT64) { { { - State = 2686; + State = 2696; int64(); } } - State = 2691; + State = 2701; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15289,17 +15304,17 @@ public I32seqContext i32seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2695; + State = 2705; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 2692; + State = 2702; int32(); } } - State = 2697; + State = 2707; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15344,17 +15359,17 @@ public I16seqContext i16seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2701; + State = 2711; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 2698; + State = 2708; int32(); } } - State = 2703; + State = 2713; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15399,17 +15414,17 @@ public I8seqContext i8seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2707; + State = 2717; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 2704; + State = 2714; int32(); } } - State = 2709; + State = 2719; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15454,17 +15469,17 @@ public BoolSeqContext boolSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 2713; + State = 2723; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__94 || _la==T__95) { { { - State = 2710; + State = 2720; truefalse(); } } - State = 2715; + State = 2725; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15511,13 +15526,13 @@ public SqstringSeqContext sqstringSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 2719; + State = 2729; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==NULLREF || _la==SQSTRING) { { { - State = 2716; + State = 2726; _la = TokenStream.LA(1); if ( !(_la==NULLREF || _la==SQSTRING) ) { ErrorHandler.RecoverInline(this); @@ -15528,7 +15543,7 @@ public SqstringSeqContext sqstringSeq() { } } } - State = 2721; + State = 2731; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15573,17 +15588,17 @@ public ClassSeqContext classSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 2725; + State = 2735; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4947802390528L) != 0) || _la==T__112 || _la==NULLREF || _la==VALUE || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 105553118478337L) != 0)) { { { - State = 2722; + State = 2732; classSeqElement(); } } - State = 2727; + State = 2737; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15624,22 +15639,22 @@ public ClassSeqElementContext classSeqElement() { ClassSeqElementContext _localctx = new ClassSeqElementContext(Context, State); EnterRule(_localctx, 318, RULE_classSeqElement); try { - State = 2732; + State = 2742; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case NULLREF: EnterOuterAlt(_localctx, 1); { - State = 2728; + State = 2738; Match(NULLREF); } break; case T__38: EnterOuterAlt(_localctx, 2); { - State = 2729; + State = 2739; Match(T__38); - State = 2730; + State = 2740; Match(SQSTRING); } break; @@ -15656,7 +15671,7 @@ public ClassSeqElementContext classSeqElement() { case ID: EnterOuterAlt(_localctx, 3); { - State = 2731; + State = 2741; className(); } break; @@ -15703,17 +15718,17 @@ public ObjSeqContext objSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 2737; + State = 2747; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__83 || ((((_la - 181)) & ~0x3f) == 0 && ((1L << (_la - 181)) & 106495L) != 0)) { { { - State = 2734; + State = 2744; serInit(); } } - State = 2739; + State = 2749; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15758,27 +15773,27 @@ public CustomAttrDeclContext customAttrDecl() { CustomAttrDeclContext _localctx = new CustomAttrDeclContext(Context, State); EnterRule(_localctx, 322, RULE_customAttrDecl); try { - State = 2743; + State = 2753; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,161,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,160,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2740; + State = 2750; customDescr(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2741; + State = 2751; customDescrWithOwner(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2742; + State = 2752; dottedName(); } break; @@ -15833,13 +15848,13 @@ public AsmOrRefDeclContext asmOrRefDecl() { EnterRule(_localctx, 324, RULE_asmOrRefDecl); int _la; try { - State = 2770; + State = 2780; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,162,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,161,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2745; + State = 2755; _la = TokenStream.LA(1); if ( !(_la==T__166 || _la==T__167) ) { ErrorHandler.RecoverInline(this); @@ -15848,72 +15863,72 @@ public AsmOrRefDeclContext asmOrRefDecl() { ErrorHandler.ReportMatch(this); Consume(); } - State = 2746; + State = 2756; Match(T__35); - State = 2747; + State = 2757; Match(T__29); - State = 2748; + State = 2758; bytes(); - State = 2749; + State = 2759; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2751; + State = 2761; Match(T__168); - State = 2752; + State = 2762; intOrWildcard(); - State = 2753; + State = 2763; Match(T__74); - State = 2754; + State = 2764; intOrWildcard(); - State = 2755; + State = 2765; Match(T__74); - State = 2756; + State = 2766; intOrWildcard(); - State = 2757; + State = 2767; Match(T__74); - State = 2758; + State = 2768; intOrWildcard(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2760; + State = 2770; Match(T__169); - State = 2761; + State = 2771; compQstring(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2762; + State = 2772; Match(T__169); - State = 2763; + State = 2773; Match(T__35); - State = 2764; + State = 2774; Match(T__29); - State = 2765; + State = 2775; bytes(); - State = 2766; + State = 2776; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2768; + State = 2778; customAttrDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2769; + State = 2779; compControl(); } break; @@ -15958,36 +15973,36 @@ public AssemblyRefHeadContext assemblyRefHead() { AssemblyRefHeadContext _localctx = new AssemblyRefHeadContext(Context, State); EnterRule(_localctx, 326, RULE_assemblyRefHead); try { - State = 2784; + State = 2794; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,163,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,162,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2772; + State = 2782; Match(T__24); - State = 2773; + State = 2783; Match(T__39); - State = 2774; + State = 2784; asmAttr(); - State = 2775; + State = 2785; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2777; + State = 2787; Match(T__24); - State = 2778; + State = 2788; Match(T__39); - State = 2779; + State = 2789; asmAttr(); - State = 2780; + State = 2790; dottedName(); - State = 2781; + State = 2791; Match(T__33); - State = 2782; + State = 2792; dottedName(); } break; @@ -16032,17 +16047,17 @@ public AssemblyRefDeclsContext assemblyRefDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2789; + State = 2799; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 36028835673735168L) != 0) || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & 4294975519L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 105555249070081L) != 0)) { { { - State = 2786; + State = 2796; assemblyRefDecl(); } } - State = 2791; + State = 2801; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16085,21 +16100,21 @@ public AssemblyRefDeclContext assemblyRefDecl() { AssemblyRefDeclContext _localctx = new AssemblyRefDeclContext(Context, State); EnterRule(_localctx, 330, RULE_assemblyRefDecl); try { - State = 2806; + State = 2816; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case HASH: EnterOuterAlt(_localctx, 1); { - State = 2792; + State = 2802; Match(HASH); - State = 2793; + State = 2803; Match(T__35); - State = 2794; + State = 2804; Match(T__29); - State = 2795; + State = 2805; bytes(); - State = 2796; + State = 2806; Match(T__30); } break; @@ -16124,29 +16139,29 @@ public AssemblyRefDeclContext assemblyRefDecl() { case ID: EnterOuterAlt(_localctx, 2); { - State = 2798; + State = 2808; asmOrRefDecl(); } break; case T__170: EnterOuterAlt(_localctx, 3); { - State = 2799; + State = 2809; Match(T__170); - State = 2800; + State = 2810; Match(T__35); - State = 2801; + State = 2811; Match(T__29); - State = 2802; + State = 2812; bytes(); - State = 2803; + State = 2813; Match(T__30); } break; case T__54: EnterOuterAlt(_localctx, 4); { - State = 2805; + State = 2815; Match(T__54); } break; @@ -16196,25 +16211,25 @@ public ExptypeHeadContext exptypeHead() { try { EnterOuterAlt(_localctx, 1); { - State = 2808; + State = 2818; Match(T__49); - State = 2809; + State = 2819; Match(T__39); - State = 2813; + State = 2823; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4618441417868443648L) != 0) || _la==T__171) { { { - State = 2810; + State = 2820; exptAttr(); } } - State = 2815; + State = 2825; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2816; + State = 2826; dottedName(); } } @@ -16261,23 +16276,23 @@ public ExportHeadContext exportHead() { try { EnterOuterAlt(_localctx, 1); { - State = 2818; + State = 2828; Match(EXPORT); - State = 2822; + State = 2832; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4618441417868443648L) != 0) || _la==T__171) { { { - State = 2819; + State = 2829; exptAttr(); } } - State = 2824; + State = 2834; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2825; + State = 2835; dottedName(); } } @@ -16311,81 +16326,81 @@ public ExptAttrContext exptAttr() { ExptAttrContext _localctx = new ExptAttrContext(Context, State); EnterRule(_localctx, 336, RULE_exptAttr); try { - State = 2842; + State = 2852; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,168,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,167,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2827; + State = 2837; Match(T__51); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2828; + State = 2838; Match(T__50); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2829; + State = 2839; Match(T__171); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2830; + State = 2840; Match(T__61); - State = 2831; + State = 2841; Match(T__50); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2832; + State = 2842; Match(T__61); - State = 2833; + State = 2843; Match(T__51); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2834; + State = 2844; Match(T__61); - State = 2835; + State = 2845; Match(T__62); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2836; + State = 2846; Match(T__61); - State = 2837; + State = 2847; Match(T__63); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2838; + State = 2848; Match(T__61); - State = 2839; + State = 2849; Match(T__64); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2840; + State = 2850; Match(T__61); - State = 2841; + State = 2851; Match(T__65); } break; @@ -16430,17 +16445,17 @@ public ExptypeDeclsContext exptypeDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2847; + State = 2857; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1125938597265408L) != 0) || _la==T__112 || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 2844; + State = 2854; exptypeDecl(); } } - State = 2849; + State = 2859; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16494,67 +16509,67 @@ public ExptypeDeclContext exptypeDecl() { ExptypeDeclContext _localctx = new ExptypeDeclContext(Context, State); EnterRule(_localctx, 340, RULE_exptypeDecl); try { - State = 2863; + State = 2873; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,170,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,169,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2850; + State = 2860; Match(T__20); - State = 2851; + State = 2861; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2852; + State = 2862; Match(T__49); - State = 2853; + State = 2863; Match(T__39); - State = 2854; + State = 2864; slashedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2855; + State = 2865; Match(T__24); - State = 2856; + State = 2866; Match(T__39); - State = 2857; + State = 2867; dottedName(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2858; + State = 2868; mdtoken(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2859; + State = 2869; Match(T__49); - State = 2860; + State = 2870; int32(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2861; + State = 2871; customAttrDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2862; + State = 2872; compControl(); } break; @@ -16604,56 +16619,56 @@ public ManifestResHeadContext manifestResHead() { EnterRule(_localctx, 342, RULE_manifestResHead); int _la; try { - State = 2884; + State = 2894; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,173,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,172,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2865; + State = 2875; Match(MRESOURCE); - State = 2869; + State = 2879; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__50 || _la==T__51) { { { - State = 2866; + State = 2876; manresAttr(); } } - State = 2871; + State = 2881; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2872; + State = 2882; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2873; + State = 2883; Match(MRESOURCE); - State = 2877; + State = 2887; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__50 || _la==T__51) { { { - State = 2874; + State = 2884; manresAttr(); } } - State = 2879; + State = 2889; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2880; + State = 2890; dottedName(); - State = 2881; + State = 2891; Match(T__33); - State = 2882; + State = 2892; dottedName(); } break; @@ -16692,7 +16707,7 @@ public ManresAttrContext manresAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 2886; + State = 2896; _la = TokenStream.LA(1); if ( !(_la==T__50 || _la==T__51) ) { ErrorHandler.RecoverInline(this); @@ -16742,17 +16757,17 @@ public ManifestResDeclsContext manifestResDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2891; + State = 2901; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38690422784L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 2888; + State = 2898; manifestResDecl(); } } - State = 2893; + State = 2903; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16800,30 +16815,30 @@ public ManifestResDeclContext manifestResDecl() { ManifestResDeclContext _localctx = new ManifestResDeclContext(Context, State); EnterRule(_localctx, 348, RULE_manifestResDecl); try { - State = 2904; + State = 2914; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__20: EnterOuterAlt(_localctx, 1); { - State = 2894; + State = 2904; Match(T__20); - State = 2895; + State = 2905; dottedName(); - State = 2896; + State = 2906; Match(T__43); - State = 2897; + State = 2907; int32(); } break; case T__24: EnterOuterAlt(_localctx, 2); { - State = 2899; + State = 2909; Match(T__24); - State = 2900; + State = 2910; Match(T__39); - State = 2901; + State = 2911; dottedName(); } break; @@ -16836,7 +16851,7 @@ public ManifestResDeclContext manifestResDecl() { case ID: EnterOuterAlt(_localctx, 3); { - State = 2902; + State = 2912; customAttrDecl(); } break; @@ -16850,7 +16865,7 @@ public ManifestResDeclContext manifestResDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 4); { - State = 2903; + State = 2913; compControl(); } break; @@ -16887,7 +16902,7 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { } private static int[] _serializedATN = { - 4,1,305,2907,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, + 4,1,305,2917,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, @@ -16956,140 +16971,141 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 3,44,893,8,44,1,45,1,45,5,45,897,8,45,10,45,12,45,900,9,45,1,45,1,45,1, 45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,5,45,913,8,45,10,45,12,45,916, 9,45,1,45,1,45,1,45,3,45,921,8,45,1,46,1,46,1,47,1,47,3,47,927,8,47,1, - 48,1,48,1,49,5,49,932,8,49,10,49,12,49,935,9,49,1,50,1,50,3,50,939,8,50, + 48,1,48,1,49,5,49,932,8,49,10,49,12,49,935,9,49,1,50,1,50,1,50,1,50,1, + 50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1, + 50,1,50,1,50,1,50,1,50,1,50,1,50,3,50,962,8,50,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,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,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,1017,8,51,3,51,1019,8,51,1,52,1,52, - 1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,3,52, - 1036,8,52,1,53,1,53,1,53,1,53,1,53,1,53,1,53,3,53,1045,8,53,1,53,1,53, - 5,53,1049,8,53,10,53,12,53,1052,9,53,1,53,1,53,1,53,1,53,1,53,1,53,3,53, - 1060,8,53,3,53,1062,8,53,1,54,1,54,1,54,1,54,5,54,1068,8,54,10,54,12,54, - 1071,9,54,1,54,1,54,1,54,1,55,1,55,1,55,1,55,5,55,1080,8,55,10,55,12,55, - 1083,9,55,1,55,1,55,1,55,1,56,1,56,1,56,1,56,5,56,1092,8,56,10,56,12,56, - 1095,9,56,1,56,1,56,1,56,1,56,3,56,1101,8,56,1,57,1,57,1,57,1,57,1,57, - 3,57,1108,8,57,3,57,1110,8,57,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58, - 1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58, - 1,58,1,58,1,58,3,58,1137,8,58,1,59,1,59,1,59,5,59,1142,8,59,10,59,12,59, - 1145,9,59,1,59,1,59,1,60,5,60,1150,8,60,10,60,12,60,1153,9,60,1,61,1,61, - 1,61,1,61,1,61,3,61,1160,8,61,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62, - 1,62,1,62,1,62,3,62,1173,8,62,1,63,1,63,1,63,5,63,1178,8,63,10,63,12,63, - 1181,9,63,3,63,1183,8,63,1,64,1,64,1,64,1,64,1,64,1,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,1202,8,64,1,65,1,65,1,65, + 1,51,3,51,1040,8,51,3,51,1042,8,51,1,52,1,52,1,52,1,52,1,53,1,53,1,53, + 1,53,1,53,1,53,1,53,3,53,1055,8,53,1,53,1,53,5,53,1059,8,53,10,53,12,53, + 1062,9,53,1,53,1,53,1,53,1,53,1,53,1,53,3,53,1070,8,53,3,53,1072,8,53, + 1,54,1,54,1,54,1,54,5,54,1078,8,54,10,54,12,54,1081,9,54,1,54,1,54,1,54, + 1,55,1,55,1,55,1,55,5,55,1090,8,55,10,55,12,55,1093,9,55,1,55,1,55,1,55, + 1,56,1,56,1,56,1,56,5,56,1102,8,56,10,56,12,56,1105,9,56,1,56,1,56,1,56, + 1,56,3,56,1111,8,56,1,57,1,57,1,57,1,57,1,57,3,57,1118,8,57,3,57,1120, + 8,57,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58, + 1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,3,58,1147, + 8,58,1,59,1,59,1,59,5,59,1152,8,59,10,59,12,59,1155,9,59,1,59,1,59,1,60, + 5,60,1160,8,60,10,60,12,60,1163,9,60,1,61,1,61,1,61,1,61,1,61,3,61,1170, + 8,61,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,3,62,1183, + 8,62,1,63,1,63,1,63,5,63,1188,8,63,10,63,12,63,1191,9,63,3,63,1193,8,63, + 1,64,1,64,1,64,1,64,1,64,1,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,1212,8,64,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, - 1,65,1,65,1,65,1,65,1,65,3,65,1296,8,65,1,66,1,66,1,66,1,66,1,66,1,66, - 1,66,3,66,1305,8,66,1,67,1,67,1,67,5,67,1310,8,67,10,67,12,67,1313,9,67, - 3,67,1315,8,67,1,68,1,68,1,69,1,69,5,69,1321,8,69,10,69,12,69,1324,9,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,1,70,1,70,1,70,3,70,1344,8,70,1,71,1,71,1,71,1,71,1,71,1,71,1,71, + 3,65,1306,8,65,1,66,1,66,1,66,1,66,1,66,1,66,1,66,3,66,1315,8,66,1,67, + 1,67,1,67,5,67,1320,8,67,10,67,12,67,1323,9,67,3,67,1325,8,67,1,68,1,68, + 1,69,1,69,5,69,1331,8,69,10,69,12,69,1334,9,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,1,70,1,70,1,70,3,70, + 1354,8,70,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, - 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,3,71,1376,8,71,1,72,1,72, + 1,71,1,71,1,71,1,71,3,71,1386,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,1,72,1,72,1,72,1,72,1,72,1,72, - 1,72,1,72,1,72,1,72,1,72,3,72,1399,8,72,1,73,1,73,1,73,1,73,1,73,1,73, - 1,73,1,73,1,73,1,73,3,73,1411,8,73,1,74,1,74,1,74,1,75,1,75,1,75,1,75, - 3,75,1420,8,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,3,76,1445, - 8,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,1469,8,76,1,77,1,77, - 1,77,1,77,5,77,1475,8,77,10,77,12,77,1478,9,77,1,77,3,77,1481,8,77,1,78, - 1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,3,78,1496, - 8,78,1,79,1,79,1,79,5,79,1501,8,79,10,79,12,79,1504,9,79,1,79,1,79,1,80, - 1,80,1,80,1,80,1,81,1,81,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, + 3,72,1409,8,72,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,3,73, + 1421,8,73,1,74,1,74,1,74,1,75,1,75,1,75,1,75,3,75,1430,8,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,3,76,1455,8,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,1479,8,76,1,77,1,77,1,77,1,77,5,77,1485,8,77, + 10,77,12,77,1488,9,77,1,77,3,77,1491,8,77,1,78,1,78,1,78,1,78,1,78,1,78, + 1,78,1,78,1,78,1,78,1,78,1,78,1,78,3,78,1506,8,78,1,79,1,79,1,79,5,79, + 1511,8,79,10,79,12,79,1514,9,79,1,79,1,79,1,80,1,80,1,80,1,80,1,81,1,81, + 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, - 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,3,82,1548,8,82, - 1,83,1,83,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1558,8,84,1,84,1,84,1,84, - 1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1574,8,84, - 1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1586,8,84,1,85, - 1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,3,85,1598,8,85,1,86,1,86, - 1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,3,86,1612,8,86,1,87, - 1,87,1,87,1,87,1,87,1,88,1,88,1,88,1,88,1,88,3,88,1624,8,88,1,89,1,89, - 1,89,1,89,1,89,1,89,1,89,1,89,1,89,3,89,1635,8,89,1,90,1,90,1,90,5,90, - 1640,8,90,10,90,12,90,1643,9,90,1,90,1,90,1,91,1,91,1,91,1,91,1,91,3,91, - 1652,8,91,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,3,92, - 1665,8,92,1,93,5,93,1668,8,93,10,93,12,93,1671,9,93,1,94,1,94,3,94,1675, - 8,94,1,94,1,94,1,95,1,95,1,95,5,95,1682,8,95,10,95,12,95,1685,9,95,1,95, - 1,95,1,96,1,96,1,96,1,96,1,97,1,97,3,97,1695,8,97,1,98,1,98,1,98,1,98, - 1,98,1,98,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, + 1,82,1,82,1,82,1,82,1,82,1,82,3,82,1558,8,82,1,83,1,83,1,84,1,84,1,84, + 1,84,1,84,1,84,3,84,1568,8,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84, + 1,84,1,84,1,84,1,84,1,84,1,84,3,84,1584,8,84,1,84,1,84,1,84,1,84,1,84, + 1,84,1,84,1,84,1,84,1,84,3,84,1596,8,84,1,85,1,85,1,85,1,85,1,85,1,85, + 1,85,1,85,1,85,1,85,3,85,1608,8,85,1,86,1,86,1,86,1,86,1,86,1,86,1,86, + 1,86,1,86,1,86,1,86,1,86,3,86,1622,8,86,1,87,1,87,1,87,1,87,1,87,1,88, + 1,88,1,88,1,88,1,88,3,88,1634,8,88,1,89,1,89,1,89,1,89,1,89,1,89,1,89, + 1,89,1,89,3,89,1645,8,89,1,90,1,90,1,90,5,90,1650,8,90,10,90,12,90,1653, + 9,90,1,90,1,90,1,91,1,91,1,91,1,91,1,91,3,91,1662,8,91,1,92,1,92,1,92, + 1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,3,92,1675,8,92,1,93,5,93,1678, + 8,93,10,93,12,93,1681,9,93,1,94,1,94,3,94,1685,8,94,1,94,1,94,1,95,1,95, + 1,95,5,95,1692,8,95,10,95,12,95,1695,9,95,1,95,1,95,1,96,1,96,1,96,1,96, + 1,97,1,97,3,97,1705,8,97,1,98,1,98,1,98,1,98,1,98,1,98,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, - 1,99,1,99,1,99,1,99,1,99,5,99,1776,8,99,10,99,12,99,1779,9,99,1,99,1,99, - 1,99,1,99,5,99,1785,8,99,10,99,12,99,1788,9,99,1,99,1,99,1,99,1,99,1,99, - 1,99,1,99,1,99,5,99,1798,8,99,10,99,12,99,1801,9,99,1,99,1,99,1,99,1,99, - 1,99,1,99,5,99,1809,8,99,10,99,12,99,1812,9,99,1,99,1,99,1,99,1,99,1,99, - 3,99,1819,8,99,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,5,100,1829, - 8,100,10,100,12,100,1832,9,100,1,100,1,100,1,100,1,100,1,100,1,101,1,101, + 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, + 5,99,1786,8,99,10,99,12,99,1789,9,99,1,99,1,99,1,99,1,99,5,99,1795,8,99, + 10,99,12,99,1798,9,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,1808, + 8,99,10,99,12,99,1811,9,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,1819,8,99, + 10,99,12,99,1822,9,99,1,99,1,99,1,99,1,99,1,99,3,99,1829,8,99,1,100,1, + 100,1,100,1,100,1,100,1,100,1,100,1,100,5,100,1839,8,100,10,100,12,100, + 1842,9,100,1,100,1,100,1,100,1,100,1,100,1,101,1,101,1,101,1,101,1,101, 1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101, - 1,101,1,101,1,101,1,101,1,101,3,101,1858,8,101,1,102,1,102,1,102,1,102, - 1,102,3,102,1865,8,102,1,103,1,103,1,103,3,103,1870,8,103,1,104,1,104, - 1,104,1,104,1,104,3,104,1877,8,104,1,105,1,105,5,105,1881,8,105,10,105, - 12,105,1884,9,105,1,105,1,105,1,105,1,105,1,105,5,105,1891,8,105,10,105, - 12,105,1894,9,105,1,105,3,105,1897,8,105,1,106,1,106,1,107,5,107,1902, - 8,107,10,107,12,107,1905,9,107,1,108,1,108,1,108,1,108,1,108,1,108,1,108, - 1,108,1,108,1,108,1,108,1,108,3,108,1919,8,108,1,109,1,109,5,109,1923, - 8,109,10,109,12,109,1926,9,109,1,109,1,109,1,109,1,109,1,109,1,109,1,110, - 1,110,1,111,5,111,1937,8,111,10,111,12,111,1940,9,111,1,112,1,112,1,112, - 1,112,1,112,1,112,1,112,1,112,1,112,1,112,3,112,1952,8,112,1,113,1,113, - 1,113,1,113,1,113,1,113,3,113,1960,8,113,1,114,1,114,1,114,4,114,1965, - 8,114,11,114,12,114,1966,1,114,1,114,3,114,1971,8,114,1,115,5,115,1974, - 8,115,10,115,12,115,1977,9,115,1,116,1,116,1,116,1,116,1,116,1,116,1,116, - 1,116,1,116,1,116,1,116,1,116,1,116,3,116,1992,8,116,1,117,1,117,1,117, - 5,117,1997,8,117,10,117,12,117,2000,9,117,1,117,1,117,1,117,1,117,1,117, - 1,117,1,117,1,117,5,117,2010,8,117,10,117,12,117,2013,9,117,1,118,1,118, + 1,101,1,101,3,101,1868,8,101,1,102,1,102,1,102,1,102,1,102,3,102,1875, + 8,102,1,103,1,103,1,103,3,103,1880,8,103,1,104,1,104,1,104,1,104,1,104, + 3,104,1887,8,104,1,105,1,105,5,105,1891,8,105,10,105,12,105,1894,9,105, + 1,105,1,105,1,105,1,105,1,105,5,105,1901,8,105,10,105,12,105,1904,9,105, + 1,105,3,105,1907,8,105,1,106,1,106,1,107,5,107,1912,8,107,10,107,12,107, + 1915,9,107,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108, + 1,108,1,108,3,108,1929,8,108,1,109,1,109,5,109,1933,8,109,10,109,12,109, + 1936,9,109,1,109,1,109,1,109,1,109,1,109,1,109,1,110,1,110,1,111,5,111, + 1947,8,111,10,111,12,111,1950,9,111,1,112,1,112,1,112,1,112,1,112,1,112, + 1,112,1,112,1,112,1,112,3,112,1962,8,112,1,113,1,113,1,113,1,113,1,113, + 1,113,3,113,1970,8,113,1,114,1,114,1,114,4,114,1975,8,114,11,114,12,114, + 1976,1,114,1,114,3,114,1981,8,114,1,115,5,115,1984,8,115,10,115,12,115, + 1987,9,115,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116, + 1,116,1,116,1,116,3,116,2002,8,116,1,117,1,117,1,117,5,117,2007,8,117, + 10,117,12,117,2010,9,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117, + 5,117,2020,8,117,10,117,12,117,2023,9,117,1,118,1,118,1,118,1,118,1,118, 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, - 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,3,118,2038,8,118, - 1,119,1,119,1,119,1,119,1,119,3,119,2045,8,119,3,119,2047,8,119,1,119, - 5,119,2050,8,119,10,119,12,119,2053,9,119,1,119,1,119,1,119,3,119,2058, - 8,119,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, + 1,118,1,118,1,118,1,118,1,118,1,118,3,118,2048,8,118,1,119,1,119,1,119, + 1,119,1,119,3,119,2055,8,119,3,119,2057,8,119,1,119,5,119,2060,8,119,10, + 119,12,119,2063,9,119,1,119,1,119,1,119,3,119,2068,8,119,1,120,1,120,1, + 120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, - 1,120,1,120,1,120,1,120,3,120,2087,8,120,1,121,1,121,1,121,3,121,2092, - 8,121,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, - 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,3,122,2115, - 8,122,1,123,5,123,2118,8,123,10,123,12,123,2121,9,123,1,124,1,124,1,124, - 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, - 1,124,1,124,3,124,2140,8,124,1,125,1,125,1,125,1,125,1,125,1,125,1,125, + 1,120,3,120,2097,8,120,1,121,1,121,1,121,3,121,2102,8,121,1,122,1,122, + 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, + 1,122,1,122,1,122,1,122,1,122,1,122,1,122,3,122,2125,8,122,1,123,5,123, + 2128,8,123,10,123,12,123,2131,9,123,1,124,1,124,1,124,1,124,1,124,1,124, + 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,3,124, + 2150,8,124,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, - 1,125,1,125,1,125,1,125,1,125,1,125,5,125,2191,8,125,10,125,12,125,2194, - 9,125,1,125,1,125,1,125,1,125,5,125,2200,8,125,10,125,12,125,2203,9,125, - 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,5,125,2213,8,125,10,125, - 12,125,2216,9,125,1,125,1,125,1,125,1,125,1,125,1,125,5,125,2224,8,125, - 10,125,12,125,2227,9,125,1,125,1,125,1,125,1,125,1,125,1,125,5,125,2235, - 8,125,10,125,12,125,2238,9,125,3,125,2240,8,125,1,126,1,126,1,126,1,126, - 1,127,1,127,3,127,2248,8,127,1,128,1,128,1,128,1,128,1,129,1,129,1,129, - 1,130,4,130,2258,8,130,11,130,12,130,2259,1,131,1,131,1,131,1,131,1,131, - 1,131,1,131,1,131,1,131,1,131,1,131,1,131,3,131,2274,8,131,1,132,1,132, - 1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,3,132,2288, - 8,132,1,133,1,133,1,133,1,133,1,133,1,133,3,133,2296,8,133,1,134,1,134, - 1,134,1,135,1,135,1,136,1,136,1,137,1,137,1,137,1,137,1,137,1,137,1,137, - 1,137,1,137,1,137,1,137,3,137,2316,8,137,1,138,1,138,1,138,1,139,1,139, - 1,139,1,139,1,139,1,139,1,139,3,139,2328,8,139,1,140,1,140,1,140,3,140, - 2333,8,140,1,141,1,141,1,141,1,141,1,141,4,141,2340,8,141,11,141,12,141, - 2341,3,141,2344,8,141,1,142,1,142,1,142,5,142,2349,8,142,10,142,12,142, - 2352,9,142,1,142,1,142,1,143,1,143,1,143,1,143,1,143,3,143,2361,8,143, + 1,125,1,125,1,125,5,125,2201,8,125,10,125,12,125,2204,9,125,1,125,1,125, + 1,125,1,125,5,125,2210,8,125,10,125,12,125,2213,9,125,1,125,1,125,1,125, + 1,125,1,125,1,125,1,125,1,125,5,125,2223,8,125,10,125,12,125,2226,9,125, + 1,125,1,125,1,125,1,125,1,125,1,125,5,125,2234,8,125,10,125,12,125,2237, + 9,125,1,125,1,125,1,125,1,125,1,125,1,125,5,125,2245,8,125,10,125,12,125, + 2248,9,125,3,125,2250,8,125,1,126,1,126,1,126,1,126,1,127,1,127,3,127, + 2258,8,127,1,128,1,128,1,128,1,128,1,129,1,129,1,129,1,130,4,130,2268, + 8,130,11,130,12,130,2269,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131, + 1,131,1,131,1,131,1,131,3,131,2284,8,131,1,132,1,132,1,132,1,132,1,132, + 1,132,1,132,1,132,1,132,1,132,1,132,1,132,3,132,2298,8,132,1,133,1,133, + 1,133,1,133,1,133,1,133,3,133,2306,8,133,1,134,1,134,1,134,1,135,1,135, + 1,136,1,136,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137, + 1,137,3,137,2326,8,137,1,138,1,138,1,138,1,139,1,139,1,139,1,139,1,139, + 1,139,1,139,3,139,2338,8,139,1,140,1,140,1,140,3,140,2343,8,140,1,141, + 1,141,1,141,1,141,1,141,4,141,2350,8,141,11,141,12,141,2351,3,141,2354, + 8,141,1,142,1,142,1,142,5,142,2359,8,142,10,142,12,142,2362,9,142,1,142, + 1,142,1,143,1,143,1,143,1,143,1,143,3,143,2371,8,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,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,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,2429,8,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,145,1,145,1,145, + 1,144,1,144,1,144,3,144,2439,8,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,145,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,145,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,145,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,145,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,145,1,145, - 3,145,2506,8,145,1,146,1,146,1,146,5,146,2511,8,146,10,146,12,146,2514, - 9,146,1,147,1,147,1,148,1,148,1,148,3,148,2521,8,148,1,149,1,149,1,149, + 1,145,1,145,1,145,1,145,1,145,1,145,1,145,1,145,1,145,3,145,2516,8,145, + 1,146,1,146,1,146,5,146,2521,8,146,10,146,12,146,2524,9,146,1,147,1,147, + 1,148,1,148,1,148,3,148,2531,8,148,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, @@ -17101,915 +17117,918 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, - 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, - 1,149,3,149,2671,8,149,1,150,1,150,5,150,2675,8,150,10,150,12,150,2678, - 9,150,1,151,1,151,5,151,2682,8,151,10,151,12,151,2685,9,151,1,152,5,152, - 2688,8,152,10,152,12,152,2691,9,152,1,153,5,153,2694,8,153,10,153,12,153, - 2697,9,153,1,154,5,154,2700,8,154,10,154,12,154,2703,9,154,1,155,5,155, - 2706,8,155,10,155,12,155,2709,9,155,1,156,5,156,2712,8,156,10,156,12,156, - 2715,9,156,1,157,5,157,2718,8,157,10,157,12,157,2721,9,157,1,158,5,158, - 2724,8,158,10,158,12,158,2727,9,158,1,159,1,159,1,159,1,159,3,159,2733, - 8,159,1,160,5,160,2736,8,160,10,160,12,160,2739,9,160,1,161,1,161,1,161, - 3,161,2744,8,161,1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162, + 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,3,149,2681, + 8,149,1,150,1,150,5,150,2685,8,150,10,150,12,150,2688,9,150,1,151,1,151, + 5,151,2692,8,151,10,151,12,151,2695,9,151,1,152,5,152,2698,8,152,10,152, + 12,152,2701,9,152,1,153,5,153,2704,8,153,10,153,12,153,2707,9,153,1,154, + 5,154,2710,8,154,10,154,12,154,2713,9,154,1,155,5,155,2716,8,155,10,155, + 12,155,2719,9,155,1,156,5,156,2722,8,156,10,156,12,156,2725,9,156,1,157, + 5,157,2728,8,157,10,157,12,157,2731,9,157,1,158,5,158,2734,8,158,10,158, + 12,158,2737,9,158,1,159,1,159,1,159,1,159,3,159,2743,8,159,1,160,5,160, + 2746,8,160,10,160,12,160,2749,9,160,1,161,1,161,1,161,3,161,2754,8,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,162,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,162,1,162,1,162,3,162,2771,8,162,1,163,1,163,1,163,1,163,1,163, - 1,163,1,163,1,163,1,163,1,163,1,163,1,163,3,163,2785,8,163,1,164,5,164, - 2788,8,164,10,164,12,164,2791,9,164,1,165,1,165,1,165,1,165,1,165,1,165, - 1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,3,165,2807,8,165,1,166, - 1,166,1,166,5,166,2812,8,166,10,166,12,166,2815,9,166,1,166,1,166,1,167, - 1,167,5,167,2821,8,167,10,167,12,167,2824,9,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,168,1,168,1,168, - 1,168,3,168,2843,8,168,1,169,5,169,2846,8,169,10,169,12,169,2849,9,169, - 1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170, - 1,170,3,170,2864,8,170,1,171,1,171,5,171,2868,8,171,10,171,12,171,2871, - 9,171,1,171,1,171,1,171,5,171,2876,8,171,10,171,12,171,2879,9,171,1,171, - 1,171,1,171,1,171,3,171,2885,8,171,1,172,1,172,1,173,5,173,2890,8,173, - 10,173,12,173,2893,9,173,1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174, - 1,174,1,174,3,174,2905,8,174,1,174,0,1,68,175,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,0,16,6,0,1,15,199,199,243, - 243,247,247,264,264,289,289,5,0,16,16,199,199,243,243,264,264,288,289, - 1,0,263,264,1,0,173,174,1,0,37,38,1,0,73,74,3,0,2,2,61,61,77,83,2,0,229, - 229,260,261,9,0,178,178,183,195,201,201,207,208,210,215,218,219,222,222, - 230,242,262,262,1,0,95,96,1,0,97,111,1,0,68,69,2,0,173,173,289,290,2,0, - 179,179,264,264,1,0,167,168,1,0,51,52,3334,0,350,1,0,0,0,2,363,1,0,0,0, - 4,365,1,0,0,0,6,372,1,0,0,0,8,381,1,0,0,0,10,434,1,0,0,0,12,436,1,0,0, - 0,14,439,1,0,0,0,16,442,1,0,0,0,18,446,1,0,0,0,20,449,1,0,0,0,22,452,1, - 0,0,0,24,459,1,0,0,0,26,475,1,0,0,0,28,477,1,0,0,0,30,479,1,0,0,0,32,489, - 1,0,0,0,34,491,1,0,0,0,36,514,1,0,0,0,38,518,1,0,0,0,40,536,1,0,0,0,42, - 563,1,0,0,0,44,586,1,0,0,0,46,622,1,0,0,0,48,624,1,0,0,0,50,628,1,0,0, - 0,52,630,1,0,0,0,54,637,1,0,0,0,56,649,1,0,0,0,58,652,1,0,0,0,60,654,1, - 0,0,0,62,667,1,0,0,0,64,675,1,0,0,0,66,677,1,0,0,0,68,685,1,0,0,0,70,701, - 1,0,0,0,72,707,1,0,0,0,74,710,1,0,0,0,76,759,1,0,0,0,78,764,1,0,0,0,80, - 769,1,0,0,0,82,774,1,0,0,0,84,782,1,0,0,0,86,787,1,0,0,0,88,892,1,0,0, - 0,90,920,1,0,0,0,92,922,1,0,0,0,94,926,1,0,0,0,96,928,1,0,0,0,98,933,1, - 0,0,0,100,938,1,0,0,0,102,1018,1,0,0,0,104,1035,1,0,0,0,106,1061,1,0,0, - 0,108,1063,1,0,0,0,110,1075,1,0,0,0,112,1100,1,0,0,0,114,1109,1,0,0,0, - 116,1136,1,0,0,0,118,1143,1,0,0,0,120,1151,1,0,0,0,122,1159,1,0,0,0,124, - 1172,1,0,0,0,126,1182,1,0,0,0,128,1201,1,0,0,0,130,1295,1,0,0,0,132,1304, - 1,0,0,0,134,1314,1,0,0,0,136,1316,1,0,0,0,138,1318,1,0,0,0,140,1343,1, - 0,0,0,142,1375,1,0,0,0,144,1398,1,0,0,0,146,1410,1,0,0,0,148,1412,1,0, - 0,0,150,1415,1,0,0,0,152,1468,1,0,0,0,154,1480,1,0,0,0,156,1495,1,0,0, - 0,158,1502,1,0,0,0,160,1507,1,0,0,0,162,1511,1,0,0,0,164,1547,1,0,0,0, - 166,1549,1,0,0,0,168,1585,1,0,0,0,170,1597,1,0,0,0,172,1611,1,0,0,0,174, - 1613,1,0,0,0,176,1623,1,0,0,0,178,1634,1,0,0,0,180,1641,1,0,0,0,182,1651, - 1,0,0,0,184,1664,1,0,0,0,186,1669,1,0,0,0,188,1672,1,0,0,0,190,1683,1, - 0,0,0,192,1688,1,0,0,0,194,1694,1,0,0,0,196,1696,1,0,0,0,198,1818,1,0, - 0,0,200,1820,1,0,0,0,202,1857,1,0,0,0,204,1864,1,0,0,0,206,1869,1,0,0, - 0,208,1876,1,0,0,0,210,1896,1,0,0,0,212,1898,1,0,0,0,214,1903,1,0,0,0, - 216,1918,1,0,0,0,218,1920,1,0,0,0,220,1933,1,0,0,0,222,1938,1,0,0,0,224, - 1951,1,0,0,0,226,1959,1,0,0,0,228,1970,1,0,0,0,230,1975,1,0,0,0,232,1991, - 1,0,0,0,234,1993,1,0,0,0,236,2037,1,0,0,0,238,2057,1,0,0,0,240,2086,1, - 0,0,0,242,2091,1,0,0,0,244,2114,1,0,0,0,246,2119,1,0,0,0,248,2139,1,0, - 0,0,250,2239,1,0,0,0,252,2241,1,0,0,0,254,2247,1,0,0,0,256,2249,1,0,0, - 0,258,2253,1,0,0,0,260,2257,1,0,0,0,262,2273,1,0,0,0,264,2287,1,0,0,0, - 266,2295,1,0,0,0,268,2297,1,0,0,0,270,2300,1,0,0,0,272,2302,1,0,0,0,274, - 2315,1,0,0,0,276,2317,1,0,0,0,278,2327,1,0,0,0,280,2332,1,0,0,0,282,2343, - 1,0,0,0,284,2350,1,0,0,0,286,2360,1,0,0,0,288,2428,1,0,0,0,290,2505,1, - 0,0,0,292,2512,1,0,0,0,294,2515,1,0,0,0,296,2520,1,0,0,0,298,2670,1,0, - 0,0,300,2676,1,0,0,0,302,2683,1,0,0,0,304,2689,1,0,0,0,306,2695,1,0,0, - 0,308,2701,1,0,0,0,310,2707,1,0,0,0,312,2713,1,0,0,0,314,2719,1,0,0,0, - 316,2725,1,0,0,0,318,2732,1,0,0,0,320,2737,1,0,0,0,322,2743,1,0,0,0,324, - 2770,1,0,0,0,326,2784,1,0,0,0,328,2789,1,0,0,0,330,2806,1,0,0,0,332,2808, - 1,0,0,0,334,2818,1,0,0,0,336,2842,1,0,0,0,338,2847,1,0,0,0,340,2863,1, - 0,0,0,342,2884,1,0,0,0,344,2886,1,0,0,0,346,2891,1,0,0,0,348,2904,1,0, - 0,0,350,351,7,0,0,0,351,1,1,0,0,0,352,364,5,288,0,0,353,354,3,4,2,0,354, - 355,5,265,0,0,355,357,1,0,0,0,356,353,1,0,0,0,357,360,1,0,0,0,358,356, - 1,0,0,0,358,359,1,0,0,0,359,361,1,0,0,0,360,358,1,0,0,0,361,364,3,4,2, - 0,362,364,5,264,0,0,363,352,1,0,0,0,363,358,1,0,0,0,363,362,1,0,0,0,364, - 3,1,0,0,0,365,366,7,1,0,0,366,5,1,0,0,0,367,368,5,263,0,0,368,369,6,3, - -1,0,369,371,5,266,0,0,370,367,1,0,0,0,371,374,1,0,0,0,372,370,1,0,0,0, - 372,373,1,0,0,0,373,375,1,0,0,0,374,372,1,0,0,0,375,376,5,263,0,0,376, - 377,6,3,-1,0,377,7,1,0,0,0,378,380,3,10,5,0,379,378,1,0,0,0,380,383,1, - 0,0,0,381,379,1,0,0,0,381,382,1,0,0,0,382,9,1,0,0,0,383,381,1,0,0,0,384, - 385,3,74,37,0,385,386,5,17,0,0,386,387,3,82,41,0,387,388,5,18,0,0,388, - 435,1,0,0,0,389,390,3,72,36,0,390,391,5,17,0,0,391,392,3,8,4,0,392,393, - 5,18,0,0,393,435,1,0,0,0,394,395,3,234,117,0,395,396,5,17,0,0,396,397, - 3,246,123,0,397,398,5,18,0,0,398,435,1,0,0,0,399,435,3,200,100,0,400,435, - 3,276,138,0,401,435,3,70,35,0,402,435,3,66,33,0,403,435,3,88,44,0,404, - 435,3,90,45,0,405,435,3,22,11,0,406,407,3,326,163,0,407,408,5,17,0,0,408, - 409,3,328,164,0,409,410,5,18,0,0,410,435,1,0,0,0,411,412,3,332,166,0,412, - 413,5,17,0,0,413,414,3,338,169,0,414,415,5,18,0,0,415,435,1,0,0,0,416, - 417,3,342,171,0,417,418,5,17,0,0,418,419,3,346,173,0,419,420,5,18,0,0, - 420,435,1,0,0,0,421,435,3,64,32,0,422,435,3,152,76,0,423,435,3,322,161, - 0,424,435,3,12,6,0,425,435,3,14,7,0,426,435,3,16,8,0,427,435,3,18,9,0, - 428,435,3,20,10,0,429,435,3,26,13,0,430,435,3,42,21,0,431,435,3,40,20, - 0,432,435,3,30,15,0,433,435,3,24,12,0,434,384,1,0,0,0,434,389,1,0,0,0, - 434,394,1,0,0,0,434,399,1,0,0,0,434,400,1,0,0,0,434,401,1,0,0,0,434,402, - 1,0,0,0,434,403,1,0,0,0,434,404,1,0,0,0,434,405,1,0,0,0,434,406,1,0,0, - 0,434,411,1,0,0,0,434,416,1,0,0,0,434,421,1,0,0,0,434,422,1,0,0,0,434, - 423,1,0,0,0,434,424,1,0,0,0,434,425,1,0,0,0,434,426,1,0,0,0,434,427,1, - 0,0,0,434,428,1,0,0,0,434,429,1,0,0,0,434,430,1,0,0,0,434,431,1,0,0,0, - 434,432,1,0,0,0,434,433,1,0,0,0,435,11,1,0,0,0,436,437,5,19,0,0,437,438, - 3,32,16,0,438,13,1,0,0,0,439,440,5,20,0,0,440,441,3,32,16,0,441,15,1,0, - 0,0,442,443,5,21,0,0,443,444,5,22,0,0,444,445,3,32,16,0,445,17,1,0,0,0, - 446,447,5,23,0,0,447,448,3,34,17,0,448,19,1,0,0,0,449,450,5,24,0,0,450, - 451,3,34,17,0,451,21,1,0,0,0,452,453,5,25,0,0,453,454,3,98,49,0,454,455, - 3,2,1,0,455,456,5,17,0,0,456,457,3,120,60,0,457,458,5,18,0,0,458,23,1, - 0,0,0,459,460,5,26,0,0,460,25,1,0,0,0,461,462,5,27,0,0,462,476,3,28,14, - 0,463,464,5,27,0,0,464,465,3,28,14,0,465,466,5,28,0,0,466,467,3,28,14, - 0,467,476,1,0,0,0,468,469,5,27,0,0,469,470,3,28,14,0,470,471,5,28,0,0, - 471,472,3,28,14,0,472,473,5,28,0,0,473,474,3,28,14,0,474,476,1,0,0,0,475, - 461,1,0,0,0,475,463,1,0,0,0,475,468,1,0,0,0,476,27,1,0,0,0,477,478,7,2, - 0,0,478,29,1,0,0,0,479,480,5,29,0,0,480,484,5,17,0,0,481,483,3,116,58, - 0,482,481,1,0,0,0,483,486,1,0,0,0,484,482,1,0,0,0,484,485,1,0,0,0,485, - 487,1,0,0,0,486,484,1,0,0,0,487,488,5,18,0,0,488,31,1,0,0,0,489,490,5, - 173,0,0,490,33,1,0,0,0,491,492,7,3,0,0,492,35,1,0,0,0,493,494,5,175,0, - 0,494,515,6,18,-1,0,495,496,3,32,16,0,496,497,5,265,0,0,497,498,6,18,-1, - 0,498,515,1,0,0,0,499,500,3,32,16,0,500,501,6,18,-1,0,501,515,1,0,0,0, - 502,503,5,188,0,0,503,504,5,30,0,0,504,505,3,32,16,0,505,506,5,31,0,0, - 506,507,6,18,-1,0,507,515,1,0,0,0,508,509,5,189,0,0,509,510,5,30,0,0,510, - 511,3,34,17,0,511,512,5,31,0,0,512,513,6,18,-1,0,513,515,1,0,0,0,514,493, - 1,0,0,0,514,495,1,0,0,0,514,499,1,0,0,0,514,502,1,0,0,0,514,508,1,0,0, - 0,515,37,1,0,0,0,516,519,3,32,16,0,517,519,5,262,0,0,518,516,1,0,0,0,518, - 517,1,0,0,0,519,39,1,0,0,0,520,521,5,267,0,0,521,537,5,289,0,0,522,523, - 5,267,0,0,523,524,5,289,0,0,524,537,5,263,0,0,525,526,5,268,0,0,526,537, - 5,289,0,0,527,528,5,269,0,0,528,537,5,289,0,0,529,530,5,270,0,0,530,537, - 5,289,0,0,531,537,5,271,0,0,532,537,5,272,0,0,533,534,5,273,0,0,534,537, - 5,263,0,0,535,537,5,32,0,0,536,520,1,0,0,0,536,522,1,0,0,0,536,525,1,0, - 0,0,536,527,1,0,0,0,536,529,1,0,0,0,536,531,1,0,0,0,536,532,1,0,0,0,536, - 533,1,0,0,0,536,535,1,0,0,0,537,41,1,0,0,0,538,539,5,33,0,0,539,540,3, - 138,69,0,540,541,5,34,0,0,541,542,3,2,1,0,542,564,1,0,0,0,543,544,5,33, - 0,0,544,545,3,116,58,0,545,546,5,34,0,0,546,547,3,2,1,0,547,564,1,0,0, - 0,548,549,5,33,0,0,549,550,3,176,88,0,550,551,5,34,0,0,551,552,3,2,1,0, - 552,564,1,0,0,0,553,554,5,33,0,0,554,555,3,44,22,0,555,556,5,34,0,0,556, - 557,3,2,1,0,557,564,1,0,0,0,558,559,5,33,0,0,559,560,3,46,23,0,560,561, - 5,34,0,0,561,562,3,2,1,0,562,564,1,0,0,0,563,538,1,0,0,0,563,543,1,0,0, - 0,563,548,1,0,0,0,563,553,1,0,0,0,563,558,1,0,0,0,564,43,1,0,0,0,565,566, - 5,35,0,0,566,587,3,48,24,0,567,568,5,35,0,0,568,569,3,48,24,0,569,570, - 5,36,0,0,570,571,3,6,3,0,571,587,1,0,0,0,572,573,5,35,0,0,573,574,3,48, - 24,0,574,575,5,36,0,0,575,576,5,17,0,0,576,577,3,52,26,0,577,578,5,18, - 0,0,578,587,1,0,0,0,579,580,5,35,0,0,580,581,3,48,24,0,581,582,5,36,0, - 0,582,583,5,30,0,0,583,584,3,292,146,0,584,585,5,31,0,0,585,587,1,0,0, - 0,586,565,1,0,0,0,586,567,1,0,0,0,586,572,1,0,0,0,586,579,1,0,0,0,587, - 45,1,0,0,0,588,589,5,35,0,0,589,590,5,30,0,0,590,591,3,50,25,0,591,592, - 5,31,0,0,592,593,3,48,24,0,593,623,1,0,0,0,594,595,5,35,0,0,595,596,5, - 30,0,0,596,597,3,50,25,0,597,598,5,31,0,0,598,599,3,48,24,0,599,600,5, - 36,0,0,600,601,3,6,3,0,601,623,1,0,0,0,602,603,5,35,0,0,603,604,5,30,0, - 0,604,605,3,50,25,0,605,606,5,31,0,0,606,607,3,48,24,0,607,608,5,36,0, - 0,608,609,5,17,0,0,609,610,3,52,26,0,610,611,5,18,0,0,611,623,1,0,0,0, - 612,613,5,35,0,0,613,614,5,30,0,0,614,615,3,50,25,0,615,616,5,31,0,0,616, - 617,3,48,24,0,617,618,5,36,0,0,618,619,5,30,0,0,619,620,3,292,146,0,620, - 621,5,31,0,0,621,623,1,0,0,0,622,588,1,0,0,0,622,594,1,0,0,0,622,602,1, - 0,0,0,622,612,1,0,0,0,623,47,1,0,0,0,624,625,3,168,84,0,625,49,1,0,0,0, - 626,629,3,124,62,0,627,629,3,176,88,0,628,626,1,0,0,0,628,627,1,0,0,0, - 629,51,1,0,0,0,630,631,3,54,27,0,631,632,3,56,28,0,632,53,1,0,0,0,633, - 636,3,298,149,0,634,636,3,40,20,0,635,633,1,0,0,0,635,634,1,0,0,0,636, - 639,1,0,0,0,637,635,1,0,0,0,637,638,1,0,0,0,638,55,1,0,0,0,639,637,1,0, - 0,0,640,641,3,58,29,0,641,642,3,60,30,0,642,643,3,2,1,0,643,644,5,36,0, - 0,644,645,3,298,149,0,645,648,1,0,0,0,646,648,3,40,20,0,647,640,1,0,0, - 0,647,646,1,0,0,0,648,651,1,0,0,0,649,647,1,0,0,0,649,650,1,0,0,0,650, - 57,1,0,0,0,651,649,1,0,0,0,652,653,7,4,0,0,653,59,1,0,0,0,654,656,3,62, - 31,0,655,657,5,261,0,0,656,655,1,0,0,0,656,657,1,0,0,0,657,61,1,0,0,0, - 658,668,3,144,72,0,659,668,3,2,1,0,660,668,5,196,0,0,661,668,5,197,0,0, - 662,663,5,202,0,0,663,664,5,39,0,0,664,668,5,264,0,0,665,666,5,202,0,0, - 666,668,3,116,58,0,667,658,1,0,0,0,667,659,1,0,0,0,667,660,1,0,0,0,667, - 661,1,0,0,0,667,662,1,0,0,0,667,665,1,0,0,0,668,63,1,0,0,0,669,670,5,198, - 0,0,670,671,5,40,0,0,671,676,3,2,1,0,672,673,5,198,0,0,673,676,3,2,1,0, - 674,676,5,198,0,0,675,669,1,0,0,0,675,672,1,0,0,0,675,674,1,0,0,0,676, - 65,1,0,0,0,677,678,5,41,0,0,678,679,5,42,0,0,679,680,3,32,16,0,680,681, - 5,43,0,0,681,682,3,68,34,0,682,683,5,44,0,0,683,684,3,0,0,0,684,67,1,0, - 0,0,685,698,6,34,-1,0,686,687,10,5,0,0,687,697,5,186,0,0,688,689,10,4, - 0,0,689,697,5,187,0,0,690,691,10,3,0,0,691,697,5,45,0,0,692,693,10,2,0, - 0,693,697,5,46,0,0,694,695,10,1,0,0,695,697,5,47,0,0,696,686,1,0,0,0,696, - 688,1,0,0,0,696,690,1,0,0,0,696,692,1,0,0,0,696,694,1,0,0,0,697,700,1, - 0,0,0,698,696,1,0,0,0,698,699,1,0,0,0,699,69,1,0,0,0,700,698,1,0,0,0,701, - 702,5,48,0,0,702,703,5,36,0,0,703,704,5,30,0,0,704,705,3,292,146,0,705, - 706,5,31,0,0,706,71,1,0,0,0,707,708,5,49,0,0,708,709,3,2,1,0,709,73,1, - 0,0,0,710,714,5,50,0,0,711,713,3,76,38,0,712,711,1,0,0,0,713,716,1,0,0, - 0,714,712,1,0,0,0,714,715,1,0,0,0,715,717,1,0,0,0,716,714,1,0,0,0,717, - 718,3,2,1,0,718,719,3,182,91,0,719,720,3,78,39,0,720,721,3,80,40,0,721, - 75,1,0,0,0,722,760,5,51,0,0,723,760,5,52,0,0,724,760,5,199,0,0,725,760, - 5,202,0,0,726,760,5,221,0,0,727,760,5,53,0,0,728,760,5,54,0,0,729,760, - 5,55,0,0,730,760,5,56,0,0,731,760,5,244,0,0,732,760,5,15,0,0,733,760,5, - 224,0,0,734,760,5,57,0,0,735,760,5,58,0,0,736,760,5,59,0,0,737,760,5,60, - 0,0,738,760,5,61,0,0,739,740,5,62,0,0,740,760,5,51,0,0,741,742,5,62,0, - 0,742,760,5,52,0,0,743,744,5,62,0,0,744,760,5,63,0,0,745,746,5,62,0,0, - 746,760,5,64,0,0,747,748,5,62,0,0,748,760,5,65,0,0,749,750,5,62,0,0,750, - 760,5,66,0,0,751,760,5,67,0,0,752,760,5,68,0,0,753,760,5,69,0,0,754,755, - 5,70,0,0,755,756,5,30,0,0,756,757,3,32,16,0,757,758,5,31,0,0,758,760,1, - 0,0,0,759,722,1,0,0,0,759,723,1,0,0,0,759,724,1,0,0,0,759,725,1,0,0,0, - 759,726,1,0,0,0,759,727,1,0,0,0,759,728,1,0,0,0,759,729,1,0,0,0,759,730, - 1,0,0,0,759,731,1,0,0,0,759,732,1,0,0,0,759,733,1,0,0,0,759,734,1,0,0, - 0,759,735,1,0,0,0,759,736,1,0,0,0,759,737,1,0,0,0,759,738,1,0,0,0,759, - 739,1,0,0,0,759,741,1,0,0,0,759,743,1,0,0,0,759,745,1,0,0,0,759,747,1, - 0,0,0,759,749,1,0,0,0,759,751,1,0,0,0,759,752,1,0,0,0,759,753,1,0,0,0, - 759,754,1,0,0,0,760,77,1,0,0,0,761,765,1,0,0,0,762,763,5,71,0,0,763,765, - 3,124,62,0,764,761,1,0,0,0,764,762,1,0,0,0,765,79,1,0,0,0,766,770,1,0, - 0,0,767,768,5,72,0,0,768,770,3,84,42,0,769,766,1,0,0,0,769,767,1,0,0,0, - 770,81,1,0,0,0,771,773,3,198,99,0,772,771,1,0,0,0,773,776,1,0,0,0,774, - 772,1,0,0,0,774,775,1,0,0,0,775,83,1,0,0,0,776,774,1,0,0,0,777,778,3,124, - 62,0,778,779,5,28,0,0,779,781,1,0,0,0,780,777,1,0,0,0,781,784,1,0,0,0, - 782,780,1,0,0,0,782,783,1,0,0,0,783,785,1,0,0,0,784,782,1,0,0,0,785,786, - 3,124,62,0,786,85,1,0,0,0,787,788,7,5,0,0,788,87,1,0,0,0,789,790,3,86, - 43,0,790,791,3,32,16,0,791,792,5,264,0,0,792,893,1,0,0,0,793,794,3,86, - 43,0,794,795,3,32,16,0,795,893,1,0,0,0,796,797,3,86,43,0,797,798,3,32, - 16,0,798,799,5,75,0,0,799,800,3,32,16,0,800,801,5,264,0,0,801,893,1,0, - 0,0,802,803,3,86,43,0,803,804,3,32,16,0,804,805,5,75,0,0,805,806,3,32, - 16,0,806,893,1,0,0,0,807,808,3,86,43,0,808,809,3,32,16,0,809,810,5,75, - 0,0,810,811,3,32,16,0,811,812,5,28,0,0,812,813,3,32,16,0,813,814,5,264, - 0,0,814,893,1,0,0,0,815,816,3,86,43,0,816,817,3,32,16,0,817,818,5,75,0, - 0,818,819,3,32,16,0,819,820,5,28,0,0,820,821,3,32,16,0,821,893,1,0,0,0, - 822,823,3,86,43,0,823,824,3,32,16,0,824,825,5,28,0,0,825,826,3,32,16,0, - 826,827,5,75,0,0,827,828,3,32,16,0,828,829,5,264,0,0,829,893,1,0,0,0,830, - 831,3,86,43,0,831,832,3,32,16,0,832,833,5,28,0,0,833,834,3,32,16,0,834, - 835,5,75,0,0,835,836,3,32,16,0,836,893,1,0,0,0,837,838,3,86,43,0,838,839, - 3,32,16,0,839,840,5,28,0,0,840,841,3,32,16,0,841,842,5,75,0,0,842,843, - 3,32,16,0,843,844,5,28,0,0,844,845,3,32,16,0,845,846,5,264,0,0,846,893, - 1,0,0,0,847,848,3,86,43,0,848,849,3,32,16,0,849,850,5,28,0,0,850,851,3, - 32,16,0,851,852,5,75,0,0,852,853,3,32,16,0,853,854,5,28,0,0,854,855,3, - 32,16,0,855,893,1,0,0,0,856,857,3,86,43,0,857,858,3,32,16,0,858,859,5, - 263,0,0,859,893,1,0,0,0,860,861,3,86,43,0,861,862,3,32,16,0,862,863,5, - 75,0,0,863,864,3,32,16,0,864,865,5,263,0,0,865,893,1,0,0,0,866,867,3,86, - 43,0,867,868,3,32,16,0,868,869,5,75,0,0,869,870,3,32,16,0,870,871,5,28, - 0,0,871,872,3,32,16,0,872,873,5,263,0,0,873,893,1,0,0,0,874,875,3,86,43, - 0,875,876,3,32,16,0,876,877,5,28,0,0,877,878,3,32,16,0,878,879,5,75,0, - 0,879,880,3,32,16,0,880,881,5,263,0,0,881,893,1,0,0,0,882,883,3,86,43, - 0,883,884,3,32,16,0,884,885,5,28,0,0,885,886,3,32,16,0,886,887,5,75,0, - 0,887,888,3,32,16,0,888,889,5,28,0,0,889,890,3,32,16,0,890,891,5,263,0, - 0,891,893,1,0,0,0,892,789,1,0,0,0,892,793,1,0,0,0,892,796,1,0,0,0,892, - 802,1,0,0,0,892,807,1,0,0,0,892,815,1,0,0,0,892,822,1,0,0,0,892,830,1, - 0,0,0,892,837,1,0,0,0,892,847,1,0,0,0,892,856,1,0,0,0,892,860,1,0,0,0, - 892,866,1,0,0,0,892,874,1,0,0,0,892,882,1,0,0,0,893,89,1,0,0,0,894,898, - 5,21,0,0,895,897,3,92,46,0,896,895,1,0,0,0,897,900,1,0,0,0,898,896,1,0, - 0,0,898,899,1,0,0,0,899,901,1,0,0,0,900,898,1,0,0,0,901,902,3,2,1,0,902, - 903,3,94,47,0,903,904,5,180,0,0,904,905,5,36,0,0,905,906,5,30,0,0,906, - 907,3,292,146,0,907,908,5,31,0,0,908,909,3,94,47,0,909,921,1,0,0,0,910, - 914,5,21,0,0,911,913,3,92,46,0,912,911,1,0,0,0,913,916,1,0,0,0,914,912, - 1,0,0,0,914,915,1,0,0,0,915,917,1,0,0,0,916,914,1,0,0,0,917,918,3,2,1, - 0,918,919,3,94,47,0,919,921,1,0,0,0,920,894,1,0,0,0,920,910,1,0,0,0,921, - 91,1,0,0,0,922,923,5,76,0,0,923,93,1,0,0,0,924,927,1,0,0,0,925,927,5,298, - 0,0,926,924,1,0,0,0,926,925,1,0,0,0,927,95,1,0,0,0,928,929,7,6,0,0,929, - 97,1,0,0,0,930,932,3,96,48,0,931,930,1,0,0,0,932,935,1,0,0,0,933,931,1, - 0,0,0,933,934,1,0,0,0,934,99,1,0,0,0,935,933,1,0,0,0,936,939,3,102,51, - 0,937,939,3,104,52,0,938,936,1,0,0,0,938,937,1,0,0,0,939,101,1,0,0,0,940, - 941,5,275,0,0,941,1019,6,51,-1,0,942,943,5,276,0,0,943,944,3,32,16,0,944, - 945,6,51,-1,0,945,1019,1,0,0,0,946,947,5,276,0,0,947,948,3,0,0,0,948,949, - 6,51,-1,0,949,1019,1,0,0,0,950,951,5,277,0,0,951,952,3,32,16,0,952,953, - 6,51,-1,0,953,1019,1,0,0,0,954,955,5,278,0,0,955,956,3,34,17,0,956,957, - 6,51,-1,0,957,1019,1,0,0,0,958,959,5,279,0,0,959,960,3,36,18,0,960,961, - 6,51,-1,0,961,1019,1,0,0,0,962,963,5,279,0,0,963,964,3,34,17,0,964,965, - 6,51,-1,0,965,1019,1,0,0,0,966,967,5,279,0,0,967,968,5,30,0,0,968,969, - 3,292,146,0,969,970,5,31,0,0,970,971,6,51,-1,0,971,1019,1,0,0,0,972,973, - 5,279,0,0,973,974,5,84,0,0,974,975,5,30,0,0,975,976,3,292,146,0,976,977, - 5,31,0,0,977,978,6,51,-1,0,978,1019,1,0,0,0,979,980,5,282,0,0,980,981, - 3,32,16,0,981,982,6,51,-1,0,982,1019,1,0,0,0,983,984,5,282,0,0,984,985, - 3,0,0,0,985,986,6,51,-1,0,986,1019,1,0,0,0,987,988,5,285,0,0,988,989,3, - 6,3,0,989,990,6,51,-1,0,990,1019,1,0,0,0,991,992,5,285,0,0,992,993,5,224, - 0,0,993,994,5,30,0,0,994,995,3,6,3,0,995,996,5,31,0,0,996,997,6,51,-1, - 0,997,1019,1,0,0,0,998,999,5,285,0,0,999,1000,5,84,0,0,1000,1001,5,30, - 0,0,1001,1002,3,292,146,0,1002,1003,5,31,0,0,1003,1004,6,51,-1,0,1004, - 1019,1,0,0,0,1005,1006,5,287,0,0,1006,1007,3,32,16,0,1007,1008,6,51,-1, - 0,1008,1019,1,0,0,0,1009,1010,5,283,0,0,1010,1016,6,51,-1,0,1011,1012, - 5,30,0,0,1012,1013,3,106,53,0,1013,1014,5,31,0,0,1014,1017,1,0,0,0,1015, - 1017,5,85,0,0,1016,1011,1,0,0,0,1016,1015,1,0,0,0,1017,1019,1,0,0,0,1018, - 940,1,0,0,0,1018,942,1,0,0,0,1018,946,1,0,0,0,1018,950,1,0,0,0,1018,954, - 1,0,0,0,1018,958,1,0,0,0,1018,962,1,0,0,0,1018,966,1,0,0,0,1018,972,1, - 0,0,0,1018,979,1,0,0,0,1018,983,1,0,0,0,1018,987,1,0,0,0,1018,991,1,0, - 0,0,1018,998,1,0,0,0,1018,1005,1,0,0,0,1018,1009,1,0,0,0,1019,103,1,0, - 0,0,1020,1021,5,280,0,0,1021,1036,3,168,84,0,1022,1023,5,286,0,0,1023, - 1036,3,178,89,0,1024,1025,5,286,0,0,1025,1036,3,174,87,0,1026,1027,5,284, - 0,0,1027,1036,3,124,62,0,1028,1029,5,281,0,0,1029,1030,3,170,85,0,1030, - 1031,3,138,69,0,1031,1032,3,112,56,0,1032,1036,1,0,0,0,1033,1034,5,287, - 0,0,1034,1036,3,50,25,0,1035,1020,1,0,0,0,1035,1022,1,0,0,0,1035,1024, - 1,0,0,0,1035,1026,1,0,0,0,1035,1028,1,0,0,0,1035,1033,1,0,0,0,1036,105, - 1,0,0,0,1037,1062,1,0,0,0,1038,1039,3,0,0,0,1039,1040,6,53,-1,0,1040,1045, - 1,0,0,0,1041,1042,3,32,16,0,1042,1043,6,53,-1,0,1043,1045,1,0,0,0,1044, - 1038,1,0,0,0,1044,1041,1,0,0,0,1045,1046,1,0,0,0,1046,1047,5,28,0,0,1047, - 1049,1,0,0,0,1048,1044,1,0,0,0,1049,1052,1,0,0,0,1050,1048,1,0,0,0,1050, - 1051,1,0,0,0,1051,1059,1,0,0,0,1052,1050,1,0,0,0,1053,1054,3,0,0,0,1054, - 1055,6,53,-1,0,1055,1060,1,0,0,0,1056,1057,3,32,16,0,1057,1058,6,53,-1, - 0,1058,1060,1,0,0,0,1059,1053,1,0,0,0,1059,1056,1,0,0,0,1060,1062,1,0, - 0,0,1061,1037,1,0,0,0,1061,1050,1,0,0,0,1062,107,1,0,0,0,1063,1069,5,86, - 0,0,1064,1065,3,138,69,0,1065,1066,5,28,0,0,1066,1068,1,0,0,0,1067,1064, - 1,0,0,0,1068,1071,1,0,0,0,1069,1067,1,0,0,0,1069,1070,1,0,0,0,1070,1072, - 1,0,0,0,1071,1069,1,0,0,0,1072,1073,3,138,69,0,1073,1074,5,87,0,0,1074, - 109,1,0,0,0,1075,1081,5,42,0,0,1076,1077,3,146,73,0,1077,1078,5,28,0,0, - 1078,1080,1,0,0,0,1079,1076,1,0,0,0,1080,1083,1,0,0,0,1081,1079,1,0,0, - 0,1081,1082,1,0,0,0,1082,1084,1,0,0,0,1083,1081,1,0,0,0,1084,1085,3,146, - 73,0,1085,1086,5,43,0,0,1086,111,1,0,0,0,1087,1093,5,30,0,0,1088,1089, - 3,114,57,0,1089,1090,5,28,0,0,1090,1092,1,0,0,0,1091,1088,1,0,0,0,1092, - 1095,1,0,0,0,1093,1091,1,0,0,0,1093,1094,1,0,0,0,1094,1096,1,0,0,0,1095, - 1093,1,0,0,0,1096,1097,3,114,57,0,1097,1098,5,31,0,0,1098,1101,1,0,0,0, - 1099,1101,5,85,0,0,1100,1087,1,0,0,0,1100,1099,1,0,0,0,1101,113,1,0,0, - 0,1102,1110,5,177,0,0,1103,1104,3,230,115,0,1104,1105,3,138,69,0,1105, - 1107,3,226,113,0,1106,1108,3,0,0,0,1107,1106,1,0,0,0,1107,1108,1,0,0,0, - 1108,1110,1,0,0,0,1109,1102,1,0,0,0,1109,1103,1,0,0,0,1110,115,1,0,0,0, - 1111,1112,5,42,0,0,1112,1113,3,2,1,0,1113,1114,5,43,0,0,1114,1115,3,118, - 59,0,1115,1137,1,0,0,0,1116,1117,5,42,0,0,1117,1118,3,174,87,0,1118,1119, - 5,43,0,0,1119,1120,3,118,59,0,1120,1137,1,0,0,0,1121,1122,5,42,0,0,1122, - 1123,5,262,0,0,1123,1124,5,43,0,0,1124,1137,3,118,59,0,1125,1126,5,42, - 0,0,1126,1127,5,198,0,0,1127,1128,3,2,1,0,1128,1129,5,43,0,0,1129,1130, - 3,118,59,0,1130,1137,1,0,0,0,1131,1137,3,118,59,0,1132,1137,3,174,87,0, - 1133,1137,5,257,0,0,1134,1137,5,258,0,0,1135,1137,5,259,0,0,1136,1111, - 1,0,0,0,1136,1116,1,0,0,0,1136,1121,1,0,0,0,1136,1125,1,0,0,0,1136,1131, - 1,0,0,0,1136,1132,1,0,0,0,1136,1133,1,0,0,0,1136,1134,1,0,0,0,1136,1135, - 1,0,0,0,1137,117,1,0,0,0,1138,1139,3,2,1,0,1139,1140,5,88,0,0,1140,1142, - 1,0,0,0,1141,1138,1,0,0,0,1142,1145,1,0,0,0,1143,1141,1,0,0,0,1143,1144, - 1,0,0,0,1144,1146,1,0,0,0,1145,1143,1,0,0,0,1146,1147,3,2,1,0,1147,119, - 1,0,0,0,1148,1150,3,122,61,0,1149,1148,1,0,0,0,1150,1153,1,0,0,0,1151, - 1149,1,0,0,0,1151,1152,1,0,0,0,1152,121,1,0,0,0,1153,1151,1,0,0,0,1154, - 1155,5,180,0,0,1155,1156,5,89,0,0,1156,1160,3,32,16,0,1157,1160,3,152, - 76,0,1158,1160,3,324,162,0,1159,1154,1,0,0,0,1159,1157,1,0,0,0,1159,1158, - 1,0,0,0,1160,123,1,0,0,0,1161,1173,3,116,58,0,1162,1163,5,42,0,0,1163, - 1164,3,2,1,0,1164,1165,5,43,0,0,1165,1173,1,0,0,0,1166,1167,5,42,0,0,1167, - 1168,5,198,0,0,1168,1169,3,2,1,0,1169,1170,5,43,0,0,1170,1173,1,0,0,0, - 1171,1173,3,138,69,0,1172,1161,1,0,0,0,1172,1162,1,0,0,0,1172,1166,1,0, - 0,0,1172,1171,1,0,0,0,1173,125,1,0,0,0,1174,1183,1,0,0,0,1175,1179,3,130, - 65,0,1176,1178,3,128,64,0,1177,1176,1,0,0,0,1178,1181,1,0,0,0,1179,1177, - 1,0,0,0,1179,1180,1,0,0,0,1180,1183,1,0,0,0,1181,1179,1,0,0,0,1182,1174, - 1,0,0,0,1182,1175,1,0,0,0,1183,127,1,0,0,0,1184,1202,5,262,0,0,1185,1202, - 5,261,0,0,1186,1187,5,42,0,0,1187,1188,3,32,16,0,1188,1189,5,43,0,0,1189, - 1202,1,0,0,0,1190,1191,5,42,0,0,1191,1192,3,32,16,0,1192,1193,5,266,0, - 0,1193,1194,3,32,16,0,1194,1195,5,43,0,0,1195,1202,1,0,0,0,1196,1197,5, - 42,0,0,1197,1198,5,266,0,0,1198,1199,3,32,16,0,1199,1200,5,43,0,0,1200, - 1202,1,0,0,0,1201,1184,1,0,0,0,1201,1185,1,0,0,0,1201,1186,1,0,0,0,1201, - 1190,1,0,0,0,1201,1196,1,0,0,0,1202,129,1,0,0,0,1203,1296,1,0,0,0,1204, - 1205,5,203,0,0,1205,1206,5,30,0,0,1206,1207,3,6,3,0,1207,1208,5,28,0,0, - 1208,1209,3,6,3,0,1209,1210,5,28,0,0,1210,1211,3,6,3,0,1211,1212,5,28, - 0,0,1212,1213,3,6,3,0,1213,1214,5,31,0,0,1214,1296,1,0,0,0,1215,1216,5, - 203,0,0,1216,1217,5,30,0,0,1217,1218,3,6,3,0,1218,1219,5,28,0,0,1219,1220, - 3,6,3,0,1220,1221,5,31,0,0,1221,1296,1,0,0,0,1222,1223,5,204,0,0,1223, - 1224,5,205,0,0,1224,1225,5,42,0,0,1225,1226,3,32,16,0,1226,1227,5,43,0, - 0,1227,1296,1,0,0,0,1228,1229,5,204,0,0,1229,1230,5,206,0,0,1230,1231, - 5,42,0,0,1231,1232,3,32,16,0,1232,1233,5,43,0,0,1233,1234,3,126,63,0,1234, - 1296,1,0,0,0,1235,1296,5,207,0,0,1236,1296,5,208,0,0,1237,1296,5,209,0, - 0,1238,1296,5,201,0,0,1239,1296,5,183,0,0,1240,1296,5,184,0,0,1241,1296, - 5,185,0,0,1242,1296,5,186,0,0,1243,1296,5,187,0,0,1244,1296,5,188,0,0, - 1245,1296,5,189,0,0,1246,1296,5,210,0,0,1247,1296,5,190,0,0,1248,1296, - 5,191,0,0,1249,1296,5,192,0,0,1250,1296,5,193,0,0,1251,1296,5,211,0,0, - 1252,1296,5,212,0,0,1253,1296,5,213,0,0,1254,1296,5,214,0,0,1255,1296, - 5,215,0,0,1256,1296,5,216,0,0,1257,1296,5,217,0,0,1258,1259,5,218,0,0, - 1259,1296,3,132,66,0,1260,1261,5,219,0,0,1261,1296,3,132,66,0,1262,1296, - 5,220,0,0,1263,1264,5,221,0,0,1264,1296,3,132,66,0,1265,1266,5,222,0,0, - 1266,1296,3,134,67,0,1267,1268,5,222,0,0,1268,1269,3,134,67,0,1269,1270, - 5,28,0,0,1270,1271,3,6,3,0,1271,1296,1,0,0,0,1272,1296,5,194,0,0,1273, - 1296,5,195,0,0,1274,1275,5,90,0,0,1275,1296,5,184,0,0,1276,1277,5,90,0, - 0,1277,1296,5,185,0,0,1278,1279,5,90,0,0,1279,1296,5,186,0,0,1280,1281, - 5,90,0,0,1281,1296,5,187,0,0,1282,1283,5,62,0,0,1283,1296,5,220,0,0,1284, - 1296,5,223,0,0,1285,1286,5,224,0,0,1286,1296,5,213,0,0,1287,1296,5,225, - 0,0,1288,1289,5,207,0,0,1289,1296,5,183,0,0,1290,1296,5,226,0,0,1291,1296, - 5,228,0,0,1292,1293,5,34,0,0,1293,1296,5,227,0,0,1294,1296,3,2,1,0,1295, - 1203,1,0,0,0,1295,1204,1,0,0,0,1295,1215,1,0,0,0,1295,1222,1,0,0,0,1295, - 1228,1,0,0,0,1295,1235,1,0,0,0,1295,1236,1,0,0,0,1295,1237,1,0,0,0,1295, - 1238,1,0,0,0,1295,1239,1,0,0,0,1295,1240,1,0,0,0,1295,1241,1,0,0,0,1295, - 1242,1,0,0,0,1295,1243,1,0,0,0,1295,1244,1,0,0,0,1295,1245,1,0,0,0,1295, - 1246,1,0,0,0,1295,1247,1,0,0,0,1295,1248,1,0,0,0,1295,1249,1,0,0,0,1295, - 1250,1,0,0,0,1295,1251,1,0,0,0,1295,1252,1,0,0,0,1295,1253,1,0,0,0,1295, - 1254,1,0,0,0,1295,1255,1,0,0,0,1295,1256,1,0,0,0,1295,1257,1,0,0,0,1295, - 1258,1,0,0,0,1295,1260,1,0,0,0,1295,1262,1,0,0,0,1295,1263,1,0,0,0,1295, - 1265,1,0,0,0,1295,1267,1,0,0,0,1295,1272,1,0,0,0,1295,1273,1,0,0,0,1295, - 1274,1,0,0,0,1295,1276,1,0,0,0,1295,1278,1,0,0,0,1295,1280,1,0,0,0,1295, - 1282,1,0,0,0,1295,1284,1,0,0,0,1295,1285,1,0,0,0,1295,1287,1,0,0,0,1295, - 1288,1,0,0,0,1295,1290,1,0,0,0,1295,1291,1,0,0,0,1295,1292,1,0,0,0,1295, - 1294,1,0,0,0,1296,131,1,0,0,0,1297,1305,1,0,0,0,1298,1299,5,30,0,0,1299, - 1300,5,91,0,0,1300,1301,5,36,0,0,1301,1302,3,32,16,0,1302,1303,5,31,0, - 0,1303,1305,1,0,0,0,1304,1297,1,0,0,0,1304,1298,1,0,0,0,1305,133,1,0,0, - 0,1306,1315,1,0,0,0,1307,1311,3,136,68,0,1308,1310,7,7,0,0,1309,1308,1, - 0,0,0,1310,1313,1,0,0,0,1311,1309,1,0,0,0,1311,1312,1,0,0,0,1312,1315, - 1,0,0,0,1313,1311,1,0,0,0,1314,1306,1,0,0,0,1314,1307,1,0,0,0,1315,135, - 1,0,0,0,1316,1317,7,8,0,0,1317,137,1,0,0,0,1318,1322,3,142,71,0,1319,1321, - 3,140,70,0,1320,1319,1,0,0,0,1321,1324,1,0,0,0,1322,1320,1,0,0,0,1322, - 1323,1,0,0,0,1323,139,1,0,0,0,1324,1322,1,0,0,0,1325,1344,5,261,0,0,1326, - 1327,5,42,0,0,1327,1344,5,43,0,0,1328,1344,3,110,55,0,1329,1344,5,260, - 0,0,1330,1344,5,262,0,0,1331,1344,5,92,0,0,1332,1333,5,93,0,0,1333,1334, - 5,30,0,0,1334,1335,3,124,62,0,1335,1336,5,31,0,0,1336,1344,1,0,0,0,1337, - 1338,5,94,0,0,1338,1339,5,30,0,0,1339,1340,3,124,62,0,1340,1341,5,31,0, - 0,1341,1344,1,0,0,0,1342,1344,3,108,54,0,1343,1325,1,0,0,0,1343,1326,1, - 0,0,0,1343,1328,1,0,0,0,1343,1329,1,0,0,0,1343,1330,1,0,0,0,1343,1331, - 1,0,0,0,1343,1332,1,0,0,0,1343,1337,1,0,0,0,1343,1342,1,0,0,0,1344,141, - 1,0,0,0,1345,1346,5,39,0,0,1346,1376,3,116,58,0,1347,1376,5,197,0,0,1348, - 1349,5,199,0,0,1349,1350,5,39,0,0,1350,1376,3,116,58,0,1351,1352,5,200, - 0,0,1352,1376,3,116,58,0,1353,1354,5,226,0,0,1354,1355,3,170,85,0,1355, - 1356,3,138,69,0,1356,1357,5,262,0,0,1357,1358,3,112,56,0,1358,1376,1,0, - 0,0,1359,1360,5,253,0,0,1360,1376,3,32,16,0,1361,1362,5,252,0,0,1362,1376, - 3,32,16,0,1363,1364,5,253,0,0,1364,1376,3,2,1,0,1365,1366,5,252,0,0,1366, - 1376,3,2,1,0,1367,1376,5,254,0,0,1368,1376,5,201,0,0,1369,1376,3,148,74, - 0,1370,1376,3,150,75,0,1371,1376,3,144,72,0,1372,1376,3,2,1,0,1373,1374, - 5,177,0,0,1374,1376,3,138,69,0,1375,1345,1,0,0,0,1375,1347,1,0,0,0,1375, - 1348,1,0,0,0,1375,1351,1,0,0,0,1375,1353,1,0,0,0,1375,1359,1,0,0,0,1375, - 1361,1,0,0,0,1375,1363,1,0,0,0,1375,1365,1,0,0,0,1375,1367,1,0,0,0,1375, - 1368,1,0,0,0,1375,1369,1,0,0,0,1375,1370,1,0,0,0,1375,1371,1,0,0,0,1375, - 1372,1,0,0,0,1375,1373,1,0,0,0,1376,143,1,0,0,0,1377,1399,5,181,0,0,1378, - 1399,5,182,0,0,1379,1399,5,183,0,0,1380,1399,5,184,0,0,1381,1399,5,185, - 0,0,1382,1399,5,186,0,0,1383,1399,5,187,0,0,1384,1399,5,188,0,0,1385,1399, - 5,189,0,0,1386,1399,5,190,0,0,1387,1399,5,191,0,0,1388,1399,5,192,0,0, - 1389,1399,5,193,0,0,1390,1391,5,90,0,0,1391,1399,5,184,0,0,1392,1393,5, - 90,0,0,1393,1399,5,185,0,0,1394,1395,5,90,0,0,1395,1399,5,186,0,0,1396, - 1397,5,90,0,0,1397,1399,5,187,0,0,1398,1377,1,0,0,0,1398,1378,1,0,0,0, - 1398,1379,1,0,0,0,1398,1380,1,0,0,0,1398,1381,1,0,0,0,1398,1382,1,0,0, - 0,1398,1383,1,0,0,0,1398,1384,1,0,0,0,1398,1385,1,0,0,0,1398,1386,1,0, - 0,0,1398,1387,1,0,0,0,1398,1388,1,0,0,0,1398,1389,1,0,0,0,1398,1390,1, - 0,0,0,1398,1392,1,0,0,0,1398,1394,1,0,0,0,1398,1396,1,0,0,0,1399,145,1, - 0,0,0,1400,1411,1,0,0,0,1401,1411,5,177,0,0,1402,1411,3,32,16,0,1403,1404, - 3,32,16,0,1404,1405,5,177,0,0,1405,1406,3,32,16,0,1406,1411,1,0,0,0,1407, - 1408,3,32,16,0,1408,1409,5,177,0,0,1409,1411,1,0,0,0,1410,1400,1,0,0,0, - 1410,1401,1,0,0,0,1410,1402,1,0,0,0,1410,1403,1,0,0,0,1410,1407,1,0,0, - 0,1411,147,1,0,0,0,1412,1413,5,1,0,0,1413,1414,5,194,0,0,1414,149,1,0, - 0,0,1415,1419,5,1,0,0,1416,1417,5,90,0,0,1417,1420,5,194,0,0,1418,1420, - 5,195,0,0,1419,1416,1,0,0,0,1419,1418,1,0,0,0,1420,151,1,0,0,0,1421,1422, - 5,294,0,0,1422,1423,3,166,83,0,1423,1424,3,124,62,0,1424,1425,5,30,0,0, - 1425,1426,3,158,79,0,1426,1427,5,31,0,0,1427,1469,1,0,0,0,1428,1429,5, - 294,0,0,1429,1430,3,166,83,0,1430,1431,3,124,62,0,1431,1432,5,36,0,0,1432, - 1433,5,17,0,0,1433,1434,3,52,26,0,1434,1435,5,18,0,0,1435,1469,1,0,0,0, - 1436,1437,5,294,0,0,1437,1438,3,166,83,0,1438,1439,3,124,62,0,1439,1469, - 1,0,0,0,1440,1441,5,295,0,0,1441,1442,3,166,83,0,1442,1444,5,36,0,0,1443, - 1445,5,84,0,0,1444,1443,1,0,0,0,1444,1445,1,0,0,0,1445,1446,1,0,0,0,1446, - 1447,5,30,0,0,1447,1448,3,292,146,0,1448,1449,5,31,0,0,1449,1469,1,0,0, - 0,1450,1451,5,295,0,0,1451,1452,3,166,83,0,1452,1453,5,84,0,0,1453,1454, - 5,30,0,0,1454,1455,3,292,146,0,1455,1456,5,31,0,0,1456,1469,1,0,0,0,1457, - 1458,5,295,0,0,1458,1459,3,166,83,0,1459,1460,3,6,3,0,1460,1469,1,0,0, - 0,1461,1462,5,295,0,0,1462,1463,3,166,83,0,1463,1464,5,36,0,0,1464,1465, - 5,17,0,0,1465,1466,3,154,77,0,1466,1467,5,18,0,0,1467,1469,1,0,0,0,1468, - 1421,1,0,0,0,1468,1428,1,0,0,0,1468,1436,1,0,0,0,1468,1440,1,0,0,0,1468, - 1450,1,0,0,0,1468,1457,1,0,0,0,1468,1461,1,0,0,0,1469,153,1,0,0,0,1470, - 1481,1,0,0,0,1471,1472,3,156,78,0,1472,1473,5,28,0,0,1473,1475,1,0,0,0, - 1474,1471,1,0,0,0,1475,1478,1,0,0,0,1476,1474,1,0,0,0,1476,1477,1,0,0, - 0,1477,1479,1,0,0,0,1478,1476,1,0,0,0,1479,1481,3,156,78,0,1480,1470,1, - 0,0,0,1480,1476,1,0,0,0,1481,155,1,0,0,0,1482,1483,5,39,0,0,1483,1484, - 5,264,0,0,1484,1485,5,36,0,0,1485,1486,5,17,0,0,1486,1487,3,56,28,0,1487, - 1488,5,18,0,0,1488,1496,1,0,0,0,1489,1490,3,124,62,0,1490,1491,5,36,0, - 0,1491,1492,5,17,0,0,1492,1493,3,56,28,0,1493,1494,5,18,0,0,1494,1496, - 1,0,0,0,1495,1482,1,0,0,0,1495,1489,1,0,0,0,1496,157,1,0,0,0,1497,1498, - 3,160,80,0,1498,1499,5,28,0,0,1499,1501,1,0,0,0,1500,1497,1,0,0,0,1501, - 1504,1,0,0,0,1502,1500,1,0,0,0,1502,1503,1,0,0,0,1503,1505,1,0,0,0,1504, - 1502,1,0,0,0,1505,1506,3,160,80,0,1506,159,1,0,0,0,1507,1508,3,6,3,0,1508, - 1509,5,36,0,0,1509,1510,3,164,82,0,1510,161,1,0,0,0,1511,1512,7,9,0,0, - 1512,163,1,0,0,0,1513,1548,3,162,81,0,1514,1548,3,32,16,0,1515,1516,5, - 186,0,0,1516,1517,5,30,0,0,1517,1518,3,32,16,0,1518,1519,5,31,0,0,1519, - 1548,1,0,0,0,1520,1548,3,6,3,0,1521,1522,3,116,58,0,1522,1523,5,30,0,0, - 1523,1524,5,184,0,0,1524,1525,5,75,0,0,1525,1526,3,32,16,0,1526,1527,5, - 31,0,0,1527,1548,1,0,0,0,1528,1529,3,116,58,0,1529,1530,5,30,0,0,1530, - 1531,5,185,0,0,1531,1532,5,75,0,0,1532,1533,3,32,16,0,1533,1534,5,31,0, - 0,1534,1548,1,0,0,0,1535,1536,3,116,58,0,1536,1537,5,30,0,0,1537,1538, - 5,186,0,0,1538,1539,5,75,0,0,1539,1540,3,32,16,0,1540,1541,5,31,0,0,1541, - 1548,1,0,0,0,1542,1543,3,116,58,0,1543,1544,5,30,0,0,1544,1545,3,32,16, - 0,1545,1546,5,31,0,0,1546,1548,1,0,0,0,1547,1513,1,0,0,0,1547,1514,1,0, - 0,0,1547,1515,1,0,0,0,1547,1520,1,0,0,0,1547,1521,1,0,0,0,1547,1528,1, - 0,0,0,1547,1535,1,0,0,0,1547,1542,1,0,0,0,1548,165,1,0,0,0,1549,1550,7, - 10,0,0,1550,167,1,0,0,0,1551,1552,3,170,85,0,1552,1553,3,138,69,0,1553, - 1554,3,124,62,0,1554,1555,5,176,0,0,1555,1557,3,242,121,0,1556,1558,3, - 108,54,0,1557,1556,1,0,0,0,1557,1558,1,0,0,0,1558,1559,1,0,0,0,1559,1560, - 3,112,56,0,1560,1586,1,0,0,0,1561,1562,3,170,85,0,1562,1563,3,138,69,0, - 1563,1564,3,124,62,0,1564,1565,5,176,0,0,1565,1566,3,242,121,0,1566,1567, - 3,196,98,0,1567,1568,3,112,56,0,1568,1586,1,0,0,0,1569,1570,3,170,85,0, - 1570,1571,3,138,69,0,1571,1573,3,242,121,0,1572,1574,3,108,54,0,1573,1572, - 1,0,0,0,1573,1574,1,0,0,0,1574,1575,1,0,0,0,1575,1576,3,112,56,0,1576, - 1586,1,0,0,0,1577,1578,3,170,85,0,1578,1579,3,138,69,0,1579,1580,3,242, - 121,0,1580,1581,3,196,98,0,1581,1582,3,112,56,0,1582,1586,1,0,0,0,1583, - 1586,3,174,87,0,1584,1586,3,2,1,0,1585,1551,1,0,0,0,1585,1561,1,0,0,0, - 1585,1569,1,0,0,0,1585,1577,1,0,0,0,1585,1583,1,0,0,0,1585,1584,1,0,0, - 0,1586,169,1,0,0,0,1587,1588,5,243,0,0,1588,1598,3,170,85,0,1589,1590, - 5,244,0,0,1590,1598,3,170,85,0,1591,1598,3,172,86,0,1592,1593,5,112,0, - 0,1593,1594,5,30,0,0,1594,1595,3,32,16,0,1595,1596,5,31,0,0,1596,1598, - 1,0,0,0,1597,1587,1,0,0,0,1597,1589,1,0,0,0,1597,1591,1,0,0,0,1597,1592, - 1,0,0,0,1598,171,1,0,0,0,1599,1612,1,0,0,0,1600,1612,5,245,0,0,1601,1612, - 5,246,0,0,1602,1603,5,247,0,0,1603,1612,5,248,0,0,1604,1605,5,247,0,0, - 1605,1612,5,249,0,0,1606,1607,5,247,0,0,1607,1612,5,250,0,0,1608,1609, - 5,247,0,0,1609,1612,5,251,0,0,1610,1612,5,247,0,0,1611,1599,1,0,0,0,1611, - 1600,1,0,0,0,1611,1601,1,0,0,0,1611,1602,1,0,0,0,1611,1604,1,0,0,0,1611, - 1606,1,0,0,0,1611,1608,1,0,0,0,1611,1610,1,0,0,0,1612,173,1,0,0,0,1613, - 1614,5,113,0,0,1614,1615,5,30,0,0,1615,1616,3,32,16,0,1616,1617,5,31,0, - 0,1617,175,1,0,0,0,1618,1619,5,226,0,0,1619,1624,3,168,84,0,1620,1621, - 5,37,0,0,1621,1624,3,178,89,0,1622,1624,3,174,87,0,1623,1618,1,0,0,0,1623, - 1620,1,0,0,0,1623,1622,1,0,0,0,1624,177,1,0,0,0,1625,1626,3,138,69,0,1626, - 1627,3,124,62,0,1627,1628,5,176,0,0,1628,1629,3,2,1,0,1629,1635,1,0,0, - 0,1630,1631,3,138,69,0,1631,1632,3,2,1,0,1632,1635,1,0,0,0,1633,1635,3, - 2,1,0,1634,1625,1,0,0,0,1634,1630,1,0,0,0,1634,1633,1,0,0,0,1635,179,1, - 0,0,0,1636,1637,3,124,62,0,1637,1638,5,28,0,0,1638,1640,1,0,0,0,1639,1636, - 1,0,0,0,1640,1643,1,0,0,0,1641,1639,1,0,0,0,1641,1642,1,0,0,0,1642,1644, - 1,0,0,0,1643,1641,1,0,0,0,1644,1645,3,124,62,0,1645,181,1,0,0,0,1646,1652, - 1,0,0,0,1647,1648,5,86,0,0,1648,1649,3,190,95,0,1649,1650,5,87,0,0,1650, - 1652,1,0,0,0,1651,1646,1,0,0,0,1651,1647,1,0,0,0,1652,183,1,0,0,0,1653, - 1665,5,266,0,0,1654,1665,5,114,0,0,1655,1665,5,39,0,0,1656,1665,5,200, - 0,0,1657,1665,5,115,0,0,1658,1665,5,116,0,0,1659,1660,5,70,0,0,1660,1661, - 5,30,0,0,1661,1662,3,32,16,0,1662,1663,5,31,0,0,1663,1665,1,0,0,0,1664, - 1653,1,0,0,0,1664,1654,1,0,0,0,1664,1655,1,0,0,0,1664,1656,1,0,0,0,1664, - 1657,1,0,0,0,1664,1658,1,0,0,0,1664,1659,1,0,0,0,1665,185,1,0,0,0,1666, - 1668,3,184,92,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,187,1,0,0,0,1671,1669,1,0,0,0,1672,1674,3,186,93, - 0,1673,1675,3,192,96,0,1674,1673,1,0,0,0,1674,1675,1,0,0,0,1675,1676,1, - 0,0,0,1676,1677,3,2,1,0,1677,189,1,0,0,0,1678,1679,3,188,94,0,1679,1680, - 5,28,0,0,1680,1682,1,0,0,0,1681,1678,1,0,0,0,1682,1685,1,0,0,0,1683,1681, - 1,0,0,0,1683,1684,1,0,0,0,1684,1686,1,0,0,0,1685,1683,1,0,0,0,1686,1687, - 3,188,94,0,1687,191,1,0,0,0,1688,1689,5,30,0,0,1689,1690,3,180,90,0,1690, - 1691,5,31,0,0,1691,193,1,0,0,0,1692,1695,1,0,0,0,1693,1695,3,196,98,0, - 1694,1692,1,0,0,0,1694,1693,1,0,0,0,1695,195,1,0,0,0,1696,1697,5,86,0, - 0,1697,1698,5,42,0,0,1698,1699,3,32,16,0,1699,1700,5,43,0,0,1700,1701, - 5,87,0,0,1701,197,1,0,0,0,1702,1703,3,234,117,0,1703,1704,5,17,0,0,1704, - 1705,3,246,123,0,1705,1706,5,18,0,0,1706,1819,1,0,0,0,1707,1708,3,74,37, - 0,1708,1709,5,17,0,0,1709,1710,3,82,41,0,1710,1711,5,18,0,0,1711,1819, - 1,0,0,0,1712,1713,3,210,105,0,1713,1714,5,17,0,0,1714,1715,3,214,107,0, - 1715,1716,5,18,0,0,1716,1819,1,0,0,0,1717,1718,3,218,109,0,1718,1719,5, - 17,0,0,1719,1720,3,222,111,0,1720,1721,5,18,0,0,1721,1819,1,0,0,0,1722, - 1819,3,200,100,0,1723,1819,3,276,138,0,1724,1819,3,152,76,0,1725,1819, - 3,88,44,0,1726,1819,3,322,161,0,1727,1728,5,117,0,0,1728,1819,3,32,16, - 0,1729,1730,5,118,0,0,1730,1819,3,32,16,0,1731,1732,3,334,167,0,1732,1733, - 5,17,0,0,1733,1734,3,338,169,0,1734,1735,5,18,0,0,1735,1819,1,0,0,0,1736, - 1737,5,302,0,0,1737,1738,3,124,62,0,1738,1739,5,176,0,0,1739,1740,3,242, - 121,0,1740,1741,5,119,0,0,1741,1742,3,170,85,0,1742,1743,3,138,69,0,1743, - 1744,3,124,62,0,1744,1745,5,176,0,0,1745,1746,3,242,121,0,1746,1747,3, - 112,56,0,1747,1819,1,0,0,0,1748,1749,5,302,0,0,1749,1750,5,226,0,0,1750, - 1751,3,170,85,0,1751,1752,3,138,69,0,1752,1753,3,124,62,0,1753,1754,5, - 176,0,0,1754,1755,3,242,121,0,1755,1756,3,194,97,0,1756,1757,3,112,56, - 0,1757,1758,5,119,0,0,1758,1759,5,226,0,0,1759,1760,3,170,85,0,1760,1761, - 3,138,69,0,1761,1762,3,124,62,0,1762,1763,5,176,0,0,1763,1764,3,242,121, - 0,1764,1765,3,194,97,0,1765,1766,3,112,56,0,1766,1819,1,0,0,0,1767,1819, - 3,26,13,0,1768,1819,3,40,20,0,1769,1770,5,255,0,0,1770,1771,5,196,0,0, - 1771,1772,5,42,0,0,1772,1773,3,32,16,0,1773,1777,5,43,0,0,1774,1776,3, - 322,161,0,1775,1774,1,0,0,0,1776,1779,1,0,0,0,1777,1775,1,0,0,0,1777,1778, - 1,0,0,0,1778,1819,1,0,0,0,1779,1777,1,0,0,0,1780,1781,5,255,0,0,1781,1782, - 5,196,0,0,1782,1786,3,2,1,0,1783,1785,3,322,161,0,1784,1783,1,0,0,0,1785, - 1788,1,0,0,0,1786,1784,1,0,0,0,1786,1787,1,0,0,0,1787,1819,1,0,0,0,1788, - 1786,1,0,0,0,1789,1790,5,255,0,0,1790,1791,5,256,0,0,1791,1792,5,42,0, - 0,1792,1793,3,32,16,0,1793,1794,5,43,0,0,1794,1795,5,28,0,0,1795,1799, - 3,124,62,0,1796,1798,3,322,161,0,1797,1796,1,0,0,0,1798,1801,1,0,0,0,1799, - 1797,1,0,0,0,1799,1800,1,0,0,0,1800,1819,1,0,0,0,1801,1799,1,0,0,0,1802, - 1803,5,255,0,0,1803,1804,5,256,0,0,1804,1805,3,2,1,0,1805,1806,5,28,0, - 0,1806,1810,3,124,62,0,1807,1809,3,322,161,0,1808,1807,1,0,0,0,1809,1812, - 1,0,0,0,1810,1808,1,0,0,0,1810,1811,1,0,0,0,1811,1819,1,0,0,0,1812,1810, - 1,0,0,0,1813,1814,5,120,0,0,1814,1815,5,196,0,0,1815,1816,3,124,62,0,1816, - 1817,3,44,22,0,1817,1819,1,0,0,0,1818,1702,1,0,0,0,1818,1707,1,0,0,0,1818, - 1712,1,0,0,0,1818,1717,1,0,0,0,1818,1722,1,0,0,0,1818,1723,1,0,0,0,1818, - 1724,1,0,0,0,1818,1725,1,0,0,0,1818,1726,1,0,0,0,1818,1727,1,0,0,0,1818, - 1729,1,0,0,0,1818,1731,1,0,0,0,1818,1736,1,0,0,0,1818,1748,1,0,0,0,1818, - 1767,1,0,0,0,1818,1768,1,0,0,0,1818,1769,1,0,0,0,1818,1780,1,0,0,0,1818, - 1789,1,0,0,0,1818,1802,1,0,0,0,1818,1813,1,0,0,0,1819,199,1,0,0,0,1820, - 1821,5,121,0,0,1821,1830,3,208,104,0,1822,1829,3,202,101,0,1823,1824,5, - 122,0,0,1824,1825,5,30,0,0,1825,1826,3,228,114,0,1826,1827,5,31,0,0,1827, - 1829,1,0,0,0,1828,1822,1,0,0,0,1828,1823,1,0,0,0,1829,1832,1,0,0,0,1830, - 1828,1,0,0,0,1830,1831,1,0,0,0,1831,1833,1,0,0,0,1832,1830,1,0,0,0,1833, - 1834,3,138,69,0,1834,1835,3,2,1,0,1835,1836,3,204,102,0,1836,1837,3,206, - 103,0,1837,201,1,0,0,0,1838,1858,5,123,0,0,1839,1858,5,51,0,0,1840,1858, - 5,52,0,0,1841,1858,5,63,0,0,1842,1858,5,124,0,0,1843,1858,5,69,0,0,1844, - 1858,5,68,0,0,1845,1858,5,64,0,0,1846,1858,5,65,0,0,1847,1858,5,66,0,0, - 1848,1858,5,125,0,0,1849,1858,5,126,0,0,1850,1858,5,127,0,0,1851,1858, - 5,16,0,0,1852,1853,5,70,0,0,1853,1854,5,30,0,0,1854,1855,3,32,16,0,1855, - 1856,5,31,0,0,1856,1858,1,0,0,0,1857,1838,1,0,0,0,1857,1839,1,0,0,0,1857, - 1840,1,0,0,0,1857,1841,1,0,0,0,1857,1842,1,0,0,0,1857,1843,1,0,0,0,1857, - 1844,1,0,0,0,1857,1845,1,0,0,0,1857,1846,1,0,0,0,1857,1847,1,0,0,0,1857, - 1848,1,0,0,0,1857,1849,1,0,0,0,1857,1850,1,0,0,0,1857,1851,1,0,0,0,1857, - 1852,1,0,0,0,1858,203,1,0,0,0,1859,1865,1,0,0,0,1860,1861,5,44,0,0,1861, - 1865,3,0,0,0,1862,1863,5,44,0,0,1863,1865,3,32,16,0,1864,1859,1,0,0,0, - 1864,1860,1,0,0,0,1864,1862,1,0,0,0,1865,205,1,0,0,0,1866,1870,1,0,0,0, - 1867,1868,5,36,0,0,1868,1870,3,296,148,0,1869,1866,1,0,0,0,1869,1867,1, - 0,0,0,1870,207,1,0,0,0,1871,1877,1,0,0,0,1872,1873,5,42,0,0,1873,1874, - 3,32,16,0,1874,1875,5,43,0,0,1875,1877,1,0,0,0,1876,1871,1,0,0,0,1876, - 1872,1,0,0,0,1877,209,1,0,0,0,1878,1882,5,128,0,0,1879,1881,3,212,106, - 0,1880,1879,1,0,0,0,1881,1884,1,0,0,0,1882,1880,1,0,0,0,1882,1883,1,0, - 0,0,1883,1885,1,0,0,0,1884,1882,1,0,0,0,1885,1886,3,124,62,0,1886,1887, - 3,2,1,0,1887,1897,1,0,0,0,1888,1892,5,128,0,0,1889,1891,3,212,106,0,1890, + 1,162,3,162,2781,8,162,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163, + 1,163,1,163,1,163,1,163,3,163,2795,8,163,1,164,5,164,2798,8,164,10,164, + 12,164,2801,9,164,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165, + 1,165,1,165,1,165,1,165,1,165,3,165,2817,8,165,1,166,1,166,1,166,5,166, + 2822,8,166,10,166,12,166,2825,9,166,1,166,1,166,1,167,1,167,5,167,2831, + 8,167,10,167,12,167,2834,9,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,168,1,168,1,168,1,168,3,168,2853, + 8,168,1,169,5,169,2856,8,169,10,169,12,169,2859,9,169,1,170,1,170,1,170, + 1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,3,170,2874, + 8,170,1,171,1,171,5,171,2878,8,171,10,171,12,171,2881,9,171,1,171,1,171, + 1,171,5,171,2886,8,171,10,171,12,171,2889,9,171,1,171,1,171,1,171,1,171, + 3,171,2895,8,171,1,172,1,172,1,173,5,173,2900,8,173,10,173,12,173,2903, + 9,173,1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,3,174, + 2915,8,174,1,174,0,1,68,175,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,0,16,6,0,1,15,199,199,243,243,247,247,264, + 264,289,289,5,0,16,16,199,199,243,243,264,264,288,289,1,0,263,264,1,0, + 173,174,1,0,37,38,1,0,73,74,3,0,2,2,61,61,77,83,2,0,229,229,260,261,9, + 0,178,178,183,195,201,201,207,208,210,215,218,219,222,222,230,242,262, + 262,1,0,95,96,1,0,97,111,1,0,68,69,2,0,173,173,289,290,2,0,179,179,264, + 264,1,0,167,168,1,0,51,52,3344,0,350,1,0,0,0,2,363,1,0,0,0,4,365,1,0,0, + 0,6,372,1,0,0,0,8,381,1,0,0,0,10,434,1,0,0,0,12,436,1,0,0,0,14,439,1,0, + 0,0,16,442,1,0,0,0,18,446,1,0,0,0,20,449,1,0,0,0,22,452,1,0,0,0,24,459, + 1,0,0,0,26,475,1,0,0,0,28,477,1,0,0,0,30,479,1,0,0,0,32,489,1,0,0,0,34, + 491,1,0,0,0,36,514,1,0,0,0,38,518,1,0,0,0,40,536,1,0,0,0,42,563,1,0,0, + 0,44,586,1,0,0,0,46,622,1,0,0,0,48,624,1,0,0,0,50,628,1,0,0,0,52,630,1, + 0,0,0,54,637,1,0,0,0,56,649,1,0,0,0,58,652,1,0,0,0,60,654,1,0,0,0,62,667, + 1,0,0,0,64,675,1,0,0,0,66,677,1,0,0,0,68,685,1,0,0,0,70,701,1,0,0,0,72, + 707,1,0,0,0,74,710,1,0,0,0,76,759,1,0,0,0,78,764,1,0,0,0,80,769,1,0,0, + 0,82,774,1,0,0,0,84,782,1,0,0,0,86,787,1,0,0,0,88,892,1,0,0,0,90,920,1, + 0,0,0,92,922,1,0,0,0,94,926,1,0,0,0,96,928,1,0,0,0,98,933,1,0,0,0,100, + 961,1,0,0,0,102,1041,1,0,0,0,104,1043,1,0,0,0,106,1071,1,0,0,0,108,1073, + 1,0,0,0,110,1085,1,0,0,0,112,1110,1,0,0,0,114,1119,1,0,0,0,116,1146,1, + 0,0,0,118,1153,1,0,0,0,120,1161,1,0,0,0,122,1169,1,0,0,0,124,1182,1,0, + 0,0,126,1192,1,0,0,0,128,1211,1,0,0,0,130,1305,1,0,0,0,132,1314,1,0,0, + 0,134,1324,1,0,0,0,136,1326,1,0,0,0,138,1328,1,0,0,0,140,1353,1,0,0,0, + 142,1385,1,0,0,0,144,1408,1,0,0,0,146,1420,1,0,0,0,148,1422,1,0,0,0,150, + 1425,1,0,0,0,152,1478,1,0,0,0,154,1490,1,0,0,0,156,1505,1,0,0,0,158,1512, + 1,0,0,0,160,1517,1,0,0,0,162,1521,1,0,0,0,164,1557,1,0,0,0,166,1559,1, + 0,0,0,168,1595,1,0,0,0,170,1607,1,0,0,0,172,1621,1,0,0,0,174,1623,1,0, + 0,0,176,1633,1,0,0,0,178,1644,1,0,0,0,180,1651,1,0,0,0,182,1661,1,0,0, + 0,184,1674,1,0,0,0,186,1679,1,0,0,0,188,1682,1,0,0,0,190,1693,1,0,0,0, + 192,1698,1,0,0,0,194,1704,1,0,0,0,196,1706,1,0,0,0,198,1828,1,0,0,0,200, + 1830,1,0,0,0,202,1867,1,0,0,0,204,1874,1,0,0,0,206,1879,1,0,0,0,208,1886, + 1,0,0,0,210,1906,1,0,0,0,212,1908,1,0,0,0,214,1913,1,0,0,0,216,1928,1, + 0,0,0,218,1930,1,0,0,0,220,1943,1,0,0,0,222,1948,1,0,0,0,224,1961,1,0, + 0,0,226,1969,1,0,0,0,228,1980,1,0,0,0,230,1985,1,0,0,0,232,2001,1,0,0, + 0,234,2003,1,0,0,0,236,2047,1,0,0,0,238,2067,1,0,0,0,240,2096,1,0,0,0, + 242,2101,1,0,0,0,244,2124,1,0,0,0,246,2129,1,0,0,0,248,2149,1,0,0,0,250, + 2249,1,0,0,0,252,2251,1,0,0,0,254,2257,1,0,0,0,256,2259,1,0,0,0,258,2263, + 1,0,0,0,260,2267,1,0,0,0,262,2283,1,0,0,0,264,2297,1,0,0,0,266,2305,1, + 0,0,0,268,2307,1,0,0,0,270,2310,1,0,0,0,272,2312,1,0,0,0,274,2325,1,0, + 0,0,276,2327,1,0,0,0,278,2337,1,0,0,0,280,2342,1,0,0,0,282,2353,1,0,0, + 0,284,2360,1,0,0,0,286,2370,1,0,0,0,288,2438,1,0,0,0,290,2515,1,0,0,0, + 292,2522,1,0,0,0,294,2525,1,0,0,0,296,2530,1,0,0,0,298,2680,1,0,0,0,300, + 2686,1,0,0,0,302,2693,1,0,0,0,304,2699,1,0,0,0,306,2705,1,0,0,0,308,2711, + 1,0,0,0,310,2717,1,0,0,0,312,2723,1,0,0,0,314,2729,1,0,0,0,316,2735,1, + 0,0,0,318,2742,1,0,0,0,320,2747,1,0,0,0,322,2753,1,0,0,0,324,2780,1,0, + 0,0,326,2794,1,0,0,0,328,2799,1,0,0,0,330,2816,1,0,0,0,332,2818,1,0,0, + 0,334,2828,1,0,0,0,336,2852,1,0,0,0,338,2857,1,0,0,0,340,2873,1,0,0,0, + 342,2894,1,0,0,0,344,2896,1,0,0,0,346,2901,1,0,0,0,348,2914,1,0,0,0,350, + 351,7,0,0,0,351,1,1,0,0,0,352,364,5,288,0,0,353,354,3,4,2,0,354,355,5, + 265,0,0,355,357,1,0,0,0,356,353,1,0,0,0,357,360,1,0,0,0,358,356,1,0,0, + 0,358,359,1,0,0,0,359,361,1,0,0,0,360,358,1,0,0,0,361,364,3,4,2,0,362, + 364,5,264,0,0,363,352,1,0,0,0,363,358,1,0,0,0,363,362,1,0,0,0,364,3,1, + 0,0,0,365,366,7,1,0,0,366,5,1,0,0,0,367,368,5,263,0,0,368,369,6,3,-1,0, + 369,371,5,266,0,0,370,367,1,0,0,0,371,374,1,0,0,0,372,370,1,0,0,0,372, + 373,1,0,0,0,373,375,1,0,0,0,374,372,1,0,0,0,375,376,5,263,0,0,376,377, + 6,3,-1,0,377,7,1,0,0,0,378,380,3,10,5,0,379,378,1,0,0,0,380,383,1,0,0, + 0,381,379,1,0,0,0,381,382,1,0,0,0,382,9,1,0,0,0,383,381,1,0,0,0,384,385, + 3,74,37,0,385,386,5,17,0,0,386,387,3,82,41,0,387,388,5,18,0,0,388,435, + 1,0,0,0,389,390,3,72,36,0,390,391,5,17,0,0,391,392,3,8,4,0,392,393,5,18, + 0,0,393,435,1,0,0,0,394,395,3,234,117,0,395,396,5,17,0,0,396,397,3,246, + 123,0,397,398,5,18,0,0,398,435,1,0,0,0,399,435,3,200,100,0,400,435,3,276, + 138,0,401,435,3,70,35,0,402,435,3,66,33,0,403,435,3,88,44,0,404,435,3, + 90,45,0,405,435,3,22,11,0,406,407,3,326,163,0,407,408,5,17,0,0,408,409, + 3,328,164,0,409,410,5,18,0,0,410,435,1,0,0,0,411,412,3,332,166,0,412,413, + 5,17,0,0,413,414,3,338,169,0,414,415,5,18,0,0,415,435,1,0,0,0,416,417, + 3,342,171,0,417,418,5,17,0,0,418,419,3,346,173,0,419,420,5,18,0,0,420, + 435,1,0,0,0,421,435,3,64,32,0,422,435,3,152,76,0,423,435,3,322,161,0,424, + 435,3,12,6,0,425,435,3,14,7,0,426,435,3,16,8,0,427,435,3,18,9,0,428,435, + 3,20,10,0,429,435,3,26,13,0,430,435,3,42,21,0,431,435,3,40,20,0,432,435, + 3,30,15,0,433,435,3,24,12,0,434,384,1,0,0,0,434,389,1,0,0,0,434,394,1, + 0,0,0,434,399,1,0,0,0,434,400,1,0,0,0,434,401,1,0,0,0,434,402,1,0,0,0, + 434,403,1,0,0,0,434,404,1,0,0,0,434,405,1,0,0,0,434,406,1,0,0,0,434,411, + 1,0,0,0,434,416,1,0,0,0,434,421,1,0,0,0,434,422,1,0,0,0,434,423,1,0,0, + 0,434,424,1,0,0,0,434,425,1,0,0,0,434,426,1,0,0,0,434,427,1,0,0,0,434, + 428,1,0,0,0,434,429,1,0,0,0,434,430,1,0,0,0,434,431,1,0,0,0,434,432,1, + 0,0,0,434,433,1,0,0,0,435,11,1,0,0,0,436,437,5,19,0,0,437,438,3,32,16, + 0,438,13,1,0,0,0,439,440,5,20,0,0,440,441,3,32,16,0,441,15,1,0,0,0,442, + 443,5,21,0,0,443,444,5,22,0,0,444,445,3,32,16,0,445,17,1,0,0,0,446,447, + 5,23,0,0,447,448,3,34,17,0,448,19,1,0,0,0,449,450,5,24,0,0,450,451,3,34, + 17,0,451,21,1,0,0,0,452,453,5,25,0,0,453,454,3,98,49,0,454,455,3,2,1,0, + 455,456,5,17,0,0,456,457,3,120,60,0,457,458,5,18,0,0,458,23,1,0,0,0,459, + 460,5,26,0,0,460,25,1,0,0,0,461,462,5,27,0,0,462,476,3,28,14,0,463,464, + 5,27,0,0,464,465,3,28,14,0,465,466,5,28,0,0,466,467,3,28,14,0,467,476, + 1,0,0,0,468,469,5,27,0,0,469,470,3,28,14,0,470,471,5,28,0,0,471,472,3, + 28,14,0,472,473,5,28,0,0,473,474,3,28,14,0,474,476,1,0,0,0,475,461,1,0, + 0,0,475,463,1,0,0,0,475,468,1,0,0,0,476,27,1,0,0,0,477,478,7,2,0,0,478, + 29,1,0,0,0,479,480,5,29,0,0,480,484,5,17,0,0,481,483,3,116,58,0,482,481, + 1,0,0,0,483,486,1,0,0,0,484,482,1,0,0,0,484,485,1,0,0,0,485,487,1,0,0, + 0,486,484,1,0,0,0,487,488,5,18,0,0,488,31,1,0,0,0,489,490,5,173,0,0,490, + 33,1,0,0,0,491,492,7,3,0,0,492,35,1,0,0,0,493,494,5,175,0,0,494,515,6, + 18,-1,0,495,496,3,32,16,0,496,497,5,265,0,0,497,498,6,18,-1,0,498,515, + 1,0,0,0,499,500,3,32,16,0,500,501,6,18,-1,0,501,515,1,0,0,0,502,503,5, + 188,0,0,503,504,5,30,0,0,504,505,3,32,16,0,505,506,5,31,0,0,506,507,6, + 18,-1,0,507,515,1,0,0,0,508,509,5,189,0,0,509,510,5,30,0,0,510,511,3,34, + 17,0,511,512,5,31,0,0,512,513,6,18,-1,0,513,515,1,0,0,0,514,493,1,0,0, + 0,514,495,1,0,0,0,514,499,1,0,0,0,514,502,1,0,0,0,514,508,1,0,0,0,515, + 37,1,0,0,0,516,519,3,32,16,0,517,519,5,262,0,0,518,516,1,0,0,0,518,517, + 1,0,0,0,519,39,1,0,0,0,520,521,5,267,0,0,521,537,5,289,0,0,522,523,5,267, + 0,0,523,524,5,289,0,0,524,537,5,263,0,0,525,526,5,268,0,0,526,537,5,289, + 0,0,527,528,5,269,0,0,528,537,5,289,0,0,529,530,5,270,0,0,530,537,5,289, + 0,0,531,537,5,271,0,0,532,537,5,272,0,0,533,534,5,273,0,0,534,537,5,263, + 0,0,535,537,5,32,0,0,536,520,1,0,0,0,536,522,1,0,0,0,536,525,1,0,0,0,536, + 527,1,0,0,0,536,529,1,0,0,0,536,531,1,0,0,0,536,532,1,0,0,0,536,533,1, + 0,0,0,536,535,1,0,0,0,537,41,1,0,0,0,538,539,5,33,0,0,539,540,3,138,69, + 0,540,541,5,34,0,0,541,542,3,2,1,0,542,564,1,0,0,0,543,544,5,33,0,0,544, + 545,3,116,58,0,545,546,5,34,0,0,546,547,3,2,1,0,547,564,1,0,0,0,548,549, + 5,33,0,0,549,550,3,176,88,0,550,551,5,34,0,0,551,552,3,2,1,0,552,564,1, + 0,0,0,553,554,5,33,0,0,554,555,3,44,22,0,555,556,5,34,0,0,556,557,3,2, + 1,0,557,564,1,0,0,0,558,559,5,33,0,0,559,560,3,46,23,0,560,561,5,34,0, + 0,561,562,3,2,1,0,562,564,1,0,0,0,563,538,1,0,0,0,563,543,1,0,0,0,563, + 548,1,0,0,0,563,553,1,0,0,0,563,558,1,0,0,0,564,43,1,0,0,0,565,566,5,35, + 0,0,566,587,3,48,24,0,567,568,5,35,0,0,568,569,3,48,24,0,569,570,5,36, + 0,0,570,571,3,6,3,0,571,587,1,0,0,0,572,573,5,35,0,0,573,574,3,48,24,0, + 574,575,5,36,0,0,575,576,5,17,0,0,576,577,3,52,26,0,577,578,5,18,0,0,578, + 587,1,0,0,0,579,580,5,35,0,0,580,581,3,48,24,0,581,582,5,36,0,0,582,583, + 5,30,0,0,583,584,3,292,146,0,584,585,5,31,0,0,585,587,1,0,0,0,586,565, + 1,0,0,0,586,567,1,0,0,0,586,572,1,0,0,0,586,579,1,0,0,0,587,45,1,0,0,0, + 588,589,5,35,0,0,589,590,5,30,0,0,590,591,3,50,25,0,591,592,5,31,0,0,592, + 593,3,48,24,0,593,623,1,0,0,0,594,595,5,35,0,0,595,596,5,30,0,0,596,597, + 3,50,25,0,597,598,5,31,0,0,598,599,3,48,24,0,599,600,5,36,0,0,600,601, + 3,6,3,0,601,623,1,0,0,0,602,603,5,35,0,0,603,604,5,30,0,0,604,605,3,50, + 25,0,605,606,5,31,0,0,606,607,3,48,24,0,607,608,5,36,0,0,608,609,5,17, + 0,0,609,610,3,52,26,0,610,611,5,18,0,0,611,623,1,0,0,0,612,613,5,35,0, + 0,613,614,5,30,0,0,614,615,3,50,25,0,615,616,5,31,0,0,616,617,3,48,24, + 0,617,618,5,36,0,0,618,619,5,30,0,0,619,620,3,292,146,0,620,621,5,31,0, + 0,621,623,1,0,0,0,622,588,1,0,0,0,622,594,1,0,0,0,622,602,1,0,0,0,622, + 612,1,0,0,0,623,47,1,0,0,0,624,625,3,168,84,0,625,49,1,0,0,0,626,629,3, + 124,62,0,627,629,3,176,88,0,628,626,1,0,0,0,628,627,1,0,0,0,629,51,1,0, + 0,0,630,631,3,54,27,0,631,632,3,56,28,0,632,53,1,0,0,0,633,636,3,298,149, + 0,634,636,3,40,20,0,635,633,1,0,0,0,635,634,1,0,0,0,636,639,1,0,0,0,637, + 635,1,0,0,0,637,638,1,0,0,0,638,55,1,0,0,0,639,637,1,0,0,0,640,641,3,58, + 29,0,641,642,3,60,30,0,642,643,3,2,1,0,643,644,5,36,0,0,644,645,3,298, + 149,0,645,648,1,0,0,0,646,648,3,40,20,0,647,640,1,0,0,0,647,646,1,0,0, + 0,648,651,1,0,0,0,649,647,1,0,0,0,649,650,1,0,0,0,650,57,1,0,0,0,651,649, + 1,0,0,0,652,653,7,4,0,0,653,59,1,0,0,0,654,656,3,62,31,0,655,657,5,261, + 0,0,656,655,1,0,0,0,656,657,1,0,0,0,657,61,1,0,0,0,658,668,3,144,72,0, + 659,668,3,2,1,0,660,668,5,196,0,0,661,668,5,197,0,0,662,663,5,202,0,0, + 663,664,5,39,0,0,664,668,5,264,0,0,665,666,5,202,0,0,666,668,3,116,58, + 0,667,658,1,0,0,0,667,659,1,0,0,0,667,660,1,0,0,0,667,661,1,0,0,0,667, + 662,1,0,0,0,667,665,1,0,0,0,668,63,1,0,0,0,669,670,5,198,0,0,670,671,5, + 40,0,0,671,676,3,2,1,0,672,673,5,198,0,0,673,676,3,2,1,0,674,676,5,198, + 0,0,675,669,1,0,0,0,675,672,1,0,0,0,675,674,1,0,0,0,676,65,1,0,0,0,677, + 678,5,41,0,0,678,679,5,42,0,0,679,680,3,32,16,0,680,681,5,43,0,0,681,682, + 3,68,34,0,682,683,5,44,0,0,683,684,3,0,0,0,684,67,1,0,0,0,685,698,6,34, + -1,0,686,687,10,5,0,0,687,697,5,186,0,0,688,689,10,4,0,0,689,697,5,187, + 0,0,690,691,10,3,0,0,691,697,5,45,0,0,692,693,10,2,0,0,693,697,5,46,0, + 0,694,695,10,1,0,0,695,697,5,47,0,0,696,686,1,0,0,0,696,688,1,0,0,0,696, + 690,1,0,0,0,696,692,1,0,0,0,696,694,1,0,0,0,697,700,1,0,0,0,698,696,1, + 0,0,0,698,699,1,0,0,0,699,69,1,0,0,0,700,698,1,0,0,0,701,702,5,48,0,0, + 702,703,5,36,0,0,703,704,5,30,0,0,704,705,3,292,146,0,705,706,5,31,0,0, + 706,71,1,0,0,0,707,708,5,49,0,0,708,709,3,2,1,0,709,73,1,0,0,0,710,714, + 5,50,0,0,711,713,3,76,38,0,712,711,1,0,0,0,713,716,1,0,0,0,714,712,1,0, + 0,0,714,715,1,0,0,0,715,717,1,0,0,0,716,714,1,0,0,0,717,718,3,2,1,0,718, + 719,3,182,91,0,719,720,3,78,39,0,720,721,3,80,40,0,721,75,1,0,0,0,722, + 760,5,51,0,0,723,760,5,52,0,0,724,760,5,199,0,0,725,760,5,202,0,0,726, + 760,5,221,0,0,727,760,5,53,0,0,728,760,5,54,0,0,729,760,5,55,0,0,730,760, + 5,56,0,0,731,760,5,244,0,0,732,760,5,15,0,0,733,760,5,224,0,0,734,760, + 5,57,0,0,735,760,5,58,0,0,736,760,5,59,0,0,737,760,5,60,0,0,738,760,5, + 61,0,0,739,740,5,62,0,0,740,760,5,51,0,0,741,742,5,62,0,0,742,760,5,52, + 0,0,743,744,5,62,0,0,744,760,5,63,0,0,745,746,5,62,0,0,746,760,5,64,0, + 0,747,748,5,62,0,0,748,760,5,65,0,0,749,750,5,62,0,0,750,760,5,66,0,0, + 751,760,5,67,0,0,752,760,5,68,0,0,753,760,5,69,0,0,754,755,5,70,0,0,755, + 756,5,30,0,0,756,757,3,32,16,0,757,758,5,31,0,0,758,760,1,0,0,0,759,722, + 1,0,0,0,759,723,1,0,0,0,759,724,1,0,0,0,759,725,1,0,0,0,759,726,1,0,0, + 0,759,727,1,0,0,0,759,728,1,0,0,0,759,729,1,0,0,0,759,730,1,0,0,0,759, + 731,1,0,0,0,759,732,1,0,0,0,759,733,1,0,0,0,759,734,1,0,0,0,759,735,1, + 0,0,0,759,736,1,0,0,0,759,737,1,0,0,0,759,738,1,0,0,0,759,739,1,0,0,0, + 759,741,1,0,0,0,759,743,1,0,0,0,759,745,1,0,0,0,759,747,1,0,0,0,759,749, + 1,0,0,0,759,751,1,0,0,0,759,752,1,0,0,0,759,753,1,0,0,0,759,754,1,0,0, + 0,760,77,1,0,0,0,761,765,1,0,0,0,762,763,5,71,0,0,763,765,3,124,62,0,764, + 761,1,0,0,0,764,762,1,0,0,0,765,79,1,0,0,0,766,770,1,0,0,0,767,768,5,72, + 0,0,768,770,3,84,42,0,769,766,1,0,0,0,769,767,1,0,0,0,770,81,1,0,0,0,771, + 773,3,198,99,0,772,771,1,0,0,0,773,776,1,0,0,0,774,772,1,0,0,0,774,775, + 1,0,0,0,775,83,1,0,0,0,776,774,1,0,0,0,777,778,3,124,62,0,778,779,5,28, + 0,0,779,781,1,0,0,0,780,777,1,0,0,0,781,784,1,0,0,0,782,780,1,0,0,0,782, + 783,1,0,0,0,783,785,1,0,0,0,784,782,1,0,0,0,785,786,3,124,62,0,786,85, + 1,0,0,0,787,788,7,5,0,0,788,87,1,0,0,0,789,790,3,86,43,0,790,791,3,32, + 16,0,791,792,5,264,0,0,792,893,1,0,0,0,793,794,3,86,43,0,794,795,3,32, + 16,0,795,893,1,0,0,0,796,797,3,86,43,0,797,798,3,32,16,0,798,799,5,75, + 0,0,799,800,3,32,16,0,800,801,5,264,0,0,801,893,1,0,0,0,802,803,3,86,43, + 0,803,804,3,32,16,0,804,805,5,75,0,0,805,806,3,32,16,0,806,893,1,0,0,0, + 807,808,3,86,43,0,808,809,3,32,16,0,809,810,5,75,0,0,810,811,3,32,16,0, + 811,812,5,28,0,0,812,813,3,32,16,0,813,814,5,264,0,0,814,893,1,0,0,0,815, + 816,3,86,43,0,816,817,3,32,16,0,817,818,5,75,0,0,818,819,3,32,16,0,819, + 820,5,28,0,0,820,821,3,32,16,0,821,893,1,0,0,0,822,823,3,86,43,0,823,824, + 3,32,16,0,824,825,5,28,0,0,825,826,3,32,16,0,826,827,5,75,0,0,827,828, + 3,32,16,0,828,829,5,264,0,0,829,893,1,0,0,0,830,831,3,86,43,0,831,832, + 3,32,16,0,832,833,5,28,0,0,833,834,3,32,16,0,834,835,5,75,0,0,835,836, + 3,32,16,0,836,893,1,0,0,0,837,838,3,86,43,0,838,839,3,32,16,0,839,840, + 5,28,0,0,840,841,3,32,16,0,841,842,5,75,0,0,842,843,3,32,16,0,843,844, + 5,28,0,0,844,845,3,32,16,0,845,846,5,264,0,0,846,893,1,0,0,0,847,848,3, + 86,43,0,848,849,3,32,16,0,849,850,5,28,0,0,850,851,3,32,16,0,851,852,5, + 75,0,0,852,853,3,32,16,0,853,854,5,28,0,0,854,855,3,32,16,0,855,893,1, + 0,0,0,856,857,3,86,43,0,857,858,3,32,16,0,858,859,5,263,0,0,859,893,1, + 0,0,0,860,861,3,86,43,0,861,862,3,32,16,0,862,863,5,75,0,0,863,864,3,32, + 16,0,864,865,5,263,0,0,865,893,1,0,0,0,866,867,3,86,43,0,867,868,3,32, + 16,0,868,869,5,75,0,0,869,870,3,32,16,0,870,871,5,28,0,0,871,872,3,32, + 16,0,872,873,5,263,0,0,873,893,1,0,0,0,874,875,3,86,43,0,875,876,3,32, + 16,0,876,877,5,28,0,0,877,878,3,32,16,0,878,879,5,75,0,0,879,880,3,32, + 16,0,880,881,5,263,0,0,881,893,1,0,0,0,882,883,3,86,43,0,883,884,3,32, + 16,0,884,885,5,28,0,0,885,886,3,32,16,0,886,887,5,75,0,0,887,888,3,32, + 16,0,888,889,5,28,0,0,889,890,3,32,16,0,890,891,5,263,0,0,891,893,1,0, + 0,0,892,789,1,0,0,0,892,793,1,0,0,0,892,796,1,0,0,0,892,802,1,0,0,0,892, + 807,1,0,0,0,892,815,1,0,0,0,892,822,1,0,0,0,892,830,1,0,0,0,892,837,1, + 0,0,0,892,847,1,0,0,0,892,856,1,0,0,0,892,860,1,0,0,0,892,866,1,0,0,0, + 892,874,1,0,0,0,892,882,1,0,0,0,893,89,1,0,0,0,894,898,5,21,0,0,895,897, + 3,92,46,0,896,895,1,0,0,0,897,900,1,0,0,0,898,896,1,0,0,0,898,899,1,0, + 0,0,899,901,1,0,0,0,900,898,1,0,0,0,901,902,3,2,1,0,902,903,3,94,47,0, + 903,904,5,180,0,0,904,905,5,36,0,0,905,906,5,30,0,0,906,907,3,292,146, + 0,907,908,5,31,0,0,908,909,3,94,47,0,909,921,1,0,0,0,910,914,5,21,0,0, + 911,913,3,92,46,0,912,911,1,0,0,0,913,916,1,0,0,0,914,912,1,0,0,0,914, + 915,1,0,0,0,915,917,1,0,0,0,916,914,1,0,0,0,917,918,3,2,1,0,918,919,3, + 94,47,0,919,921,1,0,0,0,920,894,1,0,0,0,920,910,1,0,0,0,921,91,1,0,0,0, + 922,923,5,76,0,0,923,93,1,0,0,0,924,927,1,0,0,0,925,927,5,298,0,0,926, + 924,1,0,0,0,926,925,1,0,0,0,927,95,1,0,0,0,928,929,7,6,0,0,929,97,1,0, + 0,0,930,932,3,96,48,0,931,930,1,0,0,0,932,935,1,0,0,0,933,931,1,0,0,0, + 933,934,1,0,0,0,934,99,1,0,0,0,935,933,1,0,0,0,936,962,3,102,51,0,937, + 938,5,280,0,0,938,939,3,168,84,0,939,940,6,50,-1,0,940,962,1,0,0,0,941, + 942,5,286,0,0,942,943,3,178,89,0,943,944,6,50,-1,0,944,962,1,0,0,0,945, + 946,5,286,0,0,946,947,3,174,87,0,947,948,6,50,-1,0,948,962,1,0,0,0,949, + 950,5,284,0,0,950,951,3,124,62,0,951,952,6,50,-1,0,952,962,1,0,0,0,953, + 954,5,281,0,0,954,955,3,104,52,0,955,956,6,50,-1,0,956,962,1,0,0,0,957, + 958,5,287,0,0,958,959,3,50,25,0,959,960,6,50,-1,0,960,962,1,0,0,0,961, + 936,1,0,0,0,961,937,1,0,0,0,961,941,1,0,0,0,961,945,1,0,0,0,961,949,1, + 0,0,0,961,953,1,0,0,0,961,957,1,0,0,0,962,101,1,0,0,0,963,964,5,275,0, + 0,964,1042,6,51,-1,0,965,966,5,276,0,0,966,967,3,32,16,0,967,968,6,51, + -1,0,968,1042,1,0,0,0,969,970,5,276,0,0,970,971,3,0,0,0,971,972,6,51,-1, + 0,972,1042,1,0,0,0,973,974,5,277,0,0,974,975,3,32,16,0,975,976,6,51,-1, + 0,976,1042,1,0,0,0,977,978,5,278,0,0,978,979,3,34,17,0,979,980,6,51,-1, + 0,980,1042,1,0,0,0,981,982,5,279,0,0,982,983,3,36,18,0,983,984,6,51,-1, + 0,984,1042,1,0,0,0,985,986,5,279,0,0,986,987,3,34,17,0,987,988,6,51,-1, + 0,988,1042,1,0,0,0,989,990,5,279,0,0,990,991,5,30,0,0,991,992,3,292,146, + 0,992,993,5,31,0,0,993,994,6,51,-1,0,994,1042,1,0,0,0,995,996,5,279,0, + 0,996,997,5,84,0,0,997,998,5,30,0,0,998,999,3,292,146,0,999,1000,5,31, + 0,0,1000,1001,6,51,-1,0,1001,1042,1,0,0,0,1002,1003,5,282,0,0,1003,1004, + 3,32,16,0,1004,1005,6,51,-1,0,1005,1042,1,0,0,0,1006,1007,5,282,0,0,1007, + 1008,3,0,0,0,1008,1009,6,51,-1,0,1009,1042,1,0,0,0,1010,1011,5,285,0,0, + 1011,1012,3,6,3,0,1012,1013,6,51,-1,0,1013,1042,1,0,0,0,1014,1015,5,285, + 0,0,1015,1016,5,224,0,0,1016,1017,5,30,0,0,1017,1018,3,6,3,0,1018,1019, + 5,31,0,0,1019,1020,6,51,-1,0,1020,1042,1,0,0,0,1021,1022,5,285,0,0,1022, + 1023,5,84,0,0,1023,1024,5,30,0,0,1024,1025,3,292,146,0,1025,1026,5,31, + 0,0,1026,1027,6,51,-1,0,1027,1042,1,0,0,0,1028,1029,5,287,0,0,1029,1030, + 3,32,16,0,1030,1031,6,51,-1,0,1031,1042,1,0,0,0,1032,1033,5,283,0,0,1033, + 1039,6,51,-1,0,1034,1035,5,30,0,0,1035,1036,3,106,53,0,1036,1037,5,31, + 0,0,1037,1040,1,0,0,0,1038,1040,5,85,0,0,1039,1034,1,0,0,0,1039,1038,1, + 0,0,0,1040,1042,1,0,0,0,1041,963,1,0,0,0,1041,965,1,0,0,0,1041,969,1,0, + 0,0,1041,973,1,0,0,0,1041,977,1,0,0,0,1041,981,1,0,0,0,1041,985,1,0,0, + 0,1041,989,1,0,0,0,1041,995,1,0,0,0,1041,1002,1,0,0,0,1041,1006,1,0,0, + 0,1041,1010,1,0,0,0,1041,1014,1,0,0,0,1041,1021,1,0,0,0,1041,1028,1,0, + 0,0,1041,1032,1,0,0,0,1042,103,1,0,0,0,1043,1044,3,170,85,0,1044,1045, + 3,138,69,0,1045,1046,3,112,56,0,1046,105,1,0,0,0,1047,1072,1,0,0,0,1048, + 1049,3,0,0,0,1049,1050,6,53,-1,0,1050,1055,1,0,0,0,1051,1052,3,32,16,0, + 1052,1053,6,53,-1,0,1053,1055,1,0,0,0,1054,1048,1,0,0,0,1054,1051,1,0, + 0,0,1055,1056,1,0,0,0,1056,1057,5,28,0,0,1057,1059,1,0,0,0,1058,1054,1, + 0,0,0,1059,1062,1,0,0,0,1060,1058,1,0,0,0,1060,1061,1,0,0,0,1061,1069, + 1,0,0,0,1062,1060,1,0,0,0,1063,1064,3,0,0,0,1064,1065,6,53,-1,0,1065,1070, + 1,0,0,0,1066,1067,3,32,16,0,1067,1068,6,53,-1,0,1068,1070,1,0,0,0,1069, + 1063,1,0,0,0,1069,1066,1,0,0,0,1070,1072,1,0,0,0,1071,1047,1,0,0,0,1071, + 1060,1,0,0,0,1072,107,1,0,0,0,1073,1079,5,86,0,0,1074,1075,3,138,69,0, + 1075,1076,5,28,0,0,1076,1078,1,0,0,0,1077,1074,1,0,0,0,1078,1081,1,0,0, + 0,1079,1077,1,0,0,0,1079,1080,1,0,0,0,1080,1082,1,0,0,0,1081,1079,1,0, + 0,0,1082,1083,3,138,69,0,1083,1084,5,87,0,0,1084,109,1,0,0,0,1085,1091, + 5,42,0,0,1086,1087,3,146,73,0,1087,1088,5,28,0,0,1088,1090,1,0,0,0,1089, + 1086,1,0,0,0,1090,1093,1,0,0,0,1091,1089,1,0,0,0,1091,1092,1,0,0,0,1092, + 1094,1,0,0,0,1093,1091,1,0,0,0,1094,1095,3,146,73,0,1095,1096,5,43,0,0, + 1096,111,1,0,0,0,1097,1103,5,30,0,0,1098,1099,3,114,57,0,1099,1100,5,28, + 0,0,1100,1102,1,0,0,0,1101,1098,1,0,0,0,1102,1105,1,0,0,0,1103,1101,1, + 0,0,0,1103,1104,1,0,0,0,1104,1106,1,0,0,0,1105,1103,1,0,0,0,1106,1107, + 3,114,57,0,1107,1108,5,31,0,0,1108,1111,1,0,0,0,1109,1111,5,85,0,0,1110, + 1097,1,0,0,0,1110,1109,1,0,0,0,1111,113,1,0,0,0,1112,1120,5,177,0,0,1113, + 1114,3,230,115,0,1114,1115,3,138,69,0,1115,1117,3,226,113,0,1116,1118, + 3,0,0,0,1117,1116,1,0,0,0,1117,1118,1,0,0,0,1118,1120,1,0,0,0,1119,1112, + 1,0,0,0,1119,1113,1,0,0,0,1120,115,1,0,0,0,1121,1122,5,42,0,0,1122,1123, + 3,2,1,0,1123,1124,5,43,0,0,1124,1125,3,118,59,0,1125,1147,1,0,0,0,1126, + 1127,5,42,0,0,1127,1128,3,174,87,0,1128,1129,5,43,0,0,1129,1130,3,118, + 59,0,1130,1147,1,0,0,0,1131,1132,5,42,0,0,1132,1133,5,262,0,0,1133,1134, + 5,43,0,0,1134,1147,3,118,59,0,1135,1136,5,42,0,0,1136,1137,5,198,0,0,1137, + 1138,3,2,1,0,1138,1139,5,43,0,0,1139,1140,3,118,59,0,1140,1147,1,0,0,0, + 1141,1147,3,118,59,0,1142,1147,3,174,87,0,1143,1147,5,257,0,0,1144,1147, + 5,258,0,0,1145,1147,5,259,0,0,1146,1121,1,0,0,0,1146,1126,1,0,0,0,1146, + 1131,1,0,0,0,1146,1135,1,0,0,0,1146,1141,1,0,0,0,1146,1142,1,0,0,0,1146, + 1143,1,0,0,0,1146,1144,1,0,0,0,1146,1145,1,0,0,0,1147,117,1,0,0,0,1148, + 1149,3,2,1,0,1149,1150,5,88,0,0,1150,1152,1,0,0,0,1151,1148,1,0,0,0,1152, + 1155,1,0,0,0,1153,1151,1,0,0,0,1153,1154,1,0,0,0,1154,1156,1,0,0,0,1155, + 1153,1,0,0,0,1156,1157,3,2,1,0,1157,119,1,0,0,0,1158,1160,3,122,61,0,1159, + 1158,1,0,0,0,1160,1163,1,0,0,0,1161,1159,1,0,0,0,1161,1162,1,0,0,0,1162, + 121,1,0,0,0,1163,1161,1,0,0,0,1164,1165,5,180,0,0,1165,1166,5,89,0,0,1166, + 1170,3,32,16,0,1167,1170,3,152,76,0,1168,1170,3,324,162,0,1169,1164,1, + 0,0,0,1169,1167,1,0,0,0,1169,1168,1,0,0,0,1170,123,1,0,0,0,1171,1183,3, + 116,58,0,1172,1173,5,42,0,0,1173,1174,3,2,1,0,1174,1175,5,43,0,0,1175, + 1183,1,0,0,0,1176,1177,5,42,0,0,1177,1178,5,198,0,0,1178,1179,3,2,1,0, + 1179,1180,5,43,0,0,1180,1183,1,0,0,0,1181,1183,3,138,69,0,1182,1171,1, + 0,0,0,1182,1172,1,0,0,0,1182,1176,1,0,0,0,1182,1181,1,0,0,0,1183,125,1, + 0,0,0,1184,1193,1,0,0,0,1185,1189,3,130,65,0,1186,1188,3,128,64,0,1187, + 1186,1,0,0,0,1188,1191,1,0,0,0,1189,1187,1,0,0,0,1189,1190,1,0,0,0,1190, + 1193,1,0,0,0,1191,1189,1,0,0,0,1192,1184,1,0,0,0,1192,1185,1,0,0,0,1193, + 127,1,0,0,0,1194,1212,5,262,0,0,1195,1212,5,261,0,0,1196,1197,5,42,0,0, + 1197,1198,3,32,16,0,1198,1199,5,43,0,0,1199,1212,1,0,0,0,1200,1201,5,42, + 0,0,1201,1202,3,32,16,0,1202,1203,5,266,0,0,1203,1204,3,32,16,0,1204,1205, + 5,43,0,0,1205,1212,1,0,0,0,1206,1207,5,42,0,0,1207,1208,5,266,0,0,1208, + 1209,3,32,16,0,1209,1210,5,43,0,0,1210,1212,1,0,0,0,1211,1194,1,0,0,0, + 1211,1195,1,0,0,0,1211,1196,1,0,0,0,1211,1200,1,0,0,0,1211,1206,1,0,0, + 0,1212,129,1,0,0,0,1213,1306,1,0,0,0,1214,1215,5,203,0,0,1215,1216,5,30, + 0,0,1216,1217,3,6,3,0,1217,1218,5,28,0,0,1218,1219,3,6,3,0,1219,1220,5, + 28,0,0,1220,1221,3,6,3,0,1221,1222,5,28,0,0,1222,1223,3,6,3,0,1223,1224, + 5,31,0,0,1224,1306,1,0,0,0,1225,1226,5,203,0,0,1226,1227,5,30,0,0,1227, + 1228,3,6,3,0,1228,1229,5,28,0,0,1229,1230,3,6,3,0,1230,1231,5,31,0,0,1231, + 1306,1,0,0,0,1232,1233,5,204,0,0,1233,1234,5,205,0,0,1234,1235,5,42,0, + 0,1235,1236,3,32,16,0,1236,1237,5,43,0,0,1237,1306,1,0,0,0,1238,1239,5, + 204,0,0,1239,1240,5,206,0,0,1240,1241,5,42,0,0,1241,1242,3,32,16,0,1242, + 1243,5,43,0,0,1243,1244,3,126,63,0,1244,1306,1,0,0,0,1245,1306,5,207,0, + 0,1246,1306,5,208,0,0,1247,1306,5,209,0,0,1248,1306,5,201,0,0,1249,1306, + 5,183,0,0,1250,1306,5,184,0,0,1251,1306,5,185,0,0,1252,1306,5,186,0,0, + 1253,1306,5,187,0,0,1254,1306,5,188,0,0,1255,1306,5,189,0,0,1256,1306, + 5,210,0,0,1257,1306,5,190,0,0,1258,1306,5,191,0,0,1259,1306,5,192,0,0, + 1260,1306,5,193,0,0,1261,1306,5,211,0,0,1262,1306,5,212,0,0,1263,1306, + 5,213,0,0,1264,1306,5,214,0,0,1265,1306,5,215,0,0,1266,1306,5,216,0,0, + 1267,1306,5,217,0,0,1268,1269,5,218,0,0,1269,1306,3,132,66,0,1270,1271, + 5,219,0,0,1271,1306,3,132,66,0,1272,1306,5,220,0,0,1273,1274,5,221,0,0, + 1274,1306,3,132,66,0,1275,1276,5,222,0,0,1276,1306,3,134,67,0,1277,1278, + 5,222,0,0,1278,1279,3,134,67,0,1279,1280,5,28,0,0,1280,1281,3,6,3,0,1281, + 1306,1,0,0,0,1282,1306,5,194,0,0,1283,1306,5,195,0,0,1284,1285,5,90,0, + 0,1285,1306,5,184,0,0,1286,1287,5,90,0,0,1287,1306,5,185,0,0,1288,1289, + 5,90,0,0,1289,1306,5,186,0,0,1290,1291,5,90,0,0,1291,1306,5,187,0,0,1292, + 1293,5,62,0,0,1293,1306,5,220,0,0,1294,1306,5,223,0,0,1295,1296,5,224, + 0,0,1296,1306,5,213,0,0,1297,1306,5,225,0,0,1298,1299,5,207,0,0,1299,1306, + 5,183,0,0,1300,1306,5,226,0,0,1301,1306,5,228,0,0,1302,1303,5,34,0,0,1303, + 1306,5,227,0,0,1304,1306,3,2,1,0,1305,1213,1,0,0,0,1305,1214,1,0,0,0,1305, + 1225,1,0,0,0,1305,1232,1,0,0,0,1305,1238,1,0,0,0,1305,1245,1,0,0,0,1305, + 1246,1,0,0,0,1305,1247,1,0,0,0,1305,1248,1,0,0,0,1305,1249,1,0,0,0,1305, + 1250,1,0,0,0,1305,1251,1,0,0,0,1305,1252,1,0,0,0,1305,1253,1,0,0,0,1305, + 1254,1,0,0,0,1305,1255,1,0,0,0,1305,1256,1,0,0,0,1305,1257,1,0,0,0,1305, + 1258,1,0,0,0,1305,1259,1,0,0,0,1305,1260,1,0,0,0,1305,1261,1,0,0,0,1305, + 1262,1,0,0,0,1305,1263,1,0,0,0,1305,1264,1,0,0,0,1305,1265,1,0,0,0,1305, + 1266,1,0,0,0,1305,1267,1,0,0,0,1305,1268,1,0,0,0,1305,1270,1,0,0,0,1305, + 1272,1,0,0,0,1305,1273,1,0,0,0,1305,1275,1,0,0,0,1305,1277,1,0,0,0,1305, + 1282,1,0,0,0,1305,1283,1,0,0,0,1305,1284,1,0,0,0,1305,1286,1,0,0,0,1305, + 1288,1,0,0,0,1305,1290,1,0,0,0,1305,1292,1,0,0,0,1305,1294,1,0,0,0,1305, + 1295,1,0,0,0,1305,1297,1,0,0,0,1305,1298,1,0,0,0,1305,1300,1,0,0,0,1305, + 1301,1,0,0,0,1305,1302,1,0,0,0,1305,1304,1,0,0,0,1306,131,1,0,0,0,1307, + 1315,1,0,0,0,1308,1309,5,30,0,0,1309,1310,5,91,0,0,1310,1311,5,36,0,0, + 1311,1312,3,32,16,0,1312,1313,5,31,0,0,1313,1315,1,0,0,0,1314,1307,1,0, + 0,0,1314,1308,1,0,0,0,1315,133,1,0,0,0,1316,1325,1,0,0,0,1317,1321,3,136, + 68,0,1318,1320,7,7,0,0,1319,1318,1,0,0,0,1320,1323,1,0,0,0,1321,1319,1, + 0,0,0,1321,1322,1,0,0,0,1322,1325,1,0,0,0,1323,1321,1,0,0,0,1324,1316, + 1,0,0,0,1324,1317,1,0,0,0,1325,135,1,0,0,0,1326,1327,7,8,0,0,1327,137, + 1,0,0,0,1328,1332,3,142,71,0,1329,1331,3,140,70,0,1330,1329,1,0,0,0,1331, + 1334,1,0,0,0,1332,1330,1,0,0,0,1332,1333,1,0,0,0,1333,139,1,0,0,0,1334, + 1332,1,0,0,0,1335,1354,5,261,0,0,1336,1337,5,42,0,0,1337,1354,5,43,0,0, + 1338,1354,3,110,55,0,1339,1354,5,260,0,0,1340,1354,5,262,0,0,1341,1354, + 5,92,0,0,1342,1343,5,93,0,0,1343,1344,5,30,0,0,1344,1345,3,124,62,0,1345, + 1346,5,31,0,0,1346,1354,1,0,0,0,1347,1348,5,94,0,0,1348,1349,5,30,0,0, + 1349,1350,3,124,62,0,1350,1351,5,31,0,0,1351,1354,1,0,0,0,1352,1354,3, + 108,54,0,1353,1335,1,0,0,0,1353,1336,1,0,0,0,1353,1338,1,0,0,0,1353,1339, + 1,0,0,0,1353,1340,1,0,0,0,1353,1341,1,0,0,0,1353,1342,1,0,0,0,1353,1347, + 1,0,0,0,1353,1352,1,0,0,0,1354,141,1,0,0,0,1355,1356,5,39,0,0,1356,1386, + 3,116,58,0,1357,1386,5,197,0,0,1358,1359,5,199,0,0,1359,1360,5,39,0,0, + 1360,1386,3,116,58,0,1361,1362,5,200,0,0,1362,1386,3,116,58,0,1363,1364, + 5,226,0,0,1364,1365,3,170,85,0,1365,1366,3,138,69,0,1366,1367,5,262,0, + 0,1367,1368,3,112,56,0,1368,1386,1,0,0,0,1369,1370,5,253,0,0,1370,1386, + 3,32,16,0,1371,1372,5,252,0,0,1372,1386,3,32,16,0,1373,1374,5,253,0,0, + 1374,1386,3,2,1,0,1375,1376,5,252,0,0,1376,1386,3,2,1,0,1377,1386,5,254, + 0,0,1378,1386,5,201,0,0,1379,1386,3,148,74,0,1380,1386,3,150,75,0,1381, + 1386,3,144,72,0,1382,1386,3,2,1,0,1383,1384,5,177,0,0,1384,1386,3,138, + 69,0,1385,1355,1,0,0,0,1385,1357,1,0,0,0,1385,1358,1,0,0,0,1385,1361,1, + 0,0,0,1385,1363,1,0,0,0,1385,1369,1,0,0,0,1385,1371,1,0,0,0,1385,1373, + 1,0,0,0,1385,1375,1,0,0,0,1385,1377,1,0,0,0,1385,1378,1,0,0,0,1385,1379, + 1,0,0,0,1385,1380,1,0,0,0,1385,1381,1,0,0,0,1385,1382,1,0,0,0,1385,1383, + 1,0,0,0,1386,143,1,0,0,0,1387,1409,5,181,0,0,1388,1409,5,182,0,0,1389, + 1409,5,183,0,0,1390,1409,5,184,0,0,1391,1409,5,185,0,0,1392,1409,5,186, + 0,0,1393,1409,5,187,0,0,1394,1409,5,188,0,0,1395,1409,5,189,0,0,1396,1409, + 5,190,0,0,1397,1409,5,191,0,0,1398,1409,5,192,0,0,1399,1409,5,193,0,0, + 1400,1401,5,90,0,0,1401,1409,5,184,0,0,1402,1403,5,90,0,0,1403,1409,5, + 185,0,0,1404,1405,5,90,0,0,1405,1409,5,186,0,0,1406,1407,5,90,0,0,1407, + 1409,5,187,0,0,1408,1387,1,0,0,0,1408,1388,1,0,0,0,1408,1389,1,0,0,0,1408, + 1390,1,0,0,0,1408,1391,1,0,0,0,1408,1392,1,0,0,0,1408,1393,1,0,0,0,1408, + 1394,1,0,0,0,1408,1395,1,0,0,0,1408,1396,1,0,0,0,1408,1397,1,0,0,0,1408, + 1398,1,0,0,0,1408,1399,1,0,0,0,1408,1400,1,0,0,0,1408,1402,1,0,0,0,1408, + 1404,1,0,0,0,1408,1406,1,0,0,0,1409,145,1,0,0,0,1410,1421,1,0,0,0,1411, + 1421,5,177,0,0,1412,1421,3,32,16,0,1413,1414,3,32,16,0,1414,1415,5,177, + 0,0,1415,1416,3,32,16,0,1416,1421,1,0,0,0,1417,1418,3,32,16,0,1418,1419, + 5,177,0,0,1419,1421,1,0,0,0,1420,1410,1,0,0,0,1420,1411,1,0,0,0,1420,1412, + 1,0,0,0,1420,1413,1,0,0,0,1420,1417,1,0,0,0,1421,147,1,0,0,0,1422,1423, + 5,1,0,0,1423,1424,5,194,0,0,1424,149,1,0,0,0,1425,1429,5,1,0,0,1426,1427, + 5,90,0,0,1427,1430,5,194,0,0,1428,1430,5,195,0,0,1429,1426,1,0,0,0,1429, + 1428,1,0,0,0,1430,151,1,0,0,0,1431,1432,5,294,0,0,1432,1433,3,166,83,0, + 1433,1434,3,124,62,0,1434,1435,5,30,0,0,1435,1436,3,158,79,0,1436,1437, + 5,31,0,0,1437,1479,1,0,0,0,1438,1439,5,294,0,0,1439,1440,3,166,83,0,1440, + 1441,3,124,62,0,1441,1442,5,36,0,0,1442,1443,5,17,0,0,1443,1444,3,52,26, + 0,1444,1445,5,18,0,0,1445,1479,1,0,0,0,1446,1447,5,294,0,0,1447,1448,3, + 166,83,0,1448,1449,3,124,62,0,1449,1479,1,0,0,0,1450,1451,5,295,0,0,1451, + 1452,3,166,83,0,1452,1454,5,36,0,0,1453,1455,5,84,0,0,1454,1453,1,0,0, + 0,1454,1455,1,0,0,0,1455,1456,1,0,0,0,1456,1457,5,30,0,0,1457,1458,3,292, + 146,0,1458,1459,5,31,0,0,1459,1479,1,0,0,0,1460,1461,5,295,0,0,1461,1462, + 3,166,83,0,1462,1463,5,84,0,0,1463,1464,5,30,0,0,1464,1465,3,292,146,0, + 1465,1466,5,31,0,0,1466,1479,1,0,0,0,1467,1468,5,295,0,0,1468,1469,3,166, + 83,0,1469,1470,3,6,3,0,1470,1479,1,0,0,0,1471,1472,5,295,0,0,1472,1473, + 3,166,83,0,1473,1474,5,36,0,0,1474,1475,5,17,0,0,1475,1476,3,154,77,0, + 1476,1477,5,18,0,0,1477,1479,1,0,0,0,1478,1431,1,0,0,0,1478,1438,1,0,0, + 0,1478,1446,1,0,0,0,1478,1450,1,0,0,0,1478,1460,1,0,0,0,1478,1467,1,0, + 0,0,1478,1471,1,0,0,0,1479,153,1,0,0,0,1480,1491,1,0,0,0,1481,1482,3,156, + 78,0,1482,1483,5,28,0,0,1483,1485,1,0,0,0,1484,1481,1,0,0,0,1485,1488, + 1,0,0,0,1486,1484,1,0,0,0,1486,1487,1,0,0,0,1487,1489,1,0,0,0,1488,1486, + 1,0,0,0,1489,1491,3,156,78,0,1490,1480,1,0,0,0,1490,1486,1,0,0,0,1491, + 155,1,0,0,0,1492,1493,5,39,0,0,1493,1494,5,264,0,0,1494,1495,5,36,0,0, + 1495,1496,5,17,0,0,1496,1497,3,56,28,0,1497,1498,5,18,0,0,1498,1506,1, + 0,0,0,1499,1500,3,124,62,0,1500,1501,5,36,0,0,1501,1502,5,17,0,0,1502, + 1503,3,56,28,0,1503,1504,5,18,0,0,1504,1506,1,0,0,0,1505,1492,1,0,0,0, + 1505,1499,1,0,0,0,1506,157,1,0,0,0,1507,1508,3,160,80,0,1508,1509,5,28, + 0,0,1509,1511,1,0,0,0,1510,1507,1,0,0,0,1511,1514,1,0,0,0,1512,1510,1, + 0,0,0,1512,1513,1,0,0,0,1513,1515,1,0,0,0,1514,1512,1,0,0,0,1515,1516, + 3,160,80,0,1516,159,1,0,0,0,1517,1518,3,6,3,0,1518,1519,5,36,0,0,1519, + 1520,3,164,82,0,1520,161,1,0,0,0,1521,1522,7,9,0,0,1522,163,1,0,0,0,1523, + 1558,3,162,81,0,1524,1558,3,32,16,0,1525,1526,5,186,0,0,1526,1527,5,30, + 0,0,1527,1528,3,32,16,0,1528,1529,5,31,0,0,1529,1558,1,0,0,0,1530,1558, + 3,6,3,0,1531,1532,3,116,58,0,1532,1533,5,30,0,0,1533,1534,5,184,0,0,1534, + 1535,5,75,0,0,1535,1536,3,32,16,0,1536,1537,5,31,0,0,1537,1558,1,0,0,0, + 1538,1539,3,116,58,0,1539,1540,5,30,0,0,1540,1541,5,185,0,0,1541,1542, + 5,75,0,0,1542,1543,3,32,16,0,1543,1544,5,31,0,0,1544,1558,1,0,0,0,1545, + 1546,3,116,58,0,1546,1547,5,30,0,0,1547,1548,5,186,0,0,1548,1549,5,75, + 0,0,1549,1550,3,32,16,0,1550,1551,5,31,0,0,1551,1558,1,0,0,0,1552,1553, + 3,116,58,0,1553,1554,5,30,0,0,1554,1555,3,32,16,0,1555,1556,5,31,0,0,1556, + 1558,1,0,0,0,1557,1523,1,0,0,0,1557,1524,1,0,0,0,1557,1525,1,0,0,0,1557, + 1530,1,0,0,0,1557,1531,1,0,0,0,1557,1538,1,0,0,0,1557,1545,1,0,0,0,1557, + 1552,1,0,0,0,1558,165,1,0,0,0,1559,1560,7,10,0,0,1560,167,1,0,0,0,1561, + 1562,3,170,85,0,1562,1563,3,138,69,0,1563,1564,3,124,62,0,1564,1565,5, + 176,0,0,1565,1567,3,242,121,0,1566,1568,3,108,54,0,1567,1566,1,0,0,0,1567, + 1568,1,0,0,0,1568,1569,1,0,0,0,1569,1570,3,112,56,0,1570,1596,1,0,0,0, + 1571,1572,3,170,85,0,1572,1573,3,138,69,0,1573,1574,3,124,62,0,1574,1575, + 5,176,0,0,1575,1576,3,242,121,0,1576,1577,3,196,98,0,1577,1578,3,112,56, + 0,1578,1596,1,0,0,0,1579,1580,3,170,85,0,1580,1581,3,138,69,0,1581,1583, + 3,242,121,0,1582,1584,3,108,54,0,1583,1582,1,0,0,0,1583,1584,1,0,0,0,1584, + 1585,1,0,0,0,1585,1586,3,112,56,0,1586,1596,1,0,0,0,1587,1588,3,170,85, + 0,1588,1589,3,138,69,0,1589,1590,3,242,121,0,1590,1591,3,196,98,0,1591, + 1592,3,112,56,0,1592,1596,1,0,0,0,1593,1596,3,174,87,0,1594,1596,3,2,1, + 0,1595,1561,1,0,0,0,1595,1571,1,0,0,0,1595,1579,1,0,0,0,1595,1587,1,0, + 0,0,1595,1593,1,0,0,0,1595,1594,1,0,0,0,1596,169,1,0,0,0,1597,1598,5,243, + 0,0,1598,1608,3,170,85,0,1599,1600,5,244,0,0,1600,1608,3,170,85,0,1601, + 1608,3,172,86,0,1602,1603,5,112,0,0,1603,1604,5,30,0,0,1604,1605,3,32, + 16,0,1605,1606,5,31,0,0,1606,1608,1,0,0,0,1607,1597,1,0,0,0,1607,1599, + 1,0,0,0,1607,1601,1,0,0,0,1607,1602,1,0,0,0,1608,171,1,0,0,0,1609,1622, + 1,0,0,0,1610,1622,5,245,0,0,1611,1622,5,246,0,0,1612,1613,5,247,0,0,1613, + 1622,5,248,0,0,1614,1615,5,247,0,0,1615,1622,5,249,0,0,1616,1617,5,247, + 0,0,1617,1622,5,250,0,0,1618,1619,5,247,0,0,1619,1622,5,251,0,0,1620,1622, + 5,247,0,0,1621,1609,1,0,0,0,1621,1610,1,0,0,0,1621,1611,1,0,0,0,1621,1612, + 1,0,0,0,1621,1614,1,0,0,0,1621,1616,1,0,0,0,1621,1618,1,0,0,0,1621,1620, + 1,0,0,0,1622,173,1,0,0,0,1623,1624,5,113,0,0,1624,1625,5,30,0,0,1625,1626, + 3,32,16,0,1626,1627,5,31,0,0,1627,175,1,0,0,0,1628,1629,5,226,0,0,1629, + 1634,3,168,84,0,1630,1631,5,37,0,0,1631,1634,3,178,89,0,1632,1634,3,174, + 87,0,1633,1628,1,0,0,0,1633,1630,1,0,0,0,1633,1632,1,0,0,0,1634,177,1, + 0,0,0,1635,1636,3,138,69,0,1636,1637,3,124,62,0,1637,1638,5,176,0,0,1638, + 1639,3,2,1,0,1639,1645,1,0,0,0,1640,1641,3,138,69,0,1641,1642,3,2,1,0, + 1642,1645,1,0,0,0,1643,1645,3,2,1,0,1644,1635,1,0,0,0,1644,1640,1,0,0, + 0,1644,1643,1,0,0,0,1645,179,1,0,0,0,1646,1647,3,124,62,0,1647,1648,5, + 28,0,0,1648,1650,1,0,0,0,1649,1646,1,0,0,0,1650,1653,1,0,0,0,1651,1649, + 1,0,0,0,1651,1652,1,0,0,0,1652,1654,1,0,0,0,1653,1651,1,0,0,0,1654,1655, + 3,124,62,0,1655,181,1,0,0,0,1656,1662,1,0,0,0,1657,1658,5,86,0,0,1658, + 1659,3,190,95,0,1659,1660,5,87,0,0,1660,1662,1,0,0,0,1661,1656,1,0,0,0, + 1661,1657,1,0,0,0,1662,183,1,0,0,0,1663,1675,5,266,0,0,1664,1675,5,114, + 0,0,1665,1675,5,39,0,0,1666,1675,5,200,0,0,1667,1675,5,115,0,0,1668,1675, + 5,116,0,0,1669,1670,5,70,0,0,1670,1671,5,30,0,0,1671,1672,3,32,16,0,1672, + 1673,5,31,0,0,1673,1675,1,0,0,0,1674,1663,1,0,0,0,1674,1664,1,0,0,0,1674, + 1665,1,0,0,0,1674,1666,1,0,0,0,1674,1667,1,0,0,0,1674,1668,1,0,0,0,1674, + 1669,1,0,0,0,1675,185,1,0,0,0,1676,1678,3,184,92,0,1677,1676,1,0,0,0,1678, + 1681,1,0,0,0,1679,1677,1,0,0,0,1679,1680,1,0,0,0,1680,187,1,0,0,0,1681, + 1679,1,0,0,0,1682,1684,3,186,93,0,1683,1685,3,192,96,0,1684,1683,1,0,0, + 0,1684,1685,1,0,0,0,1685,1686,1,0,0,0,1686,1687,3,2,1,0,1687,189,1,0,0, + 0,1688,1689,3,188,94,0,1689,1690,5,28,0,0,1690,1692,1,0,0,0,1691,1688, + 1,0,0,0,1692,1695,1,0,0,0,1693,1691,1,0,0,0,1693,1694,1,0,0,0,1694,1696, + 1,0,0,0,1695,1693,1,0,0,0,1696,1697,3,188,94,0,1697,191,1,0,0,0,1698,1699, + 5,30,0,0,1699,1700,3,180,90,0,1700,1701,5,31,0,0,1701,193,1,0,0,0,1702, + 1705,1,0,0,0,1703,1705,3,196,98,0,1704,1702,1,0,0,0,1704,1703,1,0,0,0, + 1705,195,1,0,0,0,1706,1707,5,86,0,0,1707,1708,5,42,0,0,1708,1709,3,32, + 16,0,1709,1710,5,43,0,0,1710,1711,5,87,0,0,1711,197,1,0,0,0,1712,1713, + 3,234,117,0,1713,1714,5,17,0,0,1714,1715,3,246,123,0,1715,1716,5,18,0, + 0,1716,1829,1,0,0,0,1717,1718,3,74,37,0,1718,1719,5,17,0,0,1719,1720,3, + 82,41,0,1720,1721,5,18,0,0,1721,1829,1,0,0,0,1722,1723,3,210,105,0,1723, + 1724,5,17,0,0,1724,1725,3,214,107,0,1725,1726,5,18,0,0,1726,1829,1,0,0, + 0,1727,1728,3,218,109,0,1728,1729,5,17,0,0,1729,1730,3,222,111,0,1730, + 1731,5,18,0,0,1731,1829,1,0,0,0,1732,1829,3,200,100,0,1733,1829,3,276, + 138,0,1734,1829,3,152,76,0,1735,1829,3,88,44,0,1736,1829,3,322,161,0,1737, + 1738,5,117,0,0,1738,1829,3,32,16,0,1739,1740,5,118,0,0,1740,1829,3,32, + 16,0,1741,1742,3,334,167,0,1742,1743,5,17,0,0,1743,1744,3,338,169,0,1744, + 1745,5,18,0,0,1745,1829,1,0,0,0,1746,1747,5,302,0,0,1747,1748,3,124,62, + 0,1748,1749,5,176,0,0,1749,1750,3,242,121,0,1750,1751,5,119,0,0,1751,1752, + 3,170,85,0,1752,1753,3,138,69,0,1753,1754,3,124,62,0,1754,1755,5,176,0, + 0,1755,1756,3,242,121,0,1756,1757,3,112,56,0,1757,1829,1,0,0,0,1758,1759, + 5,302,0,0,1759,1760,5,226,0,0,1760,1761,3,170,85,0,1761,1762,3,138,69, + 0,1762,1763,3,124,62,0,1763,1764,5,176,0,0,1764,1765,3,242,121,0,1765, + 1766,3,194,97,0,1766,1767,3,112,56,0,1767,1768,5,119,0,0,1768,1769,5,226, + 0,0,1769,1770,3,170,85,0,1770,1771,3,138,69,0,1771,1772,3,124,62,0,1772, + 1773,5,176,0,0,1773,1774,3,242,121,0,1774,1775,3,194,97,0,1775,1776,3, + 112,56,0,1776,1829,1,0,0,0,1777,1829,3,26,13,0,1778,1829,3,40,20,0,1779, + 1780,5,255,0,0,1780,1781,5,196,0,0,1781,1782,5,42,0,0,1782,1783,3,32,16, + 0,1783,1787,5,43,0,0,1784,1786,3,322,161,0,1785,1784,1,0,0,0,1786,1789, + 1,0,0,0,1787,1785,1,0,0,0,1787,1788,1,0,0,0,1788,1829,1,0,0,0,1789,1787, + 1,0,0,0,1790,1791,5,255,0,0,1791,1792,5,196,0,0,1792,1796,3,2,1,0,1793, + 1795,3,322,161,0,1794,1793,1,0,0,0,1795,1798,1,0,0,0,1796,1794,1,0,0,0, + 1796,1797,1,0,0,0,1797,1829,1,0,0,0,1798,1796,1,0,0,0,1799,1800,5,255, + 0,0,1800,1801,5,256,0,0,1801,1802,5,42,0,0,1802,1803,3,32,16,0,1803,1804, + 5,43,0,0,1804,1805,5,28,0,0,1805,1809,3,124,62,0,1806,1808,3,322,161,0, + 1807,1806,1,0,0,0,1808,1811,1,0,0,0,1809,1807,1,0,0,0,1809,1810,1,0,0, + 0,1810,1829,1,0,0,0,1811,1809,1,0,0,0,1812,1813,5,255,0,0,1813,1814,5, + 256,0,0,1814,1815,3,2,1,0,1815,1816,5,28,0,0,1816,1820,3,124,62,0,1817, + 1819,3,322,161,0,1818,1817,1,0,0,0,1819,1822,1,0,0,0,1820,1818,1,0,0,0, + 1820,1821,1,0,0,0,1821,1829,1,0,0,0,1822,1820,1,0,0,0,1823,1824,5,120, + 0,0,1824,1825,5,196,0,0,1825,1826,3,124,62,0,1826,1827,3,44,22,0,1827, + 1829,1,0,0,0,1828,1712,1,0,0,0,1828,1717,1,0,0,0,1828,1722,1,0,0,0,1828, + 1727,1,0,0,0,1828,1732,1,0,0,0,1828,1733,1,0,0,0,1828,1734,1,0,0,0,1828, + 1735,1,0,0,0,1828,1736,1,0,0,0,1828,1737,1,0,0,0,1828,1739,1,0,0,0,1828, + 1741,1,0,0,0,1828,1746,1,0,0,0,1828,1758,1,0,0,0,1828,1777,1,0,0,0,1828, + 1778,1,0,0,0,1828,1779,1,0,0,0,1828,1790,1,0,0,0,1828,1799,1,0,0,0,1828, + 1812,1,0,0,0,1828,1823,1,0,0,0,1829,199,1,0,0,0,1830,1831,5,121,0,0,1831, + 1840,3,208,104,0,1832,1839,3,202,101,0,1833,1834,5,122,0,0,1834,1835,5, + 30,0,0,1835,1836,3,228,114,0,1836,1837,5,31,0,0,1837,1839,1,0,0,0,1838, + 1832,1,0,0,0,1838,1833,1,0,0,0,1839,1842,1,0,0,0,1840,1838,1,0,0,0,1840, + 1841,1,0,0,0,1841,1843,1,0,0,0,1842,1840,1,0,0,0,1843,1844,3,138,69,0, + 1844,1845,3,2,1,0,1845,1846,3,204,102,0,1846,1847,3,206,103,0,1847,201, + 1,0,0,0,1848,1868,5,123,0,0,1849,1868,5,51,0,0,1850,1868,5,52,0,0,1851, + 1868,5,63,0,0,1852,1868,5,124,0,0,1853,1868,5,69,0,0,1854,1868,5,68,0, + 0,1855,1868,5,64,0,0,1856,1868,5,65,0,0,1857,1868,5,66,0,0,1858,1868,5, + 125,0,0,1859,1868,5,126,0,0,1860,1868,5,127,0,0,1861,1868,5,16,0,0,1862, + 1863,5,70,0,0,1863,1864,5,30,0,0,1864,1865,3,32,16,0,1865,1866,5,31,0, + 0,1866,1868,1,0,0,0,1867,1848,1,0,0,0,1867,1849,1,0,0,0,1867,1850,1,0, + 0,0,1867,1851,1,0,0,0,1867,1852,1,0,0,0,1867,1853,1,0,0,0,1867,1854,1, + 0,0,0,1867,1855,1,0,0,0,1867,1856,1,0,0,0,1867,1857,1,0,0,0,1867,1858, + 1,0,0,0,1867,1859,1,0,0,0,1867,1860,1,0,0,0,1867,1861,1,0,0,0,1867,1862, + 1,0,0,0,1868,203,1,0,0,0,1869,1875,1,0,0,0,1870,1871,5,44,0,0,1871,1875, + 3,0,0,0,1872,1873,5,44,0,0,1873,1875,3,32,16,0,1874,1869,1,0,0,0,1874, + 1870,1,0,0,0,1874,1872,1,0,0,0,1875,205,1,0,0,0,1876,1880,1,0,0,0,1877, + 1878,5,36,0,0,1878,1880,3,296,148,0,1879,1876,1,0,0,0,1879,1877,1,0,0, + 0,1880,207,1,0,0,0,1881,1887,1,0,0,0,1882,1883,5,42,0,0,1883,1884,3,32, + 16,0,1884,1885,5,43,0,0,1885,1887,1,0,0,0,1886,1881,1,0,0,0,1886,1882, + 1,0,0,0,1887,209,1,0,0,0,1888,1892,5,128,0,0,1889,1891,3,212,106,0,1890, 1889,1,0,0,0,1891,1894,1,0,0,0,1892,1890,1,0,0,0,1892,1893,1,0,0,0,1893, - 1895,1,0,0,0,1894,1892,1,0,0,0,1895,1897,3,2,1,0,1896,1878,1,0,0,0,1896, - 1888,1,0,0,0,1897,211,1,0,0,0,1898,1899,7,11,0,0,1899,213,1,0,0,0,1900, - 1902,3,216,108,0,1901,1900,1,0,0,0,1902,1905,1,0,0,0,1903,1901,1,0,0,0, - 1903,1904,1,0,0,0,1904,215,1,0,0,0,1905,1903,1,0,0,0,1906,1907,5,129,0, - 0,1907,1919,3,168,84,0,1908,1909,5,130,0,0,1909,1919,3,168,84,0,1910,1911, - 5,131,0,0,1911,1919,3,168,84,0,1912,1913,5,132,0,0,1913,1919,3,168,84, - 0,1914,1919,3,88,44,0,1915,1919,3,322,161,0,1916,1919,3,26,13,0,1917,1919, - 3,40,20,0,1918,1906,1,0,0,0,1918,1908,1,0,0,0,1918,1910,1,0,0,0,1918,1912, - 1,0,0,0,1918,1914,1,0,0,0,1918,1915,1,0,0,0,1918,1916,1,0,0,0,1918,1917, - 1,0,0,0,1919,217,1,0,0,0,1920,1924,5,133,0,0,1921,1923,3,220,110,0,1922, - 1921,1,0,0,0,1923,1926,1,0,0,0,1924,1922,1,0,0,0,1924,1925,1,0,0,0,1925, - 1927,1,0,0,0,1926,1924,1,0,0,0,1927,1928,3,170,85,0,1928,1929,3,138,69, - 0,1929,1930,3,2,1,0,1930,1931,3,112,56,0,1931,1932,3,206,103,0,1932,219, - 1,0,0,0,1933,1934,7,11,0,0,1934,221,1,0,0,0,1935,1937,3,224,112,0,1936, - 1935,1,0,0,0,1937,1940,1,0,0,0,1938,1936,1,0,0,0,1938,1939,1,0,0,0,1939, - 223,1,0,0,0,1940,1938,1,0,0,0,1941,1942,5,134,0,0,1942,1952,3,168,84,0, - 1943,1944,5,135,0,0,1944,1952,3,168,84,0,1945,1946,5,132,0,0,1946,1952, - 3,168,84,0,1947,1952,3,322,161,0,1948,1952,3,88,44,0,1949,1952,3,26,13, - 0,1950,1952,3,40,20,0,1951,1941,1,0,0,0,1951,1943,1,0,0,0,1951,1945,1, - 0,0,0,1951,1947,1,0,0,0,1951,1948,1,0,0,0,1951,1949,1,0,0,0,1951,1950, - 1,0,0,0,1952,225,1,0,0,0,1953,1960,1,0,0,0,1954,1955,5,122,0,0,1955,1956, - 5,30,0,0,1956,1957,3,228,114,0,1957,1958,5,31,0,0,1958,1960,1,0,0,0,1959, - 1953,1,0,0,0,1959,1954,1,0,0,0,1960,227,1,0,0,0,1961,1971,3,126,63,0,1962, - 1964,5,17,0,0,1963,1965,3,294,147,0,1964,1963,1,0,0,0,1965,1966,1,0,0, - 0,1966,1964,1,0,0,0,1966,1967,1,0,0,0,1967,1968,1,0,0,0,1968,1969,5,18, - 0,0,1969,1971,1,0,0,0,1970,1961,1,0,0,0,1970,1962,1,0,0,0,1971,229,1,0, - 0,0,1972,1974,3,232,116,0,1973,1972,1,0,0,0,1974,1977,1,0,0,0,1975,1973, - 1,0,0,0,1975,1976,1,0,0,0,1976,231,1,0,0,0,1977,1975,1,0,0,0,1978,1979, - 5,42,0,0,1979,1980,5,136,0,0,1980,1992,5,43,0,0,1981,1982,5,42,0,0,1982, - 1983,5,137,0,0,1983,1992,5,43,0,0,1984,1985,5,42,0,0,1985,1986,5,138,0, - 0,1986,1992,5,43,0,0,1987,1988,5,42,0,0,1988,1989,3,32,16,0,1989,1990, - 5,43,0,0,1990,1992,1,0,0,0,1991,1978,1,0,0,0,1991,1981,1,0,0,0,1991,1984, - 1,0,0,0,1991,1987,1,0,0,0,1992,233,1,0,0,0,1993,1998,5,139,0,0,1994,1997, - 3,236,118,0,1995,1997,3,238,119,0,1996,1994,1,0,0,0,1996,1995,1,0,0,0, - 1997,2000,1,0,0,0,1998,1996,1,0,0,0,1998,1999,1,0,0,0,1999,2001,1,0,0, - 0,2000,1998,1,0,0,0,2001,2002,3,170,85,0,2002,2003,3,230,115,0,2003,2004, - 3,138,69,0,2004,2005,3,226,113,0,2005,2006,3,242,121,0,2006,2007,3,182, - 91,0,2007,2011,3,112,56,0,2008,2010,3,244,122,0,2009,2008,1,0,0,0,2010, - 2013,1,0,0,0,2011,2009,1,0,0,0,2011,2012,1,0,0,0,2012,235,1,0,0,0,2013, - 2011,1,0,0,0,2014,2038,5,123,0,0,2015,2038,5,51,0,0,2016,2038,5,52,0,0, - 2017,2038,5,63,0,0,2018,2038,5,140,0,0,2019,2038,5,68,0,0,2020,2038,5, - 141,0,0,2021,2038,5,142,0,0,2022,2038,5,54,0,0,2023,2038,5,64,0,0,2024, - 2038,5,65,0,0,2025,2038,5,66,0,0,2026,2038,5,125,0,0,2027,2038,5,143,0, - 0,2028,2038,5,144,0,0,2029,2038,5,69,0,0,2030,2038,5,145,0,0,2031,2038, - 5,146,0,0,2032,2033,5,70,0,0,2033,2034,5,30,0,0,2034,2035,3,32,16,0,2035, - 2036,5,31,0,0,2036,2038,1,0,0,0,2037,2014,1,0,0,0,2037,2015,1,0,0,0,2037, - 2016,1,0,0,0,2037,2017,1,0,0,0,2037,2018,1,0,0,0,2037,2019,1,0,0,0,2037, - 2020,1,0,0,0,2037,2021,1,0,0,0,2037,2022,1,0,0,0,2037,2023,1,0,0,0,2037, - 2024,1,0,0,0,2037,2025,1,0,0,0,2037,2026,1,0,0,0,2037,2027,1,0,0,0,2037, - 2028,1,0,0,0,2037,2029,1,0,0,0,2037,2030,1,0,0,0,2037,2031,1,0,0,0,2037, - 2032,1,0,0,0,2038,237,1,0,0,0,2039,2040,5,147,0,0,2040,2046,5,30,0,0,2041, - 2044,3,6,3,0,2042,2043,5,34,0,0,2043,2045,3,6,3,0,2044,2042,1,0,0,0,2044, - 2045,1,0,0,0,2045,2047,1,0,0,0,2046,2041,1,0,0,0,2046,2047,1,0,0,0,2047, - 2051,1,0,0,0,2048,2050,3,240,120,0,2049,2048,1,0,0,0,2050,2053,1,0,0,0, - 2051,2049,1,0,0,0,2051,2052,1,0,0,0,2052,2054,1,0,0,0,2053,2051,1,0,0, - 0,2054,2058,5,31,0,0,2055,2056,5,147,0,0,2056,2058,5,85,0,0,2057,2039, - 1,0,0,0,2057,2055,1,0,0,0,2058,239,1,0,0,0,2059,2087,5,148,0,0,2060,2087, - 5,224,0,0,2061,2087,5,57,0,0,2062,2087,5,58,0,0,2063,2087,5,149,0,0,2064, - 2087,5,150,0,0,2065,2087,5,248,0,0,2066,2087,5,249,0,0,2067,2087,5,250, - 0,0,2068,2087,5,251,0,0,2069,2070,5,151,0,0,2070,2071,5,75,0,0,2071,2087, - 5,152,0,0,2072,2073,5,151,0,0,2073,2074,5,75,0,0,2074,2087,5,153,0,0,2075, - 2076,5,154,0,0,2076,2077,5,75,0,0,2077,2087,5,152,0,0,2078,2079,5,154, - 0,0,2079,2080,5,75,0,0,2080,2087,5,153,0,0,2081,2082,5,70,0,0,2082,2083, - 5,30,0,0,2083,2084,3,32,16,0,2084,2085,5,31,0,0,2085,2087,1,0,0,0,2086, - 2059,1,0,0,0,2086,2060,1,0,0,0,2086,2061,1,0,0,0,2086,2062,1,0,0,0,2086, - 2063,1,0,0,0,2086,2064,1,0,0,0,2086,2065,1,0,0,0,2086,2066,1,0,0,0,2086, - 2067,1,0,0,0,2086,2068,1,0,0,0,2086,2069,1,0,0,0,2086,2072,1,0,0,0,2086, - 2075,1,0,0,0,2086,2078,1,0,0,0,2086,2081,1,0,0,0,2087,241,1,0,0,0,2088, - 2092,5,116,0,0,2089,2092,5,155,0,0,2090,2092,3,2,1,0,2091,2088,1,0,0,0, - 2091,2089,1,0,0,0,2091,2090,1,0,0,0,2092,243,1,0,0,0,2093,2115,5,1,0,0, - 2094,2115,5,2,0,0,2095,2115,5,156,0,0,2096,2115,5,3,0,0,2097,2115,5,4, - 0,0,2098,2115,5,247,0,0,2099,2115,5,5,0,0,2100,2115,5,6,0,0,2101,2115, - 5,7,0,0,2102,2115,5,8,0,0,2103,2115,5,9,0,0,2104,2115,5,10,0,0,2105,2115, - 5,11,0,0,2106,2115,5,12,0,0,2107,2115,5,13,0,0,2108,2115,5,14,0,0,2109, - 2110,5,70,0,0,2110,2111,5,30,0,0,2111,2112,3,32,16,0,2112,2113,5,31,0, - 0,2113,2115,1,0,0,0,2114,2093,1,0,0,0,2114,2094,1,0,0,0,2114,2095,1,0, - 0,0,2114,2096,1,0,0,0,2114,2097,1,0,0,0,2114,2098,1,0,0,0,2114,2099,1, - 0,0,0,2114,2100,1,0,0,0,2114,2101,1,0,0,0,2114,2102,1,0,0,0,2114,2103, - 1,0,0,0,2114,2104,1,0,0,0,2114,2105,1,0,0,0,2114,2106,1,0,0,0,2114,2107, - 1,0,0,0,2114,2108,1,0,0,0,2114,2109,1,0,0,0,2115,245,1,0,0,0,2116,2118, - 3,248,124,0,2117,2116,1,0,0,0,2118,2121,1,0,0,0,2119,2117,1,0,0,0,2119, - 2120,1,0,0,0,2120,247,1,0,0,0,2121,2119,1,0,0,0,2122,2140,3,100,50,0,2123, - 2124,5,296,0,0,2124,2125,3,32,16,0,2125,2126,6,124,-1,0,2126,2140,1,0, - 0,0,2127,2140,3,258,129,0,2128,2129,5,297,0,0,2129,2130,3,32,16,0,2130, - 2131,6,124,-1,0,2131,2140,1,0,0,0,2132,2133,5,298,0,0,2133,2140,6,124, - -1,0,2134,2135,5,299,0,0,2135,2140,6,124,-1,0,2136,2140,3,252,126,0,2137, - 2140,3,256,128,0,2138,2140,3,250,125,0,2139,2122,1,0,0,0,2139,2123,1,0, - 0,0,2139,2127,1,0,0,0,2139,2128,1,0,0,0,2139,2132,1,0,0,0,2139,2134,1, - 0,0,0,2139,2136,1,0,0,0,2139,2137,1,0,0,0,2139,2138,1,0,0,0,2140,249,1, - 0,0,0,2141,2142,5,300,0,0,2142,2240,3,112,56,0,2143,2144,5,300,0,0,2144, - 2145,5,157,0,0,2145,2240,3,112,56,0,2146,2240,3,276,138,0,2147,2240,3, - 152,76,0,2148,2240,3,88,44,0,2149,2240,3,26,13,0,2150,2240,3,254,127,0, - 2151,2240,3,40,20,0,2152,2153,5,301,0,0,2153,2154,5,42,0,0,2154,2155,3, - 32,16,0,2155,2156,5,43,0,0,2156,2240,1,0,0,0,2157,2158,5,301,0,0,2158, - 2159,5,42,0,0,2159,2160,3,32,16,0,2160,2161,5,43,0,0,2161,2162,5,34,0, - 0,2162,2163,3,0,0,0,2163,2240,1,0,0,0,2164,2165,5,303,0,0,2165,2166,3, - 32,16,0,2166,2167,5,75,0,0,2167,2168,3,32,16,0,2168,2240,1,0,0,0,2169, - 2170,5,302,0,0,2170,2171,3,124,62,0,2171,2172,5,176,0,0,2172,2173,3,242, - 121,0,2173,2240,1,0,0,0,2174,2175,5,302,0,0,2175,2176,5,226,0,0,2176,2177, - 3,170,85,0,2177,2178,3,138,69,0,2178,2179,3,124,62,0,2179,2180,5,176,0, - 0,2180,2181,3,242,121,0,2181,2182,3,194,97,0,2182,2183,3,112,56,0,2183, - 2240,1,0,0,0,2184,2185,5,255,0,0,2185,2186,5,196,0,0,2186,2187,5,42,0, - 0,2187,2188,3,32,16,0,2188,2192,5,43,0,0,2189,2191,3,322,161,0,2190,2189, - 1,0,0,0,2191,2194,1,0,0,0,2192,2190,1,0,0,0,2192,2193,1,0,0,0,2193,2240, - 1,0,0,0,2194,2192,1,0,0,0,2195,2196,5,255,0,0,2196,2197,5,196,0,0,2197, - 2201,3,2,1,0,2198,2200,3,322,161,0,2199,2198,1,0,0,0,2200,2203,1,0,0,0, - 2201,2199,1,0,0,0,2201,2202,1,0,0,0,2202,2240,1,0,0,0,2203,2201,1,0,0, - 0,2204,2205,5,255,0,0,2205,2206,5,256,0,0,2206,2207,5,42,0,0,2207,2208, - 3,32,16,0,2208,2209,5,43,0,0,2209,2210,5,28,0,0,2210,2214,3,124,62,0,2211, - 2213,3,322,161,0,2212,2211,1,0,0,0,2213,2216,1,0,0,0,2214,2212,1,0,0,0, - 2214,2215,1,0,0,0,2215,2240,1,0,0,0,2216,2214,1,0,0,0,2217,2218,5,255, - 0,0,2218,2219,5,256,0,0,2219,2220,3,2,1,0,2220,2221,5,28,0,0,2221,2225, - 3,124,62,0,2222,2224,3,322,161,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,2240,1,0,0,0,2227,2225,1,0,0,0,2228, - 2229,5,255,0,0,2229,2230,5,42,0,0,2230,2231,3,32,16,0,2231,2232,5,43,0, - 0,2232,2236,3,206,103,0,2233,2235,3,322,161,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,2240,1,0,0,0,2238,2236, - 1,0,0,0,2239,2141,1,0,0,0,2239,2143,1,0,0,0,2239,2146,1,0,0,0,2239,2147, - 1,0,0,0,2239,2148,1,0,0,0,2239,2149,1,0,0,0,2239,2150,1,0,0,0,2239,2151, - 1,0,0,0,2239,2152,1,0,0,0,2239,2157,1,0,0,0,2239,2164,1,0,0,0,2239,2169, - 1,0,0,0,2239,2174,1,0,0,0,2239,2184,1,0,0,0,2239,2195,1,0,0,0,2239,2204, - 1,0,0,0,2239,2217,1,0,0,0,2239,2228,1,0,0,0,2240,251,1,0,0,0,2241,2242, - 3,0,0,0,2242,2243,5,75,0,0,2243,2244,6,126,-1,0,2244,253,1,0,0,0,2245, - 2248,3,44,22,0,2246,2248,3,46,23,0,2247,2245,1,0,0,0,2247,2246,1,0,0,0, - 2248,255,1,0,0,0,2249,2250,5,17,0,0,2250,2251,3,246,123,0,2251,2252,5, - 18,0,0,2252,257,1,0,0,0,2253,2254,3,262,131,0,2254,2255,3,260,130,0,2255, - 259,1,0,0,0,2256,2258,3,264,132,0,2257,2256,1,0,0,0,2258,2259,1,0,0,0, - 2259,2257,1,0,0,0,2259,2260,1,0,0,0,2260,261,1,0,0,0,2261,2262,5,158,0, - 0,2262,2274,3,256,128,0,2263,2264,5,158,0,0,2264,2265,3,0,0,0,2265,2266, - 5,159,0,0,2266,2267,3,0,0,0,2267,2274,1,0,0,0,2268,2269,5,158,0,0,2269, - 2270,3,32,16,0,2270,2271,5,159,0,0,2271,2272,3,32,16,0,2272,2274,1,0,0, - 0,2273,2261,1,0,0,0,2273,2263,1,0,0,0,2273,2268,1,0,0,0,2274,263,1,0,0, - 0,2275,2276,3,268,134,0,2276,2277,3,274,137,0,2277,2288,1,0,0,0,2278,2279, - 3,266,133,0,2279,2280,3,274,137,0,2280,2288,1,0,0,0,2281,2282,3,270,135, - 0,2282,2283,3,274,137,0,2283,2288,1,0,0,0,2284,2285,3,272,136,0,2285,2286, - 3,274,137,0,2286,2288,1,0,0,0,2287,2275,1,0,0,0,2287,2278,1,0,0,0,2287, - 2281,1,0,0,0,2287,2284,1,0,0,0,2288,265,1,0,0,0,2289,2290,5,160,0,0,2290, - 2296,3,256,128,0,2291,2292,5,160,0,0,2292,2296,3,0,0,0,2293,2294,5,160, - 0,0,2294,2296,3,32,16,0,2295,2289,1,0,0,0,2295,2291,1,0,0,0,2295,2293, - 1,0,0,0,2296,267,1,0,0,0,2297,2298,5,161,0,0,2298,2299,3,124,62,0,2299, - 269,1,0,0,0,2300,2301,5,162,0,0,2301,271,1,0,0,0,2302,2303,5,163,0,0,2303, - 273,1,0,0,0,2304,2316,3,256,128,0,2305,2306,5,164,0,0,2306,2307,3,0,0, - 0,2307,2308,5,159,0,0,2308,2309,3,0,0,0,2309,2316,1,0,0,0,2310,2311,5, - 164,0,0,2311,2312,3,32,16,0,2312,2313,5,159,0,0,2313,2314,3,32,16,0,2314, - 2316,1,0,0,0,2315,2304,1,0,0,0,2315,2305,1,0,0,0,2315,2310,1,0,0,0,2316, - 275,1,0,0,0,2317,2318,3,278,139,0,2318,2319,3,282,141,0,2319,277,1,0,0, - 0,2320,2321,5,165,0,0,2321,2322,3,280,140,0,2322,2323,3,0,0,0,2323,2324, - 5,36,0,0,2324,2328,1,0,0,0,2325,2326,5,165,0,0,2326,2328,3,280,140,0,2327, - 2320,1,0,0,0,2327,2325,1,0,0,0,2328,279,1,0,0,0,2329,2333,1,0,0,0,2330, - 2333,5,166,0,0,2331,2333,5,2,0,0,2332,2329,1,0,0,0,2332,2330,1,0,0,0,2332, - 2331,1,0,0,0,2333,281,1,0,0,0,2334,2335,5,17,0,0,2335,2336,3,284,142,0, - 2336,2337,5,18,0,0,2337,2344,1,0,0,0,2338,2340,3,288,144,0,2339,2338,1, - 0,0,0,2340,2341,1,0,0,0,2341,2339,1,0,0,0,2341,2342,1,0,0,0,2342,2344, - 1,0,0,0,2343,2334,1,0,0,0,2343,2339,1,0,0,0,2344,283,1,0,0,0,2345,2346, - 3,288,144,0,2346,2347,5,28,0,0,2347,2349,1,0,0,0,2348,2345,1,0,0,0,2349, - 2352,1,0,0,0,2350,2348,1,0,0,0,2350,2351,1,0,0,0,2351,2353,1,0,0,0,2352, - 2350,1,0,0,0,2353,2354,3,288,144,0,2354,285,1,0,0,0,2355,2361,1,0,0,0, - 2356,2357,5,42,0,0,2357,2358,3,32,16,0,2358,2359,5,43,0,0,2359,2361,1, - 0,0,0,2360,2355,1,0,0,0,2360,2356,1,0,0,0,2361,287,1,0,0,0,2362,2363,5, - 181,0,0,2363,2364,5,262,0,0,2364,2365,5,30,0,0,2365,2366,3,6,3,0,2366, - 2367,5,31,0,0,2367,2429,1,0,0,0,2368,2369,5,260,0,0,2369,2370,5,30,0,0, - 2370,2371,3,0,0,0,2371,2372,5,31,0,0,2372,2429,1,0,0,0,2373,2374,5,260, - 0,0,2374,2429,3,0,0,0,2375,2376,5,84,0,0,2376,2377,5,30,0,0,2377,2378, - 3,292,146,0,2378,2379,5,31,0,0,2379,2429,1,0,0,0,2380,2381,5,188,0,0,2381, - 2382,5,30,0,0,2382,2383,3,36,18,0,2383,2384,5,31,0,0,2384,2385,3,286,143, - 0,2385,2429,1,0,0,0,2386,2387,5,189,0,0,2387,2388,5,30,0,0,2388,2389,3, - 36,18,0,2389,2390,5,31,0,0,2390,2391,3,286,143,0,2391,2429,1,0,0,0,2392, - 2393,5,187,0,0,2393,2394,5,30,0,0,2394,2395,3,34,17,0,2395,2396,5,31,0, - 0,2396,2397,3,286,143,0,2397,2429,1,0,0,0,2398,2399,5,186,0,0,2399,2400, - 5,30,0,0,2400,2401,3,32,16,0,2401,2402,5,31,0,0,2402,2403,3,286,143,0, - 2403,2429,1,0,0,0,2404,2405,5,185,0,0,2405,2406,5,30,0,0,2406,2407,3,32, - 16,0,2407,2408,5,31,0,0,2408,2409,3,286,143,0,2409,2429,1,0,0,0,2410,2411, - 5,184,0,0,2411,2412,5,30,0,0,2412,2413,3,32,16,0,2413,2414,5,31,0,0,2414, - 2415,3,286,143,0,2415,2429,1,0,0,0,2416,2417,5,188,0,0,2417,2429,3,286, - 143,0,2418,2419,5,189,0,0,2419,2429,3,286,143,0,2420,2421,5,187,0,0,2421, - 2429,3,286,143,0,2422,2423,5,186,0,0,2423,2429,3,286,143,0,2424,2425,5, - 185,0,0,2425,2429,3,286,143,0,2426,2427,5,184,0,0,2427,2429,3,286,143, - 0,2428,2362,1,0,0,0,2428,2368,1,0,0,0,2428,2373,1,0,0,0,2428,2375,1,0, - 0,0,2428,2380,1,0,0,0,2428,2386,1,0,0,0,2428,2392,1,0,0,0,2428,2398,1, - 0,0,0,2428,2404,1,0,0,0,2428,2410,1,0,0,0,2428,2416,1,0,0,0,2428,2418, - 1,0,0,0,2428,2420,1,0,0,0,2428,2422,1,0,0,0,2428,2424,1,0,0,0,2428,2426, - 1,0,0,0,2429,289,1,0,0,0,2430,2431,5,188,0,0,2431,2432,5,30,0,0,2432,2433, - 3,36,18,0,2433,2434,5,31,0,0,2434,2506,1,0,0,0,2435,2436,5,189,0,0,2436, - 2437,5,30,0,0,2437,2438,3,36,18,0,2438,2439,5,31,0,0,2439,2506,1,0,0,0, - 2440,2441,5,188,0,0,2441,2442,5,30,0,0,2442,2443,3,32,16,0,2443,2444,5, - 31,0,0,2444,2506,1,0,0,0,2445,2446,5,189,0,0,2446,2447,5,30,0,0,2447,2448, - 3,34,17,0,2448,2449,5,31,0,0,2449,2506,1,0,0,0,2450,2451,5,187,0,0,2451, - 2452,5,30,0,0,2452,2453,3,34,17,0,2453,2454,5,31,0,0,2454,2506,1,0,0,0, - 2455,2456,5,186,0,0,2456,2457,5,30,0,0,2457,2458,3,32,16,0,2458,2459,5, - 31,0,0,2459,2506,1,0,0,0,2460,2461,5,185,0,0,2461,2462,5,30,0,0,2462,2463, - 3,32,16,0,2463,2464,5,31,0,0,2464,2506,1,0,0,0,2465,2466,5,184,0,0,2466, - 2467,5,30,0,0,2467,2468,3,32,16,0,2468,2469,5,31,0,0,2469,2506,1,0,0,0, - 2470,2471,5,193,0,0,2471,2472,5,30,0,0,2472,2473,3,34,17,0,2473,2474,5, - 31,0,0,2474,2506,1,0,0,0,2475,2476,5,192,0,0,2476,2477,5,30,0,0,2477,2478, - 3,32,16,0,2478,2479,5,31,0,0,2479,2506,1,0,0,0,2480,2481,5,191,0,0,2481, - 2482,5,30,0,0,2482,2483,3,32,16,0,2483,2484,5,31,0,0,2484,2506,1,0,0,0, - 2485,2486,5,190,0,0,2486,2487,5,30,0,0,2487,2488,3,32,16,0,2488,2489,5, - 31,0,0,2489,2506,1,0,0,0,2490,2491,5,181,0,0,2491,2492,5,30,0,0,2492,2493, - 3,32,16,0,2493,2494,5,31,0,0,2494,2506,1,0,0,0,2495,2496,5,183,0,0,2496, - 2497,5,30,0,0,2497,2498,3,162,81,0,2498,2499,5,31,0,0,2499,2506,1,0,0, - 0,2500,2501,5,84,0,0,2501,2502,5,30,0,0,2502,2503,3,292,146,0,2503,2504, - 5,31,0,0,2504,2506,1,0,0,0,2505,2430,1,0,0,0,2505,2435,1,0,0,0,2505,2440, - 1,0,0,0,2505,2445,1,0,0,0,2505,2450,1,0,0,0,2505,2455,1,0,0,0,2505,2460, - 1,0,0,0,2505,2465,1,0,0,0,2505,2470,1,0,0,0,2505,2475,1,0,0,0,2505,2480, - 1,0,0,0,2505,2485,1,0,0,0,2505,2490,1,0,0,0,2505,2495,1,0,0,0,2505,2500, - 1,0,0,0,2506,291,1,0,0,0,2507,2508,3,294,147,0,2508,2509,6,146,-1,0,2509, - 2511,1,0,0,0,2510,2507,1,0,0,0,2511,2514,1,0,0,0,2512,2510,1,0,0,0,2512, - 2513,1,0,0,0,2513,293,1,0,0,0,2514,2512,1,0,0,0,2515,2516,7,12,0,0,2516, - 295,1,0,0,0,2517,2521,3,290,145,0,2518,2521,3,6,3,0,2519,2521,5,179,0, - 0,2520,2517,1,0,0,0,2520,2518,1,0,0,0,2520,2519,1,0,0,0,2521,297,1,0,0, - 0,2522,2671,3,290,145,0,2523,2524,5,182,0,0,2524,2525,5,30,0,0,2525,2526, - 5,179,0,0,2526,2671,5,31,0,0,2527,2528,5,182,0,0,2528,2529,5,30,0,0,2529, - 2530,5,264,0,0,2530,2671,5,31,0,0,2531,2532,5,196,0,0,2532,2533,5,30,0, - 0,2533,2534,5,39,0,0,2534,2535,5,264,0,0,2535,2671,5,31,0,0,2536,2537, - 5,196,0,0,2537,2538,5,30,0,0,2538,2539,3,116,58,0,2539,2540,5,31,0,0,2540, - 2671,1,0,0,0,2541,2542,5,196,0,0,2542,2543,5,30,0,0,2543,2544,5,179,0, - 0,2544,2671,5,31,0,0,2545,2546,5,197,0,0,2546,2547,5,30,0,0,2547,2548, - 3,298,149,0,2548,2549,5,31,0,0,2549,2671,1,0,0,0,2550,2551,5,188,0,0,2551, - 2552,5,42,0,0,2552,2553,3,32,16,0,2553,2554,5,43,0,0,2554,2555,5,30,0, - 0,2555,2556,3,300,150,0,2556,2557,5,31,0,0,2557,2671,1,0,0,0,2558,2559, - 5,189,0,0,2559,2560,5,42,0,0,2560,2561,3,32,16,0,2561,2562,5,43,0,0,2562, - 2563,5,30,0,0,2563,2564,3,302,151,0,2564,2565,5,31,0,0,2565,2671,1,0,0, - 0,2566,2567,5,187,0,0,2567,2568,5,42,0,0,2568,2569,3,32,16,0,2569,2570, - 5,43,0,0,2570,2571,5,30,0,0,2571,2572,3,304,152,0,2572,2573,5,31,0,0,2573, - 2671,1,0,0,0,2574,2575,5,186,0,0,2575,2576,5,42,0,0,2576,2577,3,32,16, - 0,2577,2578,5,43,0,0,2578,2579,5,30,0,0,2579,2580,3,306,153,0,2580,2581, - 5,31,0,0,2581,2671,1,0,0,0,2582,2583,5,185,0,0,2583,2584,5,42,0,0,2584, - 2585,3,32,16,0,2585,2586,5,43,0,0,2586,2587,5,30,0,0,2587,2588,3,308,154, - 0,2588,2589,5,31,0,0,2589,2671,1,0,0,0,2590,2591,5,184,0,0,2591,2592,5, - 42,0,0,2592,2593,3,32,16,0,2593,2594,5,43,0,0,2594,2595,5,30,0,0,2595, - 2596,3,310,155,0,2596,2597,5,31,0,0,2597,2671,1,0,0,0,2598,2599,5,193, - 0,0,2599,2600,5,42,0,0,2600,2601,3,32,16,0,2601,2602,5,43,0,0,2602,2603, - 5,30,0,0,2603,2604,3,304,152,0,2604,2605,5,31,0,0,2605,2671,1,0,0,0,2606, - 2607,5,192,0,0,2607,2608,5,42,0,0,2608,2609,3,32,16,0,2609,2610,5,43,0, - 0,2610,2611,5,30,0,0,2611,2612,3,306,153,0,2612,2613,5,31,0,0,2613,2671, - 1,0,0,0,2614,2615,5,191,0,0,2615,2616,5,42,0,0,2616,2617,3,32,16,0,2617, - 2618,5,43,0,0,2618,2619,5,30,0,0,2619,2620,3,308,154,0,2620,2621,5,31, - 0,0,2621,2671,1,0,0,0,2622,2623,5,190,0,0,2623,2624,5,42,0,0,2624,2625, - 3,32,16,0,2625,2626,5,43,0,0,2626,2627,5,30,0,0,2627,2628,3,310,155,0, - 2628,2629,5,31,0,0,2629,2671,1,0,0,0,2630,2631,5,181,0,0,2631,2632,5,42, - 0,0,2632,2633,3,32,16,0,2633,2634,5,43,0,0,2634,2635,5,30,0,0,2635,2636, - 3,308,154,0,2636,2637,5,31,0,0,2637,2671,1,0,0,0,2638,2639,5,183,0,0,2639, - 2640,5,42,0,0,2640,2641,3,32,16,0,2641,2642,5,43,0,0,2642,2643,5,30,0, - 0,2643,2644,3,312,156,0,2644,2645,5,31,0,0,2645,2671,1,0,0,0,2646,2647, - 5,182,0,0,2647,2648,5,42,0,0,2648,2649,3,32,16,0,2649,2650,5,43,0,0,2650, - 2651,5,30,0,0,2651,2652,3,314,157,0,2652,2653,5,31,0,0,2653,2671,1,0,0, - 0,2654,2655,5,196,0,0,2655,2656,5,42,0,0,2656,2657,3,32,16,0,2657,2658, - 5,43,0,0,2658,2659,5,30,0,0,2659,2660,3,316,158,0,2660,2661,5,31,0,0,2661, - 2671,1,0,0,0,2662,2663,5,197,0,0,2663,2664,5,42,0,0,2664,2665,3,32,16, - 0,2665,2666,5,43,0,0,2666,2667,5,30,0,0,2667,2668,3,320,160,0,2668,2669, - 5,31,0,0,2669,2671,1,0,0,0,2670,2522,1,0,0,0,2670,2523,1,0,0,0,2670,2527, - 1,0,0,0,2670,2531,1,0,0,0,2670,2536,1,0,0,0,2670,2541,1,0,0,0,2670,2545, - 1,0,0,0,2670,2550,1,0,0,0,2670,2558,1,0,0,0,2670,2566,1,0,0,0,2670,2574, - 1,0,0,0,2670,2582,1,0,0,0,2670,2590,1,0,0,0,2670,2598,1,0,0,0,2670,2606, - 1,0,0,0,2670,2614,1,0,0,0,2670,2622,1,0,0,0,2670,2630,1,0,0,0,2670,2638, - 1,0,0,0,2670,2646,1,0,0,0,2670,2654,1,0,0,0,2670,2662,1,0,0,0,2671,299, - 1,0,0,0,2672,2675,3,36,18,0,2673,2675,3,32,16,0,2674,2672,1,0,0,0,2674, - 2673,1,0,0,0,2675,2678,1,0,0,0,2676,2674,1,0,0,0,2676,2677,1,0,0,0,2677, - 301,1,0,0,0,2678,2676,1,0,0,0,2679,2682,3,36,18,0,2680,2682,3,34,17,0, - 2681,2679,1,0,0,0,2681,2680,1,0,0,0,2682,2685,1,0,0,0,2683,2681,1,0,0, - 0,2683,2684,1,0,0,0,2684,303,1,0,0,0,2685,2683,1,0,0,0,2686,2688,3,34, - 17,0,2687,2686,1,0,0,0,2688,2691,1,0,0,0,2689,2687,1,0,0,0,2689,2690,1, - 0,0,0,2690,305,1,0,0,0,2691,2689,1,0,0,0,2692,2694,3,32,16,0,2693,2692, - 1,0,0,0,2694,2697,1,0,0,0,2695,2693,1,0,0,0,2695,2696,1,0,0,0,2696,307, - 1,0,0,0,2697,2695,1,0,0,0,2698,2700,3,32,16,0,2699,2698,1,0,0,0,2700,2703, - 1,0,0,0,2701,2699,1,0,0,0,2701,2702,1,0,0,0,2702,309,1,0,0,0,2703,2701, - 1,0,0,0,2704,2706,3,32,16,0,2705,2704,1,0,0,0,2706,2709,1,0,0,0,2707,2705, - 1,0,0,0,2707,2708,1,0,0,0,2708,311,1,0,0,0,2709,2707,1,0,0,0,2710,2712, - 3,162,81,0,2711,2710,1,0,0,0,2712,2715,1,0,0,0,2713,2711,1,0,0,0,2713, - 2714,1,0,0,0,2714,313,1,0,0,0,2715,2713,1,0,0,0,2716,2718,7,13,0,0,2717, - 2716,1,0,0,0,2718,2721,1,0,0,0,2719,2717,1,0,0,0,2719,2720,1,0,0,0,2720, - 315,1,0,0,0,2721,2719,1,0,0,0,2722,2724,3,318,159,0,2723,2722,1,0,0,0, - 2724,2727,1,0,0,0,2725,2723,1,0,0,0,2725,2726,1,0,0,0,2726,317,1,0,0,0, - 2727,2725,1,0,0,0,2728,2733,5,179,0,0,2729,2730,5,39,0,0,2730,2733,5,264, - 0,0,2731,2733,3,116,58,0,2732,2728,1,0,0,0,2732,2729,1,0,0,0,2732,2731, - 1,0,0,0,2733,319,1,0,0,0,2734,2736,3,298,149,0,2735,2734,1,0,0,0,2736, - 2739,1,0,0,0,2737,2735,1,0,0,0,2737,2738,1,0,0,0,2738,321,1,0,0,0,2739, - 2737,1,0,0,0,2740,2744,3,44,22,0,2741,2744,3,46,23,0,2742,2744,3,2,1,0, - 2743,2740,1,0,0,0,2743,2741,1,0,0,0,2743,2742,1,0,0,0,2744,323,1,0,0,0, - 2745,2746,7,14,0,0,2746,2747,5,36,0,0,2747,2748,5,30,0,0,2748,2749,3,292, - 146,0,2749,2750,5,31,0,0,2750,2771,1,0,0,0,2751,2752,5,169,0,0,2752,2753, - 3,38,19,0,2753,2754,5,75,0,0,2754,2755,3,38,19,0,2755,2756,5,75,0,0,2756, - 2757,3,38,19,0,2757,2758,5,75,0,0,2758,2759,3,38,19,0,2759,2771,1,0,0, - 0,2760,2761,5,170,0,0,2761,2771,3,6,3,0,2762,2763,5,170,0,0,2763,2764, - 5,36,0,0,2764,2765,5,30,0,0,2765,2766,3,292,146,0,2766,2767,5,31,0,0,2767, - 2771,1,0,0,0,2768,2771,3,322,161,0,2769,2771,3,40,20,0,2770,2745,1,0,0, - 0,2770,2751,1,0,0,0,2770,2760,1,0,0,0,2770,2762,1,0,0,0,2770,2768,1,0, - 0,0,2770,2769,1,0,0,0,2771,325,1,0,0,0,2772,2773,5,25,0,0,2773,2774,5, - 40,0,0,2774,2775,3,98,49,0,2775,2776,3,2,1,0,2776,2785,1,0,0,0,2777,2778, - 5,25,0,0,2778,2779,5,40,0,0,2779,2780,3,98,49,0,2780,2781,3,2,1,0,2781, - 2782,5,34,0,0,2782,2783,3,2,1,0,2783,2785,1,0,0,0,2784,2772,1,0,0,0,2784, - 2777,1,0,0,0,2785,327,1,0,0,0,2786,2788,3,330,165,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,329,1,0,0,0, - 2791,2789,1,0,0,0,2792,2793,5,180,0,0,2793,2794,5,36,0,0,2794,2795,5,30, - 0,0,2795,2796,3,292,146,0,2796,2797,5,31,0,0,2797,2807,1,0,0,0,2798,2807, - 3,324,162,0,2799,2800,5,171,0,0,2800,2801,5,36,0,0,2801,2802,5,30,0,0, - 2802,2803,3,292,146,0,2803,2804,5,31,0,0,2804,2807,1,0,0,0,2805,2807,5, - 55,0,0,2806,2792,1,0,0,0,2806,2798,1,0,0,0,2806,2799,1,0,0,0,2806,2805, - 1,0,0,0,2807,331,1,0,0,0,2808,2809,5,50,0,0,2809,2813,5,40,0,0,2810,2812, - 3,336,168,0,2811,2810,1,0,0,0,2812,2815,1,0,0,0,2813,2811,1,0,0,0,2813, - 2814,1,0,0,0,2814,2816,1,0,0,0,2815,2813,1,0,0,0,2816,2817,3,2,1,0,2817, - 333,1,0,0,0,2818,2822,5,301,0,0,2819,2821,3,336,168,0,2820,2819,1,0,0, - 0,2821,2824,1,0,0,0,2822,2820,1,0,0,0,2822,2823,1,0,0,0,2823,2825,1,0, - 0,0,2824,2822,1,0,0,0,2825,2826,3,2,1,0,2826,335,1,0,0,0,2827,2843,5,52, - 0,0,2828,2843,5,51,0,0,2829,2843,5,172,0,0,2830,2831,5,62,0,0,2831,2843, - 5,51,0,0,2832,2833,5,62,0,0,2833,2843,5,52,0,0,2834,2835,5,62,0,0,2835, - 2843,5,63,0,0,2836,2837,5,62,0,0,2837,2843,5,64,0,0,2838,2839,5,62,0,0, - 2839,2843,5,65,0,0,2840,2841,5,62,0,0,2841,2843,5,66,0,0,2842,2827,1,0, - 0,0,2842,2828,1,0,0,0,2842,2829,1,0,0,0,2842,2830,1,0,0,0,2842,2832,1, - 0,0,0,2842,2834,1,0,0,0,2842,2836,1,0,0,0,2842,2838,1,0,0,0,2842,2840, - 1,0,0,0,2843,337,1,0,0,0,2844,2846,3,340,170,0,2845,2844,1,0,0,0,2846, - 2849,1,0,0,0,2847,2845,1,0,0,0,2847,2848,1,0,0,0,2848,339,1,0,0,0,2849, - 2847,1,0,0,0,2850,2851,5,21,0,0,2851,2864,3,2,1,0,2852,2853,5,50,0,0,2853, - 2854,5,40,0,0,2854,2864,3,118,59,0,2855,2856,5,25,0,0,2856,2857,5,40,0, - 0,2857,2864,3,2,1,0,2858,2864,3,174,87,0,2859,2860,5,50,0,0,2860,2864, - 3,32,16,0,2861,2864,3,322,161,0,2862,2864,3,40,20,0,2863,2850,1,0,0,0, - 2863,2852,1,0,0,0,2863,2855,1,0,0,0,2863,2858,1,0,0,0,2863,2859,1,0,0, - 0,2863,2861,1,0,0,0,2863,2862,1,0,0,0,2864,341,1,0,0,0,2865,2869,5,274, - 0,0,2866,2868,3,344,172,0,2867,2866,1,0,0,0,2868,2871,1,0,0,0,2869,2867, - 1,0,0,0,2869,2870,1,0,0,0,2870,2872,1,0,0,0,2871,2869,1,0,0,0,2872,2885, - 3,2,1,0,2873,2877,5,274,0,0,2874,2876,3,344,172,0,2875,2874,1,0,0,0,2876, - 2879,1,0,0,0,2877,2875,1,0,0,0,2877,2878,1,0,0,0,2878,2880,1,0,0,0,2879, - 2877,1,0,0,0,2880,2881,3,2,1,0,2881,2882,5,34,0,0,2882,2883,3,2,1,0,2883, - 2885,1,0,0,0,2884,2865,1,0,0,0,2884,2873,1,0,0,0,2885,343,1,0,0,0,2886, - 2887,7,15,0,0,2887,345,1,0,0,0,2888,2890,3,348,174,0,2889,2888,1,0,0,0, - 2890,2893,1,0,0,0,2891,2889,1,0,0,0,2891,2892,1,0,0,0,2892,347,1,0,0,0, - 2893,2891,1,0,0,0,2894,2895,5,21,0,0,2895,2896,3,2,1,0,2896,2897,5,44, - 0,0,2897,2898,3,32,16,0,2898,2905,1,0,0,0,2899,2900,5,25,0,0,2900,2901, - 5,40,0,0,2901,2905,3,2,1,0,2902,2905,3,322,161,0,2903,2905,3,40,20,0,2904, - 2894,1,0,0,0,2904,2899,1,0,0,0,2904,2902,1,0,0,0,2904,2903,1,0,0,0,2905, - 349,1,0,0,0,176,358,363,372,381,434,475,484,514,518,536,563,586,622,628, + 1895,1,0,0,0,1894,1892,1,0,0,0,1895,1896,3,124,62,0,1896,1897,3,2,1,0, + 1897,1907,1,0,0,0,1898,1902,5,128,0,0,1899,1901,3,212,106,0,1900,1899, + 1,0,0,0,1901,1904,1,0,0,0,1902,1900,1,0,0,0,1902,1903,1,0,0,0,1903,1905, + 1,0,0,0,1904,1902,1,0,0,0,1905,1907,3,2,1,0,1906,1888,1,0,0,0,1906,1898, + 1,0,0,0,1907,211,1,0,0,0,1908,1909,7,11,0,0,1909,213,1,0,0,0,1910,1912, + 3,216,108,0,1911,1910,1,0,0,0,1912,1915,1,0,0,0,1913,1911,1,0,0,0,1913, + 1914,1,0,0,0,1914,215,1,0,0,0,1915,1913,1,0,0,0,1916,1917,5,129,0,0,1917, + 1929,3,168,84,0,1918,1919,5,130,0,0,1919,1929,3,168,84,0,1920,1921,5,131, + 0,0,1921,1929,3,168,84,0,1922,1923,5,132,0,0,1923,1929,3,168,84,0,1924, + 1929,3,88,44,0,1925,1929,3,322,161,0,1926,1929,3,26,13,0,1927,1929,3,40, + 20,0,1928,1916,1,0,0,0,1928,1918,1,0,0,0,1928,1920,1,0,0,0,1928,1922,1, + 0,0,0,1928,1924,1,0,0,0,1928,1925,1,0,0,0,1928,1926,1,0,0,0,1928,1927, + 1,0,0,0,1929,217,1,0,0,0,1930,1934,5,133,0,0,1931,1933,3,220,110,0,1932, + 1931,1,0,0,0,1933,1936,1,0,0,0,1934,1932,1,0,0,0,1934,1935,1,0,0,0,1935, + 1937,1,0,0,0,1936,1934,1,0,0,0,1937,1938,3,170,85,0,1938,1939,3,138,69, + 0,1939,1940,3,2,1,0,1940,1941,3,112,56,0,1941,1942,3,206,103,0,1942,219, + 1,0,0,0,1943,1944,7,11,0,0,1944,221,1,0,0,0,1945,1947,3,224,112,0,1946, + 1945,1,0,0,0,1947,1950,1,0,0,0,1948,1946,1,0,0,0,1948,1949,1,0,0,0,1949, + 223,1,0,0,0,1950,1948,1,0,0,0,1951,1952,5,134,0,0,1952,1962,3,168,84,0, + 1953,1954,5,135,0,0,1954,1962,3,168,84,0,1955,1956,5,132,0,0,1956,1962, + 3,168,84,0,1957,1962,3,322,161,0,1958,1962,3,88,44,0,1959,1962,3,26,13, + 0,1960,1962,3,40,20,0,1961,1951,1,0,0,0,1961,1953,1,0,0,0,1961,1955,1, + 0,0,0,1961,1957,1,0,0,0,1961,1958,1,0,0,0,1961,1959,1,0,0,0,1961,1960, + 1,0,0,0,1962,225,1,0,0,0,1963,1970,1,0,0,0,1964,1965,5,122,0,0,1965,1966, + 5,30,0,0,1966,1967,3,228,114,0,1967,1968,5,31,0,0,1968,1970,1,0,0,0,1969, + 1963,1,0,0,0,1969,1964,1,0,0,0,1970,227,1,0,0,0,1971,1981,3,126,63,0,1972, + 1974,5,17,0,0,1973,1975,3,294,147,0,1974,1973,1,0,0,0,1975,1976,1,0,0, + 0,1976,1974,1,0,0,0,1976,1977,1,0,0,0,1977,1978,1,0,0,0,1978,1979,5,18, + 0,0,1979,1981,1,0,0,0,1980,1971,1,0,0,0,1980,1972,1,0,0,0,1981,229,1,0, + 0,0,1982,1984,3,232,116,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,231,1,0,0,0,1987,1985,1,0,0,0,1988,1989, + 5,42,0,0,1989,1990,5,136,0,0,1990,2002,5,43,0,0,1991,1992,5,42,0,0,1992, + 1993,5,137,0,0,1993,2002,5,43,0,0,1994,1995,5,42,0,0,1995,1996,5,138,0, + 0,1996,2002,5,43,0,0,1997,1998,5,42,0,0,1998,1999,3,32,16,0,1999,2000, + 5,43,0,0,2000,2002,1,0,0,0,2001,1988,1,0,0,0,2001,1991,1,0,0,0,2001,1994, + 1,0,0,0,2001,1997,1,0,0,0,2002,233,1,0,0,0,2003,2008,5,139,0,0,2004,2007, + 3,236,118,0,2005,2007,3,238,119,0,2006,2004,1,0,0,0,2006,2005,1,0,0,0, + 2007,2010,1,0,0,0,2008,2006,1,0,0,0,2008,2009,1,0,0,0,2009,2011,1,0,0, + 0,2010,2008,1,0,0,0,2011,2012,3,170,85,0,2012,2013,3,230,115,0,2013,2014, + 3,138,69,0,2014,2015,3,226,113,0,2015,2016,3,242,121,0,2016,2017,3,182, + 91,0,2017,2021,3,112,56,0,2018,2020,3,244,122,0,2019,2018,1,0,0,0,2020, + 2023,1,0,0,0,2021,2019,1,0,0,0,2021,2022,1,0,0,0,2022,235,1,0,0,0,2023, + 2021,1,0,0,0,2024,2048,5,123,0,0,2025,2048,5,51,0,0,2026,2048,5,52,0,0, + 2027,2048,5,63,0,0,2028,2048,5,140,0,0,2029,2048,5,68,0,0,2030,2048,5, + 141,0,0,2031,2048,5,142,0,0,2032,2048,5,54,0,0,2033,2048,5,64,0,0,2034, + 2048,5,65,0,0,2035,2048,5,66,0,0,2036,2048,5,125,0,0,2037,2048,5,143,0, + 0,2038,2048,5,144,0,0,2039,2048,5,69,0,0,2040,2048,5,145,0,0,2041,2048, + 5,146,0,0,2042,2043,5,70,0,0,2043,2044,5,30,0,0,2044,2045,3,32,16,0,2045, + 2046,5,31,0,0,2046,2048,1,0,0,0,2047,2024,1,0,0,0,2047,2025,1,0,0,0,2047, + 2026,1,0,0,0,2047,2027,1,0,0,0,2047,2028,1,0,0,0,2047,2029,1,0,0,0,2047, + 2030,1,0,0,0,2047,2031,1,0,0,0,2047,2032,1,0,0,0,2047,2033,1,0,0,0,2047, + 2034,1,0,0,0,2047,2035,1,0,0,0,2047,2036,1,0,0,0,2047,2037,1,0,0,0,2047, + 2038,1,0,0,0,2047,2039,1,0,0,0,2047,2040,1,0,0,0,2047,2041,1,0,0,0,2047, + 2042,1,0,0,0,2048,237,1,0,0,0,2049,2050,5,147,0,0,2050,2056,5,30,0,0,2051, + 2054,3,6,3,0,2052,2053,5,34,0,0,2053,2055,3,6,3,0,2054,2052,1,0,0,0,2054, + 2055,1,0,0,0,2055,2057,1,0,0,0,2056,2051,1,0,0,0,2056,2057,1,0,0,0,2057, + 2061,1,0,0,0,2058,2060,3,240,120,0,2059,2058,1,0,0,0,2060,2063,1,0,0,0, + 2061,2059,1,0,0,0,2061,2062,1,0,0,0,2062,2064,1,0,0,0,2063,2061,1,0,0, + 0,2064,2068,5,31,0,0,2065,2066,5,147,0,0,2066,2068,5,85,0,0,2067,2049, + 1,0,0,0,2067,2065,1,0,0,0,2068,239,1,0,0,0,2069,2097,5,148,0,0,2070,2097, + 5,224,0,0,2071,2097,5,57,0,0,2072,2097,5,58,0,0,2073,2097,5,149,0,0,2074, + 2097,5,150,0,0,2075,2097,5,248,0,0,2076,2097,5,249,0,0,2077,2097,5,250, + 0,0,2078,2097,5,251,0,0,2079,2080,5,151,0,0,2080,2081,5,75,0,0,2081,2097, + 5,152,0,0,2082,2083,5,151,0,0,2083,2084,5,75,0,0,2084,2097,5,153,0,0,2085, + 2086,5,154,0,0,2086,2087,5,75,0,0,2087,2097,5,152,0,0,2088,2089,5,154, + 0,0,2089,2090,5,75,0,0,2090,2097,5,153,0,0,2091,2092,5,70,0,0,2092,2093, + 5,30,0,0,2093,2094,3,32,16,0,2094,2095,5,31,0,0,2095,2097,1,0,0,0,2096, + 2069,1,0,0,0,2096,2070,1,0,0,0,2096,2071,1,0,0,0,2096,2072,1,0,0,0,2096, + 2073,1,0,0,0,2096,2074,1,0,0,0,2096,2075,1,0,0,0,2096,2076,1,0,0,0,2096, + 2077,1,0,0,0,2096,2078,1,0,0,0,2096,2079,1,0,0,0,2096,2082,1,0,0,0,2096, + 2085,1,0,0,0,2096,2088,1,0,0,0,2096,2091,1,0,0,0,2097,241,1,0,0,0,2098, + 2102,5,116,0,0,2099,2102,5,155,0,0,2100,2102,3,2,1,0,2101,2098,1,0,0,0, + 2101,2099,1,0,0,0,2101,2100,1,0,0,0,2102,243,1,0,0,0,2103,2125,5,1,0,0, + 2104,2125,5,2,0,0,2105,2125,5,156,0,0,2106,2125,5,3,0,0,2107,2125,5,4, + 0,0,2108,2125,5,247,0,0,2109,2125,5,5,0,0,2110,2125,5,6,0,0,2111,2125, + 5,7,0,0,2112,2125,5,8,0,0,2113,2125,5,9,0,0,2114,2125,5,10,0,0,2115,2125, + 5,11,0,0,2116,2125,5,12,0,0,2117,2125,5,13,0,0,2118,2125,5,14,0,0,2119, + 2120,5,70,0,0,2120,2121,5,30,0,0,2121,2122,3,32,16,0,2122,2123,5,31,0, + 0,2123,2125,1,0,0,0,2124,2103,1,0,0,0,2124,2104,1,0,0,0,2124,2105,1,0, + 0,0,2124,2106,1,0,0,0,2124,2107,1,0,0,0,2124,2108,1,0,0,0,2124,2109,1, + 0,0,0,2124,2110,1,0,0,0,2124,2111,1,0,0,0,2124,2112,1,0,0,0,2124,2113, + 1,0,0,0,2124,2114,1,0,0,0,2124,2115,1,0,0,0,2124,2116,1,0,0,0,2124,2117, + 1,0,0,0,2124,2118,1,0,0,0,2124,2119,1,0,0,0,2125,245,1,0,0,0,2126,2128, + 3,248,124,0,2127,2126,1,0,0,0,2128,2131,1,0,0,0,2129,2127,1,0,0,0,2129, + 2130,1,0,0,0,2130,247,1,0,0,0,2131,2129,1,0,0,0,2132,2150,3,100,50,0,2133, + 2134,5,296,0,0,2134,2135,3,32,16,0,2135,2136,6,124,-1,0,2136,2150,1,0, + 0,0,2137,2150,3,258,129,0,2138,2139,5,297,0,0,2139,2140,3,32,16,0,2140, + 2141,6,124,-1,0,2141,2150,1,0,0,0,2142,2143,5,298,0,0,2143,2150,6,124, + -1,0,2144,2145,5,299,0,0,2145,2150,6,124,-1,0,2146,2150,3,252,126,0,2147, + 2150,3,256,128,0,2148,2150,3,250,125,0,2149,2132,1,0,0,0,2149,2133,1,0, + 0,0,2149,2137,1,0,0,0,2149,2138,1,0,0,0,2149,2142,1,0,0,0,2149,2144,1, + 0,0,0,2149,2146,1,0,0,0,2149,2147,1,0,0,0,2149,2148,1,0,0,0,2150,249,1, + 0,0,0,2151,2152,5,300,0,0,2152,2250,3,112,56,0,2153,2154,5,300,0,0,2154, + 2155,5,157,0,0,2155,2250,3,112,56,0,2156,2250,3,276,138,0,2157,2250,3, + 152,76,0,2158,2250,3,88,44,0,2159,2250,3,26,13,0,2160,2250,3,254,127,0, + 2161,2250,3,40,20,0,2162,2163,5,301,0,0,2163,2164,5,42,0,0,2164,2165,3, + 32,16,0,2165,2166,5,43,0,0,2166,2250,1,0,0,0,2167,2168,5,301,0,0,2168, + 2169,5,42,0,0,2169,2170,3,32,16,0,2170,2171,5,43,0,0,2171,2172,5,34,0, + 0,2172,2173,3,0,0,0,2173,2250,1,0,0,0,2174,2175,5,303,0,0,2175,2176,3, + 32,16,0,2176,2177,5,75,0,0,2177,2178,3,32,16,0,2178,2250,1,0,0,0,2179, + 2180,5,302,0,0,2180,2181,3,124,62,0,2181,2182,5,176,0,0,2182,2183,3,242, + 121,0,2183,2250,1,0,0,0,2184,2185,5,302,0,0,2185,2186,5,226,0,0,2186,2187, + 3,170,85,0,2187,2188,3,138,69,0,2188,2189,3,124,62,0,2189,2190,5,176,0, + 0,2190,2191,3,242,121,0,2191,2192,3,194,97,0,2192,2193,3,112,56,0,2193, + 2250,1,0,0,0,2194,2195,5,255,0,0,2195,2196,5,196,0,0,2196,2197,5,42,0, + 0,2197,2198,3,32,16,0,2198,2202,5,43,0,0,2199,2201,3,322,161,0,2200,2199, + 1,0,0,0,2201,2204,1,0,0,0,2202,2200,1,0,0,0,2202,2203,1,0,0,0,2203,2250, + 1,0,0,0,2204,2202,1,0,0,0,2205,2206,5,255,0,0,2206,2207,5,196,0,0,2207, + 2211,3,2,1,0,2208,2210,3,322,161,0,2209,2208,1,0,0,0,2210,2213,1,0,0,0, + 2211,2209,1,0,0,0,2211,2212,1,0,0,0,2212,2250,1,0,0,0,2213,2211,1,0,0, + 0,2214,2215,5,255,0,0,2215,2216,5,256,0,0,2216,2217,5,42,0,0,2217,2218, + 3,32,16,0,2218,2219,5,43,0,0,2219,2220,5,28,0,0,2220,2224,3,124,62,0,2221, + 2223,3,322,161,0,2222,2221,1,0,0,0,2223,2226,1,0,0,0,2224,2222,1,0,0,0, + 2224,2225,1,0,0,0,2225,2250,1,0,0,0,2226,2224,1,0,0,0,2227,2228,5,255, + 0,0,2228,2229,5,256,0,0,2229,2230,3,2,1,0,2230,2231,5,28,0,0,2231,2235, + 3,124,62,0,2232,2234,3,322,161,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,2250,1,0,0,0,2237,2235,1,0,0,0,2238, + 2239,5,255,0,0,2239,2240,5,42,0,0,2240,2241,3,32,16,0,2241,2242,5,43,0, + 0,2242,2246,3,206,103,0,2243,2245,3,322,161,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,2250,1,0,0,0,2248,2246, + 1,0,0,0,2249,2151,1,0,0,0,2249,2153,1,0,0,0,2249,2156,1,0,0,0,2249,2157, + 1,0,0,0,2249,2158,1,0,0,0,2249,2159,1,0,0,0,2249,2160,1,0,0,0,2249,2161, + 1,0,0,0,2249,2162,1,0,0,0,2249,2167,1,0,0,0,2249,2174,1,0,0,0,2249,2179, + 1,0,0,0,2249,2184,1,0,0,0,2249,2194,1,0,0,0,2249,2205,1,0,0,0,2249,2214, + 1,0,0,0,2249,2227,1,0,0,0,2249,2238,1,0,0,0,2250,251,1,0,0,0,2251,2252, + 3,0,0,0,2252,2253,5,75,0,0,2253,2254,6,126,-1,0,2254,253,1,0,0,0,2255, + 2258,3,44,22,0,2256,2258,3,46,23,0,2257,2255,1,0,0,0,2257,2256,1,0,0,0, + 2258,255,1,0,0,0,2259,2260,5,17,0,0,2260,2261,3,246,123,0,2261,2262,5, + 18,0,0,2262,257,1,0,0,0,2263,2264,3,262,131,0,2264,2265,3,260,130,0,2265, + 259,1,0,0,0,2266,2268,3,264,132,0,2267,2266,1,0,0,0,2268,2269,1,0,0,0, + 2269,2267,1,0,0,0,2269,2270,1,0,0,0,2270,261,1,0,0,0,2271,2272,5,158,0, + 0,2272,2284,3,256,128,0,2273,2274,5,158,0,0,2274,2275,3,0,0,0,2275,2276, + 5,159,0,0,2276,2277,3,0,0,0,2277,2284,1,0,0,0,2278,2279,5,158,0,0,2279, + 2280,3,32,16,0,2280,2281,5,159,0,0,2281,2282,3,32,16,0,2282,2284,1,0,0, + 0,2283,2271,1,0,0,0,2283,2273,1,0,0,0,2283,2278,1,0,0,0,2284,263,1,0,0, + 0,2285,2286,3,268,134,0,2286,2287,3,274,137,0,2287,2298,1,0,0,0,2288,2289, + 3,266,133,0,2289,2290,3,274,137,0,2290,2298,1,0,0,0,2291,2292,3,270,135, + 0,2292,2293,3,274,137,0,2293,2298,1,0,0,0,2294,2295,3,272,136,0,2295,2296, + 3,274,137,0,2296,2298,1,0,0,0,2297,2285,1,0,0,0,2297,2288,1,0,0,0,2297, + 2291,1,0,0,0,2297,2294,1,0,0,0,2298,265,1,0,0,0,2299,2300,5,160,0,0,2300, + 2306,3,256,128,0,2301,2302,5,160,0,0,2302,2306,3,0,0,0,2303,2304,5,160, + 0,0,2304,2306,3,32,16,0,2305,2299,1,0,0,0,2305,2301,1,0,0,0,2305,2303, + 1,0,0,0,2306,267,1,0,0,0,2307,2308,5,161,0,0,2308,2309,3,124,62,0,2309, + 269,1,0,0,0,2310,2311,5,162,0,0,2311,271,1,0,0,0,2312,2313,5,163,0,0,2313, + 273,1,0,0,0,2314,2326,3,256,128,0,2315,2316,5,164,0,0,2316,2317,3,0,0, + 0,2317,2318,5,159,0,0,2318,2319,3,0,0,0,2319,2326,1,0,0,0,2320,2321,5, + 164,0,0,2321,2322,3,32,16,0,2322,2323,5,159,0,0,2323,2324,3,32,16,0,2324, + 2326,1,0,0,0,2325,2314,1,0,0,0,2325,2315,1,0,0,0,2325,2320,1,0,0,0,2326, + 275,1,0,0,0,2327,2328,3,278,139,0,2328,2329,3,282,141,0,2329,277,1,0,0, + 0,2330,2331,5,165,0,0,2331,2332,3,280,140,0,2332,2333,3,0,0,0,2333,2334, + 5,36,0,0,2334,2338,1,0,0,0,2335,2336,5,165,0,0,2336,2338,3,280,140,0,2337, + 2330,1,0,0,0,2337,2335,1,0,0,0,2338,279,1,0,0,0,2339,2343,1,0,0,0,2340, + 2343,5,166,0,0,2341,2343,5,2,0,0,2342,2339,1,0,0,0,2342,2340,1,0,0,0,2342, + 2341,1,0,0,0,2343,281,1,0,0,0,2344,2345,5,17,0,0,2345,2346,3,284,142,0, + 2346,2347,5,18,0,0,2347,2354,1,0,0,0,2348,2350,3,288,144,0,2349,2348,1, + 0,0,0,2350,2351,1,0,0,0,2351,2349,1,0,0,0,2351,2352,1,0,0,0,2352,2354, + 1,0,0,0,2353,2344,1,0,0,0,2353,2349,1,0,0,0,2354,283,1,0,0,0,2355,2356, + 3,288,144,0,2356,2357,5,28,0,0,2357,2359,1,0,0,0,2358,2355,1,0,0,0,2359, + 2362,1,0,0,0,2360,2358,1,0,0,0,2360,2361,1,0,0,0,2361,2363,1,0,0,0,2362, + 2360,1,0,0,0,2363,2364,3,288,144,0,2364,285,1,0,0,0,2365,2371,1,0,0,0, + 2366,2367,5,42,0,0,2367,2368,3,32,16,0,2368,2369,5,43,0,0,2369,2371,1, + 0,0,0,2370,2365,1,0,0,0,2370,2366,1,0,0,0,2371,287,1,0,0,0,2372,2373,5, + 181,0,0,2373,2374,5,262,0,0,2374,2375,5,30,0,0,2375,2376,3,6,3,0,2376, + 2377,5,31,0,0,2377,2439,1,0,0,0,2378,2379,5,260,0,0,2379,2380,5,30,0,0, + 2380,2381,3,0,0,0,2381,2382,5,31,0,0,2382,2439,1,0,0,0,2383,2384,5,260, + 0,0,2384,2439,3,0,0,0,2385,2386,5,84,0,0,2386,2387,5,30,0,0,2387,2388, + 3,292,146,0,2388,2389,5,31,0,0,2389,2439,1,0,0,0,2390,2391,5,188,0,0,2391, + 2392,5,30,0,0,2392,2393,3,36,18,0,2393,2394,5,31,0,0,2394,2395,3,286,143, + 0,2395,2439,1,0,0,0,2396,2397,5,189,0,0,2397,2398,5,30,0,0,2398,2399,3, + 36,18,0,2399,2400,5,31,0,0,2400,2401,3,286,143,0,2401,2439,1,0,0,0,2402, + 2403,5,187,0,0,2403,2404,5,30,0,0,2404,2405,3,34,17,0,2405,2406,5,31,0, + 0,2406,2407,3,286,143,0,2407,2439,1,0,0,0,2408,2409,5,186,0,0,2409,2410, + 5,30,0,0,2410,2411,3,32,16,0,2411,2412,5,31,0,0,2412,2413,3,286,143,0, + 2413,2439,1,0,0,0,2414,2415,5,185,0,0,2415,2416,5,30,0,0,2416,2417,3,32, + 16,0,2417,2418,5,31,0,0,2418,2419,3,286,143,0,2419,2439,1,0,0,0,2420,2421, + 5,184,0,0,2421,2422,5,30,0,0,2422,2423,3,32,16,0,2423,2424,5,31,0,0,2424, + 2425,3,286,143,0,2425,2439,1,0,0,0,2426,2427,5,188,0,0,2427,2439,3,286, + 143,0,2428,2429,5,189,0,0,2429,2439,3,286,143,0,2430,2431,5,187,0,0,2431, + 2439,3,286,143,0,2432,2433,5,186,0,0,2433,2439,3,286,143,0,2434,2435,5, + 185,0,0,2435,2439,3,286,143,0,2436,2437,5,184,0,0,2437,2439,3,286,143, + 0,2438,2372,1,0,0,0,2438,2378,1,0,0,0,2438,2383,1,0,0,0,2438,2385,1,0, + 0,0,2438,2390,1,0,0,0,2438,2396,1,0,0,0,2438,2402,1,0,0,0,2438,2408,1, + 0,0,0,2438,2414,1,0,0,0,2438,2420,1,0,0,0,2438,2426,1,0,0,0,2438,2428, + 1,0,0,0,2438,2430,1,0,0,0,2438,2432,1,0,0,0,2438,2434,1,0,0,0,2438,2436, + 1,0,0,0,2439,289,1,0,0,0,2440,2441,5,188,0,0,2441,2442,5,30,0,0,2442,2443, + 3,36,18,0,2443,2444,5,31,0,0,2444,2516,1,0,0,0,2445,2446,5,189,0,0,2446, + 2447,5,30,0,0,2447,2448,3,36,18,0,2448,2449,5,31,0,0,2449,2516,1,0,0,0, + 2450,2451,5,188,0,0,2451,2452,5,30,0,0,2452,2453,3,32,16,0,2453,2454,5, + 31,0,0,2454,2516,1,0,0,0,2455,2456,5,189,0,0,2456,2457,5,30,0,0,2457,2458, + 3,34,17,0,2458,2459,5,31,0,0,2459,2516,1,0,0,0,2460,2461,5,187,0,0,2461, + 2462,5,30,0,0,2462,2463,3,34,17,0,2463,2464,5,31,0,0,2464,2516,1,0,0,0, + 2465,2466,5,186,0,0,2466,2467,5,30,0,0,2467,2468,3,32,16,0,2468,2469,5, + 31,0,0,2469,2516,1,0,0,0,2470,2471,5,185,0,0,2471,2472,5,30,0,0,2472,2473, + 3,32,16,0,2473,2474,5,31,0,0,2474,2516,1,0,0,0,2475,2476,5,184,0,0,2476, + 2477,5,30,0,0,2477,2478,3,32,16,0,2478,2479,5,31,0,0,2479,2516,1,0,0,0, + 2480,2481,5,193,0,0,2481,2482,5,30,0,0,2482,2483,3,34,17,0,2483,2484,5, + 31,0,0,2484,2516,1,0,0,0,2485,2486,5,192,0,0,2486,2487,5,30,0,0,2487,2488, + 3,32,16,0,2488,2489,5,31,0,0,2489,2516,1,0,0,0,2490,2491,5,191,0,0,2491, + 2492,5,30,0,0,2492,2493,3,32,16,0,2493,2494,5,31,0,0,2494,2516,1,0,0,0, + 2495,2496,5,190,0,0,2496,2497,5,30,0,0,2497,2498,3,32,16,0,2498,2499,5, + 31,0,0,2499,2516,1,0,0,0,2500,2501,5,181,0,0,2501,2502,5,30,0,0,2502,2503, + 3,32,16,0,2503,2504,5,31,0,0,2504,2516,1,0,0,0,2505,2506,5,183,0,0,2506, + 2507,5,30,0,0,2507,2508,3,162,81,0,2508,2509,5,31,0,0,2509,2516,1,0,0, + 0,2510,2511,5,84,0,0,2511,2512,5,30,0,0,2512,2513,3,292,146,0,2513,2514, + 5,31,0,0,2514,2516,1,0,0,0,2515,2440,1,0,0,0,2515,2445,1,0,0,0,2515,2450, + 1,0,0,0,2515,2455,1,0,0,0,2515,2460,1,0,0,0,2515,2465,1,0,0,0,2515,2470, + 1,0,0,0,2515,2475,1,0,0,0,2515,2480,1,0,0,0,2515,2485,1,0,0,0,2515,2490, + 1,0,0,0,2515,2495,1,0,0,0,2515,2500,1,0,0,0,2515,2505,1,0,0,0,2515,2510, + 1,0,0,0,2516,291,1,0,0,0,2517,2518,3,294,147,0,2518,2519,6,146,-1,0,2519, + 2521,1,0,0,0,2520,2517,1,0,0,0,2521,2524,1,0,0,0,2522,2520,1,0,0,0,2522, + 2523,1,0,0,0,2523,293,1,0,0,0,2524,2522,1,0,0,0,2525,2526,7,12,0,0,2526, + 295,1,0,0,0,2527,2531,3,290,145,0,2528,2531,3,6,3,0,2529,2531,5,179,0, + 0,2530,2527,1,0,0,0,2530,2528,1,0,0,0,2530,2529,1,0,0,0,2531,297,1,0,0, + 0,2532,2681,3,290,145,0,2533,2534,5,182,0,0,2534,2535,5,30,0,0,2535,2536, + 5,179,0,0,2536,2681,5,31,0,0,2537,2538,5,182,0,0,2538,2539,5,30,0,0,2539, + 2540,5,264,0,0,2540,2681,5,31,0,0,2541,2542,5,196,0,0,2542,2543,5,30,0, + 0,2543,2544,5,39,0,0,2544,2545,5,264,0,0,2545,2681,5,31,0,0,2546,2547, + 5,196,0,0,2547,2548,5,30,0,0,2548,2549,3,116,58,0,2549,2550,5,31,0,0,2550, + 2681,1,0,0,0,2551,2552,5,196,0,0,2552,2553,5,30,0,0,2553,2554,5,179,0, + 0,2554,2681,5,31,0,0,2555,2556,5,197,0,0,2556,2557,5,30,0,0,2557,2558, + 3,298,149,0,2558,2559,5,31,0,0,2559,2681,1,0,0,0,2560,2561,5,188,0,0,2561, + 2562,5,42,0,0,2562,2563,3,32,16,0,2563,2564,5,43,0,0,2564,2565,5,30,0, + 0,2565,2566,3,300,150,0,2566,2567,5,31,0,0,2567,2681,1,0,0,0,2568,2569, + 5,189,0,0,2569,2570,5,42,0,0,2570,2571,3,32,16,0,2571,2572,5,43,0,0,2572, + 2573,5,30,0,0,2573,2574,3,302,151,0,2574,2575,5,31,0,0,2575,2681,1,0,0, + 0,2576,2577,5,187,0,0,2577,2578,5,42,0,0,2578,2579,3,32,16,0,2579,2580, + 5,43,0,0,2580,2581,5,30,0,0,2581,2582,3,304,152,0,2582,2583,5,31,0,0,2583, + 2681,1,0,0,0,2584,2585,5,186,0,0,2585,2586,5,42,0,0,2586,2587,3,32,16, + 0,2587,2588,5,43,0,0,2588,2589,5,30,0,0,2589,2590,3,306,153,0,2590,2591, + 5,31,0,0,2591,2681,1,0,0,0,2592,2593,5,185,0,0,2593,2594,5,42,0,0,2594, + 2595,3,32,16,0,2595,2596,5,43,0,0,2596,2597,5,30,0,0,2597,2598,3,308,154, + 0,2598,2599,5,31,0,0,2599,2681,1,0,0,0,2600,2601,5,184,0,0,2601,2602,5, + 42,0,0,2602,2603,3,32,16,0,2603,2604,5,43,0,0,2604,2605,5,30,0,0,2605, + 2606,3,310,155,0,2606,2607,5,31,0,0,2607,2681,1,0,0,0,2608,2609,5,193, + 0,0,2609,2610,5,42,0,0,2610,2611,3,32,16,0,2611,2612,5,43,0,0,2612,2613, + 5,30,0,0,2613,2614,3,304,152,0,2614,2615,5,31,0,0,2615,2681,1,0,0,0,2616, + 2617,5,192,0,0,2617,2618,5,42,0,0,2618,2619,3,32,16,0,2619,2620,5,43,0, + 0,2620,2621,5,30,0,0,2621,2622,3,306,153,0,2622,2623,5,31,0,0,2623,2681, + 1,0,0,0,2624,2625,5,191,0,0,2625,2626,5,42,0,0,2626,2627,3,32,16,0,2627, + 2628,5,43,0,0,2628,2629,5,30,0,0,2629,2630,3,308,154,0,2630,2631,5,31, + 0,0,2631,2681,1,0,0,0,2632,2633,5,190,0,0,2633,2634,5,42,0,0,2634,2635, + 3,32,16,0,2635,2636,5,43,0,0,2636,2637,5,30,0,0,2637,2638,3,310,155,0, + 2638,2639,5,31,0,0,2639,2681,1,0,0,0,2640,2641,5,181,0,0,2641,2642,5,42, + 0,0,2642,2643,3,32,16,0,2643,2644,5,43,0,0,2644,2645,5,30,0,0,2645,2646, + 3,308,154,0,2646,2647,5,31,0,0,2647,2681,1,0,0,0,2648,2649,5,183,0,0,2649, + 2650,5,42,0,0,2650,2651,3,32,16,0,2651,2652,5,43,0,0,2652,2653,5,30,0, + 0,2653,2654,3,312,156,0,2654,2655,5,31,0,0,2655,2681,1,0,0,0,2656,2657, + 5,182,0,0,2657,2658,5,42,0,0,2658,2659,3,32,16,0,2659,2660,5,43,0,0,2660, + 2661,5,30,0,0,2661,2662,3,314,157,0,2662,2663,5,31,0,0,2663,2681,1,0,0, + 0,2664,2665,5,196,0,0,2665,2666,5,42,0,0,2666,2667,3,32,16,0,2667,2668, + 5,43,0,0,2668,2669,5,30,0,0,2669,2670,3,316,158,0,2670,2671,5,31,0,0,2671, + 2681,1,0,0,0,2672,2673,5,197,0,0,2673,2674,5,42,0,0,2674,2675,3,32,16, + 0,2675,2676,5,43,0,0,2676,2677,5,30,0,0,2677,2678,3,320,160,0,2678,2679, + 5,31,0,0,2679,2681,1,0,0,0,2680,2532,1,0,0,0,2680,2533,1,0,0,0,2680,2537, + 1,0,0,0,2680,2541,1,0,0,0,2680,2546,1,0,0,0,2680,2551,1,0,0,0,2680,2555, + 1,0,0,0,2680,2560,1,0,0,0,2680,2568,1,0,0,0,2680,2576,1,0,0,0,2680,2584, + 1,0,0,0,2680,2592,1,0,0,0,2680,2600,1,0,0,0,2680,2608,1,0,0,0,2680,2616, + 1,0,0,0,2680,2624,1,0,0,0,2680,2632,1,0,0,0,2680,2640,1,0,0,0,2680,2648, + 1,0,0,0,2680,2656,1,0,0,0,2680,2664,1,0,0,0,2680,2672,1,0,0,0,2681,299, + 1,0,0,0,2682,2685,3,36,18,0,2683,2685,3,32,16,0,2684,2682,1,0,0,0,2684, + 2683,1,0,0,0,2685,2688,1,0,0,0,2686,2684,1,0,0,0,2686,2687,1,0,0,0,2687, + 301,1,0,0,0,2688,2686,1,0,0,0,2689,2692,3,36,18,0,2690,2692,3,34,17,0, + 2691,2689,1,0,0,0,2691,2690,1,0,0,0,2692,2695,1,0,0,0,2693,2691,1,0,0, + 0,2693,2694,1,0,0,0,2694,303,1,0,0,0,2695,2693,1,0,0,0,2696,2698,3,34, + 17,0,2697,2696,1,0,0,0,2698,2701,1,0,0,0,2699,2697,1,0,0,0,2699,2700,1, + 0,0,0,2700,305,1,0,0,0,2701,2699,1,0,0,0,2702,2704,3,32,16,0,2703,2702, + 1,0,0,0,2704,2707,1,0,0,0,2705,2703,1,0,0,0,2705,2706,1,0,0,0,2706,307, + 1,0,0,0,2707,2705,1,0,0,0,2708,2710,3,32,16,0,2709,2708,1,0,0,0,2710,2713, + 1,0,0,0,2711,2709,1,0,0,0,2711,2712,1,0,0,0,2712,309,1,0,0,0,2713,2711, + 1,0,0,0,2714,2716,3,32,16,0,2715,2714,1,0,0,0,2716,2719,1,0,0,0,2717,2715, + 1,0,0,0,2717,2718,1,0,0,0,2718,311,1,0,0,0,2719,2717,1,0,0,0,2720,2722, + 3,162,81,0,2721,2720,1,0,0,0,2722,2725,1,0,0,0,2723,2721,1,0,0,0,2723, + 2724,1,0,0,0,2724,313,1,0,0,0,2725,2723,1,0,0,0,2726,2728,7,13,0,0,2727, + 2726,1,0,0,0,2728,2731,1,0,0,0,2729,2727,1,0,0,0,2729,2730,1,0,0,0,2730, + 315,1,0,0,0,2731,2729,1,0,0,0,2732,2734,3,318,159,0,2733,2732,1,0,0,0, + 2734,2737,1,0,0,0,2735,2733,1,0,0,0,2735,2736,1,0,0,0,2736,317,1,0,0,0, + 2737,2735,1,0,0,0,2738,2743,5,179,0,0,2739,2740,5,39,0,0,2740,2743,5,264, + 0,0,2741,2743,3,116,58,0,2742,2738,1,0,0,0,2742,2739,1,0,0,0,2742,2741, + 1,0,0,0,2743,319,1,0,0,0,2744,2746,3,298,149,0,2745,2744,1,0,0,0,2746, + 2749,1,0,0,0,2747,2745,1,0,0,0,2747,2748,1,0,0,0,2748,321,1,0,0,0,2749, + 2747,1,0,0,0,2750,2754,3,44,22,0,2751,2754,3,46,23,0,2752,2754,3,2,1,0, + 2753,2750,1,0,0,0,2753,2751,1,0,0,0,2753,2752,1,0,0,0,2754,323,1,0,0,0, + 2755,2756,7,14,0,0,2756,2757,5,36,0,0,2757,2758,5,30,0,0,2758,2759,3,292, + 146,0,2759,2760,5,31,0,0,2760,2781,1,0,0,0,2761,2762,5,169,0,0,2762,2763, + 3,38,19,0,2763,2764,5,75,0,0,2764,2765,3,38,19,0,2765,2766,5,75,0,0,2766, + 2767,3,38,19,0,2767,2768,5,75,0,0,2768,2769,3,38,19,0,2769,2781,1,0,0, + 0,2770,2771,5,170,0,0,2771,2781,3,6,3,0,2772,2773,5,170,0,0,2773,2774, + 5,36,0,0,2774,2775,5,30,0,0,2775,2776,3,292,146,0,2776,2777,5,31,0,0,2777, + 2781,1,0,0,0,2778,2781,3,322,161,0,2779,2781,3,40,20,0,2780,2755,1,0,0, + 0,2780,2761,1,0,0,0,2780,2770,1,0,0,0,2780,2772,1,0,0,0,2780,2778,1,0, + 0,0,2780,2779,1,0,0,0,2781,325,1,0,0,0,2782,2783,5,25,0,0,2783,2784,5, + 40,0,0,2784,2785,3,98,49,0,2785,2786,3,2,1,0,2786,2795,1,0,0,0,2787,2788, + 5,25,0,0,2788,2789,5,40,0,0,2789,2790,3,98,49,0,2790,2791,3,2,1,0,2791, + 2792,5,34,0,0,2792,2793,3,2,1,0,2793,2795,1,0,0,0,2794,2782,1,0,0,0,2794, + 2787,1,0,0,0,2795,327,1,0,0,0,2796,2798,3,330,165,0,2797,2796,1,0,0,0, + 2798,2801,1,0,0,0,2799,2797,1,0,0,0,2799,2800,1,0,0,0,2800,329,1,0,0,0, + 2801,2799,1,0,0,0,2802,2803,5,180,0,0,2803,2804,5,36,0,0,2804,2805,5,30, + 0,0,2805,2806,3,292,146,0,2806,2807,5,31,0,0,2807,2817,1,0,0,0,2808,2817, + 3,324,162,0,2809,2810,5,171,0,0,2810,2811,5,36,0,0,2811,2812,5,30,0,0, + 2812,2813,3,292,146,0,2813,2814,5,31,0,0,2814,2817,1,0,0,0,2815,2817,5, + 55,0,0,2816,2802,1,0,0,0,2816,2808,1,0,0,0,2816,2809,1,0,0,0,2816,2815, + 1,0,0,0,2817,331,1,0,0,0,2818,2819,5,50,0,0,2819,2823,5,40,0,0,2820,2822, + 3,336,168,0,2821,2820,1,0,0,0,2822,2825,1,0,0,0,2823,2821,1,0,0,0,2823, + 2824,1,0,0,0,2824,2826,1,0,0,0,2825,2823,1,0,0,0,2826,2827,3,2,1,0,2827, + 333,1,0,0,0,2828,2832,5,301,0,0,2829,2831,3,336,168,0,2830,2829,1,0,0, + 0,2831,2834,1,0,0,0,2832,2830,1,0,0,0,2832,2833,1,0,0,0,2833,2835,1,0, + 0,0,2834,2832,1,0,0,0,2835,2836,3,2,1,0,2836,335,1,0,0,0,2837,2853,5,52, + 0,0,2838,2853,5,51,0,0,2839,2853,5,172,0,0,2840,2841,5,62,0,0,2841,2853, + 5,51,0,0,2842,2843,5,62,0,0,2843,2853,5,52,0,0,2844,2845,5,62,0,0,2845, + 2853,5,63,0,0,2846,2847,5,62,0,0,2847,2853,5,64,0,0,2848,2849,5,62,0,0, + 2849,2853,5,65,0,0,2850,2851,5,62,0,0,2851,2853,5,66,0,0,2852,2837,1,0, + 0,0,2852,2838,1,0,0,0,2852,2839,1,0,0,0,2852,2840,1,0,0,0,2852,2842,1, + 0,0,0,2852,2844,1,0,0,0,2852,2846,1,0,0,0,2852,2848,1,0,0,0,2852,2850, + 1,0,0,0,2853,337,1,0,0,0,2854,2856,3,340,170,0,2855,2854,1,0,0,0,2856, + 2859,1,0,0,0,2857,2855,1,0,0,0,2857,2858,1,0,0,0,2858,339,1,0,0,0,2859, + 2857,1,0,0,0,2860,2861,5,21,0,0,2861,2874,3,2,1,0,2862,2863,5,50,0,0,2863, + 2864,5,40,0,0,2864,2874,3,118,59,0,2865,2866,5,25,0,0,2866,2867,5,40,0, + 0,2867,2874,3,2,1,0,2868,2874,3,174,87,0,2869,2870,5,50,0,0,2870,2874, + 3,32,16,0,2871,2874,3,322,161,0,2872,2874,3,40,20,0,2873,2860,1,0,0,0, + 2873,2862,1,0,0,0,2873,2865,1,0,0,0,2873,2868,1,0,0,0,2873,2869,1,0,0, + 0,2873,2871,1,0,0,0,2873,2872,1,0,0,0,2874,341,1,0,0,0,2875,2879,5,274, + 0,0,2876,2878,3,344,172,0,2877,2876,1,0,0,0,2878,2881,1,0,0,0,2879,2877, + 1,0,0,0,2879,2880,1,0,0,0,2880,2882,1,0,0,0,2881,2879,1,0,0,0,2882,2895, + 3,2,1,0,2883,2887,5,274,0,0,2884,2886,3,344,172,0,2885,2884,1,0,0,0,2886, + 2889,1,0,0,0,2887,2885,1,0,0,0,2887,2888,1,0,0,0,2888,2890,1,0,0,0,2889, + 2887,1,0,0,0,2890,2891,3,2,1,0,2891,2892,5,34,0,0,2892,2893,3,2,1,0,2893, + 2895,1,0,0,0,2894,2875,1,0,0,0,2894,2883,1,0,0,0,2895,343,1,0,0,0,2896, + 2897,7,15,0,0,2897,345,1,0,0,0,2898,2900,3,348,174,0,2899,2898,1,0,0,0, + 2900,2903,1,0,0,0,2901,2899,1,0,0,0,2901,2902,1,0,0,0,2902,347,1,0,0,0, + 2903,2901,1,0,0,0,2904,2905,5,21,0,0,2905,2906,3,2,1,0,2906,2907,5,44, + 0,0,2907,2908,3,32,16,0,2908,2915,1,0,0,0,2909,2910,5,25,0,0,2910,2911, + 5,40,0,0,2911,2915,3,2,1,0,2912,2915,3,322,161,0,2913,2915,3,40,20,0,2914, + 2904,1,0,0,0,2914,2909,1,0,0,0,2914,2912,1,0,0,0,2914,2913,1,0,0,0,2915, + 349,1,0,0,0,175,358,363,372,381,434,475,484,514,518,536,563,586,622,628, 635,637,647,649,656,667,675,696,698,714,759,764,769,774,782,892,898,914, - 920,926,933,938,1016,1018,1035,1044,1050,1059,1061,1069,1081,1093,1100, - 1107,1109,1136,1143,1151,1159,1172,1179,1182,1201,1295,1304,1311,1314, - 1322,1343,1375,1398,1410,1419,1444,1468,1476,1480,1495,1502,1547,1557, - 1573,1585,1597,1611,1623,1634,1641,1651,1664,1669,1674,1683,1694,1777, - 1786,1799,1810,1818,1828,1830,1857,1864,1869,1876,1882,1892,1896,1903, - 1918,1924,1938,1951,1959,1966,1970,1975,1991,1996,1998,2011,2037,2044, - 2046,2051,2057,2086,2091,2114,2119,2139,2192,2201,2214,2225,2236,2239, - 2247,2259,2273,2287,2295,2315,2327,2332,2341,2343,2350,2360,2428,2505, - 2512,2520,2670,2674,2676,2681,2683,2689,2695,2701,2707,2713,2719,2725, - 2732,2737,2743,2770,2784,2789,2806,2813,2822,2842,2847,2863,2869,2877, - 2884,2891,2904 + 920,926,933,961,1039,1041,1054,1060,1069,1071,1079,1091,1103,1110,1117, + 1119,1146,1153,1161,1169,1182,1189,1192,1211,1305,1314,1321,1324,1332, + 1353,1385,1408,1420,1429,1454,1478,1486,1490,1505,1512,1557,1567,1583, + 1595,1607,1621,1633,1644,1651,1661,1674,1679,1684,1693,1704,1787,1796, + 1809,1820,1828,1838,1840,1867,1874,1879,1886,1892,1902,1906,1913,1928, + 1934,1948,1961,1969,1976,1980,1985,2001,2006,2008,2021,2047,2054,2056, + 2061,2067,2096,2101,2124,2129,2149,2202,2211,2224,2235,2246,2249,2257, + 2269,2283,2297,2305,2325,2337,2342,2351,2353,2360,2370,2438,2515,2522, + 2530,2680,2684,2686,2691,2693,2699,2705,2711,2717,2723,2729,2735,2742, + 2747,2753,2780,2794,2799,2816,2823,2832,2852,2857,2873,2879,2887,2894, + 2901,2914 }; public static readonly ATN _ATN = diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILVisitor.cs b/src/tools/ilasm/src/ILAssembler/gen/CILVisitor.cs index f9cf69a1ad7003..7a7898d3170742 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILVisitor.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILVisitor.cs @@ -345,11 +345,11 @@ public interface ICILVisitor : IParseTreeVisitor { /// The visitor result. Result VisitSimpleInstr([NotNull] CILParser.SimpleInstrContext context); /// - /// Visit a parse tree produced by . + /// Visit a parse tree produced by . /// /// The parse tree. /// The visitor result. - Result VisitInstructionIsland([NotNull] CILParser.InstructionIslandContext context); + Result VisitCalliSignature([NotNull] CILParser.CalliSignatureContext context); /// /// Visit a parse tree produced by . /// diff --git a/src/tools/ilasm/tests/ILAssembler.Tests/InstructionTests.cs b/src/tools/ilasm/tests/ILAssembler.Tests/InstructionTests.cs index f0152987e338b7..c38555315cb2ae 100644 --- a/src/tools/ilasm/tests/ILAssembler.Tests/InstructionTests.cs +++ b/src/tools/ilasm/tests/ILAssembler.Tests/InstructionTests.cs @@ -73,7 +73,12 @@ .method public static void M() cil managed [InlineData("ldc.i8")] [InlineData("ldarg")] [InlineData("br")] + [InlineData("call instance void")] + [InlineData("ldsfld int32")] + [InlineData("ldsfld mdtoken(")] + [InlineData("box")] [InlineData("ldtoken")] + [InlineData("calli default void(")] [InlineData("ldc.r8 float64(")] [InlineData("ldc.r8 bytearray(00 00")] [InlineData("ldstr \"A\" +")] From 54da98b308e4a0c8f763a515af99a02d20dcff82 Mon Sep 17 00:00:00 2001 From: Jeremy Koritzinsky Date: Wed, 12 Aug 2026 21:57:34 -0700 Subject: [PATCH 05/16] Synthesize IL type and signature grammar values Convert type, signature, class-name, and member-reference rules to compact semantic values so reference instructions no longer require parse-tree subtrees. Preserve internal entity types behind object-valued generated context slots and materialize them through strongly typed action helpers. Keep marshalling as the final bounded signature island. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: c986c103-8383-4db4-9b11-9be49dc68a05 --- src/tools/ilasm/README.md | 20 +- .../Actions/GrammarActions.Conversions.cs | 26 + .../GrammarActions.CustomAttributes.cs | 14 +- .../GrammarActions.Instructions.References.cs | 49 +- .../Actions/GrammarActions.Instructions.cs | 3 +- .../Actions/GrammarActions.Literals.cs | 89 +- .../Actions/GrammarActions.Members.cs | 49 +- .../Actions/GrammarActions.MethodBodies.cs | 19 +- .../GrammarActions.Signatures.Actions.cs | 420 ++ .../GrammarActions.Signatures.References.cs | 201 + .../GrammarActions.Signatures.Types.cs | 295 + .../GrammarActions.Signatures.Values.cs | 242 + .../Actions/GrammarActions.Signatures.cs | 892 +-- .../GrammarActions.Types.References.cs | 203 + .../Actions/GrammarActions.Types.cs | 141 +- .../src/ILAssembler/Actions/GrammarActions.cs | 24 +- .../ilasm/src/ILAssembler/DocumentCompiler.cs | 10 +- src/tools/ilasm/src/ILAssembler/gen/CIL.g4 | 358 +- .../ilasm/src/ILAssembler/gen/CIL.interp | 2 +- .../ilasm/src/ILAssembler/gen/CILParser.cs | 6599 +++++++++-------- .../ILAssembler.Tests/InstructionTests.cs | 107 + 21 files changed, 5468 insertions(+), 4295 deletions(-) create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Actions.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.References.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Types.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Values.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.References.cs diff --git a/src/tools/ilasm/README.md b/src/tools/ilasm/README.md index 37f3d745551e55..c8c2c052e21029 100644 --- a/src/tools/ilasm/README.md +++ b/src/tools/ilasm/README.md @@ -27,8 +27,13 @@ accumulator instead of building a subtree at all. | `GrammarActions.Members.cs` | Class member dispatch and conversion. | | `GrammarActions.MethodBodies.cs` | Method, lexical scope and exception-handling state and conversion. | | `GrammarActions.Security.cs` | Declarative security conversion. | -| `GrammarActions.Signatures.cs` | Signature and type encoding. | +| `GrammarActions.Signatures.cs` | Signature visitor compatibility wrappers. | +| `GrammarActions.Signatures.Actions.cs` | Signature grammar actions and repetition frames. | +| `GrammarActions.Signatures.References.cs` | Member-reference synthesis and materialization. | +| `GrammarActions.Signatures.Types.cs` | Type-signature materialization and encoding. | +| `GrammarActions.Signatures.Values.cs` | Internal synthesized signature value model. | | `GrammarActions.Types.cs` | Namespace and type scopes and declaration conversion. | +| `GrammarActions.Types.References.cs` | Type-name synthesis and resolution. | `CILParser.Actions.cs` holds the parse-tree mode helpers the grammar calls. @@ -37,10 +42,15 @@ accumulator instead of building a subtree at all. Parser actions in `src/ILAssembler/gen/CIL.g4` must remain thin; they call a single `Actions` method and nothing else. Compilation orchestration belongs in the `GrammarActions` partial-class files. -Instruction dispatch and value operands run entirely with parse-tree construction disabled. -Reference and signature operand roots such as `methodRef`, `fieldRef`, `mdtoken`, `typeSpec`, -`ownerType` and `calliSignature` temporarily retain only their own bounded subtrees for semantic -conversion. +Instruction dispatch and every operand root run with parse-tree construction disabled. +Type, signature and reference rules synthesize compact semantic values that their existing +`VisitX(context).Value` wrappers materialize. The generated ANTLR context classes are public, while +ILAssembler entities and signature implementation values remain internal, so generated return +slots use `object` where an internal value or array crosses that boundary and `GrammarActions` +provides the strongly typed accessors. + +`marshalClause` is the remaining signature-layer parse-tree island. It retains only the bounded +`marshalBlob`/`nativeType` subtree until its containing signature is materialized. Semantic state that a rule pushes must be released from that rule's `finally` clause and be keyed on the owning context, because ANTLR skips `@after` actions and the remainder of an alternative once a diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs index 83bb363933c4b0..5b9d4dbca985dc 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs @@ -91,6 +91,8 @@ internal sealed partial class GrammarActions : ICILVisitor private readonly Dictionary _mappedFieldDataNames = new(); private readonly Dictionary> _mappedFieldDataReferenceFixups = new(); private readonly BlobBuilder _manifestResources = new(); + private readonly Stack _semanticRootFrames = new(); + private int _syntaxErrorCount; // Typedef aliases - maps alias name to the resolved entity private readonly Dictionary _typedefs = new(); @@ -144,6 +146,30 @@ private void ReportError(string id, string message, IToken token) private void ReportWarning(string id, string message, Antlr4.Runtime.ParserRuleContext context) => ReportDiagnostic(DiagnosticSeverity.Warning, id, message, context); + private void ReportWarning(string id, string message, IToken token) + { + _diagnostics.Add(new Diagnostic( + id, + DiagnosticSeverity.Warning, + message, + Location.From(token, _documents))); + } + + private sealed record SemanticRootFrame(ParserRuleContext Owner, int InitialSyntaxErrorCount); + + internal void RecordSyntaxError() => _syntaxErrorCount++; + + internal void BeginSemanticRoot(ParserRuleContext context) + => _semanticRootFrames.Push(new(context, _syntaxErrorCount)); + + internal bool EndSemanticRoot(ParserRuleContext context) + { + Debug.Assert(_semanticRootFrames.Count > 0); + SemanticRootFrame frame = _semanticRootFrames.Pop(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + return frame.InitialSyntaxErrorCount != _syntaxErrorCount || context.exception is not null; + } + private static bool IsRecoverableError(string diagnosticId) { // Method body and signature diagnostics are recoverable - we emit the assembly but report the error. diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.cs index 3ed52eb7da6486..e8a7a5f74ffca4 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.cs @@ -544,18 +544,10 @@ public GrammarResult.FormattedBlob VisitObjSeq(CILParser.ObjSeqContext context) } GrammarResult ICILVisitor.VisitOwnerType(CILParser.OwnerTypeContext context) => VisitOwnerType(context); + public GrammarResult.Literal VisitOwnerType(CILParser.OwnerTypeContext context) - { - if (context.memberRef() is CILParser.MemberRefContext memberRef) - { - return VisitMemberRef(memberRef); - } - if (context.typeSpec() is CILParser.TypeSpecContext typeSpec) - { - return new(VisitTypeSpec(typeSpec).Value); - } - throw new UnreachableException(); - } + => new(MaterializeOwnerType(GetOwnerTypeValue(context.Value))); + GrammarResult ICILVisitor.VisitSerializType(CILParser.SerializTypeContext context) => VisitSerializType(context); public GrammarResult.FormattedBlob VisitSerializType(CILParser.SerializTypeContext context) { diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.References.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.References.cs index 0c43210d4d1cf7..b75c2c32c3ba88 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.References.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.References.cs @@ -1,13 +1,10 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System.Collections.Immutable; using System.Diagnostics; -using System.Linq; using System.Reflection.Metadata; using System.Reflection.Metadata.Ecma335; using Antlr4.Runtime; -using Antlr4.Runtime.Tree; namespace ILAssembler; @@ -15,7 +12,7 @@ internal sealed partial class GrammarActions { internal void EmitMethodReferenceInstruction(IToken opcodeToken, CILParser.MethodRefContext context) { - if (StartInstruction(opcodeToken) is not { } instruction || ContainsSyntaxError(context)) + if (StartInstruction(opcodeToken) is not { } instruction || context.HasSyntaxError) { return; } @@ -40,7 +37,7 @@ internal void EmitMethodReferenceInstruction(IToken opcodeToken, CILParser.Metho internal void EmitFieldReferenceInstruction(IToken opcodeToken, CILParser.FieldRefContext context) { - if (StartInstruction(opcodeToken) is not { } instruction || ContainsSyntaxError(context)) + if (StartInstruction(opcodeToken) is not { } instruction || context.HasSyntaxError) { return; } @@ -51,7 +48,7 @@ internal void EmitFieldReferenceInstruction(IToken opcodeToken, CILParser.FieldR internal void EmitMetadataTokenInstruction(IToken opcodeToken, CILParser.MdtokenContext context) { - if (StartInstruction(opcodeToken) is not { } instruction || ContainsSyntaxError(context)) + if (StartInstruction(opcodeToken) is not { } instruction || context.HasSyntaxError) { return; } @@ -62,7 +59,7 @@ internal void EmitMetadataTokenInstruction(IToken opcodeToken, CILParser.Mdtoken internal void EmitTypeReferenceInstruction(IToken opcodeToken, CILParser.TypeSpecContext context) { - if (StartInstruction(opcodeToken) is not { } instruction || ContainsSyntaxError(context)) + if (StartInstruction(opcodeToken) is not { } instruction || context.HasSyntaxError) { return; } @@ -73,29 +70,21 @@ internal void EmitTypeReferenceInstruction(IToken opcodeToken, CILParser.TypeSpe internal void EmitCalliInstruction(IToken opcodeToken, CILParser.CalliSignatureContext context) { - if (StartInstruction(opcodeToken) is not { } instruction || ContainsSyntaxError(context)) + if (StartInstruction(opcodeToken) is not { } instruction || context.HasSyntaxError) { return; } Debug.Assert(instruction.OpCode == ILOpCode.Calli); - BlobBuilder signature = new(); - signature.WriteByte(VisitCallConv(context.callConv()).Value); - ImmutableArray arguments = VisitSigArgs(context.sigArgs()).Value; - signature.WriteCompressedInteger(arguments.Count(argument => !argument.IsSentinel)); - VisitType(context.type()).Value.WriteContentTo(signature); - foreach (SignatureArg argument in arguments) - { - argument.SignatureBlob.WriteContentTo(signature); - } - instruction.Method.Definition.MethodBody.OpCode(instruction.OpCode); - instruction.Method.Definition.MethodBody.Token(_entityRegistry.GetOrCreateStandaloneSignature(signature).Handle); + instruction.Method.Definition.MethodBody.Token( + _entityRegistry.GetOrCreateStandaloneSignature( + MaterializeCalliSignature(GetCalliSignatureValue(context.Value))).Handle); } internal void EmitOwnerTokenInstruction(IToken opcodeToken, CILParser.OwnerTypeContext context) { - if (StartInstruction(opcodeToken) is not { } instruction || ContainsSyntaxError(context)) + if (StartInstruction(opcodeToken) is not { } instruction || context.HasSyntaxError) { return; } @@ -104,24 +93,6 @@ internal void EmitOwnerTokenInstruction(IToken opcodeToken, CILParser.OwnerTypeC WriteInstructionToken(instruction.Method, VisitOwnerType(context).Value); } - private static bool ContainsSyntaxError(IParseTree tree) - { - if (tree is IErrorNode or ParserRuleContext { exception: not null }) - { - return true; - } - - for (int i = 0; i < tree.ChildCount; i++) - { - if (ContainsSyntaxError(tree.GetChild(i))) - { - return true; - } - } - - return false; - } - private static void WriteInstructionToken(CurrentMethodContext method, EntityRegistry.EntityBase entity) { if (entity is EntityRegistry.TypeReferenceEntity typeReference) @@ -141,5 +112,5 @@ private static void WriteInstructionToken(CurrentMethodContext method, EntityReg } GrammarResult ICILVisitor.VisitCalliSignature(CILParser.CalliSignatureContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + => new GrammarResult.FormattedBlob(MaterializeCalliSignature(GetCalliSignatureValue(context.Value))); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs index bbead890989385..9744578fdb18f0 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs @@ -451,6 +451,5 @@ GrammarResult ICILVisitor.VisitSimpleInstr(CILParser.SimpleInstrC GrammarResult ICILVisitor.VisitMdtoken(CILParser.MdtokenContext context) => VisitMdtoken(context); public GrammarResult.Literal VisitMdtoken(CILParser.MdtokenContext context) - => new(_entityRegistry.ResolveHandleToEntity( - MetadataTokens.EntityHandle(VisitInt32(context.int32()).Value))); + => new(ResolveMetadataToken(context.Value)); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs index 5a90ebd78ca420..e215c4a7ff62db 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs @@ -27,6 +27,21 @@ internal sealed partial class GrammarActions : ICILVisitor { private CILParser.CompQstringContext? _composedStringOwner; private StringBuilder? _composedStringAccumulator; + private readonly Stack _dottedNameFrames = new(); + + private sealed class DottedNameFrame + { + public DottedNameFrame(CILParser.DottedNameContext owner) + { + Owner = owner; + } + + public CILParser.DottedNameContext Owner { get; } + + public string? FirstPart { get; set; } + + public StringBuilder? Builder { get; set; } + } GrammarResult ICILVisitor.VisitCompQstring(CILParser.CompQstringContext context) { @@ -72,37 +87,53 @@ GrammarResult ICILVisitor.VisitDottedName(CILParser.DottedNameCon return VisitDottedName(context); } - public static GrammarResult.String VisitDottedName(CILParser.DottedNameContext context) + internal void BeginDottedName(CILParser.DottedNameContext context) + => _dottedNameFrames.Push(new(context)); + + internal void AddDottedNamePart(CILParser.DottedNameContext context, string value) { - CILParser.DottedNamePartContext[] parts = context.dottedNamePart(); - if (parts.Length > 0) + Debug.Assert(_dottedNameFrames.Count > 0); + DottedNameFrame frame = _dottedNameFrames.Peek(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + if (!ReferenceEquals(frame.Owner, context)) { - StringBuilder builder = new(); - for (int i = 0; i < parts.Length; i++) - { - if (i > 0) - { - builder.Append('.'); - } - - CILParser.DottedNamePartContext part = parts[i]; - builder.Append(part.SQSTRING() is { } quotedPart - ? StringHelpers.ParseQuotedString(quotedPart.GetText()) - : part.GetText()); - } - - return new(builder.ToString()); + return; } - string text = context.GetText(); - if (context.SQSTRING() is not null && text.Length >= 2 && text[0] == '\'') + if (frame.FirstPart is null) { - text = text.Substring(1, text.Length - 2); + frame.FirstPart = value; + return; } - return new(text); + + frame.Builder ??= new StringBuilder(frame.FirstPart); + frame.Builder.Append('.'); + frame.Builder.Append(value); } - GrammarResult ICILVisitor.VisitDottedNamePart(CILParser.DottedNamePartContext context) => throw new UnreachableException(); + internal void AddDottedNameToken(CILParser.DottedNameContext context, IToken token) + => AddDottedNamePart(context, ParseIdentifier(token)); + + internal string EndDottedName(CILParser.DottedNameContext context) + { + Debug.Assert(_dottedNameFrames.Count > 0); + DottedNameFrame frame = _dottedNameFrames.Pop(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + return ReferenceEquals(frame.Owner, context) + ? frame.Builder?.ToString() ?? frame.FirstPart ?? string.Empty + : string.Empty; + } + + public static GrammarResult.String VisitDottedName(CILParser.DottedNameContext context) + => new(context.Value ?? string.Empty); + + GrammarResult ICILVisitor.VisitDottedNamePart(CILParser.DottedNamePartContext context) + => new GrammarResult.String(context.Value ?? string.Empty); + + internal string ParseDottedNamePart(IToken token) + => token.Text.Length >= 2 && token.Text[0] == '\'' + ? StringHelpers.ParseQuotedString(token.Text) + : token.Text; internal double ParseFloatingLiteral(IToken token) { @@ -226,7 +257,7 @@ public GrammarResult.Literal VisitInt32(CILParser.Int32Context context) return new(ParseInt32(context.INT32().Symbol)); } - private int ParseInt32(IToken token) + internal int ParseInt32(IToken token) { ReadOnlySpan value = token.Text.AsSpan(); if (!ParseIntegerValue(value, out long num)) @@ -279,15 +310,7 @@ GrammarResult ICILVisitor.VisitSlashedName(CILParser.SlashedNameC } public static GrammarResult.Literal VisitSlashedName(CILParser.SlashedNameContext context) - { - TypeName? currentTypeName = null; - foreach (var item in context.dottedName()) - { - currentTypeName = new TypeName(currentTypeName, VisitDottedName(item).Value); - } - // We'll always have at least one dottedName, so the value here will be non-null - return new(currentTypeName!); - } + => new(GetSlashedNameValue(context)); GrammarResult ICILVisitor.VisitTruefalse(CILParser.TruefalseContext context) => VisitTruefalse(context); diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.cs index 024546c663d1f4..6a979e5199f06f 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.cs @@ -503,35 +503,9 @@ public GrammarResult VisitFieldDecl(CILParser.FieldDeclContext context) public GrammarResult VisitFieldOrProp(CILParser.FieldOrPropContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); GrammarResult ICILVisitor.VisitFieldRef(CILParser.FieldRefContext context) => VisitFieldRef(context); - public GrammarResult.Literal VisitFieldRef(CILParser.FieldRefContext context) - { - if (context.type() is not CILParser.TypeContext type) - { - // This is a typedef reference for a field member - string alias = VisitDottedName(context.dottedName()).Value; - var resolved = TryResolveTypedefAsMember(alias); - if (resolved is not null) - { - return new(resolved); - } - ReportError(DiagnosticIds.TypedefNotFound, string.Format(DiagnosticMessageTemplates.TypedefNotFound, alias), context); - return new(_entityRegistry.CreateLazilyRecordedMemberReference(_entityRegistry.ModuleType, alias, new BlobBuilder())); - } - var fieldTypeSig = VisitType(type).Value; - EntityRegistry.TypeEntity definingType = _entityRegistry.ModuleType; - if (context.typeSpec() is CILParser.TypeSpecContext typeSpec) - { - definingType = VisitTypeSpec(typeSpec).Value; - } - - string name = VisitDottedName(context.dottedName()).Value; - - var fieldSig = new BlobBuilder(fieldTypeSig.Count + 1); - fieldSig.WriteByte((byte)SignatureKind.Field); - fieldTypeSig.WriteContentTo(fieldSig); - return new(_entityRegistry.CreateLazilyRecordedMemberReference(definingType, name, fieldSig)); - } + public GrammarResult.Literal VisitFieldRef(CILParser.FieldRefContext context) + => new(MaterializeFieldReference(GetFieldReferenceValue(context.Value))); GrammarResult ICILVisitor.VisitInitOpt(CILParser.InitOptContext context) => VisitInitOpt(context); public GrammarResult.Literal VisitInitOpt(CILParser.InitOptContext context) @@ -545,24 +519,9 @@ public GrammarResult VisitFieldDecl(CILParser.FieldDeclContext context) } GrammarResult ICILVisitor.VisitMemberRef(CILParser.MemberRefContext context) => VisitMemberRef(context); - public GrammarResult.Literal VisitMemberRef(CILParser.MemberRefContext context) - { - if (context.mdtoken() is CILParser.MdtokenContext mdToken) - { - return VisitMdtoken(mdToken); - } - - if (context.methodRef() is CILParser.MethodRefContext methodRef) - { - return VisitMethodRef(methodRef); - } - if (context.fieldRef() is CILParser.FieldRefContext fieldRef) - { - return VisitFieldRef(fieldRef); - } - throw new UnreachableException(); - } + public GrammarResult.Literal VisitMemberRef(CILParser.MemberRefContext context) + => new(MaterializeMemberReference(GetMemberReferenceValue(context.Value))); GrammarResult ICILVisitor.VisitPropAttr(CILParser.PropAttrContext context) => VisitPropAttr(context); public static GrammarResult.Flag VisitPropAttr(CILParser.PropAttrContext context) diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs index fb0d8ce15803d8..e8e9a8d94797e1 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs @@ -774,22 +774,11 @@ public GrammarResult.Flag VisitMethAttr(CILParser.MethAttrCont } GrammarResult ICILVisitor.VisitMethodName(CILParser.MethodNameContext context) => VisitMethodName(context); - public GrammarResult.String VisitMethodName(CILParser.MethodNameContext context) - { - // Error recovery in a malformed method header can leave the name unmatched. - if (context.ChildCount == 0) - { - return new(string.Empty); - } - IParseTree child = context.GetChild(0); - return child switch - { - ITerminalNode terminal => new(terminal.Symbol.Text), - CILParser.DottedNameContext dottedName => VisitDottedName(dottedName), - _ => new(context.GetText()), - }; - } + public static GrammarResult.String VisitMethodName(CILParser.MethodNameContext context) + => new(context.Value ?? string.Empty); + + internal string GetMethodName(IToken token) => token.Text; public GrammarResult VisitScopeBlock(CILParser.ScopeBlockContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Actions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Actions.cs new file mode 100644 index 00000000000000..8abf0c02037130 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Actions.cs @@ -0,0 +1,420 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Linq; +using System.Reflection; +using System.Reflection.Metadata; +using Antlr4.Runtime; + +namespace ILAssembler; + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. +internal sealed partial class GrammarActions +{ + private readonly Stack _typeSignatureFrames = new(); + private readonly Stack _typeArgumentsFrames = new(); + private readonly Stack _boundsFrames = new(); + private readonly Stack _signatureArgumentsFrames = new(); + private readonly Stack _parameterAttributesFrames = new(); + + private sealed class TypeSignatureFrame + { + public TypeSignatureFrame(CILParser.TypeContext owner) + { + Owner = owner; + } + + public CILParser.TypeContext Owner { get; } + + public ElementTypeValue ElementType { get; set; } = ElementTypeValue.Error; + + public ImmutableArray.Builder Modifiers { get; } = ImmutableArray.CreateBuilder(); + } + + private sealed class TypeArgumentsFrame + { + public TypeArgumentsFrame(CILParser.TypeArgsContext owner) + { + Owner = owner; + } + + public CILParser.TypeArgsContext Owner { get; } + + public ImmutableArray.Builder Arguments { get; } = ImmutableArray.CreateBuilder(); + } + + private sealed class BoundsFrame + { + public BoundsFrame(CILParser.BoundsContext owner) + { + Owner = owner; + } + + public CILParser.BoundsContext Owner { get; } + + public ImmutableArray.Builder Bounds { get; } = ImmutableArray.CreateBuilder(); + } + + private sealed class SignatureArgumentsFrame + { + public SignatureArgumentsFrame(CILParser.SigArgsContext owner) + { + Owner = owner; + } + + public CILParser.SigArgsContext Owner { get; } + + public ImmutableArray.Builder Arguments { get; } = ImmutableArray.CreateBuilder(); + } + + private sealed class ParameterAttributesFrame + { + public ParameterAttributesFrame(CILParser.ParamAttrContext owner) + { + Owner = owner; + } + + public CILParser.ParamAttrContext Owner { get; } + + public int Attributes { get; set; } + } + + internal byte AddInstanceCallingConvention(byte callingConvention) + => (byte)(callingConvention | (byte)SignatureAttributes.Instance); + + internal byte AddExplicitCallingConvention(byte callingConvention) + => (byte)(callingConvention | (byte)(SignatureAttributes.ExplicitThis | SignatureAttributes.Instance)); + + internal byte GetRawCallingConvention(IToken token) => (byte)ParseInt32(token); + + internal byte GetDefaultCallingConvention() => (byte)SignatureCallingConvention.Default; + + internal byte GetCallingConvention(IToken token) + => (byte)(token.Type switch + { + CILParser.DEFAULT => SignatureCallingConvention.Default, + CILParser.VARARG => SignatureCallingConvention.VarArgs, + CILParser.CDECL => SignatureCallingConvention.CDecl, + CILParser.STDCALL => SignatureCallingConvention.StdCall, + CILParser.THISCALL => SignatureCallingConvention.ThisCall, + CILParser.FASTCALL => SignatureCallingConvention.FastCall, + CILParser.UNMANAGED => SignatureCallingConvention.Unmanaged, + _ => throw new UnreachableException() + }); + + internal void BeginTypeSignature(CILParser.TypeContext context) + => _typeSignatureFrames.Push(new(context)); + + internal void SetTypeSignatureElement(CILParser.TypeContext context, object? value) + { + Debug.Assert(_typeSignatureFrames.Count > 0); + TypeSignatureFrame frame = _typeSignatureFrames.Peek(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + if (ReferenceEquals(frame.Owner, context)) + { + frame.ElementType = GetElementTypeValue(value); + } + } + + internal void AddTypeSignatureModifier(CILParser.TypeContext context, object? value) + { + Debug.Assert(_typeSignatureFrames.Count > 0); + TypeSignatureFrame frame = _typeSignatureFrames.Peek(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + if (ReferenceEquals(frame.Owner, context)) + { + frame.Modifiers.Add(GetTypeModifierValue(value)); + } + } + + internal object EndTypeSignature(CILParser.TypeContext context) + { + Debug.Assert(_typeSignatureFrames.Count > 0); + TypeSignatureFrame frame = _typeSignatureFrames.Pop(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + return ReferenceEquals(frame.Owner, context) + ? new TypeValue(frame.ElementType, frame.Modifiers.ToImmutable()) + : TypeValue.Error; + } + + internal void BeginTypeArguments(CILParser.TypeArgsContext context) + => _typeArgumentsFrames.Push(new(context)); + + internal void AddTypeArgument(CILParser.TypeArgsContext context, object? value) + { + Debug.Assert(_typeArgumentsFrames.Count > 0); + TypeArgumentsFrame frame = _typeArgumentsFrames.Peek(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + if (ReferenceEquals(frame.Owner, context)) + { + frame.Arguments.Add(GetTypeValue(value)); + } + } + + internal object EndTypeArguments(CILParser.TypeArgsContext context) + { + Debug.Assert(_typeArgumentsFrames.Count > 0); + TypeArgumentsFrame frame = _typeArgumentsFrames.Pop(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + return ReferenceEquals(frame.Owner, context) ? frame.Arguments.ToImmutable() : ImmutableArray.Empty; + } + + internal void InitializeBound(CILParser.BoundContext context) + { + context.Lower = 0; + context.Upper = 0; + context.HasLower = false; + context.HasUpper = false; + } + + internal void SetBoundSize(CILParser.BoundContext context, IToken sizeToken) + { + context.Lower = 0; + context.Upper = ParseInt32(sizeToken); + context.HasLower = true; + context.HasUpper = true; + } + + internal void SetBoundRange(CILParser.BoundContext context, IToken lowerToken, IToken upperToken) + { + int lower = ParseInt32(lowerToken); + context.Lower = lower; + context.Upper = ParseInt32(upperToken) - lower + 1; + context.HasLower = true; + context.HasUpper = true; + } + + internal void SetBoundLower(CILParser.BoundContext context, IToken lowerToken) + { + context.Lower = ParseInt32(lowerToken); + context.HasLower = true; + } + + internal void BeginBounds(CILParser.BoundsContext context) + => _boundsFrames.Push(new(context)); + + internal void AddBound(CILParser.BoundsContext context, CILParser.BoundContext bound) + { + Debug.Assert(_boundsFrames.Count > 0); + BoundsFrame frame = _boundsFrames.Peek(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + if (ReferenceEquals(frame.Owner, context)) + { + frame.Bounds.Add(new( + bound.HasLower ? bound.Lower : null, + bound.HasUpper ? bound.Upper : null)); + } + } + + internal object EndBounds(CILParser.BoundsContext context) + { + Debug.Assert(_boundsFrames.Count > 0); + BoundsFrame frame = _boundsFrames.Pop(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + return ReferenceEquals(frame.Owner, context) ? frame.Bounds.ToImmutable() : ImmutableArray.Empty; + } + + internal void BeginSignatureArguments(CILParser.SigArgsContext context) + => _signatureArgumentsFrames.Push(new(context)); + + internal void AddSignatureArgument(CILParser.SigArgsContext context, object? value) + { + Debug.Assert(_signatureArgumentsFrames.Count > 0); + SignatureArgumentsFrame frame = _signatureArgumentsFrames.Peek(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + if (ReferenceEquals(frame.Owner, context)) + { + frame.Arguments.Add(GetSignatureArgumentValue(value)); + } + } + + internal object EndSignatureArguments(CILParser.SigArgsContext context) + { + Debug.Assert(_signatureArgumentsFrames.Count > 0); + SignatureArgumentsFrame frame = _signatureArgumentsFrames.Pop(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + return ReferenceEquals(frame.Owner, context) ? frame.Arguments.ToImmutable() : ImmutableArray.Empty; + } + + internal object CreateSentinelSignatureArgument() + => new SignatureArgumentValue(true, 0, null, null, null); + + internal object CreateSignatureArgument( + int attributes, + object? type, + CILParser.MarshalClauseContext marshalling, + CILParser.IdContext? name) + => new SignatureArgumentValue( + false, + attributes, + GetTypeValue(type), + marshalling, + name is null ? null : VisitId(name).Value); + + internal void BeginParameterAttributes(CILParser.ParamAttrContext context) + => _parameterAttributesFrames.Push(new(context)); + + internal void SetParameterAttributeElement(CILParser.ParamAttrElementContext context, IToken attribute) + { + context.Value = attribute.Text switch + { + "in" => (int)ParameterAttributes.In, + "out" => (int)ParameterAttributes.Out, + "opt" => (int)ParameterAttributes.Optional, + _ => throw new UnreachableException() + }; + context.ShouldAppend = true; + } + + internal void SetRawParameterAttributeElement(CILParser.ParamAttrElementContext context, IToken token) + { + context.Value = ParseInt32(token) + 1; + context.ShouldAppend = false; + } + + internal void AddParameterAttribute(CILParser.ParamAttrContext context, CILParser.ParamAttrElementContext element) + { + Debug.Assert(_parameterAttributesFrames.Count > 0); + ParameterAttributesFrame frame = _parameterAttributesFrames.Peek(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + if (ReferenceEquals(frame.Owner, context)) + { + frame.Attributes = element.ShouldAppend + ? frame.Attributes | element.Value + : element.Value; + } + } + + internal int EndParameterAttributes(CILParser.ParamAttrContext context) + { + Debug.Assert(_parameterAttributesFrames.Count > 0); + ParameterAttributesFrame frame = _parameterAttributesFrames.Pop(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + return ReferenceEquals(frame.Owner, context) ? frame.Attributes : 0; + } + + internal object CreateClassElementType(object? className, bool isValueType) + => new ClassElementTypeValue(GetClassNameValue(className), isValueType); + + internal object CreateObjectElementType() + => new PrimitiveElementTypeValue((byte)SignatureTypeCode.Object); + + internal object CreateTypedReferenceElementType() + => new PrimitiveElementTypeValue((byte)SignatureTypeCode.TypedReference); + + internal object CreateVoidElementType() + => new PrimitiveElementTypeValue((byte)SignatureTypeCode.Void); + + internal object CreatePrimitiveElementType(byte typeCode) + => new PrimitiveElementTypeValue(typeCode); + + internal object CreateFunctionPointerElementType(byte callingConvention, object? returnType, object? arguments) + => new FunctionPointerElementTypeValue( + callingConvention, + GetTypeValue(returnType), + GetSignatureArgumentsValue(arguments)); + + internal object CreateIndexedGenericParameterElementType(bool isMethodParameter, IToken token) + => new IndexedGenericParameterElementTypeValue(isMethodParameter, ParseInt32(token)); + + internal object CreateNamedGenericParameterElementType(IToken token, bool isMethodParameter, string name) + => new NamedGenericParameterElementTypeValue(token, isMethodParameter, name); + + internal object CreateTypedefElementType(IToken token, string alias) + => new TypedefElementTypeValue(token, alias); + + internal object CreateSentinelElementType(object? type) + => new SentinelElementTypeValue(GetTypeValue(type)); + + internal object CreateSzArrayTypeModifier() + => new SimpleTypeModifierValue(SimpleTypeModifierKind.SzArray); + + internal object CreateByReferenceTypeModifier() + => new SimpleTypeModifierValue(SimpleTypeModifierKind.ByReference); + + internal object CreatePointerTypeModifier() + => new SimpleTypeModifierValue(SimpleTypeModifierKind.Pointer); + + internal object CreatePinnedTypeModifier() + => new SimpleTypeModifierValue(SimpleTypeModifierKind.Pinned); + + internal object CreateArrayTypeModifier(object? bounds) + => new ArrayTypeModifierValue(GetBoundsValue(bounds)); + + internal object CreateCustomTypeModifier(object? type, bool isRequired) + => new CustomTypeModifierValue(GetTypeSpecificationValue(type), isRequired); + + internal object CreateGenericArgumentsModifier(object? arguments) + => new GenericArgumentsTypeModifierValue(GetTypeArgumentsValue(arguments)); + + internal byte GetSimpleType(IToken token, bool isUnsigned) + { + SignatureTypeCode typeCode = (token.Type, isUnsigned) switch + { + (CILParser.CHAR, false) => SignatureTypeCode.Char, + (CILParser.STRING, false) => SignatureTypeCode.String, + (CILParser.BOOL, false) => SignatureTypeCode.Boolean, + (CILParser.INT8, false) => SignatureTypeCode.SByte, + (CILParser.INT16, false) => SignatureTypeCode.Int16, + (CILParser.INT32_, false) => SignatureTypeCode.Int32, + (CILParser.INT64_, false) => SignatureTypeCode.Int64, + (CILParser.FLOAT32, false) => SignatureTypeCode.Single, + (CILParser.FLOAT64_, false) => SignatureTypeCode.Double, + (CILParser.UINT8, false) => SignatureTypeCode.Byte, + (CILParser.UINT16, false) => SignatureTypeCode.UInt16, + (CILParser.UINT32, false) => SignatureTypeCode.UInt32, + (CILParser.UINT64, false) => SignatureTypeCode.UInt64, + (CILParser.INT8, true) => SignatureTypeCode.Byte, + (CILParser.INT16, true) => SignatureTypeCode.UInt16, + (CILParser.INT32_, true) => SignatureTypeCode.UInt32, + (CILParser.INT64_, true) => SignatureTypeCode.UInt64, + _ => throw new UnreachableException() + }; + + return (byte)typeCode; + } + + internal byte GetNativeIntType() => (byte)SignatureTypeCode.IntPtr; + + internal byte GetNativeUIntType() => (byte)SignatureTypeCode.UIntPtr; + + internal object CreateClassTypeSpecification(object? className) + => new ClassTypeSpecificationValue(GetClassNameValue(className)); + + internal object CreateAssemblyTypeSpecification(string assemblyName) + => new AssemblyTypeSpecificationValue(assemblyName); + + internal object CreateModuleTypeSpecification(string moduleName) + => new ModuleTypeSpecificationValue(moduleName); + + internal object CreateSignatureTypeSpecification(object? type) + => new SignatureTypeSpecificationValue(GetTypeValue(type)); + + internal int GetGenericArity(CILParser.GenArityNotEmptyContext? context) + => context?.Value ?? 0; + + internal object CreateCalliSignature(byte callingConvention, object? returnType, object? arguments) + => new CalliSignatureValue( + callingConvention, + GetTypeValue(returnType), + GetSignatureArgumentsValue(arguments)); + + private BlobBuilder MaterializeCalliSignature(CalliSignatureValue calliSignature) + { + BlobBuilder signature = new(); + signature.WriteByte(calliSignature.CallingConvention); + ImmutableArray materializedArguments = MaterializeSignatureArguments(calliSignature.Arguments); + signature.WriteCompressedInteger(materializedArguments.Count(argument => !argument.IsSentinel)); + MaterializeType(calliSignature.ReturnType).WriteContentTo(signature); + foreach (SignatureArg argument in materializedArguments) + { + argument.SignatureBlob.WriteContentTo(signature); + } + + return signature; + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.References.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.References.cs new file mode 100644 index 00000000000000..05a40ceb13a5ae --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.References.cs @@ -0,0 +1,201 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Immutable; +using System.Linq; +using System.Reflection.Metadata; +using Antlr4.Runtime; + +namespace ILAssembler; + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. +internal sealed partial class GrammarActions +{ + internal object CreateMethodReference( + IToken token, + byte callingConvention, + object? returnType, + object? owner, + string name, + CILParser.TypeArgsContext? genericArguments, + int? genericArity, + object? arguments) + => new ParsedMethodReferenceValue( + token, + callingConvention, + GetTypeValue(returnType), + owner is null ? null : GetTypeSpecificationValue(owner), + name, + genericArguments is null ? null : GetTypeArgumentsValue(genericArguments.Value), + genericArity.GetValueOrDefault(), + GetSignatureArgumentsValue(arguments)); + + internal object CreateTokenMethodReference(int token) + => new TokenMethodReferenceValue(token); + + internal object CreateTypedefMethodReference(IToken token, string alias) + => new TypedefMethodReferenceValue(token, alias); + + internal object CreateFieldReference(object? fieldType, object? owner, string name) + => new ParsedFieldReferenceValue( + GetTypeValue(fieldType), + owner is null ? null : GetTypeSpecificationValue(owner), + name); + + internal object CreateTypedefFieldReference(IToken token, string alias) + => new TypedefFieldReferenceValue(token, alias); + + internal object CreateMethodMemberReference(object? method) + => new MethodMemberReferenceValue(GetMethodReferenceValue(method)); + + internal object CreateFieldMemberReference(object? field) + => new FieldMemberReferenceValue(GetFieldReferenceValue(field)); + + internal object CreateTokenMemberReference(int token) + => new TokenMemberReferenceValue(token); + + internal object CreateTypeOwner(object? type) + => new TypeOwnerValue(GetTypeSpecificationValue(type)); + + internal object CreateMemberOwner(object? member) + => new MemberOwnerValue(GetMemberReferenceValue(member)); + + private EntityRegistry.EntityBase MaterializeMethodReference(MethodReferenceValue methodReference) + { + switch (methodReference) + { + case TokenMethodReferenceValue token: + return ResolveMetadataToken(token.Token); + case TypedefMethodReferenceValue typedef: + if (TryResolveTypedefAsMember(typedef.Alias) is { } resolved) + { + return resolved; + } + ReportError( + DiagnosticIds.TypedefNotFound, + string.Format(DiagnosticMessageTemplates.TypedefNotFound, typedef.Alias), + typedef.Token); + return _entityRegistry.CreateLazilyRecordedMemberReference( + _entityRegistry.ModuleType, + typedef.Alias, + new BlobBuilder()); + case ParsedMethodReferenceValue parsed: + return MaterializeParsedMethodReference(parsed); + default: + return _entityRegistry.CreateLazilyRecordedMemberReference( + _entityRegistry.ModuleType, + "", + new BlobBuilder()); + } + } + + private EntityRegistry.EntityBase MaterializeParsedMethodReference(ParsedMethodReferenceValue methodReference) + { + byte callingConvention = methodReference.CallingConvention; + EntityRegistry.TypeEntity owner = methodReference.Owner is null + ? _entityRegistry.ModuleType + : ResolveTypeSpecification(methodReference.Owner); + + BlobBuilder? methodSpecificationSignature = null; + int genericArity = methodReference.GenericArity; + if (methodReference.GenericArguments is { } genericArguments) + { + genericArity = genericArguments.Length; + if (genericArity != 0) + { + methodSpecificationSignature = new BlobBuilder(); + methodSpecificationSignature.WriteByte((byte)SignatureKind.MethodSpecification); + MaterializeTypeArguments(genericArguments).WriteContentTo(methodSpecificationSignature); + } + } + + if (genericArity != 0) + { + callingConvention |= (byte)SignatureAttributes.Generic; + } + + if (_expectInstance && (callingConvention & (byte)SignatureAttributes.Instance) == 0) + { + ReportWarning( + DiagnosticIds.MissingInstanceCallConv, + DiagnosticMessageTemplates.MissingInstanceCallConv, + methodReference.Token); + callingConvention |= (byte)SignatureAttributes.Instance; + } + + BlobBuilder signature = new(); + signature.WriteByte(callingConvention); + if (genericArity != 0) + { + signature.WriteCompressedInteger(genericArity); + } + + ImmutableArray arguments = MaterializeSignatureArguments(methodReference.Arguments); + signature.WriteCompressedInteger(arguments.Count(argument => !argument.IsSentinel)); + MaterializeType(methodReference.ReturnType).WriteContentTo(signature); + foreach (SignatureArg argument in arguments) + { + argument.SignatureBlob.WriteContentTo(signature); + } + + EntityRegistry.MemberReferenceEntity memberReference = + _entityRegistry.CreateLazilyRecordedMemberReference(owner, methodReference.Name, signature); + return methodSpecificationSignature is null + ? memberReference + : _entityRegistry.GetOrCreateMethodSpecification(memberReference, methodSpecificationSignature); + } + + private EntityRegistry.EntityBase MaterializeFieldReference(FieldReferenceValue fieldReference) + { + switch (fieldReference) + { + case TypedefFieldReferenceValue typedef: + if (TryResolveTypedefAsMember(typedef.Alias) is { } resolved) + { + return resolved; + } + ReportError( + DiagnosticIds.TypedefNotFound, + string.Format(DiagnosticMessageTemplates.TypedefNotFound, typedef.Alias), + typedef.Token); + return _entityRegistry.CreateLazilyRecordedMemberReference( + _entityRegistry.ModuleType, + typedef.Alias, + new BlobBuilder()); + case ParsedFieldReferenceValue parsed: + BlobBuilder fieldType = MaterializeType(parsed.FieldType); + EntityRegistry.TypeEntity owner = parsed.Owner is null + ? _entityRegistry.ModuleType + : ResolveTypeSpecification(parsed.Owner); + BlobBuilder signature = new(fieldType.Count + 1); + signature.WriteByte((byte)SignatureKind.Field); + fieldType.WriteContentTo(signature); + return _entityRegistry.CreateLazilyRecordedMemberReference(owner, parsed.Name, signature); + default: + return _entityRegistry.CreateLazilyRecordedMemberReference( + _entityRegistry.ModuleType, + "", + new BlobBuilder()); + } + } + + private EntityRegistry.EntityBase MaterializeMemberReference(MemberReferenceValue memberReference) + => memberReference switch + { + MethodMemberReferenceValue method => MaterializeMethodReference(method.Method), + FieldMemberReferenceValue field => MaterializeFieldReference(field.Field), + TokenMemberReferenceValue token => ResolveMetadataToken(token.Token), + _ => _entityRegistry.CreateLazilyRecordedMemberReference( + _entityRegistry.ModuleType, + "", + new BlobBuilder()) + }; + + private EntityRegistry.EntityBase MaterializeOwnerType(OwnerTypeValue owner) + => owner switch + { + TypeOwnerValue type => ResolveTypeSpecification(type.Type), + MemberOwnerValue member => MaterializeMemberReference(member.Member), + _ => new EntityRegistry.FakeTypeEntity(default(TypeDefinitionHandle)) + }; +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Types.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Types.cs new file mode 100644 index 00000000000000..a371aa1d532ed7 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Types.cs @@ -0,0 +1,295 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Immutable; +using System.Linq; +using System.Reflection.Metadata; + +namespace ILAssembler; + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. +internal sealed partial class GrammarActions +{ + private BlobBuilder MaterializeType(TypeValue type) + { + const int DefaultSignatureElementBlobSize = 10; + + BlobBuilder elementType = MaterializeElementType(type.ElementType); + BlobBuilder prefix = new(DefaultSignatureElementBlobSize); + BlobBuilder suffix = new(DefaultSignatureElementBlobSize); + + for (int i = type.Modifiers.Length - 1; i >= 0; i--) + { + switch (type.Modifiers[i]) + { + case SimpleTypeModifierValue { Kind: SimpleTypeModifierKind.SzArray }: + prefix.WriteByte((byte)SignatureTypeCode.SZArray); + break; + case ArrayTypeModifierValue: + prefix.WriteByte((byte)SignatureTypeCode.Array); + break; + case SimpleTypeModifierValue { Kind: SimpleTypeModifierKind.ByReference }: + prefix.WriteByte((byte)SignatureTypeCode.ByReference); + break; + case SimpleTypeModifierValue { Kind: SimpleTypeModifierKind.Pointer }: + prefix.WriteByte((byte)SignatureTypeCode.Pointer); + break; + case SimpleTypeModifierValue { Kind: SimpleTypeModifierKind.Pinned }: + prefix.WriteByte((byte)SignatureTypeCode.Pinned); + break; + case CustomTypeModifierValue customModifier: + prefix.WriteByte((byte)(customModifier.IsRequired + ? SignatureTypeCode.RequiredModifier + : SignatureTypeCode.OptionalModifier)); + prefix.WriteTypeEntity(ResolveTypeSpecification(customModifier.Type)); + break; + case GenericArgumentsTypeModifierValue: + prefix.WriteByte((byte)SignatureTypeCode.GenericTypeInstance); + break; + } + } + + foreach (TypeModifierValue modifier in type.Modifiers) + { + switch (modifier) + { + case ArrayTypeModifierValue array: + WriteArrayShape(suffix, array.Bounds); + break; + case GenericArgumentsTypeModifierValue genericArguments: + MaterializeTypeArguments(genericArguments.Arguments).WriteContentTo(suffix); + break; + } + } + + // Work around https://github.com/dotnet/runtime/issues/127243 by writing to a separate blob. + BlobBuilder fullBlob = new(elementType.Count + prefix.Count + suffix.Count); + prefix.WriteContentTo(fullBlob); + elementType.WriteContentTo(fullBlob); + suffix.WriteContentTo(fullBlob); + return fullBlob; + } + + private BlobBuilder MaterializeElementType(ElementTypeValue elementType) + { + BlobBuilder blob = new(5); + switch (elementType) + { + case PrimitiveElementTypeValue primitive: + blob.WriteByte(primitive.TypeCode); + break; + case ClassElementTypeValue classType: + EntityRegistry.TypeEntity typeEntity = ResolveClassName(classType.ClassName); + if (TryGetPrimitiveTypeCode(typeEntity, classType.IsValueType) is { } primitiveTypeCode) + { + blob.WriteByte((byte)primitiveTypeCode); + } + else + { + blob.WriteByte((byte)(classType.IsValueType ? SignatureTypeKind.ValueType : SignatureTypeKind.Class)); + blob.WriteTypeEntity(typeEntity); + } + break; + case FunctionPointerElementTypeValue functionPointer: + blob.WriteByte((byte)SignatureTypeCode.FunctionPointer); + blob.WriteByte(functionPointer.CallingConvention); + ImmutableArray arguments = MaterializeSignatureArguments(functionPointer.Arguments); + blob.WriteCompressedInteger(arguments.Count(argument => !argument.IsSentinel)); + blob.LinkSuffix(MaterializeType(functionPointer.ReturnType)); + foreach (SignatureArg argument in arguments) + { + blob.LinkSuffix(argument.SignatureBlob); + } + break; + case IndexedGenericParameterElementTypeValue indexedGenericParameter: + blob.WriteByte((byte)(indexedGenericParameter.IsMethodParameter + ? SignatureTypeCode.GenericMethodParameter + : SignatureTypeCode.GenericTypeParameter)); + // Always emit indexed generic parameters, including intentionally invalid IL. + blob.WriteCompressedInteger(indexedGenericParameter.Index); + break; + case NamedGenericParameterElementTypeValue namedGenericParameter: + WriteNamedGenericParameter(blob, namedGenericParameter); + break; + case TypedefElementTypeValue typedef: + if (TryResolveTypedefAsTypeBlob(typedef.Alias) is { } resolved) + { + resolved.WriteContentTo(blob); + } + else + { + ReportError( + DiagnosticIds.TypedefNotFound, + string.Format(DiagnosticMessageTemplates.TypedefNotFound, typedef.Alias), + typedef.Token); + } + break; + case SentinelElementTypeValue sentinel: + blob.WriteByte((byte)SignatureTypeCode.Sentinel); + blob.LinkSuffix(MaterializeType(sentinel.Type)); + break; + } + + return blob; + } + + private void WriteNamedGenericParameter(BlobBuilder blob, NamedGenericParameterElementTypeValue genericParameter) + { + blob.WriteByte((byte)(genericParameter.IsMethodParameter + ? SignatureTypeCode.GenericMethodParameter + : SignatureTypeCode.GenericTypeParameter)); + + string name = genericParameter.Name; + if (genericParameter.IsMethodParameter) + { + if (_currentMethod is null) + { + ReportError( + DiagnosticIds.MethodTypeParameterOutsideMethod, + string.Format(DiagnosticMessageTemplates.MethodTypeParameterOutsideMethod, name), + genericParameter.Token); + blob.WriteCompressedInteger(0); + return; + } + + for (int i = 0; i < _currentMethod.Definition.GenericParameters.Count; i++) + { + if (_currentMethod.Definition.GenericParameters[i].Name == name) + { + blob.WriteCompressedInteger(i); + return; + } + } + } + else + { + if (_currentTypeDefinition.Count == 0) + { + ReportError( + DiagnosticIds.TypeParameterOutsideType, + string.Format(DiagnosticMessageTemplates.TypeParameterOutsideType, name), + genericParameter.Token); + blob.WriteCompressedInteger(0); + return; + } + + for (int i = 0; i < _currentTypeDefinition.Peek().GenericParameters.Count; i++) + { + if (_currentTypeDefinition.Peek().GenericParameters[i].Name == name) + { + blob.WriteCompressedInteger(i); + return; + } + } + } + + ReportError( + DiagnosticIds.GenericParameterNotFound, + string.Format(DiagnosticMessageTemplates.GenericParameterNotFound, name), + genericParameter.Token); + blob.WriteCompressedInteger(0); + } + + private ImmutableArray MaterializeSignatureArguments(ImmutableArray arguments) + { + ImmutableArray.Builder builder = ImmutableArray.CreateBuilder(arguments.Length); + foreach (SignatureArgumentValue argument in arguments) + { + builder.Add(MaterializeSignatureArgument(argument)); + } + return builder.MoveToImmutable(); + } + + private SignatureArg MaterializeSignatureArgument(SignatureArgumentValue argument) + { + if (argument.IsSentinel) + { + return SignatureArg.CreateSentinelArgument(); + } + + return new SignatureArg( + (System.Reflection.ParameterAttributes)argument.Attributes, + MaterializeType(argument.Type ?? TypeValue.Error), + argument.Marshalling is null ? new BlobBuilder(0) : VisitMarshalClause(argument.Marshalling).Value, + argument.Name); + } + + private BlobBuilder MaterializeTypeArguments(ImmutableArray arguments) + { + BlobBuilder blob = new(4); + blob.WriteCompressedInteger(arguments.Length); + foreach (TypeValue argument in arguments) + { + blob.LinkSuffix(MaterializeType(argument)); + } + return blob; + } + + private static void WriteArrayShape(BlobBuilder suffix, ImmutableArray bounds) + { + suffix.WriteCompressedInteger(bounds.Length); + + int sizeCount = 0; + while (sizeCount < bounds.Length && bounds[sizeCount].Upper is not null) + { + sizeCount++; + } + + suffix.WriteCompressedInteger(sizeCount); + for (int i = 0; i < sizeCount; i++) + { + suffix.WriteCompressedInteger(bounds[i].Upper.GetValueOrDefault()); + } + + int lowerBoundCount = 0; + while (lowerBoundCount < bounds.Length && bounds[lowerBoundCount].Lower is not null) + { + lowerBoundCount++; + } + + suffix.WriteCompressedInteger(lowerBoundCount); + for (int i = 0; i < lowerBoundCount; i++) + { + suffix.WriteCompressedSignedInteger(bounds[i].Lower.GetValueOrDefault()); + } + } + + private static SignatureTypeCode? TryGetPrimitiveTypeCode(EntityRegistry.TypeEntity typeEntity, bool isValueType) + { + if (typeEntity is not EntityRegistry.TypeReferenceEntity typeReference || typeReference.Namespace != "System") + { + return null; + } + + if (isValueType) + { + return typeReference.Name switch + { + "Boolean" => SignatureTypeCode.Boolean, + "Char" => SignatureTypeCode.Char, + "SByte" => SignatureTypeCode.SByte, + "Byte" => SignatureTypeCode.Byte, + "Int16" => SignatureTypeCode.Int16, + "UInt16" => SignatureTypeCode.UInt16, + "Int32" => SignatureTypeCode.Int32, + "UInt32" => SignatureTypeCode.UInt32, + "Int64" => SignatureTypeCode.Int64, + "UInt64" => SignatureTypeCode.UInt64, + "Single" => SignatureTypeCode.Single, + "Double" => SignatureTypeCode.Double, + "IntPtr" => SignatureTypeCode.IntPtr, + "UIntPtr" => SignatureTypeCode.UIntPtr, + "TypedReference" => SignatureTypeCode.TypedReference, + _ => null + }; + } + + return typeReference.Name switch + { + "String" => SignatureTypeCode.String, + "Object" => SignatureTypeCode.Object, + _ => null + }; + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Values.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Values.cs new file mode 100644 index 00000000000000..d0f29526dc7aa0 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Values.cs @@ -0,0 +1,242 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Immutable; +using Antlr4.Runtime; + +namespace ILAssembler; + +internal sealed partial class GrammarActions +{ + // ANTLR context classes are public, but these implementation values must remain internal. + // Grammar return slots therefore use object and are unwrapped only by these strongly typed helpers. + private static T GetSemanticValue(object? value, T fallback) + where T : class + => value as T ?? fallback; + + private static TypeValue GetTypeValue(object? value) + => GetSemanticValue(value, TypeValue.Error); + + private static ElementTypeValue GetElementTypeValue(object? value) + => GetSemanticValue(value, ElementTypeValue.Error); + + private static TypeModifierValue GetTypeModifierValue(object? value) + => GetSemanticValue(value, TypeModifierValue.Error); + + private static ImmutableArray GetTypeArgumentsValue(object? value) + => value is ImmutableArray arguments ? arguments : []; + + private static ImmutableArray GetBoundsValue(object? value) + => value is ImmutableArray bounds ? bounds : []; + + private static SignatureArgumentValue GetSignatureArgumentValue(object? value) + => GetSemanticValue(value, SignatureArgumentValue.Error); + + private static ImmutableArray GetSignatureArgumentsValue(object? value) + => value is ImmutableArray arguments ? arguments : []; + + private static TypeName GetTypeNameValue(object? value) + => value as TypeName ?? new TypeName(null, string.Empty); + + private static TypeName GetSlashedNameValue(CILParser.SlashedNameContext context) + => GetTypeNameValue(context.Value); + + private static ClassNameValue GetClassNameValue(object? value) + => GetSemanticValue(value, ClassNameValue.Error); + + private static TypeSpecificationValue GetTypeSpecificationValue(object? value) + => GetSemanticValue(value, TypeSpecificationValue.Error); + + private static MethodReferenceValue GetMethodReferenceValue(object? value) + => GetSemanticValue(value, MethodReferenceValue.Error); + + private static FieldReferenceValue GetFieldReferenceValue(object? value) + => GetSemanticValue(value, FieldReferenceValue.Error); + + private static MemberReferenceValue GetMemberReferenceValue(object? value) + => GetSemanticValue(value, MemberReferenceValue.Error); + + private static OwnerTypeValue GetOwnerTypeValue(object? value) + => GetSemanticValue(value, OwnerTypeValue.Error); + + private static CalliSignatureValue GetCalliSignatureValue(object? value) + => GetSemanticValue(value, CalliSignatureValue.Error); + + private sealed record ArrayBoundValue(int? Lower, int? Upper); + + private abstract record ElementTypeValue + { + public static ElementTypeValue Error { get; } = new ErrorElementTypeValue(); + } + + private sealed record ErrorElementTypeValue : ElementTypeValue; + + private sealed record PrimitiveElementTypeValue(byte TypeCode) : ElementTypeValue; + + private sealed record ClassElementTypeValue(ClassNameValue ClassName, bool IsValueType) : ElementTypeValue; + + private sealed record FunctionPointerElementTypeValue( + byte CallingConvention, + TypeValue ReturnType, + ImmutableArray Arguments) : ElementTypeValue; + + private abstract record GenericParameterElementTypeValue(bool IsMethodParameter) : ElementTypeValue; + + private sealed record IndexedGenericParameterElementTypeValue(bool IsMethodParameter, int Index) + : GenericParameterElementTypeValue(IsMethodParameter); + + private sealed record NamedGenericParameterElementTypeValue(IToken Token, bool IsMethodParameter, string Name) + : GenericParameterElementTypeValue(IsMethodParameter); + + private sealed record TypedefElementTypeValue(IToken Token, string Alias) : ElementTypeValue; + + private sealed record SentinelElementTypeValue(TypeValue Type) : ElementTypeValue; + + private sealed record TypeValue(ElementTypeValue ElementType, ImmutableArray Modifiers) + { + public static TypeValue Error { get; } = new(ElementTypeValue.Error, []); + } + + private abstract record TypeModifierValue + { + public static TypeModifierValue Error { get; } = new ErrorTypeModifierValue(); + } + + private sealed record ErrorTypeModifierValue : TypeModifierValue; + + private enum SimpleTypeModifierKind + { + SzArray, + ByReference, + Pointer, + Pinned + } + + private sealed record SimpleTypeModifierValue(SimpleTypeModifierKind Kind) : TypeModifierValue; + + private sealed record ArrayTypeModifierValue(ImmutableArray Bounds) : TypeModifierValue; + + private sealed record CustomTypeModifierValue(TypeSpecificationValue Type, bool IsRequired) : TypeModifierValue; + + private sealed record GenericArgumentsTypeModifierValue(ImmutableArray Arguments) : TypeModifierValue; + + private sealed record SignatureArgumentValue( + bool IsSentinel, + int Attributes, + TypeValue? Type, + CILParser.MarshalClauseContext? Marshalling, + string? Name) + { + public static SignatureArgumentValue Error { get; } = new(false, 0, TypeValue.Error, null, null); + } + + private sealed record CalliSignatureValue( + byte CallingConvention, + TypeValue ReturnType, + ImmutableArray Arguments) + { + public static CalliSignatureValue Error { get; } = new(0, TypeValue.Error, []); + } + + private abstract record ClassNameValue + { + public static ClassNameValue Error { get; } = new ErrorClassNameValue(); + } + + private sealed record ErrorClassNameValue : ClassNameValue; + + private sealed record UnqualifiedClassNameValue(TypeName Name) : ClassNameValue; + + private sealed record AssemblyQualifiedClassNameValue(string AssemblyName, TypeName Name) : ClassNameValue; + + private sealed record ModuleQualifiedClassNameValue(IToken Token, string ModuleName, TypeName Name) : ClassNameValue; + + private sealed record TokenQualifiedClassNameValue(int Token, TypeName Name) : ClassNameValue; + + private sealed record PointerQualifiedClassNameValue(TypeName Name) : ClassNameValue; + + private sealed record TokenClassNameValue(int Token) : ClassNameValue; + + private enum SpecialClassNameKind + { + This, + Base, + Nester + } + + private sealed record SpecialClassNameValue(IToken Token, SpecialClassNameKind Kind) : ClassNameValue; + + private abstract record TypeSpecificationValue + { + public static TypeSpecificationValue Error { get; } = new ErrorTypeSpecificationValue(); + } + + private sealed record ErrorTypeSpecificationValue : TypeSpecificationValue; + + private sealed record ClassTypeSpecificationValue(ClassNameValue ClassName) : TypeSpecificationValue; + + private sealed record AssemblyTypeSpecificationValue(string AssemblyName) : TypeSpecificationValue; + + private sealed record ModuleTypeSpecificationValue(string ModuleName) : TypeSpecificationValue; + + private sealed record SignatureTypeSpecificationValue(TypeValue Type) : TypeSpecificationValue; + + private abstract record MethodReferenceValue + { + public static MethodReferenceValue Error { get; } = new ErrorMethodReferenceValue(); + } + + private sealed record ErrorMethodReferenceValue : MethodReferenceValue; + + private sealed record TokenMethodReferenceValue(int Token) : MethodReferenceValue; + + private sealed record TypedefMethodReferenceValue(IToken Token, string Alias) : MethodReferenceValue; + + private sealed record ParsedMethodReferenceValue( + IToken Token, + byte CallingConvention, + TypeValue ReturnType, + TypeSpecificationValue? Owner, + string Name, + ImmutableArray? GenericArguments, + int GenericArity, + ImmutableArray Arguments) : MethodReferenceValue; + + private abstract record FieldReferenceValue + { + public static FieldReferenceValue Error { get; } = new ErrorFieldReferenceValue(); + } + + private sealed record ErrorFieldReferenceValue : FieldReferenceValue; + + private sealed record TypedefFieldReferenceValue(IToken Token, string Alias) : FieldReferenceValue; + + private sealed record ParsedFieldReferenceValue( + TypeValue FieldType, + TypeSpecificationValue? Owner, + string Name) : FieldReferenceValue; + + private abstract record MemberReferenceValue + { + public static MemberReferenceValue Error { get; } = new ErrorMemberReferenceValue(); + } + + private sealed record ErrorMemberReferenceValue : MemberReferenceValue; + + private sealed record MethodMemberReferenceValue(MethodReferenceValue Method) : MemberReferenceValue; + + private sealed record FieldMemberReferenceValue(FieldReferenceValue Field) : MemberReferenceValue; + + private sealed record TokenMemberReferenceValue(int Token) : MemberReferenceValue; + + private abstract record OwnerTypeValue + { + public static OwnerTypeValue Error { get; } = new ErrorOwnerTypeValue(); + } + + private sealed record ErrorOwnerTypeValue : OwnerTypeValue; + + private sealed record TypeOwnerValue(TypeSpecificationValue Type) : OwnerTypeValue; + + private sealed record MemberOwnerValue(MemberReferenceValue Member) : OwnerTypeValue; +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.cs index c5318c6ac47799..58204bbbaf52ba 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.cs @@ -2,762 +2,216 @@ // The .NET Foundation licenses this file to you under the MIT license. using System; -using System.Buffers.Binary; -using System.Collections.Generic; using System.Collections.Immutable; using System.Diagnostics; -using System.Globalization; -using System.IO; using System.Linq; using System.Reflection; using System.Reflection.Metadata; -using System.Reflection.Metadata.Ecma335; -using System.Reflection.PortableExecutable; -using System.Runtime.InteropServices; -using System.Security.Cryptography; -using System.Text; -using Antlr4.Runtime; -using Antlr4.Runtime.Misc; -using Antlr4.Runtime.Tree; - -namespace ILAssembler + +namespace ILAssembler; + +#pragma warning disable CA1822 // Visitor wrappers intentionally preserve the existing instance API. +internal sealed partial class GrammarActions { -#pragma warning disable CA1822 // Mark members as static - internal sealed partial class GrammarActions : ICILVisitor - { - GrammarResult ICILVisitor.VisitBound(CILParser.BoundContext context) => VisitBound(context); - public GrammarResult.Literal<(int? Lower, int? Upper)> VisitBound(CILParser.BoundContext context) - { - bool hasEllipsis = context.ELLIPSIS() is not null; - var indices = context.int32(); - - if (indices.Length == 0) - { - // Empty or standalone "..." - return new((null, null)); - } - - int firstValue = VisitInt32(indices[0]).Value; - - return (indices.Length, hasEllipsis) switch - { - (1, false) => new((0, firstValue)), - (1, true) => new((firstValue, null)), - (2, _) => new((firstValue, VisitInt32(indices[1]).Value - firstValue + 1)), - _ => throw new UnreachableException() - }; - } + GrammarResult ICILVisitor.VisitBound(CILParser.BoundContext context) => VisitBound(context); - GrammarResult ICILVisitor.VisitBounds(CILParser.BoundsContext context) => VisitBounds(context); - public GrammarResult.Sequence<(int? Lower, int? Upper)> VisitBounds(CILParser.BoundsContext context) - { - return new(context.bound().Select(bound => VisitBound(bound).Value).ToImmutableArray()); - } + public GrammarResult.Literal<(int? Lower, int? Upper)> VisitBound(CILParser.BoundContext context) + => new(( + context.HasLower ? context.Lower : null, + context.HasUpper ? context.Upper : null)); - GrammarResult ICILVisitor.VisitCallConv(CILParser.CallConvContext context) => VisitCallConv(context); - public GrammarResult.Literal VisitCallConv(CILParser.CallConvContext context) - { - if (context.callKind() is CILParser.CallKindContext callKind) - { - return new((byte)VisitCallKind(callKind).Value); - } - else if (context.int32() is CILParser.Int32Context int32) - { - return new((byte)VisitInt32(int32).Value); - } - else if (context.INSTANCE() is not null) - { - return new((byte)(VisitCallConv(context.callConv()).Value | (byte)SignatureAttributes.Instance)); - } - else if (context.EXPLICIT() is not null) - { - return new((byte)( - VisitCallConv(context.callConv()).Value | - (byte)(SignatureAttributes.ExplicitThis | SignatureAttributes.Instance))); - } - return new(0); - } - GrammarResult ICILVisitor.VisitCallKind(CILParser.CallKindContext context) => VisitCallKind(context); - public GrammarResult.Literal VisitCallKind(CILParser.CallKindContext context) - { - // callKind can be empty (/* EMPTY */) - return Default in that case - if (context.ChildCount == 0) - { - return new(SignatureCallingConvention.Default); - } - int childType = context.GetChild(context.ChildCount - 1).Symbol.Type; - return new(childType switch - { - CILParser.DEFAULT => SignatureCallingConvention.Default, - CILParser.VARARG => SignatureCallingConvention.VarArgs, - CILParser.CDECL => SignatureCallingConvention.CDecl, - CILParser.STDCALL => SignatureCallingConvention.StdCall, - CILParser.THISCALL => SignatureCallingConvention.ThisCall, - CILParser.FASTCALL => SignatureCallingConvention.FastCall, - CILParser.UNMANAGED => SignatureCallingConvention.Unmanaged, - _ => throw new UnreachableException() - }); - } + GrammarResult ICILVisitor.VisitBounds(CILParser.BoundsContext context) => VisitBounds(context); - private BlobBuilder BuildMethodReferenceSignature( - CILParser.CallConvContext callConvention, - CILParser.TypeContext returnType, - CILParser.SigArgsContext signatureArguments, - int genericArity) - { - var signature = new BlobBuilder(); - byte header = VisitCallConv(callConvention).Value; - if (genericArity > 0) - { - header |= (byte)SignatureAttributes.Generic; - } - - signature.WriteByte(header); - if (genericArity > 0) - { - signature.WriteCompressedInteger(genericArity); - } - - ImmutableArray arguments = VisitSigArgs(signatureArguments).Value; - signature.WriteCompressedInteger(arguments.Count(argument => !argument.IsSentinel)); - VisitType(returnType).Value.WriteContentTo(signature); - foreach (SignatureArg argument in arguments) - { - argument.SignatureBlob.WriteContentTo(signature); - } - - return signature; - } - GrammarResult ICILVisitor.VisitElementType(CILParser.ElementTypeContext context) => VisitElementType(context); - public GrammarResult.FormattedBlob VisitElementType(CILParser.ElementTypeContext context) - { - BlobBuilder blob = new(5); - if (context.OBJECT() is not null) - { - blob.WriteByte((byte)SignatureTypeCode.Object); - } - else if (context.className() is CILParser.ClassNameContext className) - { - EntityRegistry.TypeEntity typeEntity = VisitClassName(className).Value; - if (context.VALUE() is not null || context.VALUETYPE() is not null) - { - // Check for well-known value types that should use primitive type codes - if (TryGetPrimitiveTypeCode(typeEntity, isValueType: true) is { } vtPrimCode) - { - blob.WriteByte((byte)vtPrimCode); - } - else - { - blob.WriteByte((byte)SignatureTypeKind.ValueType); - blob.WriteTypeEntity(typeEntity); - } - } - else - { - // Check for well-known class types that should use primitive type codes - if (TryGetPrimitiveTypeCode(typeEntity, isValueType: false) is { } clsPrimCode) - { - blob.WriteByte((byte)clsPrimCode); - } - else - { - blob.WriteByte((byte)SignatureTypeKind.Class); - blob.WriteTypeEntity(typeEntity); - } - } - } - else if (context.callConv() is CILParser.CallConvContext callConv) - { - // Emit function pointer signature. - blob.WriteByte((byte)SignatureTypeCode.FunctionPointer); - byte sigCallConv = VisitCallConv(callConv).Value; - blob.WriteByte(sigCallConv); - var signatureArgs = VisitSigArgs(context.sigArgs()).Value; - int numArgs = signatureArgs.Count(arg => !arg.IsSentinel); - blob.WriteCompressedInteger(numArgs); - blob.LinkSuffix(VisitType(context.type()).Value); - foreach (var arg in signatureArgs) - { - blob.LinkSuffix(arg.SignatureBlob); - } - } - else if (context.ELLIPSIS() is not null) - { - blob.WriteByte((byte)SignatureTypeCode.Sentinel); - blob.LinkSuffix(VisitType(context.type()).Value); - } - else if (context.METHOD_TYPE_PARAMETER() is not null) - { - if (context.int32() is CILParser.Int32Context int32) - { - // COMPAT: Always write a reference to a generic method parameter by index - // even if we aren't in a method or the index is out of range. We want to be able to write invalid IL like this. - blob.WriteByte((byte)SignatureTypeCode.GenericMethodParameter); - blob.WriteCompressedInteger(VisitInt32(int32).Value); - } - else - { - string dottedName = VisitDottedName(context.dottedName()).Value; - if (_currentMethod is null) - { - ReportError(DiagnosticIds.MethodTypeParameterOutsideMethod, string.Format(DiagnosticMessageTemplates.MethodTypeParameterOutsideMethod, dottedName), context); - blob.WriteByte((byte)SignatureTypeCode.GenericMethodParameter); - blob.WriteCompressedInteger(0); - } - else - { - blob.WriteByte((byte)SignatureTypeCode.GenericMethodParameter); - bool foundParameter = false; - for (int i = 0; i < _currentMethod.Definition.GenericParameters.Count; i++) - { - EntityRegistry.GenericParameterEntity? genericParameter = _currentMethod.Definition.GenericParameters[i]; - if (genericParameter.Name == dottedName) - { - foundParameter = true; - blob.WriteCompressedInteger(i); - break; - } - } - if (!foundParameter) - { - // BREAK-COMPAT: ILASM would silently emit an invalid signature when a method uses an invalid method type parameter but doesn't have method type parameters. - // The signature used completely invalid undocumented codes (that were really sentinel values for how ilasm later detected errors due to how the parsing model worked with a YACC-based parser) - // and when a method had no type parameters, it didn't run the code to process out these values and emit errors. - // This seems like a scenario that doesn't need to be brought forward. - // Instead, we'll just emit a reference to "generic method parameter" 0 and report an error. - - ReportError(DiagnosticIds.GenericParameterNotFound, string.Format(DiagnosticMessageTemplates.GenericParameterNotFound, dottedName), context); - blob.WriteCompressedInteger(0); - } - } - } - } - else if (context.TYPE_PARAMETER() is not null) - { - if (context.int32() is CILParser.Int32Context int32) - { - // COMPAT: Always write a reference to a generic type parameter by index - // even if we aren't in a type or the index is out of range. We want to be able to write invalid IL like this. - blob.WriteByte((byte)SignatureTypeCode.GenericTypeParameter); - blob.WriteCompressedInteger(VisitInt32(int32).Value); - } - else - { - string dottedName = VisitDottedName(context.dottedName()).Value; - if (_currentTypeDefinition.Count == 0) - { - ReportError(DiagnosticIds.TypeParameterOutsideType, string.Format(DiagnosticMessageTemplates.TypeParameterOutsideType, dottedName), context); - blob.WriteByte((byte)SignatureTypeCode.GenericTypeParameter); - blob.WriteCompressedInteger(0); - } - else - { - blob.WriteByte((byte)SignatureTypeCode.GenericTypeParameter); - bool foundParameter = false; - for (int i = 0; i < _currentTypeDefinition.Peek().GenericParameters.Count; i++) - { - EntityRegistry.GenericParameterEntity? genericParameter = _currentTypeDefinition.Peek().GenericParameters[i]; - if (genericParameter.Name == dottedName) - { - foundParameter = true; - blob.WriteCompressedInteger(i); - break; - } - } - if (!foundParameter) - { - // BREAK-COMPAT: ILASM would silently emit an invalid signature when a type uses an invalid method type parameter but doesn't have any type parameters. - // The signature used completely invalid undocumented codes (that were really sentinel values for how ilasm later detected errors due to how the parsing model worked with a YACC-based parser) - // and when a method had no type parameters, it didn't run the code to process out these values and emit errors. - // This seems like a scenario that doesn't need to be brought forward. - // Instead, we'll just emit a reference to "generic method parameter" 0 and report an error. - - ReportError(DiagnosticIds.GenericParameterNotFound, string.Format(DiagnosticMessageTemplates.GenericParameterNotFound, dottedName), context); - blob.WriteCompressedInteger(0); - } - } - } - } - else if (context.TYPEDREF() is not null) - { - blob.WriteByte((byte)SignatureTypeCode.TypedReference); - } - else if (context.VOID() is not null) - { - blob.WriteByte((byte)SignatureTypeCode.Void); - } - else if (context.nativeInt() is not null) - { - blob.WriteByte((byte)SignatureTypeCode.IntPtr); - } - else if (context.nativeUint() is not null) - { - blob.WriteByte((byte)SignatureTypeCode.UIntPtr); - } - else if (context.simpleType() is CILParser.SimpleTypeContext simpleType) - { - blob.WriteByte((byte)VisitSimpleType(simpleType).Value); - } - else if (context.dottedName() is CILParser.DottedNameContext dottedName) - { - // Typedef reference - resolve and write the type blob - string alias = VisitDottedName(dottedName).Value; - var resolved = TryResolveTypedefAsTypeBlob(alias); - if (resolved is not null) - { - // Copy the content to avoid modifying the stored blob - resolved.WriteContentTo(blob); - } - else - { - ReportError(DiagnosticIds.TypedefNotFound, string.Format(DiagnosticMessageTemplates.TypedefNotFound, alias), context); - } - } - else - { - throw new UnreachableException(); - } - return new(blob); - } - GrammarResult ICILVisitor.VisitGenArity(CILParser.GenArityContext context) => VisitGenArity(context); - public GrammarResult.Literal VisitGenArity(CILParser.GenArityContext context) - => context.genArityNotEmpty() is CILParser.GenArityNotEmptyContext genArity ? VisitGenArityNotEmpty(genArity) : new(0); + public GrammarResult.Sequence<(int? Lower, int? Upper)> VisitBounds(CILParser.BoundsContext context) + => new(GetBoundsValue(context.Value) + .Select(bound => (bound.Lower, bound.Upper)) + .ToImmutableArray()); - GrammarResult ICILVisitor.VisitGenArityNotEmpty(CILParser.GenArityNotEmptyContext context) => VisitGenArityNotEmpty(context); - public GrammarResult.Literal VisitGenArityNotEmpty(CILParser.GenArityNotEmptyContext context) => VisitInt32(context.int32()); + GrammarResult ICILVisitor.VisitCallConv(CILParser.CallConvContext context) => VisitCallConv(context); - GrammarResult ICILVisitor.VisitNativeInt(CILParser.NativeIntContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - GrammarResult ICILVisitor.VisitNativeUint(CILParser.NativeUintContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + public static GrammarResult.Literal VisitCallConv(CILParser.CallConvContext context) + => new(context.Value); - GrammarResult ICILVisitor.VisitMethodRef(CILParser.MethodRefContext context) => VisitMethodRef(context); - public GrammarResult.Literal VisitMethodRef(CILParser.MethodRefContext context) - { - if (context.mdtoken() is CILParser.MdtokenContext token) - { - return new(VisitMdtoken(token).Value); - } - if (context.dottedName() is CILParser.DottedNameContext dottedName) - { - // This is a typedef reference for a method member - string alias = VisitDottedName(dottedName).Value; - var resolved = TryResolveTypedefAsMember(alias); - if (resolved is not null) - { - return new(resolved); - } - ReportError(DiagnosticIds.TypedefNotFound, string.Format(DiagnosticMessageTemplates.TypedefNotFound, alias), context); - return new(_entityRegistry.CreateLazilyRecordedMemberReference(_entityRegistry.ModuleType, alias, new BlobBuilder())); - } - BlobBuilder methodRefSignature = new(); - if (context.callConv() is not CILParser.CallConvContext callConvCtx) - { - // Parse error recovery - callConv is missing - return new(_entityRegistry.CreateLazilyRecordedMemberReference(_entityRegistry.ModuleType, "", methodRefSignature)); - } - byte callConv = VisitCallConv(callConvCtx).Value; - EntityRegistry.TypeEntity owner = _entityRegistry.ModuleType; - if (context.typeSpec() is CILParser.TypeSpecContext typeSpec) - { - owner = VisitTypeSpec(typeSpec).Value; - } - string name = VisitMethodName(context.methodName()).Value; - BlobBuilder? methodSpecSignature = null; - int numGenericParameters = 0; - if (context.typeArgs() is CILParser.TypeArgsContext typeArgs) - { - var types = typeArgs.type(); - numGenericParameters = types.Length; - if (types.Length != 0) - { - methodSpecSignature = new(); - methodSpecSignature.WriteByte((byte)SignatureKind.MethodSpecification); - VisitTypeArgs(typeArgs).Value.WriteContentTo(methodSpecSignature); - } - } - else if (context.genArityNotEmpty() is CILParser.GenArityNotEmptyContext genArityNotEmpty) - { - numGenericParameters = VisitGenArityNotEmpty(genArityNotEmpty).Value; - } - if (numGenericParameters != 0) - { - callConv |= (byte)SignatureAttributes.Generic; - } - if (_expectInstance && (callConv & (byte)SignatureAttributes.Instance) == 0) - { - ReportWarning(DiagnosticIds.MissingInstanceCallConv, - DiagnosticMessageTemplates.MissingInstanceCallConv, - context); - callConv |= (byte)SignatureAttributes.Instance; - } - methodRefSignature.WriteByte(callConv); - if (numGenericParameters != 0) - { - methodRefSignature.WriteCompressedInteger(numGenericParameters); - } - var args = VisitSigArgs(context.sigArgs()).Value; - methodRefSignature.WriteCompressedInteger(args.Count(arg => !arg.IsSentinel)); - // Write return type - VisitType(context.type()).Value.WriteContentTo(methodRefSignature); - // Write arg signatures - foreach (var arg in args) - { - arg.SignatureBlob.WriteContentTo(methodRefSignature); - } - - var memberRef = _entityRegistry.CreateLazilyRecordedMemberReference(owner, name, methodRefSignature); - - if (methodSpecSignature is not null) - { - return new(_entityRegistry.GetOrCreateMethodSpecification(memberRef, methodSpecSignature)); - } - - return new(memberRef); - } + GrammarResult ICILVisitor.VisitCallKind(CILParser.CallKindContext context) => VisitCallKind(context); - private EntityRegistry.MemberReferenceEntity CreateExplicitMethodReference( - CILParser.CallConvContext callConv, - CILParser.TypeContext returnType, - CILParser.TypeSpecContext owner, - CILParser.MethodNameContext methodName, - CILParser.GenArityContext? genericArity, - CILParser.SigArgsContext parameterList) - { - EntityRegistry.TypeEntity ownerType = VisitTypeSpec(owner).Value; - string name = VisitMethodName(methodName).Value; - return _entityRegistry.CreateLazilyRecordedMemberReference( - ownerType, - name, - CreateExplicitMethodSignature(callConv, returnType, genericArity, parameterList)); - } + public static GrammarResult.Literal VisitCallKind(CILParser.CallKindContext context) + => new((SignatureCallingConvention)context.Value); - private BlobBuilder CreateExplicitMethodSignature( - CILParser.CallConvContext callConv, - CILParser.TypeContext returnType, - CILParser.GenArityContext? genericArity, - CILParser.SigArgsContext parameterList) + private BlobBuilder BuildMethodReferenceSignature( + CILParser.CallConvContext callConvention, + CILParser.TypeContext returnType, + CILParser.SigArgsContext signatureArguments, + int genericArity) + { + BlobBuilder signature = new(); + byte header = VisitCallConv(callConvention).Value; + if (genericArity > 0) { - BlobBuilder signature = new(); - byte signatureHeader = VisitCallConv(callConv).Value; - int arity = genericArity is null ? 0 : VisitGenArity(genericArity).Value; - if (arity != 0) - { - signatureHeader |= (byte)SignatureAttributes.Generic; - } - - signature.WriteByte(signatureHeader); - if (arity != 0) - { - signature.WriteCompressedInteger(arity); - } - - ImmutableArray parameters = VisitSigArgs(parameterList).Value; - signature.WriteCompressedInteger(parameters.Count(parameter => !parameter.IsSentinel)); - VisitType(returnType).Value.WriteContentTo(signature); - foreach (SignatureArg parameter in parameters) - { - parameter.SignatureBlob.WriteContentTo(signature); - } - - return signature; + header |= (byte)SignatureAttributes.Generic; } - GrammarResult ICILVisitor.VisitParamAttr(CILParser.ParamAttrContext context) => VisitParamAttr(context); - public GrammarResult.Literal VisitParamAttr(CILParser.ParamAttrContext context) + signature.WriteByte(header); + if (genericArity > 0) { - ParameterAttributes attributes = 0; - foreach (var element in context.paramAttrElement()) - { - attributes |= VisitParamAttrElement(element); - } - return new(attributes); + signature.WriteCompressedInteger(genericArity); } - GrammarResult ICILVisitor.VisitParamAttrElement(CILParser.ParamAttrElementContext context) => VisitParamAttrElement(context); - public GrammarResult.Flag VisitParamAttrElement(CILParser.ParamAttrElementContext context) + ImmutableArray arguments = VisitSigArgs(signatureArguments).Value; + signature.WriteCompressedInteger(arguments.Count(argument => !argument.IsSentinel)); + VisitType(returnType).Value.WriteContentTo(signature); + foreach (SignatureArg argument in arguments) { - if (context.int32() is CILParser.Int32Context int32) - { - return new((ParameterAttributes)(VisitInt32(int32).Value + 1), ShouldAppend: false); - } - return context switch - { - { @in: not null } => new(ParameterAttributes.In), - { @out: not null } => new(ParameterAttributes.Out), - { opt: not null } => new(ParameterAttributes.Optional), - _ => throw new UnreachableException() - }; + argument.SignatureBlob.WriteContentTo(signature); } - /// - /// Checks if a type entity is a well-known corelib type and returns its primitive type code. - /// Native ilasm uses primitive type codes for well-known types like System.String and System.Object - /// in signature blobs instead of class/valuetype TypeRef references. - /// - private static SignatureTypeCode? TryGetPrimitiveTypeCode(EntityRegistry.TypeEntity typeEntity, bool isValueType) - { - if (typeEntity is not EntityRegistry.TypeReferenceEntity typeRef) - { - return null; - } - - string name = typeRef.Name; - string ns = typeRef.Namespace; - - if (ns != "System") - { - return null; - } - - if (isValueType) - { - return name switch - { - "Boolean" => SignatureTypeCode.Boolean, - "Char" => SignatureTypeCode.Char, - "SByte" => SignatureTypeCode.SByte, - "Byte" => SignatureTypeCode.Byte, - "Int16" => SignatureTypeCode.Int16, - "UInt16" => SignatureTypeCode.UInt16, - "Int32" => SignatureTypeCode.Int32, - "UInt32" => SignatureTypeCode.UInt32, - "Int64" => SignatureTypeCode.Int64, - "UInt64" => SignatureTypeCode.UInt64, - "Single" => SignatureTypeCode.Single, - "Double" => SignatureTypeCode.Double, - "IntPtr" => SignatureTypeCode.IntPtr, - "UIntPtr" => SignatureTypeCode.UIntPtr, - "TypedReference" => SignatureTypeCode.TypedReference, - _ => null - }; - } - - return name switch - { - "String" => SignatureTypeCode.String, - "Object" => SignatureTypeCode.Object, - _ => null - }; - } + return signature; + } + + GrammarResult ICILVisitor.VisitElementType(CILParser.ElementTypeContext context) => VisitElementType(context); + + public GrammarResult.FormattedBlob VisitElementType(CILParser.ElementTypeContext context) + => new(MaterializeElementType(GetElementTypeValue(context.Value))); + + GrammarResult ICILVisitor.VisitGenArity(CILParser.GenArityContext context) => VisitGenArity(context); + + public static GrammarResult.Literal VisitGenArity(CILParser.GenArityContext context) + => new(context.Value); + + GrammarResult ICILVisitor.VisitGenArityNotEmpty(CILParser.GenArityNotEmptyContext context) + => VisitGenArityNotEmpty(context); + + public static GrammarResult.Literal VisitGenArityNotEmpty(CILParser.GenArityNotEmptyContext context) + => new(context.Value); + + GrammarResult ICILVisitor.VisitNativeInt(CILParser.NativeIntContext context) + => new GrammarResult.Literal((SignatureTypeCode)context.Value); + + GrammarResult ICILVisitor.VisitNativeUint(CILParser.NativeUintContext context) + => new GrammarResult.Literal((SignatureTypeCode)context.Value); + + GrammarResult ICILVisitor.VisitMethodRef(CILParser.MethodRefContext context) => VisitMethodRef(context); - GrammarResult ICILVisitor.VisitSigArg(CILParser.SigArgContext context) => VisitSigArg(context); - public GrammarResult.Literal VisitSigArg(CILParser.SigArgContext context) + public GrammarResult.Literal VisitMethodRef(CILParser.MethodRefContext context) + => new(MaterializeMethodReference(GetMethodReferenceValue(context.Value))); + + private EntityRegistry.MemberReferenceEntity CreateExplicitMethodReference( + CILParser.CallConvContext callConv, + CILParser.TypeContext returnType, + CILParser.TypeSpecContext owner, + CILParser.MethodNameContext methodName, + CILParser.GenArityContext? genericArity, + CILParser.SigArgsContext parameterList) + => _entityRegistry.CreateLazilyRecordedMemberReference( + VisitTypeSpec(owner).Value, + VisitMethodName(methodName).Value, + CreateExplicitMethodSignature(callConv, returnType, genericArity, parameterList)); + + private BlobBuilder CreateExplicitMethodSignature( + CILParser.CallConvContext callConv, + CILParser.TypeContext returnType, + CILParser.GenArityContext? genericArity, + CILParser.SigArgsContext parameterList) + { + BlobBuilder signature = new(); + byte signatureHeader = VisitCallConv(callConv).Value; + int arity = genericArity is null ? 0 : VisitGenArity(genericArity).Value; + if (arity != 0) { - if (context.ELLIPSIS() is not null) - { - return new(SignatureArg.CreateSentinelArgument()); - } - string? name = context.id() is CILParser.IdContext id ? VisitId(id).Value : null; - return new(new SignatureArg( - VisitParamAttr(context.paramAttr()).Value, - VisitType(context.type()).Value, - VisitMarshalClause(context.marshalClause()).Value, - name)); + signatureHeader |= (byte)SignatureAttributes.Generic; } - GrammarResult ICILVisitor.VisitSigArgs(CILParser.SigArgsContext context) => VisitSigArgs(context); - public GrammarResult.Sequence VisitSigArgs(CILParser.SigArgsContext context) => new([.. context.sigArg().Select(arg => VisitSigArg(arg).Value)]); - GrammarResult ICILVisitor.VisitSimpleType(CILParser.SimpleTypeContext context) => VisitSimpleType(context); - public GrammarResult.Literal VisitSimpleType(CILParser.SimpleTypeContext context) + signature.WriteByte(signatureHeader); + if (arity != 0) { - // Handle 'unsigned intN' forms (2 children: 'unsigned' + intN keyword) - if (context.ChildCount == 2) - { - return new(context.GetChild(1).Symbol.Type switch - { - CILParser.INT8 => SignatureTypeCode.Byte, - CILParser.INT16 => SignatureTypeCode.UInt16, - CILParser.INT32_ => SignatureTypeCode.UInt32, - CILParser.INT64_ => SignatureTypeCode.UInt64, - _ => throw new UnreachableException() - }); - } - - return new(context.GetChild(0).Symbol.Type switch - { - CILParser.CHAR => SignatureTypeCode.Char, - CILParser.STRING => SignatureTypeCode.String, - CILParser.BOOL => SignatureTypeCode.Boolean, - CILParser.INT8 => SignatureTypeCode.SByte, - CILParser.INT16 => SignatureTypeCode.Int16, - CILParser.INT32_ => SignatureTypeCode.Int32, - CILParser.INT64_ => SignatureTypeCode.Int64, - CILParser.FLOAT32 => SignatureTypeCode.Single, - CILParser.FLOAT64_ => SignatureTypeCode.Double, - CILParser.UINT8 => SignatureTypeCode.Byte, - CILParser.UINT16 => SignatureTypeCode.UInt16, - CILParser.UINT32 => SignatureTypeCode.UInt32, - CILParser.UINT64 => SignatureTypeCode.UInt64, - _ => throw new UnreachableException() - }); + signature.WriteCompressedInteger(arity); } - GrammarResult ICILVisitor.VisitType(CILParser.TypeContext context) => VisitType(context); - public GrammarResult.FormattedBlob VisitType(CILParser.TypeContext context) + ImmutableArray parameters = VisitSigArgs(parameterList).Value; + signature.WriteCompressedInteger(parameters.Count(parameter => !parameter.IsSentinel)); + VisitType(returnType).Value.WriteContentTo(signature); + foreach (SignatureArg parameter in parameters) { - // These blobs will likely be very small, so use a smaller default size. - const int DefaultSignatureElementBlobSize = 10; - BlobBuilder prefix = new(DefaultSignatureElementBlobSize); - BlobBuilder suffix = new(DefaultSignatureElementBlobSize); - BlobBuilder elementType = VisitElementType(context.elementType()).Value; - - // Prefix blob writes outer modifiers first. - // Suffix blob writes inner modifiers first. - // Since all blobs are prefix blobs and only some have suffix data, - // We will go in reverse order to write the prefixes - // and then go in forward order to write the suffixes. - CILParser.TypeModifiersContext[] typeModifiers = context.typeModifiers(); - for (int i = typeModifiers.Length - 1; i >= 0; i--) - { - CILParser.TypeModifiersContext? modifier = typeModifiers[i]; - switch (modifier) - { - case CILParser.SZArrayModifierContext: - prefix.WriteByte((byte)SignatureTypeCode.SZArray); - break; - case CILParser.ArrayModifierContext: - prefix.WriteByte((byte)SignatureTypeCode.Array); - break; - case CILParser.ByRefModifierContext: - prefix.WriteByte((byte)SignatureTypeCode.ByReference); - break; - case CILParser.PtrModifierContext: - prefix.WriteByte((byte)SignatureTypeCode.Pointer); - break; - case CILParser.PinnedModifierContext: - prefix.WriteByte((byte)SignatureTypeCode.Pinned); - break; - case CILParser.RequiredModifierContext modreq: - prefix.WriteByte((byte)SignatureTypeCode.RequiredModifier); - prefix.WriteTypeEntity(VisitTypeSpec(modreq.typeSpec()).Value); - break; - case CILParser.OptionalModifierContext modopt: - prefix.WriteByte((byte)SignatureTypeCode.OptionalModifier); - prefix.WriteTypeEntity(VisitTypeSpec(modopt.typeSpec()).Value); - break; - case CILParser.GenericArgumentsModifierContext: - prefix.WriteByte((byte)SignatureTypeCode.GenericTypeInstance); - break; - } - } - - foreach (var modifier in typeModifiers) - { - switch (modifier) - { - case CILParser.ArrayModifierContext arr: - var bounds = VisitBounds(arr.bounds()).Value; - suffix.WriteCompressedInteger(bounds.Length); - // Count contiguous sizes from the start (stop at first null) - int numSizes = 0; - for (int bIdx = 0; bIdx < bounds.Length; bIdx++) - { - if (bounds[bIdx].Upper is null) - break; - numSizes++; - } - // Count contiguous lower bounds from the start (stop at first null) - int numLoBounds = 0; - for (int bIdx = 0; bIdx < bounds.Length; bIdx++) - { - if (bounds[bIdx].Lower is null) - break; - numLoBounds++; - } - suffix.WriteCompressedInteger(numSizes); - for (int bIdx = 0; bIdx < numSizes; bIdx++) - { - suffix.WriteCompressedInteger(bounds[bIdx].Upper.GetValueOrDefault()); - } - suffix.WriteCompressedInteger(numLoBounds); - for (int bIdx = 0; bIdx < numLoBounds; bIdx++) - { - suffix.WriteCompressedSignedInteger(bounds[bIdx].Lower.GetValueOrDefault()); - } - break; - case CILParser.GenericArgumentsModifierContext genericArgs: - VisitTypeArgs(genericArgs.typeArgs()).Value.WriteContentTo(suffix); - break; - } - } - - // Work around https://github.com/dotnet/runtime/issues/127243 - // by writing to a separate blob. - BlobBuilder fullBlob = new(elementType.Count + prefix.Count + suffix.Count); - prefix.WriteContentTo(fullBlob); - elementType.WriteContentTo(fullBlob); - suffix.WriteContentTo(fullBlob); - return new(fullBlob); + parameter.SignatureBlob.WriteContentTo(signature); } - GrammarResult ICILVisitor.VisitTypeArgs(CILParser.TypeArgsContext context) => VisitTypeArgs(context); + return signature; + } - public GrammarResult.FormattedBlob VisitTypeArgs(CILParser.TypeArgsContext context) - { - BlobBuilder blob = new(4); - var types = context.type(); - blob.WriteCompressedInteger(types.Length); - foreach (var type in types) - { - blob.LinkSuffix(VisitType(type).Value); - } - return new(blob); - } + GrammarResult ICILVisitor.VisitParamAttr(CILParser.ParamAttrContext context) => VisitParamAttr(context); - GrammarResult ICILVisitor.VisitTypeList(CILParser.TypeListContext context) => VisitTypeList(context); - public GrammarResult.Sequence VisitTypeList(CILParser.TypeListContext context) - { - CILParser.TypeSpecContext[] bounds = context.typeSpec(); - ImmutableArray.Builder builder = ImmutableArray.CreateBuilder(bounds.Length); - foreach (var typeSpec in bounds) - { - builder.Add(VisitTypeSpec(typeSpec).Value); - } - return new(builder.MoveToImmutable()); - } + public static GrammarResult.Literal VisitParamAttr(CILParser.ParamAttrContext context) + => new((ParameterAttributes)context.Value); + + GrammarResult ICILVisitor.VisitParamAttrElement(CILParser.ParamAttrElementContext context) + => VisitParamAttrElement(context); + + public static GrammarResult.Flag VisitParamAttrElement(CILParser.ParamAttrElementContext context) + => new((ParameterAttributes)context.Value, context.ShouldAppend); + + GrammarResult ICILVisitor.VisitSigArg(CILParser.SigArgContext context) => VisitSigArg(context); + + public GrammarResult.Literal VisitSigArg(CILParser.SigArgContext context) + => new(MaterializeSignatureArgument(GetSignatureArgumentValue(context.Value))); + + GrammarResult ICILVisitor.VisitSigArgs(CILParser.SigArgsContext context) => VisitSigArgs(context); + + public GrammarResult.Sequence VisitSigArgs(CILParser.SigArgsContext context) + => new(MaterializeSignatureArguments(GetSignatureArgumentsValue(context.Value))); + + GrammarResult ICILVisitor.VisitSimpleType(CILParser.SimpleTypeContext context) => VisitSimpleType(context); + + public static GrammarResult.Literal VisitSimpleType(CILParser.SimpleTypeContext context) + => new((SignatureTypeCode)context.Value); - GrammarResult ICILVisitor.VisitTypeSpec(CILParser.TypeSpecContext context) => VisitTypeSpec(context); - public GrammarResult.Literal VisitTypeSpec(CILParser.TypeSpecContext context) + GrammarResult ICILVisitor.VisitType(CILParser.TypeContext context) => VisitType(context); + + public GrammarResult.FormattedBlob VisitType(CILParser.TypeContext context) + => new(MaterializeType(GetTypeValue(context.Value))); + + GrammarResult ICILVisitor.VisitTypeArgs(CILParser.TypeArgsContext context) => VisitTypeArgs(context); + + public GrammarResult.FormattedBlob VisitTypeArgs(CILParser.TypeArgsContext context) + => new(MaterializeTypeArguments(GetTypeArgumentsValue(context.Value))); + + GrammarResult ICILVisitor.VisitTypeList(CILParser.TypeListContext context) => VisitTypeList(context); + + public GrammarResult.Sequence VisitTypeList(CILParser.TypeListContext context) + { + CILParser.TypeSpecContext[] bounds = context.typeSpec(); + ImmutableArray.Builder builder = + ImmutableArray.CreateBuilder(bounds.Length); + foreach (CILParser.TypeSpecContext typeSpec in bounds) { - if (context.className() is CILParser.ClassNameContext className) - { - return new(VisitClassName(className).Value); - } - else if (context.dottedName() is CILParser.DottedNameContext dottedName) - { - string nameToResolve = VisitDottedName(dottedName).Value; - if (context.MODULE() is not null) - { - EntityRegistry.ModuleReferenceEntity? module = _entityRegistry.FindModuleReference(nameToResolve); - if (module is null) - { - // report error - return new(new EntityRegistry.FakeTypeEntity(MetadataTokens.ModuleReferenceHandle(0))); - } - return new(new EntityRegistry.FakeTypeEntity(module.Handle)); - } - else - { - return new(new EntityRegistry.FakeTypeEntity( - _entityRegistry.GetOrCreateAssemblyReference(nameToResolve, newRef => - { - // Report warning on implicit assembly reference creation. - }).Handle)); - } - } - else - { - Debug.Assert(context.type() != null); - return new(_entityRegistry.GetOrCreateTypeSpec(VisitType(context.type()).Value)); - } + builder.Add(VisitTypeSpec(typeSpec).Value); } + return new(builder.MoveToImmutable()); + } - GrammarResult ICILVisitor.VisitOptionalModifier(CILParser.OptionalModifierContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - GrammarResult ICILVisitor.VisitSZArrayModifier(CILParser.SZArrayModifierContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - GrammarResult ICILVisitor.VisitRequiredModifier(CILParser.RequiredModifierContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - GrammarResult ICILVisitor.VisitPtrModifier(CILParser.PtrModifierContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - GrammarResult ICILVisitor.VisitPinnedModifier(CILParser.PinnedModifierContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - GrammarResult ICILVisitor.VisitGenericArgumentsModifier(CILParser.GenericArgumentsModifierContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - GrammarResult ICILVisitor.VisitByRefModifier(CILParser.ByRefModifierContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - GrammarResult ICILVisitor.VisitArrayModifier(CILParser.ArrayModifierContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + GrammarResult ICILVisitor.VisitTypeSpec(CILParser.TypeSpecContext context) => VisitTypeSpec(context); - } + public GrammarResult.Literal VisitTypeSpec(CILParser.TypeSpecContext context) + => new(ResolveTypeSpecification(GetTypeSpecificationValue(context.Value))); + + GrammarResult ICILVisitor.VisitOptionalModifier(CILParser.OptionalModifierContext context) + => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + + GrammarResult ICILVisitor.VisitSZArrayModifier(CILParser.SZArrayModifierContext context) + => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + + GrammarResult ICILVisitor.VisitRequiredModifier(CILParser.RequiredModifierContext context) + => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + + GrammarResult ICILVisitor.VisitPtrModifier(CILParser.PtrModifierContext context) + => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + + GrammarResult ICILVisitor.VisitPinnedModifier(CILParser.PinnedModifierContext context) + => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + + GrammarResult ICILVisitor.VisitGenericArgumentsModifier(CILParser.GenericArgumentsModifierContext context) + => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + + GrammarResult ICILVisitor.VisitByRefModifier(CILParser.ByRefModifierContext context) + => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + + GrammarResult ICILVisitor.VisitArrayModifier(CILParser.ArrayModifierContext context) + => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.References.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.References.cs new file mode 100644 index 00000000000000..83b673ebbf8af3 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.References.cs @@ -0,0 +1,203 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Generic; +using System.Diagnostics; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using Antlr4.Runtime; + +namespace ILAssembler; + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. +internal sealed partial class GrammarActions +{ + private readonly Stack _slashedNameFrames = new(); + + private sealed class SlashedNameFrame + { + public SlashedNameFrame(CILParser.SlashedNameContext owner) + { + Owner = owner; + } + + public CILParser.SlashedNameContext Owner { get; } + + public TypeName? Name { get; set; } + } + + internal void BeginSlashedName(CILParser.SlashedNameContext context) + => _slashedNameFrames.Push(new(context)); + + internal void AddSlashedNamePart(CILParser.SlashedNameContext context, string name) + { + Debug.Assert(_slashedNameFrames.Count > 0); + SlashedNameFrame frame = _slashedNameFrames.Peek(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + if (ReferenceEquals(frame.Owner, context)) + { + frame.Name = new TypeName(frame.Name, name); + } + } + + internal object EndSlashedName(CILParser.SlashedNameContext context) + { + Debug.Assert(_slashedNameFrames.Count > 0); + SlashedNameFrame frame = _slashedNameFrames.Pop(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + return ReferenceEquals(frame.Owner, context) && frame.Name is not null + ? frame.Name + : new TypeName(null, string.Empty); + } + + internal object CreateUnqualifiedClassName(object? name) + => new UnqualifiedClassNameValue(GetTypeNameValue(name)); + + internal object CreateAssemblyQualifiedClassName(string assemblyName, object? name) + => new AssemblyQualifiedClassNameValue(assemblyName, GetTypeNameValue(name)); + + internal object CreateModuleQualifiedClassName(IToken token, string moduleName, object? name) + => new ModuleQualifiedClassNameValue(token, moduleName, GetTypeNameValue(name)); + + internal object CreateTokenQualifiedClassName(int scopeToken, object? name) + => new TokenQualifiedClassNameValue(scopeToken, GetTypeNameValue(name)); + + internal object CreatePointerQualifiedClassName(object? name) + => new PointerQualifiedClassNameValue(GetTypeNameValue(name)); + + internal object CreateTokenClassName(int typeToken) + => new TokenClassNameValue(typeToken); + + internal object CreateThisClassName(IToken token) + => new SpecialClassNameValue(token, SpecialClassNameKind.This); + + internal object CreateBaseClassName(IToken token) + => new SpecialClassNameValue(token, SpecialClassNameKind.Base); + + internal object CreateNesterClassName(IToken token) + => new SpecialClassNameValue(token, SpecialClassNameKind.Nester); + + private EntityRegistry.TypeEntity ResolveClassName(ClassNameValue className) + { + switch (className) + { + case SpecialClassNameValue { Kind: SpecialClassNameKind.This } special: + if (_currentTypeDefinition.Count == 0) + { + ReportError(DiagnosticIds.ThisOutsideClass, DiagnosticMessageTemplates.ThisOutsideClass, special.Token); + return new EntityRegistry.FakeTypeEntity(default(TypeDefinitionHandle)); + } + return _currentTypeDefinition.Peek(); + case SpecialClassNameValue { Kind: SpecialClassNameKind.Base } special: + if (_currentTypeDefinition.Count == 0) + { + ReportError(DiagnosticIds.BaseOutsideClass, DiagnosticMessageTemplates.BaseOutsideClass, special.Token); + return new EntityRegistry.FakeTypeEntity(default(TypeDefinitionHandle)); + } + if (_currentTypeDefinition.Peek().BaseType is not { } baseType) + { + ReportError(DiagnosticIds.NoBaseType, DiagnosticMessageTemplates.NoBaseType, special.Token); + return new EntityRegistry.FakeTypeEntity(default(TypeDefinitionHandle)); + } + return baseType; + case SpecialClassNameValue { Kind: SpecialClassNameKind.Nester } special: + if (_currentTypeDefinition.Count < 2) + { + ReportError(DiagnosticIds.NesterOutsideNestedClass, DiagnosticMessageTemplates.NesterOutsideNestedClass, special.Token); + return new EntityRegistry.FakeTypeEntity(default(TypeDefinitionHandle)); + } + return _currentTypeDefinition.Peek().ContainingType!; + case AssemblyQualifiedClassNameValue assembly: + return _entityRegistry.GetOrCreateTypeReference( + _entityRegistry.GetOrCreateAssemblyReference(assembly.AssemblyName, _ => { }), + assembly.Name); + case ModuleQualifiedClassNameValue module: + if (_entityRegistry.FindModuleReference(module.ModuleName) is not { } moduleReference) + { + ReportError( + DiagnosticIds.ModuleNotFound, + string.Format(DiagnosticMessageTemplates.ModuleNotFound, module.ModuleName), + module.Token); + return new EntityRegistry.FakeTypeEntity(default(TypeDefinitionHandle)); + } + return _entityRegistry.GetOrCreateTypeReference(moduleReference, module.Name); + case TokenQualifiedClassNameValue tokenScope: + return _entityRegistry.GetOrCreateTypeReference( + ResolveMetadataToken(tokenScope.Token), + tokenScope.Name); + case PointerQualifiedClassNameValue pointer: + return _entityRegistry.GetOrCreateTypeReference( + new EntityRegistry.FakeTypeEntity(default(ModuleDefinitionHandle)), + pointer.Name); + case UnqualifiedClassNameValue unqualified: + return ResolveUnqualifiedClassName(unqualified.Name); + case TokenClassNameValue typeToken: + EntityRegistry.EntityBase resolvedToken = ResolveMetadataToken(typeToken.Token); + return resolvedToken is EntityRegistry.TypeEntity type + ? type + : new EntityRegistry.FakeTypeEntity(resolvedToken.Handle); + default: + return new EntityRegistry.FakeTypeEntity(default(TypeDefinitionHandle)); + } + } + + private EntityRegistry.TypeEntity ResolveUnqualifiedClassName(TypeName typeName) + { + if (typeName.ContainingTypeName is null && TryResolveTypedefAsType(typeName.DottedName) is { } typedef) + { + return typedef; + } + + if (typeName.ContainingTypeName is null) + { + (string ns, string name) = NameHelpers.SplitDottedNameToNamespaceAndName(typeName.DottedName); + if (ns == "System" && name is "String" or "Object" or "ValueType" or "Enum" + or "Type" or "Array" or "Delegate" or "MulticastDelegate" + or "Exception" or "Attribute") + { + return _entityRegistry.GetOrCreateTypeReference(_entityRegistry.GetCoreLibAssemblyReference(), typeName); + } + } + + Stack containingTypes = new(); + for (TypeName? containingType = typeName; containingType is not null; containingType = containingType.ContainingTypeName) + { + containingTypes.Push(containingType); + } + + EntityRegistry.TypeDefinitionEntity? typeDefinition = null; + while (containingTypes.Count != 0) + { + TypeName containingType = containingTypes.Pop(); + (string ns, string name) = NameHelpers.SplitDottedNameToNamespaceAndName(containingType.DottedName); + typeDefinition = _entityRegistry.GetOrCreateTypeDefinition(typeDefinition, ns, name, _ => { }); + } + + Debug.Assert(typeDefinition is not null); + return typeDefinition; + } + + private EntityRegistry.TypeEntity ResolveTypeSpecification(TypeSpecificationValue typeSpecification) + { + return typeSpecification switch + { + ClassTypeSpecificationValue classType => ResolveClassName(classType.ClassName), + ModuleTypeSpecificationValue module => ResolveModuleTypeSpecification(module.ModuleName), + AssemblyTypeSpecificationValue assembly => new EntityRegistry.FakeTypeEntity( + _entityRegistry.GetOrCreateAssemblyReference(assembly.AssemblyName, _ => { }).Handle), + SignatureTypeSpecificationValue signature => _entityRegistry.GetOrCreateTypeSpec(MaterializeType(signature.Type)), + _ => new EntityRegistry.FakeTypeEntity(default(TypeDefinitionHandle)) + }; + } + + private EntityRegistry.FakeTypeEntity ResolveModuleTypeSpecification(string moduleName) + { + EntityRegistry.ModuleReferenceEntity? module = _entityRegistry.FindModuleReference(moduleName); + return module is null + ? new EntityRegistry.FakeTypeEntity(MetadataTokens.ModuleReferenceHandle(0)) + : new EntityRegistry.FakeTypeEntity(module.Handle); + } + + private EntityRegistry.EntityBase ResolveMetadataToken(int token) + => _entityRegistry.ResolveHandleToEntity(MetadataTokens.EntityHandle(token)); +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs index db3a860121559c..e924f7a5e92425 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs @@ -448,146 +448,9 @@ private void ClearPendingCustomAttributeOwners() } GrammarResult ICILVisitor.VisitClassName(CILParser.ClassNameContext context) => VisitClassName(context); - public GrammarResult.Literal VisitClassName(CILParser.ClassNameContext context) - { - if (context.THIS() is not null) - { - if (_currentTypeDefinition.Count == 0) - { - ReportError(DiagnosticIds.ThisOutsideClass, DiagnosticMessageTemplates.ThisOutsideClass, context); - return new(new EntityRegistry.FakeTypeEntity(default(TypeDefinitionHandle))); - } - var thisType = _currentTypeDefinition.Peek(); - return new(thisType); - } - else if (context.BASE() is not null) - { - if (_currentTypeDefinition.Count == 0) - { - ReportError(DiagnosticIds.BaseOutsideClass, DiagnosticMessageTemplates.BaseOutsideClass, context); - return new(new EntityRegistry.FakeTypeEntity(default(TypeDefinitionHandle))); - } - var baseType = _currentTypeDefinition.Peek().BaseType; - if (baseType is null) - { - ReportError(DiagnosticIds.NoBaseType, DiagnosticMessageTemplates.NoBaseType, context); - return new(new EntityRegistry.FakeTypeEntity(default(TypeDefinitionHandle))); - } - return new(baseType); - } - else if (context.NESTER() is not null) - { - if (_currentTypeDefinition.Count < 2) - { - ReportError(DiagnosticIds.NesterOutsideNestedClass, DiagnosticMessageTemplates.NesterOutsideNestedClass, context); - return new(new EntityRegistry.FakeTypeEntity(default(TypeDefinitionHandle))); - } - var nesterType = _currentTypeDefinition.Peek().ContainingType!; - return new(nesterType); - } - else if (context.slashedName() is CILParser.SlashedNameContext slashedName) - { - EntityRegistry.EntityBase? resolutionContext = null; - if (context.dottedName() is CILParser.DottedNameContext dottedAssemblyOrModuleName) - { - if (context.MODULE() is not null) - { - string moduleName = VisitDottedName(dottedAssemblyOrModuleName).Value; - resolutionContext = _entityRegistry.FindModuleReference(moduleName); - if (resolutionContext is null) - { - ReportError(DiagnosticIds.ModuleNotFound, string.Format(DiagnosticMessageTemplates.ModuleNotFound, moduleName), context); - return new(new EntityRegistry.FakeTypeEntity(default(TypeDefinitionHandle))); - } - } - else - { - resolutionContext = _entityRegistry.GetOrCreateAssemblyReference(VisitDottedName(dottedAssemblyOrModuleName).Value, newRef => { }); - } - } - else if (context.mdtoken() is CILParser.MdtokenContext typeRefScope) - { - resolutionContext = VisitMdtoken(typeRefScope).Value; - } - else if (context.PTR() is not null) - { - resolutionContext = new EntityRegistry.FakeTypeEntity(default(ModuleDefinitionHandle)); - } - - if (resolutionContext is not null) - { - EntityRegistry.TypeReferenceEntity typeRef = _entityRegistry.GetOrCreateTypeReference(resolutionContext, VisitSlashedName(slashedName).Value); - return new(typeRef); - } - - Debug.Assert(resolutionContext is null); - - return new(ResolveTypeDef()); - - // Resolve typedef references - EntityRegistry.TypeEntity ResolveTypeDef() - { - TypeName typeName = VisitSlashedName(slashedName).Value; - if (typeName.ContainingTypeName is null) - { - // Check for typedef. - var typedefResult = TryResolveTypedefAsType(typeName.DottedName); - if (typedefResult is not null) - { - return typedefResult; - } - } - - // COMPAT: Before creating a forward-reference TypeDef, check if the type - // matches a well-known corelib type. Native ilasm resolves unqualified - // references to types like System.String as TypeRefs from the corelib. - if (typeName.ContainingTypeName is null) - { - var (ns, nm) = NameHelpers.SplitDottedNameToNamespaceAndName(typeName.DottedName); - if (ns == "System" && nm is "String" or "Object" or "ValueType" or "Enum" - or "Type" or "Array" or "Delegate" or "MulticastDelegate" - or "Exception" or "Attribute") - { - var coreLib = _entityRegistry.GetCoreLibAssemblyReference(); - return _entityRegistry.GetOrCreateTypeReference(coreLib, typeName); - } - } - Stack containingTypes = new(); - for (TypeName? containingType = typeName; containingType is not null; containingType = containingType.ContainingTypeName) - { - containingTypes.Push(containingType); - } - EntityRegistry.TypeDefinitionEntity? typeDef = null; - while (containingTypes.Count != 0) - { - TypeName containingType = containingTypes.Pop(); - - (string ns, string name) = NameHelpers.SplitDottedNameToNamespaceAndName(containingType.DottedName); - - typeDef = _entityRegistry.GetOrCreateTypeDefinition( - typeDef, - ns, - name, - _ => { }); - } - - return typeDef!; - } - } - else if (context.mdtoken() is CILParser.MdtokenContext typeToken) - { - EntityRegistry.EntityBase resolvedToken = VisitMdtoken(typeToken).Value; - - if (resolvedToken is not EntityRegistry.TypeEntity type) - { - return new(new EntityRegistry.FakeTypeEntity(resolvedToken.Handle)); - } - return new(type); - } - - throw new UnreachableException(); - } + public GrammarResult.Literal VisitClassName(CILParser.ClassNameContext context) + => new(ResolveClassName(GetClassNameValue(context.Value))); GrammarResult ICILVisitor.VisitClassSeq(CILParser.ClassSeqContext context) => VisitClassSeq(context); public GrammarResult.FormattedBlob VisitClassSeq(CILParser.ClassSeqContext context) diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs index cb800b1da7030d..5d79d339cc7d68 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs @@ -19,11 +19,31 @@ internal sealed partial class GrammarActions internal void BeginDocument() { Debug.Assert( - _currentMethod is null && _typeOwners.Count == 0 && _namespaceOwners.Count == 0 && _scopeStack.Count == 0, - "Namespace, type, method and scope state must be released by the owning rule's finally block."); + _currentMethod is null + && _typeOwners.Count == 0 + && _namespaceOwners.Count == 0 + && _scopeStack.Count == 0 + && _semanticRootFrames.Count == 0 + && _dottedNameFrames.Count == 0 + && _slashedNameFrames.Count == 0 + && _typeSignatureFrames.Count == 0 + && _typeArgumentsFrames.Count == 0 + && _boundsFrames.Count == 0 + && _signatureArgumentsFrames.Count == 0 + && _parameterAttributesFrames.Count == 0, + "Per-document semantic state must be released by the owning rule's finally block."); EndMethod(); ResetTypeScopes(); ClearPendingCustomAttributeOwners(); + _semanticRootFrames.Clear(); + _dottedNameFrames.Clear(); + _slashedNameFrames.Clear(); + _typeSignatureFrames.Clear(); + _typeArgumentsFrames.Clear(); + _boundsFrames.Clear(); + _signatureArgumentsFrames.Clear(); + _parameterAttributesFrames.Clear(); + _syntaxErrorCount = 0; } } diff --git a/src/tools/ilasm/src/ILAssembler/DocumentCompiler.cs b/src/tools/ilasm/src/ILAssembler/DocumentCompiler.cs index 412220f87aa4de..e4ed8d20bf7d85 100644 --- a/src/tools/ilasm/src/ILAssembler/DocumentCompiler.cs +++ b/src/tools/ilasm/src/ILAssembler/DocumentCompiler.cs @@ -61,7 +61,7 @@ public sealed class DocumentCompiler }; parser.RemoveErrorListeners(); ImmutableArray.Builder parserDiagnostics = ImmutableArray.CreateBuilder(); - parser.AddErrorListener(new ParserErrorListener(parserDiagnostics, loadedDocuments)); + parser.AddErrorListener(new ParserErrorListener(parserDiagnostics, loadedDocuments, actions.RecordSyntaxError)); _ = parser.decls(); parser.VerifyParseTreeModesBalanced(); @@ -94,15 +94,21 @@ internal sealed class ParserErrorListener : Antlr4.Runtime.IAntlrErrorListener.Builder _diagnostics; private readonly Dictionary _loadedDocuments; + private readonly Action _recordSyntaxError; - public ParserErrorListener(ImmutableArray.Builder diagnostics, Dictionary loadedDocuments) + public ParserErrorListener( + ImmutableArray.Builder diagnostics, + Dictionary loadedDocuments, + Action recordSyntaxError) { _diagnostics = diagnostics; _loadedDocuments = loadedDocuments; + _recordSyntaxError = recordSyntaxError; } public void SyntaxError(TextWriter output, IRecognizer recognizer, IToken offendingSymbol, int line, int charPositionInLine, string msg, RecognitionException e) { + _recordSyntaxError(); var sourceName = offendingSymbol?.TokenSource?.SourceName ?? ""; var span = new SourceSpan(offendingSymbol?.StartIndex ?? 0, offendingSymbol is null ? 0 : offendingSymbol.StopIndex - offendingSymbol.StartIndex + 1); if (_loadedDocuments.TryGetValue(sourceName, out var sourceText)) diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 index 3502f26b25c80c..44dbd1683459a9 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 @@ -409,8 +409,26 @@ id: | VALUE | INSTANCE | SQSTRING; -dottedName: DOTTEDNAME | ((dottedNamePart '.')* dottedNamePart) | SQSTRING; -dottedNamePart: ID | VALUE | INSTANCE | SQSTRING | DOTTEDNAME | 'volatile'; +dottedName returns [string Value] +@init {Actions.BeginDottedName(_localctx);} +: + direct = DOTTEDNAME {Actions.AddDottedNameToken(_localctx, $direct);} + | ((part = dottedNamePart {Actions.AddDottedNamePart(_localctx, $part.Value);} '.')* + tail = dottedNamePart {Actions.AddDottedNamePart(_localctx, $tail.Value);}) + | quoted = SQSTRING {Actions.AddDottedNameToken(_localctx, $quoted);} +; +finally {_localctx.Value = Actions.EndDottedName(_localctx);} + +dottedNamePart returns [string Value] +@after {_localctx.Value = Actions.ParseDottedNamePart(_localctx.Start);} +: + ID + | VALUE + | INSTANCE + | SQSTRING + | DOTTEDNAME + | 'volatile' +; compQstring returns [string Value] @init {BeginStreaming(); Actions.BeginComposedString(_localctx);} : @@ -536,12 +554,13 @@ customDescrWithOwner: customType: methodRef; ownerType -@init {BeginSubtree();} +returns [object Value, bool HasSyntaxError] +@init {Actions.BeginSemanticRoot(_localctx);} : - typeSpec - | memberRef + typeValue = typeSpec {_localctx.Value = Actions.CreateTypeOwner($typeValue.Value);} + | member = memberRef {_localctx.Value = Actions.CreateMemberOwner($member.Value);} ; -finally {EndParseTreeMode();} +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} /* Verbal description of custom attribute initialization blob */ customBlobDescr: customBlobArgs customBlobNVPairs; @@ -719,55 +738,88 @@ simpleInstr finally {Actions.EndSwitchInstruction(_localctx);} calliSignature -@init {BeginSubtree();} +returns [object Value, bool HasSyntaxError] +@init {Actions.BeginSemanticRoot(_localctx);} : - callConv type sigArgs + convention = callConv returnType = type arguments = sigArgs + {_localctx.Value = Actions.CreateCalliSignature($convention.Value, $returnType.Value, $arguments.Value);} ; -finally {EndParseTreeMode();} +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} labels: /* empty */ | ((headLabel = id {Actions.AddSwitchLabel($headLabel.start);} | headOffset = int32 {Actions.AddSwitchOffset($headOffset.start);}) ',')* (tailLabel = id {Actions.AddSwitchLabel($tailLabel.start);} | tailOffset = int32 {Actions.AddSwitchOffset($tailOffset.start);}); -typeArgs: '<' (type ',')* type '>'; +typeArgs returns [object Value] +@init {Actions.BeginTypeArguments(_localctx);} +: + '<' (argument = type {Actions.AddTypeArgument(_localctx, $argument.Value);} ',')* + lastArgument = type {Actions.AddTypeArgument(_localctx, $lastArgument.Value);} '>' +; +finally {_localctx.Value = Actions.EndTypeArguments(_localctx);} -bounds: '[' (bound ',')* bound ']'; +bounds returns [object Value] +@init {Actions.BeginBounds(_localctx);} +: + '[' (item = bound {Actions.AddBound(_localctx, $item.ctx);} ',')* + lastItem = bound {Actions.AddBound(_localctx, $lastItem.ctx);} ']' +; +finally {_localctx.Value = Actions.EndBounds(_localctx);} -sigArgs: '(' (sigArg ',')* sigArg ')' | '()'; +sigArgs returns [object Value] +@init {Actions.BeginSignatureArguments(_localctx);} +: + '(' (argument = sigArg {Actions.AddSignatureArgument(_localctx, $argument.Value);} ',')* + lastArgument = sigArg {Actions.AddSignatureArgument(_localctx, $lastArgument.Value);} ')' + | '()' +; +finally {_localctx.Value = Actions.EndSignatureArguments(_localctx);} -sigArg: - ELLIPSIS - | paramAttr type marshalClause id?; +sigArg returns [object Value]: + ELLIPSIS {_localctx.Value = Actions.CreateSentinelSignatureArgument();} + | attributes = paramAttr argumentType = type marshalling = marshalClause name = id? + {_localctx.Value = Actions.CreateSignatureArgument($attributes.Value, $argumentType.Value, $marshalling.ctx, $name.ctx);}; /* Class referencing */ -className: - '[' dottedName ']' slashedName - | '[' mdtoken ']' slashedName - | '[' PTR ']' slashedName - | '[' MODULE dottedName ']' slashedName - | slashedName - | mdtoken - | THIS - | BASE - | NESTER; - -slashedName: (dottedName '/')* dottedName; +className returns [object Value]: + '[' assemblyName = dottedName ']' typeName = slashedName + {_localctx.Value = Actions.CreateAssemblyQualifiedClassName($assemblyName.Value, $typeName.Value);} + | '[' scopeToken = mdtoken ']' typeName = slashedName + {_localctx.Value = Actions.CreateTokenQualifiedClassName($scopeToken.Value, $typeName.Value);} + | '[' PTR ']' typeName = slashedName + {_localctx.Value = Actions.CreatePointerQualifiedClassName($typeName.Value);} + | '[' MODULE moduleName = dottedName ']' typeName = slashedName + {_localctx.Value = Actions.CreateModuleQualifiedClassName(_localctx.Start, $moduleName.Value, $typeName.Value);} + | typeName = slashedName {_localctx.Value = Actions.CreateUnqualifiedClassName($typeName.Value);} + | typeToken = mdtoken {_localctx.Value = Actions.CreateTokenClassName($typeToken.Value);} + | THIS {_localctx.Value = Actions.CreateThisClassName(_localctx.Start);} + | BASE {_localctx.Value = Actions.CreateBaseClassName(_localctx.Start);} + | NESTER {_localctx.Value = Actions.CreateNesterClassName(_localctx.Start);}; + +slashedName returns [object Value] +@init {Actions.BeginSlashedName(_localctx);} +: + (part = dottedName {Actions.AddSlashedNamePart(_localctx, $part.Value);} '/')* + lastPart = dottedName {Actions.AddSlashedNamePart(_localctx, $lastPart.Value);} +; +finally {_localctx.Value = Actions.EndSlashedName(_localctx);} assemblyDecls: assemblyDecl*; assemblyDecl: (HASH 'algorithm' int32) | secDecl | asmOrRefDecl; typeSpec -@init {BeginSubtree();} +returns [object Value, bool HasSyntaxError] +@init {Actions.BeginSemanticRoot(_localctx);} : - className - | '[' dottedName ']' - | '[' MODULE dottedName ']' - | type + classType = className {_localctx.Value = Actions.CreateClassTypeSpecification($classType.Value);} + | '[' assemblyName = dottedName ']' {_localctx.Value = Actions.CreateAssemblyTypeSpecification($assemblyName.Value);} + | '[' MODULE moduleName = dottedName ']' {_localctx.Value = Actions.CreateModuleTypeSpecification($moduleName.Value);} + | signatureType = type {_localctx.Value = Actions.CreateSignatureTypeSpecification($signatureType.Value);} ; -finally {EndParseTreeMode();} +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} /* Native types for marshaling signatures */ nativeType: @@ -882,65 +934,79 @@ variantTypeElement: | CLSID; /* Managed types for signatures */ -type: elementType typeModifiers*; - -typeModifiers: - ARRAY_TYPE_NO_BOUNDS # SZArrayModifier - | '[' ']' # SZArrayModifier - | bounds # ArrayModifier - | REF # ByRefModifier - | PTR # PtrModifier - | 'pinned' # PinnedModifier - | 'modreq' '(' typeSpec ')' # RequiredModifier - | 'modopt' '(' typeSpec ')' # OptionalModifier - | typeArgs # GenericArgumentsModifier; - -elementType: - 'class' className - | OBJECT - | VALUE 'class' className - | VALUETYPE className - | 'method' callConv type PTR sigArgs - | METHOD_TYPE_PARAMETER int32 - | TYPE_PARAMETER int32 - | METHOD_TYPE_PARAMETER dottedName - | TYPE_PARAMETER dottedName - | TYPEDREF - | VOID - | nativeInt - | nativeUint - | simpleType - | dottedName /* typedef */ - | ELLIPSIS type; - -simpleType: - CHAR - | STRING - | BOOL - | INT8 - | INT16 - | INT32_ - | INT64_ - | FLOAT32 - | FLOAT64_ - | UINT8 - | UINT16 - | UINT32 - | UINT64 - | 'unsigned' INT8 - | 'unsigned' INT16 - | 'unsigned' INT32_ - | 'unsigned' INT64_; - -bound: +type returns [object Value] +@init {Actions.BeginTypeSignature(_localctx);} +: + element = elementType {Actions.SetTypeSignatureElement(_localctx, $element.Value);} + (modifier = typeModifiers {Actions.AddTypeSignatureModifier(_localctx, $modifier.Value);})* +; +finally {_localctx.Value = Actions.EndTypeSignature(_localctx);} + +typeModifiers returns [object Value]: + ARRAY_TYPE_NO_BOUNDS {_localctx.Value = Actions.CreateSzArrayTypeModifier();} # SZArrayModifier + | '[' ']' {_localctx.Value = Actions.CreateSzArrayTypeModifier();} # SZArrayModifier + | arrayBounds = bounds {_localctx.Value = Actions.CreateArrayTypeModifier($arrayBounds.Value);} # ArrayModifier + | REF {_localctx.Value = Actions.CreateByReferenceTypeModifier();} # ByRefModifier + | PTR {_localctx.Value = Actions.CreatePointerTypeModifier();} # PtrModifier + | 'pinned' {_localctx.Value = Actions.CreatePinnedTypeModifier();} # PinnedModifier + | 'modreq' '(' modifierType = typeSpec ')' {_localctx.Value = Actions.CreateCustomTypeModifier($modifierType.Value, true);} # RequiredModifier + | 'modopt' '(' modifierType = typeSpec ')' {_localctx.Value = Actions.CreateCustomTypeModifier($modifierType.Value, false);} # OptionalModifier + | arguments = typeArgs {_localctx.Value = Actions.CreateGenericArgumentsModifier($arguments.Value);} # GenericArgumentsModifier; + +elementType returns [object Value]: + 'class' classType = className {_localctx.Value = Actions.CreateClassElementType($classType.Value, false);} + | OBJECT {_localctx.Value = Actions.CreateObjectElementType();} + | VALUE 'class' valueClassType = className {_localctx.Value = Actions.CreateClassElementType($valueClassType.Value, true);} + | VALUETYPE valueType = className {_localctx.Value = Actions.CreateClassElementType($valueType.Value, true);} + | 'method' convention = callConv returnType = type PTR arguments = sigArgs + {_localctx.Value = Actions.CreateFunctionPointerElementType($convention.Value, $returnType.Value, $arguments.Value);} + | METHOD_TYPE_PARAMETER parameterIndex = int32 {_localctx.Value = Actions.CreateIndexedGenericParameterElementType(true, $parameterIndex.start);} + | TYPE_PARAMETER parameterIndex = int32 {_localctx.Value = Actions.CreateIndexedGenericParameterElementType(false, $parameterIndex.start);} + | METHOD_TYPE_PARAMETER parameterName = dottedName {_localctx.Value = Actions.CreateNamedGenericParameterElementType(_localctx.Start, true, $parameterName.Value);} + | TYPE_PARAMETER parameterName = dottedName {_localctx.Value = Actions.CreateNamedGenericParameterElementType(_localctx.Start, false, $parameterName.Value);} + | TYPEDREF {_localctx.Value = Actions.CreateTypedReferenceElementType();} + | VOID {_localctx.Value = Actions.CreateVoidElementType();} + | signedNative = nativeInt {_localctx.Value = Actions.CreatePrimitiveElementType($signedNative.Value);} + | unsignedNative = nativeUint {_localctx.Value = Actions.CreatePrimitiveElementType($unsignedNative.Value);} + | primitive = simpleType {_localctx.Value = Actions.CreatePrimitiveElementType($primitive.Value);} + | alias = dottedName {_localctx.Value = Actions.CreateTypedefElementType(_localctx.Start, $alias.Value);} /* typedef */ + | ELLIPSIS sentinelType = type {_localctx.Value = Actions.CreateSentinelElementType($sentinelType.Value);}; + +simpleType returns [byte Value]: + value = CHAR {_localctx.Value = Actions.GetSimpleType($value, false);} + | value = STRING {_localctx.Value = Actions.GetSimpleType($value, false);} + | value = BOOL {_localctx.Value = Actions.GetSimpleType($value, false);} + | value = INT8 {_localctx.Value = Actions.GetSimpleType($value, false);} + | value = INT16 {_localctx.Value = Actions.GetSimpleType($value, false);} + | value = INT32_ {_localctx.Value = Actions.GetSimpleType($value, false);} + | value = INT64_ {_localctx.Value = Actions.GetSimpleType($value, false);} + | value = FLOAT32 {_localctx.Value = Actions.GetSimpleType($value, false);} + | value = FLOAT64_ {_localctx.Value = Actions.GetSimpleType($value, false);} + | value = UINT8 {_localctx.Value = Actions.GetSimpleType($value, false);} + | value = UINT16 {_localctx.Value = Actions.GetSimpleType($value, false);} + | value = UINT32 {_localctx.Value = Actions.GetSimpleType($value, false);} + | value = UINT64 {_localctx.Value = Actions.GetSimpleType($value, false);} + | 'unsigned' value = INT8 {_localctx.Value = Actions.GetSimpleType($value, true);} + | 'unsigned' value = INT16 {_localctx.Value = Actions.GetSimpleType($value, true);} + | 'unsigned' value = INT32_ {_localctx.Value = Actions.GetSimpleType($value, true);} + | 'unsigned' value = INT64_ {_localctx.Value = Actions.GetSimpleType($value, true);}; + +bound returns [int Lower, int Upper, bool HasLower, bool HasUpper] +@init {Actions.InitializeBound(_localctx);} +: + /* EMPTY */ | ELLIPSIS - | int32 - | int32 ELLIPSIS int32 - | int32 ELLIPSIS; + | size = int32 {Actions.SetBoundSize(_localctx, $size.start);} + | lower = int32 ELLIPSIS upper = int32 {Actions.SetBoundRange(_localctx, $lower.start, $upper.start);} + | lower = int32 ELLIPSIS {Actions.SetBoundLower(_localctx, $lower.start);} +; /* Parser rules for multi-word type tokens that need whitespace handling */ -nativeInt: 'native' INT; -nativeUint: 'native' ('unsigned' INT | UINT); +nativeInt returns [byte Value]: + 'native' INT {_localctx.Value = Actions.GetNativeIntType();}; + +nativeUint returns [byte Value]: + 'native' ('unsigned' INT | UINT) {_localctx.Value = Actions.GetNativeUIntType();}; /* Security declarations */ PERMISSION: '.permission'; @@ -996,53 +1062,65 @@ secAction: /* Method referencing */ methodRef -@init {BeginSubtree();} +returns [object Value, bool HasSyntaxError] +@init {Actions.BeginSemanticRoot(_localctx);} : - callConv type typeSpec '::' methodName typeArgs? sigArgs - | callConv type typeSpec '::' methodName genArityNotEmpty sigArgs - | callConv type methodName typeArgs? sigArgs - | callConv type methodName genArityNotEmpty sigArgs - | mdtoken - | dottedName /* typeDef */ + convention = callConv returnType = type owner = typeSpec '::' name = methodName genericArguments = typeArgs? arguments = sigArgs + {_localctx.Value = Actions.CreateMethodReference(_localctx.Start, $convention.Value, $returnType.Value, $owner.Value, $name.Value, $genericArguments.ctx, null, $arguments.Value);} + | convention = callConv returnType = type owner = typeSpec '::' name = methodName genericArity = genArityNotEmpty arguments = sigArgs + {_localctx.Value = Actions.CreateMethodReference(_localctx.Start, $convention.Value, $returnType.Value, $owner.Value, $name.Value, null, $genericArity.Value, $arguments.Value);} + | convention = callConv returnType = type name = methodName genericArguments = typeArgs? arguments = sigArgs + {_localctx.Value = Actions.CreateMethodReference(_localctx.Start, $convention.Value, $returnType.Value, null, $name.Value, $genericArguments.ctx, null, $arguments.Value);} + | convention = callConv returnType = type name = methodName genericArity = genArityNotEmpty arguments = sigArgs + {_localctx.Value = Actions.CreateMethodReference(_localctx.Start, $convention.Value, $returnType.Value, null, $name.Value, null, $genericArity.Value, $arguments.Value);} + | token = mdtoken {_localctx.Value = Actions.CreateTokenMethodReference($token.Value);} + | alias = dottedName {_localctx.Value = Actions.CreateTypedefMethodReference(_localctx.Start, $alias.Value);} /* typeDef */ ; -finally {EndParseTreeMode();} +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} -callConv: - INSTANCE callConv - | EXPLICIT callConv - | callKind - | 'callconv' '(' int32 ')'; +callConv returns [byte Value]: + INSTANCE inner = callConv {_localctx.Value = Actions.AddInstanceCallingConvention($inner.Value);} + | EXPLICIT inner = callConv {_localctx.Value = Actions.AddExplicitCallingConvention($inner.Value);} + | kind = callKind {_localctx.Value = $kind.Value;} + | 'callconv' '(' raw = int32 ')' {_localctx.Value = Actions.GetRawCallingConvention($raw.start);}; -callKind: +callKind returns [byte Value] +@init {_localctx.Value = Actions.GetDefaultCallingConvention();} +: /* EMPTY */ - | DEFAULT - | VARARG - | UNMANAGED CDECL - | UNMANAGED STDCALL - | UNMANAGED THISCALL - | UNMANAGED FASTCALL - | UNMANAGED; + | kind = DEFAULT {_localctx.Value = Actions.GetCallingConvention($kind);} + | kind = VARARG {_localctx.Value = Actions.GetCallingConvention($kind);} + | UNMANAGED kind = CDECL {_localctx.Value = Actions.GetCallingConvention($kind);} + | UNMANAGED kind = STDCALL {_localctx.Value = Actions.GetCallingConvention($kind);} + | UNMANAGED kind = THISCALL {_localctx.Value = Actions.GetCallingConvention($kind);} + | UNMANAGED kind = FASTCALL {_localctx.Value = Actions.GetCallingConvention($kind);} + | kind = UNMANAGED {_localctx.Value = Actions.GetCallingConvention($kind);} +; mdtoken -@init {BeginSubtree();} +returns [int Value, bool HasSyntaxError] +@init {Actions.BeginSemanticRoot(_localctx);} : - 'mdtoken' '(' int32 ')' + 'mdtoken' '(' token = int32 ')' {_localctx.Value = Actions.ParseInt32($token.start);} ; -finally {EndParseTreeMode();} +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} -memberRef: - 'method' methodRef - | 'field' fieldRef - | mdtoken; +memberRef returns [object Value]: + 'method' method = methodRef {_localctx.Value = Actions.CreateMethodMemberReference($method.Value);} + | 'field' field = fieldRef {_localctx.Value = Actions.CreateFieldMemberReference($field.Value);} + | token = mdtoken {_localctx.Value = Actions.CreateTokenMemberReference($token.Value);}; fieldRef -@init {BeginSubtree();} +returns [object Value, bool HasSyntaxError] +@init {Actions.BeginSemanticRoot(_localctx);} : - type typeSpec '::' dottedName - | type dottedName - | dottedName // typedef + fieldType = type owner = typeSpec '::' name = dottedName + {_localctx.Value = Actions.CreateFieldReference($fieldType.Value, $owner.Value, $name.Value);} + | fieldType = type name = dottedName + {_localctx.Value = Actions.CreateFieldReference($fieldType.Value, null, $name.Value);} + | alias = dottedName {_localctx.Value = Actions.CreateTypedefFieldReference(_localctx.Start, $alias.Value);} // typedef ; -finally {EndParseTreeMode();} +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} /* Generic type parameters declaration */ typeList: (typeSpec ',')* typeSpec; @@ -1066,9 +1144,11 @@ typars: (typar ',')* typar; tyBound: '(' typeList ')'; -genArity: /* EMPTY */ | genArityNotEmpty; +genArity returns [int Value]: + value = genArityNotEmpty? {_localctx.Value = Actions.GetGenericArity($value.ctx);}; -genArityNotEmpty: '<' '[' int32 ']' '>'; +genArityNotEmpty returns [int Value]: + '<' '[' value = int32 ']' '>' {_localctx.Value = Actions.ParseInt32($value.start);}; /* Class body declarations */ classDecl @@ -1168,17 +1248,28 @@ propDecl: /* Method declaration */ -marshalClause: /* EMPTY */ | 'marshal' '(' marshalBlob ')'; +marshalClause +@init {BeginSubtree();} +: + /* EMPTY */ + | 'marshal' '(' marshalBlob ')' +; +finally {EndParseTreeMode();} marshalBlob: nativeType | '{' hexbyte+ '}'; -paramAttr: paramAttrElement*; +paramAttr returns [int Value] +@init {Actions.BeginParameterAttributes(_localctx);} +: + (element = paramAttrElement {Actions.AddParameterAttribute(_localctx, $element.ctx);})* +; +finally {_localctx.Value = Actions.EndParameterAttributes(_localctx);} -paramAttrElement: - '[' in = 'in' ']' - | '[' out = 'out' ']' - | '[' opt = 'opt' ']' - | '[' int32 ']'; +paramAttrElement returns [int Value, bool ShouldAppend]: + '[' attribute = 'in' ']' {Actions.SetParameterAttributeElement(_localctx, $attribute);} + | '[' attribute = 'out' ']' {Actions.SetParameterAttributeElement(_localctx, $attribute);} + | '[' attribute = 'opt' ']' {Actions.SetParameterAttributeElement(_localctx, $attribute);} + | '[' raw = int32 ']' {Actions.SetRawParameterAttributeElement(_localctx, $raw.start);}; methodHead @init {BeginSubtree();} @@ -1227,7 +1318,10 @@ pinvAttr: | 'charmaperror' ':' 'off' | 'flags' '(' int32 ')'; -methodName: '.ctor' | '.cctor' | dottedName; +methodName returns [string Value]: + ctorName = '.ctor' {_localctx.Value = Actions.GetMethodName($ctorName);} + | cctorName = '.cctor' {_localctx.Value = Actions.GetMethodName($cctorName);} + | dotted = dottedName {_localctx.Value = $dotted.Value;}; implAttr: 'native' diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.interp b/src/tools/ilasm/src/ILAssembler/gen/CIL.interp index 27aea6d5119aaa..5cc6ec413ec9e2 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.interp +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.interp @@ -793,4 +793,4 @@ manifestResDecl atn: -[4, 1, 305, 2917, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 357, 8, 1, 10, 1, 12, 1, 360, 9, 1, 1, 1, 1, 1, 3, 1, 364, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 5, 3, 371, 8, 3, 10, 3, 12, 3, 374, 9, 3, 1, 3, 1, 3, 1, 3, 1, 4, 5, 4, 380, 8, 4, 10, 4, 12, 4, 383, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 435, 8, 5, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 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, 476, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 5, 15, 483, 8, 15, 10, 15, 12, 15, 486, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 515, 8, 18, 1, 19, 1, 19, 3, 19, 519, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 537, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 564, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 587, 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, 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, 623, 8, 23, 1, 24, 1, 24, 1, 25, 1, 25, 3, 25, 629, 8, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 5, 27, 636, 8, 27, 10, 27, 12, 27, 639, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 648, 8, 28, 10, 28, 12, 28, 651, 9, 28, 1, 29, 1, 29, 1, 30, 1, 30, 3, 30, 657, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 668, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 676, 8, 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, 34, 1, 34, 1, 34, 1, 34, 5, 34, 697, 8, 34, 10, 34, 12, 34, 700, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 5, 37, 713, 8, 37, 10, 37, 12, 37, 716, 9, 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, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 760, 8, 38, 1, 39, 1, 39, 1, 39, 3, 39, 765, 8, 39, 1, 40, 1, 40, 1, 40, 3, 40, 770, 8, 40, 1, 41, 5, 41, 773, 8, 41, 10, 41, 12, 41, 776, 9, 41, 1, 42, 1, 42, 1, 42, 5, 42, 781, 8, 42, 10, 42, 12, 42, 784, 9, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 893, 8, 44, 1, 45, 1, 45, 5, 45, 897, 8, 45, 10, 45, 12, 45, 900, 9, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 913, 8, 45, 10, 45, 12, 45, 916, 9, 45, 1, 45, 1, 45, 1, 45, 3, 45, 921, 8, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 927, 8, 47, 1, 48, 1, 48, 1, 49, 5, 49, 932, 8, 49, 10, 49, 12, 49, 935, 9, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 962, 8, 50, 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, 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, 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, 1040, 8, 51, 3, 51, 1042, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1055, 8, 53, 1, 53, 1, 53, 5, 53, 1059, 8, 53, 10, 53, 12, 53, 1062, 9, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1070, 8, 53, 3, 53, 1072, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1078, 8, 54, 10, 54, 12, 54, 1081, 9, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1090, 8, 55, 10, 55, 12, 55, 1093, 9, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 5, 56, 1102, 8, 56, 10, 56, 12, 56, 1105, 9, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1111, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 1118, 8, 57, 3, 57, 1120, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1147, 8, 58, 1, 59, 1, 59, 1, 59, 5, 59, 1152, 8, 59, 10, 59, 12, 59, 1155, 9, 59, 1, 59, 1, 59, 1, 60, 5, 60, 1160, 8, 60, 10, 60, 12, 60, 1163, 9, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1170, 8, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 3, 62, 1183, 8, 62, 1, 63, 1, 63, 1, 63, 5, 63, 1188, 8, 63, 10, 63, 12, 63, 1191, 9, 63, 3, 63, 1193, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 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, 1212, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1306, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1315, 8, 66, 1, 67, 1, 67, 1, 67, 5, 67, 1320, 8, 67, 10, 67, 12, 67, 1323, 9, 67, 3, 67, 1325, 8, 67, 1, 68, 1, 68, 1, 69, 1, 69, 5, 69, 1331, 8, 69, 10, 69, 12, 69, 1334, 9, 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, 1, 70, 1, 70, 1, 70, 3, 70, 1354, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1386, 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, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1409, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1421, 8, 73, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1430, 8, 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, 3, 76, 1455, 8, 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, 1479, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 5, 77, 1485, 8, 77, 10, 77, 12, 77, 1488, 9, 77, 1, 77, 3, 77, 1491, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1506, 8, 78, 1, 79, 1, 79, 1, 79, 5, 79, 1511, 8, 79, 10, 79, 12, 79, 1514, 9, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1558, 8, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1568, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1584, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1596, 8, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1608, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1622, 8, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 1634, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1645, 8, 89, 1, 90, 1, 90, 1, 90, 5, 90, 1650, 8, 90, 10, 90, 12, 90, 1653, 9, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 1662, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 1675, 8, 92, 1, 93, 5, 93, 1678, 8, 93, 10, 93, 12, 93, 1681, 9, 93, 1, 94, 1, 94, 3, 94, 1685, 8, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 5, 95, 1692, 8, 95, 10, 95, 12, 95, 1695, 9, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 3, 97, 1705, 8, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1786, 8, 99, 10, 99, 12, 99, 1789, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1795, 8, 99, 10, 99, 12, 99, 1798, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1808, 8, 99, 10, 99, 12, 99, 1811, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1819, 8, 99, 10, 99, 12, 99, 1822, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 1829, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 1839, 8, 100, 10, 100, 12, 100, 1842, 9, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 1868, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 1875, 8, 102, 1, 103, 1, 103, 1, 103, 3, 103, 1880, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 1887, 8, 104, 1, 105, 1, 105, 5, 105, 1891, 8, 105, 10, 105, 12, 105, 1894, 9, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 1901, 8, 105, 10, 105, 12, 105, 1904, 9, 105, 1, 105, 3, 105, 1907, 8, 105, 1, 106, 1, 106, 1, 107, 5, 107, 1912, 8, 107, 10, 107, 12, 107, 1915, 9, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 1929, 8, 108, 1, 109, 1, 109, 5, 109, 1933, 8, 109, 10, 109, 12, 109, 1936, 9, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 111, 5, 111, 1947, 8, 111, 10, 111, 12, 111, 1950, 9, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 1962, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 1970, 8, 113, 1, 114, 1, 114, 1, 114, 4, 114, 1975, 8, 114, 11, 114, 12, 114, 1976, 1, 114, 1, 114, 3, 114, 1981, 8, 114, 1, 115, 5, 115, 1984, 8, 115, 10, 115, 12, 115, 1987, 9, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 2002, 8, 116, 1, 117, 1, 117, 1, 117, 5, 117, 2007, 8, 117, 10, 117, 12, 117, 2010, 9, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2020, 8, 117, 10, 117, 12, 117, 2023, 9, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2048, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2055, 8, 119, 3, 119, 2057, 8, 119, 1, 119, 5, 119, 2060, 8, 119, 10, 119, 12, 119, 2063, 9, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2068, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2097, 8, 120, 1, 121, 1, 121, 1, 121, 3, 121, 2102, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2125, 8, 122, 1, 123, 5, 123, 2128, 8, 123, 10, 123, 12, 123, 2131, 9, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2150, 8, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2201, 8, 125, 10, 125, 12, 125, 2204, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2210, 8, 125, 10, 125, 12, 125, 2213, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2223, 8, 125, 10, 125, 12, 125, 2226, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2234, 8, 125, 10, 125, 12, 125, 2237, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2245, 8, 125, 10, 125, 12, 125, 2248, 9, 125, 3, 125, 2250, 8, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 3, 127, 2258, 8, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 130, 4, 130, 2268, 8, 130, 11, 130, 12, 130, 2269, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 2284, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 3, 132, 2298, 8, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 2306, 8, 133, 1, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 2326, 8, 137, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 2338, 8, 139, 1, 140, 1, 140, 1, 140, 3, 140, 2343, 8, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 4, 141, 2350, 8, 141, 11, 141, 12, 141, 2351, 3, 141, 2354, 8, 141, 1, 142, 1, 142, 1, 142, 5, 142, 2359, 8, 142, 10, 142, 12, 142, 2362, 9, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 2371, 8, 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, 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, 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, 2439, 8, 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, 145, 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, 145, 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, 145, 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, 145, 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, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 3, 145, 2516, 8, 145, 1, 146, 1, 146, 1, 146, 5, 146, 2521, 8, 146, 10, 146, 12, 146, 2524, 9, 146, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 3, 148, 2531, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 2681, 8, 149, 1, 150, 1, 150, 5, 150, 2685, 8, 150, 10, 150, 12, 150, 2688, 9, 150, 1, 151, 1, 151, 5, 151, 2692, 8, 151, 10, 151, 12, 151, 2695, 9, 151, 1, 152, 5, 152, 2698, 8, 152, 10, 152, 12, 152, 2701, 9, 152, 1, 153, 5, 153, 2704, 8, 153, 10, 153, 12, 153, 2707, 9, 153, 1, 154, 5, 154, 2710, 8, 154, 10, 154, 12, 154, 2713, 9, 154, 1, 155, 5, 155, 2716, 8, 155, 10, 155, 12, 155, 2719, 9, 155, 1, 156, 5, 156, 2722, 8, 156, 10, 156, 12, 156, 2725, 9, 156, 1, 157, 5, 157, 2728, 8, 157, 10, 157, 12, 157, 2731, 9, 157, 1, 158, 5, 158, 2734, 8, 158, 10, 158, 12, 158, 2737, 9, 158, 1, 159, 1, 159, 1, 159, 1, 159, 3, 159, 2743, 8, 159, 1, 160, 5, 160, 2746, 8, 160, 10, 160, 12, 160, 2749, 9, 160, 1, 161, 1, 161, 1, 161, 3, 161, 2754, 8, 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, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 3, 162, 2781, 8, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 2795, 8, 163, 1, 164, 5, 164, 2798, 8, 164, 10, 164, 12, 164, 2801, 9, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 3, 165, 2817, 8, 165, 1, 166, 1, 166, 1, 166, 5, 166, 2822, 8, 166, 10, 166, 12, 166, 2825, 9, 166, 1, 166, 1, 166, 1, 167, 1, 167, 5, 167, 2831, 8, 167, 10, 167, 12, 167, 2834, 9, 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, 168, 1, 168, 1, 168, 1, 168, 3, 168, 2853, 8, 168, 1, 169, 5, 169, 2856, 8, 169, 10, 169, 12, 169, 2859, 9, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 2874, 8, 170, 1, 171, 1, 171, 5, 171, 2878, 8, 171, 10, 171, 12, 171, 2881, 9, 171, 1, 171, 1, 171, 1, 171, 5, 171, 2886, 8, 171, 10, 171, 12, 171, 2889, 9, 171, 1, 171, 1, 171, 1, 171, 1, 171, 3, 171, 2895, 8, 171, 1, 172, 1, 172, 1, 173, 5, 173, 2900, 8, 173, 10, 173, 12, 173, 2903, 9, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 2915, 8, 174, 1, 174, 0, 1, 68, 175, 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, 0, 16, 6, 0, 1, 15, 199, 199, 243, 243, 247, 247, 264, 264, 289, 289, 5, 0, 16, 16, 199, 199, 243, 243, 264, 264, 288, 289, 1, 0, 263, 264, 1, 0, 173, 174, 1, 0, 37, 38, 1, 0, 73, 74, 3, 0, 2, 2, 61, 61, 77, 83, 2, 0, 229, 229, 260, 261, 9, 0, 178, 178, 183, 195, 201, 201, 207, 208, 210, 215, 218, 219, 222, 222, 230, 242, 262, 262, 1, 0, 95, 96, 1, 0, 97, 111, 1, 0, 68, 69, 2, 0, 173, 173, 289, 290, 2, 0, 179, 179, 264, 264, 1, 0, 167, 168, 1, 0, 51, 52, 3344, 0, 350, 1, 0, 0, 0, 2, 363, 1, 0, 0, 0, 4, 365, 1, 0, 0, 0, 6, 372, 1, 0, 0, 0, 8, 381, 1, 0, 0, 0, 10, 434, 1, 0, 0, 0, 12, 436, 1, 0, 0, 0, 14, 439, 1, 0, 0, 0, 16, 442, 1, 0, 0, 0, 18, 446, 1, 0, 0, 0, 20, 449, 1, 0, 0, 0, 22, 452, 1, 0, 0, 0, 24, 459, 1, 0, 0, 0, 26, 475, 1, 0, 0, 0, 28, 477, 1, 0, 0, 0, 30, 479, 1, 0, 0, 0, 32, 489, 1, 0, 0, 0, 34, 491, 1, 0, 0, 0, 36, 514, 1, 0, 0, 0, 38, 518, 1, 0, 0, 0, 40, 536, 1, 0, 0, 0, 42, 563, 1, 0, 0, 0, 44, 586, 1, 0, 0, 0, 46, 622, 1, 0, 0, 0, 48, 624, 1, 0, 0, 0, 50, 628, 1, 0, 0, 0, 52, 630, 1, 0, 0, 0, 54, 637, 1, 0, 0, 0, 56, 649, 1, 0, 0, 0, 58, 652, 1, 0, 0, 0, 60, 654, 1, 0, 0, 0, 62, 667, 1, 0, 0, 0, 64, 675, 1, 0, 0, 0, 66, 677, 1, 0, 0, 0, 68, 685, 1, 0, 0, 0, 70, 701, 1, 0, 0, 0, 72, 707, 1, 0, 0, 0, 74, 710, 1, 0, 0, 0, 76, 759, 1, 0, 0, 0, 78, 764, 1, 0, 0, 0, 80, 769, 1, 0, 0, 0, 82, 774, 1, 0, 0, 0, 84, 782, 1, 0, 0, 0, 86, 787, 1, 0, 0, 0, 88, 892, 1, 0, 0, 0, 90, 920, 1, 0, 0, 0, 92, 922, 1, 0, 0, 0, 94, 926, 1, 0, 0, 0, 96, 928, 1, 0, 0, 0, 98, 933, 1, 0, 0, 0, 100, 961, 1, 0, 0, 0, 102, 1041, 1, 0, 0, 0, 104, 1043, 1, 0, 0, 0, 106, 1071, 1, 0, 0, 0, 108, 1073, 1, 0, 0, 0, 110, 1085, 1, 0, 0, 0, 112, 1110, 1, 0, 0, 0, 114, 1119, 1, 0, 0, 0, 116, 1146, 1, 0, 0, 0, 118, 1153, 1, 0, 0, 0, 120, 1161, 1, 0, 0, 0, 122, 1169, 1, 0, 0, 0, 124, 1182, 1, 0, 0, 0, 126, 1192, 1, 0, 0, 0, 128, 1211, 1, 0, 0, 0, 130, 1305, 1, 0, 0, 0, 132, 1314, 1, 0, 0, 0, 134, 1324, 1, 0, 0, 0, 136, 1326, 1, 0, 0, 0, 138, 1328, 1, 0, 0, 0, 140, 1353, 1, 0, 0, 0, 142, 1385, 1, 0, 0, 0, 144, 1408, 1, 0, 0, 0, 146, 1420, 1, 0, 0, 0, 148, 1422, 1, 0, 0, 0, 150, 1425, 1, 0, 0, 0, 152, 1478, 1, 0, 0, 0, 154, 1490, 1, 0, 0, 0, 156, 1505, 1, 0, 0, 0, 158, 1512, 1, 0, 0, 0, 160, 1517, 1, 0, 0, 0, 162, 1521, 1, 0, 0, 0, 164, 1557, 1, 0, 0, 0, 166, 1559, 1, 0, 0, 0, 168, 1595, 1, 0, 0, 0, 170, 1607, 1, 0, 0, 0, 172, 1621, 1, 0, 0, 0, 174, 1623, 1, 0, 0, 0, 176, 1633, 1, 0, 0, 0, 178, 1644, 1, 0, 0, 0, 180, 1651, 1, 0, 0, 0, 182, 1661, 1, 0, 0, 0, 184, 1674, 1, 0, 0, 0, 186, 1679, 1, 0, 0, 0, 188, 1682, 1, 0, 0, 0, 190, 1693, 1, 0, 0, 0, 192, 1698, 1, 0, 0, 0, 194, 1704, 1, 0, 0, 0, 196, 1706, 1, 0, 0, 0, 198, 1828, 1, 0, 0, 0, 200, 1830, 1, 0, 0, 0, 202, 1867, 1, 0, 0, 0, 204, 1874, 1, 0, 0, 0, 206, 1879, 1, 0, 0, 0, 208, 1886, 1, 0, 0, 0, 210, 1906, 1, 0, 0, 0, 212, 1908, 1, 0, 0, 0, 214, 1913, 1, 0, 0, 0, 216, 1928, 1, 0, 0, 0, 218, 1930, 1, 0, 0, 0, 220, 1943, 1, 0, 0, 0, 222, 1948, 1, 0, 0, 0, 224, 1961, 1, 0, 0, 0, 226, 1969, 1, 0, 0, 0, 228, 1980, 1, 0, 0, 0, 230, 1985, 1, 0, 0, 0, 232, 2001, 1, 0, 0, 0, 234, 2003, 1, 0, 0, 0, 236, 2047, 1, 0, 0, 0, 238, 2067, 1, 0, 0, 0, 240, 2096, 1, 0, 0, 0, 242, 2101, 1, 0, 0, 0, 244, 2124, 1, 0, 0, 0, 246, 2129, 1, 0, 0, 0, 248, 2149, 1, 0, 0, 0, 250, 2249, 1, 0, 0, 0, 252, 2251, 1, 0, 0, 0, 254, 2257, 1, 0, 0, 0, 256, 2259, 1, 0, 0, 0, 258, 2263, 1, 0, 0, 0, 260, 2267, 1, 0, 0, 0, 262, 2283, 1, 0, 0, 0, 264, 2297, 1, 0, 0, 0, 266, 2305, 1, 0, 0, 0, 268, 2307, 1, 0, 0, 0, 270, 2310, 1, 0, 0, 0, 272, 2312, 1, 0, 0, 0, 274, 2325, 1, 0, 0, 0, 276, 2327, 1, 0, 0, 0, 278, 2337, 1, 0, 0, 0, 280, 2342, 1, 0, 0, 0, 282, 2353, 1, 0, 0, 0, 284, 2360, 1, 0, 0, 0, 286, 2370, 1, 0, 0, 0, 288, 2438, 1, 0, 0, 0, 290, 2515, 1, 0, 0, 0, 292, 2522, 1, 0, 0, 0, 294, 2525, 1, 0, 0, 0, 296, 2530, 1, 0, 0, 0, 298, 2680, 1, 0, 0, 0, 300, 2686, 1, 0, 0, 0, 302, 2693, 1, 0, 0, 0, 304, 2699, 1, 0, 0, 0, 306, 2705, 1, 0, 0, 0, 308, 2711, 1, 0, 0, 0, 310, 2717, 1, 0, 0, 0, 312, 2723, 1, 0, 0, 0, 314, 2729, 1, 0, 0, 0, 316, 2735, 1, 0, 0, 0, 318, 2742, 1, 0, 0, 0, 320, 2747, 1, 0, 0, 0, 322, 2753, 1, 0, 0, 0, 324, 2780, 1, 0, 0, 0, 326, 2794, 1, 0, 0, 0, 328, 2799, 1, 0, 0, 0, 330, 2816, 1, 0, 0, 0, 332, 2818, 1, 0, 0, 0, 334, 2828, 1, 0, 0, 0, 336, 2852, 1, 0, 0, 0, 338, 2857, 1, 0, 0, 0, 340, 2873, 1, 0, 0, 0, 342, 2894, 1, 0, 0, 0, 344, 2896, 1, 0, 0, 0, 346, 2901, 1, 0, 0, 0, 348, 2914, 1, 0, 0, 0, 350, 351, 7, 0, 0, 0, 351, 1, 1, 0, 0, 0, 352, 364, 5, 288, 0, 0, 353, 354, 3, 4, 2, 0, 354, 355, 5, 265, 0, 0, 355, 357, 1, 0, 0, 0, 356, 353, 1, 0, 0, 0, 357, 360, 1, 0, 0, 0, 358, 356, 1, 0, 0, 0, 358, 359, 1, 0, 0, 0, 359, 361, 1, 0, 0, 0, 360, 358, 1, 0, 0, 0, 361, 364, 3, 4, 2, 0, 362, 364, 5, 264, 0, 0, 363, 352, 1, 0, 0, 0, 363, 358, 1, 0, 0, 0, 363, 362, 1, 0, 0, 0, 364, 3, 1, 0, 0, 0, 365, 366, 7, 1, 0, 0, 366, 5, 1, 0, 0, 0, 367, 368, 5, 263, 0, 0, 368, 369, 6, 3, -1, 0, 369, 371, 5, 266, 0, 0, 370, 367, 1, 0, 0, 0, 371, 374, 1, 0, 0, 0, 372, 370, 1, 0, 0, 0, 372, 373, 1, 0, 0, 0, 373, 375, 1, 0, 0, 0, 374, 372, 1, 0, 0, 0, 375, 376, 5, 263, 0, 0, 376, 377, 6, 3, -1, 0, 377, 7, 1, 0, 0, 0, 378, 380, 3, 10, 5, 0, 379, 378, 1, 0, 0, 0, 380, 383, 1, 0, 0, 0, 381, 379, 1, 0, 0, 0, 381, 382, 1, 0, 0, 0, 382, 9, 1, 0, 0, 0, 383, 381, 1, 0, 0, 0, 384, 385, 3, 74, 37, 0, 385, 386, 5, 17, 0, 0, 386, 387, 3, 82, 41, 0, 387, 388, 5, 18, 0, 0, 388, 435, 1, 0, 0, 0, 389, 390, 3, 72, 36, 0, 390, 391, 5, 17, 0, 0, 391, 392, 3, 8, 4, 0, 392, 393, 5, 18, 0, 0, 393, 435, 1, 0, 0, 0, 394, 395, 3, 234, 117, 0, 395, 396, 5, 17, 0, 0, 396, 397, 3, 246, 123, 0, 397, 398, 5, 18, 0, 0, 398, 435, 1, 0, 0, 0, 399, 435, 3, 200, 100, 0, 400, 435, 3, 276, 138, 0, 401, 435, 3, 70, 35, 0, 402, 435, 3, 66, 33, 0, 403, 435, 3, 88, 44, 0, 404, 435, 3, 90, 45, 0, 405, 435, 3, 22, 11, 0, 406, 407, 3, 326, 163, 0, 407, 408, 5, 17, 0, 0, 408, 409, 3, 328, 164, 0, 409, 410, 5, 18, 0, 0, 410, 435, 1, 0, 0, 0, 411, 412, 3, 332, 166, 0, 412, 413, 5, 17, 0, 0, 413, 414, 3, 338, 169, 0, 414, 415, 5, 18, 0, 0, 415, 435, 1, 0, 0, 0, 416, 417, 3, 342, 171, 0, 417, 418, 5, 17, 0, 0, 418, 419, 3, 346, 173, 0, 419, 420, 5, 18, 0, 0, 420, 435, 1, 0, 0, 0, 421, 435, 3, 64, 32, 0, 422, 435, 3, 152, 76, 0, 423, 435, 3, 322, 161, 0, 424, 435, 3, 12, 6, 0, 425, 435, 3, 14, 7, 0, 426, 435, 3, 16, 8, 0, 427, 435, 3, 18, 9, 0, 428, 435, 3, 20, 10, 0, 429, 435, 3, 26, 13, 0, 430, 435, 3, 42, 21, 0, 431, 435, 3, 40, 20, 0, 432, 435, 3, 30, 15, 0, 433, 435, 3, 24, 12, 0, 434, 384, 1, 0, 0, 0, 434, 389, 1, 0, 0, 0, 434, 394, 1, 0, 0, 0, 434, 399, 1, 0, 0, 0, 434, 400, 1, 0, 0, 0, 434, 401, 1, 0, 0, 0, 434, 402, 1, 0, 0, 0, 434, 403, 1, 0, 0, 0, 434, 404, 1, 0, 0, 0, 434, 405, 1, 0, 0, 0, 434, 406, 1, 0, 0, 0, 434, 411, 1, 0, 0, 0, 434, 416, 1, 0, 0, 0, 434, 421, 1, 0, 0, 0, 434, 422, 1, 0, 0, 0, 434, 423, 1, 0, 0, 0, 434, 424, 1, 0, 0, 0, 434, 425, 1, 0, 0, 0, 434, 426, 1, 0, 0, 0, 434, 427, 1, 0, 0, 0, 434, 428, 1, 0, 0, 0, 434, 429, 1, 0, 0, 0, 434, 430, 1, 0, 0, 0, 434, 431, 1, 0, 0, 0, 434, 432, 1, 0, 0, 0, 434, 433, 1, 0, 0, 0, 435, 11, 1, 0, 0, 0, 436, 437, 5, 19, 0, 0, 437, 438, 3, 32, 16, 0, 438, 13, 1, 0, 0, 0, 439, 440, 5, 20, 0, 0, 440, 441, 3, 32, 16, 0, 441, 15, 1, 0, 0, 0, 442, 443, 5, 21, 0, 0, 443, 444, 5, 22, 0, 0, 444, 445, 3, 32, 16, 0, 445, 17, 1, 0, 0, 0, 446, 447, 5, 23, 0, 0, 447, 448, 3, 34, 17, 0, 448, 19, 1, 0, 0, 0, 449, 450, 5, 24, 0, 0, 450, 451, 3, 34, 17, 0, 451, 21, 1, 0, 0, 0, 452, 453, 5, 25, 0, 0, 453, 454, 3, 98, 49, 0, 454, 455, 3, 2, 1, 0, 455, 456, 5, 17, 0, 0, 456, 457, 3, 120, 60, 0, 457, 458, 5, 18, 0, 0, 458, 23, 1, 0, 0, 0, 459, 460, 5, 26, 0, 0, 460, 25, 1, 0, 0, 0, 461, 462, 5, 27, 0, 0, 462, 476, 3, 28, 14, 0, 463, 464, 5, 27, 0, 0, 464, 465, 3, 28, 14, 0, 465, 466, 5, 28, 0, 0, 466, 467, 3, 28, 14, 0, 467, 476, 1, 0, 0, 0, 468, 469, 5, 27, 0, 0, 469, 470, 3, 28, 14, 0, 470, 471, 5, 28, 0, 0, 471, 472, 3, 28, 14, 0, 472, 473, 5, 28, 0, 0, 473, 474, 3, 28, 14, 0, 474, 476, 1, 0, 0, 0, 475, 461, 1, 0, 0, 0, 475, 463, 1, 0, 0, 0, 475, 468, 1, 0, 0, 0, 476, 27, 1, 0, 0, 0, 477, 478, 7, 2, 0, 0, 478, 29, 1, 0, 0, 0, 479, 480, 5, 29, 0, 0, 480, 484, 5, 17, 0, 0, 481, 483, 3, 116, 58, 0, 482, 481, 1, 0, 0, 0, 483, 486, 1, 0, 0, 0, 484, 482, 1, 0, 0, 0, 484, 485, 1, 0, 0, 0, 485, 487, 1, 0, 0, 0, 486, 484, 1, 0, 0, 0, 487, 488, 5, 18, 0, 0, 488, 31, 1, 0, 0, 0, 489, 490, 5, 173, 0, 0, 490, 33, 1, 0, 0, 0, 491, 492, 7, 3, 0, 0, 492, 35, 1, 0, 0, 0, 493, 494, 5, 175, 0, 0, 494, 515, 6, 18, -1, 0, 495, 496, 3, 32, 16, 0, 496, 497, 5, 265, 0, 0, 497, 498, 6, 18, -1, 0, 498, 515, 1, 0, 0, 0, 499, 500, 3, 32, 16, 0, 500, 501, 6, 18, -1, 0, 501, 515, 1, 0, 0, 0, 502, 503, 5, 188, 0, 0, 503, 504, 5, 30, 0, 0, 504, 505, 3, 32, 16, 0, 505, 506, 5, 31, 0, 0, 506, 507, 6, 18, -1, 0, 507, 515, 1, 0, 0, 0, 508, 509, 5, 189, 0, 0, 509, 510, 5, 30, 0, 0, 510, 511, 3, 34, 17, 0, 511, 512, 5, 31, 0, 0, 512, 513, 6, 18, -1, 0, 513, 515, 1, 0, 0, 0, 514, 493, 1, 0, 0, 0, 514, 495, 1, 0, 0, 0, 514, 499, 1, 0, 0, 0, 514, 502, 1, 0, 0, 0, 514, 508, 1, 0, 0, 0, 515, 37, 1, 0, 0, 0, 516, 519, 3, 32, 16, 0, 517, 519, 5, 262, 0, 0, 518, 516, 1, 0, 0, 0, 518, 517, 1, 0, 0, 0, 519, 39, 1, 0, 0, 0, 520, 521, 5, 267, 0, 0, 521, 537, 5, 289, 0, 0, 522, 523, 5, 267, 0, 0, 523, 524, 5, 289, 0, 0, 524, 537, 5, 263, 0, 0, 525, 526, 5, 268, 0, 0, 526, 537, 5, 289, 0, 0, 527, 528, 5, 269, 0, 0, 528, 537, 5, 289, 0, 0, 529, 530, 5, 270, 0, 0, 530, 537, 5, 289, 0, 0, 531, 537, 5, 271, 0, 0, 532, 537, 5, 272, 0, 0, 533, 534, 5, 273, 0, 0, 534, 537, 5, 263, 0, 0, 535, 537, 5, 32, 0, 0, 536, 520, 1, 0, 0, 0, 536, 522, 1, 0, 0, 0, 536, 525, 1, 0, 0, 0, 536, 527, 1, 0, 0, 0, 536, 529, 1, 0, 0, 0, 536, 531, 1, 0, 0, 0, 536, 532, 1, 0, 0, 0, 536, 533, 1, 0, 0, 0, 536, 535, 1, 0, 0, 0, 537, 41, 1, 0, 0, 0, 538, 539, 5, 33, 0, 0, 539, 540, 3, 138, 69, 0, 540, 541, 5, 34, 0, 0, 541, 542, 3, 2, 1, 0, 542, 564, 1, 0, 0, 0, 543, 544, 5, 33, 0, 0, 544, 545, 3, 116, 58, 0, 545, 546, 5, 34, 0, 0, 546, 547, 3, 2, 1, 0, 547, 564, 1, 0, 0, 0, 548, 549, 5, 33, 0, 0, 549, 550, 3, 176, 88, 0, 550, 551, 5, 34, 0, 0, 551, 552, 3, 2, 1, 0, 552, 564, 1, 0, 0, 0, 553, 554, 5, 33, 0, 0, 554, 555, 3, 44, 22, 0, 555, 556, 5, 34, 0, 0, 556, 557, 3, 2, 1, 0, 557, 564, 1, 0, 0, 0, 558, 559, 5, 33, 0, 0, 559, 560, 3, 46, 23, 0, 560, 561, 5, 34, 0, 0, 561, 562, 3, 2, 1, 0, 562, 564, 1, 0, 0, 0, 563, 538, 1, 0, 0, 0, 563, 543, 1, 0, 0, 0, 563, 548, 1, 0, 0, 0, 563, 553, 1, 0, 0, 0, 563, 558, 1, 0, 0, 0, 564, 43, 1, 0, 0, 0, 565, 566, 5, 35, 0, 0, 566, 587, 3, 48, 24, 0, 567, 568, 5, 35, 0, 0, 568, 569, 3, 48, 24, 0, 569, 570, 5, 36, 0, 0, 570, 571, 3, 6, 3, 0, 571, 587, 1, 0, 0, 0, 572, 573, 5, 35, 0, 0, 573, 574, 3, 48, 24, 0, 574, 575, 5, 36, 0, 0, 575, 576, 5, 17, 0, 0, 576, 577, 3, 52, 26, 0, 577, 578, 5, 18, 0, 0, 578, 587, 1, 0, 0, 0, 579, 580, 5, 35, 0, 0, 580, 581, 3, 48, 24, 0, 581, 582, 5, 36, 0, 0, 582, 583, 5, 30, 0, 0, 583, 584, 3, 292, 146, 0, 584, 585, 5, 31, 0, 0, 585, 587, 1, 0, 0, 0, 586, 565, 1, 0, 0, 0, 586, 567, 1, 0, 0, 0, 586, 572, 1, 0, 0, 0, 586, 579, 1, 0, 0, 0, 587, 45, 1, 0, 0, 0, 588, 589, 5, 35, 0, 0, 589, 590, 5, 30, 0, 0, 590, 591, 3, 50, 25, 0, 591, 592, 5, 31, 0, 0, 592, 593, 3, 48, 24, 0, 593, 623, 1, 0, 0, 0, 594, 595, 5, 35, 0, 0, 595, 596, 5, 30, 0, 0, 596, 597, 3, 50, 25, 0, 597, 598, 5, 31, 0, 0, 598, 599, 3, 48, 24, 0, 599, 600, 5, 36, 0, 0, 600, 601, 3, 6, 3, 0, 601, 623, 1, 0, 0, 0, 602, 603, 5, 35, 0, 0, 603, 604, 5, 30, 0, 0, 604, 605, 3, 50, 25, 0, 605, 606, 5, 31, 0, 0, 606, 607, 3, 48, 24, 0, 607, 608, 5, 36, 0, 0, 608, 609, 5, 17, 0, 0, 609, 610, 3, 52, 26, 0, 610, 611, 5, 18, 0, 0, 611, 623, 1, 0, 0, 0, 612, 613, 5, 35, 0, 0, 613, 614, 5, 30, 0, 0, 614, 615, 3, 50, 25, 0, 615, 616, 5, 31, 0, 0, 616, 617, 3, 48, 24, 0, 617, 618, 5, 36, 0, 0, 618, 619, 5, 30, 0, 0, 619, 620, 3, 292, 146, 0, 620, 621, 5, 31, 0, 0, 621, 623, 1, 0, 0, 0, 622, 588, 1, 0, 0, 0, 622, 594, 1, 0, 0, 0, 622, 602, 1, 0, 0, 0, 622, 612, 1, 0, 0, 0, 623, 47, 1, 0, 0, 0, 624, 625, 3, 168, 84, 0, 625, 49, 1, 0, 0, 0, 626, 629, 3, 124, 62, 0, 627, 629, 3, 176, 88, 0, 628, 626, 1, 0, 0, 0, 628, 627, 1, 0, 0, 0, 629, 51, 1, 0, 0, 0, 630, 631, 3, 54, 27, 0, 631, 632, 3, 56, 28, 0, 632, 53, 1, 0, 0, 0, 633, 636, 3, 298, 149, 0, 634, 636, 3, 40, 20, 0, 635, 633, 1, 0, 0, 0, 635, 634, 1, 0, 0, 0, 636, 639, 1, 0, 0, 0, 637, 635, 1, 0, 0, 0, 637, 638, 1, 0, 0, 0, 638, 55, 1, 0, 0, 0, 639, 637, 1, 0, 0, 0, 640, 641, 3, 58, 29, 0, 641, 642, 3, 60, 30, 0, 642, 643, 3, 2, 1, 0, 643, 644, 5, 36, 0, 0, 644, 645, 3, 298, 149, 0, 645, 648, 1, 0, 0, 0, 646, 648, 3, 40, 20, 0, 647, 640, 1, 0, 0, 0, 647, 646, 1, 0, 0, 0, 648, 651, 1, 0, 0, 0, 649, 647, 1, 0, 0, 0, 649, 650, 1, 0, 0, 0, 650, 57, 1, 0, 0, 0, 651, 649, 1, 0, 0, 0, 652, 653, 7, 4, 0, 0, 653, 59, 1, 0, 0, 0, 654, 656, 3, 62, 31, 0, 655, 657, 5, 261, 0, 0, 656, 655, 1, 0, 0, 0, 656, 657, 1, 0, 0, 0, 657, 61, 1, 0, 0, 0, 658, 668, 3, 144, 72, 0, 659, 668, 3, 2, 1, 0, 660, 668, 5, 196, 0, 0, 661, 668, 5, 197, 0, 0, 662, 663, 5, 202, 0, 0, 663, 664, 5, 39, 0, 0, 664, 668, 5, 264, 0, 0, 665, 666, 5, 202, 0, 0, 666, 668, 3, 116, 58, 0, 667, 658, 1, 0, 0, 0, 667, 659, 1, 0, 0, 0, 667, 660, 1, 0, 0, 0, 667, 661, 1, 0, 0, 0, 667, 662, 1, 0, 0, 0, 667, 665, 1, 0, 0, 0, 668, 63, 1, 0, 0, 0, 669, 670, 5, 198, 0, 0, 670, 671, 5, 40, 0, 0, 671, 676, 3, 2, 1, 0, 672, 673, 5, 198, 0, 0, 673, 676, 3, 2, 1, 0, 674, 676, 5, 198, 0, 0, 675, 669, 1, 0, 0, 0, 675, 672, 1, 0, 0, 0, 675, 674, 1, 0, 0, 0, 676, 65, 1, 0, 0, 0, 677, 678, 5, 41, 0, 0, 678, 679, 5, 42, 0, 0, 679, 680, 3, 32, 16, 0, 680, 681, 5, 43, 0, 0, 681, 682, 3, 68, 34, 0, 682, 683, 5, 44, 0, 0, 683, 684, 3, 0, 0, 0, 684, 67, 1, 0, 0, 0, 685, 698, 6, 34, -1, 0, 686, 687, 10, 5, 0, 0, 687, 697, 5, 186, 0, 0, 688, 689, 10, 4, 0, 0, 689, 697, 5, 187, 0, 0, 690, 691, 10, 3, 0, 0, 691, 697, 5, 45, 0, 0, 692, 693, 10, 2, 0, 0, 693, 697, 5, 46, 0, 0, 694, 695, 10, 1, 0, 0, 695, 697, 5, 47, 0, 0, 696, 686, 1, 0, 0, 0, 696, 688, 1, 0, 0, 0, 696, 690, 1, 0, 0, 0, 696, 692, 1, 0, 0, 0, 696, 694, 1, 0, 0, 0, 697, 700, 1, 0, 0, 0, 698, 696, 1, 0, 0, 0, 698, 699, 1, 0, 0, 0, 699, 69, 1, 0, 0, 0, 700, 698, 1, 0, 0, 0, 701, 702, 5, 48, 0, 0, 702, 703, 5, 36, 0, 0, 703, 704, 5, 30, 0, 0, 704, 705, 3, 292, 146, 0, 705, 706, 5, 31, 0, 0, 706, 71, 1, 0, 0, 0, 707, 708, 5, 49, 0, 0, 708, 709, 3, 2, 1, 0, 709, 73, 1, 0, 0, 0, 710, 714, 5, 50, 0, 0, 711, 713, 3, 76, 38, 0, 712, 711, 1, 0, 0, 0, 713, 716, 1, 0, 0, 0, 714, 712, 1, 0, 0, 0, 714, 715, 1, 0, 0, 0, 715, 717, 1, 0, 0, 0, 716, 714, 1, 0, 0, 0, 717, 718, 3, 2, 1, 0, 718, 719, 3, 182, 91, 0, 719, 720, 3, 78, 39, 0, 720, 721, 3, 80, 40, 0, 721, 75, 1, 0, 0, 0, 722, 760, 5, 51, 0, 0, 723, 760, 5, 52, 0, 0, 724, 760, 5, 199, 0, 0, 725, 760, 5, 202, 0, 0, 726, 760, 5, 221, 0, 0, 727, 760, 5, 53, 0, 0, 728, 760, 5, 54, 0, 0, 729, 760, 5, 55, 0, 0, 730, 760, 5, 56, 0, 0, 731, 760, 5, 244, 0, 0, 732, 760, 5, 15, 0, 0, 733, 760, 5, 224, 0, 0, 734, 760, 5, 57, 0, 0, 735, 760, 5, 58, 0, 0, 736, 760, 5, 59, 0, 0, 737, 760, 5, 60, 0, 0, 738, 760, 5, 61, 0, 0, 739, 740, 5, 62, 0, 0, 740, 760, 5, 51, 0, 0, 741, 742, 5, 62, 0, 0, 742, 760, 5, 52, 0, 0, 743, 744, 5, 62, 0, 0, 744, 760, 5, 63, 0, 0, 745, 746, 5, 62, 0, 0, 746, 760, 5, 64, 0, 0, 747, 748, 5, 62, 0, 0, 748, 760, 5, 65, 0, 0, 749, 750, 5, 62, 0, 0, 750, 760, 5, 66, 0, 0, 751, 760, 5, 67, 0, 0, 752, 760, 5, 68, 0, 0, 753, 760, 5, 69, 0, 0, 754, 755, 5, 70, 0, 0, 755, 756, 5, 30, 0, 0, 756, 757, 3, 32, 16, 0, 757, 758, 5, 31, 0, 0, 758, 760, 1, 0, 0, 0, 759, 722, 1, 0, 0, 0, 759, 723, 1, 0, 0, 0, 759, 724, 1, 0, 0, 0, 759, 725, 1, 0, 0, 0, 759, 726, 1, 0, 0, 0, 759, 727, 1, 0, 0, 0, 759, 728, 1, 0, 0, 0, 759, 729, 1, 0, 0, 0, 759, 730, 1, 0, 0, 0, 759, 731, 1, 0, 0, 0, 759, 732, 1, 0, 0, 0, 759, 733, 1, 0, 0, 0, 759, 734, 1, 0, 0, 0, 759, 735, 1, 0, 0, 0, 759, 736, 1, 0, 0, 0, 759, 737, 1, 0, 0, 0, 759, 738, 1, 0, 0, 0, 759, 739, 1, 0, 0, 0, 759, 741, 1, 0, 0, 0, 759, 743, 1, 0, 0, 0, 759, 745, 1, 0, 0, 0, 759, 747, 1, 0, 0, 0, 759, 749, 1, 0, 0, 0, 759, 751, 1, 0, 0, 0, 759, 752, 1, 0, 0, 0, 759, 753, 1, 0, 0, 0, 759, 754, 1, 0, 0, 0, 760, 77, 1, 0, 0, 0, 761, 765, 1, 0, 0, 0, 762, 763, 5, 71, 0, 0, 763, 765, 3, 124, 62, 0, 764, 761, 1, 0, 0, 0, 764, 762, 1, 0, 0, 0, 765, 79, 1, 0, 0, 0, 766, 770, 1, 0, 0, 0, 767, 768, 5, 72, 0, 0, 768, 770, 3, 84, 42, 0, 769, 766, 1, 0, 0, 0, 769, 767, 1, 0, 0, 0, 770, 81, 1, 0, 0, 0, 771, 773, 3, 198, 99, 0, 772, 771, 1, 0, 0, 0, 773, 776, 1, 0, 0, 0, 774, 772, 1, 0, 0, 0, 774, 775, 1, 0, 0, 0, 775, 83, 1, 0, 0, 0, 776, 774, 1, 0, 0, 0, 777, 778, 3, 124, 62, 0, 778, 779, 5, 28, 0, 0, 779, 781, 1, 0, 0, 0, 780, 777, 1, 0, 0, 0, 781, 784, 1, 0, 0, 0, 782, 780, 1, 0, 0, 0, 782, 783, 1, 0, 0, 0, 783, 785, 1, 0, 0, 0, 784, 782, 1, 0, 0, 0, 785, 786, 3, 124, 62, 0, 786, 85, 1, 0, 0, 0, 787, 788, 7, 5, 0, 0, 788, 87, 1, 0, 0, 0, 789, 790, 3, 86, 43, 0, 790, 791, 3, 32, 16, 0, 791, 792, 5, 264, 0, 0, 792, 893, 1, 0, 0, 0, 793, 794, 3, 86, 43, 0, 794, 795, 3, 32, 16, 0, 795, 893, 1, 0, 0, 0, 796, 797, 3, 86, 43, 0, 797, 798, 3, 32, 16, 0, 798, 799, 5, 75, 0, 0, 799, 800, 3, 32, 16, 0, 800, 801, 5, 264, 0, 0, 801, 893, 1, 0, 0, 0, 802, 803, 3, 86, 43, 0, 803, 804, 3, 32, 16, 0, 804, 805, 5, 75, 0, 0, 805, 806, 3, 32, 16, 0, 806, 893, 1, 0, 0, 0, 807, 808, 3, 86, 43, 0, 808, 809, 3, 32, 16, 0, 809, 810, 5, 75, 0, 0, 810, 811, 3, 32, 16, 0, 811, 812, 5, 28, 0, 0, 812, 813, 3, 32, 16, 0, 813, 814, 5, 264, 0, 0, 814, 893, 1, 0, 0, 0, 815, 816, 3, 86, 43, 0, 816, 817, 3, 32, 16, 0, 817, 818, 5, 75, 0, 0, 818, 819, 3, 32, 16, 0, 819, 820, 5, 28, 0, 0, 820, 821, 3, 32, 16, 0, 821, 893, 1, 0, 0, 0, 822, 823, 3, 86, 43, 0, 823, 824, 3, 32, 16, 0, 824, 825, 5, 28, 0, 0, 825, 826, 3, 32, 16, 0, 826, 827, 5, 75, 0, 0, 827, 828, 3, 32, 16, 0, 828, 829, 5, 264, 0, 0, 829, 893, 1, 0, 0, 0, 830, 831, 3, 86, 43, 0, 831, 832, 3, 32, 16, 0, 832, 833, 5, 28, 0, 0, 833, 834, 3, 32, 16, 0, 834, 835, 5, 75, 0, 0, 835, 836, 3, 32, 16, 0, 836, 893, 1, 0, 0, 0, 837, 838, 3, 86, 43, 0, 838, 839, 3, 32, 16, 0, 839, 840, 5, 28, 0, 0, 840, 841, 3, 32, 16, 0, 841, 842, 5, 75, 0, 0, 842, 843, 3, 32, 16, 0, 843, 844, 5, 28, 0, 0, 844, 845, 3, 32, 16, 0, 845, 846, 5, 264, 0, 0, 846, 893, 1, 0, 0, 0, 847, 848, 3, 86, 43, 0, 848, 849, 3, 32, 16, 0, 849, 850, 5, 28, 0, 0, 850, 851, 3, 32, 16, 0, 851, 852, 5, 75, 0, 0, 852, 853, 3, 32, 16, 0, 853, 854, 5, 28, 0, 0, 854, 855, 3, 32, 16, 0, 855, 893, 1, 0, 0, 0, 856, 857, 3, 86, 43, 0, 857, 858, 3, 32, 16, 0, 858, 859, 5, 263, 0, 0, 859, 893, 1, 0, 0, 0, 860, 861, 3, 86, 43, 0, 861, 862, 3, 32, 16, 0, 862, 863, 5, 75, 0, 0, 863, 864, 3, 32, 16, 0, 864, 865, 5, 263, 0, 0, 865, 893, 1, 0, 0, 0, 866, 867, 3, 86, 43, 0, 867, 868, 3, 32, 16, 0, 868, 869, 5, 75, 0, 0, 869, 870, 3, 32, 16, 0, 870, 871, 5, 28, 0, 0, 871, 872, 3, 32, 16, 0, 872, 873, 5, 263, 0, 0, 873, 893, 1, 0, 0, 0, 874, 875, 3, 86, 43, 0, 875, 876, 3, 32, 16, 0, 876, 877, 5, 28, 0, 0, 877, 878, 3, 32, 16, 0, 878, 879, 5, 75, 0, 0, 879, 880, 3, 32, 16, 0, 880, 881, 5, 263, 0, 0, 881, 893, 1, 0, 0, 0, 882, 883, 3, 86, 43, 0, 883, 884, 3, 32, 16, 0, 884, 885, 5, 28, 0, 0, 885, 886, 3, 32, 16, 0, 886, 887, 5, 75, 0, 0, 887, 888, 3, 32, 16, 0, 888, 889, 5, 28, 0, 0, 889, 890, 3, 32, 16, 0, 890, 891, 5, 263, 0, 0, 891, 893, 1, 0, 0, 0, 892, 789, 1, 0, 0, 0, 892, 793, 1, 0, 0, 0, 892, 796, 1, 0, 0, 0, 892, 802, 1, 0, 0, 0, 892, 807, 1, 0, 0, 0, 892, 815, 1, 0, 0, 0, 892, 822, 1, 0, 0, 0, 892, 830, 1, 0, 0, 0, 892, 837, 1, 0, 0, 0, 892, 847, 1, 0, 0, 0, 892, 856, 1, 0, 0, 0, 892, 860, 1, 0, 0, 0, 892, 866, 1, 0, 0, 0, 892, 874, 1, 0, 0, 0, 892, 882, 1, 0, 0, 0, 893, 89, 1, 0, 0, 0, 894, 898, 5, 21, 0, 0, 895, 897, 3, 92, 46, 0, 896, 895, 1, 0, 0, 0, 897, 900, 1, 0, 0, 0, 898, 896, 1, 0, 0, 0, 898, 899, 1, 0, 0, 0, 899, 901, 1, 0, 0, 0, 900, 898, 1, 0, 0, 0, 901, 902, 3, 2, 1, 0, 902, 903, 3, 94, 47, 0, 903, 904, 5, 180, 0, 0, 904, 905, 5, 36, 0, 0, 905, 906, 5, 30, 0, 0, 906, 907, 3, 292, 146, 0, 907, 908, 5, 31, 0, 0, 908, 909, 3, 94, 47, 0, 909, 921, 1, 0, 0, 0, 910, 914, 5, 21, 0, 0, 911, 913, 3, 92, 46, 0, 912, 911, 1, 0, 0, 0, 913, 916, 1, 0, 0, 0, 914, 912, 1, 0, 0, 0, 914, 915, 1, 0, 0, 0, 915, 917, 1, 0, 0, 0, 916, 914, 1, 0, 0, 0, 917, 918, 3, 2, 1, 0, 918, 919, 3, 94, 47, 0, 919, 921, 1, 0, 0, 0, 920, 894, 1, 0, 0, 0, 920, 910, 1, 0, 0, 0, 921, 91, 1, 0, 0, 0, 922, 923, 5, 76, 0, 0, 923, 93, 1, 0, 0, 0, 924, 927, 1, 0, 0, 0, 925, 927, 5, 298, 0, 0, 926, 924, 1, 0, 0, 0, 926, 925, 1, 0, 0, 0, 927, 95, 1, 0, 0, 0, 928, 929, 7, 6, 0, 0, 929, 97, 1, 0, 0, 0, 930, 932, 3, 96, 48, 0, 931, 930, 1, 0, 0, 0, 932, 935, 1, 0, 0, 0, 933, 931, 1, 0, 0, 0, 933, 934, 1, 0, 0, 0, 934, 99, 1, 0, 0, 0, 935, 933, 1, 0, 0, 0, 936, 962, 3, 102, 51, 0, 937, 938, 5, 280, 0, 0, 938, 939, 3, 168, 84, 0, 939, 940, 6, 50, -1, 0, 940, 962, 1, 0, 0, 0, 941, 942, 5, 286, 0, 0, 942, 943, 3, 178, 89, 0, 943, 944, 6, 50, -1, 0, 944, 962, 1, 0, 0, 0, 945, 946, 5, 286, 0, 0, 946, 947, 3, 174, 87, 0, 947, 948, 6, 50, -1, 0, 948, 962, 1, 0, 0, 0, 949, 950, 5, 284, 0, 0, 950, 951, 3, 124, 62, 0, 951, 952, 6, 50, -1, 0, 952, 962, 1, 0, 0, 0, 953, 954, 5, 281, 0, 0, 954, 955, 3, 104, 52, 0, 955, 956, 6, 50, -1, 0, 956, 962, 1, 0, 0, 0, 957, 958, 5, 287, 0, 0, 958, 959, 3, 50, 25, 0, 959, 960, 6, 50, -1, 0, 960, 962, 1, 0, 0, 0, 961, 936, 1, 0, 0, 0, 961, 937, 1, 0, 0, 0, 961, 941, 1, 0, 0, 0, 961, 945, 1, 0, 0, 0, 961, 949, 1, 0, 0, 0, 961, 953, 1, 0, 0, 0, 961, 957, 1, 0, 0, 0, 962, 101, 1, 0, 0, 0, 963, 964, 5, 275, 0, 0, 964, 1042, 6, 51, -1, 0, 965, 966, 5, 276, 0, 0, 966, 967, 3, 32, 16, 0, 967, 968, 6, 51, -1, 0, 968, 1042, 1, 0, 0, 0, 969, 970, 5, 276, 0, 0, 970, 971, 3, 0, 0, 0, 971, 972, 6, 51, -1, 0, 972, 1042, 1, 0, 0, 0, 973, 974, 5, 277, 0, 0, 974, 975, 3, 32, 16, 0, 975, 976, 6, 51, -1, 0, 976, 1042, 1, 0, 0, 0, 977, 978, 5, 278, 0, 0, 978, 979, 3, 34, 17, 0, 979, 980, 6, 51, -1, 0, 980, 1042, 1, 0, 0, 0, 981, 982, 5, 279, 0, 0, 982, 983, 3, 36, 18, 0, 983, 984, 6, 51, -1, 0, 984, 1042, 1, 0, 0, 0, 985, 986, 5, 279, 0, 0, 986, 987, 3, 34, 17, 0, 987, 988, 6, 51, -1, 0, 988, 1042, 1, 0, 0, 0, 989, 990, 5, 279, 0, 0, 990, 991, 5, 30, 0, 0, 991, 992, 3, 292, 146, 0, 992, 993, 5, 31, 0, 0, 993, 994, 6, 51, -1, 0, 994, 1042, 1, 0, 0, 0, 995, 996, 5, 279, 0, 0, 996, 997, 5, 84, 0, 0, 997, 998, 5, 30, 0, 0, 998, 999, 3, 292, 146, 0, 999, 1000, 5, 31, 0, 0, 1000, 1001, 6, 51, -1, 0, 1001, 1042, 1, 0, 0, 0, 1002, 1003, 5, 282, 0, 0, 1003, 1004, 3, 32, 16, 0, 1004, 1005, 6, 51, -1, 0, 1005, 1042, 1, 0, 0, 0, 1006, 1007, 5, 282, 0, 0, 1007, 1008, 3, 0, 0, 0, 1008, 1009, 6, 51, -1, 0, 1009, 1042, 1, 0, 0, 0, 1010, 1011, 5, 285, 0, 0, 1011, 1012, 3, 6, 3, 0, 1012, 1013, 6, 51, -1, 0, 1013, 1042, 1, 0, 0, 0, 1014, 1015, 5, 285, 0, 0, 1015, 1016, 5, 224, 0, 0, 1016, 1017, 5, 30, 0, 0, 1017, 1018, 3, 6, 3, 0, 1018, 1019, 5, 31, 0, 0, 1019, 1020, 6, 51, -1, 0, 1020, 1042, 1, 0, 0, 0, 1021, 1022, 5, 285, 0, 0, 1022, 1023, 5, 84, 0, 0, 1023, 1024, 5, 30, 0, 0, 1024, 1025, 3, 292, 146, 0, 1025, 1026, 5, 31, 0, 0, 1026, 1027, 6, 51, -1, 0, 1027, 1042, 1, 0, 0, 0, 1028, 1029, 5, 287, 0, 0, 1029, 1030, 3, 32, 16, 0, 1030, 1031, 6, 51, -1, 0, 1031, 1042, 1, 0, 0, 0, 1032, 1033, 5, 283, 0, 0, 1033, 1039, 6, 51, -1, 0, 1034, 1035, 5, 30, 0, 0, 1035, 1036, 3, 106, 53, 0, 1036, 1037, 5, 31, 0, 0, 1037, 1040, 1, 0, 0, 0, 1038, 1040, 5, 85, 0, 0, 1039, 1034, 1, 0, 0, 0, 1039, 1038, 1, 0, 0, 0, 1040, 1042, 1, 0, 0, 0, 1041, 963, 1, 0, 0, 0, 1041, 965, 1, 0, 0, 0, 1041, 969, 1, 0, 0, 0, 1041, 973, 1, 0, 0, 0, 1041, 977, 1, 0, 0, 0, 1041, 981, 1, 0, 0, 0, 1041, 985, 1, 0, 0, 0, 1041, 989, 1, 0, 0, 0, 1041, 995, 1, 0, 0, 0, 1041, 1002, 1, 0, 0, 0, 1041, 1006, 1, 0, 0, 0, 1041, 1010, 1, 0, 0, 0, 1041, 1014, 1, 0, 0, 0, 1041, 1021, 1, 0, 0, 0, 1041, 1028, 1, 0, 0, 0, 1041, 1032, 1, 0, 0, 0, 1042, 103, 1, 0, 0, 0, 1043, 1044, 3, 170, 85, 0, 1044, 1045, 3, 138, 69, 0, 1045, 1046, 3, 112, 56, 0, 1046, 105, 1, 0, 0, 0, 1047, 1072, 1, 0, 0, 0, 1048, 1049, 3, 0, 0, 0, 1049, 1050, 6, 53, -1, 0, 1050, 1055, 1, 0, 0, 0, 1051, 1052, 3, 32, 16, 0, 1052, 1053, 6, 53, -1, 0, 1053, 1055, 1, 0, 0, 0, 1054, 1048, 1, 0, 0, 0, 1054, 1051, 1, 0, 0, 0, 1055, 1056, 1, 0, 0, 0, 1056, 1057, 5, 28, 0, 0, 1057, 1059, 1, 0, 0, 0, 1058, 1054, 1, 0, 0, 0, 1059, 1062, 1, 0, 0, 0, 1060, 1058, 1, 0, 0, 0, 1060, 1061, 1, 0, 0, 0, 1061, 1069, 1, 0, 0, 0, 1062, 1060, 1, 0, 0, 0, 1063, 1064, 3, 0, 0, 0, 1064, 1065, 6, 53, -1, 0, 1065, 1070, 1, 0, 0, 0, 1066, 1067, 3, 32, 16, 0, 1067, 1068, 6, 53, -1, 0, 1068, 1070, 1, 0, 0, 0, 1069, 1063, 1, 0, 0, 0, 1069, 1066, 1, 0, 0, 0, 1070, 1072, 1, 0, 0, 0, 1071, 1047, 1, 0, 0, 0, 1071, 1060, 1, 0, 0, 0, 1072, 107, 1, 0, 0, 0, 1073, 1079, 5, 86, 0, 0, 1074, 1075, 3, 138, 69, 0, 1075, 1076, 5, 28, 0, 0, 1076, 1078, 1, 0, 0, 0, 1077, 1074, 1, 0, 0, 0, 1078, 1081, 1, 0, 0, 0, 1079, 1077, 1, 0, 0, 0, 1079, 1080, 1, 0, 0, 0, 1080, 1082, 1, 0, 0, 0, 1081, 1079, 1, 0, 0, 0, 1082, 1083, 3, 138, 69, 0, 1083, 1084, 5, 87, 0, 0, 1084, 109, 1, 0, 0, 0, 1085, 1091, 5, 42, 0, 0, 1086, 1087, 3, 146, 73, 0, 1087, 1088, 5, 28, 0, 0, 1088, 1090, 1, 0, 0, 0, 1089, 1086, 1, 0, 0, 0, 1090, 1093, 1, 0, 0, 0, 1091, 1089, 1, 0, 0, 0, 1091, 1092, 1, 0, 0, 0, 1092, 1094, 1, 0, 0, 0, 1093, 1091, 1, 0, 0, 0, 1094, 1095, 3, 146, 73, 0, 1095, 1096, 5, 43, 0, 0, 1096, 111, 1, 0, 0, 0, 1097, 1103, 5, 30, 0, 0, 1098, 1099, 3, 114, 57, 0, 1099, 1100, 5, 28, 0, 0, 1100, 1102, 1, 0, 0, 0, 1101, 1098, 1, 0, 0, 0, 1102, 1105, 1, 0, 0, 0, 1103, 1101, 1, 0, 0, 0, 1103, 1104, 1, 0, 0, 0, 1104, 1106, 1, 0, 0, 0, 1105, 1103, 1, 0, 0, 0, 1106, 1107, 3, 114, 57, 0, 1107, 1108, 5, 31, 0, 0, 1108, 1111, 1, 0, 0, 0, 1109, 1111, 5, 85, 0, 0, 1110, 1097, 1, 0, 0, 0, 1110, 1109, 1, 0, 0, 0, 1111, 113, 1, 0, 0, 0, 1112, 1120, 5, 177, 0, 0, 1113, 1114, 3, 230, 115, 0, 1114, 1115, 3, 138, 69, 0, 1115, 1117, 3, 226, 113, 0, 1116, 1118, 3, 0, 0, 0, 1117, 1116, 1, 0, 0, 0, 1117, 1118, 1, 0, 0, 0, 1118, 1120, 1, 0, 0, 0, 1119, 1112, 1, 0, 0, 0, 1119, 1113, 1, 0, 0, 0, 1120, 115, 1, 0, 0, 0, 1121, 1122, 5, 42, 0, 0, 1122, 1123, 3, 2, 1, 0, 1123, 1124, 5, 43, 0, 0, 1124, 1125, 3, 118, 59, 0, 1125, 1147, 1, 0, 0, 0, 1126, 1127, 5, 42, 0, 0, 1127, 1128, 3, 174, 87, 0, 1128, 1129, 5, 43, 0, 0, 1129, 1130, 3, 118, 59, 0, 1130, 1147, 1, 0, 0, 0, 1131, 1132, 5, 42, 0, 0, 1132, 1133, 5, 262, 0, 0, 1133, 1134, 5, 43, 0, 0, 1134, 1147, 3, 118, 59, 0, 1135, 1136, 5, 42, 0, 0, 1136, 1137, 5, 198, 0, 0, 1137, 1138, 3, 2, 1, 0, 1138, 1139, 5, 43, 0, 0, 1139, 1140, 3, 118, 59, 0, 1140, 1147, 1, 0, 0, 0, 1141, 1147, 3, 118, 59, 0, 1142, 1147, 3, 174, 87, 0, 1143, 1147, 5, 257, 0, 0, 1144, 1147, 5, 258, 0, 0, 1145, 1147, 5, 259, 0, 0, 1146, 1121, 1, 0, 0, 0, 1146, 1126, 1, 0, 0, 0, 1146, 1131, 1, 0, 0, 0, 1146, 1135, 1, 0, 0, 0, 1146, 1141, 1, 0, 0, 0, 1146, 1142, 1, 0, 0, 0, 1146, 1143, 1, 0, 0, 0, 1146, 1144, 1, 0, 0, 0, 1146, 1145, 1, 0, 0, 0, 1147, 117, 1, 0, 0, 0, 1148, 1149, 3, 2, 1, 0, 1149, 1150, 5, 88, 0, 0, 1150, 1152, 1, 0, 0, 0, 1151, 1148, 1, 0, 0, 0, 1152, 1155, 1, 0, 0, 0, 1153, 1151, 1, 0, 0, 0, 1153, 1154, 1, 0, 0, 0, 1154, 1156, 1, 0, 0, 0, 1155, 1153, 1, 0, 0, 0, 1156, 1157, 3, 2, 1, 0, 1157, 119, 1, 0, 0, 0, 1158, 1160, 3, 122, 61, 0, 1159, 1158, 1, 0, 0, 0, 1160, 1163, 1, 0, 0, 0, 1161, 1159, 1, 0, 0, 0, 1161, 1162, 1, 0, 0, 0, 1162, 121, 1, 0, 0, 0, 1163, 1161, 1, 0, 0, 0, 1164, 1165, 5, 180, 0, 0, 1165, 1166, 5, 89, 0, 0, 1166, 1170, 3, 32, 16, 0, 1167, 1170, 3, 152, 76, 0, 1168, 1170, 3, 324, 162, 0, 1169, 1164, 1, 0, 0, 0, 1169, 1167, 1, 0, 0, 0, 1169, 1168, 1, 0, 0, 0, 1170, 123, 1, 0, 0, 0, 1171, 1183, 3, 116, 58, 0, 1172, 1173, 5, 42, 0, 0, 1173, 1174, 3, 2, 1, 0, 1174, 1175, 5, 43, 0, 0, 1175, 1183, 1, 0, 0, 0, 1176, 1177, 5, 42, 0, 0, 1177, 1178, 5, 198, 0, 0, 1178, 1179, 3, 2, 1, 0, 1179, 1180, 5, 43, 0, 0, 1180, 1183, 1, 0, 0, 0, 1181, 1183, 3, 138, 69, 0, 1182, 1171, 1, 0, 0, 0, 1182, 1172, 1, 0, 0, 0, 1182, 1176, 1, 0, 0, 0, 1182, 1181, 1, 0, 0, 0, 1183, 125, 1, 0, 0, 0, 1184, 1193, 1, 0, 0, 0, 1185, 1189, 3, 130, 65, 0, 1186, 1188, 3, 128, 64, 0, 1187, 1186, 1, 0, 0, 0, 1188, 1191, 1, 0, 0, 0, 1189, 1187, 1, 0, 0, 0, 1189, 1190, 1, 0, 0, 0, 1190, 1193, 1, 0, 0, 0, 1191, 1189, 1, 0, 0, 0, 1192, 1184, 1, 0, 0, 0, 1192, 1185, 1, 0, 0, 0, 1193, 127, 1, 0, 0, 0, 1194, 1212, 5, 262, 0, 0, 1195, 1212, 5, 261, 0, 0, 1196, 1197, 5, 42, 0, 0, 1197, 1198, 3, 32, 16, 0, 1198, 1199, 5, 43, 0, 0, 1199, 1212, 1, 0, 0, 0, 1200, 1201, 5, 42, 0, 0, 1201, 1202, 3, 32, 16, 0, 1202, 1203, 5, 266, 0, 0, 1203, 1204, 3, 32, 16, 0, 1204, 1205, 5, 43, 0, 0, 1205, 1212, 1, 0, 0, 0, 1206, 1207, 5, 42, 0, 0, 1207, 1208, 5, 266, 0, 0, 1208, 1209, 3, 32, 16, 0, 1209, 1210, 5, 43, 0, 0, 1210, 1212, 1, 0, 0, 0, 1211, 1194, 1, 0, 0, 0, 1211, 1195, 1, 0, 0, 0, 1211, 1196, 1, 0, 0, 0, 1211, 1200, 1, 0, 0, 0, 1211, 1206, 1, 0, 0, 0, 1212, 129, 1, 0, 0, 0, 1213, 1306, 1, 0, 0, 0, 1214, 1215, 5, 203, 0, 0, 1215, 1216, 5, 30, 0, 0, 1216, 1217, 3, 6, 3, 0, 1217, 1218, 5, 28, 0, 0, 1218, 1219, 3, 6, 3, 0, 1219, 1220, 5, 28, 0, 0, 1220, 1221, 3, 6, 3, 0, 1221, 1222, 5, 28, 0, 0, 1222, 1223, 3, 6, 3, 0, 1223, 1224, 5, 31, 0, 0, 1224, 1306, 1, 0, 0, 0, 1225, 1226, 5, 203, 0, 0, 1226, 1227, 5, 30, 0, 0, 1227, 1228, 3, 6, 3, 0, 1228, 1229, 5, 28, 0, 0, 1229, 1230, 3, 6, 3, 0, 1230, 1231, 5, 31, 0, 0, 1231, 1306, 1, 0, 0, 0, 1232, 1233, 5, 204, 0, 0, 1233, 1234, 5, 205, 0, 0, 1234, 1235, 5, 42, 0, 0, 1235, 1236, 3, 32, 16, 0, 1236, 1237, 5, 43, 0, 0, 1237, 1306, 1, 0, 0, 0, 1238, 1239, 5, 204, 0, 0, 1239, 1240, 5, 206, 0, 0, 1240, 1241, 5, 42, 0, 0, 1241, 1242, 3, 32, 16, 0, 1242, 1243, 5, 43, 0, 0, 1243, 1244, 3, 126, 63, 0, 1244, 1306, 1, 0, 0, 0, 1245, 1306, 5, 207, 0, 0, 1246, 1306, 5, 208, 0, 0, 1247, 1306, 5, 209, 0, 0, 1248, 1306, 5, 201, 0, 0, 1249, 1306, 5, 183, 0, 0, 1250, 1306, 5, 184, 0, 0, 1251, 1306, 5, 185, 0, 0, 1252, 1306, 5, 186, 0, 0, 1253, 1306, 5, 187, 0, 0, 1254, 1306, 5, 188, 0, 0, 1255, 1306, 5, 189, 0, 0, 1256, 1306, 5, 210, 0, 0, 1257, 1306, 5, 190, 0, 0, 1258, 1306, 5, 191, 0, 0, 1259, 1306, 5, 192, 0, 0, 1260, 1306, 5, 193, 0, 0, 1261, 1306, 5, 211, 0, 0, 1262, 1306, 5, 212, 0, 0, 1263, 1306, 5, 213, 0, 0, 1264, 1306, 5, 214, 0, 0, 1265, 1306, 5, 215, 0, 0, 1266, 1306, 5, 216, 0, 0, 1267, 1306, 5, 217, 0, 0, 1268, 1269, 5, 218, 0, 0, 1269, 1306, 3, 132, 66, 0, 1270, 1271, 5, 219, 0, 0, 1271, 1306, 3, 132, 66, 0, 1272, 1306, 5, 220, 0, 0, 1273, 1274, 5, 221, 0, 0, 1274, 1306, 3, 132, 66, 0, 1275, 1276, 5, 222, 0, 0, 1276, 1306, 3, 134, 67, 0, 1277, 1278, 5, 222, 0, 0, 1278, 1279, 3, 134, 67, 0, 1279, 1280, 5, 28, 0, 0, 1280, 1281, 3, 6, 3, 0, 1281, 1306, 1, 0, 0, 0, 1282, 1306, 5, 194, 0, 0, 1283, 1306, 5, 195, 0, 0, 1284, 1285, 5, 90, 0, 0, 1285, 1306, 5, 184, 0, 0, 1286, 1287, 5, 90, 0, 0, 1287, 1306, 5, 185, 0, 0, 1288, 1289, 5, 90, 0, 0, 1289, 1306, 5, 186, 0, 0, 1290, 1291, 5, 90, 0, 0, 1291, 1306, 5, 187, 0, 0, 1292, 1293, 5, 62, 0, 0, 1293, 1306, 5, 220, 0, 0, 1294, 1306, 5, 223, 0, 0, 1295, 1296, 5, 224, 0, 0, 1296, 1306, 5, 213, 0, 0, 1297, 1306, 5, 225, 0, 0, 1298, 1299, 5, 207, 0, 0, 1299, 1306, 5, 183, 0, 0, 1300, 1306, 5, 226, 0, 0, 1301, 1306, 5, 228, 0, 0, 1302, 1303, 5, 34, 0, 0, 1303, 1306, 5, 227, 0, 0, 1304, 1306, 3, 2, 1, 0, 1305, 1213, 1, 0, 0, 0, 1305, 1214, 1, 0, 0, 0, 1305, 1225, 1, 0, 0, 0, 1305, 1232, 1, 0, 0, 0, 1305, 1238, 1, 0, 0, 0, 1305, 1245, 1, 0, 0, 0, 1305, 1246, 1, 0, 0, 0, 1305, 1247, 1, 0, 0, 0, 1305, 1248, 1, 0, 0, 0, 1305, 1249, 1, 0, 0, 0, 1305, 1250, 1, 0, 0, 0, 1305, 1251, 1, 0, 0, 0, 1305, 1252, 1, 0, 0, 0, 1305, 1253, 1, 0, 0, 0, 1305, 1254, 1, 0, 0, 0, 1305, 1255, 1, 0, 0, 0, 1305, 1256, 1, 0, 0, 0, 1305, 1257, 1, 0, 0, 0, 1305, 1258, 1, 0, 0, 0, 1305, 1259, 1, 0, 0, 0, 1305, 1260, 1, 0, 0, 0, 1305, 1261, 1, 0, 0, 0, 1305, 1262, 1, 0, 0, 0, 1305, 1263, 1, 0, 0, 0, 1305, 1264, 1, 0, 0, 0, 1305, 1265, 1, 0, 0, 0, 1305, 1266, 1, 0, 0, 0, 1305, 1267, 1, 0, 0, 0, 1305, 1268, 1, 0, 0, 0, 1305, 1270, 1, 0, 0, 0, 1305, 1272, 1, 0, 0, 0, 1305, 1273, 1, 0, 0, 0, 1305, 1275, 1, 0, 0, 0, 1305, 1277, 1, 0, 0, 0, 1305, 1282, 1, 0, 0, 0, 1305, 1283, 1, 0, 0, 0, 1305, 1284, 1, 0, 0, 0, 1305, 1286, 1, 0, 0, 0, 1305, 1288, 1, 0, 0, 0, 1305, 1290, 1, 0, 0, 0, 1305, 1292, 1, 0, 0, 0, 1305, 1294, 1, 0, 0, 0, 1305, 1295, 1, 0, 0, 0, 1305, 1297, 1, 0, 0, 0, 1305, 1298, 1, 0, 0, 0, 1305, 1300, 1, 0, 0, 0, 1305, 1301, 1, 0, 0, 0, 1305, 1302, 1, 0, 0, 0, 1305, 1304, 1, 0, 0, 0, 1306, 131, 1, 0, 0, 0, 1307, 1315, 1, 0, 0, 0, 1308, 1309, 5, 30, 0, 0, 1309, 1310, 5, 91, 0, 0, 1310, 1311, 5, 36, 0, 0, 1311, 1312, 3, 32, 16, 0, 1312, 1313, 5, 31, 0, 0, 1313, 1315, 1, 0, 0, 0, 1314, 1307, 1, 0, 0, 0, 1314, 1308, 1, 0, 0, 0, 1315, 133, 1, 0, 0, 0, 1316, 1325, 1, 0, 0, 0, 1317, 1321, 3, 136, 68, 0, 1318, 1320, 7, 7, 0, 0, 1319, 1318, 1, 0, 0, 0, 1320, 1323, 1, 0, 0, 0, 1321, 1319, 1, 0, 0, 0, 1321, 1322, 1, 0, 0, 0, 1322, 1325, 1, 0, 0, 0, 1323, 1321, 1, 0, 0, 0, 1324, 1316, 1, 0, 0, 0, 1324, 1317, 1, 0, 0, 0, 1325, 135, 1, 0, 0, 0, 1326, 1327, 7, 8, 0, 0, 1327, 137, 1, 0, 0, 0, 1328, 1332, 3, 142, 71, 0, 1329, 1331, 3, 140, 70, 0, 1330, 1329, 1, 0, 0, 0, 1331, 1334, 1, 0, 0, 0, 1332, 1330, 1, 0, 0, 0, 1332, 1333, 1, 0, 0, 0, 1333, 139, 1, 0, 0, 0, 1334, 1332, 1, 0, 0, 0, 1335, 1354, 5, 261, 0, 0, 1336, 1337, 5, 42, 0, 0, 1337, 1354, 5, 43, 0, 0, 1338, 1354, 3, 110, 55, 0, 1339, 1354, 5, 260, 0, 0, 1340, 1354, 5, 262, 0, 0, 1341, 1354, 5, 92, 0, 0, 1342, 1343, 5, 93, 0, 0, 1343, 1344, 5, 30, 0, 0, 1344, 1345, 3, 124, 62, 0, 1345, 1346, 5, 31, 0, 0, 1346, 1354, 1, 0, 0, 0, 1347, 1348, 5, 94, 0, 0, 1348, 1349, 5, 30, 0, 0, 1349, 1350, 3, 124, 62, 0, 1350, 1351, 5, 31, 0, 0, 1351, 1354, 1, 0, 0, 0, 1352, 1354, 3, 108, 54, 0, 1353, 1335, 1, 0, 0, 0, 1353, 1336, 1, 0, 0, 0, 1353, 1338, 1, 0, 0, 0, 1353, 1339, 1, 0, 0, 0, 1353, 1340, 1, 0, 0, 0, 1353, 1341, 1, 0, 0, 0, 1353, 1342, 1, 0, 0, 0, 1353, 1347, 1, 0, 0, 0, 1353, 1352, 1, 0, 0, 0, 1354, 141, 1, 0, 0, 0, 1355, 1356, 5, 39, 0, 0, 1356, 1386, 3, 116, 58, 0, 1357, 1386, 5, 197, 0, 0, 1358, 1359, 5, 199, 0, 0, 1359, 1360, 5, 39, 0, 0, 1360, 1386, 3, 116, 58, 0, 1361, 1362, 5, 200, 0, 0, 1362, 1386, 3, 116, 58, 0, 1363, 1364, 5, 226, 0, 0, 1364, 1365, 3, 170, 85, 0, 1365, 1366, 3, 138, 69, 0, 1366, 1367, 5, 262, 0, 0, 1367, 1368, 3, 112, 56, 0, 1368, 1386, 1, 0, 0, 0, 1369, 1370, 5, 253, 0, 0, 1370, 1386, 3, 32, 16, 0, 1371, 1372, 5, 252, 0, 0, 1372, 1386, 3, 32, 16, 0, 1373, 1374, 5, 253, 0, 0, 1374, 1386, 3, 2, 1, 0, 1375, 1376, 5, 252, 0, 0, 1376, 1386, 3, 2, 1, 0, 1377, 1386, 5, 254, 0, 0, 1378, 1386, 5, 201, 0, 0, 1379, 1386, 3, 148, 74, 0, 1380, 1386, 3, 150, 75, 0, 1381, 1386, 3, 144, 72, 0, 1382, 1386, 3, 2, 1, 0, 1383, 1384, 5, 177, 0, 0, 1384, 1386, 3, 138, 69, 0, 1385, 1355, 1, 0, 0, 0, 1385, 1357, 1, 0, 0, 0, 1385, 1358, 1, 0, 0, 0, 1385, 1361, 1, 0, 0, 0, 1385, 1363, 1, 0, 0, 0, 1385, 1369, 1, 0, 0, 0, 1385, 1371, 1, 0, 0, 0, 1385, 1373, 1, 0, 0, 0, 1385, 1375, 1, 0, 0, 0, 1385, 1377, 1, 0, 0, 0, 1385, 1378, 1, 0, 0, 0, 1385, 1379, 1, 0, 0, 0, 1385, 1380, 1, 0, 0, 0, 1385, 1381, 1, 0, 0, 0, 1385, 1382, 1, 0, 0, 0, 1385, 1383, 1, 0, 0, 0, 1386, 143, 1, 0, 0, 0, 1387, 1409, 5, 181, 0, 0, 1388, 1409, 5, 182, 0, 0, 1389, 1409, 5, 183, 0, 0, 1390, 1409, 5, 184, 0, 0, 1391, 1409, 5, 185, 0, 0, 1392, 1409, 5, 186, 0, 0, 1393, 1409, 5, 187, 0, 0, 1394, 1409, 5, 188, 0, 0, 1395, 1409, 5, 189, 0, 0, 1396, 1409, 5, 190, 0, 0, 1397, 1409, 5, 191, 0, 0, 1398, 1409, 5, 192, 0, 0, 1399, 1409, 5, 193, 0, 0, 1400, 1401, 5, 90, 0, 0, 1401, 1409, 5, 184, 0, 0, 1402, 1403, 5, 90, 0, 0, 1403, 1409, 5, 185, 0, 0, 1404, 1405, 5, 90, 0, 0, 1405, 1409, 5, 186, 0, 0, 1406, 1407, 5, 90, 0, 0, 1407, 1409, 5, 187, 0, 0, 1408, 1387, 1, 0, 0, 0, 1408, 1388, 1, 0, 0, 0, 1408, 1389, 1, 0, 0, 0, 1408, 1390, 1, 0, 0, 0, 1408, 1391, 1, 0, 0, 0, 1408, 1392, 1, 0, 0, 0, 1408, 1393, 1, 0, 0, 0, 1408, 1394, 1, 0, 0, 0, 1408, 1395, 1, 0, 0, 0, 1408, 1396, 1, 0, 0, 0, 1408, 1397, 1, 0, 0, 0, 1408, 1398, 1, 0, 0, 0, 1408, 1399, 1, 0, 0, 0, 1408, 1400, 1, 0, 0, 0, 1408, 1402, 1, 0, 0, 0, 1408, 1404, 1, 0, 0, 0, 1408, 1406, 1, 0, 0, 0, 1409, 145, 1, 0, 0, 0, 1410, 1421, 1, 0, 0, 0, 1411, 1421, 5, 177, 0, 0, 1412, 1421, 3, 32, 16, 0, 1413, 1414, 3, 32, 16, 0, 1414, 1415, 5, 177, 0, 0, 1415, 1416, 3, 32, 16, 0, 1416, 1421, 1, 0, 0, 0, 1417, 1418, 3, 32, 16, 0, 1418, 1419, 5, 177, 0, 0, 1419, 1421, 1, 0, 0, 0, 1420, 1410, 1, 0, 0, 0, 1420, 1411, 1, 0, 0, 0, 1420, 1412, 1, 0, 0, 0, 1420, 1413, 1, 0, 0, 0, 1420, 1417, 1, 0, 0, 0, 1421, 147, 1, 0, 0, 0, 1422, 1423, 5, 1, 0, 0, 1423, 1424, 5, 194, 0, 0, 1424, 149, 1, 0, 0, 0, 1425, 1429, 5, 1, 0, 0, 1426, 1427, 5, 90, 0, 0, 1427, 1430, 5, 194, 0, 0, 1428, 1430, 5, 195, 0, 0, 1429, 1426, 1, 0, 0, 0, 1429, 1428, 1, 0, 0, 0, 1430, 151, 1, 0, 0, 0, 1431, 1432, 5, 294, 0, 0, 1432, 1433, 3, 166, 83, 0, 1433, 1434, 3, 124, 62, 0, 1434, 1435, 5, 30, 0, 0, 1435, 1436, 3, 158, 79, 0, 1436, 1437, 5, 31, 0, 0, 1437, 1479, 1, 0, 0, 0, 1438, 1439, 5, 294, 0, 0, 1439, 1440, 3, 166, 83, 0, 1440, 1441, 3, 124, 62, 0, 1441, 1442, 5, 36, 0, 0, 1442, 1443, 5, 17, 0, 0, 1443, 1444, 3, 52, 26, 0, 1444, 1445, 5, 18, 0, 0, 1445, 1479, 1, 0, 0, 0, 1446, 1447, 5, 294, 0, 0, 1447, 1448, 3, 166, 83, 0, 1448, 1449, 3, 124, 62, 0, 1449, 1479, 1, 0, 0, 0, 1450, 1451, 5, 295, 0, 0, 1451, 1452, 3, 166, 83, 0, 1452, 1454, 5, 36, 0, 0, 1453, 1455, 5, 84, 0, 0, 1454, 1453, 1, 0, 0, 0, 1454, 1455, 1, 0, 0, 0, 1455, 1456, 1, 0, 0, 0, 1456, 1457, 5, 30, 0, 0, 1457, 1458, 3, 292, 146, 0, 1458, 1459, 5, 31, 0, 0, 1459, 1479, 1, 0, 0, 0, 1460, 1461, 5, 295, 0, 0, 1461, 1462, 3, 166, 83, 0, 1462, 1463, 5, 84, 0, 0, 1463, 1464, 5, 30, 0, 0, 1464, 1465, 3, 292, 146, 0, 1465, 1466, 5, 31, 0, 0, 1466, 1479, 1, 0, 0, 0, 1467, 1468, 5, 295, 0, 0, 1468, 1469, 3, 166, 83, 0, 1469, 1470, 3, 6, 3, 0, 1470, 1479, 1, 0, 0, 0, 1471, 1472, 5, 295, 0, 0, 1472, 1473, 3, 166, 83, 0, 1473, 1474, 5, 36, 0, 0, 1474, 1475, 5, 17, 0, 0, 1475, 1476, 3, 154, 77, 0, 1476, 1477, 5, 18, 0, 0, 1477, 1479, 1, 0, 0, 0, 1478, 1431, 1, 0, 0, 0, 1478, 1438, 1, 0, 0, 0, 1478, 1446, 1, 0, 0, 0, 1478, 1450, 1, 0, 0, 0, 1478, 1460, 1, 0, 0, 0, 1478, 1467, 1, 0, 0, 0, 1478, 1471, 1, 0, 0, 0, 1479, 153, 1, 0, 0, 0, 1480, 1491, 1, 0, 0, 0, 1481, 1482, 3, 156, 78, 0, 1482, 1483, 5, 28, 0, 0, 1483, 1485, 1, 0, 0, 0, 1484, 1481, 1, 0, 0, 0, 1485, 1488, 1, 0, 0, 0, 1486, 1484, 1, 0, 0, 0, 1486, 1487, 1, 0, 0, 0, 1487, 1489, 1, 0, 0, 0, 1488, 1486, 1, 0, 0, 0, 1489, 1491, 3, 156, 78, 0, 1490, 1480, 1, 0, 0, 0, 1490, 1486, 1, 0, 0, 0, 1491, 155, 1, 0, 0, 0, 1492, 1493, 5, 39, 0, 0, 1493, 1494, 5, 264, 0, 0, 1494, 1495, 5, 36, 0, 0, 1495, 1496, 5, 17, 0, 0, 1496, 1497, 3, 56, 28, 0, 1497, 1498, 5, 18, 0, 0, 1498, 1506, 1, 0, 0, 0, 1499, 1500, 3, 124, 62, 0, 1500, 1501, 5, 36, 0, 0, 1501, 1502, 5, 17, 0, 0, 1502, 1503, 3, 56, 28, 0, 1503, 1504, 5, 18, 0, 0, 1504, 1506, 1, 0, 0, 0, 1505, 1492, 1, 0, 0, 0, 1505, 1499, 1, 0, 0, 0, 1506, 157, 1, 0, 0, 0, 1507, 1508, 3, 160, 80, 0, 1508, 1509, 5, 28, 0, 0, 1509, 1511, 1, 0, 0, 0, 1510, 1507, 1, 0, 0, 0, 1511, 1514, 1, 0, 0, 0, 1512, 1510, 1, 0, 0, 0, 1512, 1513, 1, 0, 0, 0, 1513, 1515, 1, 0, 0, 0, 1514, 1512, 1, 0, 0, 0, 1515, 1516, 3, 160, 80, 0, 1516, 159, 1, 0, 0, 0, 1517, 1518, 3, 6, 3, 0, 1518, 1519, 5, 36, 0, 0, 1519, 1520, 3, 164, 82, 0, 1520, 161, 1, 0, 0, 0, 1521, 1522, 7, 9, 0, 0, 1522, 163, 1, 0, 0, 0, 1523, 1558, 3, 162, 81, 0, 1524, 1558, 3, 32, 16, 0, 1525, 1526, 5, 186, 0, 0, 1526, 1527, 5, 30, 0, 0, 1527, 1528, 3, 32, 16, 0, 1528, 1529, 5, 31, 0, 0, 1529, 1558, 1, 0, 0, 0, 1530, 1558, 3, 6, 3, 0, 1531, 1532, 3, 116, 58, 0, 1532, 1533, 5, 30, 0, 0, 1533, 1534, 5, 184, 0, 0, 1534, 1535, 5, 75, 0, 0, 1535, 1536, 3, 32, 16, 0, 1536, 1537, 5, 31, 0, 0, 1537, 1558, 1, 0, 0, 0, 1538, 1539, 3, 116, 58, 0, 1539, 1540, 5, 30, 0, 0, 1540, 1541, 5, 185, 0, 0, 1541, 1542, 5, 75, 0, 0, 1542, 1543, 3, 32, 16, 0, 1543, 1544, 5, 31, 0, 0, 1544, 1558, 1, 0, 0, 0, 1545, 1546, 3, 116, 58, 0, 1546, 1547, 5, 30, 0, 0, 1547, 1548, 5, 186, 0, 0, 1548, 1549, 5, 75, 0, 0, 1549, 1550, 3, 32, 16, 0, 1550, 1551, 5, 31, 0, 0, 1551, 1558, 1, 0, 0, 0, 1552, 1553, 3, 116, 58, 0, 1553, 1554, 5, 30, 0, 0, 1554, 1555, 3, 32, 16, 0, 1555, 1556, 5, 31, 0, 0, 1556, 1558, 1, 0, 0, 0, 1557, 1523, 1, 0, 0, 0, 1557, 1524, 1, 0, 0, 0, 1557, 1525, 1, 0, 0, 0, 1557, 1530, 1, 0, 0, 0, 1557, 1531, 1, 0, 0, 0, 1557, 1538, 1, 0, 0, 0, 1557, 1545, 1, 0, 0, 0, 1557, 1552, 1, 0, 0, 0, 1558, 165, 1, 0, 0, 0, 1559, 1560, 7, 10, 0, 0, 1560, 167, 1, 0, 0, 0, 1561, 1562, 3, 170, 85, 0, 1562, 1563, 3, 138, 69, 0, 1563, 1564, 3, 124, 62, 0, 1564, 1565, 5, 176, 0, 0, 1565, 1567, 3, 242, 121, 0, 1566, 1568, 3, 108, 54, 0, 1567, 1566, 1, 0, 0, 0, 1567, 1568, 1, 0, 0, 0, 1568, 1569, 1, 0, 0, 0, 1569, 1570, 3, 112, 56, 0, 1570, 1596, 1, 0, 0, 0, 1571, 1572, 3, 170, 85, 0, 1572, 1573, 3, 138, 69, 0, 1573, 1574, 3, 124, 62, 0, 1574, 1575, 5, 176, 0, 0, 1575, 1576, 3, 242, 121, 0, 1576, 1577, 3, 196, 98, 0, 1577, 1578, 3, 112, 56, 0, 1578, 1596, 1, 0, 0, 0, 1579, 1580, 3, 170, 85, 0, 1580, 1581, 3, 138, 69, 0, 1581, 1583, 3, 242, 121, 0, 1582, 1584, 3, 108, 54, 0, 1583, 1582, 1, 0, 0, 0, 1583, 1584, 1, 0, 0, 0, 1584, 1585, 1, 0, 0, 0, 1585, 1586, 3, 112, 56, 0, 1586, 1596, 1, 0, 0, 0, 1587, 1588, 3, 170, 85, 0, 1588, 1589, 3, 138, 69, 0, 1589, 1590, 3, 242, 121, 0, 1590, 1591, 3, 196, 98, 0, 1591, 1592, 3, 112, 56, 0, 1592, 1596, 1, 0, 0, 0, 1593, 1596, 3, 174, 87, 0, 1594, 1596, 3, 2, 1, 0, 1595, 1561, 1, 0, 0, 0, 1595, 1571, 1, 0, 0, 0, 1595, 1579, 1, 0, 0, 0, 1595, 1587, 1, 0, 0, 0, 1595, 1593, 1, 0, 0, 0, 1595, 1594, 1, 0, 0, 0, 1596, 169, 1, 0, 0, 0, 1597, 1598, 5, 243, 0, 0, 1598, 1608, 3, 170, 85, 0, 1599, 1600, 5, 244, 0, 0, 1600, 1608, 3, 170, 85, 0, 1601, 1608, 3, 172, 86, 0, 1602, 1603, 5, 112, 0, 0, 1603, 1604, 5, 30, 0, 0, 1604, 1605, 3, 32, 16, 0, 1605, 1606, 5, 31, 0, 0, 1606, 1608, 1, 0, 0, 0, 1607, 1597, 1, 0, 0, 0, 1607, 1599, 1, 0, 0, 0, 1607, 1601, 1, 0, 0, 0, 1607, 1602, 1, 0, 0, 0, 1608, 171, 1, 0, 0, 0, 1609, 1622, 1, 0, 0, 0, 1610, 1622, 5, 245, 0, 0, 1611, 1622, 5, 246, 0, 0, 1612, 1613, 5, 247, 0, 0, 1613, 1622, 5, 248, 0, 0, 1614, 1615, 5, 247, 0, 0, 1615, 1622, 5, 249, 0, 0, 1616, 1617, 5, 247, 0, 0, 1617, 1622, 5, 250, 0, 0, 1618, 1619, 5, 247, 0, 0, 1619, 1622, 5, 251, 0, 0, 1620, 1622, 5, 247, 0, 0, 1621, 1609, 1, 0, 0, 0, 1621, 1610, 1, 0, 0, 0, 1621, 1611, 1, 0, 0, 0, 1621, 1612, 1, 0, 0, 0, 1621, 1614, 1, 0, 0, 0, 1621, 1616, 1, 0, 0, 0, 1621, 1618, 1, 0, 0, 0, 1621, 1620, 1, 0, 0, 0, 1622, 173, 1, 0, 0, 0, 1623, 1624, 5, 113, 0, 0, 1624, 1625, 5, 30, 0, 0, 1625, 1626, 3, 32, 16, 0, 1626, 1627, 5, 31, 0, 0, 1627, 175, 1, 0, 0, 0, 1628, 1629, 5, 226, 0, 0, 1629, 1634, 3, 168, 84, 0, 1630, 1631, 5, 37, 0, 0, 1631, 1634, 3, 178, 89, 0, 1632, 1634, 3, 174, 87, 0, 1633, 1628, 1, 0, 0, 0, 1633, 1630, 1, 0, 0, 0, 1633, 1632, 1, 0, 0, 0, 1634, 177, 1, 0, 0, 0, 1635, 1636, 3, 138, 69, 0, 1636, 1637, 3, 124, 62, 0, 1637, 1638, 5, 176, 0, 0, 1638, 1639, 3, 2, 1, 0, 1639, 1645, 1, 0, 0, 0, 1640, 1641, 3, 138, 69, 0, 1641, 1642, 3, 2, 1, 0, 1642, 1645, 1, 0, 0, 0, 1643, 1645, 3, 2, 1, 0, 1644, 1635, 1, 0, 0, 0, 1644, 1640, 1, 0, 0, 0, 1644, 1643, 1, 0, 0, 0, 1645, 179, 1, 0, 0, 0, 1646, 1647, 3, 124, 62, 0, 1647, 1648, 5, 28, 0, 0, 1648, 1650, 1, 0, 0, 0, 1649, 1646, 1, 0, 0, 0, 1650, 1653, 1, 0, 0, 0, 1651, 1649, 1, 0, 0, 0, 1651, 1652, 1, 0, 0, 0, 1652, 1654, 1, 0, 0, 0, 1653, 1651, 1, 0, 0, 0, 1654, 1655, 3, 124, 62, 0, 1655, 181, 1, 0, 0, 0, 1656, 1662, 1, 0, 0, 0, 1657, 1658, 5, 86, 0, 0, 1658, 1659, 3, 190, 95, 0, 1659, 1660, 5, 87, 0, 0, 1660, 1662, 1, 0, 0, 0, 1661, 1656, 1, 0, 0, 0, 1661, 1657, 1, 0, 0, 0, 1662, 183, 1, 0, 0, 0, 1663, 1675, 5, 266, 0, 0, 1664, 1675, 5, 114, 0, 0, 1665, 1675, 5, 39, 0, 0, 1666, 1675, 5, 200, 0, 0, 1667, 1675, 5, 115, 0, 0, 1668, 1675, 5, 116, 0, 0, 1669, 1670, 5, 70, 0, 0, 1670, 1671, 5, 30, 0, 0, 1671, 1672, 3, 32, 16, 0, 1672, 1673, 5, 31, 0, 0, 1673, 1675, 1, 0, 0, 0, 1674, 1663, 1, 0, 0, 0, 1674, 1664, 1, 0, 0, 0, 1674, 1665, 1, 0, 0, 0, 1674, 1666, 1, 0, 0, 0, 1674, 1667, 1, 0, 0, 0, 1674, 1668, 1, 0, 0, 0, 1674, 1669, 1, 0, 0, 0, 1675, 185, 1, 0, 0, 0, 1676, 1678, 3, 184, 92, 0, 1677, 1676, 1, 0, 0, 0, 1678, 1681, 1, 0, 0, 0, 1679, 1677, 1, 0, 0, 0, 1679, 1680, 1, 0, 0, 0, 1680, 187, 1, 0, 0, 0, 1681, 1679, 1, 0, 0, 0, 1682, 1684, 3, 186, 93, 0, 1683, 1685, 3, 192, 96, 0, 1684, 1683, 1, 0, 0, 0, 1684, 1685, 1, 0, 0, 0, 1685, 1686, 1, 0, 0, 0, 1686, 1687, 3, 2, 1, 0, 1687, 189, 1, 0, 0, 0, 1688, 1689, 3, 188, 94, 0, 1689, 1690, 5, 28, 0, 0, 1690, 1692, 1, 0, 0, 0, 1691, 1688, 1, 0, 0, 0, 1692, 1695, 1, 0, 0, 0, 1693, 1691, 1, 0, 0, 0, 1693, 1694, 1, 0, 0, 0, 1694, 1696, 1, 0, 0, 0, 1695, 1693, 1, 0, 0, 0, 1696, 1697, 3, 188, 94, 0, 1697, 191, 1, 0, 0, 0, 1698, 1699, 5, 30, 0, 0, 1699, 1700, 3, 180, 90, 0, 1700, 1701, 5, 31, 0, 0, 1701, 193, 1, 0, 0, 0, 1702, 1705, 1, 0, 0, 0, 1703, 1705, 3, 196, 98, 0, 1704, 1702, 1, 0, 0, 0, 1704, 1703, 1, 0, 0, 0, 1705, 195, 1, 0, 0, 0, 1706, 1707, 5, 86, 0, 0, 1707, 1708, 5, 42, 0, 0, 1708, 1709, 3, 32, 16, 0, 1709, 1710, 5, 43, 0, 0, 1710, 1711, 5, 87, 0, 0, 1711, 197, 1, 0, 0, 0, 1712, 1713, 3, 234, 117, 0, 1713, 1714, 5, 17, 0, 0, 1714, 1715, 3, 246, 123, 0, 1715, 1716, 5, 18, 0, 0, 1716, 1829, 1, 0, 0, 0, 1717, 1718, 3, 74, 37, 0, 1718, 1719, 5, 17, 0, 0, 1719, 1720, 3, 82, 41, 0, 1720, 1721, 5, 18, 0, 0, 1721, 1829, 1, 0, 0, 0, 1722, 1723, 3, 210, 105, 0, 1723, 1724, 5, 17, 0, 0, 1724, 1725, 3, 214, 107, 0, 1725, 1726, 5, 18, 0, 0, 1726, 1829, 1, 0, 0, 0, 1727, 1728, 3, 218, 109, 0, 1728, 1729, 5, 17, 0, 0, 1729, 1730, 3, 222, 111, 0, 1730, 1731, 5, 18, 0, 0, 1731, 1829, 1, 0, 0, 0, 1732, 1829, 3, 200, 100, 0, 1733, 1829, 3, 276, 138, 0, 1734, 1829, 3, 152, 76, 0, 1735, 1829, 3, 88, 44, 0, 1736, 1829, 3, 322, 161, 0, 1737, 1738, 5, 117, 0, 0, 1738, 1829, 3, 32, 16, 0, 1739, 1740, 5, 118, 0, 0, 1740, 1829, 3, 32, 16, 0, 1741, 1742, 3, 334, 167, 0, 1742, 1743, 5, 17, 0, 0, 1743, 1744, 3, 338, 169, 0, 1744, 1745, 5, 18, 0, 0, 1745, 1829, 1, 0, 0, 0, 1746, 1747, 5, 302, 0, 0, 1747, 1748, 3, 124, 62, 0, 1748, 1749, 5, 176, 0, 0, 1749, 1750, 3, 242, 121, 0, 1750, 1751, 5, 119, 0, 0, 1751, 1752, 3, 170, 85, 0, 1752, 1753, 3, 138, 69, 0, 1753, 1754, 3, 124, 62, 0, 1754, 1755, 5, 176, 0, 0, 1755, 1756, 3, 242, 121, 0, 1756, 1757, 3, 112, 56, 0, 1757, 1829, 1, 0, 0, 0, 1758, 1759, 5, 302, 0, 0, 1759, 1760, 5, 226, 0, 0, 1760, 1761, 3, 170, 85, 0, 1761, 1762, 3, 138, 69, 0, 1762, 1763, 3, 124, 62, 0, 1763, 1764, 5, 176, 0, 0, 1764, 1765, 3, 242, 121, 0, 1765, 1766, 3, 194, 97, 0, 1766, 1767, 3, 112, 56, 0, 1767, 1768, 5, 119, 0, 0, 1768, 1769, 5, 226, 0, 0, 1769, 1770, 3, 170, 85, 0, 1770, 1771, 3, 138, 69, 0, 1771, 1772, 3, 124, 62, 0, 1772, 1773, 5, 176, 0, 0, 1773, 1774, 3, 242, 121, 0, 1774, 1775, 3, 194, 97, 0, 1775, 1776, 3, 112, 56, 0, 1776, 1829, 1, 0, 0, 0, 1777, 1829, 3, 26, 13, 0, 1778, 1829, 3, 40, 20, 0, 1779, 1780, 5, 255, 0, 0, 1780, 1781, 5, 196, 0, 0, 1781, 1782, 5, 42, 0, 0, 1782, 1783, 3, 32, 16, 0, 1783, 1787, 5, 43, 0, 0, 1784, 1786, 3, 322, 161, 0, 1785, 1784, 1, 0, 0, 0, 1786, 1789, 1, 0, 0, 0, 1787, 1785, 1, 0, 0, 0, 1787, 1788, 1, 0, 0, 0, 1788, 1829, 1, 0, 0, 0, 1789, 1787, 1, 0, 0, 0, 1790, 1791, 5, 255, 0, 0, 1791, 1792, 5, 196, 0, 0, 1792, 1796, 3, 2, 1, 0, 1793, 1795, 3, 322, 161, 0, 1794, 1793, 1, 0, 0, 0, 1795, 1798, 1, 0, 0, 0, 1796, 1794, 1, 0, 0, 0, 1796, 1797, 1, 0, 0, 0, 1797, 1829, 1, 0, 0, 0, 1798, 1796, 1, 0, 0, 0, 1799, 1800, 5, 255, 0, 0, 1800, 1801, 5, 256, 0, 0, 1801, 1802, 5, 42, 0, 0, 1802, 1803, 3, 32, 16, 0, 1803, 1804, 5, 43, 0, 0, 1804, 1805, 5, 28, 0, 0, 1805, 1809, 3, 124, 62, 0, 1806, 1808, 3, 322, 161, 0, 1807, 1806, 1, 0, 0, 0, 1808, 1811, 1, 0, 0, 0, 1809, 1807, 1, 0, 0, 0, 1809, 1810, 1, 0, 0, 0, 1810, 1829, 1, 0, 0, 0, 1811, 1809, 1, 0, 0, 0, 1812, 1813, 5, 255, 0, 0, 1813, 1814, 5, 256, 0, 0, 1814, 1815, 3, 2, 1, 0, 1815, 1816, 5, 28, 0, 0, 1816, 1820, 3, 124, 62, 0, 1817, 1819, 3, 322, 161, 0, 1818, 1817, 1, 0, 0, 0, 1819, 1822, 1, 0, 0, 0, 1820, 1818, 1, 0, 0, 0, 1820, 1821, 1, 0, 0, 0, 1821, 1829, 1, 0, 0, 0, 1822, 1820, 1, 0, 0, 0, 1823, 1824, 5, 120, 0, 0, 1824, 1825, 5, 196, 0, 0, 1825, 1826, 3, 124, 62, 0, 1826, 1827, 3, 44, 22, 0, 1827, 1829, 1, 0, 0, 0, 1828, 1712, 1, 0, 0, 0, 1828, 1717, 1, 0, 0, 0, 1828, 1722, 1, 0, 0, 0, 1828, 1727, 1, 0, 0, 0, 1828, 1732, 1, 0, 0, 0, 1828, 1733, 1, 0, 0, 0, 1828, 1734, 1, 0, 0, 0, 1828, 1735, 1, 0, 0, 0, 1828, 1736, 1, 0, 0, 0, 1828, 1737, 1, 0, 0, 0, 1828, 1739, 1, 0, 0, 0, 1828, 1741, 1, 0, 0, 0, 1828, 1746, 1, 0, 0, 0, 1828, 1758, 1, 0, 0, 0, 1828, 1777, 1, 0, 0, 0, 1828, 1778, 1, 0, 0, 0, 1828, 1779, 1, 0, 0, 0, 1828, 1790, 1, 0, 0, 0, 1828, 1799, 1, 0, 0, 0, 1828, 1812, 1, 0, 0, 0, 1828, 1823, 1, 0, 0, 0, 1829, 199, 1, 0, 0, 0, 1830, 1831, 5, 121, 0, 0, 1831, 1840, 3, 208, 104, 0, 1832, 1839, 3, 202, 101, 0, 1833, 1834, 5, 122, 0, 0, 1834, 1835, 5, 30, 0, 0, 1835, 1836, 3, 228, 114, 0, 1836, 1837, 5, 31, 0, 0, 1837, 1839, 1, 0, 0, 0, 1838, 1832, 1, 0, 0, 0, 1838, 1833, 1, 0, 0, 0, 1839, 1842, 1, 0, 0, 0, 1840, 1838, 1, 0, 0, 0, 1840, 1841, 1, 0, 0, 0, 1841, 1843, 1, 0, 0, 0, 1842, 1840, 1, 0, 0, 0, 1843, 1844, 3, 138, 69, 0, 1844, 1845, 3, 2, 1, 0, 1845, 1846, 3, 204, 102, 0, 1846, 1847, 3, 206, 103, 0, 1847, 201, 1, 0, 0, 0, 1848, 1868, 5, 123, 0, 0, 1849, 1868, 5, 51, 0, 0, 1850, 1868, 5, 52, 0, 0, 1851, 1868, 5, 63, 0, 0, 1852, 1868, 5, 124, 0, 0, 1853, 1868, 5, 69, 0, 0, 1854, 1868, 5, 68, 0, 0, 1855, 1868, 5, 64, 0, 0, 1856, 1868, 5, 65, 0, 0, 1857, 1868, 5, 66, 0, 0, 1858, 1868, 5, 125, 0, 0, 1859, 1868, 5, 126, 0, 0, 1860, 1868, 5, 127, 0, 0, 1861, 1868, 5, 16, 0, 0, 1862, 1863, 5, 70, 0, 0, 1863, 1864, 5, 30, 0, 0, 1864, 1865, 3, 32, 16, 0, 1865, 1866, 5, 31, 0, 0, 1866, 1868, 1, 0, 0, 0, 1867, 1848, 1, 0, 0, 0, 1867, 1849, 1, 0, 0, 0, 1867, 1850, 1, 0, 0, 0, 1867, 1851, 1, 0, 0, 0, 1867, 1852, 1, 0, 0, 0, 1867, 1853, 1, 0, 0, 0, 1867, 1854, 1, 0, 0, 0, 1867, 1855, 1, 0, 0, 0, 1867, 1856, 1, 0, 0, 0, 1867, 1857, 1, 0, 0, 0, 1867, 1858, 1, 0, 0, 0, 1867, 1859, 1, 0, 0, 0, 1867, 1860, 1, 0, 0, 0, 1867, 1861, 1, 0, 0, 0, 1867, 1862, 1, 0, 0, 0, 1868, 203, 1, 0, 0, 0, 1869, 1875, 1, 0, 0, 0, 1870, 1871, 5, 44, 0, 0, 1871, 1875, 3, 0, 0, 0, 1872, 1873, 5, 44, 0, 0, 1873, 1875, 3, 32, 16, 0, 1874, 1869, 1, 0, 0, 0, 1874, 1870, 1, 0, 0, 0, 1874, 1872, 1, 0, 0, 0, 1875, 205, 1, 0, 0, 0, 1876, 1880, 1, 0, 0, 0, 1877, 1878, 5, 36, 0, 0, 1878, 1880, 3, 296, 148, 0, 1879, 1876, 1, 0, 0, 0, 1879, 1877, 1, 0, 0, 0, 1880, 207, 1, 0, 0, 0, 1881, 1887, 1, 0, 0, 0, 1882, 1883, 5, 42, 0, 0, 1883, 1884, 3, 32, 16, 0, 1884, 1885, 5, 43, 0, 0, 1885, 1887, 1, 0, 0, 0, 1886, 1881, 1, 0, 0, 0, 1886, 1882, 1, 0, 0, 0, 1887, 209, 1, 0, 0, 0, 1888, 1892, 5, 128, 0, 0, 1889, 1891, 3, 212, 106, 0, 1890, 1889, 1, 0, 0, 0, 1891, 1894, 1, 0, 0, 0, 1892, 1890, 1, 0, 0, 0, 1892, 1893, 1, 0, 0, 0, 1893, 1895, 1, 0, 0, 0, 1894, 1892, 1, 0, 0, 0, 1895, 1896, 3, 124, 62, 0, 1896, 1897, 3, 2, 1, 0, 1897, 1907, 1, 0, 0, 0, 1898, 1902, 5, 128, 0, 0, 1899, 1901, 3, 212, 106, 0, 1900, 1899, 1, 0, 0, 0, 1901, 1904, 1, 0, 0, 0, 1902, 1900, 1, 0, 0, 0, 1902, 1903, 1, 0, 0, 0, 1903, 1905, 1, 0, 0, 0, 1904, 1902, 1, 0, 0, 0, 1905, 1907, 3, 2, 1, 0, 1906, 1888, 1, 0, 0, 0, 1906, 1898, 1, 0, 0, 0, 1907, 211, 1, 0, 0, 0, 1908, 1909, 7, 11, 0, 0, 1909, 213, 1, 0, 0, 0, 1910, 1912, 3, 216, 108, 0, 1911, 1910, 1, 0, 0, 0, 1912, 1915, 1, 0, 0, 0, 1913, 1911, 1, 0, 0, 0, 1913, 1914, 1, 0, 0, 0, 1914, 215, 1, 0, 0, 0, 1915, 1913, 1, 0, 0, 0, 1916, 1917, 5, 129, 0, 0, 1917, 1929, 3, 168, 84, 0, 1918, 1919, 5, 130, 0, 0, 1919, 1929, 3, 168, 84, 0, 1920, 1921, 5, 131, 0, 0, 1921, 1929, 3, 168, 84, 0, 1922, 1923, 5, 132, 0, 0, 1923, 1929, 3, 168, 84, 0, 1924, 1929, 3, 88, 44, 0, 1925, 1929, 3, 322, 161, 0, 1926, 1929, 3, 26, 13, 0, 1927, 1929, 3, 40, 20, 0, 1928, 1916, 1, 0, 0, 0, 1928, 1918, 1, 0, 0, 0, 1928, 1920, 1, 0, 0, 0, 1928, 1922, 1, 0, 0, 0, 1928, 1924, 1, 0, 0, 0, 1928, 1925, 1, 0, 0, 0, 1928, 1926, 1, 0, 0, 0, 1928, 1927, 1, 0, 0, 0, 1929, 217, 1, 0, 0, 0, 1930, 1934, 5, 133, 0, 0, 1931, 1933, 3, 220, 110, 0, 1932, 1931, 1, 0, 0, 0, 1933, 1936, 1, 0, 0, 0, 1934, 1932, 1, 0, 0, 0, 1934, 1935, 1, 0, 0, 0, 1935, 1937, 1, 0, 0, 0, 1936, 1934, 1, 0, 0, 0, 1937, 1938, 3, 170, 85, 0, 1938, 1939, 3, 138, 69, 0, 1939, 1940, 3, 2, 1, 0, 1940, 1941, 3, 112, 56, 0, 1941, 1942, 3, 206, 103, 0, 1942, 219, 1, 0, 0, 0, 1943, 1944, 7, 11, 0, 0, 1944, 221, 1, 0, 0, 0, 1945, 1947, 3, 224, 112, 0, 1946, 1945, 1, 0, 0, 0, 1947, 1950, 1, 0, 0, 0, 1948, 1946, 1, 0, 0, 0, 1948, 1949, 1, 0, 0, 0, 1949, 223, 1, 0, 0, 0, 1950, 1948, 1, 0, 0, 0, 1951, 1952, 5, 134, 0, 0, 1952, 1962, 3, 168, 84, 0, 1953, 1954, 5, 135, 0, 0, 1954, 1962, 3, 168, 84, 0, 1955, 1956, 5, 132, 0, 0, 1956, 1962, 3, 168, 84, 0, 1957, 1962, 3, 322, 161, 0, 1958, 1962, 3, 88, 44, 0, 1959, 1962, 3, 26, 13, 0, 1960, 1962, 3, 40, 20, 0, 1961, 1951, 1, 0, 0, 0, 1961, 1953, 1, 0, 0, 0, 1961, 1955, 1, 0, 0, 0, 1961, 1957, 1, 0, 0, 0, 1961, 1958, 1, 0, 0, 0, 1961, 1959, 1, 0, 0, 0, 1961, 1960, 1, 0, 0, 0, 1962, 225, 1, 0, 0, 0, 1963, 1970, 1, 0, 0, 0, 1964, 1965, 5, 122, 0, 0, 1965, 1966, 5, 30, 0, 0, 1966, 1967, 3, 228, 114, 0, 1967, 1968, 5, 31, 0, 0, 1968, 1970, 1, 0, 0, 0, 1969, 1963, 1, 0, 0, 0, 1969, 1964, 1, 0, 0, 0, 1970, 227, 1, 0, 0, 0, 1971, 1981, 3, 126, 63, 0, 1972, 1974, 5, 17, 0, 0, 1973, 1975, 3, 294, 147, 0, 1974, 1973, 1, 0, 0, 0, 1975, 1976, 1, 0, 0, 0, 1976, 1974, 1, 0, 0, 0, 1976, 1977, 1, 0, 0, 0, 1977, 1978, 1, 0, 0, 0, 1978, 1979, 5, 18, 0, 0, 1979, 1981, 1, 0, 0, 0, 1980, 1971, 1, 0, 0, 0, 1980, 1972, 1, 0, 0, 0, 1981, 229, 1, 0, 0, 0, 1982, 1984, 3, 232, 116, 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, 231, 1, 0, 0, 0, 1987, 1985, 1, 0, 0, 0, 1988, 1989, 5, 42, 0, 0, 1989, 1990, 5, 136, 0, 0, 1990, 2002, 5, 43, 0, 0, 1991, 1992, 5, 42, 0, 0, 1992, 1993, 5, 137, 0, 0, 1993, 2002, 5, 43, 0, 0, 1994, 1995, 5, 42, 0, 0, 1995, 1996, 5, 138, 0, 0, 1996, 2002, 5, 43, 0, 0, 1997, 1998, 5, 42, 0, 0, 1998, 1999, 3, 32, 16, 0, 1999, 2000, 5, 43, 0, 0, 2000, 2002, 1, 0, 0, 0, 2001, 1988, 1, 0, 0, 0, 2001, 1991, 1, 0, 0, 0, 2001, 1994, 1, 0, 0, 0, 2001, 1997, 1, 0, 0, 0, 2002, 233, 1, 0, 0, 0, 2003, 2008, 5, 139, 0, 0, 2004, 2007, 3, 236, 118, 0, 2005, 2007, 3, 238, 119, 0, 2006, 2004, 1, 0, 0, 0, 2006, 2005, 1, 0, 0, 0, 2007, 2010, 1, 0, 0, 0, 2008, 2006, 1, 0, 0, 0, 2008, 2009, 1, 0, 0, 0, 2009, 2011, 1, 0, 0, 0, 2010, 2008, 1, 0, 0, 0, 2011, 2012, 3, 170, 85, 0, 2012, 2013, 3, 230, 115, 0, 2013, 2014, 3, 138, 69, 0, 2014, 2015, 3, 226, 113, 0, 2015, 2016, 3, 242, 121, 0, 2016, 2017, 3, 182, 91, 0, 2017, 2021, 3, 112, 56, 0, 2018, 2020, 3, 244, 122, 0, 2019, 2018, 1, 0, 0, 0, 2020, 2023, 1, 0, 0, 0, 2021, 2019, 1, 0, 0, 0, 2021, 2022, 1, 0, 0, 0, 2022, 235, 1, 0, 0, 0, 2023, 2021, 1, 0, 0, 0, 2024, 2048, 5, 123, 0, 0, 2025, 2048, 5, 51, 0, 0, 2026, 2048, 5, 52, 0, 0, 2027, 2048, 5, 63, 0, 0, 2028, 2048, 5, 140, 0, 0, 2029, 2048, 5, 68, 0, 0, 2030, 2048, 5, 141, 0, 0, 2031, 2048, 5, 142, 0, 0, 2032, 2048, 5, 54, 0, 0, 2033, 2048, 5, 64, 0, 0, 2034, 2048, 5, 65, 0, 0, 2035, 2048, 5, 66, 0, 0, 2036, 2048, 5, 125, 0, 0, 2037, 2048, 5, 143, 0, 0, 2038, 2048, 5, 144, 0, 0, 2039, 2048, 5, 69, 0, 0, 2040, 2048, 5, 145, 0, 0, 2041, 2048, 5, 146, 0, 0, 2042, 2043, 5, 70, 0, 0, 2043, 2044, 5, 30, 0, 0, 2044, 2045, 3, 32, 16, 0, 2045, 2046, 5, 31, 0, 0, 2046, 2048, 1, 0, 0, 0, 2047, 2024, 1, 0, 0, 0, 2047, 2025, 1, 0, 0, 0, 2047, 2026, 1, 0, 0, 0, 2047, 2027, 1, 0, 0, 0, 2047, 2028, 1, 0, 0, 0, 2047, 2029, 1, 0, 0, 0, 2047, 2030, 1, 0, 0, 0, 2047, 2031, 1, 0, 0, 0, 2047, 2032, 1, 0, 0, 0, 2047, 2033, 1, 0, 0, 0, 2047, 2034, 1, 0, 0, 0, 2047, 2035, 1, 0, 0, 0, 2047, 2036, 1, 0, 0, 0, 2047, 2037, 1, 0, 0, 0, 2047, 2038, 1, 0, 0, 0, 2047, 2039, 1, 0, 0, 0, 2047, 2040, 1, 0, 0, 0, 2047, 2041, 1, 0, 0, 0, 2047, 2042, 1, 0, 0, 0, 2048, 237, 1, 0, 0, 0, 2049, 2050, 5, 147, 0, 0, 2050, 2056, 5, 30, 0, 0, 2051, 2054, 3, 6, 3, 0, 2052, 2053, 5, 34, 0, 0, 2053, 2055, 3, 6, 3, 0, 2054, 2052, 1, 0, 0, 0, 2054, 2055, 1, 0, 0, 0, 2055, 2057, 1, 0, 0, 0, 2056, 2051, 1, 0, 0, 0, 2056, 2057, 1, 0, 0, 0, 2057, 2061, 1, 0, 0, 0, 2058, 2060, 3, 240, 120, 0, 2059, 2058, 1, 0, 0, 0, 2060, 2063, 1, 0, 0, 0, 2061, 2059, 1, 0, 0, 0, 2061, 2062, 1, 0, 0, 0, 2062, 2064, 1, 0, 0, 0, 2063, 2061, 1, 0, 0, 0, 2064, 2068, 5, 31, 0, 0, 2065, 2066, 5, 147, 0, 0, 2066, 2068, 5, 85, 0, 0, 2067, 2049, 1, 0, 0, 0, 2067, 2065, 1, 0, 0, 0, 2068, 239, 1, 0, 0, 0, 2069, 2097, 5, 148, 0, 0, 2070, 2097, 5, 224, 0, 0, 2071, 2097, 5, 57, 0, 0, 2072, 2097, 5, 58, 0, 0, 2073, 2097, 5, 149, 0, 0, 2074, 2097, 5, 150, 0, 0, 2075, 2097, 5, 248, 0, 0, 2076, 2097, 5, 249, 0, 0, 2077, 2097, 5, 250, 0, 0, 2078, 2097, 5, 251, 0, 0, 2079, 2080, 5, 151, 0, 0, 2080, 2081, 5, 75, 0, 0, 2081, 2097, 5, 152, 0, 0, 2082, 2083, 5, 151, 0, 0, 2083, 2084, 5, 75, 0, 0, 2084, 2097, 5, 153, 0, 0, 2085, 2086, 5, 154, 0, 0, 2086, 2087, 5, 75, 0, 0, 2087, 2097, 5, 152, 0, 0, 2088, 2089, 5, 154, 0, 0, 2089, 2090, 5, 75, 0, 0, 2090, 2097, 5, 153, 0, 0, 2091, 2092, 5, 70, 0, 0, 2092, 2093, 5, 30, 0, 0, 2093, 2094, 3, 32, 16, 0, 2094, 2095, 5, 31, 0, 0, 2095, 2097, 1, 0, 0, 0, 2096, 2069, 1, 0, 0, 0, 2096, 2070, 1, 0, 0, 0, 2096, 2071, 1, 0, 0, 0, 2096, 2072, 1, 0, 0, 0, 2096, 2073, 1, 0, 0, 0, 2096, 2074, 1, 0, 0, 0, 2096, 2075, 1, 0, 0, 0, 2096, 2076, 1, 0, 0, 0, 2096, 2077, 1, 0, 0, 0, 2096, 2078, 1, 0, 0, 0, 2096, 2079, 1, 0, 0, 0, 2096, 2082, 1, 0, 0, 0, 2096, 2085, 1, 0, 0, 0, 2096, 2088, 1, 0, 0, 0, 2096, 2091, 1, 0, 0, 0, 2097, 241, 1, 0, 0, 0, 2098, 2102, 5, 116, 0, 0, 2099, 2102, 5, 155, 0, 0, 2100, 2102, 3, 2, 1, 0, 2101, 2098, 1, 0, 0, 0, 2101, 2099, 1, 0, 0, 0, 2101, 2100, 1, 0, 0, 0, 2102, 243, 1, 0, 0, 0, 2103, 2125, 5, 1, 0, 0, 2104, 2125, 5, 2, 0, 0, 2105, 2125, 5, 156, 0, 0, 2106, 2125, 5, 3, 0, 0, 2107, 2125, 5, 4, 0, 0, 2108, 2125, 5, 247, 0, 0, 2109, 2125, 5, 5, 0, 0, 2110, 2125, 5, 6, 0, 0, 2111, 2125, 5, 7, 0, 0, 2112, 2125, 5, 8, 0, 0, 2113, 2125, 5, 9, 0, 0, 2114, 2125, 5, 10, 0, 0, 2115, 2125, 5, 11, 0, 0, 2116, 2125, 5, 12, 0, 0, 2117, 2125, 5, 13, 0, 0, 2118, 2125, 5, 14, 0, 0, 2119, 2120, 5, 70, 0, 0, 2120, 2121, 5, 30, 0, 0, 2121, 2122, 3, 32, 16, 0, 2122, 2123, 5, 31, 0, 0, 2123, 2125, 1, 0, 0, 0, 2124, 2103, 1, 0, 0, 0, 2124, 2104, 1, 0, 0, 0, 2124, 2105, 1, 0, 0, 0, 2124, 2106, 1, 0, 0, 0, 2124, 2107, 1, 0, 0, 0, 2124, 2108, 1, 0, 0, 0, 2124, 2109, 1, 0, 0, 0, 2124, 2110, 1, 0, 0, 0, 2124, 2111, 1, 0, 0, 0, 2124, 2112, 1, 0, 0, 0, 2124, 2113, 1, 0, 0, 0, 2124, 2114, 1, 0, 0, 0, 2124, 2115, 1, 0, 0, 0, 2124, 2116, 1, 0, 0, 0, 2124, 2117, 1, 0, 0, 0, 2124, 2118, 1, 0, 0, 0, 2124, 2119, 1, 0, 0, 0, 2125, 245, 1, 0, 0, 0, 2126, 2128, 3, 248, 124, 0, 2127, 2126, 1, 0, 0, 0, 2128, 2131, 1, 0, 0, 0, 2129, 2127, 1, 0, 0, 0, 2129, 2130, 1, 0, 0, 0, 2130, 247, 1, 0, 0, 0, 2131, 2129, 1, 0, 0, 0, 2132, 2150, 3, 100, 50, 0, 2133, 2134, 5, 296, 0, 0, 2134, 2135, 3, 32, 16, 0, 2135, 2136, 6, 124, -1, 0, 2136, 2150, 1, 0, 0, 0, 2137, 2150, 3, 258, 129, 0, 2138, 2139, 5, 297, 0, 0, 2139, 2140, 3, 32, 16, 0, 2140, 2141, 6, 124, -1, 0, 2141, 2150, 1, 0, 0, 0, 2142, 2143, 5, 298, 0, 0, 2143, 2150, 6, 124, -1, 0, 2144, 2145, 5, 299, 0, 0, 2145, 2150, 6, 124, -1, 0, 2146, 2150, 3, 252, 126, 0, 2147, 2150, 3, 256, 128, 0, 2148, 2150, 3, 250, 125, 0, 2149, 2132, 1, 0, 0, 0, 2149, 2133, 1, 0, 0, 0, 2149, 2137, 1, 0, 0, 0, 2149, 2138, 1, 0, 0, 0, 2149, 2142, 1, 0, 0, 0, 2149, 2144, 1, 0, 0, 0, 2149, 2146, 1, 0, 0, 0, 2149, 2147, 1, 0, 0, 0, 2149, 2148, 1, 0, 0, 0, 2150, 249, 1, 0, 0, 0, 2151, 2152, 5, 300, 0, 0, 2152, 2250, 3, 112, 56, 0, 2153, 2154, 5, 300, 0, 0, 2154, 2155, 5, 157, 0, 0, 2155, 2250, 3, 112, 56, 0, 2156, 2250, 3, 276, 138, 0, 2157, 2250, 3, 152, 76, 0, 2158, 2250, 3, 88, 44, 0, 2159, 2250, 3, 26, 13, 0, 2160, 2250, 3, 254, 127, 0, 2161, 2250, 3, 40, 20, 0, 2162, 2163, 5, 301, 0, 0, 2163, 2164, 5, 42, 0, 0, 2164, 2165, 3, 32, 16, 0, 2165, 2166, 5, 43, 0, 0, 2166, 2250, 1, 0, 0, 0, 2167, 2168, 5, 301, 0, 0, 2168, 2169, 5, 42, 0, 0, 2169, 2170, 3, 32, 16, 0, 2170, 2171, 5, 43, 0, 0, 2171, 2172, 5, 34, 0, 0, 2172, 2173, 3, 0, 0, 0, 2173, 2250, 1, 0, 0, 0, 2174, 2175, 5, 303, 0, 0, 2175, 2176, 3, 32, 16, 0, 2176, 2177, 5, 75, 0, 0, 2177, 2178, 3, 32, 16, 0, 2178, 2250, 1, 0, 0, 0, 2179, 2180, 5, 302, 0, 0, 2180, 2181, 3, 124, 62, 0, 2181, 2182, 5, 176, 0, 0, 2182, 2183, 3, 242, 121, 0, 2183, 2250, 1, 0, 0, 0, 2184, 2185, 5, 302, 0, 0, 2185, 2186, 5, 226, 0, 0, 2186, 2187, 3, 170, 85, 0, 2187, 2188, 3, 138, 69, 0, 2188, 2189, 3, 124, 62, 0, 2189, 2190, 5, 176, 0, 0, 2190, 2191, 3, 242, 121, 0, 2191, 2192, 3, 194, 97, 0, 2192, 2193, 3, 112, 56, 0, 2193, 2250, 1, 0, 0, 0, 2194, 2195, 5, 255, 0, 0, 2195, 2196, 5, 196, 0, 0, 2196, 2197, 5, 42, 0, 0, 2197, 2198, 3, 32, 16, 0, 2198, 2202, 5, 43, 0, 0, 2199, 2201, 3, 322, 161, 0, 2200, 2199, 1, 0, 0, 0, 2201, 2204, 1, 0, 0, 0, 2202, 2200, 1, 0, 0, 0, 2202, 2203, 1, 0, 0, 0, 2203, 2250, 1, 0, 0, 0, 2204, 2202, 1, 0, 0, 0, 2205, 2206, 5, 255, 0, 0, 2206, 2207, 5, 196, 0, 0, 2207, 2211, 3, 2, 1, 0, 2208, 2210, 3, 322, 161, 0, 2209, 2208, 1, 0, 0, 0, 2210, 2213, 1, 0, 0, 0, 2211, 2209, 1, 0, 0, 0, 2211, 2212, 1, 0, 0, 0, 2212, 2250, 1, 0, 0, 0, 2213, 2211, 1, 0, 0, 0, 2214, 2215, 5, 255, 0, 0, 2215, 2216, 5, 256, 0, 0, 2216, 2217, 5, 42, 0, 0, 2217, 2218, 3, 32, 16, 0, 2218, 2219, 5, 43, 0, 0, 2219, 2220, 5, 28, 0, 0, 2220, 2224, 3, 124, 62, 0, 2221, 2223, 3, 322, 161, 0, 2222, 2221, 1, 0, 0, 0, 2223, 2226, 1, 0, 0, 0, 2224, 2222, 1, 0, 0, 0, 2224, 2225, 1, 0, 0, 0, 2225, 2250, 1, 0, 0, 0, 2226, 2224, 1, 0, 0, 0, 2227, 2228, 5, 255, 0, 0, 2228, 2229, 5, 256, 0, 0, 2229, 2230, 3, 2, 1, 0, 2230, 2231, 5, 28, 0, 0, 2231, 2235, 3, 124, 62, 0, 2232, 2234, 3, 322, 161, 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, 2250, 1, 0, 0, 0, 2237, 2235, 1, 0, 0, 0, 2238, 2239, 5, 255, 0, 0, 2239, 2240, 5, 42, 0, 0, 2240, 2241, 3, 32, 16, 0, 2241, 2242, 5, 43, 0, 0, 2242, 2246, 3, 206, 103, 0, 2243, 2245, 3, 322, 161, 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, 2250, 1, 0, 0, 0, 2248, 2246, 1, 0, 0, 0, 2249, 2151, 1, 0, 0, 0, 2249, 2153, 1, 0, 0, 0, 2249, 2156, 1, 0, 0, 0, 2249, 2157, 1, 0, 0, 0, 2249, 2158, 1, 0, 0, 0, 2249, 2159, 1, 0, 0, 0, 2249, 2160, 1, 0, 0, 0, 2249, 2161, 1, 0, 0, 0, 2249, 2162, 1, 0, 0, 0, 2249, 2167, 1, 0, 0, 0, 2249, 2174, 1, 0, 0, 0, 2249, 2179, 1, 0, 0, 0, 2249, 2184, 1, 0, 0, 0, 2249, 2194, 1, 0, 0, 0, 2249, 2205, 1, 0, 0, 0, 2249, 2214, 1, 0, 0, 0, 2249, 2227, 1, 0, 0, 0, 2249, 2238, 1, 0, 0, 0, 2250, 251, 1, 0, 0, 0, 2251, 2252, 3, 0, 0, 0, 2252, 2253, 5, 75, 0, 0, 2253, 2254, 6, 126, -1, 0, 2254, 253, 1, 0, 0, 0, 2255, 2258, 3, 44, 22, 0, 2256, 2258, 3, 46, 23, 0, 2257, 2255, 1, 0, 0, 0, 2257, 2256, 1, 0, 0, 0, 2258, 255, 1, 0, 0, 0, 2259, 2260, 5, 17, 0, 0, 2260, 2261, 3, 246, 123, 0, 2261, 2262, 5, 18, 0, 0, 2262, 257, 1, 0, 0, 0, 2263, 2264, 3, 262, 131, 0, 2264, 2265, 3, 260, 130, 0, 2265, 259, 1, 0, 0, 0, 2266, 2268, 3, 264, 132, 0, 2267, 2266, 1, 0, 0, 0, 2268, 2269, 1, 0, 0, 0, 2269, 2267, 1, 0, 0, 0, 2269, 2270, 1, 0, 0, 0, 2270, 261, 1, 0, 0, 0, 2271, 2272, 5, 158, 0, 0, 2272, 2284, 3, 256, 128, 0, 2273, 2274, 5, 158, 0, 0, 2274, 2275, 3, 0, 0, 0, 2275, 2276, 5, 159, 0, 0, 2276, 2277, 3, 0, 0, 0, 2277, 2284, 1, 0, 0, 0, 2278, 2279, 5, 158, 0, 0, 2279, 2280, 3, 32, 16, 0, 2280, 2281, 5, 159, 0, 0, 2281, 2282, 3, 32, 16, 0, 2282, 2284, 1, 0, 0, 0, 2283, 2271, 1, 0, 0, 0, 2283, 2273, 1, 0, 0, 0, 2283, 2278, 1, 0, 0, 0, 2284, 263, 1, 0, 0, 0, 2285, 2286, 3, 268, 134, 0, 2286, 2287, 3, 274, 137, 0, 2287, 2298, 1, 0, 0, 0, 2288, 2289, 3, 266, 133, 0, 2289, 2290, 3, 274, 137, 0, 2290, 2298, 1, 0, 0, 0, 2291, 2292, 3, 270, 135, 0, 2292, 2293, 3, 274, 137, 0, 2293, 2298, 1, 0, 0, 0, 2294, 2295, 3, 272, 136, 0, 2295, 2296, 3, 274, 137, 0, 2296, 2298, 1, 0, 0, 0, 2297, 2285, 1, 0, 0, 0, 2297, 2288, 1, 0, 0, 0, 2297, 2291, 1, 0, 0, 0, 2297, 2294, 1, 0, 0, 0, 2298, 265, 1, 0, 0, 0, 2299, 2300, 5, 160, 0, 0, 2300, 2306, 3, 256, 128, 0, 2301, 2302, 5, 160, 0, 0, 2302, 2306, 3, 0, 0, 0, 2303, 2304, 5, 160, 0, 0, 2304, 2306, 3, 32, 16, 0, 2305, 2299, 1, 0, 0, 0, 2305, 2301, 1, 0, 0, 0, 2305, 2303, 1, 0, 0, 0, 2306, 267, 1, 0, 0, 0, 2307, 2308, 5, 161, 0, 0, 2308, 2309, 3, 124, 62, 0, 2309, 269, 1, 0, 0, 0, 2310, 2311, 5, 162, 0, 0, 2311, 271, 1, 0, 0, 0, 2312, 2313, 5, 163, 0, 0, 2313, 273, 1, 0, 0, 0, 2314, 2326, 3, 256, 128, 0, 2315, 2316, 5, 164, 0, 0, 2316, 2317, 3, 0, 0, 0, 2317, 2318, 5, 159, 0, 0, 2318, 2319, 3, 0, 0, 0, 2319, 2326, 1, 0, 0, 0, 2320, 2321, 5, 164, 0, 0, 2321, 2322, 3, 32, 16, 0, 2322, 2323, 5, 159, 0, 0, 2323, 2324, 3, 32, 16, 0, 2324, 2326, 1, 0, 0, 0, 2325, 2314, 1, 0, 0, 0, 2325, 2315, 1, 0, 0, 0, 2325, 2320, 1, 0, 0, 0, 2326, 275, 1, 0, 0, 0, 2327, 2328, 3, 278, 139, 0, 2328, 2329, 3, 282, 141, 0, 2329, 277, 1, 0, 0, 0, 2330, 2331, 5, 165, 0, 0, 2331, 2332, 3, 280, 140, 0, 2332, 2333, 3, 0, 0, 0, 2333, 2334, 5, 36, 0, 0, 2334, 2338, 1, 0, 0, 0, 2335, 2336, 5, 165, 0, 0, 2336, 2338, 3, 280, 140, 0, 2337, 2330, 1, 0, 0, 0, 2337, 2335, 1, 0, 0, 0, 2338, 279, 1, 0, 0, 0, 2339, 2343, 1, 0, 0, 0, 2340, 2343, 5, 166, 0, 0, 2341, 2343, 5, 2, 0, 0, 2342, 2339, 1, 0, 0, 0, 2342, 2340, 1, 0, 0, 0, 2342, 2341, 1, 0, 0, 0, 2343, 281, 1, 0, 0, 0, 2344, 2345, 5, 17, 0, 0, 2345, 2346, 3, 284, 142, 0, 2346, 2347, 5, 18, 0, 0, 2347, 2354, 1, 0, 0, 0, 2348, 2350, 3, 288, 144, 0, 2349, 2348, 1, 0, 0, 0, 2350, 2351, 1, 0, 0, 0, 2351, 2349, 1, 0, 0, 0, 2351, 2352, 1, 0, 0, 0, 2352, 2354, 1, 0, 0, 0, 2353, 2344, 1, 0, 0, 0, 2353, 2349, 1, 0, 0, 0, 2354, 283, 1, 0, 0, 0, 2355, 2356, 3, 288, 144, 0, 2356, 2357, 5, 28, 0, 0, 2357, 2359, 1, 0, 0, 0, 2358, 2355, 1, 0, 0, 0, 2359, 2362, 1, 0, 0, 0, 2360, 2358, 1, 0, 0, 0, 2360, 2361, 1, 0, 0, 0, 2361, 2363, 1, 0, 0, 0, 2362, 2360, 1, 0, 0, 0, 2363, 2364, 3, 288, 144, 0, 2364, 285, 1, 0, 0, 0, 2365, 2371, 1, 0, 0, 0, 2366, 2367, 5, 42, 0, 0, 2367, 2368, 3, 32, 16, 0, 2368, 2369, 5, 43, 0, 0, 2369, 2371, 1, 0, 0, 0, 2370, 2365, 1, 0, 0, 0, 2370, 2366, 1, 0, 0, 0, 2371, 287, 1, 0, 0, 0, 2372, 2373, 5, 181, 0, 0, 2373, 2374, 5, 262, 0, 0, 2374, 2375, 5, 30, 0, 0, 2375, 2376, 3, 6, 3, 0, 2376, 2377, 5, 31, 0, 0, 2377, 2439, 1, 0, 0, 0, 2378, 2379, 5, 260, 0, 0, 2379, 2380, 5, 30, 0, 0, 2380, 2381, 3, 0, 0, 0, 2381, 2382, 5, 31, 0, 0, 2382, 2439, 1, 0, 0, 0, 2383, 2384, 5, 260, 0, 0, 2384, 2439, 3, 0, 0, 0, 2385, 2386, 5, 84, 0, 0, 2386, 2387, 5, 30, 0, 0, 2387, 2388, 3, 292, 146, 0, 2388, 2389, 5, 31, 0, 0, 2389, 2439, 1, 0, 0, 0, 2390, 2391, 5, 188, 0, 0, 2391, 2392, 5, 30, 0, 0, 2392, 2393, 3, 36, 18, 0, 2393, 2394, 5, 31, 0, 0, 2394, 2395, 3, 286, 143, 0, 2395, 2439, 1, 0, 0, 0, 2396, 2397, 5, 189, 0, 0, 2397, 2398, 5, 30, 0, 0, 2398, 2399, 3, 36, 18, 0, 2399, 2400, 5, 31, 0, 0, 2400, 2401, 3, 286, 143, 0, 2401, 2439, 1, 0, 0, 0, 2402, 2403, 5, 187, 0, 0, 2403, 2404, 5, 30, 0, 0, 2404, 2405, 3, 34, 17, 0, 2405, 2406, 5, 31, 0, 0, 2406, 2407, 3, 286, 143, 0, 2407, 2439, 1, 0, 0, 0, 2408, 2409, 5, 186, 0, 0, 2409, 2410, 5, 30, 0, 0, 2410, 2411, 3, 32, 16, 0, 2411, 2412, 5, 31, 0, 0, 2412, 2413, 3, 286, 143, 0, 2413, 2439, 1, 0, 0, 0, 2414, 2415, 5, 185, 0, 0, 2415, 2416, 5, 30, 0, 0, 2416, 2417, 3, 32, 16, 0, 2417, 2418, 5, 31, 0, 0, 2418, 2419, 3, 286, 143, 0, 2419, 2439, 1, 0, 0, 0, 2420, 2421, 5, 184, 0, 0, 2421, 2422, 5, 30, 0, 0, 2422, 2423, 3, 32, 16, 0, 2423, 2424, 5, 31, 0, 0, 2424, 2425, 3, 286, 143, 0, 2425, 2439, 1, 0, 0, 0, 2426, 2427, 5, 188, 0, 0, 2427, 2439, 3, 286, 143, 0, 2428, 2429, 5, 189, 0, 0, 2429, 2439, 3, 286, 143, 0, 2430, 2431, 5, 187, 0, 0, 2431, 2439, 3, 286, 143, 0, 2432, 2433, 5, 186, 0, 0, 2433, 2439, 3, 286, 143, 0, 2434, 2435, 5, 185, 0, 0, 2435, 2439, 3, 286, 143, 0, 2436, 2437, 5, 184, 0, 0, 2437, 2439, 3, 286, 143, 0, 2438, 2372, 1, 0, 0, 0, 2438, 2378, 1, 0, 0, 0, 2438, 2383, 1, 0, 0, 0, 2438, 2385, 1, 0, 0, 0, 2438, 2390, 1, 0, 0, 0, 2438, 2396, 1, 0, 0, 0, 2438, 2402, 1, 0, 0, 0, 2438, 2408, 1, 0, 0, 0, 2438, 2414, 1, 0, 0, 0, 2438, 2420, 1, 0, 0, 0, 2438, 2426, 1, 0, 0, 0, 2438, 2428, 1, 0, 0, 0, 2438, 2430, 1, 0, 0, 0, 2438, 2432, 1, 0, 0, 0, 2438, 2434, 1, 0, 0, 0, 2438, 2436, 1, 0, 0, 0, 2439, 289, 1, 0, 0, 0, 2440, 2441, 5, 188, 0, 0, 2441, 2442, 5, 30, 0, 0, 2442, 2443, 3, 36, 18, 0, 2443, 2444, 5, 31, 0, 0, 2444, 2516, 1, 0, 0, 0, 2445, 2446, 5, 189, 0, 0, 2446, 2447, 5, 30, 0, 0, 2447, 2448, 3, 36, 18, 0, 2448, 2449, 5, 31, 0, 0, 2449, 2516, 1, 0, 0, 0, 2450, 2451, 5, 188, 0, 0, 2451, 2452, 5, 30, 0, 0, 2452, 2453, 3, 32, 16, 0, 2453, 2454, 5, 31, 0, 0, 2454, 2516, 1, 0, 0, 0, 2455, 2456, 5, 189, 0, 0, 2456, 2457, 5, 30, 0, 0, 2457, 2458, 3, 34, 17, 0, 2458, 2459, 5, 31, 0, 0, 2459, 2516, 1, 0, 0, 0, 2460, 2461, 5, 187, 0, 0, 2461, 2462, 5, 30, 0, 0, 2462, 2463, 3, 34, 17, 0, 2463, 2464, 5, 31, 0, 0, 2464, 2516, 1, 0, 0, 0, 2465, 2466, 5, 186, 0, 0, 2466, 2467, 5, 30, 0, 0, 2467, 2468, 3, 32, 16, 0, 2468, 2469, 5, 31, 0, 0, 2469, 2516, 1, 0, 0, 0, 2470, 2471, 5, 185, 0, 0, 2471, 2472, 5, 30, 0, 0, 2472, 2473, 3, 32, 16, 0, 2473, 2474, 5, 31, 0, 0, 2474, 2516, 1, 0, 0, 0, 2475, 2476, 5, 184, 0, 0, 2476, 2477, 5, 30, 0, 0, 2477, 2478, 3, 32, 16, 0, 2478, 2479, 5, 31, 0, 0, 2479, 2516, 1, 0, 0, 0, 2480, 2481, 5, 193, 0, 0, 2481, 2482, 5, 30, 0, 0, 2482, 2483, 3, 34, 17, 0, 2483, 2484, 5, 31, 0, 0, 2484, 2516, 1, 0, 0, 0, 2485, 2486, 5, 192, 0, 0, 2486, 2487, 5, 30, 0, 0, 2487, 2488, 3, 32, 16, 0, 2488, 2489, 5, 31, 0, 0, 2489, 2516, 1, 0, 0, 0, 2490, 2491, 5, 191, 0, 0, 2491, 2492, 5, 30, 0, 0, 2492, 2493, 3, 32, 16, 0, 2493, 2494, 5, 31, 0, 0, 2494, 2516, 1, 0, 0, 0, 2495, 2496, 5, 190, 0, 0, 2496, 2497, 5, 30, 0, 0, 2497, 2498, 3, 32, 16, 0, 2498, 2499, 5, 31, 0, 0, 2499, 2516, 1, 0, 0, 0, 2500, 2501, 5, 181, 0, 0, 2501, 2502, 5, 30, 0, 0, 2502, 2503, 3, 32, 16, 0, 2503, 2504, 5, 31, 0, 0, 2504, 2516, 1, 0, 0, 0, 2505, 2506, 5, 183, 0, 0, 2506, 2507, 5, 30, 0, 0, 2507, 2508, 3, 162, 81, 0, 2508, 2509, 5, 31, 0, 0, 2509, 2516, 1, 0, 0, 0, 2510, 2511, 5, 84, 0, 0, 2511, 2512, 5, 30, 0, 0, 2512, 2513, 3, 292, 146, 0, 2513, 2514, 5, 31, 0, 0, 2514, 2516, 1, 0, 0, 0, 2515, 2440, 1, 0, 0, 0, 2515, 2445, 1, 0, 0, 0, 2515, 2450, 1, 0, 0, 0, 2515, 2455, 1, 0, 0, 0, 2515, 2460, 1, 0, 0, 0, 2515, 2465, 1, 0, 0, 0, 2515, 2470, 1, 0, 0, 0, 2515, 2475, 1, 0, 0, 0, 2515, 2480, 1, 0, 0, 0, 2515, 2485, 1, 0, 0, 0, 2515, 2490, 1, 0, 0, 0, 2515, 2495, 1, 0, 0, 0, 2515, 2500, 1, 0, 0, 0, 2515, 2505, 1, 0, 0, 0, 2515, 2510, 1, 0, 0, 0, 2516, 291, 1, 0, 0, 0, 2517, 2518, 3, 294, 147, 0, 2518, 2519, 6, 146, -1, 0, 2519, 2521, 1, 0, 0, 0, 2520, 2517, 1, 0, 0, 0, 2521, 2524, 1, 0, 0, 0, 2522, 2520, 1, 0, 0, 0, 2522, 2523, 1, 0, 0, 0, 2523, 293, 1, 0, 0, 0, 2524, 2522, 1, 0, 0, 0, 2525, 2526, 7, 12, 0, 0, 2526, 295, 1, 0, 0, 0, 2527, 2531, 3, 290, 145, 0, 2528, 2531, 3, 6, 3, 0, 2529, 2531, 5, 179, 0, 0, 2530, 2527, 1, 0, 0, 0, 2530, 2528, 1, 0, 0, 0, 2530, 2529, 1, 0, 0, 0, 2531, 297, 1, 0, 0, 0, 2532, 2681, 3, 290, 145, 0, 2533, 2534, 5, 182, 0, 0, 2534, 2535, 5, 30, 0, 0, 2535, 2536, 5, 179, 0, 0, 2536, 2681, 5, 31, 0, 0, 2537, 2538, 5, 182, 0, 0, 2538, 2539, 5, 30, 0, 0, 2539, 2540, 5, 264, 0, 0, 2540, 2681, 5, 31, 0, 0, 2541, 2542, 5, 196, 0, 0, 2542, 2543, 5, 30, 0, 0, 2543, 2544, 5, 39, 0, 0, 2544, 2545, 5, 264, 0, 0, 2545, 2681, 5, 31, 0, 0, 2546, 2547, 5, 196, 0, 0, 2547, 2548, 5, 30, 0, 0, 2548, 2549, 3, 116, 58, 0, 2549, 2550, 5, 31, 0, 0, 2550, 2681, 1, 0, 0, 0, 2551, 2552, 5, 196, 0, 0, 2552, 2553, 5, 30, 0, 0, 2553, 2554, 5, 179, 0, 0, 2554, 2681, 5, 31, 0, 0, 2555, 2556, 5, 197, 0, 0, 2556, 2557, 5, 30, 0, 0, 2557, 2558, 3, 298, 149, 0, 2558, 2559, 5, 31, 0, 0, 2559, 2681, 1, 0, 0, 0, 2560, 2561, 5, 188, 0, 0, 2561, 2562, 5, 42, 0, 0, 2562, 2563, 3, 32, 16, 0, 2563, 2564, 5, 43, 0, 0, 2564, 2565, 5, 30, 0, 0, 2565, 2566, 3, 300, 150, 0, 2566, 2567, 5, 31, 0, 0, 2567, 2681, 1, 0, 0, 0, 2568, 2569, 5, 189, 0, 0, 2569, 2570, 5, 42, 0, 0, 2570, 2571, 3, 32, 16, 0, 2571, 2572, 5, 43, 0, 0, 2572, 2573, 5, 30, 0, 0, 2573, 2574, 3, 302, 151, 0, 2574, 2575, 5, 31, 0, 0, 2575, 2681, 1, 0, 0, 0, 2576, 2577, 5, 187, 0, 0, 2577, 2578, 5, 42, 0, 0, 2578, 2579, 3, 32, 16, 0, 2579, 2580, 5, 43, 0, 0, 2580, 2581, 5, 30, 0, 0, 2581, 2582, 3, 304, 152, 0, 2582, 2583, 5, 31, 0, 0, 2583, 2681, 1, 0, 0, 0, 2584, 2585, 5, 186, 0, 0, 2585, 2586, 5, 42, 0, 0, 2586, 2587, 3, 32, 16, 0, 2587, 2588, 5, 43, 0, 0, 2588, 2589, 5, 30, 0, 0, 2589, 2590, 3, 306, 153, 0, 2590, 2591, 5, 31, 0, 0, 2591, 2681, 1, 0, 0, 0, 2592, 2593, 5, 185, 0, 0, 2593, 2594, 5, 42, 0, 0, 2594, 2595, 3, 32, 16, 0, 2595, 2596, 5, 43, 0, 0, 2596, 2597, 5, 30, 0, 0, 2597, 2598, 3, 308, 154, 0, 2598, 2599, 5, 31, 0, 0, 2599, 2681, 1, 0, 0, 0, 2600, 2601, 5, 184, 0, 0, 2601, 2602, 5, 42, 0, 0, 2602, 2603, 3, 32, 16, 0, 2603, 2604, 5, 43, 0, 0, 2604, 2605, 5, 30, 0, 0, 2605, 2606, 3, 310, 155, 0, 2606, 2607, 5, 31, 0, 0, 2607, 2681, 1, 0, 0, 0, 2608, 2609, 5, 193, 0, 0, 2609, 2610, 5, 42, 0, 0, 2610, 2611, 3, 32, 16, 0, 2611, 2612, 5, 43, 0, 0, 2612, 2613, 5, 30, 0, 0, 2613, 2614, 3, 304, 152, 0, 2614, 2615, 5, 31, 0, 0, 2615, 2681, 1, 0, 0, 0, 2616, 2617, 5, 192, 0, 0, 2617, 2618, 5, 42, 0, 0, 2618, 2619, 3, 32, 16, 0, 2619, 2620, 5, 43, 0, 0, 2620, 2621, 5, 30, 0, 0, 2621, 2622, 3, 306, 153, 0, 2622, 2623, 5, 31, 0, 0, 2623, 2681, 1, 0, 0, 0, 2624, 2625, 5, 191, 0, 0, 2625, 2626, 5, 42, 0, 0, 2626, 2627, 3, 32, 16, 0, 2627, 2628, 5, 43, 0, 0, 2628, 2629, 5, 30, 0, 0, 2629, 2630, 3, 308, 154, 0, 2630, 2631, 5, 31, 0, 0, 2631, 2681, 1, 0, 0, 0, 2632, 2633, 5, 190, 0, 0, 2633, 2634, 5, 42, 0, 0, 2634, 2635, 3, 32, 16, 0, 2635, 2636, 5, 43, 0, 0, 2636, 2637, 5, 30, 0, 0, 2637, 2638, 3, 310, 155, 0, 2638, 2639, 5, 31, 0, 0, 2639, 2681, 1, 0, 0, 0, 2640, 2641, 5, 181, 0, 0, 2641, 2642, 5, 42, 0, 0, 2642, 2643, 3, 32, 16, 0, 2643, 2644, 5, 43, 0, 0, 2644, 2645, 5, 30, 0, 0, 2645, 2646, 3, 308, 154, 0, 2646, 2647, 5, 31, 0, 0, 2647, 2681, 1, 0, 0, 0, 2648, 2649, 5, 183, 0, 0, 2649, 2650, 5, 42, 0, 0, 2650, 2651, 3, 32, 16, 0, 2651, 2652, 5, 43, 0, 0, 2652, 2653, 5, 30, 0, 0, 2653, 2654, 3, 312, 156, 0, 2654, 2655, 5, 31, 0, 0, 2655, 2681, 1, 0, 0, 0, 2656, 2657, 5, 182, 0, 0, 2657, 2658, 5, 42, 0, 0, 2658, 2659, 3, 32, 16, 0, 2659, 2660, 5, 43, 0, 0, 2660, 2661, 5, 30, 0, 0, 2661, 2662, 3, 314, 157, 0, 2662, 2663, 5, 31, 0, 0, 2663, 2681, 1, 0, 0, 0, 2664, 2665, 5, 196, 0, 0, 2665, 2666, 5, 42, 0, 0, 2666, 2667, 3, 32, 16, 0, 2667, 2668, 5, 43, 0, 0, 2668, 2669, 5, 30, 0, 0, 2669, 2670, 3, 316, 158, 0, 2670, 2671, 5, 31, 0, 0, 2671, 2681, 1, 0, 0, 0, 2672, 2673, 5, 197, 0, 0, 2673, 2674, 5, 42, 0, 0, 2674, 2675, 3, 32, 16, 0, 2675, 2676, 5, 43, 0, 0, 2676, 2677, 5, 30, 0, 0, 2677, 2678, 3, 320, 160, 0, 2678, 2679, 5, 31, 0, 0, 2679, 2681, 1, 0, 0, 0, 2680, 2532, 1, 0, 0, 0, 2680, 2533, 1, 0, 0, 0, 2680, 2537, 1, 0, 0, 0, 2680, 2541, 1, 0, 0, 0, 2680, 2546, 1, 0, 0, 0, 2680, 2551, 1, 0, 0, 0, 2680, 2555, 1, 0, 0, 0, 2680, 2560, 1, 0, 0, 0, 2680, 2568, 1, 0, 0, 0, 2680, 2576, 1, 0, 0, 0, 2680, 2584, 1, 0, 0, 0, 2680, 2592, 1, 0, 0, 0, 2680, 2600, 1, 0, 0, 0, 2680, 2608, 1, 0, 0, 0, 2680, 2616, 1, 0, 0, 0, 2680, 2624, 1, 0, 0, 0, 2680, 2632, 1, 0, 0, 0, 2680, 2640, 1, 0, 0, 0, 2680, 2648, 1, 0, 0, 0, 2680, 2656, 1, 0, 0, 0, 2680, 2664, 1, 0, 0, 0, 2680, 2672, 1, 0, 0, 0, 2681, 299, 1, 0, 0, 0, 2682, 2685, 3, 36, 18, 0, 2683, 2685, 3, 32, 16, 0, 2684, 2682, 1, 0, 0, 0, 2684, 2683, 1, 0, 0, 0, 2685, 2688, 1, 0, 0, 0, 2686, 2684, 1, 0, 0, 0, 2686, 2687, 1, 0, 0, 0, 2687, 301, 1, 0, 0, 0, 2688, 2686, 1, 0, 0, 0, 2689, 2692, 3, 36, 18, 0, 2690, 2692, 3, 34, 17, 0, 2691, 2689, 1, 0, 0, 0, 2691, 2690, 1, 0, 0, 0, 2692, 2695, 1, 0, 0, 0, 2693, 2691, 1, 0, 0, 0, 2693, 2694, 1, 0, 0, 0, 2694, 303, 1, 0, 0, 0, 2695, 2693, 1, 0, 0, 0, 2696, 2698, 3, 34, 17, 0, 2697, 2696, 1, 0, 0, 0, 2698, 2701, 1, 0, 0, 0, 2699, 2697, 1, 0, 0, 0, 2699, 2700, 1, 0, 0, 0, 2700, 305, 1, 0, 0, 0, 2701, 2699, 1, 0, 0, 0, 2702, 2704, 3, 32, 16, 0, 2703, 2702, 1, 0, 0, 0, 2704, 2707, 1, 0, 0, 0, 2705, 2703, 1, 0, 0, 0, 2705, 2706, 1, 0, 0, 0, 2706, 307, 1, 0, 0, 0, 2707, 2705, 1, 0, 0, 0, 2708, 2710, 3, 32, 16, 0, 2709, 2708, 1, 0, 0, 0, 2710, 2713, 1, 0, 0, 0, 2711, 2709, 1, 0, 0, 0, 2711, 2712, 1, 0, 0, 0, 2712, 309, 1, 0, 0, 0, 2713, 2711, 1, 0, 0, 0, 2714, 2716, 3, 32, 16, 0, 2715, 2714, 1, 0, 0, 0, 2716, 2719, 1, 0, 0, 0, 2717, 2715, 1, 0, 0, 0, 2717, 2718, 1, 0, 0, 0, 2718, 311, 1, 0, 0, 0, 2719, 2717, 1, 0, 0, 0, 2720, 2722, 3, 162, 81, 0, 2721, 2720, 1, 0, 0, 0, 2722, 2725, 1, 0, 0, 0, 2723, 2721, 1, 0, 0, 0, 2723, 2724, 1, 0, 0, 0, 2724, 313, 1, 0, 0, 0, 2725, 2723, 1, 0, 0, 0, 2726, 2728, 7, 13, 0, 0, 2727, 2726, 1, 0, 0, 0, 2728, 2731, 1, 0, 0, 0, 2729, 2727, 1, 0, 0, 0, 2729, 2730, 1, 0, 0, 0, 2730, 315, 1, 0, 0, 0, 2731, 2729, 1, 0, 0, 0, 2732, 2734, 3, 318, 159, 0, 2733, 2732, 1, 0, 0, 0, 2734, 2737, 1, 0, 0, 0, 2735, 2733, 1, 0, 0, 0, 2735, 2736, 1, 0, 0, 0, 2736, 317, 1, 0, 0, 0, 2737, 2735, 1, 0, 0, 0, 2738, 2743, 5, 179, 0, 0, 2739, 2740, 5, 39, 0, 0, 2740, 2743, 5, 264, 0, 0, 2741, 2743, 3, 116, 58, 0, 2742, 2738, 1, 0, 0, 0, 2742, 2739, 1, 0, 0, 0, 2742, 2741, 1, 0, 0, 0, 2743, 319, 1, 0, 0, 0, 2744, 2746, 3, 298, 149, 0, 2745, 2744, 1, 0, 0, 0, 2746, 2749, 1, 0, 0, 0, 2747, 2745, 1, 0, 0, 0, 2747, 2748, 1, 0, 0, 0, 2748, 321, 1, 0, 0, 0, 2749, 2747, 1, 0, 0, 0, 2750, 2754, 3, 44, 22, 0, 2751, 2754, 3, 46, 23, 0, 2752, 2754, 3, 2, 1, 0, 2753, 2750, 1, 0, 0, 0, 2753, 2751, 1, 0, 0, 0, 2753, 2752, 1, 0, 0, 0, 2754, 323, 1, 0, 0, 0, 2755, 2756, 7, 14, 0, 0, 2756, 2757, 5, 36, 0, 0, 2757, 2758, 5, 30, 0, 0, 2758, 2759, 3, 292, 146, 0, 2759, 2760, 5, 31, 0, 0, 2760, 2781, 1, 0, 0, 0, 2761, 2762, 5, 169, 0, 0, 2762, 2763, 3, 38, 19, 0, 2763, 2764, 5, 75, 0, 0, 2764, 2765, 3, 38, 19, 0, 2765, 2766, 5, 75, 0, 0, 2766, 2767, 3, 38, 19, 0, 2767, 2768, 5, 75, 0, 0, 2768, 2769, 3, 38, 19, 0, 2769, 2781, 1, 0, 0, 0, 2770, 2771, 5, 170, 0, 0, 2771, 2781, 3, 6, 3, 0, 2772, 2773, 5, 170, 0, 0, 2773, 2774, 5, 36, 0, 0, 2774, 2775, 5, 30, 0, 0, 2775, 2776, 3, 292, 146, 0, 2776, 2777, 5, 31, 0, 0, 2777, 2781, 1, 0, 0, 0, 2778, 2781, 3, 322, 161, 0, 2779, 2781, 3, 40, 20, 0, 2780, 2755, 1, 0, 0, 0, 2780, 2761, 1, 0, 0, 0, 2780, 2770, 1, 0, 0, 0, 2780, 2772, 1, 0, 0, 0, 2780, 2778, 1, 0, 0, 0, 2780, 2779, 1, 0, 0, 0, 2781, 325, 1, 0, 0, 0, 2782, 2783, 5, 25, 0, 0, 2783, 2784, 5, 40, 0, 0, 2784, 2785, 3, 98, 49, 0, 2785, 2786, 3, 2, 1, 0, 2786, 2795, 1, 0, 0, 0, 2787, 2788, 5, 25, 0, 0, 2788, 2789, 5, 40, 0, 0, 2789, 2790, 3, 98, 49, 0, 2790, 2791, 3, 2, 1, 0, 2791, 2792, 5, 34, 0, 0, 2792, 2793, 3, 2, 1, 0, 2793, 2795, 1, 0, 0, 0, 2794, 2782, 1, 0, 0, 0, 2794, 2787, 1, 0, 0, 0, 2795, 327, 1, 0, 0, 0, 2796, 2798, 3, 330, 165, 0, 2797, 2796, 1, 0, 0, 0, 2798, 2801, 1, 0, 0, 0, 2799, 2797, 1, 0, 0, 0, 2799, 2800, 1, 0, 0, 0, 2800, 329, 1, 0, 0, 0, 2801, 2799, 1, 0, 0, 0, 2802, 2803, 5, 180, 0, 0, 2803, 2804, 5, 36, 0, 0, 2804, 2805, 5, 30, 0, 0, 2805, 2806, 3, 292, 146, 0, 2806, 2807, 5, 31, 0, 0, 2807, 2817, 1, 0, 0, 0, 2808, 2817, 3, 324, 162, 0, 2809, 2810, 5, 171, 0, 0, 2810, 2811, 5, 36, 0, 0, 2811, 2812, 5, 30, 0, 0, 2812, 2813, 3, 292, 146, 0, 2813, 2814, 5, 31, 0, 0, 2814, 2817, 1, 0, 0, 0, 2815, 2817, 5, 55, 0, 0, 2816, 2802, 1, 0, 0, 0, 2816, 2808, 1, 0, 0, 0, 2816, 2809, 1, 0, 0, 0, 2816, 2815, 1, 0, 0, 0, 2817, 331, 1, 0, 0, 0, 2818, 2819, 5, 50, 0, 0, 2819, 2823, 5, 40, 0, 0, 2820, 2822, 3, 336, 168, 0, 2821, 2820, 1, 0, 0, 0, 2822, 2825, 1, 0, 0, 0, 2823, 2821, 1, 0, 0, 0, 2823, 2824, 1, 0, 0, 0, 2824, 2826, 1, 0, 0, 0, 2825, 2823, 1, 0, 0, 0, 2826, 2827, 3, 2, 1, 0, 2827, 333, 1, 0, 0, 0, 2828, 2832, 5, 301, 0, 0, 2829, 2831, 3, 336, 168, 0, 2830, 2829, 1, 0, 0, 0, 2831, 2834, 1, 0, 0, 0, 2832, 2830, 1, 0, 0, 0, 2832, 2833, 1, 0, 0, 0, 2833, 2835, 1, 0, 0, 0, 2834, 2832, 1, 0, 0, 0, 2835, 2836, 3, 2, 1, 0, 2836, 335, 1, 0, 0, 0, 2837, 2853, 5, 52, 0, 0, 2838, 2853, 5, 51, 0, 0, 2839, 2853, 5, 172, 0, 0, 2840, 2841, 5, 62, 0, 0, 2841, 2853, 5, 51, 0, 0, 2842, 2843, 5, 62, 0, 0, 2843, 2853, 5, 52, 0, 0, 2844, 2845, 5, 62, 0, 0, 2845, 2853, 5, 63, 0, 0, 2846, 2847, 5, 62, 0, 0, 2847, 2853, 5, 64, 0, 0, 2848, 2849, 5, 62, 0, 0, 2849, 2853, 5, 65, 0, 0, 2850, 2851, 5, 62, 0, 0, 2851, 2853, 5, 66, 0, 0, 2852, 2837, 1, 0, 0, 0, 2852, 2838, 1, 0, 0, 0, 2852, 2839, 1, 0, 0, 0, 2852, 2840, 1, 0, 0, 0, 2852, 2842, 1, 0, 0, 0, 2852, 2844, 1, 0, 0, 0, 2852, 2846, 1, 0, 0, 0, 2852, 2848, 1, 0, 0, 0, 2852, 2850, 1, 0, 0, 0, 2853, 337, 1, 0, 0, 0, 2854, 2856, 3, 340, 170, 0, 2855, 2854, 1, 0, 0, 0, 2856, 2859, 1, 0, 0, 0, 2857, 2855, 1, 0, 0, 0, 2857, 2858, 1, 0, 0, 0, 2858, 339, 1, 0, 0, 0, 2859, 2857, 1, 0, 0, 0, 2860, 2861, 5, 21, 0, 0, 2861, 2874, 3, 2, 1, 0, 2862, 2863, 5, 50, 0, 0, 2863, 2864, 5, 40, 0, 0, 2864, 2874, 3, 118, 59, 0, 2865, 2866, 5, 25, 0, 0, 2866, 2867, 5, 40, 0, 0, 2867, 2874, 3, 2, 1, 0, 2868, 2874, 3, 174, 87, 0, 2869, 2870, 5, 50, 0, 0, 2870, 2874, 3, 32, 16, 0, 2871, 2874, 3, 322, 161, 0, 2872, 2874, 3, 40, 20, 0, 2873, 2860, 1, 0, 0, 0, 2873, 2862, 1, 0, 0, 0, 2873, 2865, 1, 0, 0, 0, 2873, 2868, 1, 0, 0, 0, 2873, 2869, 1, 0, 0, 0, 2873, 2871, 1, 0, 0, 0, 2873, 2872, 1, 0, 0, 0, 2874, 341, 1, 0, 0, 0, 2875, 2879, 5, 274, 0, 0, 2876, 2878, 3, 344, 172, 0, 2877, 2876, 1, 0, 0, 0, 2878, 2881, 1, 0, 0, 0, 2879, 2877, 1, 0, 0, 0, 2879, 2880, 1, 0, 0, 0, 2880, 2882, 1, 0, 0, 0, 2881, 2879, 1, 0, 0, 0, 2882, 2895, 3, 2, 1, 0, 2883, 2887, 5, 274, 0, 0, 2884, 2886, 3, 344, 172, 0, 2885, 2884, 1, 0, 0, 0, 2886, 2889, 1, 0, 0, 0, 2887, 2885, 1, 0, 0, 0, 2887, 2888, 1, 0, 0, 0, 2888, 2890, 1, 0, 0, 0, 2889, 2887, 1, 0, 0, 0, 2890, 2891, 3, 2, 1, 0, 2891, 2892, 5, 34, 0, 0, 2892, 2893, 3, 2, 1, 0, 2893, 2895, 1, 0, 0, 0, 2894, 2875, 1, 0, 0, 0, 2894, 2883, 1, 0, 0, 0, 2895, 343, 1, 0, 0, 0, 2896, 2897, 7, 15, 0, 0, 2897, 345, 1, 0, 0, 0, 2898, 2900, 3, 348, 174, 0, 2899, 2898, 1, 0, 0, 0, 2900, 2903, 1, 0, 0, 0, 2901, 2899, 1, 0, 0, 0, 2901, 2902, 1, 0, 0, 0, 2902, 347, 1, 0, 0, 0, 2903, 2901, 1, 0, 0, 0, 2904, 2905, 5, 21, 0, 0, 2905, 2906, 3, 2, 1, 0, 2906, 2907, 5, 44, 0, 0, 2907, 2908, 3, 32, 16, 0, 2908, 2915, 1, 0, 0, 0, 2909, 2910, 5, 25, 0, 0, 2910, 2911, 5, 40, 0, 0, 2911, 2915, 3, 2, 1, 0, 2912, 2915, 3, 322, 161, 0, 2913, 2915, 3, 40, 20, 0, 2914, 2904, 1, 0, 0, 0, 2914, 2909, 1, 0, 0, 0, 2914, 2912, 1, 0, 0, 0, 2914, 2913, 1, 0, 0, 0, 2915, 349, 1, 0, 0, 0, 175, 358, 363, 372, 381, 434, 475, 484, 514, 518, 536, 563, 586, 622, 628, 635, 637, 647, 649, 656, 667, 675, 696, 698, 714, 759, 764, 769, 774, 782, 892, 898, 914, 920, 926, 933, 961, 1039, 1041, 1054, 1060, 1069, 1071, 1079, 1091, 1103, 1110, 1117, 1119, 1146, 1153, 1161, 1169, 1182, 1189, 1192, 1211, 1305, 1314, 1321, 1324, 1332, 1353, 1385, 1408, 1420, 1429, 1454, 1478, 1486, 1490, 1505, 1512, 1557, 1567, 1583, 1595, 1607, 1621, 1633, 1644, 1651, 1661, 1674, 1679, 1684, 1693, 1704, 1787, 1796, 1809, 1820, 1828, 1838, 1840, 1867, 1874, 1879, 1886, 1892, 1902, 1906, 1913, 1928, 1934, 1948, 1961, 1969, 1976, 1980, 1985, 2001, 2006, 2008, 2021, 2047, 2054, 2056, 2061, 2067, 2096, 2101, 2124, 2129, 2149, 2202, 2211, 2224, 2235, 2246, 2249, 2257, 2269, 2283, 2297, 2305, 2325, 2337, 2342, 2351, 2353, 2360, 2370, 2438, 2515, 2522, 2530, 2680, 2684, 2686, 2691, 2693, 2699, 2705, 2711, 2717, 2723, 2729, 2735, 2742, 2747, 2753, 2780, 2794, 2799, 2816, 2823, 2832, 2852, 2857, 2873, 2879, 2887, 2894, 2901, 2914] \ No newline at end of file +[4, 1, 305, 3067, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 359, 8, 1, 10, 1, 12, 1, 362, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 369, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 5, 3, 376, 8, 3, 10, 3, 12, 3, 379, 9, 3, 1, 3, 1, 3, 1, 3, 1, 4, 5, 4, 385, 8, 4, 10, 4, 12, 4, 388, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 440, 8, 5, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 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, 481, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 5, 15, 488, 8, 15, 10, 15, 12, 15, 491, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 520, 8, 18, 1, 19, 1, 19, 3, 19, 524, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 542, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 569, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 592, 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, 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, 628, 8, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 638, 8, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 5, 27, 645, 8, 27, 10, 27, 12, 27, 648, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 657, 8, 28, 10, 28, 12, 28, 660, 9, 28, 1, 29, 1, 29, 1, 30, 1, 30, 3, 30, 666, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 677, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 685, 8, 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, 34, 1, 34, 1, 34, 1, 34, 5, 34, 706, 8, 34, 10, 34, 12, 34, 709, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 5, 37, 722, 8, 37, 10, 37, 12, 37, 725, 9, 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, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 769, 8, 38, 1, 39, 1, 39, 1, 39, 3, 39, 774, 8, 39, 1, 40, 1, 40, 1, 40, 3, 40, 779, 8, 40, 1, 41, 5, 41, 782, 8, 41, 10, 41, 12, 41, 785, 9, 41, 1, 42, 1, 42, 1, 42, 5, 42, 790, 8, 42, 10, 42, 12, 42, 793, 9, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 902, 8, 44, 1, 45, 1, 45, 5, 45, 906, 8, 45, 10, 45, 12, 45, 909, 9, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 922, 8, 45, 10, 45, 12, 45, 925, 9, 45, 1, 45, 1, 45, 1, 45, 3, 45, 930, 8, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 936, 8, 47, 1, 48, 1, 48, 1, 49, 5, 49, 941, 8, 49, 10, 49, 12, 49, 944, 9, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 971, 8, 50, 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, 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, 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, 1049, 8, 51, 3, 51, 1051, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1065, 8, 53, 1, 53, 1, 53, 5, 53, 1069, 8, 53, 10, 53, 12, 53, 1072, 9, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1080, 8, 53, 3, 53, 1082, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1089, 8, 54, 10, 54, 12, 54, 1092, 9, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1103, 8, 55, 10, 55, 12, 55, 1106, 9, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 5, 56, 1117, 8, 56, 10, 56, 12, 56, 1120, 9, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1127, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 1135, 8, 57, 1, 57, 1, 57, 3, 57, 1139, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1178, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 1184, 8, 59, 10, 59, 12, 59, 1187, 9, 59, 1, 59, 1, 59, 1, 59, 1, 60, 5, 60, 1193, 8, 60, 10, 60, 12, 60, 1196, 9, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1203, 8, 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, 3, 62, 1222, 8, 62, 1, 63, 1, 63, 1, 63, 5, 63, 1227, 8, 63, 10, 63, 12, 63, 1230, 9, 63, 3, 63, 1232, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 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, 1251, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1345, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1354, 8, 66, 1, 67, 1, 67, 1, 67, 5, 67, 1359, 8, 67, 10, 67, 12, 67, 1362, 9, 67, 3, 67, 1364, 8, 67, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 5, 69, 1373, 8, 69, 10, 69, 12, 69, 1376, 9, 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, 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, 1407, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1467, 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, 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, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1507, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1523, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1533, 8, 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, 3, 76, 1560, 8, 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, 1584, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 5, 77, 1590, 8, 77, 10, 77, 12, 77, 1593, 9, 77, 1, 77, 3, 77, 1596, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1611, 8, 78, 1, 79, 1, 79, 1, 79, 5, 79, 1616, 8, 79, 10, 79, 12, 79, 1619, 9, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1663, 8, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1673, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1691, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1709, 8, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1728, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1749, 8, 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, 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 1768, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1783, 8, 89, 1, 90, 1, 90, 1, 90, 5, 90, 1788, 8, 90, 10, 90, 12, 90, 1791, 9, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 1800, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 1813, 8, 92, 1, 93, 5, 93, 1816, 8, 93, 10, 93, 12, 93, 1819, 9, 93, 1, 94, 1, 94, 3, 94, 1823, 8, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 5, 95, 1830, 8, 95, 10, 95, 12, 95, 1833, 9, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 3, 97, 1842, 8, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1926, 8, 99, 10, 99, 12, 99, 1929, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1935, 8, 99, 10, 99, 12, 99, 1938, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1948, 8, 99, 10, 99, 12, 99, 1951, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1959, 8, 99, 10, 99, 12, 99, 1962, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 1969, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 1979, 8, 100, 10, 100, 12, 100, 1982, 9, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 2008, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 2015, 8, 102, 1, 103, 1, 103, 1, 103, 3, 103, 2020, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 2027, 8, 104, 1, 105, 1, 105, 5, 105, 2031, 8, 105, 10, 105, 12, 105, 2034, 9, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2041, 8, 105, 10, 105, 12, 105, 2044, 9, 105, 1, 105, 3, 105, 2047, 8, 105, 1, 106, 1, 106, 1, 107, 5, 107, 2052, 8, 107, 10, 107, 12, 107, 2055, 9, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 2069, 8, 108, 1, 109, 1, 109, 5, 109, 2073, 8, 109, 10, 109, 12, 109, 2076, 9, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 111, 5, 111, 2087, 8, 111, 10, 111, 12, 111, 2090, 9, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 2102, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 2110, 8, 113, 1, 114, 1, 114, 1, 114, 4, 114, 2115, 8, 114, 11, 114, 12, 114, 2116, 1, 114, 1, 114, 3, 114, 2121, 8, 114, 1, 115, 1, 115, 1, 115, 5, 115, 2126, 8, 115, 10, 115, 12, 115, 2129, 9, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 2148, 8, 116, 1, 117, 1, 117, 1, 117, 5, 117, 2153, 8, 117, 10, 117, 12, 117, 2156, 9, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2166, 8, 117, 10, 117, 12, 117, 2169, 9, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2194, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2201, 8, 119, 3, 119, 2203, 8, 119, 1, 119, 5, 119, 2206, 8, 119, 10, 119, 12, 119, 2209, 9, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2214, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2243, 8, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 2252, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2275, 8, 122, 1, 123, 5, 123, 2278, 8, 123, 10, 123, 12, 123, 2281, 9, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2300, 8, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2351, 8, 125, 10, 125, 12, 125, 2354, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2360, 8, 125, 10, 125, 12, 125, 2363, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2373, 8, 125, 10, 125, 12, 125, 2376, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2384, 8, 125, 10, 125, 12, 125, 2387, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2395, 8, 125, 10, 125, 12, 125, 2398, 9, 125, 3, 125, 2400, 8, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 3, 127, 2408, 8, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 130, 4, 130, 2418, 8, 130, 11, 130, 12, 130, 2419, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 2434, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 3, 132, 2448, 8, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 2456, 8, 133, 1, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 2476, 8, 137, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 2488, 8, 139, 1, 140, 1, 140, 1, 140, 3, 140, 2493, 8, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 4, 141, 2500, 8, 141, 11, 141, 12, 141, 2501, 3, 141, 2504, 8, 141, 1, 142, 1, 142, 1, 142, 5, 142, 2509, 8, 142, 10, 142, 12, 142, 2512, 9, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 2521, 8, 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, 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, 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, 2589, 8, 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, 145, 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, 145, 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, 145, 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, 145, 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, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 3, 145, 2666, 8, 145, 1, 146, 1, 146, 1, 146, 5, 146, 2671, 8, 146, 10, 146, 12, 146, 2674, 9, 146, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 3, 148, 2681, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 2831, 8, 149, 1, 150, 1, 150, 5, 150, 2835, 8, 150, 10, 150, 12, 150, 2838, 9, 150, 1, 151, 1, 151, 5, 151, 2842, 8, 151, 10, 151, 12, 151, 2845, 9, 151, 1, 152, 5, 152, 2848, 8, 152, 10, 152, 12, 152, 2851, 9, 152, 1, 153, 5, 153, 2854, 8, 153, 10, 153, 12, 153, 2857, 9, 153, 1, 154, 5, 154, 2860, 8, 154, 10, 154, 12, 154, 2863, 9, 154, 1, 155, 5, 155, 2866, 8, 155, 10, 155, 12, 155, 2869, 9, 155, 1, 156, 5, 156, 2872, 8, 156, 10, 156, 12, 156, 2875, 9, 156, 1, 157, 5, 157, 2878, 8, 157, 10, 157, 12, 157, 2881, 9, 157, 1, 158, 5, 158, 2884, 8, 158, 10, 158, 12, 158, 2887, 9, 158, 1, 159, 1, 159, 1, 159, 1, 159, 3, 159, 2893, 8, 159, 1, 160, 5, 160, 2896, 8, 160, 10, 160, 12, 160, 2899, 9, 160, 1, 161, 1, 161, 1, 161, 3, 161, 2904, 8, 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, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 3, 162, 2931, 8, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 2945, 8, 163, 1, 164, 5, 164, 2948, 8, 164, 10, 164, 12, 164, 2951, 9, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 3, 165, 2967, 8, 165, 1, 166, 1, 166, 1, 166, 5, 166, 2972, 8, 166, 10, 166, 12, 166, 2975, 9, 166, 1, 166, 1, 166, 1, 167, 1, 167, 5, 167, 2981, 8, 167, 10, 167, 12, 167, 2984, 9, 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, 168, 1, 168, 1, 168, 1, 168, 3, 168, 3003, 8, 168, 1, 169, 5, 169, 3006, 8, 169, 10, 169, 12, 169, 3009, 9, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 3024, 8, 170, 1, 171, 1, 171, 5, 171, 3028, 8, 171, 10, 171, 12, 171, 3031, 9, 171, 1, 171, 1, 171, 1, 171, 5, 171, 3036, 8, 171, 10, 171, 12, 171, 3039, 9, 171, 1, 171, 1, 171, 1, 171, 1, 171, 3, 171, 3045, 8, 171, 1, 172, 1, 172, 1, 173, 5, 173, 3050, 8, 173, 10, 173, 12, 173, 3053, 9, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 3065, 8, 174, 1, 174, 0, 1, 68, 175, 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, 0, 16, 6, 0, 1, 15, 199, 199, 243, 243, 247, 247, 264, 264, 289, 289, 5, 0, 16, 16, 199, 199, 243, 243, 264, 264, 288, 289, 1, 0, 263, 264, 1, 0, 173, 174, 1, 0, 37, 38, 1, 0, 73, 74, 3, 0, 2, 2, 61, 61, 77, 83, 2, 0, 229, 229, 260, 261, 9, 0, 178, 178, 183, 195, 201, 201, 207, 208, 210, 215, 218, 219, 222, 222, 230, 242, 262, 262, 1, 0, 95, 96, 1, 0, 97, 111, 1, 0, 68, 69, 2, 0, 173, 173, 289, 290, 2, 0, 179, 179, 264, 264, 1, 0, 167, 168, 1, 0, 51, 52, 3494, 0, 350, 1, 0, 0, 0, 2, 368, 1, 0, 0, 0, 4, 370, 1, 0, 0, 0, 6, 377, 1, 0, 0, 0, 8, 386, 1, 0, 0, 0, 10, 439, 1, 0, 0, 0, 12, 441, 1, 0, 0, 0, 14, 444, 1, 0, 0, 0, 16, 447, 1, 0, 0, 0, 18, 451, 1, 0, 0, 0, 20, 454, 1, 0, 0, 0, 22, 457, 1, 0, 0, 0, 24, 464, 1, 0, 0, 0, 26, 480, 1, 0, 0, 0, 28, 482, 1, 0, 0, 0, 30, 484, 1, 0, 0, 0, 32, 494, 1, 0, 0, 0, 34, 496, 1, 0, 0, 0, 36, 519, 1, 0, 0, 0, 38, 523, 1, 0, 0, 0, 40, 541, 1, 0, 0, 0, 42, 568, 1, 0, 0, 0, 44, 591, 1, 0, 0, 0, 46, 627, 1, 0, 0, 0, 48, 629, 1, 0, 0, 0, 50, 637, 1, 0, 0, 0, 52, 639, 1, 0, 0, 0, 54, 646, 1, 0, 0, 0, 56, 658, 1, 0, 0, 0, 58, 661, 1, 0, 0, 0, 60, 663, 1, 0, 0, 0, 62, 676, 1, 0, 0, 0, 64, 684, 1, 0, 0, 0, 66, 686, 1, 0, 0, 0, 68, 694, 1, 0, 0, 0, 70, 710, 1, 0, 0, 0, 72, 716, 1, 0, 0, 0, 74, 719, 1, 0, 0, 0, 76, 768, 1, 0, 0, 0, 78, 773, 1, 0, 0, 0, 80, 778, 1, 0, 0, 0, 82, 783, 1, 0, 0, 0, 84, 791, 1, 0, 0, 0, 86, 796, 1, 0, 0, 0, 88, 901, 1, 0, 0, 0, 90, 929, 1, 0, 0, 0, 92, 931, 1, 0, 0, 0, 94, 935, 1, 0, 0, 0, 96, 937, 1, 0, 0, 0, 98, 942, 1, 0, 0, 0, 100, 970, 1, 0, 0, 0, 102, 1050, 1, 0, 0, 0, 104, 1052, 1, 0, 0, 0, 106, 1081, 1, 0, 0, 0, 108, 1083, 1, 0, 0, 0, 110, 1097, 1, 0, 0, 0, 112, 1126, 1, 0, 0, 0, 114, 1138, 1, 0, 0, 0, 116, 1177, 1, 0, 0, 0, 118, 1185, 1, 0, 0, 0, 120, 1194, 1, 0, 0, 0, 122, 1202, 1, 0, 0, 0, 124, 1221, 1, 0, 0, 0, 126, 1231, 1, 0, 0, 0, 128, 1250, 1, 0, 0, 0, 130, 1344, 1, 0, 0, 0, 132, 1353, 1, 0, 0, 0, 134, 1363, 1, 0, 0, 0, 136, 1365, 1, 0, 0, 0, 138, 1367, 1, 0, 0, 0, 140, 1406, 1, 0, 0, 0, 142, 1466, 1, 0, 0, 0, 144, 1506, 1, 0, 0, 0, 146, 1522, 1, 0, 0, 0, 148, 1524, 1, 0, 0, 0, 150, 1528, 1, 0, 0, 0, 152, 1583, 1, 0, 0, 0, 154, 1595, 1, 0, 0, 0, 156, 1610, 1, 0, 0, 0, 158, 1617, 1, 0, 0, 0, 160, 1622, 1, 0, 0, 0, 162, 1626, 1, 0, 0, 0, 164, 1662, 1, 0, 0, 0, 166, 1664, 1, 0, 0, 0, 168, 1708, 1, 0, 0, 0, 170, 1727, 1, 0, 0, 0, 172, 1748, 1, 0, 0, 0, 174, 1750, 1, 0, 0, 0, 176, 1767, 1, 0, 0, 0, 178, 1782, 1, 0, 0, 0, 180, 1789, 1, 0, 0, 0, 182, 1799, 1, 0, 0, 0, 184, 1812, 1, 0, 0, 0, 186, 1817, 1, 0, 0, 0, 188, 1820, 1, 0, 0, 0, 190, 1831, 1, 0, 0, 0, 192, 1836, 1, 0, 0, 0, 194, 1841, 1, 0, 0, 0, 196, 1845, 1, 0, 0, 0, 198, 1968, 1, 0, 0, 0, 200, 1970, 1, 0, 0, 0, 202, 2007, 1, 0, 0, 0, 204, 2014, 1, 0, 0, 0, 206, 2019, 1, 0, 0, 0, 208, 2026, 1, 0, 0, 0, 210, 2046, 1, 0, 0, 0, 212, 2048, 1, 0, 0, 0, 214, 2053, 1, 0, 0, 0, 216, 2068, 1, 0, 0, 0, 218, 2070, 1, 0, 0, 0, 220, 2083, 1, 0, 0, 0, 222, 2088, 1, 0, 0, 0, 224, 2101, 1, 0, 0, 0, 226, 2109, 1, 0, 0, 0, 228, 2120, 1, 0, 0, 0, 230, 2127, 1, 0, 0, 0, 232, 2147, 1, 0, 0, 0, 234, 2149, 1, 0, 0, 0, 236, 2193, 1, 0, 0, 0, 238, 2213, 1, 0, 0, 0, 240, 2242, 1, 0, 0, 0, 242, 2251, 1, 0, 0, 0, 244, 2274, 1, 0, 0, 0, 246, 2279, 1, 0, 0, 0, 248, 2299, 1, 0, 0, 0, 250, 2399, 1, 0, 0, 0, 252, 2401, 1, 0, 0, 0, 254, 2407, 1, 0, 0, 0, 256, 2409, 1, 0, 0, 0, 258, 2413, 1, 0, 0, 0, 260, 2417, 1, 0, 0, 0, 262, 2433, 1, 0, 0, 0, 264, 2447, 1, 0, 0, 0, 266, 2455, 1, 0, 0, 0, 268, 2457, 1, 0, 0, 0, 270, 2460, 1, 0, 0, 0, 272, 2462, 1, 0, 0, 0, 274, 2475, 1, 0, 0, 0, 276, 2477, 1, 0, 0, 0, 278, 2487, 1, 0, 0, 0, 280, 2492, 1, 0, 0, 0, 282, 2503, 1, 0, 0, 0, 284, 2510, 1, 0, 0, 0, 286, 2520, 1, 0, 0, 0, 288, 2588, 1, 0, 0, 0, 290, 2665, 1, 0, 0, 0, 292, 2672, 1, 0, 0, 0, 294, 2675, 1, 0, 0, 0, 296, 2680, 1, 0, 0, 0, 298, 2830, 1, 0, 0, 0, 300, 2836, 1, 0, 0, 0, 302, 2843, 1, 0, 0, 0, 304, 2849, 1, 0, 0, 0, 306, 2855, 1, 0, 0, 0, 308, 2861, 1, 0, 0, 0, 310, 2867, 1, 0, 0, 0, 312, 2873, 1, 0, 0, 0, 314, 2879, 1, 0, 0, 0, 316, 2885, 1, 0, 0, 0, 318, 2892, 1, 0, 0, 0, 320, 2897, 1, 0, 0, 0, 322, 2903, 1, 0, 0, 0, 324, 2930, 1, 0, 0, 0, 326, 2944, 1, 0, 0, 0, 328, 2949, 1, 0, 0, 0, 330, 2966, 1, 0, 0, 0, 332, 2968, 1, 0, 0, 0, 334, 2978, 1, 0, 0, 0, 336, 3002, 1, 0, 0, 0, 338, 3007, 1, 0, 0, 0, 340, 3023, 1, 0, 0, 0, 342, 3044, 1, 0, 0, 0, 344, 3046, 1, 0, 0, 0, 346, 3051, 1, 0, 0, 0, 348, 3064, 1, 0, 0, 0, 350, 351, 7, 0, 0, 0, 351, 1, 1, 0, 0, 0, 352, 353, 5, 288, 0, 0, 353, 369, 6, 1, -1, 0, 354, 355, 3, 4, 2, 0, 355, 356, 6, 1, -1, 0, 356, 357, 5, 265, 0, 0, 357, 359, 1, 0, 0, 0, 358, 354, 1, 0, 0, 0, 359, 362, 1, 0, 0, 0, 360, 358, 1, 0, 0, 0, 360, 361, 1, 0, 0, 0, 361, 363, 1, 0, 0, 0, 362, 360, 1, 0, 0, 0, 363, 364, 3, 4, 2, 0, 364, 365, 6, 1, -1, 0, 365, 369, 1, 0, 0, 0, 366, 367, 5, 264, 0, 0, 367, 369, 6, 1, -1, 0, 368, 352, 1, 0, 0, 0, 368, 360, 1, 0, 0, 0, 368, 366, 1, 0, 0, 0, 369, 3, 1, 0, 0, 0, 370, 371, 7, 1, 0, 0, 371, 5, 1, 0, 0, 0, 372, 373, 5, 263, 0, 0, 373, 374, 6, 3, -1, 0, 374, 376, 5, 266, 0, 0, 375, 372, 1, 0, 0, 0, 376, 379, 1, 0, 0, 0, 377, 375, 1, 0, 0, 0, 377, 378, 1, 0, 0, 0, 378, 380, 1, 0, 0, 0, 379, 377, 1, 0, 0, 0, 380, 381, 5, 263, 0, 0, 381, 382, 6, 3, -1, 0, 382, 7, 1, 0, 0, 0, 383, 385, 3, 10, 5, 0, 384, 383, 1, 0, 0, 0, 385, 388, 1, 0, 0, 0, 386, 384, 1, 0, 0, 0, 386, 387, 1, 0, 0, 0, 387, 9, 1, 0, 0, 0, 388, 386, 1, 0, 0, 0, 389, 390, 3, 74, 37, 0, 390, 391, 5, 17, 0, 0, 391, 392, 3, 82, 41, 0, 392, 393, 5, 18, 0, 0, 393, 440, 1, 0, 0, 0, 394, 395, 3, 72, 36, 0, 395, 396, 5, 17, 0, 0, 396, 397, 3, 8, 4, 0, 397, 398, 5, 18, 0, 0, 398, 440, 1, 0, 0, 0, 399, 400, 3, 234, 117, 0, 400, 401, 5, 17, 0, 0, 401, 402, 3, 246, 123, 0, 402, 403, 5, 18, 0, 0, 403, 440, 1, 0, 0, 0, 404, 440, 3, 200, 100, 0, 405, 440, 3, 276, 138, 0, 406, 440, 3, 70, 35, 0, 407, 440, 3, 66, 33, 0, 408, 440, 3, 88, 44, 0, 409, 440, 3, 90, 45, 0, 410, 440, 3, 22, 11, 0, 411, 412, 3, 326, 163, 0, 412, 413, 5, 17, 0, 0, 413, 414, 3, 328, 164, 0, 414, 415, 5, 18, 0, 0, 415, 440, 1, 0, 0, 0, 416, 417, 3, 332, 166, 0, 417, 418, 5, 17, 0, 0, 418, 419, 3, 338, 169, 0, 419, 420, 5, 18, 0, 0, 420, 440, 1, 0, 0, 0, 421, 422, 3, 342, 171, 0, 422, 423, 5, 17, 0, 0, 423, 424, 3, 346, 173, 0, 424, 425, 5, 18, 0, 0, 425, 440, 1, 0, 0, 0, 426, 440, 3, 64, 32, 0, 427, 440, 3, 152, 76, 0, 428, 440, 3, 322, 161, 0, 429, 440, 3, 12, 6, 0, 430, 440, 3, 14, 7, 0, 431, 440, 3, 16, 8, 0, 432, 440, 3, 18, 9, 0, 433, 440, 3, 20, 10, 0, 434, 440, 3, 26, 13, 0, 435, 440, 3, 42, 21, 0, 436, 440, 3, 40, 20, 0, 437, 440, 3, 30, 15, 0, 438, 440, 3, 24, 12, 0, 439, 389, 1, 0, 0, 0, 439, 394, 1, 0, 0, 0, 439, 399, 1, 0, 0, 0, 439, 404, 1, 0, 0, 0, 439, 405, 1, 0, 0, 0, 439, 406, 1, 0, 0, 0, 439, 407, 1, 0, 0, 0, 439, 408, 1, 0, 0, 0, 439, 409, 1, 0, 0, 0, 439, 410, 1, 0, 0, 0, 439, 411, 1, 0, 0, 0, 439, 416, 1, 0, 0, 0, 439, 421, 1, 0, 0, 0, 439, 426, 1, 0, 0, 0, 439, 427, 1, 0, 0, 0, 439, 428, 1, 0, 0, 0, 439, 429, 1, 0, 0, 0, 439, 430, 1, 0, 0, 0, 439, 431, 1, 0, 0, 0, 439, 432, 1, 0, 0, 0, 439, 433, 1, 0, 0, 0, 439, 434, 1, 0, 0, 0, 439, 435, 1, 0, 0, 0, 439, 436, 1, 0, 0, 0, 439, 437, 1, 0, 0, 0, 439, 438, 1, 0, 0, 0, 440, 11, 1, 0, 0, 0, 441, 442, 5, 19, 0, 0, 442, 443, 3, 32, 16, 0, 443, 13, 1, 0, 0, 0, 444, 445, 5, 20, 0, 0, 445, 446, 3, 32, 16, 0, 446, 15, 1, 0, 0, 0, 447, 448, 5, 21, 0, 0, 448, 449, 5, 22, 0, 0, 449, 450, 3, 32, 16, 0, 450, 17, 1, 0, 0, 0, 451, 452, 5, 23, 0, 0, 452, 453, 3, 34, 17, 0, 453, 19, 1, 0, 0, 0, 454, 455, 5, 24, 0, 0, 455, 456, 3, 34, 17, 0, 456, 21, 1, 0, 0, 0, 457, 458, 5, 25, 0, 0, 458, 459, 3, 98, 49, 0, 459, 460, 3, 2, 1, 0, 460, 461, 5, 17, 0, 0, 461, 462, 3, 120, 60, 0, 462, 463, 5, 18, 0, 0, 463, 23, 1, 0, 0, 0, 464, 465, 5, 26, 0, 0, 465, 25, 1, 0, 0, 0, 466, 467, 5, 27, 0, 0, 467, 481, 3, 28, 14, 0, 468, 469, 5, 27, 0, 0, 469, 470, 3, 28, 14, 0, 470, 471, 5, 28, 0, 0, 471, 472, 3, 28, 14, 0, 472, 481, 1, 0, 0, 0, 473, 474, 5, 27, 0, 0, 474, 475, 3, 28, 14, 0, 475, 476, 5, 28, 0, 0, 476, 477, 3, 28, 14, 0, 477, 478, 5, 28, 0, 0, 478, 479, 3, 28, 14, 0, 479, 481, 1, 0, 0, 0, 480, 466, 1, 0, 0, 0, 480, 468, 1, 0, 0, 0, 480, 473, 1, 0, 0, 0, 481, 27, 1, 0, 0, 0, 482, 483, 7, 2, 0, 0, 483, 29, 1, 0, 0, 0, 484, 485, 5, 29, 0, 0, 485, 489, 5, 17, 0, 0, 486, 488, 3, 116, 58, 0, 487, 486, 1, 0, 0, 0, 488, 491, 1, 0, 0, 0, 489, 487, 1, 0, 0, 0, 489, 490, 1, 0, 0, 0, 490, 492, 1, 0, 0, 0, 491, 489, 1, 0, 0, 0, 492, 493, 5, 18, 0, 0, 493, 31, 1, 0, 0, 0, 494, 495, 5, 173, 0, 0, 495, 33, 1, 0, 0, 0, 496, 497, 7, 3, 0, 0, 497, 35, 1, 0, 0, 0, 498, 499, 5, 175, 0, 0, 499, 520, 6, 18, -1, 0, 500, 501, 3, 32, 16, 0, 501, 502, 5, 265, 0, 0, 502, 503, 6, 18, -1, 0, 503, 520, 1, 0, 0, 0, 504, 505, 3, 32, 16, 0, 505, 506, 6, 18, -1, 0, 506, 520, 1, 0, 0, 0, 507, 508, 5, 188, 0, 0, 508, 509, 5, 30, 0, 0, 509, 510, 3, 32, 16, 0, 510, 511, 5, 31, 0, 0, 511, 512, 6, 18, -1, 0, 512, 520, 1, 0, 0, 0, 513, 514, 5, 189, 0, 0, 514, 515, 5, 30, 0, 0, 515, 516, 3, 34, 17, 0, 516, 517, 5, 31, 0, 0, 517, 518, 6, 18, -1, 0, 518, 520, 1, 0, 0, 0, 519, 498, 1, 0, 0, 0, 519, 500, 1, 0, 0, 0, 519, 504, 1, 0, 0, 0, 519, 507, 1, 0, 0, 0, 519, 513, 1, 0, 0, 0, 520, 37, 1, 0, 0, 0, 521, 524, 3, 32, 16, 0, 522, 524, 5, 262, 0, 0, 523, 521, 1, 0, 0, 0, 523, 522, 1, 0, 0, 0, 524, 39, 1, 0, 0, 0, 525, 526, 5, 267, 0, 0, 526, 542, 5, 289, 0, 0, 527, 528, 5, 267, 0, 0, 528, 529, 5, 289, 0, 0, 529, 542, 5, 263, 0, 0, 530, 531, 5, 268, 0, 0, 531, 542, 5, 289, 0, 0, 532, 533, 5, 269, 0, 0, 533, 542, 5, 289, 0, 0, 534, 535, 5, 270, 0, 0, 535, 542, 5, 289, 0, 0, 536, 542, 5, 271, 0, 0, 537, 542, 5, 272, 0, 0, 538, 539, 5, 273, 0, 0, 539, 542, 5, 263, 0, 0, 540, 542, 5, 32, 0, 0, 541, 525, 1, 0, 0, 0, 541, 527, 1, 0, 0, 0, 541, 530, 1, 0, 0, 0, 541, 532, 1, 0, 0, 0, 541, 534, 1, 0, 0, 0, 541, 536, 1, 0, 0, 0, 541, 537, 1, 0, 0, 0, 541, 538, 1, 0, 0, 0, 541, 540, 1, 0, 0, 0, 542, 41, 1, 0, 0, 0, 543, 544, 5, 33, 0, 0, 544, 545, 3, 138, 69, 0, 545, 546, 5, 34, 0, 0, 546, 547, 3, 2, 1, 0, 547, 569, 1, 0, 0, 0, 548, 549, 5, 33, 0, 0, 549, 550, 3, 116, 58, 0, 550, 551, 5, 34, 0, 0, 551, 552, 3, 2, 1, 0, 552, 569, 1, 0, 0, 0, 553, 554, 5, 33, 0, 0, 554, 555, 3, 176, 88, 0, 555, 556, 5, 34, 0, 0, 556, 557, 3, 2, 1, 0, 557, 569, 1, 0, 0, 0, 558, 559, 5, 33, 0, 0, 559, 560, 3, 44, 22, 0, 560, 561, 5, 34, 0, 0, 561, 562, 3, 2, 1, 0, 562, 569, 1, 0, 0, 0, 563, 564, 5, 33, 0, 0, 564, 565, 3, 46, 23, 0, 565, 566, 5, 34, 0, 0, 566, 567, 3, 2, 1, 0, 567, 569, 1, 0, 0, 0, 568, 543, 1, 0, 0, 0, 568, 548, 1, 0, 0, 0, 568, 553, 1, 0, 0, 0, 568, 558, 1, 0, 0, 0, 568, 563, 1, 0, 0, 0, 569, 43, 1, 0, 0, 0, 570, 571, 5, 35, 0, 0, 571, 592, 3, 48, 24, 0, 572, 573, 5, 35, 0, 0, 573, 574, 3, 48, 24, 0, 574, 575, 5, 36, 0, 0, 575, 576, 3, 6, 3, 0, 576, 592, 1, 0, 0, 0, 577, 578, 5, 35, 0, 0, 578, 579, 3, 48, 24, 0, 579, 580, 5, 36, 0, 0, 580, 581, 5, 17, 0, 0, 581, 582, 3, 52, 26, 0, 582, 583, 5, 18, 0, 0, 583, 592, 1, 0, 0, 0, 584, 585, 5, 35, 0, 0, 585, 586, 3, 48, 24, 0, 586, 587, 5, 36, 0, 0, 587, 588, 5, 30, 0, 0, 588, 589, 3, 292, 146, 0, 589, 590, 5, 31, 0, 0, 590, 592, 1, 0, 0, 0, 591, 570, 1, 0, 0, 0, 591, 572, 1, 0, 0, 0, 591, 577, 1, 0, 0, 0, 591, 584, 1, 0, 0, 0, 592, 45, 1, 0, 0, 0, 593, 594, 5, 35, 0, 0, 594, 595, 5, 30, 0, 0, 595, 596, 3, 50, 25, 0, 596, 597, 5, 31, 0, 0, 597, 598, 3, 48, 24, 0, 598, 628, 1, 0, 0, 0, 599, 600, 5, 35, 0, 0, 600, 601, 5, 30, 0, 0, 601, 602, 3, 50, 25, 0, 602, 603, 5, 31, 0, 0, 603, 604, 3, 48, 24, 0, 604, 605, 5, 36, 0, 0, 605, 606, 3, 6, 3, 0, 606, 628, 1, 0, 0, 0, 607, 608, 5, 35, 0, 0, 608, 609, 5, 30, 0, 0, 609, 610, 3, 50, 25, 0, 610, 611, 5, 31, 0, 0, 611, 612, 3, 48, 24, 0, 612, 613, 5, 36, 0, 0, 613, 614, 5, 17, 0, 0, 614, 615, 3, 52, 26, 0, 615, 616, 5, 18, 0, 0, 616, 628, 1, 0, 0, 0, 617, 618, 5, 35, 0, 0, 618, 619, 5, 30, 0, 0, 619, 620, 3, 50, 25, 0, 620, 621, 5, 31, 0, 0, 621, 622, 3, 48, 24, 0, 622, 623, 5, 36, 0, 0, 623, 624, 5, 30, 0, 0, 624, 625, 3, 292, 146, 0, 625, 626, 5, 31, 0, 0, 626, 628, 1, 0, 0, 0, 627, 593, 1, 0, 0, 0, 627, 599, 1, 0, 0, 0, 627, 607, 1, 0, 0, 0, 627, 617, 1, 0, 0, 0, 628, 47, 1, 0, 0, 0, 629, 630, 3, 168, 84, 0, 630, 49, 1, 0, 0, 0, 631, 632, 3, 124, 62, 0, 632, 633, 6, 25, -1, 0, 633, 638, 1, 0, 0, 0, 634, 635, 3, 176, 88, 0, 635, 636, 6, 25, -1, 0, 636, 638, 1, 0, 0, 0, 637, 631, 1, 0, 0, 0, 637, 634, 1, 0, 0, 0, 638, 51, 1, 0, 0, 0, 639, 640, 3, 54, 27, 0, 640, 641, 3, 56, 28, 0, 641, 53, 1, 0, 0, 0, 642, 645, 3, 298, 149, 0, 643, 645, 3, 40, 20, 0, 644, 642, 1, 0, 0, 0, 644, 643, 1, 0, 0, 0, 645, 648, 1, 0, 0, 0, 646, 644, 1, 0, 0, 0, 646, 647, 1, 0, 0, 0, 647, 55, 1, 0, 0, 0, 648, 646, 1, 0, 0, 0, 649, 650, 3, 58, 29, 0, 650, 651, 3, 60, 30, 0, 651, 652, 3, 2, 1, 0, 652, 653, 5, 36, 0, 0, 653, 654, 3, 298, 149, 0, 654, 657, 1, 0, 0, 0, 655, 657, 3, 40, 20, 0, 656, 649, 1, 0, 0, 0, 656, 655, 1, 0, 0, 0, 657, 660, 1, 0, 0, 0, 658, 656, 1, 0, 0, 0, 658, 659, 1, 0, 0, 0, 659, 57, 1, 0, 0, 0, 660, 658, 1, 0, 0, 0, 661, 662, 7, 4, 0, 0, 662, 59, 1, 0, 0, 0, 663, 665, 3, 62, 31, 0, 664, 666, 5, 261, 0, 0, 665, 664, 1, 0, 0, 0, 665, 666, 1, 0, 0, 0, 666, 61, 1, 0, 0, 0, 667, 677, 3, 144, 72, 0, 668, 677, 3, 2, 1, 0, 669, 677, 5, 196, 0, 0, 670, 677, 5, 197, 0, 0, 671, 672, 5, 202, 0, 0, 672, 673, 5, 39, 0, 0, 673, 677, 5, 264, 0, 0, 674, 675, 5, 202, 0, 0, 675, 677, 3, 116, 58, 0, 676, 667, 1, 0, 0, 0, 676, 668, 1, 0, 0, 0, 676, 669, 1, 0, 0, 0, 676, 670, 1, 0, 0, 0, 676, 671, 1, 0, 0, 0, 676, 674, 1, 0, 0, 0, 677, 63, 1, 0, 0, 0, 678, 679, 5, 198, 0, 0, 679, 680, 5, 40, 0, 0, 680, 685, 3, 2, 1, 0, 681, 682, 5, 198, 0, 0, 682, 685, 3, 2, 1, 0, 683, 685, 5, 198, 0, 0, 684, 678, 1, 0, 0, 0, 684, 681, 1, 0, 0, 0, 684, 683, 1, 0, 0, 0, 685, 65, 1, 0, 0, 0, 686, 687, 5, 41, 0, 0, 687, 688, 5, 42, 0, 0, 688, 689, 3, 32, 16, 0, 689, 690, 5, 43, 0, 0, 690, 691, 3, 68, 34, 0, 691, 692, 5, 44, 0, 0, 692, 693, 3, 0, 0, 0, 693, 67, 1, 0, 0, 0, 694, 707, 6, 34, -1, 0, 695, 696, 10, 5, 0, 0, 696, 706, 5, 186, 0, 0, 697, 698, 10, 4, 0, 0, 698, 706, 5, 187, 0, 0, 699, 700, 10, 3, 0, 0, 700, 706, 5, 45, 0, 0, 701, 702, 10, 2, 0, 0, 702, 706, 5, 46, 0, 0, 703, 704, 10, 1, 0, 0, 704, 706, 5, 47, 0, 0, 705, 695, 1, 0, 0, 0, 705, 697, 1, 0, 0, 0, 705, 699, 1, 0, 0, 0, 705, 701, 1, 0, 0, 0, 705, 703, 1, 0, 0, 0, 706, 709, 1, 0, 0, 0, 707, 705, 1, 0, 0, 0, 707, 708, 1, 0, 0, 0, 708, 69, 1, 0, 0, 0, 709, 707, 1, 0, 0, 0, 710, 711, 5, 48, 0, 0, 711, 712, 5, 36, 0, 0, 712, 713, 5, 30, 0, 0, 713, 714, 3, 292, 146, 0, 714, 715, 5, 31, 0, 0, 715, 71, 1, 0, 0, 0, 716, 717, 5, 49, 0, 0, 717, 718, 3, 2, 1, 0, 718, 73, 1, 0, 0, 0, 719, 723, 5, 50, 0, 0, 720, 722, 3, 76, 38, 0, 721, 720, 1, 0, 0, 0, 722, 725, 1, 0, 0, 0, 723, 721, 1, 0, 0, 0, 723, 724, 1, 0, 0, 0, 724, 726, 1, 0, 0, 0, 725, 723, 1, 0, 0, 0, 726, 727, 3, 2, 1, 0, 727, 728, 3, 182, 91, 0, 728, 729, 3, 78, 39, 0, 729, 730, 3, 80, 40, 0, 730, 75, 1, 0, 0, 0, 731, 769, 5, 51, 0, 0, 732, 769, 5, 52, 0, 0, 733, 769, 5, 199, 0, 0, 734, 769, 5, 202, 0, 0, 735, 769, 5, 221, 0, 0, 736, 769, 5, 53, 0, 0, 737, 769, 5, 54, 0, 0, 738, 769, 5, 55, 0, 0, 739, 769, 5, 56, 0, 0, 740, 769, 5, 244, 0, 0, 741, 769, 5, 15, 0, 0, 742, 769, 5, 224, 0, 0, 743, 769, 5, 57, 0, 0, 744, 769, 5, 58, 0, 0, 745, 769, 5, 59, 0, 0, 746, 769, 5, 60, 0, 0, 747, 769, 5, 61, 0, 0, 748, 749, 5, 62, 0, 0, 749, 769, 5, 51, 0, 0, 750, 751, 5, 62, 0, 0, 751, 769, 5, 52, 0, 0, 752, 753, 5, 62, 0, 0, 753, 769, 5, 63, 0, 0, 754, 755, 5, 62, 0, 0, 755, 769, 5, 64, 0, 0, 756, 757, 5, 62, 0, 0, 757, 769, 5, 65, 0, 0, 758, 759, 5, 62, 0, 0, 759, 769, 5, 66, 0, 0, 760, 769, 5, 67, 0, 0, 761, 769, 5, 68, 0, 0, 762, 769, 5, 69, 0, 0, 763, 764, 5, 70, 0, 0, 764, 765, 5, 30, 0, 0, 765, 766, 3, 32, 16, 0, 766, 767, 5, 31, 0, 0, 767, 769, 1, 0, 0, 0, 768, 731, 1, 0, 0, 0, 768, 732, 1, 0, 0, 0, 768, 733, 1, 0, 0, 0, 768, 734, 1, 0, 0, 0, 768, 735, 1, 0, 0, 0, 768, 736, 1, 0, 0, 0, 768, 737, 1, 0, 0, 0, 768, 738, 1, 0, 0, 0, 768, 739, 1, 0, 0, 0, 768, 740, 1, 0, 0, 0, 768, 741, 1, 0, 0, 0, 768, 742, 1, 0, 0, 0, 768, 743, 1, 0, 0, 0, 768, 744, 1, 0, 0, 0, 768, 745, 1, 0, 0, 0, 768, 746, 1, 0, 0, 0, 768, 747, 1, 0, 0, 0, 768, 748, 1, 0, 0, 0, 768, 750, 1, 0, 0, 0, 768, 752, 1, 0, 0, 0, 768, 754, 1, 0, 0, 0, 768, 756, 1, 0, 0, 0, 768, 758, 1, 0, 0, 0, 768, 760, 1, 0, 0, 0, 768, 761, 1, 0, 0, 0, 768, 762, 1, 0, 0, 0, 768, 763, 1, 0, 0, 0, 769, 77, 1, 0, 0, 0, 770, 774, 1, 0, 0, 0, 771, 772, 5, 71, 0, 0, 772, 774, 3, 124, 62, 0, 773, 770, 1, 0, 0, 0, 773, 771, 1, 0, 0, 0, 774, 79, 1, 0, 0, 0, 775, 779, 1, 0, 0, 0, 776, 777, 5, 72, 0, 0, 777, 779, 3, 84, 42, 0, 778, 775, 1, 0, 0, 0, 778, 776, 1, 0, 0, 0, 779, 81, 1, 0, 0, 0, 780, 782, 3, 198, 99, 0, 781, 780, 1, 0, 0, 0, 782, 785, 1, 0, 0, 0, 783, 781, 1, 0, 0, 0, 783, 784, 1, 0, 0, 0, 784, 83, 1, 0, 0, 0, 785, 783, 1, 0, 0, 0, 786, 787, 3, 124, 62, 0, 787, 788, 5, 28, 0, 0, 788, 790, 1, 0, 0, 0, 789, 786, 1, 0, 0, 0, 790, 793, 1, 0, 0, 0, 791, 789, 1, 0, 0, 0, 791, 792, 1, 0, 0, 0, 792, 794, 1, 0, 0, 0, 793, 791, 1, 0, 0, 0, 794, 795, 3, 124, 62, 0, 795, 85, 1, 0, 0, 0, 796, 797, 7, 5, 0, 0, 797, 87, 1, 0, 0, 0, 798, 799, 3, 86, 43, 0, 799, 800, 3, 32, 16, 0, 800, 801, 5, 264, 0, 0, 801, 902, 1, 0, 0, 0, 802, 803, 3, 86, 43, 0, 803, 804, 3, 32, 16, 0, 804, 902, 1, 0, 0, 0, 805, 806, 3, 86, 43, 0, 806, 807, 3, 32, 16, 0, 807, 808, 5, 75, 0, 0, 808, 809, 3, 32, 16, 0, 809, 810, 5, 264, 0, 0, 810, 902, 1, 0, 0, 0, 811, 812, 3, 86, 43, 0, 812, 813, 3, 32, 16, 0, 813, 814, 5, 75, 0, 0, 814, 815, 3, 32, 16, 0, 815, 902, 1, 0, 0, 0, 816, 817, 3, 86, 43, 0, 817, 818, 3, 32, 16, 0, 818, 819, 5, 75, 0, 0, 819, 820, 3, 32, 16, 0, 820, 821, 5, 28, 0, 0, 821, 822, 3, 32, 16, 0, 822, 823, 5, 264, 0, 0, 823, 902, 1, 0, 0, 0, 824, 825, 3, 86, 43, 0, 825, 826, 3, 32, 16, 0, 826, 827, 5, 75, 0, 0, 827, 828, 3, 32, 16, 0, 828, 829, 5, 28, 0, 0, 829, 830, 3, 32, 16, 0, 830, 902, 1, 0, 0, 0, 831, 832, 3, 86, 43, 0, 832, 833, 3, 32, 16, 0, 833, 834, 5, 28, 0, 0, 834, 835, 3, 32, 16, 0, 835, 836, 5, 75, 0, 0, 836, 837, 3, 32, 16, 0, 837, 838, 5, 264, 0, 0, 838, 902, 1, 0, 0, 0, 839, 840, 3, 86, 43, 0, 840, 841, 3, 32, 16, 0, 841, 842, 5, 28, 0, 0, 842, 843, 3, 32, 16, 0, 843, 844, 5, 75, 0, 0, 844, 845, 3, 32, 16, 0, 845, 902, 1, 0, 0, 0, 846, 847, 3, 86, 43, 0, 847, 848, 3, 32, 16, 0, 848, 849, 5, 28, 0, 0, 849, 850, 3, 32, 16, 0, 850, 851, 5, 75, 0, 0, 851, 852, 3, 32, 16, 0, 852, 853, 5, 28, 0, 0, 853, 854, 3, 32, 16, 0, 854, 855, 5, 264, 0, 0, 855, 902, 1, 0, 0, 0, 856, 857, 3, 86, 43, 0, 857, 858, 3, 32, 16, 0, 858, 859, 5, 28, 0, 0, 859, 860, 3, 32, 16, 0, 860, 861, 5, 75, 0, 0, 861, 862, 3, 32, 16, 0, 862, 863, 5, 28, 0, 0, 863, 864, 3, 32, 16, 0, 864, 902, 1, 0, 0, 0, 865, 866, 3, 86, 43, 0, 866, 867, 3, 32, 16, 0, 867, 868, 5, 263, 0, 0, 868, 902, 1, 0, 0, 0, 869, 870, 3, 86, 43, 0, 870, 871, 3, 32, 16, 0, 871, 872, 5, 75, 0, 0, 872, 873, 3, 32, 16, 0, 873, 874, 5, 263, 0, 0, 874, 902, 1, 0, 0, 0, 875, 876, 3, 86, 43, 0, 876, 877, 3, 32, 16, 0, 877, 878, 5, 75, 0, 0, 878, 879, 3, 32, 16, 0, 879, 880, 5, 28, 0, 0, 880, 881, 3, 32, 16, 0, 881, 882, 5, 263, 0, 0, 882, 902, 1, 0, 0, 0, 883, 884, 3, 86, 43, 0, 884, 885, 3, 32, 16, 0, 885, 886, 5, 28, 0, 0, 886, 887, 3, 32, 16, 0, 887, 888, 5, 75, 0, 0, 888, 889, 3, 32, 16, 0, 889, 890, 5, 263, 0, 0, 890, 902, 1, 0, 0, 0, 891, 892, 3, 86, 43, 0, 892, 893, 3, 32, 16, 0, 893, 894, 5, 28, 0, 0, 894, 895, 3, 32, 16, 0, 895, 896, 5, 75, 0, 0, 896, 897, 3, 32, 16, 0, 897, 898, 5, 28, 0, 0, 898, 899, 3, 32, 16, 0, 899, 900, 5, 263, 0, 0, 900, 902, 1, 0, 0, 0, 901, 798, 1, 0, 0, 0, 901, 802, 1, 0, 0, 0, 901, 805, 1, 0, 0, 0, 901, 811, 1, 0, 0, 0, 901, 816, 1, 0, 0, 0, 901, 824, 1, 0, 0, 0, 901, 831, 1, 0, 0, 0, 901, 839, 1, 0, 0, 0, 901, 846, 1, 0, 0, 0, 901, 856, 1, 0, 0, 0, 901, 865, 1, 0, 0, 0, 901, 869, 1, 0, 0, 0, 901, 875, 1, 0, 0, 0, 901, 883, 1, 0, 0, 0, 901, 891, 1, 0, 0, 0, 902, 89, 1, 0, 0, 0, 903, 907, 5, 21, 0, 0, 904, 906, 3, 92, 46, 0, 905, 904, 1, 0, 0, 0, 906, 909, 1, 0, 0, 0, 907, 905, 1, 0, 0, 0, 907, 908, 1, 0, 0, 0, 908, 910, 1, 0, 0, 0, 909, 907, 1, 0, 0, 0, 910, 911, 3, 2, 1, 0, 911, 912, 3, 94, 47, 0, 912, 913, 5, 180, 0, 0, 913, 914, 5, 36, 0, 0, 914, 915, 5, 30, 0, 0, 915, 916, 3, 292, 146, 0, 916, 917, 5, 31, 0, 0, 917, 918, 3, 94, 47, 0, 918, 930, 1, 0, 0, 0, 919, 923, 5, 21, 0, 0, 920, 922, 3, 92, 46, 0, 921, 920, 1, 0, 0, 0, 922, 925, 1, 0, 0, 0, 923, 921, 1, 0, 0, 0, 923, 924, 1, 0, 0, 0, 924, 926, 1, 0, 0, 0, 925, 923, 1, 0, 0, 0, 926, 927, 3, 2, 1, 0, 927, 928, 3, 94, 47, 0, 928, 930, 1, 0, 0, 0, 929, 903, 1, 0, 0, 0, 929, 919, 1, 0, 0, 0, 930, 91, 1, 0, 0, 0, 931, 932, 5, 76, 0, 0, 932, 93, 1, 0, 0, 0, 933, 936, 1, 0, 0, 0, 934, 936, 5, 298, 0, 0, 935, 933, 1, 0, 0, 0, 935, 934, 1, 0, 0, 0, 936, 95, 1, 0, 0, 0, 937, 938, 7, 6, 0, 0, 938, 97, 1, 0, 0, 0, 939, 941, 3, 96, 48, 0, 940, 939, 1, 0, 0, 0, 941, 944, 1, 0, 0, 0, 942, 940, 1, 0, 0, 0, 942, 943, 1, 0, 0, 0, 943, 99, 1, 0, 0, 0, 944, 942, 1, 0, 0, 0, 945, 971, 3, 102, 51, 0, 946, 947, 5, 280, 0, 0, 947, 948, 3, 168, 84, 0, 948, 949, 6, 50, -1, 0, 949, 971, 1, 0, 0, 0, 950, 951, 5, 286, 0, 0, 951, 952, 3, 178, 89, 0, 952, 953, 6, 50, -1, 0, 953, 971, 1, 0, 0, 0, 954, 955, 5, 286, 0, 0, 955, 956, 3, 174, 87, 0, 956, 957, 6, 50, -1, 0, 957, 971, 1, 0, 0, 0, 958, 959, 5, 284, 0, 0, 959, 960, 3, 124, 62, 0, 960, 961, 6, 50, -1, 0, 961, 971, 1, 0, 0, 0, 962, 963, 5, 281, 0, 0, 963, 964, 3, 104, 52, 0, 964, 965, 6, 50, -1, 0, 965, 971, 1, 0, 0, 0, 966, 967, 5, 287, 0, 0, 967, 968, 3, 50, 25, 0, 968, 969, 6, 50, -1, 0, 969, 971, 1, 0, 0, 0, 970, 945, 1, 0, 0, 0, 970, 946, 1, 0, 0, 0, 970, 950, 1, 0, 0, 0, 970, 954, 1, 0, 0, 0, 970, 958, 1, 0, 0, 0, 970, 962, 1, 0, 0, 0, 970, 966, 1, 0, 0, 0, 971, 101, 1, 0, 0, 0, 972, 973, 5, 275, 0, 0, 973, 1051, 6, 51, -1, 0, 974, 975, 5, 276, 0, 0, 975, 976, 3, 32, 16, 0, 976, 977, 6, 51, -1, 0, 977, 1051, 1, 0, 0, 0, 978, 979, 5, 276, 0, 0, 979, 980, 3, 0, 0, 0, 980, 981, 6, 51, -1, 0, 981, 1051, 1, 0, 0, 0, 982, 983, 5, 277, 0, 0, 983, 984, 3, 32, 16, 0, 984, 985, 6, 51, -1, 0, 985, 1051, 1, 0, 0, 0, 986, 987, 5, 278, 0, 0, 987, 988, 3, 34, 17, 0, 988, 989, 6, 51, -1, 0, 989, 1051, 1, 0, 0, 0, 990, 991, 5, 279, 0, 0, 991, 992, 3, 36, 18, 0, 992, 993, 6, 51, -1, 0, 993, 1051, 1, 0, 0, 0, 994, 995, 5, 279, 0, 0, 995, 996, 3, 34, 17, 0, 996, 997, 6, 51, -1, 0, 997, 1051, 1, 0, 0, 0, 998, 999, 5, 279, 0, 0, 999, 1000, 5, 30, 0, 0, 1000, 1001, 3, 292, 146, 0, 1001, 1002, 5, 31, 0, 0, 1002, 1003, 6, 51, -1, 0, 1003, 1051, 1, 0, 0, 0, 1004, 1005, 5, 279, 0, 0, 1005, 1006, 5, 84, 0, 0, 1006, 1007, 5, 30, 0, 0, 1007, 1008, 3, 292, 146, 0, 1008, 1009, 5, 31, 0, 0, 1009, 1010, 6, 51, -1, 0, 1010, 1051, 1, 0, 0, 0, 1011, 1012, 5, 282, 0, 0, 1012, 1013, 3, 32, 16, 0, 1013, 1014, 6, 51, -1, 0, 1014, 1051, 1, 0, 0, 0, 1015, 1016, 5, 282, 0, 0, 1016, 1017, 3, 0, 0, 0, 1017, 1018, 6, 51, -1, 0, 1018, 1051, 1, 0, 0, 0, 1019, 1020, 5, 285, 0, 0, 1020, 1021, 3, 6, 3, 0, 1021, 1022, 6, 51, -1, 0, 1022, 1051, 1, 0, 0, 0, 1023, 1024, 5, 285, 0, 0, 1024, 1025, 5, 224, 0, 0, 1025, 1026, 5, 30, 0, 0, 1026, 1027, 3, 6, 3, 0, 1027, 1028, 5, 31, 0, 0, 1028, 1029, 6, 51, -1, 0, 1029, 1051, 1, 0, 0, 0, 1030, 1031, 5, 285, 0, 0, 1031, 1032, 5, 84, 0, 0, 1032, 1033, 5, 30, 0, 0, 1033, 1034, 3, 292, 146, 0, 1034, 1035, 5, 31, 0, 0, 1035, 1036, 6, 51, -1, 0, 1036, 1051, 1, 0, 0, 0, 1037, 1038, 5, 287, 0, 0, 1038, 1039, 3, 32, 16, 0, 1039, 1040, 6, 51, -1, 0, 1040, 1051, 1, 0, 0, 0, 1041, 1042, 5, 283, 0, 0, 1042, 1048, 6, 51, -1, 0, 1043, 1044, 5, 30, 0, 0, 1044, 1045, 3, 106, 53, 0, 1045, 1046, 5, 31, 0, 0, 1046, 1049, 1, 0, 0, 0, 1047, 1049, 5, 85, 0, 0, 1048, 1043, 1, 0, 0, 0, 1048, 1047, 1, 0, 0, 0, 1049, 1051, 1, 0, 0, 0, 1050, 972, 1, 0, 0, 0, 1050, 974, 1, 0, 0, 0, 1050, 978, 1, 0, 0, 0, 1050, 982, 1, 0, 0, 0, 1050, 986, 1, 0, 0, 0, 1050, 990, 1, 0, 0, 0, 1050, 994, 1, 0, 0, 0, 1050, 998, 1, 0, 0, 0, 1050, 1004, 1, 0, 0, 0, 1050, 1011, 1, 0, 0, 0, 1050, 1015, 1, 0, 0, 0, 1050, 1019, 1, 0, 0, 0, 1050, 1023, 1, 0, 0, 0, 1050, 1030, 1, 0, 0, 0, 1050, 1037, 1, 0, 0, 0, 1050, 1041, 1, 0, 0, 0, 1051, 103, 1, 0, 0, 0, 1052, 1053, 3, 170, 85, 0, 1053, 1054, 3, 138, 69, 0, 1054, 1055, 3, 112, 56, 0, 1055, 1056, 6, 52, -1, 0, 1056, 105, 1, 0, 0, 0, 1057, 1082, 1, 0, 0, 0, 1058, 1059, 3, 0, 0, 0, 1059, 1060, 6, 53, -1, 0, 1060, 1065, 1, 0, 0, 0, 1061, 1062, 3, 32, 16, 0, 1062, 1063, 6, 53, -1, 0, 1063, 1065, 1, 0, 0, 0, 1064, 1058, 1, 0, 0, 0, 1064, 1061, 1, 0, 0, 0, 1065, 1066, 1, 0, 0, 0, 1066, 1067, 5, 28, 0, 0, 1067, 1069, 1, 0, 0, 0, 1068, 1064, 1, 0, 0, 0, 1069, 1072, 1, 0, 0, 0, 1070, 1068, 1, 0, 0, 0, 1070, 1071, 1, 0, 0, 0, 1071, 1079, 1, 0, 0, 0, 1072, 1070, 1, 0, 0, 0, 1073, 1074, 3, 0, 0, 0, 1074, 1075, 6, 53, -1, 0, 1075, 1080, 1, 0, 0, 0, 1076, 1077, 3, 32, 16, 0, 1077, 1078, 6, 53, -1, 0, 1078, 1080, 1, 0, 0, 0, 1079, 1073, 1, 0, 0, 0, 1079, 1076, 1, 0, 0, 0, 1080, 1082, 1, 0, 0, 0, 1081, 1057, 1, 0, 0, 0, 1081, 1070, 1, 0, 0, 0, 1082, 107, 1, 0, 0, 0, 1083, 1090, 5, 86, 0, 0, 1084, 1085, 3, 138, 69, 0, 1085, 1086, 6, 54, -1, 0, 1086, 1087, 5, 28, 0, 0, 1087, 1089, 1, 0, 0, 0, 1088, 1084, 1, 0, 0, 0, 1089, 1092, 1, 0, 0, 0, 1090, 1088, 1, 0, 0, 0, 1090, 1091, 1, 0, 0, 0, 1091, 1093, 1, 0, 0, 0, 1092, 1090, 1, 0, 0, 0, 1093, 1094, 3, 138, 69, 0, 1094, 1095, 6, 54, -1, 0, 1095, 1096, 5, 87, 0, 0, 1096, 109, 1, 0, 0, 0, 1097, 1104, 5, 42, 0, 0, 1098, 1099, 3, 146, 73, 0, 1099, 1100, 6, 55, -1, 0, 1100, 1101, 5, 28, 0, 0, 1101, 1103, 1, 0, 0, 0, 1102, 1098, 1, 0, 0, 0, 1103, 1106, 1, 0, 0, 0, 1104, 1102, 1, 0, 0, 0, 1104, 1105, 1, 0, 0, 0, 1105, 1107, 1, 0, 0, 0, 1106, 1104, 1, 0, 0, 0, 1107, 1108, 3, 146, 73, 0, 1108, 1109, 6, 55, -1, 0, 1109, 1110, 5, 43, 0, 0, 1110, 111, 1, 0, 0, 0, 1111, 1118, 5, 30, 0, 0, 1112, 1113, 3, 114, 57, 0, 1113, 1114, 6, 56, -1, 0, 1114, 1115, 5, 28, 0, 0, 1115, 1117, 1, 0, 0, 0, 1116, 1112, 1, 0, 0, 0, 1117, 1120, 1, 0, 0, 0, 1118, 1116, 1, 0, 0, 0, 1118, 1119, 1, 0, 0, 0, 1119, 1121, 1, 0, 0, 0, 1120, 1118, 1, 0, 0, 0, 1121, 1122, 3, 114, 57, 0, 1122, 1123, 6, 56, -1, 0, 1123, 1124, 5, 31, 0, 0, 1124, 1127, 1, 0, 0, 0, 1125, 1127, 5, 85, 0, 0, 1126, 1111, 1, 0, 0, 0, 1126, 1125, 1, 0, 0, 0, 1127, 113, 1, 0, 0, 0, 1128, 1129, 5, 177, 0, 0, 1129, 1139, 6, 57, -1, 0, 1130, 1131, 3, 230, 115, 0, 1131, 1132, 3, 138, 69, 0, 1132, 1134, 3, 226, 113, 0, 1133, 1135, 3, 0, 0, 0, 1134, 1133, 1, 0, 0, 0, 1134, 1135, 1, 0, 0, 0, 1135, 1136, 1, 0, 0, 0, 1136, 1137, 6, 57, -1, 0, 1137, 1139, 1, 0, 0, 0, 1138, 1128, 1, 0, 0, 0, 1138, 1130, 1, 0, 0, 0, 1139, 115, 1, 0, 0, 0, 1140, 1141, 5, 42, 0, 0, 1141, 1142, 3, 2, 1, 0, 1142, 1143, 5, 43, 0, 0, 1143, 1144, 3, 118, 59, 0, 1144, 1145, 6, 58, -1, 0, 1145, 1178, 1, 0, 0, 0, 1146, 1147, 5, 42, 0, 0, 1147, 1148, 3, 174, 87, 0, 1148, 1149, 5, 43, 0, 0, 1149, 1150, 3, 118, 59, 0, 1150, 1151, 6, 58, -1, 0, 1151, 1178, 1, 0, 0, 0, 1152, 1153, 5, 42, 0, 0, 1153, 1154, 5, 262, 0, 0, 1154, 1155, 5, 43, 0, 0, 1155, 1156, 3, 118, 59, 0, 1156, 1157, 6, 58, -1, 0, 1157, 1178, 1, 0, 0, 0, 1158, 1159, 5, 42, 0, 0, 1159, 1160, 5, 198, 0, 0, 1160, 1161, 3, 2, 1, 0, 1161, 1162, 5, 43, 0, 0, 1162, 1163, 3, 118, 59, 0, 1163, 1164, 6, 58, -1, 0, 1164, 1178, 1, 0, 0, 0, 1165, 1166, 3, 118, 59, 0, 1166, 1167, 6, 58, -1, 0, 1167, 1178, 1, 0, 0, 0, 1168, 1169, 3, 174, 87, 0, 1169, 1170, 6, 58, -1, 0, 1170, 1178, 1, 0, 0, 0, 1171, 1172, 5, 257, 0, 0, 1172, 1178, 6, 58, -1, 0, 1173, 1174, 5, 258, 0, 0, 1174, 1178, 6, 58, -1, 0, 1175, 1176, 5, 259, 0, 0, 1176, 1178, 6, 58, -1, 0, 1177, 1140, 1, 0, 0, 0, 1177, 1146, 1, 0, 0, 0, 1177, 1152, 1, 0, 0, 0, 1177, 1158, 1, 0, 0, 0, 1177, 1165, 1, 0, 0, 0, 1177, 1168, 1, 0, 0, 0, 1177, 1171, 1, 0, 0, 0, 1177, 1173, 1, 0, 0, 0, 1177, 1175, 1, 0, 0, 0, 1178, 117, 1, 0, 0, 0, 1179, 1180, 3, 2, 1, 0, 1180, 1181, 6, 59, -1, 0, 1181, 1182, 5, 88, 0, 0, 1182, 1184, 1, 0, 0, 0, 1183, 1179, 1, 0, 0, 0, 1184, 1187, 1, 0, 0, 0, 1185, 1183, 1, 0, 0, 0, 1185, 1186, 1, 0, 0, 0, 1186, 1188, 1, 0, 0, 0, 1187, 1185, 1, 0, 0, 0, 1188, 1189, 3, 2, 1, 0, 1189, 1190, 6, 59, -1, 0, 1190, 119, 1, 0, 0, 0, 1191, 1193, 3, 122, 61, 0, 1192, 1191, 1, 0, 0, 0, 1193, 1196, 1, 0, 0, 0, 1194, 1192, 1, 0, 0, 0, 1194, 1195, 1, 0, 0, 0, 1195, 121, 1, 0, 0, 0, 1196, 1194, 1, 0, 0, 0, 1197, 1198, 5, 180, 0, 0, 1198, 1199, 5, 89, 0, 0, 1199, 1203, 3, 32, 16, 0, 1200, 1203, 3, 152, 76, 0, 1201, 1203, 3, 324, 162, 0, 1202, 1197, 1, 0, 0, 0, 1202, 1200, 1, 0, 0, 0, 1202, 1201, 1, 0, 0, 0, 1203, 123, 1, 0, 0, 0, 1204, 1205, 3, 116, 58, 0, 1205, 1206, 6, 62, -1, 0, 1206, 1222, 1, 0, 0, 0, 1207, 1208, 5, 42, 0, 0, 1208, 1209, 3, 2, 1, 0, 1209, 1210, 5, 43, 0, 0, 1210, 1211, 6, 62, -1, 0, 1211, 1222, 1, 0, 0, 0, 1212, 1213, 5, 42, 0, 0, 1213, 1214, 5, 198, 0, 0, 1214, 1215, 3, 2, 1, 0, 1215, 1216, 5, 43, 0, 0, 1216, 1217, 6, 62, -1, 0, 1217, 1222, 1, 0, 0, 0, 1218, 1219, 3, 138, 69, 0, 1219, 1220, 6, 62, -1, 0, 1220, 1222, 1, 0, 0, 0, 1221, 1204, 1, 0, 0, 0, 1221, 1207, 1, 0, 0, 0, 1221, 1212, 1, 0, 0, 0, 1221, 1218, 1, 0, 0, 0, 1222, 125, 1, 0, 0, 0, 1223, 1232, 1, 0, 0, 0, 1224, 1228, 3, 130, 65, 0, 1225, 1227, 3, 128, 64, 0, 1226, 1225, 1, 0, 0, 0, 1227, 1230, 1, 0, 0, 0, 1228, 1226, 1, 0, 0, 0, 1228, 1229, 1, 0, 0, 0, 1229, 1232, 1, 0, 0, 0, 1230, 1228, 1, 0, 0, 0, 1231, 1223, 1, 0, 0, 0, 1231, 1224, 1, 0, 0, 0, 1232, 127, 1, 0, 0, 0, 1233, 1251, 5, 262, 0, 0, 1234, 1251, 5, 261, 0, 0, 1235, 1236, 5, 42, 0, 0, 1236, 1237, 3, 32, 16, 0, 1237, 1238, 5, 43, 0, 0, 1238, 1251, 1, 0, 0, 0, 1239, 1240, 5, 42, 0, 0, 1240, 1241, 3, 32, 16, 0, 1241, 1242, 5, 266, 0, 0, 1242, 1243, 3, 32, 16, 0, 1243, 1244, 5, 43, 0, 0, 1244, 1251, 1, 0, 0, 0, 1245, 1246, 5, 42, 0, 0, 1246, 1247, 5, 266, 0, 0, 1247, 1248, 3, 32, 16, 0, 1248, 1249, 5, 43, 0, 0, 1249, 1251, 1, 0, 0, 0, 1250, 1233, 1, 0, 0, 0, 1250, 1234, 1, 0, 0, 0, 1250, 1235, 1, 0, 0, 0, 1250, 1239, 1, 0, 0, 0, 1250, 1245, 1, 0, 0, 0, 1251, 129, 1, 0, 0, 0, 1252, 1345, 1, 0, 0, 0, 1253, 1254, 5, 203, 0, 0, 1254, 1255, 5, 30, 0, 0, 1255, 1256, 3, 6, 3, 0, 1256, 1257, 5, 28, 0, 0, 1257, 1258, 3, 6, 3, 0, 1258, 1259, 5, 28, 0, 0, 1259, 1260, 3, 6, 3, 0, 1260, 1261, 5, 28, 0, 0, 1261, 1262, 3, 6, 3, 0, 1262, 1263, 5, 31, 0, 0, 1263, 1345, 1, 0, 0, 0, 1264, 1265, 5, 203, 0, 0, 1265, 1266, 5, 30, 0, 0, 1266, 1267, 3, 6, 3, 0, 1267, 1268, 5, 28, 0, 0, 1268, 1269, 3, 6, 3, 0, 1269, 1270, 5, 31, 0, 0, 1270, 1345, 1, 0, 0, 0, 1271, 1272, 5, 204, 0, 0, 1272, 1273, 5, 205, 0, 0, 1273, 1274, 5, 42, 0, 0, 1274, 1275, 3, 32, 16, 0, 1275, 1276, 5, 43, 0, 0, 1276, 1345, 1, 0, 0, 0, 1277, 1278, 5, 204, 0, 0, 1278, 1279, 5, 206, 0, 0, 1279, 1280, 5, 42, 0, 0, 1280, 1281, 3, 32, 16, 0, 1281, 1282, 5, 43, 0, 0, 1282, 1283, 3, 126, 63, 0, 1283, 1345, 1, 0, 0, 0, 1284, 1345, 5, 207, 0, 0, 1285, 1345, 5, 208, 0, 0, 1286, 1345, 5, 209, 0, 0, 1287, 1345, 5, 201, 0, 0, 1288, 1345, 5, 183, 0, 0, 1289, 1345, 5, 184, 0, 0, 1290, 1345, 5, 185, 0, 0, 1291, 1345, 5, 186, 0, 0, 1292, 1345, 5, 187, 0, 0, 1293, 1345, 5, 188, 0, 0, 1294, 1345, 5, 189, 0, 0, 1295, 1345, 5, 210, 0, 0, 1296, 1345, 5, 190, 0, 0, 1297, 1345, 5, 191, 0, 0, 1298, 1345, 5, 192, 0, 0, 1299, 1345, 5, 193, 0, 0, 1300, 1345, 5, 211, 0, 0, 1301, 1345, 5, 212, 0, 0, 1302, 1345, 5, 213, 0, 0, 1303, 1345, 5, 214, 0, 0, 1304, 1345, 5, 215, 0, 0, 1305, 1345, 5, 216, 0, 0, 1306, 1345, 5, 217, 0, 0, 1307, 1308, 5, 218, 0, 0, 1308, 1345, 3, 132, 66, 0, 1309, 1310, 5, 219, 0, 0, 1310, 1345, 3, 132, 66, 0, 1311, 1345, 5, 220, 0, 0, 1312, 1313, 5, 221, 0, 0, 1313, 1345, 3, 132, 66, 0, 1314, 1315, 5, 222, 0, 0, 1315, 1345, 3, 134, 67, 0, 1316, 1317, 5, 222, 0, 0, 1317, 1318, 3, 134, 67, 0, 1318, 1319, 5, 28, 0, 0, 1319, 1320, 3, 6, 3, 0, 1320, 1345, 1, 0, 0, 0, 1321, 1345, 5, 194, 0, 0, 1322, 1345, 5, 195, 0, 0, 1323, 1324, 5, 90, 0, 0, 1324, 1345, 5, 184, 0, 0, 1325, 1326, 5, 90, 0, 0, 1326, 1345, 5, 185, 0, 0, 1327, 1328, 5, 90, 0, 0, 1328, 1345, 5, 186, 0, 0, 1329, 1330, 5, 90, 0, 0, 1330, 1345, 5, 187, 0, 0, 1331, 1332, 5, 62, 0, 0, 1332, 1345, 5, 220, 0, 0, 1333, 1345, 5, 223, 0, 0, 1334, 1335, 5, 224, 0, 0, 1335, 1345, 5, 213, 0, 0, 1336, 1345, 5, 225, 0, 0, 1337, 1338, 5, 207, 0, 0, 1338, 1345, 5, 183, 0, 0, 1339, 1345, 5, 226, 0, 0, 1340, 1345, 5, 228, 0, 0, 1341, 1342, 5, 34, 0, 0, 1342, 1345, 5, 227, 0, 0, 1343, 1345, 3, 2, 1, 0, 1344, 1252, 1, 0, 0, 0, 1344, 1253, 1, 0, 0, 0, 1344, 1264, 1, 0, 0, 0, 1344, 1271, 1, 0, 0, 0, 1344, 1277, 1, 0, 0, 0, 1344, 1284, 1, 0, 0, 0, 1344, 1285, 1, 0, 0, 0, 1344, 1286, 1, 0, 0, 0, 1344, 1287, 1, 0, 0, 0, 1344, 1288, 1, 0, 0, 0, 1344, 1289, 1, 0, 0, 0, 1344, 1290, 1, 0, 0, 0, 1344, 1291, 1, 0, 0, 0, 1344, 1292, 1, 0, 0, 0, 1344, 1293, 1, 0, 0, 0, 1344, 1294, 1, 0, 0, 0, 1344, 1295, 1, 0, 0, 0, 1344, 1296, 1, 0, 0, 0, 1344, 1297, 1, 0, 0, 0, 1344, 1298, 1, 0, 0, 0, 1344, 1299, 1, 0, 0, 0, 1344, 1300, 1, 0, 0, 0, 1344, 1301, 1, 0, 0, 0, 1344, 1302, 1, 0, 0, 0, 1344, 1303, 1, 0, 0, 0, 1344, 1304, 1, 0, 0, 0, 1344, 1305, 1, 0, 0, 0, 1344, 1306, 1, 0, 0, 0, 1344, 1307, 1, 0, 0, 0, 1344, 1309, 1, 0, 0, 0, 1344, 1311, 1, 0, 0, 0, 1344, 1312, 1, 0, 0, 0, 1344, 1314, 1, 0, 0, 0, 1344, 1316, 1, 0, 0, 0, 1344, 1321, 1, 0, 0, 0, 1344, 1322, 1, 0, 0, 0, 1344, 1323, 1, 0, 0, 0, 1344, 1325, 1, 0, 0, 0, 1344, 1327, 1, 0, 0, 0, 1344, 1329, 1, 0, 0, 0, 1344, 1331, 1, 0, 0, 0, 1344, 1333, 1, 0, 0, 0, 1344, 1334, 1, 0, 0, 0, 1344, 1336, 1, 0, 0, 0, 1344, 1337, 1, 0, 0, 0, 1344, 1339, 1, 0, 0, 0, 1344, 1340, 1, 0, 0, 0, 1344, 1341, 1, 0, 0, 0, 1344, 1343, 1, 0, 0, 0, 1345, 131, 1, 0, 0, 0, 1346, 1354, 1, 0, 0, 0, 1347, 1348, 5, 30, 0, 0, 1348, 1349, 5, 91, 0, 0, 1349, 1350, 5, 36, 0, 0, 1350, 1351, 3, 32, 16, 0, 1351, 1352, 5, 31, 0, 0, 1352, 1354, 1, 0, 0, 0, 1353, 1346, 1, 0, 0, 0, 1353, 1347, 1, 0, 0, 0, 1354, 133, 1, 0, 0, 0, 1355, 1364, 1, 0, 0, 0, 1356, 1360, 3, 136, 68, 0, 1357, 1359, 7, 7, 0, 0, 1358, 1357, 1, 0, 0, 0, 1359, 1362, 1, 0, 0, 0, 1360, 1358, 1, 0, 0, 0, 1360, 1361, 1, 0, 0, 0, 1361, 1364, 1, 0, 0, 0, 1362, 1360, 1, 0, 0, 0, 1363, 1355, 1, 0, 0, 0, 1363, 1356, 1, 0, 0, 0, 1364, 135, 1, 0, 0, 0, 1365, 1366, 7, 8, 0, 0, 1366, 137, 1, 0, 0, 0, 1367, 1368, 3, 142, 71, 0, 1368, 1374, 6, 69, -1, 0, 1369, 1370, 3, 140, 70, 0, 1370, 1371, 6, 69, -1, 0, 1371, 1373, 1, 0, 0, 0, 1372, 1369, 1, 0, 0, 0, 1373, 1376, 1, 0, 0, 0, 1374, 1372, 1, 0, 0, 0, 1374, 1375, 1, 0, 0, 0, 1375, 139, 1, 0, 0, 0, 1376, 1374, 1, 0, 0, 0, 1377, 1378, 5, 261, 0, 0, 1378, 1407, 6, 70, -1, 0, 1379, 1380, 5, 42, 0, 0, 1380, 1381, 5, 43, 0, 0, 1381, 1407, 6, 70, -1, 0, 1382, 1383, 3, 110, 55, 0, 1383, 1384, 6, 70, -1, 0, 1384, 1407, 1, 0, 0, 0, 1385, 1386, 5, 260, 0, 0, 1386, 1407, 6, 70, -1, 0, 1387, 1388, 5, 262, 0, 0, 1388, 1407, 6, 70, -1, 0, 1389, 1390, 5, 92, 0, 0, 1390, 1407, 6, 70, -1, 0, 1391, 1392, 5, 93, 0, 0, 1392, 1393, 5, 30, 0, 0, 1393, 1394, 3, 124, 62, 0, 1394, 1395, 5, 31, 0, 0, 1395, 1396, 6, 70, -1, 0, 1396, 1407, 1, 0, 0, 0, 1397, 1398, 5, 94, 0, 0, 1398, 1399, 5, 30, 0, 0, 1399, 1400, 3, 124, 62, 0, 1400, 1401, 5, 31, 0, 0, 1401, 1402, 6, 70, -1, 0, 1402, 1407, 1, 0, 0, 0, 1403, 1404, 3, 108, 54, 0, 1404, 1405, 6, 70, -1, 0, 1405, 1407, 1, 0, 0, 0, 1406, 1377, 1, 0, 0, 0, 1406, 1379, 1, 0, 0, 0, 1406, 1382, 1, 0, 0, 0, 1406, 1385, 1, 0, 0, 0, 1406, 1387, 1, 0, 0, 0, 1406, 1389, 1, 0, 0, 0, 1406, 1391, 1, 0, 0, 0, 1406, 1397, 1, 0, 0, 0, 1406, 1403, 1, 0, 0, 0, 1407, 141, 1, 0, 0, 0, 1408, 1409, 5, 39, 0, 0, 1409, 1410, 3, 116, 58, 0, 1410, 1411, 6, 71, -1, 0, 1411, 1467, 1, 0, 0, 0, 1412, 1413, 5, 197, 0, 0, 1413, 1467, 6, 71, -1, 0, 1414, 1415, 5, 199, 0, 0, 1415, 1416, 5, 39, 0, 0, 1416, 1417, 3, 116, 58, 0, 1417, 1418, 6, 71, -1, 0, 1418, 1467, 1, 0, 0, 0, 1419, 1420, 5, 200, 0, 0, 1420, 1421, 3, 116, 58, 0, 1421, 1422, 6, 71, -1, 0, 1422, 1467, 1, 0, 0, 0, 1423, 1424, 5, 226, 0, 0, 1424, 1425, 3, 170, 85, 0, 1425, 1426, 3, 138, 69, 0, 1426, 1427, 5, 262, 0, 0, 1427, 1428, 3, 112, 56, 0, 1428, 1429, 6, 71, -1, 0, 1429, 1467, 1, 0, 0, 0, 1430, 1431, 5, 253, 0, 0, 1431, 1432, 3, 32, 16, 0, 1432, 1433, 6, 71, -1, 0, 1433, 1467, 1, 0, 0, 0, 1434, 1435, 5, 252, 0, 0, 1435, 1436, 3, 32, 16, 0, 1436, 1437, 6, 71, -1, 0, 1437, 1467, 1, 0, 0, 0, 1438, 1439, 5, 253, 0, 0, 1439, 1440, 3, 2, 1, 0, 1440, 1441, 6, 71, -1, 0, 1441, 1467, 1, 0, 0, 0, 1442, 1443, 5, 252, 0, 0, 1443, 1444, 3, 2, 1, 0, 1444, 1445, 6, 71, -1, 0, 1445, 1467, 1, 0, 0, 0, 1446, 1447, 5, 254, 0, 0, 1447, 1467, 6, 71, -1, 0, 1448, 1449, 5, 201, 0, 0, 1449, 1467, 6, 71, -1, 0, 1450, 1451, 3, 148, 74, 0, 1451, 1452, 6, 71, -1, 0, 1452, 1467, 1, 0, 0, 0, 1453, 1454, 3, 150, 75, 0, 1454, 1455, 6, 71, -1, 0, 1455, 1467, 1, 0, 0, 0, 1456, 1457, 3, 144, 72, 0, 1457, 1458, 6, 71, -1, 0, 1458, 1467, 1, 0, 0, 0, 1459, 1460, 3, 2, 1, 0, 1460, 1461, 6, 71, -1, 0, 1461, 1467, 1, 0, 0, 0, 1462, 1463, 5, 177, 0, 0, 1463, 1464, 3, 138, 69, 0, 1464, 1465, 6, 71, -1, 0, 1465, 1467, 1, 0, 0, 0, 1466, 1408, 1, 0, 0, 0, 1466, 1412, 1, 0, 0, 0, 1466, 1414, 1, 0, 0, 0, 1466, 1419, 1, 0, 0, 0, 1466, 1423, 1, 0, 0, 0, 1466, 1430, 1, 0, 0, 0, 1466, 1434, 1, 0, 0, 0, 1466, 1438, 1, 0, 0, 0, 1466, 1442, 1, 0, 0, 0, 1466, 1446, 1, 0, 0, 0, 1466, 1448, 1, 0, 0, 0, 1466, 1450, 1, 0, 0, 0, 1466, 1453, 1, 0, 0, 0, 1466, 1456, 1, 0, 0, 0, 1466, 1459, 1, 0, 0, 0, 1466, 1462, 1, 0, 0, 0, 1467, 143, 1, 0, 0, 0, 1468, 1469, 5, 181, 0, 0, 1469, 1507, 6, 72, -1, 0, 1470, 1471, 5, 182, 0, 0, 1471, 1507, 6, 72, -1, 0, 1472, 1473, 5, 183, 0, 0, 1473, 1507, 6, 72, -1, 0, 1474, 1475, 5, 184, 0, 0, 1475, 1507, 6, 72, -1, 0, 1476, 1477, 5, 185, 0, 0, 1477, 1507, 6, 72, -1, 0, 1478, 1479, 5, 186, 0, 0, 1479, 1507, 6, 72, -1, 0, 1480, 1481, 5, 187, 0, 0, 1481, 1507, 6, 72, -1, 0, 1482, 1483, 5, 188, 0, 0, 1483, 1507, 6, 72, -1, 0, 1484, 1485, 5, 189, 0, 0, 1485, 1507, 6, 72, -1, 0, 1486, 1487, 5, 190, 0, 0, 1487, 1507, 6, 72, -1, 0, 1488, 1489, 5, 191, 0, 0, 1489, 1507, 6, 72, -1, 0, 1490, 1491, 5, 192, 0, 0, 1491, 1507, 6, 72, -1, 0, 1492, 1493, 5, 193, 0, 0, 1493, 1507, 6, 72, -1, 0, 1494, 1495, 5, 90, 0, 0, 1495, 1496, 5, 184, 0, 0, 1496, 1507, 6, 72, -1, 0, 1497, 1498, 5, 90, 0, 0, 1498, 1499, 5, 185, 0, 0, 1499, 1507, 6, 72, -1, 0, 1500, 1501, 5, 90, 0, 0, 1501, 1502, 5, 186, 0, 0, 1502, 1507, 6, 72, -1, 0, 1503, 1504, 5, 90, 0, 0, 1504, 1505, 5, 187, 0, 0, 1505, 1507, 6, 72, -1, 0, 1506, 1468, 1, 0, 0, 0, 1506, 1470, 1, 0, 0, 0, 1506, 1472, 1, 0, 0, 0, 1506, 1474, 1, 0, 0, 0, 1506, 1476, 1, 0, 0, 0, 1506, 1478, 1, 0, 0, 0, 1506, 1480, 1, 0, 0, 0, 1506, 1482, 1, 0, 0, 0, 1506, 1484, 1, 0, 0, 0, 1506, 1486, 1, 0, 0, 0, 1506, 1488, 1, 0, 0, 0, 1506, 1490, 1, 0, 0, 0, 1506, 1492, 1, 0, 0, 0, 1506, 1494, 1, 0, 0, 0, 1506, 1497, 1, 0, 0, 0, 1506, 1500, 1, 0, 0, 0, 1506, 1503, 1, 0, 0, 0, 1507, 145, 1, 0, 0, 0, 1508, 1523, 1, 0, 0, 0, 1509, 1523, 5, 177, 0, 0, 1510, 1511, 3, 32, 16, 0, 1511, 1512, 6, 73, -1, 0, 1512, 1523, 1, 0, 0, 0, 1513, 1514, 3, 32, 16, 0, 1514, 1515, 5, 177, 0, 0, 1515, 1516, 3, 32, 16, 0, 1516, 1517, 6, 73, -1, 0, 1517, 1523, 1, 0, 0, 0, 1518, 1519, 3, 32, 16, 0, 1519, 1520, 5, 177, 0, 0, 1520, 1521, 6, 73, -1, 0, 1521, 1523, 1, 0, 0, 0, 1522, 1508, 1, 0, 0, 0, 1522, 1509, 1, 0, 0, 0, 1522, 1510, 1, 0, 0, 0, 1522, 1513, 1, 0, 0, 0, 1522, 1518, 1, 0, 0, 0, 1523, 147, 1, 0, 0, 0, 1524, 1525, 5, 1, 0, 0, 1525, 1526, 5, 194, 0, 0, 1526, 1527, 6, 74, -1, 0, 1527, 149, 1, 0, 0, 0, 1528, 1532, 5, 1, 0, 0, 1529, 1530, 5, 90, 0, 0, 1530, 1533, 5, 194, 0, 0, 1531, 1533, 5, 195, 0, 0, 1532, 1529, 1, 0, 0, 0, 1532, 1531, 1, 0, 0, 0, 1533, 1534, 1, 0, 0, 0, 1534, 1535, 6, 75, -1, 0, 1535, 151, 1, 0, 0, 0, 1536, 1537, 5, 294, 0, 0, 1537, 1538, 3, 166, 83, 0, 1538, 1539, 3, 124, 62, 0, 1539, 1540, 5, 30, 0, 0, 1540, 1541, 3, 158, 79, 0, 1541, 1542, 5, 31, 0, 0, 1542, 1584, 1, 0, 0, 0, 1543, 1544, 5, 294, 0, 0, 1544, 1545, 3, 166, 83, 0, 1545, 1546, 3, 124, 62, 0, 1546, 1547, 5, 36, 0, 0, 1547, 1548, 5, 17, 0, 0, 1548, 1549, 3, 52, 26, 0, 1549, 1550, 5, 18, 0, 0, 1550, 1584, 1, 0, 0, 0, 1551, 1552, 5, 294, 0, 0, 1552, 1553, 3, 166, 83, 0, 1553, 1554, 3, 124, 62, 0, 1554, 1584, 1, 0, 0, 0, 1555, 1556, 5, 295, 0, 0, 1556, 1557, 3, 166, 83, 0, 1557, 1559, 5, 36, 0, 0, 1558, 1560, 5, 84, 0, 0, 1559, 1558, 1, 0, 0, 0, 1559, 1560, 1, 0, 0, 0, 1560, 1561, 1, 0, 0, 0, 1561, 1562, 5, 30, 0, 0, 1562, 1563, 3, 292, 146, 0, 1563, 1564, 5, 31, 0, 0, 1564, 1584, 1, 0, 0, 0, 1565, 1566, 5, 295, 0, 0, 1566, 1567, 3, 166, 83, 0, 1567, 1568, 5, 84, 0, 0, 1568, 1569, 5, 30, 0, 0, 1569, 1570, 3, 292, 146, 0, 1570, 1571, 5, 31, 0, 0, 1571, 1584, 1, 0, 0, 0, 1572, 1573, 5, 295, 0, 0, 1573, 1574, 3, 166, 83, 0, 1574, 1575, 3, 6, 3, 0, 1575, 1584, 1, 0, 0, 0, 1576, 1577, 5, 295, 0, 0, 1577, 1578, 3, 166, 83, 0, 1578, 1579, 5, 36, 0, 0, 1579, 1580, 5, 17, 0, 0, 1580, 1581, 3, 154, 77, 0, 1581, 1582, 5, 18, 0, 0, 1582, 1584, 1, 0, 0, 0, 1583, 1536, 1, 0, 0, 0, 1583, 1543, 1, 0, 0, 0, 1583, 1551, 1, 0, 0, 0, 1583, 1555, 1, 0, 0, 0, 1583, 1565, 1, 0, 0, 0, 1583, 1572, 1, 0, 0, 0, 1583, 1576, 1, 0, 0, 0, 1584, 153, 1, 0, 0, 0, 1585, 1596, 1, 0, 0, 0, 1586, 1587, 3, 156, 78, 0, 1587, 1588, 5, 28, 0, 0, 1588, 1590, 1, 0, 0, 0, 1589, 1586, 1, 0, 0, 0, 1590, 1593, 1, 0, 0, 0, 1591, 1589, 1, 0, 0, 0, 1591, 1592, 1, 0, 0, 0, 1592, 1594, 1, 0, 0, 0, 1593, 1591, 1, 0, 0, 0, 1594, 1596, 3, 156, 78, 0, 1595, 1585, 1, 0, 0, 0, 1595, 1591, 1, 0, 0, 0, 1596, 155, 1, 0, 0, 0, 1597, 1598, 5, 39, 0, 0, 1598, 1599, 5, 264, 0, 0, 1599, 1600, 5, 36, 0, 0, 1600, 1601, 5, 17, 0, 0, 1601, 1602, 3, 56, 28, 0, 1602, 1603, 5, 18, 0, 0, 1603, 1611, 1, 0, 0, 0, 1604, 1605, 3, 124, 62, 0, 1605, 1606, 5, 36, 0, 0, 1606, 1607, 5, 17, 0, 0, 1607, 1608, 3, 56, 28, 0, 1608, 1609, 5, 18, 0, 0, 1609, 1611, 1, 0, 0, 0, 1610, 1597, 1, 0, 0, 0, 1610, 1604, 1, 0, 0, 0, 1611, 157, 1, 0, 0, 0, 1612, 1613, 3, 160, 80, 0, 1613, 1614, 5, 28, 0, 0, 1614, 1616, 1, 0, 0, 0, 1615, 1612, 1, 0, 0, 0, 1616, 1619, 1, 0, 0, 0, 1617, 1615, 1, 0, 0, 0, 1617, 1618, 1, 0, 0, 0, 1618, 1620, 1, 0, 0, 0, 1619, 1617, 1, 0, 0, 0, 1620, 1621, 3, 160, 80, 0, 1621, 159, 1, 0, 0, 0, 1622, 1623, 3, 6, 3, 0, 1623, 1624, 5, 36, 0, 0, 1624, 1625, 3, 164, 82, 0, 1625, 161, 1, 0, 0, 0, 1626, 1627, 7, 9, 0, 0, 1627, 163, 1, 0, 0, 0, 1628, 1663, 3, 162, 81, 0, 1629, 1663, 3, 32, 16, 0, 1630, 1631, 5, 186, 0, 0, 1631, 1632, 5, 30, 0, 0, 1632, 1633, 3, 32, 16, 0, 1633, 1634, 5, 31, 0, 0, 1634, 1663, 1, 0, 0, 0, 1635, 1663, 3, 6, 3, 0, 1636, 1637, 3, 116, 58, 0, 1637, 1638, 5, 30, 0, 0, 1638, 1639, 5, 184, 0, 0, 1639, 1640, 5, 75, 0, 0, 1640, 1641, 3, 32, 16, 0, 1641, 1642, 5, 31, 0, 0, 1642, 1663, 1, 0, 0, 0, 1643, 1644, 3, 116, 58, 0, 1644, 1645, 5, 30, 0, 0, 1645, 1646, 5, 185, 0, 0, 1646, 1647, 5, 75, 0, 0, 1647, 1648, 3, 32, 16, 0, 1648, 1649, 5, 31, 0, 0, 1649, 1663, 1, 0, 0, 0, 1650, 1651, 3, 116, 58, 0, 1651, 1652, 5, 30, 0, 0, 1652, 1653, 5, 186, 0, 0, 1653, 1654, 5, 75, 0, 0, 1654, 1655, 3, 32, 16, 0, 1655, 1656, 5, 31, 0, 0, 1656, 1663, 1, 0, 0, 0, 1657, 1658, 3, 116, 58, 0, 1658, 1659, 5, 30, 0, 0, 1659, 1660, 3, 32, 16, 0, 1660, 1661, 5, 31, 0, 0, 1661, 1663, 1, 0, 0, 0, 1662, 1628, 1, 0, 0, 0, 1662, 1629, 1, 0, 0, 0, 1662, 1630, 1, 0, 0, 0, 1662, 1635, 1, 0, 0, 0, 1662, 1636, 1, 0, 0, 0, 1662, 1643, 1, 0, 0, 0, 1662, 1650, 1, 0, 0, 0, 1662, 1657, 1, 0, 0, 0, 1663, 165, 1, 0, 0, 0, 1664, 1665, 7, 10, 0, 0, 1665, 167, 1, 0, 0, 0, 1666, 1667, 3, 170, 85, 0, 1667, 1668, 3, 138, 69, 0, 1668, 1669, 3, 124, 62, 0, 1669, 1670, 5, 176, 0, 0, 1670, 1672, 3, 242, 121, 0, 1671, 1673, 3, 108, 54, 0, 1672, 1671, 1, 0, 0, 0, 1672, 1673, 1, 0, 0, 0, 1673, 1674, 1, 0, 0, 0, 1674, 1675, 3, 112, 56, 0, 1675, 1676, 6, 84, -1, 0, 1676, 1709, 1, 0, 0, 0, 1677, 1678, 3, 170, 85, 0, 1678, 1679, 3, 138, 69, 0, 1679, 1680, 3, 124, 62, 0, 1680, 1681, 5, 176, 0, 0, 1681, 1682, 3, 242, 121, 0, 1682, 1683, 3, 196, 98, 0, 1683, 1684, 3, 112, 56, 0, 1684, 1685, 6, 84, -1, 0, 1685, 1709, 1, 0, 0, 0, 1686, 1687, 3, 170, 85, 0, 1687, 1688, 3, 138, 69, 0, 1688, 1690, 3, 242, 121, 0, 1689, 1691, 3, 108, 54, 0, 1690, 1689, 1, 0, 0, 0, 1690, 1691, 1, 0, 0, 0, 1691, 1692, 1, 0, 0, 0, 1692, 1693, 3, 112, 56, 0, 1693, 1694, 6, 84, -1, 0, 1694, 1709, 1, 0, 0, 0, 1695, 1696, 3, 170, 85, 0, 1696, 1697, 3, 138, 69, 0, 1697, 1698, 3, 242, 121, 0, 1698, 1699, 3, 196, 98, 0, 1699, 1700, 3, 112, 56, 0, 1700, 1701, 6, 84, -1, 0, 1701, 1709, 1, 0, 0, 0, 1702, 1703, 3, 174, 87, 0, 1703, 1704, 6, 84, -1, 0, 1704, 1709, 1, 0, 0, 0, 1705, 1706, 3, 2, 1, 0, 1706, 1707, 6, 84, -1, 0, 1707, 1709, 1, 0, 0, 0, 1708, 1666, 1, 0, 0, 0, 1708, 1677, 1, 0, 0, 0, 1708, 1686, 1, 0, 0, 0, 1708, 1695, 1, 0, 0, 0, 1708, 1702, 1, 0, 0, 0, 1708, 1705, 1, 0, 0, 0, 1709, 169, 1, 0, 0, 0, 1710, 1711, 5, 243, 0, 0, 1711, 1712, 3, 170, 85, 0, 1712, 1713, 6, 85, -1, 0, 1713, 1728, 1, 0, 0, 0, 1714, 1715, 5, 244, 0, 0, 1715, 1716, 3, 170, 85, 0, 1716, 1717, 6, 85, -1, 0, 1717, 1728, 1, 0, 0, 0, 1718, 1719, 3, 172, 86, 0, 1719, 1720, 6, 85, -1, 0, 1720, 1728, 1, 0, 0, 0, 1721, 1722, 5, 112, 0, 0, 1722, 1723, 5, 30, 0, 0, 1723, 1724, 3, 32, 16, 0, 1724, 1725, 5, 31, 0, 0, 1725, 1726, 6, 85, -1, 0, 1726, 1728, 1, 0, 0, 0, 1727, 1710, 1, 0, 0, 0, 1727, 1714, 1, 0, 0, 0, 1727, 1718, 1, 0, 0, 0, 1727, 1721, 1, 0, 0, 0, 1728, 171, 1, 0, 0, 0, 1729, 1749, 1, 0, 0, 0, 1730, 1731, 5, 245, 0, 0, 1731, 1749, 6, 86, -1, 0, 1732, 1733, 5, 246, 0, 0, 1733, 1749, 6, 86, -1, 0, 1734, 1735, 5, 247, 0, 0, 1735, 1736, 5, 248, 0, 0, 1736, 1749, 6, 86, -1, 0, 1737, 1738, 5, 247, 0, 0, 1738, 1739, 5, 249, 0, 0, 1739, 1749, 6, 86, -1, 0, 1740, 1741, 5, 247, 0, 0, 1741, 1742, 5, 250, 0, 0, 1742, 1749, 6, 86, -1, 0, 1743, 1744, 5, 247, 0, 0, 1744, 1745, 5, 251, 0, 0, 1745, 1749, 6, 86, -1, 0, 1746, 1747, 5, 247, 0, 0, 1747, 1749, 6, 86, -1, 0, 1748, 1729, 1, 0, 0, 0, 1748, 1730, 1, 0, 0, 0, 1748, 1732, 1, 0, 0, 0, 1748, 1734, 1, 0, 0, 0, 1748, 1737, 1, 0, 0, 0, 1748, 1740, 1, 0, 0, 0, 1748, 1743, 1, 0, 0, 0, 1748, 1746, 1, 0, 0, 0, 1749, 173, 1, 0, 0, 0, 1750, 1751, 5, 113, 0, 0, 1751, 1752, 5, 30, 0, 0, 1752, 1753, 3, 32, 16, 0, 1753, 1754, 5, 31, 0, 0, 1754, 1755, 6, 87, -1, 0, 1755, 175, 1, 0, 0, 0, 1756, 1757, 5, 226, 0, 0, 1757, 1758, 3, 168, 84, 0, 1758, 1759, 6, 88, -1, 0, 1759, 1768, 1, 0, 0, 0, 1760, 1761, 5, 37, 0, 0, 1761, 1762, 3, 178, 89, 0, 1762, 1763, 6, 88, -1, 0, 1763, 1768, 1, 0, 0, 0, 1764, 1765, 3, 174, 87, 0, 1765, 1766, 6, 88, -1, 0, 1766, 1768, 1, 0, 0, 0, 1767, 1756, 1, 0, 0, 0, 1767, 1760, 1, 0, 0, 0, 1767, 1764, 1, 0, 0, 0, 1768, 177, 1, 0, 0, 0, 1769, 1770, 3, 138, 69, 0, 1770, 1771, 3, 124, 62, 0, 1771, 1772, 5, 176, 0, 0, 1772, 1773, 3, 2, 1, 0, 1773, 1774, 6, 89, -1, 0, 1774, 1783, 1, 0, 0, 0, 1775, 1776, 3, 138, 69, 0, 1776, 1777, 3, 2, 1, 0, 1777, 1778, 6, 89, -1, 0, 1778, 1783, 1, 0, 0, 0, 1779, 1780, 3, 2, 1, 0, 1780, 1781, 6, 89, -1, 0, 1781, 1783, 1, 0, 0, 0, 1782, 1769, 1, 0, 0, 0, 1782, 1775, 1, 0, 0, 0, 1782, 1779, 1, 0, 0, 0, 1783, 179, 1, 0, 0, 0, 1784, 1785, 3, 124, 62, 0, 1785, 1786, 5, 28, 0, 0, 1786, 1788, 1, 0, 0, 0, 1787, 1784, 1, 0, 0, 0, 1788, 1791, 1, 0, 0, 0, 1789, 1787, 1, 0, 0, 0, 1789, 1790, 1, 0, 0, 0, 1790, 1792, 1, 0, 0, 0, 1791, 1789, 1, 0, 0, 0, 1792, 1793, 3, 124, 62, 0, 1793, 181, 1, 0, 0, 0, 1794, 1800, 1, 0, 0, 0, 1795, 1796, 5, 86, 0, 0, 1796, 1797, 3, 190, 95, 0, 1797, 1798, 5, 87, 0, 0, 1798, 1800, 1, 0, 0, 0, 1799, 1794, 1, 0, 0, 0, 1799, 1795, 1, 0, 0, 0, 1800, 183, 1, 0, 0, 0, 1801, 1813, 5, 266, 0, 0, 1802, 1813, 5, 114, 0, 0, 1803, 1813, 5, 39, 0, 0, 1804, 1813, 5, 200, 0, 0, 1805, 1813, 5, 115, 0, 0, 1806, 1813, 5, 116, 0, 0, 1807, 1808, 5, 70, 0, 0, 1808, 1809, 5, 30, 0, 0, 1809, 1810, 3, 32, 16, 0, 1810, 1811, 5, 31, 0, 0, 1811, 1813, 1, 0, 0, 0, 1812, 1801, 1, 0, 0, 0, 1812, 1802, 1, 0, 0, 0, 1812, 1803, 1, 0, 0, 0, 1812, 1804, 1, 0, 0, 0, 1812, 1805, 1, 0, 0, 0, 1812, 1806, 1, 0, 0, 0, 1812, 1807, 1, 0, 0, 0, 1813, 185, 1, 0, 0, 0, 1814, 1816, 3, 184, 92, 0, 1815, 1814, 1, 0, 0, 0, 1816, 1819, 1, 0, 0, 0, 1817, 1815, 1, 0, 0, 0, 1817, 1818, 1, 0, 0, 0, 1818, 187, 1, 0, 0, 0, 1819, 1817, 1, 0, 0, 0, 1820, 1822, 3, 186, 93, 0, 1821, 1823, 3, 192, 96, 0, 1822, 1821, 1, 0, 0, 0, 1822, 1823, 1, 0, 0, 0, 1823, 1824, 1, 0, 0, 0, 1824, 1825, 3, 2, 1, 0, 1825, 189, 1, 0, 0, 0, 1826, 1827, 3, 188, 94, 0, 1827, 1828, 5, 28, 0, 0, 1828, 1830, 1, 0, 0, 0, 1829, 1826, 1, 0, 0, 0, 1830, 1833, 1, 0, 0, 0, 1831, 1829, 1, 0, 0, 0, 1831, 1832, 1, 0, 0, 0, 1832, 1834, 1, 0, 0, 0, 1833, 1831, 1, 0, 0, 0, 1834, 1835, 3, 188, 94, 0, 1835, 191, 1, 0, 0, 0, 1836, 1837, 5, 30, 0, 0, 1837, 1838, 3, 180, 90, 0, 1838, 1839, 5, 31, 0, 0, 1839, 193, 1, 0, 0, 0, 1840, 1842, 3, 196, 98, 0, 1841, 1840, 1, 0, 0, 0, 1841, 1842, 1, 0, 0, 0, 1842, 1843, 1, 0, 0, 0, 1843, 1844, 6, 97, -1, 0, 1844, 195, 1, 0, 0, 0, 1845, 1846, 5, 86, 0, 0, 1846, 1847, 5, 42, 0, 0, 1847, 1848, 3, 32, 16, 0, 1848, 1849, 5, 43, 0, 0, 1849, 1850, 5, 87, 0, 0, 1850, 1851, 6, 98, -1, 0, 1851, 197, 1, 0, 0, 0, 1852, 1853, 3, 234, 117, 0, 1853, 1854, 5, 17, 0, 0, 1854, 1855, 3, 246, 123, 0, 1855, 1856, 5, 18, 0, 0, 1856, 1969, 1, 0, 0, 0, 1857, 1858, 3, 74, 37, 0, 1858, 1859, 5, 17, 0, 0, 1859, 1860, 3, 82, 41, 0, 1860, 1861, 5, 18, 0, 0, 1861, 1969, 1, 0, 0, 0, 1862, 1863, 3, 210, 105, 0, 1863, 1864, 5, 17, 0, 0, 1864, 1865, 3, 214, 107, 0, 1865, 1866, 5, 18, 0, 0, 1866, 1969, 1, 0, 0, 0, 1867, 1868, 3, 218, 109, 0, 1868, 1869, 5, 17, 0, 0, 1869, 1870, 3, 222, 111, 0, 1870, 1871, 5, 18, 0, 0, 1871, 1969, 1, 0, 0, 0, 1872, 1969, 3, 200, 100, 0, 1873, 1969, 3, 276, 138, 0, 1874, 1969, 3, 152, 76, 0, 1875, 1969, 3, 88, 44, 0, 1876, 1969, 3, 322, 161, 0, 1877, 1878, 5, 117, 0, 0, 1878, 1969, 3, 32, 16, 0, 1879, 1880, 5, 118, 0, 0, 1880, 1969, 3, 32, 16, 0, 1881, 1882, 3, 334, 167, 0, 1882, 1883, 5, 17, 0, 0, 1883, 1884, 3, 338, 169, 0, 1884, 1885, 5, 18, 0, 0, 1885, 1969, 1, 0, 0, 0, 1886, 1887, 5, 302, 0, 0, 1887, 1888, 3, 124, 62, 0, 1888, 1889, 5, 176, 0, 0, 1889, 1890, 3, 242, 121, 0, 1890, 1891, 5, 119, 0, 0, 1891, 1892, 3, 170, 85, 0, 1892, 1893, 3, 138, 69, 0, 1893, 1894, 3, 124, 62, 0, 1894, 1895, 5, 176, 0, 0, 1895, 1896, 3, 242, 121, 0, 1896, 1897, 3, 112, 56, 0, 1897, 1969, 1, 0, 0, 0, 1898, 1899, 5, 302, 0, 0, 1899, 1900, 5, 226, 0, 0, 1900, 1901, 3, 170, 85, 0, 1901, 1902, 3, 138, 69, 0, 1902, 1903, 3, 124, 62, 0, 1903, 1904, 5, 176, 0, 0, 1904, 1905, 3, 242, 121, 0, 1905, 1906, 3, 194, 97, 0, 1906, 1907, 3, 112, 56, 0, 1907, 1908, 5, 119, 0, 0, 1908, 1909, 5, 226, 0, 0, 1909, 1910, 3, 170, 85, 0, 1910, 1911, 3, 138, 69, 0, 1911, 1912, 3, 124, 62, 0, 1912, 1913, 5, 176, 0, 0, 1913, 1914, 3, 242, 121, 0, 1914, 1915, 3, 194, 97, 0, 1915, 1916, 3, 112, 56, 0, 1916, 1969, 1, 0, 0, 0, 1917, 1969, 3, 26, 13, 0, 1918, 1969, 3, 40, 20, 0, 1919, 1920, 5, 255, 0, 0, 1920, 1921, 5, 196, 0, 0, 1921, 1922, 5, 42, 0, 0, 1922, 1923, 3, 32, 16, 0, 1923, 1927, 5, 43, 0, 0, 1924, 1926, 3, 322, 161, 0, 1925, 1924, 1, 0, 0, 0, 1926, 1929, 1, 0, 0, 0, 1927, 1925, 1, 0, 0, 0, 1927, 1928, 1, 0, 0, 0, 1928, 1969, 1, 0, 0, 0, 1929, 1927, 1, 0, 0, 0, 1930, 1931, 5, 255, 0, 0, 1931, 1932, 5, 196, 0, 0, 1932, 1936, 3, 2, 1, 0, 1933, 1935, 3, 322, 161, 0, 1934, 1933, 1, 0, 0, 0, 1935, 1938, 1, 0, 0, 0, 1936, 1934, 1, 0, 0, 0, 1936, 1937, 1, 0, 0, 0, 1937, 1969, 1, 0, 0, 0, 1938, 1936, 1, 0, 0, 0, 1939, 1940, 5, 255, 0, 0, 1940, 1941, 5, 256, 0, 0, 1941, 1942, 5, 42, 0, 0, 1942, 1943, 3, 32, 16, 0, 1943, 1944, 5, 43, 0, 0, 1944, 1945, 5, 28, 0, 0, 1945, 1949, 3, 124, 62, 0, 1946, 1948, 3, 322, 161, 0, 1947, 1946, 1, 0, 0, 0, 1948, 1951, 1, 0, 0, 0, 1949, 1947, 1, 0, 0, 0, 1949, 1950, 1, 0, 0, 0, 1950, 1969, 1, 0, 0, 0, 1951, 1949, 1, 0, 0, 0, 1952, 1953, 5, 255, 0, 0, 1953, 1954, 5, 256, 0, 0, 1954, 1955, 3, 2, 1, 0, 1955, 1956, 5, 28, 0, 0, 1956, 1960, 3, 124, 62, 0, 1957, 1959, 3, 322, 161, 0, 1958, 1957, 1, 0, 0, 0, 1959, 1962, 1, 0, 0, 0, 1960, 1958, 1, 0, 0, 0, 1960, 1961, 1, 0, 0, 0, 1961, 1969, 1, 0, 0, 0, 1962, 1960, 1, 0, 0, 0, 1963, 1964, 5, 120, 0, 0, 1964, 1965, 5, 196, 0, 0, 1965, 1966, 3, 124, 62, 0, 1966, 1967, 3, 44, 22, 0, 1967, 1969, 1, 0, 0, 0, 1968, 1852, 1, 0, 0, 0, 1968, 1857, 1, 0, 0, 0, 1968, 1862, 1, 0, 0, 0, 1968, 1867, 1, 0, 0, 0, 1968, 1872, 1, 0, 0, 0, 1968, 1873, 1, 0, 0, 0, 1968, 1874, 1, 0, 0, 0, 1968, 1875, 1, 0, 0, 0, 1968, 1876, 1, 0, 0, 0, 1968, 1877, 1, 0, 0, 0, 1968, 1879, 1, 0, 0, 0, 1968, 1881, 1, 0, 0, 0, 1968, 1886, 1, 0, 0, 0, 1968, 1898, 1, 0, 0, 0, 1968, 1917, 1, 0, 0, 0, 1968, 1918, 1, 0, 0, 0, 1968, 1919, 1, 0, 0, 0, 1968, 1930, 1, 0, 0, 0, 1968, 1939, 1, 0, 0, 0, 1968, 1952, 1, 0, 0, 0, 1968, 1963, 1, 0, 0, 0, 1969, 199, 1, 0, 0, 0, 1970, 1971, 5, 121, 0, 0, 1971, 1980, 3, 208, 104, 0, 1972, 1979, 3, 202, 101, 0, 1973, 1974, 5, 122, 0, 0, 1974, 1975, 5, 30, 0, 0, 1975, 1976, 3, 228, 114, 0, 1976, 1977, 5, 31, 0, 0, 1977, 1979, 1, 0, 0, 0, 1978, 1972, 1, 0, 0, 0, 1978, 1973, 1, 0, 0, 0, 1979, 1982, 1, 0, 0, 0, 1980, 1978, 1, 0, 0, 0, 1980, 1981, 1, 0, 0, 0, 1981, 1983, 1, 0, 0, 0, 1982, 1980, 1, 0, 0, 0, 1983, 1984, 3, 138, 69, 0, 1984, 1985, 3, 2, 1, 0, 1985, 1986, 3, 204, 102, 0, 1986, 1987, 3, 206, 103, 0, 1987, 201, 1, 0, 0, 0, 1988, 2008, 5, 123, 0, 0, 1989, 2008, 5, 51, 0, 0, 1990, 2008, 5, 52, 0, 0, 1991, 2008, 5, 63, 0, 0, 1992, 2008, 5, 124, 0, 0, 1993, 2008, 5, 69, 0, 0, 1994, 2008, 5, 68, 0, 0, 1995, 2008, 5, 64, 0, 0, 1996, 2008, 5, 65, 0, 0, 1997, 2008, 5, 66, 0, 0, 1998, 2008, 5, 125, 0, 0, 1999, 2008, 5, 126, 0, 0, 2000, 2008, 5, 127, 0, 0, 2001, 2008, 5, 16, 0, 0, 2002, 2003, 5, 70, 0, 0, 2003, 2004, 5, 30, 0, 0, 2004, 2005, 3, 32, 16, 0, 2005, 2006, 5, 31, 0, 0, 2006, 2008, 1, 0, 0, 0, 2007, 1988, 1, 0, 0, 0, 2007, 1989, 1, 0, 0, 0, 2007, 1990, 1, 0, 0, 0, 2007, 1991, 1, 0, 0, 0, 2007, 1992, 1, 0, 0, 0, 2007, 1993, 1, 0, 0, 0, 2007, 1994, 1, 0, 0, 0, 2007, 1995, 1, 0, 0, 0, 2007, 1996, 1, 0, 0, 0, 2007, 1997, 1, 0, 0, 0, 2007, 1998, 1, 0, 0, 0, 2007, 1999, 1, 0, 0, 0, 2007, 2000, 1, 0, 0, 0, 2007, 2001, 1, 0, 0, 0, 2007, 2002, 1, 0, 0, 0, 2008, 203, 1, 0, 0, 0, 2009, 2015, 1, 0, 0, 0, 2010, 2011, 5, 44, 0, 0, 2011, 2015, 3, 0, 0, 0, 2012, 2013, 5, 44, 0, 0, 2013, 2015, 3, 32, 16, 0, 2014, 2009, 1, 0, 0, 0, 2014, 2010, 1, 0, 0, 0, 2014, 2012, 1, 0, 0, 0, 2015, 205, 1, 0, 0, 0, 2016, 2020, 1, 0, 0, 0, 2017, 2018, 5, 36, 0, 0, 2018, 2020, 3, 296, 148, 0, 2019, 2016, 1, 0, 0, 0, 2019, 2017, 1, 0, 0, 0, 2020, 207, 1, 0, 0, 0, 2021, 2027, 1, 0, 0, 0, 2022, 2023, 5, 42, 0, 0, 2023, 2024, 3, 32, 16, 0, 2024, 2025, 5, 43, 0, 0, 2025, 2027, 1, 0, 0, 0, 2026, 2021, 1, 0, 0, 0, 2026, 2022, 1, 0, 0, 0, 2027, 209, 1, 0, 0, 0, 2028, 2032, 5, 128, 0, 0, 2029, 2031, 3, 212, 106, 0, 2030, 2029, 1, 0, 0, 0, 2031, 2034, 1, 0, 0, 0, 2032, 2030, 1, 0, 0, 0, 2032, 2033, 1, 0, 0, 0, 2033, 2035, 1, 0, 0, 0, 2034, 2032, 1, 0, 0, 0, 2035, 2036, 3, 124, 62, 0, 2036, 2037, 3, 2, 1, 0, 2037, 2047, 1, 0, 0, 0, 2038, 2042, 5, 128, 0, 0, 2039, 2041, 3, 212, 106, 0, 2040, 2039, 1, 0, 0, 0, 2041, 2044, 1, 0, 0, 0, 2042, 2040, 1, 0, 0, 0, 2042, 2043, 1, 0, 0, 0, 2043, 2045, 1, 0, 0, 0, 2044, 2042, 1, 0, 0, 0, 2045, 2047, 3, 2, 1, 0, 2046, 2028, 1, 0, 0, 0, 2046, 2038, 1, 0, 0, 0, 2047, 211, 1, 0, 0, 0, 2048, 2049, 7, 11, 0, 0, 2049, 213, 1, 0, 0, 0, 2050, 2052, 3, 216, 108, 0, 2051, 2050, 1, 0, 0, 0, 2052, 2055, 1, 0, 0, 0, 2053, 2051, 1, 0, 0, 0, 2053, 2054, 1, 0, 0, 0, 2054, 215, 1, 0, 0, 0, 2055, 2053, 1, 0, 0, 0, 2056, 2057, 5, 129, 0, 0, 2057, 2069, 3, 168, 84, 0, 2058, 2059, 5, 130, 0, 0, 2059, 2069, 3, 168, 84, 0, 2060, 2061, 5, 131, 0, 0, 2061, 2069, 3, 168, 84, 0, 2062, 2063, 5, 132, 0, 0, 2063, 2069, 3, 168, 84, 0, 2064, 2069, 3, 88, 44, 0, 2065, 2069, 3, 322, 161, 0, 2066, 2069, 3, 26, 13, 0, 2067, 2069, 3, 40, 20, 0, 2068, 2056, 1, 0, 0, 0, 2068, 2058, 1, 0, 0, 0, 2068, 2060, 1, 0, 0, 0, 2068, 2062, 1, 0, 0, 0, 2068, 2064, 1, 0, 0, 0, 2068, 2065, 1, 0, 0, 0, 2068, 2066, 1, 0, 0, 0, 2068, 2067, 1, 0, 0, 0, 2069, 217, 1, 0, 0, 0, 2070, 2074, 5, 133, 0, 0, 2071, 2073, 3, 220, 110, 0, 2072, 2071, 1, 0, 0, 0, 2073, 2076, 1, 0, 0, 0, 2074, 2072, 1, 0, 0, 0, 2074, 2075, 1, 0, 0, 0, 2075, 2077, 1, 0, 0, 0, 2076, 2074, 1, 0, 0, 0, 2077, 2078, 3, 170, 85, 0, 2078, 2079, 3, 138, 69, 0, 2079, 2080, 3, 2, 1, 0, 2080, 2081, 3, 112, 56, 0, 2081, 2082, 3, 206, 103, 0, 2082, 219, 1, 0, 0, 0, 2083, 2084, 7, 11, 0, 0, 2084, 221, 1, 0, 0, 0, 2085, 2087, 3, 224, 112, 0, 2086, 2085, 1, 0, 0, 0, 2087, 2090, 1, 0, 0, 0, 2088, 2086, 1, 0, 0, 0, 2088, 2089, 1, 0, 0, 0, 2089, 223, 1, 0, 0, 0, 2090, 2088, 1, 0, 0, 0, 2091, 2092, 5, 134, 0, 0, 2092, 2102, 3, 168, 84, 0, 2093, 2094, 5, 135, 0, 0, 2094, 2102, 3, 168, 84, 0, 2095, 2096, 5, 132, 0, 0, 2096, 2102, 3, 168, 84, 0, 2097, 2102, 3, 322, 161, 0, 2098, 2102, 3, 88, 44, 0, 2099, 2102, 3, 26, 13, 0, 2100, 2102, 3, 40, 20, 0, 2101, 2091, 1, 0, 0, 0, 2101, 2093, 1, 0, 0, 0, 2101, 2095, 1, 0, 0, 0, 2101, 2097, 1, 0, 0, 0, 2101, 2098, 1, 0, 0, 0, 2101, 2099, 1, 0, 0, 0, 2101, 2100, 1, 0, 0, 0, 2102, 225, 1, 0, 0, 0, 2103, 2110, 1, 0, 0, 0, 2104, 2105, 5, 122, 0, 0, 2105, 2106, 5, 30, 0, 0, 2106, 2107, 3, 228, 114, 0, 2107, 2108, 5, 31, 0, 0, 2108, 2110, 1, 0, 0, 0, 2109, 2103, 1, 0, 0, 0, 2109, 2104, 1, 0, 0, 0, 2110, 227, 1, 0, 0, 0, 2111, 2121, 3, 126, 63, 0, 2112, 2114, 5, 17, 0, 0, 2113, 2115, 3, 294, 147, 0, 2114, 2113, 1, 0, 0, 0, 2115, 2116, 1, 0, 0, 0, 2116, 2114, 1, 0, 0, 0, 2116, 2117, 1, 0, 0, 0, 2117, 2118, 1, 0, 0, 0, 2118, 2119, 5, 18, 0, 0, 2119, 2121, 1, 0, 0, 0, 2120, 2111, 1, 0, 0, 0, 2120, 2112, 1, 0, 0, 0, 2121, 229, 1, 0, 0, 0, 2122, 2123, 3, 232, 116, 0, 2123, 2124, 6, 115, -1, 0, 2124, 2126, 1, 0, 0, 0, 2125, 2122, 1, 0, 0, 0, 2126, 2129, 1, 0, 0, 0, 2127, 2125, 1, 0, 0, 0, 2127, 2128, 1, 0, 0, 0, 2128, 231, 1, 0, 0, 0, 2129, 2127, 1, 0, 0, 0, 2130, 2131, 5, 42, 0, 0, 2131, 2132, 5, 136, 0, 0, 2132, 2133, 5, 43, 0, 0, 2133, 2148, 6, 116, -1, 0, 2134, 2135, 5, 42, 0, 0, 2135, 2136, 5, 137, 0, 0, 2136, 2137, 5, 43, 0, 0, 2137, 2148, 6, 116, -1, 0, 2138, 2139, 5, 42, 0, 0, 2139, 2140, 5, 138, 0, 0, 2140, 2141, 5, 43, 0, 0, 2141, 2148, 6, 116, -1, 0, 2142, 2143, 5, 42, 0, 0, 2143, 2144, 3, 32, 16, 0, 2144, 2145, 5, 43, 0, 0, 2145, 2146, 6, 116, -1, 0, 2146, 2148, 1, 0, 0, 0, 2147, 2130, 1, 0, 0, 0, 2147, 2134, 1, 0, 0, 0, 2147, 2138, 1, 0, 0, 0, 2147, 2142, 1, 0, 0, 0, 2148, 233, 1, 0, 0, 0, 2149, 2154, 5, 139, 0, 0, 2150, 2153, 3, 236, 118, 0, 2151, 2153, 3, 238, 119, 0, 2152, 2150, 1, 0, 0, 0, 2152, 2151, 1, 0, 0, 0, 2153, 2156, 1, 0, 0, 0, 2154, 2152, 1, 0, 0, 0, 2154, 2155, 1, 0, 0, 0, 2155, 2157, 1, 0, 0, 0, 2156, 2154, 1, 0, 0, 0, 2157, 2158, 3, 170, 85, 0, 2158, 2159, 3, 230, 115, 0, 2159, 2160, 3, 138, 69, 0, 2160, 2161, 3, 226, 113, 0, 2161, 2162, 3, 242, 121, 0, 2162, 2163, 3, 182, 91, 0, 2163, 2167, 3, 112, 56, 0, 2164, 2166, 3, 244, 122, 0, 2165, 2164, 1, 0, 0, 0, 2166, 2169, 1, 0, 0, 0, 2167, 2165, 1, 0, 0, 0, 2167, 2168, 1, 0, 0, 0, 2168, 235, 1, 0, 0, 0, 2169, 2167, 1, 0, 0, 0, 2170, 2194, 5, 123, 0, 0, 2171, 2194, 5, 51, 0, 0, 2172, 2194, 5, 52, 0, 0, 2173, 2194, 5, 63, 0, 0, 2174, 2194, 5, 140, 0, 0, 2175, 2194, 5, 68, 0, 0, 2176, 2194, 5, 141, 0, 0, 2177, 2194, 5, 142, 0, 0, 2178, 2194, 5, 54, 0, 0, 2179, 2194, 5, 64, 0, 0, 2180, 2194, 5, 65, 0, 0, 2181, 2194, 5, 66, 0, 0, 2182, 2194, 5, 125, 0, 0, 2183, 2194, 5, 143, 0, 0, 2184, 2194, 5, 144, 0, 0, 2185, 2194, 5, 69, 0, 0, 2186, 2194, 5, 145, 0, 0, 2187, 2194, 5, 146, 0, 0, 2188, 2189, 5, 70, 0, 0, 2189, 2190, 5, 30, 0, 0, 2190, 2191, 3, 32, 16, 0, 2191, 2192, 5, 31, 0, 0, 2192, 2194, 1, 0, 0, 0, 2193, 2170, 1, 0, 0, 0, 2193, 2171, 1, 0, 0, 0, 2193, 2172, 1, 0, 0, 0, 2193, 2173, 1, 0, 0, 0, 2193, 2174, 1, 0, 0, 0, 2193, 2175, 1, 0, 0, 0, 2193, 2176, 1, 0, 0, 0, 2193, 2177, 1, 0, 0, 0, 2193, 2178, 1, 0, 0, 0, 2193, 2179, 1, 0, 0, 0, 2193, 2180, 1, 0, 0, 0, 2193, 2181, 1, 0, 0, 0, 2193, 2182, 1, 0, 0, 0, 2193, 2183, 1, 0, 0, 0, 2193, 2184, 1, 0, 0, 0, 2193, 2185, 1, 0, 0, 0, 2193, 2186, 1, 0, 0, 0, 2193, 2187, 1, 0, 0, 0, 2193, 2188, 1, 0, 0, 0, 2194, 237, 1, 0, 0, 0, 2195, 2196, 5, 147, 0, 0, 2196, 2202, 5, 30, 0, 0, 2197, 2200, 3, 6, 3, 0, 2198, 2199, 5, 34, 0, 0, 2199, 2201, 3, 6, 3, 0, 2200, 2198, 1, 0, 0, 0, 2200, 2201, 1, 0, 0, 0, 2201, 2203, 1, 0, 0, 0, 2202, 2197, 1, 0, 0, 0, 2202, 2203, 1, 0, 0, 0, 2203, 2207, 1, 0, 0, 0, 2204, 2206, 3, 240, 120, 0, 2205, 2204, 1, 0, 0, 0, 2206, 2209, 1, 0, 0, 0, 2207, 2205, 1, 0, 0, 0, 2207, 2208, 1, 0, 0, 0, 2208, 2210, 1, 0, 0, 0, 2209, 2207, 1, 0, 0, 0, 2210, 2214, 5, 31, 0, 0, 2211, 2212, 5, 147, 0, 0, 2212, 2214, 5, 85, 0, 0, 2213, 2195, 1, 0, 0, 0, 2213, 2211, 1, 0, 0, 0, 2214, 239, 1, 0, 0, 0, 2215, 2243, 5, 148, 0, 0, 2216, 2243, 5, 224, 0, 0, 2217, 2243, 5, 57, 0, 0, 2218, 2243, 5, 58, 0, 0, 2219, 2243, 5, 149, 0, 0, 2220, 2243, 5, 150, 0, 0, 2221, 2243, 5, 248, 0, 0, 2222, 2243, 5, 249, 0, 0, 2223, 2243, 5, 250, 0, 0, 2224, 2243, 5, 251, 0, 0, 2225, 2226, 5, 151, 0, 0, 2226, 2227, 5, 75, 0, 0, 2227, 2243, 5, 152, 0, 0, 2228, 2229, 5, 151, 0, 0, 2229, 2230, 5, 75, 0, 0, 2230, 2243, 5, 153, 0, 0, 2231, 2232, 5, 154, 0, 0, 2232, 2233, 5, 75, 0, 0, 2233, 2243, 5, 152, 0, 0, 2234, 2235, 5, 154, 0, 0, 2235, 2236, 5, 75, 0, 0, 2236, 2243, 5, 153, 0, 0, 2237, 2238, 5, 70, 0, 0, 2238, 2239, 5, 30, 0, 0, 2239, 2240, 3, 32, 16, 0, 2240, 2241, 5, 31, 0, 0, 2241, 2243, 1, 0, 0, 0, 2242, 2215, 1, 0, 0, 0, 2242, 2216, 1, 0, 0, 0, 2242, 2217, 1, 0, 0, 0, 2242, 2218, 1, 0, 0, 0, 2242, 2219, 1, 0, 0, 0, 2242, 2220, 1, 0, 0, 0, 2242, 2221, 1, 0, 0, 0, 2242, 2222, 1, 0, 0, 0, 2242, 2223, 1, 0, 0, 0, 2242, 2224, 1, 0, 0, 0, 2242, 2225, 1, 0, 0, 0, 2242, 2228, 1, 0, 0, 0, 2242, 2231, 1, 0, 0, 0, 2242, 2234, 1, 0, 0, 0, 2242, 2237, 1, 0, 0, 0, 2243, 241, 1, 0, 0, 0, 2244, 2245, 5, 116, 0, 0, 2245, 2252, 6, 121, -1, 0, 2246, 2247, 5, 155, 0, 0, 2247, 2252, 6, 121, -1, 0, 2248, 2249, 3, 2, 1, 0, 2249, 2250, 6, 121, -1, 0, 2250, 2252, 1, 0, 0, 0, 2251, 2244, 1, 0, 0, 0, 2251, 2246, 1, 0, 0, 0, 2251, 2248, 1, 0, 0, 0, 2252, 243, 1, 0, 0, 0, 2253, 2275, 5, 1, 0, 0, 2254, 2275, 5, 2, 0, 0, 2255, 2275, 5, 156, 0, 0, 2256, 2275, 5, 3, 0, 0, 2257, 2275, 5, 4, 0, 0, 2258, 2275, 5, 247, 0, 0, 2259, 2275, 5, 5, 0, 0, 2260, 2275, 5, 6, 0, 0, 2261, 2275, 5, 7, 0, 0, 2262, 2275, 5, 8, 0, 0, 2263, 2275, 5, 9, 0, 0, 2264, 2275, 5, 10, 0, 0, 2265, 2275, 5, 11, 0, 0, 2266, 2275, 5, 12, 0, 0, 2267, 2275, 5, 13, 0, 0, 2268, 2275, 5, 14, 0, 0, 2269, 2270, 5, 70, 0, 0, 2270, 2271, 5, 30, 0, 0, 2271, 2272, 3, 32, 16, 0, 2272, 2273, 5, 31, 0, 0, 2273, 2275, 1, 0, 0, 0, 2274, 2253, 1, 0, 0, 0, 2274, 2254, 1, 0, 0, 0, 2274, 2255, 1, 0, 0, 0, 2274, 2256, 1, 0, 0, 0, 2274, 2257, 1, 0, 0, 0, 2274, 2258, 1, 0, 0, 0, 2274, 2259, 1, 0, 0, 0, 2274, 2260, 1, 0, 0, 0, 2274, 2261, 1, 0, 0, 0, 2274, 2262, 1, 0, 0, 0, 2274, 2263, 1, 0, 0, 0, 2274, 2264, 1, 0, 0, 0, 2274, 2265, 1, 0, 0, 0, 2274, 2266, 1, 0, 0, 0, 2274, 2267, 1, 0, 0, 0, 2274, 2268, 1, 0, 0, 0, 2274, 2269, 1, 0, 0, 0, 2275, 245, 1, 0, 0, 0, 2276, 2278, 3, 248, 124, 0, 2277, 2276, 1, 0, 0, 0, 2278, 2281, 1, 0, 0, 0, 2279, 2277, 1, 0, 0, 0, 2279, 2280, 1, 0, 0, 0, 2280, 247, 1, 0, 0, 0, 2281, 2279, 1, 0, 0, 0, 2282, 2300, 3, 100, 50, 0, 2283, 2284, 5, 296, 0, 0, 2284, 2285, 3, 32, 16, 0, 2285, 2286, 6, 124, -1, 0, 2286, 2300, 1, 0, 0, 0, 2287, 2300, 3, 258, 129, 0, 2288, 2289, 5, 297, 0, 0, 2289, 2290, 3, 32, 16, 0, 2290, 2291, 6, 124, -1, 0, 2291, 2300, 1, 0, 0, 0, 2292, 2293, 5, 298, 0, 0, 2293, 2300, 6, 124, -1, 0, 2294, 2295, 5, 299, 0, 0, 2295, 2300, 6, 124, -1, 0, 2296, 2300, 3, 252, 126, 0, 2297, 2300, 3, 256, 128, 0, 2298, 2300, 3, 250, 125, 0, 2299, 2282, 1, 0, 0, 0, 2299, 2283, 1, 0, 0, 0, 2299, 2287, 1, 0, 0, 0, 2299, 2288, 1, 0, 0, 0, 2299, 2292, 1, 0, 0, 0, 2299, 2294, 1, 0, 0, 0, 2299, 2296, 1, 0, 0, 0, 2299, 2297, 1, 0, 0, 0, 2299, 2298, 1, 0, 0, 0, 2300, 249, 1, 0, 0, 0, 2301, 2302, 5, 300, 0, 0, 2302, 2400, 3, 112, 56, 0, 2303, 2304, 5, 300, 0, 0, 2304, 2305, 5, 157, 0, 0, 2305, 2400, 3, 112, 56, 0, 2306, 2400, 3, 276, 138, 0, 2307, 2400, 3, 152, 76, 0, 2308, 2400, 3, 88, 44, 0, 2309, 2400, 3, 26, 13, 0, 2310, 2400, 3, 254, 127, 0, 2311, 2400, 3, 40, 20, 0, 2312, 2313, 5, 301, 0, 0, 2313, 2314, 5, 42, 0, 0, 2314, 2315, 3, 32, 16, 0, 2315, 2316, 5, 43, 0, 0, 2316, 2400, 1, 0, 0, 0, 2317, 2318, 5, 301, 0, 0, 2318, 2319, 5, 42, 0, 0, 2319, 2320, 3, 32, 16, 0, 2320, 2321, 5, 43, 0, 0, 2321, 2322, 5, 34, 0, 0, 2322, 2323, 3, 0, 0, 0, 2323, 2400, 1, 0, 0, 0, 2324, 2325, 5, 303, 0, 0, 2325, 2326, 3, 32, 16, 0, 2326, 2327, 5, 75, 0, 0, 2327, 2328, 3, 32, 16, 0, 2328, 2400, 1, 0, 0, 0, 2329, 2330, 5, 302, 0, 0, 2330, 2331, 3, 124, 62, 0, 2331, 2332, 5, 176, 0, 0, 2332, 2333, 3, 242, 121, 0, 2333, 2400, 1, 0, 0, 0, 2334, 2335, 5, 302, 0, 0, 2335, 2336, 5, 226, 0, 0, 2336, 2337, 3, 170, 85, 0, 2337, 2338, 3, 138, 69, 0, 2338, 2339, 3, 124, 62, 0, 2339, 2340, 5, 176, 0, 0, 2340, 2341, 3, 242, 121, 0, 2341, 2342, 3, 194, 97, 0, 2342, 2343, 3, 112, 56, 0, 2343, 2400, 1, 0, 0, 0, 2344, 2345, 5, 255, 0, 0, 2345, 2346, 5, 196, 0, 0, 2346, 2347, 5, 42, 0, 0, 2347, 2348, 3, 32, 16, 0, 2348, 2352, 5, 43, 0, 0, 2349, 2351, 3, 322, 161, 0, 2350, 2349, 1, 0, 0, 0, 2351, 2354, 1, 0, 0, 0, 2352, 2350, 1, 0, 0, 0, 2352, 2353, 1, 0, 0, 0, 2353, 2400, 1, 0, 0, 0, 2354, 2352, 1, 0, 0, 0, 2355, 2356, 5, 255, 0, 0, 2356, 2357, 5, 196, 0, 0, 2357, 2361, 3, 2, 1, 0, 2358, 2360, 3, 322, 161, 0, 2359, 2358, 1, 0, 0, 0, 2360, 2363, 1, 0, 0, 0, 2361, 2359, 1, 0, 0, 0, 2361, 2362, 1, 0, 0, 0, 2362, 2400, 1, 0, 0, 0, 2363, 2361, 1, 0, 0, 0, 2364, 2365, 5, 255, 0, 0, 2365, 2366, 5, 256, 0, 0, 2366, 2367, 5, 42, 0, 0, 2367, 2368, 3, 32, 16, 0, 2368, 2369, 5, 43, 0, 0, 2369, 2370, 5, 28, 0, 0, 2370, 2374, 3, 124, 62, 0, 2371, 2373, 3, 322, 161, 0, 2372, 2371, 1, 0, 0, 0, 2373, 2376, 1, 0, 0, 0, 2374, 2372, 1, 0, 0, 0, 2374, 2375, 1, 0, 0, 0, 2375, 2400, 1, 0, 0, 0, 2376, 2374, 1, 0, 0, 0, 2377, 2378, 5, 255, 0, 0, 2378, 2379, 5, 256, 0, 0, 2379, 2380, 3, 2, 1, 0, 2380, 2381, 5, 28, 0, 0, 2381, 2385, 3, 124, 62, 0, 2382, 2384, 3, 322, 161, 0, 2383, 2382, 1, 0, 0, 0, 2384, 2387, 1, 0, 0, 0, 2385, 2383, 1, 0, 0, 0, 2385, 2386, 1, 0, 0, 0, 2386, 2400, 1, 0, 0, 0, 2387, 2385, 1, 0, 0, 0, 2388, 2389, 5, 255, 0, 0, 2389, 2390, 5, 42, 0, 0, 2390, 2391, 3, 32, 16, 0, 2391, 2392, 5, 43, 0, 0, 2392, 2396, 3, 206, 103, 0, 2393, 2395, 3, 322, 161, 0, 2394, 2393, 1, 0, 0, 0, 2395, 2398, 1, 0, 0, 0, 2396, 2394, 1, 0, 0, 0, 2396, 2397, 1, 0, 0, 0, 2397, 2400, 1, 0, 0, 0, 2398, 2396, 1, 0, 0, 0, 2399, 2301, 1, 0, 0, 0, 2399, 2303, 1, 0, 0, 0, 2399, 2306, 1, 0, 0, 0, 2399, 2307, 1, 0, 0, 0, 2399, 2308, 1, 0, 0, 0, 2399, 2309, 1, 0, 0, 0, 2399, 2310, 1, 0, 0, 0, 2399, 2311, 1, 0, 0, 0, 2399, 2312, 1, 0, 0, 0, 2399, 2317, 1, 0, 0, 0, 2399, 2324, 1, 0, 0, 0, 2399, 2329, 1, 0, 0, 0, 2399, 2334, 1, 0, 0, 0, 2399, 2344, 1, 0, 0, 0, 2399, 2355, 1, 0, 0, 0, 2399, 2364, 1, 0, 0, 0, 2399, 2377, 1, 0, 0, 0, 2399, 2388, 1, 0, 0, 0, 2400, 251, 1, 0, 0, 0, 2401, 2402, 3, 0, 0, 0, 2402, 2403, 5, 75, 0, 0, 2403, 2404, 6, 126, -1, 0, 2404, 253, 1, 0, 0, 0, 2405, 2408, 3, 44, 22, 0, 2406, 2408, 3, 46, 23, 0, 2407, 2405, 1, 0, 0, 0, 2407, 2406, 1, 0, 0, 0, 2408, 255, 1, 0, 0, 0, 2409, 2410, 5, 17, 0, 0, 2410, 2411, 3, 246, 123, 0, 2411, 2412, 5, 18, 0, 0, 2412, 257, 1, 0, 0, 0, 2413, 2414, 3, 262, 131, 0, 2414, 2415, 3, 260, 130, 0, 2415, 259, 1, 0, 0, 0, 2416, 2418, 3, 264, 132, 0, 2417, 2416, 1, 0, 0, 0, 2418, 2419, 1, 0, 0, 0, 2419, 2417, 1, 0, 0, 0, 2419, 2420, 1, 0, 0, 0, 2420, 261, 1, 0, 0, 0, 2421, 2422, 5, 158, 0, 0, 2422, 2434, 3, 256, 128, 0, 2423, 2424, 5, 158, 0, 0, 2424, 2425, 3, 0, 0, 0, 2425, 2426, 5, 159, 0, 0, 2426, 2427, 3, 0, 0, 0, 2427, 2434, 1, 0, 0, 0, 2428, 2429, 5, 158, 0, 0, 2429, 2430, 3, 32, 16, 0, 2430, 2431, 5, 159, 0, 0, 2431, 2432, 3, 32, 16, 0, 2432, 2434, 1, 0, 0, 0, 2433, 2421, 1, 0, 0, 0, 2433, 2423, 1, 0, 0, 0, 2433, 2428, 1, 0, 0, 0, 2434, 263, 1, 0, 0, 0, 2435, 2436, 3, 268, 134, 0, 2436, 2437, 3, 274, 137, 0, 2437, 2448, 1, 0, 0, 0, 2438, 2439, 3, 266, 133, 0, 2439, 2440, 3, 274, 137, 0, 2440, 2448, 1, 0, 0, 0, 2441, 2442, 3, 270, 135, 0, 2442, 2443, 3, 274, 137, 0, 2443, 2448, 1, 0, 0, 0, 2444, 2445, 3, 272, 136, 0, 2445, 2446, 3, 274, 137, 0, 2446, 2448, 1, 0, 0, 0, 2447, 2435, 1, 0, 0, 0, 2447, 2438, 1, 0, 0, 0, 2447, 2441, 1, 0, 0, 0, 2447, 2444, 1, 0, 0, 0, 2448, 265, 1, 0, 0, 0, 2449, 2450, 5, 160, 0, 0, 2450, 2456, 3, 256, 128, 0, 2451, 2452, 5, 160, 0, 0, 2452, 2456, 3, 0, 0, 0, 2453, 2454, 5, 160, 0, 0, 2454, 2456, 3, 32, 16, 0, 2455, 2449, 1, 0, 0, 0, 2455, 2451, 1, 0, 0, 0, 2455, 2453, 1, 0, 0, 0, 2456, 267, 1, 0, 0, 0, 2457, 2458, 5, 161, 0, 0, 2458, 2459, 3, 124, 62, 0, 2459, 269, 1, 0, 0, 0, 2460, 2461, 5, 162, 0, 0, 2461, 271, 1, 0, 0, 0, 2462, 2463, 5, 163, 0, 0, 2463, 273, 1, 0, 0, 0, 2464, 2476, 3, 256, 128, 0, 2465, 2466, 5, 164, 0, 0, 2466, 2467, 3, 0, 0, 0, 2467, 2468, 5, 159, 0, 0, 2468, 2469, 3, 0, 0, 0, 2469, 2476, 1, 0, 0, 0, 2470, 2471, 5, 164, 0, 0, 2471, 2472, 3, 32, 16, 0, 2472, 2473, 5, 159, 0, 0, 2473, 2474, 3, 32, 16, 0, 2474, 2476, 1, 0, 0, 0, 2475, 2464, 1, 0, 0, 0, 2475, 2465, 1, 0, 0, 0, 2475, 2470, 1, 0, 0, 0, 2476, 275, 1, 0, 0, 0, 2477, 2478, 3, 278, 139, 0, 2478, 2479, 3, 282, 141, 0, 2479, 277, 1, 0, 0, 0, 2480, 2481, 5, 165, 0, 0, 2481, 2482, 3, 280, 140, 0, 2482, 2483, 3, 0, 0, 0, 2483, 2484, 5, 36, 0, 0, 2484, 2488, 1, 0, 0, 0, 2485, 2486, 5, 165, 0, 0, 2486, 2488, 3, 280, 140, 0, 2487, 2480, 1, 0, 0, 0, 2487, 2485, 1, 0, 0, 0, 2488, 279, 1, 0, 0, 0, 2489, 2493, 1, 0, 0, 0, 2490, 2493, 5, 166, 0, 0, 2491, 2493, 5, 2, 0, 0, 2492, 2489, 1, 0, 0, 0, 2492, 2490, 1, 0, 0, 0, 2492, 2491, 1, 0, 0, 0, 2493, 281, 1, 0, 0, 0, 2494, 2495, 5, 17, 0, 0, 2495, 2496, 3, 284, 142, 0, 2496, 2497, 5, 18, 0, 0, 2497, 2504, 1, 0, 0, 0, 2498, 2500, 3, 288, 144, 0, 2499, 2498, 1, 0, 0, 0, 2500, 2501, 1, 0, 0, 0, 2501, 2499, 1, 0, 0, 0, 2501, 2502, 1, 0, 0, 0, 2502, 2504, 1, 0, 0, 0, 2503, 2494, 1, 0, 0, 0, 2503, 2499, 1, 0, 0, 0, 2504, 283, 1, 0, 0, 0, 2505, 2506, 3, 288, 144, 0, 2506, 2507, 5, 28, 0, 0, 2507, 2509, 1, 0, 0, 0, 2508, 2505, 1, 0, 0, 0, 2509, 2512, 1, 0, 0, 0, 2510, 2508, 1, 0, 0, 0, 2510, 2511, 1, 0, 0, 0, 2511, 2513, 1, 0, 0, 0, 2512, 2510, 1, 0, 0, 0, 2513, 2514, 3, 288, 144, 0, 2514, 285, 1, 0, 0, 0, 2515, 2521, 1, 0, 0, 0, 2516, 2517, 5, 42, 0, 0, 2517, 2518, 3, 32, 16, 0, 2518, 2519, 5, 43, 0, 0, 2519, 2521, 1, 0, 0, 0, 2520, 2515, 1, 0, 0, 0, 2520, 2516, 1, 0, 0, 0, 2521, 287, 1, 0, 0, 0, 2522, 2523, 5, 181, 0, 0, 2523, 2524, 5, 262, 0, 0, 2524, 2525, 5, 30, 0, 0, 2525, 2526, 3, 6, 3, 0, 2526, 2527, 5, 31, 0, 0, 2527, 2589, 1, 0, 0, 0, 2528, 2529, 5, 260, 0, 0, 2529, 2530, 5, 30, 0, 0, 2530, 2531, 3, 0, 0, 0, 2531, 2532, 5, 31, 0, 0, 2532, 2589, 1, 0, 0, 0, 2533, 2534, 5, 260, 0, 0, 2534, 2589, 3, 0, 0, 0, 2535, 2536, 5, 84, 0, 0, 2536, 2537, 5, 30, 0, 0, 2537, 2538, 3, 292, 146, 0, 2538, 2539, 5, 31, 0, 0, 2539, 2589, 1, 0, 0, 0, 2540, 2541, 5, 188, 0, 0, 2541, 2542, 5, 30, 0, 0, 2542, 2543, 3, 36, 18, 0, 2543, 2544, 5, 31, 0, 0, 2544, 2545, 3, 286, 143, 0, 2545, 2589, 1, 0, 0, 0, 2546, 2547, 5, 189, 0, 0, 2547, 2548, 5, 30, 0, 0, 2548, 2549, 3, 36, 18, 0, 2549, 2550, 5, 31, 0, 0, 2550, 2551, 3, 286, 143, 0, 2551, 2589, 1, 0, 0, 0, 2552, 2553, 5, 187, 0, 0, 2553, 2554, 5, 30, 0, 0, 2554, 2555, 3, 34, 17, 0, 2555, 2556, 5, 31, 0, 0, 2556, 2557, 3, 286, 143, 0, 2557, 2589, 1, 0, 0, 0, 2558, 2559, 5, 186, 0, 0, 2559, 2560, 5, 30, 0, 0, 2560, 2561, 3, 32, 16, 0, 2561, 2562, 5, 31, 0, 0, 2562, 2563, 3, 286, 143, 0, 2563, 2589, 1, 0, 0, 0, 2564, 2565, 5, 185, 0, 0, 2565, 2566, 5, 30, 0, 0, 2566, 2567, 3, 32, 16, 0, 2567, 2568, 5, 31, 0, 0, 2568, 2569, 3, 286, 143, 0, 2569, 2589, 1, 0, 0, 0, 2570, 2571, 5, 184, 0, 0, 2571, 2572, 5, 30, 0, 0, 2572, 2573, 3, 32, 16, 0, 2573, 2574, 5, 31, 0, 0, 2574, 2575, 3, 286, 143, 0, 2575, 2589, 1, 0, 0, 0, 2576, 2577, 5, 188, 0, 0, 2577, 2589, 3, 286, 143, 0, 2578, 2579, 5, 189, 0, 0, 2579, 2589, 3, 286, 143, 0, 2580, 2581, 5, 187, 0, 0, 2581, 2589, 3, 286, 143, 0, 2582, 2583, 5, 186, 0, 0, 2583, 2589, 3, 286, 143, 0, 2584, 2585, 5, 185, 0, 0, 2585, 2589, 3, 286, 143, 0, 2586, 2587, 5, 184, 0, 0, 2587, 2589, 3, 286, 143, 0, 2588, 2522, 1, 0, 0, 0, 2588, 2528, 1, 0, 0, 0, 2588, 2533, 1, 0, 0, 0, 2588, 2535, 1, 0, 0, 0, 2588, 2540, 1, 0, 0, 0, 2588, 2546, 1, 0, 0, 0, 2588, 2552, 1, 0, 0, 0, 2588, 2558, 1, 0, 0, 0, 2588, 2564, 1, 0, 0, 0, 2588, 2570, 1, 0, 0, 0, 2588, 2576, 1, 0, 0, 0, 2588, 2578, 1, 0, 0, 0, 2588, 2580, 1, 0, 0, 0, 2588, 2582, 1, 0, 0, 0, 2588, 2584, 1, 0, 0, 0, 2588, 2586, 1, 0, 0, 0, 2589, 289, 1, 0, 0, 0, 2590, 2591, 5, 188, 0, 0, 2591, 2592, 5, 30, 0, 0, 2592, 2593, 3, 36, 18, 0, 2593, 2594, 5, 31, 0, 0, 2594, 2666, 1, 0, 0, 0, 2595, 2596, 5, 189, 0, 0, 2596, 2597, 5, 30, 0, 0, 2597, 2598, 3, 36, 18, 0, 2598, 2599, 5, 31, 0, 0, 2599, 2666, 1, 0, 0, 0, 2600, 2601, 5, 188, 0, 0, 2601, 2602, 5, 30, 0, 0, 2602, 2603, 3, 32, 16, 0, 2603, 2604, 5, 31, 0, 0, 2604, 2666, 1, 0, 0, 0, 2605, 2606, 5, 189, 0, 0, 2606, 2607, 5, 30, 0, 0, 2607, 2608, 3, 34, 17, 0, 2608, 2609, 5, 31, 0, 0, 2609, 2666, 1, 0, 0, 0, 2610, 2611, 5, 187, 0, 0, 2611, 2612, 5, 30, 0, 0, 2612, 2613, 3, 34, 17, 0, 2613, 2614, 5, 31, 0, 0, 2614, 2666, 1, 0, 0, 0, 2615, 2616, 5, 186, 0, 0, 2616, 2617, 5, 30, 0, 0, 2617, 2618, 3, 32, 16, 0, 2618, 2619, 5, 31, 0, 0, 2619, 2666, 1, 0, 0, 0, 2620, 2621, 5, 185, 0, 0, 2621, 2622, 5, 30, 0, 0, 2622, 2623, 3, 32, 16, 0, 2623, 2624, 5, 31, 0, 0, 2624, 2666, 1, 0, 0, 0, 2625, 2626, 5, 184, 0, 0, 2626, 2627, 5, 30, 0, 0, 2627, 2628, 3, 32, 16, 0, 2628, 2629, 5, 31, 0, 0, 2629, 2666, 1, 0, 0, 0, 2630, 2631, 5, 193, 0, 0, 2631, 2632, 5, 30, 0, 0, 2632, 2633, 3, 34, 17, 0, 2633, 2634, 5, 31, 0, 0, 2634, 2666, 1, 0, 0, 0, 2635, 2636, 5, 192, 0, 0, 2636, 2637, 5, 30, 0, 0, 2637, 2638, 3, 32, 16, 0, 2638, 2639, 5, 31, 0, 0, 2639, 2666, 1, 0, 0, 0, 2640, 2641, 5, 191, 0, 0, 2641, 2642, 5, 30, 0, 0, 2642, 2643, 3, 32, 16, 0, 2643, 2644, 5, 31, 0, 0, 2644, 2666, 1, 0, 0, 0, 2645, 2646, 5, 190, 0, 0, 2646, 2647, 5, 30, 0, 0, 2647, 2648, 3, 32, 16, 0, 2648, 2649, 5, 31, 0, 0, 2649, 2666, 1, 0, 0, 0, 2650, 2651, 5, 181, 0, 0, 2651, 2652, 5, 30, 0, 0, 2652, 2653, 3, 32, 16, 0, 2653, 2654, 5, 31, 0, 0, 2654, 2666, 1, 0, 0, 0, 2655, 2656, 5, 183, 0, 0, 2656, 2657, 5, 30, 0, 0, 2657, 2658, 3, 162, 81, 0, 2658, 2659, 5, 31, 0, 0, 2659, 2666, 1, 0, 0, 0, 2660, 2661, 5, 84, 0, 0, 2661, 2662, 5, 30, 0, 0, 2662, 2663, 3, 292, 146, 0, 2663, 2664, 5, 31, 0, 0, 2664, 2666, 1, 0, 0, 0, 2665, 2590, 1, 0, 0, 0, 2665, 2595, 1, 0, 0, 0, 2665, 2600, 1, 0, 0, 0, 2665, 2605, 1, 0, 0, 0, 2665, 2610, 1, 0, 0, 0, 2665, 2615, 1, 0, 0, 0, 2665, 2620, 1, 0, 0, 0, 2665, 2625, 1, 0, 0, 0, 2665, 2630, 1, 0, 0, 0, 2665, 2635, 1, 0, 0, 0, 2665, 2640, 1, 0, 0, 0, 2665, 2645, 1, 0, 0, 0, 2665, 2650, 1, 0, 0, 0, 2665, 2655, 1, 0, 0, 0, 2665, 2660, 1, 0, 0, 0, 2666, 291, 1, 0, 0, 0, 2667, 2668, 3, 294, 147, 0, 2668, 2669, 6, 146, -1, 0, 2669, 2671, 1, 0, 0, 0, 2670, 2667, 1, 0, 0, 0, 2671, 2674, 1, 0, 0, 0, 2672, 2670, 1, 0, 0, 0, 2672, 2673, 1, 0, 0, 0, 2673, 293, 1, 0, 0, 0, 2674, 2672, 1, 0, 0, 0, 2675, 2676, 7, 12, 0, 0, 2676, 295, 1, 0, 0, 0, 2677, 2681, 3, 290, 145, 0, 2678, 2681, 3, 6, 3, 0, 2679, 2681, 5, 179, 0, 0, 2680, 2677, 1, 0, 0, 0, 2680, 2678, 1, 0, 0, 0, 2680, 2679, 1, 0, 0, 0, 2681, 297, 1, 0, 0, 0, 2682, 2831, 3, 290, 145, 0, 2683, 2684, 5, 182, 0, 0, 2684, 2685, 5, 30, 0, 0, 2685, 2686, 5, 179, 0, 0, 2686, 2831, 5, 31, 0, 0, 2687, 2688, 5, 182, 0, 0, 2688, 2689, 5, 30, 0, 0, 2689, 2690, 5, 264, 0, 0, 2690, 2831, 5, 31, 0, 0, 2691, 2692, 5, 196, 0, 0, 2692, 2693, 5, 30, 0, 0, 2693, 2694, 5, 39, 0, 0, 2694, 2695, 5, 264, 0, 0, 2695, 2831, 5, 31, 0, 0, 2696, 2697, 5, 196, 0, 0, 2697, 2698, 5, 30, 0, 0, 2698, 2699, 3, 116, 58, 0, 2699, 2700, 5, 31, 0, 0, 2700, 2831, 1, 0, 0, 0, 2701, 2702, 5, 196, 0, 0, 2702, 2703, 5, 30, 0, 0, 2703, 2704, 5, 179, 0, 0, 2704, 2831, 5, 31, 0, 0, 2705, 2706, 5, 197, 0, 0, 2706, 2707, 5, 30, 0, 0, 2707, 2708, 3, 298, 149, 0, 2708, 2709, 5, 31, 0, 0, 2709, 2831, 1, 0, 0, 0, 2710, 2711, 5, 188, 0, 0, 2711, 2712, 5, 42, 0, 0, 2712, 2713, 3, 32, 16, 0, 2713, 2714, 5, 43, 0, 0, 2714, 2715, 5, 30, 0, 0, 2715, 2716, 3, 300, 150, 0, 2716, 2717, 5, 31, 0, 0, 2717, 2831, 1, 0, 0, 0, 2718, 2719, 5, 189, 0, 0, 2719, 2720, 5, 42, 0, 0, 2720, 2721, 3, 32, 16, 0, 2721, 2722, 5, 43, 0, 0, 2722, 2723, 5, 30, 0, 0, 2723, 2724, 3, 302, 151, 0, 2724, 2725, 5, 31, 0, 0, 2725, 2831, 1, 0, 0, 0, 2726, 2727, 5, 187, 0, 0, 2727, 2728, 5, 42, 0, 0, 2728, 2729, 3, 32, 16, 0, 2729, 2730, 5, 43, 0, 0, 2730, 2731, 5, 30, 0, 0, 2731, 2732, 3, 304, 152, 0, 2732, 2733, 5, 31, 0, 0, 2733, 2831, 1, 0, 0, 0, 2734, 2735, 5, 186, 0, 0, 2735, 2736, 5, 42, 0, 0, 2736, 2737, 3, 32, 16, 0, 2737, 2738, 5, 43, 0, 0, 2738, 2739, 5, 30, 0, 0, 2739, 2740, 3, 306, 153, 0, 2740, 2741, 5, 31, 0, 0, 2741, 2831, 1, 0, 0, 0, 2742, 2743, 5, 185, 0, 0, 2743, 2744, 5, 42, 0, 0, 2744, 2745, 3, 32, 16, 0, 2745, 2746, 5, 43, 0, 0, 2746, 2747, 5, 30, 0, 0, 2747, 2748, 3, 308, 154, 0, 2748, 2749, 5, 31, 0, 0, 2749, 2831, 1, 0, 0, 0, 2750, 2751, 5, 184, 0, 0, 2751, 2752, 5, 42, 0, 0, 2752, 2753, 3, 32, 16, 0, 2753, 2754, 5, 43, 0, 0, 2754, 2755, 5, 30, 0, 0, 2755, 2756, 3, 310, 155, 0, 2756, 2757, 5, 31, 0, 0, 2757, 2831, 1, 0, 0, 0, 2758, 2759, 5, 193, 0, 0, 2759, 2760, 5, 42, 0, 0, 2760, 2761, 3, 32, 16, 0, 2761, 2762, 5, 43, 0, 0, 2762, 2763, 5, 30, 0, 0, 2763, 2764, 3, 304, 152, 0, 2764, 2765, 5, 31, 0, 0, 2765, 2831, 1, 0, 0, 0, 2766, 2767, 5, 192, 0, 0, 2767, 2768, 5, 42, 0, 0, 2768, 2769, 3, 32, 16, 0, 2769, 2770, 5, 43, 0, 0, 2770, 2771, 5, 30, 0, 0, 2771, 2772, 3, 306, 153, 0, 2772, 2773, 5, 31, 0, 0, 2773, 2831, 1, 0, 0, 0, 2774, 2775, 5, 191, 0, 0, 2775, 2776, 5, 42, 0, 0, 2776, 2777, 3, 32, 16, 0, 2777, 2778, 5, 43, 0, 0, 2778, 2779, 5, 30, 0, 0, 2779, 2780, 3, 308, 154, 0, 2780, 2781, 5, 31, 0, 0, 2781, 2831, 1, 0, 0, 0, 2782, 2783, 5, 190, 0, 0, 2783, 2784, 5, 42, 0, 0, 2784, 2785, 3, 32, 16, 0, 2785, 2786, 5, 43, 0, 0, 2786, 2787, 5, 30, 0, 0, 2787, 2788, 3, 310, 155, 0, 2788, 2789, 5, 31, 0, 0, 2789, 2831, 1, 0, 0, 0, 2790, 2791, 5, 181, 0, 0, 2791, 2792, 5, 42, 0, 0, 2792, 2793, 3, 32, 16, 0, 2793, 2794, 5, 43, 0, 0, 2794, 2795, 5, 30, 0, 0, 2795, 2796, 3, 308, 154, 0, 2796, 2797, 5, 31, 0, 0, 2797, 2831, 1, 0, 0, 0, 2798, 2799, 5, 183, 0, 0, 2799, 2800, 5, 42, 0, 0, 2800, 2801, 3, 32, 16, 0, 2801, 2802, 5, 43, 0, 0, 2802, 2803, 5, 30, 0, 0, 2803, 2804, 3, 312, 156, 0, 2804, 2805, 5, 31, 0, 0, 2805, 2831, 1, 0, 0, 0, 2806, 2807, 5, 182, 0, 0, 2807, 2808, 5, 42, 0, 0, 2808, 2809, 3, 32, 16, 0, 2809, 2810, 5, 43, 0, 0, 2810, 2811, 5, 30, 0, 0, 2811, 2812, 3, 314, 157, 0, 2812, 2813, 5, 31, 0, 0, 2813, 2831, 1, 0, 0, 0, 2814, 2815, 5, 196, 0, 0, 2815, 2816, 5, 42, 0, 0, 2816, 2817, 3, 32, 16, 0, 2817, 2818, 5, 43, 0, 0, 2818, 2819, 5, 30, 0, 0, 2819, 2820, 3, 316, 158, 0, 2820, 2821, 5, 31, 0, 0, 2821, 2831, 1, 0, 0, 0, 2822, 2823, 5, 197, 0, 0, 2823, 2824, 5, 42, 0, 0, 2824, 2825, 3, 32, 16, 0, 2825, 2826, 5, 43, 0, 0, 2826, 2827, 5, 30, 0, 0, 2827, 2828, 3, 320, 160, 0, 2828, 2829, 5, 31, 0, 0, 2829, 2831, 1, 0, 0, 0, 2830, 2682, 1, 0, 0, 0, 2830, 2683, 1, 0, 0, 0, 2830, 2687, 1, 0, 0, 0, 2830, 2691, 1, 0, 0, 0, 2830, 2696, 1, 0, 0, 0, 2830, 2701, 1, 0, 0, 0, 2830, 2705, 1, 0, 0, 0, 2830, 2710, 1, 0, 0, 0, 2830, 2718, 1, 0, 0, 0, 2830, 2726, 1, 0, 0, 0, 2830, 2734, 1, 0, 0, 0, 2830, 2742, 1, 0, 0, 0, 2830, 2750, 1, 0, 0, 0, 2830, 2758, 1, 0, 0, 0, 2830, 2766, 1, 0, 0, 0, 2830, 2774, 1, 0, 0, 0, 2830, 2782, 1, 0, 0, 0, 2830, 2790, 1, 0, 0, 0, 2830, 2798, 1, 0, 0, 0, 2830, 2806, 1, 0, 0, 0, 2830, 2814, 1, 0, 0, 0, 2830, 2822, 1, 0, 0, 0, 2831, 299, 1, 0, 0, 0, 2832, 2835, 3, 36, 18, 0, 2833, 2835, 3, 32, 16, 0, 2834, 2832, 1, 0, 0, 0, 2834, 2833, 1, 0, 0, 0, 2835, 2838, 1, 0, 0, 0, 2836, 2834, 1, 0, 0, 0, 2836, 2837, 1, 0, 0, 0, 2837, 301, 1, 0, 0, 0, 2838, 2836, 1, 0, 0, 0, 2839, 2842, 3, 36, 18, 0, 2840, 2842, 3, 34, 17, 0, 2841, 2839, 1, 0, 0, 0, 2841, 2840, 1, 0, 0, 0, 2842, 2845, 1, 0, 0, 0, 2843, 2841, 1, 0, 0, 0, 2843, 2844, 1, 0, 0, 0, 2844, 303, 1, 0, 0, 0, 2845, 2843, 1, 0, 0, 0, 2846, 2848, 3, 34, 17, 0, 2847, 2846, 1, 0, 0, 0, 2848, 2851, 1, 0, 0, 0, 2849, 2847, 1, 0, 0, 0, 2849, 2850, 1, 0, 0, 0, 2850, 305, 1, 0, 0, 0, 2851, 2849, 1, 0, 0, 0, 2852, 2854, 3, 32, 16, 0, 2853, 2852, 1, 0, 0, 0, 2854, 2857, 1, 0, 0, 0, 2855, 2853, 1, 0, 0, 0, 2855, 2856, 1, 0, 0, 0, 2856, 307, 1, 0, 0, 0, 2857, 2855, 1, 0, 0, 0, 2858, 2860, 3, 32, 16, 0, 2859, 2858, 1, 0, 0, 0, 2860, 2863, 1, 0, 0, 0, 2861, 2859, 1, 0, 0, 0, 2861, 2862, 1, 0, 0, 0, 2862, 309, 1, 0, 0, 0, 2863, 2861, 1, 0, 0, 0, 2864, 2866, 3, 32, 16, 0, 2865, 2864, 1, 0, 0, 0, 2866, 2869, 1, 0, 0, 0, 2867, 2865, 1, 0, 0, 0, 2867, 2868, 1, 0, 0, 0, 2868, 311, 1, 0, 0, 0, 2869, 2867, 1, 0, 0, 0, 2870, 2872, 3, 162, 81, 0, 2871, 2870, 1, 0, 0, 0, 2872, 2875, 1, 0, 0, 0, 2873, 2871, 1, 0, 0, 0, 2873, 2874, 1, 0, 0, 0, 2874, 313, 1, 0, 0, 0, 2875, 2873, 1, 0, 0, 0, 2876, 2878, 7, 13, 0, 0, 2877, 2876, 1, 0, 0, 0, 2878, 2881, 1, 0, 0, 0, 2879, 2877, 1, 0, 0, 0, 2879, 2880, 1, 0, 0, 0, 2880, 315, 1, 0, 0, 0, 2881, 2879, 1, 0, 0, 0, 2882, 2884, 3, 318, 159, 0, 2883, 2882, 1, 0, 0, 0, 2884, 2887, 1, 0, 0, 0, 2885, 2883, 1, 0, 0, 0, 2885, 2886, 1, 0, 0, 0, 2886, 317, 1, 0, 0, 0, 2887, 2885, 1, 0, 0, 0, 2888, 2893, 5, 179, 0, 0, 2889, 2890, 5, 39, 0, 0, 2890, 2893, 5, 264, 0, 0, 2891, 2893, 3, 116, 58, 0, 2892, 2888, 1, 0, 0, 0, 2892, 2889, 1, 0, 0, 0, 2892, 2891, 1, 0, 0, 0, 2893, 319, 1, 0, 0, 0, 2894, 2896, 3, 298, 149, 0, 2895, 2894, 1, 0, 0, 0, 2896, 2899, 1, 0, 0, 0, 2897, 2895, 1, 0, 0, 0, 2897, 2898, 1, 0, 0, 0, 2898, 321, 1, 0, 0, 0, 2899, 2897, 1, 0, 0, 0, 2900, 2904, 3, 44, 22, 0, 2901, 2904, 3, 46, 23, 0, 2902, 2904, 3, 2, 1, 0, 2903, 2900, 1, 0, 0, 0, 2903, 2901, 1, 0, 0, 0, 2903, 2902, 1, 0, 0, 0, 2904, 323, 1, 0, 0, 0, 2905, 2906, 7, 14, 0, 0, 2906, 2907, 5, 36, 0, 0, 2907, 2908, 5, 30, 0, 0, 2908, 2909, 3, 292, 146, 0, 2909, 2910, 5, 31, 0, 0, 2910, 2931, 1, 0, 0, 0, 2911, 2912, 5, 169, 0, 0, 2912, 2913, 3, 38, 19, 0, 2913, 2914, 5, 75, 0, 0, 2914, 2915, 3, 38, 19, 0, 2915, 2916, 5, 75, 0, 0, 2916, 2917, 3, 38, 19, 0, 2917, 2918, 5, 75, 0, 0, 2918, 2919, 3, 38, 19, 0, 2919, 2931, 1, 0, 0, 0, 2920, 2921, 5, 170, 0, 0, 2921, 2931, 3, 6, 3, 0, 2922, 2923, 5, 170, 0, 0, 2923, 2924, 5, 36, 0, 0, 2924, 2925, 5, 30, 0, 0, 2925, 2926, 3, 292, 146, 0, 2926, 2927, 5, 31, 0, 0, 2927, 2931, 1, 0, 0, 0, 2928, 2931, 3, 322, 161, 0, 2929, 2931, 3, 40, 20, 0, 2930, 2905, 1, 0, 0, 0, 2930, 2911, 1, 0, 0, 0, 2930, 2920, 1, 0, 0, 0, 2930, 2922, 1, 0, 0, 0, 2930, 2928, 1, 0, 0, 0, 2930, 2929, 1, 0, 0, 0, 2931, 325, 1, 0, 0, 0, 2932, 2933, 5, 25, 0, 0, 2933, 2934, 5, 40, 0, 0, 2934, 2935, 3, 98, 49, 0, 2935, 2936, 3, 2, 1, 0, 2936, 2945, 1, 0, 0, 0, 2937, 2938, 5, 25, 0, 0, 2938, 2939, 5, 40, 0, 0, 2939, 2940, 3, 98, 49, 0, 2940, 2941, 3, 2, 1, 0, 2941, 2942, 5, 34, 0, 0, 2942, 2943, 3, 2, 1, 0, 2943, 2945, 1, 0, 0, 0, 2944, 2932, 1, 0, 0, 0, 2944, 2937, 1, 0, 0, 0, 2945, 327, 1, 0, 0, 0, 2946, 2948, 3, 330, 165, 0, 2947, 2946, 1, 0, 0, 0, 2948, 2951, 1, 0, 0, 0, 2949, 2947, 1, 0, 0, 0, 2949, 2950, 1, 0, 0, 0, 2950, 329, 1, 0, 0, 0, 2951, 2949, 1, 0, 0, 0, 2952, 2953, 5, 180, 0, 0, 2953, 2954, 5, 36, 0, 0, 2954, 2955, 5, 30, 0, 0, 2955, 2956, 3, 292, 146, 0, 2956, 2957, 5, 31, 0, 0, 2957, 2967, 1, 0, 0, 0, 2958, 2967, 3, 324, 162, 0, 2959, 2960, 5, 171, 0, 0, 2960, 2961, 5, 36, 0, 0, 2961, 2962, 5, 30, 0, 0, 2962, 2963, 3, 292, 146, 0, 2963, 2964, 5, 31, 0, 0, 2964, 2967, 1, 0, 0, 0, 2965, 2967, 5, 55, 0, 0, 2966, 2952, 1, 0, 0, 0, 2966, 2958, 1, 0, 0, 0, 2966, 2959, 1, 0, 0, 0, 2966, 2965, 1, 0, 0, 0, 2967, 331, 1, 0, 0, 0, 2968, 2969, 5, 50, 0, 0, 2969, 2973, 5, 40, 0, 0, 2970, 2972, 3, 336, 168, 0, 2971, 2970, 1, 0, 0, 0, 2972, 2975, 1, 0, 0, 0, 2973, 2971, 1, 0, 0, 0, 2973, 2974, 1, 0, 0, 0, 2974, 2976, 1, 0, 0, 0, 2975, 2973, 1, 0, 0, 0, 2976, 2977, 3, 2, 1, 0, 2977, 333, 1, 0, 0, 0, 2978, 2982, 5, 301, 0, 0, 2979, 2981, 3, 336, 168, 0, 2980, 2979, 1, 0, 0, 0, 2981, 2984, 1, 0, 0, 0, 2982, 2980, 1, 0, 0, 0, 2982, 2983, 1, 0, 0, 0, 2983, 2985, 1, 0, 0, 0, 2984, 2982, 1, 0, 0, 0, 2985, 2986, 3, 2, 1, 0, 2986, 335, 1, 0, 0, 0, 2987, 3003, 5, 52, 0, 0, 2988, 3003, 5, 51, 0, 0, 2989, 3003, 5, 172, 0, 0, 2990, 2991, 5, 62, 0, 0, 2991, 3003, 5, 51, 0, 0, 2992, 2993, 5, 62, 0, 0, 2993, 3003, 5, 52, 0, 0, 2994, 2995, 5, 62, 0, 0, 2995, 3003, 5, 63, 0, 0, 2996, 2997, 5, 62, 0, 0, 2997, 3003, 5, 64, 0, 0, 2998, 2999, 5, 62, 0, 0, 2999, 3003, 5, 65, 0, 0, 3000, 3001, 5, 62, 0, 0, 3001, 3003, 5, 66, 0, 0, 3002, 2987, 1, 0, 0, 0, 3002, 2988, 1, 0, 0, 0, 3002, 2989, 1, 0, 0, 0, 3002, 2990, 1, 0, 0, 0, 3002, 2992, 1, 0, 0, 0, 3002, 2994, 1, 0, 0, 0, 3002, 2996, 1, 0, 0, 0, 3002, 2998, 1, 0, 0, 0, 3002, 3000, 1, 0, 0, 0, 3003, 337, 1, 0, 0, 0, 3004, 3006, 3, 340, 170, 0, 3005, 3004, 1, 0, 0, 0, 3006, 3009, 1, 0, 0, 0, 3007, 3005, 1, 0, 0, 0, 3007, 3008, 1, 0, 0, 0, 3008, 339, 1, 0, 0, 0, 3009, 3007, 1, 0, 0, 0, 3010, 3011, 5, 21, 0, 0, 3011, 3024, 3, 2, 1, 0, 3012, 3013, 5, 50, 0, 0, 3013, 3014, 5, 40, 0, 0, 3014, 3024, 3, 118, 59, 0, 3015, 3016, 5, 25, 0, 0, 3016, 3017, 5, 40, 0, 0, 3017, 3024, 3, 2, 1, 0, 3018, 3024, 3, 174, 87, 0, 3019, 3020, 5, 50, 0, 0, 3020, 3024, 3, 32, 16, 0, 3021, 3024, 3, 322, 161, 0, 3022, 3024, 3, 40, 20, 0, 3023, 3010, 1, 0, 0, 0, 3023, 3012, 1, 0, 0, 0, 3023, 3015, 1, 0, 0, 0, 3023, 3018, 1, 0, 0, 0, 3023, 3019, 1, 0, 0, 0, 3023, 3021, 1, 0, 0, 0, 3023, 3022, 1, 0, 0, 0, 3024, 341, 1, 0, 0, 0, 3025, 3029, 5, 274, 0, 0, 3026, 3028, 3, 344, 172, 0, 3027, 3026, 1, 0, 0, 0, 3028, 3031, 1, 0, 0, 0, 3029, 3027, 1, 0, 0, 0, 3029, 3030, 1, 0, 0, 0, 3030, 3032, 1, 0, 0, 0, 3031, 3029, 1, 0, 0, 0, 3032, 3045, 3, 2, 1, 0, 3033, 3037, 5, 274, 0, 0, 3034, 3036, 3, 344, 172, 0, 3035, 3034, 1, 0, 0, 0, 3036, 3039, 1, 0, 0, 0, 3037, 3035, 1, 0, 0, 0, 3037, 3038, 1, 0, 0, 0, 3038, 3040, 1, 0, 0, 0, 3039, 3037, 1, 0, 0, 0, 3040, 3041, 3, 2, 1, 0, 3041, 3042, 5, 34, 0, 0, 3042, 3043, 3, 2, 1, 0, 3043, 3045, 1, 0, 0, 0, 3044, 3025, 1, 0, 0, 0, 3044, 3033, 1, 0, 0, 0, 3045, 343, 1, 0, 0, 0, 3046, 3047, 7, 15, 0, 0, 3047, 345, 1, 0, 0, 0, 3048, 3050, 3, 348, 174, 0, 3049, 3048, 1, 0, 0, 0, 3050, 3053, 1, 0, 0, 0, 3051, 3049, 1, 0, 0, 0, 3051, 3052, 1, 0, 0, 0, 3052, 347, 1, 0, 0, 0, 3053, 3051, 1, 0, 0, 0, 3054, 3055, 5, 21, 0, 0, 3055, 3056, 3, 2, 1, 0, 3056, 3057, 5, 44, 0, 0, 3057, 3058, 3, 32, 16, 0, 3058, 3065, 1, 0, 0, 0, 3059, 3060, 5, 25, 0, 0, 3060, 3061, 5, 40, 0, 0, 3061, 3065, 3, 2, 1, 0, 3062, 3065, 3, 322, 161, 0, 3063, 3065, 3, 40, 20, 0, 3064, 3054, 1, 0, 0, 0, 3064, 3059, 1, 0, 0, 0, 3064, 3062, 1, 0, 0, 0, 3064, 3063, 1, 0, 0, 0, 3065, 349, 1, 0, 0, 0, 175, 360, 368, 377, 386, 439, 480, 489, 519, 523, 541, 568, 591, 627, 637, 644, 646, 656, 658, 665, 676, 684, 705, 707, 723, 768, 773, 778, 783, 791, 901, 907, 923, 929, 935, 942, 970, 1048, 1050, 1064, 1070, 1079, 1081, 1090, 1104, 1118, 1126, 1134, 1138, 1177, 1185, 1194, 1202, 1221, 1228, 1231, 1250, 1344, 1353, 1360, 1363, 1374, 1406, 1466, 1506, 1522, 1532, 1559, 1583, 1591, 1595, 1610, 1617, 1662, 1672, 1690, 1708, 1727, 1748, 1767, 1782, 1789, 1799, 1812, 1817, 1822, 1831, 1841, 1927, 1936, 1949, 1960, 1968, 1978, 1980, 2007, 2014, 2019, 2026, 2032, 2042, 2046, 2053, 2068, 2074, 2088, 2101, 2109, 2116, 2120, 2127, 2147, 2152, 2154, 2167, 2193, 2200, 2202, 2207, 2213, 2242, 2251, 2274, 2279, 2299, 2352, 2361, 2374, 2385, 2396, 2399, 2407, 2419, 2433, 2447, 2455, 2475, 2487, 2492, 2501, 2503, 2510, 2520, 2588, 2665, 2672, 2680, 2830, 2834, 2836, 2841, 2843, 2849, 2855, 2861, 2867, 2873, 2879, 2885, 2892, 2897, 2903, 2930, 2944, 2949, 2966, 2973, 2982, 3002, 3007, 3023, 3029, 3037, 3044, 3051, 3064] \ No newline at end of file diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs index 3f3536e0e21171..8fdfb7633941a9 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs @@ -344,6 +344,11 @@ public IdContext id() { } public partial class DottedNameContext : ParserRuleContext { + public string Value; + public IToken direct; + public DottedNamePartContext part; + public DottedNamePartContext tail; + public IToken quoted; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DOTTEDNAME() { return GetToken(CILParser.DOTTEDNAME, 0); } [System.Diagnostics.DebuggerNonUserCode] public DottedNamePartContext[] dottedNamePart() { return GetRuleContexts(); @@ -373,50 +378,55 @@ public override TResult Accept(IParseTreeVisitor visitor) { public DottedNameContext dottedName() { DottedNameContext _localctx = new DottedNameContext(Context, State); EnterRule(_localctx, 2, RULE_dottedName); + Actions.BeginDottedName(_localctx); try { int _alt; - State = 363; + State = 368; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,1,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { State = 352; - Match(DOTTEDNAME); + _localctx.direct = Match(DOTTEDNAME); + Actions.AddDottedNameToken(_localctx, _localctx.direct); } break; case 2: EnterOuterAlt(_localctx, 2); { { - State = 358; + State = 360; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,0,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 353; - dottedNamePart(); State = 354; + _localctx.part = dottedNamePart(); + Actions.AddDottedNamePart(_localctx, _localctx.part.Value); + State = 356; Match(DOT); } } } - State = 360; + State = 362; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,0,Context); } - State = 361; - dottedNamePart(); + State = 363; + _localctx.tail = dottedNamePart(); + Actions.AddDottedNamePart(_localctx, _localctx.tail.Value); } } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 362; - Match(SQSTRING); + State = 366; + _localctx.quoted = Match(SQSTRING); + Actions.AddDottedNameToken(_localctx, _localctx.quoted); } break; } @@ -427,12 +437,14 @@ public DottedNameContext dottedName() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndDottedName(_localctx); ExitRule(); } return _localctx; } public partial class DottedNamePartContext : ParserRuleContext { + public string Value; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ID() { return GetToken(CILParser.ID, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VALUE() { return GetToken(CILParser.VALUE, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTANCE() { return GetToken(CILParser.INSTANCE, 0); } @@ -459,7 +471,7 @@ public DottedNamePartContext dottedNamePart() { try { EnterOuterAlt(_localctx, 1); { - State = 365; + State = 370; _la = TokenStream.LA(1); if ( !(_la==T__15 || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50331649L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -469,6 +481,8 @@ public DottedNamePartContext dottedNamePart() { Consume(); } } + Context.Stop = TokenStream.LT(-1); + _localctx.Value = Actions.ParseDottedNamePart(_localctx.Start); } catch (RecognitionException re) { _localctx.exception = re; @@ -515,26 +529,26 @@ public CompQstringContext compQstring() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 372; + State = 377; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,2,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 367; + State = 372; _localctx.head = Match(QSTRING); Actions.AddComposedStringPart(_localctx, _localctx.head); - State = 369; + State = 374; Match(PLUS); } } } - State = 374; + State = 379; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,2,Context); } - State = 375; + State = 380; _localctx.tail = Match(QSTRING); Actions.AddComposedStringPart(_localctx, _localctx.tail); } @@ -580,17 +594,17 @@ public DeclsContext decls() { try { EnterOuterAlt(_localctx, 1); { - State = 381; + State = 386; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1972571905523712L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 281474976710659L) != 0) || ((((_la - 139)) & ~0x3f) == 0 && ((1L << (_la - 139)) & 1729382256977379329L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 6860956837609473L) != 0)) { { { - State = 378; + State = 383; decl(); } } - State = 383; + State = 388; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -724,224 +738,224 @@ public DeclContext decl() { EnterRule(_localctx, 10, RULE_decl); BeginSubtree(); try { - State = 434; + State = 439; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,4,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 384; + State = 389; classHead(); - State = 385; + State = 390; Match(T__16); - State = 386; + State = 391; classDecls(); - State = 387; + State = 392; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 389; + State = 394; nameSpaceHead(); - State = 390; + State = 395; Match(T__16); - State = 391; + State = 396; decls(); - State = 392; + State = 397; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 394; + State = 399; methodHead(); - State = 395; + State = 400; Match(T__16); - State = 396; + State = 401; methodDecls(); - State = 397; + State = 402; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 399; + State = 404; fieldDecl(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 400; + State = 405; dataDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 401; + State = 406; vtableDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 402; + State = 407; vtfixupDecl(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 403; + State = 408; extSourceSpec(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 404; + State = 409; fileDecl(); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 405; + State = 410; assemblyBlock(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 406; + State = 411; assemblyRefHead(); - State = 407; + State = 412; Match(T__16); - State = 408; + State = 413; assemblyRefDecls(); - State = 409; + State = 414; Match(T__17); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 411; + State = 416; exptypeHead(); - State = 412; + State = 417; Match(T__16); - State = 413; + State = 418; exptypeDecls(); - State = 414; + State = 419; Match(T__17); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 416; + State = 421; manifestResHead(); - State = 417; + State = 422; Match(T__16); - State = 418; + State = 423; manifestResDecls(); - State = 419; + State = 424; Match(T__17); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 421; + State = 426; moduleHead(); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 422; + State = 427; secDecl(); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 423; + State = 428; customAttrDecl(); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 424; + State = 429; subsystem(); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 425; + State = 430; corflags(); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 426; + State = 431; alignment(); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 427; + State = 432; imagebase(); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 428; + State = 433; stackreserve(); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 429; + State = 434; languageDecl(); } break; case 23: EnterOuterAlt(_localctx, 23); { - State = 430; + State = 435; typedefDecl(); } break; case 24: EnterOuterAlt(_localctx, 24); { - State = 431; + State = 436; compControl(); } break; case 25: EnterOuterAlt(_localctx, 25); { - State = 432; + State = 437; typelist(); } break; case 26: EnterOuterAlt(_localctx, 26); { - State = 433; + State = 438; mscorlib(); } break; @@ -985,9 +999,9 @@ public SubsystemContext subsystem() { try { EnterOuterAlt(_localctx, 1); { - State = 436; + State = 441; Match(T__18); - State = 437; + State = 442; int32(); } } @@ -1026,9 +1040,9 @@ public CorflagsContext corflags() { try { EnterOuterAlt(_localctx, 1); { - State = 439; + State = 444; Match(T__19); - State = 440; + State = 445; int32(); } } @@ -1067,11 +1081,11 @@ public AlignmentContext alignment() { try { EnterOuterAlt(_localctx, 1); { - State = 442; + State = 447; Match(T__20); - State = 443; + State = 448; Match(T__21); - State = 444; + State = 449; int32(); } } @@ -1110,9 +1124,9 @@ public ImagebaseContext imagebase() { try { EnterOuterAlt(_localctx, 1); { - State = 446; + State = 451; Match(T__22); - State = 447; + State = 452; int64(); } } @@ -1151,9 +1165,9 @@ public StackreserveContext stackreserve() { try { EnterOuterAlt(_localctx, 1); { - State = 449; + State = 454; Match(T__23); - State = 450; + State = 455; int64(); } } @@ -1198,17 +1212,17 @@ public AssemblyBlockContext assemblyBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 452; + State = 457; Match(T__24); - State = 453; + State = 458; asmAttr(); - State = 454; + State = 459; dottedName(); - State = 455; + State = 460; Match(T__16); - State = 456; + State = 461; assemblyDecls(); - State = 457; + State = 462; Match(T__17); } } @@ -1244,7 +1258,7 @@ public MscorlibContext mscorlib() { try { EnterOuterAlt(_localctx, 1); { - State = 459; + State = 464; Match(T__25); } } @@ -1284,45 +1298,45 @@ public LanguageDeclContext languageDecl() { LanguageDeclContext _localctx = new LanguageDeclContext(Context, State); EnterRule(_localctx, 26, RULE_languageDecl); try { - State = 475; + State = 480; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,5,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 461; + State = 466; Match(T__26); - State = 462; + State = 467; languageString(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 463; + State = 468; Match(T__26); - State = 464; + State = 469; languageString(); - State = 465; + State = 470; Match(T__27); - State = 466; + State = 471; languageString(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 468; + State = 473; Match(T__26); - State = 469; + State = 474; languageString(); - State = 470; + State = 475; Match(T__27); - State = 471; + State = 476; languageString(); - State = 472; + State = 477; Match(T__27); - State = 473; + State = 478; languageString(); } break; @@ -1363,7 +1377,7 @@ public LanguageStringContext languageString() { try { EnterOuterAlt(_localctx, 1); { - State = 477; + State = 482; _la = TokenStream.LA(1); if ( !(_la==QSTRING || _la==SQSTRING) ) { ErrorHandler.RecoverInline(this); @@ -1413,25 +1427,25 @@ public TypelistContext typelist() { try { EnterOuterAlt(_localctx, 1); { - State = 479; + State = 484; Match(T__28); - State = 480; + State = 485; Match(T__16); - State = 484; + State = 489; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__15 || _la==T__41 || _la==T__112 || ((((_la - 199)) & ~0x3f) == 0 && ((1L << (_la - 199)) & 2017630225248026625L) != 0) || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50331649L) != 0)) { { { - State = 481; + State = 486; className(); } } - State = 486; + State = 491; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 487; + State = 492; Match(T__17); } } @@ -1468,7 +1482,7 @@ public Int32Context int32() { try { EnterOuterAlt(_localctx, 1); { - State = 489; + State = 494; Match(INT32); } } @@ -1507,7 +1521,7 @@ public Int64Context int64() { try { EnterOuterAlt(_localctx, 1); { - State = 491; + State = 496; _la = TokenStream.LA(1); if ( !(_la==INT32 || _la==INT64) ) { ErrorHandler.RecoverInline(this); @@ -1564,13 +1578,13 @@ public Float64Context float64() { Float64Context _localctx = new Float64Context(Context, State); EnterRule(_localctx, 36, RULE_float64); try { - State = 514; + State = 519; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,7,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 493; + State = 498; _localctx.@decimal = Match(FLOAT64); _localctx.Value = Actions.ParseFloatingLiteral(_localctx.@decimal); } @@ -1578,9 +1592,9 @@ public Float64Context float64() { case 2: EnterOuterAlt(_localctx, 2); { - State = 495; + State = 500; _localctx.trailing = int32(); - State = 496; + State = 501; Match(DOT); _localctx.Value = Actions.ParseFloatingInteger((_localctx.trailing!=null?(_localctx.trailing.Start):null)); } @@ -1588,7 +1602,7 @@ public Float64Context float64() { case 3: EnterOuterAlt(_localctx, 3); { - State = 499; + State = 504; _localctx.integer = int32(); _localctx.Value = Actions.ParseFloatingInteger((_localctx.integer!=null?(_localctx.integer.Start):null)); } @@ -1596,13 +1610,13 @@ public Float64Context float64() { case 4: EnterOuterAlt(_localctx, 4); { - State = 502; + State = 507; Match(FLOAT32); - State = 503; + State = 508; Match(T__29); - State = 504; + State = 509; _localctx.singleBits = int32(); - State = 505; + State = 510; Match(T__30); _localctx.Value = Actions.ParseFloat32Bits((_localctx.singleBits!=null?(_localctx.singleBits.Start):null)); } @@ -1610,13 +1624,13 @@ public Float64Context float64() { case 5: EnterOuterAlt(_localctx, 5); { - State = 508; + State = 513; Match(FLOAT64_); - State = 509; + State = 514; Match(T__29); - State = 510; + State = 515; _localctx.doubleBits = int64(); - State = 511; + State = 516; Match(T__30); _localctx.Value = Actions.ParseFloat64Bits((_localctx.doubleBits!=null?(_localctx.doubleBits.Start):null)); } @@ -1657,20 +1671,20 @@ public IntOrWildcardContext intOrWildcard() { IntOrWildcardContext _localctx = new IntOrWildcardContext(Context, State); EnterRule(_localctx, 38, RULE_intOrWildcard); try { - State = 518; + State = 523; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case INT32: EnterOuterAlt(_localctx, 1); { - State = 516; + State = 521; int32(); } break; case PTR: EnterOuterAlt(_localctx, 2); { - State = 517; + State = 522; Match(PTR); } break; @@ -1717,83 +1731,83 @@ public CompControlContext compControl() { CompControlContext _localctx = new CompControlContext(Context, State); EnterRule(_localctx, 40, RULE_compControl); try { - State = 536; + State = 541; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,9,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 520; + State = 525; Match(PP_DEFINE); - State = 521; + State = 526; Match(ID); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 522; + State = 527; Match(PP_DEFINE); - State = 523; + State = 528; Match(ID); - State = 524; + State = 529; Match(QSTRING); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 525; + State = 530; Match(PP_UNDEF); - State = 526; + State = 531; Match(ID); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 527; + State = 532; Match(PP_IFDEF); - State = 528; + State = 533; Match(ID); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 529; + State = 534; Match(PP_IFNDEF); - State = 530; + State = 535; Match(ID); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 531; + State = 536; Match(PP_ELSE); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 532; + State = 537; Match(PP_ENDIF); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 533; + State = 538; Match(PP_INCLUDE); - State = 534; + State = 539; Match(QSTRING); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 535; + State = 540; Match(T__31); } break; @@ -1847,71 +1861,71 @@ public TypedefDeclContext typedefDecl() { TypedefDeclContext _localctx = new TypedefDeclContext(Context, State); EnterRule(_localctx, 42, RULE_typedefDecl); try { - State = 563; + State = 568; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,10,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 538; + State = 543; Match(T__32); - State = 539; + State = 544; type(); - State = 540; + State = 545; Match(T__33); - State = 541; + State = 546; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 543; + State = 548; Match(T__32); - State = 544; + State = 549; className(); - State = 545; + State = 550; Match(T__33); - State = 546; + State = 551; dottedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 548; + State = 553; Match(T__32); - State = 549; + State = 554; memberRef(); - State = 550; + State = 555; Match(T__33); - State = 551; + State = 556; dottedName(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 553; + State = 558; Match(T__32); - State = 554; + State = 559; customDescr(); - State = 555; + State = 560; Match(T__33); - State = 556; + State = 561; dottedName(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 558; + State = 563; Match(T__32); - State = 559; + State = 564; customDescrWithOwner(); - State = 560; + State = 565; Match(T__33); - State = 561; + State = 566; dottedName(); } break; @@ -1959,62 +1973,62 @@ public CustomDescrContext customDescr() { CustomDescrContext _localctx = new CustomDescrContext(Context, State); EnterRule(_localctx, 44, RULE_customDescr); try { - State = 586; + State = 591; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,11,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 565; + State = 570; Match(T__34); - State = 566; + State = 571; customType(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 567; + State = 572; Match(T__34); - State = 568; + State = 573; customType(); - State = 569; + State = 574; Match(T__35); - State = 570; + State = 575; compQstring(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 572; + State = 577; Match(T__34); - State = 573; + State = 578; customType(); - State = 574; + State = 579; Match(T__35); - State = 575; + State = 580; Match(T__16); - State = 576; + State = 581; customBlobDescr(); - State = 577; + State = 582; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 579; + State = 584; Match(T__34); - State = 580; + State = 585; customType(); - State = 581; + State = 586; Match(T__35); - State = 582; + State = 587; Match(T__29); - State = 583; + State = 588; bytes(); - State = 584; + State = 589; Match(T__30); } break; @@ -2065,86 +2079,86 @@ public CustomDescrWithOwnerContext customDescrWithOwner() { CustomDescrWithOwnerContext _localctx = new CustomDescrWithOwnerContext(Context, State); EnterRule(_localctx, 46, RULE_customDescrWithOwner); try { - State = 622; + State = 627; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,12,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 588; + State = 593; Match(T__34); - State = 589; + State = 594; Match(T__29); - State = 590; + State = 595; ownerType(); - State = 591; + State = 596; Match(T__30); - State = 592; + State = 597; customType(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 594; + State = 599; Match(T__34); - State = 595; + State = 600; Match(T__29); - State = 596; + State = 601; ownerType(); - State = 597; + State = 602; Match(T__30); - State = 598; + State = 603; customType(); - State = 599; + State = 604; Match(T__35); - State = 600; + State = 605; compQstring(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 602; + State = 607; Match(T__34); - State = 603; + State = 608; Match(T__29); - State = 604; + State = 609; ownerType(); - State = 605; + State = 610; Match(T__30); - State = 606; + State = 611; customType(); - State = 607; + State = 612; Match(T__35); - State = 608; + State = 613; Match(T__16); - State = 609; + State = 614; customBlobDescr(); - State = 610; + State = 615; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 612; + State = 617; Match(T__34); - State = 613; + State = 618; Match(T__29); - State = 614; + State = 619; ownerType(); - State = 615; + State = 620; Match(T__30); - State = 616; + State = 621; customType(); - State = 617; + State = 622; Match(T__35); - State = 618; + State = 623; Match(T__29); - State = 619; + State = 624; bytes(); - State = 620; + State = 625; Match(T__30); } break; @@ -2185,7 +2199,7 @@ public CustomTypeContext customType() { try { EnterOuterAlt(_localctx, 1); { - State = 624; + State = 629; methodRef(); } } @@ -2201,6 +2215,10 @@ public CustomTypeContext customType() { } public partial class OwnerTypeContext : ParserRuleContext { + public object Value; + public bool HasSyntaxError; + public TypeSpecContext typeValue; + public MemberRefContext member; [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() { return GetRuleContext(0); } @@ -2224,23 +2242,25 @@ public override TResult Accept(IParseTreeVisitor visitor) { public OwnerTypeContext ownerType() { OwnerTypeContext _localctx = new OwnerTypeContext(Context, State); EnterRule(_localctx, 50, RULE_ownerType); - BeginSubtree(); + Actions.BeginSemanticRoot(_localctx); try { - State = 628; + State = 637; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,13,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 626; - typeSpec(); + State = 631; + _localctx.typeValue = typeSpec(); + _localctx.Value = Actions.CreateTypeOwner(_localctx.typeValue.Value); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 627; - memberRef(); + State = 634; + _localctx.member = memberRef(); + _localctx.Value = Actions.CreateMemberOwner(_localctx.member.Value); } break; } @@ -2251,7 +2271,7 @@ public OwnerTypeContext ownerType() { ErrorHandler.Recover(this, re); } finally { - EndParseTreeMode(); + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); ExitRule(); } return _localctx; @@ -2284,9 +2304,9 @@ public CustomBlobDescrContext customBlobDescr() { try { EnterOuterAlt(_localctx, 1); { - State = 630; + State = 639; customBlobArgs(); - State = 631; + State = 640; customBlobNVPairs(); } } @@ -2335,13 +2355,13 @@ public CustomBlobArgsContext customBlobArgs() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 637; + State = 646; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,15,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { - State = 635; + State = 644; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__83: @@ -2361,7 +2381,7 @@ public CustomBlobArgsContext customBlobArgs() { case TYPE: case OBJECT: { - State = 633; + State = 642; serInit(); } break; @@ -2374,7 +2394,7 @@ public CustomBlobArgsContext customBlobArgs() { case PP_ENDIF: case PP_INCLUDE: { - State = 634; + State = 643; compControl(); } break; @@ -2383,7 +2403,7 @@ public CustomBlobArgsContext customBlobArgs() { } } } - State = 639; + State = 648; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,15,Context); } @@ -2452,26 +2472,26 @@ public CustomBlobNVPairsContext customBlobNVPairs() { try { EnterOuterAlt(_localctx, 1); { - State = 649; + State = 658; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 416611827712L) != 0) || ((((_la - 267)) & ~0x3f) == 0 && ((1L << (_la - 267)) & 127L) != 0)) { { - State = 647; + State = 656; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__36: case T__37: { - State = 640; + State = 649; fieldOrProp(); - State = 641; + State = 650; serializType(); - State = 642; + State = 651; dottedName(); - State = 643; + State = 652; Match(T__35); - State = 644; + State = 653; serInit(); } break; @@ -2484,7 +2504,7 @@ public CustomBlobNVPairsContext customBlobNVPairs() { case PP_ENDIF: case PP_INCLUDE: { - State = 646; + State = 655; compControl(); } break; @@ -2492,7 +2512,7 @@ public CustomBlobNVPairsContext customBlobNVPairs() { throw new NoViableAltException(this); } } - State = 651; + State = 660; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -2531,7 +2551,7 @@ public FieldOrPropContext fieldOrProp() { try { EnterOuterAlt(_localctx, 1); { - State = 652; + State = 661; _la = TokenStream.LA(1); if ( !(_la==T__36 || _la==T__37) ) { ErrorHandler.RecoverInline(this); @@ -2579,14 +2599,14 @@ public SerializTypeContext serializType() { try { EnterOuterAlt(_localctx, 1); { - State = 654; + State = 663; serializTypeElement(); - State = 656; + State = 665; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==ARRAY_TYPE_NO_BOUNDS) { { - State = 655; + State = 664; Match(ARRAY_TYPE_NO_BOUNDS); } } @@ -2636,54 +2656,54 @@ public SerializTypeElementContext serializTypeElement() { SerializTypeElementContext _localctx = new SerializTypeElementContext(Context, State); EnterRule(_localctx, 62, RULE_serializTypeElement); try { - State = 667; + State = 676; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,19,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 658; + State = 667; simpleType(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 659; + State = 668; dottedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 660; + State = 669; Match(TYPE); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 661; + State = 670; Match(OBJECT); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 662; + State = 671; Match(ENUM); - State = 663; + State = 672; Match(T__38); - State = 664; + State = 673; Match(SQSTRING); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 665; + State = 674; Match(ENUM); - State = 666; + State = 675; className(); } break; @@ -2723,33 +2743,33 @@ public ModuleHeadContext moduleHead() { ModuleHeadContext _localctx = new ModuleHeadContext(Context, State); EnterRule(_localctx, 64, RULE_moduleHead); try { - State = 675; + State = 684; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,20,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 669; + State = 678; Match(MODULE); - State = 670; + State = 679; Match(T__39); - State = 671; + State = 680; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 672; + State = 681; Match(MODULE); - State = 673; + State = 682; dottedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 674; + State = 683; Match(MODULE); } break; @@ -2796,19 +2816,19 @@ public VtfixupDeclContext vtfixupDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 677; + State = 686; Match(T__40); - State = 678; + State = 687; Match(T__41); - State = 679; + State = 688; int32(); - State = 680; + State = 689; Match(T__42); - State = 681; + State = 690; vtfixupAttr(0); - State = 682; + State = 691; Match(T__43); - State = 683; + State = 692; id(); } } @@ -2861,7 +2881,7 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { } Context.Stop = TokenStream.LT(-1); - State = 698; + State = 707; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,22,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { @@ -2870,16 +2890,16 @@ private VtfixupAttrContext vtfixupAttr(int _p) { TriggerExitRuleEvent(); _prevctx = _localctx; { - State = 696; + State = 705; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,21,Context) ) { case 1: { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 686; + State = 695; if (!(Precpred(Context, 5))) throw new FailedPredicateException(this, "Precpred(Context, 5)"); - State = 687; + State = 696; Match(INT32_); } break; @@ -2887,9 +2907,9 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 688; + State = 697; if (!(Precpred(Context, 4))) throw new FailedPredicateException(this, "Precpred(Context, 4)"); - State = 689; + State = 698; Match(INT64_); } break; @@ -2897,9 +2917,9 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 690; + State = 699; if (!(Precpred(Context, 3))) throw new FailedPredicateException(this, "Precpred(Context, 3)"); - State = 691; + State = 700; Match(T__44); } break; @@ -2907,9 +2927,9 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 692; + State = 701; if (!(Precpred(Context, 2))) throw new FailedPredicateException(this, "Precpred(Context, 2)"); - State = 693; + State = 702; Match(T__45); } break; @@ -2917,16 +2937,16 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 694; + State = 703; if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)"); - State = 695; + State = 704; Match(T__46); } break; } } } - State = 700; + State = 709; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,22,Context); } @@ -2967,15 +2987,15 @@ public VtableDeclContext vtableDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 701; + State = 710; Match(T__47); - State = 702; + State = 711; Match(T__35); - State = 703; + State = 712; Match(T__29); - State = 704; + State = 713; bytes(); - State = 705; + State = 714; Match(T__30); } } @@ -3015,9 +3035,9 @@ public NameSpaceHeadContext nameSpaceHead() { try { EnterOuterAlt(_localctx, 1); { - State = 707; + State = 716; Match(T__48); - State = 708; + State = 717; dottedName(); } Context.Stop = TokenStream.LT(-1); @@ -3076,31 +3096,31 @@ public ClassHeadContext classHead() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 710; + State = 719; Match(T__49); - State = 714; + State = 723; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,23,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 711; + State = 720; classAttr(); } } } - State = 716; + State = 725; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,23,Context); } - State = 717; + State = 726; dottedName(); - State = 718; + State = 727; typarsClause(); - State = 719; + State = 728; extendsClause(); - State = 720; + State = 729; implClause(); } Context.Stop = TokenStream.LT(-1); @@ -3145,213 +3165,213 @@ public ClassAttrContext classAttr() { ClassAttrContext _localctx = new ClassAttrContext(Context, State); EnterRule(_localctx, 76, RULE_classAttr); try { - State = 759; + State = 768; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,24,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 722; + State = 731; Match(T__50); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 723; + State = 732; Match(T__51); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 724; + State = 733; Match(VALUE); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 725; + State = 734; Match(ENUM); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 726; + State = 735; Match(INTERFACE); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 727; + State = 736; Match(T__52); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 728; + State = 737; Match(T__53); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 729; + State = 738; Match(T__54); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 730; + State = 739; Match(T__55); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 731; + State = 740; Match(EXPLICIT); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 732; + State = 741; Match(T__14); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 733; + State = 742; Match(ANSI); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 734; + State = 743; Match(T__56); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 735; + State = 744; Match(T__57); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 736; + State = 745; Match(T__58); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 737; + State = 746; Match(T__59); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 738; + State = 747; Match(T__60); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 739; + State = 748; Match(T__61); - State = 740; + State = 749; Match(T__50); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 741; + State = 750; Match(T__61); - State = 742; + State = 751; Match(T__51); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 743; + State = 752; Match(T__61); - State = 744; + State = 753; Match(T__62); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 745; + State = 754; Match(T__61); - State = 746; + State = 755; Match(T__63); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 747; + State = 756; Match(T__61); - State = 748; + State = 757; Match(T__64); } break; case 23: EnterOuterAlt(_localctx, 23); { - State = 749; + State = 758; Match(T__61); - State = 750; + State = 759; Match(T__65); } break; case 24: EnterOuterAlt(_localctx, 24); { - State = 751; + State = 760; Match(T__66); } break; case 25: EnterOuterAlt(_localctx, 25); { - State = 752; + State = 761; Match(T__67); } break; case 26: EnterOuterAlt(_localctx, 26); { - State = 753; + State = 762; Match(T__68); } break; case 27: EnterOuterAlt(_localctx, 27); { - State = 754; + State = 763; Match(T__69); - State = 755; + State = 764; Match(T__29); - State = 756; + State = 765; int32(); - State = 757; + State = 766; Match(T__30); } break; @@ -3390,7 +3410,7 @@ public ExtendsClauseContext extendsClause() { ExtendsClauseContext _localctx = new ExtendsClauseContext(Context, State); EnterRule(_localctx, 78, RULE_extendsClause); try { - State = 764; + State = 773; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -3402,9 +3422,9 @@ public ExtendsClauseContext extendsClause() { case T__70: EnterOuterAlt(_localctx, 2); { - State = 762; + State = 771; Match(T__70); - State = 763; + State = 772; typeSpec(); } break; @@ -3445,7 +3465,7 @@ public ImplClauseContext implClause() { ImplClauseContext _localctx = new ImplClauseContext(Context, State); EnterRule(_localctx, 80, RULE_implClause); try { - State = 769; + State = 778; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -3456,9 +3476,9 @@ public ImplClauseContext implClause() { case T__71: EnterOuterAlt(_localctx, 2); { - State = 767; + State = 776; Match(T__71); - State = 768; + State = 777; implList(); } break; @@ -3506,17 +3526,17 @@ public ClassDeclsContext classDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 774; + State = 783; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1125938695831552L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 1189425290649010179L) != 0) || ((((_la - 139)) & ~0x3f) == 0 && ((1L << (_la - 139)) & 1152921504673955841L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 871552083145265153L) != 0)) { { { - State = 771; + State = 780; classDecl(); } } - State = 776; + State = 785; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -3562,25 +3582,25 @@ public ImplListContext implList() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 782; + State = 791; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,28,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 777; + State = 786; typeSpec(); - State = 778; + State = 787; Match(T__27); } } } - State = 784; + State = 793; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,28,Context); } - State = 785; + State = 794; typeSpec(); } } @@ -3617,7 +3637,7 @@ public EsHeadContext esHead() { try { EnterOuterAlt(_localctx, 1); { - State = 787; + State = 796; _la = TokenStream.LA(1); if ( !(_la==T__72 || _la==T__73) ) { ErrorHandler.RecoverInline(this); @@ -3669,257 +3689,257 @@ public ExtSourceSpecContext extSourceSpec() { ExtSourceSpecContext _localctx = new ExtSourceSpecContext(Context, State); EnterRule(_localctx, 88, RULE_extSourceSpec); try { - State = 892; + State = 901; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,29,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 789; + State = 798; esHead(); - State = 790; + State = 799; int32(); - State = 791; + State = 800; Match(SQSTRING); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 793; + State = 802; esHead(); - State = 794; + State = 803; int32(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 796; + State = 805; esHead(); - State = 797; + State = 806; int32(); - State = 798; + State = 807; Match(T__74); - State = 799; + State = 808; int32(); - State = 800; + State = 809; Match(SQSTRING); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 802; + State = 811; esHead(); - State = 803; + State = 812; int32(); - State = 804; + State = 813; Match(T__74); - State = 805; + State = 814; int32(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 807; + State = 816; esHead(); - State = 808; + State = 817; int32(); - State = 809; + State = 818; Match(T__74); - State = 810; + State = 819; int32(); - State = 811; + State = 820; Match(T__27); - State = 812; + State = 821; int32(); - State = 813; + State = 822; Match(SQSTRING); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 815; + State = 824; esHead(); - State = 816; + State = 825; int32(); - State = 817; + State = 826; Match(T__74); - State = 818; + State = 827; int32(); - State = 819; + State = 828; Match(T__27); - State = 820; + State = 829; int32(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 822; + State = 831; esHead(); - State = 823; + State = 832; int32(); - State = 824; + State = 833; Match(T__27); - State = 825; + State = 834; int32(); - State = 826; + State = 835; Match(T__74); - State = 827; + State = 836; int32(); - State = 828; + State = 837; Match(SQSTRING); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 830; + State = 839; esHead(); - State = 831; + State = 840; int32(); - State = 832; + State = 841; Match(T__27); - State = 833; + State = 842; int32(); - State = 834; + State = 843; Match(T__74); - State = 835; + State = 844; int32(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 837; + State = 846; esHead(); - State = 838; + State = 847; int32(); - State = 839; + State = 848; Match(T__27); - State = 840; + State = 849; int32(); - State = 841; + State = 850; Match(T__74); - State = 842; + State = 851; int32(); - State = 843; + State = 852; Match(T__27); - State = 844; + State = 853; int32(); - State = 845; + State = 854; Match(SQSTRING); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 847; + State = 856; esHead(); - State = 848; + State = 857; int32(); - State = 849; + State = 858; Match(T__27); - State = 850; + State = 859; int32(); - State = 851; + State = 860; Match(T__74); - State = 852; + State = 861; int32(); - State = 853; + State = 862; Match(T__27); - State = 854; + State = 863; int32(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 856; + State = 865; esHead(); - State = 857; + State = 866; int32(); - State = 858; + State = 867; Match(QSTRING); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 860; + State = 869; esHead(); - State = 861; + State = 870; int32(); - State = 862; + State = 871; Match(T__74); - State = 863; + State = 872; int32(); - State = 864; + State = 873; Match(QSTRING); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 866; + State = 875; esHead(); - State = 867; + State = 876; int32(); - State = 868; + State = 877; Match(T__74); - State = 869; + State = 878; int32(); - State = 870; + State = 879; Match(T__27); - State = 871; + State = 880; int32(); - State = 872; + State = 881; Match(QSTRING); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 874; + State = 883; esHead(); - State = 875; + State = 884; int32(); - State = 876; + State = 885; Match(T__27); - State = 877; + State = 886; int32(); - State = 878; + State = 887; Match(T__74); - State = 879; + State = 888; int32(); - State = 880; + State = 889; Match(QSTRING); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 882; + State = 891; esHead(); - State = 883; + State = 892; int32(); - State = 884; + State = 893; Match(T__27); - State = 885; + State = 894; int32(); - State = 886; + State = 895; Match(T__74); - State = 887; + State = 896; int32(); - State = 888; + State = 897; Match(T__27); - State = 889; + State = 898; int32(); - State = 890; + State = 899; Match(QSTRING); } break; @@ -3975,68 +3995,68 @@ public FileDeclContext fileDecl() { EnterRule(_localctx, 90, RULE_fileDecl); int _la; try { - State = 920; + State = 929; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,32,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 894; + State = 903; Match(T__20); - State = 898; + State = 907; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__75) { { { - State = 895; + State = 904; fileAttr(); } } - State = 900; + State = 909; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 901; + State = 910; dottedName(); - State = 902; + State = 911; fileEntry(); - State = 903; + State = 912; Match(HASH); - State = 904; + State = 913; Match(T__35); - State = 905; + State = 914; Match(T__29); - State = 906; + State = 915; bytes(); - State = 907; + State = 916; Match(T__30); - State = 908; + State = 917; fileEntry(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 910; + State = 919; Match(T__20); - State = 914; + State = 923; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__75) { { { - State = 911; + State = 920; fileAttr(); } } - State = 916; + State = 925; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 917; + State = 926; dottedName(); - State = 918; + State = 927; fileEntry(); } break; @@ -4074,7 +4094,7 @@ public FileAttrContext fileAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 922; + State = 931; Match(T__75); } } @@ -4109,7 +4129,7 @@ public FileEntryContext fileEntry() { FileEntryContext _localctx = new FileEntryContext(Context, State); EnterRule(_localctx, 94, RULE_fileEntry); try { - State = 926; + State = 935; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -4159,7 +4179,7 @@ public FileEntryContext fileEntry() { case ENTRYPOINT: EnterOuterAlt(_localctx, 2); { - State = 925; + State = 934; Match(ENTRYPOINT); } break; @@ -4200,7 +4220,7 @@ public AsmAttrAnyContext asmAttrAny() { try { EnterOuterAlt(_localctx, 1); { - State = 928; + State = 937; _la = TokenStream.LA(1); if ( !(_la==T__1 || _la==T__60 || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 127L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -4250,17 +4270,17 @@ public AsmAttrContext asmAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 933; + State = 942; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__1 || _la==T__60 || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 127L) != 0)) { { { - State = 930; + State = 939; asmAttrAny(); } } - State = 935; + State = 944; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -4329,22 +4349,22 @@ public InstrContext instr() { InstrContext _localctx = new InstrContext(Context, State); EnterRule(_localctx, 100, RULE_instr); try { - State = 961; + State = 970; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,35,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 936; + State = 945; simpleInstr(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 937; + State = 946; _localctx.op = Match(INSTR_METHOD); - State = 938; + State = 947; _localctx.methodOperand = methodRef(); Actions.EmitMethodReferenceInstruction(_localctx.op, _localctx.methodOperand); } @@ -4352,9 +4372,9 @@ public InstrContext instr() { case 3: EnterOuterAlt(_localctx, 3); { - State = 941; + State = 950; _localctx.op = Match(INSTR_FIELD); - State = 942; + State = 951; _localctx.fieldOperand = fieldRef(); Actions.EmitFieldReferenceInstruction(_localctx.op, _localctx.fieldOperand); } @@ -4362,9 +4382,9 @@ public InstrContext instr() { case 4: EnterOuterAlt(_localctx, 4); { - State = 945; + State = 954; _localctx.op = Match(INSTR_FIELD); - State = 946; + State = 955; _localctx.metadataOperand = mdtoken(); Actions.EmitMetadataTokenInstruction(_localctx.op, _localctx.metadataOperand); } @@ -4372,9 +4392,9 @@ public InstrContext instr() { case 5: EnterOuterAlt(_localctx, 5); { - State = 949; + State = 958; _localctx.op = Match(INSTR_TYPE); - State = 950; + State = 959; _localctx.typeOperand = typeSpec(); Actions.EmitTypeReferenceInstruction(_localctx.op, _localctx.typeOperand); } @@ -4382,9 +4402,9 @@ public InstrContext instr() { case 6: EnterOuterAlt(_localctx, 6); { - State = 953; + State = 962; _localctx.op = Match(INSTR_SIG); - State = 954; + State = 963; _localctx.signatureOperand = calliSignature(); Actions.EmitCalliInstruction(_localctx.op, _localctx.signatureOperand); } @@ -4392,9 +4412,9 @@ public InstrContext instr() { case 7: EnterOuterAlt(_localctx, 7); { - State = 957; + State = 966; _localctx.op = Match(INSTR_TOK); - State = 958; + State = 967; _localctx.ownerOperand = ownerType(); Actions.EmitOwnerTokenInstruction(_localctx.op, _localctx.ownerOperand); } @@ -4476,13 +4496,13 @@ public SimpleInstrContext simpleInstr() { SimpleInstrContext _localctx = new SimpleInstrContext(Context, State); EnterRule(_localctx, 102, RULE_simpleInstr); try { - State = 1041; + State = 1050; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,37,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 963; + State = 972; _localctx.op = Match(INSTR_NONE); Actions.EmitNoOperandInstruction(_localctx.op); } @@ -4490,9 +4510,9 @@ public SimpleInstrContext simpleInstr() { case 2: EnterOuterAlt(_localctx, 2); { - State = 965; + State = 974; _localctx.op = Match(INSTR_VAR); - State = 966; + State = 975; _localctx.index = int32(); Actions.EmitVariableIndexInstruction(_localctx.op, (_localctx.index!=null?(_localctx.index.Start):null)); } @@ -4500,9 +4520,9 @@ public SimpleInstrContext simpleInstr() { case 3: EnterOuterAlt(_localctx, 3); { - State = 969; + State = 978; _localctx.op = Match(INSTR_VAR); - State = 970; + State = 979; _localctx.name = id(); Actions.EmitVariableNameInstruction(_localctx.op, (_localctx.name!=null?(_localctx.name.Start):null)); } @@ -4510,9 +4530,9 @@ public SimpleInstrContext simpleInstr() { case 4: EnterOuterAlt(_localctx, 4); { - State = 973; + State = 982; _localctx.op = Match(INSTR_I); - State = 974; + State = 983; _localctx.value32 = int32(); Actions.EmitInt32Instruction(_localctx.op, (_localctx.value32!=null?(_localctx.value32.Start):null)); } @@ -4520,9 +4540,9 @@ public SimpleInstrContext simpleInstr() { case 5: EnterOuterAlt(_localctx, 5); { - State = 977; + State = 986; _localctx.op = Match(INSTR_I8); - State = 978; + State = 987; _localctx.value64 = int64(); Actions.EmitInt64Instruction(_localctx.op, (_localctx.value64!=null?(_localctx.value64.Start):null)); } @@ -4530,9 +4550,9 @@ public SimpleInstrContext simpleInstr() { case 6: EnterOuterAlt(_localctx, 6); { - State = 981; + State = 990; _localctx.op = Match(INSTR_R); - State = 982; + State = 991; _localctx.value = float64(); Actions.EmitFloatingInstruction(_localctx.op, _localctx.value.Value); } @@ -4540,9 +4560,9 @@ public SimpleInstrContext simpleInstr() { case 7: EnterOuterAlt(_localctx, 7); { - State = 985; + State = 994; _localctx.op = Match(INSTR_R); - State = 986; + State = 995; _localctx.integerValue = int64(); Actions.EmitFloatingInstruction(_localctx.op, (_localctx.integerValue!=null?(_localctx.integerValue.Start):null)); } @@ -4550,13 +4570,13 @@ public SimpleInstrContext simpleInstr() { case 8: EnterOuterAlt(_localctx, 8); { - State = 989; + State = 998; _localctx.op = Match(INSTR_R); - State = 990; + State = 999; Match(T__29); - State = 991; + State = 1000; _localctx.rawFloat = bytes(); - State = 992; + State = 1001; Match(T__30); Actions.EmitRawFloatingInstruction(_localctx.op, _localctx.rawFloat.Value, (_localctx.rawFloat!=null?(_localctx.rawFloat.Start):null)); } @@ -4564,15 +4584,15 @@ public SimpleInstrContext simpleInstr() { case 9: EnterOuterAlt(_localctx, 9); { - State = 995; + State = 1004; _localctx.op = Match(INSTR_R); - State = 996; + State = 1005; Match(T__83); - State = 997; + State = 1006; Match(T__29); - State = 998; + State = 1007; _localctx.rawFloat = bytes(); - State = 999; + State = 1008; Match(T__30); Actions.EmitRawFloatingInstruction(_localctx.op, _localctx.rawFloat.Value, (_localctx.rawFloat!=null?(_localctx.rawFloat.Start):null)); } @@ -4580,9 +4600,9 @@ public SimpleInstrContext simpleInstr() { case 10: EnterOuterAlt(_localctx, 10); { - State = 1002; + State = 1011; _localctx.op = Match(INSTR_BRTARGET); - State = 1003; + State = 1012; _localctx.offset = int32(); Actions.EmitBranchOffsetInstruction(_localctx.op, (_localctx.offset!=null?(_localctx.offset.Start):null)); } @@ -4590,9 +4610,9 @@ public SimpleInstrContext simpleInstr() { case 11: EnterOuterAlt(_localctx, 11); { - State = 1006; + State = 1015; _localctx.op = Match(INSTR_BRTARGET); - State = 1007; + State = 1016; _localctx.label = id(); Actions.EmitBranchLabelInstruction(_localctx.op, (_localctx.label!=null?(_localctx.label.Start):null)); } @@ -4600,9 +4620,9 @@ public SimpleInstrContext simpleInstr() { case 12: EnterOuterAlt(_localctx, 12); { - State = 1010; + State = 1019; _localctx.op = Match(INSTR_STRING); - State = 1011; + State = 1020; _localctx.userString = compQstring(); Actions.EmitStringInstruction(_localctx.op, _localctx.userString.Value); } @@ -4610,15 +4630,15 @@ public SimpleInstrContext simpleInstr() { case 13: EnterOuterAlt(_localctx, 13); { - State = 1014; + State = 1023; _localctx.op = Match(INSTR_STRING); - State = 1015; + State = 1024; Match(ANSI); - State = 1016; + State = 1025; Match(T__29); - State = 1017; + State = 1026; _localctx.ansiString = compQstring(); - State = 1018; + State = 1027; Match(T__30); Actions.EmitAnsiStringInstruction(_localctx.op, _localctx.ansiString.Value); } @@ -4626,15 +4646,15 @@ public SimpleInstrContext simpleInstr() { case 14: EnterOuterAlt(_localctx, 14); { - State = 1021; + State = 1030; _localctx.op = Match(INSTR_STRING); - State = 1022; + State = 1031; Match(T__83); - State = 1023; + State = 1032; Match(T__29); - State = 1024; + State = 1033; _localctx.rawString = bytes(); - State = 1025; + State = 1034; Match(T__30); Actions.EmitRawStringInstruction(_localctx.op, _localctx.rawString.Value); } @@ -4642,9 +4662,9 @@ public SimpleInstrContext simpleInstr() { case 15: EnterOuterAlt(_localctx, 15); { - State = 1028; + State = 1037; _localctx.op = Match(INSTR_TOK); - State = 1029; + State = 1038; _localctx.rawToken = int32(); Actions.EmitRawTokenInstruction(_localctx.op, (_localctx.rawToken!=null?(_localctx.rawToken.Start):null)); } @@ -4652,25 +4672,25 @@ public SimpleInstrContext simpleInstr() { case 16: EnterOuterAlt(_localctx, 16); { - State = 1032; + State = 1041; _localctx.op = Match(INSTR_SWITCH); Actions.BeginSwitchInstruction(_localctx, _localctx.op); - State = 1039; + State = 1048; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__29: { - State = 1034; + State = 1043; Match(T__29); - State = 1035; + State = 1044; labels(); - State = 1036; + State = 1045; Match(T__30); } break; case T__84: { - State = 1038; + State = 1047; Match(T__84); } break; @@ -4696,6 +4716,11 @@ public SimpleInstrContext simpleInstr() { } public partial class CalliSignatureContext : ParserRuleContext { + public object Value; + public bool HasSyntaxError; + public CallConvContext convention; + public TypeContext returnType; + public SigArgsContext arguments; [System.Diagnostics.DebuggerNonUserCode] public CallConvContext callConv() { return GetRuleContext(0); } @@ -4722,16 +4747,17 @@ public override TResult Accept(IParseTreeVisitor visitor) { public CalliSignatureContext calliSignature() { CalliSignatureContext _localctx = new CalliSignatureContext(Context, State); EnterRule(_localctx, 104, RULE_calliSignature); - BeginSubtree(); + Actions.BeginSemanticRoot(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 1043; - callConv(); - State = 1044; - type(); - State = 1045; - sigArgs(); + State = 1052; + _localctx.convention = callConv(); + State = 1053; + _localctx.returnType = type(); + State = 1054; + _localctx.arguments = sigArgs(); + _localctx.Value = Actions.CreateCalliSignature(_localctx.convention.Value, _localctx.returnType.Value, _localctx.arguments.Value); } } catch (RecognitionException re) { @@ -4740,7 +4766,7 @@ public CalliSignatureContext calliSignature() { ErrorHandler.Recover(this, re); } finally { - EndParseTreeMode(); + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); ExitRule(); } return _localctx; @@ -4782,7 +4808,7 @@ public LabelsContext labels() { EnterRule(_localctx, 106, RULE_labels); try { int _alt; - State = 1071; + State = 1081; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__30: @@ -4813,14 +4839,14 @@ public LabelsContext labels() { case ID: EnterOuterAlt(_localctx, 2); { - State = 1060; + State = 1070; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,39,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1054; + State = 1064; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -4844,14 +4870,14 @@ public LabelsContext labels() { case SQSTRING: case ID: { - State = 1048; + State = 1058; _localctx.headLabel = id(); Actions.AddSwitchLabel((_localctx.headLabel!=null?(_localctx.headLabel.Start):null)); } break; case INT32: { - State = 1051; + State = 1061; _localctx.headOffset = int32(); Actions.AddSwitchOffset((_localctx.headOffset!=null?(_localctx.headOffset.Start):null)); } @@ -4859,16 +4885,16 @@ public LabelsContext labels() { default: throw new NoViableAltException(this); } - State = 1056; + State = 1066; Match(T__27); } } } - State = 1062; + State = 1072; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,39,Context); } - State = 1069; + State = 1079; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -4892,14 +4918,14 @@ public LabelsContext labels() { case SQSTRING: case ID: { - State = 1063; + State = 1073; _localctx.tailLabel = id(); Actions.AddSwitchLabel((_localctx.tailLabel!=null?(_localctx.tailLabel.Start):null)); } break; case INT32: { - State = 1066; + State = 1076; _localctx.tailOffset = int32(); Actions.AddSwitchOffset((_localctx.tailOffset!=null?(_localctx.tailOffset.Start):null)); } @@ -4925,6 +4951,9 @@ public LabelsContext labels() { } public partial class TypeArgsContext : ParserRuleContext { + public object Value; + public TypeContext argument; + public TypeContext lastArgument; [System.Diagnostics.DebuggerNonUserCode] public TypeContext[] type() { return GetRuleContexts(); } @@ -4948,33 +4977,36 @@ public override TResult Accept(IParseTreeVisitor visitor) { public TypeArgsContext typeArgs() { TypeArgsContext _localctx = new TypeArgsContext(Context, State); EnterRule(_localctx, 108, RULE_typeArgs); + Actions.BeginTypeArguments(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1073; + State = 1083; Match(T__85); - State = 1079; + State = 1090; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,42,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1074; - type(); - State = 1075; + State = 1084; + _localctx.argument = type(); + Actions.AddTypeArgument(_localctx, _localctx.argument.Value); + State = 1086; Match(T__27); } } } - State = 1081; + State = 1092; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,42,Context); } - State = 1082; - type(); - State = 1083; + State = 1093; + _localctx.lastArgument = type(); + Actions.AddTypeArgument(_localctx, _localctx.lastArgument.Value); + State = 1095; Match(T__86); } } @@ -4984,12 +5016,16 @@ public TypeArgsContext typeArgs() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndTypeArguments(_localctx); ExitRule(); } return _localctx; } public partial class BoundsContext : ParserRuleContext { + public object Value; + public BoundContext item; + public BoundContext lastItem; [System.Diagnostics.DebuggerNonUserCode] public BoundContext[] bound() { return GetRuleContexts(); } @@ -5013,33 +5049,36 @@ public override TResult Accept(IParseTreeVisitor visitor) { public BoundsContext bounds() { BoundsContext _localctx = new BoundsContext(Context, State); EnterRule(_localctx, 110, RULE_bounds); + Actions.BeginBounds(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1085; + State = 1097; Match(T__41); - State = 1091; + State = 1104; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,43,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1086; - bound(); - State = 1087; + State = 1098; + _localctx.item = bound(); + Actions.AddBound(_localctx, _localctx.item); + State = 1100; Match(T__27); } } } - State = 1093; + State = 1106; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,43,Context); } - State = 1094; - bound(); - State = 1095; + State = 1107; + _localctx.lastItem = bound(); + Actions.AddBound(_localctx, _localctx.lastItem); + State = 1109; Match(T__42); } } @@ -5049,12 +5088,16 @@ public BoundsContext bounds() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndBounds(_localctx); ExitRule(); } return _localctx; } public partial class SigArgsContext : ParserRuleContext { + public object Value; + public SigArgContext argument; + public SigArgContext lastArgument; [System.Diagnostics.DebuggerNonUserCode] public SigArgContext[] sigArg() { return GetRuleContexts(); } @@ -5078,44 +5121,47 @@ public override TResult Accept(IParseTreeVisitor visitor) { public SigArgsContext sigArgs() { SigArgsContext _localctx = new SigArgsContext(Context, State); EnterRule(_localctx, 112, RULE_sigArgs); + Actions.BeginSignatureArguments(_localctx); try { int _alt; - State = 1110; + State = 1126; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__29: EnterOuterAlt(_localctx, 1); { - State = 1097; + State = 1111; Match(T__29); - State = 1103; + State = 1118; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,44,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1098; - sigArg(); - State = 1099; + State = 1112; + _localctx.argument = sigArg(); + Actions.AddSignatureArgument(_localctx, _localctx.argument.Value); + State = 1114; Match(T__27); } } } - State = 1105; + State = 1120; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,44,Context); } - State = 1106; - sigArg(); - State = 1107; + State = 1121; + _localctx.lastArgument = sigArg(); + Actions.AddSignatureArgument(_localctx, _localctx.lastArgument.Value); + State = 1123; Match(T__30); } break; case T__84: EnterOuterAlt(_localctx, 2); { - State = 1109; + State = 1125; Match(T__84); } break; @@ -5129,12 +5175,18 @@ public SigArgsContext sigArgs() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndSignatureArguments(_localctx); ExitRule(); } return _localctx; } public partial class SigArgContext : ParserRuleContext { + public object Value; + public ParamAttrContext attributes; + public TypeContext argumentType; + public MarshalClauseContext marshalling; + public IdContext name; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ELLIPSIS() { return GetToken(CILParser.ELLIPSIS, 0); } [System.Diagnostics.DebuggerNonUserCode] public ParamAttrContext paramAttr() { return GetRuleContext(0); @@ -5167,35 +5219,37 @@ public SigArgContext sigArg() { EnterRule(_localctx, 114, RULE_sigArg); int _la; try { - State = 1119; + State = 1138; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,47,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1112; + State = 1128; Match(ELLIPSIS); + _localctx.Value = Actions.CreateSentinelSignatureArgument(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1113; - paramAttr(); - State = 1114; - type(); - State = 1115; - marshalClause(); - State = 1117; + State = 1130; + _localctx.attributes = paramAttr(); + State = 1131; + _localctx.argumentType = type(); + State = 1132; + _localctx.marshalling = marshalClause(); + State = 1134; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 65534L) != 0) || ((((_la - 199)) & ~0x3f) == 0 && ((1L << (_la - 199)) & 299067162755073L) != 0) || _la==SQSTRING || _la==ID) { { - State = 1116; - id(); + State = 1133; + _localctx.name = id(); } } + _localctx.Value = Actions.CreateSignatureArgument(_localctx.attributes.Value, _localctx.argumentType.Value, _localctx.marshalling, _localctx.name); } break; } @@ -5212,6 +5266,12 @@ public SigArgContext sigArg() { } public partial class ClassNameContext : ParserRuleContext { + public object Value; + public DottedNameContext assemblyName; + public SlashedNameContext typeName; + public MdtokenContext scopeToken; + public DottedNameContext moduleName; + public MdtokenContext typeToken; [System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() { return GetRuleContext(0); } @@ -5244,96 +5304,105 @@ public ClassNameContext className() { ClassNameContext _localctx = new ClassNameContext(Context, State); EnterRule(_localctx, 116, RULE_className); try { - State = 1146; + State = 1177; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,48,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1121; + State = 1140; Match(T__41); - State = 1122; - dottedName(); - State = 1123; + State = 1141; + _localctx.assemblyName = dottedName(); + State = 1142; Match(T__42); - State = 1124; - slashedName(); + State = 1143; + _localctx.typeName = slashedName(); + _localctx.Value = Actions.CreateAssemblyQualifiedClassName(_localctx.assemblyName.Value, _localctx.typeName.Value); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1126; + State = 1146; Match(T__41); - State = 1127; - mdtoken(); - State = 1128; + State = 1147; + _localctx.scopeToken = mdtoken(); + State = 1148; Match(T__42); - State = 1129; - slashedName(); + State = 1149; + _localctx.typeName = slashedName(); + _localctx.Value = Actions.CreateTokenQualifiedClassName(_localctx.scopeToken.Value, _localctx.typeName.Value); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1131; + State = 1152; Match(T__41); - State = 1132; + State = 1153; Match(PTR); - State = 1133; + State = 1154; Match(T__42); - State = 1134; - slashedName(); + State = 1155; + _localctx.typeName = slashedName(); + _localctx.Value = Actions.CreatePointerQualifiedClassName(_localctx.typeName.Value); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1135; + State = 1158; Match(T__41); - State = 1136; + State = 1159; Match(MODULE); - State = 1137; - dottedName(); - State = 1138; + State = 1160; + _localctx.moduleName = dottedName(); + State = 1161; Match(T__42); - State = 1139; - slashedName(); + State = 1162; + _localctx.typeName = slashedName(); + _localctx.Value = Actions.CreateModuleQualifiedClassName(_localctx.Start, _localctx.moduleName.Value, _localctx.typeName.Value); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1141; - slashedName(); + State = 1165; + _localctx.typeName = slashedName(); + _localctx.Value = Actions.CreateUnqualifiedClassName(_localctx.typeName.Value); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1142; - mdtoken(); + State = 1168; + _localctx.typeToken = mdtoken(); + _localctx.Value = Actions.CreateTokenClassName(_localctx.typeToken.Value); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1143; + State = 1171; Match(THIS); + _localctx.Value = Actions.CreateThisClassName(_localctx.Start); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1144; + State = 1173; Match(BASE); + _localctx.Value = Actions.CreateBaseClassName(_localctx.Start); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 1145; + State = 1175; Match(NESTER); + _localctx.Value = Actions.CreateNesterClassName(_localctx.Start); } break; } @@ -5350,6 +5419,9 @@ public ClassNameContext className() { } public partial class SlashedNameContext : ParserRuleContext { + public object Value; + public DottedNameContext part; + public DottedNameContext lastPart; [System.Diagnostics.DebuggerNonUserCode] public DottedNameContext[] dottedName() { return GetRuleContexts(); } @@ -5373,30 +5445,33 @@ public override TResult Accept(IParseTreeVisitor visitor) { public SlashedNameContext slashedName() { SlashedNameContext _localctx = new SlashedNameContext(Context, State); EnterRule(_localctx, 118, RULE_slashedName); + Actions.BeginSlashedName(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1153; + State = 1185; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,49,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1148; - dottedName(); - State = 1149; + State = 1179; + _localctx.part = dottedName(); + Actions.AddSlashedNamePart(_localctx, _localctx.part.Value); + State = 1181; Match(T__87); } } } - State = 1155; + State = 1187; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,49,Context); } - State = 1156; - dottedName(); + State = 1188; + _localctx.lastPart = dottedName(); + Actions.AddSlashedNamePart(_localctx, _localctx.lastPart.Value); } } catch (RecognitionException re) { @@ -5405,6 +5480,7 @@ public SlashedNameContext slashedName() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndSlashedName(_localctx); ExitRule(); } return _localctx; @@ -5438,17 +5514,17 @@ public AssemblyDeclsContext assemblyDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 1161; + State = 1194; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38654771200L) != 0) || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & 4294975503L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 6860954690125825L) != 0)) { { { - State = 1158; + State = 1191; assemblyDecl(); } } - State = 1163; + State = 1196; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -5494,18 +5570,18 @@ public AssemblyDeclContext assemblyDecl() { AssemblyDeclContext _localctx = new AssemblyDeclContext(Context, State); EnterRule(_localctx, 122, RULE_assemblyDecl); try { - State = 1169; + State = 1202; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case HASH: EnterOuterAlt(_localctx, 1); { { - State = 1164; + State = 1197; Match(HASH); - State = 1165; + State = 1198; Match(T__88); - State = 1166; + State = 1199; int32(); } } @@ -5514,7 +5590,7 @@ public AssemblyDeclContext assemblyDecl() { case PERMISSIONSET: EnterOuterAlt(_localctx, 2); { - State = 1167; + State = 1200; secDecl(); } break; @@ -5539,7 +5615,7 @@ public AssemblyDeclContext assemblyDecl() { case ID: EnterOuterAlt(_localctx, 3); { - State = 1168; + State = 1201; asmOrRefDecl(); } break; @@ -5559,6 +5635,12 @@ public AssemblyDeclContext assemblyDecl() { } public partial class TypeSpecContext : ParserRuleContext { + public object Value; + public bool HasSyntaxError; + public ClassNameContext classType; + public DottedNameContext assemblyName; + public DottedNameContext moduleName; + public TypeContext signatureType; [System.Diagnostics.DebuggerNonUserCode] public ClassNameContext className() { return GetRuleContext(0); } @@ -5586,47 +5668,51 @@ public override TResult Accept(IParseTreeVisitor visitor) { public TypeSpecContext typeSpec() { TypeSpecContext _localctx = new TypeSpecContext(Context, State); EnterRule(_localctx, 124, RULE_typeSpec); - BeginSubtree(); + Actions.BeginSemanticRoot(_localctx); try { - State = 1182; + State = 1221; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,52,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1171; - className(); + State = 1204; + _localctx.classType = className(); + _localctx.Value = Actions.CreateClassTypeSpecification(_localctx.classType.Value); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1172; + State = 1207; Match(T__41); - State = 1173; - dottedName(); - State = 1174; + State = 1208; + _localctx.assemblyName = dottedName(); + State = 1209; Match(T__42); + _localctx.Value = Actions.CreateAssemblyTypeSpecification(_localctx.assemblyName.Value); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1176; + State = 1212; Match(T__41); - State = 1177; + State = 1213; Match(MODULE); - State = 1178; - dottedName(); - State = 1179; + State = 1214; + _localctx.moduleName = dottedName(); + State = 1215; Match(T__42); + _localctx.Value = Actions.CreateModuleTypeSpecification(_localctx.moduleName.Value); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1181; - type(); + State = 1218; + _localctx.signatureType = type(); + _localctx.Value = Actions.CreateSignatureTypeSpecification(_localctx.signatureType.Value); } break; } @@ -5637,7 +5723,7 @@ public TypeSpecContext typeSpec() { ErrorHandler.Recover(this, re); } finally { - EndParseTreeMode(); + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); ExitRule(); } return _localctx; @@ -5672,7 +5758,7 @@ public NativeTypeContext nativeType() { EnterRule(_localctx, 126, RULE_nativeType); try { int _alt; - State = 1192; + State = 1231; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,54,Context) ) { case 1: @@ -5683,21 +5769,21 @@ public NativeTypeContext nativeType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1185; + State = 1224; nativeTypeElement(); - State = 1189; + State = 1228; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,53,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1186; + State = 1225; nativeTypeArrayPointerInfo(); } } } - State = 1191; + State = 1230; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,53,Context); } @@ -5795,14 +5881,14 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { NativeTypeArrayPointerInfoContext _localctx = new NativeTypeArrayPointerInfoContext(Context, State); EnterRule(_localctx, 128, RULE_nativeTypeArrayPointerInfo); try { - State = 1211; + State = 1250; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,55,Context) ) { case 1: _localctx = new PointerNativeTypeContext(_localctx); EnterOuterAlt(_localctx, 1); { - State = 1194; + State = 1233; Match(PTR); } break; @@ -5810,7 +5896,7 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeNoSizeDataContext(_localctx); EnterOuterAlt(_localctx, 2); { - State = 1195; + State = 1234; Match(ARRAY_TYPE_NO_BOUNDS); } break; @@ -5818,11 +5904,11 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeSizeContext(_localctx); EnterOuterAlt(_localctx, 3); { - State = 1196; + State = 1235; Match(T__41); - State = 1197; + State = 1236; int32(); - State = 1198; + State = 1237; Match(T__42); } break; @@ -5830,15 +5916,15 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeSizeParamIndexContext(_localctx); EnterOuterAlt(_localctx, 4); { - State = 1200; + State = 1239; Match(T__41); - State = 1201; + State = 1240; int32(); - State = 1202; + State = 1241; Match(PLUS); - State = 1203; + State = 1242; int32(); - State = 1204; + State = 1243; Match(T__42); } break; @@ -5846,13 +5932,13 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeParamIndexContext(_localctx); EnterOuterAlt(_localctx, 5); { - State = 1206; + State = 1245; Match(T__41); - State = 1207; + State = 1246; Match(PLUS); - State = 1208; + State = 1247; int32(); - State = 1209; + State = 1248; Match(T__42); } break; @@ -5952,7 +6038,7 @@ public NativeTypeElementContext nativeTypeElement() { NativeTypeElementContext _localctx = new NativeTypeElementContext(Context, State); EnterRule(_localctx, 130, RULE_nativeTypeElement); try { - State = 1305; + State = 1344; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,56,Context) ) { case 1: @@ -5963,412 +6049,412 @@ public NativeTypeElementContext nativeTypeElement() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1214; + State = 1253; _localctx.marshalType = Match(CUSTOM); - State = 1215; + State = 1254; Match(T__29); - State = 1216; + State = 1255; compQstring(); - State = 1217; + State = 1256; Match(T__27); - State = 1218; + State = 1257; compQstring(); - State = 1219; + State = 1258; Match(T__27); - State = 1220; + State = 1259; compQstring(); - State = 1221; + State = 1260; Match(T__27); - State = 1222; + State = 1261; compQstring(); - State = 1223; + State = 1262; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1225; + State = 1264; _localctx.marshalType = Match(CUSTOM); - State = 1226; + State = 1265; Match(T__29); - State = 1227; + State = 1266; compQstring(); - State = 1228; + State = 1267; Match(T__27); - State = 1229; + State = 1268; compQstring(); - State = 1230; + State = 1269; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1232; + State = 1271; Match(FIXED); - State = 1233; + State = 1272; _localctx.marshalType = Match(SYSSTRING); - State = 1234; + State = 1273; Match(T__41); - State = 1235; + State = 1274; int32(); - State = 1236; + State = 1275; Match(T__42); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1238; + State = 1277; Match(FIXED); - State = 1239; + State = 1278; _localctx.marshalType = Match(ARRAY); - State = 1240; + State = 1279; Match(T__41); - State = 1241; + State = 1280; int32(); - State = 1242; + State = 1281; Match(T__42); - State = 1243; + State = 1282; nativeType(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1245; + State = 1284; _localctx.marshalType = Match(VARIANT); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1246; + State = 1285; _localctx.marshalType = Match(CURRENCY); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1247; + State = 1286; _localctx.marshalType = Match(SYSCHAR); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 1248; + State = 1287; _localctx.marshalType = Match(VOID); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 1249; + State = 1288; _localctx.marshalType = Match(BOOL); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 1250; + State = 1289; _localctx.marshalType = Match(INT8); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 1251; + State = 1290; _localctx.marshalType = Match(INT16); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 1252; + State = 1291; _localctx.marshalType = Match(INT32_); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 1253; + State = 1292; _localctx.marshalType = Match(INT64_); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 1254; + State = 1293; _localctx.marshalType = Match(FLOAT32); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 1255; + State = 1294; _localctx.marshalType = Match(FLOAT64_); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 1256; + State = 1295; _localctx.marshalType = Match(ERROR); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 1257; + State = 1296; _localctx.marshalType = Match(UINT8); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 1258; + State = 1297; _localctx.marshalType = Match(UINT16); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 1259; + State = 1298; _localctx.marshalType = Match(UINT32); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 1260; + State = 1299; _localctx.marshalType = Match(UINT64); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 1261; + State = 1300; _localctx.marshalType = Match(DECIMAL); } break; case 23: EnterOuterAlt(_localctx, 23); { - State = 1262; + State = 1301; _localctx.marshalType = Match(DATE); } break; case 24: EnterOuterAlt(_localctx, 24); { - State = 1263; + State = 1302; _localctx.marshalType = Match(BSTR); } break; case 25: EnterOuterAlt(_localctx, 25); { - State = 1264; + State = 1303; _localctx.marshalType = Match(LPSTR); } break; case 26: EnterOuterAlt(_localctx, 26); { - State = 1265; + State = 1304; _localctx.marshalType = Match(LPWSTR); } break; case 27: EnterOuterAlt(_localctx, 27); { - State = 1266; + State = 1305; _localctx.marshalType = Match(LPTSTR); } break; case 28: EnterOuterAlt(_localctx, 28); { - State = 1267; + State = 1306; _localctx.marshalType = Match(OBJECTREF); } break; case 29: EnterOuterAlt(_localctx, 29); { - State = 1268; + State = 1307; _localctx.marshalType = Match(IUNKNOWN); - State = 1269; + State = 1308; iidParamIndex(); } break; case 30: EnterOuterAlt(_localctx, 30); { - State = 1270; + State = 1309; _localctx.marshalType = Match(IDISPATCH); - State = 1271; + State = 1310; iidParamIndex(); } break; case 31: EnterOuterAlt(_localctx, 31); { - State = 1272; + State = 1311; _localctx.marshalType = Match(STRUCT); } break; case 32: EnterOuterAlt(_localctx, 32); { - State = 1273; + State = 1312; _localctx.marshalType = Match(INTERFACE); - State = 1274; + State = 1313; iidParamIndex(); } break; case 33: EnterOuterAlt(_localctx, 33); { - State = 1275; + State = 1314; _localctx.marshalType = Match(SAFEARRAY); - State = 1276; + State = 1315; variantType(); } break; case 34: EnterOuterAlt(_localctx, 34); { - State = 1277; + State = 1316; _localctx.marshalType = Match(SAFEARRAY); - State = 1278; + State = 1317; variantType(); - State = 1279; + State = 1318; Match(T__27); - State = 1280; + State = 1319; compQstring(); } break; case 35: EnterOuterAlt(_localctx, 35); { - State = 1282; + State = 1321; _localctx.marshalType = Match(INT); } break; case 36: EnterOuterAlt(_localctx, 36); { - State = 1283; + State = 1322; _localctx.marshalType = Match(UINT); } break; case 37: EnterOuterAlt(_localctx, 37); { - State = 1284; + State = 1323; Match(T__89); - State = 1285; + State = 1324; _localctx.unsignedMarshalType = Match(INT8); } break; case 38: EnterOuterAlt(_localctx, 38); { - State = 1286; + State = 1325; Match(T__89); - State = 1287; + State = 1326; _localctx.unsignedMarshalType = Match(INT16); } break; case 39: EnterOuterAlt(_localctx, 39); { - State = 1288; + State = 1327; Match(T__89); - State = 1289; + State = 1328; _localctx.unsignedMarshalType = Match(INT32_); } break; case 40: EnterOuterAlt(_localctx, 40); { - State = 1290; + State = 1329; Match(T__89); - State = 1291; + State = 1330; _localctx.unsignedMarshalType = Match(INT64_); } break; case 41: EnterOuterAlt(_localctx, 41); { - State = 1292; + State = 1331; Match(T__61); - State = 1293; + State = 1332; _localctx.marshalType = Match(STRUCT); } break; case 42: EnterOuterAlt(_localctx, 42); { - State = 1294; + State = 1333; _localctx.marshalType = Match(BYVALSTR); } break; case 43: EnterOuterAlt(_localctx, 43); { - State = 1295; + State = 1334; Match(ANSI); - State = 1296; + State = 1335; _localctx.marshalType = Match(BSTR); } break; case 44: EnterOuterAlt(_localctx, 44); { - State = 1297; + State = 1336; _localctx.marshalType = Match(TBSTR); } break; case 45: EnterOuterAlt(_localctx, 45); { - State = 1298; + State = 1337; Match(VARIANT); - State = 1299; + State = 1338; _localctx.marshalBool = Match(BOOL); } break; case 46: EnterOuterAlt(_localctx, 46); { - State = 1300; + State = 1339; _localctx.marshalType = Match(METHOD); } break; case 47: EnterOuterAlt(_localctx, 47); { - State = 1301; + State = 1340; _localctx.marshalType = Match(LPSTRUCT); } break; case 48: EnterOuterAlt(_localctx, 48); { - State = 1302; + State = 1341; Match(T__33); - State = 1303; + State = 1342; _localctx.marshalType = Match(ANY); } break; case 49: EnterOuterAlt(_localctx, 49); { - State = 1304; + State = 1343; dottedName(); } break; @@ -6407,7 +6493,7 @@ public IidParamIndexContext iidParamIndex() { IidParamIndexContext _localctx = new IidParamIndexContext(Context, State); EnterRule(_localctx, 132, RULE_iidParamIndex); try { - State = 1314; + State = 1353; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__30: @@ -6421,15 +6507,15 @@ public IidParamIndexContext iidParamIndex() { case T__29: EnterOuterAlt(_localctx, 2); { - State = 1308; + State = 1347; Match(T__29); - State = 1309; + State = 1348; Match(T__90); - State = 1310; + State = 1349; Match(T__35); - State = 1311; + State = 1350; int32(); - State = 1312; + State = 1351; Match(T__30); } break; @@ -6484,7 +6570,7 @@ public VariantTypeContext variantType() { int _la; try { int _alt; - State = 1324; + State = 1363; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,59,Context) ) { case 1: @@ -6495,16 +6581,16 @@ public VariantTypeContext variantType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1317; + State = 1356; variantTypeElement(); - State = 1321; + State = 1360; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,58,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1318; + State = 1357; _la = TokenStream.LA(1); if ( !(((((_la - 229)) & ~0x3f) == 0 && ((1L << (_la - 229)) & 6442450945L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -6516,7 +6602,7 @@ public VariantTypeContext variantType() { } } } - State = 1323; + State = 1362; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,58,Context); } @@ -6597,7 +6683,7 @@ public VariantTypeElementContext variantTypeElement() { try { EnterOuterAlt(_localctx, 1); { - State = 1326; + State = 1365; _la = TokenStream.LA(1); if ( !(((((_la - 178)) & ~0x3f) == 0 && ((1L << (_la - 178)) & -4482436704239647L) != 0) || _la==CLSID || _la==PTR) ) { ErrorHandler.RecoverInline(this); @@ -6620,6 +6706,9 @@ public VariantTypeElementContext variantTypeElement() { } public partial class TypeContext : ParserRuleContext { + public object Value; + public ElementTypeContext element; + public TypeModifiersContext modifier; [System.Diagnostics.DebuggerNonUserCode] public ElementTypeContext elementType() { return GetRuleContext(0); } @@ -6646,25 +6735,28 @@ public override TResult Accept(IParseTreeVisitor visitor) { public TypeContext type() { TypeContext _localctx = new TypeContext(Context, State); EnterRule(_localctx, 138, RULE_type); + Actions.BeginTypeSignature(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1328; - elementType(); - State = 1332; + State = 1367; + _localctx.element = elementType(); + Actions.SetTypeSignatureElement(_localctx, _localctx.element.Value); + State = 1374; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,60,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1329; - typeModifiers(); + State = 1369; + _localctx.modifier = typeModifiers(); + Actions.AddTypeSignatureModifier(_localctx, _localctx.modifier.Value); } } } - State = 1334; + State = 1376; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,60,Context); } @@ -6676,12 +6768,14 @@ public TypeContext type() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndTypeSignature(_localctx); ExitRule(); } return _localctx; } public partial class TypeModifiersContext : ParserRuleContext { + public object Value; public TypeModifiersContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { @@ -6691,9 +6785,11 @@ public TypeModifiersContext(ParserRuleContext parent, int invokingState) public TypeModifiersContext() { } public virtual void CopyFrom(TypeModifiersContext context) { base.CopyFrom(context); + this.Value = context.Value; } } public partial class OptionalModifierContext : TypeModifiersContext { + public TypeSpecContext modifierType; [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() { return GetRuleContext(0); } @@ -6716,6 +6812,7 @@ public override TResult Accept(IParseTreeVisitor visitor) { } } public partial class RequiredModifierContext : TypeModifiersContext { + public TypeSpecContext modifierType; [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() { return GetRuleContext(0); } @@ -6747,6 +6844,7 @@ public override TResult Accept(IParseTreeVisitor visitor) { } } public partial class GenericArgumentsModifierContext : TypeModifiersContext { + public TypeArgsContext arguments; [System.Diagnostics.DebuggerNonUserCode] public TypeArgsContext typeArgs() { return GetRuleContext(0); } @@ -6769,6 +6867,7 @@ public override TResult Accept(IParseTreeVisitor visitor) { } } public partial class ArrayModifierContext : TypeModifiersContext { + public BoundsContext arrayBounds; [System.Diagnostics.DebuggerNonUserCode] public BoundsContext bounds() { return GetRuleContext(0); } @@ -6786,93 +6885,102 @@ public TypeModifiersContext typeModifiers() { TypeModifiersContext _localctx = new TypeModifiersContext(Context, State); EnterRule(_localctx, 140, RULE_typeModifiers); try { - State = 1353; + State = 1406; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,61,Context) ) { case 1: _localctx = new SZArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 1); { - State = 1335; + State = 1377; Match(ARRAY_TYPE_NO_BOUNDS); + _localctx.Value = Actions.CreateSzArrayTypeModifier(); } break; case 2: _localctx = new SZArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 2); { - State = 1336; + State = 1379; Match(T__41); - State = 1337; + State = 1380; Match(T__42); + _localctx.Value = Actions.CreateSzArrayTypeModifier(); } break; case 3: _localctx = new ArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 3); { - State = 1338; - bounds(); + State = 1382; + ((ArrayModifierContext)_localctx).arrayBounds = bounds(); + _localctx.Value = Actions.CreateArrayTypeModifier(((ArrayModifierContext)_localctx).arrayBounds.Value); } break; case 4: _localctx = new ByRefModifierContext(_localctx); EnterOuterAlt(_localctx, 4); { - State = 1339; + State = 1385; Match(REF); + _localctx.Value = Actions.CreateByReferenceTypeModifier(); } break; case 5: _localctx = new PtrModifierContext(_localctx); EnterOuterAlt(_localctx, 5); { - State = 1340; + State = 1387; Match(PTR); + _localctx.Value = Actions.CreatePointerTypeModifier(); } break; case 6: _localctx = new PinnedModifierContext(_localctx); EnterOuterAlt(_localctx, 6); { - State = 1341; + State = 1389; Match(T__91); + _localctx.Value = Actions.CreatePinnedTypeModifier(); } break; case 7: _localctx = new RequiredModifierContext(_localctx); EnterOuterAlt(_localctx, 7); { - State = 1342; + State = 1391; Match(T__92); - State = 1343; + State = 1392; Match(T__29); - State = 1344; - typeSpec(); - State = 1345; + State = 1393; + ((RequiredModifierContext)_localctx).modifierType = typeSpec(); + State = 1394; Match(T__30); + _localctx.Value = Actions.CreateCustomTypeModifier(((RequiredModifierContext)_localctx).modifierType.Value, true); } break; case 8: _localctx = new OptionalModifierContext(_localctx); EnterOuterAlt(_localctx, 8); { - State = 1347; + State = 1397; Match(T__93); - State = 1348; + State = 1398; Match(T__29); - State = 1349; - typeSpec(); - State = 1350; + State = 1399; + ((OptionalModifierContext)_localctx).modifierType = typeSpec(); + State = 1400; Match(T__30); + _localctx.Value = Actions.CreateCustomTypeModifier(((OptionalModifierContext)_localctx).modifierType.Value, false); } break; case 9: _localctx = new GenericArgumentsModifierContext(_localctx); EnterOuterAlt(_localctx, 9); { - State = 1352; - typeArgs(); + State = 1403; + ((GenericArgumentsModifierContext)_localctx).arguments = typeArgs(); + _localctx.Value = Actions.CreateGenericArgumentsModifier(((GenericArgumentsModifierContext)_localctx).arguments.Value); } break; } @@ -6889,6 +6997,20 @@ public TypeModifiersContext typeModifiers() { } public partial class ElementTypeContext : ParserRuleContext { + public object Value; + public ClassNameContext classType; + public ClassNameContext valueClassType; + public ClassNameContext valueType; + public CallConvContext convention; + public TypeContext returnType; + public SigArgsContext arguments; + public Int32Context parameterIndex; + public DottedNameContext parameterName; + public NativeIntContext signedNative; + public NativeUintContext unsignedNative; + public SimpleTypeContext primitive; + public DottedNameContext alias; + public TypeContext sentinelType; [System.Diagnostics.DebuggerNonUserCode] public ClassNameContext className() { return GetRuleContext(0); } @@ -6896,13 +7018,13 @@ [System.Diagnostics.DebuggerNonUserCode] public ClassNameContext className() { [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VALUE() { return GetToken(CILParser.VALUE, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VALUETYPE() { return GetToken(CILParser.VALUETYPE, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode METHOD() { return GetToken(CILParser.METHOD, 0); } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PTR() { return GetToken(CILParser.PTR, 0); } [System.Diagnostics.DebuggerNonUserCode] public CallConvContext callConv() { return GetRuleContext(0); } [System.Diagnostics.DebuggerNonUserCode] public TypeContext type() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PTR() { return GetToken(CILParser.PTR, 0); } [System.Diagnostics.DebuggerNonUserCode] public SigArgsContext sigArgs() { return GetRuleContext(0); } @@ -6944,145 +7066,161 @@ public ElementTypeContext elementType() { ElementTypeContext _localctx = new ElementTypeContext(Context, State); EnterRule(_localctx, 142, RULE_elementType); try { - State = 1385; + State = 1466; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,62,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1355; + State = 1408; Match(T__38); - State = 1356; - className(); + State = 1409; + _localctx.classType = className(); + _localctx.Value = Actions.CreateClassElementType(_localctx.classType.Value, false); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1357; + State = 1412; Match(OBJECT); + _localctx.Value = Actions.CreateObjectElementType(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1358; + State = 1414; Match(VALUE); - State = 1359; + State = 1415; Match(T__38); - State = 1360; - className(); + State = 1416; + _localctx.valueClassType = className(); + _localctx.Value = Actions.CreateClassElementType(_localctx.valueClassType.Value, true); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1361; + State = 1419; Match(VALUETYPE); - State = 1362; - className(); + State = 1420; + _localctx.valueType = className(); + _localctx.Value = Actions.CreateClassElementType(_localctx.valueType.Value, true); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1363; + State = 1423; Match(METHOD); - State = 1364; - callConv(); - State = 1365; - type(); - State = 1366; + State = 1424; + _localctx.convention = callConv(); + State = 1425; + _localctx.returnType = type(); + State = 1426; Match(PTR); - State = 1367; - sigArgs(); + State = 1427; + _localctx.arguments = sigArgs(); + _localctx.Value = Actions.CreateFunctionPointerElementType(_localctx.convention.Value, _localctx.returnType.Value, _localctx.arguments.Value); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1369; + State = 1430; Match(METHOD_TYPE_PARAMETER); - State = 1370; - int32(); + State = 1431; + _localctx.parameterIndex = int32(); + _localctx.Value = Actions.CreateIndexedGenericParameterElementType(true, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null)); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1371; + State = 1434; Match(TYPE_PARAMETER); - State = 1372; - int32(); + State = 1435; + _localctx.parameterIndex = int32(); + _localctx.Value = Actions.CreateIndexedGenericParameterElementType(false, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null)); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1373; + State = 1438; Match(METHOD_TYPE_PARAMETER); - State = 1374; - dottedName(); + State = 1439; + _localctx.parameterName = dottedName(); + _localctx.Value = Actions.CreateNamedGenericParameterElementType(_localctx.Start, true, _localctx.parameterName.Value); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 1375; + State = 1442; Match(TYPE_PARAMETER); - State = 1376; - dottedName(); + State = 1443; + _localctx.parameterName = dottedName(); + _localctx.Value = Actions.CreateNamedGenericParameterElementType(_localctx.Start, false, _localctx.parameterName.Value); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 1377; + State = 1446; Match(TYPEDREF); + _localctx.Value = Actions.CreateTypedReferenceElementType(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 1378; + State = 1448; Match(VOID); + _localctx.Value = Actions.CreateVoidElementType(); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 1379; - nativeInt(); + State = 1450; + _localctx.signedNative = nativeInt(); + _localctx.Value = Actions.CreatePrimitiveElementType(_localctx.signedNative.Value); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 1380; - nativeUint(); + State = 1453; + _localctx.unsignedNative = nativeUint(); + _localctx.Value = Actions.CreatePrimitiveElementType(_localctx.unsignedNative.Value); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 1381; - simpleType(); + State = 1456; + _localctx.primitive = simpleType(); + _localctx.Value = Actions.CreatePrimitiveElementType(_localctx.primitive.Value); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 1382; - dottedName(); + State = 1459; + _localctx.alias = dottedName(); + _localctx.Value = Actions.CreateTypedefElementType(_localctx.Start, _localctx.alias.Value); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 1383; + State = 1462; Match(ELLIPSIS); - State = 1384; - type(); + State = 1463; + _localctx.sentinelType = type(); + _localctx.Value = Actions.CreateSentinelElementType(_localctx.sentinelType.Value); } break; } @@ -7099,6 +7237,8 @@ public ElementTypeContext elementType() { } public partial class SimpleTypeContext : ParserRuleContext { + public byte Value; + public IToken value; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CHAR() { return GetToken(CILParser.CHAR, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STRING() { return GetToken(CILParser.STRING, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BOOL() { return GetToken(CILParser.BOOL, 0); } @@ -7130,134 +7270,151 @@ public SimpleTypeContext simpleType() { SimpleTypeContext _localctx = new SimpleTypeContext(Context, State); EnterRule(_localctx, 144, RULE_simpleType); try { - State = 1408; + State = 1506; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,63,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1387; - Match(CHAR); + State = 1468; + _localctx.value = Match(CHAR); + _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1388; - Match(STRING); + State = 1470; + _localctx.value = Match(STRING); + _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1389; - Match(BOOL); + State = 1472; + _localctx.value = Match(BOOL); + _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1390; - Match(INT8); + State = 1474; + _localctx.value = Match(INT8); + _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1391; - Match(INT16); + State = 1476; + _localctx.value = Match(INT16); + _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1392; - Match(INT32_); + State = 1478; + _localctx.value = Match(INT32_); + _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1393; - Match(INT64_); + State = 1480; + _localctx.value = Match(INT64_); + _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1394; - Match(FLOAT32); + State = 1482; + _localctx.value = Match(FLOAT32); + _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 1395; - Match(FLOAT64_); + State = 1484; + _localctx.value = Match(FLOAT64_); + _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 1396; - Match(UINT8); + State = 1486; + _localctx.value = Match(UINT8); + _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 1397; - Match(UINT16); + State = 1488; + _localctx.value = Match(UINT16); + _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 1398; - Match(UINT32); + State = 1490; + _localctx.value = Match(UINT32); + _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 1399; - Match(UINT64); + State = 1492; + _localctx.value = Match(UINT64); + _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 1400; + State = 1494; Match(T__89); - State = 1401; - Match(INT8); + State = 1495; + _localctx.value = Match(INT8); + _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 1402; + State = 1497; Match(T__89); - State = 1403; - Match(INT16); + State = 1498; + _localctx.value = Match(INT16); + _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 1404; + State = 1500; Match(T__89); - State = 1405; - Match(INT32_); + State = 1501; + _localctx.value = Match(INT32_); + _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 1406; + State = 1503; Match(T__89); - State = 1407; - Match(INT64_); + State = 1504; + _localctx.value = Match(INT64_); + _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } break; } @@ -7274,6 +7431,13 @@ public SimpleTypeContext simpleType() { } public partial class BoundContext : ParserRuleContext { + public int Lower; + public int Upper; + public bool HasLower; + public bool HasUpper; + public Int32Context size; + public Int32Context lower; + public Int32Context upper; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ELLIPSIS() { return GetToken(CILParser.ELLIPSIS, 0); } [System.Diagnostics.DebuggerNonUserCode] public Int32Context[] int32() { return GetRuleContexts(); @@ -7298,8 +7462,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { public BoundContext bound() { BoundContext _localctx = new BoundContext(Context, State); EnterRule(_localctx, 146, RULE_bound); + Actions.InitializeBound(_localctx); try { - State = 1420; + State = 1522; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,64,Context) ) { case 1: @@ -7310,35 +7475,38 @@ public BoundContext bound() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1411; + State = 1509; Match(ELLIPSIS); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1412; - int32(); + State = 1510; + _localctx.size = int32(); + Actions.SetBoundSize(_localctx, (_localctx.size!=null?(_localctx.size.Start):null)); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1413; - int32(); - State = 1414; + State = 1513; + _localctx.lower = int32(); + State = 1514; Match(ELLIPSIS); - State = 1415; - int32(); + State = 1515; + _localctx.upper = int32(); + Actions.SetBoundRange(_localctx, (_localctx.lower!=null?(_localctx.lower.Start):null), (_localctx.upper!=null?(_localctx.upper.Start):null)); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1417; - int32(); - State = 1418; + State = 1518; + _localctx.lower = int32(); + State = 1519; Match(ELLIPSIS); + Actions.SetBoundLower(_localctx, (_localctx.lower!=null?(_localctx.lower.Start):null)); } break; } @@ -7355,6 +7523,7 @@ public BoundContext bound() { } public partial class NativeIntContext : ParserRuleContext { + public byte Value; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT() { return GetToken(CILParser.INT, 0); } public NativeIntContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) @@ -7376,10 +7545,11 @@ public NativeIntContext nativeInt() { try { EnterOuterAlt(_localctx, 1); { - State = 1422; + State = 1524; Match(T__0); - State = 1423; + State = 1525; Match(INT); + _localctx.Value = Actions.GetNativeIntType(); } } catch (RecognitionException re) { @@ -7394,6 +7564,7 @@ public NativeIntContext nativeInt() { } public partial class NativeUintContext : ParserRuleContext { + public byte Value; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT() { return GetToken(CILParser.INT, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT() { return GetToken(CILParser.UINT, 0); } public NativeUintContext(ParserRuleContext parent, int invokingState) @@ -7416,28 +7587,29 @@ public NativeUintContext nativeUint() { try { EnterOuterAlt(_localctx, 1); { - State = 1425; + State = 1528; Match(T__0); - State = 1429; + State = 1532; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__89: { - State = 1426; + State = 1529; Match(T__89); - State = 1427; + State = 1530; Match(INT); } break; case UINT: { - State = 1428; + State = 1531; Match(UINT); } break; default: throw new NoViableAltException(this); } + _localctx.Value = Actions.GetNativeUIntType(); } } catch (RecognitionException re) { @@ -7494,125 +7666,125 @@ public SecDeclContext secDecl() { EnterRule(_localctx, 152, RULE_secDecl); int _la; try { - State = 1478; + State = 1583; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,67,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1431; + State = 1536; Match(PERMISSION); - State = 1432; + State = 1537; secAction(); - State = 1433; + State = 1538; typeSpec(); - State = 1434; + State = 1539; Match(T__29); - State = 1435; + State = 1540; nameValPairs(); - State = 1436; + State = 1541; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1438; + State = 1543; Match(PERMISSION); - State = 1439; + State = 1544; secAction(); - State = 1440; + State = 1545; typeSpec(); - State = 1441; + State = 1546; Match(T__35); - State = 1442; + State = 1547; Match(T__16); - State = 1443; + State = 1548; customBlobDescr(); - State = 1444; + State = 1549; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1446; + State = 1551; Match(PERMISSION); - State = 1447; + State = 1552; secAction(); - State = 1448; + State = 1553; typeSpec(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1450; + State = 1555; Match(PERMISSIONSET); - State = 1451; + State = 1556; secAction(); - State = 1452; + State = 1557; Match(T__35); - State = 1454; + State = 1559; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__83) { { - State = 1453; + State = 1558; Match(T__83); } } - State = 1456; + State = 1561; Match(T__29); - State = 1457; + State = 1562; bytes(); - State = 1458; + State = 1563; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1460; + State = 1565; Match(PERMISSIONSET); - State = 1461; + State = 1566; secAction(); - State = 1462; + State = 1567; Match(T__83); - State = 1463; + State = 1568; Match(T__29); - State = 1464; + State = 1569; bytes(); - State = 1465; + State = 1570; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1467; + State = 1572; Match(PERMISSIONSET); - State = 1468; + State = 1573; secAction(); - State = 1469; + State = 1574; compQstring(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1471; + State = 1576; Match(PERMISSIONSET); - State = 1472; + State = 1577; secAction(); - State = 1473; + State = 1578; Match(T__35); - State = 1474; + State = 1579; Match(T__16); - State = 1475; + State = 1580; secAttrSetBlob(); - State = 1476; + State = 1581; Match(T__17); } break; @@ -7655,7 +7827,7 @@ public SecAttrSetBlobContext secAttrSetBlob() { EnterRule(_localctx, 154, RULE_secAttrSetBlob); try { int _alt; - State = 1490; + State = 1595; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__17: @@ -7700,25 +7872,25 @@ public SecAttrSetBlobContext secAttrSetBlob() { case ID: EnterOuterAlt(_localctx, 2); { - State = 1486; + State = 1591; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,68,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1481; + State = 1586; secAttrBlob(); - State = 1482; + State = 1587; Match(T__27); } } } - State = 1488; + State = 1593; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,68,Context); } - State = 1489; + State = 1594; secAttrBlob(); } break; @@ -7763,38 +7935,38 @@ public SecAttrBlobContext secAttrBlob() { SecAttrBlobContext _localctx = new SecAttrBlobContext(Context, State); EnterRule(_localctx, 156, RULE_secAttrBlob); try { - State = 1505; + State = 1610; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,70,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1492; + State = 1597; Match(T__38); - State = 1493; + State = 1598; Match(SQSTRING); - State = 1494; + State = 1599; Match(T__35); - State = 1495; + State = 1600; Match(T__16); - State = 1496; + State = 1601; customBlobNVPairs(); - State = 1497; + State = 1602; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1499; + State = 1604; typeSpec(); - State = 1500; + State = 1605; Match(T__35); - State = 1501; + State = 1606; Match(T__16); - State = 1502; + State = 1607; customBlobNVPairs(); - State = 1503; + State = 1608; Match(T__17); } break; @@ -7839,25 +8011,25 @@ public NameValPairsContext nameValPairs() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1512; + State = 1617; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,71,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1507; + State = 1612; nameValPair(); - State = 1508; + State = 1613; Match(T__27); } } } - State = 1514; + State = 1619; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,71,Context); } - State = 1515; + State = 1620; nameValPair(); } } @@ -7899,11 +8071,11 @@ public NameValPairContext nameValPair() { try { EnterOuterAlt(_localctx, 1); { - State = 1517; + State = 1622; compQstring(); - State = 1518; + State = 1623; Match(T__35); - State = 1519; + State = 1624; caValue(); } } @@ -7940,7 +8112,7 @@ public TruefalseContext truefalse() { try { EnterOuterAlt(_localctx, 1); { - State = 1521; + State = 1626; _la = TokenStream.LA(1); if ( !(_la==T__94 || _la==T__95) ) { ErrorHandler.RecoverInline(this); @@ -7996,104 +8168,104 @@ public CaValueContext caValue() { CaValueContext _localctx = new CaValueContext(Context, State); EnterRule(_localctx, 164, RULE_caValue); try { - State = 1557; + State = 1662; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,72,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1523; + State = 1628; truefalse(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1524; + State = 1629; int32(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1525; + State = 1630; Match(INT32_); - State = 1526; + State = 1631; Match(T__29); - State = 1527; + State = 1632; int32(); - State = 1528; + State = 1633; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1530; + State = 1635; compQstring(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1531; + State = 1636; className(); - State = 1532; + State = 1637; Match(T__29); - State = 1533; + State = 1638; Match(INT8); - State = 1534; + State = 1639; Match(T__74); - State = 1535; + State = 1640; int32(); - State = 1536; + State = 1641; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1538; + State = 1643; className(); - State = 1539; + State = 1644; Match(T__29); - State = 1540; + State = 1645; Match(INT16); - State = 1541; + State = 1646; Match(T__74); - State = 1542; + State = 1647; int32(); - State = 1543; + State = 1648; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1545; + State = 1650; className(); - State = 1546; + State = 1651; Match(T__29); - State = 1547; + State = 1652; Match(INT32_); - State = 1548; + State = 1653; Match(T__74); - State = 1549; + State = 1654; int32(); - State = 1550; + State = 1655; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1552; + State = 1657; className(); - State = 1553; + State = 1658; Match(T__29); - State = 1554; + State = 1659; int32(); - State = 1555; + State = 1660; Match(T__30); } break; @@ -8132,7 +8304,7 @@ public SecActionContext secAction() { try { EnterOuterAlt(_localctx, 1); { - State = 1559; + State = 1664; _la = TokenStream.LA(1); if ( !(((((_la - 97)) & ~0x3f) == 0 && ((1L << (_la - 97)) & 32767L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -8155,6 +8327,18 @@ public SecActionContext secAction() { } public partial class MethodRefContext : ParserRuleContext { + public object Value; + public bool HasSyntaxError; + public CallConvContext convention; + public TypeContext returnType; + public TypeSpecContext owner; + public MethodNameContext name; + public TypeArgsContext genericArguments; + public SigArgsContext arguments; + public GenArityNotEmptyContext genericArity; + public MdtokenContext token; + public DottedNameContext alias; + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DCOLON() { return GetToken(CILParser.DCOLON, 0); } [System.Diagnostics.DebuggerNonUserCode] public CallConvContext callConv() { return GetRuleContext(0); } @@ -8164,7 +8348,6 @@ [System.Diagnostics.DebuggerNonUserCode] public TypeContext type() { [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DCOLON() { return GetToken(CILParser.DCOLON, 0); } [System.Diagnostics.DebuggerNonUserCode] public MethodNameContext methodName() { return GetRuleContext(0); } @@ -8200,108 +8383,114 @@ public override TResult Accept(IParseTreeVisitor visitor) { public MethodRefContext methodRef() { MethodRefContext _localctx = new MethodRefContext(Context, State); EnterRule(_localctx, 168, RULE_methodRef); - BeginSubtree(); + Actions.BeginSemanticRoot(_localctx); int _la; try { - State = 1595; + State = 1708; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,75,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1561; - callConv(); - State = 1562; - type(); - State = 1563; - typeSpec(); - State = 1564; + State = 1666; + _localctx.convention = callConv(); + State = 1667; + _localctx.returnType = type(); + State = 1668; + _localctx.owner = typeSpec(); + State = 1669; Match(DCOLON); - State = 1565; - methodName(); - State = 1567; + State = 1670; + _localctx.name = methodName(); + State = 1672; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 1566; - typeArgs(); + State = 1671; + _localctx.genericArguments = typeArgs(); } } - State = 1569; - sigArgs(); + State = 1674; + _localctx.arguments = sigArgs(); + _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, _localctx.owner.Value, _localctx.name.Value, _localctx.genericArguments, null, _localctx.arguments.Value); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1571; - callConv(); - State = 1572; - type(); - State = 1573; - typeSpec(); - State = 1574; + State = 1677; + _localctx.convention = callConv(); + State = 1678; + _localctx.returnType = type(); + State = 1679; + _localctx.owner = typeSpec(); + State = 1680; Match(DCOLON); - State = 1575; - methodName(); - State = 1576; - genArityNotEmpty(); - State = 1577; - sigArgs(); + State = 1681; + _localctx.name = methodName(); + State = 1682; + _localctx.genericArity = genArityNotEmpty(); + State = 1683; + _localctx.arguments = sigArgs(); + _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, _localctx.owner.Value, _localctx.name.Value, null, _localctx.genericArity.Value, _localctx.arguments.Value); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1579; - callConv(); - State = 1580; - type(); - State = 1581; - methodName(); - State = 1583; + State = 1686; + _localctx.convention = callConv(); + State = 1687; + _localctx.returnType = type(); + State = 1688; + _localctx.name = methodName(); + State = 1690; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 1582; - typeArgs(); + State = 1689; + _localctx.genericArguments = typeArgs(); } } - State = 1585; - sigArgs(); + State = 1692; + _localctx.arguments = sigArgs(); + _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, null, _localctx.name.Value, _localctx.genericArguments, null, _localctx.arguments.Value); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1587; - callConv(); - State = 1588; - type(); - State = 1589; - methodName(); - State = 1590; - genArityNotEmpty(); - State = 1591; - sigArgs(); + State = 1695; + _localctx.convention = callConv(); + State = 1696; + _localctx.returnType = type(); + State = 1697; + _localctx.name = methodName(); + State = 1698; + _localctx.genericArity = genArityNotEmpty(); + State = 1699; + _localctx.arguments = sigArgs(); + _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, null, _localctx.name.Value, null, _localctx.genericArity.Value, _localctx.arguments.Value); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1593; - mdtoken(); + State = 1702; + _localctx.token = mdtoken(); + _localctx.Value = Actions.CreateTokenMethodReference(_localctx.token.Value); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1594; - dottedName(); + State = 1705; + _localctx.alias = dottedName(); + _localctx.Value = Actions.CreateTypedefMethodReference(_localctx.Start, _localctx.alias.Value); } break; } @@ -8312,13 +8501,17 @@ public MethodRefContext methodRef() { ErrorHandler.Recover(this, re); } finally { - EndParseTreeMode(); + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); ExitRule(); } return _localctx; } public partial class CallConvContext : ParserRuleContext { + public byte Value; + public CallConvContext inner; + public CallKindContext kind; + public Int32Context raw; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTANCE() { return GetToken(CILParser.INSTANCE, 0); } [System.Diagnostics.DebuggerNonUserCode] public CallConvContext callConv() { return GetRuleContext(0); @@ -8348,45 +8541,49 @@ public CallConvContext callConv() { CallConvContext _localctx = new CallConvContext(Context, State); EnterRule(_localctx, 170, RULE_callConv); try { - State = 1607; + State = 1727; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,76,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1597; + State = 1710; Match(INSTANCE); - State = 1598; - callConv(); + State = 1711; + _localctx.inner = callConv(); + _localctx.Value = Actions.AddInstanceCallingConvention(_localctx.inner.Value); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1599; + State = 1714; Match(EXPLICIT); - State = 1600; - callConv(); + State = 1715; + _localctx.inner = callConv(); + _localctx.Value = Actions.AddExplicitCallingConvention(_localctx.inner.Value); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1601; - callKind(); + State = 1718; + _localctx.kind = callKind(); + _localctx.Value = _localctx.kind.Value; } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1602; + State = 1721; Match(T__111); - State = 1603; + State = 1722; Match(T__29); - State = 1604; - int32(); - State = 1605; + State = 1723; + _localctx.raw = int32(); + State = 1724; Match(T__30); + _localctx.Value = Actions.GetRawCallingConvention((_localctx.raw!=null?(_localctx.raw.Start):null)); } break; } @@ -8403,6 +8600,8 @@ public CallConvContext callConv() { } public partial class CallKindContext : ParserRuleContext { + public byte Value; + public IToken kind; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DEFAULT() { return GetToken(CILParser.DEFAULT, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VARARG() { return GetToken(CILParser.VARARG, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UNMANAGED() { return GetToken(CILParser.UNMANAGED, 0); } @@ -8427,8 +8626,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { public CallKindContext callKind() { CallKindContext _localctx = new CallKindContext(Context, State); EnterRule(_localctx, 172, RULE_callKind); + _localctx.Value = Actions.GetDefaultCallingConvention(); try { - State = 1621; + State = 1748; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,77,Context) ) { case 1: @@ -8439,58 +8639,65 @@ public CallKindContext callKind() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1610; - Match(DEFAULT); + State = 1730; + _localctx.kind = Match(DEFAULT); + _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1611; - Match(VARARG); + State = 1732; + _localctx.kind = Match(VARARG); + _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1612; + State = 1734; Match(UNMANAGED); - State = 1613; - Match(CDECL); + State = 1735; + _localctx.kind = Match(CDECL); + _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1614; + State = 1737; Match(UNMANAGED); - State = 1615; - Match(STDCALL); + State = 1738; + _localctx.kind = Match(STDCALL); + _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1616; + State = 1740; Match(UNMANAGED); - State = 1617; - Match(THISCALL); + State = 1741; + _localctx.kind = Match(THISCALL); + _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1618; + State = 1743; Match(UNMANAGED); - State = 1619; - Match(FASTCALL); + State = 1744; + _localctx.kind = Match(FASTCALL); + _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1620; - Match(UNMANAGED); + State = 1746; + _localctx.kind = Match(UNMANAGED); + _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } break; } @@ -8507,6 +8714,9 @@ public CallKindContext callKind() { } public partial class MdtokenContext : ParserRuleContext { + public int Value; + public bool HasSyntaxError; + public Int32Context token; [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); } @@ -8527,18 +8737,19 @@ public override TResult Accept(IParseTreeVisitor visitor) { public MdtokenContext mdtoken() { MdtokenContext _localctx = new MdtokenContext(Context, State); EnterRule(_localctx, 174, RULE_mdtoken); - BeginSubtree(); + Actions.BeginSemanticRoot(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 1623; + State = 1750; Match(T__112); - State = 1624; + State = 1751; Match(T__29); - State = 1625; - int32(); - State = 1626; + State = 1752; + _localctx.token = int32(); + State = 1753; Match(T__30); + _localctx.Value = Actions.ParseInt32((_localctx.token!=null?(_localctx.token.Start):null)); } } catch (RecognitionException re) { @@ -8547,13 +8758,17 @@ public MdtokenContext mdtoken() { ErrorHandler.Recover(this, re); } finally { - EndParseTreeMode(); + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); ExitRule(); } return _localctx; } public partial class MemberRefContext : ParserRuleContext { + public object Value; + public MethodRefContext method; + public FieldRefContext field; + public MdtokenContext token; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode METHOD() { return GetToken(CILParser.METHOD, 0); } [System.Diagnostics.DebuggerNonUserCode] public MethodRefContext methodRef() { return GetRuleContext(0); @@ -8582,32 +8797,35 @@ public MemberRefContext memberRef() { MemberRefContext _localctx = new MemberRefContext(Context, State); EnterRule(_localctx, 176, RULE_memberRef); try { - State = 1633; + State = 1767; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case METHOD: EnterOuterAlt(_localctx, 1); { - State = 1628; + State = 1756; Match(METHOD); - State = 1629; - methodRef(); + State = 1757; + _localctx.method = methodRef(); + _localctx.Value = Actions.CreateMethodMemberReference(_localctx.method.Value); } break; case T__36: EnterOuterAlt(_localctx, 2); { - State = 1630; + State = 1760; Match(T__36); - State = 1631; - fieldRef(); + State = 1761; + _localctx.field = fieldRef(); + _localctx.Value = Actions.CreateFieldMemberReference(_localctx.field.Value); } break; case T__112: EnterOuterAlt(_localctx, 3); { - State = 1632; - mdtoken(); + State = 1764; + _localctx.token = mdtoken(); + _localctx.Value = Actions.CreateTokenMemberReference(_localctx.token.Value); } break; default: @@ -8626,13 +8844,19 @@ public MemberRefContext memberRef() { } public partial class FieldRefContext : ParserRuleContext { + public object Value; + public bool HasSyntaxError; + public TypeContext fieldType; + public TypeSpecContext owner; + public DottedNameContext name; + public DottedNameContext alias; + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DCOLON() { return GetToken(CILParser.DCOLON, 0); } [System.Diagnostics.DebuggerNonUserCode] public TypeContext type() { return GetRuleContext(0); } [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DCOLON() { return GetToken(CILParser.DCOLON, 0); } [System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() { return GetRuleContext(0); } @@ -8653,38 +8877,41 @@ public override TResult Accept(IParseTreeVisitor visitor) { public FieldRefContext fieldRef() { FieldRefContext _localctx = new FieldRefContext(Context, State); EnterRule(_localctx, 178, RULE_fieldRef); - BeginSubtree(); + Actions.BeginSemanticRoot(_localctx); try { - State = 1644; + State = 1782; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,79,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1635; - type(); - State = 1636; - typeSpec(); - State = 1637; + State = 1769; + _localctx.fieldType = type(); + State = 1770; + _localctx.owner = typeSpec(); + State = 1771; Match(DCOLON); - State = 1638; - dottedName(); + State = 1772; + _localctx.name = dottedName(); + _localctx.Value = Actions.CreateFieldReference(_localctx.fieldType.Value, _localctx.owner.Value, _localctx.name.Value); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1640; - type(); - State = 1641; - dottedName(); + State = 1775; + _localctx.fieldType = type(); + State = 1776; + _localctx.name = dottedName(); + _localctx.Value = Actions.CreateFieldReference(_localctx.fieldType.Value, null, _localctx.name.Value); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1643; - dottedName(); + State = 1779; + _localctx.alias = dottedName(); + _localctx.Value = Actions.CreateTypedefFieldReference(_localctx.Start, _localctx.alias.Value); } break; } @@ -8695,7 +8922,7 @@ public FieldRefContext fieldRef() { ErrorHandler.Recover(this, re); } finally { - EndParseTreeMode(); + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); ExitRule(); } return _localctx; @@ -8729,25 +8956,25 @@ public TypeListContext typeList() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1651; + State = 1789; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,80,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1646; + State = 1784; typeSpec(); - State = 1647; + State = 1785; Match(T__27); } } } - State = 1653; + State = 1791; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,80,Context); } - State = 1654; + State = 1792; typeSpec(); } } @@ -8784,7 +9011,7 @@ public TyparsClauseContext typarsClause() { TyparsClauseContext _localctx = new TyparsClauseContext(Context, State); EnterRule(_localctx, 182, RULE_typarsClause); try { - State = 1661; + State = 1799; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -8799,11 +9026,11 @@ public TyparsClauseContext typarsClause() { case T__85: EnterOuterAlt(_localctx, 2); { - State = 1657; + State = 1795; Match(T__85); - State = 1658; + State = 1796; typars(); - State = 1659; + State = 1797; Match(T__86); } break; @@ -8853,61 +9080,61 @@ public TyparAttribContext typarAttrib() { TyparAttribContext _localctx = new TyparAttribContext(Context, State); EnterRule(_localctx, 184, RULE_typarAttrib); try { - State = 1674; + State = 1812; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case PLUS: EnterOuterAlt(_localctx, 1); { - State = 1663; + State = 1801; _localctx.covariant = Match(PLUS); } break; case T__113: EnterOuterAlt(_localctx, 2); { - State = 1664; + State = 1802; _localctx.contravariant = Match(T__113); } break; case T__38: EnterOuterAlt(_localctx, 3); { - State = 1665; + State = 1803; _localctx.@class = Match(T__38); } break; case VALUETYPE: EnterOuterAlt(_localctx, 4); { - State = 1666; + State = 1804; _localctx.valuetype = Match(VALUETYPE); } break; case T__114: EnterOuterAlt(_localctx, 5); { - State = 1667; + State = 1805; _localctx.byrefLike = Match(T__114); } break; case T__115: EnterOuterAlt(_localctx, 6); { - State = 1668; + State = 1806; _localctx.ctor = Match(T__115); } break; case T__69: EnterOuterAlt(_localctx, 7); { - State = 1669; + State = 1807; Match(T__69); - State = 1670; + State = 1808; Match(T__29); - State = 1671; + State = 1809; _localctx.flags = int32(); - State = 1672; + State = 1810; Match(T__30); } break; @@ -8954,17 +9181,17 @@ public TyparAttribsContext typarAttribs() { try { EnterOuterAlt(_localctx, 1); { - State = 1679; + State = 1817; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__38 || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & 123145302310913L) != 0) || _la==VALUETYPE || _la==PLUS) { { { - State = 1676; + State = 1814; typarAttrib(); } } - State = 1681; + State = 1819; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -9012,19 +9239,19 @@ public TyparContext typar() { try { EnterOuterAlt(_localctx, 1); { - State = 1682; + State = 1820; typarAttribs(); - State = 1684; + State = 1822; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__29) { { - State = 1683; + State = 1821; tyBound(); } } - State = 1686; + State = 1824; dottedName(); } } @@ -9067,25 +9294,25 @@ public TyparsContext typars() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1693; + State = 1831; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,85,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1688; + State = 1826; typar(); - State = 1689; + State = 1827; Match(T__27); } } } - State = 1695; + State = 1833; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,85,Context); } - State = 1696; + State = 1834; typar(); } } @@ -9124,11 +9351,11 @@ public TyBoundContext tyBound() { try { EnterOuterAlt(_localctx, 1); { - State = 1698; + State = 1836; Match(T__29); - State = 1699; + State = 1837; typeList(); - State = 1700; + State = 1838; Match(T__30); } } @@ -9144,6 +9371,8 @@ public TyBoundContext tyBound() { } public partial class GenArityContext : ParserRuleContext { + public int Value; + public GenArityNotEmptyContext value; [System.Diagnostics.DebuggerNonUserCode] public GenArityNotEmptyContext genArityNotEmpty() { return GetRuleContext(0); } @@ -9164,25 +9393,21 @@ public override TResult Accept(IParseTreeVisitor visitor) { public GenArityContext genArity() { GenArityContext _localctx = new GenArityContext(Context, State); EnterRule(_localctx, 194, RULE_genArity); + int _la; try { - State = 1704; + EnterOuterAlt(_localctx, 1); + { + State = 1841; ErrorHandler.Sync(this); - switch (TokenStream.LA(1)) { - case T__29: - case T__84: - EnterOuterAlt(_localctx, 1); - { - } - break; - case T__85: - EnterOuterAlt(_localctx, 2); + _la = TokenStream.LA(1); + if (_la==T__85) { { - State = 1703; - genArityNotEmpty(); + State = 1840; + _localctx.value = genArityNotEmpty(); } - break; - default: - throw new NoViableAltException(this); + } + + _localctx.Value = Actions.GetGenericArity(_localctx.value); } } catch (RecognitionException re) { @@ -9197,6 +9422,8 @@ public GenArityContext genArity() { } public partial class GenArityNotEmptyContext : ParserRuleContext { + public int Value; + public Int32Context value; [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); } @@ -9220,16 +9447,17 @@ public GenArityNotEmptyContext genArityNotEmpty() { try { EnterOuterAlt(_localctx, 1); { - State = 1706; + State = 1845; Match(T__85); - State = 1707; + State = 1846; Match(T__41); - State = 1708; - int32(); - State = 1709; + State = 1847; + _localctx.value = int32(); + State = 1848; Match(T__42); - State = 1710; + State = 1849; Match(T__86); + _localctx.Value = Actions.ParseInt32((_localctx.value!=null?(_localctx.value.Start):null)); } } catch (RecognitionException re) { @@ -9375,235 +9603,235 @@ public ClassDeclContext classDecl() { BeginSubtree(); try { int _alt; - State = 1828; + State = 1968; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,91,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1712; + State = 1852; methodHead(); - State = 1713; + State = 1853; Match(T__16); - State = 1714; + State = 1854; methodDecls(); - State = 1715; + State = 1855; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1717; + State = 1857; classHead(); - State = 1718; + State = 1858; Match(T__16); - State = 1719; + State = 1859; classDecls(); - State = 1720; + State = 1860; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1722; + State = 1862; eventHead(); - State = 1723; + State = 1863; Match(T__16); - State = 1724; + State = 1864; eventDecls(); - State = 1725; + State = 1865; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1727; + State = 1867; propHead(); - State = 1728; + State = 1868; Match(T__16); - State = 1729; + State = 1869; propDecls(); - State = 1730; + State = 1870; Match(T__17); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1732; + State = 1872; fieldDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1733; + State = 1873; dataDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1734; + State = 1874; secDecl(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1735; + State = 1875; extSourceSpec(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 1736; + State = 1876; customAttrDecl(); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 1737; + State = 1877; Match(T__116); - State = 1738; + State = 1878; int32(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 1739; + State = 1879; Match(T__117); - State = 1740; + State = 1880; int32(); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 1741; + State = 1881; exportHead(); - State = 1742; + State = 1882; Match(T__16); - State = 1743; + State = 1883; exptypeDecls(); - State = 1744; + State = 1884; Match(T__17); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 1746; + State = 1886; Match(OVERRIDE); - State = 1747; + State = 1887; typeSpec(); - State = 1748; + State = 1888; Match(DCOLON); - State = 1749; + State = 1889; methodName(); - State = 1750; + State = 1890; Match(T__118); - State = 1751; + State = 1891; callConv(); - State = 1752; + State = 1892; type(); - State = 1753; + State = 1893; typeSpec(); - State = 1754; + State = 1894; Match(DCOLON); - State = 1755; + State = 1895; methodName(); - State = 1756; + State = 1896; sigArgs(); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 1758; + State = 1898; Match(OVERRIDE); - State = 1759; + State = 1899; Match(METHOD); - State = 1760; + State = 1900; callConv(); - State = 1761; + State = 1901; type(); - State = 1762; + State = 1902; typeSpec(); - State = 1763; + State = 1903; Match(DCOLON); - State = 1764; + State = 1904; methodName(); - State = 1765; + State = 1905; genArity(); - State = 1766; + State = 1906; sigArgs(); - State = 1767; + State = 1907; Match(T__118); - State = 1768; + State = 1908; Match(METHOD); - State = 1769; + State = 1909; callConv(); - State = 1770; + State = 1910; type(); - State = 1771; + State = 1911; typeSpec(); - State = 1772; + State = 1912; Match(DCOLON); - State = 1773; + State = 1913; methodName(); - State = 1774; + State = 1914; genArity(); - State = 1775; + State = 1915; sigArgs(); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 1777; + State = 1917; languageDecl(); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 1778; + State = 1918; compControl(); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 1779; + State = 1919; Match(PARAM); - State = 1780; + State = 1920; Match(TYPE); - State = 1781; + State = 1921; Match(T__41); - State = 1782; + State = 1922; int32(); - State = 1783; + State = 1923; Match(T__42); - State = 1787; + State = 1927; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,87,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1784; + State = 1924; customAttrDecl(); } } } - State = 1789; + State = 1929; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,87,Context); } @@ -9612,25 +9840,25 @@ public ClassDeclContext classDecl() { case 18: EnterOuterAlt(_localctx, 18); { - State = 1790; + State = 1930; Match(PARAM); - State = 1791; + State = 1931; Match(TYPE); - State = 1792; + State = 1932; dottedName(); - State = 1796; + State = 1936; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1793; + State = 1933; customAttrDecl(); } } } - State = 1798; + State = 1938; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); } @@ -9639,33 +9867,33 @@ public ClassDeclContext classDecl() { case 19: EnterOuterAlt(_localctx, 19); { - State = 1799; + State = 1939; Match(PARAM); - State = 1800; + State = 1940; Match(CONSTRAINT); - State = 1801; + State = 1941; Match(T__41); - State = 1802; + State = 1942; int32(); - State = 1803; + State = 1943; Match(T__42); - State = 1804; + State = 1944; Match(T__27); - State = 1805; + State = 1945; typeSpec(); - State = 1809; + State = 1949; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1806; + State = 1946; customAttrDecl(); } } } - State = 1811; + State = 1951; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); } @@ -9674,29 +9902,29 @@ public ClassDeclContext classDecl() { case 20: EnterOuterAlt(_localctx, 20); { - State = 1812; + State = 1952; Match(PARAM); - State = 1813; + State = 1953; Match(CONSTRAINT); - State = 1814; + State = 1954; dottedName(); - State = 1815; + State = 1955; Match(T__27); - State = 1816; + State = 1956; typeSpec(); - State = 1820; + State = 1960; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1817; + State = 1957; customAttrDecl(); } } } - State = 1822; + State = 1962; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); } @@ -9705,13 +9933,13 @@ public ClassDeclContext classDecl() { case 21: EnterOuterAlt(_localctx, 21); { - State = 1823; + State = 1963; Match(T__119); - State = 1824; + State = 1964; Match(TYPE); - State = 1825; + State = 1965; typeSpec(); - State = 1826; + State = 1966; customDescr(); } break; @@ -9780,17 +10008,17 @@ public FieldDeclContext fieldDecl() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1830; + State = 1970; Match(T__120); - State = 1831; + State = 1971; repeatOpt(); - State = 1840; + State = 1980; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,93,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { - State = 1838; + State = 1978; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -9809,19 +10037,19 @@ public FieldDeclContext fieldDecl() { case T__125: case T__126: { - State = 1832; + State = 1972; fieldAttr(); } break; case T__121: { - State = 1833; + State = 1973; Match(T__121); - State = 1834; + State = 1974; Match(T__29); - State = 1835; + State = 1975; marshalBlob(); - State = 1836; + State = 1976; Match(T__30); } break; @@ -9830,17 +10058,17 @@ public FieldDeclContext fieldDecl() { } } } - State = 1842; + State = 1982; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,93,Context); } - State = 1843; + State = 1983; type(); - State = 1844; + State = 1984; dottedName(); - State = 1845; + State = 1985; atOpt(); - State = 1846; + State = 1986; initOpt(); } } @@ -9877,117 +10105,117 @@ public FieldAttrContext fieldAttr() { FieldAttrContext _localctx = new FieldAttrContext(Context, State); EnterRule(_localctx, 202, RULE_fieldAttr); try { - State = 1867; + State = 2007; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__122: EnterOuterAlt(_localctx, 1); { - State = 1848; + State = 1988; Match(T__122); } break; case T__50: EnterOuterAlt(_localctx, 2); { - State = 1849; + State = 1989; Match(T__50); } break; case T__51: EnterOuterAlt(_localctx, 3); { - State = 1850; + State = 1990; Match(T__51); } break; case T__62: EnterOuterAlt(_localctx, 4); { - State = 1851; + State = 1991; Match(T__62); } break; case T__123: EnterOuterAlt(_localctx, 5); { - State = 1852; + State = 1992; Match(T__123); } break; case T__68: EnterOuterAlt(_localctx, 6); { - State = 1853; + State = 1993; Match(T__68); } break; case T__67: EnterOuterAlt(_localctx, 7); { - State = 1854; + State = 1994; Match(T__67); } break; case T__63: EnterOuterAlt(_localctx, 8); { - State = 1855; + State = 1995; Match(T__63); } break; case T__64: EnterOuterAlt(_localctx, 9); { - State = 1856; + State = 1996; Match(T__64); } break; case T__65: EnterOuterAlt(_localctx, 10); { - State = 1857; + State = 1997; Match(T__65); } break; case T__124: EnterOuterAlt(_localctx, 11); { - State = 1858; + State = 1998; Match(T__124); } break; case T__125: EnterOuterAlt(_localctx, 12); { - State = 1859; + State = 1999; Match(T__125); } break; case T__126: EnterOuterAlt(_localctx, 13); { - State = 1860; + State = 2000; Match(T__126); } break; case T__15: EnterOuterAlt(_localctx, 14); { - State = 1861; + State = 2001; Match(T__15); } break; case T__69: EnterOuterAlt(_localctx, 15); { - State = 1862; + State = 2002; Match(T__69); - State = 1863; + State = 2003; Match(T__29); - State = 1864; + State = 2004; int32(); - State = 1865; + State = 2005; Match(T__30); } break; @@ -10031,7 +10259,7 @@ public AtOptContext atOpt() { AtOptContext _localctx = new AtOptContext(Context, State); EnterRule(_localctx, 204, RULE_atOpt); try { - State = 1874; + State = 2014; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,95,Context) ) { case 1: @@ -10042,18 +10270,18 @@ public AtOptContext atOpt() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1870; + State = 2010; Match(T__43); - State = 1871; + State = 2011; id(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1872; + State = 2012; Match(T__43); - State = 1873; + State = 2013; int32(); } break; @@ -10092,7 +10320,7 @@ public InitOptContext initOpt() { InitOptContext _localctx = new InitOptContext(Context, State); EnterRule(_localctx, 206, RULE_initOpt); try { - State = 1879; + State = 2019; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -10186,9 +10414,9 @@ public InitOptContext initOpt() { case T__35: EnterOuterAlt(_localctx, 2); { - State = 1877; + State = 2017; Match(T__35); - State = 1878; + State = 2018; fieldInit(); } break; @@ -10229,7 +10457,7 @@ public RepeatOptContext repeatOpt() { RepeatOptContext _localctx = new RepeatOptContext(Context, State); EnterRule(_localctx, 208, RULE_repeatOpt); try { - State = 1886; + State = 2026; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -10284,11 +10512,11 @@ public RepeatOptContext repeatOpt() { case T__41: EnterOuterAlt(_localctx, 2); { - State = 1882; + State = 2022; Match(T__41); - State = 1883; + State = 2023; int32(); - State = 1884; + State = 2024; Match(T__42); } break; @@ -10339,54 +10567,54 @@ public EventHeadContext eventHead() { EnterRule(_localctx, 210, RULE_eventHead); int _la; try { - State = 1906; + State = 2046; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,100,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1888; + State = 2028; Match(T__127); - State = 1892; + State = 2032; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 1889; + State = 2029; eventAttr(); } } - State = 1894; + State = 2034; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 1895; + State = 2035; typeSpec(); - State = 1896; + State = 2036; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1898; + State = 2038; Match(T__127); - State = 1902; + State = 2042; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 1899; + State = 2039; eventAttr(); } } - State = 1904; + State = 2044; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 1905; + State = 2045; dottedName(); } break; @@ -10425,7 +10653,7 @@ public EventAttrContext eventAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 1908; + State = 2048; _la = TokenStream.LA(1); if ( !(_la==T__67 || _la==T__68) ) { ErrorHandler.RecoverInline(this); @@ -10475,17 +10703,17 @@ public EventDeclsContext eventDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 1913; + State = 2053; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38788988928L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 1080863910568919043L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 1910; + State = 2050; eventDecl(); } } - State = 1915; + State = 2055; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -10536,42 +10764,42 @@ public EventDeclContext eventDecl() { EventDeclContext _localctx = new EventDeclContext(Context, State); EnterRule(_localctx, 216, RULE_eventDecl); try { - State = 1928; + State = 2068; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__128: EnterOuterAlt(_localctx, 1); { - State = 1916; + State = 2056; Match(T__128); - State = 1917; + State = 2057; methodRef(); } break; case T__129: EnterOuterAlt(_localctx, 2); { - State = 1918; + State = 2058; Match(T__129); - State = 1919; + State = 2059; methodRef(); } break; case T__130: EnterOuterAlt(_localctx, 3); { - State = 1920; + State = 2060; Match(T__130); - State = 1921; + State = 2061; methodRef(); } break; case T__131: EnterOuterAlt(_localctx, 4); { - State = 1922; + State = 2062; Match(T__131); - State = 1923; + State = 2063; methodRef(); } break; @@ -10579,7 +10807,7 @@ public EventDeclContext eventDecl() { case T__73: EnterOuterAlt(_localctx, 5); { - State = 1924; + State = 2064; extSourceSpec(); } break; @@ -10592,14 +10820,14 @@ public EventDeclContext eventDecl() { case ID: EnterOuterAlt(_localctx, 6); { - State = 1925; + State = 2065; customAttrDecl(); } break; case T__26: EnterOuterAlt(_localctx, 7); { - State = 1926; + State = 2066; languageDecl(); } break; @@ -10613,7 +10841,7 @@ public EventDeclContext eventDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 8); { - State = 1927; + State = 2067; compControl(); } break; @@ -10675,31 +10903,31 @@ public PropHeadContext propHead() { try { EnterOuterAlt(_localctx, 1); { - State = 1930; + State = 2070; Match(T__132); - State = 1934; + State = 2074; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 1931; + State = 2071; propAttr(); } } - State = 1936; + State = 2076; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 1937; + State = 2077; callConv(); - State = 1938; + State = 2078; type(); - State = 1939; + State = 2079; dottedName(); - State = 1940; + State = 2080; sigArgs(); - State = 1941; + State = 2081; initOpt(); } } @@ -10736,7 +10964,7 @@ public PropAttrContext propAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 1943; + State = 2083; _la = TokenStream.LA(1); if ( !(_la==T__67 || _la==T__68) ) { ErrorHandler.RecoverInline(this); @@ -10786,17 +11014,17 @@ public PropDeclsContext propDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 1948; + State = 2088; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38788988928L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 7493989779944505347L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 1945; + State = 2085; propDecl(); } } - State = 1950; + State = 2090; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -10847,33 +11075,33 @@ public PropDeclContext propDecl() { PropDeclContext _localctx = new PropDeclContext(Context, State); EnterRule(_localctx, 224, RULE_propDecl); try { - State = 1961; + State = 2101; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__133: EnterOuterAlt(_localctx, 1); { - State = 1951; + State = 2091; Match(T__133); - State = 1952; + State = 2092; methodRef(); } break; case T__134: EnterOuterAlt(_localctx, 2); { - State = 1953; + State = 2093; Match(T__134); - State = 1954; + State = 2094; methodRef(); } break; case T__131: EnterOuterAlt(_localctx, 3); { - State = 1955; + State = 2095; Match(T__131); - State = 1956; + State = 2096; methodRef(); } break; @@ -10886,7 +11114,7 @@ public PropDeclContext propDecl() { case ID: EnterOuterAlt(_localctx, 4); { - State = 1957; + State = 2097; customAttrDecl(); } break; @@ -10894,14 +11122,14 @@ public PropDeclContext propDecl() { case T__73: EnterOuterAlt(_localctx, 5); { - State = 1958; + State = 2098; extSourceSpec(); } break; case T__26: EnterOuterAlt(_localctx, 6); { - State = 1959; + State = 2099; languageDecl(); } break; @@ -10915,7 +11143,7 @@ public PropDeclContext propDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 7); { - State = 1960; + State = 2100; compControl(); } break; @@ -10955,8 +11183,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { public MarshalClauseContext marshalClause() { MarshalClauseContext _localctx = new MarshalClauseContext(Context, State); EnterRule(_localctx, 226, RULE_marshalClause); + BeginSubtree(); try { - State = 1969; + State = 2109; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -10992,13 +11221,13 @@ public MarshalClauseContext marshalClause() { case T__121: EnterOuterAlt(_localctx, 2); { - State = 1964; + State = 2104; Match(T__121); - State = 1965; + State = 2105; Match(T__29); - State = 1966; + State = 2106; marshalBlob(); - State = 1967; + State = 2107; Match(T__30); } break; @@ -11012,6 +11241,7 @@ public MarshalClauseContext marshalClause() { ErrorHandler.Recover(this, re); } finally { + EndParseTreeMode(); ExitRule(); } return _localctx; @@ -11046,7 +11276,7 @@ public MarshalBlobContext marshalBlob() { EnterRule(_localctx, 228, RULE_marshalBlob); int _la; try { - State = 1980; + State = 2120; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -11101,30 +11331,30 @@ public MarshalBlobContext marshalBlob() { case ID: EnterOuterAlt(_localctx, 1); { - State = 1971; + State = 2111; nativeType(); } break; case T__16: EnterOuterAlt(_localctx, 2); { - State = 1972; + State = 2112; Match(T__16); - State = 1974; + State = 2114; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 1973; + State = 2113; hexbyte(); } } - State = 1976; + State = 2116; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( _la==INT32 || _la==ID || _la==HEXBYTE ); - State = 1978; + State = 2118; Match(T__17); } break; @@ -11144,6 +11374,8 @@ public MarshalBlobContext marshalBlob() { } public partial class ParamAttrContext : ParserRuleContext { + public int Value; + public ParamAttrElementContext element; [System.Diagnostics.DebuggerNonUserCode] public ParamAttrElementContext[] paramAttrElement() { return GetRuleContexts(); } @@ -11167,21 +11399,23 @@ public override TResult Accept(IParseTreeVisitor visitor) { public ParamAttrContext paramAttr() { ParamAttrContext _localctx = new ParamAttrContext(Context, State); EnterRule(_localctx, 230, RULE_paramAttr); + Actions.BeginParameterAttributes(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 1985; + State = 2127; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__41) { { { - State = 1982; - paramAttrElement(); + State = 2122; + _localctx.element = paramAttrElement(); + Actions.AddParameterAttribute(_localctx, _localctx.element); } } - State = 1987; + State = 2129; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11193,15 +11427,17 @@ public ParamAttrContext paramAttr() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndParameterAttributes(_localctx); ExitRule(); } return _localctx; } public partial class ParamAttrElementContext : ParserRuleContext { - public IToken @in; - public IToken @out; - public IToken opt; + public int Value; + public bool ShouldAppend; + public IToken attribute; + public Int32Context raw; [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); } @@ -11223,51 +11459,55 @@ public ParamAttrElementContext paramAttrElement() { ParamAttrElementContext _localctx = new ParamAttrElementContext(Context, State); EnterRule(_localctx, 232, RULE_paramAttrElement); try { - State = 2001; + State = 2147; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,110,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1988; + State = 2130; Match(T__41); - State = 1989; - _localctx.@in = Match(T__135); - State = 1990; + State = 2131; + _localctx.attribute = Match(T__135); + State = 2132; Match(T__42); + Actions.SetParameterAttributeElement(_localctx, _localctx.attribute); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1991; + State = 2134; Match(T__41); - State = 1992; - _localctx.@out = Match(T__136); - State = 1993; + State = 2135; + _localctx.attribute = Match(T__136); + State = 2136; Match(T__42); + Actions.SetParameterAttributeElement(_localctx, _localctx.attribute); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1994; + State = 2138; Match(T__41); - State = 1995; - _localctx.opt = Match(T__137); - State = 1996; + State = 2139; + _localctx.attribute = Match(T__137); + State = 2140; Match(T__42); + Actions.SetParameterAttributeElement(_localctx, _localctx.attribute); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1997; + State = 2142; Match(T__41); - State = 1998; - int32(); - State = 1999; + State = 2143; + _localctx.raw = int32(); + State = 2144; Match(T__42); + Actions.SetRawParameterAttributeElement(_localctx, (_localctx.raw!=null?(_localctx.raw.Start):null)); } break; } @@ -11345,14 +11585,14 @@ public MethodHeadContext methodHead() { try { EnterOuterAlt(_localctx, 1); { - State = 2003; + State = 2149; Match(T__138); - State = 2008; + State = 2154; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & 978955L) != 0) || ((((_la - 123)) & ~0x3f) == 0 && ((1L << (_la - 123)) & 33423365L) != 0)) { { - State = 2006; + State = 2152; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__50: @@ -11375,13 +11615,13 @@ public MethodHeadContext methodHead() { case T__144: case T__145: { - State = 2004; + State = 2150; methAttr(); } break; case T__146: { - State = 2005; + State = 2151; pinvImpl(); } break; @@ -11389,35 +11629,35 @@ public MethodHeadContext methodHead() { throw new NoViableAltException(this); } } - State = 2010; + State = 2156; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2011; + State = 2157; callConv(); - State = 2012; + State = 2158; paramAttr(); - State = 2013; + State = 2159; type(); - State = 2014; + State = 2160; marshalClause(); - State = 2015; + State = 2161; methodName(); - State = 2016; + State = 2162; typarsClause(); - State = 2017; + State = 2163; sigArgs(); - State = 2021; + State = 2167; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 32766L) != 0) || _la==T__69 || _la==T__155 || _la==UNMANAGED) { { { - State = 2018; + State = 2164; implAttr(); } } - State = 2023; + State = 2169; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11459,145 +11699,145 @@ public MethAttrContext methAttr() { MethAttrContext _localctx = new MethAttrContext(Context, State); EnterRule(_localctx, 236, RULE_methAttr); try { - State = 2047; + State = 2193; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__122: EnterOuterAlt(_localctx, 1); { - State = 2024; + State = 2170; Match(T__122); } break; case T__50: EnterOuterAlt(_localctx, 2); { - State = 2025; + State = 2171; Match(T__50); } break; case T__51: EnterOuterAlt(_localctx, 3); { - State = 2026; + State = 2172; Match(T__51); } break; case T__62: EnterOuterAlt(_localctx, 4); { - State = 2027; + State = 2173; Match(T__62); } break; case T__139: EnterOuterAlt(_localctx, 5); { - State = 2028; + State = 2174; Match(T__139); } break; case T__67: EnterOuterAlt(_localctx, 6); { - State = 2029; + State = 2175; Match(T__67); } break; case T__140: EnterOuterAlt(_localctx, 7); { - State = 2030; + State = 2176; Match(T__140); } break; case T__141: EnterOuterAlt(_localctx, 8); { - State = 2031; + State = 2177; Match(T__141); } break; case T__53: EnterOuterAlt(_localctx, 9); { - State = 2032; + State = 2178; Match(T__53); } break; case T__63: EnterOuterAlt(_localctx, 10); { - State = 2033; + State = 2179; Match(T__63); } break; case T__64: EnterOuterAlt(_localctx, 11); { - State = 2034; + State = 2180; Match(T__64); } break; case T__65: EnterOuterAlt(_localctx, 12); { - State = 2035; + State = 2181; Match(T__65); } break; case T__124: EnterOuterAlt(_localctx, 13); { - State = 2036; + State = 2182; Match(T__124); } break; case T__142: EnterOuterAlt(_localctx, 14); { - State = 2037; + State = 2183; Match(T__142); } break; case T__143: EnterOuterAlt(_localctx, 15); { - State = 2038; + State = 2184; Match(T__143); } break; case T__68: EnterOuterAlt(_localctx, 16); { - State = 2039; + State = 2185; Match(T__68); } break; case T__144: EnterOuterAlt(_localctx, 17); { - State = 2040; + State = 2186; Match(T__144); } break; case T__145: EnterOuterAlt(_localctx, 18); { - State = 2041; + State = 2187; Match(T__145); } break; case T__69: EnterOuterAlt(_localctx, 19); { - State = 2042; + State = 2188; Match(T__69); - State = 2043; + State = 2189; Match(T__29); - State = 2044; + State = 2190; int32(); - State = 2045; + State = 2191; Match(T__30); } break; @@ -11648,31 +11888,31 @@ public PinvImplContext pinvImpl() { EnterRule(_localctx, 238, RULE_pinvImpl); int _la; try { - State = 2067; + State = 2213; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,118,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2049; + State = 2195; Match(T__146); - State = 2050; + State = 2196; Match(T__29); - State = 2056; + State = 2202; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==QSTRING) { { - State = 2051; + State = 2197; compQstring(); - State = 2054; + State = 2200; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__33) { { - State = 2052; + State = 2198; Match(T__33); - State = 2053; + State = 2199; compQstring(); } } @@ -11680,30 +11920,30 @@ public PinvImplContext pinvImpl() { } } - State = 2061; + State = 2207; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 57)) & ~0x3f) == 0 && ((1L << (_la - 57)) & 8195L) != 0) || ((((_la - 148)) & ~0x3f) == 0 && ((1L << (_la - 148)) & 79L) != 0) || ((((_la - 224)) & ~0x3f) == 0 && ((1L << (_la - 224)) & 251658241L) != 0)) { { { - State = 2058; + State = 2204; pinvAttr(); } } - State = 2063; + State = 2209; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2064; + State = 2210; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2065; + State = 2211; Match(T__146); - State = 2066; + State = 2212; Match(T__84); } break; @@ -11747,133 +11987,133 @@ public PinvAttrContext pinvAttr() { PinvAttrContext _localctx = new PinvAttrContext(Context, State); EnterRule(_localctx, 240, RULE_pinvAttr); try { - State = 2096; + State = 2242; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,119,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2069; + State = 2215; Match(T__147); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2070; + State = 2216; Match(ANSI); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2071; + State = 2217; Match(T__56); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2072; + State = 2218; Match(T__57); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2073; + State = 2219; Match(T__148); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2074; + State = 2220; Match(T__149); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2075; + State = 2221; Match(CDECL); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2076; + State = 2222; Match(STDCALL); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2077; + State = 2223; Match(THISCALL); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2078; + State = 2224; Match(FASTCALL); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2079; + State = 2225; Match(T__150); - State = 2080; + State = 2226; Match(T__74); - State = 2081; + State = 2227; Match(T__151); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2082; + State = 2228; Match(T__150); - State = 2083; + State = 2229; Match(T__74); - State = 2084; + State = 2230; Match(T__152); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2085; + State = 2231; Match(T__153); - State = 2086; + State = 2232; Match(T__74); - State = 2087; + State = 2233; Match(T__151); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2088; + State = 2234; Match(T__153); - State = 2089; + State = 2235; Match(T__74); - State = 2090; + State = 2236; Match(T__152); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2091; + State = 2237; Match(T__69); - State = 2092; + State = 2238; Match(T__29); - State = 2093; + State = 2239; int32(); - State = 2094; + State = 2240; Match(T__30); } break; @@ -11891,6 +12131,10 @@ public PinvAttrContext pinvAttr() { } public partial class MethodNameContext : ParserRuleContext { + public string Value; + public IToken ctorName; + public IToken cctorName; + public DottedNameContext dotted; [System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() { return GetRuleContext(0); } @@ -11912,21 +12156,23 @@ public MethodNameContext methodName() { MethodNameContext _localctx = new MethodNameContext(Context, State); EnterRule(_localctx, 242, RULE_methodName); try { - State = 2101; + State = 2251; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__115: EnterOuterAlt(_localctx, 1); { - State = 2098; - Match(T__115); + State = 2244; + _localctx.ctorName = Match(T__115); + _localctx.Value = Actions.GetMethodName(_localctx.ctorName); } break; case T__154: EnterOuterAlt(_localctx, 2); { - State = 2099; - Match(T__154); + State = 2246; + _localctx.cctorName = Match(T__154); + _localctx.Value = Actions.GetMethodName(_localctx.cctorName); } break; case T__15: @@ -11937,8 +12183,9 @@ public MethodNameContext methodName() { case ID: EnterOuterAlt(_localctx, 3); { - State = 2100; - dottedName(); + State = 2248; + _localctx.dotted = dottedName(); + _localctx.Value = _localctx.dotted.Value; } break; default: @@ -11979,131 +12226,131 @@ public ImplAttrContext implAttr() { ImplAttrContext _localctx = new ImplAttrContext(Context, State); EnterRule(_localctx, 244, RULE_implAttr); try { - State = 2124; + State = 2274; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: EnterOuterAlt(_localctx, 1); { - State = 2103; + State = 2253; Match(T__0); } break; case T__1: EnterOuterAlt(_localctx, 2); { - State = 2104; + State = 2254; Match(T__1); } break; case T__155: EnterOuterAlt(_localctx, 3); { - State = 2105; + State = 2255; Match(T__155); } break; case T__2: EnterOuterAlt(_localctx, 4); { - State = 2106; + State = 2256; Match(T__2); } break; case T__3: EnterOuterAlt(_localctx, 5); { - State = 2107; + State = 2257; Match(T__3); } break; case UNMANAGED: EnterOuterAlt(_localctx, 6); { - State = 2108; + State = 2258; Match(UNMANAGED); } break; case T__4: EnterOuterAlt(_localctx, 7); { - State = 2109; + State = 2259; Match(T__4); } break; case T__5: EnterOuterAlt(_localctx, 8); { - State = 2110; + State = 2260; Match(T__5); } break; case T__6: EnterOuterAlt(_localctx, 9); { - State = 2111; + State = 2261; Match(T__6); } break; case T__7: EnterOuterAlt(_localctx, 10); { - State = 2112; + State = 2262; Match(T__7); } break; case T__8: EnterOuterAlt(_localctx, 11); { - State = 2113; + State = 2263; Match(T__8); } break; case T__9: EnterOuterAlt(_localctx, 12); { - State = 2114; + State = 2264; Match(T__9); } break; case T__10: EnterOuterAlt(_localctx, 13); { - State = 2115; + State = 2265; Match(T__10); } break; case T__11: EnterOuterAlt(_localctx, 14); { - State = 2116; + State = 2266; Match(T__11); } break; case T__12: EnterOuterAlt(_localctx, 15); { - State = 2117; + State = 2267; Match(T__12); } break; case T__13: EnterOuterAlt(_localctx, 16); { - State = 2118; + State = 2268; Match(T__13); } break; case T__69: EnterOuterAlt(_localctx, 17); { - State = 2119; + State = 2269; Match(T__69); - State = 2120; + State = 2270; Match(T__29); - State = 2121; + State = 2271; int32(); - State = 2122; + State = 2272; Match(T__30); } break; @@ -12151,17 +12398,17 @@ public MethodDeclsContext methodDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2129; + State = 2279; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38789119998L) != 0) || _la==T__72 || _la==T__73 || ((((_la - 158)) & ~0x3f) == 0 && ((1L << (_la - 158)) & 2199023255681L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 2303696760354115601L) != 0)) { { { - State = 2126; + State = 2276; methodDecl(); } } - State = 2131; + State = 2281; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -12221,7 +12468,7 @@ public MethodDeclContext methodDecl() { MethodDeclContext _localctx = new MethodDeclContext(Context, State); EnterRule(_localctx, 248, RULE_methodDecl); try { - State = 2149; + State = 2299; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case INSTR_NONE: @@ -12239,16 +12486,16 @@ public MethodDeclContext methodDecl() { case INSTR_TOK: EnterOuterAlt(_localctx, 1); { - State = 2132; + State = 2282; instr(); } break; case EMITBYTE: EnterOuterAlt(_localctx, 2); { - State = 2133; + State = 2283; Match(EMITBYTE); - State = 2134; + State = 2284; _localctx.value = int32(); Actions.EmitByte((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -12256,16 +12503,16 @@ public MethodDeclContext methodDecl() { case T__157: EnterOuterAlt(_localctx, 3); { - State = 2137; + State = 2287; sehBlock(); } break; case MAXSTACK: EnterOuterAlt(_localctx, 4); { - State = 2138; + State = 2288; Match(MAXSTACK); - State = 2139; + State = 2289; _localctx.value = int32(); Actions.SetMaxStack((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -12273,7 +12520,7 @@ public MethodDeclContext methodDecl() { case ENTRYPOINT: EnterOuterAlt(_localctx, 5); { - State = 2142; + State = 2292; Match(ENTRYPOINT); Actions.SetEntryPoint(); } @@ -12281,7 +12528,7 @@ public MethodDeclContext methodDecl() { case ZEROINIT: EnterOuterAlt(_localctx, 6); { - State = 2144; + State = 2294; Match(ZEROINIT); Actions.SetZeroInit(); } @@ -12308,14 +12555,14 @@ public MethodDeclContext methodDecl() { case ID: EnterOuterAlt(_localctx, 7); { - State = 2146; + State = 2296; labelDecl(); } break; case T__16: EnterOuterAlt(_localctx, 8); { - State = 2147; + State = 2297; scopeBlock(); } break; @@ -12341,7 +12588,7 @@ public MethodDeclContext methodDecl() { case VTENTRY: EnterOuterAlt(_localctx, 9); { - State = 2148; + State = 2298; methodDeclIsland(); } break; @@ -12447,176 +12694,176 @@ public MethodDeclIslandContext methodDeclIsland() { BeginSubtree(); try { int _alt; - State = 2249; + State = 2399; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,129,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2151; + State = 2301; Match(LOCALS); - State = 2152; + State = 2302; sigArgs(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2153; + State = 2303; Match(LOCALS); - State = 2154; + State = 2304; Match(T__156); - State = 2155; + State = 2305; sigArgs(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2156; + State = 2306; dataDecl(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2157; + State = 2307; secDecl(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2158; + State = 2308; extSourceSpec(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2159; + State = 2309; languageDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2160; + State = 2310; customDescrInMethodBody(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2161; + State = 2311; compControl(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2162; + State = 2312; Match(EXPORT); - State = 2163; + State = 2313; Match(T__41); - State = 2164; + State = 2314; int32(); - State = 2165; + State = 2315; Match(T__42); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2167; + State = 2317; Match(EXPORT); - State = 2168; + State = 2318; Match(T__41); - State = 2169; + State = 2319; int32(); - State = 2170; + State = 2320; Match(T__42); - State = 2171; + State = 2321; Match(T__33); - State = 2172; + State = 2322; id(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2174; + State = 2324; Match(VTENTRY); - State = 2175; + State = 2325; int32(); - State = 2176; + State = 2326; Match(T__74); - State = 2177; + State = 2327; int32(); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2179; + State = 2329; Match(OVERRIDE); - State = 2180; + State = 2330; typeSpec(); - State = 2181; + State = 2331; Match(DCOLON); - State = 2182; + State = 2332; methodName(); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2184; + State = 2334; Match(OVERRIDE); - State = 2185; + State = 2335; Match(METHOD); - State = 2186; + State = 2336; callConv(); - State = 2187; + State = 2337; type(); - State = 2188; + State = 2338; typeSpec(); - State = 2189; + State = 2339; Match(DCOLON); - State = 2190; + State = 2340; methodName(); - State = 2191; + State = 2341; genArity(); - State = 2192; + State = 2342; sigArgs(); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2194; + State = 2344; Match(PARAM); - State = 2195; + State = 2345; Match(TYPE); - State = 2196; + State = 2346; Match(T__41); - State = 2197; + State = 2347; int32(); - State = 2198; + State = 2348; Match(T__42); - State = 2202; + State = 2352; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,124,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2199; + State = 2349; customAttrDecl(); } } } - State = 2204; + State = 2354; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,124,Context); } @@ -12625,25 +12872,25 @@ public MethodDeclIslandContext methodDeclIsland() { case 15: EnterOuterAlt(_localctx, 15); { - State = 2205; + State = 2355; Match(PARAM); - State = 2206; + State = 2356; Match(TYPE); - State = 2207; + State = 2357; dottedName(); - State = 2211; + State = 2361; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,125,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2208; + State = 2358; customAttrDecl(); } } } - State = 2213; + State = 2363; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,125,Context); } @@ -12652,33 +12899,33 @@ public MethodDeclIslandContext methodDeclIsland() { case 16: EnterOuterAlt(_localctx, 16); { - State = 2214; + State = 2364; Match(PARAM); - State = 2215; + State = 2365; Match(CONSTRAINT); - State = 2216; + State = 2366; Match(T__41); - State = 2217; + State = 2367; int32(); - State = 2218; + State = 2368; Match(T__42); - State = 2219; + State = 2369; Match(T__27); - State = 2220; + State = 2370; typeSpec(); - State = 2224; + State = 2374; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,126,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2221; + State = 2371; customAttrDecl(); } } } - State = 2226; + State = 2376; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,126,Context); } @@ -12687,29 +12934,29 @@ public MethodDeclIslandContext methodDeclIsland() { case 17: EnterOuterAlt(_localctx, 17); { - State = 2227; + State = 2377; Match(PARAM); - State = 2228; + State = 2378; Match(CONSTRAINT); - State = 2229; + State = 2379; dottedName(); - State = 2230; + State = 2380; Match(T__27); - State = 2231; + State = 2381; typeSpec(); - State = 2235; + State = 2385; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,127,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2232; + State = 2382; customAttrDecl(); } } } - State = 2237; + State = 2387; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,127,Context); } @@ -12718,29 +12965,29 @@ public MethodDeclIslandContext methodDeclIsland() { case 18: EnterOuterAlt(_localctx, 18); { - State = 2238; + State = 2388; Match(PARAM); - State = 2239; + State = 2389; Match(T__41); - State = 2240; + State = 2390; int32(); - State = 2241; + State = 2391; Match(T__42); - State = 2242; + State = 2392; initOpt(); - State = 2246; + State = 2396; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,128,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2243; + State = 2393; customAttrDecl(); } } } - State = 2248; + State = 2398; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,128,Context); } @@ -12787,9 +13034,9 @@ public LabelDeclContext labelDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2251; + State = 2401; _localctx.name = id(); - State = 2252; + State = 2402; Match(T__74); Actions.DefineLabel((_localctx.name!=null?(_localctx.name.Start):null)); } @@ -12830,20 +13077,20 @@ public CustomDescrInMethodBodyContext customDescrInMethodBody() { CustomDescrInMethodBodyContext _localctx = new CustomDescrInMethodBodyContext(Context, State); EnterRule(_localctx, 254, RULE_customDescrInMethodBody); try { - State = 2257; + State = 2407; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,130,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2255; + State = 2405; customDescr(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2256; + State = 2406; customDescrWithOwner(); } break; @@ -12885,11 +13132,11 @@ public ScopeBlockContext scopeBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 2259; + State = 2409; Match(T__16); - State = 2260; + State = 2410; methodDecls(); - State = 2261; + State = 2411; Match(T__17); } } @@ -12933,9 +13180,9 @@ public SehBlockContext sehBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 2263; + State = 2413; tryBlock(); - State = 2264; + State = 2414; sehClauses(); } Context.Stop = TokenStream.LT(-1); @@ -12981,17 +13228,17 @@ public SehClausesContext sehClauses() { try { EnterOuterAlt(_localctx, 1); { - State = 2267; + State = 2417; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2266; + State = 2416; sehClause(); } } - State = 2269; + State = 2419; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( ((((_la - 160)) & ~0x3f) == 0 && ((1L << (_la - 160)) & 15L) != 0) ); @@ -13042,41 +13289,41 @@ public TryBlockContext tryBlock() { TryBlockContext _localctx = new TryBlockContext(Context, State); EnterRule(_localctx, 262, RULE_tryBlock); try { - State = 2283; + State = 2433; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,132,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2271; + State = 2421; Match(T__157); - State = 2272; + State = 2422; scopeBlock(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2273; + State = 2423; Match(T__157); - State = 2274; + State = 2424; id(); - State = 2275; + State = 2425; Match(T__158); - State = 2276; + State = 2426; id(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2278; + State = 2428; Match(T__157); - State = 2279; + State = 2429; int32(); - State = 2280; + State = 2430; Match(T__158); - State = 2281; + State = 2431; int32(); } break; @@ -13127,42 +13374,42 @@ public SehClauseContext sehClause() { SehClauseContext _localctx = new SehClauseContext(Context, State); EnterRule(_localctx, 264, RULE_sehClause); try { - State = 2297; + State = 2447; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__160: EnterOuterAlt(_localctx, 1); { - State = 2285; + State = 2435; catchClause(); - State = 2286; + State = 2436; handlerBlock(); } break; case T__159: EnterOuterAlt(_localctx, 2); { - State = 2288; + State = 2438; filterClause(); - State = 2289; + State = 2439; handlerBlock(); } break; case T__161: EnterOuterAlt(_localctx, 3); { - State = 2291; + State = 2441; finallyClause(); - State = 2292; + State = 2442; handlerBlock(); } break; case T__162: EnterOuterAlt(_localctx, 4); { - State = 2294; + State = 2444; faultClause(); - State = 2295; + State = 2445; handlerBlock(); } break; @@ -13209,33 +13456,33 @@ public FilterClauseContext filterClause() { FilterClauseContext _localctx = new FilterClauseContext(Context, State); EnterRule(_localctx, 266, RULE_filterClause); try { - State = 2305; + State = 2455; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,134,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2299; + State = 2449; Match(T__159); - State = 2300; + State = 2450; scopeBlock(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2301; + State = 2451; Match(T__159); - State = 2302; + State = 2452; id(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2303; + State = 2453; Match(T__159); - State = 2304; + State = 2454; int32(); } break; @@ -13276,9 +13523,9 @@ public CatchClauseContext catchClause() { try { EnterOuterAlt(_localctx, 1); { - State = 2307; + State = 2457; Match(T__160); - State = 2308; + State = 2458; typeSpec(); } Context.Stop = TokenStream.LT(-1); @@ -13316,7 +13563,7 @@ public FinallyClauseContext finallyClause() { try { EnterOuterAlt(_localctx, 1); { - State = 2310; + State = 2460; Match(T__161); } } @@ -13352,7 +13599,7 @@ public FaultClauseContext faultClause() { try { EnterOuterAlt(_localctx, 1); { - State = 2312; + State = 2462; Match(T__162); } } @@ -13401,39 +13648,39 @@ public HandlerBlockContext handlerBlock() { HandlerBlockContext _localctx = new HandlerBlockContext(Context, State); EnterRule(_localctx, 274, RULE_handlerBlock); try { - State = 2325; + State = 2475; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,135,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2314; + State = 2464; scopeBlock(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2315; + State = 2465; Match(T__163); - State = 2316; + State = 2466; id(); - State = 2317; + State = 2467; Match(T__158); - State = 2318; + State = 2468; id(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2320; + State = 2470; Match(T__163); - State = 2321; + State = 2471; int32(); - State = 2322; + State = 2472; Match(T__158); - State = 2323; + State = 2473; int32(); } break; @@ -13477,9 +13724,9 @@ public DataDeclContext dataDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2327; + State = 2477; ddHead(); - State = 2328; + State = 2478; ddBody(); } } @@ -13519,28 +13766,28 @@ public DdHeadContext ddHead() { DdHeadContext _localctx = new DdHeadContext(Context, State); EnterRule(_localctx, 278, RULE_ddHead); try { - State = 2337; + State = 2487; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,136,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2330; + State = 2480; Match(T__164); - State = 2331; + State = 2481; tls(); - State = 2332; + State = 2482; id(); - State = 2333; + State = 2483; Match(T__35); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2335; + State = 2485; Match(T__164); - State = 2336; + State = 2486; tls(); } break; @@ -13576,7 +13823,7 @@ public TlsContext tls() { TlsContext _localctx = new TlsContext(Context, State); EnterRule(_localctx, 280, RULE_tls); try { - State = 2342; + State = 2492; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,137,Context) ) { case 1: @@ -13587,14 +13834,14 @@ public TlsContext tls() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2340; + State = 2490; Match(T__165); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2341; + State = 2491; Match(T__1); } break; @@ -13640,17 +13887,17 @@ public DdBodyContext ddBody() { EnterRule(_localctx, 282, RULE_ddBody); int _la; try { - State = 2353; + State = 2503; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: EnterOuterAlt(_localctx, 1); { - State = 2344; + State = 2494; Match(T__16); - State = 2345; + State = 2495; ddItemList(); - State = 2346; + State = 2496; Match(T__17); } break; @@ -13665,17 +13912,17 @@ public DdBodyContext ddBody() { case REF: EnterOuterAlt(_localctx, 2); { - State = 2349; + State = 2499; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2348; + State = 2498; ddItem(); } } - State = 2351; + State = 2501; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( _la==T__83 || ((((_la - 181)) & ~0x3f) == 0 && ((1L << (_la - 181)) & 505L) != 0) || _la==REF ); @@ -13724,25 +13971,25 @@ public DdItemListContext ddItemList() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 2360; + State = 2510; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,140,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2355; + State = 2505; ddItem(); - State = 2356; + State = 2506; Match(T__27); } } } - State = 2362; + State = 2512; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,140,Context); } - State = 2363; + State = 2513; ddItem(); } } @@ -13779,7 +14026,7 @@ public DdItemCountContext ddItemCount() { DdItemCountContext _localctx = new DdItemCountContext(Context, State); EnterRule(_localctx, 286, RULE_ddItemCount); try { - State = 2370; + State = 2520; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -13883,11 +14130,11 @@ public DdItemCountContext ddItemCount() { case T__41: EnterOuterAlt(_localctx, 2); { - State = 2366; + State = 2516; Match(T__41); - State = 2367; + State = 2517; int32(); - State = 2368; + State = 2518; Match(T__42); } break; @@ -13955,200 +14202,200 @@ public DdItemContext ddItem() { DdItemContext _localctx = new DdItemContext(Context, State); EnterRule(_localctx, 288, RULE_ddItem); try { - State = 2438; + State = 2588; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,142,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2372; + State = 2522; Match(CHAR); - State = 2373; + State = 2523; Match(PTR); - State = 2374; + State = 2524; Match(T__29); - State = 2375; + State = 2525; compQstring(); - State = 2376; + State = 2526; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2378; + State = 2528; Match(REF); - State = 2379; + State = 2529; Match(T__29); - State = 2380; + State = 2530; id(); - State = 2381; + State = 2531; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2383; + State = 2533; Match(REF); - State = 2384; + State = 2534; id(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2385; + State = 2535; Match(T__83); - State = 2386; + State = 2536; Match(T__29); - State = 2387; + State = 2537; bytes(); - State = 2388; + State = 2538; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2390; + State = 2540; Match(FLOAT32); - State = 2391; + State = 2541; Match(T__29); - State = 2392; + State = 2542; float64(); - State = 2393; + State = 2543; Match(T__30); - State = 2394; + State = 2544; ddItemCount(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2396; + State = 2546; Match(FLOAT64_); - State = 2397; + State = 2547; Match(T__29); - State = 2398; + State = 2548; float64(); - State = 2399; + State = 2549; Match(T__30); - State = 2400; + State = 2550; ddItemCount(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2402; + State = 2552; Match(INT64_); - State = 2403; + State = 2553; Match(T__29); - State = 2404; + State = 2554; int64(); - State = 2405; + State = 2555; Match(T__30); - State = 2406; + State = 2556; ddItemCount(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2408; + State = 2558; Match(INT32_); - State = 2409; + State = 2559; Match(T__29); - State = 2410; + State = 2560; int32(); - State = 2411; + State = 2561; Match(T__30); - State = 2412; + State = 2562; ddItemCount(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2414; + State = 2564; Match(INT16); - State = 2415; + State = 2565; Match(T__29); - State = 2416; + State = 2566; int32(); - State = 2417; + State = 2567; Match(T__30); - State = 2418; + State = 2568; ddItemCount(); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2420; + State = 2570; Match(INT8); - State = 2421; + State = 2571; Match(T__29); - State = 2422; + State = 2572; int32(); - State = 2423; + State = 2573; Match(T__30); - State = 2424; + State = 2574; ddItemCount(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2426; + State = 2576; Match(FLOAT32); - State = 2427; + State = 2577; ddItemCount(); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2428; + State = 2578; Match(FLOAT64_); - State = 2429; + State = 2579; ddItemCount(); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2430; + State = 2580; Match(INT64_); - State = 2431; + State = 2581; ddItemCount(); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2432; + State = 2582; Match(INT32_); - State = 2433; + State = 2583; ddItemCount(); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2434; + State = 2584; Match(INT16); - State = 2435; + State = 2585; ddItemCount(); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 2436; + State = 2586; Match(INT8); - State = 2437; + State = 2587; ddItemCount(); } break; @@ -14211,201 +14458,201 @@ public FieldSerInitContext fieldSerInit() { FieldSerInitContext _localctx = new FieldSerInitContext(Context, State); EnterRule(_localctx, 290, RULE_fieldSerInit); try { - State = 2515; + State = 2665; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,143,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2440; + State = 2590; Match(FLOAT32); - State = 2441; + State = 2591; Match(T__29); - State = 2442; + State = 2592; float64(); - State = 2443; + State = 2593; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2445; + State = 2595; Match(FLOAT64_); - State = 2446; + State = 2596; Match(T__29); - State = 2447; + State = 2597; float64(); - State = 2448; + State = 2598; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2450; + State = 2600; Match(FLOAT32); - State = 2451; + State = 2601; Match(T__29); - State = 2452; + State = 2602; int32(); - State = 2453; + State = 2603; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2455; + State = 2605; Match(FLOAT64_); - State = 2456; + State = 2606; Match(T__29); - State = 2457; + State = 2607; int64(); - State = 2458; + State = 2608; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2460; + State = 2610; Match(INT64_); - State = 2461; + State = 2611; Match(T__29); - State = 2462; + State = 2612; int64(); - State = 2463; + State = 2613; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2465; + State = 2615; Match(INT32_); - State = 2466; + State = 2616; Match(T__29); - State = 2467; + State = 2617; int32(); - State = 2468; + State = 2618; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2470; + State = 2620; Match(INT16); - State = 2471; + State = 2621; Match(T__29); - State = 2472; + State = 2622; int32(); - State = 2473; + State = 2623; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2475; + State = 2625; Match(INT8); - State = 2476; + State = 2626; Match(T__29); - State = 2477; + State = 2627; int32(); - State = 2478; + State = 2628; Match(T__30); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2480; + State = 2630; Match(UINT64); - State = 2481; + State = 2631; Match(T__29); - State = 2482; + State = 2632; int64(); - State = 2483; + State = 2633; Match(T__30); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2485; + State = 2635; Match(UINT32); - State = 2486; + State = 2636; Match(T__29); - State = 2487; + State = 2637; int32(); - State = 2488; + State = 2638; Match(T__30); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2490; + State = 2640; Match(UINT16); - State = 2491; + State = 2641; Match(T__29); - State = 2492; + State = 2642; int32(); - State = 2493; + State = 2643; Match(T__30); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2495; + State = 2645; Match(UINT8); - State = 2496; + State = 2646; Match(T__29); - State = 2497; + State = 2647; int32(); - State = 2498; + State = 2648; Match(T__30); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2500; + State = 2650; Match(CHAR); - State = 2501; + State = 2651; Match(T__29); - State = 2502; + State = 2652; int32(); - State = 2503; + State = 2653; Match(T__30); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2505; + State = 2655; Match(BOOL); - State = 2506; + State = 2656; Match(T__29); - State = 2507; + State = 2657; truefalse(); - State = 2508; + State = 2658; Match(T__30); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2510; + State = 2660; Match(T__83); - State = 2511; + State = 2661; Match(T__29); - State = 2512; + State = 2662; bytes(); - State = 2513; + State = 2663; Match(T__30); } break; @@ -14453,18 +14700,18 @@ public BytesContext bytes() { try { EnterOuterAlt(_localctx, 1); { - State = 2522; + State = 2672; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32 || _la==ID || _la==HEXBYTE) { { { - State = 2517; + State = 2667; _localctx.b = hexbyte(); Actions.AddByte(_localctx.b.Value); } } - State = 2524; + State = 2674; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -14508,7 +14755,7 @@ public HexbyteContext hexbyte() { try { EnterOuterAlt(_localctx, 1); { - State = 2525; + State = 2675; _la = TokenStream.LA(1); if ( !(_la==INT32 || _la==ID || _la==HEXBYTE) ) { ErrorHandler.RecoverInline(this); @@ -14558,7 +14805,7 @@ public FieldInitContext fieldInit() { FieldInitContext _localctx = new FieldInitContext(Context, State); EnterRule(_localctx, 296, RULE_fieldInit); try { - State = 2530; + State = 2680; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__83: @@ -14576,21 +14823,21 @@ public FieldInitContext fieldInit() { case UINT64: EnterOuterAlt(_localctx, 1); { - State = 2527; + State = 2677; fieldSerInit(); } break; case QSTRING: EnterOuterAlt(_localctx, 2); { - State = 2528; + State = 2678; compQstring(); } break; case NULLREF: EnterOuterAlt(_localctx, 3); { - State = 2529; + State = 2679; Match(NULLREF); } break; @@ -14687,378 +14934,378 @@ public SerInitContext serInit() { SerInitContext _localctx = new SerInitContext(Context, State); EnterRule(_localctx, 298, RULE_serInit); try { - State = 2680; + State = 2830; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,146,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2532; + State = 2682; fieldSerInit(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2533; + State = 2683; Match(STRING); - State = 2534; + State = 2684; Match(T__29); - State = 2535; + State = 2685; Match(NULLREF); - State = 2536; + State = 2686; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2537; + State = 2687; Match(STRING); - State = 2538; + State = 2688; Match(T__29); - State = 2539; + State = 2689; Match(SQSTRING); - State = 2540; + State = 2690; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2541; + State = 2691; Match(TYPE); - State = 2542; + State = 2692; Match(T__29); - State = 2543; + State = 2693; Match(T__38); - State = 2544; + State = 2694; Match(SQSTRING); - State = 2545; + State = 2695; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2546; + State = 2696; Match(TYPE); - State = 2547; + State = 2697; Match(T__29); - State = 2548; + State = 2698; className(); - State = 2549; + State = 2699; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2551; + State = 2701; Match(TYPE); - State = 2552; + State = 2702; Match(T__29); - State = 2553; + State = 2703; Match(NULLREF); - State = 2554; + State = 2704; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2555; + State = 2705; Match(OBJECT); - State = 2556; + State = 2706; Match(T__29); - State = 2557; + State = 2707; serInit(); - State = 2558; + State = 2708; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2560; + State = 2710; Match(FLOAT32); - State = 2561; + State = 2711; Match(T__41); - State = 2562; + State = 2712; int32(); - State = 2563; + State = 2713; Match(T__42); - State = 2564; + State = 2714; Match(T__29); - State = 2565; + State = 2715; f32seq(); - State = 2566; + State = 2716; Match(T__30); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2568; + State = 2718; Match(FLOAT64_); - State = 2569; + State = 2719; Match(T__41); - State = 2570; + State = 2720; int32(); - State = 2571; + State = 2721; Match(T__42); - State = 2572; + State = 2722; Match(T__29); - State = 2573; + State = 2723; f64seq(); - State = 2574; + State = 2724; Match(T__30); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2576; + State = 2726; Match(INT64_); - State = 2577; + State = 2727; Match(T__41); - State = 2578; + State = 2728; int32(); - State = 2579; + State = 2729; Match(T__42); - State = 2580; + State = 2730; Match(T__29); - State = 2581; + State = 2731; i64seq(); - State = 2582; + State = 2732; Match(T__30); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2584; + State = 2734; Match(INT32_); - State = 2585; + State = 2735; Match(T__41); - State = 2586; + State = 2736; int32(); - State = 2587; + State = 2737; Match(T__42); - State = 2588; + State = 2738; Match(T__29); - State = 2589; + State = 2739; i32seq(); - State = 2590; + State = 2740; Match(T__30); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2592; + State = 2742; Match(INT16); - State = 2593; + State = 2743; Match(T__41); - State = 2594; + State = 2744; int32(); - State = 2595; + State = 2745; Match(T__42); - State = 2596; + State = 2746; Match(T__29); - State = 2597; + State = 2747; i16seq(); - State = 2598; + State = 2748; Match(T__30); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2600; + State = 2750; Match(INT8); - State = 2601; + State = 2751; Match(T__41); - State = 2602; + State = 2752; int32(); - State = 2603; + State = 2753; Match(T__42); - State = 2604; + State = 2754; Match(T__29); - State = 2605; + State = 2755; i8seq(); - State = 2606; + State = 2756; Match(T__30); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2608; + State = 2758; Match(UINT64); - State = 2609; + State = 2759; Match(T__41); - State = 2610; + State = 2760; int32(); - State = 2611; + State = 2761; Match(T__42); - State = 2612; + State = 2762; Match(T__29); - State = 2613; + State = 2763; i64seq(); - State = 2614; + State = 2764; Match(T__30); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2616; + State = 2766; Match(UINT32); - State = 2617; + State = 2767; Match(T__41); - State = 2618; + State = 2768; int32(); - State = 2619; + State = 2769; Match(T__42); - State = 2620; + State = 2770; Match(T__29); - State = 2621; + State = 2771; i32seq(); - State = 2622; + State = 2772; Match(T__30); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 2624; + State = 2774; Match(UINT16); - State = 2625; + State = 2775; Match(T__41); - State = 2626; + State = 2776; int32(); - State = 2627; + State = 2777; Match(T__42); - State = 2628; + State = 2778; Match(T__29); - State = 2629; + State = 2779; i16seq(); - State = 2630; + State = 2780; Match(T__30); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 2632; + State = 2782; Match(UINT8); - State = 2633; + State = 2783; Match(T__41); - State = 2634; + State = 2784; int32(); - State = 2635; + State = 2785; Match(T__42); - State = 2636; + State = 2786; Match(T__29); - State = 2637; + State = 2787; i8seq(); - State = 2638; + State = 2788; Match(T__30); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 2640; + State = 2790; Match(CHAR); - State = 2641; + State = 2791; Match(T__41); - State = 2642; + State = 2792; int32(); - State = 2643; + State = 2793; Match(T__42); - State = 2644; + State = 2794; Match(T__29); - State = 2645; + State = 2795; i16seq(); - State = 2646; + State = 2796; Match(T__30); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 2648; + State = 2798; Match(BOOL); - State = 2649; + State = 2799; Match(T__41); - State = 2650; + State = 2800; int32(); - State = 2651; + State = 2801; Match(T__42); - State = 2652; + State = 2802; Match(T__29); - State = 2653; + State = 2803; boolSeq(); - State = 2654; + State = 2804; Match(T__30); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 2656; + State = 2806; Match(STRING); - State = 2657; + State = 2807; Match(T__41); - State = 2658; + State = 2808; int32(); - State = 2659; + State = 2809; Match(T__42); - State = 2660; + State = 2810; Match(T__29); - State = 2661; + State = 2811; sqstringSeq(); - State = 2662; + State = 2812; Match(T__30); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 2664; + State = 2814; Match(TYPE); - State = 2665; + State = 2815; Match(T__41); - State = 2666; + State = 2816; int32(); - State = 2667; + State = 2817; Match(T__42); - State = 2668; + State = 2818; Match(T__29); - State = 2669; + State = 2819; classSeq(); - State = 2670; + State = 2820; Match(T__30); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 2672; + State = 2822; Match(OBJECT); - State = 2673; + State = 2823; Match(T__41); - State = 2674; + State = 2824; int32(); - State = 2675; + State = 2825; Match(T__42); - State = 2676; + State = 2826; Match(T__29); - State = 2677; + State = 2827; objSeq(); - State = 2678; + State = 2828; Match(T__30); } break; @@ -15109,29 +15356,29 @@ public F32seqContext f32seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2686; + State = 2836; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 98309L) != 0)) { { - State = 2684; + State = 2834; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,147,Context) ) { case 1: { - State = 2682; + State = 2832; float64(); } break; case 2: { - State = 2683; + State = 2833; int32(); } break; } } - State = 2688; + State = 2838; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15182,29 +15429,29 @@ public F64seqContext f64seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2693; + State = 2843; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 98311L) != 0)) { { - State = 2691; + State = 2841; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,149,Context) ) { case 1: { - State = 2689; + State = 2839; float64(); } break; case 2: { - State = 2690; + State = 2840; int64(); } break; } } - State = 2695; + State = 2845; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15249,17 +15496,17 @@ public I64seqContext i64seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2699; + State = 2849; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32 || _la==INT64) { { { - State = 2696; + State = 2846; int64(); } } - State = 2701; + State = 2851; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15304,17 +15551,17 @@ public I32seqContext i32seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2705; + State = 2855; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 2702; + State = 2852; int32(); } } - State = 2707; + State = 2857; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15359,17 +15606,17 @@ public I16seqContext i16seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2711; + State = 2861; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 2708; + State = 2858; int32(); } } - State = 2713; + State = 2863; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15414,17 +15661,17 @@ public I8seqContext i8seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2717; + State = 2867; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 2714; + State = 2864; int32(); } } - State = 2719; + State = 2869; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15469,17 +15716,17 @@ public BoolSeqContext boolSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 2723; + State = 2873; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__94 || _la==T__95) { { { - State = 2720; + State = 2870; truefalse(); } } - State = 2725; + State = 2875; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15526,13 +15773,13 @@ public SqstringSeqContext sqstringSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 2729; + State = 2879; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==NULLREF || _la==SQSTRING) { { { - State = 2726; + State = 2876; _la = TokenStream.LA(1); if ( !(_la==NULLREF || _la==SQSTRING) ) { ErrorHandler.RecoverInline(this); @@ -15543,7 +15790,7 @@ public SqstringSeqContext sqstringSeq() { } } } - State = 2731; + State = 2881; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15588,17 +15835,17 @@ public ClassSeqContext classSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 2735; + State = 2885; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4947802390528L) != 0) || _la==T__112 || _la==NULLREF || _la==VALUE || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 105553118478337L) != 0)) { { { - State = 2732; + State = 2882; classSeqElement(); } } - State = 2737; + State = 2887; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15639,22 +15886,22 @@ public ClassSeqElementContext classSeqElement() { ClassSeqElementContext _localctx = new ClassSeqElementContext(Context, State); EnterRule(_localctx, 318, RULE_classSeqElement); try { - State = 2742; + State = 2892; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case NULLREF: EnterOuterAlt(_localctx, 1); { - State = 2738; + State = 2888; Match(NULLREF); } break; case T__38: EnterOuterAlt(_localctx, 2); { - State = 2739; + State = 2889; Match(T__38); - State = 2740; + State = 2890; Match(SQSTRING); } break; @@ -15671,7 +15918,7 @@ public ClassSeqElementContext classSeqElement() { case ID: EnterOuterAlt(_localctx, 3); { - State = 2741; + State = 2891; className(); } break; @@ -15718,17 +15965,17 @@ public ObjSeqContext objSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 2747; + State = 2897; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__83 || ((((_la - 181)) & ~0x3f) == 0 && ((1L << (_la - 181)) & 106495L) != 0)) { { { - State = 2744; + State = 2894; serInit(); } } - State = 2749; + State = 2899; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15773,27 +16020,27 @@ public CustomAttrDeclContext customAttrDecl() { CustomAttrDeclContext _localctx = new CustomAttrDeclContext(Context, State); EnterRule(_localctx, 322, RULE_customAttrDecl); try { - State = 2753; + State = 2903; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,160,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2750; + State = 2900; customDescr(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2751; + State = 2901; customDescrWithOwner(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2752; + State = 2902; dottedName(); } break; @@ -15848,13 +16095,13 @@ public AsmOrRefDeclContext asmOrRefDecl() { EnterRule(_localctx, 324, RULE_asmOrRefDecl); int _la; try { - State = 2780; + State = 2930; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,161,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2755; + State = 2905; _la = TokenStream.LA(1); if ( !(_la==T__166 || _la==T__167) ) { ErrorHandler.RecoverInline(this); @@ -15863,72 +16110,72 @@ public AsmOrRefDeclContext asmOrRefDecl() { ErrorHandler.ReportMatch(this); Consume(); } - State = 2756; + State = 2906; Match(T__35); - State = 2757; + State = 2907; Match(T__29); - State = 2758; + State = 2908; bytes(); - State = 2759; + State = 2909; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2761; + State = 2911; Match(T__168); - State = 2762; + State = 2912; intOrWildcard(); - State = 2763; + State = 2913; Match(T__74); - State = 2764; + State = 2914; intOrWildcard(); - State = 2765; + State = 2915; Match(T__74); - State = 2766; + State = 2916; intOrWildcard(); - State = 2767; + State = 2917; Match(T__74); - State = 2768; + State = 2918; intOrWildcard(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2770; + State = 2920; Match(T__169); - State = 2771; + State = 2921; compQstring(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2772; + State = 2922; Match(T__169); - State = 2773; + State = 2923; Match(T__35); - State = 2774; + State = 2924; Match(T__29); - State = 2775; + State = 2925; bytes(); - State = 2776; + State = 2926; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2778; + State = 2928; customAttrDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2779; + State = 2929; compControl(); } break; @@ -15973,36 +16220,36 @@ public AssemblyRefHeadContext assemblyRefHead() { AssemblyRefHeadContext _localctx = new AssemblyRefHeadContext(Context, State); EnterRule(_localctx, 326, RULE_assemblyRefHead); try { - State = 2794; + State = 2944; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,162,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2782; + State = 2932; Match(T__24); - State = 2783; + State = 2933; Match(T__39); - State = 2784; + State = 2934; asmAttr(); - State = 2785; + State = 2935; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2787; + State = 2937; Match(T__24); - State = 2788; + State = 2938; Match(T__39); - State = 2789; + State = 2939; asmAttr(); - State = 2790; + State = 2940; dottedName(); - State = 2791; + State = 2941; Match(T__33); - State = 2792; + State = 2942; dottedName(); } break; @@ -16047,17 +16294,17 @@ public AssemblyRefDeclsContext assemblyRefDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2799; + State = 2949; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 36028835673735168L) != 0) || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & 4294975519L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 105555249070081L) != 0)) { { { - State = 2796; + State = 2946; assemblyRefDecl(); } } - State = 2801; + State = 2951; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16100,21 +16347,21 @@ public AssemblyRefDeclContext assemblyRefDecl() { AssemblyRefDeclContext _localctx = new AssemblyRefDeclContext(Context, State); EnterRule(_localctx, 330, RULE_assemblyRefDecl); try { - State = 2816; + State = 2966; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case HASH: EnterOuterAlt(_localctx, 1); { - State = 2802; + State = 2952; Match(HASH); - State = 2803; + State = 2953; Match(T__35); - State = 2804; + State = 2954; Match(T__29); - State = 2805; + State = 2955; bytes(); - State = 2806; + State = 2956; Match(T__30); } break; @@ -16139,29 +16386,29 @@ public AssemblyRefDeclContext assemblyRefDecl() { case ID: EnterOuterAlt(_localctx, 2); { - State = 2808; + State = 2958; asmOrRefDecl(); } break; case T__170: EnterOuterAlt(_localctx, 3); { - State = 2809; + State = 2959; Match(T__170); - State = 2810; + State = 2960; Match(T__35); - State = 2811; + State = 2961; Match(T__29); - State = 2812; + State = 2962; bytes(); - State = 2813; + State = 2963; Match(T__30); } break; case T__54: EnterOuterAlt(_localctx, 4); { - State = 2815; + State = 2965; Match(T__54); } break; @@ -16211,25 +16458,25 @@ public ExptypeHeadContext exptypeHead() { try { EnterOuterAlt(_localctx, 1); { - State = 2818; + State = 2968; Match(T__49); - State = 2819; + State = 2969; Match(T__39); - State = 2823; + State = 2973; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4618441417868443648L) != 0) || _la==T__171) { { { - State = 2820; + State = 2970; exptAttr(); } } - State = 2825; + State = 2975; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2826; + State = 2976; dottedName(); } } @@ -16276,23 +16523,23 @@ public ExportHeadContext exportHead() { try { EnterOuterAlt(_localctx, 1); { - State = 2828; + State = 2978; Match(EXPORT); - State = 2832; + State = 2982; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4618441417868443648L) != 0) || _la==T__171) { { { - State = 2829; + State = 2979; exptAttr(); } } - State = 2834; + State = 2984; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2835; + State = 2985; dottedName(); } } @@ -16326,81 +16573,81 @@ public ExptAttrContext exptAttr() { ExptAttrContext _localctx = new ExptAttrContext(Context, State); EnterRule(_localctx, 336, RULE_exptAttr); try { - State = 2852; + State = 3002; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,167,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2837; + State = 2987; Match(T__51); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2838; + State = 2988; Match(T__50); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2839; + State = 2989; Match(T__171); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2840; + State = 2990; Match(T__61); - State = 2841; + State = 2991; Match(T__50); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2842; + State = 2992; Match(T__61); - State = 2843; + State = 2993; Match(T__51); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2844; + State = 2994; Match(T__61); - State = 2845; + State = 2995; Match(T__62); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2846; + State = 2996; Match(T__61); - State = 2847; + State = 2997; Match(T__63); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2848; + State = 2998; Match(T__61); - State = 2849; + State = 2999; Match(T__64); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2850; + State = 3000; Match(T__61); - State = 2851; + State = 3001; Match(T__65); } break; @@ -16445,17 +16692,17 @@ public ExptypeDeclsContext exptypeDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2857; + State = 3007; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1125938597265408L) != 0) || _la==T__112 || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 2854; + State = 3004; exptypeDecl(); } } - State = 2859; + State = 3009; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16509,67 +16756,67 @@ public ExptypeDeclContext exptypeDecl() { ExptypeDeclContext _localctx = new ExptypeDeclContext(Context, State); EnterRule(_localctx, 340, RULE_exptypeDecl); try { - State = 2873; + State = 3023; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,169,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2860; + State = 3010; Match(T__20); - State = 2861; + State = 3011; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2862; + State = 3012; Match(T__49); - State = 2863; + State = 3013; Match(T__39); - State = 2864; + State = 3014; slashedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2865; + State = 3015; Match(T__24); - State = 2866; + State = 3016; Match(T__39); - State = 2867; + State = 3017; dottedName(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2868; + State = 3018; mdtoken(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2869; + State = 3019; Match(T__49); - State = 2870; + State = 3020; int32(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2871; + State = 3021; customAttrDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2872; + State = 3022; compControl(); } break; @@ -16619,56 +16866,56 @@ public ManifestResHeadContext manifestResHead() { EnterRule(_localctx, 342, RULE_manifestResHead); int _la; try { - State = 2894; + State = 3044; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,172,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2875; + State = 3025; Match(MRESOURCE); - State = 2879; + State = 3029; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__50 || _la==T__51) { { { - State = 2876; + State = 3026; manresAttr(); } } - State = 2881; + State = 3031; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2882; + State = 3032; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2883; + State = 3033; Match(MRESOURCE); - State = 2887; + State = 3037; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__50 || _la==T__51) { { { - State = 2884; + State = 3034; manresAttr(); } } - State = 2889; + State = 3039; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2890; + State = 3040; dottedName(); - State = 2891; + State = 3041; Match(T__33); - State = 2892; + State = 3042; dottedName(); } break; @@ -16707,7 +16954,7 @@ public ManresAttrContext manresAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 2896; + State = 3046; _la = TokenStream.LA(1); if ( !(_la==T__50 || _la==T__51) ) { ErrorHandler.RecoverInline(this); @@ -16757,17 +17004,17 @@ public ManifestResDeclsContext manifestResDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2901; + State = 3051; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38690422784L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 2898; + State = 3048; manifestResDecl(); } } - State = 2903; + State = 3053; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16815,30 +17062,30 @@ public ManifestResDeclContext manifestResDecl() { ManifestResDeclContext _localctx = new ManifestResDeclContext(Context, State); EnterRule(_localctx, 348, RULE_manifestResDecl); try { - State = 2914; + State = 3064; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__20: EnterOuterAlt(_localctx, 1); { - State = 2904; + State = 3054; Match(T__20); - State = 2905; + State = 3055; dottedName(); - State = 2906; + State = 3056; Match(T__43); - State = 2907; + State = 3057; int32(); } break; case T__24: EnterOuterAlt(_localctx, 2); { - State = 2909; + State = 3059; Match(T__24); - State = 2910; + State = 3060; Match(T__39); - State = 2911; + State = 3061; dottedName(); } break; @@ -16851,7 +17098,7 @@ public ManifestResDeclContext manifestResDecl() { case ID: EnterOuterAlt(_localctx, 3); { - State = 2912; + State = 3062; customAttrDecl(); } break; @@ -16865,7 +17112,7 @@ public ManifestResDeclContext manifestResDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 4); { - State = 2913; + State = 3063; compControl(); } break; @@ -16902,7 +17149,7 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { } private static int[] _serializedATN = { - 4,1,305,2917,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, + 4,1,305,3067,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, @@ -16929,183 +17176,194 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 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,1,0,1,0,1,1,1,1,1,1,1, - 1,5,1,357,8,1,10,1,12,1,360,9,1,1,1,1,1,3,1,364,8,1,1,2,1,2,1,3,1,3,1, - 3,5,3,371,8,3,10,3,12,3,374,9,3,1,3,1,3,1,3,1,4,5,4,380,8,4,10,4,12,4, - 383,9,4,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1, + 1,1,1,1,1,5,1,359,8,1,10,1,12,1,362,9,1,1,1,1,1,1,1,1,1,1,1,3,1,369,8, + 1,1,2,1,2,1,3,1,3,1,3,5,3,376,8,3,10,3,12,3,379,9,3,1,3,1,3,1,3,1,4,5, + 4,385,8,4,10,4,12,4,388,9,4,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1, 5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5, - 1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,3, - 5,435,8,5,1,6,1,6,1,6,1,7,1,7,1,7,1,8,1,8,1,8,1,8,1,9,1,9,1,9,1,10,1,10, - 1,10,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,12,1,12,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,476,8,13,1,14,1, - 14,1,15,1,15,1,15,5,15,483,8,15,10,15,12,15,486,9,15,1,15,1,15,1,16,1, - 16,1,17,1,17,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1, - 18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,3,18,515,8,18,1,19,1,19, - 3,19,519,8,19,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1, - 20,1,20,1,20,1,20,1,20,3,20,537,8,20,1,21,1,21,1,21,1,21,1,21,1,21,1,21, - 1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21, - 1,21,1,21,1,21,1,21,3,21,564,8,21,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1, - 22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,3, - 22,587,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,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,623,8,23,1,24,1,24,1,25,1, - 25,3,25,629,8,25,1,26,1,26,1,26,1,27,1,27,5,27,636,8,27,10,27,12,27,639, - 9,27,1,28,1,28,1,28,1,28,1,28,1,28,1,28,5,28,648,8,28,10,28,12,28,651, - 9,28,1,29,1,29,1,30,1,30,3,30,657,8,30,1,31,1,31,1,31,1,31,1,31,1,31,1, - 31,1,31,1,31,3,31,668,8,31,1,32,1,32,1,32,1,32,1,32,1,32,3,32,676,8,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,34,1,34,1,34,1,34,5,34,697,8,34,10,34,12,34,700,9,34,1,35,1,35, - 1,35,1,35,1,35,1,35,1,36,1,36,1,36,1,37,1,37,5,37,713,8,37,10,37,12,37, - 716,9,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, + 1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1, + 5,1,5,1,5,1,5,1,5,3,5,440,8,5,1,6,1,6,1,6,1,7,1,7,1,7,1,8,1,8,1,8,1,8, + 1,9,1,9,1,9,1,10,1,10,1,10,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,12,1,12, + 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,481,8,13,1,14,1,14,1,15,1,15,1,15,5,15,488,8,15,10,15,12,15,491,9, + 15,1,15,1,15,1,16,1,16,1,17,1,17,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1, + 18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,3, + 18,520,8,18,1,19,1,19,3,19,524,8,19,1,20,1,20,1,20,1,20,1,20,1,20,1,20, + 1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,3,20,542,8,20,1,21,1,21,1, + 21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1, + 21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,3,21,569,8,21,1,22,1,22,1,22, + 1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22, + 1,22,1,22,1,22,1,22,3,22,592,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,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,628, + 8,23,1,24,1,24,1,25,1,25,1,25,1,25,1,25,1,25,3,25,638,8,25,1,26,1,26,1, + 26,1,27,1,27,5,27,645,8,27,10,27,12,27,648,9,27,1,28,1,28,1,28,1,28,1, + 28,1,28,1,28,5,28,657,8,28,10,28,12,28,660,9,28,1,29,1,29,1,30,1,30,3, + 30,666,8,30,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,3,31,677,8,31, + 1,32,1,32,1,32,1,32,1,32,1,32,3,32,685,8,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,34,1,34,1,34,1,34,5, + 34,706,8,34,10,34,12,34,709,9,34,1,35,1,35,1,35,1,35,1,35,1,35,1,36,1, + 36,1,36,1,37,1,37,5,37,722,8,37,10,37,12,37,725,9,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,38,1,38,1,38,1,38,1,38,1, 38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1, - 38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1, - 38,1,38,3,38,760,8,38,1,39,1,39,1,39,3,39,765,8,39,1,40,1,40,1,40,3,40, - 770,8,40,1,41,5,41,773,8,41,10,41,12,41,776,9,41,1,42,1,42,1,42,5,42,781, - 8,42,10,42,12,42,784,9,42,1,42,1,42,1,43,1,43,1,44,1,44,1,44,1,44,1,44, - 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, + 38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,3,38,769,8,38,1,39, + 1,39,1,39,3,39,774,8,39,1,40,1,40,1,40,3,40,779,8,40,1,41,5,41,782,8,41, + 10,41,12,41,785,9,41,1,42,1,42,1,42,5,42,790,8,42,10,42,12,42,793,9,42, + 1,42,1,42,1,43,1,43,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, - 3,44,893,8,44,1,45,1,45,5,45,897,8,45,10,45,12,45,900,9,45,1,45,1,45,1, - 45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,5,45,913,8,45,10,45,12,45,916, - 9,45,1,45,1,45,1,45,3,45,921,8,45,1,46,1,46,1,47,1,47,3,47,927,8,47,1, - 48,1,48,1,49,5,49,932,8,49,10,49,12,49,935,9,49,1,50,1,50,1,50,1,50,1, - 50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1, - 50,1,50,1,50,1,50,1,50,1,50,1,50,3,50,962,8,50,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,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,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,1040,8,51,3,51,1042,8,51,1,52,1,52,1,52,1,52,1,53,1,53,1,53, - 1,53,1,53,1,53,1,53,3,53,1055,8,53,1,53,1,53,5,53,1059,8,53,10,53,12,53, - 1062,9,53,1,53,1,53,1,53,1,53,1,53,1,53,3,53,1070,8,53,3,53,1072,8,53, - 1,54,1,54,1,54,1,54,5,54,1078,8,54,10,54,12,54,1081,9,54,1,54,1,54,1,54, - 1,55,1,55,1,55,1,55,5,55,1090,8,55,10,55,12,55,1093,9,55,1,55,1,55,1,55, - 1,56,1,56,1,56,1,56,5,56,1102,8,56,10,56,12,56,1105,9,56,1,56,1,56,1,56, - 1,56,3,56,1111,8,56,1,57,1,57,1,57,1,57,1,57,3,57,1118,8,57,3,57,1120, - 8,57,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58, - 1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,3,58,1147, - 8,58,1,59,1,59,1,59,5,59,1152,8,59,10,59,12,59,1155,9,59,1,59,1,59,1,60, - 5,60,1160,8,60,10,60,12,60,1163,9,60,1,61,1,61,1,61,1,61,1,61,3,61,1170, - 8,61,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,3,62,1183, - 8,62,1,63,1,63,1,63,5,63,1188,8,63,10,63,12,63,1191,9,63,3,63,1193,8,63, + 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,3,44,902,8,44,1,45,1,45,5, + 45,906,8,45,10,45,12,45,909,9,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1, + 45,1,45,1,45,1,45,5,45,922,8,45,10,45,12,45,925,9,45,1,45,1,45,1,45,3, + 45,930,8,45,1,46,1,46,1,47,1,47,3,47,936,8,47,1,48,1,48,1,49,5,49,941, + 8,49,10,49,12,49,944,9,49,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50, + 1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50, + 1,50,1,50,3,50,971,8,50,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,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,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,1049,8,51,3, + 51,1051,8,51,1,52,1,52,1,52,1,52,1,52,1,53,1,53,1,53,1,53,1,53,1,53,1, + 53,3,53,1065,8,53,1,53,1,53,5,53,1069,8,53,10,53,12,53,1072,9,53,1,53, + 1,53,1,53,1,53,1,53,1,53,3,53,1080,8,53,3,53,1082,8,53,1,54,1,54,1,54, + 1,54,1,54,5,54,1089,8,54,10,54,12,54,1092,9,54,1,54,1,54,1,54,1,54,1,55, + 1,55,1,55,1,55,1,55,5,55,1103,8,55,10,55,12,55,1106,9,55,1,55,1,55,1,55, + 1,55,1,56,1,56,1,56,1,56,1,56,5,56,1117,8,56,10,56,12,56,1120,9,56,1,56, + 1,56,1,56,1,56,1,56,3,56,1127,8,56,1,57,1,57,1,57,1,57,1,57,1,57,3,57, + 1135,8,57,1,57,1,57,3,57,1139,8,57,1,58,1,58,1,58,1,58,1,58,1,58,1,58, + 1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58, + 1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58, + 1,58,1,58,3,58,1178,8,58,1,59,1,59,1,59,1,59,5,59,1184,8,59,10,59,12,59, + 1187,9,59,1,59,1,59,1,59,1,60,5,60,1193,8,60,10,60,12,60,1196,9,60,1,61, + 1,61,1,61,1,61,1,61,3,61,1203,8,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,3,62,1222,8,62,1,63, + 1,63,1,63,5,63,1227,8,63,10,63,12,63,1230,9,63,3,63,1232,8,63,1,64,1,64, 1,64,1,64,1,64,1,64,1,64,1,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,1212,8,64,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, + 1,64,3,64,1251,8,64,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, - 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, - 3,65,1306,8,65,1,66,1,66,1,66,1,66,1,66,1,66,1,66,3,66,1315,8,66,1,67, - 1,67,1,67,5,67,1320,8,67,10,67,12,67,1323,9,67,3,67,1325,8,67,1,68,1,68, - 1,69,1,69,5,69,1331,8,69,10,69,12,69,1334,9,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,1,70,1,70,1,70,3,70, - 1354,8,70,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, + 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,3,65,1345, + 8,65,1,66,1,66,1,66,1,66,1,66,1,66,1,66,3,66,1354,8,66,1,67,1,67,1,67, + 5,67,1359,8,67,10,67,12,67,1362,9,67,3,67,1364,8,67,1,68,1,68,1,69,1,69, + 1,69,1,69,1,69,5,69,1373,8,69,10,69,12,69,1376,9,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,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,1407,8,70, + 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, + 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, + 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, - 1,71,1,71,1,71,1,71,3,71,1386,8,71,1,72,1,72,1,72,1,72,1,72,1,72,1,72, + 1,71,1,71,3,71,1467,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,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72, - 3,72,1409,8,72,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,3,73, - 1421,8,73,1,74,1,74,1,74,1,75,1,75,1,75,1,75,3,75,1430,8,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,3,76,1455,8,76,1,76,1,76,1,76,1,76, + 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,1507,8,72,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73, + 1,73,1,73,1,73,1,73,3,73,1523,8,73,1,74,1,74,1,74,1,74,1,75,1,75,1,75, + 1,75,3,75,1533,8,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,3,76,1479,8,76,1,77,1,77,1,77,1,77,5,77,1485,8,77, - 10,77,12,77,1488,9,77,1,77,3,77,1491,8,77,1,78,1,78,1,78,1,78,1,78,1,78, - 1,78,1,78,1,78,1,78,1,78,1,78,1,78,3,78,1506,8,78,1,79,1,79,1,79,5,79, - 1511,8,79,10,79,12,79,1514,9,79,1,79,1,79,1,80,1,80,1,80,1,80,1,81,1,81, + 1,76,3,76,1560,8,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,1584, + 8,76,1,77,1,77,1,77,1,77,5,77,1590,8,77,10,77,12,77,1593,9,77,1,77,3,77, + 1596,8,77,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78, + 1,78,3,78,1611,8,78,1,79,1,79,1,79,5,79,1616,8,79,10,79,12,79,1619,9,79, + 1,79,1,79,1,80,1,80,1,80,1,80,1,81,1,81,1,82,1,82,1,82,1,82,1,82,1,82, 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, - 1,82,1,82,1,82,1,82,1,82,1,82,3,82,1558,8,82,1,83,1,83,1,84,1,84,1,84, - 1,84,1,84,1,84,3,84,1568,8,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84, - 1,84,1,84,1,84,1,84,1,84,1,84,3,84,1584,8,84,1,84,1,84,1,84,1,84,1,84, - 1,84,1,84,1,84,1,84,1,84,3,84,1596,8,84,1,85,1,85,1,85,1,85,1,85,1,85, - 1,85,1,85,1,85,1,85,3,85,1608,8,85,1,86,1,86,1,86,1,86,1,86,1,86,1,86, - 1,86,1,86,1,86,1,86,1,86,3,86,1622,8,86,1,87,1,87,1,87,1,87,1,87,1,88, - 1,88,1,88,1,88,1,88,3,88,1634,8,88,1,89,1,89,1,89,1,89,1,89,1,89,1,89, - 1,89,1,89,3,89,1645,8,89,1,90,1,90,1,90,5,90,1650,8,90,10,90,12,90,1653, - 9,90,1,90,1,90,1,91,1,91,1,91,1,91,1,91,3,91,1662,8,91,1,92,1,92,1,92, - 1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,3,92,1675,8,92,1,93,5,93,1678, - 8,93,10,93,12,93,1681,9,93,1,94,1,94,3,94,1685,8,94,1,94,1,94,1,95,1,95, - 1,95,5,95,1692,8,95,10,95,12,95,1695,9,95,1,95,1,95,1,96,1,96,1,96,1,96, - 1,97,1,97,3,97,1705,8,97,1,98,1,98,1,98,1,98,1,98,1,98,1,99,1,99,1,99, + 3,82,1663,8,82,1,83,1,83,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1673,8,84, + 1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84, + 1,84,1,84,3,84,1691,8,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84, + 1,84,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1709,8,84,1,85,1,85,1,85,1,85, + 1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,3,85, + 1728,8,85,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86, + 1,86,1,86,1,86,1,86,1,86,1,86,1,86,3,86,1749,8,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,88,1,88,1,88,1,88,1,88,3,88, + 1768,8,88,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89, + 1,89,3,89,1783,8,89,1,90,1,90,1,90,5,90,1788,8,90,10,90,12,90,1791,9,90, + 1,90,1,90,1,91,1,91,1,91,1,91,1,91,3,91,1800,8,91,1,92,1,92,1,92,1,92, + 1,92,1,92,1,92,1,92,1,92,1,92,1,92,3,92,1813,8,92,1,93,5,93,1816,8,93, + 10,93,12,93,1819,9,93,1,94,1,94,3,94,1823,8,94,1,94,1,94,1,95,1,95,1,95, + 5,95,1830,8,95,10,95,12,95,1833,9,95,1,95,1,95,1,96,1,96,1,96,1,96,1,97, + 3,97,1842,8,97,1,97,1,97,1,98,1,98,1,98,1,98,1,98,1,98,1,98,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, - 5,99,1786,8,99,10,99,12,99,1789,9,99,1,99,1,99,1,99,1,99,5,99,1795,8,99, - 10,99,12,99,1798,9,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,1808, - 8,99,10,99,12,99,1811,9,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,1819,8,99, - 10,99,12,99,1822,9,99,1,99,1,99,1,99,1,99,1,99,3,99,1829,8,99,1,100,1, - 100,1,100,1,100,1,100,1,100,1,100,1,100,5,100,1839,8,100,10,100,12,100, - 1842,9,100,1,100,1,100,1,100,1,100,1,100,1,101,1,101,1,101,1,101,1,101, + 1,99,5,99,1926,8,99,10,99,12,99,1929,9,99,1,99,1,99,1,99,1,99,5,99,1935, + 8,99,10,99,12,99,1938,9,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99, + 1948,8,99,10,99,12,99,1951,9,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,1959, + 8,99,10,99,12,99,1962,9,99,1,99,1,99,1,99,1,99,1,99,3,99,1969,8,99,1,100, + 1,100,1,100,1,100,1,100,1,100,1,100,1,100,5,100,1979,8,100,10,100,12,100, + 1982,9,100,1,100,1,100,1,100,1,100,1,100,1,101,1,101,1,101,1,101,1,101, 1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101, - 1,101,1,101,3,101,1868,8,101,1,102,1,102,1,102,1,102,1,102,3,102,1875, - 8,102,1,103,1,103,1,103,3,103,1880,8,103,1,104,1,104,1,104,1,104,1,104, - 3,104,1887,8,104,1,105,1,105,5,105,1891,8,105,10,105,12,105,1894,9,105, - 1,105,1,105,1,105,1,105,1,105,5,105,1901,8,105,10,105,12,105,1904,9,105, - 1,105,3,105,1907,8,105,1,106,1,106,1,107,5,107,1912,8,107,10,107,12,107, - 1915,9,107,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108, - 1,108,1,108,3,108,1929,8,108,1,109,1,109,5,109,1933,8,109,10,109,12,109, - 1936,9,109,1,109,1,109,1,109,1,109,1,109,1,109,1,110,1,110,1,111,5,111, - 1947,8,111,10,111,12,111,1950,9,111,1,112,1,112,1,112,1,112,1,112,1,112, - 1,112,1,112,1,112,1,112,3,112,1962,8,112,1,113,1,113,1,113,1,113,1,113, - 1,113,3,113,1970,8,113,1,114,1,114,1,114,4,114,1975,8,114,11,114,12,114, - 1976,1,114,1,114,3,114,1981,8,114,1,115,5,115,1984,8,115,10,115,12,115, - 1987,9,115,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116, - 1,116,1,116,1,116,3,116,2002,8,116,1,117,1,117,1,117,5,117,2007,8,117, - 10,117,12,117,2010,9,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117, - 5,117,2020,8,117,10,117,12,117,2023,9,117,1,118,1,118,1,118,1,118,1,118, + 1,101,1,101,3,101,2008,8,101,1,102,1,102,1,102,1,102,1,102,3,102,2015, + 8,102,1,103,1,103,1,103,3,103,2020,8,103,1,104,1,104,1,104,1,104,1,104, + 3,104,2027,8,104,1,105,1,105,5,105,2031,8,105,10,105,12,105,2034,9,105, + 1,105,1,105,1,105,1,105,1,105,5,105,2041,8,105,10,105,12,105,2044,9,105, + 1,105,3,105,2047,8,105,1,106,1,106,1,107,5,107,2052,8,107,10,107,12,107, + 2055,9,107,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108, + 1,108,1,108,3,108,2069,8,108,1,109,1,109,5,109,2073,8,109,10,109,12,109, + 2076,9,109,1,109,1,109,1,109,1,109,1,109,1,109,1,110,1,110,1,111,5,111, + 2087,8,111,10,111,12,111,2090,9,111,1,112,1,112,1,112,1,112,1,112,1,112, + 1,112,1,112,1,112,1,112,3,112,2102,8,112,1,113,1,113,1,113,1,113,1,113, + 1,113,3,113,2110,8,113,1,114,1,114,1,114,4,114,2115,8,114,11,114,12,114, + 2116,1,114,1,114,3,114,2121,8,114,1,115,1,115,1,115,5,115,2126,8,115,10, + 115,12,115,2129,9,115,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116, + 1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,3,116,2148,8,116, + 1,117,1,117,1,117,5,117,2153,8,117,10,117,12,117,2156,9,117,1,117,1,117, + 1,117,1,117,1,117,1,117,1,117,1,117,5,117,2166,8,117,10,117,12,117,2169, + 9,117,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, - 1,118,1,118,1,118,1,118,1,118,1,118,3,118,2048,8,118,1,119,1,119,1,119, - 1,119,1,119,3,119,2055,8,119,3,119,2057,8,119,1,119,5,119,2060,8,119,10, - 119,12,119,2063,9,119,1,119,1,119,1,119,3,119,2068,8,119,1,120,1,120,1, - 120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, + 3,118,2194,8,118,1,119,1,119,1,119,1,119,1,119,3,119,2201,8,119,3,119, + 2203,8,119,1,119,5,119,2206,8,119,10,119,12,119,2209,9,119,1,119,1,119, + 1,119,3,119,2214,8,119,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, - 1,120,3,120,2097,8,120,1,121,1,121,1,121,3,121,2102,8,121,1,122,1,122, + 1,120,1,120,1,120,1,120,1,120,1,120,1,120,3,120,2243,8,120,1,121,1,121, + 1,121,1,121,1,121,1,121,1,121,3,121,2252,8,121,1,122,1,122,1,122,1,122, 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, - 1,122,1,122,1,122,1,122,1,122,1,122,1,122,3,122,2125,8,122,1,123,5,123, - 2128,8,123,10,123,12,123,2131,9,123,1,124,1,124,1,124,1,124,1,124,1,124, - 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,3,124, - 2150,8,124,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, + 1,122,1,122,1,122,1,122,1,122,3,122,2275,8,122,1,123,5,123,2278,8,123, + 10,123,12,123,2281,9,123,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, + 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,3,124,2300,8,124, 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, - 1,125,1,125,1,125,5,125,2201,8,125,10,125,12,125,2204,9,125,1,125,1,125, - 1,125,1,125,5,125,2210,8,125,10,125,12,125,2213,9,125,1,125,1,125,1,125, - 1,125,1,125,1,125,1,125,1,125,5,125,2223,8,125,10,125,12,125,2226,9,125, - 1,125,1,125,1,125,1,125,1,125,1,125,5,125,2234,8,125,10,125,12,125,2237, - 9,125,1,125,1,125,1,125,1,125,1,125,1,125,5,125,2245,8,125,10,125,12,125, - 2248,9,125,3,125,2250,8,125,1,126,1,126,1,126,1,126,1,127,1,127,3,127, - 2258,8,127,1,128,1,128,1,128,1,128,1,129,1,129,1,129,1,130,4,130,2268, - 8,130,11,130,12,130,2269,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131, - 1,131,1,131,1,131,1,131,3,131,2284,8,131,1,132,1,132,1,132,1,132,1,132, - 1,132,1,132,1,132,1,132,1,132,1,132,1,132,3,132,2298,8,132,1,133,1,133, - 1,133,1,133,1,133,1,133,3,133,2306,8,133,1,134,1,134,1,134,1,135,1,135, - 1,136,1,136,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137, - 1,137,3,137,2326,8,137,1,138,1,138,1,138,1,139,1,139,1,139,1,139,1,139, - 1,139,1,139,3,139,2338,8,139,1,140,1,140,1,140,3,140,2343,8,140,1,141, - 1,141,1,141,1,141,1,141,4,141,2350,8,141,11,141,12,141,2351,3,141,2354, - 8,141,1,142,1,142,1,142,5,142,2359,8,142,10,142,12,142,2362,9,142,1,142, - 1,142,1,143,1,143,1,143,1,143,1,143,3,143,2371,8,143,1,144,1,144,1,144, + 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, + 1,125,5,125,2351,8,125,10,125,12,125,2354,9,125,1,125,1,125,1,125,1,125, + 5,125,2360,8,125,10,125,12,125,2363,9,125,1,125,1,125,1,125,1,125,1,125, + 1,125,1,125,1,125,5,125,2373,8,125,10,125,12,125,2376,9,125,1,125,1,125, + 1,125,1,125,1,125,1,125,5,125,2384,8,125,10,125,12,125,2387,9,125,1,125, + 1,125,1,125,1,125,1,125,1,125,5,125,2395,8,125,10,125,12,125,2398,9,125, + 3,125,2400,8,125,1,126,1,126,1,126,1,126,1,127,1,127,3,127,2408,8,127, + 1,128,1,128,1,128,1,128,1,129,1,129,1,129,1,130,4,130,2418,8,130,11,130, + 12,130,2419,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131, + 1,131,1,131,3,131,2434,8,131,1,132,1,132,1,132,1,132,1,132,1,132,1,132, + 1,132,1,132,1,132,1,132,1,132,3,132,2448,8,132,1,133,1,133,1,133,1,133, + 1,133,1,133,3,133,2456,8,133,1,134,1,134,1,134,1,135,1,135,1,136,1,136, + 1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,3,137, + 2476,8,137,1,138,1,138,1,138,1,139,1,139,1,139,1,139,1,139,1,139,1,139, + 3,139,2488,8,139,1,140,1,140,1,140,3,140,2493,8,140,1,141,1,141,1,141, + 1,141,1,141,4,141,2500,8,141,11,141,12,141,2501,3,141,2504,8,141,1,142, + 1,142,1,142,5,142,2509,8,142,10,142,12,142,2512,9,142,1,142,1,142,1,143, + 1,143,1,143,1,143,1,143,3,143,2521,8,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,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,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,2439,8,144,1,145,1,145,1,145,1,145,1,145,1,145, + 1,144,3,144,2589,8,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,145,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,145,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,145,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,145,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,145,1,145,1,145,1,145, - 1,145,1,145,1,145,1,145,1,145,1,145,1,145,1,145,1,145,3,145,2516,8,145, - 1,146,1,146,1,146,5,146,2521,8,146,10,146,12,146,2524,9,146,1,147,1,147, - 1,148,1,148,1,148,3,148,2531,8,148,1,149,1,149,1,149,1,149,1,149,1,149, + 1,145,1,145,1,145,1,145,1,145,1,145,1,145,3,145,2666,8,145,1,146,1,146, + 1,146,5,146,2671,8,146,10,146,12,146,2674,9,146,1,147,1,147,1,148,1,148, + 1,148,3,148,2681,8,148,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, @@ -17117,918 +17375,959 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, - 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,3,149,2681, - 8,149,1,150,1,150,5,150,2685,8,150,10,150,12,150,2688,9,150,1,151,1,151, - 5,151,2692,8,151,10,151,12,151,2695,9,151,1,152,5,152,2698,8,152,10,152, - 12,152,2701,9,152,1,153,5,153,2704,8,153,10,153,12,153,2707,9,153,1,154, - 5,154,2710,8,154,10,154,12,154,2713,9,154,1,155,5,155,2716,8,155,10,155, - 12,155,2719,9,155,1,156,5,156,2722,8,156,10,156,12,156,2725,9,156,1,157, - 5,157,2728,8,157,10,157,12,157,2731,9,157,1,158,5,158,2734,8,158,10,158, - 12,158,2737,9,158,1,159,1,159,1,159,1,159,3,159,2743,8,159,1,160,5,160, - 2746,8,160,10,160,12,160,2749,9,160,1,161,1,161,1,161,3,161,2754,8,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,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,3,149,2831,8,149,1,150, + 1,150,5,150,2835,8,150,10,150,12,150,2838,9,150,1,151,1,151,5,151,2842, + 8,151,10,151,12,151,2845,9,151,1,152,5,152,2848,8,152,10,152,12,152,2851, + 9,152,1,153,5,153,2854,8,153,10,153,12,153,2857,9,153,1,154,5,154,2860, + 8,154,10,154,12,154,2863,9,154,1,155,5,155,2866,8,155,10,155,12,155,2869, + 9,155,1,156,5,156,2872,8,156,10,156,12,156,2875,9,156,1,157,5,157,2878, + 8,157,10,157,12,157,2881,9,157,1,158,5,158,2884,8,158,10,158,12,158,2887, + 9,158,1,159,1,159,1,159,1,159,3,159,2893,8,159,1,160,5,160,2896,8,160, + 10,160,12,160,2899,9,160,1,161,1,161,1,161,3,161,2904,8,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,162,1,162, - 1,162,3,162,2781,8,162,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163, - 1,163,1,163,1,163,1,163,3,163,2795,8,163,1,164,5,164,2798,8,164,10,164, - 12,164,2801,9,164,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165, - 1,165,1,165,1,165,1,165,1,165,3,165,2817,8,165,1,166,1,166,1,166,5,166, - 2822,8,166,10,166,12,166,2825,9,166,1,166,1,166,1,167,1,167,5,167,2831, - 8,167,10,167,12,167,2834,9,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,168,1,168,1,168,1,168,3,168,2853, - 8,168,1,169,5,169,2856,8,169,10,169,12,169,2859,9,169,1,170,1,170,1,170, - 1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,3,170,2874, - 8,170,1,171,1,171,5,171,2878,8,171,10,171,12,171,2881,9,171,1,171,1,171, - 1,171,5,171,2886,8,171,10,171,12,171,2889,9,171,1,171,1,171,1,171,1,171, - 3,171,2895,8,171,1,172,1,172,1,173,5,173,2900,8,173,10,173,12,173,2903, - 9,173,1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,3,174, - 2915,8,174,1,174,0,1,68,175,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,0,16,6,0,1,15,199,199,243,243,247,247,264, - 264,289,289,5,0,16,16,199,199,243,243,264,264,288,289,1,0,263,264,1,0, - 173,174,1,0,37,38,1,0,73,74,3,0,2,2,61,61,77,83,2,0,229,229,260,261,9, - 0,178,178,183,195,201,201,207,208,210,215,218,219,222,222,230,242,262, - 262,1,0,95,96,1,0,97,111,1,0,68,69,2,0,173,173,289,290,2,0,179,179,264, - 264,1,0,167,168,1,0,51,52,3344,0,350,1,0,0,0,2,363,1,0,0,0,4,365,1,0,0, - 0,6,372,1,0,0,0,8,381,1,0,0,0,10,434,1,0,0,0,12,436,1,0,0,0,14,439,1,0, - 0,0,16,442,1,0,0,0,18,446,1,0,0,0,20,449,1,0,0,0,22,452,1,0,0,0,24,459, - 1,0,0,0,26,475,1,0,0,0,28,477,1,0,0,0,30,479,1,0,0,0,32,489,1,0,0,0,34, - 491,1,0,0,0,36,514,1,0,0,0,38,518,1,0,0,0,40,536,1,0,0,0,42,563,1,0,0, - 0,44,586,1,0,0,0,46,622,1,0,0,0,48,624,1,0,0,0,50,628,1,0,0,0,52,630,1, - 0,0,0,54,637,1,0,0,0,56,649,1,0,0,0,58,652,1,0,0,0,60,654,1,0,0,0,62,667, - 1,0,0,0,64,675,1,0,0,0,66,677,1,0,0,0,68,685,1,0,0,0,70,701,1,0,0,0,72, - 707,1,0,0,0,74,710,1,0,0,0,76,759,1,0,0,0,78,764,1,0,0,0,80,769,1,0,0, - 0,82,774,1,0,0,0,84,782,1,0,0,0,86,787,1,0,0,0,88,892,1,0,0,0,90,920,1, - 0,0,0,92,922,1,0,0,0,94,926,1,0,0,0,96,928,1,0,0,0,98,933,1,0,0,0,100, - 961,1,0,0,0,102,1041,1,0,0,0,104,1043,1,0,0,0,106,1071,1,0,0,0,108,1073, - 1,0,0,0,110,1085,1,0,0,0,112,1110,1,0,0,0,114,1119,1,0,0,0,116,1146,1, - 0,0,0,118,1153,1,0,0,0,120,1161,1,0,0,0,122,1169,1,0,0,0,124,1182,1,0, - 0,0,126,1192,1,0,0,0,128,1211,1,0,0,0,130,1305,1,0,0,0,132,1314,1,0,0, - 0,134,1324,1,0,0,0,136,1326,1,0,0,0,138,1328,1,0,0,0,140,1353,1,0,0,0, - 142,1385,1,0,0,0,144,1408,1,0,0,0,146,1420,1,0,0,0,148,1422,1,0,0,0,150, - 1425,1,0,0,0,152,1478,1,0,0,0,154,1490,1,0,0,0,156,1505,1,0,0,0,158,1512, - 1,0,0,0,160,1517,1,0,0,0,162,1521,1,0,0,0,164,1557,1,0,0,0,166,1559,1, - 0,0,0,168,1595,1,0,0,0,170,1607,1,0,0,0,172,1621,1,0,0,0,174,1623,1,0, - 0,0,176,1633,1,0,0,0,178,1644,1,0,0,0,180,1651,1,0,0,0,182,1661,1,0,0, - 0,184,1674,1,0,0,0,186,1679,1,0,0,0,188,1682,1,0,0,0,190,1693,1,0,0,0, - 192,1698,1,0,0,0,194,1704,1,0,0,0,196,1706,1,0,0,0,198,1828,1,0,0,0,200, - 1830,1,0,0,0,202,1867,1,0,0,0,204,1874,1,0,0,0,206,1879,1,0,0,0,208,1886, - 1,0,0,0,210,1906,1,0,0,0,212,1908,1,0,0,0,214,1913,1,0,0,0,216,1928,1, - 0,0,0,218,1930,1,0,0,0,220,1943,1,0,0,0,222,1948,1,0,0,0,224,1961,1,0, - 0,0,226,1969,1,0,0,0,228,1980,1,0,0,0,230,1985,1,0,0,0,232,2001,1,0,0, - 0,234,2003,1,0,0,0,236,2047,1,0,0,0,238,2067,1,0,0,0,240,2096,1,0,0,0, - 242,2101,1,0,0,0,244,2124,1,0,0,0,246,2129,1,0,0,0,248,2149,1,0,0,0,250, - 2249,1,0,0,0,252,2251,1,0,0,0,254,2257,1,0,0,0,256,2259,1,0,0,0,258,2263, - 1,0,0,0,260,2267,1,0,0,0,262,2283,1,0,0,0,264,2297,1,0,0,0,266,2305,1, - 0,0,0,268,2307,1,0,0,0,270,2310,1,0,0,0,272,2312,1,0,0,0,274,2325,1,0, - 0,0,276,2327,1,0,0,0,278,2337,1,0,0,0,280,2342,1,0,0,0,282,2353,1,0,0, - 0,284,2360,1,0,0,0,286,2370,1,0,0,0,288,2438,1,0,0,0,290,2515,1,0,0,0, - 292,2522,1,0,0,0,294,2525,1,0,0,0,296,2530,1,0,0,0,298,2680,1,0,0,0,300, - 2686,1,0,0,0,302,2693,1,0,0,0,304,2699,1,0,0,0,306,2705,1,0,0,0,308,2711, - 1,0,0,0,310,2717,1,0,0,0,312,2723,1,0,0,0,314,2729,1,0,0,0,316,2735,1, - 0,0,0,318,2742,1,0,0,0,320,2747,1,0,0,0,322,2753,1,0,0,0,324,2780,1,0, - 0,0,326,2794,1,0,0,0,328,2799,1,0,0,0,330,2816,1,0,0,0,332,2818,1,0,0, - 0,334,2828,1,0,0,0,336,2852,1,0,0,0,338,2857,1,0,0,0,340,2873,1,0,0,0, - 342,2894,1,0,0,0,344,2896,1,0,0,0,346,2901,1,0,0,0,348,2914,1,0,0,0,350, - 351,7,0,0,0,351,1,1,0,0,0,352,364,5,288,0,0,353,354,3,4,2,0,354,355,5, - 265,0,0,355,357,1,0,0,0,356,353,1,0,0,0,357,360,1,0,0,0,358,356,1,0,0, - 0,358,359,1,0,0,0,359,361,1,0,0,0,360,358,1,0,0,0,361,364,3,4,2,0,362, - 364,5,264,0,0,363,352,1,0,0,0,363,358,1,0,0,0,363,362,1,0,0,0,364,3,1, - 0,0,0,365,366,7,1,0,0,366,5,1,0,0,0,367,368,5,263,0,0,368,369,6,3,-1,0, - 369,371,5,266,0,0,370,367,1,0,0,0,371,374,1,0,0,0,372,370,1,0,0,0,372, - 373,1,0,0,0,373,375,1,0,0,0,374,372,1,0,0,0,375,376,5,263,0,0,376,377, - 6,3,-1,0,377,7,1,0,0,0,378,380,3,10,5,0,379,378,1,0,0,0,380,383,1,0,0, - 0,381,379,1,0,0,0,381,382,1,0,0,0,382,9,1,0,0,0,383,381,1,0,0,0,384,385, - 3,74,37,0,385,386,5,17,0,0,386,387,3,82,41,0,387,388,5,18,0,0,388,435, - 1,0,0,0,389,390,3,72,36,0,390,391,5,17,0,0,391,392,3,8,4,0,392,393,5,18, - 0,0,393,435,1,0,0,0,394,395,3,234,117,0,395,396,5,17,0,0,396,397,3,246, - 123,0,397,398,5,18,0,0,398,435,1,0,0,0,399,435,3,200,100,0,400,435,3,276, - 138,0,401,435,3,70,35,0,402,435,3,66,33,0,403,435,3,88,44,0,404,435,3, - 90,45,0,405,435,3,22,11,0,406,407,3,326,163,0,407,408,5,17,0,0,408,409, - 3,328,164,0,409,410,5,18,0,0,410,435,1,0,0,0,411,412,3,332,166,0,412,413, - 5,17,0,0,413,414,3,338,169,0,414,415,5,18,0,0,415,435,1,0,0,0,416,417, - 3,342,171,0,417,418,5,17,0,0,418,419,3,346,173,0,419,420,5,18,0,0,420, - 435,1,0,0,0,421,435,3,64,32,0,422,435,3,152,76,0,423,435,3,322,161,0,424, - 435,3,12,6,0,425,435,3,14,7,0,426,435,3,16,8,0,427,435,3,18,9,0,428,435, - 3,20,10,0,429,435,3,26,13,0,430,435,3,42,21,0,431,435,3,40,20,0,432,435, - 3,30,15,0,433,435,3,24,12,0,434,384,1,0,0,0,434,389,1,0,0,0,434,394,1, - 0,0,0,434,399,1,0,0,0,434,400,1,0,0,0,434,401,1,0,0,0,434,402,1,0,0,0, - 434,403,1,0,0,0,434,404,1,0,0,0,434,405,1,0,0,0,434,406,1,0,0,0,434,411, - 1,0,0,0,434,416,1,0,0,0,434,421,1,0,0,0,434,422,1,0,0,0,434,423,1,0,0, - 0,434,424,1,0,0,0,434,425,1,0,0,0,434,426,1,0,0,0,434,427,1,0,0,0,434, - 428,1,0,0,0,434,429,1,0,0,0,434,430,1,0,0,0,434,431,1,0,0,0,434,432,1, - 0,0,0,434,433,1,0,0,0,435,11,1,0,0,0,436,437,5,19,0,0,437,438,3,32,16, - 0,438,13,1,0,0,0,439,440,5,20,0,0,440,441,3,32,16,0,441,15,1,0,0,0,442, - 443,5,21,0,0,443,444,5,22,0,0,444,445,3,32,16,0,445,17,1,0,0,0,446,447, - 5,23,0,0,447,448,3,34,17,0,448,19,1,0,0,0,449,450,5,24,0,0,450,451,3,34, - 17,0,451,21,1,0,0,0,452,453,5,25,0,0,453,454,3,98,49,0,454,455,3,2,1,0, - 455,456,5,17,0,0,456,457,3,120,60,0,457,458,5,18,0,0,458,23,1,0,0,0,459, - 460,5,26,0,0,460,25,1,0,0,0,461,462,5,27,0,0,462,476,3,28,14,0,463,464, - 5,27,0,0,464,465,3,28,14,0,465,466,5,28,0,0,466,467,3,28,14,0,467,476, - 1,0,0,0,468,469,5,27,0,0,469,470,3,28,14,0,470,471,5,28,0,0,471,472,3, - 28,14,0,472,473,5,28,0,0,473,474,3,28,14,0,474,476,1,0,0,0,475,461,1,0, - 0,0,475,463,1,0,0,0,475,468,1,0,0,0,476,27,1,0,0,0,477,478,7,2,0,0,478, - 29,1,0,0,0,479,480,5,29,0,0,480,484,5,17,0,0,481,483,3,116,58,0,482,481, - 1,0,0,0,483,486,1,0,0,0,484,482,1,0,0,0,484,485,1,0,0,0,485,487,1,0,0, - 0,486,484,1,0,0,0,487,488,5,18,0,0,488,31,1,0,0,0,489,490,5,173,0,0,490, - 33,1,0,0,0,491,492,7,3,0,0,492,35,1,0,0,0,493,494,5,175,0,0,494,515,6, - 18,-1,0,495,496,3,32,16,0,496,497,5,265,0,0,497,498,6,18,-1,0,498,515, - 1,0,0,0,499,500,3,32,16,0,500,501,6,18,-1,0,501,515,1,0,0,0,502,503,5, - 188,0,0,503,504,5,30,0,0,504,505,3,32,16,0,505,506,5,31,0,0,506,507,6, - 18,-1,0,507,515,1,0,0,0,508,509,5,189,0,0,509,510,5,30,0,0,510,511,3,34, - 17,0,511,512,5,31,0,0,512,513,6,18,-1,0,513,515,1,0,0,0,514,493,1,0,0, - 0,514,495,1,0,0,0,514,499,1,0,0,0,514,502,1,0,0,0,514,508,1,0,0,0,515, - 37,1,0,0,0,516,519,3,32,16,0,517,519,5,262,0,0,518,516,1,0,0,0,518,517, - 1,0,0,0,519,39,1,0,0,0,520,521,5,267,0,0,521,537,5,289,0,0,522,523,5,267, - 0,0,523,524,5,289,0,0,524,537,5,263,0,0,525,526,5,268,0,0,526,537,5,289, - 0,0,527,528,5,269,0,0,528,537,5,289,0,0,529,530,5,270,0,0,530,537,5,289, - 0,0,531,537,5,271,0,0,532,537,5,272,0,0,533,534,5,273,0,0,534,537,5,263, - 0,0,535,537,5,32,0,0,536,520,1,0,0,0,536,522,1,0,0,0,536,525,1,0,0,0,536, - 527,1,0,0,0,536,529,1,0,0,0,536,531,1,0,0,0,536,532,1,0,0,0,536,533,1, - 0,0,0,536,535,1,0,0,0,537,41,1,0,0,0,538,539,5,33,0,0,539,540,3,138,69, - 0,540,541,5,34,0,0,541,542,3,2,1,0,542,564,1,0,0,0,543,544,5,33,0,0,544, - 545,3,116,58,0,545,546,5,34,0,0,546,547,3,2,1,0,547,564,1,0,0,0,548,549, - 5,33,0,0,549,550,3,176,88,0,550,551,5,34,0,0,551,552,3,2,1,0,552,564,1, - 0,0,0,553,554,5,33,0,0,554,555,3,44,22,0,555,556,5,34,0,0,556,557,3,2, - 1,0,557,564,1,0,0,0,558,559,5,33,0,0,559,560,3,46,23,0,560,561,5,34,0, - 0,561,562,3,2,1,0,562,564,1,0,0,0,563,538,1,0,0,0,563,543,1,0,0,0,563, - 548,1,0,0,0,563,553,1,0,0,0,563,558,1,0,0,0,564,43,1,0,0,0,565,566,5,35, - 0,0,566,587,3,48,24,0,567,568,5,35,0,0,568,569,3,48,24,0,569,570,5,36, - 0,0,570,571,3,6,3,0,571,587,1,0,0,0,572,573,5,35,0,0,573,574,3,48,24,0, - 574,575,5,36,0,0,575,576,5,17,0,0,576,577,3,52,26,0,577,578,5,18,0,0,578, - 587,1,0,0,0,579,580,5,35,0,0,580,581,3,48,24,0,581,582,5,36,0,0,582,583, - 5,30,0,0,583,584,3,292,146,0,584,585,5,31,0,0,585,587,1,0,0,0,586,565, - 1,0,0,0,586,567,1,0,0,0,586,572,1,0,0,0,586,579,1,0,0,0,587,45,1,0,0,0, - 588,589,5,35,0,0,589,590,5,30,0,0,590,591,3,50,25,0,591,592,5,31,0,0,592, - 593,3,48,24,0,593,623,1,0,0,0,594,595,5,35,0,0,595,596,5,30,0,0,596,597, - 3,50,25,0,597,598,5,31,0,0,598,599,3,48,24,0,599,600,5,36,0,0,600,601, - 3,6,3,0,601,623,1,0,0,0,602,603,5,35,0,0,603,604,5,30,0,0,604,605,3,50, - 25,0,605,606,5,31,0,0,606,607,3,48,24,0,607,608,5,36,0,0,608,609,5,17, - 0,0,609,610,3,52,26,0,610,611,5,18,0,0,611,623,1,0,0,0,612,613,5,35,0, - 0,613,614,5,30,0,0,614,615,3,50,25,0,615,616,5,31,0,0,616,617,3,48,24, - 0,617,618,5,36,0,0,618,619,5,30,0,0,619,620,3,292,146,0,620,621,5,31,0, - 0,621,623,1,0,0,0,622,588,1,0,0,0,622,594,1,0,0,0,622,602,1,0,0,0,622, - 612,1,0,0,0,623,47,1,0,0,0,624,625,3,168,84,0,625,49,1,0,0,0,626,629,3, - 124,62,0,627,629,3,176,88,0,628,626,1,0,0,0,628,627,1,0,0,0,629,51,1,0, - 0,0,630,631,3,54,27,0,631,632,3,56,28,0,632,53,1,0,0,0,633,636,3,298,149, - 0,634,636,3,40,20,0,635,633,1,0,0,0,635,634,1,0,0,0,636,639,1,0,0,0,637, - 635,1,0,0,0,637,638,1,0,0,0,638,55,1,0,0,0,639,637,1,0,0,0,640,641,3,58, - 29,0,641,642,3,60,30,0,642,643,3,2,1,0,643,644,5,36,0,0,644,645,3,298, - 149,0,645,648,1,0,0,0,646,648,3,40,20,0,647,640,1,0,0,0,647,646,1,0,0, - 0,648,651,1,0,0,0,649,647,1,0,0,0,649,650,1,0,0,0,650,57,1,0,0,0,651,649, - 1,0,0,0,652,653,7,4,0,0,653,59,1,0,0,0,654,656,3,62,31,0,655,657,5,261, - 0,0,656,655,1,0,0,0,656,657,1,0,0,0,657,61,1,0,0,0,658,668,3,144,72,0, - 659,668,3,2,1,0,660,668,5,196,0,0,661,668,5,197,0,0,662,663,5,202,0,0, - 663,664,5,39,0,0,664,668,5,264,0,0,665,666,5,202,0,0,666,668,3,116,58, - 0,667,658,1,0,0,0,667,659,1,0,0,0,667,660,1,0,0,0,667,661,1,0,0,0,667, - 662,1,0,0,0,667,665,1,0,0,0,668,63,1,0,0,0,669,670,5,198,0,0,670,671,5, - 40,0,0,671,676,3,2,1,0,672,673,5,198,0,0,673,676,3,2,1,0,674,676,5,198, - 0,0,675,669,1,0,0,0,675,672,1,0,0,0,675,674,1,0,0,0,676,65,1,0,0,0,677, - 678,5,41,0,0,678,679,5,42,0,0,679,680,3,32,16,0,680,681,5,43,0,0,681,682, - 3,68,34,0,682,683,5,44,0,0,683,684,3,0,0,0,684,67,1,0,0,0,685,698,6,34, - -1,0,686,687,10,5,0,0,687,697,5,186,0,0,688,689,10,4,0,0,689,697,5,187, - 0,0,690,691,10,3,0,0,691,697,5,45,0,0,692,693,10,2,0,0,693,697,5,46,0, - 0,694,695,10,1,0,0,695,697,5,47,0,0,696,686,1,0,0,0,696,688,1,0,0,0,696, - 690,1,0,0,0,696,692,1,0,0,0,696,694,1,0,0,0,697,700,1,0,0,0,698,696,1, - 0,0,0,698,699,1,0,0,0,699,69,1,0,0,0,700,698,1,0,0,0,701,702,5,48,0,0, - 702,703,5,36,0,0,703,704,5,30,0,0,704,705,3,292,146,0,705,706,5,31,0,0, - 706,71,1,0,0,0,707,708,5,49,0,0,708,709,3,2,1,0,709,73,1,0,0,0,710,714, - 5,50,0,0,711,713,3,76,38,0,712,711,1,0,0,0,713,716,1,0,0,0,714,712,1,0, - 0,0,714,715,1,0,0,0,715,717,1,0,0,0,716,714,1,0,0,0,717,718,3,2,1,0,718, - 719,3,182,91,0,719,720,3,78,39,0,720,721,3,80,40,0,721,75,1,0,0,0,722, - 760,5,51,0,0,723,760,5,52,0,0,724,760,5,199,0,0,725,760,5,202,0,0,726, - 760,5,221,0,0,727,760,5,53,0,0,728,760,5,54,0,0,729,760,5,55,0,0,730,760, - 5,56,0,0,731,760,5,244,0,0,732,760,5,15,0,0,733,760,5,224,0,0,734,760, - 5,57,0,0,735,760,5,58,0,0,736,760,5,59,0,0,737,760,5,60,0,0,738,760,5, - 61,0,0,739,740,5,62,0,0,740,760,5,51,0,0,741,742,5,62,0,0,742,760,5,52, - 0,0,743,744,5,62,0,0,744,760,5,63,0,0,745,746,5,62,0,0,746,760,5,64,0, - 0,747,748,5,62,0,0,748,760,5,65,0,0,749,750,5,62,0,0,750,760,5,66,0,0, - 751,760,5,67,0,0,752,760,5,68,0,0,753,760,5,69,0,0,754,755,5,70,0,0,755, - 756,5,30,0,0,756,757,3,32,16,0,757,758,5,31,0,0,758,760,1,0,0,0,759,722, - 1,0,0,0,759,723,1,0,0,0,759,724,1,0,0,0,759,725,1,0,0,0,759,726,1,0,0, - 0,759,727,1,0,0,0,759,728,1,0,0,0,759,729,1,0,0,0,759,730,1,0,0,0,759, - 731,1,0,0,0,759,732,1,0,0,0,759,733,1,0,0,0,759,734,1,0,0,0,759,735,1, - 0,0,0,759,736,1,0,0,0,759,737,1,0,0,0,759,738,1,0,0,0,759,739,1,0,0,0, - 759,741,1,0,0,0,759,743,1,0,0,0,759,745,1,0,0,0,759,747,1,0,0,0,759,749, - 1,0,0,0,759,751,1,0,0,0,759,752,1,0,0,0,759,753,1,0,0,0,759,754,1,0,0, - 0,760,77,1,0,0,0,761,765,1,0,0,0,762,763,5,71,0,0,763,765,3,124,62,0,764, - 761,1,0,0,0,764,762,1,0,0,0,765,79,1,0,0,0,766,770,1,0,0,0,767,768,5,72, - 0,0,768,770,3,84,42,0,769,766,1,0,0,0,769,767,1,0,0,0,770,81,1,0,0,0,771, - 773,3,198,99,0,772,771,1,0,0,0,773,776,1,0,0,0,774,772,1,0,0,0,774,775, - 1,0,0,0,775,83,1,0,0,0,776,774,1,0,0,0,777,778,3,124,62,0,778,779,5,28, - 0,0,779,781,1,0,0,0,780,777,1,0,0,0,781,784,1,0,0,0,782,780,1,0,0,0,782, - 783,1,0,0,0,783,785,1,0,0,0,784,782,1,0,0,0,785,786,3,124,62,0,786,85, - 1,0,0,0,787,788,7,5,0,0,788,87,1,0,0,0,789,790,3,86,43,0,790,791,3,32, - 16,0,791,792,5,264,0,0,792,893,1,0,0,0,793,794,3,86,43,0,794,795,3,32, - 16,0,795,893,1,0,0,0,796,797,3,86,43,0,797,798,3,32,16,0,798,799,5,75, - 0,0,799,800,3,32,16,0,800,801,5,264,0,0,801,893,1,0,0,0,802,803,3,86,43, - 0,803,804,3,32,16,0,804,805,5,75,0,0,805,806,3,32,16,0,806,893,1,0,0,0, - 807,808,3,86,43,0,808,809,3,32,16,0,809,810,5,75,0,0,810,811,3,32,16,0, - 811,812,5,28,0,0,812,813,3,32,16,0,813,814,5,264,0,0,814,893,1,0,0,0,815, - 816,3,86,43,0,816,817,3,32,16,0,817,818,5,75,0,0,818,819,3,32,16,0,819, - 820,5,28,0,0,820,821,3,32,16,0,821,893,1,0,0,0,822,823,3,86,43,0,823,824, - 3,32,16,0,824,825,5,28,0,0,825,826,3,32,16,0,826,827,5,75,0,0,827,828, - 3,32,16,0,828,829,5,264,0,0,829,893,1,0,0,0,830,831,3,86,43,0,831,832, - 3,32,16,0,832,833,5,28,0,0,833,834,3,32,16,0,834,835,5,75,0,0,835,836, - 3,32,16,0,836,893,1,0,0,0,837,838,3,86,43,0,838,839,3,32,16,0,839,840, - 5,28,0,0,840,841,3,32,16,0,841,842,5,75,0,0,842,843,3,32,16,0,843,844, - 5,28,0,0,844,845,3,32,16,0,845,846,5,264,0,0,846,893,1,0,0,0,847,848,3, - 86,43,0,848,849,3,32,16,0,849,850,5,28,0,0,850,851,3,32,16,0,851,852,5, - 75,0,0,852,853,3,32,16,0,853,854,5,28,0,0,854,855,3,32,16,0,855,893,1, - 0,0,0,856,857,3,86,43,0,857,858,3,32,16,0,858,859,5,263,0,0,859,893,1, - 0,0,0,860,861,3,86,43,0,861,862,3,32,16,0,862,863,5,75,0,0,863,864,3,32, - 16,0,864,865,5,263,0,0,865,893,1,0,0,0,866,867,3,86,43,0,867,868,3,32, - 16,0,868,869,5,75,0,0,869,870,3,32,16,0,870,871,5,28,0,0,871,872,3,32, - 16,0,872,873,5,263,0,0,873,893,1,0,0,0,874,875,3,86,43,0,875,876,3,32, - 16,0,876,877,5,28,0,0,877,878,3,32,16,0,878,879,5,75,0,0,879,880,3,32, - 16,0,880,881,5,263,0,0,881,893,1,0,0,0,882,883,3,86,43,0,883,884,3,32, - 16,0,884,885,5,28,0,0,885,886,3,32,16,0,886,887,5,75,0,0,887,888,3,32, - 16,0,888,889,5,28,0,0,889,890,3,32,16,0,890,891,5,263,0,0,891,893,1,0, - 0,0,892,789,1,0,0,0,892,793,1,0,0,0,892,796,1,0,0,0,892,802,1,0,0,0,892, - 807,1,0,0,0,892,815,1,0,0,0,892,822,1,0,0,0,892,830,1,0,0,0,892,837,1, - 0,0,0,892,847,1,0,0,0,892,856,1,0,0,0,892,860,1,0,0,0,892,866,1,0,0,0, - 892,874,1,0,0,0,892,882,1,0,0,0,893,89,1,0,0,0,894,898,5,21,0,0,895,897, - 3,92,46,0,896,895,1,0,0,0,897,900,1,0,0,0,898,896,1,0,0,0,898,899,1,0, - 0,0,899,901,1,0,0,0,900,898,1,0,0,0,901,902,3,2,1,0,902,903,3,94,47,0, - 903,904,5,180,0,0,904,905,5,36,0,0,905,906,5,30,0,0,906,907,3,292,146, - 0,907,908,5,31,0,0,908,909,3,94,47,0,909,921,1,0,0,0,910,914,5,21,0,0, - 911,913,3,92,46,0,912,911,1,0,0,0,913,916,1,0,0,0,914,912,1,0,0,0,914, - 915,1,0,0,0,915,917,1,0,0,0,916,914,1,0,0,0,917,918,3,2,1,0,918,919,3, - 94,47,0,919,921,1,0,0,0,920,894,1,0,0,0,920,910,1,0,0,0,921,91,1,0,0,0, - 922,923,5,76,0,0,923,93,1,0,0,0,924,927,1,0,0,0,925,927,5,298,0,0,926, - 924,1,0,0,0,926,925,1,0,0,0,927,95,1,0,0,0,928,929,7,6,0,0,929,97,1,0, - 0,0,930,932,3,96,48,0,931,930,1,0,0,0,932,935,1,0,0,0,933,931,1,0,0,0, - 933,934,1,0,0,0,934,99,1,0,0,0,935,933,1,0,0,0,936,962,3,102,51,0,937, - 938,5,280,0,0,938,939,3,168,84,0,939,940,6,50,-1,0,940,962,1,0,0,0,941, - 942,5,286,0,0,942,943,3,178,89,0,943,944,6,50,-1,0,944,962,1,0,0,0,945, - 946,5,286,0,0,946,947,3,174,87,0,947,948,6,50,-1,0,948,962,1,0,0,0,949, - 950,5,284,0,0,950,951,3,124,62,0,951,952,6,50,-1,0,952,962,1,0,0,0,953, - 954,5,281,0,0,954,955,3,104,52,0,955,956,6,50,-1,0,956,962,1,0,0,0,957, - 958,5,287,0,0,958,959,3,50,25,0,959,960,6,50,-1,0,960,962,1,0,0,0,961, - 936,1,0,0,0,961,937,1,0,0,0,961,941,1,0,0,0,961,945,1,0,0,0,961,949,1, - 0,0,0,961,953,1,0,0,0,961,957,1,0,0,0,962,101,1,0,0,0,963,964,5,275,0, - 0,964,1042,6,51,-1,0,965,966,5,276,0,0,966,967,3,32,16,0,967,968,6,51, - -1,0,968,1042,1,0,0,0,969,970,5,276,0,0,970,971,3,0,0,0,971,972,6,51,-1, - 0,972,1042,1,0,0,0,973,974,5,277,0,0,974,975,3,32,16,0,975,976,6,51,-1, - 0,976,1042,1,0,0,0,977,978,5,278,0,0,978,979,3,34,17,0,979,980,6,51,-1, - 0,980,1042,1,0,0,0,981,982,5,279,0,0,982,983,3,36,18,0,983,984,6,51,-1, - 0,984,1042,1,0,0,0,985,986,5,279,0,0,986,987,3,34,17,0,987,988,6,51,-1, - 0,988,1042,1,0,0,0,989,990,5,279,0,0,990,991,5,30,0,0,991,992,3,292,146, - 0,992,993,5,31,0,0,993,994,6,51,-1,0,994,1042,1,0,0,0,995,996,5,279,0, - 0,996,997,5,84,0,0,997,998,5,30,0,0,998,999,3,292,146,0,999,1000,5,31, - 0,0,1000,1001,6,51,-1,0,1001,1042,1,0,0,0,1002,1003,5,282,0,0,1003,1004, - 3,32,16,0,1004,1005,6,51,-1,0,1005,1042,1,0,0,0,1006,1007,5,282,0,0,1007, - 1008,3,0,0,0,1008,1009,6,51,-1,0,1009,1042,1,0,0,0,1010,1011,5,285,0,0, - 1011,1012,3,6,3,0,1012,1013,6,51,-1,0,1013,1042,1,0,0,0,1014,1015,5,285, - 0,0,1015,1016,5,224,0,0,1016,1017,5,30,0,0,1017,1018,3,6,3,0,1018,1019, - 5,31,0,0,1019,1020,6,51,-1,0,1020,1042,1,0,0,0,1021,1022,5,285,0,0,1022, - 1023,5,84,0,0,1023,1024,5,30,0,0,1024,1025,3,292,146,0,1025,1026,5,31, - 0,0,1026,1027,6,51,-1,0,1027,1042,1,0,0,0,1028,1029,5,287,0,0,1029,1030, - 3,32,16,0,1030,1031,6,51,-1,0,1031,1042,1,0,0,0,1032,1033,5,283,0,0,1033, - 1039,6,51,-1,0,1034,1035,5,30,0,0,1035,1036,3,106,53,0,1036,1037,5,31, - 0,0,1037,1040,1,0,0,0,1038,1040,5,85,0,0,1039,1034,1,0,0,0,1039,1038,1, - 0,0,0,1040,1042,1,0,0,0,1041,963,1,0,0,0,1041,965,1,0,0,0,1041,969,1,0, - 0,0,1041,973,1,0,0,0,1041,977,1,0,0,0,1041,981,1,0,0,0,1041,985,1,0,0, - 0,1041,989,1,0,0,0,1041,995,1,0,0,0,1041,1002,1,0,0,0,1041,1006,1,0,0, - 0,1041,1010,1,0,0,0,1041,1014,1,0,0,0,1041,1021,1,0,0,0,1041,1028,1,0, - 0,0,1041,1032,1,0,0,0,1042,103,1,0,0,0,1043,1044,3,170,85,0,1044,1045, - 3,138,69,0,1045,1046,3,112,56,0,1046,105,1,0,0,0,1047,1072,1,0,0,0,1048, - 1049,3,0,0,0,1049,1050,6,53,-1,0,1050,1055,1,0,0,0,1051,1052,3,32,16,0, - 1052,1053,6,53,-1,0,1053,1055,1,0,0,0,1054,1048,1,0,0,0,1054,1051,1,0, - 0,0,1055,1056,1,0,0,0,1056,1057,5,28,0,0,1057,1059,1,0,0,0,1058,1054,1, - 0,0,0,1059,1062,1,0,0,0,1060,1058,1,0,0,0,1060,1061,1,0,0,0,1061,1069, - 1,0,0,0,1062,1060,1,0,0,0,1063,1064,3,0,0,0,1064,1065,6,53,-1,0,1065,1070, - 1,0,0,0,1066,1067,3,32,16,0,1067,1068,6,53,-1,0,1068,1070,1,0,0,0,1069, - 1063,1,0,0,0,1069,1066,1,0,0,0,1070,1072,1,0,0,0,1071,1047,1,0,0,0,1071, - 1060,1,0,0,0,1072,107,1,0,0,0,1073,1079,5,86,0,0,1074,1075,3,138,69,0, - 1075,1076,5,28,0,0,1076,1078,1,0,0,0,1077,1074,1,0,0,0,1078,1081,1,0,0, - 0,1079,1077,1,0,0,0,1079,1080,1,0,0,0,1080,1082,1,0,0,0,1081,1079,1,0, - 0,0,1082,1083,3,138,69,0,1083,1084,5,87,0,0,1084,109,1,0,0,0,1085,1091, - 5,42,0,0,1086,1087,3,146,73,0,1087,1088,5,28,0,0,1088,1090,1,0,0,0,1089, - 1086,1,0,0,0,1090,1093,1,0,0,0,1091,1089,1,0,0,0,1091,1092,1,0,0,0,1092, - 1094,1,0,0,0,1093,1091,1,0,0,0,1094,1095,3,146,73,0,1095,1096,5,43,0,0, - 1096,111,1,0,0,0,1097,1103,5,30,0,0,1098,1099,3,114,57,0,1099,1100,5,28, - 0,0,1100,1102,1,0,0,0,1101,1098,1,0,0,0,1102,1105,1,0,0,0,1103,1101,1, - 0,0,0,1103,1104,1,0,0,0,1104,1106,1,0,0,0,1105,1103,1,0,0,0,1106,1107, - 3,114,57,0,1107,1108,5,31,0,0,1108,1111,1,0,0,0,1109,1111,5,85,0,0,1110, - 1097,1,0,0,0,1110,1109,1,0,0,0,1111,113,1,0,0,0,1112,1120,5,177,0,0,1113, - 1114,3,230,115,0,1114,1115,3,138,69,0,1115,1117,3,226,113,0,1116,1118, - 3,0,0,0,1117,1116,1,0,0,0,1117,1118,1,0,0,0,1118,1120,1,0,0,0,1119,1112, - 1,0,0,0,1119,1113,1,0,0,0,1120,115,1,0,0,0,1121,1122,5,42,0,0,1122,1123, - 3,2,1,0,1123,1124,5,43,0,0,1124,1125,3,118,59,0,1125,1147,1,0,0,0,1126, - 1127,5,42,0,0,1127,1128,3,174,87,0,1128,1129,5,43,0,0,1129,1130,3,118, - 59,0,1130,1147,1,0,0,0,1131,1132,5,42,0,0,1132,1133,5,262,0,0,1133,1134, - 5,43,0,0,1134,1147,3,118,59,0,1135,1136,5,42,0,0,1136,1137,5,198,0,0,1137, - 1138,3,2,1,0,1138,1139,5,43,0,0,1139,1140,3,118,59,0,1140,1147,1,0,0,0, - 1141,1147,3,118,59,0,1142,1147,3,174,87,0,1143,1147,5,257,0,0,1144,1147, - 5,258,0,0,1145,1147,5,259,0,0,1146,1121,1,0,0,0,1146,1126,1,0,0,0,1146, - 1131,1,0,0,0,1146,1135,1,0,0,0,1146,1141,1,0,0,0,1146,1142,1,0,0,0,1146, - 1143,1,0,0,0,1146,1144,1,0,0,0,1146,1145,1,0,0,0,1147,117,1,0,0,0,1148, - 1149,3,2,1,0,1149,1150,5,88,0,0,1150,1152,1,0,0,0,1151,1148,1,0,0,0,1152, - 1155,1,0,0,0,1153,1151,1,0,0,0,1153,1154,1,0,0,0,1154,1156,1,0,0,0,1155, - 1153,1,0,0,0,1156,1157,3,2,1,0,1157,119,1,0,0,0,1158,1160,3,122,61,0,1159, - 1158,1,0,0,0,1160,1163,1,0,0,0,1161,1159,1,0,0,0,1161,1162,1,0,0,0,1162, - 121,1,0,0,0,1163,1161,1,0,0,0,1164,1165,5,180,0,0,1165,1166,5,89,0,0,1166, - 1170,3,32,16,0,1167,1170,3,152,76,0,1168,1170,3,324,162,0,1169,1164,1, - 0,0,0,1169,1167,1,0,0,0,1169,1168,1,0,0,0,1170,123,1,0,0,0,1171,1183,3, - 116,58,0,1172,1173,5,42,0,0,1173,1174,3,2,1,0,1174,1175,5,43,0,0,1175, - 1183,1,0,0,0,1176,1177,5,42,0,0,1177,1178,5,198,0,0,1178,1179,3,2,1,0, - 1179,1180,5,43,0,0,1180,1183,1,0,0,0,1181,1183,3,138,69,0,1182,1171,1, - 0,0,0,1182,1172,1,0,0,0,1182,1176,1,0,0,0,1182,1181,1,0,0,0,1183,125,1, - 0,0,0,1184,1193,1,0,0,0,1185,1189,3,130,65,0,1186,1188,3,128,64,0,1187, - 1186,1,0,0,0,1188,1191,1,0,0,0,1189,1187,1,0,0,0,1189,1190,1,0,0,0,1190, - 1193,1,0,0,0,1191,1189,1,0,0,0,1192,1184,1,0,0,0,1192,1185,1,0,0,0,1193, - 127,1,0,0,0,1194,1212,5,262,0,0,1195,1212,5,261,0,0,1196,1197,5,42,0,0, - 1197,1198,3,32,16,0,1198,1199,5,43,0,0,1199,1212,1,0,0,0,1200,1201,5,42, - 0,0,1201,1202,3,32,16,0,1202,1203,5,266,0,0,1203,1204,3,32,16,0,1204,1205, - 5,43,0,0,1205,1212,1,0,0,0,1206,1207,5,42,0,0,1207,1208,5,266,0,0,1208, - 1209,3,32,16,0,1209,1210,5,43,0,0,1210,1212,1,0,0,0,1211,1194,1,0,0,0, - 1211,1195,1,0,0,0,1211,1196,1,0,0,0,1211,1200,1,0,0,0,1211,1206,1,0,0, - 0,1212,129,1,0,0,0,1213,1306,1,0,0,0,1214,1215,5,203,0,0,1215,1216,5,30, - 0,0,1216,1217,3,6,3,0,1217,1218,5,28,0,0,1218,1219,3,6,3,0,1219,1220,5, - 28,0,0,1220,1221,3,6,3,0,1221,1222,5,28,0,0,1222,1223,3,6,3,0,1223,1224, - 5,31,0,0,1224,1306,1,0,0,0,1225,1226,5,203,0,0,1226,1227,5,30,0,0,1227, - 1228,3,6,3,0,1228,1229,5,28,0,0,1229,1230,3,6,3,0,1230,1231,5,31,0,0,1231, - 1306,1,0,0,0,1232,1233,5,204,0,0,1233,1234,5,205,0,0,1234,1235,5,42,0, - 0,1235,1236,3,32,16,0,1236,1237,5,43,0,0,1237,1306,1,0,0,0,1238,1239,5, - 204,0,0,1239,1240,5,206,0,0,1240,1241,5,42,0,0,1241,1242,3,32,16,0,1242, - 1243,5,43,0,0,1243,1244,3,126,63,0,1244,1306,1,0,0,0,1245,1306,5,207,0, - 0,1246,1306,5,208,0,0,1247,1306,5,209,0,0,1248,1306,5,201,0,0,1249,1306, - 5,183,0,0,1250,1306,5,184,0,0,1251,1306,5,185,0,0,1252,1306,5,186,0,0, - 1253,1306,5,187,0,0,1254,1306,5,188,0,0,1255,1306,5,189,0,0,1256,1306, - 5,210,0,0,1257,1306,5,190,0,0,1258,1306,5,191,0,0,1259,1306,5,192,0,0, - 1260,1306,5,193,0,0,1261,1306,5,211,0,0,1262,1306,5,212,0,0,1263,1306, - 5,213,0,0,1264,1306,5,214,0,0,1265,1306,5,215,0,0,1266,1306,5,216,0,0, - 1267,1306,5,217,0,0,1268,1269,5,218,0,0,1269,1306,3,132,66,0,1270,1271, - 5,219,0,0,1271,1306,3,132,66,0,1272,1306,5,220,0,0,1273,1274,5,221,0,0, - 1274,1306,3,132,66,0,1275,1276,5,222,0,0,1276,1306,3,134,67,0,1277,1278, - 5,222,0,0,1278,1279,3,134,67,0,1279,1280,5,28,0,0,1280,1281,3,6,3,0,1281, - 1306,1,0,0,0,1282,1306,5,194,0,0,1283,1306,5,195,0,0,1284,1285,5,90,0, - 0,1285,1306,5,184,0,0,1286,1287,5,90,0,0,1287,1306,5,185,0,0,1288,1289, - 5,90,0,0,1289,1306,5,186,0,0,1290,1291,5,90,0,0,1291,1306,5,187,0,0,1292, - 1293,5,62,0,0,1293,1306,5,220,0,0,1294,1306,5,223,0,0,1295,1296,5,224, - 0,0,1296,1306,5,213,0,0,1297,1306,5,225,0,0,1298,1299,5,207,0,0,1299,1306, - 5,183,0,0,1300,1306,5,226,0,0,1301,1306,5,228,0,0,1302,1303,5,34,0,0,1303, - 1306,5,227,0,0,1304,1306,3,2,1,0,1305,1213,1,0,0,0,1305,1214,1,0,0,0,1305, - 1225,1,0,0,0,1305,1232,1,0,0,0,1305,1238,1,0,0,0,1305,1245,1,0,0,0,1305, - 1246,1,0,0,0,1305,1247,1,0,0,0,1305,1248,1,0,0,0,1305,1249,1,0,0,0,1305, - 1250,1,0,0,0,1305,1251,1,0,0,0,1305,1252,1,0,0,0,1305,1253,1,0,0,0,1305, - 1254,1,0,0,0,1305,1255,1,0,0,0,1305,1256,1,0,0,0,1305,1257,1,0,0,0,1305, - 1258,1,0,0,0,1305,1259,1,0,0,0,1305,1260,1,0,0,0,1305,1261,1,0,0,0,1305, - 1262,1,0,0,0,1305,1263,1,0,0,0,1305,1264,1,0,0,0,1305,1265,1,0,0,0,1305, - 1266,1,0,0,0,1305,1267,1,0,0,0,1305,1268,1,0,0,0,1305,1270,1,0,0,0,1305, - 1272,1,0,0,0,1305,1273,1,0,0,0,1305,1275,1,0,0,0,1305,1277,1,0,0,0,1305, - 1282,1,0,0,0,1305,1283,1,0,0,0,1305,1284,1,0,0,0,1305,1286,1,0,0,0,1305, - 1288,1,0,0,0,1305,1290,1,0,0,0,1305,1292,1,0,0,0,1305,1294,1,0,0,0,1305, - 1295,1,0,0,0,1305,1297,1,0,0,0,1305,1298,1,0,0,0,1305,1300,1,0,0,0,1305, - 1301,1,0,0,0,1305,1302,1,0,0,0,1305,1304,1,0,0,0,1306,131,1,0,0,0,1307, - 1315,1,0,0,0,1308,1309,5,30,0,0,1309,1310,5,91,0,0,1310,1311,5,36,0,0, - 1311,1312,3,32,16,0,1312,1313,5,31,0,0,1313,1315,1,0,0,0,1314,1307,1,0, - 0,0,1314,1308,1,0,0,0,1315,133,1,0,0,0,1316,1325,1,0,0,0,1317,1321,3,136, - 68,0,1318,1320,7,7,0,0,1319,1318,1,0,0,0,1320,1323,1,0,0,0,1321,1319,1, - 0,0,0,1321,1322,1,0,0,0,1322,1325,1,0,0,0,1323,1321,1,0,0,0,1324,1316, - 1,0,0,0,1324,1317,1,0,0,0,1325,135,1,0,0,0,1326,1327,7,8,0,0,1327,137, - 1,0,0,0,1328,1332,3,142,71,0,1329,1331,3,140,70,0,1330,1329,1,0,0,0,1331, - 1334,1,0,0,0,1332,1330,1,0,0,0,1332,1333,1,0,0,0,1333,139,1,0,0,0,1334, - 1332,1,0,0,0,1335,1354,5,261,0,0,1336,1337,5,42,0,0,1337,1354,5,43,0,0, - 1338,1354,3,110,55,0,1339,1354,5,260,0,0,1340,1354,5,262,0,0,1341,1354, - 5,92,0,0,1342,1343,5,93,0,0,1343,1344,5,30,0,0,1344,1345,3,124,62,0,1345, - 1346,5,31,0,0,1346,1354,1,0,0,0,1347,1348,5,94,0,0,1348,1349,5,30,0,0, - 1349,1350,3,124,62,0,1350,1351,5,31,0,0,1351,1354,1,0,0,0,1352,1354,3, - 108,54,0,1353,1335,1,0,0,0,1353,1336,1,0,0,0,1353,1338,1,0,0,0,1353,1339, - 1,0,0,0,1353,1340,1,0,0,0,1353,1341,1,0,0,0,1353,1342,1,0,0,0,1353,1347, - 1,0,0,0,1353,1352,1,0,0,0,1354,141,1,0,0,0,1355,1356,5,39,0,0,1356,1386, - 3,116,58,0,1357,1386,5,197,0,0,1358,1359,5,199,0,0,1359,1360,5,39,0,0, - 1360,1386,3,116,58,0,1361,1362,5,200,0,0,1362,1386,3,116,58,0,1363,1364, - 5,226,0,0,1364,1365,3,170,85,0,1365,1366,3,138,69,0,1366,1367,5,262,0, - 0,1367,1368,3,112,56,0,1368,1386,1,0,0,0,1369,1370,5,253,0,0,1370,1386, - 3,32,16,0,1371,1372,5,252,0,0,1372,1386,3,32,16,0,1373,1374,5,253,0,0, - 1374,1386,3,2,1,0,1375,1376,5,252,0,0,1376,1386,3,2,1,0,1377,1386,5,254, - 0,0,1378,1386,5,201,0,0,1379,1386,3,148,74,0,1380,1386,3,150,75,0,1381, - 1386,3,144,72,0,1382,1386,3,2,1,0,1383,1384,5,177,0,0,1384,1386,3,138, - 69,0,1385,1355,1,0,0,0,1385,1357,1,0,0,0,1385,1358,1,0,0,0,1385,1361,1, - 0,0,0,1385,1363,1,0,0,0,1385,1369,1,0,0,0,1385,1371,1,0,0,0,1385,1373, - 1,0,0,0,1385,1375,1,0,0,0,1385,1377,1,0,0,0,1385,1378,1,0,0,0,1385,1379, - 1,0,0,0,1385,1380,1,0,0,0,1385,1381,1,0,0,0,1385,1382,1,0,0,0,1385,1383, - 1,0,0,0,1386,143,1,0,0,0,1387,1409,5,181,0,0,1388,1409,5,182,0,0,1389, - 1409,5,183,0,0,1390,1409,5,184,0,0,1391,1409,5,185,0,0,1392,1409,5,186, - 0,0,1393,1409,5,187,0,0,1394,1409,5,188,0,0,1395,1409,5,189,0,0,1396,1409, - 5,190,0,0,1397,1409,5,191,0,0,1398,1409,5,192,0,0,1399,1409,5,193,0,0, - 1400,1401,5,90,0,0,1401,1409,5,184,0,0,1402,1403,5,90,0,0,1403,1409,5, - 185,0,0,1404,1405,5,90,0,0,1405,1409,5,186,0,0,1406,1407,5,90,0,0,1407, - 1409,5,187,0,0,1408,1387,1,0,0,0,1408,1388,1,0,0,0,1408,1389,1,0,0,0,1408, - 1390,1,0,0,0,1408,1391,1,0,0,0,1408,1392,1,0,0,0,1408,1393,1,0,0,0,1408, - 1394,1,0,0,0,1408,1395,1,0,0,0,1408,1396,1,0,0,0,1408,1397,1,0,0,0,1408, - 1398,1,0,0,0,1408,1399,1,0,0,0,1408,1400,1,0,0,0,1408,1402,1,0,0,0,1408, - 1404,1,0,0,0,1408,1406,1,0,0,0,1409,145,1,0,0,0,1410,1421,1,0,0,0,1411, - 1421,5,177,0,0,1412,1421,3,32,16,0,1413,1414,3,32,16,0,1414,1415,5,177, - 0,0,1415,1416,3,32,16,0,1416,1421,1,0,0,0,1417,1418,3,32,16,0,1418,1419, - 5,177,0,0,1419,1421,1,0,0,0,1420,1410,1,0,0,0,1420,1411,1,0,0,0,1420,1412, - 1,0,0,0,1420,1413,1,0,0,0,1420,1417,1,0,0,0,1421,147,1,0,0,0,1422,1423, - 5,1,0,0,1423,1424,5,194,0,0,1424,149,1,0,0,0,1425,1429,5,1,0,0,1426,1427, - 5,90,0,0,1427,1430,5,194,0,0,1428,1430,5,195,0,0,1429,1426,1,0,0,0,1429, - 1428,1,0,0,0,1430,151,1,0,0,0,1431,1432,5,294,0,0,1432,1433,3,166,83,0, - 1433,1434,3,124,62,0,1434,1435,5,30,0,0,1435,1436,3,158,79,0,1436,1437, - 5,31,0,0,1437,1479,1,0,0,0,1438,1439,5,294,0,0,1439,1440,3,166,83,0,1440, - 1441,3,124,62,0,1441,1442,5,36,0,0,1442,1443,5,17,0,0,1443,1444,3,52,26, - 0,1444,1445,5,18,0,0,1445,1479,1,0,0,0,1446,1447,5,294,0,0,1447,1448,3, - 166,83,0,1448,1449,3,124,62,0,1449,1479,1,0,0,0,1450,1451,5,295,0,0,1451, - 1452,3,166,83,0,1452,1454,5,36,0,0,1453,1455,5,84,0,0,1454,1453,1,0,0, - 0,1454,1455,1,0,0,0,1455,1456,1,0,0,0,1456,1457,5,30,0,0,1457,1458,3,292, - 146,0,1458,1459,5,31,0,0,1459,1479,1,0,0,0,1460,1461,5,295,0,0,1461,1462, - 3,166,83,0,1462,1463,5,84,0,0,1463,1464,5,30,0,0,1464,1465,3,292,146,0, - 1465,1466,5,31,0,0,1466,1479,1,0,0,0,1467,1468,5,295,0,0,1468,1469,3,166, - 83,0,1469,1470,3,6,3,0,1470,1479,1,0,0,0,1471,1472,5,295,0,0,1472,1473, - 3,166,83,0,1473,1474,5,36,0,0,1474,1475,5,17,0,0,1475,1476,3,154,77,0, - 1476,1477,5,18,0,0,1477,1479,1,0,0,0,1478,1431,1,0,0,0,1478,1438,1,0,0, - 0,1478,1446,1,0,0,0,1478,1450,1,0,0,0,1478,1460,1,0,0,0,1478,1467,1,0, - 0,0,1478,1471,1,0,0,0,1479,153,1,0,0,0,1480,1491,1,0,0,0,1481,1482,3,156, - 78,0,1482,1483,5,28,0,0,1483,1485,1,0,0,0,1484,1481,1,0,0,0,1485,1488, - 1,0,0,0,1486,1484,1,0,0,0,1486,1487,1,0,0,0,1487,1489,1,0,0,0,1488,1486, - 1,0,0,0,1489,1491,3,156,78,0,1490,1480,1,0,0,0,1490,1486,1,0,0,0,1491, - 155,1,0,0,0,1492,1493,5,39,0,0,1493,1494,5,264,0,0,1494,1495,5,36,0,0, - 1495,1496,5,17,0,0,1496,1497,3,56,28,0,1497,1498,5,18,0,0,1498,1506,1, - 0,0,0,1499,1500,3,124,62,0,1500,1501,5,36,0,0,1501,1502,5,17,0,0,1502, - 1503,3,56,28,0,1503,1504,5,18,0,0,1504,1506,1,0,0,0,1505,1492,1,0,0,0, - 1505,1499,1,0,0,0,1506,157,1,0,0,0,1507,1508,3,160,80,0,1508,1509,5,28, - 0,0,1509,1511,1,0,0,0,1510,1507,1,0,0,0,1511,1514,1,0,0,0,1512,1510,1, - 0,0,0,1512,1513,1,0,0,0,1513,1515,1,0,0,0,1514,1512,1,0,0,0,1515,1516, - 3,160,80,0,1516,159,1,0,0,0,1517,1518,3,6,3,0,1518,1519,5,36,0,0,1519, - 1520,3,164,82,0,1520,161,1,0,0,0,1521,1522,7,9,0,0,1522,163,1,0,0,0,1523, - 1558,3,162,81,0,1524,1558,3,32,16,0,1525,1526,5,186,0,0,1526,1527,5,30, - 0,0,1527,1528,3,32,16,0,1528,1529,5,31,0,0,1529,1558,1,0,0,0,1530,1558, - 3,6,3,0,1531,1532,3,116,58,0,1532,1533,5,30,0,0,1533,1534,5,184,0,0,1534, - 1535,5,75,0,0,1535,1536,3,32,16,0,1536,1537,5,31,0,0,1537,1558,1,0,0,0, - 1538,1539,3,116,58,0,1539,1540,5,30,0,0,1540,1541,5,185,0,0,1541,1542, - 5,75,0,0,1542,1543,3,32,16,0,1543,1544,5,31,0,0,1544,1558,1,0,0,0,1545, - 1546,3,116,58,0,1546,1547,5,30,0,0,1547,1548,5,186,0,0,1548,1549,5,75, - 0,0,1549,1550,3,32,16,0,1550,1551,5,31,0,0,1551,1558,1,0,0,0,1552,1553, - 3,116,58,0,1553,1554,5,30,0,0,1554,1555,3,32,16,0,1555,1556,5,31,0,0,1556, - 1558,1,0,0,0,1557,1523,1,0,0,0,1557,1524,1,0,0,0,1557,1525,1,0,0,0,1557, - 1530,1,0,0,0,1557,1531,1,0,0,0,1557,1538,1,0,0,0,1557,1545,1,0,0,0,1557, - 1552,1,0,0,0,1558,165,1,0,0,0,1559,1560,7,10,0,0,1560,167,1,0,0,0,1561, - 1562,3,170,85,0,1562,1563,3,138,69,0,1563,1564,3,124,62,0,1564,1565,5, - 176,0,0,1565,1567,3,242,121,0,1566,1568,3,108,54,0,1567,1566,1,0,0,0,1567, - 1568,1,0,0,0,1568,1569,1,0,0,0,1569,1570,3,112,56,0,1570,1596,1,0,0,0, - 1571,1572,3,170,85,0,1572,1573,3,138,69,0,1573,1574,3,124,62,0,1574,1575, - 5,176,0,0,1575,1576,3,242,121,0,1576,1577,3,196,98,0,1577,1578,3,112,56, - 0,1578,1596,1,0,0,0,1579,1580,3,170,85,0,1580,1581,3,138,69,0,1581,1583, - 3,242,121,0,1582,1584,3,108,54,0,1583,1582,1,0,0,0,1583,1584,1,0,0,0,1584, - 1585,1,0,0,0,1585,1586,3,112,56,0,1586,1596,1,0,0,0,1587,1588,3,170,85, - 0,1588,1589,3,138,69,0,1589,1590,3,242,121,0,1590,1591,3,196,98,0,1591, - 1592,3,112,56,0,1592,1596,1,0,0,0,1593,1596,3,174,87,0,1594,1596,3,2,1, - 0,1595,1561,1,0,0,0,1595,1571,1,0,0,0,1595,1579,1,0,0,0,1595,1587,1,0, - 0,0,1595,1593,1,0,0,0,1595,1594,1,0,0,0,1596,169,1,0,0,0,1597,1598,5,243, - 0,0,1598,1608,3,170,85,0,1599,1600,5,244,0,0,1600,1608,3,170,85,0,1601, - 1608,3,172,86,0,1602,1603,5,112,0,0,1603,1604,5,30,0,0,1604,1605,3,32, - 16,0,1605,1606,5,31,0,0,1606,1608,1,0,0,0,1607,1597,1,0,0,0,1607,1599, - 1,0,0,0,1607,1601,1,0,0,0,1607,1602,1,0,0,0,1608,171,1,0,0,0,1609,1622, - 1,0,0,0,1610,1622,5,245,0,0,1611,1622,5,246,0,0,1612,1613,5,247,0,0,1613, - 1622,5,248,0,0,1614,1615,5,247,0,0,1615,1622,5,249,0,0,1616,1617,5,247, - 0,0,1617,1622,5,250,0,0,1618,1619,5,247,0,0,1619,1622,5,251,0,0,1620,1622, - 5,247,0,0,1621,1609,1,0,0,0,1621,1610,1,0,0,0,1621,1611,1,0,0,0,1621,1612, - 1,0,0,0,1621,1614,1,0,0,0,1621,1616,1,0,0,0,1621,1618,1,0,0,0,1621,1620, - 1,0,0,0,1622,173,1,0,0,0,1623,1624,5,113,0,0,1624,1625,5,30,0,0,1625,1626, - 3,32,16,0,1626,1627,5,31,0,0,1627,175,1,0,0,0,1628,1629,5,226,0,0,1629, - 1634,3,168,84,0,1630,1631,5,37,0,0,1631,1634,3,178,89,0,1632,1634,3,174, - 87,0,1633,1628,1,0,0,0,1633,1630,1,0,0,0,1633,1632,1,0,0,0,1634,177,1, - 0,0,0,1635,1636,3,138,69,0,1636,1637,3,124,62,0,1637,1638,5,176,0,0,1638, - 1639,3,2,1,0,1639,1645,1,0,0,0,1640,1641,3,138,69,0,1641,1642,3,2,1,0, - 1642,1645,1,0,0,0,1643,1645,3,2,1,0,1644,1635,1,0,0,0,1644,1640,1,0,0, - 0,1644,1643,1,0,0,0,1645,179,1,0,0,0,1646,1647,3,124,62,0,1647,1648,5, - 28,0,0,1648,1650,1,0,0,0,1649,1646,1,0,0,0,1650,1653,1,0,0,0,1651,1649, - 1,0,0,0,1651,1652,1,0,0,0,1652,1654,1,0,0,0,1653,1651,1,0,0,0,1654,1655, - 3,124,62,0,1655,181,1,0,0,0,1656,1662,1,0,0,0,1657,1658,5,86,0,0,1658, - 1659,3,190,95,0,1659,1660,5,87,0,0,1660,1662,1,0,0,0,1661,1656,1,0,0,0, - 1661,1657,1,0,0,0,1662,183,1,0,0,0,1663,1675,5,266,0,0,1664,1675,5,114, - 0,0,1665,1675,5,39,0,0,1666,1675,5,200,0,0,1667,1675,5,115,0,0,1668,1675, - 5,116,0,0,1669,1670,5,70,0,0,1670,1671,5,30,0,0,1671,1672,3,32,16,0,1672, - 1673,5,31,0,0,1673,1675,1,0,0,0,1674,1663,1,0,0,0,1674,1664,1,0,0,0,1674, - 1665,1,0,0,0,1674,1666,1,0,0,0,1674,1667,1,0,0,0,1674,1668,1,0,0,0,1674, - 1669,1,0,0,0,1675,185,1,0,0,0,1676,1678,3,184,92,0,1677,1676,1,0,0,0,1678, - 1681,1,0,0,0,1679,1677,1,0,0,0,1679,1680,1,0,0,0,1680,187,1,0,0,0,1681, - 1679,1,0,0,0,1682,1684,3,186,93,0,1683,1685,3,192,96,0,1684,1683,1,0,0, - 0,1684,1685,1,0,0,0,1685,1686,1,0,0,0,1686,1687,3,2,1,0,1687,189,1,0,0, - 0,1688,1689,3,188,94,0,1689,1690,5,28,0,0,1690,1692,1,0,0,0,1691,1688, - 1,0,0,0,1692,1695,1,0,0,0,1693,1691,1,0,0,0,1693,1694,1,0,0,0,1694,1696, - 1,0,0,0,1695,1693,1,0,0,0,1696,1697,3,188,94,0,1697,191,1,0,0,0,1698,1699, - 5,30,0,0,1699,1700,3,180,90,0,1700,1701,5,31,0,0,1701,193,1,0,0,0,1702, - 1705,1,0,0,0,1703,1705,3,196,98,0,1704,1702,1,0,0,0,1704,1703,1,0,0,0, - 1705,195,1,0,0,0,1706,1707,5,86,0,0,1707,1708,5,42,0,0,1708,1709,3,32, - 16,0,1709,1710,5,43,0,0,1710,1711,5,87,0,0,1711,197,1,0,0,0,1712,1713, - 3,234,117,0,1713,1714,5,17,0,0,1714,1715,3,246,123,0,1715,1716,5,18,0, - 0,1716,1829,1,0,0,0,1717,1718,3,74,37,0,1718,1719,5,17,0,0,1719,1720,3, - 82,41,0,1720,1721,5,18,0,0,1721,1829,1,0,0,0,1722,1723,3,210,105,0,1723, - 1724,5,17,0,0,1724,1725,3,214,107,0,1725,1726,5,18,0,0,1726,1829,1,0,0, - 0,1727,1728,3,218,109,0,1728,1729,5,17,0,0,1729,1730,3,222,111,0,1730, - 1731,5,18,0,0,1731,1829,1,0,0,0,1732,1829,3,200,100,0,1733,1829,3,276, - 138,0,1734,1829,3,152,76,0,1735,1829,3,88,44,0,1736,1829,3,322,161,0,1737, - 1738,5,117,0,0,1738,1829,3,32,16,0,1739,1740,5,118,0,0,1740,1829,3,32, - 16,0,1741,1742,3,334,167,0,1742,1743,5,17,0,0,1743,1744,3,338,169,0,1744, - 1745,5,18,0,0,1745,1829,1,0,0,0,1746,1747,5,302,0,0,1747,1748,3,124,62, - 0,1748,1749,5,176,0,0,1749,1750,3,242,121,0,1750,1751,5,119,0,0,1751,1752, - 3,170,85,0,1752,1753,3,138,69,0,1753,1754,3,124,62,0,1754,1755,5,176,0, - 0,1755,1756,3,242,121,0,1756,1757,3,112,56,0,1757,1829,1,0,0,0,1758,1759, - 5,302,0,0,1759,1760,5,226,0,0,1760,1761,3,170,85,0,1761,1762,3,138,69, - 0,1762,1763,3,124,62,0,1763,1764,5,176,0,0,1764,1765,3,242,121,0,1765, - 1766,3,194,97,0,1766,1767,3,112,56,0,1767,1768,5,119,0,0,1768,1769,5,226, - 0,0,1769,1770,3,170,85,0,1770,1771,3,138,69,0,1771,1772,3,124,62,0,1772, - 1773,5,176,0,0,1773,1774,3,242,121,0,1774,1775,3,194,97,0,1775,1776,3, - 112,56,0,1776,1829,1,0,0,0,1777,1829,3,26,13,0,1778,1829,3,40,20,0,1779, - 1780,5,255,0,0,1780,1781,5,196,0,0,1781,1782,5,42,0,0,1782,1783,3,32,16, - 0,1783,1787,5,43,0,0,1784,1786,3,322,161,0,1785,1784,1,0,0,0,1786,1789, - 1,0,0,0,1787,1785,1,0,0,0,1787,1788,1,0,0,0,1788,1829,1,0,0,0,1789,1787, - 1,0,0,0,1790,1791,5,255,0,0,1791,1792,5,196,0,0,1792,1796,3,2,1,0,1793, - 1795,3,322,161,0,1794,1793,1,0,0,0,1795,1798,1,0,0,0,1796,1794,1,0,0,0, - 1796,1797,1,0,0,0,1797,1829,1,0,0,0,1798,1796,1,0,0,0,1799,1800,5,255, - 0,0,1800,1801,5,256,0,0,1801,1802,5,42,0,0,1802,1803,3,32,16,0,1803,1804, - 5,43,0,0,1804,1805,5,28,0,0,1805,1809,3,124,62,0,1806,1808,3,322,161,0, - 1807,1806,1,0,0,0,1808,1811,1,0,0,0,1809,1807,1,0,0,0,1809,1810,1,0,0, - 0,1810,1829,1,0,0,0,1811,1809,1,0,0,0,1812,1813,5,255,0,0,1813,1814,5, - 256,0,0,1814,1815,3,2,1,0,1815,1816,5,28,0,0,1816,1820,3,124,62,0,1817, - 1819,3,322,161,0,1818,1817,1,0,0,0,1819,1822,1,0,0,0,1820,1818,1,0,0,0, - 1820,1821,1,0,0,0,1821,1829,1,0,0,0,1822,1820,1,0,0,0,1823,1824,5,120, - 0,0,1824,1825,5,196,0,0,1825,1826,3,124,62,0,1826,1827,3,44,22,0,1827, - 1829,1,0,0,0,1828,1712,1,0,0,0,1828,1717,1,0,0,0,1828,1722,1,0,0,0,1828, - 1727,1,0,0,0,1828,1732,1,0,0,0,1828,1733,1,0,0,0,1828,1734,1,0,0,0,1828, - 1735,1,0,0,0,1828,1736,1,0,0,0,1828,1737,1,0,0,0,1828,1739,1,0,0,0,1828, - 1741,1,0,0,0,1828,1746,1,0,0,0,1828,1758,1,0,0,0,1828,1777,1,0,0,0,1828, - 1778,1,0,0,0,1828,1779,1,0,0,0,1828,1790,1,0,0,0,1828,1799,1,0,0,0,1828, - 1812,1,0,0,0,1828,1823,1,0,0,0,1829,199,1,0,0,0,1830,1831,5,121,0,0,1831, - 1840,3,208,104,0,1832,1839,3,202,101,0,1833,1834,5,122,0,0,1834,1835,5, - 30,0,0,1835,1836,3,228,114,0,1836,1837,5,31,0,0,1837,1839,1,0,0,0,1838, - 1832,1,0,0,0,1838,1833,1,0,0,0,1839,1842,1,0,0,0,1840,1838,1,0,0,0,1840, - 1841,1,0,0,0,1841,1843,1,0,0,0,1842,1840,1,0,0,0,1843,1844,3,138,69,0, - 1844,1845,3,2,1,0,1845,1846,3,204,102,0,1846,1847,3,206,103,0,1847,201, - 1,0,0,0,1848,1868,5,123,0,0,1849,1868,5,51,0,0,1850,1868,5,52,0,0,1851, - 1868,5,63,0,0,1852,1868,5,124,0,0,1853,1868,5,69,0,0,1854,1868,5,68,0, - 0,1855,1868,5,64,0,0,1856,1868,5,65,0,0,1857,1868,5,66,0,0,1858,1868,5, - 125,0,0,1859,1868,5,126,0,0,1860,1868,5,127,0,0,1861,1868,5,16,0,0,1862, - 1863,5,70,0,0,1863,1864,5,30,0,0,1864,1865,3,32,16,0,1865,1866,5,31,0, - 0,1866,1868,1,0,0,0,1867,1848,1,0,0,0,1867,1849,1,0,0,0,1867,1850,1,0, - 0,0,1867,1851,1,0,0,0,1867,1852,1,0,0,0,1867,1853,1,0,0,0,1867,1854,1, - 0,0,0,1867,1855,1,0,0,0,1867,1856,1,0,0,0,1867,1857,1,0,0,0,1867,1858, - 1,0,0,0,1867,1859,1,0,0,0,1867,1860,1,0,0,0,1867,1861,1,0,0,0,1867,1862, - 1,0,0,0,1868,203,1,0,0,0,1869,1875,1,0,0,0,1870,1871,5,44,0,0,1871,1875, - 3,0,0,0,1872,1873,5,44,0,0,1873,1875,3,32,16,0,1874,1869,1,0,0,0,1874, - 1870,1,0,0,0,1874,1872,1,0,0,0,1875,205,1,0,0,0,1876,1880,1,0,0,0,1877, - 1878,5,36,0,0,1878,1880,3,296,148,0,1879,1876,1,0,0,0,1879,1877,1,0,0, - 0,1880,207,1,0,0,0,1881,1887,1,0,0,0,1882,1883,5,42,0,0,1883,1884,3,32, - 16,0,1884,1885,5,43,0,0,1885,1887,1,0,0,0,1886,1881,1,0,0,0,1886,1882, - 1,0,0,0,1887,209,1,0,0,0,1888,1892,5,128,0,0,1889,1891,3,212,106,0,1890, - 1889,1,0,0,0,1891,1894,1,0,0,0,1892,1890,1,0,0,0,1892,1893,1,0,0,0,1893, - 1895,1,0,0,0,1894,1892,1,0,0,0,1895,1896,3,124,62,0,1896,1897,3,2,1,0, - 1897,1907,1,0,0,0,1898,1902,5,128,0,0,1899,1901,3,212,106,0,1900,1899, - 1,0,0,0,1901,1904,1,0,0,0,1902,1900,1,0,0,0,1902,1903,1,0,0,0,1903,1905, - 1,0,0,0,1904,1902,1,0,0,0,1905,1907,3,2,1,0,1906,1888,1,0,0,0,1906,1898, - 1,0,0,0,1907,211,1,0,0,0,1908,1909,7,11,0,0,1909,213,1,0,0,0,1910,1912, - 3,216,108,0,1911,1910,1,0,0,0,1912,1915,1,0,0,0,1913,1911,1,0,0,0,1913, - 1914,1,0,0,0,1914,215,1,0,0,0,1915,1913,1,0,0,0,1916,1917,5,129,0,0,1917, - 1929,3,168,84,0,1918,1919,5,130,0,0,1919,1929,3,168,84,0,1920,1921,5,131, - 0,0,1921,1929,3,168,84,0,1922,1923,5,132,0,0,1923,1929,3,168,84,0,1924, - 1929,3,88,44,0,1925,1929,3,322,161,0,1926,1929,3,26,13,0,1927,1929,3,40, - 20,0,1928,1916,1,0,0,0,1928,1918,1,0,0,0,1928,1920,1,0,0,0,1928,1922,1, - 0,0,0,1928,1924,1,0,0,0,1928,1925,1,0,0,0,1928,1926,1,0,0,0,1928,1927, - 1,0,0,0,1929,217,1,0,0,0,1930,1934,5,133,0,0,1931,1933,3,220,110,0,1932, - 1931,1,0,0,0,1933,1936,1,0,0,0,1934,1932,1,0,0,0,1934,1935,1,0,0,0,1935, - 1937,1,0,0,0,1936,1934,1,0,0,0,1937,1938,3,170,85,0,1938,1939,3,138,69, - 0,1939,1940,3,2,1,0,1940,1941,3,112,56,0,1941,1942,3,206,103,0,1942,219, - 1,0,0,0,1943,1944,7,11,0,0,1944,221,1,0,0,0,1945,1947,3,224,112,0,1946, - 1945,1,0,0,0,1947,1950,1,0,0,0,1948,1946,1,0,0,0,1948,1949,1,0,0,0,1949, - 223,1,0,0,0,1950,1948,1,0,0,0,1951,1952,5,134,0,0,1952,1962,3,168,84,0, - 1953,1954,5,135,0,0,1954,1962,3,168,84,0,1955,1956,5,132,0,0,1956,1962, - 3,168,84,0,1957,1962,3,322,161,0,1958,1962,3,88,44,0,1959,1962,3,26,13, - 0,1960,1962,3,40,20,0,1961,1951,1,0,0,0,1961,1953,1,0,0,0,1961,1955,1, - 0,0,0,1961,1957,1,0,0,0,1961,1958,1,0,0,0,1961,1959,1,0,0,0,1961,1960, - 1,0,0,0,1962,225,1,0,0,0,1963,1970,1,0,0,0,1964,1965,5,122,0,0,1965,1966, - 5,30,0,0,1966,1967,3,228,114,0,1967,1968,5,31,0,0,1968,1970,1,0,0,0,1969, - 1963,1,0,0,0,1969,1964,1,0,0,0,1970,227,1,0,0,0,1971,1981,3,126,63,0,1972, - 1974,5,17,0,0,1973,1975,3,294,147,0,1974,1973,1,0,0,0,1975,1976,1,0,0, - 0,1976,1974,1,0,0,0,1976,1977,1,0,0,0,1977,1978,1,0,0,0,1978,1979,5,18, - 0,0,1979,1981,1,0,0,0,1980,1971,1,0,0,0,1980,1972,1,0,0,0,1981,229,1,0, - 0,0,1982,1984,3,232,116,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,231,1,0,0,0,1987,1985,1,0,0,0,1988,1989, - 5,42,0,0,1989,1990,5,136,0,0,1990,2002,5,43,0,0,1991,1992,5,42,0,0,1992, - 1993,5,137,0,0,1993,2002,5,43,0,0,1994,1995,5,42,0,0,1995,1996,5,138,0, - 0,1996,2002,5,43,0,0,1997,1998,5,42,0,0,1998,1999,3,32,16,0,1999,2000, - 5,43,0,0,2000,2002,1,0,0,0,2001,1988,1,0,0,0,2001,1991,1,0,0,0,2001,1994, - 1,0,0,0,2001,1997,1,0,0,0,2002,233,1,0,0,0,2003,2008,5,139,0,0,2004,2007, - 3,236,118,0,2005,2007,3,238,119,0,2006,2004,1,0,0,0,2006,2005,1,0,0,0, - 2007,2010,1,0,0,0,2008,2006,1,0,0,0,2008,2009,1,0,0,0,2009,2011,1,0,0, - 0,2010,2008,1,0,0,0,2011,2012,3,170,85,0,2012,2013,3,230,115,0,2013,2014, - 3,138,69,0,2014,2015,3,226,113,0,2015,2016,3,242,121,0,2016,2017,3,182, - 91,0,2017,2021,3,112,56,0,2018,2020,3,244,122,0,2019,2018,1,0,0,0,2020, - 2023,1,0,0,0,2021,2019,1,0,0,0,2021,2022,1,0,0,0,2022,235,1,0,0,0,2023, - 2021,1,0,0,0,2024,2048,5,123,0,0,2025,2048,5,51,0,0,2026,2048,5,52,0,0, - 2027,2048,5,63,0,0,2028,2048,5,140,0,0,2029,2048,5,68,0,0,2030,2048,5, - 141,0,0,2031,2048,5,142,0,0,2032,2048,5,54,0,0,2033,2048,5,64,0,0,2034, - 2048,5,65,0,0,2035,2048,5,66,0,0,2036,2048,5,125,0,0,2037,2048,5,143,0, - 0,2038,2048,5,144,0,0,2039,2048,5,69,0,0,2040,2048,5,145,0,0,2041,2048, - 5,146,0,0,2042,2043,5,70,0,0,2043,2044,5,30,0,0,2044,2045,3,32,16,0,2045, - 2046,5,31,0,0,2046,2048,1,0,0,0,2047,2024,1,0,0,0,2047,2025,1,0,0,0,2047, - 2026,1,0,0,0,2047,2027,1,0,0,0,2047,2028,1,0,0,0,2047,2029,1,0,0,0,2047, - 2030,1,0,0,0,2047,2031,1,0,0,0,2047,2032,1,0,0,0,2047,2033,1,0,0,0,2047, - 2034,1,0,0,0,2047,2035,1,0,0,0,2047,2036,1,0,0,0,2047,2037,1,0,0,0,2047, - 2038,1,0,0,0,2047,2039,1,0,0,0,2047,2040,1,0,0,0,2047,2041,1,0,0,0,2047, - 2042,1,0,0,0,2048,237,1,0,0,0,2049,2050,5,147,0,0,2050,2056,5,30,0,0,2051, - 2054,3,6,3,0,2052,2053,5,34,0,0,2053,2055,3,6,3,0,2054,2052,1,0,0,0,2054, - 2055,1,0,0,0,2055,2057,1,0,0,0,2056,2051,1,0,0,0,2056,2057,1,0,0,0,2057, - 2061,1,0,0,0,2058,2060,3,240,120,0,2059,2058,1,0,0,0,2060,2063,1,0,0,0, - 2061,2059,1,0,0,0,2061,2062,1,0,0,0,2062,2064,1,0,0,0,2063,2061,1,0,0, - 0,2064,2068,5,31,0,0,2065,2066,5,147,0,0,2066,2068,5,85,0,0,2067,2049, - 1,0,0,0,2067,2065,1,0,0,0,2068,239,1,0,0,0,2069,2097,5,148,0,0,2070,2097, - 5,224,0,0,2071,2097,5,57,0,0,2072,2097,5,58,0,0,2073,2097,5,149,0,0,2074, - 2097,5,150,0,0,2075,2097,5,248,0,0,2076,2097,5,249,0,0,2077,2097,5,250, - 0,0,2078,2097,5,251,0,0,2079,2080,5,151,0,0,2080,2081,5,75,0,0,2081,2097, - 5,152,0,0,2082,2083,5,151,0,0,2083,2084,5,75,0,0,2084,2097,5,153,0,0,2085, - 2086,5,154,0,0,2086,2087,5,75,0,0,2087,2097,5,152,0,0,2088,2089,5,154, - 0,0,2089,2090,5,75,0,0,2090,2097,5,153,0,0,2091,2092,5,70,0,0,2092,2093, - 5,30,0,0,2093,2094,3,32,16,0,2094,2095,5,31,0,0,2095,2097,1,0,0,0,2096, - 2069,1,0,0,0,2096,2070,1,0,0,0,2096,2071,1,0,0,0,2096,2072,1,0,0,0,2096, - 2073,1,0,0,0,2096,2074,1,0,0,0,2096,2075,1,0,0,0,2096,2076,1,0,0,0,2096, - 2077,1,0,0,0,2096,2078,1,0,0,0,2096,2079,1,0,0,0,2096,2082,1,0,0,0,2096, - 2085,1,0,0,0,2096,2088,1,0,0,0,2096,2091,1,0,0,0,2097,241,1,0,0,0,2098, - 2102,5,116,0,0,2099,2102,5,155,0,0,2100,2102,3,2,1,0,2101,2098,1,0,0,0, - 2101,2099,1,0,0,0,2101,2100,1,0,0,0,2102,243,1,0,0,0,2103,2125,5,1,0,0, - 2104,2125,5,2,0,0,2105,2125,5,156,0,0,2106,2125,5,3,0,0,2107,2125,5,4, - 0,0,2108,2125,5,247,0,0,2109,2125,5,5,0,0,2110,2125,5,6,0,0,2111,2125, - 5,7,0,0,2112,2125,5,8,0,0,2113,2125,5,9,0,0,2114,2125,5,10,0,0,2115,2125, - 5,11,0,0,2116,2125,5,12,0,0,2117,2125,5,13,0,0,2118,2125,5,14,0,0,2119, - 2120,5,70,0,0,2120,2121,5,30,0,0,2121,2122,3,32,16,0,2122,2123,5,31,0, - 0,2123,2125,1,0,0,0,2124,2103,1,0,0,0,2124,2104,1,0,0,0,2124,2105,1,0, - 0,0,2124,2106,1,0,0,0,2124,2107,1,0,0,0,2124,2108,1,0,0,0,2124,2109,1, - 0,0,0,2124,2110,1,0,0,0,2124,2111,1,0,0,0,2124,2112,1,0,0,0,2124,2113, - 1,0,0,0,2124,2114,1,0,0,0,2124,2115,1,0,0,0,2124,2116,1,0,0,0,2124,2117, - 1,0,0,0,2124,2118,1,0,0,0,2124,2119,1,0,0,0,2125,245,1,0,0,0,2126,2128, - 3,248,124,0,2127,2126,1,0,0,0,2128,2131,1,0,0,0,2129,2127,1,0,0,0,2129, - 2130,1,0,0,0,2130,247,1,0,0,0,2131,2129,1,0,0,0,2132,2150,3,100,50,0,2133, - 2134,5,296,0,0,2134,2135,3,32,16,0,2135,2136,6,124,-1,0,2136,2150,1,0, - 0,0,2137,2150,3,258,129,0,2138,2139,5,297,0,0,2139,2140,3,32,16,0,2140, - 2141,6,124,-1,0,2141,2150,1,0,0,0,2142,2143,5,298,0,0,2143,2150,6,124, - -1,0,2144,2145,5,299,0,0,2145,2150,6,124,-1,0,2146,2150,3,252,126,0,2147, - 2150,3,256,128,0,2148,2150,3,250,125,0,2149,2132,1,0,0,0,2149,2133,1,0, - 0,0,2149,2137,1,0,0,0,2149,2138,1,0,0,0,2149,2142,1,0,0,0,2149,2144,1, - 0,0,0,2149,2146,1,0,0,0,2149,2147,1,0,0,0,2149,2148,1,0,0,0,2150,249,1, - 0,0,0,2151,2152,5,300,0,0,2152,2250,3,112,56,0,2153,2154,5,300,0,0,2154, - 2155,5,157,0,0,2155,2250,3,112,56,0,2156,2250,3,276,138,0,2157,2250,3, - 152,76,0,2158,2250,3,88,44,0,2159,2250,3,26,13,0,2160,2250,3,254,127,0, - 2161,2250,3,40,20,0,2162,2163,5,301,0,0,2163,2164,5,42,0,0,2164,2165,3, - 32,16,0,2165,2166,5,43,0,0,2166,2250,1,0,0,0,2167,2168,5,301,0,0,2168, - 2169,5,42,0,0,2169,2170,3,32,16,0,2170,2171,5,43,0,0,2171,2172,5,34,0, - 0,2172,2173,3,0,0,0,2173,2250,1,0,0,0,2174,2175,5,303,0,0,2175,2176,3, - 32,16,0,2176,2177,5,75,0,0,2177,2178,3,32,16,0,2178,2250,1,0,0,0,2179, - 2180,5,302,0,0,2180,2181,3,124,62,0,2181,2182,5,176,0,0,2182,2183,3,242, - 121,0,2183,2250,1,0,0,0,2184,2185,5,302,0,0,2185,2186,5,226,0,0,2186,2187, - 3,170,85,0,2187,2188,3,138,69,0,2188,2189,3,124,62,0,2189,2190,5,176,0, - 0,2190,2191,3,242,121,0,2191,2192,3,194,97,0,2192,2193,3,112,56,0,2193, - 2250,1,0,0,0,2194,2195,5,255,0,0,2195,2196,5,196,0,0,2196,2197,5,42,0, - 0,2197,2198,3,32,16,0,2198,2202,5,43,0,0,2199,2201,3,322,161,0,2200,2199, - 1,0,0,0,2201,2204,1,0,0,0,2202,2200,1,0,0,0,2202,2203,1,0,0,0,2203,2250, - 1,0,0,0,2204,2202,1,0,0,0,2205,2206,5,255,0,0,2206,2207,5,196,0,0,2207, - 2211,3,2,1,0,2208,2210,3,322,161,0,2209,2208,1,0,0,0,2210,2213,1,0,0,0, - 2211,2209,1,0,0,0,2211,2212,1,0,0,0,2212,2250,1,0,0,0,2213,2211,1,0,0, - 0,2214,2215,5,255,0,0,2215,2216,5,256,0,0,2216,2217,5,42,0,0,2217,2218, - 3,32,16,0,2218,2219,5,43,0,0,2219,2220,5,28,0,0,2220,2224,3,124,62,0,2221, - 2223,3,322,161,0,2222,2221,1,0,0,0,2223,2226,1,0,0,0,2224,2222,1,0,0,0, - 2224,2225,1,0,0,0,2225,2250,1,0,0,0,2226,2224,1,0,0,0,2227,2228,5,255, - 0,0,2228,2229,5,256,0,0,2229,2230,3,2,1,0,2230,2231,5,28,0,0,2231,2235, - 3,124,62,0,2232,2234,3,322,161,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,2250,1,0,0,0,2237,2235,1,0,0,0,2238, - 2239,5,255,0,0,2239,2240,5,42,0,0,2240,2241,3,32,16,0,2241,2242,5,43,0, - 0,2242,2246,3,206,103,0,2243,2245,3,322,161,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,2250,1,0,0,0,2248,2246, - 1,0,0,0,2249,2151,1,0,0,0,2249,2153,1,0,0,0,2249,2156,1,0,0,0,2249,2157, - 1,0,0,0,2249,2158,1,0,0,0,2249,2159,1,0,0,0,2249,2160,1,0,0,0,2249,2161, - 1,0,0,0,2249,2162,1,0,0,0,2249,2167,1,0,0,0,2249,2174,1,0,0,0,2249,2179, - 1,0,0,0,2249,2184,1,0,0,0,2249,2194,1,0,0,0,2249,2205,1,0,0,0,2249,2214, - 1,0,0,0,2249,2227,1,0,0,0,2249,2238,1,0,0,0,2250,251,1,0,0,0,2251,2252, - 3,0,0,0,2252,2253,5,75,0,0,2253,2254,6,126,-1,0,2254,253,1,0,0,0,2255, - 2258,3,44,22,0,2256,2258,3,46,23,0,2257,2255,1,0,0,0,2257,2256,1,0,0,0, - 2258,255,1,0,0,0,2259,2260,5,17,0,0,2260,2261,3,246,123,0,2261,2262,5, - 18,0,0,2262,257,1,0,0,0,2263,2264,3,262,131,0,2264,2265,3,260,130,0,2265, - 259,1,0,0,0,2266,2268,3,264,132,0,2267,2266,1,0,0,0,2268,2269,1,0,0,0, - 2269,2267,1,0,0,0,2269,2270,1,0,0,0,2270,261,1,0,0,0,2271,2272,5,158,0, - 0,2272,2284,3,256,128,0,2273,2274,5,158,0,0,2274,2275,3,0,0,0,2275,2276, - 5,159,0,0,2276,2277,3,0,0,0,2277,2284,1,0,0,0,2278,2279,5,158,0,0,2279, - 2280,3,32,16,0,2280,2281,5,159,0,0,2281,2282,3,32,16,0,2282,2284,1,0,0, - 0,2283,2271,1,0,0,0,2283,2273,1,0,0,0,2283,2278,1,0,0,0,2284,263,1,0,0, - 0,2285,2286,3,268,134,0,2286,2287,3,274,137,0,2287,2298,1,0,0,0,2288,2289, - 3,266,133,0,2289,2290,3,274,137,0,2290,2298,1,0,0,0,2291,2292,3,270,135, - 0,2292,2293,3,274,137,0,2293,2298,1,0,0,0,2294,2295,3,272,136,0,2295,2296, - 3,274,137,0,2296,2298,1,0,0,0,2297,2285,1,0,0,0,2297,2288,1,0,0,0,2297, - 2291,1,0,0,0,2297,2294,1,0,0,0,2298,265,1,0,0,0,2299,2300,5,160,0,0,2300, - 2306,3,256,128,0,2301,2302,5,160,0,0,2302,2306,3,0,0,0,2303,2304,5,160, - 0,0,2304,2306,3,32,16,0,2305,2299,1,0,0,0,2305,2301,1,0,0,0,2305,2303, - 1,0,0,0,2306,267,1,0,0,0,2307,2308,5,161,0,0,2308,2309,3,124,62,0,2309, - 269,1,0,0,0,2310,2311,5,162,0,0,2311,271,1,0,0,0,2312,2313,5,163,0,0,2313, - 273,1,0,0,0,2314,2326,3,256,128,0,2315,2316,5,164,0,0,2316,2317,3,0,0, - 0,2317,2318,5,159,0,0,2318,2319,3,0,0,0,2319,2326,1,0,0,0,2320,2321,5, - 164,0,0,2321,2322,3,32,16,0,2322,2323,5,159,0,0,2323,2324,3,32,16,0,2324, - 2326,1,0,0,0,2325,2314,1,0,0,0,2325,2315,1,0,0,0,2325,2320,1,0,0,0,2326, - 275,1,0,0,0,2327,2328,3,278,139,0,2328,2329,3,282,141,0,2329,277,1,0,0, - 0,2330,2331,5,165,0,0,2331,2332,3,280,140,0,2332,2333,3,0,0,0,2333,2334, - 5,36,0,0,2334,2338,1,0,0,0,2335,2336,5,165,0,0,2336,2338,3,280,140,0,2337, - 2330,1,0,0,0,2337,2335,1,0,0,0,2338,279,1,0,0,0,2339,2343,1,0,0,0,2340, - 2343,5,166,0,0,2341,2343,5,2,0,0,2342,2339,1,0,0,0,2342,2340,1,0,0,0,2342, - 2341,1,0,0,0,2343,281,1,0,0,0,2344,2345,5,17,0,0,2345,2346,3,284,142,0, - 2346,2347,5,18,0,0,2347,2354,1,0,0,0,2348,2350,3,288,144,0,2349,2348,1, - 0,0,0,2350,2351,1,0,0,0,2351,2349,1,0,0,0,2351,2352,1,0,0,0,2352,2354, - 1,0,0,0,2353,2344,1,0,0,0,2353,2349,1,0,0,0,2354,283,1,0,0,0,2355,2356, - 3,288,144,0,2356,2357,5,28,0,0,2357,2359,1,0,0,0,2358,2355,1,0,0,0,2359, - 2362,1,0,0,0,2360,2358,1,0,0,0,2360,2361,1,0,0,0,2361,2363,1,0,0,0,2362, - 2360,1,0,0,0,2363,2364,3,288,144,0,2364,285,1,0,0,0,2365,2371,1,0,0,0, - 2366,2367,5,42,0,0,2367,2368,3,32,16,0,2368,2369,5,43,0,0,2369,2371,1, - 0,0,0,2370,2365,1,0,0,0,2370,2366,1,0,0,0,2371,287,1,0,0,0,2372,2373,5, - 181,0,0,2373,2374,5,262,0,0,2374,2375,5,30,0,0,2375,2376,3,6,3,0,2376, - 2377,5,31,0,0,2377,2439,1,0,0,0,2378,2379,5,260,0,0,2379,2380,5,30,0,0, - 2380,2381,3,0,0,0,2381,2382,5,31,0,0,2382,2439,1,0,0,0,2383,2384,5,260, - 0,0,2384,2439,3,0,0,0,2385,2386,5,84,0,0,2386,2387,5,30,0,0,2387,2388, - 3,292,146,0,2388,2389,5,31,0,0,2389,2439,1,0,0,0,2390,2391,5,188,0,0,2391, - 2392,5,30,0,0,2392,2393,3,36,18,0,2393,2394,5,31,0,0,2394,2395,3,286,143, - 0,2395,2439,1,0,0,0,2396,2397,5,189,0,0,2397,2398,5,30,0,0,2398,2399,3, - 36,18,0,2399,2400,5,31,0,0,2400,2401,3,286,143,0,2401,2439,1,0,0,0,2402, - 2403,5,187,0,0,2403,2404,5,30,0,0,2404,2405,3,34,17,0,2405,2406,5,31,0, - 0,2406,2407,3,286,143,0,2407,2439,1,0,0,0,2408,2409,5,186,0,0,2409,2410, - 5,30,0,0,2410,2411,3,32,16,0,2411,2412,5,31,0,0,2412,2413,3,286,143,0, - 2413,2439,1,0,0,0,2414,2415,5,185,0,0,2415,2416,5,30,0,0,2416,2417,3,32, - 16,0,2417,2418,5,31,0,0,2418,2419,3,286,143,0,2419,2439,1,0,0,0,2420,2421, - 5,184,0,0,2421,2422,5,30,0,0,2422,2423,3,32,16,0,2423,2424,5,31,0,0,2424, - 2425,3,286,143,0,2425,2439,1,0,0,0,2426,2427,5,188,0,0,2427,2439,3,286, - 143,0,2428,2429,5,189,0,0,2429,2439,3,286,143,0,2430,2431,5,187,0,0,2431, - 2439,3,286,143,0,2432,2433,5,186,0,0,2433,2439,3,286,143,0,2434,2435,5, - 185,0,0,2435,2439,3,286,143,0,2436,2437,5,184,0,0,2437,2439,3,286,143, - 0,2438,2372,1,0,0,0,2438,2378,1,0,0,0,2438,2383,1,0,0,0,2438,2385,1,0, - 0,0,2438,2390,1,0,0,0,2438,2396,1,0,0,0,2438,2402,1,0,0,0,2438,2408,1, - 0,0,0,2438,2414,1,0,0,0,2438,2420,1,0,0,0,2438,2426,1,0,0,0,2438,2428, - 1,0,0,0,2438,2430,1,0,0,0,2438,2432,1,0,0,0,2438,2434,1,0,0,0,2438,2436, - 1,0,0,0,2439,289,1,0,0,0,2440,2441,5,188,0,0,2441,2442,5,30,0,0,2442,2443, - 3,36,18,0,2443,2444,5,31,0,0,2444,2516,1,0,0,0,2445,2446,5,189,0,0,2446, - 2447,5,30,0,0,2447,2448,3,36,18,0,2448,2449,5,31,0,0,2449,2516,1,0,0,0, - 2450,2451,5,188,0,0,2451,2452,5,30,0,0,2452,2453,3,32,16,0,2453,2454,5, - 31,0,0,2454,2516,1,0,0,0,2455,2456,5,189,0,0,2456,2457,5,30,0,0,2457,2458, - 3,34,17,0,2458,2459,5,31,0,0,2459,2516,1,0,0,0,2460,2461,5,187,0,0,2461, - 2462,5,30,0,0,2462,2463,3,34,17,0,2463,2464,5,31,0,0,2464,2516,1,0,0,0, - 2465,2466,5,186,0,0,2466,2467,5,30,0,0,2467,2468,3,32,16,0,2468,2469,5, - 31,0,0,2469,2516,1,0,0,0,2470,2471,5,185,0,0,2471,2472,5,30,0,0,2472,2473, - 3,32,16,0,2473,2474,5,31,0,0,2474,2516,1,0,0,0,2475,2476,5,184,0,0,2476, - 2477,5,30,0,0,2477,2478,3,32,16,0,2478,2479,5,31,0,0,2479,2516,1,0,0,0, - 2480,2481,5,193,0,0,2481,2482,5,30,0,0,2482,2483,3,34,17,0,2483,2484,5, - 31,0,0,2484,2516,1,0,0,0,2485,2486,5,192,0,0,2486,2487,5,30,0,0,2487,2488, - 3,32,16,0,2488,2489,5,31,0,0,2489,2516,1,0,0,0,2490,2491,5,191,0,0,2491, - 2492,5,30,0,0,2492,2493,3,32,16,0,2493,2494,5,31,0,0,2494,2516,1,0,0,0, - 2495,2496,5,190,0,0,2496,2497,5,30,0,0,2497,2498,3,32,16,0,2498,2499,5, - 31,0,0,2499,2516,1,0,0,0,2500,2501,5,181,0,0,2501,2502,5,30,0,0,2502,2503, - 3,32,16,0,2503,2504,5,31,0,0,2504,2516,1,0,0,0,2505,2506,5,183,0,0,2506, - 2507,5,30,0,0,2507,2508,3,162,81,0,2508,2509,5,31,0,0,2509,2516,1,0,0, - 0,2510,2511,5,84,0,0,2511,2512,5,30,0,0,2512,2513,3,292,146,0,2513,2514, - 5,31,0,0,2514,2516,1,0,0,0,2515,2440,1,0,0,0,2515,2445,1,0,0,0,2515,2450, - 1,0,0,0,2515,2455,1,0,0,0,2515,2460,1,0,0,0,2515,2465,1,0,0,0,2515,2470, - 1,0,0,0,2515,2475,1,0,0,0,2515,2480,1,0,0,0,2515,2485,1,0,0,0,2515,2490, - 1,0,0,0,2515,2495,1,0,0,0,2515,2500,1,0,0,0,2515,2505,1,0,0,0,2515,2510, - 1,0,0,0,2516,291,1,0,0,0,2517,2518,3,294,147,0,2518,2519,6,146,-1,0,2519, - 2521,1,0,0,0,2520,2517,1,0,0,0,2521,2524,1,0,0,0,2522,2520,1,0,0,0,2522, - 2523,1,0,0,0,2523,293,1,0,0,0,2524,2522,1,0,0,0,2525,2526,7,12,0,0,2526, - 295,1,0,0,0,2527,2531,3,290,145,0,2528,2531,3,6,3,0,2529,2531,5,179,0, - 0,2530,2527,1,0,0,0,2530,2528,1,0,0,0,2530,2529,1,0,0,0,2531,297,1,0,0, - 0,2532,2681,3,290,145,0,2533,2534,5,182,0,0,2534,2535,5,30,0,0,2535,2536, - 5,179,0,0,2536,2681,5,31,0,0,2537,2538,5,182,0,0,2538,2539,5,30,0,0,2539, - 2540,5,264,0,0,2540,2681,5,31,0,0,2541,2542,5,196,0,0,2542,2543,5,30,0, - 0,2543,2544,5,39,0,0,2544,2545,5,264,0,0,2545,2681,5,31,0,0,2546,2547, - 5,196,0,0,2547,2548,5,30,0,0,2548,2549,3,116,58,0,2549,2550,5,31,0,0,2550, - 2681,1,0,0,0,2551,2552,5,196,0,0,2552,2553,5,30,0,0,2553,2554,5,179,0, - 0,2554,2681,5,31,0,0,2555,2556,5,197,0,0,2556,2557,5,30,0,0,2557,2558, - 3,298,149,0,2558,2559,5,31,0,0,2559,2681,1,0,0,0,2560,2561,5,188,0,0,2561, - 2562,5,42,0,0,2562,2563,3,32,16,0,2563,2564,5,43,0,0,2564,2565,5,30,0, - 0,2565,2566,3,300,150,0,2566,2567,5,31,0,0,2567,2681,1,0,0,0,2568,2569, - 5,189,0,0,2569,2570,5,42,0,0,2570,2571,3,32,16,0,2571,2572,5,43,0,0,2572, - 2573,5,30,0,0,2573,2574,3,302,151,0,2574,2575,5,31,0,0,2575,2681,1,0,0, - 0,2576,2577,5,187,0,0,2577,2578,5,42,0,0,2578,2579,3,32,16,0,2579,2580, - 5,43,0,0,2580,2581,5,30,0,0,2581,2582,3,304,152,0,2582,2583,5,31,0,0,2583, - 2681,1,0,0,0,2584,2585,5,186,0,0,2585,2586,5,42,0,0,2586,2587,3,32,16, - 0,2587,2588,5,43,0,0,2588,2589,5,30,0,0,2589,2590,3,306,153,0,2590,2591, - 5,31,0,0,2591,2681,1,0,0,0,2592,2593,5,185,0,0,2593,2594,5,42,0,0,2594, - 2595,3,32,16,0,2595,2596,5,43,0,0,2596,2597,5,30,0,0,2597,2598,3,308,154, - 0,2598,2599,5,31,0,0,2599,2681,1,0,0,0,2600,2601,5,184,0,0,2601,2602,5, - 42,0,0,2602,2603,3,32,16,0,2603,2604,5,43,0,0,2604,2605,5,30,0,0,2605, - 2606,3,310,155,0,2606,2607,5,31,0,0,2607,2681,1,0,0,0,2608,2609,5,193, - 0,0,2609,2610,5,42,0,0,2610,2611,3,32,16,0,2611,2612,5,43,0,0,2612,2613, - 5,30,0,0,2613,2614,3,304,152,0,2614,2615,5,31,0,0,2615,2681,1,0,0,0,2616, - 2617,5,192,0,0,2617,2618,5,42,0,0,2618,2619,3,32,16,0,2619,2620,5,43,0, - 0,2620,2621,5,30,0,0,2621,2622,3,306,153,0,2622,2623,5,31,0,0,2623,2681, - 1,0,0,0,2624,2625,5,191,0,0,2625,2626,5,42,0,0,2626,2627,3,32,16,0,2627, - 2628,5,43,0,0,2628,2629,5,30,0,0,2629,2630,3,308,154,0,2630,2631,5,31, - 0,0,2631,2681,1,0,0,0,2632,2633,5,190,0,0,2633,2634,5,42,0,0,2634,2635, - 3,32,16,0,2635,2636,5,43,0,0,2636,2637,5,30,0,0,2637,2638,3,310,155,0, - 2638,2639,5,31,0,0,2639,2681,1,0,0,0,2640,2641,5,181,0,0,2641,2642,5,42, - 0,0,2642,2643,3,32,16,0,2643,2644,5,43,0,0,2644,2645,5,30,0,0,2645,2646, - 3,308,154,0,2646,2647,5,31,0,0,2647,2681,1,0,0,0,2648,2649,5,183,0,0,2649, - 2650,5,42,0,0,2650,2651,3,32,16,0,2651,2652,5,43,0,0,2652,2653,5,30,0, - 0,2653,2654,3,312,156,0,2654,2655,5,31,0,0,2655,2681,1,0,0,0,2656,2657, - 5,182,0,0,2657,2658,5,42,0,0,2658,2659,3,32,16,0,2659,2660,5,43,0,0,2660, - 2661,5,30,0,0,2661,2662,3,314,157,0,2662,2663,5,31,0,0,2663,2681,1,0,0, - 0,2664,2665,5,196,0,0,2665,2666,5,42,0,0,2666,2667,3,32,16,0,2667,2668, - 5,43,0,0,2668,2669,5,30,0,0,2669,2670,3,316,158,0,2670,2671,5,31,0,0,2671, - 2681,1,0,0,0,2672,2673,5,197,0,0,2673,2674,5,42,0,0,2674,2675,3,32,16, - 0,2675,2676,5,43,0,0,2676,2677,5,30,0,0,2677,2678,3,320,160,0,2678,2679, - 5,31,0,0,2679,2681,1,0,0,0,2680,2532,1,0,0,0,2680,2533,1,0,0,0,2680,2537, - 1,0,0,0,2680,2541,1,0,0,0,2680,2546,1,0,0,0,2680,2551,1,0,0,0,2680,2555, - 1,0,0,0,2680,2560,1,0,0,0,2680,2568,1,0,0,0,2680,2576,1,0,0,0,2680,2584, - 1,0,0,0,2680,2592,1,0,0,0,2680,2600,1,0,0,0,2680,2608,1,0,0,0,2680,2616, - 1,0,0,0,2680,2624,1,0,0,0,2680,2632,1,0,0,0,2680,2640,1,0,0,0,2680,2648, - 1,0,0,0,2680,2656,1,0,0,0,2680,2664,1,0,0,0,2680,2672,1,0,0,0,2681,299, - 1,0,0,0,2682,2685,3,36,18,0,2683,2685,3,32,16,0,2684,2682,1,0,0,0,2684, - 2683,1,0,0,0,2685,2688,1,0,0,0,2686,2684,1,0,0,0,2686,2687,1,0,0,0,2687, - 301,1,0,0,0,2688,2686,1,0,0,0,2689,2692,3,36,18,0,2690,2692,3,34,17,0, - 2691,2689,1,0,0,0,2691,2690,1,0,0,0,2692,2695,1,0,0,0,2693,2691,1,0,0, - 0,2693,2694,1,0,0,0,2694,303,1,0,0,0,2695,2693,1,0,0,0,2696,2698,3,34, - 17,0,2697,2696,1,0,0,0,2698,2701,1,0,0,0,2699,2697,1,0,0,0,2699,2700,1, - 0,0,0,2700,305,1,0,0,0,2701,2699,1,0,0,0,2702,2704,3,32,16,0,2703,2702, - 1,0,0,0,2704,2707,1,0,0,0,2705,2703,1,0,0,0,2705,2706,1,0,0,0,2706,307, - 1,0,0,0,2707,2705,1,0,0,0,2708,2710,3,32,16,0,2709,2708,1,0,0,0,2710,2713, - 1,0,0,0,2711,2709,1,0,0,0,2711,2712,1,0,0,0,2712,309,1,0,0,0,2713,2711, - 1,0,0,0,2714,2716,3,32,16,0,2715,2714,1,0,0,0,2716,2719,1,0,0,0,2717,2715, - 1,0,0,0,2717,2718,1,0,0,0,2718,311,1,0,0,0,2719,2717,1,0,0,0,2720,2722, - 3,162,81,0,2721,2720,1,0,0,0,2722,2725,1,0,0,0,2723,2721,1,0,0,0,2723, - 2724,1,0,0,0,2724,313,1,0,0,0,2725,2723,1,0,0,0,2726,2728,7,13,0,0,2727, - 2726,1,0,0,0,2728,2731,1,0,0,0,2729,2727,1,0,0,0,2729,2730,1,0,0,0,2730, - 315,1,0,0,0,2731,2729,1,0,0,0,2732,2734,3,318,159,0,2733,2732,1,0,0,0, - 2734,2737,1,0,0,0,2735,2733,1,0,0,0,2735,2736,1,0,0,0,2736,317,1,0,0,0, - 2737,2735,1,0,0,0,2738,2743,5,179,0,0,2739,2740,5,39,0,0,2740,2743,5,264, - 0,0,2741,2743,3,116,58,0,2742,2738,1,0,0,0,2742,2739,1,0,0,0,2742,2741, - 1,0,0,0,2743,319,1,0,0,0,2744,2746,3,298,149,0,2745,2744,1,0,0,0,2746, - 2749,1,0,0,0,2747,2745,1,0,0,0,2747,2748,1,0,0,0,2748,321,1,0,0,0,2749, - 2747,1,0,0,0,2750,2754,3,44,22,0,2751,2754,3,46,23,0,2752,2754,3,2,1,0, - 2753,2750,1,0,0,0,2753,2751,1,0,0,0,2753,2752,1,0,0,0,2754,323,1,0,0,0, - 2755,2756,7,14,0,0,2756,2757,5,36,0,0,2757,2758,5,30,0,0,2758,2759,3,292, - 146,0,2759,2760,5,31,0,0,2760,2781,1,0,0,0,2761,2762,5,169,0,0,2762,2763, - 3,38,19,0,2763,2764,5,75,0,0,2764,2765,3,38,19,0,2765,2766,5,75,0,0,2766, - 2767,3,38,19,0,2767,2768,5,75,0,0,2768,2769,3,38,19,0,2769,2781,1,0,0, - 0,2770,2771,5,170,0,0,2771,2781,3,6,3,0,2772,2773,5,170,0,0,2773,2774, - 5,36,0,0,2774,2775,5,30,0,0,2775,2776,3,292,146,0,2776,2777,5,31,0,0,2777, - 2781,1,0,0,0,2778,2781,3,322,161,0,2779,2781,3,40,20,0,2780,2755,1,0,0, - 0,2780,2761,1,0,0,0,2780,2770,1,0,0,0,2780,2772,1,0,0,0,2780,2778,1,0, - 0,0,2780,2779,1,0,0,0,2781,325,1,0,0,0,2782,2783,5,25,0,0,2783,2784,5, - 40,0,0,2784,2785,3,98,49,0,2785,2786,3,2,1,0,2786,2795,1,0,0,0,2787,2788, - 5,25,0,0,2788,2789,5,40,0,0,2789,2790,3,98,49,0,2790,2791,3,2,1,0,2791, - 2792,5,34,0,0,2792,2793,3,2,1,0,2793,2795,1,0,0,0,2794,2782,1,0,0,0,2794, - 2787,1,0,0,0,2795,327,1,0,0,0,2796,2798,3,330,165,0,2797,2796,1,0,0,0, - 2798,2801,1,0,0,0,2799,2797,1,0,0,0,2799,2800,1,0,0,0,2800,329,1,0,0,0, - 2801,2799,1,0,0,0,2802,2803,5,180,0,0,2803,2804,5,36,0,0,2804,2805,5,30, - 0,0,2805,2806,3,292,146,0,2806,2807,5,31,0,0,2807,2817,1,0,0,0,2808,2817, - 3,324,162,0,2809,2810,5,171,0,0,2810,2811,5,36,0,0,2811,2812,5,30,0,0, - 2812,2813,3,292,146,0,2813,2814,5,31,0,0,2814,2817,1,0,0,0,2815,2817,5, - 55,0,0,2816,2802,1,0,0,0,2816,2808,1,0,0,0,2816,2809,1,0,0,0,2816,2815, - 1,0,0,0,2817,331,1,0,0,0,2818,2819,5,50,0,0,2819,2823,5,40,0,0,2820,2822, - 3,336,168,0,2821,2820,1,0,0,0,2822,2825,1,0,0,0,2823,2821,1,0,0,0,2823, - 2824,1,0,0,0,2824,2826,1,0,0,0,2825,2823,1,0,0,0,2826,2827,3,2,1,0,2827, - 333,1,0,0,0,2828,2832,5,301,0,0,2829,2831,3,336,168,0,2830,2829,1,0,0, - 0,2831,2834,1,0,0,0,2832,2830,1,0,0,0,2832,2833,1,0,0,0,2833,2835,1,0, - 0,0,2834,2832,1,0,0,0,2835,2836,3,2,1,0,2836,335,1,0,0,0,2837,2853,5,52, - 0,0,2838,2853,5,51,0,0,2839,2853,5,172,0,0,2840,2841,5,62,0,0,2841,2853, - 5,51,0,0,2842,2843,5,62,0,0,2843,2853,5,52,0,0,2844,2845,5,62,0,0,2845, - 2853,5,63,0,0,2846,2847,5,62,0,0,2847,2853,5,64,0,0,2848,2849,5,62,0,0, - 2849,2853,5,65,0,0,2850,2851,5,62,0,0,2851,2853,5,66,0,0,2852,2837,1,0, - 0,0,2852,2838,1,0,0,0,2852,2839,1,0,0,0,2852,2840,1,0,0,0,2852,2842,1, - 0,0,0,2852,2844,1,0,0,0,2852,2846,1,0,0,0,2852,2848,1,0,0,0,2852,2850, - 1,0,0,0,2853,337,1,0,0,0,2854,2856,3,340,170,0,2855,2854,1,0,0,0,2856, - 2859,1,0,0,0,2857,2855,1,0,0,0,2857,2858,1,0,0,0,2858,339,1,0,0,0,2859, - 2857,1,0,0,0,2860,2861,5,21,0,0,2861,2874,3,2,1,0,2862,2863,5,50,0,0,2863, - 2864,5,40,0,0,2864,2874,3,118,59,0,2865,2866,5,25,0,0,2866,2867,5,40,0, - 0,2867,2874,3,2,1,0,2868,2874,3,174,87,0,2869,2870,5,50,0,0,2870,2874, - 3,32,16,0,2871,2874,3,322,161,0,2872,2874,3,40,20,0,2873,2860,1,0,0,0, - 2873,2862,1,0,0,0,2873,2865,1,0,0,0,2873,2868,1,0,0,0,2873,2869,1,0,0, - 0,2873,2871,1,0,0,0,2873,2872,1,0,0,0,2874,341,1,0,0,0,2875,2879,5,274, - 0,0,2876,2878,3,344,172,0,2877,2876,1,0,0,0,2878,2881,1,0,0,0,2879,2877, - 1,0,0,0,2879,2880,1,0,0,0,2880,2882,1,0,0,0,2881,2879,1,0,0,0,2882,2895, - 3,2,1,0,2883,2887,5,274,0,0,2884,2886,3,344,172,0,2885,2884,1,0,0,0,2886, - 2889,1,0,0,0,2887,2885,1,0,0,0,2887,2888,1,0,0,0,2888,2890,1,0,0,0,2889, - 2887,1,0,0,0,2890,2891,3,2,1,0,2891,2892,5,34,0,0,2892,2893,3,2,1,0,2893, - 2895,1,0,0,0,2894,2875,1,0,0,0,2894,2883,1,0,0,0,2895,343,1,0,0,0,2896, - 2897,7,15,0,0,2897,345,1,0,0,0,2898,2900,3,348,174,0,2899,2898,1,0,0,0, - 2900,2903,1,0,0,0,2901,2899,1,0,0,0,2901,2902,1,0,0,0,2902,347,1,0,0,0, - 2903,2901,1,0,0,0,2904,2905,5,21,0,0,2905,2906,3,2,1,0,2906,2907,5,44, - 0,0,2907,2908,3,32,16,0,2908,2915,1,0,0,0,2909,2910,5,25,0,0,2910,2911, - 5,40,0,0,2911,2915,3,2,1,0,2912,2915,3,322,161,0,2913,2915,3,40,20,0,2914, - 2904,1,0,0,0,2914,2909,1,0,0,0,2914,2912,1,0,0,0,2914,2913,1,0,0,0,2915, - 349,1,0,0,0,175,358,363,372,381,434,475,484,514,518,536,563,586,622,628, - 635,637,647,649,656,667,675,696,698,714,759,764,769,774,782,892,898,914, - 920,926,933,961,1039,1041,1054,1060,1069,1071,1079,1091,1103,1110,1117, - 1119,1146,1153,1161,1169,1182,1189,1192,1211,1305,1314,1321,1324,1332, - 1353,1385,1408,1420,1429,1454,1478,1486,1490,1505,1512,1557,1567,1583, - 1595,1607,1621,1633,1644,1651,1661,1674,1679,1684,1693,1704,1787,1796, - 1809,1820,1828,1838,1840,1867,1874,1879,1886,1892,1902,1906,1913,1928, - 1934,1948,1961,1969,1976,1980,1985,2001,2006,2008,2021,2047,2054,2056, - 2061,2067,2096,2101,2124,2129,2149,2202,2211,2224,2235,2246,2249,2257, - 2269,2283,2297,2305,2325,2337,2342,2351,2353,2360,2370,2438,2515,2522, - 2530,2680,2684,2686,2691,2693,2699,2705,2711,2717,2723,2729,2735,2742, - 2747,2753,2780,2794,2799,2816,2823,2832,2852,2857,2873,2879,2887,2894, - 2901,2914 + 1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162,3,162, + 2931,8,162,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163, + 1,163,1,163,3,163,2945,8,163,1,164,5,164,2948,8,164,10,164,12,164,2951, + 9,164,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165, + 1,165,1,165,1,165,3,165,2967,8,165,1,166,1,166,1,166,5,166,2972,8,166, + 10,166,12,166,2975,9,166,1,166,1,166,1,167,1,167,5,167,2981,8,167,10,167, + 12,167,2984,9,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,168,1,168,1,168,1,168,3,168,3003,8,168,1,169, + 5,169,3006,8,169,10,169,12,169,3009,9,169,1,170,1,170,1,170,1,170,1,170, + 1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,3,170,3024,8,170,1,171, + 1,171,5,171,3028,8,171,10,171,12,171,3031,9,171,1,171,1,171,1,171,5,171, + 3036,8,171,10,171,12,171,3039,9,171,1,171,1,171,1,171,1,171,3,171,3045, + 8,171,1,172,1,172,1,173,5,173,3050,8,173,10,173,12,173,3053,9,173,1,174, + 1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,3,174,3065,8,174, + 1,174,0,1,68,175,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,0,16,6,0,1,15,199,199,243,243,247,247,264,264,289,289, + 5,0,16,16,199,199,243,243,264,264,288,289,1,0,263,264,1,0,173,174,1,0, + 37,38,1,0,73,74,3,0,2,2,61,61,77,83,2,0,229,229,260,261,9,0,178,178,183, + 195,201,201,207,208,210,215,218,219,222,222,230,242,262,262,1,0,95,96, + 1,0,97,111,1,0,68,69,2,0,173,173,289,290,2,0,179,179,264,264,1,0,167,168, + 1,0,51,52,3494,0,350,1,0,0,0,2,368,1,0,0,0,4,370,1,0,0,0,6,377,1,0,0,0, + 8,386,1,0,0,0,10,439,1,0,0,0,12,441,1,0,0,0,14,444,1,0,0,0,16,447,1,0, + 0,0,18,451,1,0,0,0,20,454,1,0,0,0,22,457,1,0,0,0,24,464,1,0,0,0,26,480, + 1,0,0,0,28,482,1,0,0,0,30,484,1,0,0,0,32,494,1,0,0,0,34,496,1,0,0,0,36, + 519,1,0,0,0,38,523,1,0,0,0,40,541,1,0,0,0,42,568,1,0,0,0,44,591,1,0,0, + 0,46,627,1,0,0,0,48,629,1,0,0,0,50,637,1,0,0,0,52,639,1,0,0,0,54,646,1, + 0,0,0,56,658,1,0,0,0,58,661,1,0,0,0,60,663,1,0,0,0,62,676,1,0,0,0,64,684, + 1,0,0,0,66,686,1,0,0,0,68,694,1,0,0,0,70,710,1,0,0,0,72,716,1,0,0,0,74, + 719,1,0,0,0,76,768,1,0,0,0,78,773,1,0,0,0,80,778,1,0,0,0,82,783,1,0,0, + 0,84,791,1,0,0,0,86,796,1,0,0,0,88,901,1,0,0,0,90,929,1,0,0,0,92,931,1, + 0,0,0,94,935,1,0,0,0,96,937,1,0,0,0,98,942,1,0,0,0,100,970,1,0,0,0,102, + 1050,1,0,0,0,104,1052,1,0,0,0,106,1081,1,0,0,0,108,1083,1,0,0,0,110,1097, + 1,0,0,0,112,1126,1,0,0,0,114,1138,1,0,0,0,116,1177,1,0,0,0,118,1185,1, + 0,0,0,120,1194,1,0,0,0,122,1202,1,0,0,0,124,1221,1,0,0,0,126,1231,1,0, + 0,0,128,1250,1,0,0,0,130,1344,1,0,0,0,132,1353,1,0,0,0,134,1363,1,0,0, + 0,136,1365,1,0,0,0,138,1367,1,0,0,0,140,1406,1,0,0,0,142,1466,1,0,0,0, + 144,1506,1,0,0,0,146,1522,1,0,0,0,148,1524,1,0,0,0,150,1528,1,0,0,0,152, + 1583,1,0,0,0,154,1595,1,0,0,0,156,1610,1,0,0,0,158,1617,1,0,0,0,160,1622, + 1,0,0,0,162,1626,1,0,0,0,164,1662,1,0,0,0,166,1664,1,0,0,0,168,1708,1, + 0,0,0,170,1727,1,0,0,0,172,1748,1,0,0,0,174,1750,1,0,0,0,176,1767,1,0, + 0,0,178,1782,1,0,0,0,180,1789,1,0,0,0,182,1799,1,0,0,0,184,1812,1,0,0, + 0,186,1817,1,0,0,0,188,1820,1,0,0,0,190,1831,1,0,0,0,192,1836,1,0,0,0, + 194,1841,1,0,0,0,196,1845,1,0,0,0,198,1968,1,0,0,0,200,1970,1,0,0,0,202, + 2007,1,0,0,0,204,2014,1,0,0,0,206,2019,1,0,0,0,208,2026,1,0,0,0,210,2046, + 1,0,0,0,212,2048,1,0,0,0,214,2053,1,0,0,0,216,2068,1,0,0,0,218,2070,1, + 0,0,0,220,2083,1,0,0,0,222,2088,1,0,0,0,224,2101,1,0,0,0,226,2109,1,0, + 0,0,228,2120,1,0,0,0,230,2127,1,0,0,0,232,2147,1,0,0,0,234,2149,1,0,0, + 0,236,2193,1,0,0,0,238,2213,1,0,0,0,240,2242,1,0,0,0,242,2251,1,0,0,0, + 244,2274,1,0,0,0,246,2279,1,0,0,0,248,2299,1,0,0,0,250,2399,1,0,0,0,252, + 2401,1,0,0,0,254,2407,1,0,0,0,256,2409,1,0,0,0,258,2413,1,0,0,0,260,2417, + 1,0,0,0,262,2433,1,0,0,0,264,2447,1,0,0,0,266,2455,1,0,0,0,268,2457,1, + 0,0,0,270,2460,1,0,0,0,272,2462,1,0,0,0,274,2475,1,0,0,0,276,2477,1,0, + 0,0,278,2487,1,0,0,0,280,2492,1,0,0,0,282,2503,1,0,0,0,284,2510,1,0,0, + 0,286,2520,1,0,0,0,288,2588,1,0,0,0,290,2665,1,0,0,0,292,2672,1,0,0,0, + 294,2675,1,0,0,0,296,2680,1,0,0,0,298,2830,1,0,0,0,300,2836,1,0,0,0,302, + 2843,1,0,0,0,304,2849,1,0,0,0,306,2855,1,0,0,0,308,2861,1,0,0,0,310,2867, + 1,0,0,0,312,2873,1,0,0,0,314,2879,1,0,0,0,316,2885,1,0,0,0,318,2892,1, + 0,0,0,320,2897,1,0,0,0,322,2903,1,0,0,0,324,2930,1,0,0,0,326,2944,1,0, + 0,0,328,2949,1,0,0,0,330,2966,1,0,0,0,332,2968,1,0,0,0,334,2978,1,0,0, + 0,336,3002,1,0,0,0,338,3007,1,0,0,0,340,3023,1,0,0,0,342,3044,1,0,0,0, + 344,3046,1,0,0,0,346,3051,1,0,0,0,348,3064,1,0,0,0,350,351,7,0,0,0,351, + 1,1,0,0,0,352,353,5,288,0,0,353,369,6,1,-1,0,354,355,3,4,2,0,355,356,6, + 1,-1,0,356,357,5,265,0,0,357,359,1,0,0,0,358,354,1,0,0,0,359,362,1,0,0, + 0,360,358,1,0,0,0,360,361,1,0,0,0,361,363,1,0,0,0,362,360,1,0,0,0,363, + 364,3,4,2,0,364,365,6,1,-1,0,365,369,1,0,0,0,366,367,5,264,0,0,367,369, + 6,1,-1,0,368,352,1,0,0,0,368,360,1,0,0,0,368,366,1,0,0,0,369,3,1,0,0,0, + 370,371,7,1,0,0,371,5,1,0,0,0,372,373,5,263,0,0,373,374,6,3,-1,0,374,376, + 5,266,0,0,375,372,1,0,0,0,376,379,1,0,0,0,377,375,1,0,0,0,377,378,1,0, + 0,0,378,380,1,0,0,0,379,377,1,0,0,0,380,381,5,263,0,0,381,382,6,3,-1,0, + 382,7,1,0,0,0,383,385,3,10,5,0,384,383,1,0,0,0,385,388,1,0,0,0,386,384, + 1,0,0,0,386,387,1,0,0,0,387,9,1,0,0,0,388,386,1,0,0,0,389,390,3,74,37, + 0,390,391,5,17,0,0,391,392,3,82,41,0,392,393,5,18,0,0,393,440,1,0,0,0, + 394,395,3,72,36,0,395,396,5,17,0,0,396,397,3,8,4,0,397,398,5,18,0,0,398, + 440,1,0,0,0,399,400,3,234,117,0,400,401,5,17,0,0,401,402,3,246,123,0,402, + 403,5,18,0,0,403,440,1,0,0,0,404,440,3,200,100,0,405,440,3,276,138,0,406, + 440,3,70,35,0,407,440,3,66,33,0,408,440,3,88,44,0,409,440,3,90,45,0,410, + 440,3,22,11,0,411,412,3,326,163,0,412,413,5,17,0,0,413,414,3,328,164,0, + 414,415,5,18,0,0,415,440,1,0,0,0,416,417,3,332,166,0,417,418,5,17,0,0, + 418,419,3,338,169,0,419,420,5,18,0,0,420,440,1,0,0,0,421,422,3,342,171, + 0,422,423,5,17,0,0,423,424,3,346,173,0,424,425,5,18,0,0,425,440,1,0,0, + 0,426,440,3,64,32,0,427,440,3,152,76,0,428,440,3,322,161,0,429,440,3,12, + 6,0,430,440,3,14,7,0,431,440,3,16,8,0,432,440,3,18,9,0,433,440,3,20,10, + 0,434,440,3,26,13,0,435,440,3,42,21,0,436,440,3,40,20,0,437,440,3,30,15, + 0,438,440,3,24,12,0,439,389,1,0,0,0,439,394,1,0,0,0,439,399,1,0,0,0,439, + 404,1,0,0,0,439,405,1,0,0,0,439,406,1,0,0,0,439,407,1,0,0,0,439,408,1, + 0,0,0,439,409,1,0,0,0,439,410,1,0,0,0,439,411,1,0,0,0,439,416,1,0,0,0, + 439,421,1,0,0,0,439,426,1,0,0,0,439,427,1,0,0,0,439,428,1,0,0,0,439,429, + 1,0,0,0,439,430,1,0,0,0,439,431,1,0,0,0,439,432,1,0,0,0,439,433,1,0,0, + 0,439,434,1,0,0,0,439,435,1,0,0,0,439,436,1,0,0,0,439,437,1,0,0,0,439, + 438,1,0,0,0,440,11,1,0,0,0,441,442,5,19,0,0,442,443,3,32,16,0,443,13,1, + 0,0,0,444,445,5,20,0,0,445,446,3,32,16,0,446,15,1,0,0,0,447,448,5,21,0, + 0,448,449,5,22,0,0,449,450,3,32,16,0,450,17,1,0,0,0,451,452,5,23,0,0,452, + 453,3,34,17,0,453,19,1,0,0,0,454,455,5,24,0,0,455,456,3,34,17,0,456,21, + 1,0,0,0,457,458,5,25,0,0,458,459,3,98,49,0,459,460,3,2,1,0,460,461,5,17, + 0,0,461,462,3,120,60,0,462,463,5,18,0,0,463,23,1,0,0,0,464,465,5,26,0, + 0,465,25,1,0,0,0,466,467,5,27,0,0,467,481,3,28,14,0,468,469,5,27,0,0,469, + 470,3,28,14,0,470,471,5,28,0,0,471,472,3,28,14,0,472,481,1,0,0,0,473,474, + 5,27,0,0,474,475,3,28,14,0,475,476,5,28,0,0,476,477,3,28,14,0,477,478, + 5,28,0,0,478,479,3,28,14,0,479,481,1,0,0,0,480,466,1,0,0,0,480,468,1,0, + 0,0,480,473,1,0,0,0,481,27,1,0,0,0,482,483,7,2,0,0,483,29,1,0,0,0,484, + 485,5,29,0,0,485,489,5,17,0,0,486,488,3,116,58,0,487,486,1,0,0,0,488,491, + 1,0,0,0,489,487,1,0,0,0,489,490,1,0,0,0,490,492,1,0,0,0,491,489,1,0,0, + 0,492,493,5,18,0,0,493,31,1,0,0,0,494,495,5,173,0,0,495,33,1,0,0,0,496, + 497,7,3,0,0,497,35,1,0,0,0,498,499,5,175,0,0,499,520,6,18,-1,0,500,501, + 3,32,16,0,501,502,5,265,0,0,502,503,6,18,-1,0,503,520,1,0,0,0,504,505, + 3,32,16,0,505,506,6,18,-1,0,506,520,1,0,0,0,507,508,5,188,0,0,508,509, + 5,30,0,0,509,510,3,32,16,0,510,511,5,31,0,0,511,512,6,18,-1,0,512,520, + 1,0,0,0,513,514,5,189,0,0,514,515,5,30,0,0,515,516,3,34,17,0,516,517,5, + 31,0,0,517,518,6,18,-1,0,518,520,1,0,0,0,519,498,1,0,0,0,519,500,1,0,0, + 0,519,504,1,0,0,0,519,507,1,0,0,0,519,513,1,0,0,0,520,37,1,0,0,0,521,524, + 3,32,16,0,522,524,5,262,0,0,523,521,1,0,0,0,523,522,1,0,0,0,524,39,1,0, + 0,0,525,526,5,267,0,0,526,542,5,289,0,0,527,528,5,267,0,0,528,529,5,289, + 0,0,529,542,5,263,0,0,530,531,5,268,0,0,531,542,5,289,0,0,532,533,5,269, + 0,0,533,542,5,289,0,0,534,535,5,270,0,0,535,542,5,289,0,0,536,542,5,271, + 0,0,537,542,5,272,0,0,538,539,5,273,0,0,539,542,5,263,0,0,540,542,5,32, + 0,0,541,525,1,0,0,0,541,527,1,0,0,0,541,530,1,0,0,0,541,532,1,0,0,0,541, + 534,1,0,0,0,541,536,1,0,0,0,541,537,1,0,0,0,541,538,1,0,0,0,541,540,1, + 0,0,0,542,41,1,0,0,0,543,544,5,33,0,0,544,545,3,138,69,0,545,546,5,34, + 0,0,546,547,3,2,1,0,547,569,1,0,0,0,548,549,5,33,0,0,549,550,3,116,58, + 0,550,551,5,34,0,0,551,552,3,2,1,0,552,569,1,0,0,0,553,554,5,33,0,0,554, + 555,3,176,88,0,555,556,5,34,0,0,556,557,3,2,1,0,557,569,1,0,0,0,558,559, + 5,33,0,0,559,560,3,44,22,0,560,561,5,34,0,0,561,562,3,2,1,0,562,569,1, + 0,0,0,563,564,5,33,0,0,564,565,3,46,23,0,565,566,5,34,0,0,566,567,3,2, + 1,0,567,569,1,0,0,0,568,543,1,0,0,0,568,548,1,0,0,0,568,553,1,0,0,0,568, + 558,1,0,0,0,568,563,1,0,0,0,569,43,1,0,0,0,570,571,5,35,0,0,571,592,3, + 48,24,0,572,573,5,35,0,0,573,574,3,48,24,0,574,575,5,36,0,0,575,576,3, + 6,3,0,576,592,1,0,0,0,577,578,5,35,0,0,578,579,3,48,24,0,579,580,5,36, + 0,0,580,581,5,17,0,0,581,582,3,52,26,0,582,583,5,18,0,0,583,592,1,0,0, + 0,584,585,5,35,0,0,585,586,3,48,24,0,586,587,5,36,0,0,587,588,5,30,0,0, + 588,589,3,292,146,0,589,590,5,31,0,0,590,592,1,0,0,0,591,570,1,0,0,0,591, + 572,1,0,0,0,591,577,1,0,0,0,591,584,1,0,0,0,592,45,1,0,0,0,593,594,5,35, + 0,0,594,595,5,30,0,0,595,596,3,50,25,0,596,597,5,31,0,0,597,598,3,48,24, + 0,598,628,1,0,0,0,599,600,5,35,0,0,600,601,5,30,0,0,601,602,3,50,25,0, + 602,603,5,31,0,0,603,604,3,48,24,0,604,605,5,36,0,0,605,606,3,6,3,0,606, + 628,1,0,0,0,607,608,5,35,0,0,608,609,5,30,0,0,609,610,3,50,25,0,610,611, + 5,31,0,0,611,612,3,48,24,0,612,613,5,36,0,0,613,614,5,17,0,0,614,615,3, + 52,26,0,615,616,5,18,0,0,616,628,1,0,0,0,617,618,5,35,0,0,618,619,5,30, + 0,0,619,620,3,50,25,0,620,621,5,31,0,0,621,622,3,48,24,0,622,623,5,36, + 0,0,623,624,5,30,0,0,624,625,3,292,146,0,625,626,5,31,0,0,626,628,1,0, + 0,0,627,593,1,0,0,0,627,599,1,0,0,0,627,607,1,0,0,0,627,617,1,0,0,0,628, + 47,1,0,0,0,629,630,3,168,84,0,630,49,1,0,0,0,631,632,3,124,62,0,632,633, + 6,25,-1,0,633,638,1,0,0,0,634,635,3,176,88,0,635,636,6,25,-1,0,636,638, + 1,0,0,0,637,631,1,0,0,0,637,634,1,0,0,0,638,51,1,0,0,0,639,640,3,54,27, + 0,640,641,3,56,28,0,641,53,1,0,0,0,642,645,3,298,149,0,643,645,3,40,20, + 0,644,642,1,0,0,0,644,643,1,0,0,0,645,648,1,0,0,0,646,644,1,0,0,0,646, + 647,1,0,0,0,647,55,1,0,0,0,648,646,1,0,0,0,649,650,3,58,29,0,650,651,3, + 60,30,0,651,652,3,2,1,0,652,653,5,36,0,0,653,654,3,298,149,0,654,657,1, + 0,0,0,655,657,3,40,20,0,656,649,1,0,0,0,656,655,1,0,0,0,657,660,1,0,0, + 0,658,656,1,0,0,0,658,659,1,0,0,0,659,57,1,0,0,0,660,658,1,0,0,0,661,662, + 7,4,0,0,662,59,1,0,0,0,663,665,3,62,31,0,664,666,5,261,0,0,665,664,1,0, + 0,0,665,666,1,0,0,0,666,61,1,0,0,0,667,677,3,144,72,0,668,677,3,2,1,0, + 669,677,5,196,0,0,670,677,5,197,0,0,671,672,5,202,0,0,672,673,5,39,0,0, + 673,677,5,264,0,0,674,675,5,202,0,0,675,677,3,116,58,0,676,667,1,0,0,0, + 676,668,1,0,0,0,676,669,1,0,0,0,676,670,1,0,0,0,676,671,1,0,0,0,676,674, + 1,0,0,0,677,63,1,0,0,0,678,679,5,198,0,0,679,680,5,40,0,0,680,685,3,2, + 1,0,681,682,5,198,0,0,682,685,3,2,1,0,683,685,5,198,0,0,684,678,1,0,0, + 0,684,681,1,0,0,0,684,683,1,0,0,0,685,65,1,0,0,0,686,687,5,41,0,0,687, + 688,5,42,0,0,688,689,3,32,16,0,689,690,5,43,0,0,690,691,3,68,34,0,691, + 692,5,44,0,0,692,693,3,0,0,0,693,67,1,0,0,0,694,707,6,34,-1,0,695,696, + 10,5,0,0,696,706,5,186,0,0,697,698,10,4,0,0,698,706,5,187,0,0,699,700, + 10,3,0,0,700,706,5,45,0,0,701,702,10,2,0,0,702,706,5,46,0,0,703,704,10, + 1,0,0,704,706,5,47,0,0,705,695,1,0,0,0,705,697,1,0,0,0,705,699,1,0,0,0, + 705,701,1,0,0,0,705,703,1,0,0,0,706,709,1,0,0,0,707,705,1,0,0,0,707,708, + 1,0,0,0,708,69,1,0,0,0,709,707,1,0,0,0,710,711,5,48,0,0,711,712,5,36,0, + 0,712,713,5,30,0,0,713,714,3,292,146,0,714,715,5,31,0,0,715,71,1,0,0,0, + 716,717,5,49,0,0,717,718,3,2,1,0,718,73,1,0,0,0,719,723,5,50,0,0,720,722, + 3,76,38,0,721,720,1,0,0,0,722,725,1,0,0,0,723,721,1,0,0,0,723,724,1,0, + 0,0,724,726,1,0,0,0,725,723,1,0,0,0,726,727,3,2,1,0,727,728,3,182,91,0, + 728,729,3,78,39,0,729,730,3,80,40,0,730,75,1,0,0,0,731,769,5,51,0,0,732, + 769,5,52,0,0,733,769,5,199,0,0,734,769,5,202,0,0,735,769,5,221,0,0,736, + 769,5,53,0,0,737,769,5,54,0,0,738,769,5,55,0,0,739,769,5,56,0,0,740,769, + 5,244,0,0,741,769,5,15,0,0,742,769,5,224,0,0,743,769,5,57,0,0,744,769, + 5,58,0,0,745,769,5,59,0,0,746,769,5,60,0,0,747,769,5,61,0,0,748,749,5, + 62,0,0,749,769,5,51,0,0,750,751,5,62,0,0,751,769,5,52,0,0,752,753,5,62, + 0,0,753,769,5,63,0,0,754,755,5,62,0,0,755,769,5,64,0,0,756,757,5,62,0, + 0,757,769,5,65,0,0,758,759,5,62,0,0,759,769,5,66,0,0,760,769,5,67,0,0, + 761,769,5,68,0,0,762,769,5,69,0,0,763,764,5,70,0,0,764,765,5,30,0,0,765, + 766,3,32,16,0,766,767,5,31,0,0,767,769,1,0,0,0,768,731,1,0,0,0,768,732, + 1,0,0,0,768,733,1,0,0,0,768,734,1,0,0,0,768,735,1,0,0,0,768,736,1,0,0, + 0,768,737,1,0,0,0,768,738,1,0,0,0,768,739,1,0,0,0,768,740,1,0,0,0,768, + 741,1,0,0,0,768,742,1,0,0,0,768,743,1,0,0,0,768,744,1,0,0,0,768,745,1, + 0,0,0,768,746,1,0,0,0,768,747,1,0,0,0,768,748,1,0,0,0,768,750,1,0,0,0, + 768,752,1,0,0,0,768,754,1,0,0,0,768,756,1,0,0,0,768,758,1,0,0,0,768,760, + 1,0,0,0,768,761,1,0,0,0,768,762,1,0,0,0,768,763,1,0,0,0,769,77,1,0,0,0, + 770,774,1,0,0,0,771,772,5,71,0,0,772,774,3,124,62,0,773,770,1,0,0,0,773, + 771,1,0,0,0,774,79,1,0,0,0,775,779,1,0,0,0,776,777,5,72,0,0,777,779,3, + 84,42,0,778,775,1,0,0,0,778,776,1,0,0,0,779,81,1,0,0,0,780,782,3,198,99, + 0,781,780,1,0,0,0,782,785,1,0,0,0,783,781,1,0,0,0,783,784,1,0,0,0,784, + 83,1,0,0,0,785,783,1,0,0,0,786,787,3,124,62,0,787,788,5,28,0,0,788,790, + 1,0,0,0,789,786,1,0,0,0,790,793,1,0,0,0,791,789,1,0,0,0,791,792,1,0,0, + 0,792,794,1,0,0,0,793,791,1,0,0,0,794,795,3,124,62,0,795,85,1,0,0,0,796, + 797,7,5,0,0,797,87,1,0,0,0,798,799,3,86,43,0,799,800,3,32,16,0,800,801, + 5,264,0,0,801,902,1,0,0,0,802,803,3,86,43,0,803,804,3,32,16,0,804,902, + 1,0,0,0,805,806,3,86,43,0,806,807,3,32,16,0,807,808,5,75,0,0,808,809,3, + 32,16,0,809,810,5,264,0,0,810,902,1,0,0,0,811,812,3,86,43,0,812,813,3, + 32,16,0,813,814,5,75,0,0,814,815,3,32,16,0,815,902,1,0,0,0,816,817,3,86, + 43,0,817,818,3,32,16,0,818,819,5,75,0,0,819,820,3,32,16,0,820,821,5,28, + 0,0,821,822,3,32,16,0,822,823,5,264,0,0,823,902,1,0,0,0,824,825,3,86,43, + 0,825,826,3,32,16,0,826,827,5,75,0,0,827,828,3,32,16,0,828,829,5,28,0, + 0,829,830,3,32,16,0,830,902,1,0,0,0,831,832,3,86,43,0,832,833,3,32,16, + 0,833,834,5,28,0,0,834,835,3,32,16,0,835,836,5,75,0,0,836,837,3,32,16, + 0,837,838,5,264,0,0,838,902,1,0,0,0,839,840,3,86,43,0,840,841,3,32,16, + 0,841,842,5,28,0,0,842,843,3,32,16,0,843,844,5,75,0,0,844,845,3,32,16, + 0,845,902,1,0,0,0,846,847,3,86,43,0,847,848,3,32,16,0,848,849,5,28,0,0, + 849,850,3,32,16,0,850,851,5,75,0,0,851,852,3,32,16,0,852,853,5,28,0,0, + 853,854,3,32,16,0,854,855,5,264,0,0,855,902,1,0,0,0,856,857,3,86,43,0, + 857,858,3,32,16,0,858,859,5,28,0,0,859,860,3,32,16,0,860,861,5,75,0,0, + 861,862,3,32,16,0,862,863,5,28,0,0,863,864,3,32,16,0,864,902,1,0,0,0,865, + 866,3,86,43,0,866,867,3,32,16,0,867,868,5,263,0,0,868,902,1,0,0,0,869, + 870,3,86,43,0,870,871,3,32,16,0,871,872,5,75,0,0,872,873,3,32,16,0,873, + 874,5,263,0,0,874,902,1,0,0,0,875,876,3,86,43,0,876,877,3,32,16,0,877, + 878,5,75,0,0,878,879,3,32,16,0,879,880,5,28,0,0,880,881,3,32,16,0,881, + 882,5,263,0,0,882,902,1,0,0,0,883,884,3,86,43,0,884,885,3,32,16,0,885, + 886,5,28,0,0,886,887,3,32,16,0,887,888,5,75,0,0,888,889,3,32,16,0,889, + 890,5,263,0,0,890,902,1,0,0,0,891,892,3,86,43,0,892,893,3,32,16,0,893, + 894,5,28,0,0,894,895,3,32,16,0,895,896,5,75,0,0,896,897,3,32,16,0,897, + 898,5,28,0,0,898,899,3,32,16,0,899,900,5,263,0,0,900,902,1,0,0,0,901,798, + 1,0,0,0,901,802,1,0,0,0,901,805,1,0,0,0,901,811,1,0,0,0,901,816,1,0,0, + 0,901,824,1,0,0,0,901,831,1,0,0,0,901,839,1,0,0,0,901,846,1,0,0,0,901, + 856,1,0,0,0,901,865,1,0,0,0,901,869,1,0,0,0,901,875,1,0,0,0,901,883,1, + 0,0,0,901,891,1,0,0,0,902,89,1,0,0,0,903,907,5,21,0,0,904,906,3,92,46, + 0,905,904,1,0,0,0,906,909,1,0,0,0,907,905,1,0,0,0,907,908,1,0,0,0,908, + 910,1,0,0,0,909,907,1,0,0,0,910,911,3,2,1,0,911,912,3,94,47,0,912,913, + 5,180,0,0,913,914,5,36,0,0,914,915,5,30,0,0,915,916,3,292,146,0,916,917, + 5,31,0,0,917,918,3,94,47,0,918,930,1,0,0,0,919,923,5,21,0,0,920,922,3, + 92,46,0,921,920,1,0,0,0,922,925,1,0,0,0,923,921,1,0,0,0,923,924,1,0,0, + 0,924,926,1,0,0,0,925,923,1,0,0,0,926,927,3,2,1,0,927,928,3,94,47,0,928, + 930,1,0,0,0,929,903,1,0,0,0,929,919,1,0,0,0,930,91,1,0,0,0,931,932,5,76, + 0,0,932,93,1,0,0,0,933,936,1,0,0,0,934,936,5,298,0,0,935,933,1,0,0,0,935, + 934,1,0,0,0,936,95,1,0,0,0,937,938,7,6,0,0,938,97,1,0,0,0,939,941,3,96, + 48,0,940,939,1,0,0,0,941,944,1,0,0,0,942,940,1,0,0,0,942,943,1,0,0,0,943, + 99,1,0,0,0,944,942,1,0,0,0,945,971,3,102,51,0,946,947,5,280,0,0,947,948, + 3,168,84,0,948,949,6,50,-1,0,949,971,1,0,0,0,950,951,5,286,0,0,951,952, + 3,178,89,0,952,953,6,50,-1,0,953,971,1,0,0,0,954,955,5,286,0,0,955,956, + 3,174,87,0,956,957,6,50,-1,0,957,971,1,0,0,0,958,959,5,284,0,0,959,960, + 3,124,62,0,960,961,6,50,-1,0,961,971,1,0,0,0,962,963,5,281,0,0,963,964, + 3,104,52,0,964,965,6,50,-1,0,965,971,1,0,0,0,966,967,5,287,0,0,967,968, + 3,50,25,0,968,969,6,50,-1,0,969,971,1,0,0,0,970,945,1,0,0,0,970,946,1, + 0,0,0,970,950,1,0,0,0,970,954,1,0,0,0,970,958,1,0,0,0,970,962,1,0,0,0, + 970,966,1,0,0,0,971,101,1,0,0,0,972,973,5,275,0,0,973,1051,6,51,-1,0,974, + 975,5,276,0,0,975,976,3,32,16,0,976,977,6,51,-1,0,977,1051,1,0,0,0,978, + 979,5,276,0,0,979,980,3,0,0,0,980,981,6,51,-1,0,981,1051,1,0,0,0,982,983, + 5,277,0,0,983,984,3,32,16,0,984,985,6,51,-1,0,985,1051,1,0,0,0,986,987, + 5,278,0,0,987,988,3,34,17,0,988,989,6,51,-1,0,989,1051,1,0,0,0,990,991, + 5,279,0,0,991,992,3,36,18,0,992,993,6,51,-1,0,993,1051,1,0,0,0,994,995, + 5,279,0,0,995,996,3,34,17,0,996,997,6,51,-1,0,997,1051,1,0,0,0,998,999, + 5,279,0,0,999,1000,5,30,0,0,1000,1001,3,292,146,0,1001,1002,5,31,0,0,1002, + 1003,6,51,-1,0,1003,1051,1,0,0,0,1004,1005,5,279,0,0,1005,1006,5,84,0, + 0,1006,1007,5,30,0,0,1007,1008,3,292,146,0,1008,1009,5,31,0,0,1009,1010, + 6,51,-1,0,1010,1051,1,0,0,0,1011,1012,5,282,0,0,1012,1013,3,32,16,0,1013, + 1014,6,51,-1,0,1014,1051,1,0,0,0,1015,1016,5,282,0,0,1016,1017,3,0,0,0, + 1017,1018,6,51,-1,0,1018,1051,1,0,0,0,1019,1020,5,285,0,0,1020,1021,3, + 6,3,0,1021,1022,6,51,-1,0,1022,1051,1,0,0,0,1023,1024,5,285,0,0,1024,1025, + 5,224,0,0,1025,1026,5,30,0,0,1026,1027,3,6,3,0,1027,1028,5,31,0,0,1028, + 1029,6,51,-1,0,1029,1051,1,0,0,0,1030,1031,5,285,0,0,1031,1032,5,84,0, + 0,1032,1033,5,30,0,0,1033,1034,3,292,146,0,1034,1035,5,31,0,0,1035,1036, + 6,51,-1,0,1036,1051,1,0,0,0,1037,1038,5,287,0,0,1038,1039,3,32,16,0,1039, + 1040,6,51,-1,0,1040,1051,1,0,0,0,1041,1042,5,283,0,0,1042,1048,6,51,-1, + 0,1043,1044,5,30,0,0,1044,1045,3,106,53,0,1045,1046,5,31,0,0,1046,1049, + 1,0,0,0,1047,1049,5,85,0,0,1048,1043,1,0,0,0,1048,1047,1,0,0,0,1049,1051, + 1,0,0,0,1050,972,1,0,0,0,1050,974,1,0,0,0,1050,978,1,0,0,0,1050,982,1, + 0,0,0,1050,986,1,0,0,0,1050,990,1,0,0,0,1050,994,1,0,0,0,1050,998,1,0, + 0,0,1050,1004,1,0,0,0,1050,1011,1,0,0,0,1050,1015,1,0,0,0,1050,1019,1, + 0,0,0,1050,1023,1,0,0,0,1050,1030,1,0,0,0,1050,1037,1,0,0,0,1050,1041, + 1,0,0,0,1051,103,1,0,0,0,1052,1053,3,170,85,0,1053,1054,3,138,69,0,1054, + 1055,3,112,56,0,1055,1056,6,52,-1,0,1056,105,1,0,0,0,1057,1082,1,0,0,0, + 1058,1059,3,0,0,0,1059,1060,6,53,-1,0,1060,1065,1,0,0,0,1061,1062,3,32, + 16,0,1062,1063,6,53,-1,0,1063,1065,1,0,0,0,1064,1058,1,0,0,0,1064,1061, + 1,0,0,0,1065,1066,1,0,0,0,1066,1067,5,28,0,0,1067,1069,1,0,0,0,1068,1064, + 1,0,0,0,1069,1072,1,0,0,0,1070,1068,1,0,0,0,1070,1071,1,0,0,0,1071,1079, + 1,0,0,0,1072,1070,1,0,0,0,1073,1074,3,0,0,0,1074,1075,6,53,-1,0,1075,1080, + 1,0,0,0,1076,1077,3,32,16,0,1077,1078,6,53,-1,0,1078,1080,1,0,0,0,1079, + 1073,1,0,0,0,1079,1076,1,0,0,0,1080,1082,1,0,0,0,1081,1057,1,0,0,0,1081, + 1070,1,0,0,0,1082,107,1,0,0,0,1083,1090,5,86,0,0,1084,1085,3,138,69,0, + 1085,1086,6,54,-1,0,1086,1087,5,28,0,0,1087,1089,1,0,0,0,1088,1084,1,0, + 0,0,1089,1092,1,0,0,0,1090,1088,1,0,0,0,1090,1091,1,0,0,0,1091,1093,1, + 0,0,0,1092,1090,1,0,0,0,1093,1094,3,138,69,0,1094,1095,6,54,-1,0,1095, + 1096,5,87,0,0,1096,109,1,0,0,0,1097,1104,5,42,0,0,1098,1099,3,146,73,0, + 1099,1100,6,55,-1,0,1100,1101,5,28,0,0,1101,1103,1,0,0,0,1102,1098,1,0, + 0,0,1103,1106,1,0,0,0,1104,1102,1,0,0,0,1104,1105,1,0,0,0,1105,1107,1, + 0,0,0,1106,1104,1,0,0,0,1107,1108,3,146,73,0,1108,1109,6,55,-1,0,1109, + 1110,5,43,0,0,1110,111,1,0,0,0,1111,1118,5,30,0,0,1112,1113,3,114,57,0, + 1113,1114,6,56,-1,0,1114,1115,5,28,0,0,1115,1117,1,0,0,0,1116,1112,1,0, + 0,0,1117,1120,1,0,0,0,1118,1116,1,0,0,0,1118,1119,1,0,0,0,1119,1121,1, + 0,0,0,1120,1118,1,0,0,0,1121,1122,3,114,57,0,1122,1123,6,56,-1,0,1123, + 1124,5,31,0,0,1124,1127,1,0,0,0,1125,1127,5,85,0,0,1126,1111,1,0,0,0,1126, + 1125,1,0,0,0,1127,113,1,0,0,0,1128,1129,5,177,0,0,1129,1139,6,57,-1,0, + 1130,1131,3,230,115,0,1131,1132,3,138,69,0,1132,1134,3,226,113,0,1133, + 1135,3,0,0,0,1134,1133,1,0,0,0,1134,1135,1,0,0,0,1135,1136,1,0,0,0,1136, + 1137,6,57,-1,0,1137,1139,1,0,0,0,1138,1128,1,0,0,0,1138,1130,1,0,0,0,1139, + 115,1,0,0,0,1140,1141,5,42,0,0,1141,1142,3,2,1,0,1142,1143,5,43,0,0,1143, + 1144,3,118,59,0,1144,1145,6,58,-1,0,1145,1178,1,0,0,0,1146,1147,5,42,0, + 0,1147,1148,3,174,87,0,1148,1149,5,43,0,0,1149,1150,3,118,59,0,1150,1151, + 6,58,-1,0,1151,1178,1,0,0,0,1152,1153,5,42,0,0,1153,1154,5,262,0,0,1154, + 1155,5,43,0,0,1155,1156,3,118,59,0,1156,1157,6,58,-1,0,1157,1178,1,0,0, + 0,1158,1159,5,42,0,0,1159,1160,5,198,0,0,1160,1161,3,2,1,0,1161,1162,5, + 43,0,0,1162,1163,3,118,59,0,1163,1164,6,58,-1,0,1164,1178,1,0,0,0,1165, + 1166,3,118,59,0,1166,1167,6,58,-1,0,1167,1178,1,0,0,0,1168,1169,3,174, + 87,0,1169,1170,6,58,-1,0,1170,1178,1,0,0,0,1171,1172,5,257,0,0,1172,1178, + 6,58,-1,0,1173,1174,5,258,0,0,1174,1178,6,58,-1,0,1175,1176,5,259,0,0, + 1176,1178,6,58,-1,0,1177,1140,1,0,0,0,1177,1146,1,0,0,0,1177,1152,1,0, + 0,0,1177,1158,1,0,0,0,1177,1165,1,0,0,0,1177,1168,1,0,0,0,1177,1171,1, + 0,0,0,1177,1173,1,0,0,0,1177,1175,1,0,0,0,1178,117,1,0,0,0,1179,1180,3, + 2,1,0,1180,1181,6,59,-1,0,1181,1182,5,88,0,0,1182,1184,1,0,0,0,1183,1179, + 1,0,0,0,1184,1187,1,0,0,0,1185,1183,1,0,0,0,1185,1186,1,0,0,0,1186,1188, + 1,0,0,0,1187,1185,1,0,0,0,1188,1189,3,2,1,0,1189,1190,6,59,-1,0,1190,119, + 1,0,0,0,1191,1193,3,122,61,0,1192,1191,1,0,0,0,1193,1196,1,0,0,0,1194, + 1192,1,0,0,0,1194,1195,1,0,0,0,1195,121,1,0,0,0,1196,1194,1,0,0,0,1197, + 1198,5,180,0,0,1198,1199,5,89,0,0,1199,1203,3,32,16,0,1200,1203,3,152, + 76,0,1201,1203,3,324,162,0,1202,1197,1,0,0,0,1202,1200,1,0,0,0,1202,1201, + 1,0,0,0,1203,123,1,0,0,0,1204,1205,3,116,58,0,1205,1206,6,62,-1,0,1206, + 1222,1,0,0,0,1207,1208,5,42,0,0,1208,1209,3,2,1,0,1209,1210,5,43,0,0,1210, + 1211,6,62,-1,0,1211,1222,1,0,0,0,1212,1213,5,42,0,0,1213,1214,5,198,0, + 0,1214,1215,3,2,1,0,1215,1216,5,43,0,0,1216,1217,6,62,-1,0,1217,1222,1, + 0,0,0,1218,1219,3,138,69,0,1219,1220,6,62,-1,0,1220,1222,1,0,0,0,1221, + 1204,1,0,0,0,1221,1207,1,0,0,0,1221,1212,1,0,0,0,1221,1218,1,0,0,0,1222, + 125,1,0,0,0,1223,1232,1,0,0,0,1224,1228,3,130,65,0,1225,1227,3,128,64, + 0,1226,1225,1,0,0,0,1227,1230,1,0,0,0,1228,1226,1,0,0,0,1228,1229,1,0, + 0,0,1229,1232,1,0,0,0,1230,1228,1,0,0,0,1231,1223,1,0,0,0,1231,1224,1, + 0,0,0,1232,127,1,0,0,0,1233,1251,5,262,0,0,1234,1251,5,261,0,0,1235,1236, + 5,42,0,0,1236,1237,3,32,16,0,1237,1238,5,43,0,0,1238,1251,1,0,0,0,1239, + 1240,5,42,0,0,1240,1241,3,32,16,0,1241,1242,5,266,0,0,1242,1243,3,32,16, + 0,1243,1244,5,43,0,0,1244,1251,1,0,0,0,1245,1246,5,42,0,0,1246,1247,5, + 266,0,0,1247,1248,3,32,16,0,1248,1249,5,43,0,0,1249,1251,1,0,0,0,1250, + 1233,1,0,0,0,1250,1234,1,0,0,0,1250,1235,1,0,0,0,1250,1239,1,0,0,0,1250, + 1245,1,0,0,0,1251,129,1,0,0,0,1252,1345,1,0,0,0,1253,1254,5,203,0,0,1254, + 1255,5,30,0,0,1255,1256,3,6,3,0,1256,1257,5,28,0,0,1257,1258,3,6,3,0,1258, + 1259,5,28,0,0,1259,1260,3,6,3,0,1260,1261,5,28,0,0,1261,1262,3,6,3,0,1262, + 1263,5,31,0,0,1263,1345,1,0,0,0,1264,1265,5,203,0,0,1265,1266,5,30,0,0, + 1266,1267,3,6,3,0,1267,1268,5,28,0,0,1268,1269,3,6,3,0,1269,1270,5,31, + 0,0,1270,1345,1,0,0,0,1271,1272,5,204,0,0,1272,1273,5,205,0,0,1273,1274, + 5,42,0,0,1274,1275,3,32,16,0,1275,1276,5,43,0,0,1276,1345,1,0,0,0,1277, + 1278,5,204,0,0,1278,1279,5,206,0,0,1279,1280,5,42,0,0,1280,1281,3,32,16, + 0,1281,1282,5,43,0,0,1282,1283,3,126,63,0,1283,1345,1,0,0,0,1284,1345, + 5,207,0,0,1285,1345,5,208,0,0,1286,1345,5,209,0,0,1287,1345,5,201,0,0, + 1288,1345,5,183,0,0,1289,1345,5,184,0,0,1290,1345,5,185,0,0,1291,1345, + 5,186,0,0,1292,1345,5,187,0,0,1293,1345,5,188,0,0,1294,1345,5,189,0,0, + 1295,1345,5,210,0,0,1296,1345,5,190,0,0,1297,1345,5,191,0,0,1298,1345, + 5,192,0,0,1299,1345,5,193,0,0,1300,1345,5,211,0,0,1301,1345,5,212,0,0, + 1302,1345,5,213,0,0,1303,1345,5,214,0,0,1304,1345,5,215,0,0,1305,1345, + 5,216,0,0,1306,1345,5,217,0,0,1307,1308,5,218,0,0,1308,1345,3,132,66,0, + 1309,1310,5,219,0,0,1310,1345,3,132,66,0,1311,1345,5,220,0,0,1312,1313, + 5,221,0,0,1313,1345,3,132,66,0,1314,1315,5,222,0,0,1315,1345,3,134,67, + 0,1316,1317,5,222,0,0,1317,1318,3,134,67,0,1318,1319,5,28,0,0,1319,1320, + 3,6,3,0,1320,1345,1,0,0,0,1321,1345,5,194,0,0,1322,1345,5,195,0,0,1323, + 1324,5,90,0,0,1324,1345,5,184,0,0,1325,1326,5,90,0,0,1326,1345,5,185,0, + 0,1327,1328,5,90,0,0,1328,1345,5,186,0,0,1329,1330,5,90,0,0,1330,1345, + 5,187,0,0,1331,1332,5,62,0,0,1332,1345,5,220,0,0,1333,1345,5,223,0,0,1334, + 1335,5,224,0,0,1335,1345,5,213,0,0,1336,1345,5,225,0,0,1337,1338,5,207, + 0,0,1338,1345,5,183,0,0,1339,1345,5,226,0,0,1340,1345,5,228,0,0,1341,1342, + 5,34,0,0,1342,1345,5,227,0,0,1343,1345,3,2,1,0,1344,1252,1,0,0,0,1344, + 1253,1,0,0,0,1344,1264,1,0,0,0,1344,1271,1,0,0,0,1344,1277,1,0,0,0,1344, + 1284,1,0,0,0,1344,1285,1,0,0,0,1344,1286,1,0,0,0,1344,1287,1,0,0,0,1344, + 1288,1,0,0,0,1344,1289,1,0,0,0,1344,1290,1,0,0,0,1344,1291,1,0,0,0,1344, + 1292,1,0,0,0,1344,1293,1,0,0,0,1344,1294,1,0,0,0,1344,1295,1,0,0,0,1344, + 1296,1,0,0,0,1344,1297,1,0,0,0,1344,1298,1,0,0,0,1344,1299,1,0,0,0,1344, + 1300,1,0,0,0,1344,1301,1,0,0,0,1344,1302,1,0,0,0,1344,1303,1,0,0,0,1344, + 1304,1,0,0,0,1344,1305,1,0,0,0,1344,1306,1,0,0,0,1344,1307,1,0,0,0,1344, + 1309,1,0,0,0,1344,1311,1,0,0,0,1344,1312,1,0,0,0,1344,1314,1,0,0,0,1344, + 1316,1,0,0,0,1344,1321,1,0,0,0,1344,1322,1,0,0,0,1344,1323,1,0,0,0,1344, + 1325,1,0,0,0,1344,1327,1,0,0,0,1344,1329,1,0,0,0,1344,1331,1,0,0,0,1344, + 1333,1,0,0,0,1344,1334,1,0,0,0,1344,1336,1,0,0,0,1344,1337,1,0,0,0,1344, + 1339,1,0,0,0,1344,1340,1,0,0,0,1344,1341,1,0,0,0,1344,1343,1,0,0,0,1345, + 131,1,0,0,0,1346,1354,1,0,0,0,1347,1348,5,30,0,0,1348,1349,5,91,0,0,1349, + 1350,5,36,0,0,1350,1351,3,32,16,0,1351,1352,5,31,0,0,1352,1354,1,0,0,0, + 1353,1346,1,0,0,0,1353,1347,1,0,0,0,1354,133,1,0,0,0,1355,1364,1,0,0,0, + 1356,1360,3,136,68,0,1357,1359,7,7,0,0,1358,1357,1,0,0,0,1359,1362,1,0, + 0,0,1360,1358,1,0,0,0,1360,1361,1,0,0,0,1361,1364,1,0,0,0,1362,1360,1, + 0,0,0,1363,1355,1,0,0,0,1363,1356,1,0,0,0,1364,135,1,0,0,0,1365,1366,7, + 8,0,0,1366,137,1,0,0,0,1367,1368,3,142,71,0,1368,1374,6,69,-1,0,1369,1370, + 3,140,70,0,1370,1371,6,69,-1,0,1371,1373,1,0,0,0,1372,1369,1,0,0,0,1373, + 1376,1,0,0,0,1374,1372,1,0,0,0,1374,1375,1,0,0,0,1375,139,1,0,0,0,1376, + 1374,1,0,0,0,1377,1378,5,261,0,0,1378,1407,6,70,-1,0,1379,1380,5,42,0, + 0,1380,1381,5,43,0,0,1381,1407,6,70,-1,0,1382,1383,3,110,55,0,1383,1384, + 6,70,-1,0,1384,1407,1,0,0,0,1385,1386,5,260,0,0,1386,1407,6,70,-1,0,1387, + 1388,5,262,0,0,1388,1407,6,70,-1,0,1389,1390,5,92,0,0,1390,1407,6,70,-1, + 0,1391,1392,5,93,0,0,1392,1393,5,30,0,0,1393,1394,3,124,62,0,1394,1395, + 5,31,0,0,1395,1396,6,70,-1,0,1396,1407,1,0,0,0,1397,1398,5,94,0,0,1398, + 1399,5,30,0,0,1399,1400,3,124,62,0,1400,1401,5,31,0,0,1401,1402,6,70,-1, + 0,1402,1407,1,0,0,0,1403,1404,3,108,54,0,1404,1405,6,70,-1,0,1405,1407, + 1,0,0,0,1406,1377,1,0,0,0,1406,1379,1,0,0,0,1406,1382,1,0,0,0,1406,1385, + 1,0,0,0,1406,1387,1,0,0,0,1406,1389,1,0,0,0,1406,1391,1,0,0,0,1406,1397, + 1,0,0,0,1406,1403,1,0,0,0,1407,141,1,0,0,0,1408,1409,5,39,0,0,1409,1410, + 3,116,58,0,1410,1411,6,71,-1,0,1411,1467,1,0,0,0,1412,1413,5,197,0,0,1413, + 1467,6,71,-1,0,1414,1415,5,199,0,0,1415,1416,5,39,0,0,1416,1417,3,116, + 58,0,1417,1418,6,71,-1,0,1418,1467,1,0,0,0,1419,1420,5,200,0,0,1420,1421, + 3,116,58,0,1421,1422,6,71,-1,0,1422,1467,1,0,0,0,1423,1424,5,226,0,0,1424, + 1425,3,170,85,0,1425,1426,3,138,69,0,1426,1427,5,262,0,0,1427,1428,3,112, + 56,0,1428,1429,6,71,-1,0,1429,1467,1,0,0,0,1430,1431,5,253,0,0,1431,1432, + 3,32,16,0,1432,1433,6,71,-1,0,1433,1467,1,0,0,0,1434,1435,5,252,0,0,1435, + 1436,3,32,16,0,1436,1437,6,71,-1,0,1437,1467,1,0,0,0,1438,1439,5,253,0, + 0,1439,1440,3,2,1,0,1440,1441,6,71,-1,0,1441,1467,1,0,0,0,1442,1443,5, + 252,0,0,1443,1444,3,2,1,0,1444,1445,6,71,-1,0,1445,1467,1,0,0,0,1446,1447, + 5,254,0,0,1447,1467,6,71,-1,0,1448,1449,5,201,0,0,1449,1467,6,71,-1,0, + 1450,1451,3,148,74,0,1451,1452,6,71,-1,0,1452,1467,1,0,0,0,1453,1454,3, + 150,75,0,1454,1455,6,71,-1,0,1455,1467,1,0,0,0,1456,1457,3,144,72,0,1457, + 1458,6,71,-1,0,1458,1467,1,0,0,0,1459,1460,3,2,1,0,1460,1461,6,71,-1,0, + 1461,1467,1,0,0,0,1462,1463,5,177,0,0,1463,1464,3,138,69,0,1464,1465,6, + 71,-1,0,1465,1467,1,0,0,0,1466,1408,1,0,0,0,1466,1412,1,0,0,0,1466,1414, + 1,0,0,0,1466,1419,1,0,0,0,1466,1423,1,0,0,0,1466,1430,1,0,0,0,1466,1434, + 1,0,0,0,1466,1438,1,0,0,0,1466,1442,1,0,0,0,1466,1446,1,0,0,0,1466,1448, + 1,0,0,0,1466,1450,1,0,0,0,1466,1453,1,0,0,0,1466,1456,1,0,0,0,1466,1459, + 1,0,0,0,1466,1462,1,0,0,0,1467,143,1,0,0,0,1468,1469,5,181,0,0,1469,1507, + 6,72,-1,0,1470,1471,5,182,0,0,1471,1507,6,72,-1,0,1472,1473,5,183,0,0, + 1473,1507,6,72,-1,0,1474,1475,5,184,0,0,1475,1507,6,72,-1,0,1476,1477, + 5,185,0,0,1477,1507,6,72,-1,0,1478,1479,5,186,0,0,1479,1507,6,72,-1,0, + 1480,1481,5,187,0,0,1481,1507,6,72,-1,0,1482,1483,5,188,0,0,1483,1507, + 6,72,-1,0,1484,1485,5,189,0,0,1485,1507,6,72,-1,0,1486,1487,5,190,0,0, + 1487,1507,6,72,-1,0,1488,1489,5,191,0,0,1489,1507,6,72,-1,0,1490,1491, + 5,192,0,0,1491,1507,6,72,-1,0,1492,1493,5,193,0,0,1493,1507,6,72,-1,0, + 1494,1495,5,90,0,0,1495,1496,5,184,0,0,1496,1507,6,72,-1,0,1497,1498,5, + 90,0,0,1498,1499,5,185,0,0,1499,1507,6,72,-1,0,1500,1501,5,90,0,0,1501, + 1502,5,186,0,0,1502,1507,6,72,-1,0,1503,1504,5,90,0,0,1504,1505,5,187, + 0,0,1505,1507,6,72,-1,0,1506,1468,1,0,0,0,1506,1470,1,0,0,0,1506,1472, + 1,0,0,0,1506,1474,1,0,0,0,1506,1476,1,0,0,0,1506,1478,1,0,0,0,1506,1480, + 1,0,0,0,1506,1482,1,0,0,0,1506,1484,1,0,0,0,1506,1486,1,0,0,0,1506,1488, + 1,0,0,0,1506,1490,1,0,0,0,1506,1492,1,0,0,0,1506,1494,1,0,0,0,1506,1497, + 1,0,0,0,1506,1500,1,0,0,0,1506,1503,1,0,0,0,1507,145,1,0,0,0,1508,1523, + 1,0,0,0,1509,1523,5,177,0,0,1510,1511,3,32,16,0,1511,1512,6,73,-1,0,1512, + 1523,1,0,0,0,1513,1514,3,32,16,0,1514,1515,5,177,0,0,1515,1516,3,32,16, + 0,1516,1517,6,73,-1,0,1517,1523,1,0,0,0,1518,1519,3,32,16,0,1519,1520, + 5,177,0,0,1520,1521,6,73,-1,0,1521,1523,1,0,0,0,1522,1508,1,0,0,0,1522, + 1509,1,0,0,0,1522,1510,1,0,0,0,1522,1513,1,0,0,0,1522,1518,1,0,0,0,1523, + 147,1,0,0,0,1524,1525,5,1,0,0,1525,1526,5,194,0,0,1526,1527,6,74,-1,0, + 1527,149,1,0,0,0,1528,1532,5,1,0,0,1529,1530,5,90,0,0,1530,1533,5,194, + 0,0,1531,1533,5,195,0,0,1532,1529,1,0,0,0,1532,1531,1,0,0,0,1533,1534, + 1,0,0,0,1534,1535,6,75,-1,0,1535,151,1,0,0,0,1536,1537,5,294,0,0,1537, + 1538,3,166,83,0,1538,1539,3,124,62,0,1539,1540,5,30,0,0,1540,1541,3,158, + 79,0,1541,1542,5,31,0,0,1542,1584,1,0,0,0,1543,1544,5,294,0,0,1544,1545, + 3,166,83,0,1545,1546,3,124,62,0,1546,1547,5,36,0,0,1547,1548,5,17,0,0, + 1548,1549,3,52,26,0,1549,1550,5,18,0,0,1550,1584,1,0,0,0,1551,1552,5,294, + 0,0,1552,1553,3,166,83,0,1553,1554,3,124,62,0,1554,1584,1,0,0,0,1555,1556, + 5,295,0,0,1556,1557,3,166,83,0,1557,1559,5,36,0,0,1558,1560,5,84,0,0,1559, + 1558,1,0,0,0,1559,1560,1,0,0,0,1560,1561,1,0,0,0,1561,1562,5,30,0,0,1562, + 1563,3,292,146,0,1563,1564,5,31,0,0,1564,1584,1,0,0,0,1565,1566,5,295, + 0,0,1566,1567,3,166,83,0,1567,1568,5,84,0,0,1568,1569,5,30,0,0,1569,1570, + 3,292,146,0,1570,1571,5,31,0,0,1571,1584,1,0,0,0,1572,1573,5,295,0,0,1573, + 1574,3,166,83,0,1574,1575,3,6,3,0,1575,1584,1,0,0,0,1576,1577,5,295,0, + 0,1577,1578,3,166,83,0,1578,1579,5,36,0,0,1579,1580,5,17,0,0,1580,1581, + 3,154,77,0,1581,1582,5,18,0,0,1582,1584,1,0,0,0,1583,1536,1,0,0,0,1583, + 1543,1,0,0,0,1583,1551,1,0,0,0,1583,1555,1,0,0,0,1583,1565,1,0,0,0,1583, + 1572,1,0,0,0,1583,1576,1,0,0,0,1584,153,1,0,0,0,1585,1596,1,0,0,0,1586, + 1587,3,156,78,0,1587,1588,5,28,0,0,1588,1590,1,0,0,0,1589,1586,1,0,0,0, + 1590,1593,1,0,0,0,1591,1589,1,0,0,0,1591,1592,1,0,0,0,1592,1594,1,0,0, + 0,1593,1591,1,0,0,0,1594,1596,3,156,78,0,1595,1585,1,0,0,0,1595,1591,1, + 0,0,0,1596,155,1,0,0,0,1597,1598,5,39,0,0,1598,1599,5,264,0,0,1599,1600, + 5,36,0,0,1600,1601,5,17,0,0,1601,1602,3,56,28,0,1602,1603,5,18,0,0,1603, + 1611,1,0,0,0,1604,1605,3,124,62,0,1605,1606,5,36,0,0,1606,1607,5,17,0, + 0,1607,1608,3,56,28,0,1608,1609,5,18,0,0,1609,1611,1,0,0,0,1610,1597,1, + 0,0,0,1610,1604,1,0,0,0,1611,157,1,0,0,0,1612,1613,3,160,80,0,1613,1614, + 5,28,0,0,1614,1616,1,0,0,0,1615,1612,1,0,0,0,1616,1619,1,0,0,0,1617,1615, + 1,0,0,0,1617,1618,1,0,0,0,1618,1620,1,0,0,0,1619,1617,1,0,0,0,1620,1621, + 3,160,80,0,1621,159,1,0,0,0,1622,1623,3,6,3,0,1623,1624,5,36,0,0,1624, + 1625,3,164,82,0,1625,161,1,0,0,0,1626,1627,7,9,0,0,1627,163,1,0,0,0,1628, + 1663,3,162,81,0,1629,1663,3,32,16,0,1630,1631,5,186,0,0,1631,1632,5,30, + 0,0,1632,1633,3,32,16,0,1633,1634,5,31,0,0,1634,1663,1,0,0,0,1635,1663, + 3,6,3,0,1636,1637,3,116,58,0,1637,1638,5,30,0,0,1638,1639,5,184,0,0,1639, + 1640,5,75,0,0,1640,1641,3,32,16,0,1641,1642,5,31,0,0,1642,1663,1,0,0,0, + 1643,1644,3,116,58,0,1644,1645,5,30,0,0,1645,1646,5,185,0,0,1646,1647, + 5,75,0,0,1647,1648,3,32,16,0,1648,1649,5,31,0,0,1649,1663,1,0,0,0,1650, + 1651,3,116,58,0,1651,1652,5,30,0,0,1652,1653,5,186,0,0,1653,1654,5,75, + 0,0,1654,1655,3,32,16,0,1655,1656,5,31,0,0,1656,1663,1,0,0,0,1657,1658, + 3,116,58,0,1658,1659,5,30,0,0,1659,1660,3,32,16,0,1660,1661,5,31,0,0,1661, + 1663,1,0,0,0,1662,1628,1,0,0,0,1662,1629,1,0,0,0,1662,1630,1,0,0,0,1662, + 1635,1,0,0,0,1662,1636,1,0,0,0,1662,1643,1,0,0,0,1662,1650,1,0,0,0,1662, + 1657,1,0,0,0,1663,165,1,0,0,0,1664,1665,7,10,0,0,1665,167,1,0,0,0,1666, + 1667,3,170,85,0,1667,1668,3,138,69,0,1668,1669,3,124,62,0,1669,1670,5, + 176,0,0,1670,1672,3,242,121,0,1671,1673,3,108,54,0,1672,1671,1,0,0,0,1672, + 1673,1,0,0,0,1673,1674,1,0,0,0,1674,1675,3,112,56,0,1675,1676,6,84,-1, + 0,1676,1709,1,0,0,0,1677,1678,3,170,85,0,1678,1679,3,138,69,0,1679,1680, + 3,124,62,0,1680,1681,5,176,0,0,1681,1682,3,242,121,0,1682,1683,3,196,98, + 0,1683,1684,3,112,56,0,1684,1685,6,84,-1,0,1685,1709,1,0,0,0,1686,1687, + 3,170,85,0,1687,1688,3,138,69,0,1688,1690,3,242,121,0,1689,1691,3,108, + 54,0,1690,1689,1,0,0,0,1690,1691,1,0,0,0,1691,1692,1,0,0,0,1692,1693,3, + 112,56,0,1693,1694,6,84,-1,0,1694,1709,1,0,0,0,1695,1696,3,170,85,0,1696, + 1697,3,138,69,0,1697,1698,3,242,121,0,1698,1699,3,196,98,0,1699,1700,3, + 112,56,0,1700,1701,6,84,-1,0,1701,1709,1,0,0,0,1702,1703,3,174,87,0,1703, + 1704,6,84,-1,0,1704,1709,1,0,0,0,1705,1706,3,2,1,0,1706,1707,6,84,-1,0, + 1707,1709,1,0,0,0,1708,1666,1,0,0,0,1708,1677,1,0,0,0,1708,1686,1,0,0, + 0,1708,1695,1,0,0,0,1708,1702,1,0,0,0,1708,1705,1,0,0,0,1709,169,1,0,0, + 0,1710,1711,5,243,0,0,1711,1712,3,170,85,0,1712,1713,6,85,-1,0,1713,1728, + 1,0,0,0,1714,1715,5,244,0,0,1715,1716,3,170,85,0,1716,1717,6,85,-1,0,1717, + 1728,1,0,0,0,1718,1719,3,172,86,0,1719,1720,6,85,-1,0,1720,1728,1,0,0, + 0,1721,1722,5,112,0,0,1722,1723,5,30,0,0,1723,1724,3,32,16,0,1724,1725, + 5,31,0,0,1725,1726,6,85,-1,0,1726,1728,1,0,0,0,1727,1710,1,0,0,0,1727, + 1714,1,0,0,0,1727,1718,1,0,0,0,1727,1721,1,0,0,0,1728,171,1,0,0,0,1729, + 1749,1,0,0,0,1730,1731,5,245,0,0,1731,1749,6,86,-1,0,1732,1733,5,246,0, + 0,1733,1749,6,86,-1,0,1734,1735,5,247,0,0,1735,1736,5,248,0,0,1736,1749, + 6,86,-1,0,1737,1738,5,247,0,0,1738,1739,5,249,0,0,1739,1749,6,86,-1,0, + 1740,1741,5,247,0,0,1741,1742,5,250,0,0,1742,1749,6,86,-1,0,1743,1744, + 5,247,0,0,1744,1745,5,251,0,0,1745,1749,6,86,-1,0,1746,1747,5,247,0,0, + 1747,1749,6,86,-1,0,1748,1729,1,0,0,0,1748,1730,1,0,0,0,1748,1732,1,0, + 0,0,1748,1734,1,0,0,0,1748,1737,1,0,0,0,1748,1740,1,0,0,0,1748,1743,1, + 0,0,0,1748,1746,1,0,0,0,1749,173,1,0,0,0,1750,1751,5,113,0,0,1751,1752, + 5,30,0,0,1752,1753,3,32,16,0,1753,1754,5,31,0,0,1754,1755,6,87,-1,0,1755, + 175,1,0,0,0,1756,1757,5,226,0,0,1757,1758,3,168,84,0,1758,1759,6,88,-1, + 0,1759,1768,1,0,0,0,1760,1761,5,37,0,0,1761,1762,3,178,89,0,1762,1763, + 6,88,-1,0,1763,1768,1,0,0,0,1764,1765,3,174,87,0,1765,1766,6,88,-1,0,1766, + 1768,1,0,0,0,1767,1756,1,0,0,0,1767,1760,1,0,0,0,1767,1764,1,0,0,0,1768, + 177,1,0,0,0,1769,1770,3,138,69,0,1770,1771,3,124,62,0,1771,1772,5,176, + 0,0,1772,1773,3,2,1,0,1773,1774,6,89,-1,0,1774,1783,1,0,0,0,1775,1776, + 3,138,69,0,1776,1777,3,2,1,0,1777,1778,6,89,-1,0,1778,1783,1,0,0,0,1779, + 1780,3,2,1,0,1780,1781,6,89,-1,0,1781,1783,1,0,0,0,1782,1769,1,0,0,0,1782, + 1775,1,0,0,0,1782,1779,1,0,0,0,1783,179,1,0,0,0,1784,1785,3,124,62,0,1785, + 1786,5,28,0,0,1786,1788,1,0,0,0,1787,1784,1,0,0,0,1788,1791,1,0,0,0,1789, + 1787,1,0,0,0,1789,1790,1,0,0,0,1790,1792,1,0,0,0,1791,1789,1,0,0,0,1792, + 1793,3,124,62,0,1793,181,1,0,0,0,1794,1800,1,0,0,0,1795,1796,5,86,0,0, + 1796,1797,3,190,95,0,1797,1798,5,87,0,0,1798,1800,1,0,0,0,1799,1794,1, + 0,0,0,1799,1795,1,0,0,0,1800,183,1,0,0,0,1801,1813,5,266,0,0,1802,1813, + 5,114,0,0,1803,1813,5,39,0,0,1804,1813,5,200,0,0,1805,1813,5,115,0,0,1806, + 1813,5,116,0,0,1807,1808,5,70,0,0,1808,1809,5,30,0,0,1809,1810,3,32,16, + 0,1810,1811,5,31,0,0,1811,1813,1,0,0,0,1812,1801,1,0,0,0,1812,1802,1,0, + 0,0,1812,1803,1,0,0,0,1812,1804,1,0,0,0,1812,1805,1,0,0,0,1812,1806,1, + 0,0,0,1812,1807,1,0,0,0,1813,185,1,0,0,0,1814,1816,3,184,92,0,1815,1814, + 1,0,0,0,1816,1819,1,0,0,0,1817,1815,1,0,0,0,1817,1818,1,0,0,0,1818,187, + 1,0,0,0,1819,1817,1,0,0,0,1820,1822,3,186,93,0,1821,1823,3,192,96,0,1822, + 1821,1,0,0,0,1822,1823,1,0,0,0,1823,1824,1,0,0,0,1824,1825,3,2,1,0,1825, + 189,1,0,0,0,1826,1827,3,188,94,0,1827,1828,5,28,0,0,1828,1830,1,0,0,0, + 1829,1826,1,0,0,0,1830,1833,1,0,0,0,1831,1829,1,0,0,0,1831,1832,1,0,0, + 0,1832,1834,1,0,0,0,1833,1831,1,0,0,0,1834,1835,3,188,94,0,1835,191,1, + 0,0,0,1836,1837,5,30,0,0,1837,1838,3,180,90,0,1838,1839,5,31,0,0,1839, + 193,1,0,0,0,1840,1842,3,196,98,0,1841,1840,1,0,0,0,1841,1842,1,0,0,0,1842, + 1843,1,0,0,0,1843,1844,6,97,-1,0,1844,195,1,0,0,0,1845,1846,5,86,0,0,1846, + 1847,5,42,0,0,1847,1848,3,32,16,0,1848,1849,5,43,0,0,1849,1850,5,87,0, + 0,1850,1851,6,98,-1,0,1851,197,1,0,0,0,1852,1853,3,234,117,0,1853,1854, + 5,17,0,0,1854,1855,3,246,123,0,1855,1856,5,18,0,0,1856,1969,1,0,0,0,1857, + 1858,3,74,37,0,1858,1859,5,17,0,0,1859,1860,3,82,41,0,1860,1861,5,18,0, + 0,1861,1969,1,0,0,0,1862,1863,3,210,105,0,1863,1864,5,17,0,0,1864,1865, + 3,214,107,0,1865,1866,5,18,0,0,1866,1969,1,0,0,0,1867,1868,3,218,109,0, + 1868,1869,5,17,0,0,1869,1870,3,222,111,0,1870,1871,5,18,0,0,1871,1969, + 1,0,0,0,1872,1969,3,200,100,0,1873,1969,3,276,138,0,1874,1969,3,152,76, + 0,1875,1969,3,88,44,0,1876,1969,3,322,161,0,1877,1878,5,117,0,0,1878,1969, + 3,32,16,0,1879,1880,5,118,0,0,1880,1969,3,32,16,0,1881,1882,3,334,167, + 0,1882,1883,5,17,0,0,1883,1884,3,338,169,0,1884,1885,5,18,0,0,1885,1969, + 1,0,0,0,1886,1887,5,302,0,0,1887,1888,3,124,62,0,1888,1889,5,176,0,0,1889, + 1890,3,242,121,0,1890,1891,5,119,0,0,1891,1892,3,170,85,0,1892,1893,3, + 138,69,0,1893,1894,3,124,62,0,1894,1895,5,176,0,0,1895,1896,3,242,121, + 0,1896,1897,3,112,56,0,1897,1969,1,0,0,0,1898,1899,5,302,0,0,1899,1900, + 5,226,0,0,1900,1901,3,170,85,0,1901,1902,3,138,69,0,1902,1903,3,124,62, + 0,1903,1904,5,176,0,0,1904,1905,3,242,121,0,1905,1906,3,194,97,0,1906, + 1907,3,112,56,0,1907,1908,5,119,0,0,1908,1909,5,226,0,0,1909,1910,3,170, + 85,0,1910,1911,3,138,69,0,1911,1912,3,124,62,0,1912,1913,5,176,0,0,1913, + 1914,3,242,121,0,1914,1915,3,194,97,0,1915,1916,3,112,56,0,1916,1969,1, + 0,0,0,1917,1969,3,26,13,0,1918,1969,3,40,20,0,1919,1920,5,255,0,0,1920, + 1921,5,196,0,0,1921,1922,5,42,0,0,1922,1923,3,32,16,0,1923,1927,5,43,0, + 0,1924,1926,3,322,161,0,1925,1924,1,0,0,0,1926,1929,1,0,0,0,1927,1925, + 1,0,0,0,1927,1928,1,0,0,0,1928,1969,1,0,0,0,1929,1927,1,0,0,0,1930,1931, + 5,255,0,0,1931,1932,5,196,0,0,1932,1936,3,2,1,0,1933,1935,3,322,161,0, + 1934,1933,1,0,0,0,1935,1938,1,0,0,0,1936,1934,1,0,0,0,1936,1937,1,0,0, + 0,1937,1969,1,0,0,0,1938,1936,1,0,0,0,1939,1940,5,255,0,0,1940,1941,5, + 256,0,0,1941,1942,5,42,0,0,1942,1943,3,32,16,0,1943,1944,5,43,0,0,1944, + 1945,5,28,0,0,1945,1949,3,124,62,0,1946,1948,3,322,161,0,1947,1946,1,0, + 0,0,1948,1951,1,0,0,0,1949,1947,1,0,0,0,1949,1950,1,0,0,0,1950,1969,1, + 0,0,0,1951,1949,1,0,0,0,1952,1953,5,255,0,0,1953,1954,5,256,0,0,1954,1955, + 3,2,1,0,1955,1956,5,28,0,0,1956,1960,3,124,62,0,1957,1959,3,322,161,0, + 1958,1957,1,0,0,0,1959,1962,1,0,0,0,1960,1958,1,0,0,0,1960,1961,1,0,0, + 0,1961,1969,1,0,0,0,1962,1960,1,0,0,0,1963,1964,5,120,0,0,1964,1965,5, + 196,0,0,1965,1966,3,124,62,0,1966,1967,3,44,22,0,1967,1969,1,0,0,0,1968, + 1852,1,0,0,0,1968,1857,1,0,0,0,1968,1862,1,0,0,0,1968,1867,1,0,0,0,1968, + 1872,1,0,0,0,1968,1873,1,0,0,0,1968,1874,1,0,0,0,1968,1875,1,0,0,0,1968, + 1876,1,0,0,0,1968,1877,1,0,0,0,1968,1879,1,0,0,0,1968,1881,1,0,0,0,1968, + 1886,1,0,0,0,1968,1898,1,0,0,0,1968,1917,1,0,0,0,1968,1918,1,0,0,0,1968, + 1919,1,0,0,0,1968,1930,1,0,0,0,1968,1939,1,0,0,0,1968,1952,1,0,0,0,1968, + 1963,1,0,0,0,1969,199,1,0,0,0,1970,1971,5,121,0,0,1971,1980,3,208,104, + 0,1972,1979,3,202,101,0,1973,1974,5,122,0,0,1974,1975,5,30,0,0,1975,1976, + 3,228,114,0,1976,1977,5,31,0,0,1977,1979,1,0,0,0,1978,1972,1,0,0,0,1978, + 1973,1,0,0,0,1979,1982,1,0,0,0,1980,1978,1,0,0,0,1980,1981,1,0,0,0,1981, + 1983,1,0,0,0,1982,1980,1,0,0,0,1983,1984,3,138,69,0,1984,1985,3,2,1,0, + 1985,1986,3,204,102,0,1986,1987,3,206,103,0,1987,201,1,0,0,0,1988,2008, + 5,123,0,0,1989,2008,5,51,0,0,1990,2008,5,52,0,0,1991,2008,5,63,0,0,1992, + 2008,5,124,0,0,1993,2008,5,69,0,0,1994,2008,5,68,0,0,1995,2008,5,64,0, + 0,1996,2008,5,65,0,0,1997,2008,5,66,0,0,1998,2008,5,125,0,0,1999,2008, + 5,126,0,0,2000,2008,5,127,0,0,2001,2008,5,16,0,0,2002,2003,5,70,0,0,2003, + 2004,5,30,0,0,2004,2005,3,32,16,0,2005,2006,5,31,0,0,2006,2008,1,0,0,0, + 2007,1988,1,0,0,0,2007,1989,1,0,0,0,2007,1990,1,0,0,0,2007,1991,1,0,0, + 0,2007,1992,1,0,0,0,2007,1993,1,0,0,0,2007,1994,1,0,0,0,2007,1995,1,0, + 0,0,2007,1996,1,0,0,0,2007,1997,1,0,0,0,2007,1998,1,0,0,0,2007,1999,1, + 0,0,0,2007,2000,1,0,0,0,2007,2001,1,0,0,0,2007,2002,1,0,0,0,2008,203,1, + 0,0,0,2009,2015,1,0,0,0,2010,2011,5,44,0,0,2011,2015,3,0,0,0,2012,2013, + 5,44,0,0,2013,2015,3,32,16,0,2014,2009,1,0,0,0,2014,2010,1,0,0,0,2014, + 2012,1,0,0,0,2015,205,1,0,0,0,2016,2020,1,0,0,0,2017,2018,5,36,0,0,2018, + 2020,3,296,148,0,2019,2016,1,0,0,0,2019,2017,1,0,0,0,2020,207,1,0,0,0, + 2021,2027,1,0,0,0,2022,2023,5,42,0,0,2023,2024,3,32,16,0,2024,2025,5,43, + 0,0,2025,2027,1,0,0,0,2026,2021,1,0,0,0,2026,2022,1,0,0,0,2027,209,1,0, + 0,0,2028,2032,5,128,0,0,2029,2031,3,212,106,0,2030,2029,1,0,0,0,2031,2034, + 1,0,0,0,2032,2030,1,0,0,0,2032,2033,1,0,0,0,2033,2035,1,0,0,0,2034,2032, + 1,0,0,0,2035,2036,3,124,62,0,2036,2037,3,2,1,0,2037,2047,1,0,0,0,2038, + 2042,5,128,0,0,2039,2041,3,212,106,0,2040,2039,1,0,0,0,2041,2044,1,0,0, + 0,2042,2040,1,0,0,0,2042,2043,1,0,0,0,2043,2045,1,0,0,0,2044,2042,1,0, + 0,0,2045,2047,3,2,1,0,2046,2028,1,0,0,0,2046,2038,1,0,0,0,2047,211,1,0, + 0,0,2048,2049,7,11,0,0,2049,213,1,0,0,0,2050,2052,3,216,108,0,2051,2050, + 1,0,0,0,2052,2055,1,0,0,0,2053,2051,1,0,0,0,2053,2054,1,0,0,0,2054,215, + 1,0,0,0,2055,2053,1,0,0,0,2056,2057,5,129,0,0,2057,2069,3,168,84,0,2058, + 2059,5,130,0,0,2059,2069,3,168,84,0,2060,2061,5,131,0,0,2061,2069,3,168, + 84,0,2062,2063,5,132,0,0,2063,2069,3,168,84,0,2064,2069,3,88,44,0,2065, + 2069,3,322,161,0,2066,2069,3,26,13,0,2067,2069,3,40,20,0,2068,2056,1,0, + 0,0,2068,2058,1,0,0,0,2068,2060,1,0,0,0,2068,2062,1,0,0,0,2068,2064,1, + 0,0,0,2068,2065,1,0,0,0,2068,2066,1,0,0,0,2068,2067,1,0,0,0,2069,217,1, + 0,0,0,2070,2074,5,133,0,0,2071,2073,3,220,110,0,2072,2071,1,0,0,0,2073, + 2076,1,0,0,0,2074,2072,1,0,0,0,2074,2075,1,0,0,0,2075,2077,1,0,0,0,2076, + 2074,1,0,0,0,2077,2078,3,170,85,0,2078,2079,3,138,69,0,2079,2080,3,2,1, + 0,2080,2081,3,112,56,0,2081,2082,3,206,103,0,2082,219,1,0,0,0,2083,2084, + 7,11,0,0,2084,221,1,0,0,0,2085,2087,3,224,112,0,2086,2085,1,0,0,0,2087, + 2090,1,0,0,0,2088,2086,1,0,0,0,2088,2089,1,0,0,0,2089,223,1,0,0,0,2090, + 2088,1,0,0,0,2091,2092,5,134,0,0,2092,2102,3,168,84,0,2093,2094,5,135, + 0,0,2094,2102,3,168,84,0,2095,2096,5,132,0,0,2096,2102,3,168,84,0,2097, + 2102,3,322,161,0,2098,2102,3,88,44,0,2099,2102,3,26,13,0,2100,2102,3,40, + 20,0,2101,2091,1,0,0,0,2101,2093,1,0,0,0,2101,2095,1,0,0,0,2101,2097,1, + 0,0,0,2101,2098,1,0,0,0,2101,2099,1,0,0,0,2101,2100,1,0,0,0,2102,225,1, + 0,0,0,2103,2110,1,0,0,0,2104,2105,5,122,0,0,2105,2106,5,30,0,0,2106,2107, + 3,228,114,0,2107,2108,5,31,0,0,2108,2110,1,0,0,0,2109,2103,1,0,0,0,2109, + 2104,1,0,0,0,2110,227,1,0,0,0,2111,2121,3,126,63,0,2112,2114,5,17,0,0, + 2113,2115,3,294,147,0,2114,2113,1,0,0,0,2115,2116,1,0,0,0,2116,2114,1, + 0,0,0,2116,2117,1,0,0,0,2117,2118,1,0,0,0,2118,2119,5,18,0,0,2119,2121, + 1,0,0,0,2120,2111,1,0,0,0,2120,2112,1,0,0,0,2121,229,1,0,0,0,2122,2123, + 3,232,116,0,2123,2124,6,115,-1,0,2124,2126,1,0,0,0,2125,2122,1,0,0,0,2126, + 2129,1,0,0,0,2127,2125,1,0,0,0,2127,2128,1,0,0,0,2128,231,1,0,0,0,2129, + 2127,1,0,0,0,2130,2131,5,42,0,0,2131,2132,5,136,0,0,2132,2133,5,43,0,0, + 2133,2148,6,116,-1,0,2134,2135,5,42,0,0,2135,2136,5,137,0,0,2136,2137, + 5,43,0,0,2137,2148,6,116,-1,0,2138,2139,5,42,0,0,2139,2140,5,138,0,0,2140, + 2141,5,43,0,0,2141,2148,6,116,-1,0,2142,2143,5,42,0,0,2143,2144,3,32,16, + 0,2144,2145,5,43,0,0,2145,2146,6,116,-1,0,2146,2148,1,0,0,0,2147,2130, + 1,0,0,0,2147,2134,1,0,0,0,2147,2138,1,0,0,0,2147,2142,1,0,0,0,2148,233, + 1,0,0,0,2149,2154,5,139,0,0,2150,2153,3,236,118,0,2151,2153,3,238,119, + 0,2152,2150,1,0,0,0,2152,2151,1,0,0,0,2153,2156,1,0,0,0,2154,2152,1,0, + 0,0,2154,2155,1,0,0,0,2155,2157,1,0,0,0,2156,2154,1,0,0,0,2157,2158,3, + 170,85,0,2158,2159,3,230,115,0,2159,2160,3,138,69,0,2160,2161,3,226,113, + 0,2161,2162,3,242,121,0,2162,2163,3,182,91,0,2163,2167,3,112,56,0,2164, + 2166,3,244,122,0,2165,2164,1,0,0,0,2166,2169,1,0,0,0,2167,2165,1,0,0,0, + 2167,2168,1,0,0,0,2168,235,1,0,0,0,2169,2167,1,0,0,0,2170,2194,5,123,0, + 0,2171,2194,5,51,0,0,2172,2194,5,52,0,0,2173,2194,5,63,0,0,2174,2194,5, + 140,0,0,2175,2194,5,68,0,0,2176,2194,5,141,0,0,2177,2194,5,142,0,0,2178, + 2194,5,54,0,0,2179,2194,5,64,0,0,2180,2194,5,65,0,0,2181,2194,5,66,0,0, + 2182,2194,5,125,0,0,2183,2194,5,143,0,0,2184,2194,5,144,0,0,2185,2194, + 5,69,0,0,2186,2194,5,145,0,0,2187,2194,5,146,0,0,2188,2189,5,70,0,0,2189, + 2190,5,30,0,0,2190,2191,3,32,16,0,2191,2192,5,31,0,0,2192,2194,1,0,0,0, + 2193,2170,1,0,0,0,2193,2171,1,0,0,0,2193,2172,1,0,0,0,2193,2173,1,0,0, + 0,2193,2174,1,0,0,0,2193,2175,1,0,0,0,2193,2176,1,0,0,0,2193,2177,1,0, + 0,0,2193,2178,1,0,0,0,2193,2179,1,0,0,0,2193,2180,1,0,0,0,2193,2181,1, + 0,0,0,2193,2182,1,0,0,0,2193,2183,1,0,0,0,2193,2184,1,0,0,0,2193,2185, + 1,0,0,0,2193,2186,1,0,0,0,2193,2187,1,0,0,0,2193,2188,1,0,0,0,2194,237, + 1,0,0,0,2195,2196,5,147,0,0,2196,2202,5,30,0,0,2197,2200,3,6,3,0,2198, + 2199,5,34,0,0,2199,2201,3,6,3,0,2200,2198,1,0,0,0,2200,2201,1,0,0,0,2201, + 2203,1,0,0,0,2202,2197,1,0,0,0,2202,2203,1,0,0,0,2203,2207,1,0,0,0,2204, + 2206,3,240,120,0,2205,2204,1,0,0,0,2206,2209,1,0,0,0,2207,2205,1,0,0,0, + 2207,2208,1,0,0,0,2208,2210,1,0,0,0,2209,2207,1,0,0,0,2210,2214,5,31,0, + 0,2211,2212,5,147,0,0,2212,2214,5,85,0,0,2213,2195,1,0,0,0,2213,2211,1, + 0,0,0,2214,239,1,0,0,0,2215,2243,5,148,0,0,2216,2243,5,224,0,0,2217,2243, + 5,57,0,0,2218,2243,5,58,0,0,2219,2243,5,149,0,0,2220,2243,5,150,0,0,2221, + 2243,5,248,0,0,2222,2243,5,249,0,0,2223,2243,5,250,0,0,2224,2243,5,251, + 0,0,2225,2226,5,151,0,0,2226,2227,5,75,0,0,2227,2243,5,152,0,0,2228,2229, + 5,151,0,0,2229,2230,5,75,0,0,2230,2243,5,153,0,0,2231,2232,5,154,0,0,2232, + 2233,5,75,0,0,2233,2243,5,152,0,0,2234,2235,5,154,0,0,2235,2236,5,75,0, + 0,2236,2243,5,153,0,0,2237,2238,5,70,0,0,2238,2239,5,30,0,0,2239,2240, + 3,32,16,0,2240,2241,5,31,0,0,2241,2243,1,0,0,0,2242,2215,1,0,0,0,2242, + 2216,1,0,0,0,2242,2217,1,0,0,0,2242,2218,1,0,0,0,2242,2219,1,0,0,0,2242, + 2220,1,0,0,0,2242,2221,1,0,0,0,2242,2222,1,0,0,0,2242,2223,1,0,0,0,2242, + 2224,1,0,0,0,2242,2225,1,0,0,0,2242,2228,1,0,0,0,2242,2231,1,0,0,0,2242, + 2234,1,0,0,0,2242,2237,1,0,0,0,2243,241,1,0,0,0,2244,2245,5,116,0,0,2245, + 2252,6,121,-1,0,2246,2247,5,155,0,0,2247,2252,6,121,-1,0,2248,2249,3,2, + 1,0,2249,2250,6,121,-1,0,2250,2252,1,0,0,0,2251,2244,1,0,0,0,2251,2246, + 1,0,0,0,2251,2248,1,0,0,0,2252,243,1,0,0,0,2253,2275,5,1,0,0,2254,2275, + 5,2,0,0,2255,2275,5,156,0,0,2256,2275,5,3,0,0,2257,2275,5,4,0,0,2258,2275, + 5,247,0,0,2259,2275,5,5,0,0,2260,2275,5,6,0,0,2261,2275,5,7,0,0,2262,2275, + 5,8,0,0,2263,2275,5,9,0,0,2264,2275,5,10,0,0,2265,2275,5,11,0,0,2266,2275, + 5,12,0,0,2267,2275,5,13,0,0,2268,2275,5,14,0,0,2269,2270,5,70,0,0,2270, + 2271,5,30,0,0,2271,2272,3,32,16,0,2272,2273,5,31,0,0,2273,2275,1,0,0,0, + 2274,2253,1,0,0,0,2274,2254,1,0,0,0,2274,2255,1,0,0,0,2274,2256,1,0,0, + 0,2274,2257,1,0,0,0,2274,2258,1,0,0,0,2274,2259,1,0,0,0,2274,2260,1,0, + 0,0,2274,2261,1,0,0,0,2274,2262,1,0,0,0,2274,2263,1,0,0,0,2274,2264,1, + 0,0,0,2274,2265,1,0,0,0,2274,2266,1,0,0,0,2274,2267,1,0,0,0,2274,2268, + 1,0,0,0,2274,2269,1,0,0,0,2275,245,1,0,0,0,2276,2278,3,248,124,0,2277, + 2276,1,0,0,0,2278,2281,1,0,0,0,2279,2277,1,0,0,0,2279,2280,1,0,0,0,2280, + 247,1,0,0,0,2281,2279,1,0,0,0,2282,2300,3,100,50,0,2283,2284,5,296,0,0, + 2284,2285,3,32,16,0,2285,2286,6,124,-1,0,2286,2300,1,0,0,0,2287,2300,3, + 258,129,0,2288,2289,5,297,0,0,2289,2290,3,32,16,0,2290,2291,6,124,-1,0, + 2291,2300,1,0,0,0,2292,2293,5,298,0,0,2293,2300,6,124,-1,0,2294,2295,5, + 299,0,0,2295,2300,6,124,-1,0,2296,2300,3,252,126,0,2297,2300,3,256,128, + 0,2298,2300,3,250,125,0,2299,2282,1,0,0,0,2299,2283,1,0,0,0,2299,2287, + 1,0,0,0,2299,2288,1,0,0,0,2299,2292,1,0,0,0,2299,2294,1,0,0,0,2299,2296, + 1,0,0,0,2299,2297,1,0,0,0,2299,2298,1,0,0,0,2300,249,1,0,0,0,2301,2302, + 5,300,0,0,2302,2400,3,112,56,0,2303,2304,5,300,0,0,2304,2305,5,157,0,0, + 2305,2400,3,112,56,0,2306,2400,3,276,138,0,2307,2400,3,152,76,0,2308,2400, + 3,88,44,0,2309,2400,3,26,13,0,2310,2400,3,254,127,0,2311,2400,3,40,20, + 0,2312,2313,5,301,0,0,2313,2314,5,42,0,0,2314,2315,3,32,16,0,2315,2316, + 5,43,0,0,2316,2400,1,0,0,0,2317,2318,5,301,0,0,2318,2319,5,42,0,0,2319, + 2320,3,32,16,0,2320,2321,5,43,0,0,2321,2322,5,34,0,0,2322,2323,3,0,0,0, + 2323,2400,1,0,0,0,2324,2325,5,303,0,0,2325,2326,3,32,16,0,2326,2327,5, + 75,0,0,2327,2328,3,32,16,0,2328,2400,1,0,0,0,2329,2330,5,302,0,0,2330, + 2331,3,124,62,0,2331,2332,5,176,0,0,2332,2333,3,242,121,0,2333,2400,1, + 0,0,0,2334,2335,5,302,0,0,2335,2336,5,226,0,0,2336,2337,3,170,85,0,2337, + 2338,3,138,69,0,2338,2339,3,124,62,0,2339,2340,5,176,0,0,2340,2341,3,242, + 121,0,2341,2342,3,194,97,0,2342,2343,3,112,56,0,2343,2400,1,0,0,0,2344, + 2345,5,255,0,0,2345,2346,5,196,0,0,2346,2347,5,42,0,0,2347,2348,3,32,16, + 0,2348,2352,5,43,0,0,2349,2351,3,322,161,0,2350,2349,1,0,0,0,2351,2354, + 1,0,0,0,2352,2350,1,0,0,0,2352,2353,1,0,0,0,2353,2400,1,0,0,0,2354,2352, + 1,0,0,0,2355,2356,5,255,0,0,2356,2357,5,196,0,0,2357,2361,3,2,1,0,2358, + 2360,3,322,161,0,2359,2358,1,0,0,0,2360,2363,1,0,0,0,2361,2359,1,0,0,0, + 2361,2362,1,0,0,0,2362,2400,1,0,0,0,2363,2361,1,0,0,0,2364,2365,5,255, + 0,0,2365,2366,5,256,0,0,2366,2367,5,42,0,0,2367,2368,3,32,16,0,2368,2369, + 5,43,0,0,2369,2370,5,28,0,0,2370,2374,3,124,62,0,2371,2373,3,322,161,0, + 2372,2371,1,0,0,0,2373,2376,1,0,0,0,2374,2372,1,0,0,0,2374,2375,1,0,0, + 0,2375,2400,1,0,0,0,2376,2374,1,0,0,0,2377,2378,5,255,0,0,2378,2379,5, + 256,0,0,2379,2380,3,2,1,0,2380,2381,5,28,0,0,2381,2385,3,124,62,0,2382, + 2384,3,322,161,0,2383,2382,1,0,0,0,2384,2387,1,0,0,0,2385,2383,1,0,0,0, + 2385,2386,1,0,0,0,2386,2400,1,0,0,0,2387,2385,1,0,0,0,2388,2389,5,255, + 0,0,2389,2390,5,42,0,0,2390,2391,3,32,16,0,2391,2392,5,43,0,0,2392,2396, + 3,206,103,0,2393,2395,3,322,161,0,2394,2393,1,0,0,0,2395,2398,1,0,0,0, + 2396,2394,1,0,0,0,2396,2397,1,0,0,0,2397,2400,1,0,0,0,2398,2396,1,0,0, + 0,2399,2301,1,0,0,0,2399,2303,1,0,0,0,2399,2306,1,0,0,0,2399,2307,1,0, + 0,0,2399,2308,1,0,0,0,2399,2309,1,0,0,0,2399,2310,1,0,0,0,2399,2311,1, + 0,0,0,2399,2312,1,0,0,0,2399,2317,1,0,0,0,2399,2324,1,0,0,0,2399,2329, + 1,0,0,0,2399,2334,1,0,0,0,2399,2344,1,0,0,0,2399,2355,1,0,0,0,2399,2364, + 1,0,0,0,2399,2377,1,0,0,0,2399,2388,1,0,0,0,2400,251,1,0,0,0,2401,2402, + 3,0,0,0,2402,2403,5,75,0,0,2403,2404,6,126,-1,0,2404,253,1,0,0,0,2405, + 2408,3,44,22,0,2406,2408,3,46,23,0,2407,2405,1,0,0,0,2407,2406,1,0,0,0, + 2408,255,1,0,0,0,2409,2410,5,17,0,0,2410,2411,3,246,123,0,2411,2412,5, + 18,0,0,2412,257,1,0,0,0,2413,2414,3,262,131,0,2414,2415,3,260,130,0,2415, + 259,1,0,0,0,2416,2418,3,264,132,0,2417,2416,1,0,0,0,2418,2419,1,0,0,0, + 2419,2417,1,0,0,0,2419,2420,1,0,0,0,2420,261,1,0,0,0,2421,2422,5,158,0, + 0,2422,2434,3,256,128,0,2423,2424,5,158,0,0,2424,2425,3,0,0,0,2425,2426, + 5,159,0,0,2426,2427,3,0,0,0,2427,2434,1,0,0,0,2428,2429,5,158,0,0,2429, + 2430,3,32,16,0,2430,2431,5,159,0,0,2431,2432,3,32,16,0,2432,2434,1,0,0, + 0,2433,2421,1,0,0,0,2433,2423,1,0,0,0,2433,2428,1,0,0,0,2434,263,1,0,0, + 0,2435,2436,3,268,134,0,2436,2437,3,274,137,0,2437,2448,1,0,0,0,2438,2439, + 3,266,133,0,2439,2440,3,274,137,0,2440,2448,1,0,0,0,2441,2442,3,270,135, + 0,2442,2443,3,274,137,0,2443,2448,1,0,0,0,2444,2445,3,272,136,0,2445,2446, + 3,274,137,0,2446,2448,1,0,0,0,2447,2435,1,0,0,0,2447,2438,1,0,0,0,2447, + 2441,1,0,0,0,2447,2444,1,0,0,0,2448,265,1,0,0,0,2449,2450,5,160,0,0,2450, + 2456,3,256,128,0,2451,2452,5,160,0,0,2452,2456,3,0,0,0,2453,2454,5,160, + 0,0,2454,2456,3,32,16,0,2455,2449,1,0,0,0,2455,2451,1,0,0,0,2455,2453, + 1,0,0,0,2456,267,1,0,0,0,2457,2458,5,161,0,0,2458,2459,3,124,62,0,2459, + 269,1,0,0,0,2460,2461,5,162,0,0,2461,271,1,0,0,0,2462,2463,5,163,0,0,2463, + 273,1,0,0,0,2464,2476,3,256,128,0,2465,2466,5,164,0,0,2466,2467,3,0,0, + 0,2467,2468,5,159,0,0,2468,2469,3,0,0,0,2469,2476,1,0,0,0,2470,2471,5, + 164,0,0,2471,2472,3,32,16,0,2472,2473,5,159,0,0,2473,2474,3,32,16,0,2474, + 2476,1,0,0,0,2475,2464,1,0,0,0,2475,2465,1,0,0,0,2475,2470,1,0,0,0,2476, + 275,1,0,0,0,2477,2478,3,278,139,0,2478,2479,3,282,141,0,2479,277,1,0,0, + 0,2480,2481,5,165,0,0,2481,2482,3,280,140,0,2482,2483,3,0,0,0,2483,2484, + 5,36,0,0,2484,2488,1,0,0,0,2485,2486,5,165,0,0,2486,2488,3,280,140,0,2487, + 2480,1,0,0,0,2487,2485,1,0,0,0,2488,279,1,0,0,0,2489,2493,1,0,0,0,2490, + 2493,5,166,0,0,2491,2493,5,2,0,0,2492,2489,1,0,0,0,2492,2490,1,0,0,0,2492, + 2491,1,0,0,0,2493,281,1,0,0,0,2494,2495,5,17,0,0,2495,2496,3,284,142,0, + 2496,2497,5,18,0,0,2497,2504,1,0,0,0,2498,2500,3,288,144,0,2499,2498,1, + 0,0,0,2500,2501,1,0,0,0,2501,2499,1,0,0,0,2501,2502,1,0,0,0,2502,2504, + 1,0,0,0,2503,2494,1,0,0,0,2503,2499,1,0,0,0,2504,283,1,0,0,0,2505,2506, + 3,288,144,0,2506,2507,5,28,0,0,2507,2509,1,0,0,0,2508,2505,1,0,0,0,2509, + 2512,1,0,0,0,2510,2508,1,0,0,0,2510,2511,1,0,0,0,2511,2513,1,0,0,0,2512, + 2510,1,0,0,0,2513,2514,3,288,144,0,2514,285,1,0,0,0,2515,2521,1,0,0,0, + 2516,2517,5,42,0,0,2517,2518,3,32,16,0,2518,2519,5,43,0,0,2519,2521,1, + 0,0,0,2520,2515,1,0,0,0,2520,2516,1,0,0,0,2521,287,1,0,0,0,2522,2523,5, + 181,0,0,2523,2524,5,262,0,0,2524,2525,5,30,0,0,2525,2526,3,6,3,0,2526, + 2527,5,31,0,0,2527,2589,1,0,0,0,2528,2529,5,260,0,0,2529,2530,5,30,0,0, + 2530,2531,3,0,0,0,2531,2532,5,31,0,0,2532,2589,1,0,0,0,2533,2534,5,260, + 0,0,2534,2589,3,0,0,0,2535,2536,5,84,0,0,2536,2537,5,30,0,0,2537,2538, + 3,292,146,0,2538,2539,5,31,0,0,2539,2589,1,0,0,0,2540,2541,5,188,0,0,2541, + 2542,5,30,0,0,2542,2543,3,36,18,0,2543,2544,5,31,0,0,2544,2545,3,286,143, + 0,2545,2589,1,0,0,0,2546,2547,5,189,0,0,2547,2548,5,30,0,0,2548,2549,3, + 36,18,0,2549,2550,5,31,0,0,2550,2551,3,286,143,0,2551,2589,1,0,0,0,2552, + 2553,5,187,0,0,2553,2554,5,30,0,0,2554,2555,3,34,17,0,2555,2556,5,31,0, + 0,2556,2557,3,286,143,0,2557,2589,1,0,0,0,2558,2559,5,186,0,0,2559,2560, + 5,30,0,0,2560,2561,3,32,16,0,2561,2562,5,31,0,0,2562,2563,3,286,143,0, + 2563,2589,1,0,0,0,2564,2565,5,185,0,0,2565,2566,5,30,0,0,2566,2567,3,32, + 16,0,2567,2568,5,31,0,0,2568,2569,3,286,143,0,2569,2589,1,0,0,0,2570,2571, + 5,184,0,0,2571,2572,5,30,0,0,2572,2573,3,32,16,0,2573,2574,5,31,0,0,2574, + 2575,3,286,143,0,2575,2589,1,0,0,0,2576,2577,5,188,0,0,2577,2589,3,286, + 143,0,2578,2579,5,189,0,0,2579,2589,3,286,143,0,2580,2581,5,187,0,0,2581, + 2589,3,286,143,0,2582,2583,5,186,0,0,2583,2589,3,286,143,0,2584,2585,5, + 185,0,0,2585,2589,3,286,143,0,2586,2587,5,184,0,0,2587,2589,3,286,143, + 0,2588,2522,1,0,0,0,2588,2528,1,0,0,0,2588,2533,1,0,0,0,2588,2535,1,0, + 0,0,2588,2540,1,0,0,0,2588,2546,1,0,0,0,2588,2552,1,0,0,0,2588,2558,1, + 0,0,0,2588,2564,1,0,0,0,2588,2570,1,0,0,0,2588,2576,1,0,0,0,2588,2578, + 1,0,0,0,2588,2580,1,0,0,0,2588,2582,1,0,0,0,2588,2584,1,0,0,0,2588,2586, + 1,0,0,0,2589,289,1,0,0,0,2590,2591,5,188,0,0,2591,2592,5,30,0,0,2592,2593, + 3,36,18,0,2593,2594,5,31,0,0,2594,2666,1,0,0,0,2595,2596,5,189,0,0,2596, + 2597,5,30,0,0,2597,2598,3,36,18,0,2598,2599,5,31,0,0,2599,2666,1,0,0,0, + 2600,2601,5,188,0,0,2601,2602,5,30,0,0,2602,2603,3,32,16,0,2603,2604,5, + 31,0,0,2604,2666,1,0,0,0,2605,2606,5,189,0,0,2606,2607,5,30,0,0,2607,2608, + 3,34,17,0,2608,2609,5,31,0,0,2609,2666,1,0,0,0,2610,2611,5,187,0,0,2611, + 2612,5,30,0,0,2612,2613,3,34,17,0,2613,2614,5,31,0,0,2614,2666,1,0,0,0, + 2615,2616,5,186,0,0,2616,2617,5,30,0,0,2617,2618,3,32,16,0,2618,2619,5, + 31,0,0,2619,2666,1,0,0,0,2620,2621,5,185,0,0,2621,2622,5,30,0,0,2622,2623, + 3,32,16,0,2623,2624,5,31,0,0,2624,2666,1,0,0,0,2625,2626,5,184,0,0,2626, + 2627,5,30,0,0,2627,2628,3,32,16,0,2628,2629,5,31,0,0,2629,2666,1,0,0,0, + 2630,2631,5,193,0,0,2631,2632,5,30,0,0,2632,2633,3,34,17,0,2633,2634,5, + 31,0,0,2634,2666,1,0,0,0,2635,2636,5,192,0,0,2636,2637,5,30,0,0,2637,2638, + 3,32,16,0,2638,2639,5,31,0,0,2639,2666,1,0,0,0,2640,2641,5,191,0,0,2641, + 2642,5,30,0,0,2642,2643,3,32,16,0,2643,2644,5,31,0,0,2644,2666,1,0,0,0, + 2645,2646,5,190,0,0,2646,2647,5,30,0,0,2647,2648,3,32,16,0,2648,2649,5, + 31,0,0,2649,2666,1,0,0,0,2650,2651,5,181,0,0,2651,2652,5,30,0,0,2652,2653, + 3,32,16,0,2653,2654,5,31,0,0,2654,2666,1,0,0,0,2655,2656,5,183,0,0,2656, + 2657,5,30,0,0,2657,2658,3,162,81,0,2658,2659,5,31,0,0,2659,2666,1,0,0, + 0,2660,2661,5,84,0,0,2661,2662,5,30,0,0,2662,2663,3,292,146,0,2663,2664, + 5,31,0,0,2664,2666,1,0,0,0,2665,2590,1,0,0,0,2665,2595,1,0,0,0,2665,2600, + 1,0,0,0,2665,2605,1,0,0,0,2665,2610,1,0,0,0,2665,2615,1,0,0,0,2665,2620, + 1,0,0,0,2665,2625,1,0,0,0,2665,2630,1,0,0,0,2665,2635,1,0,0,0,2665,2640, + 1,0,0,0,2665,2645,1,0,0,0,2665,2650,1,0,0,0,2665,2655,1,0,0,0,2665,2660, + 1,0,0,0,2666,291,1,0,0,0,2667,2668,3,294,147,0,2668,2669,6,146,-1,0,2669, + 2671,1,0,0,0,2670,2667,1,0,0,0,2671,2674,1,0,0,0,2672,2670,1,0,0,0,2672, + 2673,1,0,0,0,2673,293,1,0,0,0,2674,2672,1,0,0,0,2675,2676,7,12,0,0,2676, + 295,1,0,0,0,2677,2681,3,290,145,0,2678,2681,3,6,3,0,2679,2681,5,179,0, + 0,2680,2677,1,0,0,0,2680,2678,1,0,0,0,2680,2679,1,0,0,0,2681,297,1,0,0, + 0,2682,2831,3,290,145,0,2683,2684,5,182,0,0,2684,2685,5,30,0,0,2685,2686, + 5,179,0,0,2686,2831,5,31,0,0,2687,2688,5,182,0,0,2688,2689,5,30,0,0,2689, + 2690,5,264,0,0,2690,2831,5,31,0,0,2691,2692,5,196,0,0,2692,2693,5,30,0, + 0,2693,2694,5,39,0,0,2694,2695,5,264,0,0,2695,2831,5,31,0,0,2696,2697, + 5,196,0,0,2697,2698,5,30,0,0,2698,2699,3,116,58,0,2699,2700,5,31,0,0,2700, + 2831,1,0,0,0,2701,2702,5,196,0,0,2702,2703,5,30,0,0,2703,2704,5,179,0, + 0,2704,2831,5,31,0,0,2705,2706,5,197,0,0,2706,2707,5,30,0,0,2707,2708, + 3,298,149,0,2708,2709,5,31,0,0,2709,2831,1,0,0,0,2710,2711,5,188,0,0,2711, + 2712,5,42,0,0,2712,2713,3,32,16,0,2713,2714,5,43,0,0,2714,2715,5,30,0, + 0,2715,2716,3,300,150,0,2716,2717,5,31,0,0,2717,2831,1,0,0,0,2718,2719, + 5,189,0,0,2719,2720,5,42,0,0,2720,2721,3,32,16,0,2721,2722,5,43,0,0,2722, + 2723,5,30,0,0,2723,2724,3,302,151,0,2724,2725,5,31,0,0,2725,2831,1,0,0, + 0,2726,2727,5,187,0,0,2727,2728,5,42,0,0,2728,2729,3,32,16,0,2729,2730, + 5,43,0,0,2730,2731,5,30,0,0,2731,2732,3,304,152,0,2732,2733,5,31,0,0,2733, + 2831,1,0,0,0,2734,2735,5,186,0,0,2735,2736,5,42,0,0,2736,2737,3,32,16, + 0,2737,2738,5,43,0,0,2738,2739,5,30,0,0,2739,2740,3,306,153,0,2740,2741, + 5,31,0,0,2741,2831,1,0,0,0,2742,2743,5,185,0,0,2743,2744,5,42,0,0,2744, + 2745,3,32,16,0,2745,2746,5,43,0,0,2746,2747,5,30,0,0,2747,2748,3,308,154, + 0,2748,2749,5,31,0,0,2749,2831,1,0,0,0,2750,2751,5,184,0,0,2751,2752,5, + 42,0,0,2752,2753,3,32,16,0,2753,2754,5,43,0,0,2754,2755,5,30,0,0,2755, + 2756,3,310,155,0,2756,2757,5,31,0,0,2757,2831,1,0,0,0,2758,2759,5,193, + 0,0,2759,2760,5,42,0,0,2760,2761,3,32,16,0,2761,2762,5,43,0,0,2762,2763, + 5,30,0,0,2763,2764,3,304,152,0,2764,2765,5,31,0,0,2765,2831,1,0,0,0,2766, + 2767,5,192,0,0,2767,2768,5,42,0,0,2768,2769,3,32,16,0,2769,2770,5,43,0, + 0,2770,2771,5,30,0,0,2771,2772,3,306,153,0,2772,2773,5,31,0,0,2773,2831, + 1,0,0,0,2774,2775,5,191,0,0,2775,2776,5,42,0,0,2776,2777,3,32,16,0,2777, + 2778,5,43,0,0,2778,2779,5,30,0,0,2779,2780,3,308,154,0,2780,2781,5,31, + 0,0,2781,2831,1,0,0,0,2782,2783,5,190,0,0,2783,2784,5,42,0,0,2784,2785, + 3,32,16,0,2785,2786,5,43,0,0,2786,2787,5,30,0,0,2787,2788,3,310,155,0, + 2788,2789,5,31,0,0,2789,2831,1,0,0,0,2790,2791,5,181,0,0,2791,2792,5,42, + 0,0,2792,2793,3,32,16,0,2793,2794,5,43,0,0,2794,2795,5,30,0,0,2795,2796, + 3,308,154,0,2796,2797,5,31,0,0,2797,2831,1,0,0,0,2798,2799,5,183,0,0,2799, + 2800,5,42,0,0,2800,2801,3,32,16,0,2801,2802,5,43,0,0,2802,2803,5,30,0, + 0,2803,2804,3,312,156,0,2804,2805,5,31,0,0,2805,2831,1,0,0,0,2806,2807, + 5,182,0,0,2807,2808,5,42,0,0,2808,2809,3,32,16,0,2809,2810,5,43,0,0,2810, + 2811,5,30,0,0,2811,2812,3,314,157,0,2812,2813,5,31,0,0,2813,2831,1,0,0, + 0,2814,2815,5,196,0,0,2815,2816,5,42,0,0,2816,2817,3,32,16,0,2817,2818, + 5,43,0,0,2818,2819,5,30,0,0,2819,2820,3,316,158,0,2820,2821,5,31,0,0,2821, + 2831,1,0,0,0,2822,2823,5,197,0,0,2823,2824,5,42,0,0,2824,2825,3,32,16, + 0,2825,2826,5,43,0,0,2826,2827,5,30,0,0,2827,2828,3,320,160,0,2828,2829, + 5,31,0,0,2829,2831,1,0,0,0,2830,2682,1,0,0,0,2830,2683,1,0,0,0,2830,2687, + 1,0,0,0,2830,2691,1,0,0,0,2830,2696,1,0,0,0,2830,2701,1,0,0,0,2830,2705, + 1,0,0,0,2830,2710,1,0,0,0,2830,2718,1,0,0,0,2830,2726,1,0,0,0,2830,2734, + 1,0,0,0,2830,2742,1,0,0,0,2830,2750,1,0,0,0,2830,2758,1,0,0,0,2830,2766, + 1,0,0,0,2830,2774,1,0,0,0,2830,2782,1,0,0,0,2830,2790,1,0,0,0,2830,2798, + 1,0,0,0,2830,2806,1,0,0,0,2830,2814,1,0,0,0,2830,2822,1,0,0,0,2831,299, + 1,0,0,0,2832,2835,3,36,18,0,2833,2835,3,32,16,0,2834,2832,1,0,0,0,2834, + 2833,1,0,0,0,2835,2838,1,0,0,0,2836,2834,1,0,0,0,2836,2837,1,0,0,0,2837, + 301,1,0,0,0,2838,2836,1,0,0,0,2839,2842,3,36,18,0,2840,2842,3,34,17,0, + 2841,2839,1,0,0,0,2841,2840,1,0,0,0,2842,2845,1,0,0,0,2843,2841,1,0,0, + 0,2843,2844,1,0,0,0,2844,303,1,0,0,0,2845,2843,1,0,0,0,2846,2848,3,34, + 17,0,2847,2846,1,0,0,0,2848,2851,1,0,0,0,2849,2847,1,0,0,0,2849,2850,1, + 0,0,0,2850,305,1,0,0,0,2851,2849,1,0,0,0,2852,2854,3,32,16,0,2853,2852, + 1,0,0,0,2854,2857,1,0,0,0,2855,2853,1,0,0,0,2855,2856,1,0,0,0,2856,307, + 1,0,0,0,2857,2855,1,0,0,0,2858,2860,3,32,16,0,2859,2858,1,0,0,0,2860,2863, + 1,0,0,0,2861,2859,1,0,0,0,2861,2862,1,0,0,0,2862,309,1,0,0,0,2863,2861, + 1,0,0,0,2864,2866,3,32,16,0,2865,2864,1,0,0,0,2866,2869,1,0,0,0,2867,2865, + 1,0,0,0,2867,2868,1,0,0,0,2868,311,1,0,0,0,2869,2867,1,0,0,0,2870,2872, + 3,162,81,0,2871,2870,1,0,0,0,2872,2875,1,0,0,0,2873,2871,1,0,0,0,2873, + 2874,1,0,0,0,2874,313,1,0,0,0,2875,2873,1,0,0,0,2876,2878,7,13,0,0,2877, + 2876,1,0,0,0,2878,2881,1,0,0,0,2879,2877,1,0,0,0,2879,2880,1,0,0,0,2880, + 315,1,0,0,0,2881,2879,1,0,0,0,2882,2884,3,318,159,0,2883,2882,1,0,0,0, + 2884,2887,1,0,0,0,2885,2883,1,0,0,0,2885,2886,1,0,0,0,2886,317,1,0,0,0, + 2887,2885,1,0,0,0,2888,2893,5,179,0,0,2889,2890,5,39,0,0,2890,2893,5,264, + 0,0,2891,2893,3,116,58,0,2892,2888,1,0,0,0,2892,2889,1,0,0,0,2892,2891, + 1,0,0,0,2893,319,1,0,0,0,2894,2896,3,298,149,0,2895,2894,1,0,0,0,2896, + 2899,1,0,0,0,2897,2895,1,0,0,0,2897,2898,1,0,0,0,2898,321,1,0,0,0,2899, + 2897,1,0,0,0,2900,2904,3,44,22,0,2901,2904,3,46,23,0,2902,2904,3,2,1,0, + 2903,2900,1,0,0,0,2903,2901,1,0,0,0,2903,2902,1,0,0,0,2904,323,1,0,0,0, + 2905,2906,7,14,0,0,2906,2907,5,36,0,0,2907,2908,5,30,0,0,2908,2909,3,292, + 146,0,2909,2910,5,31,0,0,2910,2931,1,0,0,0,2911,2912,5,169,0,0,2912,2913, + 3,38,19,0,2913,2914,5,75,0,0,2914,2915,3,38,19,0,2915,2916,5,75,0,0,2916, + 2917,3,38,19,0,2917,2918,5,75,0,0,2918,2919,3,38,19,0,2919,2931,1,0,0, + 0,2920,2921,5,170,0,0,2921,2931,3,6,3,0,2922,2923,5,170,0,0,2923,2924, + 5,36,0,0,2924,2925,5,30,0,0,2925,2926,3,292,146,0,2926,2927,5,31,0,0,2927, + 2931,1,0,0,0,2928,2931,3,322,161,0,2929,2931,3,40,20,0,2930,2905,1,0,0, + 0,2930,2911,1,0,0,0,2930,2920,1,0,0,0,2930,2922,1,0,0,0,2930,2928,1,0, + 0,0,2930,2929,1,0,0,0,2931,325,1,0,0,0,2932,2933,5,25,0,0,2933,2934,5, + 40,0,0,2934,2935,3,98,49,0,2935,2936,3,2,1,0,2936,2945,1,0,0,0,2937,2938, + 5,25,0,0,2938,2939,5,40,0,0,2939,2940,3,98,49,0,2940,2941,3,2,1,0,2941, + 2942,5,34,0,0,2942,2943,3,2,1,0,2943,2945,1,0,0,0,2944,2932,1,0,0,0,2944, + 2937,1,0,0,0,2945,327,1,0,0,0,2946,2948,3,330,165,0,2947,2946,1,0,0,0, + 2948,2951,1,0,0,0,2949,2947,1,0,0,0,2949,2950,1,0,0,0,2950,329,1,0,0,0, + 2951,2949,1,0,0,0,2952,2953,5,180,0,0,2953,2954,5,36,0,0,2954,2955,5,30, + 0,0,2955,2956,3,292,146,0,2956,2957,5,31,0,0,2957,2967,1,0,0,0,2958,2967, + 3,324,162,0,2959,2960,5,171,0,0,2960,2961,5,36,0,0,2961,2962,5,30,0,0, + 2962,2963,3,292,146,0,2963,2964,5,31,0,0,2964,2967,1,0,0,0,2965,2967,5, + 55,0,0,2966,2952,1,0,0,0,2966,2958,1,0,0,0,2966,2959,1,0,0,0,2966,2965, + 1,0,0,0,2967,331,1,0,0,0,2968,2969,5,50,0,0,2969,2973,5,40,0,0,2970,2972, + 3,336,168,0,2971,2970,1,0,0,0,2972,2975,1,0,0,0,2973,2971,1,0,0,0,2973, + 2974,1,0,0,0,2974,2976,1,0,0,0,2975,2973,1,0,0,0,2976,2977,3,2,1,0,2977, + 333,1,0,0,0,2978,2982,5,301,0,0,2979,2981,3,336,168,0,2980,2979,1,0,0, + 0,2981,2984,1,0,0,0,2982,2980,1,0,0,0,2982,2983,1,0,0,0,2983,2985,1,0, + 0,0,2984,2982,1,0,0,0,2985,2986,3,2,1,0,2986,335,1,0,0,0,2987,3003,5,52, + 0,0,2988,3003,5,51,0,0,2989,3003,5,172,0,0,2990,2991,5,62,0,0,2991,3003, + 5,51,0,0,2992,2993,5,62,0,0,2993,3003,5,52,0,0,2994,2995,5,62,0,0,2995, + 3003,5,63,0,0,2996,2997,5,62,0,0,2997,3003,5,64,0,0,2998,2999,5,62,0,0, + 2999,3003,5,65,0,0,3000,3001,5,62,0,0,3001,3003,5,66,0,0,3002,2987,1,0, + 0,0,3002,2988,1,0,0,0,3002,2989,1,0,0,0,3002,2990,1,0,0,0,3002,2992,1, + 0,0,0,3002,2994,1,0,0,0,3002,2996,1,0,0,0,3002,2998,1,0,0,0,3002,3000, + 1,0,0,0,3003,337,1,0,0,0,3004,3006,3,340,170,0,3005,3004,1,0,0,0,3006, + 3009,1,0,0,0,3007,3005,1,0,0,0,3007,3008,1,0,0,0,3008,339,1,0,0,0,3009, + 3007,1,0,0,0,3010,3011,5,21,0,0,3011,3024,3,2,1,0,3012,3013,5,50,0,0,3013, + 3014,5,40,0,0,3014,3024,3,118,59,0,3015,3016,5,25,0,0,3016,3017,5,40,0, + 0,3017,3024,3,2,1,0,3018,3024,3,174,87,0,3019,3020,5,50,0,0,3020,3024, + 3,32,16,0,3021,3024,3,322,161,0,3022,3024,3,40,20,0,3023,3010,1,0,0,0, + 3023,3012,1,0,0,0,3023,3015,1,0,0,0,3023,3018,1,0,0,0,3023,3019,1,0,0, + 0,3023,3021,1,0,0,0,3023,3022,1,0,0,0,3024,341,1,0,0,0,3025,3029,5,274, + 0,0,3026,3028,3,344,172,0,3027,3026,1,0,0,0,3028,3031,1,0,0,0,3029,3027, + 1,0,0,0,3029,3030,1,0,0,0,3030,3032,1,0,0,0,3031,3029,1,0,0,0,3032,3045, + 3,2,1,0,3033,3037,5,274,0,0,3034,3036,3,344,172,0,3035,3034,1,0,0,0,3036, + 3039,1,0,0,0,3037,3035,1,0,0,0,3037,3038,1,0,0,0,3038,3040,1,0,0,0,3039, + 3037,1,0,0,0,3040,3041,3,2,1,0,3041,3042,5,34,0,0,3042,3043,3,2,1,0,3043, + 3045,1,0,0,0,3044,3025,1,0,0,0,3044,3033,1,0,0,0,3045,343,1,0,0,0,3046, + 3047,7,15,0,0,3047,345,1,0,0,0,3048,3050,3,348,174,0,3049,3048,1,0,0,0, + 3050,3053,1,0,0,0,3051,3049,1,0,0,0,3051,3052,1,0,0,0,3052,347,1,0,0,0, + 3053,3051,1,0,0,0,3054,3055,5,21,0,0,3055,3056,3,2,1,0,3056,3057,5,44, + 0,0,3057,3058,3,32,16,0,3058,3065,1,0,0,0,3059,3060,5,25,0,0,3060,3061, + 5,40,0,0,3061,3065,3,2,1,0,3062,3065,3,322,161,0,3063,3065,3,40,20,0,3064, + 3054,1,0,0,0,3064,3059,1,0,0,0,3064,3062,1,0,0,0,3064,3063,1,0,0,0,3065, + 349,1,0,0,0,175,360,368,377,386,439,480,489,519,523,541,568,591,627,637, + 644,646,656,658,665,676,684,705,707,723,768,773,778,783,791,901,907,923, + 929,935,942,970,1048,1050,1064,1070,1079,1081,1090,1104,1118,1126,1134, + 1138,1177,1185,1194,1202,1221,1228,1231,1250,1344,1353,1360,1363,1374, + 1406,1466,1506,1522,1532,1559,1583,1591,1595,1610,1617,1662,1672,1690, + 1708,1727,1748,1767,1782,1789,1799,1812,1817,1822,1831,1841,1927,1936, + 1949,1960,1968,1978,1980,2007,2014,2019,2026,2032,2042,2046,2053,2068, + 2074,2088,2101,2109,2116,2120,2127,2147,2152,2154,2167,2193,2200,2202, + 2207,2213,2242,2251,2274,2279,2299,2352,2361,2374,2385,2396,2399,2407, + 2419,2433,2447,2455,2475,2487,2492,2501,2503,2510,2520,2588,2665,2672, + 2680,2830,2834,2836,2841,2843,2849,2855,2861,2867,2873,2879,2885,2892, + 2897,2903,2930,2944,2949,2966,2973,2982,3002,3007,3023,3029,3037,3044, + 3051,3064 }; public static readonly ATN _ATN = diff --git a/src/tools/ilasm/tests/ILAssembler.Tests/InstructionTests.cs b/src/tools/ilasm/tests/ILAssembler.Tests/InstructionTests.cs index c38555315cb2ae..c56078168b7570 100644 --- a/src/tools/ilasm/tests/ILAssembler.Tests/InstructionTests.cs +++ b/src/tools/ilasm/tests/ILAssembler.Tests/InstructionTests.cs @@ -79,6 +79,7 @@ .method public static void M() cil managed [InlineData("box")] [InlineData("ldtoken")] [InlineData("calli default void(")] + [InlineData("calli vararg void(class [mscorlib]System.Tuple`1 + { + Assert.Fail("Expected no includes"); + return default; + }, + _ => + { + Assert.Fail("Expected no resources"); + return default; + }, + new Options { ErrorTolerant = true }); + + Assert.Contains(diagnostics, diagnostic => diagnostic.Id == "Parser"); + Assert.NotNull(result); + + BlobBuilder image = new(); + result!.Serialize(image); + using PEReader pe = new(image.ToImmutableArray()); + MetadataReader reader = pe.GetMetadataReader(); + string[] assemblyReferences = reader.AssemblyReferences + .Select(handle => reader.GetString(reader.GetAssemblyReference(handle).Name)) + .ToArray(); + + Assert.Contains("Used", assemblyReferences); + Assert.DoesNotContain("Unused", assemblyReferences); + Assert.Equal([0x28, 0x01, 0x00, 0x00, 0x0A, 0x2A], GetMethodIL(pe, "Good")); + } + [Fact] public void DataLabelReference_FixedUpCorrectly() @@ -445,6 +497,61 @@ calli vararg void(int32, ..., string, int64) Assert.Equal([PrimitiveTypeCode.Int32, PrimitiveTypeCode.String, PrimitiveTypeCode.Int64], signature.ParameterTypes.ToArray()); } + [Fact] + public void ReferenceAndCalliOperands_NestedSignaturesDecodeCorrectly() + { + string source = """ + .assembly extern mscorlib { } + .assembly Test { } + .class public auto ansi Test + { + .method public static void F() cil managed + { + ldsfld method vararg void *(int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile), ..., string) class [mscorlib]System.Tuple`1>::Callback + pop + call void class [mscorlib]System.Tuple`1>::Invoke(method vararg void *(int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile), ..., string)) + ldc.i4.0 + conv.i + calli vararg void(class [mscorlib]System.Tuple`1>, ..., method vararg void *(int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile), ..., string)) + ret + } + } + """; + + using var pe = DocumentCompilerTestHelpers.CompileAndGetReader(source, new Options()); + var reader = pe.GetMetadataReader(); + + MemberReference fieldReference = reader.MemberReferences + .Select(reader.GetMemberReference) + .Single(reference => reader.GetString(reference.Name) == "Callback"); + Assert.Equal( + "method void *(int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile), ..., string)", + fieldReference.DecodeFieldSignature(DocumentCompilerTestHelpers.Decoder, genericContext: null)); + + MemberReference methodReference = reader.MemberReferences + .Select(reader.GetMemberReference) + .Single(reference => reader.GetString(reference.Name) == "Invoke"); + MethodSignature methodSignature = + methodReference.DecodeMethodSignature(DocumentCompilerTestHelpers.Decoder, genericContext: null); + Assert.Equal("void", methodSignature.ReturnType); + Assert.Equal( + new[] { "method void *(int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile), ..., string)" }, + methodSignature.ParameterTypes); + + MethodSignature calliSignature = reader + .GetStandaloneSignature(MetadataTokens.StandaloneSignatureHandle(1)) + .DecodeMethodSignature(DocumentCompilerTestHelpers.Decoder, genericContext: null); + Assert.Equal(SignatureCallingConvention.VarArgs, calliSignature.Header.CallingConvention); + Assert.Equal(1, calliSignature.RequiredParameterCount); + Assert.Equal( + new[] + { + "[mscorlib]System.Tuple`1<[mscorlib]System.Tuple`1>", + "method void *(int32 modreq([mscorlib]System.Runtime.CompilerServices.IsVolatile), ..., string)", + }, + calliSignature.ParameterTypes); + } + [Fact] public void MaxStackDirective_IsPreserved() { From bcceae025edc2667d5674eed59ad39bd523cd3d4 Mon Sep 17 00:00:00 2001 From: Jeremy Koritzinsky Date: Thu, 13 Aug 2026 12:29:14 -0700 Subject: [PATCH 06/16] Synthesize IL marshalling grammar values Convert native marshalling, SAFEARRAY variants, IID parameters, and raw marshal blobs to compact semantic values. Remove the final signature-layer parse subtree while preserving descriptor bytes and recursive native-type ordering. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: c986c103-8383-4db4-9b11-9be49dc68a05 --- src/tools/ilasm/README.md | 8 +- .../GrammarActions.Marshalling.Actions.cs | 732 +++ .../Actions/GrammarActions.Marshalling.cs | 584 +- .../GrammarActions.Signatures.Actions.cs | 4 +- .../GrammarActions.Signatures.Types.cs | 2 +- .../GrammarActions.Signatures.Values.cs | 2 +- .../src/ILAssembler/Actions/GrammarActions.cs | 8 +- src/tools/ilasm/src/ILAssembler/gen/CIL.g4 | 249 +- .../ilasm/src/ILAssembler/gen/CIL.interp | 2 +- .../ilasm/src/ILAssembler/gen/CILParser.cs | 5469 +++++++++-------- .../tests/ILAssembler.Tests/InteropTests.cs | 78 + 11 files changed, 4026 insertions(+), 3112 deletions(-) create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Marshalling.Actions.cs diff --git a/src/tools/ilasm/README.md b/src/tools/ilasm/README.md index c8c2c052e21029..adf57049301b34 100644 --- a/src/tools/ilasm/README.md +++ b/src/tools/ilasm/README.md @@ -23,7 +23,8 @@ accumulator instead of building a subtree at all. | `GrammarActions.Instructions.References.cs` | Reference and signature instruction actions. | | `GrammarActions.Literals.cs` | Literals, names and strings. | | `GrammarActions.Manifest.cs` | Assembly, module, resource, vtable and typedef directives. | -| `GrammarActions.Marshalling.cs` | Native type and marshalling conversion. | +| `GrammarActions.Marshalling.Actions.cs` | Synthesized native type and marshalling descriptor actions. | +| `GrammarActions.Marshalling.cs` | Marshalling visitor wrappers and P/Invoke conversion. | | `GrammarActions.Members.cs` | Class member dispatch and conversion. | | `GrammarActions.MethodBodies.cs` | Method, lexical scope and exception-handling state and conversion. | | `GrammarActions.Security.cs` | Declarative security conversion. | @@ -49,8 +50,9 @@ ILAssembler entities and signature implementation values remain internal, so gen slots use `object` where an internal value or array crosses that boundary and `GrammarActions` provides the strongly typed accessors. -`marshalClause` is the remaining signature-layer parse-tree island. It retains only the bounded -`marshalBlob`/`nativeType` subtree until its containing signature is materialized. +All type, signature, reference and marshalling rules synthesize values without retaining parse +subtrees. The remaining `BeginSubtree` islands are structural: `decl`, `nameSpaceHead`, +`classHead`, `classDecl`, `methodHead`, `methodDeclIsland` and `sehBlock`. Semantic state that a rule pushes must be released from that rule's `finally` clause and be keyed on the owning context, because ANTLR skips `@after` actions and the remainder of an alternative once a diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Marshalling.Actions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Marshalling.Actions.cs new file mode 100644 index 00000000000000..91054df8d9defc --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Marshalling.Actions.cs @@ -0,0 +1,732 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.Reflection.Metadata; +using System.Runtime.InteropServices; +using Antlr4.Runtime; + +namespace ILAssembler; + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. +internal sealed partial class GrammarActions +{ + private const byte NativeTypeVoid = 0x01; + private const byte NativeTypeSysChar = 0x0D; + private const byte NativeTypeVariant = 0x0E; + private const byte NativeTypePointer = 0x10; + private const byte NativeTypeDecimal = 0x11; + private const byte NativeTypeDate = 0x12; + private const byte NativeTypeObjectReference = 0x18; + private const byte NativeTypeNestedStruct = 0x21; + private const byte NativeTypeMax = 0x50; + + private readonly Stack _marshalBlobFrames = new(); + private readonly Stack _nativeTypeFrames = new(); + private readonly Stack _variantTypeFrames = new(); + + private sealed class MarshalBlobFrame + { + public MarshalBlobFrame(CILParser.MarshalBlobContext owner) + { + Owner = owner; + } + + public CILParser.MarshalBlobContext Owner { get; } + + public NativeTypeValue? NativeType { get; set; } + + public BlobBuilder? RawBytes { get; set; } + } + + private sealed class NativeTypeFrame + { + public NativeTypeFrame(CILParser.NativeTypeContext owner) + { + Owner = owner; + } + + public CILParser.NativeTypeContext Owner { get; } + + public NativeTypeElementValue? Element { get; set; } + + public List? ArrayPointerInfo { get; set; } + } + + private sealed class VariantTypeFrame + { + public VariantTypeFrame(CILParser.VariantTypeContext owner) + { + Owner = owner; + } + + public CILParser.VariantTypeContext Owner { get; } + + public VariantTypeElementValue? Element { get; set; } + + public VarEnum Modifiers { get; set; } + } + + private sealed record MarshallingDescriptorValue(BlobBuilder? RawBytes, NativeTypeValue? NativeType); + + private sealed record NativeTypeValue( + IToken? Token, + NativeTypeElementValue? Element, + ImmutableArray ArrayPointerInfo) + { + public static NativeTypeValue Empty { get; } = new(null, null, []); + } + + private abstract record NativeTypeElementValue; + + private sealed record EmptyNativeTypeElementValue : NativeTypeElementValue + { + public static EmptyNativeTypeElementValue Instance { get; } = new(); + } + + private sealed record CustomMarshallerNativeTypeElementValue( + IToken? Token, + string? Guid, + string? NativeTypeName, + string MarshallerType, + string Cookie) : NativeTypeElementValue; + + private sealed record FixedSysStringNativeTypeElementValue(IToken Size) : NativeTypeElementValue; + + private sealed record FixedArrayNativeTypeElementValue(IToken Size, NativeTypeValue Element) : NativeTypeElementValue; + + private sealed record DeprecatedNativeTypeElementValue(IToken Token, int TokenType) : NativeTypeElementValue; + + private sealed record SimpleNativeTypeElementValue(int TokenType) : NativeTypeElementValue; + + private sealed record IidNativeTypeElementValue( + int TokenType, + IidParamIndexValue IidParamIndex) : NativeTypeElementValue; + + private sealed record SafeArrayNativeTypeElementValue( + VariantTypeValue VariantType, + string? UserDefinedType) : NativeTypeElementValue; + + private sealed record UnsignedNativeTypeElementValue(int TokenType) : NativeTypeElementValue; + + private sealed record NestedStructNativeTypeElementValue(IToken Token) : NativeTypeElementValue; + + private sealed record AnsiBstrNativeTypeElementValue : NativeTypeElementValue + { + public static AnsiBstrNativeTypeElementValue Instance { get; } = new(); + } + + private sealed record VariantBoolNativeTypeElementValue : NativeTypeElementValue + { + public static VariantBoolNativeTypeElementValue Instance { get; } = new(); + } + + private sealed record NativeTypeTypedefValue(IToken Token, string Alias) : NativeTypeElementValue; + + private enum NativeTypeArrayPointerInfoKind + { + Pointer, + ArrayNoSizeData, + ArraySize, + ArraySizeParamIndex, + ArrayParamIndex + } + + private sealed record NativeTypeArrayPointerInfoValue( + NativeTypeArrayPointerInfoKind Kind, + IToken? Size = null, + IToken? ParameterIndex = null); + + private sealed record IidParamIndexValue(IToken? Index) + { + public static IidParamIndexValue Empty { get; } = new((IToken?)null); + } + + private sealed record VariantTypeValue(VariantTypeElementValue? Element, VarEnum Modifiers) + { + public static VariantTypeValue Empty { get; } = new(null, 0); + } + + private sealed record VariantTypeElementValue(int TokenType); + + internal object CreateEmptyMarshallingDescriptor() + => new MarshallingDescriptorValue(new BlobBuilder(0), null); + + internal object CompleteMarshalClause(object? value) + => GetMarshallingDescriptorValue(value); + + internal void BeginMarshalBlob(CILParser.MarshalBlobContext context) + => _marshalBlobFrames.Push(new(context)); + + internal void SetMarshalBlobNativeType(CILParser.MarshalBlobContext context, object? value) + { + if (TryGetMarshalBlobFrame(context, out MarshalBlobFrame? frame)) + { + frame.NativeType = GetNativeTypeValue(value); + } + } + + internal void AddMarshalBlobByte(CILParser.MarshalBlobContext context, byte value) + { + if (TryGetMarshalBlobFrame(context, out MarshalBlobFrame? frame)) + { + (frame.RawBytes ??= new BlobBuilder()).WriteByte(value); + } + } + + internal object EndMarshalBlob(CILParser.MarshalBlobContext context) + { + Debug.Assert(_marshalBlobFrames.Count > 0); + if (_marshalBlobFrames.Count == 0) + { + return CreateEmptyMarshallingDescriptor(); + } + + MarshalBlobFrame frame = _marshalBlobFrames.Pop(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + if (!ReferenceEquals(frame.Owner, context)) + { + return CreateEmptyMarshallingDescriptor(); + } + + return new MarshallingDescriptorValue(frame.RawBytes, frame.NativeType); + } + + internal void BeginNativeType(CILParser.NativeTypeContext context) + => _nativeTypeFrames.Push(new(context)); + + internal void SetNativeTypeElement(CILParser.NativeTypeContext context, object? value) + { + if (TryGetNativeTypeFrame(context, out NativeTypeFrame? frame)) + { + frame.Element = GetNativeTypeElementValue(value); + } + } + + internal void AddNativeTypeArrayPointerInfo(CILParser.NativeTypeContext context, object? value) + { + if (TryGetNativeTypeFrame(context, out NativeTypeFrame? frame) && + value is NativeTypeArrayPointerInfoValue arrayPointerInfo) + { + (frame.ArrayPointerInfo ??= new List()).Add(arrayPointerInfo); + } + } + + internal object EndNativeType(CILParser.NativeTypeContext context) + { + Debug.Assert(_nativeTypeFrames.Count > 0); + if (_nativeTypeFrames.Count == 0) + { + return NativeTypeValue.Empty; + } + + NativeTypeFrame frame = _nativeTypeFrames.Pop(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + if (!ReferenceEquals(frame.Owner, context)) + { + return NativeTypeValue.Empty; + } + + return new NativeTypeValue( + context.Start, + frame.Element, + frame.ArrayPointerInfo?.ToImmutableArray() ?? []); + } + + internal object CreatePointerNativeType() + => new NativeTypeArrayPointerInfoValue(NativeTypeArrayPointerInfoKind.Pointer); + + internal object CreatePointerArrayTypeNoSizeData() + => new NativeTypeArrayPointerInfoValue(NativeTypeArrayPointerInfoKind.ArrayNoSizeData); + + internal object CreatePointerArrayTypeSize(IToken size) + => new NativeTypeArrayPointerInfoValue(NativeTypeArrayPointerInfoKind.ArraySize, Size: size); + + internal object CreatePointerArrayTypeSizeParamIndex(IToken size, IToken parameterIndex) + => new NativeTypeArrayPointerInfoValue( + NativeTypeArrayPointerInfoKind.ArraySizeParamIndex, + size, + parameterIndex); + + internal object CreatePointerArrayTypeParamIndex(IToken parameterIndex) + => new NativeTypeArrayPointerInfoValue( + NativeTypeArrayPointerInfoKind.ArrayParamIndex, + ParameterIndex: parameterIndex); + + internal object CreateEmptyNativeType() => EmptyNativeTypeElementValue.Instance; + + internal object CreateDeprecatedCustomMarshallerNativeType( + CILParser.NativeTypeElementContext context, + string guid, + string nativeTypeName, + string marshallerType, + string cookie) + => new CustomMarshallerNativeTypeElementValue( + context.Start, + guid, + nativeTypeName, + marshallerType, + cookie); + + internal object CreateCustomMarshallerNativeType(string marshallerType, string cookie) + => new CustomMarshallerNativeTypeElementValue( + null, + null, + null, + marshallerType, + cookie); + + internal object CreateFixedSysStringNativeType(IToken size) + => new FixedSysStringNativeTypeElementValue(size); + + internal object CreateFixedArrayNativeType(IToken size, object? element) + => new FixedArrayNativeTypeElementValue(size, GetNativeTypeValue(element)); + + internal object CreateDeprecatedNativeType( + CILParser.NativeTypeElementContext context, + IToken nativeType) + => new DeprecatedNativeTypeElementValue(context.Start, nativeType.Type); + + internal object CreateSimpleNativeType(IToken nativeType) + => new SimpleNativeTypeElementValue(nativeType.Type); + + internal object CreateIidNativeType(IToken nativeType, object? index) + => new IidNativeTypeElementValue(nativeType.Type, GetIidParamIndexValue(index)); + + internal object CreateSafeArrayNativeType(object? variantType, string? userDefinedType) + => new SafeArrayNativeTypeElementValue( + GetVariantTypeValue(variantType), + userDefinedType); + + internal object CreateUnsignedNativeType(IToken nativeType) + => new UnsignedNativeTypeElementValue(nativeType.Type); + + internal object CreateNestedStructNativeType(CILParser.NativeTypeElementContext context) + => new NestedStructNativeTypeElementValue(context.Start); + + internal object CreateAnsiBstrNativeType() => AnsiBstrNativeTypeElementValue.Instance; + + internal object CreateVariantBoolNativeType() => VariantBoolNativeTypeElementValue.Instance; + + internal object CreateNativeTypeTypedef( + CILParser.NativeTypeElementContext context, + string alias) + => new NativeTypeTypedefValue(context.Start, alias); + + internal object GetIidParamIndex(IToken index) => new IidParamIndexValue(index); + + internal void BeginVariantType(CILParser.VariantTypeContext context) + => _variantTypeFrames.Push(new(context)); + + internal void SetVariantTypeElement(CILParser.VariantTypeContext context, object? value) + { + if (TryGetVariantTypeFrame(context, out VariantTypeFrame? frame) && + value is VariantTypeElementValue element) + { + frame.Element = element; + } + } + + internal void AddVariantTypeModifier(CILParser.VariantTypeContext context, IToken modifier) + { + if (!TryGetVariantTypeFrame(context, out VariantTypeFrame? frame)) + { + return; + } + + frame.Modifiers |= modifier.Type switch + { + CILParser.ARRAY_TYPE_NO_BOUNDS => VarEnum.VT_ARRAY, + CILParser.VECTOR => VarEnum.VT_VECTOR, + CILParser.REF => VarEnum.VT_BYREF, + _ => throw new UnreachableException() + }; + } + + internal object EndVariantType(CILParser.VariantTypeContext context) + { + Debug.Assert(_variantTypeFrames.Count > 0); + if (_variantTypeFrames.Count == 0) + { + return VariantTypeValue.Empty; + } + + VariantTypeFrame frame = _variantTypeFrames.Pop(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + return ReferenceEquals(frame.Owner, context) + ? new VariantTypeValue(frame.Element, frame.Modifiers) + : VariantTypeValue.Empty; + } + + internal object GetVariantTypeElement(IToken variantType) + => new VariantTypeElementValue(variantType.Type); + + private BlobBuilder MaterializeMarshallingDescriptor(MarshallingDescriptorValue? value) + { + if (value?.RawBytes is BlobBuilder rawBytes) + { + return rawBytes; + } + + return MaterializeNativeType(value?.NativeType ?? NativeTypeValue.Empty); + } + + private BlobBuilder MaterializeNativeType(NativeTypeValue value) + { + if (value.Element is null) + { + return new BlobBuilder(); + } + + BlobBuilder element = MaterializeNativeTypeElement(value.Element); + if (value.ArrayPointerInfo.IsDefaultOrEmpty) + { + return element; + } + + BlobBuilder prefix = new(value.ArrayPointerInfo.Length); + BlobBuilder suffix = new(); + + for (int i = value.ArrayPointerInfo.Length - 1; i >= 0; i--) + { + NativeTypeArrayPointerInfoValue info = value.ArrayPointerInfo[i]; + if (info.Kind == NativeTypeArrayPointerInfoKind.Pointer) + { + if (value.Token is IToken token) + { + ReportWarning( + DiagnosticIds.DeprecatedNativeType, + string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "pointer in array"), + token); + } + prefix.WriteByte(NativeTypePointer); + } + else + { + prefix.WriteByte((byte)UnmanagedType.LPArray); + if (element.Count == 0) + { + element.WriteByte(NativeTypeMax); + } + } + } + + foreach (NativeTypeArrayPointerInfoValue info in value.ArrayPointerInfo) + { + switch (info.Kind) + { + case NativeTypeArrayPointerInfoKind.ArraySize: + suffix.WriteCompressedInteger(0); + suffix.WriteCompressedInteger(ParseMarshallingInt32(info.Size)); + suffix.WriteCompressedInteger(0); + break; + case NativeTypeArrayPointerInfoKind.ArraySizeParamIndex: + suffix.WriteCompressedInteger(ParseMarshallingInt32(info.ParameterIndex)); + suffix.WriteCompressedInteger(ParseMarshallingInt32(info.Size)); + suffix.WriteCompressedInteger(1); + break; + case NativeTypeArrayPointerInfoKind.ArrayParamIndex: + suffix.WriteCompressedInteger(ParseMarshallingInt32(info.ParameterIndex)); + break; + } + } + + prefix.LinkSuffix(element); + prefix.LinkSuffix(suffix); + return prefix; + } + + private BlobBuilder MaterializeNativeTypeElement(NativeTypeElementValue value) + { + switch (value) + { + case EmptyNativeTypeElementValue: + return new BlobBuilder(); + case CustomMarshallerNativeTypeElementValue customMarshaller: + return MaterializeCustomMarshallerNativeType(customMarshaller); + case FixedSysStringNativeTypeElementValue fixedSysString: + { + BlobBuilder blob = CreateNativeTypeBlob(UnmanagedType.ByValTStr); + blob.WriteCompressedInteger(ParseInt32(fixedSysString.Size)); + return blob; + } + case FixedArrayNativeTypeElementValue fixedArray: + { + BlobBuilder blob = CreateNativeTypeBlob(UnmanagedType.ByValArray); + blob.WriteCompressedInteger(ParseInt32(fixedArray.Size)); + MaterializeNativeType(fixedArray.Element).WriteContentTo(blob); + return blob; + } + case DeprecatedNativeTypeElementValue deprecated: + return MaterializeDeprecatedNativeType(deprecated); + case SimpleNativeTypeElementValue simple: + return CreateNativeTypeBlob(GetSimpleNativeType(simple.TokenType)); + case IidNativeTypeElementValue iid: + return MaterializeIidNativeType(iid); + case SafeArrayNativeTypeElementValue safeArray: + return MaterializeSafeArrayNativeType(safeArray); + case UnsignedNativeTypeElementValue unsigned: + return CreateNativeTypeBlob(GetUnsignedNativeType(unsigned.TokenType)); + case NestedStructNativeTypeElementValue nestedStruct: + ReportWarning( + DiagnosticIds.DeprecatedNativeType, + string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "NESTEDSTRUCT"), + nestedStruct.Token); + return CreateNativeTypeBlob(NativeTypeNestedStruct); + case AnsiBstrNativeTypeElementValue: +#pragma warning disable CS0618 // Preserve the legacy IL native type spelling. + return CreateNativeTypeBlob(UnmanagedType.AnsiBStr); +#pragma warning restore CS0618 + case VariantBoolNativeTypeElementValue: + return CreateNativeTypeBlob(UnmanagedType.VariantBool); + case NativeTypeTypedefValue typedef: + ReportError( + DiagnosticIds.TypedefNotFound, + string.Format(DiagnosticMessageTemplates.TypedefNotFound, typedef.Alias), + typedef.Token); + return new BlobBuilder(); + default: + throw new UnreachableException(); + } + } + + private BlobBuilder MaterializeCustomMarshallerNativeType( + CustomMarshallerNativeTypeElementValue customMarshaller) + { + BlobBuilder blob = CreateNativeTypeBlob(UnmanagedType.CustomMarshaler); + if (customMarshaller.Guid is not null) + { + if (customMarshaller.Token is IToken token) + { + ReportWarning( + DiagnosticIds.DeprecatedCustomMarshaller, + DiagnosticMessageTemplates.DeprecatedCustomMarshaller, + token); + } + blob.WriteSerializedString(customMarshaller.Guid); + blob.WriteSerializedString(customMarshaller.NativeTypeName); + } + else + { + blob.WriteCompressedInteger(0); + blob.WriteCompressedInteger(0); + } + + blob.WriteSerializedString(customMarshaller.MarshallerType); + blob.WriteSerializedString(customMarshaller.Cookie); + return blob; + } + + private BlobBuilder MaterializeDeprecatedNativeType(DeprecatedNativeTypeElementValue deprecated) + { + (byte value, string name) = deprecated.TokenType switch + { + CILParser.VARIANT => (NativeTypeVariant, "VARIANT"), + CILParser.SYSCHAR => (NativeTypeSysChar, "SYSCHAR"), + CILParser.VOID => (NativeTypeVoid, "VOID"), + CILParser.DECIMAL => (NativeTypeDecimal, "DECIMAL"), + CILParser.DATE => (NativeTypeDate, "DATE"), + CILParser.OBJECTREF => (NativeTypeObjectReference, "OBJECTREF"), + _ => throw new UnreachableException() + }; + + ReportWarning( + DiagnosticIds.DeprecatedNativeType, + string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, name), + deprecated.Token); + return CreateNativeTypeBlob(value); + } + + private BlobBuilder MaterializeIidNativeType(IidNativeTypeElementValue iid) + { + UnmanagedType nativeType = iid.TokenType switch + { + CILParser.IUNKNOWN => UnmanagedType.IUnknown, + CILParser.IDISPATCH => UnmanagedType.IDispatch, + CILParser.INTERFACE => UnmanagedType.Interface, + _ => throw new UnreachableException() + }; + + BlobBuilder blob = CreateNativeTypeBlob(nativeType); + if (MaterializeIidParamIndex(iid.IidParamIndex) is int parameterIndex) + { + blob.WriteCompressedInteger(parameterIndex); + } + return blob; + } + + private BlobBuilder MaterializeSafeArrayNativeType(SafeArrayNativeTypeElementValue safeArray) + { + BlobBuilder blob = CreateNativeTypeBlob(UnmanagedType.SafeArray); + blob.WriteCompressedInteger((int)MaterializeVariantType(safeArray.VariantType)); + if (safeArray.UserDefinedType is null) + { + blob.WriteCompressedInteger(0); + } + else + { + blob.WriteSerializedString(safeArray.UserDefinedType); + } + return blob; + } + + private int? MaterializeIidParamIndex(IidParamIndexValue value) + => value.Index is null ? null : ParseInt32(value.Index); + + private VarEnum MaterializeVariantType(VariantTypeValue value) + => value.Element is null + ? VarEnum.VT_EMPTY + : MaterializeVariantTypeElement(value.Element) | value.Modifiers; + + private static VarEnum MaterializeVariantTypeElement(VariantTypeElementValue value) + => value.TokenType switch + { + CILParser.VARIANT => VarEnum.VT_VARIANT, + CILParser.CURRENCY => VarEnum.VT_CY, + CILParser.VOID => VarEnum.VT_VOID, + CILParser.BOOL => VarEnum.VT_BOOL, + CILParser.INT8 => VarEnum.VT_I1, + CILParser.INT16 => VarEnum.VT_I2, + CILParser.INT32_ => VarEnum.VT_I4, + CILParser.INT64_ => VarEnum.VT_I8, + CILParser.FLOAT32 => VarEnum.VT_R4, + CILParser.FLOAT64_ => VarEnum.VT_R8, + CILParser.UINT8 => VarEnum.VT_UI1, + CILParser.UINT16 => VarEnum.VT_UI2, + CILParser.UINT32 => VarEnum.VT_UI4, + CILParser.UINT64 => VarEnum.VT_UI8, + CILParser.PTR => VarEnum.VT_PTR, + CILParser.DECIMAL => VarEnum.VT_DECIMAL, + CILParser.DATE => VarEnum.VT_DATE, + CILParser.BSTR => VarEnum.VT_BSTR, + CILParser.LPSTR => VarEnum.VT_LPSTR, + CILParser.LPWSTR => VarEnum.VT_LPWSTR, + CILParser.IUNKNOWN => VarEnum.VT_UNKNOWN, + CILParser.IDISPATCH => VarEnum.VT_DISPATCH, + CILParser.SAFEARRAY => VarEnum.VT_SAFEARRAY, + CILParser.INT => VarEnum.VT_INT, + CILParser.UINT => VarEnum.VT_UINT, + CILParser.ERROR => VarEnum.VT_ERROR, + CILParser.HRESULT => VarEnum.VT_HRESULT, + CILParser.CARRAY => VarEnum.VT_CARRAY, + CILParser.USERDEFINED => VarEnum.VT_USERDEFINED, + CILParser.RECORD => VarEnum.VT_RECORD, + CILParser.FILETIME => VarEnum.VT_FILETIME, + CILParser.BLOB => VarEnum.VT_BLOB, + CILParser.STREAM => VarEnum.VT_STREAM, + CILParser.STORAGE => VarEnum.VT_STORAGE, + CILParser.STREAMED_OBJECT => VarEnum.VT_STREAMED_OBJECT, + CILParser.STORED_OBJECT => VarEnum.VT_STORED_OBJECT, + CILParser.BLOB_OBJECT => VarEnum.VT_BLOB_OBJECT, + CILParser.CF => VarEnum.VT_CF, + CILParser.CLSID => VarEnum.VT_CLSID, + _ => throw new UnreachableException() + }; + + private static UnmanagedType GetSimpleNativeType(int tokenType) + { +#pragma warning disable CS0618 // Preserve the legacy IL native type spellings. + return tokenType switch + { + CILParser.CURRENCY => UnmanagedType.Currency, + CILParser.BOOL => UnmanagedType.Bool, + CILParser.INT8 => UnmanagedType.I1, + CILParser.INT16 => UnmanagedType.I2, + CILParser.INT32_ => UnmanagedType.I4, + CILParser.INT64_ => UnmanagedType.I8, + CILParser.FLOAT32 => UnmanagedType.R4, + CILParser.FLOAT64_ => UnmanagedType.R8, + CILParser.ERROR => UnmanagedType.Error, + CILParser.UINT8 => UnmanagedType.U1, + CILParser.UINT16 => UnmanagedType.U2, + CILParser.UINT32 => UnmanagedType.U4, + CILParser.UINT64 => UnmanagedType.U8, + CILParser.BSTR => UnmanagedType.BStr, + CILParser.LPSTR => UnmanagedType.LPStr, + CILParser.LPWSTR => UnmanagedType.LPWStr, + CILParser.LPTSTR => UnmanagedType.LPTStr, + CILParser.STRUCT => UnmanagedType.Struct, + CILParser.INT => UnmanagedType.SysInt, + CILParser.UINT => UnmanagedType.SysUInt, + CILParser.BYVALSTR => UnmanagedType.VBByRefStr, + CILParser.TBSTR => UnmanagedType.TBStr, + CILParser.METHOD => UnmanagedType.FunctionPtr, + CILParser.LPSTRUCT => UnmanagedType.LPStruct, + CILParser.ANY => UnmanagedType.AsAny, + _ => throw new UnreachableException() + }; +#pragma warning restore CS0618 + } + + private static UnmanagedType GetUnsignedNativeType(int tokenType) + => tokenType switch + { + CILParser.INT8 => UnmanagedType.U1, + CILParser.INT16 => UnmanagedType.U2, + CILParser.INT32_ => UnmanagedType.U4, + CILParser.INT64_ => UnmanagedType.U8, + _ => throw new UnreachableException() + }; + + private static BlobBuilder CreateNativeTypeBlob(UnmanagedType value) + => CreateNativeTypeBlob((byte)value); + + private static BlobBuilder CreateNativeTypeBlob(byte value) + { + BlobBuilder blob = new(1); + blob.WriteByte(value); + return blob; + } + + private int ParseMarshallingInt32(IToken? token) + => token is null ? 0 : ParseInt32(token); + + private static MarshallingDescriptorValue GetMarshallingDescriptorValue(object? value) + => value as MarshallingDescriptorValue ?? new MarshallingDescriptorValue(new BlobBuilder(), null); + + private static NativeTypeValue GetNativeTypeValue(object? value) + => value as NativeTypeValue ?? NativeTypeValue.Empty; + + private static NativeTypeElementValue GetNativeTypeElementValue(object? value) + => value as NativeTypeElementValue ?? EmptyNativeTypeElementValue.Instance; + + private static IidParamIndexValue GetIidParamIndexValue(object? value) + => value as IidParamIndexValue ?? IidParamIndexValue.Empty; + + private static VariantTypeValue GetVariantTypeValue(object? value) + => value as VariantTypeValue ?? VariantTypeValue.Empty; + + private bool TryGetMarshalBlobFrame( + CILParser.MarshalBlobContext context, + [NotNullWhen(true)] out MarshalBlobFrame? frame) + { + Debug.Assert(_marshalBlobFrames.Count > 0); + frame = _marshalBlobFrames.Count == 0 ? null : _marshalBlobFrames.Peek(); + Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); + return frame is not null && ReferenceEquals(frame.Owner, context); + } + + private bool TryGetNativeTypeFrame( + CILParser.NativeTypeContext context, + [NotNullWhen(true)] out NativeTypeFrame? frame) + { + Debug.Assert(_nativeTypeFrames.Count > 0); + frame = _nativeTypeFrames.Count == 0 ? null : _nativeTypeFrames.Peek(); + Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); + return frame is not null && ReferenceEquals(frame.Owner, context); + } + + private bool TryGetVariantTypeFrame( + CILParser.VariantTypeContext context, + [NotNullWhen(true)] out VariantTypeFrame? frame) + { + Debug.Assert(_variantTypeFrames.Count > 0); + frame = _variantTypeFrames.Count == 0 ? null : _variantTypeFrames.Peek(); + Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); + return frame is not null && ReferenceEquals(frame.Owner, context); + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Marshalling.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Marshalling.cs index 8a4920b7f1b7d9..83b1fb2ed6058d 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Marshalling.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Marshalling.cs @@ -1,526 +1,122 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System; -using System.Buffers.Binary; -using System.Collections.Generic; -using System.Collections.Immutable; using System.Diagnostics; -using System.Globalization; -using System.IO; -using System.Linq; using System.Reflection; using System.Reflection.Metadata; -using System.Reflection.Metadata.Ecma335; -using System.Reflection.PortableExecutable; using System.Runtime.InteropServices; -using System.Security.Cryptography; -using System.Text; -using Antlr4.Runtime; -using Antlr4.Runtime.Misc; -using Antlr4.Runtime.Tree; -namespace ILAssembler +namespace ILAssembler; + +#pragma warning disable CA1822 // Visitor wrappers intentionally preserve the existing instance API. +internal sealed partial class GrammarActions { -#pragma warning disable CA1822 // Mark members as static - internal sealed partial class GrammarActions : ICILVisitor - { - GrammarResult ICILVisitor.VisitIidParamIndex(CILParser.IidParamIndexContext context) => VisitIidParamIndex(context); - public GrammarResult.Literal VisitIidParamIndex(CILParser.IidParamIndexContext context) - => context.int32() is CILParser.Int32Context int32 ? new(VisitInt32(int32).Value) : new(null); + GrammarResult ICILVisitor.VisitIidParamIndex(CILParser.IidParamIndexContext context) + => VisitIidParamIndex(context); - GrammarResult ICILVisitor.VisitMarshalBlob(CILParser.MarshalBlobContext context) => VisitMarshalBlob(context); - public GrammarResult.FormattedBlob VisitMarshalBlob(CILParser.MarshalBlobContext context) - { - var hexBytes = context.hexbyte(); - if (hexBytes.Length > 0) - { - var blob = new BlobBuilder(hexBytes.Length); - foreach (var hb in hexBytes) - { - blob.WriteByte(hb.Value); - } - return new(blob); - } + public GrammarResult.Literal VisitIidParamIndex(CILParser.IidParamIndexContext context) + => new(MaterializeIidParamIndex(GetIidParamIndexValue(context.Value))); - return VisitNativeType(context.nativeType()); - } + GrammarResult ICILVisitor.VisitMarshalBlob(CILParser.MarshalBlobContext context) + => VisitMarshalBlob(context); - GrammarResult ICILVisitor.VisitMarshalClause(CILParser.MarshalClauseContext context) => VisitMarshalClause(context); - public GrammarResult.FormattedBlob VisitMarshalClause(CILParser.MarshalClauseContext context) - { - if (context.ChildCount == 0) - { - return new(new BlobBuilder(0)); - } + public GrammarResult.FormattedBlob VisitMarshalBlob(CILParser.MarshalBlobContext context) + => new(MaterializeMarshallingDescriptor(GetMarshallingDescriptorValue(context.Value))); - return VisitMarshalBlob(context.marshalBlob()); - } + GrammarResult ICILVisitor.VisitMarshalClause(CILParser.MarshalClauseContext context) + => VisitMarshalClause(context); - GrammarResult ICILVisitor.VisitNativeType(CILParser.NativeTypeContext context) => VisitNativeType(context); - public GrammarResult.FormattedBlob VisitNativeType(CILParser.NativeTypeContext context) - { - if (context.nativeTypeElement() is not CILParser.NativeTypeElementContext element) - { - return new(new BlobBuilder()); - } + public GrammarResult.FormattedBlob VisitMarshalClause(CILParser.MarshalClauseContext context) + => new(MaterializeMarshallingDescriptor(GetMarshallingDescriptorValue(context.Value))); - CILParser.NativeTypeArrayPointerInfoContext[] arrayPointerInfo = context.nativeTypeArrayPointerInfo(); - if (arrayPointerInfo.Length == 0) - { - return VisitNativeTypeElement(element); - } - var prefix = new BlobBuilder(arrayPointerInfo.Length); - var elementType = VisitNativeTypeElement(element).Value; - var suffix = new BlobBuilder(); + GrammarResult ICILVisitor.VisitNativeType(CILParser.NativeTypeContext context) + => VisitNativeType(context); - for (int i = arrayPointerInfo.Length - 1; i >= 0; i--) - { - if (arrayPointerInfo[i] is CILParser.PointerNativeTypeContext) - { - ReportWarning(DiagnosticIds.DeprecatedNativeType, - string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "pointer in array"), - context); - const int NATIVE_TYPE_PTR = 0x10; - prefix.WriteByte(NATIVE_TYPE_PTR); - } - else - { - prefix.WriteByte((byte)UnmanagedType.LPArray); - if (elementType.Count == 0) - { - // We need to have an element type for arrays, - // so write the invalid NATIVE_TYPE_MAX value so we have something parsable. - const int NATIVE_TYPE_MAX = 0x50; - elementType.WriteByte(NATIVE_TYPE_MAX); - } - } - } + public GrammarResult.FormattedBlob VisitNativeType(CILParser.NativeTypeContext context) + => new(MaterializeNativeType(GetNativeTypeValue(context.Value))); - for (int i = 0; i < arrayPointerInfo.Length; i++) - { - if (arrayPointerInfo[i] is CILParser.PointerArrayTypeSizeContext size) - { - suffix.WriteCompressedInteger(0); - suffix.WriteCompressedInteger(VisitInt32(size.int32()).Value); - suffix.WriteCompressedInteger(0); - } - else if (arrayPointerInfo[i] is CILParser.PointerArrayTypeSizeParamIndexContext sizeParamIndex) - { - var ints = sizeParamIndex.int32(); - suffix.WriteCompressedInteger(VisitInt32(ints[1]).Value); - suffix.WriteCompressedInteger(VisitInt32(ints[0]).Value); - suffix.WriteCompressedInteger(1); // Write that the paramIndex parameter was specified - } - else if (arrayPointerInfo[i] is CILParser.PointerArrayTypeParamIndexContext paramIndex) - { - suffix.WriteCompressedInteger(VisitInt32(paramIndex.int32()).Value); - } - } + GrammarResult ICILVisitor.VisitNativeTypeElement(CILParser.NativeTypeElementContext context) + => VisitNativeTypeElement(context); - prefix.LinkSuffix(elementType); - prefix.LinkSuffix(suffix); - return new(prefix); - } + public GrammarResult.FormattedBlob VisitNativeTypeElement(CILParser.NativeTypeElementContext context) + => new(MaterializeNativeTypeElement(GetNativeTypeElementValue(context.Value))); - GrammarResult ICILVisitor.VisitNativeTypeElement(CILParser.NativeTypeElementContext context) => VisitNativeTypeElement(context); - public GrammarResult.FormattedBlob VisitNativeTypeElement(CILParser.NativeTypeElementContext context) - { - var blob = new BlobBuilder(); - if (context.dottedName() is CILParser.DottedNameContext typedef) - { - // Native type typedefs are not yet fully supported - // For now, report an error and return empty blob - string alias = VisitDottedName(typedef).Value; - ReportError(DiagnosticIds.TypedefNotFound, string.Format(DiagnosticMessageTemplates.TypedefNotFound, alias), context); - return new(blob); - } - - if (context.marshalType is null) - { - if (context.marshalBool is not null) - { - blob.WriteByte((byte)UnmanagedType.VariantBool); - } - else if (context.unsignedMarshalType is not null) - { - blob.WriteByte(context.unsignedMarshalType.Type switch - { - CILParser.INT8 => (byte)UnmanagedType.U1, - CILParser.INT16 => (byte)UnmanagedType.U2, - CILParser.INT32_ => (byte)UnmanagedType.U4, - CILParser.INT64_ => (byte)UnmanagedType.U8, - _ => throw new UnreachableException(), - }); - } - return new(blob); - } + GrammarResult ICILVisitor.VisitPinvAttr(CILParser.PinvAttrContext context) + => VisitPinvAttr(context); - switch (context.marshalType.Type) - { - case CILParser.CUSTOM: - { - blob.WriteByte((byte)UnmanagedType.CustomMarshaler); - CILParser.CompQstringContext[] strings = context.compQstring(); - if (strings.Length == 4) - { - ReportWarning(DiagnosticIds.DeprecatedCustomMarshaller, - DiagnosticMessageTemplates.DeprecatedCustomMarshaller, - context); - blob.WriteSerializedString(VisitCompQstring(strings[0]).Value); - blob.WriteSerializedString(VisitCompQstring(strings[1]).Value); - blob.WriteSerializedString(VisitCompQstring(strings[2]).Value); - blob.WriteSerializedString(VisitCompQstring(strings[3]).Value); - } - else - { - Debug.Assert(strings.Length == 2); - blob.WriteCompressedInteger(0); - blob.WriteCompressedInteger(0); - blob.WriteSerializedString(VisitCompQstring(strings[0]).Value); - blob.WriteSerializedString(VisitCompQstring(strings[1]).Value); - } - break; - } - case CILParser.SYSSTRING: - blob.WriteByte((byte)UnmanagedType.ByValTStr); - blob.WriteCompressedInteger(VisitInt32(context.int32()).Value); - break; - case CILParser.ARRAY: - blob.WriteByte((byte)UnmanagedType.ByValArray); - blob.WriteCompressedInteger(VisitInt32(context.int32()).Value); - VisitNativeType(context.nativeType()).Value.WriteContentTo(blob); - break; - case CILParser.VARIANT: - ReportWarning(DiagnosticIds.DeprecatedNativeType, - string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "VARIANT"), - context); - const int NATIVE_TYPE_VARIANT = 0xe; - blob.WriteByte(NATIVE_TYPE_VARIANT); - break; -#pragma warning disable CS0618 // Type or member is obsolete - case CILParser.CURRENCY: - blob.WriteByte((byte)UnmanagedType.Currency); - break; -#pragma warning restore CS0618 // Type or member is obsolete - case CILParser.SYSCHAR: - ReportWarning(DiagnosticIds.DeprecatedNativeType, - string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "SYSCHAR"), - context); - const int NATIVE_TYPE_SYSCHAR = 0xd; - blob.WriteByte(NATIVE_TYPE_SYSCHAR); - break; - case CILParser.VOID: - ReportWarning(DiagnosticIds.DeprecatedNativeType, - string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "VOID"), - context); - const int NATIVE_TYPE_VOID = 0x1; - blob.WriteByte(NATIVE_TYPE_VOID); - break; - case CILParser.BOOL: - blob.WriteByte((byte)UnmanagedType.Bool); - break; - case CILParser.INT8: - blob.WriteByte((byte)UnmanagedType.I1); - break; - case CILParser.INT16: - blob.WriteByte((byte)UnmanagedType.I2); - break; - case CILParser.INT32_: - blob.WriteByte((byte)UnmanagedType.I4); - break; - case CILParser.INT64_: - blob.WriteByte((byte)UnmanagedType.I8); - break; - case CILParser.FLOAT32: - blob.WriteByte((byte)UnmanagedType.R4); - break; - case CILParser.FLOAT64_: - blob.WriteByte((byte)UnmanagedType.R8); - break; - case CILParser.ERROR: - blob.WriteByte((byte)UnmanagedType.Error); - break; - case CILParser.UINT8: - blob.WriteByte((byte)UnmanagedType.U1); - break; - case CILParser.UINT16: - blob.WriteByte((byte)UnmanagedType.U2); - break; - case CILParser.UINT32: - blob.WriteByte((byte)UnmanagedType.U4); - break; - case CILParser.UINT64: - blob.WriteByte((byte)UnmanagedType.U8); - break; - case CILParser.DECIMAL: - ReportWarning(DiagnosticIds.DeprecatedNativeType, - string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "DECIMAL"), - context); - const int NATIVE_TYPE_DECIMAL = 0x11; - blob.WriteByte(NATIVE_TYPE_DECIMAL); - break; - case CILParser.DATE: - ReportWarning(DiagnosticIds.DeprecatedNativeType, - string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "DATE"), - context); - const int NATIVE_TYPE_DATE = 0x12; - blob.WriteByte(NATIVE_TYPE_DATE); - break; - case CILParser.BSTR: - // Distinguish 'ansi bstr' (AnsiBStr) from plain 'bstr' (BStr) - if (context.ANSI() is not null) - { -#pragma warning disable CS0618 // Type or member is obsolete - blob.WriteByte((byte)UnmanagedType.AnsiBStr); -#pragma warning restore CS0618 - } - else - { - blob.WriteByte((byte)UnmanagedType.BStr); - } - break; - case CILParser.LPSTR: - blob.WriteByte((byte)UnmanagedType.LPStr); - break; - case CILParser.LPWSTR: - blob.WriteByte((byte)UnmanagedType.LPWStr); - break; - case CILParser.LPTSTR: - blob.WriteByte((byte)UnmanagedType.LPTStr); - break; - case CILParser.OBJECTREF: - ReportWarning(DiagnosticIds.DeprecatedNativeType, - string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "OBJECTREF"), - context); - const int NATIVE_TYPE_OBJECTREF = 0x18; - blob.WriteByte(NATIVE_TYPE_OBJECTREF); - break; - case CILParser.IUNKNOWN: - { - blob.WriteByte((byte)UnmanagedType.IUnknown); - if (VisitIidParamIndex(context.iidParamIndex()) is { Value: int index }) - { - blob.WriteCompressedInteger(index); - } - break; - } - case CILParser.IDISPATCH: - { - blob.WriteByte((byte)UnmanagedType.IDispatch); - if (VisitIidParamIndex(context.iidParamIndex()) is { Value: int index }) - { - blob.WriteCompressedInteger(index); - } - break; - } - case CILParser.STRUCT: - // Distinguish 'nested struct' from plain 'struct' - if (context.GetChild(0)?.GetText() == "nested") - { - ReportWarning(DiagnosticIds.DeprecatedNativeType, - string.Format(DiagnosticMessageTemplates.DeprecatedNativeType, "NESTEDSTRUCT"), - context); - const int NATIVE_TYPE_NESTEDSTRUCT = 0x21; - blob.WriteByte(NATIVE_TYPE_NESTEDSTRUCT); - } - else - { - blob.WriteByte((byte)UnmanagedType.Struct); - } - break; - case CILParser.INTERFACE: - { - blob.WriteByte((byte)UnmanagedType.Interface); - if (VisitIidParamIndex(context.iidParamIndex()) is { Value: int index }) - { - blob.WriteCompressedInteger(index); - } - break; - } - case CILParser.SAFEARRAY: - blob.WriteByte((byte)UnmanagedType.SafeArray); - blob.WriteCompressedInteger((int)VisitVariantType(context.variantType()).Value); - if (context.compQstring() is { Length: 1 } safeArrayCustomType) - { - string str = VisitCompQstring(safeArrayCustomType[0]).Value; - blob.WriteSerializedString(str); - } - else - { - blob.WriteCompressedInteger(0); - } - break; - case CILParser.INT: - blob.WriteByte((byte)UnmanagedType.SysInt); - break; - case CILParser.UINT: - blob.WriteByte((byte)UnmanagedType.SysUInt); - break; -#pragma warning disable CS0618 // Type or member is obsolete - case CILParser.BYVALSTR: - blob.WriteByte((byte)UnmanagedType.VBByRefStr); - break; - case CILParser.TBSTR: - blob.WriteByte((byte)UnmanagedType.TBStr); - break; -#pragma warning restore CS0618 // Type or member is obsolete - case CILParser.METHOD: - blob.WriteByte((byte)UnmanagedType.FunctionPtr); - break; - case CILParser.LPSTRUCT: - blob.WriteByte((byte)UnmanagedType.LPStruct); - break; -#pragma warning disable CS0618 // Type or member is obsolete - case CILParser.ANY: - blob.WriteByte((byte)UnmanagedType.AsAny); - break; -#pragma warning restore CS0618 // Type or member is obsolete - } - - return new(blob); + public GrammarResult.Flag VisitPinvAttr(CILParser.PinvAttrContext context) + { + if (context.int32() is CILParser.Int32Context int32) + { + return new((MethodImportAttributes)VisitInt32(int32).Value, ShouldAppend: false); } - GrammarResult ICILVisitor.VisitPinvAttr(CILParser.PinvAttrContext context) => VisitPinvAttr(context); - public GrammarResult.Flag VisitPinvAttr(CILParser.PinvAttrContext context) + return context.GetText() switch { - if (context.int32() is CILParser.Int32Context int32) - { - return new((MethodImportAttributes)VisitInt32(int32).Value, ShouldAppend: false); - } - switch (context.GetText()) - { - case "nomangle": - return new(MethodImportAttributes.ExactSpelling); - case "ansi": - return new(MethodImportAttributes.CharSetAnsi); - case "unicode": - return new(MethodImportAttributes.CharSetUnicode); - case "autochar": - return new(MethodImportAttributes.CharSetAuto); - case "lasterr": - return new(MethodImportAttributes.SetLastError); - case "winapi": - return new(MethodImportAttributes.CallingConventionWinApi); - case "cdecl": - return new(MethodImportAttributes.CallingConventionCDecl); - case "stdcall": - return new(MethodImportAttributes.CallingConventionStdCall); - case "thiscall": - return new(MethodImportAttributes.CallingConventionThisCall); - case "fastcall": - return new(MethodImportAttributes.CallingConventionFastCall); - case "bestfit:on": - return new(MethodImportAttributes.BestFitMappingEnable); - case "bestfit:off": - return new(MethodImportAttributes.BestFitMappingDisable); - case "charmaperror:on": - return new(MethodImportAttributes.ThrowOnUnmappableCharEnable); - case "charmaperror:off": - return new(MethodImportAttributes.ThrowOnUnmappableCharDisable); - default: - throw new UnreachableException(); - } - } + "nomangle" => new(MethodImportAttributes.ExactSpelling), + "ansi" => new(MethodImportAttributes.CharSetAnsi), + "unicode" => new(MethodImportAttributes.CharSetUnicode), + "autochar" => new(MethodImportAttributes.CharSetAuto), + "lasterr" => new(MethodImportAttributes.SetLastError), + "winapi" => new(MethodImportAttributes.CallingConventionWinApi), + "cdecl" => new(MethodImportAttributes.CallingConventionCDecl), + "stdcall" => new(MethodImportAttributes.CallingConventionStdCall), + "thiscall" => new(MethodImportAttributes.CallingConventionThisCall), + "fastcall" => new(MethodImportAttributes.CallingConventionFastCall), + "bestfit:on" => new(MethodImportAttributes.BestFitMappingEnable), + "bestfit:off" => new(MethodImportAttributes.BestFitMappingDisable), + "charmaperror:on" => new(MethodImportAttributes.ThrowOnUnmappableCharEnable), + "charmaperror:off" => new(MethodImportAttributes.ThrowOnUnmappableCharDisable), + _ => throw new UnreachableException() + }; + } - GrammarResult ICILVisitor.VisitPinvImpl(CILParser.PinvImplContext context) => VisitPinvImpl(context); - public GrammarResult.Literal<(string? ModuleName, string? EntryPointName, MethodImportAttributes Attributes)> VisitPinvImpl(CILParser.PinvImplContext context) + GrammarResult ICILVisitor.VisitPinvImpl(CILParser.PinvImplContext context) + => VisitPinvImpl(context); + + public GrammarResult.Literal<(string? ModuleName, string? EntryPointName, MethodImportAttributes Attributes)> VisitPinvImpl( + CILParser.PinvImplContext context) + { + MethodImportAttributes attributes = MethodImportAttributes.None; + foreach (CILParser.PinvAttrContext attribute in context.pinvAttr()) { - MethodImportAttributes attrs = MethodImportAttributes.None; - foreach (var attr in context.pinvAttr()) - { - attrs |= VisitPinvAttr(attr); - } - var names = context.compQstring(); - string? moduleName = names.Length > 0 ? VisitCompQstring(names[0]).Value : null; - string? entryPointName = names.Length > 1 ? VisitCompQstring(names[1]).Value : null; - return new((moduleName, entryPointName, attrs)); + attributes |= VisitPinvAttr(attribute); } + CILParser.CompQstringContext[] names = context.compQstring(); + string? moduleName = names.Length > 0 ? VisitCompQstring(names[0]).Value : null; + string? entryPointName = names.Length > 1 ? VisitCompQstring(names[1]).Value : null; + return new((moduleName, entryPointName, attributes)); + } - GrammarResult ICILVisitor.VisitVariantType(CILParser.VariantTypeContext context) => VisitVariantType(context); - public GrammarResult.Literal VisitVariantType(CILParser.VariantTypeContext context) - { - if (context.variantTypeElement() is not CILParser.VariantTypeElementContext element) - { - return new(VarEnum.VT_EMPTY); - } + GrammarResult ICILVisitor.VisitVariantType(CILParser.VariantTypeContext context) + => VisitVariantType(context); - VarEnum variant = VisitVariantTypeElement(element).Value; - // The 0th child is the variant element type. - for (int i = 1; i < context.ChildCount; i++) - { - ITerminalNode childToken = (ITerminalNode)context.children[i]; - if (childToken.Symbol.Type == CILParser.ARRAY_TYPE_NO_BOUNDS) - { - variant |= VarEnum.VT_ARRAY; - } - else if (childToken.Symbol.Type == CILParser.VECTOR) - { - variant |= VarEnum.VT_VECTOR; - } - else - { - Debug.Assert(childToken.Symbol.Type == CILParser.REF); - variant |= VarEnum.VT_BYREF; - } - } - return new(variant); - } + public GrammarResult.Literal VisitVariantType(CILParser.VariantTypeContext context) + => new(MaterializeVariantType(GetVariantTypeValue(context.Value))); - GrammarResult ICILVisitor.VisitVariantTypeElement(CILParser.VariantTypeElementContext context) => VisitVariantTypeElement(context); - public GrammarResult.Literal VisitVariantTypeElement(CILParser.VariantTypeElementContext context) - { - return new(context.GetChild(0).Symbol.Type switch - { - CILParser.VARIANT => VarEnum.VT_VARIANT, - CILParser.CURRENCY => VarEnum.VT_CY, - CILParser.VOID => VarEnum.VT_VOID, - CILParser.BOOL => VarEnum.VT_BOOL, - CILParser.INT8 => VarEnum.VT_I1, - CILParser.INT16 => VarEnum.VT_I2, - CILParser.INT32_ => VarEnum.VT_I4, - CILParser.INT64_ => VarEnum.VT_I8, - CILParser.FLOAT32 => VarEnum.VT_R4, - CILParser.FLOAT64_ => VarEnum.VT_R8, - CILParser.UINT8 => VarEnum.VT_UI1, - CILParser.UINT16 => VarEnum.VT_UI2, - CILParser.UINT32 => VarEnum.VT_UI4, - CILParser.UINT64 => VarEnum.VT_UI8, - CILParser.PTR => VarEnum.VT_PTR, - CILParser.DECIMAL => VarEnum.VT_DECIMAL, - CILParser.DATE => VarEnum.VT_DATE, - CILParser.BSTR => VarEnum.VT_BSTR, - CILParser.LPSTR => VarEnum.VT_LPSTR, - CILParser.LPWSTR => VarEnum.VT_LPWSTR, - CILParser.IUNKNOWN => VarEnum.VT_UNKNOWN, - CILParser.IDISPATCH => VarEnum.VT_DISPATCH, - CILParser.SAFEARRAY => VarEnum.VT_SAFEARRAY, - CILParser.INT => VarEnum.VT_INT, - CILParser.UINT => VarEnum.VT_UINT, - CILParser.ERROR => VarEnum.VT_ERROR, - CILParser.HRESULT => VarEnum.VT_HRESULT, - CILParser.CARRAY => VarEnum.VT_CARRAY, - CILParser.USERDEFINED => VarEnum.VT_USERDEFINED, - CILParser.RECORD => VarEnum.VT_RECORD, - CILParser.FILETIME => VarEnum.VT_FILETIME, - CILParser.BLOB => VarEnum.VT_BLOB, - CILParser.STREAM => VarEnum.VT_STREAM, - CILParser.STORAGE => VarEnum.VT_STORAGE, - CILParser.STREAMED_OBJECT => VarEnum.VT_STREAMED_OBJECT, - CILParser.STORED_OBJECT => VarEnum.VT_STORED_OBJECT, - CILParser.BLOB_OBJECT => VarEnum.VT_BLOB_OBJECT, - CILParser.CF => VarEnum.VT_CF, - CILParser.CLSID => VarEnum.VT_CLSID, - _ => throw new UnreachableException() - }); - } - public GrammarResult VisitNativeTypeArrayPointerInfo(CILParser.NativeTypeArrayPointerInfoContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - public GrammarResult VisitPointerArrayTypeSize(CILParser.PointerArrayTypeSizeContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - public GrammarResult VisitPointerArrayTypeParamIndex(CILParser.PointerArrayTypeParamIndexContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - public GrammarResult VisitPointerNativeType(CILParser.PointerNativeTypeContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - public GrammarResult VisitPointerArrayTypeSizeParamIndex(CILParser.PointerArrayTypeSizeParamIndexContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - public GrammarResult VisitPointerArrayTypeNoSizeData(CILParser.PointerArrayTypeNoSizeDataContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + GrammarResult ICILVisitor.VisitVariantTypeElement(CILParser.VariantTypeElementContext context) + => VisitVariantTypeElement(context); - } + public GrammarResult.Literal VisitVariantTypeElement(CILParser.VariantTypeElementContext context) + => new(MaterializeVariantTypeElement( + context.Value as VariantTypeElementValue ?? new VariantTypeElementValue(0))); + + public GrammarResult VisitNativeTypeArrayPointerInfo(CILParser.NativeTypeArrayPointerInfoContext context) + => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + + public GrammarResult VisitPointerArrayTypeSize(CILParser.PointerArrayTypeSizeContext context) + => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + + public GrammarResult VisitPointerArrayTypeParamIndex(CILParser.PointerArrayTypeParamIndexContext context) + => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + + public GrammarResult VisitPointerNativeType(CILParser.PointerNativeTypeContext context) + => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + + public GrammarResult VisitPointerArrayTypeSizeParamIndex(CILParser.PointerArrayTypeSizeParamIndexContext context) + => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + + public GrammarResult VisitPointerArrayTypeNoSizeData(CILParser.PointerArrayTypeNoSizeDataContext context) + => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Actions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Actions.cs index 8abf0c02037130..6e40b53eecc030 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Actions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Actions.cs @@ -246,13 +246,13 @@ internal object CreateSentinelSignatureArgument() internal object CreateSignatureArgument( int attributes, object? type, - CILParser.MarshalClauseContext marshalling, + object? marshalling, CILParser.IdContext? name) => new SignatureArgumentValue( false, attributes, GetTypeValue(type), - marshalling, + GetMarshallingDescriptorValue(marshalling), name is null ? null : VisitId(name).Value); internal void BeginParameterAttributes(CILParser.ParamAttrContext context) diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Types.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Types.cs index a371aa1d532ed7..fd7a323ca09fe8 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Types.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Types.cs @@ -211,7 +211,7 @@ private SignatureArg MaterializeSignatureArgument(SignatureArgumentValue argumen return new SignatureArg( (System.Reflection.ParameterAttributes)argument.Attributes, MaterializeType(argument.Type ?? TypeValue.Error), - argument.Marshalling is null ? new BlobBuilder(0) : VisitMarshalClause(argument.Marshalling).Value, + MaterializeMarshallingDescriptor(argument.Marshalling), argument.Name); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Values.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Values.cs index d0f29526dc7aa0..cd902835315e01 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Values.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Values.cs @@ -124,7 +124,7 @@ private sealed record SignatureArgumentValue( bool IsSentinel, int Attributes, TypeValue? Type, - CILParser.MarshalClauseContext? Marshalling, + MarshallingDescriptorValue? Marshalling, string? Name) { public static SignatureArgumentValue Error { get; } = new(false, 0, TypeValue.Error, null, null); diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs index 5d79d339cc7d68..b1d81f6ab33471 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs @@ -30,7 +30,10 @@ _currentMethod is null && _typeArgumentsFrames.Count == 0 && _boundsFrames.Count == 0 && _signatureArgumentsFrames.Count == 0 - && _parameterAttributesFrames.Count == 0, + && _parameterAttributesFrames.Count == 0 + && _marshalBlobFrames.Count == 0 + && _nativeTypeFrames.Count == 0 + && _variantTypeFrames.Count == 0, "Per-document semantic state must be released by the owning rule's finally block."); EndMethod(); @@ -44,6 +47,9 @@ _currentMethod is null _boundsFrames.Clear(); _signatureArgumentsFrames.Clear(); _parameterAttributesFrames.Clear(); + _marshalBlobFrames.Clear(); + _nativeTypeFrames.Clear(); + _variantTypeFrames.Clear(); _syntaxErrorCount = 0; } } diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 index 44dbd1683459a9..18810213f5acce 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 @@ -779,7 +779,7 @@ finally {_localctx.Value = Actions.EndSignatureArguments(_localctx);} sigArg returns [object Value]: ELLIPSIS {_localctx.Value = Actions.CreateSentinelSignatureArgument();} | attributes = paramAttr argumentType = type marshalling = marshalClause name = id? - {_localctx.Value = Actions.CreateSignatureArgument($attributes.Value, $argumentType.Value, $marshalling.ctx, $name.ctx);}; + {_localctx.Value = Actions.CreateSignatureArgument($attributes.Value, $argumentType.Value, $marshalling.Value, $name.ctx);}; /* Class referencing */ @@ -822,116 +822,138 @@ returns [object Value, bool HasSyntaxError] finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} /* Native types for marshaling signatures */ -nativeType: +nativeType returns [object Value] +@init {Actions.BeginNativeType(_localctx);} +: /* EMPTY */ - | nativeTypeElement nativeTypeArrayPointerInfo*; - -nativeTypeArrayPointerInfo: - PTR # PointerNativeType - | ARRAY_TYPE_NO_BOUNDS # PointerArrayTypeNoSizeData - | '[' int32 ']' # PointerArrayTypeSize - | '[' int32 PLUS int32 ']' # PointerArrayTypeSizeParamIndex - | '[' PLUS int32 ']' # PointerArrayTypeParamIndex + | element = nativeTypeElement {Actions.SetNativeTypeElement(_localctx, $element.Value);} + (info = nativeTypeArrayPointerInfo {Actions.AddNativeTypeArrayPointerInfo(_localctx, $info.Value);})* +; +finally {_localctx.Value = Actions.EndNativeType(_localctx);} + +nativeTypeArrayPointerInfo returns [object Value]: + PTR {_localctx.Value = Actions.CreatePointerNativeType();} # PointerNativeType + | ARRAY_TYPE_NO_BOUNDS {_localctx.Value = Actions.CreatePointerArrayTypeNoSizeData();} # PointerArrayTypeNoSizeData + | '[' size = int32 ']' {_localctx.Value = Actions.CreatePointerArrayTypeSize($size.start);} # PointerArrayTypeSize + | '[' size = int32 PLUS parameterIndex = int32 ']' + {_localctx.Value = Actions.CreatePointerArrayTypeSizeParamIndex($size.start, $parameterIndex.start);} # PointerArrayTypeSizeParamIndex + | '[' PLUS parameterIndex = int32 ']' + {_localctx.Value = Actions.CreatePointerArrayTypeParamIndex($parameterIndex.start);} # PointerArrayTypeParamIndex ; -nativeTypeElement: +nativeTypeElement returns [object Value]: + /* EMPTY */ {_localctx.Value = Actions.CreateEmptyNativeType();} + | marshalType = CUSTOM '(' guid = compQstring ',' nativeTypeName = compQstring ',' + marshallerType = compQstring ',' cookie = compQstring ')' + {_localctx.Value = Actions.CreateDeprecatedCustomMarshallerNativeType( + _localctx, $guid.Value, $nativeTypeName.Value, $marshallerType.Value, $cookie.Value);} + | marshalType = CUSTOM '(' marshallerType = compQstring ',' cookie = compQstring ')' + {_localctx.Value = Actions.CreateCustomMarshallerNativeType($marshallerType.Value, $cookie.Value);} + | FIXED marshalType = SYSSTRING '[' size = int32 ']' + {_localctx.Value = Actions.CreateFixedSysStringNativeType($size.start);} + | FIXED marshalType = ARRAY '[' size = int32 ']' element = nativeType + {_localctx.Value = Actions.CreateFixedArrayNativeType($size.start, $element.Value);} + | marshalType = VARIANT {_localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, $marshalType);} + | marshalType = CURRENCY {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | marshalType = SYSCHAR {_localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, $marshalType);} + | marshalType = VOID {_localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, $marshalType);} + | marshalType = BOOL {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | marshalType = INT8 {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | marshalType = INT16 {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | marshalType = INT32_ {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | marshalType = INT64_ {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | marshalType = FLOAT32 {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | marshalType = FLOAT64_ {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | marshalType = ERROR {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | marshalType = UINT8 {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | marshalType = UINT16 {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | marshalType = UINT32 {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | marshalType = UINT64 {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | marshalType = DECIMAL {_localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, $marshalType);} + | marshalType = DATE {_localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, $marshalType);} + | marshalType = BSTR {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | marshalType = LPSTR {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | marshalType = LPWSTR {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | marshalType = LPTSTR {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | marshalType = OBJECTREF {_localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, $marshalType);} + | marshalType = IUNKNOWN index = iidParamIndex {_localctx.Value = Actions.CreateIidNativeType($marshalType, $index.Value);} + | marshalType = IDISPATCH index = iidParamIndex {_localctx.Value = Actions.CreateIidNativeType($marshalType, $index.Value);} + | marshalType = STRUCT {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | marshalType = INTERFACE index = iidParamIndex {_localctx.Value = Actions.CreateIidNativeType($marshalType, $index.Value);} + | marshalType = SAFEARRAY variant = variantType + {_localctx.Value = Actions.CreateSafeArrayNativeType($variant.Value, null);} + | marshalType = SAFEARRAY variant = variantType ',' userDefinedType = compQstring + {_localctx.Value = Actions.CreateSafeArrayNativeType($variant.Value, $userDefinedType.Value);} + | marshalType = INT {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | marshalType = UINT {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | 'unsigned' unsignedMarshalType = INT8 {_localctx.Value = Actions.CreateUnsignedNativeType($unsignedMarshalType);} + | 'unsigned' unsignedMarshalType = INT16 {_localctx.Value = Actions.CreateUnsignedNativeType($unsignedMarshalType);} + | 'unsigned' unsignedMarshalType = INT32_ {_localctx.Value = Actions.CreateUnsignedNativeType($unsignedMarshalType);} + | 'unsigned' unsignedMarshalType = INT64_ {_localctx.Value = Actions.CreateUnsignedNativeType($unsignedMarshalType);} + | 'nested' marshalType = STRUCT {_localctx.Value = Actions.CreateNestedStructNativeType(_localctx);} + | marshalType = BYVALSTR {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | ANSI marshalType = BSTR {_localctx.Value = Actions.CreateAnsiBstrNativeType();} + | marshalType = TBSTR {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | VARIANT marshalBool = BOOL {_localctx.Value = Actions.CreateVariantBoolNativeType();} + | marshalType = METHOD {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | marshalType = LPSTRUCT {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | 'as' marshalType = ANY {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} + | alias = dottedName {_localctx.Value = Actions.CreateNativeTypeTypedef(_localctx, $alias.Value);} /* typedef */; + +iidParamIndex returns [object Value]: /* EMPTY */ - | marshalType=CUSTOM '(' compQstring ',' compQstring ',' compQstring ',' compQstring ')' - | marshalType=CUSTOM '(' compQstring ',' compQstring ')' - | FIXED marshalType=SYSSTRING '[' int32 ']' - | FIXED marshalType=ARRAY '[' int32 ']' nativeType - | marshalType=VARIANT - | marshalType=CURRENCY - | marshalType=SYSCHAR - | marshalType=VOID - | marshalType=BOOL - | marshalType=INT8 - | marshalType=INT16 - | marshalType=INT32_ - | marshalType=INT64_ - | marshalType=FLOAT32 - | marshalType=FLOAT64_ - | marshalType=ERROR - | marshalType=UINT8 - | marshalType=UINT16 - | marshalType=UINT32 - | marshalType=UINT64 - | marshalType=DECIMAL - | marshalType=DATE - | marshalType=BSTR - | marshalType=LPSTR - | marshalType=LPWSTR - | marshalType=LPTSTR - | marshalType=OBJECTREF - | marshalType=IUNKNOWN iidParamIndex - | marshalType=IDISPATCH iidParamIndex - | marshalType=STRUCT - | marshalType=INTERFACE iidParamIndex - | marshalType=SAFEARRAY variantType - | marshalType=SAFEARRAY variantType ',' compQstring - | marshalType=INT - | marshalType=UINT - | 'unsigned' unsignedMarshalType=INT8 - | 'unsigned' unsignedMarshalType=INT16 - | 'unsigned' unsignedMarshalType=INT32_ - | 'unsigned' unsignedMarshalType=INT64_ - | 'nested' marshalType=STRUCT - | marshalType=BYVALSTR - | ANSI marshalType=BSTR - | marshalType=TBSTR - | VARIANT marshalBool=BOOL - | marshalType=METHOD - | marshalType=LPSTRUCT - | 'as' marshalType=ANY - | dottedName /* typedef */; + | '(' 'iidparam' '=' index = int32 ')' {_localctx.Value = Actions.GetIidParamIndex($index.start);}; -iidParamIndex: /* EMPTY */ | '(' 'iidparam' '=' int32 ')'; - -variantType: +variantType returns [object Value] +@init {Actions.BeginVariantType(_localctx);} +: /*EMPTY */ - | variantTypeElement (ARRAY_TYPE_NO_BOUNDS | VECTOR | REF)*; - -variantTypeElement: - NULL - | VARIANT - | CURRENCY - | VOID - | BOOL - | INT8 - | INT16 - | INT32_ - | INT64_ - | FLOAT32 - | FLOAT64_ - | UINT8 - | UINT16 - | UINT32 - | UINT64 - | PTR - | DECIMAL - | DATE - | BSTR - | LPSTR - | LPWSTR - | IUNKNOWN - | IDISPATCH - | SAFEARRAY - | INT - | UINT - | ERROR - | HRESULT - | CARRAY - | USERDEFINED - | RECORD - | FILETIME - | BLOB - | STREAM - | STORAGE - | STREAMED_OBJECT - | STORED_OBJECT - | BLOB_OBJECT - | CF - | CLSID; + | element = variantTypeElement {Actions.SetVariantTypeElement(_localctx, $element.Value);} + (modifier = (ARRAY_TYPE_NO_BOUNDS | VECTOR | REF) {Actions.AddVariantTypeModifier(_localctx, $modifier);})* +; +finally {_localctx.Value = Actions.EndVariantType(_localctx);} + +variantTypeElement returns [object Value]: + value = NULL {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = VARIANT {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = CURRENCY {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = VOID {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = BOOL {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = INT8 {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = INT16 {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = INT32_ {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = INT64_ {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = FLOAT32 {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = FLOAT64_ {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = UINT8 {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = UINT16 {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = UINT32 {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = UINT64 {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = PTR {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = DECIMAL {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = DATE {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = BSTR {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = LPSTR {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = LPWSTR {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = IUNKNOWN {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = IDISPATCH {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = SAFEARRAY {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = INT {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = UINT {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = ERROR {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = HRESULT {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = CARRAY {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = USERDEFINED {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = RECORD {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = FILETIME {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = BLOB {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = STREAM {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = STORAGE {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = STREAMED_OBJECT {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = STORED_OBJECT {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = BLOB_OBJECT {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = CF {_localctx.Value = Actions.GetVariantTypeElement($value);} + | value = CLSID {_localctx.Value = Actions.GetVariantTypeElement($value);}; /* Managed types for signatures */ type returns [object Value] @@ -1248,15 +1270,18 @@ propDecl: /* Method declaration */ -marshalClause -@init {BeginSubtree();} -: - /* EMPTY */ - | 'marshal' '(' marshalBlob ')' +marshalClause returns [object Value]: + /* EMPTY */ {_localctx.Value = Actions.CreateEmptyMarshallingDescriptor();} + | 'marshal' '(' value = marshalBlob ')' {_localctx.Value = Actions.CompleteMarshalClause($value.Value);} ; -finally {EndParseTreeMode();} -marshalBlob: nativeType | '{' hexbyte+ '}'; +marshalBlob returns [object Value] +@init {Actions.BeginMarshalBlob(_localctx);} +: + nativeValue = nativeType {Actions.SetMarshalBlobNativeType(_localctx, $nativeValue.Value);} + | '{' (rawByte = hexbyte {Actions.AddMarshalBlobByte(_localctx, $rawByte.Value);})+ '}' +; +finally {_localctx.Value = Actions.EndMarshalBlob(_localctx);} paramAttr returns [int Value] @init {Actions.BeginParameterAttributes(_localctx);} diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.interp b/src/tools/ilasm/src/ILAssembler/gen/CIL.interp index 5cc6ec413ec9e2..2ea27fc98060ca 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.interp +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.interp @@ -793,4 +793,4 @@ manifestResDecl atn: -[4, 1, 305, 3067, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 359, 8, 1, 10, 1, 12, 1, 362, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 369, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 5, 3, 376, 8, 3, 10, 3, 12, 3, 379, 9, 3, 1, 3, 1, 3, 1, 3, 1, 4, 5, 4, 385, 8, 4, 10, 4, 12, 4, 388, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 440, 8, 5, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 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, 481, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 5, 15, 488, 8, 15, 10, 15, 12, 15, 491, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 520, 8, 18, 1, 19, 1, 19, 3, 19, 524, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 542, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 569, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 592, 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, 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, 628, 8, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 638, 8, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 5, 27, 645, 8, 27, 10, 27, 12, 27, 648, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 657, 8, 28, 10, 28, 12, 28, 660, 9, 28, 1, 29, 1, 29, 1, 30, 1, 30, 3, 30, 666, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 677, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 685, 8, 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, 34, 1, 34, 1, 34, 1, 34, 5, 34, 706, 8, 34, 10, 34, 12, 34, 709, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 5, 37, 722, 8, 37, 10, 37, 12, 37, 725, 9, 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, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 769, 8, 38, 1, 39, 1, 39, 1, 39, 3, 39, 774, 8, 39, 1, 40, 1, 40, 1, 40, 3, 40, 779, 8, 40, 1, 41, 5, 41, 782, 8, 41, 10, 41, 12, 41, 785, 9, 41, 1, 42, 1, 42, 1, 42, 5, 42, 790, 8, 42, 10, 42, 12, 42, 793, 9, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 902, 8, 44, 1, 45, 1, 45, 5, 45, 906, 8, 45, 10, 45, 12, 45, 909, 9, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 922, 8, 45, 10, 45, 12, 45, 925, 9, 45, 1, 45, 1, 45, 1, 45, 3, 45, 930, 8, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 936, 8, 47, 1, 48, 1, 48, 1, 49, 5, 49, 941, 8, 49, 10, 49, 12, 49, 944, 9, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 971, 8, 50, 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, 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, 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, 1049, 8, 51, 3, 51, 1051, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1065, 8, 53, 1, 53, 1, 53, 5, 53, 1069, 8, 53, 10, 53, 12, 53, 1072, 9, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1080, 8, 53, 3, 53, 1082, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1089, 8, 54, 10, 54, 12, 54, 1092, 9, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1103, 8, 55, 10, 55, 12, 55, 1106, 9, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 5, 56, 1117, 8, 56, 10, 56, 12, 56, 1120, 9, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1127, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 1135, 8, 57, 1, 57, 1, 57, 3, 57, 1139, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1178, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 1184, 8, 59, 10, 59, 12, 59, 1187, 9, 59, 1, 59, 1, 59, 1, 59, 1, 60, 5, 60, 1193, 8, 60, 10, 60, 12, 60, 1196, 9, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1203, 8, 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, 3, 62, 1222, 8, 62, 1, 63, 1, 63, 1, 63, 5, 63, 1227, 8, 63, 10, 63, 12, 63, 1230, 9, 63, 3, 63, 1232, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 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, 1251, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1345, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1354, 8, 66, 1, 67, 1, 67, 1, 67, 5, 67, 1359, 8, 67, 10, 67, 12, 67, 1362, 9, 67, 3, 67, 1364, 8, 67, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 5, 69, 1373, 8, 69, 10, 69, 12, 69, 1376, 9, 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, 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, 1407, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1467, 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, 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, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1507, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1523, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1533, 8, 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, 3, 76, 1560, 8, 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, 1584, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 5, 77, 1590, 8, 77, 10, 77, 12, 77, 1593, 9, 77, 1, 77, 3, 77, 1596, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1611, 8, 78, 1, 79, 1, 79, 1, 79, 5, 79, 1616, 8, 79, 10, 79, 12, 79, 1619, 9, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1663, 8, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1673, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1691, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1709, 8, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1728, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1749, 8, 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, 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 1768, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1783, 8, 89, 1, 90, 1, 90, 1, 90, 5, 90, 1788, 8, 90, 10, 90, 12, 90, 1791, 9, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 1800, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 1813, 8, 92, 1, 93, 5, 93, 1816, 8, 93, 10, 93, 12, 93, 1819, 9, 93, 1, 94, 1, 94, 3, 94, 1823, 8, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 5, 95, 1830, 8, 95, 10, 95, 12, 95, 1833, 9, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 3, 97, 1842, 8, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1926, 8, 99, 10, 99, 12, 99, 1929, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1935, 8, 99, 10, 99, 12, 99, 1938, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1948, 8, 99, 10, 99, 12, 99, 1951, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 1959, 8, 99, 10, 99, 12, 99, 1962, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 1969, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 1979, 8, 100, 10, 100, 12, 100, 1982, 9, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 2008, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 2015, 8, 102, 1, 103, 1, 103, 1, 103, 3, 103, 2020, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 2027, 8, 104, 1, 105, 1, 105, 5, 105, 2031, 8, 105, 10, 105, 12, 105, 2034, 9, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2041, 8, 105, 10, 105, 12, 105, 2044, 9, 105, 1, 105, 3, 105, 2047, 8, 105, 1, 106, 1, 106, 1, 107, 5, 107, 2052, 8, 107, 10, 107, 12, 107, 2055, 9, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 2069, 8, 108, 1, 109, 1, 109, 5, 109, 2073, 8, 109, 10, 109, 12, 109, 2076, 9, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 111, 5, 111, 2087, 8, 111, 10, 111, 12, 111, 2090, 9, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 2102, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 2110, 8, 113, 1, 114, 1, 114, 1, 114, 4, 114, 2115, 8, 114, 11, 114, 12, 114, 2116, 1, 114, 1, 114, 3, 114, 2121, 8, 114, 1, 115, 1, 115, 1, 115, 5, 115, 2126, 8, 115, 10, 115, 12, 115, 2129, 9, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 2148, 8, 116, 1, 117, 1, 117, 1, 117, 5, 117, 2153, 8, 117, 10, 117, 12, 117, 2156, 9, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2166, 8, 117, 10, 117, 12, 117, 2169, 9, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2194, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2201, 8, 119, 3, 119, 2203, 8, 119, 1, 119, 5, 119, 2206, 8, 119, 10, 119, 12, 119, 2209, 9, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2214, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2243, 8, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 2252, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2275, 8, 122, 1, 123, 5, 123, 2278, 8, 123, 10, 123, 12, 123, 2281, 9, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2300, 8, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2351, 8, 125, 10, 125, 12, 125, 2354, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2360, 8, 125, 10, 125, 12, 125, 2363, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2373, 8, 125, 10, 125, 12, 125, 2376, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2384, 8, 125, 10, 125, 12, 125, 2387, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2395, 8, 125, 10, 125, 12, 125, 2398, 9, 125, 3, 125, 2400, 8, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 3, 127, 2408, 8, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 130, 4, 130, 2418, 8, 130, 11, 130, 12, 130, 2419, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 2434, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 3, 132, 2448, 8, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 2456, 8, 133, 1, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 2476, 8, 137, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 2488, 8, 139, 1, 140, 1, 140, 1, 140, 3, 140, 2493, 8, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 4, 141, 2500, 8, 141, 11, 141, 12, 141, 2501, 3, 141, 2504, 8, 141, 1, 142, 1, 142, 1, 142, 5, 142, 2509, 8, 142, 10, 142, 12, 142, 2512, 9, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 2521, 8, 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, 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, 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, 2589, 8, 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, 145, 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, 145, 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, 145, 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, 145, 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, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 3, 145, 2666, 8, 145, 1, 146, 1, 146, 1, 146, 5, 146, 2671, 8, 146, 10, 146, 12, 146, 2674, 9, 146, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 3, 148, 2681, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 2831, 8, 149, 1, 150, 1, 150, 5, 150, 2835, 8, 150, 10, 150, 12, 150, 2838, 9, 150, 1, 151, 1, 151, 5, 151, 2842, 8, 151, 10, 151, 12, 151, 2845, 9, 151, 1, 152, 5, 152, 2848, 8, 152, 10, 152, 12, 152, 2851, 9, 152, 1, 153, 5, 153, 2854, 8, 153, 10, 153, 12, 153, 2857, 9, 153, 1, 154, 5, 154, 2860, 8, 154, 10, 154, 12, 154, 2863, 9, 154, 1, 155, 5, 155, 2866, 8, 155, 10, 155, 12, 155, 2869, 9, 155, 1, 156, 5, 156, 2872, 8, 156, 10, 156, 12, 156, 2875, 9, 156, 1, 157, 5, 157, 2878, 8, 157, 10, 157, 12, 157, 2881, 9, 157, 1, 158, 5, 158, 2884, 8, 158, 10, 158, 12, 158, 2887, 9, 158, 1, 159, 1, 159, 1, 159, 1, 159, 3, 159, 2893, 8, 159, 1, 160, 5, 160, 2896, 8, 160, 10, 160, 12, 160, 2899, 9, 160, 1, 161, 1, 161, 1, 161, 3, 161, 2904, 8, 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, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 3, 162, 2931, 8, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 2945, 8, 163, 1, 164, 5, 164, 2948, 8, 164, 10, 164, 12, 164, 2951, 9, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 3, 165, 2967, 8, 165, 1, 166, 1, 166, 1, 166, 5, 166, 2972, 8, 166, 10, 166, 12, 166, 2975, 9, 166, 1, 166, 1, 166, 1, 167, 1, 167, 5, 167, 2981, 8, 167, 10, 167, 12, 167, 2984, 9, 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, 168, 1, 168, 1, 168, 1, 168, 3, 168, 3003, 8, 168, 1, 169, 5, 169, 3006, 8, 169, 10, 169, 12, 169, 3009, 9, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 3024, 8, 170, 1, 171, 1, 171, 5, 171, 3028, 8, 171, 10, 171, 12, 171, 3031, 9, 171, 1, 171, 1, 171, 1, 171, 5, 171, 3036, 8, 171, 10, 171, 12, 171, 3039, 9, 171, 1, 171, 1, 171, 1, 171, 1, 171, 3, 171, 3045, 8, 171, 1, 172, 1, 172, 1, 173, 5, 173, 3050, 8, 173, 10, 173, 12, 173, 3053, 9, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 3065, 8, 174, 1, 174, 0, 1, 68, 175, 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, 0, 16, 6, 0, 1, 15, 199, 199, 243, 243, 247, 247, 264, 264, 289, 289, 5, 0, 16, 16, 199, 199, 243, 243, 264, 264, 288, 289, 1, 0, 263, 264, 1, 0, 173, 174, 1, 0, 37, 38, 1, 0, 73, 74, 3, 0, 2, 2, 61, 61, 77, 83, 2, 0, 229, 229, 260, 261, 9, 0, 178, 178, 183, 195, 201, 201, 207, 208, 210, 215, 218, 219, 222, 222, 230, 242, 262, 262, 1, 0, 95, 96, 1, 0, 97, 111, 1, 0, 68, 69, 2, 0, 173, 173, 289, 290, 2, 0, 179, 179, 264, 264, 1, 0, 167, 168, 1, 0, 51, 52, 3494, 0, 350, 1, 0, 0, 0, 2, 368, 1, 0, 0, 0, 4, 370, 1, 0, 0, 0, 6, 377, 1, 0, 0, 0, 8, 386, 1, 0, 0, 0, 10, 439, 1, 0, 0, 0, 12, 441, 1, 0, 0, 0, 14, 444, 1, 0, 0, 0, 16, 447, 1, 0, 0, 0, 18, 451, 1, 0, 0, 0, 20, 454, 1, 0, 0, 0, 22, 457, 1, 0, 0, 0, 24, 464, 1, 0, 0, 0, 26, 480, 1, 0, 0, 0, 28, 482, 1, 0, 0, 0, 30, 484, 1, 0, 0, 0, 32, 494, 1, 0, 0, 0, 34, 496, 1, 0, 0, 0, 36, 519, 1, 0, 0, 0, 38, 523, 1, 0, 0, 0, 40, 541, 1, 0, 0, 0, 42, 568, 1, 0, 0, 0, 44, 591, 1, 0, 0, 0, 46, 627, 1, 0, 0, 0, 48, 629, 1, 0, 0, 0, 50, 637, 1, 0, 0, 0, 52, 639, 1, 0, 0, 0, 54, 646, 1, 0, 0, 0, 56, 658, 1, 0, 0, 0, 58, 661, 1, 0, 0, 0, 60, 663, 1, 0, 0, 0, 62, 676, 1, 0, 0, 0, 64, 684, 1, 0, 0, 0, 66, 686, 1, 0, 0, 0, 68, 694, 1, 0, 0, 0, 70, 710, 1, 0, 0, 0, 72, 716, 1, 0, 0, 0, 74, 719, 1, 0, 0, 0, 76, 768, 1, 0, 0, 0, 78, 773, 1, 0, 0, 0, 80, 778, 1, 0, 0, 0, 82, 783, 1, 0, 0, 0, 84, 791, 1, 0, 0, 0, 86, 796, 1, 0, 0, 0, 88, 901, 1, 0, 0, 0, 90, 929, 1, 0, 0, 0, 92, 931, 1, 0, 0, 0, 94, 935, 1, 0, 0, 0, 96, 937, 1, 0, 0, 0, 98, 942, 1, 0, 0, 0, 100, 970, 1, 0, 0, 0, 102, 1050, 1, 0, 0, 0, 104, 1052, 1, 0, 0, 0, 106, 1081, 1, 0, 0, 0, 108, 1083, 1, 0, 0, 0, 110, 1097, 1, 0, 0, 0, 112, 1126, 1, 0, 0, 0, 114, 1138, 1, 0, 0, 0, 116, 1177, 1, 0, 0, 0, 118, 1185, 1, 0, 0, 0, 120, 1194, 1, 0, 0, 0, 122, 1202, 1, 0, 0, 0, 124, 1221, 1, 0, 0, 0, 126, 1231, 1, 0, 0, 0, 128, 1250, 1, 0, 0, 0, 130, 1344, 1, 0, 0, 0, 132, 1353, 1, 0, 0, 0, 134, 1363, 1, 0, 0, 0, 136, 1365, 1, 0, 0, 0, 138, 1367, 1, 0, 0, 0, 140, 1406, 1, 0, 0, 0, 142, 1466, 1, 0, 0, 0, 144, 1506, 1, 0, 0, 0, 146, 1522, 1, 0, 0, 0, 148, 1524, 1, 0, 0, 0, 150, 1528, 1, 0, 0, 0, 152, 1583, 1, 0, 0, 0, 154, 1595, 1, 0, 0, 0, 156, 1610, 1, 0, 0, 0, 158, 1617, 1, 0, 0, 0, 160, 1622, 1, 0, 0, 0, 162, 1626, 1, 0, 0, 0, 164, 1662, 1, 0, 0, 0, 166, 1664, 1, 0, 0, 0, 168, 1708, 1, 0, 0, 0, 170, 1727, 1, 0, 0, 0, 172, 1748, 1, 0, 0, 0, 174, 1750, 1, 0, 0, 0, 176, 1767, 1, 0, 0, 0, 178, 1782, 1, 0, 0, 0, 180, 1789, 1, 0, 0, 0, 182, 1799, 1, 0, 0, 0, 184, 1812, 1, 0, 0, 0, 186, 1817, 1, 0, 0, 0, 188, 1820, 1, 0, 0, 0, 190, 1831, 1, 0, 0, 0, 192, 1836, 1, 0, 0, 0, 194, 1841, 1, 0, 0, 0, 196, 1845, 1, 0, 0, 0, 198, 1968, 1, 0, 0, 0, 200, 1970, 1, 0, 0, 0, 202, 2007, 1, 0, 0, 0, 204, 2014, 1, 0, 0, 0, 206, 2019, 1, 0, 0, 0, 208, 2026, 1, 0, 0, 0, 210, 2046, 1, 0, 0, 0, 212, 2048, 1, 0, 0, 0, 214, 2053, 1, 0, 0, 0, 216, 2068, 1, 0, 0, 0, 218, 2070, 1, 0, 0, 0, 220, 2083, 1, 0, 0, 0, 222, 2088, 1, 0, 0, 0, 224, 2101, 1, 0, 0, 0, 226, 2109, 1, 0, 0, 0, 228, 2120, 1, 0, 0, 0, 230, 2127, 1, 0, 0, 0, 232, 2147, 1, 0, 0, 0, 234, 2149, 1, 0, 0, 0, 236, 2193, 1, 0, 0, 0, 238, 2213, 1, 0, 0, 0, 240, 2242, 1, 0, 0, 0, 242, 2251, 1, 0, 0, 0, 244, 2274, 1, 0, 0, 0, 246, 2279, 1, 0, 0, 0, 248, 2299, 1, 0, 0, 0, 250, 2399, 1, 0, 0, 0, 252, 2401, 1, 0, 0, 0, 254, 2407, 1, 0, 0, 0, 256, 2409, 1, 0, 0, 0, 258, 2413, 1, 0, 0, 0, 260, 2417, 1, 0, 0, 0, 262, 2433, 1, 0, 0, 0, 264, 2447, 1, 0, 0, 0, 266, 2455, 1, 0, 0, 0, 268, 2457, 1, 0, 0, 0, 270, 2460, 1, 0, 0, 0, 272, 2462, 1, 0, 0, 0, 274, 2475, 1, 0, 0, 0, 276, 2477, 1, 0, 0, 0, 278, 2487, 1, 0, 0, 0, 280, 2492, 1, 0, 0, 0, 282, 2503, 1, 0, 0, 0, 284, 2510, 1, 0, 0, 0, 286, 2520, 1, 0, 0, 0, 288, 2588, 1, 0, 0, 0, 290, 2665, 1, 0, 0, 0, 292, 2672, 1, 0, 0, 0, 294, 2675, 1, 0, 0, 0, 296, 2680, 1, 0, 0, 0, 298, 2830, 1, 0, 0, 0, 300, 2836, 1, 0, 0, 0, 302, 2843, 1, 0, 0, 0, 304, 2849, 1, 0, 0, 0, 306, 2855, 1, 0, 0, 0, 308, 2861, 1, 0, 0, 0, 310, 2867, 1, 0, 0, 0, 312, 2873, 1, 0, 0, 0, 314, 2879, 1, 0, 0, 0, 316, 2885, 1, 0, 0, 0, 318, 2892, 1, 0, 0, 0, 320, 2897, 1, 0, 0, 0, 322, 2903, 1, 0, 0, 0, 324, 2930, 1, 0, 0, 0, 326, 2944, 1, 0, 0, 0, 328, 2949, 1, 0, 0, 0, 330, 2966, 1, 0, 0, 0, 332, 2968, 1, 0, 0, 0, 334, 2978, 1, 0, 0, 0, 336, 3002, 1, 0, 0, 0, 338, 3007, 1, 0, 0, 0, 340, 3023, 1, 0, 0, 0, 342, 3044, 1, 0, 0, 0, 344, 3046, 1, 0, 0, 0, 346, 3051, 1, 0, 0, 0, 348, 3064, 1, 0, 0, 0, 350, 351, 7, 0, 0, 0, 351, 1, 1, 0, 0, 0, 352, 353, 5, 288, 0, 0, 353, 369, 6, 1, -1, 0, 354, 355, 3, 4, 2, 0, 355, 356, 6, 1, -1, 0, 356, 357, 5, 265, 0, 0, 357, 359, 1, 0, 0, 0, 358, 354, 1, 0, 0, 0, 359, 362, 1, 0, 0, 0, 360, 358, 1, 0, 0, 0, 360, 361, 1, 0, 0, 0, 361, 363, 1, 0, 0, 0, 362, 360, 1, 0, 0, 0, 363, 364, 3, 4, 2, 0, 364, 365, 6, 1, -1, 0, 365, 369, 1, 0, 0, 0, 366, 367, 5, 264, 0, 0, 367, 369, 6, 1, -1, 0, 368, 352, 1, 0, 0, 0, 368, 360, 1, 0, 0, 0, 368, 366, 1, 0, 0, 0, 369, 3, 1, 0, 0, 0, 370, 371, 7, 1, 0, 0, 371, 5, 1, 0, 0, 0, 372, 373, 5, 263, 0, 0, 373, 374, 6, 3, -1, 0, 374, 376, 5, 266, 0, 0, 375, 372, 1, 0, 0, 0, 376, 379, 1, 0, 0, 0, 377, 375, 1, 0, 0, 0, 377, 378, 1, 0, 0, 0, 378, 380, 1, 0, 0, 0, 379, 377, 1, 0, 0, 0, 380, 381, 5, 263, 0, 0, 381, 382, 6, 3, -1, 0, 382, 7, 1, 0, 0, 0, 383, 385, 3, 10, 5, 0, 384, 383, 1, 0, 0, 0, 385, 388, 1, 0, 0, 0, 386, 384, 1, 0, 0, 0, 386, 387, 1, 0, 0, 0, 387, 9, 1, 0, 0, 0, 388, 386, 1, 0, 0, 0, 389, 390, 3, 74, 37, 0, 390, 391, 5, 17, 0, 0, 391, 392, 3, 82, 41, 0, 392, 393, 5, 18, 0, 0, 393, 440, 1, 0, 0, 0, 394, 395, 3, 72, 36, 0, 395, 396, 5, 17, 0, 0, 396, 397, 3, 8, 4, 0, 397, 398, 5, 18, 0, 0, 398, 440, 1, 0, 0, 0, 399, 400, 3, 234, 117, 0, 400, 401, 5, 17, 0, 0, 401, 402, 3, 246, 123, 0, 402, 403, 5, 18, 0, 0, 403, 440, 1, 0, 0, 0, 404, 440, 3, 200, 100, 0, 405, 440, 3, 276, 138, 0, 406, 440, 3, 70, 35, 0, 407, 440, 3, 66, 33, 0, 408, 440, 3, 88, 44, 0, 409, 440, 3, 90, 45, 0, 410, 440, 3, 22, 11, 0, 411, 412, 3, 326, 163, 0, 412, 413, 5, 17, 0, 0, 413, 414, 3, 328, 164, 0, 414, 415, 5, 18, 0, 0, 415, 440, 1, 0, 0, 0, 416, 417, 3, 332, 166, 0, 417, 418, 5, 17, 0, 0, 418, 419, 3, 338, 169, 0, 419, 420, 5, 18, 0, 0, 420, 440, 1, 0, 0, 0, 421, 422, 3, 342, 171, 0, 422, 423, 5, 17, 0, 0, 423, 424, 3, 346, 173, 0, 424, 425, 5, 18, 0, 0, 425, 440, 1, 0, 0, 0, 426, 440, 3, 64, 32, 0, 427, 440, 3, 152, 76, 0, 428, 440, 3, 322, 161, 0, 429, 440, 3, 12, 6, 0, 430, 440, 3, 14, 7, 0, 431, 440, 3, 16, 8, 0, 432, 440, 3, 18, 9, 0, 433, 440, 3, 20, 10, 0, 434, 440, 3, 26, 13, 0, 435, 440, 3, 42, 21, 0, 436, 440, 3, 40, 20, 0, 437, 440, 3, 30, 15, 0, 438, 440, 3, 24, 12, 0, 439, 389, 1, 0, 0, 0, 439, 394, 1, 0, 0, 0, 439, 399, 1, 0, 0, 0, 439, 404, 1, 0, 0, 0, 439, 405, 1, 0, 0, 0, 439, 406, 1, 0, 0, 0, 439, 407, 1, 0, 0, 0, 439, 408, 1, 0, 0, 0, 439, 409, 1, 0, 0, 0, 439, 410, 1, 0, 0, 0, 439, 411, 1, 0, 0, 0, 439, 416, 1, 0, 0, 0, 439, 421, 1, 0, 0, 0, 439, 426, 1, 0, 0, 0, 439, 427, 1, 0, 0, 0, 439, 428, 1, 0, 0, 0, 439, 429, 1, 0, 0, 0, 439, 430, 1, 0, 0, 0, 439, 431, 1, 0, 0, 0, 439, 432, 1, 0, 0, 0, 439, 433, 1, 0, 0, 0, 439, 434, 1, 0, 0, 0, 439, 435, 1, 0, 0, 0, 439, 436, 1, 0, 0, 0, 439, 437, 1, 0, 0, 0, 439, 438, 1, 0, 0, 0, 440, 11, 1, 0, 0, 0, 441, 442, 5, 19, 0, 0, 442, 443, 3, 32, 16, 0, 443, 13, 1, 0, 0, 0, 444, 445, 5, 20, 0, 0, 445, 446, 3, 32, 16, 0, 446, 15, 1, 0, 0, 0, 447, 448, 5, 21, 0, 0, 448, 449, 5, 22, 0, 0, 449, 450, 3, 32, 16, 0, 450, 17, 1, 0, 0, 0, 451, 452, 5, 23, 0, 0, 452, 453, 3, 34, 17, 0, 453, 19, 1, 0, 0, 0, 454, 455, 5, 24, 0, 0, 455, 456, 3, 34, 17, 0, 456, 21, 1, 0, 0, 0, 457, 458, 5, 25, 0, 0, 458, 459, 3, 98, 49, 0, 459, 460, 3, 2, 1, 0, 460, 461, 5, 17, 0, 0, 461, 462, 3, 120, 60, 0, 462, 463, 5, 18, 0, 0, 463, 23, 1, 0, 0, 0, 464, 465, 5, 26, 0, 0, 465, 25, 1, 0, 0, 0, 466, 467, 5, 27, 0, 0, 467, 481, 3, 28, 14, 0, 468, 469, 5, 27, 0, 0, 469, 470, 3, 28, 14, 0, 470, 471, 5, 28, 0, 0, 471, 472, 3, 28, 14, 0, 472, 481, 1, 0, 0, 0, 473, 474, 5, 27, 0, 0, 474, 475, 3, 28, 14, 0, 475, 476, 5, 28, 0, 0, 476, 477, 3, 28, 14, 0, 477, 478, 5, 28, 0, 0, 478, 479, 3, 28, 14, 0, 479, 481, 1, 0, 0, 0, 480, 466, 1, 0, 0, 0, 480, 468, 1, 0, 0, 0, 480, 473, 1, 0, 0, 0, 481, 27, 1, 0, 0, 0, 482, 483, 7, 2, 0, 0, 483, 29, 1, 0, 0, 0, 484, 485, 5, 29, 0, 0, 485, 489, 5, 17, 0, 0, 486, 488, 3, 116, 58, 0, 487, 486, 1, 0, 0, 0, 488, 491, 1, 0, 0, 0, 489, 487, 1, 0, 0, 0, 489, 490, 1, 0, 0, 0, 490, 492, 1, 0, 0, 0, 491, 489, 1, 0, 0, 0, 492, 493, 5, 18, 0, 0, 493, 31, 1, 0, 0, 0, 494, 495, 5, 173, 0, 0, 495, 33, 1, 0, 0, 0, 496, 497, 7, 3, 0, 0, 497, 35, 1, 0, 0, 0, 498, 499, 5, 175, 0, 0, 499, 520, 6, 18, -1, 0, 500, 501, 3, 32, 16, 0, 501, 502, 5, 265, 0, 0, 502, 503, 6, 18, -1, 0, 503, 520, 1, 0, 0, 0, 504, 505, 3, 32, 16, 0, 505, 506, 6, 18, -1, 0, 506, 520, 1, 0, 0, 0, 507, 508, 5, 188, 0, 0, 508, 509, 5, 30, 0, 0, 509, 510, 3, 32, 16, 0, 510, 511, 5, 31, 0, 0, 511, 512, 6, 18, -1, 0, 512, 520, 1, 0, 0, 0, 513, 514, 5, 189, 0, 0, 514, 515, 5, 30, 0, 0, 515, 516, 3, 34, 17, 0, 516, 517, 5, 31, 0, 0, 517, 518, 6, 18, -1, 0, 518, 520, 1, 0, 0, 0, 519, 498, 1, 0, 0, 0, 519, 500, 1, 0, 0, 0, 519, 504, 1, 0, 0, 0, 519, 507, 1, 0, 0, 0, 519, 513, 1, 0, 0, 0, 520, 37, 1, 0, 0, 0, 521, 524, 3, 32, 16, 0, 522, 524, 5, 262, 0, 0, 523, 521, 1, 0, 0, 0, 523, 522, 1, 0, 0, 0, 524, 39, 1, 0, 0, 0, 525, 526, 5, 267, 0, 0, 526, 542, 5, 289, 0, 0, 527, 528, 5, 267, 0, 0, 528, 529, 5, 289, 0, 0, 529, 542, 5, 263, 0, 0, 530, 531, 5, 268, 0, 0, 531, 542, 5, 289, 0, 0, 532, 533, 5, 269, 0, 0, 533, 542, 5, 289, 0, 0, 534, 535, 5, 270, 0, 0, 535, 542, 5, 289, 0, 0, 536, 542, 5, 271, 0, 0, 537, 542, 5, 272, 0, 0, 538, 539, 5, 273, 0, 0, 539, 542, 5, 263, 0, 0, 540, 542, 5, 32, 0, 0, 541, 525, 1, 0, 0, 0, 541, 527, 1, 0, 0, 0, 541, 530, 1, 0, 0, 0, 541, 532, 1, 0, 0, 0, 541, 534, 1, 0, 0, 0, 541, 536, 1, 0, 0, 0, 541, 537, 1, 0, 0, 0, 541, 538, 1, 0, 0, 0, 541, 540, 1, 0, 0, 0, 542, 41, 1, 0, 0, 0, 543, 544, 5, 33, 0, 0, 544, 545, 3, 138, 69, 0, 545, 546, 5, 34, 0, 0, 546, 547, 3, 2, 1, 0, 547, 569, 1, 0, 0, 0, 548, 549, 5, 33, 0, 0, 549, 550, 3, 116, 58, 0, 550, 551, 5, 34, 0, 0, 551, 552, 3, 2, 1, 0, 552, 569, 1, 0, 0, 0, 553, 554, 5, 33, 0, 0, 554, 555, 3, 176, 88, 0, 555, 556, 5, 34, 0, 0, 556, 557, 3, 2, 1, 0, 557, 569, 1, 0, 0, 0, 558, 559, 5, 33, 0, 0, 559, 560, 3, 44, 22, 0, 560, 561, 5, 34, 0, 0, 561, 562, 3, 2, 1, 0, 562, 569, 1, 0, 0, 0, 563, 564, 5, 33, 0, 0, 564, 565, 3, 46, 23, 0, 565, 566, 5, 34, 0, 0, 566, 567, 3, 2, 1, 0, 567, 569, 1, 0, 0, 0, 568, 543, 1, 0, 0, 0, 568, 548, 1, 0, 0, 0, 568, 553, 1, 0, 0, 0, 568, 558, 1, 0, 0, 0, 568, 563, 1, 0, 0, 0, 569, 43, 1, 0, 0, 0, 570, 571, 5, 35, 0, 0, 571, 592, 3, 48, 24, 0, 572, 573, 5, 35, 0, 0, 573, 574, 3, 48, 24, 0, 574, 575, 5, 36, 0, 0, 575, 576, 3, 6, 3, 0, 576, 592, 1, 0, 0, 0, 577, 578, 5, 35, 0, 0, 578, 579, 3, 48, 24, 0, 579, 580, 5, 36, 0, 0, 580, 581, 5, 17, 0, 0, 581, 582, 3, 52, 26, 0, 582, 583, 5, 18, 0, 0, 583, 592, 1, 0, 0, 0, 584, 585, 5, 35, 0, 0, 585, 586, 3, 48, 24, 0, 586, 587, 5, 36, 0, 0, 587, 588, 5, 30, 0, 0, 588, 589, 3, 292, 146, 0, 589, 590, 5, 31, 0, 0, 590, 592, 1, 0, 0, 0, 591, 570, 1, 0, 0, 0, 591, 572, 1, 0, 0, 0, 591, 577, 1, 0, 0, 0, 591, 584, 1, 0, 0, 0, 592, 45, 1, 0, 0, 0, 593, 594, 5, 35, 0, 0, 594, 595, 5, 30, 0, 0, 595, 596, 3, 50, 25, 0, 596, 597, 5, 31, 0, 0, 597, 598, 3, 48, 24, 0, 598, 628, 1, 0, 0, 0, 599, 600, 5, 35, 0, 0, 600, 601, 5, 30, 0, 0, 601, 602, 3, 50, 25, 0, 602, 603, 5, 31, 0, 0, 603, 604, 3, 48, 24, 0, 604, 605, 5, 36, 0, 0, 605, 606, 3, 6, 3, 0, 606, 628, 1, 0, 0, 0, 607, 608, 5, 35, 0, 0, 608, 609, 5, 30, 0, 0, 609, 610, 3, 50, 25, 0, 610, 611, 5, 31, 0, 0, 611, 612, 3, 48, 24, 0, 612, 613, 5, 36, 0, 0, 613, 614, 5, 17, 0, 0, 614, 615, 3, 52, 26, 0, 615, 616, 5, 18, 0, 0, 616, 628, 1, 0, 0, 0, 617, 618, 5, 35, 0, 0, 618, 619, 5, 30, 0, 0, 619, 620, 3, 50, 25, 0, 620, 621, 5, 31, 0, 0, 621, 622, 3, 48, 24, 0, 622, 623, 5, 36, 0, 0, 623, 624, 5, 30, 0, 0, 624, 625, 3, 292, 146, 0, 625, 626, 5, 31, 0, 0, 626, 628, 1, 0, 0, 0, 627, 593, 1, 0, 0, 0, 627, 599, 1, 0, 0, 0, 627, 607, 1, 0, 0, 0, 627, 617, 1, 0, 0, 0, 628, 47, 1, 0, 0, 0, 629, 630, 3, 168, 84, 0, 630, 49, 1, 0, 0, 0, 631, 632, 3, 124, 62, 0, 632, 633, 6, 25, -1, 0, 633, 638, 1, 0, 0, 0, 634, 635, 3, 176, 88, 0, 635, 636, 6, 25, -1, 0, 636, 638, 1, 0, 0, 0, 637, 631, 1, 0, 0, 0, 637, 634, 1, 0, 0, 0, 638, 51, 1, 0, 0, 0, 639, 640, 3, 54, 27, 0, 640, 641, 3, 56, 28, 0, 641, 53, 1, 0, 0, 0, 642, 645, 3, 298, 149, 0, 643, 645, 3, 40, 20, 0, 644, 642, 1, 0, 0, 0, 644, 643, 1, 0, 0, 0, 645, 648, 1, 0, 0, 0, 646, 644, 1, 0, 0, 0, 646, 647, 1, 0, 0, 0, 647, 55, 1, 0, 0, 0, 648, 646, 1, 0, 0, 0, 649, 650, 3, 58, 29, 0, 650, 651, 3, 60, 30, 0, 651, 652, 3, 2, 1, 0, 652, 653, 5, 36, 0, 0, 653, 654, 3, 298, 149, 0, 654, 657, 1, 0, 0, 0, 655, 657, 3, 40, 20, 0, 656, 649, 1, 0, 0, 0, 656, 655, 1, 0, 0, 0, 657, 660, 1, 0, 0, 0, 658, 656, 1, 0, 0, 0, 658, 659, 1, 0, 0, 0, 659, 57, 1, 0, 0, 0, 660, 658, 1, 0, 0, 0, 661, 662, 7, 4, 0, 0, 662, 59, 1, 0, 0, 0, 663, 665, 3, 62, 31, 0, 664, 666, 5, 261, 0, 0, 665, 664, 1, 0, 0, 0, 665, 666, 1, 0, 0, 0, 666, 61, 1, 0, 0, 0, 667, 677, 3, 144, 72, 0, 668, 677, 3, 2, 1, 0, 669, 677, 5, 196, 0, 0, 670, 677, 5, 197, 0, 0, 671, 672, 5, 202, 0, 0, 672, 673, 5, 39, 0, 0, 673, 677, 5, 264, 0, 0, 674, 675, 5, 202, 0, 0, 675, 677, 3, 116, 58, 0, 676, 667, 1, 0, 0, 0, 676, 668, 1, 0, 0, 0, 676, 669, 1, 0, 0, 0, 676, 670, 1, 0, 0, 0, 676, 671, 1, 0, 0, 0, 676, 674, 1, 0, 0, 0, 677, 63, 1, 0, 0, 0, 678, 679, 5, 198, 0, 0, 679, 680, 5, 40, 0, 0, 680, 685, 3, 2, 1, 0, 681, 682, 5, 198, 0, 0, 682, 685, 3, 2, 1, 0, 683, 685, 5, 198, 0, 0, 684, 678, 1, 0, 0, 0, 684, 681, 1, 0, 0, 0, 684, 683, 1, 0, 0, 0, 685, 65, 1, 0, 0, 0, 686, 687, 5, 41, 0, 0, 687, 688, 5, 42, 0, 0, 688, 689, 3, 32, 16, 0, 689, 690, 5, 43, 0, 0, 690, 691, 3, 68, 34, 0, 691, 692, 5, 44, 0, 0, 692, 693, 3, 0, 0, 0, 693, 67, 1, 0, 0, 0, 694, 707, 6, 34, -1, 0, 695, 696, 10, 5, 0, 0, 696, 706, 5, 186, 0, 0, 697, 698, 10, 4, 0, 0, 698, 706, 5, 187, 0, 0, 699, 700, 10, 3, 0, 0, 700, 706, 5, 45, 0, 0, 701, 702, 10, 2, 0, 0, 702, 706, 5, 46, 0, 0, 703, 704, 10, 1, 0, 0, 704, 706, 5, 47, 0, 0, 705, 695, 1, 0, 0, 0, 705, 697, 1, 0, 0, 0, 705, 699, 1, 0, 0, 0, 705, 701, 1, 0, 0, 0, 705, 703, 1, 0, 0, 0, 706, 709, 1, 0, 0, 0, 707, 705, 1, 0, 0, 0, 707, 708, 1, 0, 0, 0, 708, 69, 1, 0, 0, 0, 709, 707, 1, 0, 0, 0, 710, 711, 5, 48, 0, 0, 711, 712, 5, 36, 0, 0, 712, 713, 5, 30, 0, 0, 713, 714, 3, 292, 146, 0, 714, 715, 5, 31, 0, 0, 715, 71, 1, 0, 0, 0, 716, 717, 5, 49, 0, 0, 717, 718, 3, 2, 1, 0, 718, 73, 1, 0, 0, 0, 719, 723, 5, 50, 0, 0, 720, 722, 3, 76, 38, 0, 721, 720, 1, 0, 0, 0, 722, 725, 1, 0, 0, 0, 723, 721, 1, 0, 0, 0, 723, 724, 1, 0, 0, 0, 724, 726, 1, 0, 0, 0, 725, 723, 1, 0, 0, 0, 726, 727, 3, 2, 1, 0, 727, 728, 3, 182, 91, 0, 728, 729, 3, 78, 39, 0, 729, 730, 3, 80, 40, 0, 730, 75, 1, 0, 0, 0, 731, 769, 5, 51, 0, 0, 732, 769, 5, 52, 0, 0, 733, 769, 5, 199, 0, 0, 734, 769, 5, 202, 0, 0, 735, 769, 5, 221, 0, 0, 736, 769, 5, 53, 0, 0, 737, 769, 5, 54, 0, 0, 738, 769, 5, 55, 0, 0, 739, 769, 5, 56, 0, 0, 740, 769, 5, 244, 0, 0, 741, 769, 5, 15, 0, 0, 742, 769, 5, 224, 0, 0, 743, 769, 5, 57, 0, 0, 744, 769, 5, 58, 0, 0, 745, 769, 5, 59, 0, 0, 746, 769, 5, 60, 0, 0, 747, 769, 5, 61, 0, 0, 748, 749, 5, 62, 0, 0, 749, 769, 5, 51, 0, 0, 750, 751, 5, 62, 0, 0, 751, 769, 5, 52, 0, 0, 752, 753, 5, 62, 0, 0, 753, 769, 5, 63, 0, 0, 754, 755, 5, 62, 0, 0, 755, 769, 5, 64, 0, 0, 756, 757, 5, 62, 0, 0, 757, 769, 5, 65, 0, 0, 758, 759, 5, 62, 0, 0, 759, 769, 5, 66, 0, 0, 760, 769, 5, 67, 0, 0, 761, 769, 5, 68, 0, 0, 762, 769, 5, 69, 0, 0, 763, 764, 5, 70, 0, 0, 764, 765, 5, 30, 0, 0, 765, 766, 3, 32, 16, 0, 766, 767, 5, 31, 0, 0, 767, 769, 1, 0, 0, 0, 768, 731, 1, 0, 0, 0, 768, 732, 1, 0, 0, 0, 768, 733, 1, 0, 0, 0, 768, 734, 1, 0, 0, 0, 768, 735, 1, 0, 0, 0, 768, 736, 1, 0, 0, 0, 768, 737, 1, 0, 0, 0, 768, 738, 1, 0, 0, 0, 768, 739, 1, 0, 0, 0, 768, 740, 1, 0, 0, 0, 768, 741, 1, 0, 0, 0, 768, 742, 1, 0, 0, 0, 768, 743, 1, 0, 0, 0, 768, 744, 1, 0, 0, 0, 768, 745, 1, 0, 0, 0, 768, 746, 1, 0, 0, 0, 768, 747, 1, 0, 0, 0, 768, 748, 1, 0, 0, 0, 768, 750, 1, 0, 0, 0, 768, 752, 1, 0, 0, 0, 768, 754, 1, 0, 0, 0, 768, 756, 1, 0, 0, 0, 768, 758, 1, 0, 0, 0, 768, 760, 1, 0, 0, 0, 768, 761, 1, 0, 0, 0, 768, 762, 1, 0, 0, 0, 768, 763, 1, 0, 0, 0, 769, 77, 1, 0, 0, 0, 770, 774, 1, 0, 0, 0, 771, 772, 5, 71, 0, 0, 772, 774, 3, 124, 62, 0, 773, 770, 1, 0, 0, 0, 773, 771, 1, 0, 0, 0, 774, 79, 1, 0, 0, 0, 775, 779, 1, 0, 0, 0, 776, 777, 5, 72, 0, 0, 777, 779, 3, 84, 42, 0, 778, 775, 1, 0, 0, 0, 778, 776, 1, 0, 0, 0, 779, 81, 1, 0, 0, 0, 780, 782, 3, 198, 99, 0, 781, 780, 1, 0, 0, 0, 782, 785, 1, 0, 0, 0, 783, 781, 1, 0, 0, 0, 783, 784, 1, 0, 0, 0, 784, 83, 1, 0, 0, 0, 785, 783, 1, 0, 0, 0, 786, 787, 3, 124, 62, 0, 787, 788, 5, 28, 0, 0, 788, 790, 1, 0, 0, 0, 789, 786, 1, 0, 0, 0, 790, 793, 1, 0, 0, 0, 791, 789, 1, 0, 0, 0, 791, 792, 1, 0, 0, 0, 792, 794, 1, 0, 0, 0, 793, 791, 1, 0, 0, 0, 794, 795, 3, 124, 62, 0, 795, 85, 1, 0, 0, 0, 796, 797, 7, 5, 0, 0, 797, 87, 1, 0, 0, 0, 798, 799, 3, 86, 43, 0, 799, 800, 3, 32, 16, 0, 800, 801, 5, 264, 0, 0, 801, 902, 1, 0, 0, 0, 802, 803, 3, 86, 43, 0, 803, 804, 3, 32, 16, 0, 804, 902, 1, 0, 0, 0, 805, 806, 3, 86, 43, 0, 806, 807, 3, 32, 16, 0, 807, 808, 5, 75, 0, 0, 808, 809, 3, 32, 16, 0, 809, 810, 5, 264, 0, 0, 810, 902, 1, 0, 0, 0, 811, 812, 3, 86, 43, 0, 812, 813, 3, 32, 16, 0, 813, 814, 5, 75, 0, 0, 814, 815, 3, 32, 16, 0, 815, 902, 1, 0, 0, 0, 816, 817, 3, 86, 43, 0, 817, 818, 3, 32, 16, 0, 818, 819, 5, 75, 0, 0, 819, 820, 3, 32, 16, 0, 820, 821, 5, 28, 0, 0, 821, 822, 3, 32, 16, 0, 822, 823, 5, 264, 0, 0, 823, 902, 1, 0, 0, 0, 824, 825, 3, 86, 43, 0, 825, 826, 3, 32, 16, 0, 826, 827, 5, 75, 0, 0, 827, 828, 3, 32, 16, 0, 828, 829, 5, 28, 0, 0, 829, 830, 3, 32, 16, 0, 830, 902, 1, 0, 0, 0, 831, 832, 3, 86, 43, 0, 832, 833, 3, 32, 16, 0, 833, 834, 5, 28, 0, 0, 834, 835, 3, 32, 16, 0, 835, 836, 5, 75, 0, 0, 836, 837, 3, 32, 16, 0, 837, 838, 5, 264, 0, 0, 838, 902, 1, 0, 0, 0, 839, 840, 3, 86, 43, 0, 840, 841, 3, 32, 16, 0, 841, 842, 5, 28, 0, 0, 842, 843, 3, 32, 16, 0, 843, 844, 5, 75, 0, 0, 844, 845, 3, 32, 16, 0, 845, 902, 1, 0, 0, 0, 846, 847, 3, 86, 43, 0, 847, 848, 3, 32, 16, 0, 848, 849, 5, 28, 0, 0, 849, 850, 3, 32, 16, 0, 850, 851, 5, 75, 0, 0, 851, 852, 3, 32, 16, 0, 852, 853, 5, 28, 0, 0, 853, 854, 3, 32, 16, 0, 854, 855, 5, 264, 0, 0, 855, 902, 1, 0, 0, 0, 856, 857, 3, 86, 43, 0, 857, 858, 3, 32, 16, 0, 858, 859, 5, 28, 0, 0, 859, 860, 3, 32, 16, 0, 860, 861, 5, 75, 0, 0, 861, 862, 3, 32, 16, 0, 862, 863, 5, 28, 0, 0, 863, 864, 3, 32, 16, 0, 864, 902, 1, 0, 0, 0, 865, 866, 3, 86, 43, 0, 866, 867, 3, 32, 16, 0, 867, 868, 5, 263, 0, 0, 868, 902, 1, 0, 0, 0, 869, 870, 3, 86, 43, 0, 870, 871, 3, 32, 16, 0, 871, 872, 5, 75, 0, 0, 872, 873, 3, 32, 16, 0, 873, 874, 5, 263, 0, 0, 874, 902, 1, 0, 0, 0, 875, 876, 3, 86, 43, 0, 876, 877, 3, 32, 16, 0, 877, 878, 5, 75, 0, 0, 878, 879, 3, 32, 16, 0, 879, 880, 5, 28, 0, 0, 880, 881, 3, 32, 16, 0, 881, 882, 5, 263, 0, 0, 882, 902, 1, 0, 0, 0, 883, 884, 3, 86, 43, 0, 884, 885, 3, 32, 16, 0, 885, 886, 5, 28, 0, 0, 886, 887, 3, 32, 16, 0, 887, 888, 5, 75, 0, 0, 888, 889, 3, 32, 16, 0, 889, 890, 5, 263, 0, 0, 890, 902, 1, 0, 0, 0, 891, 892, 3, 86, 43, 0, 892, 893, 3, 32, 16, 0, 893, 894, 5, 28, 0, 0, 894, 895, 3, 32, 16, 0, 895, 896, 5, 75, 0, 0, 896, 897, 3, 32, 16, 0, 897, 898, 5, 28, 0, 0, 898, 899, 3, 32, 16, 0, 899, 900, 5, 263, 0, 0, 900, 902, 1, 0, 0, 0, 901, 798, 1, 0, 0, 0, 901, 802, 1, 0, 0, 0, 901, 805, 1, 0, 0, 0, 901, 811, 1, 0, 0, 0, 901, 816, 1, 0, 0, 0, 901, 824, 1, 0, 0, 0, 901, 831, 1, 0, 0, 0, 901, 839, 1, 0, 0, 0, 901, 846, 1, 0, 0, 0, 901, 856, 1, 0, 0, 0, 901, 865, 1, 0, 0, 0, 901, 869, 1, 0, 0, 0, 901, 875, 1, 0, 0, 0, 901, 883, 1, 0, 0, 0, 901, 891, 1, 0, 0, 0, 902, 89, 1, 0, 0, 0, 903, 907, 5, 21, 0, 0, 904, 906, 3, 92, 46, 0, 905, 904, 1, 0, 0, 0, 906, 909, 1, 0, 0, 0, 907, 905, 1, 0, 0, 0, 907, 908, 1, 0, 0, 0, 908, 910, 1, 0, 0, 0, 909, 907, 1, 0, 0, 0, 910, 911, 3, 2, 1, 0, 911, 912, 3, 94, 47, 0, 912, 913, 5, 180, 0, 0, 913, 914, 5, 36, 0, 0, 914, 915, 5, 30, 0, 0, 915, 916, 3, 292, 146, 0, 916, 917, 5, 31, 0, 0, 917, 918, 3, 94, 47, 0, 918, 930, 1, 0, 0, 0, 919, 923, 5, 21, 0, 0, 920, 922, 3, 92, 46, 0, 921, 920, 1, 0, 0, 0, 922, 925, 1, 0, 0, 0, 923, 921, 1, 0, 0, 0, 923, 924, 1, 0, 0, 0, 924, 926, 1, 0, 0, 0, 925, 923, 1, 0, 0, 0, 926, 927, 3, 2, 1, 0, 927, 928, 3, 94, 47, 0, 928, 930, 1, 0, 0, 0, 929, 903, 1, 0, 0, 0, 929, 919, 1, 0, 0, 0, 930, 91, 1, 0, 0, 0, 931, 932, 5, 76, 0, 0, 932, 93, 1, 0, 0, 0, 933, 936, 1, 0, 0, 0, 934, 936, 5, 298, 0, 0, 935, 933, 1, 0, 0, 0, 935, 934, 1, 0, 0, 0, 936, 95, 1, 0, 0, 0, 937, 938, 7, 6, 0, 0, 938, 97, 1, 0, 0, 0, 939, 941, 3, 96, 48, 0, 940, 939, 1, 0, 0, 0, 941, 944, 1, 0, 0, 0, 942, 940, 1, 0, 0, 0, 942, 943, 1, 0, 0, 0, 943, 99, 1, 0, 0, 0, 944, 942, 1, 0, 0, 0, 945, 971, 3, 102, 51, 0, 946, 947, 5, 280, 0, 0, 947, 948, 3, 168, 84, 0, 948, 949, 6, 50, -1, 0, 949, 971, 1, 0, 0, 0, 950, 951, 5, 286, 0, 0, 951, 952, 3, 178, 89, 0, 952, 953, 6, 50, -1, 0, 953, 971, 1, 0, 0, 0, 954, 955, 5, 286, 0, 0, 955, 956, 3, 174, 87, 0, 956, 957, 6, 50, -1, 0, 957, 971, 1, 0, 0, 0, 958, 959, 5, 284, 0, 0, 959, 960, 3, 124, 62, 0, 960, 961, 6, 50, -1, 0, 961, 971, 1, 0, 0, 0, 962, 963, 5, 281, 0, 0, 963, 964, 3, 104, 52, 0, 964, 965, 6, 50, -1, 0, 965, 971, 1, 0, 0, 0, 966, 967, 5, 287, 0, 0, 967, 968, 3, 50, 25, 0, 968, 969, 6, 50, -1, 0, 969, 971, 1, 0, 0, 0, 970, 945, 1, 0, 0, 0, 970, 946, 1, 0, 0, 0, 970, 950, 1, 0, 0, 0, 970, 954, 1, 0, 0, 0, 970, 958, 1, 0, 0, 0, 970, 962, 1, 0, 0, 0, 970, 966, 1, 0, 0, 0, 971, 101, 1, 0, 0, 0, 972, 973, 5, 275, 0, 0, 973, 1051, 6, 51, -1, 0, 974, 975, 5, 276, 0, 0, 975, 976, 3, 32, 16, 0, 976, 977, 6, 51, -1, 0, 977, 1051, 1, 0, 0, 0, 978, 979, 5, 276, 0, 0, 979, 980, 3, 0, 0, 0, 980, 981, 6, 51, -1, 0, 981, 1051, 1, 0, 0, 0, 982, 983, 5, 277, 0, 0, 983, 984, 3, 32, 16, 0, 984, 985, 6, 51, -1, 0, 985, 1051, 1, 0, 0, 0, 986, 987, 5, 278, 0, 0, 987, 988, 3, 34, 17, 0, 988, 989, 6, 51, -1, 0, 989, 1051, 1, 0, 0, 0, 990, 991, 5, 279, 0, 0, 991, 992, 3, 36, 18, 0, 992, 993, 6, 51, -1, 0, 993, 1051, 1, 0, 0, 0, 994, 995, 5, 279, 0, 0, 995, 996, 3, 34, 17, 0, 996, 997, 6, 51, -1, 0, 997, 1051, 1, 0, 0, 0, 998, 999, 5, 279, 0, 0, 999, 1000, 5, 30, 0, 0, 1000, 1001, 3, 292, 146, 0, 1001, 1002, 5, 31, 0, 0, 1002, 1003, 6, 51, -1, 0, 1003, 1051, 1, 0, 0, 0, 1004, 1005, 5, 279, 0, 0, 1005, 1006, 5, 84, 0, 0, 1006, 1007, 5, 30, 0, 0, 1007, 1008, 3, 292, 146, 0, 1008, 1009, 5, 31, 0, 0, 1009, 1010, 6, 51, -1, 0, 1010, 1051, 1, 0, 0, 0, 1011, 1012, 5, 282, 0, 0, 1012, 1013, 3, 32, 16, 0, 1013, 1014, 6, 51, -1, 0, 1014, 1051, 1, 0, 0, 0, 1015, 1016, 5, 282, 0, 0, 1016, 1017, 3, 0, 0, 0, 1017, 1018, 6, 51, -1, 0, 1018, 1051, 1, 0, 0, 0, 1019, 1020, 5, 285, 0, 0, 1020, 1021, 3, 6, 3, 0, 1021, 1022, 6, 51, -1, 0, 1022, 1051, 1, 0, 0, 0, 1023, 1024, 5, 285, 0, 0, 1024, 1025, 5, 224, 0, 0, 1025, 1026, 5, 30, 0, 0, 1026, 1027, 3, 6, 3, 0, 1027, 1028, 5, 31, 0, 0, 1028, 1029, 6, 51, -1, 0, 1029, 1051, 1, 0, 0, 0, 1030, 1031, 5, 285, 0, 0, 1031, 1032, 5, 84, 0, 0, 1032, 1033, 5, 30, 0, 0, 1033, 1034, 3, 292, 146, 0, 1034, 1035, 5, 31, 0, 0, 1035, 1036, 6, 51, -1, 0, 1036, 1051, 1, 0, 0, 0, 1037, 1038, 5, 287, 0, 0, 1038, 1039, 3, 32, 16, 0, 1039, 1040, 6, 51, -1, 0, 1040, 1051, 1, 0, 0, 0, 1041, 1042, 5, 283, 0, 0, 1042, 1048, 6, 51, -1, 0, 1043, 1044, 5, 30, 0, 0, 1044, 1045, 3, 106, 53, 0, 1045, 1046, 5, 31, 0, 0, 1046, 1049, 1, 0, 0, 0, 1047, 1049, 5, 85, 0, 0, 1048, 1043, 1, 0, 0, 0, 1048, 1047, 1, 0, 0, 0, 1049, 1051, 1, 0, 0, 0, 1050, 972, 1, 0, 0, 0, 1050, 974, 1, 0, 0, 0, 1050, 978, 1, 0, 0, 0, 1050, 982, 1, 0, 0, 0, 1050, 986, 1, 0, 0, 0, 1050, 990, 1, 0, 0, 0, 1050, 994, 1, 0, 0, 0, 1050, 998, 1, 0, 0, 0, 1050, 1004, 1, 0, 0, 0, 1050, 1011, 1, 0, 0, 0, 1050, 1015, 1, 0, 0, 0, 1050, 1019, 1, 0, 0, 0, 1050, 1023, 1, 0, 0, 0, 1050, 1030, 1, 0, 0, 0, 1050, 1037, 1, 0, 0, 0, 1050, 1041, 1, 0, 0, 0, 1051, 103, 1, 0, 0, 0, 1052, 1053, 3, 170, 85, 0, 1053, 1054, 3, 138, 69, 0, 1054, 1055, 3, 112, 56, 0, 1055, 1056, 6, 52, -1, 0, 1056, 105, 1, 0, 0, 0, 1057, 1082, 1, 0, 0, 0, 1058, 1059, 3, 0, 0, 0, 1059, 1060, 6, 53, -1, 0, 1060, 1065, 1, 0, 0, 0, 1061, 1062, 3, 32, 16, 0, 1062, 1063, 6, 53, -1, 0, 1063, 1065, 1, 0, 0, 0, 1064, 1058, 1, 0, 0, 0, 1064, 1061, 1, 0, 0, 0, 1065, 1066, 1, 0, 0, 0, 1066, 1067, 5, 28, 0, 0, 1067, 1069, 1, 0, 0, 0, 1068, 1064, 1, 0, 0, 0, 1069, 1072, 1, 0, 0, 0, 1070, 1068, 1, 0, 0, 0, 1070, 1071, 1, 0, 0, 0, 1071, 1079, 1, 0, 0, 0, 1072, 1070, 1, 0, 0, 0, 1073, 1074, 3, 0, 0, 0, 1074, 1075, 6, 53, -1, 0, 1075, 1080, 1, 0, 0, 0, 1076, 1077, 3, 32, 16, 0, 1077, 1078, 6, 53, -1, 0, 1078, 1080, 1, 0, 0, 0, 1079, 1073, 1, 0, 0, 0, 1079, 1076, 1, 0, 0, 0, 1080, 1082, 1, 0, 0, 0, 1081, 1057, 1, 0, 0, 0, 1081, 1070, 1, 0, 0, 0, 1082, 107, 1, 0, 0, 0, 1083, 1090, 5, 86, 0, 0, 1084, 1085, 3, 138, 69, 0, 1085, 1086, 6, 54, -1, 0, 1086, 1087, 5, 28, 0, 0, 1087, 1089, 1, 0, 0, 0, 1088, 1084, 1, 0, 0, 0, 1089, 1092, 1, 0, 0, 0, 1090, 1088, 1, 0, 0, 0, 1090, 1091, 1, 0, 0, 0, 1091, 1093, 1, 0, 0, 0, 1092, 1090, 1, 0, 0, 0, 1093, 1094, 3, 138, 69, 0, 1094, 1095, 6, 54, -1, 0, 1095, 1096, 5, 87, 0, 0, 1096, 109, 1, 0, 0, 0, 1097, 1104, 5, 42, 0, 0, 1098, 1099, 3, 146, 73, 0, 1099, 1100, 6, 55, -1, 0, 1100, 1101, 5, 28, 0, 0, 1101, 1103, 1, 0, 0, 0, 1102, 1098, 1, 0, 0, 0, 1103, 1106, 1, 0, 0, 0, 1104, 1102, 1, 0, 0, 0, 1104, 1105, 1, 0, 0, 0, 1105, 1107, 1, 0, 0, 0, 1106, 1104, 1, 0, 0, 0, 1107, 1108, 3, 146, 73, 0, 1108, 1109, 6, 55, -1, 0, 1109, 1110, 5, 43, 0, 0, 1110, 111, 1, 0, 0, 0, 1111, 1118, 5, 30, 0, 0, 1112, 1113, 3, 114, 57, 0, 1113, 1114, 6, 56, -1, 0, 1114, 1115, 5, 28, 0, 0, 1115, 1117, 1, 0, 0, 0, 1116, 1112, 1, 0, 0, 0, 1117, 1120, 1, 0, 0, 0, 1118, 1116, 1, 0, 0, 0, 1118, 1119, 1, 0, 0, 0, 1119, 1121, 1, 0, 0, 0, 1120, 1118, 1, 0, 0, 0, 1121, 1122, 3, 114, 57, 0, 1122, 1123, 6, 56, -1, 0, 1123, 1124, 5, 31, 0, 0, 1124, 1127, 1, 0, 0, 0, 1125, 1127, 5, 85, 0, 0, 1126, 1111, 1, 0, 0, 0, 1126, 1125, 1, 0, 0, 0, 1127, 113, 1, 0, 0, 0, 1128, 1129, 5, 177, 0, 0, 1129, 1139, 6, 57, -1, 0, 1130, 1131, 3, 230, 115, 0, 1131, 1132, 3, 138, 69, 0, 1132, 1134, 3, 226, 113, 0, 1133, 1135, 3, 0, 0, 0, 1134, 1133, 1, 0, 0, 0, 1134, 1135, 1, 0, 0, 0, 1135, 1136, 1, 0, 0, 0, 1136, 1137, 6, 57, -1, 0, 1137, 1139, 1, 0, 0, 0, 1138, 1128, 1, 0, 0, 0, 1138, 1130, 1, 0, 0, 0, 1139, 115, 1, 0, 0, 0, 1140, 1141, 5, 42, 0, 0, 1141, 1142, 3, 2, 1, 0, 1142, 1143, 5, 43, 0, 0, 1143, 1144, 3, 118, 59, 0, 1144, 1145, 6, 58, -1, 0, 1145, 1178, 1, 0, 0, 0, 1146, 1147, 5, 42, 0, 0, 1147, 1148, 3, 174, 87, 0, 1148, 1149, 5, 43, 0, 0, 1149, 1150, 3, 118, 59, 0, 1150, 1151, 6, 58, -1, 0, 1151, 1178, 1, 0, 0, 0, 1152, 1153, 5, 42, 0, 0, 1153, 1154, 5, 262, 0, 0, 1154, 1155, 5, 43, 0, 0, 1155, 1156, 3, 118, 59, 0, 1156, 1157, 6, 58, -1, 0, 1157, 1178, 1, 0, 0, 0, 1158, 1159, 5, 42, 0, 0, 1159, 1160, 5, 198, 0, 0, 1160, 1161, 3, 2, 1, 0, 1161, 1162, 5, 43, 0, 0, 1162, 1163, 3, 118, 59, 0, 1163, 1164, 6, 58, -1, 0, 1164, 1178, 1, 0, 0, 0, 1165, 1166, 3, 118, 59, 0, 1166, 1167, 6, 58, -1, 0, 1167, 1178, 1, 0, 0, 0, 1168, 1169, 3, 174, 87, 0, 1169, 1170, 6, 58, -1, 0, 1170, 1178, 1, 0, 0, 0, 1171, 1172, 5, 257, 0, 0, 1172, 1178, 6, 58, -1, 0, 1173, 1174, 5, 258, 0, 0, 1174, 1178, 6, 58, -1, 0, 1175, 1176, 5, 259, 0, 0, 1176, 1178, 6, 58, -1, 0, 1177, 1140, 1, 0, 0, 0, 1177, 1146, 1, 0, 0, 0, 1177, 1152, 1, 0, 0, 0, 1177, 1158, 1, 0, 0, 0, 1177, 1165, 1, 0, 0, 0, 1177, 1168, 1, 0, 0, 0, 1177, 1171, 1, 0, 0, 0, 1177, 1173, 1, 0, 0, 0, 1177, 1175, 1, 0, 0, 0, 1178, 117, 1, 0, 0, 0, 1179, 1180, 3, 2, 1, 0, 1180, 1181, 6, 59, -1, 0, 1181, 1182, 5, 88, 0, 0, 1182, 1184, 1, 0, 0, 0, 1183, 1179, 1, 0, 0, 0, 1184, 1187, 1, 0, 0, 0, 1185, 1183, 1, 0, 0, 0, 1185, 1186, 1, 0, 0, 0, 1186, 1188, 1, 0, 0, 0, 1187, 1185, 1, 0, 0, 0, 1188, 1189, 3, 2, 1, 0, 1189, 1190, 6, 59, -1, 0, 1190, 119, 1, 0, 0, 0, 1191, 1193, 3, 122, 61, 0, 1192, 1191, 1, 0, 0, 0, 1193, 1196, 1, 0, 0, 0, 1194, 1192, 1, 0, 0, 0, 1194, 1195, 1, 0, 0, 0, 1195, 121, 1, 0, 0, 0, 1196, 1194, 1, 0, 0, 0, 1197, 1198, 5, 180, 0, 0, 1198, 1199, 5, 89, 0, 0, 1199, 1203, 3, 32, 16, 0, 1200, 1203, 3, 152, 76, 0, 1201, 1203, 3, 324, 162, 0, 1202, 1197, 1, 0, 0, 0, 1202, 1200, 1, 0, 0, 0, 1202, 1201, 1, 0, 0, 0, 1203, 123, 1, 0, 0, 0, 1204, 1205, 3, 116, 58, 0, 1205, 1206, 6, 62, -1, 0, 1206, 1222, 1, 0, 0, 0, 1207, 1208, 5, 42, 0, 0, 1208, 1209, 3, 2, 1, 0, 1209, 1210, 5, 43, 0, 0, 1210, 1211, 6, 62, -1, 0, 1211, 1222, 1, 0, 0, 0, 1212, 1213, 5, 42, 0, 0, 1213, 1214, 5, 198, 0, 0, 1214, 1215, 3, 2, 1, 0, 1215, 1216, 5, 43, 0, 0, 1216, 1217, 6, 62, -1, 0, 1217, 1222, 1, 0, 0, 0, 1218, 1219, 3, 138, 69, 0, 1219, 1220, 6, 62, -1, 0, 1220, 1222, 1, 0, 0, 0, 1221, 1204, 1, 0, 0, 0, 1221, 1207, 1, 0, 0, 0, 1221, 1212, 1, 0, 0, 0, 1221, 1218, 1, 0, 0, 0, 1222, 125, 1, 0, 0, 0, 1223, 1232, 1, 0, 0, 0, 1224, 1228, 3, 130, 65, 0, 1225, 1227, 3, 128, 64, 0, 1226, 1225, 1, 0, 0, 0, 1227, 1230, 1, 0, 0, 0, 1228, 1226, 1, 0, 0, 0, 1228, 1229, 1, 0, 0, 0, 1229, 1232, 1, 0, 0, 0, 1230, 1228, 1, 0, 0, 0, 1231, 1223, 1, 0, 0, 0, 1231, 1224, 1, 0, 0, 0, 1232, 127, 1, 0, 0, 0, 1233, 1251, 5, 262, 0, 0, 1234, 1251, 5, 261, 0, 0, 1235, 1236, 5, 42, 0, 0, 1236, 1237, 3, 32, 16, 0, 1237, 1238, 5, 43, 0, 0, 1238, 1251, 1, 0, 0, 0, 1239, 1240, 5, 42, 0, 0, 1240, 1241, 3, 32, 16, 0, 1241, 1242, 5, 266, 0, 0, 1242, 1243, 3, 32, 16, 0, 1243, 1244, 5, 43, 0, 0, 1244, 1251, 1, 0, 0, 0, 1245, 1246, 5, 42, 0, 0, 1246, 1247, 5, 266, 0, 0, 1247, 1248, 3, 32, 16, 0, 1248, 1249, 5, 43, 0, 0, 1249, 1251, 1, 0, 0, 0, 1250, 1233, 1, 0, 0, 0, 1250, 1234, 1, 0, 0, 0, 1250, 1235, 1, 0, 0, 0, 1250, 1239, 1, 0, 0, 0, 1250, 1245, 1, 0, 0, 0, 1251, 129, 1, 0, 0, 0, 1252, 1345, 1, 0, 0, 0, 1253, 1254, 5, 203, 0, 0, 1254, 1255, 5, 30, 0, 0, 1255, 1256, 3, 6, 3, 0, 1256, 1257, 5, 28, 0, 0, 1257, 1258, 3, 6, 3, 0, 1258, 1259, 5, 28, 0, 0, 1259, 1260, 3, 6, 3, 0, 1260, 1261, 5, 28, 0, 0, 1261, 1262, 3, 6, 3, 0, 1262, 1263, 5, 31, 0, 0, 1263, 1345, 1, 0, 0, 0, 1264, 1265, 5, 203, 0, 0, 1265, 1266, 5, 30, 0, 0, 1266, 1267, 3, 6, 3, 0, 1267, 1268, 5, 28, 0, 0, 1268, 1269, 3, 6, 3, 0, 1269, 1270, 5, 31, 0, 0, 1270, 1345, 1, 0, 0, 0, 1271, 1272, 5, 204, 0, 0, 1272, 1273, 5, 205, 0, 0, 1273, 1274, 5, 42, 0, 0, 1274, 1275, 3, 32, 16, 0, 1275, 1276, 5, 43, 0, 0, 1276, 1345, 1, 0, 0, 0, 1277, 1278, 5, 204, 0, 0, 1278, 1279, 5, 206, 0, 0, 1279, 1280, 5, 42, 0, 0, 1280, 1281, 3, 32, 16, 0, 1281, 1282, 5, 43, 0, 0, 1282, 1283, 3, 126, 63, 0, 1283, 1345, 1, 0, 0, 0, 1284, 1345, 5, 207, 0, 0, 1285, 1345, 5, 208, 0, 0, 1286, 1345, 5, 209, 0, 0, 1287, 1345, 5, 201, 0, 0, 1288, 1345, 5, 183, 0, 0, 1289, 1345, 5, 184, 0, 0, 1290, 1345, 5, 185, 0, 0, 1291, 1345, 5, 186, 0, 0, 1292, 1345, 5, 187, 0, 0, 1293, 1345, 5, 188, 0, 0, 1294, 1345, 5, 189, 0, 0, 1295, 1345, 5, 210, 0, 0, 1296, 1345, 5, 190, 0, 0, 1297, 1345, 5, 191, 0, 0, 1298, 1345, 5, 192, 0, 0, 1299, 1345, 5, 193, 0, 0, 1300, 1345, 5, 211, 0, 0, 1301, 1345, 5, 212, 0, 0, 1302, 1345, 5, 213, 0, 0, 1303, 1345, 5, 214, 0, 0, 1304, 1345, 5, 215, 0, 0, 1305, 1345, 5, 216, 0, 0, 1306, 1345, 5, 217, 0, 0, 1307, 1308, 5, 218, 0, 0, 1308, 1345, 3, 132, 66, 0, 1309, 1310, 5, 219, 0, 0, 1310, 1345, 3, 132, 66, 0, 1311, 1345, 5, 220, 0, 0, 1312, 1313, 5, 221, 0, 0, 1313, 1345, 3, 132, 66, 0, 1314, 1315, 5, 222, 0, 0, 1315, 1345, 3, 134, 67, 0, 1316, 1317, 5, 222, 0, 0, 1317, 1318, 3, 134, 67, 0, 1318, 1319, 5, 28, 0, 0, 1319, 1320, 3, 6, 3, 0, 1320, 1345, 1, 0, 0, 0, 1321, 1345, 5, 194, 0, 0, 1322, 1345, 5, 195, 0, 0, 1323, 1324, 5, 90, 0, 0, 1324, 1345, 5, 184, 0, 0, 1325, 1326, 5, 90, 0, 0, 1326, 1345, 5, 185, 0, 0, 1327, 1328, 5, 90, 0, 0, 1328, 1345, 5, 186, 0, 0, 1329, 1330, 5, 90, 0, 0, 1330, 1345, 5, 187, 0, 0, 1331, 1332, 5, 62, 0, 0, 1332, 1345, 5, 220, 0, 0, 1333, 1345, 5, 223, 0, 0, 1334, 1335, 5, 224, 0, 0, 1335, 1345, 5, 213, 0, 0, 1336, 1345, 5, 225, 0, 0, 1337, 1338, 5, 207, 0, 0, 1338, 1345, 5, 183, 0, 0, 1339, 1345, 5, 226, 0, 0, 1340, 1345, 5, 228, 0, 0, 1341, 1342, 5, 34, 0, 0, 1342, 1345, 5, 227, 0, 0, 1343, 1345, 3, 2, 1, 0, 1344, 1252, 1, 0, 0, 0, 1344, 1253, 1, 0, 0, 0, 1344, 1264, 1, 0, 0, 0, 1344, 1271, 1, 0, 0, 0, 1344, 1277, 1, 0, 0, 0, 1344, 1284, 1, 0, 0, 0, 1344, 1285, 1, 0, 0, 0, 1344, 1286, 1, 0, 0, 0, 1344, 1287, 1, 0, 0, 0, 1344, 1288, 1, 0, 0, 0, 1344, 1289, 1, 0, 0, 0, 1344, 1290, 1, 0, 0, 0, 1344, 1291, 1, 0, 0, 0, 1344, 1292, 1, 0, 0, 0, 1344, 1293, 1, 0, 0, 0, 1344, 1294, 1, 0, 0, 0, 1344, 1295, 1, 0, 0, 0, 1344, 1296, 1, 0, 0, 0, 1344, 1297, 1, 0, 0, 0, 1344, 1298, 1, 0, 0, 0, 1344, 1299, 1, 0, 0, 0, 1344, 1300, 1, 0, 0, 0, 1344, 1301, 1, 0, 0, 0, 1344, 1302, 1, 0, 0, 0, 1344, 1303, 1, 0, 0, 0, 1344, 1304, 1, 0, 0, 0, 1344, 1305, 1, 0, 0, 0, 1344, 1306, 1, 0, 0, 0, 1344, 1307, 1, 0, 0, 0, 1344, 1309, 1, 0, 0, 0, 1344, 1311, 1, 0, 0, 0, 1344, 1312, 1, 0, 0, 0, 1344, 1314, 1, 0, 0, 0, 1344, 1316, 1, 0, 0, 0, 1344, 1321, 1, 0, 0, 0, 1344, 1322, 1, 0, 0, 0, 1344, 1323, 1, 0, 0, 0, 1344, 1325, 1, 0, 0, 0, 1344, 1327, 1, 0, 0, 0, 1344, 1329, 1, 0, 0, 0, 1344, 1331, 1, 0, 0, 0, 1344, 1333, 1, 0, 0, 0, 1344, 1334, 1, 0, 0, 0, 1344, 1336, 1, 0, 0, 0, 1344, 1337, 1, 0, 0, 0, 1344, 1339, 1, 0, 0, 0, 1344, 1340, 1, 0, 0, 0, 1344, 1341, 1, 0, 0, 0, 1344, 1343, 1, 0, 0, 0, 1345, 131, 1, 0, 0, 0, 1346, 1354, 1, 0, 0, 0, 1347, 1348, 5, 30, 0, 0, 1348, 1349, 5, 91, 0, 0, 1349, 1350, 5, 36, 0, 0, 1350, 1351, 3, 32, 16, 0, 1351, 1352, 5, 31, 0, 0, 1352, 1354, 1, 0, 0, 0, 1353, 1346, 1, 0, 0, 0, 1353, 1347, 1, 0, 0, 0, 1354, 133, 1, 0, 0, 0, 1355, 1364, 1, 0, 0, 0, 1356, 1360, 3, 136, 68, 0, 1357, 1359, 7, 7, 0, 0, 1358, 1357, 1, 0, 0, 0, 1359, 1362, 1, 0, 0, 0, 1360, 1358, 1, 0, 0, 0, 1360, 1361, 1, 0, 0, 0, 1361, 1364, 1, 0, 0, 0, 1362, 1360, 1, 0, 0, 0, 1363, 1355, 1, 0, 0, 0, 1363, 1356, 1, 0, 0, 0, 1364, 135, 1, 0, 0, 0, 1365, 1366, 7, 8, 0, 0, 1366, 137, 1, 0, 0, 0, 1367, 1368, 3, 142, 71, 0, 1368, 1374, 6, 69, -1, 0, 1369, 1370, 3, 140, 70, 0, 1370, 1371, 6, 69, -1, 0, 1371, 1373, 1, 0, 0, 0, 1372, 1369, 1, 0, 0, 0, 1373, 1376, 1, 0, 0, 0, 1374, 1372, 1, 0, 0, 0, 1374, 1375, 1, 0, 0, 0, 1375, 139, 1, 0, 0, 0, 1376, 1374, 1, 0, 0, 0, 1377, 1378, 5, 261, 0, 0, 1378, 1407, 6, 70, -1, 0, 1379, 1380, 5, 42, 0, 0, 1380, 1381, 5, 43, 0, 0, 1381, 1407, 6, 70, -1, 0, 1382, 1383, 3, 110, 55, 0, 1383, 1384, 6, 70, -1, 0, 1384, 1407, 1, 0, 0, 0, 1385, 1386, 5, 260, 0, 0, 1386, 1407, 6, 70, -1, 0, 1387, 1388, 5, 262, 0, 0, 1388, 1407, 6, 70, -1, 0, 1389, 1390, 5, 92, 0, 0, 1390, 1407, 6, 70, -1, 0, 1391, 1392, 5, 93, 0, 0, 1392, 1393, 5, 30, 0, 0, 1393, 1394, 3, 124, 62, 0, 1394, 1395, 5, 31, 0, 0, 1395, 1396, 6, 70, -1, 0, 1396, 1407, 1, 0, 0, 0, 1397, 1398, 5, 94, 0, 0, 1398, 1399, 5, 30, 0, 0, 1399, 1400, 3, 124, 62, 0, 1400, 1401, 5, 31, 0, 0, 1401, 1402, 6, 70, -1, 0, 1402, 1407, 1, 0, 0, 0, 1403, 1404, 3, 108, 54, 0, 1404, 1405, 6, 70, -1, 0, 1405, 1407, 1, 0, 0, 0, 1406, 1377, 1, 0, 0, 0, 1406, 1379, 1, 0, 0, 0, 1406, 1382, 1, 0, 0, 0, 1406, 1385, 1, 0, 0, 0, 1406, 1387, 1, 0, 0, 0, 1406, 1389, 1, 0, 0, 0, 1406, 1391, 1, 0, 0, 0, 1406, 1397, 1, 0, 0, 0, 1406, 1403, 1, 0, 0, 0, 1407, 141, 1, 0, 0, 0, 1408, 1409, 5, 39, 0, 0, 1409, 1410, 3, 116, 58, 0, 1410, 1411, 6, 71, -1, 0, 1411, 1467, 1, 0, 0, 0, 1412, 1413, 5, 197, 0, 0, 1413, 1467, 6, 71, -1, 0, 1414, 1415, 5, 199, 0, 0, 1415, 1416, 5, 39, 0, 0, 1416, 1417, 3, 116, 58, 0, 1417, 1418, 6, 71, -1, 0, 1418, 1467, 1, 0, 0, 0, 1419, 1420, 5, 200, 0, 0, 1420, 1421, 3, 116, 58, 0, 1421, 1422, 6, 71, -1, 0, 1422, 1467, 1, 0, 0, 0, 1423, 1424, 5, 226, 0, 0, 1424, 1425, 3, 170, 85, 0, 1425, 1426, 3, 138, 69, 0, 1426, 1427, 5, 262, 0, 0, 1427, 1428, 3, 112, 56, 0, 1428, 1429, 6, 71, -1, 0, 1429, 1467, 1, 0, 0, 0, 1430, 1431, 5, 253, 0, 0, 1431, 1432, 3, 32, 16, 0, 1432, 1433, 6, 71, -1, 0, 1433, 1467, 1, 0, 0, 0, 1434, 1435, 5, 252, 0, 0, 1435, 1436, 3, 32, 16, 0, 1436, 1437, 6, 71, -1, 0, 1437, 1467, 1, 0, 0, 0, 1438, 1439, 5, 253, 0, 0, 1439, 1440, 3, 2, 1, 0, 1440, 1441, 6, 71, -1, 0, 1441, 1467, 1, 0, 0, 0, 1442, 1443, 5, 252, 0, 0, 1443, 1444, 3, 2, 1, 0, 1444, 1445, 6, 71, -1, 0, 1445, 1467, 1, 0, 0, 0, 1446, 1447, 5, 254, 0, 0, 1447, 1467, 6, 71, -1, 0, 1448, 1449, 5, 201, 0, 0, 1449, 1467, 6, 71, -1, 0, 1450, 1451, 3, 148, 74, 0, 1451, 1452, 6, 71, -1, 0, 1452, 1467, 1, 0, 0, 0, 1453, 1454, 3, 150, 75, 0, 1454, 1455, 6, 71, -1, 0, 1455, 1467, 1, 0, 0, 0, 1456, 1457, 3, 144, 72, 0, 1457, 1458, 6, 71, -1, 0, 1458, 1467, 1, 0, 0, 0, 1459, 1460, 3, 2, 1, 0, 1460, 1461, 6, 71, -1, 0, 1461, 1467, 1, 0, 0, 0, 1462, 1463, 5, 177, 0, 0, 1463, 1464, 3, 138, 69, 0, 1464, 1465, 6, 71, -1, 0, 1465, 1467, 1, 0, 0, 0, 1466, 1408, 1, 0, 0, 0, 1466, 1412, 1, 0, 0, 0, 1466, 1414, 1, 0, 0, 0, 1466, 1419, 1, 0, 0, 0, 1466, 1423, 1, 0, 0, 0, 1466, 1430, 1, 0, 0, 0, 1466, 1434, 1, 0, 0, 0, 1466, 1438, 1, 0, 0, 0, 1466, 1442, 1, 0, 0, 0, 1466, 1446, 1, 0, 0, 0, 1466, 1448, 1, 0, 0, 0, 1466, 1450, 1, 0, 0, 0, 1466, 1453, 1, 0, 0, 0, 1466, 1456, 1, 0, 0, 0, 1466, 1459, 1, 0, 0, 0, 1466, 1462, 1, 0, 0, 0, 1467, 143, 1, 0, 0, 0, 1468, 1469, 5, 181, 0, 0, 1469, 1507, 6, 72, -1, 0, 1470, 1471, 5, 182, 0, 0, 1471, 1507, 6, 72, -1, 0, 1472, 1473, 5, 183, 0, 0, 1473, 1507, 6, 72, -1, 0, 1474, 1475, 5, 184, 0, 0, 1475, 1507, 6, 72, -1, 0, 1476, 1477, 5, 185, 0, 0, 1477, 1507, 6, 72, -1, 0, 1478, 1479, 5, 186, 0, 0, 1479, 1507, 6, 72, -1, 0, 1480, 1481, 5, 187, 0, 0, 1481, 1507, 6, 72, -1, 0, 1482, 1483, 5, 188, 0, 0, 1483, 1507, 6, 72, -1, 0, 1484, 1485, 5, 189, 0, 0, 1485, 1507, 6, 72, -1, 0, 1486, 1487, 5, 190, 0, 0, 1487, 1507, 6, 72, -1, 0, 1488, 1489, 5, 191, 0, 0, 1489, 1507, 6, 72, -1, 0, 1490, 1491, 5, 192, 0, 0, 1491, 1507, 6, 72, -1, 0, 1492, 1493, 5, 193, 0, 0, 1493, 1507, 6, 72, -1, 0, 1494, 1495, 5, 90, 0, 0, 1495, 1496, 5, 184, 0, 0, 1496, 1507, 6, 72, -1, 0, 1497, 1498, 5, 90, 0, 0, 1498, 1499, 5, 185, 0, 0, 1499, 1507, 6, 72, -1, 0, 1500, 1501, 5, 90, 0, 0, 1501, 1502, 5, 186, 0, 0, 1502, 1507, 6, 72, -1, 0, 1503, 1504, 5, 90, 0, 0, 1504, 1505, 5, 187, 0, 0, 1505, 1507, 6, 72, -1, 0, 1506, 1468, 1, 0, 0, 0, 1506, 1470, 1, 0, 0, 0, 1506, 1472, 1, 0, 0, 0, 1506, 1474, 1, 0, 0, 0, 1506, 1476, 1, 0, 0, 0, 1506, 1478, 1, 0, 0, 0, 1506, 1480, 1, 0, 0, 0, 1506, 1482, 1, 0, 0, 0, 1506, 1484, 1, 0, 0, 0, 1506, 1486, 1, 0, 0, 0, 1506, 1488, 1, 0, 0, 0, 1506, 1490, 1, 0, 0, 0, 1506, 1492, 1, 0, 0, 0, 1506, 1494, 1, 0, 0, 0, 1506, 1497, 1, 0, 0, 0, 1506, 1500, 1, 0, 0, 0, 1506, 1503, 1, 0, 0, 0, 1507, 145, 1, 0, 0, 0, 1508, 1523, 1, 0, 0, 0, 1509, 1523, 5, 177, 0, 0, 1510, 1511, 3, 32, 16, 0, 1511, 1512, 6, 73, -1, 0, 1512, 1523, 1, 0, 0, 0, 1513, 1514, 3, 32, 16, 0, 1514, 1515, 5, 177, 0, 0, 1515, 1516, 3, 32, 16, 0, 1516, 1517, 6, 73, -1, 0, 1517, 1523, 1, 0, 0, 0, 1518, 1519, 3, 32, 16, 0, 1519, 1520, 5, 177, 0, 0, 1520, 1521, 6, 73, -1, 0, 1521, 1523, 1, 0, 0, 0, 1522, 1508, 1, 0, 0, 0, 1522, 1509, 1, 0, 0, 0, 1522, 1510, 1, 0, 0, 0, 1522, 1513, 1, 0, 0, 0, 1522, 1518, 1, 0, 0, 0, 1523, 147, 1, 0, 0, 0, 1524, 1525, 5, 1, 0, 0, 1525, 1526, 5, 194, 0, 0, 1526, 1527, 6, 74, -1, 0, 1527, 149, 1, 0, 0, 0, 1528, 1532, 5, 1, 0, 0, 1529, 1530, 5, 90, 0, 0, 1530, 1533, 5, 194, 0, 0, 1531, 1533, 5, 195, 0, 0, 1532, 1529, 1, 0, 0, 0, 1532, 1531, 1, 0, 0, 0, 1533, 1534, 1, 0, 0, 0, 1534, 1535, 6, 75, -1, 0, 1535, 151, 1, 0, 0, 0, 1536, 1537, 5, 294, 0, 0, 1537, 1538, 3, 166, 83, 0, 1538, 1539, 3, 124, 62, 0, 1539, 1540, 5, 30, 0, 0, 1540, 1541, 3, 158, 79, 0, 1541, 1542, 5, 31, 0, 0, 1542, 1584, 1, 0, 0, 0, 1543, 1544, 5, 294, 0, 0, 1544, 1545, 3, 166, 83, 0, 1545, 1546, 3, 124, 62, 0, 1546, 1547, 5, 36, 0, 0, 1547, 1548, 5, 17, 0, 0, 1548, 1549, 3, 52, 26, 0, 1549, 1550, 5, 18, 0, 0, 1550, 1584, 1, 0, 0, 0, 1551, 1552, 5, 294, 0, 0, 1552, 1553, 3, 166, 83, 0, 1553, 1554, 3, 124, 62, 0, 1554, 1584, 1, 0, 0, 0, 1555, 1556, 5, 295, 0, 0, 1556, 1557, 3, 166, 83, 0, 1557, 1559, 5, 36, 0, 0, 1558, 1560, 5, 84, 0, 0, 1559, 1558, 1, 0, 0, 0, 1559, 1560, 1, 0, 0, 0, 1560, 1561, 1, 0, 0, 0, 1561, 1562, 5, 30, 0, 0, 1562, 1563, 3, 292, 146, 0, 1563, 1564, 5, 31, 0, 0, 1564, 1584, 1, 0, 0, 0, 1565, 1566, 5, 295, 0, 0, 1566, 1567, 3, 166, 83, 0, 1567, 1568, 5, 84, 0, 0, 1568, 1569, 5, 30, 0, 0, 1569, 1570, 3, 292, 146, 0, 1570, 1571, 5, 31, 0, 0, 1571, 1584, 1, 0, 0, 0, 1572, 1573, 5, 295, 0, 0, 1573, 1574, 3, 166, 83, 0, 1574, 1575, 3, 6, 3, 0, 1575, 1584, 1, 0, 0, 0, 1576, 1577, 5, 295, 0, 0, 1577, 1578, 3, 166, 83, 0, 1578, 1579, 5, 36, 0, 0, 1579, 1580, 5, 17, 0, 0, 1580, 1581, 3, 154, 77, 0, 1581, 1582, 5, 18, 0, 0, 1582, 1584, 1, 0, 0, 0, 1583, 1536, 1, 0, 0, 0, 1583, 1543, 1, 0, 0, 0, 1583, 1551, 1, 0, 0, 0, 1583, 1555, 1, 0, 0, 0, 1583, 1565, 1, 0, 0, 0, 1583, 1572, 1, 0, 0, 0, 1583, 1576, 1, 0, 0, 0, 1584, 153, 1, 0, 0, 0, 1585, 1596, 1, 0, 0, 0, 1586, 1587, 3, 156, 78, 0, 1587, 1588, 5, 28, 0, 0, 1588, 1590, 1, 0, 0, 0, 1589, 1586, 1, 0, 0, 0, 1590, 1593, 1, 0, 0, 0, 1591, 1589, 1, 0, 0, 0, 1591, 1592, 1, 0, 0, 0, 1592, 1594, 1, 0, 0, 0, 1593, 1591, 1, 0, 0, 0, 1594, 1596, 3, 156, 78, 0, 1595, 1585, 1, 0, 0, 0, 1595, 1591, 1, 0, 0, 0, 1596, 155, 1, 0, 0, 0, 1597, 1598, 5, 39, 0, 0, 1598, 1599, 5, 264, 0, 0, 1599, 1600, 5, 36, 0, 0, 1600, 1601, 5, 17, 0, 0, 1601, 1602, 3, 56, 28, 0, 1602, 1603, 5, 18, 0, 0, 1603, 1611, 1, 0, 0, 0, 1604, 1605, 3, 124, 62, 0, 1605, 1606, 5, 36, 0, 0, 1606, 1607, 5, 17, 0, 0, 1607, 1608, 3, 56, 28, 0, 1608, 1609, 5, 18, 0, 0, 1609, 1611, 1, 0, 0, 0, 1610, 1597, 1, 0, 0, 0, 1610, 1604, 1, 0, 0, 0, 1611, 157, 1, 0, 0, 0, 1612, 1613, 3, 160, 80, 0, 1613, 1614, 5, 28, 0, 0, 1614, 1616, 1, 0, 0, 0, 1615, 1612, 1, 0, 0, 0, 1616, 1619, 1, 0, 0, 0, 1617, 1615, 1, 0, 0, 0, 1617, 1618, 1, 0, 0, 0, 1618, 1620, 1, 0, 0, 0, 1619, 1617, 1, 0, 0, 0, 1620, 1621, 3, 160, 80, 0, 1621, 159, 1, 0, 0, 0, 1622, 1623, 3, 6, 3, 0, 1623, 1624, 5, 36, 0, 0, 1624, 1625, 3, 164, 82, 0, 1625, 161, 1, 0, 0, 0, 1626, 1627, 7, 9, 0, 0, 1627, 163, 1, 0, 0, 0, 1628, 1663, 3, 162, 81, 0, 1629, 1663, 3, 32, 16, 0, 1630, 1631, 5, 186, 0, 0, 1631, 1632, 5, 30, 0, 0, 1632, 1633, 3, 32, 16, 0, 1633, 1634, 5, 31, 0, 0, 1634, 1663, 1, 0, 0, 0, 1635, 1663, 3, 6, 3, 0, 1636, 1637, 3, 116, 58, 0, 1637, 1638, 5, 30, 0, 0, 1638, 1639, 5, 184, 0, 0, 1639, 1640, 5, 75, 0, 0, 1640, 1641, 3, 32, 16, 0, 1641, 1642, 5, 31, 0, 0, 1642, 1663, 1, 0, 0, 0, 1643, 1644, 3, 116, 58, 0, 1644, 1645, 5, 30, 0, 0, 1645, 1646, 5, 185, 0, 0, 1646, 1647, 5, 75, 0, 0, 1647, 1648, 3, 32, 16, 0, 1648, 1649, 5, 31, 0, 0, 1649, 1663, 1, 0, 0, 0, 1650, 1651, 3, 116, 58, 0, 1651, 1652, 5, 30, 0, 0, 1652, 1653, 5, 186, 0, 0, 1653, 1654, 5, 75, 0, 0, 1654, 1655, 3, 32, 16, 0, 1655, 1656, 5, 31, 0, 0, 1656, 1663, 1, 0, 0, 0, 1657, 1658, 3, 116, 58, 0, 1658, 1659, 5, 30, 0, 0, 1659, 1660, 3, 32, 16, 0, 1660, 1661, 5, 31, 0, 0, 1661, 1663, 1, 0, 0, 0, 1662, 1628, 1, 0, 0, 0, 1662, 1629, 1, 0, 0, 0, 1662, 1630, 1, 0, 0, 0, 1662, 1635, 1, 0, 0, 0, 1662, 1636, 1, 0, 0, 0, 1662, 1643, 1, 0, 0, 0, 1662, 1650, 1, 0, 0, 0, 1662, 1657, 1, 0, 0, 0, 1663, 165, 1, 0, 0, 0, 1664, 1665, 7, 10, 0, 0, 1665, 167, 1, 0, 0, 0, 1666, 1667, 3, 170, 85, 0, 1667, 1668, 3, 138, 69, 0, 1668, 1669, 3, 124, 62, 0, 1669, 1670, 5, 176, 0, 0, 1670, 1672, 3, 242, 121, 0, 1671, 1673, 3, 108, 54, 0, 1672, 1671, 1, 0, 0, 0, 1672, 1673, 1, 0, 0, 0, 1673, 1674, 1, 0, 0, 0, 1674, 1675, 3, 112, 56, 0, 1675, 1676, 6, 84, -1, 0, 1676, 1709, 1, 0, 0, 0, 1677, 1678, 3, 170, 85, 0, 1678, 1679, 3, 138, 69, 0, 1679, 1680, 3, 124, 62, 0, 1680, 1681, 5, 176, 0, 0, 1681, 1682, 3, 242, 121, 0, 1682, 1683, 3, 196, 98, 0, 1683, 1684, 3, 112, 56, 0, 1684, 1685, 6, 84, -1, 0, 1685, 1709, 1, 0, 0, 0, 1686, 1687, 3, 170, 85, 0, 1687, 1688, 3, 138, 69, 0, 1688, 1690, 3, 242, 121, 0, 1689, 1691, 3, 108, 54, 0, 1690, 1689, 1, 0, 0, 0, 1690, 1691, 1, 0, 0, 0, 1691, 1692, 1, 0, 0, 0, 1692, 1693, 3, 112, 56, 0, 1693, 1694, 6, 84, -1, 0, 1694, 1709, 1, 0, 0, 0, 1695, 1696, 3, 170, 85, 0, 1696, 1697, 3, 138, 69, 0, 1697, 1698, 3, 242, 121, 0, 1698, 1699, 3, 196, 98, 0, 1699, 1700, 3, 112, 56, 0, 1700, 1701, 6, 84, -1, 0, 1701, 1709, 1, 0, 0, 0, 1702, 1703, 3, 174, 87, 0, 1703, 1704, 6, 84, -1, 0, 1704, 1709, 1, 0, 0, 0, 1705, 1706, 3, 2, 1, 0, 1706, 1707, 6, 84, -1, 0, 1707, 1709, 1, 0, 0, 0, 1708, 1666, 1, 0, 0, 0, 1708, 1677, 1, 0, 0, 0, 1708, 1686, 1, 0, 0, 0, 1708, 1695, 1, 0, 0, 0, 1708, 1702, 1, 0, 0, 0, 1708, 1705, 1, 0, 0, 0, 1709, 169, 1, 0, 0, 0, 1710, 1711, 5, 243, 0, 0, 1711, 1712, 3, 170, 85, 0, 1712, 1713, 6, 85, -1, 0, 1713, 1728, 1, 0, 0, 0, 1714, 1715, 5, 244, 0, 0, 1715, 1716, 3, 170, 85, 0, 1716, 1717, 6, 85, -1, 0, 1717, 1728, 1, 0, 0, 0, 1718, 1719, 3, 172, 86, 0, 1719, 1720, 6, 85, -1, 0, 1720, 1728, 1, 0, 0, 0, 1721, 1722, 5, 112, 0, 0, 1722, 1723, 5, 30, 0, 0, 1723, 1724, 3, 32, 16, 0, 1724, 1725, 5, 31, 0, 0, 1725, 1726, 6, 85, -1, 0, 1726, 1728, 1, 0, 0, 0, 1727, 1710, 1, 0, 0, 0, 1727, 1714, 1, 0, 0, 0, 1727, 1718, 1, 0, 0, 0, 1727, 1721, 1, 0, 0, 0, 1728, 171, 1, 0, 0, 0, 1729, 1749, 1, 0, 0, 0, 1730, 1731, 5, 245, 0, 0, 1731, 1749, 6, 86, -1, 0, 1732, 1733, 5, 246, 0, 0, 1733, 1749, 6, 86, -1, 0, 1734, 1735, 5, 247, 0, 0, 1735, 1736, 5, 248, 0, 0, 1736, 1749, 6, 86, -1, 0, 1737, 1738, 5, 247, 0, 0, 1738, 1739, 5, 249, 0, 0, 1739, 1749, 6, 86, -1, 0, 1740, 1741, 5, 247, 0, 0, 1741, 1742, 5, 250, 0, 0, 1742, 1749, 6, 86, -1, 0, 1743, 1744, 5, 247, 0, 0, 1744, 1745, 5, 251, 0, 0, 1745, 1749, 6, 86, -1, 0, 1746, 1747, 5, 247, 0, 0, 1747, 1749, 6, 86, -1, 0, 1748, 1729, 1, 0, 0, 0, 1748, 1730, 1, 0, 0, 0, 1748, 1732, 1, 0, 0, 0, 1748, 1734, 1, 0, 0, 0, 1748, 1737, 1, 0, 0, 0, 1748, 1740, 1, 0, 0, 0, 1748, 1743, 1, 0, 0, 0, 1748, 1746, 1, 0, 0, 0, 1749, 173, 1, 0, 0, 0, 1750, 1751, 5, 113, 0, 0, 1751, 1752, 5, 30, 0, 0, 1752, 1753, 3, 32, 16, 0, 1753, 1754, 5, 31, 0, 0, 1754, 1755, 6, 87, -1, 0, 1755, 175, 1, 0, 0, 0, 1756, 1757, 5, 226, 0, 0, 1757, 1758, 3, 168, 84, 0, 1758, 1759, 6, 88, -1, 0, 1759, 1768, 1, 0, 0, 0, 1760, 1761, 5, 37, 0, 0, 1761, 1762, 3, 178, 89, 0, 1762, 1763, 6, 88, -1, 0, 1763, 1768, 1, 0, 0, 0, 1764, 1765, 3, 174, 87, 0, 1765, 1766, 6, 88, -1, 0, 1766, 1768, 1, 0, 0, 0, 1767, 1756, 1, 0, 0, 0, 1767, 1760, 1, 0, 0, 0, 1767, 1764, 1, 0, 0, 0, 1768, 177, 1, 0, 0, 0, 1769, 1770, 3, 138, 69, 0, 1770, 1771, 3, 124, 62, 0, 1771, 1772, 5, 176, 0, 0, 1772, 1773, 3, 2, 1, 0, 1773, 1774, 6, 89, -1, 0, 1774, 1783, 1, 0, 0, 0, 1775, 1776, 3, 138, 69, 0, 1776, 1777, 3, 2, 1, 0, 1777, 1778, 6, 89, -1, 0, 1778, 1783, 1, 0, 0, 0, 1779, 1780, 3, 2, 1, 0, 1780, 1781, 6, 89, -1, 0, 1781, 1783, 1, 0, 0, 0, 1782, 1769, 1, 0, 0, 0, 1782, 1775, 1, 0, 0, 0, 1782, 1779, 1, 0, 0, 0, 1783, 179, 1, 0, 0, 0, 1784, 1785, 3, 124, 62, 0, 1785, 1786, 5, 28, 0, 0, 1786, 1788, 1, 0, 0, 0, 1787, 1784, 1, 0, 0, 0, 1788, 1791, 1, 0, 0, 0, 1789, 1787, 1, 0, 0, 0, 1789, 1790, 1, 0, 0, 0, 1790, 1792, 1, 0, 0, 0, 1791, 1789, 1, 0, 0, 0, 1792, 1793, 3, 124, 62, 0, 1793, 181, 1, 0, 0, 0, 1794, 1800, 1, 0, 0, 0, 1795, 1796, 5, 86, 0, 0, 1796, 1797, 3, 190, 95, 0, 1797, 1798, 5, 87, 0, 0, 1798, 1800, 1, 0, 0, 0, 1799, 1794, 1, 0, 0, 0, 1799, 1795, 1, 0, 0, 0, 1800, 183, 1, 0, 0, 0, 1801, 1813, 5, 266, 0, 0, 1802, 1813, 5, 114, 0, 0, 1803, 1813, 5, 39, 0, 0, 1804, 1813, 5, 200, 0, 0, 1805, 1813, 5, 115, 0, 0, 1806, 1813, 5, 116, 0, 0, 1807, 1808, 5, 70, 0, 0, 1808, 1809, 5, 30, 0, 0, 1809, 1810, 3, 32, 16, 0, 1810, 1811, 5, 31, 0, 0, 1811, 1813, 1, 0, 0, 0, 1812, 1801, 1, 0, 0, 0, 1812, 1802, 1, 0, 0, 0, 1812, 1803, 1, 0, 0, 0, 1812, 1804, 1, 0, 0, 0, 1812, 1805, 1, 0, 0, 0, 1812, 1806, 1, 0, 0, 0, 1812, 1807, 1, 0, 0, 0, 1813, 185, 1, 0, 0, 0, 1814, 1816, 3, 184, 92, 0, 1815, 1814, 1, 0, 0, 0, 1816, 1819, 1, 0, 0, 0, 1817, 1815, 1, 0, 0, 0, 1817, 1818, 1, 0, 0, 0, 1818, 187, 1, 0, 0, 0, 1819, 1817, 1, 0, 0, 0, 1820, 1822, 3, 186, 93, 0, 1821, 1823, 3, 192, 96, 0, 1822, 1821, 1, 0, 0, 0, 1822, 1823, 1, 0, 0, 0, 1823, 1824, 1, 0, 0, 0, 1824, 1825, 3, 2, 1, 0, 1825, 189, 1, 0, 0, 0, 1826, 1827, 3, 188, 94, 0, 1827, 1828, 5, 28, 0, 0, 1828, 1830, 1, 0, 0, 0, 1829, 1826, 1, 0, 0, 0, 1830, 1833, 1, 0, 0, 0, 1831, 1829, 1, 0, 0, 0, 1831, 1832, 1, 0, 0, 0, 1832, 1834, 1, 0, 0, 0, 1833, 1831, 1, 0, 0, 0, 1834, 1835, 3, 188, 94, 0, 1835, 191, 1, 0, 0, 0, 1836, 1837, 5, 30, 0, 0, 1837, 1838, 3, 180, 90, 0, 1838, 1839, 5, 31, 0, 0, 1839, 193, 1, 0, 0, 0, 1840, 1842, 3, 196, 98, 0, 1841, 1840, 1, 0, 0, 0, 1841, 1842, 1, 0, 0, 0, 1842, 1843, 1, 0, 0, 0, 1843, 1844, 6, 97, -1, 0, 1844, 195, 1, 0, 0, 0, 1845, 1846, 5, 86, 0, 0, 1846, 1847, 5, 42, 0, 0, 1847, 1848, 3, 32, 16, 0, 1848, 1849, 5, 43, 0, 0, 1849, 1850, 5, 87, 0, 0, 1850, 1851, 6, 98, -1, 0, 1851, 197, 1, 0, 0, 0, 1852, 1853, 3, 234, 117, 0, 1853, 1854, 5, 17, 0, 0, 1854, 1855, 3, 246, 123, 0, 1855, 1856, 5, 18, 0, 0, 1856, 1969, 1, 0, 0, 0, 1857, 1858, 3, 74, 37, 0, 1858, 1859, 5, 17, 0, 0, 1859, 1860, 3, 82, 41, 0, 1860, 1861, 5, 18, 0, 0, 1861, 1969, 1, 0, 0, 0, 1862, 1863, 3, 210, 105, 0, 1863, 1864, 5, 17, 0, 0, 1864, 1865, 3, 214, 107, 0, 1865, 1866, 5, 18, 0, 0, 1866, 1969, 1, 0, 0, 0, 1867, 1868, 3, 218, 109, 0, 1868, 1869, 5, 17, 0, 0, 1869, 1870, 3, 222, 111, 0, 1870, 1871, 5, 18, 0, 0, 1871, 1969, 1, 0, 0, 0, 1872, 1969, 3, 200, 100, 0, 1873, 1969, 3, 276, 138, 0, 1874, 1969, 3, 152, 76, 0, 1875, 1969, 3, 88, 44, 0, 1876, 1969, 3, 322, 161, 0, 1877, 1878, 5, 117, 0, 0, 1878, 1969, 3, 32, 16, 0, 1879, 1880, 5, 118, 0, 0, 1880, 1969, 3, 32, 16, 0, 1881, 1882, 3, 334, 167, 0, 1882, 1883, 5, 17, 0, 0, 1883, 1884, 3, 338, 169, 0, 1884, 1885, 5, 18, 0, 0, 1885, 1969, 1, 0, 0, 0, 1886, 1887, 5, 302, 0, 0, 1887, 1888, 3, 124, 62, 0, 1888, 1889, 5, 176, 0, 0, 1889, 1890, 3, 242, 121, 0, 1890, 1891, 5, 119, 0, 0, 1891, 1892, 3, 170, 85, 0, 1892, 1893, 3, 138, 69, 0, 1893, 1894, 3, 124, 62, 0, 1894, 1895, 5, 176, 0, 0, 1895, 1896, 3, 242, 121, 0, 1896, 1897, 3, 112, 56, 0, 1897, 1969, 1, 0, 0, 0, 1898, 1899, 5, 302, 0, 0, 1899, 1900, 5, 226, 0, 0, 1900, 1901, 3, 170, 85, 0, 1901, 1902, 3, 138, 69, 0, 1902, 1903, 3, 124, 62, 0, 1903, 1904, 5, 176, 0, 0, 1904, 1905, 3, 242, 121, 0, 1905, 1906, 3, 194, 97, 0, 1906, 1907, 3, 112, 56, 0, 1907, 1908, 5, 119, 0, 0, 1908, 1909, 5, 226, 0, 0, 1909, 1910, 3, 170, 85, 0, 1910, 1911, 3, 138, 69, 0, 1911, 1912, 3, 124, 62, 0, 1912, 1913, 5, 176, 0, 0, 1913, 1914, 3, 242, 121, 0, 1914, 1915, 3, 194, 97, 0, 1915, 1916, 3, 112, 56, 0, 1916, 1969, 1, 0, 0, 0, 1917, 1969, 3, 26, 13, 0, 1918, 1969, 3, 40, 20, 0, 1919, 1920, 5, 255, 0, 0, 1920, 1921, 5, 196, 0, 0, 1921, 1922, 5, 42, 0, 0, 1922, 1923, 3, 32, 16, 0, 1923, 1927, 5, 43, 0, 0, 1924, 1926, 3, 322, 161, 0, 1925, 1924, 1, 0, 0, 0, 1926, 1929, 1, 0, 0, 0, 1927, 1925, 1, 0, 0, 0, 1927, 1928, 1, 0, 0, 0, 1928, 1969, 1, 0, 0, 0, 1929, 1927, 1, 0, 0, 0, 1930, 1931, 5, 255, 0, 0, 1931, 1932, 5, 196, 0, 0, 1932, 1936, 3, 2, 1, 0, 1933, 1935, 3, 322, 161, 0, 1934, 1933, 1, 0, 0, 0, 1935, 1938, 1, 0, 0, 0, 1936, 1934, 1, 0, 0, 0, 1936, 1937, 1, 0, 0, 0, 1937, 1969, 1, 0, 0, 0, 1938, 1936, 1, 0, 0, 0, 1939, 1940, 5, 255, 0, 0, 1940, 1941, 5, 256, 0, 0, 1941, 1942, 5, 42, 0, 0, 1942, 1943, 3, 32, 16, 0, 1943, 1944, 5, 43, 0, 0, 1944, 1945, 5, 28, 0, 0, 1945, 1949, 3, 124, 62, 0, 1946, 1948, 3, 322, 161, 0, 1947, 1946, 1, 0, 0, 0, 1948, 1951, 1, 0, 0, 0, 1949, 1947, 1, 0, 0, 0, 1949, 1950, 1, 0, 0, 0, 1950, 1969, 1, 0, 0, 0, 1951, 1949, 1, 0, 0, 0, 1952, 1953, 5, 255, 0, 0, 1953, 1954, 5, 256, 0, 0, 1954, 1955, 3, 2, 1, 0, 1955, 1956, 5, 28, 0, 0, 1956, 1960, 3, 124, 62, 0, 1957, 1959, 3, 322, 161, 0, 1958, 1957, 1, 0, 0, 0, 1959, 1962, 1, 0, 0, 0, 1960, 1958, 1, 0, 0, 0, 1960, 1961, 1, 0, 0, 0, 1961, 1969, 1, 0, 0, 0, 1962, 1960, 1, 0, 0, 0, 1963, 1964, 5, 120, 0, 0, 1964, 1965, 5, 196, 0, 0, 1965, 1966, 3, 124, 62, 0, 1966, 1967, 3, 44, 22, 0, 1967, 1969, 1, 0, 0, 0, 1968, 1852, 1, 0, 0, 0, 1968, 1857, 1, 0, 0, 0, 1968, 1862, 1, 0, 0, 0, 1968, 1867, 1, 0, 0, 0, 1968, 1872, 1, 0, 0, 0, 1968, 1873, 1, 0, 0, 0, 1968, 1874, 1, 0, 0, 0, 1968, 1875, 1, 0, 0, 0, 1968, 1876, 1, 0, 0, 0, 1968, 1877, 1, 0, 0, 0, 1968, 1879, 1, 0, 0, 0, 1968, 1881, 1, 0, 0, 0, 1968, 1886, 1, 0, 0, 0, 1968, 1898, 1, 0, 0, 0, 1968, 1917, 1, 0, 0, 0, 1968, 1918, 1, 0, 0, 0, 1968, 1919, 1, 0, 0, 0, 1968, 1930, 1, 0, 0, 0, 1968, 1939, 1, 0, 0, 0, 1968, 1952, 1, 0, 0, 0, 1968, 1963, 1, 0, 0, 0, 1969, 199, 1, 0, 0, 0, 1970, 1971, 5, 121, 0, 0, 1971, 1980, 3, 208, 104, 0, 1972, 1979, 3, 202, 101, 0, 1973, 1974, 5, 122, 0, 0, 1974, 1975, 5, 30, 0, 0, 1975, 1976, 3, 228, 114, 0, 1976, 1977, 5, 31, 0, 0, 1977, 1979, 1, 0, 0, 0, 1978, 1972, 1, 0, 0, 0, 1978, 1973, 1, 0, 0, 0, 1979, 1982, 1, 0, 0, 0, 1980, 1978, 1, 0, 0, 0, 1980, 1981, 1, 0, 0, 0, 1981, 1983, 1, 0, 0, 0, 1982, 1980, 1, 0, 0, 0, 1983, 1984, 3, 138, 69, 0, 1984, 1985, 3, 2, 1, 0, 1985, 1986, 3, 204, 102, 0, 1986, 1987, 3, 206, 103, 0, 1987, 201, 1, 0, 0, 0, 1988, 2008, 5, 123, 0, 0, 1989, 2008, 5, 51, 0, 0, 1990, 2008, 5, 52, 0, 0, 1991, 2008, 5, 63, 0, 0, 1992, 2008, 5, 124, 0, 0, 1993, 2008, 5, 69, 0, 0, 1994, 2008, 5, 68, 0, 0, 1995, 2008, 5, 64, 0, 0, 1996, 2008, 5, 65, 0, 0, 1997, 2008, 5, 66, 0, 0, 1998, 2008, 5, 125, 0, 0, 1999, 2008, 5, 126, 0, 0, 2000, 2008, 5, 127, 0, 0, 2001, 2008, 5, 16, 0, 0, 2002, 2003, 5, 70, 0, 0, 2003, 2004, 5, 30, 0, 0, 2004, 2005, 3, 32, 16, 0, 2005, 2006, 5, 31, 0, 0, 2006, 2008, 1, 0, 0, 0, 2007, 1988, 1, 0, 0, 0, 2007, 1989, 1, 0, 0, 0, 2007, 1990, 1, 0, 0, 0, 2007, 1991, 1, 0, 0, 0, 2007, 1992, 1, 0, 0, 0, 2007, 1993, 1, 0, 0, 0, 2007, 1994, 1, 0, 0, 0, 2007, 1995, 1, 0, 0, 0, 2007, 1996, 1, 0, 0, 0, 2007, 1997, 1, 0, 0, 0, 2007, 1998, 1, 0, 0, 0, 2007, 1999, 1, 0, 0, 0, 2007, 2000, 1, 0, 0, 0, 2007, 2001, 1, 0, 0, 0, 2007, 2002, 1, 0, 0, 0, 2008, 203, 1, 0, 0, 0, 2009, 2015, 1, 0, 0, 0, 2010, 2011, 5, 44, 0, 0, 2011, 2015, 3, 0, 0, 0, 2012, 2013, 5, 44, 0, 0, 2013, 2015, 3, 32, 16, 0, 2014, 2009, 1, 0, 0, 0, 2014, 2010, 1, 0, 0, 0, 2014, 2012, 1, 0, 0, 0, 2015, 205, 1, 0, 0, 0, 2016, 2020, 1, 0, 0, 0, 2017, 2018, 5, 36, 0, 0, 2018, 2020, 3, 296, 148, 0, 2019, 2016, 1, 0, 0, 0, 2019, 2017, 1, 0, 0, 0, 2020, 207, 1, 0, 0, 0, 2021, 2027, 1, 0, 0, 0, 2022, 2023, 5, 42, 0, 0, 2023, 2024, 3, 32, 16, 0, 2024, 2025, 5, 43, 0, 0, 2025, 2027, 1, 0, 0, 0, 2026, 2021, 1, 0, 0, 0, 2026, 2022, 1, 0, 0, 0, 2027, 209, 1, 0, 0, 0, 2028, 2032, 5, 128, 0, 0, 2029, 2031, 3, 212, 106, 0, 2030, 2029, 1, 0, 0, 0, 2031, 2034, 1, 0, 0, 0, 2032, 2030, 1, 0, 0, 0, 2032, 2033, 1, 0, 0, 0, 2033, 2035, 1, 0, 0, 0, 2034, 2032, 1, 0, 0, 0, 2035, 2036, 3, 124, 62, 0, 2036, 2037, 3, 2, 1, 0, 2037, 2047, 1, 0, 0, 0, 2038, 2042, 5, 128, 0, 0, 2039, 2041, 3, 212, 106, 0, 2040, 2039, 1, 0, 0, 0, 2041, 2044, 1, 0, 0, 0, 2042, 2040, 1, 0, 0, 0, 2042, 2043, 1, 0, 0, 0, 2043, 2045, 1, 0, 0, 0, 2044, 2042, 1, 0, 0, 0, 2045, 2047, 3, 2, 1, 0, 2046, 2028, 1, 0, 0, 0, 2046, 2038, 1, 0, 0, 0, 2047, 211, 1, 0, 0, 0, 2048, 2049, 7, 11, 0, 0, 2049, 213, 1, 0, 0, 0, 2050, 2052, 3, 216, 108, 0, 2051, 2050, 1, 0, 0, 0, 2052, 2055, 1, 0, 0, 0, 2053, 2051, 1, 0, 0, 0, 2053, 2054, 1, 0, 0, 0, 2054, 215, 1, 0, 0, 0, 2055, 2053, 1, 0, 0, 0, 2056, 2057, 5, 129, 0, 0, 2057, 2069, 3, 168, 84, 0, 2058, 2059, 5, 130, 0, 0, 2059, 2069, 3, 168, 84, 0, 2060, 2061, 5, 131, 0, 0, 2061, 2069, 3, 168, 84, 0, 2062, 2063, 5, 132, 0, 0, 2063, 2069, 3, 168, 84, 0, 2064, 2069, 3, 88, 44, 0, 2065, 2069, 3, 322, 161, 0, 2066, 2069, 3, 26, 13, 0, 2067, 2069, 3, 40, 20, 0, 2068, 2056, 1, 0, 0, 0, 2068, 2058, 1, 0, 0, 0, 2068, 2060, 1, 0, 0, 0, 2068, 2062, 1, 0, 0, 0, 2068, 2064, 1, 0, 0, 0, 2068, 2065, 1, 0, 0, 0, 2068, 2066, 1, 0, 0, 0, 2068, 2067, 1, 0, 0, 0, 2069, 217, 1, 0, 0, 0, 2070, 2074, 5, 133, 0, 0, 2071, 2073, 3, 220, 110, 0, 2072, 2071, 1, 0, 0, 0, 2073, 2076, 1, 0, 0, 0, 2074, 2072, 1, 0, 0, 0, 2074, 2075, 1, 0, 0, 0, 2075, 2077, 1, 0, 0, 0, 2076, 2074, 1, 0, 0, 0, 2077, 2078, 3, 170, 85, 0, 2078, 2079, 3, 138, 69, 0, 2079, 2080, 3, 2, 1, 0, 2080, 2081, 3, 112, 56, 0, 2081, 2082, 3, 206, 103, 0, 2082, 219, 1, 0, 0, 0, 2083, 2084, 7, 11, 0, 0, 2084, 221, 1, 0, 0, 0, 2085, 2087, 3, 224, 112, 0, 2086, 2085, 1, 0, 0, 0, 2087, 2090, 1, 0, 0, 0, 2088, 2086, 1, 0, 0, 0, 2088, 2089, 1, 0, 0, 0, 2089, 223, 1, 0, 0, 0, 2090, 2088, 1, 0, 0, 0, 2091, 2092, 5, 134, 0, 0, 2092, 2102, 3, 168, 84, 0, 2093, 2094, 5, 135, 0, 0, 2094, 2102, 3, 168, 84, 0, 2095, 2096, 5, 132, 0, 0, 2096, 2102, 3, 168, 84, 0, 2097, 2102, 3, 322, 161, 0, 2098, 2102, 3, 88, 44, 0, 2099, 2102, 3, 26, 13, 0, 2100, 2102, 3, 40, 20, 0, 2101, 2091, 1, 0, 0, 0, 2101, 2093, 1, 0, 0, 0, 2101, 2095, 1, 0, 0, 0, 2101, 2097, 1, 0, 0, 0, 2101, 2098, 1, 0, 0, 0, 2101, 2099, 1, 0, 0, 0, 2101, 2100, 1, 0, 0, 0, 2102, 225, 1, 0, 0, 0, 2103, 2110, 1, 0, 0, 0, 2104, 2105, 5, 122, 0, 0, 2105, 2106, 5, 30, 0, 0, 2106, 2107, 3, 228, 114, 0, 2107, 2108, 5, 31, 0, 0, 2108, 2110, 1, 0, 0, 0, 2109, 2103, 1, 0, 0, 0, 2109, 2104, 1, 0, 0, 0, 2110, 227, 1, 0, 0, 0, 2111, 2121, 3, 126, 63, 0, 2112, 2114, 5, 17, 0, 0, 2113, 2115, 3, 294, 147, 0, 2114, 2113, 1, 0, 0, 0, 2115, 2116, 1, 0, 0, 0, 2116, 2114, 1, 0, 0, 0, 2116, 2117, 1, 0, 0, 0, 2117, 2118, 1, 0, 0, 0, 2118, 2119, 5, 18, 0, 0, 2119, 2121, 1, 0, 0, 0, 2120, 2111, 1, 0, 0, 0, 2120, 2112, 1, 0, 0, 0, 2121, 229, 1, 0, 0, 0, 2122, 2123, 3, 232, 116, 0, 2123, 2124, 6, 115, -1, 0, 2124, 2126, 1, 0, 0, 0, 2125, 2122, 1, 0, 0, 0, 2126, 2129, 1, 0, 0, 0, 2127, 2125, 1, 0, 0, 0, 2127, 2128, 1, 0, 0, 0, 2128, 231, 1, 0, 0, 0, 2129, 2127, 1, 0, 0, 0, 2130, 2131, 5, 42, 0, 0, 2131, 2132, 5, 136, 0, 0, 2132, 2133, 5, 43, 0, 0, 2133, 2148, 6, 116, -1, 0, 2134, 2135, 5, 42, 0, 0, 2135, 2136, 5, 137, 0, 0, 2136, 2137, 5, 43, 0, 0, 2137, 2148, 6, 116, -1, 0, 2138, 2139, 5, 42, 0, 0, 2139, 2140, 5, 138, 0, 0, 2140, 2141, 5, 43, 0, 0, 2141, 2148, 6, 116, -1, 0, 2142, 2143, 5, 42, 0, 0, 2143, 2144, 3, 32, 16, 0, 2144, 2145, 5, 43, 0, 0, 2145, 2146, 6, 116, -1, 0, 2146, 2148, 1, 0, 0, 0, 2147, 2130, 1, 0, 0, 0, 2147, 2134, 1, 0, 0, 0, 2147, 2138, 1, 0, 0, 0, 2147, 2142, 1, 0, 0, 0, 2148, 233, 1, 0, 0, 0, 2149, 2154, 5, 139, 0, 0, 2150, 2153, 3, 236, 118, 0, 2151, 2153, 3, 238, 119, 0, 2152, 2150, 1, 0, 0, 0, 2152, 2151, 1, 0, 0, 0, 2153, 2156, 1, 0, 0, 0, 2154, 2152, 1, 0, 0, 0, 2154, 2155, 1, 0, 0, 0, 2155, 2157, 1, 0, 0, 0, 2156, 2154, 1, 0, 0, 0, 2157, 2158, 3, 170, 85, 0, 2158, 2159, 3, 230, 115, 0, 2159, 2160, 3, 138, 69, 0, 2160, 2161, 3, 226, 113, 0, 2161, 2162, 3, 242, 121, 0, 2162, 2163, 3, 182, 91, 0, 2163, 2167, 3, 112, 56, 0, 2164, 2166, 3, 244, 122, 0, 2165, 2164, 1, 0, 0, 0, 2166, 2169, 1, 0, 0, 0, 2167, 2165, 1, 0, 0, 0, 2167, 2168, 1, 0, 0, 0, 2168, 235, 1, 0, 0, 0, 2169, 2167, 1, 0, 0, 0, 2170, 2194, 5, 123, 0, 0, 2171, 2194, 5, 51, 0, 0, 2172, 2194, 5, 52, 0, 0, 2173, 2194, 5, 63, 0, 0, 2174, 2194, 5, 140, 0, 0, 2175, 2194, 5, 68, 0, 0, 2176, 2194, 5, 141, 0, 0, 2177, 2194, 5, 142, 0, 0, 2178, 2194, 5, 54, 0, 0, 2179, 2194, 5, 64, 0, 0, 2180, 2194, 5, 65, 0, 0, 2181, 2194, 5, 66, 0, 0, 2182, 2194, 5, 125, 0, 0, 2183, 2194, 5, 143, 0, 0, 2184, 2194, 5, 144, 0, 0, 2185, 2194, 5, 69, 0, 0, 2186, 2194, 5, 145, 0, 0, 2187, 2194, 5, 146, 0, 0, 2188, 2189, 5, 70, 0, 0, 2189, 2190, 5, 30, 0, 0, 2190, 2191, 3, 32, 16, 0, 2191, 2192, 5, 31, 0, 0, 2192, 2194, 1, 0, 0, 0, 2193, 2170, 1, 0, 0, 0, 2193, 2171, 1, 0, 0, 0, 2193, 2172, 1, 0, 0, 0, 2193, 2173, 1, 0, 0, 0, 2193, 2174, 1, 0, 0, 0, 2193, 2175, 1, 0, 0, 0, 2193, 2176, 1, 0, 0, 0, 2193, 2177, 1, 0, 0, 0, 2193, 2178, 1, 0, 0, 0, 2193, 2179, 1, 0, 0, 0, 2193, 2180, 1, 0, 0, 0, 2193, 2181, 1, 0, 0, 0, 2193, 2182, 1, 0, 0, 0, 2193, 2183, 1, 0, 0, 0, 2193, 2184, 1, 0, 0, 0, 2193, 2185, 1, 0, 0, 0, 2193, 2186, 1, 0, 0, 0, 2193, 2187, 1, 0, 0, 0, 2193, 2188, 1, 0, 0, 0, 2194, 237, 1, 0, 0, 0, 2195, 2196, 5, 147, 0, 0, 2196, 2202, 5, 30, 0, 0, 2197, 2200, 3, 6, 3, 0, 2198, 2199, 5, 34, 0, 0, 2199, 2201, 3, 6, 3, 0, 2200, 2198, 1, 0, 0, 0, 2200, 2201, 1, 0, 0, 0, 2201, 2203, 1, 0, 0, 0, 2202, 2197, 1, 0, 0, 0, 2202, 2203, 1, 0, 0, 0, 2203, 2207, 1, 0, 0, 0, 2204, 2206, 3, 240, 120, 0, 2205, 2204, 1, 0, 0, 0, 2206, 2209, 1, 0, 0, 0, 2207, 2205, 1, 0, 0, 0, 2207, 2208, 1, 0, 0, 0, 2208, 2210, 1, 0, 0, 0, 2209, 2207, 1, 0, 0, 0, 2210, 2214, 5, 31, 0, 0, 2211, 2212, 5, 147, 0, 0, 2212, 2214, 5, 85, 0, 0, 2213, 2195, 1, 0, 0, 0, 2213, 2211, 1, 0, 0, 0, 2214, 239, 1, 0, 0, 0, 2215, 2243, 5, 148, 0, 0, 2216, 2243, 5, 224, 0, 0, 2217, 2243, 5, 57, 0, 0, 2218, 2243, 5, 58, 0, 0, 2219, 2243, 5, 149, 0, 0, 2220, 2243, 5, 150, 0, 0, 2221, 2243, 5, 248, 0, 0, 2222, 2243, 5, 249, 0, 0, 2223, 2243, 5, 250, 0, 0, 2224, 2243, 5, 251, 0, 0, 2225, 2226, 5, 151, 0, 0, 2226, 2227, 5, 75, 0, 0, 2227, 2243, 5, 152, 0, 0, 2228, 2229, 5, 151, 0, 0, 2229, 2230, 5, 75, 0, 0, 2230, 2243, 5, 153, 0, 0, 2231, 2232, 5, 154, 0, 0, 2232, 2233, 5, 75, 0, 0, 2233, 2243, 5, 152, 0, 0, 2234, 2235, 5, 154, 0, 0, 2235, 2236, 5, 75, 0, 0, 2236, 2243, 5, 153, 0, 0, 2237, 2238, 5, 70, 0, 0, 2238, 2239, 5, 30, 0, 0, 2239, 2240, 3, 32, 16, 0, 2240, 2241, 5, 31, 0, 0, 2241, 2243, 1, 0, 0, 0, 2242, 2215, 1, 0, 0, 0, 2242, 2216, 1, 0, 0, 0, 2242, 2217, 1, 0, 0, 0, 2242, 2218, 1, 0, 0, 0, 2242, 2219, 1, 0, 0, 0, 2242, 2220, 1, 0, 0, 0, 2242, 2221, 1, 0, 0, 0, 2242, 2222, 1, 0, 0, 0, 2242, 2223, 1, 0, 0, 0, 2242, 2224, 1, 0, 0, 0, 2242, 2225, 1, 0, 0, 0, 2242, 2228, 1, 0, 0, 0, 2242, 2231, 1, 0, 0, 0, 2242, 2234, 1, 0, 0, 0, 2242, 2237, 1, 0, 0, 0, 2243, 241, 1, 0, 0, 0, 2244, 2245, 5, 116, 0, 0, 2245, 2252, 6, 121, -1, 0, 2246, 2247, 5, 155, 0, 0, 2247, 2252, 6, 121, -1, 0, 2248, 2249, 3, 2, 1, 0, 2249, 2250, 6, 121, -1, 0, 2250, 2252, 1, 0, 0, 0, 2251, 2244, 1, 0, 0, 0, 2251, 2246, 1, 0, 0, 0, 2251, 2248, 1, 0, 0, 0, 2252, 243, 1, 0, 0, 0, 2253, 2275, 5, 1, 0, 0, 2254, 2275, 5, 2, 0, 0, 2255, 2275, 5, 156, 0, 0, 2256, 2275, 5, 3, 0, 0, 2257, 2275, 5, 4, 0, 0, 2258, 2275, 5, 247, 0, 0, 2259, 2275, 5, 5, 0, 0, 2260, 2275, 5, 6, 0, 0, 2261, 2275, 5, 7, 0, 0, 2262, 2275, 5, 8, 0, 0, 2263, 2275, 5, 9, 0, 0, 2264, 2275, 5, 10, 0, 0, 2265, 2275, 5, 11, 0, 0, 2266, 2275, 5, 12, 0, 0, 2267, 2275, 5, 13, 0, 0, 2268, 2275, 5, 14, 0, 0, 2269, 2270, 5, 70, 0, 0, 2270, 2271, 5, 30, 0, 0, 2271, 2272, 3, 32, 16, 0, 2272, 2273, 5, 31, 0, 0, 2273, 2275, 1, 0, 0, 0, 2274, 2253, 1, 0, 0, 0, 2274, 2254, 1, 0, 0, 0, 2274, 2255, 1, 0, 0, 0, 2274, 2256, 1, 0, 0, 0, 2274, 2257, 1, 0, 0, 0, 2274, 2258, 1, 0, 0, 0, 2274, 2259, 1, 0, 0, 0, 2274, 2260, 1, 0, 0, 0, 2274, 2261, 1, 0, 0, 0, 2274, 2262, 1, 0, 0, 0, 2274, 2263, 1, 0, 0, 0, 2274, 2264, 1, 0, 0, 0, 2274, 2265, 1, 0, 0, 0, 2274, 2266, 1, 0, 0, 0, 2274, 2267, 1, 0, 0, 0, 2274, 2268, 1, 0, 0, 0, 2274, 2269, 1, 0, 0, 0, 2275, 245, 1, 0, 0, 0, 2276, 2278, 3, 248, 124, 0, 2277, 2276, 1, 0, 0, 0, 2278, 2281, 1, 0, 0, 0, 2279, 2277, 1, 0, 0, 0, 2279, 2280, 1, 0, 0, 0, 2280, 247, 1, 0, 0, 0, 2281, 2279, 1, 0, 0, 0, 2282, 2300, 3, 100, 50, 0, 2283, 2284, 5, 296, 0, 0, 2284, 2285, 3, 32, 16, 0, 2285, 2286, 6, 124, -1, 0, 2286, 2300, 1, 0, 0, 0, 2287, 2300, 3, 258, 129, 0, 2288, 2289, 5, 297, 0, 0, 2289, 2290, 3, 32, 16, 0, 2290, 2291, 6, 124, -1, 0, 2291, 2300, 1, 0, 0, 0, 2292, 2293, 5, 298, 0, 0, 2293, 2300, 6, 124, -1, 0, 2294, 2295, 5, 299, 0, 0, 2295, 2300, 6, 124, -1, 0, 2296, 2300, 3, 252, 126, 0, 2297, 2300, 3, 256, 128, 0, 2298, 2300, 3, 250, 125, 0, 2299, 2282, 1, 0, 0, 0, 2299, 2283, 1, 0, 0, 0, 2299, 2287, 1, 0, 0, 0, 2299, 2288, 1, 0, 0, 0, 2299, 2292, 1, 0, 0, 0, 2299, 2294, 1, 0, 0, 0, 2299, 2296, 1, 0, 0, 0, 2299, 2297, 1, 0, 0, 0, 2299, 2298, 1, 0, 0, 0, 2300, 249, 1, 0, 0, 0, 2301, 2302, 5, 300, 0, 0, 2302, 2400, 3, 112, 56, 0, 2303, 2304, 5, 300, 0, 0, 2304, 2305, 5, 157, 0, 0, 2305, 2400, 3, 112, 56, 0, 2306, 2400, 3, 276, 138, 0, 2307, 2400, 3, 152, 76, 0, 2308, 2400, 3, 88, 44, 0, 2309, 2400, 3, 26, 13, 0, 2310, 2400, 3, 254, 127, 0, 2311, 2400, 3, 40, 20, 0, 2312, 2313, 5, 301, 0, 0, 2313, 2314, 5, 42, 0, 0, 2314, 2315, 3, 32, 16, 0, 2315, 2316, 5, 43, 0, 0, 2316, 2400, 1, 0, 0, 0, 2317, 2318, 5, 301, 0, 0, 2318, 2319, 5, 42, 0, 0, 2319, 2320, 3, 32, 16, 0, 2320, 2321, 5, 43, 0, 0, 2321, 2322, 5, 34, 0, 0, 2322, 2323, 3, 0, 0, 0, 2323, 2400, 1, 0, 0, 0, 2324, 2325, 5, 303, 0, 0, 2325, 2326, 3, 32, 16, 0, 2326, 2327, 5, 75, 0, 0, 2327, 2328, 3, 32, 16, 0, 2328, 2400, 1, 0, 0, 0, 2329, 2330, 5, 302, 0, 0, 2330, 2331, 3, 124, 62, 0, 2331, 2332, 5, 176, 0, 0, 2332, 2333, 3, 242, 121, 0, 2333, 2400, 1, 0, 0, 0, 2334, 2335, 5, 302, 0, 0, 2335, 2336, 5, 226, 0, 0, 2336, 2337, 3, 170, 85, 0, 2337, 2338, 3, 138, 69, 0, 2338, 2339, 3, 124, 62, 0, 2339, 2340, 5, 176, 0, 0, 2340, 2341, 3, 242, 121, 0, 2341, 2342, 3, 194, 97, 0, 2342, 2343, 3, 112, 56, 0, 2343, 2400, 1, 0, 0, 0, 2344, 2345, 5, 255, 0, 0, 2345, 2346, 5, 196, 0, 0, 2346, 2347, 5, 42, 0, 0, 2347, 2348, 3, 32, 16, 0, 2348, 2352, 5, 43, 0, 0, 2349, 2351, 3, 322, 161, 0, 2350, 2349, 1, 0, 0, 0, 2351, 2354, 1, 0, 0, 0, 2352, 2350, 1, 0, 0, 0, 2352, 2353, 1, 0, 0, 0, 2353, 2400, 1, 0, 0, 0, 2354, 2352, 1, 0, 0, 0, 2355, 2356, 5, 255, 0, 0, 2356, 2357, 5, 196, 0, 0, 2357, 2361, 3, 2, 1, 0, 2358, 2360, 3, 322, 161, 0, 2359, 2358, 1, 0, 0, 0, 2360, 2363, 1, 0, 0, 0, 2361, 2359, 1, 0, 0, 0, 2361, 2362, 1, 0, 0, 0, 2362, 2400, 1, 0, 0, 0, 2363, 2361, 1, 0, 0, 0, 2364, 2365, 5, 255, 0, 0, 2365, 2366, 5, 256, 0, 0, 2366, 2367, 5, 42, 0, 0, 2367, 2368, 3, 32, 16, 0, 2368, 2369, 5, 43, 0, 0, 2369, 2370, 5, 28, 0, 0, 2370, 2374, 3, 124, 62, 0, 2371, 2373, 3, 322, 161, 0, 2372, 2371, 1, 0, 0, 0, 2373, 2376, 1, 0, 0, 0, 2374, 2372, 1, 0, 0, 0, 2374, 2375, 1, 0, 0, 0, 2375, 2400, 1, 0, 0, 0, 2376, 2374, 1, 0, 0, 0, 2377, 2378, 5, 255, 0, 0, 2378, 2379, 5, 256, 0, 0, 2379, 2380, 3, 2, 1, 0, 2380, 2381, 5, 28, 0, 0, 2381, 2385, 3, 124, 62, 0, 2382, 2384, 3, 322, 161, 0, 2383, 2382, 1, 0, 0, 0, 2384, 2387, 1, 0, 0, 0, 2385, 2383, 1, 0, 0, 0, 2385, 2386, 1, 0, 0, 0, 2386, 2400, 1, 0, 0, 0, 2387, 2385, 1, 0, 0, 0, 2388, 2389, 5, 255, 0, 0, 2389, 2390, 5, 42, 0, 0, 2390, 2391, 3, 32, 16, 0, 2391, 2392, 5, 43, 0, 0, 2392, 2396, 3, 206, 103, 0, 2393, 2395, 3, 322, 161, 0, 2394, 2393, 1, 0, 0, 0, 2395, 2398, 1, 0, 0, 0, 2396, 2394, 1, 0, 0, 0, 2396, 2397, 1, 0, 0, 0, 2397, 2400, 1, 0, 0, 0, 2398, 2396, 1, 0, 0, 0, 2399, 2301, 1, 0, 0, 0, 2399, 2303, 1, 0, 0, 0, 2399, 2306, 1, 0, 0, 0, 2399, 2307, 1, 0, 0, 0, 2399, 2308, 1, 0, 0, 0, 2399, 2309, 1, 0, 0, 0, 2399, 2310, 1, 0, 0, 0, 2399, 2311, 1, 0, 0, 0, 2399, 2312, 1, 0, 0, 0, 2399, 2317, 1, 0, 0, 0, 2399, 2324, 1, 0, 0, 0, 2399, 2329, 1, 0, 0, 0, 2399, 2334, 1, 0, 0, 0, 2399, 2344, 1, 0, 0, 0, 2399, 2355, 1, 0, 0, 0, 2399, 2364, 1, 0, 0, 0, 2399, 2377, 1, 0, 0, 0, 2399, 2388, 1, 0, 0, 0, 2400, 251, 1, 0, 0, 0, 2401, 2402, 3, 0, 0, 0, 2402, 2403, 5, 75, 0, 0, 2403, 2404, 6, 126, -1, 0, 2404, 253, 1, 0, 0, 0, 2405, 2408, 3, 44, 22, 0, 2406, 2408, 3, 46, 23, 0, 2407, 2405, 1, 0, 0, 0, 2407, 2406, 1, 0, 0, 0, 2408, 255, 1, 0, 0, 0, 2409, 2410, 5, 17, 0, 0, 2410, 2411, 3, 246, 123, 0, 2411, 2412, 5, 18, 0, 0, 2412, 257, 1, 0, 0, 0, 2413, 2414, 3, 262, 131, 0, 2414, 2415, 3, 260, 130, 0, 2415, 259, 1, 0, 0, 0, 2416, 2418, 3, 264, 132, 0, 2417, 2416, 1, 0, 0, 0, 2418, 2419, 1, 0, 0, 0, 2419, 2417, 1, 0, 0, 0, 2419, 2420, 1, 0, 0, 0, 2420, 261, 1, 0, 0, 0, 2421, 2422, 5, 158, 0, 0, 2422, 2434, 3, 256, 128, 0, 2423, 2424, 5, 158, 0, 0, 2424, 2425, 3, 0, 0, 0, 2425, 2426, 5, 159, 0, 0, 2426, 2427, 3, 0, 0, 0, 2427, 2434, 1, 0, 0, 0, 2428, 2429, 5, 158, 0, 0, 2429, 2430, 3, 32, 16, 0, 2430, 2431, 5, 159, 0, 0, 2431, 2432, 3, 32, 16, 0, 2432, 2434, 1, 0, 0, 0, 2433, 2421, 1, 0, 0, 0, 2433, 2423, 1, 0, 0, 0, 2433, 2428, 1, 0, 0, 0, 2434, 263, 1, 0, 0, 0, 2435, 2436, 3, 268, 134, 0, 2436, 2437, 3, 274, 137, 0, 2437, 2448, 1, 0, 0, 0, 2438, 2439, 3, 266, 133, 0, 2439, 2440, 3, 274, 137, 0, 2440, 2448, 1, 0, 0, 0, 2441, 2442, 3, 270, 135, 0, 2442, 2443, 3, 274, 137, 0, 2443, 2448, 1, 0, 0, 0, 2444, 2445, 3, 272, 136, 0, 2445, 2446, 3, 274, 137, 0, 2446, 2448, 1, 0, 0, 0, 2447, 2435, 1, 0, 0, 0, 2447, 2438, 1, 0, 0, 0, 2447, 2441, 1, 0, 0, 0, 2447, 2444, 1, 0, 0, 0, 2448, 265, 1, 0, 0, 0, 2449, 2450, 5, 160, 0, 0, 2450, 2456, 3, 256, 128, 0, 2451, 2452, 5, 160, 0, 0, 2452, 2456, 3, 0, 0, 0, 2453, 2454, 5, 160, 0, 0, 2454, 2456, 3, 32, 16, 0, 2455, 2449, 1, 0, 0, 0, 2455, 2451, 1, 0, 0, 0, 2455, 2453, 1, 0, 0, 0, 2456, 267, 1, 0, 0, 0, 2457, 2458, 5, 161, 0, 0, 2458, 2459, 3, 124, 62, 0, 2459, 269, 1, 0, 0, 0, 2460, 2461, 5, 162, 0, 0, 2461, 271, 1, 0, 0, 0, 2462, 2463, 5, 163, 0, 0, 2463, 273, 1, 0, 0, 0, 2464, 2476, 3, 256, 128, 0, 2465, 2466, 5, 164, 0, 0, 2466, 2467, 3, 0, 0, 0, 2467, 2468, 5, 159, 0, 0, 2468, 2469, 3, 0, 0, 0, 2469, 2476, 1, 0, 0, 0, 2470, 2471, 5, 164, 0, 0, 2471, 2472, 3, 32, 16, 0, 2472, 2473, 5, 159, 0, 0, 2473, 2474, 3, 32, 16, 0, 2474, 2476, 1, 0, 0, 0, 2475, 2464, 1, 0, 0, 0, 2475, 2465, 1, 0, 0, 0, 2475, 2470, 1, 0, 0, 0, 2476, 275, 1, 0, 0, 0, 2477, 2478, 3, 278, 139, 0, 2478, 2479, 3, 282, 141, 0, 2479, 277, 1, 0, 0, 0, 2480, 2481, 5, 165, 0, 0, 2481, 2482, 3, 280, 140, 0, 2482, 2483, 3, 0, 0, 0, 2483, 2484, 5, 36, 0, 0, 2484, 2488, 1, 0, 0, 0, 2485, 2486, 5, 165, 0, 0, 2486, 2488, 3, 280, 140, 0, 2487, 2480, 1, 0, 0, 0, 2487, 2485, 1, 0, 0, 0, 2488, 279, 1, 0, 0, 0, 2489, 2493, 1, 0, 0, 0, 2490, 2493, 5, 166, 0, 0, 2491, 2493, 5, 2, 0, 0, 2492, 2489, 1, 0, 0, 0, 2492, 2490, 1, 0, 0, 0, 2492, 2491, 1, 0, 0, 0, 2493, 281, 1, 0, 0, 0, 2494, 2495, 5, 17, 0, 0, 2495, 2496, 3, 284, 142, 0, 2496, 2497, 5, 18, 0, 0, 2497, 2504, 1, 0, 0, 0, 2498, 2500, 3, 288, 144, 0, 2499, 2498, 1, 0, 0, 0, 2500, 2501, 1, 0, 0, 0, 2501, 2499, 1, 0, 0, 0, 2501, 2502, 1, 0, 0, 0, 2502, 2504, 1, 0, 0, 0, 2503, 2494, 1, 0, 0, 0, 2503, 2499, 1, 0, 0, 0, 2504, 283, 1, 0, 0, 0, 2505, 2506, 3, 288, 144, 0, 2506, 2507, 5, 28, 0, 0, 2507, 2509, 1, 0, 0, 0, 2508, 2505, 1, 0, 0, 0, 2509, 2512, 1, 0, 0, 0, 2510, 2508, 1, 0, 0, 0, 2510, 2511, 1, 0, 0, 0, 2511, 2513, 1, 0, 0, 0, 2512, 2510, 1, 0, 0, 0, 2513, 2514, 3, 288, 144, 0, 2514, 285, 1, 0, 0, 0, 2515, 2521, 1, 0, 0, 0, 2516, 2517, 5, 42, 0, 0, 2517, 2518, 3, 32, 16, 0, 2518, 2519, 5, 43, 0, 0, 2519, 2521, 1, 0, 0, 0, 2520, 2515, 1, 0, 0, 0, 2520, 2516, 1, 0, 0, 0, 2521, 287, 1, 0, 0, 0, 2522, 2523, 5, 181, 0, 0, 2523, 2524, 5, 262, 0, 0, 2524, 2525, 5, 30, 0, 0, 2525, 2526, 3, 6, 3, 0, 2526, 2527, 5, 31, 0, 0, 2527, 2589, 1, 0, 0, 0, 2528, 2529, 5, 260, 0, 0, 2529, 2530, 5, 30, 0, 0, 2530, 2531, 3, 0, 0, 0, 2531, 2532, 5, 31, 0, 0, 2532, 2589, 1, 0, 0, 0, 2533, 2534, 5, 260, 0, 0, 2534, 2589, 3, 0, 0, 0, 2535, 2536, 5, 84, 0, 0, 2536, 2537, 5, 30, 0, 0, 2537, 2538, 3, 292, 146, 0, 2538, 2539, 5, 31, 0, 0, 2539, 2589, 1, 0, 0, 0, 2540, 2541, 5, 188, 0, 0, 2541, 2542, 5, 30, 0, 0, 2542, 2543, 3, 36, 18, 0, 2543, 2544, 5, 31, 0, 0, 2544, 2545, 3, 286, 143, 0, 2545, 2589, 1, 0, 0, 0, 2546, 2547, 5, 189, 0, 0, 2547, 2548, 5, 30, 0, 0, 2548, 2549, 3, 36, 18, 0, 2549, 2550, 5, 31, 0, 0, 2550, 2551, 3, 286, 143, 0, 2551, 2589, 1, 0, 0, 0, 2552, 2553, 5, 187, 0, 0, 2553, 2554, 5, 30, 0, 0, 2554, 2555, 3, 34, 17, 0, 2555, 2556, 5, 31, 0, 0, 2556, 2557, 3, 286, 143, 0, 2557, 2589, 1, 0, 0, 0, 2558, 2559, 5, 186, 0, 0, 2559, 2560, 5, 30, 0, 0, 2560, 2561, 3, 32, 16, 0, 2561, 2562, 5, 31, 0, 0, 2562, 2563, 3, 286, 143, 0, 2563, 2589, 1, 0, 0, 0, 2564, 2565, 5, 185, 0, 0, 2565, 2566, 5, 30, 0, 0, 2566, 2567, 3, 32, 16, 0, 2567, 2568, 5, 31, 0, 0, 2568, 2569, 3, 286, 143, 0, 2569, 2589, 1, 0, 0, 0, 2570, 2571, 5, 184, 0, 0, 2571, 2572, 5, 30, 0, 0, 2572, 2573, 3, 32, 16, 0, 2573, 2574, 5, 31, 0, 0, 2574, 2575, 3, 286, 143, 0, 2575, 2589, 1, 0, 0, 0, 2576, 2577, 5, 188, 0, 0, 2577, 2589, 3, 286, 143, 0, 2578, 2579, 5, 189, 0, 0, 2579, 2589, 3, 286, 143, 0, 2580, 2581, 5, 187, 0, 0, 2581, 2589, 3, 286, 143, 0, 2582, 2583, 5, 186, 0, 0, 2583, 2589, 3, 286, 143, 0, 2584, 2585, 5, 185, 0, 0, 2585, 2589, 3, 286, 143, 0, 2586, 2587, 5, 184, 0, 0, 2587, 2589, 3, 286, 143, 0, 2588, 2522, 1, 0, 0, 0, 2588, 2528, 1, 0, 0, 0, 2588, 2533, 1, 0, 0, 0, 2588, 2535, 1, 0, 0, 0, 2588, 2540, 1, 0, 0, 0, 2588, 2546, 1, 0, 0, 0, 2588, 2552, 1, 0, 0, 0, 2588, 2558, 1, 0, 0, 0, 2588, 2564, 1, 0, 0, 0, 2588, 2570, 1, 0, 0, 0, 2588, 2576, 1, 0, 0, 0, 2588, 2578, 1, 0, 0, 0, 2588, 2580, 1, 0, 0, 0, 2588, 2582, 1, 0, 0, 0, 2588, 2584, 1, 0, 0, 0, 2588, 2586, 1, 0, 0, 0, 2589, 289, 1, 0, 0, 0, 2590, 2591, 5, 188, 0, 0, 2591, 2592, 5, 30, 0, 0, 2592, 2593, 3, 36, 18, 0, 2593, 2594, 5, 31, 0, 0, 2594, 2666, 1, 0, 0, 0, 2595, 2596, 5, 189, 0, 0, 2596, 2597, 5, 30, 0, 0, 2597, 2598, 3, 36, 18, 0, 2598, 2599, 5, 31, 0, 0, 2599, 2666, 1, 0, 0, 0, 2600, 2601, 5, 188, 0, 0, 2601, 2602, 5, 30, 0, 0, 2602, 2603, 3, 32, 16, 0, 2603, 2604, 5, 31, 0, 0, 2604, 2666, 1, 0, 0, 0, 2605, 2606, 5, 189, 0, 0, 2606, 2607, 5, 30, 0, 0, 2607, 2608, 3, 34, 17, 0, 2608, 2609, 5, 31, 0, 0, 2609, 2666, 1, 0, 0, 0, 2610, 2611, 5, 187, 0, 0, 2611, 2612, 5, 30, 0, 0, 2612, 2613, 3, 34, 17, 0, 2613, 2614, 5, 31, 0, 0, 2614, 2666, 1, 0, 0, 0, 2615, 2616, 5, 186, 0, 0, 2616, 2617, 5, 30, 0, 0, 2617, 2618, 3, 32, 16, 0, 2618, 2619, 5, 31, 0, 0, 2619, 2666, 1, 0, 0, 0, 2620, 2621, 5, 185, 0, 0, 2621, 2622, 5, 30, 0, 0, 2622, 2623, 3, 32, 16, 0, 2623, 2624, 5, 31, 0, 0, 2624, 2666, 1, 0, 0, 0, 2625, 2626, 5, 184, 0, 0, 2626, 2627, 5, 30, 0, 0, 2627, 2628, 3, 32, 16, 0, 2628, 2629, 5, 31, 0, 0, 2629, 2666, 1, 0, 0, 0, 2630, 2631, 5, 193, 0, 0, 2631, 2632, 5, 30, 0, 0, 2632, 2633, 3, 34, 17, 0, 2633, 2634, 5, 31, 0, 0, 2634, 2666, 1, 0, 0, 0, 2635, 2636, 5, 192, 0, 0, 2636, 2637, 5, 30, 0, 0, 2637, 2638, 3, 32, 16, 0, 2638, 2639, 5, 31, 0, 0, 2639, 2666, 1, 0, 0, 0, 2640, 2641, 5, 191, 0, 0, 2641, 2642, 5, 30, 0, 0, 2642, 2643, 3, 32, 16, 0, 2643, 2644, 5, 31, 0, 0, 2644, 2666, 1, 0, 0, 0, 2645, 2646, 5, 190, 0, 0, 2646, 2647, 5, 30, 0, 0, 2647, 2648, 3, 32, 16, 0, 2648, 2649, 5, 31, 0, 0, 2649, 2666, 1, 0, 0, 0, 2650, 2651, 5, 181, 0, 0, 2651, 2652, 5, 30, 0, 0, 2652, 2653, 3, 32, 16, 0, 2653, 2654, 5, 31, 0, 0, 2654, 2666, 1, 0, 0, 0, 2655, 2656, 5, 183, 0, 0, 2656, 2657, 5, 30, 0, 0, 2657, 2658, 3, 162, 81, 0, 2658, 2659, 5, 31, 0, 0, 2659, 2666, 1, 0, 0, 0, 2660, 2661, 5, 84, 0, 0, 2661, 2662, 5, 30, 0, 0, 2662, 2663, 3, 292, 146, 0, 2663, 2664, 5, 31, 0, 0, 2664, 2666, 1, 0, 0, 0, 2665, 2590, 1, 0, 0, 0, 2665, 2595, 1, 0, 0, 0, 2665, 2600, 1, 0, 0, 0, 2665, 2605, 1, 0, 0, 0, 2665, 2610, 1, 0, 0, 0, 2665, 2615, 1, 0, 0, 0, 2665, 2620, 1, 0, 0, 0, 2665, 2625, 1, 0, 0, 0, 2665, 2630, 1, 0, 0, 0, 2665, 2635, 1, 0, 0, 0, 2665, 2640, 1, 0, 0, 0, 2665, 2645, 1, 0, 0, 0, 2665, 2650, 1, 0, 0, 0, 2665, 2655, 1, 0, 0, 0, 2665, 2660, 1, 0, 0, 0, 2666, 291, 1, 0, 0, 0, 2667, 2668, 3, 294, 147, 0, 2668, 2669, 6, 146, -1, 0, 2669, 2671, 1, 0, 0, 0, 2670, 2667, 1, 0, 0, 0, 2671, 2674, 1, 0, 0, 0, 2672, 2670, 1, 0, 0, 0, 2672, 2673, 1, 0, 0, 0, 2673, 293, 1, 0, 0, 0, 2674, 2672, 1, 0, 0, 0, 2675, 2676, 7, 12, 0, 0, 2676, 295, 1, 0, 0, 0, 2677, 2681, 3, 290, 145, 0, 2678, 2681, 3, 6, 3, 0, 2679, 2681, 5, 179, 0, 0, 2680, 2677, 1, 0, 0, 0, 2680, 2678, 1, 0, 0, 0, 2680, 2679, 1, 0, 0, 0, 2681, 297, 1, 0, 0, 0, 2682, 2831, 3, 290, 145, 0, 2683, 2684, 5, 182, 0, 0, 2684, 2685, 5, 30, 0, 0, 2685, 2686, 5, 179, 0, 0, 2686, 2831, 5, 31, 0, 0, 2687, 2688, 5, 182, 0, 0, 2688, 2689, 5, 30, 0, 0, 2689, 2690, 5, 264, 0, 0, 2690, 2831, 5, 31, 0, 0, 2691, 2692, 5, 196, 0, 0, 2692, 2693, 5, 30, 0, 0, 2693, 2694, 5, 39, 0, 0, 2694, 2695, 5, 264, 0, 0, 2695, 2831, 5, 31, 0, 0, 2696, 2697, 5, 196, 0, 0, 2697, 2698, 5, 30, 0, 0, 2698, 2699, 3, 116, 58, 0, 2699, 2700, 5, 31, 0, 0, 2700, 2831, 1, 0, 0, 0, 2701, 2702, 5, 196, 0, 0, 2702, 2703, 5, 30, 0, 0, 2703, 2704, 5, 179, 0, 0, 2704, 2831, 5, 31, 0, 0, 2705, 2706, 5, 197, 0, 0, 2706, 2707, 5, 30, 0, 0, 2707, 2708, 3, 298, 149, 0, 2708, 2709, 5, 31, 0, 0, 2709, 2831, 1, 0, 0, 0, 2710, 2711, 5, 188, 0, 0, 2711, 2712, 5, 42, 0, 0, 2712, 2713, 3, 32, 16, 0, 2713, 2714, 5, 43, 0, 0, 2714, 2715, 5, 30, 0, 0, 2715, 2716, 3, 300, 150, 0, 2716, 2717, 5, 31, 0, 0, 2717, 2831, 1, 0, 0, 0, 2718, 2719, 5, 189, 0, 0, 2719, 2720, 5, 42, 0, 0, 2720, 2721, 3, 32, 16, 0, 2721, 2722, 5, 43, 0, 0, 2722, 2723, 5, 30, 0, 0, 2723, 2724, 3, 302, 151, 0, 2724, 2725, 5, 31, 0, 0, 2725, 2831, 1, 0, 0, 0, 2726, 2727, 5, 187, 0, 0, 2727, 2728, 5, 42, 0, 0, 2728, 2729, 3, 32, 16, 0, 2729, 2730, 5, 43, 0, 0, 2730, 2731, 5, 30, 0, 0, 2731, 2732, 3, 304, 152, 0, 2732, 2733, 5, 31, 0, 0, 2733, 2831, 1, 0, 0, 0, 2734, 2735, 5, 186, 0, 0, 2735, 2736, 5, 42, 0, 0, 2736, 2737, 3, 32, 16, 0, 2737, 2738, 5, 43, 0, 0, 2738, 2739, 5, 30, 0, 0, 2739, 2740, 3, 306, 153, 0, 2740, 2741, 5, 31, 0, 0, 2741, 2831, 1, 0, 0, 0, 2742, 2743, 5, 185, 0, 0, 2743, 2744, 5, 42, 0, 0, 2744, 2745, 3, 32, 16, 0, 2745, 2746, 5, 43, 0, 0, 2746, 2747, 5, 30, 0, 0, 2747, 2748, 3, 308, 154, 0, 2748, 2749, 5, 31, 0, 0, 2749, 2831, 1, 0, 0, 0, 2750, 2751, 5, 184, 0, 0, 2751, 2752, 5, 42, 0, 0, 2752, 2753, 3, 32, 16, 0, 2753, 2754, 5, 43, 0, 0, 2754, 2755, 5, 30, 0, 0, 2755, 2756, 3, 310, 155, 0, 2756, 2757, 5, 31, 0, 0, 2757, 2831, 1, 0, 0, 0, 2758, 2759, 5, 193, 0, 0, 2759, 2760, 5, 42, 0, 0, 2760, 2761, 3, 32, 16, 0, 2761, 2762, 5, 43, 0, 0, 2762, 2763, 5, 30, 0, 0, 2763, 2764, 3, 304, 152, 0, 2764, 2765, 5, 31, 0, 0, 2765, 2831, 1, 0, 0, 0, 2766, 2767, 5, 192, 0, 0, 2767, 2768, 5, 42, 0, 0, 2768, 2769, 3, 32, 16, 0, 2769, 2770, 5, 43, 0, 0, 2770, 2771, 5, 30, 0, 0, 2771, 2772, 3, 306, 153, 0, 2772, 2773, 5, 31, 0, 0, 2773, 2831, 1, 0, 0, 0, 2774, 2775, 5, 191, 0, 0, 2775, 2776, 5, 42, 0, 0, 2776, 2777, 3, 32, 16, 0, 2777, 2778, 5, 43, 0, 0, 2778, 2779, 5, 30, 0, 0, 2779, 2780, 3, 308, 154, 0, 2780, 2781, 5, 31, 0, 0, 2781, 2831, 1, 0, 0, 0, 2782, 2783, 5, 190, 0, 0, 2783, 2784, 5, 42, 0, 0, 2784, 2785, 3, 32, 16, 0, 2785, 2786, 5, 43, 0, 0, 2786, 2787, 5, 30, 0, 0, 2787, 2788, 3, 310, 155, 0, 2788, 2789, 5, 31, 0, 0, 2789, 2831, 1, 0, 0, 0, 2790, 2791, 5, 181, 0, 0, 2791, 2792, 5, 42, 0, 0, 2792, 2793, 3, 32, 16, 0, 2793, 2794, 5, 43, 0, 0, 2794, 2795, 5, 30, 0, 0, 2795, 2796, 3, 308, 154, 0, 2796, 2797, 5, 31, 0, 0, 2797, 2831, 1, 0, 0, 0, 2798, 2799, 5, 183, 0, 0, 2799, 2800, 5, 42, 0, 0, 2800, 2801, 3, 32, 16, 0, 2801, 2802, 5, 43, 0, 0, 2802, 2803, 5, 30, 0, 0, 2803, 2804, 3, 312, 156, 0, 2804, 2805, 5, 31, 0, 0, 2805, 2831, 1, 0, 0, 0, 2806, 2807, 5, 182, 0, 0, 2807, 2808, 5, 42, 0, 0, 2808, 2809, 3, 32, 16, 0, 2809, 2810, 5, 43, 0, 0, 2810, 2811, 5, 30, 0, 0, 2811, 2812, 3, 314, 157, 0, 2812, 2813, 5, 31, 0, 0, 2813, 2831, 1, 0, 0, 0, 2814, 2815, 5, 196, 0, 0, 2815, 2816, 5, 42, 0, 0, 2816, 2817, 3, 32, 16, 0, 2817, 2818, 5, 43, 0, 0, 2818, 2819, 5, 30, 0, 0, 2819, 2820, 3, 316, 158, 0, 2820, 2821, 5, 31, 0, 0, 2821, 2831, 1, 0, 0, 0, 2822, 2823, 5, 197, 0, 0, 2823, 2824, 5, 42, 0, 0, 2824, 2825, 3, 32, 16, 0, 2825, 2826, 5, 43, 0, 0, 2826, 2827, 5, 30, 0, 0, 2827, 2828, 3, 320, 160, 0, 2828, 2829, 5, 31, 0, 0, 2829, 2831, 1, 0, 0, 0, 2830, 2682, 1, 0, 0, 0, 2830, 2683, 1, 0, 0, 0, 2830, 2687, 1, 0, 0, 0, 2830, 2691, 1, 0, 0, 0, 2830, 2696, 1, 0, 0, 0, 2830, 2701, 1, 0, 0, 0, 2830, 2705, 1, 0, 0, 0, 2830, 2710, 1, 0, 0, 0, 2830, 2718, 1, 0, 0, 0, 2830, 2726, 1, 0, 0, 0, 2830, 2734, 1, 0, 0, 0, 2830, 2742, 1, 0, 0, 0, 2830, 2750, 1, 0, 0, 0, 2830, 2758, 1, 0, 0, 0, 2830, 2766, 1, 0, 0, 0, 2830, 2774, 1, 0, 0, 0, 2830, 2782, 1, 0, 0, 0, 2830, 2790, 1, 0, 0, 0, 2830, 2798, 1, 0, 0, 0, 2830, 2806, 1, 0, 0, 0, 2830, 2814, 1, 0, 0, 0, 2830, 2822, 1, 0, 0, 0, 2831, 299, 1, 0, 0, 0, 2832, 2835, 3, 36, 18, 0, 2833, 2835, 3, 32, 16, 0, 2834, 2832, 1, 0, 0, 0, 2834, 2833, 1, 0, 0, 0, 2835, 2838, 1, 0, 0, 0, 2836, 2834, 1, 0, 0, 0, 2836, 2837, 1, 0, 0, 0, 2837, 301, 1, 0, 0, 0, 2838, 2836, 1, 0, 0, 0, 2839, 2842, 3, 36, 18, 0, 2840, 2842, 3, 34, 17, 0, 2841, 2839, 1, 0, 0, 0, 2841, 2840, 1, 0, 0, 0, 2842, 2845, 1, 0, 0, 0, 2843, 2841, 1, 0, 0, 0, 2843, 2844, 1, 0, 0, 0, 2844, 303, 1, 0, 0, 0, 2845, 2843, 1, 0, 0, 0, 2846, 2848, 3, 34, 17, 0, 2847, 2846, 1, 0, 0, 0, 2848, 2851, 1, 0, 0, 0, 2849, 2847, 1, 0, 0, 0, 2849, 2850, 1, 0, 0, 0, 2850, 305, 1, 0, 0, 0, 2851, 2849, 1, 0, 0, 0, 2852, 2854, 3, 32, 16, 0, 2853, 2852, 1, 0, 0, 0, 2854, 2857, 1, 0, 0, 0, 2855, 2853, 1, 0, 0, 0, 2855, 2856, 1, 0, 0, 0, 2856, 307, 1, 0, 0, 0, 2857, 2855, 1, 0, 0, 0, 2858, 2860, 3, 32, 16, 0, 2859, 2858, 1, 0, 0, 0, 2860, 2863, 1, 0, 0, 0, 2861, 2859, 1, 0, 0, 0, 2861, 2862, 1, 0, 0, 0, 2862, 309, 1, 0, 0, 0, 2863, 2861, 1, 0, 0, 0, 2864, 2866, 3, 32, 16, 0, 2865, 2864, 1, 0, 0, 0, 2866, 2869, 1, 0, 0, 0, 2867, 2865, 1, 0, 0, 0, 2867, 2868, 1, 0, 0, 0, 2868, 311, 1, 0, 0, 0, 2869, 2867, 1, 0, 0, 0, 2870, 2872, 3, 162, 81, 0, 2871, 2870, 1, 0, 0, 0, 2872, 2875, 1, 0, 0, 0, 2873, 2871, 1, 0, 0, 0, 2873, 2874, 1, 0, 0, 0, 2874, 313, 1, 0, 0, 0, 2875, 2873, 1, 0, 0, 0, 2876, 2878, 7, 13, 0, 0, 2877, 2876, 1, 0, 0, 0, 2878, 2881, 1, 0, 0, 0, 2879, 2877, 1, 0, 0, 0, 2879, 2880, 1, 0, 0, 0, 2880, 315, 1, 0, 0, 0, 2881, 2879, 1, 0, 0, 0, 2882, 2884, 3, 318, 159, 0, 2883, 2882, 1, 0, 0, 0, 2884, 2887, 1, 0, 0, 0, 2885, 2883, 1, 0, 0, 0, 2885, 2886, 1, 0, 0, 0, 2886, 317, 1, 0, 0, 0, 2887, 2885, 1, 0, 0, 0, 2888, 2893, 5, 179, 0, 0, 2889, 2890, 5, 39, 0, 0, 2890, 2893, 5, 264, 0, 0, 2891, 2893, 3, 116, 58, 0, 2892, 2888, 1, 0, 0, 0, 2892, 2889, 1, 0, 0, 0, 2892, 2891, 1, 0, 0, 0, 2893, 319, 1, 0, 0, 0, 2894, 2896, 3, 298, 149, 0, 2895, 2894, 1, 0, 0, 0, 2896, 2899, 1, 0, 0, 0, 2897, 2895, 1, 0, 0, 0, 2897, 2898, 1, 0, 0, 0, 2898, 321, 1, 0, 0, 0, 2899, 2897, 1, 0, 0, 0, 2900, 2904, 3, 44, 22, 0, 2901, 2904, 3, 46, 23, 0, 2902, 2904, 3, 2, 1, 0, 2903, 2900, 1, 0, 0, 0, 2903, 2901, 1, 0, 0, 0, 2903, 2902, 1, 0, 0, 0, 2904, 323, 1, 0, 0, 0, 2905, 2906, 7, 14, 0, 0, 2906, 2907, 5, 36, 0, 0, 2907, 2908, 5, 30, 0, 0, 2908, 2909, 3, 292, 146, 0, 2909, 2910, 5, 31, 0, 0, 2910, 2931, 1, 0, 0, 0, 2911, 2912, 5, 169, 0, 0, 2912, 2913, 3, 38, 19, 0, 2913, 2914, 5, 75, 0, 0, 2914, 2915, 3, 38, 19, 0, 2915, 2916, 5, 75, 0, 0, 2916, 2917, 3, 38, 19, 0, 2917, 2918, 5, 75, 0, 0, 2918, 2919, 3, 38, 19, 0, 2919, 2931, 1, 0, 0, 0, 2920, 2921, 5, 170, 0, 0, 2921, 2931, 3, 6, 3, 0, 2922, 2923, 5, 170, 0, 0, 2923, 2924, 5, 36, 0, 0, 2924, 2925, 5, 30, 0, 0, 2925, 2926, 3, 292, 146, 0, 2926, 2927, 5, 31, 0, 0, 2927, 2931, 1, 0, 0, 0, 2928, 2931, 3, 322, 161, 0, 2929, 2931, 3, 40, 20, 0, 2930, 2905, 1, 0, 0, 0, 2930, 2911, 1, 0, 0, 0, 2930, 2920, 1, 0, 0, 0, 2930, 2922, 1, 0, 0, 0, 2930, 2928, 1, 0, 0, 0, 2930, 2929, 1, 0, 0, 0, 2931, 325, 1, 0, 0, 0, 2932, 2933, 5, 25, 0, 0, 2933, 2934, 5, 40, 0, 0, 2934, 2935, 3, 98, 49, 0, 2935, 2936, 3, 2, 1, 0, 2936, 2945, 1, 0, 0, 0, 2937, 2938, 5, 25, 0, 0, 2938, 2939, 5, 40, 0, 0, 2939, 2940, 3, 98, 49, 0, 2940, 2941, 3, 2, 1, 0, 2941, 2942, 5, 34, 0, 0, 2942, 2943, 3, 2, 1, 0, 2943, 2945, 1, 0, 0, 0, 2944, 2932, 1, 0, 0, 0, 2944, 2937, 1, 0, 0, 0, 2945, 327, 1, 0, 0, 0, 2946, 2948, 3, 330, 165, 0, 2947, 2946, 1, 0, 0, 0, 2948, 2951, 1, 0, 0, 0, 2949, 2947, 1, 0, 0, 0, 2949, 2950, 1, 0, 0, 0, 2950, 329, 1, 0, 0, 0, 2951, 2949, 1, 0, 0, 0, 2952, 2953, 5, 180, 0, 0, 2953, 2954, 5, 36, 0, 0, 2954, 2955, 5, 30, 0, 0, 2955, 2956, 3, 292, 146, 0, 2956, 2957, 5, 31, 0, 0, 2957, 2967, 1, 0, 0, 0, 2958, 2967, 3, 324, 162, 0, 2959, 2960, 5, 171, 0, 0, 2960, 2961, 5, 36, 0, 0, 2961, 2962, 5, 30, 0, 0, 2962, 2963, 3, 292, 146, 0, 2963, 2964, 5, 31, 0, 0, 2964, 2967, 1, 0, 0, 0, 2965, 2967, 5, 55, 0, 0, 2966, 2952, 1, 0, 0, 0, 2966, 2958, 1, 0, 0, 0, 2966, 2959, 1, 0, 0, 0, 2966, 2965, 1, 0, 0, 0, 2967, 331, 1, 0, 0, 0, 2968, 2969, 5, 50, 0, 0, 2969, 2973, 5, 40, 0, 0, 2970, 2972, 3, 336, 168, 0, 2971, 2970, 1, 0, 0, 0, 2972, 2975, 1, 0, 0, 0, 2973, 2971, 1, 0, 0, 0, 2973, 2974, 1, 0, 0, 0, 2974, 2976, 1, 0, 0, 0, 2975, 2973, 1, 0, 0, 0, 2976, 2977, 3, 2, 1, 0, 2977, 333, 1, 0, 0, 0, 2978, 2982, 5, 301, 0, 0, 2979, 2981, 3, 336, 168, 0, 2980, 2979, 1, 0, 0, 0, 2981, 2984, 1, 0, 0, 0, 2982, 2980, 1, 0, 0, 0, 2982, 2983, 1, 0, 0, 0, 2983, 2985, 1, 0, 0, 0, 2984, 2982, 1, 0, 0, 0, 2985, 2986, 3, 2, 1, 0, 2986, 335, 1, 0, 0, 0, 2987, 3003, 5, 52, 0, 0, 2988, 3003, 5, 51, 0, 0, 2989, 3003, 5, 172, 0, 0, 2990, 2991, 5, 62, 0, 0, 2991, 3003, 5, 51, 0, 0, 2992, 2993, 5, 62, 0, 0, 2993, 3003, 5, 52, 0, 0, 2994, 2995, 5, 62, 0, 0, 2995, 3003, 5, 63, 0, 0, 2996, 2997, 5, 62, 0, 0, 2997, 3003, 5, 64, 0, 0, 2998, 2999, 5, 62, 0, 0, 2999, 3003, 5, 65, 0, 0, 3000, 3001, 5, 62, 0, 0, 3001, 3003, 5, 66, 0, 0, 3002, 2987, 1, 0, 0, 0, 3002, 2988, 1, 0, 0, 0, 3002, 2989, 1, 0, 0, 0, 3002, 2990, 1, 0, 0, 0, 3002, 2992, 1, 0, 0, 0, 3002, 2994, 1, 0, 0, 0, 3002, 2996, 1, 0, 0, 0, 3002, 2998, 1, 0, 0, 0, 3002, 3000, 1, 0, 0, 0, 3003, 337, 1, 0, 0, 0, 3004, 3006, 3, 340, 170, 0, 3005, 3004, 1, 0, 0, 0, 3006, 3009, 1, 0, 0, 0, 3007, 3005, 1, 0, 0, 0, 3007, 3008, 1, 0, 0, 0, 3008, 339, 1, 0, 0, 0, 3009, 3007, 1, 0, 0, 0, 3010, 3011, 5, 21, 0, 0, 3011, 3024, 3, 2, 1, 0, 3012, 3013, 5, 50, 0, 0, 3013, 3014, 5, 40, 0, 0, 3014, 3024, 3, 118, 59, 0, 3015, 3016, 5, 25, 0, 0, 3016, 3017, 5, 40, 0, 0, 3017, 3024, 3, 2, 1, 0, 3018, 3024, 3, 174, 87, 0, 3019, 3020, 5, 50, 0, 0, 3020, 3024, 3, 32, 16, 0, 3021, 3024, 3, 322, 161, 0, 3022, 3024, 3, 40, 20, 0, 3023, 3010, 1, 0, 0, 0, 3023, 3012, 1, 0, 0, 0, 3023, 3015, 1, 0, 0, 0, 3023, 3018, 1, 0, 0, 0, 3023, 3019, 1, 0, 0, 0, 3023, 3021, 1, 0, 0, 0, 3023, 3022, 1, 0, 0, 0, 3024, 341, 1, 0, 0, 0, 3025, 3029, 5, 274, 0, 0, 3026, 3028, 3, 344, 172, 0, 3027, 3026, 1, 0, 0, 0, 3028, 3031, 1, 0, 0, 0, 3029, 3027, 1, 0, 0, 0, 3029, 3030, 1, 0, 0, 0, 3030, 3032, 1, 0, 0, 0, 3031, 3029, 1, 0, 0, 0, 3032, 3045, 3, 2, 1, 0, 3033, 3037, 5, 274, 0, 0, 3034, 3036, 3, 344, 172, 0, 3035, 3034, 1, 0, 0, 0, 3036, 3039, 1, 0, 0, 0, 3037, 3035, 1, 0, 0, 0, 3037, 3038, 1, 0, 0, 0, 3038, 3040, 1, 0, 0, 0, 3039, 3037, 1, 0, 0, 0, 3040, 3041, 3, 2, 1, 0, 3041, 3042, 5, 34, 0, 0, 3042, 3043, 3, 2, 1, 0, 3043, 3045, 1, 0, 0, 0, 3044, 3025, 1, 0, 0, 0, 3044, 3033, 1, 0, 0, 0, 3045, 343, 1, 0, 0, 0, 3046, 3047, 7, 15, 0, 0, 3047, 345, 1, 0, 0, 0, 3048, 3050, 3, 348, 174, 0, 3049, 3048, 1, 0, 0, 0, 3050, 3053, 1, 0, 0, 0, 3051, 3049, 1, 0, 0, 0, 3051, 3052, 1, 0, 0, 0, 3052, 347, 1, 0, 0, 0, 3053, 3051, 1, 0, 0, 0, 3054, 3055, 5, 21, 0, 0, 3055, 3056, 3, 2, 1, 0, 3056, 3057, 5, 44, 0, 0, 3057, 3058, 3, 32, 16, 0, 3058, 3065, 1, 0, 0, 0, 3059, 3060, 5, 25, 0, 0, 3060, 3061, 5, 40, 0, 0, 3061, 3065, 3, 2, 1, 0, 3062, 3065, 3, 322, 161, 0, 3063, 3065, 3, 40, 20, 0, 3064, 3054, 1, 0, 0, 0, 3064, 3059, 1, 0, 0, 0, 3064, 3062, 1, 0, 0, 0, 3064, 3063, 1, 0, 0, 0, 3065, 349, 1, 0, 0, 0, 175, 360, 368, 377, 386, 439, 480, 489, 519, 523, 541, 568, 591, 627, 637, 644, 646, 656, 658, 665, 676, 684, 705, 707, 723, 768, 773, 778, 783, 791, 901, 907, 923, 929, 935, 942, 970, 1048, 1050, 1064, 1070, 1079, 1081, 1090, 1104, 1118, 1126, 1134, 1138, 1177, 1185, 1194, 1202, 1221, 1228, 1231, 1250, 1344, 1353, 1360, 1363, 1374, 1406, 1466, 1506, 1522, 1532, 1559, 1583, 1591, 1595, 1610, 1617, 1662, 1672, 1690, 1708, 1727, 1748, 1767, 1782, 1789, 1799, 1812, 1817, 1822, 1831, 1841, 1927, 1936, 1949, 1960, 1968, 1978, 1980, 2007, 2014, 2019, 2026, 2032, 2042, 2046, 2053, 2068, 2074, 2088, 2101, 2109, 2116, 2120, 2127, 2147, 2152, 2154, 2167, 2193, 2200, 2202, 2207, 2213, 2242, 2251, 2274, 2279, 2299, 2352, 2361, 2374, 2385, 2396, 2399, 2407, 2419, 2433, 2447, 2455, 2475, 2487, 2492, 2501, 2503, 2510, 2520, 2588, 2665, 2672, 2680, 2830, 2834, 2836, 2841, 2843, 2849, 2855, 2861, 2867, 2873, 2879, 2885, 2892, 2897, 2903, 2930, 2944, 2949, 2966, 2973, 2982, 3002, 3007, 3023, 3029, 3037, 3044, 3051, 3064] \ No newline at end of file +[4, 1, 305, 3216, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 359, 8, 1, 10, 1, 12, 1, 362, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 369, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 5, 3, 376, 8, 3, 10, 3, 12, 3, 379, 9, 3, 1, 3, 1, 3, 1, 3, 1, 4, 5, 4, 385, 8, 4, 10, 4, 12, 4, 388, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 440, 8, 5, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 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, 481, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 5, 15, 488, 8, 15, 10, 15, 12, 15, 491, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 520, 8, 18, 1, 19, 1, 19, 3, 19, 524, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 542, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 569, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 592, 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, 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, 628, 8, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 638, 8, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 5, 27, 645, 8, 27, 10, 27, 12, 27, 648, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 657, 8, 28, 10, 28, 12, 28, 660, 9, 28, 1, 29, 1, 29, 1, 30, 1, 30, 3, 30, 666, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 677, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 685, 8, 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, 34, 1, 34, 1, 34, 1, 34, 5, 34, 706, 8, 34, 10, 34, 12, 34, 709, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 5, 37, 722, 8, 37, 10, 37, 12, 37, 725, 9, 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, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 769, 8, 38, 1, 39, 1, 39, 1, 39, 3, 39, 774, 8, 39, 1, 40, 1, 40, 1, 40, 3, 40, 779, 8, 40, 1, 41, 5, 41, 782, 8, 41, 10, 41, 12, 41, 785, 9, 41, 1, 42, 1, 42, 1, 42, 5, 42, 790, 8, 42, 10, 42, 12, 42, 793, 9, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 902, 8, 44, 1, 45, 1, 45, 5, 45, 906, 8, 45, 10, 45, 12, 45, 909, 9, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 922, 8, 45, 10, 45, 12, 45, 925, 9, 45, 1, 45, 1, 45, 1, 45, 3, 45, 930, 8, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 936, 8, 47, 1, 48, 1, 48, 1, 49, 5, 49, 941, 8, 49, 10, 49, 12, 49, 944, 9, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 971, 8, 50, 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, 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, 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, 1049, 8, 51, 3, 51, 1051, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1065, 8, 53, 1, 53, 1, 53, 5, 53, 1069, 8, 53, 10, 53, 12, 53, 1072, 9, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1080, 8, 53, 3, 53, 1082, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1089, 8, 54, 10, 54, 12, 54, 1092, 9, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1103, 8, 55, 10, 55, 12, 55, 1106, 9, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 5, 56, 1117, 8, 56, 10, 56, 12, 56, 1120, 9, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1127, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 1135, 8, 57, 1, 57, 1, 57, 3, 57, 1139, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1178, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 1184, 8, 59, 10, 59, 12, 59, 1187, 9, 59, 1, 59, 1, 59, 1, 59, 1, 60, 5, 60, 1193, 8, 60, 10, 60, 12, 60, 1196, 9, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1203, 8, 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, 3, 62, 1222, 8, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 5, 63, 1230, 8, 63, 10, 63, 12, 63, 1233, 9, 63, 3, 63, 1235, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 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, 1259, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1406, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1416, 8, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 5, 67, 1423, 8, 67, 10, 67, 12, 67, 1426, 9, 67, 3, 67, 1428, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1510, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 5, 69, 1517, 8, 69, 10, 69, 12, 69, 1520, 9, 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, 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, 1551, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1611, 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, 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, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1651, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1667, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1677, 8, 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, 3, 76, 1704, 8, 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, 1728, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 5, 77, 1734, 8, 77, 10, 77, 12, 77, 1737, 9, 77, 1, 77, 3, 77, 1740, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1755, 8, 78, 1, 79, 1, 79, 1, 79, 5, 79, 1760, 8, 79, 10, 79, 12, 79, 1763, 9, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1807, 8, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1817, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1835, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1853, 8, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1872, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1893, 8, 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, 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 1912, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1927, 8, 89, 1, 90, 1, 90, 1, 90, 5, 90, 1932, 8, 90, 10, 90, 12, 90, 1935, 9, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 1944, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 1957, 8, 92, 1, 93, 5, 93, 1960, 8, 93, 10, 93, 12, 93, 1963, 9, 93, 1, 94, 1, 94, 3, 94, 1967, 8, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 5, 95, 1974, 8, 95, 10, 95, 12, 95, 1977, 9, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 3, 97, 1986, 8, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2070, 8, 99, 10, 99, 12, 99, 2073, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2079, 8, 99, 10, 99, 12, 99, 2082, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2092, 8, 99, 10, 99, 12, 99, 2095, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2103, 8, 99, 10, 99, 12, 99, 2106, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 2113, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 2123, 8, 100, 10, 100, 12, 100, 2126, 9, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 2152, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 2159, 8, 102, 1, 103, 1, 103, 1, 103, 3, 103, 2164, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 2171, 8, 104, 1, 105, 1, 105, 5, 105, 2175, 8, 105, 10, 105, 12, 105, 2178, 9, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2185, 8, 105, 10, 105, 12, 105, 2188, 9, 105, 1, 105, 3, 105, 2191, 8, 105, 1, 106, 1, 106, 1, 107, 5, 107, 2196, 8, 107, 10, 107, 12, 107, 2199, 9, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 2213, 8, 108, 1, 109, 1, 109, 5, 109, 2217, 8, 109, 10, 109, 12, 109, 2220, 9, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 111, 5, 111, 2231, 8, 111, 10, 111, 12, 111, 2234, 9, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 2246, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 2255, 8, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 4, 114, 2264, 8, 114, 11, 114, 12, 114, 2265, 1, 114, 1, 114, 3, 114, 2270, 8, 114, 1, 115, 1, 115, 1, 115, 5, 115, 2275, 8, 115, 10, 115, 12, 115, 2278, 9, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 2297, 8, 116, 1, 117, 1, 117, 1, 117, 5, 117, 2302, 8, 117, 10, 117, 12, 117, 2305, 9, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2315, 8, 117, 10, 117, 12, 117, 2318, 9, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2343, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2350, 8, 119, 3, 119, 2352, 8, 119, 1, 119, 5, 119, 2355, 8, 119, 10, 119, 12, 119, 2358, 9, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2363, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2392, 8, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 2401, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2424, 8, 122, 1, 123, 5, 123, 2427, 8, 123, 10, 123, 12, 123, 2430, 9, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2449, 8, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2500, 8, 125, 10, 125, 12, 125, 2503, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2509, 8, 125, 10, 125, 12, 125, 2512, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2522, 8, 125, 10, 125, 12, 125, 2525, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2533, 8, 125, 10, 125, 12, 125, 2536, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2544, 8, 125, 10, 125, 12, 125, 2547, 9, 125, 3, 125, 2549, 8, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 3, 127, 2557, 8, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 130, 4, 130, 2567, 8, 130, 11, 130, 12, 130, 2568, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 2583, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 3, 132, 2597, 8, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 2605, 8, 133, 1, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 2625, 8, 137, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 2637, 8, 139, 1, 140, 1, 140, 1, 140, 3, 140, 2642, 8, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 4, 141, 2649, 8, 141, 11, 141, 12, 141, 2650, 3, 141, 2653, 8, 141, 1, 142, 1, 142, 1, 142, 5, 142, 2658, 8, 142, 10, 142, 12, 142, 2661, 9, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 2670, 8, 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, 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, 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, 2738, 8, 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, 145, 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, 145, 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, 145, 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, 145, 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, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 3, 145, 2815, 8, 145, 1, 146, 1, 146, 1, 146, 5, 146, 2820, 8, 146, 10, 146, 12, 146, 2823, 9, 146, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 3, 148, 2830, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 2980, 8, 149, 1, 150, 1, 150, 5, 150, 2984, 8, 150, 10, 150, 12, 150, 2987, 9, 150, 1, 151, 1, 151, 5, 151, 2991, 8, 151, 10, 151, 12, 151, 2994, 9, 151, 1, 152, 5, 152, 2997, 8, 152, 10, 152, 12, 152, 3000, 9, 152, 1, 153, 5, 153, 3003, 8, 153, 10, 153, 12, 153, 3006, 9, 153, 1, 154, 5, 154, 3009, 8, 154, 10, 154, 12, 154, 3012, 9, 154, 1, 155, 5, 155, 3015, 8, 155, 10, 155, 12, 155, 3018, 9, 155, 1, 156, 5, 156, 3021, 8, 156, 10, 156, 12, 156, 3024, 9, 156, 1, 157, 5, 157, 3027, 8, 157, 10, 157, 12, 157, 3030, 9, 157, 1, 158, 5, 158, 3033, 8, 158, 10, 158, 12, 158, 3036, 9, 158, 1, 159, 1, 159, 1, 159, 1, 159, 3, 159, 3042, 8, 159, 1, 160, 5, 160, 3045, 8, 160, 10, 160, 12, 160, 3048, 9, 160, 1, 161, 1, 161, 1, 161, 3, 161, 3053, 8, 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, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 3, 162, 3080, 8, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 3094, 8, 163, 1, 164, 5, 164, 3097, 8, 164, 10, 164, 12, 164, 3100, 9, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 3, 165, 3116, 8, 165, 1, 166, 1, 166, 1, 166, 5, 166, 3121, 8, 166, 10, 166, 12, 166, 3124, 9, 166, 1, 166, 1, 166, 1, 167, 1, 167, 5, 167, 3130, 8, 167, 10, 167, 12, 167, 3133, 9, 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, 168, 1, 168, 1, 168, 1, 168, 3, 168, 3152, 8, 168, 1, 169, 5, 169, 3155, 8, 169, 10, 169, 12, 169, 3158, 9, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 3173, 8, 170, 1, 171, 1, 171, 5, 171, 3177, 8, 171, 10, 171, 12, 171, 3180, 9, 171, 1, 171, 1, 171, 1, 171, 5, 171, 3185, 8, 171, 10, 171, 12, 171, 3188, 9, 171, 1, 171, 1, 171, 1, 171, 1, 171, 3, 171, 3194, 8, 171, 1, 172, 1, 172, 1, 173, 5, 173, 3199, 8, 173, 10, 173, 12, 173, 3202, 9, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 3214, 8, 174, 1, 174, 0, 1, 68, 175, 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, 0, 15, 6, 0, 1, 15, 199, 199, 243, 243, 247, 247, 264, 264, 289, 289, 5, 0, 16, 16, 199, 199, 243, 243, 264, 264, 288, 289, 1, 0, 263, 264, 1, 0, 173, 174, 1, 0, 37, 38, 1, 0, 73, 74, 3, 0, 2, 2, 61, 61, 77, 83, 2, 0, 229, 229, 260, 261, 1, 0, 95, 96, 1, 0, 97, 111, 1, 0, 68, 69, 2, 0, 173, 173, 289, 290, 2, 0, 179, 179, 264, 264, 1, 0, 167, 168, 1, 0, 51, 52, 3682, 0, 350, 1, 0, 0, 0, 2, 368, 1, 0, 0, 0, 4, 370, 1, 0, 0, 0, 6, 377, 1, 0, 0, 0, 8, 386, 1, 0, 0, 0, 10, 439, 1, 0, 0, 0, 12, 441, 1, 0, 0, 0, 14, 444, 1, 0, 0, 0, 16, 447, 1, 0, 0, 0, 18, 451, 1, 0, 0, 0, 20, 454, 1, 0, 0, 0, 22, 457, 1, 0, 0, 0, 24, 464, 1, 0, 0, 0, 26, 480, 1, 0, 0, 0, 28, 482, 1, 0, 0, 0, 30, 484, 1, 0, 0, 0, 32, 494, 1, 0, 0, 0, 34, 496, 1, 0, 0, 0, 36, 519, 1, 0, 0, 0, 38, 523, 1, 0, 0, 0, 40, 541, 1, 0, 0, 0, 42, 568, 1, 0, 0, 0, 44, 591, 1, 0, 0, 0, 46, 627, 1, 0, 0, 0, 48, 629, 1, 0, 0, 0, 50, 637, 1, 0, 0, 0, 52, 639, 1, 0, 0, 0, 54, 646, 1, 0, 0, 0, 56, 658, 1, 0, 0, 0, 58, 661, 1, 0, 0, 0, 60, 663, 1, 0, 0, 0, 62, 676, 1, 0, 0, 0, 64, 684, 1, 0, 0, 0, 66, 686, 1, 0, 0, 0, 68, 694, 1, 0, 0, 0, 70, 710, 1, 0, 0, 0, 72, 716, 1, 0, 0, 0, 74, 719, 1, 0, 0, 0, 76, 768, 1, 0, 0, 0, 78, 773, 1, 0, 0, 0, 80, 778, 1, 0, 0, 0, 82, 783, 1, 0, 0, 0, 84, 791, 1, 0, 0, 0, 86, 796, 1, 0, 0, 0, 88, 901, 1, 0, 0, 0, 90, 929, 1, 0, 0, 0, 92, 931, 1, 0, 0, 0, 94, 935, 1, 0, 0, 0, 96, 937, 1, 0, 0, 0, 98, 942, 1, 0, 0, 0, 100, 970, 1, 0, 0, 0, 102, 1050, 1, 0, 0, 0, 104, 1052, 1, 0, 0, 0, 106, 1081, 1, 0, 0, 0, 108, 1083, 1, 0, 0, 0, 110, 1097, 1, 0, 0, 0, 112, 1126, 1, 0, 0, 0, 114, 1138, 1, 0, 0, 0, 116, 1177, 1, 0, 0, 0, 118, 1185, 1, 0, 0, 0, 120, 1194, 1, 0, 0, 0, 122, 1202, 1, 0, 0, 0, 124, 1221, 1, 0, 0, 0, 126, 1234, 1, 0, 0, 0, 128, 1258, 1, 0, 0, 0, 130, 1405, 1, 0, 0, 0, 132, 1415, 1, 0, 0, 0, 134, 1427, 1, 0, 0, 0, 136, 1509, 1, 0, 0, 0, 138, 1511, 1, 0, 0, 0, 140, 1550, 1, 0, 0, 0, 142, 1610, 1, 0, 0, 0, 144, 1650, 1, 0, 0, 0, 146, 1666, 1, 0, 0, 0, 148, 1668, 1, 0, 0, 0, 150, 1672, 1, 0, 0, 0, 152, 1727, 1, 0, 0, 0, 154, 1739, 1, 0, 0, 0, 156, 1754, 1, 0, 0, 0, 158, 1761, 1, 0, 0, 0, 160, 1766, 1, 0, 0, 0, 162, 1770, 1, 0, 0, 0, 164, 1806, 1, 0, 0, 0, 166, 1808, 1, 0, 0, 0, 168, 1852, 1, 0, 0, 0, 170, 1871, 1, 0, 0, 0, 172, 1892, 1, 0, 0, 0, 174, 1894, 1, 0, 0, 0, 176, 1911, 1, 0, 0, 0, 178, 1926, 1, 0, 0, 0, 180, 1933, 1, 0, 0, 0, 182, 1943, 1, 0, 0, 0, 184, 1956, 1, 0, 0, 0, 186, 1961, 1, 0, 0, 0, 188, 1964, 1, 0, 0, 0, 190, 1975, 1, 0, 0, 0, 192, 1980, 1, 0, 0, 0, 194, 1985, 1, 0, 0, 0, 196, 1989, 1, 0, 0, 0, 198, 2112, 1, 0, 0, 0, 200, 2114, 1, 0, 0, 0, 202, 2151, 1, 0, 0, 0, 204, 2158, 1, 0, 0, 0, 206, 2163, 1, 0, 0, 0, 208, 2170, 1, 0, 0, 0, 210, 2190, 1, 0, 0, 0, 212, 2192, 1, 0, 0, 0, 214, 2197, 1, 0, 0, 0, 216, 2212, 1, 0, 0, 0, 218, 2214, 1, 0, 0, 0, 220, 2227, 1, 0, 0, 0, 222, 2232, 1, 0, 0, 0, 224, 2245, 1, 0, 0, 0, 226, 2254, 1, 0, 0, 0, 228, 2269, 1, 0, 0, 0, 230, 2276, 1, 0, 0, 0, 232, 2296, 1, 0, 0, 0, 234, 2298, 1, 0, 0, 0, 236, 2342, 1, 0, 0, 0, 238, 2362, 1, 0, 0, 0, 240, 2391, 1, 0, 0, 0, 242, 2400, 1, 0, 0, 0, 244, 2423, 1, 0, 0, 0, 246, 2428, 1, 0, 0, 0, 248, 2448, 1, 0, 0, 0, 250, 2548, 1, 0, 0, 0, 252, 2550, 1, 0, 0, 0, 254, 2556, 1, 0, 0, 0, 256, 2558, 1, 0, 0, 0, 258, 2562, 1, 0, 0, 0, 260, 2566, 1, 0, 0, 0, 262, 2582, 1, 0, 0, 0, 264, 2596, 1, 0, 0, 0, 266, 2604, 1, 0, 0, 0, 268, 2606, 1, 0, 0, 0, 270, 2609, 1, 0, 0, 0, 272, 2611, 1, 0, 0, 0, 274, 2624, 1, 0, 0, 0, 276, 2626, 1, 0, 0, 0, 278, 2636, 1, 0, 0, 0, 280, 2641, 1, 0, 0, 0, 282, 2652, 1, 0, 0, 0, 284, 2659, 1, 0, 0, 0, 286, 2669, 1, 0, 0, 0, 288, 2737, 1, 0, 0, 0, 290, 2814, 1, 0, 0, 0, 292, 2821, 1, 0, 0, 0, 294, 2824, 1, 0, 0, 0, 296, 2829, 1, 0, 0, 0, 298, 2979, 1, 0, 0, 0, 300, 2985, 1, 0, 0, 0, 302, 2992, 1, 0, 0, 0, 304, 2998, 1, 0, 0, 0, 306, 3004, 1, 0, 0, 0, 308, 3010, 1, 0, 0, 0, 310, 3016, 1, 0, 0, 0, 312, 3022, 1, 0, 0, 0, 314, 3028, 1, 0, 0, 0, 316, 3034, 1, 0, 0, 0, 318, 3041, 1, 0, 0, 0, 320, 3046, 1, 0, 0, 0, 322, 3052, 1, 0, 0, 0, 324, 3079, 1, 0, 0, 0, 326, 3093, 1, 0, 0, 0, 328, 3098, 1, 0, 0, 0, 330, 3115, 1, 0, 0, 0, 332, 3117, 1, 0, 0, 0, 334, 3127, 1, 0, 0, 0, 336, 3151, 1, 0, 0, 0, 338, 3156, 1, 0, 0, 0, 340, 3172, 1, 0, 0, 0, 342, 3193, 1, 0, 0, 0, 344, 3195, 1, 0, 0, 0, 346, 3200, 1, 0, 0, 0, 348, 3213, 1, 0, 0, 0, 350, 351, 7, 0, 0, 0, 351, 1, 1, 0, 0, 0, 352, 353, 5, 288, 0, 0, 353, 369, 6, 1, -1, 0, 354, 355, 3, 4, 2, 0, 355, 356, 6, 1, -1, 0, 356, 357, 5, 265, 0, 0, 357, 359, 1, 0, 0, 0, 358, 354, 1, 0, 0, 0, 359, 362, 1, 0, 0, 0, 360, 358, 1, 0, 0, 0, 360, 361, 1, 0, 0, 0, 361, 363, 1, 0, 0, 0, 362, 360, 1, 0, 0, 0, 363, 364, 3, 4, 2, 0, 364, 365, 6, 1, -1, 0, 365, 369, 1, 0, 0, 0, 366, 367, 5, 264, 0, 0, 367, 369, 6, 1, -1, 0, 368, 352, 1, 0, 0, 0, 368, 360, 1, 0, 0, 0, 368, 366, 1, 0, 0, 0, 369, 3, 1, 0, 0, 0, 370, 371, 7, 1, 0, 0, 371, 5, 1, 0, 0, 0, 372, 373, 5, 263, 0, 0, 373, 374, 6, 3, -1, 0, 374, 376, 5, 266, 0, 0, 375, 372, 1, 0, 0, 0, 376, 379, 1, 0, 0, 0, 377, 375, 1, 0, 0, 0, 377, 378, 1, 0, 0, 0, 378, 380, 1, 0, 0, 0, 379, 377, 1, 0, 0, 0, 380, 381, 5, 263, 0, 0, 381, 382, 6, 3, -1, 0, 382, 7, 1, 0, 0, 0, 383, 385, 3, 10, 5, 0, 384, 383, 1, 0, 0, 0, 385, 388, 1, 0, 0, 0, 386, 384, 1, 0, 0, 0, 386, 387, 1, 0, 0, 0, 387, 9, 1, 0, 0, 0, 388, 386, 1, 0, 0, 0, 389, 390, 3, 74, 37, 0, 390, 391, 5, 17, 0, 0, 391, 392, 3, 82, 41, 0, 392, 393, 5, 18, 0, 0, 393, 440, 1, 0, 0, 0, 394, 395, 3, 72, 36, 0, 395, 396, 5, 17, 0, 0, 396, 397, 3, 8, 4, 0, 397, 398, 5, 18, 0, 0, 398, 440, 1, 0, 0, 0, 399, 400, 3, 234, 117, 0, 400, 401, 5, 17, 0, 0, 401, 402, 3, 246, 123, 0, 402, 403, 5, 18, 0, 0, 403, 440, 1, 0, 0, 0, 404, 440, 3, 200, 100, 0, 405, 440, 3, 276, 138, 0, 406, 440, 3, 70, 35, 0, 407, 440, 3, 66, 33, 0, 408, 440, 3, 88, 44, 0, 409, 440, 3, 90, 45, 0, 410, 440, 3, 22, 11, 0, 411, 412, 3, 326, 163, 0, 412, 413, 5, 17, 0, 0, 413, 414, 3, 328, 164, 0, 414, 415, 5, 18, 0, 0, 415, 440, 1, 0, 0, 0, 416, 417, 3, 332, 166, 0, 417, 418, 5, 17, 0, 0, 418, 419, 3, 338, 169, 0, 419, 420, 5, 18, 0, 0, 420, 440, 1, 0, 0, 0, 421, 422, 3, 342, 171, 0, 422, 423, 5, 17, 0, 0, 423, 424, 3, 346, 173, 0, 424, 425, 5, 18, 0, 0, 425, 440, 1, 0, 0, 0, 426, 440, 3, 64, 32, 0, 427, 440, 3, 152, 76, 0, 428, 440, 3, 322, 161, 0, 429, 440, 3, 12, 6, 0, 430, 440, 3, 14, 7, 0, 431, 440, 3, 16, 8, 0, 432, 440, 3, 18, 9, 0, 433, 440, 3, 20, 10, 0, 434, 440, 3, 26, 13, 0, 435, 440, 3, 42, 21, 0, 436, 440, 3, 40, 20, 0, 437, 440, 3, 30, 15, 0, 438, 440, 3, 24, 12, 0, 439, 389, 1, 0, 0, 0, 439, 394, 1, 0, 0, 0, 439, 399, 1, 0, 0, 0, 439, 404, 1, 0, 0, 0, 439, 405, 1, 0, 0, 0, 439, 406, 1, 0, 0, 0, 439, 407, 1, 0, 0, 0, 439, 408, 1, 0, 0, 0, 439, 409, 1, 0, 0, 0, 439, 410, 1, 0, 0, 0, 439, 411, 1, 0, 0, 0, 439, 416, 1, 0, 0, 0, 439, 421, 1, 0, 0, 0, 439, 426, 1, 0, 0, 0, 439, 427, 1, 0, 0, 0, 439, 428, 1, 0, 0, 0, 439, 429, 1, 0, 0, 0, 439, 430, 1, 0, 0, 0, 439, 431, 1, 0, 0, 0, 439, 432, 1, 0, 0, 0, 439, 433, 1, 0, 0, 0, 439, 434, 1, 0, 0, 0, 439, 435, 1, 0, 0, 0, 439, 436, 1, 0, 0, 0, 439, 437, 1, 0, 0, 0, 439, 438, 1, 0, 0, 0, 440, 11, 1, 0, 0, 0, 441, 442, 5, 19, 0, 0, 442, 443, 3, 32, 16, 0, 443, 13, 1, 0, 0, 0, 444, 445, 5, 20, 0, 0, 445, 446, 3, 32, 16, 0, 446, 15, 1, 0, 0, 0, 447, 448, 5, 21, 0, 0, 448, 449, 5, 22, 0, 0, 449, 450, 3, 32, 16, 0, 450, 17, 1, 0, 0, 0, 451, 452, 5, 23, 0, 0, 452, 453, 3, 34, 17, 0, 453, 19, 1, 0, 0, 0, 454, 455, 5, 24, 0, 0, 455, 456, 3, 34, 17, 0, 456, 21, 1, 0, 0, 0, 457, 458, 5, 25, 0, 0, 458, 459, 3, 98, 49, 0, 459, 460, 3, 2, 1, 0, 460, 461, 5, 17, 0, 0, 461, 462, 3, 120, 60, 0, 462, 463, 5, 18, 0, 0, 463, 23, 1, 0, 0, 0, 464, 465, 5, 26, 0, 0, 465, 25, 1, 0, 0, 0, 466, 467, 5, 27, 0, 0, 467, 481, 3, 28, 14, 0, 468, 469, 5, 27, 0, 0, 469, 470, 3, 28, 14, 0, 470, 471, 5, 28, 0, 0, 471, 472, 3, 28, 14, 0, 472, 481, 1, 0, 0, 0, 473, 474, 5, 27, 0, 0, 474, 475, 3, 28, 14, 0, 475, 476, 5, 28, 0, 0, 476, 477, 3, 28, 14, 0, 477, 478, 5, 28, 0, 0, 478, 479, 3, 28, 14, 0, 479, 481, 1, 0, 0, 0, 480, 466, 1, 0, 0, 0, 480, 468, 1, 0, 0, 0, 480, 473, 1, 0, 0, 0, 481, 27, 1, 0, 0, 0, 482, 483, 7, 2, 0, 0, 483, 29, 1, 0, 0, 0, 484, 485, 5, 29, 0, 0, 485, 489, 5, 17, 0, 0, 486, 488, 3, 116, 58, 0, 487, 486, 1, 0, 0, 0, 488, 491, 1, 0, 0, 0, 489, 487, 1, 0, 0, 0, 489, 490, 1, 0, 0, 0, 490, 492, 1, 0, 0, 0, 491, 489, 1, 0, 0, 0, 492, 493, 5, 18, 0, 0, 493, 31, 1, 0, 0, 0, 494, 495, 5, 173, 0, 0, 495, 33, 1, 0, 0, 0, 496, 497, 7, 3, 0, 0, 497, 35, 1, 0, 0, 0, 498, 499, 5, 175, 0, 0, 499, 520, 6, 18, -1, 0, 500, 501, 3, 32, 16, 0, 501, 502, 5, 265, 0, 0, 502, 503, 6, 18, -1, 0, 503, 520, 1, 0, 0, 0, 504, 505, 3, 32, 16, 0, 505, 506, 6, 18, -1, 0, 506, 520, 1, 0, 0, 0, 507, 508, 5, 188, 0, 0, 508, 509, 5, 30, 0, 0, 509, 510, 3, 32, 16, 0, 510, 511, 5, 31, 0, 0, 511, 512, 6, 18, -1, 0, 512, 520, 1, 0, 0, 0, 513, 514, 5, 189, 0, 0, 514, 515, 5, 30, 0, 0, 515, 516, 3, 34, 17, 0, 516, 517, 5, 31, 0, 0, 517, 518, 6, 18, -1, 0, 518, 520, 1, 0, 0, 0, 519, 498, 1, 0, 0, 0, 519, 500, 1, 0, 0, 0, 519, 504, 1, 0, 0, 0, 519, 507, 1, 0, 0, 0, 519, 513, 1, 0, 0, 0, 520, 37, 1, 0, 0, 0, 521, 524, 3, 32, 16, 0, 522, 524, 5, 262, 0, 0, 523, 521, 1, 0, 0, 0, 523, 522, 1, 0, 0, 0, 524, 39, 1, 0, 0, 0, 525, 526, 5, 267, 0, 0, 526, 542, 5, 289, 0, 0, 527, 528, 5, 267, 0, 0, 528, 529, 5, 289, 0, 0, 529, 542, 5, 263, 0, 0, 530, 531, 5, 268, 0, 0, 531, 542, 5, 289, 0, 0, 532, 533, 5, 269, 0, 0, 533, 542, 5, 289, 0, 0, 534, 535, 5, 270, 0, 0, 535, 542, 5, 289, 0, 0, 536, 542, 5, 271, 0, 0, 537, 542, 5, 272, 0, 0, 538, 539, 5, 273, 0, 0, 539, 542, 5, 263, 0, 0, 540, 542, 5, 32, 0, 0, 541, 525, 1, 0, 0, 0, 541, 527, 1, 0, 0, 0, 541, 530, 1, 0, 0, 0, 541, 532, 1, 0, 0, 0, 541, 534, 1, 0, 0, 0, 541, 536, 1, 0, 0, 0, 541, 537, 1, 0, 0, 0, 541, 538, 1, 0, 0, 0, 541, 540, 1, 0, 0, 0, 542, 41, 1, 0, 0, 0, 543, 544, 5, 33, 0, 0, 544, 545, 3, 138, 69, 0, 545, 546, 5, 34, 0, 0, 546, 547, 3, 2, 1, 0, 547, 569, 1, 0, 0, 0, 548, 549, 5, 33, 0, 0, 549, 550, 3, 116, 58, 0, 550, 551, 5, 34, 0, 0, 551, 552, 3, 2, 1, 0, 552, 569, 1, 0, 0, 0, 553, 554, 5, 33, 0, 0, 554, 555, 3, 176, 88, 0, 555, 556, 5, 34, 0, 0, 556, 557, 3, 2, 1, 0, 557, 569, 1, 0, 0, 0, 558, 559, 5, 33, 0, 0, 559, 560, 3, 44, 22, 0, 560, 561, 5, 34, 0, 0, 561, 562, 3, 2, 1, 0, 562, 569, 1, 0, 0, 0, 563, 564, 5, 33, 0, 0, 564, 565, 3, 46, 23, 0, 565, 566, 5, 34, 0, 0, 566, 567, 3, 2, 1, 0, 567, 569, 1, 0, 0, 0, 568, 543, 1, 0, 0, 0, 568, 548, 1, 0, 0, 0, 568, 553, 1, 0, 0, 0, 568, 558, 1, 0, 0, 0, 568, 563, 1, 0, 0, 0, 569, 43, 1, 0, 0, 0, 570, 571, 5, 35, 0, 0, 571, 592, 3, 48, 24, 0, 572, 573, 5, 35, 0, 0, 573, 574, 3, 48, 24, 0, 574, 575, 5, 36, 0, 0, 575, 576, 3, 6, 3, 0, 576, 592, 1, 0, 0, 0, 577, 578, 5, 35, 0, 0, 578, 579, 3, 48, 24, 0, 579, 580, 5, 36, 0, 0, 580, 581, 5, 17, 0, 0, 581, 582, 3, 52, 26, 0, 582, 583, 5, 18, 0, 0, 583, 592, 1, 0, 0, 0, 584, 585, 5, 35, 0, 0, 585, 586, 3, 48, 24, 0, 586, 587, 5, 36, 0, 0, 587, 588, 5, 30, 0, 0, 588, 589, 3, 292, 146, 0, 589, 590, 5, 31, 0, 0, 590, 592, 1, 0, 0, 0, 591, 570, 1, 0, 0, 0, 591, 572, 1, 0, 0, 0, 591, 577, 1, 0, 0, 0, 591, 584, 1, 0, 0, 0, 592, 45, 1, 0, 0, 0, 593, 594, 5, 35, 0, 0, 594, 595, 5, 30, 0, 0, 595, 596, 3, 50, 25, 0, 596, 597, 5, 31, 0, 0, 597, 598, 3, 48, 24, 0, 598, 628, 1, 0, 0, 0, 599, 600, 5, 35, 0, 0, 600, 601, 5, 30, 0, 0, 601, 602, 3, 50, 25, 0, 602, 603, 5, 31, 0, 0, 603, 604, 3, 48, 24, 0, 604, 605, 5, 36, 0, 0, 605, 606, 3, 6, 3, 0, 606, 628, 1, 0, 0, 0, 607, 608, 5, 35, 0, 0, 608, 609, 5, 30, 0, 0, 609, 610, 3, 50, 25, 0, 610, 611, 5, 31, 0, 0, 611, 612, 3, 48, 24, 0, 612, 613, 5, 36, 0, 0, 613, 614, 5, 17, 0, 0, 614, 615, 3, 52, 26, 0, 615, 616, 5, 18, 0, 0, 616, 628, 1, 0, 0, 0, 617, 618, 5, 35, 0, 0, 618, 619, 5, 30, 0, 0, 619, 620, 3, 50, 25, 0, 620, 621, 5, 31, 0, 0, 621, 622, 3, 48, 24, 0, 622, 623, 5, 36, 0, 0, 623, 624, 5, 30, 0, 0, 624, 625, 3, 292, 146, 0, 625, 626, 5, 31, 0, 0, 626, 628, 1, 0, 0, 0, 627, 593, 1, 0, 0, 0, 627, 599, 1, 0, 0, 0, 627, 607, 1, 0, 0, 0, 627, 617, 1, 0, 0, 0, 628, 47, 1, 0, 0, 0, 629, 630, 3, 168, 84, 0, 630, 49, 1, 0, 0, 0, 631, 632, 3, 124, 62, 0, 632, 633, 6, 25, -1, 0, 633, 638, 1, 0, 0, 0, 634, 635, 3, 176, 88, 0, 635, 636, 6, 25, -1, 0, 636, 638, 1, 0, 0, 0, 637, 631, 1, 0, 0, 0, 637, 634, 1, 0, 0, 0, 638, 51, 1, 0, 0, 0, 639, 640, 3, 54, 27, 0, 640, 641, 3, 56, 28, 0, 641, 53, 1, 0, 0, 0, 642, 645, 3, 298, 149, 0, 643, 645, 3, 40, 20, 0, 644, 642, 1, 0, 0, 0, 644, 643, 1, 0, 0, 0, 645, 648, 1, 0, 0, 0, 646, 644, 1, 0, 0, 0, 646, 647, 1, 0, 0, 0, 647, 55, 1, 0, 0, 0, 648, 646, 1, 0, 0, 0, 649, 650, 3, 58, 29, 0, 650, 651, 3, 60, 30, 0, 651, 652, 3, 2, 1, 0, 652, 653, 5, 36, 0, 0, 653, 654, 3, 298, 149, 0, 654, 657, 1, 0, 0, 0, 655, 657, 3, 40, 20, 0, 656, 649, 1, 0, 0, 0, 656, 655, 1, 0, 0, 0, 657, 660, 1, 0, 0, 0, 658, 656, 1, 0, 0, 0, 658, 659, 1, 0, 0, 0, 659, 57, 1, 0, 0, 0, 660, 658, 1, 0, 0, 0, 661, 662, 7, 4, 0, 0, 662, 59, 1, 0, 0, 0, 663, 665, 3, 62, 31, 0, 664, 666, 5, 261, 0, 0, 665, 664, 1, 0, 0, 0, 665, 666, 1, 0, 0, 0, 666, 61, 1, 0, 0, 0, 667, 677, 3, 144, 72, 0, 668, 677, 3, 2, 1, 0, 669, 677, 5, 196, 0, 0, 670, 677, 5, 197, 0, 0, 671, 672, 5, 202, 0, 0, 672, 673, 5, 39, 0, 0, 673, 677, 5, 264, 0, 0, 674, 675, 5, 202, 0, 0, 675, 677, 3, 116, 58, 0, 676, 667, 1, 0, 0, 0, 676, 668, 1, 0, 0, 0, 676, 669, 1, 0, 0, 0, 676, 670, 1, 0, 0, 0, 676, 671, 1, 0, 0, 0, 676, 674, 1, 0, 0, 0, 677, 63, 1, 0, 0, 0, 678, 679, 5, 198, 0, 0, 679, 680, 5, 40, 0, 0, 680, 685, 3, 2, 1, 0, 681, 682, 5, 198, 0, 0, 682, 685, 3, 2, 1, 0, 683, 685, 5, 198, 0, 0, 684, 678, 1, 0, 0, 0, 684, 681, 1, 0, 0, 0, 684, 683, 1, 0, 0, 0, 685, 65, 1, 0, 0, 0, 686, 687, 5, 41, 0, 0, 687, 688, 5, 42, 0, 0, 688, 689, 3, 32, 16, 0, 689, 690, 5, 43, 0, 0, 690, 691, 3, 68, 34, 0, 691, 692, 5, 44, 0, 0, 692, 693, 3, 0, 0, 0, 693, 67, 1, 0, 0, 0, 694, 707, 6, 34, -1, 0, 695, 696, 10, 5, 0, 0, 696, 706, 5, 186, 0, 0, 697, 698, 10, 4, 0, 0, 698, 706, 5, 187, 0, 0, 699, 700, 10, 3, 0, 0, 700, 706, 5, 45, 0, 0, 701, 702, 10, 2, 0, 0, 702, 706, 5, 46, 0, 0, 703, 704, 10, 1, 0, 0, 704, 706, 5, 47, 0, 0, 705, 695, 1, 0, 0, 0, 705, 697, 1, 0, 0, 0, 705, 699, 1, 0, 0, 0, 705, 701, 1, 0, 0, 0, 705, 703, 1, 0, 0, 0, 706, 709, 1, 0, 0, 0, 707, 705, 1, 0, 0, 0, 707, 708, 1, 0, 0, 0, 708, 69, 1, 0, 0, 0, 709, 707, 1, 0, 0, 0, 710, 711, 5, 48, 0, 0, 711, 712, 5, 36, 0, 0, 712, 713, 5, 30, 0, 0, 713, 714, 3, 292, 146, 0, 714, 715, 5, 31, 0, 0, 715, 71, 1, 0, 0, 0, 716, 717, 5, 49, 0, 0, 717, 718, 3, 2, 1, 0, 718, 73, 1, 0, 0, 0, 719, 723, 5, 50, 0, 0, 720, 722, 3, 76, 38, 0, 721, 720, 1, 0, 0, 0, 722, 725, 1, 0, 0, 0, 723, 721, 1, 0, 0, 0, 723, 724, 1, 0, 0, 0, 724, 726, 1, 0, 0, 0, 725, 723, 1, 0, 0, 0, 726, 727, 3, 2, 1, 0, 727, 728, 3, 182, 91, 0, 728, 729, 3, 78, 39, 0, 729, 730, 3, 80, 40, 0, 730, 75, 1, 0, 0, 0, 731, 769, 5, 51, 0, 0, 732, 769, 5, 52, 0, 0, 733, 769, 5, 199, 0, 0, 734, 769, 5, 202, 0, 0, 735, 769, 5, 221, 0, 0, 736, 769, 5, 53, 0, 0, 737, 769, 5, 54, 0, 0, 738, 769, 5, 55, 0, 0, 739, 769, 5, 56, 0, 0, 740, 769, 5, 244, 0, 0, 741, 769, 5, 15, 0, 0, 742, 769, 5, 224, 0, 0, 743, 769, 5, 57, 0, 0, 744, 769, 5, 58, 0, 0, 745, 769, 5, 59, 0, 0, 746, 769, 5, 60, 0, 0, 747, 769, 5, 61, 0, 0, 748, 749, 5, 62, 0, 0, 749, 769, 5, 51, 0, 0, 750, 751, 5, 62, 0, 0, 751, 769, 5, 52, 0, 0, 752, 753, 5, 62, 0, 0, 753, 769, 5, 63, 0, 0, 754, 755, 5, 62, 0, 0, 755, 769, 5, 64, 0, 0, 756, 757, 5, 62, 0, 0, 757, 769, 5, 65, 0, 0, 758, 759, 5, 62, 0, 0, 759, 769, 5, 66, 0, 0, 760, 769, 5, 67, 0, 0, 761, 769, 5, 68, 0, 0, 762, 769, 5, 69, 0, 0, 763, 764, 5, 70, 0, 0, 764, 765, 5, 30, 0, 0, 765, 766, 3, 32, 16, 0, 766, 767, 5, 31, 0, 0, 767, 769, 1, 0, 0, 0, 768, 731, 1, 0, 0, 0, 768, 732, 1, 0, 0, 0, 768, 733, 1, 0, 0, 0, 768, 734, 1, 0, 0, 0, 768, 735, 1, 0, 0, 0, 768, 736, 1, 0, 0, 0, 768, 737, 1, 0, 0, 0, 768, 738, 1, 0, 0, 0, 768, 739, 1, 0, 0, 0, 768, 740, 1, 0, 0, 0, 768, 741, 1, 0, 0, 0, 768, 742, 1, 0, 0, 0, 768, 743, 1, 0, 0, 0, 768, 744, 1, 0, 0, 0, 768, 745, 1, 0, 0, 0, 768, 746, 1, 0, 0, 0, 768, 747, 1, 0, 0, 0, 768, 748, 1, 0, 0, 0, 768, 750, 1, 0, 0, 0, 768, 752, 1, 0, 0, 0, 768, 754, 1, 0, 0, 0, 768, 756, 1, 0, 0, 0, 768, 758, 1, 0, 0, 0, 768, 760, 1, 0, 0, 0, 768, 761, 1, 0, 0, 0, 768, 762, 1, 0, 0, 0, 768, 763, 1, 0, 0, 0, 769, 77, 1, 0, 0, 0, 770, 774, 1, 0, 0, 0, 771, 772, 5, 71, 0, 0, 772, 774, 3, 124, 62, 0, 773, 770, 1, 0, 0, 0, 773, 771, 1, 0, 0, 0, 774, 79, 1, 0, 0, 0, 775, 779, 1, 0, 0, 0, 776, 777, 5, 72, 0, 0, 777, 779, 3, 84, 42, 0, 778, 775, 1, 0, 0, 0, 778, 776, 1, 0, 0, 0, 779, 81, 1, 0, 0, 0, 780, 782, 3, 198, 99, 0, 781, 780, 1, 0, 0, 0, 782, 785, 1, 0, 0, 0, 783, 781, 1, 0, 0, 0, 783, 784, 1, 0, 0, 0, 784, 83, 1, 0, 0, 0, 785, 783, 1, 0, 0, 0, 786, 787, 3, 124, 62, 0, 787, 788, 5, 28, 0, 0, 788, 790, 1, 0, 0, 0, 789, 786, 1, 0, 0, 0, 790, 793, 1, 0, 0, 0, 791, 789, 1, 0, 0, 0, 791, 792, 1, 0, 0, 0, 792, 794, 1, 0, 0, 0, 793, 791, 1, 0, 0, 0, 794, 795, 3, 124, 62, 0, 795, 85, 1, 0, 0, 0, 796, 797, 7, 5, 0, 0, 797, 87, 1, 0, 0, 0, 798, 799, 3, 86, 43, 0, 799, 800, 3, 32, 16, 0, 800, 801, 5, 264, 0, 0, 801, 902, 1, 0, 0, 0, 802, 803, 3, 86, 43, 0, 803, 804, 3, 32, 16, 0, 804, 902, 1, 0, 0, 0, 805, 806, 3, 86, 43, 0, 806, 807, 3, 32, 16, 0, 807, 808, 5, 75, 0, 0, 808, 809, 3, 32, 16, 0, 809, 810, 5, 264, 0, 0, 810, 902, 1, 0, 0, 0, 811, 812, 3, 86, 43, 0, 812, 813, 3, 32, 16, 0, 813, 814, 5, 75, 0, 0, 814, 815, 3, 32, 16, 0, 815, 902, 1, 0, 0, 0, 816, 817, 3, 86, 43, 0, 817, 818, 3, 32, 16, 0, 818, 819, 5, 75, 0, 0, 819, 820, 3, 32, 16, 0, 820, 821, 5, 28, 0, 0, 821, 822, 3, 32, 16, 0, 822, 823, 5, 264, 0, 0, 823, 902, 1, 0, 0, 0, 824, 825, 3, 86, 43, 0, 825, 826, 3, 32, 16, 0, 826, 827, 5, 75, 0, 0, 827, 828, 3, 32, 16, 0, 828, 829, 5, 28, 0, 0, 829, 830, 3, 32, 16, 0, 830, 902, 1, 0, 0, 0, 831, 832, 3, 86, 43, 0, 832, 833, 3, 32, 16, 0, 833, 834, 5, 28, 0, 0, 834, 835, 3, 32, 16, 0, 835, 836, 5, 75, 0, 0, 836, 837, 3, 32, 16, 0, 837, 838, 5, 264, 0, 0, 838, 902, 1, 0, 0, 0, 839, 840, 3, 86, 43, 0, 840, 841, 3, 32, 16, 0, 841, 842, 5, 28, 0, 0, 842, 843, 3, 32, 16, 0, 843, 844, 5, 75, 0, 0, 844, 845, 3, 32, 16, 0, 845, 902, 1, 0, 0, 0, 846, 847, 3, 86, 43, 0, 847, 848, 3, 32, 16, 0, 848, 849, 5, 28, 0, 0, 849, 850, 3, 32, 16, 0, 850, 851, 5, 75, 0, 0, 851, 852, 3, 32, 16, 0, 852, 853, 5, 28, 0, 0, 853, 854, 3, 32, 16, 0, 854, 855, 5, 264, 0, 0, 855, 902, 1, 0, 0, 0, 856, 857, 3, 86, 43, 0, 857, 858, 3, 32, 16, 0, 858, 859, 5, 28, 0, 0, 859, 860, 3, 32, 16, 0, 860, 861, 5, 75, 0, 0, 861, 862, 3, 32, 16, 0, 862, 863, 5, 28, 0, 0, 863, 864, 3, 32, 16, 0, 864, 902, 1, 0, 0, 0, 865, 866, 3, 86, 43, 0, 866, 867, 3, 32, 16, 0, 867, 868, 5, 263, 0, 0, 868, 902, 1, 0, 0, 0, 869, 870, 3, 86, 43, 0, 870, 871, 3, 32, 16, 0, 871, 872, 5, 75, 0, 0, 872, 873, 3, 32, 16, 0, 873, 874, 5, 263, 0, 0, 874, 902, 1, 0, 0, 0, 875, 876, 3, 86, 43, 0, 876, 877, 3, 32, 16, 0, 877, 878, 5, 75, 0, 0, 878, 879, 3, 32, 16, 0, 879, 880, 5, 28, 0, 0, 880, 881, 3, 32, 16, 0, 881, 882, 5, 263, 0, 0, 882, 902, 1, 0, 0, 0, 883, 884, 3, 86, 43, 0, 884, 885, 3, 32, 16, 0, 885, 886, 5, 28, 0, 0, 886, 887, 3, 32, 16, 0, 887, 888, 5, 75, 0, 0, 888, 889, 3, 32, 16, 0, 889, 890, 5, 263, 0, 0, 890, 902, 1, 0, 0, 0, 891, 892, 3, 86, 43, 0, 892, 893, 3, 32, 16, 0, 893, 894, 5, 28, 0, 0, 894, 895, 3, 32, 16, 0, 895, 896, 5, 75, 0, 0, 896, 897, 3, 32, 16, 0, 897, 898, 5, 28, 0, 0, 898, 899, 3, 32, 16, 0, 899, 900, 5, 263, 0, 0, 900, 902, 1, 0, 0, 0, 901, 798, 1, 0, 0, 0, 901, 802, 1, 0, 0, 0, 901, 805, 1, 0, 0, 0, 901, 811, 1, 0, 0, 0, 901, 816, 1, 0, 0, 0, 901, 824, 1, 0, 0, 0, 901, 831, 1, 0, 0, 0, 901, 839, 1, 0, 0, 0, 901, 846, 1, 0, 0, 0, 901, 856, 1, 0, 0, 0, 901, 865, 1, 0, 0, 0, 901, 869, 1, 0, 0, 0, 901, 875, 1, 0, 0, 0, 901, 883, 1, 0, 0, 0, 901, 891, 1, 0, 0, 0, 902, 89, 1, 0, 0, 0, 903, 907, 5, 21, 0, 0, 904, 906, 3, 92, 46, 0, 905, 904, 1, 0, 0, 0, 906, 909, 1, 0, 0, 0, 907, 905, 1, 0, 0, 0, 907, 908, 1, 0, 0, 0, 908, 910, 1, 0, 0, 0, 909, 907, 1, 0, 0, 0, 910, 911, 3, 2, 1, 0, 911, 912, 3, 94, 47, 0, 912, 913, 5, 180, 0, 0, 913, 914, 5, 36, 0, 0, 914, 915, 5, 30, 0, 0, 915, 916, 3, 292, 146, 0, 916, 917, 5, 31, 0, 0, 917, 918, 3, 94, 47, 0, 918, 930, 1, 0, 0, 0, 919, 923, 5, 21, 0, 0, 920, 922, 3, 92, 46, 0, 921, 920, 1, 0, 0, 0, 922, 925, 1, 0, 0, 0, 923, 921, 1, 0, 0, 0, 923, 924, 1, 0, 0, 0, 924, 926, 1, 0, 0, 0, 925, 923, 1, 0, 0, 0, 926, 927, 3, 2, 1, 0, 927, 928, 3, 94, 47, 0, 928, 930, 1, 0, 0, 0, 929, 903, 1, 0, 0, 0, 929, 919, 1, 0, 0, 0, 930, 91, 1, 0, 0, 0, 931, 932, 5, 76, 0, 0, 932, 93, 1, 0, 0, 0, 933, 936, 1, 0, 0, 0, 934, 936, 5, 298, 0, 0, 935, 933, 1, 0, 0, 0, 935, 934, 1, 0, 0, 0, 936, 95, 1, 0, 0, 0, 937, 938, 7, 6, 0, 0, 938, 97, 1, 0, 0, 0, 939, 941, 3, 96, 48, 0, 940, 939, 1, 0, 0, 0, 941, 944, 1, 0, 0, 0, 942, 940, 1, 0, 0, 0, 942, 943, 1, 0, 0, 0, 943, 99, 1, 0, 0, 0, 944, 942, 1, 0, 0, 0, 945, 971, 3, 102, 51, 0, 946, 947, 5, 280, 0, 0, 947, 948, 3, 168, 84, 0, 948, 949, 6, 50, -1, 0, 949, 971, 1, 0, 0, 0, 950, 951, 5, 286, 0, 0, 951, 952, 3, 178, 89, 0, 952, 953, 6, 50, -1, 0, 953, 971, 1, 0, 0, 0, 954, 955, 5, 286, 0, 0, 955, 956, 3, 174, 87, 0, 956, 957, 6, 50, -1, 0, 957, 971, 1, 0, 0, 0, 958, 959, 5, 284, 0, 0, 959, 960, 3, 124, 62, 0, 960, 961, 6, 50, -1, 0, 961, 971, 1, 0, 0, 0, 962, 963, 5, 281, 0, 0, 963, 964, 3, 104, 52, 0, 964, 965, 6, 50, -1, 0, 965, 971, 1, 0, 0, 0, 966, 967, 5, 287, 0, 0, 967, 968, 3, 50, 25, 0, 968, 969, 6, 50, -1, 0, 969, 971, 1, 0, 0, 0, 970, 945, 1, 0, 0, 0, 970, 946, 1, 0, 0, 0, 970, 950, 1, 0, 0, 0, 970, 954, 1, 0, 0, 0, 970, 958, 1, 0, 0, 0, 970, 962, 1, 0, 0, 0, 970, 966, 1, 0, 0, 0, 971, 101, 1, 0, 0, 0, 972, 973, 5, 275, 0, 0, 973, 1051, 6, 51, -1, 0, 974, 975, 5, 276, 0, 0, 975, 976, 3, 32, 16, 0, 976, 977, 6, 51, -1, 0, 977, 1051, 1, 0, 0, 0, 978, 979, 5, 276, 0, 0, 979, 980, 3, 0, 0, 0, 980, 981, 6, 51, -1, 0, 981, 1051, 1, 0, 0, 0, 982, 983, 5, 277, 0, 0, 983, 984, 3, 32, 16, 0, 984, 985, 6, 51, -1, 0, 985, 1051, 1, 0, 0, 0, 986, 987, 5, 278, 0, 0, 987, 988, 3, 34, 17, 0, 988, 989, 6, 51, -1, 0, 989, 1051, 1, 0, 0, 0, 990, 991, 5, 279, 0, 0, 991, 992, 3, 36, 18, 0, 992, 993, 6, 51, -1, 0, 993, 1051, 1, 0, 0, 0, 994, 995, 5, 279, 0, 0, 995, 996, 3, 34, 17, 0, 996, 997, 6, 51, -1, 0, 997, 1051, 1, 0, 0, 0, 998, 999, 5, 279, 0, 0, 999, 1000, 5, 30, 0, 0, 1000, 1001, 3, 292, 146, 0, 1001, 1002, 5, 31, 0, 0, 1002, 1003, 6, 51, -1, 0, 1003, 1051, 1, 0, 0, 0, 1004, 1005, 5, 279, 0, 0, 1005, 1006, 5, 84, 0, 0, 1006, 1007, 5, 30, 0, 0, 1007, 1008, 3, 292, 146, 0, 1008, 1009, 5, 31, 0, 0, 1009, 1010, 6, 51, -1, 0, 1010, 1051, 1, 0, 0, 0, 1011, 1012, 5, 282, 0, 0, 1012, 1013, 3, 32, 16, 0, 1013, 1014, 6, 51, -1, 0, 1014, 1051, 1, 0, 0, 0, 1015, 1016, 5, 282, 0, 0, 1016, 1017, 3, 0, 0, 0, 1017, 1018, 6, 51, -1, 0, 1018, 1051, 1, 0, 0, 0, 1019, 1020, 5, 285, 0, 0, 1020, 1021, 3, 6, 3, 0, 1021, 1022, 6, 51, -1, 0, 1022, 1051, 1, 0, 0, 0, 1023, 1024, 5, 285, 0, 0, 1024, 1025, 5, 224, 0, 0, 1025, 1026, 5, 30, 0, 0, 1026, 1027, 3, 6, 3, 0, 1027, 1028, 5, 31, 0, 0, 1028, 1029, 6, 51, -1, 0, 1029, 1051, 1, 0, 0, 0, 1030, 1031, 5, 285, 0, 0, 1031, 1032, 5, 84, 0, 0, 1032, 1033, 5, 30, 0, 0, 1033, 1034, 3, 292, 146, 0, 1034, 1035, 5, 31, 0, 0, 1035, 1036, 6, 51, -1, 0, 1036, 1051, 1, 0, 0, 0, 1037, 1038, 5, 287, 0, 0, 1038, 1039, 3, 32, 16, 0, 1039, 1040, 6, 51, -1, 0, 1040, 1051, 1, 0, 0, 0, 1041, 1042, 5, 283, 0, 0, 1042, 1048, 6, 51, -1, 0, 1043, 1044, 5, 30, 0, 0, 1044, 1045, 3, 106, 53, 0, 1045, 1046, 5, 31, 0, 0, 1046, 1049, 1, 0, 0, 0, 1047, 1049, 5, 85, 0, 0, 1048, 1043, 1, 0, 0, 0, 1048, 1047, 1, 0, 0, 0, 1049, 1051, 1, 0, 0, 0, 1050, 972, 1, 0, 0, 0, 1050, 974, 1, 0, 0, 0, 1050, 978, 1, 0, 0, 0, 1050, 982, 1, 0, 0, 0, 1050, 986, 1, 0, 0, 0, 1050, 990, 1, 0, 0, 0, 1050, 994, 1, 0, 0, 0, 1050, 998, 1, 0, 0, 0, 1050, 1004, 1, 0, 0, 0, 1050, 1011, 1, 0, 0, 0, 1050, 1015, 1, 0, 0, 0, 1050, 1019, 1, 0, 0, 0, 1050, 1023, 1, 0, 0, 0, 1050, 1030, 1, 0, 0, 0, 1050, 1037, 1, 0, 0, 0, 1050, 1041, 1, 0, 0, 0, 1051, 103, 1, 0, 0, 0, 1052, 1053, 3, 170, 85, 0, 1053, 1054, 3, 138, 69, 0, 1054, 1055, 3, 112, 56, 0, 1055, 1056, 6, 52, -1, 0, 1056, 105, 1, 0, 0, 0, 1057, 1082, 1, 0, 0, 0, 1058, 1059, 3, 0, 0, 0, 1059, 1060, 6, 53, -1, 0, 1060, 1065, 1, 0, 0, 0, 1061, 1062, 3, 32, 16, 0, 1062, 1063, 6, 53, -1, 0, 1063, 1065, 1, 0, 0, 0, 1064, 1058, 1, 0, 0, 0, 1064, 1061, 1, 0, 0, 0, 1065, 1066, 1, 0, 0, 0, 1066, 1067, 5, 28, 0, 0, 1067, 1069, 1, 0, 0, 0, 1068, 1064, 1, 0, 0, 0, 1069, 1072, 1, 0, 0, 0, 1070, 1068, 1, 0, 0, 0, 1070, 1071, 1, 0, 0, 0, 1071, 1079, 1, 0, 0, 0, 1072, 1070, 1, 0, 0, 0, 1073, 1074, 3, 0, 0, 0, 1074, 1075, 6, 53, -1, 0, 1075, 1080, 1, 0, 0, 0, 1076, 1077, 3, 32, 16, 0, 1077, 1078, 6, 53, -1, 0, 1078, 1080, 1, 0, 0, 0, 1079, 1073, 1, 0, 0, 0, 1079, 1076, 1, 0, 0, 0, 1080, 1082, 1, 0, 0, 0, 1081, 1057, 1, 0, 0, 0, 1081, 1070, 1, 0, 0, 0, 1082, 107, 1, 0, 0, 0, 1083, 1090, 5, 86, 0, 0, 1084, 1085, 3, 138, 69, 0, 1085, 1086, 6, 54, -1, 0, 1086, 1087, 5, 28, 0, 0, 1087, 1089, 1, 0, 0, 0, 1088, 1084, 1, 0, 0, 0, 1089, 1092, 1, 0, 0, 0, 1090, 1088, 1, 0, 0, 0, 1090, 1091, 1, 0, 0, 0, 1091, 1093, 1, 0, 0, 0, 1092, 1090, 1, 0, 0, 0, 1093, 1094, 3, 138, 69, 0, 1094, 1095, 6, 54, -1, 0, 1095, 1096, 5, 87, 0, 0, 1096, 109, 1, 0, 0, 0, 1097, 1104, 5, 42, 0, 0, 1098, 1099, 3, 146, 73, 0, 1099, 1100, 6, 55, -1, 0, 1100, 1101, 5, 28, 0, 0, 1101, 1103, 1, 0, 0, 0, 1102, 1098, 1, 0, 0, 0, 1103, 1106, 1, 0, 0, 0, 1104, 1102, 1, 0, 0, 0, 1104, 1105, 1, 0, 0, 0, 1105, 1107, 1, 0, 0, 0, 1106, 1104, 1, 0, 0, 0, 1107, 1108, 3, 146, 73, 0, 1108, 1109, 6, 55, -1, 0, 1109, 1110, 5, 43, 0, 0, 1110, 111, 1, 0, 0, 0, 1111, 1118, 5, 30, 0, 0, 1112, 1113, 3, 114, 57, 0, 1113, 1114, 6, 56, -1, 0, 1114, 1115, 5, 28, 0, 0, 1115, 1117, 1, 0, 0, 0, 1116, 1112, 1, 0, 0, 0, 1117, 1120, 1, 0, 0, 0, 1118, 1116, 1, 0, 0, 0, 1118, 1119, 1, 0, 0, 0, 1119, 1121, 1, 0, 0, 0, 1120, 1118, 1, 0, 0, 0, 1121, 1122, 3, 114, 57, 0, 1122, 1123, 6, 56, -1, 0, 1123, 1124, 5, 31, 0, 0, 1124, 1127, 1, 0, 0, 0, 1125, 1127, 5, 85, 0, 0, 1126, 1111, 1, 0, 0, 0, 1126, 1125, 1, 0, 0, 0, 1127, 113, 1, 0, 0, 0, 1128, 1129, 5, 177, 0, 0, 1129, 1139, 6, 57, -1, 0, 1130, 1131, 3, 230, 115, 0, 1131, 1132, 3, 138, 69, 0, 1132, 1134, 3, 226, 113, 0, 1133, 1135, 3, 0, 0, 0, 1134, 1133, 1, 0, 0, 0, 1134, 1135, 1, 0, 0, 0, 1135, 1136, 1, 0, 0, 0, 1136, 1137, 6, 57, -1, 0, 1137, 1139, 1, 0, 0, 0, 1138, 1128, 1, 0, 0, 0, 1138, 1130, 1, 0, 0, 0, 1139, 115, 1, 0, 0, 0, 1140, 1141, 5, 42, 0, 0, 1141, 1142, 3, 2, 1, 0, 1142, 1143, 5, 43, 0, 0, 1143, 1144, 3, 118, 59, 0, 1144, 1145, 6, 58, -1, 0, 1145, 1178, 1, 0, 0, 0, 1146, 1147, 5, 42, 0, 0, 1147, 1148, 3, 174, 87, 0, 1148, 1149, 5, 43, 0, 0, 1149, 1150, 3, 118, 59, 0, 1150, 1151, 6, 58, -1, 0, 1151, 1178, 1, 0, 0, 0, 1152, 1153, 5, 42, 0, 0, 1153, 1154, 5, 262, 0, 0, 1154, 1155, 5, 43, 0, 0, 1155, 1156, 3, 118, 59, 0, 1156, 1157, 6, 58, -1, 0, 1157, 1178, 1, 0, 0, 0, 1158, 1159, 5, 42, 0, 0, 1159, 1160, 5, 198, 0, 0, 1160, 1161, 3, 2, 1, 0, 1161, 1162, 5, 43, 0, 0, 1162, 1163, 3, 118, 59, 0, 1163, 1164, 6, 58, -1, 0, 1164, 1178, 1, 0, 0, 0, 1165, 1166, 3, 118, 59, 0, 1166, 1167, 6, 58, -1, 0, 1167, 1178, 1, 0, 0, 0, 1168, 1169, 3, 174, 87, 0, 1169, 1170, 6, 58, -1, 0, 1170, 1178, 1, 0, 0, 0, 1171, 1172, 5, 257, 0, 0, 1172, 1178, 6, 58, -1, 0, 1173, 1174, 5, 258, 0, 0, 1174, 1178, 6, 58, -1, 0, 1175, 1176, 5, 259, 0, 0, 1176, 1178, 6, 58, -1, 0, 1177, 1140, 1, 0, 0, 0, 1177, 1146, 1, 0, 0, 0, 1177, 1152, 1, 0, 0, 0, 1177, 1158, 1, 0, 0, 0, 1177, 1165, 1, 0, 0, 0, 1177, 1168, 1, 0, 0, 0, 1177, 1171, 1, 0, 0, 0, 1177, 1173, 1, 0, 0, 0, 1177, 1175, 1, 0, 0, 0, 1178, 117, 1, 0, 0, 0, 1179, 1180, 3, 2, 1, 0, 1180, 1181, 6, 59, -1, 0, 1181, 1182, 5, 88, 0, 0, 1182, 1184, 1, 0, 0, 0, 1183, 1179, 1, 0, 0, 0, 1184, 1187, 1, 0, 0, 0, 1185, 1183, 1, 0, 0, 0, 1185, 1186, 1, 0, 0, 0, 1186, 1188, 1, 0, 0, 0, 1187, 1185, 1, 0, 0, 0, 1188, 1189, 3, 2, 1, 0, 1189, 1190, 6, 59, -1, 0, 1190, 119, 1, 0, 0, 0, 1191, 1193, 3, 122, 61, 0, 1192, 1191, 1, 0, 0, 0, 1193, 1196, 1, 0, 0, 0, 1194, 1192, 1, 0, 0, 0, 1194, 1195, 1, 0, 0, 0, 1195, 121, 1, 0, 0, 0, 1196, 1194, 1, 0, 0, 0, 1197, 1198, 5, 180, 0, 0, 1198, 1199, 5, 89, 0, 0, 1199, 1203, 3, 32, 16, 0, 1200, 1203, 3, 152, 76, 0, 1201, 1203, 3, 324, 162, 0, 1202, 1197, 1, 0, 0, 0, 1202, 1200, 1, 0, 0, 0, 1202, 1201, 1, 0, 0, 0, 1203, 123, 1, 0, 0, 0, 1204, 1205, 3, 116, 58, 0, 1205, 1206, 6, 62, -1, 0, 1206, 1222, 1, 0, 0, 0, 1207, 1208, 5, 42, 0, 0, 1208, 1209, 3, 2, 1, 0, 1209, 1210, 5, 43, 0, 0, 1210, 1211, 6, 62, -1, 0, 1211, 1222, 1, 0, 0, 0, 1212, 1213, 5, 42, 0, 0, 1213, 1214, 5, 198, 0, 0, 1214, 1215, 3, 2, 1, 0, 1215, 1216, 5, 43, 0, 0, 1216, 1217, 6, 62, -1, 0, 1217, 1222, 1, 0, 0, 0, 1218, 1219, 3, 138, 69, 0, 1219, 1220, 6, 62, -1, 0, 1220, 1222, 1, 0, 0, 0, 1221, 1204, 1, 0, 0, 0, 1221, 1207, 1, 0, 0, 0, 1221, 1212, 1, 0, 0, 0, 1221, 1218, 1, 0, 0, 0, 1222, 125, 1, 0, 0, 0, 1223, 1235, 1, 0, 0, 0, 1224, 1225, 3, 130, 65, 0, 1225, 1231, 6, 63, -1, 0, 1226, 1227, 3, 128, 64, 0, 1227, 1228, 6, 63, -1, 0, 1228, 1230, 1, 0, 0, 0, 1229, 1226, 1, 0, 0, 0, 1230, 1233, 1, 0, 0, 0, 1231, 1229, 1, 0, 0, 0, 1231, 1232, 1, 0, 0, 0, 1232, 1235, 1, 0, 0, 0, 1233, 1231, 1, 0, 0, 0, 1234, 1223, 1, 0, 0, 0, 1234, 1224, 1, 0, 0, 0, 1235, 127, 1, 0, 0, 0, 1236, 1237, 5, 262, 0, 0, 1237, 1259, 6, 64, -1, 0, 1238, 1239, 5, 261, 0, 0, 1239, 1259, 6, 64, -1, 0, 1240, 1241, 5, 42, 0, 0, 1241, 1242, 3, 32, 16, 0, 1242, 1243, 5, 43, 0, 0, 1243, 1244, 6, 64, -1, 0, 1244, 1259, 1, 0, 0, 0, 1245, 1246, 5, 42, 0, 0, 1246, 1247, 3, 32, 16, 0, 1247, 1248, 5, 266, 0, 0, 1248, 1249, 3, 32, 16, 0, 1249, 1250, 5, 43, 0, 0, 1250, 1251, 6, 64, -1, 0, 1251, 1259, 1, 0, 0, 0, 1252, 1253, 5, 42, 0, 0, 1253, 1254, 5, 266, 0, 0, 1254, 1255, 3, 32, 16, 0, 1255, 1256, 5, 43, 0, 0, 1256, 1257, 6, 64, -1, 0, 1257, 1259, 1, 0, 0, 0, 1258, 1236, 1, 0, 0, 0, 1258, 1238, 1, 0, 0, 0, 1258, 1240, 1, 0, 0, 0, 1258, 1245, 1, 0, 0, 0, 1258, 1252, 1, 0, 0, 0, 1259, 129, 1, 0, 0, 0, 1260, 1406, 6, 65, -1, 0, 1261, 1262, 5, 203, 0, 0, 1262, 1263, 5, 30, 0, 0, 1263, 1264, 3, 6, 3, 0, 1264, 1265, 5, 28, 0, 0, 1265, 1266, 3, 6, 3, 0, 1266, 1267, 5, 28, 0, 0, 1267, 1268, 3, 6, 3, 0, 1268, 1269, 5, 28, 0, 0, 1269, 1270, 3, 6, 3, 0, 1270, 1271, 5, 31, 0, 0, 1271, 1272, 6, 65, -1, 0, 1272, 1406, 1, 0, 0, 0, 1273, 1274, 5, 203, 0, 0, 1274, 1275, 5, 30, 0, 0, 1275, 1276, 3, 6, 3, 0, 1276, 1277, 5, 28, 0, 0, 1277, 1278, 3, 6, 3, 0, 1278, 1279, 5, 31, 0, 0, 1279, 1280, 6, 65, -1, 0, 1280, 1406, 1, 0, 0, 0, 1281, 1282, 5, 204, 0, 0, 1282, 1283, 5, 205, 0, 0, 1283, 1284, 5, 42, 0, 0, 1284, 1285, 3, 32, 16, 0, 1285, 1286, 5, 43, 0, 0, 1286, 1287, 6, 65, -1, 0, 1287, 1406, 1, 0, 0, 0, 1288, 1289, 5, 204, 0, 0, 1289, 1290, 5, 206, 0, 0, 1290, 1291, 5, 42, 0, 0, 1291, 1292, 3, 32, 16, 0, 1292, 1293, 5, 43, 0, 0, 1293, 1294, 3, 126, 63, 0, 1294, 1295, 6, 65, -1, 0, 1295, 1406, 1, 0, 0, 0, 1296, 1297, 5, 207, 0, 0, 1297, 1406, 6, 65, -1, 0, 1298, 1299, 5, 208, 0, 0, 1299, 1406, 6, 65, -1, 0, 1300, 1301, 5, 209, 0, 0, 1301, 1406, 6, 65, -1, 0, 1302, 1303, 5, 201, 0, 0, 1303, 1406, 6, 65, -1, 0, 1304, 1305, 5, 183, 0, 0, 1305, 1406, 6, 65, -1, 0, 1306, 1307, 5, 184, 0, 0, 1307, 1406, 6, 65, -1, 0, 1308, 1309, 5, 185, 0, 0, 1309, 1406, 6, 65, -1, 0, 1310, 1311, 5, 186, 0, 0, 1311, 1406, 6, 65, -1, 0, 1312, 1313, 5, 187, 0, 0, 1313, 1406, 6, 65, -1, 0, 1314, 1315, 5, 188, 0, 0, 1315, 1406, 6, 65, -1, 0, 1316, 1317, 5, 189, 0, 0, 1317, 1406, 6, 65, -1, 0, 1318, 1319, 5, 210, 0, 0, 1319, 1406, 6, 65, -1, 0, 1320, 1321, 5, 190, 0, 0, 1321, 1406, 6, 65, -1, 0, 1322, 1323, 5, 191, 0, 0, 1323, 1406, 6, 65, -1, 0, 1324, 1325, 5, 192, 0, 0, 1325, 1406, 6, 65, -1, 0, 1326, 1327, 5, 193, 0, 0, 1327, 1406, 6, 65, -1, 0, 1328, 1329, 5, 211, 0, 0, 1329, 1406, 6, 65, -1, 0, 1330, 1331, 5, 212, 0, 0, 1331, 1406, 6, 65, -1, 0, 1332, 1333, 5, 213, 0, 0, 1333, 1406, 6, 65, -1, 0, 1334, 1335, 5, 214, 0, 0, 1335, 1406, 6, 65, -1, 0, 1336, 1337, 5, 215, 0, 0, 1337, 1406, 6, 65, -1, 0, 1338, 1339, 5, 216, 0, 0, 1339, 1406, 6, 65, -1, 0, 1340, 1341, 5, 217, 0, 0, 1341, 1406, 6, 65, -1, 0, 1342, 1343, 5, 218, 0, 0, 1343, 1344, 3, 132, 66, 0, 1344, 1345, 6, 65, -1, 0, 1345, 1406, 1, 0, 0, 0, 1346, 1347, 5, 219, 0, 0, 1347, 1348, 3, 132, 66, 0, 1348, 1349, 6, 65, -1, 0, 1349, 1406, 1, 0, 0, 0, 1350, 1351, 5, 220, 0, 0, 1351, 1406, 6, 65, -1, 0, 1352, 1353, 5, 221, 0, 0, 1353, 1354, 3, 132, 66, 0, 1354, 1355, 6, 65, -1, 0, 1355, 1406, 1, 0, 0, 0, 1356, 1357, 5, 222, 0, 0, 1357, 1358, 3, 134, 67, 0, 1358, 1359, 6, 65, -1, 0, 1359, 1406, 1, 0, 0, 0, 1360, 1361, 5, 222, 0, 0, 1361, 1362, 3, 134, 67, 0, 1362, 1363, 5, 28, 0, 0, 1363, 1364, 3, 6, 3, 0, 1364, 1365, 6, 65, -1, 0, 1365, 1406, 1, 0, 0, 0, 1366, 1367, 5, 194, 0, 0, 1367, 1406, 6, 65, -1, 0, 1368, 1369, 5, 195, 0, 0, 1369, 1406, 6, 65, -1, 0, 1370, 1371, 5, 90, 0, 0, 1371, 1372, 5, 184, 0, 0, 1372, 1406, 6, 65, -1, 0, 1373, 1374, 5, 90, 0, 0, 1374, 1375, 5, 185, 0, 0, 1375, 1406, 6, 65, -1, 0, 1376, 1377, 5, 90, 0, 0, 1377, 1378, 5, 186, 0, 0, 1378, 1406, 6, 65, -1, 0, 1379, 1380, 5, 90, 0, 0, 1380, 1381, 5, 187, 0, 0, 1381, 1406, 6, 65, -1, 0, 1382, 1383, 5, 62, 0, 0, 1383, 1384, 5, 220, 0, 0, 1384, 1406, 6, 65, -1, 0, 1385, 1386, 5, 223, 0, 0, 1386, 1406, 6, 65, -1, 0, 1387, 1388, 5, 224, 0, 0, 1388, 1389, 5, 213, 0, 0, 1389, 1406, 6, 65, -1, 0, 1390, 1391, 5, 225, 0, 0, 1391, 1406, 6, 65, -1, 0, 1392, 1393, 5, 207, 0, 0, 1393, 1394, 5, 183, 0, 0, 1394, 1406, 6, 65, -1, 0, 1395, 1396, 5, 226, 0, 0, 1396, 1406, 6, 65, -1, 0, 1397, 1398, 5, 228, 0, 0, 1398, 1406, 6, 65, -1, 0, 1399, 1400, 5, 34, 0, 0, 1400, 1401, 5, 227, 0, 0, 1401, 1406, 6, 65, -1, 0, 1402, 1403, 3, 2, 1, 0, 1403, 1404, 6, 65, -1, 0, 1404, 1406, 1, 0, 0, 0, 1405, 1260, 1, 0, 0, 0, 1405, 1261, 1, 0, 0, 0, 1405, 1273, 1, 0, 0, 0, 1405, 1281, 1, 0, 0, 0, 1405, 1288, 1, 0, 0, 0, 1405, 1296, 1, 0, 0, 0, 1405, 1298, 1, 0, 0, 0, 1405, 1300, 1, 0, 0, 0, 1405, 1302, 1, 0, 0, 0, 1405, 1304, 1, 0, 0, 0, 1405, 1306, 1, 0, 0, 0, 1405, 1308, 1, 0, 0, 0, 1405, 1310, 1, 0, 0, 0, 1405, 1312, 1, 0, 0, 0, 1405, 1314, 1, 0, 0, 0, 1405, 1316, 1, 0, 0, 0, 1405, 1318, 1, 0, 0, 0, 1405, 1320, 1, 0, 0, 0, 1405, 1322, 1, 0, 0, 0, 1405, 1324, 1, 0, 0, 0, 1405, 1326, 1, 0, 0, 0, 1405, 1328, 1, 0, 0, 0, 1405, 1330, 1, 0, 0, 0, 1405, 1332, 1, 0, 0, 0, 1405, 1334, 1, 0, 0, 0, 1405, 1336, 1, 0, 0, 0, 1405, 1338, 1, 0, 0, 0, 1405, 1340, 1, 0, 0, 0, 1405, 1342, 1, 0, 0, 0, 1405, 1346, 1, 0, 0, 0, 1405, 1350, 1, 0, 0, 0, 1405, 1352, 1, 0, 0, 0, 1405, 1356, 1, 0, 0, 0, 1405, 1360, 1, 0, 0, 0, 1405, 1366, 1, 0, 0, 0, 1405, 1368, 1, 0, 0, 0, 1405, 1370, 1, 0, 0, 0, 1405, 1373, 1, 0, 0, 0, 1405, 1376, 1, 0, 0, 0, 1405, 1379, 1, 0, 0, 0, 1405, 1382, 1, 0, 0, 0, 1405, 1385, 1, 0, 0, 0, 1405, 1387, 1, 0, 0, 0, 1405, 1390, 1, 0, 0, 0, 1405, 1392, 1, 0, 0, 0, 1405, 1395, 1, 0, 0, 0, 1405, 1397, 1, 0, 0, 0, 1405, 1399, 1, 0, 0, 0, 1405, 1402, 1, 0, 0, 0, 1406, 131, 1, 0, 0, 0, 1407, 1416, 1, 0, 0, 0, 1408, 1409, 5, 30, 0, 0, 1409, 1410, 5, 91, 0, 0, 1410, 1411, 5, 36, 0, 0, 1411, 1412, 3, 32, 16, 0, 1412, 1413, 5, 31, 0, 0, 1413, 1414, 6, 66, -1, 0, 1414, 1416, 1, 0, 0, 0, 1415, 1407, 1, 0, 0, 0, 1415, 1408, 1, 0, 0, 0, 1416, 133, 1, 0, 0, 0, 1417, 1428, 1, 0, 0, 0, 1418, 1419, 3, 136, 68, 0, 1419, 1424, 6, 67, -1, 0, 1420, 1421, 7, 7, 0, 0, 1421, 1423, 6, 67, -1, 0, 1422, 1420, 1, 0, 0, 0, 1423, 1426, 1, 0, 0, 0, 1424, 1422, 1, 0, 0, 0, 1424, 1425, 1, 0, 0, 0, 1425, 1428, 1, 0, 0, 0, 1426, 1424, 1, 0, 0, 0, 1427, 1417, 1, 0, 0, 0, 1427, 1418, 1, 0, 0, 0, 1428, 135, 1, 0, 0, 0, 1429, 1430, 5, 178, 0, 0, 1430, 1510, 6, 68, -1, 0, 1431, 1432, 5, 207, 0, 0, 1432, 1510, 6, 68, -1, 0, 1433, 1434, 5, 208, 0, 0, 1434, 1510, 6, 68, -1, 0, 1435, 1436, 5, 201, 0, 0, 1436, 1510, 6, 68, -1, 0, 1437, 1438, 5, 183, 0, 0, 1438, 1510, 6, 68, -1, 0, 1439, 1440, 5, 184, 0, 0, 1440, 1510, 6, 68, -1, 0, 1441, 1442, 5, 185, 0, 0, 1442, 1510, 6, 68, -1, 0, 1443, 1444, 5, 186, 0, 0, 1444, 1510, 6, 68, -1, 0, 1445, 1446, 5, 187, 0, 0, 1446, 1510, 6, 68, -1, 0, 1447, 1448, 5, 188, 0, 0, 1448, 1510, 6, 68, -1, 0, 1449, 1450, 5, 189, 0, 0, 1450, 1510, 6, 68, -1, 0, 1451, 1452, 5, 190, 0, 0, 1452, 1510, 6, 68, -1, 0, 1453, 1454, 5, 191, 0, 0, 1454, 1510, 6, 68, -1, 0, 1455, 1456, 5, 192, 0, 0, 1456, 1510, 6, 68, -1, 0, 1457, 1458, 5, 193, 0, 0, 1458, 1510, 6, 68, -1, 0, 1459, 1460, 5, 262, 0, 0, 1460, 1510, 6, 68, -1, 0, 1461, 1462, 5, 211, 0, 0, 1462, 1510, 6, 68, -1, 0, 1463, 1464, 5, 212, 0, 0, 1464, 1510, 6, 68, -1, 0, 1465, 1466, 5, 213, 0, 0, 1466, 1510, 6, 68, -1, 0, 1467, 1468, 5, 214, 0, 0, 1468, 1510, 6, 68, -1, 0, 1469, 1470, 5, 215, 0, 0, 1470, 1510, 6, 68, -1, 0, 1471, 1472, 5, 218, 0, 0, 1472, 1510, 6, 68, -1, 0, 1473, 1474, 5, 219, 0, 0, 1474, 1510, 6, 68, -1, 0, 1475, 1476, 5, 222, 0, 0, 1476, 1510, 6, 68, -1, 0, 1477, 1478, 5, 194, 0, 0, 1478, 1510, 6, 68, -1, 0, 1479, 1480, 5, 195, 0, 0, 1480, 1510, 6, 68, -1, 0, 1481, 1482, 5, 210, 0, 0, 1482, 1510, 6, 68, -1, 0, 1483, 1484, 5, 230, 0, 0, 1484, 1510, 6, 68, -1, 0, 1485, 1486, 5, 231, 0, 0, 1486, 1510, 6, 68, -1, 0, 1487, 1488, 5, 232, 0, 0, 1488, 1510, 6, 68, -1, 0, 1489, 1490, 5, 233, 0, 0, 1490, 1510, 6, 68, -1, 0, 1491, 1492, 5, 234, 0, 0, 1492, 1510, 6, 68, -1, 0, 1493, 1494, 5, 235, 0, 0, 1494, 1510, 6, 68, -1, 0, 1495, 1496, 5, 236, 0, 0, 1496, 1510, 6, 68, -1, 0, 1497, 1498, 5, 237, 0, 0, 1498, 1510, 6, 68, -1, 0, 1499, 1500, 5, 238, 0, 0, 1500, 1510, 6, 68, -1, 0, 1501, 1502, 5, 239, 0, 0, 1502, 1510, 6, 68, -1, 0, 1503, 1504, 5, 240, 0, 0, 1504, 1510, 6, 68, -1, 0, 1505, 1506, 5, 241, 0, 0, 1506, 1510, 6, 68, -1, 0, 1507, 1508, 5, 242, 0, 0, 1508, 1510, 6, 68, -1, 0, 1509, 1429, 1, 0, 0, 0, 1509, 1431, 1, 0, 0, 0, 1509, 1433, 1, 0, 0, 0, 1509, 1435, 1, 0, 0, 0, 1509, 1437, 1, 0, 0, 0, 1509, 1439, 1, 0, 0, 0, 1509, 1441, 1, 0, 0, 0, 1509, 1443, 1, 0, 0, 0, 1509, 1445, 1, 0, 0, 0, 1509, 1447, 1, 0, 0, 0, 1509, 1449, 1, 0, 0, 0, 1509, 1451, 1, 0, 0, 0, 1509, 1453, 1, 0, 0, 0, 1509, 1455, 1, 0, 0, 0, 1509, 1457, 1, 0, 0, 0, 1509, 1459, 1, 0, 0, 0, 1509, 1461, 1, 0, 0, 0, 1509, 1463, 1, 0, 0, 0, 1509, 1465, 1, 0, 0, 0, 1509, 1467, 1, 0, 0, 0, 1509, 1469, 1, 0, 0, 0, 1509, 1471, 1, 0, 0, 0, 1509, 1473, 1, 0, 0, 0, 1509, 1475, 1, 0, 0, 0, 1509, 1477, 1, 0, 0, 0, 1509, 1479, 1, 0, 0, 0, 1509, 1481, 1, 0, 0, 0, 1509, 1483, 1, 0, 0, 0, 1509, 1485, 1, 0, 0, 0, 1509, 1487, 1, 0, 0, 0, 1509, 1489, 1, 0, 0, 0, 1509, 1491, 1, 0, 0, 0, 1509, 1493, 1, 0, 0, 0, 1509, 1495, 1, 0, 0, 0, 1509, 1497, 1, 0, 0, 0, 1509, 1499, 1, 0, 0, 0, 1509, 1501, 1, 0, 0, 0, 1509, 1503, 1, 0, 0, 0, 1509, 1505, 1, 0, 0, 0, 1509, 1507, 1, 0, 0, 0, 1510, 137, 1, 0, 0, 0, 1511, 1512, 3, 142, 71, 0, 1512, 1518, 6, 69, -1, 0, 1513, 1514, 3, 140, 70, 0, 1514, 1515, 6, 69, -1, 0, 1515, 1517, 1, 0, 0, 0, 1516, 1513, 1, 0, 0, 0, 1517, 1520, 1, 0, 0, 0, 1518, 1516, 1, 0, 0, 0, 1518, 1519, 1, 0, 0, 0, 1519, 139, 1, 0, 0, 0, 1520, 1518, 1, 0, 0, 0, 1521, 1522, 5, 261, 0, 0, 1522, 1551, 6, 70, -1, 0, 1523, 1524, 5, 42, 0, 0, 1524, 1525, 5, 43, 0, 0, 1525, 1551, 6, 70, -1, 0, 1526, 1527, 3, 110, 55, 0, 1527, 1528, 6, 70, -1, 0, 1528, 1551, 1, 0, 0, 0, 1529, 1530, 5, 260, 0, 0, 1530, 1551, 6, 70, -1, 0, 1531, 1532, 5, 262, 0, 0, 1532, 1551, 6, 70, -1, 0, 1533, 1534, 5, 92, 0, 0, 1534, 1551, 6, 70, -1, 0, 1535, 1536, 5, 93, 0, 0, 1536, 1537, 5, 30, 0, 0, 1537, 1538, 3, 124, 62, 0, 1538, 1539, 5, 31, 0, 0, 1539, 1540, 6, 70, -1, 0, 1540, 1551, 1, 0, 0, 0, 1541, 1542, 5, 94, 0, 0, 1542, 1543, 5, 30, 0, 0, 1543, 1544, 3, 124, 62, 0, 1544, 1545, 5, 31, 0, 0, 1545, 1546, 6, 70, -1, 0, 1546, 1551, 1, 0, 0, 0, 1547, 1548, 3, 108, 54, 0, 1548, 1549, 6, 70, -1, 0, 1549, 1551, 1, 0, 0, 0, 1550, 1521, 1, 0, 0, 0, 1550, 1523, 1, 0, 0, 0, 1550, 1526, 1, 0, 0, 0, 1550, 1529, 1, 0, 0, 0, 1550, 1531, 1, 0, 0, 0, 1550, 1533, 1, 0, 0, 0, 1550, 1535, 1, 0, 0, 0, 1550, 1541, 1, 0, 0, 0, 1550, 1547, 1, 0, 0, 0, 1551, 141, 1, 0, 0, 0, 1552, 1553, 5, 39, 0, 0, 1553, 1554, 3, 116, 58, 0, 1554, 1555, 6, 71, -1, 0, 1555, 1611, 1, 0, 0, 0, 1556, 1557, 5, 197, 0, 0, 1557, 1611, 6, 71, -1, 0, 1558, 1559, 5, 199, 0, 0, 1559, 1560, 5, 39, 0, 0, 1560, 1561, 3, 116, 58, 0, 1561, 1562, 6, 71, -1, 0, 1562, 1611, 1, 0, 0, 0, 1563, 1564, 5, 200, 0, 0, 1564, 1565, 3, 116, 58, 0, 1565, 1566, 6, 71, -1, 0, 1566, 1611, 1, 0, 0, 0, 1567, 1568, 5, 226, 0, 0, 1568, 1569, 3, 170, 85, 0, 1569, 1570, 3, 138, 69, 0, 1570, 1571, 5, 262, 0, 0, 1571, 1572, 3, 112, 56, 0, 1572, 1573, 6, 71, -1, 0, 1573, 1611, 1, 0, 0, 0, 1574, 1575, 5, 253, 0, 0, 1575, 1576, 3, 32, 16, 0, 1576, 1577, 6, 71, -1, 0, 1577, 1611, 1, 0, 0, 0, 1578, 1579, 5, 252, 0, 0, 1579, 1580, 3, 32, 16, 0, 1580, 1581, 6, 71, -1, 0, 1581, 1611, 1, 0, 0, 0, 1582, 1583, 5, 253, 0, 0, 1583, 1584, 3, 2, 1, 0, 1584, 1585, 6, 71, -1, 0, 1585, 1611, 1, 0, 0, 0, 1586, 1587, 5, 252, 0, 0, 1587, 1588, 3, 2, 1, 0, 1588, 1589, 6, 71, -1, 0, 1589, 1611, 1, 0, 0, 0, 1590, 1591, 5, 254, 0, 0, 1591, 1611, 6, 71, -1, 0, 1592, 1593, 5, 201, 0, 0, 1593, 1611, 6, 71, -1, 0, 1594, 1595, 3, 148, 74, 0, 1595, 1596, 6, 71, -1, 0, 1596, 1611, 1, 0, 0, 0, 1597, 1598, 3, 150, 75, 0, 1598, 1599, 6, 71, -1, 0, 1599, 1611, 1, 0, 0, 0, 1600, 1601, 3, 144, 72, 0, 1601, 1602, 6, 71, -1, 0, 1602, 1611, 1, 0, 0, 0, 1603, 1604, 3, 2, 1, 0, 1604, 1605, 6, 71, -1, 0, 1605, 1611, 1, 0, 0, 0, 1606, 1607, 5, 177, 0, 0, 1607, 1608, 3, 138, 69, 0, 1608, 1609, 6, 71, -1, 0, 1609, 1611, 1, 0, 0, 0, 1610, 1552, 1, 0, 0, 0, 1610, 1556, 1, 0, 0, 0, 1610, 1558, 1, 0, 0, 0, 1610, 1563, 1, 0, 0, 0, 1610, 1567, 1, 0, 0, 0, 1610, 1574, 1, 0, 0, 0, 1610, 1578, 1, 0, 0, 0, 1610, 1582, 1, 0, 0, 0, 1610, 1586, 1, 0, 0, 0, 1610, 1590, 1, 0, 0, 0, 1610, 1592, 1, 0, 0, 0, 1610, 1594, 1, 0, 0, 0, 1610, 1597, 1, 0, 0, 0, 1610, 1600, 1, 0, 0, 0, 1610, 1603, 1, 0, 0, 0, 1610, 1606, 1, 0, 0, 0, 1611, 143, 1, 0, 0, 0, 1612, 1613, 5, 181, 0, 0, 1613, 1651, 6, 72, -1, 0, 1614, 1615, 5, 182, 0, 0, 1615, 1651, 6, 72, -1, 0, 1616, 1617, 5, 183, 0, 0, 1617, 1651, 6, 72, -1, 0, 1618, 1619, 5, 184, 0, 0, 1619, 1651, 6, 72, -1, 0, 1620, 1621, 5, 185, 0, 0, 1621, 1651, 6, 72, -1, 0, 1622, 1623, 5, 186, 0, 0, 1623, 1651, 6, 72, -1, 0, 1624, 1625, 5, 187, 0, 0, 1625, 1651, 6, 72, -1, 0, 1626, 1627, 5, 188, 0, 0, 1627, 1651, 6, 72, -1, 0, 1628, 1629, 5, 189, 0, 0, 1629, 1651, 6, 72, -1, 0, 1630, 1631, 5, 190, 0, 0, 1631, 1651, 6, 72, -1, 0, 1632, 1633, 5, 191, 0, 0, 1633, 1651, 6, 72, -1, 0, 1634, 1635, 5, 192, 0, 0, 1635, 1651, 6, 72, -1, 0, 1636, 1637, 5, 193, 0, 0, 1637, 1651, 6, 72, -1, 0, 1638, 1639, 5, 90, 0, 0, 1639, 1640, 5, 184, 0, 0, 1640, 1651, 6, 72, -1, 0, 1641, 1642, 5, 90, 0, 0, 1642, 1643, 5, 185, 0, 0, 1643, 1651, 6, 72, -1, 0, 1644, 1645, 5, 90, 0, 0, 1645, 1646, 5, 186, 0, 0, 1646, 1651, 6, 72, -1, 0, 1647, 1648, 5, 90, 0, 0, 1648, 1649, 5, 187, 0, 0, 1649, 1651, 6, 72, -1, 0, 1650, 1612, 1, 0, 0, 0, 1650, 1614, 1, 0, 0, 0, 1650, 1616, 1, 0, 0, 0, 1650, 1618, 1, 0, 0, 0, 1650, 1620, 1, 0, 0, 0, 1650, 1622, 1, 0, 0, 0, 1650, 1624, 1, 0, 0, 0, 1650, 1626, 1, 0, 0, 0, 1650, 1628, 1, 0, 0, 0, 1650, 1630, 1, 0, 0, 0, 1650, 1632, 1, 0, 0, 0, 1650, 1634, 1, 0, 0, 0, 1650, 1636, 1, 0, 0, 0, 1650, 1638, 1, 0, 0, 0, 1650, 1641, 1, 0, 0, 0, 1650, 1644, 1, 0, 0, 0, 1650, 1647, 1, 0, 0, 0, 1651, 145, 1, 0, 0, 0, 1652, 1667, 1, 0, 0, 0, 1653, 1667, 5, 177, 0, 0, 1654, 1655, 3, 32, 16, 0, 1655, 1656, 6, 73, -1, 0, 1656, 1667, 1, 0, 0, 0, 1657, 1658, 3, 32, 16, 0, 1658, 1659, 5, 177, 0, 0, 1659, 1660, 3, 32, 16, 0, 1660, 1661, 6, 73, -1, 0, 1661, 1667, 1, 0, 0, 0, 1662, 1663, 3, 32, 16, 0, 1663, 1664, 5, 177, 0, 0, 1664, 1665, 6, 73, -1, 0, 1665, 1667, 1, 0, 0, 0, 1666, 1652, 1, 0, 0, 0, 1666, 1653, 1, 0, 0, 0, 1666, 1654, 1, 0, 0, 0, 1666, 1657, 1, 0, 0, 0, 1666, 1662, 1, 0, 0, 0, 1667, 147, 1, 0, 0, 0, 1668, 1669, 5, 1, 0, 0, 1669, 1670, 5, 194, 0, 0, 1670, 1671, 6, 74, -1, 0, 1671, 149, 1, 0, 0, 0, 1672, 1676, 5, 1, 0, 0, 1673, 1674, 5, 90, 0, 0, 1674, 1677, 5, 194, 0, 0, 1675, 1677, 5, 195, 0, 0, 1676, 1673, 1, 0, 0, 0, 1676, 1675, 1, 0, 0, 0, 1677, 1678, 1, 0, 0, 0, 1678, 1679, 6, 75, -1, 0, 1679, 151, 1, 0, 0, 0, 1680, 1681, 5, 294, 0, 0, 1681, 1682, 3, 166, 83, 0, 1682, 1683, 3, 124, 62, 0, 1683, 1684, 5, 30, 0, 0, 1684, 1685, 3, 158, 79, 0, 1685, 1686, 5, 31, 0, 0, 1686, 1728, 1, 0, 0, 0, 1687, 1688, 5, 294, 0, 0, 1688, 1689, 3, 166, 83, 0, 1689, 1690, 3, 124, 62, 0, 1690, 1691, 5, 36, 0, 0, 1691, 1692, 5, 17, 0, 0, 1692, 1693, 3, 52, 26, 0, 1693, 1694, 5, 18, 0, 0, 1694, 1728, 1, 0, 0, 0, 1695, 1696, 5, 294, 0, 0, 1696, 1697, 3, 166, 83, 0, 1697, 1698, 3, 124, 62, 0, 1698, 1728, 1, 0, 0, 0, 1699, 1700, 5, 295, 0, 0, 1700, 1701, 3, 166, 83, 0, 1701, 1703, 5, 36, 0, 0, 1702, 1704, 5, 84, 0, 0, 1703, 1702, 1, 0, 0, 0, 1703, 1704, 1, 0, 0, 0, 1704, 1705, 1, 0, 0, 0, 1705, 1706, 5, 30, 0, 0, 1706, 1707, 3, 292, 146, 0, 1707, 1708, 5, 31, 0, 0, 1708, 1728, 1, 0, 0, 0, 1709, 1710, 5, 295, 0, 0, 1710, 1711, 3, 166, 83, 0, 1711, 1712, 5, 84, 0, 0, 1712, 1713, 5, 30, 0, 0, 1713, 1714, 3, 292, 146, 0, 1714, 1715, 5, 31, 0, 0, 1715, 1728, 1, 0, 0, 0, 1716, 1717, 5, 295, 0, 0, 1717, 1718, 3, 166, 83, 0, 1718, 1719, 3, 6, 3, 0, 1719, 1728, 1, 0, 0, 0, 1720, 1721, 5, 295, 0, 0, 1721, 1722, 3, 166, 83, 0, 1722, 1723, 5, 36, 0, 0, 1723, 1724, 5, 17, 0, 0, 1724, 1725, 3, 154, 77, 0, 1725, 1726, 5, 18, 0, 0, 1726, 1728, 1, 0, 0, 0, 1727, 1680, 1, 0, 0, 0, 1727, 1687, 1, 0, 0, 0, 1727, 1695, 1, 0, 0, 0, 1727, 1699, 1, 0, 0, 0, 1727, 1709, 1, 0, 0, 0, 1727, 1716, 1, 0, 0, 0, 1727, 1720, 1, 0, 0, 0, 1728, 153, 1, 0, 0, 0, 1729, 1740, 1, 0, 0, 0, 1730, 1731, 3, 156, 78, 0, 1731, 1732, 5, 28, 0, 0, 1732, 1734, 1, 0, 0, 0, 1733, 1730, 1, 0, 0, 0, 1734, 1737, 1, 0, 0, 0, 1735, 1733, 1, 0, 0, 0, 1735, 1736, 1, 0, 0, 0, 1736, 1738, 1, 0, 0, 0, 1737, 1735, 1, 0, 0, 0, 1738, 1740, 3, 156, 78, 0, 1739, 1729, 1, 0, 0, 0, 1739, 1735, 1, 0, 0, 0, 1740, 155, 1, 0, 0, 0, 1741, 1742, 5, 39, 0, 0, 1742, 1743, 5, 264, 0, 0, 1743, 1744, 5, 36, 0, 0, 1744, 1745, 5, 17, 0, 0, 1745, 1746, 3, 56, 28, 0, 1746, 1747, 5, 18, 0, 0, 1747, 1755, 1, 0, 0, 0, 1748, 1749, 3, 124, 62, 0, 1749, 1750, 5, 36, 0, 0, 1750, 1751, 5, 17, 0, 0, 1751, 1752, 3, 56, 28, 0, 1752, 1753, 5, 18, 0, 0, 1753, 1755, 1, 0, 0, 0, 1754, 1741, 1, 0, 0, 0, 1754, 1748, 1, 0, 0, 0, 1755, 157, 1, 0, 0, 0, 1756, 1757, 3, 160, 80, 0, 1757, 1758, 5, 28, 0, 0, 1758, 1760, 1, 0, 0, 0, 1759, 1756, 1, 0, 0, 0, 1760, 1763, 1, 0, 0, 0, 1761, 1759, 1, 0, 0, 0, 1761, 1762, 1, 0, 0, 0, 1762, 1764, 1, 0, 0, 0, 1763, 1761, 1, 0, 0, 0, 1764, 1765, 3, 160, 80, 0, 1765, 159, 1, 0, 0, 0, 1766, 1767, 3, 6, 3, 0, 1767, 1768, 5, 36, 0, 0, 1768, 1769, 3, 164, 82, 0, 1769, 161, 1, 0, 0, 0, 1770, 1771, 7, 8, 0, 0, 1771, 163, 1, 0, 0, 0, 1772, 1807, 3, 162, 81, 0, 1773, 1807, 3, 32, 16, 0, 1774, 1775, 5, 186, 0, 0, 1775, 1776, 5, 30, 0, 0, 1776, 1777, 3, 32, 16, 0, 1777, 1778, 5, 31, 0, 0, 1778, 1807, 1, 0, 0, 0, 1779, 1807, 3, 6, 3, 0, 1780, 1781, 3, 116, 58, 0, 1781, 1782, 5, 30, 0, 0, 1782, 1783, 5, 184, 0, 0, 1783, 1784, 5, 75, 0, 0, 1784, 1785, 3, 32, 16, 0, 1785, 1786, 5, 31, 0, 0, 1786, 1807, 1, 0, 0, 0, 1787, 1788, 3, 116, 58, 0, 1788, 1789, 5, 30, 0, 0, 1789, 1790, 5, 185, 0, 0, 1790, 1791, 5, 75, 0, 0, 1791, 1792, 3, 32, 16, 0, 1792, 1793, 5, 31, 0, 0, 1793, 1807, 1, 0, 0, 0, 1794, 1795, 3, 116, 58, 0, 1795, 1796, 5, 30, 0, 0, 1796, 1797, 5, 186, 0, 0, 1797, 1798, 5, 75, 0, 0, 1798, 1799, 3, 32, 16, 0, 1799, 1800, 5, 31, 0, 0, 1800, 1807, 1, 0, 0, 0, 1801, 1802, 3, 116, 58, 0, 1802, 1803, 5, 30, 0, 0, 1803, 1804, 3, 32, 16, 0, 1804, 1805, 5, 31, 0, 0, 1805, 1807, 1, 0, 0, 0, 1806, 1772, 1, 0, 0, 0, 1806, 1773, 1, 0, 0, 0, 1806, 1774, 1, 0, 0, 0, 1806, 1779, 1, 0, 0, 0, 1806, 1780, 1, 0, 0, 0, 1806, 1787, 1, 0, 0, 0, 1806, 1794, 1, 0, 0, 0, 1806, 1801, 1, 0, 0, 0, 1807, 165, 1, 0, 0, 0, 1808, 1809, 7, 9, 0, 0, 1809, 167, 1, 0, 0, 0, 1810, 1811, 3, 170, 85, 0, 1811, 1812, 3, 138, 69, 0, 1812, 1813, 3, 124, 62, 0, 1813, 1814, 5, 176, 0, 0, 1814, 1816, 3, 242, 121, 0, 1815, 1817, 3, 108, 54, 0, 1816, 1815, 1, 0, 0, 0, 1816, 1817, 1, 0, 0, 0, 1817, 1818, 1, 0, 0, 0, 1818, 1819, 3, 112, 56, 0, 1819, 1820, 6, 84, -1, 0, 1820, 1853, 1, 0, 0, 0, 1821, 1822, 3, 170, 85, 0, 1822, 1823, 3, 138, 69, 0, 1823, 1824, 3, 124, 62, 0, 1824, 1825, 5, 176, 0, 0, 1825, 1826, 3, 242, 121, 0, 1826, 1827, 3, 196, 98, 0, 1827, 1828, 3, 112, 56, 0, 1828, 1829, 6, 84, -1, 0, 1829, 1853, 1, 0, 0, 0, 1830, 1831, 3, 170, 85, 0, 1831, 1832, 3, 138, 69, 0, 1832, 1834, 3, 242, 121, 0, 1833, 1835, 3, 108, 54, 0, 1834, 1833, 1, 0, 0, 0, 1834, 1835, 1, 0, 0, 0, 1835, 1836, 1, 0, 0, 0, 1836, 1837, 3, 112, 56, 0, 1837, 1838, 6, 84, -1, 0, 1838, 1853, 1, 0, 0, 0, 1839, 1840, 3, 170, 85, 0, 1840, 1841, 3, 138, 69, 0, 1841, 1842, 3, 242, 121, 0, 1842, 1843, 3, 196, 98, 0, 1843, 1844, 3, 112, 56, 0, 1844, 1845, 6, 84, -1, 0, 1845, 1853, 1, 0, 0, 0, 1846, 1847, 3, 174, 87, 0, 1847, 1848, 6, 84, -1, 0, 1848, 1853, 1, 0, 0, 0, 1849, 1850, 3, 2, 1, 0, 1850, 1851, 6, 84, -1, 0, 1851, 1853, 1, 0, 0, 0, 1852, 1810, 1, 0, 0, 0, 1852, 1821, 1, 0, 0, 0, 1852, 1830, 1, 0, 0, 0, 1852, 1839, 1, 0, 0, 0, 1852, 1846, 1, 0, 0, 0, 1852, 1849, 1, 0, 0, 0, 1853, 169, 1, 0, 0, 0, 1854, 1855, 5, 243, 0, 0, 1855, 1856, 3, 170, 85, 0, 1856, 1857, 6, 85, -1, 0, 1857, 1872, 1, 0, 0, 0, 1858, 1859, 5, 244, 0, 0, 1859, 1860, 3, 170, 85, 0, 1860, 1861, 6, 85, -1, 0, 1861, 1872, 1, 0, 0, 0, 1862, 1863, 3, 172, 86, 0, 1863, 1864, 6, 85, -1, 0, 1864, 1872, 1, 0, 0, 0, 1865, 1866, 5, 112, 0, 0, 1866, 1867, 5, 30, 0, 0, 1867, 1868, 3, 32, 16, 0, 1868, 1869, 5, 31, 0, 0, 1869, 1870, 6, 85, -1, 0, 1870, 1872, 1, 0, 0, 0, 1871, 1854, 1, 0, 0, 0, 1871, 1858, 1, 0, 0, 0, 1871, 1862, 1, 0, 0, 0, 1871, 1865, 1, 0, 0, 0, 1872, 171, 1, 0, 0, 0, 1873, 1893, 1, 0, 0, 0, 1874, 1875, 5, 245, 0, 0, 1875, 1893, 6, 86, -1, 0, 1876, 1877, 5, 246, 0, 0, 1877, 1893, 6, 86, -1, 0, 1878, 1879, 5, 247, 0, 0, 1879, 1880, 5, 248, 0, 0, 1880, 1893, 6, 86, -1, 0, 1881, 1882, 5, 247, 0, 0, 1882, 1883, 5, 249, 0, 0, 1883, 1893, 6, 86, -1, 0, 1884, 1885, 5, 247, 0, 0, 1885, 1886, 5, 250, 0, 0, 1886, 1893, 6, 86, -1, 0, 1887, 1888, 5, 247, 0, 0, 1888, 1889, 5, 251, 0, 0, 1889, 1893, 6, 86, -1, 0, 1890, 1891, 5, 247, 0, 0, 1891, 1893, 6, 86, -1, 0, 1892, 1873, 1, 0, 0, 0, 1892, 1874, 1, 0, 0, 0, 1892, 1876, 1, 0, 0, 0, 1892, 1878, 1, 0, 0, 0, 1892, 1881, 1, 0, 0, 0, 1892, 1884, 1, 0, 0, 0, 1892, 1887, 1, 0, 0, 0, 1892, 1890, 1, 0, 0, 0, 1893, 173, 1, 0, 0, 0, 1894, 1895, 5, 113, 0, 0, 1895, 1896, 5, 30, 0, 0, 1896, 1897, 3, 32, 16, 0, 1897, 1898, 5, 31, 0, 0, 1898, 1899, 6, 87, -1, 0, 1899, 175, 1, 0, 0, 0, 1900, 1901, 5, 226, 0, 0, 1901, 1902, 3, 168, 84, 0, 1902, 1903, 6, 88, -1, 0, 1903, 1912, 1, 0, 0, 0, 1904, 1905, 5, 37, 0, 0, 1905, 1906, 3, 178, 89, 0, 1906, 1907, 6, 88, -1, 0, 1907, 1912, 1, 0, 0, 0, 1908, 1909, 3, 174, 87, 0, 1909, 1910, 6, 88, -1, 0, 1910, 1912, 1, 0, 0, 0, 1911, 1900, 1, 0, 0, 0, 1911, 1904, 1, 0, 0, 0, 1911, 1908, 1, 0, 0, 0, 1912, 177, 1, 0, 0, 0, 1913, 1914, 3, 138, 69, 0, 1914, 1915, 3, 124, 62, 0, 1915, 1916, 5, 176, 0, 0, 1916, 1917, 3, 2, 1, 0, 1917, 1918, 6, 89, -1, 0, 1918, 1927, 1, 0, 0, 0, 1919, 1920, 3, 138, 69, 0, 1920, 1921, 3, 2, 1, 0, 1921, 1922, 6, 89, -1, 0, 1922, 1927, 1, 0, 0, 0, 1923, 1924, 3, 2, 1, 0, 1924, 1925, 6, 89, -1, 0, 1925, 1927, 1, 0, 0, 0, 1926, 1913, 1, 0, 0, 0, 1926, 1919, 1, 0, 0, 0, 1926, 1923, 1, 0, 0, 0, 1927, 179, 1, 0, 0, 0, 1928, 1929, 3, 124, 62, 0, 1929, 1930, 5, 28, 0, 0, 1930, 1932, 1, 0, 0, 0, 1931, 1928, 1, 0, 0, 0, 1932, 1935, 1, 0, 0, 0, 1933, 1931, 1, 0, 0, 0, 1933, 1934, 1, 0, 0, 0, 1934, 1936, 1, 0, 0, 0, 1935, 1933, 1, 0, 0, 0, 1936, 1937, 3, 124, 62, 0, 1937, 181, 1, 0, 0, 0, 1938, 1944, 1, 0, 0, 0, 1939, 1940, 5, 86, 0, 0, 1940, 1941, 3, 190, 95, 0, 1941, 1942, 5, 87, 0, 0, 1942, 1944, 1, 0, 0, 0, 1943, 1938, 1, 0, 0, 0, 1943, 1939, 1, 0, 0, 0, 1944, 183, 1, 0, 0, 0, 1945, 1957, 5, 266, 0, 0, 1946, 1957, 5, 114, 0, 0, 1947, 1957, 5, 39, 0, 0, 1948, 1957, 5, 200, 0, 0, 1949, 1957, 5, 115, 0, 0, 1950, 1957, 5, 116, 0, 0, 1951, 1952, 5, 70, 0, 0, 1952, 1953, 5, 30, 0, 0, 1953, 1954, 3, 32, 16, 0, 1954, 1955, 5, 31, 0, 0, 1955, 1957, 1, 0, 0, 0, 1956, 1945, 1, 0, 0, 0, 1956, 1946, 1, 0, 0, 0, 1956, 1947, 1, 0, 0, 0, 1956, 1948, 1, 0, 0, 0, 1956, 1949, 1, 0, 0, 0, 1956, 1950, 1, 0, 0, 0, 1956, 1951, 1, 0, 0, 0, 1957, 185, 1, 0, 0, 0, 1958, 1960, 3, 184, 92, 0, 1959, 1958, 1, 0, 0, 0, 1960, 1963, 1, 0, 0, 0, 1961, 1959, 1, 0, 0, 0, 1961, 1962, 1, 0, 0, 0, 1962, 187, 1, 0, 0, 0, 1963, 1961, 1, 0, 0, 0, 1964, 1966, 3, 186, 93, 0, 1965, 1967, 3, 192, 96, 0, 1966, 1965, 1, 0, 0, 0, 1966, 1967, 1, 0, 0, 0, 1967, 1968, 1, 0, 0, 0, 1968, 1969, 3, 2, 1, 0, 1969, 189, 1, 0, 0, 0, 1970, 1971, 3, 188, 94, 0, 1971, 1972, 5, 28, 0, 0, 1972, 1974, 1, 0, 0, 0, 1973, 1970, 1, 0, 0, 0, 1974, 1977, 1, 0, 0, 0, 1975, 1973, 1, 0, 0, 0, 1975, 1976, 1, 0, 0, 0, 1976, 1978, 1, 0, 0, 0, 1977, 1975, 1, 0, 0, 0, 1978, 1979, 3, 188, 94, 0, 1979, 191, 1, 0, 0, 0, 1980, 1981, 5, 30, 0, 0, 1981, 1982, 3, 180, 90, 0, 1982, 1983, 5, 31, 0, 0, 1983, 193, 1, 0, 0, 0, 1984, 1986, 3, 196, 98, 0, 1985, 1984, 1, 0, 0, 0, 1985, 1986, 1, 0, 0, 0, 1986, 1987, 1, 0, 0, 0, 1987, 1988, 6, 97, -1, 0, 1988, 195, 1, 0, 0, 0, 1989, 1990, 5, 86, 0, 0, 1990, 1991, 5, 42, 0, 0, 1991, 1992, 3, 32, 16, 0, 1992, 1993, 5, 43, 0, 0, 1993, 1994, 5, 87, 0, 0, 1994, 1995, 6, 98, -1, 0, 1995, 197, 1, 0, 0, 0, 1996, 1997, 3, 234, 117, 0, 1997, 1998, 5, 17, 0, 0, 1998, 1999, 3, 246, 123, 0, 1999, 2000, 5, 18, 0, 0, 2000, 2113, 1, 0, 0, 0, 2001, 2002, 3, 74, 37, 0, 2002, 2003, 5, 17, 0, 0, 2003, 2004, 3, 82, 41, 0, 2004, 2005, 5, 18, 0, 0, 2005, 2113, 1, 0, 0, 0, 2006, 2007, 3, 210, 105, 0, 2007, 2008, 5, 17, 0, 0, 2008, 2009, 3, 214, 107, 0, 2009, 2010, 5, 18, 0, 0, 2010, 2113, 1, 0, 0, 0, 2011, 2012, 3, 218, 109, 0, 2012, 2013, 5, 17, 0, 0, 2013, 2014, 3, 222, 111, 0, 2014, 2015, 5, 18, 0, 0, 2015, 2113, 1, 0, 0, 0, 2016, 2113, 3, 200, 100, 0, 2017, 2113, 3, 276, 138, 0, 2018, 2113, 3, 152, 76, 0, 2019, 2113, 3, 88, 44, 0, 2020, 2113, 3, 322, 161, 0, 2021, 2022, 5, 117, 0, 0, 2022, 2113, 3, 32, 16, 0, 2023, 2024, 5, 118, 0, 0, 2024, 2113, 3, 32, 16, 0, 2025, 2026, 3, 334, 167, 0, 2026, 2027, 5, 17, 0, 0, 2027, 2028, 3, 338, 169, 0, 2028, 2029, 5, 18, 0, 0, 2029, 2113, 1, 0, 0, 0, 2030, 2031, 5, 302, 0, 0, 2031, 2032, 3, 124, 62, 0, 2032, 2033, 5, 176, 0, 0, 2033, 2034, 3, 242, 121, 0, 2034, 2035, 5, 119, 0, 0, 2035, 2036, 3, 170, 85, 0, 2036, 2037, 3, 138, 69, 0, 2037, 2038, 3, 124, 62, 0, 2038, 2039, 5, 176, 0, 0, 2039, 2040, 3, 242, 121, 0, 2040, 2041, 3, 112, 56, 0, 2041, 2113, 1, 0, 0, 0, 2042, 2043, 5, 302, 0, 0, 2043, 2044, 5, 226, 0, 0, 2044, 2045, 3, 170, 85, 0, 2045, 2046, 3, 138, 69, 0, 2046, 2047, 3, 124, 62, 0, 2047, 2048, 5, 176, 0, 0, 2048, 2049, 3, 242, 121, 0, 2049, 2050, 3, 194, 97, 0, 2050, 2051, 3, 112, 56, 0, 2051, 2052, 5, 119, 0, 0, 2052, 2053, 5, 226, 0, 0, 2053, 2054, 3, 170, 85, 0, 2054, 2055, 3, 138, 69, 0, 2055, 2056, 3, 124, 62, 0, 2056, 2057, 5, 176, 0, 0, 2057, 2058, 3, 242, 121, 0, 2058, 2059, 3, 194, 97, 0, 2059, 2060, 3, 112, 56, 0, 2060, 2113, 1, 0, 0, 0, 2061, 2113, 3, 26, 13, 0, 2062, 2113, 3, 40, 20, 0, 2063, 2064, 5, 255, 0, 0, 2064, 2065, 5, 196, 0, 0, 2065, 2066, 5, 42, 0, 0, 2066, 2067, 3, 32, 16, 0, 2067, 2071, 5, 43, 0, 0, 2068, 2070, 3, 322, 161, 0, 2069, 2068, 1, 0, 0, 0, 2070, 2073, 1, 0, 0, 0, 2071, 2069, 1, 0, 0, 0, 2071, 2072, 1, 0, 0, 0, 2072, 2113, 1, 0, 0, 0, 2073, 2071, 1, 0, 0, 0, 2074, 2075, 5, 255, 0, 0, 2075, 2076, 5, 196, 0, 0, 2076, 2080, 3, 2, 1, 0, 2077, 2079, 3, 322, 161, 0, 2078, 2077, 1, 0, 0, 0, 2079, 2082, 1, 0, 0, 0, 2080, 2078, 1, 0, 0, 0, 2080, 2081, 1, 0, 0, 0, 2081, 2113, 1, 0, 0, 0, 2082, 2080, 1, 0, 0, 0, 2083, 2084, 5, 255, 0, 0, 2084, 2085, 5, 256, 0, 0, 2085, 2086, 5, 42, 0, 0, 2086, 2087, 3, 32, 16, 0, 2087, 2088, 5, 43, 0, 0, 2088, 2089, 5, 28, 0, 0, 2089, 2093, 3, 124, 62, 0, 2090, 2092, 3, 322, 161, 0, 2091, 2090, 1, 0, 0, 0, 2092, 2095, 1, 0, 0, 0, 2093, 2091, 1, 0, 0, 0, 2093, 2094, 1, 0, 0, 0, 2094, 2113, 1, 0, 0, 0, 2095, 2093, 1, 0, 0, 0, 2096, 2097, 5, 255, 0, 0, 2097, 2098, 5, 256, 0, 0, 2098, 2099, 3, 2, 1, 0, 2099, 2100, 5, 28, 0, 0, 2100, 2104, 3, 124, 62, 0, 2101, 2103, 3, 322, 161, 0, 2102, 2101, 1, 0, 0, 0, 2103, 2106, 1, 0, 0, 0, 2104, 2102, 1, 0, 0, 0, 2104, 2105, 1, 0, 0, 0, 2105, 2113, 1, 0, 0, 0, 2106, 2104, 1, 0, 0, 0, 2107, 2108, 5, 120, 0, 0, 2108, 2109, 5, 196, 0, 0, 2109, 2110, 3, 124, 62, 0, 2110, 2111, 3, 44, 22, 0, 2111, 2113, 1, 0, 0, 0, 2112, 1996, 1, 0, 0, 0, 2112, 2001, 1, 0, 0, 0, 2112, 2006, 1, 0, 0, 0, 2112, 2011, 1, 0, 0, 0, 2112, 2016, 1, 0, 0, 0, 2112, 2017, 1, 0, 0, 0, 2112, 2018, 1, 0, 0, 0, 2112, 2019, 1, 0, 0, 0, 2112, 2020, 1, 0, 0, 0, 2112, 2021, 1, 0, 0, 0, 2112, 2023, 1, 0, 0, 0, 2112, 2025, 1, 0, 0, 0, 2112, 2030, 1, 0, 0, 0, 2112, 2042, 1, 0, 0, 0, 2112, 2061, 1, 0, 0, 0, 2112, 2062, 1, 0, 0, 0, 2112, 2063, 1, 0, 0, 0, 2112, 2074, 1, 0, 0, 0, 2112, 2083, 1, 0, 0, 0, 2112, 2096, 1, 0, 0, 0, 2112, 2107, 1, 0, 0, 0, 2113, 199, 1, 0, 0, 0, 2114, 2115, 5, 121, 0, 0, 2115, 2124, 3, 208, 104, 0, 2116, 2123, 3, 202, 101, 0, 2117, 2118, 5, 122, 0, 0, 2118, 2119, 5, 30, 0, 0, 2119, 2120, 3, 228, 114, 0, 2120, 2121, 5, 31, 0, 0, 2121, 2123, 1, 0, 0, 0, 2122, 2116, 1, 0, 0, 0, 2122, 2117, 1, 0, 0, 0, 2123, 2126, 1, 0, 0, 0, 2124, 2122, 1, 0, 0, 0, 2124, 2125, 1, 0, 0, 0, 2125, 2127, 1, 0, 0, 0, 2126, 2124, 1, 0, 0, 0, 2127, 2128, 3, 138, 69, 0, 2128, 2129, 3, 2, 1, 0, 2129, 2130, 3, 204, 102, 0, 2130, 2131, 3, 206, 103, 0, 2131, 201, 1, 0, 0, 0, 2132, 2152, 5, 123, 0, 0, 2133, 2152, 5, 51, 0, 0, 2134, 2152, 5, 52, 0, 0, 2135, 2152, 5, 63, 0, 0, 2136, 2152, 5, 124, 0, 0, 2137, 2152, 5, 69, 0, 0, 2138, 2152, 5, 68, 0, 0, 2139, 2152, 5, 64, 0, 0, 2140, 2152, 5, 65, 0, 0, 2141, 2152, 5, 66, 0, 0, 2142, 2152, 5, 125, 0, 0, 2143, 2152, 5, 126, 0, 0, 2144, 2152, 5, 127, 0, 0, 2145, 2152, 5, 16, 0, 0, 2146, 2147, 5, 70, 0, 0, 2147, 2148, 5, 30, 0, 0, 2148, 2149, 3, 32, 16, 0, 2149, 2150, 5, 31, 0, 0, 2150, 2152, 1, 0, 0, 0, 2151, 2132, 1, 0, 0, 0, 2151, 2133, 1, 0, 0, 0, 2151, 2134, 1, 0, 0, 0, 2151, 2135, 1, 0, 0, 0, 2151, 2136, 1, 0, 0, 0, 2151, 2137, 1, 0, 0, 0, 2151, 2138, 1, 0, 0, 0, 2151, 2139, 1, 0, 0, 0, 2151, 2140, 1, 0, 0, 0, 2151, 2141, 1, 0, 0, 0, 2151, 2142, 1, 0, 0, 0, 2151, 2143, 1, 0, 0, 0, 2151, 2144, 1, 0, 0, 0, 2151, 2145, 1, 0, 0, 0, 2151, 2146, 1, 0, 0, 0, 2152, 203, 1, 0, 0, 0, 2153, 2159, 1, 0, 0, 0, 2154, 2155, 5, 44, 0, 0, 2155, 2159, 3, 0, 0, 0, 2156, 2157, 5, 44, 0, 0, 2157, 2159, 3, 32, 16, 0, 2158, 2153, 1, 0, 0, 0, 2158, 2154, 1, 0, 0, 0, 2158, 2156, 1, 0, 0, 0, 2159, 205, 1, 0, 0, 0, 2160, 2164, 1, 0, 0, 0, 2161, 2162, 5, 36, 0, 0, 2162, 2164, 3, 296, 148, 0, 2163, 2160, 1, 0, 0, 0, 2163, 2161, 1, 0, 0, 0, 2164, 207, 1, 0, 0, 0, 2165, 2171, 1, 0, 0, 0, 2166, 2167, 5, 42, 0, 0, 2167, 2168, 3, 32, 16, 0, 2168, 2169, 5, 43, 0, 0, 2169, 2171, 1, 0, 0, 0, 2170, 2165, 1, 0, 0, 0, 2170, 2166, 1, 0, 0, 0, 2171, 209, 1, 0, 0, 0, 2172, 2176, 5, 128, 0, 0, 2173, 2175, 3, 212, 106, 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, 2180, 3, 124, 62, 0, 2180, 2181, 3, 2, 1, 0, 2181, 2191, 1, 0, 0, 0, 2182, 2186, 5, 128, 0, 0, 2183, 2185, 3, 212, 106, 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, 2, 1, 0, 2190, 2172, 1, 0, 0, 0, 2190, 2182, 1, 0, 0, 0, 2191, 211, 1, 0, 0, 0, 2192, 2193, 7, 10, 0, 0, 2193, 213, 1, 0, 0, 0, 2194, 2196, 3, 216, 108, 0, 2195, 2194, 1, 0, 0, 0, 2196, 2199, 1, 0, 0, 0, 2197, 2195, 1, 0, 0, 0, 2197, 2198, 1, 0, 0, 0, 2198, 215, 1, 0, 0, 0, 2199, 2197, 1, 0, 0, 0, 2200, 2201, 5, 129, 0, 0, 2201, 2213, 3, 168, 84, 0, 2202, 2203, 5, 130, 0, 0, 2203, 2213, 3, 168, 84, 0, 2204, 2205, 5, 131, 0, 0, 2205, 2213, 3, 168, 84, 0, 2206, 2207, 5, 132, 0, 0, 2207, 2213, 3, 168, 84, 0, 2208, 2213, 3, 88, 44, 0, 2209, 2213, 3, 322, 161, 0, 2210, 2213, 3, 26, 13, 0, 2211, 2213, 3, 40, 20, 0, 2212, 2200, 1, 0, 0, 0, 2212, 2202, 1, 0, 0, 0, 2212, 2204, 1, 0, 0, 0, 2212, 2206, 1, 0, 0, 0, 2212, 2208, 1, 0, 0, 0, 2212, 2209, 1, 0, 0, 0, 2212, 2210, 1, 0, 0, 0, 2212, 2211, 1, 0, 0, 0, 2213, 217, 1, 0, 0, 0, 2214, 2218, 5, 133, 0, 0, 2215, 2217, 3, 220, 110, 0, 2216, 2215, 1, 0, 0, 0, 2217, 2220, 1, 0, 0, 0, 2218, 2216, 1, 0, 0, 0, 2218, 2219, 1, 0, 0, 0, 2219, 2221, 1, 0, 0, 0, 2220, 2218, 1, 0, 0, 0, 2221, 2222, 3, 170, 85, 0, 2222, 2223, 3, 138, 69, 0, 2223, 2224, 3, 2, 1, 0, 2224, 2225, 3, 112, 56, 0, 2225, 2226, 3, 206, 103, 0, 2226, 219, 1, 0, 0, 0, 2227, 2228, 7, 10, 0, 0, 2228, 221, 1, 0, 0, 0, 2229, 2231, 3, 224, 112, 0, 2230, 2229, 1, 0, 0, 0, 2231, 2234, 1, 0, 0, 0, 2232, 2230, 1, 0, 0, 0, 2232, 2233, 1, 0, 0, 0, 2233, 223, 1, 0, 0, 0, 2234, 2232, 1, 0, 0, 0, 2235, 2236, 5, 134, 0, 0, 2236, 2246, 3, 168, 84, 0, 2237, 2238, 5, 135, 0, 0, 2238, 2246, 3, 168, 84, 0, 2239, 2240, 5, 132, 0, 0, 2240, 2246, 3, 168, 84, 0, 2241, 2246, 3, 322, 161, 0, 2242, 2246, 3, 88, 44, 0, 2243, 2246, 3, 26, 13, 0, 2244, 2246, 3, 40, 20, 0, 2245, 2235, 1, 0, 0, 0, 2245, 2237, 1, 0, 0, 0, 2245, 2239, 1, 0, 0, 0, 2245, 2241, 1, 0, 0, 0, 2245, 2242, 1, 0, 0, 0, 2245, 2243, 1, 0, 0, 0, 2245, 2244, 1, 0, 0, 0, 2246, 225, 1, 0, 0, 0, 2247, 2255, 6, 113, -1, 0, 2248, 2249, 5, 122, 0, 0, 2249, 2250, 5, 30, 0, 0, 2250, 2251, 3, 228, 114, 0, 2251, 2252, 5, 31, 0, 0, 2252, 2253, 6, 113, -1, 0, 2253, 2255, 1, 0, 0, 0, 2254, 2247, 1, 0, 0, 0, 2254, 2248, 1, 0, 0, 0, 2255, 227, 1, 0, 0, 0, 2256, 2257, 3, 126, 63, 0, 2257, 2258, 6, 114, -1, 0, 2258, 2270, 1, 0, 0, 0, 2259, 2263, 5, 17, 0, 0, 2260, 2261, 3, 294, 147, 0, 2261, 2262, 6, 114, -1, 0, 2262, 2264, 1, 0, 0, 0, 2263, 2260, 1, 0, 0, 0, 2264, 2265, 1, 0, 0, 0, 2265, 2263, 1, 0, 0, 0, 2265, 2266, 1, 0, 0, 0, 2266, 2267, 1, 0, 0, 0, 2267, 2268, 5, 18, 0, 0, 2268, 2270, 1, 0, 0, 0, 2269, 2256, 1, 0, 0, 0, 2269, 2259, 1, 0, 0, 0, 2270, 229, 1, 0, 0, 0, 2271, 2272, 3, 232, 116, 0, 2272, 2273, 6, 115, -1, 0, 2273, 2275, 1, 0, 0, 0, 2274, 2271, 1, 0, 0, 0, 2275, 2278, 1, 0, 0, 0, 2276, 2274, 1, 0, 0, 0, 2276, 2277, 1, 0, 0, 0, 2277, 231, 1, 0, 0, 0, 2278, 2276, 1, 0, 0, 0, 2279, 2280, 5, 42, 0, 0, 2280, 2281, 5, 136, 0, 0, 2281, 2282, 5, 43, 0, 0, 2282, 2297, 6, 116, -1, 0, 2283, 2284, 5, 42, 0, 0, 2284, 2285, 5, 137, 0, 0, 2285, 2286, 5, 43, 0, 0, 2286, 2297, 6, 116, -1, 0, 2287, 2288, 5, 42, 0, 0, 2288, 2289, 5, 138, 0, 0, 2289, 2290, 5, 43, 0, 0, 2290, 2297, 6, 116, -1, 0, 2291, 2292, 5, 42, 0, 0, 2292, 2293, 3, 32, 16, 0, 2293, 2294, 5, 43, 0, 0, 2294, 2295, 6, 116, -1, 0, 2295, 2297, 1, 0, 0, 0, 2296, 2279, 1, 0, 0, 0, 2296, 2283, 1, 0, 0, 0, 2296, 2287, 1, 0, 0, 0, 2296, 2291, 1, 0, 0, 0, 2297, 233, 1, 0, 0, 0, 2298, 2303, 5, 139, 0, 0, 2299, 2302, 3, 236, 118, 0, 2300, 2302, 3, 238, 119, 0, 2301, 2299, 1, 0, 0, 0, 2301, 2300, 1, 0, 0, 0, 2302, 2305, 1, 0, 0, 0, 2303, 2301, 1, 0, 0, 0, 2303, 2304, 1, 0, 0, 0, 2304, 2306, 1, 0, 0, 0, 2305, 2303, 1, 0, 0, 0, 2306, 2307, 3, 170, 85, 0, 2307, 2308, 3, 230, 115, 0, 2308, 2309, 3, 138, 69, 0, 2309, 2310, 3, 226, 113, 0, 2310, 2311, 3, 242, 121, 0, 2311, 2312, 3, 182, 91, 0, 2312, 2316, 3, 112, 56, 0, 2313, 2315, 3, 244, 122, 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, 235, 1, 0, 0, 0, 2318, 2316, 1, 0, 0, 0, 2319, 2343, 5, 123, 0, 0, 2320, 2343, 5, 51, 0, 0, 2321, 2343, 5, 52, 0, 0, 2322, 2343, 5, 63, 0, 0, 2323, 2343, 5, 140, 0, 0, 2324, 2343, 5, 68, 0, 0, 2325, 2343, 5, 141, 0, 0, 2326, 2343, 5, 142, 0, 0, 2327, 2343, 5, 54, 0, 0, 2328, 2343, 5, 64, 0, 0, 2329, 2343, 5, 65, 0, 0, 2330, 2343, 5, 66, 0, 0, 2331, 2343, 5, 125, 0, 0, 2332, 2343, 5, 143, 0, 0, 2333, 2343, 5, 144, 0, 0, 2334, 2343, 5, 69, 0, 0, 2335, 2343, 5, 145, 0, 0, 2336, 2343, 5, 146, 0, 0, 2337, 2338, 5, 70, 0, 0, 2338, 2339, 5, 30, 0, 0, 2339, 2340, 3, 32, 16, 0, 2340, 2341, 5, 31, 0, 0, 2341, 2343, 1, 0, 0, 0, 2342, 2319, 1, 0, 0, 0, 2342, 2320, 1, 0, 0, 0, 2342, 2321, 1, 0, 0, 0, 2342, 2322, 1, 0, 0, 0, 2342, 2323, 1, 0, 0, 0, 2342, 2324, 1, 0, 0, 0, 2342, 2325, 1, 0, 0, 0, 2342, 2326, 1, 0, 0, 0, 2342, 2327, 1, 0, 0, 0, 2342, 2328, 1, 0, 0, 0, 2342, 2329, 1, 0, 0, 0, 2342, 2330, 1, 0, 0, 0, 2342, 2331, 1, 0, 0, 0, 2342, 2332, 1, 0, 0, 0, 2342, 2333, 1, 0, 0, 0, 2342, 2334, 1, 0, 0, 0, 2342, 2335, 1, 0, 0, 0, 2342, 2336, 1, 0, 0, 0, 2342, 2337, 1, 0, 0, 0, 2343, 237, 1, 0, 0, 0, 2344, 2345, 5, 147, 0, 0, 2345, 2351, 5, 30, 0, 0, 2346, 2349, 3, 6, 3, 0, 2347, 2348, 5, 34, 0, 0, 2348, 2350, 3, 6, 3, 0, 2349, 2347, 1, 0, 0, 0, 2349, 2350, 1, 0, 0, 0, 2350, 2352, 1, 0, 0, 0, 2351, 2346, 1, 0, 0, 0, 2351, 2352, 1, 0, 0, 0, 2352, 2356, 1, 0, 0, 0, 2353, 2355, 3, 240, 120, 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, 2363, 5, 31, 0, 0, 2360, 2361, 5, 147, 0, 0, 2361, 2363, 5, 85, 0, 0, 2362, 2344, 1, 0, 0, 0, 2362, 2360, 1, 0, 0, 0, 2363, 239, 1, 0, 0, 0, 2364, 2392, 5, 148, 0, 0, 2365, 2392, 5, 224, 0, 0, 2366, 2392, 5, 57, 0, 0, 2367, 2392, 5, 58, 0, 0, 2368, 2392, 5, 149, 0, 0, 2369, 2392, 5, 150, 0, 0, 2370, 2392, 5, 248, 0, 0, 2371, 2392, 5, 249, 0, 0, 2372, 2392, 5, 250, 0, 0, 2373, 2392, 5, 251, 0, 0, 2374, 2375, 5, 151, 0, 0, 2375, 2376, 5, 75, 0, 0, 2376, 2392, 5, 152, 0, 0, 2377, 2378, 5, 151, 0, 0, 2378, 2379, 5, 75, 0, 0, 2379, 2392, 5, 153, 0, 0, 2380, 2381, 5, 154, 0, 0, 2381, 2382, 5, 75, 0, 0, 2382, 2392, 5, 152, 0, 0, 2383, 2384, 5, 154, 0, 0, 2384, 2385, 5, 75, 0, 0, 2385, 2392, 5, 153, 0, 0, 2386, 2387, 5, 70, 0, 0, 2387, 2388, 5, 30, 0, 0, 2388, 2389, 3, 32, 16, 0, 2389, 2390, 5, 31, 0, 0, 2390, 2392, 1, 0, 0, 0, 2391, 2364, 1, 0, 0, 0, 2391, 2365, 1, 0, 0, 0, 2391, 2366, 1, 0, 0, 0, 2391, 2367, 1, 0, 0, 0, 2391, 2368, 1, 0, 0, 0, 2391, 2369, 1, 0, 0, 0, 2391, 2370, 1, 0, 0, 0, 2391, 2371, 1, 0, 0, 0, 2391, 2372, 1, 0, 0, 0, 2391, 2373, 1, 0, 0, 0, 2391, 2374, 1, 0, 0, 0, 2391, 2377, 1, 0, 0, 0, 2391, 2380, 1, 0, 0, 0, 2391, 2383, 1, 0, 0, 0, 2391, 2386, 1, 0, 0, 0, 2392, 241, 1, 0, 0, 0, 2393, 2394, 5, 116, 0, 0, 2394, 2401, 6, 121, -1, 0, 2395, 2396, 5, 155, 0, 0, 2396, 2401, 6, 121, -1, 0, 2397, 2398, 3, 2, 1, 0, 2398, 2399, 6, 121, -1, 0, 2399, 2401, 1, 0, 0, 0, 2400, 2393, 1, 0, 0, 0, 2400, 2395, 1, 0, 0, 0, 2400, 2397, 1, 0, 0, 0, 2401, 243, 1, 0, 0, 0, 2402, 2424, 5, 1, 0, 0, 2403, 2424, 5, 2, 0, 0, 2404, 2424, 5, 156, 0, 0, 2405, 2424, 5, 3, 0, 0, 2406, 2424, 5, 4, 0, 0, 2407, 2424, 5, 247, 0, 0, 2408, 2424, 5, 5, 0, 0, 2409, 2424, 5, 6, 0, 0, 2410, 2424, 5, 7, 0, 0, 2411, 2424, 5, 8, 0, 0, 2412, 2424, 5, 9, 0, 0, 2413, 2424, 5, 10, 0, 0, 2414, 2424, 5, 11, 0, 0, 2415, 2424, 5, 12, 0, 0, 2416, 2424, 5, 13, 0, 0, 2417, 2424, 5, 14, 0, 0, 2418, 2419, 5, 70, 0, 0, 2419, 2420, 5, 30, 0, 0, 2420, 2421, 3, 32, 16, 0, 2421, 2422, 5, 31, 0, 0, 2422, 2424, 1, 0, 0, 0, 2423, 2402, 1, 0, 0, 0, 2423, 2403, 1, 0, 0, 0, 2423, 2404, 1, 0, 0, 0, 2423, 2405, 1, 0, 0, 0, 2423, 2406, 1, 0, 0, 0, 2423, 2407, 1, 0, 0, 0, 2423, 2408, 1, 0, 0, 0, 2423, 2409, 1, 0, 0, 0, 2423, 2410, 1, 0, 0, 0, 2423, 2411, 1, 0, 0, 0, 2423, 2412, 1, 0, 0, 0, 2423, 2413, 1, 0, 0, 0, 2423, 2414, 1, 0, 0, 0, 2423, 2415, 1, 0, 0, 0, 2423, 2416, 1, 0, 0, 0, 2423, 2417, 1, 0, 0, 0, 2423, 2418, 1, 0, 0, 0, 2424, 245, 1, 0, 0, 0, 2425, 2427, 3, 248, 124, 0, 2426, 2425, 1, 0, 0, 0, 2427, 2430, 1, 0, 0, 0, 2428, 2426, 1, 0, 0, 0, 2428, 2429, 1, 0, 0, 0, 2429, 247, 1, 0, 0, 0, 2430, 2428, 1, 0, 0, 0, 2431, 2449, 3, 100, 50, 0, 2432, 2433, 5, 296, 0, 0, 2433, 2434, 3, 32, 16, 0, 2434, 2435, 6, 124, -1, 0, 2435, 2449, 1, 0, 0, 0, 2436, 2449, 3, 258, 129, 0, 2437, 2438, 5, 297, 0, 0, 2438, 2439, 3, 32, 16, 0, 2439, 2440, 6, 124, -1, 0, 2440, 2449, 1, 0, 0, 0, 2441, 2442, 5, 298, 0, 0, 2442, 2449, 6, 124, -1, 0, 2443, 2444, 5, 299, 0, 0, 2444, 2449, 6, 124, -1, 0, 2445, 2449, 3, 252, 126, 0, 2446, 2449, 3, 256, 128, 0, 2447, 2449, 3, 250, 125, 0, 2448, 2431, 1, 0, 0, 0, 2448, 2432, 1, 0, 0, 0, 2448, 2436, 1, 0, 0, 0, 2448, 2437, 1, 0, 0, 0, 2448, 2441, 1, 0, 0, 0, 2448, 2443, 1, 0, 0, 0, 2448, 2445, 1, 0, 0, 0, 2448, 2446, 1, 0, 0, 0, 2448, 2447, 1, 0, 0, 0, 2449, 249, 1, 0, 0, 0, 2450, 2451, 5, 300, 0, 0, 2451, 2549, 3, 112, 56, 0, 2452, 2453, 5, 300, 0, 0, 2453, 2454, 5, 157, 0, 0, 2454, 2549, 3, 112, 56, 0, 2455, 2549, 3, 276, 138, 0, 2456, 2549, 3, 152, 76, 0, 2457, 2549, 3, 88, 44, 0, 2458, 2549, 3, 26, 13, 0, 2459, 2549, 3, 254, 127, 0, 2460, 2549, 3, 40, 20, 0, 2461, 2462, 5, 301, 0, 0, 2462, 2463, 5, 42, 0, 0, 2463, 2464, 3, 32, 16, 0, 2464, 2465, 5, 43, 0, 0, 2465, 2549, 1, 0, 0, 0, 2466, 2467, 5, 301, 0, 0, 2467, 2468, 5, 42, 0, 0, 2468, 2469, 3, 32, 16, 0, 2469, 2470, 5, 43, 0, 0, 2470, 2471, 5, 34, 0, 0, 2471, 2472, 3, 0, 0, 0, 2472, 2549, 1, 0, 0, 0, 2473, 2474, 5, 303, 0, 0, 2474, 2475, 3, 32, 16, 0, 2475, 2476, 5, 75, 0, 0, 2476, 2477, 3, 32, 16, 0, 2477, 2549, 1, 0, 0, 0, 2478, 2479, 5, 302, 0, 0, 2479, 2480, 3, 124, 62, 0, 2480, 2481, 5, 176, 0, 0, 2481, 2482, 3, 242, 121, 0, 2482, 2549, 1, 0, 0, 0, 2483, 2484, 5, 302, 0, 0, 2484, 2485, 5, 226, 0, 0, 2485, 2486, 3, 170, 85, 0, 2486, 2487, 3, 138, 69, 0, 2487, 2488, 3, 124, 62, 0, 2488, 2489, 5, 176, 0, 0, 2489, 2490, 3, 242, 121, 0, 2490, 2491, 3, 194, 97, 0, 2491, 2492, 3, 112, 56, 0, 2492, 2549, 1, 0, 0, 0, 2493, 2494, 5, 255, 0, 0, 2494, 2495, 5, 196, 0, 0, 2495, 2496, 5, 42, 0, 0, 2496, 2497, 3, 32, 16, 0, 2497, 2501, 5, 43, 0, 0, 2498, 2500, 3, 322, 161, 0, 2499, 2498, 1, 0, 0, 0, 2500, 2503, 1, 0, 0, 0, 2501, 2499, 1, 0, 0, 0, 2501, 2502, 1, 0, 0, 0, 2502, 2549, 1, 0, 0, 0, 2503, 2501, 1, 0, 0, 0, 2504, 2505, 5, 255, 0, 0, 2505, 2506, 5, 196, 0, 0, 2506, 2510, 3, 2, 1, 0, 2507, 2509, 3, 322, 161, 0, 2508, 2507, 1, 0, 0, 0, 2509, 2512, 1, 0, 0, 0, 2510, 2508, 1, 0, 0, 0, 2510, 2511, 1, 0, 0, 0, 2511, 2549, 1, 0, 0, 0, 2512, 2510, 1, 0, 0, 0, 2513, 2514, 5, 255, 0, 0, 2514, 2515, 5, 256, 0, 0, 2515, 2516, 5, 42, 0, 0, 2516, 2517, 3, 32, 16, 0, 2517, 2518, 5, 43, 0, 0, 2518, 2519, 5, 28, 0, 0, 2519, 2523, 3, 124, 62, 0, 2520, 2522, 3, 322, 161, 0, 2521, 2520, 1, 0, 0, 0, 2522, 2525, 1, 0, 0, 0, 2523, 2521, 1, 0, 0, 0, 2523, 2524, 1, 0, 0, 0, 2524, 2549, 1, 0, 0, 0, 2525, 2523, 1, 0, 0, 0, 2526, 2527, 5, 255, 0, 0, 2527, 2528, 5, 256, 0, 0, 2528, 2529, 3, 2, 1, 0, 2529, 2530, 5, 28, 0, 0, 2530, 2534, 3, 124, 62, 0, 2531, 2533, 3, 322, 161, 0, 2532, 2531, 1, 0, 0, 0, 2533, 2536, 1, 0, 0, 0, 2534, 2532, 1, 0, 0, 0, 2534, 2535, 1, 0, 0, 0, 2535, 2549, 1, 0, 0, 0, 2536, 2534, 1, 0, 0, 0, 2537, 2538, 5, 255, 0, 0, 2538, 2539, 5, 42, 0, 0, 2539, 2540, 3, 32, 16, 0, 2540, 2541, 5, 43, 0, 0, 2541, 2545, 3, 206, 103, 0, 2542, 2544, 3, 322, 161, 0, 2543, 2542, 1, 0, 0, 0, 2544, 2547, 1, 0, 0, 0, 2545, 2543, 1, 0, 0, 0, 2545, 2546, 1, 0, 0, 0, 2546, 2549, 1, 0, 0, 0, 2547, 2545, 1, 0, 0, 0, 2548, 2450, 1, 0, 0, 0, 2548, 2452, 1, 0, 0, 0, 2548, 2455, 1, 0, 0, 0, 2548, 2456, 1, 0, 0, 0, 2548, 2457, 1, 0, 0, 0, 2548, 2458, 1, 0, 0, 0, 2548, 2459, 1, 0, 0, 0, 2548, 2460, 1, 0, 0, 0, 2548, 2461, 1, 0, 0, 0, 2548, 2466, 1, 0, 0, 0, 2548, 2473, 1, 0, 0, 0, 2548, 2478, 1, 0, 0, 0, 2548, 2483, 1, 0, 0, 0, 2548, 2493, 1, 0, 0, 0, 2548, 2504, 1, 0, 0, 0, 2548, 2513, 1, 0, 0, 0, 2548, 2526, 1, 0, 0, 0, 2548, 2537, 1, 0, 0, 0, 2549, 251, 1, 0, 0, 0, 2550, 2551, 3, 0, 0, 0, 2551, 2552, 5, 75, 0, 0, 2552, 2553, 6, 126, -1, 0, 2553, 253, 1, 0, 0, 0, 2554, 2557, 3, 44, 22, 0, 2555, 2557, 3, 46, 23, 0, 2556, 2554, 1, 0, 0, 0, 2556, 2555, 1, 0, 0, 0, 2557, 255, 1, 0, 0, 0, 2558, 2559, 5, 17, 0, 0, 2559, 2560, 3, 246, 123, 0, 2560, 2561, 5, 18, 0, 0, 2561, 257, 1, 0, 0, 0, 2562, 2563, 3, 262, 131, 0, 2563, 2564, 3, 260, 130, 0, 2564, 259, 1, 0, 0, 0, 2565, 2567, 3, 264, 132, 0, 2566, 2565, 1, 0, 0, 0, 2567, 2568, 1, 0, 0, 0, 2568, 2566, 1, 0, 0, 0, 2568, 2569, 1, 0, 0, 0, 2569, 261, 1, 0, 0, 0, 2570, 2571, 5, 158, 0, 0, 2571, 2583, 3, 256, 128, 0, 2572, 2573, 5, 158, 0, 0, 2573, 2574, 3, 0, 0, 0, 2574, 2575, 5, 159, 0, 0, 2575, 2576, 3, 0, 0, 0, 2576, 2583, 1, 0, 0, 0, 2577, 2578, 5, 158, 0, 0, 2578, 2579, 3, 32, 16, 0, 2579, 2580, 5, 159, 0, 0, 2580, 2581, 3, 32, 16, 0, 2581, 2583, 1, 0, 0, 0, 2582, 2570, 1, 0, 0, 0, 2582, 2572, 1, 0, 0, 0, 2582, 2577, 1, 0, 0, 0, 2583, 263, 1, 0, 0, 0, 2584, 2585, 3, 268, 134, 0, 2585, 2586, 3, 274, 137, 0, 2586, 2597, 1, 0, 0, 0, 2587, 2588, 3, 266, 133, 0, 2588, 2589, 3, 274, 137, 0, 2589, 2597, 1, 0, 0, 0, 2590, 2591, 3, 270, 135, 0, 2591, 2592, 3, 274, 137, 0, 2592, 2597, 1, 0, 0, 0, 2593, 2594, 3, 272, 136, 0, 2594, 2595, 3, 274, 137, 0, 2595, 2597, 1, 0, 0, 0, 2596, 2584, 1, 0, 0, 0, 2596, 2587, 1, 0, 0, 0, 2596, 2590, 1, 0, 0, 0, 2596, 2593, 1, 0, 0, 0, 2597, 265, 1, 0, 0, 0, 2598, 2599, 5, 160, 0, 0, 2599, 2605, 3, 256, 128, 0, 2600, 2601, 5, 160, 0, 0, 2601, 2605, 3, 0, 0, 0, 2602, 2603, 5, 160, 0, 0, 2603, 2605, 3, 32, 16, 0, 2604, 2598, 1, 0, 0, 0, 2604, 2600, 1, 0, 0, 0, 2604, 2602, 1, 0, 0, 0, 2605, 267, 1, 0, 0, 0, 2606, 2607, 5, 161, 0, 0, 2607, 2608, 3, 124, 62, 0, 2608, 269, 1, 0, 0, 0, 2609, 2610, 5, 162, 0, 0, 2610, 271, 1, 0, 0, 0, 2611, 2612, 5, 163, 0, 0, 2612, 273, 1, 0, 0, 0, 2613, 2625, 3, 256, 128, 0, 2614, 2615, 5, 164, 0, 0, 2615, 2616, 3, 0, 0, 0, 2616, 2617, 5, 159, 0, 0, 2617, 2618, 3, 0, 0, 0, 2618, 2625, 1, 0, 0, 0, 2619, 2620, 5, 164, 0, 0, 2620, 2621, 3, 32, 16, 0, 2621, 2622, 5, 159, 0, 0, 2622, 2623, 3, 32, 16, 0, 2623, 2625, 1, 0, 0, 0, 2624, 2613, 1, 0, 0, 0, 2624, 2614, 1, 0, 0, 0, 2624, 2619, 1, 0, 0, 0, 2625, 275, 1, 0, 0, 0, 2626, 2627, 3, 278, 139, 0, 2627, 2628, 3, 282, 141, 0, 2628, 277, 1, 0, 0, 0, 2629, 2630, 5, 165, 0, 0, 2630, 2631, 3, 280, 140, 0, 2631, 2632, 3, 0, 0, 0, 2632, 2633, 5, 36, 0, 0, 2633, 2637, 1, 0, 0, 0, 2634, 2635, 5, 165, 0, 0, 2635, 2637, 3, 280, 140, 0, 2636, 2629, 1, 0, 0, 0, 2636, 2634, 1, 0, 0, 0, 2637, 279, 1, 0, 0, 0, 2638, 2642, 1, 0, 0, 0, 2639, 2642, 5, 166, 0, 0, 2640, 2642, 5, 2, 0, 0, 2641, 2638, 1, 0, 0, 0, 2641, 2639, 1, 0, 0, 0, 2641, 2640, 1, 0, 0, 0, 2642, 281, 1, 0, 0, 0, 2643, 2644, 5, 17, 0, 0, 2644, 2645, 3, 284, 142, 0, 2645, 2646, 5, 18, 0, 0, 2646, 2653, 1, 0, 0, 0, 2647, 2649, 3, 288, 144, 0, 2648, 2647, 1, 0, 0, 0, 2649, 2650, 1, 0, 0, 0, 2650, 2648, 1, 0, 0, 0, 2650, 2651, 1, 0, 0, 0, 2651, 2653, 1, 0, 0, 0, 2652, 2643, 1, 0, 0, 0, 2652, 2648, 1, 0, 0, 0, 2653, 283, 1, 0, 0, 0, 2654, 2655, 3, 288, 144, 0, 2655, 2656, 5, 28, 0, 0, 2656, 2658, 1, 0, 0, 0, 2657, 2654, 1, 0, 0, 0, 2658, 2661, 1, 0, 0, 0, 2659, 2657, 1, 0, 0, 0, 2659, 2660, 1, 0, 0, 0, 2660, 2662, 1, 0, 0, 0, 2661, 2659, 1, 0, 0, 0, 2662, 2663, 3, 288, 144, 0, 2663, 285, 1, 0, 0, 0, 2664, 2670, 1, 0, 0, 0, 2665, 2666, 5, 42, 0, 0, 2666, 2667, 3, 32, 16, 0, 2667, 2668, 5, 43, 0, 0, 2668, 2670, 1, 0, 0, 0, 2669, 2664, 1, 0, 0, 0, 2669, 2665, 1, 0, 0, 0, 2670, 287, 1, 0, 0, 0, 2671, 2672, 5, 181, 0, 0, 2672, 2673, 5, 262, 0, 0, 2673, 2674, 5, 30, 0, 0, 2674, 2675, 3, 6, 3, 0, 2675, 2676, 5, 31, 0, 0, 2676, 2738, 1, 0, 0, 0, 2677, 2678, 5, 260, 0, 0, 2678, 2679, 5, 30, 0, 0, 2679, 2680, 3, 0, 0, 0, 2680, 2681, 5, 31, 0, 0, 2681, 2738, 1, 0, 0, 0, 2682, 2683, 5, 260, 0, 0, 2683, 2738, 3, 0, 0, 0, 2684, 2685, 5, 84, 0, 0, 2685, 2686, 5, 30, 0, 0, 2686, 2687, 3, 292, 146, 0, 2687, 2688, 5, 31, 0, 0, 2688, 2738, 1, 0, 0, 0, 2689, 2690, 5, 188, 0, 0, 2690, 2691, 5, 30, 0, 0, 2691, 2692, 3, 36, 18, 0, 2692, 2693, 5, 31, 0, 0, 2693, 2694, 3, 286, 143, 0, 2694, 2738, 1, 0, 0, 0, 2695, 2696, 5, 189, 0, 0, 2696, 2697, 5, 30, 0, 0, 2697, 2698, 3, 36, 18, 0, 2698, 2699, 5, 31, 0, 0, 2699, 2700, 3, 286, 143, 0, 2700, 2738, 1, 0, 0, 0, 2701, 2702, 5, 187, 0, 0, 2702, 2703, 5, 30, 0, 0, 2703, 2704, 3, 34, 17, 0, 2704, 2705, 5, 31, 0, 0, 2705, 2706, 3, 286, 143, 0, 2706, 2738, 1, 0, 0, 0, 2707, 2708, 5, 186, 0, 0, 2708, 2709, 5, 30, 0, 0, 2709, 2710, 3, 32, 16, 0, 2710, 2711, 5, 31, 0, 0, 2711, 2712, 3, 286, 143, 0, 2712, 2738, 1, 0, 0, 0, 2713, 2714, 5, 185, 0, 0, 2714, 2715, 5, 30, 0, 0, 2715, 2716, 3, 32, 16, 0, 2716, 2717, 5, 31, 0, 0, 2717, 2718, 3, 286, 143, 0, 2718, 2738, 1, 0, 0, 0, 2719, 2720, 5, 184, 0, 0, 2720, 2721, 5, 30, 0, 0, 2721, 2722, 3, 32, 16, 0, 2722, 2723, 5, 31, 0, 0, 2723, 2724, 3, 286, 143, 0, 2724, 2738, 1, 0, 0, 0, 2725, 2726, 5, 188, 0, 0, 2726, 2738, 3, 286, 143, 0, 2727, 2728, 5, 189, 0, 0, 2728, 2738, 3, 286, 143, 0, 2729, 2730, 5, 187, 0, 0, 2730, 2738, 3, 286, 143, 0, 2731, 2732, 5, 186, 0, 0, 2732, 2738, 3, 286, 143, 0, 2733, 2734, 5, 185, 0, 0, 2734, 2738, 3, 286, 143, 0, 2735, 2736, 5, 184, 0, 0, 2736, 2738, 3, 286, 143, 0, 2737, 2671, 1, 0, 0, 0, 2737, 2677, 1, 0, 0, 0, 2737, 2682, 1, 0, 0, 0, 2737, 2684, 1, 0, 0, 0, 2737, 2689, 1, 0, 0, 0, 2737, 2695, 1, 0, 0, 0, 2737, 2701, 1, 0, 0, 0, 2737, 2707, 1, 0, 0, 0, 2737, 2713, 1, 0, 0, 0, 2737, 2719, 1, 0, 0, 0, 2737, 2725, 1, 0, 0, 0, 2737, 2727, 1, 0, 0, 0, 2737, 2729, 1, 0, 0, 0, 2737, 2731, 1, 0, 0, 0, 2737, 2733, 1, 0, 0, 0, 2737, 2735, 1, 0, 0, 0, 2738, 289, 1, 0, 0, 0, 2739, 2740, 5, 188, 0, 0, 2740, 2741, 5, 30, 0, 0, 2741, 2742, 3, 36, 18, 0, 2742, 2743, 5, 31, 0, 0, 2743, 2815, 1, 0, 0, 0, 2744, 2745, 5, 189, 0, 0, 2745, 2746, 5, 30, 0, 0, 2746, 2747, 3, 36, 18, 0, 2747, 2748, 5, 31, 0, 0, 2748, 2815, 1, 0, 0, 0, 2749, 2750, 5, 188, 0, 0, 2750, 2751, 5, 30, 0, 0, 2751, 2752, 3, 32, 16, 0, 2752, 2753, 5, 31, 0, 0, 2753, 2815, 1, 0, 0, 0, 2754, 2755, 5, 189, 0, 0, 2755, 2756, 5, 30, 0, 0, 2756, 2757, 3, 34, 17, 0, 2757, 2758, 5, 31, 0, 0, 2758, 2815, 1, 0, 0, 0, 2759, 2760, 5, 187, 0, 0, 2760, 2761, 5, 30, 0, 0, 2761, 2762, 3, 34, 17, 0, 2762, 2763, 5, 31, 0, 0, 2763, 2815, 1, 0, 0, 0, 2764, 2765, 5, 186, 0, 0, 2765, 2766, 5, 30, 0, 0, 2766, 2767, 3, 32, 16, 0, 2767, 2768, 5, 31, 0, 0, 2768, 2815, 1, 0, 0, 0, 2769, 2770, 5, 185, 0, 0, 2770, 2771, 5, 30, 0, 0, 2771, 2772, 3, 32, 16, 0, 2772, 2773, 5, 31, 0, 0, 2773, 2815, 1, 0, 0, 0, 2774, 2775, 5, 184, 0, 0, 2775, 2776, 5, 30, 0, 0, 2776, 2777, 3, 32, 16, 0, 2777, 2778, 5, 31, 0, 0, 2778, 2815, 1, 0, 0, 0, 2779, 2780, 5, 193, 0, 0, 2780, 2781, 5, 30, 0, 0, 2781, 2782, 3, 34, 17, 0, 2782, 2783, 5, 31, 0, 0, 2783, 2815, 1, 0, 0, 0, 2784, 2785, 5, 192, 0, 0, 2785, 2786, 5, 30, 0, 0, 2786, 2787, 3, 32, 16, 0, 2787, 2788, 5, 31, 0, 0, 2788, 2815, 1, 0, 0, 0, 2789, 2790, 5, 191, 0, 0, 2790, 2791, 5, 30, 0, 0, 2791, 2792, 3, 32, 16, 0, 2792, 2793, 5, 31, 0, 0, 2793, 2815, 1, 0, 0, 0, 2794, 2795, 5, 190, 0, 0, 2795, 2796, 5, 30, 0, 0, 2796, 2797, 3, 32, 16, 0, 2797, 2798, 5, 31, 0, 0, 2798, 2815, 1, 0, 0, 0, 2799, 2800, 5, 181, 0, 0, 2800, 2801, 5, 30, 0, 0, 2801, 2802, 3, 32, 16, 0, 2802, 2803, 5, 31, 0, 0, 2803, 2815, 1, 0, 0, 0, 2804, 2805, 5, 183, 0, 0, 2805, 2806, 5, 30, 0, 0, 2806, 2807, 3, 162, 81, 0, 2807, 2808, 5, 31, 0, 0, 2808, 2815, 1, 0, 0, 0, 2809, 2810, 5, 84, 0, 0, 2810, 2811, 5, 30, 0, 0, 2811, 2812, 3, 292, 146, 0, 2812, 2813, 5, 31, 0, 0, 2813, 2815, 1, 0, 0, 0, 2814, 2739, 1, 0, 0, 0, 2814, 2744, 1, 0, 0, 0, 2814, 2749, 1, 0, 0, 0, 2814, 2754, 1, 0, 0, 0, 2814, 2759, 1, 0, 0, 0, 2814, 2764, 1, 0, 0, 0, 2814, 2769, 1, 0, 0, 0, 2814, 2774, 1, 0, 0, 0, 2814, 2779, 1, 0, 0, 0, 2814, 2784, 1, 0, 0, 0, 2814, 2789, 1, 0, 0, 0, 2814, 2794, 1, 0, 0, 0, 2814, 2799, 1, 0, 0, 0, 2814, 2804, 1, 0, 0, 0, 2814, 2809, 1, 0, 0, 0, 2815, 291, 1, 0, 0, 0, 2816, 2817, 3, 294, 147, 0, 2817, 2818, 6, 146, -1, 0, 2818, 2820, 1, 0, 0, 0, 2819, 2816, 1, 0, 0, 0, 2820, 2823, 1, 0, 0, 0, 2821, 2819, 1, 0, 0, 0, 2821, 2822, 1, 0, 0, 0, 2822, 293, 1, 0, 0, 0, 2823, 2821, 1, 0, 0, 0, 2824, 2825, 7, 11, 0, 0, 2825, 295, 1, 0, 0, 0, 2826, 2830, 3, 290, 145, 0, 2827, 2830, 3, 6, 3, 0, 2828, 2830, 5, 179, 0, 0, 2829, 2826, 1, 0, 0, 0, 2829, 2827, 1, 0, 0, 0, 2829, 2828, 1, 0, 0, 0, 2830, 297, 1, 0, 0, 0, 2831, 2980, 3, 290, 145, 0, 2832, 2833, 5, 182, 0, 0, 2833, 2834, 5, 30, 0, 0, 2834, 2835, 5, 179, 0, 0, 2835, 2980, 5, 31, 0, 0, 2836, 2837, 5, 182, 0, 0, 2837, 2838, 5, 30, 0, 0, 2838, 2839, 5, 264, 0, 0, 2839, 2980, 5, 31, 0, 0, 2840, 2841, 5, 196, 0, 0, 2841, 2842, 5, 30, 0, 0, 2842, 2843, 5, 39, 0, 0, 2843, 2844, 5, 264, 0, 0, 2844, 2980, 5, 31, 0, 0, 2845, 2846, 5, 196, 0, 0, 2846, 2847, 5, 30, 0, 0, 2847, 2848, 3, 116, 58, 0, 2848, 2849, 5, 31, 0, 0, 2849, 2980, 1, 0, 0, 0, 2850, 2851, 5, 196, 0, 0, 2851, 2852, 5, 30, 0, 0, 2852, 2853, 5, 179, 0, 0, 2853, 2980, 5, 31, 0, 0, 2854, 2855, 5, 197, 0, 0, 2855, 2856, 5, 30, 0, 0, 2856, 2857, 3, 298, 149, 0, 2857, 2858, 5, 31, 0, 0, 2858, 2980, 1, 0, 0, 0, 2859, 2860, 5, 188, 0, 0, 2860, 2861, 5, 42, 0, 0, 2861, 2862, 3, 32, 16, 0, 2862, 2863, 5, 43, 0, 0, 2863, 2864, 5, 30, 0, 0, 2864, 2865, 3, 300, 150, 0, 2865, 2866, 5, 31, 0, 0, 2866, 2980, 1, 0, 0, 0, 2867, 2868, 5, 189, 0, 0, 2868, 2869, 5, 42, 0, 0, 2869, 2870, 3, 32, 16, 0, 2870, 2871, 5, 43, 0, 0, 2871, 2872, 5, 30, 0, 0, 2872, 2873, 3, 302, 151, 0, 2873, 2874, 5, 31, 0, 0, 2874, 2980, 1, 0, 0, 0, 2875, 2876, 5, 187, 0, 0, 2876, 2877, 5, 42, 0, 0, 2877, 2878, 3, 32, 16, 0, 2878, 2879, 5, 43, 0, 0, 2879, 2880, 5, 30, 0, 0, 2880, 2881, 3, 304, 152, 0, 2881, 2882, 5, 31, 0, 0, 2882, 2980, 1, 0, 0, 0, 2883, 2884, 5, 186, 0, 0, 2884, 2885, 5, 42, 0, 0, 2885, 2886, 3, 32, 16, 0, 2886, 2887, 5, 43, 0, 0, 2887, 2888, 5, 30, 0, 0, 2888, 2889, 3, 306, 153, 0, 2889, 2890, 5, 31, 0, 0, 2890, 2980, 1, 0, 0, 0, 2891, 2892, 5, 185, 0, 0, 2892, 2893, 5, 42, 0, 0, 2893, 2894, 3, 32, 16, 0, 2894, 2895, 5, 43, 0, 0, 2895, 2896, 5, 30, 0, 0, 2896, 2897, 3, 308, 154, 0, 2897, 2898, 5, 31, 0, 0, 2898, 2980, 1, 0, 0, 0, 2899, 2900, 5, 184, 0, 0, 2900, 2901, 5, 42, 0, 0, 2901, 2902, 3, 32, 16, 0, 2902, 2903, 5, 43, 0, 0, 2903, 2904, 5, 30, 0, 0, 2904, 2905, 3, 310, 155, 0, 2905, 2906, 5, 31, 0, 0, 2906, 2980, 1, 0, 0, 0, 2907, 2908, 5, 193, 0, 0, 2908, 2909, 5, 42, 0, 0, 2909, 2910, 3, 32, 16, 0, 2910, 2911, 5, 43, 0, 0, 2911, 2912, 5, 30, 0, 0, 2912, 2913, 3, 304, 152, 0, 2913, 2914, 5, 31, 0, 0, 2914, 2980, 1, 0, 0, 0, 2915, 2916, 5, 192, 0, 0, 2916, 2917, 5, 42, 0, 0, 2917, 2918, 3, 32, 16, 0, 2918, 2919, 5, 43, 0, 0, 2919, 2920, 5, 30, 0, 0, 2920, 2921, 3, 306, 153, 0, 2921, 2922, 5, 31, 0, 0, 2922, 2980, 1, 0, 0, 0, 2923, 2924, 5, 191, 0, 0, 2924, 2925, 5, 42, 0, 0, 2925, 2926, 3, 32, 16, 0, 2926, 2927, 5, 43, 0, 0, 2927, 2928, 5, 30, 0, 0, 2928, 2929, 3, 308, 154, 0, 2929, 2930, 5, 31, 0, 0, 2930, 2980, 1, 0, 0, 0, 2931, 2932, 5, 190, 0, 0, 2932, 2933, 5, 42, 0, 0, 2933, 2934, 3, 32, 16, 0, 2934, 2935, 5, 43, 0, 0, 2935, 2936, 5, 30, 0, 0, 2936, 2937, 3, 310, 155, 0, 2937, 2938, 5, 31, 0, 0, 2938, 2980, 1, 0, 0, 0, 2939, 2940, 5, 181, 0, 0, 2940, 2941, 5, 42, 0, 0, 2941, 2942, 3, 32, 16, 0, 2942, 2943, 5, 43, 0, 0, 2943, 2944, 5, 30, 0, 0, 2944, 2945, 3, 308, 154, 0, 2945, 2946, 5, 31, 0, 0, 2946, 2980, 1, 0, 0, 0, 2947, 2948, 5, 183, 0, 0, 2948, 2949, 5, 42, 0, 0, 2949, 2950, 3, 32, 16, 0, 2950, 2951, 5, 43, 0, 0, 2951, 2952, 5, 30, 0, 0, 2952, 2953, 3, 312, 156, 0, 2953, 2954, 5, 31, 0, 0, 2954, 2980, 1, 0, 0, 0, 2955, 2956, 5, 182, 0, 0, 2956, 2957, 5, 42, 0, 0, 2957, 2958, 3, 32, 16, 0, 2958, 2959, 5, 43, 0, 0, 2959, 2960, 5, 30, 0, 0, 2960, 2961, 3, 314, 157, 0, 2961, 2962, 5, 31, 0, 0, 2962, 2980, 1, 0, 0, 0, 2963, 2964, 5, 196, 0, 0, 2964, 2965, 5, 42, 0, 0, 2965, 2966, 3, 32, 16, 0, 2966, 2967, 5, 43, 0, 0, 2967, 2968, 5, 30, 0, 0, 2968, 2969, 3, 316, 158, 0, 2969, 2970, 5, 31, 0, 0, 2970, 2980, 1, 0, 0, 0, 2971, 2972, 5, 197, 0, 0, 2972, 2973, 5, 42, 0, 0, 2973, 2974, 3, 32, 16, 0, 2974, 2975, 5, 43, 0, 0, 2975, 2976, 5, 30, 0, 0, 2976, 2977, 3, 320, 160, 0, 2977, 2978, 5, 31, 0, 0, 2978, 2980, 1, 0, 0, 0, 2979, 2831, 1, 0, 0, 0, 2979, 2832, 1, 0, 0, 0, 2979, 2836, 1, 0, 0, 0, 2979, 2840, 1, 0, 0, 0, 2979, 2845, 1, 0, 0, 0, 2979, 2850, 1, 0, 0, 0, 2979, 2854, 1, 0, 0, 0, 2979, 2859, 1, 0, 0, 0, 2979, 2867, 1, 0, 0, 0, 2979, 2875, 1, 0, 0, 0, 2979, 2883, 1, 0, 0, 0, 2979, 2891, 1, 0, 0, 0, 2979, 2899, 1, 0, 0, 0, 2979, 2907, 1, 0, 0, 0, 2979, 2915, 1, 0, 0, 0, 2979, 2923, 1, 0, 0, 0, 2979, 2931, 1, 0, 0, 0, 2979, 2939, 1, 0, 0, 0, 2979, 2947, 1, 0, 0, 0, 2979, 2955, 1, 0, 0, 0, 2979, 2963, 1, 0, 0, 0, 2979, 2971, 1, 0, 0, 0, 2980, 299, 1, 0, 0, 0, 2981, 2984, 3, 36, 18, 0, 2982, 2984, 3, 32, 16, 0, 2983, 2981, 1, 0, 0, 0, 2983, 2982, 1, 0, 0, 0, 2984, 2987, 1, 0, 0, 0, 2985, 2983, 1, 0, 0, 0, 2985, 2986, 1, 0, 0, 0, 2986, 301, 1, 0, 0, 0, 2987, 2985, 1, 0, 0, 0, 2988, 2991, 3, 36, 18, 0, 2989, 2991, 3, 34, 17, 0, 2990, 2988, 1, 0, 0, 0, 2990, 2989, 1, 0, 0, 0, 2991, 2994, 1, 0, 0, 0, 2992, 2990, 1, 0, 0, 0, 2992, 2993, 1, 0, 0, 0, 2993, 303, 1, 0, 0, 0, 2994, 2992, 1, 0, 0, 0, 2995, 2997, 3, 34, 17, 0, 2996, 2995, 1, 0, 0, 0, 2997, 3000, 1, 0, 0, 0, 2998, 2996, 1, 0, 0, 0, 2998, 2999, 1, 0, 0, 0, 2999, 305, 1, 0, 0, 0, 3000, 2998, 1, 0, 0, 0, 3001, 3003, 3, 32, 16, 0, 3002, 3001, 1, 0, 0, 0, 3003, 3006, 1, 0, 0, 0, 3004, 3002, 1, 0, 0, 0, 3004, 3005, 1, 0, 0, 0, 3005, 307, 1, 0, 0, 0, 3006, 3004, 1, 0, 0, 0, 3007, 3009, 3, 32, 16, 0, 3008, 3007, 1, 0, 0, 0, 3009, 3012, 1, 0, 0, 0, 3010, 3008, 1, 0, 0, 0, 3010, 3011, 1, 0, 0, 0, 3011, 309, 1, 0, 0, 0, 3012, 3010, 1, 0, 0, 0, 3013, 3015, 3, 32, 16, 0, 3014, 3013, 1, 0, 0, 0, 3015, 3018, 1, 0, 0, 0, 3016, 3014, 1, 0, 0, 0, 3016, 3017, 1, 0, 0, 0, 3017, 311, 1, 0, 0, 0, 3018, 3016, 1, 0, 0, 0, 3019, 3021, 3, 162, 81, 0, 3020, 3019, 1, 0, 0, 0, 3021, 3024, 1, 0, 0, 0, 3022, 3020, 1, 0, 0, 0, 3022, 3023, 1, 0, 0, 0, 3023, 313, 1, 0, 0, 0, 3024, 3022, 1, 0, 0, 0, 3025, 3027, 7, 12, 0, 0, 3026, 3025, 1, 0, 0, 0, 3027, 3030, 1, 0, 0, 0, 3028, 3026, 1, 0, 0, 0, 3028, 3029, 1, 0, 0, 0, 3029, 315, 1, 0, 0, 0, 3030, 3028, 1, 0, 0, 0, 3031, 3033, 3, 318, 159, 0, 3032, 3031, 1, 0, 0, 0, 3033, 3036, 1, 0, 0, 0, 3034, 3032, 1, 0, 0, 0, 3034, 3035, 1, 0, 0, 0, 3035, 317, 1, 0, 0, 0, 3036, 3034, 1, 0, 0, 0, 3037, 3042, 5, 179, 0, 0, 3038, 3039, 5, 39, 0, 0, 3039, 3042, 5, 264, 0, 0, 3040, 3042, 3, 116, 58, 0, 3041, 3037, 1, 0, 0, 0, 3041, 3038, 1, 0, 0, 0, 3041, 3040, 1, 0, 0, 0, 3042, 319, 1, 0, 0, 0, 3043, 3045, 3, 298, 149, 0, 3044, 3043, 1, 0, 0, 0, 3045, 3048, 1, 0, 0, 0, 3046, 3044, 1, 0, 0, 0, 3046, 3047, 1, 0, 0, 0, 3047, 321, 1, 0, 0, 0, 3048, 3046, 1, 0, 0, 0, 3049, 3053, 3, 44, 22, 0, 3050, 3053, 3, 46, 23, 0, 3051, 3053, 3, 2, 1, 0, 3052, 3049, 1, 0, 0, 0, 3052, 3050, 1, 0, 0, 0, 3052, 3051, 1, 0, 0, 0, 3053, 323, 1, 0, 0, 0, 3054, 3055, 7, 13, 0, 0, 3055, 3056, 5, 36, 0, 0, 3056, 3057, 5, 30, 0, 0, 3057, 3058, 3, 292, 146, 0, 3058, 3059, 5, 31, 0, 0, 3059, 3080, 1, 0, 0, 0, 3060, 3061, 5, 169, 0, 0, 3061, 3062, 3, 38, 19, 0, 3062, 3063, 5, 75, 0, 0, 3063, 3064, 3, 38, 19, 0, 3064, 3065, 5, 75, 0, 0, 3065, 3066, 3, 38, 19, 0, 3066, 3067, 5, 75, 0, 0, 3067, 3068, 3, 38, 19, 0, 3068, 3080, 1, 0, 0, 0, 3069, 3070, 5, 170, 0, 0, 3070, 3080, 3, 6, 3, 0, 3071, 3072, 5, 170, 0, 0, 3072, 3073, 5, 36, 0, 0, 3073, 3074, 5, 30, 0, 0, 3074, 3075, 3, 292, 146, 0, 3075, 3076, 5, 31, 0, 0, 3076, 3080, 1, 0, 0, 0, 3077, 3080, 3, 322, 161, 0, 3078, 3080, 3, 40, 20, 0, 3079, 3054, 1, 0, 0, 0, 3079, 3060, 1, 0, 0, 0, 3079, 3069, 1, 0, 0, 0, 3079, 3071, 1, 0, 0, 0, 3079, 3077, 1, 0, 0, 0, 3079, 3078, 1, 0, 0, 0, 3080, 325, 1, 0, 0, 0, 3081, 3082, 5, 25, 0, 0, 3082, 3083, 5, 40, 0, 0, 3083, 3084, 3, 98, 49, 0, 3084, 3085, 3, 2, 1, 0, 3085, 3094, 1, 0, 0, 0, 3086, 3087, 5, 25, 0, 0, 3087, 3088, 5, 40, 0, 0, 3088, 3089, 3, 98, 49, 0, 3089, 3090, 3, 2, 1, 0, 3090, 3091, 5, 34, 0, 0, 3091, 3092, 3, 2, 1, 0, 3092, 3094, 1, 0, 0, 0, 3093, 3081, 1, 0, 0, 0, 3093, 3086, 1, 0, 0, 0, 3094, 327, 1, 0, 0, 0, 3095, 3097, 3, 330, 165, 0, 3096, 3095, 1, 0, 0, 0, 3097, 3100, 1, 0, 0, 0, 3098, 3096, 1, 0, 0, 0, 3098, 3099, 1, 0, 0, 0, 3099, 329, 1, 0, 0, 0, 3100, 3098, 1, 0, 0, 0, 3101, 3102, 5, 180, 0, 0, 3102, 3103, 5, 36, 0, 0, 3103, 3104, 5, 30, 0, 0, 3104, 3105, 3, 292, 146, 0, 3105, 3106, 5, 31, 0, 0, 3106, 3116, 1, 0, 0, 0, 3107, 3116, 3, 324, 162, 0, 3108, 3109, 5, 171, 0, 0, 3109, 3110, 5, 36, 0, 0, 3110, 3111, 5, 30, 0, 0, 3111, 3112, 3, 292, 146, 0, 3112, 3113, 5, 31, 0, 0, 3113, 3116, 1, 0, 0, 0, 3114, 3116, 5, 55, 0, 0, 3115, 3101, 1, 0, 0, 0, 3115, 3107, 1, 0, 0, 0, 3115, 3108, 1, 0, 0, 0, 3115, 3114, 1, 0, 0, 0, 3116, 331, 1, 0, 0, 0, 3117, 3118, 5, 50, 0, 0, 3118, 3122, 5, 40, 0, 0, 3119, 3121, 3, 336, 168, 0, 3120, 3119, 1, 0, 0, 0, 3121, 3124, 1, 0, 0, 0, 3122, 3120, 1, 0, 0, 0, 3122, 3123, 1, 0, 0, 0, 3123, 3125, 1, 0, 0, 0, 3124, 3122, 1, 0, 0, 0, 3125, 3126, 3, 2, 1, 0, 3126, 333, 1, 0, 0, 0, 3127, 3131, 5, 301, 0, 0, 3128, 3130, 3, 336, 168, 0, 3129, 3128, 1, 0, 0, 0, 3130, 3133, 1, 0, 0, 0, 3131, 3129, 1, 0, 0, 0, 3131, 3132, 1, 0, 0, 0, 3132, 3134, 1, 0, 0, 0, 3133, 3131, 1, 0, 0, 0, 3134, 3135, 3, 2, 1, 0, 3135, 335, 1, 0, 0, 0, 3136, 3152, 5, 52, 0, 0, 3137, 3152, 5, 51, 0, 0, 3138, 3152, 5, 172, 0, 0, 3139, 3140, 5, 62, 0, 0, 3140, 3152, 5, 51, 0, 0, 3141, 3142, 5, 62, 0, 0, 3142, 3152, 5, 52, 0, 0, 3143, 3144, 5, 62, 0, 0, 3144, 3152, 5, 63, 0, 0, 3145, 3146, 5, 62, 0, 0, 3146, 3152, 5, 64, 0, 0, 3147, 3148, 5, 62, 0, 0, 3148, 3152, 5, 65, 0, 0, 3149, 3150, 5, 62, 0, 0, 3150, 3152, 5, 66, 0, 0, 3151, 3136, 1, 0, 0, 0, 3151, 3137, 1, 0, 0, 0, 3151, 3138, 1, 0, 0, 0, 3151, 3139, 1, 0, 0, 0, 3151, 3141, 1, 0, 0, 0, 3151, 3143, 1, 0, 0, 0, 3151, 3145, 1, 0, 0, 0, 3151, 3147, 1, 0, 0, 0, 3151, 3149, 1, 0, 0, 0, 3152, 337, 1, 0, 0, 0, 3153, 3155, 3, 340, 170, 0, 3154, 3153, 1, 0, 0, 0, 3155, 3158, 1, 0, 0, 0, 3156, 3154, 1, 0, 0, 0, 3156, 3157, 1, 0, 0, 0, 3157, 339, 1, 0, 0, 0, 3158, 3156, 1, 0, 0, 0, 3159, 3160, 5, 21, 0, 0, 3160, 3173, 3, 2, 1, 0, 3161, 3162, 5, 50, 0, 0, 3162, 3163, 5, 40, 0, 0, 3163, 3173, 3, 118, 59, 0, 3164, 3165, 5, 25, 0, 0, 3165, 3166, 5, 40, 0, 0, 3166, 3173, 3, 2, 1, 0, 3167, 3173, 3, 174, 87, 0, 3168, 3169, 5, 50, 0, 0, 3169, 3173, 3, 32, 16, 0, 3170, 3173, 3, 322, 161, 0, 3171, 3173, 3, 40, 20, 0, 3172, 3159, 1, 0, 0, 0, 3172, 3161, 1, 0, 0, 0, 3172, 3164, 1, 0, 0, 0, 3172, 3167, 1, 0, 0, 0, 3172, 3168, 1, 0, 0, 0, 3172, 3170, 1, 0, 0, 0, 3172, 3171, 1, 0, 0, 0, 3173, 341, 1, 0, 0, 0, 3174, 3178, 5, 274, 0, 0, 3175, 3177, 3, 344, 172, 0, 3176, 3175, 1, 0, 0, 0, 3177, 3180, 1, 0, 0, 0, 3178, 3176, 1, 0, 0, 0, 3178, 3179, 1, 0, 0, 0, 3179, 3181, 1, 0, 0, 0, 3180, 3178, 1, 0, 0, 0, 3181, 3194, 3, 2, 1, 0, 3182, 3186, 5, 274, 0, 0, 3183, 3185, 3, 344, 172, 0, 3184, 3183, 1, 0, 0, 0, 3185, 3188, 1, 0, 0, 0, 3186, 3184, 1, 0, 0, 0, 3186, 3187, 1, 0, 0, 0, 3187, 3189, 1, 0, 0, 0, 3188, 3186, 1, 0, 0, 0, 3189, 3190, 3, 2, 1, 0, 3190, 3191, 5, 34, 0, 0, 3191, 3192, 3, 2, 1, 0, 3192, 3194, 1, 0, 0, 0, 3193, 3174, 1, 0, 0, 0, 3193, 3182, 1, 0, 0, 0, 3194, 343, 1, 0, 0, 0, 3195, 3196, 7, 14, 0, 0, 3196, 345, 1, 0, 0, 0, 3197, 3199, 3, 348, 174, 0, 3198, 3197, 1, 0, 0, 0, 3199, 3202, 1, 0, 0, 0, 3200, 3198, 1, 0, 0, 0, 3200, 3201, 1, 0, 0, 0, 3201, 347, 1, 0, 0, 0, 3202, 3200, 1, 0, 0, 0, 3203, 3204, 5, 21, 0, 0, 3204, 3205, 3, 2, 1, 0, 3205, 3206, 5, 44, 0, 0, 3206, 3207, 3, 32, 16, 0, 3207, 3214, 1, 0, 0, 0, 3208, 3209, 5, 25, 0, 0, 3209, 3210, 5, 40, 0, 0, 3210, 3214, 3, 2, 1, 0, 3211, 3214, 3, 322, 161, 0, 3212, 3214, 3, 40, 20, 0, 3213, 3203, 1, 0, 0, 0, 3213, 3208, 1, 0, 0, 0, 3213, 3211, 1, 0, 0, 0, 3213, 3212, 1, 0, 0, 0, 3214, 349, 1, 0, 0, 0, 176, 360, 368, 377, 386, 439, 480, 489, 519, 523, 541, 568, 591, 627, 637, 644, 646, 656, 658, 665, 676, 684, 705, 707, 723, 768, 773, 778, 783, 791, 901, 907, 923, 929, 935, 942, 970, 1048, 1050, 1064, 1070, 1079, 1081, 1090, 1104, 1118, 1126, 1134, 1138, 1177, 1185, 1194, 1202, 1221, 1231, 1234, 1258, 1405, 1415, 1424, 1427, 1509, 1518, 1550, 1610, 1650, 1666, 1676, 1703, 1727, 1735, 1739, 1754, 1761, 1806, 1816, 1834, 1852, 1871, 1892, 1911, 1926, 1933, 1943, 1956, 1961, 1966, 1975, 1985, 2071, 2080, 2093, 2104, 2112, 2122, 2124, 2151, 2158, 2163, 2170, 2176, 2186, 2190, 2197, 2212, 2218, 2232, 2245, 2254, 2265, 2269, 2276, 2296, 2301, 2303, 2316, 2342, 2349, 2351, 2356, 2362, 2391, 2400, 2423, 2428, 2448, 2501, 2510, 2523, 2534, 2545, 2548, 2556, 2568, 2582, 2596, 2604, 2624, 2636, 2641, 2650, 2652, 2659, 2669, 2737, 2814, 2821, 2829, 2979, 2983, 2985, 2990, 2992, 2998, 3004, 3010, 3016, 3022, 3028, 3034, 3041, 3046, 3052, 3079, 3093, 3098, 3115, 3122, 3131, 3151, 3156, 3172, 3178, 3186, 3193, 3200, 3213] \ No newline at end of file diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs index 8fdfb7633941a9..4b638998bc9e1f 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs @@ -5249,7 +5249,7 @@ public SigArgContext sigArg() { } } - _localctx.Value = Actions.CreateSignatureArgument(_localctx.attributes.Value, _localctx.argumentType.Value, _localctx.marshalling, _localctx.name); + _localctx.Value = Actions.CreateSignatureArgument(_localctx.attributes.Value, _localctx.argumentType.Value, _localctx.marshalling.Value, _localctx.name); } break; } @@ -5730,6 +5730,9 @@ public TypeSpecContext typeSpec() { } public partial class NativeTypeContext : ParserRuleContext { + public object Value; + public NativeTypeElementContext element; + public NativeTypeArrayPointerInfoContext info; [System.Diagnostics.DebuggerNonUserCode] public NativeTypeElementContext nativeTypeElement() { return GetRuleContext(0); } @@ -5756,9 +5759,10 @@ public override TResult Accept(IParseTreeVisitor visitor) { public NativeTypeContext nativeType() { NativeTypeContext _localctx = new NativeTypeContext(Context, State); EnterRule(_localctx, 126, RULE_nativeType); + Actions.BeginNativeType(_localctx); try { int _alt; - State = 1231; + State = 1234; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,54,Context) ) { case 1: @@ -5770,20 +5774,22 @@ public NativeTypeContext nativeType() { EnterOuterAlt(_localctx, 2); { State = 1224; - nativeTypeElement(); - State = 1228; + _localctx.element = nativeTypeElement(); + Actions.SetNativeTypeElement(_localctx, _localctx.element.Value); + State = 1231; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,53,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1225; - nativeTypeArrayPointerInfo(); + State = 1226; + _localctx.info = nativeTypeArrayPointerInfo(); + Actions.AddNativeTypeArrayPointerInfo(_localctx, _localctx.info.Value); } } } - State = 1230; + State = 1233; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,53,Context); } @@ -5797,12 +5803,14 @@ public NativeTypeContext nativeType() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndNativeType(_localctx); ExitRule(); } return _localctx; } public partial class NativeTypeArrayPointerInfoContext : ParserRuleContext { + public object Value; public NativeTypeArrayPointerInfoContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { @@ -5812,9 +5820,11 @@ public NativeTypeArrayPointerInfoContext(ParserRuleContext parent, int invokingS public NativeTypeArrayPointerInfoContext() { } public virtual void CopyFrom(NativeTypeArrayPointerInfoContext context) { base.CopyFrom(context); + this.Value = context.Value; } } public partial class PointerArrayTypeSizeContext : NativeTypeArrayPointerInfoContext { + public Int32Context size; [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); } @@ -5827,6 +5837,7 @@ public override TResult Accept(IParseTreeVisitor visitor) { } } public partial class PointerArrayTypeParamIndexContext : NativeTypeArrayPointerInfoContext { + public Int32Context parameterIndex; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PLUS() { return GetToken(CILParser.PLUS, 0); } [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); @@ -5850,13 +5861,15 @@ public override TResult Accept(IParseTreeVisitor visitor) { } } public partial class PointerArrayTypeSizeParamIndexContext : NativeTypeArrayPointerInfoContext { + public Int32Context size; + public Int32Context parameterIndex; + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PLUS() { return GetToken(CILParser.PLUS, 0); } [System.Diagnostics.DebuggerNonUserCode] public Int32Context[] int32() { return GetRuleContexts(); } [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32(int i) { return GetRuleContext(i); } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PLUS() { return GetToken(CILParser.PLUS, 0); } public PointerArrayTypeSizeParamIndexContext(NativeTypeArrayPointerInfoContext context) { CopyFrom(context); } [System.Diagnostics.DebuggerNonUserCode] public override TResult Accept(IParseTreeVisitor visitor) { @@ -5881,65 +5894,70 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { NativeTypeArrayPointerInfoContext _localctx = new NativeTypeArrayPointerInfoContext(Context, State); EnterRule(_localctx, 128, RULE_nativeTypeArrayPointerInfo); try { - State = 1250; + State = 1258; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,55,Context) ) { case 1: _localctx = new PointerNativeTypeContext(_localctx); EnterOuterAlt(_localctx, 1); { - State = 1233; + State = 1236; Match(PTR); + _localctx.Value = Actions.CreatePointerNativeType(); } break; case 2: _localctx = new PointerArrayTypeNoSizeDataContext(_localctx); EnterOuterAlt(_localctx, 2); { - State = 1234; + State = 1238; Match(ARRAY_TYPE_NO_BOUNDS); + _localctx.Value = Actions.CreatePointerArrayTypeNoSizeData(); } break; case 3: _localctx = new PointerArrayTypeSizeContext(_localctx); EnterOuterAlt(_localctx, 3); { - State = 1235; + State = 1240; Match(T__41); - State = 1236; - int32(); - State = 1237; + State = 1241; + ((PointerArrayTypeSizeContext)_localctx).size = int32(); + State = 1242; Match(T__42); + _localctx.Value = Actions.CreatePointerArrayTypeSize((((PointerArrayTypeSizeContext)_localctx).size!=null?(((PointerArrayTypeSizeContext)_localctx).size.Start):null)); } break; case 4: _localctx = new PointerArrayTypeSizeParamIndexContext(_localctx); EnterOuterAlt(_localctx, 4); { - State = 1239; + State = 1245; Match(T__41); - State = 1240; - int32(); - State = 1241; + State = 1246; + ((PointerArrayTypeSizeParamIndexContext)_localctx).size = int32(); + State = 1247; Match(PLUS); - State = 1242; - int32(); - State = 1243; + State = 1248; + ((PointerArrayTypeSizeParamIndexContext)_localctx).parameterIndex = int32(); + State = 1249; Match(T__42); + _localctx.Value = Actions.CreatePointerArrayTypeSizeParamIndex((((PointerArrayTypeSizeParamIndexContext)_localctx).size!=null?(((PointerArrayTypeSizeParamIndexContext)_localctx).size.Start):null), (((PointerArrayTypeSizeParamIndexContext)_localctx).parameterIndex!=null?(((PointerArrayTypeSizeParamIndexContext)_localctx).parameterIndex.Start):null)); } break; case 5: _localctx = new PointerArrayTypeParamIndexContext(_localctx); EnterOuterAlt(_localctx, 5); { - State = 1245; + State = 1252; Match(T__41); - State = 1246; + State = 1253; Match(PLUS); - State = 1247; - int32(); - State = 1248; + State = 1254; + ((PointerArrayTypeParamIndexContext)_localctx).parameterIndex = int32(); + State = 1255; Match(T__42); + _localctx.Value = Actions.CreatePointerArrayTypeParamIndex((((PointerArrayTypeParamIndexContext)_localctx).parameterIndex!=null?(((PointerArrayTypeParamIndexContext)_localctx).parameterIndex.Start):null)); } break; } @@ -5956,25 +5974,36 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { } public partial class NativeTypeElementContext : ParserRuleContext { + public object Value; public IToken marshalType; + public CompQstringContext guid; + public CompQstringContext nativeTypeName; + public CompQstringContext marshallerType; + public CompQstringContext cookie; + public Int32Context size; + public NativeTypeContext element; + public IidParamIndexContext index; + public VariantTypeContext variant; + public CompQstringContext userDefinedType; public IToken unsignedMarshalType; public IToken marshalBool; + public DottedNameContext alias; + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CUSTOM() { return GetToken(CILParser.CUSTOM, 0); } [System.Diagnostics.DebuggerNonUserCode] public CompQstringContext[] compQstring() { return GetRuleContexts(); } [System.Diagnostics.DebuggerNonUserCode] public CompQstringContext compQstring(int i) { return GetRuleContext(i); } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CUSTOM() { return GetToken(CILParser.CUSTOM, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FIXED() { return GetToken(CILParser.FIXED, 0); } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SYSSTRING() { return GetToken(CILParser.SYSSTRING, 0); } [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SYSSTRING() { return GetToken(CILParser.SYSSTRING, 0); } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ARRAY() { return GetToken(CILParser.ARRAY, 0); } [System.Diagnostics.DebuggerNonUserCode] public NativeTypeContext nativeType() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ARRAY() { return GetToken(CILParser.ARRAY, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VARIANT() { return GetToken(CILParser.VARIANT, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CURRENCY() { return GetToken(CILParser.CURRENCY, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SYSCHAR() { return GetToken(CILParser.SYSCHAR, 0); } @@ -5998,17 +6027,17 @@ [System.Diagnostics.DebuggerNonUserCode] public NativeTypeContext nativeType() { [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LPWSTR() { return GetToken(CILParser.LPWSTR, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LPTSTR() { return GetToken(CILParser.LPTSTR, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode OBJECTREF() { return GetToken(CILParser.OBJECTREF, 0); } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IUNKNOWN() { return GetToken(CILParser.IUNKNOWN, 0); } [System.Diagnostics.DebuggerNonUserCode] public IidParamIndexContext iidParamIndex() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IUNKNOWN() { return GetToken(CILParser.IUNKNOWN, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDISPATCH() { return GetToken(CILParser.IDISPATCH, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STRUCT() { return GetToken(CILParser.STRUCT, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INTERFACE() { return GetToken(CILParser.INTERFACE, 0); } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SAFEARRAY() { return GetToken(CILParser.SAFEARRAY, 0); } [System.Diagnostics.DebuggerNonUserCode] public VariantTypeContext variantType() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SAFEARRAY() { return GetToken(CILParser.SAFEARRAY, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT() { return GetToken(CILParser.INT, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT() { return GetToken(CILParser.UINT, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BYVALSTR() { return GetToken(CILParser.BYVALSTR, 0); } @@ -6038,424 +6067,474 @@ public NativeTypeElementContext nativeTypeElement() { NativeTypeElementContext _localctx = new NativeTypeElementContext(Context, State); EnterRule(_localctx, 130, RULE_nativeTypeElement); try { - State = 1344; + State = 1405; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,56,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { + _localctx.Value = Actions.CreateEmptyNativeType(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1253; + State = 1261; _localctx.marshalType = Match(CUSTOM); - State = 1254; + State = 1262; Match(T__29); - State = 1255; - compQstring(); - State = 1256; + State = 1263; + _localctx.guid = compQstring(); + State = 1264; Match(T__27); - State = 1257; - compQstring(); - State = 1258; + State = 1265; + _localctx.nativeTypeName = compQstring(); + State = 1266; Match(T__27); - State = 1259; - compQstring(); - State = 1260; + State = 1267; + _localctx.marshallerType = compQstring(); + State = 1268; Match(T__27); - State = 1261; - compQstring(); - State = 1262; + State = 1269; + _localctx.cookie = compQstring(); + State = 1270; Match(T__30); + _localctx.Value = Actions.CreateDeprecatedCustomMarshallerNativeType( + _localctx, _localctx.guid.Value, _localctx.nativeTypeName.Value, _localctx.marshallerType.Value, _localctx.cookie.Value); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1264; + State = 1273; _localctx.marshalType = Match(CUSTOM); - State = 1265; + State = 1274; Match(T__29); - State = 1266; - compQstring(); - State = 1267; + State = 1275; + _localctx.marshallerType = compQstring(); + State = 1276; Match(T__27); - State = 1268; - compQstring(); - State = 1269; + State = 1277; + _localctx.cookie = compQstring(); + State = 1278; Match(T__30); + _localctx.Value = Actions.CreateCustomMarshallerNativeType(_localctx.marshallerType.Value, _localctx.cookie.Value); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1271; + State = 1281; Match(FIXED); - State = 1272; + State = 1282; _localctx.marshalType = Match(SYSSTRING); - State = 1273; + State = 1283; Match(T__41); - State = 1274; - int32(); - State = 1275; + State = 1284; + _localctx.size = int32(); + State = 1285; Match(T__42); + _localctx.Value = Actions.CreateFixedSysStringNativeType((_localctx.size!=null?(_localctx.size.Start):null)); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1277; + State = 1288; Match(FIXED); - State = 1278; + State = 1289; _localctx.marshalType = Match(ARRAY); - State = 1279; + State = 1290; Match(T__41); - State = 1280; - int32(); - State = 1281; + State = 1291; + _localctx.size = int32(); + State = 1292; Match(T__42); - State = 1282; - nativeType(); + State = 1293; + _localctx.element = nativeType(); + _localctx.Value = Actions.CreateFixedArrayNativeType((_localctx.size!=null?(_localctx.size.Start):null), _localctx.element.Value); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1284; + State = 1296; _localctx.marshalType = Match(VARIANT); + _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1285; + State = 1298; _localctx.marshalType = Match(CURRENCY); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1286; + State = 1300; _localctx.marshalType = Match(SYSCHAR); + _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 1287; + State = 1302; _localctx.marshalType = Match(VOID); + _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 1288; + State = 1304; _localctx.marshalType = Match(BOOL); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 1289; + State = 1306; _localctx.marshalType = Match(INT8); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 1290; + State = 1308; _localctx.marshalType = Match(INT16); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 1291; + State = 1310; _localctx.marshalType = Match(INT32_); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 1292; + State = 1312; _localctx.marshalType = Match(INT64_); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 1293; + State = 1314; _localctx.marshalType = Match(FLOAT32); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 1294; + State = 1316; _localctx.marshalType = Match(FLOAT64_); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 1295; + State = 1318; _localctx.marshalType = Match(ERROR); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 1296; + State = 1320; _localctx.marshalType = Match(UINT8); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 1297; + State = 1322; _localctx.marshalType = Match(UINT16); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 1298; + State = 1324; _localctx.marshalType = Match(UINT32); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 1299; + State = 1326; _localctx.marshalType = Match(UINT64); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 1300; + State = 1328; _localctx.marshalType = Match(DECIMAL); + _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } break; case 23: EnterOuterAlt(_localctx, 23); { - State = 1301; + State = 1330; _localctx.marshalType = Match(DATE); + _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } break; case 24: EnterOuterAlt(_localctx, 24); { - State = 1302; + State = 1332; _localctx.marshalType = Match(BSTR); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 25: EnterOuterAlt(_localctx, 25); { - State = 1303; + State = 1334; _localctx.marshalType = Match(LPSTR); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 26: EnterOuterAlt(_localctx, 26); { - State = 1304; + State = 1336; _localctx.marshalType = Match(LPWSTR); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 27: EnterOuterAlt(_localctx, 27); { - State = 1305; + State = 1338; _localctx.marshalType = Match(LPTSTR); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 28: EnterOuterAlt(_localctx, 28); { - State = 1306; + State = 1340; _localctx.marshalType = Match(OBJECTREF); + _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } break; case 29: EnterOuterAlt(_localctx, 29); { - State = 1307; + State = 1342; _localctx.marshalType = Match(IUNKNOWN); - State = 1308; - iidParamIndex(); + State = 1343; + _localctx.index = iidParamIndex(); + _localctx.Value = Actions.CreateIidNativeType(_localctx.marshalType, _localctx.index.Value); } break; case 30: EnterOuterAlt(_localctx, 30); { - State = 1309; + State = 1346; _localctx.marshalType = Match(IDISPATCH); - State = 1310; - iidParamIndex(); + State = 1347; + _localctx.index = iidParamIndex(); + _localctx.Value = Actions.CreateIidNativeType(_localctx.marshalType, _localctx.index.Value); } break; case 31: EnterOuterAlt(_localctx, 31); { - State = 1311; + State = 1350; _localctx.marshalType = Match(STRUCT); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 32: EnterOuterAlt(_localctx, 32); { - State = 1312; + State = 1352; _localctx.marshalType = Match(INTERFACE); - State = 1313; - iidParamIndex(); + State = 1353; + _localctx.index = iidParamIndex(); + _localctx.Value = Actions.CreateIidNativeType(_localctx.marshalType, _localctx.index.Value); } break; case 33: EnterOuterAlt(_localctx, 33); { - State = 1314; + State = 1356; _localctx.marshalType = Match(SAFEARRAY); - State = 1315; - variantType(); + State = 1357; + _localctx.variant = variantType(); + _localctx.Value = Actions.CreateSafeArrayNativeType(_localctx.variant.Value, null); } break; case 34: EnterOuterAlt(_localctx, 34); { - State = 1316; + State = 1360; _localctx.marshalType = Match(SAFEARRAY); - State = 1317; - variantType(); - State = 1318; + State = 1361; + _localctx.variant = variantType(); + State = 1362; Match(T__27); - State = 1319; - compQstring(); + State = 1363; + _localctx.userDefinedType = compQstring(); + _localctx.Value = Actions.CreateSafeArrayNativeType(_localctx.variant.Value, _localctx.userDefinedType.Value); } break; case 35: EnterOuterAlt(_localctx, 35); { - State = 1321; + State = 1366; _localctx.marshalType = Match(INT); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 36: EnterOuterAlt(_localctx, 36); { - State = 1322; + State = 1368; _localctx.marshalType = Match(UINT); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 37: EnterOuterAlt(_localctx, 37); { - State = 1323; + State = 1370; Match(T__89); - State = 1324; + State = 1371; _localctx.unsignedMarshalType = Match(INT8); + _localctx.Value = Actions.CreateUnsignedNativeType(_localctx.unsignedMarshalType); } break; case 38: EnterOuterAlt(_localctx, 38); { - State = 1325; + State = 1373; Match(T__89); - State = 1326; + State = 1374; _localctx.unsignedMarshalType = Match(INT16); + _localctx.Value = Actions.CreateUnsignedNativeType(_localctx.unsignedMarshalType); } break; case 39: EnterOuterAlt(_localctx, 39); { - State = 1327; + State = 1376; Match(T__89); - State = 1328; + State = 1377; _localctx.unsignedMarshalType = Match(INT32_); + _localctx.Value = Actions.CreateUnsignedNativeType(_localctx.unsignedMarshalType); } break; case 40: EnterOuterAlt(_localctx, 40); { - State = 1329; + State = 1379; Match(T__89); - State = 1330; + State = 1380; _localctx.unsignedMarshalType = Match(INT64_); + _localctx.Value = Actions.CreateUnsignedNativeType(_localctx.unsignedMarshalType); } break; case 41: EnterOuterAlt(_localctx, 41); { - State = 1331; + State = 1382; Match(T__61); - State = 1332; + State = 1383; _localctx.marshalType = Match(STRUCT); + _localctx.Value = Actions.CreateNestedStructNativeType(_localctx); } break; case 42: EnterOuterAlt(_localctx, 42); { - State = 1333; + State = 1385; _localctx.marshalType = Match(BYVALSTR); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 43: EnterOuterAlt(_localctx, 43); { - State = 1334; + State = 1387; Match(ANSI); - State = 1335; + State = 1388; _localctx.marshalType = Match(BSTR); + _localctx.Value = Actions.CreateAnsiBstrNativeType(); } break; case 44: EnterOuterAlt(_localctx, 44); { - State = 1336; + State = 1390; _localctx.marshalType = Match(TBSTR); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 45: EnterOuterAlt(_localctx, 45); { - State = 1337; + State = 1392; Match(VARIANT); - State = 1338; + State = 1393; _localctx.marshalBool = Match(BOOL); + _localctx.Value = Actions.CreateVariantBoolNativeType(); } break; case 46: EnterOuterAlt(_localctx, 46); { - State = 1339; + State = 1395; _localctx.marshalType = Match(METHOD); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 47: EnterOuterAlt(_localctx, 47); { - State = 1340; + State = 1397; _localctx.marshalType = Match(LPSTRUCT); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 48: EnterOuterAlt(_localctx, 48); { - State = 1341; + State = 1399; Match(T__33); - State = 1342; + State = 1400; _localctx.marshalType = Match(ANY); + _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } break; case 49: EnterOuterAlt(_localctx, 49); { - State = 1343; - dottedName(); + State = 1402; + _localctx.alias = dottedName(); + _localctx.Value = Actions.CreateNativeTypeTypedef(_localctx, _localctx.alias.Value); } break; } @@ -6472,6 +6551,8 @@ public NativeTypeElementContext nativeTypeElement() { } public partial class IidParamIndexContext : ParserRuleContext { + public object Value; + public Int32Context index; [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); } @@ -6493,7 +6574,7 @@ public IidParamIndexContext iidParamIndex() { IidParamIndexContext _localctx = new IidParamIndexContext(Context, State); EnterRule(_localctx, 132, RULE_iidParamIndex); try { - State = 1353; + State = 1415; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__30: @@ -6507,16 +6588,17 @@ public IidParamIndexContext iidParamIndex() { case T__29: EnterOuterAlt(_localctx, 2); { - State = 1347; + State = 1408; Match(T__29); - State = 1348; + State = 1409; Match(T__90); - State = 1349; + State = 1410; Match(T__35); - State = 1350; - int32(); - State = 1351; + State = 1411; + _localctx.index = int32(); + State = 1412; Match(T__30); + _localctx.Value = Actions.GetIidParamIndex((_localctx.index!=null?(_localctx.index.Start):null)); } break; default: @@ -6535,6 +6617,9 @@ public IidParamIndexContext iidParamIndex() { } public partial class VariantTypeContext : ParserRuleContext { + public object Value; + public VariantTypeElementContext element; + public IToken modifier; [System.Diagnostics.DebuggerNonUserCode] public VariantTypeElementContext variantTypeElement() { return GetRuleContext(0); } @@ -6567,10 +6652,11 @@ public override TResult Accept(IParseTreeVisitor visitor) { public VariantTypeContext variantType() { VariantTypeContext _localctx = new VariantTypeContext(Context, State); EnterRule(_localctx, 134, RULE_variantType); + Actions.BeginVariantType(_localctx); int _la; try { int _alt; - State = 1363; + State = 1427; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,59,Context) ) { case 1: @@ -6581,28 +6667,31 @@ public VariantTypeContext variantType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1356; - variantTypeElement(); - State = 1360; + State = 1418; + _localctx.element = variantTypeElement(); + Actions.SetVariantTypeElement(_localctx, _localctx.element.Value); + State = 1424; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,58,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1357; + State = 1420; + _localctx.modifier = TokenStream.LT(1); _la = TokenStream.LA(1); if ( !(((((_la - 229)) & ~0x3f) == 0 && ((1L << (_la - 229)) & 6442450945L) != 0)) ) { - ErrorHandler.RecoverInline(this); + _localctx.modifier = ErrorHandler.RecoverInline(this); } else { ErrorHandler.ReportMatch(this); Consume(); } + Actions.AddVariantTypeModifier(_localctx, _localctx.modifier); } } } - State = 1362; + State = 1426; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,58,Context); } @@ -6616,12 +6705,15 @@ public VariantTypeContext variantType() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndVariantType(_localctx); ExitRule(); } return _localctx; } public partial class VariantTypeElementContext : ParserRuleContext { + public object Value; + public IToken value; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode NULL() { return GetToken(CILParser.NULL, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VARIANT() { return GetToken(CILParser.VARIANT, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CURRENCY() { return GetToken(CILParser.CURRENCY, 0); } @@ -6679,19 +6771,332 @@ public override TResult Accept(IParseTreeVisitor visitor) { public VariantTypeElementContext variantTypeElement() { VariantTypeElementContext _localctx = new VariantTypeElementContext(Context, State); EnterRule(_localctx, 136, RULE_variantTypeElement); - int _la; try { - EnterOuterAlt(_localctx, 1); - { - State = 1365; - _la = TokenStream.LA(1); - if ( !(((((_la - 178)) & ~0x3f) == 0 && ((1L << (_la - 178)) & -4482436704239647L) != 0) || _la==CLSID || _la==PTR) ) { - ErrorHandler.RecoverInline(this); - } - else { - ErrorHandler.ReportMatch(this); - Consume(); - } + State = 1509; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case NULL: + EnterOuterAlt(_localctx, 1); + { + State = 1429; + _localctx.value = Match(NULL); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case VARIANT: + EnterOuterAlt(_localctx, 2); + { + State = 1431; + _localctx.value = Match(VARIANT); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case CURRENCY: + EnterOuterAlt(_localctx, 3); + { + State = 1433; + _localctx.value = Match(CURRENCY); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case VOID: + EnterOuterAlt(_localctx, 4); + { + State = 1435; + _localctx.value = Match(VOID); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case BOOL: + EnterOuterAlt(_localctx, 5); + { + State = 1437; + _localctx.value = Match(BOOL); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case INT8: + EnterOuterAlt(_localctx, 6); + { + State = 1439; + _localctx.value = Match(INT8); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case INT16: + EnterOuterAlt(_localctx, 7); + { + State = 1441; + _localctx.value = Match(INT16); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case INT32_: + EnterOuterAlt(_localctx, 8); + { + State = 1443; + _localctx.value = Match(INT32_); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case INT64_: + EnterOuterAlt(_localctx, 9); + { + State = 1445; + _localctx.value = Match(INT64_); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case FLOAT32: + EnterOuterAlt(_localctx, 10); + { + State = 1447; + _localctx.value = Match(FLOAT32); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case FLOAT64_: + EnterOuterAlt(_localctx, 11); + { + State = 1449; + _localctx.value = Match(FLOAT64_); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case UINT8: + EnterOuterAlt(_localctx, 12); + { + State = 1451; + _localctx.value = Match(UINT8); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case UINT16: + EnterOuterAlt(_localctx, 13); + { + State = 1453; + _localctx.value = Match(UINT16); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case UINT32: + EnterOuterAlt(_localctx, 14); + { + State = 1455; + _localctx.value = Match(UINT32); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case UINT64: + EnterOuterAlt(_localctx, 15); + { + State = 1457; + _localctx.value = Match(UINT64); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case PTR: + EnterOuterAlt(_localctx, 16); + { + State = 1459; + _localctx.value = Match(PTR); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case DECIMAL: + EnterOuterAlt(_localctx, 17); + { + State = 1461; + _localctx.value = Match(DECIMAL); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case DATE: + EnterOuterAlt(_localctx, 18); + { + State = 1463; + _localctx.value = Match(DATE); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case BSTR: + EnterOuterAlt(_localctx, 19); + { + State = 1465; + _localctx.value = Match(BSTR); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case LPSTR: + EnterOuterAlt(_localctx, 20); + { + State = 1467; + _localctx.value = Match(LPSTR); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case LPWSTR: + EnterOuterAlt(_localctx, 21); + { + State = 1469; + _localctx.value = Match(LPWSTR); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case IUNKNOWN: + EnterOuterAlt(_localctx, 22); + { + State = 1471; + _localctx.value = Match(IUNKNOWN); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case IDISPATCH: + EnterOuterAlt(_localctx, 23); + { + State = 1473; + _localctx.value = Match(IDISPATCH); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case SAFEARRAY: + EnterOuterAlt(_localctx, 24); + { + State = 1475; + _localctx.value = Match(SAFEARRAY); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case INT: + EnterOuterAlt(_localctx, 25); + { + State = 1477; + _localctx.value = Match(INT); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case UINT: + EnterOuterAlt(_localctx, 26); + { + State = 1479; + _localctx.value = Match(UINT); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case ERROR: + EnterOuterAlt(_localctx, 27); + { + State = 1481; + _localctx.value = Match(ERROR); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case HRESULT: + EnterOuterAlt(_localctx, 28); + { + State = 1483; + _localctx.value = Match(HRESULT); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case CARRAY: + EnterOuterAlt(_localctx, 29); + { + State = 1485; + _localctx.value = Match(CARRAY); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case USERDEFINED: + EnterOuterAlt(_localctx, 30); + { + State = 1487; + _localctx.value = Match(USERDEFINED); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case RECORD: + EnterOuterAlt(_localctx, 31); + { + State = 1489; + _localctx.value = Match(RECORD); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case FILETIME: + EnterOuterAlt(_localctx, 32); + { + State = 1491; + _localctx.value = Match(FILETIME); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case BLOB: + EnterOuterAlt(_localctx, 33); + { + State = 1493; + _localctx.value = Match(BLOB); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case STREAM: + EnterOuterAlt(_localctx, 34); + { + State = 1495; + _localctx.value = Match(STREAM); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case STORAGE: + EnterOuterAlt(_localctx, 35); + { + State = 1497; + _localctx.value = Match(STORAGE); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case STREAMED_OBJECT: + EnterOuterAlt(_localctx, 36); + { + State = 1499; + _localctx.value = Match(STREAMED_OBJECT); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case STORED_OBJECT: + EnterOuterAlt(_localctx, 37); + { + State = 1501; + _localctx.value = Match(STORED_OBJECT); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case BLOB_OBJECT: + EnterOuterAlt(_localctx, 38); + { + State = 1503; + _localctx.value = Match(BLOB_OBJECT); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case CF: + EnterOuterAlt(_localctx, 39); + { + State = 1505; + _localctx.value = Match(CF); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + case CLSID: + EnterOuterAlt(_localctx, 40); + { + State = 1507; + _localctx.value = Match(CLSID); + _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); + } + break; + default: + throw new NoViableAltException(this); } } catch (RecognitionException re) { @@ -6740,25 +7145,25 @@ public TypeContext type() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1367; + State = 1511; _localctx.element = elementType(); Actions.SetTypeSignatureElement(_localctx, _localctx.element.Value); - State = 1374; + State = 1518; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,60,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,61,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1369; + State = 1513; _localctx.modifier = typeModifiers(); Actions.AddTypeSignatureModifier(_localctx, _localctx.modifier.Value); } } } - State = 1376; + State = 1520; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,60,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,61,Context); } } } @@ -6885,14 +7290,14 @@ public TypeModifiersContext typeModifiers() { TypeModifiersContext _localctx = new TypeModifiersContext(Context, State); EnterRule(_localctx, 140, RULE_typeModifiers); try { - State = 1406; + State = 1550; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,61,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,62,Context) ) { case 1: _localctx = new SZArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 1); { - State = 1377; + State = 1521; Match(ARRAY_TYPE_NO_BOUNDS); _localctx.Value = Actions.CreateSzArrayTypeModifier(); } @@ -6901,9 +7306,9 @@ public TypeModifiersContext typeModifiers() { _localctx = new SZArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 2); { - State = 1379; + State = 1523; Match(T__41); - State = 1380; + State = 1524; Match(T__42); _localctx.Value = Actions.CreateSzArrayTypeModifier(); } @@ -6912,7 +7317,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new ArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 3); { - State = 1382; + State = 1526; ((ArrayModifierContext)_localctx).arrayBounds = bounds(); _localctx.Value = Actions.CreateArrayTypeModifier(((ArrayModifierContext)_localctx).arrayBounds.Value); } @@ -6921,7 +7326,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new ByRefModifierContext(_localctx); EnterOuterAlt(_localctx, 4); { - State = 1385; + State = 1529; Match(REF); _localctx.Value = Actions.CreateByReferenceTypeModifier(); } @@ -6930,7 +7335,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new PtrModifierContext(_localctx); EnterOuterAlt(_localctx, 5); { - State = 1387; + State = 1531; Match(PTR); _localctx.Value = Actions.CreatePointerTypeModifier(); } @@ -6939,7 +7344,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new PinnedModifierContext(_localctx); EnterOuterAlt(_localctx, 6); { - State = 1389; + State = 1533; Match(T__91); _localctx.Value = Actions.CreatePinnedTypeModifier(); } @@ -6948,13 +7353,13 @@ public TypeModifiersContext typeModifiers() { _localctx = new RequiredModifierContext(_localctx); EnterOuterAlt(_localctx, 7); { - State = 1391; + State = 1535; Match(T__92); - State = 1392; + State = 1536; Match(T__29); - State = 1393; + State = 1537; ((RequiredModifierContext)_localctx).modifierType = typeSpec(); - State = 1394; + State = 1538; Match(T__30); _localctx.Value = Actions.CreateCustomTypeModifier(((RequiredModifierContext)_localctx).modifierType.Value, true); } @@ -6963,13 +7368,13 @@ public TypeModifiersContext typeModifiers() { _localctx = new OptionalModifierContext(_localctx); EnterOuterAlt(_localctx, 8); { - State = 1397; + State = 1541; Match(T__93); - State = 1398; + State = 1542; Match(T__29); - State = 1399; + State = 1543; ((OptionalModifierContext)_localctx).modifierType = typeSpec(); - State = 1400; + State = 1544; Match(T__30); _localctx.Value = Actions.CreateCustomTypeModifier(((OptionalModifierContext)_localctx).modifierType.Value, false); } @@ -6978,7 +7383,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new GenericArgumentsModifierContext(_localctx); EnterOuterAlt(_localctx, 9); { - State = 1403; + State = 1547; ((GenericArgumentsModifierContext)_localctx).arguments = typeArgs(); _localctx.Value = Actions.CreateGenericArgumentsModifier(((GenericArgumentsModifierContext)_localctx).arguments.Value); } @@ -7066,15 +7471,15 @@ public ElementTypeContext elementType() { ElementTypeContext _localctx = new ElementTypeContext(Context, State); EnterRule(_localctx, 142, RULE_elementType); try { - State = 1466; + State = 1610; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,62,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,63,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1408; + State = 1552; Match(T__38); - State = 1409; + State = 1553; _localctx.classType = className(); _localctx.Value = Actions.CreateClassElementType(_localctx.classType.Value, false); } @@ -7082,7 +7487,7 @@ public ElementTypeContext elementType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1412; + State = 1556; Match(OBJECT); _localctx.Value = Actions.CreateObjectElementType(); } @@ -7090,11 +7495,11 @@ public ElementTypeContext elementType() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1414; + State = 1558; Match(VALUE); - State = 1415; + State = 1559; Match(T__38); - State = 1416; + State = 1560; _localctx.valueClassType = className(); _localctx.Value = Actions.CreateClassElementType(_localctx.valueClassType.Value, true); } @@ -7102,9 +7507,9 @@ public ElementTypeContext elementType() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1419; + State = 1563; Match(VALUETYPE); - State = 1420; + State = 1564; _localctx.valueType = className(); _localctx.Value = Actions.CreateClassElementType(_localctx.valueType.Value, true); } @@ -7112,15 +7517,15 @@ public ElementTypeContext elementType() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1423; + State = 1567; Match(METHOD); - State = 1424; + State = 1568; _localctx.convention = callConv(); - State = 1425; + State = 1569; _localctx.returnType = type(); - State = 1426; + State = 1570; Match(PTR); - State = 1427; + State = 1571; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateFunctionPointerElementType(_localctx.convention.Value, _localctx.returnType.Value, _localctx.arguments.Value); } @@ -7128,9 +7533,9 @@ public ElementTypeContext elementType() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1430; + State = 1574; Match(METHOD_TYPE_PARAMETER); - State = 1431; + State = 1575; _localctx.parameterIndex = int32(); _localctx.Value = Actions.CreateIndexedGenericParameterElementType(true, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null)); } @@ -7138,9 +7543,9 @@ public ElementTypeContext elementType() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1434; + State = 1578; Match(TYPE_PARAMETER); - State = 1435; + State = 1579; _localctx.parameterIndex = int32(); _localctx.Value = Actions.CreateIndexedGenericParameterElementType(false, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null)); } @@ -7148,9 +7553,9 @@ public ElementTypeContext elementType() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1438; + State = 1582; Match(METHOD_TYPE_PARAMETER); - State = 1439; + State = 1583; _localctx.parameterName = dottedName(); _localctx.Value = Actions.CreateNamedGenericParameterElementType(_localctx.Start, true, _localctx.parameterName.Value); } @@ -7158,9 +7563,9 @@ public ElementTypeContext elementType() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1442; + State = 1586; Match(TYPE_PARAMETER); - State = 1443; + State = 1587; _localctx.parameterName = dottedName(); _localctx.Value = Actions.CreateNamedGenericParameterElementType(_localctx.Start, false, _localctx.parameterName.Value); } @@ -7168,7 +7573,7 @@ public ElementTypeContext elementType() { case 10: EnterOuterAlt(_localctx, 10); { - State = 1446; + State = 1590; Match(TYPEDREF); _localctx.Value = Actions.CreateTypedReferenceElementType(); } @@ -7176,7 +7581,7 @@ public ElementTypeContext elementType() { case 11: EnterOuterAlt(_localctx, 11); { - State = 1448; + State = 1592; Match(VOID); _localctx.Value = Actions.CreateVoidElementType(); } @@ -7184,7 +7589,7 @@ public ElementTypeContext elementType() { case 12: EnterOuterAlt(_localctx, 12); { - State = 1450; + State = 1594; _localctx.signedNative = nativeInt(); _localctx.Value = Actions.CreatePrimitiveElementType(_localctx.signedNative.Value); } @@ -7192,7 +7597,7 @@ public ElementTypeContext elementType() { case 13: EnterOuterAlt(_localctx, 13); { - State = 1453; + State = 1597; _localctx.unsignedNative = nativeUint(); _localctx.Value = Actions.CreatePrimitiveElementType(_localctx.unsignedNative.Value); } @@ -7200,7 +7605,7 @@ public ElementTypeContext elementType() { case 14: EnterOuterAlt(_localctx, 14); { - State = 1456; + State = 1600; _localctx.primitive = simpleType(); _localctx.Value = Actions.CreatePrimitiveElementType(_localctx.primitive.Value); } @@ -7208,7 +7613,7 @@ public ElementTypeContext elementType() { case 15: EnterOuterAlt(_localctx, 15); { - State = 1459; + State = 1603; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateTypedefElementType(_localctx.Start, _localctx.alias.Value); } @@ -7216,9 +7621,9 @@ public ElementTypeContext elementType() { case 16: EnterOuterAlt(_localctx, 16); { - State = 1462; + State = 1606; Match(ELLIPSIS); - State = 1463; + State = 1607; _localctx.sentinelType = type(); _localctx.Value = Actions.CreateSentinelElementType(_localctx.sentinelType.Value); } @@ -7270,13 +7675,13 @@ public SimpleTypeContext simpleType() { SimpleTypeContext _localctx = new SimpleTypeContext(Context, State); EnterRule(_localctx, 144, RULE_simpleType); try { - State = 1506; + State = 1650; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,63,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,64,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1468; + State = 1612; _localctx.value = Match(CHAR); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7284,7 +7689,7 @@ public SimpleTypeContext simpleType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1470; + State = 1614; _localctx.value = Match(STRING); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7292,7 +7697,7 @@ public SimpleTypeContext simpleType() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1472; + State = 1616; _localctx.value = Match(BOOL); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7300,7 +7705,7 @@ public SimpleTypeContext simpleType() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1474; + State = 1618; _localctx.value = Match(INT8); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7308,7 +7713,7 @@ public SimpleTypeContext simpleType() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1476; + State = 1620; _localctx.value = Match(INT16); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7316,7 +7721,7 @@ public SimpleTypeContext simpleType() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1478; + State = 1622; _localctx.value = Match(INT32_); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7324,7 +7729,7 @@ public SimpleTypeContext simpleType() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1480; + State = 1624; _localctx.value = Match(INT64_); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7332,7 +7737,7 @@ public SimpleTypeContext simpleType() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1482; + State = 1626; _localctx.value = Match(FLOAT32); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7340,7 +7745,7 @@ public SimpleTypeContext simpleType() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1484; + State = 1628; _localctx.value = Match(FLOAT64_); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7348,7 +7753,7 @@ public SimpleTypeContext simpleType() { case 10: EnterOuterAlt(_localctx, 10); { - State = 1486; + State = 1630; _localctx.value = Match(UINT8); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7356,7 +7761,7 @@ public SimpleTypeContext simpleType() { case 11: EnterOuterAlt(_localctx, 11); { - State = 1488; + State = 1632; _localctx.value = Match(UINT16); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7364,7 +7769,7 @@ public SimpleTypeContext simpleType() { case 12: EnterOuterAlt(_localctx, 12); { - State = 1490; + State = 1634; _localctx.value = Match(UINT32); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7372,7 +7777,7 @@ public SimpleTypeContext simpleType() { case 13: EnterOuterAlt(_localctx, 13); { - State = 1492; + State = 1636; _localctx.value = Match(UINT64); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7380,9 +7785,9 @@ public SimpleTypeContext simpleType() { case 14: EnterOuterAlt(_localctx, 14); { - State = 1494; + State = 1638; Match(T__89); - State = 1495; + State = 1639; _localctx.value = Match(INT8); _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } @@ -7390,9 +7795,9 @@ public SimpleTypeContext simpleType() { case 15: EnterOuterAlt(_localctx, 15); { - State = 1497; + State = 1641; Match(T__89); - State = 1498; + State = 1642; _localctx.value = Match(INT16); _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } @@ -7400,9 +7805,9 @@ public SimpleTypeContext simpleType() { case 16: EnterOuterAlt(_localctx, 16); { - State = 1500; + State = 1644; Match(T__89); - State = 1501; + State = 1645; _localctx.value = Match(INT32_); _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } @@ -7410,9 +7815,9 @@ public SimpleTypeContext simpleType() { case 17: EnterOuterAlt(_localctx, 17); { - State = 1503; + State = 1647; Match(T__89); - State = 1504; + State = 1648; _localctx.value = Match(INT64_); _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } @@ -7464,9 +7869,9 @@ public BoundContext bound() { EnterRule(_localctx, 146, RULE_bound); Actions.InitializeBound(_localctx); try { - State = 1522; + State = 1666; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,64,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,65,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -7475,14 +7880,14 @@ public BoundContext bound() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1509; + State = 1653; Match(ELLIPSIS); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1510; + State = 1654; _localctx.size = int32(); Actions.SetBoundSize(_localctx, (_localctx.size!=null?(_localctx.size.Start):null)); } @@ -7490,11 +7895,11 @@ public BoundContext bound() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1513; + State = 1657; _localctx.lower = int32(); - State = 1514; + State = 1658; Match(ELLIPSIS); - State = 1515; + State = 1659; _localctx.upper = int32(); Actions.SetBoundRange(_localctx, (_localctx.lower!=null?(_localctx.lower.Start):null), (_localctx.upper!=null?(_localctx.upper.Start):null)); } @@ -7502,9 +7907,9 @@ public BoundContext bound() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1518; + State = 1662; _localctx.lower = int32(); - State = 1519; + State = 1663; Match(ELLIPSIS); Actions.SetBoundLower(_localctx, (_localctx.lower!=null?(_localctx.lower.Start):null)); } @@ -7545,9 +7950,9 @@ public NativeIntContext nativeInt() { try { EnterOuterAlt(_localctx, 1); { - State = 1524; + State = 1668; Match(T__0); - State = 1525; + State = 1669; Match(INT); _localctx.Value = Actions.GetNativeIntType(); } @@ -7587,22 +7992,22 @@ public NativeUintContext nativeUint() { try { EnterOuterAlt(_localctx, 1); { - State = 1528; + State = 1672; Match(T__0); - State = 1532; + State = 1676; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__89: { - State = 1529; + State = 1673; Match(T__89); - State = 1530; + State = 1674; Match(INT); } break; case UINT: { - State = 1531; + State = 1675; Match(UINT); } break; @@ -7666,125 +8071,125 @@ public SecDeclContext secDecl() { EnterRule(_localctx, 152, RULE_secDecl); int _la; try { - State = 1583; + State = 1727; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,67,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,68,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1536; + State = 1680; Match(PERMISSION); - State = 1537; + State = 1681; secAction(); - State = 1538; + State = 1682; typeSpec(); - State = 1539; + State = 1683; Match(T__29); - State = 1540; + State = 1684; nameValPairs(); - State = 1541; + State = 1685; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1543; + State = 1687; Match(PERMISSION); - State = 1544; + State = 1688; secAction(); - State = 1545; + State = 1689; typeSpec(); - State = 1546; + State = 1690; Match(T__35); - State = 1547; + State = 1691; Match(T__16); - State = 1548; + State = 1692; customBlobDescr(); - State = 1549; + State = 1693; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1551; + State = 1695; Match(PERMISSION); - State = 1552; + State = 1696; secAction(); - State = 1553; + State = 1697; typeSpec(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1555; + State = 1699; Match(PERMISSIONSET); - State = 1556; + State = 1700; secAction(); - State = 1557; + State = 1701; Match(T__35); - State = 1559; + State = 1703; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__83) { { - State = 1558; + State = 1702; Match(T__83); } } - State = 1561; + State = 1705; Match(T__29); - State = 1562; + State = 1706; bytes(); - State = 1563; + State = 1707; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1565; + State = 1709; Match(PERMISSIONSET); - State = 1566; + State = 1710; secAction(); - State = 1567; + State = 1711; Match(T__83); - State = 1568; + State = 1712; Match(T__29); - State = 1569; + State = 1713; bytes(); - State = 1570; + State = 1714; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1572; + State = 1716; Match(PERMISSIONSET); - State = 1573; + State = 1717; secAction(); - State = 1574; + State = 1718; compQstring(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1576; + State = 1720; Match(PERMISSIONSET); - State = 1577; + State = 1721; secAction(); - State = 1578; + State = 1722; Match(T__35); - State = 1579; + State = 1723; Match(T__16); - State = 1580; + State = 1724; secAttrSetBlob(); - State = 1581; + State = 1725; Match(T__17); } break; @@ -7827,7 +8232,7 @@ public SecAttrSetBlobContext secAttrSetBlob() { EnterRule(_localctx, 154, RULE_secAttrSetBlob); try { int _alt; - State = 1595; + State = 1739; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__17: @@ -7872,25 +8277,25 @@ public SecAttrSetBlobContext secAttrSetBlob() { case ID: EnterOuterAlt(_localctx, 2); { - State = 1591; + State = 1735; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,68,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,69,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1586; + State = 1730; secAttrBlob(); - State = 1587; + State = 1731; Match(T__27); } } } - State = 1593; + State = 1737; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,68,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,69,Context); } - State = 1594; + State = 1738; secAttrBlob(); } break; @@ -7935,38 +8340,38 @@ public SecAttrBlobContext secAttrBlob() { SecAttrBlobContext _localctx = new SecAttrBlobContext(Context, State); EnterRule(_localctx, 156, RULE_secAttrBlob); try { - State = 1610; + State = 1754; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,70,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,71,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1597; + State = 1741; Match(T__38); - State = 1598; + State = 1742; Match(SQSTRING); - State = 1599; + State = 1743; Match(T__35); - State = 1600; + State = 1744; Match(T__16); - State = 1601; + State = 1745; customBlobNVPairs(); - State = 1602; + State = 1746; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1604; + State = 1748; typeSpec(); - State = 1605; + State = 1749; Match(T__35); - State = 1606; + State = 1750; Match(T__16); - State = 1607; + State = 1751; customBlobNVPairs(); - State = 1608; + State = 1752; Match(T__17); } break; @@ -8011,25 +8416,25 @@ public NameValPairsContext nameValPairs() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1617; + State = 1761; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,71,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,72,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1612; + State = 1756; nameValPair(); - State = 1613; + State = 1757; Match(T__27); } } } - State = 1619; + State = 1763; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,71,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,72,Context); } - State = 1620; + State = 1764; nameValPair(); } } @@ -8071,11 +8476,11 @@ public NameValPairContext nameValPair() { try { EnterOuterAlt(_localctx, 1); { - State = 1622; + State = 1766; compQstring(); - State = 1623; + State = 1767; Match(T__35); - State = 1624; + State = 1768; caValue(); } } @@ -8112,7 +8517,7 @@ public TruefalseContext truefalse() { try { EnterOuterAlt(_localctx, 1); { - State = 1626; + State = 1770; _la = TokenStream.LA(1); if ( !(_la==T__94 || _la==T__95) ) { ErrorHandler.RecoverInline(this); @@ -8168,104 +8573,104 @@ public CaValueContext caValue() { CaValueContext _localctx = new CaValueContext(Context, State); EnterRule(_localctx, 164, RULE_caValue); try { - State = 1662; + State = 1806; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,72,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,73,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1628; + State = 1772; truefalse(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1629; + State = 1773; int32(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1630; + State = 1774; Match(INT32_); - State = 1631; + State = 1775; Match(T__29); - State = 1632; + State = 1776; int32(); - State = 1633; + State = 1777; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1635; + State = 1779; compQstring(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1636; + State = 1780; className(); - State = 1637; + State = 1781; Match(T__29); - State = 1638; + State = 1782; Match(INT8); - State = 1639; + State = 1783; Match(T__74); - State = 1640; + State = 1784; int32(); - State = 1641; + State = 1785; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1643; + State = 1787; className(); - State = 1644; + State = 1788; Match(T__29); - State = 1645; + State = 1789; Match(INT16); - State = 1646; + State = 1790; Match(T__74); - State = 1647; + State = 1791; int32(); - State = 1648; + State = 1792; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1650; + State = 1794; className(); - State = 1651; + State = 1795; Match(T__29); - State = 1652; + State = 1796; Match(INT32_); - State = 1653; + State = 1797; Match(T__74); - State = 1654; + State = 1798; int32(); - State = 1655; + State = 1799; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1657; + State = 1801; className(); - State = 1658; + State = 1802; Match(T__29); - State = 1659; + State = 1803; int32(); - State = 1660; + State = 1804; Match(T__30); } break; @@ -8304,7 +8709,7 @@ public SecActionContext secAction() { try { EnterOuterAlt(_localctx, 1); { - State = 1664; + State = 1808; _la = TokenStream.LA(1); if ( !(((((_la - 97)) & ~0x3f) == 0 && ((1L << (_la - 97)) & 32767L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -8386,33 +8791,33 @@ public MethodRefContext methodRef() { Actions.BeginSemanticRoot(_localctx); int _la; try { - State = 1708; + State = 1852; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,75,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,76,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1666; + State = 1810; _localctx.convention = callConv(); - State = 1667; + State = 1811; _localctx.returnType = type(); - State = 1668; + State = 1812; _localctx.owner = typeSpec(); - State = 1669; + State = 1813; Match(DCOLON); - State = 1670; + State = 1814; _localctx.name = methodName(); - State = 1672; + State = 1816; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 1671; + State = 1815; _localctx.genericArguments = typeArgs(); } } - State = 1674; + State = 1818; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, _localctx.owner.Value, _localctx.name.Value, _localctx.genericArguments, null, _localctx.arguments.Value); } @@ -8420,19 +8825,19 @@ public MethodRefContext methodRef() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1677; + State = 1821; _localctx.convention = callConv(); - State = 1678; + State = 1822; _localctx.returnType = type(); - State = 1679; + State = 1823; _localctx.owner = typeSpec(); - State = 1680; + State = 1824; Match(DCOLON); - State = 1681; + State = 1825; _localctx.name = methodName(); - State = 1682; + State = 1826; _localctx.genericArity = genArityNotEmpty(); - State = 1683; + State = 1827; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, _localctx.owner.Value, _localctx.name.Value, null, _localctx.genericArity.Value, _localctx.arguments.Value); } @@ -8440,23 +8845,23 @@ public MethodRefContext methodRef() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1686; + State = 1830; _localctx.convention = callConv(); - State = 1687; + State = 1831; _localctx.returnType = type(); - State = 1688; + State = 1832; _localctx.name = methodName(); - State = 1690; + State = 1834; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 1689; + State = 1833; _localctx.genericArguments = typeArgs(); } } - State = 1692; + State = 1836; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, null, _localctx.name.Value, _localctx.genericArguments, null, _localctx.arguments.Value); } @@ -8464,15 +8869,15 @@ public MethodRefContext methodRef() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1695; + State = 1839; _localctx.convention = callConv(); - State = 1696; + State = 1840; _localctx.returnType = type(); - State = 1697; + State = 1841; _localctx.name = methodName(); - State = 1698; + State = 1842; _localctx.genericArity = genArityNotEmpty(); - State = 1699; + State = 1843; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, null, _localctx.name.Value, null, _localctx.genericArity.Value, _localctx.arguments.Value); } @@ -8480,7 +8885,7 @@ public MethodRefContext methodRef() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1702; + State = 1846; _localctx.token = mdtoken(); _localctx.Value = Actions.CreateTokenMethodReference(_localctx.token.Value); } @@ -8488,7 +8893,7 @@ public MethodRefContext methodRef() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1705; + State = 1849; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateTypedefMethodReference(_localctx.Start, _localctx.alias.Value); } @@ -8541,15 +8946,15 @@ public CallConvContext callConv() { CallConvContext _localctx = new CallConvContext(Context, State); EnterRule(_localctx, 170, RULE_callConv); try { - State = 1727; + State = 1871; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,76,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,77,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1710; + State = 1854; Match(INSTANCE); - State = 1711; + State = 1855; _localctx.inner = callConv(); _localctx.Value = Actions.AddInstanceCallingConvention(_localctx.inner.Value); } @@ -8557,9 +8962,9 @@ public CallConvContext callConv() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1714; + State = 1858; Match(EXPLICIT); - State = 1715; + State = 1859; _localctx.inner = callConv(); _localctx.Value = Actions.AddExplicitCallingConvention(_localctx.inner.Value); } @@ -8567,7 +8972,7 @@ public CallConvContext callConv() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1718; + State = 1862; _localctx.kind = callKind(); _localctx.Value = _localctx.kind.Value; } @@ -8575,13 +8980,13 @@ public CallConvContext callConv() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1721; + State = 1865; Match(T__111); - State = 1722; + State = 1866; Match(T__29); - State = 1723; + State = 1867; _localctx.raw = int32(); - State = 1724; + State = 1868; Match(T__30); _localctx.Value = Actions.GetRawCallingConvention((_localctx.raw!=null?(_localctx.raw.Start):null)); } @@ -8628,9 +9033,9 @@ public CallKindContext callKind() { EnterRule(_localctx, 172, RULE_callKind); _localctx.Value = Actions.GetDefaultCallingConvention(); try { - State = 1748; + State = 1892; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,77,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,78,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -8639,7 +9044,7 @@ public CallKindContext callKind() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1730; + State = 1874; _localctx.kind = Match(DEFAULT); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -8647,7 +9052,7 @@ public CallKindContext callKind() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1732; + State = 1876; _localctx.kind = Match(VARARG); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -8655,9 +9060,9 @@ public CallKindContext callKind() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1734; + State = 1878; Match(UNMANAGED); - State = 1735; + State = 1879; _localctx.kind = Match(CDECL); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -8665,9 +9070,9 @@ public CallKindContext callKind() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1737; + State = 1881; Match(UNMANAGED); - State = 1738; + State = 1882; _localctx.kind = Match(STDCALL); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -8675,9 +9080,9 @@ public CallKindContext callKind() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1740; + State = 1884; Match(UNMANAGED); - State = 1741; + State = 1885; _localctx.kind = Match(THISCALL); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -8685,9 +9090,9 @@ public CallKindContext callKind() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1743; + State = 1887; Match(UNMANAGED); - State = 1744; + State = 1888; _localctx.kind = Match(FASTCALL); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -8695,7 +9100,7 @@ public CallKindContext callKind() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1746; + State = 1890; _localctx.kind = Match(UNMANAGED); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -8741,13 +9146,13 @@ public MdtokenContext mdtoken() { try { EnterOuterAlt(_localctx, 1); { - State = 1750; + State = 1894; Match(T__112); - State = 1751; + State = 1895; Match(T__29); - State = 1752; + State = 1896; _localctx.token = int32(); - State = 1753; + State = 1897; Match(T__30); _localctx.Value = Actions.ParseInt32((_localctx.token!=null?(_localctx.token.Start):null)); } @@ -8797,15 +9202,15 @@ public MemberRefContext memberRef() { MemberRefContext _localctx = new MemberRefContext(Context, State); EnterRule(_localctx, 176, RULE_memberRef); try { - State = 1767; + State = 1911; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case METHOD: EnterOuterAlt(_localctx, 1); { - State = 1756; + State = 1900; Match(METHOD); - State = 1757; + State = 1901; _localctx.method = methodRef(); _localctx.Value = Actions.CreateMethodMemberReference(_localctx.method.Value); } @@ -8813,9 +9218,9 @@ public MemberRefContext memberRef() { case T__36: EnterOuterAlt(_localctx, 2); { - State = 1760; + State = 1904; Match(T__36); - State = 1761; + State = 1905; _localctx.field = fieldRef(); _localctx.Value = Actions.CreateFieldMemberReference(_localctx.field.Value); } @@ -8823,7 +9228,7 @@ public MemberRefContext memberRef() { case T__112: EnterOuterAlt(_localctx, 3); { - State = 1764; + State = 1908; _localctx.token = mdtoken(); _localctx.Value = Actions.CreateTokenMemberReference(_localctx.token.Value); } @@ -8879,19 +9284,19 @@ public FieldRefContext fieldRef() { EnterRule(_localctx, 178, RULE_fieldRef); Actions.BeginSemanticRoot(_localctx); try { - State = 1782; + State = 1926; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,79,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,80,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1769; + State = 1913; _localctx.fieldType = type(); - State = 1770; + State = 1914; _localctx.owner = typeSpec(); - State = 1771; + State = 1915; Match(DCOLON); - State = 1772; + State = 1916; _localctx.name = dottedName(); _localctx.Value = Actions.CreateFieldReference(_localctx.fieldType.Value, _localctx.owner.Value, _localctx.name.Value); } @@ -8899,9 +9304,9 @@ public FieldRefContext fieldRef() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1775; + State = 1919; _localctx.fieldType = type(); - State = 1776; + State = 1920; _localctx.name = dottedName(); _localctx.Value = Actions.CreateFieldReference(_localctx.fieldType.Value, null, _localctx.name.Value); } @@ -8909,7 +9314,7 @@ public FieldRefContext fieldRef() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1779; + State = 1923; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateTypedefFieldReference(_localctx.Start, _localctx.alias.Value); } @@ -8956,25 +9361,25 @@ public TypeListContext typeList() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1789; + State = 1933; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,80,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,81,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1784; + State = 1928; typeSpec(); - State = 1785; + State = 1929; Match(T__27); } } } - State = 1791; + State = 1935; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,80,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,81,Context); } - State = 1792; + State = 1936; typeSpec(); } } @@ -9011,7 +9416,7 @@ public TyparsClauseContext typarsClause() { TyparsClauseContext _localctx = new TyparsClauseContext(Context, State); EnterRule(_localctx, 182, RULE_typarsClause); try { - State = 1799; + State = 1943; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -9026,11 +9431,11 @@ public TyparsClauseContext typarsClause() { case T__85: EnterOuterAlt(_localctx, 2); { - State = 1795; + State = 1939; Match(T__85); - State = 1796; + State = 1940; typars(); - State = 1797; + State = 1941; Match(T__86); } break; @@ -9080,61 +9485,61 @@ public TyparAttribContext typarAttrib() { TyparAttribContext _localctx = new TyparAttribContext(Context, State); EnterRule(_localctx, 184, RULE_typarAttrib); try { - State = 1812; + State = 1956; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case PLUS: EnterOuterAlt(_localctx, 1); { - State = 1801; + State = 1945; _localctx.covariant = Match(PLUS); } break; case T__113: EnterOuterAlt(_localctx, 2); { - State = 1802; + State = 1946; _localctx.contravariant = Match(T__113); } break; case T__38: EnterOuterAlt(_localctx, 3); { - State = 1803; + State = 1947; _localctx.@class = Match(T__38); } break; case VALUETYPE: EnterOuterAlt(_localctx, 4); { - State = 1804; + State = 1948; _localctx.valuetype = Match(VALUETYPE); } break; case T__114: EnterOuterAlt(_localctx, 5); { - State = 1805; + State = 1949; _localctx.byrefLike = Match(T__114); } break; case T__115: EnterOuterAlt(_localctx, 6); { - State = 1806; + State = 1950; _localctx.ctor = Match(T__115); } break; case T__69: EnterOuterAlt(_localctx, 7); { - State = 1807; + State = 1951; Match(T__69); - State = 1808; + State = 1952; Match(T__29); - State = 1809; + State = 1953; _localctx.flags = int32(); - State = 1810; + State = 1954; Match(T__30); } break; @@ -9181,17 +9586,17 @@ public TyparAttribsContext typarAttribs() { try { EnterOuterAlt(_localctx, 1); { - State = 1817; + State = 1961; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__38 || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & 123145302310913L) != 0) || _la==VALUETYPE || _la==PLUS) { { { - State = 1814; + State = 1958; typarAttrib(); } } - State = 1819; + State = 1963; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -9239,19 +9644,19 @@ public TyparContext typar() { try { EnterOuterAlt(_localctx, 1); { - State = 1820; + State = 1964; typarAttribs(); - State = 1822; + State = 1966; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__29) { { - State = 1821; + State = 1965; tyBound(); } } - State = 1824; + State = 1968; dottedName(); } } @@ -9294,25 +9699,25 @@ public TyparsContext typars() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1831; + State = 1975; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,85,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,86,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1826; + State = 1970; typar(); - State = 1827; + State = 1971; Match(T__27); } } } - State = 1833; + State = 1977; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,85,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,86,Context); } - State = 1834; + State = 1978; typar(); } } @@ -9351,11 +9756,11 @@ public TyBoundContext tyBound() { try { EnterOuterAlt(_localctx, 1); { - State = 1836; + State = 1980; Match(T__29); - State = 1837; + State = 1981; typeList(); - State = 1838; + State = 1982; Match(T__30); } } @@ -9397,12 +9802,12 @@ public GenArityContext genArity() { try { EnterOuterAlt(_localctx, 1); { - State = 1841; + State = 1985; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 1840; + State = 1984; _localctx.value = genArityNotEmpty(); } } @@ -9447,15 +9852,15 @@ public GenArityNotEmptyContext genArityNotEmpty() { try { EnterOuterAlt(_localctx, 1); { - State = 1845; + State = 1989; Match(T__85); - State = 1846; + State = 1990; Match(T__41); - State = 1847; + State = 1991; _localctx.value = int32(); - State = 1848; + State = 1992; Match(T__42); - State = 1849; + State = 1993; Match(T__86); _localctx.Value = Actions.ParseInt32((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -9603,343 +10008,343 @@ public ClassDeclContext classDecl() { BeginSubtree(); try { int _alt; - State = 1968; + State = 2112; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,91,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,92,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1852; + State = 1996; methodHead(); - State = 1853; + State = 1997; Match(T__16); - State = 1854; + State = 1998; methodDecls(); - State = 1855; + State = 1999; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1857; + State = 2001; classHead(); - State = 1858; + State = 2002; Match(T__16); - State = 1859; + State = 2003; classDecls(); - State = 1860; + State = 2004; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1862; + State = 2006; eventHead(); - State = 1863; + State = 2007; Match(T__16); - State = 1864; + State = 2008; eventDecls(); - State = 1865; + State = 2009; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1867; + State = 2011; propHead(); - State = 1868; + State = 2012; Match(T__16); - State = 1869; + State = 2013; propDecls(); - State = 1870; + State = 2014; Match(T__17); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1872; + State = 2016; fieldDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1873; + State = 2017; dataDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1874; + State = 2018; secDecl(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1875; + State = 2019; extSourceSpec(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 1876; + State = 2020; customAttrDecl(); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 1877; + State = 2021; Match(T__116); - State = 1878; + State = 2022; int32(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 1879; + State = 2023; Match(T__117); - State = 1880; + State = 2024; int32(); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 1881; + State = 2025; exportHead(); - State = 1882; + State = 2026; Match(T__16); - State = 1883; + State = 2027; exptypeDecls(); - State = 1884; + State = 2028; Match(T__17); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 1886; + State = 2030; Match(OVERRIDE); - State = 1887; + State = 2031; typeSpec(); - State = 1888; + State = 2032; Match(DCOLON); - State = 1889; + State = 2033; methodName(); - State = 1890; + State = 2034; Match(T__118); - State = 1891; + State = 2035; callConv(); - State = 1892; + State = 2036; type(); - State = 1893; + State = 2037; typeSpec(); - State = 1894; + State = 2038; Match(DCOLON); - State = 1895; + State = 2039; methodName(); - State = 1896; + State = 2040; sigArgs(); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 1898; + State = 2042; Match(OVERRIDE); - State = 1899; + State = 2043; Match(METHOD); - State = 1900; + State = 2044; callConv(); - State = 1901; + State = 2045; type(); - State = 1902; + State = 2046; typeSpec(); - State = 1903; + State = 2047; Match(DCOLON); - State = 1904; + State = 2048; methodName(); - State = 1905; + State = 2049; genArity(); - State = 1906; + State = 2050; sigArgs(); - State = 1907; + State = 2051; Match(T__118); - State = 1908; + State = 2052; Match(METHOD); - State = 1909; + State = 2053; callConv(); - State = 1910; + State = 2054; type(); - State = 1911; + State = 2055; typeSpec(); - State = 1912; + State = 2056; Match(DCOLON); - State = 1913; + State = 2057; methodName(); - State = 1914; + State = 2058; genArity(); - State = 1915; + State = 2059; sigArgs(); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 1917; + State = 2061; languageDecl(); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 1918; + State = 2062; compControl(); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 1919; + State = 2063; Match(PARAM); - State = 1920; + State = 2064; Match(TYPE); - State = 1921; + State = 2065; Match(T__41); - State = 1922; + State = 2066; int32(); - State = 1923; + State = 2067; Match(T__42); - State = 1927; + State = 2071; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,87,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1924; + State = 2068; customAttrDecl(); } } } - State = 1929; + State = 2073; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,87,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); } } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 1930; + State = 2074; Match(PARAM); - State = 1931; + State = 2075; Match(TYPE); - State = 1932; + State = 2076; dottedName(); - State = 1936; + State = 2080; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1933; + State = 2077; customAttrDecl(); } } } - State = 1938; + State = 2082; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); } } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 1939; + State = 2083; Match(PARAM); - State = 1940; + State = 2084; Match(CONSTRAINT); - State = 1941; + State = 2085; Match(T__41); - State = 1942; + State = 2086; int32(); - State = 1943; + State = 2087; Match(T__42); - State = 1944; + State = 2088; Match(T__27); - State = 1945; + State = 2089; typeSpec(); - State = 1949; + State = 2093; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1946; + State = 2090; customAttrDecl(); } } } - State = 1951; + State = 2095; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); } } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 1952; + State = 2096; Match(PARAM); - State = 1953; + State = 2097; Match(CONSTRAINT); - State = 1954; + State = 2098; dottedName(); - State = 1955; + State = 2099; Match(T__27); - State = 1956; + State = 2100; typeSpec(); - State = 1960; + State = 2104; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1957; + State = 2101; customAttrDecl(); } } } - State = 1962; + State = 2106; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); } } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 1963; + State = 2107; Match(T__119); - State = 1964; + State = 2108; Match(TYPE); - State = 1965; + State = 2109; typeSpec(); - State = 1966; + State = 2110; customDescr(); } break; @@ -10008,17 +10413,17 @@ public FieldDeclContext fieldDecl() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1970; + State = 2114; Match(T__120); - State = 1971; + State = 2115; repeatOpt(); - State = 1980; + State = 2124; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,93,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,94,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { - State = 1978; + State = 2122; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -10037,19 +10442,19 @@ public FieldDeclContext fieldDecl() { case T__125: case T__126: { - State = 1972; + State = 2116; fieldAttr(); } break; case T__121: { - State = 1973; + State = 2117; Match(T__121); - State = 1974; + State = 2118; Match(T__29); - State = 1975; + State = 2119; marshalBlob(); - State = 1976; + State = 2120; Match(T__30); } break; @@ -10058,17 +10463,17 @@ public FieldDeclContext fieldDecl() { } } } - State = 1982; + State = 2126; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,93,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,94,Context); } - State = 1983; + State = 2127; type(); - State = 1984; + State = 2128; dottedName(); - State = 1985; + State = 2129; atOpt(); - State = 1986; + State = 2130; initOpt(); } } @@ -10105,117 +10510,117 @@ public FieldAttrContext fieldAttr() { FieldAttrContext _localctx = new FieldAttrContext(Context, State); EnterRule(_localctx, 202, RULE_fieldAttr); try { - State = 2007; + State = 2151; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__122: EnterOuterAlt(_localctx, 1); { - State = 1988; + State = 2132; Match(T__122); } break; case T__50: EnterOuterAlt(_localctx, 2); { - State = 1989; + State = 2133; Match(T__50); } break; case T__51: EnterOuterAlt(_localctx, 3); { - State = 1990; + State = 2134; Match(T__51); } break; case T__62: EnterOuterAlt(_localctx, 4); { - State = 1991; + State = 2135; Match(T__62); } break; case T__123: EnterOuterAlt(_localctx, 5); { - State = 1992; + State = 2136; Match(T__123); } break; case T__68: EnterOuterAlt(_localctx, 6); { - State = 1993; + State = 2137; Match(T__68); } break; case T__67: EnterOuterAlt(_localctx, 7); { - State = 1994; + State = 2138; Match(T__67); } break; case T__63: EnterOuterAlt(_localctx, 8); { - State = 1995; + State = 2139; Match(T__63); } break; case T__64: EnterOuterAlt(_localctx, 9); { - State = 1996; + State = 2140; Match(T__64); } break; case T__65: EnterOuterAlt(_localctx, 10); { - State = 1997; + State = 2141; Match(T__65); } break; case T__124: EnterOuterAlt(_localctx, 11); { - State = 1998; + State = 2142; Match(T__124); } break; case T__125: EnterOuterAlt(_localctx, 12); { - State = 1999; + State = 2143; Match(T__125); } break; case T__126: EnterOuterAlt(_localctx, 13); { - State = 2000; + State = 2144; Match(T__126); } break; case T__15: EnterOuterAlt(_localctx, 14); { - State = 2001; + State = 2145; Match(T__15); } break; case T__69: EnterOuterAlt(_localctx, 15); { - State = 2002; + State = 2146; Match(T__69); - State = 2003; + State = 2147; Match(T__29); - State = 2004; + State = 2148; int32(); - State = 2005; + State = 2149; Match(T__30); } break; @@ -10259,9 +10664,9 @@ public AtOptContext atOpt() { AtOptContext _localctx = new AtOptContext(Context, State); EnterRule(_localctx, 204, RULE_atOpt); try { - State = 2014; + State = 2158; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,95,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,96,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -10270,18 +10675,18 @@ public AtOptContext atOpt() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2010; + State = 2154; Match(T__43); - State = 2011; + State = 2155; id(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2012; + State = 2156; Match(T__43); - State = 2013; + State = 2157; int32(); } break; @@ -10320,7 +10725,7 @@ public InitOptContext initOpt() { InitOptContext _localctx = new InitOptContext(Context, State); EnterRule(_localctx, 206, RULE_initOpt); try { - State = 2019; + State = 2163; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -10414,9 +10819,9 @@ public InitOptContext initOpt() { case T__35: EnterOuterAlt(_localctx, 2); { - State = 2017; + State = 2161; Match(T__35); - State = 2018; + State = 2162; fieldInit(); } break; @@ -10457,7 +10862,7 @@ public RepeatOptContext repeatOpt() { RepeatOptContext _localctx = new RepeatOptContext(Context, State); EnterRule(_localctx, 208, RULE_repeatOpt); try { - State = 2026; + State = 2170; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -10512,11 +10917,11 @@ public RepeatOptContext repeatOpt() { case T__41: EnterOuterAlt(_localctx, 2); { - State = 2022; + State = 2166; Match(T__41); - State = 2023; + State = 2167; int32(); - State = 2024; + State = 2168; Match(T__42); } break; @@ -10567,54 +10972,54 @@ public EventHeadContext eventHead() { EnterRule(_localctx, 210, RULE_eventHead); int _la; try { - State = 2046; + State = 2190; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,100,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,101,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2028; + State = 2172; Match(T__127); - State = 2032; + State = 2176; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 2029; + State = 2173; eventAttr(); } } - State = 2034; + State = 2178; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2035; + State = 2179; typeSpec(); - State = 2036; + State = 2180; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2038; + State = 2182; Match(T__127); - State = 2042; + State = 2186; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 2039; + State = 2183; eventAttr(); } } - State = 2044; + State = 2188; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2045; + State = 2189; dottedName(); } break; @@ -10653,7 +11058,7 @@ public EventAttrContext eventAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 2048; + State = 2192; _la = TokenStream.LA(1); if ( !(_la==T__67 || _la==T__68) ) { ErrorHandler.RecoverInline(this); @@ -10703,17 +11108,17 @@ public EventDeclsContext eventDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2053; + State = 2197; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38788988928L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 1080863910568919043L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 2050; + State = 2194; eventDecl(); } } - State = 2055; + State = 2199; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -10764,42 +11169,42 @@ public EventDeclContext eventDecl() { EventDeclContext _localctx = new EventDeclContext(Context, State); EnterRule(_localctx, 216, RULE_eventDecl); try { - State = 2068; + State = 2212; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__128: EnterOuterAlt(_localctx, 1); { - State = 2056; + State = 2200; Match(T__128); - State = 2057; + State = 2201; methodRef(); } break; case T__129: EnterOuterAlt(_localctx, 2); { - State = 2058; + State = 2202; Match(T__129); - State = 2059; + State = 2203; methodRef(); } break; case T__130: EnterOuterAlt(_localctx, 3); { - State = 2060; + State = 2204; Match(T__130); - State = 2061; + State = 2205; methodRef(); } break; case T__131: EnterOuterAlt(_localctx, 4); { - State = 2062; + State = 2206; Match(T__131); - State = 2063; + State = 2207; methodRef(); } break; @@ -10807,7 +11212,7 @@ public EventDeclContext eventDecl() { case T__73: EnterOuterAlt(_localctx, 5); { - State = 2064; + State = 2208; extSourceSpec(); } break; @@ -10820,14 +11225,14 @@ public EventDeclContext eventDecl() { case ID: EnterOuterAlt(_localctx, 6); { - State = 2065; + State = 2209; customAttrDecl(); } break; case T__26: EnterOuterAlt(_localctx, 7); { - State = 2066; + State = 2210; languageDecl(); } break; @@ -10841,7 +11246,7 @@ public EventDeclContext eventDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 8); { - State = 2067; + State = 2211; compControl(); } break; @@ -10903,31 +11308,31 @@ public PropHeadContext propHead() { try { EnterOuterAlt(_localctx, 1); { - State = 2070; + State = 2214; Match(T__132); - State = 2074; + State = 2218; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 2071; + State = 2215; propAttr(); } } - State = 2076; + State = 2220; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2077; + State = 2221; callConv(); - State = 2078; + State = 2222; type(); - State = 2079; + State = 2223; dottedName(); - State = 2080; + State = 2224; sigArgs(); - State = 2081; + State = 2225; initOpt(); } } @@ -10964,7 +11369,7 @@ public PropAttrContext propAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 2083; + State = 2227; _la = TokenStream.LA(1); if ( !(_la==T__67 || _la==T__68) ) { ErrorHandler.RecoverInline(this); @@ -11014,17 +11419,17 @@ public PropDeclsContext propDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2088; + State = 2232; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38788988928L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 7493989779944505347L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 2085; + State = 2229; propDecl(); } } - State = 2090; + State = 2234; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11075,33 +11480,33 @@ public PropDeclContext propDecl() { PropDeclContext _localctx = new PropDeclContext(Context, State); EnterRule(_localctx, 224, RULE_propDecl); try { - State = 2101; + State = 2245; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__133: EnterOuterAlt(_localctx, 1); { - State = 2091; + State = 2235; Match(T__133); - State = 2092; + State = 2236; methodRef(); } break; case T__134: EnterOuterAlt(_localctx, 2); { - State = 2093; + State = 2237; Match(T__134); - State = 2094; + State = 2238; methodRef(); } break; case T__131: EnterOuterAlt(_localctx, 3); { - State = 2095; + State = 2239; Match(T__131); - State = 2096; + State = 2240; methodRef(); } break; @@ -11114,7 +11519,7 @@ public PropDeclContext propDecl() { case ID: EnterOuterAlt(_localctx, 4); { - State = 2097; + State = 2241; customAttrDecl(); } break; @@ -11122,14 +11527,14 @@ public PropDeclContext propDecl() { case T__73: EnterOuterAlt(_localctx, 5); { - State = 2098; + State = 2242; extSourceSpec(); } break; case T__26: EnterOuterAlt(_localctx, 6); { - State = 2099; + State = 2243; languageDecl(); } break; @@ -11143,7 +11548,7 @@ public PropDeclContext propDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 7); { - State = 2100; + State = 2244; compControl(); } break; @@ -11163,6 +11568,8 @@ public PropDeclContext propDecl() { } public partial class MarshalClauseContext : ParserRuleContext { + public object Value; + public MarshalBlobContext value; [System.Diagnostics.DebuggerNonUserCode] public MarshalBlobContext marshalBlob() { return GetRuleContext(0); } @@ -11183,9 +11590,8 @@ public override TResult Accept(IParseTreeVisitor visitor) { public MarshalClauseContext marshalClause() { MarshalClauseContext _localctx = new MarshalClauseContext(Context, State); EnterRule(_localctx, 226, RULE_marshalClause); - BeginSubtree(); try { - State = 2109; + State = 2254; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -11216,19 +11622,21 @@ public MarshalClauseContext marshalClause() { case ID: EnterOuterAlt(_localctx, 1); { + _localctx.Value = Actions.CreateEmptyMarshallingDescriptor(); } break; case T__121: EnterOuterAlt(_localctx, 2); { - State = 2104; + State = 2248; Match(T__121); - State = 2105; + State = 2249; Match(T__29); - State = 2106; - marshalBlob(); - State = 2107; + State = 2250; + _localctx.value = marshalBlob(); + State = 2251; Match(T__30); + _localctx.Value = Actions.CompleteMarshalClause(_localctx.value.Value); } break; default: @@ -11241,13 +11649,15 @@ public MarshalClauseContext marshalClause() { ErrorHandler.Recover(this, re); } finally { - EndParseTreeMode(); ExitRule(); } return _localctx; } public partial class MarshalBlobContext : ParserRuleContext { + public object Value; + public NativeTypeContext nativeValue; + public HexbyteContext rawByte; [System.Diagnostics.DebuggerNonUserCode] public NativeTypeContext nativeType() { return GetRuleContext(0); } @@ -11274,9 +11684,10 @@ public override TResult Accept(IParseTreeVisitor visitor) { public MarshalBlobContext marshalBlob() { MarshalBlobContext _localctx = new MarshalBlobContext(Context, State); EnterRule(_localctx, 228, RULE_marshalBlob); + Actions.BeginMarshalBlob(_localctx); int _la; try { - State = 2120; + State = 2269; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -11331,30 +11742,32 @@ public MarshalBlobContext marshalBlob() { case ID: EnterOuterAlt(_localctx, 1); { - State = 2111; - nativeType(); + State = 2256; + _localctx.nativeValue = nativeType(); + Actions.SetMarshalBlobNativeType(_localctx, _localctx.nativeValue.Value); } break; case T__16: EnterOuterAlt(_localctx, 2); { - State = 2112; + State = 2259; Match(T__16); - State = 2114; + State = 2263; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2113; - hexbyte(); + State = 2260; + _localctx.rawByte = hexbyte(); + Actions.AddMarshalBlobByte(_localctx, _localctx.rawByte.Value); } } - State = 2116; + State = 2265; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( _la==INT32 || _la==ID || _la==HEXBYTE ); - State = 2118; + State = 2267; Match(T__17); } break; @@ -11368,6 +11781,7 @@ public MarshalBlobContext marshalBlob() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndMarshalBlob(_localctx); ExitRule(); } return _localctx; @@ -11404,18 +11818,18 @@ public ParamAttrContext paramAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 2127; + State = 2276; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__41) { { { - State = 2122; + State = 2271; _localctx.element = paramAttrElement(); Actions.AddParameterAttribute(_localctx, _localctx.element); } } - State = 2129; + State = 2278; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11459,17 +11873,17 @@ public ParamAttrElementContext paramAttrElement() { ParamAttrElementContext _localctx = new ParamAttrElementContext(Context, State); EnterRule(_localctx, 232, RULE_paramAttrElement); try { - State = 2147; + State = 2296; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,110,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,111,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2130; + State = 2279; Match(T__41); - State = 2131; + State = 2280; _localctx.attribute = Match(T__135); - State = 2132; + State = 2281; Match(T__42); Actions.SetParameterAttributeElement(_localctx, _localctx.attribute); } @@ -11477,11 +11891,11 @@ public ParamAttrElementContext paramAttrElement() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2134; + State = 2283; Match(T__41); - State = 2135; + State = 2284; _localctx.attribute = Match(T__136); - State = 2136; + State = 2285; Match(T__42); Actions.SetParameterAttributeElement(_localctx, _localctx.attribute); } @@ -11489,11 +11903,11 @@ public ParamAttrElementContext paramAttrElement() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2138; + State = 2287; Match(T__41); - State = 2139; + State = 2288; _localctx.attribute = Match(T__137); - State = 2140; + State = 2289; Match(T__42); Actions.SetParameterAttributeElement(_localctx, _localctx.attribute); } @@ -11501,11 +11915,11 @@ public ParamAttrElementContext paramAttrElement() { case 4: EnterOuterAlt(_localctx, 4); { - State = 2142; + State = 2291; Match(T__41); - State = 2143; + State = 2292; _localctx.raw = int32(); - State = 2144; + State = 2293; Match(T__42); Actions.SetRawParameterAttributeElement(_localctx, (_localctx.raw!=null?(_localctx.raw.Start):null)); } @@ -11585,14 +11999,14 @@ public MethodHeadContext methodHead() { try { EnterOuterAlt(_localctx, 1); { - State = 2149; + State = 2298; Match(T__138); - State = 2154; + State = 2303; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & 978955L) != 0) || ((((_la - 123)) & ~0x3f) == 0 && ((1L << (_la - 123)) & 33423365L) != 0)) { { - State = 2152; + State = 2301; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__50: @@ -11615,13 +12029,13 @@ public MethodHeadContext methodHead() { case T__144: case T__145: { - State = 2150; + State = 2299; methAttr(); } break; case T__146: { - State = 2151; + State = 2300; pinvImpl(); } break; @@ -11629,35 +12043,35 @@ public MethodHeadContext methodHead() { throw new NoViableAltException(this); } } - State = 2156; + State = 2305; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2157; + State = 2306; callConv(); - State = 2158; + State = 2307; paramAttr(); - State = 2159; + State = 2308; type(); - State = 2160; + State = 2309; marshalClause(); - State = 2161; + State = 2310; methodName(); - State = 2162; + State = 2311; typarsClause(); - State = 2163; + State = 2312; sigArgs(); - State = 2167; + State = 2316; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 32766L) != 0) || _la==T__69 || _la==T__155 || _la==UNMANAGED) { { { - State = 2164; + State = 2313; implAttr(); } } - State = 2169; + State = 2318; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11699,145 +12113,145 @@ public MethAttrContext methAttr() { MethAttrContext _localctx = new MethAttrContext(Context, State); EnterRule(_localctx, 236, RULE_methAttr); try { - State = 2193; + State = 2342; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__122: EnterOuterAlt(_localctx, 1); { - State = 2170; + State = 2319; Match(T__122); } break; case T__50: EnterOuterAlt(_localctx, 2); { - State = 2171; + State = 2320; Match(T__50); } break; case T__51: EnterOuterAlt(_localctx, 3); { - State = 2172; + State = 2321; Match(T__51); } break; case T__62: EnterOuterAlt(_localctx, 4); { - State = 2173; + State = 2322; Match(T__62); } break; case T__139: EnterOuterAlt(_localctx, 5); { - State = 2174; + State = 2323; Match(T__139); } break; case T__67: EnterOuterAlt(_localctx, 6); { - State = 2175; + State = 2324; Match(T__67); } break; case T__140: EnterOuterAlt(_localctx, 7); { - State = 2176; + State = 2325; Match(T__140); } break; case T__141: EnterOuterAlt(_localctx, 8); { - State = 2177; + State = 2326; Match(T__141); } break; case T__53: EnterOuterAlt(_localctx, 9); { - State = 2178; + State = 2327; Match(T__53); } break; case T__63: EnterOuterAlt(_localctx, 10); { - State = 2179; + State = 2328; Match(T__63); } break; case T__64: EnterOuterAlt(_localctx, 11); { - State = 2180; + State = 2329; Match(T__64); } break; case T__65: EnterOuterAlt(_localctx, 12); { - State = 2181; + State = 2330; Match(T__65); } break; case T__124: EnterOuterAlt(_localctx, 13); { - State = 2182; + State = 2331; Match(T__124); } break; case T__142: EnterOuterAlt(_localctx, 14); { - State = 2183; + State = 2332; Match(T__142); } break; case T__143: EnterOuterAlt(_localctx, 15); { - State = 2184; + State = 2333; Match(T__143); } break; case T__68: EnterOuterAlt(_localctx, 16); { - State = 2185; + State = 2334; Match(T__68); } break; case T__144: EnterOuterAlt(_localctx, 17); { - State = 2186; + State = 2335; Match(T__144); } break; case T__145: EnterOuterAlt(_localctx, 18); { - State = 2187; + State = 2336; Match(T__145); } break; case T__69: EnterOuterAlt(_localctx, 19); { - State = 2188; + State = 2337; Match(T__69); - State = 2189; + State = 2338; Match(T__29); - State = 2190; + State = 2339; int32(); - State = 2191; + State = 2340; Match(T__30); } break; @@ -11888,31 +12302,31 @@ public PinvImplContext pinvImpl() { EnterRule(_localctx, 238, RULE_pinvImpl); int _la; try { - State = 2213; + State = 2362; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,118,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,119,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2195; + State = 2344; Match(T__146); - State = 2196; + State = 2345; Match(T__29); - State = 2202; + State = 2351; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==QSTRING) { { - State = 2197; + State = 2346; compQstring(); - State = 2200; + State = 2349; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__33) { { - State = 2198; + State = 2347; Match(T__33); - State = 2199; + State = 2348; compQstring(); } } @@ -11920,30 +12334,30 @@ public PinvImplContext pinvImpl() { } } - State = 2207; + State = 2356; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 57)) & ~0x3f) == 0 && ((1L << (_la - 57)) & 8195L) != 0) || ((((_la - 148)) & ~0x3f) == 0 && ((1L << (_la - 148)) & 79L) != 0) || ((((_la - 224)) & ~0x3f) == 0 && ((1L << (_la - 224)) & 251658241L) != 0)) { { { - State = 2204; + State = 2353; pinvAttr(); } } - State = 2209; + State = 2358; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2210; + State = 2359; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2211; + State = 2360; Match(T__146); - State = 2212; + State = 2361; Match(T__84); } break; @@ -11987,133 +12401,133 @@ public PinvAttrContext pinvAttr() { PinvAttrContext _localctx = new PinvAttrContext(Context, State); EnterRule(_localctx, 240, RULE_pinvAttr); try { - State = 2242; + State = 2391; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,119,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,120,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2215; + State = 2364; Match(T__147); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2216; + State = 2365; Match(ANSI); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2217; + State = 2366; Match(T__56); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2218; + State = 2367; Match(T__57); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2219; + State = 2368; Match(T__148); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2220; + State = 2369; Match(T__149); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2221; + State = 2370; Match(CDECL); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2222; + State = 2371; Match(STDCALL); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2223; + State = 2372; Match(THISCALL); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2224; + State = 2373; Match(FASTCALL); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2225; + State = 2374; Match(T__150); - State = 2226; + State = 2375; Match(T__74); - State = 2227; + State = 2376; Match(T__151); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2228; + State = 2377; Match(T__150); - State = 2229; + State = 2378; Match(T__74); - State = 2230; + State = 2379; Match(T__152); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2231; + State = 2380; Match(T__153); - State = 2232; + State = 2381; Match(T__74); - State = 2233; + State = 2382; Match(T__151); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2234; + State = 2383; Match(T__153); - State = 2235; + State = 2384; Match(T__74); - State = 2236; + State = 2385; Match(T__152); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2237; + State = 2386; Match(T__69); - State = 2238; + State = 2387; Match(T__29); - State = 2239; + State = 2388; int32(); - State = 2240; + State = 2389; Match(T__30); } break; @@ -12156,13 +12570,13 @@ public MethodNameContext methodName() { MethodNameContext _localctx = new MethodNameContext(Context, State); EnterRule(_localctx, 242, RULE_methodName); try { - State = 2251; + State = 2400; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__115: EnterOuterAlt(_localctx, 1); { - State = 2244; + State = 2393; _localctx.ctorName = Match(T__115); _localctx.Value = Actions.GetMethodName(_localctx.ctorName); } @@ -12170,7 +12584,7 @@ public MethodNameContext methodName() { case T__154: EnterOuterAlt(_localctx, 2); { - State = 2246; + State = 2395; _localctx.cctorName = Match(T__154); _localctx.Value = Actions.GetMethodName(_localctx.cctorName); } @@ -12183,7 +12597,7 @@ public MethodNameContext methodName() { case ID: EnterOuterAlt(_localctx, 3); { - State = 2248; + State = 2397; _localctx.dotted = dottedName(); _localctx.Value = _localctx.dotted.Value; } @@ -12226,131 +12640,131 @@ public ImplAttrContext implAttr() { ImplAttrContext _localctx = new ImplAttrContext(Context, State); EnterRule(_localctx, 244, RULE_implAttr); try { - State = 2274; + State = 2423; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: EnterOuterAlt(_localctx, 1); { - State = 2253; + State = 2402; Match(T__0); } break; case T__1: EnterOuterAlt(_localctx, 2); { - State = 2254; + State = 2403; Match(T__1); } break; case T__155: EnterOuterAlt(_localctx, 3); { - State = 2255; + State = 2404; Match(T__155); } break; case T__2: EnterOuterAlt(_localctx, 4); { - State = 2256; + State = 2405; Match(T__2); } break; case T__3: EnterOuterAlt(_localctx, 5); { - State = 2257; + State = 2406; Match(T__3); } break; case UNMANAGED: EnterOuterAlt(_localctx, 6); { - State = 2258; + State = 2407; Match(UNMANAGED); } break; case T__4: EnterOuterAlt(_localctx, 7); { - State = 2259; + State = 2408; Match(T__4); } break; case T__5: EnterOuterAlt(_localctx, 8); { - State = 2260; + State = 2409; Match(T__5); } break; case T__6: EnterOuterAlt(_localctx, 9); { - State = 2261; + State = 2410; Match(T__6); } break; case T__7: EnterOuterAlt(_localctx, 10); { - State = 2262; + State = 2411; Match(T__7); } break; case T__8: EnterOuterAlt(_localctx, 11); { - State = 2263; + State = 2412; Match(T__8); } break; case T__9: EnterOuterAlt(_localctx, 12); { - State = 2264; + State = 2413; Match(T__9); } break; case T__10: EnterOuterAlt(_localctx, 13); { - State = 2265; + State = 2414; Match(T__10); } break; case T__11: EnterOuterAlt(_localctx, 14); { - State = 2266; + State = 2415; Match(T__11); } break; case T__12: EnterOuterAlt(_localctx, 15); { - State = 2267; + State = 2416; Match(T__12); } break; case T__13: EnterOuterAlt(_localctx, 16); { - State = 2268; + State = 2417; Match(T__13); } break; case T__69: EnterOuterAlt(_localctx, 17); { - State = 2269; + State = 2418; Match(T__69); - State = 2270; + State = 2419; Match(T__29); - State = 2271; + State = 2420; int32(); - State = 2272; + State = 2421; Match(T__30); } break; @@ -12398,17 +12812,17 @@ public MethodDeclsContext methodDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2279; + State = 2428; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38789119998L) != 0) || _la==T__72 || _la==T__73 || ((((_la - 158)) & ~0x3f) == 0 && ((1L << (_la - 158)) & 2199023255681L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 2303696760354115601L) != 0)) { { { - State = 2276; + State = 2425; methodDecl(); } } - State = 2281; + State = 2430; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -12468,7 +12882,7 @@ public MethodDeclContext methodDecl() { MethodDeclContext _localctx = new MethodDeclContext(Context, State); EnterRule(_localctx, 248, RULE_methodDecl); try { - State = 2299; + State = 2448; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case INSTR_NONE: @@ -12486,16 +12900,16 @@ public MethodDeclContext methodDecl() { case INSTR_TOK: EnterOuterAlt(_localctx, 1); { - State = 2282; + State = 2431; instr(); } break; case EMITBYTE: EnterOuterAlt(_localctx, 2); { - State = 2283; + State = 2432; Match(EMITBYTE); - State = 2284; + State = 2433; _localctx.value = int32(); Actions.EmitByte((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -12503,16 +12917,16 @@ public MethodDeclContext methodDecl() { case T__157: EnterOuterAlt(_localctx, 3); { - State = 2287; + State = 2436; sehBlock(); } break; case MAXSTACK: EnterOuterAlt(_localctx, 4); { - State = 2288; + State = 2437; Match(MAXSTACK); - State = 2289; + State = 2438; _localctx.value = int32(); Actions.SetMaxStack((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -12520,7 +12934,7 @@ public MethodDeclContext methodDecl() { case ENTRYPOINT: EnterOuterAlt(_localctx, 5); { - State = 2292; + State = 2441; Match(ENTRYPOINT); Actions.SetEntryPoint(); } @@ -12528,7 +12942,7 @@ public MethodDeclContext methodDecl() { case ZEROINIT: EnterOuterAlt(_localctx, 6); { - State = 2294; + State = 2443; Match(ZEROINIT); Actions.SetZeroInit(); } @@ -12555,14 +12969,14 @@ public MethodDeclContext methodDecl() { case ID: EnterOuterAlt(_localctx, 7); { - State = 2296; + State = 2445; labelDecl(); } break; case T__16: EnterOuterAlt(_localctx, 8); { - State = 2297; + State = 2446; scopeBlock(); } break; @@ -12588,7 +13002,7 @@ public MethodDeclContext methodDecl() { case VTENTRY: EnterOuterAlt(_localctx, 9); { - State = 2298; + State = 2447; methodDeclIsland(); } break; @@ -12694,302 +13108,302 @@ public MethodDeclIslandContext methodDeclIsland() { BeginSubtree(); try { int _alt; - State = 2399; + State = 2548; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,129,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,130,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2301; + State = 2450; Match(LOCALS); - State = 2302; + State = 2451; sigArgs(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2303; + State = 2452; Match(LOCALS); - State = 2304; + State = 2453; Match(T__156); - State = 2305; + State = 2454; sigArgs(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2306; + State = 2455; dataDecl(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2307; + State = 2456; secDecl(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2308; + State = 2457; extSourceSpec(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2309; + State = 2458; languageDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2310; + State = 2459; customDescrInMethodBody(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2311; + State = 2460; compControl(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2312; + State = 2461; Match(EXPORT); - State = 2313; + State = 2462; Match(T__41); - State = 2314; + State = 2463; int32(); - State = 2315; + State = 2464; Match(T__42); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2317; + State = 2466; Match(EXPORT); - State = 2318; + State = 2467; Match(T__41); - State = 2319; + State = 2468; int32(); - State = 2320; + State = 2469; Match(T__42); - State = 2321; + State = 2470; Match(T__33); - State = 2322; + State = 2471; id(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2324; + State = 2473; Match(VTENTRY); - State = 2325; + State = 2474; int32(); - State = 2326; + State = 2475; Match(T__74); - State = 2327; + State = 2476; int32(); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2329; + State = 2478; Match(OVERRIDE); - State = 2330; + State = 2479; typeSpec(); - State = 2331; + State = 2480; Match(DCOLON); - State = 2332; + State = 2481; methodName(); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2334; + State = 2483; Match(OVERRIDE); - State = 2335; + State = 2484; Match(METHOD); - State = 2336; + State = 2485; callConv(); - State = 2337; + State = 2486; type(); - State = 2338; + State = 2487; typeSpec(); - State = 2339; + State = 2488; Match(DCOLON); - State = 2340; + State = 2489; methodName(); - State = 2341; + State = 2490; genArity(); - State = 2342; + State = 2491; sigArgs(); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2344; + State = 2493; Match(PARAM); - State = 2345; + State = 2494; Match(TYPE); - State = 2346; + State = 2495; Match(T__41); - State = 2347; + State = 2496; int32(); - State = 2348; + State = 2497; Match(T__42); - State = 2352; + State = 2501; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,124,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,125,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2349; + State = 2498; customAttrDecl(); } } } - State = 2354; + State = 2503; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,124,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,125,Context); } } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2355; + State = 2504; Match(PARAM); - State = 2356; + State = 2505; Match(TYPE); - State = 2357; + State = 2506; dottedName(); - State = 2361; + State = 2510; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,125,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,126,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2358; + State = 2507; customAttrDecl(); } } } - State = 2363; + State = 2512; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,125,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,126,Context); } } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 2364; + State = 2513; Match(PARAM); - State = 2365; + State = 2514; Match(CONSTRAINT); - State = 2366; + State = 2515; Match(T__41); - State = 2367; + State = 2516; int32(); - State = 2368; + State = 2517; Match(T__42); - State = 2369; + State = 2518; Match(T__27); - State = 2370; + State = 2519; typeSpec(); - State = 2374; + State = 2523; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,126,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,127,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2371; + State = 2520; customAttrDecl(); } } } - State = 2376; + State = 2525; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,126,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,127,Context); } } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 2377; + State = 2526; Match(PARAM); - State = 2378; + State = 2527; Match(CONSTRAINT); - State = 2379; + State = 2528; dottedName(); - State = 2380; + State = 2529; Match(T__27); - State = 2381; + State = 2530; typeSpec(); - State = 2385; + State = 2534; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,127,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,128,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2382; + State = 2531; customAttrDecl(); } } } - State = 2387; + State = 2536; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,127,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,128,Context); } } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 2388; + State = 2537; Match(PARAM); - State = 2389; + State = 2538; Match(T__41); - State = 2390; + State = 2539; int32(); - State = 2391; + State = 2540; Match(T__42); - State = 2392; + State = 2541; initOpt(); - State = 2396; + State = 2545; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,128,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,129,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2393; + State = 2542; customAttrDecl(); } } } - State = 2398; + State = 2547; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,128,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,129,Context); } } break; @@ -13034,9 +13448,9 @@ public LabelDeclContext labelDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2401; + State = 2550; _localctx.name = id(); - State = 2402; + State = 2551; Match(T__74); Actions.DefineLabel((_localctx.name!=null?(_localctx.name.Start):null)); } @@ -13077,20 +13491,20 @@ public CustomDescrInMethodBodyContext customDescrInMethodBody() { CustomDescrInMethodBodyContext _localctx = new CustomDescrInMethodBodyContext(Context, State); EnterRule(_localctx, 254, RULE_customDescrInMethodBody); try { - State = 2407; + State = 2556; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,130,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,131,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2405; + State = 2554; customDescr(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2406; + State = 2555; customDescrWithOwner(); } break; @@ -13132,11 +13546,11 @@ public ScopeBlockContext scopeBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 2409; + State = 2558; Match(T__16); - State = 2410; + State = 2559; methodDecls(); - State = 2411; + State = 2560; Match(T__17); } } @@ -13180,9 +13594,9 @@ public SehBlockContext sehBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 2413; + State = 2562; tryBlock(); - State = 2414; + State = 2563; sehClauses(); } Context.Stop = TokenStream.LT(-1); @@ -13228,17 +13642,17 @@ public SehClausesContext sehClauses() { try { EnterOuterAlt(_localctx, 1); { - State = 2417; + State = 2566; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2416; + State = 2565; sehClause(); } } - State = 2419; + State = 2568; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( ((((_la - 160)) & ~0x3f) == 0 && ((1L << (_la - 160)) & 15L) != 0) ); @@ -13289,41 +13703,41 @@ public TryBlockContext tryBlock() { TryBlockContext _localctx = new TryBlockContext(Context, State); EnterRule(_localctx, 262, RULE_tryBlock); try { - State = 2433; + State = 2582; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,132,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,133,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2421; + State = 2570; Match(T__157); - State = 2422; + State = 2571; scopeBlock(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2423; + State = 2572; Match(T__157); - State = 2424; + State = 2573; id(); - State = 2425; + State = 2574; Match(T__158); - State = 2426; + State = 2575; id(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2428; + State = 2577; Match(T__157); - State = 2429; + State = 2578; int32(); - State = 2430; + State = 2579; Match(T__158); - State = 2431; + State = 2580; int32(); } break; @@ -13374,42 +13788,42 @@ public SehClauseContext sehClause() { SehClauseContext _localctx = new SehClauseContext(Context, State); EnterRule(_localctx, 264, RULE_sehClause); try { - State = 2447; + State = 2596; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__160: EnterOuterAlt(_localctx, 1); { - State = 2435; + State = 2584; catchClause(); - State = 2436; + State = 2585; handlerBlock(); } break; case T__159: EnterOuterAlt(_localctx, 2); { - State = 2438; + State = 2587; filterClause(); - State = 2439; + State = 2588; handlerBlock(); } break; case T__161: EnterOuterAlt(_localctx, 3); { - State = 2441; + State = 2590; finallyClause(); - State = 2442; + State = 2591; handlerBlock(); } break; case T__162: EnterOuterAlt(_localctx, 4); { - State = 2444; + State = 2593; faultClause(); - State = 2445; + State = 2594; handlerBlock(); } break; @@ -13456,33 +13870,33 @@ public FilterClauseContext filterClause() { FilterClauseContext _localctx = new FilterClauseContext(Context, State); EnterRule(_localctx, 266, RULE_filterClause); try { - State = 2455; + State = 2604; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,134,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,135,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2449; + State = 2598; Match(T__159); - State = 2450; + State = 2599; scopeBlock(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2451; + State = 2600; Match(T__159); - State = 2452; + State = 2601; id(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2453; + State = 2602; Match(T__159); - State = 2454; + State = 2603; int32(); } break; @@ -13523,9 +13937,9 @@ public CatchClauseContext catchClause() { try { EnterOuterAlt(_localctx, 1); { - State = 2457; + State = 2606; Match(T__160); - State = 2458; + State = 2607; typeSpec(); } Context.Stop = TokenStream.LT(-1); @@ -13563,7 +13977,7 @@ public FinallyClauseContext finallyClause() { try { EnterOuterAlt(_localctx, 1); { - State = 2460; + State = 2609; Match(T__161); } } @@ -13599,7 +14013,7 @@ public FaultClauseContext faultClause() { try { EnterOuterAlt(_localctx, 1); { - State = 2462; + State = 2611; Match(T__162); } } @@ -13648,39 +14062,39 @@ public HandlerBlockContext handlerBlock() { HandlerBlockContext _localctx = new HandlerBlockContext(Context, State); EnterRule(_localctx, 274, RULE_handlerBlock); try { - State = 2475; + State = 2624; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,135,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,136,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2464; + State = 2613; scopeBlock(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2465; + State = 2614; Match(T__163); - State = 2466; + State = 2615; id(); - State = 2467; + State = 2616; Match(T__158); - State = 2468; + State = 2617; id(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2470; + State = 2619; Match(T__163); - State = 2471; + State = 2620; int32(); - State = 2472; + State = 2621; Match(T__158); - State = 2473; + State = 2622; int32(); } break; @@ -13724,9 +14138,9 @@ public DataDeclContext dataDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2477; + State = 2626; ddHead(); - State = 2478; + State = 2627; ddBody(); } } @@ -13766,28 +14180,28 @@ public DdHeadContext ddHead() { DdHeadContext _localctx = new DdHeadContext(Context, State); EnterRule(_localctx, 278, RULE_ddHead); try { - State = 2487; + State = 2636; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,136,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,137,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2480; + State = 2629; Match(T__164); - State = 2481; + State = 2630; tls(); - State = 2482; + State = 2631; id(); - State = 2483; + State = 2632; Match(T__35); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2485; + State = 2634; Match(T__164); - State = 2486; + State = 2635; tls(); } break; @@ -13823,9 +14237,9 @@ public TlsContext tls() { TlsContext _localctx = new TlsContext(Context, State); EnterRule(_localctx, 280, RULE_tls); try { - State = 2492; + State = 2641; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,137,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,138,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -13834,14 +14248,14 @@ public TlsContext tls() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2490; + State = 2639; Match(T__165); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2491; + State = 2640; Match(T__1); } break; @@ -13887,17 +14301,17 @@ public DdBodyContext ddBody() { EnterRule(_localctx, 282, RULE_ddBody); int _la; try { - State = 2503; + State = 2652; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: EnterOuterAlt(_localctx, 1); { - State = 2494; + State = 2643; Match(T__16); - State = 2495; + State = 2644; ddItemList(); - State = 2496; + State = 2645; Match(T__17); } break; @@ -13912,17 +14326,17 @@ public DdBodyContext ddBody() { case REF: EnterOuterAlt(_localctx, 2); { - State = 2499; + State = 2648; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2498; + State = 2647; ddItem(); } } - State = 2501; + State = 2650; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( _la==T__83 || ((((_la - 181)) & ~0x3f) == 0 && ((1L << (_la - 181)) & 505L) != 0) || _la==REF ); @@ -13971,25 +14385,25 @@ public DdItemListContext ddItemList() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 2510; + State = 2659; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,140,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,141,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2505; + State = 2654; ddItem(); - State = 2506; + State = 2655; Match(T__27); } } } - State = 2512; + State = 2661; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,140,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,141,Context); } - State = 2513; + State = 2662; ddItem(); } } @@ -14026,7 +14440,7 @@ public DdItemCountContext ddItemCount() { DdItemCountContext _localctx = new DdItemCountContext(Context, State); EnterRule(_localctx, 286, RULE_ddItemCount); try { - State = 2520; + State = 2669; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -14130,11 +14544,11 @@ public DdItemCountContext ddItemCount() { case T__41: EnterOuterAlt(_localctx, 2); { - State = 2516; + State = 2665; Match(T__41); - State = 2517; + State = 2666; int32(); - State = 2518; + State = 2667; Match(T__42); } break; @@ -14202,200 +14616,200 @@ public DdItemContext ddItem() { DdItemContext _localctx = new DdItemContext(Context, State); EnterRule(_localctx, 288, RULE_ddItem); try { - State = 2588; + State = 2737; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,142,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,143,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2522; + State = 2671; Match(CHAR); - State = 2523; + State = 2672; Match(PTR); - State = 2524; + State = 2673; Match(T__29); - State = 2525; + State = 2674; compQstring(); - State = 2526; + State = 2675; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2528; + State = 2677; Match(REF); - State = 2529; + State = 2678; Match(T__29); - State = 2530; + State = 2679; id(); - State = 2531; + State = 2680; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2533; + State = 2682; Match(REF); - State = 2534; + State = 2683; id(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2535; + State = 2684; Match(T__83); - State = 2536; + State = 2685; Match(T__29); - State = 2537; + State = 2686; bytes(); - State = 2538; + State = 2687; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2540; + State = 2689; Match(FLOAT32); - State = 2541; + State = 2690; Match(T__29); - State = 2542; + State = 2691; float64(); - State = 2543; + State = 2692; Match(T__30); - State = 2544; + State = 2693; ddItemCount(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2546; + State = 2695; Match(FLOAT64_); - State = 2547; + State = 2696; Match(T__29); - State = 2548; + State = 2697; float64(); - State = 2549; + State = 2698; Match(T__30); - State = 2550; + State = 2699; ddItemCount(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2552; + State = 2701; Match(INT64_); - State = 2553; + State = 2702; Match(T__29); - State = 2554; + State = 2703; int64(); - State = 2555; + State = 2704; Match(T__30); - State = 2556; + State = 2705; ddItemCount(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2558; + State = 2707; Match(INT32_); - State = 2559; + State = 2708; Match(T__29); - State = 2560; + State = 2709; int32(); - State = 2561; + State = 2710; Match(T__30); - State = 2562; + State = 2711; ddItemCount(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2564; + State = 2713; Match(INT16); - State = 2565; + State = 2714; Match(T__29); - State = 2566; + State = 2715; int32(); - State = 2567; + State = 2716; Match(T__30); - State = 2568; + State = 2717; ddItemCount(); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2570; + State = 2719; Match(INT8); - State = 2571; + State = 2720; Match(T__29); - State = 2572; + State = 2721; int32(); - State = 2573; + State = 2722; Match(T__30); - State = 2574; + State = 2723; ddItemCount(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2576; + State = 2725; Match(FLOAT32); - State = 2577; + State = 2726; ddItemCount(); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2578; + State = 2727; Match(FLOAT64_); - State = 2579; + State = 2728; ddItemCount(); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2580; + State = 2729; Match(INT64_); - State = 2581; + State = 2730; ddItemCount(); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2582; + State = 2731; Match(INT32_); - State = 2583; + State = 2732; ddItemCount(); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2584; + State = 2733; Match(INT16); - State = 2585; + State = 2734; ddItemCount(); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 2586; + State = 2735; Match(INT8); - State = 2587; + State = 2736; ddItemCount(); } break; @@ -14458,201 +14872,201 @@ public FieldSerInitContext fieldSerInit() { FieldSerInitContext _localctx = new FieldSerInitContext(Context, State); EnterRule(_localctx, 290, RULE_fieldSerInit); try { - State = 2665; + State = 2814; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,143,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,144,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2590; + State = 2739; Match(FLOAT32); - State = 2591; + State = 2740; Match(T__29); - State = 2592; + State = 2741; float64(); - State = 2593; + State = 2742; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2595; + State = 2744; Match(FLOAT64_); - State = 2596; + State = 2745; Match(T__29); - State = 2597; + State = 2746; float64(); - State = 2598; + State = 2747; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2600; + State = 2749; Match(FLOAT32); - State = 2601; + State = 2750; Match(T__29); - State = 2602; + State = 2751; int32(); - State = 2603; + State = 2752; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2605; + State = 2754; Match(FLOAT64_); - State = 2606; + State = 2755; Match(T__29); - State = 2607; + State = 2756; int64(); - State = 2608; + State = 2757; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2610; + State = 2759; Match(INT64_); - State = 2611; + State = 2760; Match(T__29); - State = 2612; + State = 2761; int64(); - State = 2613; + State = 2762; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2615; + State = 2764; Match(INT32_); - State = 2616; + State = 2765; Match(T__29); - State = 2617; + State = 2766; int32(); - State = 2618; + State = 2767; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2620; + State = 2769; Match(INT16); - State = 2621; + State = 2770; Match(T__29); - State = 2622; + State = 2771; int32(); - State = 2623; + State = 2772; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2625; + State = 2774; Match(INT8); - State = 2626; + State = 2775; Match(T__29); - State = 2627; + State = 2776; int32(); - State = 2628; + State = 2777; Match(T__30); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2630; + State = 2779; Match(UINT64); - State = 2631; + State = 2780; Match(T__29); - State = 2632; + State = 2781; int64(); - State = 2633; + State = 2782; Match(T__30); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2635; + State = 2784; Match(UINT32); - State = 2636; + State = 2785; Match(T__29); - State = 2637; + State = 2786; int32(); - State = 2638; + State = 2787; Match(T__30); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2640; + State = 2789; Match(UINT16); - State = 2641; + State = 2790; Match(T__29); - State = 2642; + State = 2791; int32(); - State = 2643; + State = 2792; Match(T__30); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2645; + State = 2794; Match(UINT8); - State = 2646; + State = 2795; Match(T__29); - State = 2647; + State = 2796; int32(); - State = 2648; + State = 2797; Match(T__30); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2650; + State = 2799; Match(CHAR); - State = 2651; + State = 2800; Match(T__29); - State = 2652; + State = 2801; int32(); - State = 2653; + State = 2802; Match(T__30); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2655; + State = 2804; Match(BOOL); - State = 2656; + State = 2805; Match(T__29); - State = 2657; + State = 2806; truefalse(); - State = 2658; + State = 2807; Match(T__30); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2660; + State = 2809; Match(T__83); - State = 2661; + State = 2810; Match(T__29); - State = 2662; + State = 2811; bytes(); - State = 2663; + State = 2812; Match(T__30); } break; @@ -14700,18 +15114,18 @@ public BytesContext bytes() { try { EnterOuterAlt(_localctx, 1); { - State = 2672; + State = 2821; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32 || _la==ID || _la==HEXBYTE) { { { - State = 2667; + State = 2816; _localctx.b = hexbyte(); Actions.AddByte(_localctx.b.Value); } } - State = 2674; + State = 2823; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -14755,7 +15169,7 @@ public HexbyteContext hexbyte() { try { EnterOuterAlt(_localctx, 1); { - State = 2675; + State = 2824; _la = TokenStream.LA(1); if ( !(_la==INT32 || _la==ID || _la==HEXBYTE) ) { ErrorHandler.RecoverInline(this); @@ -14805,7 +15219,7 @@ public FieldInitContext fieldInit() { FieldInitContext _localctx = new FieldInitContext(Context, State); EnterRule(_localctx, 296, RULE_fieldInit); try { - State = 2680; + State = 2829; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__83: @@ -14823,21 +15237,21 @@ public FieldInitContext fieldInit() { case UINT64: EnterOuterAlt(_localctx, 1); { - State = 2677; + State = 2826; fieldSerInit(); } break; case QSTRING: EnterOuterAlt(_localctx, 2); { - State = 2678; + State = 2827; compQstring(); } break; case NULLREF: EnterOuterAlt(_localctx, 3); { - State = 2679; + State = 2828; Match(NULLREF); } break; @@ -14934,378 +15348,378 @@ public SerInitContext serInit() { SerInitContext _localctx = new SerInitContext(Context, State); EnterRule(_localctx, 298, RULE_serInit); try { - State = 2830; + State = 2979; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,146,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,147,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2682; + State = 2831; fieldSerInit(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2683; + State = 2832; Match(STRING); - State = 2684; + State = 2833; Match(T__29); - State = 2685; + State = 2834; Match(NULLREF); - State = 2686; + State = 2835; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2687; + State = 2836; Match(STRING); - State = 2688; + State = 2837; Match(T__29); - State = 2689; + State = 2838; Match(SQSTRING); - State = 2690; + State = 2839; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2691; + State = 2840; Match(TYPE); - State = 2692; + State = 2841; Match(T__29); - State = 2693; + State = 2842; Match(T__38); - State = 2694; + State = 2843; Match(SQSTRING); - State = 2695; + State = 2844; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2696; + State = 2845; Match(TYPE); - State = 2697; + State = 2846; Match(T__29); - State = 2698; + State = 2847; className(); - State = 2699; + State = 2848; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2701; + State = 2850; Match(TYPE); - State = 2702; + State = 2851; Match(T__29); - State = 2703; + State = 2852; Match(NULLREF); - State = 2704; + State = 2853; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2705; + State = 2854; Match(OBJECT); - State = 2706; + State = 2855; Match(T__29); - State = 2707; + State = 2856; serInit(); - State = 2708; + State = 2857; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2710; + State = 2859; Match(FLOAT32); - State = 2711; + State = 2860; Match(T__41); - State = 2712; + State = 2861; int32(); - State = 2713; + State = 2862; Match(T__42); - State = 2714; + State = 2863; Match(T__29); - State = 2715; + State = 2864; f32seq(); - State = 2716; + State = 2865; Match(T__30); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2718; + State = 2867; Match(FLOAT64_); - State = 2719; + State = 2868; Match(T__41); - State = 2720; + State = 2869; int32(); - State = 2721; + State = 2870; Match(T__42); - State = 2722; + State = 2871; Match(T__29); - State = 2723; + State = 2872; f64seq(); - State = 2724; + State = 2873; Match(T__30); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2726; + State = 2875; Match(INT64_); - State = 2727; + State = 2876; Match(T__41); - State = 2728; + State = 2877; int32(); - State = 2729; + State = 2878; Match(T__42); - State = 2730; + State = 2879; Match(T__29); - State = 2731; + State = 2880; i64seq(); - State = 2732; + State = 2881; Match(T__30); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2734; + State = 2883; Match(INT32_); - State = 2735; + State = 2884; Match(T__41); - State = 2736; + State = 2885; int32(); - State = 2737; + State = 2886; Match(T__42); - State = 2738; + State = 2887; Match(T__29); - State = 2739; + State = 2888; i32seq(); - State = 2740; + State = 2889; Match(T__30); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2742; + State = 2891; Match(INT16); - State = 2743; + State = 2892; Match(T__41); - State = 2744; + State = 2893; int32(); - State = 2745; + State = 2894; Match(T__42); - State = 2746; + State = 2895; Match(T__29); - State = 2747; + State = 2896; i16seq(); - State = 2748; + State = 2897; Match(T__30); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2750; + State = 2899; Match(INT8); - State = 2751; + State = 2900; Match(T__41); - State = 2752; + State = 2901; int32(); - State = 2753; + State = 2902; Match(T__42); - State = 2754; + State = 2903; Match(T__29); - State = 2755; + State = 2904; i8seq(); - State = 2756; + State = 2905; Match(T__30); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2758; + State = 2907; Match(UINT64); - State = 2759; + State = 2908; Match(T__41); - State = 2760; + State = 2909; int32(); - State = 2761; + State = 2910; Match(T__42); - State = 2762; + State = 2911; Match(T__29); - State = 2763; + State = 2912; i64seq(); - State = 2764; + State = 2913; Match(T__30); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2766; + State = 2915; Match(UINT32); - State = 2767; + State = 2916; Match(T__41); - State = 2768; + State = 2917; int32(); - State = 2769; + State = 2918; Match(T__42); - State = 2770; + State = 2919; Match(T__29); - State = 2771; + State = 2920; i32seq(); - State = 2772; + State = 2921; Match(T__30); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 2774; + State = 2923; Match(UINT16); - State = 2775; + State = 2924; Match(T__41); - State = 2776; + State = 2925; int32(); - State = 2777; + State = 2926; Match(T__42); - State = 2778; + State = 2927; Match(T__29); - State = 2779; + State = 2928; i16seq(); - State = 2780; + State = 2929; Match(T__30); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 2782; + State = 2931; Match(UINT8); - State = 2783; + State = 2932; Match(T__41); - State = 2784; + State = 2933; int32(); - State = 2785; + State = 2934; Match(T__42); - State = 2786; + State = 2935; Match(T__29); - State = 2787; + State = 2936; i8seq(); - State = 2788; + State = 2937; Match(T__30); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 2790; + State = 2939; Match(CHAR); - State = 2791; + State = 2940; Match(T__41); - State = 2792; + State = 2941; int32(); - State = 2793; + State = 2942; Match(T__42); - State = 2794; + State = 2943; Match(T__29); - State = 2795; + State = 2944; i16seq(); - State = 2796; + State = 2945; Match(T__30); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 2798; + State = 2947; Match(BOOL); - State = 2799; + State = 2948; Match(T__41); - State = 2800; + State = 2949; int32(); - State = 2801; + State = 2950; Match(T__42); - State = 2802; + State = 2951; Match(T__29); - State = 2803; + State = 2952; boolSeq(); - State = 2804; + State = 2953; Match(T__30); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 2806; + State = 2955; Match(STRING); - State = 2807; + State = 2956; Match(T__41); - State = 2808; + State = 2957; int32(); - State = 2809; + State = 2958; Match(T__42); - State = 2810; + State = 2959; Match(T__29); - State = 2811; + State = 2960; sqstringSeq(); - State = 2812; + State = 2961; Match(T__30); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 2814; + State = 2963; Match(TYPE); - State = 2815; + State = 2964; Match(T__41); - State = 2816; + State = 2965; int32(); - State = 2817; + State = 2966; Match(T__42); - State = 2818; + State = 2967; Match(T__29); - State = 2819; + State = 2968; classSeq(); - State = 2820; + State = 2969; Match(T__30); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 2822; + State = 2971; Match(OBJECT); - State = 2823; + State = 2972; Match(T__41); - State = 2824; + State = 2973; int32(); - State = 2825; + State = 2974; Match(T__42); - State = 2826; + State = 2975; Match(T__29); - State = 2827; + State = 2976; objSeq(); - State = 2828; + State = 2977; Match(T__30); } break; @@ -15356,29 +15770,29 @@ public F32seqContext f32seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2836; + State = 2985; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 98309L) != 0)) { { - State = 2834; + State = 2983; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,147,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,148,Context) ) { case 1: { - State = 2832; + State = 2981; float64(); } break; case 2: { - State = 2833; + State = 2982; int32(); } break; } } - State = 2838; + State = 2987; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15429,29 +15843,29 @@ public F64seqContext f64seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2843; + State = 2992; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 98311L) != 0)) { { - State = 2841; + State = 2990; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,149,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,150,Context) ) { case 1: { - State = 2839; + State = 2988; float64(); } break; case 2: { - State = 2840; + State = 2989; int64(); } break; } } - State = 2845; + State = 2994; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15496,17 +15910,17 @@ public I64seqContext i64seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2849; + State = 2998; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32 || _la==INT64) { { { - State = 2846; + State = 2995; int64(); } } - State = 2851; + State = 3000; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15551,17 +15965,17 @@ public I32seqContext i32seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2855; + State = 3004; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 2852; + State = 3001; int32(); } } - State = 2857; + State = 3006; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15606,17 +16020,17 @@ public I16seqContext i16seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2861; + State = 3010; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 2858; + State = 3007; int32(); } } - State = 2863; + State = 3012; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15661,17 +16075,17 @@ public I8seqContext i8seq() { try { EnterOuterAlt(_localctx, 1); { - State = 2867; + State = 3016; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 2864; + State = 3013; int32(); } } - State = 2869; + State = 3018; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15716,17 +16130,17 @@ public BoolSeqContext boolSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 2873; + State = 3022; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__94 || _la==T__95) { { { - State = 2870; + State = 3019; truefalse(); } } - State = 2875; + State = 3024; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15773,13 +16187,13 @@ public SqstringSeqContext sqstringSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 2879; + State = 3028; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==NULLREF || _la==SQSTRING) { { { - State = 2876; + State = 3025; _la = TokenStream.LA(1); if ( !(_la==NULLREF || _la==SQSTRING) ) { ErrorHandler.RecoverInline(this); @@ -15790,7 +16204,7 @@ public SqstringSeqContext sqstringSeq() { } } } - State = 2881; + State = 3030; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15835,17 +16249,17 @@ public ClassSeqContext classSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 2885; + State = 3034; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4947802390528L) != 0) || _la==T__112 || _la==NULLREF || _la==VALUE || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 105553118478337L) != 0)) { { { - State = 2882; + State = 3031; classSeqElement(); } } - State = 2887; + State = 3036; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15886,22 +16300,22 @@ public ClassSeqElementContext classSeqElement() { ClassSeqElementContext _localctx = new ClassSeqElementContext(Context, State); EnterRule(_localctx, 318, RULE_classSeqElement); try { - State = 2892; + State = 3041; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case NULLREF: EnterOuterAlt(_localctx, 1); { - State = 2888; + State = 3037; Match(NULLREF); } break; case T__38: EnterOuterAlt(_localctx, 2); { - State = 2889; + State = 3038; Match(T__38); - State = 2890; + State = 3039; Match(SQSTRING); } break; @@ -15918,7 +16332,7 @@ public ClassSeqElementContext classSeqElement() { case ID: EnterOuterAlt(_localctx, 3); { - State = 2891; + State = 3040; className(); } break; @@ -15965,17 +16379,17 @@ public ObjSeqContext objSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 2897; + State = 3046; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__83 || ((((_la - 181)) & ~0x3f) == 0 && ((1L << (_la - 181)) & 106495L) != 0)) { { { - State = 2894; + State = 3043; serInit(); } } - State = 2899; + State = 3048; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16020,27 +16434,27 @@ public CustomAttrDeclContext customAttrDecl() { CustomAttrDeclContext _localctx = new CustomAttrDeclContext(Context, State); EnterRule(_localctx, 322, RULE_customAttrDecl); try { - State = 2903; + State = 3052; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,160,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,161,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2900; + State = 3049; customDescr(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2901; + State = 3050; customDescrWithOwner(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2902; + State = 3051; dottedName(); } break; @@ -16095,13 +16509,13 @@ public AsmOrRefDeclContext asmOrRefDecl() { EnterRule(_localctx, 324, RULE_asmOrRefDecl); int _la; try { - State = 2930; + State = 3079; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,161,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,162,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2905; + State = 3054; _la = TokenStream.LA(1); if ( !(_la==T__166 || _la==T__167) ) { ErrorHandler.RecoverInline(this); @@ -16110,72 +16524,72 @@ public AsmOrRefDeclContext asmOrRefDecl() { ErrorHandler.ReportMatch(this); Consume(); } - State = 2906; + State = 3055; Match(T__35); - State = 2907; + State = 3056; Match(T__29); - State = 2908; + State = 3057; bytes(); - State = 2909; + State = 3058; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2911; + State = 3060; Match(T__168); - State = 2912; + State = 3061; intOrWildcard(); - State = 2913; + State = 3062; Match(T__74); - State = 2914; + State = 3063; intOrWildcard(); - State = 2915; + State = 3064; Match(T__74); - State = 2916; + State = 3065; intOrWildcard(); - State = 2917; + State = 3066; Match(T__74); - State = 2918; + State = 3067; intOrWildcard(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2920; + State = 3069; Match(T__169); - State = 2921; + State = 3070; compQstring(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2922; + State = 3071; Match(T__169); - State = 2923; + State = 3072; Match(T__35); - State = 2924; + State = 3073; Match(T__29); - State = 2925; + State = 3074; bytes(); - State = 2926; + State = 3075; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2928; + State = 3077; customAttrDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2929; + State = 3078; compControl(); } break; @@ -16220,36 +16634,36 @@ public AssemblyRefHeadContext assemblyRefHead() { AssemblyRefHeadContext _localctx = new AssemblyRefHeadContext(Context, State); EnterRule(_localctx, 326, RULE_assemblyRefHead); try { - State = 2944; + State = 3093; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,162,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,163,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2932; + State = 3081; Match(T__24); - State = 2933; + State = 3082; Match(T__39); - State = 2934; + State = 3083; asmAttr(); - State = 2935; + State = 3084; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2937; + State = 3086; Match(T__24); - State = 2938; + State = 3087; Match(T__39); - State = 2939; + State = 3088; asmAttr(); - State = 2940; + State = 3089; dottedName(); - State = 2941; + State = 3090; Match(T__33); - State = 2942; + State = 3091; dottedName(); } break; @@ -16294,17 +16708,17 @@ public AssemblyRefDeclsContext assemblyRefDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2949; + State = 3098; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 36028835673735168L) != 0) || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & 4294975519L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 105555249070081L) != 0)) { { { - State = 2946; + State = 3095; assemblyRefDecl(); } } - State = 2951; + State = 3100; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16347,21 +16761,21 @@ public AssemblyRefDeclContext assemblyRefDecl() { AssemblyRefDeclContext _localctx = new AssemblyRefDeclContext(Context, State); EnterRule(_localctx, 330, RULE_assemblyRefDecl); try { - State = 2966; + State = 3115; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case HASH: EnterOuterAlt(_localctx, 1); { - State = 2952; + State = 3101; Match(HASH); - State = 2953; + State = 3102; Match(T__35); - State = 2954; + State = 3103; Match(T__29); - State = 2955; + State = 3104; bytes(); - State = 2956; + State = 3105; Match(T__30); } break; @@ -16386,29 +16800,29 @@ public AssemblyRefDeclContext assemblyRefDecl() { case ID: EnterOuterAlt(_localctx, 2); { - State = 2958; + State = 3107; asmOrRefDecl(); } break; case T__170: EnterOuterAlt(_localctx, 3); { - State = 2959; + State = 3108; Match(T__170); - State = 2960; + State = 3109; Match(T__35); - State = 2961; + State = 3110; Match(T__29); - State = 2962; + State = 3111; bytes(); - State = 2963; + State = 3112; Match(T__30); } break; case T__54: EnterOuterAlt(_localctx, 4); { - State = 2965; + State = 3114; Match(T__54); } break; @@ -16458,25 +16872,25 @@ public ExptypeHeadContext exptypeHead() { try { EnterOuterAlt(_localctx, 1); { - State = 2968; + State = 3117; Match(T__49); - State = 2969; + State = 3118; Match(T__39); - State = 2973; + State = 3122; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4618441417868443648L) != 0) || _la==T__171) { { { - State = 2970; + State = 3119; exptAttr(); } } - State = 2975; + State = 3124; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2976; + State = 3125; dottedName(); } } @@ -16523,23 +16937,23 @@ public ExportHeadContext exportHead() { try { EnterOuterAlt(_localctx, 1); { - State = 2978; + State = 3127; Match(EXPORT); - State = 2982; + State = 3131; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4618441417868443648L) != 0) || _la==T__171) { { { - State = 2979; + State = 3128; exptAttr(); } } - State = 2984; + State = 3133; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2985; + State = 3134; dottedName(); } } @@ -16573,81 +16987,81 @@ public ExptAttrContext exptAttr() { ExptAttrContext _localctx = new ExptAttrContext(Context, State); EnterRule(_localctx, 336, RULE_exptAttr); try { - State = 3002; + State = 3151; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,167,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,168,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2987; + State = 3136; Match(T__51); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2988; + State = 3137; Match(T__50); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2989; + State = 3138; Match(T__171); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2990; + State = 3139; Match(T__61); - State = 2991; + State = 3140; Match(T__50); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2992; + State = 3141; Match(T__61); - State = 2993; + State = 3142; Match(T__51); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2994; + State = 3143; Match(T__61); - State = 2995; + State = 3144; Match(T__62); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2996; + State = 3145; Match(T__61); - State = 2997; + State = 3146; Match(T__63); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2998; + State = 3147; Match(T__61); - State = 2999; + State = 3148; Match(T__64); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 3000; + State = 3149; Match(T__61); - State = 3001; + State = 3150; Match(T__65); } break; @@ -16692,17 +17106,17 @@ public ExptypeDeclsContext exptypeDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 3007; + State = 3156; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1125938597265408L) != 0) || _la==T__112 || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 3004; + State = 3153; exptypeDecl(); } } - State = 3009; + State = 3158; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16756,67 +17170,67 @@ public ExptypeDeclContext exptypeDecl() { ExptypeDeclContext _localctx = new ExptypeDeclContext(Context, State); EnterRule(_localctx, 340, RULE_exptypeDecl); try { - State = 3023; + State = 3172; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,169,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,170,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3010; + State = 3159; Match(T__20); - State = 3011; + State = 3160; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3012; + State = 3161; Match(T__49); - State = 3013; + State = 3162; Match(T__39); - State = 3014; + State = 3163; slashedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3015; + State = 3164; Match(T__24); - State = 3016; + State = 3165; Match(T__39); - State = 3017; + State = 3166; dottedName(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 3018; + State = 3167; mdtoken(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 3019; + State = 3168; Match(T__49); - State = 3020; + State = 3169; int32(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 3021; + State = 3170; customAttrDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 3022; + State = 3171; compControl(); } break; @@ -16866,56 +17280,56 @@ public ManifestResHeadContext manifestResHead() { EnterRule(_localctx, 342, RULE_manifestResHead); int _la; try { - State = 3044; + State = 3193; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,172,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,173,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3025; + State = 3174; Match(MRESOURCE); - State = 3029; + State = 3178; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__50 || _la==T__51) { { { - State = 3026; + State = 3175; manresAttr(); } } - State = 3031; + State = 3180; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 3032; + State = 3181; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3033; + State = 3182; Match(MRESOURCE); - State = 3037; + State = 3186; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__50 || _la==T__51) { { { - State = 3034; + State = 3183; manresAttr(); } } - State = 3039; + State = 3188; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 3040; + State = 3189; dottedName(); - State = 3041; + State = 3190; Match(T__33); - State = 3042; + State = 3191; dottedName(); } break; @@ -16954,7 +17368,7 @@ public ManresAttrContext manresAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 3046; + State = 3195; _la = TokenStream.LA(1); if ( !(_la==T__50 || _la==T__51) ) { ErrorHandler.RecoverInline(this); @@ -17004,17 +17418,17 @@ public ManifestResDeclsContext manifestResDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 3051; + State = 3200; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38690422784L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 3048; + State = 3197; manifestResDecl(); } } - State = 3053; + State = 3202; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17062,30 +17476,30 @@ public ManifestResDeclContext manifestResDecl() { ManifestResDeclContext _localctx = new ManifestResDeclContext(Context, State); EnterRule(_localctx, 348, RULE_manifestResDecl); try { - State = 3064; + State = 3213; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__20: EnterOuterAlt(_localctx, 1); { - State = 3054; + State = 3203; Match(T__20); - State = 3055; + State = 3204; dottedName(); - State = 3056; + State = 3205; Match(T__43); - State = 3057; + State = 3206; int32(); } break; case T__24: EnterOuterAlt(_localctx, 2); { - State = 3059; + State = 3208; Match(T__24); - State = 3060; + State = 3209; Match(T__39); - State = 3061; + State = 3210; dottedName(); } break; @@ -17098,7 +17512,7 @@ public ManifestResDeclContext manifestResDecl() { case ID: EnterOuterAlt(_localctx, 3); { - State = 3062; + State = 3211; customAttrDecl(); } break; @@ -17112,7 +17526,7 @@ public ManifestResDeclContext manifestResDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 4); { - State = 3063; + State = 3212; compControl(); } break; @@ -17149,7 +17563,7 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { } private static int[] _serializedATN = { - 4,1,305,3067,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, + 4,1,305,3216,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, @@ -17241,129 +17655,140 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 1187,9,59,1,59,1,59,1,59,1,60,5,60,1193,8,60,10,60,12,60,1196,9,60,1,61, 1,61,1,61,1,61,1,61,3,61,1203,8,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,3,62,1222,8,62,1,63, - 1,63,1,63,5,63,1227,8,63,10,63,12,63,1230,9,63,3,63,1232,8,63,1,64,1,64, - 1,64,1,64,1,64,1,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,1251,8,64,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, + 1,63,1,63,1,63,1,63,1,63,5,63,1230,8,63,10,63,12,63,1233,9,63,3,63,1235, + 8,63,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,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,1259,8,64,1,65,1,65, + 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, + 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, - 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,3,65,1345, - 8,65,1,66,1,66,1,66,1,66,1,66,1,66,1,66,3,66,1354,8,66,1,67,1,67,1,67, - 5,67,1359,8,67,10,67,12,67,1362,9,67,3,67,1364,8,67,1,68,1,68,1,69,1,69, - 1,69,1,69,1,69,5,69,1373,8,69,10,69,12,69,1376,9,69,1,70,1,70,1,70,1,70, + 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, + 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, + 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, + 1,65,1,65,1,65,3,65,1406,8,65,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66, + 3,66,1416,8,66,1,67,1,67,1,67,1,67,1,67,5,67,1423,8,67,10,67,12,67,1426, + 9,67,3,67,1428,8,67,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, + 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, + 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, + 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, + 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, + 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, + 3,68,1510,8,68,1,69,1,69,1,69,1,69,1,69,5,69,1517,8,69,10,69,12,69,1520, + 9,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,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,1,70,1,70,1,70,1,70,1,70,1,70,1,70,1,70,3,70,1407,8,70, - 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, + 1,70,1,70,3,70,1551,8,70,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, - 1,71,1,71,3,71,1467,8,71,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72, + 1,71,1,71,1,71,1,71,1,71,1,71,1,71,3,71,1611,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,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,1,72,1,72, - 1,72,3,72,1507,8,72,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73, - 1,73,1,73,1,73,1,73,3,73,1523,8,73,1,74,1,74,1,74,1,74,1,75,1,75,1,75, - 1,75,3,75,1533,8,75,1,75,1,75,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76, + 1,72,1,72,1,72,1,72,1,72,1,72,3,72,1651,8,72,1,73,1,73,1,73,1,73,1,73, + 1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,3,73,1667,8,73,1,74,1,74, + 1,74,1,74,1,75,1,75,1,75,1,75,3,75,1677,8,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,3,76,1560,8,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,1584, - 8,76,1,77,1,77,1,77,1,77,5,77,1590,8,77,10,77,12,77,1593,9,77,1,77,3,77, - 1596,8,77,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78, - 1,78,3,78,1611,8,78,1,79,1,79,1,79,5,79,1616,8,79,10,79,12,79,1619,9,79, - 1,79,1,79,1,80,1,80,1,80,1,80,1,81,1,81,1,82,1,82,1,82,1,82,1,82,1,82, + 1,76,1,76,1,76,1,76,1,76,1,76,3,76,1704,8,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,1728,8,76,1,77,1,77,1,77,1,77,5,77,1734,8,77,10,77, + 12,77,1737,9,77,1,77,3,77,1740,8,77,1,78,1,78,1,78,1,78,1,78,1,78,1,78, + 1,78,1,78,1,78,1,78,1,78,1,78,3,78,1755,8,78,1,79,1,79,1,79,5,79,1760, + 8,79,10,79,12,79,1763,9,79,1,79,1,79,1,80,1,80,1,80,1,80,1,81,1,81,1,82, 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, - 3,82,1663,8,82,1,83,1,83,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1673,8,84, - 1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84, - 1,84,1,84,3,84,1691,8,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84, - 1,84,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1709,8,84,1,85,1,85,1,85,1,85, - 1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,3,85, - 1728,8,85,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86, - 1,86,1,86,1,86,1,86,1,86,1,86,1,86,3,86,1749,8,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,88,1,88,1,88,1,88,1,88,3,88, - 1768,8,88,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89, - 1,89,3,89,1783,8,89,1,90,1,90,1,90,5,90,1788,8,90,10,90,12,90,1791,9,90, - 1,90,1,90,1,91,1,91,1,91,1,91,1,91,3,91,1800,8,91,1,92,1,92,1,92,1,92, - 1,92,1,92,1,92,1,92,1,92,1,92,1,92,3,92,1813,8,92,1,93,5,93,1816,8,93, - 10,93,12,93,1819,9,93,1,94,1,94,3,94,1823,8,94,1,94,1,94,1,95,1,95,1,95, - 5,95,1830,8,95,10,95,12,95,1833,9,95,1,95,1,95,1,96,1,96,1,96,1,96,1,97, - 3,97,1842,8,97,1,97,1,97,1,98,1,98,1,98,1,98,1,98,1,98,1,98,1,99,1,99, - 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, + 1,82,1,82,1,82,1,82,1,82,3,82,1807,8,82,1,83,1,83,1,84,1,84,1,84,1,84, + 1,84,1,84,3,84,1817,8,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84, + 1,84,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1835,8,84,1,84,1,84,1,84,1,84, + 1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1853, + 8,84,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85, + 1,85,1,85,1,85,1,85,3,85,1872,8,85,1,86,1,86,1,86,1,86,1,86,1,86,1,86, + 1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,3,86,1893, + 8,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,88, + 1,88,1,88,1,88,1,88,3,88,1912,8,88,1,89,1,89,1,89,1,89,1,89,1,89,1,89, + 1,89,1,89,1,89,1,89,1,89,1,89,3,89,1927,8,89,1,90,1,90,1,90,5,90,1932, + 8,90,10,90,12,90,1935,9,90,1,90,1,90,1,91,1,91,1,91,1,91,1,91,3,91,1944, + 8,91,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,3,92,1957, + 8,92,1,93,5,93,1960,8,93,10,93,12,93,1963,9,93,1,94,1,94,3,94,1967,8,94, + 1,94,1,94,1,95,1,95,1,95,5,95,1974,8,95,10,95,12,95,1977,9,95,1,95,1,95, + 1,96,1,96,1,96,1,96,1,97,3,97,1986,8,97,1,97,1,97,1,98,1,98,1,98,1,98, + 1,98,1,98,1,98,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, - 1,99,5,99,1926,8,99,10,99,12,99,1929,9,99,1,99,1,99,1,99,1,99,5,99,1935, - 8,99,10,99,12,99,1938,9,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99, - 1948,8,99,10,99,12,99,1951,9,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,1959, - 8,99,10,99,12,99,1962,9,99,1,99,1,99,1,99,1,99,1,99,3,99,1969,8,99,1,100, - 1,100,1,100,1,100,1,100,1,100,1,100,1,100,5,100,1979,8,100,10,100,12,100, - 1982,9,100,1,100,1,100,1,100,1,100,1,100,1,101,1,101,1,101,1,101,1,101, + 1,99,1,99,1,99,1,99,1,99,1,99,5,99,2070,8,99,10,99,12,99,2073,9,99,1,99, + 1,99,1,99,1,99,5,99,2079,8,99,10,99,12,99,2082,9,99,1,99,1,99,1,99,1,99, + 1,99,1,99,1,99,1,99,5,99,2092,8,99,10,99,12,99,2095,9,99,1,99,1,99,1,99, + 1,99,1,99,1,99,5,99,2103,8,99,10,99,12,99,2106,9,99,1,99,1,99,1,99,1,99, + 1,99,3,99,2113,8,99,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,5, + 100,2123,8,100,10,100,12,100,2126,9,100,1,100,1,100,1,100,1,100,1,100, 1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101, - 1,101,1,101,3,101,2008,8,101,1,102,1,102,1,102,1,102,1,102,3,102,2015, - 8,102,1,103,1,103,1,103,3,103,2020,8,103,1,104,1,104,1,104,1,104,1,104, - 3,104,2027,8,104,1,105,1,105,5,105,2031,8,105,10,105,12,105,2034,9,105, - 1,105,1,105,1,105,1,105,1,105,5,105,2041,8,105,10,105,12,105,2044,9,105, - 1,105,3,105,2047,8,105,1,106,1,106,1,107,5,107,2052,8,107,10,107,12,107, - 2055,9,107,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108, - 1,108,1,108,3,108,2069,8,108,1,109,1,109,5,109,2073,8,109,10,109,12,109, - 2076,9,109,1,109,1,109,1,109,1,109,1,109,1,109,1,110,1,110,1,111,5,111, - 2087,8,111,10,111,12,111,2090,9,111,1,112,1,112,1,112,1,112,1,112,1,112, - 1,112,1,112,1,112,1,112,3,112,2102,8,112,1,113,1,113,1,113,1,113,1,113, - 1,113,3,113,2110,8,113,1,114,1,114,1,114,4,114,2115,8,114,11,114,12,114, - 2116,1,114,1,114,3,114,2121,8,114,1,115,1,115,1,115,5,115,2126,8,115,10, - 115,12,115,2129,9,115,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116, - 1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,3,116,2148,8,116, - 1,117,1,117,1,117,5,117,2153,8,117,10,117,12,117,2156,9,117,1,117,1,117, - 1,117,1,117,1,117,1,117,1,117,1,117,5,117,2166,8,117,10,117,12,117,2169, - 9,117,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, + 1,101,1,101,1,101,1,101,1,101,1,101,1,101,3,101,2152,8,101,1,102,1,102, + 1,102,1,102,1,102,3,102,2159,8,102,1,103,1,103,1,103,3,103,2164,8,103, + 1,104,1,104,1,104,1,104,1,104,3,104,2171,8,104,1,105,1,105,5,105,2175, + 8,105,10,105,12,105,2178,9,105,1,105,1,105,1,105,1,105,1,105,5,105,2185, + 8,105,10,105,12,105,2188,9,105,1,105,3,105,2191,8,105,1,106,1,106,1,107, + 5,107,2196,8,107,10,107,12,107,2199,9,107,1,108,1,108,1,108,1,108,1,108, + 1,108,1,108,1,108,1,108,1,108,1,108,1,108,3,108,2213,8,108,1,109,1,109, + 5,109,2217,8,109,10,109,12,109,2220,9,109,1,109,1,109,1,109,1,109,1,109, + 1,109,1,110,1,110,1,111,5,111,2231,8,111,10,111,12,111,2234,9,111,1,112, + 1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,3,112,2246,8,112, + 1,113,1,113,1,113,1,113,1,113,1,113,1,113,3,113,2255,8,113,1,114,1,114, + 1,114,1,114,1,114,1,114,1,114,4,114,2264,8,114,11,114,12,114,2265,1,114, + 1,114,3,114,2270,8,114,1,115,1,115,1,115,5,115,2275,8,115,10,115,12,115, + 2278,9,115,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116, + 1,116,1,116,1,116,1,116,1,116,1,116,1,116,3,116,2297,8,116,1,117,1,117, + 1,117,5,117,2302,8,117,10,117,12,117,2305,9,117,1,117,1,117,1,117,1,117, + 1,117,1,117,1,117,1,117,5,117,2315,8,117,10,117,12,117,2318,9,117,1,118, 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, - 3,118,2194,8,118,1,119,1,119,1,119,1,119,1,119,3,119,2201,8,119,3,119, - 2203,8,119,1,119,5,119,2206,8,119,10,119,12,119,2209,9,119,1,119,1,119, - 1,119,3,119,2214,8,119,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, + 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,3,118,2343, + 8,118,1,119,1,119,1,119,1,119,1,119,3,119,2350,8,119,3,119,2352,8,119, + 1,119,5,119,2355,8,119,10,119,12,119,2358,9,119,1,119,1,119,1,119,3,119, + 2363,8,119,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, - 1,120,1,120,1,120,1,120,1,120,1,120,1,120,3,120,2243,8,120,1,121,1,121, - 1,121,1,121,1,121,1,121,1,121,3,121,2252,8,121,1,122,1,122,1,122,1,122, + 1,120,1,120,1,120,1,120,1,120,3,120,2392,8,120,1,121,1,121,1,121,1,121, + 1,121,1,121,1,121,3,121,2401,8,121,1,122,1,122,1,122,1,122,1,122,1,122, 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, - 1,122,1,122,1,122,1,122,1,122,3,122,2275,8,122,1,123,5,123,2278,8,123, - 10,123,12,123,2281,9,123,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, - 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,3,124,2300,8,124, + 1,122,1,122,1,122,3,122,2424,8,122,1,123,5,123,2427,8,123,10,123,12,123, + 2430,9,123,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, + 1,124,1,124,1,124,1,124,1,124,1,124,1,124,3,124,2449,8,124,1,125,1,125, 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, - 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, - 1,125,5,125,2351,8,125,10,125,12,125,2354,9,125,1,125,1,125,1,125,1,125, - 5,125,2360,8,125,10,125,12,125,2363,9,125,1,125,1,125,1,125,1,125,1,125, - 1,125,1,125,1,125,5,125,2373,8,125,10,125,12,125,2376,9,125,1,125,1,125, - 1,125,1,125,1,125,1,125,5,125,2384,8,125,10,125,12,125,2387,9,125,1,125, - 1,125,1,125,1,125,1,125,1,125,5,125,2395,8,125,10,125,12,125,2398,9,125, - 3,125,2400,8,125,1,126,1,126,1,126,1,126,1,127,1,127,3,127,2408,8,127, - 1,128,1,128,1,128,1,128,1,129,1,129,1,129,1,130,4,130,2418,8,130,11,130, - 12,130,2419,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131, - 1,131,1,131,3,131,2434,8,131,1,132,1,132,1,132,1,132,1,132,1,132,1,132, - 1,132,1,132,1,132,1,132,1,132,3,132,2448,8,132,1,133,1,133,1,133,1,133, - 1,133,1,133,3,133,2456,8,133,1,134,1,134,1,134,1,135,1,135,1,136,1,136, - 1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,3,137, - 2476,8,137,1,138,1,138,1,138,1,139,1,139,1,139,1,139,1,139,1,139,1,139, - 3,139,2488,8,139,1,140,1,140,1,140,3,140,2493,8,140,1,141,1,141,1,141, - 1,141,1,141,4,141,2500,8,141,11,141,12,141,2501,3,141,2504,8,141,1,142, - 1,142,1,142,5,142,2509,8,142,10,142,12,142,2512,9,142,1,142,1,142,1,143, - 1,143,1,143,1,143,1,143,3,143,2521,8,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,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,5,125, + 2500,8,125,10,125,12,125,2503,9,125,1,125,1,125,1,125,1,125,5,125,2509, + 8,125,10,125,12,125,2512,9,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, + 1,125,5,125,2522,8,125,10,125,12,125,2525,9,125,1,125,1,125,1,125,1,125, + 1,125,1,125,5,125,2533,8,125,10,125,12,125,2536,9,125,1,125,1,125,1,125, + 1,125,1,125,1,125,5,125,2544,8,125,10,125,12,125,2547,9,125,3,125,2549, + 8,125,1,126,1,126,1,126,1,126,1,127,1,127,3,127,2557,8,127,1,128,1,128, + 1,128,1,128,1,129,1,129,1,129,1,130,4,130,2567,8,130,11,130,12,130,2568, + 1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131, + 3,131,2583,8,131,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132, + 1,132,1,132,1,132,3,132,2597,8,132,1,133,1,133,1,133,1,133,1,133,1,133, + 3,133,2605,8,133,1,134,1,134,1,134,1,135,1,135,1,136,1,136,1,137,1,137, + 1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,3,137,2625,8,137, + 1,138,1,138,1,138,1,139,1,139,1,139,1,139,1,139,1,139,1,139,3,139,2637, + 8,139,1,140,1,140,1,140,3,140,2642,8,140,1,141,1,141,1,141,1,141,1,141, + 4,141,2649,8,141,11,141,12,141,2650,3,141,2653,8,141,1,142,1,142,1,142, + 5,142,2658,8,142,10,142,12,142,2661,9,142,1,142,1,142,1,143,1,143,1,143, + 1,143,1,143,3,143,2670,8,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,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,1,144,1,144,1,144,1,144,1,144,1,144,1,144, - 1,144,3,144,2589,8,144,1,145,1,145,1,145,1,145,1,145,1,145,1,145,1,145, + 1,144,1,144,1,144,1,144,1,144,1,144,1,144,1,144,1,144,1,144,1,144,3,144, + 2738,8,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,145,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,145,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,145,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,145,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,145,1,145,1,145,1,145,1,145,1,145, - 1,145,1,145,1,145,1,145,1,145,1,145,1,145,3,145,2666,8,145,1,146,1,146, - 1,146,5,146,2671,8,146,10,146,12,146,2674,9,146,1,147,1,147,1,148,1,148, - 1,148,3,148,2681,8,148,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, + 1,145,1,145,1,145,1,145,1,145,3,145,2815,8,145,1,146,1,146,1,146,5,146, + 2820,8,146,10,146,12,146,2823,9,146,1,147,1,147,1,148,1,148,1,148,3,148, + 2830,8,148,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, @@ -17375,959 +17800,1009 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, - 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,3,149,2831,8,149,1,150, - 1,150,5,150,2835,8,150,10,150,12,150,2838,9,150,1,151,1,151,5,151,2842, - 8,151,10,151,12,151,2845,9,151,1,152,5,152,2848,8,152,10,152,12,152,2851, - 9,152,1,153,5,153,2854,8,153,10,153,12,153,2857,9,153,1,154,5,154,2860, - 8,154,10,154,12,154,2863,9,154,1,155,5,155,2866,8,155,10,155,12,155,2869, - 9,155,1,156,5,156,2872,8,156,10,156,12,156,2875,9,156,1,157,5,157,2878, - 8,157,10,157,12,157,2881,9,157,1,158,5,158,2884,8,158,10,158,12,158,2887, - 9,158,1,159,1,159,1,159,1,159,3,159,2893,8,159,1,160,5,160,2896,8,160, - 10,160,12,160,2899,9,160,1,161,1,161,1,161,3,161,2904,8,161,1,162,1,162, + 1,149,1,149,1,149,1,149,1,149,1,149,3,149,2980,8,149,1,150,1,150,5,150, + 2984,8,150,10,150,12,150,2987,9,150,1,151,1,151,5,151,2991,8,151,10,151, + 12,151,2994,9,151,1,152,5,152,2997,8,152,10,152,12,152,3000,9,152,1,153, + 5,153,3003,8,153,10,153,12,153,3006,9,153,1,154,5,154,3009,8,154,10,154, + 12,154,3012,9,154,1,155,5,155,3015,8,155,10,155,12,155,3018,9,155,1,156, + 5,156,3021,8,156,10,156,12,156,3024,9,156,1,157,5,157,3027,8,157,10,157, + 12,157,3030,9,157,1,158,5,158,3033,8,158,10,158,12,158,3036,9,158,1,159, + 1,159,1,159,1,159,3,159,3042,8,159,1,160,5,160,3045,8,160,10,160,12,160, + 3048,9,160,1,161,1,161,1,161,3,161,3053,8,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,162,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,162,1,162,3,162, - 2931,8,162,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163, - 1,163,1,163,3,163,2945,8,163,1,164,5,164,2948,8,164,10,164,12,164,2951, - 9,164,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165, - 1,165,1,165,1,165,3,165,2967,8,165,1,166,1,166,1,166,5,166,2972,8,166, - 10,166,12,166,2975,9,166,1,166,1,166,1,167,1,167,5,167,2981,8,167,10,167, - 12,167,2984,9,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,168,1,168,1,168,1,168,3,168,3003,8,168,1,169, - 5,169,3006,8,169,10,169,12,169,3009,9,169,1,170,1,170,1,170,1,170,1,170, - 1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,3,170,3024,8,170,1,171, - 1,171,5,171,3028,8,171,10,171,12,171,3031,9,171,1,171,1,171,1,171,5,171, - 3036,8,171,10,171,12,171,3039,9,171,1,171,1,171,1,171,1,171,3,171,3045, - 8,171,1,172,1,172,1,173,5,173,3050,8,173,10,173,12,173,3053,9,173,1,174, - 1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,174,3,174,3065,8,174, - 1,174,0,1,68,175,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,0,16,6,0,1,15,199,199,243,243,247,247,264,264,289,289, - 5,0,16,16,199,199,243,243,264,264,288,289,1,0,263,264,1,0,173,174,1,0, - 37,38,1,0,73,74,3,0,2,2,61,61,77,83,2,0,229,229,260,261,9,0,178,178,183, - 195,201,201,207,208,210,215,218,219,222,222,230,242,262,262,1,0,95,96, - 1,0,97,111,1,0,68,69,2,0,173,173,289,290,2,0,179,179,264,264,1,0,167,168, - 1,0,51,52,3494,0,350,1,0,0,0,2,368,1,0,0,0,4,370,1,0,0,0,6,377,1,0,0,0, - 8,386,1,0,0,0,10,439,1,0,0,0,12,441,1,0,0,0,14,444,1,0,0,0,16,447,1,0, - 0,0,18,451,1,0,0,0,20,454,1,0,0,0,22,457,1,0,0,0,24,464,1,0,0,0,26,480, - 1,0,0,0,28,482,1,0,0,0,30,484,1,0,0,0,32,494,1,0,0,0,34,496,1,0,0,0,36, - 519,1,0,0,0,38,523,1,0,0,0,40,541,1,0,0,0,42,568,1,0,0,0,44,591,1,0,0, - 0,46,627,1,0,0,0,48,629,1,0,0,0,50,637,1,0,0,0,52,639,1,0,0,0,54,646,1, - 0,0,0,56,658,1,0,0,0,58,661,1,0,0,0,60,663,1,0,0,0,62,676,1,0,0,0,64,684, - 1,0,0,0,66,686,1,0,0,0,68,694,1,0,0,0,70,710,1,0,0,0,72,716,1,0,0,0,74, - 719,1,0,0,0,76,768,1,0,0,0,78,773,1,0,0,0,80,778,1,0,0,0,82,783,1,0,0, - 0,84,791,1,0,0,0,86,796,1,0,0,0,88,901,1,0,0,0,90,929,1,0,0,0,92,931,1, - 0,0,0,94,935,1,0,0,0,96,937,1,0,0,0,98,942,1,0,0,0,100,970,1,0,0,0,102, - 1050,1,0,0,0,104,1052,1,0,0,0,106,1081,1,0,0,0,108,1083,1,0,0,0,110,1097, - 1,0,0,0,112,1126,1,0,0,0,114,1138,1,0,0,0,116,1177,1,0,0,0,118,1185,1, - 0,0,0,120,1194,1,0,0,0,122,1202,1,0,0,0,124,1221,1,0,0,0,126,1231,1,0, - 0,0,128,1250,1,0,0,0,130,1344,1,0,0,0,132,1353,1,0,0,0,134,1363,1,0,0, - 0,136,1365,1,0,0,0,138,1367,1,0,0,0,140,1406,1,0,0,0,142,1466,1,0,0,0, - 144,1506,1,0,0,0,146,1522,1,0,0,0,148,1524,1,0,0,0,150,1528,1,0,0,0,152, - 1583,1,0,0,0,154,1595,1,0,0,0,156,1610,1,0,0,0,158,1617,1,0,0,0,160,1622, - 1,0,0,0,162,1626,1,0,0,0,164,1662,1,0,0,0,166,1664,1,0,0,0,168,1708,1, - 0,0,0,170,1727,1,0,0,0,172,1748,1,0,0,0,174,1750,1,0,0,0,176,1767,1,0, - 0,0,178,1782,1,0,0,0,180,1789,1,0,0,0,182,1799,1,0,0,0,184,1812,1,0,0, - 0,186,1817,1,0,0,0,188,1820,1,0,0,0,190,1831,1,0,0,0,192,1836,1,0,0,0, - 194,1841,1,0,0,0,196,1845,1,0,0,0,198,1968,1,0,0,0,200,1970,1,0,0,0,202, - 2007,1,0,0,0,204,2014,1,0,0,0,206,2019,1,0,0,0,208,2026,1,0,0,0,210,2046, - 1,0,0,0,212,2048,1,0,0,0,214,2053,1,0,0,0,216,2068,1,0,0,0,218,2070,1, - 0,0,0,220,2083,1,0,0,0,222,2088,1,0,0,0,224,2101,1,0,0,0,226,2109,1,0, - 0,0,228,2120,1,0,0,0,230,2127,1,0,0,0,232,2147,1,0,0,0,234,2149,1,0,0, - 0,236,2193,1,0,0,0,238,2213,1,0,0,0,240,2242,1,0,0,0,242,2251,1,0,0,0, - 244,2274,1,0,0,0,246,2279,1,0,0,0,248,2299,1,0,0,0,250,2399,1,0,0,0,252, - 2401,1,0,0,0,254,2407,1,0,0,0,256,2409,1,0,0,0,258,2413,1,0,0,0,260,2417, - 1,0,0,0,262,2433,1,0,0,0,264,2447,1,0,0,0,266,2455,1,0,0,0,268,2457,1, - 0,0,0,270,2460,1,0,0,0,272,2462,1,0,0,0,274,2475,1,0,0,0,276,2477,1,0, - 0,0,278,2487,1,0,0,0,280,2492,1,0,0,0,282,2503,1,0,0,0,284,2510,1,0,0, - 0,286,2520,1,0,0,0,288,2588,1,0,0,0,290,2665,1,0,0,0,292,2672,1,0,0,0, - 294,2675,1,0,0,0,296,2680,1,0,0,0,298,2830,1,0,0,0,300,2836,1,0,0,0,302, - 2843,1,0,0,0,304,2849,1,0,0,0,306,2855,1,0,0,0,308,2861,1,0,0,0,310,2867, - 1,0,0,0,312,2873,1,0,0,0,314,2879,1,0,0,0,316,2885,1,0,0,0,318,2892,1, - 0,0,0,320,2897,1,0,0,0,322,2903,1,0,0,0,324,2930,1,0,0,0,326,2944,1,0, - 0,0,328,2949,1,0,0,0,330,2966,1,0,0,0,332,2968,1,0,0,0,334,2978,1,0,0, - 0,336,3002,1,0,0,0,338,3007,1,0,0,0,340,3023,1,0,0,0,342,3044,1,0,0,0, - 344,3046,1,0,0,0,346,3051,1,0,0,0,348,3064,1,0,0,0,350,351,7,0,0,0,351, - 1,1,0,0,0,352,353,5,288,0,0,353,369,6,1,-1,0,354,355,3,4,2,0,355,356,6, - 1,-1,0,356,357,5,265,0,0,357,359,1,0,0,0,358,354,1,0,0,0,359,362,1,0,0, - 0,360,358,1,0,0,0,360,361,1,0,0,0,361,363,1,0,0,0,362,360,1,0,0,0,363, - 364,3,4,2,0,364,365,6,1,-1,0,365,369,1,0,0,0,366,367,5,264,0,0,367,369, - 6,1,-1,0,368,352,1,0,0,0,368,360,1,0,0,0,368,366,1,0,0,0,369,3,1,0,0,0, - 370,371,7,1,0,0,371,5,1,0,0,0,372,373,5,263,0,0,373,374,6,3,-1,0,374,376, - 5,266,0,0,375,372,1,0,0,0,376,379,1,0,0,0,377,375,1,0,0,0,377,378,1,0, - 0,0,378,380,1,0,0,0,379,377,1,0,0,0,380,381,5,263,0,0,381,382,6,3,-1,0, - 382,7,1,0,0,0,383,385,3,10,5,0,384,383,1,0,0,0,385,388,1,0,0,0,386,384, - 1,0,0,0,386,387,1,0,0,0,387,9,1,0,0,0,388,386,1,0,0,0,389,390,3,74,37, - 0,390,391,5,17,0,0,391,392,3,82,41,0,392,393,5,18,0,0,393,440,1,0,0,0, - 394,395,3,72,36,0,395,396,5,17,0,0,396,397,3,8,4,0,397,398,5,18,0,0,398, - 440,1,0,0,0,399,400,3,234,117,0,400,401,5,17,0,0,401,402,3,246,123,0,402, - 403,5,18,0,0,403,440,1,0,0,0,404,440,3,200,100,0,405,440,3,276,138,0,406, - 440,3,70,35,0,407,440,3,66,33,0,408,440,3,88,44,0,409,440,3,90,45,0,410, - 440,3,22,11,0,411,412,3,326,163,0,412,413,5,17,0,0,413,414,3,328,164,0, - 414,415,5,18,0,0,415,440,1,0,0,0,416,417,3,332,166,0,417,418,5,17,0,0, - 418,419,3,338,169,0,419,420,5,18,0,0,420,440,1,0,0,0,421,422,3,342,171, - 0,422,423,5,17,0,0,423,424,3,346,173,0,424,425,5,18,0,0,425,440,1,0,0, - 0,426,440,3,64,32,0,427,440,3,152,76,0,428,440,3,322,161,0,429,440,3,12, - 6,0,430,440,3,14,7,0,431,440,3,16,8,0,432,440,3,18,9,0,433,440,3,20,10, - 0,434,440,3,26,13,0,435,440,3,42,21,0,436,440,3,40,20,0,437,440,3,30,15, - 0,438,440,3,24,12,0,439,389,1,0,0,0,439,394,1,0,0,0,439,399,1,0,0,0,439, - 404,1,0,0,0,439,405,1,0,0,0,439,406,1,0,0,0,439,407,1,0,0,0,439,408,1, - 0,0,0,439,409,1,0,0,0,439,410,1,0,0,0,439,411,1,0,0,0,439,416,1,0,0,0, - 439,421,1,0,0,0,439,426,1,0,0,0,439,427,1,0,0,0,439,428,1,0,0,0,439,429, - 1,0,0,0,439,430,1,0,0,0,439,431,1,0,0,0,439,432,1,0,0,0,439,433,1,0,0, - 0,439,434,1,0,0,0,439,435,1,0,0,0,439,436,1,0,0,0,439,437,1,0,0,0,439, - 438,1,0,0,0,440,11,1,0,0,0,441,442,5,19,0,0,442,443,3,32,16,0,443,13,1, - 0,0,0,444,445,5,20,0,0,445,446,3,32,16,0,446,15,1,0,0,0,447,448,5,21,0, - 0,448,449,5,22,0,0,449,450,3,32,16,0,450,17,1,0,0,0,451,452,5,23,0,0,452, - 453,3,34,17,0,453,19,1,0,0,0,454,455,5,24,0,0,455,456,3,34,17,0,456,21, - 1,0,0,0,457,458,5,25,0,0,458,459,3,98,49,0,459,460,3,2,1,0,460,461,5,17, - 0,0,461,462,3,120,60,0,462,463,5,18,0,0,463,23,1,0,0,0,464,465,5,26,0, - 0,465,25,1,0,0,0,466,467,5,27,0,0,467,481,3,28,14,0,468,469,5,27,0,0,469, - 470,3,28,14,0,470,471,5,28,0,0,471,472,3,28,14,0,472,481,1,0,0,0,473,474, - 5,27,0,0,474,475,3,28,14,0,475,476,5,28,0,0,476,477,3,28,14,0,477,478, - 5,28,0,0,478,479,3,28,14,0,479,481,1,0,0,0,480,466,1,0,0,0,480,468,1,0, - 0,0,480,473,1,0,0,0,481,27,1,0,0,0,482,483,7,2,0,0,483,29,1,0,0,0,484, - 485,5,29,0,0,485,489,5,17,0,0,486,488,3,116,58,0,487,486,1,0,0,0,488,491, - 1,0,0,0,489,487,1,0,0,0,489,490,1,0,0,0,490,492,1,0,0,0,491,489,1,0,0, - 0,492,493,5,18,0,0,493,31,1,0,0,0,494,495,5,173,0,0,495,33,1,0,0,0,496, - 497,7,3,0,0,497,35,1,0,0,0,498,499,5,175,0,0,499,520,6,18,-1,0,500,501, - 3,32,16,0,501,502,5,265,0,0,502,503,6,18,-1,0,503,520,1,0,0,0,504,505, - 3,32,16,0,505,506,6,18,-1,0,506,520,1,0,0,0,507,508,5,188,0,0,508,509, - 5,30,0,0,509,510,3,32,16,0,510,511,5,31,0,0,511,512,6,18,-1,0,512,520, - 1,0,0,0,513,514,5,189,0,0,514,515,5,30,0,0,515,516,3,34,17,0,516,517,5, - 31,0,0,517,518,6,18,-1,0,518,520,1,0,0,0,519,498,1,0,0,0,519,500,1,0,0, - 0,519,504,1,0,0,0,519,507,1,0,0,0,519,513,1,0,0,0,520,37,1,0,0,0,521,524, - 3,32,16,0,522,524,5,262,0,0,523,521,1,0,0,0,523,522,1,0,0,0,524,39,1,0, - 0,0,525,526,5,267,0,0,526,542,5,289,0,0,527,528,5,267,0,0,528,529,5,289, - 0,0,529,542,5,263,0,0,530,531,5,268,0,0,531,542,5,289,0,0,532,533,5,269, - 0,0,533,542,5,289,0,0,534,535,5,270,0,0,535,542,5,289,0,0,536,542,5,271, - 0,0,537,542,5,272,0,0,538,539,5,273,0,0,539,542,5,263,0,0,540,542,5,32, - 0,0,541,525,1,0,0,0,541,527,1,0,0,0,541,530,1,0,0,0,541,532,1,0,0,0,541, - 534,1,0,0,0,541,536,1,0,0,0,541,537,1,0,0,0,541,538,1,0,0,0,541,540,1, - 0,0,0,542,41,1,0,0,0,543,544,5,33,0,0,544,545,3,138,69,0,545,546,5,34, - 0,0,546,547,3,2,1,0,547,569,1,0,0,0,548,549,5,33,0,0,549,550,3,116,58, - 0,550,551,5,34,0,0,551,552,3,2,1,0,552,569,1,0,0,0,553,554,5,33,0,0,554, - 555,3,176,88,0,555,556,5,34,0,0,556,557,3,2,1,0,557,569,1,0,0,0,558,559, - 5,33,0,0,559,560,3,44,22,0,560,561,5,34,0,0,561,562,3,2,1,0,562,569,1, - 0,0,0,563,564,5,33,0,0,564,565,3,46,23,0,565,566,5,34,0,0,566,567,3,2, - 1,0,567,569,1,0,0,0,568,543,1,0,0,0,568,548,1,0,0,0,568,553,1,0,0,0,568, - 558,1,0,0,0,568,563,1,0,0,0,569,43,1,0,0,0,570,571,5,35,0,0,571,592,3, - 48,24,0,572,573,5,35,0,0,573,574,3,48,24,0,574,575,5,36,0,0,575,576,3, - 6,3,0,576,592,1,0,0,0,577,578,5,35,0,0,578,579,3,48,24,0,579,580,5,36, - 0,0,580,581,5,17,0,0,581,582,3,52,26,0,582,583,5,18,0,0,583,592,1,0,0, - 0,584,585,5,35,0,0,585,586,3,48,24,0,586,587,5,36,0,0,587,588,5,30,0,0, - 588,589,3,292,146,0,589,590,5,31,0,0,590,592,1,0,0,0,591,570,1,0,0,0,591, - 572,1,0,0,0,591,577,1,0,0,0,591,584,1,0,0,0,592,45,1,0,0,0,593,594,5,35, - 0,0,594,595,5,30,0,0,595,596,3,50,25,0,596,597,5,31,0,0,597,598,3,48,24, - 0,598,628,1,0,0,0,599,600,5,35,0,0,600,601,5,30,0,0,601,602,3,50,25,0, - 602,603,5,31,0,0,603,604,3,48,24,0,604,605,5,36,0,0,605,606,3,6,3,0,606, - 628,1,0,0,0,607,608,5,35,0,0,608,609,5,30,0,0,609,610,3,50,25,0,610,611, - 5,31,0,0,611,612,3,48,24,0,612,613,5,36,0,0,613,614,5,17,0,0,614,615,3, - 52,26,0,615,616,5,18,0,0,616,628,1,0,0,0,617,618,5,35,0,0,618,619,5,30, - 0,0,619,620,3,50,25,0,620,621,5,31,0,0,621,622,3,48,24,0,622,623,5,36, - 0,0,623,624,5,30,0,0,624,625,3,292,146,0,625,626,5,31,0,0,626,628,1,0, - 0,0,627,593,1,0,0,0,627,599,1,0,0,0,627,607,1,0,0,0,627,617,1,0,0,0,628, - 47,1,0,0,0,629,630,3,168,84,0,630,49,1,0,0,0,631,632,3,124,62,0,632,633, - 6,25,-1,0,633,638,1,0,0,0,634,635,3,176,88,0,635,636,6,25,-1,0,636,638, - 1,0,0,0,637,631,1,0,0,0,637,634,1,0,0,0,638,51,1,0,0,0,639,640,3,54,27, - 0,640,641,3,56,28,0,641,53,1,0,0,0,642,645,3,298,149,0,643,645,3,40,20, - 0,644,642,1,0,0,0,644,643,1,0,0,0,645,648,1,0,0,0,646,644,1,0,0,0,646, - 647,1,0,0,0,647,55,1,0,0,0,648,646,1,0,0,0,649,650,3,58,29,0,650,651,3, - 60,30,0,651,652,3,2,1,0,652,653,5,36,0,0,653,654,3,298,149,0,654,657,1, - 0,0,0,655,657,3,40,20,0,656,649,1,0,0,0,656,655,1,0,0,0,657,660,1,0,0, - 0,658,656,1,0,0,0,658,659,1,0,0,0,659,57,1,0,0,0,660,658,1,0,0,0,661,662, - 7,4,0,0,662,59,1,0,0,0,663,665,3,62,31,0,664,666,5,261,0,0,665,664,1,0, - 0,0,665,666,1,0,0,0,666,61,1,0,0,0,667,677,3,144,72,0,668,677,3,2,1,0, - 669,677,5,196,0,0,670,677,5,197,0,0,671,672,5,202,0,0,672,673,5,39,0,0, - 673,677,5,264,0,0,674,675,5,202,0,0,675,677,3,116,58,0,676,667,1,0,0,0, - 676,668,1,0,0,0,676,669,1,0,0,0,676,670,1,0,0,0,676,671,1,0,0,0,676,674, - 1,0,0,0,677,63,1,0,0,0,678,679,5,198,0,0,679,680,5,40,0,0,680,685,3,2, - 1,0,681,682,5,198,0,0,682,685,3,2,1,0,683,685,5,198,0,0,684,678,1,0,0, - 0,684,681,1,0,0,0,684,683,1,0,0,0,685,65,1,0,0,0,686,687,5,41,0,0,687, - 688,5,42,0,0,688,689,3,32,16,0,689,690,5,43,0,0,690,691,3,68,34,0,691, - 692,5,44,0,0,692,693,3,0,0,0,693,67,1,0,0,0,694,707,6,34,-1,0,695,696, - 10,5,0,0,696,706,5,186,0,0,697,698,10,4,0,0,698,706,5,187,0,0,699,700, - 10,3,0,0,700,706,5,45,0,0,701,702,10,2,0,0,702,706,5,46,0,0,703,704,10, - 1,0,0,704,706,5,47,0,0,705,695,1,0,0,0,705,697,1,0,0,0,705,699,1,0,0,0, - 705,701,1,0,0,0,705,703,1,0,0,0,706,709,1,0,0,0,707,705,1,0,0,0,707,708, - 1,0,0,0,708,69,1,0,0,0,709,707,1,0,0,0,710,711,5,48,0,0,711,712,5,36,0, - 0,712,713,5,30,0,0,713,714,3,292,146,0,714,715,5,31,0,0,715,71,1,0,0,0, - 716,717,5,49,0,0,717,718,3,2,1,0,718,73,1,0,0,0,719,723,5,50,0,0,720,722, - 3,76,38,0,721,720,1,0,0,0,722,725,1,0,0,0,723,721,1,0,0,0,723,724,1,0, - 0,0,724,726,1,0,0,0,725,723,1,0,0,0,726,727,3,2,1,0,727,728,3,182,91,0, - 728,729,3,78,39,0,729,730,3,80,40,0,730,75,1,0,0,0,731,769,5,51,0,0,732, - 769,5,52,0,0,733,769,5,199,0,0,734,769,5,202,0,0,735,769,5,221,0,0,736, - 769,5,53,0,0,737,769,5,54,0,0,738,769,5,55,0,0,739,769,5,56,0,0,740,769, - 5,244,0,0,741,769,5,15,0,0,742,769,5,224,0,0,743,769,5,57,0,0,744,769, - 5,58,0,0,745,769,5,59,0,0,746,769,5,60,0,0,747,769,5,61,0,0,748,749,5, - 62,0,0,749,769,5,51,0,0,750,751,5,62,0,0,751,769,5,52,0,0,752,753,5,62, - 0,0,753,769,5,63,0,0,754,755,5,62,0,0,755,769,5,64,0,0,756,757,5,62,0, - 0,757,769,5,65,0,0,758,759,5,62,0,0,759,769,5,66,0,0,760,769,5,67,0,0, - 761,769,5,68,0,0,762,769,5,69,0,0,763,764,5,70,0,0,764,765,5,30,0,0,765, - 766,3,32,16,0,766,767,5,31,0,0,767,769,1,0,0,0,768,731,1,0,0,0,768,732, - 1,0,0,0,768,733,1,0,0,0,768,734,1,0,0,0,768,735,1,0,0,0,768,736,1,0,0, - 0,768,737,1,0,0,0,768,738,1,0,0,0,768,739,1,0,0,0,768,740,1,0,0,0,768, - 741,1,0,0,0,768,742,1,0,0,0,768,743,1,0,0,0,768,744,1,0,0,0,768,745,1, - 0,0,0,768,746,1,0,0,0,768,747,1,0,0,0,768,748,1,0,0,0,768,750,1,0,0,0, - 768,752,1,0,0,0,768,754,1,0,0,0,768,756,1,0,0,0,768,758,1,0,0,0,768,760, - 1,0,0,0,768,761,1,0,0,0,768,762,1,0,0,0,768,763,1,0,0,0,769,77,1,0,0,0, - 770,774,1,0,0,0,771,772,5,71,0,0,772,774,3,124,62,0,773,770,1,0,0,0,773, - 771,1,0,0,0,774,79,1,0,0,0,775,779,1,0,0,0,776,777,5,72,0,0,777,779,3, - 84,42,0,778,775,1,0,0,0,778,776,1,0,0,0,779,81,1,0,0,0,780,782,3,198,99, - 0,781,780,1,0,0,0,782,785,1,0,0,0,783,781,1,0,0,0,783,784,1,0,0,0,784, - 83,1,0,0,0,785,783,1,0,0,0,786,787,3,124,62,0,787,788,5,28,0,0,788,790, - 1,0,0,0,789,786,1,0,0,0,790,793,1,0,0,0,791,789,1,0,0,0,791,792,1,0,0, - 0,792,794,1,0,0,0,793,791,1,0,0,0,794,795,3,124,62,0,795,85,1,0,0,0,796, - 797,7,5,0,0,797,87,1,0,0,0,798,799,3,86,43,0,799,800,3,32,16,0,800,801, - 5,264,0,0,801,902,1,0,0,0,802,803,3,86,43,0,803,804,3,32,16,0,804,902, - 1,0,0,0,805,806,3,86,43,0,806,807,3,32,16,0,807,808,5,75,0,0,808,809,3, - 32,16,0,809,810,5,264,0,0,810,902,1,0,0,0,811,812,3,86,43,0,812,813,3, - 32,16,0,813,814,5,75,0,0,814,815,3,32,16,0,815,902,1,0,0,0,816,817,3,86, - 43,0,817,818,3,32,16,0,818,819,5,75,0,0,819,820,3,32,16,0,820,821,5,28, - 0,0,821,822,3,32,16,0,822,823,5,264,0,0,823,902,1,0,0,0,824,825,3,86,43, - 0,825,826,3,32,16,0,826,827,5,75,0,0,827,828,3,32,16,0,828,829,5,28,0, - 0,829,830,3,32,16,0,830,902,1,0,0,0,831,832,3,86,43,0,832,833,3,32,16, - 0,833,834,5,28,0,0,834,835,3,32,16,0,835,836,5,75,0,0,836,837,3,32,16, - 0,837,838,5,264,0,0,838,902,1,0,0,0,839,840,3,86,43,0,840,841,3,32,16, - 0,841,842,5,28,0,0,842,843,3,32,16,0,843,844,5,75,0,0,844,845,3,32,16, - 0,845,902,1,0,0,0,846,847,3,86,43,0,847,848,3,32,16,0,848,849,5,28,0,0, - 849,850,3,32,16,0,850,851,5,75,0,0,851,852,3,32,16,0,852,853,5,28,0,0, - 853,854,3,32,16,0,854,855,5,264,0,0,855,902,1,0,0,0,856,857,3,86,43,0, - 857,858,3,32,16,0,858,859,5,28,0,0,859,860,3,32,16,0,860,861,5,75,0,0, - 861,862,3,32,16,0,862,863,5,28,0,0,863,864,3,32,16,0,864,902,1,0,0,0,865, - 866,3,86,43,0,866,867,3,32,16,0,867,868,5,263,0,0,868,902,1,0,0,0,869, - 870,3,86,43,0,870,871,3,32,16,0,871,872,5,75,0,0,872,873,3,32,16,0,873, - 874,5,263,0,0,874,902,1,0,0,0,875,876,3,86,43,0,876,877,3,32,16,0,877, - 878,5,75,0,0,878,879,3,32,16,0,879,880,5,28,0,0,880,881,3,32,16,0,881, - 882,5,263,0,0,882,902,1,0,0,0,883,884,3,86,43,0,884,885,3,32,16,0,885, - 886,5,28,0,0,886,887,3,32,16,0,887,888,5,75,0,0,888,889,3,32,16,0,889, - 890,5,263,0,0,890,902,1,0,0,0,891,892,3,86,43,0,892,893,3,32,16,0,893, - 894,5,28,0,0,894,895,3,32,16,0,895,896,5,75,0,0,896,897,3,32,16,0,897, - 898,5,28,0,0,898,899,3,32,16,0,899,900,5,263,0,0,900,902,1,0,0,0,901,798, - 1,0,0,0,901,802,1,0,0,0,901,805,1,0,0,0,901,811,1,0,0,0,901,816,1,0,0, - 0,901,824,1,0,0,0,901,831,1,0,0,0,901,839,1,0,0,0,901,846,1,0,0,0,901, - 856,1,0,0,0,901,865,1,0,0,0,901,869,1,0,0,0,901,875,1,0,0,0,901,883,1, - 0,0,0,901,891,1,0,0,0,902,89,1,0,0,0,903,907,5,21,0,0,904,906,3,92,46, - 0,905,904,1,0,0,0,906,909,1,0,0,0,907,905,1,0,0,0,907,908,1,0,0,0,908, - 910,1,0,0,0,909,907,1,0,0,0,910,911,3,2,1,0,911,912,3,94,47,0,912,913, - 5,180,0,0,913,914,5,36,0,0,914,915,5,30,0,0,915,916,3,292,146,0,916,917, - 5,31,0,0,917,918,3,94,47,0,918,930,1,0,0,0,919,923,5,21,0,0,920,922,3, - 92,46,0,921,920,1,0,0,0,922,925,1,0,0,0,923,921,1,0,0,0,923,924,1,0,0, - 0,924,926,1,0,0,0,925,923,1,0,0,0,926,927,3,2,1,0,927,928,3,94,47,0,928, - 930,1,0,0,0,929,903,1,0,0,0,929,919,1,0,0,0,930,91,1,0,0,0,931,932,5,76, - 0,0,932,93,1,0,0,0,933,936,1,0,0,0,934,936,5,298,0,0,935,933,1,0,0,0,935, - 934,1,0,0,0,936,95,1,0,0,0,937,938,7,6,0,0,938,97,1,0,0,0,939,941,3,96, - 48,0,940,939,1,0,0,0,941,944,1,0,0,0,942,940,1,0,0,0,942,943,1,0,0,0,943, - 99,1,0,0,0,944,942,1,0,0,0,945,971,3,102,51,0,946,947,5,280,0,0,947,948, - 3,168,84,0,948,949,6,50,-1,0,949,971,1,0,0,0,950,951,5,286,0,0,951,952, - 3,178,89,0,952,953,6,50,-1,0,953,971,1,0,0,0,954,955,5,286,0,0,955,956, - 3,174,87,0,956,957,6,50,-1,0,957,971,1,0,0,0,958,959,5,284,0,0,959,960, - 3,124,62,0,960,961,6,50,-1,0,961,971,1,0,0,0,962,963,5,281,0,0,963,964, - 3,104,52,0,964,965,6,50,-1,0,965,971,1,0,0,0,966,967,5,287,0,0,967,968, - 3,50,25,0,968,969,6,50,-1,0,969,971,1,0,0,0,970,945,1,0,0,0,970,946,1, - 0,0,0,970,950,1,0,0,0,970,954,1,0,0,0,970,958,1,0,0,0,970,962,1,0,0,0, - 970,966,1,0,0,0,971,101,1,0,0,0,972,973,5,275,0,0,973,1051,6,51,-1,0,974, - 975,5,276,0,0,975,976,3,32,16,0,976,977,6,51,-1,0,977,1051,1,0,0,0,978, - 979,5,276,0,0,979,980,3,0,0,0,980,981,6,51,-1,0,981,1051,1,0,0,0,982,983, - 5,277,0,0,983,984,3,32,16,0,984,985,6,51,-1,0,985,1051,1,0,0,0,986,987, - 5,278,0,0,987,988,3,34,17,0,988,989,6,51,-1,0,989,1051,1,0,0,0,990,991, - 5,279,0,0,991,992,3,36,18,0,992,993,6,51,-1,0,993,1051,1,0,0,0,994,995, - 5,279,0,0,995,996,3,34,17,0,996,997,6,51,-1,0,997,1051,1,0,0,0,998,999, - 5,279,0,0,999,1000,5,30,0,0,1000,1001,3,292,146,0,1001,1002,5,31,0,0,1002, - 1003,6,51,-1,0,1003,1051,1,0,0,0,1004,1005,5,279,0,0,1005,1006,5,84,0, - 0,1006,1007,5,30,0,0,1007,1008,3,292,146,0,1008,1009,5,31,0,0,1009,1010, - 6,51,-1,0,1010,1051,1,0,0,0,1011,1012,5,282,0,0,1012,1013,3,32,16,0,1013, - 1014,6,51,-1,0,1014,1051,1,0,0,0,1015,1016,5,282,0,0,1016,1017,3,0,0,0, - 1017,1018,6,51,-1,0,1018,1051,1,0,0,0,1019,1020,5,285,0,0,1020,1021,3, - 6,3,0,1021,1022,6,51,-1,0,1022,1051,1,0,0,0,1023,1024,5,285,0,0,1024,1025, - 5,224,0,0,1025,1026,5,30,0,0,1026,1027,3,6,3,0,1027,1028,5,31,0,0,1028, - 1029,6,51,-1,0,1029,1051,1,0,0,0,1030,1031,5,285,0,0,1031,1032,5,84,0, - 0,1032,1033,5,30,0,0,1033,1034,3,292,146,0,1034,1035,5,31,0,0,1035,1036, - 6,51,-1,0,1036,1051,1,0,0,0,1037,1038,5,287,0,0,1038,1039,3,32,16,0,1039, - 1040,6,51,-1,0,1040,1051,1,0,0,0,1041,1042,5,283,0,0,1042,1048,6,51,-1, - 0,1043,1044,5,30,0,0,1044,1045,3,106,53,0,1045,1046,5,31,0,0,1046,1049, - 1,0,0,0,1047,1049,5,85,0,0,1048,1043,1,0,0,0,1048,1047,1,0,0,0,1049,1051, - 1,0,0,0,1050,972,1,0,0,0,1050,974,1,0,0,0,1050,978,1,0,0,0,1050,982,1, - 0,0,0,1050,986,1,0,0,0,1050,990,1,0,0,0,1050,994,1,0,0,0,1050,998,1,0, - 0,0,1050,1004,1,0,0,0,1050,1011,1,0,0,0,1050,1015,1,0,0,0,1050,1019,1, - 0,0,0,1050,1023,1,0,0,0,1050,1030,1,0,0,0,1050,1037,1,0,0,0,1050,1041, - 1,0,0,0,1051,103,1,0,0,0,1052,1053,3,170,85,0,1053,1054,3,138,69,0,1054, - 1055,3,112,56,0,1055,1056,6,52,-1,0,1056,105,1,0,0,0,1057,1082,1,0,0,0, - 1058,1059,3,0,0,0,1059,1060,6,53,-1,0,1060,1065,1,0,0,0,1061,1062,3,32, - 16,0,1062,1063,6,53,-1,0,1063,1065,1,0,0,0,1064,1058,1,0,0,0,1064,1061, - 1,0,0,0,1065,1066,1,0,0,0,1066,1067,5,28,0,0,1067,1069,1,0,0,0,1068,1064, - 1,0,0,0,1069,1072,1,0,0,0,1070,1068,1,0,0,0,1070,1071,1,0,0,0,1071,1079, - 1,0,0,0,1072,1070,1,0,0,0,1073,1074,3,0,0,0,1074,1075,6,53,-1,0,1075,1080, - 1,0,0,0,1076,1077,3,32,16,0,1077,1078,6,53,-1,0,1078,1080,1,0,0,0,1079, - 1073,1,0,0,0,1079,1076,1,0,0,0,1080,1082,1,0,0,0,1081,1057,1,0,0,0,1081, - 1070,1,0,0,0,1082,107,1,0,0,0,1083,1090,5,86,0,0,1084,1085,3,138,69,0, - 1085,1086,6,54,-1,0,1086,1087,5,28,0,0,1087,1089,1,0,0,0,1088,1084,1,0, - 0,0,1089,1092,1,0,0,0,1090,1088,1,0,0,0,1090,1091,1,0,0,0,1091,1093,1, - 0,0,0,1092,1090,1,0,0,0,1093,1094,3,138,69,0,1094,1095,6,54,-1,0,1095, - 1096,5,87,0,0,1096,109,1,0,0,0,1097,1104,5,42,0,0,1098,1099,3,146,73,0, - 1099,1100,6,55,-1,0,1100,1101,5,28,0,0,1101,1103,1,0,0,0,1102,1098,1,0, - 0,0,1103,1106,1,0,0,0,1104,1102,1,0,0,0,1104,1105,1,0,0,0,1105,1107,1, - 0,0,0,1106,1104,1,0,0,0,1107,1108,3,146,73,0,1108,1109,6,55,-1,0,1109, - 1110,5,43,0,0,1110,111,1,0,0,0,1111,1118,5,30,0,0,1112,1113,3,114,57,0, - 1113,1114,6,56,-1,0,1114,1115,5,28,0,0,1115,1117,1,0,0,0,1116,1112,1,0, - 0,0,1117,1120,1,0,0,0,1118,1116,1,0,0,0,1118,1119,1,0,0,0,1119,1121,1, - 0,0,0,1120,1118,1,0,0,0,1121,1122,3,114,57,0,1122,1123,6,56,-1,0,1123, - 1124,5,31,0,0,1124,1127,1,0,0,0,1125,1127,5,85,0,0,1126,1111,1,0,0,0,1126, - 1125,1,0,0,0,1127,113,1,0,0,0,1128,1129,5,177,0,0,1129,1139,6,57,-1,0, - 1130,1131,3,230,115,0,1131,1132,3,138,69,0,1132,1134,3,226,113,0,1133, - 1135,3,0,0,0,1134,1133,1,0,0,0,1134,1135,1,0,0,0,1135,1136,1,0,0,0,1136, - 1137,6,57,-1,0,1137,1139,1,0,0,0,1138,1128,1,0,0,0,1138,1130,1,0,0,0,1139, - 115,1,0,0,0,1140,1141,5,42,0,0,1141,1142,3,2,1,0,1142,1143,5,43,0,0,1143, - 1144,3,118,59,0,1144,1145,6,58,-1,0,1145,1178,1,0,0,0,1146,1147,5,42,0, - 0,1147,1148,3,174,87,0,1148,1149,5,43,0,0,1149,1150,3,118,59,0,1150,1151, - 6,58,-1,0,1151,1178,1,0,0,0,1152,1153,5,42,0,0,1153,1154,5,262,0,0,1154, - 1155,5,43,0,0,1155,1156,3,118,59,0,1156,1157,6,58,-1,0,1157,1178,1,0,0, - 0,1158,1159,5,42,0,0,1159,1160,5,198,0,0,1160,1161,3,2,1,0,1161,1162,5, - 43,0,0,1162,1163,3,118,59,0,1163,1164,6,58,-1,0,1164,1178,1,0,0,0,1165, - 1166,3,118,59,0,1166,1167,6,58,-1,0,1167,1178,1,0,0,0,1168,1169,3,174, - 87,0,1169,1170,6,58,-1,0,1170,1178,1,0,0,0,1171,1172,5,257,0,0,1172,1178, - 6,58,-1,0,1173,1174,5,258,0,0,1174,1178,6,58,-1,0,1175,1176,5,259,0,0, - 1176,1178,6,58,-1,0,1177,1140,1,0,0,0,1177,1146,1,0,0,0,1177,1152,1,0, - 0,0,1177,1158,1,0,0,0,1177,1165,1,0,0,0,1177,1168,1,0,0,0,1177,1171,1, - 0,0,0,1177,1173,1,0,0,0,1177,1175,1,0,0,0,1178,117,1,0,0,0,1179,1180,3, - 2,1,0,1180,1181,6,59,-1,0,1181,1182,5,88,0,0,1182,1184,1,0,0,0,1183,1179, - 1,0,0,0,1184,1187,1,0,0,0,1185,1183,1,0,0,0,1185,1186,1,0,0,0,1186,1188, - 1,0,0,0,1187,1185,1,0,0,0,1188,1189,3,2,1,0,1189,1190,6,59,-1,0,1190,119, - 1,0,0,0,1191,1193,3,122,61,0,1192,1191,1,0,0,0,1193,1196,1,0,0,0,1194, - 1192,1,0,0,0,1194,1195,1,0,0,0,1195,121,1,0,0,0,1196,1194,1,0,0,0,1197, - 1198,5,180,0,0,1198,1199,5,89,0,0,1199,1203,3,32,16,0,1200,1203,3,152, - 76,0,1201,1203,3,324,162,0,1202,1197,1,0,0,0,1202,1200,1,0,0,0,1202,1201, - 1,0,0,0,1203,123,1,0,0,0,1204,1205,3,116,58,0,1205,1206,6,62,-1,0,1206, - 1222,1,0,0,0,1207,1208,5,42,0,0,1208,1209,3,2,1,0,1209,1210,5,43,0,0,1210, - 1211,6,62,-1,0,1211,1222,1,0,0,0,1212,1213,5,42,0,0,1213,1214,5,198,0, - 0,1214,1215,3,2,1,0,1215,1216,5,43,0,0,1216,1217,6,62,-1,0,1217,1222,1, - 0,0,0,1218,1219,3,138,69,0,1219,1220,6,62,-1,0,1220,1222,1,0,0,0,1221, - 1204,1,0,0,0,1221,1207,1,0,0,0,1221,1212,1,0,0,0,1221,1218,1,0,0,0,1222, - 125,1,0,0,0,1223,1232,1,0,0,0,1224,1228,3,130,65,0,1225,1227,3,128,64, - 0,1226,1225,1,0,0,0,1227,1230,1,0,0,0,1228,1226,1,0,0,0,1228,1229,1,0, - 0,0,1229,1232,1,0,0,0,1230,1228,1,0,0,0,1231,1223,1,0,0,0,1231,1224,1, - 0,0,0,1232,127,1,0,0,0,1233,1251,5,262,0,0,1234,1251,5,261,0,0,1235,1236, - 5,42,0,0,1236,1237,3,32,16,0,1237,1238,5,43,0,0,1238,1251,1,0,0,0,1239, - 1240,5,42,0,0,1240,1241,3,32,16,0,1241,1242,5,266,0,0,1242,1243,3,32,16, - 0,1243,1244,5,43,0,0,1244,1251,1,0,0,0,1245,1246,5,42,0,0,1246,1247,5, - 266,0,0,1247,1248,3,32,16,0,1248,1249,5,43,0,0,1249,1251,1,0,0,0,1250, - 1233,1,0,0,0,1250,1234,1,0,0,0,1250,1235,1,0,0,0,1250,1239,1,0,0,0,1250, - 1245,1,0,0,0,1251,129,1,0,0,0,1252,1345,1,0,0,0,1253,1254,5,203,0,0,1254, - 1255,5,30,0,0,1255,1256,3,6,3,0,1256,1257,5,28,0,0,1257,1258,3,6,3,0,1258, - 1259,5,28,0,0,1259,1260,3,6,3,0,1260,1261,5,28,0,0,1261,1262,3,6,3,0,1262, - 1263,5,31,0,0,1263,1345,1,0,0,0,1264,1265,5,203,0,0,1265,1266,5,30,0,0, - 1266,1267,3,6,3,0,1267,1268,5,28,0,0,1268,1269,3,6,3,0,1269,1270,5,31, - 0,0,1270,1345,1,0,0,0,1271,1272,5,204,0,0,1272,1273,5,205,0,0,1273,1274, - 5,42,0,0,1274,1275,3,32,16,0,1275,1276,5,43,0,0,1276,1345,1,0,0,0,1277, - 1278,5,204,0,0,1278,1279,5,206,0,0,1279,1280,5,42,0,0,1280,1281,3,32,16, - 0,1281,1282,5,43,0,0,1282,1283,3,126,63,0,1283,1345,1,0,0,0,1284,1345, - 5,207,0,0,1285,1345,5,208,0,0,1286,1345,5,209,0,0,1287,1345,5,201,0,0, - 1288,1345,5,183,0,0,1289,1345,5,184,0,0,1290,1345,5,185,0,0,1291,1345, - 5,186,0,0,1292,1345,5,187,0,0,1293,1345,5,188,0,0,1294,1345,5,189,0,0, - 1295,1345,5,210,0,0,1296,1345,5,190,0,0,1297,1345,5,191,0,0,1298,1345, - 5,192,0,0,1299,1345,5,193,0,0,1300,1345,5,211,0,0,1301,1345,5,212,0,0, - 1302,1345,5,213,0,0,1303,1345,5,214,0,0,1304,1345,5,215,0,0,1305,1345, - 5,216,0,0,1306,1345,5,217,0,0,1307,1308,5,218,0,0,1308,1345,3,132,66,0, - 1309,1310,5,219,0,0,1310,1345,3,132,66,0,1311,1345,5,220,0,0,1312,1313, - 5,221,0,0,1313,1345,3,132,66,0,1314,1315,5,222,0,0,1315,1345,3,134,67, - 0,1316,1317,5,222,0,0,1317,1318,3,134,67,0,1318,1319,5,28,0,0,1319,1320, - 3,6,3,0,1320,1345,1,0,0,0,1321,1345,5,194,0,0,1322,1345,5,195,0,0,1323, - 1324,5,90,0,0,1324,1345,5,184,0,0,1325,1326,5,90,0,0,1326,1345,5,185,0, - 0,1327,1328,5,90,0,0,1328,1345,5,186,0,0,1329,1330,5,90,0,0,1330,1345, - 5,187,0,0,1331,1332,5,62,0,0,1332,1345,5,220,0,0,1333,1345,5,223,0,0,1334, - 1335,5,224,0,0,1335,1345,5,213,0,0,1336,1345,5,225,0,0,1337,1338,5,207, - 0,0,1338,1345,5,183,0,0,1339,1345,5,226,0,0,1340,1345,5,228,0,0,1341,1342, - 5,34,0,0,1342,1345,5,227,0,0,1343,1345,3,2,1,0,1344,1252,1,0,0,0,1344, - 1253,1,0,0,0,1344,1264,1,0,0,0,1344,1271,1,0,0,0,1344,1277,1,0,0,0,1344, - 1284,1,0,0,0,1344,1285,1,0,0,0,1344,1286,1,0,0,0,1344,1287,1,0,0,0,1344, - 1288,1,0,0,0,1344,1289,1,0,0,0,1344,1290,1,0,0,0,1344,1291,1,0,0,0,1344, - 1292,1,0,0,0,1344,1293,1,0,0,0,1344,1294,1,0,0,0,1344,1295,1,0,0,0,1344, - 1296,1,0,0,0,1344,1297,1,0,0,0,1344,1298,1,0,0,0,1344,1299,1,0,0,0,1344, - 1300,1,0,0,0,1344,1301,1,0,0,0,1344,1302,1,0,0,0,1344,1303,1,0,0,0,1344, - 1304,1,0,0,0,1344,1305,1,0,0,0,1344,1306,1,0,0,0,1344,1307,1,0,0,0,1344, - 1309,1,0,0,0,1344,1311,1,0,0,0,1344,1312,1,0,0,0,1344,1314,1,0,0,0,1344, - 1316,1,0,0,0,1344,1321,1,0,0,0,1344,1322,1,0,0,0,1344,1323,1,0,0,0,1344, - 1325,1,0,0,0,1344,1327,1,0,0,0,1344,1329,1,0,0,0,1344,1331,1,0,0,0,1344, - 1333,1,0,0,0,1344,1334,1,0,0,0,1344,1336,1,0,0,0,1344,1337,1,0,0,0,1344, - 1339,1,0,0,0,1344,1340,1,0,0,0,1344,1341,1,0,0,0,1344,1343,1,0,0,0,1345, - 131,1,0,0,0,1346,1354,1,0,0,0,1347,1348,5,30,0,0,1348,1349,5,91,0,0,1349, - 1350,5,36,0,0,1350,1351,3,32,16,0,1351,1352,5,31,0,0,1352,1354,1,0,0,0, - 1353,1346,1,0,0,0,1353,1347,1,0,0,0,1354,133,1,0,0,0,1355,1364,1,0,0,0, - 1356,1360,3,136,68,0,1357,1359,7,7,0,0,1358,1357,1,0,0,0,1359,1362,1,0, - 0,0,1360,1358,1,0,0,0,1360,1361,1,0,0,0,1361,1364,1,0,0,0,1362,1360,1, - 0,0,0,1363,1355,1,0,0,0,1363,1356,1,0,0,0,1364,135,1,0,0,0,1365,1366,7, - 8,0,0,1366,137,1,0,0,0,1367,1368,3,142,71,0,1368,1374,6,69,-1,0,1369,1370, - 3,140,70,0,1370,1371,6,69,-1,0,1371,1373,1,0,0,0,1372,1369,1,0,0,0,1373, - 1376,1,0,0,0,1374,1372,1,0,0,0,1374,1375,1,0,0,0,1375,139,1,0,0,0,1376, - 1374,1,0,0,0,1377,1378,5,261,0,0,1378,1407,6,70,-1,0,1379,1380,5,42,0, - 0,1380,1381,5,43,0,0,1381,1407,6,70,-1,0,1382,1383,3,110,55,0,1383,1384, - 6,70,-1,0,1384,1407,1,0,0,0,1385,1386,5,260,0,0,1386,1407,6,70,-1,0,1387, - 1388,5,262,0,0,1388,1407,6,70,-1,0,1389,1390,5,92,0,0,1390,1407,6,70,-1, - 0,1391,1392,5,93,0,0,1392,1393,5,30,0,0,1393,1394,3,124,62,0,1394,1395, - 5,31,0,0,1395,1396,6,70,-1,0,1396,1407,1,0,0,0,1397,1398,5,94,0,0,1398, - 1399,5,30,0,0,1399,1400,3,124,62,0,1400,1401,5,31,0,0,1401,1402,6,70,-1, - 0,1402,1407,1,0,0,0,1403,1404,3,108,54,0,1404,1405,6,70,-1,0,1405,1407, - 1,0,0,0,1406,1377,1,0,0,0,1406,1379,1,0,0,0,1406,1382,1,0,0,0,1406,1385, - 1,0,0,0,1406,1387,1,0,0,0,1406,1389,1,0,0,0,1406,1391,1,0,0,0,1406,1397, - 1,0,0,0,1406,1403,1,0,0,0,1407,141,1,0,0,0,1408,1409,5,39,0,0,1409,1410, - 3,116,58,0,1410,1411,6,71,-1,0,1411,1467,1,0,0,0,1412,1413,5,197,0,0,1413, - 1467,6,71,-1,0,1414,1415,5,199,0,0,1415,1416,5,39,0,0,1416,1417,3,116, - 58,0,1417,1418,6,71,-1,0,1418,1467,1,0,0,0,1419,1420,5,200,0,0,1420,1421, - 3,116,58,0,1421,1422,6,71,-1,0,1422,1467,1,0,0,0,1423,1424,5,226,0,0,1424, - 1425,3,170,85,0,1425,1426,3,138,69,0,1426,1427,5,262,0,0,1427,1428,3,112, - 56,0,1428,1429,6,71,-1,0,1429,1467,1,0,0,0,1430,1431,5,253,0,0,1431,1432, - 3,32,16,0,1432,1433,6,71,-1,0,1433,1467,1,0,0,0,1434,1435,5,252,0,0,1435, - 1436,3,32,16,0,1436,1437,6,71,-1,0,1437,1467,1,0,0,0,1438,1439,5,253,0, - 0,1439,1440,3,2,1,0,1440,1441,6,71,-1,0,1441,1467,1,0,0,0,1442,1443,5, - 252,0,0,1443,1444,3,2,1,0,1444,1445,6,71,-1,0,1445,1467,1,0,0,0,1446,1447, - 5,254,0,0,1447,1467,6,71,-1,0,1448,1449,5,201,0,0,1449,1467,6,71,-1,0, - 1450,1451,3,148,74,0,1451,1452,6,71,-1,0,1452,1467,1,0,0,0,1453,1454,3, - 150,75,0,1454,1455,6,71,-1,0,1455,1467,1,0,0,0,1456,1457,3,144,72,0,1457, - 1458,6,71,-1,0,1458,1467,1,0,0,0,1459,1460,3,2,1,0,1460,1461,6,71,-1,0, - 1461,1467,1,0,0,0,1462,1463,5,177,0,0,1463,1464,3,138,69,0,1464,1465,6, - 71,-1,0,1465,1467,1,0,0,0,1466,1408,1,0,0,0,1466,1412,1,0,0,0,1466,1414, - 1,0,0,0,1466,1419,1,0,0,0,1466,1423,1,0,0,0,1466,1430,1,0,0,0,1466,1434, - 1,0,0,0,1466,1438,1,0,0,0,1466,1442,1,0,0,0,1466,1446,1,0,0,0,1466,1448, - 1,0,0,0,1466,1450,1,0,0,0,1466,1453,1,0,0,0,1466,1456,1,0,0,0,1466,1459, - 1,0,0,0,1466,1462,1,0,0,0,1467,143,1,0,0,0,1468,1469,5,181,0,0,1469,1507, - 6,72,-1,0,1470,1471,5,182,0,0,1471,1507,6,72,-1,0,1472,1473,5,183,0,0, - 1473,1507,6,72,-1,0,1474,1475,5,184,0,0,1475,1507,6,72,-1,0,1476,1477, - 5,185,0,0,1477,1507,6,72,-1,0,1478,1479,5,186,0,0,1479,1507,6,72,-1,0, - 1480,1481,5,187,0,0,1481,1507,6,72,-1,0,1482,1483,5,188,0,0,1483,1507, - 6,72,-1,0,1484,1485,5,189,0,0,1485,1507,6,72,-1,0,1486,1487,5,190,0,0, - 1487,1507,6,72,-1,0,1488,1489,5,191,0,0,1489,1507,6,72,-1,0,1490,1491, - 5,192,0,0,1491,1507,6,72,-1,0,1492,1493,5,193,0,0,1493,1507,6,72,-1,0, - 1494,1495,5,90,0,0,1495,1496,5,184,0,0,1496,1507,6,72,-1,0,1497,1498,5, - 90,0,0,1498,1499,5,185,0,0,1499,1507,6,72,-1,0,1500,1501,5,90,0,0,1501, - 1502,5,186,0,0,1502,1507,6,72,-1,0,1503,1504,5,90,0,0,1504,1505,5,187, - 0,0,1505,1507,6,72,-1,0,1506,1468,1,0,0,0,1506,1470,1,0,0,0,1506,1472, - 1,0,0,0,1506,1474,1,0,0,0,1506,1476,1,0,0,0,1506,1478,1,0,0,0,1506,1480, - 1,0,0,0,1506,1482,1,0,0,0,1506,1484,1,0,0,0,1506,1486,1,0,0,0,1506,1488, - 1,0,0,0,1506,1490,1,0,0,0,1506,1492,1,0,0,0,1506,1494,1,0,0,0,1506,1497, - 1,0,0,0,1506,1500,1,0,0,0,1506,1503,1,0,0,0,1507,145,1,0,0,0,1508,1523, - 1,0,0,0,1509,1523,5,177,0,0,1510,1511,3,32,16,0,1511,1512,6,73,-1,0,1512, - 1523,1,0,0,0,1513,1514,3,32,16,0,1514,1515,5,177,0,0,1515,1516,3,32,16, - 0,1516,1517,6,73,-1,0,1517,1523,1,0,0,0,1518,1519,3,32,16,0,1519,1520, - 5,177,0,0,1520,1521,6,73,-1,0,1521,1523,1,0,0,0,1522,1508,1,0,0,0,1522, - 1509,1,0,0,0,1522,1510,1,0,0,0,1522,1513,1,0,0,0,1522,1518,1,0,0,0,1523, - 147,1,0,0,0,1524,1525,5,1,0,0,1525,1526,5,194,0,0,1526,1527,6,74,-1,0, - 1527,149,1,0,0,0,1528,1532,5,1,0,0,1529,1530,5,90,0,0,1530,1533,5,194, - 0,0,1531,1533,5,195,0,0,1532,1529,1,0,0,0,1532,1531,1,0,0,0,1533,1534, - 1,0,0,0,1534,1535,6,75,-1,0,1535,151,1,0,0,0,1536,1537,5,294,0,0,1537, - 1538,3,166,83,0,1538,1539,3,124,62,0,1539,1540,5,30,0,0,1540,1541,3,158, - 79,0,1541,1542,5,31,0,0,1542,1584,1,0,0,0,1543,1544,5,294,0,0,1544,1545, - 3,166,83,0,1545,1546,3,124,62,0,1546,1547,5,36,0,0,1547,1548,5,17,0,0, - 1548,1549,3,52,26,0,1549,1550,5,18,0,0,1550,1584,1,0,0,0,1551,1552,5,294, - 0,0,1552,1553,3,166,83,0,1553,1554,3,124,62,0,1554,1584,1,0,0,0,1555,1556, - 5,295,0,0,1556,1557,3,166,83,0,1557,1559,5,36,0,0,1558,1560,5,84,0,0,1559, - 1558,1,0,0,0,1559,1560,1,0,0,0,1560,1561,1,0,0,0,1561,1562,5,30,0,0,1562, - 1563,3,292,146,0,1563,1564,5,31,0,0,1564,1584,1,0,0,0,1565,1566,5,295, - 0,0,1566,1567,3,166,83,0,1567,1568,5,84,0,0,1568,1569,5,30,0,0,1569,1570, - 3,292,146,0,1570,1571,5,31,0,0,1571,1584,1,0,0,0,1572,1573,5,295,0,0,1573, - 1574,3,166,83,0,1574,1575,3,6,3,0,1575,1584,1,0,0,0,1576,1577,5,295,0, - 0,1577,1578,3,166,83,0,1578,1579,5,36,0,0,1579,1580,5,17,0,0,1580,1581, - 3,154,77,0,1581,1582,5,18,0,0,1582,1584,1,0,0,0,1583,1536,1,0,0,0,1583, - 1543,1,0,0,0,1583,1551,1,0,0,0,1583,1555,1,0,0,0,1583,1565,1,0,0,0,1583, - 1572,1,0,0,0,1583,1576,1,0,0,0,1584,153,1,0,0,0,1585,1596,1,0,0,0,1586, - 1587,3,156,78,0,1587,1588,5,28,0,0,1588,1590,1,0,0,0,1589,1586,1,0,0,0, - 1590,1593,1,0,0,0,1591,1589,1,0,0,0,1591,1592,1,0,0,0,1592,1594,1,0,0, - 0,1593,1591,1,0,0,0,1594,1596,3,156,78,0,1595,1585,1,0,0,0,1595,1591,1, - 0,0,0,1596,155,1,0,0,0,1597,1598,5,39,0,0,1598,1599,5,264,0,0,1599,1600, - 5,36,0,0,1600,1601,5,17,0,0,1601,1602,3,56,28,0,1602,1603,5,18,0,0,1603, - 1611,1,0,0,0,1604,1605,3,124,62,0,1605,1606,5,36,0,0,1606,1607,5,17,0, - 0,1607,1608,3,56,28,0,1608,1609,5,18,0,0,1609,1611,1,0,0,0,1610,1597,1, - 0,0,0,1610,1604,1,0,0,0,1611,157,1,0,0,0,1612,1613,3,160,80,0,1613,1614, - 5,28,0,0,1614,1616,1,0,0,0,1615,1612,1,0,0,0,1616,1619,1,0,0,0,1617,1615, - 1,0,0,0,1617,1618,1,0,0,0,1618,1620,1,0,0,0,1619,1617,1,0,0,0,1620,1621, - 3,160,80,0,1621,159,1,0,0,0,1622,1623,3,6,3,0,1623,1624,5,36,0,0,1624, - 1625,3,164,82,0,1625,161,1,0,0,0,1626,1627,7,9,0,0,1627,163,1,0,0,0,1628, - 1663,3,162,81,0,1629,1663,3,32,16,0,1630,1631,5,186,0,0,1631,1632,5,30, - 0,0,1632,1633,3,32,16,0,1633,1634,5,31,0,0,1634,1663,1,0,0,0,1635,1663, - 3,6,3,0,1636,1637,3,116,58,0,1637,1638,5,30,0,0,1638,1639,5,184,0,0,1639, - 1640,5,75,0,0,1640,1641,3,32,16,0,1641,1642,5,31,0,0,1642,1663,1,0,0,0, - 1643,1644,3,116,58,0,1644,1645,5,30,0,0,1645,1646,5,185,0,0,1646,1647, - 5,75,0,0,1647,1648,3,32,16,0,1648,1649,5,31,0,0,1649,1663,1,0,0,0,1650, - 1651,3,116,58,0,1651,1652,5,30,0,0,1652,1653,5,186,0,0,1653,1654,5,75, - 0,0,1654,1655,3,32,16,0,1655,1656,5,31,0,0,1656,1663,1,0,0,0,1657,1658, - 3,116,58,0,1658,1659,5,30,0,0,1659,1660,3,32,16,0,1660,1661,5,31,0,0,1661, - 1663,1,0,0,0,1662,1628,1,0,0,0,1662,1629,1,0,0,0,1662,1630,1,0,0,0,1662, - 1635,1,0,0,0,1662,1636,1,0,0,0,1662,1643,1,0,0,0,1662,1650,1,0,0,0,1662, - 1657,1,0,0,0,1663,165,1,0,0,0,1664,1665,7,10,0,0,1665,167,1,0,0,0,1666, - 1667,3,170,85,0,1667,1668,3,138,69,0,1668,1669,3,124,62,0,1669,1670,5, - 176,0,0,1670,1672,3,242,121,0,1671,1673,3,108,54,0,1672,1671,1,0,0,0,1672, - 1673,1,0,0,0,1673,1674,1,0,0,0,1674,1675,3,112,56,0,1675,1676,6,84,-1, - 0,1676,1709,1,0,0,0,1677,1678,3,170,85,0,1678,1679,3,138,69,0,1679,1680, - 3,124,62,0,1680,1681,5,176,0,0,1681,1682,3,242,121,0,1682,1683,3,196,98, - 0,1683,1684,3,112,56,0,1684,1685,6,84,-1,0,1685,1709,1,0,0,0,1686,1687, - 3,170,85,0,1687,1688,3,138,69,0,1688,1690,3,242,121,0,1689,1691,3,108, - 54,0,1690,1689,1,0,0,0,1690,1691,1,0,0,0,1691,1692,1,0,0,0,1692,1693,3, - 112,56,0,1693,1694,6,84,-1,0,1694,1709,1,0,0,0,1695,1696,3,170,85,0,1696, - 1697,3,138,69,0,1697,1698,3,242,121,0,1698,1699,3,196,98,0,1699,1700,3, - 112,56,0,1700,1701,6,84,-1,0,1701,1709,1,0,0,0,1702,1703,3,174,87,0,1703, - 1704,6,84,-1,0,1704,1709,1,0,0,0,1705,1706,3,2,1,0,1706,1707,6,84,-1,0, - 1707,1709,1,0,0,0,1708,1666,1,0,0,0,1708,1677,1,0,0,0,1708,1686,1,0,0, - 0,1708,1695,1,0,0,0,1708,1702,1,0,0,0,1708,1705,1,0,0,0,1709,169,1,0,0, - 0,1710,1711,5,243,0,0,1711,1712,3,170,85,0,1712,1713,6,85,-1,0,1713,1728, - 1,0,0,0,1714,1715,5,244,0,0,1715,1716,3,170,85,0,1716,1717,6,85,-1,0,1717, - 1728,1,0,0,0,1718,1719,3,172,86,0,1719,1720,6,85,-1,0,1720,1728,1,0,0, - 0,1721,1722,5,112,0,0,1722,1723,5,30,0,0,1723,1724,3,32,16,0,1724,1725, - 5,31,0,0,1725,1726,6,85,-1,0,1726,1728,1,0,0,0,1727,1710,1,0,0,0,1727, - 1714,1,0,0,0,1727,1718,1,0,0,0,1727,1721,1,0,0,0,1728,171,1,0,0,0,1729, - 1749,1,0,0,0,1730,1731,5,245,0,0,1731,1749,6,86,-1,0,1732,1733,5,246,0, - 0,1733,1749,6,86,-1,0,1734,1735,5,247,0,0,1735,1736,5,248,0,0,1736,1749, - 6,86,-1,0,1737,1738,5,247,0,0,1738,1739,5,249,0,0,1739,1749,6,86,-1,0, - 1740,1741,5,247,0,0,1741,1742,5,250,0,0,1742,1749,6,86,-1,0,1743,1744, - 5,247,0,0,1744,1745,5,251,0,0,1745,1749,6,86,-1,0,1746,1747,5,247,0,0, - 1747,1749,6,86,-1,0,1748,1729,1,0,0,0,1748,1730,1,0,0,0,1748,1732,1,0, - 0,0,1748,1734,1,0,0,0,1748,1737,1,0,0,0,1748,1740,1,0,0,0,1748,1743,1, - 0,0,0,1748,1746,1,0,0,0,1749,173,1,0,0,0,1750,1751,5,113,0,0,1751,1752, - 5,30,0,0,1752,1753,3,32,16,0,1753,1754,5,31,0,0,1754,1755,6,87,-1,0,1755, - 175,1,0,0,0,1756,1757,5,226,0,0,1757,1758,3,168,84,0,1758,1759,6,88,-1, - 0,1759,1768,1,0,0,0,1760,1761,5,37,0,0,1761,1762,3,178,89,0,1762,1763, - 6,88,-1,0,1763,1768,1,0,0,0,1764,1765,3,174,87,0,1765,1766,6,88,-1,0,1766, - 1768,1,0,0,0,1767,1756,1,0,0,0,1767,1760,1,0,0,0,1767,1764,1,0,0,0,1768, - 177,1,0,0,0,1769,1770,3,138,69,0,1770,1771,3,124,62,0,1771,1772,5,176, - 0,0,1772,1773,3,2,1,0,1773,1774,6,89,-1,0,1774,1783,1,0,0,0,1775,1776, - 3,138,69,0,1776,1777,3,2,1,0,1777,1778,6,89,-1,0,1778,1783,1,0,0,0,1779, - 1780,3,2,1,0,1780,1781,6,89,-1,0,1781,1783,1,0,0,0,1782,1769,1,0,0,0,1782, - 1775,1,0,0,0,1782,1779,1,0,0,0,1783,179,1,0,0,0,1784,1785,3,124,62,0,1785, - 1786,5,28,0,0,1786,1788,1,0,0,0,1787,1784,1,0,0,0,1788,1791,1,0,0,0,1789, - 1787,1,0,0,0,1789,1790,1,0,0,0,1790,1792,1,0,0,0,1791,1789,1,0,0,0,1792, - 1793,3,124,62,0,1793,181,1,0,0,0,1794,1800,1,0,0,0,1795,1796,5,86,0,0, - 1796,1797,3,190,95,0,1797,1798,5,87,0,0,1798,1800,1,0,0,0,1799,1794,1, - 0,0,0,1799,1795,1,0,0,0,1800,183,1,0,0,0,1801,1813,5,266,0,0,1802,1813, - 5,114,0,0,1803,1813,5,39,0,0,1804,1813,5,200,0,0,1805,1813,5,115,0,0,1806, - 1813,5,116,0,0,1807,1808,5,70,0,0,1808,1809,5,30,0,0,1809,1810,3,32,16, - 0,1810,1811,5,31,0,0,1811,1813,1,0,0,0,1812,1801,1,0,0,0,1812,1802,1,0, - 0,0,1812,1803,1,0,0,0,1812,1804,1,0,0,0,1812,1805,1,0,0,0,1812,1806,1, - 0,0,0,1812,1807,1,0,0,0,1813,185,1,0,0,0,1814,1816,3,184,92,0,1815,1814, - 1,0,0,0,1816,1819,1,0,0,0,1817,1815,1,0,0,0,1817,1818,1,0,0,0,1818,187, - 1,0,0,0,1819,1817,1,0,0,0,1820,1822,3,186,93,0,1821,1823,3,192,96,0,1822, - 1821,1,0,0,0,1822,1823,1,0,0,0,1823,1824,1,0,0,0,1824,1825,3,2,1,0,1825, - 189,1,0,0,0,1826,1827,3,188,94,0,1827,1828,5,28,0,0,1828,1830,1,0,0,0, - 1829,1826,1,0,0,0,1830,1833,1,0,0,0,1831,1829,1,0,0,0,1831,1832,1,0,0, - 0,1832,1834,1,0,0,0,1833,1831,1,0,0,0,1834,1835,3,188,94,0,1835,191,1, - 0,0,0,1836,1837,5,30,0,0,1837,1838,3,180,90,0,1838,1839,5,31,0,0,1839, - 193,1,0,0,0,1840,1842,3,196,98,0,1841,1840,1,0,0,0,1841,1842,1,0,0,0,1842, - 1843,1,0,0,0,1843,1844,6,97,-1,0,1844,195,1,0,0,0,1845,1846,5,86,0,0,1846, - 1847,5,42,0,0,1847,1848,3,32,16,0,1848,1849,5,43,0,0,1849,1850,5,87,0, - 0,1850,1851,6,98,-1,0,1851,197,1,0,0,0,1852,1853,3,234,117,0,1853,1854, - 5,17,0,0,1854,1855,3,246,123,0,1855,1856,5,18,0,0,1856,1969,1,0,0,0,1857, - 1858,3,74,37,0,1858,1859,5,17,0,0,1859,1860,3,82,41,0,1860,1861,5,18,0, - 0,1861,1969,1,0,0,0,1862,1863,3,210,105,0,1863,1864,5,17,0,0,1864,1865, - 3,214,107,0,1865,1866,5,18,0,0,1866,1969,1,0,0,0,1867,1868,3,218,109,0, - 1868,1869,5,17,0,0,1869,1870,3,222,111,0,1870,1871,5,18,0,0,1871,1969, - 1,0,0,0,1872,1969,3,200,100,0,1873,1969,3,276,138,0,1874,1969,3,152,76, - 0,1875,1969,3,88,44,0,1876,1969,3,322,161,0,1877,1878,5,117,0,0,1878,1969, - 3,32,16,0,1879,1880,5,118,0,0,1880,1969,3,32,16,0,1881,1882,3,334,167, - 0,1882,1883,5,17,0,0,1883,1884,3,338,169,0,1884,1885,5,18,0,0,1885,1969, - 1,0,0,0,1886,1887,5,302,0,0,1887,1888,3,124,62,0,1888,1889,5,176,0,0,1889, - 1890,3,242,121,0,1890,1891,5,119,0,0,1891,1892,3,170,85,0,1892,1893,3, - 138,69,0,1893,1894,3,124,62,0,1894,1895,5,176,0,0,1895,1896,3,242,121, - 0,1896,1897,3,112,56,0,1897,1969,1,0,0,0,1898,1899,5,302,0,0,1899,1900, - 5,226,0,0,1900,1901,3,170,85,0,1901,1902,3,138,69,0,1902,1903,3,124,62, - 0,1903,1904,5,176,0,0,1904,1905,3,242,121,0,1905,1906,3,194,97,0,1906, - 1907,3,112,56,0,1907,1908,5,119,0,0,1908,1909,5,226,0,0,1909,1910,3,170, - 85,0,1910,1911,3,138,69,0,1911,1912,3,124,62,0,1912,1913,5,176,0,0,1913, - 1914,3,242,121,0,1914,1915,3,194,97,0,1915,1916,3,112,56,0,1916,1969,1, - 0,0,0,1917,1969,3,26,13,0,1918,1969,3,40,20,0,1919,1920,5,255,0,0,1920, - 1921,5,196,0,0,1921,1922,5,42,0,0,1922,1923,3,32,16,0,1923,1927,5,43,0, - 0,1924,1926,3,322,161,0,1925,1924,1,0,0,0,1926,1929,1,0,0,0,1927,1925, - 1,0,0,0,1927,1928,1,0,0,0,1928,1969,1,0,0,0,1929,1927,1,0,0,0,1930,1931, - 5,255,0,0,1931,1932,5,196,0,0,1932,1936,3,2,1,0,1933,1935,3,322,161,0, - 1934,1933,1,0,0,0,1935,1938,1,0,0,0,1936,1934,1,0,0,0,1936,1937,1,0,0, - 0,1937,1969,1,0,0,0,1938,1936,1,0,0,0,1939,1940,5,255,0,0,1940,1941,5, - 256,0,0,1941,1942,5,42,0,0,1942,1943,3,32,16,0,1943,1944,5,43,0,0,1944, - 1945,5,28,0,0,1945,1949,3,124,62,0,1946,1948,3,322,161,0,1947,1946,1,0, - 0,0,1948,1951,1,0,0,0,1949,1947,1,0,0,0,1949,1950,1,0,0,0,1950,1969,1, - 0,0,0,1951,1949,1,0,0,0,1952,1953,5,255,0,0,1953,1954,5,256,0,0,1954,1955, - 3,2,1,0,1955,1956,5,28,0,0,1956,1960,3,124,62,0,1957,1959,3,322,161,0, - 1958,1957,1,0,0,0,1959,1962,1,0,0,0,1960,1958,1,0,0,0,1960,1961,1,0,0, - 0,1961,1969,1,0,0,0,1962,1960,1,0,0,0,1963,1964,5,120,0,0,1964,1965,5, - 196,0,0,1965,1966,3,124,62,0,1966,1967,3,44,22,0,1967,1969,1,0,0,0,1968, - 1852,1,0,0,0,1968,1857,1,0,0,0,1968,1862,1,0,0,0,1968,1867,1,0,0,0,1968, - 1872,1,0,0,0,1968,1873,1,0,0,0,1968,1874,1,0,0,0,1968,1875,1,0,0,0,1968, - 1876,1,0,0,0,1968,1877,1,0,0,0,1968,1879,1,0,0,0,1968,1881,1,0,0,0,1968, - 1886,1,0,0,0,1968,1898,1,0,0,0,1968,1917,1,0,0,0,1968,1918,1,0,0,0,1968, - 1919,1,0,0,0,1968,1930,1,0,0,0,1968,1939,1,0,0,0,1968,1952,1,0,0,0,1968, - 1963,1,0,0,0,1969,199,1,0,0,0,1970,1971,5,121,0,0,1971,1980,3,208,104, - 0,1972,1979,3,202,101,0,1973,1974,5,122,0,0,1974,1975,5,30,0,0,1975,1976, - 3,228,114,0,1976,1977,5,31,0,0,1977,1979,1,0,0,0,1978,1972,1,0,0,0,1978, - 1973,1,0,0,0,1979,1982,1,0,0,0,1980,1978,1,0,0,0,1980,1981,1,0,0,0,1981, - 1983,1,0,0,0,1982,1980,1,0,0,0,1983,1984,3,138,69,0,1984,1985,3,2,1,0, - 1985,1986,3,204,102,0,1986,1987,3,206,103,0,1987,201,1,0,0,0,1988,2008, - 5,123,0,0,1989,2008,5,51,0,0,1990,2008,5,52,0,0,1991,2008,5,63,0,0,1992, - 2008,5,124,0,0,1993,2008,5,69,0,0,1994,2008,5,68,0,0,1995,2008,5,64,0, - 0,1996,2008,5,65,0,0,1997,2008,5,66,0,0,1998,2008,5,125,0,0,1999,2008, - 5,126,0,0,2000,2008,5,127,0,0,2001,2008,5,16,0,0,2002,2003,5,70,0,0,2003, - 2004,5,30,0,0,2004,2005,3,32,16,0,2005,2006,5,31,0,0,2006,2008,1,0,0,0, - 2007,1988,1,0,0,0,2007,1989,1,0,0,0,2007,1990,1,0,0,0,2007,1991,1,0,0, - 0,2007,1992,1,0,0,0,2007,1993,1,0,0,0,2007,1994,1,0,0,0,2007,1995,1,0, - 0,0,2007,1996,1,0,0,0,2007,1997,1,0,0,0,2007,1998,1,0,0,0,2007,1999,1, - 0,0,0,2007,2000,1,0,0,0,2007,2001,1,0,0,0,2007,2002,1,0,0,0,2008,203,1, - 0,0,0,2009,2015,1,0,0,0,2010,2011,5,44,0,0,2011,2015,3,0,0,0,2012,2013, - 5,44,0,0,2013,2015,3,32,16,0,2014,2009,1,0,0,0,2014,2010,1,0,0,0,2014, - 2012,1,0,0,0,2015,205,1,0,0,0,2016,2020,1,0,0,0,2017,2018,5,36,0,0,2018, - 2020,3,296,148,0,2019,2016,1,0,0,0,2019,2017,1,0,0,0,2020,207,1,0,0,0, - 2021,2027,1,0,0,0,2022,2023,5,42,0,0,2023,2024,3,32,16,0,2024,2025,5,43, - 0,0,2025,2027,1,0,0,0,2026,2021,1,0,0,0,2026,2022,1,0,0,0,2027,209,1,0, - 0,0,2028,2032,5,128,0,0,2029,2031,3,212,106,0,2030,2029,1,0,0,0,2031,2034, - 1,0,0,0,2032,2030,1,0,0,0,2032,2033,1,0,0,0,2033,2035,1,0,0,0,2034,2032, - 1,0,0,0,2035,2036,3,124,62,0,2036,2037,3,2,1,0,2037,2047,1,0,0,0,2038, - 2042,5,128,0,0,2039,2041,3,212,106,0,2040,2039,1,0,0,0,2041,2044,1,0,0, - 0,2042,2040,1,0,0,0,2042,2043,1,0,0,0,2043,2045,1,0,0,0,2044,2042,1,0, - 0,0,2045,2047,3,2,1,0,2046,2028,1,0,0,0,2046,2038,1,0,0,0,2047,211,1,0, - 0,0,2048,2049,7,11,0,0,2049,213,1,0,0,0,2050,2052,3,216,108,0,2051,2050, - 1,0,0,0,2052,2055,1,0,0,0,2053,2051,1,0,0,0,2053,2054,1,0,0,0,2054,215, - 1,0,0,0,2055,2053,1,0,0,0,2056,2057,5,129,0,0,2057,2069,3,168,84,0,2058, - 2059,5,130,0,0,2059,2069,3,168,84,0,2060,2061,5,131,0,0,2061,2069,3,168, - 84,0,2062,2063,5,132,0,0,2063,2069,3,168,84,0,2064,2069,3,88,44,0,2065, - 2069,3,322,161,0,2066,2069,3,26,13,0,2067,2069,3,40,20,0,2068,2056,1,0, - 0,0,2068,2058,1,0,0,0,2068,2060,1,0,0,0,2068,2062,1,0,0,0,2068,2064,1, - 0,0,0,2068,2065,1,0,0,0,2068,2066,1,0,0,0,2068,2067,1,0,0,0,2069,217,1, - 0,0,0,2070,2074,5,133,0,0,2071,2073,3,220,110,0,2072,2071,1,0,0,0,2073, - 2076,1,0,0,0,2074,2072,1,0,0,0,2074,2075,1,0,0,0,2075,2077,1,0,0,0,2076, - 2074,1,0,0,0,2077,2078,3,170,85,0,2078,2079,3,138,69,0,2079,2080,3,2,1, - 0,2080,2081,3,112,56,0,2081,2082,3,206,103,0,2082,219,1,0,0,0,2083,2084, - 7,11,0,0,2084,221,1,0,0,0,2085,2087,3,224,112,0,2086,2085,1,0,0,0,2087, - 2090,1,0,0,0,2088,2086,1,0,0,0,2088,2089,1,0,0,0,2089,223,1,0,0,0,2090, - 2088,1,0,0,0,2091,2092,5,134,0,0,2092,2102,3,168,84,0,2093,2094,5,135, - 0,0,2094,2102,3,168,84,0,2095,2096,5,132,0,0,2096,2102,3,168,84,0,2097, - 2102,3,322,161,0,2098,2102,3,88,44,0,2099,2102,3,26,13,0,2100,2102,3,40, - 20,0,2101,2091,1,0,0,0,2101,2093,1,0,0,0,2101,2095,1,0,0,0,2101,2097,1, - 0,0,0,2101,2098,1,0,0,0,2101,2099,1,0,0,0,2101,2100,1,0,0,0,2102,225,1, - 0,0,0,2103,2110,1,0,0,0,2104,2105,5,122,0,0,2105,2106,5,30,0,0,2106,2107, - 3,228,114,0,2107,2108,5,31,0,0,2108,2110,1,0,0,0,2109,2103,1,0,0,0,2109, - 2104,1,0,0,0,2110,227,1,0,0,0,2111,2121,3,126,63,0,2112,2114,5,17,0,0, - 2113,2115,3,294,147,0,2114,2113,1,0,0,0,2115,2116,1,0,0,0,2116,2114,1, - 0,0,0,2116,2117,1,0,0,0,2117,2118,1,0,0,0,2118,2119,5,18,0,0,2119,2121, - 1,0,0,0,2120,2111,1,0,0,0,2120,2112,1,0,0,0,2121,229,1,0,0,0,2122,2123, - 3,232,116,0,2123,2124,6,115,-1,0,2124,2126,1,0,0,0,2125,2122,1,0,0,0,2126, - 2129,1,0,0,0,2127,2125,1,0,0,0,2127,2128,1,0,0,0,2128,231,1,0,0,0,2129, - 2127,1,0,0,0,2130,2131,5,42,0,0,2131,2132,5,136,0,0,2132,2133,5,43,0,0, - 2133,2148,6,116,-1,0,2134,2135,5,42,0,0,2135,2136,5,137,0,0,2136,2137, - 5,43,0,0,2137,2148,6,116,-1,0,2138,2139,5,42,0,0,2139,2140,5,138,0,0,2140, - 2141,5,43,0,0,2141,2148,6,116,-1,0,2142,2143,5,42,0,0,2143,2144,3,32,16, - 0,2144,2145,5,43,0,0,2145,2146,6,116,-1,0,2146,2148,1,0,0,0,2147,2130, - 1,0,0,0,2147,2134,1,0,0,0,2147,2138,1,0,0,0,2147,2142,1,0,0,0,2148,233, - 1,0,0,0,2149,2154,5,139,0,0,2150,2153,3,236,118,0,2151,2153,3,238,119, - 0,2152,2150,1,0,0,0,2152,2151,1,0,0,0,2153,2156,1,0,0,0,2154,2152,1,0, - 0,0,2154,2155,1,0,0,0,2155,2157,1,0,0,0,2156,2154,1,0,0,0,2157,2158,3, - 170,85,0,2158,2159,3,230,115,0,2159,2160,3,138,69,0,2160,2161,3,226,113, - 0,2161,2162,3,242,121,0,2162,2163,3,182,91,0,2163,2167,3,112,56,0,2164, - 2166,3,244,122,0,2165,2164,1,0,0,0,2166,2169,1,0,0,0,2167,2165,1,0,0,0, - 2167,2168,1,0,0,0,2168,235,1,0,0,0,2169,2167,1,0,0,0,2170,2194,5,123,0, - 0,2171,2194,5,51,0,0,2172,2194,5,52,0,0,2173,2194,5,63,0,0,2174,2194,5, - 140,0,0,2175,2194,5,68,0,0,2176,2194,5,141,0,0,2177,2194,5,142,0,0,2178, - 2194,5,54,0,0,2179,2194,5,64,0,0,2180,2194,5,65,0,0,2181,2194,5,66,0,0, - 2182,2194,5,125,0,0,2183,2194,5,143,0,0,2184,2194,5,144,0,0,2185,2194, - 5,69,0,0,2186,2194,5,145,0,0,2187,2194,5,146,0,0,2188,2189,5,70,0,0,2189, - 2190,5,30,0,0,2190,2191,3,32,16,0,2191,2192,5,31,0,0,2192,2194,1,0,0,0, - 2193,2170,1,0,0,0,2193,2171,1,0,0,0,2193,2172,1,0,0,0,2193,2173,1,0,0, - 0,2193,2174,1,0,0,0,2193,2175,1,0,0,0,2193,2176,1,0,0,0,2193,2177,1,0, - 0,0,2193,2178,1,0,0,0,2193,2179,1,0,0,0,2193,2180,1,0,0,0,2193,2181,1, - 0,0,0,2193,2182,1,0,0,0,2193,2183,1,0,0,0,2193,2184,1,0,0,0,2193,2185, - 1,0,0,0,2193,2186,1,0,0,0,2193,2187,1,0,0,0,2193,2188,1,0,0,0,2194,237, - 1,0,0,0,2195,2196,5,147,0,0,2196,2202,5,30,0,0,2197,2200,3,6,3,0,2198, - 2199,5,34,0,0,2199,2201,3,6,3,0,2200,2198,1,0,0,0,2200,2201,1,0,0,0,2201, - 2203,1,0,0,0,2202,2197,1,0,0,0,2202,2203,1,0,0,0,2203,2207,1,0,0,0,2204, - 2206,3,240,120,0,2205,2204,1,0,0,0,2206,2209,1,0,0,0,2207,2205,1,0,0,0, - 2207,2208,1,0,0,0,2208,2210,1,0,0,0,2209,2207,1,0,0,0,2210,2214,5,31,0, - 0,2211,2212,5,147,0,0,2212,2214,5,85,0,0,2213,2195,1,0,0,0,2213,2211,1, - 0,0,0,2214,239,1,0,0,0,2215,2243,5,148,0,0,2216,2243,5,224,0,0,2217,2243, - 5,57,0,0,2218,2243,5,58,0,0,2219,2243,5,149,0,0,2220,2243,5,150,0,0,2221, - 2243,5,248,0,0,2222,2243,5,249,0,0,2223,2243,5,250,0,0,2224,2243,5,251, - 0,0,2225,2226,5,151,0,0,2226,2227,5,75,0,0,2227,2243,5,152,0,0,2228,2229, - 5,151,0,0,2229,2230,5,75,0,0,2230,2243,5,153,0,0,2231,2232,5,154,0,0,2232, - 2233,5,75,0,0,2233,2243,5,152,0,0,2234,2235,5,154,0,0,2235,2236,5,75,0, - 0,2236,2243,5,153,0,0,2237,2238,5,70,0,0,2238,2239,5,30,0,0,2239,2240, - 3,32,16,0,2240,2241,5,31,0,0,2241,2243,1,0,0,0,2242,2215,1,0,0,0,2242, - 2216,1,0,0,0,2242,2217,1,0,0,0,2242,2218,1,0,0,0,2242,2219,1,0,0,0,2242, - 2220,1,0,0,0,2242,2221,1,0,0,0,2242,2222,1,0,0,0,2242,2223,1,0,0,0,2242, - 2224,1,0,0,0,2242,2225,1,0,0,0,2242,2228,1,0,0,0,2242,2231,1,0,0,0,2242, - 2234,1,0,0,0,2242,2237,1,0,0,0,2243,241,1,0,0,0,2244,2245,5,116,0,0,2245, - 2252,6,121,-1,0,2246,2247,5,155,0,0,2247,2252,6,121,-1,0,2248,2249,3,2, - 1,0,2249,2250,6,121,-1,0,2250,2252,1,0,0,0,2251,2244,1,0,0,0,2251,2246, - 1,0,0,0,2251,2248,1,0,0,0,2252,243,1,0,0,0,2253,2275,5,1,0,0,2254,2275, - 5,2,0,0,2255,2275,5,156,0,0,2256,2275,5,3,0,0,2257,2275,5,4,0,0,2258,2275, - 5,247,0,0,2259,2275,5,5,0,0,2260,2275,5,6,0,0,2261,2275,5,7,0,0,2262,2275, - 5,8,0,0,2263,2275,5,9,0,0,2264,2275,5,10,0,0,2265,2275,5,11,0,0,2266,2275, - 5,12,0,0,2267,2275,5,13,0,0,2268,2275,5,14,0,0,2269,2270,5,70,0,0,2270, - 2271,5,30,0,0,2271,2272,3,32,16,0,2272,2273,5,31,0,0,2273,2275,1,0,0,0, - 2274,2253,1,0,0,0,2274,2254,1,0,0,0,2274,2255,1,0,0,0,2274,2256,1,0,0, - 0,2274,2257,1,0,0,0,2274,2258,1,0,0,0,2274,2259,1,0,0,0,2274,2260,1,0, - 0,0,2274,2261,1,0,0,0,2274,2262,1,0,0,0,2274,2263,1,0,0,0,2274,2264,1, - 0,0,0,2274,2265,1,0,0,0,2274,2266,1,0,0,0,2274,2267,1,0,0,0,2274,2268, - 1,0,0,0,2274,2269,1,0,0,0,2275,245,1,0,0,0,2276,2278,3,248,124,0,2277, - 2276,1,0,0,0,2278,2281,1,0,0,0,2279,2277,1,0,0,0,2279,2280,1,0,0,0,2280, - 247,1,0,0,0,2281,2279,1,0,0,0,2282,2300,3,100,50,0,2283,2284,5,296,0,0, - 2284,2285,3,32,16,0,2285,2286,6,124,-1,0,2286,2300,1,0,0,0,2287,2300,3, - 258,129,0,2288,2289,5,297,0,0,2289,2290,3,32,16,0,2290,2291,6,124,-1,0, - 2291,2300,1,0,0,0,2292,2293,5,298,0,0,2293,2300,6,124,-1,0,2294,2295,5, - 299,0,0,2295,2300,6,124,-1,0,2296,2300,3,252,126,0,2297,2300,3,256,128, - 0,2298,2300,3,250,125,0,2299,2282,1,0,0,0,2299,2283,1,0,0,0,2299,2287, - 1,0,0,0,2299,2288,1,0,0,0,2299,2292,1,0,0,0,2299,2294,1,0,0,0,2299,2296, - 1,0,0,0,2299,2297,1,0,0,0,2299,2298,1,0,0,0,2300,249,1,0,0,0,2301,2302, - 5,300,0,0,2302,2400,3,112,56,0,2303,2304,5,300,0,0,2304,2305,5,157,0,0, - 2305,2400,3,112,56,0,2306,2400,3,276,138,0,2307,2400,3,152,76,0,2308,2400, - 3,88,44,0,2309,2400,3,26,13,0,2310,2400,3,254,127,0,2311,2400,3,40,20, - 0,2312,2313,5,301,0,0,2313,2314,5,42,0,0,2314,2315,3,32,16,0,2315,2316, - 5,43,0,0,2316,2400,1,0,0,0,2317,2318,5,301,0,0,2318,2319,5,42,0,0,2319, - 2320,3,32,16,0,2320,2321,5,43,0,0,2321,2322,5,34,0,0,2322,2323,3,0,0,0, - 2323,2400,1,0,0,0,2324,2325,5,303,0,0,2325,2326,3,32,16,0,2326,2327,5, - 75,0,0,2327,2328,3,32,16,0,2328,2400,1,0,0,0,2329,2330,5,302,0,0,2330, - 2331,3,124,62,0,2331,2332,5,176,0,0,2332,2333,3,242,121,0,2333,2400,1, - 0,0,0,2334,2335,5,302,0,0,2335,2336,5,226,0,0,2336,2337,3,170,85,0,2337, - 2338,3,138,69,0,2338,2339,3,124,62,0,2339,2340,5,176,0,0,2340,2341,3,242, - 121,0,2341,2342,3,194,97,0,2342,2343,3,112,56,0,2343,2400,1,0,0,0,2344, - 2345,5,255,0,0,2345,2346,5,196,0,0,2346,2347,5,42,0,0,2347,2348,3,32,16, - 0,2348,2352,5,43,0,0,2349,2351,3,322,161,0,2350,2349,1,0,0,0,2351,2354, - 1,0,0,0,2352,2350,1,0,0,0,2352,2353,1,0,0,0,2353,2400,1,0,0,0,2354,2352, - 1,0,0,0,2355,2356,5,255,0,0,2356,2357,5,196,0,0,2357,2361,3,2,1,0,2358, - 2360,3,322,161,0,2359,2358,1,0,0,0,2360,2363,1,0,0,0,2361,2359,1,0,0,0, - 2361,2362,1,0,0,0,2362,2400,1,0,0,0,2363,2361,1,0,0,0,2364,2365,5,255, - 0,0,2365,2366,5,256,0,0,2366,2367,5,42,0,0,2367,2368,3,32,16,0,2368,2369, - 5,43,0,0,2369,2370,5,28,0,0,2370,2374,3,124,62,0,2371,2373,3,322,161,0, - 2372,2371,1,0,0,0,2373,2376,1,0,0,0,2374,2372,1,0,0,0,2374,2375,1,0,0, - 0,2375,2400,1,0,0,0,2376,2374,1,0,0,0,2377,2378,5,255,0,0,2378,2379,5, - 256,0,0,2379,2380,3,2,1,0,2380,2381,5,28,0,0,2381,2385,3,124,62,0,2382, - 2384,3,322,161,0,2383,2382,1,0,0,0,2384,2387,1,0,0,0,2385,2383,1,0,0,0, - 2385,2386,1,0,0,0,2386,2400,1,0,0,0,2387,2385,1,0,0,0,2388,2389,5,255, - 0,0,2389,2390,5,42,0,0,2390,2391,3,32,16,0,2391,2392,5,43,0,0,2392,2396, - 3,206,103,0,2393,2395,3,322,161,0,2394,2393,1,0,0,0,2395,2398,1,0,0,0, - 2396,2394,1,0,0,0,2396,2397,1,0,0,0,2397,2400,1,0,0,0,2398,2396,1,0,0, - 0,2399,2301,1,0,0,0,2399,2303,1,0,0,0,2399,2306,1,0,0,0,2399,2307,1,0, - 0,0,2399,2308,1,0,0,0,2399,2309,1,0,0,0,2399,2310,1,0,0,0,2399,2311,1, - 0,0,0,2399,2312,1,0,0,0,2399,2317,1,0,0,0,2399,2324,1,0,0,0,2399,2329, - 1,0,0,0,2399,2334,1,0,0,0,2399,2344,1,0,0,0,2399,2355,1,0,0,0,2399,2364, - 1,0,0,0,2399,2377,1,0,0,0,2399,2388,1,0,0,0,2400,251,1,0,0,0,2401,2402, - 3,0,0,0,2402,2403,5,75,0,0,2403,2404,6,126,-1,0,2404,253,1,0,0,0,2405, - 2408,3,44,22,0,2406,2408,3,46,23,0,2407,2405,1,0,0,0,2407,2406,1,0,0,0, - 2408,255,1,0,0,0,2409,2410,5,17,0,0,2410,2411,3,246,123,0,2411,2412,5, - 18,0,0,2412,257,1,0,0,0,2413,2414,3,262,131,0,2414,2415,3,260,130,0,2415, - 259,1,0,0,0,2416,2418,3,264,132,0,2417,2416,1,0,0,0,2418,2419,1,0,0,0, - 2419,2417,1,0,0,0,2419,2420,1,0,0,0,2420,261,1,0,0,0,2421,2422,5,158,0, - 0,2422,2434,3,256,128,0,2423,2424,5,158,0,0,2424,2425,3,0,0,0,2425,2426, - 5,159,0,0,2426,2427,3,0,0,0,2427,2434,1,0,0,0,2428,2429,5,158,0,0,2429, - 2430,3,32,16,0,2430,2431,5,159,0,0,2431,2432,3,32,16,0,2432,2434,1,0,0, - 0,2433,2421,1,0,0,0,2433,2423,1,0,0,0,2433,2428,1,0,0,0,2434,263,1,0,0, - 0,2435,2436,3,268,134,0,2436,2437,3,274,137,0,2437,2448,1,0,0,0,2438,2439, - 3,266,133,0,2439,2440,3,274,137,0,2440,2448,1,0,0,0,2441,2442,3,270,135, - 0,2442,2443,3,274,137,0,2443,2448,1,0,0,0,2444,2445,3,272,136,0,2445,2446, - 3,274,137,0,2446,2448,1,0,0,0,2447,2435,1,0,0,0,2447,2438,1,0,0,0,2447, - 2441,1,0,0,0,2447,2444,1,0,0,0,2448,265,1,0,0,0,2449,2450,5,160,0,0,2450, - 2456,3,256,128,0,2451,2452,5,160,0,0,2452,2456,3,0,0,0,2453,2454,5,160, - 0,0,2454,2456,3,32,16,0,2455,2449,1,0,0,0,2455,2451,1,0,0,0,2455,2453, - 1,0,0,0,2456,267,1,0,0,0,2457,2458,5,161,0,0,2458,2459,3,124,62,0,2459, - 269,1,0,0,0,2460,2461,5,162,0,0,2461,271,1,0,0,0,2462,2463,5,163,0,0,2463, - 273,1,0,0,0,2464,2476,3,256,128,0,2465,2466,5,164,0,0,2466,2467,3,0,0, - 0,2467,2468,5,159,0,0,2468,2469,3,0,0,0,2469,2476,1,0,0,0,2470,2471,5, - 164,0,0,2471,2472,3,32,16,0,2472,2473,5,159,0,0,2473,2474,3,32,16,0,2474, - 2476,1,0,0,0,2475,2464,1,0,0,0,2475,2465,1,0,0,0,2475,2470,1,0,0,0,2476, - 275,1,0,0,0,2477,2478,3,278,139,0,2478,2479,3,282,141,0,2479,277,1,0,0, - 0,2480,2481,5,165,0,0,2481,2482,3,280,140,0,2482,2483,3,0,0,0,2483,2484, - 5,36,0,0,2484,2488,1,0,0,0,2485,2486,5,165,0,0,2486,2488,3,280,140,0,2487, - 2480,1,0,0,0,2487,2485,1,0,0,0,2488,279,1,0,0,0,2489,2493,1,0,0,0,2490, - 2493,5,166,0,0,2491,2493,5,2,0,0,2492,2489,1,0,0,0,2492,2490,1,0,0,0,2492, - 2491,1,0,0,0,2493,281,1,0,0,0,2494,2495,5,17,0,0,2495,2496,3,284,142,0, - 2496,2497,5,18,0,0,2497,2504,1,0,0,0,2498,2500,3,288,144,0,2499,2498,1, - 0,0,0,2500,2501,1,0,0,0,2501,2499,1,0,0,0,2501,2502,1,0,0,0,2502,2504, - 1,0,0,0,2503,2494,1,0,0,0,2503,2499,1,0,0,0,2504,283,1,0,0,0,2505,2506, - 3,288,144,0,2506,2507,5,28,0,0,2507,2509,1,0,0,0,2508,2505,1,0,0,0,2509, - 2512,1,0,0,0,2510,2508,1,0,0,0,2510,2511,1,0,0,0,2511,2513,1,0,0,0,2512, - 2510,1,0,0,0,2513,2514,3,288,144,0,2514,285,1,0,0,0,2515,2521,1,0,0,0, - 2516,2517,5,42,0,0,2517,2518,3,32,16,0,2518,2519,5,43,0,0,2519,2521,1, - 0,0,0,2520,2515,1,0,0,0,2520,2516,1,0,0,0,2521,287,1,0,0,0,2522,2523,5, - 181,0,0,2523,2524,5,262,0,0,2524,2525,5,30,0,0,2525,2526,3,6,3,0,2526, - 2527,5,31,0,0,2527,2589,1,0,0,0,2528,2529,5,260,0,0,2529,2530,5,30,0,0, - 2530,2531,3,0,0,0,2531,2532,5,31,0,0,2532,2589,1,0,0,0,2533,2534,5,260, - 0,0,2534,2589,3,0,0,0,2535,2536,5,84,0,0,2536,2537,5,30,0,0,2537,2538, - 3,292,146,0,2538,2539,5,31,0,0,2539,2589,1,0,0,0,2540,2541,5,188,0,0,2541, - 2542,5,30,0,0,2542,2543,3,36,18,0,2543,2544,5,31,0,0,2544,2545,3,286,143, - 0,2545,2589,1,0,0,0,2546,2547,5,189,0,0,2547,2548,5,30,0,0,2548,2549,3, - 36,18,0,2549,2550,5,31,0,0,2550,2551,3,286,143,0,2551,2589,1,0,0,0,2552, - 2553,5,187,0,0,2553,2554,5,30,0,0,2554,2555,3,34,17,0,2555,2556,5,31,0, - 0,2556,2557,3,286,143,0,2557,2589,1,0,0,0,2558,2559,5,186,0,0,2559,2560, - 5,30,0,0,2560,2561,3,32,16,0,2561,2562,5,31,0,0,2562,2563,3,286,143,0, - 2563,2589,1,0,0,0,2564,2565,5,185,0,0,2565,2566,5,30,0,0,2566,2567,3,32, - 16,0,2567,2568,5,31,0,0,2568,2569,3,286,143,0,2569,2589,1,0,0,0,2570,2571, - 5,184,0,0,2571,2572,5,30,0,0,2572,2573,3,32,16,0,2573,2574,5,31,0,0,2574, - 2575,3,286,143,0,2575,2589,1,0,0,0,2576,2577,5,188,0,0,2577,2589,3,286, - 143,0,2578,2579,5,189,0,0,2579,2589,3,286,143,0,2580,2581,5,187,0,0,2581, - 2589,3,286,143,0,2582,2583,5,186,0,0,2583,2589,3,286,143,0,2584,2585,5, - 185,0,0,2585,2589,3,286,143,0,2586,2587,5,184,0,0,2587,2589,3,286,143, - 0,2588,2522,1,0,0,0,2588,2528,1,0,0,0,2588,2533,1,0,0,0,2588,2535,1,0, - 0,0,2588,2540,1,0,0,0,2588,2546,1,0,0,0,2588,2552,1,0,0,0,2588,2558,1, - 0,0,0,2588,2564,1,0,0,0,2588,2570,1,0,0,0,2588,2576,1,0,0,0,2588,2578, - 1,0,0,0,2588,2580,1,0,0,0,2588,2582,1,0,0,0,2588,2584,1,0,0,0,2588,2586, - 1,0,0,0,2589,289,1,0,0,0,2590,2591,5,188,0,0,2591,2592,5,30,0,0,2592,2593, - 3,36,18,0,2593,2594,5,31,0,0,2594,2666,1,0,0,0,2595,2596,5,189,0,0,2596, - 2597,5,30,0,0,2597,2598,3,36,18,0,2598,2599,5,31,0,0,2599,2666,1,0,0,0, - 2600,2601,5,188,0,0,2601,2602,5,30,0,0,2602,2603,3,32,16,0,2603,2604,5, - 31,0,0,2604,2666,1,0,0,0,2605,2606,5,189,0,0,2606,2607,5,30,0,0,2607,2608, - 3,34,17,0,2608,2609,5,31,0,0,2609,2666,1,0,0,0,2610,2611,5,187,0,0,2611, - 2612,5,30,0,0,2612,2613,3,34,17,0,2613,2614,5,31,0,0,2614,2666,1,0,0,0, - 2615,2616,5,186,0,0,2616,2617,5,30,0,0,2617,2618,3,32,16,0,2618,2619,5, - 31,0,0,2619,2666,1,0,0,0,2620,2621,5,185,0,0,2621,2622,5,30,0,0,2622,2623, - 3,32,16,0,2623,2624,5,31,0,0,2624,2666,1,0,0,0,2625,2626,5,184,0,0,2626, - 2627,5,30,0,0,2627,2628,3,32,16,0,2628,2629,5,31,0,0,2629,2666,1,0,0,0, - 2630,2631,5,193,0,0,2631,2632,5,30,0,0,2632,2633,3,34,17,0,2633,2634,5, - 31,0,0,2634,2666,1,0,0,0,2635,2636,5,192,0,0,2636,2637,5,30,0,0,2637,2638, - 3,32,16,0,2638,2639,5,31,0,0,2639,2666,1,0,0,0,2640,2641,5,191,0,0,2641, - 2642,5,30,0,0,2642,2643,3,32,16,0,2643,2644,5,31,0,0,2644,2666,1,0,0,0, - 2645,2646,5,190,0,0,2646,2647,5,30,0,0,2647,2648,3,32,16,0,2648,2649,5, - 31,0,0,2649,2666,1,0,0,0,2650,2651,5,181,0,0,2651,2652,5,30,0,0,2652,2653, - 3,32,16,0,2653,2654,5,31,0,0,2654,2666,1,0,0,0,2655,2656,5,183,0,0,2656, - 2657,5,30,0,0,2657,2658,3,162,81,0,2658,2659,5,31,0,0,2659,2666,1,0,0, - 0,2660,2661,5,84,0,0,2661,2662,5,30,0,0,2662,2663,3,292,146,0,2663,2664, - 5,31,0,0,2664,2666,1,0,0,0,2665,2590,1,0,0,0,2665,2595,1,0,0,0,2665,2600, - 1,0,0,0,2665,2605,1,0,0,0,2665,2610,1,0,0,0,2665,2615,1,0,0,0,2665,2620, - 1,0,0,0,2665,2625,1,0,0,0,2665,2630,1,0,0,0,2665,2635,1,0,0,0,2665,2640, - 1,0,0,0,2665,2645,1,0,0,0,2665,2650,1,0,0,0,2665,2655,1,0,0,0,2665,2660, - 1,0,0,0,2666,291,1,0,0,0,2667,2668,3,294,147,0,2668,2669,6,146,-1,0,2669, - 2671,1,0,0,0,2670,2667,1,0,0,0,2671,2674,1,0,0,0,2672,2670,1,0,0,0,2672, - 2673,1,0,0,0,2673,293,1,0,0,0,2674,2672,1,0,0,0,2675,2676,7,12,0,0,2676, - 295,1,0,0,0,2677,2681,3,290,145,0,2678,2681,3,6,3,0,2679,2681,5,179,0, - 0,2680,2677,1,0,0,0,2680,2678,1,0,0,0,2680,2679,1,0,0,0,2681,297,1,0,0, - 0,2682,2831,3,290,145,0,2683,2684,5,182,0,0,2684,2685,5,30,0,0,2685,2686, - 5,179,0,0,2686,2831,5,31,0,0,2687,2688,5,182,0,0,2688,2689,5,30,0,0,2689, - 2690,5,264,0,0,2690,2831,5,31,0,0,2691,2692,5,196,0,0,2692,2693,5,30,0, - 0,2693,2694,5,39,0,0,2694,2695,5,264,0,0,2695,2831,5,31,0,0,2696,2697, - 5,196,0,0,2697,2698,5,30,0,0,2698,2699,3,116,58,0,2699,2700,5,31,0,0,2700, - 2831,1,0,0,0,2701,2702,5,196,0,0,2702,2703,5,30,0,0,2703,2704,5,179,0, - 0,2704,2831,5,31,0,0,2705,2706,5,197,0,0,2706,2707,5,30,0,0,2707,2708, - 3,298,149,0,2708,2709,5,31,0,0,2709,2831,1,0,0,0,2710,2711,5,188,0,0,2711, - 2712,5,42,0,0,2712,2713,3,32,16,0,2713,2714,5,43,0,0,2714,2715,5,30,0, - 0,2715,2716,3,300,150,0,2716,2717,5,31,0,0,2717,2831,1,0,0,0,2718,2719, - 5,189,0,0,2719,2720,5,42,0,0,2720,2721,3,32,16,0,2721,2722,5,43,0,0,2722, - 2723,5,30,0,0,2723,2724,3,302,151,0,2724,2725,5,31,0,0,2725,2831,1,0,0, - 0,2726,2727,5,187,0,0,2727,2728,5,42,0,0,2728,2729,3,32,16,0,2729,2730, - 5,43,0,0,2730,2731,5,30,0,0,2731,2732,3,304,152,0,2732,2733,5,31,0,0,2733, - 2831,1,0,0,0,2734,2735,5,186,0,0,2735,2736,5,42,0,0,2736,2737,3,32,16, - 0,2737,2738,5,43,0,0,2738,2739,5,30,0,0,2739,2740,3,306,153,0,2740,2741, - 5,31,0,0,2741,2831,1,0,0,0,2742,2743,5,185,0,0,2743,2744,5,42,0,0,2744, - 2745,3,32,16,0,2745,2746,5,43,0,0,2746,2747,5,30,0,0,2747,2748,3,308,154, - 0,2748,2749,5,31,0,0,2749,2831,1,0,0,0,2750,2751,5,184,0,0,2751,2752,5, - 42,0,0,2752,2753,3,32,16,0,2753,2754,5,43,0,0,2754,2755,5,30,0,0,2755, - 2756,3,310,155,0,2756,2757,5,31,0,0,2757,2831,1,0,0,0,2758,2759,5,193, - 0,0,2759,2760,5,42,0,0,2760,2761,3,32,16,0,2761,2762,5,43,0,0,2762,2763, - 5,30,0,0,2763,2764,3,304,152,0,2764,2765,5,31,0,0,2765,2831,1,0,0,0,2766, - 2767,5,192,0,0,2767,2768,5,42,0,0,2768,2769,3,32,16,0,2769,2770,5,43,0, - 0,2770,2771,5,30,0,0,2771,2772,3,306,153,0,2772,2773,5,31,0,0,2773,2831, - 1,0,0,0,2774,2775,5,191,0,0,2775,2776,5,42,0,0,2776,2777,3,32,16,0,2777, - 2778,5,43,0,0,2778,2779,5,30,0,0,2779,2780,3,308,154,0,2780,2781,5,31, - 0,0,2781,2831,1,0,0,0,2782,2783,5,190,0,0,2783,2784,5,42,0,0,2784,2785, - 3,32,16,0,2785,2786,5,43,0,0,2786,2787,5,30,0,0,2787,2788,3,310,155,0, - 2788,2789,5,31,0,0,2789,2831,1,0,0,0,2790,2791,5,181,0,0,2791,2792,5,42, - 0,0,2792,2793,3,32,16,0,2793,2794,5,43,0,0,2794,2795,5,30,0,0,2795,2796, - 3,308,154,0,2796,2797,5,31,0,0,2797,2831,1,0,0,0,2798,2799,5,183,0,0,2799, - 2800,5,42,0,0,2800,2801,3,32,16,0,2801,2802,5,43,0,0,2802,2803,5,30,0, - 0,2803,2804,3,312,156,0,2804,2805,5,31,0,0,2805,2831,1,0,0,0,2806,2807, - 5,182,0,0,2807,2808,5,42,0,0,2808,2809,3,32,16,0,2809,2810,5,43,0,0,2810, - 2811,5,30,0,0,2811,2812,3,314,157,0,2812,2813,5,31,0,0,2813,2831,1,0,0, - 0,2814,2815,5,196,0,0,2815,2816,5,42,0,0,2816,2817,3,32,16,0,2817,2818, - 5,43,0,0,2818,2819,5,30,0,0,2819,2820,3,316,158,0,2820,2821,5,31,0,0,2821, - 2831,1,0,0,0,2822,2823,5,197,0,0,2823,2824,5,42,0,0,2824,2825,3,32,16, - 0,2825,2826,5,43,0,0,2826,2827,5,30,0,0,2827,2828,3,320,160,0,2828,2829, - 5,31,0,0,2829,2831,1,0,0,0,2830,2682,1,0,0,0,2830,2683,1,0,0,0,2830,2687, - 1,0,0,0,2830,2691,1,0,0,0,2830,2696,1,0,0,0,2830,2701,1,0,0,0,2830,2705, - 1,0,0,0,2830,2710,1,0,0,0,2830,2718,1,0,0,0,2830,2726,1,0,0,0,2830,2734, - 1,0,0,0,2830,2742,1,0,0,0,2830,2750,1,0,0,0,2830,2758,1,0,0,0,2830,2766, - 1,0,0,0,2830,2774,1,0,0,0,2830,2782,1,0,0,0,2830,2790,1,0,0,0,2830,2798, - 1,0,0,0,2830,2806,1,0,0,0,2830,2814,1,0,0,0,2830,2822,1,0,0,0,2831,299, - 1,0,0,0,2832,2835,3,36,18,0,2833,2835,3,32,16,0,2834,2832,1,0,0,0,2834, - 2833,1,0,0,0,2835,2838,1,0,0,0,2836,2834,1,0,0,0,2836,2837,1,0,0,0,2837, - 301,1,0,0,0,2838,2836,1,0,0,0,2839,2842,3,36,18,0,2840,2842,3,34,17,0, - 2841,2839,1,0,0,0,2841,2840,1,0,0,0,2842,2845,1,0,0,0,2843,2841,1,0,0, - 0,2843,2844,1,0,0,0,2844,303,1,0,0,0,2845,2843,1,0,0,0,2846,2848,3,34, - 17,0,2847,2846,1,0,0,0,2848,2851,1,0,0,0,2849,2847,1,0,0,0,2849,2850,1, - 0,0,0,2850,305,1,0,0,0,2851,2849,1,0,0,0,2852,2854,3,32,16,0,2853,2852, - 1,0,0,0,2854,2857,1,0,0,0,2855,2853,1,0,0,0,2855,2856,1,0,0,0,2856,307, - 1,0,0,0,2857,2855,1,0,0,0,2858,2860,3,32,16,0,2859,2858,1,0,0,0,2860,2863, - 1,0,0,0,2861,2859,1,0,0,0,2861,2862,1,0,0,0,2862,309,1,0,0,0,2863,2861, - 1,0,0,0,2864,2866,3,32,16,0,2865,2864,1,0,0,0,2866,2869,1,0,0,0,2867,2865, - 1,0,0,0,2867,2868,1,0,0,0,2868,311,1,0,0,0,2869,2867,1,0,0,0,2870,2872, - 3,162,81,0,2871,2870,1,0,0,0,2872,2875,1,0,0,0,2873,2871,1,0,0,0,2873, - 2874,1,0,0,0,2874,313,1,0,0,0,2875,2873,1,0,0,0,2876,2878,7,13,0,0,2877, - 2876,1,0,0,0,2878,2881,1,0,0,0,2879,2877,1,0,0,0,2879,2880,1,0,0,0,2880, - 315,1,0,0,0,2881,2879,1,0,0,0,2882,2884,3,318,159,0,2883,2882,1,0,0,0, - 2884,2887,1,0,0,0,2885,2883,1,0,0,0,2885,2886,1,0,0,0,2886,317,1,0,0,0, - 2887,2885,1,0,0,0,2888,2893,5,179,0,0,2889,2890,5,39,0,0,2890,2893,5,264, - 0,0,2891,2893,3,116,58,0,2892,2888,1,0,0,0,2892,2889,1,0,0,0,2892,2891, - 1,0,0,0,2893,319,1,0,0,0,2894,2896,3,298,149,0,2895,2894,1,0,0,0,2896, - 2899,1,0,0,0,2897,2895,1,0,0,0,2897,2898,1,0,0,0,2898,321,1,0,0,0,2899, - 2897,1,0,0,0,2900,2904,3,44,22,0,2901,2904,3,46,23,0,2902,2904,3,2,1,0, - 2903,2900,1,0,0,0,2903,2901,1,0,0,0,2903,2902,1,0,0,0,2904,323,1,0,0,0, - 2905,2906,7,14,0,0,2906,2907,5,36,0,0,2907,2908,5,30,0,0,2908,2909,3,292, - 146,0,2909,2910,5,31,0,0,2910,2931,1,0,0,0,2911,2912,5,169,0,0,2912,2913, - 3,38,19,0,2913,2914,5,75,0,0,2914,2915,3,38,19,0,2915,2916,5,75,0,0,2916, - 2917,3,38,19,0,2917,2918,5,75,0,0,2918,2919,3,38,19,0,2919,2931,1,0,0, - 0,2920,2921,5,170,0,0,2921,2931,3,6,3,0,2922,2923,5,170,0,0,2923,2924, - 5,36,0,0,2924,2925,5,30,0,0,2925,2926,3,292,146,0,2926,2927,5,31,0,0,2927, - 2931,1,0,0,0,2928,2931,3,322,161,0,2929,2931,3,40,20,0,2930,2905,1,0,0, - 0,2930,2911,1,0,0,0,2930,2920,1,0,0,0,2930,2922,1,0,0,0,2930,2928,1,0, - 0,0,2930,2929,1,0,0,0,2931,325,1,0,0,0,2932,2933,5,25,0,0,2933,2934,5, - 40,0,0,2934,2935,3,98,49,0,2935,2936,3,2,1,0,2936,2945,1,0,0,0,2937,2938, - 5,25,0,0,2938,2939,5,40,0,0,2939,2940,3,98,49,0,2940,2941,3,2,1,0,2941, - 2942,5,34,0,0,2942,2943,3,2,1,0,2943,2945,1,0,0,0,2944,2932,1,0,0,0,2944, - 2937,1,0,0,0,2945,327,1,0,0,0,2946,2948,3,330,165,0,2947,2946,1,0,0,0, - 2948,2951,1,0,0,0,2949,2947,1,0,0,0,2949,2950,1,0,0,0,2950,329,1,0,0,0, - 2951,2949,1,0,0,0,2952,2953,5,180,0,0,2953,2954,5,36,0,0,2954,2955,5,30, - 0,0,2955,2956,3,292,146,0,2956,2957,5,31,0,0,2957,2967,1,0,0,0,2958,2967, - 3,324,162,0,2959,2960,5,171,0,0,2960,2961,5,36,0,0,2961,2962,5,30,0,0, - 2962,2963,3,292,146,0,2963,2964,5,31,0,0,2964,2967,1,0,0,0,2965,2967,5, - 55,0,0,2966,2952,1,0,0,0,2966,2958,1,0,0,0,2966,2959,1,0,0,0,2966,2965, - 1,0,0,0,2967,331,1,0,0,0,2968,2969,5,50,0,0,2969,2973,5,40,0,0,2970,2972, - 3,336,168,0,2971,2970,1,0,0,0,2972,2975,1,0,0,0,2973,2971,1,0,0,0,2973, - 2974,1,0,0,0,2974,2976,1,0,0,0,2975,2973,1,0,0,0,2976,2977,3,2,1,0,2977, - 333,1,0,0,0,2978,2982,5,301,0,0,2979,2981,3,336,168,0,2980,2979,1,0,0, - 0,2981,2984,1,0,0,0,2982,2980,1,0,0,0,2982,2983,1,0,0,0,2983,2985,1,0, - 0,0,2984,2982,1,0,0,0,2985,2986,3,2,1,0,2986,335,1,0,0,0,2987,3003,5,52, - 0,0,2988,3003,5,51,0,0,2989,3003,5,172,0,0,2990,2991,5,62,0,0,2991,3003, - 5,51,0,0,2992,2993,5,62,0,0,2993,3003,5,52,0,0,2994,2995,5,62,0,0,2995, - 3003,5,63,0,0,2996,2997,5,62,0,0,2997,3003,5,64,0,0,2998,2999,5,62,0,0, - 2999,3003,5,65,0,0,3000,3001,5,62,0,0,3001,3003,5,66,0,0,3002,2987,1,0, - 0,0,3002,2988,1,0,0,0,3002,2989,1,0,0,0,3002,2990,1,0,0,0,3002,2992,1, - 0,0,0,3002,2994,1,0,0,0,3002,2996,1,0,0,0,3002,2998,1,0,0,0,3002,3000, - 1,0,0,0,3003,337,1,0,0,0,3004,3006,3,340,170,0,3005,3004,1,0,0,0,3006, - 3009,1,0,0,0,3007,3005,1,0,0,0,3007,3008,1,0,0,0,3008,339,1,0,0,0,3009, - 3007,1,0,0,0,3010,3011,5,21,0,0,3011,3024,3,2,1,0,3012,3013,5,50,0,0,3013, - 3014,5,40,0,0,3014,3024,3,118,59,0,3015,3016,5,25,0,0,3016,3017,5,40,0, - 0,3017,3024,3,2,1,0,3018,3024,3,174,87,0,3019,3020,5,50,0,0,3020,3024, - 3,32,16,0,3021,3024,3,322,161,0,3022,3024,3,40,20,0,3023,3010,1,0,0,0, - 3023,3012,1,0,0,0,3023,3015,1,0,0,0,3023,3018,1,0,0,0,3023,3019,1,0,0, - 0,3023,3021,1,0,0,0,3023,3022,1,0,0,0,3024,341,1,0,0,0,3025,3029,5,274, - 0,0,3026,3028,3,344,172,0,3027,3026,1,0,0,0,3028,3031,1,0,0,0,3029,3027, - 1,0,0,0,3029,3030,1,0,0,0,3030,3032,1,0,0,0,3031,3029,1,0,0,0,3032,3045, - 3,2,1,0,3033,3037,5,274,0,0,3034,3036,3,344,172,0,3035,3034,1,0,0,0,3036, - 3039,1,0,0,0,3037,3035,1,0,0,0,3037,3038,1,0,0,0,3038,3040,1,0,0,0,3039, - 3037,1,0,0,0,3040,3041,3,2,1,0,3041,3042,5,34,0,0,3042,3043,3,2,1,0,3043, - 3045,1,0,0,0,3044,3025,1,0,0,0,3044,3033,1,0,0,0,3045,343,1,0,0,0,3046, - 3047,7,15,0,0,3047,345,1,0,0,0,3048,3050,3,348,174,0,3049,3048,1,0,0,0, - 3050,3053,1,0,0,0,3051,3049,1,0,0,0,3051,3052,1,0,0,0,3052,347,1,0,0,0, - 3053,3051,1,0,0,0,3054,3055,5,21,0,0,3055,3056,3,2,1,0,3056,3057,5,44, - 0,0,3057,3058,3,32,16,0,3058,3065,1,0,0,0,3059,3060,5,25,0,0,3060,3061, - 5,40,0,0,3061,3065,3,2,1,0,3062,3065,3,322,161,0,3063,3065,3,40,20,0,3064, - 3054,1,0,0,0,3064,3059,1,0,0,0,3064,3062,1,0,0,0,3064,3063,1,0,0,0,3065, - 349,1,0,0,0,175,360,368,377,386,439,480,489,519,523,541,568,591,627,637, + 1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162,3,162,3080,8,162, + 1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163, + 3,163,3094,8,163,1,164,5,164,3097,8,164,10,164,12,164,3100,9,164,1,165, + 1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165, + 1,165,3,165,3116,8,165,1,166,1,166,1,166,5,166,3121,8,166,10,166,12,166, + 3124,9,166,1,166,1,166,1,167,1,167,5,167,3130,8,167,10,167,12,167,3133, + 9,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,168,1,168,1,168,1,168,3,168,3152,8,168,1,169,5,169,3155, + 8,169,10,169,12,169,3158,9,169,1,170,1,170,1,170,1,170,1,170,1,170,1,170, + 1,170,1,170,1,170,1,170,1,170,1,170,3,170,3173,8,170,1,171,1,171,5,171, + 3177,8,171,10,171,12,171,3180,9,171,1,171,1,171,1,171,5,171,3185,8,171, + 10,171,12,171,3188,9,171,1,171,1,171,1,171,1,171,3,171,3194,8,171,1,172, + 1,172,1,173,5,173,3199,8,173,10,173,12,173,3202,9,173,1,174,1,174,1,174, + 1,174,1,174,1,174,1,174,1,174,1,174,1,174,3,174,3214,8,174,1,174,0,1,68, + 175,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,0,15,6,0,1,15,199,199,243,243,247,247,264,264,289,289,5,0,16,16,199, + 199,243,243,264,264,288,289,1,0,263,264,1,0,173,174,1,0,37,38,1,0,73,74, + 3,0,2,2,61,61,77,83,2,0,229,229,260,261,1,0,95,96,1,0,97,111,1,0,68,69, + 2,0,173,173,289,290,2,0,179,179,264,264,1,0,167,168,1,0,51,52,3682,0,350, + 1,0,0,0,2,368,1,0,0,0,4,370,1,0,0,0,6,377,1,0,0,0,8,386,1,0,0,0,10,439, + 1,0,0,0,12,441,1,0,0,0,14,444,1,0,0,0,16,447,1,0,0,0,18,451,1,0,0,0,20, + 454,1,0,0,0,22,457,1,0,0,0,24,464,1,0,0,0,26,480,1,0,0,0,28,482,1,0,0, + 0,30,484,1,0,0,0,32,494,1,0,0,0,34,496,1,0,0,0,36,519,1,0,0,0,38,523,1, + 0,0,0,40,541,1,0,0,0,42,568,1,0,0,0,44,591,1,0,0,0,46,627,1,0,0,0,48,629, + 1,0,0,0,50,637,1,0,0,0,52,639,1,0,0,0,54,646,1,0,0,0,56,658,1,0,0,0,58, + 661,1,0,0,0,60,663,1,0,0,0,62,676,1,0,0,0,64,684,1,0,0,0,66,686,1,0,0, + 0,68,694,1,0,0,0,70,710,1,0,0,0,72,716,1,0,0,0,74,719,1,0,0,0,76,768,1, + 0,0,0,78,773,1,0,0,0,80,778,1,0,0,0,82,783,1,0,0,0,84,791,1,0,0,0,86,796, + 1,0,0,0,88,901,1,0,0,0,90,929,1,0,0,0,92,931,1,0,0,0,94,935,1,0,0,0,96, + 937,1,0,0,0,98,942,1,0,0,0,100,970,1,0,0,0,102,1050,1,0,0,0,104,1052,1, + 0,0,0,106,1081,1,0,0,0,108,1083,1,0,0,0,110,1097,1,0,0,0,112,1126,1,0, + 0,0,114,1138,1,0,0,0,116,1177,1,0,0,0,118,1185,1,0,0,0,120,1194,1,0,0, + 0,122,1202,1,0,0,0,124,1221,1,0,0,0,126,1234,1,0,0,0,128,1258,1,0,0,0, + 130,1405,1,0,0,0,132,1415,1,0,0,0,134,1427,1,0,0,0,136,1509,1,0,0,0,138, + 1511,1,0,0,0,140,1550,1,0,0,0,142,1610,1,0,0,0,144,1650,1,0,0,0,146,1666, + 1,0,0,0,148,1668,1,0,0,0,150,1672,1,0,0,0,152,1727,1,0,0,0,154,1739,1, + 0,0,0,156,1754,1,0,0,0,158,1761,1,0,0,0,160,1766,1,0,0,0,162,1770,1,0, + 0,0,164,1806,1,0,0,0,166,1808,1,0,0,0,168,1852,1,0,0,0,170,1871,1,0,0, + 0,172,1892,1,0,0,0,174,1894,1,0,0,0,176,1911,1,0,0,0,178,1926,1,0,0,0, + 180,1933,1,0,0,0,182,1943,1,0,0,0,184,1956,1,0,0,0,186,1961,1,0,0,0,188, + 1964,1,0,0,0,190,1975,1,0,0,0,192,1980,1,0,0,0,194,1985,1,0,0,0,196,1989, + 1,0,0,0,198,2112,1,0,0,0,200,2114,1,0,0,0,202,2151,1,0,0,0,204,2158,1, + 0,0,0,206,2163,1,0,0,0,208,2170,1,0,0,0,210,2190,1,0,0,0,212,2192,1,0, + 0,0,214,2197,1,0,0,0,216,2212,1,0,0,0,218,2214,1,0,0,0,220,2227,1,0,0, + 0,222,2232,1,0,0,0,224,2245,1,0,0,0,226,2254,1,0,0,0,228,2269,1,0,0,0, + 230,2276,1,0,0,0,232,2296,1,0,0,0,234,2298,1,0,0,0,236,2342,1,0,0,0,238, + 2362,1,0,0,0,240,2391,1,0,0,0,242,2400,1,0,0,0,244,2423,1,0,0,0,246,2428, + 1,0,0,0,248,2448,1,0,0,0,250,2548,1,0,0,0,252,2550,1,0,0,0,254,2556,1, + 0,0,0,256,2558,1,0,0,0,258,2562,1,0,0,0,260,2566,1,0,0,0,262,2582,1,0, + 0,0,264,2596,1,0,0,0,266,2604,1,0,0,0,268,2606,1,0,0,0,270,2609,1,0,0, + 0,272,2611,1,0,0,0,274,2624,1,0,0,0,276,2626,1,0,0,0,278,2636,1,0,0,0, + 280,2641,1,0,0,0,282,2652,1,0,0,0,284,2659,1,0,0,0,286,2669,1,0,0,0,288, + 2737,1,0,0,0,290,2814,1,0,0,0,292,2821,1,0,0,0,294,2824,1,0,0,0,296,2829, + 1,0,0,0,298,2979,1,0,0,0,300,2985,1,0,0,0,302,2992,1,0,0,0,304,2998,1, + 0,0,0,306,3004,1,0,0,0,308,3010,1,0,0,0,310,3016,1,0,0,0,312,3022,1,0, + 0,0,314,3028,1,0,0,0,316,3034,1,0,0,0,318,3041,1,0,0,0,320,3046,1,0,0, + 0,322,3052,1,0,0,0,324,3079,1,0,0,0,326,3093,1,0,0,0,328,3098,1,0,0,0, + 330,3115,1,0,0,0,332,3117,1,0,0,0,334,3127,1,0,0,0,336,3151,1,0,0,0,338, + 3156,1,0,0,0,340,3172,1,0,0,0,342,3193,1,0,0,0,344,3195,1,0,0,0,346,3200, + 1,0,0,0,348,3213,1,0,0,0,350,351,7,0,0,0,351,1,1,0,0,0,352,353,5,288,0, + 0,353,369,6,1,-1,0,354,355,3,4,2,0,355,356,6,1,-1,0,356,357,5,265,0,0, + 357,359,1,0,0,0,358,354,1,0,0,0,359,362,1,0,0,0,360,358,1,0,0,0,360,361, + 1,0,0,0,361,363,1,0,0,0,362,360,1,0,0,0,363,364,3,4,2,0,364,365,6,1,-1, + 0,365,369,1,0,0,0,366,367,5,264,0,0,367,369,6,1,-1,0,368,352,1,0,0,0,368, + 360,1,0,0,0,368,366,1,0,0,0,369,3,1,0,0,0,370,371,7,1,0,0,371,5,1,0,0, + 0,372,373,5,263,0,0,373,374,6,3,-1,0,374,376,5,266,0,0,375,372,1,0,0,0, + 376,379,1,0,0,0,377,375,1,0,0,0,377,378,1,0,0,0,378,380,1,0,0,0,379,377, + 1,0,0,0,380,381,5,263,0,0,381,382,6,3,-1,0,382,7,1,0,0,0,383,385,3,10, + 5,0,384,383,1,0,0,0,385,388,1,0,0,0,386,384,1,0,0,0,386,387,1,0,0,0,387, + 9,1,0,0,0,388,386,1,0,0,0,389,390,3,74,37,0,390,391,5,17,0,0,391,392,3, + 82,41,0,392,393,5,18,0,0,393,440,1,0,0,0,394,395,3,72,36,0,395,396,5,17, + 0,0,396,397,3,8,4,0,397,398,5,18,0,0,398,440,1,0,0,0,399,400,3,234,117, + 0,400,401,5,17,0,0,401,402,3,246,123,0,402,403,5,18,0,0,403,440,1,0,0, + 0,404,440,3,200,100,0,405,440,3,276,138,0,406,440,3,70,35,0,407,440,3, + 66,33,0,408,440,3,88,44,0,409,440,3,90,45,0,410,440,3,22,11,0,411,412, + 3,326,163,0,412,413,5,17,0,0,413,414,3,328,164,0,414,415,5,18,0,0,415, + 440,1,0,0,0,416,417,3,332,166,0,417,418,5,17,0,0,418,419,3,338,169,0,419, + 420,5,18,0,0,420,440,1,0,0,0,421,422,3,342,171,0,422,423,5,17,0,0,423, + 424,3,346,173,0,424,425,5,18,0,0,425,440,1,0,0,0,426,440,3,64,32,0,427, + 440,3,152,76,0,428,440,3,322,161,0,429,440,3,12,6,0,430,440,3,14,7,0,431, + 440,3,16,8,0,432,440,3,18,9,0,433,440,3,20,10,0,434,440,3,26,13,0,435, + 440,3,42,21,0,436,440,3,40,20,0,437,440,3,30,15,0,438,440,3,24,12,0,439, + 389,1,0,0,0,439,394,1,0,0,0,439,399,1,0,0,0,439,404,1,0,0,0,439,405,1, + 0,0,0,439,406,1,0,0,0,439,407,1,0,0,0,439,408,1,0,0,0,439,409,1,0,0,0, + 439,410,1,0,0,0,439,411,1,0,0,0,439,416,1,0,0,0,439,421,1,0,0,0,439,426, + 1,0,0,0,439,427,1,0,0,0,439,428,1,0,0,0,439,429,1,0,0,0,439,430,1,0,0, + 0,439,431,1,0,0,0,439,432,1,0,0,0,439,433,1,0,0,0,439,434,1,0,0,0,439, + 435,1,0,0,0,439,436,1,0,0,0,439,437,1,0,0,0,439,438,1,0,0,0,440,11,1,0, + 0,0,441,442,5,19,0,0,442,443,3,32,16,0,443,13,1,0,0,0,444,445,5,20,0,0, + 445,446,3,32,16,0,446,15,1,0,0,0,447,448,5,21,0,0,448,449,5,22,0,0,449, + 450,3,32,16,0,450,17,1,0,0,0,451,452,5,23,0,0,452,453,3,34,17,0,453,19, + 1,0,0,0,454,455,5,24,0,0,455,456,3,34,17,0,456,21,1,0,0,0,457,458,5,25, + 0,0,458,459,3,98,49,0,459,460,3,2,1,0,460,461,5,17,0,0,461,462,3,120,60, + 0,462,463,5,18,0,0,463,23,1,0,0,0,464,465,5,26,0,0,465,25,1,0,0,0,466, + 467,5,27,0,0,467,481,3,28,14,0,468,469,5,27,0,0,469,470,3,28,14,0,470, + 471,5,28,0,0,471,472,3,28,14,0,472,481,1,0,0,0,473,474,5,27,0,0,474,475, + 3,28,14,0,475,476,5,28,0,0,476,477,3,28,14,0,477,478,5,28,0,0,478,479, + 3,28,14,0,479,481,1,0,0,0,480,466,1,0,0,0,480,468,1,0,0,0,480,473,1,0, + 0,0,481,27,1,0,0,0,482,483,7,2,0,0,483,29,1,0,0,0,484,485,5,29,0,0,485, + 489,5,17,0,0,486,488,3,116,58,0,487,486,1,0,0,0,488,491,1,0,0,0,489,487, + 1,0,0,0,489,490,1,0,0,0,490,492,1,0,0,0,491,489,1,0,0,0,492,493,5,18,0, + 0,493,31,1,0,0,0,494,495,5,173,0,0,495,33,1,0,0,0,496,497,7,3,0,0,497, + 35,1,0,0,0,498,499,5,175,0,0,499,520,6,18,-1,0,500,501,3,32,16,0,501,502, + 5,265,0,0,502,503,6,18,-1,0,503,520,1,0,0,0,504,505,3,32,16,0,505,506, + 6,18,-1,0,506,520,1,0,0,0,507,508,5,188,0,0,508,509,5,30,0,0,509,510,3, + 32,16,0,510,511,5,31,0,0,511,512,6,18,-1,0,512,520,1,0,0,0,513,514,5,189, + 0,0,514,515,5,30,0,0,515,516,3,34,17,0,516,517,5,31,0,0,517,518,6,18,-1, + 0,518,520,1,0,0,0,519,498,1,0,0,0,519,500,1,0,0,0,519,504,1,0,0,0,519, + 507,1,0,0,0,519,513,1,0,0,0,520,37,1,0,0,0,521,524,3,32,16,0,522,524,5, + 262,0,0,523,521,1,0,0,0,523,522,1,0,0,0,524,39,1,0,0,0,525,526,5,267,0, + 0,526,542,5,289,0,0,527,528,5,267,0,0,528,529,5,289,0,0,529,542,5,263, + 0,0,530,531,5,268,0,0,531,542,5,289,0,0,532,533,5,269,0,0,533,542,5,289, + 0,0,534,535,5,270,0,0,535,542,5,289,0,0,536,542,5,271,0,0,537,542,5,272, + 0,0,538,539,5,273,0,0,539,542,5,263,0,0,540,542,5,32,0,0,541,525,1,0,0, + 0,541,527,1,0,0,0,541,530,1,0,0,0,541,532,1,0,0,0,541,534,1,0,0,0,541, + 536,1,0,0,0,541,537,1,0,0,0,541,538,1,0,0,0,541,540,1,0,0,0,542,41,1,0, + 0,0,543,544,5,33,0,0,544,545,3,138,69,0,545,546,5,34,0,0,546,547,3,2,1, + 0,547,569,1,0,0,0,548,549,5,33,0,0,549,550,3,116,58,0,550,551,5,34,0,0, + 551,552,3,2,1,0,552,569,1,0,0,0,553,554,5,33,0,0,554,555,3,176,88,0,555, + 556,5,34,0,0,556,557,3,2,1,0,557,569,1,0,0,0,558,559,5,33,0,0,559,560, + 3,44,22,0,560,561,5,34,0,0,561,562,3,2,1,0,562,569,1,0,0,0,563,564,5,33, + 0,0,564,565,3,46,23,0,565,566,5,34,0,0,566,567,3,2,1,0,567,569,1,0,0,0, + 568,543,1,0,0,0,568,548,1,0,0,0,568,553,1,0,0,0,568,558,1,0,0,0,568,563, + 1,0,0,0,569,43,1,0,0,0,570,571,5,35,0,0,571,592,3,48,24,0,572,573,5,35, + 0,0,573,574,3,48,24,0,574,575,5,36,0,0,575,576,3,6,3,0,576,592,1,0,0,0, + 577,578,5,35,0,0,578,579,3,48,24,0,579,580,5,36,0,0,580,581,5,17,0,0,581, + 582,3,52,26,0,582,583,5,18,0,0,583,592,1,0,0,0,584,585,5,35,0,0,585,586, + 3,48,24,0,586,587,5,36,0,0,587,588,5,30,0,0,588,589,3,292,146,0,589,590, + 5,31,0,0,590,592,1,0,0,0,591,570,1,0,0,0,591,572,1,0,0,0,591,577,1,0,0, + 0,591,584,1,0,0,0,592,45,1,0,0,0,593,594,5,35,0,0,594,595,5,30,0,0,595, + 596,3,50,25,0,596,597,5,31,0,0,597,598,3,48,24,0,598,628,1,0,0,0,599,600, + 5,35,0,0,600,601,5,30,0,0,601,602,3,50,25,0,602,603,5,31,0,0,603,604,3, + 48,24,0,604,605,5,36,0,0,605,606,3,6,3,0,606,628,1,0,0,0,607,608,5,35, + 0,0,608,609,5,30,0,0,609,610,3,50,25,0,610,611,5,31,0,0,611,612,3,48,24, + 0,612,613,5,36,0,0,613,614,5,17,0,0,614,615,3,52,26,0,615,616,5,18,0,0, + 616,628,1,0,0,0,617,618,5,35,0,0,618,619,5,30,0,0,619,620,3,50,25,0,620, + 621,5,31,0,0,621,622,3,48,24,0,622,623,5,36,0,0,623,624,5,30,0,0,624,625, + 3,292,146,0,625,626,5,31,0,0,626,628,1,0,0,0,627,593,1,0,0,0,627,599,1, + 0,0,0,627,607,1,0,0,0,627,617,1,0,0,0,628,47,1,0,0,0,629,630,3,168,84, + 0,630,49,1,0,0,0,631,632,3,124,62,0,632,633,6,25,-1,0,633,638,1,0,0,0, + 634,635,3,176,88,0,635,636,6,25,-1,0,636,638,1,0,0,0,637,631,1,0,0,0,637, + 634,1,0,0,0,638,51,1,0,0,0,639,640,3,54,27,0,640,641,3,56,28,0,641,53, + 1,0,0,0,642,645,3,298,149,0,643,645,3,40,20,0,644,642,1,0,0,0,644,643, + 1,0,0,0,645,648,1,0,0,0,646,644,1,0,0,0,646,647,1,0,0,0,647,55,1,0,0,0, + 648,646,1,0,0,0,649,650,3,58,29,0,650,651,3,60,30,0,651,652,3,2,1,0,652, + 653,5,36,0,0,653,654,3,298,149,0,654,657,1,0,0,0,655,657,3,40,20,0,656, + 649,1,0,0,0,656,655,1,0,0,0,657,660,1,0,0,0,658,656,1,0,0,0,658,659,1, + 0,0,0,659,57,1,0,0,0,660,658,1,0,0,0,661,662,7,4,0,0,662,59,1,0,0,0,663, + 665,3,62,31,0,664,666,5,261,0,0,665,664,1,0,0,0,665,666,1,0,0,0,666,61, + 1,0,0,0,667,677,3,144,72,0,668,677,3,2,1,0,669,677,5,196,0,0,670,677,5, + 197,0,0,671,672,5,202,0,0,672,673,5,39,0,0,673,677,5,264,0,0,674,675,5, + 202,0,0,675,677,3,116,58,0,676,667,1,0,0,0,676,668,1,0,0,0,676,669,1,0, + 0,0,676,670,1,0,0,0,676,671,1,0,0,0,676,674,1,0,0,0,677,63,1,0,0,0,678, + 679,5,198,0,0,679,680,5,40,0,0,680,685,3,2,1,0,681,682,5,198,0,0,682,685, + 3,2,1,0,683,685,5,198,0,0,684,678,1,0,0,0,684,681,1,0,0,0,684,683,1,0, + 0,0,685,65,1,0,0,0,686,687,5,41,0,0,687,688,5,42,0,0,688,689,3,32,16,0, + 689,690,5,43,0,0,690,691,3,68,34,0,691,692,5,44,0,0,692,693,3,0,0,0,693, + 67,1,0,0,0,694,707,6,34,-1,0,695,696,10,5,0,0,696,706,5,186,0,0,697,698, + 10,4,0,0,698,706,5,187,0,0,699,700,10,3,0,0,700,706,5,45,0,0,701,702,10, + 2,0,0,702,706,5,46,0,0,703,704,10,1,0,0,704,706,5,47,0,0,705,695,1,0,0, + 0,705,697,1,0,0,0,705,699,1,0,0,0,705,701,1,0,0,0,705,703,1,0,0,0,706, + 709,1,0,0,0,707,705,1,0,0,0,707,708,1,0,0,0,708,69,1,0,0,0,709,707,1,0, + 0,0,710,711,5,48,0,0,711,712,5,36,0,0,712,713,5,30,0,0,713,714,3,292,146, + 0,714,715,5,31,0,0,715,71,1,0,0,0,716,717,5,49,0,0,717,718,3,2,1,0,718, + 73,1,0,0,0,719,723,5,50,0,0,720,722,3,76,38,0,721,720,1,0,0,0,722,725, + 1,0,0,0,723,721,1,0,0,0,723,724,1,0,0,0,724,726,1,0,0,0,725,723,1,0,0, + 0,726,727,3,2,1,0,727,728,3,182,91,0,728,729,3,78,39,0,729,730,3,80,40, + 0,730,75,1,0,0,0,731,769,5,51,0,0,732,769,5,52,0,0,733,769,5,199,0,0,734, + 769,5,202,0,0,735,769,5,221,0,0,736,769,5,53,0,0,737,769,5,54,0,0,738, + 769,5,55,0,0,739,769,5,56,0,0,740,769,5,244,0,0,741,769,5,15,0,0,742,769, + 5,224,0,0,743,769,5,57,0,0,744,769,5,58,0,0,745,769,5,59,0,0,746,769,5, + 60,0,0,747,769,5,61,0,0,748,749,5,62,0,0,749,769,5,51,0,0,750,751,5,62, + 0,0,751,769,5,52,0,0,752,753,5,62,0,0,753,769,5,63,0,0,754,755,5,62,0, + 0,755,769,5,64,0,0,756,757,5,62,0,0,757,769,5,65,0,0,758,759,5,62,0,0, + 759,769,5,66,0,0,760,769,5,67,0,0,761,769,5,68,0,0,762,769,5,69,0,0,763, + 764,5,70,0,0,764,765,5,30,0,0,765,766,3,32,16,0,766,767,5,31,0,0,767,769, + 1,0,0,0,768,731,1,0,0,0,768,732,1,0,0,0,768,733,1,0,0,0,768,734,1,0,0, + 0,768,735,1,0,0,0,768,736,1,0,0,0,768,737,1,0,0,0,768,738,1,0,0,0,768, + 739,1,0,0,0,768,740,1,0,0,0,768,741,1,0,0,0,768,742,1,0,0,0,768,743,1, + 0,0,0,768,744,1,0,0,0,768,745,1,0,0,0,768,746,1,0,0,0,768,747,1,0,0,0, + 768,748,1,0,0,0,768,750,1,0,0,0,768,752,1,0,0,0,768,754,1,0,0,0,768,756, + 1,0,0,0,768,758,1,0,0,0,768,760,1,0,0,0,768,761,1,0,0,0,768,762,1,0,0, + 0,768,763,1,0,0,0,769,77,1,0,0,0,770,774,1,0,0,0,771,772,5,71,0,0,772, + 774,3,124,62,0,773,770,1,0,0,0,773,771,1,0,0,0,774,79,1,0,0,0,775,779, + 1,0,0,0,776,777,5,72,0,0,777,779,3,84,42,0,778,775,1,0,0,0,778,776,1,0, + 0,0,779,81,1,0,0,0,780,782,3,198,99,0,781,780,1,0,0,0,782,785,1,0,0,0, + 783,781,1,0,0,0,783,784,1,0,0,0,784,83,1,0,0,0,785,783,1,0,0,0,786,787, + 3,124,62,0,787,788,5,28,0,0,788,790,1,0,0,0,789,786,1,0,0,0,790,793,1, + 0,0,0,791,789,1,0,0,0,791,792,1,0,0,0,792,794,1,0,0,0,793,791,1,0,0,0, + 794,795,3,124,62,0,795,85,1,0,0,0,796,797,7,5,0,0,797,87,1,0,0,0,798,799, + 3,86,43,0,799,800,3,32,16,0,800,801,5,264,0,0,801,902,1,0,0,0,802,803, + 3,86,43,0,803,804,3,32,16,0,804,902,1,0,0,0,805,806,3,86,43,0,806,807, + 3,32,16,0,807,808,5,75,0,0,808,809,3,32,16,0,809,810,5,264,0,0,810,902, + 1,0,0,0,811,812,3,86,43,0,812,813,3,32,16,0,813,814,5,75,0,0,814,815,3, + 32,16,0,815,902,1,0,0,0,816,817,3,86,43,0,817,818,3,32,16,0,818,819,5, + 75,0,0,819,820,3,32,16,0,820,821,5,28,0,0,821,822,3,32,16,0,822,823,5, + 264,0,0,823,902,1,0,0,0,824,825,3,86,43,0,825,826,3,32,16,0,826,827,5, + 75,0,0,827,828,3,32,16,0,828,829,5,28,0,0,829,830,3,32,16,0,830,902,1, + 0,0,0,831,832,3,86,43,0,832,833,3,32,16,0,833,834,5,28,0,0,834,835,3,32, + 16,0,835,836,5,75,0,0,836,837,3,32,16,0,837,838,5,264,0,0,838,902,1,0, + 0,0,839,840,3,86,43,0,840,841,3,32,16,0,841,842,5,28,0,0,842,843,3,32, + 16,0,843,844,5,75,0,0,844,845,3,32,16,0,845,902,1,0,0,0,846,847,3,86,43, + 0,847,848,3,32,16,0,848,849,5,28,0,0,849,850,3,32,16,0,850,851,5,75,0, + 0,851,852,3,32,16,0,852,853,5,28,0,0,853,854,3,32,16,0,854,855,5,264,0, + 0,855,902,1,0,0,0,856,857,3,86,43,0,857,858,3,32,16,0,858,859,5,28,0,0, + 859,860,3,32,16,0,860,861,5,75,0,0,861,862,3,32,16,0,862,863,5,28,0,0, + 863,864,3,32,16,0,864,902,1,0,0,0,865,866,3,86,43,0,866,867,3,32,16,0, + 867,868,5,263,0,0,868,902,1,0,0,0,869,870,3,86,43,0,870,871,3,32,16,0, + 871,872,5,75,0,0,872,873,3,32,16,0,873,874,5,263,0,0,874,902,1,0,0,0,875, + 876,3,86,43,0,876,877,3,32,16,0,877,878,5,75,0,0,878,879,3,32,16,0,879, + 880,5,28,0,0,880,881,3,32,16,0,881,882,5,263,0,0,882,902,1,0,0,0,883,884, + 3,86,43,0,884,885,3,32,16,0,885,886,5,28,0,0,886,887,3,32,16,0,887,888, + 5,75,0,0,888,889,3,32,16,0,889,890,5,263,0,0,890,902,1,0,0,0,891,892,3, + 86,43,0,892,893,3,32,16,0,893,894,5,28,0,0,894,895,3,32,16,0,895,896,5, + 75,0,0,896,897,3,32,16,0,897,898,5,28,0,0,898,899,3,32,16,0,899,900,5, + 263,0,0,900,902,1,0,0,0,901,798,1,0,0,0,901,802,1,0,0,0,901,805,1,0,0, + 0,901,811,1,0,0,0,901,816,1,0,0,0,901,824,1,0,0,0,901,831,1,0,0,0,901, + 839,1,0,0,0,901,846,1,0,0,0,901,856,1,0,0,0,901,865,1,0,0,0,901,869,1, + 0,0,0,901,875,1,0,0,0,901,883,1,0,0,0,901,891,1,0,0,0,902,89,1,0,0,0,903, + 907,5,21,0,0,904,906,3,92,46,0,905,904,1,0,0,0,906,909,1,0,0,0,907,905, + 1,0,0,0,907,908,1,0,0,0,908,910,1,0,0,0,909,907,1,0,0,0,910,911,3,2,1, + 0,911,912,3,94,47,0,912,913,5,180,0,0,913,914,5,36,0,0,914,915,5,30,0, + 0,915,916,3,292,146,0,916,917,5,31,0,0,917,918,3,94,47,0,918,930,1,0,0, + 0,919,923,5,21,0,0,920,922,3,92,46,0,921,920,1,0,0,0,922,925,1,0,0,0,923, + 921,1,0,0,0,923,924,1,0,0,0,924,926,1,0,0,0,925,923,1,0,0,0,926,927,3, + 2,1,0,927,928,3,94,47,0,928,930,1,0,0,0,929,903,1,0,0,0,929,919,1,0,0, + 0,930,91,1,0,0,0,931,932,5,76,0,0,932,93,1,0,0,0,933,936,1,0,0,0,934,936, + 5,298,0,0,935,933,1,0,0,0,935,934,1,0,0,0,936,95,1,0,0,0,937,938,7,6,0, + 0,938,97,1,0,0,0,939,941,3,96,48,0,940,939,1,0,0,0,941,944,1,0,0,0,942, + 940,1,0,0,0,942,943,1,0,0,0,943,99,1,0,0,0,944,942,1,0,0,0,945,971,3,102, + 51,0,946,947,5,280,0,0,947,948,3,168,84,0,948,949,6,50,-1,0,949,971,1, + 0,0,0,950,951,5,286,0,0,951,952,3,178,89,0,952,953,6,50,-1,0,953,971,1, + 0,0,0,954,955,5,286,0,0,955,956,3,174,87,0,956,957,6,50,-1,0,957,971,1, + 0,0,0,958,959,5,284,0,0,959,960,3,124,62,0,960,961,6,50,-1,0,961,971,1, + 0,0,0,962,963,5,281,0,0,963,964,3,104,52,0,964,965,6,50,-1,0,965,971,1, + 0,0,0,966,967,5,287,0,0,967,968,3,50,25,0,968,969,6,50,-1,0,969,971,1, + 0,0,0,970,945,1,0,0,0,970,946,1,0,0,0,970,950,1,0,0,0,970,954,1,0,0,0, + 970,958,1,0,0,0,970,962,1,0,0,0,970,966,1,0,0,0,971,101,1,0,0,0,972,973, + 5,275,0,0,973,1051,6,51,-1,0,974,975,5,276,0,0,975,976,3,32,16,0,976,977, + 6,51,-1,0,977,1051,1,0,0,0,978,979,5,276,0,0,979,980,3,0,0,0,980,981,6, + 51,-1,0,981,1051,1,0,0,0,982,983,5,277,0,0,983,984,3,32,16,0,984,985,6, + 51,-1,0,985,1051,1,0,0,0,986,987,5,278,0,0,987,988,3,34,17,0,988,989,6, + 51,-1,0,989,1051,1,0,0,0,990,991,5,279,0,0,991,992,3,36,18,0,992,993,6, + 51,-1,0,993,1051,1,0,0,0,994,995,5,279,0,0,995,996,3,34,17,0,996,997,6, + 51,-1,0,997,1051,1,0,0,0,998,999,5,279,0,0,999,1000,5,30,0,0,1000,1001, + 3,292,146,0,1001,1002,5,31,0,0,1002,1003,6,51,-1,0,1003,1051,1,0,0,0,1004, + 1005,5,279,0,0,1005,1006,5,84,0,0,1006,1007,5,30,0,0,1007,1008,3,292,146, + 0,1008,1009,5,31,0,0,1009,1010,6,51,-1,0,1010,1051,1,0,0,0,1011,1012,5, + 282,0,0,1012,1013,3,32,16,0,1013,1014,6,51,-1,0,1014,1051,1,0,0,0,1015, + 1016,5,282,0,0,1016,1017,3,0,0,0,1017,1018,6,51,-1,0,1018,1051,1,0,0,0, + 1019,1020,5,285,0,0,1020,1021,3,6,3,0,1021,1022,6,51,-1,0,1022,1051,1, + 0,0,0,1023,1024,5,285,0,0,1024,1025,5,224,0,0,1025,1026,5,30,0,0,1026, + 1027,3,6,3,0,1027,1028,5,31,0,0,1028,1029,6,51,-1,0,1029,1051,1,0,0,0, + 1030,1031,5,285,0,0,1031,1032,5,84,0,0,1032,1033,5,30,0,0,1033,1034,3, + 292,146,0,1034,1035,5,31,0,0,1035,1036,6,51,-1,0,1036,1051,1,0,0,0,1037, + 1038,5,287,0,0,1038,1039,3,32,16,0,1039,1040,6,51,-1,0,1040,1051,1,0,0, + 0,1041,1042,5,283,0,0,1042,1048,6,51,-1,0,1043,1044,5,30,0,0,1044,1045, + 3,106,53,0,1045,1046,5,31,0,0,1046,1049,1,0,0,0,1047,1049,5,85,0,0,1048, + 1043,1,0,0,0,1048,1047,1,0,0,0,1049,1051,1,0,0,0,1050,972,1,0,0,0,1050, + 974,1,0,0,0,1050,978,1,0,0,0,1050,982,1,0,0,0,1050,986,1,0,0,0,1050,990, + 1,0,0,0,1050,994,1,0,0,0,1050,998,1,0,0,0,1050,1004,1,0,0,0,1050,1011, + 1,0,0,0,1050,1015,1,0,0,0,1050,1019,1,0,0,0,1050,1023,1,0,0,0,1050,1030, + 1,0,0,0,1050,1037,1,0,0,0,1050,1041,1,0,0,0,1051,103,1,0,0,0,1052,1053, + 3,170,85,0,1053,1054,3,138,69,0,1054,1055,3,112,56,0,1055,1056,6,52,-1, + 0,1056,105,1,0,0,0,1057,1082,1,0,0,0,1058,1059,3,0,0,0,1059,1060,6,53, + -1,0,1060,1065,1,0,0,0,1061,1062,3,32,16,0,1062,1063,6,53,-1,0,1063,1065, + 1,0,0,0,1064,1058,1,0,0,0,1064,1061,1,0,0,0,1065,1066,1,0,0,0,1066,1067, + 5,28,0,0,1067,1069,1,0,0,0,1068,1064,1,0,0,0,1069,1072,1,0,0,0,1070,1068, + 1,0,0,0,1070,1071,1,0,0,0,1071,1079,1,0,0,0,1072,1070,1,0,0,0,1073,1074, + 3,0,0,0,1074,1075,6,53,-1,0,1075,1080,1,0,0,0,1076,1077,3,32,16,0,1077, + 1078,6,53,-1,0,1078,1080,1,0,0,0,1079,1073,1,0,0,0,1079,1076,1,0,0,0,1080, + 1082,1,0,0,0,1081,1057,1,0,0,0,1081,1070,1,0,0,0,1082,107,1,0,0,0,1083, + 1090,5,86,0,0,1084,1085,3,138,69,0,1085,1086,6,54,-1,0,1086,1087,5,28, + 0,0,1087,1089,1,0,0,0,1088,1084,1,0,0,0,1089,1092,1,0,0,0,1090,1088,1, + 0,0,0,1090,1091,1,0,0,0,1091,1093,1,0,0,0,1092,1090,1,0,0,0,1093,1094, + 3,138,69,0,1094,1095,6,54,-1,0,1095,1096,5,87,0,0,1096,109,1,0,0,0,1097, + 1104,5,42,0,0,1098,1099,3,146,73,0,1099,1100,6,55,-1,0,1100,1101,5,28, + 0,0,1101,1103,1,0,0,0,1102,1098,1,0,0,0,1103,1106,1,0,0,0,1104,1102,1, + 0,0,0,1104,1105,1,0,0,0,1105,1107,1,0,0,0,1106,1104,1,0,0,0,1107,1108, + 3,146,73,0,1108,1109,6,55,-1,0,1109,1110,5,43,0,0,1110,111,1,0,0,0,1111, + 1118,5,30,0,0,1112,1113,3,114,57,0,1113,1114,6,56,-1,0,1114,1115,5,28, + 0,0,1115,1117,1,0,0,0,1116,1112,1,0,0,0,1117,1120,1,0,0,0,1118,1116,1, + 0,0,0,1118,1119,1,0,0,0,1119,1121,1,0,0,0,1120,1118,1,0,0,0,1121,1122, + 3,114,57,0,1122,1123,6,56,-1,0,1123,1124,5,31,0,0,1124,1127,1,0,0,0,1125, + 1127,5,85,0,0,1126,1111,1,0,0,0,1126,1125,1,0,0,0,1127,113,1,0,0,0,1128, + 1129,5,177,0,0,1129,1139,6,57,-1,0,1130,1131,3,230,115,0,1131,1132,3,138, + 69,0,1132,1134,3,226,113,0,1133,1135,3,0,0,0,1134,1133,1,0,0,0,1134,1135, + 1,0,0,0,1135,1136,1,0,0,0,1136,1137,6,57,-1,0,1137,1139,1,0,0,0,1138,1128, + 1,0,0,0,1138,1130,1,0,0,0,1139,115,1,0,0,0,1140,1141,5,42,0,0,1141,1142, + 3,2,1,0,1142,1143,5,43,0,0,1143,1144,3,118,59,0,1144,1145,6,58,-1,0,1145, + 1178,1,0,0,0,1146,1147,5,42,0,0,1147,1148,3,174,87,0,1148,1149,5,43,0, + 0,1149,1150,3,118,59,0,1150,1151,6,58,-1,0,1151,1178,1,0,0,0,1152,1153, + 5,42,0,0,1153,1154,5,262,0,0,1154,1155,5,43,0,0,1155,1156,3,118,59,0,1156, + 1157,6,58,-1,0,1157,1178,1,0,0,0,1158,1159,5,42,0,0,1159,1160,5,198,0, + 0,1160,1161,3,2,1,0,1161,1162,5,43,0,0,1162,1163,3,118,59,0,1163,1164, + 6,58,-1,0,1164,1178,1,0,0,0,1165,1166,3,118,59,0,1166,1167,6,58,-1,0,1167, + 1178,1,0,0,0,1168,1169,3,174,87,0,1169,1170,6,58,-1,0,1170,1178,1,0,0, + 0,1171,1172,5,257,0,0,1172,1178,6,58,-1,0,1173,1174,5,258,0,0,1174,1178, + 6,58,-1,0,1175,1176,5,259,0,0,1176,1178,6,58,-1,0,1177,1140,1,0,0,0,1177, + 1146,1,0,0,0,1177,1152,1,0,0,0,1177,1158,1,0,0,0,1177,1165,1,0,0,0,1177, + 1168,1,0,0,0,1177,1171,1,0,0,0,1177,1173,1,0,0,0,1177,1175,1,0,0,0,1178, + 117,1,0,0,0,1179,1180,3,2,1,0,1180,1181,6,59,-1,0,1181,1182,5,88,0,0,1182, + 1184,1,0,0,0,1183,1179,1,0,0,0,1184,1187,1,0,0,0,1185,1183,1,0,0,0,1185, + 1186,1,0,0,0,1186,1188,1,0,0,0,1187,1185,1,0,0,0,1188,1189,3,2,1,0,1189, + 1190,6,59,-1,0,1190,119,1,0,0,0,1191,1193,3,122,61,0,1192,1191,1,0,0,0, + 1193,1196,1,0,0,0,1194,1192,1,0,0,0,1194,1195,1,0,0,0,1195,121,1,0,0,0, + 1196,1194,1,0,0,0,1197,1198,5,180,0,0,1198,1199,5,89,0,0,1199,1203,3,32, + 16,0,1200,1203,3,152,76,0,1201,1203,3,324,162,0,1202,1197,1,0,0,0,1202, + 1200,1,0,0,0,1202,1201,1,0,0,0,1203,123,1,0,0,0,1204,1205,3,116,58,0,1205, + 1206,6,62,-1,0,1206,1222,1,0,0,0,1207,1208,5,42,0,0,1208,1209,3,2,1,0, + 1209,1210,5,43,0,0,1210,1211,6,62,-1,0,1211,1222,1,0,0,0,1212,1213,5,42, + 0,0,1213,1214,5,198,0,0,1214,1215,3,2,1,0,1215,1216,5,43,0,0,1216,1217, + 6,62,-1,0,1217,1222,1,0,0,0,1218,1219,3,138,69,0,1219,1220,6,62,-1,0,1220, + 1222,1,0,0,0,1221,1204,1,0,0,0,1221,1207,1,0,0,0,1221,1212,1,0,0,0,1221, + 1218,1,0,0,0,1222,125,1,0,0,0,1223,1235,1,0,0,0,1224,1225,3,130,65,0,1225, + 1231,6,63,-1,0,1226,1227,3,128,64,0,1227,1228,6,63,-1,0,1228,1230,1,0, + 0,0,1229,1226,1,0,0,0,1230,1233,1,0,0,0,1231,1229,1,0,0,0,1231,1232,1, + 0,0,0,1232,1235,1,0,0,0,1233,1231,1,0,0,0,1234,1223,1,0,0,0,1234,1224, + 1,0,0,0,1235,127,1,0,0,0,1236,1237,5,262,0,0,1237,1259,6,64,-1,0,1238, + 1239,5,261,0,0,1239,1259,6,64,-1,0,1240,1241,5,42,0,0,1241,1242,3,32,16, + 0,1242,1243,5,43,0,0,1243,1244,6,64,-1,0,1244,1259,1,0,0,0,1245,1246,5, + 42,0,0,1246,1247,3,32,16,0,1247,1248,5,266,0,0,1248,1249,3,32,16,0,1249, + 1250,5,43,0,0,1250,1251,6,64,-1,0,1251,1259,1,0,0,0,1252,1253,5,42,0,0, + 1253,1254,5,266,0,0,1254,1255,3,32,16,0,1255,1256,5,43,0,0,1256,1257,6, + 64,-1,0,1257,1259,1,0,0,0,1258,1236,1,0,0,0,1258,1238,1,0,0,0,1258,1240, + 1,0,0,0,1258,1245,1,0,0,0,1258,1252,1,0,0,0,1259,129,1,0,0,0,1260,1406, + 6,65,-1,0,1261,1262,5,203,0,0,1262,1263,5,30,0,0,1263,1264,3,6,3,0,1264, + 1265,5,28,0,0,1265,1266,3,6,3,0,1266,1267,5,28,0,0,1267,1268,3,6,3,0,1268, + 1269,5,28,0,0,1269,1270,3,6,3,0,1270,1271,5,31,0,0,1271,1272,6,65,-1,0, + 1272,1406,1,0,0,0,1273,1274,5,203,0,0,1274,1275,5,30,0,0,1275,1276,3,6, + 3,0,1276,1277,5,28,0,0,1277,1278,3,6,3,0,1278,1279,5,31,0,0,1279,1280, + 6,65,-1,0,1280,1406,1,0,0,0,1281,1282,5,204,0,0,1282,1283,5,205,0,0,1283, + 1284,5,42,0,0,1284,1285,3,32,16,0,1285,1286,5,43,0,0,1286,1287,6,65,-1, + 0,1287,1406,1,0,0,0,1288,1289,5,204,0,0,1289,1290,5,206,0,0,1290,1291, + 5,42,0,0,1291,1292,3,32,16,0,1292,1293,5,43,0,0,1293,1294,3,126,63,0,1294, + 1295,6,65,-1,0,1295,1406,1,0,0,0,1296,1297,5,207,0,0,1297,1406,6,65,-1, + 0,1298,1299,5,208,0,0,1299,1406,6,65,-1,0,1300,1301,5,209,0,0,1301,1406, + 6,65,-1,0,1302,1303,5,201,0,0,1303,1406,6,65,-1,0,1304,1305,5,183,0,0, + 1305,1406,6,65,-1,0,1306,1307,5,184,0,0,1307,1406,6,65,-1,0,1308,1309, + 5,185,0,0,1309,1406,6,65,-1,0,1310,1311,5,186,0,0,1311,1406,6,65,-1,0, + 1312,1313,5,187,0,0,1313,1406,6,65,-1,0,1314,1315,5,188,0,0,1315,1406, + 6,65,-1,0,1316,1317,5,189,0,0,1317,1406,6,65,-1,0,1318,1319,5,210,0,0, + 1319,1406,6,65,-1,0,1320,1321,5,190,0,0,1321,1406,6,65,-1,0,1322,1323, + 5,191,0,0,1323,1406,6,65,-1,0,1324,1325,5,192,0,0,1325,1406,6,65,-1,0, + 1326,1327,5,193,0,0,1327,1406,6,65,-1,0,1328,1329,5,211,0,0,1329,1406, + 6,65,-1,0,1330,1331,5,212,0,0,1331,1406,6,65,-1,0,1332,1333,5,213,0,0, + 1333,1406,6,65,-1,0,1334,1335,5,214,0,0,1335,1406,6,65,-1,0,1336,1337, + 5,215,0,0,1337,1406,6,65,-1,0,1338,1339,5,216,0,0,1339,1406,6,65,-1,0, + 1340,1341,5,217,0,0,1341,1406,6,65,-1,0,1342,1343,5,218,0,0,1343,1344, + 3,132,66,0,1344,1345,6,65,-1,0,1345,1406,1,0,0,0,1346,1347,5,219,0,0,1347, + 1348,3,132,66,0,1348,1349,6,65,-1,0,1349,1406,1,0,0,0,1350,1351,5,220, + 0,0,1351,1406,6,65,-1,0,1352,1353,5,221,0,0,1353,1354,3,132,66,0,1354, + 1355,6,65,-1,0,1355,1406,1,0,0,0,1356,1357,5,222,0,0,1357,1358,3,134,67, + 0,1358,1359,6,65,-1,0,1359,1406,1,0,0,0,1360,1361,5,222,0,0,1361,1362, + 3,134,67,0,1362,1363,5,28,0,0,1363,1364,3,6,3,0,1364,1365,6,65,-1,0,1365, + 1406,1,0,0,0,1366,1367,5,194,0,0,1367,1406,6,65,-1,0,1368,1369,5,195,0, + 0,1369,1406,6,65,-1,0,1370,1371,5,90,0,0,1371,1372,5,184,0,0,1372,1406, + 6,65,-1,0,1373,1374,5,90,0,0,1374,1375,5,185,0,0,1375,1406,6,65,-1,0,1376, + 1377,5,90,0,0,1377,1378,5,186,0,0,1378,1406,6,65,-1,0,1379,1380,5,90,0, + 0,1380,1381,5,187,0,0,1381,1406,6,65,-1,0,1382,1383,5,62,0,0,1383,1384, + 5,220,0,0,1384,1406,6,65,-1,0,1385,1386,5,223,0,0,1386,1406,6,65,-1,0, + 1387,1388,5,224,0,0,1388,1389,5,213,0,0,1389,1406,6,65,-1,0,1390,1391, + 5,225,0,0,1391,1406,6,65,-1,0,1392,1393,5,207,0,0,1393,1394,5,183,0,0, + 1394,1406,6,65,-1,0,1395,1396,5,226,0,0,1396,1406,6,65,-1,0,1397,1398, + 5,228,0,0,1398,1406,6,65,-1,0,1399,1400,5,34,0,0,1400,1401,5,227,0,0,1401, + 1406,6,65,-1,0,1402,1403,3,2,1,0,1403,1404,6,65,-1,0,1404,1406,1,0,0,0, + 1405,1260,1,0,0,0,1405,1261,1,0,0,0,1405,1273,1,0,0,0,1405,1281,1,0,0, + 0,1405,1288,1,0,0,0,1405,1296,1,0,0,0,1405,1298,1,0,0,0,1405,1300,1,0, + 0,0,1405,1302,1,0,0,0,1405,1304,1,0,0,0,1405,1306,1,0,0,0,1405,1308,1, + 0,0,0,1405,1310,1,0,0,0,1405,1312,1,0,0,0,1405,1314,1,0,0,0,1405,1316, + 1,0,0,0,1405,1318,1,0,0,0,1405,1320,1,0,0,0,1405,1322,1,0,0,0,1405,1324, + 1,0,0,0,1405,1326,1,0,0,0,1405,1328,1,0,0,0,1405,1330,1,0,0,0,1405,1332, + 1,0,0,0,1405,1334,1,0,0,0,1405,1336,1,0,0,0,1405,1338,1,0,0,0,1405,1340, + 1,0,0,0,1405,1342,1,0,0,0,1405,1346,1,0,0,0,1405,1350,1,0,0,0,1405,1352, + 1,0,0,0,1405,1356,1,0,0,0,1405,1360,1,0,0,0,1405,1366,1,0,0,0,1405,1368, + 1,0,0,0,1405,1370,1,0,0,0,1405,1373,1,0,0,0,1405,1376,1,0,0,0,1405,1379, + 1,0,0,0,1405,1382,1,0,0,0,1405,1385,1,0,0,0,1405,1387,1,0,0,0,1405,1390, + 1,0,0,0,1405,1392,1,0,0,0,1405,1395,1,0,0,0,1405,1397,1,0,0,0,1405,1399, + 1,0,0,0,1405,1402,1,0,0,0,1406,131,1,0,0,0,1407,1416,1,0,0,0,1408,1409, + 5,30,0,0,1409,1410,5,91,0,0,1410,1411,5,36,0,0,1411,1412,3,32,16,0,1412, + 1413,5,31,0,0,1413,1414,6,66,-1,0,1414,1416,1,0,0,0,1415,1407,1,0,0,0, + 1415,1408,1,0,0,0,1416,133,1,0,0,0,1417,1428,1,0,0,0,1418,1419,3,136,68, + 0,1419,1424,6,67,-1,0,1420,1421,7,7,0,0,1421,1423,6,67,-1,0,1422,1420, + 1,0,0,0,1423,1426,1,0,0,0,1424,1422,1,0,0,0,1424,1425,1,0,0,0,1425,1428, + 1,0,0,0,1426,1424,1,0,0,0,1427,1417,1,0,0,0,1427,1418,1,0,0,0,1428,135, + 1,0,0,0,1429,1430,5,178,0,0,1430,1510,6,68,-1,0,1431,1432,5,207,0,0,1432, + 1510,6,68,-1,0,1433,1434,5,208,0,0,1434,1510,6,68,-1,0,1435,1436,5,201, + 0,0,1436,1510,6,68,-1,0,1437,1438,5,183,0,0,1438,1510,6,68,-1,0,1439,1440, + 5,184,0,0,1440,1510,6,68,-1,0,1441,1442,5,185,0,0,1442,1510,6,68,-1,0, + 1443,1444,5,186,0,0,1444,1510,6,68,-1,0,1445,1446,5,187,0,0,1446,1510, + 6,68,-1,0,1447,1448,5,188,0,0,1448,1510,6,68,-1,0,1449,1450,5,189,0,0, + 1450,1510,6,68,-1,0,1451,1452,5,190,0,0,1452,1510,6,68,-1,0,1453,1454, + 5,191,0,0,1454,1510,6,68,-1,0,1455,1456,5,192,0,0,1456,1510,6,68,-1,0, + 1457,1458,5,193,0,0,1458,1510,6,68,-1,0,1459,1460,5,262,0,0,1460,1510, + 6,68,-1,0,1461,1462,5,211,0,0,1462,1510,6,68,-1,0,1463,1464,5,212,0,0, + 1464,1510,6,68,-1,0,1465,1466,5,213,0,0,1466,1510,6,68,-1,0,1467,1468, + 5,214,0,0,1468,1510,6,68,-1,0,1469,1470,5,215,0,0,1470,1510,6,68,-1,0, + 1471,1472,5,218,0,0,1472,1510,6,68,-1,0,1473,1474,5,219,0,0,1474,1510, + 6,68,-1,0,1475,1476,5,222,0,0,1476,1510,6,68,-1,0,1477,1478,5,194,0,0, + 1478,1510,6,68,-1,0,1479,1480,5,195,0,0,1480,1510,6,68,-1,0,1481,1482, + 5,210,0,0,1482,1510,6,68,-1,0,1483,1484,5,230,0,0,1484,1510,6,68,-1,0, + 1485,1486,5,231,0,0,1486,1510,6,68,-1,0,1487,1488,5,232,0,0,1488,1510, + 6,68,-1,0,1489,1490,5,233,0,0,1490,1510,6,68,-1,0,1491,1492,5,234,0,0, + 1492,1510,6,68,-1,0,1493,1494,5,235,0,0,1494,1510,6,68,-1,0,1495,1496, + 5,236,0,0,1496,1510,6,68,-1,0,1497,1498,5,237,0,0,1498,1510,6,68,-1,0, + 1499,1500,5,238,0,0,1500,1510,6,68,-1,0,1501,1502,5,239,0,0,1502,1510, + 6,68,-1,0,1503,1504,5,240,0,0,1504,1510,6,68,-1,0,1505,1506,5,241,0,0, + 1506,1510,6,68,-1,0,1507,1508,5,242,0,0,1508,1510,6,68,-1,0,1509,1429, + 1,0,0,0,1509,1431,1,0,0,0,1509,1433,1,0,0,0,1509,1435,1,0,0,0,1509,1437, + 1,0,0,0,1509,1439,1,0,0,0,1509,1441,1,0,0,0,1509,1443,1,0,0,0,1509,1445, + 1,0,0,0,1509,1447,1,0,0,0,1509,1449,1,0,0,0,1509,1451,1,0,0,0,1509,1453, + 1,0,0,0,1509,1455,1,0,0,0,1509,1457,1,0,0,0,1509,1459,1,0,0,0,1509,1461, + 1,0,0,0,1509,1463,1,0,0,0,1509,1465,1,0,0,0,1509,1467,1,0,0,0,1509,1469, + 1,0,0,0,1509,1471,1,0,0,0,1509,1473,1,0,0,0,1509,1475,1,0,0,0,1509,1477, + 1,0,0,0,1509,1479,1,0,0,0,1509,1481,1,0,0,0,1509,1483,1,0,0,0,1509,1485, + 1,0,0,0,1509,1487,1,0,0,0,1509,1489,1,0,0,0,1509,1491,1,0,0,0,1509,1493, + 1,0,0,0,1509,1495,1,0,0,0,1509,1497,1,0,0,0,1509,1499,1,0,0,0,1509,1501, + 1,0,0,0,1509,1503,1,0,0,0,1509,1505,1,0,0,0,1509,1507,1,0,0,0,1510,137, + 1,0,0,0,1511,1512,3,142,71,0,1512,1518,6,69,-1,0,1513,1514,3,140,70,0, + 1514,1515,6,69,-1,0,1515,1517,1,0,0,0,1516,1513,1,0,0,0,1517,1520,1,0, + 0,0,1518,1516,1,0,0,0,1518,1519,1,0,0,0,1519,139,1,0,0,0,1520,1518,1,0, + 0,0,1521,1522,5,261,0,0,1522,1551,6,70,-1,0,1523,1524,5,42,0,0,1524,1525, + 5,43,0,0,1525,1551,6,70,-1,0,1526,1527,3,110,55,0,1527,1528,6,70,-1,0, + 1528,1551,1,0,0,0,1529,1530,5,260,0,0,1530,1551,6,70,-1,0,1531,1532,5, + 262,0,0,1532,1551,6,70,-1,0,1533,1534,5,92,0,0,1534,1551,6,70,-1,0,1535, + 1536,5,93,0,0,1536,1537,5,30,0,0,1537,1538,3,124,62,0,1538,1539,5,31,0, + 0,1539,1540,6,70,-1,0,1540,1551,1,0,0,0,1541,1542,5,94,0,0,1542,1543,5, + 30,0,0,1543,1544,3,124,62,0,1544,1545,5,31,0,0,1545,1546,6,70,-1,0,1546, + 1551,1,0,0,0,1547,1548,3,108,54,0,1548,1549,6,70,-1,0,1549,1551,1,0,0, + 0,1550,1521,1,0,0,0,1550,1523,1,0,0,0,1550,1526,1,0,0,0,1550,1529,1,0, + 0,0,1550,1531,1,0,0,0,1550,1533,1,0,0,0,1550,1535,1,0,0,0,1550,1541,1, + 0,0,0,1550,1547,1,0,0,0,1551,141,1,0,0,0,1552,1553,5,39,0,0,1553,1554, + 3,116,58,0,1554,1555,6,71,-1,0,1555,1611,1,0,0,0,1556,1557,5,197,0,0,1557, + 1611,6,71,-1,0,1558,1559,5,199,0,0,1559,1560,5,39,0,0,1560,1561,3,116, + 58,0,1561,1562,6,71,-1,0,1562,1611,1,0,0,0,1563,1564,5,200,0,0,1564,1565, + 3,116,58,0,1565,1566,6,71,-1,0,1566,1611,1,0,0,0,1567,1568,5,226,0,0,1568, + 1569,3,170,85,0,1569,1570,3,138,69,0,1570,1571,5,262,0,0,1571,1572,3,112, + 56,0,1572,1573,6,71,-1,0,1573,1611,1,0,0,0,1574,1575,5,253,0,0,1575,1576, + 3,32,16,0,1576,1577,6,71,-1,0,1577,1611,1,0,0,0,1578,1579,5,252,0,0,1579, + 1580,3,32,16,0,1580,1581,6,71,-1,0,1581,1611,1,0,0,0,1582,1583,5,253,0, + 0,1583,1584,3,2,1,0,1584,1585,6,71,-1,0,1585,1611,1,0,0,0,1586,1587,5, + 252,0,0,1587,1588,3,2,1,0,1588,1589,6,71,-1,0,1589,1611,1,0,0,0,1590,1591, + 5,254,0,0,1591,1611,6,71,-1,0,1592,1593,5,201,0,0,1593,1611,6,71,-1,0, + 1594,1595,3,148,74,0,1595,1596,6,71,-1,0,1596,1611,1,0,0,0,1597,1598,3, + 150,75,0,1598,1599,6,71,-1,0,1599,1611,1,0,0,0,1600,1601,3,144,72,0,1601, + 1602,6,71,-1,0,1602,1611,1,0,0,0,1603,1604,3,2,1,0,1604,1605,6,71,-1,0, + 1605,1611,1,0,0,0,1606,1607,5,177,0,0,1607,1608,3,138,69,0,1608,1609,6, + 71,-1,0,1609,1611,1,0,0,0,1610,1552,1,0,0,0,1610,1556,1,0,0,0,1610,1558, + 1,0,0,0,1610,1563,1,0,0,0,1610,1567,1,0,0,0,1610,1574,1,0,0,0,1610,1578, + 1,0,0,0,1610,1582,1,0,0,0,1610,1586,1,0,0,0,1610,1590,1,0,0,0,1610,1592, + 1,0,0,0,1610,1594,1,0,0,0,1610,1597,1,0,0,0,1610,1600,1,0,0,0,1610,1603, + 1,0,0,0,1610,1606,1,0,0,0,1611,143,1,0,0,0,1612,1613,5,181,0,0,1613,1651, + 6,72,-1,0,1614,1615,5,182,0,0,1615,1651,6,72,-1,0,1616,1617,5,183,0,0, + 1617,1651,6,72,-1,0,1618,1619,5,184,0,0,1619,1651,6,72,-1,0,1620,1621, + 5,185,0,0,1621,1651,6,72,-1,0,1622,1623,5,186,0,0,1623,1651,6,72,-1,0, + 1624,1625,5,187,0,0,1625,1651,6,72,-1,0,1626,1627,5,188,0,0,1627,1651, + 6,72,-1,0,1628,1629,5,189,0,0,1629,1651,6,72,-1,0,1630,1631,5,190,0,0, + 1631,1651,6,72,-1,0,1632,1633,5,191,0,0,1633,1651,6,72,-1,0,1634,1635, + 5,192,0,0,1635,1651,6,72,-1,0,1636,1637,5,193,0,0,1637,1651,6,72,-1,0, + 1638,1639,5,90,0,0,1639,1640,5,184,0,0,1640,1651,6,72,-1,0,1641,1642,5, + 90,0,0,1642,1643,5,185,0,0,1643,1651,6,72,-1,0,1644,1645,5,90,0,0,1645, + 1646,5,186,0,0,1646,1651,6,72,-1,0,1647,1648,5,90,0,0,1648,1649,5,187, + 0,0,1649,1651,6,72,-1,0,1650,1612,1,0,0,0,1650,1614,1,0,0,0,1650,1616, + 1,0,0,0,1650,1618,1,0,0,0,1650,1620,1,0,0,0,1650,1622,1,0,0,0,1650,1624, + 1,0,0,0,1650,1626,1,0,0,0,1650,1628,1,0,0,0,1650,1630,1,0,0,0,1650,1632, + 1,0,0,0,1650,1634,1,0,0,0,1650,1636,1,0,0,0,1650,1638,1,0,0,0,1650,1641, + 1,0,0,0,1650,1644,1,0,0,0,1650,1647,1,0,0,0,1651,145,1,0,0,0,1652,1667, + 1,0,0,0,1653,1667,5,177,0,0,1654,1655,3,32,16,0,1655,1656,6,73,-1,0,1656, + 1667,1,0,0,0,1657,1658,3,32,16,0,1658,1659,5,177,0,0,1659,1660,3,32,16, + 0,1660,1661,6,73,-1,0,1661,1667,1,0,0,0,1662,1663,3,32,16,0,1663,1664, + 5,177,0,0,1664,1665,6,73,-1,0,1665,1667,1,0,0,0,1666,1652,1,0,0,0,1666, + 1653,1,0,0,0,1666,1654,1,0,0,0,1666,1657,1,0,0,0,1666,1662,1,0,0,0,1667, + 147,1,0,0,0,1668,1669,5,1,0,0,1669,1670,5,194,0,0,1670,1671,6,74,-1,0, + 1671,149,1,0,0,0,1672,1676,5,1,0,0,1673,1674,5,90,0,0,1674,1677,5,194, + 0,0,1675,1677,5,195,0,0,1676,1673,1,0,0,0,1676,1675,1,0,0,0,1677,1678, + 1,0,0,0,1678,1679,6,75,-1,0,1679,151,1,0,0,0,1680,1681,5,294,0,0,1681, + 1682,3,166,83,0,1682,1683,3,124,62,0,1683,1684,5,30,0,0,1684,1685,3,158, + 79,0,1685,1686,5,31,0,0,1686,1728,1,0,0,0,1687,1688,5,294,0,0,1688,1689, + 3,166,83,0,1689,1690,3,124,62,0,1690,1691,5,36,0,0,1691,1692,5,17,0,0, + 1692,1693,3,52,26,0,1693,1694,5,18,0,0,1694,1728,1,0,0,0,1695,1696,5,294, + 0,0,1696,1697,3,166,83,0,1697,1698,3,124,62,0,1698,1728,1,0,0,0,1699,1700, + 5,295,0,0,1700,1701,3,166,83,0,1701,1703,5,36,0,0,1702,1704,5,84,0,0,1703, + 1702,1,0,0,0,1703,1704,1,0,0,0,1704,1705,1,0,0,0,1705,1706,5,30,0,0,1706, + 1707,3,292,146,0,1707,1708,5,31,0,0,1708,1728,1,0,0,0,1709,1710,5,295, + 0,0,1710,1711,3,166,83,0,1711,1712,5,84,0,0,1712,1713,5,30,0,0,1713,1714, + 3,292,146,0,1714,1715,5,31,0,0,1715,1728,1,0,0,0,1716,1717,5,295,0,0,1717, + 1718,3,166,83,0,1718,1719,3,6,3,0,1719,1728,1,0,0,0,1720,1721,5,295,0, + 0,1721,1722,3,166,83,0,1722,1723,5,36,0,0,1723,1724,5,17,0,0,1724,1725, + 3,154,77,0,1725,1726,5,18,0,0,1726,1728,1,0,0,0,1727,1680,1,0,0,0,1727, + 1687,1,0,0,0,1727,1695,1,0,0,0,1727,1699,1,0,0,0,1727,1709,1,0,0,0,1727, + 1716,1,0,0,0,1727,1720,1,0,0,0,1728,153,1,0,0,0,1729,1740,1,0,0,0,1730, + 1731,3,156,78,0,1731,1732,5,28,0,0,1732,1734,1,0,0,0,1733,1730,1,0,0,0, + 1734,1737,1,0,0,0,1735,1733,1,0,0,0,1735,1736,1,0,0,0,1736,1738,1,0,0, + 0,1737,1735,1,0,0,0,1738,1740,3,156,78,0,1739,1729,1,0,0,0,1739,1735,1, + 0,0,0,1740,155,1,0,0,0,1741,1742,5,39,0,0,1742,1743,5,264,0,0,1743,1744, + 5,36,0,0,1744,1745,5,17,0,0,1745,1746,3,56,28,0,1746,1747,5,18,0,0,1747, + 1755,1,0,0,0,1748,1749,3,124,62,0,1749,1750,5,36,0,0,1750,1751,5,17,0, + 0,1751,1752,3,56,28,0,1752,1753,5,18,0,0,1753,1755,1,0,0,0,1754,1741,1, + 0,0,0,1754,1748,1,0,0,0,1755,157,1,0,0,0,1756,1757,3,160,80,0,1757,1758, + 5,28,0,0,1758,1760,1,0,0,0,1759,1756,1,0,0,0,1760,1763,1,0,0,0,1761,1759, + 1,0,0,0,1761,1762,1,0,0,0,1762,1764,1,0,0,0,1763,1761,1,0,0,0,1764,1765, + 3,160,80,0,1765,159,1,0,0,0,1766,1767,3,6,3,0,1767,1768,5,36,0,0,1768, + 1769,3,164,82,0,1769,161,1,0,0,0,1770,1771,7,8,0,0,1771,163,1,0,0,0,1772, + 1807,3,162,81,0,1773,1807,3,32,16,0,1774,1775,5,186,0,0,1775,1776,5,30, + 0,0,1776,1777,3,32,16,0,1777,1778,5,31,0,0,1778,1807,1,0,0,0,1779,1807, + 3,6,3,0,1780,1781,3,116,58,0,1781,1782,5,30,0,0,1782,1783,5,184,0,0,1783, + 1784,5,75,0,0,1784,1785,3,32,16,0,1785,1786,5,31,0,0,1786,1807,1,0,0,0, + 1787,1788,3,116,58,0,1788,1789,5,30,0,0,1789,1790,5,185,0,0,1790,1791, + 5,75,0,0,1791,1792,3,32,16,0,1792,1793,5,31,0,0,1793,1807,1,0,0,0,1794, + 1795,3,116,58,0,1795,1796,5,30,0,0,1796,1797,5,186,0,0,1797,1798,5,75, + 0,0,1798,1799,3,32,16,0,1799,1800,5,31,0,0,1800,1807,1,0,0,0,1801,1802, + 3,116,58,0,1802,1803,5,30,0,0,1803,1804,3,32,16,0,1804,1805,5,31,0,0,1805, + 1807,1,0,0,0,1806,1772,1,0,0,0,1806,1773,1,0,0,0,1806,1774,1,0,0,0,1806, + 1779,1,0,0,0,1806,1780,1,0,0,0,1806,1787,1,0,0,0,1806,1794,1,0,0,0,1806, + 1801,1,0,0,0,1807,165,1,0,0,0,1808,1809,7,9,0,0,1809,167,1,0,0,0,1810, + 1811,3,170,85,0,1811,1812,3,138,69,0,1812,1813,3,124,62,0,1813,1814,5, + 176,0,0,1814,1816,3,242,121,0,1815,1817,3,108,54,0,1816,1815,1,0,0,0,1816, + 1817,1,0,0,0,1817,1818,1,0,0,0,1818,1819,3,112,56,0,1819,1820,6,84,-1, + 0,1820,1853,1,0,0,0,1821,1822,3,170,85,0,1822,1823,3,138,69,0,1823,1824, + 3,124,62,0,1824,1825,5,176,0,0,1825,1826,3,242,121,0,1826,1827,3,196,98, + 0,1827,1828,3,112,56,0,1828,1829,6,84,-1,0,1829,1853,1,0,0,0,1830,1831, + 3,170,85,0,1831,1832,3,138,69,0,1832,1834,3,242,121,0,1833,1835,3,108, + 54,0,1834,1833,1,0,0,0,1834,1835,1,0,0,0,1835,1836,1,0,0,0,1836,1837,3, + 112,56,0,1837,1838,6,84,-1,0,1838,1853,1,0,0,0,1839,1840,3,170,85,0,1840, + 1841,3,138,69,0,1841,1842,3,242,121,0,1842,1843,3,196,98,0,1843,1844,3, + 112,56,0,1844,1845,6,84,-1,0,1845,1853,1,0,0,0,1846,1847,3,174,87,0,1847, + 1848,6,84,-1,0,1848,1853,1,0,0,0,1849,1850,3,2,1,0,1850,1851,6,84,-1,0, + 1851,1853,1,0,0,0,1852,1810,1,0,0,0,1852,1821,1,0,0,0,1852,1830,1,0,0, + 0,1852,1839,1,0,0,0,1852,1846,1,0,0,0,1852,1849,1,0,0,0,1853,169,1,0,0, + 0,1854,1855,5,243,0,0,1855,1856,3,170,85,0,1856,1857,6,85,-1,0,1857,1872, + 1,0,0,0,1858,1859,5,244,0,0,1859,1860,3,170,85,0,1860,1861,6,85,-1,0,1861, + 1872,1,0,0,0,1862,1863,3,172,86,0,1863,1864,6,85,-1,0,1864,1872,1,0,0, + 0,1865,1866,5,112,0,0,1866,1867,5,30,0,0,1867,1868,3,32,16,0,1868,1869, + 5,31,0,0,1869,1870,6,85,-1,0,1870,1872,1,0,0,0,1871,1854,1,0,0,0,1871, + 1858,1,0,0,0,1871,1862,1,0,0,0,1871,1865,1,0,0,0,1872,171,1,0,0,0,1873, + 1893,1,0,0,0,1874,1875,5,245,0,0,1875,1893,6,86,-1,0,1876,1877,5,246,0, + 0,1877,1893,6,86,-1,0,1878,1879,5,247,0,0,1879,1880,5,248,0,0,1880,1893, + 6,86,-1,0,1881,1882,5,247,0,0,1882,1883,5,249,0,0,1883,1893,6,86,-1,0, + 1884,1885,5,247,0,0,1885,1886,5,250,0,0,1886,1893,6,86,-1,0,1887,1888, + 5,247,0,0,1888,1889,5,251,0,0,1889,1893,6,86,-1,0,1890,1891,5,247,0,0, + 1891,1893,6,86,-1,0,1892,1873,1,0,0,0,1892,1874,1,0,0,0,1892,1876,1,0, + 0,0,1892,1878,1,0,0,0,1892,1881,1,0,0,0,1892,1884,1,0,0,0,1892,1887,1, + 0,0,0,1892,1890,1,0,0,0,1893,173,1,0,0,0,1894,1895,5,113,0,0,1895,1896, + 5,30,0,0,1896,1897,3,32,16,0,1897,1898,5,31,0,0,1898,1899,6,87,-1,0,1899, + 175,1,0,0,0,1900,1901,5,226,0,0,1901,1902,3,168,84,0,1902,1903,6,88,-1, + 0,1903,1912,1,0,0,0,1904,1905,5,37,0,0,1905,1906,3,178,89,0,1906,1907, + 6,88,-1,0,1907,1912,1,0,0,0,1908,1909,3,174,87,0,1909,1910,6,88,-1,0,1910, + 1912,1,0,0,0,1911,1900,1,0,0,0,1911,1904,1,0,0,0,1911,1908,1,0,0,0,1912, + 177,1,0,0,0,1913,1914,3,138,69,0,1914,1915,3,124,62,0,1915,1916,5,176, + 0,0,1916,1917,3,2,1,0,1917,1918,6,89,-1,0,1918,1927,1,0,0,0,1919,1920, + 3,138,69,0,1920,1921,3,2,1,0,1921,1922,6,89,-1,0,1922,1927,1,0,0,0,1923, + 1924,3,2,1,0,1924,1925,6,89,-1,0,1925,1927,1,0,0,0,1926,1913,1,0,0,0,1926, + 1919,1,0,0,0,1926,1923,1,0,0,0,1927,179,1,0,0,0,1928,1929,3,124,62,0,1929, + 1930,5,28,0,0,1930,1932,1,0,0,0,1931,1928,1,0,0,0,1932,1935,1,0,0,0,1933, + 1931,1,0,0,0,1933,1934,1,0,0,0,1934,1936,1,0,0,0,1935,1933,1,0,0,0,1936, + 1937,3,124,62,0,1937,181,1,0,0,0,1938,1944,1,0,0,0,1939,1940,5,86,0,0, + 1940,1941,3,190,95,0,1941,1942,5,87,0,0,1942,1944,1,0,0,0,1943,1938,1, + 0,0,0,1943,1939,1,0,0,0,1944,183,1,0,0,0,1945,1957,5,266,0,0,1946,1957, + 5,114,0,0,1947,1957,5,39,0,0,1948,1957,5,200,0,0,1949,1957,5,115,0,0,1950, + 1957,5,116,0,0,1951,1952,5,70,0,0,1952,1953,5,30,0,0,1953,1954,3,32,16, + 0,1954,1955,5,31,0,0,1955,1957,1,0,0,0,1956,1945,1,0,0,0,1956,1946,1,0, + 0,0,1956,1947,1,0,0,0,1956,1948,1,0,0,0,1956,1949,1,0,0,0,1956,1950,1, + 0,0,0,1956,1951,1,0,0,0,1957,185,1,0,0,0,1958,1960,3,184,92,0,1959,1958, + 1,0,0,0,1960,1963,1,0,0,0,1961,1959,1,0,0,0,1961,1962,1,0,0,0,1962,187, + 1,0,0,0,1963,1961,1,0,0,0,1964,1966,3,186,93,0,1965,1967,3,192,96,0,1966, + 1965,1,0,0,0,1966,1967,1,0,0,0,1967,1968,1,0,0,0,1968,1969,3,2,1,0,1969, + 189,1,0,0,0,1970,1971,3,188,94,0,1971,1972,5,28,0,0,1972,1974,1,0,0,0, + 1973,1970,1,0,0,0,1974,1977,1,0,0,0,1975,1973,1,0,0,0,1975,1976,1,0,0, + 0,1976,1978,1,0,0,0,1977,1975,1,0,0,0,1978,1979,3,188,94,0,1979,191,1, + 0,0,0,1980,1981,5,30,0,0,1981,1982,3,180,90,0,1982,1983,5,31,0,0,1983, + 193,1,0,0,0,1984,1986,3,196,98,0,1985,1984,1,0,0,0,1985,1986,1,0,0,0,1986, + 1987,1,0,0,0,1987,1988,6,97,-1,0,1988,195,1,0,0,0,1989,1990,5,86,0,0,1990, + 1991,5,42,0,0,1991,1992,3,32,16,0,1992,1993,5,43,0,0,1993,1994,5,87,0, + 0,1994,1995,6,98,-1,0,1995,197,1,0,0,0,1996,1997,3,234,117,0,1997,1998, + 5,17,0,0,1998,1999,3,246,123,0,1999,2000,5,18,0,0,2000,2113,1,0,0,0,2001, + 2002,3,74,37,0,2002,2003,5,17,0,0,2003,2004,3,82,41,0,2004,2005,5,18,0, + 0,2005,2113,1,0,0,0,2006,2007,3,210,105,0,2007,2008,5,17,0,0,2008,2009, + 3,214,107,0,2009,2010,5,18,0,0,2010,2113,1,0,0,0,2011,2012,3,218,109,0, + 2012,2013,5,17,0,0,2013,2014,3,222,111,0,2014,2015,5,18,0,0,2015,2113, + 1,0,0,0,2016,2113,3,200,100,0,2017,2113,3,276,138,0,2018,2113,3,152,76, + 0,2019,2113,3,88,44,0,2020,2113,3,322,161,0,2021,2022,5,117,0,0,2022,2113, + 3,32,16,0,2023,2024,5,118,0,0,2024,2113,3,32,16,0,2025,2026,3,334,167, + 0,2026,2027,5,17,0,0,2027,2028,3,338,169,0,2028,2029,5,18,0,0,2029,2113, + 1,0,0,0,2030,2031,5,302,0,0,2031,2032,3,124,62,0,2032,2033,5,176,0,0,2033, + 2034,3,242,121,0,2034,2035,5,119,0,0,2035,2036,3,170,85,0,2036,2037,3, + 138,69,0,2037,2038,3,124,62,0,2038,2039,5,176,0,0,2039,2040,3,242,121, + 0,2040,2041,3,112,56,0,2041,2113,1,0,0,0,2042,2043,5,302,0,0,2043,2044, + 5,226,0,0,2044,2045,3,170,85,0,2045,2046,3,138,69,0,2046,2047,3,124,62, + 0,2047,2048,5,176,0,0,2048,2049,3,242,121,0,2049,2050,3,194,97,0,2050, + 2051,3,112,56,0,2051,2052,5,119,0,0,2052,2053,5,226,0,0,2053,2054,3,170, + 85,0,2054,2055,3,138,69,0,2055,2056,3,124,62,0,2056,2057,5,176,0,0,2057, + 2058,3,242,121,0,2058,2059,3,194,97,0,2059,2060,3,112,56,0,2060,2113,1, + 0,0,0,2061,2113,3,26,13,0,2062,2113,3,40,20,0,2063,2064,5,255,0,0,2064, + 2065,5,196,0,0,2065,2066,5,42,0,0,2066,2067,3,32,16,0,2067,2071,5,43,0, + 0,2068,2070,3,322,161,0,2069,2068,1,0,0,0,2070,2073,1,0,0,0,2071,2069, + 1,0,0,0,2071,2072,1,0,0,0,2072,2113,1,0,0,0,2073,2071,1,0,0,0,2074,2075, + 5,255,0,0,2075,2076,5,196,0,0,2076,2080,3,2,1,0,2077,2079,3,322,161,0, + 2078,2077,1,0,0,0,2079,2082,1,0,0,0,2080,2078,1,0,0,0,2080,2081,1,0,0, + 0,2081,2113,1,0,0,0,2082,2080,1,0,0,0,2083,2084,5,255,0,0,2084,2085,5, + 256,0,0,2085,2086,5,42,0,0,2086,2087,3,32,16,0,2087,2088,5,43,0,0,2088, + 2089,5,28,0,0,2089,2093,3,124,62,0,2090,2092,3,322,161,0,2091,2090,1,0, + 0,0,2092,2095,1,0,0,0,2093,2091,1,0,0,0,2093,2094,1,0,0,0,2094,2113,1, + 0,0,0,2095,2093,1,0,0,0,2096,2097,5,255,0,0,2097,2098,5,256,0,0,2098,2099, + 3,2,1,0,2099,2100,5,28,0,0,2100,2104,3,124,62,0,2101,2103,3,322,161,0, + 2102,2101,1,0,0,0,2103,2106,1,0,0,0,2104,2102,1,0,0,0,2104,2105,1,0,0, + 0,2105,2113,1,0,0,0,2106,2104,1,0,0,0,2107,2108,5,120,0,0,2108,2109,5, + 196,0,0,2109,2110,3,124,62,0,2110,2111,3,44,22,0,2111,2113,1,0,0,0,2112, + 1996,1,0,0,0,2112,2001,1,0,0,0,2112,2006,1,0,0,0,2112,2011,1,0,0,0,2112, + 2016,1,0,0,0,2112,2017,1,0,0,0,2112,2018,1,0,0,0,2112,2019,1,0,0,0,2112, + 2020,1,0,0,0,2112,2021,1,0,0,0,2112,2023,1,0,0,0,2112,2025,1,0,0,0,2112, + 2030,1,0,0,0,2112,2042,1,0,0,0,2112,2061,1,0,0,0,2112,2062,1,0,0,0,2112, + 2063,1,0,0,0,2112,2074,1,0,0,0,2112,2083,1,0,0,0,2112,2096,1,0,0,0,2112, + 2107,1,0,0,0,2113,199,1,0,0,0,2114,2115,5,121,0,0,2115,2124,3,208,104, + 0,2116,2123,3,202,101,0,2117,2118,5,122,0,0,2118,2119,5,30,0,0,2119,2120, + 3,228,114,0,2120,2121,5,31,0,0,2121,2123,1,0,0,0,2122,2116,1,0,0,0,2122, + 2117,1,0,0,0,2123,2126,1,0,0,0,2124,2122,1,0,0,0,2124,2125,1,0,0,0,2125, + 2127,1,0,0,0,2126,2124,1,0,0,0,2127,2128,3,138,69,0,2128,2129,3,2,1,0, + 2129,2130,3,204,102,0,2130,2131,3,206,103,0,2131,201,1,0,0,0,2132,2152, + 5,123,0,0,2133,2152,5,51,0,0,2134,2152,5,52,0,0,2135,2152,5,63,0,0,2136, + 2152,5,124,0,0,2137,2152,5,69,0,0,2138,2152,5,68,0,0,2139,2152,5,64,0, + 0,2140,2152,5,65,0,0,2141,2152,5,66,0,0,2142,2152,5,125,0,0,2143,2152, + 5,126,0,0,2144,2152,5,127,0,0,2145,2152,5,16,0,0,2146,2147,5,70,0,0,2147, + 2148,5,30,0,0,2148,2149,3,32,16,0,2149,2150,5,31,0,0,2150,2152,1,0,0,0, + 2151,2132,1,0,0,0,2151,2133,1,0,0,0,2151,2134,1,0,0,0,2151,2135,1,0,0, + 0,2151,2136,1,0,0,0,2151,2137,1,0,0,0,2151,2138,1,0,0,0,2151,2139,1,0, + 0,0,2151,2140,1,0,0,0,2151,2141,1,0,0,0,2151,2142,1,0,0,0,2151,2143,1, + 0,0,0,2151,2144,1,0,0,0,2151,2145,1,0,0,0,2151,2146,1,0,0,0,2152,203,1, + 0,0,0,2153,2159,1,0,0,0,2154,2155,5,44,0,0,2155,2159,3,0,0,0,2156,2157, + 5,44,0,0,2157,2159,3,32,16,0,2158,2153,1,0,0,0,2158,2154,1,0,0,0,2158, + 2156,1,0,0,0,2159,205,1,0,0,0,2160,2164,1,0,0,0,2161,2162,5,36,0,0,2162, + 2164,3,296,148,0,2163,2160,1,0,0,0,2163,2161,1,0,0,0,2164,207,1,0,0,0, + 2165,2171,1,0,0,0,2166,2167,5,42,0,0,2167,2168,3,32,16,0,2168,2169,5,43, + 0,0,2169,2171,1,0,0,0,2170,2165,1,0,0,0,2170,2166,1,0,0,0,2171,209,1,0, + 0,0,2172,2176,5,128,0,0,2173,2175,3,212,106,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,2180,3,124,62,0,2180,2181,3,2,1,0,2181,2191,1,0,0,0,2182, + 2186,5,128,0,0,2183,2185,3,212,106,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,2,1,0,2190,2172,1,0,0,0,2190,2182,1,0,0,0,2191,211,1,0, + 0,0,2192,2193,7,10,0,0,2193,213,1,0,0,0,2194,2196,3,216,108,0,2195,2194, + 1,0,0,0,2196,2199,1,0,0,0,2197,2195,1,0,0,0,2197,2198,1,0,0,0,2198,215, + 1,0,0,0,2199,2197,1,0,0,0,2200,2201,5,129,0,0,2201,2213,3,168,84,0,2202, + 2203,5,130,0,0,2203,2213,3,168,84,0,2204,2205,5,131,0,0,2205,2213,3,168, + 84,0,2206,2207,5,132,0,0,2207,2213,3,168,84,0,2208,2213,3,88,44,0,2209, + 2213,3,322,161,0,2210,2213,3,26,13,0,2211,2213,3,40,20,0,2212,2200,1,0, + 0,0,2212,2202,1,0,0,0,2212,2204,1,0,0,0,2212,2206,1,0,0,0,2212,2208,1, + 0,0,0,2212,2209,1,0,0,0,2212,2210,1,0,0,0,2212,2211,1,0,0,0,2213,217,1, + 0,0,0,2214,2218,5,133,0,0,2215,2217,3,220,110,0,2216,2215,1,0,0,0,2217, + 2220,1,0,0,0,2218,2216,1,0,0,0,2218,2219,1,0,0,0,2219,2221,1,0,0,0,2220, + 2218,1,0,0,0,2221,2222,3,170,85,0,2222,2223,3,138,69,0,2223,2224,3,2,1, + 0,2224,2225,3,112,56,0,2225,2226,3,206,103,0,2226,219,1,0,0,0,2227,2228, + 7,10,0,0,2228,221,1,0,0,0,2229,2231,3,224,112,0,2230,2229,1,0,0,0,2231, + 2234,1,0,0,0,2232,2230,1,0,0,0,2232,2233,1,0,0,0,2233,223,1,0,0,0,2234, + 2232,1,0,0,0,2235,2236,5,134,0,0,2236,2246,3,168,84,0,2237,2238,5,135, + 0,0,2238,2246,3,168,84,0,2239,2240,5,132,0,0,2240,2246,3,168,84,0,2241, + 2246,3,322,161,0,2242,2246,3,88,44,0,2243,2246,3,26,13,0,2244,2246,3,40, + 20,0,2245,2235,1,0,0,0,2245,2237,1,0,0,0,2245,2239,1,0,0,0,2245,2241,1, + 0,0,0,2245,2242,1,0,0,0,2245,2243,1,0,0,0,2245,2244,1,0,0,0,2246,225,1, + 0,0,0,2247,2255,6,113,-1,0,2248,2249,5,122,0,0,2249,2250,5,30,0,0,2250, + 2251,3,228,114,0,2251,2252,5,31,0,0,2252,2253,6,113,-1,0,2253,2255,1,0, + 0,0,2254,2247,1,0,0,0,2254,2248,1,0,0,0,2255,227,1,0,0,0,2256,2257,3,126, + 63,0,2257,2258,6,114,-1,0,2258,2270,1,0,0,0,2259,2263,5,17,0,0,2260,2261, + 3,294,147,0,2261,2262,6,114,-1,0,2262,2264,1,0,0,0,2263,2260,1,0,0,0,2264, + 2265,1,0,0,0,2265,2263,1,0,0,0,2265,2266,1,0,0,0,2266,2267,1,0,0,0,2267, + 2268,5,18,0,0,2268,2270,1,0,0,0,2269,2256,1,0,0,0,2269,2259,1,0,0,0,2270, + 229,1,0,0,0,2271,2272,3,232,116,0,2272,2273,6,115,-1,0,2273,2275,1,0,0, + 0,2274,2271,1,0,0,0,2275,2278,1,0,0,0,2276,2274,1,0,0,0,2276,2277,1,0, + 0,0,2277,231,1,0,0,0,2278,2276,1,0,0,0,2279,2280,5,42,0,0,2280,2281,5, + 136,0,0,2281,2282,5,43,0,0,2282,2297,6,116,-1,0,2283,2284,5,42,0,0,2284, + 2285,5,137,0,0,2285,2286,5,43,0,0,2286,2297,6,116,-1,0,2287,2288,5,42, + 0,0,2288,2289,5,138,0,0,2289,2290,5,43,0,0,2290,2297,6,116,-1,0,2291,2292, + 5,42,0,0,2292,2293,3,32,16,0,2293,2294,5,43,0,0,2294,2295,6,116,-1,0,2295, + 2297,1,0,0,0,2296,2279,1,0,0,0,2296,2283,1,0,0,0,2296,2287,1,0,0,0,2296, + 2291,1,0,0,0,2297,233,1,0,0,0,2298,2303,5,139,0,0,2299,2302,3,236,118, + 0,2300,2302,3,238,119,0,2301,2299,1,0,0,0,2301,2300,1,0,0,0,2302,2305, + 1,0,0,0,2303,2301,1,0,0,0,2303,2304,1,0,0,0,2304,2306,1,0,0,0,2305,2303, + 1,0,0,0,2306,2307,3,170,85,0,2307,2308,3,230,115,0,2308,2309,3,138,69, + 0,2309,2310,3,226,113,0,2310,2311,3,242,121,0,2311,2312,3,182,91,0,2312, + 2316,3,112,56,0,2313,2315,3,244,122,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,235,1,0,0,0,2318,2316,1,0, + 0,0,2319,2343,5,123,0,0,2320,2343,5,51,0,0,2321,2343,5,52,0,0,2322,2343, + 5,63,0,0,2323,2343,5,140,0,0,2324,2343,5,68,0,0,2325,2343,5,141,0,0,2326, + 2343,5,142,0,0,2327,2343,5,54,0,0,2328,2343,5,64,0,0,2329,2343,5,65,0, + 0,2330,2343,5,66,0,0,2331,2343,5,125,0,0,2332,2343,5,143,0,0,2333,2343, + 5,144,0,0,2334,2343,5,69,0,0,2335,2343,5,145,0,0,2336,2343,5,146,0,0,2337, + 2338,5,70,0,0,2338,2339,5,30,0,0,2339,2340,3,32,16,0,2340,2341,5,31,0, + 0,2341,2343,1,0,0,0,2342,2319,1,0,0,0,2342,2320,1,0,0,0,2342,2321,1,0, + 0,0,2342,2322,1,0,0,0,2342,2323,1,0,0,0,2342,2324,1,0,0,0,2342,2325,1, + 0,0,0,2342,2326,1,0,0,0,2342,2327,1,0,0,0,2342,2328,1,0,0,0,2342,2329, + 1,0,0,0,2342,2330,1,0,0,0,2342,2331,1,0,0,0,2342,2332,1,0,0,0,2342,2333, + 1,0,0,0,2342,2334,1,0,0,0,2342,2335,1,0,0,0,2342,2336,1,0,0,0,2342,2337, + 1,0,0,0,2343,237,1,0,0,0,2344,2345,5,147,0,0,2345,2351,5,30,0,0,2346,2349, + 3,6,3,0,2347,2348,5,34,0,0,2348,2350,3,6,3,0,2349,2347,1,0,0,0,2349,2350, + 1,0,0,0,2350,2352,1,0,0,0,2351,2346,1,0,0,0,2351,2352,1,0,0,0,2352,2356, + 1,0,0,0,2353,2355,3,240,120,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, + 2363,5,31,0,0,2360,2361,5,147,0,0,2361,2363,5,85,0,0,2362,2344,1,0,0,0, + 2362,2360,1,0,0,0,2363,239,1,0,0,0,2364,2392,5,148,0,0,2365,2392,5,224, + 0,0,2366,2392,5,57,0,0,2367,2392,5,58,0,0,2368,2392,5,149,0,0,2369,2392, + 5,150,0,0,2370,2392,5,248,0,0,2371,2392,5,249,0,0,2372,2392,5,250,0,0, + 2373,2392,5,251,0,0,2374,2375,5,151,0,0,2375,2376,5,75,0,0,2376,2392,5, + 152,0,0,2377,2378,5,151,0,0,2378,2379,5,75,0,0,2379,2392,5,153,0,0,2380, + 2381,5,154,0,0,2381,2382,5,75,0,0,2382,2392,5,152,0,0,2383,2384,5,154, + 0,0,2384,2385,5,75,0,0,2385,2392,5,153,0,0,2386,2387,5,70,0,0,2387,2388, + 5,30,0,0,2388,2389,3,32,16,0,2389,2390,5,31,0,0,2390,2392,1,0,0,0,2391, + 2364,1,0,0,0,2391,2365,1,0,0,0,2391,2366,1,0,0,0,2391,2367,1,0,0,0,2391, + 2368,1,0,0,0,2391,2369,1,0,0,0,2391,2370,1,0,0,0,2391,2371,1,0,0,0,2391, + 2372,1,0,0,0,2391,2373,1,0,0,0,2391,2374,1,0,0,0,2391,2377,1,0,0,0,2391, + 2380,1,0,0,0,2391,2383,1,0,0,0,2391,2386,1,0,0,0,2392,241,1,0,0,0,2393, + 2394,5,116,0,0,2394,2401,6,121,-1,0,2395,2396,5,155,0,0,2396,2401,6,121, + -1,0,2397,2398,3,2,1,0,2398,2399,6,121,-1,0,2399,2401,1,0,0,0,2400,2393, + 1,0,0,0,2400,2395,1,0,0,0,2400,2397,1,0,0,0,2401,243,1,0,0,0,2402,2424, + 5,1,0,0,2403,2424,5,2,0,0,2404,2424,5,156,0,0,2405,2424,5,3,0,0,2406,2424, + 5,4,0,0,2407,2424,5,247,0,0,2408,2424,5,5,0,0,2409,2424,5,6,0,0,2410,2424, + 5,7,0,0,2411,2424,5,8,0,0,2412,2424,5,9,0,0,2413,2424,5,10,0,0,2414,2424, + 5,11,0,0,2415,2424,5,12,0,0,2416,2424,5,13,0,0,2417,2424,5,14,0,0,2418, + 2419,5,70,0,0,2419,2420,5,30,0,0,2420,2421,3,32,16,0,2421,2422,5,31,0, + 0,2422,2424,1,0,0,0,2423,2402,1,0,0,0,2423,2403,1,0,0,0,2423,2404,1,0, + 0,0,2423,2405,1,0,0,0,2423,2406,1,0,0,0,2423,2407,1,0,0,0,2423,2408,1, + 0,0,0,2423,2409,1,0,0,0,2423,2410,1,0,0,0,2423,2411,1,0,0,0,2423,2412, + 1,0,0,0,2423,2413,1,0,0,0,2423,2414,1,0,0,0,2423,2415,1,0,0,0,2423,2416, + 1,0,0,0,2423,2417,1,0,0,0,2423,2418,1,0,0,0,2424,245,1,0,0,0,2425,2427, + 3,248,124,0,2426,2425,1,0,0,0,2427,2430,1,0,0,0,2428,2426,1,0,0,0,2428, + 2429,1,0,0,0,2429,247,1,0,0,0,2430,2428,1,0,0,0,2431,2449,3,100,50,0,2432, + 2433,5,296,0,0,2433,2434,3,32,16,0,2434,2435,6,124,-1,0,2435,2449,1,0, + 0,0,2436,2449,3,258,129,0,2437,2438,5,297,0,0,2438,2439,3,32,16,0,2439, + 2440,6,124,-1,0,2440,2449,1,0,0,0,2441,2442,5,298,0,0,2442,2449,6,124, + -1,0,2443,2444,5,299,0,0,2444,2449,6,124,-1,0,2445,2449,3,252,126,0,2446, + 2449,3,256,128,0,2447,2449,3,250,125,0,2448,2431,1,0,0,0,2448,2432,1,0, + 0,0,2448,2436,1,0,0,0,2448,2437,1,0,0,0,2448,2441,1,0,0,0,2448,2443,1, + 0,0,0,2448,2445,1,0,0,0,2448,2446,1,0,0,0,2448,2447,1,0,0,0,2449,249,1, + 0,0,0,2450,2451,5,300,0,0,2451,2549,3,112,56,0,2452,2453,5,300,0,0,2453, + 2454,5,157,0,0,2454,2549,3,112,56,0,2455,2549,3,276,138,0,2456,2549,3, + 152,76,0,2457,2549,3,88,44,0,2458,2549,3,26,13,0,2459,2549,3,254,127,0, + 2460,2549,3,40,20,0,2461,2462,5,301,0,0,2462,2463,5,42,0,0,2463,2464,3, + 32,16,0,2464,2465,5,43,0,0,2465,2549,1,0,0,0,2466,2467,5,301,0,0,2467, + 2468,5,42,0,0,2468,2469,3,32,16,0,2469,2470,5,43,0,0,2470,2471,5,34,0, + 0,2471,2472,3,0,0,0,2472,2549,1,0,0,0,2473,2474,5,303,0,0,2474,2475,3, + 32,16,0,2475,2476,5,75,0,0,2476,2477,3,32,16,0,2477,2549,1,0,0,0,2478, + 2479,5,302,0,0,2479,2480,3,124,62,0,2480,2481,5,176,0,0,2481,2482,3,242, + 121,0,2482,2549,1,0,0,0,2483,2484,5,302,0,0,2484,2485,5,226,0,0,2485,2486, + 3,170,85,0,2486,2487,3,138,69,0,2487,2488,3,124,62,0,2488,2489,5,176,0, + 0,2489,2490,3,242,121,0,2490,2491,3,194,97,0,2491,2492,3,112,56,0,2492, + 2549,1,0,0,0,2493,2494,5,255,0,0,2494,2495,5,196,0,0,2495,2496,5,42,0, + 0,2496,2497,3,32,16,0,2497,2501,5,43,0,0,2498,2500,3,322,161,0,2499,2498, + 1,0,0,0,2500,2503,1,0,0,0,2501,2499,1,0,0,0,2501,2502,1,0,0,0,2502,2549, + 1,0,0,0,2503,2501,1,0,0,0,2504,2505,5,255,0,0,2505,2506,5,196,0,0,2506, + 2510,3,2,1,0,2507,2509,3,322,161,0,2508,2507,1,0,0,0,2509,2512,1,0,0,0, + 2510,2508,1,0,0,0,2510,2511,1,0,0,0,2511,2549,1,0,0,0,2512,2510,1,0,0, + 0,2513,2514,5,255,0,0,2514,2515,5,256,0,0,2515,2516,5,42,0,0,2516,2517, + 3,32,16,0,2517,2518,5,43,0,0,2518,2519,5,28,0,0,2519,2523,3,124,62,0,2520, + 2522,3,322,161,0,2521,2520,1,0,0,0,2522,2525,1,0,0,0,2523,2521,1,0,0,0, + 2523,2524,1,0,0,0,2524,2549,1,0,0,0,2525,2523,1,0,0,0,2526,2527,5,255, + 0,0,2527,2528,5,256,0,0,2528,2529,3,2,1,0,2529,2530,5,28,0,0,2530,2534, + 3,124,62,0,2531,2533,3,322,161,0,2532,2531,1,0,0,0,2533,2536,1,0,0,0,2534, + 2532,1,0,0,0,2534,2535,1,0,0,0,2535,2549,1,0,0,0,2536,2534,1,0,0,0,2537, + 2538,5,255,0,0,2538,2539,5,42,0,0,2539,2540,3,32,16,0,2540,2541,5,43,0, + 0,2541,2545,3,206,103,0,2542,2544,3,322,161,0,2543,2542,1,0,0,0,2544,2547, + 1,0,0,0,2545,2543,1,0,0,0,2545,2546,1,0,0,0,2546,2549,1,0,0,0,2547,2545, + 1,0,0,0,2548,2450,1,0,0,0,2548,2452,1,0,0,0,2548,2455,1,0,0,0,2548,2456, + 1,0,0,0,2548,2457,1,0,0,0,2548,2458,1,0,0,0,2548,2459,1,0,0,0,2548,2460, + 1,0,0,0,2548,2461,1,0,0,0,2548,2466,1,0,0,0,2548,2473,1,0,0,0,2548,2478, + 1,0,0,0,2548,2483,1,0,0,0,2548,2493,1,0,0,0,2548,2504,1,0,0,0,2548,2513, + 1,0,0,0,2548,2526,1,0,0,0,2548,2537,1,0,0,0,2549,251,1,0,0,0,2550,2551, + 3,0,0,0,2551,2552,5,75,0,0,2552,2553,6,126,-1,0,2553,253,1,0,0,0,2554, + 2557,3,44,22,0,2555,2557,3,46,23,0,2556,2554,1,0,0,0,2556,2555,1,0,0,0, + 2557,255,1,0,0,0,2558,2559,5,17,0,0,2559,2560,3,246,123,0,2560,2561,5, + 18,0,0,2561,257,1,0,0,0,2562,2563,3,262,131,0,2563,2564,3,260,130,0,2564, + 259,1,0,0,0,2565,2567,3,264,132,0,2566,2565,1,0,0,0,2567,2568,1,0,0,0, + 2568,2566,1,0,0,0,2568,2569,1,0,0,0,2569,261,1,0,0,0,2570,2571,5,158,0, + 0,2571,2583,3,256,128,0,2572,2573,5,158,0,0,2573,2574,3,0,0,0,2574,2575, + 5,159,0,0,2575,2576,3,0,0,0,2576,2583,1,0,0,0,2577,2578,5,158,0,0,2578, + 2579,3,32,16,0,2579,2580,5,159,0,0,2580,2581,3,32,16,0,2581,2583,1,0,0, + 0,2582,2570,1,0,0,0,2582,2572,1,0,0,0,2582,2577,1,0,0,0,2583,263,1,0,0, + 0,2584,2585,3,268,134,0,2585,2586,3,274,137,0,2586,2597,1,0,0,0,2587,2588, + 3,266,133,0,2588,2589,3,274,137,0,2589,2597,1,0,0,0,2590,2591,3,270,135, + 0,2591,2592,3,274,137,0,2592,2597,1,0,0,0,2593,2594,3,272,136,0,2594,2595, + 3,274,137,0,2595,2597,1,0,0,0,2596,2584,1,0,0,0,2596,2587,1,0,0,0,2596, + 2590,1,0,0,0,2596,2593,1,0,0,0,2597,265,1,0,0,0,2598,2599,5,160,0,0,2599, + 2605,3,256,128,0,2600,2601,5,160,0,0,2601,2605,3,0,0,0,2602,2603,5,160, + 0,0,2603,2605,3,32,16,0,2604,2598,1,0,0,0,2604,2600,1,0,0,0,2604,2602, + 1,0,0,0,2605,267,1,0,0,0,2606,2607,5,161,0,0,2607,2608,3,124,62,0,2608, + 269,1,0,0,0,2609,2610,5,162,0,0,2610,271,1,0,0,0,2611,2612,5,163,0,0,2612, + 273,1,0,0,0,2613,2625,3,256,128,0,2614,2615,5,164,0,0,2615,2616,3,0,0, + 0,2616,2617,5,159,0,0,2617,2618,3,0,0,0,2618,2625,1,0,0,0,2619,2620,5, + 164,0,0,2620,2621,3,32,16,0,2621,2622,5,159,0,0,2622,2623,3,32,16,0,2623, + 2625,1,0,0,0,2624,2613,1,0,0,0,2624,2614,1,0,0,0,2624,2619,1,0,0,0,2625, + 275,1,0,0,0,2626,2627,3,278,139,0,2627,2628,3,282,141,0,2628,277,1,0,0, + 0,2629,2630,5,165,0,0,2630,2631,3,280,140,0,2631,2632,3,0,0,0,2632,2633, + 5,36,0,0,2633,2637,1,0,0,0,2634,2635,5,165,0,0,2635,2637,3,280,140,0,2636, + 2629,1,0,0,0,2636,2634,1,0,0,0,2637,279,1,0,0,0,2638,2642,1,0,0,0,2639, + 2642,5,166,0,0,2640,2642,5,2,0,0,2641,2638,1,0,0,0,2641,2639,1,0,0,0,2641, + 2640,1,0,0,0,2642,281,1,0,0,0,2643,2644,5,17,0,0,2644,2645,3,284,142,0, + 2645,2646,5,18,0,0,2646,2653,1,0,0,0,2647,2649,3,288,144,0,2648,2647,1, + 0,0,0,2649,2650,1,0,0,0,2650,2648,1,0,0,0,2650,2651,1,0,0,0,2651,2653, + 1,0,0,0,2652,2643,1,0,0,0,2652,2648,1,0,0,0,2653,283,1,0,0,0,2654,2655, + 3,288,144,0,2655,2656,5,28,0,0,2656,2658,1,0,0,0,2657,2654,1,0,0,0,2658, + 2661,1,0,0,0,2659,2657,1,0,0,0,2659,2660,1,0,0,0,2660,2662,1,0,0,0,2661, + 2659,1,0,0,0,2662,2663,3,288,144,0,2663,285,1,0,0,0,2664,2670,1,0,0,0, + 2665,2666,5,42,0,0,2666,2667,3,32,16,0,2667,2668,5,43,0,0,2668,2670,1, + 0,0,0,2669,2664,1,0,0,0,2669,2665,1,0,0,0,2670,287,1,0,0,0,2671,2672,5, + 181,0,0,2672,2673,5,262,0,0,2673,2674,5,30,0,0,2674,2675,3,6,3,0,2675, + 2676,5,31,0,0,2676,2738,1,0,0,0,2677,2678,5,260,0,0,2678,2679,5,30,0,0, + 2679,2680,3,0,0,0,2680,2681,5,31,0,0,2681,2738,1,0,0,0,2682,2683,5,260, + 0,0,2683,2738,3,0,0,0,2684,2685,5,84,0,0,2685,2686,5,30,0,0,2686,2687, + 3,292,146,0,2687,2688,5,31,0,0,2688,2738,1,0,0,0,2689,2690,5,188,0,0,2690, + 2691,5,30,0,0,2691,2692,3,36,18,0,2692,2693,5,31,0,0,2693,2694,3,286,143, + 0,2694,2738,1,0,0,0,2695,2696,5,189,0,0,2696,2697,5,30,0,0,2697,2698,3, + 36,18,0,2698,2699,5,31,0,0,2699,2700,3,286,143,0,2700,2738,1,0,0,0,2701, + 2702,5,187,0,0,2702,2703,5,30,0,0,2703,2704,3,34,17,0,2704,2705,5,31,0, + 0,2705,2706,3,286,143,0,2706,2738,1,0,0,0,2707,2708,5,186,0,0,2708,2709, + 5,30,0,0,2709,2710,3,32,16,0,2710,2711,5,31,0,0,2711,2712,3,286,143,0, + 2712,2738,1,0,0,0,2713,2714,5,185,0,0,2714,2715,5,30,0,0,2715,2716,3,32, + 16,0,2716,2717,5,31,0,0,2717,2718,3,286,143,0,2718,2738,1,0,0,0,2719,2720, + 5,184,0,0,2720,2721,5,30,0,0,2721,2722,3,32,16,0,2722,2723,5,31,0,0,2723, + 2724,3,286,143,0,2724,2738,1,0,0,0,2725,2726,5,188,0,0,2726,2738,3,286, + 143,0,2727,2728,5,189,0,0,2728,2738,3,286,143,0,2729,2730,5,187,0,0,2730, + 2738,3,286,143,0,2731,2732,5,186,0,0,2732,2738,3,286,143,0,2733,2734,5, + 185,0,0,2734,2738,3,286,143,0,2735,2736,5,184,0,0,2736,2738,3,286,143, + 0,2737,2671,1,0,0,0,2737,2677,1,0,0,0,2737,2682,1,0,0,0,2737,2684,1,0, + 0,0,2737,2689,1,0,0,0,2737,2695,1,0,0,0,2737,2701,1,0,0,0,2737,2707,1, + 0,0,0,2737,2713,1,0,0,0,2737,2719,1,0,0,0,2737,2725,1,0,0,0,2737,2727, + 1,0,0,0,2737,2729,1,0,0,0,2737,2731,1,0,0,0,2737,2733,1,0,0,0,2737,2735, + 1,0,0,0,2738,289,1,0,0,0,2739,2740,5,188,0,0,2740,2741,5,30,0,0,2741,2742, + 3,36,18,0,2742,2743,5,31,0,0,2743,2815,1,0,0,0,2744,2745,5,189,0,0,2745, + 2746,5,30,0,0,2746,2747,3,36,18,0,2747,2748,5,31,0,0,2748,2815,1,0,0,0, + 2749,2750,5,188,0,0,2750,2751,5,30,0,0,2751,2752,3,32,16,0,2752,2753,5, + 31,0,0,2753,2815,1,0,0,0,2754,2755,5,189,0,0,2755,2756,5,30,0,0,2756,2757, + 3,34,17,0,2757,2758,5,31,0,0,2758,2815,1,0,0,0,2759,2760,5,187,0,0,2760, + 2761,5,30,0,0,2761,2762,3,34,17,0,2762,2763,5,31,0,0,2763,2815,1,0,0,0, + 2764,2765,5,186,0,0,2765,2766,5,30,0,0,2766,2767,3,32,16,0,2767,2768,5, + 31,0,0,2768,2815,1,0,0,0,2769,2770,5,185,0,0,2770,2771,5,30,0,0,2771,2772, + 3,32,16,0,2772,2773,5,31,0,0,2773,2815,1,0,0,0,2774,2775,5,184,0,0,2775, + 2776,5,30,0,0,2776,2777,3,32,16,0,2777,2778,5,31,0,0,2778,2815,1,0,0,0, + 2779,2780,5,193,0,0,2780,2781,5,30,0,0,2781,2782,3,34,17,0,2782,2783,5, + 31,0,0,2783,2815,1,0,0,0,2784,2785,5,192,0,0,2785,2786,5,30,0,0,2786,2787, + 3,32,16,0,2787,2788,5,31,0,0,2788,2815,1,0,0,0,2789,2790,5,191,0,0,2790, + 2791,5,30,0,0,2791,2792,3,32,16,0,2792,2793,5,31,0,0,2793,2815,1,0,0,0, + 2794,2795,5,190,0,0,2795,2796,5,30,0,0,2796,2797,3,32,16,0,2797,2798,5, + 31,0,0,2798,2815,1,0,0,0,2799,2800,5,181,0,0,2800,2801,5,30,0,0,2801,2802, + 3,32,16,0,2802,2803,5,31,0,0,2803,2815,1,0,0,0,2804,2805,5,183,0,0,2805, + 2806,5,30,0,0,2806,2807,3,162,81,0,2807,2808,5,31,0,0,2808,2815,1,0,0, + 0,2809,2810,5,84,0,0,2810,2811,5,30,0,0,2811,2812,3,292,146,0,2812,2813, + 5,31,0,0,2813,2815,1,0,0,0,2814,2739,1,0,0,0,2814,2744,1,0,0,0,2814,2749, + 1,0,0,0,2814,2754,1,0,0,0,2814,2759,1,0,0,0,2814,2764,1,0,0,0,2814,2769, + 1,0,0,0,2814,2774,1,0,0,0,2814,2779,1,0,0,0,2814,2784,1,0,0,0,2814,2789, + 1,0,0,0,2814,2794,1,0,0,0,2814,2799,1,0,0,0,2814,2804,1,0,0,0,2814,2809, + 1,0,0,0,2815,291,1,0,0,0,2816,2817,3,294,147,0,2817,2818,6,146,-1,0,2818, + 2820,1,0,0,0,2819,2816,1,0,0,0,2820,2823,1,0,0,0,2821,2819,1,0,0,0,2821, + 2822,1,0,0,0,2822,293,1,0,0,0,2823,2821,1,0,0,0,2824,2825,7,11,0,0,2825, + 295,1,0,0,0,2826,2830,3,290,145,0,2827,2830,3,6,3,0,2828,2830,5,179,0, + 0,2829,2826,1,0,0,0,2829,2827,1,0,0,0,2829,2828,1,0,0,0,2830,297,1,0,0, + 0,2831,2980,3,290,145,0,2832,2833,5,182,0,0,2833,2834,5,30,0,0,2834,2835, + 5,179,0,0,2835,2980,5,31,0,0,2836,2837,5,182,0,0,2837,2838,5,30,0,0,2838, + 2839,5,264,0,0,2839,2980,5,31,0,0,2840,2841,5,196,0,0,2841,2842,5,30,0, + 0,2842,2843,5,39,0,0,2843,2844,5,264,0,0,2844,2980,5,31,0,0,2845,2846, + 5,196,0,0,2846,2847,5,30,0,0,2847,2848,3,116,58,0,2848,2849,5,31,0,0,2849, + 2980,1,0,0,0,2850,2851,5,196,0,0,2851,2852,5,30,0,0,2852,2853,5,179,0, + 0,2853,2980,5,31,0,0,2854,2855,5,197,0,0,2855,2856,5,30,0,0,2856,2857, + 3,298,149,0,2857,2858,5,31,0,0,2858,2980,1,0,0,0,2859,2860,5,188,0,0,2860, + 2861,5,42,0,0,2861,2862,3,32,16,0,2862,2863,5,43,0,0,2863,2864,5,30,0, + 0,2864,2865,3,300,150,0,2865,2866,5,31,0,0,2866,2980,1,0,0,0,2867,2868, + 5,189,0,0,2868,2869,5,42,0,0,2869,2870,3,32,16,0,2870,2871,5,43,0,0,2871, + 2872,5,30,0,0,2872,2873,3,302,151,0,2873,2874,5,31,0,0,2874,2980,1,0,0, + 0,2875,2876,5,187,0,0,2876,2877,5,42,0,0,2877,2878,3,32,16,0,2878,2879, + 5,43,0,0,2879,2880,5,30,0,0,2880,2881,3,304,152,0,2881,2882,5,31,0,0,2882, + 2980,1,0,0,0,2883,2884,5,186,0,0,2884,2885,5,42,0,0,2885,2886,3,32,16, + 0,2886,2887,5,43,0,0,2887,2888,5,30,0,0,2888,2889,3,306,153,0,2889,2890, + 5,31,0,0,2890,2980,1,0,0,0,2891,2892,5,185,0,0,2892,2893,5,42,0,0,2893, + 2894,3,32,16,0,2894,2895,5,43,0,0,2895,2896,5,30,0,0,2896,2897,3,308,154, + 0,2897,2898,5,31,0,0,2898,2980,1,0,0,0,2899,2900,5,184,0,0,2900,2901,5, + 42,0,0,2901,2902,3,32,16,0,2902,2903,5,43,0,0,2903,2904,5,30,0,0,2904, + 2905,3,310,155,0,2905,2906,5,31,0,0,2906,2980,1,0,0,0,2907,2908,5,193, + 0,0,2908,2909,5,42,0,0,2909,2910,3,32,16,0,2910,2911,5,43,0,0,2911,2912, + 5,30,0,0,2912,2913,3,304,152,0,2913,2914,5,31,0,0,2914,2980,1,0,0,0,2915, + 2916,5,192,0,0,2916,2917,5,42,0,0,2917,2918,3,32,16,0,2918,2919,5,43,0, + 0,2919,2920,5,30,0,0,2920,2921,3,306,153,0,2921,2922,5,31,0,0,2922,2980, + 1,0,0,0,2923,2924,5,191,0,0,2924,2925,5,42,0,0,2925,2926,3,32,16,0,2926, + 2927,5,43,0,0,2927,2928,5,30,0,0,2928,2929,3,308,154,0,2929,2930,5,31, + 0,0,2930,2980,1,0,0,0,2931,2932,5,190,0,0,2932,2933,5,42,0,0,2933,2934, + 3,32,16,0,2934,2935,5,43,0,0,2935,2936,5,30,0,0,2936,2937,3,310,155,0, + 2937,2938,5,31,0,0,2938,2980,1,0,0,0,2939,2940,5,181,0,0,2940,2941,5,42, + 0,0,2941,2942,3,32,16,0,2942,2943,5,43,0,0,2943,2944,5,30,0,0,2944,2945, + 3,308,154,0,2945,2946,5,31,0,0,2946,2980,1,0,0,0,2947,2948,5,183,0,0,2948, + 2949,5,42,0,0,2949,2950,3,32,16,0,2950,2951,5,43,0,0,2951,2952,5,30,0, + 0,2952,2953,3,312,156,0,2953,2954,5,31,0,0,2954,2980,1,0,0,0,2955,2956, + 5,182,0,0,2956,2957,5,42,0,0,2957,2958,3,32,16,0,2958,2959,5,43,0,0,2959, + 2960,5,30,0,0,2960,2961,3,314,157,0,2961,2962,5,31,0,0,2962,2980,1,0,0, + 0,2963,2964,5,196,0,0,2964,2965,5,42,0,0,2965,2966,3,32,16,0,2966,2967, + 5,43,0,0,2967,2968,5,30,0,0,2968,2969,3,316,158,0,2969,2970,5,31,0,0,2970, + 2980,1,0,0,0,2971,2972,5,197,0,0,2972,2973,5,42,0,0,2973,2974,3,32,16, + 0,2974,2975,5,43,0,0,2975,2976,5,30,0,0,2976,2977,3,320,160,0,2977,2978, + 5,31,0,0,2978,2980,1,0,0,0,2979,2831,1,0,0,0,2979,2832,1,0,0,0,2979,2836, + 1,0,0,0,2979,2840,1,0,0,0,2979,2845,1,0,0,0,2979,2850,1,0,0,0,2979,2854, + 1,0,0,0,2979,2859,1,0,0,0,2979,2867,1,0,0,0,2979,2875,1,0,0,0,2979,2883, + 1,0,0,0,2979,2891,1,0,0,0,2979,2899,1,0,0,0,2979,2907,1,0,0,0,2979,2915, + 1,0,0,0,2979,2923,1,0,0,0,2979,2931,1,0,0,0,2979,2939,1,0,0,0,2979,2947, + 1,0,0,0,2979,2955,1,0,0,0,2979,2963,1,0,0,0,2979,2971,1,0,0,0,2980,299, + 1,0,0,0,2981,2984,3,36,18,0,2982,2984,3,32,16,0,2983,2981,1,0,0,0,2983, + 2982,1,0,0,0,2984,2987,1,0,0,0,2985,2983,1,0,0,0,2985,2986,1,0,0,0,2986, + 301,1,0,0,0,2987,2985,1,0,0,0,2988,2991,3,36,18,0,2989,2991,3,34,17,0, + 2990,2988,1,0,0,0,2990,2989,1,0,0,0,2991,2994,1,0,0,0,2992,2990,1,0,0, + 0,2992,2993,1,0,0,0,2993,303,1,0,0,0,2994,2992,1,0,0,0,2995,2997,3,34, + 17,0,2996,2995,1,0,0,0,2997,3000,1,0,0,0,2998,2996,1,0,0,0,2998,2999,1, + 0,0,0,2999,305,1,0,0,0,3000,2998,1,0,0,0,3001,3003,3,32,16,0,3002,3001, + 1,0,0,0,3003,3006,1,0,0,0,3004,3002,1,0,0,0,3004,3005,1,0,0,0,3005,307, + 1,0,0,0,3006,3004,1,0,0,0,3007,3009,3,32,16,0,3008,3007,1,0,0,0,3009,3012, + 1,0,0,0,3010,3008,1,0,0,0,3010,3011,1,0,0,0,3011,309,1,0,0,0,3012,3010, + 1,0,0,0,3013,3015,3,32,16,0,3014,3013,1,0,0,0,3015,3018,1,0,0,0,3016,3014, + 1,0,0,0,3016,3017,1,0,0,0,3017,311,1,0,0,0,3018,3016,1,0,0,0,3019,3021, + 3,162,81,0,3020,3019,1,0,0,0,3021,3024,1,0,0,0,3022,3020,1,0,0,0,3022, + 3023,1,0,0,0,3023,313,1,0,0,0,3024,3022,1,0,0,0,3025,3027,7,12,0,0,3026, + 3025,1,0,0,0,3027,3030,1,0,0,0,3028,3026,1,0,0,0,3028,3029,1,0,0,0,3029, + 315,1,0,0,0,3030,3028,1,0,0,0,3031,3033,3,318,159,0,3032,3031,1,0,0,0, + 3033,3036,1,0,0,0,3034,3032,1,0,0,0,3034,3035,1,0,0,0,3035,317,1,0,0,0, + 3036,3034,1,0,0,0,3037,3042,5,179,0,0,3038,3039,5,39,0,0,3039,3042,5,264, + 0,0,3040,3042,3,116,58,0,3041,3037,1,0,0,0,3041,3038,1,0,0,0,3041,3040, + 1,0,0,0,3042,319,1,0,0,0,3043,3045,3,298,149,0,3044,3043,1,0,0,0,3045, + 3048,1,0,0,0,3046,3044,1,0,0,0,3046,3047,1,0,0,0,3047,321,1,0,0,0,3048, + 3046,1,0,0,0,3049,3053,3,44,22,0,3050,3053,3,46,23,0,3051,3053,3,2,1,0, + 3052,3049,1,0,0,0,3052,3050,1,0,0,0,3052,3051,1,0,0,0,3053,323,1,0,0,0, + 3054,3055,7,13,0,0,3055,3056,5,36,0,0,3056,3057,5,30,0,0,3057,3058,3,292, + 146,0,3058,3059,5,31,0,0,3059,3080,1,0,0,0,3060,3061,5,169,0,0,3061,3062, + 3,38,19,0,3062,3063,5,75,0,0,3063,3064,3,38,19,0,3064,3065,5,75,0,0,3065, + 3066,3,38,19,0,3066,3067,5,75,0,0,3067,3068,3,38,19,0,3068,3080,1,0,0, + 0,3069,3070,5,170,0,0,3070,3080,3,6,3,0,3071,3072,5,170,0,0,3072,3073, + 5,36,0,0,3073,3074,5,30,0,0,3074,3075,3,292,146,0,3075,3076,5,31,0,0,3076, + 3080,1,0,0,0,3077,3080,3,322,161,0,3078,3080,3,40,20,0,3079,3054,1,0,0, + 0,3079,3060,1,0,0,0,3079,3069,1,0,0,0,3079,3071,1,0,0,0,3079,3077,1,0, + 0,0,3079,3078,1,0,0,0,3080,325,1,0,0,0,3081,3082,5,25,0,0,3082,3083,5, + 40,0,0,3083,3084,3,98,49,0,3084,3085,3,2,1,0,3085,3094,1,0,0,0,3086,3087, + 5,25,0,0,3087,3088,5,40,0,0,3088,3089,3,98,49,0,3089,3090,3,2,1,0,3090, + 3091,5,34,0,0,3091,3092,3,2,1,0,3092,3094,1,0,0,0,3093,3081,1,0,0,0,3093, + 3086,1,0,0,0,3094,327,1,0,0,0,3095,3097,3,330,165,0,3096,3095,1,0,0,0, + 3097,3100,1,0,0,0,3098,3096,1,0,0,0,3098,3099,1,0,0,0,3099,329,1,0,0,0, + 3100,3098,1,0,0,0,3101,3102,5,180,0,0,3102,3103,5,36,0,0,3103,3104,5,30, + 0,0,3104,3105,3,292,146,0,3105,3106,5,31,0,0,3106,3116,1,0,0,0,3107,3116, + 3,324,162,0,3108,3109,5,171,0,0,3109,3110,5,36,0,0,3110,3111,5,30,0,0, + 3111,3112,3,292,146,0,3112,3113,5,31,0,0,3113,3116,1,0,0,0,3114,3116,5, + 55,0,0,3115,3101,1,0,0,0,3115,3107,1,0,0,0,3115,3108,1,0,0,0,3115,3114, + 1,0,0,0,3116,331,1,0,0,0,3117,3118,5,50,0,0,3118,3122,5,40,0,0,3119,3121, + 3,336,168,0,3120,3119,1,0,0,0,3121,3124,1,0,0,0,3122,3120,1,0,0,0,3122, + 3123,1,0,0,0,3123,3125,1,0,0,0,3124,3122,1,0,0,0,3125,3126,3,2,1,0,3126, + 333,1,0,0,0,3127,3131,5,301,0,0,3128,3130,3,336,168,0,3129,3128,1,0,0, + 0,3130,3133,1,0,0,0,3131,3129,1,0,0,0,3131,3132,1,0,0,0,3132,3134,1,0, + 0,0,3133,3131,1,0,0,0,3134,3135,3,2,1,0,3135,335,1,0,0,0,3136,3152,5,52, + 0,0,3137,3152,5,51,0,0,3138,3152,5,172,0,0,3139,3140,5,62,0,0,3140,3152, + 5,51,0,0,3141,3142,5,62,0,0,3142,3152,5,52,0,0,3143,3144,5,62,0,0,3144, + 3152,5,63,0,0,3145,3146,5,62,0,0,3146,3152,5,64,0,0,3147,3148,5,62,0,0, + 3148,3152,5,65,0,0,3149,3150,5,62,0,0,3150,3152,5,66,0,0,3151,3136,1,0, + 0,0,3151,3137,1,0,0,0,3151,3138,1,0,0,0,3151,3139,1,0,0,0,3151,3141,1, + 0,0,0,3151,3143,1,0,0,0,3151,3145,1,0,0,0,3151,3147,1,0,0,0,3151,3149, + 1,0,0,0,3152,337,1,0,0,0,3153,3155,3,340,170,0,3154,3153,1,0,0,0,3155, + 3158,1,0,0,0,3156,3154,1,0,0,0,3156,3157,1,0,0,0,3157,339,1,0,0,0,3158, + 3156,1,0,0,0,3159,3160,5,21,0,0,3160,3173,3,2,1,0,3161,3162,5,50,0,0,3162, + 3163,5,40,0,0,3163,3173,3,118,59,0,3164,3165,5,25,0,0,3165,3166,5,40,0, + 0,3166,3173,3,2,1,0,3167,3173,3,174,87,0,3168,3169,5,50,0,0,3169,3173, + 3,32,16,0,3170,3173,3,322,161,0,3171,3173,3,40,20,0,3172,3159,1,0,0,0, + 3172,3161,1,0,0,0,3172,3164,1,0,0,0,3172,3167,1,0,0,0,3172,3168,1,0,0, + 0,3172,3170,1,0,0,0,3172,3171,1,0,0,0,3173,341,1,0,0,0,3174,3178,5,274, + 0,0,3175,3177,3,344,172,0,3176,3175,1,0,0,0,3177,3180,1,0,0,0,3178,3176, + 1,0,0,0,3178,3179,1,0,0,0,3179,3181,1,0,0,0,3180,3178,1,0,0,0,3181,3194, + 3,2,1,0,3182,3186,5,274,0,0,3183,3185,3,344,172,0,3184,3183,1,0,0,0,3185, + 3188,1,0,0,0,3186,3184,1,0,0,0,3186,3187,1,0,0,0,3187,3189,1,0,0,0,3188, + 3186,1,0,0,0,3189,3190,3,2,1,0,3190,3191,5,34,0,0,3191,3192,3,2,1,0,3192, + 3194,1,0,0,0,3193,3174,1,0,0,0,3193,3182,1,0,0,0,3194,343,1,0,0,0,3195, + 3196,7,14,0,0,3196,345,1,0,0,0,3197,3199,3,348,174,0,3198,3197,1,0,0,0, + 3199,3202,1,0,0,0,3200,3198,1,0,0,0,3200,3201,1,0,0,0,3201,347,1,0,0,0, + 3202,3200,1,0,0,0,3203,3204,5,21,0,0,3204,3205,3,2,1,0,3205,3206,5,44, + 0,0,3206,3207,3,32,16,0,3207,3214,1,0,0,0,3208,3209,5,25,0,0,3209,3210, + 5,40,0,0,3210,3214,3,2,1,0,3211,3214,3,322,161,0,3212,3214,3,40,20,0,3213, + 3203,1,0,0,0,3213,3208,1,0,0,0,3213,3211,1,0,0,0,3213,3212,1,0,0,0,3214, + 349,1,0,0,0,176,360,368,377,386,439,480,489,519,523,541,568,591,627,637, 644,646,656,658,665,676,684,705,707,723,768,773,778,783,791,901,907,923, 929,935,942,970,1048,1050,1064,1070,1079,1081,1090,1104,1118,1126,1134, - 1138,1177,1185,1194,1202,1221,1228,1231,1250,1344,1353,1360,1363,1374, - 1406,1466,1506,1522,1532,1559,1583,1591,1595,1610,1617,1662,1672,1690, - 1708,1727,1748,1767,1782,1789,1799,1812,1817,1822,1831,1841,1927,1936, - 1949,1960,1968,1978,1980,2007,2014,2019,2026,2032,2042,2046,2053,2068, - 2074,2088,2101,2109,2116,2120,2127,2147,2152,2154,2167,2193,2200,2202, - 2207,2213,2242,2251,2274,2279,2299,2352,2361,2374,2385,2396,2399,2407, - 2419,2433,2447,2455,2475,2487,2492,2501,2503,2510,2520,2588,2665,2672, - 2680,2830,2834,2836,2841,2843,2849,2855,2861,2867,2873,2879,2885,2892, - 2897,2903,2930,2944,2949,2966,2973,2982,3002,3007,3023,3029,3037,3044, - 3051,3064 + 1138,1177,1185,1194,1202,1221,1231,1234,1258,1405,1415,1424,1427,1509, + 1518,1550,1610,1650,1666,1676,1703,1727,1735,1739,1754,1761,1806,1816, + 1834,1852,1871,1892,1911,1926,1933,1943,1956,1961,1966,1975,1985,2071, + 2080,2093,2104,2112,2122,2124,2151,2158,2163,2170,2176,2186,2190,2197, + 2212,2218,2232,2245,2254,2265,2269,2276,2296,2301,2303,2316,2342,2349, + 2351,2356,2362,2391,2400,2423,2428,2448,2501,2510,2523,2534,2545,2548, + 2556,2568,2582,2596,2604,2624,2636,2641,2650,2652,2659,2669,2737,2814, + 2821,2829,2979,2983,2985,2990,2992,2998,3004,3010,3016,3022,3028,3034, + 3041,3046,3052,3079,3093,3098,3115,3122,3131,3151,3156,3172,3178,3186, + 3193,3200,3213 }; public static readonly ATN _ATN = diff --git a/src/tools/ilasm/tests/ILAssembler.Tests/InteropTests.cs b/src/tools/ilasm/tests/ILAssembler.Tests/InteropTests.cs index 66b01d758db456..256c74b16c59a3 100644 --- a/src/tools/ilasm/tests/ILAssembler.Tests/InteropTests.cs +++ b/src/tools/ilasm/tests/ILAssembler.Tests/InteropTests.cs @@ -205,6 +205,84 @@ .field public marshal({{blob}}) int32[] Values Assert.Equal(Convert.FromHexString(expectedHex), reader.GetBlobBytes(field.GetMarshallingDescriptor())); } + [Fact] + public void MalformedRawMarshalBlob_DoesNotLeakIntoFollowingField() + { + string source = """ + .assembly test { } + .class public auto ansi Test + { + .field public marshal({ }) int32 Bad + .field public marshal({ 2A 50 }) int32[] Good + } + """; + + DocumentCompiler compiler = new(); + var (diagnostics, result) = compiler.Compile( + new SourceText(source, "test.il"), + _ => { Assert.Fail("Expected no includes"); return default; }, + _ => { Assert.Fail("Expected no resources"); return default; }, + new Options { ErrorTolerant = true }); + + Assert.Contains(diagnostics, diagnostic => diagnostic.Id == "Parser"); + Assert.NotNull(result); + + BlobBuilder image = new(); + result!.Serialize(image); + using PEReader pe = new(image.ToImmutableArray()); + MetadataReader reader = pe.GetMetadataReader(); + FieldDefinition good = reader.FieldDefinitions + .Select(reader.GetFieldDefinition) + .Single(field => reader.GetString(field.Name) == "Good"); + + Assert.Equal([0x2A, 0x50], reader.GetBlobBytes(good.GetMarshallingDescriptor())); + } + + [Theory] + [InlineData("marshal({")] + [InlineData("marshal(fixed array[2] int32[3 +")] + [InlineData("marshal(custom(\"Marshaller\",")] + public void MalformedNestedMarshal_DoesNotLeakFramesIntoNextDocument(string malformedMarshal) + { + ImmutableArray documents = + [ + new SourceText($$""" + .assembly test { } + .class public auto ansi Broken + { + .method public static void M(object {{malformedMarshal}} + """, "broken.il"), + new SourceText(""" + .class public auto ansi Following + { + .field public marshal(fixed array[2] int16[3+1]) int16[] Values + } + """, "following.il") + ]; + + DocumentCompiler compiler = new(); + var (diagnostics, result) = compiler.Compile( + documents, + _ => { Assert.Fail("Expected no includes"); return default; }, + _ => { Assert.Fail("Expected no resources"); return default; }, + new Options { ErrorTolerant = true }); + + Assert.Contains(diagnostics, diagnostic => diagnostic.Id == "Parser"); + Assert.NotNull(result); + + BlobBuilder image = new(); + result!.Serialize(image); + using PEReader pe = new(image.ToImmutableArray()); + MetadataReader reader = pe.GetMetadataReader(); + FieldDefinition field = reader.FieldDefinitions + .Select(reader.GetFieldDefinition) + .Single(field => reader.GetString(field.Name) == "Values"); + + Assert.Equal( + [0x1E, 0x02, 0x2A, 0x05, 0x01, 0x03, 0x01], + reader.GetBlobBytes(field.GetMarshallingDescriptor())); + } + [Theory] [InlineData("int8", UnmanagedType.U1)] [InlineData("int16", UnmanagedType.U2)] From 00d2289d1cba64cc3cc70634c56d254d2d75b308 Mon Sep 17 00:00:00 2001 From: Jeremy Koritzinsky Date: Thu, 13 Aug 2026 13:16:17 -0700 Subject: [PATCH 07/16] Compile method directives and exception regions during parsing Replace the generic method-declaration and SEH subtrees with direct method directive actions and synthesized exception-region descriptors. Keep nested scopes and handlers tree-free while preserving catch type and label allocation order. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: c986c103-8383-4db4-9b11-9be49dc68a05 --- src/tools/ilasm/README.md | 14 +- .../GrammarActions.MethodBodies.Directives.cs | 355 + ...rActions.MethodBodies.ExceptionHandling.cs | 337 + .../GrammarActions.MethodBodies.Values.cs | 121 + .../Actions/GrammarActions.MethodBodies.cs | 523 +- .../src/ILAssembler/Actions/GrammarActions.cs | 4 + src/tools/ilasm/src/ILAssembler/gen/CIL.g4 | 192 +- .../ilasm/src/ILAssembler/gen/CIL.interp | 8 +- .../src/ILAssembler/gen/CILBaseVisitor.cs | 44 +- .../ilasm/src/ILAssembler/gen/CILParser.cs | 7232 +++++++++-------- .../ilasm/src/ILAssembler/gen/CILVisitor.cs | 28 +- .../ILAssembler.Tests/CustomAttributeTests.cs | 60 + .../ExceptionHandlingTests.cs | 94 + 13 files changed, 4954 insertions(+), 4058 deletions(-) create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.Directives.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.ExceptionHandling.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.Values.cs diff --git a/src/tools/ilasm/README.md b/src/tools/ilasm/README.md index adf57049301b34..463e5ac0026493 100644 --- a/src/tools/ilasm/README.md +++ b/src/tools/ilasm/README.md @@ -26,7 +26,10 @@ accumulator instead of building a subtree at all. | `GrammarActions.Marshalling.Actions.cs` | Synthesized native type and marshalling descriptor actions. | | `GrammarActions.Marshalling.cs` | Marshalling visitor wrappers and P/Invoke conversion. | | `GrammarActions.Members.cs` | Class member dispatch and conversion. | -| `GrammarActions.MethodBodies.cs` | Method, lexical scope and exception-handling state and conversion. | +| `GrammarActions.MethodBodies.cs` | Method headers and parser-driven visitor guards. | +| `GrammarActions.MethodBodies.Directives.cs` | Direct method-body directives and parameter ownership. | +| `GrammarActions.MethodBodies.ExceptionHandling.cs` | Lexical scopes and synthesized exception regions. | +| `GrammarActions.MethodBodies.Values.cs` | Internal method-body directive and exception-region values. | | `GrammarActions.Security.cs` | Declarative security conversion. | | `GrammarActions.Signatures.cs` | Signature visitor compatibility wrappers. | | `GrammarActions.Signatures.Actions.cs` | Signature grammar actions and repetition frames. | @@ -50,9 +53,12 @@ ILAssembler entities and signature implementation values remain internal, so gen slots use `object` where an internal value or array crosses that boundary and `GrammarActions` provides the strongly typed accessors. -All type, signature, reference and marshalling rules synthesize values without retaining parse -subtrees. The remaining `BeginSubtree` islands are structural: `decl`, `nameSpaceHead`, -`classHead`, `classDecl`, `methodHead`, `methodDeclIsland` and `sehBlock`. +All type, signature, reference, marshalling, method-body directive and exception-handling rules +synthesize values without retaining item or exception-block subtrees. `scopeBlock` records offsets +under its context key without inspecting children. The remaining `BeginSubtree` islands are +declaration/member structure (`decl`, `nameSpaceHead`, `classHead`, `classDecl`, and `methodHead`) +and bounded shared directives such as data, security, source, language, initialization and custom +attribute declarations. Semantic state that a rule pushes must be released from that rule's `finally` clause and be keyed on the owning context, because ANTLR skips `@after` actions and the remainder of an alternative once a diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.Directives.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.Directives.cs new file mode 100644 index 00000000000000..89ef0e03391002 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.Directives.cs @@ -0,0 +1,355 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Linq; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; + +namespace ILAssembler; + +internal sealed partial class GrammarActions +{ + internal void EndLocalsDirective(CILParser.LocalsDeclContext context) + { + bool hasSyntaxError = EndSemanticRoot(context); + if (hasSyntaxError || _currentMethod is null || context.arguments is null) + { + return; + } + + if (context.initialize is not null) + { + _currentMethod.Definition.BodyAttributes = MethodBodyAttributes.InitLocals; + } + + Dictionary localsScope; + if (_currentMethod.LocalsScopes.Count > 0) + { + localsScope = _currentMethod.LocalsScopes[^1]; + } + else + { + localsScope = new(); + _currentMethod.LocalsScopes.Add(localsScope); + } + + ImmutableArray locals = + MaterializeSignatureArguments(GetSignatureArgumentsValue(context.arguments.Value)); + foreach (SignatureArg local in locals) + { + if (local.Name is not null) + { + localsScope.TryAdd(local.Name, _currentMethod.AllLocals.Count); + } + + _currentMethod.AllLocals.Add(local); + } + } + + internal void EndExportDirective(CILParser.ExportDeclContext context) + { + bool hasSyntaxError = EndSemanticRoot(context); + if (hasSyntaxError || _currentMethod is null || context.ordinal is null) + { + return; + } + + _currentMethod.Definition.ExportOrdinal = ParseInt32(context.ordinal.Start); + _currentMethod.Definition.ExportAlias = + context.alias is null ? null : ParseIdentifier(context.alias.Start); + } + + internal void EndVTableEntryDirective(CILParser.VtentryDeclContext context) + { + bool hasSyntaxError = EndSemanticRoot(context); + if (hasSyntaxError || _currentMethod is null || context.table is null || context.slot is null) + { + return; + } + + _currentMethod.Definition.VTableEntry = ParseInt32(context.table.Start); + _currentMethod.Definition.VTableSlot = ParseInt32(context.slot.Start); + } + + internal void EndOverrideDirective(CILParser.OverrideDeclContext context) + { + bool hasSyntaxError = EndSemanticRoot(context); + if (hasSyntaxError || + _currentMethod is null || + context.owner is null || + context.name is null || + _currentTypeDefinition.PeekOrDefault() is not { } currentType) + { + return; + } + + BlobBuilder signature = _currentMethod.Definition.MethodSignature!; + if (context.convention is not null) + { + if (context.returnType is null || context.arity is null || context.arguments is null) + { + return; + } + + signature = BuildOverrideSignature( + context.convention.Value, + context.returnType.Value, + context.arity.Value, + context.arguments.Value); + } + + EntityRegistry.TypeEntity owner = + ResolveTypeSpecification(GetTypeSpecificationValue(context.owner.Value)); + EntityRegistry.MemberReferenceEntity declaration = + _entityRegistry.CreateLazilyRecordedMemberReference(owner, context.name.Value, signature); + currentType.MethodImplementations.Add( + EntityRegistry.CreateUnrecordedMethodImplementation(_currentMethod.Definition, declaration)); + } + + private BlobBuilder BuildOverrideSignature( + byte callingConvention, + object? returnType, + int genericArity, + object? signatureArguments) + { + BlobBuilder signature = new(); + byte header = callingConvention; + if (genericArity > 0) + { + header |= (byte)SignatureAttributes.Generic; + } + + signature.WriteByte(header); + if (genericArity > 0) + { + signature.WriteCompressedInteger(genericArity); + } + + ImmutableArray arguments = + MaterializeSignatureArguments(GetSignatureArgumentsValue(signatureArguments)); + signature.WriteCompressedInteger(arguments.Length); + MaterializeType(GetTypeValue(returnType)).WriteContentTo(signature); + foreach (SignatureArg argument in arguments) + { + argument.SignatureBlob.WriteContentTo(signature); + } + + return signature; + } + + internal void BeginParameterDirective(CILParser.ParameterDeclContext context) + { + BeginSemanticRoot(context); + _parameterDirectiveFrames.Push(new(context)); + } + + internal void AddParameterCustomAttribute( + CILParser.ParameterDeclContext context, + CILParser.CustomAttrDeclContext attribute) + { + Debug.Assert(_parameterDirectiveFrames.Count > 0); + if (_parameterDirectiveFrames.Count == 0) + { + return; + } + + ParameterDirectiveFrame frame = _parameterDirectiveFrames.Peek(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + if (ReferenceEquals(frame.Owner, context)) + { + frame.CustomAttributes.Add(attribute); + } + } + + internal void EndParameterDirective(CILParser.ParameterDeclContext context) + { + ParameterDirectiveFrame? frame = null; + Debug.Assert(_parameterDirectiveFrames.Count > 0); + if (_parameterDirectiveFrames.Count > 0 && + ReferenceEquals(_parameterDirectiveFrames.Peek().Owner, context)) + { + frame = _parameterDirectiveFrames.Pop(); + } + + bool hasSyntaxError = EndSemanticRoot(context); + if (hasSyntaxError || frame is null || _currentMethod is null) + { + return; + } + + if (context.genericIndex is not null || context.genericName is not null) + { + EntityRegistry.GenericParameterEntity? parameter = ResolveMethodGenericParameter( + context.genericIndex, + context.genericName?.Value, + context); + if (parameter is not null) + { + ApplyCustomAttributes(frame.CustomAttributes, parameter); + } + + return; + } + + if (context.constraintIndex is not null || context.constraintName is not null) + { + EntityRegistry.GenericParameterEntity? parameter = ResolveMethodGenericParameter( + context.constraintIndex, + context.constraintName?.Value, + context); + if (parameter is null || context.constraintType is null) + { + return; + } + + EntityRegistry.TypeEntity baseType = + ResolveTypeSpecification(GetTypeSpecificationValue(context.constraintType.Value)); + EntityRegistry.GenericParameterConstraintEntity? constraint = + parameter.Constraints.FirstOrDefault(candidate => candidate.BaseType == baseType); + if (constraint is null) + { + constraint = EntityRegistry.CreateGenericConstraint(baseType); + constraint.Owner = parameter; + parameter.Constraints.Add(constraint); + _currentMethod.Definition.GenericParameterConstraints.Add(constraint); + } + + ApplyCustomAttributes(frame.CustomAttributes, constraint); + return; + } + + if (context.parameterIndex is null || context.initializer is null) + { + return; + } + + int index = ParseInt32(context.parameterIndex.Start); + if ((uint)index >= (uint)_currentMethod.Definition.Parameters.Count) + { + ReportError( + DiagnosticIds.ParameterIndexOutOfRange, + string.Format(DiagnosticMessageTemplates.ParameterIndexOutOfRange, index), + context); + return; + } + + EntityRegistry.ParameterEntity parameterEntity = _currentMethod.Definition.Parameters[index]; + object? constantValue = VisitInitOpt(context.initializer).Value; + if (constantValue is not NoConstantSentinel) + { + parameterEntity.ConstantValue = constantValue; + parameterEntity.HasConstant = true; + } + + foreach (CILParser.CustomAttrDeclContext attributeContext in frame.CustomAttributes) + { + EntityRegistry.CustomAttributeEntity? attribute = VisitCustomAttrDecl(attributeContext).Value; + if (attribute is not null) + { + attribute.Owner = parameterEntity; + parameterEntity.HasCustomAttributes = true; + } + } + } + + private EntityRegistry.GenericParameterEntity? ResolveMethodGenericParameter( + CILParser.Int32Context? indexContext, + string? name, + CILParser.ParameterDeclContext diagnosticContext) + { + Debug.Assert(_currentMethod is not null); + if (indexContext is not null) + { + int index = ParseInt32(indexContext.Start); + if ((uint)index >= (uint)_currentMethod.Definition.GenericParameters.Count) + { + ReportError( + DiagnosticIds.GenericParameterIndexOutOfRange, + string.Format(DiagnosticMessageTemplates.GenericParameterIndexOutOfRange, index), + diagnosticContext); + return null; + } + + return _currentMethod.Definition.GenericParameters[index]; + } + + EntityRegistry.GenericParameterEntity? parameter = + _currentMethod.Definition.GenericParameters.FirstOrDefault(candidate => candidate.Name == name); + if (parameter is null) + { + ReportError( + DiagnosticIds.UnknownGenericParameter, + string.Format(DiagnosticMessageTemplates.UnknownGenericParameter, name), + diagnosticContext); + } + + return parameter; + } + + private void ApplyCustomAttributes( + List attributeContexts, + EntityRegistry.EntityBase owner) + { + foreach (CILParser.CustomAttrDeclContext attributeContext in attributeContexts) + { + EntityRegistry.CustomAttributeEntity? attribute = VisitCustomAttrDecl(attributeContext).Value; + if (attribute is not null) + { + attribute.Owner = owner; + } + } + } + + internal void ProcessMethodDataDeclaration(CILParser.DataDeclContext context) + { + if (_currentMethod is not null && !context.HasSyntaxError) + { + _ = VisitDataDecl(context); + } + } + + internal void ProcessMethodSecurityDeclaration(CILParser.SecDeclContext context) + { + if (_currentMethod is null || context.HasSyntaxError) + { + return; + } + + EntityRegistry.DeclarativeSecurityAttributeEntity? security = VisitSecDecl(context).Value; + security?.Parent = _currentMethod.Definition; + } + + internal void ProcessMethodSourceDirective(CILParser.ExtSourceSpecContext context) + { + if (_currentMethod is not null && !context.HasSyntaxError) + { + _ = VisitExtSourceSpec(context); + } + } + + internal void ProcessMethodLanguageDirective(CILParser.LanguageDeclContext context) + { + if (_currentMethod is not null && !context.HasSyntaxError) + { + _ = VisitLanguageDecl(context); + } + } + + internal void ProcessMethodCustomAttribute(CILParser.CustomDescrInMethodBodyContext context) + { + if (_currentMethod is null || context.HasSyntaxError) + { + return; + } + + EntityRegistry.CustomAttributeEntity? attribute = VisitCustomDescrInMethodBody(context).Value; + if (attribute is not null) + { + attribute.Owner = _currentMethod.Definition; + } + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.ExceptionHandling.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.ExceptionHandling.cs new file mode 100644 index 00000000000000..8df08131bd3a72 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.ExceptionHandling.cs @@ -0,0 +1,337 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using Antlr4.Runtime; + +namespace ILAssembler; + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. +internal sealed partial class GrammarActions +{ + private readonly Dictionary _scopeRanges = new(); + private readonly Stack _scopeStack = new(); + private RuleContext? _methodOwner; + + internal void BeginMethod(CILParser.MethodHeadContext context) + { + ClearPendingCustomAttributeOwners(); + ResetMethodBodyState(); + _currentMethod = new CurrentMethodContext(VisitMethodHead(context).Value); + _methodOwner = context.Parent; + } + + private void EndMethod() + { + Debug.Assert( + _scopeStack.Count == 0 && + _parameterDirectiveFrames.Count == 0 && + _exceptionBlockFrames.Count == 0 && + _exceptionClauseListFrames.Count == 0 && + _catchClauseFrames.Count == 0 && + _semanticRootFrames.Count == 0, + "Method-body frames must be released by their owning rules."); + + _methodOwner = null; + if (_currentMethod is not null) + { + if (_currentMethod.AllLocals.Count > 0) + { + BlobBuilder localsSignature = new(); + BlobEncoder encoder = new(localsSignature); + LocalVariablesEncoder localsEncoder = + encoder.LocalVariableSignature(_currentMethod.AllLocals.Count); + foreach (SignatureArg local in _currentMethod.AllLocals) + { + local.SignatureBlob.WriteContentTo(localsEncoder.AddVariable().Builder); + } + + _currentMethod.Definition.LocalsSignature = + _entityRegistry.GetOrCreateStandaloneSignature(localsSignature); + } + + ValidateLabelReferences(); + _currentMethod = null; + } + + ResetMethodBodyState(); + ClearPendingCustomAttributeOwners(); + } + + private void ResetMethodBodyState() + { + _scopeRanges.Clear(); + _scopeStack.Clear(); + _parameterDirectiveFrames.Clear(); + _exceptionBlockFrames.Clear(); + _exceptionClauseListFrames.Clear(); + _catchClauseFrames.Clear(); + } + + internal void BeginScope(CILParser.ScopeBlockContext context) + { + if (_currentMethod is not null) + { + _scopeStack.Push( + new ScopeFrame(context, CurrentMethodBodyOffset, _currentMethod.LocalsScopes.Count)); + } + } + + internal void EndScope(CILParser.ScopeBlockContext context) + { + if (_scopeStack.Count == 0 || !ReferenceEquals(_scopeStack.Peek().Context, context)) + { + return; + } + + ScopeFrame frame = _scopeStack.Pop(); + if (_currentMethod is not null && frame.LocalsScopeCount < _currentMethod.LocalsScopes.Count) + { + _currentMethod.LocalsScopes.RemoveRange( + frame.LocalsScopeCount, + _currentMethod.LocalsScopes.Count - frame.LocalsScopeCount); + } + + _scopeRanges[context] = (frame.Start, CurrentMethodBodyOffset); + } + + internal void BeginExceptionBlock(CILParser.SehBlockContext context) + => _exceptionBlockFrames.Push(new(context, _syntaxErrorCount)); + + internal void EndExceptionBlock(CILParser.SehBlockContext context) + { + Debug.Assert(_exceptionBlockFrames.Count > 0); + if (_exceptionBlockFrames.Count == 0 || + !ReferenceEquals(_exceptionBlockFrames.Peek().Owner, context)) + { + return; + } + + ExceptionBlockFrame frame = _exceptionBlockFrames.Pop(); + if (_currentMethod is null || + frame.InitialSyntaxErrorCount != _syntaxErrorCount || + context.exception is not null || + context.tryRange is null || + context.clauses is null) + { + return; + } + + ExceptionRangeValue tryRangeValue = GetExceptionRangeValue(context.tryRange.Value); + (LabelHandle Start, LabelHandle End)? tryRange = ResolveExceptionRange(tryRangeValue); + if (tryRange is null) + { + return; + } + + foreach (ExceptionClauseValue clause in GetExceptionClausesValue(context.clauses.Value)) + { + (LabelHandle Start, LabelHandle End)? handlerRange = ResolveExceptionRange(clause.Handler); + if (handlerRange is null) + { + continue; + } + + switch (clause) + { + case FinallyExceptionClauseValue: + AddExceptionRegion(new EntityRegistry.ExceptionRegion.FinallyRegion( + tryRange.Value.Start, + tryRange.Value.End, + handlerRange.Value.Start, + handlerRange.Value.End)); + break; + case FaultExceptionClauseValue: + AddExceptionRegion(new EntityRegistry.ExceptionRegion.FaultRegion( + tryRange.Value.Start, + tryRange.Value.End, + handlerRange.Value.Start, + handlerRange.Value.End)); + break; + case CatchExceptionClauseValue { CatchType: { IsValid: true, Type: not null } catchType }: + AddExceptionRegion(new EntityRegistry.ExceptionRegion.CatchRegion( + tryRange.Value.Start, + tryRange.Value.End, + handlerRange.Value.Start, + handlerRange.Value.End, + catchType.Type)); + break; + case FilterExceptionClauseValue filterClause + when ResolveExceptionFilter(filterClause.Filter) is LabelHandle filterStart: + AddExceptionRegion(new EntityRegistry.ExceptionRegion.FilterRegion( + tryRange.Value.Start, + tryRange.Value.End, + handlerRange.Value.Start, + handlerRange.Value.End, + filterStart)); + break; + } + } + } + + internal void BeginExceptionClauses(CILParser.SehClausesContext context) + => _exceptionClauseListFrames.Push(new(context)); + + internal void AddExceptionClause(CILParser.SehClausesContext context, object? clause) + { + Debug.Assert(_exceptionClauseListFrames.Count > 0); + if (_exceptionClauseListFrames.Count == 0) + { + return; + } + + ExceptionClauseListFrame frame = _exceptionClauseListFrames.Peek(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + if (ReferenceEquals(frame.Owner, context)) + { + frame.Clauses.Add(GetExceptionClauseValue(clause)); + } + } + + internal object EndExceptionClauses(CILParser.SehClausesContext context) + { + Debug.Assert(_exceptionClauseListFrames.Count > 0); + if (_exceptionClauseListFrames.Count == 0 || + !ReferenceEquals(_exceptionClauseListFrames.Peek().Owner, context)) + { + return ImmutableArray.Empty; + } + + return _exceptionClauseListFrames.Pop().Clauses.ToImmutable(); + } + + internal void BeginCatchClause(CILParser.CatchClauseContext context) + => _catchClauseFrames.Push(new(context, _syntaxErrorCount)); + + internal object EndCatchClause(CILParser.CatchClauseContext context) + { + Debug.Assert(_catchClauseFrames.Count > 0); + if (_catchClauseFrames.Count == 0 || + !ReferenceEquals(_catchClauseFrames.Peek().Owner, context)) + { + return CatchTypeValue.Invalid; + } + + CatchClauseFrame frame = _catchClauseFrames.Pop(); + if (_currentMethod is null || + frame.InitialSyntaxErrorCount != _syntaxErrorCount || + context.exception is not null || + context.catchType is null || + context.catchType.HasSyntaxError) + { + return CatchTypeValue.Invalid; + } + + EntityRegistry.TypeEntity catchType = + ResolveTypeSpecification(GetTypeSpecificationValue(context.catchType.Value)); + return new CatchTypeValue(catchType, IsValid: true); + } + + internal object CreateScopeExceptionRange(CILParser.ScopeBlockContext scope) + => new ScopeExceptionRangeValue(scope); + + internal object CreateLabelExceptionRange(IToken start, IToken end) + => new LabelExceptionRangeValue(ParseIdentifier(start), ParseIdentifier(end)); + + internal object CreateOffsetExceptionRange(IToken start, IToken end) + => new OffsetExceptionRangeValue(ParseInt32(start), ParseInt32(end)); + + internal object CreateScopeFilter(CILParser.ScopeBlockContext scope) + => new ScopeExceptionFilterValue(scope); + + internal object CreateLabelFilter(IToken label) + => new LabelExceptionFilterValue(ParseIdentifier(label)); + + internal object CreateOffsetFilter(IToken offset) + => new OffsetExceptionFilterValue(ParseInt32(offset)); + + internal object CreateCatchExceptionClause(object? catchType, object? handler) + => new CatchExceptionClauseValue( + GetCatchTypeValue(catchType), + GetExceptionRangeValue(handler)); + + internal object CreateFilterExceptionClause(object? filter, object? handler) + => new FilterExceptionClauseValue( + GetExceptionFilterValue(filter), + GetExceptionRangeValue(handler)); + + internal object CreateFinallyExceptionClause(object? handler) + => new FinallyExceptionClauseValue(GetExceptionRangeValue(handler)); + + internal object CreateFaultExceptionClause(object? handler) + => new FaultExceptionClauseValue(GetExceptionRangeValue(handler)); + + private void AddExceptionRegion(EntityRegistry.ExceptionRegion region) + { + Debug.Assert(_currentMethod is not null); + _currentMethod.Definition.ExceptionRegions.Add(region); + } + + private (LabelHandle Start, LabelHandle End)? ResolveExceptionRange(ExceptionRangeValue range) + => range switch + { + ScopeExceptionRangeValue scope => GetScopeRange(scope.Scope), + LabelExceptionRangeValue labels => ( + GetOrCreateMethodLabel(labels.Start), + GetOrCreateMethodLabel(labels.End)), + OffsetExceptionRangeValue offsets => ( + DefineMethodLabelAtOffset(offsets.Start), + DefineMethodLabelAtOffset(offsets.End)), + _ => null, + }; + + private LabelHandle? ResolveExceptionFilter(ExceptionFilterValue filter) + => filter switch + { + ScopeExceptionFilterValue scope => GetScopeRange(scope.Scope).Start, + LabelExceptionFilterValue label => GetOrCreateMethodLabel(label.Label), + OffsetExceptionFilterValue offset => DefineMethodLabelAtOffset(offset.Offset), + _ => null, + }; + + private (LabelHandle Start, LabelHandle End) GetScopeRange(CILParser.ScopeBlockContext context) + { + if (!_scopeRanges.TryGetValue(context, out (int Start, int End) range)) + { + int offset = CurrentMethodBodyOffset; + range = (offset, offset); + } + + return ( + DefineMethodLabelAtOffset(range.Start), + DefineMethodLabelAtOffset(range.End)); + } + + private LabelHandle GetOrCreateMethodLabel(string name) + { + Debug.Assert(_currentMethod is not null); + if (!_currentMethod.Labels.TryGetValue(name, out LabelHandle label)) + { + label = _currentMethod.Definition.MethodBody.DefineLabel(); + _currentMethod.Labels[name] = label; + } + + return label; + } + + private LabelHandle DefineMethodLabelAtOffset(int offset) + { + Debug.Assert(_currentMethod is not null); + LabelHandle label = _currentMethod.Definition.MethodBody.DefineLabel(); + _currentMethod.Definition.MethodBody.MarkLabel(label, offset); + return label; + } + + private int CurrentMethodBodyOffset => _currentMethod?.Definition.MethodBody.Offset ?? 0; + + private readonly record struct ScopeFrame( + CILParser.ScopeBlockContext Context, + int Start, + int LocalsScopeCount); +} +#pragma warning restore CA1822 diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.Values.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.Values.cs new file mode 100644 index 00000000000000..680d94cbb8f8e0 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.Values.cs @@ -0,0 +1,121 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Generic; +using System.Collections.Immutable; + +namespace ILAssembler; + +internal sealed partial class GrammarActions +{ + private readonly Stack _parameterDirectiveFrames = new(); + private readonly Stack _exceptionBlockFrames = new(); + private readonly Stack _exceptionClauseListFrames = new(); + private readonly Stack _catchClauseFrames = new(); + + private sealed class ParameterDirectiveFrame + { + public ParameterDirectiveFrame(CILParser.ParameterDeclContext owner) + { + Owner = owner; + } + + public CILParser.ParameterDeclContext Owner { get; } + + public List CustomAttributes { get; } = new(); + } + + private abstract record ExceptionRangeValue + { + public static ExceptionRangeValue Invalid { get; } = new InvalidExceptionRangeValue(); + } + + private sealed record InvalidExceptionRangeValue : ExceptionRangeValue; + + private sealed record ScopeExceptionRangeValue(CILParser.ScopeBlockContext Scope) : ExceptionRangeValue; + + private sealed record LabelExceptionRangeValue(string Start, string End) : ExceptionRangeValue; + + private sealed record OffsetExceptionRangeValue(int Start, int End) : ExceptionRangeValue; + + private abstract record ExceptionFilterValue + { + public static ExceptionFilterValue Invalid { get; } = new InvalidExceptionFilterValue(); + } + + private sealed record InvalidExceptionFilterValue : ExceptionFilterValue; + + private sealed record ScopeExceptionFilterValue(CILParser.ScopeBlockContext Scope) : ExceptionFilterValue; + + private sealed record LabelExceptionFilterValue(string Label) : ExceptionFilterValue; + + private sealed record OffsetExceptionFilterValue(int Offset) : ExceptionFilterValue; + + private sealed record CatchTypeValue(EntityRegistry.TypeEntity? Type, bool IsValid) + { + public static CatchTypeValue Invalid { get; } = new(null, IsValid: false); + } + + private abstract record ExceptionClauseValue(ExceptionRangeValue Handler) + { + public static ExceptionClauseValue Invalid { get; } = + new InvalidExceptionClauseValue(ExceptionRangeValue.Invalid); + } + + private sealed record InvalidExceptionClauseValue(ExceptionRangeValue Handler) + : ExceptionClauseValue(Handler); + + private sealed record CatchExceptionClauseValue( + CatchTypeValue CatchType, + ExceptionRangeValue Handler) + : ExceptionClauseValue(Handler); + + private sealed record FilterExceptionClauseValue( + ExceptionFilterValue Filter, + ExceptionRangeValue Handler) + : ExceptionClauseValue(Handler); + + private sealed record FinallyExceptionClauseValue(ExceptionRangeValue Handler) + : ExceptionClauseValue(Handler); + + private sealed record FaultExceptionClauseValue(ExceptionRangeValue Handler) + : ExceptionClauseValue(Handler); + + private sealed record ExceptionBlockFrame( + CILParser.SehBlockContext Owner, + int InitialSyntaxErrorCount); + + private sealed class ExceptionClauseListFrame + { + public ExceptionClauseListFrame(CILParser.SehClausesContext owner) + { + Owner = owner; + } + + public CILParser.SehClausesContext Owner { get; } + + public ImmutableArray.Builder Clauses { get; } = + ImmutableArray.CreateBuilder(); + } + + private sealed record CatchClauseFrame( + CILParser.CatchClauseContext Owner, + int InitialSyntaxErrorCount); + + private static ExceptionRangeValue GetExceptionRangeValue(object? value) + => value as ExceptionRangeValue ?? ExceptionRangeValue.Invalid; + + private static ExceptionFilterValue GetExceptionFilterValue(object? value) + => value as ExceptionFilterValue ?? ExceptionFilterValue.Invalid; + + private static CatchTypeValue GetCatchTypeValue(object? value) + => value as CatchTypeValue ?? CatchTypeValue.Invalid; + + private static ExceptionClauseValue GetExceptionClauseValue(object? value) + => value as ExceptionClauseValue ?? ExceptionClauseValue.Invalid; + + private static ImmutableArray GetExceptionClausesValue(object? value) + => value is ImmutableArray clauses + ? clauses + : ImmutableArray.Empty; +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs index e8e9a8d94797e1..b8fbb5faa599dc 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs @@ -22,519 +22,13 @@ namespace ILAssembler; +#pragma warning disable CA1822 // Mark members as static internal sealed partial class GrammarActions { - private readonly Dictionary _scopeRanges = new(); - private readonly Stack _scopeStack = new(); - private readonly Dictionary _catchTypes = new(); - private RuleContext? _methodOwner; - - internal void BeginMethod(CILParser.MethodHeadContext context) - { - ClearPendingCustomAttributeOwners(); - ResetMethodBodyState(); - _currentMethod = new CurrentMethodContext(VisitMethodHead(context).Value); - _methodOwner = context.Parent; - } - - private void EndMethod() - { - _methodOwner = null; - if (_currentMethod is not null) - { - if (_currentMethod.AllLocals.Count > 0) - { - BlobBuilder localsSignature = new(); - BlobEncoder encoder = new(localsSignature); - LocalVariablesEncoder localsEncoder = encoder.LocalVariableSignature(_currentMethod.AllLocals.Count); - foreach (SignatureArg local in _currentMethod.AllLocals) - { - local.SignatureBlob.WriteContentTo(localsEncoder.AddVariable().Builder); - } - - _currentMethod.Definition.LocalsSignature = _entityRegistry.GetOrCreateStandaloneSignature(localsSignature); - } - - ValidateLabelReferences(); - _currentMethod = null; - } - - ResetMethodBodyState(); - ClearPendingCustomAttributeOwners(); - } - - private void ResetMethodBodyState() - { - _scopeRanges.Clear(); - _scopeStack.Clear(); - _catchTypes.Clear(); - } - - internal void BeginScope(CILParser.ScopeBlockContext context) - { - if (_currentMethod is null) - { - return; - } - - _scopeStack.Push(new ScopeFrame(context, CurrentMethodBodyOffset, _currentMethod.LocalsScopes.Count)); - } - - /// - /// Closes the lexical scope opened for , if one was opened. - /// - /// - /// This runs from the scopeBlock rule's finally block. It is keyed on the owning - /// context so that it is idempotent and so that an unopened scope (for example when the opening - /// brace failed to match) cannot pop a frame belonging to an enclosing scope. - /// - internal void EndScope(CILParser.ScopeBlockContext context) - { - if (_scopeStack.Count == 0 || !ReferenceEquals(_scopeStack.Peek().Context, context)) - { - return; - } - - ScopeFrame frame = _scopeStack.Pop(); - if (_currentMethod is not null && frame.LocalsScopeCount < _currentMethod.LocalsScopes.Count) - { - _currentMethod.LocalsScopes.RemoveRange( - frame.LocalsScopeCount, - _currentMethod.LocalsScopes.Count - frame.LocalsScopeCount); - } - - _scopeRanges[context] = (frame.Start, CurrentMethodBodyOffset); - } - - /// - /// Resolves the type of a catch clause before its handler body is parsed. - /// - /// - /// Native ilasm resolves the caught type as soon as it is parsed, so the type reference it - /// creates precedes any reference created by the handler body. Resolving the type when the - /// exception regions are recorded instead would reorder the emitted TypeRef rows. - /// - internal void OnCatchClause(CILParser.CatchClauseContext context) - { - if (_currentMethod is null) - { - return; - } - - _catchTypes[context] = VisitTypeSpec(context.typeSpec()).Value; - } - - internal void EndExceptionBlock(CILParser.SehBlockContext context) - { - if (_currentMethod is null || context.sehClauses() is not CILParser.SehClausesContext clauses) - { - return; - } - - (LabelHandle TryStart, LabelHandle TryEnd) tryRange = GetTryRange(context.tryBlock()); - - foreach (CILParser.SehClauseContext clause in clauses.sehClause()) - { - (LabelHandle HandlerStart, LabelHandle HandlerEnd) handlerRange = GetHandlerRange(clause.handlerBlock()); - if (clause.finallyClause() is not null) - { - AddExceptionRegion(new EntityRegistry.ExceptionRegion.FinallyRegion( - tryRange.TryStart, - tryRange.TryEnd, - handlerRange.HandlerStart, - handlerRange.HandlerEnd)); - } - else if (clause.faultClause() is not null) - { - AddExceptionRegion(new EntityRegistry.ExceptionRegion.FaultRegion( - tryRange.TryStart, - tryRange.TryEnd, - handlerRange.HandlerStart, - handlerRange.HandlerEnd)); - } - else if (clause.catchClause() is CILParser.CatchClauseContext catchClause) - { - if (_catchTypes.Remove(catchClause, out EntityRegistry.TypeEntity? catchType)) - { - AddExceptionRegion(new EntityRegistry.ExceptionRegion.CatchRegion( - tryRange.TryStart, - tryRange.TryEnd, - handlerRange.HandlerStart, - handlerRange.HandlerEnd, - catchType)); - } - } - else if (clause.filterClause() is CILParser.FilterClauseContext filterClause) - { - AddExceptionRegion(new EntityRegistry.ExceptionRegion.FilterRegion( - tryRange.TryStart, - tryRange.TryEnd, - handlerRange.HandlerStart, - handlerRange.HandlerEnd, - GetFilterStart(filterClause))); - } - } - } - - private void AddExceptionRegion(EntityRegistry.ExceptionRegion region) - { - Debug.Assert(_currentMethod is not null); - _currentMethod.Definition.ExceptionRegions.Add(region); - } - - private int CurrentMethodBodyOffset => _currentMethod?.Definition.MethodBody.Offset ?? 0; - - private LabelHandle GetOrCreateMethodLabel(CILParser.IdContext context) - { - Debug.Assert(_currentMethod is not null); - string name = VisitId(context).Value; - if (!_currentMethod.Labels.TryGetValue(name, out LabelHandle label)) - { - label = _currentMethod.Definition.MethodBody.DefineLabel(); - _currentMethod.Labels[name] = label; - } - - return label; - } - - private LabelHandle DefineMethodLabelAtOffset(int offset) - { - Debug.Assert(_currentMethod is not null); - LabelHandle label = _currentMethod.Definition.MethodBody.DefineLabel(); - _currentMethod.Definition.MethodBody.MarkLabel(label, offset); - return label; - } - - private (LabelHandle Start, LabelHandle End) GetTryRange(CILParser.TryBlockContext? context) - => context?.scopeBlock() is CILParser.ScopeBlockContext scope - ? GetScopeRange(scope) - : GetExplicitRange(context?.id(), context?.int32()); - - private (LabelHandle Start, LabelHandle End) GetHandlerRange(CILParser.HandlerBlockContext? context) - => context?.scopeBlock() is CILParser.ScopeBlockContext scope - ? GetScopeRange(scope) - : GetExplicitRange(context?.id(), context?.int32()); - - private LabelHandle GetFilterStart(CILParser.FilterClauseContext context) - { - if (context.scopeBlock() is CILParser.ScopeBlockContext scope) - { - return GetScopeRange(scope).Start; - } - - if (context.id() is CILParser.IdContext id) - { - return GetOrCreateMethodLabel(id); - } - - return context.int32() is CILParser.Int32Context offset - ? DefineMethodLabelAtOffset(VisitInt32(offset).Value) - : DefineMethodLabelAtOffset(CurrentMethodBodyOffset); - } - - private (LabelHandle Start, LabelHandle End) GetScopeRange(CILParser.ScopeBlockContext context) - { - if (!_scopeRanges.TryGetValue(context, out (int Start, int End) range)) - { - int offset = CurrentMethodBodyOffset; - range = (offset, offset); - } - - return ( - DefineMethodLabelAtOffset(range.Start), - DefineMethodLabelAtOffset(range.End)); - } - - /// - /// Resolves an explicit label or offset range, falling back to an empty range at the current - /// offset when error recovery left the range unmatched. - /// - private (LabelHandle Start, LabelHandle End) GetExplicitRange( - CILParser.IdContext[]? ids, - CILParser.Int32Context[]? offsets) - { - if (ids is { Length: 2 }) - { - return (GetOrCreateMethodLabel(ids[0]), GetOrCreateMethodLabel(ids[1])); - } - - if (offsets is { Length: 2 }) - { - return ( - DefineMethodLabelAtOffset(VisitInt32(offsets[0]).Value), - DefineMethodLabelAtOffset(VisitInt32(offsets[1]).Value)); - } - - int currentOffset = CurrentMethodBodyOffset; - return ( - DefineMethodLabelAtOffset(currentOffset), - DefineMethodLabelAtOffset(currentOffset)); - } - - private readonly record struct ScopeFrame(CILParser.ScopeBlockContext Context, int Start, int LocalsScopeCount); - - internal GrammarResult ProcessMethodDeclarationIsland(CILParser.MethodDeclIslandContext context) - { - if (_currentMethod is null) - { - return GrammarResult.SentinelValue.Result; - } - - var currentMethod = _currentMethod!; - - if (context.LOCALS() is not null) - { - if (context.ChildCount == 3) - { - // init keyword specified - currentMethod.Definition.BodyAttributes = MethodBodyAttributes.InitLocals; - } - Dictionary localsScope; - if (currentMethod.LocalsScopes.Count != 0) - { - localsScope = currentMethod.LocalsScopes[currentMethod.LocalsScopes.Count - 1]; - } - else - { - localsScope = new(); - currentMethod.LocalsScopes.Add(localsScope); - } - var newLocals = VisitSigArgs(context.sigArgs()).Value; - foreach (var loc in newLocals) - { - // BREAK-COMPAT: We don't allow specifying a local's slot via the [in], [out], or [opt] parameter attributes, or the custom int override. - // This only worked in ilasm due to how ilasm reused fields. - // We're only going to support allowing this tool to determine the slot numbers. - // This blocks two different locals in two different scopes from resuing the same slot - // but that is a very rare scenario (even using more than one .locals block in a method in IL is quite rare) - - // If the local is named, add it to our name-lookup dictionary. - // Otherwise, it will only be accessible via its index. - if (loc.Name is not null) - { - localsScope.TryAdd(loc.Name, currentMethod.AllLocals.Count); - } - currentMethod.AllLocals.Add(loc); - } - } - else if (context.EXPORT() is not null) - { - // .export [ordinal] or .export [ordinal] as alias - int ordinal = VisitInt32(context.int32()[0]).Value; - string? alias = context.id() is { } aliasId ? VisitId(aliasId).Value : null; - - currentMethod.Definition.ExportOrdinal = ordinal; - currentMethod.Definition.ExportAlias = alias; - } - else if (context.VTENTRY() is not null) - { - // .vtentry vtableIndex : slotIndex - int vtableEntry = VisitInt32(context.int32()[0]).Value; - int vtableSlot = VisitInt32(context.int32()[1]).Value; - - currentMethod.Definition.VTableEntry = vtableEntry; - currentMethod.Definition.VTableSlot = vtableSlot; - } - else if (context.OVERRIDE() is not null) - { - EntityRegistry.TypeDefinitionEntity? currentType = _currentTypeDefinition.PeekOrDefault(); - if (currentType is null) - { - return GrammarResult.SentinelValue.Result; - } - - BlobBuilder signature = currentMethod.Definition.MethodSignature!; - if (context.callConv() is {} callConv) - { - // We have an explicitly specified signature, so we need to parse it. - signature = new(); - var callConvByte = VisitCallConv(callConv).Value; - var arity = VisitGenArity(context.genArity()).Value; - if (arity > 0) - { - callConvByte |= (byte)SignatureAttributes.Generic; - } - signature.WriteByte(callConvByte); - if (arity > 0) - { - signature.WriteCompressedInteger(arity); - } - var args = VisitSigArgs(context.sigArgs()).Value; - signature.WriteCompressedInteger(args.Length); - VisitType(context.type()).Value.WriteContentTo(signature); - foreach (var arg in args) - { - arg.SignatureBlob.WriteContentTo(signature); - } - } - - var ownerType = VisitTypeSpec(context.typeSpec()).Value; - var methodName = VisitMethodName(context.methodName()).Value; - var methodRef = _entityRegistry.CreateLazilyRecordedMemberReference(ownerType, methodName, signature); - currentType.MethodImplementations.Add(EntityRegistry.CreateUnrecordedMethodImplementation(currentMethod.Definition, methodRef)); - } - else if (context.PARAM() is not null) - { - // BREAK-COMPAT: We require attributes on parameters, generic parameters, and constraints - // to be specified directly after the .param directive, not at any point later in the method. - // This matches the IL outputted by ILDASM, ILSpy, and other tools in the ecosystem. - // Attributes not specified directly after the .param directive are applied to the method itself. - var customAttrDeclarations = context.customAttrDecl(); - if (context.TYPE() is not null) - { - // Type parameters - EntityRegistry.GenericParameterEntity? param = null; - if (context.int32() is { Length: > 0 } int32) - { - int index = VisitInt32(int32[0]).Value; - if (index < 0 || index >= currentMethod.Definition.GenericParameters.Count) - { - ReportError(DiagnosticIds.GenericParameterIndexOutOfRange, - string.Format(DiagnosticMessageTemplates.GenericParameterIndexOutOfRange, index), - context); - return GrammarResult.SentinelValue.Result; - } - param = currentMethod.Definition.GenericParameters[index]; - } - else - { - string name = VisitDottedName(context.dottedName()).Value; - foreach (var genericParam in currentMethod.Definition.GenericParameters) - { - if (genericParam.Name == name) - { - param = genericParam; - break; - } - } - if (param is null) - { - ReportError(DiagnosticIds.UnknownGenericParameter, - string.Format(DiagnosticMessageTemplates.UnknownGenericParameter, name), - context); - return GrammarResult.SentinelValue.Result; - } - } - foreach (var attr in customAttrDeclarations ?? Array.Empty()) - { - var customAttrDecl = VisitCustomAttrDecl(attr).Value; - customAttrDecl?.Owner = param; - } - } - else if (context.CONSTRAINT() is not null) - { - // constraints - EntityRegistry.GenericParameterEntity? param = null; - if (context.int32() is { Length: > 0 } int32) - { - int index = VisitInt32(int32[0]).Value; - if (index < 0 || index >= currentMethod.Definition.GenericParameters.Count) - { - ReportError(DiagnosticIds.GenericParameterIndexOutOfRange, - string.Format(DiagnosticMessageTemplates.GenericParameterIndexOutOfRange, index), - context); - return GrammarResult.SentinelValue.Result; - } - param = currentMethod.Definition.GenericParameters[index]; - } - else - { - string name = VisitDottedName(context.dottedName()).Value; - foreach (var genericParam in currentMethod.Definition.GenericParameters) - { - if (genericParam.Name == name) - { - param = genericParam; - break; - } - } - if (param is null) - { - ReportError(DiagnosticIds.UnknownGenericParameter, - string.Format(DiagnosticMessageTemplates.UnknownGenericParameter, name), - context); - return GrammarResult.SentinelValue.Result; - } - } - EntityRegistry.GenericParameterConstraintEntity? constraint = null; - var baseType = VisitTypeSpec(context.typeSpec()).Value; - foreach (var constraintEntity in param.Constraints) - { - if (constraintEntity.BaseType == baseType) - { - constraint = constraintEntity; - break; - } - } - if (constraint is null) - { - constraint = EntityRegistry.CreateGenericConstraint(baseType); - constraint.Owner = param; - param.Constraints.Add(constraint); - currentMethod.Definition.GenericParameterConstraints.Add(constraint); - } - foreach (var attr in customAttrDeclarations ?? Array.Empty()) - { - var customAttrDecl = VisitCustomAttrDecl(attr).Value; - customAttrDecl?.Owner = constraint; - } - } - else - { - // Adding attributes to parameters. - int index = VisitInt32(context.int32()[0]).Value; - if (index < 0 || index >= currentMethod.Definition.Parameters.Count) - { - ReportError(DiagnosticIds.ParameterIndexOutOfRange, - string.Format(DiagnosticMessageTemplates.ParameterIndexOutOfRange, index), - context); - return GrammarResult.SentinelValue.Result; - } - - // Handle initOpt to get the Constant table entry if a constant value is provided. - var constantValue = VisitInitOpt(context.initOpt()).Value; - var param = currentMethod.Definition.Parameters[index]; - if (constantValue is not NoConstantSentinel) - { - param.ConstantValue = constantValue; - param.HasConstant = true; - } - foreach (var attr in customAttrDeclarations ?? Array.Empty()) - { - var customAttrDecl = VisitCustomAttrDecl(attr).Value; - if (customAttrDecl is not null) - { - customAttrDecl.Owner = param; - param.HasCustomAttributes = true; - } - } - } - } - else if (context.secDecl() is {} secDecl) - { - var declarativeSecurity = VisitSecDecl(secDecl).Value; - declarativeSecurity?.Parent = currentMethod.Definition; - } - else if (context.customDescrInMethodBody() is {} customDescrInMethod) - { - var customAttr = VisitCustomDescrInMethodBody(customDescrInMethod).Value; - if (customAttr is not null) - { - customAttr.Owner = currentMethod.Definition; - } - } - else - { - // Handle other methodDecl alternatives - var child = context.children[0]; - _ = child.Accept(this); - } - return GrammarResult.SentinelValue.Result; - } - -#pragma warning disable CA1822 // Mark members as static GrammarResult ICILVisitor.VisitCatchClause(CILParser.CatchClauseContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + GrammarResult ICILVisitor.VisitExportDecl(CILParser.ExportDeclContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + public GrammarResult VisitFaultClause(CILParser.FaultClauseContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); GrammarResult ICILVisitor.VisitFilterClause(CILParser.FilterClauseContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); @@ -607,6 +101,8 @@ private void ValidateLabelReferences() GrammarResult ICILVisitor.VisitLabelDecl(CILParser.LabelDeclContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + GrammarResult ICILVisitor.VisitLocalsDecl(CILParser.LocalsDeclContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + GrammarResult ICILVisitor.VisitMethAttr(CILParser.MethAttrContext context) => VisitMethAttr(context); public GrammarResult.Flag VisitMethAttr(CILParser.MethAttrContext context) { @@ -639,13 +135,10 @@ public GrammarResult.Flag VisitMethAttr(CILParser.MethAttrCont }; } - public GrammarResult VisitMethodDecls(CILParser.MethodDeclsContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); GrammarResult ICILVisitor.VisitMethodDecl(CILParser.MethodDeclContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - GrammarResult ICILVisitor.VisitMethodDeclIsland(CILParser.MethodDeclIslandContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - GrammarResult ICILVisitor.VisitMethodHead(CILParser.MethodHeadContext context) => VisitMethodHead(context); public GrammarResult.Literal VisitMethodHead(CILParser.MethodHeadContext context) { @@ -780,6 +273,10 @@ public static GrammarResult.String VisitMethodName(CILParser.MethodNameContext c internal string GetMethodName(IToken token) => token.Text; + GrammarResult ICILVisitor.VisitOverrideDecl(CILParser.OverrideDeclContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitParameterDecl(CILParser.ParameterDeclContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + public GrammarResult VisitScopeBlock(CILParser.ScopeBlockContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); public GrammarResult VisitSehBlock(CILParser.SehBlockContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); @@ -790,5 +287,7 @@ public static GrammarResult.String VisitMethodName(CILParser.MethodNameContext c GrammarResult ICILVisitor.VisitTryBlock(CILParser.TryBlockContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + GrammarResult ICILVisitor.VisitVtentryDecl(CILParser.VtentryDeclContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + #pragma warning restore CA1822 // Mark members as static } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs index b1d81f6ab33471..8c08a019ffb02e 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs @@ -23,6 +23,10 @@ _currentMethod is null && _typeOwners.Count == 0 && _namespaceOwners.Count == 0 && _scopeStack.Count == 0 + && _parameterDirectiveFrames.Count == 0 + && _exceptionBlockFrames.Count == 0 + && _exceptionClauseListFrames.Count == 0 + && _catchClauseFrames.Count == 0 && _semanticRootFrames.Count == 0 && _dottedNameFrames.Count == 0 && _slashedNameFrames.Count == 0 diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 index 18810213f5acce..c0f00bedf52b00 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 @@ -496,10 +496,13 @@ assemblyBlock: mscorlib: '.mscorlib'; -languageDecl: +languageDecl returns [bool HasSyntaxError] +@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +: '.language' languageString | '.language' languageString ',' languageString | '.language' languageString ',' languageString ',' languageString; +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} languageString: SQSTRING | QSTRING; @@ -665,7 +668,9 @@ implList: (typeSpec ',')* typeSpec; /* External source declarations */ esHead: '.line' | '#line'; -extSourceSpec: +extSourceSpec returns [bool HasSyntaxError] +@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +: esHead int32 SQSTRING | esHead int32 | esHead int32 ':' int32 SQSTRING @@ -681,6 +686,7 @@ extSourceSpec: | esHead int32 ':' int32 ',' int32 QSTRING | esHead int32 ',' int32 ':' int32 QSTRING | esHead int32 ',' int32 ':' int32 ',' int32 QSTRING; +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} /* Manifest declarations */ fileDecl: @@ -1031,10 +1037,9 @@ nativeUint returns [byte Value]: 'native' ('unsigned' INT | UINT) {_localctx.Value = Actions.GetNativeUIntType();}; /* Security declarations */ -PERMISSION: '.permission'; -PERMISSIONSET: '.permissionset'; - -secDecl: +secDecl returns [bool HasSyntaxError] +@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +: PERMISSION secAction typeSpec '(' nameValPairs ')' | PERMISSION secAction typeSpec '=' '{' customBlobDescr '}' | PERMISSION secAction typeSpec @@ -1042,8 +1047,12 @@ secDecl: | PERMISSIONSET secAction 'bytearray' '(' bytes ')' | PERMISSIONSET secAction compQstring | PERMISSIONSET secAction '=' '{' secAttrSetBlob '}'; +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} + + PERMISSION: '.permission'; + PERMISSIONSET: '.permissionset'; -secAttrSetBlob: | (secAttrBlob ',')* secAttrBlob; + secAttrSetBlob: | (secAttrBlob ',')* secAttrBlob; secAttrBlob: 'class' SQSTRING '=' '{' customBlobNVPairs '}' @@ -1224,7 +1233,13 @@ fieldAttr: atOpt: /* EMPTY */ | 'at' id | 'at' int32; -initOpt: /* EMPTY */ | '=' fieldInit; +initOpt returns [bool HasSyntaxError] +@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +: + /* EMPTY */ + | '=' fieldInit +; +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} repeatOpt: /* EMPTY */ | '[' int32 ']'; @@ -1392,39 +1407,72 @@ methodDecl: | ZEROINIT {Actions.SetZeroInit();} | labelDecl | scopeBlock - | methodDeclIsland; + | localsDecl + | declaration = dataDecl {Actions.ProcessMethodDataDeclaration($declaration.ctx);} + | security = secDecl {Actions.ProcessMethodSecurityDeclaration($security.ctx);} + | source = extSourceSpec {Actions.ProcessMethodSourceDirective($source.ctx);} + | language = languageDecl {Actions.ProcessMethodLanguageDirective($language.ctx);} + | attribute = customDescrInMethodBody {Actions.ProcessMethodCustomAttribute($attribute.ctx);} + | compControl + | exportDecl + | vtentryDecl + | overrideDecl + | parameterDecl +; -methodDeclIsland -@init {BeginSubtree();} -@after {Actions.ProcessMethodDeclarationIsland(_localctx);} +localsDecl +@init {Actions.BeginSemanticRoot(_localctx);} : - LOCALS sigArgs - | LOCALS 'init' sigArgs - | dataDecl - | secDecl - | extSourceSpec - | languageDecl - | customDescrInMethodBody // Only customDescr and customDescrWithOwner, NOT bare typedefs - | compControl - | EXPORT '[' int32 ']' - | EXPORT '[' int32 ']' 'as' id - | VTENTRY int32 ':' int32 - | OVERRIDE typeSpec '::' methodName - | OVERRIDE 'method' callConv type typeSpec '::' methodName genArity sigArgs - | PARAM TYPE '[' int32 ']' customAttrDecl* - | PARAM TYPE dottedName customAttrDecl* - | PARAM CONSTRAINT '[' int32 ']' ',' typeSpec customAttrDecl* - | PARAM CONSTRAINT dottedName ',' typeSpec customAttrDecl* - | PARAM '[' int32 ']' initOpt customAttrDecl* + LOCALS initialize = 'init'? arguments = sigArgs ; -finally {EndParseTreeMode();} +finally {Actions.EndLocalsDirective(_localctx);} + +exportDecl +@init {Actions.BeginSemanticRoot(_localctx);} +: + EXPORT '[' ordinal = int32 ']' ('as' alias = id)? +; +finally {Actions.EndExportDirective(_localctx);} + +vtentryDecl +@init {Actions.BeginSemanticRoot(_localctx);} +: + VTENTRY table = int32 ':' slot = int32 +; +finally {Actions.EndVTableEntryDirective(_localctx);} + +overrideDecl +@init {Actions.BeginSemanticRoot(_localctx);} +: + OVERRIDE owner = typeSpec '::' name = methodName + | OVERRIDE 'method' convention = callConv returnType = type owner = typeSpec '::' name = methodName + arity = genArity arguments = sigArgs +; +finally {Actions.EndOverrideDirective(_localctx);} + +parameterDecl +@init {Actions.BeginParameterDirective(_localctx);} +: + PARAM TYPE '[' genericIndex = int32 ']' (attribute = customAttrDecl {Actions.AddParameterCustomAttribute(_localctx, $attribute.ctx);})* + | PARAM TYPE genericName = dottedName (attribute = customAttrDecl {Actions.AddParameterCustomAttribute(_localctx, $attribute.ctx);})* + | PARAM CONSTRAINT '[' constraintIndex = int32 ']' ',' constraintType = typeSpec + (attribute = customAttrDecl {Actions.AddParameterCustomAttribute(_localctx, $attribute.ctx);})* + | PARAM CONSTRAINT constraintName = dottedName ',' constraintType = typeSpec + (attribute = customAttrDecl {Actions.AddParameterCustomAttribute(_localctx, $attribute.ctx);})* + | PARAM '[' parameterIndex = int32 ']' initializer = initOpt + (attribute = customAttrDecl {Actions.AddParameterCustomAttribute(_localctx, $attribute.ctx);})* +; +finally {Actions.EndParameterDirective(_localctx);} labelDecl: name = id ':' {Actions.DefineLabel($name.start);}; -customDescrInMethodBody: +customDescrInMethodBody returns [bool HasSyntaxError] +@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +: customDescr | customDescrWithOwner; +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} scopeBlock @init {Actions.BeginScope(_localctx);} @@ -1435,48 +1483,67 @@ finally {Actions.EndScope(_localctx);} /* Structured exception handling directives */ sehBlock -@init {BeginSubtree();} -@after {Actions.EndExceptionBlock(_localctx);} +@init {Actions.BeginExceptionBlock(_localctx);} : - tryBlock sehClauses + tryRange = tryBlock clauses = sehClauses ; -finally {EndParseTreeMode();} - -sehClauses: sehClause+; - -tryBlock: - '.try' scopeBlock - | '.try' id 'to' id - | '.try' int32 'to' int32; +finally {Actions.EndExceptionBlock(_localctx);} -sehClause: - catchClause handlerBlock - | filterClause handlerBlock - | finallyClause handlerBlock - | faultClause handlerBlock; - -filterClause: - 'filter' scopeBlock - | 'filter' id - | 'filter' int32; +sehClauses returns [object Value] +@init {Actions.BeginExceptionClauses(_localctx);} +: + (clause = sehClause {Actions.AddExceptionClause(_localctx, $clause.Value);})+ +; +finally {_localctx.Value = Actions.EndExceptionClauses(_localctx);} + +tryBlock returns [object Value]: + '.try' body = scopeBlock {_localctx.Value = Actions.CreateScopeExceptionRange($body.ctx);} + | '.try' startLabel = id 'to' endLabel = id + {_localctx.Value = Actions.CreateLabelExceptionRange($startLabel.start, $endLabel.start);} + | '.try' startOffset = int32 'to' endOffset = int32 + {_localctx.Value = Actions.CreateOffsetExceptionRange($startOffset.start, $endOffset.start);}; + +sehClause returns [object Value]: + caught = catchClause handler = handlerBlock + {_localctx.Value = Actions.CreateCatchExceptionClause($caught.Value, $handler.Value);} + | filtered = filterClause handler = handlerBlock + {_localctx.Value = Actions.CreateFilterExceptionClause($filtered.Value, $handler.Value);} + | finallyClause handler = handlerBlock + {_localctx.Value = Actions.CreateFinallyExceptionClause($handler.Value);} + | faultClause handler = handlerBlock + {_localctx.Value = Actions.CreateFaultExceptionClause($handler.Value);}; + +filterClause returns [object Value]: + 'filter' body = scopeBlock {_localctx.Value = Actions.CreateScopeFilter($body.ctx);} + | 'filter' label = id {_localctx.Value = Actions.CreateLabelFilter($label.start);} + | 'filter' offset = int32 {_localctx.Value = Actions.CreateOffsetFilter($offset.start);}; catchClause -@after {Actions.OnCatchClause(_localctx);} +returns [object Value] +@init {Actions.BeginCatchClause(_localctx);} : - 'catch' typeSpec + 'catch' catchType = typeSpec ; +finally {_localctx.Value = Actions.EndCatchClause(_localctx);} finallyClause: 'finally'; faultClause: 'fault'; -handlerBlock: - scopeBlock - | 'handler' id 'to' id - | 'handler' int32 'to' int32; +handlerBlock returns [object Value]: + body = scopeBlock {_localctx.Value = Actions.CreateScopeExceptionRange($body.ctx);} + | 'handler' startLabel = id 'to' endLabel = id + {_localctx.Value = Actions.CreateLabelExceptionRange($startLabel.start, $endLabel.start);} + | 'handler' startOffset = int32 'to' endOffset = int32 + {_localctx.Value = Actions.CreateOffsetExceptionRange($startOffset.start, $endOffset.start);}; /* Data declaration */ -dataDecl: ddHead ddBody; +dataDecl returns [bool HasSyntaxError] +@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +: + ddHead ddBody +; +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} ddHead: '.data' tls id '=' | '.data' tls; @@ -1590,10 +1657,13 @@ classSeqElement: NULLREF | 'class' SQSTRING | className; objSeq: serInit*; -customAttrDecl: +customAttrDecl returns [bool HasSyntaxError] +@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +: customDescr | customDescrWithOwner | dottedName /* typedef */; +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} /* Assembly References */ asmOrRefDecl: diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.interp b/src/tools/ilasm/src/ILAssembler/gen/CIL.interp index 2ea27fc98060ca..f7a660cf76e050 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.interp +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.interp @@ -740,7 +740,11 @@ methodName implAttr methodDecls methodDecl -methodDeclIsland +localsDecl +exportDecl +vtentryDecl +overrideDecl +parameterDecl labelDecl customDescrInMethodBody scopeBlock @@ -793,4 +797,4 @@ manifestResDecl atn: -[4, 1, 305, 3216, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 359, 8, 1, 10, 1, 12, 1, 362, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 369, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 5, 3, 376, 8, 3, 10, 3, 12, 3, 379, 9, 3, 1, 3, 1, 3, 1, 3, 1, 4, 5, 4, 385, 8, 4, 10, 4, 12, 4, 388, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 440, 8, 5, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 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, 481, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 5, 15, 488, 8, 15, 10, 15, 12, 15, 491, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 520, 8, 18, 1, 19, 1, 19, 3, 19, 524, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 542, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 569, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 592, 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, 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, 628, 8, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 638, 8, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 5, 27, 645, 8, 27, 10, 27, 12, 27, 648, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 657, 8, 28, 10, 28, 12, 28, 660, 9, 28, 1, 29, 1, 29, 1, 30, 1, 30, 3, 30, 666, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 677, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 685, 8, 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, 34, 1, 34, 1, 34, 1, 34, 5, 34, 706, 8, 34, 10, 34, 12, 34, 709, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 5, 37, 722, 8, 37, 10, 37, 12, 37, 725, 9, 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, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 769, 8, 38, 1, 39, 1, 39, 1, 39, 3, 39, 774, 8, 39, 1, 40, 1, 40, 1, 40, 3, 40, 779, 8, 40, 1, 41, 5, 41, 782, 8, 41, 10, 41, 12, 41, 785, 9, 41, 1, 42, 1, 42, 1, 42, 5, 42, 790, 8, 42, 10, 42, 12, 42, 793, 9, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 902, 8, 44, 1, 45, 1, 45, 5, 45, 906, 8, 45, 10, 45, 12, 45, 909, 9, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 922, 8, 45, 10, 45, 12, 45, 925, 9, 45, 1, 45, 1, 45, 1, 45, 3, 45, 930, 8, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 936, 8, 47, 1, 48, 1, 48, 1, 49, 5, 49, 941, 8, 49, 10, 49, 12, 49, 944, 9, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 971, 8, 50, 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, 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, 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, 1049, 8, 51, 3, 51, 1051, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1065, 8, 53, 1, 53, 1, 53, 5, 53, 1069, 8, 53, 10, 53, 12, 53, 1072, 9, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1080, 8, 53, 3, 53, 1082, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1089, 8, 54, 10, 54, 12, 54, 1092, 9, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1103, 8, 55, 10, 55, 12, 55, 1106, 9, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 5, 56, 1117, 8, 56, 10, 56, 12, 56, 1120, 9, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1127, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 1135, 8, 57, 1, 57, 1, 57, 3, 57, 1139, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1178, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 1184, 8, 59, 10, 59, 12, 59, 1187, 9, 59, 1, 59, 1, 59, 1, 59, 1, 60, 5, 60, 1193, 8, 60, 10, 60, 12, 60, 1196, 9, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1203, 8, 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, 3, 62, 1222, 8, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 5, 63, 1230, 8, 63, 10, 63, 12, 63, 1233, 9, 63, 3, 63, 1235, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 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, 1259, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1406, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1416, 8, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 5, 67, 1423, 8, 67, 10, 67, 12, 67, 1426, 9, 67, 3, 67, 1428, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1510, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 5, 69, 1517, 8, 69, 10, 69, 12, 69, 1520, 9, 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, 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, 1551, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1611, 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, 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, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1651, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1667, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1677, 8, 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, 3, 76, 1704, 8, 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, 1728, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 5, 77, 1734, 8, 77, 10, 77, 12, 77, 1737, 9, 77, 1, 77, 3, 77, 1740, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1755, 8, 78, 1, 79, 1, 79, 1, 79, 5, 79, 1760, 8, 79, 10, 79, 12, 79, 1763, 9, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1807, 8, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1817, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1835, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1853, 8, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1872, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1893, 8, 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, 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 1912, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1927, 8, 89, 1, 90, 1, 90, 1, 90, 5, 90, 1932, 8, 90, 10, 90, 12, 90, 1935, 9, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 1944, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 1957, 8, 92, 1, 93, 5, 93, 1960, 8, 93, 10, 93, 12, 93, 1963, 9, 93, 1, 94, 1, 94, 3, 94, 1967, 8, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 5, 95, 1974, 8, 95, 10, 95, 12, 95, 1977, 9, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 3, 97, 1986, 8, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2070, 8, 99, 10, 99, 12, 99, 2073, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2079, 8, 99, 10, 99, 12, 99, 2082, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2092, 8, 99, 10, 99, 12, 99, 2095, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2103, 8, 99, 10, 99, 12, 99, 2106, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 2113, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 2123, 8, 100, 10, 100, 12, 100, 2126, 9, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 2152, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 2159, 8, 102, 1, 103, 1, 103, 1, 103, 3, 103, 2164, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 2171, 8, 104, 1, 105, 1, 105, 5, 105, 2175, 8, 105, 10, 105, 12, 105, 2178, 9, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2185, 8, 105, 10, 105, 12, 105, 2188, 9, 105, 1, 105, 3, 105, 2191, 8, 105, 1, 106, 1, 106, 1, 107, 5, 107, 2196, 8, 107, 10, 107, 12, 107, 2199, 9, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 2213, 8, 108, 1, 109, 1, 109, 5, 109, 2217, 8, 109, 10, 109, 12, 109, 2220, 9, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 111, 5, 111, 2231, 8, 111, 10, 111, 12, 111, 2234, 9, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 2246, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 2255, 8, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 4, 114, 2264, 8, 114, 11, 114, 12, 114, 2265, 1, 114, 1, 114, 3, 114, 2270, 8, 114, 1, 115, 1, 115, 1, 115, 5, 115, 2275, 8, 115, 10, 115, 12, 115, 2278, 9, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 2297, 8, 116, 1, 117, 1, 117, 1, 117, 5, 117, 2302, 8, 117, 10, 117, 12, 117, 2305, 9, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2315, 8, 117, 10, 117, 12, 117, 2318, 9, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2343, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2350, 8, 119, 3, 119, 2352, 8, 119, 1, 119, 5, 119, 2355, 8, 119, 10, 119, 12, 119, 2358, 9, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2363, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2392, 8, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 2401, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2424, 8, 122, 1, 123, 5, 123, 2427, 8, 123, 10, 123, 12, 123, 2430, 9, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2449, 8, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2500, 8, 125, 10, 125, 12, 125, 2503, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2509, 8, 125, 10, 125, 12, 125, 2512, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2522, 8, 125, 10, 125, 12, 125, 2525, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2533, 8, 125, 10, 125, 12, 125, 2536, 9, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 2544, 8, 125, 10, 125, 12, 125, 2547, 9, 125, 3, 125, 2549, 8, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 3, 127, 2557, 8, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 130, 4, 130, 2567, 8, 130, 11, 130, 12, 130, 2568, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 2583, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 3, 132, 2597, 8, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 2605, 8, 133, 1, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 2625, 8, 137, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 2637, 8, 139, 1, 140, 1, 140, 1, 140, 3, 140, 2642, 8, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 4, 141, 2649, 8, 141, 11, 141, 12, 141, 2650, 3, 141, 2653, 8, 141, 1, 142, 1, 142, 1, 142, 5, 142, 2658, 8, 142, 10, 142, 12, 142, 2661, 9, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 2670, 8, 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, 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, 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, 2738, 8, 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, 145, 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, 145, 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, 145, 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, 145, 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, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 3, 145, 2815, 8, 145, 1, 146, 1, 146, 1, 146, 5, 146, 2820, 8, 146, 10, 146, 12, 146, 2823, 9, 146, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 3, 148, 2830, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 2980, 8, 149, 1, 150, 1, 150, 5, 150, 2984, 8, 150, 10, 150, 12, 150, 2987, 9, 150, 1, 151, 1, 151, 5, 151, 2991, 8, 151, 10, 151, 12, 151, 2994, 9, 151, 1, 152, 5, 152, 2997, 8, 152, 10, 152, 12, 152, 3000, 9, 152, 1, 153, 5, 153, 3003, 8, 153, 10, 153, 12, 153, 3006, 9, 153, 1, 154, 5, 154, 3009, 8, 154, 10, 154, 12, 154, 3012, 9, 154, 1, 155, 5, 155, 3015, 8, 155, 10, 155, 12, 155, 3018, 9, 155, 1, 156, 5, 156, 3021, 8, 156, 10, 156, 12, 156, 3024, 9, 156, 1, 157, 5, 157, 3027, 8, 157, 10, 157, 12, 157, 3030, 9, 157, 1, 158, 5, 158, 3033, 8, 158, 10, 158, 12, 158, 3036, 9, 158, 1, 159, 1, 159, 1, 159, 1, 159, 3, 159, 3042, 8, 159, 1, 160, 5, 160, 3045, 8, 160, 10, 160, 12, 160, 3048, 9, 160, 1, 161, 1, 161, 1, 161, 3, 161, 3053, 8, 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, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 3, 162, 3080, 8, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 3094, 8, 163, 1, 164, 5, 164, 3097, 8, 164, 10, 164, 12, 164, 3100, 9, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 3, 165, 3116, 8, 165, 1, 166, 1, 166, 1, 166, 5, 166, 3121, 8, 166, 10, 166, 12, 166, 3124, 9, 166, 1, 166, 1, 166, 1, 167, 1, 167, 5, 167, 3130, 8, 167, 10, 167, 12, 167, 3133, 9, 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, 168, 1, 168, 1, 168, 1, 168, 3, 168, 3152, 8, 168, 1, 169, 5, 169, 3155, 8, 169, 10, 169, 12, 169, 3158, 9, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 3173, 8, 170, 1, 171, 1, 171, 5, 171, 3177, 8, 171, 10, 171, 12, 171, 3180, 9, 171, 1, 171, 1, 171, 1, 171, 5, 171, 3185, 8, 171, 10, 171, 12, 171, 3188, 9, 171, 1, 171, 1, 171, 1, 171, 1, 171, 3, 171, 3194, 8, 171, 1, 172, 1, 172, 1, 173, 5, 173, 3199, 8, 173, 10, 173, 12, 173, 3202, 9, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 3214, 8, 174, 1, 174, 0, 1, 68, 175, 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, 0, 15, 6, 0, 1, 15, 199, 199, 243, 243, 247, 247, 264, 264, 289, 289, 5, 0, 16, 16, 199, 199, 243, 243, 264, 264, 288, 289, 1, 0, 263, 264, 1, 0, 173, 174, 1, 0, 37, 38, 1, 0, 73, 74, 3, 0, 2, 2, 61, 61, 77, 83, 2, 0, 229, 229, 260, 261, 1, 0, 95, 96, 1, 0, 97, 111, 1, 0, 68, 69, 2, 0, 173, 173, 289, 290, 2, 0, 179, 179, 264, 264, 1, 0, 167, 168, 1, 0, 51, 52, 3682, 0, 350, 1, 0, 0, 0, 2, 368, 1, 0, 0, 0, 4, 370, 1, 0, 0, 0, 6, 377, 1, 0, 0, 0, 8, 386, 1, 0, 0, 0, 10, 439, 1, 0, 0, 0, 12, 441, 1, 0, 0, 0, 14, 444, 1, 0, 0, 0, 16, 447, 1, 0, 0, 0, 18, 451, 1, 0, 0, 0, 20, 454, 1, 0, 0, 0, 22, 457, 1, 0, 0, 0, 24, 464, 1, 0, 0, 0, 26, 480, 1, 0, 0, 0, 28, 482, 1, 0, 0, 0, 30, 484, 1, 0, 0, 0, 32, 494, 1, 0, 0, 0, 34, 496, 1, 0, 0, 0, 36, 519, 1, 0, 0, 0, 38, 523, 1, 0, 0, 0, 40, 541, 1, 0, 0, 0, 42, 568, 1, 0, 0, 0, 44, 591, 1, 0, 0, 0, 46, 627, 1, 0, 0, 0, 48, 629, 1, 0, 0, 0, 50, 637, 1, 0, 0, 0, 52, 639, 1, 0, 0, 0, 54, 646, 1, 0, 0, 0, 56, 658, 1, 0, 0, 0, 58, 661, 1, 0, 0, 0, 60, 663, 1, 0, 0, 0, 62, 676, 1, 0, 0, 0, 64, 684, 1, 0, 0, 0, 66, 686, 1, 0, 0, 0, 68, 694, 1, 0, 0, 0, 70, 710, 1, 0, 0, 0, 72, 716, 1, 0, 0, 0, 74, 719, 1, 0, 0, 0, 76, 768, 1, 0, 0, 0, 78, 773, 1, 0, 0, 0, 80, 778, 1, 0, 0, 0, 82, 783, 1, 0, 0, 0, 84, 791, 1, 0, 0, 0, 86, 796, 1, 0, 0, 0, 88, 901, 1, 0, 0, 0, 90, 929, 1, 0, 0, 0, 92, 931, 1, 0, 0, 0, 94, 935, 1, 0, 0, 0, 96, 937, 1, 0, 0, 0, 98, 942, 1, 0, 0, 0, 100, 970, 1, 0, 0, 0, 102, 1050, 1, 0, 0, 0, 104, 1052, 1, 0, 0, 0, 106, 1081, 1, 0, 0, 0, 108, 1083, 1, 0, 0, 0, 110, 1097, 1, 0, 0, 0, 112, 1126, 1, 0, 0, 0, 114, 1138, 1, 0, 0, 0, 116, 1177, 1, 0, 0, 0, 118, 1185, 1, 0, 0, 0, 120, 1194, 1, 0, 0, 0, 122, 1202, 1, 0, 0, 0, 124, 1221, 1, 0, 0, 0, 126, 1234, 1, 0, 0, 0, 128, 1258, 1, 0, 0, 0, 130, 1405, 1, 0, 0, 0, 132, 1415, 1, 0, 0, 0, 134, 1427, 1, 0, 0, 0, 136, 1509, 1, 0, 0, 0, 138, 1511, 1, 0, 0, 0, 140, 1550, 1, 0, 0, 0, 142, 1610, 1, 0, 0, 0, 144, 1650, 1, 0, 0, 0, 146, 1666, 1, 0, 0, 0, 148, 1668, 1, 0, 0, 0, 150, 1672, 1, 0, 0, 0, 152, 1727, 1, 0, 0, 0, 154, 1739, 1, 0, 0, 0, 156, 1754, 1, 0, 0, 0, 158, 1761, 1, 0, 0, 0, 160, 1766, 1, 0, 0, 0, 162, 1770, 1, 0, 0, 0, 164, 1806, 1, 0, 0, 0, 166, 1808, 1, 0, 0, 0, 168, 1852, 1, 0, 0, 0, 170, 1871, 1, 0, 0, 0, 172, 1892, 1, 0, 0, 0, 174, 1894, 1, 0, 0, 0, 176, 1911, 1, 0, 0, 0, 178, 1926, 1, 0, 0, 0, 180, 1933, 1, 0, 0, 0, 182, 1943, 1, 0, 0, 0, 184, 1956, 1, 0, 0, 0, 186, 1961, 1, 0, 0, 0, 188, 1964, 1, 0, 0, 0, 190, 1975, 1, 0, 0, 0, 192, 1980, 1, 0, 0, 0, 194, 1985, 1, 0, 0, 0, 196, 1989, 1, 0, 0, 0, 198, 2112, 1, 0, 0, 0, 200, 2114, 1, 0, 0, 0, 202, 2151, 1, 0, 0, 0, 204, 2158, 1, 0, 0, 0, 206, 2163, 1, 0, 0, 0, 208, 2170, 1, 0, 0, 0, 210, 2190, 1, 0, 0, 0, 212, 2192, 1, 0, 0, 0, 214, 2197, 1, 0, 0, 0, 216, 2212, 1, 0, 0, 0, 218, 2214, 1, 0, 0, 0, 220, 2227, 1, 0, 0, 0, 222, 2232, 1, 0, 0, 0, 224, 2245, 1, 0, 0, 0, 226, 2254, 1, 0, 0, 0, 228, 2269, 1, 0, 0, 0, 230, 2276, 1, 0, 0, 0, 232, 2296, 1, 0, 0, 0, 234, 2298, 1, 0, 0, 0, 236, 2342, 1, 0, 0, 0, 238, 2362, 1, 0, 0, 0, 240, 2391, 1, 0, 0, 0, 242, 2400, 1, 0, 0, 0, 244, 2423, 1, 0, 0, 0, 246, 2428, 1, 0, 0, 0, 248, 2448, 1, 0, 0, 0, 250, 2548, 1, 0, 0, 0, 252, 2550, 1, 0, 0, 0, 254, 2556, 1, 0, 0, 0, 256, 2558, 1, 0, 0, 0, 258, 2562, 1, 0, 0, 0, 260, 2566, 1, 0, 0, 0, 262, 2582, 1, 0, 0, 0, 264, 2596, 1, 0, 0, 0, 266, 2604, 1, 0, 0, 0, 268, 2606, 1, 0, 0, 0, 270, 2609, 1, 0, 0, 0, 272, 2611, 1, 0, 0, 0, 274, 2624, 1, 0, 0, 0, 276, 2626, 1, 0, 0, 0, 278, 2636, 1, 0, 0, 0, 280, 2641, 1, 0, 0, 0, 282, 2652, 1, 0, 0, 0, 284, 2659, 1, 0, 0, 0, 286, 2669, 1, 0, 0, 0, 288, 2737, 1, 0, 0, 0, 290, 2814, 1, 0, 0, 0, 292, 2821, 1, 0, 0, 0, 294, 2824, 1, 0, 0, 0, 296, 2829, 1, 0, 0, 0, 298, 2979, 1, 0, 0, 0, 300, 2985, 1, 0, 0, 0, 302, 2992, 1, 0, 0, 0, 304, 2998, 1, 0, 0, 0, 306, 3004, 1, 0, 0, 0, 308, 3010, 1, 0, 0, 0, 310, 3016, 1, 0, 0, 0, 312, 3022, 1, 0, 0, 0, 314, 3028, 1, 0, 0, 0, 316, 3034, 1, 0, 0, 0, 318, 3041, 1, 0, 0, 0, 320, 3046, 1, 0, 0, 0, 322, 3052, 1, 0, 0, 0, 324, 3079, 1, 0, 0, 0, 326, 3093, 1, 0, 0, 0, 328, 3098, 1, 0, 0, 0, 330, 3115, 1, 0, 0, 0, 332, 3117, 1, 0, 0, 0, 334, 3127, 1, 0, 0, 0, 336, 3151, 1, 0, 0, 0, 338, 3156, 1, 0, 0, 0, 340, 3172, 1, 0, 0, 0, 342, 3193, 1, 0, 0, 0, 344, 3195, 1, 0, 0, 0, 346, 3200, 1, 0, 0, 0, 348, 3213, 1, 0, 0, 0, 350, 351, 7, 0, 0, 0, 351, 1, 1, 0, 0, 0, 352, 353, 5, 288, 0, 0, 353, 369, 6, 1, -1, 0, 354, 355, 3, 4, 2, 0, 355, 356, 6, 1, -1, 0, 356, 357, 5, 265, 0, 0, 357, 359, 1, 0, 0, 0, 358, 354, 1, 0, 0, 0, 359, 362, 1, 0, 0, 0, 360, 358, 1, 0, 0, 0, 360, 361, 1, 0, 0, 0, 361, 363, 1, 0, 0, 0, 362, 360, 1, 0, 0, 0, 363, 364, 3, 4, 2, 0, 364, 365, 6, 1, -1, 0, 365, 369, 1, 0, 0, 0, 366, 367, 5, 264, 0, 0, 367, 369, 6, 1, -1, 0, 368, 352, 1, 0, 0, 0, 368, 360, 1, 0, 0, 0, 368, 366, 1, 0, 0, 0, 369, 3, 1, 0, 0, 0, 370, 371, 7, 1, 0, 0, 371, 5, 1, 0, 0, 0, 372, 373, 5, 263, 0, 0, 373, 374, 6, 3, -1, 0, 374, 376, 5, 266, 0, 0, 375, 372, 1, 0, 0, 0, 376, 379, 1, 0, 0, 0, 377, 375, 1, 0, 0, 0, 377, 378, 1, 0, 0, 0, 378, 380, 1, 0, 0, 0, 379, 377, 1, 0, 0, 0, 380, 381, 5, 263, 0, 0, 381, 382, 6, 3, -1, 0, 382, 7, 1, 0, 0, 0, 383, 385, 3, 10, 5, 0, 384, 383, 1, 0, 0, 0, 385, 388, 1, 0, 0, 0, 386, 384, 1, 0, 0, 0, 386, 387, 1, 0, 0, 0, 387, 9, 1, 0, 0, 0, 388, 386, 1, 0, 0, 0, 389, 390, 3, 74, 37, 0, 390, 391, 5, 17, 0, 0, 391, 392, 3, 82, 41, 0, 392, 393, 5, 18, 0, 0, 393, 440, 1, 0, 0, 0, 394, 395, 3, 72, 36, 0, 395, 396, 5, 17, 0, 0, 396, 397, 3, 8, 4, 0, 397, 398, 5, 18, 0, 0, 398, 440, 1, 0, 0, 0, 399, 400, 3, 234, 117, 0, 400, 401, 5, 17, 0, 0, 401, 402, 3, 246, 123, 0, 402, 403, 5, 18, 0, 0, 403, 440, 1, 0, 0, 0, 404, 440, 3, 200, 100, 0, 405, 440, 3, 276, 138, 0, 406, 440, 3, 70, 35, 0, 407, 440, 3, 66, 33, 0, 408, 440, 3, 88, 44, 0, 409, 440, 3, 90, 45, 0, 410, 440, 3, 22, 11, 0, 411, 412, 3, 326, 163, 0, 412, 413, 5, 17, 0, 0, 413, 414, 3, 328, 164, 0, 414, 415, 5, 18, 0, 0, 415, 440, 1, 0, 0, 0, 416, 417, 3, 332, 166, 0, 417, 418, 5, 17, 0, 0, 418, 419, 3, 338, 169, 0, 419, 420, 5, 18, 0, 0, 420, 440, 1, 0, 0, 0, 421, 422, 3, 342, 171, 0, 422, 423, 5, 17, 0, 0, 423, 424, 3, 346, 173, 0, 424, 425, 5, 18, 0, 0, 425, 440, 1, 0, 0, 0, 426, 440, 3, 64, 32, 0, 427, 440, 3, 152, 76, 0, 428, 440, 3, 322, 161, 0, 429, 440, 3, 12, 6, 0, 430, 440, 3, 14, 7, 0, 431, 440, 3, 16, 8, 0, 432, 440, 3, 18, 9, 0, 433, 440, 3, 20, 10, 0, 434, 440, 3, 26, 13, 0, 435, 440, 3, 42, 21, 0, 436, 440, 3, 40, 20, 0, 437, 440, 3, 30, 15, 0, 438, 440, 3, 24, 12, 0, 439, 389, 1, 0, 0, 0, 439, 394, 1, 0, 0, 0, 439, 399, 1, 0, 0, 0, 439, 404, 1, 0, 0, 0, 439, 405, 1, 0, 0, 0, 439, 406, 1, 0, 0, 0, 439, 407, 1, 0, 0, 0, 439, 408, 1, 0, 0, 0, 439, 409, 1, 0, 0, 0, 439, 410, 1, 0, 0, 0, 439, 411, 1, 0, 0, 0, 439, 416, 1, 0, 0, 0, 439, 421, 1, 0, 0, 0, 439, 426, 1, 0, 0, 0, 439, 427, 1, 0, 0, 0, 439, 428, 1, 0, 0, 0, 439, 429, 1, 0, 0, 0, 439, 430, 1, 0, 0, 0, 439, 431, 1, 0, 0, 0, 439, 432, 1, 0, 0, 0, 439, 433, 1, 0, 0, 0, 439, 434, 1, 0, 0, 0, 439, 435, 1, 0, 0, 0, 439, 436, 1, 0, 0, 0, 439, 437, 1, 0, 0, 0, 439, 438, 1, 0, 0, 0, 440, 11, 1, 0, 0, 0, 441, 442, 5, 19, 0, 0, 442, 443, 3, 32, 16, 0, 443, 13, 1, 0, 0, 0, 444, 445, 5, 20, 0, 0, 445, 446, 3, 32, 16, 0, 446, 15, 1, 0, 0, 0, 447, 448, 5, 21, 0, 0, 448, 449, 5, 22, 0, 0, 449, 450, 3, 32, 16, 0, 450, 17, 1, 0, 0, 0, 451, 452, 5, 23, 0, 0, 452, 453, 3, 34, 17, 0, 453, 19, 1, 0, 0, 0, 454, 455, 5, 24, 0, 0, 455, 456, 3, 34, 17, 0, 456, 21, 1, 0, 0, 0, 457, 458, 5, 25, 0, 0, 458, 459, 3, 98, 49, 0, 459, 460, 3, 2, 1, 0, 460, 461, 5, 17, 0, 0, 461, 462, 3, 120, 60, 0, 462, 463, 5, 18, 0, 0, 463, 23, 1, 0, 0, 0, 464, 465, 5, 26, 0, 0, 465, 25, 1, 0, 0, 0, 466, 467, 5, 27, 0, 0, 467, 481, 3, 28, 14, 0, 468, 469, 5, 27, 0, 0, 469, 470, 3, 28, 14, 0, 470, 471, 5, 28, 0, 0, 471, 472, 3, 28, 14, 0, 472, 481, 1, 0, 0, 0, 473, 474, 5, 27, 0, 0, 474, 475, 3, 28, 14, 0, 475, 476, 5, 28, 0, 0, 476, 477, 3, 28, 14, 0, 477, 478, 5, 28, 0, 0, 478, 479, 3, 28, 14, 0, 479, 481, 1, 0, 0, 0, 480, 466, 1, 0, 0, 0, 480, 468, 1, 0, 0, 0, 480, 473, 1, 0, 0, 0, 481, 27, 1, 0, 0, 0, 482, 483, 7, 2, 0, 0, 483, 29, 1, 0, 0, 0, 484, 485, 5, 29, 0, 0, 485, 489, 5, 17, 0, 0, 486, 488, 3, 116, 58, 0, 487, 486, 1, 0, 0, 0, 488, 491, 1, 0, 0, 0, 489, 487, 1, 0, 0, 0, 489, 490, 1, 0, 0, 0, 490, 492, 1, 0, 0, 0, 491, 489, 1, 0, 0, 0, 492, 493, 5, 18, 0, 0, 493, 31, 1, 0, 0, 0, 494, 495, 5, 173, 0, 0, 495, 33, 1, 0, 0, 0, 496, 497, 7, 3, 0, 0, 497, 35, 1, 0, 0, 0, 498, 499, 5, 175, 0, 0, 499, 520, 6, 18, -1, 0, 500, 501, 3, 32, 16, 0, 501, 502, 5, 265, 0, 0, 502, 503, 6, 18, -1, 0, 503, 520, 1, 0, 0, 0, 504, 505, 3, 32, 16, 0, 505, 506, 6, 18, -1, 0, 506, 520, 1, 0, 0, 0, 507, 508, 5, 188, 0, 0, 508, 509, 5, 30, 0, 0, 509, 510, 3, 32, 16, 0, 510, 511, 5, 31, 0, 0, 511, 512, 6, 18, -1, 0, 512, 520, 1, 0, 0, 0, 513, 514, 5, 189, 0, 0, 514, 515, 5, 30, 0, 0, 515, 516, 3, 34, 17, 0, 516, 517, 5, 31, 0, 0, 517, 518, 6, 18, -1, 0, 518, 520, 1, 0, 0, 0, 519, 498, 1, 0, 0, 0, 519, 500, 1, 0, 0, 0, 519, 504, 1, 0, 0, 0, 519, 507, 1, 0, 0, 0, 519, 513, 1, 0, 0, 0, 520, 37, 1, 0, 0, 0, 521, 524, 3, 32, 16, 0, 522, 524, 5, 262, 0, 0, 523, 521, 1, 0, 0, 0, 523, 522, 1, 0, 0, 0, 524, 39, 1, 0, 0, 0, 525, 526, 5, 267, 0, 0, 526, 542, 5, 289, 0, 0, 527, 528, 5, 267, 0, 0, 528, 529, 5, 289, 0, 0, 529, 542, 5, 263, 0, 0, 530, 531, 5, 268, 0, 0, 531, 542, 5, 289, 0, 0, 532, 533, 5, 269, 0, 0, 533, 542, 5, 289, 0, 0, 534, 535, 5, 270, 0, 0, 535, 542, 5, 289, 0, 0, 536, 542, 5, 271, 0, 0, 537, 542, 5, 272, 0, 0, 538, 539, 5, 273, 0, 0, 539, 542, 5, 263, 0, 0, 540, 542, 5, 32, 0, 0, 541, 525, 1, 0, 0, 0, 541, 527, 1, 0, 0, 0, 541, 530, 1, 0, 0, 0, 541, 532, 1, 0, 0, 0, 541, 534, 1, 0, 0, 0, 541, 536, 1, 0, 0, 0, 541, 537, 1, 0, 0, 0, 541, 538, 1, 0, 0, 0, 541, 540, 1, 0, 0, 0, 542, 41, 1, 0, 0, 0, 543, 544, 5, 33, 0, 0, 544, 545, 3, 138, 69, 0, 545, 546, 5, 34, 0, 0, 546, 547, 3, 2, 1, 0, 547, 569, 1, 0, 0, 0, 548, 549, 5, 33, 0, 0, 549, 550, 3, 116, 58, 0, 550, 551, 5, 34, 0, 0, 551, 552, 3, 2, 1, 0, 552, 569, 1, 0, 0, 0, 553, 554, 5, 33, 0, 0, 554, 555, 3, 176, 88, 0, 555, 556, 5, 34, 0, 0, 556, 557, 3, 2, 1, 0, 557, 569, 1, 0, 0, 0, 558, 559, 5, 33, 0, 0, 559, 560, 3, 44, 22, 0, 560, 561, 5, 34, 0, 0, 561, 562, 3, 2, 1, 0, 562, 569, 1, 0, 0, 0, 563, 564, 5, 33, 0, 0, 564, 565, 3, 46, 23, 0, 565, 566, 5, 34, 0, 0, 566, 567, 3, 2, 1, 0, 567, 569, 1, 0, 0, 0, 568, 543, 1, 0, 0, 0, 568, 548, 1, 0, 0, 0, 568, 553, 1, 0, 0, 0, 568, 558, 1, 0, 0, 0, 568, 563, 1, 0, 0, 0, 569, 43, 1, 0, 0, 0, 570, 571, 5, 35, 0, 0, 571, 592, 3, 48, 24, 0, 572, 573, 5, 35, 0, 0, 573, 574, 3, 48, 24, 0, 574, 575, 5, 36, 0, 0, 575, 576, 3, 6, 3, 0, 576, 592, 1, 0, 0, 0, 577, 578, 5, 35, 0, 0, 578, 579, 3, 48, 24, 0, 579, 580, 5, 36, 0, 0, 580, 581, 5, 17, 0, 0, 581, 582, 3, 52, 26, 0, 582, 583, 5, 18, 0, 0, 583, 592, 1, 0, 0, 0, 584, 585, 5, 35, 0, 0, 585, 586, 3, 48, 24, 0, 586, 587, 5, 36, 0, 0, 587, 588, 5, 30, 0, 0, 588, 589, 3, 292, 146, 0, 589, 590, 5, 31, 0, 0, 590, 592, 1, 0, 0, 0, 591, 570, 1, 0, 0, 0, 591, 572, 1, 0, 0, 0, 591, 577, 1, 0, 0, 0, 591, 584, 1, 0, 0, 0, 592, 45, 1, 0, 0, 0, 593, 594, 5, 35, 0, 0, 594, 595, 5, 30, 0, 0, 595, 596, 3, 50, 25, 0, 596, 597, 5, 31, 0, 0, 597, 598, 3, 48, 24, 0, 598, 628, 1, 0, 0, 0, 599, 600, 5, 35, 0, 0, 600, 601, 5, 30, 0, 0, 601, 602, 3, 50, 25, 0, 602, 603, 5, 31, 0, 0, 603, 604, 3, 48, 24, 0, 604, 605, 5, 36, 0, 0, 605, 606, 3, 6, 3, 0, 606, 628, 1, 0, 0, 0, 607, 608, 5, 35, 0, 0, 608, 609, 5, 30, 0, 0, 609, 610, 3, 50, 25, 0, 610, 611, 5, 31, 0, 0, 611, 612, 3, 48, 24, 0, 612, 613, 5, 36, 0, 0, 613, 614, 5, 17, 0, 0, 614, 615, 3, 52, 26, 0, 615, 616, 5, 18, 0, 0, 616, 628, 1, 0, 0, 0, 617, 618, 5, 35, 0, 0, 618, 619, 5, 30, 0, 0, 619, 620, 3, 50, 25, 0, 620, 621, 5, 31, 0, 0, 621, 622, 3, 48, 24, 0, 622, 623, 5, 36, 0, 0, 623, 624, 5, 30, 0, 0, 624, 625, 3, 292, 146, 0, 625, 626, 5, 31, 0, 0, 626, 628, 1, 0, 0, 0, 627, 593, 1, 0, 0, 0, 627, 599, 1, 0, 0, 0, 627, 607, 1, 0, 0, 0, 627, 617, 1, 0, 0, 0, 628, 47, 1, 0, 0, 0, 629, 630, 3, 168, 84, 0, 630, 49, 1, 0, 0, 0, 631, 632, 3, 124, 62, 0, 632, 633, 6, 25, -1, 0, 633, 638, 1, 0, 0, 0, 634, 635, 3, 176, 88, 0, 635, 636, 6, 25, -1, 0, 636, 638, 1, 0, 0, 0, 637, 631, 1, 0, 0, 0, 637, 634, 1, 0, 0, 0, 638, 51, 1, 0, 0, 0, 639, 640, 3, 54, 27, 0, 640, 641, 3, 56, 28, 0, 641, 53, 1, 0, 0, 0, 642, 645, 3, 298, 149, 0, 643, 645, 3, 40, 20, 0, 644, 642, 1, 0, 0, 0, 644, 643, 1, 0, 0, 0, 645, 648, 1, 0, 0, 0, 646, 644, 1, 0, 0, 0, 646, 647, 1, 0, 0, 0, 647, 55, 1, 0, 0, 0, 648, 646, 1, 0, 0, 0, 649, 650, 3, 58, 29, 0, 650, 651, 3, 60, 30, 0, 651, 652, 3, 2, 1, 0, 652, 653, 5, 36, 0, 0, 653, 654, 3, 298, 149, 0, 654, 657, 1, 0, 0, 0, 655, 657, 3, 40, 20, 0, 656, 649, 1, 0, 0, 0, 656, 655, 1, 0, 0, 0, 657, 660, 1, 0, 0, 0, 658, 656, 1, 0, 0, 0, 658, 659, 1, 0, 0, 0, 659, 57, 1, 0, 0, 0, 660, 658, 1, 0, 0, 0, 661, 662, 7, 4, 0, 0, 662, 59, 1, 0, 0, 0, 663, 665, 3, 62, 31, 0, 664, 666, 5, 261, 0, 0, 665, 664, 1, 0, 0, 0, 665, 666, 1, 0, 0, 0, 666, 61, 1, 0, 0, 0, 667, 677, 3, 144, 72, 0, 668, 677, 3, 2, 1, 0, 669, 677, 5, 196, 0, 0, 670, 677, 5, 197, 0, 0, 671, 672, 5, 202, 0, 0, 672, 673, 5, 39, 0, 0, 673, 677, 5, 264, 0, 0, 674, 675, 5, 202, 0, 0, 675, 677, 3, 116, 58, 0, 676, 667, 1, 0, 0, 0, 676, 668, 1, 0, 0, 0, 676, 669, 1, 0, 0, 0, 676, 670, 1, 0, 0, 0, 676, 671, 1, 0, 0, 0, 676, 674, 1, 0, 0, 0, 677, 63, 1, 0, 0, 0, 678, 679, 5, 198, 0, 0, 679, 680, 5, 40, 0, 0, 680, 685, 3, 2, 1, 0, 681, 682, 5, 198, 0, 0, 682, 685, 3, 2, 1, 0, 683, 685, 5, 198, 0, 0, 684, 678, 1, 0, 0, 0, 684, 681, 1, 0, 0, 0, 684, 683, 1, 0, 0, 0, 685, 65, 1, 0, 0, 0, 686, 687, 5, 41, 0, 0, 687, 688, 5, 42, 0, 0, 688, 689, 3, 32, 16, 0, 689, 690, 5, 43, 0, 0, 690, 691, 3, 68, 34, 0, 691, 692, 5, 44, 0, 0, 692, 693, 3, 0, 0, 0, 693, 67, 1, 0, 0, 0, 694, 707, 6, 34, -1, 0, 695, 696, 10, 5, 0, 0, 696, 706, 5, 186, 0, 0, 697, 698, 10, 4, 0, 0, 698, 706, 5, 187, 0, 0, 699, 700, 10, 3, 0, 0, 700, 706, 5, 45, 0, 0, 701, 702, 10, 2, 0, 0, 702, 706, 5, 46, 0, 0, 703, 704, 10, 1, 0, 0, 704, 706, 5, 47, 0, 0, 705, 695, 1, 0, 0, 0, 705, 697, 1, 0, 0, 0, 705, 699, 1, 0, 0, 0, 705, 701, 1, 0, 0, 0, 705, 703, 1, 0, 0, 0, 706, 709, 1, 0, 0, 0, 707, 705, 1, 0, 0, 0, 707, 708, 1, 0, 0, 0, 708, 69, 1, 0, 0, 0, 709, 707, 1, 0, 0, 0, 710, 711, 5, 48, 0, 0, 711, 712, 5, 36, 0, 0, 712, 713, 5, 30, 0, 0, 713, 714, 3, 292, 146, 0, 714, 715, 5, 31, 0, 0, 715, 71, 1, 0, 0, 0, 716, 717, 5, 49, 0, 0, 717, 718, 3, 2, 1, 0, 718, 73, 1, 0, 0, 0, 719, 723, 5, 50, 0, 0, 720, 722, 3, 76, 38, 0, 721, 720, 1, 0, 0, 0, 722, 725, 1, 0, 0, 0, 723, 721, 1, 0, 0, 0, 723, 724, 1, 0, 0, 0, 724, 726, 1, 0, 0, 0, 725, 723, 1, 0, 0, 0, 726, 727, 3, 2, 1, 0, 727, 728, 3, 182, 91, 0, 728, 729, 3, 78, 39, 0, 729, 730, 3, 80, 40, 0, 730, 75, 1, 0, 0, 0, 731, 769, 5, 51, 0, 0, 732, 769, 5, 52, 0, 0, 733, 769, 5, 199, 0, 0, 734, 769, 5, 202, 0, 0, 735, 769, 5, 221, 0, 0, 736, 769, 5, 53, 0, 0, 737, 769, 5, 54, 0, 0, 738, 769, 5, 55, 0, 0, 739, 769, 5, 56, 0, 0, 740, 769, 5, 244, 0, 0, 741, 769, 5, 15, 0, 0, 742, 769, 5, 224, 0, 0, 743, 769, 5, 57, 0, 0, 744, 769, 5, 58, 0, 0, 745, 769, 5, 59, 0, 0, 746, 769, 5, 60, 0, 0, 747, 769, 5, 61, 0, 0, 748, 749, 5, 62, 0, 0, 749, 769, 5, 51, 0, 0, 750, 751, 5, 62, 0, 0, 751, 769, 5, 52, 0, 0, 752, 753, 5, 62, 0, 0, 753, 769, 5, 63, 0, 0, 754, 755, 5, 62, 0, 0, 755, 769, 5, 64, 0, 0, 756, 757, 5, 62, 0, 0, 757, 769, 5, 65, 0, 0, 758, 759, 5, 62, 0, 0, 759, 769, 5, 66, 0, 0, 760, 769, 5, 67, 0, 0, 761, 769, 5, 68, 0, 0, 762, 769, 5, 69, 0, 0, 763, 764, 5, 70, 0, 0, 764, 765, 5, 30, 0, 0, 765, 766, 3, 32, 16, 0, 766, 767, 5, 31, 0, 0, 767, 769, 1, 0, 0, 0, 768, 731, 1, 0, 0, 0, 768, 732, 1, 0, 0, 0, 768, 733, 1, 0, 0, 0, 768, 734, 1, 0, 0, 0, 768, 735, 1, 0, 0, 0, 768, 736, 1, 0, 0, 0, 768, 737, 1, 0, 0, 0, 768, 738, 1, 0, 0, 0, 768, 739, 1, 0, 0, 0, 768, 740, 1, 0, 0, 0, 768, 741, 1, 0, 0, 0, 768, 742, 1, 0, 0, 0, 768, 743, 1, 0, 0, 0, 768, 744, 1, 0, 0, 0, 768, 745, 1, 0, 0, 0, 768, 746, 1, 0, 0, 0, 768, 747, 1, 0, 0, 0, 768, 748, 1, 0, 0, 0, 768, 750, 1, 0, 0, 0, 768, 752, 1, 0, 0, 0, 768, 754, 1, 0, 0, 0, 768, 756, 1, 0, 0, 0, 768, 758, 1, 0, 0, 0, 768, 760, 1, 0, 0, 0, 768, 761, 1, 0, 0, 0, 768, 762, 1, 0, 0, 0, 768, 763, 1, 0, 0, 0, 769, 77, 1, 0, 0, 0, 770, 774, 1, 0, 0, 0, 771, 772, 5, 71, 0, 0, 772, 774, 3, 124, 62, 0, 773, 770, 1, 0, 0, 0, 773, 771, 1, 0, 0, 0, 774, 79, 1, 0, 0, 0, 775, 779, 1, 0, 0, 0, 776, 777, 5, 72, 0, 0, 777, 779, 3, 84, 42, 0, 778, 775, 1, 0, 0, 0, 778, 776, 1, 0, 0, 0, 779, 81, 1, 0, 0, 0, 780, 782, 3, 198, 99, 0, 781, 780, 1, 0, 0, 0, 782, 785, 1, 0, 0, 0, 783, 781, 1, 0, 0, 0, 783, 784, 1, 0, 0, 0, 784, 83, 1, 0, 0, 0, 785, 783, 1, 0, 0, 0, 786, 787, 3, 124, 62, 0, 787, 788, 5, 28, 0, 0, 788, 790, 1, 0, 0, 0, 789, 786, 1, 0, 0, 0, 790, 793, 1, 0, 0, 0, 791, 789, 1, 0, 0, 0, 791, 792, 1, 0, 0, 0, 792, 794, 1, 0, 0, 0, 793, 791, 1, 0, 0, 0, 794, 795, 3, 124, 62, 0, 795, 85, 1, 0, 0, 0, 796, 797, 7, 5, 0, 0, 797, 87, 1, 0, 0, 0, 798, 799, 3, 86, 43, 0, 799, 800, 3, 32, 16, 0, 800, 801, 5, 264, 0, 0, 801, 902, 1, 0, 0, 0, 802, 803, 3, 86, 43, 0, 803, 804, 3, 32, 16, 0, 804, 902, 1, 0, 0, 0, 805, 806, 3, 86, 43, 0, 806, 807, 3, 32, 16, 0, 807, 808, 5, 75, 0, 0, 808, 809, 3, 32, 16, 0, 809, 810, 5, 264, 0, 0, 810, 902, 1, 0, 0, 0, 811, 812, 3, 86, 43, 0, 812, 813, 3, 32, 16, 0, 813, 814, 5, 75, 0, 0, 814, 815, 3, 32, 16, 0, 815, 902, 1, 0, 0, 0, 816, 817, 3, 86, 43, 0, 817, 818, 3, 32, 16, 0, 818, 819, 5, 75, 0, 0, 819, 820, 3, 32, 16, 0, 820, 821, 5, 28, 0, 0, 821, 822, 3, 32, 16, 0, 822, 823, 5, 264, 0, 0, 823, 902, 1, 0, 0, 0, 824, 825, 3, 86, 43, 0, 825, 826, 3, 32, 16, 0, 826, 827, 5, 75, 0, 0, 827, 828, 3, 32, 16, 0, 828, 829, 5, 28, 0, 0, 829, 830, 3, 32, 16, 0, 830, 902, 1, 0, 0, 0, 831, 832, 3, 86, 43, 0, 832, 833, 3, 32, 16, 0, 833, 834, 5, 28, 0, 0, 834, 835, 3, 32, 16, 0, 835, 836, 5, 75, 0, 0, 836, 837, 3, 32, 16, 0, 837, 838, 5, 264, 0, 0, 838, 902, 1, 0, 0, 0, 839, 840, 3, 86, 43, 0, 840, 841, 3, 32, 16, 0, 841, 842, 5, 28, 0, 0, 842, 843, 3, 32, 16, 0, 843, 844, 5, 75, 0, 0, 844, 845, 3, 32, 16, 0, 845, 902, 1, 0, 0, 0, 846, 847, 3, 86, 43, 0, 847, 848, 3, 32, 16, 0, 848, 849, 5, 28, 0, 0, 849, 850, 3, 32, 16, 0, 850, 851, 5, 75, 0, 0, 851, 852, 3, 32, 16, 0, 852, 853, 5, 28, 0, 0, 853, 854, 3, 32, 16, 0, 854, 855, 5, 264, 0, 0, 855, 902, 1, 0, 0, 0, 856, 857, 3, 86, 43, 0, 857, 858, 3, 32, 16, 0, 858, 859, 5, 28, 0, 0, 859, 860, 3, 32, 16, 0, 860, 861, 5, 75, 0, 0, 861, 862, 3, 32, 16, 0, 862, 863, 5, 28, 0, 0, 863, 864, 3, 32, 16, 0, 864, 902, 1, 0, 0, 0, 865, 866, 3, 86, 43, 0, 866, 867, 3, 32, 16, 0, 867, 868, 5, 263, 0, 0, 868, 902, 1, 0, 0, 0, 869, 870, 3, 86, 43, 0, 870, 871, 3, 32, 16, 0, 871, 872, 5, 75, 0, 0, 872, 873, 3, 32, 16, 0, 873, 874, 5, 263, 0, 0, 874, 902, 1, 0, 0, 0, 875, 876, 3, 86, 43, 0, 876, 877, 3, 32, 16, 0, 877, 878, 5, 75, 0, 0, 878, 879, 3, 32, 16, 0, 879, 880, 5, 28, 0, 0, 880, 881, 3, 32, 16, 0, 881, 882, 5, 263, 0, 0, 882, 902, 1, 0, 0, 0, 883, 884, 3, 86, 43, 0, 884, 885, 3, 32, 16, 0, 885, 886, 5, 28, 0, 0, 886, 887, 3, 32, 16, 0, 887, 888, 5, 75, 0, 0, 888, 889, 3, 32, 16, 0, 889, 890, 5, 263, 0, 0, 890, 902, 1, 0, 0, 0, 891, 892, 3, 86, 43, 0, 892, 893, 3, 32, 16, 0, 893, 894, 5, 28, 0, 0, 894, 895, 3, 32, 16, 0, 895, 896, 5, 75, 0, 0, 896, 897, 3, 32, 16, 0, 897, 898, 5, 28, 0, 0, 898, 899, 3, 32, 16, 0, 899, 900, 5, 263, 0, 0, 900, 902, 1, 0, 0, 0, 901, 798, 1, 0, 0, 0, 901, 802, 1, 0, 0, 0, 901, 805, 1, 0, 0, 0, 901, 811, 1, 0, 0, 0, 901, 816, 1, 0, 0, 0, 901, 824, 1, 0, 0, 0, 901, 831, 1, 0, 0, 0, 901, 839, 1, 0, 0, 0, 901, 846, 1, 0, 0, 0, 901, 856, 1, 0, 0, 0, 901, 865, 1, 0, 0, 0, 901, 869, 1, 0, 0, 0, 901, 875, 1, 0, 0, 0, 901, 883, 1, 0, 0, 0, 901, 891, 1, 0, 0, 0, 902, 89, 1, 0, 0, 0, 903, 907, 5, 21, 0, 0, 904, 906, 3, 92, 46, 0, 905, 904, 1, 0, 0, 0, 906, 909, 1, 0, 0, 0, 907, 905, 1, 0, 0, 0, 907, 908, 1, 0, 0, 0, 908, 910, 1, 0, 0, 0, 909, 907, 1, 0, 0, 0, 910, 911, 3, 2, 1, 0, 911, 912, 3, 94, 47, 0, 912, 913, 5, 180, 0, 0, 913, 914, 5, 36, 0, 0, 914, 915, 5, 30, 0, 0, 915, 916, 3, 292, 146, 0, 916, 917, 5, 31, 0, 0, 917, 918, 3, 94, 47, 0, 918, 930, 1, 0, 0, 0, 919, 923, 5, 21, 0, 0, 920, 922, 3, 92, 46, 0, 921, 920, 1, 0, 0, 0, 922, 925, 1, 0, 0, 0, 923, 921, 1, 0, 0, 0, 923, 924, 1, 0, 0, 0, 924, 926, 1, 0, 0, 0, 925, 923, 1, 0, 0, 0, 926, 927, 3, 2, 1, 0, 927, 928, 3, 94, 47, 0, 928, 930, 1, 0, 0, 0, 929, 903, 1, 0, 0, 0, 929, 919, 1, 0, 0, 0, 930, 91, 1, 0, 0, 0, 931, 932, 5, 76, 0, 0, 932, 93, 1, 0, 0, 0, 933, 936, 1, 0, 0, 0, 934, 936, 5, 298, 0, 0, 935, 933, 1, 0, 0, 0, 935, 934, 1, 0, 0, 0, 936, 95, 1, 0, 0, 0, 937, 938, 7, 6, 0, 0, 938, 97, 1, 0, 0, 0, 939, 941, 3, 96, 48, 0, 940, 939, 1, 0, 0, 0, 941, 944, 1, 0, 0, 0, 942, 940, 1, 0, 0, 0, 942, 943, 1, 0, 0, 0, 943, 99, 1, 0, 0, 0, 944, 942, 1, 0, 0, 0, 945, 971, 3, 102, 51, 0, 946, 947, 5, 280, 0, 0, 947, 948, 3, 168, 84, 0, 948, 949, 6, 50, -1, 0, 949, 971, 1, 0, 0, 0, 950, 951, 5, 286, 0, 0, 951, 952, 3, 178, 89, 0, 952, 953, 6, 50, -1, 0, 953, 971, 1, 0, 0, 0, 954, 955, 5, 286, 0, 0, 955, 956, 3, 174, 87, 0, 956, 957, 6, 50, -1, 0, 957, 971, 1, 0, 0, 0, 958, 959, 5, 284, 0, 0, 959, 960, 3, 124, 62, 0, 960, 961, 6, 50, -1, 0, 961, 971, 1, 0, 0, 0, 962, 963, 5, 281, 0, 0, 963, 964, 3, 104, 52, 0, 964, 965, 6, 50, -1, 0, 965, 971, 1, 0, 0, 0, 966, 967, 5, 287, 0, 0, 967, 968, 3, 50, 25, 0, 968, 969, 6, 50, -1, 0, 969, 971, 1, 0, 0, 0, 970, 945, 1, 0, 0, 0, 970, 946, 1, 0, 0, 0, 970, 950, 1, 0, 0, 0, 970, 954, 1, 0, 0, 0, 970, 958, 1, 0, 0, 0, 970, 962, 1, 0, 0, 0, 970, 966, 1, 0, 0, 0, 971, 101, 1, 0, 0, 0, 972, 973, 5, 275, 0, 0, 973, 1051, 6, 51, -1, 0, 974, 975, 5, 276, 0, 0, 975, 976, 3, 32, 16, 0, 976, 977, 6, 51, -1, 0, 977, 1051, 1, 0, 0, 0, 978, 979, 5, 276, 0, 0, 979, 980, 3, 0, 0, 0, 980, 981, 6, 51, -1, 0, 981, 1051, 1, 0, 0, 0, 982, 983, 5, 277, 0, 0, 983, 984, 3, 32, 16, 0, 984, 985, 6, 51, -1, 0, 985, 1051, 1, 0, 0, 0, 986, 987, 5, 278, 0, 0, 987, 988, 3, 34, 17, 0, 988, 989, 6, 51, -1, 0, 989, 1051, 1, 0, 0, 0, 990, 991, 5, 279, 0, 0, 991, 992, 3, 36, 18, 0, 992, 993, 6, 51, -1, 0, 993, 1051, 1, 0, 0, 0, 994, 995, 5, 279, 0, 0, 995, 996, 3, 34, 17, 0, 996, 997, 6, 51, -1, 0, 997, 1051, 1, 0, 0, 0, 998, 999, 5, 279, 0, 0, 999, 1000, 5, 30, 0, 0, 1000, 1001, 3, 292, 146, 0, 1001, 1002, 5, 31, 0, 0, 1002, 1003, 6, 51, -1, 0, 1003, 1051, 1, 0, 0, 0, 1004, 1005, 5, 279, 0, 0, 1005, 1006, 5, 84, 0, 0, 1006, 1007, 5, 30, 0, 0, 1007, 1008, 3, 292, 146, 0, 1008, 1009, 5, 31, 0, 0, 1009, 1010, 6, 51, -1, 0, 1010, 1051, 1, 0, 0, 0, 1011, 1012, 5, 282, 0, 0, 1012, 1013, 3, 32, 16, 0, 1013, 1014, 6, 51, -1, 0, 1014, 1051, 1, 0, 0, 0, 1015, 1016, 5, 282, 0, 0, 1016, 1017, 3, 0, 0, 0, 1017, 1018, 6, 51, -1, 0, 1018, 1051, 1, 0, 0, 0, 1019, 1020, 5, 285, 0, 0, 1020, 1021, 3, 6, 3, 0, 1021, 1022, 6, 51, -1, 0, 1022, 1051, 1, 0, 0, 0, 1023, 1024, 5, 285, 0, 0, 1024, 1025, 5, 224, 0, 0, 1025, 1026, 5, 30, 0, 0, 1026, 1027, 3, 6, 3, 0, 1027, 1028, 5, 31, 0, 0, 1028, 1029, 6, 51, -1, 0, 1029, 1051, 1, 0, 0, 0, 1030, 1031, 5, 285, 0, 0, 1031, 1032, 5, 84, 0, 0, 1032, 1033, 5, 30, 0, 0, 1033, 1034, 3, 292, 146, 0, 1034, 1035, 5, 31, 0, 0, 1035, 1036, 6, 51, -1, 0, 1036, 1051, 1, 0, 0, 0, 1037, 1038, 5, 287, 0, 0, 1038, 1039, 3, 32, 16, 0, 1039, 1040, 6, 51, -1, 0, 1040, 1051, 1, 0, 0, 0, 1041, 1042, 5, 283, 0, 0, 1042, 1048, 6, 51, -1, 0, 1043, 1044, 5, 30, 0, 0, 1044, 1045, 3, 106, 53, 0, 1045, 1046, 5, 31, 0, 0, 1046, 1049, 1, 0, 0, 0, 1047, 1049, 5, 85, 0, 0, 1048, 1043, 1, 0, 0, 0, 1048, 1047, 1, 0, 0, 0, 1049, 1051, 1, 0, 0, 0, 1050, 972, 1, 0, 0, 0, 1050, 974, 1, 0, 0, 0, 1050, 978, 1, 0, 0, 0, 1050, 982, 1, 0, 0, 0, 1050, 986, 1, 0, 0, 0, 1050, 990, 1, 0, 0, 0, 1050, 994, 1, 0, 0, 0, 1050, 998, 1, 0, 0, 0, 1050, 1004, 1, 0, 0, 0, 1050, 1011, 1, 0, 0, 0, 1050, 1015, 1, 0, 0, 0, 1050, 1019, 1, 0, 0, 0, 1050, 1023, 1, 0, 0, 0, 1050, 1030, 1, 0, 0, 0, 1050, 1037, 1, 0, 0, 0, 1050, 1041, 1, 0, 0, 0, 1051, 103, 1, 0, 0, 0, 1052, 1053, 3, 170, 85, 0, 1053, 1054, 3, 138, 69, 0, 1054, 1055, 3, 112, 56, 0, 1055, 1056, 6, 52, -1, 0, 1056, 105, 1, 0, 0, 0, 1057, 1082, 1, 0, 0, 0, 1058, 1059, 3, 0, 0, 0, 1059, 1060, 6, 53, -1, 0, 1060, 1065, 1, 0, 0, 0, 1061, 1062, 3, 32, 16, 0, 1062, 1063, 6, 53, -1, 0, 1063, 1065, 1, 0, 0, 0, 1064, 1058, 1, 0, 0, 0, 1064, 1061, 1, 0, 0, 0, 1065, 1066, 1, 0, 0, 0, 1066, 1067, 5, 28, 0, 0, 1067, 1069, 1, 0, 0, 0, 1068, 1064, 1, 0, 0, 0, 1069, 1072, 1, 0, 0, 0, 1070, 1068, 1, 0, 0, 0, 1070, 1071, 1, 0, 0, 0, 1071, 1079, 1, 0, 0, 0, 1072, 1070, 1, 0, 0, 0, 1073, 1074, 3, 0, 0, 0, 1074, 1075, 6, 53, -1, 0, 1075, 1080, 1, 0, 0, 0, 1076, 1077, 3, 32, 16, 0, 1077, 1078, 6, 53, -1, 0, 1078, 1080, 1, 0, 0, 0, 1079, 1073, 1, 0, 0, 0, 1079, 1076, 1, 0, 0, 0, 1080, 1082, 1, 0, 0, 0, 1081, 1057, 1, 0, 0, 0, 1081, 1070, 1, 0, 0, 0, 1082, 107, 1, 0, 0, 0, 1083, 1090, 5, 86, 0, 0, 1084, 1085, 3, 138, 69, 0, 1085, 1086, 6, 54, -1, 0, 1086, 1087, 5, 28, 0, 0, 1087, 1089, 1, 0, 0, 0, 1088, 1084, 1, 0, 0, 0, 1089, 1092, 1, 0, 0, 0, 1090, 1088, 1, 0, 0, 0, 1090, 1091, 1, 0, 0, 0, 1091, 1093, 1, 0, 0, 0, 1092, 1090, 1, 0, 0, 0, 1093, 1094, 3, 138, 69, 0, 1094, 1095, 6, 54, -1, 0, 1095, 1096, 5, 87, 0, 0, 1096, 109, 1, 0, 0, 0, 1097, 1104, 5, 42, 0, 0, 1098, 1099, 3, 146, 73, 0, 1099, 1100, 6, 55, -1, 0, 1100, 1101, 5, 28, 0, 0, 1101, 1103, 1, 0, 0, 0, 1102, 1098, 1, 0, 0, 0, 1103, 1106, 1, 0, 0, 0, 1104, 1102, 1, 0, 0, 0, 1104, 1105, 1, 0, 0, 0, 1105, 1107, 1, 0, 0, 0, 1106, 1104, 1, 0, 0, 0, 1107, 1108, 3, 146, 73, 0, 1108, 1109, 6, 55, -1, 0, 1109, 1110, 5, 43, 0, 0, 1110, 111, 1, 0, 0, 0, 1111, 1118, 5, 30, 0, 0, 1112, 1113, 3, 114, 57, 0, 1113, 1114, 6, 56, -1, 0, 1114, 1115, 5, 28, 0, 0, 1115, 1117, 1, 0, 0, 0, 1116, 1112, 1, 0, 0, 0, 1117, 1120, 1, 0, 0, 0, 1118, 1116, 1, 0, 0, 0, 1118, 1119, 1, 0, 0, 0, 1119, 1121, 1, 0, 0, 0, 1120, 1118, 1, 0, 0, 0, 1121, 1122, 3, 114, 57, 0, 1122, 1123, 6, 56, -1, 0, 1123, 1124, 5, 31, 0, 0, 1124, 1127, 1, 0, 0, 0, 1125, 1127, 5, 85, 0, 0, 1126, 1111, 1, 0, 0, 0, 1126, 1125, 1, 0, 0, 0, 1127, 113, 1, 0, 0, 0, 1128, 1129, 5, 177, 0, 0, 1129, 1139, 6, 57, -1, 0, 1130, 1131, 3, 230, 115, 0, 1131, 1132, 3, 138, 69, 0, 1132, 1134, 3, 226, 113, 0, 1133, 1135, 3, 0, 0, 0, 1134, 1133, 1, 0, 0, 0, 1134, 1135, 1, 0, 0, 0, 1135, 1136, 1, 0, 0, 0, 1136, 1137, 6, 57, -1, 0, 1137, 1139, 1, 0, 0, 0, 1138, 1128, 1, 0, 0, 0, 1138, 1130, 1, 0, 0, 0, 1139, 115, 1, 0, 0, 0, 1140, 1141, 5, 42, 0, 0, 1141, 1142, 3, 2, 1, 0, 1142, 1143, 5, 43, 0, 0, 1143, 1144, 3, 118, 59, 0, 1144, 1145, 6, 58, -1, 0, 1145, 1178, 1, 0, 0, 0, 1146, 1147, 5, 42, 0, 0, 1147, 1148, 3, 174, 87, 0, 1148, 1149, 5, 43, 0, 0, 1149, 1150, 3, 118, 59, 0, 1150, 1151, 6, 58, -1, 0, 1151, 1178, 1, 0, 0, 0, 1152, 1153, 5, 42, 0, 0, 1153, 1154, 5, 262, 0, 0, 1154, 1155, 5, 43, 0, 0, 1155, 1156, 3, 118, 59, 0, 1156, 1157, 6, 58, -1, 0, 1157, 1178, 1, 0, 0, 0, 1158, 1159, 5, 42, 0, 0, 1159, 1160, 5, 198, 0, 0, 1160, 1161, 3, 2, 1, 0, 1161, 1162, 5, 43, 0, 0, 1162, 1163, 3, 118, 59, 0, 1163, 1164, 6, 58, -1, 0, 1164, 1178, 1, 0, 0, 0, 1165, 1166, 3, 118, 59, 0, 1166, 1167, 6, 58, -1, 0, 1167, 1178, 1, 0, 0, 0, 1168, 1169, 3, 174, 87, 0, 1169, 1170, 6, 58, -1, 0, 1170, 1178, 1, 0, 0, 0, 1171, 1172, 5, 257, 0, 0, 1172, 1178, 6, 58, -1, 0, 1173, 1174, 5, 258, 0, 0, 1174, 1178, 6, 58, -1, 0, 1175, 1176, 5, 259, 0, 0, 1176, 1178, 6, 58, -1, 0, 1177, 1140, 1, 0, 0, 0, 1177, 1146, 1, 0, 0, 0, 1177, 1152, 1, 0, 0, 0, 1177, 1158, 1, 0, 0, 0, 1177, 1165, 1, 0, 0, 0, 1177, 1168, 1, 0, 0, 0, 1177, 1171, 1, 0, 0, 0, 1177, 1173, 1, 0, 0, 0, 1177, 1175, 1, 0, 0, 0, 1178, 117, 1, 0, 0, 0, 1179, 1180, 3, 2, 1, 0, 1180, 1181, 6, 59, -1, 0, 1181, 1182, 5, 88, 0, 0, 1182, 1184, 1, 0, 0, 0, 1183, 1179, 1, 0, 0, 0, 1184, 1187, 1, 0, 0, 0, 1185, 1183, 1, 0, 0, 0, 1185, 1186, 1, 0, 0, 0, 1186, 1188, 1, 0, 0, 0, 1187, 1185, 1, 0, 0, 0, 1188, 1189, 3, 2, 1, 0, 1189, 1190, 6, 59, -1, 0, 1190, 119, 1, 0, 0, 0, 1191, 1193, 3, 122, 61, 0, 1192, 1191, 1, 0, 0, 0, 1193, 1196, 1, 0, 0, 0, 1194, 1192, 1, 0, 0, 0, 1194, 1195, 1, 0, 0, 0, 1195, 121, 1, 0, 0, 0, 1196, 1194, 1, 0, 0, 0, 1197, 1198, 5, 180, 0, 0, 1198, 1199, 5, 89, 0, 0, 1199, 1203, 3, 32, 16, 0, 1200, 1203, 3, 152, 76, 0, 1201, 1203, 3, 324, 162, 0, 1202, 1197, 1, 0, 0, 0, 1202, 1200, 1, 0, 0, 0, 1202, 1201, 1, 0, 0, 0, 1203, 123, 1, 0, 0, 0, 1204, 1205, 3, 116, 58, 0, 1205, 1206, 6, 62, -1, 0, 1206, 1222, 1, 0, 0, 0, 1207, 1208, 5, 42, 0, 0, 1208, 1209, 3, 2, 1, 0, 1209, 1210, 5, 43, 0, 0, 1210, 1211, 6, 62, -1, 0, 1211, 1222, 1, 0, 0, 0, 1212, 1213, 5, 42, 0, 0, 1213, 1214, 5, 198, 0, 0, 1214, 1215, 3, 2, 1, 0, 1215, 1216, 5, 43, 0, 0, 1216, 1217, 6, 62, -1, 0, 1217, 1222, 1, 0, 0, 0, 1218, 1219, 3, 138, 69, 0, 1219, 1220, 6, 62, -1, 0, 1220, 1222, 1, 0, 0, 0, 1221, 1204, 1, 0, 0, 0, 1221, 1207, 1, 0, 0, 0, 1221, 1212, 1, 0, 0, 0, 1221, 1218, 1, 0, 0, 0, 1222, 125, 1, 0, 0, 0, 1223, 1235, 1, 0, 0, 0, 1224, 1225, 3, 130, 65, 0, 1225, 1231, 6, 63, -1, 0, 1226, 1227, 3, 128, 64, 0, 1227, 1228, 6, 63, -1, 0, 1228, 1230, 1, 0, 0, 0, 1229, 1226, 1, 0, 0, 0, 1230, 1233, 1, 0, 0, 0, 1231, 1229, 1, 0, 0, 0, 1231, 1232, 1, 0, 0, 0, 1232, 1235, 1, 0, 0, 0, 1233, 1231, 1, 0, 0, 0, 1234, 1223, 1, 0, 0, 0, 1234, 1224, 1, 0, 0, 0, 1235, 127, 1, 0, 0, 0, 1236, 1237, 5, 262, 0, 0, 1237, 1259, 6, 64, -1, 0, 1238, 1239, 5, 261, 0, 0, 1239, 1259, 6, 64, -1, 0, 1240, 1241, 5, 42, 0, 0, 1241, 1242, 3, 32, 16, 0, 1242, 1243, 5, 43, 0, 0, 1243, 1244, 6, 64, -1, 0, 1244, 1259, 1, 0, 0, 0, 1245, 1246, 5, 42, 0, 0, 1246, 1247, 3, 32, 16, 0, 1247, 1248, 5, 266, 0, 0, 1248, 1249, 3, 32, 16, 0, 1249, 1250, 5, 43, 0, 0, 1250, 1251, 6, 64, -1, 0, 1251, 1259, 1, 0, 0, 0, 1252, 1253, 5, 42, 0, 0, 1253, 1254, 5, 266, 0, 0, 1254, 1255, 3, 32, 16, 0, 1255, 1256, 5, 43, 0, 0, 1256, 1257, 6, 64, -1, 0, 1257, 1259, 1, 0, 0, 0, 1258, 1236, 1, 0, 0, 0, 1258, 1238, 1, 0, 0, 0, 1258, 1240, 1, 0, 0, 0, 1258, 1245, 1, 0, 0, 0, 1258, 1252, 1, 0, 0, 0, 1259, 129, 1, 0, 0, 0, 1260, 1406, 6, 65, -1, 0, 1261, 1262, 5, 203, 0, 0, 1262, 1263, 5, 30, 0, 0, 1263, 1264, 3, 6, 3, 0, 1264, 1265, 5, 28, 0, 0, 1265, 1266, 3, 6, 3, 0, 1266, 1267, 5, 28, 0, 0, 1267, 1268, 3, 6, 3, 0, 1268, 1269, 5, 28, 0, 0, 1269, 1270, 3, 6, 3, 0, 1270, 1271, 5, 31, 0, 0, 1271, 1272, 6, 65, -1, 0, 1272, 1406, 1, 0, 0, 0, 1273, 1274, 5, 203, 0, 0, 1274, 1275, 5, 30, 0, 0, 1275, 1276, 3, 6, 3, 0, 1276, 1277, 5, 28, 0, 0, 1277, 1278, 3, 6, 3, 0, 1278, 1279, 5, 31, 0, 0, 1279, 1280, 6, 65, -1, 0, 1280, 1406, 1, 0, 0, 0, 1281, 1282, 5, 204, 0, 0, 1282, 1283, 5, 205, 0, 0, 1283, 1284, 5, 42, 0, 0, 1284, 1285, 3, 32, 16, 0, 1285, 1286, 5, 43, 0, 0, 1286, 1287, 6, 65, -1, 0, 1287, 1406, 1, 0, 0, 0, 1288, 1289, 5, 204, 0, 0, 1289, 1290, 5, 206, 0, 0, 1290, 1291, 5, 42, 0, 0, 1291, 1292, 3, 32, 16, 0, 1292, 1293, 5, 43, 0, 0, 1293, 1294, 3, 126, 63, 0, 1294, 1295, 6, 65, -1, 0, 1295, 1406, 1, 0, 0, 0, 1296, 1297, 5, 207, 0, 0, 1297, 1406, 6, 65, -1, 0, 1298, 1299, 5, 208, 0, 0, 1299, 1406, 6, 65, -1, 0, 1300, 1301, 5, 209, 0, 0, 1301, 1406, 6, 65, -1, 0, 1302, 1303, 5, 201, 0, 0, 1303, 1406, 6, 65, -1, 0, 1304, 1305, 5, 183, 0, 0, 1305, 1406, 6, 65, -1, 0, 1306, 1307, 5, 184, 0, 0, 1307, 1406, 6, 65, -1, 0, 1308, 1309, 5, 185, 0, 0, 1309, 1406, 6, 65, -1, 0, 1310, 1311, 5, 186, 0, 0, 1311, 1406, 6, 65, -1, 0, 1312, 1313, 5, 187, 0, 0, 1313, 1406, 6, 65, -1, 0, 1314, 1315, 5, 188, 0, 0, 1315, 1406, 6, 65, -1, 0, 1316, 1317, 5, 189, 0, 0, 1317, 1406, 6, 65, -1, 0, 1318, 1319, 5, 210, 0, 0, 1319, 1406, 6, 65, -1, 0, 1320, 1321, 5, 190, 0, 0, 1321, 1406, 6, 65, -1, 0, 1322, 1323, 5, 191, 0, 0, 1323, 1406, 6, 65, -1, 0, 1324, 1325, 5, 192, 0, 0, 1325, 1406, 6, 65, -1, 0, 1326, 1327, 5, 193, 0, 0, 1327, 1406, 6, 65, -1, 0, 1328, 1329, 5, 211, 0, 0, 1329, 1406, 6, 65, -1, 0, 1330, 1331, 5, 212, 0, 0, 1331, 1406, 6, 65, -1, 0, 1332, 1333, 5, 213, 0, 0, 1333, 1406, 6, 65, -1, 0, 1334, 1335, 5, 214, 0, 0, 1335, 1406, 6, 65, -1, 0, 1336, 1337, 5, 215, 0, 0, 1337, 1406, 6, 65, -1, 0, 1338, 1339, 5, 216, 0, 0, 1339, 1406, 6, 65, -1, 0, 1340, 1341, 5, 217, 0, 0, 1341, 1406, 6, 65, -1, 0, 1342, 1343, 5, 218, 0, 0, 1343, 1344, 3, 132, 66, 0, 1344, 1345, 6, 65, -1, 0, 1345, 1406, 1, 0, 0, 0, 1346, 1347, 5, 219, 0, 0, 1347, 1348, 3, 132, 66, 0, 1348, 1349, 6, 65, -1, 0, 1349, 1406, 1, 0, 0, 0, 1350, 1351, 5, 220, 0, 0, 1351, 1406, 6, 65, -1, 0, 1352, 1353, 5, 221, 0, 0, 1353, 1354, 3, 132, 66, 0, 1354, 1355, 6, 65, -1, 0, 1355, 1406, 1, 0, 0, 0, 1356, 1357, 5, 222, 0, 0, 1357, 1358, 3, 134, 67, 0, 1358, 1359, 6, 65, -1, 0, 1359, 1406, 1, 0, 0, 0, 1360, 1361, 5, 222, 0, 0, 1361, 1362, 3, 134, 67, 0, 1362, 1363, 5, 28, 0, 0, 1363, 1364, 3, 6, 3, 0, 1364, 1365, 6, 65, -1, 0, 1365, 1406, 1, 0, 0, 0, 1366, 1367, 5, 194, 0, 0, 1367, 1406, 6, 65, -1, 0, 1368, 1369, 5, 195, 0, 0, 1369, 1406, 6, 65, -1, 0, 1370, 1371, 5, 90, 0, 0, 1371, 1372, 5, 184, 0, 0, 1372, 1406, 6, 65, -1, 0, 1373, 1374, 5, 90, 0, 0, 1374, 1375, 5, 185, 0, 0, 1375, 1406, 6, 65, -1, 0, 1376, 1377, 5, 90, 0, 0, 1377, 1378, 5, 186, 0, 0, 1378, 1406, 6, 65, -1, 0, 1379, 1380, 5, 90, 0, 0, 1380, 1381, 5, 187, 0, 0, 1381, 1406, 6, 65, -1, 0, 1382, 1383, 5, 62, 0, 0, 1383, 1384, 5, 220, 0, 0, 1384, 1406, 6, 65, -1, 0, 1385, 1386, 5, 223, 0, 0, 1386, 1406, 6, 65, -1, 0, 1387, 1388, 5, 224, 0, 0, 1388, 1389, 5, 213, 0, 0, 1389, 1406, 6, 65, -1, 0, 1390, 1391, 5, 225, 0, 0, 1391, 1406, 6, 65, -1, 0, 1392, 1393, 5, 207, 0, 0, 1393, 1394, 5, 183, 0, 0, 1394, 1406, 6, 65, -1, 0, 1395, 1396, 5, 226, 0, 0, 1396, 1406, 6, 65, -1, 0, 1397, 1398, 5, 228, 0, 0, 1398, 1406, 6, 65, -1, 0, 1399, 1400, 5, 34, 0, 0, 1400, 1401, 5, 227, 0, 0, 1401, 1406, 6, 65, -1, 0, 1402, 1403, 3, 2, 1, 0, 1403, 1404, 6, 65, -1, 0, 1404, 1406, 1, 0, 0, 0, 1405, 1260, 1, 0, 0, 0, 1405, 1261, 1, 0, 0, 0, 1405, 1273, 1, 0, 0, 0, 1405, 1281, 1, 0, 0, 0, 1405, 1288, 1, 0, 0, 0, 1405, 1296, 1, 0, 0, 0, 1405, 1298, 1, 0, 0, 0, 1405, 1300, 1, 0, 0, 0, 1405, 1302, 1, 0, 0, 0, 1405, 1304, 1, 0, 0, 0, 1405, 1306, 1, 0, 0, 0, 1405, 1308, 1, 0, 0, 0, 1405, 1310, 1, 0, 0, 0, 1405, 1312, 1, 0, 0, 0, 1405, 1314, 1, 0, 0, 0, 1405, 1316, 1, 0, 0, 0, 1405, 1318, 1, 0, 0, 0, 1405, 1320, 1, 0, 0, 0, 1405, 1322, 1, 0, 0, 0, 1405, 1324, 1, 0, 0, 0, 1405, 1326, 1, 0, 0, 0, 1405, 1328, 1, 0, 0, 0, 1405, 1330, 1, 0, 0, 0, 1405, 1332, 1, 0, 0, 0, 1405, 1334, 1, 0, 0, 0, 1405, 1336, 1, 0, 0, 0, 1405, 1338, 1, 0, 0, 0, 1405, 1340, 1, 0, 0, 0, 1405, 1342, 1, 0, 0, 0, 1405, 1346, 1, 0, 0, 0, 1405, 1350, 1, 0, 0, 0, 1405, 1352, 1, 0, 0, 0, 1405, 1356, 1, 0, 0, 0, 1405, 1360, 1, 0, 0, 0, 1405, 1366, 1, 0, 0, 0, 1405, 1368, 1, 0, 0, 0, 1405, 1370, 1, 0, 0, 0, 1405, 1373, 1, 0, 0, 0, 1405, 1376, 1, 0, 0, 0, 1405, 1379, 1, 0, 0, 0, 1405, 1382, 1, 0, 0, 0, 1405, 1385, 1, 0, 0, 0, 1405, 1387, 1, 0, 0, 0, 1405, 1390, 1, 0, 0, 0, 1405, 1392, 1, 0, 0, 0, 1405, 1395, 1, 0, 0, 0, 1405, 1397, 1, 0, 0, 0, 1405, 1399, 1, 0, 0, 0, 1405, 1402, 1, 0, 0, 0, 1406, 131, 1, 0, 0, 0, 1407, 1416, 1, 0, 0, 0, 1408, 1409, 5, 30, 0, 0, 1409, 1410, 5, 91, 0, 0, 1410, 1411, 5, 36, 0, 0, 1411, 1412, 3, 32, 16, 0, 1412, 1413, 5, 31, 0, 0, 1413, 1414, 6, 66, -1, 0, 1414, 1416, 1, 0, 0, 0, 1415, 1407, 1, 0, 0, 0, 1415, 1408, 1, 0, 0, 0, 1416, 133, 1, 0, 0, 0, 1417, 1428, 1, 0, 0, 0, 1418, 1419, 3, 136, 68, 0, 1419, 1424, 6, 67, -1, 0, 1420, 1421, 7, 7, 0, 0, 1421, 1423, 6, 67, -1, 0, 1422, 1420, 1, 0, 0, 0, 1423, 1426, 1, 0, 0, 0, 1424, 1422, 1, 0, 0, 0, 1424, 1425, 1, 0, 0, 0, 1425, 1428, 1, 0, 0, 0, 1426, 1424, 1, 0, 0, 0, 1427, 1417, 1, 0, 0, 0, 1427, 1418, 1, 0, 0, 0, 1428, 135, 1, 0, 0, 0, 1429, 1430, 5, 178, 0, 0, 1430, 1510, 6, 68, -1, 0, 1431, 1432, 5, 207, 0, 0, 1432, 1510, 6, 68, -1, 0, 1433, 1434, 5, 208, 0, 0, 1434, 1510, 6, 68, -1, 0, 1435, 1436, 5, 201, 0, 0, 1436, 1510, 6, 68, -1, 0, 1437, 1438, 5, 183, 0, 0, 1438, 1510, 6, 68, -1, 0, 1439, 1440, 5, 184, 0, 0, 1440, 1510, 6, 68, -1, 0, 1441, 1442, 5, 185, 0, 0, 1442, 1510, 6, 68, -1, 0, 1443, 1444, 5, 186, 0, 0, 1444, 1510, 6, 68, -1, 0, 1445, 1446, 5, 187, 0, 0, 1446, 1510, 6, 68, -1, 0, 1447, 1448, 5, 188, 0, 0, 1448, 1510, 6, 68, -1, 0, 1449, 1450, 5, 189, 0, 0, 1450, 1510, 6, 68, -1, 0, 1451, 1452, 5, 190, 0, 0, 1452, 1510, 6, 68, -1, 0, 1453, 1454, 5, 191, 0, 0, 1454, 1510, 6, 68, -1, 0, 1455, 1456, 5, 192, 0, 0, 1456, 1510, 6, 68, -1, 0, 1457, 1458, 5, 193, 0, 0, 1458, 1510, 6, 68, -1, 0, 1459, 1460, 5, 262, 0, 0, 1460, 1510, 6, 68, -1, 0, 1461, 1462, 5, 211, 0, 0, 1462, 1510, 6, 68, -1, 0, 1463, 1464, 5, 212, 0, 0, 1464, 1510, 6, 68, -1, 0, 1465, 1466, 5, 213, 0, 0, 1466, 1510, 6, 68, -1, 0, 1467, 1468, 5, 214, 0, 0, 1468, 1510, 6, 68, -1, 0, 1469, 1470, 5, 215, 0, 0, 1470, 1510, 6, 68, -1, 0, 1471, 1472, 5, 218, 0, 0, 1472, 1510, 6, 68, -1, 0, 1473, 1474, 5, 219, 0, 0, 1474, 1510, 6, 68, -1, 0, 1475, 1476, 5, 222, 0, 0, 1476, 1510, 6, 68, -1, 0, 1477, 1478, 5, 194, 0, 0, 1478, 1510, 6, 68, -1, 0, 1479, 1480, 5, 195, 0, 0, 1480, 1510, 6, 68, -1, 0, 1481, 1482, 5, 210, 0, 0, 1482, 1510, 6, 68, -1, 0, 1483, 1484, 5, 230, 0, 0, 1484, 1510, 6, 68, -1, 0, 1485, 1486, 5, 231, 0, 0, 1486, 1510, 6, 68, -1, 0, 1487, 1488, 5, 232, 0, 0, 1488, 1510, 6, 68, -1, 0, 1489, 1490, 5, 233, 0, 0, 1490, 1510, 6, 68, -1, 0, 1491, 1492, 5, 234, 0, 0, 1492, 1510, 6, 68, -1, 0, 1493, 1494, 5, 235, 0, 0, 1494, 1510, 6, 68, -1, 0, 1495, 1496, 5, 236, 0, 0, 1496, 1510, 6, 68, -1, 0, 1497, 1498, 5, 237, 0, 0, 1498, 1510, 6, 68, -1, 0, 1499, 1500, 5, 238, 0, 0, 1500, 1510, 6, 68, -1, 0, 1501, 1502, 5, 239, 0, 0, 1502, 1510, 6, 68, -1, 0, 1503, 1504, 5, 240, 0, 0, 1504, 1510, 6, 68, -1, 0, 1505, 1506, 5, 241, 0, 0, 1506, 1510, 6, 68, -1, 0, 1507, 1508, 5, 242, 0, 0, 1508, 1510, 6, 68, -1, 0, 1509, 1429, 1, 0, 0, 0, 1509, 1431, 1, 0, 0, 0, 1509, 1433, 1, 0, 0, 0, 1509, 1435, 1, 0, 0, 0, 1509, 1437, 1, 0, 0, 0, 1509, 1439, 1, 0, 0, 0, 1509, 1441, 1, 0, 0, 0, 1509, 1443, 1, 0, 0, 0, 1509, 1445, 1, 0, 0, 0, 1509, 1447, 1, 0, 0, 0, 1509, 1449, 1, 0, 0, 0, 1509, 1451, 1, 0, 0, 0, 1509, 1453, 1, 0, 0, 0, 1509, 1455, 1, 0, 0, 0, 1509, 1457, 1, 0, 0, 0, 1509, 1459, 1, 0, 0, 0, 1509, 1461, 1, 0, 0, 0, 1509, 1463, 1, 0, 0, 0, 1509, 1465, 1, 0, 0, 0, 1509, 1467, 1, 0, 0, 0, 1509, 1469, 1, 0, 0, 0, 1509, 1471, 1, 0, 0, 0, 1509, 1473, 1, 0, 0, 0, 1509, 1475, 1, 0, 0, 0, 1509, 1477, 1, 0, 0, 0, 1509, 1479, 1, 0, 0, 0, 1509, 1481, 1, 0, 0, 0, 1509, 1483, 1, 0, 0, 0, 1509, 1485, 1, 0, 0, 0, 1509, 1487, 1, 0, 0, 0, 1509, 1489, 1, 0, 0, 0, 1509, 1491, 1, 0, 0, 0, 1509, 1493, 1, 0, 0, 0, 1509, 1495, 1, 0, 0, 0, 1509, 1497, 1, 0, 0, 0, 1509, 1499, 1, 0, 0, 0, 1509, 1501, 1, 0, 0, 0, 1509, 1503, 1, 0, 0, 0, 1509, 1505, 1, 0, 0, 0, 1509, 1507, 1, 0, 0, 0, 1510, 137, 1, 0, 0, 0, 1511, 1512, 3, 142, 71, 0, 1512, 1518, 6, 69, -1, 0, 1513, 1514, 3, 140, 70, 0, 1514, 1515, 6, 69, -1, 0, 1515, 1517, 1, 0, 0, 0, 1516, 1513, 1, 0, 0, 0, 1517, 1520, 1, 0, 0, 0, 1518, 1516, 1, 0, 0, 0, 1518, 1519, 1, 0, 0, 0, 1519, 139, 1, 0, 0, 0, 1520, 1518, 1, 0, 0, 0, 1521, 1522, 5, 261, 0, 0, 1522, 1551, 6, 70, -1, 0, 1523, 1524, 5, 42, 0, 0, 1524, 1525, 5, 43, 0, 0, 1525, 1551, 6, 70, -1, 0, 1526, 1527, 3, 110, 55, 0, 1527, 1528, 6, 70, -1, 0, 1528, 1551, 1, 0, 0, 0, 1529, 1530, 5, 260, 0, 0, 1530, 1551, 6, 70, -1, 0, 1531, 1532, 5, 262, 0, 0, 1532, 1551, 6, 70, -1, 0, 1533, 1534, 5, 92, 0, 0, 1534, 1551, 6, 70, -1, 0, 1535, 1536, 5, 93, 0, 0, 1536, 1537, 5, 30, 0, 0, 1537, 1538, 3, 124, 62, 0, 1538, 1539, 5, 31, 0, 0, 1539, 1540, 6, 70, -1, 0, 1540, 1551, 1, 0, 0, 0, 1541, 1542, 5, 94, 0, 0, 1542, 1543, 5, 30, 0, 0, 1543, 1544, 3, 124, 62, 0, 1544, 1545, 5, 31, 0, 0, 1545, 1546, 6, 70, -1, 0, 1546, 1551, 1, 0, 0, 0, 1547, 1548, 3, 108, 54, 0, 1548, 1549, 6, 70, -1, 0, 1549, 1551, 1, 0, 0, 0, 1550, 1521, 1, 0, 0, 0, 1550, 1523, 1, 0, 0, 0, 1550, 1526, 1, 0, 0, 0, 1550, 1529, 1, 0, 0, 0, 1550, 1531, 1, 0, 0, 0, 1550, 1533, 1, 0, 0, 0, 1550, 1535, 1, 0, 0, 0, 1550, 1541, 1, 0, 0, 0, 1550, 1547, 1, 0, 0, 0, 1551, 141, 1, 0, 0, 0, 1552, 1553, 5, 39, 0, 0, 1553, 1554, 3, 116, 58, 0, 1554, 1555, 6, 71, -1, 0, 1555, 1611, 1, 0, 0, 0, 1556, 1557, 5, 197, 0, 0, 1557, 1611, 6, 71, -1, 0, 1558, 1559, 5, 199, 0, 0, 1559, 1560, 5, 39, 0, 0, 1560, 1561, 3, 116, 58, 0, 1561, 1562, 6, 71, -1, 0, 1562, 1611, 1, 0, 0, 0, 1563, 1564, 5, 200, 0, 0, 1564, 1565, 3, 116, 58, 0, 1565, 1566, 6, 71, -1, 0, 1566, 1611, 1, 0, 0, 0, 1567, 1568, 5, 226, 0, 0, 1568, 1569, 3, 170, 85, 0, 1569, 1570, 3, 138, 69, 0, 1570, 1571, 5, 262, 0, 0, 1571, 1572, 3, 112, 56, 0, 1572, 1573, 6, 71, -1, 0, 1573, 1611, 1, 0, 0, 0, 1574, 1575, 5, 253, 0, 0, 1575, 1576, 3, 32, 16, 0, 1576, 1577, 6, 71, -1, 0, 1577, 1611, 1, 0, 0, 0, 1578, 1579, 5, 252, 0, 0, 1579, 1580, 3, 32, 16, 0, 1580, 1581, 6, 71, -1, 0, 1581, 1611, 1, 0, 0, 0, 1582, 1583, 5, 253, 0, 0, 1583, 1584, 3, 2, 1, 0, 1584, 1585, 6, 71, -1, 0, 1585, 1611, 1, 0, 0, 0, 1586, 1587, 5, 252, 0, 0, 1587, 1588, 3, 2, 1, 0, 1588, 1589, 6, 71, -1, 0, 1589, 1611, 1, 0, 0, 0, 1590, 1591, 5, 254, 0, 0, 1591, 1611, 6, 71, -1, 0, 1592, 1593, 5, 201, 0, 0, 1593, 1611, 6, 71, -1, 0, 1594, 1595, 3, 148, 74, 0, 1595, 1596, 6, 71, -1, 0, 1596, 1611, 1, 0, 0, 0, 1597, 1598, 3, 150, 75, 0, 1598, 1599, 6, 71, -1, 0, 1599, 1611, 1, 0, 0, 0, 1600, 1601, 3, 144, 72, 0, 1601, 1602, 6, 71, -1, 0, 1602, 1611, 1, 0, 0, 0, 1603, 1604, 3, 2, 1, 0, 1604, 1605, 6, 71, -1, 0, 1605, 1611, 1, 0, 0, 0, 1606, 1607, 5, 177, 0, 0, 1607, 1608, 3, 138, 69, 0, 1608, 1609, 6, 71, -1, 0, 1609, 1611, 1, 0, 0, 0, 1610, 1552, 1, 0, 0, 0, 1610, 1556, 1, 0, 0, 0, 1610, 1558, 1, 0, 0, 0, 1610, 1563, 1, 0, 0, 0, 1610, 1567, 1, 0, 0, 0, 1610, 1574, 1, 0, 0, 0, 1610, 1578, 1, 0, 0, 0, 1610, 1582, 1, 0, 0, 0, 1610, 1586, 1, 0, 0, 0, 1610, 1590, 1, 0, 0, 0, 1610, 1592, 1, 0, 0, 0, 1610, 1594, 1, 0, 0, 0, 1610, 1597, 1, 0, 0, 0, 1610, 1600, 1, 0, 0, 0, 1610, 1603, 1, 0, 0, 0, 1610, 1606, 1, 0, 0, 0, 1611, 143, 1, 0, 0, 0, 1612, 1613, 5, 181, 0, 0, 1613, 1651, 6, 72, -1, 0, 1614, 1615, 5, 182, 0, 0, 1615, 1651, 6, 72, -1, 0, 1616, 1617, 5, 183, 0, 0, 1617, 1651, 6, 72, -1, 0, 1618, 1619, 5, 184, 0, 0, 1619, 1651, 6, 72, -1, 0, 1620, 1621, 5, 185, 0, 0, 1621, 1651, 6, 72, -1, 0, 1622, 1623, 5, 186, 0, 0, 1623, 1651, 6, 72, -1, 0, 1624, 1625, 5, 187, 0, 0, 1625, 1651, 6, 72, -1, 0, 1626, 1627, 5, 188, 0, 0, 1627, 1651, 6, 72, -1, 0, 1628, 1629, 5, 189, 0, 0, 1629, 1651, 6, 72, -1, 0, 1630, 1631, 5, 190, 0, 0, 1631, 1651, 6, 72, -1, 0, 1632, 1633, 5, 191, 0, 0, 1633, 1651, 6, 72, -1, 0, 1634, 1635, 5, 192, 0, 0, 1635, 1651, 6, 72, -1, 0, 1636, 1637, 5, 193, 0, 0, 1637, 1651, 6, 72, -1, 0, 1638, 1639, 5, 90, 0, 0, 1639, 1640, 5, 184, 0, 0, 1640, 1651, 6, 72, -1, 0, 1641, 1642, 5, 90, 0, 0, 1642, 1643, 5, 185, 0, 0, 1643, 1651, 6, 72, -1, 0, 1644, 1645, 5, 90, 0, 0, 1645, 1646, 5, 186, 0, 0, 1646, 1651, 6, 72, -1, 0, 1647, 1648, 5, 90, 0, 0, 1648, 1649, 5, 187, 0, 0, 1649, 1651, 6, 72, -1, 0, 1650, 1612, 1, 0, 0, 0, 1650, 1614, 1, 0, 0, 0, 1650, 1616, 1, 0, 0, 0, 1650, 1618, 1, 0, 0, 0, 1650, 1620, 1, 0, 0, 0, 1650, 1622, 1, 0, 0, 0, 1650, 1624, 1, 0, 0, 0, 1650, 1626, 1, 0, 0, 0, 1650, 1628, 1, 0, 0, 0, 1650, 1630, 1, 0, 0, 0, 1650, 1632, 1, 0, 0, 0, 1650, 1634, 1, 0, 0, 0, 1650, 1636, 1, 0, 0, 0, 1650, 1638, 1, 0, 0, 0, 1650, 1641, 1, 0, 0, 0, 1650, 1644, 1, 0, 0, 0, 1650, 1647, 1, 0, 0, 0, 1651, 145, 1, 0, 0, 0, 1652, 1667, 1, 0, 0, 0, 1653, 1667, 5, 177, 0, 0, 1654, 1655, 3, 32, 16, 0, 1655, 1656, 6, 73, -1, 0, 1656, 1667, 1, 0, 0, 0, 1657, 1658, 3, 32, 16, 0, 1658, 1659, 5, 177, 0, 0, 1659, 1660, 3, 32, 16, 0, 1660, 1661, 6, 73, -1, 0, 1661, 1667, 1, 0, 0, 0, 1662, 1663, 3, 32, 16, 0, 1663, 1664, 5, 177, 0, 0, 1664, 1665, 6, 73, -1, 0, 1665, 1667, 1, 0, 0, 0, 1666, 1652, 1, 0, 0, 0, 1666, 1653, 1, 0, 0, 0, 1666, 1654, 1, 0, 0, 0, 1666, 1657, 1, 0, 0, 0, 1666, 1662, 1, 0, 0, 0, 1667, 147, 1, 0, 0, 0, 1668, 1669, 5, 1, 0, 0, 1669, 1670, 5, 194, 0, 0, 1670, 1671, 6, 74, -1, 0, 1671, 149, 1, 0, 0, 0, 1672, 1676, 5, 1, 0, 0, 1673, 1674, 5, 90, 0, 0, 1674, 1677, 5, 194, 0, 0, 1675, 1677, 5, 195, 0, 0, 1676, 1673, 1, 0, 0, 0, 1676, 1675, 1, 0, 0, 0, 1677, 1678, 1, 0, 0, 0, 1678, 1679, 6, 75, -1, 0, 1679, 151, 1, 0, 0, 0, 1680, 1681, 5, 294, 0, 0, 1681, 1682, 3, 166, 83, 0, 1682, 1683, 3, 124, 62, 0, 1683, 1684, 5, 30, 0, 0, 1684, 1685, 3, 158, 79, 0, 1685, 1686, 5, 31, 0, 0, 1686, 1728, 1, 0, 0, 0, 1687, 1688, 5, 294, 0, 0, 1688, 1689, 3, 166, 83, 0, 1689, 1690, 3, 124, 62, 0, 1690, 1691, 5, 36, 0, 0, 1691, 1692, 5, 17, 0, 0, 1692, 1693, 3, 52, 26, 0, 1693, 1694, 5, 18, 0, 0, 1694, 1728, 1, 0, 0, 0, 1695, 1696, 5, 294, 0, 0, 1696, 1697, 3, 166, 83, 0, 1697, 1698, 3, 124, 62, 0, 1698, 1728, 1, 0, 0, 0, 1699, 1700, 5, 295, 0, 0, 1700, 1701, 3, 166, 83, 0, 1701, 1703, 5, 36, 0, 0, 1702, 1704, 5, 84, 0, 0, 1703, 1702, 1, 0, 0, 0, 1703, 1704, 1, 0, 0, 0, 1704, 1705, 1, 0, 0, 0, 1705, 1706, 5, 30, 0, 0, 1706, 1707, 3, 292, 146, 0, 1707, 1708, 5, 31, 0, 0, 1708, 1728, 1, 0, 0, 0, 1709, 1710, 5, 295, 0, 0, 1710, 1711, 3, 166, 83, 0, 1711, 1712, 5, 84, 0, 0, 1712, 1713, 5, 30, 0, 0, 1713, 1714, 3, 292, 146, 0, 1714, 1715, 5, 31, 0, 0, 1715, 1728, 1, 0, 0, 0, 1716, 1717, 5, 295, 0, 0, 1717, 1718, 3, 166, 83, 0, 1718, 1719, 3, 6, 3, 0, 1719, 1728, 1, 0, 0, 0, 1720, 1721, 5, 295, 0, 0, 1721, 1722, 3, 166, 83, 0, 1722, 1723, 5, 36, 0, 0, 1723, 1724, 5, 17, 0, 0, 1724, 1725, 3, 154, 77, 0, 1725, 1726, 5, 18, 0, 0, 1726, 1728, 1, 0, 0, 0, 1727, 1680, 1, 0, 0, 0, 1727, 1687, 1, 0, 0, 0, 1727, 1695, 1, 0, 0, 0, 1727, 1699, 1, 0, 0, 0, 1727, 1709, 1, 0, 0, 0, 1727, 1716, 1, 0, 0, 0, 1727, 1720, 1, 0, 0, 0, 1728, 153, 1, 0, 0, 0, 1729, 1740, 1, 0, 0, 0, 1730, 1731, 3, 156, 78, 0, 1731, 1732, 5, 28, 0, 0, 1732, 1734, 1, 0, 0, 0, 1733, 1730, 1, 0, 0, 0, 1734, 1737, 1, 0, 0, 0, 1735, 1733, 1, 0, 0, 0, 1735, 1736, 1, 0, 0, 0, 1736, 1738, 1, 0, 0, 0, 1737, 1735, 1, 0, 0, 0, 1738, 1740, 3, 156, 78, 0, 1739, 1729, 1, 0, 0, 0, 1739, 1735, 1, 0, 0, 0, 1740, 155, 1, 0, 0, 0, 1741, 1742, 5, 39, 0, 0, 1742, 1743, 5, 264, 0, 0, 1743, 1744, 5, 36, 0, 0, 1744, 1745, 5, 17, 0, 0, 1745, 1746, 3, 56, 28, 0, 1746, 1747, 5, 18, 0, 0, 1747, 1755, 1, 0, 0, 0, 1748, 1749, 3, 124, 62, 0, 1749, 1750, 5, 36, 0, 0, 1750, 1751, 5, 17, 0, 0, 1751, 1752, 3, 56, 28, 0, 1752, 1753, 5, 18, 0, 0, 1753, 1755, 1, 0, 0, 0, 1754, 1741, 1, 0, 0, 0, 1754, 1748, 1, 0, 0, 0, 1755, 157, 1, 0, 0, 0, 1756, 1757, 3, 160, 80, 0, 1757, 1758, 5, 28, 0, 0, 1758, 1760, 1, 0, 0, 0, 1759, 1756, 1, 0, 0, 0, 1760, 1763, 1, 0, 0, 0, 1761, 1759, 1, 0, 0, 0, 1761, 1762, 1, 0, 0, 0, 1762, 1764, 1, 0, 0, 0, 1763, 1761, 1, 0, 0, 0, 1764, 1765, 3, 160, 80, 0, 1765, 159, 1, 0, 0, 0, 1766, 1767, 3, 6, 3, 0, 1767, 1768, 5, 36, 0, 0, 1768, 1769, 3, 164, 82, 0, 1769, 161, 1, 0, 0, 0, 1770, 1771, 7, 8, 0, 0, 1771, 163, 1, 0, 0, 0, 1772, 1807, 3, 162, 81, 0, 1773, 1807, 3, 32, 16, 0, 1774, 1775, 5, 186, 0, 0, 1775, 1776, 5, 30, 0, 0, 1776, 1777, 3, 32, 16, 0, 1777, 1778, 5, 31, 0, 0, 1778, 1807, 1, 0, 0, 0, 1779, 1807, 3, 6, 3, 0, 1780, 1781, 3, 116, 58, 0, 1781, 1782, 5, 30, 0, 0, 1782, 1783, 5, 184, 0, 0, 1783, 1784, 5, 75, 0, 0, 1784, 1785, 3, 32, 16, 0, 1785, 1786, 5, 31, 0, 0, 1786, 1807, 1, 0, 0, 0, 1787, 1788, 3, 116, 58, 0, 1788, 1789, 5, 30, 0, 0, 1789, 1790, 5, 185, 0, 0, 1790, 1791, 5, 75, 0, 0, 1791, 1792, 3, 32, 16, 0, 1792, 1793, 5, 31, 0, 0, 1793, 1807, 1, 0, 0, 0, 1794, 1795, 3, 116, 58, 0, 1795, 1796, 5, 30, 0, 0, 1796, 1797, 5, 186, 0, 0, 1797, 1798, 5, 75, 0, 0, 1798, 1799, 3, 32, 16, 0, 1799, 1800, 5, 31, 0, 0, 1800, 1807, 1, 0, 0, 0, 1801, 1802, 3, 116, 58, 0, 1802, 1803, 5, 30, 0, 0, 1803, 1804, 3, 32, 16, 0, 1804, 1805, 5, 31, 0, 0, 1805, 1807, 1, 0, 0, 0, 1806, 1772, 1, 0, 0, 0, 1806, 1773, 1, 0, 0, 0, 1806, 1774, 1, 0, 0, 0, 1806, 1779, 1, 0, 0, 0, 1806, 1780, 1, 0, 0, 0, 1806, 1787, 1, 0, 0, 0, 1806, 1794, 1, 0, 0, 0, 1806, 1801, 1, 0, 0, 0, 1807, 165, 1, 0, 0, 0, 1808, 1809, 7, 9, 0, 0, 1809, 167, 1, 0, 0, 0, 1810, 1811, 3, 170, 85, 0, 1811, 1812, 3, 138, 69, 0, 1812, 1813, 3, 124, 62, 0, 1813, 1814, 5, 176, 0, 0, 1814, 1816, 3, 242, 121, 0, 1815, 1817, 3, 108, 54, 0, 1816, 1815, 1, 0, 0, 0, 1816, 1817, 1, 0, 0, 0, 1817, 1818, 1, 0, 0, 0, 1818, 1819, 3, 112, 56, 0, 1819, 1820, 6, 84, -1, 0, 1820, 1853, 1, 0, 0, 0, 1821, 1822, 3, 170, 85, 0, 1822, 1823, 3, 138, 69, 0, 1823, 1824, 3, 124, 62, 0, 1824, 1825, 5, 176, 0, 0, 1825, 1826, 3, 242, 121, 0, 1826, 1827, 3, 196, 98, 0, 1827, 1828, 3, 112, 56, 0, 1828, 1829, 6, 84, -1, 0, 1829, 1853, 1, 0, 0, 0, 1830, 1831, 3, 170, 85, 0, 1831, 1832, 3, 138, 69, 0, 1832, 1834, 3, 242, 121, 0, 1833, 1835, 3, 108, 54, 0, 1834, 1833, 1, 0, 0, 0, 1834, 1835, 1, 0, 0, 0, 1835, 1836, 1, 0, 0, 0, 1836, 1837, 3, 112, 56, 0, 1837, 1838, 6, 84, -1, 0, 1838, 1853, 1, 0, 0, 0, 1839, 1840, 3, 170, 85, 0, 1840, 1841, 3, 138, 69, 0, 1841, 1842, 3, 242, 121, 0, 1842, 1843, 3, 196, 98, 0, 1843, 1844, 3, 112, 56, 0, 1844, 1845, 6, 84, -1, 0, 1845, 1853, 1, 0, 0, 0, 1846, 1847, 3, 174, 87, 0, 1847, 1848, 6, 84, -1, 0, 1848, 1853, 1, 0, 0, 0, 1849, 1850, 3, 2, 1, 0, 1850, 1851, 6, 84, -1, 0, 1851, 1853, 1, 0, 0, 0, 1852, 1810, 1, 0, 0, 0, 1852, 1821, 1, 0, 0, 0, 1852, 1830, 1, 0, 0, 0, 1852, 1839, 1, 0, 0, 0, 1852, 1846, 1, 0, 0, 0, 1852, 1849, 1, 0, 0, 0, 1853, 169, 1, 0, 0, 0, 1854, 1855, 5, 243, 0, 0, 1855, 1856, 3, 170, 85, 0, 1856, 1857, 6, 85, -1, 0, 1857, 1872, 1, 0, 0, 0, 1858, 1859, 5, 244, 0, 0, 1859, 1860, 3, 170, 85, 0, 1860, 1861, 6, 85, -1, 0, 1861, 1872, 1, 0, 0, 0, 1862, 1863, 3, 172, 86, 0, 1863, 1864, 6, 85, -1, 0, 1864, 1872, 1, 0, 0, 0, 1865, 1866, 5, 112, 0, 0, 1866, 1867, 5, 30, 0, 0, 1867, 1868, 3, 32, 16, 0, 1868, 1869, 5, 31, 0, 0, 1869, 1870, 6, 85, -1, 0, 1870, 1872, 1, 0, 0, 0, 1871, 1854, 1, 0, 0, 0, 1871, 1858, 1, 0, 0, 0, 1871, 1862, 1, 0, 0, 0, 1871, 1865, 1, 0, 0, 0, 1872, 171, 1, 0, 0, 0, 1873, 1893, 1, 0, 0, 0, 1874, 1875, 5, 245, 0, 0, 1875, 1893, 6, 86, -1, 0, 1876, 1877, 5, 246, 0, 0, 1877, 1893, 6, 86, -1, 0, 1878, 1879, 5, 247, 0, 0, 1879, 1880, 5, 248, 0, 0, 1880, 1893, 6, 86, -1, 0, 1881, 1882, 5, 247, 0, 0, 1882, 1883, 5, 249, 0, 0, 1883, 1893, 6, 86, -1, 0, 1884, 1885, 5, 247, 0, 0, 1885, 1886, 5, 250, 0, 0, 1886, 1893, 6, 86, -1, 0, 1887, 1888, 5, 247, 0, 0, 1888, 1889, 5, 251, 0, 0, 1889, 1893, 6, 86, -1, 0, 1890, 1891, 5, 247, 0, 0, 1891, 1893, 6, 86, -1, 0, 1892, 1873, 1, 0, 0, 0, 1892, 1874, 1, 0, 0, 0, 1892, 1876, 1, 0, 0, 0, 1892, 1878, 1, 0, 0, 0, 1892, 1881, 1, 0, 0, 0, 1892, 1884, 1, 0, 0, 0, 1892, 1887, 1, 0, 0, 0, 1892, 1890, 1, 0, 0, 0, 1893, 173, 1, 0, 0, 0, 1894, 1895, 5, 113, 0, 0, 1895, 1896, 5, 30, 0, 0, 1896, 1897, 3, 32, 16, 0, 1897, 1898, 5, 31, 0, 0, 1898, 1899, 6, 87, -1, 0, 1899, 175, 1, 0, 0, 0, 1900, 1901, 5, 226, 0, 0, 1901, 1902, 3, 168, 84, 0, 1902, 1903, 6, 88, -1, 0, 1903, 1912, 1, 0, 0, 0, 1904, 1905, 5, 37, 0, 0, 1905, 1906, 3, 178, 89, 0, 1906, 1907, 6, 88, -1, 0, 1907, 1912, 1, 0, 0, 0, 1908, 1909, 3, 174, 87, 0, 1909, 1910, 6, 88, -1, 0, 1910, 1912, 1, 0, 0, 0, 1911, 1900, 1, 0, 0, 0, 1911, 1904, 1, 0, 0, 0, 1911, 1908, 1, 0, 0, 0, 1912, 177, 1, 0, 0, 0, 1913, 1914, 3, 138, 69, 0, 1914, 1915, 3, 124, 62, 0, 1915, 1916, 5, 176, 0, 0, 1916, 1917, 3, 2, 1, 0, 1917, 1918, 6, 89, -1, 0, 1918, 1927, 1, 0, 0, 0, 1919, 1920, 3, 138, 69, 0, 1920, 1921, 3, 2, 1, 0, 1921, 1922, 6, 89, -1, 0, 1922, 1927, 1, 0, 0, 0, 1923, 1924, 3, 2, 1, 0, 1924, 1925, 6, 89, -1, 0, 1925, 1927, 1, 0, 0, 0, 1926, 1913, 1, 0, 0, 0, 1926, 1919, 1, 0, 0, 0, 1926, 1923, 1, 0, 0, 0, 1927, 179, 1, 0, 0, 0, 1928, 1929, 3, 124, 62, 0, 1929, 1930, 5, 28, 0, 0, 1930, 1932, 1, 0, 0, 0, 1931, 1928, 1, 0, 0, 0, 1932, 1935, 1, 0, 0, 0, 1933, 1931, 1, 0, 0, 0, 1933, 1934, 1, 0, 0, 0, 1934, 1936, 1, 0, 0, 0, 1935, 1933, 1, 0, 0, 0, 1936, 1937, 3, 124, 62, 0, 1937, 181, 1, 0, 0, 0, 1938, 1944, 1, 0, 0, 0, 1939, 1940, 5, 86, 0, 0, 1940, 1941, 3, 190, 95, 0, 1941, 1942, 5, 87, 0, 0, 1942, 1944, 1, 0, 0, 0, 1943, 1938, 1, 0, 0, 0, 1943, 1939, 1, 0, 0, 0, 1944, 183, 1, 0, 0, 0, 1945, 1957, 5, 266, 0, 0, 1946, 1957, 5, 114, 0, 0, 1947, 1957, 5, 39, 0, 0, 1948, 1957, 5, 200, 0, 0, 1949, 1957, 5, 115, 0, 0, 1950, 1957, 5, 116, 0, 0, 1951, 1952, 5, 70, 0, 0, 1952, 1953, 5, 30, 0, 0, 1953, 1954, 3, 32, 16, 0, 1954, 1955, 5, 31, 0, 0, 1955, 1957, 1, 0, 0, 0, 1956, 1945, 1, 0, 0, 0, 1956, 1946, 1, 0, 0, 0, 1956, 1947, 1, 0, 0, 0, 1956, 1948, 1, 0, 0, 0, 1956, 1949, 1, 0, 0, 0, 1956, 1950, 1, 0, 0, 0, 1956, 1951, 1, 0, 0, 0, 1957, 185, 1, 0, 0, 0, 1958, 1960, 3, 184, 92, 0, 1959, 1958, 1, 0, 0, 0, 1960, 1963, 1, 0, 0, 0, 1961, 1959, 1, 0, 0, 0, 1961, 1962, 1, 0, 0, 0, 1962, 187, 1, 0, 0, 0, 1963, 1961, 1, 0, 0, 0, 1964, 1966, 3, 186, 93, 0, 1965, 1967, 3, 192, 96, 0, 1966, 1965, 1, 0, 0, 0, 1966, 1967, 1, 0, 0, 0, 1967, 1968, 1, 0, 0, 0, 1968, 1969, 3, 2, 1, 0, 1969, 189, 1, 0, 0, 0, 1970, 1971, 3, 188, 94, 0, 1971, 1972, 5, 28, 0, 0, 1972, 1974, 1, 0, 0, 0, 1973, 1970, 1, 0, 0, 0, 1974, 1977, 1, 0, 0, 0, 1975, 1973, 1, 0, 0, 0, 1975, 1976, 1, 0, 0, 0, 1976, 1978, 1, 0, 0, 0, 1977, 1975, 1, 0, 0, 0, 1978, 1979, 3, 188, 94, 0, 1979, 191, 1, 0, 0, 0, 1980, 1981, 5, 30, 0, 0, 1981, 1982, 3, 180, 90, 0, 1982, 1983, 5, 31, 0, 0, 1983, 193, 1, 0, 0, 0, 1984, 1986, 3, 196, 98, 0, 1985, 1984, 1, 0, 0, 0, 1985, 1986, 1, 0, 0, 0, 1986, 1987, 1, 0, 0, 0, 1987, 1988, 6, 97, -1, 0, 1988, 195, 1, 0, 0, 0, 1989, 1990, 5, 86, 0, 0, 1990, 1991, 5, 42, 0, 0, 1991, 1992, 3, 32, 16, 0, 1992, 1993, 5, 43, 0, 0, 1993, 1994, 5, 87, 0, 0, 1994, 1995, 6, 98, -1, 0, 1995, 197, 1, 0, 0, 0, 1996, 1997, 3, 234, 117, 0, 1997, 1998, 5, 17, 0, 0, 1998, 1999, 3, 246, 123, 0, 1999, 2000, 5, 18, 0, 0, 2000, 2113, 1, 0, 0, 0, 2001, 2002, 3, 74, 37, 0, 2002, 2003, 5, 17, 0, 0, 2003, 2004, 3, 82, 41, 0, 2004, 2005, 5, 18, 0, 0, 2005, 2113, 1, 0, 0, 0, 2006, 2007, 3, 210, 105, 0, 2007, 2008, 5, 17, 0, 0, 2008, 2009, 3, 214, 107, 0, 2009, 2010, 5, 18, 0, 0, 2010, 2113, 1, 0, 0, 0, 2011, 2012, 3, 218, 109, 0, 2012, 2013, 5, 17, 0, 0, 2013, 2014, 3, 222, 111, 0, 2014, 2015, 5, 18, 0, 0, 2015, 2113, 1, 0, 0, 0, 2016, 2113, 3, 200, 100, 0, 2017, 2113, 3, 276, 138, 0, 2018, 2113, 3, 152, 76, 0, 2019, 2113, 3, 88, 44, 0, 2020, 2113, 3, 322, 161, 0, 2021, 2022, 5, 117, 0, 0, 2022, 2113, 3, 32, 16, 0, 2023, 2024, 5, 118, 0, 0, 2024, 2113, 3, 32, 16, 0, 2025, 2026, 3, 334, 167, 0, 2026, 2027, 5, 17, 0, 0, 2027, 2028, 3, 338, 169, 0, 2028, 2029, 5, 18, 0, 0, 2029, 2113, 1, 0, 0, 0, 2030, 2031, 5, 302, 0, 0, 2031, 2032, 3, 124, 62, 0, 2032, 2033, 5, 176, 0, 0, 2033, 2034, 3, 242, 121, 0, 2034, 2035, 5, 119, 0, 0, 2035, 2036, 3, 170, 85, 0, 2036, 2037, 3, 138, 69, 0, 2037, 2038, 3, 124, 62, 0, 2038, 2039, 5, 176, 0, 0, 2039, 2040, 3, 242, 121, 0, 2040, 2041, 3, 112, 56, 0, 2041, 2113, 1, 0, 0, 0, 2042, 2043, 5, 302, 0, 0, 2043, 2044, 5, 226, 0, 0, 2044, 2045, 3, 170, 85, 0, 2045, 2046, 3, 138, 69, 0, 2046, 2047, 3, 124, 62, 0, 2047, 2048, 5, 176, 0, 0, 2048, 2049, 3, 242, 121, 0, 2049, 2050, 3, 194, 97, 0, 2050, 2051, 3, 112, 56, 0, 2051, 2052, 5, 119, 0, 0, 2052, 2053, 5, 226, 0, 0, 2053, 2054, 3, 170, 85, 0, 2054, 2055, 3, 138, 69, 0, 2055, 2056, 3, 124, 62, 0, 2056, 2057, 5, 176, 0, 0, 2057, 2058, 3, 242, 121, 0, 2058, 2059, 3, 194, 97, 0, 2059, 2060, 3, 112, 56, 0, 2060, 2113, 1, 0, 0, 0, 2061, 2113, 3, 26, 13, 0, 2062, 2113, 3, 40, 20, 0, 2063, 2064, 5, 255, 0, 0, 2064, 2065, 5, 196, 0, 0, 2065, 2066, 5, 42, 0, 0, 2066, 2067, 3, 32, 16, 0, 2067, 2071, 5, 43, 0, 0, 2068, 2070, 3, 322, 161, 0, 2069, 2068, 1, 0, 0, 0, 2070, 2073, 1, 0, 0, 0, 2071, 2069, 1, 0, 0, 0, 2071, 2072, 1, 0, 0, 0, 2072, 2113, 1, 0, 0, 0, 2073, 2071, 1, 0, 0, 0, 2074, 2075, 5, 255, 0, 0, 2075, 2076, 5, 196, 0, 0, 2076, 2080, 3, 2, 1, 0, 2077, 2079, 3, 322, 161, 0, 2078, 2077, 1, 0, 0, 0, 2079, 2082, 1, 0, 0, 0, 2080, 2078, 1, 0, 0, 0, 2080, 2081, 1, 0, 0, 0, 2081, 2113, 1, 0, 0, 0, 2082, 2080, 1, 0, 0, 0, 2083, 2084, 5, 255, 0, 0, 2084, 2085, 5, 256, 0, 0, 2085, 2086, 5, 42, 0, 0, 2086, 2087, 3, 32, 16, 0, 2087, 2088, 5, 43, 0, 0, 2088, 2089, 5, 28, 0, 0, 2089, 2093, 3, 124, 62, 0, 2090, 2092, 3, 322, 161, 0, 2091, 2090, 1, 0, 0, 0, 2092, 2095, 1, 0, 0, 0, 2093, 2091, 1, 0, 0, 0, 2093, 2094, 1, 0, 0, 0, 2094, 2113, 1, 0, 0, 0, 2095, 2093, 1, 0, 0, 0, 2096, 2097, 5, 255, 0, 0, 2097, 2098, 5, 256, 0, 0, 2098, 2099, 3, 2, 1, 0, 2099, 2100, 5, 28, 0, 0, 2100, 2104, 3, 124, 62, 0, 2101, 2103, 3, 322, 161, 0, 2102, 2101, 1, 0, 0, 0, 2103, 2106, 1, 0, 0, 0, 2104, 2102, 1, 0, 0, 0, 2104, 2105, 1, 0, 0, 0, 2105, 2113, 1, 0, 0, 0, 2106, 2104, 1, 0, 0, 0, 2107, 2108, 5, 120, 0, 0, 2108, 2109, 5, 196, 0, 0, 2109, 2110, 3, 124, 62, 0, 2110, 2111, 3, 44, 22, 0, 2111, 2113, 1, 0, 0, 0, 2112, 1996, 1, 0, 0, 0, 2112, 2001, 1, 0, 0, 0, 2112, 2006, 1, 0, 0, 0, 2112, 2011, 1, 0, 0, 0, 2112, 2016, 1, 0, 0, 0, 2112, 2017, 1, 0, 0, 0, 2112, 2018, 1, 0, 0, 0, 2112, 2019, 1, 0, 0, 0, 2112, 2020, 1, 0, 0, 0, 2112, 2021, 1, 0, 0, 0, 2112, 2023, 1, 0, 0, 0, 2112, 2025, 1, 0, 0, 0, 2112, 2030, 1, 0, 0, 0, 2112, 2042, 1, 0, 0, 0, 2112, 2061, 1, 0, 0, 0, 2112, 2062, 1, 0, 0, 0, 2112, 2063, 1, 0, 0, 0, 2112, 2074, 1, 0, 0, 0, 2112, 2083, 1, 0, 0, 0, 2112, 2096, 1, 0, 0, 0, 2112, 2107, 1, 0, 0, 0, 2113, 199, 1, 0, 0, 0, 2114, 2115, 5, 121, 0, 0, 2115, 2124, 3, 208, 104, 0, 2116, 2123, 3, 202, 101, 0, 2117, 2118, 5, 122, 0, 0, 2118, 2119, 5, 30, 0, 0, 2119, 2120, 3, 228, 114, 0, 2120, 2121, 5, 31, 0, 0, 2121, 2123, 1, 0, 0, 0, 2122, 2116, 1, 0, 0, 0, 2122, 2117, 1, 0, 0, 0, 2123, 2126, 1, 0, 0, 0, 2124, 2122, 1, 0, 0, 0, 2124, 2125, 1, 0, 0, 0, 2125, 2127, 1, 0, 0, 0, 2126, 2124, 1, 0, 0, 0, 2127, 2128, 3, 138, 69, 0, 2128, 2129, 3, 2, 1, 0, 2129, 2130, 3, 204, 102, 0, 2130, 2131, 3, 206, 103, 0, 2131, 201, 1, 0, 0, 0, 2132, 2152, 5, 123, 0, 0, 2133, 2152, 5, 51, 0, 0, 2134, 2152, 5, 52, 0, 0, 2135, 2152, 5, 63, 0, 0, 2136, 2152, 5, 124, 0, 0, 2137, 2152, 5, 69, 0, 0, 2138, 2152, 5, 68, 0, 0, 2139, 2152, 5, 64, 0, 0, 2140, 2152, 5, 65, 0, 0, 2141, 2152, 5, 66, 0, 0, 2142, 2152, 5, 125, 0, 0, 2143, 2152, 5, 126, 0, 0, 2144, 2152, 5, 127, 0, 0, 2145, 2152, 5, 16, 0, 0, 2146, 2147, 5, 70, 0, 0, 2147, 2148, 5, 30, 0, 0, 2148, 2149, 3, 32, 16, 0, 2149, 2150, 5, 31, 0, 0, 2150, 2152, 1, 0, 0, 0, 2151, 2132, 1, 0, 0, 0, 2151, 2133, 1, 0, 0, 0, 2151, 2134, 1, 0, 0, 0, 2151, 2135, 1, 0, 0, 0, 2151, 2136, 1, 0, 0, 0, 2151, 2137, 1, 0, 0, 0, 2151, 2138, 1, 0, 0, 0, 2151, 2139, 1, 0, 0, 0, 2151, 2140, 1, 0, 0, 0, 2151, 2141, 1, 0, 0, 0, 2151, 2142, 1, 0, 0, 0, 2151, 2143, 1, 0, 0, 0, 2151, 2144, 1, 0, 0, 0, 2151, 2145, 1, 0, 0, 0, 2151, 2146, 1, 0, 0, 0, 2152, 203, 1, 0, 0, 0, 2153, 2159, 1, 0, 0, 0, 2154, 2155, 5, 44, 0, 0, 2155, 2159, 3, 0, 0, 0, 2156, 2157, 5, 44, 0, 0, 2157, 2159, 3, 32, 16, 0, 2158, 2153, 1, 0, 0, 0, 2158, 2154, 1, 0, 0, 0, 2158, 2156, 1, 0, 0, 0, 2159, 205, 1, 0, 0, 0, 2160, 2164, 1, 0, 0, 0, 2161, 2162, 5, 36, 0, 0, 2162, 2164, 3, 296, 148, 0, 2163, 2160, 1, 0, 0, 0, 2163, 2161, 1, 0, 0, 0, 2164, 207, 1, 0, 0, 0, 2165, 2171, 1, 0, 0, 0, 2166, 2167, 5, 42, 0, 0, 2167, 2168, 3, 32, 16, 0, 2168, 2169, 5, 43, 0, 0, 2169, 2171, 1, 0, 0, 0, 2170, 2165, 1, 0, 0, 0, 2170, 2166, 1, 0, 0, 0, 2171, 209, 1, 0, 0, 0, 2172, 2176, 5, 128, 0, 0, 2173, 2175, 3, 212, 106, 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, 2180, 3, 124, 62, 0, 2180, 2181, 3, 2, 1, 0, 2181, 2191, 1, 0, 0, 0, 2182, 2186, 5, 128, 0, 0, 2183, 2185, 3, 212, 106, 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, 2, 1, 0, 2190, 2172, 1, 0, 0, 0, 2190, 2182, 1, 0, 0, 0, 2191, 211, 1, 0, 0, 0, 2192, 2193, 7, 10, 0, 0, 2193, 213, 1, 0, 0, 0, 2194, 2196, 3, 216, 108, 0, 2195, 2194, 1, 0, 0, 0, 2196, 2199, 1, 0, 0, 0, 2197, 2195, 1, 0, 0, 0, 2197, 2198, 1, 0, 0, 0, 2198, 215, 1, 0, 0, 0, 2199, 2197, 1, 0, 0, 0, 2200, 2201, 5, 129, 0, 0, 2201, 2213, 3, 168, 84, 0, 2202, 2203, 5, 130, 0, 0, 2203, 2213, 3, 168, 84, 0, 2204, 2205, 5, 131, 0, 0, 2205, 2213, 3, 168, 84, 0, 2206, 2207, 5, 132, 0, 0, 2207, 2213, 3, 168, 84, 0, 2208, 2213, 3, 88, 44, 0, 2209, 2213, 3, 322, 161, 0, 2210, 2213, 3, 26, 13, 0, 2211, 2213, 3, 40, 20, 0, 2212, 2200, 1, 0, 0, 0, 2212, 2202, 1, 0, 0, 0, 2212, 2204, 1, 0, 0, 0, 2212, 2206, 1, 0, 0, 0, 2212, 2208, 1, 0, 0, 0, 2212, 2209, 1, 0, 0, 0, 2212, 2210, 1, 0, 0, 0, 2212, 2211, 1, 0, 0, 0, 2213, 217, 1, 0, 0, 0, 2214, 2218, 5, 133, 0, 0, 2215, 2217, 3, 220, 110, 0, 2216, 2215, 1, 0, 0, 0, 2217, 2220, 1, 0, 0, 0, 2218, 2216, 1, 0, 0, 0, 2218, 2219, 1, 0, 0, 0, 2219, 2221, 1, 0, 0, 0, 2220, 2218, 1, 0, 0, 0, 2221, 2222, 3, 170, 85, 0, 2222, 2223, 3, 138, 69, 0, 2223, 2224, 3, 2, 1, 0, 2224, 2225, 3, 112, 56, 0, 2225, 2226, 3, 206, 103, 0, 2226, 219, 1, 0, 0, 0, 2227, 2228, 7, 10, 0, 0, 2228, 221, 1, 0, 0, 0, 2229, 2231, 3, 224, 112, 0, 2230, 2229, 1, 0, 0, 0, 2231, 2234, 1, 0, 0, 0, 2232, 2230, 1, 0, 0, 0, 2232, 2233, 1, 0, 0, 0, 2233, 223, 1, 0, 0, 0, 2234, 2232, 1, 0, 0, 0, 2235, 2236, 5, 134, 0, 0, 2236, 2246, 3, 168, 84, 0, 2237, 2238, 5, 135, 0, 0, 2238, 2246, 3, 168, 84, 0, 2239, 2240, 5, 132, 0, 0, 2240, 2246, 3, 168, 84, 0, 2241, 2246, 3, 322, 161, 0, 2242, 2246, 3, 88, 44, 0, 2243, 2246, 3, 26, 13, 0, 2244, 2246, 3, 40, 20, 0, 2245, 2235, 1, 0, 0, 0, 2245, 2237, 1, 0, 0, 0, 2245, 2239, 1, 0, 0, 0, 2245, 2241, 1, 0, 0, 0, 2245, 2242, 1, 0, 0, 0, 2245, 2243, 1, 0, 0, 0, 2245, 2244, 1, 0, 0, 0, 2246, 225, 1, 0, 0, 0, 2247, 2255, 6, 113, -1, 0, 2248, 2249, 5, 122, 0, 0, 2249, 2250, 5, 30, 0, 0, 2250, 2251, 3, 228, 114, 0, 2251, 2252, 5, 31, 0, 0, 2252, 2253, 6, 113, -1, 0, 2253, 2255, 1, 0, 0, 0, 2254, 2247, 1, 0, 0, 0, 2254, 2248, 1, 0, 0, 0, 2255, 227, 1, 0, 0, 0, 2256, 2257, 3, 126, 63, 0, 2257, 2258, 6, 114, -1, 0, 2258, 2270, 1, 0, 0, 0, 2259, 2263, 5, 17, 0, 0, 2260, 2261, 3, 294, 147, 0, 2261, 2262, 6, 114, -1, 0, 2262, 2264, 1, 0, 0, 0, 2263, 2260, 1, 0, 0, 0, 2264, 2265, 1, 0, 0, 0, 2265, 2263, 1, 0, 0, 0, 2265, 2266, 1, 0, 0, 0, 2266, 2267, 1, 0, 0, 0, 2267, 2268, 5, 18, 0, 0, 2268, 2270, 1, 0, 0, 0, 2269, 2256, 1, 0, 0, 0, 2269, 2259, 1, 0, 0, 0, 2270, 229, 1, 0, 0, 0, 2271, 2272, 3, 232, 116, 0, 2272, 2273, 6, 115, -1, 0, 2273, 2275, 1, 0, 0, 0, 2274, 2271, 1, 0, 0, 0, 2275, 2278, 1, 0, 0, 0, 2276, 2274, 1, 0, 0, 0, 2276, 2277, 1, 0, 0, 0, 2277, 231, 1, 0, 0, 0, 2278, 2276, 1, 0, 0, 0, 2279, 2280, 5, 42, 0, 0, 2280, 2281, 5, 136, 0, 0, 2281, 2282, 5, 43, 0, 0, 2282, 2297, 6, 116, -1, 0, 2283, 2284, 5, 42, 0, 0, 2284, 2285, 5, 137, 0, 0, 2285, 2286, 5, 43, 0, 0, 2286, 2297, 6, 116, -1, 0, 2287, 2288, 5, 42, 0, 0, 2288, 2289, 5, 138, 0, 0, 2289, 2290, 5, 43, 0, 0, 2290, 2297, 6, 116, -1, 0, 2291, 2292, 5, 42, 0, 0, 2292, 2293, 3, 32, 16, 0, 2293, 2294, 5, 43, 0, 0, 2294, 2295, 6, 116, -1, 0, 2295, 2297, 1, 0, 0, 0, 2296, 2279, 1, 0, 0, 0, 2296, 2283, 1, 0, 0, 0, 2296, 2287, 1, 0, 0, 0, 2296, 2291, 1, 0, 0, 0, 2297, 233, 1, 0, 0, 0, 2298, 2303, 5, 139, 0, 0, 2299, 2302, 3, 236, 118, 0, 2300, 2302, 3, 238, 119, 0, 2301, 2299, 1, 0, 0, 0, 2301, 2300, 1, 0, 0, 0, 2302, 2305, 1, 0, 0, 0, 2303, 2301, 1, 0, 0, 0, 2303, 2304, 1, 0, 0, 0, 2304, 2306, 1, 0, 0, 0, 2305, 2303, 1, 0, 0, 0, 2306, 2307, 3, 170, 85, 0, 2307, 2308, 3, 230, 115, 0, 2308, 2309, 3, 138, 69, 0, 2309, 2310, 3, 226, 113, 0, 2310, 2311, 3, 242, 121, 0, 2311, 2312, 3, 182, 91, 0, 2312, 2316, 3, 112, 56, 0, 2313, 2315, 3, 244, 122, 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, 235, 1, 0, 0, 0, 2318, 2316, 1, 0, 0, 0, 2319, 2343, 5, 123, 0, 0, 2320, 2343, 5, 51, 0, 0, 2321, 2343, 5, 52, 0, 0, 2322, 2343, 5, 63, 0, 0, 2323, 2343, 5, 140, 0, 0, 2324, 2343, 5, 68, 0, 0, 2325, 2343, 5, 141, 0, 0, 2326, 2343, 5, 142, 0, 0, 2327, 2343, 5, 54, 0, 0, 2328, 2343, 5, 64, 0, 0, 2329, 2343, 5, 65, 0, 0, 2330, 2343, 5, 66, 0, 0, 2331, 2343, 5, 125, 0, 0, 2332, 2343, 5, 143, 0, 0, 2333, 2343, 5, 144, 0, 0, 2334, 2343, 5, 69, 0, 0, 2335, 2343, 5, 145, 0, 0, 2336, 2343, 5, 146, 0, 0, 2337, 2338, 5, 70, 0, 0, 2338, 2339, 5, 30, 0, 0, 2339, 2340, 3, 32, 16, 0, 2340, 2341, 5, 31, 0, 0, 2341, 2343, 1, 0, 0, 0, 2342, 2319, 1, 0, 0, 0, 2342, 2320, 1, 0, 0, 0, 2342, 2321, 1, 0, 0, 0, 2342, 2322, 1, 0, 0, 0, 2342, 2323, 1, 0, 0, 0, 2342, 2324, 1, 0, 0, 0, 2342, 2325, 1, 0, 0, 0, 2342, 2326, 1, 0, 0, 0, 2342, 2327, 1, 0, 0, 0, 2342, 2328, 1, 0, 0, 0, 2342, 2329, 1, 0, 0, 0, 2342, 2330, 1, 0, 0, 0, 2342, 2331, 1, 0, 0, 0, 2342, 2332, 1, 0, 0, 0, 2342, 2333, 1, 0, 0, 0, 2342, 2334, 1, 0, 0, 0, 2342, 2335, 1, 0, 0, 0, 2342, 2336, 1, 0, 0, 0, 2342, 2337, 1, 0, 0, 0, 2343, 237, 1, 0, 0, 0, 2344, 2345, 5, 147, 0, 0, 2345, 2351, 5, 30, 0, 0, 2346, 2349, 3, 6, 3, 0, 2347, 2348, 5, 34, 0, 0, 2348, 2350, 3, 6, 3, 0, 2349, 2347, 1, 0, 0, 0, 2349, 2350, 1, 0, 0, 0, 2350, 2352, 1, 0, 0, 0, 2351, 2346, 1, 0, 0, 0, 2351, 2352, 1, 0, 0, 0, 2352, 2356, 1, 0, 0, 0, 2353, 2355, 3, 240, 120, 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, 2363, 5, 31, 0, 0, 2360, 2361, 5, 147, 0, 0, 2361, 2363, 5, 85, 0, 0, 2362, 2344, 1, 0, 0, 0, 2362, 2360, 1, 0, 0, 0, 2363, 239, 1, 0, 0, 0, 2364, 2392, 5, 148, 0, 0, 2365, 2392, 5, 224, 0, 0, 2366, 2392, 5, 57, 0, 0, 2367, 2392, 5, 58, 0, 0, 2368, 2392, 5, 149, 0, 0, 2369, 2392, 5, 150, 0, 0, 2370, 2392, 5, 248, 0, 0, 2371, 2392, 5, 249, 0, 0, 2372, 2392, 5, 250, 0, 0, 2373, 2392, 5, 251, 0, 0, 2374, 2375, 5, 151, 0, 0, 2375, 2376, 5, 75, 0, 0, 2376, 2392, 5, 152, 0, 0, 2377, 2378, 5, 151, 0, 0, 2378, 2379, 5, 75, 0, 0, 2379, 2392, 5, 153, 0, 0, 2380, 2381, 5, 154, 0, 0, 2381, 2382, 5, 75, 0, 0, 2382, 2392, 5, 152, 0, 0, 2383, 2384, 5, 154, 0, 0, 2384, 2385, 5, 75, 0, 0, 2385, 2392, 5, 153, 0, 0, 2386, 2387, 5, 70, 0, 0, 2387, 2388, 5, 30, 0, 0, 2388, 2389, 3, 32, 16, 0, 2389, 2390, 5, 31, 0, 0, 2390, 2392, 1, 0, 0, 0, 2391, 2364, 1, 0, 0, 0, 2391, 2365, 1, 0, 0, 0, 2391, 2366, 1, 0, 0, 0, 2391, 2367, 1, 0, 0, 0, 2391, 2368, 1, 0, 0, 0, 2391, 2369, 1, 0, 0, 0, 2391, 2370, 1, 0, 0, 0, 2391, 2371, 1, 0, 0, 0, 2391, 2372, 1, 0, 0, 0, 2391, 2373, 1, 0, 0, 0, 2391, 2374, 1, 0, 0, 0, 2391, 2377, 1, 0, 0, 0, 2391, 2380, 1, 0, 0, 0, 2391, 2383, 1, 0, 0, 0, 2391, 2386, 1, 0, 0, 0, 2392, 241, 1, 0, 0, 0, 2393, 2394, 5, 116, 0, 0, 2394, 2401, 6, 121, -1, 0, 2395, 2396, 5, 155, 0, 0, 2396, 2401, 6, 121, -1, 0, 2397, 2398, 3, 2, 1, 0, 2398, 2399, 6, 121, -1, 0, 2399, 2401, 1, 0, 0, 0, 2400, 2393, 1, 0, 0, 0, 2400, 2395, 1, 0, 0, 0, 2400, 2397, 1, 0, 0, 0, 2401, 243, 1, 0, 0, 0, 2402, 2424, 5, 1, 0, 0, 2403, 2424, 5, 2, 0, 0, 2404, 2424, 5, 156, 0, 0, 2405, 2424, 5, 3, 0, 0, 2406, 2424, 5, 4, 0, 0, 2407, 2424, 5, 247, 0, 0, 2408, 2424, 5, 5, 0, 0, 2409, 2424, 5, 6, 0, 0, 2410, 2424, 5, 7, 0, 0, 2411, 2424, 5, 8, 0, 0, 2412, 2424, 5, 9, 0, 0, 2413, 2424, 5, 10, 0, 0, 2414, 2424, 5, 11, 0, 0, 2415, 2424, 5, 12, 0, 0, 2416, 2424, 5, 13, 0, 0, 2417, 2424, 5, 14, 0, 0, 2418, 2419, 5, 70, 0, 0, 2419, 2420, 5, 30, 0, 0, 2420, 2421, 3, 32, 16, 0, 2421, 2422, 5, 31, 0, 0, 2422, 2424, 1, 0, 0, 0, 2423, 2402, 1, 0, 0, 0, 2423, 2403, 1, 0, 0, 0, 2423, 2404, 1, 0, 0, 0, 2423, 2405, 1, 0, 0, 0, 2423, 2406, 1, 0, 0, 0, 2423, 2407, 1, 0, 0, 0, 2423, 2408, 1, 0, 0, 0, 2423, 2409, 1, 0, 0, 0, 2423, 2410, 1, 0, 0, 0, 2423, 2411, 1, 0, 0, 0, 2423, 2412, 1, 0, 0, 0, 2423, 2413, 1, 0, 0, 0, 2423, 2414, 1, 0, 0, 0, 2423, 2415, 1, 0, 0, 0, 2423, 2416, 1, 0, 0, 0, 2423, 2417, 1, 0, 0, 0, 2423, 2418, 1, 0, 0, 0, 2424, 245, 1, 0, 0, 0, 2425, 2427, 3, 248, 124, 0, 2426, 2425, 1, 0, 0, 0, 2427, 2430, 1, 0, 0, 0, 2428, 2426, 1, 0, 0, 0, 2428, 2429, 1, 0, 0, 0, 2429, 247, 1, 0, 0, 0, 2430, 2428, 1, 0, 0, 0, 2431, 2449, 3, 100, 50, 0, 2432, 2433, 5, 296, 0, 0, 2433, 2434, 3, 32, 16, 0, 2434, 2435, 6, 124, -1, 0, 2435, 2449, 1, 0, 0, 0, 2436, 2449, 3, 258, 129, 0, 2437, 2438, 5, 297, 0, 0, 2438, 2439, 3, 32, 16, 0, 2439, 2440, 6, 124, -1, 0, 2440, 2449, 1, 0, 0, 0, 2441, 2442, 5, 298, 0, 0, 2442, 2449, 6, 124, -1, 0, 2443, 2444, 5, 299, 0, 0, 2444, 2449, 6, 124, -1, 0, 2445, 2449, 3, 252, 126, 0, 2446, 2449, 3, 256, 128, 0, 2447, 2449, 3, 250, 125, 0, 2448, 2431, 1, 0, 0, 0, 2448, 2432, 1, 0, 0, 0, 2448, 2436, 1, 0, 0, 0, 2448, 2437, 1, 0, 0, 0, 2448, 2441, 1, 0, 0, 0, 2448, 2443, 1, 0, 0, 0, 2448, 2445, 1, 0, 0, 0, 2448, 2446, 1, 0, 0, 0, 2448, 2447, 1, 0, 0, 0, 2449, 249, 1, 0, 0, 0, 2450, 2451, 5, 300, 0, 0, 2451, 2549, 3, 112, 56, 0, 2452, 2453, 5, 300, 0, 0, 2453, 2454, 5, 157, 0, 0, 2454, 2549, 3, 112, 56, 0, 2455, 2549, 3, 276, 138, 0, 2456, 2549, 3, 152, 76, 0, 2457, 2549, 3, 88, 44, 0, 2458, 2549, 3, 26, 13, 0, 2459, 2549, 3, 254, 127, 0, 2460, 2549, 3, 40, 20, 0, 2461, 2462, 5, 301, 0, 0, 2462, 2463, 5, 42, 0, 0, 2463, 2464, 3, 32, 16, 0, 2464, 2465, 5, 43, 0, 0, 2465, 2549, 1, 0, 0, 0, 2466, 2467, 5, 301, 0, 0, 2467, 2468, 5, 42, 0, 0, 2468, 2469, 3, 32, 16, 0, 2469, 2470, 5, 43, 0, 0, 2470, 2471, 5, 34, 0, 0, 2471, 2472, 3, 0, 0, 0, 2472, 2549, 1, 0, 0, 0, 2473, 2474, 5, 303, 0, 0, 2474, 2475, 3, 32, 16, 0, 2475, 2476, 5, 75, 0, 0, 2476, 2477, 3, 32, 16, 0, 2477, 2549, 1, 0, 0, 0, 2478, 2479, 5, 302, 0, 0, 2479, 2480, 3, 124, 62, 0, 2480, 2481, 5, 176, 0, 0, 2481, 2482, 3, 242, 121, 0, 2482, 2549, 1, 0, 0, 0, 2483, 2484, 5, 302, 0, 0, 2484, 2485, 5, 226, 0, 0, 2485, 2486, 3, 170, 85, 0, 2486, 2487, 3, 138, 69, 0, 2487, 2488, 3, 124, 62, 0, 2488, 2489, 5, 176, 0, 0, 2489, 2490, 3, 242, 121, 0, 2490, 2491, 3, 194, 97, 0, 2491, 2492, 3, 112, 56, 0, 2492, 2549, 1, 0, 0, 0, 2493, 2494, 5, 255, 0, 0, 2494, 2495, 5, 196, 0, 0, 2495, 2496, 5, 42, 0, 0, 2496, 2497, 3, 32, 16, 0, 2497, 2501, 5, 43, 0, 0, 2498, 2500, 3, 322, 161, 0, 2499, 2498, 1, 0, 0, 0, 2500, 2503, 1, 0, 0, 0, 2501, 2499, 1, 0, 0, 0, 2501, 2502, 1, 0, 0, 0, 2502, 2549, 1, 0, 0, 0, 2503, 2501, 1, 0, 0, 0, 2504, 2505, 5, 255, 0, 0, 2505, 2506, 5, 196, 0, 0, 2506, 2510, 3, 2, 1, 0, 2507, 2509, 3, 322, 161, 0, 2508, 2507, 1, 0, 0, 0, 2509, 2512, 1, 0, 0, 0, 2510, 2508, 1, 0, 0, 0, 2510, 2511, 1, 0, 0, 0, 2511, 2549, 1, 0, 0, 0, 2512, 2510, 1, 0, 0, 0, 2513, 2514, 5, 255, 0, 0, 2514, 2515, 5, 256, 0, 0, 2515, 2516, 5, 42, 0, 0, 2516, 2517, 3, 32, 16, 0, 2517, 2518, 5, 43, 0, 0, 2518, 2519, 5, 28, 0, 0, 2519, 2523, 3, 124, 62, 0, 2520, 2522, 3, 322, 161, 0, 2521, 2520, 1, 0, 0, 0, 2522, 2525, 1, 0, 0, 0, 2523, 2521, 1, 0, 0, 0, 2523, 2524, 1, 0, 0, 0, 2524, 2549, 1, 0, 0, 0, 2525, 2523, 1, 0, 0, 0, 2526, 2527, 5, 255, 0, 0, 2527, 2528, 5, 256, 0, 0, 2528, 2529, 3, 2, 1, 0, 2529, 2530, 5, 28, 0, 0, 2530, 2534, 3, 124, 62, 0, 2531, 2533, 3, 322, 161, 0, 2532, 2531, 1, 0, 0, 0, 2533, 2536, 1, 0, 0, 0, 2534, 2532, 1, 0, 0, 0, 2534, 2535, 1, 0, 0, 0, 2535, 2549, 1, 0, 0, 0, 2536, 2534, 1, 0, 0, 0, 2537, 2538, 5, 255, 0, 0, 2538, 2539, 5, 42, 0, 0, 2539, 2540, 3, 32, 16, 0, 2540, 2541, 5, 43, 0, 0, 2541, 2545, 3, 206, 103, 0, 2542, 2544, 3, 322, 161, 0, 2543, 2542, 1, 0, 0, 0, 2544, 2547, 1, 0, 0, 0, 2545, 2543, 1, 0, 0, 0, 2545, 2546, 1, 0, 0, 0, 2546, 2549, 1, 0, 0, 0, 2547, 2545, 1, 0, 0, 0, 2548, 2450, 1, 0, 0, 0, 2548, 2452, 1, 0, 0, 0, 2548, 2455, 1, 0, 0, 0, 2548, 2456, 1, 0, 0, 0, 2548, 2457, 1, 0, 0, 0, 2548, 2458, 1, 0, 0, 0, 2548, 2459, 1, 0, 0, 0, 2548, 2460, 1, 0, 0, 0, 2548, 2461, 1, 0, 0, 0, 2548, 2466, 1, 0, 0, 0, 2548, 2473, 1, 0, 0, 0, 2548, 2478, 1, 0, 0, 0, 2548, 2483, 1, 0, 0, 0, 2548, 2493, 1, 0, 0, 0, 2548, 2504, 1, 0, 0, 0, 2548, 2513, 1, 0, 0, 0, 2548, 2526, 1, 0, 0, 0, 2548, 2537, 1, 0, 0, 0, 2549, 251, 1, 0, 0, 0, 2550, 2551, 3, 0, 0, 0, 2551, 2552, 5, 75, 0, 0, 2552, 2553, 6, 126, -1, 0, 2553, 253, 1, 0, 0, 0, 2554, 2557, 3, 44, 22, 0, 2555, 2557, 3, 46, 23, 0, 2556, 2554, 1, 0, 0, 0, 2556, 2555, 1, 0, 0, 0, 2557, 255, 1, 0, 0, 0, 2558, 2559, 5, 17, 0, 0, 2559, 2560, 3, 246, 123, 0, 2560, 2561, 5, 18, 0, 0, 2561, 257, 1, 0, 0, 0, 2562, 2563, 3, 262, 131, 0, 2563, 2564, 3, 260, 130, 0, 2564, 259, 1, 0, 0, 0, 2565, 2567, 3, 264, 132, 0, 2566, 2565, 1, 0, 0, 0, 2567, 2568, 1, 0, 0, 0, 2568, 2566, 1, 0, 0, 0, 2568, 2569, 1, 0, 0, 0, 2569, 261, 1, 0, 0, 0, 2570, 2571, 5, 158, 0, 0, 2571, 2583, 3, 256, 128, 0, 2572, 2573, 5, 158, 0, 0, 2573, 2574, 3, 0, 0, 0, 2574, 2575, 5, 159, 0, 0, 2575, 2576, 3, 0, 0, 0, 2576, 2583, 1, 0, 0, 0, 2577, 2578, 5, 158, 0, 0, 2578, 2579, 3, 32, 16, 0, 2579, 2580, 5, 159, 0, 0, 2580, 2581, 3, 32, 16, 0, 2581, 2583, 1, 0, 0, 0, 2582, 2570, 1, 0, 0, 0, 2582, 2572, 1, 0, 0, 0, 2582, 2577, 1, 0, 0, 0, 2583, 263, 1, 0, 0, 0, 2584, 2585, 3, 268, 134, 0, 2585, 2586, 3, 274, 137, 0, 2586, 2597, 1, 0, 0, 0, 2587, 2588, 3, 266, 133, 0, 2588, 2589, 3, 274, 137, 0, 2589, 2597, 1, 0, 0, 0, 2590, 2591, 3, 270, 135, 0, 2591, 2592, 3, 274, 137, 0, 2592, 2597, 1, 0, 0, 0, 2593, 2594, 3, 272, 136, 0, 2594, 2595, 3, 274, 137, 0, 2595, 2597, 1, 0, 0, 0, 2596, 2584, 1, 0, 0, 0, 2596, 2587, 1, 0, 0, 0, 2596, 2590, 1, 0, 0, 0, 2596, 2593, 1, 0, 0, 0, 2597, 265, 1, 0, 0, 0, 2598, 2599, 5, 160, 0, 0, 2599, 2605, 3, 256, 128, 0, 2600, 2601, 5, 160, 0, 0, 2601, 2605, 3, 0, 0, 0, 2602, 2603, 5, 160, 0, 0, 2603, 2605, 3, 32, 16, 0, 2604, 2598, 1, 0, 0, 0, 2604, 2600, 1, 0, 0, 0, 2604, 2602, 1, 0, 0, 0, 2605, 267, 1, 0, 0, 0, 2606, 2607, 5, 161, 0, 0, 2607, 2608, 3, 124, 62, 0, 2608, 269, 1, 0, 0, 0, 2609, 2610, 5, 162, 0, 0, 2610, 271, 1, 0, 0, 0, 2611, 2612, 5, 163, 0, 0, 2612, 273, 1, 0, 0, 0, 2613, 2625, 3, 256, 128, 0, 2614, 2615, 5, 164, 0, 0, 2615, 2616, 3, 0, 0, 0, 2616, 2617, 5, 159, 0, 0, 2617, 2618, 3, 0, 0, 0, 2618, 2625, 1, 0, 0, 0, 2619, 2620, 5, 164, 0, 0, 2620, 2621, 3, 32, 16, 0, 2621, 2622, 5, 159, 0, 0, 2622, 2623, 3, 32, 16, 0, 2623, 2625, 1, 0, 0, 0, 2624, 2613, 1, 0, 0, 0, 2624, 2614, 1, 0, 0, 0, 2624, 2619, 1, 0, 0, 0, 2625, 275, 1, 0, 0, 0, 2626, 2627, 3, 278, 139, 0, 2627, 2628, 3, 282, 141, 0, 2628, 277, 1, 0, 0, 0, 2629, 2630, 5, 165, 0, 0, 2630, 2631, 3, 280, 140, 0, 2631, 2632, 3, 0, 0, 0, 2632, 2633, 5, 36, 0, 0, 2633, 2637, 1, 0, 0, 0, 2634, 2635, 5, 165, 0, 0, 2635, 2637, 3, 280, 140, 0, 2636, 2629, 1, 0, 0, 0, 2636, 2634, 1, 0, 0, 0, 2637, 279, 1, 0, 0, 0, 2638, 2642, 1, 0, 0, 0, 2639, 2642, 5, 166, 0, 0, 2640, 2642, 5, 2, 0, 0, 2641, 2638, 1, 0, 0, 0, 2641, 2639, 1, 0, 0, 0, 2641, 2640, 1, 0, 0, 0, 2642, 281, 1, 0, 0, 0, 2643, 2644, 5, 17, 0, 0, 2644, 2645, 3, 284, 142, 0, 2645, 2646, 5, 18, 0, 0, 2646, 2653, 1, 0, 0, 0, 2647, 2649, 3, 288, 144, 0, 2648, 2647, 1, 0, 0, 0, 2649, 2650, 1, 0, 0, 0, 2650, 2648, 1, 0, 0, 0, 2650, 2651, 1, 0, 0, 0, 2651, 2653, 1, 0, 0, 0, 2652, 2643, 1, 0, 0, 0, 2652, 2648, 1, 0, 0, 0, 2653, 283, 1, 0, 0, 0, 2654, 2655, 3, 288, 144, 0, 2655, 2656, 5, 28, 0, 0, 2656, 2658, 1, 0, 0, 0, 2657, 2654, 1, 0, 0, 0, 2658, 2661, 1, 0, 0, 0, 2659, 2657, 1, 0, 0, 0, 2659, 2660, 1, 0, 0, 0, 2660, 2662, 1, 0, 0, 0, 2661, 2659, 1, 0, 0, 0, 2662, 2663, 3, 288, 144, 0, 2663, 285, 1, 0, 0, 0, 2664, 2670, 1, 0, 0, 0, 2665, 2666, 5, 42, 0, 0, 2666, 2667, 3, 32, 16, 0, 2667, 2668, 5, 43, 0, 0, 2668, 2670, 1, 0, 0, 0, 2669, 2664, 1, 0, 0, 0, 2669, 2665, 1, 0, 0, 0, 2670, 287, 1, 0, 0, 0, 2671, 2672, 5, 181, 0, 0, 2672, 2673, 5, 262, 0, 0, 2673, 2674, 5, 30, 0, 0, 2674, 2675, 3, 6, 3, 0, 2675, 2676, 5, 31, 0, 0, 2676, 2738, 1, 0, 0, 0, 2677, 2678, 5, 260, 0, 0, 2678, 2679, 5, 30, 0, 0, 2679, 2680, 3, 0, 0, 0, 2680, 2681, 5, 31, 0, 0, 2681, 2738, 1, 0, 0, 0, 2682, 2683, 5, 260, 0, 0, 2683, 2738, 3, 0, 0, 0, 2684, 2685, 5, 84, 0, 0, 2685, 2686, 5, 30, 0, 0, 2686, 2687, 3, 292, 146, 0, 2687, 2688, 5, 31, 0, 0, 2688, 2738, 1, 0, 0, 0, 2689, 2690, 5, 188, 0, 0, 2690, 2691, 5, 30, 0, 0, 2691, 2692, 3, 36, 18, 0, 2692, 2693, 5, 31, 0, 0, 2693, 2694, 3, 286, 143, 0, 2694, 2738, 1, 0, 0, 0, 2695, 2696, 5, 189, 0, 0, 2696, 2697, 5, 30, 0, 0, 2697, 2698, 3, 36, 18, 0, 2698, 2699, 5, 31, 0, 0, 2699, 2700, 3, 286, 143, 0, 2700, 2738, 1, 0, 0, 0, 2701, 2702, 5, 187, 0, 0, 2702, 2703, 5, 30, 0, 0, 2703, 2704, 3, 34, 17, 0, 2704, 2705, 5, 31, 0, 0, 2705, 2706, 3, 286, 143, 0, 2706, 2738, 1, 0, 0, 0, 2707, 2708, 5, 186, 0, 0, 2708, 2709, 5, 30, 0, 0, 2709, 2710, 3, 32, 16, 0, 2710, 2711, 5, 31, 0, 0, 2711, 2712, 3, 286, 143, 0, 2712, 2738, 1, 0, 0, 0, 2713, 2714, 5, 185, 0, 0, 2714, 2715, 5, 30, 0, 0, 2715, 2716, 3, 32, 16, 0, 2716, 2717, 5, 31, 0, 0, 2717, 2718, 3, 286, 143, 0, 2718, 2738, 1, 0, 0, 0, 2719, 2720, 5, 184, 0, 0, 2720, 2721, 5, 30, 0, 0, 2721, 2722, 3, 32, 16, 0, 2722, 2723, 5, 31, 0, 0, 2723, 2724, 3, 286, 143, 0, 2724, 2738, 1, 0, 0, 0, 2725, 2726, 5, 188, 0, 0, 2726, 2738, 3, 286, 143, 0, 2727, 2728, 5, 189, 0, 0, 2728, 2738, 3, 286, 143, 0, 2729, 2730, 5, 187, 0, 0, 2730, 2738, 3, 286, 143, 0, 2731, 2732, 5, 186, 0, 0, 2732, 2738, 3, 286, 143, 0, 2733, 2734, 5, 185, 0, 0, 2734, 2738, 3, 286, 143, 0, 2735, 2736, 5, 184, 0, 0, 2736, 2738, 3, 286, 143, 0, 2737, 2671, 1, 0, 0, 0, 2737, 2677, 1, 0, 0, 0, 2737, 2682, 1, 0, 0, 0, 2737, 2684, 1, 0, 0, 0, 2737, 2689, 1, 0, 0, 0, 2737, 2695, 1, 0, 0, 0, 2737, 2701, 1, 0, 0, 0, 2737, 2707, 1, 0, 0, 0, 2737, 2713, 1, 0, 0, 0, 2737, 2719, 1, 0, 0, 0, 2737, 2725, 1, 0, 0, 0, 2737, 2727, 1, 0, 0, 0, 2737, 2729, 1, 0, 0, 0, 2737, 2731, 1, 0, 0, 0, 2737, 2733, 1, 0, 0, 0, 2737, 2735, 1, 0, 0, 0, 2738, 289, 1, 0, 0, 0, 2739, 2740, 5, 188, 0, 0, 2740, 2741, 5, 30, 0, 0, 2741, 2742, 3, 36, 18, 0, 2742, 2743, 5, 31, 0, 0, 2743, 2815, 1, 0, 0, 0, 2744, 2745, 5, 189, 0, 0, 2745, 2746, 5, 30, 0, 0, 2746, 2747, 3, 36, 18, 0, 2747, 2748, 5, 31, 0, 0, 2748, 2815, 1, 0, 0, 0, 2749, 2750, 5, 188, 0, 0, 2750, 2751, 5, 30, 0, 0, 2751, 2752, 3, 32, 16, 0, 2752, 2753, 5, 31, 0, 0, 2753, 2815, 1, 0, 0, 0, 2754, 2755, 5, 189, 0, 0, 2755, 2756, 5, 30, 0, 0, 2756, 2757, 3, 34, 17, 0, 2757, 2758, 5, 31, 0, 0, 2758, 2815, 1, 0, 0, 0, 2759, 2760, 5, 187, 0, 0, 2760, 2761, 5, 30, 0, 0, 2761, 2762, 3, 34, 17, 0, 2762, 2763, 5, 31, 0, 0, 2763, 2815, 1, 0, 0, 0, 2764, 2765, 5, 186, 0, 0, 2765, 2766, 5, 30, 0, 0, 2766, 2767, 3, 32, 16, 0, 2767, 2768, 5, 31, 0, 0, 2768, 2815, 1, 0, 0, 0, 2769, 2770, 5, 185, 0, 0, 2770, 2771, 5, 30, 0, 0, 2771, 2772, 3, 32, 16, 0, 2772, 2773, 5, 31, 0, 0, 2773, 2815, 1, 0, 0, 0, 2774, 2775, 5, 184, 0, 0, 2775, 2776, 5, 30, 0, 0, 2776, 2777, 3, 32, 16, 0, 2777, 2778, 5, 31, 0, 0, 2778, 2815, 1, 0, 0, 0, 2779, 2780, 5, 193, 0, 0, 2780, 2781, 5, 30, 0, 0, 2781, 2782, 3, 34, 17, 0, 2782, 2783, 5, 31, 0, 0, 2783, 2815, 1, 0, 0, 0, 2784, 2785, 5, 192, 0, 0, 2785, 2786, 5, 30, 0, 0, 2786, 2787, 3, 32, 16, 0, 2787, 2788, 5, 31, 0, 0, 2788, 2815, 1, 0, 0, 0, 2789, 2790, 5, 191, 0, 0, 2790, 2791, 5, 30, 0, 0, 2791, 2792, 3, 32, 16, 0, 2792, 2793, 5, 31, 0, 0, 2793, 2815, 1, 0, 0, 0, 2794, 2795, 5, 190, 0, 0, 2795, 2796, 5, 30, 0, 0, 2796, 2797, 3, 32, 16, 0, 2797, 2798, 5, 31, 0, 0, 2798, 2815, 1, 0, 0, 0, 2799, 2800, 5, 181, 0, 0, 2800, 2801, 5, 30, 0, 0, 2801, 2802, 3, 32, 16, 0, 2802, 2803, 5, 31, 0, 0, 2803, 2815, 1, 0, 0, 0, 2804, 2805, 5, 183, 0, 0, 2805, 2806, 5, 30, 0, 0, 2806, 2807, 3, 162, 81, 0, 2807, 2808, 5, 31, 0, 0, 2808, 2815, 1, 0, 0, 0, 2809, 2810, 5, 84, 0, 0, 2810, 2811, 5, 30, 0, 0, 2811, 2812, 3, 292, 146, 0, 2812, 2813, 5, 31, 0, 0, 2813, 2815, 1, 0, 0, 0, 2814, 2739, 1, 0, 0, 0, 2814, 2744, 1, 0, 0, 0, 2814, 2749, 1, 0, 0, 0, 2814, 2754, 1, 0, 0, 0, 2814, 2759, 1, 0, 0, 0, 2814, 2764, 1, 0, 0, 0, 2814, 2769, 1, 0, 0, 0, 2814, 2774, 1, 0, 0, 0, 2814, 2779, 1, 0, 0, 0, 2814, 2784, 1, 0, 0, 0, 2814, 2789, 1, 0, 0, 0, 2814, 2794, 1, 0, 0, 0, 2814, 2799, 1, 0, 0, 0, 2814, 2804, 1, 0, 0, 0, 2814, 2809, 1, 0, 0, 0, 2815, 291, 1, 0, 0, 0, 2816, 2817, 3, 294, 147, 0, 2817, 2818, 6, 146, -1, 0, 2818, 2820, 1, 0, 0, 0, 2819, 2816, 1, 0, 0, 0, 2820, 2823, 1, 0, 0, 0, 2821, 2819, 1, 0, 0, 0, 2821, 2822, 1, 0, 0, 0, 2822, 293, 1, 0, 0, 0, 2823, 2821, 1, 0, 0, 0, 2824, 2825, 7, 11, 0, 0, 2825, 295, 1, 0, 0, 0, 2826, 2830, 3, 290, 145, 0, 2827, 2830, 3, 6, 3, 0, 2828, 2830, 5, 179, 0, 0, 2829, 2826, 1, 0, 0, 0, 2829, 2827, 1, 0, 0, 0, 2829, 2828, 1, 0, 0, 0, 2830, 297, 1, 0, 0, 0, 2831, 2980, 3, 290, 145, 0, 2832, 2833, 5, 182, 0, 0, 2833, 2834, 5, 30, 0, 0, 2834, 2835, 5, 179, 0, 0, 2835, 2980, 5, 31, 0, 0, 2836, 2837, 5, 182, 0, 0, 2837, 2838, 5, 30, 0, 0, 2838, 2839, 5, 264, 0, 0, 2839, 2980, 5, 31, 0, 0, 2840, 2841, 5, 196, 0, 0, 2841, 2842, 5, 30, 0, 0, 2842, 2843, 5, 39, 0, 0, 2843, 2844, 5, 264, 0, 0, 2844, 2980, 5, 31, 0, 0, 2845, 2846, 5, 196, 0, 0, 2846, 2847, 5, 30, 0, 0, 2847, 2848, 3, 116, 58, 0, 2848, 2849, 5, 31, 0, 0, 2849, 2980, 1, 0, 0, 0, 2850, 2851, 5, 196, 0, 0, 2851, 2852, 5, 30, 0, 0, 2852, 2853, 5, 179, 0, 0, 2853, 2980, 5, 31, 0, 0, 2854, 2855, 5, 197, 0, 0, 2855, 2856, 5, 30, 0, 0, 2856, 2857, 3, 298, 149, 0, 2857, 2858, 5, 31, 0, 0, 2858, 2980, 1, 0, 0, 0, 2859, 2860, 5, 188, 0, 0, 2860, 2861, 5, 42, 0, 0, 2861, 2862, 3, 32, 16, 0, 2862, 2863, 5, 43, 0, 0, 2863, 2864, 5, 30, 0, 0, 2864, 2865, 3, 300, 150, 0, 2865, 2866, 5, 31, 0, 0, 2866, 2980, 1, 0, 0, 0, 2867, 2868, 5, 189, 0, 0, 2868, 2869, 5, 42, 0, 0, 2869, 2870, 3, 32, 16, 0, 2870, 2871, 5, 43, 0, 0, 2871, 2872, 5, 30, 0, 0, 2872, 2873, 3, 302, 151, 0, 2873, 2874, 5, 31, 0, 0, 2874, 2980, 1, 0, 0, 0, 2875, 2876, 5, 187, 0, 0, 2876, 2877, 5, 42, 0, 0, 2877, 2878, 3, 32, 16, 0, 2878, 2879, 5, 43, 0, 0, 2879, 2880, 5, 30, 0, 0, 2880, 2881, 3, 304, 152, 0, 2881, 2882, 5, 31, 0, 0, 2882, 2980, 1, 0, 0, 0, 2883, 2884, 5, 186, 0, 0, 2884, 2885, 5, 42, 0, 0, 2885, 2886, 3, 32, 16, 0, 2886, 2887, 5, 43, 0, 0, 2887, 2888, 5, 30, 0, 0, 2888, 2889, 3, 306, 153, 0, 2889, 2890, 5, 31, 0, 0, 2890, 2980, 1, 0, 0, 0, 2891, 2892, 5, 185, 0, 0, 2892, 2893, 5, 42, 0, 0, 2893, 2894, 3, 32, 16, 0, 2894, 2895, 5, 43, 0, 0, 2895, 2896, 5, 30, 0, 0, 2896, 2897, 3, 308, 154, 0, 2897, 2898, 5, 31, 0, 0, 2898, 2980, 1, 0, 0, 0, 2899, 2900, 5, 184, 0, 0, 2900, 2901, 5, 42, 0, 0, 2901, 2902, 3, 32, 16, 0, 2902, 2903, 5, 43, 0, 0, 2903, 2904, 5, 30, 0, 0, 2904, 2905, 3, 310, 155, 0, 2905, 2906, 5, 31, 0, 0, 2906, 2980, 1, 0, 0, 0, 2907, 2908, 5, 193, 0, 0, 2908, 2909, 5, 42, 0, 0, 2909, 2910, 3, 32, 16, 0, 2910, 2911, 5, 43, 0, 0, 2911, 2912, 5, 30, 0, 0, 2912, 2913, 3, 304, 152, 0, 2913, 2914, 5, 31, 0, 0, 2914, 2980, 1, 0, 0, 0, 2915, 2916, 5, 192, 0, 0, 2916, 2917, 5, 42, 0, 0, 2917, 2918, 3, 32, 16, 0, 2918, 2919, 5, 43, 0, 0, 2919, 2920, 5, 30, 0, 0, 2920, 2921, 3, 306, 153, 0, 2921, 2922, 5, 31, 0, 0, 2922, 2980, 1, 0, 0, 0, 2923, 2924, 5, 191, 0, 0, 2924, 2925, 5, 42, 0, 0, 2925, 2926, 3, 32, 16, 0, 2926, 2927, 5, 43, 0, 0, 2927, 2928, 5, 30, 0, 0, 2928, 2929, 3, 308, 154, 0, 2929, 2930, 5, 31, 0, 0, 2930, 2980, 1, 0, 0, 0, 2931, 2932, 5, 190, 0, 0, 2932, 2933, 5, 42, 0, 0, 2933, 2934, 3, 32, 16, 0, 2934, 2935, 5, 43, 0, 0, 2935, 2936, 5, 30, 0, 0, 2936, 2937, 3, 310, 155, 0, 2937, 2938, 5, 31, 0, 0, 2938, 2980, 1, 0, 0, 0, 2939, 2940, 5, 181, 0, 0, 2940, 2941, 5, 42, 0, 0, 2941, 2942, 3, 32, 16, 0, 2942, 2943, 5, 43, 0, 0, 2943, 2944, 5, 30, 0, 0, 2944, 2945, 3, 308, 154, 0, 2945, 2946, 5, 31, 0, 0, 2946, 2980, 1, 0, 0, 0, 2947, 2948, 5, 183, 0, 0, 2948, 2949, 5, 42, 0, 0, 2949, 2950, 3, 32, 16, 0, 2950, 2951, 5, 43, 0, 0, 2951, 2952, 5, 30, 0, 0, 2952, 2953, 3, 312, 156, 0, 2953, 2954, 5, 31, 0, 0, 2954, 2980, 1, 0, 0, 0, 2955, 2956, 5, 182, 0, 0, 2956, 2957, 5, 42, 0, 0, 2957, 2958, 3, 32, 16, 0, 2958, 2959, 5, 43, 0, 0, 2959, 2960, 5, 30, 0, 0, 2960, 2961, 3, 314, 157, 0, 2961, 2962, 5, 31, 0, 0, 2962, 2980, 1, 0, 0, 0, 2963, 2964, 5, 196, 0, 0, 2964, 2965, 5, 42, 0, 0, 2965, 2966, 3, 32, 16, 0, 2966, 2967, 5, 43, 0, 0, 2967, 2968, 5, 30, 0, 0, 2968, 2969, 3, 316, 158, 0, 2969, 2970, 5, 31, 0, 0, 2970, 2980, 1, 0, 0, 0, 2971, 2972, 5, 197, 0, 0, 2972, 2973, 5, 42, 0, 0, 2973, 2974, 3, 32, 16, 0, 2974, 2975, 5, 43, 0, 0, 2975, 2976, 5, 30, 0, 0, 2976, 2977, 3, 320, 160, 0, 2977, 2978, 5, 31, 0, 0, 2978, 2980, 1, 0, 0, 0, 2979, 2831, 1, 0, 0, 0, 2979, 2832, 1, 0, 0, 0, 2979, 2836, 1, 0, 0, 0, 2979, 2840, 1, 0, 0, 0, 2979, 2845, 1, 0, 0, 0, 2979, 2850, 1, 0, 0, 0, 2979, 2854, 1, 0, 0, 0, 2979, 2859, 1, 0, 0, 0, 2979, 2867, 1, 0, 0, 0, 2979, 2875, 1, 0, 0, 0, 2979, 2883, 1, 0, 0, 0, 2979, 2891, 1, 0, 0, 0, 2979, 2899, 1, 0, 0, 0, 2979, 2907, 1, 0, 0, 0, 2979, 2915, 1, 0, 0, 0, 2979, 2923, 1, 0, 0, 0, 2979, 2931, 1, 0, 0, 0, 2979, 2939, 1, 0, 0, 0, 2979, 2947, 1, 0, 0, 0, 2979, 2955, 1, 0, 0, 0, 2979, 2963, 1, 0, 0, 0, 2979, 2971, 1, 0, 0, 0, 2980, 299, 1, 0, 0, 0, 2981, 2984, 3, 36, 18, 0, 2982, 2984, 3, 32, 16, 0, 2983, 2981, 1, 0, 0, 0, 2983, 2982, 1, 0, 0, 0, 2984, 2987, 1, 0, 0, 0, 2985, 2983, 1, 0, 0, 0, 2985, 2986, 1, 0, 0, 0, 2986, 301, 1, 0, 0, 0, 2987, 2985, 1, 0, 0, 0, 2988, 2991, 3, 36, 18, 0, 2989, 2991, 3, 34, 17, 0, 2990, 2988, 1, 0, 0, 0, 2990, 2989, 1, 0, 0, 0, 2991, 2994, 1, 0, 0, 0, 2992, 2990, 1, 0, 0, 0, 2992, 2993, 1, 0, 0, 0, 2993, 303, 1, 0, 0, 0, 2994, 2992, 1, 0, 0, 0, 2995, 2997, 3, 34, 17, 0, 2996, 2995, 1, 0, 0, 0, 2997, 3000, 1, 0, 0, 0, 2998, 2996, 1, 0, 0, 0, 2998, 2999, 1, 0, 0, 0, 2999, 305, 1, 0, 0, 0, 3000, 2998, 1, 0, 0, 0, 3001, 3003, 3, 32, 16, 0, 3002, 3001, 1, 0, 0, 0, 3003, 3006, 1, 0, 0, 0, 3004, 3002, 1, 0, 0, 0, 3004, 3005, 1, 0, 0, 0, 3005, 307, 1, 0, 0, 0, 3006, 3004, 1, 0, 0, 0, 3007, 3009, 3, 32, 16, 0, 3008, 3007, 1, 0, 0, 0, 3009, 3012, 1, 0, 0, 0, 3010, 3008, 1, 0, 0, 0, 3010, 3011, 1, 0, 0, 0, 3011, 309, 1, 0, 0, 0, 3012, 3010, 1, 0, 0, 0, 3013, 3015, 3, 32, 16, 0, 3014, 3013, 1, 0, 0, 0, 3015, 3018, 1, 0, 0, 0, 3016, 3014, 1, 0, 0, 0, 3016, 3017, 1, 0, 0, 0, 3017, 311, 1, 0, 0, 0, 3018, 3016, 1, 0, 0, 0, 3019, 3021, 3, 162, 81, 0, 3020, 3019, 1, 0, 0, 0, 3021, 3024, 1, 0, 0, 0, 3022, 3020, 1, 0, 0, 0, 3022, 3023, 1, 0, 0, 0, 3023, 313, 1, 0, 0, 0, 3024, 3022, 1, 0, 0, 0, 3025, 3027, 7, 12, 0, 0, 3026, 3025, 1, 0, 0, 0, 3027, 3030, 1, 0, 0, 0, 3028, 3026, 1, 0, 0, 0, 3028, 3029, 1, 0, 0, 0, 3029, 315, 1, 0, 0, 0, 3030, 3028, 1, 0, 0, 0, 3031, 3033, 3, 318, 159, 0, 3032, 3031, 1, 0, 0, 0, 3033, 3036, 1, 0, 0, 0, 3034, 3032, 1, 0, 0, 0, 3034, 3035, 1, 0, 0, 0, 3035, 317, 1, 0, 0, 0, 3036, 3034, 1, 0, 0, 0, 3037, 3042, 5, 179, 0, 0, 3038, 3039, 5, 39, 0, 0, 3039, 3042, 5, 264, 0, 0, 3040, 3042, 3, 116, 58, 0, 3041, 3037, 1, 0, 0, 0, 3041, 3038, 1, 0, 0, 0, 3041, 3040, 1, 0, 0, 0, 3042, 319, 1, 0, 0, 0, 3043, 3045, 3, 298, 149, 0, 3044, 3043, 1, 0, 0, 0, 3045, 3048, 1, 0, 0, 0, 3046, 3044, 1, 0, 0, 0, 3046, 3047, 1, 0, 0, 0, 3047, 321, 1, 0, 0, 0, 3048, 3046, 1, 0, 0, 0, 3049, 3053, 3, 44, 22, 0, 3050, 3053, 3, 46, 23, 0, 3051, 3053, 3, 2, 1, 0, 3052, 3049, 1, 0, 0, 0, 3052, 3050, 1, 0, 0, 0, 3052, 3051, 1, 0, 0, 0, 3053, 323, 1, 0, 0, 0, 3054, 3055, 7, 13, 0, 0, 3055, 3056, 5, 36, 0, 0, 3056, 3057, 5, 30, 0, 0, 3057, 3058, 3, 292, 146, 0, 3058, 3059, 5, 31, 0, 0, 3059, 3080, 1, 0, 0, 0, 3060, 3061, 5, 169, 0, 0, 3061, 3062, 3, 38, 19, 0, 3062, 3063, 5, 75, 0, 0, 3063, 3064, 3, 38, 19, 0, 3064, 3065, 5, 75, 0, 0, 3065, 3066, 3, 38, 19, 0, 3066, 3067, 5, 75, 0, 0, 3067, 3068, 3, 38, 19, 0, 3068, 3080, 1, 0, 0, 0, 3069, 3070, 5, 170, 0, 0, 3070, 3080, 3, 6, 3, 0, 3071, 3072, 5, 170, 0, 0, 3072, 3073, 5, 36, 0, 0, 3073, 3074, 5, 30, 0, 0, 3074, 3075, 3, 292, 146, 0, 3075, 3076, 5, 31, 0, 0, 3076, 3080, 1, 0, 0, 0, 3077, 3080, 3, 322, 161, 0, 3078, 3080, 3, 40, 20, 0, 3079, 3054, 1, 0, 0, 0, 3079, 3060, 1, 0, 0, 0, 3079, 3069, 1, 0, 0, 0, 3079, 3071, 1, 0, 0, 0, 3079, 3077, 1, 0, 0, 0, 3079, 3078, 1, 0, 0, 0, 3080, 325, 1, 0, 0, 0, 3081, 3082, 5, 25, 0, 0, 3082, 3083, 5, 40, 0, 0, 3083, 3084, 3, 98, 49, 0, 3084, 3085, 3, 2, 1, 0, 3085, 3094, 1, 0, 0, 0, 3086, 3087, 5, 25, 0, 0, 3087, 3088, 5, 40, 0, 0, 3088, 3089, 3, 98, 49, 0, 3089, 3090, 3, 2, 1, 0, 3090, 3091, 5, 34, 0, 0, 3091, 3092, 3, 2, 1, 0, 3092, 3094, 1, 0, 0, 0, 3093, 3081, 1, 0, 0, 0, 3093, 3086, 1, 0, 0, 0, 3094, 327, 1, 0, 0, 0, 3095, 3097, 3, 330, 165, 0, 3096, 3095, 1, 0, 0, 0, 3097, 3100, 1, 0, 0, 0, 3098, 3096, 1, 0, 0, 0, 3098, 3099, 1, 0, 0, 0, 3099, 329, 1, 0, 0, 0, 3100, 3098, 1, 0, 0, 0, 3101, 3102, 5, 180, 0, 0, 3102, 3103, 5, 36, 0, 0, 3103, 3104, 5, 30, 0, 0, 3104, 3105, 3, 292, 146, 0, 3105, 3106, 5, 31, 0, 0, 3106, 3116, 1, 0, 0, 0, 3107, 3116, 3, 324, 162, 0, 3108, 3109, 5, 171, 0, 0, 3109, 3110, 5, 36, 0, 0, 3110, 3111, 5, 30, 0, 0, 3111, 3112, 3, 292, 146, 0, 3112, 3113, 5, 31, 0, 0, 3113, 3116, 1, 0, 0, 0, 3114, 3116, 5, 55, 0, 0, 3115, 3101, 1, 0, 0, 0, 3115, 3107, 1, 0, 0, 0, 3115, 3108, 1, 0, 0, 0, 3115, 3114, 1, 0, 0, 0, 3116, 331, 1, 0, 0, 0, 3117, 3118, 5, 50, 0, 0, 3118, 3122, 5, 40, 0, 0, 3119, 3121, 3, 336, 168, 0, 3120, 3119, 1, 0, 0, 0, 3121, 3124, 1, 0, 0, 0, 3122, 3120, 1, 0, 0, 0, 3122, 3123, 1, 0, 0, 0, 3123, 3125, 1, 0, 0, 0, 3124, 3122, 1, 0, 0, 0, 3125, 3126, 3, 2, 1, 0, 3126, 333, 1, 0, 0, 0, 3127, 3131, 5, 301, 0, 0, 3128, 3130, 3, 336, 168, 0, 3129, 3128, 1, 0, 0, 0, 3130, 3133, 1, 0, 0, 0, 3131, 3129, 1, 0, 0, 0, 3131, 3132, 1, 0, 0, 0, 3132, 3134, 1, 0, 0, 0, 3133, 3131, 1, 0, 0, 0, 3134, 3135, 3, 2, 1, 0, 3135, 335, 1, 0, 0, 0, 3136, 3152, 5, 52, 0, 0, 3137, 3152, 5, 51, 0, 0, 3138, 3152, 5, 172, 0, 0, 3139, 3140, 5, 62, 0, 0, 3140, 3152, 5, 51, 0, 0, 3141, 3142, 5, 62, 0, 0, 3142, 3152, 5, 52, 0, 0, 3143, 3144, 5, 62, 0, 0, 3144, 3152, 5, 63, 0, 0, 3145, 3146, 5, 62, 0, 0, 3146, 3152, 5, 64, 0, 0, 3147, 3148, 5, 62, 0, 0, 3148, 3152, 5, 65, 0, 0, 3149, 3150, 5, 62, 0, 0, 3150, 3152, 5, 66, 0, 0, 3151, 3136, 1, 0, 0, 0, 3151, 3137, 1, 0, 0, 0, 3151, 3138, 1, 0, 0, 0, 3151, 3139, 1, 0, 0, 0, 3151, 3141, 1, 0, 0, 0, 3151, 3143, 1, 0, 0, 0, 3151, 3145, 1, 0, 0, 0, 3151, 3147, 1, 0, 0, 0, 3151, 3149, 1, 0, 0, 0, 3152, 337, 1, 0, 0, 0, 3153, 3155, 3, 340, 170, 0, 3154, 3153, 1, 0, 0, 0, 3155, 3158, 1, 0, 0, 0, 3156, 3154, 1, 0, 0, 0, 3156, 3157, 1, 0, 0, 0, 3157, 339, 1, 0, 0, 0, 3158, 3156, 1, 0, 0, 0, 3159, 3160, 5, 21, 0, 0, 3160, 3173, 3, 2, 1, 0, 3161, 3162, 5, 50, 0, 0, 3162, 3163, 5, 40, 0, 0, 3163, 3173, 3, 118, 59, 0, 3164, 3165, 5, 25, 0, 0, 3165, 3166, 5, 40, 0, 0, 3166, 3173, 3, 2, 1, 0, 3167, 3173, 3, 174, 87, 0, 3168, 3169, 5, 50, 0, 0, 3169, 3173, 3, 32, 16, 0, 3170, 3173, 3, 322, 161, 0, 3171, 3173, 3, 40, 20, 0, 3172, 3159, 1, 0, 0, 0, 3172, 3161, 1, 0, 0, 0, 3172, 3164, 1, 0, 0, 0, 3172, 3167, 1, 0, 0, 0, 3172, 3168, 1, 0, 0, 0, 3172, 3170, 1, 0, 0, 0, 3172, 3171, 1, 0, 0, 0, 3173, 341, 1, 0, 0, 0, 3174, 3178, 5, 274, 0, 0, 3175, 3177, 3, 344, 172, 0, 3176, 3175, 1, 0, 0, 0, 3177, 3180, 1, 0, 0, 0, 3178, 3176, 1, 0, 0, 0, 3178, 3179, 1, 0, 0, 0, 3179, 3181, 1, 0, 0, 0, 3180, 3178, 1, 0, 0, 0, 3181, 3194, 3, 2, 1, 0, 3182, 3186, 5, 274, 0, 0, 3183, 3185, 3, 344, 172, 0, 3184, 3183, 1, 0, 0, 0, 3185, 3188, 1, 0, 0, 0, 3186, 3184, 1, 0, 0, 0, 3186, 3187, 1, 0, 0, 0, 3187, 3189, 1, 0, 0, 0, 3188, 3186, 1, 0, 0, 0, 3189, 3190, 3, 2, 1, 0, 3190, 3191, 5, 34, 0, 0, 3191, 3192, 3, 2, 1, 0, 3192, 3194, 1, 0, 0, 0, 3193, 3174, 1, 0, 0, 0, 3193, 3182, 1, 0, 0, 0, 3194, 343, 1, 0, 0, 0, 3195, 3196, 7, 14, 0, 0, 3196, 345, 1, 0, 0, 0, 3197, 3199, 3, 348, 174, 0, 3198, 3197, 1, 0, 0, 0, 3199, 3202, 1, 0, 0, 0, 3200, 3198, 1, 0, 0, 0, 3200, 3201, 1, 0, 0, 0, 3201, 347, 1, 0, 0, 0, 3202, 3200, 1, 0, 0, 0, 3203, 3204, 5, 21, 0, 0, 3204, 3205, 3, 2, 1, 0, 3205, 3206, 5, 44, 0, 0, 3206, 3207, 3, 32, 16, 0, 3207, 3214, 1, 0, 0, 0, 3208, 3209, 5, 25, 0, 0, 3209, 3210, 5, 40, 0, 0, 3210, 3214, 3, 2, 1, 0, 3211, 3214, 3, 322, 161, 0, 3212, 3214, 3, 40, 20, 0, 3213, 3203, 1, 0, 0, 0, 3213, 3208, 1, 0, 0, 0, 3213, 3211, 1, 0, 0, 0, 3213, 3212, 1, 0, 0, 0, 3214, 349, 1, 0, 0, 0, 176, 360, 368, 377, 386, 439, 480, 489, 519, 523, 541, 568, 591, 627, 637, 644, 646, 656, 658, 665, 676, 684, 705, 707, 723, 768, 773, 778, 783, 791, 901, 907, 923, 929, 935, 942, 970, 1048, 1050, 1064, 1070, 1079, 1081, 1090, 1104, 1118, 1126, 1134, 1138, 1177, 1185, 1194, 1202, 1221, 1231, 1234, 1258, 1405, 1415, 1424, 1427, 1509, 1518, 1550, 1610, 1650, 1666, 1676, 1703, 1727, 1735, 1739, 1754, 1761, 1806, 1816, 1834, 1852, 1871, 1892, 1911, 1926, 1933, 1943, 1956, 1961, 1966, 1975, 1985, 2071, 2080, 2093, 2104, 2112, 2122, 2124, 2151, 2158, 2163, 2170, 2176, 2186, 2190, 2197, 2212, 2218, 2232, 2245, 2254, 2265, 2269, 2276, 2296, 2301, 2303, 2316, 2342, 2349, 2351, 2356, 2362, 2391, 2400, 2423, 2428, 2448, 2501, 2510, 2523, 2534, 2545, 2548, 2556, 2568, 2582, 2596, 2604, 2624, 2636, 2641, 2650, 2652, 2659, 2669, 2737, 2814, 2821, 2829, 2979, 2983, 2985, 2990, 2992, 2998, 3004, 3010, 3016, 3022, 3028, 3034, 3041, 3046, 3052, 3079, 3093, 3098, 3115, 3122, 3131, 3151, 3156, 3172, 3178, 3186, 3193, 3200, 3213] \ No newline at end of file +[4, 1, 305, 3267, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 367, 8, 1, 10, 1, 12, 1, 370, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 377, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 5, 3, 384, 8, 3, 10, 3, 12, 3, 387, 9, 3, 1, 3, 1, 3, 1, 3, 1, 4, 5, 4, 393, 8, 4, 10, 4, 12, 4, 396, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 448, 8, 5, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 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, 489, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 5, 15, 496, 8, 15, 10, 15, 12, 15, 499, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 528, 8, 18, 1, 19, 1, 19, 3, 19, 532, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 550, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 577, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 600, 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, 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, 636, 8, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 646, 8, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 5, 27, 653, 8, 27, 10, 27, 12, 27, 656, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 665, 8, 28, 10, 28, 12, 28, 668, 9, 28, 1, 29, 1, 29, 1, 30, 1, 30, 3, 30, 674, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 685, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 693, 8, 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, 34, 1, 34, 1, 34, 1, 34, 5, 34, 714, 8, 34, 10, 34, 12, 34, 717, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 5, 37, 730, 8, 37, 10, 37, 12, 37, 733, 9, 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, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 777, 8, 38, 1, 39, 1, 39, 1, 39, 3, 39, 782, 8, 39, 1, 40, 1, 40, 1, 40, 3, 40, 787, 8, 40, 1, 41, 5, 41, 790, 8, 41, 10, 41, 12, 41, 793, 9, 41, 1, 42, 1, 42, 1, 42, 5, 42, 798, 8, 42, 10, 42, 12, 42, 801, 9, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 910, 8, 44, 1, 45, 1, 45, 5, 45, 914, 8, 45, 10, 45, 12, 45, 917, 9, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 930, 8, 45, 10, 45, 12, 45, 933, 9, 45, 1, 45, 1, 45, 1, 45, 3, 45, 938, 8, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 944, 8, 47, 1, 48, 1, 48, 1, 49, 5, 49, 949, 8, 49, 10, 49, 12, 49, 952, 9, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 979, 8, 50, 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, 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, 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, 1057, 8, 51, 3, 51, 1059, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1073, 8, 53, 1, 53, 1, 53, 5, 53, 1077, 8, 53, 10, 53, 12, 53, 1080, 9, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1088, 8, 53, 3, 53, 1090, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1097, 8, 54, 10, 54, 12, 54, 1100, 9, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1111, 8, 55, 10, 55, 12, 55, 1114, 9, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 5, 56, 1125, 8, 56, 10, 56, 12, 56, 1128, 9, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1135, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 1143, 8, 57, 1, 57, 1, 57, 3, 57, 1147, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1186, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 1192, 8, 59, 10, 59, 12, 59, 1195, 9, 59, 1, 59, 1, 59, 1, 59, 1, 60, 5, 60, 1201, 8, 60, 10, 60, 12, 60, 1204, 9, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1211, 8, 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, 3, 62, 1230, 8, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 5, 63, 1238, 8, 63, 10, 63, 12, 63, 1241, 9, 63, 3, 63, 1243, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 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, 1267, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1414, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1424, 8, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 5, 67, 1431, 8, 67, 10, 67, 12, 67, 1434, 9, 67, 3, 67, 1436, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1518, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 5, 69, 1525, 8, 69, 10, 69, 12, 69, 1528, 9, 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, 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, 1559, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1619, 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, 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, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1659, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1675, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1685, 8, 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, 3, 76, 1712, 8, 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, 1736, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 5, 77, 1742, 8, 77, 10, 77, 12, 77, 1745, 9, 77, 1, 77, 3, 77, 1748, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1763, 8, 78, 1, 79, 1, 79, 1, 79, 5, 79, 1768, 8, 79, 10, 79, 12, 79, 1771, 9, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1815, 8, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1825, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1843, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1861, 8, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1880, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1901, 8, 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, 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 1920, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1935, 8, 89, 1, 90, 1, 90, 1, 90, 5, 90, 1940, 8, 90, 10, 90, 12, 90, 1943, 9, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 1952, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 1965, 8, 92, 1, 93, 5, 93, 1968, 8, 93, 10, 93, 12, 93, 1971, 9, 93, 1, 94, 1, 94, 3, 94, 1975, 8, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 5, 95, 1982, 8, 95, 10, 95, 12, 95, 1985, 9, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 3, 97, 1994, 8, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2078, 8, 99, 10, 99, 12, 99, 2081, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2087, 8, 99, 10, 99, 12, 99, 2090, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2100, 8, 99, 10, 99, 12, 99, 2103, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2111, 8, 99, 10, 99, 12, 99, 2114, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 2121, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 2131, 8, 100, 10, 100, 12, 100, 2134, 9, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 2160, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 2167, 8, 102, 1, 103, 1, 103, 1, 103, 3, 103, 2172, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 2179, 8, 104, 1, 105, 1, 105, 5, 105, 2183, 8, 105, 10, 105, 12, 105, 2186, 9, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2193, 8, 105, 10, 105, 12, 105, 2196, 9, 105, 1, 105, 3, 105, 2199, 8, 105, 1, 106, 1, 106, 1, 107, 5, 107, 2204, 8, 107, 10, 107, 12, 107, 2207, 9, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 2221, 8, 108, 1, 109, 1, 109, 5, 109, 2225, 8, 109, 10, 109, 12, 109, 2228, 9, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 111, 5, 111, 2239, 8, 111, 10, 111, 12, 111, 2242, 9, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 2254, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 2263, 8, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 4, 114, 2272, 8, 114, 11, 114, 12, 114, 2273, 1, 114, 1, 114, 3, 114, 2278, 8, 114, 1, 115, 1, 115, 1, 115, 5, 115, 2283, 8, 115, 10, 115, 12, 115, 2286, 9, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 2305, 8, 116, 1, 117, 1, 117, 1, 117, 5, 117, 2310, 8, 117, 10, 117, 12, 117, 2313, 9, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2323, 8, 117, 10, 117, 12, 117, 2326, 9, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2351, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2358, 8, 119, 3, 119, 2360, 8, 119, 1, 119, 5, 119, 2363, 8, 119, 10, 119, 12, 119, 2366, 9, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2371, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2400, 8, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 2409, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2432, 8, 122, 1, 123, 5, 123, 2435, 8, 123, 10, 123, 12, 123, 2438, 9, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2477, 8, 124, 1, 125, 1, 125, 3, 125, 2481, 8, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, 2491, 8, 126, 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, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 2513, 8, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2523, 8, 129, 10, 129, 12, 129, 2526, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2534, 8, 129, 10, 129, 12, 129, 2537, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2549, 8, 129, 10, 129, 12, 129, 2552, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2562, 8, 129, 10, 129, 12, 129, 2565, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2575, 8, 129, 10, 129, 12, 129, 2578, 9, 129, 3, 129, 2580, 8, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 3, 131, 2588, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 4, 134, 2600, 8, 134, 11, 134, 12, 134, 2601, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 3, 135, 2620, 8, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 3, 136, 2638, 8, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 2652, 8, 137, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 2676, 8, 141, 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 2688, 8, 143, 1, 144, 1, 144, 1, 144, 3, 144, 2693, 8, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 4, 145, 2700, 8, 145, 11, 145, 12, 145, 2701, 3, 145, 2704, 8, 145, 1, 146, 1, 146, 1, 146, 5, 146, 2709, 8, 146, 10, 146, 12, 146, 2712, 9, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 2721, 8, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 3, 148, 2789, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 2866, 8, 149, 1, 150, 1, 150, 1, 150, 5, 150, 2871, 8, 150, 10, 150, 12, 150, 2874, 9, 150, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 3, 152, 2881, 8, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 3, 153, 3031, 8, 153, 1, 154, 1, 154, 5, 154, 3035, 8, 154, 10, 154, 12, 154, 3038, 9, 154, 1, 155, 1, 155, 5, 155, 3042, 8, 155, 10, 155, 12, 155, 3045, 9, 155, 1, 156, 5, 156, 3048, 8, 156, 10, 156, 12, 156, 3051, 9, 156, 1, 157, 5, 157, 3054, 8, 157, 10, 157, 12, 157, 3057, 9, 157, 1, 158, 5, 158, 3060, 8, 158, 10, 158, 12, 158, 3063, 9, 158, 1, 159, 5, 159, 3066, 8, 159, 10, 159, 12, 159, 3069, 9, 159, 1, 160, 5, 160, 3072, 8, 160, 10, 160, 12, 160, 3075, 9, 160, 1, 161, 5, 161, 3078, 8, 161, 10, 161, 12, 161, 3081, 9, 161, 1, 162, 5, 162, 3084, 8, 162, 10, 162, 12, 162, 3087, 9, 162, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 3093, 8, 163, 1, 164, 5, 164, 3096, 8, 164, 10, 164, 12, 164, 3099, 9, 164, 1, 165, 1, 165, 1, 165, 3, 165, 3104, 8, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 3, 166, 3131, 8, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 3, 167, 3145, 8, 167, 1, 168, 5, 168, 3148, 8, 168, 10, 168, 12, 168, 3151, 9, 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, 169, 3, 169, 3167, 8, 169, 1, 170, 1, 170, 1, 170, 5, 170, 3172, 8, 170, 10, 170, 12, 170, 3175, 9, 170, 1, 170, 1, 170, 1, 171, 1, 171, 5, 171, 3181, 8, 171, 10, 171, 12, 171, 3184, 9, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, 172, 3203, 8, 172, 1, 173, 5, 173, 3206, 8, 173, 10, 173, 12, 173, 3209, 9, 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, 3, 174, 3224, 8, 174, 1, 175, 1, 175, 5, 175, 3228, 8, 175, 10, 175, 12, 175, 3231, 9, 175, 1, 175, 1, 175, 1, 175, 5, 175, 3236, 8, 175, 10, 175, 12, 175, 3239, 9, 175, 1, 175, 1, 175, 1, 175, 1, 175, 3, 175, 3245, 8, 175, 1, 176, 1, 176, 1, 177, 5, 177, 3250, 8, 177, 10, 177, 12, 177, 3253, 9, 177, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 3, 178, 3265, 8, 178, 1, 178, 0, 1, 68, 179, 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, 0, 15, 6, 0, 1, 15, 199, 199, 243, 243, 247, 247, 264, 264, 289, 289, 5, 0, 16, 16, 199, 199, 243, 243, 264, 264, 288, 289, 1, 0, 263, 264, 1, 0, 173, 174, 1, 0, 37, 38, 1, 0, 73, 74, 3, 0, 2, 2, 61, 61, 77, 83, 2, 0, 229, 229, 260, 261, 1, 0, 95, 96, 1, 0, 97, 111, 1, 0, 68, 69, 2, 0, 173, 173, 289, 290, 2, 0, 179, 179, 264, 264, 1, 0, 167, 168, 1, 0, 51, 52, 3729, 0, 358, 1, 0, 0, 0, 2, 376, 1, 0, 0, 0, 4, 378, 1, 0, 0, 0, 6, 385, 1, 0, 0, 0, 8, 394, 1, 0, 0, 0, 10, 447, 1, 0, 0, 0, 12, 449, 1, 0, 0, 0, 14, 452, 1, 0, 0, 0, 16, 455, 1, 0, 0, 0, 18, 459, 1, 0, 0, 0, 20, 462, 1, 0, 0, 0, 22, 465, 1, 0, 0, 0, 24, 472, 1, 0, 0, 0, 26, 488, 1, 0, 0, 0, 28, 490, 1, 0, 0, 0, 30, 492, 1, 0, 0, 0, 32, 502, 1, 0, 0, 0, 34, 504, 1, 0, 0, 0, 36, 527, 1, 0, 0, 0, 38, 531, 1, 0, 0, 0, 40, 549, 1, 0, 0, 0, 42, 576, 1, 0, 0, 0, 44, 599, 1, 0, 0, 0, 46, 635, 1, 0, 0, 0, 48, 637, 1, 0, 0, 0, 50, 645, 1, 0, 0, 0, 52, 647, 1, 0, 0, 0, 54, 654, 1, 0, 0, 0, 56, 666, 1, 0, 0, 0, 58, 669, 1, 0, 0, 0, 60, 671, 1, 0, 0, 0, 62, 684, 1, 0, 0, 0, 64, 692, 1, 0, 0, 0, 66, 694, 1, 0, 0, 0, 68, 702, 1, 0, 0, 0, 70, 718, 1, 0, 0, 0, 72, 724, 1, 0, 0, 0, 74, 727, 1, 0, 0, 0, 76, 776, 1, 0, 0, 0, 78, 781, 1, 0, 0, 0, 80, 786, 1, 0, 0, 0, 82, 791, 1, 0, 0, 0, 84, 799, 1, 0, 0, 0, 86, 804, 1, 0, 0, 0, 88, 909, 1, 0, 0, 0, 90, 937, 1, 0, 0, 0, 92, 939, 1, 0, 0, 0, 94, 943, 1, 0, 0, 0, 96, 945, 1, 0, 0, 0, 98, 950, 1, 0, 0, 0, 100, 978, 1, 0, 0, 0, 102, 1058, 1, 0, 0, 0, 104, 1060, 1, 0, 0, 0, 106, 1089, 1, 0, 0, 0, 108, 1091, 1, 0, 0, 0, 110, 1105, 1, 0, 0, 0, 112, 1134, 1, 0, 0, 0, 114, 1146, 1, 0, 0, 0, 116, 1185, 1, 0, 0, 0, 118, 1193, 1, 0, 0, 0, 120, 1202, 1, 0, 0, 0, 122, 1210, 1, 0, 0, 0, 124, 1229, 1, 0, 0, 0, 126, 1242, 1, 0, 0, 0, 128, 1266, 1, 0, 0, 0, 130, 1413, 1, 0, 0, 0, 132, 1423, 1, 0, 0, 0, 134, 1435, 1, 0, 0, 0, 136, 1517, 1, 0, 0, 0, 138, 1519, 1, 0, 0, 0, 140, 1558, 1, 0, 0, 0, 142, 1618, 1, 0, 0, 0, 144, 1658, 1, 0, 0, 0, 146, 1674, 1, 0, 0, 0, 148, 1676, 1, 0, 0, 0, 150, 1680, 1, 0, 0, 0, 152, 1735, 1, 0, 0, 0, 154, 1747, 1, 0, 0, 0, 156, 1762, 1, 0, 0, 0, 158, 1769, 1, 0, 0, 0, 160, 1774, 1, 0, 0, 0, 162, 1778, 1, 0, 0, 0, 164, 1814, 1, 0, 0, 0, 166, 1816, 1, 0, 0, 0, 168, 1860, 1, 0, 0, 0, 170, 1879, 1, 0, 0, 0, 172, 1900, 1, 0, 0, 0, 174, 1902, 1, 0, 0, 0, 176, 1919, 1, 0, 0, 0, 178, 1934, 1, 0, 0, 0, 180, 1941, 1, 0, 0, 0, 182, 1951, 1, 0, 0, 0, 184, 1964, 1, 0, 0, 0, 186, 1969, 1, 0, 0, 0, 188, 1972, 1, 0, 0, 0, 190, 1983, 1, 0, 0, 0, 192, 1988, 1, 0, 0, 0, 194, 1993, 1, 0, 0, 0, 196, 1997, 1, 0, 0, 0, 198, 2120, 1, 0, 0, 0, 200, 2122, 1, 0, 0, 0, 202, 2159, 1, 0, 0, 0, 204, 2166, 1, 0, 0, 0, 206, 2171, 1, 0, 0, 0, 208, 2178, 1, 0, 0, 0, 210, 2198, 1, 0, 0, 0, 212, 2200, 1, 0, 0, 0, 214, 2205, 1, 0, 0, 0, 216, 2220, 1, 0, 0, 0, 218, 2222, 1, 0, 0, 0, 220, 2235, 1, 0, 0, 0, 222, 2240, 1, 0, 0, 0, 224, 2253, 1, 0, 0, 0, 226, 2262, 1, 0, 0, 0, 228, 2277, 1, 0, 0, 0, 230, 2284, 1, 0, 0, 0, 232, 2304, 1, 0, 0, 0, 234, 2306, 1, 0, 0, 0, 236, 2350, 1, 0, 0, 0, 238, 2370, 1, 0, 0, 0, 240, 2399, 1, 0, 0, 0, 242, 2408, 1, 0, 0, 0, 244, 2431, 1, 0, 0, 0, 246, 2436, 1, 0, 0, 0, 248, 2476, 1, 0, 0, 0, 250, 2478, 1, 0, 0, 0, 252, 2484, 1, 0, 0, 0, 254, 2492, 1, 0, 0, 0, 256, 2512, 1, 0, 0, 0, 258, 2579, 1, 0, 0, 0, 260, 2581, 1, 0, 0, 0, 262, 2587, 1, 0, 0, 0, 264, 2589, 1, 0, 0, 0, 266, 2593, 1, 0, 0, 0, 268, 2599, 1, 0, 0, 0, 270, 2619, 1, 0, 0, 0, 272, 2637, 1, 0, 0, 0, 274, 2651, 1, 0, 0, 0, 276, 2653, 1, 0, 0, 0, 278, 2656, 1, 0, 0, 0, 280, 2658, 1, 0, 0, 0, 282, 2675, 1, 0, 0, 0, 284, 2677, 1, 0, 0, 0, 286, 2687, 1, 0, 0, 0, 288, 2692, 1, 0, 0, 0, 290, 2703, 1, 0, 0, 0, 292, 2710, 1, 0, 0, 0, 294, 2720, 1, 0, 0, 0, 296, 2788, 1, 0, 0, 0, 298, 2865, 1, 0, 0, 0, 300, 2872, 1, 0, 0, 0, 302, 2875, 1, 0, 0, 0, 304, 2880, 1, 0, 0, 0, 306, 3030, 1, 0, 0, 0, 308, 3036, 1, 0, 0, 0, 310, 3043, 1, 0, 0, 0, 312, 3049, 1, 0, 0, 0, 314, 3055, 1, 0, 0, 0, 316, 3061, 1, 0, 0, 0, 318, 3067, 1, 0, 0, 0, 320, 3073, 1, 0, 0, 0, 322, 3079, 1, 0, 0, 0, 324, 3085, 1, 0, 0, 0, 326, 3092, 1, 0, 0, 0, 328, 3097, 1, 0, 0, 0, 330, 3103, 1, 0, 0, 0, 332, 3130, 1, 0, 0, 0, 334, 3144, 1, 0, 0, 0, 336, 3149, 1, 0, 0, 0, 338, 3166, 1, 0, 0, 0, 340, 3168, 1, 0, 0, 0, 342, 3178, 1, 0, 0, 0, 344, 3202, 1, 0, 0, 0, 346, 3207, 1, 0, 0, 0, 348, 3223, 1, 0, 0, 0, 350, 3244, 1, 0, 0, 0, 352, 3246, 1, 0, 0, 0, 354, 3251, 1, 0, 0, 0, 356, 3264, 1, 0, 0, 0, 358, 359, 7, 0, 0, 0, 359, 1, 1, 0, 0, 0, 360, 361, 5, 288, 0, 0, 361, 377, 6, 1, -1, 0, 362, 363, 3, 4, 2, 0, 363, 364, 6, 1, -1, 0, 364, 365, 5, 265, 0, 0, 365, 367, 1, 0, 0, 0, 366, 362, 1, 0, 0, 0, 367, 370, 1, 0, 0, 0, 368, 366, 1, 0, 0, 0, 368, 369, 1, 0, 0, 0, 369, 371, 1, 0, 0, 0, 370, 368, 1, 0, 0, 0, 371, 372, 3, 4, 2, 0, 372, 373, 6, 1, -1, 0, 373, 377, 1, 0, 0, 0, 374, 375, 5, 264, 0, 0, 375, 377, 6, 1, -1, 0, 376, 360, 1, 0, 0, 0, 376, 368, 1, 0, 0, 0, 376, 374, 1, 0, 0, 0, 377, 3, 1, 0, 0, 0, 378, 379, 7, 1, 0, 0, 379, 5, 1, 0, 0, 0, 380, 381, 5, 263, 0, 0, 381, 382, 6, 3, -1, 0, 382, 384, 5, 266, 0, 0, 383, 380, 1, 0, 0, 0, 384, 387, 1, 0, 0, 0, 385, 383, 1, 0, 0, 0, 385, 386, 1, 0, 0, 0, 386, 388, 1, 0, 0, 0, 387, 385, 1, 0, 0, 0, 388, 389, 5, 263, 0, 0, 389, 390, 6, 3, -1, 0, 390, 7, 1, 0, 0, 0, 391, 393, 3, 10, 5, 0, 392, 391, 1, 0, 0, 0, 393, 396, 1, 0, 0, 0, 394, 392, 1, 0, 0, 0, 394, 395, 1, 0, 0, 0, 395, 9, 1, 0, 0, 0, 396, 394, 1, 0, 0, 0, 397, 398, 3, 74, 37, 0, 398, 399, 5, 17, 0, 0, 399, 400, 3, 82, 41, 0, 400, 401, 5, 18, 0, 0, 401, 448, 1, 0, 0, 0, 402, 403, 3, 72, 36, 0, 403, 404, 5, 17, 0, 0, 404, 405, 3, 8, 4, 0, 405, 406, 5, 18, 0, 0, 406, 448, 1, 0, 0, 0, 407, 408, 3, 234, 117, 0, 408, 409, 5, 17, 0, 0, 409, 410, 3, 246, 123, 0, 410, 411, 5, 18, 0, 0, 411, 448, 1, 0, 0, 0, 412, 448, 3, 200, 100, 0, 413, 448, 3, 284, 142, 0, 414, 448, 3, 70, 35, 0, 415, 448, 3, 66, 33, 0, 416, 448, 3, 88, 44, 0, 417, 448, 3, 90, 45, 0, 418, 448, 3, 22, 11, 0, 419, 420, 3, 334, 167, 0, 420, 421, 5, 17, 0, 0, 421, 422, 3, 336, 168, 0, 422, 423, 5, 18, 0, 0, 423, 448, 1, 0, 0, 0, 424, 425, 3, 340, 170, 0, 425, 426, 5, 17, 0, 0, 426, 427, 3, 346, 173, 0, 427, 428, 5, 18, 0, 0, 428, 448, 1, 0, 0, 0, 429, 430, 3, 350, 175, 0, 430, 431, 5, 17, 0, 0, 431, 432, 3, 354, 177, 0, 432, 433, 5, 18, 0, 0, 433, 448, 1, 0, 0, 0, 434, 448, 3, 64, 32, 0, 435, 448, 3, 152, 76, 0, 436, 448, 3, 330, 165, 0, 437, 448, 3, 12, 6, 0, 438, 448, 3, 14, 7, 0, 439, 448, 3, 16, 8, 0, 440, 448, 3, 18, 9, 0, 441, 448, 3, 20, 10, 0, 442, 448, 3, 26, 13, 0, 443, 448, 3, 42, 21, 0, 444, 448, 3, 40, 20, 0, 445, 448, 3, 30, 15, 0, 446, 448, 3, 24, 12, 0, 447, 397, 1, 0, 0, 0, 447, 402, 1, 0, 0, 0, 447, 407, 1, 0, 0, 0, 447, 412, 1, 0, 0, 0, 447, 413, 1, 0, 0, 0, 447, 414, 1, 0, 0, 0, 447, 415, 1, 0, 0, 0, 447, 416, 1, 0, 0, 0, 447, 417, 1, 0, 0, 0, 447, 418, 1, 0, 0, 0, 447, 419, 1, 0, 0, 0, 447, 424, 1, 0, 0, 0, 447, 429, 1, 0, 0, 0, 447, 434, 1, 0, 0, 0, 447, 435, 1, 0, 0, 0, 447, 436, 1, 0, 0, 0, 447, 437, 1, 0, 0, 0, 447, 438, 1, 0, 0, 0, 447, 439, 1, 0, 0, 0, 447, 440, 1, 0, 0, 0, 447, 441, 1, 0, 0, 0, 447, 442, 1, 0, 0, 0, 447, 443, 1, 0, 0, 0, 447, 444, 1, 0, 0, 0, 447, 445, 1, 0, 0, 0, 447, 446, 1, 0, 0, 0, 448, 11, 1, 0, 0, 0, 449, 450, 5, 19, 0, 0, 450, 451, 3, 32, 16, 0, 451, 13, 1, 0, 0, 0, 452, 453, 5, 20, 0, 0, 453, 454, 3, 32, 16, 0, 454, 15, 1, 0, 0, 0, 455, 456, 5, 21, 0, 0, 456, 457, 5, 22, 0, 0, 457, 458, 3, 32, 16, 0, 458, 17, 1, 0, 0, 0, 459, 460, 5, 23, 0, 0, 460, 461, 3, 34, 17, 0, 461, 19, 1, 0, 0, 0, 462, 463, 5, 24, 0, 0, 463, 464, 3, 34, 17, 0, 464, 21, 1, 0, 0, 0, 465, 466, 5, 25, 0, 0, 466, 467, 3, 98, 49, 0, 467, 468, 3, 2, 1, 0, 468, 469, 5, 17, 0, 0, 469, 470, 3, 120, 60, 0, 470, 471, 5, 18, 0, 0, 471, 23, 1, 0, 0, 0, 472, 473, 5, 26, 0, 0, 473, 25, 1, 0, 0, 0, 474, 475, 5, 27, 0, 0, 475, 489, 3, 28, 14, 0, 476, 477, 5, 27, 0, 0, 477, 478, 3, 28, 14, 0, 478, 479, 5, 28, 0, 0, 479, 480, 3, 28, 14, 0, 480, 489, 1, 0, 0, 0, 481, 482, 5, 27, 0, 0, 482, 483, 3, 28, 14, 0, 483, 484, 5, 28, 0, 0, 484, 485, 3, 28, 14, 0, 485, 486, 5, 28, 0, 0, 486, 487, 3, 28, 14, 0, 487, 489, 1, 0, 0, 0, 488, 474, 1, 0, 0, 0, 488, 476, 1, 0, 0, 0, 488, 481, 1, 0, 0, 0, 489, 27, 1, 0, 0, 0, 490, 491, 7, 2, 0, 0, 491, 29, 1, 0, 0, 0, 492, 493, 5, 29, 0, 0, 493, 497, 5, 17, 0, 0, 494, 496, 3, 116, 58, 0, 495, 494, 1, 0, 0, 0, 496, 499, 1, 0, 0, 0, 497, 495, 1, 0, 0, 0, 497, 498, 1, 0, 0, 0, 498, 500, 1, 0, 0, 0, 499, 497, 1, 0, 0, 0, 500, 501, 5, 18, 0, 0, 501, 31, 1, 0, 0, 0, 502, 503, 5, 173, 0, 0, 503, 33, 1, 0, 0, 0, 504, 505, 7, 3, 0, 0, 505, 35, 1, 0, 0, 0, 506, 507, 5, 175, 0, 0, 507, 528, 6, 18, -1, 0, 508, 509, 3, 32, 16, 0, 509, 510, 5, 265, 0, 0, 510, 511, 6, 18, -1, 0, 511, 528, 1, 0, 0, 0, 512, 513, 3, 32, 16, 0, 513, 514, 6, 18, -1, 0, 514, 528, 1, 0, 0, 0, 515, 516, 5, 188, 0, 0, 516, 517, 5, 30, 0, 0, 517, 518, 3, 32, 16, 0, 518, 519, 5, 31, 0, 0, 519, 520, 6, 18, -1, 0, 520, 528, 1, 0, 0, 0, 521, 522, 5, 189, 0, 0, 522, 523, 5, 30, 0, 0, 523, 524, 3, 34, 17, 0, 524, 525, 5, 31, 0, 0, 525, 526, 6, 18, -1, 0, 526, 528, 1, 0, 0, 0, 527, 506, 1, 0, 0, 0, 527, 508, 1, 0, 0, 0, 527, 512, 1, 0, 0, 0, 527, 515, 1, 0, 0, 0, 527, 521, 1, 0, 0, 0, 528, 37, 1, 0, 0, 0, 529, 532, 3, 32, 16, 0, 530, 532, 5, 262, 0, 0, 531, 529, 1, 0, 0, 0, 531, 530, 1, 0, 0, 0, 532, 39, 1, 0, 0, 0, 533, 534, 5, 267, 0, 0, 534, 550, 5, 289, 0, 0, 535, 536, 5, 267, 0, 0, 536, 537, 5, 289, 0, 0, 537, 550, 5, 263, 0, 0, 538, 539, 5, 268, 0, 0, 539, 550, 5, 289, 0, 0, 540, 541, 5, 269, 0, 0, 541, 550, 5, 289, 0, 0, 542, 543, 5, 270, 0, 0, 543, 550, 5, 289, 0, 0, 544, 550, 5, 271, 0, 0, 545, 550, 5, 272, 0, 0, 546, 547, 5, 273, 0, 0, 547, 550, 5, 263, 0, 0, 548, 550, 5, 32, 0, 0, 549, 533, 1, 0, 0, 0, 549, 535, 1, 0, 0, 0, 549, 538, 1, 0, 0, 0, 549, 540, 1, 0, 0, 0, 549, 542, 1, 0, 0, 0, 549, 544, 1, 0, 0, 0, 549, 545, 1, 0, 0, 0, 549, 546, 1, 0, 0, 0, 549, 548, 1, 0, 0, 0, 550, 41, 1, 0, 0, 0, 551, 552, 5, 33, 0, 0, 552, 553, 3, 138, 69, 0, 553, 554, 5, 34, 0, 0, 554, 555, 3, 2, 1, 0, 555, 577, 1, 0, 0, 0, 556, 557, 5, 33, 0, 0, 557, 558, 3, 116, 58, 0, 558, 559, 5, 34, 0, 0, 559, 560, 3, 2, 1, 0, 560, 577, 1, 0, 0, 0, 561, 562, 5, 33, 0, 0, 562, 563, 3, 176, 88, 0, 563, 564, 5, 34, 0, 0, 564, 565, 3, 2, 1, 0, 565, 577, 1, 0, 0, 0, 566, 567, 5, 33, 0, 0, 567, 568, 3, 44, 22, 0, 568, 569, 5, 34, 0, 0, 569, 570, 3, 2, 1, 0, 570, 577, 1, 0, 0, 0, 571, 572, 5, 33, 0, 0, 572, 573, 3, 46, 23, 0, 573, 574, 5, 34, 0, 0, 574, 575, 3, 2, 1, 0, 575, 577, 1, 0, 0, 0, 576, 551, 1, 0, 0, 0, 576, 556, 1, 0, 0, 0, 576, 561, 1, 0, 0, 0, 576, 566, 1, 0, 0, 0, 576, 571, 1, 0, 0, 0, 577, 43, 1, 0, 0, 0, 578, 579, 5, 35, 0, 0, 579, 600, 3, 48, 24, 0, 580, 581, 5, 35, 0, 0, 581, 582, 3, 48, 24, 0, 582, 583, 5, 36, 0, 0, 583, 584, 3, 6, 3, 0, 584, 600, 1, 0, 0, 0, 585, 586, 5, 35, 0, 0, 586, 587, 3, 48, 24, 0, 587, 588, 5, 36, 0, 0, 588, 589, 5, 17, 0, 0, 589, 590, 3, 52, 26, 0, 590, 591, 5, 18, 0, 0, 591, 600, 1, 0, 0, 0, 592, 593, 5, 35, 0, 0, 593, 594, 3, 48, 24, 0, 594, 595, 5, 36, 0, 0, 595, 596, 5, 30, 0, 0, 596, 597, 3, 300, 150, 0, 597, 598, 5, 31, 0, 0, 598, 600, 1, 0, 0, 0, 599, 578, 1, 0, 0, 0, 599, 580, 1, 0, 0, 0, 599, 585, 1, 0, 0, 0, 599, 592, 1, 0, 0, 0, 600, 45, 1, 0, 0, 0, 601, 602, 5, 35, 0, 0, 602, 603, 5, 30, 0, 0, 603, 604, 3, 50, 25, 0, 604, 605, 5, 31, 0, 0, 605, 606, 3, 48, 24, 0, 606, 636, 1, 0, 0, 0, 607, 608, 5, 35, 0, 0, 608, 609, 5, 30, 0, 0, 609, 610, 3, 50, 25, 0, 610, 611, 5, 31, 0, 0, 611, 612, 3, 48, 24, 0, 612, 613, 5, 36, 0, 0, 613, 614, 3, 6, 3, 0, 614, 636, 1, 0, 0, 0, 615, 616, 5, 35, 0, 0, 616, 617, 5, 30, 0, 0, 617, 618, 3, 50, 25, 0, 618, 619, 5, 31, 0, 0, 619, 620, 3, 48, 24, 0, 620, 621, 5, 36, 0, 0, 621, 622, 5, 17, 0, 0, 622, 623, 3, 52, 26, 0, 623, 624, 5, 18, 0, 0, 624, 636, 1, 0, 0, 0, 625, 626, 5, 35, 0, 0, 626, 627, 5, 30, 0, 0, 627, 628, 3, 50, 25, 0, 628, 629, 5, 31, 0, 0, 629, 630, 3, 48, 24, 0, 630, 631, 5, 36, 0, 0, 631, 632, 5, 30, 0, 0, 632, 633, 3, 300, 150, 0, 633, 634, 5, 31, 0, 0, 634, 636, 1, 0, 0, 0, 635, 601, 1, 0, 0, 0, 635, 607, 1, 0, 0, 0, 635, 615, 1, 0, 0, 0, 635, 625, 1, 0, 0, 0, 636, 47, 1, 0, 0, 0, 637, 638, 3, 168, 84, 0, 638, 49, 1, 0, 0, 0, 639, 640, 3, 124, 62, 0, 640, 641, 6, 25, -1, 0, 641, 646, 1, 0, 0, 0, 642, 643, 3, 176, 88, 0, 643, 644, 6, 25, -1, 0, 644, 646, 1, 0, 0, 0, 645, 639, 1, 0, 0, 0, 645, 642, 1, 0, 0, 0, 646, 51, 1, 0, 0, 0, 647, 648, 3, 54, 27, 0, 648, 649, 3, 56, 28, 0, 649, 53, 1, 0, 0, 0, 650, 653, 3, 306, 153, 0, 651, 653, 3, 40, 20, 0, 652, 650, 1, 0, 0, 0, 652, 651, 1, 0, 0, 0, 653, 656, 1, 0, 0, 0, 654, 652, 1, 0, 0, 0, 654, 655, 1, 0, 0, 0, 655, 55, 1, 0, 0, 0, 656, 654, 1, 0, 0, 0, 657, 658, 3, 58, 29, 0, 658, 659, 3, 60, 30, 0, 659, 660, 3, 2, 1, 0, 660, 661, 5, 36, 0, 0, 661, 662, 3, 306, 153, 0, 662, 665, 1, 0, 0, 0, 663, 665, 3, 40, 20, 0, 664, 657, 1, 0, 0, 0, 664, 663, 1, 0, 0, 0, 665, 668, 1, 0, 0, 0, 666, 664, 1, 0, 0, 0, 666, 667, 1, 0, 0, 0, 667, 57, 1, 0, 0, 0, 668, 666, 1, 0, 0, 0, 669, 670, 7, 4, 0, 0, 670, 59, 1, 0, 0, 0, 671, 673, 3, 62, 31, 0, 672, 674, 5, 261, 0, 0, 673, 672, 1, 0, 0, 0, 673, 674, 1, 0, 0, 0, 674, 61, 1, 0, 0, 0, 675, 685, 3, 144, 72, 0, 676, 685, 3, 2, 1, 0, 677, 685, 5, 196, 0, 0, 678, 685, 5, 197, 0, 0, 679, 680, 5, 202, 0, 0, 680, 681, 5, 39, 0, 0, 681, 685, 5, 264, 0, 0, 682, 683, 5, 202, 0, 0, 683, 685, 3, 116, 58, 0, 684, 675, 1, 0, 0, 0, 684, 676, 1, 0, 0, 0, 684, 677, 1, 0, 0, 0, 684, 678, 1, 0, 0, 0, 684, 679, 1, 0, 0, 0, 684, 682, 1, 0, 0, 0, 685, 63, 1, 0, 0, 0, 686, 687, 5, 198, 0, 0, 687, 688, 5, 40, 0, 0, 688, 693, 3, 2, 1, 0, 689, 690, 5, 198, 0, 0, 690, 693, 3, 2, 1, 0, 691, 693, 5, 198, 0, 0, 692, 686, 1, 0, 0, 0, 692, 689, 1, 0, 0, 0, 692, 691, 1, 0, 0, 0, 693, 65, 1, 0, 0, 0, 694, 695, 5, 41, 0, 0, 695, 696, 5, 42, 0, 0, 696, 697, 3, 32, 16, 0, 697, 698, 5, 43, 0, 0, 698, 699, 3, 68, 34, 0, 699, 700, 5, 44, 0, 0, 700, 701, 3, 0, 0, 0, 701, 67, 1, 0, 0, 0, 702, 715, 6, 34, -1, 0, 703, 704, 10, 5, 0, 0, 704, 714, 5, 186, 0, 0, 705, 706, 10, 4, 0, 0, 706, 714, 5, 187, 0, 0, 707, 708, 10, 3, 0, 0, 708, 714, 5, 45, 0, 0, 709, 710, 10, 2, 0, 0, 710, 714, 5, 46, 0, 0, 711, 712, 10, 1, 0, 0, 712, 714, 5, 47, 0, 0, 713, 703, 1, 0, 0, 0, 713, 705, 1, 0, 0, 0, 713, 707, 1, 0, 0, 0, 713, 709, 1, 0, 0, 0, 713, 711, 1, 0, 0, 0, 714, 717, 1, 0, 0, 0, 715, 713, 1, 0, 0, 0, 715, 716, 1, 0, 0, 0, 716, 69, 1, 0, 0, 0, 717, 715, 1, 0, 0, 0, 718, 719, 5, 48, 0, 0, 719, 720, 5, 36, 0, 0, 720, 721, 5, 30, 0, 0, 721, 722, 3, 300, 150, 0, 722, 723, 5, 31, 0, 0, 723, 71, 1, 0, 0, 0, 724, 725, 5, 49, 0, 0, 725, 726, 3, 2, 1, 0, 726, 73, 1, 0, 0, 0, 727, 731, 5, 50, 0, 0, 728, 730, 3, 76, 38, 0, 729, 728, 1, 0, 0, 0, 730, 733, 1, 0, 0, 0, 731, 729, 1, 0, 0, 0, 731, 732, 1, 0, 0, 0, 732, 734, 1, 0, 0, 0, 733, 731, 1, 0, 0, 0, 734, 735, 3, 2, 1, 0, 735, 736, 3, 182, 91, 0, 736, 737, 3, 78, 39, 0, 737, 738, 3, 80, 40, 0, 738, 75, 1, 0, 0, 0, 739, 777, 5, 51, 0, 0, 740, 777, 5, 52, 0, 0, 741, 777, 5, 199, 0, 0, 742, 777, 5, 202, 0, 0, 743, 777, 5, 221, 0, 0, 744, 777, 5, 53, 0, 0, 745, 777, 5, 54, 0, 0, 746, 777, 5, 55, 0, 0, 747, 777, 5, 56, 0, 0, 748, 777, 5, 244, 0, 0, 749, 777, 5, 15, 0, 0, 750, 777, 5, 224, 0, 0, 751, 777, 5, 57, 0, 0, 752, 777, 5, 58, 0, 0, 753, 777, 5, 59, 0, 0, 754, 777, 5, 60, 0, 0, 755, 777, 5, 61, 0, 0, 756, 757, 5, 62, 0, 0, 757, 777, 5, 51, 0, 0, 758, 759, 5, 62, 0, 0, 759, 777, 5, 52, 0, 0, 760, 761, 5, 62, 0, 0, 761, 777, 5, 63, 0, 0, 762, 763, 5, 62, 0, 0, 763, 777, 5, 64, 0, 0, 764, 765, 5, 62, 0, 0, 765, 777, 5, 65, 0, 0, 766, 767, 5, 62, 0, 0, 767, 777, 5, 66, 0, 0, 768, 777, 5, 67, 0, 0, 769, 777, 5, 68, 0, 0, 770, 777, 5, 69, 0, 0, 771, 772, 5, 70, 0, 0, 772, 773, 5, 30, 0, 0, 773, 774, 3, 32, 16, 0, 774, 775, 5, 31, 0, 0, 775, 777, 1, 0, 0, 0, 776, 739, 1, 0, 0, 0, 776, 740, 1, 0, 0, 0, 776, 741, 1, 0, 0, 0, 776, 742, 1, 0, 0, 0, 776, 743, 1, 0, 0, 0, 776, 744, 1, 0, 0, 0, 776, 745, 1, 0, 0, 0, 776, 746, 1, 0, 0, 0, 776, 747, 1, 0, 0, 0, 776, 748, 1, 0, 0, 0, 776, 749, 1, 0, 0, 0, 776, 750, 1, 0, 0, 0, 776, 751, 1, 0, 0, 0, 776, 752, 1, 0, 0, 0, 776, 753, 1, 0, 0, 0, 776, 754, 1, 0, 0, 0, 776, 755, 1, 0, 0, 0, 776, 756, 1, 0, 0, 0, 776, 758, 1, 0, 0, 0, 776, 760, 1, 0, 0, 0, 776, 762, 1, 0, 0, 0, 776, 764, 1, 0, 0, 0, 776, 766, 1, 0, 0, 0, 776, 768, 1, 0, 0, 0, 776, 769, 1, 0, 0, 0, 776, 770, 1, 0, 0, 0, 776, 771, 1, 0, 0, 0, 777, 77, 1, 0, 0, 0, 778, 782, 1, 0, 0, 0, 779, 780, 5, 71, 0, 0, 780, 782, 3, 124, 62, 0, 781, 778, 1, 0, 0, 0, 781, 779, 1, 0, 0, 0, 782, 79, 1, 0, 0, 0, 783, 787, 1, 0, 0, 0, 784, 785, 5, 72, 0, 0, 785, 787, 3, 84, 42, 0, 786, 783, 1, 0, 0, 0, 786, 784, 1, 0, 0, 0, 787, 81, 1, 0, 0, 0, 788, 790, 3, 198, 99, 0, 789, 788, 1, 0, 0, 0, 790, 793, 1, 0, 0, 0, 791, 789, 1, 0, 0, 0, 791, 792, 1, 0, 0, 0, 792, 83, 1, 0, 0, 0, 793, 791, 1, 0, 0, 0, 794, 795, 3, 124, 62, 0, 795, 796, 5, 28, 0, 0, 796, 798, 1, 0, 0, 0, 797, 794, 1, 0, 0, 0, 798, 801, 1, 0, 0, 0, 799, 797, 1, 0, 0, 0, 799, 800, 1, 0, 0, 0, 800, 802, 1, 0, 0, 0, 801, 799, 1, 0, 0, 0, 802, 803, 3, 124, 62, 0, 803, 85, 1, 0, 0, 0, 804, 805, 7, 5, 0, 0, 805, 87, 1, 0, 0, 0, 806, 807, 3, 86, 43, 0, 807, 808, 3, 32, 16, 0, 808, 809, 5, 264, 0, 0, 809, 910, 1, 0, 0, 0, 810, 811, 3, 86, 43, 0, 811, 812, 3, 32, 16, 0, 812, 910, 1, 0, 0, 0, 813, 814, 3, 86, 43, 0, 814, 815, 3, 32, 16, 0, 815, 816, 5, 75, 0, 0, 816, 817, 3, 32, 16, 0, 817, 818, 5, 264, 0, 0, 818, 910, 1, 0, 0, 0, 819, 820, 3, 86, 43, 0, 820, 821, 3, 32, 16, 0, 821, 822, 5, 75, 0, 0, 822, 823, 3, 32, 16, 0, 823, 910, 1, 0, 0, 0, 824, 825, 3, 86, 43, 0, 825, 826, 3, 32, 16, 0, 826, 827, 5, 75, 0, 0, 827, 828, 3, 32, 16, 0, 828, 829, 5, 28, 0, 0, 829, 830, 3, 32, 16, 0, 830, 831, 5, 264, 0, 0, 831, 910, 1, 0, 0, 0, 832, 833, 3, 86, 43, 0, 833, 834, 3, 32, 16, 0, 834, 835, 5, 75, 0, 0, 835, 836, 3, 32, 16, 0, 836, 837, 5, 28, 0, 0, 837, 838, 3, 32, 16, 0, 838, 910, 1, 0, 0, 0, 839, 840, 3, 86, 43, 0, 840, 841, 3, 32, 16, 0, 841, 842, 5, 28, 0, 0, 842, 843, 3, 32, 16, 0, 843, 844, 5, 75, 0, 0, 844, 845, 3, 32, 16, 0, 845, 846, 5, 264, 0, 0, 846, 910, 1, 0, 0, 0, 847, 848, 3, 86, 43, 0, 848, 849, 3, 32, 16, 0, 849, 850, 5, 28, 0, 0, 850, 851, 3, 32, 16, 0, 851, 852, 5, 75, 0, 0, 852, 853, 3, 32, 16, 0, 853, 910, 1, 0, 0, 0, 854, 855, 3, 86, 43, 0, 855, 856, 3, 32, 16, 0, 856, 857, 5, 28, 0, 0, 857, 858, 3, 32, 16, 0, 858, 859, 5, 75, 0, 0, 859, 860, 3, 32, 16, 0, 860, 861, 5, 28, 0, 0, 861, 862, 3, 32, 16, 0, 862, 863, 5, 264, 0, 0, 863, 910, 1, 0, 0, 0, 864, 865, 3, 86, 43, 0, 865, 866, 3, 32, 16, 0, 866, 867, 5, 28, 0, 0, 867, 868, 3, 32, 16, 0, 868, 869, 5, 75, 0, 0, 869, 870, 3, 32, 16, 0, 870, 871, 5, 28, 0, 0, 871, 872, 3, 32, 16, 0, 872, 910, 1, 0, 0, 0, 873, 874, 3, 86, 43, 0, 874, 875, 3, 32, 16, 0, 875, 876, 5, 263, 0, 0, 876, 910, 1, 0, 0, 0, 877, 878, 3, 86, 43, 0, 878, 879, 3, 32, 16, 0, 879, 880, 5, 75, 0, 0, 880, 881, 3, 32, 16, 0, 881, 882, 5, 263, 0, 0, 882, 910, 1, 0, 0, 0, 883, 884, 3, 86, 43, 0, 884, 885, 3, 32, 16, 0, 885, 886, 5, 75, 0, 0, 886, 887, 3, 32, 16, 0, 887, 888, 5, 28, 0, 0, 888, 889, 3, 32, 16, 0, 889, 890, 5, 263, 0, 0, 890, 910, 1, 0, 0, 0, 891, 892, 3, 86, 43, 0, 892, 893, 3, 32, 16, 0, 893, 894, 5, 28, 0, 0, 894, 895, 3, 32, 16, 0, 895, 896, 5, 75, 0, 0, 896, 897, 3, 32, 16, 0, 897, 898, 5, 263, 0, 0, 898, 910, 1, 0, 0, 0, 899, 900, 3, 86, 43, 0, 900, 901, 3, 32, 16, 0, 901, 902, 5, 28, 0, 0, 902, 903, 3, 32, 16, 0, 903, 904, 5, 75, 0, 0, 904, 905, 3, 32, 16, 0, 905, 906, 5, 28, 0, 0, 906, 907, 3, 32, 16, 0, 907, 908, 5, 263, 0, 0, 908, 910, 1, 0, 0, 0, 909, 806, 1, 0, 0, 0, 909, 810, 1, 0, 0, 0, 909, 813, 1, 0, 0, 0, 909, 819, 1, 0, 0, 0, 909, 824, 1, 0, 0, 0, 909, 832, 1, 0, 0, 0, 909, 839, 1, 0, 0, 0, 909, 847, 1, 0, 0, 0, 909, 854, 1, 0, 0, 0, 909, 864, 1, 0, 0, 0, 909, 873, 1, 0, 0, 0, 909, 877, 1, 0, 0, 0, 909, 883, 1, 0, 0, 0, 909, 891, 1, 0, 0, 0, 909, 899, 1, 0, 0, 0, 910, 89, 1, 0, 0, 0, 911, 915, 5, 21, 0, 0, 912, 914, 3, 92, 46, 0, 913, 912, 1, 0, 0, 0, 914, 917, 1, 0, 0, 0, 915, 913, 1, 0, 0, 0, 915, 916, 1, 0, 0, 0, 916, 918, 1, 0, 0, 0, 917, 915, 1, 0, 0, 0, 918, 919, 3, 2, 1, 0, 919, 920, 3, 94, 47, 0, 920, 921, 5, 180, 0, 0, 921, 922, 5, 36, 0, 0, 922, 923, 5, 30, 0, 0, 923, 924, 3, 300, 150, 0, 924, 925, 5, 31, 0, 0, 925, 926, 3, 94, 47, 0, 926, 938, 1, 0, 0, 0, 927, 931, 5, 21, 0, 0, 928, 930, 3, 92, 46, 0, 929, 928, 1, 0, 0, 0, 930, 933, 1, 0, 0, 0, 931, 929, 1, 0, 0, 0, 931, 932, 1, 0, 0, 0, 932, 934, 1, 0, 0, 0, 933, 931, 1, 0, 0, 0, 934, 935, 3, 2, 1, 0, 935, 936, 3, 94, 47, 0, 936, 938, 1, 0, 0, 0, 937, 911, 1, 0, 0, 0, 937, 927, 1, 0, 0, 0, 938, 91, 1, 0, 0, 0, 939, 940, 5, 76, 0, 0, 940, 93, 1, 0, 0, 0, 941, 944, 1, 0, 0, 0, 942, 944, 5, 298, 0, 0, 943, 941, 1, 0, 0, 0, 943, 942, 1, 0, 0, 0, 944, 95, 1, 0, 0, 0, 945, 946, 7, 6, 0, 0, 946, 97, 1, 0, 0, 0, 947, 949, 3, 96, 48, 0, 948, 947, 1, 0, 0, 0, 949, 952, 1, 0, 0, 0, 950, 948, 1, 0, 0, 0, 950, 951, 1, 0, 0, 0, 951, 99, 1, 0, 0, 0, 952, 950, 1, 0, 0, 0, 953, 979, 3, 102, 51, 0, 954, 955, 5, 280, 0, 0, 955, 956, 3, 168, 84, 0, 956, 957, 6, 50, -1, 0, 957, 979, 1, 0, 0, 0, 958, 959, 5, 286, 0, 0, 959, 960, 3, 178, 89, 0, 960, 961, 6, 50, -1, 0, 961, 979, 1, 0, 0, 0, 962, 963, 5, 286, 0, 0, 963, 964, 3, 174, 87, 0, 964, 965, 6, 50, -1, 0, 965, 979, 1, 0, 0, 0, 966, 967, 5, 284, 0, 0, 967, 968, 3, 124, 62, 0, 968, 969, 6, 50, -1, 0, 969, 979, 1, 0, 0, 0, 970, 971, 5, 281, 0, 0, 971, 972, 3, 104, 52, 0, 972, 973, 6, 50, -1, 0, 973, 979, 1, 0, 0, 0, 974, 975, 5, 287, 0, 0, 975, 976, 3, 50, 25, 0, 976, 977, 6, 50, -1, 0, 977, 979, 1, 0, 0, 0, 978, 953, 1, 0, 0, 0, 978, 954, 1, 0, 0, 0, 978, 958, 1, 0, 0, 0, 978, 962, 1, 0, 0, 0, 978, 966, 1, 0, 0, 0, 978, 970, 1, 0, 0, 0, 978, 974, 1, 0, 0, 0, 979, 101, 1, 0, 0, 0, 980, 981, 5, 275, 0, 0, 981, 1059, 6, 51, -1, 0, 982, 983, 5, 276, 0, 0, 983, 984, 3, 32, 16, 0, 984, 985, 6, 51, -1, 0, 985, 1059, 1, 0, 0, 0, 986, 987, 5, 276, 0, 0, 987, 988, 3, 0, 0, 0, 988, 989, 6, 51, -1, 0, 989, 1059, 1, 0, 0, 0, 990, 991, 5, 277, 0, 0, 991, 992, 3, 32, 16, 0, 992, 993, 6, 51, -1, 0, 993, 1059, 1, 0, 0, 0, 994, 995, 5, 278, 0, 0, 995, 996, 3, 34, 17, 0, 996, 997, 6, 51, -1, 0, 997, 1059, 1, 0, 0, 0, 998, 999, 5, 279, 0, 0, 999, 1000, 3, 36, 18, 0, 1000, 1001, 6, 51, -1, 0, 1001, 1059, 1, 0, 0, 0, 1002, 1003, 5, 279, 0, 0, 1003, 1004, 3, 34, 17, 0, 1004, 1005, 6, 51, -1, 0, 1005, 1059, 1, 0, 0, 0, 1006, 1007, 5, 279, 0, 0, 1007, 1008, 5, 30, 0, 0, 1008, 1009, 3, 300, 150, 0, 1009, 1010, 5, 31, 0, 0, 1010, 1011, 6, 51, -1, 0, 1011, 1059, 1, 0, 0, 0, 1012, 1013, 5, 279, 0, 0, 1013, 1014, 5, 84, 0, 0, 1014, 1015, 5, 30, 0, 0, 1015, 1016, 3, 300, 150, 0, 1016, 1017, 5, 31, 0, 0, 1017, 1018, 6, 51, -1, 0, 1018, 1059, 1, 0, 0, 0, 1019, 1020, 5, 282, 0, 0, 1020, 1021, 3, 32, 16, 0, 1021, 1022, 6, 51, -1, 0, 1022, 1059, 1, 0, 0, 0, 1023, 1024, 5, 282, 0, 0, 1024, 1025, 3, 0, 0, 0, 1025, 1026, 6, 51, -1, 0, 1026, 1059, 1, 0, 0, 0, 1027, 1028, 5, 285, 0, 0, 1028, 1029, 3, 6, 3, 0, 1029, 1030, 6, 51, -1, 0, 1030, 1059, 1, 0, 0, 0, 1031, 1032, 5, 285, 0, 0, 1032, 1033, 5, 224, 0, 0, 1033, 1034, 5, 30, 0, 0, 1034, 1035, 3, 6, 3, 0, 1035, 1036, 5, 31, 0, 0, 1036, 1037, 6, 51, -1, 0, 1037, 1059, 1, 0, 0, 0, 1038, 1039, 5, 285, 0, 0, 1039, 1040, 5, 84, 0, 0, 1040, 1041, 5, 30, 0, 0, 1041, 1042, 3, 300, 150, 0, 1042, 1043, 5, 31, 0, 0, 1043, 1044, 6, 51, -1, 0, 1044, 1059, 1, 0, 0, 0, 1045, 1046, 5, 287, 0, 0, 1046, 1047, 3, 32, 16, 0, 1047, 1048, 6, 51, -1, 0, 1048, 1059, 1, 0, 0, 0, 1049, 1050, 5, 283, 0, 0, 1050, 1056, 6, 51, -1, 0, 1051, 1052, 5, 30, 0, 0, 1052, 1053, 3, 106, 53, 0, 1053, 1054, 5, 31, 0, 0, 1054, 1057, 1, 0, 0, 0, 1055, 1057, 5, 85, 0, 0, 1056, 1051, 1, 0, 0, 0, 1056, 1055, 1, 0, 0, 0, 1057, 1059, 1, 0, 0, 0, 1058, 980, 1, 0, 0, 0, 1058, 982, 1, 0, 0, 0, 1058, 986, 1, 0, 0, 0, 1058, 990, 1, 0, 0, 0, 1058, 994, 1, 0, 0, 0, 1058, 998, 1, 0, 0, 0, 1058, 1002, 1, 0, 0, 0, 1058, 1006, 1, 0, 0, 0, 1058, 1012, 1, 0, 0, 0, 1058, 1019, 1, 0, 0, 0, 1058, 1023, 1, 0, 0, 0, 1058, 1027, 1, 0, 0, 0, 1058, 1031, 1, 0, 0, 0, 1058, 1038, 1, 0, 0, 0, 1058, 1045, 1, 0, 0, 0, 1058, 1049, 1, 0, 0, 0, 1059, 103, 1, 0, 0, 0, 1060, 1061, 3, 170, 85, 0, 1061, 1062, 3, 138, 69, 0, 1062, 1063, 3, 112, 56, 0, 1063, 1064, 6, 52, -1, 0, 1064, 105, 1, 0, 0, 0, 1065, 1090, 1, 0, 0, 0, 1066, 1067, 3, 0, 0, 0, 1067, 1068, 6, 53, -1, 0, 1068, 1073, 1, 0, 0, 0, 1069, 1070, 3, 32, 16, 0, 1070, 1071, 6, 53, -1, 0, 1071, 1073, 1, 0, 0, 0, 1072, 1066, 1, 0, 0, 0, 1072, 1069, 1, 0, 0, 0, 1073, 1074, 1, 0, 0, 0, 1074, 1075, 5, 28, 0, 0, 1075, 1077, 1, 0, 0, 0, 1076, 1072, 1, 0, 0, 0, 1077, 1080, 1, 0, 0, 0, 1078, 1076, 1, 0, 0, 0, 1078, 1079, 1, 0, 0, 0, 1079, 1087, 1, 0, 0, 0, 1080, 1078, 1, 0, 0, 0, 1081, 1082, 3, 0, 0, 0, 1082, 1083, 6, 53, -1, 0, 1083, 1088, 1, 0, 0, 0, 1084, 1085, 3, 32, 16, 0, 1085, 1086, 6, 53, -1, 0, 1086, 1088, 1, 0, 0, 0, 1087, 1081, 1, 0, 0, 0, 1087, 1084, 1, 0, 0, 0, 1088, 1090, 1, 0, 0, 0, 1089, 1065, 1, 0, 0, 0, 1089, 1078, 1, 0, 0, 0, 1090, 107, 1, 0, 0, 0, 1091, 1098, 5, 86, 0, 0, 1092, 1093, 3, 138, 69, 0, 1093, 1094, 6, 54, -1, 0, 1094, 1095, 5, 28, 0, 0, 1095, 1097, 1, 0, 0, 0, 1096, 1092, 1, 0, 0, 0, 1097, 1100, 1, 0, 0, 0, 1098, 1096, 1, 0, 0, 0, 1098, 1099, 1, 0, 0, 0, 1099, 1101, 1, 0, 0, 0, 1100, 1098, 1, 0, 0, 0, 1101, 1102, 3, 138, 69, 0, 1102, 1103, 6, 54, -1, 0, 1103, 1104, 5, 87, 0, 0, 1104, 109, 1, 0, 0, 0, 1105, 1112, 5, 42, 0, 0, 1106, 1107, 3, 146, 73, 0, 1107, 1108, 6, 55, -1, 0, 1108, 1109, 5, 28, 0, 0, 1109, 1111, 1, 0, 0, 0, 1110, 1106, 1, 0, 0, 0, 1111, 1114, 1, 0, 0, 0, 1112, 1110, 1, 0, 0, 0, 1112, 1113, 1, 0, 0, 0, 1113, 1115, 1, 0, 0, 0, 1114, 1112, 1, 0, 0, 0, 1115, 1116, 3, 146, 73, 0, 1116, 1117, 6, 55, -1, 0, 1117, 1118, 5, 43, 0, 0, 1118, 111, 1, 0, 0, 0, 1119, 1126, 5, 30, 0, 0, 1120, 1121, 3, 114, 57, 0, 1121, 1122, 6, 56, -1, 0, 1122, 1123, 5, 28, 0, 0, 1123, 1125, 1, 0, 0, 0, 1124, 1120, 1, 0, 0, 0, 1125, 1128, 1, 0, 0, 0, 1126, 1124, 1, 0, 0, 0, 1126, 1127, 1, 0, 0, 0, 1127, 1129, 1, 0, 0, 0, 1128, 1126, 1, 0, 0, 0, 1129, 1130, 3, 114, 57, 0, 1130, 1131, 6, 56, -1, 0, 1131, 1132, 5, 31, 0, 0, 1132, 1135, 1, 0, 0, 0, 1133, 1135, 5, 85, 0, 0, 1134, 1119, 1, 0, 0, 0, 1134, 1133, 1, 0, 0, 0, 1135, 113, 1, 0, 0, 0, 1136, 1137, 5, 177, 0, 0, 1137, 1147, 6, 57, -1, 0, 1138, 1139, 3, 230, 115, 0, 1139, 1140, 3, 138, 69, 0, 1140, 1142, 3, 226, 113, 0, 1141, 1143, 3, 0, 0, 0, 1142, 1141, 1, 0, 0, 0, 1142, 1143, 1, 0, 0, 0, 1143, 1144, 1, 0, 0, 0, 1144, 1145, 6, 57, -1, 0, 1145, 1147, 1, 0, 0, 0, 1146, 1136, 1, 0, 0, 0, 1146, 1138, 1, 0, 0, 0, 1147, 115, 1, 0, 0, 0, 1148, 1149, 5, 42, 0, 0, 1149, 1150, 3, 2, 1, 0, 1150, 1151, 5, 43, 0, 0, 1151, 1152, 3, 118, 59, 0, 1152, 1153, 6, 58, -1, 0, 1153, 1186, 1, 0, 0, 0, 1154, 1155, 5, 42, 0, 0, 1155, 1156, 3, 174, 87, 0, 1156, 1157, 5, 43, 0, 0, 1157, 1158, 3, 118, 59, 0, 1158, 1159, 6, 58, -1, 0, 1159, 1186, 1, 0, 0, 0, 1160, 1161, 5, 42, 0, 0, 1161, 1162, 5, 262, 0, 0, 1162, 1163, 5, 43, 0, 0, 1163, 1164, 3, 118, 59, 0, 1164, 1165, 6, 58, -1, 0, 1165, 1186, 1, 0, 0, 0, 1166, 1167, 5, 42, 0, 0, 1167, 1168, 5, 198, 0, 0, 1168, 1169, 3, 2, 1, 0, 1169, 1170, 5, 43, 0, 0, 1170, 1171, 3, 118, 59, 0, 1171, 1172, 6, 58, -1, 0, 1172, 1186, 1, 0, 0, 0, 1173, 1174, 3, 118, 59, 0, 1174, 1175, 6, 58, -1, 0, 1175, 1186, 1, 0, 0, 0, 1176, 1177, 3, 174, 87, 0, 1177, 1178, 6, 58, -1, 0, 1178, 1186, 1, 0, 0, 0, 1179, 1180, 5, 257, 0, 0, 1180, 1186, 6, 58, -1, 0, 1181, 1182, 5, 258, 0, 0, 1182, 1186, 6, 58, -1, 0, 1183, 1184, 5, 259, 0, 0, 1184, 1186, 6, 58, -1, 0, 1185, 1148, 1, 0, 0, 0, 1185, 1154, 1, 0, 0, 0, 1185, 1160, 1, 0, 0, 0, 1185, 1166, 1, 0, 0, 0, 1185, 1173, 1, 0, 0, 0, 1185, 1176, 1, 0, 0, 0, 1185, 1179, 1, 0, 0, 0, 1185, 1181, 1, 0, 0, 0, 1185, 1183, 1, 0, 0, 0, 1186, 117, 1, 0, 0, 0, 1187, 1188, 3, 2, 1, 0, 1188, 1189, 6, 59, -1, 0, 1189, 1190, 5, 88, 0, 0, 1190, 1192, 1, 0, 0, 0, 1191, 1187, 1, 0, 0, 0, 1192, 1195, 1, 0, 0, 0, 1193, 1191, 1, 0, 0, 0, 1193, 1194, 1, 0, 0, 0, 1194, 1196, 1, 0, 0, 0, 1195, 1193, 1, 0, 0, 0, 1196, 1197, 3, 2, 1, 0, 1197, 1198, 6, 59, -1, 0, 1198, 119, 1, 0, 0, 0, 1199, 1201, 3, 122, 61, 0, 1200, 1199, 1, 0, 0, 0, 1201, 1204, 1, 0, 0, 0, 1202, 1200, 1, 0, 0, 0, 1202, 1203, 1, 0, 0, 0, 1203, 121, 1, 0, 0, 0, 1204, 1202, 1, 0, 0, 0, 1205, 1206, 5, 180, 0, 0, 1206, 1207, 5, 89, 0, 0, 1207, 1211, 3, 32, 16, 0, 1208, 1211, 3, 152, 76, 0, 1209, 1211, 3, 332, 166, 0, 1210, 1205, 1, 0, 0, 0, 1210, 1208, 1, 0, 0, 0, 1210, 1209, 1, 0, 0, 0, 1211, 123, 1, 0, 0, 0, 1212, 1213, 3, 116, 58, 0, 1213, 1214, 6, 62, -1, 0, 1214, 1230, 1, 0, 0, 0, 1215, 1216, 5, 42, 0, 0, 1216, 1217, 3, 2, 1, 0, 1217, 1218, 5, 43, 0, 0, 1218, 1219, 6, 62, -1, 0, 1219, 1230, 1, 0, 0, 0, 1220, 1221, 5, 42, 0, 0, 1221, 1222, 5, 198, 0, 0, 1222, 1223, 3, 2, 1, 0, 1223, 1224, 5, 43, 0, 0, 1224, 1225, 6, 62, -1, 0, 1225, 1230, 1, 0, 0, 0, 1226, 1227, 3, 138, 69, 0, 1227, 1228, 6, 62, -1, 0, 1228, 1230, 1, 0, 0, 0, 1229, 1212, 1, 0, 0, 0, 1229, 1215, 1, 0, 0, 0, 1229, 1220, 1, 0, 0, 0, 1229, 1226, 1, 0, 0, 0, 1230, 125, 1, 0, 0, 0, 1231, 1243, 1, 0, 0, 0, 1232, 1233, 3, 130, 65, 0, 1233, 1239, 6, 63, -1, 0, 1234, 1235, 3, 128, 64, 0, 1235, 1236, 6, 63, -1, 0, 1236, 1238, 1, 0, 0, 0, 1237, 1234, 1, 0, 0, 0, 1238, 1241, 1, 0, 0, 0, 1239, 1237, 1, 0, 0, 0, 1239, 1240, 1, 0, 0, 0, 1240, 1243, 1, 0, 0, 0, 1241, 1239, 1, 0, 0, 0, 1242, 1231, 1, 0, 0, 0, 1242, 1232, 1, 0, 0, 0, 1243, 127, 1, 0, 0, 0, 1244, 1245, 5, 262, 0, 0, 1245, 1267, 6, 64, -1, 0, 1246, 1247, 5, 261, 0, 0, 1247, 1267, 6, 64, -1, 0, 1248, 1249, 5, 42, 0, 0, 1249, 1250, 3, 32, 16, 0, 1250, 1251, 5, 43, 0, 0, 1251, 1252, 6, 64, -1, 0, 1252, 1267, 1, 0, 0, 0, 1253, 1254, 5, 42, 0, 0, 1254, 1255, 3, 32, 16, 0, 1255, 1256, 5, 266, 0, 0, 1256, 1257, 3, 32, 16, 0, 1257, 1258, 5, 43, 0, 0, 1258, 1259, 6, 64, -1, 0, 1259, 1267, 1, 0, 0, 0, 1260, 1261, 5, 42, 0, 0, 1261, 1262, 5, 266, 0, 0, 1262, 1263, 3, 32, 16, 0, 1263, 1264, 5, 43, 0, 0, 1264, 1265, 6, 64, -1, 0, 1265, 1267, 1, 0, 0, 0, 1266, 1244, 1, 0, 0, 0, 1266, 1246, 1, 0, 0, 0, 1266, 1248, 1, 0, 0, 0, 1266, 1253, 1, 0, 0, 0, 1266, 1260, 1, 0, 0, 0, 1267, 129, 1, 0, 0, 0, 1268, 1414, 6, 65, -1, 0, 1269, 1270, 5, 203, 0, 0, 1270, 1271, 5, 30, 0, 0, 1271, 1272, 3, 6, 3, 0, 1272, 1273, 5, 28, 0, 0, 1273, 1274, 3, 6, 3, 0, 1274, 1275, 5, 28, 0, 0, 1275, 1276, 3, 6, 3, 0, 1276, 1277, 5, 28, 0, 0, 1277, 1278, 3, 6, 3, 0, 1278, 1279, 5, 31, 0, 0, 1279, 1280, 6, 65, -1, 0, 1280, 1414, 1, 0, 0, 0, 1281, 1282, 5, 203, 0, 0, 1282, 1283, 5, 30, 0, 0, 1283, 1284, 3, 6, 3, 0, 1284, 1285, 5, 28, 0, 0, 1285, 1286, 3, 6, 3, 0, 1286, 1287, 5, 31, 0, 0, 1287, 1288, 6, 65, -1, 0, 1288, 1414, 1, 0, 0, 0, 1289, 1290, 5, 204, 0, 0, 1290, 1291, 5, 205, 0, 0, 1291, 1292, 5, 42, 0, 0, 1292, 1293, 3, 32, 16, 0, 1293, 1294, 5, 43, 0, 0, 1294, 1295, 6, 65, -1, 0, 1295, 1414, 1, 0, 0, 0, 1296, 1297, 5, 204, 0, 0, 1297, 1298, 5, 206, 0, 0, 1298, 1299, 5, 42, 0, 0, 1299, 1300, 3, 32, 16, 0, 1300, 1301, 5, 43, 0, 0, 1301, 1302, 3, 126, 63, 0, 1302, 1303, 6, 65, -1, 0, 1303, 1414, 1, 0, 0, 0, 1304, 1305, 5, 207, 0, 0, 1305, 1414, 6, 65, -1, 0, 1306, 1307, 5, 208, 0, 0, 1307, 1414, 6, 65, -1, 0, 1308, 1309, 5, 209, 0, 0, 1309, 1414, 6, 65, -1, 0, 1310, 1311, 5, 201, 0, 0, 1311, 1414, 6, 65, -1, 0, 1312, 1313, 5, 183, 0, 0, 1313, 1414, 6, 65, -1, 0, 1314, 1315, 5, 184, 0, 0, 1315, 1414, 6, 65, -1, 0, 1316, 1317, 5, 185, 0, 0, 1317, 1414, 6, 65, -1, 0, 1318, 1319, 5, 186, 0, 0, 1319, 1414, 6, 65, -1, 0, 1320, 1321, 5, 187, 0, 0, 1321, 1414, 6, 65, -1, 0, 1322, 1323, 5, 188, 0, 0, 1323, 1414, 6, 65, -1, 0, 1324, 1325, 5, 189, 0, 0, 1325, 1414, 6, 65, -1, 0, 1326, 1327, 5, 210, 0, 0, 1327, 1414, 6, 65, -1, 0, 1328, 1329, 5, 190, 0, 0, 1329, 1414, 6, 65, -1, 0, 1330, 1331, 5, 191, 0, 0, 1331, 1414, 6, 65, -1, 0, 1332, 1333, 5, 192, 0, 0, 1333, 1414, 6, 65, -1, 0, 1334, 1335, 5, 193, 0, 0, 1335, 1414, 6, 65, -1, 0, 1336, 1337, 5, 211, 0, 0, 1337, 1414, 6, 65, -1, 0, 1338, 1339, 5, 212, 0, 0, 1339, 1414, 6, 65, -1, 0, 1340, 1341, 5, 213, 0, 0, 1341, 1414, 6, 65, -1, 0, 1342, 1343, 5, 214, 0, 0, 1343, 1414, 6, 65, -1, 0, 1344, 1345, 5, 215, 0, 0, 1345, 1414, 6, 65, -1, 0, 1346, 1347, 5, 216, 0, 0, 1347, 1414, 6, 65, -1, 0, 1348, 1349, 5, 217, 0, 0, 1349, 1414, 6, 65, -1, 0, 1350, 1351, 5, 218, 0, 0, 1351, 1352, 3, 132, 66, 0, 1352, 1353, 6, 65, -1, 0, 1353, 1414, 1, 0, 0, 0, 1354, 1355, 5, 219, 0, 0, 1355, 1356, 3, 132, 66, 0, 1356, 1357, 6, 65, -1, 0, 1357, 1414, 1, 0, 0, 0, 1358, 1359, 5, 220, 0, 0, 1359, 1414, 6, 65, -1, 0, 1360, 1361, 5, 221, 0, 0, 1361, 1362, 3, 132, 66, 0, 1362, 1363, 6, 65, -1, 0, 1363, 1414, 1, 0, 0, 0, 1364, 1365, 5, 222, 0, 0, 1365, 1366, 3, 134, 67, 0, 1366, 1367, 6, 65, -1, 0, 1367, 1414, 1, 0, 0, 0, 1368, 1369, 5, 222, 0, 0, 1369, 1370, 3, 134, 67, 0, 1370, 1371, 5, 28, 0, 0, 1371, 1372, 3, 6, 3, 0, 1372, 1373, 6, 65, -1, 0, 1373, 1414, 1, 0, 0, 0, 1374, 1375, 5, 194, 0, 0, 1375, 1414, 6, 65, -1, 0, 1376, 1377, 5, 195, 0, 0, 1377, 1414, 6, 65, -1, 0, 1378, 1379, 5, 90, 0, 0, 1379, 1380, 5, 184, 0, 0, 1380, 1414, 6, 65, -1, 0, 1381, 1382, 5, 90, 0, 0, 1382, 1383, 5, 185, 0, 0, 1383, 1414, 6, 65, -1, 0, 1384, 1385, 5, 90, 0, 0, 1385, 1386, 5, 186, 0, 0, 1386, 1414, 6, 65, -1, 0, 1387, 1388, 5, 90, 0, 0, 1388, 1389, 5, 187, 0, 0, 1389, 1414, 6, 65, -1, 0, 1390, 1391, 5, 62, 0, 0, 1391, 1392, 5, 220, 0, 0, 1392, 1414, 6, 65, -1, 0, 1393, 1394, 5, 223, 0, 0, 1394, 1414, 6, 65, -1, 0, 1395, 1396, 5, 224, 0, 0, 1396, 1397, 5, 213, 0, 0, 1397, 1414, 6, 65, -1, 0, 1398, 1399, 5, 225, 0, 0, 1399, 1414, 6, 65, -1, 0, 1400, 1401, 5, 207, 0, 0, 1401, 1402, 5, 183, 0, 0, 1402, 1414, 6, 65, -1, 0, 1403, 1404, 5, 226, 0, 0, 1404, 1414, 6, 65, -1, 0, 1405, 1406, 5, 228, 0, 0, 1406, 1414, 6, 65, -1, 0, 1407, 1408, 5, 34, 0, 0, 1408, 1409, 5, 227, 0, 0, 1409, 1414, 6, 65, -1, 0, 1410, 1411, 3, 2, 1, 0, 1411, 1412, 6, 65, -1, 0, 1412, 1414, 1, 0, 0, 0, 1413, 1268, 1, 0, 0, 0, 1413, 1269, 1, 0, 0, 0, 1413, 1281, 1, 0, 0, 0, 1413, 1289, 1, 0, 0, 0, 1413, 1296, 1, 0, 0, 0, 1413, 1304, 1, 0, 0, 0, 1413, 1306, 1, 0, 0, 0, 1413, 1308, 1, 0, 0, 0, 1413, 1310, 1, 0, 0, 0, 1413, 1312, 1, 0, 0, 0, 1413, 1314, 1, 0, 0, 0, 1413, 1316, 1, 0, 0, 0, 1413, 1318, 1, 0, 0, 0, 1413, 1320, 1, 0, 0, 0, 1413, 1322, 1, 0, 0, 0, 1413, 1324, 1, 0, 0, 0, 1413, 1326, 1, 0, 0, 0, 1413, 1328, 1, 0, 0, 0, 1413, 1330, 1, 0, 0, 0, 1413, 1332, 1, 0, 0, 0, 1413, 1334, 1, 0, 0, 0, 1413, 1336, 1, 0, 0, 0, 1413, 1338, 1, 0, 0, 0, 1413, 1340, 1, 0, 0, 0, 1413, 1342, 1, 0, 0, 0, 1413, 1344, 1, 0, 0, 0, 1413, 1346, 1, 0, 0, 0, 1413, 1348, 1, 0, 0, 0, 1413, 1350, 1, 0, 0, 0, 1413, 1354, 1, 0, 0, 0, 1413, 1358, 1, 0, 0, 0, 1413, 1360, 1, 0, 0, 0, 1413, 1364, 1, 0, 0, 0, 1413, 1368, 1, 0, 0, 0, 1413, 1374, 1, 0, 0, 0, 1413, 1376, 1, 0, 0, 0, 1413, 1378, 1, 0, 0, 0, 1413, 1381, 1, 0, 0, 0, 1413, 1384, 1, 0, 0, 0, 1413, 1387, 1, 0, 0, 0, 1413, 1390, 1, 0, 0, 0, 1413, 1393, 1, 0, 0, 0, 1413, 1395, 1, 0, 0, 0, 1413, 1398, 1, 0, 0, 0, 1413, 1400, 1, 0, 0, 0, 1413, 1403, 1, 0, 0, 0, 1413, 1405, 1, 0, 0, 0, 1413, 1407, 1, 0, 0, 0, 1413, 1410, 1, 0, 0, 0, 1414, 131, 1, 0, 0, 0, 1415, 1424, 1, 0, 0, 0, 1416, 1417, 5, 30, 0, 0, 1417, 1418, 5, 91, 0, 0, 1418, 1419, 5, 36, 0, 0, 1419, 1420, 3, 32, 16, 0, 1420, 1421, 5, 31, 0, 0, 1421, 1422, 6, 66, -1, 0, 1422, 1424, 1, 0, 0, 0, 1423, 1415, 1, 0, 0, 0, 1423, 1416, 1, 0, 0, 0, 1424, 133, 1, 0, 0, 0, 1425, 1436, 1, 0, 0, 0, 1426, 1427, 3, 136, 68, 0, 1427, 1432, 6, 67, -1, 0, 1428, 1429, 7, 7, 0, 0, 1429, 1431, 6, 67, -1, 0, 1430, 1428, 1, 0, 0, 0, 1431, 1434, 1, 0, 0, 0, 1432, 1430, 1, 0, 0, 0, 1432, 1433, 1, 0, 0, 0, 1433, 1436, 1, 0, 0, 0, 1434, 1432, 1, 0, 0, 0, 1435, 1425, 1, 0, 0, 0, 1435, 1426, 1, 0, 0, 0, 1436, 135, 1, 0, 0, 0, 1437, 1438, 5, 178, 0, 0, 1438, 1518, 6, 68, -1, 0, 1439, 1440, 5, 207, 0, 0, 1440, 1518, 6, 68, -1, 0, 1441, 1442, 5, 208, 0, 0, 1442, 1518, 6, 68, -1, 0, 1443, 1444, 5, 201, 0, 0, 1444, 1518, 6, 68, -1, 0, 1445, 1446, 5, 183, 0, 0, 1446, 1518, 6, 68, -1, 0, 1447, 1448, 5, 184, 0, 0, 1448, 1518, 6, 68, -1, 0, 1449, 1450, 5, 185, 0, 0, 1450, 1518, 6, 68, -1, 0, 1451, 1452, 5, 186, 0, 0, 1452, 1518, 6, 68, -1, 0, 1453, 1454, 5, 187, 0, 0, 1454, 1518, 6, 68, -1, 0, 1455, 1456, 5, 188, 0, 0, 1456, 1518, 6, 68, -1, 0, 1457, 1458, 5, 189, 0, 0, 1458, 1518, 6, 68, -1, 0, 1459, 1460, 5, 190, 0, 0, 1460, 1518, 6, 68, -1, 0, 1461, 1462, 5, 191, 0, 0, 1462, 1518, 6, 68, -1, 0, 1463, 1464, 5, 192, 0, 0, 1464, 1518, 6, 68, -1, 0, 1465, 1466, 5, 193, 0, 0, 1466, 1518, 6, 68, -1, 0, 1467, 1468, 5, 262, 0, 0, 1468, 1518, 6, 68, -1, 0, 1469, 1470, 5, 211, 0, 0, 1470, 1518, 6, 68, -1, 0, 1471, 1472, 5, 212, 0, 0, 1472, 1518, 6, 68, -1, 0, 1473, 1474, 5, 213, 0, 0, 1474, 1518, 6, 68, -1, 0, 1475, 1476, 5, 214, 0, 0, 1476, 1518, 6, 68, -1, 0, 1477, 1478, 5, 215, 0, 0, 1478, 1518, 6, 68, -1, 0, 1479, 1480, 5, 218, 0, 0, 1480, 1518, 6, 68, -1, 0, 1481, 1482, 5, 219, 0, 0, 1482, 1518, 6, 68, -1, 0, 1483, 1484, 5, 222, 0, 0, 1484, 1518, 6, 68, -1, 0, 1485, 1486, 5, 194, 0, 0, 1486, 1518, 6, 68, -1, 0, 1487, 1488, 5, 195, 0, 0, 1488, 1518, 6, 68, -1, 0, 1489, 1490, 5, 210, 0, 0, 1490, 1518, 6, 68, -1, 0, 1491, 1492, 5, 230, 0, 0, 1492, 1518, 6, 68, -1, 0, 1493, 1494, 5, 231, 0, 0, 1494, 1518, 6, 68, -1, 0, 1495, 1496, 5, 232, 0, 0, 1496, 1518, 6, 68, -1, 0, 1497, 1498, 5, 233, 0, 0, 1498, 1518, 6, 68, -1, 0, 1499, 1500, 5, 234, 0, 0, 1500, 1518, 6, 68, -1, 0, 1501, 1502, 5, 235, 0, 0, 1502, 1518, 6, 68, -1, 0, 1503, 1504, 5, 236, 0, 0, 1504, 1518, 6, 68, -1, 0, 1505, 1506, 5, 237, 0, 0, 1506, 1518, 6, 68, -1, 0, 1507, 1508, 5, 238, 0, 0, 1508, 1518, 6, 68, -1, 0, 1509, 1510, 5, 239, 0, 0, 1510, 1518, 6, 68, -1, 0, 1511, 1512, 5, 240, 0, 0, 1512, 1518, 6, 68, -1, 0, 1513, 1514, 5, 241, 0, 0, 1514, 1518, 6, 68, -1, 0, 1515, 1516, 5, 242, 0, 0, 1516, 1518, 6, 68, -1, 0, 1517, 1437, 1, 0, 0, 0, 1517, 1439, 1, 0, 0, 0, 1517, 1441, 1, 0, 0, 0, 1517, 1443, 1, 0, 0, 0, 1517, 1445, 1, 0, 0, 0, 1517, 1447, 1, 0, 0, 0, 1517, 1449, 1, 0, 0, 0, 1517, 1451, 1, 0, 0, 0, 1517, 1453, 1, 0, 0, 0, 1517, 1455, 1, 0, 0, 0, 1517, 1457, 1, 0, 0, 0, 1517, 1459, 1, 0, 0, 0, 1517, 1461, 1, 0, 0, 0, 1517, 1463, 1, 0, 0, 0, 1517, 1465, 1, 0, 0, 0, 1517, 1467, 1, 0, 0, 0, 1517, 1469, 1, 0, 0, 0, 1517, 1471, 1, 0, 0, 0, 1517, 1473, 1, 0, 0, 0, 1517, 1475, 1, 0, 0, 0, 1517, 1477, 1, 0, 0, 0, 1517, 1479, 1, 0, 0, 0, 1517, 1481, 1, 0, 0, 0, 1517, 1483, 1, 0, 0, 0, 1517, 1485, 1, 0, 0, 0, 1517, 1487, 1, 0, 0, 0, 1517, 1489, 1, 0, 0, 0, 1517, 1491, 1, 0, 0, 0, 1517, 1493, 1, 0, 0, 0, 1517, 1495, 1, 0, 0, 0, 1517, 1497, 1, 0, 0, 0, 1517, 1499, 1, 0, 0, 0, 1517, 1501, 1, 0, 0, 0, 1517, 1503, 1, 0, 0, 0, 1517, 1505, 1, 0, 0, 0, 1517, 1507, 1, 0, 0, 0, 1517, 1509, 1, 0, 0, 0, 1517, 1511, 1, 0, 0, 0, 1517, 1513, 1, 0, 0, 0, 1517, 1515, 1, 0, 0, 0, 1518, 137, 1, 0, 0, 0, 1519, 1520, 3, 142, 71, 0, 1520, 1526, 6, 69, -1, 0, 1521, 1522, 3, 140, 70, 0, 1522, 1523, 6, 69, -1, 0, 1523, 1525, 1, 0, 0, 0, 1524, 1521, 1, 0, 0, 0, 1525, 1528, 1, 0, 0, 0, 1526, 1524, 1, 0, 0, 0, 1526, 1527, 1, 0, 0, 0, 1527, 139, 1, 0, 0, 0, 1528, 1526, 1, 0, 0, 0, 1529, 1530, 5, 261, 0, 0, 1530, 1559, 6, 70, -1, 0, 1531, 1532, 5, 42, 0, 0, 1532, 1533, 5, 43, 0, 0, 1533, 1559, 6, 70, -1, 0, 1534, 1535, 3, 110, 55, 0, 1535, 1536, 6, 70, -1, 0, 1536, 1559, 1, 0, 0, 0, 1537, 1538, 5, 260, 0, 0, 1538, 1559, 6, 70, -1, 0, 1539, 1540, 5, 262, 0, 0, 1540, 1559, 6, 70, -1, 0, 1541, 1542, 5, 92, 0, 0, 1542, 1559, 6, 70, -1, 0, 1543, 1544, 5, 93, 0, 0, 1544, 1545, 5, 30, 0, 0, 1545, 1546, 3, 124, 62, 0, 1546, 1547, 5, 31, 0, 0, 1547, 1548, 6, 70, -1, 0, 1548, 1559, 1, 0, 0, 0, 1549, 1550, 5, 94, 0, 0, 1550, 1551, 5, 30, 0, 0, 1551, 1552, 3, 124, 62, 0, 1552, 1553, 5, 31, 0, 0, 1553, 1554, 6, 70, -1, 0, 1554, 1559, 1, 0, 0, 0, 1555, 1556, 3, 108, 54, 0, 1556, 1557, 6, 70, -1, 0, 1557, 1559, 1, 0, 0, 0, 1558, 1529, 1, 0, 0, 0, 1558, 1531, 1, 0, 0, 0, 1558, 1534, 1, 0, 0, 0, 1558, 1537, 1, 0, 0, 0, 1558, 1539, 1, 0, 0, 0, 1558, 1541, 1, 0, 0, 0, 1558, 1543, 1, 0, 0, 0, 1558, 1549, 1, 0, 0, 0, 1558, 1555, 1, 0, 0, 0, 1559, 141, 1, 0, 0, 0, 1560, 1561, 5, 39, 0, 0, 1561, 1562, 3, 116, 58, 0, 1562, 1563, 6, 71, -1, 0, 1563, 1619, 1, 0, 0, 0, 1564, 1565, 5, 197, 0, 0, 1565, 1619, 6, 71, -1, 0, 1566, 1567, 5, 199, 0, 0, 1567, 1568, 5, 39, 0, 0, 1568, 1569, 3, 116, 58, 0, 1569, 1570, 6, 71, -1, 0, 1570, 1619, 1, 0, 0, 0, 1571, 1572, 5, 200, 0, 0, 1572, 1573, 3, 116, 58, 0, 1573, 1574, 6, 71, -1, 0, 1574, 1619, 1, 0, 0, 0, 1575, 1576, 5, 226, 0, 0, 1576, 1577, 3, 170, 85, 0, 1577, 1578, 3, 138, 69, 0, 1578, 1579, 5, 262, 0, 0, 1579, 1580, 3, 112, 56, 0, 1580, 1581, 6, 71, -1, 0, 1581, 1619, 1, 0, 0, 0, 1582, 1583, 5, 253, 0, 0, 1583, 1584, 3, 32, 16, 0, 1584, 1585, 6, 71, -1, 0, 1585, 1619, 1, 0, 0, 0, 1586, 1587, 5, 252, 0, 0, 1587, 1588, 3, 32, 16, 0, 1588, 1589, 6, 71, -1, 0, 1589, 1619, 1, 0, 0, 0, 1590, 1591, 5, 253, 0, 0, 1591, 1592, 3, 2, 1, 0, 1592, 1593, 6, 71, -1, 0, 1593, 1619, 1, 0, 0, 0, 1594, 1595, 5, 252, 0, 0, 1595, 1596, 3, 2, 1, 0, 1596, 1597, 6, 71, -1, 0, 1597, 1619, 1, 0, 0, 0, 1598, 1599, 5, 254, 0, 0, 1599, 1619, 6, 71, -1, 0, 1600, 1601, 5, 201, 0, 0, 1601, 1619, 6, 71, -1, 0, 1602, 1603, 3, 148, 74, 0, 1603, 1604, 6, 71, -1, 0, 1604, 1619, 1, 0, 0, 0, 1605, 1606, 3, 150, 75, 0, 1606, 1607, 6, 71, -1, 0, 1607, 1619, 1, 0, 0, 0, 1608, 1609, 3, 144, 72, 0, 1609, 1610, 6, 71, -1, 0, 1610, 1619, 1, 0, 0, 0, 1611, 1612, 3, 2, 1, 0, 1612, 1613, 6, 71, -1, 0, 1613, 1619, 1, 0, 0, 0, 1614, 1615, 5, 177, 0, 0, 1615, 1616, 3, 138, 69, 0, 1616, 1617, 6, 71, -1, 0, 1617, 1619, 1, 0, 0, 0, 1618, 1560, 1, 0, 0, 0, 1618, 1564, 1, 0, 0, 0, 1618, 1566, 1, 0, 0, 0, 1618, 1571, 1, 0, 0, 0, 1618, 1575, 1, 0, 0, 0, 1618, 1582, 1, 0, 0, 0, 1618, 1586, 1, 0, 0, 0, 1618, 1590, 1, 0, 0, 0, 1618, 1594, 1, 0, 0, 0, 1618, 1598, 1, 0, 0, 0, 1618, 1600, 1, 0, 0, 0, 1618, 1602, 1, 0, 0, 0, 1618, 1605, 1, 0, 0, 0, 1618, 1608, 1, 0, 0, 0, 1618, 1611, 1, 0, 0, 0, 1618, 1614, 1, 0, 0, 0, 1619, 143, 1, 0, 0, 0, 1620, 1621, 5, 181, 0, 0, 1621, 1659, 6, 72, -1, 0, 1622, 1623, 5, 182, 0, 0, 1623, 1659, 6, 72, -1, 0, 1624, 1625, 5, 183, 0, 0, 1625, 1659, 6, 72, -1, 0, 1626, 1627, 5, 184, 0, 0, 1627, 1659, 6, 72, -1, 0, 1628, 1629, 5, 185, 0, 0, 1629, 1659, 6, 72, -1, 0, 1630, 1631, 5, 186, 0, 0, 1631, 1659, 6, 72, -1, 0, 1632, 1633, 5, 187, 0, 0, 1633, 1659, 6, 72, -1, 0, 1634, 1635, 5, 188, 0, 0, 1635, 1659, 6, 72, -1, 0, 1636, 1637, 5, 189, 0, 0, 1637, 1659, 6, 72, -1, 0, 1638, 1639, 5, 190, 0, 0, 1639, 1659, 6, 72, -1, 0, 1640, 1641, 5, 191, 0, 0, 1641, 1659, 6, 72, -1, 0, 1642, 1643, 5, 192, 0, 0, 1643, 1659, 6, 72, -1, 0, 1644, 1645, 5, 193, 0, 0, 1645, 1659, 6, 72, -1, 0, 1646, 1647, 5, 90, 0, 0, 1647, 1648, 5, 184, 0, 0, 1648, 1659, 6, 72, -1, 0, 1649, 1650, 5, 90, 0, 0, 1650, 1651, 5, 185, 0, 0, 1651, 1659, 6, 72, -1, 0, 1652, 1653, 5, 90, 0, 0, 1653, 1654, 5, 186, 0, 0, 1654, 1659, 6, 72, -1, 0, 1655, 1656, 5, 90, 0, 0, 1656, 1657, 5, 187, 0, 0, 1657, 1659, 6, 72, -1, 0, 1658, 1620, 1, 0, 0, 0, 1658, 1622, 1, 0, 0, 0, 1658, 1624, 1, 0, 0, 0, 1658, 1626, 1, 0, 0, 0, 1658, 1628, 1, 0, 0, 0, 1658, 1630, 1, 0, 0, 0, 1658, 1632, 1, 0, 0, 0, 1658, 1634, 1, 0, 0, 0, 1658, 1636, 1, 0, 0, 0, 1658, 1638, 1, 0, 0, 0, 1658, 1640, 1, 0, 0, 0, 1658, 1642, 1, 0, 0, 0, 1658, 1644, 1, 0, 0, 0, 1658, 1646, 1, 0, 0, 0, 1658, 1649, 1, 0, 0, 0, 1658, 1652, 1, 0, 0, 0, 1658, 1655, 1, 0, 0, 0, 1659, 145, 1, 0, 0, 0, 1660, 1675, 1, 0, 0, 0, 1661, 1675, 5, 177, 0, 0, 1662, 1663, 3, 32, 16, 0, 1663, 1664, 6, 73, -1, 0, 1664, 1675, 1, 0, 0, 0, 1665, 1666, 3, 32, 16, 0, 1666, 1667, 5, 177, 0, 0, 1667, 1668, 3, 32, 16, 0, 1668, 1669, 6, 73, -1, 0, 1669, 1675, 1, 0, 0, 0, 1670, 1671, 3, 32, 16, 0, 1671, 1672, 5, 177, 0, 0, 1672, 1673, 6, 73, -1, 0, 1673, 1675, 1, 0, 0, 0, 1674, 1660, 1, 0, 0, 0, 1674, 1661, 1, 0, 0, 0, 1674, 1662, 1, 0, 0, 0, 1674, 1665, 1, 0, 0, 0, 1674, 1670, 1, 0, 0, 0, 1675, 147, 1, 0, 0, 0, 1676, 1677, 5, 1, 0, 0, 1677, 1678, 5, 194, 0, 0, 1678, 1679, 6, 74, -1, 0, 1679, 149, 1, 0, 0, 0, 1680, 1684, 5, 1, 0, 0, 1681, 1682, 5, 90, 0, 0, 1682, 1685, 5, 194, 0, 0, 1683, 1685, 5, 195, 0, 0, 1684, 1681, 1, 0, 0, 0, 1684, 1683, 1, 0, 0, 0, 1685, 1686, 1, 0, 0, 0, 1686, 1687, 6, 75, -1, 0, 1687, 151, 1, 0, 0, 0, 1688, 1689, 5, 294, 0, 0, 1689, 1690, 3, 166, 83, 0, 1690, 1691, 3, 124, 62, 0, 1691, 1692, 5, 30, 0, 0, 1692, 1693, 3, 158, 79, 0, 1693, 1694, 5, 31, 0, 0, 1694, 1736, 1, 0, 0, 0, 1695, 1696, 5, 294, 0, 0, 1696, 1697, 3, 166, 83, 0, 1697, 1698, 3, 124, 62, 0, 1698, 1699, 5, 36, 0, 0, 1699, 1700, 5, 17, 0, 0, 1700, 1701, 3, 52, 26, 0, 1701, 1702, 5, 18, 0, 0, 1702, 1736, 1, 0, 0, 0, 1703, 1704, 5, 294, 0, 0, 1704, 1705, 3, 166, 83, 0, 1705, 1706, 3, 124, 62, 0, 1706, 1736, 1, 0, 0, 0, 1707, 1708, 5, 295, 0, 0, 1708, 1709, 3, 166, 83, 0, 1709, 1711, 5, 36, 0, 0, 1710, 1712, 5, 84, 0, 0, 1711, 1710, 1, 0, 0, 0, 1711, 1712, 1, 0, 0, 0, 1712, 1713, 1, 0, 0, 0, 1713, 1714, 5, 30, 0, 0, 1714, 1715, 3, 300, 150, 0, 1715, 1716, 5, 31, 0, 0, 1716, 1736, 1, 0, 0, 0, 1717, 1718, 5, 295, 0, 0, 1718, 1719, 3, 166, 83, 0, 1719, 1720, 5, 84, 0, 0, 1720, 1721, 5, 30, 0, 0, 1721, 1722, 3, 300, 150, 0, 1722, 1723, 5, 31, 0, 0, 1723, 1736, 1, 0, 0, 0, 1724, 1725, 5, 295, 0, 0, 1725, 1726, 3, 166, 83, 0, 1726, 1727, 3, 6, 3, 0, 1727, 1736, 1, 0, 0, 0, 1728, 1729, 5, 295, 0, 0, 1729, 1730, 3, 166, 83, 0, 1730, 1731, 5, 36, 0, 0, 1731, 1732, 5, 17, 0, 0, 1732, 1733, 3, 154, 77, 0, 1733, 1734, 5, 18, 0, 0, 1734, 1736, 1, 0, 0, 0, 1735, 1688, 1, 0, 0, 0, 1735, 1695, 1, 0, 0, 0, 1735, 1703, 1, 0, 0, 0, 1735, 1707, 1, 0, 0, 0, 1735, 1717, 1, 0, 0, 0, 1735, 1724, 1, 0, 0, 0, 1735, 1728, 1, 0, 0, 0, 1736, 153, 1, 0, 0, 0, 1737, 1748, 1, 0, 0, 0, 1738, 1739, 3, 156, 78, 0, 1739, 1740, 5, 28, 0, 0, 1740, 1742, 1, 0, 0, 0, 1741, 1738, 1, 0, 0, 0, 1742, 1745, 1, 0, 0, 0, 1743, 1741, 1, 0, 0, 0, 1743, 1744, 1, 0, 0, 0, 1744, 1746, 1, 0, 0, 0, 1745, 1743, 1, 0, 0, 0, 1746, 1748, 3, 156, 78, 0, 1747, 1737, 1, 0, 0, 0, 1747, 1743, 1, 0, 0, 0, 1748, 155, 1, 0, 0, 0, 1749, 1750, 5, 39, 0, 0, 1750, 1751, 5, 264, 0, 0, 1751, 1752, 5, 36, 0, 0, 1752, 1753, 5, 17, 0, 0, 1753, 1754, 3, 56, 28, 0, 1754, 1755, 5, 18, 0, 0, 1755, 1763, 1, 0, 0, 0, 1756, 1757, 3, 124, 62, 0, 1757, 1758, 5, 36, 0, 0, 1758, 1759, 5, 17, 0, 0, 1759, 1760, 3, 56, 28, 0, 1760, 1761, 5, 18, 0, 0, 1761, 1763, 1, 0, 0, 0, 1762, 1749, 1, 0, 0, 0, 1762, 1756, 1, 0, 0, 0, 1763, 157, 1, 0, 0, 0, 1764, 1765, 3, 160, 80, 0, 1765, 1766, 5, 28, 0, 0, 1766, 1768, 1, 0, 0, 0, 1767, 1764, 1, 0, 0, 0, 1768, 1771, 1, 0, 0, 0, 1769, 1767, 1, 0, 0, 0, 1769, 1770, 1, 0, 0, 0, 1770, 1772, 1, 0, 0, 0, 1771, 1769, 1, 0, 0, 0, 1772, 1773, 3, 160, 80, 0, 1773, 159, 1, 0, 0, 0, 1774, 1775, 3, 6, 3, 0, 1775, 1776, 5, 36, 0, 0, 1776, 1777, 3, 164, 82, 0, 1777, 161, 1, 0, 0, 0, 1778, 1779, 7, 8, 0, 0, 1779, 163, 1, 0, 0, 0, 1780, 1815, 3, 162, 81, 0, 1781, 1815, 3, 32, 16, 0, 1782, 1783, 5, 186, 0, 0, 1783, 1784, 5, 30, 0, 0, 1784, 1785, 3, 32, 16, 0, 1785, 1786, 5, 31, 0, 0, 1786, 1815, 1, 0, 0, 0, 1787, 1815, 3, 6, 3, 0, 1788, 1789, 3, 116, 58, 0, 1789, 1790, 5, 30, 0, 0, 1790, 1791, 5, 184, 0, 0, 1791, 1792, 5, 75, 0, 0, 1792, 1793, 3, 32, 16, 0, 1793, 1794, 5, 31, 0, 0, 1794, 1815, 1, 0, 0, 0, 1795, 1796, 3, 116, 58, 0, 1796, 1797, 5, 30, 0, 0, 1797, 1798, 5, 185, 0, 0, 1798, 1799, 5, 75, 0, 0, 1799, 1800, 3, 32, 16, 0, 1800, 1801, 5, 31, 0, 0, 1801, 1815, 1, 0, 0, 0, 1802, 1803, 3, 116, 58, 0, 1803, 1804, 5, 30, 0, 0, 1804, 1805, 5, 186, 0, 0, 1805, 1806, 5, 75, 0, 0, 1806, 1807, 3, 32, 16, 0, 1807, 1808, 5, 31, 0, 0, 1808, 1815, 1, 0, 0, 0, 1809, 1810, 3, 116, 58, 0, 1810, 1811, 5, 30, 0, 0, 1811, 1812, 3, 32, 16, 0, 1812, 1813, 5, 31, 0, 0, 1813, 1815, 1, 0, 0, 0, 1814, 1780, 1, 0, 0, 0, 1814, 1781, 1, 0, 0, 0, 1814, 1782, 1, 0, 0, 0, 1814, 1787, 1, 0, 0, 0, 1814, 1788, 1, 0, 0, 0, 1814, 1795, 1, 0, 0, 0, 1814, 1802, 1, 0, 0, 0, 1814, 1809, 1, 0, 0, 0, 1815, 165, 1, 0, 0, 0, 1816, 1817, 7, 9, 0, 0, 1817, 167, 1, 0, 0, 0, 1818, 1819, 3, 170, 85, 0, 1819, 1820, 3, 138, 69, 0, 1820, 1821, 3, 124, 62, 0, 1821, 1822, 5, 176, 0, 0, 1822, 1824, 3, 242, 121, 0, 1823, 1825, 3, 108, 54, 0, 1824, 1823, 1, 0, 0, 0, 1824, 1825, 1, 0, 0, 0, 1825, 1826, 1, 0, 0, 0, 1826, 1827, 3, 112, 56, 0, 1827, 1828, 6, 84, -1, 0, 1828, 1861, 1, 0, 0, 0, 1829, 1830, 3, 170, 85, 0, 1830, 1831, 3, 138, 69, 0, 1831, 1832, 3, 124, 62, 0, 1832, 1833, 5, 176, 0, 0, 1833, 1834, 3, 242, 121, 0, 1834, 1835, 3, 196, 98, 0, 1835, 1836, 3, 112, 56, 0, 1836, 1837, 6, 84, -1, 0, 1837, 1861, 1, 0, 0, 0, 1838, 1839, 3, 170, 85, 0, 1839, 1840, 3, 138, 69, 0, 1840, 1842, 3, 242, 121, 0, 1841, 1843, 3, 108, 54, 0, 1842, 1841, 1, 0, 0, 0, 1842, 1843, 1, 0, 0, 0, 1843, 1844, 1, 0, 0, 0, 1844, 1845, 3, 112, 56, 0, 1845, 1846, 6, 84, -1, 0, 1846, 1861, 1, 0, 0, 0, 1847, 1848, 3, 170, 85, 0, 1848, 1849, 3, 138, 69, 0, 1849, 1850, 3, 242, 121, 0, 1850, 1851, 3, 196, 98, 0, 1851, 1852, 3, 112, 56, 0, 1852, 1853, 6, 84, -1, 0, 1853, 1861, 1, 0, 0, 0, 1854, 1855, 3, 174, 87, 0, 1855, 1856, 6, 84, -1, 0, 1856, 1861, 1, 0, 0, 0, 1857, 1858, 3, 2, 1, 0, 1858, 1859, 6, 84, -1, 0, 1859, 1861, 1, 0, 0, 0, 1860, 1818, 1, 0, 0, 0, 1860, 1829, 1, 0, 0, 0, 1860, 1838, 1, 0, 0, 0, 1860, 1847, 1, 0, 0, 0, 1860, 1854, 1, 0, 0, 0, 1860, 1857, 1, 0, 0, 0, 1861, 169, 1, 0, 0, 0, 1862, 1863, 5, 243, 0, 0, 1863, 1864, 3, 170, 85, 0, 1864, 1865, 6, 85, -1, 0, 1865, 1880, 1, 0, 0, 0, 1866, 1867, 5, 244, 0, 0, 1867, 1868, 3, 170, 85, 0, 1868, 1869, 6, 85, -1, 0, 1869, 1880, 1, 0, 0, 0, 1870, 1871, 3, 172, 86, 0, 1871, 1872, 6, 85, -1, 0, 1872, 1880, 1, 0, 0, 0, 1873, 1874, 5, 112, 0, 0, 1874, 1875, 5, 30, 0, 0, 1875, 1876, 3, 32, 16, 0, 1876, 1877, 5, 31, 0, 0, 1877, 1878, 6, 85, -1, 0, 1878, 1880, 1, 0, 0, 0, 1879, 1862, 1, 0, 0, 0, 1879, 1866, 1, 0, 0, 0, 1879, 1870, 1, 0, 0, 0, 1879, 1873, 1, 0, 0, 0, 1880, 171, 1, 0, 0, 0, 1881, 1901, 1, 0, 0, 0, 1882, 1883, 5, 245, 0, 0, 1883, 1901, 6, 86, -1, 0, 1884, 1885, 5, 246, 0, 0, 1885, 1901, 6, 86, -1, 0, 1886, 1887, 5, 247, 0, 0, 1887, 1888, 5, 248, 0, 0, 1888, 1901, 6, 86, -1, 0, 1889, 1890, 5, 247, 0, 0, 1890, 1891, 5, 249, 0, 0, 1891, 1901, 6, 86, -1, 0, 1892, 1893, 5, 247, 0, 0, 1893, 1894, 5, 250, 0, 0, 1894, 1901, 6, 86, -1, 0, 1895, 1896, 5, 247, 0, 0, 1896, 1897, 5, 251, 0, 0, 1897, 1901, 6, 86, -1, 0, 1898, 1899, 5, 247, 0, 0, 1899, 1901, 6, 86, -1, 0, 1900, 1881, 1, 0, 0, 0, 1900, 1882, 1, 0, 0, 0, 1900, 1884, 1, 0, 0, 0, 1900, 1886, 1, 0, 0, 0, 1900, 1889, 1, 0, 0, 0, 1900, 1892, 1, 0, 0, 0, 1900, 1895, 1, 0, 0, 0, 1900, 1898, 1, 0, 0, 0, 1901, 173, 1, 0, 0, 0, 1902, 1903, 5, 113, 0, 0, 1903, 1904, 5, 30, 0, 0, 1904, 1905, 3, 32, 16, 0, 1905, 1906, 5, 31, 0, 0, 1906, 1907, 6, 87, -1, 0, 1907, 175, 1, 0, 0, 0, 1908, 1909, 5, 226, 0, 0, 1909, 1910, 3, 168, 84, 0, 1910, 1911, 6, 88, -1, 0, 1911, 1920, 1, 0, 0, 0, 1912, 1913, 5, 37, 0, 0, 1913, 1914, 3, 178, 89, 0, 1914, 1915, 6, 88, -1, 0, 1915, 1920, 1, 0, 0, 0, 1916, 1917, 3, 174, 87, 0, 1917, 1918, 6, 88, -1, 0, 1918, 1920, 1, 0, 0, 0, 1919, 1908, 1, 0, 0, 0, 1919, 1912, 1, 0, 0, 0, 1919, 1916, 1, 0, 0, 0, 1920, 177, 1, 0, 0, 0, 1921, 1922, 3, 138, 69, 0, 1922, 1923, 3, 124, 62, 0, 1923, 1924, 5, 176, 0, 0, 1924, 1925, 3, 2, 1, 0, 1925, 1926, 6, 89, -1, 0, 1926, 1935, 1, 0, 0, 0, 1927, 1928, 3, 138, 69, 0, 1928, 1929, 3, 2, 1, 0, 1929, 1930, 6, 89, -1, 0, 1930, 1935, 1, 0, 0, 0, 1931, 1932, 3, 2, 1, 0, 1932, 1933, 6, 89, -1, 0, 1933, 1935, 1, 0, 0, 0, 1934, 1921, 1, 0, 0, 0, 1934, 1927, 1, 0, 0, 0, 1934, 1931, 1, 0, 0, 0, 1935, 179, 1, 0, 0, 0, 1936, 1937, 3, 124, 62, 0, 1937, 1938, 5, 28, 0, 0, 1938, 1940, 1, 0, 0, 0, 1939, 1936, 1, 0, 0, 0, 1940, 1943, 1, 0, 0, 0, 1941, 1939, 1, 0, 0, 0, 1941, 1942, 1, 0, 0, 0, 1942, 1944, 1, 0, 0, 0, 1943, 1941, 1, 0, 0, 0, 1944, 1945, 3, 124, 62, 0, 1945, 181, 1, 0, 0, 0, 1946, 1952, 1, 0, 0, 0, 1947, 1948, 5, 86, 0, 0, 1948, 1949, 3, 190, 95, 0, 1949, 1950, 5, 87, 0, 0, 1950, 1952, 1, 0, 0, 0, 1951, 1946, 1, 0, 0, 0, 1951, 1947, 1, 0, 0, 0, 1952, 183, 1, 0, 0, 0, 1953, 1965, 5, 266, 0, 0, 1954, 1965, 5, 114, 0, 0, 1955, 1965, 5, 39, 0, 0, 1956, 1965, 5, 200, 0, 0, 1957, 1965, 5, 115, 0, 0, 1958, 1965, 5, 116, 0, 0, 1959, 1960, 5, 70, 0, 0, 1960, 1961, 5, 30, 0, 0, 1961, 1962, 3, 32, 16, 0, 1962, 1963, 5, 31, 0, 0, 1963, 1965, 1, 0, 0, 0, 1964, 1953, 1, 0, 0, 0, 1964, 1954, 1, 0, 0, 0, 1964, 1955, 1, 0, 0, 0, 1964, 1956, 1, 0, 0, 0, 1964, 1957, 1, 0, 0, 0, 1964, 1958, 1, 0, 0, 0, 1964, 1959, 1, 0, 0, 0, 1965, 185, 1, 0, 0, 0, 1966, 1968, 3, 184, 92, 0, 1967, 1966, 1, 0, 0, 0, 1968, 1971, 1, 0, 0, 0, 1969, 1967, 1, 0, 0, 0, 1969, 1970, 1, 0, 0, 0, 1970, 187, 1, 0, 0, 0, 1971, 1969, 1, 0, 0, 0, 1972, 1974, 3, 186, 93, 0, 1973, 1975, 3, 192, 96, 0, 1974, 1973, 1, 0, 0, 0, 1974, 1975, 1, 0, 0, 0, 1975, 1976, 1, 0, 0, 0, 1976, 1977, 3, 2, 1, 0, 1977, 189, 1, 0, 0, 0, 1978, 1979, 3, 188, 94, 0, 1979, 1980, 5, 28, 0, 0, 1980, 1982, 1, 0, 0, 0, 1981, 1978, 1, 0, 0, 0, 1982, 1985, 1, 0, 0, 0, 1983, 1981, 1, 0, 0, 0, 1983, 1984, 1, 0, 0, 0, 1984, 1986, 1, 0, 0, 0, 1985, 1983, 1, 0, 0, 0, 1986, 1987, 3, 188, 94, 0, 1987, 191, 1, 0, 0, 0, 1988, 1989, 5, 30, 0, 0, 1989, 1990, 3, 180, 90, 0, 1990, 1991, 5, 31, 0, 0, 1991, 193, 1, 0, 0, 0, 1992, 1994, 3, 196, 98, 0, 1993, 1992, 1, 0, 0, 0, 1993, 1994, 1, 0, 0, 0, 1994, 1995, 1, 0, 0, 0, 1995, 1996, 6, 97, -1, 0, 1996, 195, 1, 0, 0, 0, 1997, 1998, 5, 86, 0, 0, 1998, 1999, 5, 42, 0, 0, 1999, 2000, 3, 32, 16, 0, 2000, 2001, 5, 43, 0, 0, 2001, 2002, 5, 87, 0, 0, 2002, 2003, 6, 98, -1, 0, 2003, 197, 1, 0, 0, 0, 2004, 2005, 3, 234, 117, 0, 2005, 2006, 5, 17, 0, 0, 2006, 2007, 3, 246, 123, 0, 2007, 2008, 5, 18, 0, 0, 2008, 2121, 1, 0, 0, 0, 2009, 2010, 3, 74, 37, 0, 2010, 2011, 5, 17, 0, 0, 2011, 2012, 3, 82, 41, 0, 2012, 2013, 5, 18, 0, 0, 2013, 2121, 1, 0, 0, 0, 2014, 2015, 3, 210, 105, 0, 2015, 2016, 5, 17, 0, 0, 2016, 2017, 3, 214, 107, 0, 2017, 2018, 5, 18, 0, 0, 2018, 2121, 1, 0, 0, 0, 2019, 2020, 3, 218, 109, 0, 2020, 2021, 5, 17, 0, 0, 2021, 2022, 3, 222, 111, 0, 2022, 2023, 5, 18, 0, 0, 2023, 2121, 1, 0, 0, 0, 2024, 2121, 3, 200, 100, 0, 2025, 2121, 3, 284, 142, 0, 2026, 2121, 3, 152, 76, 0, 2027, 2121, 3, 88, 44, 0, 2028, 2121, 3, 330, 165, 0, 2029, 2030, 5, 117, 0, 0, 2030, 2121, 3, 32, 16, 0, 2031, 2032, 5, 118, 0, 0, 2032, 2121, 3, 32, 16, 0, 2033, 2034, 3, 342, 171, 0, 2034, 2035, 5, 17, 0, 0, 2035, 2036, 3, 346, 173, 0, 2036, 2037, 5, 18, 0, 0, 2037, 2121, 1, 0, 0, 0, 2038, 2039, 5, 302, 0, 0, 2039, 2040, 3, 124, 62, 0, 2040, 2041, 5, 176, 0, 0, 2041, 2042, 3, 242, 121, 0, 2042, 2043, 5, 119, 0, 0, 2043, 2044, 3, 170, 85, 0, 2044, 2045, 3, 138, 69, 0, 2045, 2046, 3, 124, 62, 0, 2046, 2047, 5, 176, 0, 0, 2047, 2048, 3, 242, 121, 0, 2048, 2049, 3, 112, 56, 0, 2049, 2121, 1, 0, 0, 0, 2050, 2051, 5, 302, 0, 0, 2051, 2052, 5, 226, 0, 0, 2052, 2053, 3, 170, 85, 0, 2053, 2054, 3, 138, 69, 0, 2054, 2055, 3, 124, 62, 0, 2055, 2056, 5, 176, 0, 0, 2056, 2057, 3, 242, 121, 0, 2057, 2058, 3, 194, 97, 0, 2058, 2059, 3, 112, 56, 0, 2059, 2060, 5, 119, 0, 0, 2060, 2061, 5, 226, 0, 0, 2061, 2062, 3, 170, 85, 0, 2062, 2063, 3, 138, 69, 0, 2063, 2064, 3, 124, 62, 0, 2064, 2065, 5, 176, 0, 0, 2065, 2066, 3, 242, 121, 0, 2066, 2067, 3, 194, 97, 0, 2067, 2068, 3, 112, 56, 0, 2068, 2121, 1, 0, 0, 0, 2069, 2121, 3, 26, 13, 0, 2070, 2121, 3, 40, 20, 0, 2071, 2072, 5, 255, 0, 0, 2072, 2073, 5, 196, 0, 0, 2073, 2074, 5, 42, 0, 0, 2074, 2075, 3, 32, 16, 0, 2075, 2079, 5, 43, 0, 0, 2076, 2078, 3, 330, 165, 0, 2077, 2076, 1, 0, 0, 0, 2078, 2081, 1, 0, 0, 0, 2079, 2077, 1, 0, 0, 0, 2079, 2080, 1, 0, 0, 0, 2080, 2121, 1, 0, 0, 0, 2081, 2079, 1, 0, 0, 0, 2082, 2083, 5, 255, 0, 0, 2083, 2084, 5, 196, 0, 0, 2084, 2088, 3, 2, 1, 0, 2085, 2087, 3, 330, 165, 0, 2086, 2085, 1, 0, 0, 0, 2087, 2090, 1, 0, 0, 0, 2088, 2086, 1, 0, 0, 0, 2088, 2089, 1, 0, 0, 0, 2089, 2121, 1, 0, 0, 0, 2090, 2088, 1, 0, 0, 0, 2091, 2092, 5, 255, 0, 0, 2092, 2093, 5, 256, 0, 0, 2093, 2094, 5, 42, 0, 0, 2094, 2095, 3, 32, 16, 0, 2095, 2096, 5, 43, 0, 0, 2096, 2097, 5, 28, 0, 0, 2097, 2101, 3, 124, 62, 0, 2098, 2100, 3, 330, 165, 0, 2099, 2098, 1, 0, 0, 0, 2100, 2103, 1, 0, 0, 0, 2101, 2099, 1, 0, 0, 0, 2101, 2102, 1, 0, 0, 0, 2102, 2121, 1, 0, 0, 0, 2103, 2101, 1, 0, 0, 0, 2104, 2105, 5, 255, 0, 0, 2105, 2106, 5, 256, 0, 0, 2106, 2107, 3, 2, 1, 0, 2107, 2108, 5, 28, 0, 0, 2108, 2112, 3, 124, 62, 0, 2109, 2111, 3, 330, 165, 0, 2110, 2109, 1, 0, 0, 0, 2111, 2114, 1, 0, 0, 0, 2112, 2110, 1, 0, 0, 0, 2112, 2113, 1, 0, 0, 0, 2113, 2121, 1, 0, 0, 0, 2114, 2112, 1, 0, 0, 0, 2115, 2116, 5, 120, 0, 0, 2116, 2117, 5, 196, 0, 0, 2117, 2118, 3, 124, 62, 0, 2118, 2119, 3, 44, 22, 0, 2119, 2121, 1, 0, 0, 0, 2120, 2004, 1, 0, 0, 0, 2120, 2009, 1, 0, 0, 0, 2120, 2014, 1, 0, 0, 0, 2120, 2019, 1, 0, 0, 0, 2120, 2024, 1, 0, 0, 0, 2120, 2025, 1, 0, 0, 0, 2120, 2026, 1, 0, 0, 0, 2120, 2027, 1, 0, 0, 0, 2120, 2028, 1, 0, 0, 0, 2120, 2029, 1, 0, 0, 0, 2120, 2031, 1, 0, 0, 0, 2120, 2033, 1, 0, 0, 0, 2120, 2038, 1, 0, 0, 0, 2120, 2050, 1, 0, 0, 0, 2120, 2069, 1, 0, 0, 0, 2120, 2070, 1, 0, 0, 0, 2120, 2071, 1, 0, 0, 0, 2120, 2082, 1, 0, 0, 0, 2120, 2091, 1, 0, 0, 0, 2120, 2104, 1, 0, 0, 0, 2120, 2115, 1, 0, 0, 0, 2121, 199, 1, 0, 0, 0, 2122, 2123, 5, 121, 0, 0, 2123, 2132, 3, 208, 104, 0, 2124, 2131, 3, 202, 101, 0, 2125, 2126, 5, 122, 0, 0, 2126, 2127, 5, 30, 0, 0, 2127, 2128, 3, 228, 114, 0, 2128, 2129, 5, 31, 0, 0, 2129, 2131, 1, 0, 0, 0, 2130, 2124, 1, 0, 0, 0, 2130, 2125, 1, 0, 0, 0, 2131, 2134, 1, 0, 0, 0, 2132, 2130, 1, 0, 0, 0, 2132, 2133, 1, 0, 0, 0, 2133, 2135, 1, 0, 0, 0, 2134, 2132, 1, 0, 0, 0, 2135, 2136, 3, 138, 69, 0, 2136, 2137, 3, 2, 1, 0, 2137, 2138, 3, 204, 102, 0, 2138, 2139, 3, 206, 103, 0, 2139, 201, 1, 0, 0, 0, 2140, 2160, 5, 123, 0, 0, 2141, 2160, 5, 51, 0, 0, 2142, 2160, 5, 52, 0, 0, 2143, 2160, 5, 63, 0, 0, 2144, 2160, 5, 124, 0, 0, 2145, 2160, 5, 69, 0, 0, 2146, 2160, 5, 68, 0, 0, 2147, 2160, 5, 64, 0, 0, 2148, 2160, 5, 65, 0, 0, 2149, 2160, 5, 66, 0, 0, 2150, 2160, 5, 125, 0, 0, 2151, 2160, 5, 126, 0, 0, 2152, 2160, 5, 127, 0, 0, 2153, 2160, 5, 16, 0, 0, 2154, 2155, 5, 70, 0, 0, 2155, 2156, 5, 30, 0, 0, 2156, 2157, 3, 32, 16, 0, 2157, 2158, 5, 31, 0, 0, 2158, 2160, 1, 0, 0, 0, 2159, 2140, 1, 0, 0, 0, 2159, 2141, 1, 0, 0, 0, 2159, 2142, 1, 0, 0, 0, 2159, 2143, 1, 0, 0, 0, 2159, 2144, 1, 0, 0, 0, 2159, 2145, 1, 0, 0, 0, 2159, 2146, 1, 0, 0, 0, 2159, 2147, 1, 0, 0, 0, 2159, 2148, 1, 0, 0, 0, 2159, 2149, 1, 0, 0, 0, 2159, 2150, 1, 0, 0, 0, 2159, 2151, 1, 0, 0, 0, 2159, 2152, 1, 0, 0, 0, 2159, 2153, 1, 0, 0, 0, 2159, 2154, 1, 0, 0, 0, 2160, 203, 1, 0, 0, 0, 2161, 2167, 1, 0, 0, 0, 2162, 2163, 5, 44, 0, 0, 2163, 2167, 3, 0, 0, 0, 2164, 2165, 5, 44, 0, 0, 2165, 2167, 3, 32, 16, 0, 2166, 2161, 1, 0, 0, 0, 2166, 2162, 1, 0, 0, 0, 2166, 2164, 1, 0, 0, 0, 2167, 205, 1, 0, 0, 0, 2168, 2172, 1, 0, 0, 0, 2169, 2170, 5, 36, 0, 0, 2170, 2172, 3, 304, 152, 0, 2171, 2168, 1, 0, 0, 0, 2171, 2169, 1, 0, 0, 0, 2172, 207, 1, 0, 0, 0, 2173, 2179, 1, 0, 0, 0, 2174, 2175, 5, 42, 0, 0, 2175, 2176, 3, 32, 16, 0, 2176, 2177, 5, 43, 0, 0, 2177, 2179, 1, 0, 0, 0, 2178, 2173, 1, 0, 0, 0, 2178, 2174, 1, 0, 0, 0, 2179, 209, 1, 0, 0, 0, 2180, 2184, 5, 128, 0, 0, 2181, 2183, 3, 212, 106, 0, 2182, 2181, 1, 0, 0, 0, 2183, 2186, 1, 0, 0, 0, 2184, 2182, 1, 0, 0, 0, 2184, 2185, 1, 0, 0, 0, 2185, 2187, 1, 0, 0, 0, 2186, 2184, 1, 0, 0, 0, 2187, 2188, 3, 124, 62, 0, 2188, 2189, 3, 2, 1, 0, 2189, 2199, 1, 0, 0, 0, 2190, 2194, 5, 128, 0, 0, 2191, 2193, 3, 212, 106, 0, 2192, 2191, 1, 0, 0, 0, 2193, 2196, 1, 0, 0, 0, 2194, 2192, 1, 0, 0, 0, 2194, 2195, 1, 0, 0, 0, 2195, 2197, 1, 0, 0, 0, 2196, 2194, 1, 0, 0, 0, 2197, 2199, 3, 2, 1, 0, 2198, 2180, 1, 0, 0, 0, 2198, 2190, 1, 0, 0, 0, 2199, 211, 1, 0, 0, 0, 2200, 2201, 7, 10, 0, 0, 2201, 213, 1, 0, 0, 0, 2202, 2204, 3, 216, 108, 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, 215, 1, 0, 0, 0, 2207, 2205, 1, 0, 0, 0, 2208, 2209, 5, 129, 0, 0, 2209, 2221, 3, 168, 84, 0, 2210, 2211, 5, 130, 0, 0, 2211, 2221, 3, 168, 84, 0, 2212, 2213, 5, 131, 0, 0, 2213, 2221, 3, 168, 84, 0, 2214, 2215, 5, 132, 0, 0, 2215, 2221, 3, 168, 84, 0, 2216, 2221, 3, 88, 44, 0, 2217, 2221, 3, 330, 165, 0, 2218, 2221, 3, 26, 13, 0, 2219, 2221, 3, 40, 20, 0, 2220, 2208, 1, 0, 0, 0, 2220, 2210, 1, 0, 0, 0, 2220, 2212, 1, 0, 0, 0, 2220, 2214, 1, 0, 0, 0, 2220, 2216, 1, 0, 0, 0, 2220, 2217, 1, 0, 0, 0, 2220, 2218, 1, 0, 0, 0, 2220, 2219, 1, 0, 0, 0, 2221, 217, 1, 0, 0, 0, 2222, 2226, 5, 133, 0, 0, 2223, 2225, 3, 220, 110, 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, 2230, 3, 170, 85, 0, 2230, 2231, 3, 138, 69, 0, 2231, 2232, 3, 2, 1, 0, 2232, 2233, 3, 112, 56, 0, 2233, 2234, 3, 206, 103, 0, 2234, 219, 1, 0, 0, 0, 2235, 2236, 7, 10, 0, 0, 2236, 221, 1, 0, 0, 0, 2237, 2239, 3, 224, 112, 0, 2238, 2237, 1, 0, 0, 0, 2239, 2242, 1, 0, 0, 0, 2240, 2238, 1, 0, 0, 0, 2240, 2241, 1, 0, 0, 0, 2241, 223, 1, 0, 0, 0, 2242, 2240, 1, 0, 0, 0, 2243, 2244, 5, 134, 0, 0, 2244, 2254, 3, 168, 84, 0, 2245, 2246, 5, 135, 0, 0, 2246, 2254, 3, 168, 84, 0, 2247, 2248, 5, 132, 0, 0, 2248, 2254, 3, 168, 84, 0, 2249, 2254, 3, 330, 165, 0, 2250, 2254, 3, 88, 44, 0, 2251, 2254, 3, 26, 13, 0, 2252, 2254, 3, 40, 20, 0, 2253, 2243, 1, 0, 0, 0, 2253, 2245, 1, 0, 0, 0, 2253, 2247, 1, 0, 0, 0, 2253, 2249, 1, 0, 0, 0, 2253, 2250, 1, 0, 0, 0, 2253, 2251, 1, 0, 0, 0, 2253, 2252, 1, 0, 0, 0, 2254, 225, 1, 0, 0, 0, 2255, 2263, 6, 113, -1, 0, 2256, 2257, 5, 122, 0, 0, 2257, 2258, 5, 30, 0, 0, 2258, 2259, 3, 228, 114, 0, 2259, 2260, 5, 31, 0, 0, 2260, 2261, 6, 113, -1, 0, 2261, 2263, 1, 0, 0, 0, 2262, 2255, 1, 0, 0, 0, 2262, 2256, 1, 0, 0, 0, 2263, 227, 1, 0, 0, 0, 2264, 2265, 3, 126, 63, 0, 2265, 2266, 6, 114, -1, 0, 2266, 2278, 1, 0, 0, 0, 2267, 2271, 5, 17, 0, 0, 2268, 2269, 3, 302, 151, 0, 2269, 2270, 6, 114, -1, 0, 2270, 2272, 1, 0, 0, 0, 2271, 2268, 1, 0, 0, 0, 2272, 2273, 1, 0, 0, 0, 2273, 2271, 1, 0, 0, 0, 2273, 2274, 1, 0, 0, 0, 2274, 2275, 1, 0, 0, 0, 2275, 2276, 5, 18, 0, 0, 2276, 2278, 1, 0, 0, 0, 2277, 2264, 1, 0, 0, 0, 2277, 2267, 1, 0, 0, 0, 2278, 229, 1, 0, 0, 0, 2279, 2280, 3, 232, 116, 0, 2280, 2281, 6, 115, -1, 0, 2281, 2283, 1, 0, 0, 0, 2282, 2279, 1, 0, 0, 0, 2283, 2286, 1, 0, 0, 0, 2284, 2282, 1, 0, 0, 0, 2284, 2285, 1, 0, 0, 0, 2285, 231, 1, 0, 0, 0, 2286, 2284, 1, 0, 0, 0, 2287, 2288, 5, 42, 0, 0, 2288, 2289, 5, 136, 0, 0, 2289, 2290, 5, 43, 0, 0, 2290, 2305, 6, 116, -1, 0, 2291, 2292, 5, 42, 0, 0, 2292, 2293, 5, 137, 0, 0, 2293, 2294, 5, 43, 0, 0, 2294, 2305, 6, 116, -1, 0, 2295, 2296, 5, 42, 0, 0, 2296, 2297, 5, 138, 0, 0, 2297, 2298, 5, 43, 0, 0, 2298, 2305, 6, 116, -1, 0, 2299, 2300, 5, 42, 0, 0, 2300, 2301, 3, 32, 16, 0, 2301, 2302, 5, 43, 0, 0, 2302, 2303, 6, 116, -1, 0, 2303, 2305, 1, 0, 0, 0, 2304, 2287, 1, 0, 0, 0, 2304, 2291, 1, 0, 0, 0, 2304, 2295, 1, 0, 0, 0, 2304, 2299, 1, 0, 0, 0, 2305, 233, 1, 0, 0, 0, 2306, 2311, 5, 139, 0, 0, 2307, 2310, 3, 236, 118, 0, 2308, 2310, 3, 238, 119, 0, 2309, 2307, 1, 0, 0, 0, 2309, 2308, 1, 0, 0, 0, 2310, 2313, 1, 0, 0, 0, 2311, 2309, 1, 0, 0, 0, 2311, 2312, 1, 0, 0, 0, 2312, 2314, 1, 0, 0, 0, 2313, 2311, 1, 0, 0, 0, 2314, 2315, 3, 170, 85, 0, 2315, 2316, 3, 230, 115, 0, 2316, 2317, 3, 138, 69, 0, 2317, 2318, 3, 226, 113, 0, 2318, 2319, 3, 242, 121, 0, 2319, 2320, 3, 182, 91, 0, 2320, 2324, 3, 112, 56, 0, 2321, 2323, 3, 244, 122, 0, 2322, 2321, 1, 0, 0, 0, 2323, 2326, 1, 0, 0, 0, 2324, 2322, 1, 0, 0, 0, 2324, 2325, 1, 0, 0, 0, 2325, 235, 1, 0, 0, 0, 2326, 2324, 1, 0, 0, 0, 2327, 2351, 5, 123, 0, 0, 2328, 2351, 5, 51, 0, 0, 2329, 2351, 5, 52, 0, 0, 2330, 2351, 5, 63, 0, 0, 2331, 2351, 5, 140, 0, 0, 2332, 2351, 5, 68, 0, 0, 2333, 2351, 5, 141, 0, 0, 2334, 2351, 5, 142, 0, 0, 2335, 2351, 5, 54, 0, 0, 2336, 2351, 5, 64, 0, 0, 2337, 2351, 5, 65, 0, 0, 2338, 2351, 5, 66, 0, 0, 2339, 2351, 5, 125, 0, 0, 2340, 2351, 5, 143, 0, 0, 2341, 2351, 5, 144, 0, 0, 2342, 2351, 5, 69, 0, 0, 2343, 2351, 5, 145, 0, 0, 2344, 2351, 5, 146, 0, 0, 2345, 2346, 5, 70, 0, 0, 2346, 2347, 5, 30, 0, 0, 2347, 2348, 3, 32, 16, 0, 2348, 2349, 5, 31, 0, 0, 2349, 2351, 1, 0, 0, 0, 2350, 2327, 1, 0, 0, 0, 2350, 2328, 1, 0, 0, 0, 2350, 2329, 1, 0, 0, 0, 2350, 2330, 1, 0, 0, 0, 2350, 2331, 1, 0, 0, 0, 2350, 2332, 1, 0, 0, 0, 2350, 2333, 1, 0, 0, 0, 2350, 2334, 1, 0, 0, 0, 2350, 2335, 1, 0, 0, 0, 2350, 2336, 1, 0, 0, 0, 2350, 2337, 1, 0, 0, 0, 2350, 2338, 1, 0, 0, 0, 2350, 2339, 1, 0, 0, 0, 2350, 2340, 1, 0, 0, 0, 2350, 2341, 1, 0, 0, 0, 2350, 2342, 1, 0, 0, 0, 2350, 2343, 1, 0, 0, 0, 2350, 2344, 1, 0, 0, 0, 2350, 2345, 1, 0, 0, 0, 2351, 237, 1, 0, 0, 0, 2352, 2353, 5, 147, 0, 0, 2353, 2359, 5, 30, 0, 0, 2354, 2357, 3, 6, 3, 0, 2355, 2356, 5, 34, 0, 0, 2356, 2358, 3, 6, 3, 0, 2357, 2355, 1, 0, 0, 0, 2357, 2358, 1, 0, 0, 0, 2358, 2360, 1, 0, 0, 0, 2359, 2354, 1, 0, 0, 0, 2359, 2360, 1, 0, 0, 0, 2360, 2364, 1, 0, 0, 0, 2361, 2363, 3, 240, 120, 0, 2362, 2361, 1, 0, 0, 0, 2363, 2366, 1, 0, 0, 0, 2364, 2362, 1, 0, 0, 0, 2364, 2365, 1, 0, 0, 0, 2365, 2367, 1, 0, 0, 0, 2366, 2364, 1, 0, 0, 0, 2367, 2371, 5, 31, 0, 0, 2368, 2369, 5, 147, 0, 0, 2369, 2371, 5, 85, 0, 0, 2370, 2352, 1, 0, 0, 0, 2370, 2368, 1, 0, 0, 0, 2371, 239, 1, 0, 0, 0, 2372, 2400, 5, 148, 0, 0, 2373, 2400, 5, 224, 0, 0, 2374, 2400, 5, 57, 0, 0, 2375, 2400, 5, 58, 0, 0, 2376, 2400, 5, 149, 0, 0, 2377, 2400, 5, 150, 0, 0, 2378, 2400, 5, 248, 0, 0, 2379, 2400, 5, 249, 0, 0, 2380, 2400, 5, 250, 0, 0, 2381, 2400, 5, 251, 0, 0, 2382, 2383, 5, 151, 0, 0, 2383, 2384, 5, 75, 0, 0, 2384, 2400, 5, 152, 0, 0, 2385, 2386, 5, 151, 0, 0, 2386, 2387, 5, 75, 0, 0, 2387, 2400, 5, 153, 0, 0, 2388, 2389, 5, 154, 0, 0, 2389, 2390, 5, 75, 0, 0, 2390, 2400, 5, 152, 0, 0, 2391, 2392, 5, 154, 0, 0, 2392, 2393, 5, 75, 0, 0, 2393, 2400, 5, 153, 0, 0, 2394, 2395, 5, 70, 0, 0, 2395, 2396, 5, 30, 0, 0, 2396, 2397, 3, 32, 16, 0, 2397, 2398, 5, 31, 0, 0, 2398, 2400, 1, 0, 0, 0, 2399, 2372, 1, 0, 0, 0, 2399, 2373, 1, 0, 0, 0, 2399, 2374, 1, 0, 0, 0, 2399, 2375, 1, 0, 0, 0, 2399, 2376, 1, 0, 0, 0, 2399, 2377, 1, 0, 0, 0, 2399, 2378, 1, 0, 0, 0, 2399, 2379, 1, 0, 0, 0, 2399, 2380, 1, 0, 0, 0, 2399, 2381, 1, 0, 0, 0, 2399, 2382, 1, 0, 0, 0, 2399, 2385, 1, 0, 0, 0, 2399, 2388, 1, 0, 0, 0, 2399, 2391, 1, 0, 0, 0, 2399, 2394, 1, 0, 0, 0, 2400, 241, 1, 0, 0, 0, 2401, 2402, 5, 116, 0, 0, 2402, 2409, 6, 121, -1, 0, 2403, 2404, 5, 155, 0, 0, 2404, 2409, 6, 121, -1, 0, 2405, 2406, 3, 2, 1, 0, 2406, 2407, 6, 121, -1, 0, 2407, 2409, 1, 0, 0, 0, 2408, 2401, 1, 0, 0, 0, 2408, 2403, 1, 0, 0, 0, 2408, 2405, 1, 0, 0, 0, 2409, 243, 1, 0, 0, 0, 2410, 2432, 5, 1, 0, 0, 2411, 2432, 5, 2, 0, 0, 2412, 2432, 5, 156, 0, 0, 2413, 2432, 5, 3, 0, 0, 2414, 2432, 5, 4, 0, 0, 2415, 2432, 5, 247, 0, 0, 2416, 2432, 5, 5, 0, 0, 2417, 2432, 5, 6, 0, 0, 2418, 2432, 5, 7, 0, 0, 2419, 2432, 5, 8, 0, 0, 2420, 2432, 5, 9, 0, 0, 2421, 2432, 5, 10, 0, 0, 2422, 2432, 5, 11, 0, 0, 2423, 2432, 5, 12, 0, 0, 2424, 2432, 5, 13, 0, 0, 2425, 2432, 5, 14, 0, 0, 2426, 2427, 5, 70, 0, 0, 2427, 2428, 5, 30, 0, 0, 2428, 2429, 3, 32, 16, 0, 2429, 2430, 5, 31, 0, 0, 2430, 2432, 1, 0, 0, 0, 2431, 2410, 1, 0, 0, 0, 2431, 2411, 1, 0, 0, 0, 2431, 2412, 1, 0, 0, 0, 2431, 2413, 1, 0, 0, 0, 2431, 2414, 1, 0, 0, 0, 2431, 2415, 1, 0, 0, 0, 2431, 2416, 1, 0, 0, 0, 2431, 2417, 1, 0, 0, 0, 2431, 2418, 1, 0, 0, 0, 2431, 2419, 1, 0, 0, 0, 2431, 2420, 1, 0, 0, 0, 2431, 2421, 1, 0, 0, 0, 2431, 2422, 1, 0, 0, 0, 2431, 2423, 1, 0, 0, 0, 2431, 2424, 1, 0, 0, 0, 2431, 2425, 1, 0, 0, 0, 2431, 2426, 1, 0, 0, 0, 2432, 245, 1, 0, 0, 0, 2433, 2435, 3, 248, 124, 0, 2434, 2433, 1, 0, 0, 0, 2435, 2438, 1, 0, 0, 0, 2436, 2434, 1, 0, 0, 0, 2436, 2437, 1, 0, 0, 0, 2437, 247, 1, 0, 0, 0, 2438, 2436, 1, 0, 0, 0, 2439, 2477, 3, 100, 50, 0, 2440, 2441, 5, 296, 0, 0, 2441, 2442, 3, 32, 16, 0, 2442, 2443, 6, 124, -1, 0, 2443, 2477, 1, 0, 0, 0, 2444, 2477, 3, 266, 133, 0, 2445, 2446, 5, 297, 0, 0, 2446, 2447, 3, 32, 16, 0, 2447, 2448, 6, 124, -1, 0, 2448, 2477, 1, 0, 0, 0, 2449, 2450, 5, 298, 0, 0, 2450, 2477, 6, 124, -1, 0, 2451, 2452, 5, 299, 0, 0, 2452, 2477, 6, 124, -1, 0, 2453, 2477, 3, 260, 130, 0, 2454, 2477, 3, 264, 132, 0, 2455, 2477, 3, 250, 125, 0, 2456, 2457, 3, 284, 142, 0, 2457, 2458, 6, 124, -1, 0, 2458, 2477, 1, 0, 0, 0, 2459, 2460, 3, 152, 76, 0, 2460, 2461, 6, 124, -1, 0, 2461, 2477, 1, 0, 0, 0, 2462, 2463, 3, 88, 44, 0, 2463, 2464, 6, 124, -1, 0, 2464, 2477, 1, 0, 0, 0, 2465, 2466, 3, 26, 13, 0, 2466, 2467, 6, 124, -1, 0, 2467, 2477, 1, 0, 0, 0, 2468, 2469, 3, 262, 131, 0, 2469, 2470, 6, 124, -1, 0, 2470, 2477, 1, 0, 0, 0, 2471, 2477, 3, 40, 20, 0, 2472, 2477, 3, 252, 126, 0, 2473, 2477, 3, 254, 127, 0, 2474, 2477, 3, 256, 128, 0, 2475, 2477, 3, 258, 129, 0, 2476, 2439, 1, 0, 0, 0, 2476, 2440, 1, 0, 0, 0, 2476, 2444, 1, 0, 0, 0, 2476, 2445, 1, 0, 0, 0, 2476, 2449, 1, 0, 0, 0, 2476, 2451, 1, 0, 0, 0, 2476, 2453, 1, 0, 0, 0, 2476, 2454, 1, 0, 0, 0, 2476, 2455, 1, 0, 0, 0, 2476, 2456, 1, 0, 0, 0, 2476, 2459, 1, 0, 0, 0, 2476, 2462, 1, 0, 0, 0, 2476, 2465, 1, 0, 0, 0, 2476, 2468, 1, 0, 0, 0, 2476, 2471, 1, 0, 0, 0, 2476, 2472, 1, 0, 0, 0, 2476, 2473, 1, 0, 0, 0, 2476, 2474, 1, 0, 0, 0, 2476, 2475, 1, 0, 0, 0, 2477, 249, 1, 0, 0, 0, 2478, 2480, 5, 300, 0, 0, 2479, 2481, 5, 157, 0, 0, 2480, 2479, 1, 0, 0, 0, 2480, 2481, 1, 0, 0, 0, 2481, 2482, 1, 0, 0, 0, 2482, 2483, 3, 112, 56, 0, 2483, 251, 1, 0, 0, 0, 2484, 2485, 5, 301, 0, 0, 2485, 2486, 5, 42, 0, 0, 2486, 2487, 3, 32, 16, 0, 2487, 2490, 5, 43, 0, 0, 2488, 2489, 5, 34, 0, 0, 2489, 2491, 3, 0, 0, 0, 2490, 2488, 1, 0, 0, 0, 2490, 2491, 1, 0, 0, 0, 2491, 253, 1, 0, 0, 0, 2492, 2493, 5, 303, 0, 0, 2493, 2494, 3, 32, 16, 0, 2494, 2495, 5, 75, 0, 0, 2495, 2496, 3, 32, 16, 0, 2496, 255, 1, 0, 0, 0, 2497, 2498, 5, 302, 0, 0, 2498, 2499, 3, 124, 62, 0, 2499, 2500, 5, 176, 0, 0, 2500, 2501, 3, 242, 121, 0, 2501, 2513, 1, 0, 0, 0, 2502, 2503, 5, 302, 0, 0, 2503, 2504, 5, 226, 0, 0, 2504, 2505, 3, 170, 85, 0, 2505, 2506, 3, 138, 69, 0, 2506, 2507, 3, 124, 62, 0, 2507, 2508, 5, 176, 0, 0, 2508, 2509, 3, 242, 121, 0, 2509, 2510, 3, 194, 97, 0, 2510, 2511, 3, 112, 56, 0, 2511, 2513, 1, 0, 0, 0, 2512, 2497, 1, 0, 0, 0, 2512, 2502, 1, 0, 0, 0, 2513, 257, 1, 0, 0, 0, 2514, 2515, 5, 255, 0, 0, 2515, 2516, 5, 196, 0, 0, 2516, 2517, 5, 42, 0, 0, 2517, 2518, 3, 32, 16, 0, 2518, 2524, 5, 43, 0, 0, 2519, 2520, 3, 330, 165, 0, 2520, 2521, 6, 129, -1, 0, 2521, 2523, 1, 0, 0, 0, 2522, 2519, 1, 0, 0, 0, 2523, 2526, 1, 0, 0, 0, 2524, 2522, 1, 0, 0, 0, 2524, 2525, 1, 0, 0, 0, 2525, 2580, 1, 0, 0, 0, 2526, 2524, 1, 0, 0, 0, 2527, 2528, 5, 255, 0, 0, 2528, 2529, 5, 196, 0, 0, 2529, 2535, 3, 2, 1, 0, 2530, 2531, 3, 330, 165, 0, 2531, 2532, 6, 129, -1, 0, 2532, 2534, 1, 0, 0, 0, 2533, 2530, 1, 0, 0, 0, 2534, 2537, 1, 0, 0, 0, 2535, 2533, 1, 0, 0, 0, 2535, 2536, 1, 0, 0, 0, 2536, 2580, 1, 0, 0, 0, 2537, 2535, 1, 0, 0, 0, 2538, 2539, 5, 255, 0, 0, 2539, 2540, 5, 256, 0, 0, 2540, 2541, 5, 42, 0, 0, 2541, 2542, 3, 32, 16, 0, 2542, 2543, 5, 43, 0, 0, 2543, 2544, 5, 28, 0, 0, 2544, 2550, 3, 124, 62, 0, 2545, 2546, 3, 330, 165, 0, 2546, 2547, 6, 129, -1, 0, 2547, 2549, 1, 0, 0, 0, 2548, 2545, 1, 0, 0, 0, 2549, 2552, 1, 0, 0, 0, 2550, 2548, 1, 0, 0, 0, 2550, 2551, 1, 0, 0, 0, 2551, 2580, 1, 0, 0, 0, 2552, 2550, 1, 0, 0, 0, 2553, 2554, 5, 255, 0, 0, 2554, 2555, 5, 256, 0, 0, 2555, 2556, 3, 2, 1, 0, 2556, 2557, 5, 28, 0, 0, 2557, 2563, 3, 124, 62, 0, 2558, 2559, 3, 330, 165, 0, 2559, 2560, 6, 129, -1, 0, 2560, 2562, 1, 0, 0, 0, 2561, 2558, 1, 0, 0, 0, 2562, 2565, 1, 0, 0, 0, 2563, 2561, 1, 0, 0, 0, 2563, 2564, 1, 0, 0, 0, 2564, 2580, 1, 0, 0, 0, 2565, 2563, 1, 0, 0, 0, 2566, 2567, 5, 255, 0, 0, 2567, 2568, 5, 42, 0, 0, 2568, 2569, 3, 32, 16, 0, 2569, 2570, 5, 43, 0, 0, 2570, 2576, 3, 206, 103, 0, 2571, 2572, 3, 330, 165, 0, 2572, 2573, 6, 129, -1, 0, 2573, 2575, 1, 0, 0, 0, 2574, 2571, 1, 0, 0, 0, 2575, 2578, 1, 0, 0, 0, 2576, 2574, 1, 0, 0, 0, 2576, 2577, 1, 0, 0, 0, 2577, 2580, 1, 0, 0, 0, 2578, 2576, 1, 0, 0, 0, 2579, 2514, 1, 0, 0, 0, 2579, 2527, 1, 0, 0, 0, 2579, 2538, 1, 0, 0, 0, 2579, 2553, 1, 0, 0, 0, 2579, 2566, 1, 0, 0, 0, 2580, 259, 1, 0, 0, 0, 2581, 2582, 3, 0, 0, 0, 2582, 2583, 5, 75, 0, 0, 2583, 2584, 6, 130, -1, 0, 2584, 261, 1, 0, 0, 0, 2585, 2588, 3, 44, 22, 0, 2586, 2588, 3, 46, 23, 0, 2587, 2585, 1, 0, 0, 0, 2587, 2586, 1, 0, 0, 0, 2588, 263, 1, 0, 0, 0, 2589, 2590, 5, 17, 0, 0, 2590, 2591, 3, 246, 123, 0, 2591, 2592, 5, 18, 0, 0, 2592, 265, 1, 0, 0, 0, 2593, 2594, 3, 270, 135, 0, 2594, 2595, 3, 268, 134, 0, 2595, 267, 1, 0, 0, 0, 2596, 2597, 3, 272, 136, 0, 2597, 2598, 6, 134, -1, 0, 2598, 2600, 1, 0, 0, 0, 2599, 2596, 1, 0, 0, 0, 2600, 2601, 1, 0, 0, 0, 2601, 2599, 1, 0, 0, 0, 2601, 2602, 1, 0, 0, 0, 2602, 269, 1, 0, 0, 0, 2603, 2604, 5, 158, 0, 0, 2604, 2605, 3, 264, 132, 0, 2605, 2606, 6, 135, -1, 0, 2606, 2620, 1, 0, 0, 0, 2607, 2608, 5, 158, 0, 0, 2608, 2609, 3, 0, 0, 0, 2609, 2610, 5, 159, 0, 0, 2610, 2611, 3, 0, 0, 0, 2611, 2612, 6, 135, -1, 0, 2612, 2620, 1, 0, 0, 0, 2613, 2614, 5, 158, 0, 0, 2614, 2615, 3, 32, 16, 0, 2615, 2616, 5, 159, 0, 0, 2616, 2617, 3, 32, 16, 0, 2617, 2618, 6, 135, -1, 0, 2618, 2620, 1, 0, 0, 0, 2619, 2603, 1, 0, 0, 0, 2619, 2607, 1, 0, 0, 0, 2619, 2613, 1, 0, 0, 0, 2620, 271, 1, 0, 0, 0, 2621, 2622, 3, 276, 138, 0, 2622, 2623, 3, 282, 141, 0, 2623, 2624, 6, 136, -1, 0, 2624, 2638, 1, 0, 0, 0, 2625, 2626, 3, 274, 137, 0, 2626, 2627, 3, 282, 141, 0, 2627, 2628, 6, 136, -1, 0, 2628, 2638, 1, 0, 0, 0, 2629, 2630, 3, 278, 139, 0, 2630, 2631, 3, 282, 141, 0, 2631, 2632, 6, 136, -1, 0, 2632, 2638, 1, 0, 0, 0, 2633, 2634, 3, 280, 140, 0, 2634, 2635, 3, 282, 141, 0, 2635, 2636, 6, 136, -1, 0, 2636, 2638, 1, 0, 0, 0, 2637, 2621, 1, 0, 0, 0, 2637, 2625, 1, 0, 0, 0, 2637, 2629, 1, 0, 0, 0, 2637, 2633, 1, 0, 0, 0, 2638, 273, 1, 0, 0, 0, 2639, 2640, 5, 160, 0, 0, 2640, 2641, 3, 264, 132, 0, 2641, 2642, 6, 137, -1, 0, 2642, 2652, 1, 0, 0, 0, 2643, 2644, 5, 160, 0, 0, 2644, 2645, 3, 0, 0, 0, 2645, 2646, 6, 137, -1, 0, 2646, 2652, 1, 0, 0, 0, 2647, 2648, 5, 160, 0, 0, 2648, 2649, 3, 32, 16, 0, 2649, 2650, 6, 137, -1, 0, 2650, 2652, 1, 0, 0, 0, 2651, 2639, 1, 0, 0, 0, 2651, 2643, 1, 0, 0, 0, 2651, 2647, 1, 0, 0, 0, 2652, 275, 1, 0, 0, 0, 2653, 2654, 5, 161, 0, 0, 2654, 2655, 3, 124, 62, 0, 2655, 277, 1, 0, 0, 0, 2656, 2657, 5, 162, 0, 0, 2657, 279, 1, 0, 0, 0, 2658, 2659, 5, 163, 0, 0, 2659, 281, 1, 0, 0, 0, 2660, 2661, 3, 264, 132, 0, 2661, 2662, 6, 141, -1, 0, 2662, 2676, 1, 0, 0, 0, 2663, 2664, 5, 164, 0, 0, 2664, 2665, 3, 0, 0, 0, 2665, 2666, 5, 159, 0, 0, 2666, 2667, 3, 0, 0, 0, 2667, 2668, 6, 141, -1, 0, 2668, 2676, 1, 0, 0, 0, 2669, 2670, 5, 164, 0, 0, 2670, 2671, 3, 32, 16, 0, 2671, 2672, 5, 159, 0, 0, 2672, 2673, 3, 32, 16, 0, 2673, 2674, 6, 141, -1, 0, 2674, 2676, 1, 0, 0, 0, 2675, 2660, 1, 0, 0, 0, 2675, 2663, 1, 0, 0, 0, 2675, 2669, 1, 0, 0, 0, 2676, 283, 1, 0, 0, 0, 2677, 2678, 3, 286, 143, 0, 2678, 2679, 3, 290, 145, 0, 2679, 285, 1, 0, 0, 0, 2680, 2681, 5, 165, 0, 0, 2681, 2682, 3, 288, 144, 0, 2682, 2683, 3, 0, 0, 0, 2683, 2684, 5, 36, 0, 0, 2684, 2688, 1, 0, 0, 0, 2685, 2686, 5, 165, 0, 0, 2686, 2688, 3, 288, 144, 0, 2687, 2680, 1, 0, 0, 0, 2687, 2685, 1, 0, 0, 0, 2688, 287, 1, 0, 0, 0, 2689, 2693, 1, 0, 0, 0, 2690, 2693, 5, 166, 0, 0, 2691, 2693, 5, 2, 0, 0, 2692, 2689, 1, 0, 0, 0, 2692, 2690, 1, 0, 0, 0, 2692, 2691, 1, 0, 0, 0, 2693, 289, 1, 0, 0, 0, 2694, 2695, 5, 17, 0, 0, 2695, 2696, 3, 292, 146, 0, 2696, 2697, 5, 18, 0, 0, 2697, 2704, 1, 0, 0, 0, 2698, 2700, 3, 296, 148, 0, 2699, 2698, 1, 0, 0, 0, 2700, 2701, 1, 0, 0, 0, 2701, 2699, 1, 0, 0, 0, 2701, 2702, 1, 0, 0, 0, 2702, 2704, 1, 0, 0, 0, 2703, 2694, 1, 0, 0, 0, 2703, 2699, 1, 0, 0, 0, 2704, 291, 1, 0, 0, 0, 2705, 2706, 3, 296, 148, 0, 2706, 2707, 5, 28, 0, 0, 2707, 2709, 1, 0, 0, 0, 2708, 2705, 1, 0, 0, 0, 2709, 2712, 1, 0, 0, 0, 2710, 2708, 1, 0, 0, 0, 2710, 2711, 1, 0, 0, 0, 2711, 2713, 1, 0, 0, 0, 2712, 2710, 1, 0, 0, 0, 2713, 2714, 3, 296, 148, 0, 2714, 293, 1, 0, 0, 0, 2715, 2721, 1, 0, 0, 0, 2716, 2717, 5, 42, 0, 0, 2717, 2718, 3, 32, 16, 0, 2718, 2719, 5, 43, 0, 0, 2719, 2721, 1, 0, 0, 0, 2720, 2715, 1, 0, 0, 0, 2720, 2716, 1, 0, 0, 0, 2721, 295, 1, 0, 0, 0, 2722, 2723, 5, 181, 0, 0, 2723, 2724, 5, 262, 0, 0, 2724, 2725, 5, 30, 0, 0, 2725, 2726, 3, 6, 3, 0, 2726, 2727, 5, 31, 0, 0, 2727, 2789, 1, 0, 0, 0, 2728, 2729, 5, 260, 0, 0, 2729, 2730, 5, 30, 0, 0, 2730, 2731, 3, 0, 0, 0, 2731, 2732, 5, 31, 0, 0, 2732, 2789, 1, 0, 0, 0, 2733, 2734, 5, 260, 0, 0, 2734, 2789, 3, 0, 0, 0, 2735, 2736, 5, 84, 0, 0, 2736, 2737, 5, 30, 0, 0, 2737, 2738, 3, 300, 150, 0, 2738, 2739, 5, 31, 0, 0, 2739, 2789, 1, 0, 0, 0, 2740, 2741, 5, 188, 0, 0, 2741, 2742, 5, 30, 0, 0, 2742, 2743, 3, 36, 18, 0, 2743, 2744, 5, 31, 0, 0, 2744, 2745, 3, 294, 147, 0, 2745, 2789, 1, 0, 0, 0, 2746, 2747, 5, 189, 0, 0, 2747, 2748, 5, 30, 0, 0, 2748, 2749, 3, 36, 18, 0, 2749, 2750, 5, 31, 0, 0, 2750, 2751, 3, 294, 147, 0, 2751, 2789, 1, 0, 0, 0, 2752, 2753, 5, 187, 0, 0, 2753, 2754, 5, 30, 0, 0, 2754, 2755, 3, 34, 17, 0, 2755, 2756, 5, 31, 0, 0, 2756, 2757, 3, 294, 147, 0, 2757, 2789, 1, 0, 0, 0, 2758, 2759, 5, 186, 0, 0, 2759, 2760, 5, 30, 0, 0, 2760, 2761, 3, 32, 16, 0, 2761, 2762, 5, 31, 0, 0, 2762, 2763, 3, 294, 147, 0, 2763, 2789, 1, 0, 0, 0, 2764, 2765, 5, 185, 0, 0, 2765, 2766, 5, 30, 0, 0, 2766, 2767, 3, 32, 16, 0, 2767, 2768, 5, 31, 0, 0, 2768, 2769, 3, 294, 147, 0, 2769, 2789, 1, 0, 0, 0, 2770, 2771, 5, 184, 0, 0, 2771, 2772, 5, 30, 0, 0, 2772, 2773, 3, 32, 16, 0, 2773, 2774, 5, 31, 0, 0, 2774, 2775, 3, 294, 147, 0, 2775, 2789, 1, 0, 0, 0, 2776, 2777, 5, 188, 0, 0, 2777, 2789, 3, 294, 147, 0, 2778, 2779, 5, 189, 0, 0, 2779, 2789, 3, 294, 147, 0, 2780, 2781, 5, 187, 0, 0, 2781, 2789, 3, 294, 147, 0, 2782, 2783, 5, 186, 0, 0, 2783, 2789, 3, 294, 147, 0, 2784, 2785, 5, 185, 0, 0, 2785, 2789, 3, 294, 147, 0, 2786, 2787, 5, 184, 0, 0, 2787, 2789, 3, 294, 147, 0, 2788, 2722, 1, 0, 0, 0, 2788, 2728, 1, 0, 0, 0, 2788, 2733, 1, 0, 0, 0, 2788, 2735, 1, 0, 0, 0, 2788, 2740, 1, 0, 0, 0, 2788, 2746, 1, 0, 0, 0, 2788, 2752, 1, 0, 0, 0, 2788, 2758, 1, 0, 0, 0, 2788, 2764, 1, 0, 0, 0, 2788, 2770, 1, 0, 0, 0, 2788, 2776, 1, 0, 0, 0, 2788, 2778, 1, 0, 0, 0, 2788, 2780, 1, 0, 0, 0, 2788, 2782, 1, 0, 0, 0, 2788, 2784, 1, 0, 0, 0, 2788, 2786, 1, 0, 0, 0, 2789, 297, 1, 0, 0, 0, 2790, 2791, 5, 188, 0, 0, 2791, 2792, 5, 30, 0, 0, 2792, 2793, 3, 36, 18, 0, 2793, 2794, 5, 31, 0, 0, 2794, 2866, 1, 0, 0, 0, 2795, 2796, 5, 189, 0, 0, 2796, 2797, 5, 30, 0, 0, 2797, 2798, 3, 36, 18, 0, 2798, 2799, 5, 31, 0, 0, 2799, 2866, 1, 0, 0, 0, 2800, 2801, 5, 188, 0, 0, 2801, 2802, 5, 30, 0, 0, 2802, 2803, 3, 32, 16, 0, 2803, 2804, 5, 31, 0, 0, 2804, 2866, 1, 0, 0, 0, 2805, 2806, 5, 189, 0, 0, 2806, 2807, 5, 30, 0, 0, 2807, 2808, 3, 34, 17, 0, 2808, 2809, 5, 31, 0, 0, 2809, 2866, 1, 0, 0, 0, 2810, 2811, 5, 187, 0, 0, 2811, 2812, 5, 30, 0, 0, 2812, 2813, 3, 34, 17, 0, 2813, 2814, 5, 31, 0, 0, 2814, 2866, 1, 0, 0, 0, 2815, 2816, 5, 186, 0, 0, 2816, 2817, 5, 30, 0, 0, 2817, 2818, 3, 32, 16, 0, 2818, 2819, 5, 31, 0, 0, 2819, 2866, 1, 0, 0, 0, 2820, 2821, 5, 185, 0, 0, 2821, 2822, 5, 30, 0, 0, 2822, 2823, 3, 32, 16, 0, 2823, 2824, 5, 31, 0, 0, 2824, 2866, 1, 0, 0, 0, 2825, 2826, 5, 184, 0, 0, 2826, 2827, 5, 30, 0, 0, 2827, 2828, 3, 32, 16, 0, 2828, 2829, 5, 31, 0, 0, 2829, 2866, 1, 0, 0, 0, 2830, 2831, 5, 193, 0, 0, 2831, 2832, 5, 30, 0, 0, 2832, 2833, 3, 34, 17, 0, 2833, 2834, 5, 31, 0, 0, 2834, 2866, 1, 0, 0, 0, 2835, 2836, 5, 192, 0, 0, 2836, 2837, 5, 30, 0, 0, 2837, 2838, 3, 32, 16, 0, 2838, 2839, 5, 31, 0, 0, 2839, 2866, 1, 0, 0, 0, 2840, 2841, 5, 191, 0, 0, 2841, 2842, 5, 30, 0, 0, 2842, 2843, 3, 32, 16, 0, 2843, 2844, 5, 31, 0, 0, 2844, 2866, 1, 0, 0, 0, 2845, 2846, 5, 190, 0, 0, 2846, 2847, 5, 30, 0, 0, 2847, 2848, 3, 32, 16, 0, 2848, 2849, 5, 31, 0, 0, 2849, 2866, 1, 0, 0, 0, 2850, 2851, 5, 181, 0, 0, 2851, 2852, 5, 30, 0, 0, 2852, 2853, 3, 32, 16, 0, 2853, 2854, 5, 31, 0, 0, 2854, 2866, 1, 0, 0, 0, 2855, 2856, 5, 183, 0, 0, 2856, 2857, 5, 30, 0, 0, 2857, 2858, 3, 162, 81, 0, 2858, 2859, 5, 31, 0, 0, 2859, 2866, 1, 0, 0, 0, 2860, 2861, 5, 84, 0, 0, 2861, 2862, 5, 30, 0, 0, 2862, 2863, 3, 300, 150, 0, 2863, 2864, 5, 31, 0, 0, 2864, 2866, 1, 0, 0, 0, 2865, 2790, 1, 0, 0, 0, 2865, 2795, 1, 0, 0, 0, 2865, 2800, 1, 0, 0, 0, 2865, 2805, 1, 0, 0, 0, 2865, 2810, 1, 0, 0, 0, 2865, 2815, 1, 0, 0, 0, 2865, 2820, 1, 0, 0, 0, 2865, 2825, 1, 0, 0, 0, 2865, 2830, 1, 0, 0, 0, 2865, 2835, 1, 0, 0, 0, 2865, 2840, 1, 0, 0, 0, 2865, 2845, 1, 0, 0, 0, 2865, 2850, 1, 0, 0, 0, 2865, 2855, 1, 0, 0, 0, 2865, 2860, 1, 0, 0, 0, 2866, 299, 1, 0, 0, 0, 2867, 2868, 3, 302, 151, 0, 2868, 2869, 6, 150, -1, 0, 2869, 2871, 1, 0, 0, 0, 2870, 2867, 1, 0, 0, 0, 2871, 2874, 1, 0, 0, 0, 2872, 2870, 1, 0, 0, 0, 2872, 2873, 1, 0, 0, 0, 2873, 301, 1, 0, 0, 0, 2874, 2872, 1, 0, 0, 0, 2875, 2876, 7, 11, 0, 0, 2876, 303, 1, 0, 0, 0, 2877, 2881, 3, 298, 149, 0, 2878, 2881, 3, 6, 3, 0, 2879, 2881, 5, 179, 0, 0, 2880, 2877, 1, 0, 0, 0, 2880, 2878, 1, 0, 0, 0, 2880, 2879, 1, 0, 0, 0, 2881, 305, 1, 0, 0, 0, 2882, 3031, 3, 298, 149, 0, 2883, 2884, 5, 182, 0, 0, 2884, 2885, 5, 30, 0, 0, 2885, 2886, 5, 179, 0, 0, 2886, 3031, 5, 31, 0, 0, 2887, 2888, 5, 182, 0, 0, 2888, 2889, 5, 30, 0, 0, 2889, 2890, 5, 264, 0, 0, 2890, 3031, 5, 31, 0, 0, 2891, 2892, 5, 196, 0, 0, 2892, 2893, 5, 30, 0, 0, 2893, 2894, 5, 39, 0, 0, 2894, 2895, 5, 264, 0, 0, 2895, 3031, 5, 31, 0, 0, 2896, 2897, 5, 196, 0, 0, 2897, 2898, 5, 30, 0, 0, 2898, 2899, 3, 116, 58, 0, 2899, 2900, 5, 31, 0, 0, 2900, 3031, 1, 0, 0, 0, 2901, 2902, 5, 196, 0, 0, 2902, 2903, 5, 30, 0, 0, 2903, 2904, 5, 179, 0, 0, 2904, 3031, 5, 31, 0, 0, 2905, 2906, 5, 197, 0, 0, 2906, 2907, 5, 30, 0, 0, 2907, 2908, 3, 306, 153, 0, 2908, 2909, 5, 31, 0, 0, 2909, 3031, 1, 0, 0, 0, 2910, 2911, 5, 188, 0, 0, 2911, 2912, 5, 42, 0, 0, 2912, 2913, 3, 32, 16, 0, 2913, 2914, 5, 43, 0, 0, 2914, 2915, 5, 30, 0, 0, 2915, 2916, 3, 308, 154, 0, 2916, 2917, 5, 31, 0, 0, 2917, 3031, 1, 0, 0, 0, 2918, 2919, 5, 189, 0, 0, 2919, 2920, 5, 42, 0, 0, 2920, 2921, 3, 32, 16, 0, 2921, 2922, 5, 43, 0, 0, 2922, 2923, 5, 30, 0, 0, 2923, 2924, 3, 310, 155, 0, 2924, 2925, 5, 31, 0, 0, 2925, 3031, 1, 0, 0, 0, 2926, 2927, 5, 187, 0, 0, 2927, 2928, 5, 42, 0, 0, 2928, 2929, 3, 32, 16, 0, 2929, 2930, 5, 43, 0, 0, 2930, 2931, 5, 30, 0, 0, 2931, 2932, 3, 312, 156, 0, 2932, 2933, 5, 31, 0, 0, 2933, 3031, 1, 0, 0, 0, 2934, 2935, 5, 186, 0, 0, 2935, 2936, 5, 42, 0, 0, 2936, 2937, 3, 32, 16, 0, 2937, 2938, 5, 43, 0, 0, 2938, 2939, 5, 30, 0, 0, 2939, 2940, 3, 314, 157, 0, 2940, 2941, 5, 31, 0, 0, 2941, 3031, 1, 0, 0, 0, 2942, 2943, 5, 185, 0, 0, 2943, 2944, 5, 42, 0, 0, 2944, 2945, 3, 32, 16, 0, 2945, 2946, 5, 43, 0, 0, 2946, 2947, 5, 30, 0, 0, 2947, 2948, 3, 316, 158, 0, 2948, 2949, 5, 31, 0, 0, 2949, 3031, 1, 0, 0, 0, 2950, 2951, 5, 184, 0, 0, 2951, 2952, 5, 42, 0, 0, 2952, 2953, 3, 32, 16, 0, 2953, 2954, 5, 43, 0, 0, 2954, 2955, 5, 30, 0, 0, 2955, 2956, 3, 318, 159, 0, 2956, 2957, 5, 31, 0, 0, 2957, 3031, 1, 0, 0, 0, 2958, 2959, 5, 193, 0, 0, 2959, 2960, 5, 42, 0, 0, 2960, 2961, 3, 32, 16, 0, 2961, 2962, 5, 43, 0, 0, 2962, 2963, 5, 30, 0, 0, 2963, 2964, 3, 312, 156, 0, 2964, 2965, 5, 31, 0, 0, 2965, 3031, 1, 0, 0, 0, 2966, 2967, 5, 192, 0, 0, 2967, 2968, 5, 42, 0, 0, 2968, 2969, 3, 32, 16, 0, 2969, 2970, 5, 43, 0, 0, 2970, 2971, 5, 30, 0, 0, 2971, 2972, 3, 314, 157, 0, 2972, 2973, 5, 31, 0, 0, 2973, 3031, 1, 0, 0, 0, 2974, 2975, 5, 191, 0, 0, 2975, 2976, 5, 42, 0, 0, 2976, 2977, 3, 32, 16, 0, 2977, 2978, 5, 43, 0, 0, 2978, 2979, 5, 30, 0, 0, 2979, 2980, 3, 316, 158, 0, 2980, 2981, 5, 31, 0, 0, 2981, 3031, 1, 0, 0, 0, 2982, 2983, 5, 190, 0, 0, 2983, 2984, 5, 42, 0, 0, 2984, 2985, 3, 32, 16, 0, 2985, 2986, 5, 43, 0, 0, 2986, 2987, 5, 30, 0, 0, 2987, 2988, 3, 318, 159, 0, 2988, 2989, 5, 31, 0, 0, 2989, 3031, 1, 0, 0, 0, 2990, 2991, 5, 181, 0, 0, 2991, 2992, 5, 42, 0, 0, 2992, 2993, 3, 32, 16, 0, 2993, 2994, 5, 43, 0, 0, 2994, 2995, 5, 30, 0, 0, 2995, 2996, 3, 316, 158, 0, 2996, 2997, 5, 31, 0, 0, 2997, 3031, 1, 0, 0, 0, 2998, 2999, 5, 183, 0, 0, 2999, 3000, 5, 42, 0, 0, 3000, 3001, 3, 32, 16, 0, 3001, 3002, 5, 43, 0, 0, 3002, 3003, 5, 30, 0, 0, 3003, 3004, 3, 320, 160, 0, 3004, 3005, 5, 31, 0, 0, 3005, 3031, 1, 0, 0, 0, 3006, 3007, 5, 182, 0, 0, 3007, 3008, 5, 42, 0, 0, 3008, 3009, 3, 32, 16, 0, 3009, 3010, 5, 43, 0, 0, 3010, 3011, 5, 30, 0, 0, 3011, 3012, 3, 322, 161, 0, 3012, 3013, 5, 31, 0, 0, 3013, 3031, 1, 0, 0, 0, 3014, 3015, 5, 196, 0, 0, 3015, 3016, 5, 42, 0, 0, 3016, 3017, 3, 32, 16, 0, 3017, 3018, 5, 43, 0, 0, 3018, 3019, 5, 30, 0, 0, 3019, 3020, 3, 324, 162, 0, 3020, 3021, 5, 31, 0, 0, 3021, 3031, 1, 0, 0, 0, 3022, 3023, 5, 197, 0, 0, 3023, 3024, 5, 42, 0, 0, 3024, 3025, 3, 32, 16, 0, 3025, 3026, 5, 43, 0, 0, 3026, 3027, 5, 30, 0, 0, 3027, 3028, 3, 328, 164, 0, 3028, 3029, 5, 31, 0, 0, 3029, 3031, 1, 0, 0, 0, 3030, 2882, 1, 0, 0, 0, 3030, 2883, 1, 0, 0, 0, 3030, 2887, 1, 0, 0, 0, 3030, 2891, 1, 0, 0, 0, 3030, 2896, 1, 0, 0, 0, 3030, 2901, 1, 0, 0, 0, 3030, 2905, 1, 0, 0, 0, 3030, 2910, 1, 0, 0, 0, 3030, 2918, 1, 0, 0, 0, 3030, 2926, 1, 0, 0, 0, 3030, 2934, 1, 0, 0, 0, 3030, 2942, 1, 0, 0, 0, 3030, 2950, 1, 0, 0, 0, 3030, 2958, 1, 0, 0, 0, 3030, 2966, 1, 0, 0, 0, 3030, 2974, 1, 0, 0, 0, 3030, 2982, 1, 0, 0, 0, 3030, 2990, 1, 0, 0, 0, 3030, 2998, 1, 0, 0, 0, 3030, 3006, 1, 0, 0, 0, 3030, 3014, 1, 0, 0, 0, 3030, 3022, 1, 0, 0, 0, 3031, 307, 1, 0, 0, 0, 3032, 3035, 3, 36, 18, 0, 3033, 3035, 3, 32, 16, 0, 3034, 3032, 1, 0, 0, 0, 3034, 3033, 1, 0, 0, 0, 3035, 3038, 1, 0, 0, 0, 3036, 3034, 1, 0, 0, 0, 3036, 3037, 1, 0, 0, 0, 3037, 309, 1, 0, 0, 0, 3038, 3036, 1, 0, 0, 0, 3039, 3042, 3, 36, 18, 0, 3040, 3042, 3, 34, 17, 0, 3041, 3039, 1, 0, 0, 0, 3041, 3040, 1, 0, 0, 0, 3042, 3045, 1, 0, 0, 0, 3043, 3041, 1, 0, 0, 0, 3043, 3044, 1, 0, 0, 0, 3044, 311, 1, 0, 0, 0, 3045, 3043, 1, 0, 0, 0, 3046, 3048, 3, 34, 17, 0, 3047, 3046, 1, 0, 0, 0, 3048, 3051, 1, 0, 0, 0, 3049, 3047, 1, 0, 0, 0, 3049, 3050, 1, 0, 0, 0, 3050, 313, 1, 0, 0, 0, 3051, 3049, 1, 0, 0, 0, 3052, 3054, 3, 32, 16, 0, 3053, 3052, 1, 0, 0, 0, 3054, 3057, 1, 0, 0, 0, 3055, 3053, 1, 0, 0, 0, 3055, 3056, 1, 0, 0, 0, 3056, 315, 1, 0, 0, 0, 3057, 3055, 1, 0, 0, 0, 3058, 3060, 3, 32, 16, 0, 3059, 3058, 1, 0, 0, 0, 3060, 3063, 1, 0, 0, 0, 3061, 3059, 1, 0, 0, 0, 3061, 3062, 1, 0, 0, 0, 3062, 317, 1, 0, 0, 0, 3063, 3061, 1, 0, 0, 0, 3064, 3066, 3, 32, 16, 0, 3065, 3064, 1, 0, 0, 0, 3066, 3069, 1, 0, 0, 0, 3067, 3065, 1, 0, 0, 0, 3067, 3068, 1, 0, 0, 0, 3068, 319, 1, 0, 0, 0, 3069, 3067, 1, 0, 0, 0, 3070, 3072, 3, 162, 81, 0, 3071, 3070, 1, 0, 0, 0, 3072, 3075, 1, 0, 0, 0, 3073, 3071, 1, 0, 0, 0, 3073, 3074, 1, 0, 0, 0, 3074, 321, 1, 0, 0, 0, 3075, 3073, 1, 0, 0, 0, 3076, 3078, 7, 12, 0, 0, 3077, 3076, 1, 0, 0, 0, 3078, 3081, 1, 0, 0, 0, 3079, 3077, 1, 0, 0, 0, 3079, 3080, 1, 0, 0, 0, 3080, 323, 1, 0, 0, 0, 3081, 3079, 1, 0, 0, 0, 3082, 3084, 3, 326, 163, 0, 3083, 3082, 1, 0, 0, 0, 3084, 3087, 1, 0, 0, 0, 3085, 3083, 1, 0, 0, 0, 3085, 3086, 1, 0, 0, 0, 3086, 325, 1, 0, 0, 0, 3087, 3085, 1, 0, 0, 0, 3088, 3093, 5, 179, 0, 0, 3089, 3090, 5, 39, 0, 0, 3090, 3093, 5, 264, 0, 0, 3091, 3093, 3, 116, 58, 0, 3092, 3088, 1, 0, 0, 0, 3092, 3089, 1, 0, 0, 0, 3092, 3091, 1, 0, 0, 0, 3093, 327, 1, 0, 0, 0, 3094, 3096, 3, 306, 153, 0, 3095, 3094, 1, 0, 0, 0, 3096, 3099, 1, 0, 0, 0, 3097, 3095, 1, 0, 0, 0, 3097, 3098, 1, 0, 0, 0, 3098, 329, 1, 0, 0, 0, 3099, 3097, 1, 0, 0, 0, 3100, 3104, 3, 44, 22, 0, 3101, 3104, 3, 46, 23, 0, 3102, 3104, 3, 2, 1, 0, 3103, 3100, 1, 0, 0, 0, 3103, 3101, 1, 0, 0, 0, 3103, 3102, 1, 0, 0, 0, 3104, 331, 1, 0, 0, 0, 3105, 3106, 7, 13, 0, 0, 3106, 3107, 5, 36, 0, 0, 3107, 3108, 5, 30, 0, 0, 3108, 3109, 3, 300, 150, 0, 3109, 3110, 5, 31, 0, 0, 3110, 3131, 1, 0, 0, 0, 3111, 3112, 5, 169, 0, 0, 3112, 3113, 3, 38, 19, 0, 3113, 3114, 5, 75, 0, 0, 3114, 3115, 3, 38, 19, 0, 3115, 3116, 5, 75, 0, 0, 3116, 3117, 3, 38, 19, 0, 3117, 3118, 5, 75, 0, 0, 3118, 3119, 3, 38, 19, 0, 3119, 3131, 1, 0, 0, 0, 3120, 3121, 5, 170, 0, 0, 3121, 3131, 3, 6, 3, 0, 3122, 3123, 5, 170, 0, 0, 3123, 3124, 5, 36, 0, 0, 3124, 3125, 5, 30, 0, 0, 3125, 3126, 3, 300, 150, 0, 3126, 3127, 5, 31, 0, 0, 3127, 3131, 1, 0, 0, 0, 3128, 3131, 3, 330, 165, 0, 3129, 3131, 3, 40, 20, 0, 3130, 3105, 1, 0, 0, 0, 3130, 3111, 1, 0, 0, 0, 3130, 3120, 1, 0, 0, 0, 3130, 3122, 1, 0, 0, 0, 3130, 3128, 1, 0, 0, 0, 3130, 3129, 1, 0, 0, 0, 3131, 333, 1, 0, 0, 0, 3132, 3133, 5, 25, 0, 0, 3133, 3134, 5, 40, 0, 0, 3134, 3135, 3, 98, 49, 0, 3135, 3136, 3, 2, 1, 0, 3136, 3145, 1, 0, 0, 0, 3137, 3138, 5, 25, 0, 0, 3138, 3139, 5, 40, 0, 0, 3139, 3140, 3, 98, 49, 0, 3140, 3141, 3, 2, 1, 0, 3141, 3142, 5, 34, 0, 0, 3142, 3143, 3, 2, 1, 0, 3143, 3145, 1, 0, 0, 0, 3144, 3132, 1, 0, 0, 0, 3144, 3137, 1, 0, 0, 0, 3145, 335, 1, 0, 0, 0, 3146, 3148, 3, 338, 169, 0, 3147, 3146, 1, 0, 0, 0, 3148, 3151, 1, 0, 0, 0, 3149, 3147, 1, 0, 0, 0, 3149, 3150, 1, 0, 0, 0, 3150, 337, 1, 0, 0, 0, 3151, 3149, 1, 0, 0, 0, 3152, 3153, 5, 180, 0, 0, 3153, 3154, 5, 36, 0, 0, 3154, 3155, 5, 30, 0, 0, 3155, 3156, 3, 300, 150, 0, 3156, 3157, 5, 31, 0, 0, 3157, 3167, 1, 0, 0, 0, 3158, 3167, 3, 332, 166, 0, 3159, 3160, 5, 171, 0, 0, 3160, 3161, 5, 36, 0, 0, 3161, 3162, 5, 30, 0, 0, 3162, 3163, 3, 300, 150, 0, 3163, 3164, 5, 31, 0, 0, 3164, 3167, 1, 0, 0, 0, 3165, 3167, 5, 55, 0, 0, 3166, 3152, 1, 0, 0, 0, 3166, 3158, 1, 0, 0, 0, 3166, 3159, 1, 0, 0, 0, 3166, 3165, 1, 0, 0, 0, 3167, 339, 1, 0, 0, 0, 3168, 3169, 5, 50, 0, 0, 3169, 3173, 5, 40, 0, 0, 3170, 3172, 3, 344, 172, 0, 3171, 3170, 1, 0, 0, 0, 3172, 3175, 1, 0, 0, 0, 3173, 3171, 1, 0, 0, 0, 3173, 3174, 1, 0, 0, 0, 3174, 3176, 1, 0, 0, 0, 3175, 3173, 1, 0, 0, 0, 3176, 3177, 3, 2, 1, 0, 3177, 341, 1, 0, 0, 0, 3178, 3182, 5, 301, 0, 0, 3179, 3181, 3, 344, 172, 0, 3180, 3179, 1, 0, 0, 0, 3181, 3184, 1, 0, 0, 0, 3182, 3180, 1, 0, 0, 0, 3182, 3183, 1, 0, 0, 0, 3183, 3185, 1, 0, 0, 0, 3184, 3182, 1, 0, 0, 0, 3185, 3186, 3, 2, 1, 0, 3186, 343, 1, 0, 0, 0, 3187, 3203, 5, 52, 0, 0, 3188, 3203, 5, 51, 0, 0, 3189, 3203, 5, 172, 0, 0, 3190, 3191, 5, 62, 0, 0, 3191, 3203, 5, 51, 0, 0, 3192, 3193, 5, 62, 0, 0, 3193, 3203, 5, 52, 0, 0, 3194, 3195, 5, 62, 0, 0, 3195, 3203, 5, 63, 0, 0, 3196, 3197, 5, 62, 0, 0, 3197, 3203, 5, 64, 0, 0, 3198, 3199, 5, 62, 0, 0, 3199, 3203, 5, 65, 0, 0, 3200, 3201, 5, 62, 0, 0, 3201, 3203, 5, 66, 0, 0, 3202, 3187, 1, 0, 0, 0, 3202, 3188, 1, 0, 0, 0, 3202, 3189, 1, 0, 0, 0, 3202, 3190, 1, 0, 0, 0, 3202, 3192, 1, 0, 0, 0, 3202, 3194, 1, 0, 0, 0, 3202, 3196, 1, 0, 0, 0, 3202, 3198, 1, 0, 0, 0, 3202, 3200, 1, 0, 0, 0, 3203, 345, 1, 0, 0, 0, 3204, 3206, 3, 348, 174, 0, 3205, 3204, 1, 0, 0, 0, 3206, 3209, 1, 0, 0, 0, 3207, 3205, 1, 0, 0, 0, 3207, 3208, 1, 0, 0, 0, 3208, 347, 1, 0, 0, 0, 3209, 3207, 1, 0, 0, 0, 3210, 3211, 5, 21, 0, 0, 3211, 3224, 3, 2, 1, 0, 3212, 3213, 5, 50, 0, 0, 3213, 3214, 5, 40, 0, 0, 3214, 3224, 3, 118, 59, 0, 3215, 3216, 5, 25, 0, 0, 3216, 3217, 5, 40, 0, 0, 3217, 3224, 3, 2, 1, 0, 3218, 3224, 3, 174, 87, 0, 3219, 3220, 5, 50, 0, 0, 3220, 3224, 3, 32, 16, 0, 3221, 3224, 3, 330, 165, 0, 3222, 3224, 3, 40, 20, 0, 3223, 3210, 1, 0, 0, 0, 3223, 3212, 1, 0, 0, 0, 3223, 3215, 1, 0, 0, 0, 3223, 3218, 1, 0, 0, 0, 3223, 3219, 1, 0, 0, 0, 3223, 3221, 1, 0, 0, 0, 3223, 3222, 1, 0, 0, 0, 3224, 349, 1, 0, 0, 0, 3225, 3229, 5, 274, 0, 0, 3226, 3228, 3, 352, 176, 0, 3227, 3226, 1, 0, 0, 0, 3228, 3231, 1, 0, 0, 0, 3229, 3227, 1, 0, 0, 0, 3229, 3230, 1, 0, 0, 0, 3230, 3232, 1, 0, 0, 0, 3231, 3229, 1, 0, 0, 0, 3232, 3245, 3, 2, 1, 0, 3233, 3237, 5, 274, 0, 0, 3234, 3236, 3, 352, 176, 0, 3235, 3234, 1, 0, 0, 0, 3236, 3239, 1, 0, 0, 0, 3237, 3235, 1, 0, 0, 0, 3237, 3238, 1, 0, 0, 0, 3238, 3240, 1, 0, 0, 0, 3239, 3237, 1, 0, 0, 0, 3240, 3241, 3, 2, 1, 0, 3241, 3242, 5, 34, 0, 0, 3242, 3243, 3, 2, 1, 0, 3243, 3245, 1, 0, 0, 0, 3244, 3225, 1, 0, 0, 0, 3244, 3233, 1, 0, 0, 0, 3245, 351, 1, 0, 0, 0, 3246, 3247, 7, 14, 0, 0, 3247, 353, 1, 0, 0, 0, 3248, 3250, 3, 356, 178, 0, 3249, 3248, 1, 0, 0, 0, 3250, 3253, 1, 0, 0, 0, 3251, 3249, 1, 0, 0, 0, 3251, 3252, 1, 0, 0, 0, 3252, 355, 1, 0, 0, 0, 3253, 3251, 1, 0, 0, 0, 3254, 3255, 5, 21, 0, 0, 3255, 3256, 3, 2, 1, 0, 3256, 3257, 5, 44, 0, 0, 3257, 3258, 3, 32, 16, 0, 3258, 3265, 1, 0, 0, 0, 3259, 3260, 5, 25, 0, 0, 3260, 3261, 5, 40, 0, 0, 3261, 3265, 3, 2, 1, 0, 3262, 3265, 3, 330, 165, 0, 3263, 3265, 3, 40, 20, 0, 3264, 3254, 1, 0, 0, 0, 3264, 3259, 1, 0, 0, 0, 3264, 3262, 1, 0, 0, 0, 3264, 3263, 1, 0, 0, 0, 3265, 357, 1, 0, 0, 0, 179, 368, 376, 385, 394, 447, 488, 497, 527, 531, 549, 576, 599, 635, 645, 652, 654, 664, 666, 673, 684, 692, 713, 715, 731, 776, 781, 786, 791, 799, 909, 915, 931, 937, 943, 950, 978, 1056, 1058, 1072, 1078, 1087, 1089, 1098, 1112, 1126, 1134, 1142, 1146, 1185, 1193, 1202, 1210, 1229, 1239, 1242, 1266, 1413, 1423, 1432, 1435, 1517, 1526, 1558, 1618, 1658, 1674, 1684, 1711, 1735, 1743, 1747, 1762, 1769, 1814, 1824, 1842, 1860, 1879, 1900, 1919, 1934, 1941, 1951, 1964, 1969, 1974, 1983, 1993, 2079, 2088, 2101, 2112, 2120, 2130, 2132, 2159, 2166, 2171, 2178, 2184, 2194, 2198, 2205, 2220, 2226, 2240, 2253, 2262, 2273, 2277, 2284, 2304, 2309, 2311, 2324, 2350, 2357, 2359, 2364, 2370, 2399, 2408, 2431, 2436, 2476, 2480, 2490, 2512, 2524, 2535, 2550, 2563, 2576, 2579, 2587, 2601, 2619, 2637, 2651, 2675, 2687, 2692, 2701, 2703, 2710, 2720, 2788, 2865, 2872, 2880, 3030, 3034, 3036, 3041, 3043, 3049, 3055, 3061, 3067, 3073, 3079, 3085, 3092, 3097, 3103, 3130, 3144, 3149, 3166, 3173, 3182, 3202, 3207, 3223, 3229, 3237, 3244, 3251, 3264] \ No newline at end of file diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILBaseVisitor.cs b/src/tools/ilasm/src/ILAssembler/gen/CILBaseVisitor.cs index c4f366e7a7fad4..9e101306c41a2d 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILBaseVisitor.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILBaseVisitor.cs @@ -1409,7 +1409,7 @@ public partial class CILBaseVisitor : AbstractParseTreeVisitor, /// The visitor result. public virtual Result VisitMethodDecl([NotNull] CILParser.MethodDeclContext context) { return VisitChildren(context); } /// - /// Visit a parse tree produced by . + /// Visit a parse tree produced by . /// /// The default implementation returns the result of calling /// on . @@ -1417,7 +1417,47 @@ public partial class CILBaseVisitor : AbstractParseTreeVisitor, /// /// The parse tree. /// The visitor result. - public virtual Result VisitMethodDeclIsland([NotNull] CILParser.MethodDeclIslandContext context) { return VisitChildren(context); } + public virtual Result VisitLocalsDecl([NotNull] CILParser.LocalsDeclContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitExportDecl([NotNull] CILParser.ExportDeclContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitVtentryDecl([NotNull] CILParser.VtentryDeclContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitOverrideDecl([NotNull] CILParser.OverrideDeclContext context) { return VisitChildren(context); } + /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitParameterDecl([NotNull] CILParser.ParameterDeclContext context) { return VisitChildren(context); } /// /// Visit a parse tree produced by . /// diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs index 4b638998bc9e1f..b62987fa6b6cf1 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs @@ -122,22 +122,23 @@ public const int RULE_marshalClause = 113, RULE_marshalBlob = 114, RULE_paramAttr = 115, RULE_paramAttrElement = 116, RULE_methodHead = 117, RULE_methAttr = 118, RULE_pinvImpl = 119, RULE_pinvAttr = 120, RULE_methodName = 121, RULE_implAttr = 122, - RULE_methodDecls = 123, RULE_methodDecl = 124, RULE_methodDeclIsland = 125, - RULE_labelDecl = 126, RULE_customDescrInMethodBody = 127, RULE_scopeBlock = 128, - RULE_sehBlock = 129, RULE_sehClauses = 130, RULE_tryBlock = 131, RULE_sehClause = 132, - RULE_filterClause = 133, RULE_catchClause = 134, RULE_finallyClause = 135, - RULE_faultClause = 136, RULE_handlerBlock = 137, RULE_dataDecl = 138, - RULE_ddHead = 139, RULE_tls = 140, RULE_ddBody = 141, RULE_ddItemList = 142, - RULE_ddItemCount = 143, RULE_ddItem = 144, RULE_fieldSerInit = 145, RULE_bytes = 146, - RULE_hexbyte = 147, RULE_fieldInit = 148, RULE_serInit = 149, RULE_f32seq = 150, - RULE_f64seq = 151, RULE_i64seq = 152, RULE_i32seq = 153, RULE_i16seq = 154, - RULE_i8seq = 155, RULE_boolSeq = 156, RULE_sqstringSeq = 157, RULE_classSeq = 158, - RULE_classSeqElement = 159, RULE_objSeq = 160, RULE_customAttrDecl = 161, - RULE_asmOrRefDecl = 162, RULE_assemblyRefHead = 163, RULE_assemblyRefDecls = 164, - RULE_assemblyRefDecl = 165, RULE_exptypeHead = 166, RULE_exportHead = 167, - RULE_exptAttr = 168, RULE_exptypeDecls = 169, RULE_exptypeDecl = 170, - RULE_manifestResHead = 171, RULE_manresAttr = 172, RULE_manifestResDecls = 173, - RULE_manifestResDecl = 174; + RULE_methodDecls = 123, RULE_methodDecl = 124, RULE_localsDecl = 125, + RULE_exportDecl = 126, RULE_vtentryDecl = 127, RULE_overrideDecl = 128, + RULE_parameterDecl = 129, RULE_labelDecl = 130, RULE_customDescrInMethodBody = 131, + RULE_scopeBlock = 132, RULE_sehBlock = 133, RULE_sehClauses = 134, RULE_tryBlock = 135, + RULE_sehClause = 136, RULE_filterClause = 137, RULE_catchClause = 138, + RULE_finallyClause = 139, RULE_faultClause = 140, RULE_handlerBlock = 141, + RULE_dataDecl = 142, RULE_ddHead = 143, RULE_tls = 144, RULE_ddBody = 145, + RULE_ddItemList = 146, RULE_ddItemCount = 147, RULE_ddItem = 148, RULE_fieldSerInit = 149, + RULE_bytes = 150, RULE_hexbyte = 151, RULE_fieldInit = 152, RULE_serInit = 153, + RULE_f32seq = 154, RULE_f64seq = 155, RULE_i64seq = 156, RULE_i32seq = 157, + RULE_i16seq = 158, RULE_i8seq = 159, RULE_boolSeq = 160, RULE_sqstringSeq = 161, + RULE_classSeq = 162, RULE_classSeqElement = 163, RULE_objSeq = 164, RULE_customAttrDecl = 165, + RULE_asmOrRefDecl = 166, RULE_assemblyRefHead = 167, RULE_assemblyRefDecls = 168, + RULE_assemblyRefDecl = 169, RULE_exptypeHead = 170, RULE_exportHead = 171, + RULE_exptAttr = 172, RULE_exptypeDecls = 173, RULE_exptypeDecl = 174, + RULE_manifestResHead = 175, RULE_manresAttr = 176, RULE_manifestResDecls = 177, + RULE_manifestResDecl = 178; public static readonly string[] ruleNames = { "id", "dottedName", "dottedNamePart", "compQstring", "decls", "decl", "subsystem", "corflags", "alignment", "imagebase", "stackreserve", "assemblyBlock", @@ -161,14 +162,14 @@ public const int "repeatOpt", "eventHead", "eventAttr", "eventDecls", "eventDecl", "propHead", "propAttr", "propDecls", "propDecl", "marshalClause", "marshalBlob", "paramAttr", "paramAttrElement", "methodHead", "methAttr", "pinvImpl", "pinvAttr", - "methodName", "implAttr", "methodDecls", "methodDecl", "methodDeclIsland", - "labelDecl", "customDescrInMethodBody", "scopeBlock", "sehBlock", "sehClauses", - "tryBlock", "sehClause", "filterClause", "catchClause", "finallyClause", - "faultClause", "handlerBlock", "dataDecl", "ddHead", "tls", "ddBody", - "ddItemList", "ddItemCount", "ddItem", "fieldSerInit", "bytes", "hexbyte", - "fieldInit", "serInit", "f32seq", "f64seq", "i64seq", "i32seq", "i16seq", - "i8seq", "boolSeq", "sqstringSeq", "classSeq", "classSeqElement", "objSeq", - "customAttrDecl", "asmOrRefDecl", "assemblyRefHead", "assemblyRefDecls", + "methodName", "implAttr", "methodDecls", "methodDecl", "localsDecl", "exportDecl", + "vtentryDecl", "overrideDecl", "parameterDecl", "labelDecl", "customDescrInMethodBody", + "scopeBlock", "sehBlock", "sehClauses", "tryBlock", "sehClause", "filterClause", + "catchClause", "finallyClause", "faultClause", "handlerBlock", "dataDecl", + "ddHead", "tls", "ddBody", "ddItemList", "ddItemCount", "ddItem", "fieldSerInit", + "bytes", "hexbyte", "fieldInit", "serInit", "f32seq", "f64seq", "i64seq", + "i32seq", "i16seq", "i8seq", "boolSeq", "sqstringSeq", "classSeq", "classSeqElement", + "objSeq", "customAttrDecl", "asmOrRefDecl", "assemblyRefHead", "assemblyRefDecls", "assemblyRefDecl", "exptypeHead", "exportHead", "exptAttr", "exptypeDecls", "exptypeDecl", "manifestResHead", "manresAttr", "manifestResDecls", "manifestResDecl" }; @@ -321,7 +322,7 @@ public IdContext id() { try { EnterOuterAlt(_localctx, 1); { - State = 350; + State = 358; _la = TokenStream.LA(1); if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 65534L) != 0) || ((((_la - 199)) & ~0x3f) == 0 && ((1L << (_la - 199)) & 299067162755073L) != 0) || _la==SQSTRING || _la==ID) ) { ErrorHandler.RecoverInline(this); @@ -381,13 +382,13 @@ public DottedNameContext dottedName() { Actions.BeginDottedName(_localctx); try { int _alt; - State = 368; + State = 376; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,1,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 352; + State = 360; _localctx.direct = Match(DOTTEDNAME); Actions.AddDottedNameToken(_localctx, _localctx.direct); } @@ -396,26 +397,26 @@ public DottedNameContext dottedName() { EnterOuterAlt(_localctx, 2); { { - State = 360; + State = 368; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,0,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 354; + State = 362; _localctx.part = dottedNamePart(); Actions.AddDottedNamePart(_localctx, _localctx.part.Value); - State = 356; + State = 364; Match(DOT); } } } - State = 362; + State = 370; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,0,Context); } - State = 363; + State = 371; _localctx.tail = dottedNamePart(); Actions.AddDottedNamePart(_localctx, _localctx.tail.Value); } @@ -424,7 +425,7 @@ public DottedNameContext dottedName() { case 3: EnterOuterAlt(_localctx, 3); { - State = 366; + State = 374; _localctx.quoted = Match(SQSTRING); Actions.AddDottedNameToken(_localctx, _localctx.quoted); } @@ -471,7 +472,7 @@ public DottedNamePartContext dottedNamePart() { try { EnterOuterAlt(_localctx, 1); { - State = 370; + State = 378; _la = TokenStream.LA(1); if ( !(_la==T__15 || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50331649L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -529,26 +530,26 @@ public CompQstringContext compQstring() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 377; + State = 385; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,2,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 372; + State = 380; _localctx.head = Match(QSTRING); Actions.AddComposedStringPart(_localctx, _localctx.head); - State = 374; + State = 382; Match(PLUS); } } } - State = 379; + State = 387; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,2,Context); } - State = 380; + State = 388; _localctx.tail = Match(QSTRING); Actions.AddComposedStringPart(_localctx, _localctx.tail); } @@ -594,17 +595,17 @@ public DeclsContext decls() { try { EnterOuterAlt(_localctx, 1); { - State = 386; + State = 394; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1972571905523712L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 281474976710659L) != 0) || ((((_la - 139)) & ~0x3f) == 0 && ((1L << (_la - 139)) & 1729382256977379329L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 6860956837609473L) != 0)) { { { - State = 383; + State = 391; decl(); } } - State = 388; + State = 396; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -738,224 +739,224 @@ public DeclContext decl() { EnterRule(_localctx, 10, RULE_decl); BeginSubtree(); try { - State = 439; + State = 447; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,4,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 389; + State = 397; classHead(); - State = 390; + State = 398; Match(T__16); - State = 391; + State = 399; classDecls(); - State = 392; + State = 400; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 394; + State = 402; nameSpaceHead(); - State = 395; + State = 403; Match(T__16); - State = 396; + State = 404; decls(); - State = 397; + State = 405; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 399; + State = 407; methodHead(); - State = 400; + State = 408; Match(T__16); - State = 401; + State = 409; methodDecls(); - State = 402; + State = 410; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 404; + State = 412; fieldDecl(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 405; + State = 413; dataDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 406; + State = 414; vtableDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 407; + State = 415; vtfixupDecl(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 408; + State = 416; extSourceSpec(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 409; + State = 417; fileDecl(); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 410; + State = 418; assemblyBlock(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 411; + State = 419; assemblyRefHead(); - State = 412; + State = 420; Match(T__16); - State = 413; + State = 421; assemblyRefDecls(); - State = 414; + State = 422; Match(T__17); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 416; + State = 424; exptypeHead(); - State = 417; + State = 425; Match(T__16); - State = 418; + State = 426; exptypeDecls(); - State = 419; + State = 427; Match(T__17); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 421; + State = 429; manifestResHead(); - State = 422; + State = 430; Match(T__16); - State = 423; + State = 431; manifestResDecls(); - State = 424; + State = 432; Match(T__17); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 426; + State = 434; moduleHead(); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 427; + State = 435; secDecl(); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 428; + State = 436; customAttrDecl(); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 429; + State = 437; subsystem(); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 430; + State = 438; corflags(); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 431; + State = 439; alignment(); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 432; + State = 440; imagebase(); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 433; + State = 441; stackreserve(); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 434; + State = 442; languageDecl(); } break; case 23: EnterOuterAlt(_localctx, 23); { - State = 435; + State = 443; typedefDecl(); } break; case 24: EnterOuterAlt(_localctx, 24); { - State = 436; + State = 444; compControl(); } break; case 25: EnterOuterAlt(_localctx, 25); { - State = 437; + State = 445; typelist(); } break; case 26: EnterOuterAlt(_localctx, 26); { - State = 438; + State = 446; mscorlib(); } break; @@ -999,9 +1000,9 @@ public SubsystemContext subsystem() { try { EnterOuterAlt(_localctx, 1); { - State = 441; + State = 449; Match(T__18); - State = 442; + State = 450; int32(); } } @@ -1040,9 +1041,9 @@ public CorflagsContext corflags() { try { EnterOuterAlt(_localctx, 1); { - State = 444; + State = 452; Match(T__19); - State = 445; + State = 453; int32(); } } @@ -1081,11 +1082,11 @@ public AlignmentContext alignment() { try { EnterOuterAlt(_localctx, 1); { - State = 447; + State = 455; Match(T__20); - State = 448; + State = 456; Match(T__21); - State = 449; + State = 457; int32(); } } @@ -1124,9 +1125,9 @@ public ImagebaseContext imagebase() { try { EnterOuterAlt(_localctx, 1); { - State = 451; + State = 459; Match(T__22); - State = 452; + State = 460; int64(); } } @@ -1165,9 +1166,9 @@ public StackreserveContext stackreserve() { try { EnterOuterAlt(_localctx, 1); { - State = 454; + State = 462; Match(T__23); - State = 455; + State = 463; int64(); } } @@ -1212,17 +1213,17 @@ public AssemblyBlockContext assemblyBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 457; + State = 465; Match(T__24); - State = 458; + State = 466; asmAttr(); - State = 459; + State = 467; dottedName(); - State = 460; + State = 468; Match(T__16); - State = 461; + State = 469; assemblyDecls(); - State = 462; + State = 470; Match(T__17); } } @@ -1258,7 +1259,7 @@ public MscorlibContext mscorlib() { try { EnterOuterAlt(_localctx, 1); { - State = 464; + State = 472; Match(T__25); } } @@ -1274,6 +1275,7 @@ public MscorlibContext mscorlib() { } public partial class LanguageDeclContext : ParserRuleContext { + public bool HasSyntaxError; [System.Diagnostics.DebuggerNonUserCode] public LanguageStringContext[] languageString() { return GetRuleContexts(); } @@ -1297,46 +1299,47 @@ public override TResult Accept(IParseTreeVisitor visitor) { public LanguageDeclContext languageDecl() { LanguageDeclContext _localctx = new LanguageDeclContext(Context, State); EnterRule(_localctx, 26, RULE_languageDecl); + BeginSubtree(); Actions.BeginSemanticRoot(_localctx); try { - State = 480; + State = 488; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,5,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 466; + State = 474; Match(T__26); - State = 467; + State = 475; languageString(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 468; + State = 476; Match(T__26); - State = 469; + State = 477; languageString(); - State = 470; + State = 478; Match(T__27); - State = 471; + State = 479; languageString(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 473; + State = 481; Match(T__26); - State = 474; + State = 482; languageString(); - State = 475; + State = 483; Match(T__27); - State = 476; + State = 484; languageString(); - State = 477; + State = 485; Match(T__27); - State = 478; + State = 486; languageString(); } break; @@ -1348,6 +1351,7 @@ public LanguageDeclContext languageDecl() { ErrorHandler.Recover(this, re); } finally { + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; @@ -1377,7 +1381,7 @@ public LanguageStringContext languageString() { try { EnterOuterAlt(_localctx, 1); { - State = 482; + State = 490; _la = TokenStream.LA(1); if ( !(_la==QSTRING || _la==SQSTRING) ) { ErrorHandler.RecoverInline(this); @@ -1427,25 +1431,25 @@ public TypelistContext typelist() { try { EnterOuterAlt(_localctx, 1); { - State = 484; + State = 492; Match(T__28); - State = 485; + State = 493; Match(T__16); - State = 489; + State = 497; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__15 || _la==T__41 || _la==T__112 || ((((_la - 199)) & ~0x3f) == 0 && ((1L << (_la - 199)) & 2017630225248026625L) != 0) || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50331649L) != 0)) { { { - State = 486; + State = 494; className(); } } - State = 491; + State = 499; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 492; + State = 500; Match(T__17); } } @@ -1482,7 +1486,7 @@ public Int32Context int32() { try { EnterOuterAlt(_localctx, 1); { - State = 494; + State = 502; Match(INT32); } } @@ -1521,7 +1525,7 @@ public Int64Context int64() { try { EnterOuterAlt(_localctx, 1); { - State = 496; + State = 504; _la = TokenStream.LA(1); if ( !(_la==INT32 || _la==INT64) ) { ErrorHandler.RecoverInline(this); @@ -1578,13 +1582,13 @@ public Float64Context float64() { Float64Context _localctx = new Float64Context(Context, State); EnterRule(_localctx, 36, RULE_float64); try { - State = 519; + State = 527; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,7,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 498; + State = 506; _localctx.@decimal = Match(FLOAT64); _localctx.Value = Actions.ParseFloatingLiteral(_localctx.@decimal); } @@ -1592,9 +1596,9 @@ public Float64Context float64() { case 2: EnterOuterAlt(_localctx, 2); { - State = 500; + State = 508; _localctx.trailing = int32(); - State = 501; + State = 509; Match(DOT); _localctx.Value = Actions.ParseFloatingInteger((_localctx.trailing!=null?(_localctx.trailing.Start):null)); } @@ -1602,7 +1606,7 @@ public Float64Context float64() { case 3: EnterOuterAlt(_localctx, 3); { - State = 504; + State = 512; _localctx.integer = int32(); _localctx.Value = Actions.ParseFloatingInteger((_localctx.integer!=null?(_localctx.integer.Start):null)); } @@ -1610,13 +1614,13 @@ public Float64Context float64() { case 4: EnterOuterAlt(_localctx, 4); { - State = 507; + State = 515; Match(FLOAT32); - State = 508; + State = 516; Match(T__29); - State = 509; + State = 517; _localctx.singleBits = int32(); - State = 510; + State = 518; Match(T__30); _localctx.Value = Actions.ParseFloat32Bits((_localctx.singleBits!=null?(_localctx.singleBits.Start):null)); } @@ -1624,13 +1628,13 @@ public Float64Context float64() { case 5: EnterOuterAlt(_localctx, 5); { - State = 513; + State = 521; Match(FLOAT64_); - State = 514; + State = 522; Match(T__29); - State = 515; + State = 523; _localctx.doubleBits = int64(); - State = 516; + State = 524; Match(T__30); _localctx.Value = Actions.ParseFloat64Bits((_localctx.doubleBits!=null?(_localctx.doubleBits.Start):null)); } @@ -1671,20 +1675,20 @@ public IntOrWildcardContext intOrWildcard() { IntOrWildcardContext _localctx = new IntOrWildcardContext(Context, State); EnterRule(_localctx, 38, RULE_intOrWildcard); try { - State = 523; + State = 531; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case INT32: EnterOuterAlt(_localctx, 1); { - State = 521; + State = 529; int32(); } break; case PTR: EnterOuterAlt(_localctx, 2); { - State = 522; + State = 530; Match(PTR); } break; @@ -1731,83 +1735,83 @@ public CompControlContext compControl() { CompControlContext _localctx = new CompControlContext(Context, State); EnterRule(_localctx, 40, RULE_compControl); try { - State = 541; + State = 549; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,9,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 525; + State = 533; Match(PP_DEFINE); - State = 526; + State = 534; Match(ID); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 527; + State = 535; Match(PP_DEFINE); - State = 528; + State = 536; Match(ID); - State = 529; + State = 537; Match(QSTRING); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 530; + State = 538; Match(PP_UNDEF); - State = 531; + State = 539; Match(ID); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 532; + State = 540; Match(PP_IFDEF); - State = 533; + State = 541; Match(ID); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 534; + State = 542; Match(PP_IFNDEF); - State = 535; + State = 543; Match(ID); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 536; + State = 544; Match(PP_ELSE); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 537; + State = 545; Match(PP_ENDIF); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 538; + State = 546; Match(PP_INCLUDE); - State = 539; + State = 547; Match(QSTRING); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 540; + State = 548; Match(T__31); } break; @@ -1861,71 +1865,71 @@ public TypedefDeclContext typedefDecl() { TypedefDeclContext _localctx = new TypedefDeclContext(Context, State); EnterRule(_localctx, 42, RULE_typedefDecl); try { - State = 568; + State = 576; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,10,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 543; + State = 551; Match(T__32); - State = 544; + State = 552; type(); - State = 545; + State = 553; Match(T__33); - State = 546; + State = 554; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 548; + State = 556; Match(T__32); - State = 549; + State = 557; className(); - State = 550; + State = 558; Match(T__33); - State = 551; + State = 559; dottedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 553; + State = 561; Match(T__32); - State = 554; + State = 562; memberRef(); - State = 555; + State = 563; Match(T__33); - State = 556; + State = 564; dottedName(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 558; + State = 566; Match(T__32); - State = 559; + State = 567; customDescr(); - State = 560; + State = 568; Match(T__33); - State = 561; + State = 569; dottedName(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 563; + State = 571; Match(T__32); - State = 564; + State = 572; customDescrWithOwner(); - State = 565; + State = 573; Match(T__33); - State = 566; + State = 574; dottedName(); } break; @@ -1973,62 +1977,62 @@ public CustomDescrContext customDescr() { CustomDescrContext _localctx = new CustomDescrContext(Context, State); EnterRule(_localctx, 44, RULE_customDescr); try { - State = 591; + State = 599; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,11,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 570; + State = 578; Match(T__34); - State = 571; + State = 579; customType(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 572; + State = 580; Match(T__34); - State = 573; + State = 581; customType(); - State = 574; + State = 582; Match(T__35); - State = 575; + State = 583; compQstring(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 577; + State = 585; Match(T__34); - State = 578; + State = 586; customType(); - State = 579; + State = 587; Match(T__35); - State = 580; + State = 588; Match(T__16); - State = 581; + State = 589; customBlobDescr(); - State = 582; + State = 590; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 584; + State = 592; Match(T__34); - State = 585; + State = 593; customType(); - State = 586; + State = 594; Match(T__35); - State = 587; + State = 595; Match(T__29); - State = 588; + State = 596; bytes(); - State = 589; + State = 597; Match(T__30); } break; @@ -2079,86 +2083,86 @@ public CustomDescrWithOwnerContext customDescrWithOwner() { CustomDescrWithOwnerContext _localctx = new CustomDescrWithOwnerContext(Context, State); EnterRule(_localctx, 46, RULE_customDescrWithOwner); try { - State = 627; + State = 635; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,12,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 593; + State = 601; Match(T__34); - State = 594; + State = 602; Match(T__29); - State = 595; + State = 603; ownerType(); - State = 596; + State = 604; Match(T__30); - State = 597; + State = 605; customType(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 599; + State = 607; Match(T__34); - State = 600; + State = 608; Match(T__29); - State = 601; + State = 609; ownerType(); - State = 602; + State = 610; Match(T__30); - State = 603; + State = 611; customType(); - State = 604; + State = 612; Match(T__35); - State = 605; + State = 613; compQstring(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 607; + State = 615; Match(T__34); - State = 608; + State = 616; Match(T__29); - State = 609; + State = 617; ownerType(); - State = 610; + State = 618; Match(T__30); - State = 611; + State = 619; customType(); - State = 612; + State = 620; Match(T__35); - State = 613; + State = 621; Match(T__16); - State = 614; + State = 622; customBlobDescr(); - State = 615; + State = 623; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 617; + State = 625; Match(T__34); - State = 618; + State = 626; Match(T__29); - State = 619; + State = 627; ownerType(); - State = 620; + State = 628; Match(T__30); - State = 621; + State = 629; customType(); - State = 622; + State = 630; Match(T__35); - State = 623; + State = 631; Match(T__29); - State = 624; + State = 632; bytes(); - State = 625; + State = 633; Match(T__30); } break; @@ -2199,7 +2203,7 @@ public CustomTypeContext customType() { try { EnterOuterAlt(_localctx, 1); { - State = 629; + State = 637; methodRef(); } } @@ -2244,13 +2248,13 @@ public OwnerTypeContext ownerType() { EnterRule(_localctx, 50, RULE_ownerType); Actions.BeginSemanticRoot(_localctx); try { - State = 637; + State = 645; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,13,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 631; + State = 639; _localctx.typeValue = typeSpec(); _localctx.Value = Actions.CreateTypeOwner(_localctx.typeValue.Value); } @@ -2258,7 +2262,7 @@ public OwnerTypeContext ownerType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 634; + State = 642; _localctx.member = memberRef(); _localctx.Value = Actions.CreateMemberOwner(_localctx.member.Value); } @@ -2304,9 +2308,9 @@ public CustomBlobDescrContext customBlobDescr() { try { EnterOuterAlt(_localctx, 1); { - State = 639; + State = 647; customBlobArgs(); - State = 640; + State = 648; customBlobNVPairs(); } } @@ -2355,13 +2359,13 @@ public CustomBlobArgsContext customBlobArgs() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 646; + State = 654; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,15,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { - State = 644; + State = 652; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__83: @@ -2381,7 +2385,7 @@ public CustomBlobArgsContext customBlobArgs() { case TYPE: case OBJECT: { - State = 642; + State = 650; serInit(); } break; @@ -2394,7 +2398,7 @@ public CustomBlobArgsContext customBlobArgs() { case PP_ENDIF: case PP_INCLUDE: { - State = 643; + State = 651; compControl(); } break; @@ -2403,7 +2407,7 @@ public CustomBlobArgsContext customBlobArgs() { } } } - State = 648; + State = 656; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,15,Context); } @@ -2472,26 +2476,26 @@ public CustomBlobNVPairsContext customBlobNVPairs() { try { EnterOuterAlt(_localctx, 1); { - State = 658; + State = 666; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 416611827712L) != 0) || ((((_la - 267)) & ~0x3f) == 0 && ((1L << (_la - 267)) & 127L) != 0)) { { - State = 656; + State = 664; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__36: case T__37: { - State = 649; + State = 657; fieldOrProp(); - State = 650; + State = 658; serializType(); - State = 651; + State = 659; dottedName(); - State = 652; + State = 660; Match(T__35); - State = 653; + State = 661; serInit(); } break; @@ -2504,7 +2508,7 @@ public CustomBlobNVPairsContext customBlobNVPairs() { case PP_ENDIF: case PP_INCLUDE: { - State = 655; + State = 663; compControl(); } break; @@ -2512,7 +2516,7 @@ public CustomBlobNVPairsContext customBlobNVPairs() { throw new NoViableAltException(this); } } - State = 660; + State = 668; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -2551,7 +2555,7 @@ public FieldOrPropContext fieldOrProp() { try { EnterOuterAlt(_localctx, 1); { - State = 661; + State = 669; _la = TokenStream.LA(1); if ( !(_la==T__36 || _la==T__37) ) { ErrorHandler.RecoverInline(this); @@ -2599,14 +2603,14 @@ public SerializTypeContext serializType() { try { EnterOuterAlt(_localctx, 1); { - State = 663; + State = 671; serializTypeElement(); - State = 665; + State = 673; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==ARRAY_TYPE_NO_BOUNDS) { { - State = 664; + State = 672; Match(ARRAY_TYPE_NO_BOUNDS); } } @@ -2656,54 +2660,54 @@ public SerializTypeElementContext serializTypeElement() { SerializTypeElementContext _localctx = new SerializTypeElementContext(Context, State); EnterRule(_localctx, 62, RULE_serializTypeElement); try { - State = 676; + State = 684; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,19,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 667; + State = 675; simpleType(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 668; + State = 676; dottedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 669; + State = 677; Match(TYPE); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 670; + State = 678; Match(OBJECT); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 671; + State = 679; Match(ENUM); - State = 672; + State = 680; Match(T__38); - State = 673; + State = 681; Match(SQSTRING); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 674; + State = 682; Match(ENUM); - State = 675; + State = 683; className(); } break; @@ -2743,33 +2747,33 @@ public ModuleHeadContext moduleHead() { ModuleHeadContext _localctx = new ModuleHeadContext(Context, State); EnterRule(_localctx, 64, RULE_moduleHead); try { - State = 684; + State = 692; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,20,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 678; + State = 686; Match(MODULE); - State = 679; + State = 687; Match(T__39); - State = 680; + State = 688; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 681; + State = 689; Match(MODULE); - State = 682; + State = 690; dottedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 683; + State = 691; Match(MODULE); } break; @@ -2816,19 +2820,19 @@ public VtfixupDeclContext vtfixupDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 686; + State = 694; Match(T__40); - State = 687; + State = 695; Match(T__41); - State = 688; + State = 696; int32(); - State = 689; + State = 697; Match(T__42); - State = 690; + State = 698; vtfixupAttr(0); - State = 691; + State = 699; Match(T__43); - State = 692; + State = 700; id(); } } @@ -2881,7 +2885,7 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { } Context.Stop = TokenStream.LT(-1); - State = 707; + State = 715; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,22,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { @@ -2890,16 +2894,16 @@ private VtfixupAttrContext vtfixupAttr(int _p) { TriggerExitRuleEvent(); _prevctx = _localctx; { - State = 705; + State = 713; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,21,Context) ) { case 1: { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 695; + State = 703; if (!(Precpred(Context, 5))) throw new FailedPredicateException(this, "Precpred(Context, 5)"); - State = 696; + State = 704; Match(INT32_); } break; @@ -2907,9 +2911,9 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 697; + State = 705; if (!(Precpred(Context, 4))) throw new FailedPredicateException(this, "Precpred(Context, 4)"); - State = 698; + State = 706; Match(INT64_); } break; @@ -2917,9 +2921,9 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 699; + State = 707; if (!(Precpred(Context, 3))) throw new FailedPredicateException(this, "Precpred(Context, 3)"); - State = 700; + State = 708; Match(T__44); } break; @@ -2927,9 +2931,9 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 701; + State = 709; if (!(Precpred(Context, 2))) throw new FailedPredicateException(this, "Precpred(Context, 2)"); - State = 702; + State = 710; Match(T__45); } break; @@ -2937,16 +2941,16 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 703; + State = 711; if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)"); - State = 704; + State = 712; Match(T__46); } break; } } } - State = 709; + State = 717; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,22,Context); } @@ -2987,15 +2991,15 @@ public VtableDeclContext vtableDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 710; + State = 718; Match(T__47); - State = 711; + State = 719; Match(T__35); - State = 712; + State = 720; Match(T__29); - State = 713; + State = 721; bytes(); - State = 714; + State = 722; Match(T__30); } } @@ -3035,9 +3039,9 @@ public NameSpaceHeadContext nameSpaceHead() { try { EnterOuterAlt(_localctx, 1); { - State = 716; + State = 724; Match(T__48); - State = 717; + State = 725; dottedName(); } Context.Stop = TokenStream.LT(-1); @@ -3096,31 +3100,31 @@ public ClassHeadContext classHead() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 719; + State = 727; Match(T__49); - State = 723; + State = 731; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,23,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 720; + State = 728; classAttr(); } } } - State = 725; + State = 733; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,23,Context); } - State = 726; + State = 734; dottedName(); - State = 727; + State = 735; typarsClause(); - State = 728; + State = 736; extendsClause(); - State = 729; + State = 737; implClause(); } Context.Stop = TokenStream.LT(-1); @@ -3165,213 +3169,213 @@ public ClassAttrContext classAttr() { ClassAttrContext _localctx = new ClassAttrContext(Context, State); EnterRule(_localctx, 76, RULE_classAttr); try { - State = 768; + State = 776; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,24,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 731; + State = 739; Match(T__50); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 732; + State = 740; Match(T__51); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 733; + State = 741; Match(VALUE); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 734; + State = 742; Match(ENUM); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 735; + State = 743; Match(INTERFACE); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 736; + State = 744; Match(T__52); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 737; + State = 745; Match(T__53); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 738; + State = 746; Match(T__54); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 739; + State = 747; Match(T__55); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 740; + State = 748; Match(EXPLICIT); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 741; + State = 749; Match(T__14); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 742; + State = 750; Match(ANSI); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 743; + State = 751; Match(T__56); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 744; + State = 752; Match(T__57); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 745; + State = 753; Match(T__58); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 746; + State = 754; Match(T__59); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 747; + State = 755; Match(T__60); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 748; + State = 756; Match(T__61); - State = 749; + State = 757; Match(T__50); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 750; + State = 758; Match(T__61); - State = 751; + State = 759; Match(T__51); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 752; + State = 760; Match(T__61); - State = 753; + State = 761; Match(T__62); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 754; + State = 762; Match(T__61); - State = 755; + State = 763; Match(T__63); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 756; + State = 764; Match(T__61); - State = 757; + State = 765; Match(T__64); } break; case 23: EnterOuterAlt(_localctx, 23); { - State = 758; + State = 766; Match(T__61); - State = 759; + State = 767; Match(T__65); } break; case 24: EnterOuterAlt(_localctx, 24); { - State = 760; + State = 768; Match(T__66); } break; case 25: EnterOuterAlt(_localctx, 25); { - State = 761; + State = 769; Match(T__67); } break; case 26: EnterOuterAlt(_localctx, 26); { - State = 762; + State = 770; Match(T__68); } break; case 27: EnterOuterAlt(_localctx, 27); { - State = 763; + State = 771; Match(T__69); - State = 764; + State = 772; Match(T__29); - State = 765; + State = 773; int32(); - State = 766; + State = 774; Match(T__30); } break; @@ -3410,7 +3414,7 @@ public ExtendsClauseContext extendsClause() { ExtendsClauseContext _localctx = new ExtendsClauseContext(Context, State); EnterRule(_localctx, 78, RULE_extendsClause); try { - State = 773; + State = 781; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -3422,9 +3426,9 @@ public ExtendsClauseContext extendsClause() { case T__70: EnterOuterAlt(_localctx, 2); { - State = 771; + State = 779; Match(T__70); - State = 772; + State = 780; typeSpec(); } break; @@ -3465,7 +3469,7 @@ public ImplClauseContext implClause() { ImplClauseContext _localctx = new ImplClauseContext(Context, State); EnterRule(_localctx, 80, RULE_implClause); try { - State = 778; + State = 786; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -3476,9 +3480,9 @@ public ImplClauseContext implClause() { case T__71: EnterOuterAlt(_localctx, 2); { - State = 776; + State = 784; Match(T__71); - State = 777; + State = 785; implList(); } break; @@ -3526,17 +3530,17 @@ public ClassDeclsContext classDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 783; + State = 791; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1125938695831552L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 1189425290649010179L) != 0) || ((((_la - 139)) & ~0x3f) == 0 && ((1L << (_la - 139)) & 1152921504673955841L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 871552083145265153L) != 0)) { { { - State = 780; + State = 788; classDecl(); } } - State = 785; + State = 793; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -3582,25 +3586,25 @@ public ImplListContext implList() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 791; + State = 799; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,28,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 786; + State = 794; typeSpec(); - State = 787; + State = 795; Match(T__27); } } } - State = 793; + State = 801; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,28,Context); } - State = 794; + State = 802; typeSpec(); } } @@ -3637,7 +3641,7 @@ public EsHeadContext esHead() { try { EnterOuterAlt(_localctx, 1); { - State = 796; + State = 804; _la = TokenStream.LA(1); if ( !(_la==T__72 || _la==T__73) ) { ErrorHandler.RecoverInline(this); @@ -3660,6 +3664,7 @@ public EsHeadContext esHead() { } public partial class ExtSourceSpecContext : ParserRuleContext { + public bool HasSyntaxError; [System.Diagnostics.DebuggerNonUserCode] public EsHeadContext esHead() { return GetRuleContext(0); } @@ -3688,258 +3693,259 @@ public override TResult Accept(IParseTreeVisitor visitor) { public ExtSourceSpecContext extSourceSpec() { ExtSourceSpecContext _localctx = new ExtSourceSpecContext(Context, State); EnterRule(_localctx, 88, RULE_extSourceSpec); + BeginSubtree(); Actions.BeginSemanticRoot(_localctx); try { - State = 901; + State = 909; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,29,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 798; + State = 806; esHead(); - State = 799; + State = 807; int32(); - State = 800; + State = 808; Match(SQSTRING); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 802; + State = 810; esHead(); - State = 803; + State = 811; int32(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 805; + State = 813; esHead(); - State = 806; + State = 814; int32(); - State = 807; + State = 815; Match(T__74); - State = 808; + State = 816; int32(); - State = 809; + State = 817; Match(SQSTRING); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 811; + State = 819; esHead(); - State = 812; + State = 820; int32(); - State = 813; + State = 821; Match(T__74); - State = 814; + State = 822; int32(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 816; + State = 824; esHead(); - State = 817; + State = 825; int32(); - State = 818; + State = 826; Match(T__74); - State = 819; + State = 827; int32(); - State = 820; + State = 828; Match(T__27); - State = 821; + State = 829; int32(); - State = 822; + State = 830; Match(SQSTRING); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 824; + State = 832; esHead(); - State = 825; + State = 833; int32(); - State = 826; + State = 834; Match(T__74); - State = 827; + State = 835; int32(); - State = 828; + State = 836; Match(T__27); - State = 829; + State = 837; int32(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 831; + State = 839; esHead(); - State = 832; + State = 840; int32(); - State = 833; + State = 841; Match(T__27); - State = 834; + State = 842; int32(); - State = 835; + State = 843; Match(T__74); - State = 836; + State = 844; int32(); - State = 837; + State = 845; Match(SQSTRING); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 839; + State = 847; esHead(); - State = 840; + State = 848; int32(); - State = 841; + State = 849; Match(T__27); - State = 842; + State = 850; int32(); - State = 843; + State = 851; Match(T__74); - State = 844; + State = 852; int32(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 846; + State = 854; esHead(); - State = 847; + State = 855; int32(); - State = 848; + State = 856; Match(T__27); - State = 849; + State = 857; int32(); - State = 850; + State = 858; Match(T__74); - State = 851; + State = 859; int32(); - State = 852; + State = 860; Match(T__27); - State = 853; + State = 861; int32(); - State = 854; + State = 862; Match(SQSTRING); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 856; + State = 864; esHead(); - State = 857; + State = 865; int32(); - State = 858; + State = 866; Match(T__27); - State = 859; + State = 867; int32(); - State = 860; + State = 868; Match(T__74); - State = 861; + State = 869; int32(); - State = 862; + State = 870; Match(T__27); - State = 863; + State = 871; int32(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 865; + State = 873; esHead(); - State = 866; + State = 874; int32(); - State = 867; + State = 875; Match(QSTRING); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 869; + State = 877; esHead(); - State = 870; + State = 878; int32(); - State = 871; + State = 879; Match(T__74); - State = 872; + State = 880; int32(); - State = 873; + State = 881; Match(QSTRING); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 875; + State = 883; esHead(); - State = 876; + State = 884; int32(); - State = 877; + State = 885; Match(T__74); - State = 878; + State = 886; int32(); - State = 879; + State = 887; Match(T__27); - State = 880; + State = 888; int32(); - State = 881; + State = 889; Match(QSTRING); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 883; + State = 891; esHead(); - State = 884; + State = 892; int32(); - State = 885; + State = 893; Match(T__27); - State = 886; + State = 894; int32(); - State = 887; + State = 895; Match(T__74); - State = 888; + State = 896; int32(); - State = 889; + State = 897; Match(QSTRING); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 891; + State = 899; esHead(); - State = 892; + State = 900; int32(); - State = 893; + State = 901; Match(T__27); - State = 894; + State = 902; int32(); - State = 895; + State = 903; Match(T__74); - State = 896; + State = 904; int32(); - State = 897; + State = 905; Match(T__27); - State = 898; + State = 906; int32(); - State = 899; + State = 907; Match(QSTRING); } break; @@ -3951,6 +3957,7 @@ public ExtSourceSpecContext extSourceSpec() { ErrorHandler.Recover(this, re); } finally { + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; @@ -3995,68 +4002,68 @@ public FileDeclContext fileDecl() { EnterRule(_localctx, 90, RULE_fileDecl); int _la; try { - State = 929; + State = 937; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,32,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 903; + State = 911; Match(T__20); - State = 907; + State = 915; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__75) { { { - State = 904; + State = 912; fileAttr(); } } - State = 909; + State = 917; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 910; + State = 918; dottedName(); - State = 911; + State = 919; fileEntry(); - State = 912; + State = 920; Match(HASH); - State = 913; + State = 921; Match(T__35); - State = 914; + State = 922; Match(T__29); - State = 915; + State = 923; bytes(); - State = 916; + State = 924; Match(T__30); - State = 917; + State = 925; fileEntry(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 919; + State = 927; Match(T__20); - State = 923; + State = 931; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__75) { { { - State = 920; + State = 928; fileAttr(); } } - State = 925; + State = 933; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 926; + State = 934; dottedName(); - State = 927; + State = 935; fileEntry(); } break; @@ -4094,7 +4101,7 @@ public FileAttrContext fileAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 931; + State = 939; Match(T__75); } } @@ -4129,7 +4136,7 @@ public FileEntryContext fileEntry() { FileEntryContext _localctx = new FileEntryContext(Context, State); EnterRule(_localctx, 94, RULE_fileEntry); try { - State = 935; + State = 943; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -4179,7 +4186,7 @@ public FileEntryContext fileEntry() { case ENTRYPOINT: EnterOuterAlt(_localctx, 2); { - State = 934; + State = 942; Match(ENTRYPOINT); } break; @@ -4220,7 +4227,7 @@ public AsmAttrAnyContext asmAttrAny() { try { EnterOuterAlt(_localctx, 1); { - State = 937; + State = 945; _la = TokenStream.LA(1); if ( !(_la==T__1 || _la==T__60 || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 127L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -4270,17 +4277,17 @@ public AsmAttrContext asmAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 942; + State = 950; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__1 || _la==T__60 || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 127L) != 0)) { { { - State = 939; + State = 947; asmAttrAny(); } } - State = 944; + State = 952; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -4349,22 +4356,22 @@ public InstrContext instr() { InstrContext _localctx = new InstrContext(Context, State); EnterRule(_localctx, 100, RULE_instr); try { - State = 970; + State = 978; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,35,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 945; + State = 953; simpleInstr(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 946; + State = 954; _localctx.op = Match(INSTR_METHOD); - State = 947; + State = 955; _localctx.methodOperand = methodRef(); Actions.EmitMethodReferenceInstruction(_localctx.op, _localctx.methodOperand); } @@ -4372,9 +4379,9 @@ public InstrContext instr() { case 3: EnterOuterAlt(_localctx, 3); { - State = 950; + State = 958; _localctx.op = Match(INSTR_FIELD); - State = 951; + State = 959; _localctx.fieldOperand = fieldRef(); Actions.EmitFieldReferenceInstruction(_localctx.op, _localctx.fieldOperand); } @@ -4382,9 +4389,9 @@ public InstrContext instr() { case 4: EnterOuterAlt(_localctx, 4); { - State = 954; + State = 962; _localctx.op = Match(INSTR_FIELD); - State = 955; + State = 963; _localctx.metadataOperand = mdtoken(); Actions.EmitMetadataTokenInstruction(_localctx.op, _localctx.metadataOperand); } @@ -4392,9 +4399,9 @@ public InstrContext instr() { case 5: EnterOuterAlt(_localctx, 5); { - State = 958; + State = 966; _localctx.op = Match(INSTR_TYPE); - State = 959; + State = 967; _localctx.typeOperand = typeSpec(); Actions.EmitTypeReferenceInstruction(_localctx.op, _localctx.typeOperand); } @@ -4402,9 +4409,9 @@ public InstrContext instr() { case 6: EnterOuterAlt(_localctx, 6); { - State = 962; + State = 970; _localctx.op = Match(INSTR_SIG); - State = 963; + State = 971; _localctx.signatureOperand = calliSignature(); Actions.EmitCalliInstruction(_localctx.op, _localctx.signatureOperand); } @@ -4412,9 +4419,9 @@ public InstrContext instr() { case 7: EnterOuterAlt(_localctx, 7); { - State = 966; + State = 974; _localctx.op = Match(INSTR_TOK); - State = 967; + State = 975; _localctx.ownerOperand = ownerType(); Actions.EmitOwnerTokenInstruction(_localctx.op, _localctx.ownerOperand); } @@ -4496,13 +4503,13 @@ public SimpleInstrContext simpleInstr() { SimpleInstrContext _localctx = new SimpleInstrContext(Context, State); EnterRule(_localctx, 102, RULE_simpleInstr); try { - State = 1050; + State = 1058; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,37,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 972; + State = 980; _localctx.op = Match(INSTR_NONE); Actions.EmitNoOperandInstruction(_localctx.op); } @@ -4510,9 +4517,9 @@ public SimpleInstrContext simpleInstr() { case 2: EnterOuterAlt(_localctx, 2); { - State = 974; + State = 982; _localctx.op = Match(INSTR_VAR); - State = 975; + State = 983; _localctx.index = int32(); Actions.EmitVariableIndexInstruction(_localctx.op, (_localctx.index!=null?(_localctx.index.Start):null)); } @@ -4520,9 +4527,9 @@ public SimpleInstrContext simpleInstr() { case 3: EnterOuterAlt(_localctx, 3); { - State = 978; + State = 986; _localctx.op = Match(INSTR_VAR); - State = 979; + State = 987; _localctx.name = id(); Actions.EmitVariableNameInstruction(_localctx.op, (_localctx.name!=null?(_localctx.name.Start):null)); } @@ -4530,9 +4537,9 @@ public SimpleInstrContext simpleInstr() { case 4: EnterOuterAlt(_localctx, 4); { - State = 982; + State = 990; _localctx.op = Match(INSTR_I); - State = 983; + State = 991; _localctx.value32 = int32(); Actions.EmitInt32Instruction(_localctx.op, (_localctx.value32!=null?(_localctx.value32.Start):null)); } @@ -4540,9 +4547,9 @@ public SimpleInstrContext simpleInstr() { case 5: EnterOuterAlt(_localctx, 5); { - State = 986; + State = 994; _localctx.op = Match(INSTR_I8); - State = 987; + State = 995; _localctx.value64 = int64(); Actions.EmitInt64Instruction(_localctx.op, (_localctx.value64!=null?(_localctx.value64.Start):null)); } @@ -4550,9 +4557,9 @@ public SimpleInstrContext simpleInstr() { case 6: EnterOuterAlt(_localctx, 6); { - State = 990; + State = 998; _localctx.op = Match(INSTR_R); - State = 991; + State = 999; _localctx.value = float64(); Actions.EmitFloatingInstruction(_localctx.op, _localctx.value.Value); } @@ -4560,9 +4567,9 @@ public SimpleInstrContext simpleInstr() { case 7: EnterOuterAlt(_localctx, 7); { - State = 994; + State = 1002; _localctx.op = Match(INSTR_R); - State = 995; + State = 1003; _localctx.integerValue = int64(); Actions.EmitFloatingInstruction(_localctx.op, (_localctx.integerValue!=null?(_localctx.integerValue.Start):null)); } @@ -4570,13 +4577,13 @@ public SimpleInstrContext simpleInstr() { case 8: EnterOuterAlt(_localctx, 8); { - State = 998; + State = 1006; _localctx.op = Match(INSTR_R); - State = 999; + State = 1007; Match(T__29); - State = 1000; + State = 1008; _localctx.rawFloat = bytes(); - State = 1001; + State = 1009; Match(T__30); Actions.EmitRawFloatingInstruction(_localctx.op, _localctx.rawFloat.Value, (_localctx.rawFloat!=null?(_localctx.rawFloat.Start):null)); } @@ -4584,15 +4591,15 @@ public SimpleInstrContext simpleInstr() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1004; + State = 1012; _localctx.op = Match(INSTR_R); - State = 1005; + State = 1013; Match(T__83); - State = 1006; + State = 1014; Match(T__29); - State = 1007; + State = 1015; _localctx.rawFloat = bytes(); - State = 1008; + State = 1016; Match(T__30); Actions.EmitRawFloatingInstruction(_localctx.op, _localctx.rawFloat.Value, (_localctx.rawFloat!=null?(_localctx.rawFloat.Start):null)); } @@ -4600,9 +4607,9 @@ public SimpleInstrContext simpleInstr() { case 10: EnterOuterAlt(_localctx, 10); { - State = 1011; + State = 1019; _localctx.op = Match(INSTR_BRTARGET); - State = 1012; + State = 1020; _localctx.offset = int32(); Actions.EmitBranchOffsetInstruction(_localctx.op, (_localctx.offset!=null?(_localctx.offset.Start):null)); } @@ -4610,9 +4617,9 @@ public SimpleInstrContext simpleInstr() { case 11: EnterOuterAlt(_localctx, 11); { - State = 1015; + State = 1023; _localctx.op = Match(INSTR_BRTARGET); - State = 1016; + State = 1024; _localctx.label = id(); Actions.EmitBranchLabelInstruction(_localctx.op, (_localctx.label!=null?(_localctx.label.Start):null)); } @@ -4620,9 +4627,9 @@ public SimpleInstrContext simpleInstr() { case 12: EnterOuterAlt(_localctx, 12); { - State = 1019; + State = 1027; _localctx.op = Match(INSTR_STRING); - State = 1020; + State = 1028; _localctx.userString = compQstring(); Actions.EmitStringInstruction(_localctx.op, _localctx.userString.Value); } @@ -4630,15 +4637,15 @@ public SimpleInstrContext simpleInstr() { case 13: EnterOuterAlt(_localctx, 13); { - State = 1023; + State = 1031; _localctx.op = Match(INSTR_STRING); - State = 1024; + State = 1032; Match(ANSI); - State = 1025; + State = 1033; Match(T__29); - State = 1026; + State = 1034; _localctx.ansiString = compQstring(); - State = 1027; + State = 1035; Match(T__30); Actions.EmitAnsiStringInstruction(_localctx.op, _localctx.ansiString.Value); } @@ -4646,15 +4653,15 @@ public SimpleInstrContext simpleInstr() { case 14: EnterOuterAlt(_localctx, 14); { - State = 1030; + State = 1038; _localctx.op = Match(INSTR_STRING); - State = 1031; + State = 1039; Match(T__83); - State = 1032; + State = 1040; Match(T__29); - State = 1033; + State = 1041; _localctx.rawString = bytes(); - State = 1034; + State = 1042; Match(T__30); Actions.EmitRawStringInstruction(_localctx.op, _localctx.rawString.Value); } @@ -4662,9 +4669,9 @@ public SimpleInstrContext simpleInstr() { case 15: EnterOuterAlt(_localctx, 15); { - State = 1037; + State = 1045; _localctx.op = Match(INSTR_TOK); - State = 1038; + State = 1046; _localctx.rawToken = int32(); Actions.EmitRawTokenInstruction(_localctx.op, (_localctx.rawToken!=null?(_localctx.rawToken.Start):null)); } @@ -4672,25 +4679,25 @@ public SimpleInstrContext simpleInstr() { case 16: EnterOuterAlt(_localctx, 16); { - State = 1041; + State = 1049; _localctx.op = Match(INSTR_SWITCH); Actions.BeginSwitchInstruction(_localctx, _localctx.op); - State = 1048; + State = 1056; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__29: { - State = 1043; + State = 1051; Match(T__29); - State = 1044; + State = 1052; labels(); - State = 1045; + State = 1053; Match(T__30); } break; case T__84: { - State = 1047; + State = 1055; Match(T__84); } break; @@ -4751,11 +4758,11 @@ public CalliSignatureContext calliSignature() { try { EnterOuterAlt(_localctx, 1); { - State = 1052; + State = 1060; _localctx.convention = callConv(); - State = 1053; + State = 1061; _localctx.returnType = type(); - State = 1054; + State = 1062; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateCalliSignature(_localctx.convention.Value, _localctx.returnType.Value, _localctx.arguments.Value); } @@ -4808,7 +4815,7 @@ public LabelsContext labels() { EnterRule(_localctx, 106, RULE_labels); try { int _alt; - State = 1081; + State = 1089; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__30: @@ -4839,14 +4846,14 @@ public LabelsContext labels() { case ID: EnterOuterAlt(_localctx, 2); { - State = 1070; + State = 1078; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,39,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1064; + State = 1072; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -4870,14 +4877,14 @@ public LabelsContext labels() { case SQSTRING: case ID: { - State = 1058; + State = 1066; _localctx.headLabel = id(); Actions.AddSwitchLabel((_localctx.headLabel!=null?(_localctx.headLabel.Start):null)); } break; case INT32: { - State = 1061; + State = 1069; _localctx.headOffset = int32(); Actions.AddSwitchOffset((_localctx.headOffset!=null?(_localctx.headOffset.Start):null)); } @@ -4885,16 +4892,16 @@ public LabelsContext labels() { default: throw new NoViableAltException(this); } - State = 1066; + State = 1074; Match(T__27); } } } - State = 1072; + State = 1080; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,39,Context); } - State = 1079; + State = 1087; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -4918,14 +4925,14 @@ public LabelsContext labels() { case SQSTRING: case ID: { - State = 1073; + State = 1081; _localctx.tailLabel = id(); Actions.AddSwitchLabel((_localctx.tailLabel!=null?(_localctx.tailLabel.Start):null)); } break; case INT32: { - State = 1076; + State = 1084; _localctx.tailOffset = int32(); Actions.AddSwitchOffset((_localctx.tailOffset!=null?(_localctx.tailOffset.Start):null)); } @@ -4982,31 +4989,31 @@ public TypeArgsContext typeArgs() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1083; + State = 1091; Match(T__85); - State = 1090; + State = 1098; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,42,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1084; + State = 1092; _localctx.argument = type(); Actions.AddTypeArgument(_localctx, _localctx.argument.Value); - State = 1086; + State = 1094; Match(T__27); } } } - State = 1092; + State = 1100; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,42,Context); } - State = 1093; + State = 1101; _localctx.lastArgument = type(); Actions.AddTypeArgument(_localctx, _localctx.lastArgument.Value); - State = 1095; + State = 1103; Match(T__86); } } @@ -5054,31 +5061,31 @@ public BoundsContext bounds() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1097; + State = 1105; Match(T__41); - State = 1104; + State = 1112; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,43,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1098; + State = 1106; _localctx.item = bound(); Actions.AddBound(_localctx, _localctx.item); - State = 1100; + State = 1108; Match(T__27); } } } - State = 1106; + State = 1114; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,43,Context); } - State = 1107; + State = 1115; _localctx.lastItem = bound(); Actions.AddBound(_localctx, _localctx.lastItem); - State = 1109; + State = 1117; Match(T__42); } } @@ -5124,44 +5131,44 @@ public SigArgsContext sigArgs() { Actions.BeginSignatureArguments(_localctx); try { int _alt; - State = 1126; + State = 1134; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__29: EnterOuterAlt(_localctx, 1); { - State = 1111; + State = 1119; Match(T__29); - State = 1118; + State = 1126; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,44,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1112; + State = 1120; _localctx.argument = sigArg(); Actions.AddSignatureArgument(_localctx, _localctx.argument.Value); - State = 1114; + State = 1122; Match(T__27); } } } - State = 1120; + State = 1128; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,44,Context); } - State = 1121; + State = 1129; _localctx.lastArgument = sigArg(); Actions.AddSignatureArgument(_localctx, _localctx.lastArgument.Value); - State = 1123; + State = 1131; Match(T__30); } break; case T__84: EnterOuterAlt(_localctx, 2); { - State = 1125; + State = 1133; Match(T__84); } break; @@ -5219,13 +5226,13 @@ public SigArgContext sigArg() { EnterRule(_localctx, 114, RULE_sigArg); int _la; try { - State = 1138; + State = 1146; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,47,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1128; + State = 1136; Match(ELLIPSIS); _localctx.Value = Actions.CreateSentinelSignatureArgument(); } @@ -5233,18 +5240,18 @@ public SigArgContext sigArg() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1130; + State = 1138; _localctx.attributes = paramAttr(); - State = 1131; + State = 1139; _localctx.argumentType = type(); - State = 1132; + State = 1140; _localctx.marshalling = marshalClause(); - State = 1134; + State = 1142; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 65534L) != 0) || ((((_la - 199)) & ~0x3f) == 0 && ((1L << (_la - 199)) & 299067162755073L) != 0) || _la==SQSTRING || _la==ID) { { - State = 1133; + State = 1141; _localctx.name = id(); } } @@ -5304,19 +5311,19 @@ public ClassNameContext className() { ClassNameContext _localctx = new ClassNameContext(Context, State); EnterRule(_localctx, 116, RULE_className); try { - State = 1177; + State = 1185; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,48,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1140; + State = 1148; Match(T__41); - State = 1141; + State = 1149; _localctx.assemblyName = dottedName(); - State = 1142; + State = 1150; Match(T__42); - State = 1143; + State = 1151; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreateAssemblyQualifiedClassName(_localctx.assemblyName.Value, _localctx.typeName.Value); } @@ -5324,13 +5331,13 @@ public ClassNameContext className() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1146; + State = 1154; Match(T__41); - State = 1147; + State = 1155; _localctx.scopeToken = mdtoken(); - State = 1148; + State = 1156; Match(T__42); - State = 1149; + State = 1157; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreateTokenQualifiedClassName(_localctx.scopeToken.Value, _localctx.typeName.Value); } @@ -5338,13 +5345,13 @@ public ClassNameContext className() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1152; + State = 1160; Match(T__41); - State = 1153; + State = 1161; Match(PTR); - State = 1154; + State = 1162; Match(T__42); - State = 1155; + State = 1163; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreatePointerQualifiedClassName(_localctx.typeName.Value); } @@ -5352,15 +5359,15 @@ public ClassNameContext className() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1158; + State = 1166; Match(T__41); - State = 1159; + State = 1167; Match(MODULE); - State = 1160; + State = 1168; _localctx.moduleName = dottedName(); - State = 1161; + State = 1169; Match(T__42); - State = 1162; + State = 1170; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreateModuleQualifiedClassName(_localctx.Start, _localctx.moduleName.Value, _localctx.typeName.Value); } @@ -5368,7 +5375,7 @@ public ClassNameContext className() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1165; + State = 1173; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreateUnqualifiedClassName(_localctx.typeName.Value); } @@ -5376,7 +5383,7 @@ public ClassNameContext className() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1168; + State = 1176; _localctx.typeToken = mdtoken(); _localctx.Value = Actions.CreateTokenClassName(_localctx.typeToken.Value); } @@ -5384,7 +5391,7 @@ public ClassNameContext className() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1171; + State = 1179; Match(THIS); _localctx.Value = Actions.CreateThisClassName(_localctx.Start); } @@ -5392,7 +5399,7 @@ public ClassNameContext className() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1173; + State = 1181; Match(BASE); _localctx.Value = Actions.CreateBaseClassName(_localctx.Start); } @@ -5400,7 +5407,7 @@ public ClassNameContext className() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1175; + State = 1183; Match(NESTER); _localctx.Value = Actions.CreateNesterClassName(_localctx.Start); } @@ -5450,26 +5457,26 @@ public SlashedNameContext slashedName() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1185; + State = 1193; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,49,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1179; + State = 1187; _localctx.part = dottedName(); Actions.AddSlashedNamePart(_localctx, _localctx.part.Value); - State = 1181; + State = 1189; Match(T__87); } } } - State = 1187; + State = 1195; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,49,Context); } - State = 1188; + State = 1196; _localctx.lastPart = dottedName(); Actions.AddSlashedNamePart(_localctx, _localctx.lastPart.Value); } @@ -5514,17 +5521,17 @@ public AssemblyDeclsContext assemblyDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 1194; + State = 1202; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38654771200L) != 0) || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & 4294975503L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 6860954690125825L) != 0)) { { { - State = 1191; + State = 1199; assemblyDecl(); } } - State = 1196; + State = 1204; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -5570,18 +5577,18 @@ public AssemblyDeclContext assemblyDecl() { AssemblyDeclContext _localctx = new AssemblyDeclContext(Context, State); EnterRule(_localctx, 122, RULE_assemblyDecl); try { - State = 1202; + State = 1210; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case HASH: EnterOuterAlt(_localctx, 1); { { - State = 1197; + State = 1205; Match(HASH); - State = 1198; + State = 1206; Match(T__88); - State = 1199; + State = 1207; int32(); } } @@ -5590,7 +5597,7 @@ public AssemblyDeclContext assemblyDecl() { case PERMISSIONSET: EnterOuterAlt(_localctx, 2); { - State = 1200; + State = 1208; secDecl(); } break; @@ -5615,7 +5622,7 @@ public AssemblyDeclContext assemblyDecl() { case ID: EnterOuterAlt(_localctx, 3); { - State = 1201; + State = 1209; asmOrRefDecl(); } break; @@ -5670,13 +5677,13 @@ public TypeSpecContext typeSpec() { EnterRule(_localctx, 124, RULE_typeSpec); Actions.BeginSemanticRoot(_localctx); try { - State = 1221; + State = 1229; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,52,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1204; + State = 1212; _localctx.classType = className(); _localctx.Value = Actions.CreateClassTypeSpecification(_localctx.classType.Value); } @@ -5684,11 +5691,11 @@ public TypeSpecContext typeSpec() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1207; + State = 1215; Match(T__41); - State = 1208; + State = 1216; _localctx.assemblyName = dottedName(); - State = 1209; + State = 1217; Match(T__42); _localctx.Value = Actions.CreateAssemblyTypeSpecification(_localctx.assemblyName.Value); } @@ -5696,13 +5703,13 @@ public TypeSpecContext typeSpec() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1212; + State = 1220; Match(T__41); - State = 1213; + State = 1221; Match(MODULE); - State = 1214; + State = 1222; _localctx.moduleName = dottedName(); - State = 1215; + State = 1223; Match(T__42); _localctx.Value = Actions.CreateModuleTypeSpecification(_localctx.moduleName.Value); } @@ -5710,7 +5717,7 @@ public TypeSpecContext typeSpec() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1218; + State = 1226; _localctx.signatureType = type(); _localctx.Value = Actions.CreateSignatureTypeSpecification(_localctx.signatureType.Value); } @@ -5762,7 +5769,7 @@ public NativeTypeContext nativeType() { Actions.BeginNativeType(_localctx); try { int _alt; - State = 1234; + State = 1242; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,54,Context) ) { case 1: @@ -5773,23 +5780,23 @@ public NativeTypeContext nativeType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1224; + State = 1232; _localctx.element = nativeTypeElement(); Actions.SetNativeTypeElement(_localctx, _localctx.element.Value); - State = 1231; + State = 1239; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,53,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1226; + State = 1234; _localctx.info = nativeTypeArrayPointerInfo(); Actions.AddNativeTypeArrayPointerInfo(_localctx, _localctx.info.Value); } } } - State = 1233; + State = 1241; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,53,Context); } @@ -5894,14 +5901,14 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { NativeTypeArrayPointerInfoContext _localctx = new NativeTypeArrayPointerInfoContext(Context, State); EnterRule(_localctx, 128, RULE_nativeTypeArrayPointerInfo); try { - State = 1258; + State = 1266; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,55,Context) ) { case 1: _localctx = new PointerNativeTypeContext(_localctx); EnterOuterAlt(_localctx, 1); { - State = 1236; + State = 1244; Match(PTR); _localctx.Value = Actions.CreatePointerNativeType(); } @@ -5910,7 +5917,7 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeNoSizeDataContext(_localctx); EnterOuterAlt(_localctx, 2); { - State = 1238; + State = 1246; Match(ARRAY_TYPE_NO_BOUNDS); _localctx.Value = Actions.CreatePointerArrayTypeNoSizeData(); } @@ -5919,11 +5926,11 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeSizeContext(_localctx); EnterOuterAlt(_localctx, 3); { - State = 1240; + State = 1248; Match(T__41); - State = 1241; + State = 1249; ((PointerArrayTypeSizeContext)_localctx).size = int32(); - State = 1242; + State = 1250; Match(T__42); _localctx.Value = Actions.CreatePointerArrayTypeSize((((PointerArrayTypeSizeContext)_localctx).size!=null?(((PointerArrayTypeSizeContext)_localctx).size.Start):null)); } @@ -5932,15 +5939,15 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeSizeParamIndexContext(_localctx); EnterOuterAlt(_localctx, 4); { - State = 1245; + State = 1253; Match(T__41); - State = 1246; + State = 1254; ((PointerArrayTypeSizeParamIndexContext)_localctx).size = int32(); - State = 1247; + State = 1255; Match(PLUS); - State = 1248; + State = 1256; ((PointerArrayTypeSizeParamIndexContext)_localctx).parameterIndex = int32(); - State = 1249; + State = 1257; Match(T__42); _localctx.Value = Actions.CreatePointerArrayTypeSizeParamIndex((((PointerArrayTypeSizeParamIndexContext)_localctx).size!=null?(((PointerArrayTypeSizeParamIndexContext)_localctx).size.Start):null), (((PointerArrayTypeSizeParamIndexContext)_localctx).parameterIndex!=null?(((PointerArrayTypeSizeParamIndexContext)_localctx).parameterIndex.Start):null)); } @@ -5949,13 +5956,13 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeParamIndexContext(_localctx); EnterOuterAlt(_localctx, 5); { - State = 1252; + State = 1260; Match(T__41); - State = 1253; + State = 1261; Match(PLUS); - State = 1254; + State = 1262; ((PointerArrayTypeParamIndexContext)_localctx).parameterIndex = int32(); - State = 1255; + State = 1263; Match(T__42); _localctx.Value = Actions.CreatePointerArrayTypeParamIndex((((PointerArrayTypeParamIndexContext)_localctx).parameterIndex!=null?(((PointerArrayTypeParamIndexContext)_localctx).parameterIndex.Start):null)); } @@ -6067,7 +6074,7 @@ public NativeTypeElementContext nativeTypeElement() { NativeTypeElementContext _localctx = new NativeTypeElementContext(Context, State); EnterRule(_localctx, 130, RULE_nativeTypeElement); try { - State = 1405; + State = 1413; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,56,Context) ) { case 1: @@ -6079,25 +6086,25 @@ public NativeTypeElementContext nativeTypeElement() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1261; + State = 1269; _localctx.marshalType = Match(CUSTOM); - State = 1262; + State = 1270; Match(T__29); - State = 1263; + State = 1271; _localctx.guid = compQstring(); - State = 1264; + State = 1272; Match(T__27); - State = 1265; + State = 1273; _localctx.nativeTypeName = compQstring(); - State = 1266; + State = 1274; Match(T__27); - State = 1267; + State = 1275; _localctx.marshallerType = compQstring(); - State = 1268; + State = 1276; Match(T__27); - State = 1269; + State = 1277; _localctx.cookie = compQstring(); - State = 1270; + State = 1278; Match(T__30); _localctx.Value = Actions.CreateDeprecatedCustomMarshallerNativeType( _localctx, _localctx.guid.Value, _localctx.nativeTypeName.Value, _localctx.marshallerType.Value, _localctx.cookie.Value); @@ -6106,17 +6113,17 @@ public NativeTypeElementContext nativeTypeElement() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1273; + State = 1281; _localctx.marshalType = Match(CUSTOM); - State = 1274; + State = 1282; Match(T__29); - State = 1275; + State = 1283; _localctx.marshallerType = compQstring(); - State = 1276; + State = 1284; Match(T__27); - State = 1277; + State = 1285; _localctx.cookie = compQstring(); - State = 1278; + State = 1286; Match(T__30); _localctx.Value = Actions.CreateCustomMarshallerNativeType(_localctx.marshallerType.Value, _localctx.cookie.Value); } @@ -6124,15 +6131,15 @@ public NativeTypeElementContext nativeTypeElement() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1281; + State = 1289; Match(FIXED); - State = 1282; + State = 1290; _localctx.marshalType = Match(SYSSTRING); - State = 1283; + State = 1291; Match(T__41); - State = 1284; + State = 1292; _localctx.size = int32(); - State = 1285; + State = 1293; Match(T__42); _localctx.Value = Actions.CreateFixedSysStringNativeType((_localctx.size!=null?(_localctx.size.Start):null)); } @@ -6140,17 +6147,17 @@ public NativeTypeElementContext nativeTypeElement() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1288; + State = 1296; Match(FIXED); - State = 1289; + State = 1297; _localctx.marshalType = Match(ARRAY); - State = 1290; + State = 1298; Match(T__41); - State = 1291; + State = 1299; _localctx.size = int32(); - State = 1292; + State = 1300; Match(T__42); - State = 1293; + State = 1301; _localctx.element = nativeType(); _localctx.Value = Actions.CreateFixedArrayNativeType((_localctx.size!=null?(_localctx.size.Start):null), _localctx.element.Value); } @@ -6158,7 +6165,7 @@ public NativeTypeElementContext nativeTypeElement() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1296; + State = 1304; _localctx.marshalType = Match(VARIANT); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6166,7 +6173,7 @@ public NativeTypeElementContext nativeTypeElement() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1298; + State = 1306; _localctx.marshalType = Match(CURRENCY); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6174,7 +6181,7 @@ public NativeTypeElementContext nativeTypeElement() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1300; + State = 1308; _localctx.marshalType = Match(SYSCHAR); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6182,7 +6189,7 @@ public NativeTypeElementContext nativeTypeElement() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1302; + State = 1310; _localctx.marshalType = Match(VOID); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6190,7 +6197,7 @@ public NativeTypeElementContext nativeTypeElement() { case 10: EnterOuterAlt(_localctx, 10); { - State = 1304; + State = 1312; _localctx.marshalType = Match(BOOL); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6198,7 +6205,7 @@ public NativeTypeElementContext nativeTypeElement() { case 11: EnterOuterAlt(_localctx, 11); { - State = 1306; + State = 1314; _localctx.marshalType = Match(INT8); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6206,7 +6213,7 @@ public NativeTypeElementContext nativeTypeElement() { case 12: EnterOuterAlt(_localctx, 12); { - State = 1308; + State = 1316; _localctx.marshalType = Match(INT16); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6214,7 +6221,7 @@ public NativeTypeElementContext nativeTypeElement() { case 13: EnterOuterAlt(_localctx, 13); { - State = 1310; + State = 1318; _localctx.marshalType = Match(INT32_); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6222,7 +6229,7 @@ public NativeTypeElementContext nativeTypeElement() { case 14: EnterOuterAlt(_localctx, 14); { - State = 1312; + State = 1320; _localctx.marshalType = Match(INT64_); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6230,7 +6237,7 @@ public NativeTypeElementContext nativeTypeElement() { case 15: EnterOuterAlt(_localctx, 15); { - State = 1314; + State = 1322; _localctx.marshalType = Match(FLOAT32); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6238,7 +6245,7 @@ public NativeTypeElementContext nativeTypeElement() { case 16: EnterOuterAlt(_localctx, 16); { - State = 1316; + State = 1324; _localctx.marshalType = Match(FLOAT64_); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6246,7 +6253,7 @@ public NativeTypeElementContext nativeTypeElement() { case 17: EnterOuterAlt(_localctx, 17); { - State = 1318; + State = 1326; _localctx.marshalType = Match(ERROR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6254,7 +6261,7 @@ public NativeTypeElementContext nativeTypeElement() { case 18: EnterOuterAlt(_localctx, 18); { - State = 1320; + State = 1328; _localctx.marshalType = Match(UINT8); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6262,7 +6269,7 @@ public NativeTypeElementContext nativeTypeElement() { case 19: EnterOuterAlt(_localctx, 19); { - State = 1322; + State = 1330; _localctx.marshalType = Match(UINT16); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6270,7 +6277,7 @@ public NativeTypeElementContext nativeTypeElement() { case 20: EnterOuterAlt(_localctx, 20); { - State = 1324; + State = 1332; _localctx.marshalType = Match(UINT32); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6278,7 +6285,7 @@ public NativeTypeElementContext nativeTypeElement() { case 21: EnterOuterAlt(_localctx, 21); { - State = 1326; + State = 1334; _localctx.marshalType = Match(UINT64); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6286,7 +6293,7 @@ public NativeTypeElementContext nativeTypeElement() { case 22: EnterOuterAlt(_localctx, 22); { - State = 1328; + State = 1336; _localctx.marshalType = Match(DECIMAL); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6294,7 +6301,7 @@ public NativeTypeElementContext nativeTypeElement() { case 23: EnterOuterAlt(_localctx, 23); { - State = 1330; + State = 1338; _localctx.marshalType = Match(DATE); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6302,7 +6309,7 @@ public NativeTypeElementContext nativeTypeElement() { case 24: EnterOuterAlt(_localctx, 24); { - State = 1332; + State = 1340; _localctx.marshalType = Match(BSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6310,7 +6317,7 @@ public NativeTypeElementContext nativeTypeElement() { case 25: EnterOuterAlt(_localctx, 25); { - State = 1334; + State = 1342; _localctx.marshalType = Match(LPSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6318,7 +6325,7 @@ public NativeTypeElementContext nativeTypeElement() { case 26: EnterOuterAlt(_localctx, 26); { - State = 1336; + State = 1344; _localctx.marshalType = Match(LPWSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6326,7 +6333,7 @@ public NativeTypeElementContext nativeTypeElement() { case 27: EnterOuterAlt(_localctx, 27); { - State = 1338; + State = 1346; _localctx.marshalType = Match(LPTSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6334,7 +6341,7 @@ public NativeTypeElementContext nativeTypeElement() { case 28: EnterOuterAlt(_localctx, 28); { - State = 1340; + State = 1348; _localctx.marshalType = Match(OBJECTREF); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6342,9 +6349,9 @@ public NativeTypeElementContext nativeTypeElement() { case 29: EnterOuterAlt(_localctx, 29); { - State = 1342; + State = 1350; _localctx.marshalType = Match(IUNKNOWN); - State = 1343; + State = 1351; _localctx.index = iidParamIndex(); _localctx.Value = Actions.CreateIidNativeType(_localctx.marshalType, _localctx.index.Value); } @@ -6352,9 +6359,9 @@ public NativeTypeElementContext nativeTypeElement() { case 30: EnterOuterAlt(_localctx, 30); { - State = 1346; + State = 1354; _localctx.marshalType = Match(IDISPATCH); - State = 1347; + State = 1355; _localctx.index = iidParamIndex(); _localctx.Value = Actions.CreateIidNativeType(_localctx.marshalType, _localctx.index.Value); } @@ -6362,7 +6369,7 @@ public NativeTypeElementContext nativeTypeElement() { case 31: EnterOuterAlt(_localctx, 31); { - State = 1350; + State = 1358; _localctx.marshalType = Match(STRUCT); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6370,9 +6377,9 @@ public NativeTypeElementContext nativeTypeElement() { case 32: EnterOuterAlt(_localctx, 32); { - State = 1352; + State = 1360; _localctx.marshalType = Match(INTERFACE); - State = 1353; + State = 1361; _localctx.index = iidParamIndex(); _localctx.Value = Actions.CreateIidNativeType(_localctx.marshalType, _localctx.index.Value); } @@ -6380,9 +6387,9 @@ public NativeTypeElementContext nativeTypeElement() { case 33: EnterOuterAlt(_localctx, 33); { - State = 1356; + State = 1364; _localctx.marshalType = Match(SAFEARRAY); - State = 1357; + State = 1365; _localctx.variant = variantType(); _localctx.Value = Actions.CreateSafeArrayNativeType(_localctx.variant.Value, null); } @@ -6390,13 +6397,13 @@ public NativeTypeElementContext nativeTypeElement() { case 34: EnterOuterAlt(_localctx, 34); { - State = 1360; + State = 1368; _localctx.marshalType = Match(SAFEARRAY); - State = 1361; + State = 1369; _localctx.variant = variantType(); - State = 1362; + State = 1370; Match(T__27); - State = 1363; + State = 1371; _localctx.userDefinedType = compQstring(); _localctx.Value = Actions.CreateSafeArrayNativeType(_localctx.variant.Value, _localctx.userDefinedType.Value); } @@ -6404,7 +6411,7 @@ public NativeTypeElementContext nativeTypeElement() { case 35: EnterOuterAlt(_localctx, 35); { - State = 1366; + State = 1374; _localctx.marshalType = Match(INT); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6412,7 +6419,7 @@ public NativeTypeElementContext nativeTypeElement() { case 36: EnterOuterAlt(_localctx, 36); { - State = 1368; + State = 1376; _localctx.marshalType = Match(UINT); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6420,9 +6427,9 @@ public NativeTypeElementContext nativeTypeElement() { case 37: EnterOuterAlt(_localctx, 37); { - State = 1370; + State = 1378; Match(T__89); - State = 1371; + State = 1379; _localctx.unsignedMarshalType = Match(INT8); _localctx.Value = Actions.CreateUnsignedNativeType(_localctx.unsignedMarshalType); } @@ -6430,9 +6437,9 @@ public NativeTypeElementContext nativeTypeElement() { case 38: EnterOuterAlt(_localctx, 38); { - State = 1373; + State = 1381; Match(T__89); - State = 1374; + State = 1382; _localctx.unsignedMarshalType = Match(INT16); _localctx.Value = Actions.CreateUnsignedNativeType(_localctx.unsignedMarshalType); } @@ -6440,9 +6447,9 @@ public NativeTypeElementContext nativeTypeElement() { case 39: EnterOuterAlt(_localctx, 39); { - State = 1376; + State = 1384; Match(T__89); - State = 1377; + State = 1385; _localctx.unsignedMarshalType = Match(INT32_); _localctx.Value = Actions.CreateUnsignedNativeType(_localctx.unsignedMarshalType); } @@ -6450,9 +6457,9 @@ public NativeTypeElementContext nativeTypeElement() { case 40: EnterOuterAlt(_localctx, 40); { - State = 1379; + State = 1387; Match(T__89); - State = 1380; + State = 1388; _localctx.unsignedMarshalType = Match(INT64_); _localctx.Value = Actions.CreateUnsignedNativeType(_localctx.unsignedMarshalType); } @@ -6460,9 +6467,9 @@ public NativeTypeElementContext nativeTypeElement() { case 41: EnterOuterAlt(_localctx, 41); { - State = 1382; + State = 1390; Match(T__61); - State = 1383; + State = 1391; _localctx.marshalType = Match(STRUCT); _localctx.Value = Actions.CreateNestedStructNativeType(_localctx); } @@ -6470,7 +6477,7 @@ public NativeTypeElementContext nativeTypeElement() { case 42: EnterOuterAlt(_localctx, 42); { - State = 1385; + State = 1393; _localctx.marshalType = Match(BYVALSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6478,9 +6485,9 @@ public NativeTypeElementContext nativeTypeElement() { case 43: EnterOuterAlt(_localctx, 43); { - State = 1387; + State = 1395; Match(ANSI); - State = 1388; + State = 1396; _localctx.marshalType = Match(BSTR); _localctx.Value = Actions.CreateAnsiBstrNativeType(); } @@ -6488,7 +6495,7 @@ public NativeTypeElementContext nativeTypeElement() { case 44: EnterOuterAlt(_localctx, 44); { - State = 1390; + State = 1398; _localctx.marshalType = Match(TBSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6496,9 +6503,9 @@ public NativeTypeElementContext nativeTypeElement() { case 45: EnterOuterAlt(_localctx, 45); { - State = 1392; + State = 1400; Match(VARIANT); - State = 1393; + State = 1401; _localctx.marshalBool = Match(BOOL); _localctx.Value = Actions.CreateVariantBoolNativeType(); } @@ -6506,7 +6513,7 @@ public NativeTypeElementContext nativeTypeElement() { case 46: EnterOuterAlt(_localctx, 46); { - State = 1395; + State = 1403; _localctx.marshalType = Match(METHOD); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6514,7 +6521,7 @@ public NativeTypeElementContext nativeTypeElement() { case 47: EnterOuterAlt(_localctx, 47); { - State = 1397; + State = 1405; _localctx.marshalType = Match(LPSTRUCT); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6522,9 +6529,9 @@ public NativeTypeElementContext nativeTypeElement() { case 48: EnterOuterAlt(_localctx, 48); { - State = 1399; + State = 1407; Match(T__33); - State = 1400; + State = 1408; _localctx.marshalType = Match(ANY); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6532,7 +6539,7 @@ public NativeTypeElementContext nativeTypeElement() { case 49: EnterOuterAlt(_localctx, 49); { - State = 1402; + State = 1410; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateNativeTypeTypedef(_localctx, _localctx.alias.Value); } @@ -6574,7 +6581,7 @@ public IidParamIndexContext iidParamIndex() { IidParamIndexContext _localctx = new IidParamIndexContext(Context, State); EnterRule(_localctx, 132, RULE_iidParamIndex); try { - State = 1415; + State = 1423; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__30: @@ -6588,15 +6595,15 @@ public IidParamIndexContext iidParamIndex() { case T__29: EnterOuterAlt(_localctx, 2); { - State = 1408; + State = 1416; Match(T__29); - State = 1409; + State = 1417; Match(T__90); - State = 1410; + State = 1418; Match(T__35); - State = 1411; + State = 1419; _localctx.index = int32(); - State = 1412; + State = 1420; Match(T__30); _localctx.Value = Actions.GetIidParamIndex((_localctx.index!=null?(_localctx.index.Start):null)); } @@ -6656,7 +6663,7 @@ public VariantTypeContext variantType() { int _la; try { int _alt; - State = 1427; + State = 1435; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,59,Context) ) { case 1: @@ -6667,17 +6674,17 @@ public VariantTypeContext variantType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1418; + State = 1426; _localctx.element = variantTypeElement(); Actions.SetVariantTypeElement(_localctx, _localctx.element.Value); - State = 1424; + State = 1432; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,58,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1420; + State = 1428; _localctx.modifier = TokenStream.LT(1); _la = TokenStream.LA(1); if ( !(((((_la - 229)) & ~0x3f) == 0 && ((1L << (_la - 229)) & 6442450945L) != 0)) ) { @@ -6691,7 +6698,7 @@ public VariantTypeContext variantType() { } } } - State = 1426; + State = 1434; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,58,Context); } @@ -6772,13 +6779,13 @@ public VariantTypeElementContext variantTypeElement() { VariantTypeElementContext _localctx = new VariantTypeElementContext(Context, State); EnterRule(_localctx, 136, RULE_variantTypeElement); try { - State = 1509; + State = 1517; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case NULL: EnterOuterAlt(_localctx, 1); { - State = 1429; + State = 1437; _localctx.value = Match(NULL); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6786,7 +6793,7 @@ public VariantTypeElementContext variantTypeElement() { case VARIANT: EnterOuterAlt(_localctx, 2); { - State = 1431; + State = 1439; _localctx.value = Match(VARIANT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6794,7 +6801,7 @@ public VariantTypeElementContext variantTypeElement() { case CURRENCY: EnterOuterAlt(_localctx, 3); { - State = 1433; + State = 1441; _localctx.value = Match(CURRENCY); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6802,7 +6809,7 @@ public VariantTypeElementContext variantTypeElement() { case VOID: EnterOuterAlt(_localctx, 4); { - State = 1435; + State = 1443; _localctx.value = Match(VOID); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6810,7 +6817,7 @@ public VariantTypeElementContext variantTypeElement() { case BOOL: EnterOuterAlt(_localctx, 5); { - State = 1437; + State = 1445; _localctx.value = Match(BOOL); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6818,7 +6825,7 @@ public VariantTypeElementContext variantTypeElement() { case INT8: EnterOuterAlt(_localctx, 6); { - State = 1439; + State = 1447; _localctx.value = Match(INT8); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6826,7 +6833,7 @@ public VariantTypeElementContext variantTypeElement() { case INT16: EnterOuterAlt(_localctx, 7); { - State = 1441; + State = 1449; _localctx.value = Match(INT16); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6834,7 +6841,7 @@ public VariantTypeElementContext variantTypeElement() { case INT32_: EnterOuterAlt(_localctx, 8); { - State = 1443; + State = 1451; _localctx.value = Match(INT32_); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6842,7 +6849,7 @@ public VariantTypeElementContext variantTypeElement() { case INT64_: EnterOuterAlt(_localctx, 9); { - State = 1445; + State = 1453; _localctx.value = Match(INT64_); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6850,7 +6857,7 @@ public VariantTypeElementContext variantTypeElement() { case FLOAT32: EnterOuterAlt(_localctx, 10); { - State = 1447; + State = 1455; _localctx.value = Match(FLOAT32); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6858,7 +6865,7 @@ public VariantTypeElementContext variantTypeElement() { case FLOAT64_: EnterOuterAlt(_localctx, 11); { - State = 1449; + State = 1457; _localctx.value = Match(FLOAT64_); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6866,7 +6873,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT8: EnterOuterAlt(_localctx, 12); { - State = 1451; + State = 1459; _localctx.value = Match(UINT8); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6874,7 +6881,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT16: EnterOuterAlt(_localctx, 13); { - State = 1453; + State = 1461; _localctx.value = Match(UINT16); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6882,7 +6889,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT32: EnterOuterAlt(_localctx, 14); { - State = 1455; + State = 1463; _localctx.value = Match(UINT32); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6890,7 +6897,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT64: EnterOuterAlt(_localctx, 15); { - State = 1457; + State = 1465; _localctx.value = Match(UINT64); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6898,7 +6905,7 @@ public VariantTypeElementContext variantTypeElement() { case PTR: EnterOuterAlt(_localctx, 16); { - State = 1459; + State = 1467; _localctx.value = Match(PTR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6906,7 +6913,7 @@ public VariantTypeElementContext variantTypeElement() { case DECIMAL: EnterOuterAlt(_localctx, 17); { - State = 1461; + State = 1469; _localctx.value = Match(DECIMAL); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6914,7 +6921,7 @@ public VariantTypeElementContext variantTypeElement() { case DATE: EnterOuterAlt(_localctx, 18); { - State = 1463; + State = 1471; _localctx.value = Match(DATE); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6922,7 +6929,7 @@ public VariantTypeElementContext variantTypeElement() { case BSTR: EnterOuterAlt(_localctx, 19); { - State = 1465; + State = 1473; _localctx.value = Match(BSTR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6930,7 +6937,7 @@ public VariantTypeElementContext variantTypeElement() { case LPSTR: EnterOuterAlt(_localctx, 20); { - State = 1467; + State = 1475; _localctx.value = Match(LPSTR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6938,7 +6945,7 @@ public VariantTypeElementContext variantTypeElement() { case LPWSTR: EnterOuterAlt(_localctx, 21); { - State = 1469; + State = 1477; _localctx.value = Match(LPWSTR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6946,7 +6953,7 @@ public VariantTypeElementContext variantTypeElement() { case IUNKNOWN: EnterOuterAlt(_localctx, 22); { - State = 1471; + State = 1479; _localctx.value = Match(IUNKNOWN); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6954,7 +6961,7 @@ public VariantTypeElementContext variantTypeElement() { case IDISPATCH: EnterOuterAlt(_localctx, 23); { - State = 1473; + State = 1481; _localctx.value = Match(IDISPATCH); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6962,7 +6969,7 @@ public VariantTypeElementContext variantTypeElement() { case SAFEARRAY: EnterOuterAlt(_localctx, 24); { - State = 1475; + State = 1483; _localctx.value = Match(SAFEARRAY); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6970,7 +6977,7 @@ public VariantTypeElementContext variantTypeElement() { case INT: EnterOuterAlt(_localctx, 25); { - State = 1477; + State = 1485; _localctx.value = Match(INT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6978,7 +6985,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT: EnterOuterAlt(_localctx, 26); { - State = 1479; + State = 1487; _localctx.value = Match(UINT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6986,7 +6993,7 @@ public VariantTypeElementContext variantTypeElement() { case ERROR: EnterOuterAlt(_localctx, 27); { - State = 1481; + State = 1489; _localctx.value = Match(ERROR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6994,7 +7001,7 @@ public VariantTypeElementContext variantTypeElement() { case HRESULT: EnterOuterAlt(_localctx, 28); { - State = 1483; + State = 1491; _localctx.value = Match(HRESULT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7002,7 +7009,7 @@ public VariantTypeElementContext variantTypeElement() { case CARRAY: EnterOuterAlt(_localctx, 29); { - State = 1485; + State = 1493; _localctx.value = Match(CARRAY); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7010,7 +7017,7 @@ public VariantTypeElementContext variantTypeElement() { case USERDEFINED: EnterOuterAlt(_localctx, 30); { - State = 1487; + State = 1495; _localctx.value = Match(USERDEFINED); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7018,7 +7025,7 @@ public VariantTypeElementContext variantTypeElement() { case RECORD: EnterOuterAlt(_localctx, 31); { - State = 1489; + State = 1497; _localctx.value = Match(RECORD); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7026,7 +7033,7 @@ public VariantTypeElementContext variantTypeElement() { case FILETIME: EnterOuterAlt(_localctx, 32); { - State = 1491; + State = 1499; _localctx.value = Match(FILETIME); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7034,7 +7041,7 @@ public VariantTypeElementContext variantTypeElement() { case BLOB: EnterOuterAlt(_localctx, 33); { - State = 1493; + State = 1501; _localctx.value = Match(BLOB); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7042,7 +7049,7 @@ public VariantTypeElementContext variantTypeElement() { case STREAM: EnterOuterAlt(_localctx, 34); { - State = 1495; + State = 1503; _localctx.value = Match(STREAM); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7050,7 +7057,7 @@ public VariantTypeElementContext variantTypeElement() { case STORAGE: EnterOuterAlt(_localctx, 35); { - State = 1497; + State = 1505; _localctx.value = Match(STORAGE); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7058,7 +7065,7 @@ public VariantTypeElementContext variantTypeElement() { case STREAMED_OBJECT: EnterOuterAlt(_localctx, 36); { - State = 1499; + State = 1507; _localctx.value = Match(STREAMED_OBJECT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7066,7 +7073,7 @@ public VariantTypeElementContext variantTypeElement() { case STORED_OBJECT: EnterOuterAlt(_localctx, 37); { - State = 1501; + State = 1509; _localctx.value = Match(STORED_OBJECT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7074,7 +7081,7 @@ public VariantTypeElementContext variantTypeElement() { case BLOB_OBJECT: EnterOuterAlt(_localctx, 38); { - State = 1503; + State = 1511; _localctx.value = Match(BLOB_OBJECT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7082,7 +7089,7 @@ public VariantTypeElementContext variantTypeElement() { case CF: EnterOuterAlt(_localctx, 39); { - State = 1505; + State = 1513; _localctx.value = Match(CF); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7090,7 +7097,7 @@ public VariantTypeElementContext variantTypeElement() { case CLSID: EnterOuterAlt(_localctx, 40); { - State = 1507; + State = 1515; _localctx.value = Match(CLSID); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7145,23 +7152,23 @@ public TypeContext type() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1511; + State = 1519; _localctx.element = elementType(); Actions.SetTypeSignatureElement(_localctx, _localctx.element.Value); - State = 1518; + State = 1526; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,61,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1513; + State = 1521; _localctx.modifier = typeModifiers(); Actions.AddTypeSignatureModifier(_localctx, _localctx.modifier.Value); } } } - State = 1520; + State = 1528; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,61,Context); } @@ -7290,14 +7297,14 @@ public TypeModifiersContext typeModifiers() { TypeModifiersContext _localctx = new TypeModifiersContext(Context, State); EnterRule(_localctx, 140, RULE_typeModifiers); try { - State = 1550; + State = 1558; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,62,Context) ) { case 1: _localctx = new SZArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 1); { - State = 1521; + State = 1529; Match(ARRAY_TYPE_NO_BOUNDS); _localctx.Value = Actions.CreateSzArrayTypeModifier(); } @@ -7306,9 +7313,9 @@ public TypeModifiersContext typeModifiers() { _localctx = new SZArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 2); { - State = 1523; + State = 1531; Match(T__41); - State = 1524; + State = 1532; Match(T__42); _localctx.Value = Actions.CreateSzArrayTypeModifier(); } @@ -7317,7 +7324,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new ArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 3); { - State = 1526; + State = 1534; ((ArrayModifierContext)_localctx).arrayBounds = bounds(); _localctx.Value = Actions.CreateArrayTypeModifier(((ArrayModifierContext)_localctx).arrayBounds.Value); } @@ -7326,7 +7333,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new ByRefModifierContext(_localctx); EnterOuterAlt(_localctx, 4); { - State = 1529; + State = 1537; Match(REF); _localctx.Value = Actions.CreateByReferenceTypeModifier(); } @@ -7335,7 +7342,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new PtrModifierContext(_localctx); EnterOuterAlt(_localctx, 5); { - State = 1531; + State = 1539; Match(PTR); _localctx.Value = Actions.CreatePointerTypeModifier(); } @@ -7344,7 +7351,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new PinnedModifierContext(_localctx); EnterOuterAlt(_localctx, 6); { - State = 1533; + State = 1541; Match(T__91); _localctx.Value = Actions.CreatePinnedTypeModifier(); } @@ -7353,13 +7360,13 @@ public TypeModifiersContext typeModifiers() { _localctx = new RequiredModifierContext(_localctx); EnterOuterAlt(_localctx, 7); { - State = 1535; + State = 1543; Match(T__92); - State = 1536; + State = 1544; Match(T__29); - State = 1537; + State = 1545; ((RequiredModifierContext)_localctx).modifierType = typeSpec(); - State = 1538; + State = 1546; Match(T__30); _localctx.Value = Actions.CreateCustomTypeModifier(((RequiredModifierContext)_localctx).modifierType.Value, true); } @@ -7368,13 +7375,13 @@ public TypeModifiersContext typeModifiers() { _localctx = new OptionalModifierContext(_localctx); EnterOuterAlt(_localctx, 8); { - State = 1541; + State = 1549; Match(T__93); - State = 1542; + State = 1550; Match(T__29); - State = 1543; + State = 1551; ((OptionalModifierContext)_localctx).modifierType = typeSpec(); - State = 1544; + State = 1552; Match(T__30); _localctx.Value = Actions.CreateCustomTypeModifier(((OptionalModifierContext)_localctx).modifierType.Value, false); } @@ -7383,7 +7390,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new GenericArgumentsModifierContext(_localctx); EnterOuterAlt(_localctx, 9); { - State = 1547; + State = 1555; ((GenericArgumentsModifierContext)_localctx).arguments = typeArgs(); _localctx.Value = Actions.CreateGenericArgumentsModifier(((GenericArgumentsModifierContext)_localctx).arguments.Value); } @@ -7471,15 +7478,15 @@ public ElementTypeContext elementType() { ElementTypeContext _localctx = new ElementTypeContext(Context, State); EnterRule(_localctx, 142, RULE_elementType); try { - State = 1610; + State = 1618; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,63,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1552; + State = 1560; Match(T__38); - State = 1553; + State = 1561; _localctx.classType = className(); _localctx.Value = Actions.CreateClassElementType(_localctx.classType.Value, false); } @@ -7487,7 +7494,7 @@ public ElementTypeContext elementType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1556; + State = 1564; Match(OBJECT); _localctx.Value = Actions.CreateObjectElementType(); } @@ -7495,11 +7502,11 @@ public ElementTypeContext elementType() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1558; + State = 1566; Match(VALUE); - State = 1559; + State = 1567; Match(T__38); - State = 1560; + State = 1568; _localctx.valueClassType = className(); _localctx.Value = Actions.CreateClassElementType(_localctx.valueClassType.Value, true); } @@ -7507,9 +7514,9 @@ public ElementTypeContext elementType() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1563; + State = 1571; Match(VALUETYPE); - State = 1564; + State = 1572; _localctx.valueType = className(); _localctx.Value = Actions.CreateClassElementType(_localctx.valueType.Value, true); } @@ -7517,15 +7524,15 @@ public ElementTypeContext elementType() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1567; + State = 1575; Match(METHOD); - State = 1568; + State = 1576; _localctx.convention = callConv(); - State = 1569; + State = 1577; _localctx.returnType = type(); - State = 1570; + State = 1578; Match(PTR); - State = 1571; + State = 1579; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateFunctionPointerElementType(_localctx.convention.Value, _localctx.returnType.Value, _localctx.arguments.Value); } @@ -7533,9 +7540,9 @@ public ElementTypeContext elementType() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1574; + State = 1582; Match(METHOD_TYPE_PARAMETER); - State = 1575; + State = 1583; _localctx.parameterIndex = int32(); _localctx.Value = Actions.CreateIndexedGenericParameterElementType(true, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null)); } @@ -7543,9 +7550,9 @@ public ElementTypeContext elementType() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1578; + State = 1586; Match(TYPE_PARAMETER); - State = 1579; + State = 1587; _localctx.parameterIndex = int32(); _localctx.Value = Actions.CreateIndexedGenericParameterElementType(false, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null)); } @@ -7553,9 +7560,9 @@ public ElementTypeContext elementType() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1582; + State = 1590; Match(METHOD_TYPE_PARAMETER); - State = 1583; + State = 1591; _localctx.parameterName = dottedName(); _localctx.Value = Actions.CreateNamedGenericParameterElementType(_localctx.Start, true, _localctx.parameterName.Value); } @@ -7563,9 +7570,9 @@ public ElementTypeContext elementType() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1586; + State = 1594; Match(TYPE_PARAMETER); - State = 1587; + State = 1595; _localctx.parameterName = dottedName(); _localctx.Value = Actions.CreateNamedGenericParameterElementType(_localctx.Start, false, _localctx.parameterName.Value); } @@ -7573,7 +7580,7 @@ public ElementTypeContext elementType() { case 10: EnterOuterAlt(_localctx, 10); { - State = 1590; + State = 1598; Match(TYPEDREF); _localctx.Value = Actions.CreateTypedReferenceElementType(); } @@ -7581,7 +7588,7 @@ public ElementTypeContext elementType() { case 11: EnterOuterAlt(_localctx, 11); { - State = 1592; + State = 1600; Match(VOID); _localctx.Value = Actions.CreateVoidElementType(); } @@ -7589,7 +7596,7 @@ public ElementTypeContext elementType() { case 12: EnterOuterAlt(_localctx, 12); { - State = 1594; + State = 1602; _localctx.signedNative = nativeInt(); _localctx.Value = Actions.CreatePrimitiveElementType(_localctx.signedNative.Value); } @@ -7597,7 +7604,7 @@ public ElementTypeContext elementType() { case 13: EnterOuterAlt(_localctx, 13); { - State = 1597; + State = 1605; _localctx.unsignedNative = nativeUint(); _localctx.Value = Actions.CreatePrimitiveElementType(_localctx.unsignedNative.Value); } @@ -7605,7 +7612,7 @@ public ElementTypeContext elementType() { case 14: EnterOuterAlt(_localctx, 14); { - State = 1600; + State = 1608; _localctx.primitive = simpleType(); _localctx.Value = Actions.CreatePrimitiveElementType(_localctx.primitive.Value); } @@ -7613,7 +7620,7 @@ public ElementTypeContext elementType() { case 15: EnterOuterAlt(_localctx, 15); { - State = 1603; + State = 1611; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateTypedefElementType(_localctx.Start, _localctx.alias.Value); } @@ -7621,9 +7628,9 @@ public ElementTypeContext elementType() { case 16: EnterOuterAlt(_localctx, 16); { - State = 1606; + State = 1614; Match(ELLIPSIS); - State = 1607; + State = 1615; _localctx.sentinelType = type(); _localctx.Value = Actions.CreateSentinelElementType(_localctx.sentinelType.Value); } @@ -7675,13 +7682,13 @@ public SimpleTypeContext simpleType() { SimpleTypeContext _localctx = new SimpleTypeContext(Context, State); EnterRule(_localctx, 144, RULE_simpleType); try { - State = 1650; + State = 1658; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,64,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1612; + State = 1620; _localctx.value = Match(CHAR); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7689,7 +7696,7 @@ public SimpleTypeContext simpleType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1614; + State = 1622; _localctx.value = Match(STRING); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7697,7 +7704,7 @@ public SimpleTypeContext simpleType() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1616; + State = 1624; _localctx.value = Match(BOOL); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7705,7 +7712,7 @@ public SimpleTypeContext simpleType() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1618; + State = 1626; _localctx.value = Match(INT8); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7713,7 +7720,7 @@ public SimpleTypeContext simpleType() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1620; + State = 1628; _localctx.value = Match(INT16); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7721,7 +7728,7 @@ public SimpleTypeContext simpleType() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1622; + State = 1630; _localctx.value = Match(INT32_); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7729,7 +7736,7 @@ public SimpleTypeContext simpleType() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1624; + State = 1632; _localctx.value = Match(INT64_); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7737,7 +7744,7 @@ public SimpleTypeContext simpleType() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1626; + State = 1634; _localctx.value = Match(FLOAT32); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7745,7 +7752,7 @@ public SimpleTypeContext simpleType() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1628; + State = 1636; _localctx.value = Match(FLOAT64_); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7753,7 +7760,7 @@ public SimpleTypeContext simpleType() { case 10: EnterOuterAlt(_localctx, 10); { - State = 1630; + State = 1638; _localctx.value = Match(UINT8); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7761,7 +7768,7 @@ public SimpleTypeContext simpleType() { case 11: EnterOuterAlt(_localctx, 11); { - State = 1632; + State = 1640; _localctx.value = Match(UINT16); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7769,7 +7776,7 @@ public SimpleTypeContext simpleType() { case 12: EnterOuterAlt(_localctx, 12); { - State = 1634; + State = 1642; _localctx.value = Match(UINT32); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7777,7 +7784,7 @@ public SimpleTypeContext simpleType() { case 13: EnterOuterAlt(_localctx, 13); { - State = 1636; + State = 1644; _localctx.value = Match(UINT64); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7785,9 +7792,9 @@ public SimpleTypeContext simpleType() { case 14: EnterOuterAlt(_localctx, 14); { - State = 1638; + State = 1646; Match(T__89); - State = 1639; + State = 1647; _localctx.value = Match(INT8); _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } @@ -7795,9 +7802,9 @@ public SimpleTypeContext simpleType() { case 15: EnterOuterAlt(_localctx, 15); { - State = 1641; + State = 1649; Match(T__89); - State = 1642; + State = 1650; _localctx.value = Match(INT16); _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } @@ -7805,9 +7812,9 @@ public SimpleTypeContext simpleType() { case 16: EnterOuterAlt(_localctx, 16); { - State = 1644; + State = 1652; Match(T__89); - State = 1645; + State = 1653; _localctx.value = Match(INT32_); _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } @@ -7815,9 +7822,9 @@ public SimpleTypeContext simpleType() { case 17: EnterOuterAlt(_localctx, 17); { - State = 1647; + State = 1655; Match(T__89); - State = 1648; + State = 1656; _localctx.value = Match(INT64_); _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } @@ -7869,7 +7876,7 @@ public BoundContext bound() { EnterRule(_localctx, 146, RULE_bound); Actions.InitializeBound(_localctx); try { - State = 1666; + State = 1674; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,65,Context) ) { case 1: @@ -7880,14 +7887,14 @@ public BoundContext bound() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1653; + State = 1661; Match(ELLIPSIS); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1654; + State = 1662; _localctx.size = int32(); Actions.SetBoundSize(_localctx, (_localctx.size!=null?(_localctx.size.Start):null)); } @@ -7895,11 +7902,11 @@ public BoundContext bound() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1657; + State = 1665; _localctx.lower = int32(); - State = 1658; + State = 1666; Match(ELLIPSIS); - State = 1659; + State = 1667; _localctx.upper = int32(); Actions.SetBoundRange(_localctx, (_localctx.lower!=null?(_localctx.lower.Start):null), (_localctx.upper!=null?(_localctx.upper.Start):null)); } @@ -7907,9 +7914,9 @@ public BoundContext bound() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1662; + State = 1670; _localctx.lower = int32(); - State = 1663; + State = 1671; Match(ELLIPSIS); Actions.SetBoundLower(_localctx, (_localctx.lower!=null?(_localctx.lower.Start):null)); } @@ -7950,9 +7957,9 @@ public NativeIntContext nativeInt() { try { EnterOuterAlt(_localctx, 1); { - State = 1668; + State = 1676; Match(T__0); - State = 1669; + State = 1677; Match(INT); _localctx.Value = Actions.GetNativeIntType(); } @@ -7992,22 +7999,22 @@ public NativeUintContext nativeUint() { try { EnterOuterAlt(_localctx, 1); { - State = 1672; + State = 1680; Match(T__0); - State = 1676; + State = 1684; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__89: { - State = 1673; + State = 1681; Match(T__89); - State = 1674; + State = 1682; Match(INT); } break; case UINT: { - State = 1675; + State = 1683; Match(UINT); } break; @@ -8029,6 +8036,7 @@ public NativeUintContext nativeUint() { } public partial class SecDeclContext : ParserRuleContext { + public bool HasSyntaxError; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PERMISSION() { return GetToken(CILParser.PERMISSION, 0); } [System.Diagnostics.DebuggerNonUserCode] public SecActionContext secAction() { return GetRuleContext(0); @@ -8069,127 +8077,128 @@ public override TResult Accept(IParseTreeVisitor visitor) { public SecDeclContext secDecl() { SecDeclContext _localctx = new SecDeclContext(Context, State); EnterRule(_localctx, 152, RULE_secDecl); + BeginSubtree(); Actions.BeginSemanticRoot(_localctx); int _la; try { - State = 1727; + State = 1735; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,68,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1680; + State = 1688; Match(PERMISSION); - State = 1681; + State = 1689; secAction(); - State = 1682; + State = 1690; typeSpec(); - State = 1683; + State = 1691; Match(T__29); - State = 1684; + State = 1692; nameValPairs(); - State = 1685; + State = 1693; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1687; + State = 1695; Match(PERMISSION); - State = 1688; + State = 1696; secAction(); - State = 1689; + State = 1697; typeSpec(); - State = 1690; + State = 1698; Match(T__35); - State = 1691; + State = 1699; Match(T__16); - State = 1692; + State = 1700; customBlobDescr(); - State = 1693; + State = 1701; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1695; + State = 1703; Match(PERMISSION); - State = 1696; + State = 1704; secAction(); - State = 1697; + State = 1705; typeSpec(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1699; + State = 1707; Match(PERMISSIONSET); - State = 1700; + State = 1708; secAction(); - State = 1701; + State = 1709; Match(T__35); - State = 1703; + State = 1711; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__83) { { - State = 1702; + State = 1710; Match(T__83); } } - State = 1705; + State = 1713; Match(T__29); - State = 1706; + State = 1714; bytes(); - State = 1707; + State = 1715; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1709; + State = 1717; Match(PERMISSIONSET); - State = 1710; + State = 1718; secAction(); - State = 1711; + State = 1719; Match(T__83); - State = 1712; + State = 1720; Match(T__29); - State = 1713; + State = 1721; bytes(); - State = 1714; + State = 1722; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1716; + State = 1724; Match(PERMISSIONSET); - State = 1717; + State = 1725; secAction(); - State = 1718; + State = 1726; compQstring(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1720; + State = 1728; Match(PERMISSIONSET); - State = 1721; + State = 1729; secAction(); - State = 1722; + State = 1730; Match(T__35); - State = 1723; + State = 1731; Match(T__16); - State = 1724; + State = 1732; secAttrSetBlob(); - State = 1725; + State = 1733; Match(T__17); } break; @@ -8201,6 +8210,7 @@ public SecDeclContext secDecl() { ErrorHandler.Recover(this, re); } finally { + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; @@ -8232,7 +8242,7 @@ public SecAttrSetBlobContext secAttrSetBlob() { EnterRule(_localctx, 154, RULE_secAttrSetBlob); try { int _alt; - State = 1739; + State = 1747; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__17: @@ -8277,25 +8287,25 @@ public SecAttrSetBlobContext secAttrSetBlob() { case ID: EnterOuterAlt(_localctx, 2); { - State = 1735; + State = 1743; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,69,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1730; + State = 1738; secAttrBlob(); - State = 1731; + State = 1739; Match(T__27); } } } - State = 1737; + State = 1745; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,69,Context); } - State = 1738; + State = 1746; secAttrBlob(); } break; @@ -8340,38 +8350,38 @@ public SecAttrBlobContext secAttrBlob() { SecAttrBlobContext _localctx = new SecAttrBlobContext(Context, State); EnterRule(_localctx, 156, RULE_secAttrBlob); try { - State = 1754; + State = 1762; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,71,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1741; + State = 1749; Match(T__38); - State = 1742; + State = 1750; Match(SQSTRING); - State = 1743; + State = 1751; Match(T__35); - State = 1744; + State = 1752; Match(T__16); - State = 1745; + State = 1753; customBlobNVPairs(); - State = 1746; + State = 1754; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1748; + State = 1756; typeSpec(); - State = 1749; + State = 1757; Match(T__35); - State = 1750; + State = 1758; Match(T__16); - State = 1751; + State = 1759; customBlobNVPairs(); - State = 1752; + State = 1760; Match(T__17); } break; @@ -8416,25 +8426,25 @@ public NameValPairsContext nameValPairs() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1761; + State = 1769; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,72,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1756; + State = 1764; nameValPair(); - State = 1757; + State = 1765; Match(T__27); } } } - State = 1763; + State = 1771; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,72,Context); } - State = 1764; + State = 1772; nameValPair(); } } @@ -8476,11 +8486,11 @@ public NameValPairContext nameValPair() { try { EnterOuterAlt(_localctx, 1); { - State = 1766; + State = 1774; compQstring(); - State = 1767; + State = 1775; Match(T__35); - State = 1768; + State = 1776; caValue(); } } @@ -8517,7 +8527,7 @@ public TruefalseContext truefalse() { try { EnterOuterAlt(_localctx, 1); { - State = 1770; + State = 1778; _la = TokenStream.LA(1); if ( !(_la==T__94 || _la==T__95) ) { ErrorHandler.RecoverInline(this); @@ -8573,104 +8583,104 @@ public CaValueContext caValue() { CaValueContext _localctx = new CaValueContext(Context, State); EnterRule(_localctx, 164, RULE_caValue); try { - State = 1806; + State = 1814; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,73,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1772; + State = 1780; truefalse(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1773; + State = 1781; int32(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1774; + State = 1782; Match(INT32_); - State = 1775; + State = 1783; Match(T__29); - State = 1776; + State = 1784; int32(); - State = 1777; + State = 1785; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1779; + State = 1787; compQstring(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1780; + State = 1788; className(); - State = 1781; + State = 1789; Match(T__29); - State = 1782; + State = 1790; Match(INT8); - State = 1783; + State = 1791; Match(T__74); - State = 1784; + State = 1792; int32(); - State = 1785; + State = 1793; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1787; + State = 1795; className(); - State = 1788; + State = 1796; Match(T__29); - State = 1789; + State = 1797; Match(INT16); - State = 1790; + State = 1798; Match(T__74); - State = 1791; + State = 1799; int32(); - State = 1792; + State = 1800; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1794; + State = 1802; className(); - State = 1795; + State = 1803; Match(T__29); - State = 1796; + State = 1804; Match(INT32_); - State = 1797; + State = 1805; Match(T__74); - State = 1798; + State = 1806; int32(); - State = 1799; + State = 1807; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1801; + State = 1809; className(); - State = 1802; + State = 1810; Match(T__29); - State = 1803; + State = 1811; int32(); - State = 1804; + State = 1812; Match(T__30); } break; @@ -8709,7 +8719,7 @@ public SecActionContext secAction() { try { EnterOuterAlt(_localctx, 1); { - State = 1808; + State = 1816; _la = TokenStream.LA(1); if ( !(((((_la - 97)) & ~0x3f) == 0 && ((1L << (_la - 97)) & 32767L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -8791,33 +8801,33 @@ public MethodRefContext methodRef() { Actions.BeginSemanticRoot(_localctx); int _la; try { - State = 1852; + State = 1860; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,76,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1810; + State = 1818; _localctx.convention = callConv(); - State = 1811; + State = 1819; _localctx.returnType = type(); - State = 1812; + State = 1820; _localctx.owner = typeSpec(); - State = 1813; + State = 1821; Match(DCOLON); - State = 1814; + State = 1822; _localctx.name = methodName(); - State = 1816; + State = 1824; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 1815; + State = 1823; _localctx.genericArguments = typeArgs(); } } - State = 1818; + State = 1826; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, _localctx.owner.Value, _localctx.name.Value, _localctx.genericArguments, null, _localctx.arguments.Value); } @@ -8825,19 +8835,19 @@ public MethodRefContext methodRef() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1821; + State = 1829; _localctx.convention = callConv(); - State = 1822; + State = 1830; _localctx.returnType = type(); - State = 1823; + State = 1831; _localctx.owner = typeSpec(); - State = 1824; + State = 1832; Match(DCOLON); - State = 1825; + State = 1833; _localctx.name = methodName(); - State = 1826; + State = 1834; _localctx.genericArity = genArityNotEmpty(); - State = 1827; + State = 1835; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, _localctx.owner.Value, _localctx.name.Value, null, _localctx.genericArity.Value, _localctx.arguments.Value); } @@ -8845,23 +8855,23 @@ public MethodRefContext methodRef() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1830; + State = 1838; _localctx.convention = callConv(); - State = 1831; + State = 1839; _localctx.returnType = type(); - State = 1832; + State = 1840; _localctx.name = methodName(); - State = 1834; + State = 1842; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 1833; + State = 1841; _localctx.genericArguments = typeArgs(); } } - State = 1836; + State = 1844; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, null, _localctx.name.Value, _localctx.genericArguments, null, _localctx.arguments.Value); } @@ -8869,15 +8879,15 @@ public MethodRefContext methodRef() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1839; + State = 1847; _localctx.convention = callConv(); - State = 1840; + State = 1848; _localctx.returnType = type(); - State = 1841; + State = 1849; _localctx.name = methodName(); - State = 1842; + State = 1850; _localctx.genericArity = genArityNotEmpty(); - State = 1843; + State = 1851; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, null, _localctx.name.Value, null, _localctx.genericArity.Value, _localctx.arguments.Value); } @@ -8885,7 +8895,7 @@ public MethodRefContext methodRef() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1846; + State = 1854; _localctx.token = mdtoken(); _localctx.Value = Actions.CreateTokenMethodReference(_localctx.token.Value); } @@ -8893,7 +8903,7 @@ public MethodRefContext methodRef() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1849; + State = 1857; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateTypedefMethodReference(_localctx.Start, _localctx.alias.Value); } @@ -8946,15 +8956,15 @@ public CallConvContext callConv() { CallConvContext _localctx = new CallConvContext(Context, State); EnterRule(_localctx, 170, RULE_callConv); try { - State = 1871; + State = 1879; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,77,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1854; + State = 1862; Match(INSTANCE); - State = 1855; + State = 1863; _localctx.inner = callConv(); _localctx.Value = Actions.AddInstanceCallingConvention(_localctx.inner.Value); } @@ -8962,9 +8972,9 @@ public CallConvContext callConv() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1858; + State = 1866; Match(EXPLICIT); - State = 1859; + State = 1867; _localctx.inner = callConv(); _localctx.Value = Actions.AddExplicitCallingConvention(_localctx.inner.Value); } @@ -8972,7 +8982,7 @@ public CallConvContext callConv() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1862; + State = 1870; _localctx.kind = callKind(); _localctx.Value = _localctx.kind.Value; } @@ -8980,13 +8990,13 @@ public CallConvContext callConv() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1865; + State = 1873; Match(T__111); - State = 1866; + State = 1874; Match(T__29); - State = 1867; + State = 1875; _localctx.raw = int32(); - State = 1868; + State = 1876; Match(T__30); _localctx.Value = Actions.GetRawCallingConvention((_localctx.raw!=null?(_localctx.raw.Start):null)); } @@ -9033,7 +9043,7 @@ public CallKindContext callKind() { EnterRule(_localctx, 172, RULE_callKind); _localctx.Value = Actions.GetDefaultCallingConvention(); try { - State = 1892; + State = 1900; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,78,Context) ) { case 1: @@ -9044,7 +9054,7 @@ public CallKindContext callKind() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1874; + State = 1882; _localctx.kind = Match(DEFAULT); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9052,7 +9062,7 @@ public CallKindContext callKind() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1876; + State = 1884; _localctx.kind = Match(VARARG); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9060,9 +9070,9 @@ public CallKindContext callKind() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1878; + State = 1886; Match(UNMANAGED); - State = 1879; + State = 1887; _localctx.kind = Match(CDECL); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9070,9 +9080,9 @@ public CallKindContext callKind() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1881; + State = 1889; Match(UNMANAGED); - State = 1882; + State = 1890; _localctx.kind = Match(STDCALL); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9080,9 +9090,9 @@ public CallKindContext callKind() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1884; + State = 1892; Match(UNMANAGED); - State = 1885; + State = 1893; _localctx.kind = Match(THISCALL); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9090,9 +9100,9 @@ public CallKindContext callKind() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1887; + State = 1895; Match(UNMANAGED); - State = 1888; + State = 1896; _localctx.kind = Match(FASTCALL); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9100,7 +9110,7 @@ public CallKindContext callKind() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1890; + State = 1898; _localctx.kind = Match(UNMANAGED); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9146,13 +9156,13 @@ public MdtokenContext mdtoken() { try { EnterOuterAlt(_localctx, 1); { - State = 1894; + State = 1902; Match(T__112); - State = 1895; + State = 1903; Match(T__29); - State = 1896; + State = 1904; _localctx.token = int32(); - State = 1897; + State = 1905; Match(T__30); _localctx.Value = Actions.ParseInt32((_localctx.token!=null?(_localctx.token.Start):null)); } @@ -9202,15 +9212,15 @@ public MemberRefContext memberRef() { MemberRefContext _localctx = new MemberRefContext(Context, State); EnterRule(_localctx, 176, RULE_memberRef); try { - State = 1911; + State = 1919; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case METHOD: EnterOuterAlt(_localctx, 1); { - State = 1900; + State = 1908; Match(METHOD); - State = 1901; + State = 1909; _localctx.method = methodRef(); _localctx.Value = Actions.CreateMethodMemberReference(_localctx.method.Value); } @@ -9218,9 +9228,9 @@ public MemberRefContext memberRef() { case T__36: EnterOuterAlt(_localctx, 2); { - State = 1904; + State = 1912; Match(T__36); - State = 1905; + State = 1913; _localctx.field = fieldRef(); _localctx.Value = Actions.CreateFieldMemberReference(_localctx.field.Value); } @@ -9228,7 +9238,7 @@ public MemberRefContext memberRef() { case T__112: EnterOuterAlt(_localctx, 3); { - State = 1908; + State = 1916; _localctx.token = mdtoken(); _localctx.Value = Actions.CreateTokenMemberReference(_localctx.token.Value); } @@ -9284,19 +9294,19 @@ public FieldRefContext fieldRef() { EnterRule(_localctx, 178, RULE_fieldRef); Actions.BeginSemanticRoot(_localctx); try { - State = 1926; + State = 1934; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,80,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1913; + State = 1921; _localctx.fieldType = type(); - State = 1914; + State = 1922; _localctx.owner = typeSpec(); - State = 1915; + State = 1923; Match(DCOLON); - State = 1916; + State = 1924; _localctx.name = dottedName(); _localctx.Value = Actions.CreateFieldReference(_localctx.fieldType.Value, _localctx.owner.Value, _localctx.name.Value); } @@ -9304,9 +9314,9 @@ public FieldRefContext fieldRef() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1919; + State = 1927; _localctx.fieldType = type(); - State = 1920; + State = 1928; _localctx.name = dottedName(); _localctx.Value = Actions.CreateFieldReference(_localctx.fieldType.Value, null, _localctx.name.Value); } @@ -9314,7 +9324,7 @@ public FieldRefContext fieldRef() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1923; + State = 1931; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateTypedefFieldReference(_localctx.Start, _localctx.alias.Value); } @@ -9361,25 +9371,25 @@ public TypeListContext typeList() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1933; + State = 1941; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,81,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1928; + State = 1936; typeSpec(); - State = 1929; + State = 1937; Match(T__27); } } } - State = 1935; + State = 1943; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,81,Context); } - State = 1936; + State = 1944; typeSpec(); } } @@ -9416,7 +9426,7 @@ public TyparsClauseContext typarsClause() { TyparsClauseContext _localctx = new TyparsClauseContext(Context, State); EnterRule(_localctx, 182, RULE_typarsClause); try { - State = 1943; + State = 1951; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -9431,11 +9441,11 @@ public TyparsClauseContext typarsClause() { case T__85: EnterOuterAlt(_localctx, 2); { - State = 1939; + State = 1947; Match(T__85); - State = 1940; + State = 1948; typars(); - State = 1941; + State = 1949; Match(T__86); } break; @@ -9485,61 +9495,61 @@ public TyparAttribContext typarAttrib() { TyparAttribContext _localctx = new TyparAttribContext(Context, State); EnterRule(_localctx, 184, RULE_typarAttrib); try { - State = 1956; + State = 1964; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case PLUS: EnterOuterAlt(_localctx, 1); { - State = 1945; + State = 1953; _localctx.covariant = Match(PLUS); } break; case T__113: EnterOuterAlt(_localctx, 2); { - State = 1946; + State = 1954; _localctx.contravariant = Match(T__113); } break; case T__38: EnterOuterAlt(_localctx, 3); { - State = 1947; + State = 1955; _localctx.@class = Match(T__38); } break; case VALUETYPE: EnterOuterAlt(_localctx, 4); { - State = 1948; + State = 1956; _localctx.valuetype = Match(VALUETYPE); } break; case T__114: EnterOuterAlt(_localctx, 5); { - State = 1949; + State = 1957; _localctx.byrefLike = Match(T__114); } break; case T__115: EnterOuterAlt(_localctx, 6); { - State = 1950; + State = 1958; _localctx.ctor = Match(T__115); } break; case T__69: EnterOuterAlt(_localctx, 7); { - State = 1951; + State = 1959; Match(T__69); - State = 1952; + State = 1960; Match(T__29); - State = 1953; + State = 1961; _localctx.flags = int32(); - State = 1954; + State = 1962; Match(T__30); } break; @@ -9586,17 +9596,17 @@ public TyparAttribsContext typarAttribs() { try { EnterOuterAlt(_localctx, 1); { - State = 1961; + State = 1969; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__38 || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & 123145302310913L) != 0) || _la==VALUETYPE || _la==PLUS) { { { - State = 1958; + State = 1966; typarAttrib(); } } - State = 1963; + State = 1971; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -9644,19 +9654,19 @@ public TyparContext typar() { try { EnterOuterAlt(_localctx, 1); { - State = 1964; + State = 1972; typarAttribs(); - State = 1966; + State = 1974; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__29) { { - State = 1965; + State = 1973; tyBound(); } } - State = 1968; + State = 1976; dottedName(); } } @@ -9699,25 +9709,25 @@ public TyparsContext typars() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1975; + State = 1983; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,86,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1970; + State = 1978; typar(); - State = 1971; + State = 1979; Match(T__27); } } } - State = 1977; + State = 1985; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,86,Context); } - State = 1978; + State = 1986; typar(); } } @@ -9756,11 +9766,11 @@ public TyBoundContext tyBound() { try { EnterOuterAlt(_localctx, 1); { - State = 1980; + State = 1988; Match(T__29); - State = 1981; + State = 1989; typeList(); - State = 1982; + State = 1990; Match(T__30); } } @@ -9802,12 +9812,12 @@ public GenArityContext genArity() { try { EnterOuterAlt(_localctx, 1); { - State = 1985; + State = 1993; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 1984; + State = 1992; _localctx.value = genArityNotEmpty(); } } @@ -9852,15 +9862,15 @@ public GenArityNotEmptyContext genArityNotEmpty() { try { EnterOuterAlt(_localctx, 1); { - State = 1989; + State = 1997; Match(T__85); - State = 1990; + State = 1998; Match(T__41); - State = 1991; + State = 1999; _localctx.value = int32(); - State = 1992; + State = 2000; Match(T__42); - State = 1993; + State = 2001; Match(T__86); _localctx.Value = Actions.ParseInt32((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -10008,235 +10018,235 @@ public ClassDeclContext classDecl() { BeginSubtree(); try { int _alt; - State = 2112; + State = 2120; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,92,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1996; + State = 2004; methodHead(); - State = 1997; + State = 2005; Match(T__16); - State = 1998; + State = 2006; methodDecls(); - State = 1999; + State = 2007; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2001; + State = 2009; classHead(); - State = 2002; + State = 2010; Match(T__16); - State = 2003; + State = 2011; classDecls(); - State = 2004; + State = 2012; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2006; + State = 2014; eventHead(); - State = 2007; + State = 2015; Match(T__16); - State = 2008; + State = 2016; eventDecls(); - State = 2009; + State = 2017; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2011; + State = 2019; propHead(); - State = 2012; + State = 2020; Match(T__16); - State = 2013; + State = 2021; propDecls(); - State = 2014; + State = 2022; Match(T__17); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2016; + State = 2024; fieldDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2017; + State = 2025; dataDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2018; + State = 2026; secDecl(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2019; + State = 2027; extSourceSpec(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2020; + State = 2028; customAttrDecl(); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2021; + State = 2029; Match(T__116); - State = 2022; + State = 2030; int32(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2023; + State = 2031; Match(T__117); - State = 2024; + State = 2032; int32(); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2025; + State = 2033; exportHead(); - State = 2026; + State = 2034; Match(T__16); - State = 2027; + State = 2035; exptypeDecls(); - State = 2028; + State = 2036; Match(T__17); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2030; + State = 2038; Match(OVERRIDE); - State = 2031; + State = 2039; typeSpec(); - State = 2032; + State = 2040; Match(DCOLON); - State = 2033; + State = 2041; methodName(); - State = 2034; + State = 2042; Match(T__118); - State = 2035; + State = 2043; callConv(); - State = 2036; + State = 2044; type(); - State = 2037; + State = 2045; typeSpec(); - State = 2038; + State = 2046; Match(DCOLON); - State = 2039; + State = 2047; methodName(); - State = 2040; + State = 2048; sigArgs(); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2042; + State = 2050; Match(OVERRIDE); - State = 2043; + State = 2051; Match(METHOD); - State = 2044; + State = 2052; callConv(); - State = 2045; + State = 2053; type(); - State = 2046; + State = 2054; typeSpec(); - State = 2047; + State = 2055; Match(DCOLON); - State = 2048; + State = 2056; methodName(); - State = 2049; + State = 2057; genArity(); - State = 2050; + State = 2058; sigArgs(); - State = 2051; + State = 2059; Match(T__118); - State = 2052; + State = 2060; Match(METHOD); - State = 2053; + State = 2061; callConv(); - State = 2054; + State = 2062; type(); - State = 2055; + State = 2063; typeSpec(); - State = 2056; + State = 2064; Match(DCOLON); - State = 2057; + State = 2065; methodName(); - State = 2058; + State = 2066; genArity(); - State = 2059; + State = 2067; sigArgs(); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2061; + State = 2069; languageDecl(); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 2062; + State = 2070; compControl(); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 2063; + State = 2071; Match(PARAM); - State = 2064; + State = 2072; Match(TYPE); - State = 2065; + State = 2073; Match(T__41); - State = 2066; + State = 2074; int32(); - State = 2067; + State = 2075; Match(T__42); - State = 2071; + State = 2079; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2068; + State = 2076; customAttrDecl(); } } } - State = 2073; + State = 2081; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); } @@ -10245,25 +10255,25 @@ public ClassDeclContext classDecl() { case 18: EnterOuterAlt(_localctx, 18); { - State = 2074; + State = 2082; Match(PARAM); - State = 2075; + State = 2083; Match(TYPE); - State = 2076; + State = 2084; dottedName(); - State = 2080; + State = 2088; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2077; + State = 2085; customAttrDecl(); } } } - State = 2082; + State = 2090; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); } @@ -10272,33 +10282,33 @@ public ClassDeclContext classDecl() { case 19: EnterOuterAlt(_localctx, 19); { - State = 2083; + State = 2091; Match(PARAM); - State = 2084; + State = 2092; Match(CONSTRAINT); - State = 2085; + State = 2093; Match(T__41); - State = 2086; + State = 2094; int32(); - State = 2087; + State = 2095; Match(T__42); - State = 2088; + State = 2096; Match(T__27); - State = 2089; + State = 2097; typeSpec(); - State = 2093; + State = 2101; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2090; + State = 2098; customAttrDecl(); } } } - State = 2095; + State = 2103; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); } @@ -10307,29 +10317,29 @@ public ClassDeclContext classDecl() { case 20: EnterOuterAlt(_localctx, 20); { - State = 2096; + State = 2104; Match(PARAM); - State = 2097; + State = 2105; Match(CONSTRAINT); - State = 2098; + State = 2106; dottedName(); - State = 2099; + State = 2107; Match(T__27); - State = 2100; + State = 2108; typeSpec(); - State = 2104; + State = 2112; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2101; + State = 2109; customAttrDecl(); } } } - State = 2106; + State = 2114; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); } @@ -10338,13 +10348,13 @@ public ClassDeclContext classDecl() { case 21: EnterOuterAlt(_localctx, 21); { - State = 2107; + State = 2115; Match(T__119); - State = 2108; + State = 2116; Match(TYPE); - State = 2109; + State = 2117; typeSpec(); - State = 2110; + State = 2118; customDescr(); } break; @@ -10413,17 +10423,17 @@ public FieldDeclContext fieldDecl() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 2114; + State = 2122; Match(T__120); - State = 2115; + State = 2123; repeatOpt(); - State = 2124; + State = 2132; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,94,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { - State = 2122; + State = 2130; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -10442,19 +10452,19 @@ public FieldDeclContext fieldDecl() { case T__125: case T__126: { - State = 2116; + State = 2124; fieldAttr(); } break; case T__121: { - State = 2117; + State = 2125; Match(T__121); - State = 2118; + State = 2126; Match(T__29); - State = 2119; + State = 2127; marshalBlob(); - State = 2120; + State = 2128; Match(T__30); } break; @@ -10463,17 +10473,17 @@ public FieldDeclContext fieldDecl() { } } } - State = 2126; + State = 2134; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,94,Context); } - State = 2127; + State = 2135; type(); - State = 2128; + State = 2136; dottedName(); - State = 2129; + State = 2137; atOpt(); - State = 2130; + State = 2138; initOpt(); } } @@ -10510,117 +10520,117 @@ public FieldAttrContext fieldAttr() { FieldAttrContext _localctx = new FieldAttrContext(Context, State); EnterRule(_localctx, 202, RULE_fieldAttr); try { - State = 2151; + State = 2159; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__122: EnterOuterAlt(_localctx, 1); { - State = 2132; + State = 2140; Match(T__122); } break; case T__50: EnterOuterAlt(_localctx, 2); { - State = 2133; + State = 2141; Match(T__50); } break; case T__51: EnterOuterAlt(_localctx, 3); { - State = 2134; + State = 2142; Match(T__51); } break; case T__62: EnterOuterAlt(_localctx, 4); { - State = 2135; + State = 2143; Match(T__62); } break; case T__123: EnterOuterAlt(_localctx, 5); { - State = 2136; + State = 2144; Match(T__123); } break; case T__68: EnterOuterAlt(_localctx, 6); { - State = 2137; + State = 2145; Match(T__68); } break; case T__67: EnterOuterAlt(_localctx, 7); { - State = 2138; + State = 2146; Match(T__67); } break; case T__63: EnterOuterAlt(_localctx, 8); { - State = 2139; + State = 2147; Match(T__63); } break; case T__64: EnterOuterAlt(_localctx, 9); { - State = 2140; + State = 2148; Match(T__64); } break; case T__65: EnterOuterAlt(_localctx, 10); { - State = 2141; + State = 2149; Match(T__65); } break; case T__124: EnterOuterAlt(_localctx, 11); { - State = 2142; + State = 2150; Match(T__124); } break; case T__125: EnterOuterAlt(_localctx, 12); { - State = 2143; + State = 2151; Match(T__125); } break; case T__126: EnterOuterAlt(_localctx, 13); { - State = 2144; + State = 2152; Match(T__126); } break; case T__15: EnterOuterAlt(_localctx, 14); { - State = 2145; + State = 2153; Match(T__15); } break; case T__69: EnterOuterAlt(_localctx, 15); { - State = 2146; + State = 2154; Match(T__69); - State = 2147; + State = 2155; Match(T__29); - State = 2148; + State = 2156; int32(); - State = 2149; + State = 2157; Match(T__30); } break; @@ -10664,7 +10674,7 @@ public AtOptContext atOpt() { AtOptContext _localctx = new AtOptContext(Context, State); EnterRule(_localctx, 204, RULE_atOpt); try { - State = 2158; + State = 2166; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,96,Context) ) { case 1: @@ -10675,18 +10685,18 @@ public AtOptContext atOpt() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2154; + State = 2162; Match(T__43); - State = 2155; + State = 2163; id(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2156; + State = 2164; Match(T__43); - State = 2157; + State = 2165; int32(); } break; @@ -10704,6 +10714,7 @@ public AtOptContext atOpt() { } public partial class InitOptContext : ParserRuleContext { + public bool HasSyntaxError; [System.Diagnostics.DebuggerNonUserCode] public FieldInitContext fieldInit() { return GetRuleContext(0); } @@ -10724,8 +10735,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { public InitOptContext initOpt() { InitOptContext _localctx = new InitOptContext(Context, State); EnterRule(_localctx, 206, RULE_initOpt); + BeginSubtree(); Actions.BeginSemanticRoot(_localctx); try { - State = 2163; + State = 2171; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -10819,9 +10831,9 @@ public InitOptContext initOpt() { case T__35: EnterOuterAlt(_localctx, 2); { - State = 2161; + State = 2169; Match(T__35); - State = 2162; + State = 2170; fieldInit(); } break; @@ -10835,6 +10847,7 @@ public InitOptContext initOpt() { ErrorHandler.Recover(this, re); } finally { + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; @@ -10862,7 +10875,7 @@ public RepeatOptContext repeatOpt() { RepeatOptContext _localctx = new RepeatOptContext(Context, State); EnterRule(_localctx, 208, RULE_repeatOpt); try { - State = 2170; + State = 2178; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -10917,11 +10930,11 @@ public RepeatOptContext repeatOpt() { case T__41: EnterOuterAlt(_localctx, 2); { - State = 2166; + State = 2174; Match(T__41); - State = 2167; + State = 2175; int32(); - State = 2168; + State = 2176; Match(T__42); } break; @@ -10972,54 +10985,54 @@ public EventHeadContext eventHead() { EnterRule(_localctx, 210, RULE_eventHead); int _la; try { - State = 2190; + State = 2198; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,101,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2172; + State = 2180; Match(T__127); - State = 2176; + State = 2184; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 2173; + State = 2181; eventAttr(); } } - State = 2178; + State = 2186; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2179; + State = 2187; typeSpec(); - State = 2180; + State = 2188; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2182; + State = 2190; Match(T__127); - State = 2186; + State = 2194; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 2183; + State = 2191; eventAttr(); } } - State = 2188; + State = 2196; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2189; + State = 2197; dottedName(); } break; @@ -11058,7 +11071,7 @@ public EventAttrContext eventAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 2192; + State = 2200; _la = TokenStream.LA(1); if ( !(_la==T__67 || _la==T__68) ) { ErrorHandler.RecoverInline(this); @@ -11108,17 +11121,17 @@ public EventDeclsContext eventDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2197; + State = 2205; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38788988928L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 1080863910568919043L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 2194; + State = 2202; eventDecl(); } } - State = 2199; + State = 2207; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11169,42 +11182,42 @@ public EventDeclContext eventDecl() { EventDeclContext _localctx = new EventDeclContext(Context, State); EnterRule(_localctx, 216, RULE_eventDecl); try { - State = 2212; + State = 2220; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__128: EnterOuterAlt(_localctx, 1); { - State = 2200; + State = 2208; Match(T__128); - State = 2201; + State = 2209; methodRef(); } break; case T__129: EnterOuterAlt(_localctx, 2); { - State = 2202; + State = 2210; Match(T__129); - State = 2203; + State = 2211; methodRef(); } break; case T__130: EnterOuterAlt(_localctx, 3); { - State = 2204; + State = 2212; Match(T__130); - State = 2205; + State = 2213; methodRef(); } break; case T__131: EnterOuterAlt(_localctx, 4); { - State = 2206; + State = 2214; Match(T__131); - State = 2207; + State = 2215; methodRef(); } break; @@ -11212,7 +11225,7 @@ public EventDeclContext eventDecl() { case T__73: EnterOuterAlt(_localctx, 5); { - State = 2208; + State = 2216; extSourceSpec(); } break; @@ -11225,14 +11238,14 @@ public EventDeclContext eventDecl() { case ID: EnterOuterAlt(_localctx, 6); { - State = 2209; + State = 2217; customAttrDecl(); } break; case T__26: EnterOuterAlt(_localctx, 7); { - State = 2210; + State = 2218; languageDecl(); } break; @@ -11246,7 +11259,7 @@ public EventDeclContext eventDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 8); { - State = 2211; + State = 2219; compControl(); } break; @@ -11308,31 +11321,31 @@ public PropHeadContext propHead() { try { EnterOuterAlt(_localctx, 1); { - State = 2214; + State = 2222; Match(T__132); - State = 2218; + State = 2226; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 2215; + State = 2223; propAttr(); } } - State = 2220; + State = 2228; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2221; + State = 2229; callConv(); - State = 2222; + State = 2230; type(); - State = 2223; + State = 2231; dottedName(); - State = 2224; + State = 2232; sigArgs(); - State = 2225; + State = 2233; initOpt(); } } @@ -11369,7 +11382,7 @@ public PropAttrContext propAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 2227; + State = 2235; _la = TokenStream.LA(1); if ( !(_la==T__67 || _la==T__68) ) { ErrorHandler.RecoverInline(this); @@ -11419,17 +11432,17 @@ public PropDeclsContext propDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2232; + State = 2240; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38788988928L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 7493989779944505347L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 2229; + State = 2237; propDecl(); } } - State = 2234; + State = 2242; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11480,33 +11493,33 @@ public PropDeclContext propDecl() { PropDeclContext _localctx = new PropDeclContext(Context, State); EnterRule(_localctx, 224, RULE_propDecl); try { - State = 2245; + State = 2253; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__133: EnterOuterAlt(_localctx, 1); { - State = 2235; + State = 2243; Match(T__133); - State = 2236; + State = 2244; methodRef(); } break; case T__134: EnterOuterAlt(_localctx, 2); { - State = 2237; + State = 2245; Match(T__134); - State = 2238; + State = 2246; methodRef(); } break; case T__131: EnterOuterAlt(_localctx, 3); { - State = 2239; + State = 2247; Match(T__131); - State = 2240; + State = 2248; methodRef(); } break; @@ -11519,7 +11532,7 @@ public PropDeclContext propDecl() { case ID: EnterOuterAlt(_localctx, 4); { - State = 2241; + State = 2249; customAttrDecl(); } break; @@ -11527,14 +11540,14 @@ public PropDeclContext propDecl() { case T__73: EnterOuterAlt(_localctx, 5); { - State = 2242; + State = 2250; extSourceSpec(); } break; case T__26: EnterOuterAlt(_localctx, 6); { - State = 2243; + State = 2251; languageDecl(); } break; @@ -11548,7 +11561,7 @@ public PropDeclContext propDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 7); { - State = 2244; + State = 2252; compControl(); } break; @@ -11591,7 +11604,7 @@ public MarshalClauseContext marshalClause() { MarshalClauseContext _localctx = new MarshalClauseContext(Context, State); EnterRule(_localctx, 226, RULE_marshalClause); try { - State = 2254; + State = 2262; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -11628,13 +11641,13 @@ public MarshalClauseContext marshalClause() { case T__121: EnterOuterAlt(_localctx, 2); { - State = 2248; + State = 2256; Match(T__121); - State = 2249; + State = 2257; Match(T__29); - State = 2250; + State = 2258; _localctx.value = marshalBlob(); - State = 2251; + State = 2259; Match(T__30); _localctx.Value = Actions.CompleteMarshalClause(_localctx.value.Value); } @@ -11687,7 +11700,7 @@ public MarshalBlobContext marshalBlob() { Actions.BeginMarshalBlob(_localctx); int _la; try { - State = 2269; + State = 2277; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -11742,7 +11755,7 @@ public MarshalBlobContext marshalBlob() { case ID: EnterOuterAlt(_localctx, 1); { - State = 2256; + State = 2264; _localctx.nativeValue = nativeType(); Actions.SetMarshalBlobNativeType(_localctx, _localctx.nativeValue.Value); } @@ -11750,24 +11763,24 @@ public MarshalBlobContext marshalBlob() { case T__16: EnterOuterAlt(_localctx, 2); { - State = 2259; + State = 2267; Match(T__16); - State = 2263; + State = 2271; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2260; + State = 2268; _localctx.rawByte = hexbyte(); Actions.AddMarshalBlobByte(_localctx, _localctx.rawByte.Value); } } - State = 2265; + State = 2273; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( _la==INT32 || _la==ID || _la==HEXBYTE ); - State = 2267; + State = 2275; Match(T__17); } break; @@ -11818,18 +11831,18 @@ public ParamAttrContext paramAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 2276; + State = 2284; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__41) { { { - State = 2271; + State = 2279; _localctx.element = paramAttrElement(); Actions.AddParameterAttribute(_localctx, _localctx.element); } } - State = 2278; + State = 2286; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11873,17 +11886,17 @@ public ParamAttrElementContext paramAttrElement() { ParamAttrElementContext _localctx = new ParamAttrElementContext(Context, State); EnterRule(_localctx, 232, RULE_paramAttrElement); try { - State = 2296; + State = 2304; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,111,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2279; + State = 2287; Match(T__41); - State = 2280; + State = 2288; _localctx.attribute = Match(T__135); - State = 2281; + State = 2289; Match(T__42); Actions.SetParameterAttributeElement(_localctx, _localctx.attribute); } @@ -11891,11 +11904,11 @@ public ParamAttrElementContext paramAttrElement() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2283; + State = 2291; Match(T__41); - State = 2284; + State = 2292; _localctx.attribute = Match(T__136); - State = 2285; + State = 2293; Match(T__42); Actions.SetParameterAttributeElement(_localctx, _localctx.attribute); } @@ -11903,11 +11916,11 @@ public ParamAttrElementContext paramAttrElement() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2287; + State = 2295; Match(T__41); - State = 2288; + State = 2296; _localctx.attribute = Match(T__137); - State = 2289; + State = 2297; Match(T__42); Actions.SetParameterAttributeElement(_localctx, _localctx.attribute); } @@ -11915,11 +11928,11 @@ public ParamAttrElementContext paramAttrElement() { case 4: EnterOuterAlt(_localctx, 4); { - State = 2291; + State = 2299; Match(T__41); - State = 2292; + State = 2300; _localctx.raw = int32(); - State = 2293; + State = 2301; Match(T__42); Actions.SetRawParameterAttributeElement(_localctx, (_localctx.raw!=null?(_localctx.raw.Start):null)); } @@ -11999,14 +12012,14 @@ public MethodHeadContext methodHead() { try { EnterOuterAlt(_localctx, 1); { - State = 2298; + State = 2306; Match(T__138); - State = 2303; + State = 2311; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & 978955L) != 0) || ((((_la - 123)) & ~0x3f) == 0 && ((1L << (_la - 123)) & 33423365L) != 0)) { { - State = 2301; + State = 2309; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__50: @@ -12029,13 +12042,13 @@ public MethodHeadContext methodHead() { case T__144: case T__145: { - State = 2299; + State = 2307; methAttr(); } break; case T__146: { - State = 2300; + State = 2308; pinvImpl(); } break; @@ -12043,35 +12056,35 @@ public MethodHeadContext methodHead() { throw new NoViableAltException(this); } } - State = 2305; + State = 2313; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2306; + State = 2314; callConv(); - State = 2307; + State = 2315; paramAttr(); - State = 2308; + State = 2316; type(); - State = 2309; + State = 2317; marshalClause(); - State = 2310; + State = 2318; methodName(); - State = 2311; + State = 2319; typarsClause(); - State = 2312; + State = 2320; sigArgs(); - State = 2316; + State = 2324; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 32766L) != 0) || _la==T__69 || _la==T__155 || _la==UNMANAGED) { { { - State = 2313; + State = 2321; implAttr(); } } - State = 2318; + State = 2326; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -12113,145 +12126,145 @@ public MethAttrContext methAttr() { MethAttrContext _localctx = new MethAttrContext(Context, State); EnterRule(_localctx, 236, RULE_methAttr); try { - State = 2342; + State = 2350; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__122: EnterOuterAlt(_localctx, 1); { - State = 2319; + State = 2327; Match(T__122); } break; case T__50: EnterOuterAlt(_localctx, 2); { - State = 2320; + State = 2328; Match(T__50); } break; case T__51: EnterOuterAlt(_localctx, 3); { - State = 2321; + State = 2329; Match(T__51); } break; case T__62: EnterOuterAlt(_localctx, 4); { - State = 2322; + State = 2330; Match(T__62); } break; case T__139: EnterOuterAlt(_localctx, 5); { - State = 2323; + State = 2331; Match(T__139); } break; case T__67: EnterOuterAlt(_localctx, 6); { - State = 2324; + State = 2332; Match(T__67); } break; case T__140: EnterOuterAlt(_localctx, 7); { - State = 2325; + State = 2333; Match(T__140); } break; case T__141: EnterOuterAlt(_localctx, 8); { - State = 2326; + State = 2334; Match(T__141); } break; case T__53: EnterOuterAlt(_localctx, 9); { - State = 2327; + State = 2335; Match(T__53); } break; case T__63: EnterOuterAlt(_localctx, 10); { - State = 2328; + State = 2336; Match(T__63); } break; case T__64: EnterOuterAlt(_localctx, 11); { - State = 2329; + State = 2337; Match(T__64); } break; case T__65: EnterOuterAlt(_localctx, 12); { - State = 2330; + State = 2338; Match(T__65); } break; case T__124: EnterOuterAlt(_localctx, 13); { - State = 2331; + State = 2339; Match(T__124); } break; case T__142: EnterOuterAlt(_localctx, 14); { - State = 2332; + State = 2340; Match(T__142); } break; case T__143: EnterOuterAlt(_localctx, 15); { - State = 2333; + State = 2341; Match(T__143); } break; case T__68: EnterOuterAlt(_localctx, 16); { - State = 2334; + State = 2342; Match(T__68); } break; case T__144: EnterOuterAlt(_localctx, 17); { - State = 2335; + State = 2343; Match(T__144); } break; case T__145: EnterOuterAlt(_localctx, 18); { - State = 2336; + State = 2344; Match(T__145); } break; case T__69: EnterOuterAlt(_localctx, 19); { - State = 2337; + State = 2345; Match(T__69); - State = 2338; + State = 2346; Match(T__29); - State = 2339; + State = 2347; int32(); - State = 2340; + State = 2348; Match(T__30); } break; @@ -12302,31 +12315,31 @@ public PinvImplContext pinvImpl() { EnterRule(_localctx, 238, RULE_pinvImpl); int _la; try { - State = 2362; + State = 2370; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,119,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2344; + State = 2352; Match(T__146); - State = 2345; + State = 2353; Match(T__29); - State = 2351; + State = 2359; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==QSTRING) { { - State = 2346; + State = 2354; compQstring(); - State = 2349; + State = 2357; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__33) { { - State = 2347; + State = 2355; Match(T__33); - State = 2348; + State = 2356; compQstring(); } } @@ -12334,30 +12347,30 @@ public PinvImplContext pinvImpl() { } } - State = 2356; + State = 2364; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 57)) & ~0x3f) == 0 && ((1L << (_la - 57)) & 8195L) != 0) || ((((_la - 148)) & ~0x3f) == 0 && ((1L << (_la - 148)) & 79L) != 0) || ((((_la - 224)) & ~0x3f) == 0 && ((1L << (_la - 224)) & 251658241L) != 0)) { { { - State = 2353; + State = 2361; pinvAttr(); } } - State = 2358; + State = 2366; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2359; + State = 2367; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2360; + State = 2368; Match(T__146); - State = 2361; + State = 2369; Match(T__84); } break; @@ -12401,133 +12414,133 @@ public PinvAttrContext pinvAttr() { PinvAttrContext _localctx = new PinvAttrContext(Context, State); EnterRule(_localctx, 240, RULE_pinvAttr); try { - State = 2391; + State = 2399; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,120,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2364; + State = 2372; Match(T__147); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2365; + State = 2373; Match(ANSI); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2366; + State = 2374; Match(T__56); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2367; + State = 2375; Match(T__57); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2368; + State = 2376; Match(T__148); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2369; + State = 2377; Match(T__149); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2370; + State = 2378; Match(CDECL); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2371; + State = 2379; Match(STDCALL); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2372; + State = 2380; Match(THISCALL); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2373; + State = 2381; Match(FASTCALL); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2374; + State = 2382; Match(T__150); - State = 2375; + State = 2383; Match(T__74); - State = 2376; + State = 2384; Match(T__151); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2377; + State = 2385; Match(T__150); - State = 2378; + State = 2386; Match(T__74); - State = 2379; + State = 2387; Match(T__152); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2380; + State = 2388; Match(T__153); - State = 2381; + State = 2389; Match(T__74); - State = 2382; + State = 2390; Match(T__151); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2383; + State = 2391; Match(T__153); - State = 2384; + State = 2392; Match(T__74); - State = 2385; + State = 2393; Match(T__152); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2386; + State = 2394; Match(T__69); - State = 2387; + State = 2395; Match(T__29); - State = 2388; + State = 2396; int32(); - State = 2389; + State = 2397; Match(T__30); } break; @@ -12570,13 +12583,13 @@ public MethodNameContext methodName() { MethodNameContext _localctx = new MethodNameContext(Context, State); EnterRule(_localctx, 242, RULE_methodName); try { - State = 2400; + State = 2408; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__115: EnterOuterAlt(_localctx, 1); { - State = 2393; + State = 2401; _localctx.ctorName = Match(T__115); _localctx.Value = Actions.GetMethodName(_localctx.ctorName); } @@ -12584,7 +12597,7 @@ public MethodNameContext methodName() { case T__154: EnterOuterAlt(_localctx, 2); { - State = 2395; + State = 2403; _localctx.cctorName = Match(T__154); _localctx.Value = Actions.GetMethodName(_localctx.cctorName); } @@ -12597,7 +12610,7 @@ public MethodNameContext methodName() { case ID: EnterOuterAlt(_localctx, 3); { - State = 2397; + State = 2405; _localctx.dotted = dottedName(); _localctx.Value = _localctx.dotted.Value; } @@ -12640,131 +12653,131 @@ public ImplAttrContext implAttr() { ImplAttrContext _localctx = new ImplAttrContext(Context, State); EnterRule(_localctx, 244, RULE_implAttr); try { - State = 2423; + State = 2431; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: EnterOuterAlt(_localctx, 1); { - State = 2402; + State = 2410; Match(T__0); } break; case T__1: EnterOuterAlt(_localctx, 2); { - State = 2403; + State = 2411; Match(T__1); } break; case T__155: EnterOuterAlt(_localctx, 3); { - State = 2404; + State = 2412; Match(T__155); } break; case T__2: EnterOuterAlt(_localctx, 4); { - State = 2405; + State = 2413; Match(T__2); } break; case T__3: EnterOuterAlt(_localctx, 5); { - State = 2406; + State = 2414; Match(T__3); } break; case UNMANAGED: EnterOuterAlt(_localctx, 6); { - State = 2407; + State = 2415; Match(UNMANAGED); } break; case T__4: EnterOuterAlt(_localctx, 7); { - State = 2408; + State = 2416; Match(T__4); } break; case T__5: EnterOuterAlt(_localctx, 8); { - State = 2409; + State = 2417; Match(T__5); } break; case T__6: EnterOuterAlt(_localctx, 9); { - State = 2410; + State = 2418; Match(T__6); } break; case T__7: EnterOuterAlt(_localctx, 10); { - State = 2411; + State = 2419; Match(T__7); } break; case T__8: EnterOuterAlt(_localctx, 11); { - State = 2412; + State = 2420; Match(T__8); } break; case T__9: EnterOuterAlt(_localctx, 12); { - State = 2413; + State = 2421; Match(T__9); } break; case T__10: EnterOuterAlt(_localctx, 13); { - State = 2414; + State = 2422; Match(T__10); } break; case T__11: EnterOuterAlt(_localctx, 14); { - State = 2415; + State = 2423; Match(T__11); } break; case T__12: EnterOuterAlt(_localctx, 15); { - State = 2416; + State = 2424; Match(T__12); } break; case T__13: EnterOuterAlt(_localctx, 16); { - State = 2417; + State = 2425; Match(T__13); } break; case T__69: EnterOuterAlt(_localctx, 17); { - State = 2418; + State = 2426; Match(T__69); - State = 2419; + State = 2427; Match(T__29); - State = 2420; + State = 2428; int32(); - State = 2421; + State = 2429; Match(T__30); } break; @@ -12812,17 +12825,17 @@ public MethodDeclsContext methodDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2428; + State = 2436; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38789119998L) != 0) || _la==T__72 || _la==T__73 || ((((_la - 158)) & ~0x3f) == 0 && ((1L << (_la - 158)) & 2199023255681L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 2303696760354115601L) != 0)) { { { - State = 2425; + State = 2433; methodDecl(); } } - State = 2430; + State = 2438; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -12842,6 +12855,11 @@ public MethodDeclsContext methodDecls() { public partial class MethodDeclContext : ParserRuleContext { public Int32Context value; + public DataDeclContext declaration; + public SecDeclContext security; + public ExtSourceSpecContext source; + public LanguageDeclContext language; + public CustomDescrInMethodBodyContext attribute; [System.Diagnostics.DebuggerNonUserCode] public InstrContext instr() { return GetRuleContext(0); } @@ -12861,8 +12879,38 @@ [System.Diagnostics.DebuggerNonUserCode] public LabelDeclContext labelDecl() { [System.Diagnostics.DebuggerNonUserCode] public ScopeBlockContext scopeBlock() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public MethodDeclIslandContext methodDeclIsland() { - return GetRuleContext(0); + [System.Diagnostics.DebuggerNonUserCode] public LocalsDeclContext localsDecl() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public DataDeclContext dataDecl() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public SecDeclContext secDecl() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public ExtSourceSpecContext extSourceSpec() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public LanguageDeclContext languageDecl() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public CustomDescrInMethodBodyContext customDescrInMethodBody() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public CompControlContext compControl() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public ExportDeclContext exportDecl() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public VtentryDeclContext vtentryDecl() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public OverrideDeclContext overrideDecl() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public ParameterDeclContext parameterDecl() { + return GetRuleContext(0); } public MethodDeclContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) @@ -12882,7 +12930,7 @@ public MethodDeclContext methodDecl() { MethodDeclContext _localctx = new MethodDeclContext(Context, State); EnterRule(_localctx, 248, RULE_methodDecl); try { - State = 2448; + State = 2476; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case INSTR_NONE: @@ -12900,16 +12948,16 @@ public MethodDeclContext methodDecl() { case INSTR_TOK: EnterOuterAlt(_localctx, 1); { - State = 2431; + State = 2439; instr(); } break; case EMITBYTE: EnterOuterAlt(_localctx, 2); { - State = 2432; + State = 2440; Match(EMITBYTE); - State = 2433; + State = 2441; _localctx.value = int32(); Actions.EmitByte((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -12917,16 +12965,16 @@ public MethodDeclContext methodDecl() { case T__157: EnterOuterAlt(_localctx, 3); { - State = 2436; + State = 2444; sehBlock(); } break; case MAXSTACK: EnterOuterAlt(_localctx, 4); { - State = 2437; + State = 2445; Match(MAXSTACK); - State = 2438; + State = 2446; _localctx.value = int32(); Actions.SetMaxStack((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -12934,7 +12982,7 @@ public MethodDeclContext methodDecl() { case ENTRYPOINT: EnterOuterAlt(_localctx, 5); { - State = 2441; + State = 2449; Match(ENTRYPOINT); Actions.SetEntryPoint(); } @@ -12942,7 +12990,7 @@ public MethodDeclContext methodDecl() { case ZEROINIT: EnterOuterAlt(_localctx, 6); { - State = 2443; + State = 2451; Match(ZEROINIT); Actions.SetZeroInit(); } @@ -12969,45 +13017,110 @@ public MethodDeclContext methodDecl() { case ID: EnterOuterAlt(_localctx, 7); { - State = 2445; + State = 2453; labelDecl(); } break; case T__16: EnterOuterAlt(_localctx, 8); { - State = 2446; + State = 2454; scopeBlock(); } break; - case T__26: - case T__31: - case T__34: - case T__72: - case T__73: + case LOCALS: + EnterOuterAlt(_localctx, 9); + { + State = 2455; + localsDecl(); + } + break; case T__164: - case PARAM: - case PP_DEFINE: - case PP_UNDEF: - case PP_IFDEF: - case PP_IFNDEF: - case PP_ELSE: - case PP_ENDIF: - case PP_INCLUDE: + EnterOuterAlt(_localctx, 10); + { + State = 2456; + _localctx.declaration = dataDecl(); + Actions.ProcessMethodDataDeclaration(_localctx.declaration); + } + break; case PERMISSION: case PERMISSIONSET: - case LOCALS: - case EXPORT: - case OVERRIDE: - case VTENTRY: - EnterOuterAlt(_localctx, 9); + EnterOuterAlt(_localctx, 11); { - State = 2447; - methodDeclIsland(); + State = 2459; + _localctx.security = secDecl(); + Actions.ProcessMethodSecurityDeclaration(_localctx.security); } break; - default: - throw new NoViableAltException(this); + case T__72: + case T__73: + EnterOuterAlt(_localctx, 12); + { + State = 2462; + _localctx.source = extSourceSpec(); + Actions.ProcessMethodSourceDirective(_localctx.source); + } + break; + case T__26: + EnterOuterAlt(_localctx, 13); + { + State = 2465; + _localctx.language = languageDecl(); + Actions.ProcessMethodLanguageDirective(_localctx.language); + } + break; + case T__34: + EnterOuterAlt(_localctx, 14); + { + State = 2468; + _localctx.attribute = customDescrInMethodBody(); + Actions.ProcessMethodCustomAttribute(_localctx.attribute); + } + break; + case T__31: + case PP_DEFINE: + case PP_UNDEF: + case PP_IFDEF: + case PP_IFNDEF: + case PP_ELSE: + case PP_ENDIF: + case PP_INCLUDE: + EnterOuterAlt(_localctx, 15); + { + State = 2471; + compControl(); + } + break; + case EXPORT: + EnterOuterAlt(_localctx, 16); + { + State = 2472; + exportDecl(); + } + break; + case VTENTRY: + EnterOuterAlt(_localctx, 17); + { + State = 2473; + vtentryDecl(); + } + break; + case OVERRIDE: + EnterOuterAlt(_localctx, 18); + { + State = 2474; + overrideDecl(); + } + break; + case PARAM: + EnterOuterAlt(_localctx, 19); + { + State = 2475; + parameterDecl(); + } + break; + default: + throw new NoViableAltException(this); } } catch (RecognitionException re) { @@ -13021,45 +13134,194 @@ public MethodDeclContext methodDecl() { return _localctx; } - public partial class MethodDeclIslandContext : ParserRuleContext { + public partial class LocalsDeclContext : ParserRuleContext { + public IToken initialize; + public SigArgsContext arguments; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LOCALS() { return GetToken(CILParser.LOCALS, 0); } [System.Diagnostics.DebuggerNonUserCode] public SigArgsContext sigArgs() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public DataDeclContext dataDecl() { - return GetRuleContext(0); - } - [System.Diagnostics.DebuggerNonUserCode] public SecDeclContext secDecl() { - return GetRuleContext(0); + public LocalsDeclContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { } - [System.Diagnostics.DebuggerNonUserCode] public ExtSourceSpecContext extSourceSpec() { - return GetRuleContext(0); + public override int RuleIndex { get { return RULE_localsDecl; } } + [System.Diagnostics.DebuggerNonUserCode] + public override TResult Accept(IParseTreeVisitor visitor) { + ICILVisitor typedVisitor = visitor as ICILVisitor; + if (typedVisitor != null) return typedVisitor.VisitLocalsDecl(this); + else return visitor.VisitChildren(this); } - [System.Diagnostics.DebuggerNonUserCode] public LanguageDeclContext languageDecl() { - return GetRuleContext(0); + } + + [RuleVersion(0)] + public LocalsDeclContext localsDecl() { + LocalsDeclContext _localctx = new LocalsDeclContext(Context, State); + EnterRule(_localctx, 250, RULE_localsDecl); + Actions.BeginSemanticRoot(_localctx); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 2478; + Match(LOCALS); + State = 2480; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==T__156) { + { + State = 2479; + _localctx.initialize = Match(T__156); + } + } + + State = 2482; + _localctx.arguments = sigArgs(); + } } - [System.Diagnostics.DebuggerNonUserCode] public CustomDescrInMethodBodyContext customDescrInMethodBody() { - return GetRuleContext(0); + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); } - [System.Diagnostics.DebuggerNonUserCode] public CompControlContext compControl() { - return GetRuleContext(0); + finally { + Actions.EndLocalsDirective(_localctx); + ExitRule(); } + return _localctx; + } + + public partial class ExportDeclContext : ParserRuleContext { + public Int32Context ordinal; + public IdContext alias; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode EXPORT() { return GetToken(CILParser.EXPORT, 0); } + [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public IdContext id() { + return GetRuleContext(0); + } + public ExportDeclContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_exportDecl; } } + [System.Diagnostics.DebuggerNonUserCode] + public override TResult Accept(IParseTreeVisitor visitor) { + ICILVisitor typedVisitor = visitor as ICILVisitor; + if (typedVisitor != null) return typedVisitor.VisitExportDecl(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ExportDeclContext exportDecl() { + ExportDeclContext _localctx = new ExportDeclContext(Context, State); + EnterRule(_localctx, 252, RULE_exportDecl); + Actions.BeginSemanticRoot(_localctx); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 2484; + Match(EXPORT); + State = 2485; + Match(T__41); + State = 2486; + _localctx.ordinal = int32(); + State = 2487; + Match(T__42); + State = 2490; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==T__33) { + { + State = 2488; + Match(T__33); + State = 2489; + _localctx.alias = id(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + Actions.EndExportDirective(_localctx); + ExitRule(); + } + return _localctx; + } + + public partial class VtentryDeclContext : ParserRuleContext { + public Int32Context table; + public Int32Context slot; + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VTENTRY() { return GetToken(CILParser.VTENTRY, 0); } [System.Diagnostics.DebuggerNonUserCode] public Int32Context[] int32() { return GetRuleContexts(); } [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32(int i) { return GetRuleContext(i); } - [System.Diagnostics.DebuggerNonUserCode] public IdContext id() { - return GetRuleContext(0); + public VtentryDeclContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VTENTRY() { return GetToken(CILParser.VTENTRY, 0); } + public override int RuleIndex { get { return RULE_vtentryDecl; } } + [System.Diagnostics.DebuggerNonUserCode] + public override TResult Accept(IParseTreeVisitor visitor) { + ICILVisitor typedVisitor = visitor as ICILVisitor; + if (typedVisitor != null) return typedVisitor.VisitVtentryDecl(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public VtentryDeclContext vtentryDecl() { + VtentryDeclContext _localctx = new VtentryDeclContext(Context, State); + EnterRule(_localctx, 254, RULE_vtentryDecl); + Actions.BeginSemanticRoot(_localctx); + try { + EnterOuterAlt(_localctx, 1); + { + State = 2492; + Match(VTENTRY); + State = 2493; + _localctx.table = int32(); + State = 2494; + Match(T__74); + State = 2495; + _localctx.slot = int32(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + Actions.EndVTableEntryDirective(_localctx); + ExitRule(); + } + return _localctx; + } + + public partial class OverrideDeclContext : ParserRuleContext { + public TypeSpecContext owner; + public MethodNameContext name; + public CallConvContext convention; + public TypeContext returnType; + public GenArityContext arity; + public SigArgsContext arguments; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode OVERRIDE() { return GetToken(CILParser.OVERRIDE, 0); } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DCOLON() { return GetToken(CILParser.DCOLON, 0); } [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DCOLON() { return GetToken(CILParser.DCOLON, 0); } [System.Diagnostics.DebuggerNonUserCode] public MethodNameContext methodName() { return GetRuleContext(0); } @@ -13073,343 +13335,295 @@ [System.Diagnostics.DebuggerNonUserCode] public TypeContext type() { [System.Diagnostics.DebuggerNonUserCode] public GenArityContext genArity() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PARAM() { return GetToken(CILParser.PARAM, 0); } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TYPE() { return GetToken(CILParser.TYPE, 0); } - [System.Diagnostics.DebuggerNonUserCode] public CustomAttrDeclContext[] customAttrDecl() { - return GetRuleContexts(); - } - [System.Diagnostics.DebuggerNonUserCode] public CustomAttrDeclContext customAttrDecl(int i) { - return GetRuleContext(i); - } - [System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() { - return GetRuleContext(0); - } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CONSTRAINT() { return GetToken(CILParser.CONSTRAINT, 0); } - [System.Diagnostics.DebuggerNonUserCode] public InitOptContext initOpt() { - return GetRuleContext(0); + [System.Diagnostics.DebuggerNonUserCode] public SigArgsContext sigArgs() { + return GetRuleContext(0); } - public MethodDeclIslandContext(ParserRuleContext parent, int invokingState) + public OverrideDeclContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { } - public override int RuleIndex { get { return RULE_methodDeclIsland; } } + public override int RuleIndex { get { return RULE_overrideDecl; } } [System.Diagnostics.DebuggerNonUserCode] public override TResult Accept(IParseTreeVisitor visitor) { ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitMethodDeclIsland(this); + if (typedVisitor != null) return typedVisitor.VisitOverrideDecl(this); else return visitor.VisitChildren(this); } - } - - [RuleVersion(0)] - public MethodDeclIslandContext methodDeclIsland() { - MethodDeclIslandContext _localctx = new MethodDeclIslandContext(Context, State); - EnterRule(_localctx, 250, RULE_methodDeclIsland); - BeginSubtree(); - try { - int _alt; - State = 2548; - ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,130,Context) ) { - case 1: - EnterOuterAlt(_localctx, 1); - { - State = 2450; - Match(LOCALS); - State = 2451; - sigArgs(); - } - break; - case 2: - EnterOuterAlt(_localctx, 2); - { - State = 2452; - Match(LOCALS); - State = 2453; - Match(T__156); - State = 2454; - sigArgs(); - } - break; - case 3: - EnterOuterAlt(_localctx, 3); - { - State = 2455; - dataDecl(); - } - break; - case 4: - EnterOuterAlt(_localctx, 4); - { - State = 2456; - secDecl(); - } - break; - case 5: - EnterOuterAlt(_localctx, 5); - { - State = 2457; - extSourceSpec(); - } - break; - case 6: - EnterOuterAlt(_localctx, 6); - { - State = 2458; - languageDecl(); - } - break; - case 7: - EnterOuterAlt(_localctx, 7); - { - State = 2459; - customDescrInMethodBody(); - } - break; - case 8: - EnterOuterAlt(_localctx, 8); - { - State = 2460; - compControl(); - } - break; - case 9: - EnterOuterAlt(_localctx, 9); - { - State = 2461; - Match(EXPORT); - State = 2462; - Match(T__41); - State = 2463; - int32(); - State = 2464; - Match(T__42); - } - break; - case 10: - EnterOuterAlt(_localctx, 10); - { - State = 2466; - Match(EXPORT); - State = 2467; - Match(T__41); - State = 2468; - int32(); - State = 2469; - Match(T__42); - State = 2470; - Match(T__33); - State = 2471; - id(); - } - break; - case 11: - EnterOuterAlt(_localctx, 11); - { - State = 2473; - Match(VTENTRY); - State = 2474; - int32(); - State = 2475; - Match(T__74); - State = 2476; - int32(); - } - break; - case 12: - EnterOuterAlt(_localctx, 12); + } + + [RuleVersion(0)] + public OverrideDeclContext overrideDecl() { + OverrideDeclContext _localctx = new OverrideDeclContext(Context, State); + EnterRule(_localctx, 256, RULE_overrideDecl); + Actions.BeginSemanticRoot(_localctx); + try { + State = 2512; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,127,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); { - State = 2478; + State = 2497; Match(OVERRIDE); - State = 2479; - typeSpec(); - State = 2480; + State = 2498; + _localctx.owner = typeSpec(); + State = 2499; Match(DCOLON); - State = 2481; - methodName(); + State = 2500; + _localctx.name = methodName(); } break; - case 13: - EnterOuterAlt(_localctx, 13); + case 2: + EnterOuterAlt(_localctx, 2); { - State = 2483; + State = 2502; Match(OVERRIDE); - State = 2484; + State = 2503; Match(METHOD); - State = 2485; - callConv(); - State = 2486; - type(); - State = 2487; - typeSpec(); - State = 2488; + State = 2504; + _localctx.convention = callConv(); + State = 2505; + _localctx.returnType = type(); + State = 2506; + _localctx.owner = typeSpec(); + State = 2507; Match(DCOLON); - State = 2489; - methodName(); - State = 2490; - genArity(); - State = 2491; - sigArgs(); + State = 2508; + _localctx.name = methodName(); + State = 2509; + _localctx.arity = genArity(); + State = 2510; + _localctx.arguments = sigArgs(); } break; - case 14: - EnterOuterAlt(_localctx, 14); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + Actions.EndOverrideDirective(_localctx); + ExitRule(); + } + return _localctx; + } + + public partial class ParameterDeclContext : ParserRuleContext { + public Int32Context genericIndex; + public CustomAttrDeclContext attribute; + public DottedNameContext genericName; + public Int32Context constraintIndex; + public TypeSpecContext constraintType; + public DottedNameContext constraintName; + public Int32Context parameterIndex; + public InitOptContext initializer; + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PARAM() { return GetToken(CILParser.PARAM, 0); } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TYPE() { return GetToken(CILParser.TYPE, 0); } + [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public CustomAttrDeclContext[] customAttrDecl() { + return GetRuleContexts(); + } + [System.Diagnostics.DebuggerNonUserCode] public CustomAttrDeclContext customAttrDecl(int i) { + return GetRuleContext(i); + } + [System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CONSTRAINT() { return GetToken(CILParser.CONSTRAINT, 0); } + [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public InitOptContext initOpt() { + return GetRuleContext(0); + } + public ParameterDeclContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_parameterDecl; } } + [System.Diagnostics.DebuggerNonUserCode] + public override TResult Accept(IParseTreeVisitor visitor) { + ICILVisitor typedVisitor = visitor as ICILVisitor; + if (typedVisitor != null) return typedVisitor.VisitParameterDecl(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ParameterDeclContext parameterDecl() { + ParameterDeclContext _localctx = new ParameterDeclContext(Context, State); + EnterRule(_localctx, 258, RULE_parameterDecl); + Actions.BeginParameterDirective(_localctx); + try { + int _alt; + State = 2579; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,133,Context) ) { + case 1: + EnterOuterAlt(_localctx, 1); { - State = 2493; + State = 2514; Match(PARAM); - State = 2494; + State = 2515; Match(TYPE); - State = 2495; + State = 2516; Match(T__41); - State = 2496; - int32(); - State = 2497; + State = 2517; + _localctx.genericIndex = int32(); + State = 2518; Match(T__42); - State = 2501; + State = 2524; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,125,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,128,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2498; - customAttrDecl(); + State = 2519; + _localctx.attribute = customAttrDecl(); + Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2503; + State = 2526; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,125,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,128,Context); } } break; - case 15: - EnterOuterAlt(_localctx, 15); + case 2: + EnterOuterAlt(_localctx, 2); { - State = 2504; + State = 2527; Match(PARAM); - State = 2505; + State = 2528; Match(TYPE); - State = 2506; - dottedName(); - State = 2510; + State = 2529; + _localctx.genericName = dottedName(); + State = 2535; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,126,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,129,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2507; - customAttrDecl(); + State = 2530; + _localctx.attribute = customAttrDecl(); + Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2512; + State = 2537; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,126,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,129,Context); } } break; - case 16: - EnterOuterAlt(_localctx, 16); + case 3: + EnterOuterAlt(_localctx, 3); { - State = 2513; + State = 2538; Match(PARAM); - State = 2514; + State = 2539; Match(CONSTRAINT); - State = 2515; + State = 2540; Match(T__41); - State = 2516; - int32(); - State = 2517; + State = 2541; + _localctx.constraintIndex = int32(); + State = 2542; Match(T__42); - State = 2518; + State = 2543; Match(T__27); - State = 2519; - typeSpec(); - State = 2523; + State = 2544; + _localctx.constraintType = typeSpec(); + State = 2550; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,127,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,130,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2520; - customAttrDecl(); + State = 2545; + _localctx.attribute = customAttrDecl(); + Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2525; + State = 2552; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,127,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,130,Context); } } break; - case 17: - EnterOuterAlt(_localctx, 17); + case 4: + EnterOuterAlt(_localctx, 4); { - State = 2526; + State = 2553; Match(PARAM); - State = 2527; + State = 2554; Match(CONSTRAINT); - State = 2528; - dottedName(); - State = 2529; + State = 2555; + _localctx.constraintName = dottedName(); + State = 2556; Match(T__27); - State = 2530; - typeSpec(); - State = 2534; + State = 2557; + _localctx.constraintType = typeSpec(); + State = 2563; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,128,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,131,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2531; - customAttrDecl(); + State = 2558; + _localctx.attribute = customAttrDecl(); + Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2536; + State = 2565; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,128,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,131,Context); } } break; - case 18: - EnterOuterAlt(_localctx, 18); + case 5: + EnterOuterAlt(_localctx, 5); { - State = 2537; + State = 2566; Match(PARAM); - State = 2538; + State = 2567; Match(T__41); - State = 2539; - int32(); - State = 2540; + State = 2568; + _localctx.parameterIndex = int32(); + State = 2569; Match(T__42); - State = 2541; - initOpt(); - State = 2545; + State = 2570; + _localctx.initializer = initOpt(); + State = 2576; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,129,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,132,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2542; - customAttrDecl(); + State = 2571; + _localctx.attribute = customAttrDecl(); + Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2547; + State = 2578; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,129,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,132,Context); } } break; } - Context.Stop = TokenStream.LT(-1); - Actions.ProcessMethodDeclarationIsland(_localctx); } catch (RecognitionException re) { _localctx.exception = re; @@ -13417,7 +13631,7 @@ public MethodDeclIslandContext methodDeclIsland() { ErrorHandler.Recover(this, re); } finally { - EndParseTreeMode(); + Actions.EndParameterDirective(_localctx); ExitRule(); } return _localctx; @@ -13444,13 +13658,13 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public LabelDeclContext labelDecl() { LabelDeclContext _localctx = new LabelDeclContext(Context, State); - EnterRule(_localctx, 252, RULE_labelDecl); + EnterRule(_localctx, 260, RULE_labelDecl); try { EnterOuterAlt(_localctx, 1); { - State = 2550; + State = 2581; _localctx.name = id(); - State = 2551; + State = 2582; Match(T__74); Actions.DefineLabel((_localctx.name!=null?(_localctx.name.Start):null)); } @@ -13467,6 +13681,7 @@ public LabelDeclContext labelDecl() { } public partial class CustomDescrInMethodBodyContext : ParserRuleContext { + public bool HasSyntaxError; [System.Diagnostics.DebuggerNonUserCode] public CustomDescrContext customDescr() { return GetRuleContext(0); } @@ -13489,22 +13704,23 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public CustomDescrInMethodBodyContext customDescrInMethodBody() { CustomDescrInMethodBodyContext _localctx = new CustomDescrInMethodBodyContext(Context, State); - EnterRule(_localctx, 254, RULE_customDescrInMethodBody); + EnterRule(_localctx, 262, RULE_customDescrInMethodBody); + BeginSubtree(); Actions.BeginSemanticRoot(_localctx); try { - State = 2556; + State = 2587; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,131,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,134,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2554; + State = 2585; customDescr(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2555; + State = 2586; customDescrWithOwner(); } break; @@ -13516,6 +13732,7 @@ public CustomDescrInMethodBodyContext customDescrInMethodBody() { ErrorHandler.Recover(this, re); } finally { + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; @@ -13541,16 +13758,16 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ScopeBlockContext scopeBlock() { ScopeBlockContext _localctx = new ScopeBlockContext(Context, State); - EnterRule(_localctx, 256, RULE_scopeBlock); + EnterRule(_localctx, 264, RULE_scopeBlock); Actions.BeginScope(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 2558; + State = 2589; Match(T__16); - State = 2559; + State = 2590; methodDecls(); - State = 2560; + State = 2591; Match(T__17); } } @@ -13567,6 +13784,8 @@ public ScopeBlockContext scopeBlock() { } public partial class SehBlockContext : ParserRuleContext { + public TryBlockContext tryRange; + public SehClausesContext clauses; [System.Diagnostics.DebuggerNonUserCode] public TryBlockContext tryBlock() { return GetRuleContext(0); } @@ -13589,18 +13808,16 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SehBlockContext sehBlock() { SehBlockContext _localctx = new SehBlockContext(Context, State); - EnterRule(_localctx, 258, RULE_sehBlock); - BeginSubtree(); + EnterRule(_localctx, 266, RULE_sehBlock); + Actions.BeginExceptionBlock(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 2562; - tryBlock(); - State = 2563; - sehClauses(); + State = 2593; + _localctx.tryRange = tryBlock(); + State = 2594; + _localctx.clauses = sehClauses(); } - Context.Stop = TokenStream.LT(-1); - Actions.EndExceptionBlock(_localctx); } catch (RecognitionException re) { _localctx.exception = re; @@ -13608,13 +13825,15 @@ public SehBlockContext sehBlock() { ErrorHandler.Recover(this, re); } finally { - EndParseTreeMode(); + Actions.EndExceptionBlock(_localctx); ExitRule(); } return _localctx; } public partial class SehClausesContext : ParserRuleContext { + public object Value; + public SehClauseContext clause; [System.Diagnostics.DebuggerNonUserCode] public SehClauseContext[] sehClause() { return GetRuleContexts(); } @@ -13637,22 +13856,24 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SehClausesContext sehClauses() { SehClausesContext _localctx = new SehClausesContext(Context, State); - EnterRule(_localctx, 260, RULE_sehClauses); + EnterRule(_localctx, 268, RULE_sehClauses); + Actions.BeginExceptionClauses(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2566; + State = 2599; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2565; - sehClause(); + State = 2596; + _localctx.clause = sehClause(); + Actions.AddExceptionClause(_localctx, _localctx.clause.Value); } } - State = 2568; + State = 2601; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( ((((_la - 160)) & ~0x3f) == 0 && ((1L << (_la - 160)) & 15L) != 0) ); @@ -13664,12 +13885,19 @@ public SehClausesContext sehClauses() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndExceptionClauses(_localctx); ExitRule(); } return _localctx; } public partial class TryBlockContext : ParserRuleContext { + public object Value; + public ScopeBlockContext body; + public IdContext startLabel; + public IdContext endLabel; + public Int32Context startOffset; + public Int32Context endOffset; [System.Diagnostics.DebuggerNonUserCode] public ScopeBlockContext scopeBlock() { return GetRuleContext(0); } @@ -13701,44 +13929,47 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TryBlockContext tryBlock() { TryBlockContext _localctx = new TryBlockContext(Context, State); - EnterRule(_localctx, 262, RULE_tryBlock); + EnterRule(_localctx, 270, RULE_tryBlock); try { - State = 2582; + State = 2619; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,133,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,136,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2570; + State = 2603; Match(T__157); - State = 2571; - scopeBlock(); + State = 2604; + _localctx.body = scopeBlock(); + _localctx.Value = Actions.CreateScopeExceptionRange(_localctx.body); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2572; + State = 2607; Match(T__157); - State = 2573; - id(); - State = 2574; + State = 2608; + _localctx.startLabel = id(); + State = 2609; Match(T__158); - State = 2575; - id(); + State = 2610; + _localctx.endLabel = id(); + _localctx.Value = Actions.CreateLabelExceptionRange((_localctx.startLabel!=null?(_localctx.startLabel.Start):null), (_localctx.endLabel!=null?(_localctx.endLabel.Start):null)); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2577; + State = 2613; Match(T__157); - State = 2578; - int32(); - State = 2579; + State = 2614; + _localctx.startOffset = int32(); + State = 2615; Match(T__158); - State = 2580; - int32(); + State = 2616; + _localctx.endOffset = int32(); + _localctx.Value = Actions.CreateOffsetExceptionRange((_localctx.startOffset!=null?(_localctx.startOffset.Start):null), (_localctx.endOffset!=null?(_localctx.endOffset.Start):null)); } break; } @@ -13755,6 +13986,10 @@ public TryBlockContext tryBlock() { } public partial class SehClauseContext : ParserRuleContext { + public object Value; + public CatchClauseContext caught; + public HandlerBlockContext handler; + public FilterClauseContext filtered; [System.Diagnostics.DebuggerNonUserCode] public CatchClauseContext catchClause() { return GetRuleContext(0); } @@ -13786,45 +14021,49 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SehClauseContext sehClause() { SehClauseContext _localctx = new SehClauseContext(Context, State); - EnterRule(_localctx, 264, RULE_sehClause); + EnterRule(_localctx, 272, RULE_sehClause); try { - State = 2596; + State = 2637; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__160: EnterOuterAlt(_localctx, 1); { - State = 2584; - catchClause(); - State = 2585; - handlerBlock(); + State = 2621; + _localctx.caught = catchClause(); + State = 2622; + _localctx.handler = handlerBlock(); + _localctx.Value = Actions.CreateCatchExceptionClause(_localctx.caught.Value, _localctx.handler.Value); } break; case T__159: EnterOuterAlt(_localctx, 2); { - State = 2587; - filterClause(); - State = 2588; - handlerBlock(); + State = 2625; + _localctx.filtered = filterClause(); + State = 2626; + _localctx.handler = handlerBlock(); + _localctx.Value = Actions.CreateFilterExceptionClause(_localctx.filtered.Value, _localctx.handler.Value); } break; case T__161: EnterOuterAlt(_localctx, 3); { - State = 2590; + State = 2629; finallyClause(); - State = 2591; - handlerBlock(); + State = 2630; + _localctx.handler = handlerBlock(); + _localctx.Value = Actions.CreateFinallyExceptionClause(_localctx.handler.Value); } break; case T__162: EnterOuterAlt(_localctx, 4); { - State = 2593; + State = 2633; faultClause(); - State = 2594; - handlerBlock(); + State = 2634; + _localctx.handler = handlerBlock(); + _localctx.Value = Actions.CreateFaultExceptionClause(_localctx.handler.Value); } break; default: @@ -13843,6 +14082,10 @@ public SehClauseContext sehClause() { } public partial class FilterClauseContext : ParserRuleContext { + public object Value; + public ScopeBlockContext body; + public IdContext label; + public Int32Context offset; [System.Diagnostics.DebuggerNonUserCode] public ScopeBlockContext scopeBlock() { return GetRuleContext(0); } @@ -13868,36 +14111,39 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public FilterClauseContext filterClause() { FilterClauseContext _localctx = new FilterClauseContext(Context, State); - EnterRule(_localctx, 266, RULE_filterClause); + EnterRule(_localctx, 274, RULE_filterClause); try { - State = 2604; + State = 2651; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,135,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,138,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2598; + State = 2639; Match(T__159); - State = 2599; - scopeBlock(); + State = 2640; + _localctx.body = scopeBlock(); + _localctx.Value = Actions.CreateScopeFilter(_localctx.body); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2600; + State = 2643; Match(T__159); - State = 2601; - id(); + State = 2644; + _localctx.label = id(); + _localctx.Value = Actions.CreateLabelFilter((_localctx.label!=null?(_localctx.label.Start):null)); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2602; + State = 2647; Match(T__159); - State = 2603; - int32(); + State = 2648; + _localctx.offset = int32(); + _localctx.Value = Actions.CreateOffsetFilter((_localctx.offset!=null?(_localctx.offset.Start):null)); } break; } @@ -13914,6 +14160,8 @@ public FilterClauseContext filterClause() { } public partial class CatchClauseContext : ParserRuleContext { + public object Value; + public TypeSpecContext catchType; [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() { return GetRuleContext(0); } @@ -13933,17 +14181,16 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public CatchClauseContext catchClause() { CatchClauseContext _localctx = new CatchClauseContext(Context, State); - EnterRule(_localctx, 268, RULE_catchClause); + EnterRule(_localctx, 276, RULE_catchClause); + Actions.BeginCatchClause(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 2606; + State = 2653; Match(T__160); - State = 2607; - typeSpec(); + State = 2654; + _localctx.catchType = typeSpec(); } - Context.Stop = TokenStream.LT(-1); - Actions.OnCatchClause(_localctx); } catch (RecognitionException re) { _localctx.exception = re; @@ -13951,6 +14198,7 @@ public CatchClauseContext catchClause() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndCatchClause(_localctx); ExitRule(); } return _localctx; @@ -13973,11 +14221,11 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public FinallyClauseContext finallyClause() { FinallyClauseContext _localctx = new FinallyClauseContext(Context, State); - EnterRule(_localctx, 270, RULE_finallyClause); + EnterRule(_localctx, 278, RULE_finallyClause); try { EnterOuterAlt(_localctx, 1); { - State = 2609; + State = 2656; Match(T__161); } } @@ -14009,11 +14257,11 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public FaultClauseContext faultClause() { FaultClauseContext _localctx = new FaultClauseContext(Context, State); - EnterRule(_localctx, 272, RULE_faultClause); + EnterRule(_localctx, 280, RULE_faultClause); try { EnterOuterAlt(_localctx, 1); { - State = 2611; + State = 2658; Match(T__162); } } @@ -14029,6 +14277,12 @@ public FaultClauseContext faultClause() { } public partial class HandlerBlockContext : ParserRuleContext { + public object Value; + public ScopeBlockContext body; + public IdContext startLabel; + public IdContext endLabel; + public Int32Context startOffset; + public Int32Context endOffset; [System.Diagnostics.DebuggerNonUserCode] public ScopeBlockContext scopeBlock() { return GetRuleContext(0); } @@ -14060,42 +14314,45 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public HandlerBlockContext handlerBlock() { HandlerBlockContext _localctx = new HandlerBlockContext(Context, State); - EnterRule(_localctx, 274, RULE_handlerBlock); + EnterRule(_localctx, 282, RULE_handlerBlock); try { - State = 2624; + State = 2675; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,136,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,139,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2613; - scopeBlock(); + State = 2660; + _localctx.body = scopeBlock(); + _localctx.Value = Actions.CreateScopeExceptionRange(_localctx.body); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2614; + State = 2663; Match(T__163); - State = 2615; - id(); - State = 2616; + State = 2664; + _localctx.startLabel = id(); + State = 2665; Match(T__158); - State = 2617; - id(); + State = 2666; + _localctx.endLabel = id(); + _localctx.Value = Actions.CreateLabelExceptionRange((_localctx.startLabel!=null?(_localctx.startLabel.Start):null), (_localctx.endLabel!=null?(_localctx.endLabel.Start):null)); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2619; + State = 2669; Match(T__163); - State = 2620; - int32(); - State = 2621; + State = 2670; + _localctx.startOffset = int32(); + State = 2671; Match(T__158); - State = 2622; - int32(); + State = 2672; + _localctx.endOffset = int32(); + _localctx.Value = Actions.CreateOffsetExceptionRange((_localctx.startOffset!=null?(_localctx.startOffset.Start):null), (_localctx.endOffset!=null?(_localctx.endOffset.Start):null)); } break; } @@ -14112,6 +14369,7 @@ public HandlerBlockContext handlerBlock() { } public partial class DataDeclContext : ParserRuleContext { + public bool HasSyntaxError; [System.Diagnostics.DebuggerNonUserCode] public DdHeadContext ddHead() { return GetRuleContext(0); } @@ -14134,13 +14392,14 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public DataDeclContext dataDecl() { DataDeclContext _localctx = new DataDeclContext(Context, State); - EnterRule(_localctx, 276, RULE_dataDecl); + EnterRule(_localctx, 284, RULE_dataDecl); + BeginSubtree(); Actions.BeginSemanticRoot(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 2626; + State = 2677; ddHead(); - State = 2627; + State = 2678; ddBody(); } } @@ -14150,6 +14409,7 @@ public DataDeclContext dataDecl() { ErrorHandler.Recover(this, re); } finally { + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; @@ -14178,30 +14438,30 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public DdHeadContext ddHead() { DdHeadContext _localctx = new DdHeadContext(Context, State); - EnterRule(_localctx, 278, RULE_ddHead); + EnterRule(_localctx, 286, RULE_ddHead); try { - State = 2636; + State = 2687; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,137,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,140,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2629; + State = 2680; Match(T__164); - State = 2630; + State = 2681; tls(); - State = 2631; + State = 2682; id(); - State = 2632; + State = 2683; Match(T__35); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2634; + State = 2685; Match(T__164); - State = 2635; + State = 2686; tls(); } break; @@ -14235,11 +14495,11 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TlsContext tls() { TlsContext _localctx = new TlsContext(Context, State); - EnterRule(_localctx, 280, RULE_tls); + EnterRule(_localctx, 288, RULE_tls); try { - State = 2641; + State = 2692; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,138,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,141,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -14248,14 +14508,14 @@ public TlsContext tls() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2639; + State = 2690; Match(T__165); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2640; + State = 2691; Match(T__1); } break; @@ -14298,20 +14558,20 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public DdBodyContext ddBody() { DdBodyContext _localctx = new DdBodyContext(Context, State); - EnterRule(_localctx, 282, RULE_ddBody); + EnterRule(_localctx, 290, RULE_ddBody); int _la; try { - State = 2652; + State = 2703; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: EnterOuterAlt(_localctx, 1); { - State = 2643; + State = 2694; Match(T__16); - State = 2644; + State = 2695; ddItemList(); - State = 2645; + State = 2696; Match(T__17); } break; @@ -14326,17 +14586,17 @@ public DdBodyContext ddBody() { case REF: EnterOuterAlt(_localctx, 2); { - State = 2648; + State = 2699; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2647; + State = 2698; ddItem(); } } - State = 2650; + State = 2701; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( _la==T__83 || ((((_la - 181)) & ~0x3f) == 0 && ((1L << (_la - 181)) & 505L) != 0) || _la==REF ); @@ -14380,30 +14640,30 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public DdItemListContext ddItemList() { DdItemListContext _localctx = new DdItemListContext(Context, State); - EnterRule(_localctx, 284, RULE_ddItemList); + EnterRule(_localctx, 292, RULE_ddItemList); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 2659; + State = 2710; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,141,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,144,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2654; + State = 2705; ddItem(); - State = 2655; + State = 2706; Match(T__27); } } } - State = 2661; + State = 2712; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,141,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,144,Context); } - State = 2662; + State = 2713; ddItem(); } } @@ -14438,9 +14698,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public DdItemCountContext ddItemCount() { DdItemCountContext _localctx = new DdItemCountContext(Context, State); - EnterRule(_localctx, 286, RULE_ddItemCount); + EnterRule(_localctx, 294, RULE_ddItemCount); try { - State = 2669; + State = 2720; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -14544,11 +14804,11 @@ public DdItemCountContext ddItemCount() { case T__41: EnterOuterAlt(_localctx, 2); { - State = 2665; + State = 2716; Match(T__41); - State = 2666; + State = 2717; int32(); - State = 2667; + State = 2718; Match(T__42); } break; @@ -14614,202 +14874,202 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public DdItemContext ddItem() { DdItemContext _localctx = new DdItemContext(Context, State); - EnterRule(_localctx, 288, RULE_ddItem); + EnterRule(_localctx, 296, RULE_ddItem); try { - State = 2737; + State = 2788; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,143,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,146,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2671; + State = 2722; Match(CHAR); - State = 2672; + State = 2723; Match(PTR); - State = 2673; + State = 2724; Match(T__29); - State = 2674; + State = 2725; compQstring(); - State = 2675; + State = 2726; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2677; + State = 2728; Match(REF); - State = 2678; + State = 2729; Match(T__29); - State = 2679; + State = 2730; id(); - State = 2680; + State = 2731; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2682; + State = 2733; Match(REF); - State = 2683; + State = 2734; id(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2684; + State = 2735; Match(T__83); - State = 2685; + State = 2736; Match(T__29); - State = 2686; + State = 2737; bytes(); - State = 2687; + State = 2738; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2689; + State = 2740; Match(FLOAT32); - State = 2690; + State = 2741; Match(T__29); - State = 2691; + State = 2742; float64(); - State = 2692; + State = 2743; Match(T__30); - State = 2693; + State = 2744; ddItemCount(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2695; + State = 2746; Match(FLOAT64_); - State = 2696; + State = 2747; Match(T__29); - State = 2697; + State = 2748; float64(); - State = 2698; + State = 2749; Match(T__30); - State = 2699; + State = 2750; ddItemCount(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2701; + State = 2752; Match(INT64_); - State = 2702; + State = 2753; Match(T__29); - State = 2703; + State = 2754; int64(); - State = 2704; + State = 2755; Match(T__30); - State = 2705; + State = 2756; ddItemCount(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2707; + State = 2758; Match(INT32_); - State = 2708; + State = 2759; Match(T__29); - State = 2709; + State = 2760; int32(); - State = 2710; + State = 2761; Match(T__30); - State = 2711; + State = 2762; ddItemCount(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2713; + State = 2764; Match(INT16); - State = 2714; + State = 2765; Match(T__29); - State = 2715; + State = 2766; int32(); - State = 2716; + State = 2767; Match(T__30); - State = 2717; + State = 2768; ddItemCount(); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2719; + State = 2770; Match(INT8); - State = 2720; + State = 2771; Match(T__29); - State = 2721; + State = 2772; int32(); - State = 2722; + State = 2773; Match(T__30); - State = 2723; + State = 2774; ddItemCount(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2725; + State = 2776; Match(FLOAT32); - State = 2726; + State = 2777; ddItemCount(); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2727; + State = 2778; Match(FLOAT64_); - State = 2728; + State = 2779; ddItemCount(); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2729; + State = 2780; Match(INT64_); - State = 2730; + State = 2781; ddItemCount(); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2731; + State = 2782; Match(INT32_); - State = 2732; + State = 2783; ddItemCount(); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2733; + State = 2784; Match(INT16); - State = 2734; + State = 2785; ddItemCount(); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 2735; + State = 2786; Match(INT8); - State = 2736; + State = 2787; ddItemCount(); } break; @@ -14870,203 +15130,203 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public FieldSerInitContext fieldSerInit() { FieldSerInitContext _localctx = new FieldSerInitContext(Context, State); - EnterRule(_localctx, 290, RULE_fieldSerInit); + EnterRule(_localctx, 298, RULE_fieldSerInit); try { - State = 2814; + State = 2865; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,144,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,147,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2739; + State = 2790; Match(FLOAT32); - State = 2740; + State = 2791; Match(T__29); - State = 2741; + State = 2792; float64(); - State = 2742; + State = 2793; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2744; + State = 2795; Match(FLOAT64_); - State = 2745; + State = 2796; Match(T__29); - State = 2746; + State = 2797; float64(); - State = 2747; + State = 2798; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2749; + State = 2800; Match(FLOAT32); - State = 2750; + State = 2801; Match(T__29); - State = 2751; + State = 2802; int32(); - State = 2752; + State = 2803; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2754; + State = 2805; Match(FLOAT64_); - State = 2755; + State = 2806; Match(T__29); - State = 2756; + State = 2807; int64(); - State = 2757; + State = 2808; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2759; + State = 2810; Match(INT64_); - State = 2760; + State = 2811; Match(T__29); - State = 2761; + State = 2812; int64(); - State = 2762; + State = 2813; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2764; + State = 2815; Match(INT32_); - State = 2765; + State = 2816; Match(T__29); - State = 2766; + State = 2817; int32(); - State = 2767; + State = 2818; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2769; + State = 2820; Match(INT16); - State = 2770; + State = 2821; Match(T__29); - State = 2771; + State = 2822; int32(); - State = 2772; + State = 2823; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2774; + State = 2825; Match(INT8); - State = 2775; + State = 2826; Match(T__29); - State = 2776; + State = 2827; int32(); - State = 2777; + State = 2828; Match(T__30); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2779; + State = 2830; Match(UINT64); - State = 2780; + State = 2831; Match(T__29); - State = 2781; + State = 2832; int64(); - State = 2782; + State = 2833; Match(T__30); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2784; + State = 2835; Match(UINT32); - State = 2785; + State = 2836; Match(T__29); - State = 2786; + State = 2837; int32(); - State = 2787; + State = 2838; Match(T__30); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2789; + State = 2840; Match(UINT16); - State = 2790; + State = 2841; Match(T__29); - State = 2791; + State = 2842; int32(); - State = 2792; + State = 2843; Match(T__30); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2794; + State = 2845; Match(UINT8); - State = 2795; + State = 2846; Match(T__29); - State = 2796; + State = 2847; int32(); - State = 2797; + State = 2848; Match(T__30); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2799; + State = 2850; Match(CHAR); - State = 2800; + State = 2851; Match(T__29); - State = 2801; + State = 2852; int32(); - State = 2802; + State = 2853; Match(T__30); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2804; + State = 2855; Match(BOOL); - State = 2805; + State = 2856; Match(T__29); - State = 2806; + State = 2857; truefalse(); - State = 2807; + State = 2858; Match(T__30); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2809; + State = 2860; Match(T__83); - State = 2810; + State = 2861; Match(T__29); - State = 2811; + State = 2862; bytes(); - State = 2812; + State = 2863; Match(T__30); } break; @@ -15108,24 +15368,24 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public BytesContext bytes() { BytesContext _localctx = new BytesContext(Context, State); - EnterRule(_localctx, 292, RULE_bytes); + EnterRule(_localctx, 300, RULE_bytes); BeginStreaming(); Actions.BeginBytes(); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2821; + State = 2872; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32 || _la==ID || _la==HEXBYTE) { { { - State = 2816; + State = 2867; _localctx.b = hexbyte(); Actions.AddByte(_localctx.b.Value); } } - State = 2823; + State = 2874; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15164,12 +15424,12 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public HexbyteContext hexbyte() { HexbyteContext _localctx = new HexbyteContext(Context, State); - EnterRule(_localctx, 294, RULE_hexbyte); + EnterRule(_localctx, 302, RULE_hexbyte); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2824; + State = 2875; _la = TokenStream.LA(1); if ( !(_la==INT32 || _la==ID || _la==HEXBYTE) ) { ErrorHandler.RecoverInline(this); @@ -15217,9 +15477,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public FieldInitContext fieldInit() { FieldInitContext _localctx = new FieldInitContext(Context, State); - EnterRule(_localctx, 296, RULE_fieldInit); + EnterRule(_localctx, 304, RULE_fieldInit); try { - State = 2829; + State = 2880; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__83: @@ -15237,21 +15497,21 @@ public FieldInitContext fieldInit() { case UINT64: EnterOuterAlt(_localctx, 1); { - State = 2826; + State = 2877; fieldSerInit(); } break; case QSTRING: EnterOuterAlt(_localctx, 2); { - State = 2827; + State = 2878; compQstring(); } break; case NULLREF: EnterOuterAlt(_localctx, 3); { - State = 2828; + State = 2879; Match(NULLREF); } break; @@ -15346,380 +15606,380 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SerInitContext serInit() { SerInitContext _localctx = new SerInitContext(Context, State); - EnterRule(_localctx, 298, RULE_serInit); + EnterRule(_localctx, 306, RULE_serInit); try { - State = 2979; + State = 3030; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,147,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,150,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2831; + State = 2882; fieldSerInit(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2832; + State = 2883; Match(STRING); - State = 2833; + State = 2884; Match(T__29); - State = 2834; + State = 2885; Match(NULLREF); - State = 2835; + State = 2886; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2836; + State = 2887; Match(STRING); - State = 2837; + State = 2888; Match(T__29); - State = 2838; + State = 2889; Match(SQSTRING); - State = 2839; + State = 2890; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2840; + State = 2891; Match(TYPE); - State = 2841; + State = 2892; Match(T__29); - State = 2842; + State = 2893; Match(T__38); - State = 2843; + State = 2894; Match(SQSTRING); - State = 2844; + State = 2895; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2845; + State = 2896; Match(TYPE); - State = 2846; + State = 2897; Match(T__29); - State = 2847; + State = 2898; className(); - State = 2848; + State = 2899; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2850; + State = 2901; Match(TYPE); - State = 2851; + State = 2902; Match(T__29); - State = 2852; + State = 2903; Match(NULLREF); - State = 2853; + State = 2904; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2854; + State = 2905; Match(OBJECT); - State = 2855; + State = 2906; Match(T__29); - State = 2856; + State = 2907; serInit(); - State = 2857; + State = 2908; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2859; + State = 2910; Match(FLOAT32); - State = 2860; + State = 2911; Match(T__41); - State = 2861; + State = 2912; int32(); - State = 2862; + State = 2913; Match(T__42); - State = 2863; + State = 2914; Match(T__29); - State = 2864; + State = 2915; f32seq(); - State = 2865; + State = 2916; Match(T__30); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2867; + State = 2918; Match(FLOAT64_); - State = 2868; + State = 2919; Match(T__41); - State = 2869; + State = 2920; int32(); - State = 2870; + State = 2921; Match(T__42); - State = 2871; + State = 2922; Match(T__29); - State = 2872; + State = 2923; f64seq(); - State = 2873; + State = 2924; Match(T__30); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2875; + State = 2926; Match(INT64_); - State = 2876; + State = 2927; Match(T__41); - State = 2877; + State = 2928; int32(); - State = 2878; + State = 2929; Match(T__42); - State = 2879; + State = 2930; Match(T__29); - State = 2880; + State = 2931; i64seq(); - State = 2881; + State = 2932; Match(T__30); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2883; + State = 2934; Match(INT32_); - State = 2884; + State = 2935; Match(T__41); - State = 2885; + State = 2936; int32(); - State = 2886; + State = 2937; Match(T__42); - State = 2887; + State = 2938; Match(T__29); - State = 2888; + State = 2939; i32seq(); - State = 2889; + State = 2940; Match(T__30); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2891; + State = 2942; Match(INT16); - State = 2892; + State = 2943; Match(T__41); - State = 2893; + State = 2944; int32(); - State = 2894; + State = 2945; Match(T__42); - State = 2895; + State = 2946; Match(T__29); - State = 2896; + State = 2947; i16seq(); - State = 2897; + State = 2948; Match(T__30); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2899; + State = 2950; Match(INT8); - State = 2900; + State = 2951; Match(T__41); - State = 2901; + State = 2952; int32(); - State = 2902; + State = 2953; Match(T__42); - State = 2903; + State = 2954; Match(T__29); - State = 2904; + State = 2955; i8seq(); - State = 2905; + State = 2956; Match(T__30); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2907; + State = 2958; Match(UINT64); - State = 2908; + State = 2959; Match(T__41); - State = 2909; + State = 2960; int32(); - State = 2910; + State = 2961; Match(T__42); - State = 2911; + State = 2962; Match(T__29); - State = 2912; + State = 2963; i64seq(); - State = 2913; + State = 2964; Match(T__30); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2915; + State = 2966; Match(UINT32); - State = 2916; + State = 2967; Match(T__41); - State = 2917; + State = 2968; int32(); - State = 2918; + State = 2969; Match(T__42); - State = 2919; + State = 2970; Match(T__29); - State = 2920; + State = 2971; i32seq(); - State = 2921; + State = 2972; Match(T__30); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 2923; + State = 2974; Match(UINT16); - State = 2924; + State = 2975; Match(T__41); - State = 2925; + State = 2976; int32(); - State = 2926; + State = 2977; Match(T__42); - State = 2927; + State = 2978; Match(T__29); - State = 2928; + State = 2979; i16seq(); - State = 2929; + State = 2980; Match(T__30); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 2931; + State = 2982; Match(UINT8); - State = 2932; + State = 2983; Match(T__41); - State = 2933; + State = 2984; int32(); - State = 2934; + State = 2985; Match(T__42); - State = 2935; + State = 2986; Match(T__29); - State = 2936; + State = 2987; i8seq(); - State = 2937; + State = 2988; Match(T__30); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 2939; + State = 2990; Match(CHAR); - State = 2940; + State = 2991; Match(T__41); - State = 2941; + State = 2992; int32(); - State = 2942; + State = 2993; Match(T__42); - State = 2943; + State = 2994; Match(T__29); - State = 2944; + State = 2995; i16seq(); - State = 2945; + State = 2996; Match(T__30); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 2947; + State = 2998; Match(BOOL); - State = 2948; + State = 2999; Match(T__41); - State = 2949; + State = 3000; int32(); - State = 2950; + State = 3001; Match(T__42); - State = 2951; + State = 3002; Match(T__29); - State = 2952; + State = 3003; boolSeq(); - State = 2953; + State = 3004; Match(T__30); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 2955; + State = 3006; Match(STRING); - State = 2956; + State = 3007; Match(T__41); - State = 2957; + State = 3008; int32(); - State = 2958; + State = 3009; Match(T__42); - State = 2959; + State = 3010; Match(T__29); - State = 2960; + State = 3011; sqstringSeq(); - State = 2961; + State = 3012; Match(T__30); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 2963; + State = 3014; Match(TYPE); - State = 2964; + State = 3015; Match(T__41); - State = 2965; + State = 3016; int32(); - State = 2966; + State = 3017; Match(T__42); - State = 2967; + State = 3018; Match(T__29); - State = 2968; + State = 3019; classSeq(); - State = 2969; + State = 3020; Match(T__30); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 2971; + State = 3022; Match(OBJECT); - State = 2972; + State = 3023; Match(T__41); - State = 2973; + State = 3024; int32(); - State = 2974; + State = 3025; Match(T__42); - State = 2975; + State = 3026; Match(T__29); - State = 2976; + State = 3027; objSeq(); - State = 2977; + State = 3028; Match(T__30); } break; @@ -15765,34 +16025,34 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public F32seqContext f32seq() { F32seqContext _localctx = new F32seqContext(Context, State); - EnterRule(_localctx, 300, RULE_f32seq); + EnterRule(_localctx, 308, RULE_f32seq); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2985; + State = 3036; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 98309L) != 0)) { { - State = 2983; + State = 3034; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,148,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,151,Context) ) { case 1: { - State = 2981; + State = 3032; float64(); } break; case 2: { - State = 2982; + State = 3033; int32(); } break; } } - State = 2987; + State = 3038; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15838,34 +16098,34 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public F64seqContext f64seq() { F64seqContext _localctx = new F64seqContext(Context, State); - EnterRule(_localctx, 302, RULE_f64seq); + EnterRule(_localctx, 310, RULE_f64seq); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2992; + State = 3043; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 98311L) != 0)) { { - State = 2990; + State = 3041; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,150,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,153,Context) ) { case 1: { - State = 2988; + State = 3039; float64(); } break; case 2: { - State = 2989; + State = 3040; int64(); } break; } } - State = 2994; + State = 3045; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15905,22 +16165,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public I64seqContext i64seq() { I64seqContext _localctx = new I64seqContext(Context, State); - EnterRule(_localctx, 304, RULE_i64seq); + EnterRule(_localctx, 312, RULE_i64seq); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2998; + State = 3049; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32 || _la==INT64) { { { - State = 2995; + State = 3046; int64(); } } - State = 3000; + State = 3051; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15960,22 +16220,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public I32seqContext i32seq() { I32seqContext _localctx = new I32seqContext(Context, State); - EnterRule(_localctx, 306, RULE_i32seq); + EnterRule(_localctx, 314, RULE_i32seq); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3004; + State = 3055; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 3001; + State = 3052; int32(); } } - State = 3006; + State = 3057; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16015,22 +16275,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public I16seqContext i16seq() { I16seqContext _localctx = new I16seqContext(Context, State); - EnterRule(_localctx, 308, RULE_i16seq); + EnterRule(_localctx, 316, RULE_i16seq); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3010; + State = 3061; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 3007; + State = 3058; int32(); } } - State = 3012; + State = 3063; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16070,22 +16330,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public I8seqContext i8seq() { I8seqContext _localctx = new I8seqContext(Context, State); - EnterRule(_localctx, 310, RULE_i8seq); + EnterRule(_localctx, 318, RULE_i8seq); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3016; + State = 3067; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 3013; + State = 3064; int32(); } } - State = 3018; + State = 3069; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16125,22 +16385,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public BoolSeqContext boolSeq() { BoolSeqContext _localctx = new BoolSeqContext(Context, State); - EnterRule(_localctx, 312, RULE_boolSeq); + EnterRule(_localctx, 320, RULE_boolSeq); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3022; + State = 3073; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__94 || _la==T__95) { { { - State = 3019; + State = 3070; truefalse(); } } - State = 3024; + State = 3075; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16182,18 +16442,18 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SqstringSeqContext sqstringSeq() { SqstringSeqContext _localctx = new SqstringSeqContext(Context, State); - EnterRule(_localctx, 314, RULE_sqstringSeq); + EnterRule(_localctx, 322, RULE_sqstringSeq); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3028; + State = 3079; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==NULLREF || _la==SQSTRING) { { { - State = 3025; + State = 3076; _la = TokenStream.LA(1); if ( !(_la==NULLREF || _la==SQSTRING) ) { ErrorHandler.RecoverInline(this); @@ -16204,7 +16464,7 @@ public SqstringSeqContext sqstringSeq() { } } } - State = 3030; + State = 3081; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16244,22 +16504,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ClassSeqContext classSeq() { ClassSeqContext _localctx = new ClassSeqContext(Context, State); - EnterRule(_localctx, 316, RULE_classSeq); + EnterRule(_localctx, 324, RULE_classSeq); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3034; + State = 3085; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4947802390528L) != 0) || _la==T__112 || _la==NULLREF || _la==VALUE || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 105553118478337L) != 0)) { { { - State = 3031; + State = 3082; classSeqElement(); } } - State = 3036; + State = 3087; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16298,24 +16558,24 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ClassSeqElementContext classSeqElement() { ClassSeqElementContext _localctx = new ClassSeqElementContext(Context, State); - EnterRule(_localctx, 318, RULE_classSeqElement); + EnterRule(_localctx, 326, RULE_classSeqElement); try { - State = 3041; + State = 3092; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case NULLREF: EnterOuterAlt(_localctx, 1); { - State = 3037; + State = 3088; Match(NULLREF); } break; case T__38: EnterOuterAlt(_localctx, 2); { - State = 3038; + State = 3089; Match(T__38); - State = 3039; + State = 3090; Match(SQSTRING); } break; @@ -16332,7 +16592,7 @@ public ClassSeqElementContext classSeqElement() { case ID: EnterOuterAlt(_localctx, 3); { - State = 3040; + State = 3091; className(); } break; @@ -16374,22 +16634,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ObjSeqContext objSeq() { ObjSeqContext _localctx = new ObjSeqContext(Context, State); - EnterRule(_localctx, 320, RULE_objSeq); + EnterRule(_localctx, 328, RULE_objSeq); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3046; + State = 3097; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__83 || ((((_la - 181)) & ~0x3f) == 0 && ((1L << (_la - 181)) & 106495L) != 0)) { { { - State = 3043; + State = 3094; serInit(); } } - State = 3048; + State = 3099; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16407,6 +16667,7 @@ public ObjSeqContext objSeq() { } public partial class CustomAttrDeclContext : ParserRuleContext { + public bool HasSyntaxError; [System.Diagnostics.DebuggerNonUserCode] public CustomDescrContext customDescr() { return GetRuleContext(0); } @@ -16432,29 +16693,30 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public CustomAttrDeclContext customAttrDecl() { CustomAttrDeclContext _localctx = new CustomAttrDeclContext(Context, State); - EnterRule(_localctx, 322, RULE_customAttrDecl); + EnterRule(_localctx, 330, RULE_customAttrDecl); + BeginSubtree(); Actions.BeginSemanticRoot(_localctx); try { - State = 3052; + State = 3103; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,161,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,164,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3049; + State = 3100; customDescr(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3050; + State = 3101; customDescrWithOwner(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3051; + State = 3102; dottedName(); } break; @@ -16466,6 +16728,7 @@ public CustomAttrDeclContext customAttrDecl() { ErrorHandler.Recover(this, re); } finally { + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; @@ -16506,16 +16769,16 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public AsmOrRefDeclContext asmOrRefDecl() { AsmOrRefDeclContext _localctx = new AsmOrRefDeclContext(Context, State); - EnterRule(_localctx, 324, RULE_asmOrRefDecl); + EnterRule(_localctx, 332, RULE_asmOrRefDecl); int _la; try { - State = 3079; + State = 3130; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,162,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,165,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3054; + State = 3105; _la = TokenStream.LA(1); if ( !(_la==T__166 || _la==T__167) ) { ErrorHandler.RecoverInline(this); @@ -16524,72 +16787,72 @@ public AsmOrRefDeclContext asmOrRefDecl() { ErrorHandler.ReportMatch(this); Consume(); } - State = 3055; + State = 3106; Match(T__35); - State = 3056; + State = 3107; Match(T__29); - State = 3057; + State = 3108; bytes(); - State = 3058; + State = 3109; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3060; + State = 3111; Match(T__168); - State = 3061; + State = 3112; intOrWildcard(); - State = 3062; + State = 3113; Match(T__74); - State = 3063; + State = 3114; intOrWildcard(); - State = 3064; + State = 3115; Match(T__74); - State = 3065; + State = 3116; intOrWildcard(); - State = 3066; + State = 3117; Match(T__74); - State = 3067; + State = 3118; intOrWildcard(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3069; + State = 3120; Match(T__169); - State = 3070; + State = 3121; compQstring(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 3071; + State = 3122; Match(T__169); - State = 3072; + State = 3123; Match(T__35); - State = 3073; + State = 3124; Match(T__29); - State = 3074; + State = 3125; bytes(); - State = 3075; + State = 3126; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 3077; + State = 3128; customAttrDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 3078; + State = 3129; compControl(); } break; @@ -16632,38 +16895,38 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public AssemblyRefHeadContext assemblyRefHead() { AssemblyRefHeadContext _localctx = new AssemblyRefHeadContext(Context, State); - EnterRule(_localctx, 326, RULE_assemblyRefHead); + EnterRule(_localctx, 334, RULE_assemblyRefHead); try { - State = 3093; + State = 3144; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,163,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,166,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3081; + State = 3132; Match(T__24); - State = 3082; + State = 3133; Match(T__39); - State = 3083; + State = 3134; asmAttr(); - State = 3084; + State = 3135; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3086; + State = 3137; Match(T__24); - State = 3087; + State = 3138; Match(T__39); - State = 3088; + State = 3139; asmAttr(); - State = 3089; + State = 3140; dottedName(); - State = 3090; + State = 3141; Match(T__33); - State = 3091; + State = 3142; dottedName(); } break; @@ -16703,22 +16966,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public AssemblyRefDeclsContext assemblyRefDecls() { AssemblyRefDeclsContext _localctx = new AssemblyRefDeclsContext(Context, State); - EnterRule(_localctx, 328, RULE_assemblyRefDecls); + EnterRule(_localctx, 336, RULE_assemblyRefDecls); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3098; + State = 3149; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 36028835673735168L) != 0) || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & 4294975519L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 105555249070081L) != 0)) { { { - State = 3095; + State = 3146; assemblyRefDecl(); } } - State = 3100; + State = 3151; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16759,23 +17022,23 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public AssemblyRefDeclContext assemblyRefDecl() { AssemblyRefDeclContext _localctx = new AssemblyRefDeclContext(Context, State); - EnterRule(_localctx, 330, RULE_assemblyRefDecl); + EnterRule(_localctx, 338, RULE_assemblyRefDecl); try { - State = 3115; + State = 3166; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case HASH: EnterOuterAlt(_localctx, 1); { - State = 3101; + State = 3152; Match(HASH); - State = 3102; + State = 3153; Match(T__35); - State = 3103; + State = 3154; Match(T__29); - State = 3104; + State = 3155; bytes(); - State = 3105; + State = 3156; Match(T__30); } break; @@ -16800,29 +17063,29 @@ public AssemblyRefDeclContext assemblyRefDecl() { case ID: EnterOuterAlt(_localctx, 2); { - State = 3107; + State = 3158; asmOrRefDecl(); } break; case T__170: EnterOuterAlt(_localctx, 3); { - State = 3108; + State = 3159; Match(T__170); - State = 3109; + State = 3160; Match(T__35); - State = 3110; + State = 3161; Match(T__29); - State = 3111; + State = 3162; bytes(); - State = 3112; + State = 3163; Match(T__30); } break; case T__54: EnterOuterAlt(_localctx, 4); { - State = 3114; + State = 3165; Match(T__54); } break; @@ -16867,30 +17130,30 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ExptypeHeadContext exptypeHead() { ExptypeHeadContext _localctx = new ExptypeHeadContext(Context, State); - EnterRule(_localctx, 332, RULE_exptypeHead); + EnterRule(_localctx, 340, RULE_exptypeHead); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3117; + State = 3168; Match(T__49); - State = 3118; + State = 3169; Match(T__39); - State = 3122; + State = 3173; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4618441417868443648L) != 0) || _la==T__171) { { { - State = 3119; + State = 3170; exptAttr(); } } - State = 3124; + State = 3175; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 3125; + State = 3176; dottedName(); } } @@ -16932,28 +17195,28 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ExportHeadContext exportHead() { ExportHeadContext _localctx = new ExportHeadContext(Context, State); - EnterRule(_localctx, 334, RULE_exportHead); + EnterRule(_localctx, 342, RULE_exportHead); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3127; + State = 3178; Match(EXPORT); - State = 3131; + State = 3182; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4618441417868443648L) != 0) || _la==T__171) { { { - State = 3128; + State = 3179; exptAttr(); } } - State = 3133; + State = 3184; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 3134; + State = 3185; dottedName(); } } @@ -16985,83 +17248,83 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ExptAttrContext exptAttr() { ExptAttrContext _localctx = new ExptAttrContext(Context, State); - EnterRule(_localctx, 336, RULE_exptAttr); + EnterRule(_localctx, 344, RULE_exptAttr); try { - State = 3151; + State = 3202; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,168,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,171,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3136; + State = 3187; Match(T__51); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3137; + State = 3188; Match(T__50); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3138; + State = 3189; Match(T__171); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 3139; + State = 3190; Match(T__61); - State = 3140; + State = 3191; Match(T__50); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 3141; + State = 3192; Match(T__61); - State = 3142; + State = 3193; Match(T__51); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 3143; + State = 3194; Match(T__61); - State = 3144; + State = 3195; Match(T__62); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 3145; + State = 3196; Match(T__61); - State = 3146; + State = 3197; Match(T__63); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 3147; + State = 3198; Match(T__61); - State = 3148; + State = 3199; Match(T__64); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 3149; + State = 3200; Match(T__61); - State = 3150; + State = 3201; Match(T__65); } break; @@ -17101,22 +17364,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ExptypeDeclsContext exptypeDecls() { ExptypeDeclsContext _localctx = new ExptypeDeclsContext(Context, State); - EnterRule(_localctx, 338, RULE_exptypeDecls); + EnterRule(_localctx, 346, RULE_exptypeDecls); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3156; + State = 3207; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1125938597265408L) != 0) || _la==T__112 || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 3153; + State = 3204; exptypeDecl(); } } - State = 3158; + State = 3209; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17168,69 +17431,69 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ExptypeDeclContext exptypeDecl() { ExptypeDeclContext _localctx = new ExptypeDeclContext(Context, State); - EnterRule(_localctx, 340, RULE_exptypeDecl); + EnterRule(_localctx, 348, RULE_exptypeDecl); try { - State = 3172; + State = 3223; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,170,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,173,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3159; + State = 3210; Match(T__20); - State = 3160; + State = 3211; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3161; + State = 3212; Match(T__49); - State = 3162; + State = 3213; Match(T__39); - State = 3163; + State = 3214; slashedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3164; + State = 3215; Match(T__24); - State = 3165; + State = 3216; Match(T__39); - State = 3166; + State = 3217; dottedName(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 3167; + State = 3218; mdtoken(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 3168; + State = 3219; Match(T__49); - State = 3169; + State = 3220; int32(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 3170; + State = 3221; customAttrDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 3171; + State = 3222; compControl(); } break; @@ -17277,59 +17540,59 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ManifestResHeadContext manifestResHead() { ManifestResHeadContext _localctx = new ManifestResHeadContext(Context, State); - EnterRule(_localctx, 342, RULE_manifestResHead); + EnterRule(_localctx, 350, RULE_manifestResHead); int _la; try { - State = 3193; + State = 3244; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,173,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,176,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3174; + State = 3225; Match(MRESOURCE); - State = 3178; + State = 3229; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__50 || _la==T__51) { { { - State = 3175; + State = 3226; manresAttr(); } } - State = 3180; + State = 3231; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 3181; + State = 3232; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3182; + State = 3233; Match(MRESOURCE); - State = 3186; + State = 3237; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__50 || _la==T__51) { { { - State = 3183; + State = 3234; manresAttr(); } } - State = 3188; + State = 3239; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 3189; + State = 3240; dottedName(); - State = 3190; + State = 3241; Match(T__33); - State = 3191; + State = 3242; dottedName(); } break; @@ -17363,12 +17626,12 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ManresAttrContext manresAttr() { ManresAttrContext _localctx = new ManresAttrContext(Context, State); - EnterRule(_localctx, 344, RULE_manresAttr); + EnterRule(_localctx, 352, RULE_manresAttr); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3195; + State = 3246; _la = TokenStream.LA(1); if ( !(_la==T__50 || _la==T__51) ) { ErrorHandler.RecoverInline(this); @@ -17413,22 +17676,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ManifestResDeclsContext manifestResDecls() { ManifestResDeclsContext _localctx = new ManifestResDeclsContext(Context, State); - EnterRule(_localctx, 346, RULE_manifestResDecls); + EnterRule(_localctx, 354, RULE_manifestResDecls); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3200; + State = 3251; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38690422784L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 3197; + State = 3248; manifestResDecl(); } } - State = 3202; + State = 3253; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17474,32 +17737,32 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ManifestResDeclContext manifestResDecl() { ManifestResDeclContext _localctx = new ManifestResDeclContext(Context, State); - EnterRule(_localctx, 348, RULE_manifestResDecl); + EnterRule(_localctx, 356, RULE_manifestResDecl); try { - State = 3213; + State = 3264; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__20: EnterOuterAlt(_localctx, 1); { - State = 3203; + State = 3254; Match(T__20); - State = 3204; + State = 3255; dottedName(); - State = 3205; + State = 3256; Match(T__43); - State = 3206; + State = 3257; int32(); } break; case T__24: EnterOuterAlt(_localctx, 2); { - State = 3208; + State = 3259; Match(T__24); - State = 3209; + State = 3260; Match(T__39); - State = 3210; + State = 3261; dottedName(); } break; @@ -17512,7 +17775,7 @@ public ManifestResDeclContext manifestResDecl() { case ID: EnterOuterAlt(_localctx, 3); { - State = 3211; + State = 3262; customAttrDecl(); } break; @@ -17526,7 +17789,7 @@ public ManifestResDeclContext manifestResDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 4); { - State = 3212; + State = 3263; compControl(); } break; @@ -17563,7 +17826,7 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { } private static int[] _serializedATN = { - 4,1,305,3216,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, + 4,1,305,3267,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, @@ -17589,75 +17852,76 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 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,1,0,1,0,1,1,1,1,1,1,1, - 1,1,1,1,1,5,1,359,8,1,10,1,12,1,362,9,1,1,1,1,1,1,1,1,1,1,1,3,1,369,8, - 1,1,2,1,2,1,3,1,3,1,3,5,3,376,8,3,10,3,12,3,379,9,3,1,3,1,3,1,3,1,4,5, - 4,385,8,4,10,4,12,4,388,9,4,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1, - 5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5, + 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,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,5,1,367,8,1,10, + 1,12,1,370,9,1,1,1,1,1,1,1,1,1,1,1,3,1,377,8,1,1,2,1,2,1,3,1,3,1,3,5,3, + 384,8,3,10,3,12,3,387,9,3,1,3,1,3,1,3,1,4,5,4,393,8,4,10,4,12,4,396,9, + 4,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5, 1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1, - 5,1,5,1,5,1,5,1,5,3,5,440,8,5,1,6,1,6,1,6,1,7,1,7,1,7,1,8,1,8,1,8,1,8, - 1,9,1,9,1,9,1,10,1,10,1,10,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,12,1,12, - 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,481,8,13,1,14,1,14,1,15,1,15,1,15,5,15,488,8,15,10,15,12,15,491,9, - 15,1,15,1,15,1,16,1,16,1,17,1,17,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1, - 18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,3, - 18,520,8,18,1,19,1,19,3,19,524,8,19,1,20,1,20,1,20,1,20,1,20,1,20,1,20, - 1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,3,20,542,8,20,1,21,1,21,1, - 21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1, - 21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,3,21,569,8,21,1,22,1,22,1,22, - 1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22, - 1,22,1,22,1,22,1,22,3,22,592,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,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,628, - 8,23,1,24,1,24,1,25,1,25,1,25,1,25,1,25,1,25,3,25,638,8,25,1,26,1,26,1, - 26,1,27,1,27,5,27,645,8,27,10,27,12,27,648,9,27,1,28,1,28,1,28,1,28,1, - 28,1,28,1,28,5,28,657,8,28,10,28,12,28,660,9,28,1,29,1,29,1,30,1,30,3, - 30,666,8,30,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,3,31,677,8,31, - 1,32,1,32,1,32,1,32,1,32,1,32,3,32,685,8,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,34,1,34,1,34,1,34,5, - 34,706,8,34,10,34,12,34,709,9,34,1,35,1,35,1,35,1,35,1,35,1,35,1,36,1, - 36,1,36,1,37,1,37,5,37,722,8,37,10,37,12,37,725,9,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,38,1,38,1,38,1,38,1,38,1, + 5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,448, + 8,5,1,6,1,6,1,6,1,7,1,7,1,7,1,8,1,8,1,8,1,8,1,9,1,9,1,9,1,10,1,10,1,10, + 1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,12,1,12,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,489,8,13,1,14,1,14,1, + 15,1,15,1,15,5,15,496,8,15,10,15,12,15,499,9,15,1,15,1,15,1,16,1,16,1, + 17,1,17,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1, + 18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,3,18,528,8,18,1,19,1,19,3,19, + 532,8,19,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1, + 20,1,20,1,20,1,20,3,20,550,8,20,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21, + 1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21, + 1,21,1,21,1,21,3,21,577,8,21,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1, + 22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,3,22,600, + 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,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,636,8,23,1,24,1,24,1,25,1,25,1, + 25,1,25,1,25,1,25,3,25,646,8,25,1,26,1,26,1,26,1,27,1,27,5,27,653,8,27, + 10,27,12,27,656,9,27,1,28,1,28,1,28,1,28,1,28,1,28,1,28,5,28,665,8,28, + 10,28,12,28,668,9,28,1,29,1,29,1,30,1,30,3,30,674,8,30,1,31,1,31,1,31, + 1,31,1,31,1,31,1,31,1,31,1,31,3,31,685,8,31,1,32,1,32,1,32,1,32,1,32,1, + 32,3,32,693,8,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,34,1,34,1,34,1,34,5,34,714,8,34,10,34,12,34,717, + 9,34,1,35,1,35,1,35,1,35,1,35,1,35,1,36,1,36,1,36,1,37,1,37,5,37,730,8, + 37,10,37,12,37,733,9,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,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1, 38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1, - 38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,3,38,769,8,38,1,39, - 1,39,1,39,3,39,774,8,39,1,40,1,40,1,40,3,40,779,8,40,1,41,5,41,782,8,41, - 10,41,12,41,785,9,41,1,42,1,42,1,42,5,42,790,8,42,10,42,12,42,793,9,42, - 1,42,1,42,1,43,1,43,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, - 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, - 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, - 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, - 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, - 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, - 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, - 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,3,44,902,8,44,1,45,1,45,5, - 45,906,8,45,10,45,12,45,909,9,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1, - 45,1,45,1,45,1,45,5,45,922,8,45,10,45,12,45,925,9,45,1,45,1,45,1,45,3, - 45,930,8,45,1,46,1,46,1,47,1,47,3,47,936,8,47,1,48,1,48,1,49,5,49,941, - 8,49,10,49,12,49,944,9,49,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50, + 38,1,38,1,38,1,38,1,38,3,38,777,8,38,1,39,1,39,1,39,3,39,782,8,39,1,40, + 1,40,1,40,3,40,787,8,40,1,41,5,41,790,8,41,10,41,12,41,793,9,41,1,42,1, + 42,1,42,5,42,798,8,42,10,42,12,42,801,9,42,1,42,1,42,1,43,1,43,1,44,1, + 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, + 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, + 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, + 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, + 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, + 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, + 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, + 44,1,44,1,44,1,44,3,44,910,8,44,1,45,1,45,5,45,914,8,45,10,45,12,45,917, + 9,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,5,45,930,8, + 45,10,45,12,45,933,9,45,1,45,1,45,1,45,3,45,938,8,45,1,46,1,46,1,47,1, + 47,3,47,944,8,47,1,48,1,48,1,49,5,49,949,8,49,10,49,12,49,952,9,49,1,50, 1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50, - 1,50,1,50,3,50,971,8,50,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1, + 1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,3,50,979,8,50,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,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,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,3,51,1049,8,51,3, - 51,1051,8,51,1,52,1,52,1,52,1,52,1,52,1,53,1,53,1,53,1,53,1,53,1,53,1, - 53,3,53,1065,8,53,1,53,1,53,5,53,1069,8,53,10,53,12,53,1072,9,53,1,53, - 1,53,1,53,1,53,1,53,1,53,3,53,1080,8,53,3,53,1082,8,53,1,54,1,54,1,54, - 1,54,1,54,5,54,1089,8,54,10,54,12,54,1092,9,54,1,54,1,54,1,54,1,54,1,55, - 1,55,1,55,1,55,1,55,5,55,1103,8,55,10,55,12,55,1106,9,55,1,55,1,55,1,55, - 1,55,1,56,1,56,1,56,1,56,1,56,5,56,1117,8,56,10,56,12,56,1120,9,56,1,56, - 1,56,1,56,1,56,1,56,3,56,1127,8,56,1,57,1,57,1,57,1,57,1,57,1,57,3,57, - 1135,8,57,1,57,1,57,3,57,1139,8,57,1,58,1,58,1,58,1,58,1,58,1,58,1,58, - 1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58, + 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,1057,8,51,3,51,1059,8,51,1,52,1,52,1,52,1, + 52,1,52,1,53,1,53,1,53,1,53,1,53,1,53,1,53,3,53,1073,8,53,1,53,1,53,5, + 53,1077,8,53,10,53,12,53,1080,9,53,1,53,1,53,1,53,1,53,1,53,1,53,3,53, + 1088,8,53,3,53,1090,8,53,1,54,1,54,1,54,1,54,1,54,5,54,1097,8,54,10,54, + 12,54,1100,9,54,1,54,1,54,1,54,1,54,1,55,1,55,1,55,1,55,1,55,5,55,1111, + 8,55,10,55,12,55,1114,9,55,1,55,1,55,1,55,1,55,1,56,1,56,1,56,1,56,1,56, + 5,56,1125,8,56,10,56,12,56,1128,9,56,1,56,1,56,1,56,1,56,1,56,3,56,1135, + 8,56,1,57,1,57,1,57,1,57,1,57,1,57,3,57,1143,8,57,1,57,1,57,3,57,1147, + 8,57,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58, 1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58, - 1,58,1,58,3,58,1178,8,58,1,59,1,59,1,59,1,59,5,59,1184,8,59,10,59,12,59, - 1187,9,59,1,59,1,59,1,59,1,60,5,60,1193,8,60,10,60,12,60,1196,9,60,1,61, - 1,61,1,61,1,61,1,61,3,61,1203,8,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,3,62,1222,8,62,1,63, - 1,63,1,63,1,63,1,63,1,63,5,63,1230,8,63,10,63,12,63,1233,9,63,3,63,1235, - 8,63,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,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,1259,8,64,1,65,1,65, + 1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,3,58,1186,8,58,1,59, + 1,59,1,59,1,59,5,59,1192,8,59,10,59,12,59,1195,9,59,1,59,1,59,1,59,1,60, + 5,60,1201,8,60,10,60,12,60,1204,9,60,1,61,1,61,1,61,1,61,1,61,3,61,1211, + 8,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,3,62,1230,8,62,1,63,1,63,1,63,1,63,1,63,1,63,5,63, + 1238,8,63,10,63,12,63,1241,9,63,3,63,1243,8,63,1,64,1,64,1,64,1,64,1,64, + 1,64,1,64,1,64,1,64,1,64,1,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,1267,8,64,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, @@ -17667,1142 +17931,1160 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, - 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, - 1,65,1,65,1,65,3,65,1406,8,65,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66, - 3,66,1416,8,66,1,67,1,67,1,67,1,67,1,67,5,67,1423,8,67,10,67,12,67,1426, - 9,67,3,67,1428,8,67,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, + 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,3,65,1414,8,65, + 1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,3,66,1424,8,66,1,67,1,67,1,67, + 1,67,1,67,5,67,1431,8,67,10,67,12,67,1434,9,67,3,67,1436,8,67,1,68,1,68, 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, - 3,68,1510,8,68,1,69,1,69,1,69,1,69,1,69,5,69,1517,8,69,10,69,12,69,1520, - 9,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,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,3,68,1518,8,68,1,69,1,69,1,69, + 1,69,1,69,5,69,1525,8,69,10,69,12,69,1528,9,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,1,70,1,70,1,70,1,70, - 1,70,1,70,3,70,1551,8,70,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, + 1,70,1,70,1,70,1,70,1,70,1,70,1,70,1,70,1,70,1,70,3,70,1559,8,70,1,71, + 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, - 1,71,1,71,1,71,1,71,1,71,1,71,1,71,3,71,1611,8,71,1,72,1,72,1,72,1,72, + 1,71,3,71,1619,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,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,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,1651,8,72,1,73,1,73,1,73,1,73,1,73, - 1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,3,73,1667,8,73,1,74,1,74, - 1,74,1,74,1,75,1,75,1,75,1,75,3,75,1677,8,75,1,75,1,75,1,76,1,76,1,76, + 3,72,1659,8,72,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73, + 1,73,1,73,1,73,3,73,1675,8,73,1,74,1,74,1,74,1,74,1,75,1,75,1,75,1,75, + 3,75,1685,8,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,1,76,1,76,3,76,1704,8,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,1728,8,76,1,77,1,77,1,77,1,77,5,77,1734,8,77,10,77, - 12,77,1737,9,77,1,77,3,77,1740,8,77,1,78,1,78,1,78,1,78,1,78,1,78,1,78, - 1,78,1,78,1,78,1,78,1,78,1,78,3,78,1755,8,78,1,79,1,79,1,79,5,79,1760, - 8,79,10,79,12,79,1763,9,79,1,79,1,79,1,80,1,80,1,80,1,80,1,81,1,81,1,82, - 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, + 3,76,1712,8,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,1736,8,76, + 1,77,1,77,1,77,1,77,5,77,1742,8,77,10,77,12,77,1745,9,77,1,77,3,77,1748, + 8,77,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78, + 3,78,1763,8,78,1,79,1,79,1,79,5,79,1768,8,79,10,79,12,79,1771,9,79,1,79, + 1,79,1,80,1,80,1,80,1,80,1,81,1,81,1,82,1,82,1,82,1,82,1,82,1,82,1,82, 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, - 1,82,1,82,1,82,1,82,1,82,3,82,1807,8,82,1,83,1,83,1,84,1,84,1,84,1,84, - 1,84,1,84,3,84,1817,8,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84, - 1,84,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1835,8,84,1,84,1,84,1,84,1,84, - 1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1853, - 8,84,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85, - 1,85,1,85,1,85,1,85,3,85,1872,8,85,1,86,1,86,1,86,1,86,1,86,1,86,1,86, - 1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,3,86,1893, - 8,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,88, - 1,88,1,88,1,88,1,88,3,88,1912,8,88,1,89,1,89,1,89,1,89,1,89,1,89,1,89, - 1,89,1,89,1,89,1,89,1,89,1,89,3,89,1927,8,89,1,90,1,90,1,90,5,90,1932, - 8,90,10,90,12,90,1935,9,90,1,90,1,90,1,91,1,91,1,91,1,91,1,91,3,91,1944, - 8,91,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,3,92,1957, - 8,92,1,93,5,93,1960,8,93,10,93,12,93,1963,9,93,1,94,1,94,3,94,1967,8,94, - 1,94,1,94,1,95,1,95,1,95,5,95,1974,8,95,10,95,12,95,1977,9,95,1,95,1,95, - 1,96,1,96,1,96,1,96,1,97,3,97,1986,8,97,1,97,1,97,1,98,1,98,1,98,1,98, - 1,98,1,98,1,98,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, + 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,3,82, + 1815,8,82,1,83,1,83,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1825,8,84,1,84, + 1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84, + 1,84,3,84,1843,8,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84, + 1,84,1,84,1,84,1,84,1,84,1,84,3,84,1861,8,84,1,85,1,85,1,85,1,85,1,85, + 1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,3,85,1880, + 8,85,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86, + 1,86,1,86,1,86,1,86,1,86,1,86,3,86,1901,8,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,88,1,88,1,88,1,88,1,88,3,88,1920, + 8,88,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89, + 3,89,1935,8,89,1,90,1,90,1,90,5,90,1940,8,90,10,90,12,90,1943,9,90,1,90, + 1,90,1,91,1,91,1,91,1,91,1,91,3,91,1952,8,91,1,92,1,92,1,92,1,92,1,92, + 1,92,1,92,1,92,1,92,1,92,1,92,3,92,1965,8,92,1,93,5,93,1968,8,93,10,93, + 12,93,1971,9,93,1,94,1,94,3,94,1975,8,94,1,94,1,94,1,95,1,95,1,95,5,95, + 1982,8,95,10,95,12,95,1985,9,95,1,95,1,95,1,96,1,96,1,96,1,96,1,97,3,97, + 1994,8,97,1,97,1,97,1,98,1,98,1,98,1,98,1,98,1,98,1,98,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, - 1,99,1,99,1,99,1,99,1,99,1,99,5,99,2070,8,99,10,99,12,99,2073,9,99,1,99, - 1,99,1,99,1,99,5,99,2079,8,99,10,99,12,99,2082,9,99,1,99,1,99,1,99,1,99, - 1,99,1,99,1,99,1,99,5,99,2092,8,99,10,99,12,99,2095,9,99,1,99,1,99,1,99, - 1,99,1,99,1,99,5,99,2103,8,99,10,99,12,99,2106,9,99,1,99,1,99,1,99,1,99, - 1,99,3,99,2113,8,99,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,5, - 100,2123,8,100,10,100,12,100,2126,9,100,1,100,1,100,1,100,1,100,1,100, + 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, + 5,99,2078,8,99,10,99,12,99,2081,9,99,1,99,1,99,1,99,1,99,5,99,2087,8,99, + 10,99,12,99,2090,9,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,2100, + 8,99,10,99,12,99,2103,9,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,2111,8,99, + 10,99,12,99,2114,9,99,1,99,1,99,1,99,1,99,1,99,3,99,2121,8,99,1,100,1, + 100,1,100,1,100,1,100,1,100,1,100,1,100,5,100,2131,8,100,10,100,12,100, + 2134,9,100,1,100,1,100,1,100,1,100,1,100,1,101,1,101,1,101,1,101,1,101, 1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101, - 1,101,1,101,1,101,1,101,1,101,1,101,1,101,3,101,2152,8,101,1,102,1,102, - 1,102,1,102,1,102,3,102,2159,8,102,1,103,1,103,1,103,3,103,2164,8,103, - 1,104,1,104,1,104,1,104,1,104,3,104,2171,8,104,1,105,1,105,5,105,2175, - 8,105,10,105,12,105,2178,9,105,1,105,1,105,1,105,1,105,1,105,5,105,2185, - 8,105,10,105,12,105,2188,9,105,1,105,3,105,2191,8,105,1,106,1,106,1,107, - 5,107,2196,8,107,10,107,12,107,2199,9,107,1,108,1,108,1,108,1,108,1,108, - 1,108,1,108,1,108,1,108,1,108,1,108,1,108,3,108,2213,8,108,1,109,1,109, - 5,109,2217,8,109,10,109,12,109,2220,9,109,1,109,1,109,1,109,1,109,1,109, - 1,109,1,110,1,110,1,111,5,111,2231,8,111,10,111,12,111,2234,9,111,1,112, - 1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,3,112,2246,8,112, - 1,113,1,113,1,113,1,113,1,113,1,113,1,113,3,113,2255,8,113,1,114,1,114, - 1,114,1,114,1,114,1,114,1,114,4,114,2264,8,114,11,114,12,114,2265,1,114, - 1,114,3,114,2270,8,114,1,115,1,115,1,115,5,115,2275,8,115,10,115,12,115, - 2278,9,115,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116, - 1,116,1,116,1,116,1,116,1,116,1,116,1,116,3,116,2297,8,116,1,117,1,117, - 1,117,5,117,2302,8,117,10,117,12,117,2305,9,117,1,117,1,117,1,117,1,117, - 1,117,1,117,1,117,1,117,5,117,2315,8,117,10,117,12,117,2318,9,117,1,118, + 1,101,1,101,3,101,2160,8,101,1,102,1,102,1,102,1,102,1,102,3,102,2167, + 8,102,1,103,1,103,1,103,3,103,2172,8,103,1,104,1,104,1,104,1,104,1,104, + 3,104,2179,8,104,1,105,1,105,5,105,2183,8,105,10,105,12,105,2186,9,105, + 1,105,1,105,1,105,1,105,1,105,5,105,2193,8,105,10,105,12,105,2196,9,105, + 1,105,3,105,2199,8,105,1,106,1,106,1,107,5,107,2204,8,107,10,107,12,107, + 2207,9,107,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108, + 1,108,1,108,3,108,2221,8,108,1,109,1,109,5,109,2225,8,109,10,109,12,109, + 2228,9,109,1,109,1,109,1,109,1,109,1,109,1,109,1,110,1,110,1,111,5,111, + 2239,8,111,10,111,12,111,2242,9,111,1,112,1,112,1,112,1,112,1,112,1,112, + 1,112,1,112,1,112,1,112,3,112,2254,8,112,1,113,1,113,1,113,1,113,1,113, + 1,113,1,113,3,113,2263,8,113,1,114,1,114,1,114,1,114,1,114,1,114,1,114, + 4,114,2272,8,114,11,114,12,114,2273,1,114,1,114,3,114,2278,8,114,1,115, + 1,115,1,115,5,115,2283,8,115,10,115,12,115,2286,9,115,1,116,1,116,1,116, + 1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116, + 1,116,1,116,3,116,2305,8,116,1,117,1,117,1,117,5,117,2310,8,117,10,117, + 12,117,2313,9,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,5,117, + 2323,8,117,10,117,12,117,2326,9,117,1,118,1,118,1,118,1,118,1,118,1,118, 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, - 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,3,118,2343, - 8,118,1,119,1,119,1,119,1,119,1,119,3,119,2350,8,119,3,119,2352,8,119, - 1,119,5,119,2355,8,119,10,119,12,119,2358,9,119,1,119,1,119,1,119,3,119, - 2363,8,119,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, + 1,118,1,118,1,118,1,118,1,118,3,118,2351,8,118,1,119,1,119,1,119,1,119, + 1,119,3,119,2358,8,119,3,119,2360,8,119,1,119,5,119,2363,8,119,10,119, + 12,119,2366,9,119,1,119,1,119,1,119,3,119,2371,8,119,1,120,1,120,1,120, 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, - 1,120,1,120,1,120,1,120,1,120,3,120,2392,8,120,1,121,1,121,1,121,1,121, - 1,121,1,121,1,121,3,121,2401,8,121,1,122,1,122,1,122,1,122,1,122,1,122, - 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, - 1,122,1,122,1,122,3,122,2424,8,122,1,123,5,123,2427,8,123,10,123,12,123, - 2430,9,123,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, - 1,124,1,124,1,124,1,124,1,124,1,124,1,124,3,124,2449,8,124,1,125,1,125, - 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, - 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, - 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, - 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,5,125, - 2500,8,125,10,125,12,125,2503,9,125,1,125,1,125,1,125,1,125,5,125,2509, - 8,125,10,125,12,125,2512,9,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, - 1,125,5,125,2522,8,125,10,125,12,125,2525,9,125,1,125,1,125,1,125,1,125, - 1,125,1,125,5,125,2533,8,125,10,125,12,125,2536,9,125,1,125,1,125,1,125, - 1,125,1,125,1,125,5,125,2544,8,125,10,125,12,125,2547,9,125,3,125,2549, - 8,125,1,126,1,126,1,126,1,126,1,127,1,127,3,127,2557,8,127,1,128,1,128, - 1,128,1,128,1,129,1,129,1,129,1,130,4,130,2567,8,130,11,130,12,130,2568, - 1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131, - 3,131,2583,8,131,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132, - 1,132,1,132,1,132,3,132,2597,8,132,1,133,1,133,1,133,1,133,1,133,1,133, - 3,133,2605,8,133,1,134,1,134,1,134,1,135,1,135,1,136,1,136,1,137,1,137, - 1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,3,137,2625,8,137, - 1,138,1,138,1,138,1,139,1,139,1,139,1,139,1,139,1,139,1,139,3,139,2637, - 8,139,1,140,1,140,1,140,3,140,2642,8,140,1,141,1,141,1,141,1,141,1,141, - 4,141,2649,8,141,11,141,12,141,2650,3,141,2653,8,141,1,142,1,142,1,142, - 5,142,2658,8,142,10,142,12,142,2661,9,142,1,142,1,142,1,143,1,143,1,143, - 1,143,1,143,3,143,2670,8,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,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,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, - 2738,8,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,145,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,145,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,145,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,145,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,145,1,145,1,145,1,145,1,145,1,145, - 1,145,1,145,1,145,1,145,1,145,3,145,2815,8,145,1,146,1,146,1,146,5,146, - 2820,8,146,10,146,12,146,2823,9,146,1,147,1,147,1,148,1,148,1,148,3,148, - 2830,8,148,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, - 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, - 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, - 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, - 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, - 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, - 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, + 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, + 3,120,2400,8,120,1,121,1,121,1,121,1,121,1,121,1,121,1,121,3,121,2409, + 8,121,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, + 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,3,122,2432, + 8,122,1,123,5,123,2435,8,123,10,123,12,123,2438,9,123,1,124,1,124,1,124, + 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, + 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, + 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,3,124,2477, + 8,124,1,125,1,125,3,125,2481,8,125,1,125,1,125,1,126,1,126,1,126,1,126, + 1,126,1,126,3,126,2491,8,126,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,128,1,128,1,128,1,128,1,128,1,128, + 1,128,3,128,2513,8,128,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129, + 5,129,2523,8,129,10,129,12,129,2526,9,129,1,129,1,129,1,129,1,129,1,129, + 1,129,5,129,2534,8,129,10,129,12,129,2537,9,129,1,129,1,129,1,129,1,129, + 1,129,1,129,1,129,1,129,1,129,1,129,5,129,2549,8,129,10,129,12,129,2552, + 9,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,5,129,2562,8,129, + 10,129,12,129,2565,9,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129, + 5,129,2575,8,129,10,129,12,129,2578,9,129,3,129,2580,8,129,1,130,1,130, + 1,130,1,130,1,131,1,131,3,131,2588,8,131,1,132,1,132,1,132,1,132,1,133, + 1,133,1,133,1,134,1,134,1,134,4,134,2600,8,134,11,134,12,134,2601,1,135, + 1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135, + 1,135,1,135,1,135,3,135,2620,8,135,1,136,1,136,1,136,1,136,1,136,1,136, + 1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,3,136,2638, + 8,136,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137, + 1,137,3,137,2652,8,137,1,138,1,138,1,138,1,139,1,139,1,140,1,140,1,141, + 1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141, + 1,141,1,141,3,141,2676,8,141,1,142,1,142,1,142,1,143,1,143,1,143,1,143, + 1,143,1,143,1,143,3,143,2688,8,143,1,144,1,144,1,144,3,144,2693,8,144, + 1,145,1,145,1,145,1,145,1,145,4,145,2700,8,145,11,145,12,145,2701,3,145, + 2704,8,145,1,146,1,146,1,146,5,146,2709,8,146,10,146,12,146,2712,9,146, + 1,146,1,146,1,147,1,147,1,147,1,147,1,147,3,147,2721,8,147,1,148,1,148, + 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, + 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, + 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, + 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, + 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, + 1,148,1,148,1,148,1,148,3,148,2789,8,148,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, - 1,149,1,149,1,149,1,149,1,149,1,149,3,149,2980,8,149,1,150,1,150,5,150, - 2984,8,150,10,150,12,150,2987,9,150,1,151,1,151,5,151,2991,8,151,10,151, - 12,151,2994,9,151,1,152,5,152,2997,8,152,10,152,12,152,3000,9,152,1,153, - 5,153,3003,8,153,10,153,12,153,3006,9,153,1,154,5,154,3009,8,154,10,154, - 12,154,3012,9,154,1,155,5,155,3015,8,155,10,155,12,155,3018,9,155,1,156, - 5,156,3021,8,156,10,156,12,156,3024,9,156,1,157,5,157,3027,8,157,10,157, - 12,157,3030,9,157,1,158,5,158,3033,8,158,10,158,12,158,3036,9,158,1,159, - 1,159,1,159,1,159,3,159,3042,8,159,1,160,5,160,3045,8,160,10,160,12,160, - 3048,9,160,1,161,1,161,1,161,3,161,3053,8,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,162,1,162,1,162,1,162, - 1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162,3,162,3080,8,162, - 1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163, - 3,163,3094,8,163,1,164,5,164,3097,8,164,10,164,12,164,3100,9,164,1,165, - 1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165,1,165, - 1,165,3,165,3116,8,165,1,166,1,166,1,166,5,166,3121,8,166,10,166,12,166, - 3124,9,166,1,166,1,166,1,167,1,167,5,167,3130,8,167,10,167,12,167,3133, - 9,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,168,1,168,1,168,1,168,3,168,3152,8,168,1,169,5,169,3155, - 8,169,10,169,12,169,3158,9,169,1,170,1,170,1,170,1,170,1,170,1,170,1,170, - 1,170,1,170,1,170,1,170,1,170,1,170,3,170,3173,8,170,1,171,1,171,5,171, - 3177,8,171,10,171,12,171,3180,9,171,1,171,1,171,1,171,5,171,3185,8,171, - 10,171,12,171,3188,9,171,1,171,1,171,1,171,1,171,3,171,3194,8,171,1,172, - 1,172,1,173,5,173,3199,8,173,10,173,12,173,3202,9,173,1,174,1,174,1,174, - 1,174,1,174,1,174,1,174,1,174,1,174,1,174,3,174,3214,8,174,1,174,0,1,68, - 175,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,0,15,6,0,1,15,199,199,243,243,247,247,264,264,289,289,5,0,16,16,199, - 199,243,243,264,264,288,289,1,0,263,264,1,0,173,174,1,0,37,38,1,0,73,74, - 3,0,2,2,61,61,77,83,2,0,229,229,260,261,1,0,95,96,1,0,97,111,1,0,68,69, - 2,0,173,173,289,290,2,0,179,179,264,264,1,0,167,168,1,0,51,52,3682,0,350, - 1,0,0,0,2,368,1,0,0,0,4,370,1,0,0,0,6,377,1,0,0,0,8,386,1,0,0,0,10,439, - 1,0,0,0,12,441,1,0,0,0,14,444,1,0,0,0,16,447,1,0,0,0,18,451,1,0,0,0,20, - 454,1,0,0,0,22,457,1,0,0,0,24,464,1,0,0,0,26,480,1,0,0,0,28,482,1,0,0, - 0,30,484,1,0,0,0,32,494,1,0,0,0,34,496,1,0,0,0,36,519,1,0,0,0,38,523,1, - 0,0,0,40,541,1,0,0,0,42,568,1,0,0,0,44,591,1,0,0,0,46,627,1,0,0,0,48,629, - 1,0,0,0,50,637,1,0,0,0,52,639,1,0,0,0,54,646,1,0,0,0,56,658,1,0,0,0,58, - 661,1,0,0,0,60,663,1,0,0,0,62,676,1,0,0,0,64,684,1,0,0,0,66,686,1,0,0, - 0,68,694,1,0,0,0,70,710,1,0,0,0,72,716,1,0,0,0,74,719,1,0,0,0,76,768,1, - 0,0,0,78,773,1,0,0,0,80,778,1,0,0,0,82,783,1,0,0,0,84,791,1,0,0,0,86,796, - 1,0,0,0,88,901,1,0,0,0,90,929,1,0,0,0,92,931,1,0,0,0,94,935,1,0,0,0,96, - 937,1,0,0,0,98,942,1,0,0,0,100,970,1,0,0,0,102,1050,1,0,0,0,104,1052,1, - 0,0,0,106,1081,1,0,0,0,108,1083,1,0,0,0,110,1097,1,0,0,0,112,1126,1,0, - 0,0,114,1138,1,0,0,0,116,1177,1,0,0,0,118,1185,1,0,0,0,120,1194,1,0,0, - 0,122,1202,1,0,0,0,124,1221,1,0,0,0,126,1234,1,0,0,0,128,1258,1,0,0,0, - 130,1405,1,0,0,0,132,1415,1,0,0,0,134,1427,1,0,0,0,136,1509,1,0,0,0,138, - 1511,1,0,0,0,140,1550,1,0,0,0,142,1610,1,0,0,0,144,1650,1,0,0,0,146,1666, - 1,0,0,0,148,1668,1,0,0,0,150,1672,1,0,0,0,152,1727,1,0,0,0,154,1739,1, - 0,0,0,156,1754,1,0,0,0,158,1761,1,0,0,0,160,1766,1,0,0,0,162,1770,1,0, - 0,0,164,1806,1,0,0,0,166,1808,1,0,0,0,168,1852,1,0,0,0,170,1871,1,0,0, - 0,172,1892,1,0,0,0,174,1894,1,0,0,0,176,1911,1,0,0,0,178,1926,1,0,0,0, - 180,1933,1,0,0,0,182,1943,1,0,0,0,184,1956,1,0,0,0,186,1961,1,0,0,0,188, - 1964,1,0,0,0,190,1975,1,0,0,0,192,1980,1,0,0,0,194,1985,1,0,0,0,196,1989, - 1,0,0,0,198,2112,1,0,0,0,200,2114,1,0,0,0,202,2151,1,0,0,0,204,2158,1, - 0,0,0,206,2163,1,0,0,0,208,2170,1,0,0,0,210,2190,1,0,0,0,212,2192,1,0, - 0,0,214,2197,1,0,0,0,216,2212,1,0,0,0,218,2214,1,0,0,0,220,2227,1,0,0, - 0,222,2232,1,0,0,0,224,2245,1,0,0,0,226,2254,1,0,0,0,228,2269,1,0,0,0, - 230,2276,1,0,0,0,232,2296,1,0,0,0,234,2298,1,0,0,0,236,2342,1,0,0,0,238, - 2362,1,0,0,0,240,2391,1,0,0,0,242,2400,1,0,0,0,244,2423,1,0,0,0,246,2428, - 1,0,0,0,248,2448,1,0,0,0,250,2548,1,0,0,0,252,2550,1,0,0,0,254,2556,1, - 0,0,0,256,2558,1,0,0,0,258,2562,1,0,0,0,260,2566,1,0,0,0,262,2582,1,0, - 0,0,264,2596,1,0,0,0,266,2604,1,0,0,0,268,2606,1,0,0,0,270,2609,1,0,0, - 0,272,2611,1,0,0,0,274,2624,1,0,0,0,276,2626,1,0,0,0,278,2636,1,0,0,0, - 280,2641,1,0,0,0,282,2652,1,0,0,0,284,2659,1,0,0,0,286,2669,1,0,0,0,288, - 2737,1,0,0,0,290,2814,1,0,0,0,292,2821,1,0,0,0,294,2824,1,0,0,0,296,2829, - 1,0,0,0,298,2979,1,0,0,0,300,2985,1,0,0,0,302,2992,1,0,0,0,304,2998,1, - 0,0,0,306,3004,1,0,0,0,308,3010,1,0,0,0,310,3016,1,0,0,0,312,3022,1,0, - 0,0,314,3028,1,0,0,0,316,3034,1,0,0,0,318,3041,1,0,0,0,320,3046,1,0,0, - 0,322,3052,1,0,0,0,324,3079,1,0,0,0,326,3093,1,0,0,0,328,3098,1,0,0,0, - 330,3115,1,0,0,0,332,3117,1,0,0,0,334,3127,1,0,0,0,336,3151,1,0,0,0,338, - 3156,1,0,0,0,340,3172,1,0,0,0,342,3193,1,0,0,0,344,3195,1,0,0,0,346,3200, - 1,0,0,0,348,3213,1,0,0,0,350,351,7,0,0,0,351,1,1,0,0,0,352,353,5,288,0, - 0,353,369,6,1,-1,0,354,355,3,4,2,0,355,356,6,1,-1,0,356,357,5,265,0,0, - 357,359,1,0,0,0,358,354,1,0,0,0,359,362,1,0,0,0,360,358,1,0,0,0,360,361, - 1,0,0,0,361,363,1,0,0,0,362,360,1,0,0,0,363,364,3,4,2,0,364,365,6,1,-1, - 0,365,369,1,0,0,0,366,367,5,264,0,0,367,369,6,1,-1,0,368,352,1,0,0,0,368, - 360,1,0,0,0,368,366,1,0,0,0,369,3,1,0,0,0,370,371,7,1,0,0,371,5,1,0,0, - 0,372,373,5,263,0,0,373,374,6,3,-1,0,374,376,5,266,0,0,375,372,1,0,0,0, - 376,379,1,0,0,0,377,375,1,0,0,0,377,378,1,0,0,0,378,380,1,0,0,0,379,377, - 1,0,0,0,380,381,5,263,0,0,381,382,6,3,-1,0,382,7,1,0,0,0,383,385,3,10, - 5,0,384,383,1,0,0,0,385,388,1,0,0,0,386,384,1,0,0,0,386,387,1,0,0,0,387, - 9,1,0,0,0,388,386,1,0,0,0,389,390,3,74,37,0,390,391,5,17,0,0,391,392,3, - 82,41,0,392,393,5,18,0,0,393,440,1,0,0,0,394,395,3,72,36,0,395,396,5,17, - 0,0,396,397,3,8,4,0,397,398,5,18,0,0,398,440,1,0,0,0,399,400,3,234,117, - 0,400,401,5,17,0,0,401,402,3,246,123,0,402,403,5,18,0,0,403,440,1,0,0, - 0,404,440,3,200,100,0,405,440,3,276,138,0,406,440,3,70,35,0,407,440,3, - 66,33,0,408,440,3,88,44,0,409,440,3,90,45,0,410,440,3,22,11,0,411,412, - 3,326,163,0,412,413,5,17,0,0,413,414,3,328,164,0,414,415,5,18,0,0,415, - 440,1,0,0,0,416,417,3,332,166,0,417,418,5,17,0,0,418,419,3,338,169,0,419, - 420,5,18,0,0,420,440,1,0,0,0,421,422,3,342,171,0,422,423,5,17,0,0,423, - 424,3,346,173,0,424,425,5,18,0,0,425,440,1,0,0,0,426,440,3,64,32,0,427, - 440,3,152,76,0,428,440,3,322,161,0,429,440,3,12,6,0,430,440,3,14,7,0,431, - 440,3,16,8,0,432,440,3,18,9,0,433,440,3,20,10,0,434,440,3,26,13,0,435, - 440,3,42,21,0,436,440,3,40,20,0,437,440,3,30,15,0,438,440,3,24,12,0,439, - 389,1,0,0,0,439,394,1,0,0,0,439,399,1,0,0,0,439,404,1,0,0,0,439,405,1, - 0,0,0,439,406,1,0,0,0,439,407,1,0,0,0,439,408,1,0,0,0,439,409,1,0,0,0, - 439,410,1,0,0,0,439,411,1,0,0,0,439,416,1,0,0,0,439,421,1,0,0,0,439,426, - 1,0,0,0,439,427,1,0,0,0,439,428,1,0,0,0,439,429,1,0,0,0,439,430,1,0,0, - 0,439,431,1,0,0,0,439,432,1,0,0,0,439,433,1,0,0,0,439,434,1,0,0,0,439, - 435,1,0,0,0,439,436,1,0,0,0,439,437,1,0,0,0,439,438,1,0,0,0,440,11,1,0, - 0,0,441,442,5,19,0,0,442,443,3,32,16,0,443,13,1,0,0,0,444,445,5,20,0,0, - 445,446,3,32,16,0,446,15,1,0,0,0,447,448,5,21,0,0,448,449,5,22,0,0,449, - 450,3,32,16,0,450,17,1,0,0,0,451,452,5,23,0,0,452,453,3,34,17,0,453,19, - 1,0,0,0,454,455,5,24,0,0,455,456,3,34,17,0,456,21,1,0,0,0,457,458,5,25, - 0,0,458,459,3,98,49,0,459,460,3,2,1,0,460,461,5,17,0,0,461,462,3,120,60, - 0,462,463,5,18,0,0,463,23,1,0,0,0,464,465,5,26,0,0,465,25,1,0,0,0,466, - 467,5,27,0,0,467,481,3,28,14,0,468,469,5,27,0,0,469,470,3,28,14,0,470, - 471,5,28,0,0,471,472,3,28,14,0,472,481,1,0,0,0,473,474,5,27,0,0,474,475, - 3,28,14,0,475,476,5,28,0,0,476,477,3,28,14,0,477,478,5,28,0,0,478,479, - 3,28,14,0,479,481,1,0,0,0,480,466,1,0,0,0,480,468,1,0,0,0,480,473,1,0, - 0,0,481,27,1,0,0,0,482,483,7,2,0,0,483,29,1,0,0,0,484,485,5,29,0,0,485, - 489,5,17,0,0,486,488,3,116,58,0,487,486,1,0,0,0,488,491,1,0,0,0,489,487, - 1,0,0,0,489,490,1,0,0,0,490,492,1,0,0,0,491,489,1,0,0,0,492,493,5,18,0, - 0,493,31,1,0,0,0,494,495,5,173,0,0,495,33,1,0,0,0,496,497,7,3,0,0,497, - 35,1,0,0,0,498,499,5,175,0,0,499,520,6,18,-1,0,500,501,3,32,16,0,501,502, - 5,265,0,0,502,503,6,18,-1,0,503,520,1,0,0,0,504,505,3,32,16,0,505,506, - 6,18,-1,0,506,520,1,0,0,0,507,508,5,188,0,0,508,509,5,30,0,0,509,510,3, - 32,16,0,510,511,5,31,0,0,511,512,6,18,-1,0,512,520,1,0,0,0,513,514,5,189, - 0,0,514,515,5,30,0,0,515,516,3,34,17,0,516,517,5,31,0,0,517,518,6,18,-1, - 0,518,520,1,0,0,0,519,498,1,0,0,0,519,500,1,0,0,0,519,504,1,0,0,0,519, - 507,1,0,0,0,519,513,1,0,0,0,520,37,1,0,0,0,521,524,3,32,16,0,522,524,5, - 262,0,0,523,521,1,0,0,0,523,522,1,0,0,0,524,39,1,0,0,0,525,526,5,267,0, - 0,526,542,5,289,0,0,527,528,5,267,0,0,528,529,5,289,0,0,529,542,5,263, - 0,0,530,531,5,268,0,0,531,542,5,289,0,0,532,533,5,269,0,0,533,542,5,289, - 0,0,534,535,5,270,0,0,535,542,5,289,0,0,536,542,5,271,0,0,537,542,5,272, - 0,0,538,539,5,273,0,0,539,542,5,263,0,0,540,542,5,32,0,0,541,525,1,0,0, - 0,541,527,1,0,0,0,541,530,1,0,0,0,541,532,1,0,0,0,541,534,1,0,0,0,541, - 536,1,0,0,0,541,537,1,0,0,0,541,538,1,0,0,0,541,540,1,0,0,0,542,41,1,0, - 0,0,543,544,5,33,0,0,544,545,3,138,69,0,545,546,5,34,0,0,546,547,3,2,1, - 0,547,569,1,0,0,0,548,549,5,33,0,0,549,550,3,116,58,0,550,551,5,34,0,0, - 551,552,3,2,1,0,552,569,1,0,0,0,553,554,5,33,0,0,554,555,3,176,88,0,555, - 556,5,34,0,0,556,557,3,2,1,0,557,569,1,0,0,0,558,559,5,33,0,0,559,560, - 3,44,22,0,560,561,5,34,0,0,561,562,3,2,1,0,562,569,1,0,0,0,563,564,5,33, - 0,0,564,565,3,46,23,0,565,566,5,34,0,0,566,567,3,2,1,0,567,569,1,0,0,0, - 568,543,1,0,0,0,568,548,1,0,0,0,568,553,1,0,0,0,568,558,1,0,0,0,568,563, - 1,0,0,0,569,43,1,0,0,0,570,571,5,35,0,0,571,592,3,48,24,0,572,573,5,35, - 0,0,573,574,3,48,24,0,574,575,5,36,0,0,575,576,3,6,3,0,576,592,1,0,0,0, - 577,578,5,35,0,0,578,579,3,48,24,0,579,580,5,36,0,0,580,581,5,17,0,0,581, - 582,3,52,26,0,582,583,5,18,0,0,583,592,1,0,0,0,584,585,5,35,0,0,585,586, - 3,48,24,0,586,587,5,36,0,0,587,588,5,30,0,0,588,589,3,292,146,0,589,590, - 5,31,0,0,590,592,1,0,0,0,591,570,1,0,0,0,591,572,1,0,0,0,591,577,1,0,0, - 0,591,584,1,0,0,0,592,45,1,0,0,0,593,594,5,35,0,0,594,595,5,30,0,0,595, - 596,3,50,25,0,596,597,5,31,0,0,597,598,3,48,24,0,598,628,1,0,0,0,599,600, - 5,35,0,0,600,601,5,30,0,0,601,602,3,50,25,0,602,603,5,31,0,0,603,604,3, - 48,24,0,604,605,5,36,0,0,605,606,3,6,3,0,606,628,1,0,0,0,607,608,5,35, - 0,0,608,609,5,30,0,0,609,610,3,50,25,0,610,611,5,31,0,0,611,612,3,48,24, - 0,612,613,5,36,0,0,613,614,5,17,0,0,614,615,3,52,26,0,615,616,5,18,0,0, - 616,628,1,0,0,0,617,618,5,35,0,0,618,619,5,30,0,0,619,620,3,50,25,0,620, - 621,5,31,0,0,621,622,3,48,24,0,622,623,5,36,0,0,623,624,5,30,0,0,624,625, - 3,292,146,0,625,626,5,31,0,0,626,628,1,0,0,0,627,593,1,0,0,0,627,599,1, - 0,0,0,627,607,1,0,0,0,627,617,1,0,0,0,628,47,1,0,0,0,629,630,3,168,84, - 0,630,49,1,0,0,0,631,632,3,124,62,0,632,633,6,25,-1,0,633,638,1,0,0,0, - 634,635,3,176,88,0,635,636,6,25,-1,0,636,638,1,0,0,0,637,631,1,0,0,0,637, - 634,1,0,0,0,638,51,1,0,0,0,639,640,3,54,27,0,640,641,3,56,28,0,641,53, - 1,0,0,0,642,645,3,298,149,0,643,645,3,40,20,0,644,642,1,0,0,0,644,643, - 1,0,0,0,645,648,1,0,0,0,646,644,1,0,0,0,646,647,1,0,0,0,647,55,1,0,0,0, - 648,646,1,0,0,0,649,650,3,58,29,0,650,651,3,60,30,0,651,652,3,2,1,0,652, - 653,5,36,0,0,653,654,3,298,149,0,654,657,1,0,0,0,655,657,3,40,20,0,656, - 649,1,0,0,0,656,655,1,0,0,0,657,660,1,0,0,0,658,656,1,0,0,0,658,659,1, - 0,0,0,659,57,1,0,0,0,660,658,1,0,0,0,661,662,7,4,0,0,662,59,1,0,0,0,663, - 665,3,62,31,0,664,666,5,261,0,0,665,664,1,0,0,0,665,666,1,0,0,0,666,61, - 1,0,0,0,667,677,3,144,72,0,668,677,3,2,1,0,669,677,5,196,0,0,670,677,5, - 197,0,0,671,672,5,202,0,0,672,673,5,39,0,0,673,677,5,264,0,0,674,675,5, - 202,0,0,675,677,3,116,58,0,676,667,1,0,0,0,676,668,1,0,0,0,676,669,1,0, - 0,0,676,670,1,0,0,0,676,671,1,0,0,0,676,674,1,0,0,0,677,63,1,0,0,0,678, - 679,5,198,0,0,679,680,5,40,0,0,680,685,3,2,1,0,681,682,5,198,0,0,682,685, - 3,2,1,0,683,685,5,198,0,0,684,678,1,0,0,0,684,681,1,0,0,0,684,683,1,0, - 0,0,685,65,1,0,0,0,686,687,5,41,0,0,687,688,5,42,0,0,688,689,3,32,16,0, - 689,690,5,43,0,0,690,691,3,68,34,0,691,692,5,44,0,0,692,693,3,0,0,0,693, - 67,1,0,0,0,694,707,6,34,-1,0,695,696,10,5,0,0,696,706,5,186,0,0,697,698, - 10,4,0,0,698,706,5,187,0,0,699,700,10,3,0,0,700,706,5,45,0,0,701,702,10, - 2,0,0,702,706,5,46,0,0,703,704,10,1,0,0,704,706,5,47,0,0,705,695,1,0,0, - 0,705,697,1,0,0,0,705,699,1,0,0,0,705,701,1,0,0,0,705,703,1,0,0,0,706, - 709,1,0,0,0,707,705,1,0,0,0,707,708,1,0,0,0,708,69,1,0,0,0,709,707,1,0, - 0,0,710,711,5,48,0,0,711,712,5,36,0,0,712,713,5,30,0,0,713,714,3,292,146, - 0,714,715,5,31,0,0,715,71,1,0,0,0,716,717,5,49,0,0,717,718,3,2,1,0,718, - 73,1,0,0,0,719,723,5,50,0,0,720,722,3,76,38,0,721,720,1,0,0,0,722,725, - 1,0,0,0,723,721,1,0,0,0,723,724,1,0,0,0,724,726,1,0,0,0,725,723,1,0,0, - 0,726,727,3,2,1,0,727,728,3,182,91,0,728,729,3,78,39,0,729,730,3,80,40, - 0,730,75,1,0,0,0,731,769,5,51,0,0,732,769,5,52,0,0,733,769,5,199,0,0,734, - 769,5,202,0,0,735,769,5,221,0,0,736,769,5,53,0,0,737,769,5,54,0,0,738, - 769,5,55,0,0,739,769,5,56,0,0,740,769,5,244,0,0,741,769,5,15,0,0,742,769, - 5,224,0,0,743,769,5,57,0,0,744,769,5,58,0,0,745,769,5,59,0,0,746,769,5, - 60,0,0,747,769,5,61,0,0,748,749,5,62,0,0,749,769,5,51,0,0,750,751,5,62, - 0,0,751,769,5,52,0,0,752,753,5,62,0,0,753,769,5,63,0,0,754,755,5,62,0, - 0,755,769,5,64,0,0,756,757,5,62,0,0,757,769,5,65,0,0,758,759,5,62,0,0, - 759,769,5,66,0,0,760,769,5,67,0,0,761,769,5,68,0,0,762,769,5,69,0,0,763, - 764,5,70,0,0,764,765,5,30,0,0,765,766,3,32,16,0,766,767,5,31,0,0,767,769, - 1,0,0,0,768,731,1,0,0,0,768,732,1,0,0,0,768,733,1,0,0,0,768,734,1,0,0, - 0,768,735,1,0,0,0,768,736,1,0,0,0,768,737,1,0,0,0,768,738,1,0,0,0,768, - 739,1,0,0,0,768,740,1,0,0,0,768,741,1,0,0,0,768,742,1,0,0,0,768,743,1, - 0,0,0,768,744,1,0,0,0,768,745,1,0,0,0,768,746,1,0,0,0,768,747,1,0,0,0, - 768,748,1,0,0,0,768,750,1,0,0,0,768,752,1,0,0,0,768,754,1,0,0,0,768,756, - 1,0,0,0,768,758,1,0,0,0,768,760,1,0,0,0,768,761,1,0,0,0,768,762,1,0,0, - 0,768,763,1,0,0,0,769,77,1,0,0,0,770,774,1,0,0,0,771,772,5,71,0,0,772, - 774,3,124,62,0,773,770,1,0,0,0,773,771,1,0,0,0,774,79,1,0,0,0,775,779, - 1,0,0,0,776,777,5,72,0,0,777,779,3,84,42,0,778,775,1,0,0,0,778,776,1,0, - 0,0,779,81,1,0,0,0,780,782,3,198,99,0,781,780,1,0,0,0,782,785,1,0,0,0, - 783,781,1,0,0,0,783,784,1,0,0,0,784,83,1,0,0,0,785,783,1,0,0,0,786,787, - 3,124,62,0,787,788,5,28,0,0,788,790,1,0,0,0,789,786,1,0,0,0,790,793,1, - 0,0,0,791,789,1,0,0,0,791,792,1,0,0,0,792,794,1,0,0,0,793,791,1,0,0,0, - 794,795,3,124,62,0,795,85,1,0,0,0,796,797,7,5,0,0,797,87,1,0,0,0,798,799, - 3,86,43,0,799,800,3,32,16,0,800,801,5,264,0,0,801,902,1,0,0,0,802,803, - 3,86,43,0,803,804,3,32,16,0,804,902,1,0,0,0,805,806,3,86,43,0,806,807, - 3,32,16,0,807,808,5,75,0,0,808,809,3,32,16,0,809,810,5,264,0,0,810,902, - 1,0,0,0,811,812,3,86,43,0,812,813,3,32,16,0,813,814,5,75,0,0,814,815,3, - 32,16,0,815,902,1,0,0,0,816,817,3,86,43,0,817,818,3,32,16,0,818,819,5, - 75,0,0,819,820,3,32,16,0,820,821,5,28,0,0,821,822,3,32,16,0,822,823,5, - 264,0,0,823,902,1,0,0,0,824,825,3,86,43,0,825,826,3,32,16,0,826,827,5, - 75,0,0,827,828,3,32,16,0,828,829,5,28,0,0,829,830,3,32,16,0,830,902,1, - 0,0,0,831,832,3,86,43,0,832,833,3,32,16,0,833,834,5,28,0,0,834,835,3,32, - 16,0,835,836,5,75,0,0,836,837,3,32,16,0,837,838,5,264,0,0,838,902,1,0, - 0,0,839,840,3,86,43,0,840,841,3,32,16,0,841,842,5,28,0,0,842,843,3,32, - 16,0,843,844,5,75,0,0,844,845,3,32,16,0,845,902,1,0,0,0,846,847,3,86,43, - 0,847,848,3,32,16,0,848,849,5,28,0,0,849,850,3,32,16,0,850,851,5,75,0, - 0,851,852,3,32,16,0,852,853,5,28,0,0,853,854,3,32,16,0,854,855,5,264,0, - 0,855,902,1,0,0,0,856,857,3,86,43,0,857,858,3,32,16,0,858,859,5,28,0,0, - 859,860,3,32,16,0,860,861,5,75,0,0,861,862,3,32,16,0,862,863,5,28,0,0, - 863,864,3,32,16,0,864,902,1,0,0,0,865,866,3,86,43,0,866,867,3,32,16,0, - 867,868,5,263,0,0,868,902,1,0,0,0,869,870,3,86,43,0,870,871,3,32,16,0, - 871,872,5,75,0,0,872,873,3,32,16,0,873,874,5,263,0,0,874,902,1,0,0,0,875, - 876,3,86,43,0,876,877,3,32,16,0,877,878,5,75,0,0,878,879,3,32,16,0,879, - 880,5,28,0,0,880,881,3,32,16,0,881,882,5,263,0,0,882,902,1,0,0,0,883,884, - 3,86,43,0,884,885,3,32,16,0,885,886,5,28,0,0,886,887,3,32,16,0,887,888, - 5,75,0,0,888,889,3,32,16,0,889,890,5,263,0,0,890,902,1,0,0,0,891,892,3, - 86,43,0,892,893,3,32,16,0,893,894,5,28,0,0,894,895,3,32,16,0,895,896,5, - 75,0,0,896,897,3,32,16,0,897,898,5,28,0,0,898,899,3,32,16,0,899,900,5, - 263,0,0,900,902,1,0,0,0,901,798,1,0,0,0,901,802,1,0,0,0,901,805,1,0,0, - 0,901,811,1,0,0,0,901,816,1,0,0,0,901,824,1,0,0,0,901,831,1,0,0,0,901, - 839,1,0,0,0,901,846,1,0,0,0,901,856,1,0,0,0,901,865,1,0,0,0,901,869,1, - 0,0,0,901,875,1,0,0,0,901,883,1,0,0,0,901,891,1,0,0,0,902,89,1,0,0,0,903, - 907,5,21,0,0,904,906,3,92,46,0,905,904,1,0,0,0,906,909,1,0,0,0,907,905, - 1,0,0,0,907,908,1,0,0,0,908,910,1,0,0,0,909,907,1,0,0,0,910,911,3,2,1, - 0,911,912,3,94,47,0,912,913,5,180,0,0,913,914,5,36,0,0,914,915,5,30,0, - 0,915,916,3,292,146,0,916,917,5,31,0,0,917,918,3,94,47,0,918,930,1,0,0, - 0,919,923,5,21,0,0,920,922,3,92,46,0,921,920,1,0,0,0,922,925,1,0,0,0,923, - 921,1,0,0,0,923,924,1,0,0,0,924,926,1,0,0,0,925,923,1,0,0,0,926,927,3, - 2,1,0,927,928,3,94,47,0,928,930,1,0,0,0,929,903,1,0,0,0,929,919,1,0,0, - 0,930,91,1,0,0,0,931,932,5,76,0,0,932,93,1,0,0,0,933,936,1,0,0,0,934,936, - 5,298,0,0,935,933,1,0,0,0,935,934,1,0,0,0,936,95,1,0,0,0,937,938,7,6,0, - 0,938,97,1,0,0,0,939,941,3,96,48,0,940,939,1,0,0,0,941,944,1,0,0,0,942, - 940,1,0,0,0,942,943,1,0,0,0,943,99,1,0,0,0,944,942,1,0,0,0,945,971,3,102, - 51,0,946,947,5,280,0,0,947,948,3,168,84,0,948,949,6,50,-1,0,949,971,1, - 0,0,0,950,951,5,286,0,0,951,952,3,178,89,0,952,953,6,50,-1,0,953,971,1, - 0,0,0,954,955,5,286,0,0,955,956,3,174,87,0,956,957,6,50,-1,0,957,971,1, - 0,0,0,958,959,5,284,0,0,959,960,3,124,62,0,960,961,6,50,-1,0,961,971,1, - 0,0,0,962,963,5,281,0,0,963,964,3,104,52,0,964,965,6,50,-1,0,965,971,1, - 0,0,0,966,967,5,287,0,0,967,968,3,50,25,0,968,969,6,50,-1,0,969,971,1, - 0,0,0,970,945,1,0,0,0,970,946,1,0,0,0,970,950,1,0,0,0,970,954,1,0,0,0, - 970,958,1,0,0,0,970,962,1,0,0,0,970,966,1,0,0,0,971,101,1,0,0,0,972,973, - 5,275,0,0,973,1051,6,51,-1,0,974,975,5,276,0,0,975,976,3,32,16,0,976,977, - 6,51,-1,0,977,1051,1,0,0,0,978,979,5,276,0,0,979,980,3,0,0,0,980,981,6, - 51,-1,0,981,1051,1,0,0,0,982,983,5,277,0,0,983,984,3,32,16,0,984,985,6, - 51,-1,0,985,1051,1,0,0,0,986,987,5,278,0,0,987,988,3,34,17,0,988,989,6, - 51,-1,0,989,1051,1,0,0,0,990,991,5,279,0,0,991,992,3,36,18,0,992,993,6, - 51,-1,0,993,1051,1,0,0,0,994,995,5,279,0,0,995,996,3,34,17,0,996,997,6, - 51,-1,0,997,1051,1,0,0,0,998,999,5,279,0,0,999,1000,5,30,0,0,1000,1001, - 3,292,146,0,1001,1002,5,31,0,0,1002,1003,6,51,-1,0,1003,1051,1,0,0,0,1004, - 1005,5,279,0,0,1005,1006,5,84,0,0,1006,1007,5,30,0,0,1007,1008,3,292,146, - 0,1008,1009,5,31,0,0,1009,1010,6,51,-1,0,1010,1051,1,0,0,0,1011,1012,5, - 282,0,0,1012,1013,3,32,16,0,1013,1014,6,51,-1,0,1014,1051,1,0,0,0,1015, - 1016,5,282,0,0,1016,1017,3,0,0,0,1017,1018,6,51,-1,0,1018,1051,1,0,0,0, - 1019,1020,5,285,0,0,1020,1021,3,6,3,0,1021,1022,6,51,-1,0,1022,1051,1, - 0,0,0,1023,1024,5,285,0,0,1024,1025,5,224,0,0,1025,1026,5,30,0,0,1026, - 1027,3,6,3,0,1027,1028,5,31,0,0,1028,1029,6,51,-1,0,1029,1051,1,0,0,0, - 1030,1031,5,285,0,0,1031,1032,5,84,0,0,1032,1033,5,30,0,0,1033,1034,3, - 292,146,0,1034,1035,5,31,0,0,1035,1036,6,51,-1,0,1036,1051,1,0,0,0,1037, - 1038,5,287,0,0,1038,1039,3,32,16,0,1039,1040,6,51,-1,0,1040,1051,1,0,0, - 0,1041,1042,5,283,0,0,1042,1048,6,51,-1,0,1043,1044,5,30,0,0,1044,1045, - 3,106,53,0,1045,1046,5,31,0,0,1046,1049,1,0,0,0,1047,1049,5,85,0,0,1048, - 1043,1,0,0,0,1048,1047,1,0,0,0,1049,1051,1,0,0,0,1050,972,1,0,0,0,1050, - 974,1,0,0,0,1050,978,1,0,0,0,1050,982,1,0,0,0,1050,986,1,0,0,0,1050,990, - 1,0,0,0,1050,994,1,0,0,0,1050,998,1,0,0,0,1050,1004,1,0,0,0,1050,1011, - 1,0,0,0,1050,1015,1,0,0,0,1050,1019,1,0,0,0,1050,1023,1,0,0,0,1050,1030, - 1,0,0,0,1050,1037,1,0,0,0,1050,1041,1,0,0,0,1051,103,1,0,0,0,1052,1053, - 3,170,85,0,1053,1054,3,138,69,0,1054,1055,3,112,56,0,1055,1056,6,52,-1, - 0,1056,105,1,0,0,0,1057,1082,1,0,0,0,1058,1059,3,0,0,0,1059,1060,6,53, - -1,0,1060,1065,1,0,0,0,1061,1062,3,32,16,0,1062,1063,6,53,-1,0,1063,1065, - 1,0,0,0,1064,1058,1,0,0,0,1064,1061,1,0,0,0,1065,1066,1,0,0,0,1066,1067, - 5,28,0,0,1067,1069,1,0,0,0,1068,1064,1,0,0,0,1069,1072,1,0,0,0,1070,1068, - 1,0,0,0,1070,1071,1,0,0,0,1071,1079,1,0,0,0,1072,1070,1,0,0,0,1073,1074, - 3,0,0,0,1074,1075,6,53,-1,0,1075,1080,1,0,0,0,1076,1077,3,32,16,0,1077, - 1078,6,53,-1,0,1078,1080,1,0,0,0,1079,1073,1,0,0,0,1079,1076,1,0,0,0,1080, - 1082,1,0,0,0,1081,1057,1,0,0,0,1081,1070,1,0,0,0,1082,107,1,0,0,0,1083, - 1090,5,86,0,0,1084,1085,3,138,69,0,1085,1086,6,54,-1,0,1086,1087,5,28, - 0,0,1087,1089,1,0,0,0,1088,1084,1,0,0,0,1089,1092,1,0,0,0,1090,1088,1, - 0,0,0,1090,1091,1,0,0,0,1091,1093,1,0,0,0,1092,1090,1,0,0,0,1093,1094, - 3,138,69,0,1094,1095,6,54,-1,0,1095,1096,5,87,0,0,1096,109,1,0,0,0,1097, - 1104,5,42,0,0,1098,1099,3,146,73,0,1099,1100,6,55,-1,0,1100,1101,5,28, - 0,0,1101,1103,1,0,0,0,1102,1098,1,0,0,0,1103,1106,1,0,0,0,1104,1102,1, - 0,0,0,1104,1105,1,0,0,0,1105,1107,1,0,0,0,1106,1104,1,0,0,0,1107,1108, - 3,146,73,0,1108,1109,6,55,-1,0,1109,1110,5,43,0,0,1110,111,1,0,0,0,1111, - 1118,5,30,0,0,1112,1113,3,114,57,0,1113,1114,6,56,-1,0,1114,1115,5,28, - 0,0,1115,1117,1,0,0,0,1116,1112,1,0,0,0,1117,1120,1,0,0,0,1118,1116,1, - 0,0,0,1118,1119,1,0,0,0,1119,1121,1,0,0,0,1120,1118,1,0,0,0,1121,1122, - 3,114,57,0,1122,1123,6,56,-1,0,1123,1124,5,31,0,0,1124,1127,1,0,0,0,1125, - 1127,5,85,0,0,1126,1111,1,0,0,0,1126,1125,1,0,0,0,1127,113,1,0,0,0,1128, - 1129,5,177,0,0,1129,1139,6,57,-1,0,1130,1131,3,230,115,0,1131,1132,3,138, - 69,0,1132,1134,3,226,113,0,1133,1135,3,0,0,0,1134,1133,1,0,0,0,1134,1135, - 1,0,0,0,1135,1136,1,0,0,0,1136,1137,6,57,-1,0,1137,1139,1,0,0,0,1138,1128, - 1,0,0,0,1138,1130,1,0,0,0,1139,115,1,0,0,0,1140,1141,5,42,0,0,1141,1142, - 3,2,1,0,1142,1143,5,43,0,0,1143,1144,3,118,59,0,1144,1145,6,58,-1,0,1145, - 1178,1,0,0,0,1146,1147,5,42,0,0,1147,1148,3,174,87,0,1148,1149,5,43,0, - 0,1149,1150,3,118,59,0,1150,1151,6,58,-1,0,1151,1178,1,0,0,0,1152,1153, - 5,42,0,0,1153,1154,5,262,0,0,1154,1155,5,43,0,0,1155,1156,3,118,59,0,1156, - 1157,6,58,-1,0,1157,1178,1,0,0,0,1158,1159,5,42,0,0,1159,1160,5,198,0, - 0,1160,1161,3,2,1,0,1161,1162,5,43,0,0,1162,1163,3,118,59,0,1163,1164, - 6,58,-1,0,1164,1178,1,0,0,0,1165,1166,3,118,59,0,1166,1167,6,58,-1,0,1167, - 1178,1,0,0,0,1168,1169,3,174,87,0,1169,1170,6,58,-1,0,1170,1178,1,0,0, - 0,1171,1172,5,257,0,0,1172,1178,6,58,-1,0,1173,1174,5,258,0,0,1174,1178, - 6,58,-1,0,1175,1176,5,259,0,0,1176,1178,6,58,-1,0,1177,1140,1,0,0,0,1177, - 1146,1,0,0,0,1177,1152,1,0,0,0,1177,1158,1,0,0,0,1177,1165,1,0,0,0,1177, - 1168,1,0,0,0,1177,1171,1,0,0,0,1177,1173,1,0,0,0,1177,1175,1,0,0,0,1178, - 117,1,0,0,0,1179,1180,3,2,1,0,1180,1181,6,59,-1,0,1181,1182,5,88,0,0,1182, - 1184,1,0,0,0,1183,1179,1,0,0,0,1184,1187,1,0,0,0,1185,1183,1,0,0,0,1185, - 1186,1,0,0,0,1186,1188,1,0,0,0,1187,1185,1,0,0,0,1188,1189,3,2,1,0,1189, - 1190,6,59,-1,0,1190,119,1,0,0,0,1191,1193,3,122,61,0,1192,1191,1,0,0,0, - 1193,1196,1,0,0,0,1194,1192,1,0,0,0,1194,1195,1,0,0,0,1195,121,1,0,0,0, - 1196,1194,1,0,0,0,1197,1198,5,180,0,0,1198,1199,5,89,0,0,1199,1203,3,32, - 16,0,1200,1203,3,152,76,0,1201,1203,3,324,162,0,1202,1197,1,0,0,0,1202, - 1200,1,0,0,0,1202,1201,1,0,0,0,1203,123,1,0,0,0,1204,1205,3,116,58,0,1205, - 1206,6,62,-1,0,1206,1222,1,0,0,0,1207,1208,5,42,0,0,1208,1209,3,2,1,0, - 1209,1210,5,43,0,0,1210,1211,6,62,-1,0,1211,1222,1,0,0,0,1212,1213,5,42, - 0,0,1213,1214,5,198,0,0,1214,1215,3,2,1,0,1215,1216,5,43,0,0,1216,1217, - 6,62,-1,0,1217,1222,1,0,0,0,1218,1219,3,138,69,0,1219,1220,6,62,-1,0,1220, - 1222,1,0,0,0,1221,1204,1,0,0,0,1221,1207,1,0,0,0,1221,1212,1,0,0,0,1221, - 1218,1,0,0,0,1222,125,1,0,0,0,1223,1235,1,0,0,0,1224,1225,3,130,65,0,1225, - 1231,6,63,-1,0,1226,1227,3,128,64,0,1227,1228,6,63,-1,0,1228,1230,1,0, - 0,0,1229,1226,1,0,0,0,1230,1233,1,0,0,0,1231,1229,1,0,0,0,1231,1232,1, - 0,0,0,1232,1235,1,0,0,0,1233,1231,1,0,0,0,1234,1223,1,0,0,0,1234,1224, - 1,0,0,0,1235,127,1,0,0,0,1236,1237,5,262,0,0,1237,1259,6,64,-1,0,1238, - 1239,5,261,0,0,1239,1259,6,64,-1,0,1240,1241,5,42,0,0,1241,1242,3,32,16, - 0,1242,1243,5,43,0,0,1243,1244,6,64,-1,0,1244,1259,1,0,0,0,1245,1246,5, - 42,0,0,1246,1247,3,32,16,0,1247,1248,5,266,0,0,1248,1249,3,32,16,0,1249, - 1250,5,43,0,0,1250,1251,6,64,-1,0,1251,1259,1,0,0,0,1252,1253,5,42,0,0, - 1253,1254,5,266,0,0,1254,1255,3,32,16,0,1255,1256,5,43,0,0,1256,1257,6, - 64,-1,0,1257,1259,1,0,0,0,1258,1236,1,0,0,0,1258,1238,1,0,0,0,1258,1240, - 1,0,0,0,1258,1245,1,0,0,0,1258,1252,1,0,0,0,1259,129,1,0,0,0,1260,1406, - 6,65,-1,0,1261,1262,5,203,0,0,1262,1263,5,30,0,0,1263,1264,3,6,3,0,1264, - 1265,5,28,0,0,1265,1266,3,6,3,0,1266,1267,5,28,0,0,1267,1268,3,6,3,0,1268, - 1269,5,28,0,0,1269,1270,3,6,3,0,1270,1271,5,31,0,0,1271,1272,6,65,-1,0, - 1272,1406,1,0,0,0,1273,1274,5,203,0,0,1274,1275,5,30,0,0,1275,1276,3,6, - 3,0,1276,1277,5,28,0,0,1277,1278,3,6,3,0,1278,1279,5,31,0,0,1279,1280, - 6,65,-1,0,1280,1406,1,0,0,0,1281,1282,5,204,0,0,1282,1283,5,205,0,0,1283, - 1284,5,42,0,0,1284,1285,3,32,16,0,1285,1286,5,43,0,0,1286,1287,6,65,-1, - 0,1287,1406,1,0,0,0,1288,1289,5,204,0,0,1289,1290,5,206,0,0,1290,1291, - 5,42,0,0,1291,1292,3,32,16,0,1292,1293,5,43,0,0,1293,1294,3,126,63,0,1294, - 1295,6,65,-1,0,1295,1406,1,0,0,0,1296,1297,5,207,0,0,1297,1406,6,65,-1, - 0,1298,1299,5,208,0,0,1299,1406,6,65,-1,0,1300,1301,5,209,0,0,1301,1406, - 6,65,-1,0,1302,1303,5,201,0,0,1303,1406,6,65,-1,0,1304,1305,5,183,0,0, - 1305,1406,6,65,-1,0,1306,1307,5,184,0,0,1307,1406,6,65,-1,0,1308,1309, - 5,185,0,0,1309,1406,6,65,-1,0,1310,1311,5,186,0,0,1311,1406,6,65,-1,0, - 1312,1313,5,187,0,0,1313,1406,6,65,-1,0,1314,1315,5,188,0,0,1315,1406, - 6,65,-1,0,1316,1317,5,189,0,0,1317,1406,6,65,-1,0,1318,1319,5,210,0,0, - 1319,1406,6,65,-1,0,1320,1321,5,190,0,0,1321,1406,6,65,-1,0,1322,1323, - 5,191,0,0,1323,1406,6,65,-1,0,1324,1325,5,192,0,0,1325,1406,6,65,-1,0, - 1326,1327,5,193,0,0,1327,1406,6,65,-1,0,1328,1329,5,211,0,0,1329,1406, - 6,65,-1,0,1330,1331,5,212,0,0,1331,1406,6,65,-1,0,1332,1333,5,213,0,0, - 1333,1406,6,65,-1,0,1334,1335,5,214,0,0,1335,1406,6,65,-1,0,1336,1337, - 5,215,0,0,1337,1406,6,65,-1,0,1338,1339,5,216,0,0,1339,1406,6,65,-1,0, - 1340,1341,5,217,0,0,1341,1406,6,65,-1,0,1342,1343,5,218,0,0,1343,1344, - 3,132,66,0,1344,1345,6,65,-1,0,1345,1406,1,0,0,0,1346,1347,5,219,0,0,1347, - 1348,3,132,66,0,1348,1349,6,65,-1,0,1349,1406,1,0,0,0,1350,1351,5,220, - 0,0,1351,1406,6,65,-1,0,1352,1353,5,221,0,0,1353,1354,3,132,66,0,1354, - 1355,6,65,-1,0,1355,1406,1,0,0,0,1356,1357,5,222,0,0,1357,1358,3,134,67, - 0,1358,1359,6,65,-1,0,1359,1406,1,0,0,0,1360,1361,5,222,0,0,1361,1362, - 3,134,67,0,1362,1363,5,28,0,0,1363,1364,3,6,3,0,1364,1365,6,65,-1,0,1365, - 1406,1,0,0,0,1366,1367,5,194,0,0,1367,1406,6,65,-1,0,1368,1369,5,195,0, - 0,1369,1406,6,65,-1,0,1370,1371,5,90,0,0,1371,1372,5,184,0,0,1372,1406, - 6,65,-1,0,1373,1374,5,90,0,0,1374,1375,5,185,0,0,1375,1406,6,65,-1,0,1376, - 1377,5,90,0,0,1377,1378,5,186,0,0,1378,1406,6,65,-1,0,1379,1380,5,90,0, - 0,1380,1381,5,187,0,0,1381,1406,6,65,-1,0,1382,1383,5,62,0,0,1383,1384, - 5,220,0,0,1384,1406,6,65,-1,0,1385,1386,5,223,0,0,1386,1406,6,65,-1,0, - 1387,1388,5,224,0,0,1388,1389,5,213,0,0,1389,1406,6,65,-1,0,1390,1391, - 5,225,0,0,1391,1406,6,65,-1,0,1392,1393,5,207,0,0,1393,1394,5,183,0,0, - 1394,1406,6,65,-1,0,1395,1396,5,226,0,0,1396,1406,6,65,-1,0,1397,1398, - 5,228,0,0,1398,1406,6,65,-1,0,1399,1400,5,34,0,0,1400,1401,5,227,0,0,1401, - 1406,6,65,-1,0,1402,1403,3,2,1,0,1403,1404,6,65,-1,0,1404,1406,1,0,0,0, - 1405,1260,1,0,0,0,1405,1261,1,0,0,0,1405,1273,1,0,0,0,1405,1281,1,0,0, - 0,1405,1288,1,0,0,0,1405,1296,1,0,0,0,1405,1298,1,0,0,0,1405,1300,1,0, - 0,0,1405,1302,1,0,0,0,1405,1304,1,0,0,0,1405,1306,1,0,0,0,1405,1308,1, - 0,0,0,1405,1310,1,0,0,0,1405,1312,1,0,0,0,1405,1314,1,0,0,0,1405,1316, - 1,0,0,0,1405,1318,1,0,0,0,1405,1320,1,0,0,0,1405,1322,1,0,0,0,1405,1324, - 1,0,0,0,1405,1326,1,0,0,0,1405,1328,1,0,0,0,1405,1330,1,0,0,0,1405,1332, - 1,0,0,0,1405,1334,1,0,0,0,1405,1336,1,0,0,0,1405,1338,1,0,0,0,1405,1340, - 1,0,0,0,1405,1342,1,0,0,0,1405,1346,1,0,0,0,1405,1350,1,0,0,0,1405,1352, - 1,0,0,0,1405,1356,1,0,0,0,1405,1360,1,0,0,0,1405,1366,1,0,0,0,1405,1368, - 1,0,0,0,1405,1370,1,0,0,0,1405,1373,1,0,0,0,1405,1376,1,0,0,0,1405,1379, - 1,0,0,0,1405,1382,1,0,0,0,1405,1385,1,0,0,0,1405,1387,1,0,0,0,1405,1390, - 1,0,0,0,1405,1392,1,0,0,0,1405,1395,1,0,0,0,1405,1397,1,0,0,0,1405,1399, - 1,0,0,0,1405,1402,1,0,0,0,1406,131,1,0,0,0,1407,1416,1,0,0,0,1408,1409, - 5,30,0,0,1409,1410,5,91,0,0,1410,1411,5,36,0,0,1411,1412,3,32,16,0,1412, - 1413,5,31,0,0,1413,1414,6,66,-1,0,1414,1416,1,0,0,0,1415,1407,1,0,0,0, - 1415,1408,1,0,0,0,1416,133,1,0,0,0,1417,1428,1,0,0,0,1418,1419,3,136,68, - 0,1419,1424,6,67,-1,0,1420,1421,7,7,0,0,1421,1423,6,67,-1,0,1422,1420, - 1,0,0,0,1423,1426,1,0,0,0,1424,1422,1,0,0,0,1424,1425,1,0,0,0,1425,1428, - 1,0,0,0,1426,1424,1,0,0,0,1427,1417,1,0,0,0,1427,1418,1,0,0,0,1428,135, - 1,0,0,0,1429,1430,5,178,0,0,1430,1510,6,68,-1,0,1431,1432,5,207,0,0,1432, - 1510,6,68,-1,0,1433,1434,5,208,0,0,1434,1510,6,68,-1,0,1435,1436,5,201, - 0,0,1436,1510,6,68,-1,0,1437,1438,5,183,0,0,1438,1510,6,68,-1,0,1439,1440, - 5,184,0,0,1440,1510,6,68,-1,0,1441,1442,5,185,0,0,1442,1510,6,68,-1,0, - 1443,1444,5,186,0,0,1444,1510,6,68,-1,0,1445,1446,5,187,0,0,1446,1510, - 6,68,-1,0,1447,1448,5,188,0,0,1448,1510,6,68,-1,0,1449,1450,5,189,0,0, - 1450,1510,6,68,-1,0,1451,1452,5,190,0,0,1452,1510,6,68,-1,0,1453,1454, - 5,191,0,0,1454,1510,6,68,-1,0,1455,1456,5,192,0,0,1456,1510,6,68,-1,0, - 1457,1458,5,193,0,0,1458,1510,6,68,-1,0,1459,1460,5,262,0,0,1460,1510, - 6,68,-1,0,1461,1462,5,211,0,0,1462,1510,6,68,-1,0,1463,1464,5,212,0,0, - 1464,1510,6,68,-1,0,1465,1466,5,213,0,0,1466,1510,6,68,-1,0,1467,1468, - 5,214,0,0,1468,1510,6,68,-1,0,1469,1470,5,215,0,0,1470,1510,6,68,-1,0, - 1471,1472,5,218,0,0,1472,1510,6,68,-1,0,1473,1474,5,219,0,0,1474,1510, - 6,68,-1,0,1475,1476,5,222,0,0,1476,1510,6,68,-1,0,1477,1478,5,194,0,0, - 1478,1510,6,68,-1,0,1479,1480,5,195,0,0,1480,1510,6,68,-1,0,1481,1482, - 5,210,0,0,1482,1510,6,68,-1,0,1483,1484,5,230,0,0,1484,1510,6,68,-1,0, - 1485,1486,5,231,0,0,1486,1510,6,68,-1,0,1487,1488,5,232,0,0,1488,1510, - 6,68,-1,0,1489,1490,5,233,0,0,1490,1510,6,68,-1,0,1491,1492,5,234,0,0, - 1492,1510,6,68,-1,0,1493,1494,5,235,0,0,1494,1510,6,68,-1,0,1495,1496, - 5,236,0,0,1496,1510,6,68,-1,0,1497,1498,5,237,0,0,1498,1510,6,68,-1,0, - 1499,1500,5,238,0,0,1500,1510,6,68,-1,0,1501,1502,5,239,0,0,1502,1510, - 6,68,-1,0,1503,1504,5,240,0,0,1504,1510,6,68,-1,0,1505,1506,5,241,0,0, - 1506,1510,6,68,-1,0,1507,1508,5,242,0,0,1508,1510,6,68,-1,0,1509,1429, - 1,0,0,0,1509,1431,1,0,0,0,1509,1433,1,0,0,0,1509,1435,1,0,0,0,1509,1437, - 1,0,0,0,1509,1439,1,0,0,0,1509,1441,1,0,0,0,1509,1443,1,0,0,0,1509,1445, - 1,0,0,0,1509,1447,1,0,0,0,1509,1449,1,0,0,0,1509,1451,1,0,0,0,1509,1453, - 1,0,0,0,1509,1455,1,0,0,0,1509,1457,1,0,0,0,1509,1459,1,0,0,0,1509,1461, - 1,0,0,0,1509,1463,1,0,0,0,1509,1465,1,0,0,0,1509,1467,1,0,0,0,1509,1469, - 1,0,0,0,1509,1471,1,0,0,0,1509,1473,1,0,0,0,1509,1475,1,0,0,0,1509,1477, - 1,0,0,0,1509,1479,1,0,0,0,1509,1481,1,0,0,0,1509,1483,1,0,0,0,1509,1485, - 1,0,0,0,1509,1487,1,0,0,0,1509,1489,1,0,0,0,1509,1491,1,0,0,0,1509,1493, - 1,0,0,0,1509,1495,1,0,0,0,1509,1497,1,0,0,0,1509,1499,1,0,0,0,1509,1501, - 1,0,0,0,1509,1503,1,0,0,0,1509,1505,1,0,0,0,1509,1507,1,0,0,0,1510,137, - 1,0,0,0,1511,1512,3,142,71,0,1512,1518,6,69,-1,0,1513,1514,3,140,70,0, - 1514,1515,6,69,-1,0,1515,1517,1,0,0,0,1516,1513,1,0,0,0,1517,1520,1,0, - 0,0,1518,1516,1,0,0,0,1518,1519,1,0,0,0,1519,139,1,0,0,0,1520,1518,1,0, - 0,0,1521,1522,5,261,0,0,1522,1551,6,70,-1,0,1523,1524,5,42,0,0,1524,1525, - 5,43,0,0,1525,1551,6,70,-1,0,1526,1527,3,110,55,0,1527,1528,6,70,-1,0, - 1528,1551,1,0,0,0,1529,1530,5,260,0,0,1530,1551,6,70,-1,0,1531,1532,5, - 262,0,0,1532,1551,6,70,-1,0,1533,1534,5,92,0,0,1534,1551,6,70,-1,0,1535, - 1536,5,93,0,0,1536,1537,5,30,0,0,1537,1538,3,124,62,0,1538,1539,5,31,0, - 0,1539,1540,6,70,-1,0,1540,1551,1,0,0,0,1541,1542,5,94,0,0,1542,1543,5, - 30,0,0,1543,1544,3,124,62,0,1544,1545,5,31,0,0,1545,1546,6,70,-1,0,1546, - 1551,1,0,0,0,1547,1548,3,108,54,0,1548,1549,6,70,-1,0,1549,1551,1,0,0, - 0,1550,1521,1,0,0,0,1550,1523,1,0,0,0,1550,1526,1,0,0,0,1550,1529,1,0, - 0,0,1550,1531,1,0,0,0,1550,1533,1,0,0,0,1550,1535,1,0,0,0,1550,1541,1, - 0,0,0,1550,1547,1,0,0,0,1551,141,1,0,0,0,1552,1553,5,39,0,0,1553,1554, - 3,116,58,0,1554,1555,6,71,-1,0,1555,1611,1,0,0,0,1556,1557,5,197,0,0,1557, - 1611,6,71,-1,0,1558,1559,5,199,0,0,1559,1560,5,39,0,0,1560,1561,3,116, - 58,0,1561,1562,6,71,-1,0,1562,1611,1,0,0,0,1563,1564,5,200,0,0,1564,1565, - 3,116,58,0,1565,1566,6,71,-1,0,1566,1611,1,0,0,0,1567,1568,5,226,0,0,1568, - 1569,3,170,85,0,1569,1570,3,138,69,0,1570,1571,5,262,0,0,1571,1572,3,112, - 56,0,1572,1573,6,71,-1,0,1573,1611,1,0,0,0,1574,1575,5,253,0,0,1575,1576, - 3,32,16,0,1576,1577,6,71,-1,0,1577,1611,1,0,0,0,1578,1579,5,252,0,0,1579, - 1580,3,32,16,0,1580,1581,6,71,-1,0,1581,1611,1,0,0,0,1582,1583,5,253,0, - 0,1583,1584,3,2,1,0,1584,1585,6,71,-1,0,1585,1611,1,0,0,0,1586,1587,5, - 252,0,0,1587,1588,3,2,1,0,1588,1589,6,71,-1,0,1589,1611,1,0,0,0,1590,1591, - 5,254,0,0,1591,1611,6,71,-1,0,1592,1593,5,201,0,0,1593,1611,6,71,-1,0, - 1594,1595,3,148,74,0,1595,1596,6,71,-1,0,1596,1611,1,0,0,0,1597,1598,3, - 150,75,0,1598,1599,6,71,-1,0,1599,1611,1,0,0,0,1600,1601,3,144,72,0,1601, - 1602,6,71,-1,0,1602,1611,1,0,0,0,1603,1604,3,2,1,0,1604,1605,6,71,-1,0, - 1605,1611,1,0,0,0,1606,1607,5,177,0,0,1607,1608,3,138,69,0,1608,1609,6, - 71,-1,0,1609,1611,1,0,0,0,1610,1552,1,0,0,0,1610,1556,1,0,0,0,1610,1558, - 1,0,0,0,1610,1563,1,0,0,0,1610,1567,1,0,0,0,1610,1574,1,0,0,0,1610,1578, - 1,0,0,0,1610,1582,1,0,0,0,1610,1586,1,0,0,0,1610,1590,1,0,0,0,1610,1592, - 1,0,0,0,1610,1594,1,0,0,0,1610,1597,1,0,0,0,1610,1600,1,0,0,0,1610,1603, - 1,0,0,0,1610,1606,1,0,0,0,1611,143,1,0,0,0,1612,1613,5,181,0,0,1613,1651, - 6,72,-1,0,1614,1615,5,182,0,0,1615,1651,6,72,-1,0,1616,1617,5,183,0,0, - 1617,1651,6,72,-1,0,1618,1619,5,184,0,0,1619,1651,6,72,-1,0,1620,1621, - 5,185,0,0,1621,1651,6,72,-1,0,1622,1623,5,186,0,0,1623,1651,6,72,-1,0, - 1624,1625,5,187,0,0,1625,1651,6,72,-1,0,1626,1627,5,188,0,0,1627,1651, - 6,72,-1,0,1628,1629,5,189,0,0,1629,1651,6,72,-1,0,1630,1631,5,190,0,0, - 1631,1651,6,72,-1,0,1632,1633,5,191,0,0,1633,1651,6,72,-1,0,1634,1635, - 5,192,0,0,1635,1651,6,72,-1,0,1636,1637,5,193,0,0,1637,1651,6,72,-1,0, - 1638,1639,5,90,0,0,1639,1640,5,184,0,0,1640,1651,6,72,-1,0,1641,1642,5, - 90,0,0,1642,1643,5,185,0,0,1643,1651,6,72,-1,0,1644,1645,5,90,0,0,1645, - 1646,5,186,0,0,1646,1651,6,72,-1,0,1647,1648,5,90,0,0,1648,1649,5,187, - 0,0,1649,1651,6,72,-1,0,1650,1612,1,0,0,0,1650,1614,1,0,0,0,1650,1616, - 1,0,0,0,1650,1618,1,0,0,0,1650,1620,1,0,0,0,1650,1622,1,0,0,0,1650,1624, - 1,0,0,0,1650,1626,1,0,0,0,1650,1628,1,0,0,0,1650,1630,1,0,0,0,1650,1632, - 1,0,0,0,1650,1634,1,0,0,0,1650,1636,1,0,0,0,1650,1638,1,0,0,0,1650,1641, - 1,0,0,0,1650,1644,1,0,0,0,1650,1647,1,0,0,0,1651,145,1,0,0,0,1652,1667, - 1,0,0,0,1653,1667,5,177,0,0,1654,1655,3,32,16,0,1655,1656,6,73,-1,0,1656, - 1667,1,0,0,0,1657,1658,3,32,16,0,1658,1659,5,177,0,0,1659,1660,3,32,16, - 0,1660,1661,6,73,-1,0,1661,1667,1,0,0,0,1662,1663,3,32,16,0,1663,1664, - 5,177,0,0,1664,1665,6,73,-1,0,1665,1667,1,0,0,0,1666,1652,1,0,0,0,1666, - 1653,1,0,0,0,1666,1654,1,0,0,0,1666,1657,1,0,0,0,1666,1662,1,0,0,0,1667, - 147,1,0,0,0,1668,1669,5,1,0,0,1669,1670,5,194,0,0,1670,1671,6,74,-1,0, - 1671,149,1,0,0,0,1672,1676,5,1,0,0,1673,1674,5,90,0,0,1674,1677,5,194, - 0,0,1675,1677,5,195,0,0,1676,1673,1,0,0,0,1676,1675,1,0,0,0,1677,1678, - 1,0,0,0,1678,1679,6,75,-1,0,1679,151,1,0,0,0,1680,1681,5,294,0,0,1681, - 1682,3,166,83,0,1682,1683,3,124,62,0,1683,1684,5,30,0,0,1684,1685,3,158, - 79,0,1685,1686,5,31,0,0,1686,1728,1,0,0,0,1687,1688,5,294,0,0,1688,1689, - 3,166,83,0,1689,1690,3,124,62,0,1690,1691,5,36,0,0,1691,1692,5,17,0,0, - 1692,1693,3,52,26,0,1693,1694,5,18,0,0,1694,1728,1,0,0,0,1695,1696,5,294, - 0,0,1696,1697,3,166,83,0,1697,1698,3,124,62,0,1698,1728,1,0,0,0,1699,1700, - 5,295,0,0,1700,1701,3,166,83,0,1701,1703,5,36,0,0,1702,1704,5,84,0,0,1703, - 1702,1,0,0,0,1703,1704,1,0,0,0,1704,1705,1,0,0,0,1705,1706,5,30,0,0,1706, - 1707,3,292,146,0,1707,1708,5,31,0,0,1708,1728,1,0,0,0,1709,1710,5,295, - 0,0,1710,1711,3,166,83,0,1711,1712,5,84,0,0,1712,1713,5,30,0,0,1713,1714, - 3,292,146,0,1714,1715,5,31,0,0,1715,1728,1,0,0,0,1716,1717,5,295,0,0,1717, - 1718,3,166,83,0,1718,1719,3,6,3,0,1719,1728,1,0,0,0,1720,1721,5,295,0, - 0,1721,1722,3,166,83,0,1722,1723,5,36,0,0,1723,1724,5,17,0,0,1724,1725, - 3,154,77,0,1725,1726,5,18,0,0,1726,1728,1,0,0,0,1727,1680,1,0,0,0,1727, - 1687,1,0,0,0,1727,1695,1,0,0,0,1727,1699,1,0,0,0,1727,1709,1,0,0,0,1727, - 1716,1,0,0,0,1727,1720,1,0,0,0,1728,153,1,0,0,0,1729,1740,1,0,0,0,1730, - 1731,3,156,78,0,1731,1732,5,28,0,0,1732,1734,1,0,0,0,1733,1730,1,0,0,0, - 1734,1737,1,0,0,0,1735,1733,1,0,0,0,1735,1736,1,0,0,0,1736,1738,1,0,0, - 0,1737,1735,1,0,0,0,1738,1740,3,156,78,0,1739,1729,1,0,0,0,1739,1735,1, - 0,0,0,1740,155,1,0,0,0,1741,1742,5,39,0,0,1742,1743,5,264,0,0,1743,1744, - 5,36,0,0,1744,1745,5,17,0,0,1745,1746,3,56,28,0,1746,1747,5,18,0,0,1747, - 1755,1,0,0,0,1748,1749,3,124,62,0,1749,1750,5,36,0,0,1750,1751,5,17,0, - 0,1751,1752,3,56,28,0,1752,1753,5,18,0,0,1753,1755,1,0,0,0,1754,1741,1, - 0,0,0,1754,1748,1,0,0,0,1755,157,1,0,0,0,1756,1757,3,160,80,0,1757,1758, - 5,28,0,0,1758,1760,1,0,0,0,1759,1756,1,0,0,0,1760,1763,1,0,0,0,1761,1759, - 1,0,0,0,1761,1762,1,0,0,0,1762,1764,1,0,0,0,1763,1761,1,0,0,0,1764,1765, - 3,160,80,0,1765,159,1,0,0,0,1766,1767,3,6,3,0,1767,1768,5,36,0,0,1768, - 1769,3,164,82,0,1769,161,1,0,0,0,1770,1771,7,8,0,0,1771,163,1,0,0,0,1772, - 1807,3,162,81,0,1773,1807,3,32,16,0,1774,1775,5,186,0,0,1775,1776,5,30, - 0,0,1776,1777,3,32,16,0,1777,1778,5,31,0,0,1778,1807,1,0,0,0,1779,1807, - 3,6,3,0,1780,1781,3,116,58,0,1781,1782,5,30,0,0,1782,1783,5,184,0,0,1783, - 1784,5,75,0,0,1784,1785,3,32,16,0,1785,1786,5,31,0,0,1786,1807,1,0,0,0, - 1787,1788,3,116,58,0,1788,1789,5,30,0,0,1789,1790,5,185,0,0,1790,1791, - 5,75,0,0,1791,1792,3,32,16,0,1792,1793,5,31,0,0,1793,1807,1,0,0,0,1794, - 1795,3,116,58,0,1795,1796,5,30,0,0,1796,1797,5,186,0,0,1797,1798,5,75, - 0,0,1798,1799,3,32,16,0,1799,1800,5,31,0,0,1800,1807,1,0,0,0,1801,1802, - 3,116,58,0,1802,1803,5,30,0,0,1803,1804,3,32,16,0,1804,1805,5,31,0,0,1805, - 1807,1,0,0,0,1806,1772,1,0,0,0,1806,1773,1,0,0,0,1806,1774,1,0,0,0,1806, - 1779,1,0,0,0,1806,1780,1,0,0,0,1806,1787,1,0,0,0,1806,1794,1,0,0,0,1806, - 1801,1,0,0,0,1807,165,1,0,0,0,1808,1809,7,9,0,0,1809,167,1,0,0,0,1810, - 1811,3,170,85,0,1811,1812,3,138,69,0,1812,1813,3,124,62,0,1813,1814,5, - 176,0,0,1814,1816,3,242,121,0,1815,1817,3,108,54,0,1816,1815,1,0,0,0,1816, - 1817,1,0,0,0,1817,1818,1,0,0,0,1818,1819,3,112,56,0,1819,1820,6,84,-1, - 0,1820,1853,1,0,0,0,1821,1822,3,170,85,0,1822,1823,3,138,69,0,1823,1824, - 3,124,62,0,1824,1825,5,176,0,0,1825,1826,3,242,121,0,1826,1827,3,196,98, - 0,1827,1828,3,112,56,0,1828,1829,6,84,-1,0,1829,1853,1,0,0,0,1830,1831, - 3,170,85,0,1831,1832,3,138,69,0,1832,1834,3,242,121,0,1833,1835,3,108, - 54,0,1834,1833,1,0,0,0,1834,1835,1,0,0,0,1835,1836,1,0,0,0,1836,1837,3, - 112,56,0,1837,1838,6,84,-1,0,1838,1853,1,0,0,0,1839,1840,3,170,85,0,1840, - 1841,3,138,69,0,1841,1842,3,242,121,0,1842,1843,3,196,98,0,1843,1844,3, - 112,56,0,1844,1845,6,84,-1,0,1845,1853,1,0,0,0,1846,1847,3,174,87,0,1847, - 1848,6,84,-1,0,1848,1853,1,0,0,0,1849,1850,3,2,1,0,1850,1851,6,84,-1,0, - 1851,1853,1,0,0,0,1852,1810,1,0,0,0,1852,1821,1,0,0,0,1852,1830,1,0,0, - 0,1852,1839,1,0,0,0,1852,1846,1,0,0,0,1852,1849,1,0,0,0,1853,169,1,0,0, - 0,1854,1855,5,243,0,0,1855,1856,3,170,85,0,1856,1857,6,85,-1,0,1857,1872, - 1,0,0,0,1858,1859,5,244,0,0,1859,1860,3,170,85,0,1860,1861,6,85,-1,0,1861, - 1872,1,0,0,0,1862,1863,3,172,86,0,1863,1864,6,85,-1,0,1864,1872,1,0,0, - 0,1865,1866,5,112,0,0,1866,1867,5,30,0,0,1867,1868,3,32,16,0,1868,1869, - 5,31,0,0,1869,1870,6,85,-1,0,1870,1872,1,0,0,0,1871,1854,1,0,0,0,1871, - 1858,1,0,0,0,1871,1862,1,0,0,0,1871,1865,1,0,0,0,1872,171,1,0,0,0,1873, - 1893,1,0,0,0,1874,1875,5,245,0,0,1875,1893,6,86,-1,0,1876,1877,5,246,0, - 0,1877,1893,6,86,-1,0,1878,1879,5,247,0,0,1879,1880,5,248,0,0,1880,1893, - 6,86,-1,0,1881,1882,5,247,0,0,1882,1883,5,249,0,0,1883,1893,6,86,-1,0, - 1884,1885,5,247,0,0,1885,1886,5,250,0,0,1886,1893,6,86,-1,0,1887,1888, - 5,247,0,0,1888,1889,5,251,0,0,1889,1893,6,86,-1,0,1890,1891,5,247,0,0, - 1891,1893,6,86,-1,0,1892,1873,1,0,0,0,1892,1874,1,0,0,0,1892,1876,1,0, - 0,0,1892,1878,1,0,0,0,1892,1881,1,0,0,0,1892,1884,1,0,0,0,1892,1887,1, - 0,0,0,1892,1890,1,0,0,0,1893,173,1,0,0,0,1894,1895,5,113,0,0,1895,1896, - 5,30,0,0,1896,1897,3,32,16,0,1897,1898,5,31,0,0,1898,1899,6,87,-1,0,1899, - 175,1,0,0,0,1900,1901,5,226,0,0,1901,1902,3,168,84,0,1902,1903,6,88,-1, - 0,1903,1912,1,0,0,0,1904,1905,5,37,0,0,1905,1906,3,178,89,0,1906,1907, - 6,88,-1,0,1907,1912,1,0,0,0,1908,1909,3,174,87,0,1909,1910,6,88,-1,0,1910, - 1912,1,0,0,0,1911,1900,1,0,0,0,1911,1904,1,0,0,0,1911,1908,1,0,0,0,1912, - 177,1,0,0,0,1913,1914,3,138,69,0,1914,1915,3,124,62,0,1915,1916,5,176, - 0,0,1916,1917,3,2,1,0,1917,1918,6,89,-1,0,1918,1927,1,0,0,0,1919,1920, - 3,138,69,0,1920,1921,3,2,1,0,1921,1922,6,89,-1,0,1922,1927,1,0,0,0,1923, - 1924,3,2,1,0,1924,1925,6,89,-1,0,1925,1927,1,0,0,0,1926,1913,1,0,0,0,1926, - 1919,1,0,0,0,1926,1923,1,0,0,0,1927,179,1,0,0,0,1928,1929,3,124,62,0,1929, - 1930,5,28,0,0,1930,1932,1,0,0,0,1931,1928,1,0,0,0,1932,1935,1,0,0,0,1933, - 1931,1,0,0,0,1933,1934,1,0,0,0,1934,1936,1,0,0,0,1935,1933,1,0,0,0,1936, - 1937,3,124,62,0,1937,181,1,0,0,0,1938,1944,1,0,0,0,1939,1940,5,86,0,0, - 1940,1941,3,190,95,0,1941,1942,5,87,0,0,1942,1944,1,0,0,0,1943,1938,1, - 0,0,0,1943,1939,1,0,0,0,1944,183,1,0,0,0,1945,1957,5,266,0,0,1946,1957, - 5,114,0,0,1947,1957,5,39,0,0,1948,1957,5,200,0,0,1949,1957,5,115,0,0,1950, - 1957,5,116,0,0,1951,1952,5,70,0,0,1952,1953,5,30,0,0,1953,1954,3,32,16, - 0,1954,1955,5,31,0,0,1955,1957,1,0,0,0,1956,1945,1,0,0,0,1956,1946,1,0, - 0,0,1956,1947,1,0,0,0,1956,1948,1,0,0,0,1956,1949,1,0,0,0,1956,1950,1, - 0,0,0,1956,1951,1,0,0,0,1957,185,1,0,0,0,1958,1960,3,184,92,0,1959,1958, - 1,0,0,0,1960,1963,1,0,0,0,1961,1959,1,0,0,0,1961,1962,1,0,0,0,1962,187, - 1,0,0,0,1963,1961,1,0,0,0,1964,1966,3,186,93,0,1965,1967,3,192,96,0,1966, - 1965,1,0,0,0,1966,1967,1,0,0,0,1967,1968,1,0,0,0,1968,1969,3,2,1,0,1969, - 189,1,0,0,0,1970,1971,3,188,94,0,1971,1972,5,28,0,0,1972,1974,1,0,0,0, - 1973,1970,1,0,0,0,1974,1977,1,0,0,0,1975,1973,1,0,0,0,1975,1976,1,0,0, - 0,1976,1978,1,0,0,0,1977,1975,1,0,0,0,1978,1979,3,188,94,0,1979,191,1, - 0,0,0,1980,1981,5,30,0,0,1981,1982,3,180,90,0,1982,1983,5,31,0,0,1983, - 193,1,0,0,0,1984,1986,3,196,98,0,1985,1984,1,0,0,0,1985,1986,1,0,0,0,1986, - 1987,1,0,0,0,1987,1988,6,97,-1,0,1988,195,1,0,0,0,1989,1990,5,86,0,0,1990, - 1991,5,42,0,0,1991,1992,3,32,16,0,1992,1993,5,43,0,0,1993,1994,5,87,0, - 0,1994,1995,6,98,-1,0,1995,197,1,0,0,0,1996,1997,3,234,117,0,1997,1998, - 5,17,0,0,1998,1999,3,246,123,0,1999,2000,5,18,0,0,2000,2113,1,0,0,0,2001, - 2002,3,74,37,0,2002,2003,5,17,0,0,2003,2004,3,82,41,0,2004,2005,5,18,0, - 0,2005,2113,1,0,0,0,2006,2007,3,210,105,0,2007,2008,5,17,0,0,2008,2009, - 3,214,107,0,2009,2010,5,18,0,0,2010,2113,1,0,0,0,2011,2012,3,218,109,0, - 2012,2013,5,17,0,0,2013,2014,3,222,111,0,2014,2015,5,18,0,0,2015,2113, - 1,0,0,0,2016,2113,3,200,100,0,2017,2113,3,276,138,0,2018,2113,3,152,76, - 0,2019,2113,3,88,44,0,2020,2113,3,322,161,0,2021,2022,5,117,0,0,2022,2113, - 3,32,16,0,2023,2024,5,118,0,0,2024,2113,3,32,16,0,2025,2026,3,334,167, - 0,2026,2027,5,17,0,0,2027,2028,3,338,169,0,2028,2029,5,18,0,0,2029,2113, - 1,0,0,0,2030,2031,5,302,0,0,2031,2032,3,124,62,0,2032,2033,5,176,0,0,2033, - 2034,3,242,121,0,2034,2035,5,119,0,0,2035,2036,3,170,85,0,2036,2037,3, - 138,69,0,2037,2038,3,124,62,0,2038,2039,5,176,0,0,2039,2040,3,242,121, - 0,2040,2041,3,112,56,0,2041,2113,1,0,0,0,2042,2043,5,302,0,0,2043,2044, - 5,226,0,0,2044,2045,3,170,85,0,2045,2046,3,138,69,0,2046,2047,3,124,62, - 0,2047,2048,5,176,0,0,2048,2049,3,242,121,0,2049,2050,3,194,97,0,2050, - 2051,3,112,56,0,2051,2052,5,119,0,0,2052,2053,5,226,0,0,2053,2054,3,170, - 85,0,2054,2055,3,138,69,0,2055,2056,3,124,62,0,2056,2057,5,176,0,0,2057, - 2058,3,242,121,0,2058,2059,3,194,97,0,2059,2060,3,112,56,0,2060,2113,1, - 0,0,0,2061,2113,3,26,13,0,2062,2113,3,40,20,0,2063,2064,5,255,0,0,2064, - 2065,5,196,0,0,2065,2066,5,42,0,0,2066,2067,3,32,16,0,2067,2071,5,43,0, - 0,2068,2070,3,322,161,0,2069,2068,1,0,0,0,2070,2073,1,0,0,0,2071,2069, - 1,0,0,0,2071,2072,1,0,0,0,2072,2113,1,0,0,0,2073,2071,1,0,0,0,2074,2075, - 5,255,0,0,2075,2076,5,196,0,0,2076,2080,3,2,1,0,2077,2079,3,322,161,0, - 2078,2077,1,0,0,0,2079,2082,1,0,0,0,2080,2078,1,0,0,0,2080,2081,1,0,0, - 0,2081,2113,1,0,0,0,2082,2080,1,0,0,0,2083,2084,5,255,0,0,2084,2085,5, - 256,0,0,2085,2086,5,42,0,0,2086,2087,3,32,16,0,2087,2088,5,43,0,0,2088, - 2089,5,28,0,0,2089,2093,3,124,62,0,2090,2092,3,322,161,0,2091,2090,1,0, - 0,0,2092,2095,1,0,0,0,2093,2091,1,0,0,0,2093,2094,1,0,0,0,2094,2113,1, - 0,0,0,2095,2093,1,0,0,0,2096,2097,5,255,0,0,2097,2098,5,256,0,0,2098,2099, - 3,2,1,0,2099,2100,5,28,0,0,2100,2104,3,124,62,0,2101,2103,3,322,161,0, - 2102,2101,1,0,0,0,2103,2106,1,0,0,0,2104,2102,1,0,0,0,2104,2105,1,0,0, - 0,2105,2113,1,0,0,0,2106,2104,1,0,0,0,2107,2108,5,120,0,0,2108,2109,5, - 196,0,0,2109,2110,3,124,62,0,2110,2111,3,44,22,0,2111,2113,1,0,0,0,2112, - 1996,1,0,0,0,2112,2001,1,0,0,0,2112,2006,1,0,0,0,2112,2011,1,0,0,0,2112, - 2016,1,0,0,0,2112,2017,1,0,0,0,2112,2018,1,0,0,0,2112,2019,1,0,0,0,2112, - 2020,1,0,0,0,2112,2021,1,0,0,0,2112,2023,1,0,0,0,2112,2025,1,0,0,0,2112, - 2030,1,0,0,0,2112,2042,1,0,0,0,2112,2061,1,0,0,0,2112,2062,1,0,0,0,2112, - 2063,1,0,0,0,2112,2074,1,0,0,0,2112,2083,1,0,0,0,2112,2096,1,0,0,0,2112, - 2107,1,0,0,0,2113,199,1,0,0,0,2114,2115,5,121,0,0,2115,2124,3,208,104, - 0,2116,2123,3,202,101,0,2117,2118,5,122,0,0,2118,2119,5,30,0,0,2119,2120, - 3,228,114,0,2120,2121,5,31,0,0,2121,2123,1,0,0,0,2122,2116,1,0,0,0,2122, - 2117,1,0,0,0,2123,2126,1,0,0,0,2124,2122,1,0,0,0,2124,2125,1,0,0,0,2125, - 2127,1,0,0,0,2126,2124,1,0,0,0,2127,2128,3,138,69,0,2128,2129,3,2,1,0, - 2129,2130,3,204,102,0,2130,2131,3,206,103,0,2131,201,1,0,0,0,2132,2152, - 5,123,0,0,2133,2152,5,51,0,0,2134,2152,5,52,0,0,2135,2152,5,63,0,0,2136, - 2152,5,124,0,0,2137,2152,5,69,0,0,2138,2152,5,68,0,0,2139,2152,5,64,0, - 0,2140,2152,5,65,0,0,2141,2152,5,66,0,0,2142,2152,5,125,0,0,2143,2152, - 5,126,0,0,2144,2152,5,127,0,0,2145,2152,5,16,0,0,2146,2147,5,70,0,0,2147, - 2148,5,30,0,0,2148,2149,3,32,16,0,2149,2150,5,31,0,0,2150,2152,1,0,0,0, - 2151,2132,1,0,0,0,2151,2133,1,0,0,0,2151,2134,1,0,0,0,2151,2135,1,0,0, - 0,2151,2136,1,0,0,0,2151,2137,1,0,0,0,2151,2138,1,0,0,0,2151,2139,1,0, - 0,0,2151,2140,1,0,0,0,2151,2141,1,0,0,0,2151,2142,1,0,0,0,2151,2143,1, - 0,0,0,2151,2144,1,0,0,0,2151,2145,1,0,0,0,2151,2146,1,0,0,0,2152,203,1, - 0,0,0,2153,2159,1,0,0,0,2154,2155,5,44,0,0,2155,2159,3,0,0,0,2156,2157, - 5,44,0,0,2157,2159,3,32,16,0,2158,2153,1,0,0,0,2158,2154,1,0,0,0,2158, - 2156,1,0,0,0,2159,205,1,0,0,0,2160,2164,1,0,0,0,2161,2162,5,36,0,0,2162, - 2164,3,296,148,0,2163,2160,1,0,0,0,2163,2161,1,0,0,0,2164,207,1,0,0,0, - 2165,2171,1,0,0,0,2166,2167,5,42,0,0,2167,2168,3,32,16,0,2168,2169,5,43, - 0,0,2169,2171,1,0,0,0,2170,2165,1,0,0,0,2170,2166,1,0,0,0,2171,209,1,0, - 0,0,2172,2176,5,128,0,0,2173,2175,3,212,106,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,2180,3,124,62,0,2180,2181,3,2,1,0,2181,2191,1,0,0,0,2182, - 2186,5,128,0,0,2183,2185,3,212,106,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,2,1,0,2190,2172,1,0,0,0,2190,2182,1,0,0,0,2191,211,1,0, - 0,0,2192,2193,7,10,0,0,2193,213,1,0,0,0,2194,2196,3,216,108,0,2195,2194, - 1,0,0,0,2196,2199,1,0,0,0,2197,2195,1,0,0,0,2197,2198,1,0,0,0,2198,215, - 1,0,0,0,2199,2197,1,0,0,0,2200,2201,5,129,0,0,2201,2213,3,168,84,0,2202, - 2203,5,130,0,0,2203,2213,3,168,84,0,2204,2205,5,131,0,0,2205,2213,3,168, - 84,0,2206,2207,5,132,0,0,2207,2213,3,168,84,0,2208,2213,3,88,44,0,2209, - 2213,3,322,161,0,2210,2213,3,26,13,0,2211,2213,3,40,20,0,2212,2200,1,0, - 0,0,2212,2202,1,0,0,0,2212,2204,1,0,0,0,2212,2206,1,0,0,0,2212,2208,1, - 0,0,0,2212,2209,1,0,0,0,2212,2210,1,0,0,0,2212,2211,1,0,0,0,2213,217,1, - 0,0,0,2214,2218,5,133,0,0,2215,2217,3,220,110,0,2216,2215,1,0,0,0,2217, - 2220,1,0,0,0,2218,2216,1,0,0,0,2218,2219,1,0,0,0,2219,2221,1,0,0,0,2220, - 2218,1,0,0,0,2221,2222,3,170,85,0,2222,2223,3,138,69,0,2223,2224,3,2,1, - 0,2224,2225,3,112,56,0,2225,2226,3,206,103,0,2226,219,1,0,0,0,2227,2228, - 7,10,0,0,2228,221,1,0,0,0,2229,2231,3,224,112,0,2230,2229,1,0,0,0,2231, - 2234,1,0,0,0,2232,2230,1,0,0,0,2232,2233,1,0,0,0,2233,223,1,0,0,0,2234, - 2232,1,0,0,0,2235,2236,5,134,0,0,2236,2246,3,168,84,0,2237,2238,5,135, - 0,0,2238,2246,3,168,84,0,2239,2240,5,132,0,0,2240,2246,3,168,84,0,2241, - 2246,3,322,161,0,2242,2246,3,88,44,0,2243,2246,3,26,13,0,2244,2246,3,40, - 20,0,2245,2235,1,0,0,0,2245,2237,1,0,0,0,2245,2239,1,0,0,0,2245,2241,1, - 0,0,0,2245,2242,1,0,0,0,2245,2243,1,0,0,0,2245,2244,1,0,0,0,2246,225,1, - 0,0,0,2247,2255,6,113,-1,0,2248,2249,5,122,0,0,2249,2250,5,30,0,0,2250, - 2251,3,228,114,0,2251,2252,5,31,0,0,2252,2253,6,113,-1,0,2253,2255,1,0, - 0,0,2254,2247,1,0,0,0,2254,2248,1,0,0,0,2255,227,1,0,0,0,2256,2257,3,126, - 63,0,2257,2258,6,114,-1,0,2258,2270,1,0,0,0,2259,2263,5,17,0,0,2260,2261, - 3,294,147,0,2261,2262,6,114,-1,0,2262,2264,1,0,0,0,2263,2260,1,0,0,0,2264, - 2265,1,0,0,0,2265,2263,1,0,0,0,2265,2266,1,0,0,0,2266,2267,1,0,0,0,2267, - 2268,5,18,0,0,2268,2270,1,0,0,0,2269,2256,1,0,0,0,2269,2259,1,0,0,0,2270, - 229,1,0,0,0,2271,2272,3,232,116,0,2272,2273,6,115,-1,0,2273,2275,1,0,0, - 0,2274,2271,1,0,0,0,2275,2278,1,0,0,0,2276,2274,1,0,0,0,2276,2277,1,0, - 0,0,2277,231,1,0,0,0,2278,2276,1,0,0,0,2279,2280,5,42,0,0,2280,2281,5, - 136,0,0,2281,2282,5,43,0,0,2282,2297,6,116,-1,0,2283,2284,5,42,0,0,2284, - 2285,5,137,0,0,2285,2286,5,43,0,0,2286,2297,6,116,-1,0,2287,2288,5,42, - 0,0,2288,2289,5,138,0,0,2289,2290,5,43,0,0,2290,2297,6,116,-1,0,2291,2292, - 5,42,0,0,2292,2293,3,32,16,0,2293,2294,5,43,0,0,2294,2295,6,116,-1,0,2295, - 2297,1,0,0,0,2296,2279,1,0,0,0,2296,2283,1,0,0,0,2296,2287,1,0,0,0,2296, - 2291,1,0,0,0,2297,233,1,0,0,0,2298,2303,5,139,0,0,2299,2302,3,236,118, - 0,2300,2302,3,238,119,0,2301,2299,1,0,0,0,2301,2300,1,0,0,0,2302,2305, - 1,0,0,0,2303,2301,1,0,0,0,2303,2304,1,0,0,0,2304,2306,1,0,0,0,2305,2303, - 1,0,0,0,2306,2307,3,170,85,0,2307,2308,3,230,115,0,2308,2309,3,138,69, - 0,2309,2310,3,226,113,0,2310,2311,3,242,121,0,2311,2312,3,182,91,0,2312, - 2316,3,112,56,0,2313,2315,3,244,122,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,235,1,0,0,0,2318,2316,1,0, - 0,0,2319,2343,5,123,0,0,2320,2343,5,51,0,0,2321,2343,5,52,0,0,2322,2343, - 5,63,0,0,2323,2343,5,140,0,0,2324,2343,5,68,0,0,2325,2343,5,141,0,0,2326, - 2343,5,142,0,0,2327,2343,5,54,0,0,2328,2343,5,64,0,0,2329,2343,5,65,0, - 0,2330,2343,5,66,0,0,2331,2343,5,125,0,0,2332,2343,5,143,0,0,2333,2343, - 5,144,0,0,2334,2343,5,69,0,0,2335,2343,5,145,0,0,2336,2343,5,146,0,0,2337, - 2338,5,70,0,0,2338,2339,5,30,0,0,2339,2340,3,32,16,0,2340,2341,5,31,0, - 0,2341,2343,1,0,0,0,2342,2319,1,0,0,0,2342,2320,1,0,0,0,2342,2321,1,0, - 0,0,2342,2322,1,0,0,0,2342,2323,1,0,0,0,2342,2324,1,0,0,0,2342,2325,1, - 0,0,0,2342,2326,1,0,0,0,2342,2327,1,0,0,0,2342,2328,1,0,0,0,2342,2329, - 1,0,0,0,2342,2330,1,0,0,0,2342,2331,1,0,0,0,2342,2332,1,0,0,0,2342,2333, - 1,0,0,0,2342,2334,1,0,0,0,2342,2335,1,0,0,0,2342,2336,1,0,0,0,2342,2337, - 1,0,0,0,2343,237,1,0,0,0,2344,2345,5,147,0,0,2345,2351,5,30,0,0,2346,2349, - 3,6,3,0,2347,2348,5,34,0,0,2348,2350,3,6,3,0,2349,2347,1,0,0,0,2349,2350, - 1,0,0,0,2350,2352,1,0,0,0,2351,2346,1,0,0,0,2351,2352,1,0,0,0,2352,2356, - 1,0,0,0,2353,2355,3,240,120,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, - 2363,5,31,0,0,2360,2361,5,147,0,0,2361,2363,5,85,0,0,2362,2344,1,0,0,0, - 2362,2360,1,0,0,0,2363,239,1,0,0,0,2364,2392,5,148,0,0,2365,2392,5,224, - 0,0,2366,2392,5,57,0,0,2367,2392,5,58,0,0,2368,2392,5,149,0,0,2369,2392, - 5,150,0,0,2370,2392,5,248,0,0,2371,2392,5,249,0,0,2372,2392,5,250,0,0, - 2373,2392,5,251,0,0,2374,2375,5,151,0,0,2375,2376,5,75,0,0,2376,2392,5, - 152,0,0,2377,2378,5,151,0,0,2378,2379,5,75,0,0,2379,2392,5,153,0,0,2380, - 2381,5,154,0,0,2381,2382,5,75,0,0,2382,2392,5,152,0,0,2383,2384,5,154, - 0,0,2384,2385,5,75,0,0,2385,2392,5,153,0,0,2386,2387,5,70,0,0,2387,2388, - 5,30,0,0,2388,2389,3,32,16,0,2389,2390,5,31,0,0,2390,2392,1,0,0,0,2391, - 2364,1,0,0,0,2391,2365,1,0,0,0,2391,2366,1,0,0,0,2391,2367,1,0,0,0,2391, - 2368,1,0,0,0,2391,2369,1,0,0,0,2391,2370,1,0,0,0,2391,2371,1,0,0,0,2391, - 2372,1,0,0,0,2391,2373,1,0,0,0,2391,2374,1,0,0,0,2391,2377,1,0,0,0,2391, - 2380,1,0,0,0,2391,2383,1,0,0,0,2391,2386,1,0,0,0,2392,241,1,0,0,0,2393, - 2394,5,116,0,0,2394,2401,6,121,-1,0,2395,2396,5,155,0,0,2396,2401,6,121, - -1,0,2397,2398,3,2,1,0,2398,2399,6,121,-1,0,2399,2401,1,0,0,0,2400,2393, - 1,0,0,0,2400,2395,1,0,0,0,2400,2397,1,0,0,0,2401,243,1,0,0,0,2402,2424, - 5,1,0,0,2403,2424,5,2,0,0,2404,2424,5,156,0,0,2405,2424,5,3,0,0,2406,2424, - 5,4,0,0,2407,2424,5,247,0,0,2408,2424,5,5,0,0,2409,2424,5,6,0,0,2410,2424, - 5,7,0,0,2411,2424,5,8,0,0,2412,2424,5,9,0,0,2413,2424,5,10,0,0,2414,2424, - 5,11,0,0,2415,2424,5,12,0,0,2416,2424,5,13,0,0,2417,2424,5,14,0,0,2418, - 2419,5,70,0,0,2419,2420,5,30,0,0,2420,2421,3,32,16,0,2421,2422,5,31,0, - 0,2422,2424,1,0,0,0,2423,2402,1,0,0,0,2423,2403,1,0,0,0,2423,2404,1,0, - 0,0,2423,2405,1,0,0,0,2423,2406,1,0,0,0,2423,2407,1,0,0,0,2423,2408,1, - 0,0,0,2423,2409,1,0,0,0,2423,2410,1,0,0,0,2423,2411,1,0,0,0,2423,2412, - 1,0,0,0,2423,2413,1,0,0,0,2423,2414,1,0,0,0,2423,2415,1,0,0,0,2423,2416, - 1,0,0,0,2423,2417,1,0,0,0,2423,2418,1,0,0,0,2424,245,1,0,0,0,2425,2427, - 3,248,124,0,2426,2425,1,0,0,0,2427,2430,1,0,0,0,2428,2426,1,0,0,0,2428, - 2429,1,0,0,0,2429,247,1,0,0,0,2430,2428,1,0,0,0,2431,2449,3,100,50,0,2432, - 2433,5,296,0,0,2433,2434,3,32,16,0,2434,2435,6,124,-1,0,2435,2449,1,0, - 0,0,2436,2449,3,258,129,0,2437,2438,5,297,0,0,2438,2439,3,32,16,0,2439, - 2440,6,124,-1,0,2440,2449,1,0,0,0,2441,2442,5,298,0,0,2442,2449,6,124, - -1,0,2443,2444,5,299,0,0,2444,2449,6,124,-1,0,2445,2449,3,252,126,0,2446, - 2449,3,256,128,0,2447,2449,3,250,125,0,2448,2431,1,0,0,0,2448,2432,1,0, - 0,0,2448,2436,1,0,0,0,2448,2437,1,0,0,0,2448,2441,1,0,0,0,2448,2443,1, - 0,0,0,2448,2445,1,0,0,0,2448,2446,1,0,0,0,2448,2447,1,0,0,0,2449,249,1, - 0,0,0,2450,2451,5,300,0,0,2451,2549,3,112,56,0,2452,2453,5,300,0,0,2453, - 2454,5,157,0,0,2454,2549,3,112,56,0,2455,2549,3,276,138,0,2456,2549,3, - 152,76,0,2457,2549,3,88,44,0,2458,2549,3,26,13,0,2459,2549,3,254,127,0, - 2460,2549,3,40,20,0,2461,2462,5,301,0,0,2462,2463,5,42,0,0,2463,2464,3, - 32,16,0,2464,2465,5,43,0,0,2465,2549,1,0,0,0,2466,2467,5,301,0,0,2467, - 2468,5,42,0,0,2468,2469,3,32,16,0,2469,2470,5,43,0,0,2470,2471,5,34,0, - 0,2471,2472,3,0,0,0,2472,2549,1,0,0,0,2473,2474,5,303,0,0,2474,2475,3, - 32,16,0,2475,2476,5,75,0,0,2476,2477,3,32,16,0,2477,2549,1,0,0,0,2478, - 2479,5,302,0,0,2479,2480,3,124,62,0,2480,2481,5,176,0,0,2481,2482,3,242, - 121,0,2482,2549,1,0,0,0,2483,2484,5,302,0,0,2484,2485,5,226,0,0,2485,2486, - 3,170,85,0,2486,2487,3,138,69,0,2487,2488,3,124,62,0,2488,2489,5,176,0, - 0,2489,2490,3,242,121,0,2490,2491,3,194,97,0,2491,2492,3,112,56,0,2492, - 2549,1,0,0,0,2493,2494,5,255,0,0,2494,2495,5,196,0,0,2495,2496,5,42,0, - 0,2496,2497,3,32,16,0,2497,2501,5,43,0,0,2498,2500,3,322,161,0,2499,2498, - 1,0,0,0,2500,2503,1,0,0,0,2501,2499,1,0,0,0,2501,2502,1,0,0,0,2502,2549, - 1,0,0,0,2503,2501,1,0,0,0,2504,2505,5,255,0,0,2505,2506,5,196,0,0,2506, - 2510,3,2,1,0,2507,2509,3,322,161,0,2508,2507,1,0,0,0,2509,2512,1,0,0,0, - 2510,2508,1,0,0,0,2510,2511,1,0,0,0,2511,2549,1,0,0,0,2512,2510,1,0,0, - 0,2513,2514,5,255,0,0,2514,2515,5,256,0,0,2515,2516,5,42,0,0,2516,2517, - 3,32,16,0,2517,2518,5,43,0,0,2518,2519,5,28,0,0,2519,2523,3,124,62,0,2520, - 2522,3,322,161,0,2521,2520,1,0,0,0,2522,2525,1,0,0,0,2523,2521,1,0,0,0, - 2523,2524,1,0,0,0,2524,2549,1,0,0,0,2525,2523,1,0,0,0,2526,2527,5,255, - 0,0,2527,2528,5,256,0,0,2528,2529,3,2,1,0,2529,2530,5,28,0,0,2530,2534, - 3,124,62,0,2531,2533,3,322,161,0,2532,2531,1,0,0,0,2533,2536,1,0,0,0,2534, - 2532,1,0,0,0,2534,2535,1,0,0,0,2535,2549,1,0,0,0,2536,2534,1,0,0,0,2537, - 2538,5,255,0,0,2538,2539,5,42,0,0,2539,2540,3,32,16,0,2540,2541,5,43,0, - 0,2541,2545,3,206,103,0,2542,2544,3,322,161,0,2543,2542,1,0,0,0,2544,2547, - 1,0,0,0,2545,2543,1,0,0,0,2545,2546,1,0,0,0,2546,2549,1,0,0,0,2547,2545, - 1,0,0,0,2548,2450,1,0,0,0,2548,2452,1,0,0,0,2548,2455,1,0,0,0,2548,2456, - 1,0,0,0,2548,2457,1,0,0,0,2548,2458,1,0,0,0,2548,2459,1,0,0,0,2548,2460, - 1,0,0,0,2548,2461,1,0,0,0,2548,2466,1,0,0,0,2548,2473,1,0,0,0,2548,2478, - 1,0,0,0,2548,2483,1,0,0,0,2548,2493,1,0,0,0,2548,2504,1,0,0,0,2548,2513, - 1,0,0,0,2548,2526,1,0,0,0,2548,2537,1,0,0,0,2549,251,1,0,0,0,2550,2551, - 3,0,0,0,2551,2552,5,75,0,0,2552,2553,6,126,-1,0,2553,253,1,0,0,0,2554, - 2557,3,44,22,0,2555,2557,3,46,23,0,2556,2554,1,0,0,0,2556,2555,1,0,0,0, - 2557,255,1,0,0,0,2558,2559,5,17,0,0,2559,2560,3,246,123,0,2560,2561,5, - 18,0,0,2561,257,1,0,0,0,2562,2563,3,262,131,0,2563,2564,3,260,130,0,2564, - 259,1,0,0,0,2565,2567,3,264,132,0,2566,2565,1,0,0,0,2567,2568,1,0,0,0, - 2568,2566,1,0,0,0,2568,2569,1,0,0,0,2569,261,1,0,0,0,2570,2571,5,158,0, - 0,2571,2583,3,256,128,0,2572,2573,5,158,0,0,2573,2574,3,0,0,0,2574,2575, - 5,159,0,0,2575,2576,3,0,0,0,2576,2583,1,0,0,0,2577,2578,5,158,0,0,2578, - 2579,3,32,16,0,2579,2580,5,159,0,0,2580,2581,3,32,16,0,2581,2583,1,0,0, - 0,2582,2570,1,0,0,0,2582,2572,1,0,0,0,2582,2577,1,0,0,0,2583,263,1,0,0, - 0,2584,2585,3,268,134,0,2585,2586,3,274,137,0,2586,2597,1,0,0,0,2587,2588, - 3,266,133,0,2588,2589,3,274,137,0,2589,2597,1,0,0,0,2590,2591,3,270,135, - 0,2591,2592,3,274,137,0,2592,2597,1,0,0,0,2593,2594,3,272,136,0,2594,2595, - 3,274,137,0,2595,2597,1,0,0,0,2596,2584,1,0,0,0,2596,2587,1,0,0,0,2596, - 2590,1,0,0,0,2596,2593,1,0,0,0,2597,265,1,0,0,0,2598,2599,5,160,0,0,2599, - 2605,3,256,128,0,2600,2601,5,160,0,0,2601,2605,3,0,0,0,2602,2603,5,160, - 0,0,2603,2605,3,32,16,0,2604,2598,1,0,0,0,2604,2600,1,0,0,0,2604,2602, - 1,0,0,0,2605,267,1,0,0,0,2606,2607,5,161,0,0,2607,2608,3,124,62,0,2608, - 269,1,0,0,0,2609,2610,5,162,0,0,2610,271,1,0,0,0,2611,2612,5,163,0,0,2612, - 273,1,0,0,0,2613,2625,3,256,128,0,2614,2615,5,164,0,0,2615,2616,3,0,0, - 0,2616,2617,5,159,0,0,2617,2618,3,0,0,0,2618,2625,1,0,0,0,2619,2620,5, - 164,0,0,2620,2621,3,32,16,0,2621,2622,5,159,0,0,2622,2623,3,32,16,0,2623, - 2625,1,0,0,0,2624,2613,1,0,0,0,2624,2614,1,0,0,0,2624,2619,1,0,0,0,2625, - 275,1,0,0,0,2626,2627,3,278,139,0,2627,2628,3,282,141,0,2628,277,1,0,0, - 0,2629,2630,5,165,0,0,2630,2631,3,280,140,0,2631,2632,3,0,0,0,2632,2633, - 5,36,0,0,2633,2637,1,0,0,0,2634,2635,5,165,0,0,2635,2637,3,280,140,0,2636, - 2629,1,0,0,0,2636,2634,1,0,0,0,2637,279,1,0,0,0,2638,2642,1,0,0,0,2639, - 2642,5,166,0,0,2640,2642,5,2,0,0,2641,2638,1,0,0,0,2641,2639,1,0,0,0,2641, - 2640,1,0,0,0,2642,281,1,0,0,0,2643,2644,5,17,0,0,2644,2645,3,284,142,0, - 2645,2646,5,18,0,0,2646,2653,1,0,0,0,2647,2649,3,288,144,0,2648,2647,1, - 0,0,0,2649,2650,1,0,0,0,2650,2648,1,0,0,0,2650,2651,1,0,0,0,2651,2653, - 1,0,0,0,2652,2643,1,0,0,0,2652,2648,1,0,0,0,2653,283,1,0,0,0,2654,2655, - 3,288,144,0,2655,2656,5,28,0,0,2656,2658,1,0,0,0,2657,2654,1,0,0,0,2658, - 2661,1,0,0,0,2659,2657,1,0,0,0,2659,2660,1,0,0,0,2660,2662,1,0,0,0,2661, - 2659,1,0,0,0,2662,2663,3,288,144,0,2663,285,1,0,0,0,2664,2670,1,0,0,0, - 2665,2666,5,42,0,0,2666,2667,3,32,16,0,2667,2668,5,43,0,0,2668,2670,1, - 0,0,0,2669,2664,1,0,0,0,2669,2665,1,0,0,0,2670,287,1,0,0,0,2671,2672,5, - 181,0,0,2672,2673,5,262,0,0,2673,2674,5,30,0,0,2674,2675,3,6,3,0,2675, - 2676,5,31,0,0,2676,2738,1,0,0,0,2677,2678,5,260,0,0,2678,2679,5,30,0,0, - 2679,2680,3,0,0,0,2680,2681,5,31,0,0,2681,2738,1,0,0,0,2682,2683,5,260, - 0,0,2683,2738,3,0,0,0,2684,2685,5,84,0,0,2685,2686,5,30,0,0,2686,2687, - 3,292,146,0,2687,2688,5,31,0,0,2688,2738,1,0,0,0,2689,2690,5,188,0,0,2690, - 2691,5,30,0,0,2691,2692,3,36,18,0,2692,2693,5,31,0,0,2693,2694,3,286,143, - 0,2694,2738,1,0,0,0,2695,2696,5,189,0,0,2696,2697,5,30,0,0,2697,2698,3, - 36,18,0,2698,2699,5,31,0,0,2699,2700,3,286,143,0,2700,2738,1,0,0,0,2701, - 2702,5,187,0,0,2702,2703,5,30,0,0,2703,2704,3,34,17,0,2704,2705,5,31,0, - 0,2705,2706,3,286,143,0,2706,2738,1,0,0,0,2707,2708,5,186,0,0,2708,2709, - 5,30,0,0,2709,2710,3,32,16,0,2710,2711,5,31,0,0,2711,2712,3,286,143,0, - 2712,2738,1,0,0,0,2713,2714,5,185,0,0,2714,2715,5,30,0,0,2715,2716,3,32, - 16,0,2716,2717,5,31,0,0,2717,2718,3,286,143,0,2718,2738,1,0,0,0,2719,2720, - 5,184,0,0,2720,2721,5,30,0,0,2721,2722,3,32,16,0,2722,2723,5,31,0,0,2723, - 2724,3,286,143,0,2724,2738,1,0,0,0,2725,2726,5,188,0,0,2726,2738,3,286, - 143,0,2727,2728,5,189,0,0,2728,2738,3,286,143,0,2729,2730,5,187,0,0,2730, - 2738,3,286,143,0,2731,2732,5,186,0,0,2732,2738,3,286,143,0,2733,2734,5, - 185,0,0,2734,2738,3,286,143,0,2735,2736,5,184,0,0,2736,2738,3,286,143, - 0,2737,2671,1,0,0,0,2737,2677,1,0,0,0,2737,2682,1,0,0,0,2737,2684,1,0, - 0,0,2737,2689,1,0,0,0,2737,2695,1,0,0,0,2737,2701,1,0,0,0,2737,2707,1, - 0,0,0,2737,2713,1,0,0,0,2737,2719,1,0,0,0,2737,2725,1,0,0,0,2737,2727, - 1,0,0,0,2737,2729,1,0,0,0,2737,2731,1,0,0,0,2737,2733,1,0,0,0,2737,2735, - 1,0,0,0,2738,289,1,0,0,0,2739,2740,5,188,0,0,2740,2741,5,30,0,0,2741,2742, - 3,36,18,0,2742,2743,5,31,0,0,2743,2815,1,0,0,0,2744,2745,5,189,0,0,2745, - 2746,5,30,0,0,2746,2747,3,36,18,0,2747,2748,5,31,0,0,2748,2815,1,0,0,0, - 2749,2750,5,188,0,0,2750,2751,5,30,0,0,2751,2752,3,32,16,0,2752,2753,5, - 31,0,0,2753,2815,1,0,0,0,2754,2755,5,189,0,0,2755,2756,5,30,0,0,2756,2757, - 3,34,17,0,2757,2758,5,31,0,0,2758,2815,1,0,0,0,2759,2760,5,187,0,0,2760, - 2761,5,30,0,0,2761,2762,3,34,17,0,2762,2763,5,31,0,0,2763,2815,1,0,0,0, - 2764,2765,5,186,0,0,2765,2766,5,30,0,0,2766,2767,3,32,16,0,2767,2768,5, - 31,0,0,2768,2815,1,0,0,0,2769,2770,5,185,0,0,2770,2771,5,30,0,0,2771,2772, - 3,32,16,0,2772,2773,5,31,0,0,2773,2815,1,0,0,0,2774,2775,5,184,0,0,2775, - 2776,5,30,0,0,2776,2777,3,32,16,0,2777,2778,5,31,0,0,2778,2815,1,0,0,0, - 2779,2780,5,193,0,0,2780,2781,5,30,0,0,2781,2782,3,34,17,0,2782,2783,5, - 31,0,0,2783,2815,1,0,0,0,2784,2785,5,192,0,0,2785,2786,5,30,0,0,2786,2787, - 3,32,16,0,2787,2788,5,31,0,0,2788,2815,1,0,0,0,2789,2790,5,191,0,0,2790, - 2791,5,30,0,0,2791,2792,3,32,16,0,2792,2793,5,31,0,0,2793,2815,1,0,0,0, - 2794,2795,5,190,0,0,2795,2796,5,30,0,0,2796,2797,3,32,16,0,2797,2798,5, - 31,0,0,2798,2815,1,0,0,0,2799,2800,5,181,0,0,2800,2801,5,30,0,0,2801,2802, - 3,32,16,0,2802,2803,5,31,0,0,2803,2815,1,0,0,0,2804,2805,5,183,0,0,2805, - 2806,5,30,0,0,2806,2807,3,162,81,0,2807,2808,5,31,0,0,2808,2815,1,0,0, - 0,2809,2810,5,84,0,0,2810,2811,5,30,0,0,2811,2812,3,292,146,0,2812,2813, - 5,31,0,0,2813,2815,1,0,0,0,2814,2739,1,0,0,0,2814,2744,1,0,0,0,2814,2749, - 1,0,0,0,2814,2754,1,0,0,0,2814,2759,1,0,0,0,2814,2764,1,0,0,0,2814,2769, - 1,0,0,0,2814,2774,1,0,0,0,2814,2779,1,0,0,0,2814,2784,1,0,0,0,2814,2789, - 1,0,0,0,2814,2794,1,0,0,0,2814,2799,1,0,0,0,2814,2804,1,0,0,0,2814,2809, - 1,0,0,0,2815,291,1,0,0,0,2816,2817,3,294,147,0,2817,2818,6,146,-1,0,2818, - 2820,1,0,0,0,2819,2816,1,0,0,0,2820,2823,1,0,0,0,2821,2819,1,0,0,0,2821, - 2822,1,0,0,0,2822,293,1,0,0,0,2823,2821,1,0,0,0,2824,2825,7,11,0,0,2825, - 295,1,0,0,0,2826,2830,3,290,145,0,2827,2830,3,6,3,0,2828,2830,5,179,0, - 0,2829,2826,1,0,0,0,2829,2827,1,0,0,0,2829,2828,1,0,0,0,2830,297,1,0,0, - 0,2831,2980,3,290,145,0,2832,2833,5,182,0,0,2833,2834,5,30,0,0,2834,2835, - 5,179,0,0,2835,2980,5,31,0,0,2836,2837,5,182,0,0,2837,2838,5,30,0,0,2838, - 2839,5,264,0,0,2839,2980,5,31,0,0,2840,2841,5,196,0,0,2841,2842,5,30,0, - 0,2842,2843,5,39,0,0,2843,2844,5,264,0,0,2844,2980,5,31,0,0,2845,2846, - 5,196,0,0,2846,2847,5,30,0,0,2847,2848,3,116,58,0,2848,2849,5,31,0,0,2849, - 2980,1,0,0,0,2850,2851,5,196,0,0,2851,2852,5,30,0,0,2852,2853,5,179,0, - 0,2853,2980,5,31,0,0,2854,2855,5,197,0,0,2855,2856,5,30,0,0,2856,2857, - 3,298,149,0,2857,2858,5,31,0,0,2858,2980,1,0,0,0,2859,2860,5,188,0,0,2860, - 2861,5,42,0,0,2861,2862,3,32,16,0,2862,2863,5,43,0,0,2863,2864,5,30,0, - 0,2864,2865,3,300,150,0,2865,2866,5,31,0,0,2866,2980,1,0,0,0,2867,2868, - 5,189,0,0,2868,2869,5,42,0,0,2869,2870,3,32,16,0,2870,2871,5,43,0,0,2871, - 2872,5,30,0,0,2872,2873,3,302,151,0,2873,2874,5,31,0,0,2874,2980,1,0,0, - 0,2875,2876,5,187,0,0,2876,2877,5,42,0,0,2877,2878,3,32,16,0,2878,2879, - 5,43,0,0,2879,2880,5,30,0,0,2880,2881,3,304,152,0,2881,2882,5,31,0,0,2882, - 2980,1,0,0,0,2883,2884,5,186,0,0,2884,2885,5,42,0,0,2885,2886,3,32,16, - 0,2886,2887,5,43,0,0,2887,2888,5,30,0,0,2888,2889,3,306,153,0,2889,2890, - 5,31,0,0,2890,2980,1,0,0,0,2891,2892,5,185,0,0,2892,2893,5,42,0,0,2893, - 2894,3,32,16,0,2894,2895,5,43,0,0,2895,2896,5,30,0,0,2896,2897,3,308,154, - 0,2897,2898,5,31,0,0,2898,2980,1,0,0,0,2899,2900,5,184,0,0,2900,2901,5, - 42,0,0,2901,2902,3,32,16,0,2902,2903,5,43,0,0,2903,2904,5,30,0,0,2904, - 2905,3,310,155,0,2905,2906,5,31,0,0,2906,2980,1,0,0,0,2907,2908,5,193, - 0,0,2908,2909,5,42,0,0,2909,2910,3,32,16,0,2910,2911,5,43,0,0,2911,2912, - 5,30,0,0,2912,2913,3,304,152,0,2913,2914,5,31,0,0,2914,2980,1,0,0,0,2915, - 2916,5,192,0,0,2916,2917,5,42,0,0,2917,2918,3,32,16,0,2918,2919,5,43,0, - 0,2919,2920,5,30,0,0,2920,2921,3,306,153,0,2921,2922,5,31,0,0,2922,2980, - 1,0,0,0,2923,2924,5,191,0,0,2924,2925,5,42,0,0,2925,2926,3,32,16,0,2926, - 2927,5,43,0,0,2927,2928,5,30,0,0,2928,2929,3,308,154,0,2929,2930,5,31, - 0,0,2930,2980,1,0,0,0,2931,2932,5,190,0,0,2932,2933,5,42,0,0,2933,2934, - 3,32,16,0,2934,2935,5,43,0,0,2935,2936,5,30,0,0,2936,2937,3,310,155,0, - 2937,2938,5,31,0,0,2938,2980,1,0,0,0,2939,2940,5,181,0,0,2940,2941,5,42, - 0,0,2941,2942,3,32,16,0,2942,2943,5,43,0,0,2943,2944,5,30,0,0,2944,2945, - 3,308,154,0,2945,2946,5,31,0,0,2946,2980,1,0,0,0,2947,2948,5,183,0,0,2948, - 2949,5,42,0,0,2949,2950,3,32,16,0,2950,2951,5,43,0,0,2951,2952,5,30,0, - 0,2952,2953,3,312,156,0,2953,2954,5,31,0,0,2954,2980,1,0,0,0,2955,2956, - 5,182,0,0,2956,2957,5,42,0,0,2957,2958,3,32,16,0,2958,2959,5,43,0,0,2959, - 2960,5,30,0,0,2960,2961,3,314,157,0,2961,2962,5,31,0,0,2962,2980,1,0,0, - 0,2963,2964,5,196,0,0,2964,2965,5,42,0,0,2965,2966,3,32,16,0,2966,2967, - 5,43,0,0,2967,2968,5,30,0,0,2968,2969,3,316,158,0,2969,2970,5,31,0,0,2970, - 2980,1,0,0,0,2971,2972,5,197,0,0,2972,2973,5,42,0,0,2973,2974,3,32,16, - 0,2974,2975,5,43,0,0,2975,2976,5,30,0,0,2976,2977,3,320,160,0,2977,2978, - 5,31,0,0,2978,2980,1,0,0,0,2979,2831,1,0,0,0,2979,2832,1,0,0,0,2979,2836, - 1,0,0,0,2979,2840,1,0,0,0,2979,2845,1,0,0,0,2979,2850,1,0,0,0,2979,2854, - 1,0,0,0,2979,2859,1,0,0,0,2979,2867,1,0,0,0,2979,2875,1,0,0,0,2979,2883, - 1,0,0,0,2979,2891,1,0,0,0,2979,2899,1,0,0,0,2979,2907,1,0,0,0,2979,2915, - 1,0,0,0,2979,2923,1,0,0,0,2979,2931,1,0,0,0,2979,2939,1,0,0,0,2979,2947, - 1,0,0,0,2979,2955,1,0,0,0,2979,2963,1,0,0,0,2979,2971,1,0,0,0,2980,299, - 1,0,0,0,2981,2984,3,36,18,0,2982,2984,3,32,16,0,2983,2981,1,0,0,0,2983, - 2982,1,0,0,0,2984,2987,1,0,0,0,2985,2983,1,0,0,0,2985,2986,1,0,0,0,2986, - 301,1,0,0,0,2987,2985,1,0,0,0,2988,2991,3,36,18,0,2989,2991,3,34,17,0, - 2990,2988,1,0,0,0,2990,2989,1,0,0,0,2991,2994,1,0,0,0,2992,2990,1,0,0, - 0,2992,2993,1,0,0,0,2993,303,1,0,0,0,2994,2992,1,0,0,0,2995,2997,3,34, - 17,0,2996,2995,1,0,0,0,2997,3000,1,0,0,0,2998,2996,1,0,0,0,2998,2999,1, - 0,0,0,2999,305,1,0,0,0,3000,2998,1,0,0,0,3001,3003,3,32,16,0,3002,3001, - 1,0,0,0,3003,3006,1,0,0,0,3004,3002,1,0,0,0,3004,3005,1,0,0,0,3005,307, - 1,0,0,0,3006,3004,1,0,0,0,3007,3009,3,32,16,0,3008,3007,1,0,0,0,3009,3012, - 1,0,0,0,3010,3008,1,0,0,0,3010,3011,1,0,0,0,3011,309,1,0,0,0,3012,3010, - 1,0,0,0,3013,3015,3,32,16,0,3014,3013,1,0,0,0,3015,3018,1,0,0,0,3016,3014, - 1,0,0,0,3016,3017,1,0,0,0,3017,311,1,0,0,0,3018,3016,1,0,0,0,3019,3021, - 3,162,81,0,3020,3019,1,0,0,0,3021,3024,1,0,0,0,3022,3020,1,0,0,0,3022, - 3023,1,0,0,0,3023,313,1,0,0,0,3024,3022,1,0,0,0,3025,3027,7,12,0,0,3026, - 3025,1,0,0,0,3027,3030,1,0,0,0,3028,3026,1,0,0,0,3028,3029,1,0,0,0,3029, - 315,1,0,0,0,3030,3028,1,0,0,0,3031,3033,3,318,159,0,3032,3031,1,0,0,0, - 3033,3036,1,0,0,0,3034,3032,1,0,0,0,3034,3035,1,0,0,0,3035,317,1,0,0,0, - 3036,3034,1,0,0,0,3037,3042,5,179,0,0,3038,3039,5,39,0,0,3039,3042,5,264, - 0,0,3040,3042,3,116,58,0,3041,3037,1,0,0,0,3041,3038,1,0,0,0,3041,3040, - 1,0,0,0,3042,319,1,0,0,0,3043,3045,3,298,149,0,3044,3043,1,0,0,0,3045, - 3048,1,0,0,0,3046,3044,1,0,0,0,3046,3047,1,0,0,0,3047,321,1,0,0,0,3048, - 3046,1,0,0,0,3049,3053,3,44,22,0,3050,3053,3,46,23,0,3051,3053,3,2,1,0, - 3052,3049,1,0,0,0,3052,3050,1,0,0,0,3052,3051,1,0,0,0,3053,323,1,0,0,0, - 3054,3055,7,13,0,0,3055,3056,5,36,0,0,3056,3057,5,30,0,0,3057,3058,3,292, - 146,0,3058,3059,5,31,0,0,3059,3080,1,0,0,0,3060,3061,5,169,0,0,3061,3062, - 3,38,19,0,3062,3063,5,75,0,0,3063,3064,3,38,19,0,3064,3065,5,75,0,0,3065, - 3066,3,38,19,0,3066,3067,5,75,0,0,3067,3068,3,38,19,0,3068,3080,1,0,0, - 0,3069,3070,5,170,0,0,3070,3080,3,6,3,0,3071,3072,5,170,0,0,3072,3073, - 5,36,0,0,3073,3074,5,30,0,0,3074,3075,3,292,146,0,3075,3076,5,31,0,0,3076, - 3080,1,0,0,0,3077,3080,3,322,161,0,3078,3080,3,40,20,0,3079,3054,1,0,0, - 0,3079,3060,1,0,0,0,3079,3069,1,0,0,0,3079,3071,1,0,0,0,3079,3077,1,0, - 0,0,3079,3078,1,0,0,0,3080,325,1,0,0,0,3081,3082,5,25,0,0,3082,3083,5, - 40,0,0,3083,3084,3,98,49,0,3084,3085,3,2,1,0,3085,3094,1,0,0,0,3086,3087, - 5,25,0,0,3087,3088,5,40,0,0,3088,3089,3,98,49,0,3089,3090,3,2,1,0,3090, - 3091,5,34,0,0,3091,3092,3,2,1,0,3092,3094,1,0,0,0,3093,3081,1,0,0,0,3093, - 3086,1,0,0,0,3094,327,1,0,0,0,3095,3097,3,330,165,0,3096,3095,1,0,0,0, - 3097,3100,1,0,0,0,3098,3096,1,0,0,0,3098,3099,1,0,0,0,3099,329,1,0,0,0, - 3100,3098,1,0,0,0,3101,3102,5,180,0,0,3102,3103,5,36,0,0,3103,3104,5,30, - 0,0,3104,3105,3,292,146,0,3105,3106,5,31,0,0,3106,3116,1,0,0,0,3107,3116, - 3,324,162,0,3108,3109,5,171,0,0,3109,3110,5,36,0,0,3110,3111,5,30,0,0, - 3111,3112,3,292,146,0,3112,3113,5,31,0,0,3113,3116,1,0,0,0,3114,3116,5, - 55,0,0,3115,3101,1,0,0,0,3115,3107,1,0,0,0,3115,3108,1,0,0,0,3115,3114, - 1,0,0,0,3116,331,1,0,0,0,3117,3118,5,50,0,0,3118,3122,5,40,0,0,3119,3121, - 3,336,168,0,3120,3119,1,0,0,0,3121,3124,1,0,0,0,3122,3120,1,0,0,0,3122, - 3123,1,0,0,0,3123,3125,1,0,0,0,3124,3122,1,0,0,0,3125,3126,3,2,1,0,3126, - 333,1,0,0,0,3127,3131,5,301,0,0,3128,3130,3,336,168,0,3129,3128,1,0,0, - 0,3130,3133,1,0,0,0,3131,3129,1,0,0,0,3131,3132,1,0,0,0,3132,3134,1,0, - 0,0,3133,3131,1,0,0,0,3134,3135,3,2,1,0,3135,335,1,0,0,0,3136,3152,5,52, - 0,0,3137,3152,5,51,0,0,3138,3152,5,172,0,0,3139,3140,5,62,0,0,3140,3152, - 5,51,0,0,3141,3142,5,62,0,0,3142,3152,5,52,0,0,3143,3144,5,62,0,0,3144, - 3152,5,63,0,0,3145,3146,5,62,0,0,3146,3152,5,64,0,0,3147,3148,5,62,0,0, - 3148,3152,5,65,0,0,3149,3150,5,62,0,0,3150,3152,5,66,0,0,3151,3136,1,0, - 0,0,3151,3137,1,0,0,0,3151,3138,1,0,0,0,3151,3139,1,0,0,0,3151,3141,1, - 0,0,0,3151,3143,1,0,0,0,3151,3145,1,0,0,0,3151,3147,1,0,0,0,3151,3149, - 1,0,0,0,3152,337,1,0,0,0,3153,3155,3,340,170,0,3154,3153,1,0,0,0,3155, - 3158,1,0,0,0,3156,3154,1,0,0,0,3156,3157,1,0,0,0,3157,339,1,0,0,0,3158, - 3156,1,0,0,0,3159,3160,5,21,0,0,3160,3173,3,2,1,0,3161,3162,5,50,0,0,3162, - 3163,5,40,0,0,3163,3173,3,118,59,0,3164,3165,5,25,0,0,3165,3166,5,40,0, - 0,3166,3173,3,2,1,0,3167,3173,3,174,87,0,3168,3169,5,50,0,0,3169,3173, - 3,32,16,0,3170,3173,3,322,161,0,3171,3173,3,40,20,0,3172,3159,1,0,0,0, - 3172,3161,1,0,0,0,3172,3164,1,0,0,0,3172,3167,1,0,0,0,3172,3168,1,0,0, - 0,3172,3170,1,0,0,0,3172,3171,1,0,0,0,3173,341,1,0,0,0,3174,3178,5,274, - 0,0,3175,3177,3,344,172,0,3176,3175,1,0,0,0,3177,3180,1,0,0,0,3178,3176, - 1,0,0,0,3178,3179,1,0,0,0,3179,3181,1,0,0,0,3180,3178,1,0,0,0,3181,3194, - 3,2,1,0,3182,3186,5,274,0,0,3183,3185,3,344,172,0,3184,3183,1,0,0,0,3185, - 3188,1,0,0,0,3186,3184,1,0,0,0,3186,3187,1,0,0,0,3187,3189,1,0,0,0,3188, - 3186,1,0,0,0,3189,3190,3,2,1,0,3190,3191,5,34,0,0,3191,3192,3,2,1,0,3192, - 3194,1,0,0,0,3193,3174,1,0,0,0,3193,3182,1,0,0,0,3194,343,1,0,0,0,3195, - 3196,7,14,0,0,3196,345,1,0,0,0,3197,3199,3,348,174,0,3198,3197,1,0,0,0, - 3199,3202,1,0,0,0,3200,3198,1,0,0,0,3200,3201,1,0,0,0,3201,347,1,0,0,0, - 3202,3200,1,0,0,0,3203,3204,5,21,0,0,3204,3205,3,2,1,0,3205,3206,5,44, - 0,0,3206,3207,3,32,16,0,3207,3214,1,0,0,0,3208,3209,5,25,0,0,3209,3210, - 5,40,0,0,3210,3214,3,2,1,0,3211,3214,3,322,161,0,3212,3214,3,40,20,0,3213, - 3203,1,0,0,0,3213,3208,1,0,0,0,3213,3211,1,0,0,0,3213,3212,1,0,0,0,3214, - 349,1,0,0,0,176,360,368,377,386,439,480,489,519,523,541,568,591,627,637, - 644,646,656,658,665,676,684,705,707,723,768,773,778,783,791,901,907,923, - 929,935,942,970,1048,1050,1064,1070,1079,1081,1090,1104,1118,1126,1134, - 1138,1177,1185,1194,1202,1221,1231,1234,1258,1405,1415,1424,1427,1509, - 1518,1550,1610,1650,1666,1676,1703,1727,1735,1739,1754,1761,1806,1816, - 1834,1852,1871,1892,1911,1926,1933,1943,1956,1961,1966,1975,1985,2071, - 2080,2093,2104,2112,2122,2124,2151,2158,2163,2170,2176,2186,2190,2197, - 2212,2218,2232,2245,2254,2265,2269,2276,2296,2301,2303,2316,2342,2349, - 2351,2356,2362,2391,2400,2423,2428,2448,2501,2510,2523,2534,2545,2548, - 2556,2568,2582,2596,2604,2624,2636,2641,2650,2652,2659,2669,2737,2814, - 2821,2829,2979,2983,2985,2990,2992,2998,3004,3010,3016,3022,3028,3034, - 3041,3046,3052,3079,3093,3098,3115,3122,3131,3151,3156,3172,3178,3186, - 3193,3200,3213 + 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,3,149,2866, + 8,149,1,150,1,150,1,150,5,150,2871,8,150,10,150,12,150,2874,9,150,1,151, + 1,151,1,152,1,152,1,152,3,152,2881,8,152,1,153,1,153,1,153,1,153,1,153, + 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, + 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, + 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, + 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, + 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, + 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, + 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, + 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, + 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, + 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, + 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, + 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,3,153, + 3031,8,153,1,154,1,154,5,154,3035,8,154,10,154,12,154,3038,9,154,1,155, + 1,155,5,155,3042,8,155,10,155,12,155,3045,9,155,1,156,5,156,3048,8,156, + 10,156,12,156,3051,9,156,1,157,5,157,3054,8,157,10,157,12,157,3057,9,157, + 1,158,5,158,3060,8,158,10,158,12,158,3063,9,158,1,159,5,159,3066,8,159, + 10,159,12,159,3069,9,159,1,160,5,160,3072,8,160,10,160,12,160,3075,9,160, + 1,161,5,161,3078,8,161,10,161,12,161,3081,9,161,1,162,5,162,3084,8,162, + 10,162,12,162,3087,9,162,1,163,1,163,1,163,1,163,3,163,3093,8,163,1,164, + 5,164,3096,8,164,10,164,12,164,3099,9,164,1,165,1,165,1,165,3,165,3104, + 8,165,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166, + 1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166, + 1,166,1,166,3,166,3131,8,166,1,167,1,167,1,167,1,167,1,167,1,167,1,167, + 1,167,1,167,1,167,1,167,1,167,3,167,3145,8,167,1,168,5,168,3148,8,168, + 10,168,12,168,3151,9,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,169,3,169,3167,8,169,1,170,1,170,1,170, + 5,170,3172,8,170,10,170,12,170,3175,9,170,1,170,1,170,1,171,1,171,5,171, + 3181,8,171,10,171,12,171,3184,9,171,1,171,1,171,1,172,1,172,1,172,1,172, + 1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,3,172, + 3203,8,172,1,173,5,173,3206,8,173,10,173,12,173,3209,9,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,3,174, + 3224,8,174,1,175,1,175,5,175,3228,8,175,10,175,12,175,3231,9,175,1,175, + 1,175,1,175,5,175,3236,8,175,10,175,12,175,3239,9,175,1,175,1,175,1,175, + 1,175,3,175,3245,8,175,1,176,1,176,1,177,5,177,3250,8,177,10,177,12,177, + 3253,9,177,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178, + 3,178,3265,8,178,1,178,0,1,68,179,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,0,15,6,0,1,15,199,199, + 243,243,247,247,264,264,289,289,5,0,16,16,199,199,243,243,264,264,288, + 289,1,0,263,264,1,0,173,174,1,0,37,38,1,0,73,74,3,0,2,2,61,61,77,83,2, + 0,229,229,260,261,1,0,95,96,1,0,97,111,1,0,68,69,2,0,173,173,289,290,2, + 0,179,179,264,264,1,0,167,168,1,0,51,52,3729,0,358,1,0,0,0,2,376,1,0,0, + 0,4,378,1,0,0,0,6,385,1,0,0,0,8,394,1,0,0,0,10,447,1,0,0,0,12,449,1,0, + 0,0,14,452,1,0,0,0,16,455,1,0,0,0,18,459,1,0,0,0,20,462,1,0,0,0,22,465, + 1,0,0,0,24,472,1,0,0,0,26,488,1,0,0,0,28,490,1,0,0,0,30,492,1,0,0,0,32, + 502,1,0,0,0,34,504,1,0,0,0,36,527,1,0,0,0,38,531,1,0,0,0,40,549,1,0,0, + 0,42,576,1,0,0,0,44,599,1,0,0,0,46,635,1,0,0,0,48,637,1,0,0,0,50,645,1, + 0,0,0,52,647,1,0,0,0,54,654,1,0,0,0,56,666,1,0,0,0,58,669,1,0,0,0,60,671, + 1,0,0,0,62,684,1,0,0,0,64,692,1,0,0,0,66,694,1,0,0,0,68,702,1,0,0,0,70, + 718,1,0,0,0,72,724,1,0,0,0,74,727,1,0,0,0,76,776,1,0,0,0,78,781,1,0,0, + 0,80,786,1,0,0,0,82,791,1,0,0,0,84,799,1,0,0,0,86,804,1,0,0,0,88,909,1, + 0,0,0,90,937,1,0,0,0,92,939,1,0,0,0,94,943,1,0,0,0,96,945,1,0,0,0,98,950, + 1,0,0,0,100,978,1,0,0,0,102,1058,1,0,0,0,104,1060,1,0,0,0,106,1089,1,0, + 0,0,108,1091,1,0,0,0,110,1105,1,0,0,0,112,1134,1,0,0,0,114,1146,1,0,0, + 0,116,1185,1,0,0,0,118,1193,1,0,0,0,120,1202,1,0,0,0,122,1210,1,0,0,0, + 124,1229,1,0,0,0,126,1242,1,0,0,0,128,1266,1,0,0,0,130,1413,1,0,0,0,132, + 1423,1,0,0,0,134,1435,1,0,0,0,136,1517,1,0,0,0,138,1519,1,0,0,0,140,1558, + 1,0,0,0,142,1618,1,0,0,0,144,1658,1,0,0,0,146,1674,1,0,0,0,148,1676,1, + 0,0,0,150,1680,1,0,0,0,152,1735,1,0,0,0,154,1747,1,0,0,0,156,1762,1,0, + 0,0,158,1769,1,0,0,0,160,1774,1,0,0,0,162,1778,1,0,0,0,164,1814,1,0,0, + 0,166,1816,1,0,0,0,168,1860,1,0,0,0,170,1879,1,0,0,0,172,1900,1,0,0,0, + 174,1902,1,0,0,0,176,1919,1,0,0,0,178,1934,1,0,0,0,180,1941,1,0,0,0,182, + 1951,1,0,0,0,184,1964,1,0,0,0,186,1969,1,0,0,0,188,1972,1,0,0,0,190,1983, + 1,0,0,0,192,1988,1,0,0,0,194,1993,1,0,0,0,196,1997,1,0,0,0,198,2120,1, + 0,0,0,200,2122,1,0,0,0,202,2159,1,0,0,0,204,2166,1,0,0,0,206,2171,1,0, + 0,0,208,2178,1,0,0,0,210,2198,1,0,0,0,212,2200,1,0,0,0,214,2205,1,0,0, + 0,216,2220,1,0,0,0,218,2222,1,0,0,0,220,2235,1,0,0,0,222,2240,1,0,0,0, + 224,2253,1,0,0,0,226,2262,1,0,0,0,228,2277,1,0,0,0,230,2284,1,0,0,0,232, + 2304,1,0,0,0,234,2306,1,0,0,0,236,2350,1,0,0,0,238,2370,1,0,0,0,240,2399, + 1,0,0,0,242,2408,1,0,0,0,244,2431,1,0,0,0,246,2436,1,0,0,0,248,2476,1, + 0,0,0,250,2478,1,0,0,0,252,2484,1,0,0,0,254,2492,1,0,0,0,256,2512,1,0, + 0,0,258,2579,1,0,0,0,260,2581,1,0,0,0,262,2587,1,0,0,0,264,2589,1,0,0, + 0,266,2593,1,0,0,0,268,2599,1,0,0,0,270,2619,1,0,0,0,272,2637,1,0,0,0, + 274,2651,1,0,0,0,276,2653,1,0,0,0,278,2656,1,0,0,0,280,2658,1,0,0,0,282, + 2675,1,0,0,0,284,2677,1,0,0,0,286,2687,1,0,0,0,288,2692,1,0,0,0,290,2703, + 1,0,0,0,292,2710,1,0,0,0,294,2720,1,0,0,0,296,2788,1,0,0,0,298,2865,1, + 0,0,0,300,2872,1,0,0,0,302,2875,1,0,0,0,304,2880,1,0,0,0,306,3030,1,0, + 0,0,308,3036,1,0,0,0,310,3043,1,0,0,0,312,3049,1,0,0,0,314,3055,1,0,0, + 0,316,3061,1,0,0,0,318,3067,1,0,0,0,320,3073,1,0,0,0,322,3079,1,0,0,0, + 324,3085,1,0,0,0,326,3092,1,0,0,0,328,3097,1,0,0,0,330,3103,1,0,0,0,332, + 3130,1,0,0,0,334,3144,1,0,0,0,336,3149,1,0,0,0,338,3166,1,0,0,0,340,3168, + 1,0,0,0,342,3178,1,0,0,0,344,3202,1,0,0,0,346,3207,1,0,0,0,348,3223,1, + 0,0,0,350,3244,1,0,0,0,352,3246,1,0,0,0,354,3251,1,0,0,0,356,3264,1,0, + 0,0,358,359,7,0,0,0,359,1,1,0,0,0,360,361,5,288,0,0,361,377,6,1,-1,0,362, + 363,3,4,2,0,363,364,6,1,-1,0,364,365,5,265,0,0,365,367,1,0,0,0,366,362, + 1,0,0,0,367,370,1,0,0,0,368,366,1,0,0,0,368,369,1,0,0,0,369,371,1,0,0, + 0,370,368,1,0,0,0,371,372,3,4,2,0,372,373,6,1,-1,0,373,377,1,0,0,0,374, + 375,5,264,0,0,375,377,6,1,-1,0,376,360,1,0,0,0,376,368,1,0,0,0,376,374, + 1,0,0,0,377,3,1,0,0,0,378,379,7,1,0,0,379,5,1,0,0,0,380,381,5,263,0,0, + 381,382,6,3,-1,0,382,384,5,266,0,0,383,380,1,0,0,0,384,387,1,0,0,0,385, + 383,1,0,0,0,385,386,1,0,0,0,386,388,1,0,0,0,387,385,1,0,0,0,388,389,5, + 263,0,0,389,390,6,3,-1,0,390,7,1,0,0,0,391,393,3,10,5,0,392,391,1,0,0, + 0,393,396,1,0,0,0,394,392,1,0,0,0,394,395,1,0,0,0,395,9,1,0,0,0,396,394, + 1,0,0,0,397,398,3,74,37,0,398,399,5,17,0,0,399,400,3,82,41,0,400,401,5, + 18,0,0,401,448,1,0,0,0,402,403,3,72,36,0,403,404,5,17,0,0,404,405,3,8, + 4,0,405,406,5,18,0,0,406,448,1,0,0,0,407,408,3,234,117,0,408,409,5,17, + 0,0,409,410,3,246,123,0,410,411,5,18,0,0,411,448,1,0,0,0,412,448,3,200, + 100,0,413,448,3,284,142,0,414,448,3,70,35,0,415,448,3,66,33,0,416,448, + 3,88,44,0,417,448,3,90,45,0,418,448,3,22,11,0,419,420,3,334,167,0,420, + 421,5,17,0,0,421,422,3,336,168,0,422,423,5,18,0,0,423,448,1,0,0,0,424, + 425,3,340,170,0,425,426,5,17,0,0,426,427,3,346,173,0,427,428,5,18,0,0, + 428,448,1,0,0,0,429,430,3,350,175,0,430,431,5,17,0,0,431,432,3,354,177, + 0,432,433,5,18,0,0,433,448,1,0,0,0,434,448,3,64,32,0,435,448,3,152,76, + 0,436,448,3,330,165,0,437,448,3,12,6,0,438,448,3,14,7,0,439,448,3,16,8, + 0,440,448,3,18,9,0,441,448,3,20,10,0,442,448,3,26,13,0,443,448,3,42,21, + 0,444,448,3,40,20,0,445,448,3,30,15,0,446,448,3,24,12,0,447,397,1,0,0, + 0,447,402,1,0,0,0,447,407,1,0,0,0,447,412,1,0,0,0,447,413,1,0,0,0,447, + 414,1,0,0,0,447,415,1,0,0,0,447,416,1,0,0,0,447,417,1,0,0,0,447,418,1, + 0,0,0,447,419,1,0,0,0,447,424,1,0,0,0,447,429,1,0,0,0,447,434,1,0,0,0, + 447,435,1,0,0,0,447,436,1,0,0,0,447,437,1,0,0,0,447,438,1,0,0,0,447,439, + 1,0,0,0,447,440,1,0,0,0,447,441,1,0,0,0,447,442,1,0,0,0,447,443,1,0,0, + 0,447,444,1,0,0,0,447,445,1,0,0,0,447,446,1,0,0,0,448,11,1,0,0,0,449,450, + 5,19,0,0,450,451,3,32,16,0,451,13,1,0,0,0,452,453,5,20,0,0,453,454,3,32, + 16,0,454,15,1,0,0,0,455,456,5,21,0,0,456,457,5,22,0,0,457,458,3,32,16, + 0,458,17,1,0,0,0,459,460,5,23,0,0,460,461,3,34,17,0,461,19,1,0,0,0,462, + 463,5,24,0,0,463,464,3,34,17,0,464,21,1,0,0,0,465,466,5,25,0,0,466,467, + 3,98,49,0,467,468,3,2,1,0,468,469,5,17,0,0,469,470,3,120,60,0,470,471, + 5,18,0,0,471,23,1,0,0,0,472,473,5,26,0,0,473,25,1,0,0,0,474,475,5,27,0, + 0,475,489,3,28,14,0,476,477,5,27,0,0,477,478,3,28,14,0,478,479,5,28,0, + 0,479,480,3,28,14,0,480,489,1,0,0,0,481,482,5,27,0,0,482,483,3,28,14,0, + 483,484,5,28,0,0,484,485,3,28,14,0,485,486,5,28,0,0,486,487,3,28,14,0, + 487,489,1,0,0,0,488,474,1,0,0,0,488,476,1,0,0,0,488,481,1,0,0,0,489,27, + 1,0,0,0,490,491,7,2,0,0,491,29,1,0,0,0,492,493,5,29,0,0,493,497,5,17,0, + 0,494,496,3,116,58,0,495,494,1,0,0,0,496,499,1,0,0,0,497,495,1,0,0,0,497, + 498,1,0,0,0,498,500,1,0,0,0,499,497,1,0,0,0,500,501,5,18,0,0,501,31,1, + 0,0,0,502,503,5,173,0,0,503,33,1,0,0,0,504,505,7,3,0,0,505,35,1,0,0,0, + 506,507,5,175,0,0,507,528,6,18,-1,0,508,509,3,32,16,0,509,510,5,265,0, + 0,510,511,6,18,-1,0,511,528,1,0,0,0,512,513,3,32,16,0,513,514,6,18,-1, + 0,514,528,1,0,0,0,515,516,5,188,0,0,516,517,5,30,0,0,517,518,3,32,16,0, + 518,519,5,31,0,0,519,520,6,18,-1,0,520,528,1,0,0,0,521,522,5,189,0,0,522, + 523,5,30,0,0,523,524,3,34,17,0,524,525,5,31,0,0,525,526,6,18,-1,0,526, + 528,1,0,0,0,527,506,1,0,0,0,527,508,1,0,0,0,527,512,1,0,0,0,527,515,1, + 0,0,0,527,521,1,0,0,0,528,37,1,0,0,0,529,532,3,32,16,0,530,532,5,262,0, + 0,531,529,1,0,0,0,531,530,1,0,0,0,532,39,1,0,0,0,533,534,5,267,0,0,534, + 550,5,289,0,0,535,536,5,267,0,0,536,537,5,289,0,0,537,550,5,263,0,0,538, + 539,5,268,0,0,539,550,5,289,0,0,540,541,5,269,0,0,541,550,5,289,0,0,542, + 543,5,270,0,0,543,550,5,289,0,0,544,550,5,271,0,0,545,550,5,272,0,0,546, + 547,5,273,0,0,547,550,5,263,0,0,548,550,5,32,0,0,549,533,1,0,0,0,549,535, + 1,0,0,0,549,538,1,0,0,0,549,540,1,0,0,0,549,542,1,0,0,0,549,544,1,0,0, + 0,549,545,1,0,0,0,549,546,1,0,0,0,549,548,1,0,0,0,550,41,1,0,0,0,551,552, + 5,33,0,0,552,553,3,138,69,0,553,554,5,34,0,0,554,555,3,2,1,0,555,577,1, + 0,0,0,556,557,5,33,0,0,557,558,3,116,58,0,558,559,5,34,0,0,559,560,3,2, + 1,0,560,577,1,0,0,0,561,562,5,33,0,0,562,563,3,176,88,0,563,564,5,34,0, + 0,564,565,3,2,1,0,565,577,1,0,0,0,566,567,5,33,0,0,567,568,3,44,22,0,568, + 569,5,34,0,0,569,570,3,2,1,0,570,577,1,0,0,0,571,572,5,33,0,0,572,573, + 3,46,23,0,573,574,5,34,0,0,574,575,3,2,1,0,575,577,1,0,0,0,576,551,1,0, + 0,0,576,556,1,0,0,0,576,561,1,0,0,0,576,566,1,0,0,0,576,571,1,0,0,0,577, + 43,1,0,0,0,578,579,5,35,0,0,579,600,3,48,24,0,580,581,5,35,0,0,581,582, + 3,48,24,0,582,583,5,36,0,0,583,584,3,6,3,0,584,600,1,0,0,0,585,586,5,35, + 0,0,586,587,3,48,24,0,587,588,5,36,0,0,588,589,5,17,0,0,589,590,3,52,26, + 0,590,591,5,18,0,0,591,600,1,0,0,0,592,593,5,35,0,0,593,594,3,48,24,0, + 594,595,5,36,0,0,595,596,5,30,0,0,596,597,3,300,150,0,597,598,5,31,0,0, + 598,600,1,0,0,0,599,578,1,0,0,0,599,580,1,0,0,0,599,585,1,0,0,0,599,592, + 1,0,0,0,600,45,1,0,0,0,601,602,5,35,0,0,602,603,5,30,0,0,603,604,3,50, + 25,0,604,605,5,31,0,0,605,606,3,48,24,0,606,636,1,0,0,0,607,608,5,35,0, + 0,608,609,5,30,0,0,609,610,3,50,25,0,610,611,5,31,0,0,611,612,3,48,24, + 0,612,613,5,36,0,0,613,614,3,6,3,0,614,636,1,0,0,0,615,616,5,35,0,0,616, + 617,5,30,0,0,617,618,3,50,25,0,618,619,5,31,0,0,619,620,3,48,24,0,620, + 621,5,36,0,0,621,622,5,17,0,0,622,623,3,52,26,0,623,624,5,18,0,0,624,636, + 1,0,0,0,625,626,5,35,0,0,626,627,5,30,0,0,627,628,3,50,25,0,628,629,5, + 31,0,0,629,630,3,48,24,0,630,631,5,36,0,0,631,632,5,30,0,0,632,633,3,300, + 150,0,633,634,5,31,0,0,634,636,1,0,0,0,635,601,1,0,0,0,635,607,1,0,0,0, + 635,615,1,0,0,0,635,625,1,0,0,0,636,47,1,0,0,0,637,638,3,168,84,0,638, + 49,1,0,0,0,639,640,3,124,62,0,640,641,6,25,-1,0,641,646,1,0,0,0,642,643, + 3,176,88,0,643,644,6,25,-1,0,644,646,1,0,0,0,645,639,1,0,0,0,645,642,1, + 0,0,0,646,51,1,0,0,0,647,648,3,54,27,0,648,649,3,56,28,0,649,53,1,0,0, + 0,650,653,3,306,153,0,651,653,3,40,20,0,652,650,1,0,0,0,652,651,1,0,0, + 0,653,656,1,0,0,0,654,652,1,0,0,0,654,655,1,0,0,0,655,55,1,0,0,0,656,654, + 1,0,0,0,657,658,3,58,29,0,658,659,3,60,30,0,659,660,3,2,1,0,660,661,5, + 36,0,0,661,662,3,306,153,0,662,665,1,0,0,0,663,665,3,40,20,0,664,657,1, + 0,0,0,664,663,1,0,0,0,665,668,1,0,0,0,666,664,1,0,0,0,666,667,1,0,0,0, + 667,57,1,0,0,0,668,666,1,0,0,0,669,670,7,4,0,0,670,59,1,0,0,0,671,673, + 3,62,31,0,672,674,5,261,0,0,673,672,1,0,0,0,673,674,1,0,0,0,674,61,1,0, + 0,0,675,685,3,144,72,0,676,685,3,2,1,0,677,685,5,196,0,0,678,685,5,197, + 0,0,679,680,5,202,0,0,680,681,5,39,0,0,681,685,5,264,0,0,682,683,5,202, + 0,0,683,685,3,116,58,0,684,675,1,0,0,0,684,676,1,0,0,0,684,677,1,0,0,0, + 684,678,1,0,0,0,684,679,1,0,0,0,684,682,1,0,0,0,685,63,1,0,0,0,686,687, + 5,198,0,0,687,688,5,40,0,0,688,693,3,2,1,0,689,690,5,198,0,0,690,693,3, + 2,1,0,691,693,5,198,0,0,692,686,1,0,0,0,692,689,1,0,0,0,692,691,1,0,0, + 0,693,65,1,0,0,0,694,695,5,41,0,0,695,696,5,42,0,0,696,697,3,32,16,0,697, + 698,5,43,0,0,698,699,3,68,34,0,699,700,5,44,0,0,700,701,3,0,0,0,701,67, + 1,0,0,0,702,715,6,34,-1,0,703,704,10,5,0,0,704,714,5,186,0,0,705,706,10, + 4,0,0,706,714,5,187,0,0,707,708,10,3,0,0,708,714,5,45,0,0,709,710,10,2, + 0,0,710,714,5,46,0,0,711,712,10,1,0,0,712,714,5,47,0,0,713,703,1,0,0,0, + 713,705,1,0,0,0,713,707,1,0,0,0,713,709,1,0,0,0,713,711,1,0,0,0,714,717, + 1,0,0,0,715,713,1,0,0,0,715,716,1,0,0,0,716,69,1,0,0,0,717,715,1,0,0,0, + 718,719,5,48,0,0,719,720,5,36,0,0,720,721,5,30,0,0,721,722,3,300,150,0, + 722,723,5,31,0,0,723,71,1,0,0,0,724,725,5,49,0,0,725,726,3,2,1,0,726,73, + 1,0,0,0,727,731,5,50,0,0,728,730,3,76,38,0,729,728,1,0,0,0,730,733,1,0, + 0,0,731,729,1,0,0,0,731,732,1,0,0,0,732,734,1,0,0,0,733,731,1,0,0,0,734, + 735,3,2,1,0,735,736,3,182,91,0,736,737,3,78,39,0,737,738,3,80,40,0,738, + 75,1,0,0,0,739,777,5,51,0,0,740,777,5,52,0,0,741,777,5,199,0,0,742,777, + 5,202,0,0,743,777,5,221,0,0,744,777,5,53,0,0,745,777,5,54,0,0,746,777, + 5,55,0,0,747,777,5,56,0,0,748,777,5,244,0,0,749,777,5,15,0,0,750,777,5, + 224,0,0,751,777,5,57,0,0,752,777,5,58,0,0,753,777,5,59,0,0,754,777,5,60, + 0,0,755,777,5,61,0,0,756,757,5,62,0,0,757,777,5,51,0,0,758,759,5,62,0, + 0,759,777,5,52,0,0,760,761,5,62,0,0,761,777,5,63,0,0,762,763,5,62,0,0, + 763,777,5,64,0,0,764,765,5,62,0,0,765,777,5,65,0,0,766,767,5,62,0,0,767, + 777,5,66,0,0,768,777,5,67,0,0,769,777,5,68,0,0,770,777,5,69,0,0,771,772, + 5,70,0,0,772,773,5,30,0,0,773,774,3,32,16,0,774,775,5,31,0,0,775,777,1, + 0,0,0,776,739,1,0,0,0,776,740,1,0,0,0,776,741,1,0,0,0,776,742,1,0,0,0, + 776,743,1,0,0,0,776,744,1,0,0,0,776,745,1,0,0,0,776,746,1,0,0,0,776,747, + 1,0,0,0,776,748,1,0,0,0,776,749,1,0,0,0,776,750,1,0,0,0,776,751,1,0,0, + 0,776,752,1,0,0,0,776,753,1,0,0,0,776,754,1,0,0,0,776,755,1,0,0,0,776, + 756,1,0,0,0,776,758,1,0,0,0,776,760,1,0,0,0,776,762,1,0,0,0,776,764,1, + 0,0,0,776,766,1,0,0,0,776,768,1,0,0,0,776,769,1,0,0,0,776,770,1,0,0,0, + 776,771,1,0,0,0,777,77,1,0,0,0,778,782,1,0,0,0,779,780,5,71,0,0,780,782, + 3,124,62,0,781,778,1,0,0,0,781,779,1,0,0,0,782,79,1,0,0,0,783,787,1,0, + 0,0,784,785,5,72,0,0,785,787,3,84,42,0,786,783,1,0,0,0,786,784,1,0,0,0, + 787,81,1,0,0,0,788,790,3,198,99,0,789,788,1,0,0,0,790,793,1,0,0,0,791, + 789,1,0,0,0,791,792,1,0,0,0,792,83,1,0,0,0,793,791,1,0,0,0,794,795,3,124, + 62,0,795,796,5,28,0,0,796,798,1,0,0,0,797,794,1,0,0,0,798,801,1,0,0,0, + 799,797,1,0,0,0,799,800,1,0,0,0,800,802,1,0,0,0,801,799,1,0,0,0,802,803, + 3,124,62,0,803,85,1,0,0,0,804,805,7,5,0,0,805,87,1,0,0,0,806,807,3,86, + 43,0,807,808,3,32,16,0,808,809,5,264,0,0,809,910,1,0,0,0,810,811,3,86, + 43,0,811,812,3,32,16,0,812,910,1,0,0,0,813,814,3,86,43,0,814,815,3,32, + 16,0,815,816,5,75,0,0,816,817,3,32,16,0,817,818,5,264,0,0,818,910,1,0, + 0,0,819,820,3,86,43,0,820,821,3,32,16,0,821,822,5,75,0,0,822,823,3,32, + 16,0,823,910,1,0,0,0,824,825,3,86,43,0,825,826,3,32,16,0,826,827,5,75, + 0,0,827,828,3,32,16,0,828,829,5,28,0,0,829,830,3,32,16,0,830,831,5,264, + 0,0,831,910,1,0,0,0,832,833,3,86,43,0,833,834,3,32,16,0,834,835,5,75,0, + 0,835,836,3,32,16,0,836,837,5,28,0,0,837,838,3,32,16,0,838,910,1,0,0,0, + 839,840,3,86,43,0,840,841,3,32,16,0,841,842,5,28,0,0,842,843,3,32,16,0, + 843,844,5,75,0,0,844,845,3,32,16,0,845,846,5,264,0,0,846,910,1,0,0,0,847, + 848,3,86,43,0,848,849,3,32,16,0,849,850,5,28,0,0,850,851,3,32,16,0,851, + 852,5,75,0,0,852,853,3,32,16,0,853,910,1,0,0,0,854,855,3,86,43,0,855,856, + 3,32,16,0,856,857,5,28,0,0,857,858,3,32,16,0,858,859,5,75,0,0,859,860, + 3,32,16,0,860,861,5,28,0,0,861,862,3,32,16,0,862,863,5,264,0,0,863,910, + 1,0,0,0,864,865,3,86,43,0,865,866,3,32,16,0,866,867,5,28,0,0,867,868,3, + 32,16,0,868,869,5,75,0,0,869,870,3,32,16,0,870,871,5,28,0,0,871,872,3, + 32,16,0,872,910,1,0,0,0,873,874,3,86,43,0,874,875,3,32,16,0,875,876,5, + 263,0,0,876,910,1,0,0,0,877,878,3,86,43,0,878,879,3,32,16,0,879,880,5, + 75,0,0,880,881,3,32,16,0,881,882,5,263,0,0,882,910,1,0,0,0,883,884,3,86, + 43,0,884,885,3,32,16,0,885,886,5,75,0,0,886,887,3,32,16,0,887,888,5,28, + 0,0,888,889,3,32,16,0,889,890,5,263,0,0,890,910,1,0,0,0,891,892,3,86,43, + 0,892,893,3,32,16,0,893,894,5,28,0,0,894,895,3,32,16,0,895,896,5,75,0, + 0,896,897,3,32,16,0,897,898,5,263,0,0,898,910,1,0,0,0,899,900,3,86,43, + 0,900,901,3,32,16,0,901,902,5,28,0,0,902,903,3,32,16,0,903,904,5,75,0, + 0,904,905,3,32,16,0,905,906,5,28,0,0,906,907,3,32,16,0,907,908,5,263,0, + 0,908,910,1,0,0,0,909,806,1,0,0,0,909,810,1,0,0,0,909,813,1,0,0,0,909, + 819,1,0,0,0,909,824,1,0,0,0,909,832,1,0,0,0,909,839,1,0,0,0,909,847,1, + 0,0,0,909,854,1,0,0,0,909,864,1,0,0,0,909,873,1,0,0,0,909,877,1,0,0,0, + 909,883,1,0,0,0,909,891,1,0,0,0,909,899,1,0,0,0,910,89,1,0,0,0,911,915, + 5,21,0,0,912,914,3,92,46,0,913,912,1,0,0,0,914,917,1,0,0,0,915,913,1,0, + 0,0,915,916,1,0,0,0,916,918,1,0,0,0,917,915,1,0,0,0,918,919,3,2,1,0,919, + 920,3,94,47,0,920,921,5,180,0,0,921,922,5,36,0,0,922,923,5,30,0,0,923, + 924,3,300,150,0,924,925,5,31,0,0,925,926,3,94,47,0,926,938,1,0,0,0,927, + 931,5,21,0,0,928,930,3,92,46,0,929,928,1,0,0,0,930,933,1,0,0,0,931,929, + 1,0,0,0,931,932,1,0,0,0,932,934,1,0,0,0,933,931,1,0,0,0,934,935,3,2,1, + 0,935,936,3,94,47,0,936,938,1,0,0,0,937,911,1,0,0,0,937,927,1,0,0,0,938, + 91,1,0,0,0,939,940,5,76,0,0,940,93,1,0,0,0,941,944,1,0,0,0,942,944,5,298, + 0,0,943,941,1,0,0,0,943,942,1,0,0,0,944,95,1,0,0,0,945,946,7,6,0,0,946, + 97,1,0,0,0,947,949,3,96,48,0,948,947,1,0,0,0,949,952,1,0,0,0,950,948,1, + 0,0,0,950,951,1,0,0,0,951,99,1,0,0,0,952,950,1,0,0,0,953,979,3,102,51, + 0,954,955,5,280,0,0,955,956,3,168,84,0,956,957,6,50,-1,0,957,979,1,0,0, + 0,958,959,5,286,0,0,959,960,3,178,89,0,960,961,6,50,-1,0,961,979,1,0,0, + 0,962,963,5,286,0,0,963,964,3,174,87,0,964,965,6,50,-1,0,965,979,1,0,0, + 0,966,967,5,284,0,0,967,968,3,124,62,0,968,969,6,50,-1,0,969,979,1,0,0, + 0,970,971,5,281,0,0,971,972,3,104,52,0,972,973,6,50,-1,0,973,979,1,0,0, + 0,974,975,5,287,0,0,975,976,3,50,25,0,976,977,6,50,-1,0,977,979,1,0,0, + 0,978,953,1,0,0,0,978,954,1,0,0,0,978,958,1,0,0,0,978,962,1,0,0,0,978, + 966,1,0,0,0,978,970,1,0,0,0,978,974,1,0,0,0,979,101,1,0,0,0,980,981,5, + 275,0,0,981,1059,6,51,-1,0,982,983,5,276,0,0,983,984,3,32,16,0,984,985, + 6,51,-1,0,985,1059,1,0,0,0,986,987,5,276,0,0,987,988,3,0,0,0,988,989,6, + 51,-1,0,989,1059,1,0,0,0,990,991,5,277,0,0,991,992,3,32,16,0,992,993,6, + 51,-1,0,993,1059,1,0,0,0,994,995,5,278,0,0,995,996,3,34,17,0,996,997,6, + 51,-1,0,997,1059,1,0,0,0,998,999,5,279,0,0,999,1000,3,36,18,0,1000,1001, + 6,51,-1,0,1001,1059,1,0,0,0,1002,1003,5,279,0,0,1003,1004,3,34,17,0,1004, + 1005,6,51,-1,0,1005,1059,1,0,0,0,1006,1007,5,279,0,0,1007,1008,5,30,0, + 0,1008,1009,3,300,150,0,1009,1010,5,31,0,0,1010,1011,6,51,-1,0,1011,1059, + 1,0,0,0,1012,1013,5,279,0,0,1013,1014,5,84,0,0,1014,1015,5,30,0,0,1015, + 1016,3,300,150,0,1016,1017,5,31,0,0,1017,1018,6,51,-1,0,1018,1059,1,0, + 0,0,1019,1020,5,282,0,0,1020,1021,3,32,16,0,1021,1022,6,51,-1,0,1022,1059, + 1,0,0,0,1023,1024,5,282,0,0,1024,1025,3,0,0,0,1025,1026,6,51,-1,0,1026, + 1059,1,0,0,0,1027,1028,5,285,0,0,1028,1029,3,6,3,0,1029,1030,6,51,-1,0, + 1030,1059,1,0,0,0,1031,1032,5,285,0,0,1032,1033,5,224,0,0,1033,1034,5, + 30,0,0,1034,1035,3,6,3,0,1035,1036,5,31,0,0,1036,1037,6,51,-1,0,1037,1059, + 1,0,0,0,1038,1039,5,285,0,0,1039,1040,5,84,0,0,1040,1041,5,30,0,0,1041, + 1042,3,300,150,0,1042,1043,5,31,0,0,1043,1044,6,51,-1,0,1044,1059,1,0, + 0,0,1045,1046,5,287,0,0,1046,1047,3,32,16,0,1047,1048,6,51,-1,0,1048,1059, + 1,0,0,0,1049,1050,5,283,0,0,1050,1056,6,51,-1,0,1051,1052,5,30,0,0,1052, + 1053,3,106,53,0,1053,1054,5,31,0,0,1054,1057,1,0,0,0,1055,1057,5,85,0, + 0,1056,1051,1,0,0,0,1056,1055,1,0,0,0,1057,1059,1,0,0,0,1058,980,1,0,0, + 0,1058,982,1,0,0,0,1058,986,1,0,0,0,1058,990,1,0,0,0,1058,994,1,0,0,0, + 1058,998,1,0,0,0,1058,1002,1,0,0,0,1058,1006,1,0,0,0,1058,1012,1,0,0,0, + 1058,1019,1,0,0,0,1058,1023,1,0,0,0,1058,1027,1,0,0,0,1058,1031,1,0,0, + 0,1058,1038,1,0,0,0,1058,1045,1,0,0,0,1058,1049,1,0,0,0,1059,103,1,0,0, + 0,1060,1061,3,170,85,0,1061,1062,3,138,69,0,1062,1063,3,112,56,0,1063, + 1064,6,52,-1,0,1064,105,1,0,0,0,1065,1090,1,0,0,0,1066,1067,3,0,0,0,1067, + 1068,6,53,-1,0,1068,1073,1,0,0,0,1069,1070,3,32,16,0,1070,1071,6,53,-1, + 0,1071,1073,1,0,0,0,1072,1066,1,0,0,0,1072,1069,1,0,0,0,1073,1074,1,0, + 0,0,1074,1075,5,28,0,0,1075,1077,1,0,0,0,1076,1072,1,0,0,0,1077,1080,1, + 0,0,0,1078,1076,1,0,0,0,1078,1079,1,0,0,0,1079,1087,1,0,0,0,1080,1078, + 1,0,0,0,1081,1082,3,0,0,0,1082,1083,6,53,-1,0,1083,1088,1,0,0,0,1084,1085, + 3,32,16,0,1085,1086,6,53,-1,0,1086,1088,1,0,0,0,1087,1081,1,0,0,0,1087, + 1084,1,0,0,0,1088,1090,1,0,0,0,1089,1065,1,0,0,0,1089,1078,1,0,0,0,1090, + 107,1,0,0,0,1091,1098,5,86,0,0,1092,1093,3,138,69,0,1093,1094,6,54,-1, + 0,1094,1095,5,28,0,0,1095,1097,1,0,0,0,1096,1092,1,0,0,0,1097,1100,1,0, + 0,0,1098,1096,1,0,0,0,1098,1099,1,0,0,0,1099,1101,1,0,0,0,1100,1098,1, + 0,0,0,1101,1102,3,138,69,0,1102,1103,6,54,-1,0,1103,1104,5,87,0,0,1104, + 109,1,0,0,0,1105,1112,5,42,0,0,1106,1107,3,146,73,0,1107,1108,6,55,-1, + 0,1108,1109,5,28,0,0,1109,1111,1,0,0,0,1110,1106,1,0,0,0,1111,1114,1,0, + 0,0,1112,1110,1,0,0,0,1112,1113,1,0,0,0,1113,1115,1,0,0,0,1114,1112,1, + 0,0,0,1115,1116,3,146,73,0,1116,1117,6,55,-1,0,1117,1118,5,43,0,0,1118, + 111,1,0,0,0,1119,1126,5,30,0,0,1120,1121,3,114,57,0,1121,1122,6,56,-1, + 0,1122,1123,5,28,0,0,1123,1125,1,0,0,0,1124,1120,1,0,0,0,1125,1128,1,0, + 0,0,1126,1124,1,0,0,0,1126,1127,1,0,0,0,1127,1129,1,0,0,0,1128,1126,1, + 0,0,0,1129,1130,3,114,57,0,1130,1131,6,56,-1,0,1131,1132,5,31,0,0,1132, + 1135,1,0,0,0,1133,1135,5,85,0,0,1134,1119,1,0,0,0,1134,1133,1,0,0,0,1135, + 113,1,0,0,0,1136,1137,5,177,0,0,1137,1147,6,57,-1,0,1138,1139,3,230,115, + 0,1139,1140,3,138,69,0,1140,1142,3,226,113,0,1141,1143,3,0,0,0,1142,1141, + 1,0,0,0,1142,1143,1,0,0,0,1143,1144,1,0,0,0,1144,1145,6,57,-1,0,1145,1147, + 1,0,0,0,1146,1136,1,0,0,0,1146,1138,1,0,0,0,1147,115,1,0,0,0,1148,1149, + 5,42,0,0,1149,1150,3,2,1,0,1150,1151,5,43,0,0,1151,1152,3,118,59,0,1152, + 1153,6,58,-1,0,1153,1186,1,0,0,0,1154,1155,5,42,0,0,1155,1156,3,174,87, + 0,1156,1157,5,43,0,0,1157,1158,3,118,59,0,1158,1159,6,58,-1,0,1159,1186, + 1,0,0,0,1160,1161,5,42,0,0,1161,1162,5,262,0,0,1162,1163,5,43,0,0,1163, + 1164,3,118,59,0,1164,1165,6,58,-1,0,1165,1186,1,0,0,0,1166,1167,5,42,0, + 0,1167,1168,5,198,0,0,1168,1169,3,2,1,0,1169,1170,5,43,0,0,1170,1171,3, + 118,59,0,1171,1172,6,58,-1,0,1172,1186,1,0,0,0,1173,1174,3,118,59,0,1174, + 1175,6,58,-1,0,1175,1186,1,0,0,0,1176,1177,3,174,87,0,1177,1178,6,58,-1, + 0,1178,1186,1,0,0,0,1179,1180,5,257,0,0,1180,1186,6,58,-1,0,1181,1182, + 5,258,0,0,1182,1186,6,58,-1,0,1183,1184,5,259,0,0,1184,1186,6,58,-1,0, + 1185,1148,1,0,0,0,1185,1154,1,0,0,0,1185,1160,1,0,0,0,1185,1166,1,0,0, + 0,1185,1173,1,0,0,0,1185,1176,1,0,0,0,1185,1179,1,0,0,0,1185,1181,1,0, + 0,0,1185,1183,1,0,0,0,1186,117,1,0,0,0,1187,1188,3,2,1,0,1188,1189,6,59, + -1,0,1189,1190,5,88,0,0,1190,1192,1,0,0,0,1191,1187,1,0,0,0,1192,1195, + 1,0,0,0,1193,1191,1,0,0,0,1193,1194,1,0,0,0,1194,1196,1,0,0,0,1195,1193, + 1,0,0,0,1196,1197,3,2,1,0,1197,1198,6,59,-1,0,1198,119,1,0,0,0,1199,1201, + 3,122,61,0,1200,1199,1,0,0,0,1201,1204,1,0,0,0,1202,1200,1,0,0,0,1202, + 1203,1,0,0,0,1203,121,1,0,0,0,1204,1202,1,0,0,0,1205,1206,5,180,0,0,1206, + 1207,5,89,0,0,1207,1211,3,32,16,0,1208,1211,3,152,76,0,1209,1211,3,332, + 166,0,1210,1205,1,0,0,0,1210,1208,1,0,0,0,1210,1209,1,0,0,0,1211,123,1, + 0,0,0,1212,1213,3,116,58,0,1213,1214,6,62,-1,0,1214,1230,1,0,0,0,1215, + 1216,5,42,0,0,1216,1217,3,2,1,0,1217,1218,5,43,0,0,1218,1219,6,62,-1,0, + 1219,1230,1,0,0,0,1220,1221,5,42,0,0,1221,1222,5,198,0,0,1222,1223,3,2, + 1,0,1223,1224,5,43,0,0,1224,1225,6,62,-1,0,1225,1230,1,0,0,0,1226,1227, + 3,138,69,0,1227,1228,6,62,-1,0,1228,1230,1,0,0,0,1229,1212,1,0,0,0,1229, + 1215,1,0,0,0,1229,1220,1,0,0,0,1229,1226,1,0,0,0,1230,125,1,0,0,0,1231, + 1243,1,0,0,0,1232,1233,3,130,65,0,1233,1239,6,63,-1,0,1234,1235,3,128, + 64,0,1235,1236,6,63,-1,0,1236,1238,1,0,0,0,1237,1234,1,0,0,0,1238,1241, + 1,0,0,0,1239,1237,1,0,0,0,1239,1240,1,0,0,0,1240,1243,1,0,0,0,1241,1239, + 1,0,0,0,1242,1231,1,0,0,0,1242,1232,1,0,0,0,1243,127,1,0,0,0,1244,1245, + 5,262,0,0,1245,1267,6,64,-1,0,1246,1247,5,261,0,0,1247,1267,6,64,-1,0, + 1248,1249,5,42,0,0,1249,1250,3,32,16,0,1250,1251,5,43,0,0,1251,1252,6, + 64,-1,0,1252,1267,1,0,0,0,1253,1254,5,42,0,0,1254,1255,3,32,16,0,1255, + 1256,5,266,0,0,1256,1257,3,32,16,0,1257,1258,5,43,0,0,1258,1259,6,64,-1, + 0,1259,1267,1,0,0,0,1260,1261,5,42,0,0,1261,1262,5,266,0,0,1262,1263,3, + 32,16,0,1263,1264,5,43,0,0,1264,1265,6,64,-1,0,1265,1267,1,0,0,0,1266, + 1244,1,0,0,0,1266,1246,1,0,0,0,1266,1248,1,0,0,0,1266,1253,1,0,0,0,1266, + 1260,1,0,0,0,1267,129,1,0,0,0,1268,1414,6,65,-1,0,1269,1270,5,203,0,0, + 1270,1271,5,30,0,0,1271,1272,3,6,3,0,1272,1273,5,28,0,0,1273,1274,3,6, + 3,0,1274,1275,5,28,0,0,1275,1276,3,6,3,0,1276,1277,5,28,0,0,1277,1278, + 3,6,3,0,1278,1279,5,31,0,0,1279,1280,6,65,-1,0,1280,1414,1,0,0,0,1281, + 1282,5,203,0,0,1282,1283,5,30,0,0,1283,1284,3,6,3,0,1284,1285,5,28,0,0, + 1285,1286,3,6,3,0,1286,1287,5,31,0,0,1287,1288,6,65,-1,0,1288,1414,1,0, + 0,0,1289,1290,5,204,0,0,1290,1291,5,205,0,0,1291,1292,5,42,0,0,1292,1293, + 3,32,16,0,1293,1294,5,43,0,0,1294,1295,6,65,-1,0,1295,1414,1,0,0,0,1296, + 1297,5,204,0,0,1297,1298,5,206,0,0,1298,1299,5,42,0,0,1299,1300,3,32,16, + 0,1300,1301,5,43,0,0,1301,1302,3,126,63,0,1302,1303,6,65,-1,0,1303,1414, + 1,0,0,0,1304,1305,5,207,0,0,1305,1414,6,65,-1,0,1306,1307,5,208,0,0,1307, + 1414,6,65,-1,0,1308,1309,5,209,0,0,1309,1414,6,65,-1,0,1310,1311,5,201, + 0,0,1311,1414,6,65,-1,0,1312,1313,5,183,0,0,1313,1414,6,65,-1,0,1314,1315, + 5,184,0,0,1315,1414,6,65,-1,0,1316,1317,5,185,0,0,1317,1414,6,65,-1,0, + 1318,1319,5,186,0,0,1319,1414,6,65,-1,0,1320,1321,5,187,0,0,1321,1414, + 6,65,-1,0,1322,1323,5,188,0,0,1323,1414,6,65,-1,0,1324,1325,5,189,0,0, + 1325,1414,6,65,-1,0,1326,1327,5,210,0,0,1327,1414,6,65,-1,0,1328,1329, + 5,190,0,0,1329,1414,6,65,-1,0,1330,1331,5,191,0,0,1331,1414,6,65,-1,0, + 1332,1333,5,192,0,0,1333,1414,6,65,-1,0,1334,1335,5,193,0,0,1335,1414, + 6,65,-1,0,1336,1337,5,211,0,0,1337,1414,6,65,-1,0,1338,1339,5,212,0,0, + 1339,1414,6,65,-1,0,1340,1341,5,213,0,0,1341,1414,6,65,-1,0,1342,1343, + 5,214,0,0,1343,1414,6,65,-1,0,1344,1345,5,215,0,0,1345,1414,6,65,-1,0, + 1346,1347,5,216,0,0,1347,1414,6,65,-1,0,1348,1349,5,217,0,0,1349,1414, + 6,65,-1,0,1350,1351,5,218,0,0,1351,1352,3,132,66,0,1352,1353,6,65,-1,0, + 1353,1414,1,0,0,0,1354,1355,5,219,0,0,1355,1356,3,132,66,0,1356,1357,6, + 65,-1,0,1357,1414,1,0,0,0,1358,1359,5,220,0,0,1359,1414,6,65,-1,0,1360, + 1361,5,221,0,0,1361,1362,3,132,66,0,1362,1363,6,65,-1,0,1363,1414,1,0, + 0,0,1364,1365,5,222,0,0,1365,1366,3,134,67,0,1366,1367,6,65,-1,0,1367, + 1414,1,0,0,0,1368,1369,5,222,0,0,1369,1370,3,134,67,0,1370,1371,5,28,0, + 0,1371,1372,3,6,3,0,1372,1373,6,65,-1,0,1373,1414,1,0,0,0,1374,1375,5, + 194,0,0,1375,1414,6,65,-1,0,1376,1377,5,195,0,0,1377,1414,6,65,-1,0,1378, + 1379,5,90,0,0,1379,1380,5,184,0,0,1380,1414,6,65,-1,0,1381,1382,5,90,0, + 0,1382,1383,5,185,0,0,1383,1414,6,65,-1,0,1384,1385,5,90,0,0,1385,1386, + 5,186,0,0,1386,1414,6,65,-1,0,1387,1388,5,90,0,0,1388,1389,5,187,0,0,1389, + 1414,6,65,-1,0,1390,1391,5,62,0,0,1391,1392,5,220,0,0,1392,1414,6,65,-1, + 0,1393,1394,5,223,0,0,1394,1414,6,65,-1,0,1395,1396,5,224,0,0,1396,1397, + 5,213,0,0,1397,1414,6,65,-1,0,1398,1399,5,225,0,0,1399,1414,6,65,-1,0, + 1400,1401,5,207,0,0,1401,1402,5,183,0,0,1402,1414,6,65,-1,0,1403,1404, + 5,226,0,0,1404,1414,6,65,-1,0,1405,1406,5,228,0,0,1406,1414,6,65,-1,0, + 1407,1408,5,34,0,0,1408,1409,5,227,0,0,1409,1414,6,65,-1,0,1410,1411,3, + 2,1,0,1411,1412,6,65,-1,0,1412,1414,1,0,0,0,1413,1268,1,0,0,0,1413,1269, + 1,0,0,0,1413,1281,1,0,0,0,1413,1289,1,0,0,0,1413,1296,1,0,0,0,1413,1304, + 1,0,0,0,1413,1306,1,0,0,0,1413,1308,1,0,0,0,1413,1310,1,0,0,0,1413,1312, + 1,0,0,0,1413,1314,1,0,0,0,1413,1316,1,0,0,0,1413,1318,1,0,0,0,1413,1320, + 1,0,0,0,1413,1322,1,0,0,0,1413,1324,1,0,0,0,1413,1326,1,0,0,0,1413,1328, + 1,0,0,0,1413,1330,1,0,0,0,1413,1332,1,0,0,0,1413,1334,1,0,0,0,1413,1336, + 1,0,0,0,1413,1338,1,0,0,0,1413,1340,1,0,0,0,1413,1342,1,0,0,0,1413,1344, + 1,0,0,0,1413,1346,1,0,0,0,1413,1348,1,0,0,0,1413,1350,1,0,0,0,1413,1354, + 1,0,0,0,1413,1358,1,0,0,0,1413,1360,1,0,0,0,1413,1364,1,0,0,0,1413,1368, + 1,0,0,0,1413,1374,1,0,0,0,1413,1376,1,0,0,0,1413,1378,1,0,0,0,1413,1381, + 1,0,0,0,1413,1384,1,0,0,0,1413,1387,1,0,0,0,1413,1390,1,0,0,0,1413,1393, + 1,0,0,0,1413,1395,1,0,0,0,1413,1398,1,0,0,0,1413,1400,1,0,0,0,1413,1403, + 1,0,0,0,1413,1405,1,0,0,0,1413,1407,1,0,0,0,1413,1410,1,0,0,0,1414,131, + 1,0,0,0,1415,1424,1,0,0,0,1416,1417,5,30,0,0,1417,1418,5,91,0,0,1418,1419, + 5,36,0,0,1419,1420,3,32,16,0,1420,1421,5,31,0,0,1421,1422,6,66,-1,0,1422, + 1424,1,0,0,0,1423,1415,1,0,0,0,1423,1416,1,0,0,0,1424,133,1,0,0,0,1425, + 1436,1,0,0,0,1426,1427,3,136,68,0,1427,1432,6,67,-1,0,1428,1429,7,7,0, + 0,1429,1431,6,67,-1,0,1430,1428,1,0,0,0,1431,1434,1,0,0,0,1432,1430,1, + 0,0,0,1432,1433,1,0,0,0,1433,1436,1,0,0,0,1434,1432,1,0,0,0,1435,1425, + 1,0,0,0,1435,1426,1,0,0,0,1436,135,1,0,0,0,1437,1438,5,178,0,0,1438,1518, + 6,68,-1,0,1439,1440,5,207,0,0,1440,1518,6,68,-1,0,1441,1442,5,208,0,0, + 1442,1518,6,68,-1,0,1443,1444,5,201,0,0,1444,1518,6,68,-1,0,1445,1446, + 5,183,0,0,1446,1518,6,68,-1,0,1447,1448,5,184,0,0,1448,1518,6,68,-1,0, + 1449,1450,5,185,0,0,1450,1518,6,68,-1,0,1451,1452,5,186,0,0,1452,1518, + 6,68,-1,0,1453,1454,5,187,0,0,1454,1518,6,68,-1,0,1455,1456,5,188,0,0, + 1456,1518,6,68,-1,0,1457,1458,5,189,0,0,1458,1518,6,68,-1,0,1459,1460, + 5,190,0,0,1460,1518,6,68,-1,0,1461,1462,5,191,0,0,1462,1518,6,68,-1,0, + 1463,1464,5,192,0,0,1464,1518,6,68,-1,0,1465,1466,5,193,0,0,1466,1518, + 6,68,-1,0,1467,1468,5,262,0,0,1468,1518,6,68,-1,0,1469,1470,5,211,0,0, + 1470,1518,6,68,-1,0,1471,1472,5,212,0,0,1472,1518,6,68,-1,0,1473,1474, + 5,213,0,0,1474,1518,6,68,-1,0,1475,1476,5,214,0,0,1476,1518,6,68,-1,0, + 1477,1478,5,215,0,0,1478,1518,6,68,-1,0,1479,1480,5,218,0,0,1480,1518, + 6,68,-1,0,1481,1482,5,219,0,0,1482,1518,6,68,-1,0,1483,1484,5,222,0,0, + 1484,1518,6,68,-1,0,1485,1486,5,194,0,0,1486,1518,6,68,-1,0,1487,1488, + 5,195,0,0,1488,1518,6,68,-1,0,1489,1490,5,210,0,0,1490,1518,6,68,-1,0, + 1491,1492,5,230,0,0,1492,1518,6,68,-1,0,1493,1494,5,231,0,0,1494,1518, + 6,68,-1,0,1495,1496,5,232,0,0,1496,1518,6,68,-1,0,1497,1498,5,233,0,0, + 1498,1518,6,68,-1,0,1499,1500,5,234,0,0,1500,1518,6,68,-1,0,1501,1502, + 5,235,0,0,1502,1518,6,68,-1,0,1503,1504,5,236,0,0,1504,1518,6,68,-1,0, + 1505,1506,5,237,0,0,1506,1518,6,68,-1,0,1507,1508,5,238,0,0,1508,1518, + 6,68,-1,0,1509,1510,5,239,0,0,1510,1518,6,68,-1,0,1511,1512,5,240,0,0, + 1512,1518,6,68,-1,0,1513,1514,5,241,0,0,1514,1518,6,68,-1,0,1515,1516, + 5,242,0,0,1516,1518,6,68,-1,0,1517,1437,1,0,0,0,1517,1439,1,0,0,0,1517, + 1441,1,0,0,0,1517,1443,1,0,0,0,1517,1445,1,0,0,0,1517,1447,1,0,0,0,1517, + 1449,1,0,0,0,1517,1451,1,0,0,0,1517,1453,1,0,0,0,1517,1455,1,0,0,0,1517, + 1457,1,0,0,0,1517,1459,1,0,0,0,1517,1461,1,0,0,0,1517,1463,1,0,0,0,1517, + 1465,1,0,0,0,1517,1467,1,0,0,0,1517,1469,1,0,0,0,1517,1471,1,0,0,0,1517, + 1473,1,0,0,0,1517,1475,1,0,0,0,1517,1477,1,0,0,0,1517,1479,1,0,0,0,1517, + 1481,1,0,0,0,1517,1483,1,0,0,0,1517,1485,1,0,0,0,1517,1487,1,0,0,0,1517, + 1489,1,0,0,0,1517,1491,1,0,0,0,1517,1493,1,0,0,0,1517,1495,1,0,0,0,1517, + 1497,1,0,0,0,1517,1499,1,0,0,0,1517,1501,1,0,0,0,1517,1503,1,0,0,0,1517, + 1505,1,0,0,0,1517,1507,1,0,0,0,1517,1509,1,0,0,0,1517,1511,1,0,0,0,1517, + 1513,1,0,0,0,1517,1515,1,0,0,0,1518,137,1,0,0,0,1519,1520,3,142,71,0,1520, + 1526,6,69,-1,0,1521,1522,3,140,70,0,1522,1523,6,69,-1,0,1523,1525,1,0, + 0,0,1524,1521,1,0,0,0,1525,1528,1,0,0,0,1526,1524,1,0,0,0,1526,1527,1, + 0,0,0,1527,139,1,0,0,0,1528,1526,1,0,0,0,1529,1530,5,261,0,0,1530,1559, + 6,70,-1,0,1531,1532,5,42,0,0,1532,1533,5,43,0,0,1533,1559,6,70,-1,0,1534, + 1535,3,110,55,0,1535,1536,6,70,-1,0,1536,1559,1,0,0,0,1537,1538,5,260, + 0,0,1538,1559,6,70,-1,0,1539,1540,5,262,0,0,1540,1559,6,70,-1,0,1541,1542, + 5,92,0,0,1542,1559,6,70,-1,0,1543,1544,5,93,0,0,1544,1545,5,30,0,0,1545, + 1546,3,124,62,0,1546,1547,5,31,0,0,1547,1548,6,70,-1,0,1548,1559,1,0,0, + 0,1549,1550,5,94,0,0,1550,1551,5,30,0,0,1551,1552,3,124,62,0,1552,1553, + 5,31,0,0,1553,1554,6,70,-1,0,1554,1559,1,0,0,0,1555,1556,3,108,54,0,1556, + 1557,6,70,-1,0,1557,1559,1,0,0,0,1558,1529,1,0,0,0,1558,1531,1,0,0,0,1558, + 1534,1,0,0,0,1558,1537,1,0,0,0,1558,1539,1,0,0,0,1558,1541,1,0,0,0,1558, + 1543,1,0,0,0,1558,1549,1,0,0,0,1558,1555,1,0,0,0,1559,141,1,0,0,0,1560, + 1561,5,39,0,0,1561,1562,3,116,58,0,1562,1563,6,71,-1,0,1563,1619,1,0,0, + 0,1564,1565,5,197,0,0,1565,1619,6,71,-1,0,1566,1567,5,199,0,0,1567,1568, + 5,39,0,0,1568,1569,3,116,58,0,1569,1570,6,71,-1,0,1570,1619,1,0,0,0,1571, + 1572,5,200,0,0,1572,1573,3,116,58,0,1573,1574,6,71,-1,0,1574,1619,1,0, + 0,0,1575,1576,5,226,0,0,1576,1577,3,170,85,0,1577,1578,3,138,69,0,1578, + 1579,5,262,0,0,1579,1580,3,112,56,0,1580,1581,6,71,-1,0,1581,1619,1,0, + 0,0,1582,1583,5,253,0,0,1583,1584,3,32,16,0,1584,1585,6,71,-1,0,1585,1619, + 1,0,0,0,1586,1587,5,252,0,0,1587,1588,3,32,16,0,1588,1589,6,71,-1,0,1589, + 1619,1,0,0,0,1590,1591,5,253,0,0,1591,1592,3,2,1,0,1592,1593,6,71,-1,0, + 1593,1619,1,0,0,0,1594,1595,5,252,0,0,1595,1596,3,2,1,0,1596,1597,6,71, + -1,0,1597,1619,1,0,0,0,1598,1599,5,254,0,0,1599,1619,6,71,-1,0,1600,1601, + 5,201,0,0,1601,1619,6,71,-1,0,1602,1603,3,148,74,0,1603,1604,6,71,-1,0, + 1604,1619,1,0,0,0,1605,1606,3,150,75,0,1606,1607,6,71,-1,0,1607,1619,1, + 0,0,0,1608,1609,3,144,72,0,1609,1610,6,71,-1,0,1610,1619,1,0,0,0,1611, + 1612,3,2,1,0,1612,1613,6,71,-1,0,1613,1619,1,0,0,0,1614,1615,5,177,0,0, + 1615,1616,3,138,69,0,1616,1617,6,71,-1,0,1617,1619,1,0,0,0,1618,1560,1, + 0,0,0,1618,1564,1,0,0,0,1618,1566,1,0,0,0,1618,1571,1,0,0,0,1618,1575, + 1,0,0,0,1618,1582,1,0,0,0,1618,1586,1,0,0,0,1618,1590,1,0,0,0,1618,1594, + 1,0,0,0,1618,1598,1,0,0,0,1618,1600,1,0,0,0,1618,1602,1,0,0,0,1618,1605, + 1,0,0,0,1618,1608,1,0,0,0,1618,1611,1,0,0,0,1618,1614,1,0,0,0,1619,143, + 1,0,0,0,1620,1621,5,181,0,0,1621,1659,6,72,-1,0,1622,1623,5,182,0,0,1623, + 1659,6,72,-1,0,1624,1625,5,183,0,0,1625,1659,6,72,-1,0,1626,1627,5,184, + 0,0,1627,1659,6,72,-1,0,1628,1629,5,185,0,0,1629,1659,6,72,-1,0,1630,1631, + 5,186,0,0,1631,1659,6,72,-1,0,1632,1633,5,187,0,0,1633,1659,6,72,-1,0, + 1634,1635,5,188,0,0,1635,1659,6,72,-1,0,1636,1637,5,189,0,0,1637,1659, + 6,72,-1,0,1638,1639,5,190,0,0,1639,1659,6,72,-1,0,1640,1641,5,191,0,0, + 1641,1659,6,72,-1,0,1642,1643,5,192,0,0,1643,1659,6,72,-1,0,1644,1645, + 5,193,0,0,1645,1659,6,72,-1,0,1646,1647,5,90,0,0,1647,1648,5,184,0,0,1648, + 1659,6,72,-1,0,1649,1650,5,90,0,0,1650,1651,5,185,0,0,1651,1659,6,72,-1, + 0,1652,1653,5,90,0,0,1653,1654,5,186,0,0,1654,1659,6,72,-1,0,1655,1656, + 5,90,0,0,1656,1657,5,187,0,0,1657,1659,6,72,-1,0,1658,1620,1,0,0,0,1658, + 1622,1,0,0,0,1658,1624,1,0,0,0,1658,1626,1,0,0,0,1658,1628,1,0,0,0,1658, + 1630,1,0,0,0,1658,1632,1,0,0,0,1658,1634,1,0,0,0,1658,1636,1,0,0,0,1658, + 1638,1,0,0,0,1658,1640,1,0,0,0,1658,1642,1,0,0,0,1658,1644,1,0,0,0,1658, + 1646,1,0,0,0,1658,1649,1,0,0,0,1658,1652,1,0,0,0,1658,1655,1,0,0,0,1659, + 145,1,0,0,0,1660,1675,1,0,0,0,1661,1675,5,177,0,0,1662,1663,3,32,16,0, + 1663,1664,6,73,-1,0,1664,1675,1,0,0,0,1665,1666,3,32,16,0,1666,1667,5, + 177,0,0,1667,1668,3,32,16,0,1668,1669,6,73,-1,0,1669,1675,1,0,0,0,1670, + 1671,3,32,16,0,1671,1672,5,177,0,0,1672,1673,6,73,-1,0,1673,1675,1,0,0, + 0,1674,1660,1,0,0,0,1674,1661,1,0,0,0,1674,1662,1,0,0,0,1674,1665,1,0, + 0,0,1674,1670,1,0,0,0,1675,147,1,0,0,0,1676,1677,5,1,0,0,1677,1678,5,194, + 0,0,1678,1679,6,74,-1,0,1679,149,1,0,0,0,1680,1684,5,1,0,0,1681,1682,5, + 90,0,0,1682,1685,5,194,0,0,1683,1685,5,195,0,0,1684,1681,1,0,0,0,1684, + 1683,1,0,0,0,1685,1686,1,0,0,0,1686,1687,6,75,-1,0,1687,151,1,0,0,0,1688, + 1689,5,294,0,0,1689,1690,3,166,83,0,1690,1691,3,124,62,0,1691,1692,5,30, + 0,0,1692,1693,3,158,79,0,1693,1694,5,31,0,0,1694,1736,1,0,0,0,1695,1696, + 5,294,0,0,1696,1697,3,166,83,0,1697,1698,3,124,62,0,1698,1699,5,36,0,0, + 1699,1700,5,17,0,0,1700,1701,3,52,26,0,1701,1702,5,18,0,0,1702,1736,1, + 0,0,0,1703,1704,5,294,0,0,1704,1705,3,166,83,0,1705,1706,3,124,62,0,1706, + 1736,1,0,0,0,1707,1708,5,295,0,0,1708,1709,3,166,83,0,1709,1711,5,36,0, + 0,1710,1712,5,84,0,0,1711,1710,1,0,0,0,1711,1712,1,0,0,0,1712,1713,1,0, + 0,0,1713,1714,5,30,0,0,1714,1715,3,300,150,0,1715,1716,5,31,0,0,1716,1736, + 1,0,0,0,1717,1718,5,295,0,0,1718,1719,3,166,83,0,1719,1720,5,84,0,0,1720, + 1721,5,30,0,0,1721,1722,3,300,150,0,1722,1723,5,31,0,0,1723,1736,1,0,0, + 0,1724,1725,5,295,0,0,1725,1726,3,166,83,0,1726,1727,3,6,3,0,1727,1736, + 1,0,0,0,1728,1729,5,295,0,0,1729,1730,3,166,83,0,1730,1731,5,36,0,0,1731, + 1732,5,17,0,0,1732,1733,3,154,77,0,1733,1734,5,18,0,0,1734,1736,1,0,0, + 0,1735,1688,1,0,0,0,1735,1695,1,0,0,0,1735,1703,1,0,0,0,1735,1707,1,0, + 0,0,1735,1717,1,0,0,0,1735,1724,1,0,0,0,1735,1728,1,0,0,0,1736,153,1,0, + 0,0,1737,1748,1,0,0,0,1738,1739,3,156,78,0,1739,1740,5,28,0,0,1740,1742, + 1,0,0,0,1741,1738,1,0,0,0,1742,1745,1,0,0,0,1743,1741,1,0,0,0,1743,1744, + 1,0,0,0,1744,1746,1,0,0,0,1745,1743,1,0,0,0,1746,1748,3,156,78,0,1747, + 1737,1,0,0,0,1747,1743,1,0,0,0,1748,155,1,0,0,0,1749,1750,5,39,0,0,1750, + 1751,5,264,0,0,1751,1752,5,36,0,0,1752,1753,5,17,0,0,1753,1754,3,56,28, + 0,1754,1755,5,18,0,0,1755,1763,1,0,0,0,1756,1757,3,124,62,0,1757,1758, + 5,36,0,0,1758,1759,5,17,0,0,1759,1760,3,56,28,0,1760,1761,5,18,0,0,1761, + 1763,1,0,0,0,1762,1749,1,0,0,0,1762,1756,1,0,0,0,1763,157,1,0,0,0,1764, + 1765,3,160,80,0,1765,1766,5,28,0,0,1766,1768,1,0,0,0,1767,1764,1,0,0,0, + 1768,1771,1,0,0,0,1769,1767,1,0,0,0,1769,1770,1,0,0,0,1770,1772,1,0,0, + 0,1771,1769,1,0,0,0,1772,1773,3,160,80,0,1773,159,1,0,0,0,1774,1775,3, + 6,3,0,1775,1776,5,36,0,0,1776,1777,3,164,82,0,1777,161,1,0,0,0,1778,1779, + 7,8,0,0,1779,163,1,0,0,0,1780,1815,3,162,81,0,1781,1815,3,32,16,0,1782, + 1783,5,186,0,0,1783,1784,5,30,0,0,1784,1785,3,32,16,0,1785,1786,5,31,0, + 0,1786,1815,1,0,0,0,1787,1815,3,6,3,0,1788,1789,3,116,58,0,1789,1790,5, + 30,0,0,1790,1791,5,184,0,0,1791,1792,5,75,0,0,1792,1793,3,32,16,0,1793, + 1794,5,31,0,0,1794,1815,1,0,0,0,1795,1796,3,116,58,0,1796,1797,5,30,0, + 0,1797,1798,5,185,0,0,1798,1799,5,75,0,0,1799,1800,3,32,16,0,1800,1801, + 5,31,0,0,1801,1815,1,0,0,0,1802,1803,3,116,58,0,1803,1804,5,30,0,0,1804, + 1805,5,186,0,0,1805,1806,5,75,0,0,1806,1807,3,32,16,0,1807,1808,5,31,0, + 0,1808,1815,1,0,0,0,1809,1810,3,116,58,0,1810,1811,5,30,0,0,1811,1812, + 3,32,16,0,1812,1813,5,31,0,0,1813,1815,1,0,0,0,1814,1780,1,0,0,0,1814, + 1781,1,0,0,0,1814,1782,1,0,0,0,1814,1787,1,0,0,0,1814,1788,1,0,0,0,1814, + 1795,1,0,0,0,1814,1802,1,0,0,0,1814,1809,1,0,0,0,1815,165,1,0,0,0,1816, + 1817,7,9,0,0,1817,167,1,0,0,0,1818,1819,3,170,85,0,1819,1820,3,138,69, + 0,1820,1821,3,124,62,0,1821,1822,5,176,0,0,1822,1824,3,242,121,0,1823, + 1825,3,108,54,0,1824,1823,1,0,0,0,1824,1825,1,0,0,0,1825,1826,1,0,0,0, + 1826,1827,3,112,56,0,1827,1828,6,84,-1,0,1828,1861,1,0,0,0,1829,1830,3, + 170,85,0,1830,1831,3,138,69,0,1831,1832,3,124,62,0,1832,1833,5,176,0,0, + 1833,1834,3,242,121,0,1834,1835,3,196,98,0,1835,1836,3,112,56,0,1836,1837, + 6,84,-1,0,1837,1861,1,0,0,0,1838,1839,3,170,85,0,1839,1840,3,138,69,0, + 1840,1842,3,242,121,0,1841,1843,3,108,54,0,1842,1841,1,0,0,0,1842,1843, + 1,0,0,0,1843,1844,1,0,0,0,1844,1845,3,112,56,0,1845,1846,6,84,-1,0,1846, + 1861,1,0,0,0,1847,1848,3,170,85,0,1848,1849,3,138,69,0,1849,1850,3,242, + 121,0,1850,1851,3,196,98,0,1851,1852,3,112,56,0,1852,1853,6,84,-1,0,1853, + 1861,1,0,0,0,1854,1855,3,174,87,0,1855,1856,6,84,-1,0,1856,1861,1,0,0, + 0,1857,1858,3,2,1,0,1858,1859,6,84,-1,0,1859,1861,1,0,0,0,1860,1818,1, + 0,0,0,1860,1829,1,0,0,0,1860,1838,1,0,0,0,1860,1847,1,0,0,0,1860,1854, + 1,0,0,0,1860,1857,1,0,0,0,1861,169,1,0,0,0,1862,1863,5,243,0,0,1863,1864, + 3,170,85,0,1864,1865,6,85,-1,0,1865,1880,1,0,0,0,1866,1867,5,244,0,0,1867, + 1868,3,170,85,0,1868,1869,6,85,-1,0,1869,1880,1,0,0,0,1870,1871,3,172, + 86,0,1871,1872,6,85,-1,0,1872,1880,1,0,0,0,1873,1874,5,112,0,0,1874,1875, + 5,30,0,0,1875,1876,3,32,16,0,1876,1877,5,31,0,0,1877,1878,6,85,-1,0,1878, + 1880,1,0,0,0,1879,1862,1,0,0,0,1879,1866,1,0,0,0,1879,1870,1,0,0,0,1879, + 1873,1,0,0,0,1880,171,1,0,0,0,1881,1901,1,0,0,0,1882,1883,5,245,0,0,1883, + 1901,6,86,-1,0,1884,1885,5,246,0,0,1885,1901,6,86,-1,0,1886,1887,5,247, + 0,0,1887,1888,5,248,0,0,1888,1901,6,86,-1,0,1889,1890,5,247,0,0,1890,1891, + 5,249,0,0,1891,1901,6,86,-1,0,1892,1893,5,247,0,0,1893,1894,5,250,0,0, + 1894,1901,6,86,-1,0,1895,1896,5,247,0,0,1896,1897,5,251,0,0,1897,1901, + 6,86,-1,0,1898,1899,5,247,0,0,1899,1901,6,86,-1,0,1900,1881,1,0,0,0,1900, + 1882,1,0,0,0,1900,1884,1,0,0,0,1900,1886,1,0,0,0,1900,1889,1,0,0,0,1900, + 1892,1,0,0,0,1900,1895,1,0,0,0,1900,1898,1,0,0,0,1901,173,1,0,0,0,1902, + 1903,5,113,0,0,1903,1904,5,30,0,0,1904,1905,3,32,16,0,1905,1906,5,31,0, + 0,1906,1907,6,87,-1,0,1907,175,1,0,0,0,1908,1909,5,226,0,0,1909,1910,3, + 168,84,0,1910,1911,6,88,-1,0,1911,1920,1,0,0,0,1912,1913,5,37,0,0,1913, + 1914,3,178,89,0,1914,1915,6,88,-1,0,1915,1920,1,0,0,0,1916,1917,3,174, + 87,0,1917,1918,6,88,-1,0,1918,1920,1,0,0,0,1919,1908,1,0,0,0,1919,1912, + 1,0,0,0,1919,1916,1,0,0,0,1920,177,1,0,0,0,1921,1922,3,138,69,0,1922,1923, + 3,124,62,0,1923,1924,5,176,0,0,1924,1925,3,2,1,0,1925,1926,6,89,-1,0,1926, + 1935,1,0,0,0,1927,1928,3,138,69,0,1928,1929,3,2,1,0,1929,1930,6,89,-1, + 0,1930,1935,1,0,0,0,1931,1932,3,2,1,0,1932,1933,6,89,-1,0,1933,1935,1, + 0,0,0,1934,1921,1,0,0,0,1934,1927,1,0,0,0,1934,1931,1,0,0,0,1935,179,1, + 0,0,0,1936,1937,3,124,62,0,1937,1938,5,28,0,0,1938,1940,1,0,0,0,1939,1936, + 1,0,0,0,1940,1943,1,0,0,0,1941,1939,1,0,0,0,1941,1942,1,0,0,0,1942,1944, + 1,0,0,0,1943,1941,1,0,0,0,1944,1945,3,124,62,0,1945,181,1,0,0,0,1946,1952, + 1,0,0,0,1947,1948,5,86,0,0,1948,1949,3,190,95,0,1949,1950,5,87,0,0,1950, + 1952,1,0,0,0,1951,1946,1,0,0,0,1951,1947,1,0,0,0,1952,183,1,0,0,0,1953, + 1965,5,266,0,0,1954,1965,5,114,0,0,1955,1965,5,39,0,0,1956,1965,5,200, + 0,0,1957,1965,5,115,0,0,1958,1965,5,116,0,0,1959,1960,5,70,0,0,1960,1961, + 5,30,0,0,1961,1962,3,32,16,0,1962,1963,5,31,0,0,1963,1965,1,0,0,0,1964, + 1953,1,0,0,0,1964,1954,1,0,0,0,1964,1955,1,0,0,0,1964,1956,1,0,0,0,1964, + 1957,1,0,0,0,1964,1958,1,0,0,0,1964,1959,1,0,0,0,1965,185,1,0,0,0,1966, + 1968,3,184,92,0,1967,1966,1,0,0,0,1968,1971,1,0,0,0,1969,1967,1,0,0,0, + 1969,1970,1,0,0,0,1970,187,1,0,0,0,1971,1969,1,0,0,0,1972,1974,3,186,93, + 0,1973,1975,3,192,96,0,1974,1973,1,0,0,0,1974,1975,1,0,0,0,1975,1976,1, + 0,0,0,1976,1977,3,2,1,0,1977,189,1,0,0,0,1978,1979,3,188,94,0,1979,1980, + 5,28,0,0,1980,1982,1,0,0,0,1981,1978,1,0,0,0,1982,1985,1,0,0,0,1983,1981, + 1,0,0,0,1983,1984,1,0,0,0,1984,1986,1,0,0,0,1985,1983,1,0,0,0,1986,1987, + 3,188,94,0,1987,191,1,0,0,0,1988,1989,5,30,0,0,1989,1990,3,180,90,0,1990, + 1991,5,31,0,0,1991,193,1,0,0,0,1992,1994,3,196,98,0,1993,1992,1,0,0,0, + 1993,1994,1,0,0,0,1994,1995,1,0,0,0,1995,1996,6,97,-1,0,1996,195,1,0,0, + 0,1997,1998,5,86,0,0,1998,1999,5,42,0,0,1999,2000,3,32,16,0,2000,2001, + 5,43,0,0,2001,2002,5,87,0,0,2002,2003,6,98,-1,0,2003,197,1,0,0,0,2004, + 2005,3,234,117,0,2005,2006,5,17,0,0,2006,2007,3,246,123,0,2007,2008,5, + 18,0,0,2008,2121,1,0,0,0,2009,2010,3,74,37,0,2010,2011,5,17,0,0,2011,2012, + 3,82,41,0,2012,2013,5,18,0,0,2013,2121,1,0,0,0,2014,2015,3,210,105,0,2015, + 2016,5,17,0,0,2016,2017,3,214,107,0,2017,2018,5,18,0,0,2018,2121,1,0,0, + 0,2019,2020,3,218,109,0,2020,2021,5,17,0,0,2021,2022,3,222,111,0,2022, + 2023,5,18,0,0,2023,2121,1,0,0,0,2024,2121,3,200,100,0,2025,2121,3,284, + 142,0,2026,2121,3,152,76,0,2027,2121,3,88,44,0,2028,2121,3,330,165,0,2029, + 2030,5,117,0,0,2030,2121,3,32,16,0,2031,2032,5,118,0,0,2032,2121,3,32, + 16,0,2033,2034,3,342,171,0,2034,2035,5,17,0,0,2035,2036,3,346,173,0,2036, + 2037,5,18,0,0,2037,2121,1,0,0,0,2038,2039,5,302,0,0,2039,2040,3,124,62, + 0,2040,2041,5,176,0,0,2041,2042,3,242,121,0,2042,2043,5,119,0,0,2043,2044, + 3,170,85,0,2044,2045,3,138,69,0,2045,2046,3,124,62,0,2046,2047,5,176,0, + 0,2047,2048,3,242,121,0,2048,2049,3,112,56,0,2049,2121,1,0,0,0,2050,2051, + 5,302,0,0,2051,2052,5,226,0,0,2052,2053,3,170,85,0,2053,2054,3,138,69, + 0,2054,2055,3,124,62,0,2055,2056,5,176,0,0,2056,2057,3,242,121,0,2057, + 2058,3,194,97,0,2058,2059,3,112,56,0,2059,2060,5,119,0,0,2060,2061,5,226, + 0,0,2061,2062,3,170,85,0,2062,2063,3,138,69,0,2063,2064,3,124,62,0,2064, + 2065,5,176,0,0,2065,2066,3,242,121,0,2066,2067,3,194,97,0,2067,2068,3, + 112,56,0,2068,2121,1,0,0,0,2069,2121,3,26,13,0,2070,2121,3,40,20,0,2071, + 2072,5,255,0,0,2072,2073,5,196,0,0,2073,2074,5,42,0,0,2074,2075,3,32,16, + 0,2075,2079,5,43,0,0,2076,2078,3,330,165,0,2077,2076,1,0,0,0,2078,2081, + 1,0,0,0,2079,2077,1,0,0,0,2079,2080,1,0,0,0,2080,2121,1,0,0,0,2081,2079, + 1,0,0,0,2082,2083,5,255,0,0,2083,2084,5,196,0,0,2084,2088,3,2,1,0,2085, + 2087,3,330,165,0,2086,2085,1,0,0,0,2087,2090,1,0,0,0,2088,2086,1,0,0,0, + 2088,2089,1,0,0,0,2089,2121,1,0,0,0,2090,2088,1,0,0,0,2091,2092,5,255, + 0,0,2092,2093,5,256,0,0,2093,2094,5,42,0,0,2094,2095,3,32,16,0,2095,2096, + 5,43,0,0,2096,2097,5,28,0,0,2097,2101,3,124,62,0,2098,2100,3,330,165,0, + 2099,2098,1,0,0,0,2100,2103,1,0,0,0,2101,2099,1,0,0,0,2101,2102,1,0,0, + 0,2102,2121,1,0,0,0,2103,2101,1,0,0,0,2104,2105,5,255,0,0,2105,2106,5, + 256,0,0,2106,2107,3,2,1,0,2107,2108,5,28,0,0,2108,2112,3,124,62,0,2109, + 2111,3,330,165,0,2110,2109,1,0,0,0,2111,2114,1,0,0,0,2112,2110,1,0,0,0, + 2112,2113,1,0,0,0,2113,2121,1,0,0,0,2114,2112,1,0,0,0,2115,2116,5,120, + 0,0,2116,2117,5,196,0,0,2117,2118,3,124,62,0,2118,2119,3,44,22,0,2119, + 2121,1,0,0,0,2120,2004,1,0,0,0,2120,2009,1,0,0,0,2120,2014,1,0,0,0,2120, + 2019,1,0,0,0,2120,2024,1,0,0,0,2120,2025,1,0,0,0,2120,2026,1,0,0,0,2120, + 2027,1,0,0,0,2120,2028,1,0,0,0,2120,2029,1,0,0,0,2120,2031,1,0,0,0,2120, + 2033,1,0,0,0,2120,2038,1,0,0,0,2120,2050,1,0,0,0,2120,2069,1,0,0,0,2120, + 2070,1,0,0,0,2120,2071,1,0,0,0,2120,2082,1,0,0,0,2120,2091,1,0,0,0,2120, + 2104,1,0,0,0,2120,2115,1,0,0,0,2121,199,1,0,0,0,2122,2123,5,121,0,0,2123, + 2132,3,208,104,0,2124,2131,3,202,101,0,2125,2126,5,122,0,0,2126,2127,5, + 30,0,0,2127,2128,3,228,114,0,2128,2129,5,31,0,0,2129,2131,1,0,0,0,2130, + 2124,1,0,0,0,2130,2125,1,0,0,0,2131,2134,1,0,0,0,2132,2130,1,0,0,0,2132, + 2133,1,0,0,0,2133,2135,1,0,0,0,2134,2132,1,0,0,0,2135,2136,3,138,69,0, + 2136,2137,3,2,1,0,2137,2138,3,204,102,0,2138,2139,3,206,103,0,2139,201, + 1,0,0,0,2140,2160,5,123,0,0,2141,2160,5,51,0,0,2142,2160,5,52,0,0,2143, + 2160,5,63,0,0,2144,2160,5,124,0,0,2145,2160,5,69,0,0,2146,2160,5,68,0, + 0,2147,2160,5,64,0,0,2148,2160,5,65,0,0,2149,2160,5,66,0,0,2150,2160,5, + 125,0,0,2151,2160,5,126,0,0,2152,2160,5,127,0,0,2153,2160,5,16,0,0,2154, + 2155,5,70,0,0,2155,2156,5,30,0,0,2156,2157,3,32,16,0,2157,2158,5,31,0, + 0,2158,2160,1,0,0,0,2159,2140,1,0,0,0,2159,2141,1,0,0,0,2159,2142,1,0, + 0,0,2159,2143,1,0,0,0,2159,2144,1,0,0,0,2159,2145,1,0,0,0,2159,2146,1, + 0,0,0,2159,2147,1,0,0,0,2159,2148,1,0,0,0,2159,2149,1,0,0,0,2159,2150, + 1,0,0,0,2159,2151,1,0,0,0,2159,2152,1,0,0,0,2159,2153,1,0,0,0,2159,2154, + 1,0,0,0,2160,203,1,0,0,0,2161,2167,1,0,0,0,2162,2163,5,44,0,0,2163,2167, + 3,0,0,0,2164,2165,5,44,0,0,2165,2167,3,32,16,0,2166,2161,1,0,0,0,2166, + 2162,1,0,0,0,2166,2164,1,0,0,0,2167,205,1,0,0,0,2168,2172,1,0,0,0,2169, + 2170,5,36,0,0,2170,2172,3,304,152,0,2171,2168,1,0,0,0,2171,2169,1,0,0, + 0,2172,207,1,0,0,0,2173,2179,1,0,0,0,2174,2175,5,42,0,0,2175,2176,3,32, + 16,0,2176,2177,5,43,0,0,2177,2179,1,0,0,0,2178,2173,1,0,0,0,2178,2174, + 1,0,0,0,2179,209,1,0,0,0,2180,2184,5,128,0,0,2181,2183,3,212,106,0,2182, + 2181,1,0,0,0,2183,2186,1,0,0,0,2184,2182,1,0,0,0,2184,2185,1,0,0,0,2185, + 2187,1,0,0,0,2186,2184,1,0,0,0,2187,2188,3,124,62,0,2188,2189,3,2,1,0, + 2189,2199,1,0,0,0,2190,2194,5,128,0,0,2191,2193,3,212,106,0,2192,2191, + 1,0,0,0,2193,2196,1,0,0,0,2194,2192,1,0,0,0,2194,2195,1,0,0,0,2195,2197, + 1,0,0,0,2196,2194,1,0,0,0,2197,2199,3,2,1,0,2198,2180,1,0,0,0,2198,2190, + 1,0,0,0,2199,211,1,0,0,0,2200,2201,7,10,0,0,2201,213,1,0,0,0,2202,2204, + 3,216,108,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,215,1,0,0,0,2207,2205,1,0,0,0,2208,2209,5,129,0,0,2209, + 2221,3,168,84,0,2210,2211,5,130,0,0,2211,2221,3,168,84,0,2212,2213,5,131, + 0,0,2213,2221,3,168,84,0,2214,2215,5,132,0,0,2215,2221,3,168,84,0,2216, + 2221,3,88,44,0,2217,2221,3,330,165,0,2218,2221,3,26,13,0,2219,2221,3,40, + 20,0,2220,2208,1,0,0,0,2220,2210,1,0,0,0,2220,2212,1,0,0,0,2220,2214,1, + 0,0,0,2220,2216,1,0,0,0,2220,2217,1,0,0,0,2220,2218,1,0,0,0,2220,2219, + 1,0,0,0,2221,217,1,0,0,0,2222,2226,5,133,0,0,2223,2225,3,220,110,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,2230,3,170,85,0,2230,2231,3,138,69, + 0,2231,2232,3,2,1,0,2232,2233,3,112,56,0,2233,2234,3,206,103,0,2234,219, + 1,0,0,0,2235,2236,7,10,0,0,2236,221,1,0,0,0,2237,2239,3,224,112,0,2238, + 2237,1,0,0,0,2239,2242,1,0,0,0,2240,2238,1,0,0,0,2240,2241,1,0,0,0,2241, + 223,1,0,0,0,2242,2240,1,0,0,0,2243,2244,5,134,0,0,2244,2254,3,168,84,0, + 2245,2246,5,135,0,0,2246,2254,3,168,84,0,2247,2248,5,132,0,0,2248,2254, + 3,168,84,0,2249,2254,3,330,165,0,2250,2254,3,88,44,0,2251,2254,3,26,13, + 0,2252,2254,3,40,20,0,2253,2243,1,0,0,0,2253,2245,1,0,0,0,2253,2247,1, + 0,0,0,2253,2249,1,0,0,0,2253,2250,1,0,0,0,2253,2251,1,0,0,0,2253,2252, + 1,0,0,0,2254,225,1,0,0,0,2255,2263,6,113,-1,0,2256,2257,5,122,0,0,2257, + 2258,5,30,0,0,2258,2259,3,228,114,0,2259,2260,5,31,0,0,2260,2261,6,113, + -1,0,2261,2263,1,0,0,0,2262,2255,1,0,0,0,2262,2256,1,0,0,0,2263,227,1, + 0,0,0,2264,2265,3,126,63,0,2265,2266,6,114,-1,0,2266,2278,1,0,0,0,2267, + 2271,5,17,0,0,2268,2269,3,302,151,0,2269,2270,6,114,-1,0,2270,2272,1,0, + 0,0,2271,2268,1,0,0,0,2272,2273,1,0,0,0,2273,2271,1,0,0,0,2273,2274,1, + 0,0,0,2274,2275,1,0,0,0,2275,2276,5,18,0,0,2276,2278,1,0,0,0,2277,2264, + 1,0,0,0,2277,2267,1,0,0,0,2278,229,1,0,0,0,2279,2280,3,232,116,0,2280, + 2281,6,115,-1,0,2281,2283,1,0,0,0,2282,2279,1,0,0,0,2283,2286,1,0,0,0, + 2284,2282,1,0,0,0,2284,2285,1,0,0,0,2285,231,1,0,0,0,2286,2284,1,0,0,0, + 2287,2288,5,42,0,0,2288,2289,5,136,0,0,2289,2290,5,43,0,0,2290,2305,6, + 116,-1,0,2291,2292,5,42,0,0,2292,2293,5,137,0,0,2293,2294,5,43,0,0,2294, + 2305,6,116,-1,0,2295,2296,5,42,0,0,2296,2297,5,138,0,0,2297,2298,5,43, + 0,0,2298,2305,6,116,-1,0,2299,2300,5,42,0,0,2300,2301,3,32,16,0,2301,2302, + 5,43,0,0,2302,2303,6,116,-1,0,2303,2305,1,0,0,0,2304,2287,1,0,0,0,2304, + 2291,1,0,0,0,2304,2295,1,0,0,0,2304,2299,1,0,0,0,2305,233,1,0,0,0,2306, + 2311,5,139,0,0,2307,2310,3,236,118,0,2308,2310,3,238,119,0,2309,2307,1, + 0,0,0,2309,2308,1,0,0,0,2310,2313,1,0,0,0,2311,2309,1,0,0,0,2311,2312, + 1,0,0,0,2312,2314,1,0,0,0,2313,2311,1,0,0,0,2314,2315,3,170,85,0,2315, + 2316,3,230,115,0,2316,2317,3,138,69,0,2317,2318,3,226,113,0,2318,2319, + 3,242,121,0,2319,2320,3,182,91,0,2320,2324,3,112,56,0,2321,2323,3,244, + 122,0,2322,2321,1,0,0,0,2323,2326,1,0,0,0,2324,2322,1,0,0,0,2324,2325, + 1,0,0,0,2325,235,1,0,0,0,2326,2324,1,0,0,0,2327,2351,5,123,0,0,2328,2351, + 5,51,0,0,2329,2351,5,52,0,0,2330,2351,5,63,0,0,2331,2351,5,140,0,0,2332, + 2351,5,68,0,0,2333,2351,5,141,0,0,2334,2351,5,142,0,0,2335,2351,5,54,0, + 0,2336,2351,5,64,0,0,2337,2351,5,65,0,0,2338,2351,5,66,0,0,2339,2351,5, + 125,0,0,2340,2351,5,143,0,0,2341,2351,5,144,0,0,2342,2351,5,69,0,0,2343, + 2351,5,145,0,0,2344,2351,5,146,0,0,2345,2346,5,70,0,0,2346,2347,5,30,0, + 0,2347,2348,3,32,16,0,2348,2349,5,31,0,0,2349,2351,1,0,0,0,2350,2327,1, + 0,0,0,2350,2328,1,0,0,0,2350,2329,1,0,0,0,2350,2330,1,0,0,0,2350,2331, + 1,0,0,0,2350,2332,1,0,0,0,2350,2333,1,0,0,0,2350,2334,1,0,0,0,2350,2335, + 1,0,0,0,2350,2336,1,0,0,0,2350,2337,1,0,0,0,2350,2338,1,0,0,0,2350,2339, + 1,0,0,0,2350,2340,1,0,0,0,2350,2341,1,0,0,0,2350,2342,1,0,0,0,2350,2343, + 1,0,0,0,2350,2344,1,0,0,0,2350,2345,1,0,0,0,2351,237,1,0,0,0,2352,2353, + 5,147,0,0,2353,2359,5,30,0,0,2354,2357,3,6,3,0,2355,2356,5,34,0,0,2356, + 2358,3,6,3,0,2357,2355,1,0,0,0,2357,2358,1,0,0,0,2358,2360,1,0,0,0,2359, + 2354,1,0,0,0,2359,2360,1,0,0,0,2360,2364,1,0,0,0,2361,2363,3,240,120,0, + 2362,2361,1,0,0,0,2363,2366,1,0,0,0,2364,2362,1,0,0,0,2364,2365,1,0,0, + 0,2365,2367,1,0,0,0,2366,2364,1,0,0,0,2367,2371,5,31,0,0,2368,2369,5,147, + 0,0,2369,2371,5,85,0,0,2370,2352,1,0,0,0,2370,2368,1,0,0,0,2371,239,1, + 0,0,0,2372,2400,5,148,0,0,2373,2400,5,224,0,0,2374,2400,5,57,0,0,2375, + 2400,5,58,0,0,2376,2400,5,149,0,0,2377,2400,5,150,0,0,2378,2400,5,248, + 0,0,2379,2400,5,249,0,0,2380,2400,5,250,0,0,2381,2400,5,251,0,0,2382,2383, + 5,151,0,0,2383,2384,5,75,0,0,2384,2400,5,152,0,0,2385,2386,5,151,0,0,2386, + 2387,5,75,0,0,2387,2400,5,153,0,0,2388,2389,5,154,0,0,2389,2390,5,75,0, + 0,2390,2400,5,152,0,0,2391,2392,5,154,0,0,2392,2393,5,75,0,0,2393,2400, + 5,153,0,0,2394,2395,5,70,0,0,2395,2396,5,30,0,0,2396,2397,3,32,16,0,2397, + 2398,5,31,0,0,2398,2400,1,0,0,0,2399,2372,1,0,0,0,2399,2373,1,0,0,0,2399, + 2374,1,0,0,0,2399,2375,1,0,0,0,2399,2376,1,0,0,0,2399,2377,1,0,0,0,2399, + 2378,1,0,0,0,2399,2379,1,0,0,0,2399,2380,1,0,0,0,2399,2381,1,0,0,0,2399, + 2382,1,0,0,0,2399,2385,1,0,0,0,2399,2388,1,0,0,0,2399,2391,1,0,0,0,2399, + 2394,1,0,0,0,2400,241,1,0,0,0,2401,2402,5,116,0,0,2402,2409,6,121,-1,0, + 2403,2404,5,155,0,0,2404,2409,6,121,-1,0,2405,2406,3,2,1,0,2406,2407,6, + 121,-1,0,2407,2409,1,0,0,0,2408,2401,1,0,0,0,2408,2403,1,0,0,0,2408,2405, + 1,0,0,0,2409,243,1,0,0,0,2410,2432,5,1,0,0,2411,2432,5,2,0,0,2412,2432, + 5,156,0,0,2413,2432,5,3,0,0,2414,2432,5,4,0,0,2415,2432,5,247,0,0,2416, + 2432,5,5,0,0,2417,2432,5,6,0,0,2418,2432,5,7,0,0,2419,2432,5,8,0,0,2420, + 2432,5,9,0,0,2421,2432,5,10,0,0,2422,2432,5,11,0,0,2423,2432,5,12,0,0, + 2424,2432,5,13,0,0,2425,2432,5,14,0,0,2426,2427,5,70,0,0,2427,2428,5,30, + 0,0,2428,2429,3,32,16,0,2429,2430,5,31,0,0,2430,2432,1,0,0,0,2431,2410, + 1,0,0,0,2431,2411,1,0,0,0,2431,2412,1,0,0,0,2431,2413,1,0,0,0,2431,2414, + 1,0,0,0,2431,2415,1,0,0,0,2431,2416,1,0,0,0,2431,2417,1,0,0,0,2431,2418, + 1,0,0,0,2431,2419,1,0,0,0,2431,2420,1,0,0,0,2431,2421,1,0,0,0,2431,2422, + 1,0,0,0,2431,2423,1,0,0,0,2431,2424,1,0,0,0,2431,2425,1,0,0,0,2431,2426, + 1,0,0,0,2432,245,1,0,0,0,2433,2435,3,248,124,0,2434,2433,1,0,0,0,2435, + 2438,1,0,0,0,2436,2434,1,0,0,0,2436,2437,1,0,0,0,2437,247,1,0,0,0,2438, + 2436,1,0,0,0,2439,2477,3,100,50,0,2440,2441,5,296,0,0,2441,2442,3,32,16, + 0,2442,2443,6,124,-1,0,2443,2477,1,0,0,0,2444,2477,3,266,133,0,2445,2446, + 5,297,0,0,2446,2447,3,32,16,0,2447,2448,6,124,-1,0,2448,2477,1,0,0,0,2449, + 2450,5,298,0,0,2450,2477,6,124,-1,0,2451,2452,5,299,0,0,2452,2477,6,124, + -1,0,2453,2477,3,260,130,0,2454,2477,3,264,132,0,2455,2477,3,250,125,0, + 2456,2457,3,284,142,0,2457,2458,6,124,-1,0,2458,2477,1,0,0,0,2459,2460, + 3,152,76,0,2460,2461,6,124,-1,0,2461,2477,1,0,0,0,2462,2463,3,88,44,0, + 2463,2464,6,124,-1,0,2464,2477,1,0,0,0,2465,2466,3,26,13,0,2466,2467,6, + 124,-1,0,2467,2477,1,0,0,0,2468,2469,3,262,131,0,2469,2470,6,124,-1,0, + 2470,2477,1,0,0,0,2471,2477,3,40,20,0,2472,2477,3,252,126,0,2473,2477, + 3,254,127,0,2474,2477,3,256,128,0,2475,2477,3,258,129,0,2476,2439,1,0, + 0,0,2476,2440,1,0,0,0,2476,2444,1,0,0,0,2476,2445,1,0,0,0,2476,2449,1, + 0,0,0,2476,2451,1,0,0,0,2476,2453,1,0,0,0,2476,2454,1,0,0,0,2476,2455, + 1,0,0,0,2476,2456,1,0,0,0,2476,2459,1,0,0,0,2476,2462,1,0,0,0,2476,2465, + 1,0,0,0,2476,2468,1,0,0,0,2476,2471,1,0,0,0,2476,2472,1,0,0,0,2476,2473, + 1,0,0,0,2476,2474,1,0,0,0,2476,2475,1,0,0,0,2477,249,1,0,0,0,2478,2480, + 5,300,0,0,2479,2481,5,157,0,0,2480,2479,1,0,0,0,2480,2481,1,0,0,0,2481, + 2482,1,0,0,0,2482,2483,3,112,56,0,2483,251,1,0,0,0,2484,2485,5,301,0,0, + 2485,2486,5,42,0,0,2486,2487,3,32,16,0,2487,2490,5,43,0,0,2488,2489,5, + 34,0,0,2489,2491,3,0,0,0,2490,2488,1,0,0,0,2490,2491,1,0,0,0,2491,253, + 1,0,0,0,2492,2493,5,303,0,0,2493,2494,3,32,16,0,2494,2495,5,75,0,0,2495, + 2496,3,32,16,0,2496,255,1,0,0,0,2497,2498,5,302,0,0,2498,2499,3,124,62, + 0,2499,2500,5,176,0,0,2500,2501,3,242,121,0,2501,2513,1,0,0,0,2502,2503, + 5,302,0,0,2503,2504,5,226,0,0,2504,2505,3,170,85,0,2505,2506,3,138,69, + 0,2506,2507,3,124,62,0,2507,2508,5,176,0,0,2508,2509,3,242,121,0,2509, + 2510,3,194,97,0,2510,2511,3,112,56,0,2511,2513,1,0,0,0,2512,2497,1,0,0, + 0,2512,2502,1,0,0,0,2513,257,1,0,0,0,2514,2515,5,255,0,0,2515,2516,5,196, + 0,0,2516,2517,5,42,0,0,2517,2518,3,32,16,0,2518,2524,5,43,0,0,2519,2520, + 3,330,165,0,2520,2521,6,129,-1,0,2521,2523,1,0,0,0,2522,2519,1,0,0,0,2523, + 2526,1,0,0,0,2524,2522,1,0,0,0,2524,2525,1,0,0,0,2525,2580,1,0,0,0,2526, + 2524,1,0,0,0,2527,2528,5,255,0,0,2528,2529,5,196,0,0,2529,2535,3,2,1,0, + 2530,2531,3,330,165,0,2531,2532,6,129,-1,0,2532,2534,1,0,0,0,2533,2530, + 1,0,0,0,2534,2537,1,0,0,0,2535,2533,1,0,0,0,2535,2536,1,0,0,0,2536,2580, + 1,0,0,0,2537,2535,1,0,0,0,2538,2539,5,255,0,0,2539,2540,5,256,0,0,2540, + 2541,5,42,0,0,2541,2542,3,32,16,0,2542,2543,5,43,0,0,2543,2544,5,28,0, + 0,2544,2550,3,124,62,0,2545,2546,3,330,165,0,2546,2547,6,129,-1,0,2547, + 2549,1,0,0,0,2548,2545,1,0,0,0,2549,2552,1,0,0,0,2550,2548,1,0,0,0,2550, + 2551,1,0,0,0,2551,2580,1,0,0,0,2552,2550,1,0,0,0,2553,2554,5,255,0,0,2554, + 2555,5,256,0,0,2555,2556,3,2,1,0,2556,2557,5,28,0,0,2557,2563,3,124,62, + 0,2558,2559,3,330,165,0,2559,2560,6,129,-1,0,2560,2562,1,0,0,0,2561,2558, + 1,0,0,0,2562,2565,1,0,0,0,2563,2561,1,0,0,0,2563,2564,1,0,0,0,2564,2580, + 1,0,0,0,2565,2563,1,0,0,0,2566,2567,5,255,0,0,2567,2568,5,42,0,0,2568, + 2569,3,32,16,0,2569,2570,5,43,0,0,2570,2576,3,206,103,0,2571,2572,3,330, + 165,0,2572,2573,6,129,-1,0,2573,2575,1,0,0,0,2574,2571,1,0,0,0,2575,2578, + 1,0,0,0,2576,2574,1,0,0,0,2576,2577,1,0,0,0,2577,2580,1,0,0,0,2578,2576, + 1,0,0,0,2579,2514,1,0,0,0,2579,2527,1,0,0,0,2579,2538,1,0,0,0,2579,2553, + 1,0,0,0,2579,2566,1,0,0,0,2580,259,1,0,0,0,2581,2582,3,0,0,0,2582,2583, + 5,75,0,0,2583,2584,6,130,-1,0,2584,261,1,0,0,0,2585,2588,3,44,22,0,2586, + 2588,3,46,23,0,2587,2585,1,0,0,0,2587,2586,1,0,0,0,2588,263,1,0,0,0,2589, + 2590,5,17,0,0,2590,2591,3,246,123,0,2591,2592,5,18,0,0,2592,265,1,0,0, + 0,2593,2594,3,270,135,0,2594,2595,3,268,134,0,2595,267,1,0,0,0,2596,2597, + 3,272,136,0,2597,2598,6,134,-1,0,2598,2600,1,0,0,0,2599,2596,1,0,0,0,2600, + 2601,1,0,0,0,2601,2599,1,0,0,0,2601,2602,1,0,0,0,2602,269,1,0,0,0,2603, + 2604,5,158,0,0,2604,2605,3,264,132,0,2605,2606,6,135,-1,0,2606,2620,1, + 0,0,0,2607,2608,5,158,0,0,2608,2609,3,0,0,0,2609,2610,5,159,0,0,2610,2611, + 3,0,0,0,2611,2612,6,135,-1,0,2612,2620,1,0,0,0,2613,2614,5,158,0,0,2614, + 2615,3,32,16,0,2615,2616,5,159,0,0,2616,2617,3,32,16,0,2617,2618,6,135, + -1,0,2618,2620,1,0,0,0,2619,2603,1,0,0,0,2619,2607,1,0,0,0,2619,2613,1, + 0,0,0,2620,271,1,0,0,0,2621,2622,3,276,138,0,2622,2623,3,282,141,0,2623, + 2624,6,136,-1,0,2624,2638,1,0,0,0,2625,2626,3,274,137,0,2626,2627,3,282, + 141,0,2627,2628,6,136,-1,0,2628,2638,1,0,0,0,2629,2630,3,278,139,0,2630, + 2631,3,282,141,0,2631,2632,6,136,-1,0,2632,2638,1,0,0,0,2633,2634,3,280, + 140,0,2634,2635,3,282,141,0,2635,2636,6,136,-1,0,2636,2638,1,0,0,0,2637, + 2621,1,0,0,0,2637,2625,1,0,0,0,2637,2629,1,0,0,0,2637,2633,1,0,0,0,2638, + 273,1,0,0,0,2639,2640,5,160,0,0,2640,2641,3,264,132,0,2641,2642,6,137, + -1,0,2642,2652,1,0,0,0,2643,2644,5,160,0,0,2644,2645,3,0,0,0,2645,2646, + 6,137,-1,0,2646,2652,1,0,0,0,2647,2648,5,160,0,0,2648,2649,3,32,16,0,2649, + 2650,6,137,-1,0,2650,2652,1,0,0,0,2651,2639,1,0,0,0,2651,2643,1,0,0,0, + 2651,2647,1,0,0,0,2652,275,1,0,0,0,2653,2654,5,161,0,0,2654,2655,3,124, + 62,0,2655,277,1,0,0,0,2656,2657,5,162,0,0,2657,279,1,0,0,0,2658,2659,5, + 163,0,0,2659,281,1,0,0,0,2660,2661,3,264,132,0,2661,2662,6,141,-1,0,2662, + 2676,1,0,0,0,2663,2664,5,164,0,0,2664,2665,3,0,0,0,2665,2666,5,159,0,0, + 2666,2667,3,0,0,0,2667,2668,6,141,-1,0,2668,2676,1,0,0,0,2669,2670,5,164, + 0,0,2670,2671,3,32,16,0,2671,2672,5,159,0,0,2672,2673,3,32,16,0,2673,2674, + 6,141,-1,0,2674,2676,1,0,0,0,2675,2660,1,0,0,0,2675,2663,1,0,0,0,2675, + 2669,1,0,0,0,2676,283,1,0,0,0,2677,2678,3,286,143,0,2678,2679,3,290,145, + 0,2679,285,1,0,0,0,2680,2681,5,165,0,0,2681,2682,3,288,144,0,2682,2683, + 3,0,0,0,2683,2684,5,36,0,0,2684,2688,1,0,0,0,2685,2686,5,165,0,0,2686, + 2688,3,288,144,0,2687,2680,1,0,0,0,2687,2685,1,0,0,0,2688,287,1,0,0,0, + 2689,2693,1,0,0,0,2690,2693,5,166,0,0,2691,2693,5,2,0,0,2692,2689,1,0, + 0,0,2692,2690,1,0,0,0,2692,2691,1,0,0,0,2693,289,1,0,0,0,2694,2695,5,17, + 0,0,2695,2696,3,292,146,0,2696,2697,5,18,0,0,2697,2704,1,0,0,0,2698,2700, + 3,296,148,0,2699,2698,1,0,0,0,2700,2701,1,0,0,0,2701,2699,1,0,0,0,2701, + 2702,1,0,0,0,2702,2704,1,0,0,0,2703,2694,1,0,0,0,2703,2699,1,0,0,0,2704, + 291,1,0,0,0,2705,2706,3,296,148,0,2706,2707,5,28,0,0,2707,2709,1,0,0,0, + 2708,2705,1,0,0,0,2709,2712,1,0,0,0,2710,2708,1,0,0,0,2710,2711,1,0,0, + 0,2711,2713,1,0,0,0,2712,2710,1,0,0,0,2713,2714,3,296,148,0,2714,293,1, + 0,0,0,2715,2721,1,0,0,0,2716,2717,5,42,0,0,2717,2718,3,32,16,0,2718,2719, + 5,43,0,0,2719,2721,1,0,0,0,2720,2715,1,0,0,0,2720,2716,1,0,0,0,2721,295, + 1,0,0,0,2722,2723,5,181,0,0,2723,2724,5,262,0,0,2724,2725,5,30,0,0,2725, + 2726,3,6,3,0,2726,2727,5,31,0,0,2727,2789,1,0,0,0,2728,2729,5,260,0,0, + 2729,2730,5,30,0,0,2730,2731,3,0,0,0,2731,2732,5,31,0,0,2732,2789,1,0, + 0,0,2733,2734,5,260,0,0,2734,2789,3,0,0,0,2735,2736,5,84,0,0,2736,2737, + 5,30,0,0,2737,2738,3,300,150,0,2738,2739,5,31,0,0,2739,2789,1,0,0,0,2740, + 2741,5,188,0,0,2741,2742,5,30,0,0,2742,2743,3,36,18,0,2743,2744,5,31,0, + 0,2744,2745,3,294,147,0,2745,2789,1,0,0,0,2746,2747,5,189,0,0,2747,2748, + 5,30,0,0,2748,2749,3,36,18,0,2749,2750,5,31,0,0,2750,2751,3,294,147,0, + 2751,2789,1,0,0,0,2752,2753,5,187,0,0,2753,2754,5,30,0,0,2754,2755,3,34, + 17,0,2755,2756,5,31,0,0,2756,2757,3,294,147,0,2757,2789,1,0,0,0,2758,2759, + 5,186,0,0,2759,2760,5,30,0,0,2760,2761,3,32,16,0,2761,2762,5,31,0,0,2762, + 2763,3,294,147,0,2763,2789,1,0,0,0,2764,2765,5,185,0,0,2765,2766,5,30, + 0,0,2766,2767,3,32,16,0,2767,2768,5,31,0,0,2768,2769,3,294,147,0,2769, + 2789,1,0,0,0,2770,2771,5,184,0,0,2771,2772,5,30,0,0,2772,2773,3,32,16, + 0,2773,2774,5,31,0,0,2774,2775,3,294,147,0,2775,2789,1,0,0,0,2776,2777, + 5,188,0,0,2777,2789,3,294,147,0,2778,2779,5,189,0,0,2779,2789,3,294,147, + 0,2780,2781,5,187,0,0,2781,2789,3,294,147,0,2782,2783,5,186,0,0,2783,2789, + 3,294,147,0,2784,2785,5,185,0,0,2785,2789,3,294,147,0,2786,2787,5,184, + 0,0,2787,2789,3,294,147,0,2788,2722,1,0,0,0,2788,2728,1,0,0,0,2788,2733, + 1,0,0,0,2788,2735,1,0,0,0,2788,2740,1,0,0,0,2788,2746,1,0,0,0,2788,2752, + 1,0,0,0,2788,2758,1,0,0,0,2788,2764,1,0,0,0,2788,2770,1,0,0,0,2788,2776, + 1,0,0,0,2788,2778,1,0,0,0,2788,2780,1,0,0,0,2788,2782,1,0,0,0,2788,2784, + 1,0,0,0,2788,2786,1,0,0,0,2789,297,1,0,0,0,2790,2791,5,188,0,0,2791,2792, + 5,30,0,0,2792,2793,3,36,18,0,2793,2794,5,31,0,0,2794,2866,1,0,0,0,2795, + 2796,5,189,0,0,2796,2797,5,30,0,0,2797,2798,3,36,18,0,2798,2799,5,31,0, + 0,2799,2866,1,0,0,0,2800,2801,5,188,0,0,2801,2802,5,30,0,0,2802,2803,3, + 32,16,0,2803,2804,5,31,0,0,2804,2866,1,0,0,0,2805,2806,5,189,0,0,2806, + 2807,5,30,0,0,2807,2808,3,34,17,0,2808,2809,5,31,0,0,2809,2866,1,0,0,0, + 2810,2811,5,187,0,0,2811,2812,5,30,0,0,2812,2813,3,34,17,0,2813,2814,5, + 31,0,0,2814,2866,1,0,0,0,2815,2816,5,186,0,0,2816,2817,5,30,0,0,2817,2818, + 3,32,16,0,2818,2819,5,31,0,0,2819,2866,1,0,0,0,2820,2821,5,185,0,0,2821, + 2822,5,30,0,0,2822,2823,3,32,16,0,2823,2824,5,31,0,0,2824,2866,1,0,0,0, + 2825,2826,5,184,0,0,2826,2827,5,30,0,0,2827,2828,3,32,16,0,2828,2829,5, + 31,0,0,2829,2866,1,0,0,0,2830,2831,5,193,0,0,2831,2832,5,30,0,0,2832,2833, + 3,34,17,0,2833,2834,5,31,0,0,2834,2866,1,0,0,0,2835,2836,5,192,0,0,2836, + 2837,5,30,0,0,2837,2838,3,32,16,0,2838,2839,5,31,0,0,2839,2866,1,0,0,0, + 2840,2841,5,191,0,0,2841,2842,5,30,0,0,2842,2843,3,32,16,0,2843,2844,5, + 31,0,0,2844,2866,1,0,0,0,2845,2846,5,190,0,0,2846,2847,5,30,0,0,2847,2848, + 3,32,16,0,2848,2849,5,31,0,0,2849,2866,1,0,0,0,2850,2851,5,181,0,0,2851, + 2852,5,30,0,0,2852,2853,3,32,16,0,2853,2854,5,31,0,0,2854,2866,1,0,0,0, + 2855,2856,5,183,0,0,2856,2857,5,30,0,0,2857,2858,3,162,81,0,2858,2859, + 5,31,0,0,2859,2866,1,0,0,0,2860,2861,5,84,0,0,2861,2862,5,30,0,0,2862, + 2863,3,300,150,0,2863,2864,5,31,0,0,2864,2866,1,0,0,0,2865,2790,1,0,0, + 0,2865,2795,1,0,0,0,2865,2800,1,0,0,0,2865,2805,1,0,0,0,2865,2810,1,0, + 0,0,2865,2815,1,0,0,0,2865,2820,1,0,0,0,2865,2825,1,0,0,0,2865,2830,1, + 0,0,0,2865,2835,1,0,0,0,2865,2840,1,0,0,0,2865,2845,1,0,0,0,2865,2850, + 1,0,0,0,2865,2855,1,0,0,0,2865,2860,1,0,0,0,2866,299,1,0,0,0,2867,2868, + 3,302,151,0,2868,2869,6,150,-1,0,2869,2871,1,0,0,0,2870,2867,1,0,0,0,2871, + 2874,1,0,0,0,2872,2870,1,0,0,0,2872,2873,1,0,0,0,2873,301,1,0,0,0,2874, + 2872,1,0,0,0,2875,2876,7,11,0,0,2876,303,1,0,0,0,2877,2881,3,298,149,0, + 2878,2881,3,6,3,0,2879,2881,5,179,0,0,2880,2877,1,0,0,0,2880,2878,1,0, + 0,0,2880,2879,1,0,0,0,2881,305,1,0,0,0,2882,3031,3,298,149,0,2883,2884, + 5,182,0,0,2884,2885,5,30,0,0,2885,2886,5,179,0,0,2886,3031,5,31,0,0,2887, + 2888,5,182,0,0,2888,2889,5,30,0,0,2889,2890,5,264,0,0,2890,3031,5,31,0, + 0,2891,2892,5,196,0,0,2892,2893,5,30,0,0,2893,2894,5,39,0,0,2894,2895, + 5,264,0,0,2895,3031,5,31,0,0,2896,2897,5,196,0,0,2897,2898,5,30,0,0,2898, + 2899,3,116,58,0,2899,2900,5,31,0,0,2900,3031,1,0,0,0,2901,2902,5,196,0, + 0,2902,2903,5,30,0,0,2903,2904,5,179,0,0,2904,3031,5,31,0,0,2905,2906, + 5,197,0,0,2906,2907,5,30,0,0,2907,2908,3,306,153,0,2908,2909,5,31,0,0, + 2909,3031,1,0,0,0,2910,2911,5,188,0,0,2911,2912,5,42,0,0,2912,2913,3,32, + 16,0,2913,2914,5,43,0,0,2914,2915,5,30,0,0,2915,2916,3,308,154,0,2916, + 2917,5,31,0,0,2917,3031,1,0,0,0,2918,2919,5,189,0,0,2919,2920,5,42,0,0, + 2920,2921,3,32,16,0,2921,2922,5,43,0,0,2922,2923,5,30,0,0,2923,2924,3, + 310,155,0,2924,2925,5,31,0,0,2925,3031,1,0,0,0,2926,2927,5,187,0,0,2927, + 2928,5,42,0,0,2928,2929,3,32,16,0,2929,2930,5,43,0,0,2930,2931,5,30,0, + 0,2931,2932,3,312,156,0,2932,2933,5,31,0,0,2933,3031,1,0,0,0,2934,2935, + 5,186,0,0,2935,2936,5,42,0,0,2936,2937,3,32,16,0,2937,2938,5,43,0,0,2938, + 2939,5,30,0,0,2939,2940,3,314,157,0,2940,2941,5,31,0,0,2941,3031,1,0,0, + 0,2942,2943,5,185,0,0,2943,2944,5,42,0,0,2944,2945,3,32,16,0,2945,2946, + 5,43,0,0,2946,2947,5,30,0,0,2947,2948,3,316,158,0,2948,2949,5,31,0,0,2949, + 3031,1,0,0,0,2950,2951,5,184,0,0,2951,2952,5,42,0,0,2952,2953,3,32,16, + 0,2953,2954,5,43,0,0,2954,2955,5,30,0,0,2955,2956,3,318,159,0,2956,2957, + 5,31,0,0,2957,3031,1,0,0,0,2958,2959,5,193,0,0,2959,2960,5,42,0,0,2960, + 2961,3,32,16,0,2961,2962,5,43,0,0,2962,2963,5,30,0,0,2963,2964,3,312,156, + 0,2964,2965,5,31,0,0,2965,3031,1,0,0,0,2966,2967,5,192,0,0,2967,2968,5, + 42,0,0,2968,2969,3,32,16,0,2969,2970,5,43,0,0,2970,2971,5,30,0,0,2971, + 2972,3,314,157,0,2972,2973,5,31,0,0,2973,3031,1,0,0,0,2974,2975,5,191, + 0,0,2975,2976,5,42,0,0,2976,2977,3,32,16,0,2977,2978,5,43,0,0,2978,2979, + 5,30,0,0,2979,2980,3,316,158,0,2980,2981,5,31,0,0,2981,3031,1,0,0,0,2982, + 2983,5,190,0,0,2983,2984,5,42,0,0,2984,2985,3,32,16,0,2985,2986,5,43,0, + 0,2986,2987,5,30,0,0,2987,2988,3,318,159,0,2988,2989,5,31,0,0,2989,3031, + 1,0,0,0,2990,2991,5,181,0,0,2991,2992,5,42,0,0,2992,2993,3,32,16,0,2993, + 2994,5,43,0,0,2994,2995,5,30,0,0,2995,2996,3,316,158,0,2996,2997,5,31, + 0,0,2997,3031,1,0,0,0,2998,2999,5,183,0,0,2999,3000,5,42,0,0,3000,3001, + 3,32,16,0,3001,3002,5,43,0,0,3002,3003,5,30,0,0,3003,3004,3,320,160,0, + 3004,3005,5,31,0,0,3005,3031,1,0,0,0,3006,3007,5,182,0,0,3007,3008,5,42, + 0,0,3008,3009,3,32,16,0,3009,3010,5,43,0,0,3010,3011,5,30,0,0,3011,3012, + 3,322,161,0,3012,3013,5,31,0,0,3013,3031,1,0,0,0,3014,3015,5,196,0,0,3015, + 3016,5,42,0,0,3016,3017,3,32,16,0,3017,3018,5,43,0,0,3018,3019,5,30,0, + 0,3019,3020,3,324,162,0,3020,3021,5,31,0,0,3021,3031,1,0,0,0,3022,3023, + 5,197,0,0,3023,3024,5,42,0,0,3024,3025,3,32,16,0,3025,3026,5,43,0,0,3026, + 3027,5,30,0,0,3027,3028,3,328,164,0,3028,3029,5,31,0,0,3029,3031,1,0,0, + 0,3030,2882,1,0,0,0,3030,2883,1,0,0,0,3030,2887,1,0,0,0,3030,2891,1,0, + 0,0,3030,2896,1,0,0,0,3030,2901,1,0,0,0,3030,2905,1,0,0,0,3030,2910,1, + 0,0,0,3030,2918,1,0,0,0,3030,2926,1,0,0,0,3030,2934,1,0,0,0,3030,2942, + 1,0,0,0,3030,2950,1,0,0,0,3030,2958,1,0,0,0,3030,2966,1,0,0,0,3030,2974, + 1,0,0,0,3030,2982,1,0,0,0,3030,2990,1,0,0,0,3030,2998,1,0,0,0,3030,3006, + 1,0,0,0,3030,3014,1,0,0,0,3030,3022,1,0,0,0,3031,307,1,0,0,0,3032,3035, + 3,36,18,0,3033,3035,3,32,16,0,3034,3032,1,0,0,0,3034,3033,1,0,0,0,3035, + 3038,1,0,0,0,3036,3034,1,0,0,0,3036,3037,1,0,0,0,3037,309,1,0,0,0,3038, + 3036,1,0,0,0,3039,3042,3,36,18,0,3040,3042,3,34,17,0,3041,3039,1,0,0,0, + 3041,3040,1,0,0,0,3042,3045,1,0,0,0,3043,3041,1,0,0,0,3043,3044,1,0,0, + 0,3044,311,1,0,0,0,3045,3043,1,0,0,0,3046,3048,3,34,17,0,3047,3046,1,0, + 0,0,3048,3051,1,0,0,0,3049,3047,1,0,0,0,3049,3050,1,0,0,0,3050,313,1,0, + 0,0,3051,3049,1,0,0,0,3052,3054,3,32,16,0,3053,3052,1,0,0,0,3054,3057, + 1,0,0,0,3055,3053,1,0,0,0,3055,3056,1,0,0,0,3056,315,1,0,0,0,3057,3055, + 1,0,0,0,3058,3060,3,32,16,0,3059,3058,1,0,0,0,3060,3063,1,0,0,0,3061,3059, + 1,0,0,0,3061,3062,1,0,0,0,3062,317,1,0,0,0,3063,3061,1,0,0,0,3064,3066, + 3,32,16,0,3065,3064,1,0,0,0,3066,3069,1,0,0,0,3067,3065,1,0,0,0,3067,3068, + 1,0,0,0,3068,319,1,0,0,0,3069,3067,1,0,0,0,3070,3072,3,162,81,0,3071,3070, + 1,0,0,0,3072,3075,1,0,0,0,3073,3071,1,0,0,0,3073,3074,1,0,0,0,3074,321, + 1,0,0,0,3075,3073,1,0,0,0,3076,3078,7,12,0,0,3077,3076,1,0,0,0,3078,3081, + 1,0,0,0,3079,3077,1,0,0,0,3079,3080,1,0,0,0,3080,323,1,0,0,0,3081,3079, + 1,0,0,0,3082,3084,3,326,163,0,3083,3082,1,0,0,0,3084,3087,1,0,0,0,3085, + 3083,1,0,0,0,3085,3086,1,0,0,0,3086,325,1,0,0,0,3087,3085,1,0,0,0,3088, + 3093,5,179,0,0,3089,3090,5,39,0,0,3090,3093,5,264,0,0,3091,3093,3,116, + 58,0,3092,3088,1,0,0,0,3092,3089,1,0,0,0,3092,3091,1,0,0,0,3093,327,1, + 0,0,0,3094,3096,3,306,153,0,3095,3094,1,0,0,0,3096,3099,1,0,0,0,3097,3095, + 1,0,0,0,3097,3098,1,0,0,0,3098,329,1,0,0,0,3099,3097,1,0,0,0,3100,3104, + 3,44,22,0,3101,3104,3,46,23,0,3102,3104,3,2,1,0,3103,3100,1,0,0,0,3103, + 3101,1,0,0,0,3103,3102,1,0,0,0,3104,331,1,0,0,0,3105,3106,7,13,0,0,3106, + 3107,5,36,0,0,3107,3108,5,30,0,0,3108,3109,3,300,150,0,3109,3110,5,31, + 0,0,3110,3131,1,0,0,0,3111,3112,5,169,0,0,3112,3113,3,38,19,0,3113,3114, + 5,75,0,0,3114,3115,3,38,19,0,3115,3116,5,75,0,0,3116,3117,3,38,19,0,3117, + 3118,5,75,0,0,3118,3119,3,38,19,0,3119,3131,1,0,0,0,3120,3121,5,170,0, + 0,3121,3131,3,6,3,0,3122,3123,5,170,0,0,3123,3124,5,36,0,0,3124,3125,5, + 30,0,0,3125,3126,3,300,150,0,3126,3127,5,31,0,0,3127,3131,1,0,0,0,3128, + 3131,3,330,165,0,3129,3131,3,40,20,0,3130,3105,1,0,0,0,3130,3111,1,0,0, + 0,3130,3120,1,0,0,0,3130,3122,1,0,0,0,3130,3128,1,0,0,0,3130,3129,1,0, + 0,0,3131,333,1,0,0,0,3132,3133,5,25,0,0,3133,3134,5,40,0,0,3134,3135,3, + 98,49,0,3135,3136,3,2,1,0,3136,3145,1,0,0,0,3137,3138,5,25,0,0,3138,3139, + 5,40,0,0,3139,3140,3,98,49,0,3140,3141,3,2,1,0,3141,3142,5,34,0,0,3142, + 3143,3,2,1,0,3143,3145,1,0,0,0,3144,3132,1,0,0,0,3144,3137,1,0,0,0,3145, + 335,1,0,0,0,3146,3148,3,338,169,0,3147,3146,1,0,0,0,3148,3151,1,0,0,0, + 3149,3147,1,0,0,0,3149,3150,1,0,0,0,3150,337,1,0,0,0,3151,3149,1,0,0,0, + 3152,3153,5,180,0,0,3153,3154,5,36,0,0,3154,3155,5,30,0,0,3155,3156,3, + 300,150,0,3156,3157,5,31,0,0,3157,3167,1,0,0,0,3158,3167,3,332,166,0,3159, + 3160,5,171,0,0,3160,3161,5,36,0,0,3161,3162,5,30,0,0,3162,3163,3,300,150, + 0,3163,3164,5,31,0,0,3164,3167,1,0,0,0,3165,3167,5,55,0,0,3166,3152,1, + 0,0,0,3166,3158,1,0,0,0,3166,3159,1,0,0,0,3166,3165,1,0,0,0,3167,339,1, + 0,0,0,3168,3169,5,50,0,0,3169,3173,5,40,0,0,3170,3172,3,344,172,0,3171, + 3170,1,0,0,0,3172,3175,1,0,0,0,3173,3171,1,0,0,0,3173,3174,1,0,0,0,3174, + 3176,1,0,0,0,3175,3173,1,0,0,0,3176,3177,3,2,1,0,3177,341,1,0,0,0,3178, + 3182,5,301,0,0,3179,3181,3,344,172,0,3180,3179,1,0,0,0,3181,3184,1,0,0, + 0,3182,3180,1,0,0,0,3182,3183,1,0,0,0,3183,3185,1,0,0,0,3184,3182,1,0, + 0,0,3185,3186,3,2,1,0,3186,343,1,0,0,0,3187,3203,5,52,0,0,3188,3203,5, + 51,0,0,3189,3203,5,172,0,0,3190,3191,5,62,0,0,3191,3203,5,51,0,0,3192, + 3193,5,62,0,0,3193,3203,5,52,0,0,3194,3195,5,62,0,0,3195,3203,5,63,0,0, + 3196,3197,5,62,0,0,3197,3203,5,64,0,0,3198,3199,5,62,0,0,3199,3203,5,65, + 0,0,3200,3201,5,62,0,0,3201,3203,5,66,0,0,3202,3187,1,0,0,0,3202,3188, + 1,0,0,0,3202,3189,1,0,0,0,3202,3190,1,0,0,0,3202,3192,1,0,0,0,3202,3194, + 1,0,0,0,3202,3196,1,0,0,0,3202,3198,1,0,0,0,3202,3200,1,0,0,0,3203,345, + 1,0,0,0,3204,3206,3,348,174,0,3205,3204,1,0,0,0,3206,3209,1,0,0,0,3207, + 3205,1,0,0,0,3207,3208,1,0,0,0,3208,347,1,0,0,0,3209,3207,1,0,0,0,3210, + 3211,5,21,0,0,3211,3224,3,2,1,0,3212,3213,5,50,0,0,3213,3214,5,40,0,0, + 3214,3224,3,118,59,0,3215,3216,5,25,0,0,3216,3217,5,40,0,0,3217,3224,3, + 2,1,0,3218,3224,3,174,87,0,3219,3220,5,50,0,0,3220,3224,3,32,16,0,3221, + 3224,3,330,165,0,3222,3224,3,40,20,0,3223,3210,1,0,0,0,3223,3212,1,0,0, + 0,3223,3215,1,0,0,0,3223,3218,1,0,0,0,3223,3219,1,0,0,0,3223,3221,1,0, + 0,0,3223,3222,1,0,0,0,3224,349,1,0,0,0,3225,3229,5,274,0,0,3226,3228,3, + 352,176,0,3227,3226,1,0,0,0,3228,3231,1,0,0,0,3229,3227,1,0,0,0,3229,3230, + 1,0,0,0,3230,3232,1,0,0,0,3231,3229,1,0,0,0,3232,3245,3,2,1,0,3233,3237, + 5,274,0,0,3234,3236,3,352,176,0,3235,3234,1,0,0,0,3236,3239,1,0,0,0,3237, + 3235,1,0,0,0,3237,3238,1,0,0,0,3238,3240,1,0,0,0,3239,3237,1,0,0,0,3240, + 3241,3,2,1,0,3241,3242,5,34,0,0,3242,3243,3,2,1,0,3243,3245,1,0,0,0,3244, + 3225,1,0,0,0,3244,3233,1,0,0,0,3245,351,1,0,0,0,3246,3247,7,14,0,0,3247, + 353,1,0,0,0,3248,3250,3,356,178,0,3249,3248,1,0,0,0,3250,3253,1,0,0,0, + 3251,3249,1,0,0,0,3251,3252,1,0,0,0,3252,355,1,0,0,0,3253,3251,1,0,0,0, + 3254,3255,5,21,0,0,3255,3256,3,2,1,0,3256,3257,5,44,0,0,3257,3258,3,32, + 16,0,3258,3265,1,0,0,0,3259,3260,5,25,0,0,3260,3261,5,40,0,0,3261,3265, + 3,2,1,0,3262,3265,3,330,165,0,3263,3265,3,40,20,0,3264,3254,1,0,0,0,3264, + 3259,1,0,0,0,3264,3262,1,0,0,0,3264,3263,1,0,0,0,3265,357,1,0,0,0,179, + 368,376,385,394,447,488,497,527,531,549,576,599,635,645,652,654,664,666, + 673,684,692,713,715,731,776,781,786,791,799,909,915,931,937,943,950,978, + 1056,1058,1072,1078,1087,1089,1098,1112,1126,1134,1142,1146,1185,1193, + 1202,1210,1229,1239,1242,1266,1413,1423,1432,1435,1517,1526,1558,1618, + 1658,1674,1684,1711,1735,1743,1747,1762,1769,1814,1824,1842,1860,1879, + 1900,1919,1934,1941,1951,1964,1969,1974,1983,1993,2079,2088,2101,2112, + 2120,2130,2132,2159,2166,2171,2178,2184,2194,2198,2205,2220,2226,2240, + 2253,2262,2273,2277,2284,2304,2309,2311,2324,2350,2357,2359,2364,2370, + 2399,2408,2431,2436,2476,2480,2490,2512,2524,2535,2550,2563,2576,2579, + 2587,2601,2619,2637,2651,2675,2687,2692,2701,2703,2710,2720,2788,2865, + 2872,2880,3030,3034,3036,3041,3043,3049,3055,3061,3067,3073,3079,3085, + 3092,3097,3103,3130,3144,3149,3166,3173,3182,3202,3207,3223,3229,3237, + 3244,3251,3264 }; public static readonly ATN _ATN = diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILVisitor.cs b/src/tools/ilasm/src/ILAssembler/gen/CILVisitor.cs index 7a7898d3170742..e937296823f511 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILVisitor.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILVisitor.cs @@ -862,11 +862,35 @@ public interface ICILVisitor : IParseTreeVisitor { /// The visitor result. Result VisitMethodDecl([NotNull] CILParser.MethodDeclContext context); /// - /// Visit a parse tree produced by . + /// Visit a parse tree produced by . /// /// The parse tree. /// The visitor result. - Result VisitMethodDeclIsland([NotNull] CILParser.MethodDeclIslandContext context); + Result VisitLocalsDecl([NotNull] CILParser.LocalsDeclContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitExportDecl([NotNull] CILParser.ExportDeclContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitVtentryDecl([NotNull] CILParser.VtentryDeclContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitOverrideDecl([NotNull] CILParser.OverrideDeclContext context); + /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitParameterDecl([NotNull] CILParser.ParameterDeclContext context); /// /// Visit a parse tree produced by . /// diff --git a/src/tools/ilasm/tests/ILAssembler.Tests/CustomAttributeTests.cs b/src/tools/ilasm/tests/ILAssembler.Tests/CustomAttributeTests.cs index 3510309463bde5..b2824811baac86 100644 --- a/src/tools/ilasm/tests/ILAssembler.Tests/CustomAttributeTests.cs +++ b/src/tools/ilasm/tests/ILAssembler.Tests/CustomAttributeTests.cs @@ -1096,6 +1096,66 @@ .class public auto ansi Second extends [mscorlib]System.Object Assert.Equal(TypeAttributes.Serializable, first.Attributes & TypeAttributes.Serializable); } + [Fact] + public void MethodBodyCustomAttributes_PreserveOwnerAndOrder() + { + string source = """ + .assembly extern mscorlib { } + .assembly test { } + .class public auto ansi Test extends [mscorlib]System.Object + { + .method public static void M(int32 value) cil managed + { + .custom instance void [mscorlib]System.ObsoleteAttribute::.ctor() = (01 00 00 00) + .custom instance void [mscorlib]System.Diagnostics.DebuggerHiddenAttribute::.ctor() = (01 00 00 00) + .param [1] + .custom instance void [mscorlib]System.Diagnostics.DebuggerHiddenAttribute::.ctor() = (01 00 00 00) + .custom instance void [mscorlib]System.ObsoleteAttribute::.ctor() = (01 00 00 00) + .param type T + .custom instance void [mscorlib]System.ObsoleteAttribute::.ctor() = (01 00 00 00) + .custom instance void [mscorlib]System.Diagnostics.DebuggerHiddenAttribute::.ctor() = (01 00 00 00) + .param constraint T, [mscorlib]System.IDisposable + .custom instance void [mscorlib]System.Diagnostics.DebuggerHiddenAttribute::.ctor() = (01 00 00 00) + .custom instance void [mscorlib]System.ObsoleteAttribute::.ctor() = (01 00 00 00) + ret + } + } + """; + + using var pe = DocumentCompilerTestHelpers.CompileAndGetReader(source, new Options()); + var reader = pe.GetMetadataReader(); + MethodDefinitionHandle methodHandle = Assert.Single(reader.MethodDefinitions); + var method = reader.GetMethodDefinition(methodHandle); + ParameterHandle parameterHandle = method.GetParameters() + .Single(handle => reader.GetParameter(handle).SequenceNumber == 1); + GenericParameterHandle genericParameterHandle = Assert.Single(method.GetGenericParameters()); + GenericParameterConstraintHandle constraintHandle = + Assert.Single(reader.GetGenericParameter(genericParameterHandle).GetConstraints()); + + Assert.Equal( + ["ObsoleteAttribute", "DebuggerHiddenAttribute"], + GetAttributeTypeNames(reader, reader.GetCustomAttributes(methodHandle))); + Assert.Equal( + ["DebuggerHiddenAttribute", "ObsoleteAttribute"], + GetAttributeTypeNames(reader, reader.GetCustomAttributes(parameterHandle))); + Assert.Equal( + ["ObsoleteAttribute", "DebuggerHiddenAttribute"], + GetAttributeTypeNames(reader, reader.GetCustomAttributes(genericParameterHandle))); + Assert.Equal( + ["DebuggerHiddenAttribute", "ObsoleteAttribute"], + GetAttributeTypeNames(reader, reader.GetCustomAttributes(constraintHandle))); + + static string[] GetAttributeTypeNames( + MetadataReader reader, + CustomAttributeHandleCollection attributes) + => attributes + .Select(reader.GetCustomAttribute) + .Select(attribute => reader.GetMemberReference((MemberReferenceHandle)attribute.Constructor)) + .Select(constructor => reader.GetTypeReference((TypeReferenceHandle)constructor.Parent)) + .Select(type => reader.GetString(type.Name)) + .ToArray(); + } + [Fact] public void PseudoCustomAttribute_ZeroArgDescriptor_MalformedBlobSkipped() { diff --git a/src/tools/ilasm/tests/ILAssembler.Tests/ExceptionHandlingTests.cs b/src/tools/ilasm/tests/ILAssembler.Tests/ExceptionHandlingTests.cs index 8cf84b76494a55..86b80c62283695 100644 --- a/src/tools/ilasm/tests/ILAssembler.Tests/ExceptionHandlingTests.cs +++ b/src/tools/ilasm/tests/ILAssembler.Tests/ExceptionHandlingTests.cs @@ -501,5 +501,99 @@ leave.s DONE .ToArray()); } + [Fact] + public void LabelBasedFilterRegion_EmitsExactExceptionRegionBounds() + { + string source = """ + .assembly extern mscorlib { } + .assembly test { } + .class public auto ansi beforefieldinit Test extends [mscorlib]System.Object + { + .method public static void M() cil managed + { + .maxstack 1 + .try TRY_START to TRY_END filter FILTER_START handler HANDLER_START to HANDLER_END + TRY_START: + nop + leave.s DONE + TRY_END: + FILTER_START: + pop + ldc.i4.1 + endfilter + HANDLER_START: + pop + leave.s DONE + HANDLER_END: + DONE: + ret + } + } + """; + + using var pe = DocumentCompilerTestHelpers.CompileAndGetReader(source, new Options()); + var reader = pe.GetMetadataReader(); + var method = reader.GetMethodDefinition(Assert.Single(reader.MethodDefinitions)); + var region = Assert.Single(pe.GetMethodBody(method.RelativeVirtualAddress).ExceptionRegions); + + Assert.Equal(ExceptionRegionKind.Filter, region.Kind); + Assert.Equal(0, region.TryOffset); + Assert.Equal(3, region.TryLength); + Assert.Equal(3, region.FilterOffset); + Assert.Equal(7, region.HandlerOffset); + Assert.Equal(3, region.HandlerLength); + } + + [Fact] + public void NestedTryBlocks_EmitInnerRegionBeforeOuterRegion() + { + string source = """ + .assembly extern mscorlib { } + .assembly test { } + .class public auto ansi beforefieldinit Test extends [mscorlib]System.Object + { + .method public static void M() cil managed + { + .maxstack 1 + .try + { + .try + { + nop + leave.s INNER_DONE + } + catch [mscorlib]System.Exception + { + pop + leave.s INNER_DONE + } + INNER_DONE: + leave.s DONE + } + finally + { + endfinally + } + DONE: + ret + } + } + """; + + using var pe = DocumentCompilerTestHelpers.CompileAndGetReader(source, new Options()); + var reader = pe.GetMetadataReader(); + var method = reader.GetMethodDefinition(Assert.Single(reader.MethodDefinitions)); + ImmutableArray regions = + pe.GetMethodBody(method.RelativeVirtualAddress).ExceptionRegions; + + Assert.Equal(2, regions.Length); + Assert.Equal(ExceptionRegionKind.Catch, regions[0].Kind); + Assert.Equal(ExceptionRegionKind.Finally, regions[1].Kind); + Assert.True(regions[0].TryOffset >= regions[1].TryOffset); + Assert.True( + regions[0].HandlerOffset + regions[0].HandlerLength <= + regions[1].TryOffset + regions[1].TryLength); + } + } } From 649eea9a409b85dfc16383f43493e8e382309252 Mon Sep 17 00:00:00 2001 From: Jeremy Koritzinsky Date: Thu, 13 Aug 2026 15:02:44 -0700 Subject: [PATCH 08/16] Compile IL class members during parsing Replace class-member and method-header subtrees with synthesized method, field, property, event, generic, and P/Invoke values. Resolve class-level method overrides at type close so forward method definitions bind like native ilasm. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: c986c103-8383-4db4-9b11-9be49dc68a05 --- src/tools/ilasm/README.md | 24 +- .../Actions/GrammarActions.Data.cs | 6 - .../Actions/GrammarActions.Declarations.cs | 8 +- .../Actions/GrammarActions.Marshalling.cs | 48 - .../Actions/GrammarActions.Members.Class.cs | 518 ++ .../Actions/GrammarActions.Members.Fields.cs | 297 ++ ...GrammarActions.Members.PropertiesEvents.cs | 428 ++ .../Actions/GrammarActions.Members.Values.cs | 68 + .../Actions/GrammarActions.Members.cs | 587 +-- ...rActions.MethodBodies.ExceptionHandling.cs | 8 - .../Actions/GrammarActions.MethodBodies.cs | 188 - .../GrammarActions.MethodHeaders.Actions.cs | 566 ++ .../GrammarActions.MethodHeaders.Generics.cs | 153 + .../GrammarActions.MethodHeaders.Values.cs | 80 + .../Actions/GrammarActions.MethodHeaders.cs | 219 + .../Actions/GrammarActions.Signatures.cs | 79 +- .../Actions/GrammarActions.Types.cs | 140 +- .../src/ILAssembler/Actions/GrammarActions.cs | 26 +- .../ilasm/src/ILAssembler/EntityRegistry.cs | 6 +- src/tools/ilasm/src/ILAssembler/gen/CIL.g4 | 443 +- .../ilasm/src/ILAssembler/gen/CIL.interp | 2 +- .../ilasm/src/ILAssembler/gen/CILParser.cs | 4624 +++++++++-------- .../tests/ILAssembler.Tests/EventTests.cs | 21 + .../tests/ILAssembler.Tests/MethodTests.cs | 92 + 24 files changed, 5321 insertions(+), 3310 deletions(-) create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Class.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Fields.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.PropertiesEvents.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Values.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.Actions.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.Generics.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.Values.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.cs diff --git a/src/tools/ilasm/README.md b/src/tools/ilasm/README.md index 463e5ac0026493..f6bf08130bd2dc 100644 --- a/src/tools/ilasm/README.md +++ b/src/tools/ilasm/README.md @@ -25,8 +25,16 @@ accumulator instead of building a subtree at all. | `GrammarActions.Manifest.cs` | Assembly, module, resource, vtable and typedef directives. | | `GrammarActions.Marshalling.Actions.cs` | Synthesized native type and marshalling descriptor actions. | | `GrammarActions.Marshalling.cs` | Marshalling visitor wrappers and P/Invoke conversion. | -| `GrammarActions.Members.cs` | Class member dispatch and conversion. | -| `GrammarActions.MethodBodies.cs` | Method headers and parser-driven visitor guards. | +| `GrammarActions.Members.cs` | Parser-driven class member visitor guards. | +| `GrammarActions.Members.Class.cs` | Class directives, generic parameter annotations and method overrides. | +| `GrammarActions.Members.Fields.cs` | Field declarations, attributes, layout, constants, marshalling and RVA data. | +| `GrammarActions.Members.PropertiesEvents.cs` | Property and event headers, bodies and accessors. | +| `GrammarActions.Members.Values.cs` | Internal synthesized member value model. | +| `GrammarActions.MethodHeaders.cs` | Method definition and signature materialization. | +| `GrammarActions.MethodHeaders.Actions.cs` | Method header, attribute, P/Invoke and generic parser actions. | +| `GrammarActions.MethodHeaders.Generics.cs` | Generic parameter and constraint synthesis and materialization. | +| `GrammarActions.MethodHeaders.Values.cs` | Internal synthesized method-header value model. | +| `GrammarActions.MethodBodies.cs` | Parser-driven method-body visitor guards. | | `GrammarActions.MethodBodies.Directives.cs` | Direct method-body directives and parameter ownership. | | `GrammarActions.MethodBodies.ExceptionHandling.cs` | Lexical scopes and synthesized exception regions. | | `GrammarActions.MethodBodies.Values.cs` | Internal method-body directive and exception-region values. | @@ -53,12 +61,12 @@ ILAssembler entities and signature implementation values remain internal, so gen slots use `object` where an internal value or array crosses that boundary and `GrammarActions` provides the strongly typed accessors. -All type, signature, reference, marshalling, method-body directive and exception-handling rules -synthesize values without retaining item or exception-block subtrees. `scopeBlock` records offsets -under its context key without inspecting children. The remaining `BeginSubtree` islands are -declaration/member structure (`decl`, `nameSpaceHead`, `classHead`, `classDecl`, and `methodHead`) -and bounded shared directives such as data, security, source, language, initialization and custom -attribute declarations. +All type, signature, reference, marshalling, class-member, method-header, method-body directive and +exception-handling rules synthesize values without retaining structural subtrees. `scopeBlock` +records offsets under its context key without inspecting children. The remaining `BeginSubtree` +islands are `decl`, `nameSpaceHead`, `classHead`, `dataDecl`, `secDecl`, `extSourceSpec`, +`languageDecl`, `initOpt`, `customAttrDecl`, `customDescr`, `customDescrWithOwner` and +`customDescrInMethodBody`. Semantic state that a rule pushes must be released from that rule's `finally` clause and be keyed on the owning context, because ANTLR skips `@after` actions and the remainder of an alternative once a diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Data.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Data.cs index 16091973c4bc2b..eb313fb17fc681 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Data.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Data.cs @@ -25,12 +25,6 @@ namespace ILAssembler #pragma warning disable CA1822 // Mark members as static internal sealed partial class GrammarActions : ICILVisitor { - GrammarResult ICILVisitor.VisitAtOpt(CILParser.AtOptContext context) => VisitAtOpt(context); - public GrammarResult.Literal VisitAtOpt(CILParser.AtOptContext context) - => context.id() is { } id ? new(VisitId(id).Value) - : context.int32() is { } i ? new(VisitInt32(i).Value.ToString()) - : new(null); - public GrammarResult VisitDataDecl(CILParser.DataDeclContext context) { _ = VisitDdHead(context.ddHead()); diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.cs index fbfc3de421517d..cfdf24c12778bb 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.cs @@ -28,7 +28,8 @@ internal void OnDeclaration(CILParser.DeclContext context) { if (context.classHead() is not null || context.nameSpaceHead() is not null || - context.methodHead() is not null) + context.methodHead() is not null || + context.fieldDecl() is not null) { return; } @@ -51,10 +52,9 @@ public GrammarResult VisitDecl(CILParser.DeclContext context) throw new UnreachableException(StructuralNodeIsDrivenByParserActions); } - if (context.fieldDecl() is { } fieldDecl) + if (context.fieldDecl() is not null) { - _ = VisitFieldDecl(fieldDecl); - return GrammarResult.SentinelValue.Result; + throw new UnreachableException(StructuralNodeIsDrivenByParserActions); } if (context.dataDecl() is { } dataDecl) { diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Marshalling.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Marshalling.cs index 83b1fb2ed6058d..19ea28b975861d 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Marshalling.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Marshalling.cs @@ -41,54 +41,6 @@ GrammarResult ICILVisitor.VisitNativeTypeElement(CILParser.Native public GrammarResult.FormattedBlob VisitNativeTypeElement(CILParser.NativeTypeElementContext context) => new(MaterializeNativeTypeElement(GetNativeTypeElementValue(context.Value))); - GrammarResult ICILVisitor.VisitPinvAttr(CILParser.PinvAttrContext context) - => VisitPinvAttr(context); - - public GrammarResult.Flag VisitPinvAttr(CILParser.PinvAttrContext context) - { - if (context.int32() is CILParser.Int32Context int32) - { - return new((MethodImportAttributes)VisitInt32(int32).Value, ShouldAppend: false); - } - - return context.GetText() switch - { - "nomangle" => new(MethodImportAttributes.ExactSpelling), - "ansi" => new(MethodImportAttributes.CharSetAnsi), - "unicode" => new(MethodImportAttributes.CharSetUnicode), - "autochar" => new(MethodImportAttributes.CharSetAuto), - "lasterr" => new(MethodImportAttributes.SetLastError), - "winapi" => new(MethodImportAttributes.CallingConventionWinApi), - "cdecl" => new(MethodImportAttributes.CallingConventionCDecl), - "stdcall" => new(MethodImportAttributes.CallingConventionStdCall), - "thiscall" => new(MethodImportAttributes.CallingConventionThisCall), - "fastcall" => new(MethodImportAttributes.CallingConventionFastCall), - "bestfit:on" => new(MethodImportAttributes.BestFitMappingEnable), - "bestfit:off" => new(MethodImportAttributes.BestFitMappingDisable), - "charmaperror:on" => new(MethodImportAttributes.ThrowOnUnmappableCharEnable), - "charmaperror:off" => new(MethodImportAttributes.ThrowOnUnmappableCharDisable), - _ => throw new UnreachableException() - }; - } - - GrammarResult ICILVisitor.VisitPinvImpl(CILParser.PinvImplContext context) - => VisitPinvImpl(context); - - public GrammarResult.Literal<(string? ModuleName, string? EntryPointName, MethodImportAttributes Attributes)> VisitPinvImpl( - CILParser.PinvImplContext context) - { - MethodImportAttributes attributes = MethodImportAttributes.None; - foreach (CILParser.PinvAttrContext attribute in context.pinvAttr()) - { - attributes |= VisitPinvAttr(attribute); - } - - CILParser.CompQstringContext[] names = context.compQstring(); - string? moduleName = names.Length > 0 ? VisitCompQstring(names[0]).Value : null; - string? entryPointName = names.Length > 1 ? VisitCompQstring(names[1]).Value : null; - return new((moduleName, entryPointName, attributes)); - } - GrammarResult ICILVisitor.VisitVariantType(CILParser.VariantTypeContext context) => VisitVariantType(context); diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Class.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Class.cs new file mode 100644 index 00000000000000..f02f11de84b623 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Class.cs @@ -0,0 +1,518 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Reflection; +using System.Reflection.Metadata; +using Antlr4.Runtime; + +namespace ILAssembler; + +internal sealed partial class GrammarActions +{ + private readonly Stack _classGenericDirectiveFrames = new(); + private readonly Dictionary< + EntityRegistry.TypeDefinitionEntity, + List> _pendingClassMethodOverrides = new(); + + private sealed record ClassGenericDirectiveFrame( + CILParser.ClassDeclContext Owner, + EntityRegistry.EntityBase? AttributeOwner); + + private sealed record PendingClassMethodOverride( + EntityRegistry.MemberReferenceEntity Declaration, + EntityRegistry.MemberReferenceEntity? ReferencedBody, + string BodyName, + BlobBuilder BodySignature, + IToken Location); + + private void PrepareClassMember() + { + _pendingClassCustomAttributeOwner = null; + } + + internal void ProcessClassDataDeclaration(CILParser.DataDeclContext context) + { + PrepareClassMember(); + if (!context.HasSyntaxError) + { + _ = VisitDataDecl(context); + } + } + + internal void ProcessClassSecurityDeclaration(CILParser.SecDeclContext context) + { + PrepareClassMember(); + if (context.HasSyntaxError) + { + return; + } + + EntityRegistry.DeclarativeSecurityAttributeEntity? security = VisitSecDecl(context).Value; + security?.Parent = _currentTypeDefinition.PeekOrDefault(); + } + + internal void ProcessClassSourceDirective(CILParser.ExtSourceSpecContext context) + { + PrepareClassMember(); + if (!context.HasSyntaxError) + { + _ = VisitExtSourceSpec(context); + } + } + + internal void ProcessClassLanguageDirective(CILParser.LanguageDeclContext context) + { + PrepareClassMember(); + if (!context.HasSyntaxError) + { + _ = VisitLanguageDecl(context); + } + } + + internal void ProcessClassCustomAttribute(CILParser.CustomAttrDeclContext context) + { + if (context.HasSyntaxError) + { + return; + } + + if (VisitCustomAttrDecl(context).Value is { } customAttribute) + { + customAttribute.Owner = + _pendingClassCustomAttributeOwner ?? + _currentTypeDefinition.PeekOrDefault(); + } + } + + internal void SetClassSize(IToken token) + { + PrepareClassMember(); + if (_currentTypeDefinition.PeekOrDefault() is { } currentType) + { + currentType.ClassSize = ParseInt32(token); + } + } + + internal void SetClassPackingSize(IToken token) + { + PrepareClassMember(); + if (_currentTypeDefinition.PeekOrDefault() is { } currentType) + { + currentType.PackingSize = ParseInt32(token); + } + } + + internal void ProcessClassExport( + CILParser.ExportHeadContext export, + CILParser.ExptypeDeclsContext declarations) + { + PrepareClassMember(); + _ = export; + _ = declarations; + } + + internal void ProcessClassCompilerControl() + { + PrepareClassMember(); + } + + internal void AddClassMethodOverride( + CILParser.ClassDeclContext context, + object? declarationOwner, + string declarationName, + byte bodyCallingConvention, + object? bodyReturnType, + object? bodyOwner, + string bodyName, + object? bodyArguments) + { + PrepareClassMember(); + AddClassMethodOverrideCore( + context, + bodyCallingConvention, + bodyReturnType, + declarationOwner, + declarationName, + 0, + bodyArguments, + bodyCallingConvention, + bodyReturnType, + bodyOwner, + bodyName, + 0, + bodyArguments); + } + + internal void AddClassMethodOverride( + CILParser.ClassDeclContext context, + byte declarationCallingConvention, + object? declarationReturnType, + object? declarationOwner, + string declarationName, + int declarationArity, + object? declarationArguments, + byte bodyCallingConvention, + object? bodyReturnType, + object? bodyOwner, + string bodyName, + int bodyArity, + object? bodyArguments) + { + PrepareClassMember(); + AddClassMethodOverrideCore( + context, + declarationCallingConvention, + declarationReturnType, + declarationOwner, + declarationName, + declarationArity, + declarationArguments, + bodyCallingConvention, + bodyReturnType, + bodyOwner, + bodyName, + bodyArity, + bodyArguments); + } + + private void AddClassMethodOverrideCore( + CILParser.ClassDeclContext context, + byte declarationCallingConvention, + object? declarationReturnType, + object? declarationOwner, + string declarationName, + int declarationArity, + object? declarationArguments, + byte bodyCallingConvention, + object? bodyReturnType, + object? bodyOwner, + string bodyName, + int bodyArity, + object? bodyArguments) + { + if (_currentTypeDefinition.PeekOrDefault() is not { } currentType) + { + return; + } + + BlobBuilder declarationSignature = BuildClassMethodOverrideSignature( + declarationCallingConvention, + declarationReturnType, + declarationArguments, + declarationArity); + BlobBuilder bodySignature = BuildClassMethodOverrideSignature( + bodyCallingConvention, + bodyReturnType, + bodyArguments, + bodyArity); + + EntityRegistry.MemberReferenceEntity declaration = + _entityRegistry.CreateLazilyRecordedMemberReference( + ResolveTypeSpecification(GetTypeSpecificationValue(declarationOwner)), + declarationName, + declarationSignature); + EntityRegistry.TypeEntity resolvedBodyOwner = + ResolveTypeSpecification(GetTypeSpecificationValue(bodyOwner)); + EntityRegistry.MemberReferenceEntity? referencedBody = + ReferenceEquals(resolvedBodyOwner, currentType) + ? null + : _entityRegistry.CreateLazilyRecordedMemberReference( + resolvedBodyOwner, + bodyName, + bodySignature); + + if (!_pendingClassMethodOverrides.TryGetValue( + currentType, + out List? pendingOverrides)) + { + pendingOverrides = new(); + _pendingClassMethodOverrides.Add(currentType, pendingOverrides); + } + + pendingOverrides.Add( + new( + declaration, + referencedBody, + bodyName, + bodySignature, + context.Start)); + } + + private void CompleteClassMethodOverrides(EntityRegistry.TypeDefinitionEntity type) + { + if (!_pendingClassMethodOverrides.Remove( + type, + out List? pendingOverrides)) + { + return; + } + + foreach (PendingClassMethodOverride pending in pendingOverrides) + { + if (pending.ReferencedBody is { } referencedBody) + { + type.MethodImplementations.Add( + EntityRegistry.CreateUnrecordedMethodImplementation( + type, + referencedBody, + pending.Declaration)); + continue; + } + + EntityRegistry.MethodDefinitionEntity? bodyMethod = null; + bool isAmbiguous = false; + foreach (EntityRegistry.MethodDefinitionEntity candidate in type.Methods) + { + if (candidate.Name != pending.BodyName || + candidate.MethodSignature is null || + !candidate.MethodSignature.ContentEquals(pending.BodySignature)) + { + continue; + } + + if (bodyMethod is not null) + { + isAmbiguous = true; + break; + } + + bodyMethod = candidate; + } + + if (bodyMethod is null || isAmbiguous) + { + ReportError( + DiagnosticIds.InvalidMetadataToken, + $"Override body method '{pending.BodyName}' could not be resolved uniquely", + pending.Location); + continue; + } + + type.MethodImplementations.Add( + EntityRegistry.CreateUnrecordedMethodImplementation( + bodyMethod, + pending.Declaration)); + } + } + + private BlobBuilder BuildClassMethodOverrideSignature( + byte callingConvention, + object? returnType, + object? arguments, + int genericArity) + { + BlobBuilder signature = new(); + byte header = callingConvention; + if (genericArity > 0) + { + header |= (byte)SignatureAttributes.Generic; + } + signature.WriteByte(header); + if (genericArity > 0) + { + signature.WriteCompressedInteger(genericArity); + } + + ImmutableArray argumentValues = + GetSignatureArgumentsValue(arguments); + ImmutableArray materializedArguments = + MaterializeSignatureArguments(argumentValues); + int parameterCount = 0; + foreach (SignatureArg argument in materializedArguments) + { + if (!argument.IsSentinel) + { + parameterCount++; + } + } + signature.WriteCompressedInteger(parameterCount); + MaterializeType(GetTypeValue(returnType)).WriteContentTo(signature); + foreach (SignatureArg argument in materializedArguments) + { + argument.SignatureBlob.WriteContentTo(signature); + } + + return signature; + } + + internal void BeginClassGenericParameterDirective( + CILParser.ClassDeclContext context, + IToken index) + { + PrepareClassMember(); + BeginClassGenericDirective(context, FindClassGenericParameter(context, ParseInt32(index))); + } + + internal void BeginClassGenericParameterDirective( + CILParser.ClassDeclContext context, + string name) + { + PrepareClassMember(); + BeginClassGenericDirective(context, FindClassGenericParameter(name)); + } + + internal void BeginClassGenericConstraintDirective( + CILParser.ClassDeclContext context, + IToken index, + object? constraintType) + { + PrepareClassMember(); + BeginClassGenericDirective( + context, + FindOrCreateClassGenericConstraint( + FindClassGenericParameter(context, ParseInt32(index)), + constraintType)); + } + + internal void BeginClassGenericConstraintDirective( + CILParser.ClassDeclContext context, + string name, + object? constraintType) + { + PrepareClassMember(); + BeginClassGenericDirective( + context, + FindOrCreateClassGenericConstraint( + FindClassGenericParameter(name), + constraintType)); + } + + private void BeginClassGenericDirective( + CILParser.ClassDeclContext context, + EntityRegistry.EntityBase? owner) + { + _pendingClassCustomAttributeOwner = owner; + _classGenericDirectiveFrames.Push(new(context, owner)); + } + + internal void AddClassGenericDirectiveAttribute( + CILParser.ClassDeclContext context, + CILParser.CustomAttrDeclContext attribute) + { + if (attribute.HasSyntaxError || + _classGenericDirectiveFrames.Count == 0 || + !ReferenceEquals(_classGenericDirectiveFrames.Peek().Owner, context) || + _classGenericDirectiveFrames.Peek().AttributeOwner is not { } owner) + { + return; + } + + if (VisitCustomAttrDecl(attribute).Value is { } customAttribute) + { + customAttribute.Owner = owner; + } + } + + private EntityRegistry.GenericParameterEntity? FindClassGenericParameter( + CILParser.ClassDeclContext context, + int index) + { + EntityRegistry.TypeDefinitionEntity? currentType = _currentTypeDefinition.PeekOrDefault(); + if (currentType is not null && + index >= 0 && + index < currentType.GenericParameters.Count) + { + return currentType.GenericParameters[index]; + } + + ReportError( + DiagnosticIds.GenericParameterIndexOutOfRange, + string.Format(DiagnosticMessageTemplates.GenericParameterIndexOutOfRange, index), + context); + return null; + } + + private EntityRegistry.GenericParameterEntity? FindClassGenericParameter(string name) + { + EntityRegistry.TypeDefinitionEntity? currentType = _currentTypeDefinition.PeekOrDefault(); + if (currentType is null) + { + return null; + } + + foreach (EntityRegistry.GenericParameterEntity parameter in currentType.GenericParameters) + { + if (parameter.Name == name) + { + return parameter; + } + } + + return null; + } + + private EntityRegistry.GenericParameterConstraintEntity? FindOrCreateClassGenericConstraint( + EntityRegistry.GenericParameterEntity? parameter, + object? constraintType) + { + if (parameter is null || + _currentTypeDefinition.PeekOrDefault() is not { } currentType) + { + return null; + } + + EntityRegistry.TypeEntity baseType = + ResolveTypeSpecification(GetTypeSpecificationValue(constraintType)); + foreach (EntityRegistry.GenericParameterConstraintEntity constraint in parameter.Constraints) + { + if (constraint.BaseType == baseType) + { + return constraint; + } + } + + EntityRegistry.GenericParameterConstraintEntity newConstraint = + EntityRegistry.CreateGenericConstraint(baseType); + newConstraint.Owner = parameter; + parameter.Constraints.Add(newConstraint); + currentType.GenericParameterConstraints.Add(newConstraint); + return newConstraint; + } + + internal void AddInterfaceImplementationAttribute( + CILParser.ClassDeclContext context, + object? interfaceType, + CILParser.CustomDescrContext attribute) + { + PrepareClassMember(); + if (attribute.HasSyntaxError || + _currentTypeDefinition.PeekOrDefault() is not { } currentType) + { + return; + } + + EntityRegistry.TypeEntity resolvedInterface = + ResolveTypeSpecification(GetTypeSpecificationValue(interfaceType)); + EntityRegistry.InterfaceImplementationEntity? implementation = null; + foreach (EntityRegistry.InterfaceImplementationEntity candidate in currentType.InterfaceImplementations) + { + if (candidate.InterfaceType == resolvedInterface) + { + implementation = candidate; + break; + } + } + + if (implementation is null) + { + implementation = + EntityRegistry.CreateUnrecordedInterfaceImplementation(currentType, resolvedInterface); + currentType.InterfaceImplementations.Add(implementation); + } + + VisitCustomDescr(attribute).Value.Owner = implementation; + _ = context; + } + + private void EndClassGenericDirective(CILParser.ClassDeclContext context) + { + if (_classGenericDirectiveFrames.Count > 0 && + ReferenceEquals(_classGenericDirectiveFrames.Peek().Owner, context)) + { + _classGenericDirectiveFrames.Pop(); + } + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Fields.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Fields.cs new file mode 100644 index 00000000000000..d7dc5d33c93379 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Fields.cs @@ -0,0 +1,297 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Generic; +using System.Diagnostics; +using System.Globalization; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using Antlr4.Runtime; + +namespace ILAssembler; + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. +internal sealed partial class GrammarActions +{ + private readonly Stack _fieldDeclarationFrames = new(); + + private sealed class FieldDeclarationFrame + { + public FieldDeclarationFrame(CILParser.FieldDeclContext owner, int initialSyntaxErrorCount) + { + Owner = owner; + InitialSyntaxErrorCount = initialSyntaxErrorCount; + } + + public CILParser.FieldDeclContext Owner { get; } + + public int InitialSyntaxErrorCount { get; } + + public FieldAttributes Attributes { get; set; } + + public MarshallingDescriptorValue Marshalling { get; set; } = + GetMarshallingDescriptorValue(null); + } + + internal void BeginFieldDeclaration(CILParser.FieldDeclContext context) + { + ClearPendingCustomAttributeOwners(); + _fieldDeclarationFrames.Push(new(context, _syntaxErrorCount)); + } + + internal void AddFieldAttribute(CILParser.FieldDeclContext context, object? value) + { + if (TryGetFieldDeclarationFrame(context) is { } frame) + { + frame.Attributes = ApplyAttribute( + frame.Attributes, + GetAttributeValue(value)); + } + } + + internal void SetFieldMarshalling(CILParser.FieldDeclContext context, object? value) + { + if (TryGetFieldDeclarationFrame(context) is { } frame) + { + frame.Marshalling = GetMarshallingDescriptorValue(value); + } + } + + internal object CreateFieldDeclaration( + CILParser.FieldDeclContext context, + CILParser.RepeatOptContext offset, + object? fieldType, + string name, + string? dataDeclarationName, + object? initializer) + { + FieldDeclarationFrame? frame = TryGetFieldDeclarationFrame(context); + if (frame is null || + frame.InitialSyntaxErrorCount != _syntaxErrorCount || + context.exception is not null) + { + return FieldDeclarationValue.Error; + } + + FieldAttributes attributes = frame.Attributes; + if (attributes.HasFlag(FieldAttributes.RTSpecialName)) + { + attributes |= FieldAttributes.SpecialName; + } + + return new FieldDeclarationValue( + true, + attributes, + GetTypeValue(fieldType), + name, + frame.Marshalling, + dataDeclarationName, + offset.HasValue ? offset.Value : null, + initializer); + } + + internal void DefineField(CILParser.FieldDeclContext context, object? value) + { + _ = context; + FieldDeclarationValue declaration = GetFieldDeclarationValue(value); + if (!declaration.IsValid) + { + return; + } + + BlobBuilder signature = new(); + _ = new BlobEncoder(signature).Field(); + MaterializeType(declaration.FieldType).WriteContentTo(signature); + + EntityRegistry.FieldDefinitionEntity? field = + EntityRegistry.CreateUnrecordedFieldDefinition( + declaration.Attributes, + _currentTypeDefinition.PeekOrDefault() ?? _entityRegistry.ModuleType, + declaration.Name, + signature); + _lastFieldDefinition = field; + _pendingClassCustomAttributeOwner = field; + + if (field is null) + { + return; + } + + field.MarshallingDescriptor = MaterializeMarshallingDescriptor(declaration.Marshalling); + field.DataDeclarationName = declaration.DataDeclarationName; + field.Offset = declaration.Offset; + if (declaration.ConstantValue is not NoConstantSentinel) + { + field.ConstantValue = declaration.ConstantValue; + field.HasConstant = true; + } + } + internal void EndFieldDeclaration(CILParser.FieldDeclContext context) + { + if (_fieldDeclarationFrames.Count == 0) + { + return; + } + + FieldDeclarationFrame frame = _fieldDeclarationFrames.Peek(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + if (ReferenceEquals(frame.Owner, context)) + { + _fieldDeclarationFrames.Pop(); + } + } + + internal object CreateFieldAttribute(IToken token) + => token.Text switch + { + "static" => new AttributeValue(FieldAttributes.Static, 0, true), + "public" => new AttributeValue( + FieldAttributes.Public, + FieldAttributes.FieldAccessMask, + true), + "private" => new AttributeValue( + FieldAttributes.Private, + FieldAttributes.FieldAccessMask, + true), + "family" => new AttributeValue( + FieldAttributes.Family, + FieldAttributes.FieldAccessMask, + true), + "initonly" => new AttributeValue(FieldAttributes.InitOnly, 0, true), + "rtspecialname" => new AttributeValue(FieldAttributes.RTSpecialName, 0, true), + "specialname" => new AttributeValue(FieldAttributes.SpecialName, 0, true), + "assembly" => new AttributeValue( + FieldAttributes.Assembly, + FieldAttributes.FieldAccessMask, + true), + "famandassem" => new AttributeValue( + FieldAttributes.FamANDAssem, + FieldAttributes.FieldAccessMask, + true), + "famorassem" => new AttributeValue( + FieldAttributes.FamORAssem, + FieldAttributes.FieldAccessMask, + true), + "privatescope" => new AttributeValue( + FieldAttributes.PrivateScope, + FieldAttributes.FieldAccessMask, + true), + "literal" => new AttributeValue(FieldAttributes.Literal, 0, true), +#pragma warning disable SYSLIB0050 + "notserialized" => new AttributeValue(FieldAttributes.NotSerialized, 0, true), +#pragma warning restore SYSLIB0050 + "volatile" => new AttributeValue(0, 0, true), + _ => throw new UnreachableException(), + }; + + internal object CreateRawFieldAttribute(IToken token) + => new AttributeValue((FieldAttributes)ParseInt32(token), 0, false); + + internal string GetFieldDataName(IToken token) + => ParseIdentifier(token); + + internal string GetFieldDataOffset(IToken token) + => ParseInt32(token).ToString(CultureInfo.InvariantCulture); + + internal void BeginFieldInitializer(CILParser.InitOptContext context) + { + BeginSemanticRoot(context); + context.Value = NoConstantSentinel.Instance; + } + + internal void SetFieldInitializer( + CILParser.InitOptContext context, + CILParser.FieldInitContext initializer) + { + context.Value = VisitFieldInit(initializer).Value; + } + + internal bool EndFieldInitializer(CILParser.InitOptContext context) + => EndSemanticRoot(context); + + internal void SetFieldOffset(CILParser.RepeatOptContext context, IToken token) + { + context.Value = ParseInt32(token); + context.HasValue = true; + } + + GrammarResult ICILVisitor.VisitAtOpt(CILParser.AtOptContext context) + => VisitAtOpt(context); + + public static GrammarResult.Literal VisitAtOpt(CILParser.AtOptContext context) + => new(context.Value); + + GrammarResult ICILVisitor.VisitFieldAttr(CILParser.FieldAttrContext context) + => VisitFieldAttr(context); + + public static GrammarResult.Flag VisitFieldAttr( + CILParser.FieldAttrContext context) + { + AttributeValue attribute = + GetAttributeValue(context.Value); + return new(attribute.Value, attribute.ShouldAppend, attribute.GroupMask); + } + + GrammarResult ICILVisitor.VisitFieldDecl(CILParser.FieldDeclContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitFieldInit(CILParser.FieldInitContext context) + => VisitFieldInit(context); + + public GrammarResult.Literal VisitFieldInit(CILParser.FieldInitContext context) + { + if (context.NULLREF() is not null) + { + return new(null); + } + if (context.compQstring() is { } composedString) + { + return new(VisitCompQstring(composedString).Value); + } + if (context.fieldSerInit() is { } serializedInitializer) + { + return new(ExtractConstantFromSerInit(VisitFieldSerInit(serializedInitializer).Value)); + } + + return new(null); + } + + GrammarResult ICILVisitor.VisitFieldOrProp(CILParser.FieldOrPropContext context) + => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + + GrammarResult ICILVisitor.VisitFieldRef(CILParser.FieldRefContext context) + => VisitFieldRef(context); + + public GrammarResult.Literal VisitFieldRef( + CILParser.FieldRefContext context) + => new(MaterializeFieldReference(GetFieldReferenceValue(context.Value))); + + GrammarResult ICILVisitor.VisitInitOpt(CILParser.InitOptContext context) + => VisitInitOpt(context); + + public static GrammarResult.Literal VisitInitOpt(CILParser.InitOptContext context) + => new(context.Value); + + GrammarResult ICILVisitor.VisitMemberRef(CILParser.MemberRefContext context) + => VisitMemberRef(context); + + public GrammarResult.Literal VisitMemberRef( + CILParser.MemberRefContext context) + => new(MaterializeMemberReference(GetMemberReferenceValue(context.Value))); + + GrammarResult ICILVisitor.VisitRepeatOpt(CILParser.RepeatOptContext context) + => VisitRepeatOpt(context); + + public static GrammarResult.Literal VisitRepeatOpt(CILParser.RepeatOptContext context) + => new(context.HasValue ? context.Value : null); + + private FieldDeclarationFrame? TryGetFieldDeclarationFrame(CILParser.FieldDeclContext context) + { + Debug.Assert(_fieldDeclarationFrames.Count > 0); + FieldDeclarationFrame? frame = + _fieldDeclarationFrames.Count == 0 ? null : _fieldDeclarationFrames.Peek(); + Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); + return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.PropertiesEvents.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.PropertiesEvents.cs new file mode 100644 index 00000000000000..6b8f99e4148185 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.PropertiesEvents.cs @@ -0,0 +1,428 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Generic; +using System.Diagnostics; +using System.Reflection; +using System.Reflection.Metadata; +using Antlr4.Runtime; + +namespace ILAssembler; + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. +internal sealed partial class GrammarActions +{ + private readonly Stack _propertyHeaderFrames = new(); + private readonly Stack _eventHeaderFrames = new(); + private readonly Stack _propertyBodyFrames = new(); + private readonly Stack _eventBodyFrames = new(); + + private sealed class PropertyHeaderFrame + { + public PropertyHeaderFrame(CILParser.PropHeadContext owner, int initialSyntaxErrorCount) + { + Owner = owner; + InitialSyntaxErrorCount = initialSyntaxErrorCount; + } + + public CILParser.PropHeadContext Owner { get; } + + public int InitialSyntaxErrorCount { get; } + + public PropertyAttributes Attributes { get; set; } + } + + private sealed class EventHeaderFrame + { + public EventHeaderFrame(CILParser.EventHeadContext owner, int initialSyntaxErrorCount) + { + Owner = owner; + InitialSyntaxErrorCount = initialSyntaxErrorCount; + } + + public CILParser.EventHeadContext Owner { get; } + + public int InitialSyntaxErrorCount { get; } + + public EventAttributes Attributes { get; set; } + } + + private sealed record PropertyBodyFrame( + CILParser.ClassDeclContext Owner, + EntityRegistry.PropertyEntity? Property); + + private sealed record EventBodyFrame( + CILParser.ClassDeclContext Owner, + EntityRegistry.EventEntity? Event); + + internal void BeginPropertyHeader(CILParser.PropHeadContext context) + => _propertyHeaderFrames.Push(new(context, _syntaxErrorCount)); + + internal void AddPropertyAttribute(CILParser.PropHeadContext context, object? value) + { + if (TryGetPropertyHeaderFrame(context) is { } frame) + { + frame.Attributes = ApplyAttribute( + frame.Attributes, + GetAttributeValue(value)); + } + } + internal object CreatePropertyHeader( + CILParser.PropHeadContext context, + byte callingConvention, + object? propertyType, + string name, + object? arguments, + object? initializer) + { + PropertyHeaderFrame? frame = TryGetPropertyHeaderFrame(context); + if (frame is null || + frame.InitialSyntaxErrorCount != _syntaxErrorCount || + context.exception is not null) + { + return PropertyHeaderValue.Error; + } + + return new PropertyHeaderValue( + true, + frame.Attributes, + callingConvention, + GetTypeValue(propertyType), + name, + GetSignatureArgumentsValue(arguments), + initializer); + } + + internal void EndPropertyHeader(CILParser.PropHeadContext context) + { + if (_propertyHeaderFrames.Count == 0) + { + return; + } + + PropertyHeaderFrame frame = _propertyHeaderFrames.Peek(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + if (ReferenceEquals(frame.Owner, context)) + { + _propertyHeaderFrames.Pop(); + } + } + + internal object CreatePropertyAttribute(IToken token) + => token.Text switch + { + "specialname" => new AttributeValue( + PropertyAttributes.SpecialName, + 0, + true), + "rtspecialname" => new AttributeValue(0, 0, true), + _ => throw new UnreachableException(), + }; + + internal void BeginProperty(CILParser.ClassDeclContext context, object? value) + { + PrepareClassMember(); + PropertyHeaderValue header = GetPropertyHeaderValue(value); + EntityRegistry.PropertyEntity? property = null; + if (header.IsValid && _currentTypeDefinition.PeekOrDefault() is { } currentType) + { + BlobBuilder signature = new(); + signature.WriteByte( + (byte)(header.CallingConvention | (byte)SignatureKind.Property)); + signature.WriteCompressedInteger(header.Arguments.Length); + MaterializeType(header.PropertyType).WriteContentTo(signature); + foreach (SignatureArgumentValue argument in header.Arguments) + { + MaterializeSignatureArgument(argument).SignatureBlob.WriteContentTo(signature); + } + + property = new EntityRegistry.PropertyEntity(header.Attributes, signature, header.Name); + if (header.ConstantValue is not NoConstantSentinel) + { + property.ConstantValue = header.ConstantValue; + property.HasConstant = true; + property.Attributes |= PropertyAttributes.HasDefault; + } + + currentType.Properties.Add(property); + } + + _propertyBodyFrames.Push(new(context, property)); + } + + internal void AddPropertySetter(CILParser.PropDeclContext context, object? value) + => AddPropertyAccessor(context, MethodSemanticsAttributes.Setter, value); + + internal void AddPropertyGetter(CILParser.PropDeclContext context, object? value) + => AddPropertyAccessor(context, MethodSemanticsAttributes.Getter, value); + + internal void AddPropertyOther(CILParser.PropDeclContext context, object? value) + => AddPropertyAccessor(context, MethodSemanticsAttributes.Other, value); + + private void AddPropertyAccessor( + CILParser.PropDeclContext context, + MethodSemanticsAttributes semantics, + object? value) + { + if (TryGetPropertyBodyFrame(context) is { Property: { } property }) + { + property.Accessors.Add( + (semantics, MaterializeMethodReference(GetMethodReferenceValue(value)))); + } + } + + internal void AddPropertyCustomAttribute( + CILParser.PropDeclContext context, + CILParser.CustomAttrDeclContext attribute) + { + if (attribute.HasSyntaxError || + TryGetPropertyBodyFrame(context) is not { Property: { } property }) + { + return; + } + + if (VisitCustomAttrDecl(attribute).Value is { } customAttribute) + { + customAttribute.Owner = property; + } + } + + internal void ProcessPropertySourceDirective(CILParser.ExtSourceSpecContext context) + { + if (!context.HasSyntaxError) + { + _ = VisitExtSourceSpec(context); + } + } + + internal void ProcessPropertyLanguageDirective(CILParser.LanguageDeclContext context) + { + if (!context.HasSyntaxError) + { + _ = VisitLanguageDecl(context); + } + } + + internal void BeginEventHeader(CILParser.EventHeadContext context) + => _eventHeaderFrames.Push(new(context, _syntaxErrorCount)); + + internal void AddEventAttribute(CILParser.EventHeadContext context, object? value) + { + if (TryGetEventHeaderFrame(context) is { } frame) + { + frame.Attributes = ApplyAttribute( + frame.Attributes, + GetAttributeValue(value)); + } + } + + internal object CreateEventHeader( + CILParser.EventHeadContext context, + object? eventType, + string name) + { + EventHeaderFrame? frame = TryGetEventHeaderFrame(context); + if (frame is null || + frame.InitialSyntaxErrorCount != _syntaxErrorCount || + context.exception is not null) + { + return EventHeaderValue.Error; + } + + return new EventHeaderValue( + true, + frame.Attributes, + eventType is null ? null : GetTypeSpecificationValue(eventType), + name); + } + + internal void EndEventHeader(CILParser.EventHeadContext context) + { + if (_eventHeaderFrames.Count == 0) + { + return; + } + + EventHeaderFrame frame = _eventHeaderFrames.Peek(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + if (ReferenceEquals(frame.Owner, context)) + { + _eventHeaderFrames.Pop(); + } + } + + internal object CreateEventAttribute(IToken token) + => token.Text switch + { + "specialname" => new AttributeValue( + EventAttributes.SpecialName, + 0, + true), + "rtspecialname" => new AttributeValue(0, 0, true), + _ => throw new UnreachableException(), + }; + + internal void BeginEvent(CILParser.ClassDeclContext context, object? value) + { + PrepareClassMember(); + EventHeaderValue header = GetEventHeaderValue(value); + EntityRegistry.EventEntity? @event = null; + if (header.IsValid && _currentTypeDefinition.PeekOrDefault() is { } currentType) + { + @event = new EntityRegistry.EventEntity( + header.Attributes, + header.EventType is null + ? null + : ResolveTypeSpecification(header.EventType), + header.Name); + currentType.Events.Add(@event); + } + + _eventBodyFrames.Push(new(context, @event)); + } + + internal void AddEventAdder(CILParser.EventDeclContext context, object? value) + => AddEventAccessor(context, MethodSemanticsAttributes.Adder, value); + + internal void AddEventRemover(CILParser.EventDeclContext context, object? value) + => AddEventAccessor(context, MethodSemanticsAttributes.Remover, value); + + internal void AddEventRaiser(CILParser.EventDeclContext context, object? value) + => AddEventAccessor(context, MethodSemanticsAttributes.Raiser, value); + + internal void AddEventOther(CILParser.EventDeclContext context, object? value) + => AddEventAccessor(context, MethodSemanticsAttributes.Other, value); + + private void AddEventAccessor( + CILParser.EventDeclContext context, + MethodSemanticsAttributes semantics, + object? value) + { + if (TryGetEventBodyFrame(context) is { Event: { } @event }) + { + @event.Accessors.Add( + (semantics, MaterializeMethodReference(GetMethodReferenceValue(value)))); + } + } + + internal void AddEventCustomAttribute( + CILParser.EventDeclContext context, + CILParser.CustomAttrDeclContext attribute) + { + if (attribute.HasSyntaxError || + TryGetEventBodyFrame(context) is not { Event: { } @event }) + { + return; + } + + if (VisitCustomAttrDecl(attribute).Value is { } customAttribute) + { + customAttribute.Owner = @event; + } + } + + internal void ProcessEventSourceDirective(CILParser.ExtSourceSpecContext context) + { + if (!context.HasSyntaxError) + { + _ = VisitExtSourceSpec(context); + } + } + + internal void ProcessEventLanguageDirective(CILParser.LanguageDeclContext context) + { + if (!context.HasSyntaxError) + { + _ = VisitLanguageDecl(context); + } + } + + private void EndPropertyAndEventBodies(CILParser.ClassDeclContext context) + { + if (_propertyBodyFrames.Count > 0 && + ReferenceEquals(_propertyBodyFrames.Peek().Owner, context)) + { + _propertyBodyFrames.Pop(); + } + + if (_eventBodyFrames.Count > 0 && + ReferenceEquals(_eventBodyFrames.Peek().Owner, context)) + { + _eventBodyFrames.Pop(); + } + } + + GrammarResult ICILVisitor.VisitEventAttr(CILParser.EventAttrContext context) + => VisitEventAttr(context); + + public static GrammarResult.Flag VisitEventAttr( + CILParser.EventAttrContext context) + { + AttributeValue attribute = + GetAttributeValue(context.Value); + return new(attribute.Value, attribute.ShouldAppend, attribute.GroupMask); + } + + GrammarResult ICILVisitor.VisitEventDecl(CILParser.EventDeclContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitEventDecls(CILParser.EventDeclsContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitEventHead(CILParser.EventHeadContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitPropAttr(CILParser.PropAttrContext context) + => VisitPropAttr(context); + + public static GrammarResult.Flag VisitPropAttr( + CILParser.PropAttrContext context) + { + AttributeValue attribute = + GetAttributeValue(context.Value); + return new(attribute.Value, attribute.ShouldAppend, attribute.GroupMask); + } + + GrammarResult ICILVisitor.VisitPropDecl(CILParser.PropDeclContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitPropDecls(CILParser.PropDeclsContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitPropHead(CILParser.PropHeadContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + private PropertyHeaderFrame? TryGetPropertyHeaderFrame(CILParser.PropHeadContext context) + { + Debug.Assert(_propertyHeaderFrames.Count > 0); + PropertyHeaderFrame? frame = + _propertyHeaderFrames.Count == 0 ? null : _propertyHeaderFrames.Peek(); + Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); + return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; + } + + private EventHeaderFrame? TryGetEventHeaderFrame(CILParser.EventHeadContext context) + { + Debug.Assert(_eventHeaderFrames.Count > 0); + EventHeaderFrame? frame = + _eventHeaderFrames.Count == 0 ? null : _eventHeaderFrames.Peek(); + Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); + return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; + } + + private PropertyBodyFrame? TryGetPropertyBodyFrame(CILParser.PropDeclContext context) + { + PropertyBodyFrame? frame = + _propertyBodyFrames.Count == 0 ? null : _propertyBodyFrames.Peek(); + Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context.Parent?.Parent)); + return frame is not null && ReferenceEquals(frame.Owner, context.Parent?.Parent) ? frame : null; + } + + private EventBodyFrame? TryGetEventBodyFrame(CILParser.EventDeclContext context) + { + EventBodyFrame? frame = + _eventBodyFrames.Count == 0 ? null : _eventBodyFrames.Peek(); + Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context.Parent?.Parent)); + return frame is not null && ReferenceEquals(frame.Owner, context.Parent?.Parent) ? frame : null; + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Values.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Values.cs new file mode 100644 index 00000000000000..2897d8ea4e1115 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Values.cs @@ -0,0 +1,68 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Immutable; +using System.Reflection; + +namespace ILAssembler; + +internal sealed partial class GrammarActions +{ + private sealed record FieldDeclarationValue( + bool IsValid, + FieldAttributes Attributes, + TypeValue FieldType, + string Name, + MarshallingDescriptorValue Marshalling, + string? DataDeclarationName, + int? Offset, + object? ConstantValue) + { + public static FieldDeclarationValue Error { get; } = new( + false, + 0, + TypeValue.Error, + string.Empty, + GetMarshallingDescriptorValue(null), + null, + null, + NoConstantSentinel.Instance); + } + + private sealed record PropertyHeaderValue( + bool IsValid, + PropertyAttributes Attributes, + byte CallingConvention, + TypeValue PropertyType, + string Name, + ImmutableArray Arguments, + object? ConstantValue) + { + public static PropertyHeaderValue Error { get; } = new( + false, + 0, + 0, + TypeValue.Error, + string.Empty, + [], + NoConstantSentinel.Instance); + } + + private sealed record EventHeaderValue( + bool IsValid, + EventAttributes Attributes, + TypeSpecificationValue? EventType, + string Name) + { + public static EventHeaderValue Error { get; } = new(false, 0, null, string.Empty); + } + + private static FieldDeclarationValue GetFieldDeclarationValue(object? value) + => value as FieldDeclarationValue ?? FieldDeclarationValue.Error; + + private static PropertyHeaderValue GetPropertyHeaderValue(object? value) + => value as PropertyHeaderValue ?? PropertyHeaderValue.Error; + + private static EventHeaderValue GetEventHeaderValue(object? value) + => value as EventHeaderValue ?? EventHeaderValue.Error; +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.cs index 6a979e5199f06f..61607c7663aa67 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.cs @@ -1,597 +1,12 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System; -using System.Buffers.Binary; -using System.Collections.Generic; -using System.Collections.Immutable; using System.Diagnostics; -using System.Globalization; -using System.IO; -using System.Linq; -using System.Reflection; -using System.Reflection.Metadata; -using System.Reflection.Metadata.Ecma335; -using System.Reflection.PortableExecutable; -using System.Runtime.InteropServices; -using System.Security.Cryptography; -using System.Text; -using Antlr4.Runtime; -using Antlr4.Runtime.Misc; -using Antlr4.Runtime.Tree; namespace ILAssembler; internal sealed partial class GrammarActions { - internal void OnClassDeclaration(CILParser.ClassDeclContext context) - { - if (context.classHead() is not null || context.methodHead() is not null) - { - return; - } - - VisitClassDecl(context); - } - public GrammarResult VisitClassDecl(CILParser.ClassDeclContext context) - { - bool isStandaloneCustomAttribute = - context.customAttrDecl().Length == 1 && - context.PARAM() is null; - if (!isStandaloneCustomAttribute) - { - _pendingClassCustomAttributeOwner = null; - } - - if (context.classHead() is not null || context.methodHead() is not null) - { - throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - } - - if (context.secDecl() is {} secDecl) - { - var declarativeSecurity = VisitSecDecl(secDecl).Value; - declarativeSecurity?.Parent = _currentTypeDefinition.PeekOrDefault(); - } - else if (context.TYPE() is not null && - context.typeSpec().Length == 1 && - context.customDescr() is { } interfaceAttribute) - { - var currentType = _currentTypeDefinition.PeekOrDefault(); - if (currentType is not null) - { - EntityRegistry.TypeEntity interfaceType = VisitTypeSpec(context.typeSpec()[0]).Value; - EntityRegistry.InterfaceImplementationEntity? implementation = - currentType.InterfaceImplementations.FirstOrDefault( - candidate => candidate.InterfaceType == interfaceType); - if (implementation is null) - { - implementation = - EntityRegistry.CreateUnrecordedInterfaceImplementation(currentType, interfaceType); - currentType.InterfaceImplementations.Add(implementation); - } - - VisitCustomDescr(interfaceAttribute).Value.Owner = implementation; - } - } - else if (context.fieldDecl() is {} fieldDecl) - { - _ = VisitFieldDecl(fieldDecl); - } - else if (context.dataDecl() is { } dataDecl) - { - _ = VisitDataDecl(dataDecl); - } - else if (context.extSourceSpec() is { } extSourceSpec) - { - _ = VisitExtSourceSpec(extSourceSpec); - } - else if (context.languageDecl() is { } languageDecl) - { - _ = VisitLanguageDecl(languageDecl); - } - else if (context.OVERRIDE() is not null) - { - var currentType = _currentTypeDefinition.PeekOrDefault(); - if (currentType is not null) - { - var typeSpecs = context.typeSpec(); - var methodNames = context.methodName(); - var callConventions = context.callConv(); - var returnTypes = context.type(); - var signatureArguments = context.sigArgs(); - var genericArities = context.genArity(); - - int bodySignatureIndex = context.METHOD().Length == 0 ? 0 : 1; - BlobBuilder declarationSignature = BuildMethodReferenceSignature( - callConventions[0], - returnTypes[0], - signatureArguments[0], - genericArities.Length > 0 ? VisitGenArity(genericArities[0]).Value : 0); - BlobBuilder bodySignature = context.METHOD().Length == 0 - ? declarationSignature - : BuildMethodReferenceSignature( - callConventions[bodySignatureIndex], - returnTypes[bodySignatureIndex], - signatureArguments[bodySignatureIndex], - genericArities.Length > bodySignatureIndex - ? VisitGenArity(genericArities[bodySignatureIndex]).Value - : 0); - - string bodyName = VisitMethodName(methodNames[1]).Value; - EntityRegistry.MethodDefinitionEntity[] bodyMethods = currentType.Methods - .Where(method => - method.Name == bodyName && - method.MethodSignature is not null && - method.MethodSignature.ContentEquals(bodySignature)) - .Take(2) - .ToArray(); - if (bodyMethods.Length != 1) - { - ReportError( - DiagnosticIds.InvalidMetadataToken, - $"Override body method '{bodyName}' could not be resolved uniquely", - context); - return GrammarResult.SentinelValue.Result; - } - - EntityRegistry.MethodDefinitionEntity bodyMethod = bodyMethods[0]; - EntityRegistry.MemberReferenceEntity declaration = - _entityRegistry.CreateLazilyRecordedMemberReference( - VisitTypeSpec(typeSpecs[0]).Value, - VisitMethodName(methodNames[0]).Value, - declarationSignature); - currentType.MethodImplementations.Add( - EntityRegistry.CreateUnrecordedMethodImplementation(bodyMethod, declaration)); - } - } - else if (context.int32() is {} int32) - { - // .pack or .size - string keyword = context.GetChild(0).GetText(); - int value = VisitInt32(int32).Value; - var currentType = _currentTypeDefinition.PeekOrDefault(); - if (currentType is not null) - { - if (keyword == ".pack") - { - currentType.PackingSize = value; - } - else if (keyword == ".size") - { - currentType.ClassSize = value; - } - } - } - else if (context.propHead() is CILParser.PropHeadContext propHead) - { - var property = VisitPropHead(propHead).Value; - var currentType = _currentTypeDefinition.PeekOrDefault(); - if (currentType is not null) - { - currentType.Properties.Add(property); - foreach (var propDecl in context.propDecls().propDecl()) - { - if (propDecl.customAttrDecl() is { } customAttrDecl) - { - var customAttr = VisitCustomAttrDecl(customAttrDecl).Value; - if (customAttr is not null) - { - customAttr.Owner = property; - } - } - else if (VisitPropDecl(propDecl).Value is { } accessor) - { - property.Accessors.Add(accessor); - } - } - } - } - else if (context.eventHead() is CILParser.EventHeadContext eventHead) - { - var evt = VisitEventHead(eventHead).Value; - var currentType = _currentTypeDefinition.PeekOrDefault(); - if (currentType is not null) - { - currentType.Events.Add(evt); - foreach (var eventDecl in context.eventDecls().eventDecl()) - { - if (eventDecl.customAttrDecl() is { } customAttrDecl) - { - var customAttr = VisitCustomAttrDecl(customAttrDecl).Value; - if (customAttr is not null) - { - customAttr.Owner = evt; - } - } - else if (VisitEventDecl(eventDecl).Value is { } accessor) - { - evt.Accessors.Add(accessor); - } - } - } - } - else if (context.OVERRIDE() is not null) - { - var currentType = _currentTypeDefinition.PeekOrDefault(); - if (currentType is null) - { - throw new UnreachableException(); - } - - CILParser.CallConvContext[] callConvs = context.callConv(); - CILParser.TypeContext[] returnTypes = context.type(); - CILParser.TypeSpecContext[] owners = context.typeSpec(); - CILParser.MethodNameContext[] methodNames = context.methodName(); - CILParser.GenArityContext[] genericArities = context.genArity(); - CILParser.SigArgsContext[] parameterLists = context.sigArgs(); - - EntityRegistry.MemberReferenceEntity declaration; - EntityRegistry.MemberReferenceEntity body; - if (callConvs.Length == 2) - { - declaration = CreateExplicitMethodReference( - callConvs[0], returnTypes[0], owners[0], methodNames[0], genericArities[0], parameterLists[0]); - body = CreateExplicitMethodReference( - callConvs[1], returnTypes[1], owners[1], methodNames[1], genericArities[1], parameterLists[1]); - } - else - { - EntityRegistry.TypeEntity declarationOwner = VisitTypeSpec(owners[0]).Value; - string declarationName = VisitMethodName(methodNames[0]).Value; - EntityRegistry.TypeEntity bodyOwner = VisitTypeSpec(owners[1]).Value; - string bodyName = VisitMethodName(methodNames[1]).Value; - BlobBuilder bodySignature = CreateExplicitMethodSignature( - callConvs[0], returnTypes[0], genericArity: null, parameterLists[0]); - BlobBuilder declarationSignature = new(); - bodySignature.WriteContentTo(declarationSignature); - declaration = _entityRegistry.CreateLazilyRecordedMemberReference( - declarationOwner, declarationName, declarationSignature); - body = _entityRegistry.CreateLazilyRecordedMemberReference( - bodyOwner, bodyName, bodySignature); - } - - currentType.MethodImplementations.Add(EntityRegistry.CreateUnrecordedMethodImplementation(currentType, body, declaration)); - } - else if (isStandaloneCustomAttribute) - { - if (VisitCustomAttrDecl(context.customAttrDecl()[0]).Value is { } customAttr) - { - customAttr.Owner = - _pendingClassCustomAttributeOwner ?? - _currentTypeDefinition.PeekOrDefault(); - } - } - else if (context.PARAM() is not null) - { - var customAttrDeclarations = context.customAttrDecl(); - var currentType = _currentTypeDefinition.PeekOrDefault(); - if (currentType is not null && context.TYPE() is not null) - { - EntityRegistry.GenericParameterEntity? param = null; - if (context.int32() is { } int32ctx) - { - int index = VisitInt32(int32ctx).Value; - if (index >= 0 && index < currentType.GenericParameters.Count) - { - param = currentType.GenericParameters[index]; - } - else - { - ReportError( - DiagnosticIds.GenericParameterIndexOutOfRange, - string.Format(DiagnosticMessageTemplates.GenericParameterIndexOutOfRange, index), - context); - } - } - else if (context.dottedName() is { } dn) - { - string name = VisitDottedName(dn).Value; - foreach (var genericParam in currentType.GenericParameters) - { - if (genericParam.Name == name) - { - param = genericParam; - break; - } - } - } - if (param is not null) - { - foreach (var attr in customAttrDeclarations ?? Array.Empty()) - { - var customAttrDecl = VisitCustomAttrDecl(attr).Value; - customAttrDecl?.Owner = param; - } - _pendingClassCustomAttributeOwner = param; - } - } - else if (currentType is not null && context.CONSTRAINT() is not null) - { - EntityRegistry.GenericParameterEntity? param = null; - if (context.int32() is { } int32ctx) - { - int index = VisitInt32(int32ctx).Value; - if (index >= 0 && index < currentType.GenericParameters.Count) - { - param = currentType.GenericParameters[index]; - } - else - { - ReportError( - DiagnosticIds.GenericParameterIndexOutOfRange, - string.Format(DiagnosticMessageTemplates.GenericParameterIndexOutOfRange, index), - context); - } - } - else if (context.dottedName() is { } dn) - { - string name = VisitDottedName(dn).Value; - foreach (var genericParam in currentType.GenericParameters) - { - if (genericParam.Name == name) - { - param = genericParam; - break; - } - } - } - if (param is not null) - { - var baseType = VisitTypeSpec(context.typeSpec()[0]).Value; - EntityRegistry.GenericParameterConstraintEntity? constraint = - param.Constraints.FirstOrDefault(entity => entity.BaseType == baseType); - if (constraint is null) - { - constraint = EntityRegistry.CreateGenericConstraint(baseType); - constraint.Owner = param; - param.Constraints.Add(constraint); - currentType.GenericParameterConstraints.Add(constraint); - } - foreach (var attr in customAttrDeclarations ?? Array.Empty()) - { - var customAttrDecl = VisitCustomAttrDecl(attr).Value; - customAttrDecl?.Owner = constraint; - } - _pendingClassCustomAttributeOwner = constraint; - } - } - } - - return GrammarResult.SentinelValue.Result; - } - -#pragma warning disable CA1822 // Mark members as static - GrammarResult ICILVisitor.VisitEventAttr(CILParser.EventAttrContext context) => VisitEventAttr(context); - public GrammarResult.Flag VisitEventAttr(CILParser.EventAttrContext context) - { - return context.GetText() switch - { - "specialname" => new(EventAttributes.SpecialName), - "rtspecialname" => new(0), // COMPAT: Ignore - _ => throw new UnreachableException(), - }; - } - - GrammarResult ICILVisitor.VisitEventDecl(CILParser.EventDeclContext context) => VisitEventDecl(context); - public GrammarResult.Literal<(MethodSemanticsAttributes, EntityRegistry.EntityBase)?> VisitEventDecl(CILParser.EventDeclContext context) - { - if (context.ChildCount != 2) - { - return new(null); - } - string accessor = context.GetChild(0).GetText(); - EntityRegistry.EntityBase memberReference = VisitMethodRef(context.methodRef()).Value; - MethodSemanticsAttributes methodSemanticsAttributes = accessor switch - { - ".addon" => MethodSemanticsAttributes.Adder, - ".removeon" => MethodSemanticsAttributes.Remover, - ".fire" => MethodSemanticsAttributes.Raiser, - ".other" => MethodSemanticsAttributes.Other, - _ => throw new UnreachableException(), - }; - return new((methodSemanticsAttributes, memberReference)); - } - - GrammarResult ICILVisitor.VisitEventDecls(CILParser.EventDeclsContext context) => VisitEventDecls(context); - public GrammarResult.Sequence<(MethodSemanticsAttributes, EntityRegistry.EntityBase)> VisitEventDecls(CILParser.EventDeclsContext context) - => new( - context.eventDecl() - .Select(decl => VisitEventDecl(decl).Value) - .Where(decl => decl is not null) - .Select(decl => decl!.Value).ToImmutableArray()); - - GrammarResult ICILVisitor.VisitEventHead(CILParser.EventHeadContext context) => VisitEventHead(context); - public GrammarResult.Literal VisitEventHead(CILParser.EventHeadContext context) - { - string name = VisitDottedName(context.dottedName()).Value; - EventAttributes eventAttributes = context.eventAttr().Select(attr => VisitEventAttr(attr).Value).Aggregate((EventAttributes)0, (a, b) => a | b); - return new(new EntityRegistry.EventEntity(eventAttributes, VisitTypeSpec(context.typeSpec()).Value, name)); - } - - GrammarResult ICILVisitor.VisitFieldAttr(CILParser.FieldAttrContext context) => VisitFieldAttr(context); - public GrammarResult.Flag VisitFieldAttr(CILParser.FieldAttrContext context) - { - if (context.int32() is { } int32) - { - return new((FieldAttributes)VisitInt32(int32).Value, ShouldAppend: false); - } - - return context.GetText() switch - { - "static" => new(FieldAttributes.Static), - "public" => new(FieldAttributes.Public, FieldAttributes.FieldAccessMask), - "private" => new(FieldAttributes.Private, FieldAttributes.FieldAccessMask), - "family" => new(FieldAttributes.Family, FieldAttributes.FieldAccessMask), - "initonly" => new(FieldAttributes.InitOnly), - "rtspecialname" => new(FieldAttributes.RTSpecialName), - "specialname" => new(FieldAttributes.SpecialName), - "assembly" => new(FieldAttributes.Assembly, FieldAttributes.FieldAccessMask), - "famandassem" => new(FieldAttributes.FamANDAssem, FieldAttributes.FieldAccessMask), - "famorassem" => new(FieldAttributes.FamORAssem, FieldAttributes.FieldAccessMask), - "privatescope" => new(FieldAttributes.PrivateScope, FieldAttributes.FieldAccessMask), - "literal" => new(FieldAttributes.Literal), -#pragma warning disable SYSLIB0050 // FieldAttributes.NotSeralized is obsolete - "notserialized" => new(FieldAttributes.NotSerialized), -#pragma warning restore SYSLIB0050 // FieldAttributes.NotSeralized is obsolete - "volatile" => new(0), // COMPAT: volatile is not a field attribute; accepted for compatibility - _ => throw new UnreachableException() - }; - } - GrammarResult ICILVisitor.VisitFieldDecl(CILParser.FieldDeclContext context) => VisitFieldDecl(context); - public GrammarResult VisitFieldDecl(CILParser.FieldDeclContext context) - { - var fieldAttrs = context.fieldAttr().Select(VisitFieldAttr).Aggregate((FieldAttributes)0, (a, b) => a | b); - // COMPAT: Native ilasm implicitly adds SpecialName when RTSpecialName is set - if (fieldAttrs.HasFlag(FieldAttributes.RTSpecialName)) - { - fieldAttrs |= FieldAttributes.SpecialName; - } - var fieldType = VisitType(context.type()).Value; - var marshalBlobs = context.marshalBlob(); - var marshalBlob = marshalBlobs.Length > 0 ? VisitMarshalBlob(marshalBlobs[marshalBlobs.Length - 1]).Value : null; - string name = VisitDottedName(context.dottedName()).Value; - var rvaOffset = VisitAtOpt(context.atOpt()).Value; - var fieldOffset = VisitRepeatOpt(context.repeatOpt()).Value; - var constantValue = VisitInitOpt(context.initOpt()).Value; - - var signature = new BlobEncoder(new BlobBuilder()); - _ = signature.Field(); - fieldType.WriteContentTo(signature.Builder); - - var field = EntityRegistry.CreateUnrecordedFieldDefinition(fieldAttrs, _currentTypeDefinition.PeekOrDefault() ?? _entityRegistry.ModuleType, name, signature.Builder); - _lastFieldDefinition = field; - _pendingClassCustomAttributeOwner = field; - - if (field is not null) - { - field.MarshallingDescriptor = marshalBlob; - field.DataDeclarationName = rvaOffset; - field.Offset = fieldOffset; - if (constantValue is not NoConstantSentinel) - { - field.ConstantValue = constantValue; - field.HasConstant = true; - } - } - - return GrammarResult.SentinelValue.Result; - } - - GrammarResult ICILVisitor.VisitFieldInit(CILParser.FieldInitContext context) => VisitFieldInit(context); - public GrammarResult.Literal VisitFieldInit(CILParser.FieldInitContext context) - { - // fieldInit: fieldSerInit | compQstring | NULLREF; - if (context.NULLREF() is not null) - { - return new(null); - } - if (context.compQstring() is CILParser.CompQstringContext compQstring) - { - return new(VisitCompQstring(compQstring).Value); - } - if (context.fieldSerInit() is CILParser.FieldSerInitContext fieldSerInit) - { - // fieldSerInit returns a blob with type byte prefix - extract the actual value - var blob = VisitFieldSerInit(fieldSerInit).Value; - return new(ExtractConstantFromSerInit(blob)); - } - return new(null); - } - - public GrammarResult VisitFieldOrProp(CILParser.FieldOrPropContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - - GrammarResult ICILVisitor.VisitFieldRef(CILParser.FieldRefContext context) => VisitFieldRef(context); - - public GrammarResult.Literal VisitFieldRef(CILParser.FieldRefContext context) - => new(MaterializeFieldReference(GetFieldReferenceValue(context.Value))); - - GrammarResult ICILVisitor.VisitInitOpt(CILParser.InitOptContext context) => VisitInitOpt(context); - public GrammarResult.Literal VisitInitOpt(CILParser.InitOptContext context) - { - if (context.fieldInit() is CILParser.FieldInitContext fieldInit) - { - return VisitFieldInit(fieldInit); - } - // No initializer - return a sentinel indicating no constant - return new(NoConstantSentinel.Instance); - } - - GrammarResult ICILVisitor.VisitMemberRef(CILParser.MemberRefContext context) => VisitMemberRef(context); - - public GrammarResult.Literal VisitMemberRef(CILParser.MemberRefContext context) - => new(MaterializeMemberReference(GetMemberReferenceValue(context.Value))); - - GrammarResult ICILVisitor.VisitPropAttr(CILParser.PropAttrContext context) => VisitPropAttr(context); - public static GrammarResult.Flag VisitPropAttr(CILParser.PropAttrContext context) - { - return context.GetText() switch - { - "specialname" => new(PropertyAttributes.SpecialName), - "rtspecialname" => new(0), // COMPAT: Ignore - _ => throw new UnreachableException(), - }; - } - - GrammarResult ICILVisitor.VisitPropDecl(CILParser.PropDeclContext context) => VisitPropDecl(context); - public GrammarResult.Literal<(MethodSemanticsAttributes, EntityRegistry.EntityBase)?> VisitPropDecl(CILParser.PropDeclContext context) - { - if (context.ChildCount != 2) - { - return new(null); - } - string accessor = context.GetChild(0).GetText(); - EntityRegistry.EntityBase memberReference = VisitMethodRef(context.methodRef()).Value; - MethodSemanticsAttributes methodSemanticsAttributes = accessor switch - { - ".set" => MethodSemanticsAttributes.Setter, - ".get" => MethodSemanticsAttributes.Getter, - ".other" => MethodSemanticsAttributes.Other, - _ => throw new UnreachableException(), - }; - return new((methodSemanticsAttributes, memberReference)); - } - - GrammarResult ICILVisitor.VisitPropDecls(CILParser.PropDeclsContext context) => VisitPropDecls(context); - public GrammarResult.Sequence<(MethodSemanticsAttributes, EntityRegistry.EntityBase)> VisitPropDecls(CILParser.PropDeclsContext context) - => new( - context.propDecl() - .Select(decl => VisitPropDecl(decl).Value) - .Where(decl => decl is not null) - .Select(decl => decl!.Value).ToImmutableArray()); - - GrammarResult ICILVisitor.VisitPropHead(ILAssembler.CILParser.PropHeadContext context) => VisitPropHead(context); - public GrammarResult.Literal VisitPropHead(CILParser.PropHeadContext context) - { - var propAttrs = context.propAttr().Select(VisitPropAttr).Aggregate((PropertyAttributes)0, (a, b) => a | b); - var name = VisitDottedName(context.dottedName()).Value; - - var signature = new BlobBuilder(); - byte callConv = (byte)(VisitCallConv(context.callConv()).Value | (byte)SignatureKind.Property); - signature.WriteByte(callConv); - var args = VisitSigArgs(context.sigArgs()).Value; - signature.WriteCompressedInteger(args.Length); - VisitType(context.type()).Value.WriteContentTo(signature); - foreach (var arg in args) - { - arg.SignatureBlob.WriteContentTo(signature); - } - - // Handle initOpt to set the Constant table entry if a constant value is provided. - var constantValue = VisitInitOpt(context.initOpt()).Value; - var property = new EntityRegistry.PropertyEntity(propAttrs, signature, name); - if (constantValue is not NoConstantSentinel) - { - property.ConstantValue = constantValue; - property.HasConstant = true; - property.Attributes |= PropertyAttributes.HasDefault; - } - return new(property); - } - - GrammarResult ICILVisitor.VisitRepeatOpt(CILParser.RepeatOptContext context) => VisitRepeatOpt(context); - public GrammarResult.Literal VisitRepeatOpt(CILParser.RepeatOptContext context) => context.int32() is {} int32 ? new(VisitInt32(int32).Value) : new(null); - -#pragma warning restore CA1822 // Mark members as static + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.ExceptionHandling.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.ExceptionHandling.cs index 8df08131bd3a72..601a1cf32e1752 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.ExceptionHandling.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.ExceptionHandling.cs @@ -18,14 +18,6 @@ internal sealed partial class GrammarActions private readonly Stack _scopeStack = new(); private RuleContext? _methodOwner; - internal void BeginMethod(CILParser.MethodHeadContext context) - { - ClearPendingCustomAttributeOwners(); - ResetMethodBodyState(); - _currentMethod = new CurrentMethodContext(VisitMethodHead(context).Value); - _methodOwner = context.Parent; - } - private void EndMethod() { Debug.Assert( diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs index b8fbb5faa599dc..a6fcd294a966af 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs @@ -37,35 +37,6 @@ internal sealed partial class GrammarActions GrammarResult ICILVisitor.VisitHandlerBlock(CILParser.HandlerBlockContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - GrammarResult ICILVisitor.VisitImplAttr(ILAssembler.CILParser.ImplAttrContext context) => VisitImplAttr(context); - public GrammarResult.Flag VisitImplAttr(CILParser.ImplAttrContext context) - { - if (context.int32() is CILParser.Int32Context int32) - { - return new((MethodImplAttributes)VisitInt32(int32).Value, ShouldAppend: false); - } - string attribute = context.GetText(); - return attribute switch - { - "native" => new(MethodImplAttributes.Native, MethodImplAttributes.CodeTypeMask), - "cil" or "il" => new(MethodImplAttributes.IL, MethodImplAttributes.CodeTypeMask), - "optil" => new(MethodImplAttributes.OPTIL, MethodImplAttributes.CodeTypeMask), - "managed" => new(MethodImplAttributes.Managed, MethodImplAttributes.ManagedMask), - "unmanaged" => new(MethodImplAttributes.Unmanaged, MethodImplAttributes.ManagedMask), - "forwardref" => new(MethodImplAttributes.ForwardRef), - "preservesig" => new(MethodImplAttributes.PreserveSig), - "runtime" => new(MethodImplAttributes.Runtime, MethodImplAttributes.CodeTypeMask), - "internalcall" => new(MethodImplAttributes.InternalCall), - "synchronized" => new(MethodImplAttributes.Synchronized), - "noinlining" => new(MethodImplAttributes.NoInlining), - "aggressiveinlining" => new(MethodImplAttributes.AggressiveInlining), - "nooptimization" => new(MethodImplAttributes.NoOptimization), - "aggressiveoptimization" => new(MethodImplAttributes.AggressiveOptimization), - "async" => new(MethodImplAttributes.Async), - _ => throw new UnreachableException(), - }; - } - GrammarResult ICILVisitor.VisitImplClause(CILParser.ImplClauseContext context) => VisitImplClause(context); public GrammarResult.Sequence VisitImplClause(CILParser.ImplClauseContext context) => context.implList() is {} implList ? VisitImplList(implList) : new(ImmutableArray.Empty); @@ -103,169 +74,10 @@ private void ValidateLabelReferences() GrammarResult ICILVisitor.VisitLocalsDecl(CILParser.LocalsDeclContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - GrammarResult ICILVisitor.VisitMethAttr(CILParser.MethAttrContext context) => VisitMethAttr(context); - public GrammarResult.Flag VisitMethAttr(CILParser.MethAttrContext context) - { - if (context.int32() is CILParser.Int32Context int32) - { - return new((MethodAttributes)VisitInt32(int32).Value, ShouldAppend: false); - } - string attribute = context.GetText(); - return attribute switch - { - "static" => new(MethodAttributes.Static), - "public" => new(MethodAttributes.Public, MethodAttributes.MemberAccessMask), - "private" => new(MethodAttributes.Private, MethodAttributes.MemberAccessMask), - "family" => new(MethodAttributes.Family, MethodAttributes.MemberAccessMask), - "final" => new(MethodAttributes.Final), - "specialname" => new(MethodAttributes.SpecialName), - "virtual" => new(MethodAttributes.Virtual), - "strict" => new(MethodAttributes.CheckAccessOnOverride), - "abstract" => new(MethodAttributes.Abstract), - "assembly" => new(MethodAttributes.Assembly, MethodAttributes.MemberAccessMask), - "famandassem" => new(MethodAttributes.FamANDAssem, MethodAttributes.MemberAccessMask), - "famorassem" => new(MethodAttributes.FamORAssem, MethodAttributes.MemberAccessMask), - "privatescope" => new(MethodAttributes.PrivateScope, MethodAttributes.MemberAccessMask), - "hidebysig" => new(MethodAttributes.HideBySig), - "newslot" => new(MethodAttributes.NewSlot), - "rtspecialname" => new(MethodAttributes.RTSpecialName), - "unmanagedexp" => new(MethodAttributes.UnmanagedExport), - "reqsecobj" => new(MethodAttributes.RequireSecObject), - _ => throw new UnreachableException(), - }; - } - public GrammarResult VisitMethodDecls(CILParser.MethodDeclsContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); GrammarResult ICILVisitor.VisitMethodDecl(CILParser.MethodDeclContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - GrammarResult ICILVisitor.VisitMethodHead(CILParser.MethodHeadContext context) => VisitMethodHead(context); - public GrammarResult.Literal VisitMethodHead(CILParser.MethodHeadContext context) - { - string name = VisitMethodName(context.methodName()).Value; - var containingType = _currentTypeDefinition.PeekOrDefault() ?? _entityRegistry.ModuleType; - var methodDefinition = EntityRegistry.CreateUnrecordedMethodDefinition(containingType, name); - - BlobBuilder methodSignature = new(); - byte sigHeader = VisitCallConv(context.callConv()).Value; - - // Two-pass generic parameter processing for method params: - // Pass 1: Register all parameter names (without resolving constraints) - _currentMethod = new(methodDefinition); - var typarContexts = context.typarsClause()?.typars()?.typar() ?? Array.Empty(); - for (int i = 0; i < typarContexts.Length; i++) - { - var attributes = VisitTyparAttribs(typarContexts[i].typarAttribs()).Value; - var param = EntityRegistry.CreateGenericParameter(attributes, VisitDottedName(typarContexts[i].dottedName()).Value); - param.Owner = methodDefinition; - param.Index = i; - methodDefinition.GenericParameters.Add(param); - } - if (typarContexts.Length != 0) - { - sigHeader |= (byte)SignatureAttributes.Generic; - } - methodDefinition.MethodAttributes = context.methAttr().Aggregate((MethodAttributes)0, (acc, attr) => acc | VisitMethAttr(attr)); - - // COMPAT: Native ilasm implicitly adds RTSpecialName + SpecialName for .ctor/.cctor methods - if (name is ".ctor" or ".cctor") - { - methodDefinition.MethodAttributes |= MethodAttributes.RTSpecialName | MethodAttributes.SpecialName; - } - // COMPAT: Native ilasm implicitly adds SpecialName when RTSpecialName is set - else if (methodDefinition.MethodAttributes.HasFlag(MethodAttributes.RTSpecialName)) - { - methodDefinition.MethodAttributes |= MethodAttributes.SpecialName; - } - - if (methodDefinition.MethodAttributes.HasFlag(MethodAttributes.Abstract) && !methodDefinition.ContainingType.Attributes.HasFlag(TypeAttributes.Abstract)) - { - ReportWarning(DiagnosticIds.AbstractMethodNotInAbstractType, - string.Format(DiagnosticMessageTemplates.AbstractMethodNotInAbstractType, methodDefinition.Name), - context); - } - - (EntityRegistry.ModuleReferenceEntity Module, string? EntryPoint, MethodImportAttributes Attributes)? pInvokeInformation = null; - foreach (var pInvokeInfo in context.pinvImpl()) - { - var (moduleName, entryPoint, attributes) = VisitPinvImpl(pInvokeInfo).Value; - if (moduleName is null) - { - ReportError(DiagnosticIds.InvalidPInvokeSignature, - DiagnosticMessageTemplates.InvalidPInvokeSignature, - pInvokeInfo); - continue; - } - pInvokeInformation = (_entityRegistry.GetOrCreateModuleReference(moduleName, _ => { }), entryPoint ?? name, attributes); - } - methodDefinition.MethodImportInformation = pInvokeInformation; - - SignatureHeader parsedHeader = new(sigHeader); - if (methodDefinition.MethodAttributes.HasFlag(MethodAttributes.Static) && (parsedHeader.IsInstance || parsedHeader.HasExplicitThis)) - { - // Error on static + instance. - } - // COMPAT: Native ilasm auto-adds instance calling convention for non-static methods in class context - if (!methodDefinition.MethodAttributes.HasFlag(MethodAttributes.Static) - && !parsedHeader.IsInstance - && _currentTypeDefinition.Count > 0) - { - sigHeader |= (byte)SignatureAttributes.Instance; - parsedHeader = new(sigHeader); - } - if (parsedHeader.HasExplicitThis && !parsedHeader.IsInstance) - { - // Warn on explicit-this + non-instance - parsedHeader = new(sigHeader |= (byte)SignatureAttributes.Instance); - } - methodSignature.WriteByte(sigHeader); - if (typarContexts.Length != 0) - { - methodSignature.WriteCompressedInteger(typarContexts.Length); - } - // Pass 2: Resolve constraints (now all params are registered) - for (int i = 0; i < typarContexts.Length; i++) - { - var param = methodDefinition.GenericParameters[i]; - foreach (var constraint in VisitTyBound(typarContexts[i].tyBound()).Value) - { - constraint.Owner = param; - param.Constraints.Add(constraint); - methodDefinition.GenericParameterConstraints.Add(constraint); - } - } - - var args = VisitSigArgs(context.sigArgs()).Value; - methodSignature.WriteCompressedInteger(args.Length); - - SignatureArg returnValue = new(VisitParamAttr(context.paramAttr()).Value, VisitType(context.type()).Value, VisitMarshalClause(context.marshalClause()).Value, null); - - returnValue.SignatureBlob.WriteContentTo(methodSignature); - methodDefinition.Parameters.Add(EntityRegistry.CreateParameter(returnValue.Attributes, returnValue.Name, returnValue.MarshallingDescriptor, 0)); - for (int i = 0; i < args.Length; i++) - { - SignatureArg? arg = args[i]; - arg.SignatureBlob.WriteContentTo(methodSignature); - // COMPAT: Native ilasm auto-generates A_N names for unnamed parameters - string? paramName = arg.Name ?? $"A_{i}"; - methodDefinition.Parameters.Add(EntityRegistry.CreateParameter(arg.Attributes, paramName, arg.MarshallingDescriptor, i + 1)); - } - // We've parsed all signature information. We can reset the current method now (the caller will handle setting/unsetting it for the method body). - _currentMethod = null; - methodDefinition.SignatureHeader = parsedHeader; - methodDefinition.MethodSignature = methodSignature; - - methodDefinition.ImplementationAttributes = context.implAttr().Aggregate((MethodImplAttributes)0, (acc, attr) => acc | VisitImplAttr(attr)); - if (!EntityRegistry.TryAddMethodDefinitionToContainingType(methodDefinition)) - { - ReportError(DiagnosticIds.DuplicateMethod, - DiagnosticMessageTemplates.DuplicateMethod, - context); - } - - return new(methodDefinition); - } - GrammarResult ICILVisitor.VisitMethodName(CILParser.MethodNameContext context) => VisitMethodName(context); public static GrammarResult.String VisitMethodName(CILParser.MethodNameContext context) diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.Actions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.Actions.cs new file mode 100644 index 00000000000000..ec4e8ae65163f6 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.Actions.cs @@ -0,0 +1,566 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Reflection; +using Antlr4.Runtime; + +namespace ILAssembler; + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. +internal sealed partial class GrammarActions +{ + private readonly Stack _methodHeaderFrames = new(); + private readonly Stack _pInvokeFrames = new(); + private readonly Stack _genericTypeListFrames = new(); + private readonly Stack _genericParameterAttributesFrames = new(); + private readonly Stack _genericParametersFrames = new(); + + private sealed class MethodHeaderFrame + { + public MethodHeaderFrame(CILParser.MethodHeadContext owner, int initialSyntaxErrorCount) + { + Owner = owner; + InitialSyntaxErrorCount = initialSyntaxErrorCount; + } + + public CILParser.MethodHeadContext Owner { get; } + + public int InitialSyntaxErrorCount { get; } + + public MethodAttributes Attributes { get; set; } + + public ImmutableArray.Builder PInvokes { get; } = + ImmutableArray.CreateBuilder(); + + public MethodImplAttributes ImplementationAttributes { get; set; } + } + + private sealed class PInvokeFrame + { + public PInvokeFrame(CILParser.PinvImplContext owner) + { + Owner = owner; + } + + public CILParser.PinvImplContext Owner { get; } + + public string? ModuleName { get; set; } + + public string? EntryPointName { get; set; } + + public MethodImportAttributes Attributes { get; set; } + } + + private sealed class GenericTypeListFrame + { + public GenericTypeListFrame(CILParser.TypeListContext owner) + { + Owner = owner; + } + + public CILParser.TypeListContext Owner { get; } + + public ImmutableArray.Builder Types { get; } = + ImmutableArray.CreateBuilder(); + } + + private sealed class GenericParameterAttributesFrame + { + public GenericParameterAttributesFrame(CILParser.TyparAttribsContext owner) + { + Owner = owner; + } + + public CILParser.TyparAttribsContext Owner { get; } + + public GenericParameterAttributes Attributes { get; set; } + } + + private sealed class GenericParametersFrame + { + public GenericParametersFrame(CILParser.TyparsContext owner) + { + Owner = owner; + } + + public CILParser.TyparsContext Owner { get; } + + public ImmutableArray.Builder Parameters { get; } = + ImmutableArray.CreateBuilder(); + } + + internal void BeginMethodHeader(CILParser.MethodHeadContext context) + { + ClearPendingCustomAttributeOwners(); + _methodHeaderFrames.Push(new(context, _syntaxErrorCount)); + } + + internal void AddMethodAttribute(CILParser.MethodHeadContext context, object? value) + { + if (TryGetMethodHeaderFrame(context) is { } frame) + { + frame.Attributes = ApplyAttribute(frame.Attributes, GetAttributeValue(value)); + } + } + internal void AddPInvoke(CILParser.MethodHeadContext context, object? value) + { + if (TryGetMethodHeaderFrame(context) is { } frame) + { + frame.PInvokes.Add(GetPInvokeValue(value)); + } + } + + internal void AddMethodImplementationAttribute(CILParser.MethodHeadContext context, object? value) + { + if (TryGetMethodHeaderFrame(context) is { } frame) + { + frame.ImplementationAttributes = ApplyAttribute( + frame.ImplementationAttributes, + GetAttributeValue(value)); + } + } + + internal object CreateMethodHeader( + CILParser.MethodHeadContext context, + byte callingConvention, + int returnAttributes, + object? returnType, + object? returnMarshalling, + string name, + object? genericParameters, + object? arguments) + { + MethodHeaderFrame? frame = TryGetMethodHeaderFrame(context); + if (frame is null || + frame.InitialSyntaxErrorCount != _syntaxErrorCount || + context.exception is not null) + { + return MethodHeaderValue.Error; + } + + return new MethodHeaderValue( + true, + frame.Attributes, + frame.PInvokes.ToImmutable(), + callingConvention, + returnAttributes, + GetTypeValue(returnType), + GetMarshallingDescriptorValue(returnMarshalling), + name, + GetGenericParameterDeclarations(genericParameters), + GetSignatureArgumentsValue(arguments), + frame.ImplementationAttributes); + } + + internal void EndMethodHeader(CILParser.MethodHeadContext context) + { + if (_methodHeaderFrames.Count == 0) + { + return; + } + + MethodHeaderFrame frame = _methodHeaderFrames.Peek(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + if (ReferenceEquals(frame.Owner, context)) + { + _methodHeaderFrames.Pop(); + } + } + + internal object CreateMethodAttribute(IToken token) + => token.Text switch + { + "static" => new AttributeValue(MethodAttributes.Static, 0, true), + "public" => new AttributeValue( + MethodAttributes.Public, + MethodAttributes.MemberAccessMask, + true), + "private" => new AttributeValue( + MethodAttributes.Private, + MethodAttributes.MemberAccessMask, + true), + "family" => new AttributeValue( + MethodAttributes.Family, + MethodAttributes.MemberAccessMask, + true), + "final" => new AttributeValue(MethodAttributes.Final, 0, true), + "specialname" => new AttributeValue(MethodAttributes.SpecialName, 0, true), + "virtual" => new AttributeValue(MethodAttributes.Virtual, 0, true), + "strict" => new AttributeValue( + MethodAttributes.CheckAccessOnOverride, + 0, + true), + "abstract" => new AttributeValue(MethodAttributes.Abstract, 0, true), + "assembly" => new AttributeValue( + MethodAttributes.Assembly, + MethodAttributes.MemberAccessMask, + true), + "famandassem" => new AttributeValue( + MethodAttributes.FamANDAssem, + MethodAttributes.MemberAccessMask, + true), + "famorassem" => new AttributeValue( + MethodAttributes.FamORAssem, + MethodAttributes.MemberAccessMask, + true), + "privatescope" => new AttributeValue( + MethodAttributes.PrivateScope, + MethodAttributes.MemberAccessMask, + true), + "hidebysig" => new AttributeValue(MethodAttributes.HideBySig, 0, true), + "newslot" => new AttributeValue(MethodAttributes.NewSlot, 0, true), + "rtspecialname" => new AttributeValue(MethodAttributes.RTSpecialName, 0, true), + "unmanagedexp" => new AttributeValue(MethodAttributes.UnmanagedExport, 0, true), + "reqsecobj" => new AttributeValue(MethodAttributes.RequireSecObject, 0, true), + _ => throw new UnreachableException(), + }; + + internal object CreateRawMethodAttribute(IToken token) + => new AttributeValue((MethodAttributes)ParseInt32(token), 0, false); + + internal object CreateMethodImplementationAttribute(IToken token) + => token.Text switch + { + "native" => new AttributeValue( + MethodImplAttributes.Native, + MethodImplAttributes.CodeTypeMask, + true), + "cil" or "il" => new AttributeValue( + MethodImplAttributes.IL, + MethodImplAttributes.CodeTypeMask, + true), + "optil" => new AttributeValue( + MethodImplAttributes.OPTIL, + MethodImplAttributes.CodeTypeMask, + true), + "managed" => new AttributeValue( + MethodImplAttributes.Managed, + MethodImplAttributes.ManagedMask, + true), + "unmanaged" => new AttributeValue( + MethodImplAttributes.Unmanaged, + MethodImplAttributes.ManagedMask, + true), + "forwardref" => new AttributeValue(MethodImplAttributes.ForwardRef, 0, true), + "preservesig" => new AttributeValue(MethodImplAttributes.PreserveSig, 0, true), + "runtime" => new AttributeValue( + MethodImplAttributes.Runtime, + MethodImplAttributes.CodeTypeMask, + true), + "internalcall" => new AttributeValue(MethodImplAttributes.InternalCall, 0, true), + "synchronized" => new AttributeValue(MethodImplAttributes.Synchronized, 0, true), + "noinlining" => new AttributeValue(MethodImplAttributes.NoInlining, 0, true), + "aggressiveinlining" => new AttributeValue( + MethodImplAttributes.AggressiveInlining, + 0, + true), + "nooptimization" => new AttributeValue(MethodImplAttributes.NoOptimization, 0, true), + "aggressiveoptimization" => new AttributeValue( + MethodImplAttributes.AggressiveOptimization, + 0, + true), + "async" => new AttributeValue(MethodImplAttributes.Async, 0, true), + _ => throw new UnreachableException(), + }; + + internal object CreateRawMethodImplementationAttribute(IToken token) + => new AttributeValue((MethodImplAttributes)ParseInt32(token), 0, false); + + internal void BeginPInvoke(CILParser.PinvImplContext context) + => _pInvokeFrames.Push(new(context)); + + internal void SetPInvokeModule(CILParser.PinvImplContext context, string moduleName) + { + if (TryGetPInvokeFrame(context) is { } frame) + { + frame.ModuleName = moduleName; + } + } + + internal void SetPInvokeEntryPoint(CILParser.PinvImplContext context, string entryPointName) + { + if (TryGetPInvokeFrame(context) is { } frame) + { + frame.EntryPointName = entryPointName; + } + } + + internal void AddPInvokeAttribute(CILParser.PinvImplContext context, object? value) + { + if (TryGetPInvokeFrame(context) is { } frame) + { + frame.Attributes = ApplyAttribute( + frame.Attributes, + GetAttributeValue(value)); + } + } + + internal object EndPInvoke(CILParser.PinvImplContext context) + { + if (_pInvokeFrames.Count == 0) + { + return new PInvokeValue(null, null, 0); + } + + PInvokeFrame frame = _pInvokeFrames.Peek(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + if (!ReferenceEquals(frame.Owner, context)) + { + return new PInvokeValue(null, null, 0); + } + + _pInvokeFrames.Pop(); + return new PInvokeValue(frame.ModuleName, frame.EntryPointName, frame.Attributes); + } + + internal object CreatePInvokeAttribute(IToken token) + => token.Text switch + { + "nomangle" => new AttributeValue( + MethodImportAttributes.ExactSpelling, + 0, + true), + "ansi" => new AttributeValue( + MethodImportAttributes.CharSetAnsi, + 0, + true), + "unicode" => new AttributeValue( + MethodImportAttributes.CharSetUnicode, + 0, + true), + "autochar" => new AttributeValue( + MethodImportAttributes.CharSetAuto, + 0, + true), + "lasterr" => new AttributeValue( + MethodImportAttributes.SetLastError, + 0, + true), + "winapi" => new AttributeValue( + MethodImportAttributes.CallingConventionWinApi, + 0, + true), + "cdecl" => new AttributeValue( + MethodImportAttributes.CallingConventionCDecl, + 0, + true), + "stdcall" => new AttributeValue( + MethodImportAttributes.CallingConventionStdCall, + 0, + true), + "thiscall" => new AttributeValue( + MethodImportAttributes.CallingConventionThisCall, + 0, + true), + "fastcall" => new AttributeValue( + MethodImportAttributes.CallingConventionFastCall, + 0, + true), + _ => throw new UnreachableException(), + }; + + internal object CreateBestFitPInvokeAttribute(IToken setting) + => new AttributeValue( + setting.Text == "on" + ? MethodImportAttributes.BestFitMappingEnable + : MethodImportAttributes.BestFitMappingDisable, + 0, + true); + + internal object CreateCharMapErrorPInvokeAttribute(IToken setting) + => new AttributeValue( + setting.Text == "on" + ? MethodImportAttributes.ThrowOnUnmappableCharEnable + : MethodImportAttributes.ThrowOnUnmappableCharDisable, + 0, + true); + + internal object CreateRawPInvokeAttribute(IToken token) + => new AttributeValue( + (MethodImportAttributes)ParseInt32(token), + 0, + false); + + internal void BeginGenericTypeList(CILParser.TypeListContext context) + => _genericTypeListFrames.Push(new(context)); + + internal void AddGenericType(CILParser.TypeListContext context, object? value) + { + if (TryGetGenericTypeListFrame(context) is { } frame) + { + frame.Types.Add(GetTypeSpecificationValue(value)); + } + } + + internal object EndGenericTypeList(CILParser.TypeListContext context) + { + if (_genericTypeListFrames.Count == 0) + { + return ImmutableArray.Empty; + } + + GenericTypeListFrame frame = _genericTypeListFrames.Peek(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + if (!ReferenceEquals(frame.Owner, context)) + { + return ImmutableArray.Empty; + } + + _genericTypeListFrames.Pop(); + return frame.Types.ToImmutable(); + } + + internal object CreateEmptyGenericParameterList() + => ImmutableArray.Empty; + + internal object CreateGenericParameterAttribute(IToken token) + => token.Text switch + { + "+" => new AttributeValue( + GenericParameterAttributes.Covariant, + 0, + true), + "-" => new AttributeValue( + GenericParameterAttributes.Contravariant, + 0, + true), + "class" => new AttributeValue( + GenericParameterAttributes.ReferenceTypeConstraint, + 0, + true), + "valuetype" => new AttributeValue( + GenericParameterAttributes.NotNullableValueTypeConstraint, + 0, + true), + "byreflike" => new AttributeValue( + GenericParameterAttributes.AllowByRefLike, + 0, + true), + ".ctor" => new AttributeValue( + GenericParameterAttributes.DefaultConstructorConstraint, + 0, + true), + _ => throw new UnreachableException(), + }; + + internal object CreateRawGenericParameterAttribute(IToken token) + => new AttributeValue( + (GenericParameterAttributes)ParseInt32(token), + 0, + true); + + internal void BeginGenericParameterAttributes(CILParser.TyparAttribsContext context) + => _genericParameterAttributesFrames.Push(new(context)); + + internal void AddGenericParameterAttribute(CILParser.TyparAttribsContext context, object? value) + { + if (TryGetGenericParameterAttributesFrame(context) is { } frame) + { + frame.Attributes = ApplyAttribute( + frame.Attributes, + GetAttributeValue(value)); + } + } + + internal object EndGenericParameterAttributes(CILParser.TyparAttribsContext context) + { + if (_genericParameterAttributesFrames.Count == 0) + { + return new AttributeValue(0, 0, true); + } + + GenericParameterAttributesFrame frame = _genericParameterAttributesFrames.Peek(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + if (!ReferenceEquals(frame.Owner, context)) + { + return new AttributeValue(0, 0, true); + } + + _genericParameterAttributesFrames.Pop(); + return new AttributeValue(frame.Attributes, 0, true); + } + + internal object CreateGenericParameterDeclaration( + object? attributes, + CILParser.TyBoundContext? constraints, + string name) + => new GenericParameterDeclarationValue( + GetAttributeValue(attributes).Value, + name, + constraints?.Value is ImmutableArray types ? types : []); + + internal void BeginGenericParameters(CILParser.TyparsContext context) + => _genericParametersFrames.Push(new(context)); + + internal void AddGenericParameter(CILParser.TyparsContext context, object? value) + { + if (TryGetGenericParametersFrame(context) is { } frame) + { + frame.Parameters.Add(GetGenericParameterDeclaration(value)); + } + } + + internal object EndGenericParameters(CILParser.TyparsContext context) + { + if (_genericParametersFrames.Count == 0) + { + return ImmutableArray.Empty; + } + + GenericParametersFrame frame = _genericParametersFrames.Peek(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + if (!ReferenceEquals(frame.Owner, context)) + { + return ImmutableArray.Empty; + } + + _genericParametersFrames.Pop(); + return frame.Parameters.ToImmutable(); + } + + private MethodHeaderFrame? TryGetMethodHeaderFrame(CILParser.MethodHeadContext context) + { + Debug.Assert(_methodHeaderFrames.Count > 0); + MethodHeaderFrame? frame = _methodHeaderFrames.Count == 0 ? null : _methodHeaderFrames.Peek(); + Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); + return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; + } + + private PInvokeFrame? TryGetPInvokeFrame(CILParser.PinvImplContext context) + { + Debug.Assert(_pInvokeFrames.Count > 0); + PInvokeFrame? frame = _pInvokeFrames.Count == 0 ? null : _pInvokeFrames.Peek(); + Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); + return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; + } + + private GenericTypeListFrame? TryGetGenericTypeListFrame(CILParser.TypeListContext context) + { + Debug.Assert(_genericTypeListFrames.Count > 0); + GenericTypeListFrame? frame = _genericTypeListFrames.Count == 0 ? null : _genericTypeListFrames.Peek(); + Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); + return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; + } + + private GenericParameterAttributesFrame? TryGetGenericParameterAttributesFrame( + CILParser.TyparAttribsContext context) + { + Debug.Assert(_genericParameterAttributesFrames.Count > 0); + GenericParameterAttributesFrame? frame = + _genericParameterAttributesFrames.Count == 0 ? null : _genericParameterAttributesFrames.Peek(); + Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); + return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; + } + + private GenericParametersFrame? TryGetGenericParametersFrame(CILParser.TyparsContext context) + { + Debug.Assert(_genericParametersFrames.Count > 0); + GenericParametersFrame? frame = + _genericParametersFrames.Count == 0 ? null : _genericParametersFrames.Peek(); + Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); + return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.Generics.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.Generics.cs new file mode 100644 index 00000000000000..1c8baa34d48c7b --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.Generics.cs @@ -0,0 +1,153 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Reflection; + +namespace ILAssembler; + +#pragma warning disable CA1822 // Visitor wrappers intentionally preserve the existing instance API. +internal sealed partial class GrammarActions +{ + private static void RegisterGenericParameterNames( + EntityRegistry.EntityBase owner, + NamedElementList parameters, + ImmutableArray declarations) + { + for (int i = 0; i < declarations.Length; i++) + { + GenericParameterDeclarationValue declaration = declarations[i]; + EntityRegistry.GenericParameterEntity parameter = + EntityRegistry.CreateGenericParameter(declaration.Attributes, declaration.Name); + parameter.Owner = owner; + parameter.Index = i; + parameters.Add(parameter); + } + } + private void MaterializeGenericParameterConstraints( + NamedElementList parameters, + List constraints, + ImmutableArray declarations) + { + Debug.Assert(parameters.Count >= declarations.Length); + int count = System.Math.Min(parameters.Count, declarations.Length); + for (int i = 0; i < count; i++) + { + EntityRegistry.GenericParameterEntity parameter = parameters[i]; + foreach (TypeSpecificationValue constraintType in declarations[i].Constraints) + { + EntityRegistry.GenericParameterConstraintEntity constraint = + EntityRegistry.CreateGenericConstraint(ResolveTypeSpecification(constraintType)); + constraint.Owner = parameter; + parameter.Constraints.Add(constraint); + constraints.Add(constraint); + } + } + } + + GrammarResult ICILVisitor.VisitTyBound(CILParser.TyBoundContext context) + => VisitTyBound(context); + + public GrammarResult.Sequence VisitTyBound( + CILParser.TyBoundContext? context) + { + if (context?.Value is not ImmutableArray constraintTypes) + { + return new([]); + } + + ImmutableArray.Builder constraints = + ImmutableArray.CreateBuilder( + constraintTypes.Length); + foreach (TypeSpecificationValue constraintType in constraintTypes) + { + constraints.Add( + EntityRegistry.CreateGenericConstraint(ResolveTypeSpecification(constraintType))); + } + + return new(constraints.MoveToImmutable()); + } + + GrammarResult ICILVisitor.VisitTypar(CILParser.TyparContext context) + => VisitTypar(context); + + public GrammarResult.Literal VisitTypar( + CILParser.TyparContext context) + { + GenericParameterDeclarationValue declaration = + GetGenericParameterDeclaration(context.Value); + EntityRegistry.GenericParameterEntity parameter = + EntityRegistry.CreateGenericParameter(declaration.Attributes, declaration.Name); + foreach (TypeSpecificationValue constraintType in declaration.Constraints) + { + parameter.Constraints.Add( + EntityRegistry.CreateGenericConstraint(ResolveTypeSpecification(constraintType))); + } + + return new(parameter); + } + + GrammarResult ICILVisitor.VisitTyparAttrib(CILParser.TyparAttribContext context) + => VisitTyparAttrib(context); + + public static GrammarResult.Flag VisitTyparAttrib( + CILParser.TyparAttribContext context) + { + AttributeValue attribute = + GetAttributeValue(context.Value); + return new(attribute.Value, attribute.ShouldAppend, attribute.GroupMask); + } + + GrammarResult ICILVisitor.VisitTyparAttribs(CILParser.TyparAttribsContext context) + => VisitTyparAttribs(context); + + public static GrammarResult.Literal VisitTyparAttribs( + CILParser.TyparAttribsContext context) + => new(GetAttributeValue(context.Value).Value); + + GrammarResult ICILVisitor.VisitTypars(CILParser.TyparsContext context) + => VisitTypars(context); + + public GrammarResult.Sequence VisitTypars( + CILParser.TyparsContext context) + { + ImmutableArray declarations = + GetGenericParameterDeclarations(context.Value); + ImmutableArray.Builder parameters = + ImmutableArray.CreateBuilder(declarations.Length); + foreach (GenericParameterDeclarationValue declaration in declarations) + { + EntityRegistry.GenericParameterEntity parameter = + EntityRegistry.CreateGenericParameter(declaration.Attributes, declaration.Name); + foreach (TypeSpecificationValue constraintType in declaration.Constraints) + { + parameter.Constraints.Add( + EntityRegistry.CreateGenericConstraint(ResolveTypeSpecification(constraintType))); + } + parameters.Add(parameter); + } + + return new(parameters.MoveToImmutable()); + } + + GrammarResult ICILVisitor.VisitTyparsClause(CILParser.TyparsClauseContext context) + => VisitTyparsClause(context); + + public GrammarResult.Sequence VisitTyparsClause( + CILParser.TyparsClauseContext context) + { + ImmutableArray declarations = + GetGenericParameterDeclarations(context.Value); + ImmutableArray.Builder parameters = + ImmutableArray.CreateBuilder(declarations.Length); + foreach (GenericParameterDeclarationValue declaration in declarations) + { + parameters.Add( + EntityRegistry.CreateGenericParameter(declaration.Attributes, declaration.Name)); + } + + return new(parameters.MoveToImmutable()); + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.Values.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.Values.cs new file mode 100644 index 00000000000000..243f5e4f36556e --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.Values.cs @@ -0,0 +1,80 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Immutable; +using System.Reflection; + +namespace ILAssembler; + +internal sealed partial class GrammarActions +{ + private sealed record AttributeValue(T Value, T GroupMask, bool ShouldAppend) + where T : struct, System.Enum; + + private sealed record PInvokeValue( + string? ModuleName, + string? EntryPointName, + MethodImportAttributes Attributes); + + private sealed record GenericParameterDeclarationValue( + GenericParameterAttributes Attributes, + string Name, + ImmutableArray Constraints); + + private sealed record MethodHeaderValue( + bool IsValid, + MethodAttributes Attributes, + ImmutableArray PInvokes, + byte CallingConvention, + int ReturnAttributes, + TypeValue ReturnType, + MarshallingDescriptorValue ReturnMarshalling, + string Name, + ImmutableArray GenericParameters, + ImmutableArray Arguments, + MethodImplAttributes ImplementationAttributes) + { + public static MethodHeaderValue Error { get; } = new( + false, + 0, + [], + 0, + 0, + TypeValue.Error, + GetMarshallingDescriptorValue(null), + string.Empty, + [], + [], + 0); + } + + private static AttributeValue GetAttributeValue(object? value) + where T : struct, System.Enum + => value as AttributeValue ?? new(default, default, true); + + private static T ApplyAttribute(T current, AttributeValue attribute) + where T : struct, System.Enum + { + if (!attribute.ShouldAppend) + { + return attribute.Value; + } + + int currentValue = System.Convert.ToInt32(current); + int groupMask = System.Convert.ToInt32(attribute.GroupMask); + int attributeValue = System.Convert.ToInt32(attribute.Value); + return (T)System.Enum.ToObject(typeof(T), (currentValue & ~groupMask) | attributeValue); + } + + private static ImmutableArray GetGenericParameterDeclarations(object? value) + => value is ImmutableArray parameters ? parameters : []; + + private static GenericParameterDeclarationValue GetGenericParameterDeclaration(object? value) + => value as GenericParameterDeclarationValue ?? new(0, string.Empty, []); + + private static MethodHeaderValue GetMethodHeaderValue(object? value) + => value as MethodHeaderValue ?? MethodHeaderValue.Error; + + private static PInvokeValue GetPInvokeValue(object? value) + => value as PInvokeValue ?? new(null, null, 0); +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.cs new file mode 100644 index 00000000000000..ce412f1a3b41d0 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.cs @@ -0,0 +1,219 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Immutable; +using System.Diagnostics; +using System.Reflection; +using System.Reflection.Metadata; + +namespace ILAssembler; + +internal sealed partial class GrammarActions +{ + internal void BeginMethod(CILParser.MethodHeadContext context, object? value) + { + MethodHeaderValue header = GetMethodHeaderValue(value); + ResetMethodBodyState(); + if (!header.IsValid) + { + return; + } + + EntityRegistry.TypeDefinitionEntity containingType = + _currentTypeDefinition.PeekOrDefault() ?? _entityRegistry.ModuleType; + EntityRegistry.MethodDefinitionEntity methodDefinition = + EntityRegistry.CreateUnrecordedMethodDefinition(containingType, header.Name); + + _currentMethod = new(methodDefinition); + try + { + RegisterGenericParameterNames( + methodDefinition, + methodDefinition.GenericParameters, + header.GenericParameters); + + methodDefinition.MethodAttributes = header.Attributes; + ApplyImplicitMethodAttributes(methodDefinition); + + if (methodDefinition.MethodAttributes.HasFlag(MethodAttributes.Abstract) && + !methodDefinition.ContainingType.Attributes.HasFlag(TypeAttributes.Abstract)) + { + ReportWarning( + DiagnosticIds.AbstractMethodNotInAbstractType, + string.Format( + DiagnosticMessageTemplates.AbstractMethodNotInAbstractType, + methodDefinition.Name), + context); + } + + ApplyPInvokeInformation(methodDefinition, header, context); + + byte signatureHeader = header.CallingConvention; + if (header.GenericParameters.Length != 0) + { + signatureHeader |= (byte)SignatureAttributes.Generic; + } + + SignatureHeader parsedHeader = new(signatureHeader); + if (!methodDefinition.MethodAttributes.HasFlag(MethodAttributes.Static) && + !parsedHeader.IsInstance && + _currentTypeDefinition.Count > 0) + { + signatureHeader |= (byte)SignatureAttributes.Instance; + parsedHeader = new(signatureHeader); + } + if (parsedHeader.HasExplicitThis && !parsedHeader.IsInstance) + { + signatureHeader |= (byte)SignatureAttributes.Instance; + parsedHeader = new(signatureHeader); + } + + BlobBuilder methodSignature = new(); + methodSignature.WriteByte(signatureHeader); + if (header.GenericParameters.Length != 0) + { + methodSignature.WriteCompressedInteger(header.GenericParameters.Length); + } + + MaterializeGenericParameterConstraints( + methodDefinition.GenericParameters, + methodDefinition.GenericParameterConstraints, + header.GenericParameters); + + ImmutableArray arguments = MaterializeSignatureArguments(header.Arguments); + methodSignature.WriteCompressedInteger(arguments.Length); + + SignatureArg returnValue = new( + (ParameterAttributes)header.ReturnAttributes, + MaterializeType(header.ReturnType), + MaterializeMarshallingDescriptor(header.ReturnMarshalling), + null); + returnValue.SignatureBlob.WriteContentTo(methodSignature); + methodDefinition.Parameters.Add( + EntityRegistry.CreateParameter( + returnValue.Attributes, + returnValue.Name, + returnValue.MarshallingDescriptor, + 0)); + + for (int i = 0; i < arguments.Length; i++) + { + SignatureArg argument = arguments[i]; + argument.SignatureBlob.WriteContentTo(methodSignature); + string? parameterName = argument.Name ?? $"A_{i}"; + methodDefinition.Parameters.Add( + EntityRegistry.CreateParameter( + argument.Attributes, + parameterName, + argument.MarshallingDescriptor, + i + 1)); + } + + methodDefinition.SignatureHeader = parsedHeader; + methodDefinition.MethodSignature = methodSignature; + methodDefinition.ImplementationAttributes = header.ImplementationAttributes; + + if (!EntityRegistry.TryAddMethodDefinitionToContainingType(methodDefinition)) + { + ReportError( + DiagnosticIds.DuplicateMethod, + DiagnosticMessageTemplates.DuplicateMethod, + context); + } + + _currentMethod = new(methodDefinition); + _methodOwner = context.Parent; + } + catch + { + _currentMethod = null; + _methodOwner = null; + ResetMethodBodyState(); + throw; + } + } + + private static void ApplyImplicitMethodAttributes(EntityRegistry.MethodDefinitionEntity method) + { + if (method.Name is ".ctor" or ".cctor") + { + method.MethodAttributes |= MethodAttributes.RTSpecialName | MethodAttributes.SpecialName; + } + else if (method.MethodAttributes.HasFlag(MethodAttributes.RTSpecialName)) + { + method.MethodAttributes |= MethodAttributes.SpecialName; + } + } + + private void ApplyPInvokeInformation( + EntityRegistry.MethodDefinitionEntity method, + MethodHeaderValue header, + CILParser.MethodHeadContext context) + { + (EntityRegistry.ModuleReferenceEntity Module, string? EntryPoint, MethodImportAttributes Attributes)? + pInvokeInformation = null; + + foreach (PInvokeValue pInvoke in header.PInvokes) + { + if (pInvoke.ModuleName is null) + { + ReportError( + DiagnosticIds.InvalidPInvokeSignature, + DiagnosticMessageTemplates.InvalidPInvokeSignature, + context); + continue; + } + + pInvokeInformation = ( + _entityRegistry.GetOrCreateModuleReference(pInvoke.ModuleName, _ => { }), + pInvoke.EntryPointName ?? header.Name, + pInvoke.Attributes); + } + + method.MethodImportInformation = pInvokeInformation; + } + + GrammarResult ICILVisitor.VisitImplAttr(CILParser.ImplAttrContext context) + => VisitImplAttr(context); + + public static GrammarResult.Flag VisitImplAttr(CILParser.ImplAttrContext context) + { + AttributeValue attribute = + GetAttributeValue(context.Value); + return new(attribute.Value, attribute.ShouldAppend, attribute.GroupMask); + } + + GrammarResult ICILVisitor.VisitMethAttr(CILParser.MethAttrContext context) + => VisitMethAttr(context); + + public static GrammarResult.Flag VisitMethAttr(CILParser.MethAttrContext context) + { + AttributeValue attribute = GetAttributeValue(context.Value); + return new(attribute.Value, attribute.ShouldAppend, attribute.GroupMask); + } + + GrammarResult ICILVisitor.VisitMethodHead(CILParser.MethodHeadContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitPinvAttr(CILParser.PinvAttrContext context) + => VisitPinvAttr(context); + + public static GrammarResult.Flag VisitPinvAttr(CILParser.PinvAttrContext context) + { + AttributeValue attribute = + GetAttributeValue(context.Value); + return new(attribute.Value, attribute.ShouldAppend, attribute.GroupMask); + } + + GrammarResult ICILVisitor.VisitPinvImpl(CILParser.PinvImplContext context) + => VisitPinvImpl(context); + + public static GrammarResult.Literal<( + string? ModuleName, + string? EntryPointName, + MethodImportAttributes Attributes)> VisitPinvImpl(CILParser.PinvImplContext context) + { + PInvokeValue value = GetPInvokeValue(context.Value); + return new((value.ModuleName, value.EntryPointName, value.Attributes)); + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.cs index 58204bbbaf52ba..a8c4b1ef766018 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.cs @@ -37,35 +37,6 @@ public static GrammarResult.Literal VisitCallConv(CILParser.CallConvContex public static GrammarResult.Literal VisitCallKind(CILParser.CallKindContext context) => new((SignatureCallingConvention)context.Value); - private BlobBuilder BuildMethodReferenceSignature( - CILParser.CallConvContext callConvention, - CILParser.TypeContext returnType, - CILParser.SigArgsContext signatureArguments, - int genericArity) - { - BlobBuilder signature = new(); - byte header = VisitCallConv(callConvention).Value; - if (genericArity > 0) - { - header |= (byte)SignatureAttributes.Generic; - } - signature.WriteByte(header); - if (genericArity > 0) - { - signature.WriteCompressedInteger(genericArity); - } - - ImmutableArray arguments = VisitSigArgs(signatureArguments).Value; - signature.WriteCompressedInteger(arguments.Count(argument => !argument.IsSentinel)); - VisitType(returnType).Value.WriteContentTo(signature); - foreach (SignatureArg argument in arguments) - { - argument.SignatureBlob.WriteContentTo(signature); - } - - return signature; - } - GrammarResult ICILVisitor.VisitElementType(CILParser.ElementTypeContext context) => VisitElementType(context); public GrammarResult.FormattedBlob VisitElementType(CILParser.ElementTypeContext context) @@ -93,49 +64,6 @@ GrammarResult ICILVisitor.VisitNativeUint(CILParser.NativeUintCon public GrammarResult.Literal VisitMethodRef(CILParser.MethodRefContext context) => new(MaterializeMethodReference(GetMethodReferenceValue(context.Value))); - private EntityRegistry.MemberReferenceEntity CreateExplicitMethodReference( - CILParser.CallConvContext callConv, - CILParser.TypeContext returnType, - CILParser.TypeSpecContext owner, - CILParser.MethodNameContext methodName, - CILParser.GenArityContext? genericArity, - CILParser.SigArgsContext parameterList) - => _entityRegistry.CreateLazilyRecordedMemberReference( - VisitTypeSpec(owner).Value, - VisitMethodName(methodName).Value, - CreateExplicitMethodSignature(callConv, returnType, genericArity, parameterList)); - - private BlobBuilder CreateExplicitMethodSignature( - CILParser.CallConvContext callConv, - CILParser.TypeContext returnType, - CILParser.GenArityContext? genericArity, - CILParser.SigArgsContext parameterList) - { - BlobBuilder signature = new(); - byte signatureHeader = VisitCallConv(callConv).Value; - int arity = genericArity is null ? 0 : VisitGenArity(genericArity).Value; - if (arity != 0) - { - signatureHeader |= (byte)SignatureAttributes.Generic; - } - - signature.WriteByte(signatureHeader); - if (arity != 0) - { - signature.WriteCompressedInteger(arity); - } - - ImmutableArray parameters = VisitSigArgs(parameterList).Value; - signature.WriteCompressedInteger(parameters.Count(parameter => !parameter.IsSentinel)); - VisitType(returnType).Value.WriteContentTo(signature); - foreach (SignatureArg parameter in parameters) - { - parameter.SignatureBlob.WriteContentTo(signature); - } - - return signature; - } - GrammarResult ICILVisitor.VisitParamAttr(CILParser.ParamAttrContext context) => VisitParamAttr(context); public static GrammarResult.Literal VisitParamAttr(CILParser.ParamAttrContext context) @@ -176,12 +104,13 @@ public GrammarResult.FormattedBlob VisitTypeArgs(CILParser.TypeArgsContext conte public GrammarResult.Sequence VisitTypeList(CILParser.TypeListContext context) { - CILParser.TypeSpecContext[] bounds = context.typeSpec(); + ImmutableArray bounds = + context.Value is ImmutableArray value ? value : []; ImmutableArray.Builder builder = ImmutableArray.CreateBuilder(bounds.Length); - foreach (CILParser.TypeSpecContext typeSpec in bounds) + foreach (TypeSpecificationValue typeSpec in bounds) { - builder.Add(VisitTypeSpec(typeSpec).Value); + builder.Add(ResolveTypeSpecification(typeSpec)); } return new(builder.MoveToImmutable()); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs index e924f7a5e92425..5951fa3c5ef5e4 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs @@ -66,11 +66,9 @@ internal void EndDeclaration(CILParser.DeclContext context) /// internal void EndClassDeclaration(CILParser.ClassDeclContext context) { + EndClassGenericDirective(context); + EndPropertyAndEventBodies(context); EndScopesOwnedBy(context); - if (context.classHead() is not null || context.methodHead() is not null) - { - ClearPendingCustomAttributeOwners(); - } } private void EndScopesOwnedBy(RuleContext owner) @@ -93,6 +91,7 @@ private void EndScopesOwnedBy(RuleContext owner) private void EndType() { + CompleteClassMethodOverrides(_currentTypeDefinition.Peek()); _typeOwners.Pop(); _currentTypeDefinition.Pop(); ClearPendingCustomAttributeOwners(); @@ -312,32 +311,20 @@ private void ClearPendingCustomAttributeOwners() }); - // Two-pass generic parameter processing: - // Pass 1: Register all parameter names (without resolving constraints) - var typarContexts = context.typarsClause()?.typars()?.typar() ?? Array.Empty(); - for (int i = 0; i < typarContexts.Length; i++) - { - var attributes = VisitTyparAttribs(typarContexts[i].typarAttribs()).Value; - var param = EntityRegistry.CreateGenericParameter(attributes, VisitDottedName(typarContexts[i].dottedName()).Value); - param.Owner = newTypeDef; - param.Index = i; - newTypeDef.GenericParameters.Add(param); - } + ImmutableArray genericParameters = + GetGenericParameterDeclarations(context.typarsClause().Value); + RegisterGenericParameterNames( + newTypeDef, + newTypeDef.GenericParameters, + genericParameters); // Push the type so that !T references in constraints, extends, and implements can resolve _currentTypeDefinition.Push(newTypeDef); - // Pass 2: Resolve constraints (now all params are registered and type is on stack) - for (int i = 0; i < typarContexts.Length; i++) - { - var param = newTypeDef.GenericParameters[i]; - foreach (var constraint in VisitTyBound(typarContexts[i].tyBound()).Value) - { - constraint.Owner = param; - param.Constraints.Add(constraint); - newTypeDef.GenericParameterConstraints.Add(constraint); - } - } + MaterializeGenericParameterConstraints( + newTypeDef.GenericParameters, + newTypeDef.GenericParameterConstraints, + genericParameters); if (context.extendsClause() is CILParser.ExtendsClauseContext extends) { @@ -396,34 +383,22 @@ private void ClearPendingCustomAttributeOwners() if (typeDefinition.GenericParameters.Count == 0) { - // Two-pass generic parameter processing for forward-referenced types - var typarContexts = context.typarsClause()?.typars()?.typar() ?? Array.Empty(); - for (int i = 0; i < typarContexts.Length; i++) - { - var attributes = VisitTyparAttribs(typarContexts[i].typarAttribs()).Value; - var param = EntityRegistry.CreateGenericParameter(attributes, VisitDottedName(typarContexts[i].dottedName()).Value); - param.Owner = typeDefinition; - param.Index = i; - typeDefinition.GenericParameters.Add(param); - } + ImmutableArray genericParameters = + GetGenericParameterDeclarations(context.typarsClause().Value); + RegisterGenericParameterNames( + typeDefinition, + typeDefinition.GenericParameters, + genericParameters); _currentTypeDefinition.Push(typeDefinition); - // Pass 2: Resolve constraints - for (int i = 0; i < typarContexts.Length; i++) - { - var param = typeDefinition.GenericParameters[i]; - foreach (var constraint in VisitTyBound(typarContexts[i].tyBound()).Value) - { - constraint.Owner = param; - param.Constraints.Add(constraint); - typeDefinition.GenericParameterConstraints.Add(constraint); - } - } + MaterializeGenericParameterConstraints( + typeDefinition.GenericParameters, + typeDefinition.GenericParameterConstraints, + genericParameters); } else { - _ = context.typarsClause().Accept(this); _currentTypeDefinition.Push(typeDefinition); } @@ -505,74 +480,5 @@ public GrammarResult.FormattedBlob VisitClassSeqElement(CILParser.ClassSeqElemen public static GrammarResult.String VisitNameSpaceHead(CILParser.NameSpaceHeadContext context) => VisitDottedName(context.dottedName()); - GrammarResult ICILVisitor.VisitTyBound(CILParser.TyBoundContext context) => VisitTyBound(context); - public GrammarResult.Sequence VisitTyBound(CILParser.TyBoundContext? context) - { - // context or typeList can be null when there are no constraints - if (context?.typeList() is not CILParser.TypeListContext typeList) - { - return new(ImmutableArray.Empty); - } - // Filter out null types (from unresolved type parameters) before creating constraints - return new(VisitTypeList(typeList).Value - .Where(t => t is not null) - .Select(EntityRegistry.CreateGenericConstraint) - .ToImmutableArray()); - } - - GrammarResult ICILVisitor.VisitTypar(CILParser.TyparContext context) => VisitTypar(context); - - public GrammarResult.Literal VisitTypar(CILParser.TyparContext context) - { - GenericParameterAttributes attributes = VisitTyparAttribs(context.typarAttribs()).Value; - EntityRegistry.GenericParameterEntity genericParameter = EntityRegistry.CreateGenericParameter(attributes, VisitDottedName(context.dottedName()).Value); - - foreach (var constraint in VisitTyBound(context.tyBound()).Value) - { - genericParameter.Constraints.Add(constraint); - } - - return new(genericParameter); - } - - GrammarResult ICILVisitor.VisitTyparAttrib(CILParser.TyparAttribContext context) => VisitTyparAttrib(context); - public GrammarResult.Flag VisitTyparAttrib(CILParser.TyparAttribContext context) - { - return context switch - { - { covariant: not null } => new(GenericParameterAttributes.Covariant), - { contravariant: not null } => new(GenericParameterAttributes.Contravariant), - { @class: not null } => new(GenericParameterAttributes.ReferenceTypeConstraint), - { valuetype: not null } => new(GenericParameterAttributes.NotNullableValueTypeConstraint), - { byrefLike: not null } => new(GenericParameterAttributes.AllowByRefLike), - { ctor: not null } => new(GenericParameterAttributes.DefaultConstructorConstraint), - { flags: CILParser.Int32Context int32 } => new((GenericParameterAttributes)VisitInt32(int32).Value), - _ => throw new UnreachableException() - }; - } - GrammarResult ICILVisitor.VisitTyparAttribs(CILParser.TyparAttribsContext context) => VisitTyparAttribs(context); - - public GrammarResult.Literal VisitTyparAttribs(CILParser.TyparAttribsContext context) => - new(context.typarAttrib() - .Select(VisitTyparAttrib) - .Aggregate( - (GenericParameterAttributes)0, (agg, attr) => agg | attr)); - - GrammarResult ICILVisitor.VisitTypars(CILParser.TyparsContext context) => VisitTypars(context); - public GrammarResult.Sequence VisitTypars(CILParser.TyparsContext context) - { - CILParser.TyparContext[] typeParameters = context.typar(); - ImmutableArray.Builder builder = ImmutableArray.CreateBuilder(typeParameters.Length); - - foreach (var typeParameter in typeParameters) - { - builder.Add(VisitTypar(typeParameter).Value); - } - return new(builder.MoveToImmutable()); - } - - GrammarResult ICILVisitor.VisitTyparsClause(CILParser.TyparsClauseContext context) => VisitTyparsClause(context); - public GrammarResult.Sequence VisitTyparsClause(CILParser.TyparsClauseContext context) => context.typars() is null ? new(ImmutableArray.Empty) : VisitTypars(context.typars()); - #pragma warning restore CA1822 // Mark members as static } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs index 8c08a019ffb02e..de91c1d9eec55c 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs @@ -37,7 +37,19 @@ _currentMethod is null && _parameterAttributesFrames.Count == 0 && _marshalBlobFrames.Count == 0 && _nativeTypeFrames.Count == 0 - && _variantTypeFrames.Count == 0, + && _variantTypeFrames.Count == 0 + && _methodHeaderFrames.Count == 0 + && _pInvokeFrames.Count == 0 + && _genericTypeListFrames.Count == 0 + && _genericParameterAttributesFrames.Count == 0 + && _genericParametersFrames.Count == 0 + && _fieldDeclarationFrames.Count == 0 + && _propertyHeaderFrames.Count == 0 + && _eventHeaderFrames.Count == 0 + && _propertyBodyFrames.Count == 0 + && _eventBodyFrames.Count == 0 + && _classGenericDirectiveFrames.Count == 0 + && _pendingClassMethodOverrides.Count == 0, "Per-document semantic state must be released by the owning rule's finally block."); EndMethod(); @@ -54,6 +66,18 @@ _currentMethod is null _marshalBlobFrames.Clear(); _nativeTypeFrames.Clear(); _variantTypeFrames.Clear(); + _methodHeaderFrames.Clear(); + _pInvokeFrames.Clear(); + _genericTypeListFrames.Clear(); + _genericParameterAttributesFrames.Clear(); + _genericParametersFrames.Clear(); + _fieldDeclarationFrames.Clear(); + _propertyHeaderFrames.Clear(); + _eventHeaderFrames.Clear(); + _propertyBodyFrames.Clear(); + _eventBodyFrames.Clear(); + _classGenericDirectiveFrames.Clear(); + _pendingClassMethodOverrides.Clear(); _syntaxErrorCount = 0; } } diff --git a/src/tools/ilasm/src/ILAssembler/EntityRegistry.cs b/src/tools/ilasm/src/ILAssembler/EntityRegistry.cs index f87536cfef6199..e765adddb2c262 100644 --- a/src/tools/ilasm/src/ILAssembler/EntityRegistry.cs +++ b/src/tools/ilasm/src/ILAssembler/EntityRegistry.cs @@ -572,7 +572,7 @@ public Blob WriteContentTo(MetadataBuilder builder, BlobBuilder ilStream, IReadO builder.AddEvent( evt.Attributes, builder.GetOrAddString(evt.Name), - evt.Type.Handle); + evt.Type?.Handle ?? default(TypeDefinitionHandle)); foreach (var accessor in evt.Accessors) { @@ -2174,10 +2174,10 @@ public sealed class InterfaceImplementationEntity(TypeDefinitionEntity type, Typ public TypeEntity InterfaceType { get; } = interfaceType; } - public sealed class EventEntity(EventAttributes attributes, TypeEntity type, string name) : EntityBase + public sealed class EventEntity(EventAttributes attributes, TypeEntity? type, string name) : EntityBase { public EventAttributes Attributes { get; set; } = attributes; - public TypeEntity Type { get; } = type; + public TypeEntity? Type { get; } = type; public string Name { get; } = name; public List<(MethodSemanticsAttributes Semantic, EntityBase Method)> Accessors { get; } = new(); diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 index c0f00bedf52b00..6367949684dbb3 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 @@ -542,17 +542,23 @@ typedefDecl: | '.typedef' customDescrWithOwner 'as' dottedName; /* Custom attribute declarations */ -customDescr: +customDescr returns [bool HasSyntaxError] +@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +: '.custom' customType | '.custom' customType '=' compQstring | '.custom' customType '=' '{' customBlobDescr '}' | '.custom' customType '=' '(' bytes ')'; +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} -customDescrWithOwner: +customDescrWithOwner returns [bool HasSyntaxError] +@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +: '.custom' '(' ownerType ')' customType | '.custom' '(' ownerType ')' customType '=' compQstring | '.custom' '(' ownerType ')' customType '=' '{' customBlobDescr '}' | '.custom' '(' ownerType ')' customType '=' '(' bytes ')'; +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} customType: methodRef; @@ -1154,26 +1160,51 @@ returns [object Value, bool HasSyntaxError] finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} /* Generic type parameters declaration */ -typeList: (typeSpec ',')* typeSpec; - -typarsClause: /* EMPTY */ | '<' typars '>'; +typeList returns [object Value] +@init {Actions.BeginGenericTypeList(_localctx);} +: + (item = typeSpec {Actions.AddGenericType(_localctx, $item.Value);} ',')* + tail = typeSpec {Actions.AddGenericType(_localctx, $tail.Value);} +; +finally {_localctx.Value = Actions.EndGenericTypeList(_localctx);} -typarAttrib: - covariant = PLUS - | contravariant = '-' - | class = 'class' - | valuetype = VALUETYPE - | byrefLike = 'byreflike' - | ctor = '.ctor' - | 'flags' '(' flags = int32 ')'; +typarsClause returns [object Value] +@init {_localctx.Value = Actions.CreateEmptyGenericParameterList();} +: + /* EMPTY */ + | '<' parameters = typars '>' {_localctx.Value = $parameters.Value;} +; -typarAttribs: typarAttrib*; +typarAttrib returns [object Value]: + covariant = PLUS {_localctx.Value = Actions.CreateGenericParameterAttribute($covariant);} + | contravariant = '-' {_localctx.Value = Actions.CreateGenericParameterAttribute($contravariant);} + | class = 'class' {_localctx.Value = Actions.CreateGenericParameterAttribute($class);} + | valuetype = VALUETYPE {_localctx.Value = Actions.CreateGenericParameterAttribute($valuetype);} + | byrefLike = 'byreflike' {_localctx.Value = Actions.CreateGenericParameterAttribute($byrefLike);} + | ctor = '.ctor' {_localctx.Value = Actions.CreateGenericParameterAttribute($ctor);} + | 'flags' '(' flags = int32 ')' {_localctx.Value = Actions.CreateRawGenericParameterAttribute($flags.start);}; + +typarAttribs returns [object Value] +@init {Actions.BeginGenericParameterAttributes(_localctx);} +: + (attribute = typarAttrib {Actions.AddGenericParameterAttribute(_localctx, $attribute.Value);})* +; +finally {_localctx.Value = Actions.EndGenericParameterAttributes(_localctx);} -typar: typarAttribs tyBound? dottedName; +typar returns [object Value]: + attributes = typarAttribs constraints = tyBound? name = dottedName + {_localctx.Value = Actions.CreateGenericParameterDeclaration($attributes.Value, $constraints.ctx, $name.Value);}; -typars: (typar ',')* typar; +typars returns [object Value] +@init {Actions.BeginGenericParameters(_localctx);} +: + (parameter = typar {Actions.AddGenericParameter(_localctx, $parameter.Value);} ',')* + tail = typar {Actions.AddGenericParameter(_localctx, $tail.Value);} +; +finally {_localctx.Value = Actions.EndGenericParameters(_localctx);} -tyBound: '(' typeList ')'; +tyBound returns [object Value]: + '(' constraints = typeList ')' {_localctx.Value = $constraints.Value;}; genArity returns [int Value]: value = genArityNotEmpty? {_localctx.Value = Actions.GetGenericArity($value.ctx);}; @@ -1183,104 +1214,188 @@ genArityNotEmpty returns [int Value]: /* Class body declarations */ classDecl -@init {BeginSubtree();} -@after {Actions.OnClassDeclaration(_localctx);} +@init {BeginStreaming();} : methodHead '{' methodDecls '}' | classHead '{' classDecls '}' - | eventHead '{' eventDecls '}' - | propHead '{' propDecls '}' + | eventHeader = eventHead {Actions.BeginEvent(_localctx, $eventHeader.Value);} '{' eventDecls '}' + | property = propHead {Actions.BeginProperty(_localctx, $property.Value);} '{' propDecls '}' | fieldDecl - | dataDecl - | secDecl - | extSourceSpec - | customAttrDecl - | '.size' int32 - | '.pack' int32 - | exportHead '{' exptypeDecls '}' - | OVERRIDE typeSpec '::' methodName 'with' callConv type typeSpec '::' methodName sigArgs - | OVERRIDE 'method' callConv type typeSpec '::' methodName genArity sigArgs 'with' 'method' - callConv type typeSpec '::' methodName genArity sigArgs - | languageDecl - | compControl - | PARAM TYPE '[' int32 ']' customAttrDecl* - | PARAM TYPE dottedName customAttrDecl* - | PARAM CONSTRAINT '[' int32 ']' ',' typeSpec customAttrDecl* - | PARAM CONSTRAINT dottedName ',' typeSpec customAttrDecl* - | '.interfaceimpl' TYPE typeSpec customDescr; + | data = dataDecl {Actions.ProcessClassDataDeclaration($data.ctx);} + | security = secDecl {Actions.ProcessClassSecurityDeclaration($security.ctx);} + | source = extSourceSpec {Actions.ProcessClassSourceDirective($source.ctx);} + | attribute = customAttrDecl {Actions.ProcessClassCustomAttribute($attribute.ctx);} + | '.size' size = int32 {Actions.SetClassSize($size.start);} + | '.pack' packing = int32 {Actions.SetClassPackingSize($packing.start);} + | export = exportHead '{' exportDeclarations = exptypeDecls '}' + {Actions.ProcessClassExport($export.ctx, $exportDeclarations.ctx);} + | OVERRIDE declarationOwner = typeSpec '::' declarationName = methodName 'with' + bodyConvention = callConv bodyReturnType = type bodyOwner = typeSpec '::' + bodyName = methodName bodyArguments = sigArgs + {Actions.AddClassMethodOverride( + _localctx, + $declarationOwner.Value, + $declarationName.Value, + $bodyConvention.Value, + $bodyReturnType.Value, + $bodyOwner.Value, + $bodyName.Value, + $bodyArguments.Value);} + | OVERRIDE 'method' + declarationConvention = callConv declarationReturnType = type declarationOwner = typeSpec '::' + declarationName = methodName declarationArity = genArity declarationArguments = sigArgs + 'with' 'method' + bodyConvention = callConv bodyReturnType = type bodyOwner = typeSpec '::' + bodyName = methodName bodyArity = genArity bodyArguments = sigArgs + {Actions.AddClassMethodOverride( + _localctx, + $declarationConvention.Value, + $declarationReturnType.Value, + $declarationOwner.Value, + $declarationName.Value, + $declarationArity.Value, + $declarationArguments.Value, + $bodyConvention.Value, + $bodyReturnType.Value, + $bodyOwner.Value, + $bodyName.Value, + $bodyArity.Value, + $bodyArguments.Value);} + | language = languageDecl {Actions.ProcessClassLanguageDirective($language.ctx);} + | compControl {Actions.ProcessClassCompilerControl();} + | PARAM TYPE '[' parameterIndex = int32 ']' + {Actions.BeginClassGenericParameterDirective(_localctx, $parameterIndex.start);} + (attribute = customAttrDecl {Actions.AddClassGenericDirectiveAttribute(_localctx, $attribute.ctx);})* + | PARAM TYPE parameterName = dottedName + {Actions.BeginClassGenericParameterDirective(_localctx, $parameterName.Value);} + (attribute = customAttrDecl {Actions.AddClassGenericDirectiveAttribute(_localctx, $attribute.ctx);})* + | PARAM CONSTRAINT '[' parameterIndex = int32 ']' ',' constraintType = typeSpec + {Actions.BeginClassGenericConstraintDirective(_localctx, $parameterIndex.start, $constraintType.Value);} + (attribute = customAttrDecl {Actions.AddClassGenericDirectiveAttribute(_localctx, $attribute.ctx);})* + | PARAM CONSTRAINT parameterName = dottedName ',' constraintType = typeSpec + {Actions.BeginClassGenericConstraintDirective(_localctx, $parameterName.Value, $constraintType.Value);} + (attribute = customAttrDecl {Actions.AddClassGenericDirectiveAttribute(_localctx, $attribute.ctx);})* + | '.interfaceimpl' TYPE interfaceType = typeSpec interfaceAttribute = customDescr + {Actions.AddInterfaceImplementationAttribute(_localctx, $interfaceType.Value, $interfaceAttribute.ctx);} +; finally {EndParseTreeMode(); Actions.EndClassDeclaration(_localctx);} /* Field declaration */ -fieldDecl: - '.field' repeatOpt (fieldAttr | 'marshal' '(' marshalBlob ')')* type dottedName atOpt initOpt; - -fieldAttr: - 'static' - | 'public' - | 'private' - | 'family' - | 'initonly' - | 'rtspecialname' - | 'specialname' - | 'assembly' - | 'famandassem' - | 'famorassem' - | 'privatescope' - | 'literal' - | 'notserialized' - | 'volatile' - | 'flags' '(' int32 ')'; - -atOpt: /* EMPTY */ | 'at' id | 'at' int32; +fieldDecl returns [object Value] +@init {BeginStreaming(); Actions.BeginFieldDeclaration(_localctx);} +@after {Actions.DefineField(_localctx, _localctx.Value);} +: + '.field' offset = repeatOpt + ( + attribute = fieldAttr {Actions.AddFieldAttribute(_localctx, $attribute.Value);} + | 'marshal' '(' marshalling = marshalBlob ')' {Actions.SetFieldMarshalling(_localctx, $marshalling.Value);} + )* + fieldType = type name = dottedName data = atOpt initializer = initOpt + {_localctx.Value = Actions.CreateFieldDeclaration( + _localctx, + $offset.ctx, + $fieldType.Value, + $name.Value, + $data.Value, + $initializer.Value);} +; +finally {Actions.EndFieldDeclaration(_localctx); EndParseTreeMode();} + +fieldAttr returns [object Value]: + attribute = 'static' {_localctx.Value = Actions.CreateFieldAttribute($attribute);} + | attribute = 'public' {_localctx.Value = Actions.CreateFieldAttribute($attribute);} + | attribute = 'private' {_localctx.Value = Actions.CreateFieldAttribute($attribute);} + | attribute = 'family' {_localctx.Value = Actions.CreateFieldAttribute($attribute);} + | attribute = 'initonly' {_localctx.Value = Actions.CreateFieldAttribute($attribute);} + | attribute = 'rtspecialname' {_localctx.Value = Actions.CreateFieldAttribute($attribute);} + | attribute = 'specialname' {_localctx.Value = Actions.CreateFieldAttribute($attribute);} + | attribute = 'assembly' {_localctx.Value = Actions.CreateFieldAttribute($attribute);} + | attribute = 'famandassem' {_localctx.Value = Actions.CreateFieldAttribute($attribute);} + | attribute = 'famorassem' {_localctx.Value = Actions.CreateFieldAttribute($attribute);} + | attribute = 'privatescope' {_localctx.Value = Actions.CreateFieldAttribute($attribute);} + | attribute = 'literal' {_localctx.Value = Actions.CreateFieldAttribute($attribute);} + | attribute = 'notserialized' {_localctx.Value = Actions.CreateFieldAttribute($attribute);} + | attribute = 'volatile' {_localctx.Value = Actions.CreateFieldAttribute($attribute);} + | 'flags' '(' flags = int32 ')' {_localctx.Value = Actions.CreateRawFieldAttribute($flags.start);}; + +atOpt returns [string Value]: + /* EMPTY */ + | 'at' name = id {_localctx.Value = Actions.GetFieldDataName($name.start);} + | 'at' offset = int32 {_localctx.Value = Actions.GetFieldDataOffset($offset.start);}; -initOpt returns [bool HasSyntaxError] -@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +initOpt returns [object Value, bool HasSyntaxError] +@init {BeginSubtree(); Actions.BeginFieldInitializer(_localctx);} : /* EMPTY */ - | '=' fieldInit + | '=' initializer = fieldInit {Actions.SetFieldInitializer(_localctx, $initializer.ctx);} ; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} +finally {_localctx.HasSyntaxError = Actions.EndFieldInitializer(_localctx); EndParseTreeMode();} -repeatOpt: /* EMPTY */ | '[' int32 ']'; +repeatOpt returns [int Value, bool HasValue]: + /* EMPTY */ + | '[' offset = int32 ']' {Actions.SetFieldOffset(_localctx, $offset.start);}; /* Event declaration */ -eventHead: - '.event' eventAttr* typeSpec dottedName - | '.event' eventAttr* dottedName; +eventHead returns [object Value] +@init {Actions.BeginEventHeader(_localctx);} +: + '.event' + (attribute = eventAttr {Actions.AddEventAttribute(_localctx, $attribute.Value);})* + eventType = typeSpec name = dottedName + {_localctx.Value = Actions.CreateEventHeader(_localctx, $eventType.Value, $name.Value);} + | '.event' + (attribute = eventAttr {Actions.AddEventAttribute(_localctx, $attribute.Value);})* + name = dottedName + {_localctx.Value = Actions.CreateEventHeader(_localctx, null, $name.Value);} +; +finally {Actions.EndEventHeader(_localctx);} -eventAttr: - 'rtspecialname' - | 'specialname'; +eventAttr returns [object Value]: + attribute = 'rtspecialname' {_localctx.Value = Actions.CreateEventAttribute($attribute);} + | attribute = 'specialname' {_localctx.Value = Actions.CreateEventAttribute($attribute);}; eventDecls: eventDecl*; eventDecl: - '.addon' methodRef - | '.removeon' methodRef - | '.fire' methodRef - | '.other' methodRef - | extSourceSpec - | customAttrDecl - | languageDecl + '.addon' accessor = methodRef {Actions.AddEventAdder(_localctx, $accessor.Value);} + | '.removeon' accessor = methodRef {Actions.AddEventRemover(_localctx, $accessor.Value);} + | '.fire' accessor = methodRef {Actions.AddEventRaiser(_localctx, $accessor.Value);} + | '.other' accessor = methodRef {Actions.AddEventOther(_localctx, $accessor.Value);} + | source = extSourceSpec {Actions.ProcessEventSourceDirective($source.ctx);} + | attribute = customAttrDecl {Actions.AddEventCustomAttribute(_localctx, $attribute.ctx);} + | language = languageDecl {Actions.ProcessEventLanguageDirective($language.ctx);} | compControl; /* Property declaration */ -propHead: - '.property' propAttr* callConv type dottedName sigArgs initOpt; +propHead returns [object Value] +@init {Actions.BeginPropertyHeader(_localctx);} +: + '.property' + (attribute = propAttr {Actions.AddPropertyAttribute(_localctx, $attribute.Value);})* + convention = callConv propertyType = type name = dottedName arguments = sigArgs initializer = initOpt + {_localctx.Value = Actions.CreatePropertyHeader( + _localctx, + $convention.Value, + $propertyType.Value, + $name.Value, + $arguments.Value, + $initializer.Value);} +; +finally {Actions.EndPropertyHeader(_localctx);} -propAttr: - 'rtspecialname' - | 'specialname'; +propAttr returns [object Value]: + attribute = 'rtspecialname' {_localctx.Value = Actions.CreatePropertyAttribute($attribute);} + | attribute = 'specialname' {_localctx.Value = Actions.CreatePropertyAttribute($attribute);}; propDecls: propDecl*; propDecl: - '.set' methodRef - | '.get' methodRef - | '.other' methodRef - | customAttrDecl - | extSourceSpec - | languageDecl + '.set' accessor = methodRef {Actions.AddPropertySetter(_localctx, $accessor.Value);} + | '.get' accessor = methodRef {Actions.AddPropertyGetter(_localctx, $accessor.Value);} + | '.other' accessor = methodRef {Actions.AddPropertyOther(_localctx, $accessor.Value);} + | attribute = customAttrDecl {Actions.AddPropertyCustomAttribute(_localctx, $attribute.ctx);} + | source = extSourceSpec {Actions.ProcessPropertySourceDirective($source.ctx);} + | language = languageDecl {Actions.ProcessPropertyLanguageDirective($language.ctx);} | compControl; /* Method declaration */ @@ -1312,75 +1427,103 @@ paramAttrElement returns [int Value, bool ShouldAppend]: | '[' raw = int32 ']' {Actions.SetRawParameterAttributeElement(_localctx, $raw.start);}; methodHead -@init {BeginSubtree();} -@after {Actions.BeginMethod(_localctx);} +returns [object Value] +@init {BeginStreaming(); Actions.BeginMethodHeader(_localctx);} +@after {Actions.BeginMethod(_localctx, _localctx.Value);} : - '.method' (methAttr | pinvImpl)* callConv paramAttr type marshalClause methodName typarsClause sigArgs - implAttr*; -finally {EndParseTreeMode();} - -methAttr: 'static' - | 'public' - | 'private' - | 'family' - | 'final' - | 'specialname' - | 'virtual' - | 'strict' - | 'abstract' - | 'assembly' - | 'famandassem' - | 'famorassem' - | 'privatescope' - | 'hidebysig' - | 'newslot' - | 'rtspecialname' - | 'unmanagedexp' - | 'reqsecobj' - | 'flags' '(' int32 ')'; - -pinvImpl: 'pinvokeimpl' '(' (compQstring ('as' compQstring)?)? pinvAttr* ')' | 'pinvokeimpl' '()'; - -pinvAttr: - 'nomangle' - | 'ansi' - | 'unicode' - | 'autochar' - | 'lasterr' - | 'winapi' - | 'cdecl' - | 'stdcall' - | 'thiscall' - | 'fastcall' - | 'bestfit' ':' 'on' - | 'bestfit' ':' 'off' - | 'charmaperror' ':' 'on' - | 'charmaperror' ':' 'off' - | 'flags' '(' int32 ')'; + '.method' + ( + attribute = methAttr {Actions.AddMethodAttribute(_localctx, $attribute.Value);} + | pInvoke = pinvImpl {Actions.AddPInvoke(_localctx, $pInvoke.Value);} + )* + convention = callConv returnAttributes = paramAttr returnType = type returnMarshalling = marshalClause + name = methodName genericParameters = typarsClause arguments = sigArgs + (implementation = implAttr {Actions.AddMethodImplementationAttribute(_localctx, $implementation.Value);})* + {_localctx.Value = Actions.CreateMethodHeader( + _localctx, + $convention.Value, + $returnAttributes.Value, + $returnType.Value, + $returnMarshalling.Value, + $name.Value, + $genericParameters.Value, + $arguments.Value);} +; +finally {Actions.EndMethodHeader(_localctx); EndParseTreeMode();} + +methAttr returns [object Value]: + attribute = 'static' {_localctx.Value = Actions.CreateMethodAttribute($attribute);} + | attribute = 'public' {_localctx.Value = Actions.CreateMethodAttribute($attribute);} + | attribute = 'private' {_localctx.Value = Actions.CreateMethodAttribute($attribute);} + | attribute = 'family' {_localctx.Value = Actions.CreateMethodAttribute($attribute);} + | attribute = 'final' {_localctx.Value = Actions.CreateMethodAttribute($attribute);} + | attribute = 'specialname' {_localctx.Value = Actions.CreateMethodAttribute($attribute);} + | attribute = 'virtual' {_localctx.Value = Actions.CreateMethodAttribute($attribute);} + | attribute = 'strict' {_localctx.Value = Actions.CreateMethodAttribute($attribute);} + | attribute = 'abstract' {_localctx.Value = Actions.CreateMethodAttribute($attribute);} + | attribute = 'assembly' {_localctx.Value = Actions.CreateMethodAttribute($attribute);} + | attribute = 'famandassem' {_localctx.Value = Actions.CreateMethodAttribute($attribute);} + | attribute = 'famorassem' {_localctx.Value = Actions.CreateMethodAttribute($attribute);} + | attribute = 'privatescope' {_localctx.Value = Actions.CreateMethodAttribute($attribute);} + | attribute = 'hidebysig' {_localctx.Value = Actions.CreateMethodAttribute($attribute);} + | attribute = 'newslot' {_localctx.Value = Actions.CreateMethodAttribute($attribute);} + | attribute = 'rtspecialname' {_localctx.Value = Actions.CreateMethodAttribute($attribute);} + | attribute = 'unmanagedexp' {_localctx.Value = Actions.CreateMethodAttribute($attribute);} + | attribute = 'reqsecobj' {_localctx.Value = Actions.CreateMethodAttribute($attribute);} + | 'flags' '(' flags = int32 ')' {_localctx.Value = Actions.CreateRawMethodAttribute($flags.start);}; + +pinvImpl returns [object Value] +@init {Actions.BeginPInvoke(_localctx);} +: + 'pinvokeimpl' '(' + (module = compQstring {Actions.SetPInvokeModule(_localctx, $module.Value);} + ('as' entryPoint = compQstring {Actions.SetPInvokeEntryPoint(_localctx, $entryPoint.Value);})?)? + (attribute = pinvAttr {Actions.AddPInvokeAttribute(_localctx, $attribute.Value);})* + ')' + | 'pinvokeimpl' '()' +; +finally {_localctx.Value = Actions.EndPInvoke(_localctx);} + +pinvAttr returns [object Value]: + attribute = 'nomangle' {_localctx.Value = Actions.CreatePInvokeAttribute($attribute);} + | attribute = 'ansi' {_localctx.Value = Actions.CreatePInvokeAttribute($attribute);} + | attribute = 'unicode' {_localctx.Value = Actions.CreatePInvokeAttribute($attribute);} + | attribute = 'autochar' {_localctx.Value = Actions.CreatePInvokeAttribute($attribute);} + | attribute = 'lasterr' {_localctx.Value = Actions.CreatePInvokeAttribute($attribute);} + | attribute = 'winapi' {_localctx.Value = Actions.CreatePInvokeAttribute($attribute);} + | attribute = 'cdecl' {_localctx.Value = Actions.CreatePInvokeAttribute($attribute);} + | attribute = 'stdcall' {_localctx.Value = Actions.CreatePInvokeAttribute($attribute);} + | attribute = 'thiscall' {_localctx.Value = Actions.CreatePInvokeAttribute($attribute);} + | attribute = 'fastcall' {_localctx.Value = Actions.CreatePInvokeAttribute($attribute);} + | 'bestfit' ':' setting = 'on' {_localctx.Value = Actions.CreateBestFitPInvokeAttribute($setting);} + | 'bestfit' ':' setting = 'off' {_localctx.Value = Actions.CreateBestFitPInvokeAttribute($setting);} + | 'charmaperror' ':' setting = 'on' {_localctx.Value = Actions.CreateCharMapErrorPInvokeAttribute($setting);} + | 'charmaperror' ':' setting = 'off' {_localctx.Value = Actions.CreateCharMapErrorPInvokeAttribute($setting);} + | 'flags' '(' flags = int32 ')' {_localctx.Value = Actions.CreateRawPInvokeAttribute($flags.start);}; methodName returns [string Value]: ctorName = '.ctor' {_localctx.Value = Actions.GetMethodName($ctorName);} | cctorName = '.cctor' {_localctx.Value = Actions.GetMethodName($cctorName);} | dotted = dottedName {_localctx.Value = $dotted.Value;}; -implAttr: - 'native' - | 'cil' - | 'il' - | 'optil' - | 'managed' - | 'unmanaged' - | 'forwardref' - | 'preservesig' - | 'runtime' - | 'internalcall' - | 'synchronized' - | 'noinlining' - | 'aggressiveinlining' - | 'nooptimization' - | 'aggressiveoptimization' - | 'async' - | 'flags' '(' int32 ')'; +implAttr returns [object Value]: + attribute = 'native' {_localctx.Value = Actions.CreateMethodImplementationAttribute($attribute);} + | attribute = 'cil' {_localctx.Value = Actions.CreateMethodImplementationAttribute($attribute);} + | attribute = 'il' {_localctx.Value = Actions.CreateMethodImplementationAttribute($attribute);} + | attribute = 'optil' {_localctx.Value = Actions.CreateMethodImplementationAttribute($attribute);} + | attribute = 'managed' {_localctx.Value = Actions.CreateMethodImplementationAttribute($attribute);} + | attribute = 'unmanaged' {_localctx.Value = Actions.CreateMethodImplementationAttribute($attribute);} + | attribute = 'forwardref' {_localctx.Value = Actions.CreateMethodImplementationAttribute($attribute);} + | attribute = 'preservesig' {_localctx.Value = Actions.CreateMethodImplementationAttribute($attribute);} + | attribute = 'runtime' {_localctx.Value = Actions.CreateMethodImplementationAttribute($attribute);} + | attribute = 'internalcall' {_localctx.Value = Actions.CreateMethodImplementationAttribute($attribute);} + | attribute = 'synchronized' {_localctx.Value = Actions.CreateMethodImplementationAttribute($attribute);} + | attribute = 'noinlining' {_localctx.Value = Actions.CreateMethodImplementationAttribute($attribute);} + | attribute = 'aggressiveinlining' {_localctx.Value = Actions.CreateMethodImplementationAttribute($attribute);} + | attribute = 'nooptimization' {_localctx.Value = Actions.CreateMethodImplementationAttribute($attribute);} + | attribute = 'aggressiveoptimization' {_localctx.Value = Actions.CreateMethodImplementationAttribute($attribute);} + | attribute = 'async' {_localctx.Value = Actions.CreateMethodImplementationAttribute($attribute);} + | 'flags' '(' flags = int32 ')' {_localctx.Value = Actions.CreateRawMethodImplementationAttribute($flags.start);}; EMITBYTE: '.emitbyte'; MAXSTACK: '.maxstack'; diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.interp b/src/tools/ilasm/src/ILAssembler/gen/CIL.interp index f7a660cf76e050..4929987f5e3fb1 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.interp +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.interp @@ -797,4 +797,4 @@ manifestResDecl atn: -[4, 1, 305, 3267, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 367, 8, 1, 10, 1, 12, 1, 370, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 377, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 5, 3, 384, 8, 3, 10, 3, 12, 3, 387, 9, 3, 1, 3, 1, 3, 1, 3, 1, 4, 5, 4, 393, 8, 4, 10, 4, 12, 4, 396, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 448, 8, 5, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 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, 489, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 5, 15, 496, 8, 15, 10, 15, 12, 15, 499, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 528, 8, 18, 1, 19, 1, 19, 3, 19, 532, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 550, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 577, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 600, 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, 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, 636, 8, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 646, 8, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 5, 27, 653, 8, 27, 10, 27, 12, 27, 656, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 665, 8, 28, 10, 28, 12, 28, 668, 9, 28, 1, 29, 1, 29, 1, 30, 1, 30, 3, 30, 674, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 685, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 693, 8, 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, 34, 1, 34, 1, 34, 1, 34, 5, 34, 714, 8, 34, 10, 34, 12, 34, 717, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 5, 37, 730, 8, 37, 10, 37, 12, 37, 733, 9, 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, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 777, 8, 38, 1, 39, 1, 39, 1, 39, 3, 39, 782, 8, 39, 1, 40, 1, 40, 1, 40, 3, 40, 787, 8, 40, 1, 41, 5, 41, 790, 8, 41, 10, 41, 12, 41, 793, 9, 41, 1, 42, 1, 42, 1, 42, 5, 42, 798, 8, 42, 10, 42, 12, 42, 801, 9, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 910, 8, 44, 1, 45, 1, 45, 5, 45, 914, 8, 45, 10, 45, 12, 45, 917, 9, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 930, 8, 45, 10, 45, 12, 45, 933, 9, 45, 1, 45, 1, 45, 1, 45, 3, 45, 938, 8, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 944, 8, 47, 1, 48, 1, 48, 1, 49, 5, 49, 949, 8, 49, 10, 49, 12, 49, 952, 9, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 979, 8, 50, 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, 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, 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, 1057, 8, 51, 3, 51, 1059, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1073, 8, 53, 1, 53, 1, 53, 5, 53, 1077, 8, 53, 10, 53, 12, 53, 1080, 9, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1088, 8, 53, 3, 53, 1090, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1097, 8, 54, 10, 54, 12, 54, 1100, 9, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1111, 8, 55, 10, 55, 12, 55, 1114, 9, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 5, 56, 1125, 8, 56, 10, 56, 12, 56, 1128, 9, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1135, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 1143, 8, 57, 1, 57, 1, 57, 3, 57, 1147, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1186, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 1192, 8, 59, 10, 59, 12, 59, 1195, 9, 59, 1, 59, 1, 59, 1, 59, 1, 60, 5, 60, 1201, 8, 60, 10, 60, 12, 60, 1204, 9, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1211, 8, 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, 3, 62, 1230, 8, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 5, 63, 1238, 8, 63, 10, 63, 12, 63, 1241, 9, 63, 3, 63, 1243, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 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, 1267, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1414, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1424, 8, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 5, 67, 1431, 8, 67, 10, 67, 12, 67, 1434, 9, 67, 3, 67, 1436, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1518, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 5, 69, 1525, 8, 69, 10, 69, 12, 69, 1528, 9, 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, 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, 1559, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1619, 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, 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, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1659, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1675, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1685, 8, 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, 3, 76, 1712, 8, 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, 1736, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 5, 77, 1742, 8, 77, 10, 77, 12, 77, 1745, 9, 77, 1, 77, 3, 77, 1748, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1763, 8, 78, 1, 79, 1, 79, 1, 79, 5, 79, 1768, 8, 79, 10, 79, 12, 79, 1771, 9, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1815, 8, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1825, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1843, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1861, 8, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1880, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1901, 8, 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, 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 1920, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1935, 8, 89, 1, 90, 1, 90, 1, 90, 5, 90, 1940, 8, 90, 10, 90, 12, 90, 1943, 9, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 1952, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 1965, 8, 92, 1, 93, 5, 93, 1968, 8, 93, 10, 93, 12, 93, 1971, 9, 93, 1, 94, 1, 94, 3, 94, 1975, 8, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 5, 95, 1982, 8, 95, 10, 95, 12, 95, 1985, 9, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 3, 97, 1994, 8, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2078, 8, 99, 10, 99, 12, 99, 2081, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2087, 8, 99, 10, 99, 12, 99, 2090, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2100, 8, 99, 10, 99, 12, 99, 2103, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2111, 8, 99, 10, 99, 12, 99, 2114, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 2121, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 2131, 8, 100, 10, 100, 12, 100, 2134, 9, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 2160, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 2167, 8, 102, 1, 103, 1, 103, 1, 103, 3, 103, 2172, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 2179, 8, 104, 1, 105, 1, 105, 5, 105, 2183, 8, 105, 10, 105, 12, 105, 2186, 9, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2193, 8, 105, 10, 105, 12, 105, 2196, 9, 105, 1, 105, 3, 105, 2199, 8, 105, 1, 106, 1, 106, 1, 107, 5, 107, 2204, 8, 107, 10, 107, 12, 107, 2207, 9, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 2221, 8, 108, 1, 109, 1, 109, 5, 109, 2225, 8, 109, 10, 109, 12, 109, 2228, 9, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 111, 5, 111, 2239, 8, 111, 10, 111, 12, 111, 2242, 9, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 2254, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 2263, 8, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 4, 114, 2272, 8, 114, 11, 114, 12, 114, 2273, 1, 114, 1, 114, 3, 114, 2278, 8, 114, 1, 115, 1, 115, 1, 115, 5, 115, 2283, 8, 115, 10, 115, 12, 115, 2286, 9, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 2305, 8, 116, 1, 117, 1, 117, 1, 117, 5, 117, 2310, 8, 117, 10, 117, 12, 117, 2313, 9, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2323, 8, 117, 10, 117, 12, 117, 2326, 9, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2351, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2358, 8, 119, 3, 119, 2360, 8, 119, 1, 119, 5, 119, 2363, 8, 119, 10, 119, 12, 119, 2366, 9, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2371, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2400, 8, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 2409, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2432, 8, 122, 1, 123, 5, 123, 2435, 8, 123, 10, 123, 12, 123, 2438, 9, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2477, 8, 124, 1, 125, 1, 125, 3, 125, 2481, 8, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, 2491, 8, 126, 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, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 2513, 8, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2523, 8, 129, 10, 129, 12, 129, 2526, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2534, 8, 129, 10, 129, 12, 129, 2537, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2549, 8, 129, 10, 129, 12, 129, 2552, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2562, 8, 129, 10, 129, 12, 129, 2565, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2575, 8, 129, 10, 129, 12, 129, 2578, 9, 129, 3, 129, 2580, 8, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 3, 131, 2588, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 4, 134, 2600, 8, 134, 11, 134, 12, 134, 2601, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 3, 135, 2620, 8, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 3, 136, 2638, 8, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 2652, 8, 137, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 2676, 8, 141, 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 2688, 8, 143, 1, 144, 1, 144, 1, 144, 3, 144, 2693, 8, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 4, 145, 2700, 8, 145, 11, 145, 12, 145, 2701, 3, 145, 2704, 8, 145, 1, 146, 1, 146, 1, 146, 5, 146, 2709, 8, 146, 10, 146, 12, 146, 2712, 9, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 2721, 8, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 3, 148, 2789, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 2866, 8, 149, 1, 150, 1, 150, 1, 150, 5, 150, 2871, 8, 150, 10, 150, 12, 150, 2874, 9, 150, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 3, 152, 2881, 8, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 3, 153, 3031, 8, 153, 1, 154, 1, 154, 5, 154, 3035, 8, 154, 10, 154, 12, 154, 3038, 9, 154, 1, 155, 1, 155, 5, 155, 3042, 8, 155, 10, 155, 12, 155, 3045, 9, 155, 1, 156, 5, 156, 3048, 8, 156, 10, 156, 12, 156, 3051, 9, 156, 1, 157, 5, 157, 3054, 8, 157, 10, 157, 12, 157, 3057, 9, 157, 1, 158, 5, 158, 3060, 8, 158, 10, 158, 12, 158, 3063, 9, 158, 1, 159, 5, 159, 3066, 8, 159, 10, 159, 12, 159, 3069, 9, 159, 1, 160, 5, 160, 3072, 8, 160, 10, 160, 12, 160, 3075, 9, 160, 1, 161, 5, 161, 3078, 8, 161, 10, 161, 12, 161, 3081, 9, 161, 1, 162, 5, 162, 3084, 8, 162, 10, 162, 12, 162, 3087, 9, 162, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 3093, 8, 163, 1, 164, 5, 164, 3096, 8, 164, 10, 164, 12, 164, 3099, 9, 164, 1, 165, 1, 165, 1, 165, 3, 165, 3104, 8, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 3, 166, 3131, 8, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 3, 167, 3145, 8, 167, 1, 168, 5, 168, 3148, 8, 168, 10, 168, 12, 168, 3151, 9, 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, 169, 3, 169, 3167, 8, 169, 1, 170, 1, 170, 1, 170, 5, 170, 3172, 8, 170, 10, 170, 12, 170, 3175, 9, 170, 1, 170, 1, 170, 1, 171, 1, 171, 5, 171, 3181, 8, 171, 10, 171, 12, 171, 3184, 9, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, 172, 3203, 8, 172, 1, 173, 5, 173, 3206, 8, 173, 10, 173, 12, 173, 3209, 9, 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, 3, 174, 3224, 8, 174, 1, 175, 1, 175, 5, 175, 3228, 8, 175, 10, 175, 12, 175, 3231, 9, 175, 1, 175, 1, 175, 1, 175, 5, 175, 3236, 8, 175, 10, 175, 12, 175, 3239, 9, 175, 1, 175, 1, 175, 1, 175, 1, 175, 3, 175, 3245, 8, 175, 1, 176, 1, 176, 1, 177, 5, 177, 3250, 8, 177, 10, 177, 12, 177, 3253, 9, 177, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 3, 178, 3265, 8, 178, 1, 178, 0, 1, 68, 179, 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, 0, 15, 6, 0, 1, 15, 199, 199, 243, 243, 247, 247, 264, 264, 289, 289, 5, 0, 16, 16, 199, 199, 243, 243, 264, 264, 288, 289, 1, 0, 263, 264, 1, 0, 173, 174, 1, 0, 37, 38, 1, 0, 73, 74, 3, 0, 2, 2, 61, 61, 77, 83, 2, 0, 229, 229, 260, 261, 1, 0, 95, 96, 1, 0, 97, 111, 1, 0, 68, 69, 2, 0, 173, 173, 289, 290, 2, 0, 179, 179, 264, 264, 1, 0, 167, 168, 1, 0, 51, 52, 3729, 0, 358, 1, 0, 0, 0, 2, 376, 1, 0, 0, 0, 4, 378, 1, 0, 0, 0, 6, 385, 1, 0, 0, 0, 8, 394, 1, 0, 0, 0, 10, 447, 1, 0, 0, 0, 12, 449, 1, 0, 0, 0, 14, 452, 1, 0, 0, 0, 16, 455, 1, 0, 0, 0, 18, 459, 1, 0, 0, 0, 20, 462, 1, 0, 0, 0, 22, 465, 1, 0, 0, 0, 24, 472, 1, 0, 0, 0, 26, 488, 1, 0, 0, 0, 28, 490, 1, 0, 0, 0, 30, 492, 1, 0, 0, 0, 32, 502, 1, 0, 0, 0, 34, 504, 1, 0, 0, 0, 36, 527, 1, 0, 0, 0, 38, 531, 1, 0, 0, 0, 40, 549, 1, 0, 0, 0, 42, 576, 1, 0, 0, 0, 44, 599, 1, 0, 0, 0, 46, 635, 1, 0, 0, 0, 48, 637, 1, 0, 0, 0, 50, 645, 1, 0, 0, 0, 52, 647, 1, 0, 0, 0, 54, 654, 1, 0, 0, 0, 56, 666, 1, 0, 0, 0, 58, 669, 1, 0, 0, 0, 60, 671, 1, 0, 0, 0, 62, 684, 1, 0, 0, 0, 64, 692, 1, 0, 0, 0, 66, 694, 1, 0, 0, 0, 68, 702, 1, 0, 0, 0, 70, 718, 1, 0, 0, 0, 72, 724, 1, 0, 0, 0, 74, 727, 1, 0, 0, 0, 76, 776, 1, 0, 0, 0, 78, 781, 1, 0, 0, 0, 80, 786, 1, 0, 0, 0, 82, 791, 1, 0, 0, 0, 84, 799, 1, 0, 0, 0, 86, 804, 1, 0, 0, 0, 88, 909, 1, 0, 0, 0, 90, 937, 1, 0, 0, 0, 92, 939, 1, 0, 0, 0, 94, 943, 1, 0, 0, 0, 96, 945, 1, 0, 0, 0, 98, 950, 1, 0, 0, 0, 100, 978, 1, 0, 0, 0, 102, 1058, 1, 0, 0, 0, 104, 1060, 1, 0, 0, 0, 106, 1089, 1, 0, 0, 0, 108, 1091, 1, 0, 0, 0, 110, 1105, 1, 0, 0, 0, 112, 1134, 1, 0, 0, 0, 114, 1146, 1, 0, 0, 0, 116, 1185, 1, 0, 0, 0, 118, 1193, 1, 0, 0, 0, 120, 1202, 1, 0, 0, 0, 122, 1210, 1, 0, 0, 0, 124, 1229, 1, 0, 0, 0, 126, 1242, 1, 0, 0, 0, 128, 1266, 1, 0, 0, 0, 130, 1413, 1, 0, 0, 0, 132, 1423, 1, 0, 0, 0, 134, 1435, 1, 0, 0, 0, 136, 1517, 1, 0, 0, 0, 138, 1519, 1, 0, 0, 0, 140, 1558, 1, 0, 0, 0, 142, 1618, 1, 0, 0, 0, 144, 1658, 1, 0, 0, 0, 146, 1674, 1, 0, 0, 0, 148, 1676, 1, 0, 0, 0, 150, 1680, 1, 0, 0, 0, 152, 1735, 1, 0, 0, 0, 154, 1747, 1, 0, 0, 0, 156, 1762, 1, 0, 0, 0, 158, 1769, 1, 0, 0, 0, 160, 1774, 1, 0, 0, 0, 162, 1778, 1, 0, 0, 0, 164, 1814, 1, 0, 0, 0, 166, 1816, 1, 0, 0, 0, 168, 1860, 1, 0, 0, 0, 170, 1879, 1, 0, 0, 0, 172, 1900, 1, 0, 0, 0, 174, 1902, 1, 0, 0, 0, 176, 1919, 1, 0, 0, 0, 178, 1934, 1, 0, 0, 0, 180, 1941, 1, 0, 0, 0, 182, 1951, 1, 0, 0, 0, 184, 1964, 1, 0, 0, 0, 186, 1969, 1, 0, 0, 0, 188, 1972, 1, 0, 0, 0, 190, 1983, 1, 0, 0, 0, 192, 1988, 1, 0, 0, 0, 194, 1993, 1, 0, 0, 0, 196, 1997, 1, 0, 0, 0, 198, 2120, 1, 0, 0, 0, 200, 2122, 1, 0, 0, 0, 202, 2159, 1, 0, 0, 0, 204, 2166, 1, 0, 0, 0, 206, 2171, 1, 0, 0, 0, 208, 2178, 1, 0, 0, 0, 210, 2198, 1, 0, 0, 0, 212, 2200, 1, 0, 0, 0, 214, 2205, 1, 0, 0, 0, 216, 2220, 1, 0, 0, 0, 218, 2222, 1, 0, 0, 0, 220, 2235, 1, 0, 0, 0, 222, 2240, 1, 0, 0, 0, 224, 2253, 1, 0, 0, 0, 226, 2262, 1, 0, 0, 0, 228, 2277, 1, 0, 0, 0, 230, 2284, 1, 0, 0, 0, 232, 2304, 1, 0, 0, 0, 234, 2306, 1, 0, 0, 0, 236, 2350, 1, 0, 0, 0, 238, 2370, 1, 0, 0, 0, 240, 2399, 1, 0, 0, 0, 242, 2408, 1, 0, 0, 0, 244, 2431, 1, 0, 0, 0, 246, 2436, 1, 0, 0, 0, 248, 2476, 1, 0, 0, 0, 250, 2478, 1, 0, 0, 0, 252, 2484, 1, 0, 0, 0, 254, 2492, 1, 0, 0, 0, 256, 2512, 1, 0, 0, 0, 258, 2579, 1, 0, 0, 0, 260, 2581, 1, 0, 0, 0, 262, 2587, 1, 0, 0, 0, 264, 2589, 1, 0, 0, 0, 266, 2593, 1, 0, 0, 0, 268, 2599, 1, 0, 0, 0, 270, 2619, 1, 0, 0, 0, 272, 2637, 1, 0, 0, 0, 274, 2651, 1, 0, 0, 0, 276, 2653, 1, 0, 0, 0, 278, 2656, 1, 0, 0, 0, 280, 2658, 1, 0, 0, 0, 282, 2675, 1, 0, 0, 0, 284, 2677, 1, 0, 0, 0, 286, 2687, 1, 0, 0, 0, 288, 2692, 1, 0, 0, 0, 290, 2703, 1, 0, 0, 0, 292, 2710, 1, 0, 0, 0, 294, 2720, 1, 0, 0, 0, 296, 2788, 1, 0, 0, 0, 298, 2865, 1, 0, 0, 0, 300, 2872, 1, 0, 0, 0, 302, 2875, 1, 0, 0, 0, 304, 2880, 1, 0, 0, 0, 306, 3030, 1, 0, 0, 0, 308, 3036, 1, 0, 0, 0, 310, 3043, 1, 0, 0, 0, 312, 3049, 1, 0, 0, 0, 314, 3055, 1, 0, 0, 0, 316, 3061, 1, 0, 0, 0, 318, 3067, 1, 0, 0, 0, 320, 3073, 1, 0, 0, 0, 322, 3079, 1, 0, 0, 0, 324, 3085, 1, 0, 0, 0, 326, 3092, 1, 0, 0, 0, 328, 3097, 1, 0, 0, 0, 330, 3103, 1, 0, 0, 0, 332, 3130, 1, 0, 0, 0, 334, 3144, 1, 0, 0, 0, 336, 3149, 1, 0, 0, 0, 338, 3166, 1, 0, 0, 0, 340, 3168, 1, 0, 0, 0, 342, 3178, 1, 0, 0, 0, 344, 3202, 1, 0, 0, 0, 346, 3207, 1, 0, 0, 0, 348, 3223, 1, 0, 0, 0, 350, 3244, 1, 0, 0, 0, 352, 3246, 1, 0, 0, 0, 354, 3251, 1, 0, 0, 0, 356, 3264, 1, 0, 0, 0, 358, 359, 7, 0, 0, 0, 359, 1, 1, 0, 0, 0, 360, 361, 5, 288, 0, 0, 361, 377, 6, 1, -1, 0, 362, 363, 3, 4, 2, 0, 363, 364, 6, 1, -1, 0, 364, 365, 5, 265, 0, 0, 365, 367, 1, 0, 0, 0, 366, 362, 1, 0, 0, 0, 367, 370, 1, 0, 0, 0, 368, 366, 1, 0, 0, 0, 368, 369, 1, 0, 0, 0, 369, 371, 1, 0, 0, 0, 370, 368, 1, 0, 0, 0, 371, 372, 3, 4, 2, 0, 372, 373, 6, 1, -1, 0, 373, 377, 1, 0, 0, 0, 374, 375, 5, 264, 0, 0, 375, 377, 6, 1, -1, 0, 376, 360, 1, 0, 0, 0, 376, 368, 1, 0, 0, 0, 376, 374, 1, 0, 0, 0, 377, 3, 1, 0, 0, 0, 378, 379, 7, 1, 0, 0, 379, 5, 1, 0, 0, 0, 380, 381, 5, 263, 0, 0, 381, 382, 6, 3, -1, 0, 382, 384, 5, 266, 0, 0, 383, 380, 1, 0, 0, 0, 384, 387, 1, 0, 0, 0, 385, 383, 1, 0, 0, 0, 385, 386, 1, 0, 0, 0, 386, 388, 1, 0, 0, 0, 387, 385, 1, 0, 0, 0, 388, 389, 5, 263, 0, 0, 389, 390, 6, 3, -1, 0, 390, 7, 1, 0, 0, 0, 391, 393, 3, 10, 5, 0, 392, 391, 1, 0, 0, 0, 393, 396, 1, 0, 0, 0, 394, 392, 1, 0, 0, 0, 394, 395, 1, 0, 0, 0, 395, 9, 1, 0, 0, 0, 396, 394, 1, 0, 0, 0, 397, 398, 3, 74, 37, 0, 398, 399, 5, 17, 0, 0, 399, 400, 3, 82, 41, 0, 400, 401, 5, 18, 0, 0, 401, 448, 1, 0, 0, 0, 402, 403, 3, 72, 36, 0, 403, 404, 5, 17, 0, 0, 404, 405, 3, 8, 4, 0, 405, 406, 5, 18, 0, 0, 406, 448, 1, 0, 0, 0, 407, 408, 3, 234, 117, 0, 408, 409, 5, 17, 0, 0, 409, 410, 3, 246, 123, 0, 410, 411, 5, 18, 0, 0, 411, 448, 1, 0, 0, 0, 412, 448, 3, 200, 100, 0, 413, 448, 3, 284, 142, 0, 414, 448, 3, 70, 35, 0, 415, 448, 3, 66, 33, 0, 416, 448, 3, 88, 44, 0, 417, 448, 3, 90, 45, 0, 418, 448, 3, 22, 11, 0, 419, 420, 3, 334, 167, 0, 420, 421, 5, 17, 0, 0, 421, 422, 3, 336, 168, 0, 422, 423, 5, 18, 0, 0, 423, 448, 1, 0, 0, 0, 424, 425, 3, 340, 170, 0, 425, 426, 5, 17, 0, 0, 426, 427, 3, 346, 173, 0, 427, 428, 5, 18, 0, 0, 428, 448, 1, 0, 0, 0, 429, 430, 3, 350, 175, 0, 430, 431, 5, 17, 0, 0, 431, 432, 3, 354, 177, 0, 432, 433, 5, 18, 0, 0, 433, 448, 1, 0, 0, 0, 434, 448, 3, 64, 32, 0, 435, 448, 3, 152, 76, 0, 436, 448, 3, 330, 165, 0, 437, 448, 3, 12, 6, 0, 438, 448, 3, 14, 7, 0, 439, 448, 3, 16, 8, 0, 440, 448, 3, 18, 9, 0, 441, 448, 3, 20, 10, 0, 442, 448, 3, 26, 13, 0, 443, 448, 3, 42, 21, 0, 444, 448, 3, 40, 20, 0, 445, 448, 3, 30, 15, 0, 446, 448, 3, 24, 12, 0, 447, 397, 1, 0, 0, 0, 447, 402, 1, 0, 0, 0, 447, 407, 1, 0, 0, 0, 447, 412, 1, 0, 0, 0, 447, 413, 1, 0, 0, 0, 447, 414, 1, 0, 0, 0, 447, 415, 1, 0, 0, 0, 447, 416, 1, 0, 0, 0, 447, 417, 1, 0, 0, 0, 447, 418, 1, 0, 0, 0, 447, 419, 1, 0, 0, 0, 447, 424, 1, 0, 0, 0, 447, 429, 1, 0, 0, 0, 447, 434, 1, 0, 0, 0, 447, 435, 1, 0, 0, 0, 447, 436, 1, 0, 0, 0, 447, 437, 1, 0, 0, 0, 447, 438, 1, 0, 0, 0, 447, 439, 1, 0, 0, 0, 447, 440, 1, 0, 0, 0, 447, 441, 1, 0, 0, 0, 447, 442, 1, 0, 0, 0, 447, 443, 1, 0, 0, 0, 447, 444, 1, 0, 0, 0, 447, 445, 1, 0, 0, 0, 447, 446, 1, 0, 0, 0, 448, 11, 1, 0, 0, 0, 449, 450, 5, 19, 0, 0, 450, 451, 3, 32, 16, 0, 451, 13, 1, 0, 0, 0, 452, 453, 5, 20, 0, 0, 453, 454, 3, 32, 16, 0, 454, 15, 1, 0, 0, 0, 455, 456, 5, 21, 0, 0, 456, 457, 5, 22, 0, 0, 457, 458, 3, 32, 16, 0, 458, 17, 1, 0, 0, 0, 459, 460, 5, 23, 0, 0, 460, 461, 3, 34, 17, 0, 461, 19, 1, 0, 0, 0, 462, 463, 5, 24, 0, 0, 463, 464, 3, 34, 17, 0, 464, 21, 1, 0, 0, 0, 465, 466, 5, 25, 0, 0, 466, 467, 3, 98, 49, 0, 467, 468, 3, 2, 1, 0, 468, 469, 5, 17, 0, 0, 469, 470, 3, 120, 60, 0, 470, 471, 5, 18, 0, 0, 471, 23, 1, 0, 0, 0, 472, 473, 5, 26, 0, 0, 473, 25, 1, 0, 0, 0, 474, 475, 5, 27, 0, 0, 475, 489, 3, 28, 14, 0, 476, 477, 5, 27, 0, 0, 477, 478, 3, 28, 14, 0, 478, 479, 5, 28, 0, 0, 479, 480, 3, 28, 14, 0, 480, 489, 1, 0, 0, 0, 481, 482, 5, 27, 0, 0, 482, 483, 3, 28, 14, 0, 483, 484, 5, 28, 0, 0, 484, 485, 3, 28, 14, 0, 485, 486, 5, 28, 0, 0, 486, 487, 3, 28, 14, 0, 487, 489, 1, 0, 0, 0, 488, 474, 1, 0, 0, 0, 488, 476, 1, 0, 0, 0, 488, 481, 1, 0, 0, 0, 489, 27, 1, 0, 0, 0, 490, 491, 7, 2, 0, 0, 491, 29, 1, 0, 0, 0, 492, 493, 5, 29, 0, 0, 493, 497, 5, 17, 0, 0, 494, 496, 3, 116, 58, 0, 495, 494, 1, 0, 0, 0, 496, 499, 1, 0, 0, 0, 497, 495, 1, 0, 0, 0, 497, 498, 1, 0, 0, 0, 498, 500, 1, 0, 0, 0, 499, 497, 1, 0, 0, 0, 500, 501, 5, 18, 0, 0, 501, 31, 1, 0, 0, 0, 502, 503, 5, 173, 0, 0, 503, 33, 1, 0, 0, 0, 504, 505, 7, 3, 0, 0, 505, 35, 1, 0, 0, 0, 506, 507, 5, 175, 0, 0, 507, 528, 6, 18, -1, 0, 508, 509, 3, 32, 16, 0, 509, 510, 5, 265, 0, 0, 510, 511, 6, 18, -1, 0, 511, 528, 1, 0, 0, 0, 512, 513, 3, 32, 16, 0, 513, 514, 6, 18, -1, 0, 514, 528, 1, 0, 0, 0, 515, 516, 5, 188, 0, 0, 516, 517, 5, 30, 0, 0, 517, 518, 3, 32, 16, 0, 518, 519, 5, 31, 0, 0, 519, 520, 6, 18, -1, 0, 520, 528, 1, 0, 0, 0, 521, 522, 5, 189, 0, 0, 522, 523, 5, 30, 0, 0, 523, 524, 3, 34, 17, 0, 524, 525, 5, 31, 0, 0, 525, 526, 6, 18, -1, 0, 526, 528, 1, 0, 0, 0, 527, 506, 1, 0, 0, 0, 527, 508, 1, 0, 0, 0, 527, 512, 1, 0, 0, 0, 527, 515, 1, 0, 0, 0, 527, 521, 1, 0, 0, 0, 528, 37, 1, 0, 0, 0, 529, 532, 3, 32, 16, 0, 530, 532, 5, 262, 0, 0, 531, 529, 1, 0, 0, 0, 531, 530, 1, 0, 0, 0, 532, 39, 1, 0, 0, 0, 533, 534, 5, 267, 0, 0, 534, 550, 5, 289, 0, 0, 535, 536, 5, 267, 0, 0, 536, 537, 5, 289, 0, 0, 537, 550, 5, 263, 0, 0, 538, 539, 5, 268, 0, 0, 539, 550, 5, 289, 0, 0, 540, 541, 5, 269, 0, 0, 541, 550, 5, 289, 0, 0, 542, 543, 5, 270, 0, 0, 543, 550, 5, 289, 0, 0, 544, 550, 5, 271, 0, 0, 545, 550, 5, 272, 0, 0, 546, 547, 5, 273, 0, 0, 547, 550, 5, 263, 0, 0, 548, 550, 5, 32, 0, 0, 549, 533, 1, 0, 0, 0, 549, 535, 1, 0, 0, 0, 549, 538, 1, 0, 0, 0, 549, 540, 1, 0, 0, 0, 549, 542, 1, 0, 0, 0, 549, 544, 1, 0, 0, 0, 549, 545, 1, 0, 0, 0, 549, 546, 1, 0, 0, 0, 549, 548, 1, 0, 0, 0, 550, 41, 1, 0, 0, 0, 551, 552, 5, 33, 0, 0, 552, 553, 3, 138, 69, 0, 553, 554, 5, 34, 0, 0, 554, 555, 3, 2, 1, 0, 555, 577, 1, 0, 0, 0, 556, 557, 5, 33, 0, 0, 557, 558, 3, 116, 58, 0, 558, 559, 5, 34, 0, 0, 559, 560, 3, 2, 1, 0, 560, 577, 1, 0, 0, 0, 561, 562, 5, 33, 0, 0, 562, 563, 3, 176, 88, 0, 563, 564, 5, 34, 0, 0, 564, 565, 3, 2, 1, 0, 565, 577, 1, 0, 0, 0, 566, 567, 5, 33, 0, 0, 567, 568, 3, 44, 22, 0, 568, 569, 5, 34, 0, 0, 569, 570, 3, 2, 1, 0, 570, 577, 1, 0, 0, 0, 571, 572, 5, 33, 0, 0, 572, 573, 3, 46, 23, 0, 573, 574, 5, 34, 0, 0, 574, 575, 3, 2, 1, 0, 575, 577, 1, 0, 0, 0, 576, 551, 1, 0, 0, 0, 576, 556, 1, 0, 0, 0, 576, 561, 1, 0, 0, 0, 576, 566, 1, 0, 0, 0, 576, 571, 1, 0, 0, 0, 577, 43, 1, 0, 0, 0, 578, 579, 5, 35, 0, 0, 579, 600, 3, 48, 24, 0, 580, 581, 5, 35, 0, 0, 581, 582, 3, 48, 24, 0, 582, 583, 5, 36, 0, 0, 583, 584, 3, 6, 3, 0, 584, 600, 1, 0, 0, 0, 585, 586, 5, 35, 0, 0, 586, 587, 3, 48, 24, 0, 587, 588, 5, 36, 0, 0, 588, 589, 5, 17, 0, 0, 589, 590, 3, 52, 26, 0, 590, 591, 5, 18, 0, 0, 591, 600, 1, 0, 0, 0, 592, 593, 5, 35, 0, 0, 593, 594, 3, 48, 24, 0, 594, 595, 5, 36, 0, 0, 595, 596, 5, 30, 0, 0, 596, 597, 3, 300, 150, 0, 597, 598, 5, 31, 0, 0, 598, 600, 1, 0, 0, 0, 599, 578, 1, 0, 0, 0, 599, 580, 1, 0, 0, 0, 599, 585, 1, 0, 0, 0, 599, 592, 1, 0, 0, 0, 600, 45, 1, 0, 0, 0, 601, 602, 5, 35, 0, 0, 602, 603, 5, 30, 0, 0, 603, 604, 3, 50, 25, 0, 604, 605, 5, 31, 0, 0, 605, 606, 3, 48, 24, 0, 606, 636, 1, 0, 0, 0, 607, 608, 5, 35, 0, 0, 608, 609, 5, 30, 0, 0, 609, 610, 3, 50, 25, 0, 610, 611, 5, 31, 0, 0, 611, 612, 3, 48, 24, 0, 612, 613, 5, 36, 0, 0, 613, 614, 3, 6, 3, 0, 614, 636, 1, 0, 0, 0, 615, 616, 5, 35, 0, 0, 616, 617, 5, 30, 0, 0, 617, 618, 3, 50, 25, 0, 618, 619, 5, 31, 0, 0, 619, 620, 3, 48, 24, 0, 620, 621, 5, 36, 0, 0, 621, 622, 5, 17, 0, 0, 622, 623, 3, 52, 26, 0, 623, 624, 5, 18, 0, 0, 624, 636, 1, 0, 0, 0, 625, 626, 5, 35, 0, 0, 626, 627, 5, 30, 0, 0, 627, 628, 3, 50, 25, 0, 628, 629, 5, 31, 0, 0, 629, 630, 3, 48, 24, 0, 630, 631, 5, 36, 0, 0, 631, 632, 5, 30, 0, 0, 632, 633, 3, 300, 150, 0, 633, 634, 5, 31, 0, 0, 634, 636, 1, 0, 0, 0, 635, 601, 1, 0, 0, 0, 635, 607, 1, 0, 0, 0, 635, 615, 1, 0, 0, 0, 635, 625, 1, 0, 0, 0, 636, 47, 1, 0, 0, 0, 637, 638, 3, 168, 84, 0, 638, 49, 1, 0, 0, 0, 639, 640, 3, 124, 62, 0, 640, 641, 6, 25, -1, 0, 641, 646, 1, 0, 0, 0, 642, 643, 3, 176, 88, 0, 643, 644, 6, 25, -1, 0, 644, 646, 1, 0, 0, 0, 645, 639, 1, 0, 0, 0, 645, 642, 1, 0, 0, 0, 646, 51, 1, 0, 0, 0, 647, 648, 3, 54, 27, 0, 648, 649, 3, 56, 28, 0, 649, 53, 1, 0, 0, 0, 650, 653, 3, 306, 153, 0, 651, 653, 3, 40, 20, 0, 652, 650, 1, 0, 0, 0, 652, 651, 1, 0, 0, 0, 653, 656, 1, 0, 0, 0, 654, 652, 1, 0, 0, 0, 654, 655, 1, 0, 0, 0, 655, 55, 1, 0, 0, 0, 656, 654, 1, 0, 0, 0, 657, 658, 3, 58, 29, 0, 658, 659, 3, 60, 30, 0, 659, 660, 3, 2, 1, 0, 660, 661, 5, 36, 0, 0, 661, 662, 3, 306, 153, 0, 662, 665, 1, 0, 0, 0, 663, 665, 3, 40, 20, 0, 664, 657, 1, 0, 0, 0, 664, 663, 1, 0, 0, 0, 665, 668, 1, 0, 0, 0, 666, 664, 1, 0, 0, 0, 666, 667, 1, 0, 0, 0, 667, 57, 1, 0, 0, 0, 668, 666, 1, 0, 0, 0, 669, 670, 7, 4, 0, 0, 670, 59, 1, 0, 0, 0, 671, 673, 3, 62, 31, 0, 672, 674, 5, 261, 0, 0, 673, 672, 1, 0, 0, 0, 673, 674, 1, 0, 0, 0, 674, 61, 1, 0, 0, 0, 675, 685, 3, 144, 72, 0, 676, 685, 3, 2, 1, 0, 677, 685, 5, 196, 0, 0, 678, 685, 5, 197, 0, 0, 679, 680, 5, 202, 0, 0, 680, 681, 5, 39, 0, 0, 681, 685, 5, 264, 0, 0, 682, 683, 5, 202, 0, 0, 683, 685, 3, 116, 58, 0, 684, 675, 1, 0, 0, 0, 684, 676, 1, 0, 0, 0, 684, 677, 1, 0, 0, 0, 684, 678, 1, 0, 0, 0, 684, 679, 1, 0, 0, 0, 684, 682, 1, 0, 0, 0, 685, 63, 1, 0, 0, 0, 686, 687, 5, 198, 0, 0, 687, 688, 5, 40, 0, 0, 688, 693, 3, 2, 1, 0, 689, 690, 5, 198, 0, 0, 690, 693, 3, 2, 1, 0, 691, 693, 5, 198, 0, 0, 692, 686, 1, 0, 0, 0, 692, 689, 1, 0, 0, 0, 692, 691, 1, 0, 0, 0, 693, 65, 1, 0, 0, 0, 694, 695, 5, 41, 0, 0, 695, 696, 5, 42, 0, 0, 696, 697, 3, 32, 16, 0, 697, 698, 5, 43, 0, 0, 698, 699, 3, 68, 34, 0, 699, 700, 5, 44, 0, 0, 700, 701, 3, 0, 0, 0, 701, 67, 1, 0, 0, 0, 702, 715, 6, 34, -1, 0, 703, 704, 10, 5, 0, 0, 704, 714, 5, 186, 0, 0, 705, 706, 10, 4, 0, 0, 706, 714, 5, 187, 0, 0, 707, 708, 10, 3, 0, 0, 708, 714, 5, 45, 0, 0, 709, 710, 10, 2, 0, 0, 710, 714, 5, 46, 0, 0, 711, 712, 10, 1, 0, 0, 712, 714, 5, 47, 0, 0, 713, 703, 1, 0, 0, 0, 713, 705, 1, 0, 0, 0, 713, 707, 1, 0, 0, 0, 713, 709, 1, 0, 0, 0, 713, 711, 1, 0, 0, 0, 714, 717, 1, 0, 0, 0, 715, 713, 1, 0, 0, 0, 715, 716, 1, 0, 0, 0, 716, 69, 1, 0, 0, 0, 717, 715, 1, 0, 0, 0, 718, 719, 5, 48, 0, 0, 719, 720, 5, 36, 0, 0, 720, 721, 5, 30, 0, 0, 721, 722, 3, 300, 150, 0, 722, 723, 5, 31, 0, 0, 723, 71, 1, 0, 0, 0, 724, 725, 5, 49, 0, 0, 725, 726, 3, 2, 1, 0, 726, 73, 1, 0, 0, 0, 727, 731, 5, 50, 0, 0, 728, 730, 3, 76, 38, 0, 729, 728, 1, 0, 0, 0, 730, 733, 1, 0, 0, 0, 731, 729, 1, 0, 0, 0, 731, 732, 1, 0, 0, 0, 732, 734, 1, 0, 0, 0, 733, 731, 1, 0, 0, 0, 734, 735, 3, 2, 1, 0, 735, 736, 3, 182, 91, 0, 736, 737, 3, 78, 39, 0, 737, 738, 3, 80, 40, 0, 738, 75, 1, 0, 0, 0, 739, 777, 5, 51, 0, 0, 740, 777, 5, 52, 0, 0, 741, 777, 5, 199, 0, 0, 742, 777, 5, 202, 0, 0, 743, 777, 5, 221, 0, 0, 744, 777, 5, 53, 0, 0, 745, 777, 5, 54, 0, 0, 746, 777, 5, 55, 0, 0, 747, 777, 5, 56, 0, 0, 748, 777, 5, 244, 0, 0, 749, 777, 5, 15, 0, 0, 750, 777, 5, 224, 0, 0, 751, 777, 5, 57, 0, 0, 752, 777, 5, 58, 0, 0, 753, 777, 5, 59, 0, 0, 754, 777, 5, 60, 0, 0, 755, 777, 5, 61, 0, 0, 756, 757, 5, 62, 0, 0, 757, 777, 5, 51, 0, 0, 758, 759, 5, 62, 0, 0, 759, 777, 5, 52, 0, 0, 760, 761, 5, 62, 0, 0, 761, 777, 5, 63, 0, 0, 762, 763, 5, 62, 0, 0, 763, 777, 5, 64, 0, 0, 764, 765, 5, 62, 0, 0, 765, 777, 5, 65, 0, 0, 766, 767, 5, 62, 0, 0, 767, 777, 5, 66, 0, 0, 768, 777, 5, 67, 0, 0, 769, 777, 5, 68, 0, 0, 770, 777, 5, 69, 0, 0, 771, 772, 5, 70, 0, 0, 772, 773, 5, 30, 0, 0, 773, 774, 3, 32, 16, 0, 774, 775, 5, 31, 0, 0, 775, 777, 1, 0, 0, 0, 776, 739, 1, 0, 0, 0, 776, 740, 1, 0, 0, 0, 776, 741, 1, 0, 0, 0, 776, 742, 1, 0, 0, 0, 776, 743, 1, 0, 0, 0, 776, 744, 1, 0, 0, 0, 776, 745, 1, 0, 0, 0, 776, 746, 1, 0, 0, 0, 776, 747, 1, 0, 0, 0, 776, 748, 1, 0, 0, 0, 776, 749, 1, 0, 0, 0, 776, 750, 1, 0, 0, 0, 776, 751, 1, 0, 0, 0, 776, 752, 1, 0, 0, 0, 776, 753, 1, 0, 0, 0, 776, 754, 1, 0, 0, 0, 776, 755, 1, 0, 0, 0, 776, 756, 1, 0, 0, 0, 776, 758, 1, 0, 0, 0, 776, 760, 1, 0, 0, 0, 776, 762, 1, 0, 0, 0, 776, 764, 1, 0, 0, 0, 776, 766, 1, 0, 0, 0, 776, 768, 1, 0, 0, 0, 776, 769, 1, 0, 0, 0, 776, 770, 1, 0, 0, 0, 776, 771, 1, 0, 0, 0, 777, 77, 1, 0, 0, 0, 778, 782, 1, 0, 0, 0, 779, 780, 5, 71, 0, 0, 780, 782, 3, 124, 62, 0, 781, 778, 1, 0, 0, 0, 781, 779, 1, 0, 0, 0, 782, 79, 1, 0, 0, 0, 783, 787, 1, 0, 0, 0, 784, 785, 5, 72, 0, 0, 785, 787, 3, 84, 42, 0, 786, 783, 1, 0, 0, 0, 786, 784, 1, 0, 0, 0, 787, 81, 1, 0, 0, 0, 788, 790, 3, 198, 99, 0, 789, 788, 1, 0, 0, 0, 790, 793, 1, 0, 0, 0, 791, 789, 1, 0, 0, 0, 791, 792, 1, 0, 0, 0, 792, 83, 1, 0, 0, 0, 793, 791, 1, 0, 0, 0, 794, 795, 3, 124, 62, 0, 795, 796, 5, 28, 0, 0, 796, 798, 1, 0, 0, 0, 797, 794, 1, 0, 0, 0, 798, 801, 1, 0, 0, 0, 799, 797, 1, 0, 0, 0, 799, 800, 1, 0, 0, 0, 800, 802, 1, 0, 0, 0, 801, 799, 1, 0, 0, 0, 802, 803, 3, 124, 62, 0, 803, 85, 1, 0, 0, 0, 804, 805, 7, 5, 0, 0, 805, 87, 1, 0, 0, 0, 806, 807, 3, 86, 43, 0, 807, 808, 3, 32, 16, 0, 808, 809, 5, 264, 0, 0, 809, 910, 1, 0, 0, 0, 810, 811, 3, 86, 43, 0, 811, 812, 3, 32, 16, 0, 812, 910, 1, 0, 0, 0, 813, 814, 3, 86, 43, 0, 814, 815, 3, 32, 16, 0, 815, 816, 5, 75, 0, 0, 816, 817, 3, 32, 16, 0, 817, 818, 5, 264, 0, 0, 818, 910, 1, 0, 0, 0, 819, 820, 3, 86, 43, 0, 820, 821, 3, 32, 16, 0, 821, 822, 5, 75, 0, 0, 822, 823, 3, 32, 16, 0, 823, 910, 1, 0, 0, 0, 824, 825, 3, 86, 43, 0, 825, 826, 3, 32, 16, 0, 826, 827, 5, 75, 0, 0, 827, 828, 3, 32, 16, 0, 828, 829, 5, 28, 0, 0, 829, 830, 3, 32, 16, 0, 830, 831, 5, 264, 0, 0, 831, 910, 1, 0, 0, 0, 832, 833, 3, 86, 43, 0, 833, 834, 3, 32, 16, 0, 834, 835, 5, 75, 0, 0, 835, 836, 3, 32, 16, 0, 836, 837, 5, 28, 0, 0, 837, 838, 3, 32, 16, 0, 838, 910, 1, 0, 0, 0, 839, 840, 3, 86, 43, 0, 840, 841, 3, 32, 16, 0, 841, 842, 5, 28, 0, 0, 842, 843, 3, 32, 16, 0, 843, 844, 5, 75, 0, 0, 844, 845, 3, 32, 16, 0, 845, 846, 5, 264, 0, 0, 846, 910, 1, 0, 0, 0, 847, 848, 3, 86, 43, 0, 848, 849, 3, 32, 16, 0, 849, 850, 5, 28, 0, 0, 850, 851, 3, 32, 16, 0, 851, 852, 5, 75, 0, 0, 852, 853, 3, 32, 16, 0, 853, 910, 1, 0, 0, 0, 854, 855, 3, 86, 43, 0, 855, 856, 3, 32, 16, 0, 856, 857, 5, 28, 0, 0, 857, 858, 3, 32, 16, 0, 858, 859, 5, 75, 0, 0, 859, 860, 3, 32, 16, 0, 860, 861, 5, 28, 0, 0, 861, 862, 3, 32, 16, 0, 862, 863, 5, 264, 0, 0, 863, 910, 1, 0, 0, 0, 864, 865, 3, 86, 43, 0, 865, 866, 3, 32, 16, 0, 866, 867, 5, 28, 0, 0, 867, 868, 3, 32, 16, 0, 868, 869, 5, 75, 0, 0, 869, 870, 3, 32, 16, 0, 870, 871, 5, 28, 0, 0, 871, 872, 3, 32, 16, 0, 872, 910, 1, 0, 0, 0, 873, 874, 3, 86, 43, 0, 874, 875, 3, 32, 16, 0, 875, 876, 5, 263, 0, 0, 876, 910, 1, 0, 0, 0, 877, 878, 3, 86, 43, 0, 878, 879, 3, 32, 16, 0, 879, 880, 5, 75, 0, 0, 880, 881, 3, 32, 16, 0, 881, 882, 5, 263, 0, 0, 882, 910, 1, 0, 0, 0, 883, 884, 3, 86, 43, 0, 884, 885, 3, 32, 16, 0, 885, 886, 5, 75, 0, 0, 886, 887, 3, 32, 16, 0, 887, 888, 5, 28, 0, 0, 888, 889, 3, 32, 16, 0, 889, 890, 5, 263, 0, 0, 890, 910, 1, 0, 0, 0, 891, 892, 3, 86, 43, 0, 892, 893, 3, 32, 16, 0, 893, 894, 5, 28, 0, 0, 894, 895, 3, 32, 16, 0, 895, 896, 5, 75, 0, 0, 896, 897, 3, 32, 16, 0, 897, 898, 5, 263, 0, 0, 898, 910, 1, 0, 0, 0, 899, 900, 3, 86, 43, 0, 900, 901, 3, 32, 16, 0, 901, 902, 5, 28, 0, 0, 902, 903, 3, 32, 16, 0, 903, 904, 5, 75, 0, 0, 904, 905, 3, 32, 16, 0, 905, 906, 5, 28, 0, 0, 906, 907, 3, 32, 16, 0, 907, 908, 5, 263, 0, 0, 908, 910, 1, 0, 0, 0, 909, 806, 1, 0, 0, 0, 909, 810, 1, 0, 0, 0, 909, 813, 1, 0, 0, 0, 909, 819, 1, 0, 0, 0, 909, 824, 1, 0, 0, 0, 909, 832, 1, 0, 0, 0, 909, 839, 1, 0, 0, 0, 909, 847, 1, 0, 0, 0, 909, 854, 1, 0, 0, 0, 909, 864, 1, 0, 0, 0, 909, 873, 1, 0, 0, 0, 909, 877, 1, 0, 0, 0, 909, 883, 1, 0, 0, 0, 909, 891, 1, 0, 0, 0, 909, 899, 1, 0, 0, 0, 910, 89, 1, 0, 0, 0, 911, 915, 5, 21, 0, 0, 912, 914, 3, 92, 46, 0, 913, 912, 1, 0, 0, 0, 914, 917, 1, 0, 0, 0, 915, 913, 1, 0, 0, 0, 915, 916, 1, 0, 0, 0, 916, 918, 1, 0, 0, 0, 917, 915, 1, 0, 0, 0, 918, 919, 3, 2, 1, 0, 919, 920, 3, 94, 47, 0, 920, 921, 5, 180, 0, 0, 921, 922, 5, 36, 0, 0, 922, 923, 5, 30, 0, 0, 923, 924, 3, 300, 150, 0, 924, 925, 5, 31, 0, 0, 925, 926, 3, 94, 47, 0, 926, 938, 1, 0, 0, 0, 927, 931, 5, 21, 0, 0, 928, 930, 3, 92, 46, 0, 929, 928, 1, 0, 0, 0, 930, 933, 1, 0, 0, 0, 931, 929, 1, 0, 0, 0, 931, 932, 1, 0, 0, 0, 932, 934, 1, 0, 0, 0, 933, 931, 1, 0, 0, 0, 934, 935, 3, 2, 1, 0, 935, 936, 3, 94, 47, 0, 936, 938, 1, 0, 0, 0, 937, 911, 1, 0, 0, 0, 937, 927, 1, 0, 0, 0, 938, 91, 1, 0, 0, 0, 939, 940, 5, 76, 0, 0, 940, 93, 1, 0, 0, 0, 941, 944, 1, 0, 0, 0, 942, 944, 5, 298, 0, 0, 943, 941, 1, 0, 0, 0, 943, 942, 1, 0, 0, 0, 944, 95, 1, 0, 0, 0, 945, 946, 7, 6, 0, 0, 946, 97, 1, 0, 0, 0, 947, 949, 3, 96, 48, 0, 948, 947, 1, 0, 0, 0, 949, 952, 1, 0, 0, 0, 950, 948, 1, 0, 0, 0, 950, 951, 1, 0, 0, 0, 951, 99, 1, 0, 0, 0, 952, 950, 1, 0, 0, 0, 953, 979, 3, 102, 51, 0, 954, 955, 5, 280, 0, 0, 955, 956, 3, 168, 84, 0, 956, 957, 6, 50, -1, 0, 957, 979, 1, 0, 0, 0, 958, 959, 5, 286, 0, 0, 959, 960, 3, 178, 89, 0, 960, 961, 6, 50, -1, 0, 961, 979, 1, 0, 0, 0, 962, 963, 5, 286, 0, 0, 963, 964, 3, 174, 87, 0, 964, 965, 6, 50, -1, 0, 965, 979, 1, 0, 0, 0, 966, 967, 5, 284, 0, 0, 967, 968, 3, 124, 62, 0, 968, 969, 6, 50, -1, 0, 969, 979, 1, 0, 0, 0, 970, 971, 5, 281, 0, 0, 971, 972, 3, 104, 52, 0, 972, 973, 6, 50, -1, 0, 973, 979, 1, 0, 0, 0, 974, 975, 5, 287, 0, 0, 975, 976, 3, 50, 25, 0, 976, 977, 6, 50, -1, 0, 977, 979, 1, 0, 0, 0, 978, 953, 1, 0, 0, 0, 978, 954, 1, 0, 0, 0, 978, 958, 1, 0, 0, 0, 978, 962, 1, 0, 0, 0, 978, 966, 1, 0, 0, 0, 978, 970, 1, 0, 0, 0, 978, 974, 1, 0, 0, 0, 979, 101, 1, 0, 0, 0, 980, 981, 5, 275, 0, 0, 981, 1059, 6, 51, -1, 0, 982, 983, 5, 276, 0, 0, 983, 984, 3, 32, 16, 0, 984, 985, 6, 51, -1, 0, 985, 1059, 1, 0, 0, 0, 986, 987, 5, 276, 0, 0, 987, 988, 3, 0, 0, 0, 988, 989, 6, 51, -1, 0, 989, 1059, 1, 0, 0, 0, 990, 991, 5, 277, 0, 0, 991, 992, 3, 32, 16, 0, 992, 993, 6, 51, -1, 0, 993, 1059, 1, 0, 0, 0, 994, 995, 5, 278, 0, 0, 995, 996, 3, 34, 17, 0, 996, 997, 6, 51, -1, 0, 997, 1059, 1, 0, 0, 0, 998, 999, 5, 279, 0, 0, 999, 1000, 3, 36, 18, 0, 1000, 1001, 6, 51, -1, 0, 1001, 1059, 1, 0, 0, 0, 1002, 1003, 5, 279, 0, 0, 1003, 1004, 3, 34, 17, 0, 1004, 1005, 6, 51, -1, 0, 1005, 1059, 1, 0, 0, 0, 1006, 1007, 5, 279, 0, 0, 1007, 1008, 5, 30, 0, 0, 1008, 1009, 3, 300, 150, 0, 1009, 1010, 5, 31, 0, 0, 1010, 1011, 6, 51, -1, 0, 1011, 1059, 1, 0, 0, 0, 1012, 1013, 5, 279, 0, 0, 1013, 1014, 5, 84, 0, 0, 1014, 1015, 5, 30, 0, 0, 1015, 1016, 3, 300, 150, 0, 1016, 1017, 5, 31, 0, 0, 1017, 1018, 6, 51, -1, 0, 1018, 1059, 1, 0, 0, 0, 1019, 1020, 5, 282, 0, 0, 1020, 1021, 3, 32, 16, 0, 1021, 1022, 6, 51, -1, 0, 1022, 1059, 1, 0, 0, 0, 1023, 1024, 5, 282, 0, 0, 1024, 1025, 3, 0, 0, 0, 1025, 1026, 6, 51, -1, 0, 1026, 1059, 1, 0, 0, 0, 1027, 1028, 5, 285, 0, 0, 1028, 1029, 3, 6, 3, 0, 1029, 1030, 6, 51, -1, 0, 1030, 1059, 1, 0, 0, 0, 1031, 1032, 5, 285, 0, 0, 1032, 1033, 5, 224, 0, 0, 1033, 1034, 5, 30, 0, 0, 1034, 1035, 3, 6, 3, 0, 1035, 1036, 5, 31, 0, 0, 1036, 1037, 6, 51, -1, 0, 1037, 1059, 1, 0, 0, 0, 1038, 1039, 5, 285, 0, 0, 1039, 1040, 5, 84, 0, 0, 1040, 1041, 5, 30, 0, 0, 1041, 1042, 3, 300, 150, 0, 1042, 1043, 5, 31, 0, 0, 1043, 1044, 6, 51, -1, 0, 1044, 1059, 1, 0, 0, 0, 1045, 1046, 5, 287, 0, 0, 1046, 1047, 3, 32, 16, 0, 1047, 1048, 6, 51, -1, 0, 1048, 1059, 1, 0, 0, 0, 1049, 1050, 5, 283, 0, 0, 1050, 1056, 6, 51, -1, 0, 1051, 1052, 5, 30, 0, 0, 1052, 1053, 3, 106, 53, 0, 1053, 1054, 5, 31, 0, 0, 1054, 1057, 1, 0, 0, 0, 1055, 1057, 5, 85, 0, 0, 1056, 1051, 1, 0, 0, 0, 1056, 1055, 1, 0, 0, 0, 1057, 1059, 1, 0, 0, 0, 1058, 980, 1, 0, 0, 0, 1058, 982, 1, 0, 0, 0, 1058, 986, 1, 0, 0, 0, 1058, 990, 1, 0, 0, 0, 1058, 994, 1, 0, 0, 0, 1058, 998, 1, 0, 0, 0, 1058, 1002, 1, 0, 0, 0, 1058, 1006, 1, 0, 0, 0, 1058, 1012, 1, 0, 0, 0, 1058, 1019, 1, 0, 0, 0, 1058, 1023, 1, 0, 0, 0, 1058, 1027, 1, 0, 0, 0, 1058, 1031, 1, 0, 0, 0, 1058, 1038, 1, 0, 0, 0, 1058, 1045, 1, 0, 0, 0, 1058, 1049, 1, 0, 0, 0, 1059, 103, 1, 0, 0, 0, 1060, 1061, 3, 170, 85, 0, 1061, 1062, 3, 138, 69, 0, 1062, 1063, 3, 112, 56, 0, 1063, 1064, 6, 52, -1, 0, 1064, 105, 1, 0, 0, 0, 1065, 1090, 1, 0, 0, 0, 1066, 1067, 3, 0, 0, 0, 1067, 1068, 6, 53, -1, 0, 1068, 1073, 1, 0, 0, 0, 1069, 1070, 3, 32, 16, 0, 1070, 1071, 6, 53, -1, 0, 1071, 1073, 1, 0, 0, 0, 1072, 1066, 1, 0, 0, 0, 1072, 1069, 1, 0, 0, 0, 1073, 1074, 1, 0, 0, 0, 1074, 1075, 5, 28, 0, 0, 1075, 1077, 1, 0, 0, 0, 1076, 1072, 1, 0, 0, 0, 1077, 1080, 1, 0, 0, 0, 1078, 1076, 1, 0, 0, 0, 1078, 1079, 1, 0, 0, 0, 1079, 1087, 1, 0, 0, 0, 1080, 1078, 1, 0, 0, 0, 1081, 1082, 3, 0, 0, 0, 1082, 1083, 6, 53, -1, 0, 1083, 1088, 1, 0, 0, 0, 1084, 1085, 3, 32, 16, 0, 1085, 1086, 6, 53, -1, 0, 1086, 1088, 1, 0, 0, 0, 1087, 1081, 1, 0, 0, 0, 1087, 1084, 1, 0, 0, 0, 1088, 1090, 1, 0, 0, 0, 1089, 1065, 1, 0, 0, 0, 1089, 1078, 1, 0, 0, 0, 1090, 107, 1, 0, 0, 0, 1091, 1098, 5, 86, 0, 0, 1092, 1093, 3, 138, 69, 0, 1093, 1094, 6, 54, -1, 0, 1094, 1095, 5, 28, 0, 0, 1095, 1097, 1, 0, 0, 0, 1096, 1092, 1, 0, 0, 0, 1097, 1100, 1, 0, 0, 0, 1098, 1096, 1, 0, 0, 0, 1098, 1099, 1, 0, 0, 0, 1099, 1101, 1, 0, 0, 0, 1100, 1098, 1, 0, 0, 0, 1101, 1102, 3, 138, 69, 0, 1102, 1103, 6, 54, -1, 0, 1103, 1104, 5, 87, 0, 0, 1104, 109, 1, 0, 0, 0, 1105, 1112, 5, 42, 0, 0, 1106, 1107, 3, 146, 73, 0, 1107, 1108, 6, 55, -1, 0, 1108, 1109, 5, 28, 0, 0, 1109, 1111, 1, 0, 0, 0, 1110, 1106, 1, 0, 0, 0, 1111, 1114, 1, 0, 0, 0, 1112, 1110, 1, 0, 0, 0, 1112, 1113, 1, 0, 0, 0, 1113, 1115, 1, 0, 0, 0, 1114, 1112, 1, 0, 0, 0, 1115, 1116, 3, 146, 73, 0, 1116, 1117, 6, 55, -1, 0, 1117, 1118, 5, 43, 0, 0, 1118, 111, 1, 0, 0, 0, 1119, 1126, 5, 30, 0, 0, 1120, 1121, 3, 114, 57, 0, 1121, 1122, 6, 56, -1, 0, 1122, 1123, 5, 28, 0, 0, 1123, 1125, 1, 0, 0, 0, 1124, 1120, 1, 0, 0, 0, 1125, 1128, 1, 0, 0, 0, 1126, 1124, 1, 0, 0, 0, 1126, 1127, 1, 0, 0, 0, 1127, 1129, 1, 0, 0, 0, 1128, 1126, 1, 0, 0, 0, 1129, 1130, 3, 114, 57, 0, 1130, 1131, 6, 56, -1, 0, 1131, 1132, 5, 31, 0, 0, 1132, 1135, 1, 0, 0, 0, 1133, 1135, 5, 85, 0, 0, 1134, 1119, 1, 0, 0, 0, 1134, 1133, 1, 0, 0, 0, 1135, 113, 1, 0, 0, 0, 1136, 1137, 5, 177, 0, 0, 1137, 1147, 6, 57, -1, 0, 1138, 1139, 3, 230, 115, 0, 1139, 1140, 3, 138, 69, 0, 1140, 1142, 3, 226, 113, 0, 1141, 1143, 3, 0, 0, 0, 1142, 1141, 1, 0, 0, 0, 1142, 1143, 1, 0, 0, 0, 1143, 1144, 1, 0, 0, 0, 1144, 1145, 6, 57, -1, 0, 1145, 1147, 1, 0, 0, 0, 1146, 1136, 1, 0, 0, 0, 1146, 1138, 1, 0, 0, 0, 1147, 115, 1, 0, 0, 0, 1148, 1149, 5, 42, 0, 0, 1149, 1150, 3, 2, 1, 0, 1150, 1151, 5, 43, 0, 0, 1151, 1152, 3, 118, 59, 0, 1152, 1153, 6, 58, -1, 0, 1153, 1186, 1, 0, 0, 0, 1154, 1155, 5, 42, 0, 0, 1155, 1156, 3, 174, 87, 0, 1156, 1157, 5, 43, 0, 0, 1157, 1158, 3, 118, 59, 0, 1158, 1159, 6, 58, -1, 0, 1159, 1186, 1, 0, 0, 0, 1160, 1161, 5, 42, 0, 0, 1161, 1162, 5, 262, 0, 0, 1162, 1163, 5, 43, 0, 0, 1163, 1164, 3, 118, 59, 0, 1164, 1165, 6, 58, -1, 0, 1165, 1186, 1, 0, 0, 0, 1166, 1167, 5, 42, 0, 0, 1167, 1168, 5, 198, 0, 0, 1168, 1169, 3, 2, 1, 0, 1169, 1170, 5, 43, 0, 0, 1170, 1171, 3, 118, 59, 0, 1171, 1172, 6, 58, -1, 0, 1172, 1186, 1, 0, 0, 0, 1173, 1174, 3, 118, 59, 0, 1174, 1175, 6, 58, -1, 0, 1175, 1186, 1, 0, 0, 0, 1176, 1177, 3, 174, 87, 0, 1177, 1178, 6, 58, -1, 0, 1178, 1186, 1, 0, 0, 0, 1179, 1180, 5, 257, 0, 0, 1180, 1186, 6, 58, -1, 0, 1181, 1182, 5, 258, 0, 0, 1182, 1186, 6, 58, -1, 0, 1183, 1184, 5, 259, 0, 0, 1184, 1186, 6, 58, -1, 0, 1185, 1148, 1, 0, 0, 0, 1185, 1154, 1, 0, 0, 0, 1185, 1160, 1, 0, 0, 0, 1185, 1166, 1, 0, 0, 0, 1185, 1173, 1, 0, 0, 0, 1185, 1176, 1, 0, 0, 0, 1185, 1179, 1, 0, 0, 0, 1185, 1181, 1, 0, 0, 0, 1185, 1183, 1, 0, 0, 0, 1186, 117, 1, 0, 0, 0, 1187, 1188, 3, 2, 1, 0, 1188, 1189, 6, 59, -1, 0, 1189, 1190, 5, 88, 0, 0, 1190, 1192, 1, 0, 0, 0, 1191, 1187, 1, 0, 0, 0, 1192, 1195, 1, 0, 0, 0, 1193, 1191, 1, 0, 0, 0, 1193, 1194, 1, 0, 0, 0, 1194, 1196, 1, 0, 0, 0, 1195, 1193, 1, 0, 0, 0, 1196, 1197, 3, 2, 1, 0, 1197, 1198, 6, 59, -1, 0, 1198, 119, 1, 0, 0, 0, 1199, 1201, 3, 122, 61, 0, 1200, 1199, 1, 0, 0, 0, 1201, 1204, 1, 0, 0, 0, 1202, 1200, 1, 0, 0, 0, 1202, 1203, 1, 0, 0, 0, 1203, 121, 1, 0, 0, 0, 1204, 1202, 1, 0, 0, 0, 1205, 1206, 5, 180, 0, 0, 1206, 1207, 5, 89, 0, 0, 1207, 1211, 3, 32, 16, 0, 1208, 1211, 3, 152, 76, 0, 1209, 1211, 3, 332, 166, 0, 1210, 1205, 1, 0, 0, 0, 1210, 1208, 1, 0, 0, 0, 1210, 1209, 1, 0, 0, 0, 1211, 123, 1, 0, 0, 0, 1212, 1213, 3, 116, 58, 0, 1213, 1214, 6, 62, -1, 0, 1214, 1230, 1, 0, 0, 0, 1215, 1216, 5, 42, 0, 0, 1216, 1217, 3, 2, 1, 0, 1217, 1218, 5, 43, 0, 0, 1218, 1219, 6, 62, -1, 0, 1219, 1230, 1, 0, 0, 0, 1220, 1221, 5, 42, 0, 0, 1221, 1222, 5, 198, 0, 0, 1222, 1223, 3, 2, 1, 0, 1223, 1224, 5, 43, 0, 0, 1224, 1225, 6, 62, -1, 0, 1225, 1230, 1, 0, 0, 0, 1226, 1227, 3, 138, 69, 0, 1227, 1228, 6, 62, -1, 0, 1228, 1230, 1, 0, 0, 0, 1229, 1212, 1, 0, 0, 0, 1229, 1215, 1, 0, 0, 0, 1229, 1220, 1, 0, 0, 0, 1229, 1226, 1, 0, 0, 0, 1230, 125, 1, 0, 0, 0, 1231, 1243, 1, 0, 0, 0, 1232, 1233, 3, 130, 65, 0, 1233, 1239, 6, 63, -1, 0, 1234, 1235, 3, 128, 64, 0, 1235, 1236, 6, 63, -1, 0, 1236, 1238, 1, 0, 0, 0, 1237, 1234, 1, 0, 0, 0, 1238, 1241, 1, 0, 0, 0, 1239, 1237, 1, 0, 0, 0, 1239, 1240, 1, 0, 0, 0, 1240, 1243, 1, 0, 0, 0, 1241, 1239, 1, 0, 0, 0, 1242, 1231, 1, 0, 0, 0, 1242, 1232, 1, 0, 0, 0, 1243, 127, 1, 0, 0, 0, 1244, 1245, 5, 262, 0, 0, 1245, 1267, 6, 64, -1, 0, 1246, 1247, 5, 261, 0, 0, 1247, 1267, 6, 64, -1, 0, 1248, 1249, 5, 42, 0, 0, 1249, 1250, 3, 32, 16, 0, 1250, 1251, 5, 43, 0, 0, 1251, 1252, 6, 64, -1, 0, 1252, 1267, 1, 0, 0, 0, 1253, 1254, 5, 42, 0, 0, 1254, 1255, 3, 32, 16, 0, 1255, 1256, 5, 266, 0, 0, 1256, 1257, 3, 32, 16, 0, 1257, 1258, 5, 43, 0, 0, 1258, 1259, 6, 64, -1, 0, 1259, 1267, 1, 0, 0, 0, 1260, 1261, 5, 42, 0, 0, 1261, 1262, 5, 266, 0, 0, 1262, 1263, 3, 32, 16, 0, 1263, 1264, 5, 43, 0, 0, 1264, 1265, 6, 64, -1, 0, 1265, 1267, 1, 0, 0, 0, 1266, 1244, 1, 0, 0, 0, 1266, 1246, 1, 0, 0, 0, 1266, 1248, 1, 0, 0, 0, 1266, 1253, 1, 0, 0, 0, 1266, 1260, 1, 0, 0, 0, 1267, 129, 1, 0, 0, 0, 1268, 1414, 6, 65, -1, 0, 1269, 1270, 5, 203, 0, 0, 1270, 1271, 5, 30, 0, 0, 1271, 1272, 3, 6, 3, 0, 1272, 1273, 5, 28, 0, 0, 1273, 1274, 3, 6, 3, 0, 1274, 1275, 5, 28, 0, 0, 1275, 1276, 3, 6, 3, 0, 1276, 1277, 5, 28, 0, 0, 1277, 1278, 3, 6, 3, 0, 1278, 1279, 5, 31, 0, 0, 1279, 1280, 6, 65, -1, 0, 1280, 1414, 1, 0, 0, 0, 1281, 1282, 5, 203, 0, 0, 1282, 1283, 5, 30, 0, 0, 1283, 1284, 3, 6, 3, 0, 1284, 1285, 5, 28, 0, 0, 1285, 1286, 3, 6, 3, 0, 1286, 1287, 5, 31, 0, 0, 1287, 1288, 6, 65, -1, 0, 1288, 1414, 1, 0, 0, 0, 1289, 1290, 5, 204, 0, 0, 1290, 1291, 5, 205, 0, 0, 1291, 1292, 5, 42, 0, 0, 1292, 1293, 3, 32, 16, 0, 1293, 1294, 5, 43, 0, 0, 1294, 1295, 6, 65, -1, 0, 1295, 1414, 1, 0, 0, 0, 1296, 1297, 5, 204, 0, 0, 1297, 1298, 5, 206, 0, 0, 1298, 1299, 5, 42, 0, 0, 1299, 1300, 3, 32, 16, 0, 1300, 1301, 5, 43, 0, 0, 1301, 1302, 3, 126, 63, 0, 1302, 1303, 6, 65, -1, 0, 1303, 1414, 1, 0, 0, 0, 1304, 1305, 5, 207, 0, 0, 1305, 1414, 6, 65, -1, 0, 1306, 1307, 5, 208, 0, 0, 1307, 1414, 6, 65, -1, 0, 1308, 1309, 5, 209, 0, 0, 1309, 1414, 6, 65, -1, 0, 1310, 1311, 5, 201, 0, 0, 1311, 1414, 6, 65, -1, 0, 1312, 1313, 5, 183, 0, 0, 1313, 1414, 6, 65, -1, 0, 1314, 1315, 5, 184, 0, 0, 1315, 1414, 6, 65, -1, 0, 1316, 1317, 5, 185, 0, 0, 1317, 1414, 6, 65, -1, 0, 1318, 1319, 5, 186, 0, 0, 1319, 1414, 6, 65, -1, 0, 1320, 1321, 5, 187, 0, 0, 1321, 1414, 6, 65, -1, 0, 1322, 1323, 5, 188, 0, 0, 1323, 1414, 6, 65, -1, 0, 1324, 1325, 5, 189, 0, 0, 1325, 1414, 6, 65, -1, 0, 1326, 1327, 5, 210, 0, 0, 1327, 1414, 6, 65, -1, 0, 1328, 1329, 5, 190, 0, 0, 1329, 1414, 6, 65, -1, 0, 1330, 1331, 5, 191, 0, 0, 1331, 1414, 6, 65, -1, 0, 1332, 1333, 5, 192, 0, 0, 1333, 1414, 6, 65, -1, 0, 1334, 1335, 5, 193, 0, 0, 1335, 1414, 6, 65, -1, 0, 1336, 1337, 5, 211, 0, 0, 1337, 1414, 6, 65, -1, 0, 1338, 1339, 5, 212, 0, 0, 1339, 1414, 6, 65, -1, 0, 1340, 1341, 5, 213, 0, 0, 1341, 1414, 6, 65, -1, 0, 1342, 1343, 5, 214, 0, 0, 1343, 1414, 6, 65, -1, 0, 1344, 1345, 5, 215, 0, 0, 1345, 1414, 6, 65, -1, 0, 1346, 1347, 5, 216, 0, 0, 1347, 1414, 6, 65, -1, 0, 1348, 1349, 5, 217, 0, 0, 1349, 1414, 6, 65, -1, 0, 1350, 1351, 5, 218, 0, 0, 1351, 1352, 3, 132, 66, 0, 1352, 1353, 6, 65, -1, 0, 1353, 1414, 1, 0, 0, 0, 1354, 1355, 5, 219, 0, 0, 1355, 1356, 3, 132, 66, 0, 1356, 1357, 6, 65, -1, 0, 1357, 1414, 1, 0, 0, 0, 1358, 1359, 5, 220, 0, 0, 1359, 1414, 6, 65, -1, 0, 1360, 1361, 5, 221, 0, 0, 1361, 1362, 3, 132, 66, 0, 1362, 1363, 6, 65, -1, 0, 1363, 1414, 1, 0, 0, 0, 1364, 1365, 5, 222, 0, 0, 1365, 1366, 3, 134, 67, 0, 1366, 1367, 6, 65, -1, 0, 1367, 1414, 1, 0, 0, 0, 1368, 1369, 5, 222, 0, 0, 1369, 1370, 3, 134, 67, 0, 1370, 1371, 5, 28, 0, 0, 1371, 1372, 3, 6, 3, 0, 1372, 1373, 6, 65, -1, 0, 1373, 1414, 1, 0, 0, 0, 1374, 1375, 5, 194, 0, 0, 1375, 1414, 6, 65, -1, 0, 1376, 1377, 5, 195, 0, 0, 1377, 1414, 6, 65, -1, 0, 1378, 1379, 5, 90, 0, 0, 1379, 1380, 5, 184, 0, 0, 1380, 1414, 6, 65, -1, 0, 1381, 1382, 5, 90, 0, 0, 1382, 1383, 5, 185, 0, 0, 1383, 1414, 6, 65, -1, 0, 1384, 1385, 5, 90, 0, 0, 1385, 1386, 5, 186, 0, 0, 1386, 1414, 6, 65, -1, 0, 1387, 1388, 5, 90, 0, 0, 1388, 1389, 5, 187, 0, 0, 1389, 1414, 6, 65, -1, 0, 1390, 1391, 5, 62, 0, 0, 1391, 1392, 5, 220, 0, 0, 1392, 1414, 6, 65, -1, 0, 1393, 1394, 5, 223, 0, 0, 1394, 1414, 6, 65, -1, 0, 1395, 1396, 5, 224, 0, 0, 1396, 1397, 5, 213, 0, 0, 1397, 1414, 6, 65, -1, 0, 1398, 1399, 5, 225, 0, 0, 1399, 1414, 6, 65, -1, 0, 1400, 1401, 5, 207, 0, 0, 1401, 1402, 5, 183, 0, 0, 1402, 1414, 6, 65, -1, 0, 1403, 1404, 5, 226, 0, 0, 1404, 1414, 6, 65, -1, 0, 1405, 1406, 5, 228, 0, 0, 1406, 1414, 6, 65, -1, 0, 1407, 1408, 5, 34, 0, 0, 1408, 1409, 5, 227, 0, 0, 1409, 1414, 6, 65, -1, 0, 1410, 1411, 3, 2, 1, 0, 1411, 1412, 6, 65, -1, 0, 1412, 1414, 1, 0, 0, 0, 1413, 1268, 1, 0, 0, 0, 1413, 1269, 1, 0, 0, 0, 1413, 1281, 1, 0, 0, 0, 1413, 1289, 1, 0, 0, 0, 1413, 1296, 1, 0, 0, 0, 1413, 1304, 1, 0, 0, 0, 1413, 1306, 1, 0, 0, 0, 1413, 1308, 1, 0, 0, 0, 1413, 1310, 1, 0, 0, 0, 1413, 1312, 1, 0, 0, 0, 1413, 1314, 1, 0, 0, 0, 1413, 1316, 1, 0, 0, 0, 1413, 1318, 1, 0, 0, 0, 1413, 1320, 1, 0, 0, 0, 1413, 1322, 1, 0, 0, 0, 1413, 1324, 1, 0, 0, 0, 1413, 1326, 1, 0, 0, 0, 1413, 1328, 1, 0, 0, 0, 1413, 1330, 1, 0, 0, 0, 1413, 1332, 1, 0, 0, 0, 1413, 1334, 1, 0, 0, 0, 1413, 1336, 1, 0, 0, 0, 1413, 1338, 1, 0, 0, 0, 1413, 1340, 1, 0, 0, 0, 1413, 1342, 1, 0, 0, 0, 1413, 1344, 1, 0, 0, 0, 1413, 1346, 1, 0, 0, 0, 1413, 1348, 1, 0, 0, 0, 1413, 1350, 1, 0, 0, 0, 1413, 1354, 1, 0, 0, 0, 1413, 1358, 1, 0, 0, 0, 1413, 1360, 1, 0, 0, 0, 1413, 1364, 1, 0, 0, 0, 1413, 1368, 1, 0, 0, 0, 1413, 1374, 1, 0, 0, 0, 1413, 1376, 1, 0, 0, 0, 1413, 1378, 1, 0, 0, 0, 1413, 1381, 1, 0, 0, 0, 1413, 1384, 1, 0, 0, 0, 1413, 1387, 1, 0, 0, 0, 1413, 1390, 1, 0, 0, 0, 1413, 1393, 1, 0, 0, 0, 1413, 1395, 1, 0, 0, 0, 1413, 1398, 1, 0, 0, 0, 1413, 1400, 1, 0, 0, 0, 1413, 1403, 1, 0, 0, 0, 1413, 1405, 1, 0, 0, 0, 1413, 1407, 1, 0, 0, 0, 1413, 1410, 1, 0, 0, 0, 1414, 131, 1, 0, 0, 0, 1415, 1424, 1, 0, 0, 0, 1416, 1417, 5, 30, 0, 0, 1417, 1418, 5, 91, 0, 0, 1418, 1419, 5, 36, 0, 0, 1419, 1420, 3, 32, 16, 0, 1420, 1421, 5, 31, 0, 0, 1421, 1422, 6, 66, -1, 0, 1422, 1424, 1, 0, 0, 0, 1423, 1415, 1, 0, 0, 0, 1423, 1416, 1, 0, 0, 0, 1424, 133, 1, 0, 0, 0, 1425, 1436, 1, 0, 0, 0, 1426, 1427, 3, 136, 68, 0, 1427, 1432, 6, 67, -1, 0, 1428, 1429, 7, 7, 0, 0, 1429, 1431, 6, 67, -1, 0, 1430, 1428, 1, 0, 0, 0, 1431, 1434, 1, 0, 0, 0, 1432, 1430, 1, 0, 0, 0, 1432, 1433, 1, 0, 0, 0, 1433, 1436, 1, 0, 0, 0, 1434, 1432, 1, 0, 0, 0, 1435, 1425, 1, 0, 0, 0, 1435, 1426, 1, 0, 0, 0, 1436, 135, 1, 0, 0, 0, 1437, 1438, 5, 178, 0, 0, 1438, 1518, 6, 68, -1, 0, 1439, 1440, 5, 207, 0, 0, 1440, 1518, 6, 68, -1, 0, 1441, 1442, 5, 208, 0, 0, 1442, 1518, 6, 68, -1, 0, 1443, 1444, 5, 201, 0, 0, 1444, 1518, 6, 68, -1, 0, 1445, 1446, 5, 183, 0, 0, 1446, 1518, 6, 68, -1, 0, 1447, 1448, 5, 184, 0, 0, 1448, 1518, 6, 68, -1, 0, 1449, 1450, 5, 185, 0, 0, 1450, 1518, 6, 68, -1, 0, 1451, 1452, 5, 186, 0, 0, 1452, 1518, 6, 68, -1, 0, 1453, 1454, 5, 187, 0, 0, 1454, 1518, 6, 68, -1, 0, 1455, 1456, 5, 188, 0, 0, 1456, 1518, 6, 68, -1, 0, 1457, 1458, 5, 189, 0, 0, 1458, 1518, 6, 68, -1, 0, 1459, 1460, 5, 190, 0, 0, 1460, 1518, 6, 68, -1, 0, 1461, 1462, 5, 191, 0, 0, 1462, 1518, 6, 68, -1, 0, 1463, 1464, 5, 192, 0, 0, 1464, 1518, 6, 68, -1, 0, 1465, 1466, 5, 193, 0, 0, 1466, 1518, 6, 68, -1, 0, 1467, 1468, 5, 262, 0, 0, 1468, 1518, 6, 68, -1, 0, 1469, 1470, 5, 211, 0, 0, 1470, 1518, 6, 68, -1, 0, 1471, 1472, 5, 212, 0, 0, 1472, 1518, 6, 68, -1, 0, 1473, 1474, 5, 213, 0, 0, 1474, 1518, 6, 68, -1, 0, 1475, 1476, 5, 214, 0, 0, 1476, 1518, 6, 68, -1, 0, 1477, 1478, 5, 215, 0, 0, 1478, 1518, 6, 68, -1, 0, 1479, 1480, 5, 218, 0, 0, 1480, 1518, 6, 68, -1, 0, 1481, 1482, 5, 219, 0, 0, 1482, 1518, 6, 68, -1, 0, 1483, 1484, 5, 222, 0, 0, 1484, 1518, 6, 68, -1, 0, 1485, 1486, 5, 194, 0, 0, 1486, 1518, 6, 68, -1, 0, 1487, 1488, 5, 195, 0, 0, 1488, 1518, 6, 68, -1, 0, 1489, 1490, 5, 210, 0, 0, 1490, 1518, 6, 68, -1, 0, 1491, 1492, 5, 230, 0, 0, 1492, 1518, 6, 68, -1, 0, 1493, 1494, 5, 231, 0, 0, 1494, 1518, 6, 68, -1, 0, 1495, 1496, 5, 232, 0, 0, 1496, 1518, 6, 68, -1, 0, 1497, 1498, 5, 233, 0, 0, 1498, 1518, 6, 68, -1, 0, 1499, 1500, 5, 234, 0, 0, 1500, 1518, 6, 68, -1, 0, 1501, 1502, 5, 235, 0, 0, 1502, 1518, 6, 68, -1, 0, 1503, 1504, 5, 236, 0, 0, 1504, 1518, 6, 68, -1, 0, 1505, 1506, 5, 237, 0, 0, 1506, 1518, 6, 68, -1, 0, 1507, 1508, 5, 238, 0, 0, 1508, 1518, 6, 68, -1, 0, 1509, 1510, 5, 239, 0, 0, 1510, 1518, 6, 68, -1, 0, 1511, 1512, 5, 240, 0, 0, 1512, 1518, 6, 68, -1, 0, 1513, 1514, 5, 241, 0, 0, 1514, 1518, 6, 68, -1, 0, 1515, 1516, 5, 242, 0, 0, 1516, 1518, 6, 68, -1, 0, 1517, 1437, 1, 0, 0, 0, 1517, 1439, 1, 0, 0, 0, 1517, 1441, 1, 0, 0, 0, 1517, 1443, 1, 0, 0, 0, 1517, 1445, 1, 0, 0, 0, 1517, 1447, 1, 0, 0, 0, 1517, 1449, 1, 0, 0, 0, 1517, 1451, 1, 0, 0, 0, 1517, 1453, 1, 0, 0, 0, 1517, 1455, 1, 0, 0, 0, 1517, 1457, 1, 0, 0, 0, 1517, 1459, 1, 0, 0, 0, 1517, 1461, 1, 0, 0, 0, 1517, 1463, 1, 0, 0, 0, 1517, 1465, 1, 0, 0, 0, 1517, 1467, 1, 0, 0, 0, 1517, 1469, 1, 0, 0, 0, 1517, 1471, 1, 0, 0, 0, 1517, 1473, 1, 0, 0, 0, 1517, 1475, 1, 0, 0, 0, 1517, 1477, 1, 0, 0, 0, 1517, 1479, 1, 0, 0, 0, 1517, 1481, 1, 0, 0, 0, 1517, 1483, 1, 0, 0, 0, 1517, 1485, 1, 0, 0, 0, 1517, 1487, 1, 0, 0, 0, 1517, 1489, 1, 0, 0, 0, 1517, 1491, 1, 0, 0, 0, 1517, 1493, 1, 0, 0, 0, 1517, 1495, 1, 0, 0, 0, 1517, 1497, 1, 0, 0, 0, 1517, 1499, 1, 0, 0, 0, 1517, 1501, 1, 0, 0, 0, 1517, 1503, 1, 0, 0, 0, 1517, 1505, 1, 0, 0, 0, 1517, 1507, 1, 0, 0, 0, 1517, 1509, 1, 0, 0, 0, 1517, 1511, 1, 0, 0, 0, 1517, 1513, 1, 0, 0, 0, 1517, 1515, 1, 0, 0, 0, 1518, 137, 1, 0, 0, 0, 1519, 1520, 3, 142, 71, 0, 1520, 1526, 6, 69, -1, 0, 1521, 1522, 3, 140, 70, 0, 1522, 1523, 6, 69, -1, 0, 1523, 1525, 1, 0, 0, 0, 1524, 1521, 1, 0, 0, 0, 1525, 1528, 1, 0, 0, 0, 1526, 1524, 1, 0, 0, 0, 1526, 1527, 1, 0, 0, 0, 1527, 139, 1, 0, 0, 0, 1528, 1526, 1, 0, 0, 0, 1529, 1530, 5, 261, 0, 0, 1530, 1559, 6, 70, -1, 0, 1531, 1532, 5, 42, 0, 0, 1532, 1533, 5, 43, 0, 0, 1533, 1559, 6, 70, -1, 0, 1534, 1535, 3, 110, 55, 0, 1535, 1536, 6, 70, -1, 0, 1536, 1559, 1, 0, 0, 0, 1537, 1538, 5, 260, 0, 0, 1538, 1559, 6, 70, -1, 0, 1539, 1540, 5, 262, 0, 0, 1540, 1559, 6, 70, -1, 0, 1541, 1542, 5, 92, 0, 0, 1542, 1559, 6, 70, -1, 0, 1543, 1544, 5, 93, 0, 0, 1544, 1545, 5, 30, 0, 0, 1545, 1546, 3, 124, 62, 0, 1546, 1547, 5, 31, 0, 0, 1547, 1548, 6, 70, -1, 0, 1548, 1559, 1, 0, 0, 0, 1549, 1550, 5, 94, 0, 0, 1550, 1551, 5, 30, 0, 0, 1551, 1552, 3, 124, 62, 0, 1552, 1553, 5, 31, 0, 0, 1553, 1554, 6, 70, -1, 0, 1554, 1559, 1, 0, 0, 0, 1555, 1556, 3, 108, 54, 0, 1556, 1557, 6, 70, -1, 0, 1557, 1559, 1, 0, 0, 0, 1558, 1529, 1, 0, 0, 0, 1558, 1531, 1, 0, 0, 0, 1558, 1534, 1, 0, 0, 0, 1558, 1537, 1, 0, 0, 0, 1558, 1539, 1, 0, 0, 0, 1558, 1541, 1, 0, 0, 0, 1558, 1543, 1, 0, 0, 0, 1558, 1549, 1, 0, 0, 0, 1558, 1555, 1, 0, 0, 0, 1559, 141, 1, 0, 0, 0, 1560, 1561, 5, 39, 0, 0, 1561, 1562, 3, 116, 58, 0, 1562, 1563, 6, 71, -1, 0, 1563, 1619, 1, 0, 0, 0, 1564, 1565, 5, 197, 0, 0, 1565, 1619, 6, 71, -1, 0, 1566, 1567, 5, 199, 0, 0, 1567, 1568, 5, 39, 0, 0, 1568, 1569, 3, 116, 58, 0, 1569, 1570, 6, 71, -1, 0, 1570, 1619, 1, 0, 0, 0, 1571, 1572, 5, 200, 0, 0, 1572, 1573, 3, 116, 58, 0, 1573, 1574, 6, 71, -1, 0, 1574, 1619, 1, 0, 0, 0, 1575, 1576, 5, 226, 0, 0, 1576, 1577, 3, 170, 85, 0, 1577, 1578, 3, 138, 69, 0, 1578, 1579, 5, 262, 0, 0, 1579, 1580, 3, 112, 56, 0, 1580, 1581, 6, 71, -1, 0, 1581, 1619, 1, 0, 0, 0, 1582, 1583, 5, 253, 0, 0, 1583, 1584, 3, 32, 16, 0, 1584, 1585, 6, 71, -1, 0, 1585, 1619, 1, 0, 0, 0, 1586, 1587, 5, 252, 0, 0, 1587, 1588, 3, 32, 16, 0, 1588, 1589, 6, 71, -1, 0, 1589, 1619, 1, 0, 0, 0, 1590, 1591, 5, 253, 0, 0, 1591, 1592, 3, 2, 1, 0, 1592, 1593, 6, 71, -1, 0, 1593, 1619, 1, 0, 0, 0, 1594, 1595, 5, 252, 0, 0, 1595, 1596, 3, 2, 1, 0, 1596, 1597, 6, 71, -1, 0, 1597, 1619, 1, 0, 0, 0, 1598, 1599, 5, 254, 0, 0, 1599, 1619, 6, 71, -1, 0, 1600, 1601, 5, 201, 0, 0, 1601, 1619, 6, 71, -1, 0, 1602, 1603, 3, 148, 74, 0, 1603, 1604, 6, 71, -1, 0, 1604, 1619, 1, 0, 0, 0, 1605, 1606, 3, 150, 75, 0, 1606, 1607, 6, 71, -1, 0, 1607, 1619, 1, 0, 0, 0, 1608, 1609, 3, 144, 72, 0, 1609, 1610, 6, 71, -1, 0, 1610, 1619, 1, 0, 0, 0, 1611, 1612, 3, 2, 1, 0, 1612, 1613, 6, 71, -1, 0, 1613, 1619, 1, 0, 0, 0, 1614, 1615, 5, 177, 0, 0, 1615, 1616, 3, 138, 69, 0, 1616, 1617, 6, 71, -1, 0, 1617, 1619, 1, 0, 0, 0, 1618, 1560, 1, 0, 0, 0, 1618, 1564, 1, 0, 0, 0, 1618, 1566, 1, 0, 0, 0, 1618, 1571, 1, 0, 0, 0, 1618, 1575, 1, 0, 0, 0, 1618, 1582, 1, 0, 0, 0, 1618, 1586, 1, 0, 0, 0, 1618, 1590, 1, 0, 0, 0, 1618, 1594, 1, 0, 0, 0, 1618, 1598, 1, 0, 0, 0, 1618, 1600, 1, 0, 0, 0, 1618, 1602, 1, 0, 0, 0, 1618, 1605, 1, 0, 0, 0, 1618, 1608, 1, 0, 0, 0, 1618, 1611, 1, 0, 0, 0, 1618, 1614, 1, 0, 0, 0, 1619, 143, 1, 0, 0, 0, 1620, 1621, 5, 181, 0, 0, 1621, 1659, 6, 72, -1, 0, 1622, 1623, 5, 182, 0, 0, 1623, 1659, 6, 72, -1, 0, 1624, 1625, 5, 183, 0, 0, 1625, 1659, 6, 72, -1, 0, 1626, 1627, 5, 184, 0, 0, 1627, 1659, 6, 72, -1, 0, 1628, 1629, 5, 185, 0, 0, 1629, 1659, 6, 72, -1, 0, 1630, 1631, 5, 186, 0, 0, 1631, 1659, 6, 72, -1, 0, 1632, 1633, 5, 187, 0, 0, 1633, 1659, 6, 72, -1, 0, 1634, 1635, 5, 188, 0, 0, 1635, 1659, 6, 72, -1, 0, 1636, 1637, 5, 189, 0, 0, 1637, 1659, 6, 72, -1, 0, 1638, 1639, 5, 190, 0, 0, 1639, 1659, 6, 72, -1, 0, 1640, 1641, 5, 191, 0, 0, 1641, 1659, 6, 72, -1, 0, 1642, 1643, 5, 192, 0, 0, 1643, 1659, 6, 72, -1, 0, 1644, 1645, 5, 193, 0, 0, 1645, 1659, 6, 72, -1, 0, 1646, 1647, 5, 90, 0, 0, 1647, 1648, 5, 184, 0, 0, 1648, 1659, 6, 72, -1, 0, 1649, 1650, 5, 90, 0, 0, 1650, 1651, 5, 185, 0, 0, 1651, 1659, 6, 72, -1, 0, 1652, 1653, 5, 90, 0, 0, 1653, 1654, 5, 186, 0, 0, 1654, 1659, 6, 72, -1, 0, 1655, 1656, 5, 90, 0, 0, 1656, 1657, 5, 187, 0, 0, 1657, 1659, 6, 72, -1, 0, 1658, 1620, 1, 0, 0, 0, 1658, 1622, 1, 0, 0, 0, 1658, 1624, 1, 0, 0, 0, 1658, 1626, 1, 0, 0, 0, 1658, 1628, 1, 0, 0, 0, 1658, 1630, 1, 0, 0, 0, 1658, 1632, 1, 0, 0, 0, 1658, 1634, 1, 0, 0, 0, 1658, 1636, 1, 0, 0, 0, 1658, 1638, 1, 0, 0, 0, 1658, 1640, 1, 0, 0, 0, 1658, 1642, 1, 0, 0, 0, 1658, 1644, 1, 0, 0, 0, 1658, 1646, 1, 0, 0, 0, 1658, 1649, 1, 0, 0, 0, 1658, 1652, 1, 0, 0, 0, 1658, 1655, 1, 0, 0, 0, 1659, 145, 1, 0, 0, 0, 1660, 1675, 1, 0, 0, 0, 1661, 1675, 5, 177, 0, 0, 1662, 1663, 3, 32, 16, 0, 1663, 1664, 6, 73, -1, 0, 1664, 1675, 1, 0, 0, 0, 1665, 1666, 3, 32, 16, 0, 1666, 1667, 5, 177, 0, 0, 1667, 1668, 3, 32, 16, 0, 1668, 1669, 6, 73, -1, 0, 1669, 1675, 1, 0, 0, 0, 1670, 1671, 3, 32, 16, 0, 1671, 1672, 5, 177, 0, 0, 1672, 1673, 6, 73, -1, 0, 1673, 1675, 1, 0, 0, 0, 1674, 1660, 1, 0, 0, 0, 1674, 1661, 1, 0, 0, 0, 1674, 1662, 1, 0, 0, 0, 1674, 1665, 1, 0, 0, 0, 1674, 1670, 1, 0, 0, 0, 1675, 147, 1, 0, 0, 0, 1676, 1677, 5, 1, 0, 0, 1677, 1678, 5, 194, 0, 0, 1678, 1679, 6, 74, -1, 0, 1679, 149, 1, 0, 0, 0, 1680, 1684, 5, 1, 0, 0, 1681, 1682, 5, 90, 0, 0, 1682, 1685, 5, 194, 0, 0, 1683, 1685, 5, 195, 0, 0, 1684, 1681, 1, 0, 0, 0, 1684, 1683, 1, 0, 0, 0, 1685, 1686, 1, 0, 0, 0, 1686, 1687, 6, 75, -1, 0, 1687, 151, 1, 0, 0, 0, 1688, 1689, 5, 294, 0, 0, 1689, 1690, 3, 166, 83, 0, 1690, 1691, 3, 124, 62, 0, 1691, 1692, 5, 30, 0, 0, 1692, 1693, 3, 158, 79, 0, 1693, 1694, 5, 31, 0, 0, 1694, 1736, 1, 0, 0, 0, 1695, 1696, 5, 294, 0, 0, 1696, 1697, 3, 166, 83, 0, 1697, 1698, 3, 124, 62, 0, 1698, 1699, 5, 36, 0, 0, 1699, 1700, 5, 17, 0, 0, 1700, 1701, 3, 52, 26, 0, 1701, 1702, 5, 18, 0, 0, 1702, 1736, 1, 0, 0, 0, 1703, 1704, 5, 294, 0, 0, 1704, 1705, 3, 166, 83, 0, 1705, 1706, 3, 124, 62, 0, 1706, 1736, 1, 0, 0, 0, 1707, 1708, 5, 295, 0, 0, 1708, 1709, 3, 166, 83, 0, 1709, 1711, 5, 36, 0, 0, 1710, 1712, 5, 84, 0, 0, 1711, 1710, 1, 0, 0, 0, 1711, 1712, 1, 0, 0, 0, 1712, 1713, 1, 0, 0, 0, 1713, 1714, 5, 30, 0, 0, 1714, 1715, 3, 300, 150, 0, 1715, 1716, 5, 31, 0, 0, 1716, 1736, 1, 0, 0, 0, 1717, 1718, 5, 295, 0, 0, 1718, 1719, 3, 166, 83, 0, 1719, 1720, 5, 84, 0, 0, 1720, 1721, 5, 30, 0, 0, 1721, 1722, 3, 300, 150, 0, 1722, 1723, 5, 31, 0, 0, 1723, 1736, 1, 0, 0, 0, 1724, 1725, 5, 295, 0, 0, 1725, 1726, 3, 166, 83, 0, 1726, 1727, 3, 6, 3, 0, 1727, 1736, 1, 0, 0, 0, 1728, 1729, 5, 295, 0, 0, 1729, 1730, 3, 166, 83, 0, 1730, 1731, 5, 36, 0, 0, 1731, 1732, 5, 17, 0, 0, 1732, 1733, 3, 154, 77, 0, 1733, 1734, 5, 18, 0, 0, 1734, 1736, 1, 0, 0, 0, 1735, 1688, 1, 0, 0, 0, 1735, 1695, 1, 0, 0, 0, 1735, 1703, 1, 0, 0, 0, 1735, 1707, 1, 0, 0, 0, 1735, 1717, 1, 0, 0, 0, 1735, 1724, 1, 0, 0, 0, 1735, 1728, 1, 0, 0, 0, 1736, 153, 1, 0, 0, 0, 1737, 1748, 1, 0, 0, 0, 1738, 1739, 3, 156, 78, 0, 1739, 1740, 5, 28, 0, 0, 1740, 1742, 1, 0, 0, 0, 1741, 1738, 1, 0, 0, 0, 1742, 1745, 1, 0, 0, 0, 1743, 1741, 1, 0, 0, 0, 1743, 1744, 1, 0, 0, 0, 1744, 1746, 1, 0, 0, 0, 1745, 1743, 1, 0, 0, 0, 1746, 1748, 3, 156, 78, 0, 1747, 1737, 1, 0, 0, 0, 1747, 1743, 1, 0, 0, 0, 1748, 155, 1, 0, 0, 0, 1749, 1750, 5, 39, 0, 0, 1750, 1751, 5, 264, 0, 0, 1751, 1752, 5, 36, 0, 0, 1752, 1753, 5, 17, 0, 0, 1753, 1754, 3, 56, 28, 0, 1754, 1755, 5, 18, 0, 0, 1755, 1763, 1, 0, 0, 0, 1756, 1757, 3, 124, 62, 0, 1757, 1758, 5, 36, 0, 0, 1758, 1759, 5, 17, 0, 0, 1759, 1760, 3, 56, 28, 0, 1760, 1761, 5, 18, 0, 0, 1761, 1763, 1, 0, 0, 0, 1762, 1749, 1, 0, 0, 0, 1762, 1756, 1, 0, 0, 0, 1763, 157, 1, 0, 0, 0, 1764, 1765, 3, 160, 80, 0, 1765, 1766, 5, 28, 0, 0, 1766, 1768, 1, 0, 0, 0, 1767, 1764, 1, 0, 0, 0, 1768, 1771, 1, 0, 0, 0, 1769, 1767, 1, 0, 0, 0, 1769, 1770, 1, 0, 0, 0, 1770, 1772, 1, 0, 0, 0, 1771, 1769, 1, 0, 0, 0, 1772, 1773, 3, 160, 80, 0, 1773, 159, 1, 0, 0, 0, 1774, 1775, 3, 6, 3, 0, 1775, 1776, 5, 36, 0, 0, 1776, 1777, 3, 164, 82, 0, 1777, 161, 1, 0, 0, 0, 1778, 1779, 7, 8, 0, 0, 1779, 163, 1, 0, 0, 0, 1780, 1815, 3, 162, 81, 0, 1781, 1815, 3, 32, 16, 0, 1782, 1783, 5, 186, 0, 0, 1783, 1784, 5, 30, 0, 0, 1784, 1785, 3, 32, 16, 0, 1785, 1786, 5, 31, 0, 0, 1786, 1815, 1, 0, 0, 0, 1787, 1815, 3, 6, 3, 0, 1788, 1789, 3, 116, 58, 0, 1789, 1790, 5, 30, 0, 0, 1790, 1791, 5, 184, 0, 0, 1791, 1792, 5, 75, 0, 0, 1792, 1793, 3, 32, 16, 0, 1793, 1794, 5, 31, 0, 0, 1794, 1815, 1, 0, 0, 0, 1795, 1796, 3, 116, 58, 0, 1796, 1797, 5, 30, 0, 0, 1797, 1798, 5, 185, 0, 0, 1798, 1799, 5, 75, 0, 0, 1799, 1800, 3, 32, 16, 0, 1800, 1801, 5, 31, 0, 0, 1801, 1815, 1, 0, 0, 0, 1802, 1803, 3, 116, 58, 0, 1803, 1804, 5, 30, 0, 0, 1804, 1805, 5, 186, 0, 0, 1805, 1806, 5, 75, 0, 0, 1806, 1807, 3, 32, 16, 0, 1807, 1808, 5, 31, 0, 0, 1808, 1815, 1, 0, 0, 0, 1809, 1810, 3, 116, 58, 0, 1810, 1811, 5, 30, 0, 0, 1811, 1812, 3, 32, 16, 0, 1812, 1813, 5, 31, 0, 0, 1813, 1815, 1, 0, 0, 0, 1814, 1780, 1, 0, 0, 0, 1814, 1781, 1, 0, 0, 0, 1814, 1782, 1, 0, 0, 0, 1814, 1787, 1, 0, 0, 0, 1814, 1788, 1, 0, 0, 0, 1814, 1795, 1, 0, 0, 0, 1814, 1802, 1, 0, 0, 0, 1814, 1809, 1, 0, 0, 0, 1815, 165, 1, 0, 0, 0, 1816, 1817, 7, 9, 0, 0, 1817, 167, 1, 0, 0, 0, 1818, 1819, 3, 170, 85, 0, 1819, 1820, 3, 138, 69, 0, 1820, 1821, 3, 124, 62, 0, 1821, 1822, 5, 176, 0, 0, 1822, 1824, 3, 242, 121, 0, 1823, 1825, 3, 108, 54, 0, 1824, 1823, 1, 0, 0, 0, 1824, 1825, 1, 0, 0, 0, 1825, 1826, 1, 0, 0, 0, 1826, 1827, 3, 112, 56, 0, 1827, 1828, 6, 84, -1, 0, 1828, 1861, 1, 0, 0, 0, 1829, 1830, 3, 170, 85, 0, 1830, 1831, 3, 138, 69, 0, 1831, 1832, 3, 124, 62, 0, 1832, 1833, 5, 176, 0, 0, 1833, 1834, 3, 242, 121, 0, 1834, 1835, 3, 196, 98, 0, 1835, 1836, 3, 112, 56, 0, 1836, 1837, 6, 84, -1, 0, 1837, 1861, 1, 0, 0, 0, 1838, 1839, 3, 170, 85, 0, 1839, 1840, 3, 138, 69, 0, 1840, 1842, 3, 242, 121, 0, 1841, 1843, 3, 108, 54, 0, 1842, 1841, 1, 0, 0, 0, 1842, 1843, 1, 0, 0, 0, 1843, 1844, 1, 0, 0, 0, 1844, 1845, 3, 112, 56, 0, 1845, 1846, 6, 84, -1, 0, 1846, 1861, 1, 0, 0, 0, 1847, 1848, 3, 170, 85, 0, 1848, 1849, 3, 138, 69, 0, 1849, 1850, 3, 242, 121, 0, 1850, 1851, 3, 196, 98, 0, 1851, 1852, 3, 112, 56, 0, 1852, 1853, 6, 84, -1, 0, 1853, 1861, 1, 0, 0, 0, 1854, 1855, 3, 174, 87, 0, 1855, 1856, 6, 84, -1, 0, 1856, 1861, 1, 0, 0, 0, 1857, 1858, 3, 2, 1, 0, 1858, 1859, 6, 84, -1, 0, 1859, 1861, 1, 0, 0, 0, 1860, 1818, 1, 0, 0, 0, 1860, 1829, 1, 0, 0, 0, 1860, 1838, 1, 0, 0, 0, 1860, 1847, 1, 0, 0, 0, 1860, 1854, 1, 0, 0, 0, 1860, 1857, 1, 0, 0, 0, 1861, 169, 1, 0, 0, 0, 1862, 1863, 5, 243, 0, 0, 1863, 1864, 3, 170, 85, 0, 1864, 1865, 6, 85, -1, 0, 1865, 1880, 1, 0, 0, 0, 1866, 1867, 5, 244, 0, 0, 1867, 1868, 3, 170, 85, 0, 1868, 1869, 6, 85, -1, 0, 1869, 1880, 1, 0, 0, 0, 1870, 1871, 3, 172, 86, 0, 1871, 1872, 6, 85, -1, 0, 1872, 1880, 1, 0, 0, 0, 1873, 1874, 5, 112, 0, 0, 1874, 1875, 5, 30, 0, 0, 1875, 1876, 3, 32, 16, 0, 1876, 1877, 5, 31, 0, 0, 1877, 1878, 6, 85, -1, 0, 1878, 1880, 1, 0, 0, 0, 1879, 1862, 1, 0, 0, 0, 1879, 1866, 1, 0, 0, 0, 1879, 1870, 1, 0, 0, 0, 1879, 1873, 1, 0, 0, 0, 1880, 171, 1, 0, 0, 0, 1881, 1901, 1, 0, 0, 0, 1882, 1883, 5, 245, 0, 0, 1883, 1901, 6, 86, -1, 0, 1884, 1885, 5, 246, 0, 0, 1885, 1901, 6, 86, -1, 0, 1886, 1887, 5, 247, 0, 0, 1887, 1888, 5, 248, 0, 0, 1888, 1901, 6, 86, -1, 0, 1889, 1890, 5, 247, 0, 0, 1890, 1891, 5, 249, 0, 0, 1891, 1901, 6, 86, -1, 0, 1892, 1893, 5, 247, 0, 0, 1893, 1894, 5, 250, 0, 0, 1894, 1901, 6, 86, -1, 0, 1895, 1896, 5, 247, 0, 0, 1896, 1897, 5, 251, 0, 0, 1897, 1901, 6, 86, -1, 0, 1898, 1899, 5, 247, 0, 0, 1899, 1901, 6, 86, -1, 0, 1900, 1881, 1, 0, 0, 0, 1900, 1882, 1, 0, 0, 0, 1900, 1884, 1, 0, 0, 0, 1900, 1886, 1, 0, 0, 0, 1900, 1889, 1, 0, 0, 0, 1900, 1892, 1, 0, 0, 0, 1900, 1895, 1, 0, 0, 0, 1900, 1898, 1, 0, 0, 0, 1901, 173, 1, 0, 0, 0, 1902, 1903, 5, 113, 0, 0, 1903, 1904, 5, 30, 0, 0, 1904, 1905, 3, 32, 16, 0, 1905, 1906, 5, 31, 0, 0, 1906, 1907, 6, 87, -1, 0, 1907, 175, 1, 0, 0, 0, 1908, 1909, 5, 226, 0, 0, 1909, 1910, 3, 168, 84, 0, 1910, 1911, 6, 88, -1, 0, 1911, 1920, 1, 0, 0, 0, 1912, 1913, 5, 37, 0, 0, 1913, 1914, 3, 178, 89, 0, 1914, 1915, 6, 88, -1, 0, 1915, 1920, 1, 0, 0, 0, 1916, 1917, 3, 174, 87, 0, 1917, 1918, 6, 88, -1, 0, 1918, 1920, 1, 0, 0, 0, 1919, 1908, 1, 0, 0, 0, 1919, 1912, 1, 0, 0, 0, 1919, 1916, 1, 0, 0, 0, 1920, 177, 1, 0, 0, 0, 1921, 1922, 3, 138, 69, 0, 1922, 1923, 3, 124, 62, 0, 1923, 1924, 5, 176, 0, 0, 1924, 1925, 3, 2, 1, 0, 1925, 1926, 6, 89, -1, 0, 1926, 1935, 1, 0, 0, 0, 1927, 1928, 3, 138, 69, 0, 1928, 1929, 3, 2, 1, 0, 1929, 1930, 6, 89, -1, 0, 1930, 1935, 1, 0, 0, 0, 1931, 1932, 3, 2, 1, 0, 1932, 1933, 6, 89, -1, 0, 1933, 1935, 1, 0, 0, 0, 1934, 1921, 1, 0, 0, 0, 1934, 1927, 1, 0, 0, 0, 1934, 1931, 1, 0, 0, 0, 1935, 179, 1, 0, 0, 0, 1936, 1937, 3, 124, 62, 0, 1937, 1938, 5, 28, 0, 0, 1938, 1940, 1, 0, 0, 0, 1939, 1936, 1, 0, 0, 0, 1940, 1943, 1, 0, 0, 0, 1941, 1939, 1, 0, 0, 0, 1941, 1942, 1, 0, 0, 0, 1942, 1944, 1, 0, 0, 0, 1943, 1941, 1, 0, 0, 0, 1944, 1945, 3, 124, 62, 0, 1945, 181, 1, 0, 0, 0, 1946, 1952, 1, 0, 0, 0, 1947, 1948, 5, 86, 0, 0, 1948, 1949, 3, 190, 95, 0, 1949, 1950, 5, 87, 0, 0, 1950, 1952, 1, 0, 0, 0, 1951, 1946, 1, 0, 0, 0, 1951, 1947, 1, 0, 0, 0, 1952, 183, 1, 0, 0, 0, 1953, 1965, 5, 266, 0, 0, 1954, 1965, 5, 114, 0, 0, 1955, 1965, 5, 39, 0, 0, 1956, 1965, 5, 200, 0, 0, 1957, 1965, 5, 115, 0, 0, 1958, 1965, 5, 116, 0, 0, 1959, 1960, 5, 70, 0, 0, 1960, 1961, 5, 30, 0, 0, 1961, 1962, 3, 32, 16, 0, 1962, 1963, 5, 31, 0, 0, 1963, 1965, 1, 0, 0, 0, 1964, 1953, 1, 0, 0, 0, 1964, 1954, 1, 0, 0, 0, 1964, 1955, 1, 0, 0, 0, 1964, 1956, 1, 0, 0, 0, 1964, 1957, 1, 0, 0, 0, 1964, 1958, 1, 0, 0, 0, 1964, 1959, 1, 0, 0, 0, 1965, 185, 1, 0, 0, 0, 1966, 1968, 3, 184, 92, 0, 1967, 1966, 1, 0, 0, 0, 1968, 1971, 1, 0, 0, 0, 1969, 1967, 1, 0, 0, 0, 1969, 1970, 1, 0, 0, 0, 1970, 187, 1, 0, 0, 0, 1971, 1969, 1, 0, 0, 0, 1972, 1974, 3, 186, 93, 0, 1973, 1975, 3, 192, 96, 0, 1974, 1973, 1, 0, 0, 0, 1974, 1975, 1, 0, 0, 0, 1975, 1976, 1, 0, 0, 0, 1976, 1977, 3, 2, 1, 0, 1977, 189, 1, 0, 0, 0, 1978, 1979, 3, 188, 94, 0, 1979, 1980, 5, 28, 0, 0, 1980, 1982, 1, 0, 0, 0, 1981, 1978, 1, 0, 0, 0, 1982, 1985, 1, 0, 0, 0, 1983, 1981, 1, 0, 0, 0, 1983, 1984, 1, 0, 0, 0, 1984, 1986, 1, 0, 0, 0, 1985, 1983, 1, 0, 0, 0, 1986, 1987, 3, 188, 94, 0, 1987, 191, 1, 0, 0, 0, 1988, 1989, 5, 30, 0, 0, 1989, 1990, 3, 180, 90, 0, 1990, 1991, 5, 31, 0, 0, 1991, 193, 1, 0, 0, 0, 1992, 1994, 3, 196, 98, 0, 1993, 1992, 1, 0, 0, 0, 1993, 1994, 1, 0, 0, 0, 1994, 1995, 1, 0, 0, 0, 1995, 1996, 6, 97, -1, 0, 1996, 195, 1, 0, 0, 0, 1997, 1998, 5, 86, 0, 0, 1998, 1999, 5, 42, 0, 0, 1999, 2000, 3, 32, 16, 0, 2000, 2001, 5, 43, 0, 0, 2001, 2002, 5, 87, 0, 0, 2002, 2003, 6, 98, -1, 0, 2003, 197, 1, 0, 0, 0, 2004, 2005, 3, 234, 117, 0, 2005, 2006, 5, 17, 0, 0, 2006, 2007, 3, 246, 123, 0, 2007, 2008, 5, 18, 0, 0, 2008, 2121, 1, 0, 0, 0, 2009, 2010, 3, 74, 37, 0, 2010, 2011, 5, 17, 0, 0, 2011, 2012, 3, 82, 41, 0, 2012, 2013, 5, 18, 0, 0, 2013, 2121, 1, 0, 0, 0, 2014, 2015, 3, 210, 105, 0, 2015, 2016, 5, 17, 0, 0, 2016, 2017, 3, 214, 107, 0, 2017, 2018, 5, 18, 0, 0, 2018, 2121, 1, 0, 0, 0, 2019, 2020, 3, 218, 109, 0, 2020, 2021, 5, 17, 0, 0, 2021, 2022, 3, 222, 111, 0, 2022, 2023, 5, 18, 0, 0, 2023, 2121, 1, 0, 0, 0, 2024, 2121, 3, 200, 100, 0, 2025, 2121, 3, 284, 142, 0, 2026, 2121, 3, 152, 76, 0, 2027, 2121, 3, 88, 44, 0, 2028, 2121, 3, 330, 165, 0, 2029, 2030, 5, 117, 0, 0, 2030, 2121, 3, 32, 16, 0, 2031, 2032, 5, 118, 0, 0, 2032, 2121, 3, 32, 16, 0, 2033, 2034, 3, 342, 171, 0, 2034, 2035, 5, 17, 0, 0, 2035, 2036, 3, 346, 173, 0, 2036, 2037, 5, 18, 0, 0, 2037, 2121, 1, 0, 0, 0, 2038, 2039, 5, 302, 0, 0, 2039, 2040, 3, 124, 62, 0, 2040, 2041, 5, 176, 0, 0, 2041, 2042, 3, 242, 121, 0, 2042, 2043, 5, 119, 0, 0, 2043, 2044, 3, 170, 85, 0, 2044, 2045, 3, 138, 69, 0, 2045, 2046, 3, 124, 62, 0, 2046, 2047, 5, 176, 0, 0, 2047, 2048, 3, 242, 121, 0, 2048, 2049, 3, 112, 56, 0, 2049, 2121, 1, 0, 0, 0, 2050, 2051, 5, 302, 0, 0, 2051, 2052, 5, 226, 0, 0, 2052, 2053, 3, 170, 85, 0, 2053, 2054, 3, 138, 69, 0, 2054, 2055, 3, 124, 62, 0, 2055, 2056, 5, 176, 0, 0, 2056, 2057, 3, 242, 121, 0, 2057, 2058, 3, 194, 97, 0, 2058, 2059, 3, 112, 56, 0, 2059, 2060, 5, 119, 0, 0, 2060, 2061, 5, 226, 0, 0, 2061, 2062, 3, 170, 85, 0, 2062, 2063, 3, 138, 69, 0, 2063, 2064, 3, 124, 62, 0, 2064, 2065, 5, 176, 0, 0, 2065, 2066, 3, 242, 121, 0, 2066, 2067, 3, 194, 97, 0, 2067, 2068, 3, 112, 56, 0, 2068, 2121, 1, 0, 0, 0, 2069, 2121, 3, 26, 13, 0, 2070, 2121, 3, 40, 20, 0, 2071, 2072, 5, 255, 0, 0, 2072, 2073, 5, 196, 0, 0, 2073, 2074, 5, 42, 0, 0, 2074, 2075, 3, 32, 16, 0, 2075, 2079, 5, 43, 0, 0, 2076, 2078, 3, 330, 165, 0, 2077, 2076, 1, 0, 0, 0, 2078, 2081, 1, 0, 0, 0, 2079, 2077, 1, 0, 0, 0, 2079, 2080, 1, 0, 0, 0, 2080, 2121, 1, 0, 0, 0, 2081, 2079, 1, 0, 0, 0, 2082, 2083, 5, 255, 0, 0, 2083, 2084, 5, 196, 0, 0, 2084, 2088, 3, 2, 1, 0, 2085, 2087, 3, 330, 165, 0, 2086, 2085, 1, 0, 0, 0, 2087, 2090, 1, 0, 0, 0, 2088, 2086, 1, 0, 0, 0, 2088, 2089, 1, 0, 0, 0, 2089, 2121, 1, 0, 0, 0, 2090, 2088, 1, 0, 0, 0, 2091, 2092, 5, 255, 0, 0, 2092, 2093, 5, 256, 0, 0, 2093, 2094, 5, 42, 0, 0, 2094, 2095, 3, 32, 16, 0, 2095, 2096, 5, 43, 0, 0, 2096, 2097, 5, 28, 0, 0, 2097, 2101, 3, 124, 62, 0, 2098, 2100, 3, 330, 165, 0, 2099, 2098, 1, 0, 0, 0, 2100, 2103, 1, 0, 0, 0, 2101, 2099, 1, 0, 0, 0, 2101, 2102, 1, 0, 0, 0, 2102, 2121, 1, 0, 0, 0, 2103, 2101, 1, 0, 0, 0, 2104, 2105, 5, 255, 0, 0, 2105, 2106, 5, 256, 0, 0, 2106, 2107, 3, 2, 1, 0, 2107, 2108, 5, 28, 0, 0, 2108, 2112, 3, 124, 62, 0, 2109, 2111, 3, 330, 165, 0, 2110, 2109, 1, 0, 0, 0, 2111, 2114, 1, 0, 0, 0, 2112, 2110, 1, 0, 0, 0, 2112, 2113, 1, 0, 0, 0, 2113, 2121, 1, 0, 0, 0, 2114, 2112, 1, 0, 0, 0, 2115, 2116, 5, 120, 0, 0, 2116, 2117, 5, 196, 0, 0, 2117, 2118, 3, 124, 62, 0, 2118, 2119, 3, 44, 22, 0, 2119, 2121, 1, 0, 0, 0, 2120, 2004, 1, 0, 0, 0, 2120, 2009, 1, 0, 0, 0, 2120, 2014, 1, 0, 0, 0, 2120, 2019, 1, 0, 0, 0, 2120, 2024, 1, 0, 0, 0, 2120, 2025, 1, 0, 0, 0, 2120, 2026, 1, 0, 0, 0, 2120, 2027, 1, 0, 0, 0, 2120, 2028, 1, 0, 0, 0, 2120, 2029, 1, 0, 0, 0, 2120, 2031, 1, 0, 0, 0, 2120, 2033, 1, 0, 0, 0, 2120, 2038, 1, 0, 0, 0, 2120, 2050, 1, 0, 0, 0, 2120, 2069, 1, 0, 0, 0, 2120, 2070, 1, 0, 0, 0, 2120, 2071, 1, 0, 0, 0, 2120, 2082, 1, 0, 0, 0, 2120, 2091, 1, 0, 0, 0, 2120, 2104, 1, 0, 0, 0, 2120, 2115, 1, 0, 0, 0, 2121, 199, 1, 0, 0, 0, 2122, 2123, 5, 121, 0, 0, 2123, 2132, 3, 208, 104, 0, 2124, 2131, 3, 202, 101, 0, 2125, 2126, 5, 122, 0, 0, 2126, 2127, 5, 30, 0, 0, 2127, 2128, 3, 228, 114, 0, 2128, 2129, 5, 31, 0, 0, 2129, 2131, 1, 0, 0, 0, 2130, 2124, 1, 0, 0, 0, 2130, 2125, 1, 0, 0, 0, 2131, 2134, 1, 0, 0, 0, 2132, 2130, 1, 0, 0, 0, 2132, 2133, 1, 0, 0, 0, 2133, 2135, 1, 0, 0, 0, 2134, 2132, 1, 0, 0, 0, 2135, 2136, 3, 138, 69, 0, 2136, 2137, 3, 2, 1, 0, 2137, 2138, 3, 204, 102, 0, 2138, 2139, 3, 206, 103, 0, 2139, 201, 1, 0, 0, 0, 2140, 2160, 5, 123, 0, 0, 2141, 2160, 5, 51, 0, 0, 2142, 2160, 5, 52, 0, 0, 2143, 2160, 5, 63, 0, 0, 2144, 2160, 5, 124, 0, 0, 2145, 2160, 5, 69, 0, 0, 2146, 2160, 5, 68, 0, 0, 2147, 2160, 5, 64, 0, 0, 2148, 2160, 5, 65, 0, 0, 2149, 2160, 5, 66, 0, 0, 2150, 2160, 5, 125, 0, 0, 2151, 2160, 5, 126, 0, 0, 2152, 2160, 5, 127, 0, 0, 2153, 2160, 5, 16, 0, 0, 2154, 2155, 5, 70, 0, 0, 2155, 2156, 5, 30, 0, 0, 2156, 2157, 3, 32, 16, 0, 2157, 2158, 5, 31, 0, 0, 2158, 2160, 1, 0, 0, 0, 2159, 2140, 1, 0, 0, 0, 2159, 2141, 1, 0, 0, 0, 2159, 2142, 1, 0, 0, 0, 2159, 2143, 1, 0, 0, 0, 2159, 2144, 1, 0, 0, 0, 2159, 2145, 1, 0, 0, 0, 2159, 2146, 1, 0, 0, 0, 2159, 2147, 1, 0, 0, 0, 2159, 2148, 1, 0, 0, 0, 2159, 2149, 1, 0, 0, 0, 2159, 2150, 1, 0, 0, 0, 2159, 2151, 1, 0, 0, 0, 2159, 2152, 1, 0, 0, 0, 2159, 2153, 1, 0, 0, 0, 2159, 2154, 1, 0, 0, 0, 2160, 203, 1, 0, 0, 0, 2161, 2167, 1, 0, 0, 0, 2162, 2163, 5, 44, 0, 0, 2163, 2167, 3, 0, 0, 0, 2164, 2165, 5, 44, 0, 0, 2165, 2167, 3, 32, 16, 0, 2166, 2161, 1, 0, 0, 0, 2166, 2162, 1, 0, 0, 0, 2166, 2164, 1, 0, 0, 0, 2167, 205, 1, 0, 0, 0, 2168, 2172, 1, 0, 0, 0, 2169, 2170, 5, 36, 0, 0, 2170, 2172, 3, 304, 152, 0, 2171, 2168, 1, 0, 0, 0, 2171, 2169, 1, 0, 0, 0, 2172, 207, 1, 0, 0, 0, 2173, 2179, 1, 0, 0, 0, 2174, 2175, 5, 42, 0, 0, 2175, 2176, 3, 32, 16, 0, 2176, 2177, 5, 43, 0, 0, 2177, 2179, 1, 0, 0, 0, 2178, 2173, 1, 0, 0, 0, 2178, 2174, 1, 0, 0, 0, 2179, 209, 1, 0, 0, 0, 2180, 2184, 5, 128, 0, 0, 2181, 2183, 3, 212, 106, 0, 2182, 2181, 1, 0, 0, 0, 2183, 2186, 1, 0, 0, 0, 2184, 2182, 1, 0, 0, 0, 2184, 2185, 1, 0, 0, 0, 2185, 2187, 1, 0, 0, 0, 2186, 2184, 1, 0, 0, 0, 2187, 2188, 3, 124, 62, 0, 2188, 2189, 3, 2, 1, 0, 2189, 2199, 1, 0, 0, 0, 2190, 2194, 5, 128, 0, 0, 2191, 2193, 3, 212, 106, 0, 2192, 2191, 1, 0, 0, 0, 2193, 2196, 1, 0, 0, 0, 2194, 2192, 1, 0, 0, 0, 2194, 2195, 1, 0, 0, 0, 2195, 2197, 1, 0, 0, 0, 2196, 2194, 1, 0, 0, 0, 2197, 2199, 3, 2, 1, 0, 2198, 2180, 1, 0, 0, 0, 2198, 2190, 1, 0, 0, 0, 2199, 211, 1, 0, 0, 0, 2200, 2201, 7, 10, 0, 0, 2201, 213, 1, 0, 0, 0, 2202, 2204, 3, 216, 108, 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, 215, 1, 0, 0, 0, 2207, 2205, 1, 0, 0, 0, 2208, 2209, 5, 129, 0, 0, 2209, 2221, 3, 168, 84, 0, 2210, 2211, 5, 130, 0, 0, 2211, 2221, 3, 168, 84, 0, 2212, 2213, 5, 131, 0, 0, 2213, 2221, 3, 168, 84, 0, 2214, 2215, 5, 132, 0, 0, 2215, 2221, 3, 168, 84, 0, 2216, 2221, 3, 88, 44, 0, 2217, 2221, 3, 330, 165, 0, 2218, 2221, 3, 26, 13, 0, 2219, 2221, 3, 40, 20, 0, 2220, 2208, 1, 0, 0, 0, 2220, 2210, 1, 0, 0, 0, 2220, 2212, 1, 0, 0, 0, 2220, 2214, 1, 0, 0, 0, 2220, 2216, 1, 0, 0, 0, 2220, 2217, 1, 0, 0, 0, 2220, 2218, 1, 0, 0, 0, 2220, 2219, 1, 0, 0, 0, 2221, 217, 1, 0, 0, 0, 2222, 2226, 5, 133, 0, 0, 2223, 2225, 3, 220, 110, 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, 2230, 3, 170, 85, 0, 2230, 2231, 3, 138, 69, 0, 2231, 2232, 3, 2, 1, 0, 2232, 2233, 3, 112, 56, 0, 2233, 2234, 3, 206, 103, 0, 2234, 219, 1, 0, 0, 0, 2235, 2236, 7, 10, 0, 0, 2236, 221, 1, 0, 0, 0, 2237, 2239, 3, 224, 112, 0, 2238, 2237, 1, 0, 0, 0, 2239, 2242, 1, 0, 0, 0, 2240, 2238, 1, 0, 0, 0, 2240, 2241, 1, 0, 0, 0, 2241, 223, 1, 0, 0, 0, 2242, 2240, 1, 0, 0, 0, 2243, 2244, 5, 134, 0, 0, 2244, 2254, 3, 168, 84, 0, 2245, 2246, 5, 135, 0, 0, 2246, 2254, 3, 168, 84, 0, 2247, 2248, 5, 132, 0, 0, 2248, 2254, 3, 168, 84, 0, 2249, 2254, 3, 330, 165, 0, 2250, 2254, 3, 88, 44, 0, 2251, 2254, 3, 26, 13, 0, 2252, 2254, 3, 40, 20, 0, 2253, 2243, 1, 0, 0, 0, 2253, 2245, 1, 0, 0, 0, 2253, 2247, 1, 0, 0, 0, 2253, 2249, 1, 0, 0, 0, 2253, 2250, 1, 0, 0, 0, 2253, 2251, 1, 0, 0, 0, 2253, 2252, 1, 0, 0, 0, 2254, 225, 1, 0, 0, 0, 2255, 2263, 6, 113, -1, 0, 2256, 2257, 5, 122, 0, 0, 2257, 2258, 5, 30, 0, 0, 2258, 2259, 3, 228, 114, 0, 2259, 2260, 5, 31, 0, 0, 2260, 2261, 6, 113, -1, 0, 2261, 2263, 1, 0, 0, 0, 2262, 2255, 1, 0, 0, 0, 2262, 2256, 1, 0, 0, 0, 2263, 227, 1, 0, 0, 0, 2264, 2265, 3, 126, 63, 0, 2265, 2266, 6, 114, -1, 0, 2266, 2278, 1, 0, 0, 0, 2267, 2271, 5, 17, 0, 0, 2268, 2269, 3, 302, 151, 0, 2269, 2270, 6, 114, -1, 0, 2270, 2272, 1, 0, 0, 0, 2271, 2268, 1, 0, 0, 0, 2272, 2273, 1, 0, 0, 0, 2273, 2271, 1, 0, 0, 0, 2273, 2274, 1, 0, 0, 0, 2274, 2275, 1, 0, 0, 0, 2275, 2276, 5, 18, 0, 0, 2276, 2278, 1, 0, 0, 0, 2277, 2264, 1, 0, 0, 0, 2277, 2267, 1, 0, 0, 0, 2278, 229, 1, 0, 0, 0, 2279, 2280, 3, 232, 116, 0, 2280, 2281, 6, 115, -1, 0, 2281, 2283, 1, 0, 0, 0, 2282, 2279, 1, 0, 0, 0, 2283, 2286, 1, 0, 0, 0, 2284, 2282, 1, 0, 0, 0, 2284, 2285, 1, 0, 0, 0, 2285, 231, 1, 0, 0, 0, 2286, 2284, 1, 0, 0, 0, 2287, 2288, 5, 42, 0, 0, 2288, 2289, 5, 136, 0, 0, 2289, 2290, 5, 43, 0, 0, 2290, 2305, 6, 116, -1, 0, 2291, 2292, 5, 42, 0, 0, 2292, 2293, 5, 137, 0, 0, 2293, 2294, 5, 43, 0, 0, 2294, 2305, 6, 116, -1, 0, 2295, 2296, 5, 42, 0, 0, 2296, 2297, 5, 138, 0, 0, 2297, 2298, 5, 43, 0, 0, 2298, 2305, 6, 116, -1, 0, 2299, 2300, 5, 42, 0, 0, 2300, 2301, 3, 32, 16, 0, 2301, 2302, 5, 43, 0, 0, 2302, 2303, 6, 116, -1, 0, 2303, 2305, 1, 0, 0, 0, 2304, 2287, 1, 0, 0, 0, 2304, 2291, 1, 0, 0, 0, 2304, 2295, 1, 0, 0, 0, 2304, 2299, 1, 0, 0, 0, 2305, 233, 1, 0, 0, 0, 2306, 2311, 5, 139, 0, 0, 2307, 2310, 3, 236, 118, 0, 2308, 2310, 3, 238, 119, 0, 2309, 2307, 1, 0, 0, 0, 2309, 2308, 1, 0, 0, 0, 2310, 2313, 1, 0, 0, 0, 2311, 2309, 1, 0, 0, 0, 2311, 2312, 1, 0, 0, 0, 2312, 2314, 1, 0, 0, 0, 2313, 2311, 1, 0, 0, 0, 2314, 2315, 3, 170, 85, 0, 2315, 2316, 3, 230, 115, 0, 2316, 2317, 3, 138, 69, 0, 2317, 2318, 3, 226, 113, 0, 2318, 2319, 3, 242, 121, 0, 2319, 2320, 3, 182, 91, 0, 2320, 2324, 3, 112, 56, 0, 2321, 2323, 3, 244, 122, 0, 2322, 2321, 1, 0, 0, 0, 2323, 2326, 1, 0, 0, 0, 2324, 2322, 1, 0, 0, 0, 2324, 2325, 1, 0, 0, 0, 2325, 235, 1, 0, 0, 0, 2326, 2324, 1, 0, 0, 0, 2327, 2351, 5, 123, 0, 0, 2328, 2351, 5, 51, 0, 0, 2329, 2351, 5, 52, 0, 0, 2330, 2351, 5, 63, 0, 0, 2331, 2351, 5, 140, 0, 0, 2332, 2351, 5, 68, 0, 0, 2333, 2351, 5, 141, 0, 0, 2334, 2351, 5, 142, 0, 0, 2335, 2351, 5, 54, 0, 0, 2336, 2351, 5, 64, 0, 0, 2337, 2351, 5, 65, 0, 0, 2338, 2351, 5, 66, 0, 0, 2339, 2351, 5, 125, 0, 0, 2340, 2351, 5, 143, 0, 0, 2341, 2351, 5, 144, 0, 0, 2342, 2351, 5, 69, 0, 0, 2343, 2351, 5, 145, 0, 0, 2344, 2351, 5, 146, 0, 0, 2345, 2346, 5, 70, 0, 0, 2346, 2347, 5, 30, 0, 0, 2347, 2348, 3, 32, 16, 0, 2348, 2349, 5, 31, 0, 0, 2349, 2351, 1, 0, 0, 0, 2350, 2327, 1, 0, 0, 0, 2350, 2328, 1, 0, 0, 0, 2350, 2329, 1, 0, 0, 0, 2350, 2330, 1, 0, 0, 0, 2350, 2331, 1, 0, 0, 0, 2350, 2332, 1, 0, 0, 0, 2350, 2333, 1, 0, 0, 0, 2350, 2334, 1, 0, 0, 0, 2350, 2335, 1, 0, 0, 0, 2350, 2336, 1, 0, 0, 0, 2350, 2337, 1, 0, 0, 0, 2350, 2338, 1, 0, 0, 0, 2350, 2339, 1, 0, 0, 0, 2350, 2340, 1, 0, 0, 0, 2350, 2341, 1, 0, 0, 0, 2350, 2342, 1, 0, 0, 0, 2350, 2343, 1, 0, 0, 0, 2350, 2344, 1, 0, 0, 0, 2350, 2345, 1, 0, 0, 0, 2351, 237, 1, 0, 0, 0, 2352, 2353, 5, 147, 0, 0, 2353, 2359, 5, 30, 0, 0, 2354, 2357, 3, 6, 3, 0, 2355, 2356, 5, 34, 0, 0, 2356, 2358, 3, 6, 3, 0, 2357, 2355, 1, 0, 0, 0, 2357, 2358, 1, 0, 0, 0, 2358, 2360, 1, 0, 0, 0, 2359, 2354, 1, 0, 0, 0, 2359, 2360, 1, 0, 0, 0, 2360, 2364, 1, 0, 0, 0, 2361, 2363, 3, 240, 120, 0, 2362, 2361, 1, 0, 0, 0, 2363, 2366, 1, 0, 0, 0, 2364, 2362, 1, 0, 0, 0, 2364, 2365, 1, 0, 0, 0, 2365, 2367, 1, 0, 0, 0, 2366, 2364, 1, 0, 0, 0, 2367, 2371, 5, 31, 0, 0, 2368, 2369, 5, 147, 0, 0, 2369, 2371, 5, 85, 0, 0, 2370, 2352, 1, 0, 0, 0, 2370, 2368, 1, 0, 0, 0, 2371, 239, 1, 0, 0, 0, 2372, 2400, 5, 148, 0, 0, 2373, 2400, 5, 224, 0, 0, 2374, 2400, 5, 57, 0, 0, 2375, 2400, 5, 58, 0, 0, 2376, 2400, 5, 149, 0, 0, 2377, 2400, 5, 150, 0, 0, 2378, 2400, 5, 248, 0, 0, 2379, 2400, 5, 249, 0, 0, 2380, 2400, 5, 250, 0, 0, 2381, 2400, 5, 251, 0, 0, 2382, 2383, 5, 151, 0, 0, 2383, 2384, 5, 75, 0, 0, 2384, 2400, 5, 152, 0, 0, 2385, 2386, 5, 151, 0, 0, 2386, 2387, 5, 75, 0, 0, 2387, 2400, 5, 153, 0, 0, 2388, 2389, 5, 154, 0, 0, 2389, 2390, 5, 75, 0, 0, 2390, 2400, 5, 152, 0, 0, 2391, 2392, 5, 154, 0, 0, 2392, 2393, 5, 75, 0, 0, 2393, 2400, 5, 153, 0, 0, 2394, 2395, 5, 70, 0, 0, 2395, 2396, 5, 30, 0, 0, 2396, 2397, 3, 32, 16, 0, 2397, 2398, 5, 31, 0, 0, 2398, 2400, 1, 0, 0, 0, 2399, 2372, 1, 0, 0, 0, 2399, 2373, 1, 0, 0, 0, 2399, 2374, 1, 0, 0, 0, 2399, 2375, 1, 0, 0, 0, 2399, 2376, 1, 0, 0, 0, 2399, 2377, 1, 0, 0, 0, 2399, 2378, 1, 0, 0, 0, 2399, 2379, 1, 0, 0, 0, 2399, 2380, 1, 0, 0, 0, 2399, 2381, 1, 0, 0, 0, 2399, 2382, 1, 0, 0, 0, 2399, 2385, 1, 0, 0, 0, 2399, 2388, 1, 0, 0, 0, 2399, 2391, 1, 0, 0, 0, 2399, 2394, 1, 0, 0, 0, 2400, 241, 1, 0, 0, 0, 2401, 2402, 5, 116, 0, 0, 2402, 2409, 6, 121, -1, 0, 2403, 2404, 5, 155, 0, 0, 2404, 2409, 6, 121, -1, 0, 2405, 2406, 3, 2, 1, 0, 2406, 2407, 6, 121, -1, 0, 2407, 2409, 1, 0, 0, 0, 2408, 2401, 1, 0, 0, 0, 2408, 2403, 1, 0, 0, 0, 2408, 2405, 1, 0, 0, 0, 2409, 243, 1, 0, 0, 0, 2410, 2432, 5, 1, 0, 0, 2411, 2432, 5, 2, 0, 0, 2412, 2432, 5, 156, 0, 0, 2413, 2432, 5, 3, 0, 0, 2414, 2432, 5, 4, 0, 0, 2415, 2432, 5, 247, 0, 0, 2416, 2432, 5, 5, 0, 0, 2417, 2432, 5, 6, 0, 0, 2418, 2432, 5, 7, 0, 0, 2419, 2432, 5, 8, 0, 0, 2420, 2432, 5, 9, 0, 0, 2421, 2432, 5, 10, 0, 0, 2422, 2432, 5, 11, 0, 0, 2423, 2432, 5, 12, 0, 0, 2424, 2432, 5, 13, 0, 0, 2425, 2432, 5, 14, 0, 0, 2426, 2427, 5, 70, 0, 0, 2427, 2428, 5, 30, 0, 0, 2428, 2429, 3, 32, 16, 0, 2429, 2430, 5, 31, 0, 0, 2430, 2432, 1, 0, 0, 0, 2431, 2410, 1, 0, 0, 0, 2431, 2411, 1, 0, 0, 0, 2431, 2412, 1, 0, 0, 0, 2431, 2413, 1, 0, 0, 0, 2431, 2414, 1, 0, 0, 0, 2431, 2415, 1, 0, 0, 0, 2431, 2416, 1, 0, 0, 0, 2431, 2417, 1, 0, 0, 0, 2431, 2418, 1, 0, 0, 0, 2431, 2419, 1, 0, 0, 0, 2431, 2420, 1, 0, 0, 0, 2431, 2421, 1, 0, 0, 0, 2431, 2422, 1, 0, 0, 0, 2431, 2423, 1, 0, 0, 0, 2431, 2424, 1, 0, 0, 0, 2431, 2425, 1, 0, 0, 0, 2431, 2426, 1, 0, 0, 0, 2432, 245, 1, 0, 0, 0, 2433, 2435, 3, 248, 124, 0, 2434, 2433, 1, 0, 0, 0, 2435, 2438, 1, 0, 0, 0, 2436, 2434, 1, 0, 0, 0, 2436, 2437, 1, 0, 0, 0, 2437, 247, 1, 0, 0, 0, 2438, 2436, 1, 0, 0, 0, 2439, 2477, 3, 100, 50, 0, 2440, 2441, 5, 296, 0, 0, 2441, 2442, 3, 32, 16, 0, 2442, 2443, 6, 124, -1, 0, 2443, 2477, 1, 0, 0, 0, 2444, 2477, 3, 266, 133, 0, 2445, 2446, 5, 297, 0, 0, 2446, 2447, 3, 32, 16, 0, 2447, 2448, 6, 124, -1, 0, 2448, 2477, 1, 0, 0, 0, 2449, 2450, 5, 298, 0, 0, 2450, 2477, 6, 124, -1, 0, 2451, 2452, 5, 299, 0, 0, 2452, 2477, 6, 124, -1, 0, 2453, 2477, 3, 260, 130, 0, 2454, 2477, 3, 264, 132, 0, 2455, 2477, 3, 250, 125, 0, 2456, 2457, 3, 284, 142, 0, 2457, 2458, 6, 124, -1, 0, 2458, 2477, 1, 0, 0, 0, 2459, 2460, 3, 152, 76, 0, 2460, 2461, 6, 124, -1, 0, 2461, 2477, 1, 0, 0, 0, 2462, 2463, 3, 88, 44, 0, 2463, 2464, 6, 124, -1, 0, 2464, 2477, 1, 0, 0, 0, 2465, 2466, 3, 26, 13, 0, 2466, 2467, 6, 124, -1, 0, 2467, 2477, 1, 0, 0, 0, 2468, 2469, 3, 262, 131, 0, 2469, 2470, 6, 124, -1, 0, 2470, 2477, 1, 0, 0, 0, 2471, 2477, 3, 40, 20, 0, 2472, 2477, 3, 252, 126, 0, 2473, 2477, 3, 254, 127, 0, 2474, 2477, 3, 256, 128, 0, 2475, 2477, 3, 258, 129, 0, 2476, 2439, 1, 0, 0, 0, 2476, 2440, 1, 0, 0, 0, 2476, 2444, 1, 0, 0, 0, 2476, 2445, 1, 0, 0, 0, 2476, 2449, 1, 0, 0, 0, 2476, 2451, 1, 0, 0, 0, 2476, 2453, 1, 0, 0, 0, 2476, 2454, 1, 0, 0, 0, 2476, 2455, 1, 0, 0, 0, 2476, 2456, 1, 0, 0, 0, 2476, 2459, 1, 0, 0, 0, 2476, 2462, 1, 0, 0, 0, 2476, 2465, 1, 0, 0, 0, 2476, 2468, 1, 0, 0, 0, 2476, 2471, 1, 0, 0, 0, 2476, 2472, 1, 0, 0, 0, 2476, 2473, 1, 0, 0, 0, 2476, 2474, 1, 0, 0, 0, 2476, 2475, 1, 0, 0, 0, 2477, 249, 1, 0, 0, 0, 2478, 2480, 5, 300, 0, 0, 2479, 2481, 5, 157, 0, 0, 2480, 2479, 1, 0, 0, 0, 2480, 2481, 1, 0, 0, 0, 2481, 2482, 1, 0, 0, 0, 2482, 2483, 3, 112, 56, 0, 2483, 251, 1, 0, 0, 0, 2484, 2485, 5, 301, 0, 0, 2485, 2486, 5, 42, 0, 0, 2486, 2487, 3, 32, 16, 0, 2487, 2490, 5, 43, 0, 0, 2488, 2489, 5, 34, 0, 0, 2489, 2491, 3, 0, 0, 0, 2490, 2488, 1, 0, 0, 0, 2490, 2491, 1, 0, 0, 0, 2491, 253, 1, 0, 0, 0, 2492, 2493, 5, 303, 0, 0, 2493, 2494, 3, 32, 16, 0, 2494, 2495, 5, 75, 0, 0, 2495, 2496, 3, 32, 16, 0, 2496, 255, 1, 0, 0, 0, 2497, 2498, 5, 302, 0, 0, 2498, 2499, 3, 124, 62, 0, 2499, 2500, 5, 176, 0, 0, 2500, 2501, 3, 242, 121, 0, 2501, 2513, 1, 0, 0, 0, 2502, 2503, 5, 302, 0, 0, 2503, 2504, 5, 226, 0, 0, 2504, 2505, 3, 170, 85, 0, 2505, 2506, 3, 138, 69, 0, 2506, 2507, 3, 124, 62, 0, 2507, 2508, 5, 176, 0, 0, 2508, 2509, 3, 242, 121, 0, 2509, 2510, 3, 194, 97, 0, 2510, 2511, 3, 112, 56, 0, 2511, 2513, 1, 0, 0, 0, 2512, 2497, 1, 0, 0, 0, 2512, 2502, 1, 0, 0, 0, 2513, 257, 1, 0, 0, 0, 2514, 2515, 5, 255, 0, 0, 2515, 2516, 5, 196, 0, 0, 2516, 2517, 5, 42, 0, 0, 2517, 2518, 3, 32, 16, 0, 2518, 2524, 5, 43, 0, 0, 2519, 2520, 3, 330, 165, 0, 2520, 2521, 6, 129, -1, 0, 2521, 2523, 1, 0, 0, 0, 2522, 2519, 1, 0, 0, 0, 2523, 2526, 1, 0, 0, 0, 2524, 2522, 1, 0, 0, 0, 2524, 2525, 1, 0, 0, 0, 2525, 2580, 1, 0, 0, 0, 2526, 2524, 1, 0, 0, 0, 2527, 2528, 5, 255, 0, 0, 2528, 2529, 5, 196, 0, 0, 2529, 2535, 3, 2, 1, 0, 2530, 2531, 3, 330, 165, 0, 2531, 2532, 6, 129, -1, 0, 2532, 2534, 1, 0, 0, 0, 2533, 2530, 1, 0, 0, 0, 2534, 2537, 1, 0, 0, 0, 2535, 2533, 1, 0, 0, 0, 2535, 2536, 1, 0, 0, 0, 2536, 2580, 1, 0, 0, 0, 2537, 2535, 1, 0, 0, 0, 2538, 2539, 5, 255, 0, 0, 2539, 2540, 5, 256, 0, 0, 2540, 2541, 5, 42, 0, 0, 2541, 2542, 3, 32, 16, 0, 2542, 2543, 5, 43, 0, 0, 2543, 2544, 5, 28, 0, 0, 2544, 2550, 3, 124, 62, 0, 2545, 2546, 3, 330, 165, 0, 2546, 2547, 6, 129, -1, 0, 2547, 2549, 1, 0, 0, 0, 2548, 2545, 1, 0, 0, 0, 2549, 2552, 1, 0, 0, 0, 2550, 2548, 1, 0, 0, 0, 2550, 2551, 1, 0, 0, 0, 2551, 2580, 1, 0, 0, 0, 2552, 2550, 1, 0, 0, 0, 2553, 2554, 5, 255, 0, 0, 2554, 2555, 5, 256, 0, 0, 2555, 2556, 3, 2, 1, 0, 2556, 2557, 5, 28, 0, 0, 2557, 2563, 3, 124, 62, 0, 2558, 2559, 3, 330, 165, 0, 2559, 2560, 6, 129, -1, 0, 2560, 2562, 1, 0, 0, 0, 2561, 2558, 1, 0, 0, 0, 2562, 2565, 1, 0, 0, 0, 2563, 2561, 1, 0, 0, 0, 2563, 2564, 1, 0, 0, 0, 2564, 2580, 1, 0, 0, 0, 2565, 2563, 1, 0, 0, 0, 2566, 2567, 5, 255, 0, 0, 2567, 2568, 5, 42, 0, 0, 2568, 2569, 3, 32, 16, 0, 2569, 2570, 5, 43, 0, 0, 2570, 2576, 3, 206, 103, 0, 2571, 2572, 3, 330, 165, 0, 2572, 2573, 6, 129, -1, 0, 2573, 2575, 1, 0, 0, 0, 2574, 2571, 1, 0, 0, 0, 2575, 2578, 1, 0, 0, 0, 2576, 2574, 1, 0, 0, 0, 2576, 2577, 1, 0, 0, 0, 2577, 2580, 1, 0, 0, 0, 2578, 2576, 1, 0, 0, 0, 2579, 2514, 1, 0, 0, 0, 2579, 2527, 1, 0, 0, 0, 2579, 2538, 1, 0, 0, 0, 2579, 2553, 1, 0, 0, 0, 2579, 2566, 1, 0, 0, 0, 2580, 259, 1, 0, 0, 0, 2581, 2582, 3, 0, 0, 0, 2582, 2583, 5, 75, 0, 0, 2583, 2584, 6, 130, -1, 0, 2584, 261, 1, 0, 0, 0, 2585, 2588, 3, 44, 22, 0, 2586, 2588, 3, 46, 23, 0, 2587, 2585, 1, 0, 0, 0, 2587, 2586, 1, 0, 0, 0, 2588, 263, 1, 0, 0, 0, 2589, 2590, 5, 17, 0, 0, 2590, 2591, 3, 246, 123, 0, 2591, 2592, 5, 18, 0, 0, 2592, 265, 1, 0, 0, 0, 2593, 2594, 3, 270, 135, 0, 2594, 2595, 3, 268, 134, 0, 2595, 267, 1, 0, 0, 0, 2596, 2597, 3, 272, 136, 0, 2597, 2598, 6, 134, -1, 0, 2598, 2600, 1, 0, 0, 0, 2599, 2596, 1, 0, 0, 0, 2600, 2601, 1, 0, 0, 0, 2601, 2599, 1, 0, 0, 0, 2601, 2602, 1, 0, 0, 0, 2602, 269, 1, 0, 0, 0, 2603, 2604, 5, 158, 0, 0, 2604, 2605, 3, 264, 132, 0, 2605, 2606, 6, 135, -1, 0, 2606, 2620, 1, 0, 0, 0, 2607, 2608, 5, 158, 0, 0, 2608, 2609, 3, 0, 0, 0, 2609, 2610, 5, 159, 0, 0, 2610, 2611, 3, 0, 0, 0, 2611, 2612, 6, 135, -1, 0, 2612, 2620, 1, 0, 0, 0, 2613, 2614, 5, 158, 0, 0, 2614, 2615, 3, 32, 16, 0, 2615, 2616, 5, 159, 0, 0, 2616, 2617, 3, 32, 16, 0, 2617, 2618, 6, 135, -1, 0, 2618, 2620, 1, 0, 0, 0, 2619, 2603, 1, 0, 0, 0, 2619, 2607, 1, 0, 0, 0, 2619, 2613, 1, 0, 0, 0, 2620, 271, 1, 0, 0, 0, 2621, 2622, 3, 276, 138, 0, 2622, 2623, 3, 282, 141, 0, 2623, 2624, 6, 136, -1, 0, 2624, 2638, 1, 0, 0, 0, 2625, 2626, 3, 274, 137, 0, 2626, 2627, 3, 282, 141, 0, 2627, 2628, 6, 136, -1, 0, 2628, 2638, 1, 0, 0, 0, 2629, 2630, 3, 278, 139, 0, 2630, 2631, 3, 282, 141, 0, 2631, 2632, 6, 136, -1, 0, 2632, 2638, 1, 0, 0, 0, 2633, 2634, 3, 280, 140, 0, 2634, 2635, 3, 282, 141, 0, 2635, 2636, 6, 136, -1, 0, 2636, 2638, 1, 0, 0, 0, 2637, 2621, 1, 0, 0, 0, 2637, 2625, 1, 0, 0, 0, 2637, 2629, 1, 0, 0, 0, 2637, 2633, 1, 0, 0, 0, 2638, 273, 1, 0, 0, 0, 2639, 2640, 5, 160, 0, 0, 2640, 2641, 3, 264, 132, 0, 2641, 2642, 6, 137, -1, 0, 2642, 2652, 1, 0, 0, 0, 2643, 2644, 5, 160, 0, 0, 2644, 2645, 3, 0, 0, 0, 2645, 2646, 6, 137, -1, 0, 2646, 2652, 1, 0, 0, 0, 2647, 2648, 5, 160, 0, 0, 2648, 2649, 3, 32, 16, 0, 2649, 2650, 6, 137, -1, 0, 2650, 2652, 1, 0, 0, 0, 2651, 2639, 1, 0, 0, 0, 2651, 2643, 1, 0, 0, 0, 2651, 2647, 1, 0, 0, 0, 2652, 275, 1, 0, 0, 0, 2653, 2654, 5, 161, 0, 0, 2654, 2655, 3, 124, 62, 0, 2655, 277, 1, 0, 0, 0, 2656, 2657, 5, 162, 0, 0, 2657, 279, 1, 0, 0, 0, 2658, 2659, 5, 163, 0, 0, 2659, 281, 1, 0, 0, 0, 2660, 2661, 3, 264, 132, 0, 2661, 2662, 6, 141, -1, 0, 2662, 2676, 1, 0, 0, 0, 2663, 2664, 5, 164, 0, 0, 2664, 2665, 3, 0, 0, 0, 2665, 2666, 5, 159, 0, 0, 2666, 2667, 3, 0, 0, 0, 2667, 2668, 6, 141, -1, 0, 2668, 2676, 1, 0, 0, 0, 2669, 2670, 5, 164, 0, 0, 2670, 2671, 3, 32, 16, 0, 2671, 2672, 5, 159, 0, 0, 2672, 2673, 3, 32, 16, 0, 2673, 2674, 6, 141, -1, 0, 2674, 2676, 1, 0, 0, 0, 2675, 2660, 1, 0, 0, 0, 2675, 2663, 1, 0, 0, 0, 2675, 2669, 1, 0, 0, 0, 2676, 283, 1, 0, 0, 0, 2677, 2678, 3, 286, 143, 0, 2678, 2679, 3, 290, 145, 0, 2679, 285, 1, 0, 0, 0, 2680, 2681, 5, 165, 0, 0, 2681, 2682, 3, 288, 144, 0, 2682, 2683, 3, 0, 0, 0, 2683, 2684, 5, 36, 0, 0, 2684, 2688, 1, 0, 0, 0, 2685, 2686, 5, 165, 0, 0, 2686, 2688, 3, 288, 144, 0, 2687, 2680, 1, 0, 0, 0, 2687, 2685, 1, 0, 0, 0, 2688, 287, 1, 0, 0, 0, 2689, 2693, 1, 0, 0, 0, 2690, 2693, 5, 166, 0, 0, 2691, 2693, 5, 2, 0, 0, 2692, 2689, 1, 0, 0, 0, 2692, 2690, 1, 0, 0, 0, 2692, 2691, 1, 0, 0, 0, 2693, 289, 1, 0, 0, 0, 2694, 2695, 5, 17, 0, 0, 2695, 2696, 3, 292, 146, 0, 2696, 2697, 5, 18, 0, 0, 2697, 2704, 1, 0, 0, 0, 2698, 2700, 3, 296, 148, 0, 2699, 2698, 1, 0, 0, 0, 2700, 2701, 1, 0, 0, 0, 2701, 2699, 1, 0, 0, 0, 2701, 2702, 1, 0, 0, 0, 2702, 2704, 1, 0, 0, 0, 2703, 2694, 1, 0, 0, 0, 2703, 2699, 1, 0, 0, 0, 2704, 291, 1, 0, 0, 0, 2705, 2706, 3, 296, 148, 0, 2706, 2707, 5, 28, 0, 0, 2707, 2709, 1, 0, 0, 0, 2708, 2705, 1, 0, 0, 0, 2709, 2712, 1, 0, 0, 0, 2710, 2708, 1, 0, 0, 0, 2710, 2711, 1, 0, 0, 0, 2711, 2713, 1, 0, 0, 0, 2712, 2710, 1, 0, 0, 0, 2713, 2714, 3, 296, 148, 0, 2714, 293, 1, 0, 0, 0, 2715, 2721, 1, 0, 0, 0, 2716, 2717, 5, 42, 0, 0, 2717, 2718, 3, 32, 16, 0, 2718, 2719, 5, 43, 0, 0, 2719, 2721, 1, 0, 0, 0, 2720, 2715, 1, 0, 0, 0, 2720, 2716, 1, 0, 0, 0, 2721, 295, 1, 0, 0, 0, 2722, 2723, 5, 181, 0, 0, 2723, 2724, 5, 262, 0, 0, 2724, 2725, 5, 30, 0, 0, 2725, 2726, 3, 6, 3, 0, 2726, 2727, 5, 31, 0, 0, 2727, 2789, 1, 0, 0, 0, 2728, 2729, 5, 260, 0, 0, 2729, 2730, 5, 30, 0, 0, 2730, 2731, 3, 0, 0, 0, 2731, 2732, 5, 31, 0, 0, 2732, 2789, 1, 0, 0, 0, 2733, 2734, 5, 260, 0, 0, 2734, 2789, 3, 0, 0, 0, 2735, 2736, 5, 84, 0, 0, 2736, 2737, 5, 30, 0, 0, 2737, 2738, 3, 300, 150, 0, 2738, 2739, 5, 31, 0, 0, 2739, 2789, 1, 0, 0, 0, 2740, 2741, 5, 188, 0, 0, 2741, 2742, 5, 30, 0, 0, 2742, 2743, 3, 36, 18, 0, 2743, 2744, 5, 31, 0, 0, 2744, 2745, 3, 294, 147, 0, 2745, 2789, 1, 0, 0, 0, 2746, 2747, 5, 189, 0, 0, 2747, 2748, 5, 30, 0, 0, 2748, 2749, 3, 36, 18, 0, 2749, 2750, 5, 31, 0, 0, 2750, 2751, 3, 294, 147, 0, 2751, 2789, 1, 0, 0, 0, 2752, 2753, 5, 187, 0, 0, 2753, 2754, 5, 30, 0, 0, 2754, 2755, 3, 34, 17, 0, 2755, 2756, 5, 31, 0, 0, 2756, 2757, 3, 294, 147, 0, 2757, 2789, 1, 0, 0, 0, 2758, 2759, 5, 186, 0, 0, 2759, 2760, 5, 30, 0, 0, 2760, 2761, 3, 32, 16, 0, 2761, 2762, 5, 31, 0, 0, 2762, 2763, 3, 294, 147, 0, 2763, 2789, 1, 0, 0, 0, 2764, 2765, 5, 185, 0, 0, 2765, 2766, 5, 30, 0, 0, 2766, 2767, 3, 32, 16, 0, 2767, 2768, 5, 31, 0, 0, 2768, 2769, 3, 294, 147, 0, 2769, 2789, 1, 0, 0, 0, 2770, 2771, 5, 184, 0, 0, 2771, 2772, 5, 30, 0, 0, 2772, 2773, 3, 32, 16, 0, 2773, 2774, 5, 31, 0, 0, 2774, 2775, 3, 294, 147, 0, 2775, 2789, 1, 0, 0, 0, 2776, 2777, 5, 188, 0, 0, 2777, 2789, 3, 294, 147, 0, 2778, 2779, 5, 189, 0, 0, 2779, 2789, 3, 294, 147, 0, 2780, 2781, 5, 187, 0, 0, 2781, 2789, 3, 294, 147, 0, 2782, 2783, 5, 186, 0, 0, 2783, 2789, 3, 294, 147, 0, 2784, 2785, 5, 185, 0, 0, 2785, 2789, 3, 294, 147, 0, 2786, 2787, 5, 184, 0, 0, 2787, 2789, 3, 294, 147, 0, 2788, 2722, 1, 0, 0, 0, 2788, 2728, 1, 0, 0, 0, 2788, 2733, 1, 0, 0, 0, 2788, 2735, 1, 0, 0, 0, 2788, 2740, 1, 0, 0, 0, 2788, 2746, 1, 0, 0, 0, 2788, 2752, 1, 0, 0, 0, 2788, 2758, 1, 0, 0, 0, 2788, 2764, 1, 0, 0, 0, 2788, 2770, 1, 0, 0, 0, 2788, 2776, 1, 0, 0, 0, 2788, 2778, 1, 0, 0, 0, 2788, 2780, 1, 0, 0, 0, 2788, 2782, 1, 0, 0, 0, 2788, 2784, 1, 0, 0, 0, 2788, 2786, 1, 0, 0, 0, 2789, 297, 1, 0, 0, 0, 2790, 2791, 5, 188, 0, 0, 2791, 2792, 5, 30, 0, 0, 2792, 2793, 3, 36, 18, 0, 2793, 2794, 5, 31, 0, 0, 2794, 2866, 1, 0, 0, 0, 2795, 2796, 5, 189, 0, 0, 2796, 2797, 5, 30, 0, 0, 2797, 2798, 3, 36, 18, 0, 2798, 2799, 5, 31, 0, 0, 2799, 2866, 1, 0, 0, 0, 2800, 2801, 5, 188, 0, 0, 2801, 2802, 5, 30, 0, 0, 2802, 2803, 3, 32, 16, 0, 2803, 2804, 5, 31, 0, 0, 2804, 2866, 1, 0, 0, 0, 2805, 2806, 5, 189, 0, 0, 2806, 2807, 5, 30, 0, 0, 2807, 2808, 3, 34, 17, 0, 2808, 2809, 5, 31, 0, 0, 2809, 2866, 1, 0, 0, 0, 2810, 2811, 5, 187, 0, 0, 2811, 2812, 5, 30, 0, 0, 2812, 2813, 3, 34, 17, 0, 2813, 2814, 5, 31, 0, 0, 2814, 2866, 1, 0, 0, 0, 2815, 2816, 5, 186, 0, 0, 2816, 2817, 5, 30, 0, 0, 2817, 2818, 3, 32, 16, 0, 2818, 2819, 5, 31, 0, 0, 2819, 2866, 1, 0, 0, 0, 2820, 2821, 5, 185, 0, 0, 2821, 2822, 5, 30, 0, 0, 2822, 2823, 3, 32, 16, 0, 2823, 2824, 5, 31, 0, 0, 2824, 2866, 1, 0, 0, 0, 2825, 2826, 5, 184, 0, 0, 2826, 2827, 5, 30, 0, 0, 2827, 2828, 3, 32, 16, 0, 2828, 2829, 5, 31, 0, 0, 2829, 2866, 1, 0, 0, 0, 2830, 2831, 5, 193, 0, 0, 2831, 2832, 5, 30, 0, 0, 2832, 2833, 3, 34, 17, 0, 2833, 2834, 5, 31, 0, 0, 2834, 2866, 1, 0, 0, 0, 2835, 2836, 5, 192, 0, 0, 2836, 2837, 5, 30, 0, 0, 2837, 2838, 3, 32, 16, 0, 2838, 2839, 5, 31, 0, 0, 2839, 2866, 1, 0, 0, 0, 2840, 2841, 5, 191, 0, 0, 2841, 2842, 5, 30, 0, 0, 2842, 2843, 3, 32, 16, 0, 2843, 2844, 5, 31, 0, 0, 2844, 2866, 1, 0, 0, 0, 2845, 2846, 5, 190, 0, 0, 2846, 2847, 5, 30, 0, 0, 2847, 2848, 3, 32, 16, 0, 2848, 2849, 5, 31, 0, 0, 2849, 2866, 1, 0, 0, 0, 2850, 2851, 5, 181, 0, 0, 2851, 2852, 5, 30, 0, 0, 2852, 2853, 3, 32, 16, 0, 2853, 2854, 5, 31, 0, 0, 2854, 2866, 1, 0, 0, 0, 2855, 2856, 5, 183, 0, 0, 2856, 2857, 5, 30, 0, 0, 2857, 2858, 3, 162, 81, 0, 2858, 2859, 5, 31, 0, 0, 2859, 2866, 1, 0, 0, 0, 2860, 2861, 5, 84, 0, 0, 2861, 2862, 5, 30, 0, 0, 2862, 2863, 3, 300, 150, 0, 2863, 2864, 5, 31, 0, 0, 2864, 2866, 1, 0, 0, 0, 2865, 2790, 1, 0, 0, 0, 2865, 2795, 1, 0, 0, 0, 2865, 2800, 1, 0, 0, 0, 2865, 2805, 1, 0, 0, 0, 2865, 2810, 1, 0, 0, 0, 2865, 2815, 1, 0, 0, 0, 2865, 2820, 1, 0, 0, 0, 2865, 2825, 1, 0, 0, 0, 2865, 2830, 1, 0, 0, 0, 2865, 2835, 1, 0, 0, 0, 2865, 2840, 1, 0, 0, 0, 2865, 2845, 1, 0, 0, 0, 2865, 2850, 1, 0, 0, 0, 2865, 2855, 1, 0, 0, 0, 2865, 2860, 1, 0, 0, 0, 2866, 299, 1, 0, 0, 0, 2867, 2868, 3, 302, 151, 0, 2868, 2869, 6, 150, -1, 0, 2869, 2871, 1, 0, 0, 0, 2870, 2867, 1, 0, 0, 0, 2871, 2874, 1, 0, 0, 0, 2872, 2870, 1, 0, 0, 0, 2872, 2873, 1, 0, 0, 0, 2873, 301, 1, 0, 0, 0, 2874, 2872, 1, 0, 0, 0, 2875, 2876, 7, 11, 0, 0, 2876, 303, 1, 0, 0, 0, 2877, 2881, 3, 298, 149, 0, 2878, 2881, 3, 6, 3, 0, 2879, 2881, 5, 179, 0, 0, 2880, 2877, 1, 0, 0, 0, 2880, 2878, 1, 0, 0, 0, 2880, 2879, 1, 0, 0, 0, 2881, 305, 1, 0, 0, 0, 2882, 3031, 3, 298, 149, 0, 2883, 2884, 5, 182, 0, 0, 2884, 2885, 5, 30, 0, 0, 2885, 2886, 5, 179, 0, 0, 2886, 3031, 5, 31, 0, 0, 2887, 2888, 5, 182, 0, 0, 2888, 2889, 5, 30, 0, 0, 2889, 2890, 5, 264, 0, 0, 2890, 3031, 5, 31, 0, 0, 2891, 2892, 5, 196, 0, 0, 2892, 2893, 5, 30, 0, 0, 2893, 2894, 5, 39, 0, 0, 2894, 2895, 5, 264, 0, 0, 2895, 3031, 5, 31, 0, 0, 2896, 2897, 5, 196, 0, 0, 2897, 2898, 5, 30, 0, 0, 2898, 2899, 3, 116, 58, 0, 2899, 2900, 5, 31, 0, 0, 2900, 3031, 1, 0, 0, 0, 2901, 2902, 5, 196, 0, 0, 2902, 2903, 5, 30, 0, 0, 2903, 2904, 5, 179, 0, 0, 2904, 3031, 5, 31, 0, 0, 2905, 2906, 5, 197, 0, 0, 2906, 2907, 5, 30, 0, 0, 2907, 2908, 3, 306, 153, 0, 2908, 2909, 5, 31, 0, 0, 2909, 3031, 1, 0, 0, 0, 2910, 2911, 5, 188, 0, 0, 2911, 2912, 5, 42, 0, 0, 2912, 2913, 3, 32, 16, 0, 2913, 2914, 5, 43, 0, 0, 2914, 2915, 5, 30, 0, 0, 2915, 2916, 3, 308, 154, 0, 2916, 2917, 5, 31, 0, 0, 2917, 3031, 1, 0, 0, 0, 2918, 2919, 5, 189, 0, 0, 2919, 2920, 5, 42, 0, 0, 2920, 2921, 3, 32, 16, 0, 2921, 2922, 5, 43, 0, 0, 2922, 2923, 5, 30, 0, 0, 2923, 2924, 3, 310, 155, 0, 2924, 2925, 5, 31, 0, 0, 2925, 3031, 1, 0, 0, 0, 2926, 2927, 5, 187, 0, 0, 2927, 2928, 5, 42, 0, 0, 2928, 2929, 3, 32, 16, 0, 2929, 2930, 5, 43, 0, 0, 2930, 2931, 5, 30, 0, 0, 2931, 2932, 3, 312, 156, 0, 2932, 2933, 5, 31, 0, 0, 2933, 3031, 1, 0, 0, 0, 2934, 2935, 5, 186, 0, 0, 2935, 2936, 5, 42, 0, 0, 2936, 2937, 3, 32, 16, 0, 2937, 2938, 5, 43, 0, 0, 2938, 2939, 5, 30, 0, 0, 2939, 2940, 3, 314, 157, 0, 2940, 2941, 5, 31, 0, 0, 2941, 3031, 1, 0, 0, 0, 2942, 2943, 5, 185, 0, 0, 2943, 2944, 5, 42, 0, 0, 2944, 2945, 3, 32, 16, 0, 2945, 2946, 5, 43, 0, 0, 2946, 2947, 5, 30, 0, 0, 2947, 2948, 3, 316, 158, 0, 2948, 2949, 5, 31, 0, 0, 2949, 3031, 1, 0, 0, 0, 2950, 2951, 5, 184, 0, 0, 2951, 2952, 5, 42, 0, 0, 2952, 2953, 3, 32, 16, 0, 2953, 2954, 5, 43, 0, 0, 2954, 2955, 5, 30, 0, 0, 2955, 2956, 3, 318, 159, 0, 2956, 2957, 5, 31, 0, 0, 2957, 3031, 1, 0, 0, 0, 2958, 2959, 5, 193, 0, 0, 2959, 2960, 5, 42, 0, 0, 2960, 2961, 3, 32, 16, 0, 2961, 2962, 5, 43, 0, 0, 2962, 2963, 5, 30, 0, 0, 2963, 2964, 3, 312, 156, 0, 2964, 2965, 5, 31, 0, 0, 2965, 3031, 1, 0, 0, 0, 2966, 2967, 5, 192, 0, 0, 2967, 2968, 5, 42, 0, 0, 2968, 2969, 3, 32, 16, 0, 2969, 2970, 5, 43, 0, 0, 2970, 2971, 5, 30, 0, 0, 2971, 2972, 3, 314, 157, 0, 2972, 2973, 5, 31, 0, 0, 2973, 3031, 1, 0, 0, 0, 2974, 2975, 5, 191, 0, 0, 2975, 2976, 5, 42, 0, 0, 2976, 2977, 3, 32, 16, 0, 2977, 2978, 5, 43, 0, 0, 2978, 2979, 5, 30, 0, 0, 2979, 2980, 3, 316, 158, 0, 2980, 2981, 5, 31, 0, 0, 2981, 3031, 1, 0, 0, 0, 2982, 2983, 5, 190, 0, 0, 2983, 2984, 5, 42, 0, 0, 2984, 2985, 3, 32, 16, 0, 2985, 2986, 5, 43, 0, 0, 2986, 2987, 5, 30, 0, 0, 2987, 2988, 3, 318, 159, 0, 2988, 2989, 5, 31, 0, 0, 2989, 3031, 1, 0, 0, 0, 2990, 2991, 5, 181, 0, 0, 2991, 2992, 5, 42, 0, 0, 2992, 2993, 3, 32, 16, 0, 2993, 2994, 5, 43, 0, 0, 2994, 2995, 5, 30, 0, 0, 2995, 2996, 3, 316, 158, 0, 2996, 2997, 5, 31, 0, 0, 2997, 3031, 1, 0, 0, 0, 2998, 2999, 5, 183, 0, 0, 2999, 3000, 5, 42, 0, 0, 3000, 3001, 3, 32, 16, 0, 3001, 3002, 5, 43, 0, 0, 3002, 3003, 5, 30, 0, 0, 3003, 3004, 3, 320, 160, 0, 3004, 3005, 5, 31, 0, 0, 3005, 3031, 1, 0, 0, 0, 3006, 3007, 5, 182, 0, 0, 3007, 3008, 5, 42, 0, 0, 3008, 3009, 3, 32, 16, 0, 3009, 3010, 5, 43, 0, 0, 3010, 3011, 5, 30, 0, 0, 3011, 3012, 3, 322, 161, 0, 3012, 3013, 5, 31, 0, 0, 3013, 3031, 1, 0, 0, 0, 3014, 3015, 5, 196, 0, 0, 3015, 3016, 5, 42, 0, 0, 3016, 3017, 3, 32, 16, 0, 3017, 3018, 5, 43, 0, 0, 3018, 3019, 5, 30, 0, 0, 3019, 3020, 3, 324, 162, 0, 3020, 3021, 5, 31, 0, 0, 3021, 3031, 1, 0, 0, 0, 3022, 3023, 5, 197, 0, 0, 3023, 3024, 5, 42, 0, 0, 3024, 3025, 3, 32, 16, 0, 3025, 3026, 5, 43, 0, 0, 3026, 3027, 5, 30, 0, 0, 3027, 3028, 3, 328, 164, 0, 3028, 3029, 5, 31, 0, 0, 3029, 3031, 1, 0, 0, 0, 3030, 2882, 1, 0, 0, 0, 3030, 2883, 1, 0, 0, 0, 3030, 2887, 1, 0, 0, 0, 3030, 2891, 1, 0, 0, 0, 3030, 2896, 1, 0, 0, 0, 3030, 2901, 1, 0, 0, 0, 3030, 2905, 1, 0, 0, 0, 3030, 2910, 1, 0, 0, 0, 3030, 2918, 1, 0, 0, 0, 3030, 2926, 1, 0, 0, 0, 3030, 2934, 1, 0, 0, 0, 3030, 2942, 1, 0, 0, 0, 3030, 2950, 1, 0, 0, 0, 3030, 2958, 1, 0, 0, 0, 3030, 2966, 1, 0, 0, 0, 3030, 2974, 1, 0, 0, 0, 3030, 2982, 1, 0, 0, 0, 3030, 2990, 1, 0, 0, 0, 3030, 2998, 1, 0, 0, 0, 3030, 3006, 1, 0, 0, 0, 3030, 3014, 1, 0, 0, 0, 3030, 3022, 1, 0, 0, 0, 3031, 307, 1, 0, 0, 0, 3032, 3035, 3, 36, 18, 0, 3033, 3035, 3, 32, 16, 0, 3034, 3032, 1, 0, 0, 0, 3034, 3033, 1, 0, 0, 0, 3035, 3038, 1, 0, 0, 0, 3036, 3034, 1, 0, 0, 0, 3036, 3037, 1, 0, 0, 0, 3037, 309, 1, 0, 0, 0, 3038, 3036, 1, 0, 0, 0, 3039, 3042, 3, 36, 18, 0, 3040, 3042, 3, 34, 17, 0, 3041, 3039, 1, 0, 0, 0, 3041, 3040, 1, 0, 0, 0, 3042, 3045, 1, 0, 0, 0, 3043, 3041, 1, 0, 0, 0, 3043, 3044, 1, 0, 0, 0, 3044, 311, 1, 0, 0, 0, 3045, 3043, 1, 0, 0, 0, 3046, 3048, 3, 34, 17, 0, 3047, 3046, 1, 0, 0, 0, 3048, 3051, 1, 0, 0, 0, 3049, 3047, 1, 0, 0, 0, 3049, 3050, 1, 0, 0, 0, 3050, 313, 1, 0, 0, 0, 3051, 3049, 1, 0, 0, 0, 3052, 3054, 3, 32, 16, 0, 3053, 3052, 1, 0, 0, 0, 3054, 3057, 1, 0, 0, 0, 3055, 3053, 1, 0, 0, 0, 3055, 3056, 1, 0, 0, 0, 3056, 315, 1, 0, 0, 0, 3057, 3055, 1, 0, 0, 0, 3058, 3060, 3, 32, 16, 0, 3059, 3058, 1, 0, 0, 0, 3060, 3063, 1, 0, 0, 0, 3061, 3059, 1, 0, 0, 0, 3061, 3062, 1, 0, 0, 0, 3062, 317, 1, 0, 0, 0, 3063, 3061, 1, 0, 0, 0, 3064, 3066, 3, 32, 16, 0, 3065, 3064, 1, 0, 0, 0, 3066, 3069, 1, 0, 0, 0, 3067, 3065, 1, 0, 0, 0, 3067, 3068, 1, 0, 0, 0, 3068, 319, 1, 0, 0, 0, 3069, 3067, 1, 0, 0, 0, 3070, 3072, 3, 162, 81, 0, 3071, 3070, 1, 0, 0, 0, 3072, 3075, 1, 0, 0, 0, 3073, 3071, 1, 0, 0, 0, 3073, 3074, 1, 0, 0, 0, 3074, 321, 1, 0, 0, 0, 3075, 3073, 1, 0, 0, 0, 3076, 3078, 7, 12, 0, 0, 3077, 3076, 1, 0, 0, 0, 3078, 3081, 1, 0, 0, 0, 3079, 3077, 1, 0, 0, 0, 3079, 3080, 1, 0, 0, 0, 3080, 323, 1, 0, 0, 0, 3081, 3079, 1, 0, 0, 0, 3082, 3084, 3, 326, 163, 0, 3083, 3082, 1, 0, 0, 0, 3084, 3087, 1, 0, 0, 0, 3085, 3083, 1, 0, 0, 0, 3085, 3086, 1, 0, 0, 0, 3086, 325, 1, 0, 0, 0, 3087, 3085, 1, 0, 0, 0, 3088, 3093, 5, 179, 0, 0, 3089, 3090, 5, 39, 0, 0, 3090, 3093, 5, 264, 0, 0, 3091, 3093, 3, 116, 58, 0, 3092, 3088, 1, 0, 0, 0, 3092, 3089, 1, 0, 0, 0, 3092, 3091, 1, 0, 0, 0, 3093, 327, 1, 0, 0, 0, 3094, 3096, 3, 306, 153, 0, 3095, 3094, 1, 0, 0, 0, 3096, 3099, 1, 0, 0, 0, 3097, 3095, 1, 0, 0, 0, 3097, 3098, 1, 0, 0, 0, 3098, 329, 1, 0, 0, 0, 3099, 3097, 1, 0, 0, 0, 3100, 3104, 3, 44, 22, 0, 3101, 3104, 3, 46, 23, 0, 3102, 3104, 3, 2, 1, 0, 3103, 3100, 1, 0, 0, 0, 3103, 3101, 1, 0, 0, 0, 3103, 3102, 1, 0, 0, 0, 3104, 331, 1, 0, 0, 0, 3105, 3106, 7, 13, 0, 0, 3106, 3107, 5, 36, 0, 0, 3107, 3108, 5, 30, 0, 0, 3108, 3109, 3, 300, 150, 0, 3109, 3110, 5, 31, 0, 0, 3110, 3131, 1, 0, 0, 0, 3111, 3112, 5, 169, 0, 0, 3112, 3113, 3, 38, 19, 0, 3113, 3114, 5, 75, 0, 0, 3114, 3115, 3, 38, 19, 0, 3115, 3116, 5, 75, 0, 0, 3116, 3117, 3, 38, 19, 0, 3117, 3118, 5, 75, 0, 0, 3118, 3119, 3, 38, 19, 0, 3119, 3131, 1, 0, 0, 0, 3120, 3121, 5, 170, 0, 0, 3121, 3131, 3, 6, 3, 0, 3122, 3123, 5, 170, 0, 0, 3123, 3124, 5, 36, 0, 0, 3124, 3125, 5, 30, 0, 0, 3125, 3126, 3, 300, 150, 0, 3126, 3127, 5, 31, 0, 0, 3127, 3131, 1, 0, 0, 0, 3128, 3131, 3, 330, 165, 0, 3129, 3131, 3, 40, 20, 0, 3130, 3105, 1, 0, 0, 0, 3130, 3111, 1, 0, 0, 0, 3130, 3120, 1, 0, 0, 0, 3130, 3122, 1, 0, 0, 0, 3130, 3128, 1, 0, 0, 0, 3130, 3129, 1, 0, 0, 0, 3131, 333, 1, 0, 0, 0, 3132, 3133, 5, 25, 0, 0, 3133, 3134, 5, 40, 0, 0, 3134, 3135, 3, 98, 49, 0, 3135, 3136, 3, 2, 1, 0, 3136, 3145, 1, 0, 0, 0, 3137, 3138, 5, 25, 0, 0, 3138, 3139, 5, 40, 0, 0, 3139, 3140, 3, 98, 49, 0, 3140, 3141, 3, 2, 1, 0, 3141, 3142, 5, 34, 0, 0, 3142, 3143, 3, 2, 1, 0, 3143, 3145, 1, 0, 0, 0, 3144, 3132, 1, 0, 0, 0, 3144, 3137, 1, 0, 0, 0, 3145, 335, 1, 0, 0, 0, 3146, 3148, 3, 338, 169, 0, 3147, 3146, 1, 0, 0, 0, 3148, 3151, 1, 0, 0, 0, 3149, 3147, 1, 0, 0, 0, 3149, 3150, 1, 0, 0, 0, 3150, 337, 1, 0, 0, 0, 3151, 3149, 1, 0, 0, 0, 3152, 3153, 5, 180, 0, 0, 3153, 3154, 5, 36, 0, 0, 3154, 3155, 5, 30, 0, 0, 3155, 3156, 3, 300, 150, 0, 3156, 3157, 5, 31, 0, 0, 3157, 3167, 1, 0, 0, 0, 3158, 3167, 3, 332, 166, 0, 3159, 3160, 5, 171, 0, 0, 3160, 3161, 5, 36, 0, 0, 3161, 3162, 5, 30, 0, 0, 3162, 3163, 3, 300, 150, 0, 3163, 3164, 5, 31, 0, 0, 3164, 3167, 1, 0, 0, 0, 3165, 3167, 5, 55, 0, 0, 3166, 3152, 1, 0, 0, 0, 3166, 3158, 1, 0, 0, 0, 3166, 3159, 1, 0, 0, 0, 3166, 3165, 1, 0, 0, 0, 3167, 339, 1, 0, 0, 0, 3168, 3169, 5, 50, 0, 0, 3169, 3173, 5, 40, 0, 0, 3170, 3172, 3, 344, 172, 0, 3171, 3170, 1, 0, 0, 0, 3172, 3175, 1, 0, 0, 0, 3173, 3171, 1, 0, 0, 0, 3173, 3174, 1, 0, 0, 0, 3174, 3176, 1, 0, 0, 0, 3175, 3173, 1, 0, 0, 0, 3176, 3177, 3, 2, 1, 0, 3177, 341, 1, 0, 0, 0, 3178, 3182, 5, 301, 0, 0, 3179, 3181, 3, 344, 172, 0, 3180, 3179, 1, 0, 0, 0, 3181, 3184, 1, 0, 0, 0, 3182, 3180, 1, 0, 0, 0, 3182, 3183, 1, 0, 0, 0, 3183, 3185, 1, 0, 0, 0, 3184, 3182, 1, 0, 0, 0, 3185, 3186, 3, 2, 1, 0, 3186, 343, 1, 0, 0, 0, 3187, 3203, 5, 52, 0, 0, 3188, 3203, 5, 51, 0, 0, 3189, 3203, 5, 172, 0, 0, 3190, 3191, 5, 62, 0, 0, 3191, 3203, 5, 51, 0, 0, 3192, 3193, 5, 62, 0, 0, 3193, 3203, 5, 52, 0, 0, 3194, 3195, 5, 62, 0, 0, 3195, 3203, 5, 63, 0, 0, 3196, 3197, 5, 62, 0, 0, 3197, 3203, 5, 64, 0, 0, 3198, 3199, 5, 62, 0, 0, 3199, 3203, 5, 65, 0, 0, 3200, 3201, 5, 62, 0, 0, 3201, 3203, 5, 66, 0, 0, 3202, 3187, 1, 0, 0, 0, 3202, 3188, 1, 0, 0, 0, 3202, 3189, 1, 0, 0, 0, 3202, 3190, 1, 0, 0, 0, 3202, 3192, 1, 0, 0, 0, 3202, 3194, 1, 0, 0, 0, 3202, 3196, 1, 0, 0, 0, 3202, 3198, 1, 0, 0, 0, 3202, 3200, 1, 0, 0, 0, 3203, 345, 1, 0, 0, 0, 3204, 3206, 3, 348, 174, 0, 3205, 3204, 1, 0, 0, 0, 3206, 3209, 1, 0, 0, 0, 3207, 3205, 1, 0, 0, 0, 3207, 3208, 1, 0, 0, 0, 3208, 347, 1, 0, 0, 0, 3209, 3207, 1, 0, 0, 0, 3210, 3211, 5, 21, 0, 0, 3211, 3224, 3, 2, 1, 0, 3212, 3213, 5, 50, 0, 0, 3213, 3214, 5, 40, 0, 0, 3214, 3224, 3, 118, 59, 0, 3215, 3216, 5, 25, 0, 0, 3216, 3217, 5, 40, 0, 0, 3217, 3224, 3, 2, 1, 0, 3218, 3224, 3, 174, 87, 0, 3219, 3220, 5, 50, 0, 0, 3220, 3224, 3, 32, 16, 0, 3221, 3224, 3, 330, 165, 0, 3222, 3224, 3, 40, 20, 0, 3223, 3210, 1, 0, 0, 0, 3223, 3212, 1, 0, 0, 0, 3223, 3215, 1, 0, 0, 0, 3223, 3218, 1, 0, 0, 0, 3223, 3219, 1, 0, 0, 0, 3223, 3221, 1, 0, 0, 0, 3223, 3222, 1, 0, 0, 0, 3224, 349, 1, 0, 0, 0, 3225, 3229, 5, 274, 0, 0, 3226, 3228, 3, 352, 176, 0, 3227, 3226, 1, 0, 0, 0, 3228, 3231, 1, 0, 0, 0, 3229, 3227, 1, 0, 0, 0, 3229, 3230, 1, 0, 0, 0, 3230, 3232, 1, 0, 0, 0, 3231, 3229, 1, 0, 0, 0, 3232, 3245, 3, 2, 1, 0, 3233, 3237, 5, 274, 0, 0, 3234, 3236, 3, 352, 176, 0, 3235, 3234, 1, 0, 0, 0, 3236, 3239, 1, 0, 0, 0, 3237, 3235, 1, 0, 0, 0, 3237, 3238, 1, 0, 0, 0, 3238, 3240, 1, 0, 0, 0, 3239, 3237, 1, 0, 0, 0, 3240, 3241, 3, 2, 1, 0, 3241, 3242, 5, 34, 0, 0, 3242, 3243, 3, 2, 1, 0, 3243, 3245, 1, 0, 0, 0, 3244, 3225, 1, 0, 0, 0, 3244, 3233, 1, 0, 0, 0, 3245, 351, 1, 0, 0, 0, 3246, 3247, 7, 14, 0, 0, 3247, 353, 1, 0, 0, 0, 3248, 3250, 3, 356, 178, 0, 3249, 3248, 1, 0, 0, 0, 3250, 3253, 1, 0, 0, 0, 3251, 3249, 1, 0, 0, 0, 3251, 3252, 1, 0, 0, 0, 3252, 355, 1, 0, 0, 0, 3253, 3251, 1, 0, 0, 0, 3254, 3255, 5, 21, 0, 0, 3255, 3256, 3, 2, 1, 0, 3256, 3257, 5, 44, 0, 0, 3257, 3258, 3, 32, 16, 0, 3258, 3265, 1, 0, 0, 0, 3259, 3260, 5, 25, 0, 0, 3260, 3261, 5, 40, 0, 0, 3261, 3265, 3, 2, 1, 0, 3262, 3265, 3, 330, 165, 0, 3263, 3265, 3, 40, 20, 0, 3264, 3254, 1, 0, 0, 0, 3264, 3259, 1, 0, 0, 0, 3264, 3262, 1, 0, 0, 0, 3264, 3263, 1, 0, 0, 0, 3265, 357, 1, 0, 0, 0, 179, 368, 376, 385, 394, 447, 488, 497, 527, 531, 549, 576, 599, 635, 645, 652, 654, 664, 666, 673, 684, 692, 713, 715, 731, 776, 781, 786, 791, 799, 909, 915, 931, 937, 943, 950, 978, 1056, 1058, 1072, 1078, 1087, 1089, 1098, 1112, 1126, 1134, 1142, 1146, 1185, 1193, 1202, 1210, 1229, 1239, 1242, 1266, 1413, 1423, 1432, 1435, 1517, 1526, 1558, 1618, 1658, 1674, 1684, 1711, 1735, 1743, 1747, 1762, 1769, 1814, 1824, 1842, 1860, 1879, 1900, 1919, 1934, 1941, 1951, 1964, 1969, 1974, 1983, 1993, 2079, 2088, 2101, 2112, 2120, 2130, 2132, 2159, 2166, 2171, 2178, 2184, 2194, 2198, 2205, 2220, 2226, 2240, 2253, 2262, 2273, 2277, 2284, 2304, 2309, 2311, 2324, 2350, 2357, 2359, 2364, 2370, 2399, 2408, 2431, 2436, 2476, 2480, 2490, 2512, 2524, 2535, 2550, 2563, 2576, 2579, 2587, 2601, 2619, 2637, 2651, 2675, 2687, 2692, 2701, 2703, 2710, 2720, 2788, 2865, 2872, 2880, 3030, 3034, 3036, 3041, 3043, 3049, 3055, 3061, 3067, 3073, 3079, 3085, 3092, 3097, 3103, 3130, 3144, 3149, 3166, 3173, 3182, 3202, 3207, 3223, 3229, 3237, 3244, 3251, 3264] \ No newline at end of file +[4, 1, 305, 3451, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 367, 8, 1, 10, 1, 12, 1, 370, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 377, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 5, 3, 384, 8, 3, 10, 3, 12, 3, 387, 9, 3, 1, 3, 1, 3, 1, 3, 1, 4, 5, 4, 393, 8, 4, 10, 4, 12, 4, 396, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 448, 8, 5, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 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, 489, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 5, 15, 496, 8, 15, 10, 15, 12, 15, 499, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 528, 8, 18, 1, 19, 1, 19, 3, 19, 532, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 550, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 577, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 600, 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, 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, 636, 8, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 646, 8, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 5, 27, 653, 8, 27, 10, 27, 12, 27, 656, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 665, 8, 28, 10, 28, 12, 28, 668, 9, 28, 1, 29, 1, 29, 1, 30, 1, 30, 3, 30, 674, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 685, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 693, 8, 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, 34, 1, 34, 1, 34, 1, 34, 5, 34, 714, 8, 34, 10, 34, 12, 34, 717, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 5, 37, 730, 8, 37, 10, 37, 12, 37, 733, 9, 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, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 777, 8, 38, 1, 39, 1, 39, 1, 39, 3, 39, 782, 8, 39, 1, 40, 1, 40, 1, 40, 3, 40, 787, 8, 40, 1, 41, 5, 41, 790, 8, 41, 10, 41, 12, 41, 793, 9, 41, 1, 42, 1, 42, 1, 42, 5, 42, 798, 8, 42, 10, 42, 12, 42, 801, 9, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 910, 8, 44, 1, 45, 1, 45, 5, 45, 914, 8, 45, 10, 45, 12, 45, 917, 9, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 930, 8, 45, 10, 45, 12, 45, 933, 9, 45, 1, 45, 1, 45, 1, 45, 3, 45, 938, 8, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 944, 8, 47, 1, 48, 1, 48, 1, 49, 5, 49, 949, 8, 49, 10, 49, 12, 49, 952, 9, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 979, 8, 50, 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, 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, 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, 1057, 8, 51, 3, 51, 1059, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1073, 8, 53, 1, 53, 1, 53, 5, 53, 1077, 8, 53, 10, 53, 12, 53, 1080, 9, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1088, 8, 53, 3, 53, 1090, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1097, 8, 54, 10, 54, 12, 54, 1100, 9, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1111, 8, 55, 10, 55, 12, 55, 1114, 9, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 5, 56, 1125, 8, 56, 10, 56, 12, 56, 1128, 9, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1135, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 1143, 8, 57, 1, 57, 1, 57, 3, 57, 1147, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1186, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 1192, 8, 59, 10, 59, 12, 59, 1195, 9, 59, 1, 59, 1, 59, 1, 59, 1, 60, 5, 60, 1201, 8, 60, 10, 60, 12, 60, 1204, 9, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1211, 8, 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, 3, 62, 1230, 8, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 5, 63, 1238, 8, 63, 10, 63, 12, 63, 1241, 9, 63, 3, 63, 1243, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 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, 1267, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1414, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1424, 8, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 5, 67, 1431, 8, 67, 10, 67, 12, 67, 1434, 9, 67, 3, 67, 1436, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1518, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 5, 69, 1525, 8, 69, 10, 69, 12, 69, 1528, 9, 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, 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, 1559, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1619, 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, 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, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1659, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1675, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1685, 8, 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, 3, 76, 1712, 8, 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, 1736, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 5, 77, 1742, 8, 77, 10, 77, 12, 77, 1745, 9, 77, 1, 77, 3, 77, 1748, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1763, 8, 78, 1, 79, 1, 79, 1, 79, 5, 79, 1768, 8, 79, 10, 79, 12, 79, 1771, 9, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1815, 8, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1825, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1843, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1861, 8, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1880, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1901, 8, 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, 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 1920, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1935, 8, 89, 1, 90, 1, 90, 1, 90, 1, 90, 5, 90, 1941, 8, 90, 10, 90, 12, 90, 1944, 9, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 1955, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 1975, 8, 92, 1, 93, 1, 93, 1, 93, 5, 93, 1980, 8, 93, 10, 93, 12, 93, 1983, 9, 93, 1, 94, 1, 94, 3, 94, 1987, 8, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 5, 95, 1996, 8, 95, 10, 95, 12, 95, 1999, 9, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 3, 97, 2010, 8, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2118, 8, 99, 10, 99, 12, 99, 2121, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2130, 8, 99, 10, 99, 12, 99, 2133, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2146, 8, 99, 10, 99, 12, 99, 2149, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2160, 8, 99, 10, 99, 12, 99, 2163, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 2171, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 2184, 8, 100, 10, 100, 12, 100, 2187, 9, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 2229, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 2240, 8, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 3, 103, 2247, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 2255, 8, 104, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2261, 8, 105, 10, 105, 12, 105, 2264, 9, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2274, 8, 105, 10, 105, 12, 105, 2277, 9, 105, 1, 105, 1, 105, 1, 105, 3, 105, 2282, 8, 105, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 2288, 8, 106, 1, 107, 5, 107, 2291, 8, 107, 10, 107, 12, 107, 2294, 9, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 2322, 8, 108, 1, 109, 1, 109, 1, 109, 1, 109, 5, 109, 2328, 8, 109, 10, 109, 12, 109, 2331, 9, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 2344, 8, 110, 1, 111, 5, 111, 2347, 8, 111, 10, 111, 12, 111, 2350, 9, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 2374, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 2383, 8, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 4, 114, 2392, 8, 114, 11, 114, 12, 114, 2393, 1, 114, 1, 114, 3, 114, 2398, 8, 114, 1, 115, 1, 115, 1, 115, 5, 115, 2403, 8, 115, 10, 115, 12, 115, 2406, 9, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 2425, 8, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2434, 8, 117, 10, 117, 12, 117, 2437, 9, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2449, 8, 117, 10, 117, 12, 117, 2452, 9, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2498, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2508, 8, 119, 3, 119, 2510, 8, 119, 1, 119, 1, 119, 1, 119, 5, 119, 2515, 8, 119, 10, 119, 12, 119, 2518, 9, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2523, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2567, 8, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 2576, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2616, 8, 122, 1, 123, 5, 123, 2619, 8, 123, 10, 123, 12, 123, 2622, 9, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2661, 8, 124, 1, 125, 1, 125, 3, 125, 2665, 8, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, 2675, 8, 126, 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, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 2697, 8, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2707, 8, 129, 10, 129, 12, 129, 2710, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2718, 8, 129, 10, 129, 12, 129, 2721, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2733, 8, 129, 10, 129, 12, 129, 2736, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2746, 8, 129, 10, 129, 12, 129, 2749, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2759, 8, 129, 10, 129, 12, 129, 2762, 9, 129, 3, 129, 2764, 8, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 3, 131, 2772, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 4, 134, 2784, 8, 134, 11, 134, 12, 134, 2785, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 3, 135, 2804, 8, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 3, 136, 2822, 8, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 2836, 8, 137, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 2860, 8, 141, 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 2872, 8, 143, 1, 144, 1, 144, 1, 144, 3, 144, 2877, 8, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 4, 145, 2884, 8, 145, 11, 145, 12, 145, 2885, 3, 145, 2888, 8, 145, 1, 146, 1, 146, 1, 146, 5, 146, 2893, 8, 146, 10, 146, 12, 146, 2896, 9, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 2905, 8, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 3, 148, 2973, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 3050, 8, 149, 1, 150, 1, 150, 1, 150, 5, 150, 3055, 8, 150, 10, 150, 12, 150, 3058, 9, 150, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 3, 152, 3065, 8, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 3, 153, 3215, 8, 153, 1, 154, 1, 154, 5, 154, 3219, 8, 154, 10, 154, 12, 154, 3222, 9, 154, 1, 155, 1, 155, 5, 155, 3226, 8, 155, 10, 155, 12, 155, 3229, 9, 155, 1, 156, 5, 156, 3232, 8, 156, 10, 156, 12, 156, 3235, 9, 156, 1, 157, 5, 157, 3238, 8, 157, 10, 157, 12, 157, 3241, 9, 157, 1, 158, 5, 158, 3244, 8, 158, 10, 158, 12, 158, 3247, 9, 158, 1, 159, 5, 159, 3250, 8, 159, 10, 159, 12, 159, 3253, 9, 159, 1, 160, 5, 160, 3256, 8, 160, 10, 160, 12, 160, 3259, 9, 160, 1, 161, 5, 161, 3262, 8, 161, 10, 161, 12, 161, 3265, 9, 161, 1, 162, 5, 162, 3268, 8, 162, 10, 162, 12, 162, 3271, 9, 162, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 3277, 8, 163, 1, 164, 5, 164, 3280, 8, 164, 10, 164, 12, 164, 3283, 9, 164, 1, 165, 1, 165, 1, 165, 3, 165, 3288, 8, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 3, 166, 3315, 8, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 3, 167, 3329, 8, 167, 1, 168, 5, 168, 3332, 8, 168, 10, 168, 12, 168, 3335, 9, 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, 169, 3, 169, 3351, 8, 169, 1, 170, 1, 170, 1, 170, 5, 170, 3356, 8, 170, 10, 170, 12, 170, 3359, 9, 170, 1, 170, 1, 170, 1, 171, 1, 171, 5, 171, 3365, 8, 171, 10, 171, 12, 171, 3368, 9, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, 172, 3387, 8, 172, 1, 173, 5, 173, 3390, 8, 173, 10, 173, 12, 173, 3393, 9, 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, 3, 174, 3408, 8, 174, 1, 175, 1, 175, 5, 175, 3412, 8, 175, 10, 175, 12, 175, 3415, 9, 175, 1, 175, 1, 175, 1, 175, 5, 175, 3420, 8, 175, 10, 175, 12, 175, 3423, 9, 175, 1, 175, 1, 175, 1, 175, 1, 175, 3, 175, 3429, 8, 175, 1, 176, 1, 176, 1, 177, 5, 177, 3434, 8, 177, 10, 177, 12, 177, 3437, 9, 177, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 3, 178, 3449, 8, 178, 1, 178, 0, 1, 68, 179, 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, 0, 14, 6, 0, 1, 15, 199, 199, 243, 243, 247, 247, 264, 264, 289, 289, 5, 0, 16, 16, 199, 199, 243, 243, 264, 264, 288, 289, 1, 0, 263, 264, 1, 0, 173, 174, 1, 0, 37, 38, 1, 0, 73, 74, 3, 0, 2, 2, 61, 61, 77, 83, 2, 0, 229, 229, 260, 261, 1, 0, 95, 96, 1, 0, 97, 111, 2, 0, 173, 173, 289, 290, 2, 0, 179, 179, 264, 264, 1, 0, 167, 168, 1, 0, 51, 52, 3915, 0, 358, 1, 0, 0, 0, 2, 376, 1, 0, 0, 0, 4, 378, 1, 0, 0, 0, 6, 385, 1, 0, 0, 0, 8, 394, 1, 0, 0, 0, 10, 447, 1, 0, 0, 0, 12, 449, 1, 0, 0, 0, 14, 452, 1, 0, 0, 0, 16, 455, 1, 0, 0, 0, 18, 459, 1, 0, 0, 0, 20, 462, 1, 0, 0, 0, 22, 465, 1, 0, 0, 0, 24, 472, 1, 0, 0, 0, 26, 488, 1, 0, 0, 0, 28, 490, 1, 0, 0, 0, 30, 492, 1, 0, 0, 0, 32, 502, 1, 0, 0, 0, 34, 504, 1, 0, 0, 0, 36, 527, 1, 0, 0, 0, 38, 531, 1, 0, 0, 0, 40, 549, 1, 0, 0, 0, 42, 576, 1, 0, 0, 0, 44, 599, 1, 0, 0, 0, 46, 635, 1, 0, 0, 0, 48, 637, 1, 0, 0, 0, 50, 645, 1, 0, 0, 0, 52, 647, 1, 0, 0, 0, 54, 654, 1, 0, 0, 0, 56, 666, 1, 0, 0, 0, 58, 669, 1, 0, 0, 0, 60, 671, 1, 0, 0, 0, 62, 684, 1, 0, 0, 0, 64, 692, 1, 0, 0, 0, 66, 694, 1, 0, 0, 0, 68, 702, 1, 0, 0, 0, 70, 718, 1, 0, 0, 0, 72, 724, 1, 0, 0, 0, 74, 727, 1, 0, 0, 0, 76, 776, 1, 0, 0, 0, 78, 781, 1, 0, 0, 0, 80, 786, 1, 0, 0, 0, 82, 791, 1, 0, 0, 0, 84, 799, 1, 0, 0, 0, 86, 804, 1, 0, 0, 0, 88, 909, 1, 0, 0, 0, 90, 937, 1, 0, 0, 0, 92, 939, 1, 0, 0, 0, 94, 943, 1, 0, 0, 0, 96, 945, 1, 0, 0, 0, 98, 950, 1, 0, 0, 0, 100, 978, 1, 0, 0, 0, 102, 1058, 1, 0, 0, 0, 104, 1060, 1, 0, 0, 0, 106, 1089, 1, 0, 0, 0, 108, 1091, 1, 0, 0, 0, 110, 1105, 1, 0, 0, 0, 112, 1134, 1, 0, 0, 0, 114, 1146, 1, 0, 0, 0, 116, 1185, 1, 0, 0, 0, 118, 1193, 1, 0, 0, 0, 120, 1202, 1, 0, 0, 0, 122, 1210, 1, 0, 0, 0, 124, 1229, 1, 0, 0, 0, 126, 1242, 1, 0, 0, 0, 128, 1266, 1, 0, 0, 0, 130, 1413, 1, 0, 0, 0, 132, 1423, 1, 0, 0, 0, 134, 1435, 1, 0, 0, 0, 136, 1517, 1, 0, 0, 0, 138, 1519, 1, 0, 0, 0, 140, 1558, 1, 0, 0, 0, 142, 1618, 1, 0, 0, 0, 144, 1658, 1, 0, 0, 0, 146, 1674, 1, 0, 0, 0, 148, 1676, 1, 0, 0, 0, 150, 1680, 1, 0, 0, 0, 152, 1735, 1, 0, 0, 0, 154, 1747, 1, 0, 0, 0, 156, 1762, 1, 0, 0, 0, 158, 1769, 1, 0, 0, 0, 160, 1774, 1, 0, 0, 0, 162, 1778, 1, 0, 0, 0, 164, 1814, 1, 0, 0, 0, 166, 1816, 1, 0, 0, 0, 168, 1860, 1, 0, 0, 0, 170, 1879, 1, 0, 0, 0, 172, 1900, 1, 0, 0, 0, 174, 1902, 1, 0, 0, 0, 176, 1919, 1, 0, 0, 0, 178, 1934, 1, 0, 0, 0, 180, 1942, 1, 0, 0, 0, 182, 1954, 1, 0, 0, 0, 184, 1974, 1, 0, 0, 0, 186, 1981, 1, 0, 0, 0, 188, 1984, 1, 0, 0, 0, 190, 1997, 1, 0, 0, 0, 192, 2003, 1, 0, 0, 0, 194, 2009, 1, 0, 0, 0, 196, 2013, 1, 0, 0, 0, 198, 2170, 1, 0, 0, 0, 200, 2172, 1, 0, 0, 0, 202, 2228, 1, 0, 0, 0, 204, 2239, 1, 0, 0, 0, 206, 2246, 1, 0, 0, 0, 208, 2254, 1, 0, 0, 0, 210, 2281, 1, 0, 0, 0, 212, 2287, 1, 0, 0, 0, 214, 2292, 1, 0, 0, 0, 216, 2321, 1, 0, 0, 0, 218, 2323, 1, 0, 0, 0, 220, 2343, 1, 0, 0, 0, 222, 2348, 1, 0, 0, 0, 224, 2373, 1, 0, 0, 0, 226, 2382, 1, 0, 0, 0, 228, 2397, 1, 0, 0, 0, 230, 2404, 1, 0, 0, 0, 232, 2424, 1, 0, 0, 0, 234, 2426, 1, 0, 0, 0, 236, 2497, 1, 0, 0, 0, 238, 2522, 1, 0, 0, 0, 240, 2566, 1, 0, 0, 0, 242, 2575, 1, 0, 0, 0, 244, 2615, 1, 0, 0, 0, 246, 2620, 1, 0, 0, 0, 248, 2660, 1, 0, 0, 0, 250, 2662, 1, 0, 0, 0, 252, 2668, 1, 0, 0, 0, 254, 2676, 1, 0, 0, 0, 256, 2696, 1, 0, 0, 0, 258, 2763, 1, 0, 0, 0, 260, 2765, 1, 0, 0, 0, 262, 2771, 1, 0, 0, 0, 264, 2773, 1, 0, 0, 0, 266, 2777, 1, 0, 0, 0, 268, 2783, 1, 0, 0, 0, 270, 2803, 1, 0, 0, 0, 272, 2821, 1, 0, 0, 0, 274, 2835, 1, 0, 0, 0, 276, 2837, 1, 0, 0, 0, 278, 2840, 1, 0, 0, 0, 280, 2842, 1, 0, 0, 0, 282, 2859, 1, 0, 0, 0, 284, 2861, 1, 0, 0, 0, 286, 2871, 1, 0, 0, 0, 288, 2876, 1, 0, 0, 0, 290, 2887, 1, 0, 0, 0, 292, 2894, 1, 0, 0, 0, 294, 2904, 1, 0, 0, 0, 296, 2972, 1, 0, 0, 0, 298, 3049, 1, 0, 0, 0, 300, 3056, 1, 0, 0, 0, 302, 3059, 1, 0, 0, 0, 304, 3064, 1, 0, 0, 0, 306, 3214, 1, 0, 0, 0, 308, 3220, 1, 0, 0, 0, 310, 3227, 1, 0, 0, 0, 312, 3233, 1, 0, 0, 0, 314, 3239, 1, 0, 0, 0, 316, 3245, 1, 0, 0, 0, 318, 3251, 1, 0, 0, 0, 320, 3257, 1, 0, 0, 0, 322, 3263, 1, 0, 0, 0, 324, 3269, 1, 0, 0, 0, 326, 3276, 1, 0, 0, 0, 328, 3281, 1, 0, 0, 0, 330, 3287, 1, 0, 0, 0, 332, 3314, 1, 0, 0, 0, 334, 3328, 1, 0, 0, 0, 336, 3333, 1, 0, 0, 0, 338, 3350, 1, 0, 0, 0, 340, 3352, 1, 0, 0, 0, 342, 3362, 1, 0, 0, 0, 344, 3386, 1, 0, 0, 0, 346, 3391, 1, 0, 0, 0, 348, 3407, 1, 0, 0, 0, 350, 3428, 1, 0, 0, 0, 352, 3430, 1, 0, 0, 0, 354, 3435, 1, 0, 0, 0, 356, 3448, 1, 0, 0, 0, 358, 359, 7, 0, 0, 0, 359, 1, 1, 0, 0, 0, 360, 361, 5, 288, 0, 0, 361, 377, 6, 1, -1, 0, 362, 363, 3, 4, 2, 0, 363, 364, 6, 1, -1, 0, 364, 365, 5, 265, 0, 0, 365, 367, 1, 0, 0, 0, 366, 362, 1, 0, 0, 0, 367, 370, 1, 0, 0, 0, 368, 366, 1, 0, 0, 0, 368, 369, 1, 0, 0, 0, 369, 371, 1, 0, 0, 0, 370, 368, 1, 0, 0, 0, 371, 372, 3, 4, 2, 0, 372, 373, 6, 1, -1, 0, 373, 377, 1, 0, 0, 0, 374, 375, 5, 264, 0, 0, 375, 377, 6, 1, -1, 0, 376, 360, 1, 0, 0, 0, 376, 368, 1, 0, 0, 0, 376, 374, 1, 0, 0, 0, 377, 3, 1, 0, 0, 0, 378, 379, 7, 1, 0, 0, 379, 5, 1, 0, 0, 0, 380, 381, 5, 263, 0, 0, 381, 382, 6, 3, -1, 0, 382, 384, 5, 266, 0, 0, 383, 380, 1, 0, 0, 0, 384, 387, 1, 0, 0, 0, 385, 383, 1, 0, 0, 0, 385, 386, 1, 0, 0, 0, 386, 388, 1, 0, 0, 0, 387, 385, 1, 0, 0, 0, 388, 389, 5, 263, 0, 0, 389, 390, 6, 3, -1, 0, 390, 7, 1, 0, 0, 0, 391, 393, 3, 10, 5, 0, 392, 391, 1, 0, 0, 0, 393, 396, 1, 0, 0, 0, 394, 392, 1, 0, 0, 0, 394, 395, 1, 0, 0, 0, 395, 9, 1, 0, 0, 0, 396, 394, 1, 0, 0, 0, 397, 398, 3, 74, 37, 0, 398, 399, 5, 17, 0, 0, 399, 400, 3, 82, 41, 0, 400, 401, 5, 18, 0, 0, 401, 448, 1, 0, 0, 0, 402, 403, 3, 72, 36, 0, 403, 404, 5, 17, 0, 0, 404, 405, 3, 8, 4, 0, 405, 406, 5, 18, 0, 0, 406, 448, 1, 0, 0, 0, 407, 408, 3, 234, 117, 0, 408, 409, 5, 17, 0, 0, 409, 410, 3, 246, 123, 0, 410, 411, 5, 18, 0, 0, 411, 448, 1, 0, 0, 0, 412, 448, 3, 200, 100, 0, 413, 448, 3, 284, 142, 0, 414, 448, 3, 70, 35, 0, 415, 448, 3, 66, 33, 0, 416, 448, 3, 88, 44, 0, 417, 448, 3, 90, 45, 0, 418, 448, 3, 22, 11, 0, 419, 420, 3, 334, 167, 0, 420, 421, 5, 17, 0, 0, 421, 422, 3, 336, 168, 0, 422, 423, 5, 18, 0, 0, 423, 448, 1, 0, 0, 0, 424, 425, 3, 340, 170, 0, 425, 426, 5, 17, 0, 0, 426, 427, 3, 346, 173, 0, 427, 428, 5, 18, 0, 0, 428, 448, 1, 0, 0, 0, 429, 430, 3, 350, 175, 0, 430, 431, 5, 17, 0, 0, 431, 432, 3, 354, 177, 0, 432, 433, 5, 18, 0, 0, 433, 448, 1, 0, 0, 0, 434, 448, 3, 64, 32, 0, 435, 448, 3, 152, 76, 0, 436, 448, 3, 330, 165, 0, 437, 448, 3, 12, 6, 0, 438, 448, 3, 14, 7, 0, 439, 448, 3, 16, 8, 0, 440, 448, 3, 18, 9, 0, 441, 448, 3, 20, 10, 0, 442, 448, 3, 26, 13, 0, 443, 448, 3, 42, 21, 0, 444, 448, 3, 40, 20, 0, 445, 448, 3, 30, 15, 0, 446, 448, 3, 24, 12, 0, 447, 397, 1, 0, 0, 0, 447, 402, 1, 0, 0, 0, 447, 407, 1, 0, 0, 0, 447, 412, 1, 0, 0, 0, 447, 413, 1, 0, 0, 0, 447, 414, 1, 0, 0, 0, 447, 415, 1, 0, 0, 0, 447, 416, 1, 0, 0, 0, 447, 417, 1, 0, 0, 0, 447, 418, 1, 0, 0, 0, 447, 419, 1, 0, 0, 0, 447, 424, 1, 0, 0, 0, 447, 429, 1, 0, 0, 0, 447, 434, 1, 0, 0, 0, 447, 435, 1, 0, 0, 0, 447, 436, 1, 0, 0, 0, 447, 437, 1, 0, 0, 0, 447, 438, 1, 0, 0, 0, 447, 439, 1, 0, 0, 0, 447, 440, 1, 0, 0, 0, 447, 441, 1, 0, 0, 0, 447, 442, 1, 0, 0, 0, 447, 443, 1, 0, 0, 0, 447, 444, 1, 0, 0, 0, 447, 445, 1, 0, 0, 0, 447, 446, 1, 0, 0, 0, 448, 11, 1, 0, 0, 0, 449, 450, 5, 19, 0, 0, 450, 451, 3, 32, 16, 0, 451, 13, 1, 0, 0, 0, 452, 453, 5, 20, 0, 0, 453, 454, 3, 32, 16, 0, 454, 15, 1, 0, 0, 0, 455, 456, 5, 21, 0, 0, 456, 457, 5, 22, 0, 0, 457, 458, 3, 32, 16, 0, 458, 17, 1, 0, 0, 0, 459, 460, 5, 23, 0, 0, 460, 461, 3, 34, 17, 0, 461, 19, 1, 0, 0, 0, 462, 463, 5, 24, 0, 0, 463, 464, 3, 34, 17, 0, 464, 21, 1, 0, 0, 0, 465, 466, 5, 25, 0, 0, 466, 467, 3, 98, 49, 0, 467, 468, 3, 2, 1, 0, 468, 469, 5, 17, 0, 0, 469, 470, 3, 120, 60, 0, 470, 471, 5, 18, 0, 0, 471, 23, 1, 0, 0, 0, 472, 473, 5, 26, 0, 0, 473, 25, 1, 0, 0, 0, 474, 475, 5, 27, 0, 0, 475, 489, 3, 28, 14, 0, 476, 477, 5, 27, 0, 0, 477, 478, 3, 28, 14, 0, 478, 479, 5, 28, 0, 0, 479, 480, 3, 28, 14, 0, 480, 489, 1, 0, 0, 0, 481, 482, 5, 27, 0, 0, 482, 483, 3, 28, 14, 0, 483, 484, 5, 28, 0, 0, 484, 485, 3, 28, 14, 0, 485, 486, 5, 28, 0, 0, 486, 487, 3, 28, 14, 0, 487, 489, 1, 0, 0, 0, 488, 474, 1, 0, 0, 0, 488, 476, 1, 0, 0, 0, 488, 481, 1, 0, 0, 0, 489, 27, 1, 0, 0, 0, 490, 491, 7, 2, 0, 0, 491, 29, 1, 0, 0, 0, 492, 493, 5, 29, 0, 0, 493, 497, 5, 17, 0, 0, 494, 496, 3, 116, 58, 0, 495, 494, 1, 0, 0, 0, 496, 499, 1, 0, 0, 0, 497, 495, 1, 0, 0, 0, 497, 498, 1, 0, 0, 0, 498, 500, 1, 0, 0, 0, 499, 497, 1, 0, 0, 0, 500, 501, 5, 18, 0, 0, 501, 31, 1, 0, 0, 0, 502, 503, 5, 173, 0, 0, 503, 33, 1, 0, 0, 0, 504, 505, 7, 3, 0, 0, 505, 35, 1, 0, 0, 0, 506, 507, 5, 175, 0, 0, 507, 528, 6, 18, -1, 0, 508, 509, 3, 32, 16, 0, 509, 510, 5, 265, 0, 0, 510, 511, 6, 18, -1, 0, 511, 528, 1, 0, 0, 0, 512, 513, 3, 32, 16, 0, 513, 514, 6, 18, -1, 0, 514, 528, 1, 0, 0, 0, 515, 516, 5, 188, 0, 0, 516, 517, 5, 30, 0, 0, 517, 518, 3, 32, 16, 0, 518, 519, 5, 31, 0, 0, 519, 520, 6, 18, -1, 0, 520, 528, 1, 0, 0, 0, 521, 522, 5, 189, 0, 0, 522, 523, 5, 30, 0, 0, 523, 524, 3, 34, 17, 0, 524, 525, 5, 31, 0, 0, 525, 526, 6, 18, -1, 0, 526, 528, 1, 0, 0, 0, 527, 506, 1, 0, 0, 0, 527, 508, 1, 0, 0, 0, 527, 512, 1, 0, 0, 0, 527, 515, 1, 0, 0, 0, 527, 521, 1, 0, 0, 0, 528, 37, 1, 0, 0, 0, 529, 532, 3, 32, 16, 0, 530, 532, 5, 262, 0, 0, 531, 529, 1, 0, 0, 0, 531, 530, 1, 0, 0, 0, 532, 39, 1, 0, 0, 0, 533, 534, 5, 267, 0, 0, 534, 550, 5, 289, 0, 0, 535, 536, 5, 267, 0, 0, 536, 537, 5, 289, 0, 0, 537, 550, 5, 263, 0, 0, 538, 539, 5, 268, 0, 0, 539, 550, 5, 289, 0, 0, 540, 541, 5, 269, 0, 0, 541, 550, 5, 289, 0, 0, 542, 543, 5, 270, 0, 0, 543, 550, 5, 289, 0, 0, 544, 550, 5, 271, 0, 0, 545, 550, 5, 272, 0, 0, 546, 547, 5, 273, 0, 0, 547, 550, 5, 263, 0, 0, 548, 550, 5, 32, 0, 0, 549, 533, 1, 0, 0, 0, 549, 535, 1, 0, 0, 0, 549, 538, 1, 0, 0, 0, 549, 540, 1, 0, 0, 0, 549, 542, 1, 0, 0, 0, 549, 544, 1, 0, 0, 0, 549, 545, 1, 0, 0, 0, 549, 546, 1, 0, 0, 0, 549, 548, 1, 0, 0, 0, 550, 41, 1, 0, 0, 0, 551, 552, 5, 33, 0, 0, 552, 553, 3, 138, 69, 0, 553, 554, 5, 34, 0, 0, 554, 555, 3, 2, 1, 0, 555, 577, 1, 0, 0, 0, 556, 557, 5, 33, 0, 0, 557, 558, 3, 116, 58, 0, 558, 559, 5, 34, 0, 0, 559, 560, 3, 2, 1, 0, 560, 577, 1, 0, 0, 0, 561, 562, 5, 33, 0, 0, 562, 563, 3, 176, 88, 0, 563, 564, 5, 34, 0, 0, 564, 565, 3, 2, 1, 0, 565, 577, 1, 0, 0, 0, 566, 567, 5, 33, 0, 0, 567, 568, 3, 44, 22, 0, 568, 569, 5, 34, 0, 0, 569, 570, 3, 2, 1, 0, 570, 577, 1, 0, 0, 0, 571, 572, 5, 33, 0, 0, 572, 573, 3, 46, 23, 0, 573, 574, 5, 34, 0, 0, 574, 575, 3, 2, 1, 0, 575, 577, 1, 0, 0, 0, 576, 551, 1, 0, 0, 0, 576, 556, 1, 0, 0, 0, 576, 561, 1, 0, 0, 0, 576, 566, 1, 0, 0, 0, 576, 571, 1, 0, 0, 0, 577, 43, 1, 0, 0, 0, 578, 579, 5, 35, 0, 0, 579, 600, 3, 48, 24, 0, 580, 581, 5, 35, 0, 0, 581, 582, 3, 48, 24, 0, 582, 583, 5, 36, 0, 0, 583, 584, 3, 6, 3, 0, 584, 600, 1, 0, 0, 0, 585, 586, 5, 35, 0, 0, 586, 587, 3, 48, 24, 0, 587, 588, 5, 36, 0, 0, 588, 589, 5, 17, 0, 0, 589, 590, 3, 52, 26, 0, 590, 591, 5, 18, 0, 0, 591, 600, 1, 0, 0, 0, 592, 593, 5, 35, 0, 0, 593, 594, 3, 48, 24, 0, 594, 595, 5, 36, 0, 0, 595, 596, 5, 30, 0, 0, 596, 597, 3, 300, 150, 0, 597, 598, 5, 31, 0, 0, 598, 600, 1, 0, 0, 0, 599, 578, 1, 0, 0, 0, 599, 580, 1, 0, 0, 0, 599, 585, 1, 0, 0, 0, 599, 592, 1, 0, 0, 0, 600, 45, 1, 0, 0, 0, 601, 602, 5, 35, 0, 0, 602, 603, 5, 30, 0, 0, 603, 604, 3, 50, 25, 0, 604, 605, 5, 31, 0, 0, 605, 606, 3, 48, 24, 0, 606, 636, 1, 0, 0, 0, 607, 608, 5, 35, 0, 0, 608, 609, 5, 30, 0, 0, 609, 610, 3, 50, 25, 0, 610, 611, 5, 31, 0, 0, 611, 612, 3, 48, 24, 0, 612, 613, 5, 36, 0, 0, 613, 614, 3, 6, 3, 0, 614, 636, 1, 0, 0, 0, 615, 616, 5, 35, 0, 0, 616, 617, 5, 30, 0, 0, 617, 618, 3, 50, 25, 0, 618, 619, 5, 31, 0, 0, 619, 620, 3, 48, 24, 0, 620, 621, 5, 36, 0, 0, 621, 622, 5, 17, 0, 0, 622, 623, 3, 52, 26, 0, 623, 624, 5, 18, 0, 0, 624, 636, 1, 0, 0, 0, 625, 626, 5, 35, 0, 0, 626, 627, 5, 30, 0, 0, 627, 628, 3, 50, 25, 0, 628, 629, 5, 31, 0, 0, 629, 630, 3, 48, 24, 0, 630, 631, 5, 36, 0, 0, 631, 632, 5, 30, 0, 0, 632, 633, 3, 300, 150, 0, 633, 634, 5, 31, 0, 0, 634, 636, 1, 0, 0, 0, 635, 601, 1, 0, 0, 0, 635, 607, 1, 0, 0, 0, 635, 615, 1, 0, 0, 0, 635, 625, 1, 0, 0, 0, 636, 47, 1, 0, 0, 0, 637, 638, 3, 168, 84, 0, 638, 49, 1, 0, 0, 0, 639, 640, 3, 124, 62, 0, 640, 641, 6, 25, -1, 0, 641, 646, 1, 0, 0, 0, 642, 643, 3, 176, 88, 0, 643, 644, 6, 25, -1, 0, 644, 646, 1, 0, 0, 0, 645, 639, 1, 0, 0, 0, 645, 642, 1, 0, 0, 0, 646, 51, 1, 0, 0, 0, 647, 648, 3, 54, 27, 0, 648, 649, 3, 56, 28, 0, 649, 53, 1, 0, 0, 0, 650, 653, 3, 306, 153, 0, 651, 653, 3, 40, 20, 0, 652, 650, 1, 0, 0, 0, 652, 651, 1, 0, 0, 0, 653, 656, 1, 0, 0, 0, 654, 652, 1, 0, 0, 0, 654, 655, 1, 0, 0, 0, 655, 55, 1, 0, 0, 0, 656, 654, 1, 0, 0, 0, 657, 658, 3, 58, 29, 0, 658, 659, 3, 60, 30, 0, 659, 660, 3, 2, 1, 0, 660, 661, 5, 36, 0, 0, 661, 662, 3, 306, 153, 0, 662, 665, 1, 0, 0, 0, 663, 665, 3, 40, 20, 0, 664, 657, 1, 0, 0, 0, 664, 663, 1, 0, 0, 0, 665, 668, 1, 0, 0, 0, 666, 664, 1, 0, 0, 0, 666, 667, 1, 0, 0, 0, 667, 57, 1, 0, 0, 0, 668, 666, 1, 0, 0, 0, 669, 670, 7, 4, 0, 0, 670, 59, 1, 0, 0, 0, 671, 673, 3, 62, 31, 0, 672, 674, 5, 261, 0, 0, 673, 672, 1, 0, 0, 0, 673, 674, 1, 0, 0, 0, 674, 61, 1, 0, 0, 0, 675, 685, 3, 144, 72, 0, 676, 685, 3, 2, 1, 0, 677, 685, 5, 196, 0, 0, 678, 685, 5, 197, 0, 0, 679, 680, 5, 202, 0, 0, 680, 681, 5, 39, 0, 0, 681, 685, 5, 264, 0, 0, 682, 683, 5, 202, 0, 0, 683, 685, 3, 116, 58, 0, 684, 675, 1, 0, 0, 0, 684, 676, 1, 0, 0, 0, 684, 677, 1, 0, 0, 0, 684, 678, 1, 0, 0, 0, 684, 679, 1, 0, 0, 0, 684, 682, 1, 0, 0, 0, 685, 63, 1, 0, 0, 0, 686, 687, 5, 198, 0, 0, 687, 688, 5, 40, 0, 0, 688, 693, 3, 2, 1, 0, 689, 690, 5, 198, 0, 0, 690, 693, 3, 2, 1, 0, 691, 693, 5, 198, 0, 0, 692, 686, 1, 0, 0, 0, 692, 689, 1, 0, 0, 0, 692, 691, 1, 0, 0, 0, 693, 65, 1, 0, 0, 0, 694, 695, 5, 41, 0, 0, 695, 696, 5, 42, 0, 0, 696, 697, 3, 32, 16, 0, 697, 698, 5, 43, 0, 0, 698, 699, 3, 68, 34, 0, 699, 700, 5, 44, 0, 0, 700, 701, 3, 0, 0, 0, 701, 67, 1, 0, 0, 0, 702, 715, 6, 34, -1, 0, 703, 704, 10, 5, 0, 0, 704, 714, 5, 186, 0, 0, 705, 706, 10, 4, 0, 0, 706, 714, 5, 187, 0, 0, 707, 708, 10, 3, 0, 0, 708, 714, 5, 45, 0, 0, 709, 710, 10, 2, 0, 0, 710, 714, 5, 46, 0, 0, 711, 712, 10, 1, 0, 0, 712, 714, 5, 47, 0, 0, 713, 703, 1, 0, 0, 0, 713, 705, 1, 0, 0, 0, 713, 707, 1, 0, 0, 0, 713, 709, 1, 0, 0, 0, 713, 711, 1, 0, 0, 0, 714, 717, 1, 0, 0, 0, 715, 713, 1, 0, 0, 0, 715, 716, 1, 0, 0, 0, 716, 69, 1, 0, 0, 0, 717, 715, 1, 0, 0, 0, 718, 719, 5, 48, 0, 0, 719, 720, 5, 36, 0, 0, 720, 721, 5, 30, 0, 0, 721, 722, 3, 300, 150, 0, 722, 723, 5, 31, 0, 0, 723, 71, 1, 0, 0, 0, 724, 725, 5, 49, 0, 0, 725, 726, 3, 2, 1, 0, 726, 73, 1, 0, 0, 0, 727, 731, 5, 50, 0, 0, 728, 730, 3, 76, 38, 0, 729, 728, 1, 0, 0, 0, 730, 733, 1, 0, 0, 0, 731, 729, 1, 0, 0, 0, 731, 732, 1, 0, 0, 0, 732, 734, 1, 0, 0, 0, 733, 731, 1, 0, 0, 0, 734, 735, 3, 2, 1, 0, 735, 736, 3, 182, 91, 0, 736, 737, 3, 78, 39, 0, 737, 738, 3, 80, 40, 0, 738, 75, 1, 0, 0, 0, 739, 777, 5, 51, 0, 0, 740, 777, 5, 52, 0, 0, 741, 777, 5, 199, 0, 0, 742, 777, 5, 202, 0, 0, 743, 777, 5, 221, 0, 0, 744, 777, 5, 53, 0, 0, 745, 777, 5, 54, 0, 0, 746, 777, 5, 55, 0, 0, 747, 777, 5, 56, 0, 0, 748, 777, 5, 244, 0, 0, 749, 777, 5, 15, 0, 0, 750, 777, 5, 224, 0, 0, 751, 777, 5, 57, 0, 0, 752, 777, 5, 58, 0, 0, 753, 777, 5, 59, 0, 0, 754, 777, 5, 60, 0, 0, 755, 777, 5, 61, 0, 0, 756, 757, 5, 62, 0, 0, 757, 777, 5, 51, 0, 0, 758, 759, 5, 62, 0, 0, 759, 777, 5, 52, 0, 0, 760, 761, 5, 62, 0, 0, 761, 777, 5, 63, 0, 0, 762, 763, 5, 62, 0, 0, 763, 777, 5, 64, 0, 0, 764, 765, 5, 62, 0, 0, 765, 777, 5, 65, 0, 0, 766, 767, 5, 62, 0, 0, 767, 777, 5, 66, 0, 0, 768, 777, 5, 67, 0, 0, 769, 777, 5, 68, 0, 0, 770, 777, 5, 69, 0, 0, 771, 772, 5, 70, 0, 0, 772, 773, 5, 30, 0, 0, 773, 774, 3, 32, 16, 0, 774, 775, 5, 31, 0, 0, 775, 777, 1, 0, 0, 0, 776, 739, 1, 0, 0, 0, 776, 740, 1, 0, 0, 0, 776, 741, 1, 0, 0, 0, 776, 742, 1, 0, 0, 0, 776, 743, 1, 0, 0, 0, 776, 744, 1, 0, 0, 0, 776, 745, 1, 0, 0, 0, 776, 746, 1, 0, 0, 0, 776, 747, 1, 0, 0, 0, 776, 748, 1, 0, 0, 0, 776, 749, 1, 0, 0, 0, 776, 750, 1, 0, 0, 0, 776, 751, 1, 0, 0, 0, 776, 752, 1, 0, 0, 0, 776, 753, 1, 0, 0, 0, 776, 754, 1, 0, 0, 0, 776, 755, 1, 0, 0, 0, 776, 756, 1, 0, 0, 0, 776, 758, 1, 0, 0, 0, 776, 760, 1, 0, 0, 0, 776, 762, 1, 0, 0, 0, 776, 764, 1, 0, 0, 0, 776, 766, 1, 0, 0, 0, 776, 768, 1, 0, 0, 0, 776, 769, 1, 0, 0, 0, 776, 770, 1, 0, 0, 0, 776, 771, 1, 0, 0, 0, 777, 77, 1, 0, 0, 0, 778, 782, 1, 0, 0, 0, 779, 780, 5, 71, 0, 0, 780, 782, 3, 124, 62, 0, 781, 778, 1, 0, 0, 0, 781, 779, 1, 0, 0, 0, 782, 79, 1, 0, 0, 0, 783, 787, 1, 0, 0, 0, 784, 785, 5, 72, 0, 0, 785, 787, 3, 84, 42, 0, 786, 783, 1, 0, 0, 0, 786, 784, 1, 0, 0, 0, 787, 81, 1, 0, 0, 0, 788, 790, 3, 198, 99, 0, 789, 788, 1, 0, 0, 0, 790, 793, 1, 0, 0, 0, 791, 789, 1, 0, 0, 0, 791, 792, 1, 0, 0, 0, 792, 83, 1, 0, 0, 0, 793, 791, 1, 0, 0, 0, 794, 795, 3, 124, 62, 0, 795, 796, 5, 28, 0, 0, 796, 798, 1, 0, 0, 0, 797, 794, 1, 0, 0, 0, 798, 801, 1, 0, 0, 0, 799, 797, 1, 0, 0, 0, 799, 800, 1, 0, 0, 0, 800, 802, 1, 0, 0, 0, 801, 799, 1, 0, 0, 0, 802, 803, 3, 124, 62, 0, 803, 85, 1, 0, 0, 0, 804, 805, 7, 5, 0, 0, 805, 87, 1, 0, 0, 0, 806, 807, 3, 86, 43, 0, 807, 808, 3, 32, 16, 0, 808, 809, 5, 264, 0, 0, 809, 910, 1, 0, 0, 0, 810, 811, 3, 86, 43, 0, 811, 812, 3, 32, 16, 0, 812, 910, 1, 0, 0, 0, 813, 814, 3, 86, 43, 0, 814, 815, 3, 32, 16, 0, 815, 816, 5, 75, 0, 0, 816, 817, 3, 32, 16, 0, 817, 818, 5, 264, 0, 0, 818, 910, 1, 0, 0, 0, 819, 820, 3, 86, 43, 0, 820, 821, 3, 32, 16, 0, 821, 822, 5, 75, 0, 0, 822, 823, 3, 32, 16, 0, 823, 910, 1, 0, 0, 0, 824, 825, 3, 86, 43, 0, 825, 826, 3, 32, 16, 0, 826, 827, 5, 75, 0, 0, 827, 828, 3, 32, 16, 0, 828, 829, 5, 28, 0, 0, 829, 830, 3, 32, 16, 0, 830, 831, 5, 264, 0, 0, 831, 910, 1, 0, 0, 0, 832, 833, 3, 86, 43, 0, 833, 834, 3, 32, 16, 0, 834, 835, 5, 75, 0, 0, 835, 836, 3, 32, 16, 0, 836, 837, 5, 28, 0, 0, 837, 838, 3, 32, 16, 0, 838, 910, 1, 0, 0, 0, 839, 840, 3, 86, 43, 0, 840, 841, 3, 32, 16, 0, 841, 842, 5, 28, 0, 0, 842, 843, 3, 32, 16, 0, 843, 844, 5, 75, 0, 0, 844, 845, 3, 32, 16, 0, 845, 846, 5, 264, 0, 0, 846, 910, 1, 0, 0, 0, 847, 848, 3, 86, 43, 0, 848, 849, 3, 32, 16, 0, 849, 850, 5, 28, 0, 0, 850, 851, 3, 32, 16, 0, 851, 852, 5, 75, 0, 0, 852, 853, 3, 32, 16, 0, 853, 910, 1, 0, 0, 0, 854, 855, 3, 86, 43, 0, 855, 856, 3, 32, 16, 0, 856, 857, 5, 28, 0, 0, 857, 858, 3, 32, 16, 0, 858, 859, 5, 75, 0, 0, 859, 860, 3, 32, 16, 0, 860, 861, 5, 28, 0, 0, 861, 862, 3, 32, 16, 0, 862, 863, 5, 264, 0, 0, 863, 910, 1, 0, 0, 0, 864, 865, 3, 86, 43, 0, 865, 866, 3, 32, 16, 0, 866, 867, 5, 28, 0, 0, 867, 868, 3, 32, 16, 0, 868, 869, 5, 75, 0, 0, 869, 870, 3, 32, 16, 0, 870, 871, 5, 28, 0, 0, 871, 872, 3, 32, 16, 0, 872, 910, 1, 0, 0, 0, 873, 874, 3, 86, 43, 0, 874, 875, 3, 32, 16, 0, 875, 876, 5, 263, 0, 0, 876, 910, 1, 0, 0, 0, 877, 878, 3, 86, 43, 0, 878, 879, 3, 32, 16, 0, 879, 880, 5, 75, 0, 0, 880, 881, 3, 32, 16, 0, 881, 882, 5, 263, 0, 0, 882, 910, 1, 0, 0, 0, 883, 884, 3, 86, 43, 0, 884, 885, 3, 32, 16, 0, 885, 886, 5, 75, 0, 0, 886, 887, 3, 32, 16, 0, 887, 888, 5, 28, 0, 0, 888, 889, 3, 32, 16, 0, 889, 890, 5, 263, 0, 0, 890, 910, 1, 0, 0, 0, 891, 892, 3, 86, 43, 0, 892, 893, 3, 32, 16, 0, 893, 894, 5, 28, 0, 0, 894, 895, 3, 32, 16, 0, 895, 896, 5, 75, 0, 0, 896, 897, 3, 32, 16, 0, 897, 898, 5, 263, 0, 0, 898, 910, 1, 0, 0, 0, 899, 900, 3, 86, 43, 0, 900, 901, 3, 32, 16, 0, 901, 902, 5, 28, 0, 0, 902, 903, 3, 32, 16, 0, 903, 904, 5, 75, 0, 0, 904, 905, 3, 32, 16, 0, 905, 906, 5, 28, 0, 0, 906, 907, 3, 32, 16, 0, 907, 908, 5, 263, 0, 0, 908, 910, 1, 0, 0, 0, 909, 806, 1, 0, 0, 0, 909, 810, 1, 0, 0, 0, 909, 813, 1, 0, 0, 0, 909, 819, 1, 0, 0, 0, 909, 824, 1, 0, 0, 0, 909, 832, 1, 0, 0, 0, 909, 839, 1, 0, 0, 0, 909, 847, 1, 0, 0, 0, 909, 854, 1, 0, 0, 0, 909, 864, 1, 0, 0, 0, 909, 873, 1, 0, 0, 0, 909, 877, 1, 0, 0, 0, 909, 883, 1, 0, 0, 0, 909, 891, 1, 0, 0, 0, 909, 899, 1, 0, 0, 0, 910, 89, 1, 0, 0, 0, 911, 915, 5, 21, 0, 0, 912, 914, 3, 92, 46, 0, 913, 912, 1, 0, 0, 0, 914, 917, 1, 0, 0, 0, 915, 913, 1, 0, 0, 0, 915, 916, 1, 0, 0, 0, 916, 918, 1, 0, 0, 0, 917, 915, 1, 0, 0, 0, 918, 919, 3, 2, 1, 0, 919, 920, 3, 94, 47, 0, 920, 921, 5, 180, 0, 0, 921, 922, 5, 36, 0, 0, 922, 923, 5, 30, 0, 0, 923, 924, 3, 300, 150, 0, 924, 925, 5, 31, 0, 0, 925, 926, 3, 94, 47, 0, 926, 938, 1, 0, 0, 0, 927, 931, 5, 21, 0, 0, 928, 930, 3, 92, 46, 0, 929, 928, 1, 0, 0, 0, 930, 933, 1, 0, 0, 0, 931, 929, 1, 0, 0, 0, 931, 932, 1, 0, 0, 0, 932, 934, 1, 0, 0, 0, 933, 931, 1, 0, 0, 0, 934, 935, 3, 2, 1, 0, 935, 936, 3, 94, 47, 0, 936, 938, 1, 0, 0, 0, 937, 911, 1, 0, 0, 0, 937, 927, 1, 0, 0, 0, 938, 91, 1, 0, 0, 0, 939, 940, 5, 76, 0, 0, 940, 93, 1, 0, 0, 0, 941, 944, 1, 0, 0, 0, 942, 944, 5, 298, 0, 0, 943, 941, 1, 0, 0, 0, 943, 942, 1, 0, 0, 0, 944, 95, 1, 0, 0, 0, 945, 946, 7, 6, 0, 0, 946, 97, 1, 0, 0, 0, 947, 949, 3, 96, 48, 0, 948, 947, 1, 0, 0, 0, 949, 952, 1, 0, 0, 0, 950, 948, 1, 0, 0, 0, 950, 951, 1, 0, 0, 0, 951, 99, 1, 0, 0, 0, 952, 950, 1, 0, 0, 0, 953, 979, 3, 102, 51, 0, 954, 955, 5, 280, 0, 0, 955, 956, 3, 168, 84, 0, 956, 957, 6, 50, -1, 0, 957, 979, 1, 0, 0, 0, 958, 959, 5, 286, 0, 0, 959, 960, 3, 178, 89, 0, 960, 961, 6, 50, -1, 0, 961, 979, 1, 0, 0, 0, 962, 963, 5, 286, 0, 0, 963, 964, 3, 174, 87, 0, 964, 965, 6, 50, -1, 0, 965, 979, 1, 0, 0, 0, 966, 967, 5, 284, 0, 0, 967, 968, 3, 124, 62, 0, 968, 969, 6, 50, -1, 0, 969, 979, 1, 0, 0, 0, 970, 971, 5, 281, 0, 0, 971, 972, 3, 104, 52, 0, 972, 973, 6, 50, -1, 0, 973, 979, 1, 0, 0, 0, 974, 975, 5, 287, 0, 0, 975, 976, 3, 50, 25, 0, 976, 977, 6, 50, -1, 0, 977, 979, 1, 0, 0, 0, 978, 953, 1, 0, 0, 0, 978, 954, 1, 0, 0, 0, 978, 958, 1, 0, 0, 0, 978, 962, 1, 0, 0, 0, 978, 966, 1, 0, 0, 0, 978, 970, 1, 0, 0, 0, 978, 974, 1, 0, 0, 0, 979, 101, 1, 0, 0, 0, 980, 981, 5, 275, 0, 0, 981, 1059, 6, 51, -1, 0, 982, 983, 5, 276, 0, 0, 983, 984, 3, 32, 16, 0, 984, 985, 6, 51, -1, 0, 985, 1059, 1, 0, 0, 0, 986, 987, 5, 276, 0, 0, 987, 988, 3, 0, 0, 0, 988, 989, 6, 51, -1, 0, 989, 1059, 1, 0, 0, 0, 990, 991, 5, 277, 0, 0, 991, 992, 3, 32, 16, 0, 992, 993, 6, 51, -1, 0, 993, 1059, 1, 0, 0, 0, 994, 995, 5, 278, 0, 0, 995, 996, 3, 34, 17, 0, 996, 997, 6, 51, -1, 0, 997, 1059, 1, 0, 0, 0, 998, 999, 5, 279, 0, 0, 999, 1000, 3, 36, 18, 0, 1000, 1001, 6, 51, -1, 0, 1001, 1059, 1, 0, 0, 0, 1002, 1003, 5, 279, 0, 0, 1003, 1004, 3, 34, 17, 0, 1004, 1005, 6, 51, -1, 0, 1005, 1059, 1, 0, 0, 0, 1006, 1007, 5, 279, 0, 0, 1007, 1008, 5, 30, 0, 0, 1008, 1009, 3, 300, 150, 0, 1009, 1010, 5, 31, 0, 0, 1010, 1011, 6, 51, -1, 0, 1011, 1059, 1, 0, 0, 0, 1012, 1013, 5, 279, 0, 0, 1013, 1014, 5, 84, 0, 0, 1014, 1015, 5, 30, 0, 0, 1015, 1016, 3, 300, 150, 0, 1016, 1017, 5, 31, 0, 0, 1017, 1018, 6, 51, -1, 0, 1018, 1059, 1, 0, 0, 0, 1019, 1020, 5, 282, 0, 0, 1020, 1021, 3, 32, 16, 0, 1021, 1022, 6, 51, -1, 0, 1022, 1059, 1, 0, 0, 0, 1023, 1024, 5, 282, 0, 0, 1024, 1025, 3, 0, 0, 0, 1025, 1026, 6, 51, -1, 0, 1026, 1059, 1, 0, 0, 0, 1027, 1028, 5, 285, 0, 0, 1028, 1029, 3, 6, 3, 0, 1029, 1030, 6, 51, -1, 0, 1030, 1059, 1, 0, 0, 0, 1031, 1032, 5, 285, 0, 0, 1032, 1033, 5, 224, 0, 0, 1033, 1034, 5, 30, 0, 0, 1034, 1035, 3, 6, 3, 0, 1035, 1036, 5, 31, 0, 0, 1036, 1037, 6, 51, -1, 0, 1037, 1059, 1, 0, 0, 0, 1038, 1039, 5, 285, 0, 0, 1039, 1040, 5, 84, 0, 0, 1040, 1041, 5, 30, 0, 0, 1041, 1042, 3, 300, 150, 0, 1042, 1043, 5, 31, 0, 0, 1043, 1044, 6, 51, -1, 0, 1044, 1059, 1, 0, 0, 0, 1045, 1046, 5, 287, 0, 0, 1046, 1047, 3, 32, 16, 0, 1047, 1048, 6, 51, -1, 0, 1048, 1059, 1, 0, 0, 0, 1049, 1050, 5, 283, 0, 0, 1050, 1056, 6, 51, -1, 0, 1051, 1052, 5, 30, 0, 0, 1052, 1053, 3, 106, 53, 0, 1053, 1054, 5, 31, 0, 0, 1054, 1057, 1, 0, 0, 0, 1055, 1057, 5, 85, 0, 0, 1056, 1051, 1, 0, 0, 0, 1056, 1055, 1, 0, 0, 0, 1057, 1059, 1, 0, 0, 0, 1058, 980, 1, 0, 0, 0, 1058, 982, 1, 0, 0, 0, 1058, 986, 1, 0, 0, 0, 1058, 990, 1, 0, 0, 0, 1058, 994, 1, 0, 0, 0, 1058, 998, 1, 0, 0, 0, 1058, 1002, 1, 0, 0, 0, 1058, 1006, 1, 0, 0, 0, 1058, 1012, 1, 0, 0, 0, 1058, 1019, 1, 0, 0, 0, 1058, 1023, 1, 0, 0, 0, 1058, 1027, 1, 0, 0, 0, 1058, 1031, 1, 0, 0, 0, 1058, 1038, 1, 0, 0, 0, 1058, 1045, 1, 0, 0, 0, 1058, 1049, 1, 0, 0, 0, 1059, 103, 1, 0, 0, 0, 1060, 1061, 3, 170, 85, 0, 1061, 1062, 3, 138, 69, 0, 1062, 1063, 3, 112, 56, 0, 1063, 1064, 6, 52, -1, 0, 1064, 105, 1, 0, 0, 0, 1065, 1090, 1, 0, 0, 0, 1066, 1067, 3, 0, 0, 0, 1067, 1068, 6, 53, -1, 0, 1068, 1073, 1, 0, 0, 0, 1069, 1070, 3, 32, 16, 0, 1070, 1071, 6, 53, -1, 0, 1071, 1073, 1, 0, 0, 0, 1072, 1066, 1, 0, 0, 0, 1072, 1069, 1, 0, 0, 0, 1073, 1074, 1, 0, 0, 0, 1074, 1075, 5, 28, 0, 0, 1075, 1077, 1, 0, 0, 0, 1076, 1072, 1, 0, 0, 0, 1077, 1080, 1, 0, 0, 0, 1078, 1076, 1, 0, 0, 0, 1078, 1079, 1, 0, 0, 0, 1079, 1087, 1, 0, 0, 0, 1080, 1078, 1, 0, 0, 0, 1081, 1082, 3, 0, 0, 0, 1082, 1083, 6, 53, -1, 0, 1083, 1088, 1, 0, 0, 0, 1084, 1085, 3, 32, 16, 0, 1085, 1086, 6, 53, -1, 0, 1086, 1088, 1, 0, 0, 0, 1087, 1081, 1, 0, 0, 0, 1087, 1084, 1, 0, 0, 0, 1088, 1090, 1, 0, 0, 0, 1089, 1065, 1, 0, 0, 0, 1089, 1078, 1, 0, 0, 0, 1090, 107, 1, 0, 0, 0, 1091, 1098, 5, 86, 0, 0, 1092, 1093, 3, 138, 69, 0, 1093, 1094, 6, 54, -1, 0, 1094, 1095, 5, 28, 0, 0, 1095, 1097, 1, 0, 0, 0, 1096, 1092, 1, 0, 0, 0, 1097, 1100, 1, 0, 0, 0, 1098, 1096, 1, 0, 0, 0, 1098, 1099, 1, 0, 0, 0, 1099, 1101, 1, 0, 0, 0, 1100, 1098, 1, 0, 0, 0, 1101, 1102, 3, 138, 69, 0, 1102, 1103, 6, 54, -1, 0, 1103, 1104, 5, 87, 0, 0, 1104, 109, 1, 0, 0, 0, 1105, 1112, 5, 42, 0, 0, 1106, 1107, 3, 146, 73, 0, 1107, 1108, 6, 55, -1, 0, 1108, 1109, 5, 28, 0, 0, 1109, 1111, 1, 0, 0, 0, 1110, 1106, 1, 0, 0, 0, 1111, 1114, 1, 0, 0, 0, 1112, 1110, 1, 0, 0, 0, 1112, 1113, 1, 0, 0, 0, 1113, 1115, 1, 0, 0, 0, 1114, 1112, 1, 0, 0, 0, 1115, 1116, 3, 146, 73, 0, 1116, 1117, 6, 55, -1, 0, 1117, 1118, 5, 43, 0, 0, 1118, 111, 1, 0, 0, 0, 1119, 1126, 5, 30, 0, 0, 1120, 1121, 3, 114, 57, 0, 1121, 1122, 6, 56, -1, 0, 1122, 1123, 5, 28, 0, 0, 1123, 1125, 1, 0, 0, 0, 1124, 1120, 1, 0, 0, 0, 1125, 1128, 1, 0, 0, 0, 1126, 1124, 1, 0, 0, 0, 1126, 1127, 1, 0, 0, 0, 1127, 1129, 1, 0, 0, 0, 1128, 1126, 1, 0, 0, 0, 1129, 1130, 3, 114, 57, 0, 1130, 1131, 6, 56, -1, 0, 1131, 1132, 5, 31, 0, 0, 1132, 1135, 1, 0, 0, 0, 1133, 1135, 5, 85, 0, 0, 1134, 1119, 1, 0, 0, 0, 1134, 1133, 1, 0, 0, 0, 1135, 113, 1, 0, 0, 0, 1136, 1137, 5, 177, 0, 0, 1137, 1147, 6, 57, -1, 0, 1138, 1139, 3, 230, 115, 0, 1139, 1140, 3, 138, 69, 0, 1140, 1142, 3, 226, 113, 0, 1141, 1143, 3, 0, 0, 0, 1142, 1141, 1, 0, 0, 0, 1142, 1143, 1, 0, 0, 0, 1143, 1144, 1, 0, 0, 0, 1144, 1145, 6, 57, -1, 0, 1145, 1147, 1, 0, 0, 0, 1146, 1136, 1, 0, 0, 0, 1146, 1138, 1, 0, 0, 0, 1147, 115, 1, 0, 0, 0, 1148, 1149, 5, 42, 0, 0, 1149, 1150, 3, 2, 1, 0, 1150, 1151, 5, 43, 0, 0, 1151, 1152, 3, 118, 59, 0, 1152, 1153, 6, 58, -1, 0, 1153, 1186, 1, 0, 0, 0, 1154, 1155, 5, 42, 0, 0, 1155, 1156, 3, 174, 87, 0, 1156, 1157, 5, 43, 0, 0, 1157, 1158, 3, 118, 59, 0, 1158, 1159, 6, 58, -1, 0, 1159, 1186, 1, 0, 0, 0, 1160, 1161, 5, 42, 0, 0, 1161, 1162, 5, 262, 0, 0, 1162, 1163, 5, 43, 0, 0, 1163, 1164, 3, 118, 59, 0, 1164, 1165, 6, 58, -1, 0, 1165, 1186, 1, 0, 0, 0, 1166, 1167, 5, 42, 0, 0, 1167, 1168, 5, 198, 0, 0, 1168, 1169, 3, 2, 1, 0, 1169, 1170, 5, 43, 0, 0, 1170, 1171, 3, 118, 59, 0, 1171, 1172, 6, 58, -1, 0, 1172, 1186, 1, 0, 0, 0, 1173, 1174, 3, 118, 59, 0, 1174, 1175, 6, 58, -1, 0, 1175, 1186, 1, 0, 0, 0, 1176, 1177, 3, 174, 87, 0, 1177, 1178, 6, 58, -1, 0, 1178, 1186, 1, 0, 0, 0, 1179, 1180, 5, 257, 0, 0, 1180, 1186, 6, 58, -1, 0, 1181, 1182, 5, 258, 0, 0, 1182, 1186, 6, 58, -1, 0, 1183, 1184, 5, 259, 0, 0, 1184, 1186, 6, 58, -1, 0, 1185, 1148, 1, 0, 0, 0, 1185, 1154, 1, 0, 0, 0, 1185, 1160, 1, 0, 0, 0, 1185, 1166, 1, 0, 0, 0, 1185, 1173, 1, 0, 0, 0, 1185, 1176, 1, 0, 0, 0, 1185, 1179, 1, 0, 0, 0, 1185, 1181, 1, 0, 0, 0, 1185, 1183, 1, 0, 0, 0, 1186, 117, 1, 0, 0, 0, 1187, 1188, 3, 2, 1, 0, 1188, 1189, 6, 59, -1, 0, 1189, 1190, 5, 88, 0, 0, 1190, 1192, 1, 0, 0, 0, 1191, 1187, 1, 0, 0, 0, 1192, 1195, 1, 0, 0, 0, 1193, 1191, 1, 0, 0, 0, 1193, 1194, 1, 0, 0, 0, 1194, 1196, 1, 0, 0, 0, 1195, 1193, 1, 0, 0, 0, 1196, 1197, 3, 2, 1, 0, 1197, 1198, 6, 59, -1, 0, 1198, 119, 1, 0, 0, 0, 1199, 1201, 3, 122, 61, 0, 1200, 1199, 1, 0, 0, 0, 1201, 1204, 1, 0, 0, 0, 1202, 1200, 1, 0, 0, 0, 1202, 1203, 1, 0, 0, 0, 1203, 121, 1, 0, 0, 0, 1204, 1202, 1, 0, 0, 0, 1205, 1206, 5, 180, 0, 0, 1206, 1207, 5, 89, 0, 0, 1207, 1211, 3, 32, 16, 0, 1208, 1211, 3, 152, 76, 0, 1209, 1211, 3, 332, 166, 0, 1210, 1205, 1, 0, 0, 0, 1210, 1208, 1, 0, 0, 0, 1210, 1209, 1, 0, 0, 0, 1211, 123, 1, 0, 0, 0, 1212, 1213, 3, 116, 58, 0, 1213, 1214, 6, 62, -1, 0, 1214, 1230, 1, 0, 0, 0, 1215, 1216, 5, 42, 0, 0, 1216, 1217, 3, 2, 1, 0, 1217, 1218, 5, 43, 0, 0, 1218, 1219, 6, 62, -1, 0, 1219, 1230, 1, 0, 0, 0, 1220, 1221, 5, 42, 0, 0, 1221, 1222, 5, 198, 0, 0, 1222, 1223, 3, 2, 1, 0, 1223, 1224, 5, 43, 0, 0, 1224, 1225, 6, 62, -1, 0, 1225, 1230, 1, 0, 0, 0, 1226, 1227, 3, 138, 69, 0, 1227, 1228, 6, 62, -1, 0, 1228, 1230, 1, 0, 0, 0, 1229, 1212, 1, 0, 0, 0, 1229, 1215, 1, 0, 0, 0, 1229, 1220, 1, 0, 0, 0, 1229, 1226, 1, 0, 0, 0, 1230, 125, 1, 0, 0, 0, 1231, 1243, 1, 0, 0, 0, 1232, 1233, 3, 130, 65, 0, 1233, 1239, 6, 63, -1, 0, 1234, 1235, 3, 128, 64, 0, 1235, 1236, 6, 63, -1, 0, 1236, 1238, 1, 0, 0, 0, 1237, 1234, 1, 0, 0, 0, 1238, 1241, 1, 0, 0, 0, 1239, 1237, 1, 0, 0, 0, 1239, 1240, 1, 0, 0, 0, 1240, 1243, 1, 0, 0, 0, 1241, 1239, 1, 0, 0, 0, 1242, 1231, 1, 0, 0, 0, 1242, 1232, 1, 0, 0, 0, 1243, 127, 1, 0, 0, 0, 1244, 1245, 5, 262, 0, 0, 1245, 1267, 6, 64, -1, 0, 1246, 1247, 5, 261, 0, 0, 1247, 1267, 6, 64, -1, 0, 1248, 1249, 5, 42, 0, 0, 1249, 1250, 3, 32, 16, 0, 1250, 1251, 5, 43, 0, 0, 1251, 1252, 6, 64, -1, 0, 1252, 1267, 1, 0, 0, 0, 1253, 1254, 5, 42, 0, 0, 1254, 1255, 3, 32, 16, 0, 1255, 1256, 5, 266, 0, 0, 1256, 1257, 3, 32, 16, 0, 1257, 1258, 5, 43, 0, 0, 1258, 1259, 6, 64, -1, 0, 1259, 1267, 1, 0, 0, 0, 1260, 1261, 5, 42, 0, 0, 1261, 1262, 5, 266, 0, 0, 1262, 1263, 3, 32, 16, 0, 1263, 1264, 5, 43, 0, 0, 1264, 1265, 6, 64, -1, 0, 1265, 1267, 1, 0, 0, 0, 1266, 1244, 1, 0, 0, 0, 1266, 1246, 1, 0, 0, 0, 1266, 1248, 1, 0, 0, 0, 1266, 1253, 1, 0, 0, 0, 1266, 1260, 1, 0, 0, 0, 1267, 129, 1, 0, 0, 0, 1268, 1414, 6, 65, -1, 0, 1269, 1270, 5, 203, 0, 0, 1270, 1271, 5, 30, 0, 0, 1271, 1272, 3, 6, 3, 0, 1272, 1273, 5, 28, 0, 0, 1273, 1274, 3, 6, 3, 0, 1274, 1275, 5, 28, 0, 0, 1275, 1276, 3, 6, 3, 0, 1276, 1277, 5, 28, 0, 0, 1277, 1278, 3, 6, 3, 0, 1278, 1279, 5, 31, 0, 0, 1279, 1280, 6, 65, -1, 0, 1280, 1414, 1, 0, 0, 0, 1281, 1282, 5, 203, 0, 0, 1282, 1283, 5, 30, 0, 0, 1283, 1284, 3, 6, 3, 0, 1284, 1285, 5, 28, 0, 0, 1285, 1286, 3, 6, 3, 0, 1286, 1287, 5, 31, 0, 0, 1287, 1288, 6, 65, -1, 0, 1288, 1414, 1, 0, 0, 0, 1289, 1290, 5, 204, 0, 0, 1290, 1291, 5, 205, 0, 0, 1291, 1292, 5, 42, 0, 0, 1292, 1293, 3, 32, 16, 0, 1293, 1294, 5, 43, 0, 0, 1294, 1295, 6, 65, -1, 0, 1295, 1414, 1, 0, 0, 0, 1296, 1297, 5, 204, 0, 0, 1297, 1298, 5, 206, 0, 0, 1298, 1299, 5, 42, 0, 0, 1299, 1300, 3, 32, 16, 0, 1300, 1301, 5, 43, 0, 0, 1301, 1302, 3, 126, 63, 0, 1302, 1303, 6, 65, -1, 0, 1303, 1414, 1, 0, 0, 0, 1304, 1305, 5, 207, 0, 0, 1305, 1414, 6, 65, -1, 0, 1306, 1307, 5, 208, 0, 0, 1307, 1414, 6, 65, -1, 0, 1308, 1309, 5, 209, 0, 0, 1309, 1414, 6, 65, -1, 0, 1310, 1311, 5, 201, 0, 0, 1311, 1414, 6, 65, -1, 0, 1312, 1313, 5, 183, 0, 0, 1313, 1414, 6, 65, -1, 0, 1314, 1315, 5, 184, 0, 0, 1315, 1414, 6, 65, -1, 0, 1316, 1317, 5, 185, 0, 0, 1317, 1414, 6, 65, -1, 0, 1318, 1319, 5, 186, 0, 0, 1319, 1414, 6, 65, -1, 0, 1320, 1321, 5, 187, 0, 0, 1321, 1414, 6, 65, -1, 0, 1322, 1323, 5, 188, 0, 0, 1323, 1414, 6, 65, -1, 0, 1324, 1325, 5, 189, 0, 0, 1325, 1414, 6, 65, -1, 0, 1326, 1327, 5, 210, 0, 0, 1327, 1414, 6, 65, -1, 0, 1328, 1329, 5, 190, 0, 0, 1329, 1414, 6, 65, -1, 0, 1330, 1331, 5, 191, 0, 0, 1331, 1414, 6, 65, -1, 0, 1332, 1333, 5, 192, 0, 0, 1333, 1414, 6, 65, -1, 0, 1334, 1335, 5, 193, 0, 0, 1335, 1414, 6, 65, -1, 0, 1336, 1337, 5, 211, 0, 0, 1337, 1414, 6, 65, -1, 0, 1338, 1339, 5, 212, 0, 0, 1339, 1414, 6, 65, -1, 0, 1340, 1341, 5, 213, 0, 0, 1341, 1414, 6, 65, -1, 0, 1342, 1343, 5, 214, 0, 0, 1343, 1414, 6, 65, -1, 0, 1344, 1345, 5, 215, 0, 0, 1345, 1414, 6, 65, -1, 0, 1346, 1347, 5, 216, 0, 0, 1347, 1414, 6, 65, -1, 0, 1348, 1349, 5, 217, 0, 0, 1349, 1414, 6, 65, -1, 0, 1350, 1351, 5, 218, 0, 0, 1351, 1352, 3, 132, 66, 0, 1352, 1353, 6, 65, -1, 0, 1353, 1414, 1, 0, 0, 0, 1354, 1355, 5, 219, 0, 0, 1355, 1356, 3, 132, 66, 0, 1356, 1357, 6, 65, -1, 0, 1357, 1414, 1, 0, 0, 0, 1358, 1359, 5, 220, 0, 0, 1359, 1414, 6, 65, -1, 0, 1360, 1361, 5, 221, 0, 0, 1361, 1362, 3, 132, 66, 0, 1362, 1363, 6, 65, -1, 0, 1363, 1414, 1, 0, 0, 0, 1364, 1365, 5, 222, 0, 0, 1365, 1366, 3, 134, 67, 0, 1366, 1367, 6, 65, -1, 0, 1367, 1414, 1, 0, 0, 0, 1368, 1369, 5, 222, 0, 0, 1369, 1370, 3, 134, 67, 0, 1370, 1371, 5, 28, 0, 0, 1371, 1372, 3, 6, 3, 0, 1372, 1373, 6, 65, -1, 0, 1373, 1414, 1, 0, 0, 0, 1374, 1375, 5, 194, 0, 0, 1375, 1414, 6, 65, -1, 0, 1376, 1377, 5, 195, 0, 0, 1377, 1414, 6, 65, -1, 0, 1378, 1379, 5, 90, 0, 0, 1379, 1380, 5, 184, 0, 0, 1380, 1414, 6, 65, -1, 0, 1381, 1382, 5, 90, 0, 0, 1382, 1383, 5, 185, 0, 0, 1383, 1414, 6, 65, -1, 0, 1384, 1385, 5, 90, 0, 0, 1385, 1386, 5, 186, 0, 0, 1386, 1414, 6, 65, -1, 0, 1387, 1388, 5, 90, 0, 0, 1388, 1389, 5, 187, 0, 0, 1389, 1414, 6, 65, -1, 0, 1390, 1391, 5, 62, 0, 0, 1391, 1392, 5, 220, 0, 0, 1392, 1414, 6, 65, -1, 0, 1393, 1394, 5, 223, 0, 0, 1394, 1414, 6, 65, -1, 0, 1395, 1396, 5, 224, 0, 0, 1396, 1397, 5, 213, 0, 0, 1397, 1414, 6, 65, -1, 0, 1398, 1399, 5, 225, 0, 0, 1399, 1414, 6, 65, -1, 0, 1400, 1401, 5, 207, 0, 0, 1401, 1402, 5, 183, 0, 0, 1402, 1414, 6, 65, -1, 0, 1403, 1404, 5, 226, 0, 0, 1404, 1414, 6, 65, -1, 0, 1405, 1406, 5, 228, 0, 0, 1406, 1414, 6, 65, -1, 0, 1407, 1408, 5, 34, 0, 0, 1408, 1409, 5, 227, 0, 0, 1409, 1414, 6, 65, -1, 0, 1410, 1411, 3, 2, 1, 0, 1411, 1412, 6, 65, -1, 0, 1412, 1414, 1, 0, 0, 0, 1413, 1268, 1, 0, 0, 0, 1413, 1269, 1, 0, 0, 0, 1413, 1281, 1, 0, 0, 0, 1413, 1289, 1, 0, 0, 0, 1413, 1296, 1, 0, 0, 0, 1413, 1304, 1, 0, 0, 0, 1413, 1306, 1, 0, 0, 0, 1413, 1308, 1, 0, 0, 0, 1413, 1310, 1, 0, 0, 0, 1413, 1312, 1, 0, 0, 0, 1413, 1314, 1, 0, 0, 0, 1413, 1316, 1, 0, 0, 0, 1413, 1318, 1, 0, 0, 0, 1413, 1320, 1, 0, 0, 0, 1413, 1322, 1, 0, 0, 0, 1413, 1324, 1, 0, 0, 0, 1413, 1326, 1, 0, 0, 0, 1413, 1328, 1, 0, 0, 0, 1413, 1330, 1, 0, 0, 0, 1413, 1332, 1, 0, 0, 0, 1413, 1334, 1, 0, 0, 0, 1413, 1336, 1, 0, 0, 0, 1413, 1338, 1, 0, 0, 0, 1413, 1340, 1, 0, 0, 0, 1413, 1342, 1, 0, 0, 0, 1413, 1344, 1, 0, 0, 0, 1413, 1346, 1, 0, 0, 0, 1413, 1348, 1, 0, 0, 0, 1413, 1350, 1, 0, 0, 0, 1413, 1354, 1, 0, 0, 0, 1413, 1358, 1, 0, 0, 0, 1413, 1360, 1, 0, 0, 0, 1413, 1364, 1, 0, 0, 0, 1413, 1368, 1, 0, 0, 0, 1413, 1374, 1, 0, 0, 0, 1413, 1376, 1, 0, 0, 0, 1413, 1378, 1, 0, 0, 0, 1413, 1381, 1, 0, 0, 0, 1413, 1384, 1, 0, 0, 0, 1413, 1387, 1, 0, 0, 0, 1413, 1390, 1, 0, 0, 0, 1413, 1393, 1, 0, 0, 0, 1413, 1395, 1, 0, 0, 0, 1413, 1398, 1, 0, 0, 0, 1413, 1400, 1, 0, 0, 0, 1413, 1403, 1, 0, 0, 0, 1413, 1405, 1, 0, 0, 0, 1413, 1407, 1, 0, 0, 0, 1413, 1410, 1, 0, 0, 0, 1414, 131, 1, 0, 0, 0, 1415, 1424, 1, 0, 0, 0, 1416, 1417, 5, 30, 0, 0, 1417, 1418, 5, 91, 0, 0, 1418, 1419, 5, 36, 0, 0, 1419, 1420, 3, 32, 16, 0, 1420, 1421, 5, 31, 0, 0, 1421, 1422, 6, 66, -1, 0, 1422, 1424, 1, 0, 0, 0, 1423, 1415, 1, 0, 0, 0, 1423, 1416, 1, 0, 0, 0, 1424, 133, 1, 0, 0, 0, 1425, 1436, 1, 0, 0, 0, 1426, 1427, 3, 136, 68, 0, 1427, 1432, 6, 67, -1, 0, 1428, 1429, 7, 7, 0, 0, 1429, 1431, 6, 67, -1, 0, 1430, 1428, 1, 0, 0, 0, 1431, 1434, 1, 0, 0, 0, 1432, 1430, 1, 0, 0, 0, 1432, 1433, 1, 0, 0, 0, 1433, 1436, 1, 0, 0, 0, 1434, 1432, 1, 0, 0, 0, 1435, 1425, 1, 0, 0, 0, 1435, 1426, 1, 0, 0, 0, 1436, 135, 1, 0, 0, 0, 1437, 1438, 5, 178, 0, 0, 1438, 1518, 6, 68, -1, 0, 1439, 1440, 5, 207, 0, 0, 1440, 1518, 6, 68, -1, 0, 1441, 1442, 5, 208, 0, 0, 1442, 1518, 6, 68, -1, 0, 1443, 1444, 5, 201, 0, 0, 1444, 1518, 6, 68, -1, 0, 1445, 1446, 5, 183, 0, 0, 1446, 1518, 6, 68, -1, 0, 1447, 1448, 5, 184, 0, 0, 1448, 1518, 6, 68, -1, 0, 1449, 1450, 5, 185, 0, 0, 1450, 1518, 6, 68, -1, 0, 1451, 1452, 5, 186, 0, 0, 1452, 1518, 6, 68, -1, 0, 1453, 1454, 5, 187, 0, 0, 1454, 1518, 6, 68, -1, 0, 1455, 1456, 5, 188, 0, 0, 1456, 1518, 6, 68, -1, 0, 1457, 1458, 5, 189, 0, 0, 1458, 1518, 6, 68, -1, 0, 1459, 1460, 5, 190, 0, 0, 1460, 1518, 6, 68, -1, 0, 1461, 1462, 5, 191, 0, 0, 1462, 1518, 6, 68, -1, 0, 1463, 1464, 5, 192, 0, 0, 1464, 1518, 6, 68, -1, 0, 1465, 1466, 5, 193, 0, 0, 1466, 1518, 6, 68, -1, 0, 1467, 1468, 5, 262, 0, 0, 1468, 1518, 6, 68, -1, 0, 1469, 1470, 5, 211, 0, 0, 1470, 1518, 6, 68, -1, 0, 1471, 1472, 5, 212, 0, 0, 1472, 1518, 6, 68, -1, 0, 1473, 1474, 5, 213, 0, 0, 1474, 1518, 6, 68, -1, 0, 1475, 1476, 5, 214, 0, 0, 1476, 1518, 6, 68, -1, 0, 1477, 1478, 5, 215, 0, 0, 1478, 1518, 6, 68, -1, 0, 1479, 1480, 5, 218, 0, 0, 1480, 1518, 6, 68, -1, 0, 1481, 1482, 5, 219, 0, 0, 1482, 1518, 6, 68, -1, 0, 1483, 1484, 5, 222, 0, 0, 1484, 1518, 6, 68, -1, 0, 1485, 1486, 5, 194, 0, 0, 1486, 1518, 6, 68, -1, 0, 1487, 1488, 5, 195, 0, 0, 1488, 1518, 6, 68, -1, 0, 1489, 1490, 5, 210, 0, 0, 1490, 1518, 6, 68, -1, 0, 1491, 1492, 5, 230, 0, 0, 1492, 1518, 6, 68, -1, 0, 1493, 1494, 5, 231, 0, 0, 1494, 1518, 6, 68, -1, 0, 1495, 1496, 5, 232, 0, 0, 1496, 1518, 6, 68, -1, 0, 1497, 1498, 5, 233, 0, 0, 1498, 1518, 6, 68, -1, 0, 1499, 1500, 5, 234, 0, 0, 1500, 1518, 6, 68, -1, 0, 1501, 1502, 5, 235, 0, 0, 1502, 1518, 6, 68, -1, 0, 1503, 1504, 5, 236, 0, 0, 1504, 1518, 6, 68, -1, 0, 1505, 1506, 5, 237, 0, 0, 1506, 1518, 6, 68, -1, 0, 1507, 1508, 5, 238, 0, 0, 1508, 1518, 6, 68, -1, 0, 1509, 1510, 5, 239, 0, 0, 1510, 1518, 6, 68, -1, 0, 1511, 1512, 5, 240, 0, 0, 1512, 1518, 6, 68, -1, 0, 1513, 1514, 5, 241, 0, 0, 1514, 1518, 6, 68, -1, 0, 1515, 1516, 5, 242, 0, 0, 1516, 1518, 6, 68, -1, 0, 1517, 1437, 1, 0, 0, 0, 1517, 1439, 1, 0, 0, 0, 1517, 1441, 1, 0, 0, 0, 1517, 1443, 1, 0, 0, 0, 1517, 1445, 1, 0, 0, 0, 1517, 1447, 1, 0, 0, 0, 1517, 1449, 1, 0, 0, 0, 1517, 1451, 1, 0, 0, 0, 1517, 1453, 1, 0, 0, 0, 1517, 1455, 1, 0, 0, 0, 1517, 1457, 1, 0, 0, 0, 1517, 1459, 1, 0, 0, 0, 1517, 1461, 1, 0, 0, 0, 1517, 1463, 1, 0, 0, 0, 1517, 1465, 1, 0, 0, 0, 1517, 1467, 1, 0, 0, 0, 1517, 1469, 1, 0, 0, 0, 1517, 1471, 1, 0, 0, 0, 1517, 1473, 1, 0, 0, 0, 1517, 1475, 1, 0, 0, 0, 1517, 1477, 1, 0, 0, 0, 1517, 1479, 1, 0, 0, 0, 1517, 1481, 1, 0, 0, 0, 1517, 1483, 1, 0, 0, 0, 1517, 1485, 1, 0, 0, 0, 1517, 1487, 1, 0, 0, 0, 1517, 1489, 1, 0, 0, 0, 1517, 1491, 1, 0, 0, 0, 1517, 1493, 1, 0, 0, 0, 1517, 1495, 1, 0, 0, 0, 1517, 1497, 1, 0, 0, 0, 1517, 1499, 1, 0, 0, 0, 1517, 1501, 1, 0, 0, 0, 1517, 1503, 1, 0, 0, 0, 1517, 1505, 1, 0, 0, 0, 1517, 1507, 1, 0, 0, 0, 1517, 1509, 1, 0, 0, 0, 1517, 1511, 1, 0, 0, 0, 1517, 1513, 1, 0, 0, 0, 1517, 1515, 1, 0, 0, 0, 1518, 137, 1, 0, 0, 0, 1519, 1520, 3, 142, 71, 0, 1520, 1526, 6, 69, -1, 0, 1521, 1522, 3, 140, 70, 0, 1522, 1523, 6, 69, -1, 0, 1523, 1525, 1, 0, 0, 0, 1524, 1521, 1, 0, 0, 0, 1525, 1528, 1, 0, 0, 0, 1526, 1524, 1, 0, 0, 0, 1526, 1527, 1, 0, 0, 0, 1527, 139, 1, 0, 0, 0, 1528, 1526, 1, 0, 0, 0, 1529, 1530, 5, 261, 0, 0, 1530, 1559, 6, 70, -1, 0, 1531, 1532, 5, 42, 0, 0, 1532, 1533, 5, 43, 0, 0, 1533, 1559, 6, 70, -1, 0, 1534, 1535, 3, 110, 55, 0, 1535, 1536, 6, 70, -1, 0, 1536, 1559, 1, 0, 0, 0, 1537, 1538, 5, 260, 0, 0, 1538, 1559, 6, 70, -1, 0, 1539, 1540, 5, 262, 0, 0, 1540, 1559, 6, 70, -1, 0, 1541, 1542, 5, 92, 0, 0, 1542, 1559, 6, 70, -1, 0, 1543, 1544, 5, 93, 0, 0, 1544, 1545, 5, 30, 0, 0, 1545, 1546, 3, 124, 62, 0, 1546, 1547, 5, 31, 0, 0, 1547, 1548, 6, 70, -1, 0, 1548, 1559, 1, 0, 0, 0, 1549, 1550, 5, 94, 0, 0, 1550, 1551, 5, 30, 0, 0, 1551, 1552, 3, 124, 62, 0, 1552, 1553, 5, 31, 0, 0, 1553, 1554, 6, 70, -1, 0, 1554, 1559, 1, 0, 0, 0, 1555, 1556, 3, 108, 54, 0, 1556, 1557, 6, 70, -1, 0, 1557, 1559, 1, 0, 0, 0, 1558, 1529, 1, 0, 0, 0, 1558, 1531, 1, 0, 0, 0, 1558, 1534, 1, 0, 0, 0, 1558, 1537, 1, 0, 0, 0, 1558, 1539, 1, 0, 0, 0, 1558, 1541, 1, 0, 0, 0, 1558, 1543, 1, 0, 0, 0, 1558, 1549, 1, 0, 0, 0, 1558, 1555, 1, 0, 0, 0, 1559, 141, 1, 0, 0, 0, 1560, 1561, 5, 39, 0, 0, 1561, 1562, 3, 116, 58, 0, 1562, 1563, 6, 71, -1, 0, 1563, 1619, 1, 0, 0, 0, 1564, 1565, 5, 197, 0, 0, 1565, 1619, 6, 71, -1, 0, 1566, 1567, 5, 199, 0, 0, 1567, 1568, 5, 39, 0, 0, 1568, 1569, 3, 116, 58, 0, 1569, 1570, 6, 71, -1, 0, 1570, 1619, 1, 0, 0, 0, 1571, 1572, 5, 200, 0, 0, 1572, 1573, 3, 116, 58, 0, 1573, 1574, 6, 71, -1, 0, 1574, 1619, 1, 0, 0, 0, 1575, 1576, 5, 226, 0, 0, 1576, 1577, 3, 170, 85, 0, 1577, 1578, 3, 138, 69, 0, 1578, 1579, 5, 262, 0, 0, 1579, 1580, 3, 112, 56, 0, 1580, 1581, 6, 71, -1, 0, 1581, 1619, 1, 0, 0, 0, 1582, 1583, 5, 253, 0, 0, 1583, 1584, 3, 32, 16, 0, 1584, 1585, 6, 71, -1, 0, 1585, 1619, 1, 0, 0, 0, 1586, 1587, 5, 252, 0, 0, 1587, 1588, 3, 32, 16, 0, 1588, 1589, 6, 71, -1, 0, 1589, 1619, 1, 0, 0, 0, 1590, 1591, 5, 253, 0, 0, 1591, 1592, 3, 2, 1, 0, 1592, 1593, 6, 71, -1, 0, 1593, 1619, 1, 0, 0, 0, 1594, 1595, 5, 252, 0, 0, 1595, 1596, 3, 2, 1, 0, 1596, 1597, 6, 71, -1, 0, 1597, 1619, 1, 0, 0, 0, 1598, 1599, 5, 254, 0, 0, 1599, 1619, 6, 71, -1, 0, 1600, 1601, 5, 201, 0, 0, 1601, 1619, 6, 71, -1, 0, 1602, 1603, 3, 148, 74, 0, 1603, 1604, 6, 71, -1, 0, 1604, 1619, 1, 0, 0, 0, 1605, 1606, 3, 150, 75, 0, 1606, 1607, 6, 71, -1, 0, 1607, 1619, 1, 0, 0, 0, 1608, 1609, 3, 144, 72, 0, 1609, 1610, 6, 71, -1, 0, 1610, 1619, 1, 0, 0, 0, 1611, 1612, 3, 2, 1, 0, 1612, 1613, 6, 71, -1, 0, 1613, 1619, 1, 0, 0, 0, 1614, 1615, 5, 177, 0, 0, 1615, 1616, 3, 138, 69, 0, 1616, 1617, 6, 71, -1, 0, 1617, 1619, 1, 0, 0, 0, 1618, 1560, 1, 0, 0, 0, 1618, 1564, 1, 0, 0, 0, 1618, 1566, 1, 0, 0, 0, 1618, 1571, 1, 0, 0, 0, 1618, 1575, 1, 0, 0, 0, 1618, 1582, 1, 0, 0, 0, 1618, 1586, 1, 0, 0, 0, 1618, 1590, 1, 0, 0, 0, 1618, 1594, 1, 0, 0, 0, 1618, 1598, 1, 0, 0, 0, 1618, 1600, 1, 0, 0, 0, 1618, 1602, 1, 0, 0, 0, 1618, 1605, 1, 0, 0, 0, 1618, 1608, 1, 0, 0, 0, 1618, 1611, 1, 0, 0, 0, 1618, 1614, 1, 0, 0, 0, 1619, 143, 1, 0, 0, 0, 1620, 1621, 5, 181, 0, 0, 1621, 1659, 6, 72, -1, 0, 1622, 1623, 5, 182, 0, 0, 1623, 1659, 6, 72, -1, 0, 1624, 1625, 5, 183, 0, 0, 1625, 1659, 6, 72, -1, 0, 1626, 1627, 5, 184, 0, 0, 1627, 1659, 6, 72, -1, 0, 1628, 1629, 5, 185, 0, 0, 1629, 1659, 6, 72, -1, 0, 1630, 1631, 5, 186, 0, 0, 1631, 1659, 6, 72, -1, 0, 1632, 1633, 5, 187, 0, 0, 1633, 1659, 6, 72, -1, 0, 1634, 1635, 5, 188, 0, 0, 1635, 1659, 6, 72, -1, 0, 1636, 1637, 5, 189, 0, 0, 1637, 1659, 6, 72, -1, 0, 1638, 1639, 5, 190, 0, 0, 1639, 1659, 6, 72, -1, 0, 1640, 1641, 5, 191, 0, 0, 1641, 1659, 6, 72, -1, 0, 1642, 1643, 5, 192, 0, 0, 1643, 1659, 6, 72, -1, 0, 1644, 1645, 5, 193, 0, 0, 1645, 1659, 6, 72, -1, 0, 1646, 1647, 5, 90, 0, 0, 1647, 1648, 5, 184, 0, 0, 1648, 1659, 6, 72, -1, 0, 1649, 1650, 5, 90, 0, 0, 1650, 1651, 5, 185, 0, 0, 1651, 1659, 6, 72, -1, 0, 1652, 1653, 5, 90, 0, 0, 1653, 1654, 5, 186, 0, 0, 1654, 1659, 6, 72, -1, 0, 1655, 1656, 5, 90, 0, 0, 1656, 1657, 5, 187, 0, 0, 1657, 1659, 6, 72, -1, 0, 1658, 1620, 1, 0, 0, 0, 1658, 1622, 1, 0, 0, 0, 1658, 1624, 1, 0, 0, 0, 1658, 1626, 1, 0, 0, 0, 1658, 1628, 1, 0, 0, 0, 1658, 1630, 1, 0, 0, 0, 1658, 1632, 1, 0, 0, 0, 1658, 1634, 1, 0, 0, 0, 1658, 1636, 1, 0, 0, 0, 1658, 1638, 1, 0, 0, 0, 1658, 1640, 1, 0, 0, 0, 1658, 1642, 1, 0, 0, 0, 1658, 1644, 1, 0, 0, 0, 1658, 1646, 1, 0, 0, 0, 1658, 1649, 1, 0, 0, 0, 1658, 1652, 1, 0, 0, 0, 1658, 1655, 1, 0, 0, 0, 1659, 145, 1, 0, 0, 0, 1660, 1675, 1, 0, 0, 0, 1661, 1675, 5, 177, 0, 0, 1662, 1663, 3, 32, 16, 0, 1663, 1664, 6, 73, -1, 0, 1664, 1675, 1, 0, 0, 0, 1665, 1666, 3, 32, 16, 0, 1666, 1667, 5, 177, 0, 0, 1667, 1668, 3, 32, 16, 0, 1668, 1669, 6, 73, -1, 0, 1669, 1675, 1, 0, 0, 0, 1670, 1671, 3, 32, 16, 0, 1671, 1672, 5, 177, 0, 0, 1672, 1673, 6, 73, -1, 0, 1673, 1675, 1, 0, 0, 0, 1674, 1660, 1, 0, 0, 0, 1674, 1661, 1, 0, 0, 0, 1674, 1662, 1, 0, 0, 0, 1674, 1665, 1, 0, 0, 0, 1674, 1670, 1, 0, 0, 0, 1675, 147, 1, 0, 0, 0, 1676, 1677, 5, 1, 0, 0, 1677, 1678, 5, 194, 0, 0, 1678, 1679, 6, 74, -1, 0, 1679, 149, 1, 0, 0, 0, 1680, 1684, 5, 1, 0, 0, 1681, 1682, 5, 90, 0, 0, 1682, 1685, 5, 194, 0, 0, 1683, 1685, 5, 195, 0, 0, 1684, 1681, 1, 0, 0, 0, 1684, 1683, 1, 0, 0, 0, 1685, 1686, 1, 0, 0, 0, 1686, 1687, 6, 75, -1, 0, 1687, 151, 1, 0, 0, 0, 1688, 1689, 5, 294, 0, 0, 1689, 1690, 3, 166, 83, 0, 1690, 1691, 3, 124, 62, 0, 1691, 1692, 5, 30, 0, 0, 1692, 1693, 3, 158, 79, 0, 1693, 1694, 5, 31, 0, 0, 1694, 1736, 1, 0, 0, 0, 1695, 1696, 5, 294, 0, 0, 1696, 1697, 3, 166, 83, 0, 1697, 1698, 3, 124, 62, 0, 1698, 1699, 5, 36, 0, 0, 1699, 1700, 5, 17, 0, 0, 1700, 1701, 3, 52, 26, 0, 1701, 1702, 5, 18, 0, 0, 1702, 1736, 1, 0, 0, 0, 1703, 1704, 5, 294, 0, 0, 1704, 1705, 3, 166, 83, 0, 1705, 1706, 3, 124, 62, 0, 1706, 1736, 1, 0, 0, 0, 1707, 1708, 5, 295, 0, 0, 1708, 1709, 3, 166, 83, 0, 1709, 1711, 5, 36, 0, 0, 1710, 1712, 5, 84, 0, 0, 1711, 1710, 1, 0, 0, 0, 1711, 1712, 1, 0, 0, 0, 1712, 1713, 1, 0, 0, 0, 1713, 1714, 5, 30, 0, 0, 1714, 1715, 3, 300, 150, 0, 1715, 1716, 5, 31, 0, 0, 1716, 1736, 1, 0, 0, 0, 1717, 1718, 5, 295, 0, 0, 1718, 1719, 3, 166, 83, 0, 1719, 1720, 5, 84, 0, 0, 1720, 1721, 5, 30, 0, 0, 1721, 1722, 3, 300, 150, 0, 1722, 1723, 5, 31, 0, 0, 1723, 1736, 1, 0, 0, 0, 1724, 1725, 5, 295, 0, 0, 1725, 1726, 3, 166, 83, 0, 1726, 1727, 3, 6, 3, 0, 1727, 1736, 1, 0, 0, 0, 1728, 1729, 5, 295, 0, 0, 1729, 1730, 3, 166, 83, 0, 1730, 1731, 5, 36, 0, 0, 1731, 1732, 5, 17, 0, 0, 1732, 1733, 3, 154, 77, 0, 1733, 1734, 5, 18, 0, 0, 1734, 1736, 1, 0, 0, 0, 1735, 1688, 1, 0, 0, 0, 1735, 1695, 1, 0, 0, 0, 1735, 1703, 1, 0, 0, 0, 1735, 1707, 1, 0, 0, 0, 1735, 1717, 1, 0, 0, 0, 1735, 1724, 1, 0, 0, 0, 1735, 1728, 1, 0, 0, 0, 1736, 153, 1, 0, 0, 0, 1737, 1748, 1, 0, 0, 0, 1738, 1739, 3, 156, 78, 0, 1739, 1740, 5, 28, 0, 0, 1740, 1742, 1, 0, 0, 0, 1741, 1738, 1, 0, 0, 0, 1742, 1745, 1, 0, 0, 0, 1743, 1741, 1, 0, 0, 0, 1743, 1744, 1, 0, 0, 0, 1744, 1746, 1, 0, 0, 0, 1745, 1743, 1, 0, 0, 0, 1746, 1748, 3, 156, 78, 0, 1747, 1737, 1, 0, 0, 0, 1747, 1743, 1, 0, 0, 0, 1748, 155, 1, 0, 0, 0, 1749, 1750, 5, 39, 0, 0, 1750, 1751, 5, 264, 0, 0, 1751, 1752, 5, 36, 0, 0, 1752, 1753, 5, 17, 0, 0, 1753, 1754, 3, 56, 28, 0, 1754, 1755, 5, 18, 0, 0, 1755, 1763, 1, 0, 0, 0, 1756, 1757, 3, 124, 62, 0, 1757, 1758, 5, 36, 0, 0, 1758, 1759, 5, 17, 0, 0, 1759, 1760, 3, 56, 28, 0, 1760, 1761, 5, 18, 0, 0, 1761, 1763, 1, 0, 0, 0, 1762, 1749, 1, 0, 0, 0, 1762, 1756, 1, 0, 0, 0, 1763, 157, 1, 0, 0, 0, 1764, 1765, 3, 160, 80, 0, 1765, 1766, 5, 28, 0, 0, 1766, 1768, 1, 0, 0, 0, 1767, 1764, 1, 0, 0, 0, 1768, 1771, 1, 0, 0, 0, 1769, 1767, 1, 0, 0, 0, 1769, 1770, 1, 0, 0, 0, 1770, 1772, 1, 0, 0, 0, 1771, 1769, 1, 0, 0, 0, 1772, 1773, 3, 160, 80, 0, 1773, 159, 1, 0, 0, 0, 1774, 1775, 3, 6, 3, 0, 1775, 1776, 5, 36, 0, 0, 1776, 1777, 3, 164, 82, 0, 1777, 161, 1, 0, 0, 0, 1778, 1779, 7, 8, 0, 0, 1779, 163, 1, 0, 0, 0, 1780, 1815, 3, 162, 81, 0, 1781, 1815, 3, 32, 16, 0, 1782, 1783, 5, 186, 0, 0, 1783, 1784, 5, 30, 0, 0, 1784, 1785, 3, 32, 16, 0, 1785, 1786, 5, 31, 0, 0, 1786, 1815, 1, 0, 0, 0, 1787, 1815, 3, 6, 3, 0, 1788, 1789, 3, 116, 58, 0, 1789, 1790, 5, 30, 0, 0, 1790, 1791, 5, 184, 0, 0, 1791, 1792, 5, 75, 0, 0, 1792, 1793, 3, 32, 16, 0, 1793, 1794, 5, 31, 0, 0, 1794, 1815, 1, 0, 0, 0, 1795, 1796, 3, 116, 58, 0, 1796, 1797, 5, 30, 0, 0, 1797, 1798, 5, 185, 0, 0, 1798, 1799, 5, 75, 0, 0, 1799, 1800, 3, 32, 16, 0, 1800, 1801, 5, 31, 0, 0, 1801, 1815, 1, 0, 0, 0, 1802, 1803, 3, 116, 58, 0, 1803, 1804, 5, 30, 0, 0, 1804, 1805, 5, 186, 0, 0, 1805, 1806, 5, 75, 0, 0, 1806, 1807, 3, 32, 16, 0, 1807, 1808, 5, 31, 0, 0, 1808, 1815, 1, 0, 0, 0, 1809, 1810, 3, 116, 58, 0, 1810, 1811, 5, 30, 0, 0, 1811, 1812, 3, 32, 16, 0, 1812, 1813, 5, 31, 0, 0, 1813, 1815, 1, 0, 0, 0, 1814, 1780, 1, 0, 0, 0, 1814, 1781, 1, 0, 0, 0, 1814, 1782, 1, 0, 0, 0, 1814, 1787, 1, 0, 0, 0, 1814, 1788, 1, 0, 0, 0, 1814, 1795, 1, 0, 0, 0, 1814, 1802, 1, 0, 0, 0, 1814, 1809, 1, 0, 0, 0, 1815, 165, 1, 0, 0, 0, 1816, 1817, 7, 9, 0, 0, 1817, 167, 1, 0, 0, 0, 1818, 1819, 3, 170, 85, 0, 1819, 1820, 3, 138, 69, 0, 1820, 1821, 3, 124, 62, 0, 1821, 1822, 5, 176, 0, 0, 1822, 1824, 3, 242, 121, 0, 1823, 1825, 3, 108, 54, 0, 1824, 1823, 1, 0, 0, 0, 1824, 1825, 1, 0, 0, 0, 1825, 1826, 1, 0, 0, 0, 1826, 1827, 3, 112, 56, 0, 1827, 1828, 6, 84, -1, 0, 1828, 1861, 1, 0, 0, 0, 1829, 1830, 3, 170, 85, 0, 1830, 1831, 3, 138, 69, 0, 1831, 1832, 3, 124, 62, 0, 1832, 1833, 5, 176, 0, 0, 1833, 1834, 3, 242, 121, 0, 1834, 1835, 3, 196, 98, 0, 1835, 1836, 3, 112, 56, 0, 1836, 1837, 6, 84, -1, 0, 1837, 1861, 1, 0, 0, 0, 1838, 1839, 3, 170, 85, 0, 1839, 1840, 3, 138, 69, 0, 1840, 1842, 3, 242, 121, 0, 1841, 1843, 3, 108, 54, 0, 1842, 1841, 1, 0, 0, 0, 1842, 1843, 1, 0, 0, 0, 1843, 1844, 1, 0, 0, 0, 1844, 1845, 3, 112, 56, 0, 1845, 1846, 6, 84, -1, 0, 1846, 1861, 1, 0, 0, 0, 1847, 1848, 3, 170, 85, 0, 1848, 1849, 3, 138, 69, 0, 1849, 1850, 3, 242, 121, 0, 1850, 1851, 3, 196, 98, 0, 1851, 1852, 3, 112, 56, 0, 1852, 1853, 6, 84, -1, 0, 1853, 1861, 1, 0, 0, 0, 1854, 1855, 3, 174, 87, 0, 1855, 1856, 6, 84, -1, 0, 1856, 1861, 1, 0, 0, 0, 1857, 1858, 3, 2, 1, 0, 1858, 1859, 6, 84, -1, 0, 1859, 1861, 1, 0, 0, 0, 1860, 1818, 1, 0, 0, 0, 1860, 1829, 1, 0, 0, 0, 1860, 1838, 1, 0, 0, 0, 1860, 1847, 1, 0, 0, 0, 1860, 1854, 1, 0, 0, 0, 1860, 1857, 1, 0, 0, 0, 1861, 169, 1, 0, 0, 0, 1862, 1863, 5, 243, 0, 0, 1863, 1864, 3, 170, 85, 0, 1864, 1865, 6, 85, -1, 0, 1865, 1880, 1, 0, 0, 0, 1866, 1867, 5, 244, 0, 0, 1867, 1868, 3, 170, 85, 0, 1868, 1869, 6, 85, -1, 0, 1869, 1880, 1, 0, 0, 0, 1870, 1871, 3, 172, 86, 0, 1871, 1872, 6, 85, -1, 0, 1872, 1880, 1, 0, 0, 0, 1873, 1874, 5, 112, 0, 0, 1874, 1875, 5, 30, 0, 0, 1875, 1876, 3, 32, 16, 0, 1876, 1877, 5, 31, 0, 0, 1877, 1878, 6, 85, -1, 0, 1878, 1880, 1, 0, 0, 0, 1879, 1862, 1, 0, 0, 0, 1879, 1866, 1, 0, 0, 0, 1879, 1870, 1, 0, 0, 0, 1879, 1873, 1, 0, 0, 0, 1880, 171, 1, 0, 0, 0, 1881, 1901, 1, 0, 0, 0, 1882, 1883, 5, 245, 0, 0, 1883, 1901, 6, 86, -1, 0, 1884, 1885, 5, 246, 0, 0, 1885, 1901, 6, 86, -1, 0, 1886, 1887, 5, 247, 0, 0, 1887, 1888, 5, 248, 0, 0, 1888, 1901, 6, 86, -1, 0, 1889, 1890, 5, 247, 0, 0, 1890, 1891, 5, 249, 0, 0, 1891, 1901, 6, 86, -1, 0, 1892, 1893, 5, 247, 0, 0, 1893, 1894, 5, 250, 0, 0, 1894, 1901, 6, 86, -1, 0, 1895, 1896, 5, 247, 0, 0, 1896, 1897, 5, 251, 0, 0, 1897, 1901, 6, 86, -1, 0, 1898, 1899, 5, 247, 0, 0, 1899, 1901, 6, 86, -1, 0, 1900, 1881, 1, 0, 0, 0, 1900, 1882, 1, 0, 0, 0, 1900, 1884, 1, 0, 0, 0, 1900, 1886, 1, 0, 0, 0, 1900, 1889, 1, 0, 0, 0, 1900, 1892, 1, 0, 0, 0, 1900, 1895, 1, 0, 0, 0, 1900, 1898, 1, 0, 0, 0, 1901, 173, 1, 0, 0, 0, 1902, 1903, 5, 113, 0, 0, 1903, 1904, 5, 30, 0, 0, 1904, 1905, 3, 32, 16, 0, 1905, 1906, 5, 31, 0, 0, 1906, 1907, 6, 87, -1, 0, 1907, 175, 1, 0, 0, 0, 1908, 1909, 5, 226, 0, 0, 1909, 1910, 3, 168, 84, 0, 1910, 1911, 6, 88, -1, 0, 1911, 1920, 1, 0, 0, 0, 1912, 1913, 5, 37, 0, 0, 1913, 1914, 3, 178, 89, 0, 1914, 1915, 6, 88, -1, 0, 1915, 1920, 1, 0, 0, 0, 1916, 1917, 3, 174, 87, 0, 1917, 1918, 6, 88, -1, 0, 1918, 1920, 1, 0, 0, 0, 1919, 1908, 1, 0, 0, 0, 1919, 1912, 1, 0, 0, 0, 1919, 1916, 1, 0, 0, 0, 1920, 177, 1, 0, 0, 0, 1921, 1922, 3, 138, 69, 0, 1922, 1923, 3, 124, 62, 0, 1923, 1924, 5, 176, 0, 0, 1924, 1925, 3, 2, 1, 0, 1925, 1926, 6, 89, -1, 0, 1926, 1935, 1, 0, 0, 0, 1927, 1928, 3, 138, 69, 0, 1928, 1929, 3, 2, 1, 0, 1929, 1930, 6, 89, -1, 0, 1930, 1935, 1, 0, 0, 0, 1931, 1932, 3, 2, 1, 0, 1932, 1933, 6, 89, -1, 0, 1933, 1935, 1, 0, 0, 0, 1934, 1921, 1, 0, 0, 0, 1934, 1927, 1, 0, 0, 0, 1934, 1931, 1, 0, 0, 0, 1935, 179, 1, 0, 0, 0, 1936, 1937, 3, 124, 62, 0, 1937, 1938, 6, 90, -1, 0, 1938, 1939, 5, 28, 0, 0, 1939, 1941, 1, 0, 0, 0, 1940, 1936, 1, 0, 0, 0, 1941, 1944, 1, 0, 0, 0, 1942, 1940, 1, 0, 0, 0, 1942, 1943, 1, 0, 0, 0, 1943, 1945, 1, 0, 0, 0, 1944, 1942, 1, 0, 0, 0, 1945, 1946, 3, 124, 62, 0, 1946, 1947, 6, 90, -1, 0, 1947, 181, 1, 0, 0, 0, 1948, 1955, 1, 0, 0, 0, 1949, 1950, 5, 86, 0, 0, 1950, 1951, 3, 190, 95, 0, 1951, 1952, 5, 87, 0, 0, 1952, 1953, 6, 91, -1, 0, 1953, 1955, 1, 0, 0, 0, 1954, 1948, 1, 0, 0, 0, 1954, 1949, 1, 0, 0, 0, 1955, 183, 1, 0, 0, 0, 1956, 1957, 5, 266, 0, 0, 1957, 1975, 6, 92, -1, 0, 1958, 1959, 5, 114, 0, 0, 1959, 1975, 6, 92, -1, 0, 1960, 1961, 5, 39, 0, 0, 1961, 1975, 6, 92, -1, 0, 1962, 1963, 5, 200, 0, 0, 1963, 1975, 6, 92, -1, 0, 1964, 1965, 5, 115, 0, 0, 1965, 1975, 6, 92, -1, 0, 1966, 1967, 5, 116, 0, 0, 1967, 1975, 6, 92, -1, 0, 1968, 1969, 5, 70, 0, 0, 1969, 1970, 5, 30, 0, 0, 1970, 1971, 3, 32, 16, 0, 1971, 1972, 5, 31, 0, 0, 1972, 1973, 6, 92, -1, 0, 1973, 1975, 1, 0, 0, 0, 1974, 1956, 1, 0, 0, 0, 1974, 1958, 1, 0, 0, 0, 1974, 1960, 1, 0, 0, 0, 1974, 1962, 1, 0, 0, 0, 1974, 1964, 1, 0, 0, 0, 1974, 1966, 1, 0, 0, 0, 1974, 1968, 1, 0, 0, 0, 1975, 185, 1, 0, 0, 0, 1976, 1977, 3, 184, 92, 0, 1977, 1978, 6, 93, -1, 0, 1978, 1980, 1, 0, 0, 0, 1979, 1976, 1, 0, 0, 0, 1980, 1983, 1, 0, 0, 0, 1981, 1979, 1, 0, 0, 0, 1981, 1982, 1, 0, 0, 0, 1982, 187, 1, 0, 0, 0, 1983, 1981, 1, 0, 0, 0, 1984, 1986, 3, 186, 93, 0, 1985, 1987, 3, 192, 96, 0, 1986, 1985, 1, 0, 0, 0, 1986, 1987, 1, 0, 0, 0, 1987, 1988, 1, 0, 0, 0, 1988, 1989, 3, 2, 1, 0, 1989, 1990, 6, 94, -1, 0, 1990, 189, 1, 0, 0, 0, 1991, 1992, 3, 188, 94, 0, 1992, 1993, 6, 95, -1, 0, 1993, 1994, 5, 28, 0, 0, 1994, 1996, 1, 0, 0, 0, 1995, 1991, 1, 0, 0, 0, 1996, 1999, 1, 0, 0, 0, 1997, 1995, 1, 0, 0, 0, 1997, 1998, 1, 0, 0, 0, 1998, 2000, 1, 0, 0, 0, 1999, 1997, 1, 0, 0, 0, 2000, 2001, 3, 188, 94, 0, 2001, 2002, 6, 95, -1, 0, 2002, 191, 1, 0, 0, 0, 2003, 2004, 5, 30, 0, 0, 2004, 2005, 3, 180, 90, 0, 2005, 2006, 5, 31, 0, 0, 2006, 2007, 6, 96, -1, 0, 2007, 193, 1, 0, 0, 0, 2008, 2010, 3, 196, 98, 0, 2009, 2008, 1, 0, 0, 0, 2009, 2010, 1, 0, 0, 0, 2010, 2011, 1, 0, 0, 0, 2011, 2012, 6, 97, -1, 0, 2012, 195, 1, 0, 0, 0, 2013, 2014, 5, 86, 0, 0, 2014, 2015, 5, 42, 0, 0, 2015, 2016, 3, 32, 16, 0, 2016, 2017, 5, 43, 0, 0, 2017, 2018, 5, 87, 0, 0, 2018, 2019, 6, 98, -1, 0, 2019, 197, 1, 0, 0, 0, 2020, 2021, 3, 234, 117, 0, 2021, 2022, 5, 17, 0, 0, 2022, 2023, 3, 246, 123, 0, 2023, 2024, 5, 18, 0, 0, 2024, 2171, 1, 0, 0, 0, 2025, 2026, 3, 74, 37, 0, 2026, 2027, 5, 17, 0, 0, 2027, 2028, 3, 82, 41, 0, 2028, 2029, 5, 18, 0, 0, 2029, 2171, 1, 0, 0, 0, 2030, 2031, 3, 210, 105, 0, 2031, 2032, 6, 99, -1, 0, 2032, 2033, 5, 17, 0, 0, 2033, 2034, 3, 214, 107, 0, 2034, 2035, 5, 18, 0, 0, 2035, 2171, 1, 0, 0, 0, 2036, 2037, 3, 218, 109, 0, 2037, 2038, 6, 99, -1, 0, 2038, 2039, 5, 17, 0, 0, 2039, 2040, 3, 222, 111, 0, 2040, 2041, 5, 18, 0, 0, 2041, 2171, 1, 0, 0, 0, 2042, 2171, 3, 200, 100, 0, 2043, 2044, 3, 284, 142, 0, 2044, 2045, 6, 99, -1, 0, 2045, 2171, 1, 0, 0, 0, 2046, 2047, 3, 152, 76, 0, 2047, 2048, 6, 99, -1, 0, 2048, 2171, 1, 0, 0, 0, 2049, 2050, 3, 88, 44, 0, 2050, 2051, 6, 99, -1, 0, 2051, 2171, 1, 0, 0, 0, 2052, 2053, 3, 330, 165, 0, 2053, 2054, 6, 99, -1, 0, 2054, 2171, 1, 0, 0, 0, 2055, 2056, 5, 117, 0, 0, 2056, 2057, 3, 32, 16, 0, 2057, 2058, 6, 99, -1, 0, 2058, 2171, 1, 0, 0, 0, 2059, 2060, 5, 118, 0, 0, 2060, 2061, 3, 32, 16, 0, 2061, 2062, 6, 99, -1, 0, 2062, 2171, 1, 0, 0, 0, 2063, 2064, 3, 342, 171, 0, 2064, 2065, 5, 17, 0, 0, 2065, 2066, 3, 346, 173, 0, 2066, 2067, 5, 18, 0, 0, 2067, 2068, 6, 99, -1, 0, 2068, 2171, 1, 0, 0, 0, 2069, 2070, 5, 302, 0, 0, 2070, 2071, 3, 124, 62, 0, 2071, 2072, 5, 176, 0, 0, 2072, 2073, 3, 242, 121, 0, 2073, 2074, 5, 119, 0, 0, 2074, 2075, 3, 170, 85, 0, 2075, 2076, 3, 138, 69, 0, 2076, 2077, 3, 124, 62, 0, 2077, 2078, 5, 176, 0, 0, 2078, 2079, 3, 242, 121, 0, 2079, 2080, 3, 112, 56, 0, 2080, 2081, 6, 99, -1, 0, 2081, 2171, 1, 0, 0, 0, 2082, 2083, 5, 302, 0, 0, 2083, 2084, 5, 226, 0, 0, 2084, 2085, 3, 170, 85, 0, 2085, 2086, 3, 138, 69, 0, 2086, 2087, 3, 124, 62, 0, 2087, 2088, 5, 176, 0, 0, 2088, 2089, 3, 242, 121, 0, 2089, 2090, 3, 194, 97, 0, 2090, 2091, 3, 112, 56, 0, 2091, 2092, 5, 119, 0, 0, 2092, 2093, 5, 226, 0, 0, 2093, 2094, 3, 170, 85, 0, 2094, 2095, 3, 138, 69, 0, 2095, 2096, 3, 124, 62, 0, 2096, 2097, 5, 176, 0, 0, 2097, 2098, 3, 242, 121, 0, 2098, 2099, 3, 194, 97, 0, 2099, 2100, 3, 112, 56, 0, 2100, 2101, 6, 99, -1, 0, 2101, 2171, 1, 0, 0, 0, 2102, 2103, 3, 26, 13, 0, 2103, 2104, 6, 99, -1, 0, 2104, 2171, 1, 0, 0, 0, 2105, 2106, 3, 40, 20, 0, 2106, 2107, 6, 99, -1, 0, 2107, 2171, 1, 0, 0, 0, 2108, 2109, 5, 255, 0, 0, 2109, 2110, 5, 196, 0, 0, 2110, 2111, 5, 42, 0, 0, 2111, 2112, 3, 32, 16, 0, 2112, 2113, 5, 43, 0, 0, 2113, 2119, 6, 99, -1, 0, 2114, 2115, 3, 330, 165, 0, 2115, 2116, 6, 99, -1, 0, 2116, 2118, 1, 0, 0, 0, 2117, 2114, 1, 0, 0, 0, 2118, 2121, 1, 0, 0, 0, 2119, 2117, 1, 0, 0, 0, 2119, 2120, 1, 0, 0, 0, 2120, 2171, 1, 0, 0, 0, 2121, 2119, 1, 0, 0, 0, 2122, 2123, 5, 255, 0, 0, 2123, 2124, 5, 196, 0, 0, 2124, 2125, 3, 2, 1, 0, 2125, 2131, 6, 99, -1, 0, 2126, 2127, 3, 330, 165, 0, 2127, 2128, 6, 99, -1, 0, 2128, 2130, 1, 0, 0, 0, 2129, 2126, 1, 0, 0, 0, 2130, 2133, 1, 0, 0, 0, 2131, 2129, 1, 0, 0, 0, 2131, 2132, 1, 0, 0, 0, 2132, 2171, 1, 0, 0, 0, 2133, 2131, 1, 0, 0, 0, 2134, 2135, 5, 255, 0, 0, 2135, 2136, 5, 256, 0, 0, 2136, 2137, 5, 42, 0, 0, 2137, 2138, 3, 32, 16, 0, 2138, 2139, 5, 43, 0, 0, 2139, 2140, 5, 28, 0, 0, 2140, 2141, 3, 124, 62, 0, 2141, 2147, 6, 99, -1, 0, 2142, 2143, 3, 330, 165, 0, 2143, 2144, 6, 99, -1, 0, 2144, 2146, 1, 0, 0, 0, 2145, 2142, 1, 0, 0, 0, 2146, 2149, 1, 0, 0, 0, 2147, 2145, 1, 0, 0, 0, 2147, 2148, 1, 0, 0, 0, 2148, 2171, 1, 0, 0, 0, 2149, 2147, 1, 0, 0, 0, 2150, 2151, 5, 255, 0, 0, 2151, 2152, 5, 256, 0, 0, 2152, 2153, 3, 2, 1, 0, 2153, 2154, 5, 28, 0, 0, 2154, 2155, 3, 124, 62, 0, 2155, 2161, 6, 99, -1, 0, 2156, 2157, 3, 330, 165, 0, 2157, 2158, 6, 99, -1, 0, 2158, 2160, 1, 0, 0, 0, 2159, 2156, 1, 0, 0, 0, 2160, 2163, 1, 0, 0, 0, 2161, 2159, 1, 0, 0, 0, 2161, 2162, 1, 0, 0, 0, 2162, 2171, 1, 0, 0, 0, 2163, 2161, 1, 0, 0, 0, 2164, 2165, 5, 120, 0, 0, 2165, 2166, 5, 196, 0, 0, 2166, 2167, 3, 124, 62, 0, 2167, 2168, 3, 44, 22, 0, 2168, 2169, 6, 99, -1, 0, 2169, 2171, 1, 0, 0, 0, 2170, 2020, 1, 0, 0, 0, 2170, 2025, 1, 0, 0, 0, 2170, 2030, 1, 0, 0, 0, 2170, 2036, 1, 0, 0, 0, 2170, 2042, 1, 0, 0, 0, 2170, 2043, 1, 0, 0, 0, 2170, 2046, 1, 0, 0, 0, 2170, 2049, 1, 0, 0, 0, 2170, 2052, 1, 0, 0, 0, 2170, 2055, 1, 0, 0, 0, 2170, 2059, 1, 0, 0, 0, 2170, 2063, 1, 0, 0, 0, 2170, 2069, 1, 0, 0, 0, 2170, 2082, 1, 0, 0, 0, 2170, 2102, 1, 0, 0, 0, 2170, 2105, 1, 0, 0, 0, 2170, 2108, 1, 0, 0, 0, 2170, 2122, 1, 0, 0, 0, 2170, 2134, 1, 0, 0, 0, 2170, 2150, 1, 0, 0, 0, 2170, 2164, 1, 0, 0, 0, 2171, 199, 1, 0, 0, 0, 2172, 2173, 5, 121, 0, 0, 2173, 2185, 3, 208, 104, 0, 2174, 2175, 3, 202, 101, 0, 2175, 2176, 6, 100, -1, 0, 2176, 2184, 1, 0, 0, 0, 2177, 2178, 5, 122, 0, 0, 2178, 2179, 5, 30, 0, 0, 2179, 2180, 3, 228, 114, 0, 2180, 2181, 5, 31, 0, 0, 2181, 2182, 6, 100, -1, 0, 2182, 2184, 1, 0, 0, 0, 2183, 2174, 1, 0, 0, 0, 2183, 2177, 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, 2189, 3, 138, 69, 0, 2189, 2190, 3, 2, 1, 0, 2190, 2191, 3, 204, 102, 0, 2191, 2192, 3, 206, 103, 0, 2192, 2193, 6, 100, -1, 0, 2193, 201, 1, 0, 0, 0, 2194, 2195, 5, 123, 0, 0, 2195, 2229, 6, 101, -1, 0, 2196, 2197, 5, 51, 0, 0, 2197, 2229, 6, 101, -1, 0, 2198, 2199, 5, 52, 0, 0, 2199, 2229, 6, 101, -1, 0, 2200, 2201, 5, 63, 0, 0, 2201, 2229, 6, 101, -1, 0, 2202, 2203, 5, 124, 0, 0, 2203, 2229, 6, 101, -1, 0, 2204, 2205, 5, 69, 0, 0, 2205, 2229, 6, 101, -1, 0, 2206, 2207, 5, 68, 0, 0, 2207, 2229, 6, 101, -1, 0, 2208, 2209, 5, 64, 0, 0, 2209, 2229, 6, 101, -1, 0, 2210, 2211, 5, 65, 0, 0, 2211, 2229, 6, 101, -1, 0, 2212, 2213, 5, 66, 0, 0, 2213, 2229, 6, 101, -1, 0, 2214, 2215, 5, 125, 0, 0, 2215, 2229, 6, 101, -1, 0, 2216, 2217, 5, 126, 0, 0, 2217, 2229, 6, 101, -1, 0, 2218, 2219, 5, 127, 0, 0, 2219, 2229, 6, 101, -1, 0, 2220, 2221, 5, 16, 0, 0, 2221, 2229, 6, 101, -1, 0, 2222, 2223, 5, 70, 0, 0, 2223, 2224, 5, 30, 0, 0, 2224, 2225, 3, 32, 16, 0, 2225, 2226, 5, 31, 0, 0, 2226, 2227, 6, 101, -1, 0, 2227, 2229, 1, 0, 0, 0, 2228, 2194, 1, 0, 0, 0, 2228, 2196, 1, 0, 0, 0, 2228, 2198, 1, 0, 0, 0, 2228, 2200, 1, 0, 0, 0, 2228, 2202, 1, 0, 0, 0, 2228, 2204, 1, 0, 0, 0, 2228, 2206, 1, 0, 0, 0, 2228, 2208, 1, 0, 0, 0, 2228, 2210, 1, 0, 0, 0, 2228, 2212, 1, 0, 0, 0, 2228, 2214, 1, 0, 0, 0, 2228, 2216, 1, 0, 0, 0, 2228, 2218, 1, 0, 0, 0, 2228, 2220, 1, 0, 0, 0, 2228, 2222, 1, 0, 0, 0, 2229, 203, 1, 0, 0, 0, 2230, 2240, 1, 0, 0, 0, 2231, 2232, 5, 44, 0, 0, 2232, 2233, 3, 0, 0, 0, 2233, 2234, 6, 102, -1, 0, 2234, 2240, 1, 0, 0, 0, 2235, 2236, 5, 44, 0, 0, 2236, 2237, 3, 32, 16, 0, 2237, 2238, 6, 102, -1, 0, 2238, 2240, 1, 0, 0, 0, 2239, 2230, 1, 0, 0, 0, 2239, 2231, 1, 0, 0, 0, 2239, 2235, 1, 0, 0, 0, 2240, 205, 1, 0, 0, 0, 2241, 2247, 1, 0, 0, 0, 2242, 2243, 5, 36, 0, 0, 2243, 2244, 3, 304, 152, 0, 2244, 2245, 6, 103, -1, 0, 2245, 2247, 1, 0, 0, 0, 2246, 2241, 1, 0, 0, 0, 2246, 2242, 1, 0, 0, 0, 2247, 207, 1, 0, 0, 0, 2248, 2255, 1, 0, 0, 0, 2249, 2250, 5, 42, 0, 0, 2250, 2251, 3, 32, 16, 0, 2251, 2252, 5, 43, 0, 0, 2252, 2253, 6, 104, -1, 0, 2253, 2255, 1, 0, 0, 0, 2254, 2248, 1, 0, 0, 0, 2254, 2249, 1, 0, 0, 0, 2255, 209, 1, 0, 0, 0, 2256, 2262, 5, 128, 0, 0, 2257, 2258, 3, 212, 106, 0, 2258, 2259, 6, 105, -1, 0, 2259, 2261, 1, 0, 0, 0, 2260, 2257, 1, 0, 0, 0, 2261, 2264, 1, 0, 0, 0, 2262, 2260, 1, 0, 0, 0, 2262, 2263, 1, 0, 0, 0, 2263, 2265, 1, 0, 0, 0, 2264, 2262, 1, 0, 0, 0, 2265, 2266, 3, 124, 62, 0, 2266, 2267, 3, 2, 1, 0, 2267, 2268, 6, 105, -1, 0, 2268, 2282, 1, 0, 0, 0, 2269, 2275, 5, 128, 0, 0, 2270, 2271, 3, 212, 106, 0, 2271, 2272, 6, 105, -1, 0, 2272, 2274, 1, 0, 0, 0, 2273, 2270, 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, 2279, 3, 2, 1, 0, 2279, 2280, 6, 105, -1, 0, 2280, 2282, 1, 0, 0, 0, 2281, 2256, 1, 0, 0, 0, 2281, 2269, 1, 0, 0, 0, 2282, 211, 1, 0, 0, 0, 2283, 2284, 5, 69, 0, 0, 2284, 2288, 6, 106, -1, 0, 2285, 2286, 5, 68, 0, 0, 2286, 2288, 6, 106, -1, 0, 2287, 2283, 1, 0, 0, 0, 2287, 2285, 1, 0, 0, 0, 2288, 213, 1, 0, 0, 0, 2289, 2291, 3, 216, 108, 0, 2290, 2289, 1, 0, 0, 0, 2291, 2294, 1, 0, 0, 0, 2292, 2290, 1, 0, 0, 0, 2292, 2293, 1, 0, 0, 0, 2293, 215, 1, 0, 0, 0, 2294, 2292, 1, 0, 0, 0, 2295, 2296, 5, 129, 0, 0, 2296, 2297, 3, 168, 84, 0, 2297, 2298, 6, 108, -1, 0, 2298, 2322, 1, 0, 0, 0, 2299, 2300, 5, 130, 0, 0, 2300, 2301, 3, 168, 84, 0, 2301, 2302, 6, 108, -1, 0, 2302, 2322, 1, 0, 0, 0, 2303, 2304, 5, 131, 0, 0, 2304, 2305, 3, 168, 84, 0, 2305, 2306, 6, 108, -1, 0, 2306, 2322, 1, 0, 0, 0, 2307, 2308, 5, 132, 0, 0, 2308, 2309, 3, 168, 84, 0, 2309, 2310, 6, 108, -1, 0, 2310, 2322, 1, 0, 0, 0, 2311, 2312, 3, 88, 44, 0, 2312, 2313, 6, 108, -1, 0, 2313, 2322, 1, 0, 0, 0, 2314, 2315, 3, 330, 165, 0, 2315, 2316, 6, 108, -1, 0, 2316, 2322, 1, 0, 0, 0, 2317, 2318, 3, 26, 13, 0, 2318, 2319, 6, 108, -1, 0, 2319, 2322, 1, 0, 0, 0, 2320, 2322, 3, 40, 20, 0, 2321, 2295, 1, 0, 0, 0, 2321, 2299, 1, 0, 0, 0, 2321, 2303, 1, 0, 0, 0, 2321, 2307, 1, 0, 0, 0, 2321, 2311, 1, 0, 0, 0, 2321, 2314, 1, 0, 0, 0, 2321, 2317, 1, 0, 0, 0, 2321, 2320, 1, 0, 0, 0, 2322, 217, 1, 0, 0, 0, 2323, 2329, 5, 133, 0, 0, 2324, 2325, 3, 220, 110, 0, 2325, 2326, 6, 109, -1, 0, 2326, 2328, 1, 0, 0, 0, 2327, 2324, 1, 0, 0, 0, 2328, 2331, 1, 0, 0, 0, 2329, 2327, 1, 0, 0, 0, 2329, 2330, 1, 0, 0, 0, 2330, 2332, 1, 0, 0, 0, 2331, 2329, 1, 0, 0, 0, 2332, 2333, 3, 170, 85, 0, 2333, 2334, 3, 138, 69, 0, 2334, 2335, 3, 2, 1, 0, 2335, 2336, 3, 112, 56, 0, 2336, 2337, 3, 206, 103, 0, 2337, 2338, 6, 109, -1, 0, 2338, 219, 1, 0, 0, 0, 2339, 2340, 5, 69, 0, 0, 2340, 2344, 6, 110, -1, 0, 2341, 2342, 5, 68, 0, 0, 2342, 2344, 6, 110, -1, 0, 2343, 2339, 1, 0, 0, 0, 2343, 2341, 1, 0, 0, 0, 2344, 221, 1, 0, 0, 0, 2345, 2347, 3, 224, 112, 0, 2346, 2345, 1, 0, 0, 0, 2347, 2350, 1, 0, 0, 0, 2348, 2346, 1, 0, 0, 0, 2348, 2349, 1, 0, 0, 0, 2349, 223, 1, 0, 0, 0, 2350, 2348, 1, 0, 0, 0, 2351, 2352, 5, 134, 0, 0, 2352, 2353, 3, 168, 84, 0, 2353, 2354, 6, 112, -1, 0, 2354, 2374, 1, 0, 0, 0, 2355, 2356, 5, 135, 0, 0, 2356, 2357, 3, 168, 84, 0, 2357, 2358, 6, 112, -1, 0, 2358, 2374, 1, 0, 0, 0, 2359, 2360, 5, 132, 0, 0, 2360, 2361, 3, 168, 84, 0, 2361, 2362, 6, 112, -1, 0, 2362, 2374, 1, 0, 0, 0, 2363, 2364, 3, 330, 165, 0, 2364, 2365, 6, 112, -1, 0, 2365, 2374, 1, 0, 0, 0, 2366, 2367, 3, 88, 44, 0, 2367, 2368, 6, 112, -1, 0, 2368, 2374, 1, 0, 0, 0, 2369, 2370, 3, 26, 13, 0, 2370, 2371, 6, 112, -1, 0, 2371, 2374, 1, 0, 0, 0, 2372, 2374, 3, 40, 20, 0, 2373, 2351, 1, 0, 0, 0, 2373, 2355, 1, 0, 0, 0, 2373, 2359, 1, 0, 0, 0, 2373, 2363, 1, 0, 0, 0, 2373, 2366, 1, 0, 0, 0, 2373, 2369, 1, 0, 0, 0, 2373, 2372, 1, 0, 0, 0, 2374, 225, 1, 0, 0, 0, 2375, 2383, 6, 113, -1, 0, 2376, 2377, 5, 122, 0, 0, 2377, 2378, 5, 30, 0, 0, 2378, 2379, 3, 228, 114, 0, 2379, 2380, 5, 31, 0, 0, 2380, 2381, 6, 113, -1, 0, 2381, 2383, 1, 0, 0, 0, 2382, 2375, 1, 0, 0, 0, 2382, 2376, 1, 0, 0, 0, 2383, 227, 1, 0, 0, 0, 2384, 2385, 3, 126, 63, 0, 2385, 2386, 6, 114, -1, 0, 2386, 2398, 1, 0, 0, 0, 2387, 2391, 5, 17, 0, 0, 2388, 2389, 3, 302, 151, 0, 2389, 2390, 6, 114, -1, 0, 2390, 2392, 1, 0, 0, 0, 2391, 2388, 1, 0, 0, 0, 2392, 2393, 1, 0, 0, 0, 2393, 2391, 1, 0, 0, 0, 2393, 2394, 1, 0, 0, 0, 2394, 2395, 1, 0, 0, 0, 2395, 2396, 5, 18, 0, 0, 2396, 2398, 1, 0, 0, 0, 2397, 2384, 1, 0, 0, 0, 2397, 2387, 1, 0, 0, 0, 2398, 229, 1, 0, 0, 0, 2399, 2400, 3, 232, 116, 0, 2400, 2401, 6, 115, -1, 0, 2401, 2403, 1, 0, 0, 0, 2402, 2399, 1, 0, 0, 0, 2403, 2406, 1, 0, 0, 0, 2404, 2402, 1, 0, 0, 0, 2404, 2405, 1, 0, 0, 0, 2405, 231, 1, 0, 0, 0, 2406, 2404, 1, 0, 0, 0, 2407, 2408, 5, 42, 0, 0, 2408, 2409, 5, 136, 0, 0, 2409, 2410, 5, 43, 0, 0, 2410, 2425, 6, 116, -1, 0, 2411, 2412, 5, 42, 0, 0, 2412, 2413, 5, 137, 0, 0, 2413, 2414, 5, 43, 0, 0, 2414, 2425, 6, 116, -1, 0, 2415, 2416, 5, 42, 0, 0, 2416, 2417, 5, 138, 0, 0, 2417, 2418, 5, 43, 0, 0, 2418, 2425, 6, 116, -1, 0, 2419, 2420, 5, 42, 0, 0, 2420, 2421, 3, 32, 16, 0, 2421, 2422, 5, 43, 0, 0, 2422, 2423, 6, 116, -1, 0, 2423, 2425, 1, 0, 0, 0, 2424, 2407, 1, 0, 0, 0, 2424, 2411, 1, 0, 0, 0, 2424, 2415, 1, 0, 0, 0, 2424, 2419, 1, 0, 0, 0, 2425, 233, 1, 0, 0, 0, 2426, 2435, 5, 139, 0, 0, 2427, 2428, 3, 236, 118, 0, 2428, 2429, 6, 117, -1, 0, 2429, 2434, 1, 0, 0, 0, 2430, 2431, 3, 238, 119, 0, 2431, 2432, 6, 117, -1, 0, 2432, 2434, 1, 0, 0, 0, 2433, 2427, 1, 0, 0, 0, 2433, 2430, 1, 0, 0, 0, 2434, 2437, 1, 0, 0, 0, 2435, 2433, 1, 0, 0, 0, 2435, 2436, 1, 0, 0, 0, 2436, 2438, 1, 0, 0, 0, 2437, 2435, 1, 0, 0, 0, 2438, 2439, 3, 170, 85, 0, 2439, 2440, 3, 230, 115, 0, 2440, 2441, 3, 138, 69, 0, 2441, 2442, 3, 226, 113, 0, 2442, 2443, 3, 242, 121, 0, 2443, 2444, 3, 182, 91, 0, 2444, 2450, 3, 112, 56, 0, 2445, 2446, 3, 244, 122, 0, 2446, 2447, 6, 117, -1, 0, 2447, 2449, 1, 0, 0, 0, 2448, 2445, 1, 0, 0, 0, 2449, 2452, 1, 0, 0, 0, 2450, 2448, 1, 0, 0, 0, 2450, 2451, 1, 0, 0, 0, 2451, 2453, 1, 0, 0, 0, 2452, 2450, 1, 0, 0, 0, 2453, 2454, 6, 117, -1, 0, 2454, 235, 1, 0, 0, 0, 2455, 2456, 5, 123, 0, 0, 2456, 2498, 6, 118, -1, 0, 2457, 2458, 5, 51, 0, 0, 2458, 2498, 6, 118, -1, 0, 2459, 2460, 5, 52, 0, 0, 2460, 2498, 6, 118, -1, 0, 2461, 2462, 5, 63, 0, 0, 2462, 2498, 6, 118, -1, 0, 2463, 2464, 5, 140, 0, 0, 2464, 2498, 6, 118, -1, 0, 2465, 2466, 5, 68, 0, 0, 2466, 2498, 6, 118, -1, 0, 2467, 2468, 5, 141, 0, 0, 2468, 2498, 6, 118, -1, 0, 2469, 2470, 5, 142, 0, 0, 2470, 2498, 6, 118, -1, 0, 2471, 2472, 5, 54, 0, 0, 2472, 2498, 6, 118, -1, 0, 2473, 2474, 5, 64, 0, 0, 2474, 2498, 6, 118, -1, 0, 2475, 2476, 5, 65, 0, 0, 2476, 2498, 6, 118, -1, 0, 2477, 2478, 5, 66, 0, 0, 2478, 2498, 6, 118, -1, 0, 2479, 2480, 5, 125, 0, 0, 2480, 2498, 6, 118, -1, 0, 2481, 2482, 5, 143, 0, 0, 2482, 2498, 6, 118, -1, 0, 2483, 2484, 5, 144, 0, 0, 2484, 2498, 6, 118, -1, 0, 2485, 2486, 5, 69, 0, 0, 2486, 2498, 6, 118, -1, 0, 2487, 2488, 5, 145, 0, 0, 2488, 2498, 6, 118, -1, 0, 2489, 2490, 5, 146, 0, 0, 2490, 2498, 6, 118, -1, 0, 2491, 2492, 5, 70, 0, 0, 2492, 2493, 5, 30, 0, 0, 2493, 2494, 3, 32, 16, 0, 2494, 2495, 5, 31, 0, 0, 2495, 2496, 6, 118, -1, 0, 2496, 2498, 1, 0, 0, 0, 2497, 2455, 1, 0, 0, 0, 2497, 2457, 1, 0, 0, 0, 2497, 2459, 1, 0, 0, 0, 2497, 2461, 1, 0, 0, 0, 2497, 2463, 1, 0, 0, 0, 2497, 2465, 1, 0, 0, 0, 2497, 2467, 1, 0, 0, 0, 2497, 2469, 1, 0, 0, 0, 2497, 2471, 1, 0, 0, 0, 2497, 2473, 1, 0, 0, 0, 2497, 2475, 1, 0, 0, 0, 2497, 2477, 1, 0, 0, 0, 2497, 2479, 1, 0, 0, 0, 2497, 2481, 1, 0, 0, 0, 2497, 2483, 1, 0, 0, 0, 2497, 2485, 1, 0, 0, 0, 2497, 2487, 1, 0, 0, 0, 2497, 2489, 1, 0, 0, 0, 2497, 2491, 1, 0, 0, 0, 2498, 237, 1, 0, 0, 0, 2499, 2500, 5, 147, 0, 0, 2500, 2509, 5, 30, 0, 0, 2501, 2502, 3, 6, 3, 0, 2502, 2507, 6, 119, -1, 0, 2503, 2504, 5, 34, 0, 0, 2504, 2505, 3, 6, 3, 0, 2505, 2506, 6, 119, -1, 0, 2506, 2508, 1, 0, 0, 0, 2507, 2503, 1, 0, 0, 0, 2507, 2508, 1, 0, 0, 0, 2508, 2510, 1, 0, 0, 0, 2509, 2501, 1, 0, 0, 0, 2509, 2510, 1, 0, 0, 0, 2510, 2516, 1, 0, 0, 0, 2511, 2512, 3, 240, 120, 0, 2512, 2513, 6, 119, -1, 0, 2513, 2515, 1, 0, 0, 0, 2514, 2511, 1, 0, 0, 0, 2515, 2518, 1, 0, 0, 0, 2516, 2514, 1, 0, 0, 0, 2516, 2517, 1, 0, 0, 0, 2517, 2519, 1, 0, 0, 0, 2518, 2516, 1, 0, 0, 0, 2519, 2523, 5, 31, 0, 0, 2520, 2521, 5, 147, 0, 0, 2521, 2523, 5, 85, 0, 0, 2522, 2499, 1, 0, 0, 0, 2522, 2520, 1, 0, 0, 0, 2523, 239, 1, 0, 0, 0, 2524, 2525, 5, 148, 0, 0, 2525, 2567, 6, 120, -1, 0, 2526, 2527, 5, 224, 0, 0, 2527, 2567, 6, 120, -1, 0, 2528, 2529, 5, 57, 0, 0, 2529, 2567, 6, 120, -1, 0, 2530, 2531, 5, 58, 0, 0, 2531, 2567, 6, 120, -1, 0, 2532, 2533, 5, 149, 0, 0, 2533, 2567, 6, 120, -1, 0, 2534, 2535, 5, 150, 0, 0, 2535, 2567, 6, 120, -1, 0, 2536, 2537, 5, 248, 0, 0, 2537, 2567, 6, 120, -1, 0, 2538, 2539, 5, 249, 0, 0, 2539, 2567, 6, 120, -1, 0, 2540, 2541, 5, 250, 0, 0, 2541, 2567, 6, 120, -1, 0, 2542, 2543, 5, 251, 0, 0, 2543, 2567, 6, 120, -1, 0, 2544, 2545, 5, 151, 0, 0, 2545, 2546, 5, 75, 0, 0, 2546, 2547, 5, 152, 0, 0, 2547, 2567, 6, 120, -1, 0, 2548, 2549, 5, 151, 0, 0, 2549, 2550, 5, 75, 0, 0, 2550, 2551, 5, 153, 0, 0, 2551, 2567, 6, 120, -1, 0, 2552, 2553, 5, 154, 0, 0, 2553, 2554, 5, 75, 0, 0, 2554, 2555, 5, 152, 0, 0, 2555, 2567, 6, 120, -1, 0, 2556, 2557, 5, 154, 0, 0, 2557, 2558, 5, 75, 0, 0, 2558, 2559, 5, 153, 0, 0, 2559, 2567, 6, 120, -1, 0, 2560, 2561, 5, 70, 0, 0, 2561, 2562, 5, 30, 0, 0, 2562, 2563, 3, 32, 16, 0, 2563, 2564, 5, 31, 0, 0, 2564, 2565, 6, 120, -1, 0, 2565, 2567, 1, 0, 0, 0, 2566, 2524, 1, 0, 0, 0, 2566, 2526, 1, 0, 0, 0, 2566, 2528, 1, 0, 0, 0, 2566, 2530, 1, 0, 0, 0, 2566, 2532, 1, 0, 0, 0, 2566, 2534, 1, 0, 0, 0, 2566, 2536, 1, 0, 0, 0, 2566, 2538, 1, 0, 0, 0, 2566, 2540, 1, 0, 0, 0, 2566, 2542, 1, 0, 0, 0, 2566, 2544, 1, 0, 0, 0, 2566, 2548, 1, 0, 0, 0, 2566, 2552, 1, 0, 0, 0, 2566, 2556, 1, 0, 0, 0, 2566, 2560, 1, 0, 0, 0, 2567, 241, 1, 0, 0, 0, 2568, 2569, 5, 116, 0, 0, 2569, 2576, 6, 121, -1, 0, 2570, 2571, 5, 155, 0, 0, 2571, 2576, 6, 121, -1, 0, 2572, 2573, 3, 2, 1, 0, 2573, 2574, 6, 121, -1, 0, 2574, 2576, 1, 0, 0, 0, 2575, 2568, 1, 0, 0, 0, 2575, 2570, 1, 0, 0, 0, 2575, 2572, 1, 0, 0, 0, 2576, 243, 1, 0, 0, 0, 2577, 2578, 5, 1, 0, 0, 2578, 2616, 6, 122, -1, 0, 2579, 2580, 5, 2, 0, 0, 2580, 2616, 6, 122, -1, 0, 2581, 2582, 5, 156, 0, 0, 2582, 2616, 6, 122, -1, 0, 2583, 2584, 5, 3, 0, 0, 2584, 2616, 6, 122, -1, 0, 2585, 2586, 5, 4, 0, 0, 2586, 2616, 6, 122, -1, 0, 2587, 2588, 5, 247, 0, 0, 2588, 2616, 6, 122, -1, 0, 2589, 2590, 5, 5, 0, 0, 2590, 2616, 6, 122, -1, 0, 2591, 2592, 5, 6, 0, 0, 2592, 2616, 6, 122, -1, 0, 2593, 2594, 5, 7, 0, 0, 2594, 2616, 6, 122, -1, 0, 2595, 2596, 5, 8, 0, 0, 2596, 2616, 6, 122, -1, 0, 2597, 2598, 5, 9, 0, 0, 2598, 2616, 6, 122, -1, 0, 2599, 2600, 5, 10, 0, 0, 2600, 2616, 6, 122, -1, 0, 2601, 2602, 5, 11, 0, 0, 2602, 2616, 6, 122, -1, 0, 2603, 2604, 5, 12, 0, 0, 2604, 2616, 6, 122, -1, 0, 2605, 2606, 5, 13, 0, 0, 2606, 2616, 6, 122, -1, 0, 2607, 2608, 5, 14, 0, 0, 2608, 2616, 6, 122, -1, 0, 2609, 2610, 5, 70, 0, 0, 2610, 2611, 5, 30, 0, 0, 2611, 2612, 3, 32, 16, 0, 2612, 2613, 5, 31, 0, 0, 2613, 2614, 6, 122, -1, 0, 2614, 2616, 1, 0, 0, 0, 2615, 2577, 1, 0, 0, 0, 2615, 2579, 1, 0, 0, 0, 2615, 2581, 1, 0, 0, 0, 2615, 2583, 1, 0, 0, 0, 2615, 2585, 1, 0, 0, 0, 2615, 2587, 1, 0, 0, 0, 2615, 2589, 1, 0, 0, 0, 2615, 2591, 1, 0, 0, 0, 2615, 2593, 1, 0, 0, 0, 2615, 2595, 1, 0, 0, 0, 2615, 2597, 1, 0, 0, 0, 2615, 2599, 1, 0, 0, 0, 2615, 2601, 1, 0, 0, 0, 2615, 2603, 1, 0, 0, 0, 2615, 2605, 1, 0, 0, 0, 2615, 2607, 1, 0, 0, 0, 2615, 2609, 1, 0, 0, 0, 2616, 245, 1, 0, 0, 0, 2617, 2619, 3, 248, 124, 0, 2618, 2617, 1, 0, 0, 0, 2619, 2622, 1, 0, 0, 0, 2620, 2618, 1, 0, 0, 0, 2620, 2621, 1, 0, 0, 0, 2621, 247, 1, 0, 0, 0, 2622, 2620, 1, 0, 0, 0, 2623, 2661, 3, 100, 50, 0, 2624, 2625, 5, 296, 0, 0, 2625, 2626, 3, 32, 16, 0, 2626, 2627, 6, 124, -1, 0, 2627, 2661, 1, 0, 0, 0, 2628, 2661, 3, 266, 133, 0, 2629, 2630, 5, 297, 0, 0, 2630, 2631, 3, 32, 16, 0, 2631, 2632, 6, 124, -1, 0, 2632, 2661, 1, 0, 0, 0, 2633, 2634, 5, 298, 0, 0, 2634, 2661, 6, 124, -1, 0, 2635, 2636, 5, 299, 0, 0, 2636, 2661, 6, 124, -1, 0, 2637, 2661, 3, 260, 130, 0, 2638, 2661, 3, 264, 132, 0, 2639, 2661, 3, 250, 125, 0, 2640, 2641, 3, 284, 142, 0, 2641, 2642, 6, 124, -1, 0, 2642, 2661, 1, 0, 0, 0, 2643, 2644, 3, 152, 76, 0, 2644, 2645, 6, 124, -1, 0, 2645, 2661, 1, 0, 0, 0, 2646, 2647, 3, 88, 44, 0, 2647, 2648, 6, 124, -1, 0, 2648, 2661, 1, 0, 0, 0, 2649, 2650, 3, 26, 13, 0, 2650, 2651, 6, 124, -1, 0, 2651, 2661, 1, 0, 0, 0, 2652, 2653, 3, 262, 131, 0, 2653, 2654, 6, 124, -1, 0, 2654, 2661, 1, 0, 0, 0, 2655, 2661, 3, 40, 20, 0, 2656, 2661, 3, 252, 126, 0, 2657, 2661, 3, 254, 127, 0, 2658, 2661, 3, 256, 128, 0, 2659, 2661, 3, 258, 129, 0, 2660, 2623, 1, 0, 0, 0, 2660, 2624, 1, 0, 0, 0, 2660, 2628, 1, 0, 0, 0, 2660, 2629, 1, 0, 0, 0, 2660, 2633, 1, 0, 0, 0, 2660, 2635, 1, 0, 0, 0, 2660, 2637, 1, 0, 0, 0, 2660, 2638, 1, 0, 0, 0, 2660, 2639, 1, 0, 0, 0, 2660, 2640, 1, 0, 0, 0, 2660, 2643, 1, 0, 0, 0, 2660, 2646, 1, 0, 0, 0, 2660, 2649, 1, 0, 0, 0, 2660, 2652, 1, 0, 0, 0, 2660, 2655, 1, 0, 0, 0, 2660, 2656, 1, 0, 0, 0, 2660, 2657, 1, 0, 0, 0, 2660, 2658, 1, 0, 0, 0, 2660, 2659, 1, 0, 0, 0, 2661, 249, 1, 0, 0, 0, 2662, 2664, 5, 300, 0, 0, 2663, 2665, 5, 157, 0, 0, 2664, 2663, 1, 0, 0, 0, 2664, 2665, 1, 0, 0, 0, 2665, 2666, 1, 0, 0, 0, 2666, 2667, 3, 112, 56, 0, 2667, 251, 1, 0, 0, 0, 2668, 2669, 5, 301, 0, 0, 2669, 2670, 5, 42, 0, 0, 2670, 2671, 3, 32, 16, 0, 2671, 2674, 5, 43, 0, 0, 2672, 2673, 5, 34, 0, 0, 2673, 2675, 3, 0, 0, 0, 2674, 2672, 1, 0, 0, 0, 2674, 2675, 1, 0, 0, 0, 2675, 253, 1, 0, 0, 0, 2676, 2677, 5, 303, 0, 0, 2677, 2678, 3, 32, 16, 0, 2678, 2679, 5, 75, 0, 0, 2679, 2680, 3, 32, 16, 0, 2680, 255, 1, 0, 0, 0, 2681, 2682, 5, 302, 0, 0, 2682, 2683, 3, 124, 62, 0, 2683, 2684, 5, 176, 0, 0, 2684, 2685, 3, 242, 121, 0, 2685, 2697, 1, 0, 0, 0, 2686, 2687, 5, 302, 0, 0, 2687, 2688, 5, 226, 0, 0, 2688, 2689, 3, 170, 85, 0, 2689, 2690, 3, 138, 69, 0, 2690, 2691, 3, 124, 62, 0, 2691, 2692, 5, 176, 0, 0, 2692, 2693, 3, 242, 121, 0, 2693, 2694, 3, 194, 97, 0, 2694, 2695, 3, 112, 56, 0, 2695, 2697, 1, 0, 0, 0, 2696, 2681, 1, 0, 0, 0, 2696, 2686, 1, 0, 0, 0, 2697, 257, 1, 0, 0, 0, 2698, 2699, 5, 255, 0, 0, 2699, 2700, 5, 196, 0, 0, 2700, 2701, 5, 42, 0, 0, 2701, 2702, 3, 32, 16, 0, 2702, 2708, 5, 43, 0, 0, 2703, 2704, 3, 330, 165, 0, 2704, 2705, 6, 129, -1, 0, 2705, 2707, 1, 0, 0, 0, 2706, 2703, 1, 0, 0, 0, 2707, 2710, 1, 0, 0, 0, 2708, 2706, 1, 0, 0, 0, 2708, 2709, 1, 0, 0, 0, 2709, 2764, 1, 0, 0, 0, 2710, 2708, 1, 0, 0, 0, 2711, 2712, 5, 255, 0, 0, 2712, 2713, 5, 196, 0, 0, 2713, 2719, 3, 2, 1, 0, 2714, 2715, 3, 330, 165, 0, 2715, 2716, 6, 129, -1, 0, 2716, 2718, 1, 0, 0, 0, 2717, 2714, 1, 0, 0, 0, 2718, 2721, 1, 0, 0, 0, 2719, 2717, 1, 0, 0, 0, 2719, 2720, 1, 0, 0, 0, 2720, 2764, 1, 0, 0, 0, 2721, 2719, 1, 0, 0, 0, 2722, 2723, 5, 255, 0, 0, 2723, 2724, 5, 256, 0, 0, 2724, 2725, 5, 42, 0, 0, 2725, 2726, 3, 32, 16, 0, 2726, 2727, 5, 43, 0, 0, 2727, 2728, 5, 28, 0, 0, 2728, 2734, 3, 124, 62, 0, 2729, 2730, 3, 330, 165, 0, 2730, 2731, 6, 129, -1, 0, 2731, 2733, 1, 0, 0, 0, 2732, 2729, 1, 0, 0, 0, 2733, 2736, 1, 0, 0, 0, 2734, 2732, 1, 0, 0, 0, 2734, 2735, 1, 0, 0, 0, 2735, 2764, 1, 0, 0, 0, 2736, 2734, 1, 0, 0, 0, 2737, 2738, 5, 255, 0, 0, 2738, 2739, 5, 256, 0, 0, 2739, 2740, 3, 2, 1, 0, 2740, 2741, 5, 28, 0, 0, 2741, 2747, 3, 124, 62, 0, 2742, 2743, 3, 330, 165, 0, 2743, 2744, 6, 129, -1, 0, 2744, 2746, 1, 0, 0, 0, 2745, 2742, 1, 0, 0, 0, 2746, 2749, 1, 0, 0, 0, 2747, 2745, 1, 0, 0, 0, 2747, 2748, 1, 0, 0, 0, 2748, 2764, 1, 0, 0, 0, 2749, 2747, 1, 0, 0, 0, 2750, 2751, 5, 255, 0, 0, 2751, 2752, 5, 42, 0, 0, 2752, 2753, 3, 32, 16, 0, 2753, 2754, 5, 43, 0, 0, 2754, 2760, 3, 206, 103, 0, 2755, 2756, 3, 330, 165, 0, 2756, 2757, 6, 129, -1, 0, 2757, 2759, 1, 0, 0, 0, 2758, 2755, 1, 0, 0, 0, 2759, 2762, 1, 0, 0, 0, 2760, 2758, 1, 0, 0, 0, 2760, 2761, 1, 0, 0, 0, 2761, 2764, 1, 0, 0, 0, 2762, 2760, 1, 0, 0, 0, 2763, 2698, 1, 0, 0, 0, 2763, 2711, 1, 0, 0, 0, 2763, 2722, 1, 0, 0, 0, 2763, 2737, 1, 0, 0, 0, 2763, 2750, 1, 0, 0, 0, 2764, 259, 1, 0, 0, 0, 2765, 2766, 3, 0, 0, 0, 2766, 2767, 5, 75, 0, 0, 2767, 2768, 6, 130, -1, 0, 2768, 261, 1, 0, 0, 0, 2769, 2772, 3, 44, 22, 0, 2770, 2772, 3, 46, 23, 0, 2771, 2769, 1, 0, 0, 0, 2771, 2770, 1, 0, 0, 0, 2772, 263, 1, 0, 0, 0, 2773, 2774, 5, 17, 0, 0, 2774, 2775, 3, 246, 123, 0, 2775, 2776, 5, 18, 0, 0, 2776, 265, 1, 0, 0, 0, 2777, 2778, 3, 270, 135, 0, 2778, 2779, 3, 268, 134, 0, 2779, 267, 1, 0, 0, 0, 2780, 2781, 3, 272, 136, 0, 2781, 2782, 6, 134, -1, 0, 2782, 2784, 1, 0, 0, 0, 2783, 2780, 1, 0, 0, 0, 2784, 2785, 1, 0, 0, 0, 2785, 2783, 1, 0, 0, 0, 2785, 2786, 1, 0, 0, 0, 2786, 269, 1, 0, 0, 0, 2787, 2788, 5, 158, 0, 0, 2788, 2789, 3, 264, 132, 0, 2789, 2790, 6, 135, -1, 0, 2790, 2804, 1, 0, 0, 0, 2791, 2792, 5, 158, 0, 0, 2792, 2793, 3, 0, 0, 0, 2793, 2794, 5, 159, 0, 0, 2794, 2795, 3, 0, 0, 0, 2795, 2796, 6, 135, -1, 0, 2796, 2804, 1, 0, 0, 0, 2797, 2798, 5, 158, 0, 0, 2798, 2799, 3, 32, 16, 0, 2799, 2800, 5, 159, 0, 0, 2800, 2801, 3, 32, 16, 0, 2801, 2802, 6, 135, -1, 0, 2802, 2804, 1, 0, 0, 0, 2803, 2787, 1, 0, 0, 0, 2803, 2791, 1, 0, 0, 0, 2803, 2797, 1, 0, 0, 0, 2804, 271, 1, 0, 0, 0, 2805, 2806, 3, 276, 138, 0, 2806, 2807, 3, 282, 141, 0, 2807, 2808, 6, 136, -1, 0, 2808, 2822, 1, 0, 0, 0, 2809, 2810, 3, 274, 137, 0, 2810, 2811, 3, 282, 141, 0, 2811, 2812, 6, 136, -1, 0, 2812, 2822, 1, 0, 0, 0, 2813, 2814, 3, 278, 139, 0, 2814, 2815, 3, 282, 141, 0, 2815, 2816, 6, 136, -1, 0, 2816, 2822, 1, 0, 0, 0, 2817, 2818, 3, 280, 140, 0, 2818, 2819, 3, 282, 141, 0, 2819, 2820, 6, 136, -1, 0, 2820, 2822, 1, 0, 0, 0, 2821, 2805, 1, 0, 0, 0, 2821, 2809, 1, 0, 0, 0, 2821, 2813, 1, 0, 0, 0, 2821, 2817, 1, 0, 0, 0, 2822, 273, 1, 0, 0, 0, 2823, 2824, 5, 160, 0, 0, 2824, 2825, 3, 264, 132, 0, 2825, 2826, 6, 137, -1, 0, 2826, 2836, 1, 0, 0, 0, 2827, 2828, 5, 160, 0, 0, 2828, 2829, 3, 0, 0, 0, 2829, 2830, 6, 137, -1, 0, 2830, 2836, 1, 0, 0, 0, 2831, 2832, 5, 160, 0, 0, 2832, 2833, 3, 32, 16, 0, 2833, 2834, 6, 137, -1, 0, 2834, 2836, 1, 0, 0, 0, 2835, 2823, 1, 0, 0, 0, 2835, 2827, 1, 0, 0, 0, 2835, 2831, 1, 0, 0, 0, 2836, 275, 1, 0, 0, 0, 2837, 2838, 5, 161, 0, 0, 2838, 2839, 3, 124, 62, 0, 2839, 277, 1, 0, 0, 0, 2840, 2841, 5, 162, 0, 0, 2841, 279, 1, 0, 0, 0, 2842, 2843, 5, 163, 0, 0, 2843, 281, 1, 0, 0, 0, 2844, 2845, 3, 264, 132, 0, 2845, 2846, 6, 141, -1, 0, 2846, 2860, 1, 0, 0, 0, 2847, 2848, 5, 164, 0, 0, 2848, 2849, 3, 0, 0, 0, 2849, 2850, 5, 159, 0, 0, 2850, 2851, 3, 0, 0, 0, 2851, 2852, 6, 141, -1, 0, 2852, 2860, 1, 0, 0, 0, 2853, 2854, 5, 164, 0, 0, 2854, 2855, 3, 32, 16, 0, 2855, 2856, 5, 159, 0, 0, 2856, 2857, 3, 32, 16, 0, 2857, 2858, 6, 141, -1, 0, 2858, 2860, 1, 0, 0, 0, 2859, 2844, 1, 0, 0, 0, 2859, 2847, 1, 0, 0, 0, 2859, 2853, 1, 0, 0, 0, 2860, 283, 1, 0, 0, 0, 2861, 2862, 3, 286, 143, 0, 2862, 2863, 3, 290, 145, 0, 2863, 285, 1, 0, 0, 0, 2864, 2865, 5, 165, 0, 0, 2865, 2866, 3, 288, 144, 0, 2866, 2867, 3, 0, 0, 0, 2867, 2868, 5, 36, 0, 0, 2868, 2872, 1, 0, 0, 0, 2869, 2870, 5, 165, 0, 0, 2870, 2872, 3, 288, 144, 0, 2871, 2864, 1, 0, 0, 0, 2871, 2869, 1, 0, 0, 0, 2872, 287, 1, 0, 0, 0, 2873, 2877, 1, 0, 0, 0, 2874, 2877, 5, 166, 0, 0, 2875, 2877, 5, 2, 0, 0, 2876, 2873, 1, 0, 0, 0, 2876, 2874, 1, 0, 0, 0, 2876, 2875, 1, 0, 0, 0, 2877, 289, 1, 0, 0, 0, 2878, 2879, 5, 17, 0, 0, 2879, 2880, 3, 292, 146, 0, 2880, 2881, 5, 18, 0, 0, 2881, 2888, 1, 0, 0, 0, 2882, 2884, 3, 296, 148, 0, 2883, 2882, 1, 0, 0, 0, 2884, 2885, 1, 0, 0, 0, 2885, 2883, 1, 0, 0, 0, 2885, 2886, 1, 0, 0, 0, 2886, 2888, 1, 0, 0, 0, 2887, 2878, 1, 0, 0, 0, 2887, 2883, 1, 0, 0, 0, 2888, 291, 1, 0, 0, 0, 2889, 2890, 3, 296, 148, 0, 2890, 2891, 5, 28, 0, 0, 2891, 2893, 1, 0, 0, 0, 2892, 2889, 1, 0, 0, 0, 2893, 2896, 1, 0, 0, 0, 2894, 2892, 1, 0, 0, 0, 2894, 2895, 1, 0, 0, 0, 2895, 2897, 1, 0, 0, 0, 2896, 2894, 1, 0, 0, 0, 2897, 2898, 3, 296, 148, 0, 2898, 293, 1, 0, 0, 0, 2899, 2905, 1, 0, 0, 0, 2900, 2901, 5, 42, 0, 0, 2901, 2902, 3, 32, 16, 0, 2902, 2903, 5, 43, 0, 0, 2903, 2905, 1, 0, 0, 0, 2904, 2899, 1, 0, 0, 0, 2904, 2900, 1, 0, 0, 0, 2905, 295, 1, 0, 0, 0, 2906, 2907, 5, 181, 0, 0, 2907, 2908, 5, 262, 0, 0, 2908, 2909, 5, 30, 0, 0, 2909, 2910, 3, 6, 3, 0, 2910, 2911, 5, 31, 0, 0, 2911, 2973, 1, 0, 0, 0, 2912, 2913, 5, 260, 0, 0, 2913, 2914, 5, 30, 0, 0, 2914, 2915, 3, 0, 0, 0, 2915, 2916, 5, 31, 0, 0, 2916, 2973, 1, 0, 0, 0, 2917, 2918, 5, 260, 0, 0, 2918, 2973, 3, 0, 0, 0, 2919, 2920, 5, 84, 0, 0, 2920, 2921, 5, 30, 0, 0, 2921, 2922, 3, 300, 150, 0, 2922, 2923, 5, 31, 0, 0, 2923, 2973, 1, 0, 0, 0, 2924, 2925, 5, 188, 0, 0, 2925, 2926, 5, 30, 0, 0, 2926, 2927, 3, 36, 18, 0, 2927, 2928, 5, 31, 0, 0, 2928, 2929, 3, 294, 147, 0, 2929, 2973, 1, 0, 0, 0, 2930, 2931, 5, 189, 0, 0, 2931, 2932, 5, 30, 0, 0, 2932, 2933, 3, 36, 18, 0, 2933, 2934, 5, 31, 0, 0, 2934, 2935, 3, 294, 147, 0, 2935, 2973, 1, 0, 0, 0, 2936, 2937, 5, 187, 0, 0, 2937, 2938, 5, 30, 0, 0, 2938, 2939, 3, 34, 17, 0, 2939, 2940, 5, 31, 0, 0, 2940, 2941, 3, 294, 147, 0, 2941, 2973, 1, 0, 0, 0, 2942, 2943, 5, 186, 0, 0, 2943, 2944, 5, 30, 0, 0, 2944, 2945, 3, 32, 16, 0, 2945, 2946, 5, 31, 0, 0, 2946, 2947, 3, 294, 147, 0, 2947, 2973, 1, 0, 0, 0, 2948, 2949, 5, 185, 0, 0, 2949, 2950, 5, 30, 0, 0, 2950, 2951, 3, 32, 16, 0, 2951, 2952, 5, 31, 0, 0, 2952, 2953, 3, 294, 147, 0, 2953, 2973, 1, 0, 0, 0, 2954, 2955, 5, 184, 0, 0, 2955, 2956, 5, 30, 0, 0, 2956, 2957, 3, 32, 16, 0, 2957, 2958, 5, 31, 0, 0, 2958, 2959, 3, 294, 147, 0, 2959, 2973, 1, 0, 0, 0, 2960, 2961, 5, 188, 0, 0, 2961, 2973, 3, 294, 147, 0, 2962, 2963, 5, 189, 0, 0, 2963, 2973, 3, 294, 147, 0, 2964, 2965, 5, 187, 0, 0, 2965, 2973, 3, 294, 147, 0, 2966, 2967, 5, 186, 0, 0, 2967, 2973, 3, 294, 147, 0, 2968, 2969, 5, 185, 0, 0, 2969, 2973, 3, 294, 147, 0, 2970, 2971, 5, 184, 0, 0, 2971, 2973, 3, 294, 147, 0, 2972, 2906, 1, 0, 0, 0, 2972, 2912, 1, 0, 0, 0, 2972, 2917, 1, 0, 0, 0, 2972, 2919, 1, 0, 0, 0, 2972, 2924, 1, 0, 0, 0, 2972, 2930, 1, 0, 0, 0, 2972, 2936, 1, 0, 0, 0, 2972, 2942, 1, 0, 0, 0, 2972, 2948, 1, 0, 0, 0, 2972, 2954, 1, 0, 0, 0, 2972, 2960, 1, 0, 0, 0, 2972, 2962, 1, 0, 0, 0, 2972, 2964, 1, 0, 0, 0, 2972, 2966, 1, 0, 0, 0, 2972, 2968, 1, 0, 0, 0, 2972, 2970, 1, 0, 0, 0, 2973, 297, 1, 0, 0, 0, 2974, 2975, 5, 188, 0, 0, 2975, 2976, 5, 30, 0, 0, 2976, 2977, 3, 36, 18, 0, 2977, 2978, 5, 31, 0, 0, 2978, 3050, 1, 0, 0, 0, 2979, 2980, 5, 189, 0, 0, 2980, 2981, 5, 30, 0, 0, 2981, 2982, 3, 36, 18, 0, 2982, 2983, 5, 31, 0, 0, 2983, 3050, 1, 0, 0, 0, 2984, 2985, 5, 188, 0, 0, 2985, 2986, 5, 30, 0, 0, 2986, 2987, 3, 32, 16, 0, 2987, 2988, 5, 31, 0, 0, 2988, 3050, 1, 0, 0, 0, 2989, 2990, 5, 189, 0, 0, 2990, 2991, 5, 30, 0, 0, 2991, 2992, 3, 34, 17, 0, 2992, 2993, 5, 31, 0, 0, 2993, 3050, 1, 0, 0, 0, 2994, 2995, 5, 187, 0, 0, 2995, 2996, 5, 30, 0, 0, 2996, 2997, 3, 34, 17, 0, 2997, 2998, 5, 31, 0, 0, 2998, 3050, 1, 0, 0, 0, 2999, 3000, 5, 186, 0, 0, 3000, 3001, 5, 30, 0, 0, 3001, 3002, 3, 32, 16, 0, 3002, 3003, 5, 31, 0, 0, 3003, 3050, 1, 0, 0, 0, 3004, 3005, 5, 185, 0, 0, 3005, 3006, 5, 30, 0, 0, 3006, 3007, 3, 32, 16, 0, 3007, 3008, 5, 31, 0, 0, 3008, 3050, 1, 0, 0, 0, 3009, 3010, 5, 184, 0, 0, 3010, 3011, 5, 30, 0, 0, 3011, 3012, 3, 32, 16, 0, 3012, 3013, 5, 31, 0, 0, 3013, 3050, 1, 0, 0, 0, 3014, 3015, 5, 193, 0, 0, 3015, 3016, 5, 30, 0, 0, 3016, 3017, 3, 34, 17, 0, 3017, 3018, 5, 31, 0, 0, 3018, 3050, 1, 0, 0, 0, 3019, 3020, 5, 192, 0, 0, 3020, 3021, 5, 30, 0, 0, 3021, 3022, 3, 32, 16, 0, 3022, 3023, 5, 31, 0, 0, 3023, 3050, 1, 0, 0, 0, 3024, 3025, 5, 191, 0, 0, 3025, 3026, 5, 30, 0, 0, 3026, 3027, 3, 32, 16, 0, 3027, 3028, 5, 31, 0, 0, 3028, 3050, 1, 0, 0, 0, 3029, 3030, 5, 190, 0, 0, 3030, 3031, 5, 30, 0, 0, 3031, 3032, 3, 32, 16, 0, 3032, 3033, 5, 31, 0, 0, 3033, 3050, 1, 0, 0, 0, 3034, 3035, 5, 181, 0, 0, 3035, 3036, 5, 30, 0, 0, 3036, 3037, 3, 32, 16, 0, 3037, 3038, 5, 31, 0, 0, 3038, 3050, 1, 0, 0, 0, 3039, 3040, 5, 183, 0, 0, 3040, 3041, 5, 30, 0, 0, 3041, 3042, 3, 162, 81, 0, 3042, 3043, 5, 31, 0, 0, 3043, 3050, 1, 0, 0, 0, 3044, 3045, 5, 84, 0, 0, 3045, 3046, 5, 30, 0, 0, 3046, 3047, 3, 300, 150, 0, 3047, 3048, 5, 31, 0, 0, 3048, 3050, 1, 0, 0, 0, 3049, 2974, 1, 0, 0, 0, 3049, 2979, 1, 0, 0, 0, 3049, 2984, 1, 0, 0, 0, 3049, 2989, 1, 0, 0, 0, 3049, 2994, 1, 0, 0, 0, 3049, 2999, 1, 0, 0, 0, 3049, 3004, 1, 0, 0, 0, 3049, 3009, 1, 0, 0, 0, 3049, 3014, 1, 0, 0, 0, 3049, 3019, 1, 0, 0, 0, 3049, 3024, 1, 0, 0, 0, 3049, 3029, 1, 0, 0, 0, 3049, 3034, 1, 0, 0, 0, 3049, 3039, 1, 0, 0, 0, 3049, 3044, 1, 0, 0, 0, 3050, 299, 1, 0, 0, 0, 3051, 3052, 3, 302, 151, 0, 3052, 3053, 6, 150, -1, 0, 3053, 3055, 1, 0, 0, 0, 3054, 3051, 1, 0, 0, 0, 3055, 3058, 1, 0, 0, 0, 3056, 3054, 1, 0, 0, 0, 3056, 3057, 1, 0, 0, 0, 3057, 301, 1, 0, 0, 0, 3058, 3056, 1, 0, 0, 0, 3059, 3060, 7, 10, 0, 0, 3060, 303, 1, 0, 0, 0, 3061, 3065, 3, 298, 149, 0, 3062, 3065, 3, 6, 3, 0, 3063, 3065, 5, 179, 0, 0, 3064, 3061, 1, 0, 0, 0, 3064, 3062, 1, 0, 0, 0, 3064, 3063, 1, 0, 0, 0, 3065, 305, 1, 0, 0, 0, 3066, 3215, 3, 298, 149, 0, 3067, 3068, 5, 182, 0, 0, 3068, 3069, 5, 30, 0, 0, 3069, 3070, 5, 179, 0, 0, 3070, 3215, 5, 31, 0, 0, 3071, 3072, 5, 182, 0, 0, 3072, 3073, 5, 30, 0, 0, 3073, 3074, 5, 264, 0, 0, 3074, 3215, 5, 31, 0, 0, 3075, 3076, 5, 196, 0, 0, 3076, 3077, 5, 30, 0, 0, 3077, 3078, 5, 39, 0, 0, 3078, 3079, 5, 264, 0, 0, 3079, 3215, 5, 31, 0, 0, 3080, 3081, 5, 196, 0, 0, 3081, 3082, 5, 30, 0, 0, 3082, 3083, 3, 116, 58, 0, 3083, 3084, 5, 31, 0, 0, 3084, 3215, 1, 0, 0, 0, 3085, 3086, 5, 196, 0, 0, 3086, 3087, 5, 30, 0, 0, 3087, 3088, 5, 179, 0, 0, 3088, 3215, 5, 31, 0, 0, 3089, 3090, 5, 197, 0, 0, 3090, 3091, 5, 30, 0, 0, 3091, 3092, 3, 306, 153, 0, 3092, 3093, 5, 31, 0, 0, 3093, 3215, 1, 0, 0, 0, 3094, 3095, 5, 188, 0, 0, 3095, 3096, 5, 42, 0, 0, 3096, 3097, 3, 32, 16, 0, 3097, 3098, 5, 43, 0, 0, 3098, 3099, 5, 30, 0, 0, 3099, 3100, 3, 308, 154, 0, 3100, 3101, 5, 31, 0, 0, 3101, 3215, 1, 0, 0, 0, 3102, 3103, 5, 189, 0, 0, 3103, 3104, 5, 42, 0, 0, 3104, 3105, 3, 32, 16, 0, 3105, 3106, 5, 43, 0, 0, 3106, 3107, 5, 30, 0, 0, 3107, 3108, 3, 310, 155, 0, 3108, 3109, 5, 31, 0, 0, 3109, 3215, 1, 0, 0, 0, 3110, 3111, 5, 187, 0, 0, 3111, 3112, 5, 42, 0, 0, 3112, 3113, 3, 32, 16, 0, 3113, 3114, 5, 43, 0, 0, 3114, 3115, 5, 30, 0, 0, 3115, 3116, 3, 312, 156, 0, 3116, 3117, 5, 31, 0, 0, 3117, 3215, 1, 0, 0, 0, 3118, 3119, 5, 186, 0, 0, 3119, 3120, 5, 42, 0, 0, 3120, 3121, 3, 32, 16, 0, 3121, 3122, 5, 43, 0, 0, 3122, 3123, 5, 30, 0, 0, 3123, 3124, 3, 314, 157, 0, 3124, 3125, 5, 31, 0, 0, 3125, 3215, 1, 0, 0, 0, 3126, 3127, 5, 185, 0, 0, 3127, 3128, 5, 42, 0, 0, 3128, 3129, 3, 32, 16, 0, 3129, 3130, 5, 43, 0, 0, 3130, 3131, 5, 30, 0, 0, 3131, 3132, 3, 316, 158, 0, 3132, 3133, 5, 31, 0, 0, 3133, 3215, 1, 0, 0, 0, 3134, 3135, 5, 184, 0, 0, 3135, 3136, 5, 42, 0, 0, 3136, 3137, 3, 32, 16, 0, 3137, 3138, 5, 43, 0, 0, 3138, 3139, 5, 30, 0, 0, 3139, 3140, 3, 318, 159, 0, 3140, 3141, 5, 31, 0, 0, 3141, 3215, 1, 0, 0, 0, 3142, 3143, 5, 193, 0, 0, 3143, 3144, 5, 42, 0, 0, 3144, 3145, 3, 32, 16, 0, 3145, 3146, 5, 43, 0, 0, 3146, 3147, 5, 30, 0, 0, 3147, 3148, 3, 312, 156, 0, 3148, 3149, 5, 31, 0, 0, 3149, 3215, 1, 0, 0, 0, 3150, 3151, 5, 192, 0, 0, 3151, 3152, 5, 42, 0, 0, 3152, 3153, 3, 32, 16, 0, 3153, 3154, 5, 43, 0, 0, 3154, 3155, 5, 30, 0, 0, 3155, 3156, 3, 314, 157, 0, 3156, 3157, 5, 31, 0, 0, 3157, 3215, 1, 0, 0, 0, 3158, 3159, 5, 191, 0, 0, 3159, 3160, 5, 42, 0, 0, 3160, 3161, 3, 32, 16, 0, 3161, 3162, 5, 43, 0, 0, 3162, 3163, 5, 30, 0, 0, 3163, 3164, 3, 316, 158, 0, 3164, 3165, 5, 31, 0, 0, 3165, 3215, 1, 0, 0, 0, 3166, 3167, 5, 190, 0, 0, 3167, 3168, 5, 42, 0, 0, 3168, 3169, 3, 32, 16, 0, 3169, 3170, 5, 43, 0, 0, 3170, 3171, 5, 30, 0, 0, 3171, 3172, 3, 318, 159, 0, 3172, 3173, 5, 31, 0, 0, 3173, 3215, 1, 0, 0, 0, 3174, 3175, 5, 181, 0, 0, 3175, 3176, 5, 42, 0, 0, 3176, 3177, 3, 32, 16, 0, 3177, 3178, 5, 43, 0, 0, 3178, 3179, 5, 30, 0, 0, 3179, 3180, 3, 316, 158, 0, 3180, 3181, 5, 31, 0, 0, 3181, 3215, 1, 0, 0, 0, 3182, 3183, 5, 183, 0, 0, 3183, 3184, 5, 42, 0, 0, 3184, 3185, 3, 32, 16, 0, 3185, 3186, 5, 43, 0, 0, 3186, 3187, 5, 30, 0, 0, 3187, 3188, 3, 320, 160, 0, 3188, 3189, 5, 31, 0, 0, 3189, 3215, 1, 0, 0, 0, 3190, 3191, 5, 182, 0, 0, 3191, 3192, 5, 42, 0, 0, 3192, 3193, 3, 32, 16, 0, 3193, 3194, 5, 43, 0, 0, 3194, 3195, 5, 30, 0, 0, 3195, 3196, 3, 322, 161, 0, 3196, 3197, 5, 31, 0, 0, 3197, 3215, 1, 0, 0, 0, 3198, 3199, 5, 196, 0, 0, 3199, 3200, 5, 42, 0, 0, 3200, 3201, 3, 32, 16, 0, 3201, 3202, 5, 43, 0, 0, 3202, 3203, 5, 30, 0, 0, 3203, 3204, 3, 324, 162, 0, 3204, 3205, 5, 31, 0, 0, 3205, 3215, 1, 0, 0, 0, 3206, 3207, 5, 197, 0, 0, 3207, 3208, 5, 42, 0, 0, 3208, 3209, 3, 32, 16, 0, 3209, 3210, 5, 43, 0, 0, 3210, 3211, 5, 30, 0, 0, 3211, 3212, 3, 328, 164, 0, 3212, 3213, 5, 31, 0, 0, 3213, 3215, 1, 0, 0, 0, 3214, 3066, 1, 0, 0, 0, 3214, 3067, 1, 0, 0, 0, 3214, 3071, 1, 0, 0, 0, 3214, 3075, 1, 0, 0, 0, 3214, 3080, 1, 0, 0, 0, 3214, 3085, 1, 0, 0, 0, 3214, 3089, 1, 0, 0, 0, 3214, 3094, 1, 0, 0, 0, 3214, 3102, 1, 0, 0, 0, 3214, 3110, 1, 0, 0, 0, 3214, 3118, 1, 0, 0, 0, 3214, 3126, 1, 0, 0, 0, 3214, 3134, 1, 0, 0, 0, 3214, 3142, 1, 0, 0, 0, 3214, 3150, 1, 0, 0, 0, 3214, 3158, 1, 0, 0, 0, 3214, 3166, 1, 0, 0, 0, 3214, 3174, 1, 0, 0, 0, 3214, 3182, 1, 0, 0, 0, 3214, 3190, 1, 0, 0, 0, 3214, 3198, 1, 0, 0, 0, 3214, 3206, 1, 0, 0, 0, 3215, 307, 1, 0, 0, 0, 3216, 3219, 3, 36, 18, 0, 3217, 3219, 3, 32, 16, 0, 3218, 3216, 1, 0, 0, 0, 3218, 3217, 1, 0, 0, 0, 3219, 3222, 1, 0, 0, 0, 3220, 3218, 1, 0, 0, 0, 3220, 3221, 1, 0, 0, 0, 3221, 309, 1, 0, 0, 0, 3222, 3220, 1, 0, 0, 0, 3223, 3226, 3, 36, 18, 0, 3224, 3226, 3, 34, 17, 0, 3225, 3223, 1, 0, 0, 0, 3225, 3224, 1, 0, 0, 0, 3226, 3229, 1, 0, 0, 0, 3227, 3225, 1, 0, 0, 0, 3227, 3228, 1, 0, 0, 0, 3228, 311, 1, 0, 0, 0, 3229, 3227, 1, 0, 0, 0, 3230, 3232, 3, 34, 17, 0, 3231, 3230, 1, 0, 0, 0, 3232, 3235, 1, 0, 0, 0, 3233, 3231, 1, 0, 0, 0, 3233, 3234, 1, 0, 0, 0, 3234, 313, 1, 0, 0, 0, 3235, 3233, 1, 0, 0, 0, 3236, 3238, 3, 32, 16, 0, 3237, 3236, 1, 0, 0, 0, 3238, 3241, 1, 0, 0, 0, 3239, 3237, 1, 0, 0, 0, 3239, 3240, 1, 0, 0, 0, 3240, 315, 1, 0, 0, 0, 3241, 3239, 1, 0, 0, 0, 3242, 3244, 3, 32, 16, 0, 3243, 3242, 1, 0, 0, 0, 3244, 3247, 1, 0, 0, 0, 3245, 3243, 1, 0, 0, 0, 3245, 3246, 1, 0, 0, 0, 3246, 317, 1, 0, 0, 0, 3247, 3245, 1, 0, 0, 0, 3248, 3250, 3, 32, 16, 0, 3249, 3248, 1, 0, 0, 0, 3250, 3253, 1, 0, 0, 0, 3251, 3249, 1, 0, 0, 0, 3251, 3252, 1, 0, 0, 0, 3252, 319, 1, 0, 0, 0, 3253, 3251, 1, 0, 0, 0, 3254, 3256, 3, 162, 81, 0, 3255, 3254, 1, 0, 0, 0, 3256, 3259, 1, 0, 0, 0, 3257, 3255, 1, 0, 0, 0, 3257, 3258, 1, 0, 0, 0, 3258, 321, 1, 0, 0, 0, 3259, 3257, 1, 0, 0, 0, 3260, 3262, 7, 11, 0, 0, 3261, 3260, 1, 0, 0, 0, 3262, 3265, 1, 0, 0, 0, 3263, 3261, 1, 0, 0, 0, 3263, 3264, 1, 0, 0, 0, 3264, 323, 1, 0, 0, 0, 3265, 3263, 1, 0, 0, 0, 3266, 3268, 3, 326, 163, 0, 3267, 3266, 1, 0, 0, 0, 3268, 3271, 1, 0, 0, 0, 3269, 3267, 1, 0, 0, 0, 3269, 3270, 1, 0, 0, 0, 3270, 325, 1, 0, 0, 0, 3271, 3269, 1, 0, 0, 0, 3272, 3277, 5, 179, 0, 0, 3273, 3274, 5, 39, 0, 0, 3274, 3277, 5, 264, 0, 0, 3275, 3277, 3, 116, 58, 0, 3276, 3272, 1, 0, 0, 0, 3276, 3273, 1, 0, 0, 0, 3276, 3275, 1, 0, 0, 0, 3277, 327, 1, 0, 0, 0, 3278, 3280, 3, 306, 153, 0, 3279, 3278, 1, 0, 0, 0, 3280, 3283, 1, 0, 0, 0, 3281, 3279, 1, 0, 0, 0, 3281, 3282, 1, 0, 0, 0, 3282, 329, 1, 0, 0, 0, 3283, 3281, 1, 0, 0, 0, 3284, 3288, 3, 44, 22, 0, 3285, 3288, 3, 46, 23, 0, 3286, 3288, 3, 2, 1, 0, 3287, 3284, 1, 0, 0, 0, 3287, 3285, 1, 0, 0, 0, 3287, 3286, 1, 0, 0, 0, 3288, 331, 1, 0, 0, 0, 3289, 3290, 7, 12, 0, 0, 3290, 3291, 5, 36, 0, 0, 3291, 3292, 5, 30, 0, 0, 3292, 3293, 3, 300, 150, 0, 3293, 3294, 5, 31, 0, 0, 3294, 3315, 1, 0, 0, 0, 3295, 3296, 5, 169, 0, 0, 3296, 3297, 3, 38, 19, 0, 3297, 3298, 5, 75, 0, 0, 3298, 3299, 3, 38, 19, 0, 3299, 3300, 5, 75, 0, 0, 3300, 3301, 3, 38, 19, 0, 3301, 3302, 5, 75, 0, 0, 3302, 3303, 3, 38, 19, 0, 3303, 3315, 1, 0, 0, 0, 3304, 3305, 5, 170, 0, 0, 3305, 3315, 3, 6, 3, 0, 3306, 3307, 5, 170, 0, 0, 3307, 3308, 5, 36, 0, 0, 3308, 3309, 5, 30, 0, 0, 3309, 3310, 3, 300, 150, 0, 3310, 3311, 5, 31, 0, 0, 3311, 3315, 1, 0, 0, 0, 3312, 3315, 3, 330, 165, 0, 3313, 3315, 3, 40, 20, 0, 3314, 3289, 1, 0, 0, 0, 3314, 3295, 1, 0, 0, 0, 3314, 3304, 1, 0, 0, 0, 3314, 3306, 1, 0, 0, 0, 3314, 3312, 1, 0, 0, 0, 3314, 3313, 1, 0, 0, 0, 3315, 333, 1, 0, 0, 0, 3316, 3317, 5, 25, 0, 0, 3317, 3318, 5, 40, 0, 0, 3318, 3319, 3, 98, 49, 0, 3319, 3320, 3, 2, 1, 0, 3320, 3329, 1, 0, 0, 0, 3321, 3322, 5, 25, 0, 0, 3322, 3323, 5, 40, 0, 0, 3323, 3324, 3, 98, 49, 0, 3324, 3325, 3, 2, 1, 0, 3325, 3326, 5, 34, 0, 0, 3326, 3327, 3, 2, 1, 0, 3327, 3329, 1, 0, 0, 0, 3328, 3316, 1, 0, 0, 0, 3328, 3321, 1, 0, 0, 0, 3329, 335, 1, 0, 0, 0, 3330, 3332, 3, 338, 169, 0, 3331, 3330, 1, 0, 0, 0, 3332, 3335, 1, 0, 0, 0, 3333, 3331, 1, 0, 0, 0, 3333, 3334, 1, 0, 0, 0, 3334, 337, 1, 0, 0, 0, 3335, 3333, 1, 0, 0, 0, 3336, 3337, 5, 180, 0, 0, 3337, 3338, 5, 36, 0, 0, 3338, 3339, 5, 30, 0, 0, 3339, 3340, 3, 300, 150, 0, 3340, 3341, 5, 31, 0, 0, 3341, 3351, 1, 0, 0, 0, 3342, 3351, 3, 332, 166, 0, 3343, 3344, 5, 171, 0, 0, 3344, 3345, 5, 36, 0, 0, 3345, 3346, 5, 30, 0, 0, 3346, 3347, 3, 300, 150, 0, 3347, 3348, 5, 31, 0, 0, 3348, 3351, 1, 0, 0, 0, 3349, 3351, 5, 55, 0, 0, 3350, 3336, 1, 0, 0, 0, 3350, 3342, 1, 0, 0, 0, 3350, 3343, 1, 0, 0, 0, 3350, 3349, 1, 0, 0, 0, 3351, 339, 1, 0, 0, 0, 3352, 3353, 5, 50, 0, 0, 3353, 3357, 5, 40, 0, 0, 3354, 3356, 3, 344, 172, 0, 3355, 3354, 1, 0, 0, 0, 3356, 3359, 1, 0, 0, 0, 3357, 3355, 1, 0, 0, 0, 3357, 3358, 1, 0, 0, 0, 3358, 3360, 1, 0, 0, 0, 3359, 3357, 1, 0, 0, 0, 3360, 3361, 3, 2, 1, 0, 3361, 341, 1, 0, 0, 0, 3362, 3366, 5, 301, 0, 0, 3363, 3365, 3, 344, 172, 0, 3364, 3363, 1, 0, 0, 0, 3365, 3368, 1, 0, 0, 0, 3366, 3364, 1, 0, 0, 0, 3366, 3367, 1, 0, 0, 0, 3367, 3369, 1, 0, 0, 0, 3368, 3366, 1, 0, 0, 0, 3369, 3370, 3, 2, 1, 0, 3370, 343, 1, 0, 0, 0, 3371, 3387, 5, 52, 0, 0, 3372, 3387, 5, 51, 0, 0, 3373, 3387, 5, 172, 0, 0, 3374, 3375, 5, 62, 0, 0, 3375, 3387, 5, 51, 0, 0, 3376, 3377, 5, 62, 0, 0, 3377, 3387, 5, 52, 0, 0, 3378, 3379, 5, 62, 0, 0, 3379, 3387, 5, 63, 0, 0, 3380, 3381, 5, 62, 0, 0, 3381, 3387, 5, 64, 0, 0, 3382, 3383, 5, 62, 0, 0, 3383, 3387, 5, 65, 0, 0, 3384, 3385, 5, 62, 0, 0, 3385, 3387, 5, 66, 0, 0, 3386, 3371, 1, 0, 0, 0, 3386, 3372, 1, 0, 0, 0, 3386, 3373, 1, 0, 0, 0, 3386, 3374, 1, 0, 0, 0, 3386, 3376, 1, 0, 0, 0, 3386, 3378, 1, 0, 0, 0, 3386, 3380, 1, 0, 0, 0, 3386, 3382, 1, 0, 0, 0, 3386, 3384, 1, 0, 0, 0, 3387, 345, 1, 0, 0, 0, 3388, 3390, 3, 348, 174, 0, 3389, 3388, 1, 0, 0, 0, 3390, 3393, 1, 0, 0, 0, 3391, 3389, 1, 0, 0, 0, 3391, 3392, 1, 0, 0, 0, 3392, 347, 1, 0, 0, 0, 3393, 3391, 1, 0, 0, 0, 3394, 3395, 5, 21, 0, 0, 3395, 3408, 3, 2, 1, 0, 3396, 3397, 5, 50, 0, 0, 3397, 3398, 5, 40, 0, 0, 3398, 3408, 3, 118, 59, 0, 3399, 3400, 5, 25, 0, 0, 3400, 3401, 5, 40, 0, 0, 3401, 3408, 3, 2, 1, 0, 3402, 3408, 3, 174, 87, 0, 3403, 3404, 5, 50, 0, 0, 3404, 3408, 3, 32, 16, 0, 3405, 3408, 3, 330, 165, 0, 3406, 3408, 3, 40, 20, 0, 3407, 3394, 1, 0, 0, 0, 3407, 3396, 1, 0, 0, 0, 3407, 3399, 1, 0, 0, 0, 3407, 3402, 1, 0, 0, 0, 3407, 3403, 1, 0, 0, 0, 3407, 3405, 1, 0, 0, 0, 3407, 3406, 1, 0, 0, 0, 3408, 349, 1, 0, 0, 0, 3409, 3413, 5, 274, 0, 0, 3410, 3412, 3, 352, 176, 0, 3411, 3410, 1, 0, 0, 0, 3412, 3415, 1, 0, 0, 0, 3413, 3411, 1, 0, 0, 0, 3413, 3414, 1, 0, 0, 0, 3414, 3416, 1, 0, 0, 0, 3415, 3413, 1, 0, 0, 0, 3416, 3429, 3, 2, 1, 0, 3417, 3421, 5, 274, 0, 0, 3418, 3420, 3, 352, 176, 0, 3419, 3418, 1, 0, 0, 0, 3420, 3423, 1, 0, 0, 0, 3421, 3419, 1, 0, 0, 0, 3421, 3422, 1, 0, 0, 0, 3422, 3424, 1, 0, 0, 0, 3423, 3421, 1, 0, 0, 0, 3424, 3425, 3, 2, 1, 0, 3425, 3426, 5, 34, 0, 0, 3426, 3427, 3, 2, 1, 0, 3427, 3429, 1, 0, 0, 0, 3428, 3409, 1, 0, 0, 0, 3428, 3417, 1, 0, 0, 0, 3429, 351, 1, 0, 0, 0, 3430, 3431, 7, 13, 0, 0, 3431, 353, 1, 0, 0, 0, 3432, 3434, 3, 356, 178, 0, 3433, 3432, 1, 0, 0, 0, 3434, 3437, 1, 0, 0, 0, 3435, 3433, 1, 0, 0, 0, 3435, 3436, 1, 0, 0, 0, 3436, 355, 1, 0, 0, 0, 3437, 3435, 1, 0, 0, 0, 3438, 3439, 5, 21, 0, 0, 3439, 3440, 3, 2, 1, 0, 3440, 3441, 5, 44, 0, 0, 3441, 3442, 3, 32, 16, 0, 3442, 3449, 1, 0, 0, 0, 3443, 3444, 5, 25, 0, 0, 3444, 3445, 5, 40, 0, 0, 3445, 3449, 3, 2, 1, 0, 3446, 3449, 3, 330, 165, 0, 3447, 3449, 3, 40, 20, 0, 3448, 3438, 1, 0, 0, 0, 3448, 3443, 1, 0, 0, 0, 3448, 3446, 1, 0, 0, 0, 3448, 3447, 1, 0, 0, 0, 3449, 357, 1, 0, 0, 0, 181, 368, 376, 385, 394, 447, 488, 497, 527, 531, 549, 576, 599, 635, 645, 652, 654, 664, 666, 673, 684, 692, 713, 715, 731, 776, 781, 786, 791, 799, 909, 915, 931, 937, 943, 950, 978, 1056, 1058, 1072, 1078, 1087, 1089, 1098, 1112, 1126, 1134, 1142, 1146, 1185, 1193, 1202, 1210, 1229, 1239, 1242, 1266, 1413, 1423, 1432, 1435, 1517, 1526, 1558, 1618, 1658, 1674, 1684, 1711, 1735, 1743, 1747, 1762, 1769, 1814, 1824, 1842, 1860, 1879, 1900, 1919, 1934, 1942, 1954, 1974, 1981, 1986, 1997, 2009, 2119, 2131, 2147, 2161, 2170, 2183, 2185, 2228, 2239, 2246, 2254, 2262, 2275, 2281, 2287, 2292, 2321, 2329, 2343, 2348, 2373, 2382, 2393, 2397, 2404, 2424, 2433, 2435, 2450, 2497, 2507, 2509, 2516, 2522, 2566, 2575, 2615, 2620, 2660, 2664, 2674, 2696, 2708, 2719, 2734, 2747, 2760, 2763, 2771, 2785, 2803, 2821, 2835, 2859, 2871, 2876, 2885, 2887, 2894, 2904, 2972, 3049, 3056, 3064, 3214, 3218, 3220, 3225, 3227, 3233, 3239, 3245, 3251, 3257, 3263, 3269, 3276, 3281, 3287, 3314, 3328, 3333, 3350, 3357, 3366, 3386, 3391, 3407, 3413, 3421, 3428, 3435, 3448] \ No newline at end of file diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs index b62987fa6b6cf1..0249f26925167e 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs @@ -1947,6 +1947,7 @@ public TypedefDeclContext typedefDecl() { } public partial class CustomDescrContext : ParserRuleContext { + public bool HasSyntaxError; [System.Diagnostics.DebuggerNonUserCode] public CustomTypeContext customType() { return GetRuleContext(0); } @@ -1976,6 +1977,7 @@ public override TResult Accept(IParseTreeVisitor visitor) { public CustomDescrContext customDescr() { CustomDescrContext _localctx = new CustomDescrContext(Context, State); EnterRule(_localctx, 44, RULE_customDescr); + BeginSubtree(); Actions.BeginSemanticRoot(_localctx); try { State = 599; ErrorHandler.Sync(this); @@ -2044,12 +2046,14 @@ public CustomDescrContext customDescr() { ErrorHandler.Recover(this, re); } finally { + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; } public partial class CustomDescrWithOwnerContext : ParserRuleContext { + public bool HasSyntaxError; [System.Diagnostics.DebuggerNonUserCode] public OwnerTypeContext ownerType() { return GetRuleContext(0); } @@ -2082,6 +2086,7 @@ public override TResult Accept(IParseTreeVisitor visitor) { public CustomDescrWithOwnerContext customDescrWithOwner() { CustomDescrWithOwnerContext _localctx = new CustomDescrWithOwnerContext(Context, State); EnterRule(_localctx, 46, RULE_customDescrWithOwner); + BeginSubtree(); Actions.BeginSemanticRoot(_localctx); try { State = 635; ErrorHandler.Sync(this); @@ -2174,6 +2179,7 @@ public CustomDescrWithOwnerContext customDescrWithOwner() { ErrorHandler.Recover(this, re); } finally { + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; @@ -9344,6 +9350,9 @@ public FieldRefContext fieldRef() { } public partial class TypeListContext : ParserRuleContext { + public object Value; + public TypeSpecContext item; + public TypeSpecContext tail; [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext[] typeSpec() { return GetRuleContexts(); } @@ -9367,11 +9376,12 @@ public override TResult Accept(IParseTreeVisitor visitor) { public TypeListContext typeList() { TypeListContext _localctx = new TypeListContext(Context, State); EnterRule(_localctx, 180, RULE_typeList); + Actions.BeginGenericTypeList(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1941; + State = 1942; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,81,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { @@ -9379,18 +9389,20 @@ public TypeListContext typeList() { { { State = 1936; - typeSpec(); - State = 1937; + _localctx.item = typeSpec(); + Actions.AddGenericType(_localctx, _localctx.item.Value); + State = 1938; Match(T__27); } } } - State = 1943; + State = 1944; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,81,Context); } - State = 1944; - typeSpec(); + State = 1945; + _localctx.tail = typeSpec(); + Actions.AddGenericType(_localctx, _localctx.tail.Value); } } catch (RecognitionException re) { @@ -9399,12 +9411,15 @@ public TypeListContext typeList() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndGenericTypeList(_localctx); ExitRule(); } return _localctx; } public partial class TyparsClauseContext : ParserRuleContext { + public object Value; + public TyparsContext parameters; [System.Diagnostics.DebuggerNonUserCode] public TyparsContext typars() { return GetRuleContext(0); } @@ -9425,8 +9440,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { public TyparsClauseContext typarsClause() { TyparsClauseContext _localctx = new TyparsClauseContext(Context, State); EnterRule(_localctx, 182, RULE_typarsClause); + _localctx.Value = Actions.CreateEmptyGenericParameterList(); try { - State = 1951; + State = 1954; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -9441,12 +9457,13 @@ public TyparsClauseContext typarsClause() { case T__85: EnterOuterAlt(_localctx, 2); { - State = 1947; - Match(T__85); - State = 1948; - typars(); State = 1949; + Match(T__85); + State = 1950; + _localctx.parameters = typars(); + State = 1951; Match(T__86); + _localctx.Value = _localctx.parameters.Value; } break; default: @@ -9465,6 +9482,7 @@ public TyparsClauseContext typarsClause() { } public partial class TyparAttribContext : ParserRuleContext { + public object Value; public IToken covariant; public IToken contravariant; public IToken @class; @@ -9495,62 +9513,69 @@ public TyparAttribContext typarAttrib() { TyparAttribContext _localctx = new TyparAttribContext(Context, State); EnterRule(_localctx, 184, RULE_typarAttrib); try { - State = 1964; + State = 1974; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case PLUS: EnterOuterAlt(_localctx, 1); { - State = 1953; + State = 1956; _localctx.covariant = Match(PLUS); + _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.covariant); } break; case T__113: EnterOuterAlt(_localctx, 2); { - State = 1954; + State = 1958; _localctx.contravariant = Match(T__113); + _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.contravariant); } break; case T__38: EnterOuterAlt(_localctx, 3); { - State = 1955; + State = 1960; _localctx.@class = Match(T__38); + _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.@class); } break; case VALUETYPE: EnterOuterAlt(_localctx, 4); { - State = 1956; + State = 1962; _localctx.valuetype = Match(VALUETYPE); + _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.valuetype); } break; case T__114: EnterOuterAlt(_localctx, 5); { - State = 1957; + State = 1964; _localctx.byrefLike = Match(T__114); + _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.byrefLike); } break; case T__115: EnterOuterAlt(_localctx, 6); { - State = 1958; + State = 1966; _localctx.ctor = Match(T__115); + _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.ctor); } break; case T__69: EnterOuterAlt(_localctx, 7); { - State = 1959; + State = 1968; Match(T__69); - State = 1960; + State = 1969; Match(T__29); - State = 1961; + State = 1970; _localctx.flags = int32(); - State = 1962; + State = 1971; Match(T__30); + _localctx.Value = Actions.CreateRawGenericParameterAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } break; default: @@ -9569,6 +9594,8 @@ public TyparAttribContext typarAttrib() { } public partial class TyparAttribsContext : ParserRuleContext { + public object Value; + public TyparAttribContext attribute; [System.Diagnostics.DebuggerNonUserCode] public TyparAttribContext[] typarAttrib() { return GetRuleContexts(); } @@ -9592,21 +9619,23 @@ public override TResult Accept(IParseTreeVisitor visitor) { public TyparAttribsContext typarAttribs() { TyparAttribsContext _localctx = new TyparAttribsContext(Context, State); EnterRule(_localctx, 186, RULE_typarAttribs); + Actions.BeginGenericParameterAttributes(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 1969; + State = 1981; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__38 || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & 123145302310913L) != 0) || _la==VALUETYPE || _la==PLUS) { { { - State = 1966; - typarAttrib(); + State = 1976; + _localctx.attribute = typarAttrib(); + Actions.AddGenericParameterAttribute(_localctx, _localctx.attribute.Value); } } - State = 1971; + State = 1983; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -9618,12 +9647,17 @@ public TyparAttribsContext typarAttribs() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndGenericParameterAttributes(_localctx); ExitRule(); } return _localctx; } public partial class TyparContext : ParserRuleContext { + public object Value; + public TyparAttribsContext attributes; + public TyBoundContext constraints; + public DottedNameContext name; [System.Diagnostics.DebuggerNonUserCode] public TyparAttribsContext typarAttribs() { return GetRuleContext(0); } @@ -9654,20 +9688,21 @@ public TyparContext typar() { try { EnterOuterAlt(_localctx, 1); { - State = 1972; - typarAttribs(); - State = 1974; + State = 1984; + _localctx.attributes = typarAttribs(); + State = 1986; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__29) { { - State = 1973; - tyBound(); + State = 1985; + _localctx.constraints = tyBound(); } } - State = 1976; - dottedName(); + State = 1988; + _localctx.name = dottedName(); + _localctx.Value = Actions.CreateGenericParameterDeclaration(_localctx.attributes.Value, _localctx.constraints, _localctx.name.Value); } } catch (RecognitionException re) { @@ -9682,6 +9717,9 @@ public TyparContext typar() { } public partial class TyparsContext : ParserRuleContext { + public object Value; + public TyparContext parameter; + public TyparContext tail; [System.Diagnostics.DebuggerNonUserCode] public TyparContext[] typar() { return GetRuleContexts(); } @@ -9705,30 +9743,33 @@ public override TResult Accept(IParseTreeVisitor visitor) { public TyparsContext typars() { TyparsContext _localctx = new TyparsContext(Context, State); EnterRule(_localctx, 190, RULE_typars); + Actions.BeginGenericParameters(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1983; + State = 1997; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,86,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1978; - typar(); - State = 1979; + State = 1991; + _localctx.parameter = typar(); + Actions.AddGenericParameter(_localctx, _localctx.parameter.Value); + State = 1993; Match(T__27); } } } - State = 1985; + State = 1999; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,86,Context); } - State = 1986; - typar(); + State = 2000; + _localctx.tail = typar(); + Actions.AddGenericParameter(_localctx, _localctx.tail.Value); } } catch (RecognitionException re) { @@ -9737,12 +9778,15 @@ public TyparsContext typars() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndGenericParameters(_localctx); ExitRule(); } return _localctx; } public partial class TyBoundContext : ParserRuleContext { + public object Value; + public TypeListContext constraints; [System.Diagnostics.DebuggerNonUserCode] public TypeListContext typeList() { return GetRuleContext(0); } @@ -9766,12 +9810,13 @@ public TyBoundContext tyBound() { try { EnterOuterAlt(_localctx, 1); { - State = 1988; + State = 2003; Match(T__29); - State = 1989; - typeList(); - State = 1990; + State = 2004; + _localctx.constraints = typeList(); + State = 2005; Match(T__30); + _localctx.Value = _localctx.constraints.Value; } } catch (RecognitionException re) { @@ -9812,12 +9857,12 @@ public GenArityContext genArity() { try { EnterOuterAlt(_localctx, 1); { - State = 1993; + State = 2009; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 1992; + State = 2008; _localctx.value = genArityNotEmpty(); } } @@ -9862,15 +9907,15 @@ public GenArityNotEmptyContext genArityNotEmpty() { try { EnterOuterAlt(_localctx, 1); { - State = 1997; + State = 2013; Match(T__85); - State = 1998; + State = 2014; Match(T__41); - State = 1999; + State = 2015; _localctx.value = int32(); - State = 2000; + State = 2016; Match(T__42); - State = 2001; + State = 2017; Match(T__86); _localctx.Value = Actions.ParseInt32((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -9887,6 +9932,34 @@ public GenArityNotEmptyContext genArityNotEmpty() { } public partial class ClassDeclContext : ParserRuleContext { + public EventHeadContext eventHeader; + public PropHeadContext property; + public DataDeclContext data; + public SecDeclContext security; + public ExtSourceSpecContext source; + public CustomAttrDeclContext attribute; + public Int32Context size; + public Int32Context packing; + public ExportHeadContext export; + public ExptypeDeclsContext exportDeclarations; + public TypeSpecContext declarationOwner; + public MethodNameContext declarationName; + public CallConvContext bodyConvention; + public TypeContext bodyReturnType; + public TypeSpecContext bodyOwner; + public MethodNameContext bodyName; + public SigArgsContext bodyArguments; + public CallConvContext declarationConvention; + public TypeContext declarationReturnType; + public GenArityContext declarationArity; + public SigArgsContext declarationArguments; + public GenArityContext bodyArity; + public LanguageDeclContext language; + public Int32Context parameterIndex; + public DottedNameContext parameterName; + public TypeSpecContext constraintType; + public TypeSpecContext interfaceType; + public CustomDescrContext interfaceAttribute; [System.Diagnostics.DebuggerNonUserCode] public MethodHeadContext methodHead() { return GetRuleContext(0); } @@ -9899,18 +9972,18 @@ [System.Diagnostics.DebuggerNonUserCode] public ClassHeadContext classHead() { [System.Diagnostics.DebuggerNonUserCode] public ClassDeclsContext classDecls() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public EventHeadContext eventHead() { - return GetRuleContext(0); - } [System.Diagnostics.DebuggerNonUserCode] public EventDeclsContext eventDecls() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public PropHeadContext propHead() { - return GetRuleContext(0); + [System.Diagnostics.DebuggerNonUserCode] public EventHeadContext eventHead() { + return GetRuleContext(0); } [System.Diagnostics.DebuggerNonUserCode] public PropDeclsContext propDecls() { return GetRuleContext(0); } + [System.Diagnostics.DebuggerNonUserCode] public PropHeadContext propHead() { + return GetRuleContext(0); + } [System.Diagnostics.DebuggerNonUserCode] public FieldDeclContext fieldDecl() { return GetRuleContext(0); } @@ -9939,16 +10012,16 @@ [System.Diagnostics.DebuggerNonUserCode] public ExptypeDeclsContext exptypeDecls return GetRuleContext(0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode OVERRIDE() { return GetToken(CILParser.OVERRIDE, 0); } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] DCOLON() { return GetTokens(CILParser.DCOLON); } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DCOLON(int i) { + return GetToken(CILParser.DCOLON, i); + } [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext[] typeSpec() { return GetRuleContexts(); } [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec(int i) { return GetRuleContext(i); } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] DCOLON() { return GetTokens(CILParser.DCOLON); } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DCOLON(int i) { - return GetToken(CILParser.DCOLON, i); - } [System.Diagnostics.DebuggerNonUserCode] public MethodNameContext[] methodName() { return GetRuleContexts(); } @@ -10015,238 +10088,274 @@ public override TResult Accept(IParseTreeVisitor visitor) { public ClassDeclContext classDecl() { ClassDeclContext _localctx = new ClassDeclContext(Context, State); EnterRule(_localctx, 198, RULE_classDecl); - BeginSubtree(); + BeginStreaming(); try { int _alt; - State = 2120; + State = 2170; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,92,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2004; + State = 2020; methodHead(); - State = 2005; + State = 2021; Match(T__16); - State = 2006; + State = 2022; methodDecls(); - State = 2007; + State = 2023; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2009; + State = 2025; classHead(); - State = 2010; + State = 2026; Match(T__16); - State = 2011; + State = 2027; classDecls(); - State = 2012; + State = 2028; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2014; - eventHead(); - State = 2015; + State = 2030; + _localctx.eventHeader = eventHead(); + Actions.BeginEvent(_localctx, _localctx.eventHeader.Value); + State = 2032; Match(T__16); - State = 2016; + State = 2033; eventDecls(); - State = 2017; + State = 2034; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2019; - propHead(); - State = 2020; + State = 2036; + _localctx.property = propHead(); + Actions.BeginProperty(_localctx, _localctx.property.Value); + State = 2038; Match(T__16); - State = 2021; + State = 2039; propDecls(); - State = 2022; + State = 2040; Match(T__17); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2024; + State = 2042; fieldDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2025; - dataDecl(); + State = 2043; + _localctx.data = dataDecl(); + Actions.ProcessClassDataDeclaration(_localctx.data); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2026; - secDecl(); + State = 2046; + _localctx.security = secDecl(); + Actions.ProcessClassSecurityDeclaration(_localctx.security); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2027; - extSourceSpec(); + State = 2049; + _localctx.source = extSourceSpec(); + Actions.ProcessClassSourceDirective(_localctx.source); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2028; - customAttrDecl(); + State = 2052; + _localctx.attribute = customAttrDecl(); + Actions.ProcessClassCustomAttribute(_localctx.attribute); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2029; + State = 2055; Match(T__116); - State = 2030; - int32(); + State = 2056; + _localctx.size = int32(); + Actions.SetClassSize((_localctx.size!=null?(_localctx.size.Start):null)); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2031; + State = 2059; Match(T__117); - State = 2032; - int32(); + State = 2060; + _localctx.packing = int32(); + Actions.SetClassPackingSize((_localctx.packing!=null?(_localctx.packing.Start):null)); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2033; - exportHead(); - State = 2034; + State = 2063; + _localctx.export = exportHead(); + State = 2064; Match(T__16); - State = 2035; - exptypeDecls(); - State = 2036; + State = 2065; + _localctx.exportDeclarations = exptypeDecls(); + State = 2066; Match(T__17); + Actions.ProcessClassExport(_localctx.export, _localctx.exportDeclarations); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2038; + State = 2069; Match(OVERRIDE); - State = 2039; - typeSpec(); - State = 2040; + State = 2070; + _localctx.declarationOwner = typeSpec(); + State = 2071; Match(DCOLON); - State = 2041; - methodName(); - State = 2042; + State = 2072; + _localctx.declarationName = methodName(); + State = 2073; Match(T__118); - State = 2043; - callConv(); - State = 2044; - type(); - State = 2045; - typeSpec(); - State = 2046; + State = 2074; + _localctx.bodyConvention = callConv(); + State = 2075; + _localctx.bodyReturnType = type(); + State = 2076; + _localctx.bodyOwner = typeSpec(); + State = 2077; Match(DCOLON); - State = 2047; - methodName(); - State = 2048; - sigArgs(); + State = 2078; + _localctx.bodyName = methodName(); + State = 2079; + _localctx.bodyArguments = sigArgs(); + Actions.AddClassMethodOverride( + _localctx, + _localctx.declarationOwner.Value, + _localctx.declarationName.Value, + _localctx.bodyConvention.Value, + _localctx.bodyReturnType.Value, + _localctx.bodyOwner.Value, + _localctx.bodyName.Value, + _localctx.bodyArguments.Value); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2050; + State = 2082; Match(OVERRIDE); - State = 2051; + State = 2083; Match(METHOD); - State = 2052; - callConv(); - State = 2053; - type(); - State = 2054; - typeSpec(); - State = 2055; + State = 2084; + _localctx.declarationConvention = callConv(); + State = 2085; + _localctx.declarationReturnType = type(); + State = 2086; + _localctx.declarationOwner = typeSpec(); + State = 2087; Match(DCOLON); - State = 2056; - methodName(); - State = 2057; - genArity(); - State = 2058; - sigArgs(); - State = 2059; + State = 2088; + _localctx.declarationName = methodName(); + State = 2089; + _localctx.declarationArity = genArity(); + State = 2090; + _localctx.declarationArguments = sigArgs(); + State = 2091; Match(T__118); - State = 2060; + State = 2092; Match(METHOD); - State = 2061; - callConv(); - State = 2062; - type(); - State = 2063; - typeSpec(); - State = 2064; + State = 2093; + _localctx.bodyConvention = callConv(); + State = 2094; + _localctx.bodyReturnType = type(); + State = 2095; + _localctx.bodyOwner = typeSpec(); + State = 2096; Match(DCOLON); - State = 2065; - methodName(); - State = 2066; - genArity(); - State = 2067; - sigArgs(); + State = 2097; + _localctx.bodyName = methodName(); + State = 2098; + _localctx.bodyArity = genArity(); + State = 2099; + _localctx.bodyArguments = sigArgs(); + Actions.AddClassMethodOverride( + _localctx, + _localctx.declarationConvention.Value, + _localctx.declarationReturnType.Value, + _localctx.declarationOwner.Value, + _localctx.declarationName.Value, + _localctx.declarationArity.Value, + _localctx.declarationArguments.Value, + _localctx.bodyConvention.Value, + _localctx.bodyReturnType.Value, + _localctx.bodyOwner.Value, + _localctx.bodyName.Value, + _localctx.bodyArity.Value, + _localctx.bodyArguments.Value); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2069; - languageDecl(); + State = 2102; + _localctx.language = languageDecl(); + Actions.ProcessClassLanguageDirective(_localctx.language); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 2070; + State = 2105; compControl(); + Actions.ProcessClassCompilerControl(); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 2071; + State = 2108; Match(PARAM); - State = 2072; + State = 2109; Match(TYPE); - State = 2073; + State = 2110; Match(T__41); - State = 2074; - int32(); - State = 2075; + State = 2111; + _localctx.parameterIndex = int32(); + State = 2112; Match(T__42); - State = 2079; + Actions.BeginClassGenericParameterDirective(_localctx, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null)); + State = 2119; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2076; - customAttrDecl(); + State = 2114; + _localctx.attribute = customAttrDecl(); + Actions.AddClassGenericDirectiveAttribute(_localctx, _localctx.attribute); } } } - State = 2081; + State = 2121; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); } @@ -10255,25 +10364,27 @@ public ClassDeclContext classDecl() { case 18: EnterOuterAlt(_localctx, 18); { - State = 2082; + State = 2122; Match(PARAM); - State = 2083; + State = 2123; Match(TYPE); - State = 2084; - dottedName(); - State = 2088; + State = 2124; + _localctx.parameterName = dottedName(); + Actions.BeginClassGenericParameterDirective(_localctx, _localctx.parameterName.Value); + State = 2131; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2085; - customAttrDecl(); + State = 2126; + _localctx.attribute = customAttrDecl(); + Actions.AddClassGenericDirectiveAttribute(_localctx, _localctx.attribute); } } } - State = 2090; + State = 2133; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); } @@ -10282,33 +10393,35 @@ public ClassDeclContext classDecl() { case 19: EnterOuterAlt(_localctx, 19); { - State = 2091; + State = 2134; Match(PARAM); - State = 2092; + State = 2135; Match(CONSTRAINT); - State = 2093; + State = 2136; Match(T__41); - State = 2094; - int32(); - State = 2095; + State = 2137; + _localctx.parameterIndex = int32(); + State = 2138; Match(T__42); - State = 2096; + State = 2139; Match(T__27); - State = 2097; - typeSpec(); - State = 2101; + State = 2140; + _localctx.constraintType = typeSpec(); + Actions.BeginClassGenericConstraintDirective(_localctx, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null), _localctx.constraintType.Value); + State = 2147; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2098; - customAttrDecl(); + State = 2142; + _localctx.attribute = customAttrDecl(); + Actions.AddClassGenericDirectiveAttribute(_localctx, _localctx.attribute); } } } - State = 2103; + State = 2149; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); } @@ -10317,29 +10430,31 @@ public ClassDeclContext classDecl() { case 20: EnterOuterAlt(_localctx, 20); { - State = 2104; + State = 2150; Match(PARAM); - State = 2105; + State = 2151; Match(CONSTRAINT); - State = 2106; - dottedName(); - State = 2107; + State = 2152; + _localctx.parameterName = dottedName(); + State = 2153; Match(T__27); - State = 2108; - typeSpec(); - State = 2112; + State = 2154; + _localctx.constraintType = typeSpec(); + Actions.BeginClassGenericConstraintDirective(_localctx, _localctx.parameterName.Value, _localctx.constraintType.Value); + State = 2161; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2109; - customAttrDecl(); + State = 2156; + _localctx.attribute = customAttrDecl(); + Actions.AddClassGenericDirectiveAttribute(_localctx, _localctx.attribute); } } } - State = 2114; + State = 2163; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); } @@ -10348,19 +10463,18 @@ public ClassDeclContext classDecl() { case 21: EnterOuterAlt(_localctx, 21); { - State = 2115; + State = 2164; Match(T__119); - State = 2116; + State = 2165; Match(TYPE); - State = 2117; - typeSpec(); - State = 2118; - customDescr(); + State = 2166; + _localctx.interfaceType = typeSpec(); + State = 2167; + _localctx.interfaceAttribute = customDescr(); + Actions.AddInterfaceImplementationAttribute(_localctx, _localctx.interfaceType.Value, _localctx.interfaceAttribute); } break; } - Context.Stop = TokenStream.LT(-1); - Actions.OnClassDeclaration(_localctx); } catch (RecognitionException re) { _localctx.exception = re; @@ -10375,6 +10489,14 @@ public ClassDeclContext classDecl() { } public partial class FieldDeclContext : ParserRuleContext { + public object Value; + public RepeatOptContext offset; + public FieldAttrContext attribute; + public MarshalBlobContext marshalling; + public TypeContext fieldType; + public DottedNameContext name; + public AtOptContext data; + public InitOptContext initializer; [System.Diagnostics.DebuggerNonUserCode] public RepeatOptContext repeatOpt() { return GetRuleContext(0); } @@ -10419,21 +10541,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { public FieldDeclContext fieldDecl() { FieldDeclContext _localctx = new FieldDeclContext(Context, State); EnterRule(_localctx, 200, RULE_fieldDecl); + BeginStreaming(); Actions.BeginFieldDeclaration(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 2122; + State = 2172; Match(T__120); - State = 2123; - repeatOpt(); - State = 2132; + State = 2173; + _localctx.offset = repeatOpt(); + State = 2185; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,94,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { - State = 2130; + State = 2183; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -10452,20 +10575,22 @@ public FieldDeclContext fieldDecl() { case T__125: case T__126: { - State = 2124; - fieldAttr(); + State = 2174; + _localctx.attribute = fieldAttr(); + Actions.AddFieldAttribute(_localctx, _localctx.attribute.Value); } break; case T__121: { - State = 2125; + State = 2177; Match(T__121); - State = 2126; + State = 2178; Match(T__29); - State = 2127; - marshalBlob(); - State = 2128; + State = 2179; + _localctx.marshalling = marshalBlob(); + State = 2180; Match(T__30); + Actions.SetFieldMarshalling(_localctx, _localctx.marshalling.Value); } break; default: @@ -10473,19 +10598,28 @@ public FieldDeclContext fieldDecl() { } } } - State = 2134; + State = 2187; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,94,Context); } - State = 2135; - type(); - State = 2136; - dottedName(); - State = 2137; - atOpt(); - State = 2138; - initOpt(); + State = 2188; + _localctx.fieldType = type(); + State = 2189; + _localctx.name = dottedName(); + State = 2190; + _localctx.data = atOpt(); + State = 2191; + _localctx.initializer = initOpt(); + _localctx.Value = Actions.CreateFieldDeclaration( + _localctx, + _localctx.offset, + _localctx.fieldType.Value, + _localctx.name.Value, + _localctx.data.Value, + _localctx.initializer.Value); } + Context.Stop = TokenStream.LT(-1); + Actions.DefineField(_localctx, _localctx.Value); } catch (RecognitionException re) { _localctx.exception = re; @@ -10493,12 +10627,16 @@ public FieldDeclContext fieldDecl() { ErrorHandler.Recover(this, re); } finally { + Actions.EndFieldDeclaration(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; } public partial class FieldAttrContext : ParserRuleContext { + public object Value; + public IToken attribute; + public Int32Context flags; [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); } @@ -10520,118 +10658,133 @@ public FieldAttrContext fieldAttr() { FieldAttrContext _localctx = new FieldAttrContext(Context, State); EnterRule(_localctx, 202, RULE_fieldAttr); try { - State = 2159; + State = 2228; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__122: EnterOuterAlt(_localctx, 1); { - State = 2140; - Match(T__122); + State = 2194; + _localctx.attribute = Match(T__122); + _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } break; case T__50: EnterOuterAlt(_localctx, 2); { - State = 2141; - Match(T__50); + State = 2196; + _localctx.attribute = Match(T__50); + _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } break; case T__51: EnterOuterAlt(_localctx, 3); { - State = 2142; - Match(T__51); + State = 2198; + _localctx.attribute = Match(T__51); + _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } break; case T__62: EnterOuterAlt(_localctx, 4); { - State = 2143; - Match(T__62); + State = 2200; + _localctx.attribute = Match(T__62); + _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } break; case T__123: EnterOuterAlt(_localctx, 5); { - State = 2144; - Match(T__123); + State = 2202; + _localctx.attribute = Match(T__123); + _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } break; case T__68: EnterOuterAlt(_localctx, 6); { - State = 2145; - Match(T__68); + State = 2204; + _localctx.attribute = Match(T__68); + _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } break; case T__67: EnterOuterAlt(_localctx, 7); { - State = 2146; - Match(T__67); + State = 2206; + _localctx.attribute = Match(T__67); + _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } break; case T__63: EnterOuterAlt(_localctx, 8); { - State = 2147; - Match(T__63); + State = 2208; + _localctx.attribute = Match(T__63); + _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } break; case T__64: EnterOuterAlt(_localctx, 9); { - State = 2148; - Match(T__64); + State = 2210; + _localctx.attribute = Match(T__64); + _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } break; case T__65: EnterOuterAlt(_localctx, 10); { - State = 2149; - Match(T__65); + State = 2212; + _localctx.attribute = Match(T__65); + _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } break; case T__124: EnterOuterAlt(_localctx, 11); { - State = 2150; - Match(T__124); + State = 2214; + _localctx.attribute = Match(T__124); + _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } break; case T__125: EnterOuterAlt(_localctx, 12); { - State = 2151; - Match(T__125); + State = 2216; + _localctx.attribute = Match(T__125); + _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } break; case T__126: EnterOuterAlt(_localctx, 13); { - State = 2152; - Match(T__126); + State = 2218; + _localctx.attribute = Match(T__126); + _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } break; case T__15: EnterOuterAlt(_localctx, 14); { - State = 2153; - Match(T__15); + State = 2220; + _localctx.attribute = Match(T__15); + _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } break; case T__69: EnterOuterAlt(_localctx, 15); { - State = 2154; + State = 2222; Match(T__69); - State = 2155; + State = 2223; Match(T__29); - State = 2156; - int32(); - State = 2157; + State = 2224; + _localctx.flags = int32(); + State = 2225; Match(T__30); + _localctx.Value = Actions.CreateRawFieldAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } break; default: @@ -10650,6 +10803,9 @@ public FieldAttrContext fieldAttr() { } public partial class AtOptContext : ParserRuleContext { + public string Value; + public IdContext name; + public Int32Context offset; [System.Diagnostics.DebuggerNonUserCode] public IdContext id() { return GetRuleContext(0); } @@ -10674,7 +10830,7 @@ public AtOptContext atOpt() { AtOptContext _localctx = new AtOptContext(Context, State); EnterRule(_localctx, 204, RULE_atOpt); try { - State = 2166; + State = 2239; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,96,Context) ) { case 1: @@ -10685,19 +10841,21 @@ public AtOptContext atOpt() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2162; + State = 2231; Match(T__43); - State = 2163; - id(); + State = 2232; + _localctx.name = id(); + _localctx.Value = Actions.GetFieldDataName((_localctx.name!=null?(_localctx.name.Start):null)); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2164; + State = 2235; Match(T__43); - State = 2165; - int32(); + State = 2236; + _localctx.offset = int32(); + _localctx.Value = Actions.GetFieldDataOffset((_localctx.offset!=null?(_localctx.offset.Start):null)); } break; } @@ -10714,7 +10872,9 @@ public AtOptContext atOpt() { } public partial class InitOptContext : ParserRuleContext { + public object Value; public bool HasSyntaxError; + public FieldInitContext initializer; [System.Diagnostics.DebuggerNonUserCode] public FieldInitContext fieldInit() { return GetRuleContext(0); } @@ -10735,9 +10895,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { public InitOptContext initOpt() { InitOptContext _localctx = new InitOptContext(Context, State); EnterRule(_localctx, 206, RULE_initOpt); - BeginSubtree(); Actions.BeginSemanticRoot(_localctx); + BeginSubtree(); Actions.BeginFieldInitializer(_localctx); try { - State = 2171; + State = 2246; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -10831,10 +10991,11 @@ public InitOptContext initOpt() { case T__35: EnterOuterAlt(_localctx, 2); { - State = 2169; + State = 2242; Match(T__35); - State = 2170; - fieldInit(); + State = 2243; + _localctx.initializer = fieldInit(); + Actions.SetFieldInitializer(_localctx, _localctx.initializer); } break; default: @@ -10847,13 +11008,16 @@ public InitOptContext initOpt() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); + _localctx.HasSyntaxError = Actions.EndFieldInitializer(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; } public partial class RepeatOptContext : ParserRuleContext { + public int Value; + public bool HasValue; + public Int32Context offset; [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); } @@ -10875,7 +11039,7 @@ public RepeatOptContext repeatOpt() { RepeatOptContext _localctx = new RepeatOptContext(Context, State); EnterRule(_localctx, 208, RULE_repeatOpt); try { - State = 2178; + State = 2254; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -10930,12 +11094,13 @@ public RepeatOptContext repeatOpt() { case T__41: EnterOuterAlt(_localctx, 2); { - State = 2174; + State = 2249; Match(T__41); - State = 2175; - int32(); - State = 2176; + State = 2250; + _localctx.offset = int32(); + State = 2251; Match(T__42); + Actions.SetFieldOffset(_localctx, (_localctx.offset!=null?(_localctx.offset.Start):null)); } break; default: @@ -10954,6 +11119,10 @@ public RepeatOptContext repeatOpt() { } public partial class EventHeadContext : ParserRuleContext { + public object Value; + public EventAttrContext attribute; + public TypeSpecContext eventType; + public DottedNameContext name; [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() { return GetRuleContext(0); } @@ -10983,57 +11152,62 @@ public override TResult Accept(IParseTreeVisitor visitor) { public EventHeadContext eventHead() { EventHeadContext _localctx = new EventHeadContext(Context, State); EnterRule(_localctx, 210, RULE_eventHead); + Actions.BeginEventHeader(_localctx); int _la; try { - State = 2198; + State = 2281; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,101,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2180; + State = 2256; Match(T__127); - State = 2184; + State = 2262; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 2181; - eventAttr(); + State = 2257; + _localctx.attribute = eventAttr(); + Actions.AddEventAttribute(_localctx, _localctx.attribute.Value); } } - State = 2186; + State = 2264; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2187; - typeSpec(); - State = 2188; - dottedName(); + State = 2265; + _localctx.eventType = typeSpec(); + State = 2266; + _localctx.name = dottedName(); + _localctx.Value = Actions.CreateEventHeader(_localctx, _localctx.eventType.Value, _localctx.name.Value); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2190; + State = 2269; Match(T__127); - State = 2194; + State = 2275; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 2191; - eventAttr(); + State = 2270; + _localctx.attribute = eventAttr(); + Actions.AddEventAttribute(_localctx, _localctx.attribute.Value); } } - State = 2196; + State = 2277; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2197; - dottedName(); + State = 2278; + _localctx.name = dottedName(); + _localctx.Value = Actions.CreateEventHeader(_localctx, null, _localctx.name.Value); } break; } @@ -11044,12 +11218,15 @@ public EventHeadContext eventHead() { ErrorHandler.Recover(this, re); } finally { + Actions.EndEventHeader(_localctx); ExitRule(); } return _localctx; } public partial class EventAttrContext : ParserRuleContext { + public object Value; + public IToken attribute; public EventAttrContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { @@ -11067,19 +11244,28 @@ public override TResult Accept(IParseTreeVisitor visitor) { public EventAttrContext eventAttr() { EventAttrContext _localctx = new EventAttrContext(Context, State); EnterRule(_localctx, 212, RULE_eventAttr); - int _la; try { - EnterOuterAlt(_localctx, 1); - { - State = 2200; - _la = TokenStream.LA(1); - if ( !(_la==T__67 || _la==T__68) ) { - ErrorHandler.RecoverInline(this); - } - else { - ErrorHandler.ReportMatch(this); - Consume(); - } + State = 2287; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case T__68: + EnterOuterAlt(_localctx, 1); + { + State = 2283; + _localctx.attribute = Match(T__68); + _localctx.Value = Actions.CreateEventAttribute(_localctx.attribute); + } + break; + case T__67: + EnterOuterAlt(_localctx, 2); + { + State = 2285; + _localctx.attribute = Match(T__67); + _localctx.Value = Actions.CreateEventAttribute(_localctx.attribute); + } + break; + default: + throw new NoViableAltException(this); } } catch (RecognitionException re) { @@ -11121,17 +11307,17 @@ public EventDeclsContext eventDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2205; + State = 2292; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38788988928L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 1080863910568919043L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 2202; + State = 2289; eventDecl(); } } - State = 2207; + State = 2294; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11149,6 +11335,10 @@ public EventDeclsContext eventDecls() { } public partial class EventDeclContext : ParserRuleContext { + public MethodRefContext accessor; + public ExtSourceSpecContext source; + public CustomAttrDeclContext attribute; + public LanguageDeclContext language; [System.Diagnostics.DebuggerNonUserCode] public MethodRefContext methodRef() { return GetRuleContext(0); } @@ -11182,51 +11372,56 @@ public EventDeclContext eventDecl() { EventDeclContext _localctx = new EventDeclContext(Context, State); EnterRule(_localctx, 216, RULE_eventDecl); try { - State = 2220; + State = 2321; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__128: EnterOuterAlt(_localctx, 1); { - State = 2208; + State = 2295; Match(T__128); - State = 2209; - methodRef(); + State = 2296; + _localctx.accessor = methodRef(); + Actions.AddEventAdder(_localctx, _localctx.accessor.Value); } break; case T__129: EnterOuterAlt(_localctx, 2); { - State = 2210; + State = 2299; Match(T__129); - State = 2211; - methodRef(); + State = 2300; + _localctx.accessor = methodRef(); + Actions.AddEventRemover(_localctx, _localctx.accessor.Value); } break; case T__130: EnterOuterAlt(_localctx, 3); { - State = 2212; + State = 2303; Match(T__130); - State = 2213; - methodRef(); + State = 2304; + _localctx.accessor = methodRef(); + Actions.AddEventRaiser(_localctx, _localctx.accessor.Value); } break; case T__131: EnterOuterAlt(_localctx, 4); { - State = 2214; + State = 2307; Match(T__131); - State = 2215; - methodRef(); + State = 2308; + _localctx.accessor = methodRef(); + Actions.AddEventOther(_localctx, _localctx.accessor.Value); } break; case T__72: case T__73: EnterOuterAlt(_localctx, 5); { - State = 2216; - extSourceSpec(); + State = 2311; + _localctx.source = extSourceSpec(); + Actions.ProcessEventSourceDirective(_localctx.source); } break; case T__15: @@ -11238,15 +11433,17 @@ public EventDeclContext eventDecl() { case ID: EnterOuterAlt(_localctx, 6); { - State = 2217; - customAttrDecl(); + State = 2314; + _localctx.attribute = customAttrDecl(); + Actions.AddEventCustomAttribute(_localctx, _localctx.attribute); } break; case T__26: EnterOuterAlt(_localctx, 7); { - State = 2218; - languageDecl(); + State = 2317; + _localctx.language = languageDecl(); + Actions.ProcessEventLanguageDirective(_localctx.language); } break; case T__31: @@ -11259,7 +11456,7 @@ public EventDeclContext eventDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 8); { - State = 2219; + State = 2320; compControl(); } break; @@ -11279,6 +11476,13 @@ public EventDeclContext eventDecl() { } public partial class PropHeadContext : ParserRuleContext { + public object Value; + public PropAttrContext attribute; + public CallConvContext convention; + public TypeContext propertyType; + public DottedNameContext name; + public SigArgsContext arguments; + public InitOptContext initializer; [System.Diagnostics.DebuggerNonUserCode] public CallConvContext callConv() { return GetRuleContext(0); } @@ -11317,36 +11521,45 @@ public override TResult Accept(IParseTreeVisitor visitor) { public PropHeadContext propHead() { PropHeadContext _localctx = new PropHeadContext(Context, State); EnterRule(_localctx, 218, RULE_propHead); + Actions.BeginPropertyHeader(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2222; + State = 2323; Match(T__132); - State = 2226; + State = 2329; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 2223; - propAttr(); + State = 2324; + _localctx.attribute = propAttr(); + Actions.AddPropertyAttribute(_localctx, _localctx.attribute.Value); } } - State = 2228; + State = 2331; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2229; - callConv(); - State = 2230; - type(); - State = 2231; - dottedName(); - State = 2232; - sigArgs(); - State = 2233; - initOpt(); + State = 2332; + _localctx.convention = callConv(); + State = 2333; + _localctx.propertyType = type(); + State = 2334; + _localctx.name = dottedName(); + State = 2335; + _localctx.arguments = sigArgs(); + State = 2336; + _localctx.initializer = initOpt(); + _localctx.Value = Actions.CreatePropertyHeader( + _localctx, + _localctx.convention.Value, + _localctx.propertyType.Value, + _localctx.name.Value, + _localctx.arguments.Value, + _localctx.initializer.Value); } } catch (RecognitionException re) { @@ -11355,12 +11568,15 @@ public PropHeadContext propHead() { ErrorHandler.Recover(this, re); } finally { + Actions.EndPropertyHeader(_localctx); ExitRule(); } return _localctx; } public partial class PropAttrContext : ParserRuleContext { + public object Value; + public IToken attribute; public PropAttrContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { @@ -11378,19 +11594,28 @@ public override TResult Accept(IParseTreeVisitor visitor) { public PropAttrContext propAttr() { PropAttrContext _localctx = new PropAttrContext(Context, State); EnterRule(_localctx, 220, RULE_propAttr); - int _la; try { - EnterOuterAlt(_localctx, 1); - { - State = 2235; - _la = TokenStream.LA(1); - if ( !(_la==T__67 || _la==T__68) ) { - ErrorHandler.RecoverInline(this); - } - else { - ErrorHandler.ReportMatch(this); - Consume(); - } + State = 2343; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case T__68: + EnterOuterAlt(_localctx, 1); + { + State = 2339; + _localctx.attribute = Match(T__68); + _localctx.Value = Actions.CreatePropertyAttribute(_localctx.attribute); + } + break; + case T__67: + EnterOuterAlt(_localctx, 2); + { + State = 2341; + _localctx.attribute = Match(T__67); + _localctx.Value = Actions.CreatePropertyAttribute(_localctx.attribute); + } + break; + default: + throw new NoViableAltException(this); } } catch (RecognitionException re) { @@ -11432,17 +11657,17 @@ public PropDeclsContext propDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2240; + State = 2348; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38788988928L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 7493989779944505347L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 2237; + State = 2345; propDecl(); } } - State = 2242; + State = 2350; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11460,6 +11685,10 @@ public PropDeclsContext propDecls() { } public partial class PropDeclContext : ParserRuleContext { + public MethodRefContext accessor; + public CustomAttrDeclContext attribute; + public ExtSourceSpecContext source; + public LanguageDeclContext language; [System.Diagnostics.DebuggerNonUserCode] public MethodRefContext methodRef() { return GetRuleContext(0); } @@ -11493,34 +11722,37 @@ public PropDeclContext propDecl() { PropDeclContext _localctx = new PropDeclContext(Context, State); EnterRule(_localctx, 224, RULE_propDecl); try { - State = 2253; + State = 2373; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__133: EnterOuterAlt(_localctx, 1); { - State = 2243; + State = 2351; Match(T__133); - State = 2244; - methodRef(); + State = 2352; + _localctx.accessor = methodRef(); + Actions.AddPropertySetter(_localctx, _localctx.accessor.Value); } break; case T__134: EnterOuterAlt(_localctx, 2); { - State = 2245; + State = 2355; Match(T__134); - State = 2246; - methodRef(); + State = 2356; + _localctx.accessor = methodRef(); + Actions.AddPropertyGetter(_localctx, _localctx.accessor.Value); } break; case T__131: EnterOuterAlt(_localctx, 3); { - State = 2247; + State = 2359; Match(T__131); - State = 2248; - methodRef(); + State = 2360; + _localctx.accessor = methodRef(); + Actions.AddPropertyOther(_localctx, _localctx.accessor.Value); } break; case T__15: @@ -11532,23 +11764,26 @@ public PropDeclContext propDecl() { case ID: EnterOuterAlt(_localctx, 4); { - State = 2249; - customAttrDecl(); + State = 2363; + _localctx.attribute = customAttrDecl(); + Actions.AddPropertyCustomAttribute(_localctx, _localctx.attribute); } break; case T__72: case T__73: EnterOuterAlt(_localctx, 5); { - State = 2250; - extSourceSpec(); + State = 2366; + _localctx.source = extSourceSpec(); + Actions.ProcessPropertySourceDirective(_localctx.source); } break; case T__26: EnterOuterAlt(_localctx, 6); { - State = 2251; - languageDecl(); + State = 2369; + _localctx.language = languageDecl(); + Actions.ProcessPropertyLanguageDirective(_localctx.language); } break; case T__31: @@ -11561,7 +11796,7 @@ public PropDeclContext propDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 7); { - State = 2252; + State = 2372; compControl(); } break; @@ -11604,7 +11839,7 @@ public MarshalClauseContext marshalClause() { MarshalClauseContext _localctx = new MarshalClauseContext(Context, State); EnterRule(_localctx, 226, RULE_marshalClause); try { - State = 2262; + State = 2382; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -11641,13 +11876,13 @@ public MarshalClauseContext marshalClause() { case T__121: EnterOuterAlt(_localctx, 2); { - State = 2256; + State = 2376; Match(T__121); - State = 2257; + State = 2377; Match(T__29); - State = 2258; + State = 2378; _localctx.value = marshalBlob(); - State = 2259; + State = 2379; Match(T__30); _localctx.Value = Actions.CompleteMarshalClause(_localctx.value.Value); } @@ -11700,7 +11935,7 @@ public MarshalBlobContext marshalBlob() { Actions.BeginMarshalBlob(_localctx); int _la; try { - State = 2277; + State = 2397; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -11755,7 +11990,7 @@ public MarshalBlobContext marshalBlob() { case ID: EnterOuterAlt(_localctx, 1); { - State = 2264; + State = 2384; _localctx.nativeValue = nativeType(); Actions.SetMarshalBlobNativeType(_localctx, _localctx.nativeValue.Value); } @@ -11763,24 +11998,24 @@ public MarshalBlobContext marshalBlob() { case T__16: EnterOuterAlt(_localctx, 2); { - State = 2267; + State = 2387; Match(T__16); - State = 2271; + State = 2391; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2268; + State = 2388; _localctx.rawByte = hexbyte(); Actions.AddMarshalBlobByte(_localctx, _localctx.rawByte.Value); } } - State = 2273; + State = 2393; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( _la==INT32 || _la==ID || _la==HEXBYTE ); - State = 2275; + State = 2395; Match(T__17); } break; @@ -11831,18 +12066,18 @@ public ParamAttrContext paramAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 2284; + State = 2404; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__41) { { { - State = 2279; + State = 2399; _localctx.element = paramAttrElement(); Actions.AddParameterAttribute(_localctx, _localctx.element); } } - State = 2286; + State = 2406; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11886,17 +12121,17 @@ public ParamAttrElementContext paramAttrElement() { ParamAttrElementContext _localctx = new ParamAttrElementContext(Context, State); EnterRule(_localctx, 232, RULE_paramAttrElement); try { - State = 2304; + State = 2424; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,111,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,113,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2287; + State = 2407; Match(T__41); - State = 2288; + State = 2408; _localctx.attribute = Match(T__135); - State = 2289; + State = 2409; Match(T__42); Actions.SetParameterAttributeElement(_localctx, _localctx.attribute); } @@ -11904,11 +12139,11 @@ public ParamAttrElementContext paramAttrElement() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2291; + State = 2411; Match(T__41); - State = 2292; + State = 2412; _localctx.attribute = Match(T__136); - State = 2293; + State = 2413; Match(T__42); Actions.SetParameterAttributeElement(_localctx, _localctx.attribute); } @@ -11916,11 +12151,11 @@ public ParamAttrElementContext paramAttrElement() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2295; + State = 2415; Match(T__41); - State = 2296; + State = 2416; _localctx.attribute = Match(T__137); - State = 2297; + State = 2417; Match(T__42); Actions.SetParameterAttributeElement(_localctx, _localctx.attribute); } @@ -11928,11 +12163,11 @@ public ParamAttrElementContext paramAttrElement() { case 4: EnterOuterAlt(_localctx, 4); { - State = 2299; + State = 2419; Match(T__41); - State = 2300; + State = 2420; _localctx.raw = int32(); - State = 2301; + State = 2421; Match(T__42); Actions.SetRawParameterAttributeElement(_localctx, (_localctx.raw!=null?(_localctx.raw.Start):null)); } @@ -11951,6 +12186,17 @@ public ParamAttrElementContext paramAttrElement() { } public partial class MethodHeadContext : ParserRuleContext { + public object Value; + public MethAttrContext attribute; + public PinvImplContext pInvoke; + public CallConvContext convention; + public ParamAttrContext returnAttributes; + public TypeContext returnType; + public MarshalClauseContext returnMarshalling; + public MethodNameContext name; + public TyparsClauseContext genericParameters; + public SigArgsContext arguments; + public ImplAttrContext implementation; [System.Diagnostics.DebuggerNonUserCode] public CallConvContext callConv() { return GetRuleContext(0); } @@ -12007,19 +12253,19 @@ public override TResult Accept(IParseTreeVisitor visitor) { public MethodHeadContext methodHead() { MethodHeadContext _localctx = new MethodHeadContext(Context, State); EnterRule(_localctx, 234, RULE_methodHead); - BeginSubtree(); + BeginStreaming(); Actions.BeginMethodHeader(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2306; + State = 2426; Match(T__138); - State = 2311; + State = 2435; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & 978955L) != 0) || ((((_la - 123)) & ~0x3f) == 0 && ((1L << (_la - 123)) & 33423365L) != 0)) { { - State = 2309; + State = 2433; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__50: @@ -12042,55 +12288,67 @@ public MethodHeadContext methodHead() { case T__144: case T__145: { - State = 2307; - methAttr(); + State = 2427; + _localctx.attribute = methAttr(); + Actions.AddMethodAttribute(_localctx, _localctx.attribute.Value); } break; case T__146: { - State = 2308; - pinvImpl(); + State = 2430; + _localctx.pInvoke = pinvImpl(); + Actions.AddPInvoke(_localctx, _localctx.pInvoke.Value); } break; default: throw new NoViableAltException(this); } } - State = 2313; + State = 2437; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2314; - callConv(); - State = 2315; - paramAttr(); - State = 2316; - type(); - State = 2317; - marshalClause(); - State = 2318; - methodName(); - State = 2319; - typarsClause(); - State = 2320; - sigArgs(); - State = 2324; + State = 2438; + _localctx.convention = callConv(); + State = 2439; + _localctx.returnAttributes = paramAttr(); + State = 2440; + _localctx.returnType = type(); + State = 2441; + _localctx.returnMarshalling = marshalClause(); + State = 2442; + _localctx.name = methodName(); + State = 2443; + _localctx.genericParameters = typarsClause(); + State = 2444; + _localctx.arguments = sigArgs(); + State = 2450; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 32766L) != 0) || _la==T__69 || _la==T__155 || _la==UNMANAGED) { { { - State = 2321; - implAttr(); + State = 2445; + _localctx.implementation = implAttr(); + Actions.AddMethodImplementationAttribute(_localctx, _localctx.implementation.Value); } } - State = 2326; + State = 2452; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } + _localctx.Value = Actions.CreateMethodHeader( + _localctx, + _localctx.convention.Value, + _localctx.returnAttributes.Value, + _localctx.returnType.Value, + _localctx.returnMarshalling.Value, + _localctx.name.Value, + _localctx.genericParameters.Value, + _localctx.arguments.Value); } Context.Stop = TokenStream.LT(-1); - Actions.BeginMethod(_localctx); + Actions.BeginMethod(_localctx, _localctx.Value); } catch (RecognitionException re) { _localctx.exception = re; @@ -12098,13 +12356,16 @@ public MethodHeadContext methodHead() { ErrorHandler.Recover(this, re); } finally { - EndParseTreeMode(); + Actions.EndMethodHeader(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; } public partial class MethAttrContext : ParserRuleContext { + public object Value; + public IToken attribute; + public Int32Context flags; [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); } @@ -12126,146 +12387,165 @@ public MethAttrContext methAttr() { MethAttrContext _localctx = new MethAttrContext(Context, State); EnterRule(_localctx, 236, RULE_methAttr); try { - State = 2350; + State = 2497; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__122: EnterOuterAlt(_localctx, 1); { - State = 2327; - Match(T__122); + State = 2455; + _localctx.attribute = Match(T__122); + _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } break; case T__50: EnterOuterAlt(_localctx, 2); { - State = 2328; - Match(T__50); + State = 2457; + _localctx.attribute = Match(T__50); + _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } break; case T__51: EnterOuterAlt(_localctx, 3); { - State = 2329; - Match(T__51); + State = 2459; + _localctx.attribute = Match(T__51); + _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } break; case T__62: EnterOuterAlt(_localctx, 4); { - State = 2330; - Match(T__62); + State = 2461; + _localctx.attribute = Match(T__62); + _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } break; case T__139: EnterOuterAlt(_localctx, 5); { - State = 2331; - Match(T__139); + State = 2463; + _localctx.attribute = Match(T__139); + _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } break; case T__67: EnterOuterAlt(_localctx, 6); { - State = 2332; - Match(T__67); + State = 2465; + _localctx.attribute = Match(T__67); + _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } break; case T__140: EnterOuterAlt(_localctx, 7); { - State = 2333; - Match(T__140); + State = 2467; + _localctx.attribute = Match(T__140); + _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } break; case T__141: EnterOuterAlt(_localctx, 8); { - State = 2334; - Match(T__141); + State = 2469; + _localctx.attribute = Match(T__141); + _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } break; case T__53: EnterOuterAlt(_localctx, 9); { - State = 2335; - Match(T__53); + State = 2471; + _localctx.attribute = Match(T__53); + _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } break; case T__63: EnterOuterAlt(_localctx, 10); { - State = 2336; - Match(T__63); + State = 2473; + _localctx.attribute = Match(T__63); + _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } break; case T__64: EnterOuterAlt(_localctx, 11); { - State = 2337; - Match(T__64); + State = 2475; + _localctx.attribute = Match(T__64); + _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } break; case T__65: EnterOuterAlt(_localctx, 12); { - State = 2338; - Match(T__65); + State = 2477; + _localctx.attribute = Match(T__65); + _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } break; case T__124: EnterOuterAlt(_localctx, 13); { - State = 2339; - Match(T__124); + State = 2479; + _localctx.attribute = Match(T__124); + _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } break; case T__142: EnterOuterAlt(_localctx, 14); { - State = 2340; - Match(T__142); + State = 2481; + _localctx.attribute = Match(T__142); + _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } break; case T__143: EnterOuterAlt(_localctx, 15); { - State = 2341; - Match(T__143); + State = 2483; + _localctx.attribute = Match(T__143); + _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } break; case T__68: EnterOuterAlt(_localctx, 16); { - State = 2342; - Match(T__68); + State = 2485; + _localctx.attribute = Match(T__68); + _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } break; case T__144: EnterOuterAlt(_localctx, 17); { - State = 2343; - Match(T__144); + State = 2487; + _localctx.attribute = Match(T__144); + _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } break; case T__145: EnterOuterAlt(_localctx, 18); { - State = 2344; - Match(T__145); + State = 2489; + _localctx.attribute = Match(T__145); + _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } break; case T__69: EnterOuterAlt(_localctx, 19); { - State = 2345; + State = 2491; Match(T__69); - State = 2346; + State = 2492; Match(T__29); - State = 2347; - int32(); - State = 2348; + State = 2493; + _localctx.flags = int32(); + State = 2494; Match(T__30); + _localctx.Value = Actions.CreateRawMethodAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } break; default: @@ -12284,6 +12564,10 @@ public MethAttrContext methAttr() { } public partial class PinvImplContext : ParserRuleContext { + public object Value; + public CompQstringContext module; + public CompQstringContext entryPoint; + public PinvAttrContext attribute; [System.Diagnostics.DebuggerNonUserCode] public CompQstringContext[] compQstring() { return GetRuleContexts(); } @@ -12313,64 +12597,68 @@ public override TResult Accept(IParseTreeVisitor visitor) { public PinvImplContext pinvImpl() { PinvImplContext _localctx = new PinvImplContext(Context, State); EnterRule(_localctx, 238, RULE_pinvImpl); + Actions.BeginPInvoke(_localctx); int _la; try { - State = 2370; + State = 2522; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,119,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,121,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2352; + State = 2499; Match(T__146); - State = 2353; + State = 2500; Match(T__29); - State = 2359; + State = 2509; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==QSTRING) { { - State = 2354; - compQstring(); - State = 2357; + State = 2501; + _localctx.module = compQstring(); + Actions.SetPInvokeModule(_localctx, _localctx.module.Value); + State = 2507; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__33) { { - State = 2355; + State = 2503; Match(T__33); - State = 2356; - compQstring(); + State = 2504; + _localctx.entryPoint = compQstring(); + Actions.SetPInvokeEntryPoint(_localctx, _localctx.entryPoint.Value); } } } } - State = 2364; + State = 2516; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 57)) & ~0x3f) == 0 && ((1L << (_la - 57)) & 8195L) != 0) || ((((_la - 148)) & ~0x3f) == 0 && ((1L << (_la - 148)) & 79L) != 0) || ((((_la - 224)) & ~0x3f) == 0 && ((1L << (_la - 224)) & 251658241L) != 0)) { { { - State = 2361; - pinvAttr(); + State = 2511; + _localctx.attribute = pinvAttr(); + Actions.AddPInvokeAttribute(_localctx, _localctx.attribute.Value); } } - State = 2366; + State = 2518; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2367; + State = 2519; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2368; + State = 2520; Match(T__146); - State = 2369; + State = 2521; Match(T__84); } break; @@ -12382,12 +12670,17 @@ public PinvImplContext pinvImpl() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndPInvoke(_localctx); ExitRule(); } return _localctx; } public partial class PinvAttrContext : ParserRuleContext { + public object Value; + public IToken attribute; + public IToken setting; + public Int32Context flags; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ANSI() { return GetToken(CILParser.ANSI, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CDECL() { return GetToken(CILParser.CDECL, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STDCALL() { return GetToken(CILParser.STDCALL, 0); } @@ -12414,134 +12707,149 @@ public PinvAttrContext pinvAttr() { PinvAttrContext _localctx = new PinvAttrContext(Context, State); EnterRule(_localctx, 240, RULE_pinvAttr); try { - State = 2399; + State = 2566; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,120,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,122,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2372; - Match(T__147); + State = 2524; + _localctx.attribute = Match(T__147); + _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2373; - Match(ANSI); + State = 2526; + _localctx.attribute = Match(ANSI); + _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2374; - Match(T__56); + State = 2528; + _localctx.attribute = Match(T__56); + _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2375; - Match(T__57); + State = 2530; + _localctx.attribute = Match(T__57); + _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2376; - Match(T__148); + State = 2532; + _localctx.attribute = Match(T__148); + _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2377; - Match(T__149); + State = 2534; + _localctx.attribute = Match(T__149); + _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2378; - Match(CDECL); + State = 2536; + _localctx.attribute = Match(CDECL); + _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2379; - Match(STDCALL); + State = 2538; + _localctx.attribute = Match(STDCALL); + _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2380; - Match(THISCALL); + State = 2540; + _localctx.attribute = Match(THISCALL); + _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2381; - Match(FASTCALL); + State = 2542; + _localctx.attribute = Match(FASTCALL); + _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2382; + State = 2544; Match(T__150); - State = 2383; + State = 2545; Match(T__74); - State = 2384; - Match(T__151); + State = 2546; + _localctx.setting = Match(T__151); + _localctx.Value = Actions.CreateBestFitPInvokeAttribute(_localctx.setting); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2385; + State = 2548; Match(T__150); - State = 2386; + State = 2549; Match(T__74); - State = 2387; - Match(T__152); + State = 2550; + _localctx.setting = Match(T__152); + _localctx.Value = Actions.CreateBestFitPInvokeAttribute(_localctx.setting); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2388; + State = 2552; Match(T__153); - State = 2389; + State = 2553; Match(T__74); - State = 2390; - Match(T__151); + State = 2554; + _localctx.setting = Match(T__151); + _localctx.Value = Actions.CreateCharMapErrorPInvokeAttribute(_localctx.setting); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2391; + State = 2556; Match(T__153); - State = 2392; + State = 2557; Match(T__74); - State = 2393; - Match(T__152); + State = 2558; + _localctx.setting = Match(T__152); + _localctx.Value = Actions.CreateCharMapErrorPInvokeAttribute(_localctx.setting); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2394; + State = 2560; Match(T__69); - State = 2395; + State = 2561; Match(T__29); - State = 2396; - int32(); - State = 2397; + State = 2562; + _localctx.flags = int32(); + State = 2563; Match(T__30); + _localctx.Value = Actions.CreateRawPInvokeAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } break; } @@ -12583,13 +12891,13 @@ public MethodNameContext methodName() { MethodNameContext _localctx = new MethodNameContext(Context, State); EnterRule(_localctx, 242, RULE_methodName); try { - State = 2408; + State = 2575; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__115: EnterOuterAlt(_localctx, 1); { - State = 2401; + State = 2568; _localctx.ctorName = Match(T__115); _localctx.Value = Actions.GetMethodName(_localctx.ctorName); } @@ -12597,7 +12905,7 @@ public MethodNameContext methodName() { case T__154: EnterOuterAlt(_localctx, 2); { - State = 2403; + State = 2570; _localctx.cctorName = Match(T__154); _localctx.Value = Actions.GetMethodName(_localctx.cctorName); } @@ -12610,7 +12918,7 @@ public MethodNameContext methodName() { case ID: EnterOuterAlt(_localctx, 3); { - State = 2405; + State = 2572; _localctx.dotted = dottedName(); _localctx.Value = _localctx.dotted.Value; } @@ -12631,6 +12939,9 @@ public MethodNameContext methodName() { } public partial class ImplAttrContext : ParserRuleContext { + public object Value; + public IToken attribute; + public Int32Context flags; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UNMANAGED() { return GetToken(CILParser.UNMANAGED, 0); } [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); @@ -12653,132 +12964,149 @@ public ImplAttrContext implAttr() { ImplAttrContext _localctx = new ImplAttrContext(Context, State); EnterRule(_localctx, 244, RULE_implAttr); try { - State = 2431; + State = 2615; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: EnterOuterAlt(_localctx, 1); { - State = 2410; - Match(T__0); + State = 2577; + _localctx.attribute = Match(T__0); + _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } break; case T__1: EnterOuterAlt(_localctx, 2); { - State = 2411; - Match(T__1); + State = 2579; + _localctx.attribute = Match(T__1); + _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } break; case T__155: EnterOuterAlt(_localctx, 3); { - State = 2412; - Match(T__155); + State = 2581; + _localctx.attribute = Match(T__155); + _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } break; case T__2: EnterOuterAlt(_localctx, 4); { - State = 2413; - Match(T__2); + State = 2583; + _localctx.attribute = Match(T__2); + _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } break; case T__3: EnterOuterAlt(_localctx, 5); { - State = 2414; - Match(T__3); + State = 2585; + _localctx.attribute = Match(T__3); + _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } break; case UNMANAGED: EnterOuterAlt(_localctx, 6); { - State = 2415; - Match(UNMANAGED); + State = 2587; + _localctx.attribute = Match(UNMANAGED); + _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } break; case T__4: EnterOuterAlt(_localctx, 7); { - State = 2416; - Match(T__4); + State = 2589; + _localctx.attribute = Match(T__4); + _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } break; case T__5: EnterOuterAlt(_localctx, 8); { - State = 2417; - Match(T__5); + State = 2591; + _localctx.attribute = Match(T__5); + _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } break; case T__6: EnterOuterAlt(_localctx, 9); { - State = 2418; - Match(T__6); + State = 2593; + _localctx.attribute = Match(T__6); + _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } break; case T__7: EnterOuterAlt(_localctx, 10); { - State = 2419; - Match(T__7); + State = 2595; + _localctx.attribute = Match(T__7); + _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } break; case T__8: EnterOuterAlt(_localctx, 11); { - State = 2420; - Match(T__8); + State = 2597; + _localctx.attribute = Match(T__8); + _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } break; case T__9: EnterOuterAlt(_localctx, 12); { - State = 2421; - Match(T__9); + State = 2599; + _localctx.attribute = Match(T__9); + _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } break; case T__10: EnterOuterAlt(_localctx, 13); { - State = 2422; - Match(T__10); + State = 2601; + _localctx.attribute = Match(T__10); + _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } break; case T__11: EnterOuterAlt(_localctx, 14); { - State = 2423; - Match(T__11); + State = 2603; + _localctx.attribute = Match(T__11); + _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } break; case T__12: EnterOuterAlt(_localctx, 15); { - State = 2424; - Match(T__12); + State = 2605; + _localctx.attribute = Match(T__12); + _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } break; case T__13: EnterOuterAlt(_localctx, 16); { - State = 2425; - Match(T__13); + State = 2607; + _localctx.attribute = Match(T__13); + _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } break; case T__69: EnterOuterAlt(_localctx, 17); { - State = 2426; + State = 2609; Match(T__69); - State = 2427; + State = 2610; Match(T__29); - State = 2428; - int32(); - State = 2429; + State = 2611; + _localctx.flags = int32(); + State = 2612; Match(T__30); + _localctx.Value = Actions.CreateRawMethodImplementationAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } break; default: @@ -12825,17 +13153,17 @@ public MethodDeclsContext methodDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2436; + State = 2620; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38789119998L) != 0) || _la==T__72 || _la==T__73 || ((((_la - 158)) & ~0x3f) == 0 && ((1L << (_la - 158)) & 2199023255681L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 2303696760354115601L) != 0)) { { { - State = 2433; + State = 2617; methodDecl(); } } - State = 2438; + State = 2622; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -12930,7 +13258,7 @@ public MethodDeclContext methodDecl() { MethodDeclContext _localctx = new MethodDeclContext(Context, State); EnterRule(_localctx, 248, RULE_methodDecl); try { - State = 2476; + State = 2660; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case INSTR_NONE: @@ -12948,16 +13276,16 @@ public MethodDeclContext methodDecl() { case INSTR_TOK: EnterOuterAlt(_localctx, 1); { - State = 2439; + State = 2623; instr(); } break; case EMITBYTE: EnterOuterAlt(_localctx, 2); { - State = 2440; + State = 2624; Match(EMITBYTE); - State = 2441; + State = 2625; _localctx.value = int32(); Actions.EmitByte((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -12965,16 +13293,16 @@ public MethodDeclContext methodDecl() { case T__157: EnterOuterAlt(_localctx, 3); { - State = 2444; + State = 2628; sehBlock(); } break; case MAXSTACK: EnterOuterAlt(_localctx, 4); { - State = 2445; + State = 2629; Match(MAXSTACK); - State = 2446; + State = 2630; _localctx.value = int32(); Actions.SetMaxStack((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -12982,7 +13310,7 @@ public MethodDeclContext methodDecl() { case ENTRYPOINT: EnterOuterAlt(_localctx, 5); { - State = 2449; + State = 2633; Match(ENTRYPOINT); Actions.SetEntryPoint(); } @@ -12990,7 +13318,7 @@ public MethodDeclContext methodDecl() { case ZEROINIT: EnterOuterAlt(_localctx, 6); { - State = 2451; + State = 2635; Match(ZEROINIT); Actions.SetZeroInit(); } @@ -13017,28 +13345,28 @@ public MethodDeclContext methodDecl() { case ID: EnterOuterAlt(_localctx, 7); { - State = 2453; + State = 2637; labelDecl(); } break; case T__16: EnterOuterAlt(_localctx, 8); { - State = 2454; + State = 2638; scopeBlock(); } break; case LOCALS: EnterOuterAlt(_localctx, 9); { - State = 2455; + State = 2639; localsDecl(); } break; case T__164: EnterOuterAlt(_localctx, 10); { - State = 2456; + State = 2640; _localctx.declaration = dataDecl(); Actions.ProcessMethodDataDeclaration(_localctx.declaration); } @@ -13047,7 +13375,7 @@ public MethodDeclContext methodDecl() { case PERMISSIONSET: EnterOuterAlt(_localctx, 11); { - State = 2459; + State = 2643; _localctx.security = secDecl(); Actions.ProcessMethodSecurityDeclaration(_localctx.security); } @@ -13056,7 +13384,7 @@ public MethodDeclContext methodDecl() { case T__73: EnterOuterAlt(_localctx, 12); { - State = 2462; + State = 2646; _localctx.source = extSourceSpec(); Actions.ProcessMethodSourceDirective(_localctx.source); } @@ -13064,7 +13392,7 @@ public MethodDeclContext methodDecl() { case T__26: EnterOuterAlt(_localctx, 13); { - State = 2465; + State = 2649; _localctx.language = languageDecl(); Actions.ProcessMethodLanguageDirective(_localctx.language); } @@ -13072,7 +13400,7 @@ public MethodDeclContext methodDecl() { case T__34: EnterOuterAlt(_localctx, 14); { - State = 2468; + State = 2652; _localctx.attribute = customDescrInMethodBody(); Actions.ProcessMethodCustomAttribute(_localctx.attribute); } @@ -13087,35 +13415,35 @@ public MethodDeclContext methodDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 15); { - State = 2471; + State = 2655; compControl(); } break; case EXPORT: EnterOuterAlt(_localctx, 16); { - State = 2472; + State = 2656; exportDecl(); } break; case VTENTRY: EnterOuterAlt(_localctx, 17); { - State = 2473; + State = 2657; vtentryDecl(); } break; case OVERRIDE: EnterOuterAlt(_localctx, 18); { - State = 2474; + State = 2658; overrideDecl(); } break; case PARAM: EnterOuterAlt(_localctx, 19); { - State = 2475; + State = 2659; parameterDecl(); } break; @@ -13163,19 +13491,19 @@ public LocalsDeclContext localsDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2478; + State = 2662; Match(LOCALS); - State = 2480; + State = 2664; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__156) { { - State = 2479; + State = 2663; _localctx.initialize = Match(T__156); } } - State = 2482; + State = 2666; _localctx.arguments = sigArgs(); } } @@ -13223,22 +13551,22 @@ public ExportDeclContext exportDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2484; + State = 2668; Match(EXPORT); - State = 2485; + State = 2669; Match(T__41); - State = 2486; + State = 2670; _localctx.ordinal = int32(); - State = 2487; + State = 2671; Match(T__42); - State = 2490; + State = 2674; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__33) { { - State = 2488; + State = 2672; Match(T__33); - State = 2489; + State = 2673; _localctx.alias = id(); } } @@ -13288,13 +13616,13 @@ public VtentryDeclContext vtentryDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2492; + State = 2676; Match(VTENTRY); - State = 2493; + State = 2677; _localctx.table = int32(); - State = 2494; + State = 2678; Match(T__74); - State = 2495; + State = 2679; _localctx.slot = int32(); } } @@ -13357,42 +13685,42 @@ public OverrideDeclContext overrideDecl() { EnterRule(_localctx, 256, RULE_overrideDecl); Actions.BeginSemanticRoot(_localctx); try { - State = 2512; + State = 2696; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,127,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,129,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2497; + State = 2681; Match(OVERRIDE); - State = 2498; + State = 2682; _localctx.owner = typeSpec(); - State = 2499; + State = 2683; Match(DCOLON); - State = 2500; + State = 2684; _localctx.name = methodName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2502; + State = 2686; Match(OVERRIDE); - State = 2503; + State = 2687; Match(METHOD); - State = 2504; + State = 2688; _localctx.convention = callConv(); - State = 2505; + State = 2689; _localctx.returnType = type(); - State = 2506; + State = 2690; _localctx.owner = typeSpec(); - State = 2507; + State = 2691; Match(DCOLON); - State = 2508; + State = 2692; _localctx.name = methodName(); - State = 2509; + State = 2693; _localctx.arity = genArity(); - State = 2510; + State = 2694; _localctx.arguments = sigArgs(); } break; @@ -13460,166 +13788,166 @@ public ParameterDeclContext parameterDecl() { Actions.BeginParameterDirective(_localctx); try { int _alt; - State = 2579; + State = 2763; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,133,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,135,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2514; + State = 2698; Match(PARAM); - State = 2515; + State = 2699; Match(TYPE); - State = 2516; + State = 2700; Match(T__41); - State = 2517; + State = 2701; _localctx.genericIndex = int32(); - State = 2518; + State = 2702; Match(T__42); - State = 2524; + State = 2708; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,128,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,130,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2519; + State = 2703; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2526; + State = 2710; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,128,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,130,Context); } } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2527; + State = 2711; Match(PARAM); - State = 2528; + State = 2712; Match(TYPE); - State = 2529; + State = 2713; _localctx.genericName = dottedName(); - State = 2535; + State = 2719; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,129,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,131,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2530; + State = 2714; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2537; + State = 2721; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,129,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,131,Context); } } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2538; + State = 2722; Match(PARAM); - State = 2539; + State = 2723; Match(CONSTRAINT); - State = 2540; + State = 2724; Match(T__41); - State = 2541; + State = 2725; _localctx.constraintIndex = int32(); - State = 2542; + State = 2726; Match(T__42); - State = 2543; + State = 2727; Match(T__27); - State = 2544; + State = 2728; _localctx.constraintType = typeSpec(); - State = 2550; + State = 2734; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,130,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,132,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2545; + State = 2729; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2552; + State = 2736; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,130,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,132,Context); } } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2553; + State = 2737; Match(PARAM); - State = 2554; + State = 2738; Match(CONSTRAINT); - State = 2555; + State = 2739; _localctx.constraintName = dottedName(); - State = 2556; + State = 2740; Match(T__27); - State = 2557; + State = 2741; _localctx.constraintType = typeSpec(); - State = 2563; + State = 2747; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,131,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,133,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2558; + State = 2742; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2565; + State = 2749; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,131,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,133,Context); } } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2566; + State = 2750; Match(PARAM); - State = 2567; + State = 2751; Match(T__41); - State = 2568; + State = 2752; _localctx.parameterIndex = int32(); - State = 2569; + State = 2753; Match(T__42); - State = 2570; + State = 2754; _localctx.initializer = initOpt(); - State = 2576; + State = 2760; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,132,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,134,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2571; + State = 2755; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2578; + State = 2762; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,132,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,134,Context); } } break; @@ -13662,9 +13990,9 @@ public LabelDeclContext labelDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2581; + State = 2765; _localctx.name = id(); - State = 2582; + State = 2766; Match(T__74); Actions.DefineLabel((_localctx.name!=null?(_localctx.name.Start):null)); } @@ -13707,20 +14035,20 @@ public CustomDescrInMethodBodyContext customDescrInMethodBody() { EnterRule(_localctx, 262, RULE_customDescrInMethodBody); BeginSubtree(); Actions.BeginSemanticRoot(_localctx); try { - State = 2587; + State = 2771; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,134,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,136,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2585; + State = 2769; customDescr(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2586; + State = 2770; customDescrWithOwner(); } break; @@ -13763,11 +14091,11 @@ public ScopeBlockContext scopeBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 2589; + State = 2773; Match(T__16); - State = 2590; + State = 2774; methodDecls(); - State = 2591; + State = 2775; Match(T__17); } } @@ -13813,9 +14141,9 @@ public SehBlockContext sehBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 2593; + State = 2777; _localctx.tryRange = tryBlock(); - State = 2594; + State = 2778; _localctx.clauses = sehClauses(); } } @@ -13862,18 +14190,18 @@ public SehClausesContext sehClauses() { try { EnterOuterAlt(_localctx, 1); { - State = 2599; + State = 2783; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2596; + State = 2780; _localctx.clause = sehClause(); Actions.AddExceptionClause(_localctx, _localctx.clause.Value); } } - State = 2601; + State = 2785; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( ((((_la - 160)) & ~0x3f) == 0 && ((1L << (_la - 160)) & 15L) != 0) ); @@ -13931,15 +14259,15 @@ public TryBlockContext tryBlock() { TryBlockContext _localctx = new TryBlockContext(Context, State); EnterRule(_localctx, 270, RULE_tryBlock); try { - State = 2619; + State = 2803; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,136,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,138,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2603; + State = 2787; Match(T__157); - State = 2604; + State = 2788; _localctx.body = scopeBlock(); _localctx.Value = Actions.CreateScopeExceptionRange(_localctx.body); } @@ -13947,13 +14275,13 @@ public TryBlockContext tryBlock() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2607; + State = 2791; Match(T__157); - State = 2608; + State = 2792; _localctx.startLabel = id(); - State = 2609; + State = 2793; Match(T__158); - State = 2610; + State = 2794; _localctx.endLabel = id(); _localctx.Value = Actions.CreateLabelExceptionRange((_localctx.startLabel!=null?(_localctx.startLabel.Start):null), (_localctx.endLabel!=null?(_localctx.endLabel.Start):null)); } @@ -13961,13 +14289,13 @@ public TryBlockContext tryBlock() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2613; + State = 2797; Match(T__157); - State = 2614; + State = 2798; _localctx.startOffset = int32(); - State = 2615; + State = 2799; Match(T__158); - State = 2616; + State = 2800; _localctx.endOffset = int32(); _localctx.Value = Actions.CreateOffsetExceptionRange((_localctx.startOffset!=null?(_localctx.startOffset.Start):null), (_localctx.endOffset!=null?(_localctx.endOffset.Start):null)); } @@ -14023,15 +14351,15 @@ public SehClauseContext sehClause() { SehClauseContext _localctx = new SehClauseContext(Context, State); EnterRule(_localctx, 272, RULE_sehClause); try { - State = 2637; + State = 2821; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__160: EnterOuterAlt(_localctx, 1); { - State = 2621; + State = 2805; _localctx.caught = catchClause(); - State = 2622; + State = 2806; _localctx.handler = handlerBlock(); _localctx.Value = Actions.CreateCatchExceptionClause(_localctx.caught.Value, _localctx.handler.Value); } @@ -14039,9 +14367,9 @@ public SehClauseContext sehClause() { case T__159: EnterOuterAlt(_localctx, 2); { - State = 2625; + State = 2809; _localctx.filtered = filterClause(); - State = 2626; + State = 2810; _localctx.handler = handlerBlock(); _localctx.Value = Actions.CreateFilterExceptionClause(_localctx.filtered.Value, _localctx.handler.Value); } @@ -14049,9 +14377,9 @@ public SehClauseContext sehClause() { case T__161: EnterOuterAlt(_localctx, 3); { - State = 2629; + State = 2813; finallyClause(); - State = 2630; + State = 2814; _localctx.handler = handlerBlock(); _localctx.Value = Actions.CreateFinallyExceptionClause(_localctx.handler.Value); } @@ -14059,9 +14387,9 @@ public SehClauseContext sehClause() { case T__162: EnterOuterAlt(_localctx, 4); { - State = 2633; + State = 2817; faultClause(); - State = 2634; + State = 2818; _localctx.handler = handlerBlock(); _localctx.Value = Actions.CreateFaultExceptionClause(_localctx.handler.Value); } @@ -14113,15 +14441,15 @@ public FilterClauseContext filterClause() { FilterClauseContext _localctx = new FilterClauseContext(Context, State); EnterRule(_localctx, 274, RULE_filterClause); try { - State = 2651; + State = 2835; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,138,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,140,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2639; + State = 2823; Match(T__159); - State = 2640; + State = 2824; _localctx.body = scopeBlock(); _localctx.Value = Actions.CreateScopeFilter(_localctx.body); } @@ -14129,9 +14457,9 @@ public FilterClauseContext filterClause() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2643; + State = 2827; Match(T__159); - State = 2644; + State = 2828; _localctx.label = id(); _localctx.Value = Actions.CreateLabelFilter((_localctx.label!=null?(_localctx.label.Start):null)); } @@ -14139,9 +14467,9 @@ public FilterClauseContext filterClause() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2647; + State = 2831; Match(T__159); - State = 2648; + State = 2832; _localctx.offset = int32(); _localctx.Value = Actions.CreateOffsetFilter((_localctx.offset!=null?(_localctx.offset.Start):null)); } @@ -14186,9 +14514,9 @@ public CatchClauseContext catchClause() { try { EnterOuterAlt(_localctx, 1); { - State = 2653; + State = 2837; Match(T__160); - State = 2654; + State = 2838; _localctx.catchType = typeSpec(); } } @@ -14225,7 +14553,7 @@ public FinallyClauseContext finallyClause() { try { EnterOuterAlt(_localctx, 1); { - State = 2656; + State = 2840; Match(T__161); } } @@ -14261,7 +14589,7 @@ public FaultClauseContext faultClause() { try { EnterOuterAlt(_localctx, 1); { - State = 2658; + State = 2842; Match(T__162); } } @@ -14316,13 +14644,13 @@ public HandlerBlockContext handlerBlock() { HandlerBlockContext _localctx = new HandlerBlockContext(Context, State); EnterRule(_localctx, 282, RULE_handlerBlock); try { - State = 2675; + State = 2859; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,139,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,141,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2660; + State = 2844; _localctx.body = scopeBlock(); _localctx.Value = Actions.CreateScopeExceptionRange(_localctx.body); } @@ -14330,13 +14658,13 @@ public HandlerBlockContext handlerBlock() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2663; + State = 2847; Match(T__163); - State = 2664; + State = 2848; _localctx.startLabel = id(); - State = 2665; + State = 2849; Match(T__158); - State = 2666; + State = 2850; _localctx.endLabel = id(); _localctx.Value = Actions.CreateLabelExceptionRange((_localctx.startLabel!=null?(_localctx.startLabel.Start):null), (_localctx.endLabel!=null?(_localctx.endLabel.Start):null)); } @@ -14344,13 +14672,13 @@ public HandlerBlockContext handlerBlock() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2669; + State = 2853; Match(T__163); - State = 2670; + State = 2854; _localctx.startOffset = int32(); - State = 2671; + State = 2855; Match(T__158); - State = 2672; + State = 2856; _localctx.endOffset = int32(); _localctx.Value = Actions.CreateOffsetExceptionRange((_localctx.startOffset!=null?(_localctx.startOffset.Start):null), (_localctx.endOffset!=null?(_localctx.endOffset.Start):null)); } @@ -14397,9 +14725,9 @@ public DataDeclContext dataDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2677; + State = 2861; ddHead(); - State = 2678; + State = 2862; ddBody(); } } @@ -14440,28 +14768,28 @@ public DdHeadContext ddHead() { DdHeadContext _localctx = new DdHeadContext(Context, State); EnterRule(_localctx, 286, RULE_ddHead); try { - State = 2687; + State = 2871; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,140,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,142,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2680; + State = 2864; Match(T__164); - State = 2681; + State = 2865; tls(); - State = 2682; + State = 2866; id(); - State = 2683; + State = 2867; Match(T__35); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2685; + State = 2869; Match(T__164); - State = 2686; + State = 2870; tls(); } break; @@ -14497,9 +14825,9 @@ public TlsContext tls() { TlsContext _localctx = new TlsContext(Context, State); EnterRule(_localctx, 288, RULE_tls); try { - State = 2692; + State = 2876; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,141,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,143,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -14508,14 +14836,14 @@ public TlsContext tls() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2690; + State = 2874; Match(T__165); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2691; + State = 2875; Match(T__1); } break; @@ -14561,17 +14889,17 @@ public DdBodyContext ddBody() { EnterRule(_localctx, 290, RULE_ddBody); int _la; try { - State = 2703; + State = 2887; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: EnterOuterAlt(_localctx, 1); { - State = 2694; + State = 2878; Match(T__16); - State = 2695; + State = 2879; ddItemList(); - State = 2696; + State = 2880; Match(T__17); } break; @@ -14586,17 +14914,17 @@ public DdBodyContext ddBody() { case REF: EnterOuterAlt(_localctx, 2); { - State = 2699; + State = 2883; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2698; + State = 2882; ddItem(); } } - State = 2701; + State = 2885; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( _la==T__83 || ((((_la - 181)) & ~0x3f) == 0 && ((1L << (_la - 181)) & 505L) != 0) || _la==REF ); @@ -14645,25 +14973,25 @@ public DdItemListContext ddItemList() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 2710; + State = 2894; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,144,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,146,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2705; + State = 2889; ddItem(); - State = 2706; + State = 2890; Match(T__27); } } } - State = 2712; + State = 2896; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,144,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,146,Context); } - State = 2713; + State = 2897; ddItem(); } } @@ -14700,7 +15028,7 @@ public DdItemCountContext ddItemCount() { DdItemCountContext _localctx = new DdItemCountContext(Context, State); EnterRule(_localctx, 294, RULE_ddItemCount); try { - State = 2720; + State = 2904; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -14804,11 +15132,11 @@ public DdItemCountContext ddItemCount() { case T__41: EnterOuterAlt(_localctx, 2); { - State = 2716; + State = 2900; Match(T__41); - State = 2717; + State = 2901; int32(); - State = 2718; + State = 2902; Match(T__42); } break; @@ -14876,200 +15204,200 @@ public DdItemContext ddItem() { DdItemContext _localctx = new DdItemContext(Context, State); EnterRule(_localctx, 296, RULE_ddItem); try { - State = 2788; + State = 2972; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,146,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,148,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2722; + State = 2906; Match(CHAR); - State = 2723; + State = 2907; Match(PTR); - State = 2724; + State = 2908; Match(T__29); - State = 2725; + State = 2909; compQstring(); - State = 2726; + State = 2910; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2728; + State = 2912; Match(REF); - State = 2729; + State = 2913; Match(T__29); - State = 2730; + State = 2914; id(); - State = 2731; + State = 2915; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2733; + State = 2917; Match(REF); - State = 2734; + State = 2918; id(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2735; + State = 2919; Match(T__83); - State = 2736; + State = 2920; Match(T__29); - State = 2737; + State = 2921; bytes(); - State = 2738; + State = 2922; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2740; + State = 2924; Match(FLOAT32); - State = 2741; + State = 2925; Match(T__29); - State = 2742; + State = 2926; float64(); - State = 2743; + State = 2927; Match(T__30); - State = 2744; + State = 2928; ddItemCount(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2746; + State = 2930; Match(FLOAT64_); - State = 2747; + State = 2931; Match(T__29); - State = 2748; + State = 2932; float64(); - State = 2749; + State = 2933; Match(T__30); - State = 2750; + State = 2934; ddItemCount(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2752; + State = 2936; Match(INT64_); - State = 2753; + State = 2937; Match(T__29); - State = 2754; + State = 2938; int64(); - State = 2755; + State = 2939; Match(T__30); - State = 2756; + State = 2940; ddItemCount(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2758; + State = 2942; Match(INT32_); - State = 2759; + State = 2943; Match(T__29); - State = 2760; + State = 2944; int32(); - State = 2761; + State = 2945; Match(T__30); - State = 2762; + State = 2946; ddItemCount(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2764; + State = 2948; Match(INT16); - State = 2765; + State = 2949; Match(T__29); - State = 2766; + State = 2950; int32(); - State = 2767; + State = 2951; Match(T__30); - State = 2768; + State = 2952; ddItemCount(); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2770; + State = 2954; Match(INT8); - State = 2771; + State = 2955; Match(T__29); - State = 2772; + State = 2956; int32(); - State = 2773; + State = 2957; Match(T__30); - State = 2774; + State = 2958; ddItemCount(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2776; + State = 2960; Match(FLOAT32); - State = 2777; + State = 2961; ddItemCount(); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2778; + State = 2962; Match(FLOAT64_); - State = 2779; + State = 2963; ddItemCount(); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2780; + State = 2964; Match(INT64_); - State = 2781; + State = 2965; ddItemCount(); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2782; + State = 2966; Match(INT32_); - State = 2783; + State = 2967; ddItemCount(); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2784; + State = 2968; Match(INT16); - State = 2785; + State = 2969; ddItemCount(); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 2786; + State = 2970; Match(INT8); - State = 2787; + State = 2971; ddItemCount(); } break; @@ -15132,201 +15460,201 @@ public FieldSerInitContext fieldSerInit() { FieldSerInitContext _localctx = new FieldSerInitContext(Context, State); EnterRule(_localctx, 298, RULE_fieldSerInit); try { - State = 2865; + State = 3049; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,147,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,149,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2790; + State = 2974; Match(FLOAT32); - State = 2791; + State = 2975; Match(T__29); - State = 2792; + State = 2976; float64(); - State = 2793; + State = 2977; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2795; + State = 2979; Match(FLOAT64_); - State = 2796; + State = 2980; Match(T__29); - State = 2797; + State = 2981; float64(); - State = 2798; + State = 2982; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2800; + State = 2984; Match(FLOAT32); - State = 2801; + State = 2985; Match(T__29); - State = 2802; + State = 2986; int32(); - State = 2803; + State = 2987; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2805; + State = 2989; Match(FLOAT64_); - State = 2806; + State = 2990; Match(T__29); - State = 2807; + State = 2991; int64(); - State = 2808; + State = 2992; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2810; + State = 2994; Match(INT64_); - State = 2811; + State = 2995; Match(T__29); - State = 2812; + State = 2996; int64(); - State = 2813; + State = 2997; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2815; + State = 2999; Match(INT32_); - State = 2816; + State = 3000; Match(T__29); - State = 2817; + State = 3001; int32(); - State = 2818; + State = 3002; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2820; + State = 3004; Match(INT16); - State = 2821; + State = 3005; Match(T__29); - State = 2822; + State = 3006; int32(); - State = 2823; + State = 3007; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2825; + State = 3009; Match(INT8); - State = 2826; + State = 3010; Match(T__29); - State = 2827; + State = 3011; int32(); - State = 2828; + State = 3012; Match(T__30); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2830; + State = 3014; Match(UINT64); - State = 2831; + State = 3015; Match(T__29); - State = 2832; + State = 3016; int64(); - State = 2833; + State = 3017; Match(T__30); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2835; + State = 3019; Match(UINT32); - State = 2836; + State = 3020; Match(T__29); - State = 2837; + State = 3021; int32(); - State = 2838; + State = 3022; Match(T__30); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2840; + State = 3024; Match(UINT16); - State = 2841; + State = 3025; Match(T__29); - State = 2842; + State = 3026; int32(); - State = 2843; + State = 3027; Match(T__30); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2845; + State = 3029; Match(UINT8); - State = 2846; + State = 3030; Match(T__29); - State = 2847; + State = 3031; int32(); - State = 2848; + State = 3032; Match(T__30); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2850; + State = 3034; Match(CHAR); - State = 2851; + State = 3035; Match(T__29); - State = 2852; + State = 3036; int32(); - State = 2853; + State = 3037; Match(T__30); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2855; + State = 3039; Match(BOOL); - State = 2856; + State = 3040; Match(T__29); - State = 2857; + State = 3041; truefalse(); - State = 2858; + State = 3042; Match(T__30); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2860; + State = 3044; Match(T__83); - State = 2861; + State = 3045; Match(T__29); - State = 2862; + State = 3046; bytes(); - State = 2863; + State = 3047; Match(T__30); } break; @@ -15374,18 +15702,18 @@ public BytesContext bytes() { try { EnterOuterAlt(_localctx, 1); { - State = 2872; + State = 3056; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32 || _la==ID || _la==HEXBYTE) { { { - State = 2867; + State = 3051; _localctx.b = hexbyte(); Actions.AddByte(_localctx.b.Value); } } - State = 2874; + State = 3058; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15429,7 +15757,7 @@ public HexbyteContext hexbyte() { try { EnterOuterAlt(_localctx, 1); { - State = 2875; + State = 3059; _la = TokenStream.LA(1); if ( !(_la==INT32 || _la==ID || _la==HEXBYTE) ) { ErrorHandler.RecoverInline(this); @@ -15479,7 +15807,7 @@ public FieldInitContext fieldInit() { FieldInitContext _localctx = new FieldInitContext(Context, State); EnterRule(_localctx, 304, RULE_fieldInit); try { - State = 2880; + State = 3064; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__83: @@ -15497,21 +15825,21 @@ public FieldInitContext fieldInit() { case UINT64: EnterOuterAlt(_localctx, 1); { - State = 2877; + State = 3061; fieldSerInit(); } break; case QSTRING: EnterOuterAlt(_localctx, 2); { - State = 2878; + State = 3062; compQstring(); } break; case NULLREF: EnterOuterAlt(_localctx, 3); { - State = 2879; + State = 3063; Match(NULLREF); } break; @@ -15608,378 +15936,378 @@ public SerInitContext serInit() { SerInitContext _localctx = new SerInitContext(Context, State); EnterRule(_localctx, 306, RULE_serInit); try { - State = 3030; + State = 3214; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,150,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,152,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2882; + State = 3066; fieldSerInit(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2883; + State = 3067; Match(STRING); - State = 2884; + State = 3068; Match(T__29); - State = 2885; + State = 3069; Match(NULLREF); - State = 2886; + State = 3070; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2887; + State = 3071; Match(STRING); - State = 2888; + State = 3072; Match(T__29); - State = 2889; + State = 3073; Match(SQSTRING); - State = 2890; + State = 3074; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2891; + State = 3075; Match(TYPE); - State = 2892; + State = 3076; Match(T__29); - State = 2893; + State = 3077; Match(T__38); - State = 2894; + State = 3078; Match(SQSTRING); - State = 2895; + State = 3079; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2896; + State = 3080; Match(TYPE); - State = 2897; + State = 3081; Match(T__29); - State = 2898; + State = 3082; className(); - State = 2899; + State = 3083; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2901; + State = 3085; Match(TYPE); - State = 2902; + State = 3086; Match(T__29); - State = 2903; + State = 3087; Match(NULLREF); - State = 2904; + State = 3088; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2905; + State = 3089; Match(OBJECT); - State = 2906; + State = 3090; Match(T__29); - State = 2907; + State = 3091; serInit(); - State = 2908; + State = 3092; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2910; + State = 3094; Match(FLOAT32); - State = 2911; + State = 3095; Match(T__41); - State = 2912; + State = 3096; int32(); - State = 2913; + State = 3097; Match(T__42); - State = 2914; + State = 3098; Match(T__29); - State = 2915; + State = 3099; f32seq(); - State = 2916; + State = 3100; Match(T__30); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2918; + State = 3102; Match(FLOAT64_); - State = 2919; + State = 3103; Match(T__41); - State = 2920; + State = 3104; int32(); - State = 2921; + State = 3105; Match(T__42); - State = 2922; + State = 3106; Match(T__29); - State = 2923; + State = 3107; f64seq(); - State = 2924; + State = 3108; Match(T__30); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2926; + State = 3110; Match(INT64_); - State = 2927; + State = 3111; Match(T__41); - State = 2928; + State = 3112; int32(); - State = 2929; + State = 3113; Match(T__42); - State = 2930; + State = 3114; Match(T__29); - State = 2931; + State = 3115; i64seq(); - State = 2932; + State = 3116; Match(T__30); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2934; + State = 3118; Match(INT32_); - State = 2935; + State = 3119; Match(T__41); - State = 2936; + State = 3120; int32(); - State = 2937; + State = 3121; Match(T__42); - State = 2938; + State = 3122; Match(T__29); - State = 2939; + State = 3123; i32seq(); - State = 2940; + State = 3124; Match(T__30); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2942; + State = 3126; Match(INT16); - State = 2943; + State = 3127; Match(T__41); - State = 2944; + State = 3128; int32(); - State = 2945; + State = 3129; Match(T__42); - State = 2946; + State = 3130; Match(T__29); - State = 2947; + State = 3131; i16seq(); - State = 2948; + State = 3132; Match(T__30); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2950; + State = 3134; Match(INT8); - State = 2951; + State = 3135; Match(T__41); - State = 2952; + State = 3136; int32(); - State = 2953; + State = 3137; Match(T__42); - State = 2954; + State = 3138; Match(T__29); - State = 2955; + State = 3139; i8seq(); - State = 2956; + State = 3140; Match(T__30); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2958; + State = 3142; Match(UINT64); - State = 2959; + State = 3143; Match(T__41); - State = 2960; + State = 3144; int32(); - State = 2961; + State = 3145; Match(T__42); - State = 2962; + State = 3146; Match(T__29); - State = 2963; + State = 3147; i64seq(); - State = 2964; + State = 3148; Match(T__30); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2966; + State = 3150; Match(UINT32); - State = 2967; + State = 3151; Match(T__41); - State = 2968; + State = 3152; int32(); - State = 2969; + State = 3153; Match(T__42); - State = 2970; + State = 3154; Match(T__29); - State = 2971; + State = 3155; i32seq(); - State = 2972; + State = 3156; Match(T__30); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 2974; + State = 3158; Match(UINT16); - State = 2975; + State = 3159; Match(T__41); - State = 2976; + State = 3160; int32(); - State = 2977; + State = 3161; Match(T__42); - State = 2978; + State = 3162; Match(T__29); - State = 2979; + State = 3163; i16seq(); - State = 2980; + State = 3164; Match(T__30); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 2982; + State = 3166; Match(UINT8); - State = 2983; + State = 3167; Match(T__41); - State = 2984; + State = 3168; int32(); - State = 2985; + State = 3169; Match(T__42); - State = 2986; + State = 3170; Match(T__29); - State = 2987; + State = 3171; i8seq(); - State = 2988; + State = 3172; Match(T__30); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 2990; + State = 3174; Match(CHAR); - State = 2991; + State = 3175; Match(T__41); - State = 2992; + State = 3176; int32(); - State = 2993; + State = 3177; Match(T__42); - State = 2994; + State = 3178; Match(T__29); - State = 2995; + State = 3179; i16seq(); - State = 2996; + State = 3180; Match(T__30); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 2998; + State = 3182; Match(BOOL); - State = 2999; + State = 3183; Match(T__41); - State = 3000; + State = 3184; int32(); - State = 3001; + State = 3185; Match(T__42); - State = 3002; + State = 3186; Match(T__29); - State = 3003; + State = 3187; boolSeq(); - State = 3004; + State = 3188; Match(T__30); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 3006; + State = 3190; Match(STRING); - State = 3007; + State = 3191; Match(T__41); - State = 3008; + State = 3192; int32(); - State = 3009; + State = 3193; Match(T__42); - State = 3010; + State = 3194; Match(T__29); - State = 3011; + State = 3195; sqstringSeq(); - State = 3012; + State = 3196; Match(T__30); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 3014; + State = 3198; Match(TYPE); - State = 3015; + State = 3199; Match(T__41); - State = 3016; + State = 3200; int32(); - State = 3017; + State = 3201; Match(T__42); - State = 3018; + State = 3202; Match(T__29); - State = 3019; + State = 3203; classSeq(); - State = 3020; + State = 3204; Match(T__30); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 3022; + State = 3206; Match(OBJECT); - State = 3023; + State = 3207; Match(T__41); - State = 3024; + State = 3208; int32(); - State = 3025; + State = 3209; Match(T__42); - State = 3026; + State = 3210; Match(T__29); - State = 3027; + State = 3211; objSeq(); - State = 3028; + State = 3212; Match(T__30); } break; @@ -16030,29 +16358,29 @@ public F32seqContext f32seq() { try { EnterOuterAlt(_localctx, 1); { - State = 3036; + State = 3220; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 98309L) != 0)) { { - State = 3034; + State = 3218; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,151,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,153,Context) ) { case 1: { - State = 3032; + State = 3216; float64(); } break; case 2: { - State = 3033; + State = 3217; int32(); } break; } } - State = 3038; + State = 3222; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16103,29 +16431,29 @@ public F64seqContext f64seq() { try { EnterOuterAlt(_localctx, 1); { - State = 3043; + State = 3227; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 98311L) != 0)) { { - State = 3041; + State = 3225; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,153,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,155,Context) ) { case 1: { - State = 3039; + State = 3223; float64(); } break; case 2: { - State = 3040; + State = 3224; int64(); } break; } } - State = 3045; + State = 3229; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16170,17 +16498,17 @@ public I64seqContext i64seq() { try { EnterOuterAlt(_localctx, 1); { - State = 3049; + State = 3233; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32 || _la==INT64) { { { - State = 3046; + State = 3230; int64(); } } - State = 3051; + State = 3235; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16225,17 +16553,17 @@ public I32seqContext i32seq() { try { EnterOuterAlt(_localctx, 1); { - State = 3055; + State = 3239; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 3052; + State = 3236; int32(); } } - State = 3057; + State = 3241; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16280,17 +16608,17 @@ public I16seqContext i16seq() { try { EnterOuterAlt(_localctx, 1); { - State = 3061; + State = 3245; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 3058; + State = 3242; int32(); } } - State = 3063; + State = 3247; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16335,17 +16663,17 @@ public I8seqContext i8seq() { try { EnterOuterAlt(_localctx, 1); { - State = 3067; + State = 3251; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 3064; + State = 3248; int32(); } } - State = 3069; + State = 3253; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16390,17 +16718,17 @@ public BoolSeqContext boolSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 3073; + State = 3257; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__94 || _la==T__95) { { { - State = 3070; + State = 3254; truefalse(); } } - State = 3075; + State = 3259; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16447,13 +16775,13 @@ public SqstringSeqContext sqstringSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 3079; + State = 3263; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==NULLREF || _la==SQSTRING) { { { - State = 3076; + State = 3260; _la = TokenStream.LA(1); if ( !(_la==NULLREF || _la==SQSTRING) ) { ErrorHandler.RecoverInline(this); @@ -16464,7 +16792,7 @@ public SqstringSeqContext sqstringSeq() { } } } - State = 3081; + State = 3265; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16509,17 +16837,17 @@ public ClassSeqContext classSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 3085; + State = 3269; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4947802390528L) != 0) || _la==T__112 || _la==NULLREF || _la==VALUE || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 105553118478337L) != 0)) { { { - State = 3082; + State = 3266; classSeqElement(); } } - State = 3087; + State = 3271; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16560,22 +16888,22 @@ public ClassSeqElementContext classSeqElement() { ClassSeqElementContext _localctx = new ClassSeqElementContext(Context, State); EnterRule(_localctx, 326, RULE_classSeqElement); try { - State = 3092; + State = 3276; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case NULLREF: EnterOuterAlt(_localctx, 1); { - State = 3088; + State = 3272; Match(NULLREF); } break; case T__38: EnterOuterAlt(_localctx, 2); { - State = 3089; + State = 3273; Match(T__38); - State = 3090; + State = 3274; Match(SQSTRING); } break; @@ -16592,7 +16920,7 @@ public ClassSeqElementContext classSeqElement() { case ID: EnterOuterAlt(_localctx, 3); { - State = 3091; + State = 3275; className(); } break; @@ -16639,17 +16967,17 @@ public ObjSeqContext objSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 3097; + State = 3281; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__83 || ((((_la - 181)) & ~0x3f) == 0 && ((1L << (_la - 181)) & 106495L) != 0)) { { { - State = 3094; + State = 3278; serInit(); } } - State = 3099; + State = 3283; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16696,27 +17024,27 @@ public CustomAttrDeclContext customAttrDecl() { EnterRule(_localctx, 330, RULE_customAttrDecl); BeginSubtree(); Actions.BeginSemanticRoot(_localctx); try { - State = 3103; + State = 3287; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,164,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,166,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3100; + State = 3284; customDescr(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3101; + State = 3285; customDescrWithOwner(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3102; + State = 3286; dottedName(); } break; @@ -16772,13 +17100,13 @@ public AsmOrRefDeclContext asmOrRefDecl() { EnterRule(_localctx, 332, RULE_asmOrRefDecl); int _la; try { - State = 3130; + State = 3314; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,165,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,167,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3105; + State = 3289; _la = TokenStream.LA(1); if ( !(_la==T__166 || _la==T__167) ) { ErrorHandler.RecoverInline(this); @@ -16787,72 +17115,72 @@ public AsmOrRefDeclContext asmOrRefDecl() { ErrorHandler.ReportMatch(this); Consume(); } - State = 3106; + State = 3290; Match(T__35); - State = 3107; + State = 3291; Match(T__29); - State = 3108; + State = 3292; bytes(); - State = 3109; + State = 3293; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3111; + State = 3295; Match(T__168); - State = 3112; + State = 3296; intOrWildcard(); - State = 3113; + State = 3297; Match(T__74); - State = 3114; + State = 3298; intOrWildcard(); - State = 3115; + State = 3299; Match(T__74); - State = 3116; + State = 3300; intOrWildcard(); - State = 3117; + State = 3301; Match(T__74); - State = 3118; + State = 3302; intOrWildcard(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3120; + State = 3304; Match(T__169); - State = 3121; + State = 3305; compQstring(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 3122; + State = 3306; Match(T__169); - State = 3123; + State = 3307; Match(T__35); - State = 3124; + State = 3308; Match(T__29); - State = 3125; + State = 3309; bytes(); - State = 3126; + State = 3310; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 3128; + State = 3312; customAttrDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 3129; + State = 3313; compControl(); } break; @@ -16897,36 +17225,36 @@ public AssemblyRefHeadContext assemblyRefHead() { AssemblyRefHeadContext _localctx = new AssemblyRefHeadContext(Context, State); EnterRule(_localctx, 334, RULE_assemblyRefHead); try { - State = 3144; + State = 3328; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,166,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,168,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3132; + State = 3316; Match(T__24); - State = 3133; + State = 3317; Match(T__39); - State = 3134; + State = 3318; asmAttr(); - State = 3135; + State = 3319; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3137; + State = 3321; Match(T__24); - State = 3138; + State = 3322; Match(T__39); - State = 3139; + State = 3323; asmAttr(); - State = 3140; + State = 3324; dottedName(); - State = 3141; + State = 3325; Match(T__33); - State = 3142; + State = 3326; dottedName(); } break; @@ -16971,17 +17299,17 @@ public AssemblyRefDeclsContext assemblyRefDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 3149; + State = 3333; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 36028835673735168L) != 0) || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & 4294975519L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 105555249070081L) != 0)) { { { - State = 3146; + State = 3330; assemblyRefDecl(); } } - State = 3151; + State = 3335; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17024,21 +17352,21 @@ public AssemblyRefDeclContext assemblyRefDecl() { AssemblyRefDeclContext _localctx = new AssemblyRefDeclContext(Context, State); EnterRule(_localctx, 338, RULE_assemblyRefDecl); try { - State = 3166; + State = 3350; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case HASH: EnterOuterAlt(_localctx, 1); { - State = 3152; + State = 3336; Match(HASH); - State = 3153; + State = 3337; Match(T__35); - State = 3154; + State = 3338; Match(T__29); - State = 3155; + State = 3339; bytes(); - State = 3156; + State = 3340; Match(T__30); } break; @@ -17063,29 +17391,29 @@ public AssemblyRefDeclContext assemblyRefDecl() { case ID: EnterOuterAlt(_localctx, 2); { - State = 3158; + State = 3342; asmOrRefDecl(); } break; case T__170: EnterOuterAlt(_localctx, 3); { - State = 3159; + State = 3343; Match(T__170); - State = 3160; + State = 3344; Match(T__35); - State = 3161; + State = 3345; Match(T__29); - State = 3162; + State = 3346; bytes(); - State = 3163; + State = 3347; Match(T__30); } break; case T__54: EnterOuterAlt(_localctx, 4); { - State = 3165; + State = 3349; Match(T__54); } break; @@ -17135,25 +17463,25 @@ public ExptypeHeadContext exptypeHead() { try { EnterOuterAlt(_localctx, 1); { - State = 3168; + State = 3352; Match(T__49); - State = 3169; + State = 3353; Match(T__39); - State = 3173; + State = 3357; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4618441417868443648L) != 0) || _la==T__171) { { { - State = 3170; + State = 3354; exptAttr(); } } - State = 3175; + State = 3359; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 3176; + State = 3360; dottedName(); } } @@ -17200,23 +17528,23 @@ public ExportHeadContext exportHead() { try { EnterOuterAlt(_localctx, 1); { - State = 3178; + State = 3362; Match(EXPORT); - State = 3182; + State = 3366; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4618441417868443648L) != 0) || _la==T__171) { { { - State = 3179; + State = 3363; exptAttr(); } } - State = 3184; + State = 3368; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 3185; + State = 3369; dottedName(); } } @@ -17250,81 +17578,81 @@ public ExptAttrContext exptAttr() { ExptAttrContext _localctx = new ExptAttrContext(Context, State); EnterRule(_localctx, 344, RULE_exptAttr); try { - State = 3202; + State = 3386; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,171,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,173,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3187; + State = 3371; Match(T__51); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3188; + State = 3372; Match(T__50); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3189; + State = 3373; Match(T__171); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 3190; + State = 3374; Match(T__61); - State = 3191; + State = 3375; Match(T__50); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 3192; + State = 3376; Match(T__61); - State = 3193; + State = 3377; Match(T__51); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 3194; + State = 3378; Match(T__61); - State = 3195; + State = 3379; Match(T__62); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 3196; + State = 3380; Match(T__61); - State = 3197; + State = 3381; Match(T__63); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 3198; + State = 3382; Match(T__61); - State = 3199; + State = 3383; Match(T__64); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 3200; + State = 3384; Match(T__61); - State = 3201; + State = 3385; Match(T__65); } break; @@ -17369,17 +17697,17 @@ public ExptypeDeclsContext exptypeDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 3207; + State = 3391; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1125938597265408L) != 0) || _la==T__112 || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 3204; + State = 3388; exptypeDecl(); } } - State = 3209; + State = 3393; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17433,67 +17761,67 @@ public ExptypeDeclContext exptypeDecl() { ExptypeDeclContext _localctx = new ExptypeDeclContext(Context, State); EnterRule(_localctx, 348, RULE_exptypeDecl); try { - State = 3223; + State = 3407; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,173,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,175,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3210; + State = 3394; Match(T__20); - State = 3211; + State = 3395; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3212; + State = 3396; Match(T__49); - State = 3213; + State = 3397; Match(T__39); - State = 3214; + State = 3398; slashedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3215; + State = 3399; Match(T__24); - State = 3216; + State = 3400; Match(T__39); - State = 3217; + State = 3401; dottedName(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 3218; + State = 3402; mdtoken(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 3219; + State = 3403; Match(T__49); - State = 3220; + State = 3404; int32(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 3221; + State = 3405; customAttrDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 3222; + State = 3406; compControl(); } break; @@ -17543,56 +17871,56 @@ public ManifestResHeadContext manifestResHead() { EnterRule(_localctx, 350, RULE_manifestResHead); int _la; try { - State = 3244; + State = 3428; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,176,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,178,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3225; + State = 3409; Match(MRESOURCE); - State = 3229; + State = 3413; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__50 || _la==T__51) { { { - State = 3226; + State = 3410; manresAttr(); } } - State = 3231; + State = 3415; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 3232; + State = 3416; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3233; + State = 3417; Match(MRESOURCE); - State = 3237; + State = 3421; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__50 || _la==T__51) { { { - State = 3234; + State = 3418; manresAttr(); } } - State = 3239; + State = 3423; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 3240; + State = 3424; dottedName(); - State = 3241; + State = 3425; Match(T__33); - State = 3242; + State = 3426; dottedName(); } break; @@ -17631,7 +17959,7 @@ public ManresAttrContext manresAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 3246; + State = 3430; _la = TokenStream.LA(1); if ( !(_la==T__50 || _la==T__51) ) { ErrorHandler.RecoverInline(this); @@ -17681,17 +18009,17 @@ public ManifestResDeclsContext manifestResDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 3251; + State = 3435; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38690422784L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 3248; + State = 3432; manifestResDecl(); } } - State = 3253; + State = 3437; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17739,30 +18067,30 @@ public ManifestResDeclContext manifestResDecl() { ManifestResDeclContext _localctx = new ManifestResDeclContext(Context, State); EnterRule(_localctx, 356, RULE_manifestResDecl); try { - State = 3264; + State = 3448; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__20: EnterOuterAlt(_localctx, 1); { - State = 3254; + State = 3438; Match(T__20); - State = 3255; + State = 3439; dottedName(); - State = 3256; + State = 3440; Match(T__43); - State = 3257; + State = 3441; int32(); } break; case T__24: EnterOuterAlt(_localctx, 2); { - State = 3259; + State = 3443; Match(T__24); - State = 3260; + State = 3444; Match(T__39); - State = 3261; + State = 3445; dottedName(); } break; @@ -17775,7 +18103,7 @@ public ManifestResDeclContext manifestResDecl() { case ID: EnterOuterAlt(_localctx, 3); { - State = 3262; + State = 3446; customAttrDecl(); } break; @@ -17789,7 +18117,7 @@ public ManifestResDeclContext manifestResDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 4); { - State = 3263; + State = 3447; compControl(); } break; @@ -17826,7 +18154,7 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { } private static int[] _serializedATN = { - 4,1,305,3267,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, + 4,1,305,3451,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, @@ -17971,91 +18299,106 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 1,86,1,86,1,86,1,86,1,86,1,86,3,86,1901,8,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,88,1,88,1,88,1,88,1,88,3,88,1920, 8,88,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89, - 3,89,1935,8,89,1,90,1,90,1,90,5,90,1940,8,90,10,90,12,90,1943,9,90,1,90, - 1,90,1,91,1,91,1,91,1,91,1,91,3,91,1952,8,91,1,92,1,92,1,92,1,92,1,92, - 1,92,1,92,1,92,1,92,1,92,1,92,3,92,1965,8,92,1,93,5,93,1968,8,93,10,93, - 12,93,1971,9,93,1,94,1,94,3,94,1975,8,94,1,94,1,94,1,95,1,95,1,95,5,95, - 1982,8,95,10,95,12,95,1985,9,95,1,95,1,95,1,96,1,96,1,96,1,96,1,97,3,97, - 1994,8,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, + 3,89,1935,8,89,1,90,1,90,1,90,1,90,5,90,1941,8,90,10,90,12,90,1944,9,90, + 1,90,1,90,1,90,1,91,1,91,1,91,1,91,1,91,1,91,3,91,1955,8,91,1,92,1,92, + 1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92, + 1,92,1,92,3,92,1975,8,92,1,93,1,93,1,93,5,93,1980,8,93,10,93,12,93,1983, + 9,93,1,94,1,94,3,94,1987,8,94,1,94,1,94,1,94,1,95,1,95,1,95,1,95,5,95, + 1996,8,95,10,95,12,95,1999,9,95,1,95,1,95,1,95,1,96,1,96,1,96,1,96,1,96, + 1,97,3,97,2010,8,97,1,97,1,97,1,98,1,98,1,98,1,98,1,98,1,98,1,98,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, - 5,99,2078,8,99,10,99,12,99,2081,9,99,1,99,1,99,1,99,1,99,5,99,2087,8,99, - 10,99,12,99,2090,9,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,2100, - 8,99,10,99,12,99,2103,9,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,2111,8,99, - 10,99,12,99,2114,9,99,1,99,1,99,1,99,1,99,1,99,3,99,2121,8,99,1,100,1, - 100,1,100,1,100,1,100,1,100,1,100,1,100,5,100,2131,8,100,10,100,12,100, - 2134,9,100,1,100,1,100,1,100,1,100,1,100,1,101,1,101,1,101,1,101,1,101, + 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, + 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,2118, + 8,99,10,99,12,99,2121,9,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,2130, + 8,99,10,99,12,99,2133,9,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, + 1,99,1,99,5,99,2146,8,99,10,99,12,99,2149,9,99,1,99,1,99,1,99,1,99,1,99, + 1,99,1,99,1,99,1,99,5,99,2160,8,99,10,99,12,99,2163,9,99,1,99,1,99,1,99, + 1,99,1,99,1,99,3,99,2171,8,99,1,100,1,100,1,100,1,100,1,100,1,100,1,100, + 1,100,1,100,1,100,1,100,5,100,2184,8,100,10,100,12,100,2187,9,100,1,100, + 1,100,1,100,1,100,1,100,1,100,1,101,1,101,1,101,1,101,1,101,1,101,1,101, + 1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101, 1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101, - 1,101,1,101,3,101,2160,8,101,1,102,1,102,1,102,1,102,1,102,3,102,2167, - 8,102,1,103,1,103,1,103,3,103,2172,8,103,1,104,1,104,1,104,1,104,1,104, - 3,104,2179,8,104,1,105,1,105,5,105,2183,8,105,10,105,12,105,2186,9,105, - 1,105,1,105,1,105,1,105,1,105,5,105,2193,8,105,10,105,12,105,2196,9,105, - 1,105,3,105,2199,8,105,1,106,1,106,1,107,5,107,2204,8,107,10,107,12,107, - 2207,9,107,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108, - 1,108,1,108,3,108,2221,8,108,1,109,1,109,5,109,2225,8,109,10,109,12,109, - 2228,9,109,1,109,1,109,1,109,1,109,1,109,1,109,1,110,1,110,1,111,5,111, - 2239,8,111,10,111,12,111,2242,9,111,1,112,1,112,1,112,1,112,1,112,1,112, - 1,112,1,112,1,112,1,112,3,112,2254,8,112,1,113,1,113,1,113,1,113,1,113, - 1,113,1,113,3,113,2263,8,113,1,114,1,114,1,114,1,114,1,114,1,114,1,114, - 4,114,2272,8,114,11,114,12,114,2273,1,114,1,114,3,114,2278,8,114,1,115, - 1,115,1,115,5,115,2283,8,115,10,115,12,115,2286,9,115,1,116,1,116,1,116, - 1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116, - 1,116,1,116,3,116,2305,8,116,1,117,1,117,1,117,5,117,2310,8,117,10,117, - 12,117,2313,9,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,5,117, - 2323,8,117,10,117,12,117,2326,9,117,1,118,1,118,1,118,1,118,1,118,1,118, + 1,101,1,101,1,101,3,101,2229,8,101,1,102,1,102,1,102,1,102,1,102,1,102, + 1,102,1,102,1,102,3,102,2240,8,102,1,103,1,103,1,103,1,103,1,103,3,103, + 2247,8,103,1,104,1,104,1,104,1,104,1,104,1,104,3,104,2255,8,104,1,105, + 1,105,1,105,1,105,5,105,2261,8,105,10,105,12,105,2264,9,105,1,105,1,105, + 1,105,1,105,1,105,1,105,1,105,1,105,5,105,2274,8,105,10,105,12,105,2277, + 9,105,1,105,1,105,1,105,3,105,2282,8,105,1,106,1,106,1,106,1,106,3,106, + 2288,8,106,1,107,5,107,2291,8,107,10,107,12,107,2294,9,107,1,108,1,108, + 1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108, + 1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108, + 3,108,2322,8,108,1,109,1,109,1,109,1,109,5,109,2328,8,109,10,109,12,109, + 2331,9,109,1,109,1,109,1,109,1,109,1,109,1,109,1,109,1,110,1,110,1,110, + 1,110,3,110,2344,8,110,1,111,5,111,2347,8,111,10,111,12,111,2350,9,111, + 1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112, + 1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,3,112,2374, + 8,112,1,113,1,113,1,113,1,113,1,113,1,113,1,113,3,113,2383,8,113,1,114, + 1,114,1,114,1,114,1,114,1,114,1,114,4,114,2392,8,114,11,114,12,114,2393, + 1,114,1,114,3,114,2398,8,114,1,115,1,115,1,115,5,115,2403,8,115,10,115, + 12,115,2406,9,115,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116, + 1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,3,116,2425,8,116,1,117, + 1,117,1,117,1,117,1,117,1,117,1,117,5,117,2434,8,117,10,117,12,117,2437, + 9,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,5,117, + 2449,8,117,10,117,12,117,2452,9,117,1,117,1,117,1,118,1,118,1,118,1,118, 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, - 1,118,1,118,1,118,1,118,1,118,3,118,2351,8,118,1,119,1,119,1,119,1,119, - 1,119,3,119,2358,8,119,3,119,2360,8,119,1,119,5,119,2363,8,119,10,119, - 12,119,2366,9,119,1,119,1,119,1,119,3,119,2371,8,119,1,120,1,120,1,120, + 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, + 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, + 1,118,1,118,3,118,2498,8,118,1,119,1,119,1,119,1,119,1,119,1,119,1,119, + 1,119,3,119,2508,8,119,3,119,2510,8,119,1,119,1,119,1,119,5,119,2515,8, + 119,10,119,12,119,2518,9,119,1,119,1,119,1,119,3,119,2523,8,119,1,120, 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, - 3,120,2400,8,120,1,121,1,121,1,121,1,121,1,121,1,121,1,121,3,121,2409, - 8,121,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, - 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,3,122,2432, - 8,122,1,123,5,123,2435,8,123,10,123,12,123,2438,9,123,1,124,1,124,1,124, + 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, + 1,120,1,120,1,120,1,120,1,120,3,120,2567,8,120,1,121,1,121,1,121,1,121, + 1,121,1,121,1,121,3,121,2576,8,121,1,122,1,122,1,122,1,122,1,122,1,122, + 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, + 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, + 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,3,122,2616,8,122,1,123, + 5,123,2619,8,123,10,123,12,123,2622,9,123,1,124,1,124,1,124,1,124,1,124, 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, - 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,3,124,2477, - 8,124,1,125,1,125,3,125,2481,8,125,1,125,1,125,1,126,1,126,1,126,1,126, - 1,126,1,126,3,126,2491,8,126,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,128,1,128,1,128,1,128,1,128,1,128, - 1,128,3,128,2513,8,128,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129, - 5,129,2523,8,129,10,129,12,129,2526,9,129,1,129,1,129,1,129,1,129,1,129, - 1,129,5,129,2534,8,129,10,129,12,129,2537,9,129,1,129,1,129,1,129,1,129, - 1,129,1,129,1,129,1,129,1,129,1,129,5,129,2549,8,129,10,129,12,129,2552, - 9,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,5,129,2562,8,129, - 10,129,12,129,2565,9,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129, - 5,129,2575,8,129,10,129,12,129,2578,9,129,3,129,2580,8,129,1,130,1,130, - 1,130,1,130,1,131,1,131,3,131,2588,8,131,1,132,1,132,1,132,1,132,1,133, - 1,133,1,133,1,134,1,134,1,134,4,134,2600,8,134,11,134,12,134,2601,1,135, + 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,3,124,2661,8,124,1,125, + 1,125,3,125,2665,8,125,1,125,1,125,1,126,1,126,1,126,1,126,1,126,1,126, + 3,126,2675,8,126,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,128,1,128,1,128,1,128,1,128,1,128,1,128,3,128, + 2697,8,128,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,5,129,2707, + 8,129,10,129,12,129,2710,9,129,1,129,1,129,1,129,1,129,1,129,1,129,5,129, + 2718,8,129,10,129,12,129,2721,9,129,1,129,1,129,1,129,1,129,1,129,1,129, + 1,129,1,129,1,129,1,129,5,129,2733,8,129,10,129,12,129,2736,9,129,1,129, + 1,129,1,129,1,129,1,129,1,129,1,129,1,129,5,129,2746,8,129,10,129,12,129, + 2749,9,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,5,129,2759, + 8,129,10,129,12,129,2762,9,129,3,129,2764,8,129,1,130,1,130,1,130,1,130, + 1,131,1,131,3,131,2772,8,131,1,132,1,132,1,132,1,132,1,133,1,133,1,133, + 1,134,1,134,1,134,4,134,2784,8,134,11,134,12,134,2785,1,135,1,135,1,135, 1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135, - 1,135,1,135,1,135,3,135,2620,8,135,1,136,1,136,1,136,1,136,1,136,1,136, - 1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,3,136,2638, - 8,136,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137, - 1,137,3,137,2652,8,137,1,138,1,138,1,138,1,139,1,139,1,140,1,140,1,141, + 1,135,3,135,2804,8,135,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136, + 1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,3,136,2822,8,136,1,137, + 1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,3,137, + 2836,8,137,1,138,1,138,1,138,1,139,1,139,1,140,1,140,1,141,1,141,1,141, 1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141, - 1,141,1,141,3,141,2676,8,141,1,142,1,142,1,142,1,143,1,143,1,143,1,143, - 1,143,1,143,1,143,3,143,2688,8,143,1,144,1,144,1,144,3,144,2693,8,144, - 1,145,1,145,1,145,1,145,1,145,4,145,2700,8,145,11,145,12,145,2701,3,145, - 2704,8,145,1,146,1,146,1,146,5,146,2709,8,146,10,146,12,146,2712,9,146, - 1,146,1,146,1,147,1,147,1,147,1,147,1,147,3,147,2721,8,147,1,148,1,148, + 3,141,2860,8,141,1,142,1,142,1,142,1,143,1,143,1,143,1,143,1,143,1,143, + 1,143,3,143,2872,8,143,1,144,1,144,1,144,3,144,2877,8,144,1,145,1,145, + 1,145,1,145,1,145,4,145,2884,8,145,11,145,12,145,2885,3,145,2888,8,145, + 1,146,1,146,1,146,5,146,2893,8,146,10,146,12,146,2896,9,146,1,146,1,146, + 1,147,1,147,1,147,1,147,1,147,3,147,2905,8,147,1,148,1,148,1,148,1,148, 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, - 1,148,1,148,1,148,1,148,3,148,2789,8,148,1,149,1,149,1,149,1,149,1,149, + 1,148,1,148,3,148,2973,8,148,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, - 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,3,149,2866, - 8,149,1,150,1,150,1,150,5,150,2871,8,150,10,150,12,150,2874,9,150,1,151, - 1,151,1,152,1,152,1,152,3,152,2881,8,152,1,153,1,153,1,153,1,153,1,153, + 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,3,149,3050,8,149,1,150, + 1,150,1,150,5,150,3055,8,150,10,150,12,150,3058,9,150,1,151,1,151,1,152, + 1,152,1,152,3,152,3065,8,152,1,153,1,153,1,153,1,153,1,153,1,153,1,153, 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, @@ -18067,411 +18410,410 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, - 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,3,153, - 3031,8,153,1,154,1,154,5,154,3035,8,154,10,154,12,154,3038,9,154,1,155, - 1,155,5,155,3042,8,155,10,155,12,155,3045,9,155,1,156,5,156,3048,8,156, - 10,156,12,156,3051,9,156,1,157,5,157,3054,8,157,10,157,12,157,3057,9,157, - 1,158,5,158,3060,8,158,10,158,12,158,3063,9,158,1,159,5,159,3066,8,159, - 10,159,12,159,3069,9,159,1,160,5,160,3072,8,160,10,160,12,160,3075,9,160, - 1,161,5,161,3078,8,161,10,161,12,161,3081,9,161,1,162,5,162,3084,8,162, - 10,162,12,162,3087,9,162,1,163,1,163,1,163,1,163,3,163,3093,8,163,1,164, - 5,164,3096,8,164,10,164,12,164,3099,9,164,1,165,1,165,1,165,3,165,3104, - 8,165,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166, + 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,3,153,3215,8,153, + 1,154,1,154,5,154,3219,8,154,10,154,12,154,3222,9,154,1,155,1,155,5,155, + 3226,8,155,10,155,12,155,3229,9,155,1,156,5,156,3232,8,156,10,156,12,156, + 3235,9,156,1,157,5,157,3238,8,157,10,157,12,157,3241,9,157,1,158,5,158, + 3244,8,158,10,158,12,158,3247,9,158,1,159,5,159,3250,8,159,10,159,12,159, + 3253,9,159,1,160,5,160,3256,8,160,10,160,12,160,3259,9,160,1,161,5,161, + 3262,8,161,10,161,12,161,3265,9,161,1,162,5,162,3268,8,162,10,162,12,162, + 3271,9,162,1,163,1,163,1,163,1,163,3,163,3277,8,163,1,164,5,164,3280,8, + 164,10,164,12,164,3283,9,164,1,165,1,165,1,165,3,165,3288,8,165,1,166, + 1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166, 1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166, - 1,166,1,166,3,166,3131,8,166,1,167,1,167,1,167,1,167,1,167,1,167,1,167, - 1,167,1,167,1,167,1,167,1,167,3,167,3145,8,167,1,168,5,168,3148,8,168, - 10,168,12,168,3151,9,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,169,3,169,3167,8,169,1,170,1,170,1,170, - 5,170,3172,8,170,10,170,12,170,3175,9,170,1,170,1,170,1,171,1,171,5,171, - 3181,8,171,10,171,12,171,3184,9,171,1,171,1,171,1,172,1,172,1,172,1,172, - 1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,3,172, - 3203,8,172,1,173,5,173,3206,8,173,10,173,12,173,3209,9,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,3,174, - 3224,8,174,1,175,1,175,5,175,3228,8,175,10,175,12,175,3231,9,175,1,175, - 1,175,1,175,5,175,3236,8,175,10,175,12,175,3239,9,175,1,175,1,175,1,175, - 1,175,3,175,3245,8,175,1,176,1,176,1,177,5,177,3250,8,177,10,177,12,177, - 3253,9,177,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178, - 3,178,3265,8,178,1,178,0,1,68,179,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,0,15,6,0,1,15,199,199, - 243,243,247,247,264,264,289,289,5,0,16,16,199,199,243,243,264,264,288, - 289,1,0,263,264,1,0,173,174,1,0,37,38,1,0,73,74,3,0,2,2,61,61,77,83,2, - 0,229,229,260,261,1,0,95,96,1,0,97,111,1,0,68,69,2,0,173,173,289,290,2, - 0,179,179,264,264,1,0,167,168,1,0,51,52,3729,0,358,1,0,0,0,2,376,1,0,0, - 0,4,378,1,0,0,0,6,385,1,0,0,0,8,394,1,0,0,0,10,447,1,0,0,0,12,449,1,0, - 0,0,14,452,1,0,0,0,16,455,1,0,0,0,18,459,1,0,0,0,20,462,1,0,0,0,22,465, - 1,0,0,0,24,472,1,0,0,0,26,488,1,0,0,0,28,490,1,0,0,0,30,492,1,0,0,0,32, - 502,1,0,0,0,34,504,1,0,0,0,36,527,1,0,0,0,38,531,1,0,0,0,40,549,1,0,0, - 0,42,576,1,0,0,0,44,599,1,0,0,0,46,635,1,0,0,0,48,637,1,0,0,0,50,645,1, - 0,0,0,52,647,1,0,0,0,54,654,1,0,0,0,56,666,1,0,0,0,58,669,1,0,0,0,60,671, - 1,0,0,0,62,684,1,0,0,0,64,692,1,0,0,0,66,694,1,0,0,0,68,702,1,0,0,0,70, - 718,1,0,0,0,72,724,1,0,0,0,74,727,1,0,0,0,76,776,1,0,0,0,78,781,1,0,0, - 0,80,786,1,0,0,0,82,791,1,0,0,0,84,799,1,0,0,0,86,804,1,0,0,0,88,909,1, - 0,0,0,90,937,1,0,0,0,92,939,1,0,0,0,94,943,1,0,0,0,96,945,1,0,0,0,98,950, - 1,0,0,0,100,978,1,0,0,0,102,1058,1,0,0,0,104,1060,1,0,0,0,106,1089,1,0, - 0,0,108,1091,1,0,0,0,110,1105,1,0,0,0,112,1134,1,0,0,0,114,1146,1,0,0, - 0,116,1185,1,0,0,0,118,1193,1,0,0,0,120,1202,1,0,0,0,122,1210,1,0,0,0, - 124,1229,1,0,0,0,126,1242,1,0,0,0,128,1266,1,0,0,0,130,1413,1,0,0,0,132, - 1423,1,0,0,0,134,1435,1,0,0,0,136,1517,1,0,0,0,138,1519,1,0,0,0,140,1558, - 1,0,0,0,142,1618,1,0,0,0,144,1658,1,0,0,0,146,1674,1,0,0,0,148,1676,1, - 0,0,0,150,1680,1,0,0,0,152,1735,1,0,0,0,154,1747,1,0,0,0,156,1762,1,0, - 0,0,158,1769,1,0,0,0,160,1774,1,0,0,0,162,1778,1,0,0,0,164,1814,1,0,0, - 0,166,1816,1,0,0,0,168,1860,1,0,0,0,170,1879,1,0,0,0,172,1900,1,0,0,0, - 174,1902,1,0,0,0,176,1919,1,0,0,0,178,1934,1,0,0,0,180,1941,1,0,0,0,182, - 1951,1,0,0,0,184,1964,1,0,0,0,186,1969,1,0,0,0,188,1972,1,0,0,0,190,1983, - 1,0,0,0,192,1988,1,0,0,0,194,1993,1,0,0,0,196,1997,1,0,0,0,198,2120,1, - 0,0,0,200,2122,1,0,0,0,202,2159,1,0,0,0,204,2166,1,0,0,0,206,2171,1,0, - 0,0,208,2178,1,0,0,0,210,2198,1,0,0,0,212,2200,1,0,0,0,214,2205,1,0,0, - 0,216,2220,1,0,0,0,218,2222,1,0,0,0,220,2235,1,0,0,0,222,2240,1,0,0,0, - 224,2253,1,0,0,0,226,2262,1,0,0,0,228,2277,1,0,0,0,230,2284,1,0,0,0,232, - 2304,1,0,0,0,234,2306,1,0,0,0,236,2350,1,0,0,0,238,2370,1,0,0,0,240,2399, - 1,0,0,0,242,2408,1,0,0,0,244,2431,1,0,0,0,246,2436,1,0,0,0,248,2476,1, - 0,0,0,250,2478,1,0,0,0,252,2484,1,0,0,0,254,2492,1,0,0,0,256,2512,1,0, - 0,0,258,2579,1,0,0,0,260,2581,1,0,0,0,262,2587,1,0,0,0,264,2589,1,0,0, - 0,266,2593,1,0,0,0,268,2599,1,0,0,0,270,2619,1,0,0,0,272,2637,1,0,0,0, - 274,2651,1,0,0,0,276,2653,1,0,0,0,278,2656,1,0,0,0,280,2658,1,0,0,0,282, - 2675,1,0,0,0,284,2677,1,0,0,0,286,2687,1,0,0,0,288,2692,1,0,0,0,290,2703, - 1,0,0,0,292,2710,1,0,0,0,294,2720,1,0,0,0,296,2788,1,0,0,0,298,2865,1, - 0,0,0,300,2872,1,0,0,0,302,2875,1,0,0,0,304,2880,1,0,0,0,306,3030,1,0, - 0,0,308,3036,1,0,0,0,310,3043,1,0,0,0,312,3049,1,0,0,0,314,3055,1,0,0, - 0,316,3061,1,0,0,0,318,3067,1,0,0,0,320,3073,1,0,0,0,322,3079,1,0,0,0, - 324,3085,1,0,0,0,326,3092,1,0,0,0,328,3097,1,0,0,0,330,3103,1,0,0,0,332, - 3130,1,0,0,0,334,3144,1,0,0,0,336,3149,1,0,0,0,338,3166,1,0,0,0,340,3168, - 1,0,0,0,342,3178,1,0,0,0,344,3202,1,0,0,0,346,3207,1,0,0,0,348,3223,1, - 0,0,0,350,3244,1,0,0,0,352,3246,1,0,0,0,354,3251,1,0,0,0,356,3264,1,0, - 0,0,358,359,7,0,0,0,359,1,1,0,0,0,360,361,5,288,0,0,361,377,6,1,-1,0,362, - 363,3,4,2,0,363,364,6,1,-1,0,364,365,5,265,0,0,365,367,1,0,0,0,366,362, - 1,0,0,0,367,370,1,0,0,0,368,366,1,0,0,0,368,369,1,0,0,0,369,371,1,0,0, - 0,370,368,1,0,0,0,371,372,3,4,2,0,372,373,6,1,-1,0,373,377,1,0,0,0,374, - 375,5,264,0,0,375,377,6,1,-1,0,376,360,1,0,0,0,376,368,1,0,0,0,376,374, - 1,0,0,0,377,3,1,0,0,0,378,379,7,1,0,0,379,5,1,0,0,0,380,381,5,263,0,0, - 381,382,6,3,-1,0,382,384,5,266,0,0,383,380,1,0,0,0,384,387,1,0,0,0,385, - 383,1,0,0,0,385,386,1,0,0,0,386,388,1,0,0,0,387,385,1,0,0,0,388,389,5, - 263,0,0,389,390,6,3,-1,0,390,7,1,0,0,0,391,393,3,10,5,0,392,391,1,0,0, - 0,393,396,1,0,0,0,394,392,1,0,0,0,394,395,1,0,0,0,395,9,1,0,0,0,396,394, - 1,0,0,0,397,398,3,74,37,0,398,399,5,17,0,0,399,400,3,82,41,0,400,401,5, - 18,0,0,401,448,1,0,0,0,402,403,3,72,36,0,403,404,5,17,0,0,404,405,3,8, - 4,0,405,406,5,18,0,0,406,448,1,0,0,0,407,408,3,234,117,0,408,409,5,17, - 0,0,409,410,3,246,123,0,410,411,5,18,0,0,411,448,1,0,0,0,412,448,3,200, - 100,0,413,448,3,284,142,0,414,448,3,70,35,0,415,448,3,66,33,0,416,448, - 3,88,44,0,417,448,3,90,45,0,418,448,3,22,11,0,419,420,3,334,167,0,420, - 421,5,17,0,0,421,422,3,336,168,0,422,423,5,18,0,0,423,448,1,0,0,0,424, - 425,3,340,170,0,425,426,5,17,0,0,426,427,3,346,173,0,427,428,5,18,0,0, - 428,448,1,0,0,0,429,430,3,350,175,0,430,431,5,17,0,0,431,432,3,354,177, - 0,432,433,5,18,0,0,433,448,1,0,0,0,434,448,3,64,32,0,435,448,3,152,76, - 0,436,448,3,330,165,0,437,448,3,12,6,0,438,448,3,14,7,0,439,448,3,16,8, - 0,440,448,3,18,9,0,441,448,3,20,10,0,442,448,3,26,13,0,443,448,3,42,21, - 0,444,448,3,40,20,0,445,448,3,30,15,0,446,448,3,24,12,0,447,397,1,0,0, - 0,447,402,1,0,0,0,447,407,1,0,0,0,447,412,1,0,0,0,447,413,1,0,0,0,447, - 414,1,0,0,0,447,415,1,0,0,0,447,416,1,0,0,0,447,417,1,0,0,0,447,418,1, - 0,0,0,447,419,1,0,0,0,447,424,1,0,0,0,447,429,1,0,0,0,447,434,1,0,0,0, - 447,435,1,0,0,0,447,436,1,0,0,0,447,437,1,0,0,0,447,438,1,0,0,0,447,439, - 1,0,0,0,447,440,1,0,0,0,447,441,1,0,0,0,447,442,1,0,0,0,447,443,1,0,0, - 0,447,444,1,0,0,0,447,445,1,0,0,0,447,446,1,0,0,0,448,11,1,0,0,0,449,450, - 5,19,0,0,450,451,3,32,16,0,451,13,1,0,0,0,452,453,5,20,0,0,453,454,3,32, - 16,0,454,15,1,0,0,0,455,456,5,21,0,0,456,457,5,22,0,0,457,458,3,32,16, - 0,458,17,1,0,0,0,459,460,5,23,0,0,460,461,3,34,17,0,461,19,1,0,0,0,462, - 463,5,24,0,0,463,464,3,34,17,0,464,21,1,0,0,0,465,466,5,25,0,0,466,467, - 3,98,49,0,467,468,3,2,1,0,468,469,5,17,0,0,469,470,3,120,60,0,470,471, - 5,18,0,0,471,23,1,0,0,0,472,473,5,26,0,0,473,25,1,0,0,0,474,475,5,27,0, - 0,475,489,3,28,14,0,476,477,5,27,0,0,477,478,3,28,14,0,478,479,5,28,0, - 0,479,480,3,28,14,0,480,489,1,0,0,0,481,482,5,27,0,0,482,483,3,28,14,0, - 483,484,5,28,0,0,484,485,3,28,14,0,485,486,5,28,0,0,486,487,3,28,14,0, - 487,489,1,0,0,0,488,474,1,0,0,0,488,476,1,0,0,0,488,481,1,0,0,0,489,27, - 1,0,0,0,490,491,7,2,0,0,491,29,1,0,0,0,492,493,5,29,0,0,493,497,5,17,0, - 0,494,496,3,116,58,0,495,494,1,0,0,0,496,499,1,0,0,0,497,495,1,0,0,0,497, - 498,1,0,0,0,498,500,1,0,0,0,499,497,1,0,0,0,500,501,5,18,0,0,501,31,1, - 0,0,0,502,503,5,173,0,0,503,33,1,0,0,0,504,505,7,3,0,0,505,35,1,0,0,0, - 506,507,5,175,0,0,507,528,6,18,-1,0,508,509,3,32,16,0,509,510,5,265,0, - 0,510,511,6,18,-1,0,511,528,1,0,0,0,512,513,3,32,16,0,513,514,6,18,-1, - 0,514,528,1,0,0,0,515,516,5,188,0,0,516,517,5,30,0,0,517,518,3,32,16,0, - 518,519,5,31,0,0,519,520,6,18,-1,0,520,528,1,0,0,0,521,522,5,189,0,0,522, - 523,5,30,0,0,523,524,3,34,17,0,524,525,5,31,0,0,525,526,6,18,-1,0,526, - 528,1,0,0,0,527,506,1,0,0,0,527,508,1,0,0,0,527,512,1,0,0,0,527,515,1, - 0,0,0,527,521,1,0,0,0,528,37,1,0,0,0,529,532,3,32,16,0,530,532,5,262,0, - 0,531,529,1,0,0,0,531,530,1,0,0,0,532,39,1,0,0,0,533,534,5,267,0,0,534, - 550,5,289,0,0,535,536,5,267,0,0,536,537,5,289,0,0,537,550,5,263,0,0,538, - 539,5,268,0,0,539,550,5,289,0,0,540,541,5,269,0,0,541,550,5,289,0,0,542, - 543,5,270,0,0,543,550,5,289,0,0,544,550,5,271,0,0,545,550,5,272,0,0,546, - 547,5,273,0,0,547,550,5,263,0,0,548,550,5,32,0,0,549,533,1,0,0,0,549,535, - 1,0,0,0,549,538,1,0,0,0,549,540,1,0,0,0,549,542,1,0,0,0,549,544,1,0,0, - 0,549,545,1,0,0,0,549,546,1,0,0,0,549,548,1,0,0,0,550,41,1,0,0,0,551,552, - 5,33,0,0,552,553,3,138,69,0,553,554,5,34,0,0,554,555,3,2,1,0,555,577,1, - 0,0,0,556,557,5,33,0,0,557,558,3,116,58,0,558,559,5,34,0,0,559,560,3,2, - 1,0,560,577,1,0,0,0,561,562,5,33,0,0,562,563,3,176,88,0,563,564,5,34,0, - 0,564,565,3,2,1,0,565,577,1,0,0,0,566,567,5,33,0,0,567,568,3,44,22,0,568, - 569,5,34,0,0,569,570,3,2,1,0,570,577,1,0,0,0,571,572,5,33,0,0,572,573, - 3,46,23,0,573,574,5,34,0,0,574,575,3,2,1,0,575,577,1,0,0,0,576,551,1,0, - 0,0,576,556,1,0,0,0,576,561,1,0,0,0,576,566,1,0,0,0,576,571,1,0,0,0,577, - 43,1,0,0,0,578,579,5,35,0,0,579,600,3,48,24,0,580,581,5,35,0,0,581,582, - 3,48,24,0,582,583,5,36,0,0,583,584,3,6,3,0,584,600,1,0,0,0,585,586,5,35, - 0,0,586,587,3,48,24,0,587,588,5,36,0,0,588,589,5,17,0,0,589,590,3,52,26, - 0,590,591,5,18,0,0,591,600,1,0,0,0,592,593,5,35,0,0,593,594,3,48,24,0, - 594,595,5,36,0,0,595,596,5,30,0,0,596,597,3,300,150,0,597,598,5,31,0,0, - 598,600,1,0,0,0,599,578,1,0,0,0,599,580,1,0,0,0,599,585,1,0,0,0,599,592, - 1,0,0,0,600,45,1,0,0,0,601,602,5,35,0,0,602,603,5,30,0,0,603,604,3,50, - 25,0,604,605,5,31,0,0,605,606,3,48,24,0,606,636,1,0,0,0,607,608,5,35,0, - 0,608,609,5,30,0,0,609,610,3,50,25,0,610,611,5,31,0,0,611,612,3,48,24, - 0,612,613,5,36,0,0,613,614,3,6,3,0,614,636,1,0,0,0,615,616,5,35,0,0,616, - 617,5,30,0,0,617,618,3,50,25,0,618,619,5,31,0,0,619,620,3,48,24,0,620, - 621,5,36,0,0,621,622,5,17,0,0,622,623,3,52,26,0,623,624,5,18,0,0,624,636, - 1,0,0,0,625,626,5,35,0,0,626,627,5,30,0,0,627,628,3,50,25,0,628,629,5, - 31,0,0,629,630,3,48,24,0,630,631,5,36,0,0,631,632,5,30,0,0,632,633,3,300, - 150,0,633,634,5,31,0,0,634,636,1,0,0,0,635,601,1,0,0,0,635,607,1,0,0,0, - 635,615,1,0,0,0,635,625,1,0,0,0,636,47,1,0,0,0,637,638,3,168,84,0,638, - 49,1,0,0,0,639,640,3,124,62,0,640,641,6,25,-1,0,641,646,1,0,0,0,642,643, - 3,176,88,0,643,644,6,25,-1,0,644,646,1,0,0,0,645,639,1,0,0,0,645,642,1, - 0,0,0,646,51,1,0,0,0,647,648,3,54,27,0,648,649,3,56,28,0,649,53,1,0,0, - 0,650,653,3,306,153,0,651,653,3,40,20,0,652,650,1,0,0,0,652,651,1,0,0, - 0,653,656,1,0,0,0,654,652,1,0,0,0,654,655,1,0,0,0,655,55,1,0,0,0,656,654, - 1,0,0,0,657,658,3,58,29,0,658,659,3,60,30,0,659,660,3,2,1,0,660,661,5, - 36,0,0,661,662,3,306,153,0,662,665,1,0,0,0,663,665,3,40,20,0,664,657,1, - 0,0,0,664,663,1,0,0,0,665,668,1,0,0,0,666,664,1,0,0,0,666,667,1,0,0,0, - 667,57,1,0,0,0,668,666,1,0,0,0,669,670,7,4,0,0,670,59,1,0,0,0,671,673, - 3,62,31,0,672,674,5,261,0,0,673,672,1,0,0,0,673,674,1,0,0,0,674,61,1,0, - 0,0,675,685,3,144,72,0,676,685,3,2,1,0,677,685,5,196,0,0,678,685,5,197, - 0,0,679,680,5,202,0,0,680,681,5,39,0,0,681,685,5,264,0,0,682,683,5,202, - 0,0,683,685,3,116,58,0,684,675,1,0,0,0,684,676,1,0,0,0,684,677,1,0,0,0, - 684,678,1,0,0,0,684,679,1,0,0,0,684,682,1,0,0,0,685,63,1,0,0,0,686,687, - 5,198,0,0,687,688,5,40,0,0,688,693,3,2,1,0,689,690,5,198,0,0,690,693,3, - 2,1,0,691,693,5,198,0,0,692,686,1,0,0,0,692,689,1,0,0,0,692,691,1,0,0, - 0,693,65,1,0,0,0,694,695,5,41,0,0,695,696,5,42,0,0,696,697,3,32,16,0,697, - 698,5,43,0,0,698,699,3,68,34,0,699,700,5,44,0,0,700,701,3,0,0,0,701,67, - 1,0,0,0,702,715,6,34,-1,0,703,704,10,5,0,0,704,714,5,186,0,0,705,706,10, - 4,0,0,706,714,5,187,0,0,707,708,10,3,0,0,708,714,5,45,0,0,709,710,10,2, - 0,0,710,714,5,46,0,0,711,712,10,1,0,0,712,714,5,47,0,0,713,703,1,0,0,0, - 713,705,1,0,0,0,713,707,1,0,0,0,713,709,1,0,0,0,713,711,1,0,0,0,714,717, - 1,0,0,0,715,713,1,0,0,0,715,716,1,0,0,0,716,69,1,0,0,0,717,715,1,0,0,0, - 718,719,5,48,0,0,719,720,5,36,0,0,720,721,5,30,0,0,721,722,3,300,150,0, - 722,723,5,31,0,0,723,71,1,0,0,0,724,725,5,49,0,0,725,726,3,2,1,0,726,73, - 1,0,0,0,727,731,5,50,0,0,728,730,3,76,38,0,729,728,1,0,0,0,730,733,1,0, - 0,0,731,729,1,0,0,0,731,732,1,0,0,0,732,734,1,0,0,0,733,731,1,0,0,0,734, - 735,3,2,1,0,735,736,3,182,91,0,736,737,3,78,39,0,737,738,3,80,40,0,738, - 75,1,0,0,0,739,777,5,51,0,0,740,777,5,52,0,0,741,777,5,199,0,0,742,777, - 5,202,0,0,743,777,5,221,0,0,744,777,5,53,0,0,745,777,5,54,0,0,746,777, - 5,55,0,0,747,777,5,56,0,0,748,777,5,244,0,0,749,777,5,15,0,0,750,777,5, - 224,0,0,751,777,5,57,0,0,752,777,5,58,0,0,753,777,5,59,0,0,754,777,5,60, - 0,0,755,777,5,61,0,0,756,757,5,62,0,0,757,777,5,51,0,0,758,759,5,62,0, - 0,759,777,5,52,0,0,760,761,5,62,0,0,761,777,5,63,0,0,762,763,5,62,0,0, - 763,777,5,64,0,0,764,765,5,62,0,0,765,777,5,65,0,0,766,767,5,62,0,0,767, - 777,5,66,0,0,768,777,5,67,0,0,769,777,5,68,0,0,770,777,5,69,0,0,771,772, - 5,70,0,0,772,773,5,30,0,0,773,774,3,32,16,0,774,775,5,31,0,0,775,777,1, - 0,0,0,776,739,1,0,0,0,776,740,1,0,0,0,776,741,1,0,0,0,776,742,1,0,0,0, - 776,743,1,0,0,0,776,744,1,0,0,0,776,745,1,0,0,0,776,746,1,0,0,0,776,747, - 1,0,0,0,776,748,1,0,0,0,776,749,1,0,0,0,776,750,1,0,0,0,776,751,1,0,0, - 0,776,752,1,0,0,0,776,753,1,0,0,0,776,754,1,0,0,0,776,755,1,0,0,0,776, - 756,1,0,0,0,776,758,1,0,0,0,776,760,1,0,0,0,776,762,1,0,0,0,776,764,1, - 0,0,0,776,766,1,0,0,0,776,768,1,0,0,0,776,769,1,0,0,0,776,770,1,0,0,0, - 776,771,1,0,0,0,777,77,1,0,0,0,778,782,1,0,0,0,779,780,5,71,0,0,780,782, - 3,124,62,0,781,778,1,0,0,0,781,779,1,0,0,0,782,79,1,0,0,0,783,787,1,0, - 0,0,784,785,5,72,0,0,785,787,3,84,42,0,786,783,1,0,0,0,786,784,1,0,0,0, - 787,81,1,0,0,0,788,790,3,198,99,0,789,788,1,0,0,0,790,793,1,0,0,0,791, - 789,1,0,0,0,791,792,1,0,0,0,792,83,1,0,0,0,793,791,1,0,0,0,794,795,3,124, - 62,0,795,796,5,28,0,0,796,798,1,0,0,0,797,794,1,0,0,0,798,801,1,0,0,0, - 799,797,1,0,0,0,799,800,1,0,0,0,800,802,1,0,0,0,801,799,1,0,0,0,802,803, - 3,124,62,0,803,85,1,0,0,0,804,805,7,5,0,0,805,87,1,0,0,0,806,807,3,86, - 43,0,807,808,3,32,16,0,808,809,5,264,0,0,809,910,1,0,0,0,810,811,3,86, - 43,0,811,812,3,32,16,0,812,910,1,0,0,0,813,814,3,86,43,0,814,815,3,32, - 16,0,815,816,5,75,0,0,816,817,3,32,16,0,817,818,5,264,0,0,818,910,1,0, - 0,0,819,820,3,86,43,0,820,821,3,32,16,0,821,822,5,75,0,0,822,823,3,32, - 16,0,823,910,1,0,0,0,824,825,3,86,43,0,825,826,3,32,16,0,826,827,5,75, - 0,0,827,828,3,32,16,0,828,829,5,28,0,0,829,830,3,32,16,0,830,831,5,264, - 0,0,831,910,1,0,0,0,832,833,3,86,43,0,833,834,3,32,16,0,834,835,5,75,0, - 0,835,836,3,32,16,0,836,837,5,28,0,0,837,838,3,32,16,0,838,910,1,0,0,0, - 839,840,3,86,43,0,840,841,3,32,16,0,841,842,5,28,0,0,842,843,3,32,16,0, - 843,844,5,75,0,0,844,845,3,32,16,0,845,846,5,264,0,0,846,910,1,0,0,0,847, - 848,3,86,43,0,848,849,3,32,16,0,849,850,5,28,0,0,850,851,3,32,16,0,851, - 852,5,75,0,0,852,853,3,32,16,0,853,910,1,0,0,0,854,855,3,86,43,0,855,856, - 3,32,16,0,856,857,5,28,0,0,857,858,3,32,16,0,858,859,5,75,0,0,859,860, - 3,32,16,0,860,861,5,28,0,0,861,862,3,32,16,0,862,863,5,264,0,0,863,910, - 1,0,0,0,864,865,3,86,43,0,865,866,3,32,16,0,866,867,5,28,0,0,867,868,3, - 32,16,0,868,869,5,75,0,0,869,870,3,32,16,0,870,871,5,28,0,0,871,872,3, - 32,16,0,872,910,1,0,0,0,873,874,3,86,43,0,874,875,3,32,16,0,875,876,5, - 263,0,0,876,910,1,0,0,0,877,878,3,86,43,0,878,879,3,32,16,0,879,880,5, - 75,0,0,880,881,3,32,16,0,881,882,5,263,0,0,882,910,1,0,0,0,883,884,3,86, - 43,0,884,885,3,32,16,0,885,886,5,75,0,0,886,887,3,32,16,0,887,888,5,28, - 0,0,888,889,3,32,16,0,889,890,5,263,0,0,890,910,1,0,0,0,891,892,3,86,43, - 0,892,893,3,32,16,0,893,894,5,28,0,0,894,895,3,32,16,0,895,896,5,75,0, - 0,896,897,3,32,16,0,897,898,5,263,0,0,898,910,1,0,0,0,899,900,3,86,43, - 0,900,901,3,32,16,0,901,902,5,28,0,0,902,903,3,32,16,0,903,904,5,75,0, - 0,904,905,3,32,16,0,905,906,5,28,0,0,906,907,3,32,16,0,907,908,5,263,0, - 0,908,910,1,0,0,0,909,806,1,0,0,0,909,810,1,0,0,0,909,813,1,0,0,0,909, - 819,1,0,0,0,909,824,1,0,0,0,909,832,1,0,0,0,909,839,1,0,0,0,909,847,1, - 0,0,0,909,854,1,0,0,0,909,864,1,0,0,0,909,873,1,0,0,0,909,877,1,0,0,0, - 909,883,1,0,0,0,909,891,1,0,0,0,909,899,1,0,0,0,910,89,1,0,0,0,911,915, - 5,21,0,0,912,914,3,92,46,0,913,912,1,0,0,0,914,917,1,0,0,0,915,913,1,0, - 0,0,915,916,1,0,0,0,916,918,1,0,0,0,917,915,1,0,0,0,918,919,3,2,1,0,919, - 920,3,94,47,0,920,921,5,180,0,0,921,922,5,36,0,0,922,923,5,30,0,0,923, - 924,3,300,150,0,924,925,5,31,0,0,925,926,3,94,47,0,926,938,1,0,0,0,927, - 931,5,21,0,0,928,930,3,92,46,0,929,928,1,0,0,0,930,933,1,0,0,0,931,929, - 1,0,0,0,931,932,1,0,0,0,932,934,1,0,0,0,933,931,1,0,0,0,934,935,3,2,1, - 0,935,936,3,94,47,0,936,938,1,0,0,0,937,911,1,0,0,0,937,927,1,0,0,0,938, - 91,1,0,0,0,939,940,5,76,0,0,940,93,1,0,0,0,941,944,1,0,0,0,942,944,5,298, - 0,0,943,941,1,0,0,0,943,942,1,0,0,0,944,95,1,0,0,0,945,946,7,6,0,0,946, - 97,1,0,0,0,947,949,3,96,48,0,948,947,1,0,0,0,949,952,1,0,0,0,950,948,1, - 0,0,0,950,951,1,0,0,0,951,99,1,0,0,0,952,950,1,0,0,0,953,979,3,102,51, - 0,954,955,5,280,0,0,955,956,3,168,84,0,956,957,6,50,-1,0,957,979,1,0,0, - 0,958,959,5,286,0,0,959,960,3,178,89,0,960,961,6,50,-1,0,961,979,1,0,0, - 0,962,963,5,286,0,0,963,964,3,174,87,0,964,965,6,50,-1,0,965,979,1,0,0, - 0,966,967,5,284,0,0,967,968,3,124,62,0,968,969,6,50,-1,0,969,979,1,0,0, - 0,970,971,5,281,0,0,971,972,3,104,52,0,972,973,6,50,-1,0,973,979,1,0,0, - 0,974,975,5,287,0,0,975,976,3,50,25,0,976,977,6,50,-1,0,977,979,1,0,0, - 0,978,953,1,0,0,0,978,954,1,0,0,0,978,958,1,0,0,0,978,962,1,0,0,0,978, - 966,1,0,0,0,978,970,1,0,0,0,978,974,1,0,0,0,979,101,1,0,0,0,980,981,5, - 275,0,0,981,1059,6,51,-1,0,982,983,5,276,0,0,983,984,3,32,16,0,984,985, - 6,51,-1,0,985,1059,1,0,0,0,986,987,5,276,0,0,987,988,3,0,0,0,988,989,6, - 51,-1,0,989,1059,1,0,0,0,990,991,5,277,0,0,991,992,3,32,16,0,992,993,6, - 51,-1,0,993,1059,1,0,0,0,994,995,5,278,0,0,995,996,3,34,17,0,996,997,6, - 51,-1,0,997,1059,1,0,0,0,998,999,5,279,0,0,999,1000,3,36,18,0,1000,1001, - 6,51,-1,0,1001,1059,1,0,0,0,1002,1003,5,279,0,0,1003,1004,3,34,17,0,1004, - 1005,6,51,-1,0,1005,1059,1,0,0,0,1006,1007,5,279,0,0,1007,1008,5,30,0, - 0,1008,1009,3,300,150,0,1009,1010,5,31,0,0,1010,1011,6,51,-1,0,1011,1059, - 1,0,0,0,1012,1013,5,279,0,0,1013,1014,5,84,0,0,1014,1015,5,30,0,0,1015, - 1016,3,300,150,0,1016,1017,5,31,0,0,1017,1018,6,51,-1,0,1018,1059,1,0, - 0,0,1019,1020,5,282,0,0,1020,1021,3,32,16,0,1021,1022,6,51,-1,0,1022,1059, - 1,0,0,0,1023,1024,5,282,0,0,1024,1025,3,0,0,0,1025,1026,6,51,-1,0,1026, - 1059,1,0,0,0,1027,1028,5,285,0,0,1028,1029,3,6,3,0,1029,1030,6,51,-1,0, - 1030,1059,1,0,0,0,1031,1032,5,285,0,0,1032,1033,5,224,0,0,1033,1034,5, - 30,0,0,1034,1035,3,6,3,0,1035,1036,5,31,0,0,1036,1037,6,51,-1,0,1037,1059, - 1,0,0,0,1038,1039,5,285,0,0,1039,1040,5,84,0,0,1040,1041,5,30,0,0,1041, - 1042,3,300,150,0,1042,1043,5,31,0,0,1043,1044,6,51,-1,0,1044,1059,1,0, - 0,0,1045,1046,5,287,0,0,1046,1047,3,32,16,0,1047,1048,6,51,-1,0,1048,1059, - 1,0,0,0,1049,1050,5,283,0,0,1050,1056,6,51,-1,0,1051,1052,5,30,0,0,1052, - 1053,3,106,53,0,1053,1054,5,31,0,0,1054,1057,1,0,0,0,1055,1057,5,85,0, - 0,1056,1051,1,0,0,0,1056,1055,1,0,0,0,1057,1059,1,0,0,0,1058,980,1,0,0, - 0,1058,982,1,0,0,0,1058,986,1,0,0,0,1058,990,1,0,0,0,1058,994,1,0,0,0, - 1058,998,1,0,0,0,1058,1002,1,0,0,0,1058,1006,1,0,0,0,1058,1012,1,0,0,0, - 1058,1019,1,0,0,0,1058,1023,1,0,0,0,1058,1027,1,0,0,0,1058,1031,1,0,0, - 0,1058,1038,1,0,0,0,1058,1045,1,0,0,0,1058,1049,1,0,0,0,1059,103,1,0,0, - 0,1060,1061,3,170,85,0,1061,1062,3,138,69,0,1062,1063,3,112,56,0,1063, - 1064,6,52,-1,0,1064,105,1,0,0,0,1065,1090,1,0,0,0,1066,1067,3,0,0,0,1067, - 1068,6,53,-1,0,1068,1073,1,0,0,0,1069,1070,3,32,16,0,1070,1071,6,53,-1, - 0,1071,1073,1,0,0,0,1072,1066,1,0,0,0,1072,1069,1,0,0,0,1073,1074,1,0, - 0,0,1074,1075,5,28,0,0,1075,1077,1,0,0,0,1076,1072,1,0,0,0,1077,1080,1, - 0,0,0,1078,1076,1,0,0,0,1078,1079,1,0,0,0,1079,1087,1,0,0,0,1080,1078, - 1,0,0,0,1081,1082,3,0,0,0,1082,1083,6,53,-1,0,1083,1088,1,0,0,0,1084,1085, - 3,32,16,0,1085,1086,6,53,-1,0,1086,1088,1,0,0,0,1087,1081,1,0,0,0,1087, - 1084,1,0,0,0,1088,1090,1,0,0,0,1089,1065,1,0,0,0,1089,1078,1,0,0,0,1090, - 107,1,0,0,0,1091,1098,5,86,0,0,1092,1093,3,138,69,0,1093,1094,6,54,-1, - 0,1094,1095,5,28,0,0,1095,1097,1,0,0,0,1096,1092,1,0,0,0,1097,1100,1,0, - 0,0,1098,1096,1,0,0,0,1098,1099,1,0,0,0,1099,1101,1,0,0,0,1100,1098,1, - 0,0,0,1101,1102,3,138,69,0,1102,1103,6,54,-1,0,1103,1104,5,87,0,0,1104, - 109,1,0,0,0,1105,1112,5,42,0,0,1106,1107,3,146,73,0,1107,1108,6,55,-1, - 0,1108,1109,5,28,0,0,1109,1111,1,0,0,0,1110,1106,1,0,0,0,1111,1114,1,0, - 0,0,1112,1110,1,0,0,0,1112,1113,1,0,0,0,1113,1115,1,0,0,0,1114,1112,1, - 0,0,0,1115,1116,3,146,73,0,1116,1117,6,55,-1,0,1117,1118,5,43,0,0,1118, - 111,1,0,0,0,1119,1126,5,30,0,0,1120,1121,3,114,57,0,1121,1122,6,56,-1, - 0,1122,1123,5,28,0,0,1123,1125,1,0,0,0,1124,1120,1,0,0,0,1125,1128,1,0, - 0,0,1126,1124,1,0,0,0,1126,1127,1,0,0,0,1127,1129,1,0,0,0,1128,1126,1, - 0,0,0,1129,1130,3,114,57,0,1130,1131,6,56,-1,0,1131,1132,5,31,0,0,1132, - 1135,1,0,0,0,1133,1135,5,85,0,0,1134,1119,1,0,0,0,1134,1133,1,0,0,0,1135, - 113,1,0,0,0,1136,1137,5,177,0,0,1137,1147,6,57,-1,0,1138,1139,3,230,115, - 0,1139,1140,3,138,69,0,1140,1142,3,226,113,0,1141,1143,3,0,0,0,1142,1141, - 1,0,0,0,1142,1143,1,0,0,0,1143,1144,1,0,0,0,1144,1145,6,57,-1,0,1145,1147, - 1,0,0,0,1146,1136,1,0,0,0,1146,1138,1,0,0,0,1147,115,1,0,0,0,1148,1149, - 5,42,0,0,1149,1150,3,2,1,0,1150,1151,5,43,0,0,1151,1152,3,118,59,0,1152, - 1153,6,58,-1,0,1153,1186,1,0,0,0,1154,1155,5,42,0,0,1155,1156,3,174,87, - 0,1156,1157,5,43,0,0,1157,1158,3,118,59,0,1158,1159,6,58,-1,0,1159,1186, - 1,0,0,0,1160,1161,5,42,0,0,1161,1162,5,262,0,0,1162,1163,5,43,0,0,1163, - 1164,3,118,59,0,1164,1165,6,58,-1,0,1165,1186,1,0,0,0,1166,1167,5,42,0, - 0,1167,1168,5,198,0,0,1168,1169,3,2,1,0,1169,1170,5,43,0,0,1170,1171,3, - 118,59,0,1171,1172,6,58,-1,0,1172,1186,1,0,0,0,1173,1174,3,118,59,0,1174, - 1175,6,58,-1,0,1175,1186,1,0,0,0,1176,1177,3,174,87,0,1177,1178,6,58,-1, - 0,1178,1186,1,0,0,0,1179,1180,5,257,0,0,1180,1186,6,58,-1,0,1181,1182, - 5,258,0,0,1182,1186,6,58,-1,0,1183,1184,5,259,0,0,1184,1186,6,58,-1,0, - 1185,1148,1,0,0,0,1185,1154,1,0,0,0,1185,1160,1,0,0,0,1185,1166,1,0,0, - 0,1185,1173,1,0,0,0,1185,1176,1,0,0,0,1185,1179,1,0,0,0,1185,1181,1,0, - 0,0,1185,1183,1,0,0,0,1186,117,1,0,0,0,1187,1188,3,2,1,0,1188,1189,6,59, - -1,0,1189,1190,5,88,0,0,1190,1192,1,0,0,0,1191,1187,1,0,0,0,1192,1195, - 1,0,0,0,1193,1191,1,0,0,0,1193,1194,1,0,0,0,1194,1196,1,0,0,0,1195,1193, - 1,0,0,0,1196,1197,3,2,1,0,1197,1198,6,59,-1,0,1198,119,1,0,0,0,1199,1201, - 3,122,61,0,1200,1199,1,0,0,0,1201,1204,1,0,0,0,1202,1200,1,0,0,0,1202, - 1203,1,0,0,0,1203,121,1,0,0,0,1204,1202,1,0,0,0,1205,1206,5,180,0,0,1206, - 1207,5,89,0,0,1207,1211,3,32,16,0,1208,1211,3,152,76,0,1209,1211,3,332, - 166,0,1210,1205,1,0,0,0,1210,1208,1,0,0,0,1210,1209,1,0,0,0,1211,123,1, - 0,0,0,1212,1213,3,116,58,0,1213,1214,6,62,-1,0,1214,1230,1,0,0,0,1215, - 1216,5,42,0,0,1216,1217,3,2,1,0,1217,1218,5,43,0,0,1218,1219,6,62,-1,0, - 1219,1230,1,0,0,0,1220,1221,5,42,0,0,1221,1222,5,198,0,0,1222,1223,3,2, - 1,0,1223,1224,5,43,0,0,1224,1225,6,62,-1,0,1225,1230,1,0,0,0,1226,1227, - 3,138,69,0,1227,1228,6,62,-1,0,1228,1230,1,0,0,0,1229,1212,1,0,0,0,1229, - 1215,1,0,0,0,1229,1220,1,0,0,0,1229,1226,1,0,0,0,1230,125,1,0,0,0,1231, - 1243,1,0,0,0,1232,1233,3,130,65,0,1233,1239,6,63,-1,0,1234,1235,3,128, - 64,0,1235,1236,6,63,-1,0,1236,1238,1,0,0,0,1237,1234,1,0,0,0,1238,1241, - 1,0,0,0,1239,1237,1,0,0,0,1239,1240,1,0,0,0,1240,1243,1,0,0,0,1241,1239, - 1,0,0,0,1242,1231,1,0,0,0,1242,1232,1,0,0,0,1243,127,1,0,0,0,1244,1245, - 5,262,0,0,1245,1267,6,64,-1,0,1246,1247,5,261,0,0,1247,1267,6,64,-1,0, - 1248,1249,5,42,0,0,1249,1250,3,32,16,0,1250,1251,5,43,0,0,1251,1252,6, - 64,-1,0,1252,1267,1,0,0,0,1253,1254,5,42,0,0,1254,1255,3,32,16,0,1255, - 1256,5,266,0,0,1256,1257,3,32,16,0,1257,1258,5,43,0,0,1258,1259,6,64,-1, - 0,1259,1267,1,0,0,0,1260,1261,5,42,0,0,1261,1262,5,266,0,0,1262,1263,3, - 32,16,0,1263,1264,5,43,0,0,1264,1265,6,64,-1,0,1265,1267,1,0,0,0,1266, - 1244,1,0,0,0,1266,1246,1,0,0,0,1266,1248,1,0,0,0,1266,1253,1,0,0,0,1266, - 1260,1,0,0,0,1267,129,1,0,0,0,1268,1414,6,65,-1,0,1269,1270,5,203,0,0, - 1270,1271,5,30,0,0,1271,1272,3,6,3,0,1272,1273,5,28,0,0,1273,1274,3,6, - 3,0,1274,1275,5,28,0,0,1275,1276,3,6,3,0,1276,1277,5,28,0,0,1277,1278, - 3,6,3,0,1278,1279,5,31,0,0,1279,1280,6,65,-1,0,1280,1414,1,0,0,0,1281, - 1282,5,203,0,0,1282,1283,5,30,0,0,1283,1284,3,6,3,0,1284,1285,5,28,0,0, - 1285,1286,3,6,3,0,1286,1287,5,31,0,0,1287,1288,6,65,-1,0,1288,1414,1,0, - 0,0,1289,1290,5,204,0,0,1290,1291,5,205,0,0,1291,1292,5,42,0,0,1292,1293, - 3,32,16,0,1293,1294,5,43,0,0,1294,1295,6,65,-1,0,1295,1414,1,0,0,0,1296, - 1297,5,204,0,0,1297,1298,5,206,0,0,1298,1299,5,42,0,0,1299,1300,3,32,16, - 0,1300,1301,5,43,0,0,1301,1302,3,126,63,0,1302,1303,6,65,-1,0,1303,1414, - 1,0,0,0,1304,1305,5,207,0,0,1305,1414,6,65,-1,0,1306,1307,5,208,0,0,1307, - 1414,6,65,-1,0,1308,1309,5,209,0,0,1309,1414,6,65,-1,0,1310,1311,5,201, - 0,0,1311,1414,6,65,-1,0,1312,1313,5,183,0,0,1313,1414,6,65,-1,0,1314,1315, - 5,184,0,0,1315,1414,6,65,-1,0,1316,1317,5,185,0,0,1317,1414,6,65,-1,0, - 1318,1319,5,186,0,0,1319,1414,6,65,-1,0,1320,1321,5,187,0,0,1321,1414, - 6,65,-1,0,1322,1323,5,188,0,0,1323,1414,6,65,-1,0,1324,1325,5,189,0,0, - 1325,1414,6,65,-1,0,1326,1327,5,210,0,0,1327,1414,6,65,-1,0,1328,1329, - 5,190,0,0,1329,1414,6,65,-1,0,1330,1331,5,191,0,0,1331,1414,6,65,-1,0, - 1332,1333,5,192,0,0,1333,1414,6,65,-1,0,1334,1335,5,193,0,0,1335,1414, - 6,65,-1,0,1336,1337,5,211,0,0,1337,1414,6,65,-1,0,1338,1339,5,212,0,0, - 1339,1414,6,65,-1,0,1340,1341,5,213,0,0,1341,1414,6,65,-1,0,1342,1343, - 5,214,0,0,1343,1414,6,65,-1,0,1344,1345,5,215,0,0,1345,1414,6,65,-1,0, - 1346,1347,5,216,0,0,1347,1414,6,65,-1,0,1348,1349,5,217,0,0,1349,1414, - 6,65,-1,0,1350,1351,5,218,0,0,1351,1352,3,132,66,0,1352,1353,6,65,-1,0, - 1353,1414,1,0,0,0,1354,1355,5,219,0,0,1355,1356,3,132,66,0,1356,1357,6, - 65,-1,0,1357,1414,1,0,0,0,1358,1359,5,220,0,0,1359,1414,6,65,-1,0,1360, - 1361,5,221,0,0,1361,1362,3,132,66,0,1362,1363,6,65,-1,0,1363,1414,1,0, - 0,0,1364,1365,5,222,0,0,1365,1366,3,134,67,0,1366,1367,6,65,-1,0,1367, - 1414,1,0,0,0,1368,1369,5,222,0,0,1369,1370,3,134,67,0,1370,1371,5,28,0, - 0,1371,1372,3,6,3,0,1372,1373,6,65,-1,0,1373,1414,1,0,0,0,1374,1375,5, - 194,0,0,1375,1414,6,65,-1,0,1376,1377,5,195,0,0,1377,1414,6,65,-1,0,1378, - 1379,5,90,0,0,1379,1380,5,184,0,0,1380,1414,6,65,-1,0,1381,1382,5,90,0, - 0,1382,1383,5,185,0,0,1383,1414,6,65,-1,0,1384,1385,5,90,0,0,1385,1386, - 5,186,0,0,1386,1414,6,65,-1,0,1387,1388,5,90,0,0,1388,1389,5,187,0,0,1389, - 1414,6,65,-1,0,1390,1391,5,62,0,0,1391,1392,5,220,0,0,1392,1414,6,65,-1, - 0,1393,1394,5,223,0,0,1394,1414,6,65,-1,0,1395,1396,5,224,0,0,1396,1397, - 5,213,0,0,1397,1414,6,65,-1,0,1398,1399,5,225,0,0,1399,1414,6,65,-1,0, - 1400,1401,5,207,0,0,1401,1402,5,183,0,0,1402,1414,6,65,-1,0,1403,1404, - 5,226,0,0,1404,1414,6,65,-1,0,1405,1406,5,228,0,0,1406,1414,6,65,-1,0, - 1407,1408,5,34,0,0,1408,1409,5,227,0,0,1409,1414,6,65,-1,0,1410,1411,3, - 2,1,0,1411,1412,6,65,-1,0,1412,1414,1,0,0,0,1413,1268,1,0,0,0,1413,1269, - 1,0,0,0,1413,1281,1,0,0,0,1413,1289,1,0,0,0,1413,1296,1,0,0,0,1413,1304, - 1,0,0,0,1413,1306,1,0,0,0,1413,1308,1,0,0,0,1413,1310,1,0,0,0,1413,1312, - 1,0,0,0,1413,1314,1,0,0,0,1413,1316,1,0,0,0,1413,1318,1,0,0,0,1413,1320, - 1,0,0,0,1413,1322,1,0,0,0,1413,1324,1,0,0,0,1413,1326,1,0,0,0,1413,1328, - 1,0,0,0,1413,1330,1,0,0,0,1413,1332,1,0,0,0,1413,1334,1,0,0,0,1413,1336, - 1,0,0,0,1413,1338,1,0,0,0,1413,1340,1,0,0,0,1413,1342,1,0,0,0,1413,1344, - 1,0,0,0,1413,1346,1,0,0,0,1413,1348,1,0,0,0,1413,1350,1,0,0,0,1413,1354, - 1,0,0,0,1413,1358,1,0,0,0,1413,1360,1,0,0,0,1413,1364,1,0,0,0,1413,1368, - 1,0,0,0,1413,1374,1,0,0,0,1413,1376,1,0,0,0,1413,1378,1,0,0,0,1413,1381, - 1,0,0,0,1413,1384,1,0,0,0,1413,1387,1,0,0,0,1413,1390,1,0,0,0,1413,1393, - 1,0,0,0,1413,1395,1,0,0,0,1413,1398,1,0,0,0,1413,1400,1,0,0,0,1413,1403, - 1,0,0,0,1413,1405,1,0,0,0,1413,1407,1,0,0,0,1413,1410,1,0,0,0,1414,131, - 1,0,0,0,1415,1424,1,0,0,0,1416,1417,5,30,0,0,1417,1418,5,91,0,0,1418,1419, - 5,36,0,0,1419,1420,3,32,16,0,1420,1421,5,31,0,0,1421,1422,6,66,-1,0,1422, - 1424,1,0,0,0,1423,1415,1,0,0,0,1423,1416,1,0,0,0,1424,133,1,0,0,0,1425, - 1436,1,0,0,0,1426,1427,3,136,68,0,1427,1432,6,67,-1,0,1428,1429,7,7,0, - 0,1429,1431,6,67,-1,0,1430,1428,1,0,0,0,1431,1434,1,0,0,0,1432,1430,1, - 0,0,0,1432,1433,1,0,0,0,1433,1436,1,0,0,0,1434,1432,1,0,0,0,1435,1425, + 3,166,3315,8,166,1,167,1,167,1,167,1,167,1,167,1,167,1,167,1,167,1,167, + 1,167,1,167,1,167,3,167,3329,8,167,1,168,5,168,3332,8,168,10,168,12,168, + 3335,9,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,169,3,169,3351,8,169,1,170,1,170,1,170,5,170,3356, + 8,170,10,170,12,170,3359,9,170,1,170,1,170,1,171,1,171,5,171,3365,8,171, + 10,171,12,171,3368,9,171,1,171,1,171,1,172,1,172,1,172,1,172,1,172,1,172, + 1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,3,172,3387,8,172, + 1,173,5,173,3390,8,173,10,173,12,173,3393,9,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,3,174,3408,8,174, + 1,175,1,175,5,175,3412,8,175,10,175,12,175,3415,9,175,1,175,1,175,1,175, + 5,175,3420,8,175,10,175,12,175,3423,9,175,1,175,1,175,1,175,1,175,3,175, + 3429,8,175,1,176,1,176,1,177,5,177,3434,8,177,10,177,12,177,3437,9,177, + 1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,3,178,3449, + 8,178,1,178,0,1,68,179,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,0,14,6,0,1,15,199,199,243,243,247, + 247,264,264,289,289,5,0,16,16,199,199,243,243,264,264,288,289,1,0,263, + 264,1,0,173,174,1,0,37,38,1,0,73,74,3,0,2,2,61,61,77,83,2,0,229,229,260, + 261,1,0,95,96,1,0,97,111,2,0,173,173,289,290,2,0,179,179,264,264,1,0,167, + 168,1,0,51,52,3915,0,358,1,0,0,0,2,376,1,0,0,0,4,378,1,0,0,0,6,385,1,0, + 0,0,8,394,1,0,0,0,10,447,1,0,0,0,12,449,1,0,0,0,14,452,1,0,0,0,16,455, + 1,0,0,0,18,459,1,0,0,0,20,462,1,0,0,0,22,465,1,0,0,0,24,472,1,0,0,0,26, + 488,1,0,0,0,28,490,1,0,0,0,30,492,1,0,0,0,32,502,1,0,0,0,34,504,1,0,0, + 0,36,527,1,0,0,0,38,531,1,0,0,0,40,549,1,0,0,0,42,576,1,0,0,0,44,599,1, + 0,0,0,46,635,1,0,0,0,48,637,1,0,0,0,50,645,1,0,0,0,52,647,1,0,0,0,54,654, + 1,0,0,0,56,666,1,0,0,0,58,669,1,0,0,0,60,671,1,0,0,0,62,684,1,0,0,0,64, + 692,1,0,0,0,66,694,1,0,0,0,68,702,1,0,0,0,70,718,1,0,0,0,72,724,1,0,0, + 0,74,727,1,0,0,0,76,776,1,0,0,0,78,781,1,0,0,0,80,786,1,0,0,0,82,791,1, + 0,0,0,84,799,1,0,0,0,86,804,1,0,0,0,88,909,1,0,0,0,90,937,1,0,0,0,92,939, + 1,0,0,0,94,943,1,0,0,0,96,945,1,0,0,0,98,950,1,0,0,0,100,978,1,0,0,0,102, + 1058,1,0,0,0,104,1060,1,0,0,0,106,1089,1,0,0,0,108,1091,1,0,0,0,110,1105, + 1,0,0,0,112,1134,1,0,0,0,114,1146,1,0,0,0,116,1185,1,0,0,0,118,1193,1, + 0,0,0,120,1202,1,0,0,0,122,1210,1,0,0,0,124,1229,1,0,0,0,126,1242,1,0, + 0,0,128,1266,1,0,0,0,130,1413,1,0,0,0,132,1423,1,0,0,0,134,1435,1,0,0, + 0,136,1517,1,0,0,0,138,1519,1,0,0,0,140,1558,1,0,0,0,142,1618,1,0,0,0, + 144,1658,1,0,0,0,146,1674,1,0,0,0,148,1676,1,0,0,0,150,1680,1,0,0,0,152, + 1735,1,0,0,0,154,1747,1,0,0,0,156,1762,1,0,0,0,158,1769,1,0,0,0,160,1774, + 1,0,0,0,162,1778,1,0,0,0,164,1814,1,0,0,0,166,1816,1,0,0,0,168,1860,1, + 0,0,0,170,1879,1,0,0,0,172,1900,1,0,0,0,174,1902,1,0,0,0,176,1919,1,0, + 0,0,178,1934,1,0,0,0,180,1942,1,0,0,0,182,1954,1,0,0,0,184,1974,1,0,0, + 0,186,1981,1,0,0,0,188,1984,1,0,0,0,190,1997,1,0,0,0,192,2003,1,0,0,0, + 194,2009,1,0,0,0,196,2013,1,0,0,0,198,2170,1,0,0,0,200,2172,1,0,0,0,202, + 2228,1,0,0,0,204,2239,1,0,0,0,206,2246,1,0,0,0,208,2254,1,0,0,0,210,2281, + 1,0,0,0,212,2287,1,0,0,0,214,2292,1,0,0,0,216,2321,1,0,0,0,218,2323,1, + 0,0,0,220,2343,1,0,0,0,222,2348,1,0,0,0,224,2373,1,0,0,0,226,2382,1,0, + 0,0,228,2397,1,0,0,0,230,2404,1,0,0,0,232,2424,1,0,0,0,234,2426,1,0,0, + 0,236,2497,1,0,0,0,238,2522,1,0,0,0,240,2566,1,0,0,0,242,2575,1,0,0,0, + 244,2615,1,0,0,0,246,2620,1,0,0,0,248,2660,1,0,0,0,250,2662,1,0,0,0,252, + 2668,1,0,0,0,254,2676,1,0,0,0,256,2696,1,0,0,0,258,2763,1,0,0,0,260,2765, + 1,0,0,0,262,2771,1,0,0,0,264,2773,1,0,0,0,266,2777,1,0,0,0,268,2783,1, + 0,0,0,270,2803,1,0,0,0,272,2821,1,0,0,0,274,2835,1,0,0,0,276,2837,1,0, + 0,0,278,2840,1,0,0,0,280,2842,1,0,0,0,282,2859,1,0,0,0,284,2861,1,0,0, + 0,286,2871,1,0,0,0,288,2876,1,0,0,0,290,2887,1,0,0,0,292,2894,1,0,0,0, + 294,2904,1,0,0,0,296,2972,1,0,0,0,298,3049,1,0,0,0,300,3056,1,0,0,0,302, + 3059,1,0,0,0,304,3064,1,0,0,0,306,3214,1,0,0,0,308,3220,1,0,0,0,310,3227, + 1,0,0,0,312,3233,1,0,0,0,314,3239,1,0,0,0,316,3245,1,0,0,0,318,3251,1, + 0,0,0,320,3257,1,0,0,0,322,3263,1,0,0,0,324,3269,1,0,0,0,326,3276,1,0, + 0,0,328,3281,1,0,0,0,330,3287,1,0,0,0,332,3314,1,0,0,0,334,3328,1,0,0, + 0,336,3333,1,0,0,0,338,3350,1,0,0,0,340,3352,1,0,0,0,342,3362,1,0,0,0, + 344,3386,1,0,0,0,346,3391,1,0,0,0,348,3407,1,0,0,0,350,3428,1,0,0,0,352, + 3430,1,0,0,0,354,3435,1,0,0,0,356,3448,1,0,0,0,358,359,7,0,0,0,359,1,1, + 0,0,0,360,361,5,288,0,0,361,377,6,1,-1,0,362,363,3,4,2,0,363,364,6,1,-1, + 0,364,365,5,265,0,0,365,367,1,0,0,0,366,362,1,0,0,0,367,370,1,0,0,0,368, + 366,1,0,0,0,368,369,1,0,0,0,369,371,1,0,0,0,370,368,1,0,0,0,371,372,3, + 4,2,0,372,373,6,1,-1,0,373,377,1,0,0,0,374,375,5,264,0,0,375,377,6,1,-1, + 0,376,360,1,0,0,0,376,368,1,0,0,0,376,374,1,0,0,0,377,3,1,0,0,0,378,379, + 7,1,0,0,379,5,1,0,0,0,380,381,5,263,0,0,381,382,6,3,-1,0,382,384,5,266, + 0,0,383,380,1,0,0,0,384,387,1,0,0,0,385,383,1,0,0,0,385,386,1,0,0,0,386, + 388,1,0,0,0,387,385,1,0,0,0,388,389,5,263,0,0,389,390,6,3,-1,0,390,7,1, + 0,0,0,391,393,3,10,5,0,392,391,1,0,0,0,393,396,1,0,0,0,394,392,1,0,0,0, + 394,395,1,0,0,0,395,9,1,0,0,0,396,394,1,0,0,0,397,398,3,74,37,0,398,399, + 5,17,0,0,399,400,3,82,41,0,400,401,5,18,0,0,401,448,1,0,0,0,402,403,3, + 72,36,0,403,404,5,17,0,0,404,405,3,8,4,0,405,406,5,18,0,0,406,448,1,0, + 0,0,407,408,3,234,117,0,408,409,5,17,0,0,409,410,3,246,123,0,410,411,5, + 18,0,0,411,448,1,0,0,0,412,448,3,200,100,0,413,448,3,284,142,0,414,448, + 3,70,35,0,415,448,3,66,33,0,416,448,3,88,44,0,417,448,3,90,45,0,418,448, + 3,22,11,0,419,420,3,334,167,0,420,421,5,17,0,0,421,422,3,336,168,0,422, + 423,5,18,0,0,423,448,1,0,0,0,424,425,3,340,170,0,425,426,5,17,0,0,426, + 427,3,346,173,0,427,428,5,18,0,0,428,448,1,0,0,0,429,430,3,350,175,0,430, + 431,5,17,0,0,431,432,3,354,177,0,432,433,5,18,0,0,433,448,1,0,0,0,434, + 448,3,64,32,0,435,448,3,152,76,0,436,448,3,330,165,0,437,448,3,12,6,0, + 438,448,3,14,7,0,439,448,3,16,8,0,440,448,3,18,9,0,441,448,3,20,10,0,442, + 448,3,26,13,0,443,448,3,42,21,0,444,448,3,40,20,0,445,448,3,30,15,0,446, + 448,3,24,12,0,447,397,1,0,0,0,447,402,1,0,0,0,447,407,1,0,0,0,447,412, + 1,0,0,0,447,413,1,0,0,0,447,414,1,0,0,0,447,415,1,0,0,0,447,416,1,0,0, + 0,447,417,1,0,0,0,447,418,1,0,0,0,447,419,1,0,0,0,447,424,1,0,0,0,447, + 429,1,0,0,0,447,434,1,0,0,0,447,435,1,0,0,0,447,436,1,0,0,0,447,437,1, + 0,0,0,447,438,1,0,0,0,447,439,1,0,0,0,447,440,1,0,0,0,447,441,1,0,0,0, + 447,442,1,0,0,0,447,443,1,0,0,0,447,444,1,0,0,0,447,445,1,0,0,0,447,446, + 1,0,0,0,448,11,1,0,0,0,449,450,5,19,0,0,450,451,3,32,16,0,451,13,1,0,0, + 0,452,453,5,20,0,0,453,454,3,32,16,0,454,15,1,0,0,0,455,456,5,21,0,0,456, + 457,5,22,0,0,457,458,3,32,16,0,458,17,1,0,0,0,459,460,5,23,0,0,460,461, + 3,34,17,0,461,19,1,0,0,0,462,463,5,24,0,0,463,464,3,34,17,0,464,21,1,0, + 0,0,465,466,5,25,0,0,466,467,3,98,49,0,467,468,3,2,1,0,468,469,5,17,0, + 0,469,470,3,120,60,0,470,471,5,18,0,0,471,23,1,0,0,0,472,473,5,26,0,0, + 473,25,1,0,0,0,474,475,5,27,0,0,475,489,3,28,14,0,476,477,5,27,0,0,477, + 478,3,28,14,0,478,479,5,28,0,0,479,480,3,28,14,0,480,489,1,0,0,0,481,482, + 5,27,0,0,482,483,3,28,14,0,483,484,5,28,0,0,484,485,3,28,14,0,485,486, + 5,28,0,0,486,487,3,28,14,0,487,489,1,0,0,0,488,474,1,0,0,0,488,476,1,0, + 0,0,488,481,1,0,0,0,489,27,1,0,0,0,490,491,7,2,0,0,491,29,1,0,0,0,492, + 493,5,29,0,0,493,497,5,17,0,0,494,496,3,116,58,0,495,494,1,0,0,0,496,499, + 1,0,0,0,497,495,1,0,0,0,497,498,1,0,0,0,498,500,1,0,0,0,499,497,1,0,0, + 0,500,501,5,18,0,0,501,31,1,0,0,0,502,503,5,173,0,0,503,33,1,0,0,0,504, + 505,7,3,0,0,505,35,1,0,0,0,506,507,5,175,0,0,507,528,6,18,-1,0,508,509, + 3,32,16,0,509,510,5,265,0,0,510,511,6,18,-1,0,511,528,1,0,0,0,512,513, + 3,32,16,0,513,514,6,18,-1,0,514,528,1,0,0,0,515,516,5,188,0,0,516,517, + 5,30,0,0,517,518,3,32,16,0,518,519,5,31,0,0,519,520,6,18,-1,0,520,528, + 1,0,0,0,521,522,5,189,0,0,522,523,5,30,0,0,523,524,3,34,17,0,524,525,5, + 31,0,0,525,526,6,18,-1,0,526,528,1,0,0,0,527,506,1,0,0,0,527,508,1,0,0, + 0,527,512,1,0,0,0,527,515,1,0,0,0,527,521,1,0,0,0,528,37,1,0,0,0,529,532, + 3,32,16,0,530,532,5,262,0,0,531,529,1,0,0,0,531,530,1,0,0,0,532,39,1,0, + 0,0,533,534,5,267,0,0,534,550,5,289,0,0,535,536,5,267,0,0,536,537,5,289, + 0,0,537,550,5,263,0,0,538,539,5,268,0,0,539,550,5,289,0,0,540,541,5,269, + 0,0,541,550,5,289,0,0,542,543,5,270,0,0,543,550,5,289,0,0,544,550,5,271, + 0,0,545,550,5,272,0,0,546,547,5,273,0,0,547,550,5,263,0,0,548,550,5,32, + 0,0,549,533,1,0,0,0,549,535,1,0,0,0,549,538,1,0,0,0,549,540,1,0,0,0,549, + 542,1,0,0,0,549,544,1,0,0,0,549,545,1,0,0,0,549,546,1,0,0,0,549,548,1, + 0,0,0,550,41,1,0,0,0,551,552,5,33,0,0,552,553,3,138,69,0,553,554,5,34, + 0,0,554,555,3,2,1,0,555,577,1,0,0,0,556,557,5,33,0,0,557,558,3,116,58, + 0,558,559,5,34,0,0,559,560,3,2,1,0,560,577,1,0,0,0,561,562,5,33,0,0,562, + 563,3,176,88,0,563,564,5,34,0,0,564,565,3,2,1,0,565,577,1,0,0,0,566,567, + 5,33,0,0,567,568,3,44,22,0,568,569,5,34,0,0,569,570,3,2,1,0,570,577,1, + 0,0,0,571,572,5,33,0,0,572,573,3,46,23,0,573,574,5,34,0,0,574,575,3,2, + 1,0,575,577,1,0,0,0,576,551,1,0,0,0,576,556,1,0,0,0,576,561,1,0,0,0,576, + 566,1,0,0,0,576,571,1,0,0,0,577,43,1,0,0,0,578,579,5,35,0,0,579,600,3, + 48,24,0,580,581,5,35,0,0,581,582,3,48,24,0,582,583,5,36,0,0,583,584,3, + 6,3,0,584,600,1,0,0,0,585,586,5,35,0,0,586,587,3,48,24,0,587,588,5,36, + 0,0,588,589,5,17,0,0,589,590,3,52,26,0,590,591,5,18,0,0,591,600,1,0,0, + 0,592,593,5,35,0,0,593,594,3,48,24,0,594,595,5,36,0,0,595,596,5,30,0,0, + 596,597,3,300,150,0,597,598,5,31,0,0,598,600,1,0,0,0,599,578,1,0,0,0,599, + 580,1,0,0,0,599,585,1,0,0,0,599,592,1,0,0,0,600,45,1,0,0,0,601,602,5,35, + 0,0,602,603,5,30,0,0,603,604,3,50,25,0,604,605,5,31,0,0,605,606,3,48,24, + 0,606,636,1,0,0,0,607,608,5,35,0,0,608,609,5,30,0,0,609,610,3,50,25,0, + 610,611,5,31,0,0,611,612,3,48,24,0,612,613,5,36,0,0,613,614,3,6,3,0,614, + 636,1,0,0,0,615,616,5,35,0,0,616,617,5,30,0,0,617,618,3,50,25,0,618,619, + 5,31,0,0,619,620,3,48,24,0,620,621,5,36,0,0,621,622,5,17,0,0,622,623,3, + 52,26,0,623,624,5,18,0,0,624,636,1,0,0,0,625,626,5,35,0,0,626,627,5,30, + 0,0,627,628,3,50,25,0,628,629,5,31,0,0,629,630,3,48,24,0,630,631,5,36, + 0,0,631,632,5,30,0,0,632,633,3,300,150,0,633,634,5,31,0,0,634,636,1,0, + 0,0,635,601,1,0,0,0,635,607,1,0,0,0,635,615,1,0,0,0,635,625,1,0,0,0,636, + 47,1,0,0,0,637,638,3,168,84,0,638,49,1,0,0,0,639,640,3,124,62,0,640,641, + 6,25,-1,0,641,646,1,0,0,0,642,643,3,176,88,0,643,644,6,25,-1,0,644,646, + 1,0,0,0,645,639,1,0,0,0,645,642,1,0,0,0,646,51,1,0,0,0,647,648,3,54,27, + 0,648,649,3,56,28,0,649,53,1,0,0,0,650,653,3,306,153,0,651,653,3,40,20, + 0,652,650,1,0,0,0,652,651,1,0,0,0,653,656,1,0,0,0,654,652,1,0,0,0,654, + 655,1,0,0,0,655,55,1,0,0,0,656,654,1,0,0,0,657,658,3,58,29,0,658,659,3, + 60,30,0,659,660,3,2,1,0,660,661,5,36,0,0,661,662,3,306,153,0,662,665,1, + 0,0,0,663,665,3,40,20,0,664,657,1,0,0,0,664,663,1,0,0,0,665,668,1,0,0, + 0,666,664,1,0,0,0,666,667,1,0,0,0,667,57,1,0,0,0,668,666,1,0,0,0,669,670, + 7,4,0,0,670,59,1,0,0,0,671,673,3,62,31,0,672,674,5,261,0,0,673,672,1,0, + 0,0,673,674,1,0,0,0,674,61,1,0,0,0,675,685,3,144,72,0,676,685,3,2,1,0, + 677,685,5,196,0,0,678,685,5,197,0,0,679,680,5,202,0,0,680,681,5,39,0,0, + 681,685,5,264,0,0,682,683,5,202,0,0,683,685,3,116,58,0,684,675,1,0,0,0, + 684,676,1,0,0,0,684,677,1,0,0,0,684,678,1,0,0,0,684,679,1,0,0,0,684,682, + 1,0,0,0,685,63,1,0,0,0,686,687,5,198,0,0,687,688,5,40,0,0,688,693,3,2, + 1,0,689,690,5,198,0,0,690,693,3,2,1,0,691,693,5,198,0,0,692,686,1,0,0, + 0,692,689,1,0,0,0,692,691,1,0,0,0,693,65,1,0,0,0,694,695,5,41,0,0,695, + 696,5,42,0,0,696,697,3,32,16,0,697,698,5,43,0,0,698,699,3,68,34,0,699, + 700,5,44,0,0,700,701,3,0,0,0,701,67,1,0,0,0,702,715,6,34,-1,0,703,704, + 10,5,0,0,704,714,5,186,0,0,705,706,10,4,0,0,706,714,5,187,0,0,707,708, + 10,3,0,0,708,714,5,45,0,0,709,710,10,2,0,0,710,714,5,46,0,0,711,712,10, + 1,0,0,712,714,5,47,0,0,713,703,1,0,0,0,713,705,1,0,0,0,713,707,1,0,0,0, + 713,709,1,0,0,0,713,711,1,0,0,0,714,717,1,0,0,0,715,713,1,0,0,0,715,716, + 1,0,0,0,716,69,1,0,0,0,717,715,1,0,0,0,718,719,5,48,0,0,719,720,5,36,0, + 0,720,721,5,30,0,0,721,722,3,300,150,0,722,723,5,31,0,0,723,71,1,0,0,0, + 724,725,5,49,0,0,725,726,3,2,1,0,726,73,1,0,0,0,727,731,5,50,0,0,728,730, + 3,76,38,0,729,728,1,0,0,0,730,733,1,0,0,0,731,729,1,0,0,0,731,732,1,0, + 0,0,732,734,1,0,0,0,733,731,1,0,0,0,734,735,3,2,1,0,735,736,3,182,91,0, + 736,737,3,78,39,0,737,738,3,80,40,0,738,75,1,0,0,0,739,777,5,51,0,0,740, + 777,5,52,0,0,741,777,5,199,0,0,742,777,5,202,0,0,743,777,5,221,0,0,744, + 777,5,53,0,0,745,777,5,54,0,0,746,777,5,55,0,0,747,777,5,56,0,0,748,777, + 5,244,0,0,749,777,5,15,0,0,750,777,5,224,0,0,751,777,5,57,0,0,752,777, + 5,58,0,0,753,777,5,59,0,0,754,777,5,60,0,0,755,777,5,61,0,0,756,757,5, + 62,0,0,757,777,5,51,0,0,758,759,5,62,0,0,759,777,5,52,0,0,760,761,5,62, + 0,0,761,777,5,63,0,0,762,763,5,62,0,0,763,777,5,64,0,0,764,765,5,62,0, + 0,765,777,5,65,0,0,766,767,5,62,0,0,767,777,5,66,0,0,768,777,5,67,0,0, + 769,777,5,68,0,0,770,777,5,69,0,0,771,772,5,70,0,0,772,773,5,30,0,0,773, + 774,3,32,16,0,774,775,5,31,0,0,775,777,1,0,0,0,776,739,1,0,0,0,776,740, + 1,0,0,0,776,741,1,0,0,0,776,742,1,0,0,0,776,743,1,0,0,0,776,744,1,0,0, + 0,776,745,1,0,0,0,776,746,1,0,0,0,776,747,1,0,0,0,776,748,1,0,0,0,776, + 749,1,0,0,0,776,750,1,0,0,0,776,751,1,0,0,0,776,752,1,0,0,0,776,753,1, + 0,0,0,776,754,1,0,0,0,776,755,1,0,0,0,776,756,1,0,0,0,776,758,1,0,0,0, + 776,760,1,0,0,0,776,762,1,0,0,0,776,764,1,0,0,0,776,766,1,0,0,0,776,768, + 1,0,0,0,776,769,1,0,0,0,776,770,1,0,0,0,776,771,1,0,0,0,777,77,1,0,0,0, + 778,782,1,0,0,0,779,780,5,71,0,0,780,782,3,124,62,0,781,778,1,0,0,0,781, + 779,1,0,0,0,782,79,1,0,0,0,783,787,1,0,0,0,784,785,5,72,0,0,785,787,3, + 84,42,0,786,783,1,0,0,0,786,784,1,0,0,0,787,81,1,0,0,0,788,790,3,198,99, + 0,789,788,1,0,0,0,790,793,1,0,0,0,791,789,1,0,0,0,791,792,1,0,0,0,792, + 83,1,0,0,0,793,791,1,0,0,0,794,795,3,124,62,0,795,796,5,28,0,0,796,798, + 1,0,0,0,797,794,1,0,0,0,798,801,1,0,0,0,799,797,1,0,0,0,799,800,1,0,0, + 0,800,802,1,0,0,0,801,799,1,0,0,0,802,803,3,124,62,0,803,85,1,0,0,0,804, + 805,7,5,0,0,805,87,1,0,0,0,806,807,3,86,43,0,807,808,3,32,16,0,808,809, + 5,264,0,0,809,910,1,0,0,0,810,811,3,86,43,0,811,812,3,32,16,0,812,910, + 1,0,0,0,813,814,3,86,43,0,814,815,3,32,16,0,815,816,5,75,0,0,816,817,3, + 32,16,0,817,818,5,264,0,0,818,910,1,0,0,0,819,820,3,86,43,0,820,821,3, + 32,16,0,821,822,5,75,0,0,822,823,3,32,16,0,823,910,1,0,0,0,824,825,3,86, + 43,0,825,826,3,32,16,0,826,827,5,75,0,0,827,828,3,32,16,0,828,829,5,28, + 0,0,829,830,3,32,16,0,830,831,5,264,0,0,831,910,1,0,0,0,832,833,3,86,43, + 0,833,834,3,32,16,0,834,835,5,75,0,0,835,836,3,32,16,0,836,837,5,28,0, + 0,837,838,3,32,16,0,838,910,1,0,0,0,839,840,3,86,43,0,840,841,3,32,16, + 0,841,842,5,28,0,0,842,843,3,32,16,0,843,844,5,75,0,0,844,845,3,32,16, + 0,845,846,5,264,0,0,846,910,1,0,0,0,847,848,3,86,43,0,848,849,3,32,16, + 0,849,850,5,28,0,0,850,851,3,32,16,0,851,852,5,75,0,0,852,853,3,32,16, + 0,853,910,1,0,0,0,854,855,3,86,43,0,855,856,3,32,16,0,856,857,5,28,0,0, + 857,858,3,32,16,0,858,859,5,75,0,0,859,860,3,32,16,0,860,861,5,28,0,0, + 861,862,3,32,16,0,862,863,5,264,0,0,863,910,1,0,0,0,864,865,3,86,43,0, + 865,866,3,32,16,0,866,867,5,28,0,0,867,868,3,32,16,0,868,869,5,75,0,0, + 869,870,3,32,16,0,870,871,5,28,0,0,871,872,3,32,16,0,872,910,1,0,0,0,873, + 874,3,86,43,0,874,875,3,32,16,0,875,876,5,263,0,0,876,910,1,0,0,0,877, + 878,3,86,43,0,878,879,3,32,16,0,879,880,5,75,0,0,880,881,3,32,16,0,881, + 882,5,263,0,0,882,910,1,0,0,0,883,884,3,86,43,0,884,885,3,32,16,0,885, + 886,5,75,0,0,886,887,3,32,16,0,887,888,5,28,0,0,888,889,3,32,16,0,889, + 890,5,263,0,0,890,910,1,0,0,0,891,892,3,86,43,0,892,893,3,32,16,0,893, + 894,5,28,0,0,894,895,3,32,16,0,895,896,5,75,0,0,896,897,3,32,16,0,897, + 898,5,263,0,0,898,910,1,0,0,0,899,900,3,86,43,0,900,901,3,32,16,0,901, + 902,5,28,0,0,902,903,3,32,16,0,903,904,5,75,0,0,904,905,3,32,16,0,905, + 906,5,28,0,0,906,907,3,32,16,0,907,908,5,263,0,0,908,910,1,0,0,0,909,806, + 1,0,0,0,909,810,1,0,0,0,909,813,1,0,0,0,909,819,1,0,0,0,909,824,1,0,0, + 0,909,832,1,0,0,0,909,839,1,0,0,0,909,847,1,0,0,0,909,854,1,0,0,0,909, + 864,1,0,0,0,909,873,1,0,0,0,909,877,1,0,0,0,909,883,1,0,0,0,909,891,1, + 0,0,0,909,899,1,0,0,0,910,89,1,0,0,0,911,915,5,21,0,0,912,914,3,92,46, + 0,913,912,1,0,0,0,914,917,1,0,0,0,915,913,1,0,0,0,915,916,1,0,0,0,916, + 918,1,0,0,0,917,915,1,0,0,0,918,919,3,2,1,0,919,920,3,94,47,0,920,921, + 5,180,0,0,921,922,5,36,0,0,922,923,5,30,0,0,923,924,3,300,150,0,924,925, + 5,31,0,0,925,926,3,94,47,0,926,938,1,0,0,0,927,931,5,21,0,0,928,930,3, + 92,46,0,929,928,1,0,0,0,930,933,1,0,0,0,931,929,1,0,0,0,931,932,1,0,0, + 0,932,934,1,0,0,0,933,931,1,0,0,0,934,935,3,2,1,0,935,936,3,94,47,0,936, + 938,1,0,0,0,937,911,1,0,0,0,937,927,1,0,0,0,938,91,1,0,0,0,939,940,5,76, + 0,0,940,93,1,0,0,0,941,944,1,0,0,0,942,944,5,298,0,0,943,941,1,0,0,0,943, + 942,1,0,0,0,944,95,1,0,0,0,945,946,7,6,0,0,946,97,1,0,0,0,947,949,3,96, + 48,0,948,947,1,0,0,0,949,952,1,0,0,0,950,948,1,0,0,0,950,951,1,0,0,0,951, + 99,1,0,0,0,952,950,1,0,0,0,953,979,3,102,51,0,954,955,5,280,0,0,955,956, + 3,168,84,0,956,957,6,50,-1,0,957,979,1,0,0,0,958,959,5,286,0,0,959,960, + 3,178,89,0,960,961,6,50,-1,0,961,979,1,0,0,0,962,963,5,286,0,0,963,964, + 3,174,87,0,964,965,6,50,-1,0,965,979,1,0,0,0,966,967,5,284,0,0,967,968, + 3,124,62,0,968,969,6,50,-1,0,969,979,1,0,0,0,970,971,5,281,0,0,971,972, + 3,104,52,0,972,973,6,50,-1,0,973,979,1,0,0,0,974,975,5,287,0,0,975,976, + 3,50,25,0,976,977,6,50,-1,0,977,979,1,0,0,0,978,953,1,0,0,0,978,954,1, + 0,0,0,978,958,1,0,0,0,978,962,1,0,0,0,978,966,1,0,0,0,978,970,1,0,0,0, + 978,974,1,0,0,0,979,101,1,0,0,0,980,981,5,275,0,0,981,1059,6,51,-1,0,982, + 983,5,276,0,0,983,984,3,32,16,0,984,985,6,51,-1,0,985,1059,1,0,0,0,986, + 987,5,276,0,0,987,988,3,0,0,0,988,989,6,51,-1,0,989,1059,1,0,0,0,990,991, + 5,277,0,0,991,992,3,32,16,0,992,993,6,51,-1,0,993,1059,1,0,0,0,994,995, + 5,278,0,0,995,996,3,34,17,0,996,997,6,51,-1,0,997,1059,1,0,0,0,998,999, + 5,279,0,0,999,1000,3,36,18,0,1000,1001,6,51,-1,0,1001,1059,1,0,0,0,1002, + 1003,5,279,0,0,1003,1004,3,34,17,0,1004,1005,6,51,-1,0,1005,1059,1,0,0, + 0,1006,1007,5,279,0,0,1007,1008,5,30,0,0,1008,1009,3,300,150,0,1009,1010, + 5,31,0,0,1010,1011,6,51,-1,0,1011,1059,1,0,0,0,1012,1013,5,279,0,0,1013, + 1014,5,84,0,0,1014,1015,5,30,0,0,1015,1016,3,300,150,0,1016,1017,5,31, + 0,0,1017,1018,6,51,-1,0,1018,1059,1,0,0,0,1019,1020,5,282,0,0,1020,1021, + 3,32,16,0,1021,1022,6,51,-1,0,1022,1059,1,0,0,0,1023,1024,5,282,0,0,1024, + 1025,3,0,0,0,1025,1026,6,51,-1,0,1026,1059,1,0,0,0,1027,1028,5,285,0,0, + 1028,1029,3,6,3,0,1029,1030,6,51,-1,0,1030,1059,1,0,0,0,1031,1032,5,285, + 0,0,1032,1033,5,224,0,0,1033,1034,5,30,0,0,1034,1035,3,6,3,0,1035,1036, + 5,31,0,0,1036,1037,6,51,-1,0,1037,1059,1,0,0,0,1038,1039,5,285,0,0,1039, + 1040,5,84,0,0,1040,1041,5,30,0,0,1041,1042,3,300,150,0,1042,1043,5,31, + 0,0,1043,1044,6,51,-1,0,1044,1059,1,0,0,0,1045,1046,5,287,0,0,1046,1047, + 3,32,16,0,1047,1048,6,51,-1,0,1048,1059,1,0,0,0,1049,1050,5,283,0,0,1050, + 1056,6,51,-1,0,1051,1052,5,30,0,0,1052,1053,3,106,53,0,1053,1054,5,31, + 0,0,1054,1057,1,0,0,0,1055,1057,5,85,0,0,1056,1051,1,0,0,0,1056,1055,1, + 0,0,0,1057,1059,1,0,0,0,1058,980,1,0,0,0,1058,982,1,0,0,0,1058,986,1,0, + 0,0,1058,990,1,0,0,0,1058,994,1,0,0,0,1058,998,1,0,0,0,1058,1002,1,0,0, + 0,1058,1006,1,0,0,0,1058,1012,1,0,0,0,1058,1019,1,0,0,0,1058,1023,1,0, + 0,0,1058,1027,1,0,0,0,1058,1031,1,0,0,0,1058,1038,1,0,0,0,1058,1045,1, + 0,0,0,1058,1049,1,0,0,0,1059,103,1,0,0,0,1060,1061,3,170,85,0,1061,1062, + 3,138,69,0,1062,1063,3,112,56,0,1063,1064,6,52,-1,0,1064,105,1,0,0,0,1065, + 1090,1,0,0,0,1066,1067,3,0,0,0,1067,1068,6,53,-1,0,1068,1073,1,0,0,0,1069, + 1070,3,32,16,0,1070,1071,6,53,-1,0,1071,1073,1,0,0,0,1072,1066,1,0,0,0, + 1072,1069,1,0,0,0,1073,1074,1,0,0,0,1074,1075,5,28,0,0,1075,1077,1,0,0, + 0,1076,1072,1,0,0,0,1077,1080,1,0,0,0,1078,1076,1,0,0,0,1078,1079,1,0, + 0,0,1079,1087,1,0,0,0,1080,1078,1,0,0,0,1081,1082,3,0,0,0,1082,1083,6, + 53,-1,0,1083,1088,1,0,0,0,1084,1085,3,32,16,0,1085,1086,6,53,-1,0,1086, + 1088,1,0,0,0,1087,1081,1,0,0,0,1087,1084,1,0,0,0,1088,1090,1,0,0,0,1089, + 1065,1,0,0,0,1089,1078,1,0,0,0,1090,107,1,0,0,0,1091,1098,5,86,0,0,1092, + 1093,3,138,69,0,1093,1094,6,54,-1,0,1094,1095,5,28,0,0,1095,1097,1,0,0, + 0,1096,1092,1,0,0,0,1097,1100,1,0,0,0,1098,1096,1,0,0,0,1098,1099,1,0, + 0,0,1099,1101,1,0,0,0,1100,1098,1,0,0,0,1101,1102,3,138,69,0,1102,1103, + 6,54,-1,0,1103,1104,5,87,0,0,1104,109,1,0,0,0,1105,1112,5,42,0,0,1106, + 1107,3,146,73,0,1107,1108,6,55,-1,0,1108,1109,5,28,0,0,1109,1111,1,0,0, + 0,1110,1106,1,0,0,0,1111,1114,1,0,0,0,1112,1110,1,0,0,0,1112,1113,1,0, + 0,0,1113,1115,1,0,0,0,1114,1112,1,0,0,0,1115,1116,3,146,73,0,1116,1117, + 6,55,-1,0,1117,1118,5,43,0,0,1118,111,1,0,0,0,1119,1126,5,30,0,0,1120, + 1121,3,114,57,0,1121,1122,6,56,-1,0,1122,1123,5,28,0,0,1123,1125,1,0,0, + 0,1124,1120,1,0,0,0,1125,1128,1,0,0,0,1126,1124,1,0,0,0,1126,1127,1,0, + 0,0,1127,1129,1,0,0,0,1128,1126,1,0,0,0,1129,1130,3,114,57,0,1130,1131, + 6,56,-1,0,1131,1132,5,31,0,0,1132,1135,1,0,0,0,1133,1135,5,85,0,0,1134, + 1119,1,0,0,0,1134,1133,1,0,0,0,1135,113,1,0,0,0,1136,1137,5,177,0,0,1137, + 1147,6,57,-1,0,1138,1139,3,230,115,0,1139,1140,3,138,69,0,1140,1142,3, + 226,113,0,1141,1143,3,0,0,0,1142,1141,1,0,0,0,1142,1143,1,0,0,0,1143,1144, + 1,0,0,0,1144,1145,6,57,-1,0,1145,1147,1,0,0,0,1146,1136,1,0,0,0,1146,1138, + 1,0,0,0,1147,115,1,0,0,0,1148,1149,5,42,0,0,1149,1150,3,2,1,0,1150,1151, + 5,43,0,0,1151,1152,3,118,59,0,1152,1153,6,58,-1,0,1153,1186,1,0,0,0,1154, + 1155,5,42,0,0,1155,1156,3,174,87,0,1156,1157,5,43,0,0,1157,1158,3,118, + 59,0,1158,1159,6,58,-1,0,1159,1186,1,0,0,0,1160,1161,5,42,0,0,1161,1162, + 5,262,0,0,1162,1163,5,43,0,0,1163,1164,3,118,59,0,1164,1165,6,58,-1,0, + 1165,1186,1,0,0,0,1166,1167,5,42,0,0,1167,1168,5,198,0,0,1168,1169,3,2, + 1,0,1169,1170,5,43,0,0,1170,1171,3,118,59,0,1171,1172,6,58,-1,0,1172,1186, + 1,0,0,0,1173,1174,3,118,59,0,1174,1175,6,58,-1,0,1175,1186,1,0,0,0,1176, + 1177,3,174,87,0,1177,1178,6,58,-1,0,1178,1186,1,0,0,0,1179,1180,5,257, + 0,0,1180,1186,6,58,-1,0,1181,1182,5,258,0,0,1182,1186,6,58,-1,0,1183,1184, + 5,259,0,0,1184,1186,6,58,-1,0,1185,1148,1,0,0,0,1185,1154,1,0,0,0,1185, + 1160,1,0,0,0,1185,1166,1,0,0,0,1185,1173,1,0,0,0,1185,1176,1,0,0,0,1185, + 1179,1,0,0,0,1185,1181,1,0,0,0,1185,1183,1,0,0,0,1186,117,1,0,0,0,1187, + 1188,3,2,1,0,1188,1189,6,59,-1,0,1189,1190,5,88,0,0,1190,1192,1,0,0,0, + 1191,1187,1,0,0,0,1192,1195,1,0,0,0,1193,1191,1,0,0,0,1193,1194,1,0,0, + 0,1194,1196,1,0,0,0,1195,1193,1,0,0,0,1196,1197,3,2,1,0,1197,1198,6,59, + -1,0,1198,119,1,0,0,0,1199,1201,3,122,61,0,1200,1199,1,0,0,0,1201,1204, + 1,0,0,0,1202,1200,1,0,0,0,1202,1203,1,0,0,0,1203,121,1,0,0,0,1204,1202, + 1,0,0,0,1205,1206,5,180,0,0,1206,1207,5,89,0,0,1207,1211,3,32,16,0,1208, + 1211,3,152,76,0,1209,1211,3,332,166,0,1210,1205,1,0,0,0,1210,1208,1,0, + 0,0,1210,1209,1,0,0,0,1211,123,1,0,0,0,1212,1213,3,116,58,0,1213,1214, + 6,62,-1,0,1214,1230,1,0,0,0,1215,1216,5,42,0,0,1216,1217,3,2,1,0,1217, + 1218,5,43,0,0,1218,1219,6,62,-1,0,1219,1230,1,0,0,0,1220,1221,5,42,0,0, + 1221,1222,5,198,0,0,1222,1223,3,2,1,0,1223,1224,5,43,0,0,1224,1225,6,62, + -1,0,1225,1230,1,0,0,0,1226,1227,3,138,69,0,1227,1228,6,62,-1,0,1228,1230, + 1,0,0,0,1229,1212,1,0,0,0,1229,1215,1,0,0,0,1229,1220,1,0,0,0,1229,1226, + 1,0,0,0,1230,125,1,0,0,0,1231,1243,1,0,0,0,1232,1233,3,130,65,0,1233,1239, + 6,63,-1,0,1234,1235,3,128,64,0,1235,1236,6,63,-1,0,1236,1238,1,0,0,0,1237, + 1234,1,0,0,0,1238,1241,1,0,0,0,1239,1237,1,0,0,0,1239,1240,1,0,0,0,1240, + 1243,1,0,0,0,1241,1239,1,0,0,0,1242,1231,1,0,0,0,1242,1232,1,0,0,0,1243, + 127,1,0,0,0,1244,1245,5,262,0,0,1245,1267,6,64,-1,0,1246,1247,5,261,0, + 0,1247,1267,6,64,-1,0,1248,1249,5,42,0,0,1249,1250,3,32,16,0,1250,1251, + 5,43,0,0,1251,1252,6,64,-1,0,1252,1267,1,0,0,0,1253,1254,5,42,0,0,1254, + 1255,3,32,16,0,1255,1256,5,266,0,0,1256,1257,3,32,16,0,1257,1258,5,43, + 0,0,1258,1259,6,64,-1,0,1259,1267,1,0,0,0,1260,1261,5,42,0,0,1261,1262, + 5,266,0,0,1262,1263,3,32,16,0,1263,1264,5,43,0,0,1264,1265,6,64,-1,0,1265, + 1267,1,0,0,0,1266,1244,1,0,0,0,1266,1246,1,0,0,0,1266,1248,1,0,0,0,1266, + 1253,1,0,0,0,1266,1260,1,0,0,0,1267,129,1,0,0,0,1268,1414,6,65,-1,0,1269, + 1270,5,203,0,0,1270,1271,5,30,0,0,1271,1272,3,6,3,0,1272,1273,5,28,0,0, + 1273,1274,3,6,3,0,1274,1275,5,28,0,0,1275,1276,3,6,3,0,1276,1277,5,28, + 0,0,1277,1278,3,6,3,0,1278,1279,5,31,0,0,1279,1280,6,65,-1,0,1280,1414, + 1,0,0,0,1281,1282,5,203,0,0,1282,1283,5,30,0,0,1283,1284,3,6,3,0,1284, + 1285,5,28,0,0,1285,1286,3,6,3,0,1286,1287,5,31,0,0,1287,1288,6,65,-1,0, + 1288,1414,1,0,0,0,1289,1290,5,204,0,0,1290,1291,5,205,0,0,1291,1292,5, + 42,0,0,1292,1293,3,32,16,0,1293,1294,5,43,0,0,1294,1295,6,65,-1,0,1295, + 1414,1,0,0,0,1296,1297,5,204,0,0,1297,1298,5,206,0,0,1298,1299,5,42,0, + 0,1299,1300,3,32,16,0,1300,1301,5,43,0,0,1301,1302,3,126,63,0,1302,1303, + 6,65,-1,0,1303,1414,1,0,0,0,1304,1305,5,207,0,0,1305,1414,6,65,-1,0,1306, + 1307,5,208,0,0,1307,1414,6,65,-1,0,1308,1309,5,209,0,0,1309,1414,6,65, + -1,0,1310,1311,5,201,0,0,1311,1414,6,65,-1,0,1312,1313,5,183,0,0,1313, + 1414,6,65,-1,0,1314,1315,5,184,0,0,1315,1414,6,65,-1,0,1316,1317,5,185, + 0,0,1317,1414,6,65,-1,0,1318,1319,5,186,0,0,1319,1414,6,65,-1,0,1320,1321, + 5,187,0,0,1321,1414,6,65,-1,0,1322,1323,5,188,0,0,1323,1414,6,65,-1,0, + 1324,1325,5,189,0,0,1325,1414,6,65,-1,0,1326,1327,5,210,0,0,1327,1414, + 6,65,-1,0,1328,1329,5,190,0,0,1329,1414,6,65,-1,0,1330,1331,5,191,0,0, + 1331,1414,6,65,-1,0,1332,1333,5,192,0,0,1333,1414,6,65,-1,0,1334,1335, + 5,193,0,0,1335,1414,6,65,-1,0,1336,1337,5,211,0,0,1337,1414,6,65,-1,0, + 1338,1339,5,212,0,0,1339,1414,6,65,-1,0,1340,1341,5,213,0,0,1341,1414, + 6,65,-1,0,1342,1343,5,214,0,0,1343,1414,6,65,-1,0,1344,1345,5,215,0,0, + 1345,1414,6,65,-1,0,1346,1347,5,216,0,0,1347,1414,6,65,-1,0,1348,1349, + 5,217,0,0,1349,1414,6,65,-1,0,1350,1351,5,218,0,0,1351,1352,3,132,66,0, + 1352,1353,6,65,-1,0,1353,1414,1,0,0,0,1354,1355,5,219,0,0,1355,1356,3, + 132,66,0,1356,1357,6,65,-1,0,1357,1414,1,0,0,0,1358,1359,5,220,0,0,1359, + 1414,6,65,-1,0,1360,1361,5,221,0,0,1361,1362,3,132,66,0,1362,1363,6,65, + -1,0,1363,1414,1,0,0,0,1364,1365,5,222,0,0,1365,1366,3,134,67,0,1366,1367, + 6,65,-1,0,1367,1414,1,0,0,0,1368,1369,5,222,0,0,1369,1370,3,134,67,0,1370, + 1371,5,28,0,0,1371,1372,3,6,3,0,1372,1373,6,65,-1,0,1373,1414,1,0,0,0, + 1374,1375,5,194,0,0,1375,1414,6,65,-1,0,1376,1377,5,195,0,0,1377,1414, + 6,65,-1,0,1378,1379,5,90,0,0,1379,1380,5,184,0,0,1380,1414,6,65,-1,0,1381, + 1382,5,90,0,0,1382,1383,5,185,0,0,1383,1414,6,65,-1,0,1384,1385,5,90,0, + 0,1385,1386,5,186,0,0,1386,1414,6,65,-1,0,1387,1388,5,90,0,0,1388,1389, + 5,187,0,0,1389,1414,6,65,-1,0,1390,1391,5,62,0,0,1391,1392,5,220,0,0,1392, + 1414,6,65,-1,0,1393,1394,5,223,0,0,1394,1414,6,65,-1,0,1395,1396,5,224, + 0,0,1396,1397,5,213,0,0,1397,1414,6,65,-1,0,1398,1399,5,225,0,0,1399,1414, + 6,65,-1,0,1400,1401,5,207,0,0,1401,1402,5,183,0,0,1402,1414,6,65,-1,0, + 1403,1404,5,226,0,0,1404,1414,6,65,-1,0,1405,1406,5,228,0,0,1406,1414, + 6,65,-1,0,1407,1408,5,34,0,0,1408,1409,5,227,0,0,1409,1414,6,65,-1,0,1410, + 1411,3,2,1,0,1411,1412,6,65,-1,0,1412,1414,1,0,0,0,1413,1268,1,0,0,0,1413, + 1269,1,0,0,0,1413,1281,1,0,0,0,1413,1289,1,0,0,0,1413,1296,1,0,0,0,1413, + 1304,1,0,0,0,1413,1306,1,0,0,0,1413,1308,1,0,0,0,1413,1310,1,0,0,0,1413, + 1312,1,0,0,0,1413,1314,1,0,0,0,1413,1316,1,0,0,0,1413,1318,1,0,0,0,1413, + 1320,1,0,0,0,1413,1322,1,0,0,0,1413,1324,1,0,0,0,1413,1326,1,0,0,0,1413, + 1328,1,0,0,0,1413,1330,1,0,0,0,1413,1332,1,0,0,0,1413,1334,1,0,0,0,1413, + 1336,1,0,0,0,1413,1338,1,0,0,0,1413,1340,1,0,0,0,1413,1342,1,0,0,0,1413, + 1344,1,0,0,0,1413,1346,1,0,0,0,1413,1348,1,0,0,0,1413,1350,1,0,0,0,1413, + 1354,1,0,0,0,1413,1358,1,0,0,0,1413,1360,1,0,0,0,1413,1364,1,0,0,0,1413, + 1368,1,0,0,0,1413,1374,1,0,0,0,1413,1376,1,0,0,0,1413,1378,1,0,0,0,1413, + 1381,1,0,0,0,1413,1384,1,0,0,0,1413,1387,1,0,0,0,1413,1390,1,0,0,0,1413, + 1393,1,0,0,0,1413,1395,1,0,0,0,1413,1398,1,0,0,0,1413,1400,1,0,0,0,1413, + 1403,1,0,0,0,1413,1405,1,0,0,0,1413,1407,1,0,0,0,1413,1410,1,0,0,0,1414, + 131,1,0,0,0,1415,1424,1,0,0,0,1416,1417,5,30,0,0,1417,1418,5,91,0,0,1418, + 1419,5,36,0,0,1419,1420,3,32,16,0,1420,1421,5,31,0,0,1421,1422,6,66,-1, + 0,1422,1424,1,0,0,0,1423,1415,1,0,0,0,1423,1416,1,0,0,0,1424,133,1,0,0, + 0,1425,1436,1,0,0,0,1426,1427,3,136,68,0,1427,1432,6,67,-1,0,1428,1429, + 7,7,0,0,1429,1431,6,67,-1,0,1430,1428,1,0,0,0,1431,1434,1,0,0,0,1432,1430, + 1,0,0,0,1432,1433,1,0,0,0,1433,1436,1,0,0,0,1434,1432,1,0,0,0,1435,1425, 1,0,0,0,1435,1426,1,0,0,0,1436,135,1,0,0,0,1437,1438,5,178,0,0,1438,1518, 6,68,-1,0,1439,1440,5,207,0,0,1440,1518,6,68,-1,0,1441,1442,5,208,0,0, 1442,1518,6,68,-1,0,1443,1444,5,201,0,0,1444,1518,6,68,-1,0,1445,1446, @@ -18640,451 +18982,503 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 1935,1,0,0,0,1927,1928,3,138,69,0,1928,1929,3,2,1,0,1929,1930,6,89,-1, 0,1930,1935,1,0,0,0,1931,1932,3,2,1,0,1932,1933,6,89,-1,0,1933,1935,1, 0,0,0,1934,1921,1,0,0,0,1934,1927,1,0,0,0,1934,1931,1,0,0,0,1935,179,1, - 0,0,0,1936,1937,3,124,62,0,1937,1938,5,28,0,0,1938,1940,1,0,0,0,1939,1936, - 1,0,0,0,1940,1943,1,0,0,0,1941,1939,1,0,0,0,1941,1942,1,0,0,0,1942,1944, - 1,0,0,0,1943,1941,1,0,0,0,1944,1945,3,124,62,0,1945,181,1,0,0,0,1946,1952, - 1,0,0,0,1947,1948,5,86,0,0,1948,1949,3,190,95,0,1949,1950,5,87,0,0,1950, - 1952,1,0,0,0,1951,1946,1,0,0,0,1951,1947,1,0,0,0,1952,183,1,0,0,0,1953, - 1965,5,266,0,0,1954,1965,5,114,0,0,1955,1965,5,39,0,0,1956,1965,5,200, - 0,0,1957,1965,5,115,0,0,1958,1965,5,116,0,0,1959,1960,5,70,0,0,1960,1961, - 5,30,0,0,1961,1962,3,32,16,0,1962,1963,5,31,0,0,1963,1965,1,0,0,0,1964, - 1953,1,0,0,0,1964,1954,1,0,0,0,1964,1955,1,0,0,0,1964,1956,1,0,0,0,1964, - 1957,1,0,0,0,1964,1958,1,0,0,0,1964,1959,1,0,0,0,1965,185,1,0,0,0,1966, - 1968,3,184,92,0,1967,1966,1,0,0,0,1968,1971,1,0,0,0,1969,1967,1,0,0,0, - 1969,1970,1,0,0,0,1970,187,1,0,0,0,1971,1969,1,0,0,0,1972,1974,3,186,93, - 0,1973,1975,3,192,96,0,1974,1973,1,0,0,0,1974,1975,1,0,0,0,1975,1976,1, - 0,0,0,1976,1977,3,2,1,0,1977,189,1,0,0,0,1978,1979,3,188,94,0,1979,1980, - 5,28,0,0,1980,1982,1,0,0,0,1981,1978,1,0,0,0,1982,1985,1,0,0,0,1983,1981, - 1,0,0,0,1983,1984,1,0,0,0,1984,1986,1,0,0,0,1985,1983,1,0,0,0,1986,1987, - 3,188,94,0,1987,191,1,0,0,0,1988,1989,5,30,0,0,1989,1990,3,180,90,0,1990, - 1991,5,31,0,0,1991,193,1,0,0,0,1992,1994,3,196,98,0,1993,1992,1,0,0,0, - 1993,1994,1,0,0,0,1994,1995,1,0,0,0,1995,1996,6,97,-1,0,1996,195,1,0,0, - 0,1997,1998,5,86,0,0,1998,1999,5,42,0,0,1999,2000,3,32,16,0,2000,2001, - 5,43,0,0,2001,2002,5,87,0,0,2002,2003,6,98,-1,0,2003,197,1,0,0,0,2004, - 2005,3,234,117,0,2005,2006,5,17,0,0,2006,2007,3,246,123,0,2007,2008,5, - 18,0,0,2008,2121,1,0,0,0,2009,2010,3,74,37,0,2010,2011,5,17,0,0,2011,2012, - 3,82,41,0,2012,2013,5,18,0,0,2013,2121,1,0,0,0,2014,2015,3,210,105,0,2015, - 2016,5,17,0,0,2016,2017,3,214,107,0,2017,2018,5,18,0,0,2018,2121,1,0,0, - 0,2019,2020,3,218,109,0,2020,2021,5,17,0,0,2021,2022,3,222,111,0,2022, - 2023,5,18,0,0,2023,2121,1,0,0,0,2024,2121,3,200,100,0,2025,2121,3,284, - 142,0,2026,2121,3,152,76,0,2027,2121,3,88,44,0,2028,2121,3,330,165,0,2029, - 2030,5,117,0,0,2030,2121,3,32,16,0,2031,2032,5,118,0,0,2032,2121,3,32, - 16,0,2033,2034,3,342,171,0,2034,2035,5,17,0,0,2035,2036,3,346,173,0,2036, - 2037,5,18,0,0,2037,2121,1,0,0,0,2038,2039,5,302,0,0,2039,2040,3,124,62, - 0,2040,2041,5,176,0,0,2041,2042,3,242,121,0,2042,2043,5,119,0,0,2043,2044, - 3,170,85,0,2044,2045,3,138,69,0,2045,2046,3,124,62,0,2046,2047,5,176,0, - 0,2047,2048,3,242,121,0,2048,2049,3,112,56,0,2049,2121,1,0,0,0,2050,2051, - 5,302,0,0,2051,2052,5,226,0,0,2052,2053,3,170,85,0,2053,2054,3,138,69, - 0,2054,2055,3,124,62,0,2055,2056,5,176,0,0,2056,2057,3,242,121,0,2057, - 2058,3,194,97,0,2058,2059,3,112,56,0,2059,2060,5,119,0,0,2060,2061,5,226, - 0,0,2061,2062,3,170,85,0,2062,2063,3,138,69,0,2063,2064,3,124,62,0,2064, - 2065,5,176,0,0,2065,2066,3,242,121,0,2066,2067,3,194,97,0,2067,2068,3, - 112,56,0,2068,2121,1,0,0,0,2069,2121,3,26,13,0,2070,2121,3,40,20,0,2071, - 2072,5,255,0,0,2072,2073,5,196,0,0,2073,2074,5,42,0,0,2074,2075,3,32,16, - 0,2075,2079,5,43,0,0,2076,2078,3,330,165,0,2077,2076,1,0,0,0,2078,2081, - 1,0,0,0,2079,2077,1,0,0,0,2079,2080,1,0,0,0,2080,2121,1,0,0,0,2081,2079, - 1,0,0,0,2082,2083,5,255,0,0,2083,2084,5,196,0,0,2084,2088,3,2,1,0,2085, - 2087,3,330,165,0,2086,2085,1,0,0,0,2087,2090,1,0,0,0,2088,2086,1,0,0,0, - 2088,2089,1,0,0,0,2089,2121,1,0,0,0,2090,2088,1,0,0,0,2091,2092,5,255, - 0,0,2092,2093,5,256,0,0,2093,2094,5,42,0,0,2094,2095,3,32,16,0,2095,2096, - 5,43,0,0,2096,2097,5,28,0,0,2097,2101,3,124,62,0,2098,2100,3,330,165,0, - 2099,2098,1,0,0,0,2100,2103,1,0,0,0,2101,2099,1,0,0,0,2101,2102,1,0,0, - 0,2102,2121,1,0,0,0,2103,2101,1,0,0,0,2104,2105,5,255,0,0,2105,2106,5, - 256,0,0,2106,2107,3,2,1,0,2107,2108,5,28,0,0,2108,2112,3,124,62,0,2109, - 2111,3,330,165,0,2110,2109,1,0,0,0,2111,2114,1,0,0,0,2112,2110,1,0,0,0, - 2112,2113,1,0,0,0,2113,2121,1,0,0,0,2114,2112,1,0,0,0,2115,2116,5,120, - 0,0,2116,2117,5,196,0,0,2117,2118,3,124,62,0,2118,2119,3,44,22,0,2119, - 2121,1,0,0,0,2120,2004,1,0,0,0,2120,2009,1,0,0,0,2120,2014,1,0,0,0,2120, - 2019,1,0,0,0,2120,2024,1,0,0,0,2120,2025,1,0,0,0,2120,2026,1,0,0,0,2120, - 2027,1,0,0,0,2120,2028,1,0,0,0,2120,2029,1,0,0,0,2120,2031,1,0,0,0,2120, - 2033,1,0,0,0,2120,2038,1,0,0,0,2120,2050,1,0,0,0,2120,2069,1,0,0,0,2120, - 2070,1,0,0,0,2120,2071,1,0,0,0,2120,2082,1,0,0,0,2120,2091,1,0,0,0,2120, - 2104,1,0,0,0,2120,2115,1,0,0,0,2121,199,1,0,0,0,2122,2123,5,121,0,0,2123, - 2132,3,208,104,0,2124,2131,3,202,101,0,2125,2126,5,122,0,0,2126,2127,5, - 30,0,0,2127,2128,3,228,114,0,2128,2129,5,31,0,0,2129,2131,1,0,0,0,2130, - 2124,1,0,0,0,2130,2125,1,0,0,0,2131,2134,1,0,0,0,2132,2130,1,0,0,0,2132, - 2133,1,0,0,0,2133,2135,1,0,0,0,2134,2132,1,0,0,0,2135,2136,3,138,69,0, - 2136,2137,3,2,1,0,2137,2138,3,204,102,0,2138,2139,3,206,103,0,2139,201, - 1,0,0,0,2140,2160,5,123,0,0,2141,2160,5,51,0,0,2142,2160,5,52,0,0,2143, - 2160,5,63,0,0,2144,2160,5,124,0,0,2145,2160,5,69,0,0,2146,2160,5,68,0, - 0,2147,2160,5,64,0,0,2148,2160,5,65,0,0,2149,2160,5,66,0,0,2150,2160,5, - 125,0,0,2151,2160,5,126,0,0,2152,2160,5,127,0,0,2153,2160,5,16,0,0,2154, - 2155,5,70,0,0,2155,2156,5,30,0,0,2156,2157,3,32,16,0,2157,2158,5,31,0, - 0,2158,2160,1,0,0,0,2159,2140,1,0,0,0,2159,2141,1,0,0,0,2159,2142,1,0, - 0,0,2159,2143,1,0,0,0,2159,2144,1,0,0,0,2159,2145,1,0,0,0,2159,2146,1, - 0,0,0,2159,2147,1,0,0,0,2159,2148,1,0,0,0,2159,2149,1,0,0,0,2159,2150, - 1,0,0,0,2159,2151,1,0,0,0,2159,2152,1,0,0,0,2159,2153,1,0,0,0,2159,2154, - 1,0,0,0,2160,203,1,0,0,0,2161,2167,1,0,0,0,2162,2163,5,44,0,0,2163,2167, - 3,0,0,0,2164,2165,5,44,0,0,2165,2167,3,32,16,0,2166,2161,1,0,0,0,2166, - 2162,1,0,0,0,2166,2164,1,0,0,0,2167,205,1,0,0,0,2168,2172,1,0,0,0,2169, - 2170,5,36,0,0,2170,2172,3,304,152,0,2171,2168,1,0,0,0,2171,2169,1,0,0, - 0,2172,207,1,0,0,0,2173,2179,1,0,0,0,2174,2175,5,42,0,0,2175,2176,3,32, - 16,0,2176,2177,5,43,0,0,2177,2179,1,0,0,0,2178,2173,1,0,0,0,2178,2174, - 1,0,0,0,2179,209,1,0,0,0,2180,2184,5,128,0,0,2181,2183,3,212,106,0,2182, - 2181,1,0,0,0,2183,2186,1,0,0,0,2184,2182,1,0,0,0,2184,2185,1,0,0,0,2185, - 2187,1,0,0,0,2186,2184,1,0,0,0,2187,2188,3,124,62,0,2188,2189,3,2,1,0, - 2189,2199,1,0,0,0,2190,2194,5,128,0,0,2191,2193,3,212,106,0,2192,2191, - 1,0,0,0,2193,2196,1,0,0,0,2194,2192,1,0,0,0,2194,2195,1,0,0,0,2195,2197, - 1,0,0,0,2196,2194,1,0,0,0,2197,2199,3,2,1,0,2198,2180,1,0,0,0,2198,2190, - 1,0,0,0,2199,211,1,0,0,0,2200,2201,7,10,0,0,2201,213,1,0,0,0,2202,2204, - 3,216,108,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,215,1,0,0,0,2207,2205,1,0,0,0,2208,2209,5,129,0,0,2209, - 2221,3,168,84,0,2210,2211,5,130,0,0,2211,2221,3,168,84,0,2212,2213,5,131, - 0,0,2213,2221,3,168,84,0,2214,2215,5,132,0,0,2215,2221,3,168,84,0,2216, - 2221,3,88,44,0,2217,2221,3,330,165,0,2218,2221,3,26,13,0,2219,2221,3,40, - 20,0,2220,2208,1,0,0,0,2220,2210,1,0,0,0,2220,2212,1,0,0,0,2220,2214,1, - 0,0,0,2220,2216,1,0,0,0,2220,2217,1,0,0,0,2220,2218,1,0,0,0,2220,2219, - 1,0,0,0,2221,217,1,0,0,0,2222,2226,5,133,0,0,2223,2225,3,220,110,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,2230,3,170,85,0,2230,2231,3,138,69, - 0,2231,2232,3,2,1,0,2232,2233,3,112,56,0,2233,2234,3,206,103,0,2234,219, - 1,0,0,0,2235,2236,7,10,0,0,2236,221,1,0,0,0,2237,2239,3,224,112,0,2238, - 2237,1,0,0,0,2239,2242,1,0,0,0,2240,2238,1,0,0,0,2240,2241,1,0,0,0,2241, - 223,1,0,0,0,2242,2240,1,0,0,0,2243,2244,5,134,0,0,2244,2254,3,168,84,0, - 2245,2246,5,135,0,0,2246,2254,3,168,84,0,2247,2248,5,132,0,0,2248,2254, - 3,168,84,0,2249,2254,3,330,165,0,2250,2254,3,88,44,0,2251,2254,3,26,13, - 0,2252,2254,3,40,20,0,2253,2243,1,0,0,0,2253,2245,1,0,0,0,2253,2247,1, - 0,0,0,2253,2249,1,0,0,0,2253,2250,1,0,0,0,2253,2251,1,0,0,0,2253,2252, - 1,0,0,0,2254,225,1,0,0,0,2255,2263,6,113,-1,0,2256,2257,5,122,0,0,2257, - 2258,5,30,0,0,2258,2259,3,228,114,0,2259,2260,5,31,0,0,2260,2261,6,113, - -1,0,2261,2263,1,0,0,0,2262,2255,1,0,0,0,2262,2256,1,0,0,0,2263,227,1, - 0,0,0,2264,2265,3,126,63,0,2265,2266,6,114,-1,0,2266,2278,1,0,0,0,2267, - 2271,5,17,0,0,2268,2269,3,302,151,0,2269,2270,6,114,-1,0,2270,2272,1,0, - 0,0,2271,2268,1,0,0,0,2272,2273,1,0,0,0,2273,2271,1,0,0,0,2273,2274,1, - 0,0,0,2274,2275,1,0,0,0,2275,2276,5,18,0,0,2276,2278,1,0,0,0,2277,2264, - 1,0,0,0,2277,2267,1,0,0,0,2278,229,1,0,0,0,2279,2280,3,232,116,0,2280, - 2281,6,115,-1,0,2281,2283,1,0,0,0,2282,2279,1,0,0,0,2283,2286,1,0,0,0, - 2284,2282,1,0,0,0,2284,2285,1,0,0,0,2285,231,1,0,0,0,2286,2284,1,0,0,0, - 2287,2288,5,42,0,0,2288,2289,5,136,0,0,2289,2290,5,43,0,0,2290,2305,6, - 116,-1,0,2291,2292,5,42,0,0,2292,2293,5,137,0,0,2293,2294,5,43,0,0,2294, - 2305,6,116,-1,0,2295,2296,5,42,0,0,2296,2297,5,138,0,0,2297,2298,5,43, - 0,0,2298,2305,6,116,-1,0,2299,2300,5,42,0,0,2300,2301,3,32,16,0,2301,2302, - 5,43,0,0,2302,2303,6,116,-1,0,2303,2305,1,0,0,0,2304,2287,1,0,0,0,2304, - 2291,1,0,0,0,2304,2295,1,0,0,0,2304,2299,1,0,0,0,2305,233,1,0,0,0,2306, - 2311,5,139,0,0,2307,2310,3,236,118,0,2308,2310,3,238,119,0,2309,2307,1, - 0,0,0,2309,2308,1,0,0,0,2310,2313,1,0,0,0,2311,2309,1,0,0,0,2311,2312, - 1,0,0,0,2312,2314,1,0,0,0,2313,2311,1,0,0,0,2314,2315,3,170,85,0,2315, - 2316,3,230,115,0,2316,2317,3,138,69,0,2317,2318,3,226,113,0,2318,2319, - 3,242,121,0,2319,2320,3,182,91,0,2320,2324,3,112,56,0,2321,2323,3,244, - 122,0,2322,2321,1,0,0,0,2323,2326,1,0,0,0,2324,2322,1,0,0,0,2324,2325, - 1,0,0,0,2325,235,1,0,0,0,2326,2324,1,0,0,0,2327,2351,5,123,0,0,2328,2351, - 5,51,0,0,2329,2351,5,52,0,0,2330,2351,5,63,0,0,2331,2351,5,140,0,0,2332, - 2351,5,68,0,0,2333,2351,5,141,0,0,2334,2351,5,142,0,0,2335,2351,5,54,0, - 0,2336,2351,5,64,0,0,2337,2351,5,65,0,0,2338,2351,5,66,0,0,2339,2351,5, - 125,0,0,2340,2351,5,143,0,0,2341,2351,5,144,0,0,2342,2351,5,69,0,0,2343, - 2351,5,145,0,0,2344,2351,5,146,0,0,2345,2346,5,70,0,0,2346,2347,5,30,0, - 0,2347,2348,3,32,16,0,2348,2349,5,31,0,0,2349,2351,1,0,0,0,2350,2327,1, - 0,0,0,2350,2328,1,0,0,0,2350,2329,1,0,0,0,2350,2330,1,0,0,0,2350,2331, - 1,0,0,0,2350,2332,1,0,0,0,2350,2333,1,0,0,0,2350,2334,1,0,0,0,2350,2335, - 1,0,0,0,2350,2336,1,0,0,0,2350,2337,1,0,0,0,2350,2338,1,0,0,0,2350,2339, - 1,0,0,0,2350,2340,1,0,0,0,2350,2341,1,0,0,0,2350,2342,1,0,0,0,2350,2343, - 1,0,0,0,2350,2344,1,0,0,0,2350,2345,1,0,0,0,2351,237,1,0,0,0,2352,2353, - 5,147,0,0,2353,2359,5,30,0,0,2354,2357,3,6,3,0,2355,2356,5,34,0,0,2356, - 2358,3,6,3,0,2357,2355,1,0,0,0,2357,2358,1,0,0,0,2358,2360,1,0,0,0,2359, - 2354,1,0,0,0,2359,2360,1,0,0,0,2360,2364,1,0,0,0,2361,2363,3,240,120,0, - 2362,2361,1,0,0,0,2363,2366,1,0,0,0,2364,2362,1,0,0,0,2364,2365,1,0,0, - 0,2365,2367,1,0,0,0,2366,2364,1,0,0,0,2367,2371,5,31,0,0,2368,2369,5,147, - 0,0,2369,2371,5,85,0,0,2370,2352,1,0,0,0,2370,2368,1,0,0,0,2371,239,1, - 0,0,0,2372,2400,5,148,0,0,2373,2400,5,224,0,0,2374,2400,5,57,0,0,2375, - 2400,5,58,0,0,2376,2400,5,149,0,0,2377,2400,5,150,0,0,2378,2400,5,248, - 0,0,2379,2400,5,249,0,0,2380,2400,5,250,0,0,2381,2400,5,251,0,0,2382,2383, - 5,151,0,0,2383,2384,5,75,0,0,2384,2400,5,152,0,0,2385,2386,5,151,0,0,2386, - 2387,5,75,0,0,2387,2400,5,153,0,0,2388,2389,5,154,0,0,2389,2390,5,75,0, - 0,2390,2400,5,152,0,0,2391,2392,5,154,0,0,2392,2393,5,75,0,0,2393,2400, - 5,153,0,0,2394,2395,5,70,0,0,2395,2396,5,30,0,0,2396,2397,3,32,16,0,2397, - 2398,5,31,0,0,2398,2400,1,0,0,0,2399,2372,1,0,0,0,2399,2373,1,0,0,0,2399, - 2374,1,0,0,0,2399,2375,1,0,0,0,2399,2376,1,0,0,0,2399,2377,1,0,0,0,2399, - 2378,1,0,0,0,2399,2379,1,0,0,0,2399,2380,1,0,0,0,2399,2381,1,0,0,0,2399, - 2382,1,0,0,0,2399,2385,1,0,0,0,2399,2388,1,0,0,0,2399,2391,1,0,0,0,2399, - 2394,1,0,0,0,2400,241,1,0,0,0,2401,2402,5,116,0,0,2402,2409,6,121,-1,0, - 2403,2404,5,155,0,0,2404,2409,6,121,-1,0,2405,2406,3,2,1,0,2406,2407,6, - 121,-1,0,2407,2409,1,0,0,0,2408,2401,1,0,0,0,2408,2403,1,0,0,0,2408,2405, - 1,0,0,0,2409,243,1,0,0,0,2410,2432,5,1,0,0,2411,2432,5,2,0,0,2412,2432, - 5,156,0,0,2413,2432,5,3,0,0,2414,2432,5,4,0,0,2415,2432,5,247,0,0,2416, - 2432,5,5,0,0,2417,2432,5,6,0,0,2418,2432,5,7,0,0,2419,2432,5,8,0,0,2420, - 2432,5,9,0,0,2421,2432,5,10,0,0,2422,2432,5,11,0,0,2423,2432,5,12,0,0, - 2424,2432,5,13,0,0,2425,2432,5,14,0,0,2426,2427,5,70,0,0,2427,2428,5,30, - 0,0,2428,2429,3,32,16,0,2429,2430,5,31,0,0,2430,2432,1,0,0,0,2431,2410, - 1,0,0,0,2431,2411,1,0,0,0,2431,2412,1,0,0,0,2431,2413,1,0,0,0,2431,2414, - 1,0,0,0,2431,2415,1,0,0,0,2431,2416,1,0,0,0,2431,2417,1,0,0,0,2431,2418, - 1,0,0,0,2431,2419,1,0,0,0,2431,2420,1,0,0,0,2431,2421,1,0,0,0,2431,2422, - 1,0,0,0,2431,2423,1,0,0,0,2431,2424,1,0,0,0,2431,2425,1,0,0,0,2431,2426, - 1,0,0,0,2432,245,1,0,0,0,2433,2435,3,248,124,0,2434,2433,1,0,0,0,2435, - 2438,1,0,0,0,2436,2434,1,0,0,0,2436,2437,1,0,0,0,2437,247,1,0,0,0,2438, - 2436,1,0,0,0,2439,2477,3,100,50,0,2440,2441,5,296,0,0,2441,2442,3,32,16, - 0,2442,2443,6,124,-1,0,2443,2477,1,0,0,0,2444,2477,3,266,133,0,2445,2446, - 5,297,0,0,2446,2447,3,32,16,0,2447,2448,6,124,-1,0,2448,2477,1,0,0,0,2449, - 2450,5,298,0,0,2450,2477,6,124,-1,0,2451,2452,5,299,0,0,2452,2477,6,124, - -1,0,2453,2477,3,260,130,0,2454,2477,3,264,132,0,2455,2477,3,250,125,0, - 2456,2457,3,284,142,0,2457,2458,6,124,-1,0,2458,2477,1,0,0,0,2459,2460, - 3,152,76,0,2460,2461,6,124,-1,0,2461,2477,1,0,0,0,2462,2463,3,88,44,0, - 2463,2464,6,124,-1,0,2464,2477,1,0,0,0,2465,2466,3,26,13,0,2466,2467,6, - 124,-1,0,2467,2477,1,0,0,0,2468,2469,3,262,131,0,2469,2470,6,124,-1,0, - 2470,2477,1,0,0,0,2471,2477,3,40,20,0,2472,2477,3,252,126,0,2473,2477, - 3,254,127,0,2474,2477,3,256,128,0,2475,2477,3,258,129,0,2476,2439,1,0, - 0,0,2476,2440,1,0,0,0,2476,2444,1,0,0,0,2476,2445,1,0,0,0,2476,2449,1, - 0,0,0,2476,2451,1,0,0,0,2476,2453,1,0,0,0,2476,2454,1,0,0,0,2476,2455, - 1,0,0,0,2476,2456,1,0,0,0,2476,2459,1,0,0,0,2476,2462,1,0,0,0,2476,2465, - 1,0,0,0,2476,2468,1,0,0,0,2476,2471,1,0,0,0,2476,2472,1,0,0,0,2476,2473, - 1,0,0,0,2476,2474,1,0,0,0,2476,2475,1,0,0,0,2477,249,1,0,0,0,2478,2480, - 5,300,0,0,2479,2481,5,157,0,0,2480,2479,1,0,0,0,2480,2481,1,0,0,0,2481, - 2482,1,0,0,0,2482,2483,3,112,56,0,2483,251,1,0,0,0,2484,2485,5,301,0,0, - 2485,2486,5,42,0,0,2486,2487,3,32,16,0,2487,2490,5,43,0,0,2488,2489,5, - 34,0,0,2489,2491,3,0,0,0,2490,2488,1,0,0,0,2490,2491,1,0,0,0,2491,253, - 1,0,0,0,2492,2493,5,303,0,0,2493,2494,3,32,16,0,2494,2495,5,75,0,0,2495, - 2496,3,32,16,0,2496,255,1,0,0,0,2497,2498,5,302,0,0,2498,2499,3,124,62, - 0,2499,2500,5,176,0,0,2500,2501,3,242,121,0,2501,2513,1,0,0,0,2502,2503, - 5,302,0,0,2503,2504,5,226,0,0,2504,2505,3,170,85,0,2505,2506,3,138,69, - 0,2506,2507,3,124,62,0,2507,2508,5,176,0,0,2508,2509,3,242,121,0,2509, - 2510,3,194,97,0,2510,2511,3,112,56,0,2511,2513,1,0,0,0,2512,2497,1,0,0, - 0,2512,2502,1,0,0,0,2513,257,1,0,0,0,2514,2515,5,255,0,0,2515,2516,5,196, - 0,0,2516,2517,5,42,0,0,2517,2518,3,32,16,0,2518,2524,5,43,0,0,2519,2520, - 3,330,165,0,2520,2521,6,129,-1,0,2521,2523,1,0,0,0,2522,2519,1,0,0,0,2523, - 2526,1,0,0,0,2524,2522,1,0,0,0,2524,2525,1,0,0,0,2525,2580,1,0,0,0,2526, - 2524,1,0,0,0,2527,2528,5,255,0,0,2528,2529,5,196,0,0,2529,2535,3,2,1,0, - 2530,2531,3,330,165,0,2531,2532,6,129,-1,0,2532,2534,1,0,0,0,2533,2530, - 1,0,0,0,2534,2537,1,0,0,0,2535,2533,1,0,0,0,2535,2536,1,0,0,0,2536,2580, - 1,0,0,0,2537,2535,1,0,0,0,2538,2539,5,255,0,0,2539,2540,5,256,0,0,2540, - 2541,5,42,0,0,2541,2542,3,32,16,0,2542,2543,5,43,0,0,2543,2544,5,28,0, - 0,2544,2550,3,124,62,0,2545,2546,3,330,165,0,2546,2547,6,129,-1,0,2547, - 2549,1,0,0,0,2548,2545,1,0,0,0,2549,2552,1,0,0,0,2550,2548,1,0,0,0,2550, - 2551,1,0,0,0,2551,2580,1,0,0,0,2552,2550,1,0,0,0,2553,2554,5,255,0,0,2554, - 2555,5,256,0,0,2555,2556,3,2,1,0,2556,2557,5,28,0,0,2557,2563,3,124,62, - 0,2558,2559,3,330,165,0,2559,2560,6,129,-1,0,2560,2562,1,0,0,0,2561,2558, - 1,0,0,0,2562,2565,1,0,0,0,2563,2561,1,0,0,0,2563,2564,1,0,0,0,2564,2580, - 1,0,0,0,2565,2563,1,0,0,0,2566,2567,5,255,0,0,2567,2568,5,42,0,0,2568, - 2569,3,32,16,0,2569,2570,5,43,0,0,2570,2576,3,206,103,0,2571,2572,3,330, - 165,0,2572,2573,6,129,-1,0,2573,2575,1,0,0,0,2574,2571,1,0,0,0,2575,2578, - 1,0,0,0,2576,2574,1,0,0,0,2576,2577,1,0,0,0,2577,2580,1,0,0,0,2578,2576, - 1,0,0,0,2579,2514,1,0,0,0,2579,2527,1,0,0,0,2579,2538,1,0,0,0,2579,2553, - 1,0,0,0,2579,2566,1,0,0,0,2580,259,1,0,0,0,2581,2582,3,0,0,0,2582,2583, - 5,75,0,0,2583,2584,6,130,-1,0,2584,261,1,0,0,0,2585,2588,3,44,22,0,2586, - 2588,3,46,23,0,2587,2585,1,0,0,0,2587,2586,1,0,0,0,2588,263,1,0,0,0,2589, - 2590,5,17,0,0,2590,2591,3,246,123,0,2591,2592,5,18,0,0,2592,265,1,0,0, - 0,2593,2594,3,270,135,0,2594,2595,3,268,134,0,2595,267,1,0,0,0,2596,2597, - 3,272,136,0,2597,2598,6,134,-1,0,2598,2600,1,0,0,0,2599,2596,1,0,0,0,2600, - 2601,1,0,0,0,2601,2599,1,0,0,0,2601,2602,1,0,0,0,2602,269,1,0,0,0,2603, - 2604,5,158,0,0,2604,2605,3,264,132,0,2605,2606,6,135,-1,0,2606,2620,1, - 0,0,0,2607,2608,5,158,0,0,2608,2609,3,0,0,0,2609,2610,5,159,0,0,2610,2611, - 3,0,0,0,2611,2612,6,135,-1,0,2612,2620,1,0,0,0,2613,2614,5,158,0,0,2614, - 2615,3,32,16,0,2615,2616,5,159,0,0,2616,2617,3,32,16,0,2617,2618,6,135, - -1,0,2618,2620,1,0,0,0,2619,2603,1,0,0,0,2619,2607,1,0,0,0,2619,2613,1, - 0,0,0,2620,271,1,0,0,0,2621,2622,3,276,138,0,2622,2623,3,282,141,0,2623, - 2624,6,136,-1,0,2624,2638,1,0,0,0,2625,2626,3,274,137,0,2626,2627,3,282, - 141,0,2627,2628,6,136,-1,0,2628,2638,1,0,0,0,2629,2630,3,278,139,0,2630, - 2631,3,282,141,0,2631,2632,6,136,-1,0,2632,2638,1,0,0,0,2633,2634,3,280, - 140,0,2634,2635,3,282,141,0,2635,2636,6,136,-1,0,2636,2638,1,0,0,0,2637, - 2621,1,0,0,0,2637,2625,1,0,0,0,2637,2629,1,0,0,0,2637,2633,1,0,0,0,2638, - 273,1,0,0,0,2639,2640,5,160,0,0,2640,2641,3,264,132,0,2641,2642,6,137, - -1,0,2642,2652,1,0,0,0,2643,2644,5,160,0,0,2644,2645,3,0,0,0,2645,2646, - 6,137,-1,0,2646,2652,1,0,0,0,2647,2648,5,160,0,0,2648,2649,3,32,16,0,2649, - 2650,6,137,-1,0,2650,2652,1,0,0,0,2651,2639,1,0,0,0,2651,2643,1,0,0,0, - 2651,2647,1,0,0,0,2652,275,1,0,0,0,2653,2654,5,161,0,0,2654,2655,3,124, - 62,0,2655,277,1,0,0,0,2656,2657,5,162,0,0,2657,279,1,0,0,0,2658,2659,5, - 163,0,0,2659,281,1,0,0,0,2660,2661,3,264,132,0,2661,2662,6,141,-1,0,2662, - 2676,1,0,0,0,2663,2664,5,164,0,0,2664,2665,3,0,0,0,2665,2666,5,159,0,0, - 2666,2667,3,0,0,0,2667,2668,6,141,-1,0,2668,2676,1,0,0,0,2669,2670,5,164, - 0,0,2670,2671,3,32,16,0,2671,2672,5,159,0,0,2672,2673,3,32,16,0,2673,2674, - 6,141,-1,0,2674,2676,1,0,0,0,2675,2660,1,0,0,0,2675,2663,1,0,0,0,2675, - 2669,1,0,0,0,2676,283,1,0,0,0,2677,2678,3,286,143,0,2678,2679,3,290,145, - 0,2679,285,1,0,0,0,2680,2681,5,165,0,0,2681,2682,3,288,144,0,2682,2683, - 3,0,0,0,2683,2684,5,36,0,0,2684,2688,1,0,0,0,2685,2686,5,165,0,0,2686, - 2688,3,288,144,0,2687,2680,1,0,0,0,2687,2685,1,0,0,0,2688,287,1,0,0,0, - 2689,2693,1,0,0,0,2690,2693,5,166,0,0,2691,2693,5,2,0,0,2692,2689,1,0, - 0,0,2692,2690,1,0,0,0,2692,2691,1,0,0,0,2693,289,1,0,0,0,2694,2695,5,17, - 0,0,2695,2696,3,292,146,0,2696,2697,5,18,0,0,2697,2704,1,0,0,0,2698,2700, - 3,296,148,0,2699,2698,1,0,0,0,2700,2701,1,0,0,0,2701,2699,1,0,0,0,2701, - 2702,1,0,0,0,2702,2704,1,0,0,0,2703,2694,1,0,0,0,2703,2699,1,0,0,0,2704, - 291,1,0,0,0,2705,2706,3,296,148,0,2706,2707,5,28,0,0,2707,2709,1,0,0,0, - 2708,2705,1,0,0,0,2709,2712,1,0,0,0,2710,2708,1,0,0,0,2710,2711,1,0,0, - 0,2711,2713,1,0,0,0,2712,2710,1,0,0,0,2713,2714,3,296,148,0,2714,293,1, - 0,0,0,2715,2721,1,0,0,0,2716,2717,5,42,0,0,2717,2718,3,32,16,0,2718,2719, - 5,43,0,0,2719,2721,1,0,0,0,2720,2715,1,0,0,0,2720,2716,1,0,0,0,2721,295, - 1,0,0,0,2722,2723,5,181,0,0,2723,2724,5,262,0,0,2724,2725,5,30,0,0,2725, - 2726,3,6,3,0,2726,2727,5,31,0,0,2727,2789,1,0,0,0,2728,2729,5,260,0,0, - 2729,2730,5,30,0,0,2730,2731,3,0,0,0,2731,2732,5,31,0,0,2732,2789,1,0, - 0,0,2733,2734,5,260,0,0,2734,2789,3,0,0,0,2735,2736,5,84,0,0,2736,2737, - 5,30,0,0,2737,2738,3,300,150,0,2738,2739,5,31,0,0,2739,2789,1,0,0,0,2740, - 2741,5,188,0,0,2741,2742,5,30,0,0,2742,2743,3,36,18,0,2743,2744,5,31,0, - 0,2744,2745,3,294,147,0,2745,2789,1,0,0,0,2746,2747,5,189,0,0,2747,2748, - 5,30,0,0,2748,2749,3,36,18,0,2749,2750,5,31,0,0,2750,2751,3,294,147,0, - 2751,2789,1,0,0,0,2752,2753,5,187,0,0,2753,2754,5,30,0,0,2754,2755,3,34, - 17,0,2755,2756,5,31,0,0,2756,2757,3,294,147,0,2757,2789,1,0,0,0,2758,2759, - 5,186,0,0,2759,2760,5,30,0,0,2760,2761,3,32,16,0,2761,2762,5,31,0,0,2762, - 2763,3,294,147,0,2763,2789,1,0,0,0,2764,2765,5,185,0,0,2765,2766,5,30, - 0,0,2766,2767,3,32,16,0,2767,2768,5,31,0,0,2768,2769,3,294,147,0,2769, - 2789,1,0,0,0,2770,2771,5,184,0,0,2771,2772,5,30,0,0,2772,2773,3,32,16, - 0,2773,2774,5,31,0,0,2774,2775,3,294,147,0,2775,2789,1,0,0,0,2776,2777, - 5,188,0,0,2777,2789,3,294,147,0,2778,2779,5,189,0,0,2779,2789,3,294,147, - 0,2780,2781,5,187,0,0,2781,2789,3,294,147,0,2782,2783,5,186,0,0,2783,2789, - 3,294,147,0,2784,2785,5,185,0,0,2785,2789,3,294,147,0,2786,2787,5,184, - 0,0,2787,2789,3,294,147,0,2788,2722,1,0,0,0,2788,2728,1,0,0,0,2788,2733, - 1,0,0,0,2788,2735,1,0,0,0,2788,2740,1,0,0,0,2788,2746,1,0,0,0,2788,2752, - 1,0,0,0,2788,2758,1,0,0,0,2788,2764,1,0,0,0,2788,2770,1,0,0,0,2788,2776, - 1,0,0,0,2788,2778,1,0,0,0,2788,2780,1,0,0,0,2788,2782,1,0,0,0,2788,2784, - 1,0,0,0,2788,2786,1,0,0,0,2789,297,1,0,0,0,2790,2791,5,188,0,0,2791,2792, - 5,30,0,0,2792,2793,3,36,18,0,2793,2794,5,31,0,0,2794,2866,1,0,0,0,2795, - 2796,5,189,0,0,2796,2797,5,30,0,0,2797,2798,3,36,18,0,2798,2799,5,31,0, - 0,2799,2866,1,0,0,0,2800,2801,5,188,0,0,2801,2802,5,30,0,0,2802,2803,3, - 32,16,0,2803,2804,5,31,0,0,2804,2866,1,0,0,0,2805,2806,5,189,0,0,2806, - 2807,5,30,0,0,2807,2808,3,34,17,0,2808,2809,5,31,0,0,2809,2866,1,0,0,0, - 2810,2811,5,187,0,0,2811,2812,5,30,0,0,2812,2813,3,34,17,0,2813,2814,5, - 31,0,0,2814,2866,1,0,0,0,2815,2816,5,186,0,0,2816,2817,5,30,0,0,2817,2818, - 3,32,16,0,2818,2819,5,31,0,0,2819,2866,1,0,0,0,2820,2821,5,185,0,0,2821, - 2822,5,30,0,0,2822,2823,3,32,16,0,2823,2824,5,31,0,0,2824,2866,1,0,0,0, - 2825,2826,5,184,0,0,2826,2827,5,30,0,0,2827,2828,3,32,16,0,2828,2829,5, - 31,0,0,2829,2866,1,0,0,0,2830,2831,5,193,0,0,2831,2832,5,30,0,0,2832,2833, - 3,34,17,0,2833,2834,5,31,0,0,2834,2866,1,0,0,0,2835,2836,5,192,0,0,2836, - 2837,5,30,0,0,2837,2838,3,32,16,0,2838,2839,5,31,0,0,2839,2866,1,0,0,0, - 2840,2841,5,191,0,0,2841,2842,5,30,0,0,2842,2843,3,32,16,0,2843,2844,5, - 31,0,0,2844,2866,1,0,0,0,2845,2846,5,190,0,0,2846,2847,5,30,0,0,2847,2848, - 3,32,16,0,2848,2849,5,31,0,0,2849,2866,1,0,0,0,2850,2851,5,181,0,0,2851, - 2852,5,30,0,0,2852,2853,3,32,16,0,2853,2854,5,31,0,0,2854,2866,1,0,0,0, - 2855,2856,5,183,0,0,2856,2857,5,30,0,0,2857,2858,3,162,81,0,2858,2859, - 5,31,0,0,2859,2866,1,0,0,0,2860,2861,5,84,0,0,2861,2862,5,30,0,0,2862, - 2863,3,300,150,0,2863,2864,5,31,0,0,2864,2866,1,0,0,0,2865,2790,1,0,0, - 0,2865,2795,1,0,0,0,2865,2800,1,0,0,0,2865,2805,1,0,0,0,2865,2810,1,0, - 0,0,2865,2815,1,0,0,0,2865,2820,1,0,0,0,2865,2825,1,0,0,0,2865,2830,1, - 0,0,0,2865,2835,1,0,0,0,2865,2840,1,0,0,0,2865,2845,1,0,0,0,2865,2850, - 1,0,0,0,2865,2855,1,0,0,0,2865,2860,1,0,0,0,2866,299,1,0,0,0,2867,2868, - 3,302,151,0,2868,2869,6,150,-1,0,2869,2871,1,0,0,0,2870,2867,1,0,0,0,2871, - 2874,1,0,0,0,2872,2870,1,0,0,0,2872,2873,1,0,0,0,2873,301,1,0,0,0,2874, - 2872,1,0,0,0,2875,2876,7,11,0,0,2876,303,1,0,0,0,2877,2881,3,298,149,0, - 2878,2881,3,6,3,0,2879,2881,5,179,0,0,2880,2877,1,0,0,0,2880,2878,1,0, - 0,0,2880,2879,1,0,0,0,2881,305,1,0,0,0,2882,3031,3,298,149,0,2883,2884, - 5,182,0,0,2884,2885,5,30,0,0,2885,2886,5,179,0,0,2886,3031,5,31,0,0,2887, - 2888,5,182,0,0,2888,2889,5,30,0,0,2889,2890,5,264,0,0,2890,3031,5,31,0, - 0,2891,2892,5,196,0,0,2892,2893,5,30,0,0,2893,2894,5,39,0,0,2894,2895, - 5,264,0,0,2895,3031,5,31,0,0,2896,2897,5,196,0,0,2897,2898,5,30,0,0,2898, - 2899,3,116,58,0,2899,2900,5,31,0,0,2900,3031,1,0,0,0,2901,2902,5,196,0, - 0,2902,2903,5,30,0,0,2903,2904,5,179,0,0,2904,3031,5,31,0,0,2905,2906, - 5,197,0,0,2906,2907,5,30,0,0,2907,2908,3,306,153,0,2908,2909,5,31,0,0, - 2909,3031,1,0,0,0,2910,2911,5,188,0,0,2911,2912,5,42,0,0,2912,2913,3,32, - 16,0,2913,2914,5,43,0,0,2914,2915,5,30,0,0,2915,2916,3,308,154,0,2916, - 2917,5,31,0,0,2917,3031,1,0,0,0,2918,2919,5,189,0,0,2919,2920,5,42,0,0, - 2920,2921,3,32,16,0,2921,2922,5,43,0,0,2922,2923,5,30,0,0,2923,2924,3, - 310,155,0,2924,2925,5,31,0,0,2925,3031,1,0,0,0,2926,2927,5,187,0,0,2927, - 2928,5,42,0,0,2928,2929,3,32,16,0,2929,2930,5,43,0,0,2930,2931,5,30,0, - 0,2931,2932,3,312,156,0,2932,2933,5,31,0,0,2933,3031,1,0,0,0,2934,2935, - 5,186,0,0,2935,2936,5,42,0,0,2936,2937,3,32,16,0,2937,2938,5,43,0,0,2938, - 2939,5,30,0,0,2939,2940,3,314,157,0,2940,2941,5,31,0,0,2941,3031,1,0,0, - 0,2942,2943,5,185,0,0,2943,2944,5,42,0,0,2944,2945,3,32,16,0,2945,2946, - 5,43,0,0,2946,2947,5,30,0,0,2947,2948,3,316,158,0,2948,2949,5,31,0,0,2949, - 3031,1,0,0,0,2950,2951,5,184,0,0,2951,2952,5,42,0,0,2952,2953,3,32,16, - 0,2953,2954,5,43,0,0,2954,2955,5,30,0,0,2955,2956,3,318,159,0,2956,2957, - 5,31,0,0,2957,3031,1,0,0,0,2958,2959,5,193,0,0,2959,2960,5,42,0,0,2960, - 2961,3,32,16,0,2961,2962,5,43,0,0,2962,2963,5,30,0,0,2963,2964,3,312,156, - 0,2964,2965,5,31,0,0,2965,3031,1,0,0,0,2966,2967,5,192,0,0,2967,2968,5, - 42,0,0,2968,2969,3,32,16,0,2969,2970,5,43,0,0,2970,2971,5,30,0,0,2971, - 2972,3,314,157,0,2972,2973,5,31,0,0,2973,3031,1,0,0,0,2974,2975,5,191, - 0,0,2975,2976,5,42,0,0,2976,2977,3,32,16,0,2977,2978,5,43,0,0,2978,2979, - 5,30,0,0,2979,2980,3,316,158,0,2980,2981,5,31,0,0,2981,3031,1,0,0,0,2982, - 2983,5,190,0,0,2983,2984,5,42,0,0,2984,2985,3,32,16,0,2985,2986,5,43,0, - 0,2986,2987,5,30,0,0,2987,2988,3,318,159,0,2988,2989,5,31,0,0,2989,3031, - 1,0,0,0,2990,2991,5,181,0,0,2991,2992,5,42,0,0,2992,2993,3,32,16,0,2993, - 2994,5,43,0,0,2994,2995,5,30,0,0,2995,2996,3,316,158,0,2996,2997,5,31, - 0,0,2997,3031,1,0,0,0,2998,2999,5,183,0,0,2999,3000,5,42,0,0,3000,3001, - 3,32,16,0,3001,3002,5,43,0,0,3002,3003,5,30,0,0,3003,3004,3,320,160,0, - 3004,3005,5,31,0,0,3005,3031,1,0,0,0,3006,3007,5,182,0,0,3007,3008,5,42, - 0,0,3008,3009,3,32,16,0,3009,3010,5,43,0,0,3010,3011,5,30,0,0,3011,3012, - 3,322,161,0,3012,3013,5,31,0,0,3013,3031,1,0,0,0,3014,3015,5,196,0,0,3015, - 3016,5,42,0,0,3016,3017,3,32,16,0,3017,3018,5,43,0,0,3018,3019,5,30,0, - 0,3019,3020,3,324,162,0,3020,3021,5,31,0,0,3021,3031,1,0,0,0,3022,3023, - 5,197,0,0,3023,3024,5,42,0,0,3024,3025,3,32,16,0,3025,3026,5,43,0,0,3026, - 3027,5,30,0,0,3027,3028,3,328,164,0,3028,3029,5,31,0,0,3029,3031,1,0,0, - 0,3030,2882,1,0,0,0,3030,2883,1,0,0,0,3030,2887,1,0,0,0,3030,2891,1,0, - 0,0,3030,2896,1,0,0,0,3030,2901,1,0,0,0,3030,2905,1,0,0,0,3030,2910,1, - 0,0,0,3030,2918,1,0,0,0,3030,2926,1,0,0,0,3030,2934,1,0,0,0,3030,2942, - 1,0,0,0,3030,2950,1,0,0,0,3030,2958,1,0,0,0,3030,2966,1,0,0,0,3030,2974, - 1,0,0,0,3030,2982,1,0,0,0,3030,2990,1,0,0,0,3030,2998,1,0,0,0,3030,3006, - 1,0,0,0,3030,3014,1,0,0,0,3030,3022,1,0,0,0,3031,307,1,0,0,0,3032,3035, - 3,36,18,0,3033,3035,3,32,16,0,3034,3032,1,0,0,0,3034,3033,1,0,0,0,3035, - 3038,1,0,0,0,3036,3034,1,0,0,0,3036,3037,1,0,0,0,3037,309,1,0,0,0,3038, - 3036,1,0,0,0,3039,3042,3,36,18,0,3040,3042,3,34,17,0,3041,3039,1,0,0,0, - 3041,3040,1,0,0,0,3042,3045,1,0,0,0,3043,3041,1,0,0,0,3043,3044,1,0,0, - 0,3044,311,1,0,0,0,3045,3043,1,0,0,0,3046,3048,3,34,17,0,3047,3046,1,0, - 0,0,3048,3051,1,0,0,0,3049,3047,1,0,0,0,3049,3050,1,0,0,0,3050,313,1,0, - 0,0,3051,3049,1,0,0,0,3052,3054,3,32,16,0,3053,3052,1,0,0,0,3054,3057, - 1,0,0,0,3055,3053,1,0,0,0,3055,3056,1,0,0,0,3056,315,1,0,0,0,3057,3055, - 1,0,0,0,3058,3060,3,32,16,0,3059,3058,1,0,0,0,3060,3063,1,0,0,0,3061,3059, - 1,0,0,0,3061,3062,1,0,0,0,3062,317,1,0,0,0,3063,3061,1,0,0,0,3064,3066, - 3,32,16,0,3065,3064,1,0,0,0,3066,3069,1,0,0,0,3067,3065,1,0,0,0,3067,3068, - 1,0,0,0,3068,319,1,0,0,0,3069,3067,1,0,0,0,3070,3072,3,162,81,0,3071,3070, - 1,0,0,0,3072,3075,1,0,0,0,3073,3071,1,0,0,0,3073,3074,1,0,0,0,3074,321, - 1,0,0,0,3075,3073,1,0,0,0,3076,3078,7,12,0,0,3077,3076,1,0,0,0,3078,3081, - 1,0,0,0,3079,3077,1,0,0,0,3079,3080,1,0,0,0,3080,323,1,0,0,0,3081,3079, - 1,0,0,0,3082,3084,3,326,163,0,3083,3082,1,0,0,0,3084,3087,1,0,0,0,3085, - 3083,1,0,0,0,3085,3086,1,0,0,0,3086,325,1,0,0,0,3087,3085,1,0,0,0,3088, - 3093,5,179,0,0,3089,3090,5,39,0,0,3090,3093,5,264,0,0,3091,3093,3,116, - 58,0,3092,3088,1,0,0,0,3092,3089,1,0,0,0,3092,3091,1,0,0,0,3093,327,1, - 0,0,0,3094,3096,3,306,153,0,3095,3094,1,0,0,0,3096,3099,1,0,0,0,3097,3095, - 1,0,0,0,3097,3098,1,0,0,0,3098,329,1,0,0,0,3099,3097,1,0,0,0,3100,3104, - 3,44,22,0,3101,3104,3,46,23,0,3102,3104,3,2,1,0,3103,3100,1,0,0,0,3103, - 3101,1,0,0,0,3103,3102,1,0,0,0,3104,331,1,0,0,0,3105,3106,7,13,0,0,3106, - 3107,5,36,0,0,3107,3108,5,30,0,0,3108,3109,3,300,150,0,3109,3110,5,31, - 0,0,3110,3131,1,0,0,0,3111,3112,5,169,0,0,3112,3113,3,38,19,0,3113,3114, - 5,75,0,0,3114,3115,3,38,19,0,3115,3116,5,75,0,0,3116,3117,3,38,19,0,3117, - 3118,5,75,0,0,3118,3119,3,38,19,0,3119,3131,1,0,0,0,3120,3121,5,170,0, - 0,3121,3131,3,6,3,0,3122,3123,5,170,0,0,3123,3124,5,36,0,0,3124,3125,5, - 30,0,0,3125,3126,3,300,150,0,3126,3127,5,31,0,0,3127,3131,1,0,0,0,3128, - 3131,3,330,165,0,3129,3131,3,40,20,0,3130,3105,1,0,0,0,3130,3111,1,0,0, - 0,3130,3120,1,0,0,0,3130,3122,1,0,0,0,3130,3128,1,0,0,0,3130,3129,1,0, - 0,0,3131,333,1,0,0,0,3132,3133,5,25,0,0,3133,3134,5,40,0,0,3134,3135,3, - 98,49,0,3135,3136,3,2,1,0,3136,3145,1,0,0,0,3137,3138,5,25,0,0,3138,3139, - 5,40,0,0,3139,3140,3,98,49,0,3140,3141,3,2,1,0,3141,3142,5,34,0,0,3142, - 3143,3,2,1,0,3143,3145,1,0,0,0,3144,3132,1,0,0,0,3144,3137,1,0,0,0,3145, - 335,1,0,0,0,3146,3148,3,338,169,0,3147,3146,1,0,0,0,3148,3151,1,0,0,0, - 3149,3147,1,0,0,0,3149,3150,1,0,0,0,3150,337,1,0,0,0,3151,3149,1,0,0,0, - 3152,3153,5,180,0,0,3153,3154,5,36,0,0,3154,3155,5,30,0,0,3155,3156,3, - 300,150,0,3156,3157,5,31,0,0,3157,3167,1,0,0,0,3158,3167,3,332,166,0,3159, - 3160,5,171,0,0,3160,3161,5,36,0,0,3161,3162,5,30,0,0,3162,3163,3,300,150, - 0,3163,3164,5,31,0,0,3164,3167,1,0,0,0,3165,3167,5,55,0,0,3166,3152,1, - 0,0,0,3166,3158,1,0,0,0,3166,3159,1,0,0,0,3166,3165,1,0,0,0,3167,339,1, - 0,0,0,3168,3169,5,50,0,0,3169,3173,5,40,0,0,3170,3172,3,344,172,0,3171, - 3170,1,0,0,0,3172,3175,1,0,0,0,3173,3171,1,0,0,0,3173,3174,1,0,0,0,3174, - 3176,1,0,0,0,3175,3173,1,0,0,0,3176,3177,3,2,1,0,3177,341,1,0,0,0,3178, - 3182,5,301,0,0,3179,3181,3,344,172,0,3180,3179,1,0,0,0,3181,3184,1,0,0, - 0,3182,3180,1,0,0,0,3182,3183,1,0,0,0,3183,3185,1,0,0,0,3184,3182,1,0, - 0,0,3185,3186,3,2,1,0,3186,343,1,0,0,0,3187,3203,5,52,0,0,3188,3203,5, - 51,0,0,3189,3203,5,172,0,0,3190,3191,5,62,0,0,3191,3203,5,51,0,0,3192, - 3193,5,62,0,0,3193,3203,5,52,0,0,3194,3195,5,62,0,0,3195,3203,5,63,0,0, - 3196,3197,5,62,0,0,3197,3203,5,64,0,0,3198,3199,5,62,0,0,3199,3203,5,65, - 0,0,3200,3201,5,62,0,0,3201,3203,5,66,0,0,3202,3187,1,0,0,0,3202,3188, - 1,0,0,0,3202,3189,1,0,0,0,3202,3190,1,0,0,0,3202,3192,1,0,0,0,3202,3194, - 1,0,0,0,3202,3196,1,0,0,0,3202,3198,1,0,0,0,3202,3200,1,0,0,0,3203,345, - 1,0,0,0,3204,3206,3,348,174,0,3205,3204,1,0,0,0,3206,3209,1,0,0,0,3207, - 3205,1,0,0,0,3207,3208,1,0,0,0,3208,347,1,0,0,0,3209,3207,1,0,0,0,3210, - 3211,5,21,0,0,3211,3224,3,2,1,0,3212,3213,5,50,0,0,3213,3214,5,40,0,0, - 3214,3224,3,118,59,0,3215,3216,5,25,0,0,3216,3217,5,40,0,0,3217,3224,3, - 2,1,0,3218,3224,3,174,87,0,3219,3220,5,50,0,0,3220,3224,3,32,16,0,3221, - 3224,3,330,165,0,3222,3224,3,40,20,0,3223,3210,1,0,0,0,3223,3212,1,0,0, - 0,3223,3215,1,0,0,0,3223,3218,1,0,0,0,3223,3219,1,0,0,0,3223,3221,1,0, - 0,0,3223,3222,1,0,0,0,3224,349,1,0,0,0,3225,3229,5,274,0,0,3226,3228,3, - 352,176,0,3227,3226,1,0,0,0,3228,3231,1,0,0,0,3229,3227,1,0,0,0,3229,3230, - 1,0,0,0,3230,3232,1,0,0,0,3231,3229,1,0,0,0,3232,3245,3,2,1,0,3233,3237, - 5,274,0,0,3234,3236,3,352,176,0,3235,3234,1,0,0,0,3236,3239,1,0,0,0,3237, - 3235,1,0,0,0,3237,3238,1,0,0,0,3238,3240,1,0,0,0,3239,3237,1,0,0,0,3240, - 3241,3,2,1,0,3241,3242,5,34,0,0,3242,3243,3,2,1,0,3243,3245,1,0,0,0,3244, - 3225,1,0,0,0,3244,3233,1,0,0,0,3245,351,1,0,0,0,3246,3247,7,14,0,0,3247, - 353,1,0,0,0,3248,3250,3,356,178,0,3249,3248,1,0,0,0,3250,3253,1,0,0,0, - 3251,3249,1,0,0,0,3251,3252,1,0,0,0,3252,355,1,0,0,0,3253,3251,1,0,0,0, - 3254,3255,5,21,0,0,3255,3256,3,2,1,0,3256,3257,5,44,0,0,3257,3258,3,32, - 16,0,3258,3265,1,0,0,0,3259,3260,5,25,0,0,3260,3261,5,40,0,0,3261,3265, - 3,2,1,0,3262,3265,3,330,165,0,3263,3265,3,40,20,0,3264,3254,1,0,0,0,3264, - 3259,1,0,0,0,3264,3262,1,0,0,0,3264,3263,1,0,0,0,3265,357,1,0,0,0,179, + 0,0,0,1936,1937,3,124,62,0,1937,1938,6,90,-1,0,1938,1939,5,28,0,0,1939, + 1941,1,0,0,0,1940,1936,1,0,0,0,1941,1944,1,0,0,0,1942,1940,1,0,0,0,1942, + 1943,1,0,0,0,1943,1945,1,0,0,0,1944,1942,1,0,0,0,1945,1946,3,124,62,0, + 1946,1947,6,90,-1,0,1947,181,1,0,0,0,1948,1955,1,0,0,0,1949,1950,5,86, + 0,0,1950,1951,3,190,95,0,1951,1952,5,87,0,0,1952,1953,6,91,-1,0,1953,1955, + 1,0,0,0,1954,1948,1,0,0,0,1954,1949,1,0,0,0,1955,183,1,0,0,0,1956,1957, + 5,266,0,0,1957,1975,6,92,-1,0,1958,1959,5,114,0,0,1959,1975,6,92,-1,0, + 1960,1961,5,39,0,0,1961,1975,6,92,-1,0,1962,1963,5,200,0,0,1963,1975,6, + 92,-1,0,1964,1965,5,115,0,0,1965,1975,6,92,-1,0,1966,1967,5,116,0,0,1967, + 1975,6,92,-1,0,1968,1969,5,70,0,0,1969,1970,5,30,0,0,1970,1971,3,32,16, + 0,1971,1972,5,31,0,0,1972,1973,6,92,-1,0,1973,1975,1,0,0,0,1974,1956,1, + 0,0,0,1974,1958,1,0,0,0,1974,1960,1,0,0,0,1974,1962,1,0,0,0,1974,1964, + 1,0,0,0,1974,1966,1,0,0,0,1974,1968,1,0,0,0,1975,185,1,0,0,0,1976,1977, + 3,184,92,0,1977,1978,6,93,-1,0,1978,1980,1,0,0,0,1979,1976,1,0,0,0,1980, + 1983,1,0,0,0,1981,1979,1,0,0,0,1981,1982,1,0,0,0,1982,187,1,0,0,0,1983, + 1981,1,0,0,0,1984,1986,3,186,93,0,1985,1987,3,192,96,0,1986,1985,1,0,0, + 0,1986,1987,1,0,0,0,1987,1988,1,0,0,0,1988,1989,3,2,1,0,1989,1990,6,94, + -1,0,1990,189,1,0,0,0,1991,1992,3,188,94,0,1992,1993,6,95,-1,0,1993,1994, + 5,28,0,0,1994,1996,1,0,0,0,1995,1991,1,0,0,0,1996,1999,1,0,0,0,1997,1995, + 1,0,0,0,1997,1998,1,0,0,0,1998,2000,1,0,0,0,1999,1997,1,0,0,0,2000,2001, + 3,188,94,0,2001,2002,6,95,-1,0,2002,191,1,0,0,0,2003,2004,5,30,0,0,2004, + 2005,3,180,90,0,2005,2006,5,31,0,0,2006,2007,6,96,-1,0,2007,193,1,0,0, + 0,2008,2010,3,196,98,0,2009,2008,1,0,0,0,2009,2010,1,0,0,0,2010,2011,1, + 0,0,0,2011,2012,6,97,-1,0,2012,195,1,0,0,0,2013,2014,5,86,0,0,2014,2015, + 5,42,0,0,2015,2016,3,32,16,0,2016,2017,5,43,0,0,2017,2018,5,87,0,0,2018, + 2019,6,98,-1,0,2019,197,1,0,0,0,2020,2021,3,234,117,0,2021,2022,5,17,0, + 0,2022,2023,3,246,123,0,2023,2024,5,18,0,0,2024,2171,1,0,0,0,2025,2026, + 3,74,37,0,2026,2027,5,17,0,0,2027,2028,3,82,41,0,2028,2029,5,18,0,0,2029, + 2171,1,0,0,0,2030,2031,3,210,105,0,2031,2032,6,99,-1,0,2032,2033,5,17, + 0,0,2033,2034,3,214,107,0,2034,2035,5,18,0,0,2035,2171,1,0,0,0,2036,2037, + 3,218,109,0,2037,2038,6,99,-1,0,2038,2039,5,17,0,0,2039,2040,3,222,111, + 0,2040,2041,5,18,0,0,2041,2171,1,0,0,0,2042,2171,3,200,100,0,2043,2044, + 3,284,142,0,2044,2045,6,99,-1,0,2045,2171,1,0,0,0,2046,2047,3,152,76,0, + 2047,2048,6,99,-1,0,2048,2171,1,0,0,0,2049,2050,3,88,44,0,2050,2051,6, + 99,-1,0,2051,2171,1,0,0,0,2052,2053,3,330,165,0,2053,2054,6,99,-1,0,2054, + 2171,1,0,0,0,2055,2056,5,117,0,0,2056,2057,3,32,16,0,2057,2058,6,99,-1, + 0,2058,2171,1,0,0,0,2059,2060,5,118,0,0,2060,2061,3,32,16,0,2061,2062, + 6,99,-1,0,2062,2171,1,0,0,0,2063,2064,3,342,171,0,2064,2065,5,17,0,0,2065, + 2066,3,346,173,0,2066,2067,5,18,0,0,2067,2068,6,99,-1,0,2068,2171,1,0, + 0,0,2069,2070,5,302,0,0,2070,2071,3,124,62,0,2071,2072,5,176,0,0,2072, + 2073,3,242,121,0,2073,2074,5,119,0,0,2074,2075,3,170,85,0,2075,2076,3, + 138,69,0,2076,2077,3,124,62,0,2077,2078,5,176,0,0,2078,2079,3,242,121, + 0,2079,2080,3,112,56,0,2080,2081,6,99,-1,0,2081,2171,1,0,0,0,2082,2083, + 5,302,0,0,2083,2084,5,226,0,0,2084,2085,3,170,85,0,2085,2086,3,138,69, + 0,2086,2087,3,124,62,0,2087,2088,5,176,0,0,2088,2089,3,242,121,0,2089, + 2090,3,194,97,0,2090,2091,3,112,56,0,2091,2092,5,119,0,0,2092,2093,5,226, + 0,0,2093,2094,3,170,85,0,2094,2095,3,138,69,0,2095,2096,3,124,62,0,2096, + 2097,5,176,0,0,2097,2098,3,242,121,0,2098,2099,3,194,97,0,2099,2100,3, + 112,56,0,2100,2101,6,99,-1,0,2101,2171,1,0,0,0,2102,2103,3,26,13,0,2103, + 2104,6,99,-1,0,2104,2171,1,0,0,0,2105,2106,3,40,20,0,2106,2107,6,99,-1, + 0,2107,2171,1,0,0,0,2108,2109,5,255,0,0,2109,2110,5,196,0,0,2110,2111, + 5,42,0,0,2111,2112,3,32,16,0,2112,2113,5,43,0,0,2113,2119,6,99,-1,0,2114, + 2115,3,330,165,0,2115,2116,6,99,-1,0,2116,2118,1,0,0,0,2117,2114,1,0,0, + 0,2118,2121,1,0,0,0,2119,2117,1,0,0,0,2119,2120,1,0,0,0,2120,2171,1,0, + 0,0,2121,2119,1,0,0,0,2122,2123,5,255,0,0,2123,2124,5,196,0,0,2124,2125, + 3,2,1,0,2125,2131,6,99,-1,0,2126,2127,3,330,165,0,2127,2128,6,99,-1,0, + 2128,2130,1,0,0,0,2129,2126,1,0,0,0,2130,2133,1,0,0,0,2131,2129,1,0,0, + 0,2131,2132,1,0,0,0,2132,2171,1,0,0,0,2133,2131,1,0,0,0,2134,2135,5,255, + 0,0,2135,2136,5,256,0,0,2136,2137,5,42,0,0,2137,2138,3,32,16,0,2138,2139, + 5,43,0,0,2139,2140,5,28,0,0,2140,2141,3,124,62,0,2141,2147,6,99,-1,0,2142, + 2143,3,330,165,0,2143,2144,6,99,-1,0,2144,2146,1,0,0,0,2145,2142,1,0,0, + 0,2146,2149,1,0,0,0,2147,2145,1,0,0,0,2147,2148,1,0,0,0,2148,2171,1,0, + 0,0,2149,2147,1,0,0,0,2150,2151,5,255,0,0,2151,2152,5,256,0,0,2152,2153, + 3,2,1,0,2153,2154,5,28,0,0,2154,2155,3,124,62,0,2155,2161,6,99,-1,0,2156, + 2157,3,330,165,0,2157,2158,6,99,-1,0,2158,2160,1,0,0,0,2159,2156,1,0,0, + 0,2160,2163,1,0,0,0,2161,2159,1,0,0,0,2161,2162,1,0,0,0,2162,2171,1,0, + 0,0,2163,2161,1,0,0,0,2164,2165,5,120,0,0,2165,2166,5,196,0,0,2166,2167, + 3,124,62,0,2167,2168,3,44,22,0,2168,2169,6,99,-1,0,2169,2171,1,0,0,0,2170, + 2020,1,0,0,0,2170,2025,1,0,0,0,2170,2030,1,0,0,0,2170,2036,1,0,0,0,2170, + 2042,1,0,0,0,2170,2043,1,0,0,0,2170,2046,1,0,0,0,2170,2049,1,0,0,0,2170, + 2052,1,0,0,0,2170,2055,1,0,0,0,2170,2059,1,0,0,0,2170,2063,1,0,0,0,2170, + 2069,1,0,0,0,2170,2082,1,0,0,0,2170,2102,1,0,0,0,2170,2105,1,0,0,0,2170, + 2108,1,0,0,0,2170,2122,1,0,0,0,2170,2134,1,0,0,0,2170,2150,1,0,0,0,2170, + 2164,1,0,0,0,2171,199,1,0,0,0,2172,2173,5,121,0,0,2173,2185,3,208,104, + 0,2174,2175,3,202,101,0,2175,2176,6,100,-1,0,2176,2184,1,0,0,0,2177,2178, + 5,122,0,0,2178,2179,5,30,0,0,2179,2180,3,228,114,0,2180,2181,5,31,0,0, + 2181,2182,6,100,-1,0,2182,2184,1,0,0,0,2183,2174,1,0,0,0,2183,2177,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,2189,3,138,69,0,2189,2190,3,2,1,0,2190,2191, + 3,204,102,0,2191,2192,3,206,103,0,2192,2193,6,100,-1,0,2193,201,1,0,0, + 0,2194,2195,5,123,0,0,2195,2229,6,101,-1,0,2196,2197,5,51,0,0,2197,2229, + 6,101,-1,0,2198,2199,5,52,0,0,2199,2229,6,101,-1,0,2200,2201,5,63,0,0, + 2201,2229,6,101,-1,0,2202,2203,5,124,0,0,2203,2229,6,101,-1,0,2204,2205, + 5,69,0,0,2205,2229,6,101,-1,0,2206,2207,5,68,0,0,2207,2229,6,101,-1,0, + 2208,2209,5,64,0,0,2209,2229,6,101,-1,0,2210,2211,5,65,0,0,2211,2229,6, + 101,-1,0,2212,2213,5,66,0,0,2213,2229,6,101,-1,0,2214,2215,5,125,0,0,2215, + 2229,6,101,-1,0,2216,2217,5,126,0,0,2217,2229,6,101,-1,0,2218,2219,5,127, + 0,0,2219,2229,6,101,-1,0,2220,2221,5,16,0,0,2221,2229,6,101,-1,0,2222, + 2223,5,70,0,0,2223,2224,5,30,0,0,2224,2225,3,32,16,0,2225,2226,5,31,0, + 0,2226,2227,6,101,-1,0,2227,2229,1,0,0,0,2228,2194,1,0,0,0,2228,2196,1, + 0,0,0,2228,2198,1,0,0,0,2228,2200,1,0,0,0,2228,2202,1,0,0,0,2228,2204, + 1,0,0,0,2228,2206,1,0,0,0,2228,2208,1,0,0,0,2228,2210,1,0,0,0,2228,2212, + 1,0,0,0,2228,2214,1,0,0,0,2228,2216,1,0,0,0,2228,2218,1,0,0,0,2228,2220, + 1,0,0,0,2228,2222,1,0,0,0,2229,203,1,0,0,0,2230,2240,1,0,0,0,2231,2232, + 5,44,0,0,2232,2233,3,0,0,0,2233,2234,6,102,-1,0,2234,2240,1,0,0,0,2235, + 2236,5,44,0,0,2236,2237,3,32,16,0,2237,2238,6,102,-1,0,2238,2240,1,0,0, + 0,2239,2230,1,0,0,0,2239,2231,1,0,0,0,2239,2235,1,0,0,0,2240,205,1,0,0, + 0,2241,2247,1,0,0,0,2242,2243,5,36,0,0,2243,2244,3,304,152,0,2244,2245, + 6,103,-1,0,2245,2247,1,0,0,0,2246,2241,1,0,0,0,2246,2242,1,0,0,0,2247, + 207,1,0,0,0,2248,2255,1,0,0,0,2249,2250,5,42,0,0,2250,2251,3,32,16,0,2251, + 2252,5,43,0,0,2252,2253,6,104,-1,0,2253,2255,1,0,0,0,2254,2248,1,0,0,0, + 2254,2249,1,0,0,0,2255,209,1,0,0,0,2256,2262,5,128,0,0,2257,2258,3,212, + 106,0,2258,2259,6,105,-1,0,2259,2261,1,0,0,0,2260,2257,1,0,0,0,2261,2264, + 1,0,0,0,2262,2260,1,0,0,0,2262,2263,1,0,0,0,2263,2265,1,0,0,0,2264,2262, + 1,0,0,0,2265,2266,3,124,62,0,2266,2267,3,2,1,0,2267,2268,6,105,-1,0,2268, + 2282,1,0,0,0,2269,2275,5,128,0,0,2270,2271,3,212,106,0,2271,2272,6,105, + -1,0,2272,2274,1,0,0,0,2273,2270,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,2279, + 3,2,1,0,2279,2280,6,105,-1,0,2280,2282,1,0,0,0,2281,2256,1,0,0,0,2281, + 2269,1,0,0,0,2282,211,1,0,0,0,2283,2284,5,69,0,0,2284,2288,6,106,-1,0, + 2285,2286,5,68,0,0,2286,2288,6,106,-1,0,2287,2283,1,0,0,0,2287,2285,1, + 0,0,0,2288,213,1,0,0,0,2289,2291,3,216,108,0,2290,2289,1,0,0,0,2291,2294, + 1,0,0,0,2292,2290,1,0,0,0,2292,2293,1,0,0,0,2293,215,1,0,0,0,2294,2292, + 1,0,0,0,2295,2296,5,129,0,0,2296,2297,3,168,84,0,2297,2298,6,108,-1,0, + 2298,2322,1,0,0,0,2299,2300,5,130,0,0,2300,2301,3,168,84,0,2301,2302,6, + 108,-1,0,2302,2322,1,0,0,0,2303,2304,5,131,0,0,2304,2305,3,168,84,0,2305, + 2306,6,108,-1,0,2306,2322,1,0,0,0,2307,2308,5,132,0,0,2308,2309,3,168, + 84,0,2309,2310,6,108,-1,0,2310,2322,1,0,0,0,2311,2312,3,88,44,0,2312,2313, + 6,108,-1,0,2313,2322,1,0,0,0,2314,2315,3,330,165,0,2315,2316,6,108,-1, + 0,2316,2322,1,0,0,0,2317,2318,3,26,13,0,2318,2319,6,108,-1,0,2319,2322, + 1,0,0,0,2320,2322,3,40,20,0,2321,2295,1,0,0,0,2321,2299,1,0,0,0,2321,2303, + 1,0,0,0,2321,2307,1,0,0,0,2321,2311,1,0,0,0,2321,2314,1,0,0,0,2321,2317, + 1,0,0,0,2321,2320,1,0,0,0,2322,217,1,0,0,0,2323,2329,5,133,0,0,2324,2325, + 3,220,110,0,2325,2326,6,109,-1,0,2326,2328,1,0,0,0,2327,2324,1,0,0,0,2328, + 2331,1,0,0,0,2329,2327,1,0,0,0,2329,2330,1,0,0,0,2330,2332,1,0,0,0,2331, + 2329,1,0,0,0,2332,2333,3,170,85,0,2333,2334,3,138,69,0,2334,2335,3,2,1, + 0,2335,2336,3,112,56,0,2336,2337,3,206,103,0,2337,2338,6,109,-1,0,2338, + 219,1,0,0,0,2339,2340,5,69,0,0,2340,2344,6,110,-1,0,2341,2342,5,68,0,0, + 2342,2344,6,110,-1,0,2343,2339,1,0,0,0,2343,2341,1,0,0,0,2344,221,1,0, + 0,0,2345,2347,3,224,112,0,2346,2345,1,0,0,0,2347,2350,1,0,0,0,2348,2346, + 1,0,0,0,2348,2349,1,0,0,0,2349,223,1,0,0,0,2350,2348,1,0,0,0,2351,2352, + 5,134,0,0,2352,2353,3,168,84,0,2353,2354,6,112,-1,0,2354,2374,1,0,0,0, + 2355,2356,5,135,0,0,2356,2357,3,168,84,0,2357,2358,6,112,-1,0,2358,2374, + 1,0,0,0,2359,2360,5,132,0,0,2360,2361,3,168,84,0,2361,2362,6,112,-1,0, + 2362,2374,1,0,0,0,2363,2364,3,330,165,0,2364,2365,6,112,-1,0,2365,2374, + 1,0,0,0,2366,2367,3,88,44,0,2367,2368,6,112,-1,0,2368,2374,1,0,0,0,2369, + 2370,3,26,13,0,2370,2371,6,112,-1,0,2371,2374,1,0,0,0,2372,2374,3,40,20, + 0,2373,2351,1,0,0,0,2373,2355,1,0,0,0,2373,2359,1,0,0,0,2373,2363,1,0, + 0,0,2373,2366,1,0,0,0,2373,2369,1,0,0,0,2373,2372,1,0,0,0,2374,225,1,0, + 0,0,2375,2383,6,113,-1,0,2376,2377,5,122,0,0,2377,2378,5,30,0,0,2378,2379, + 3,228,114,0,2379,2380,5,31,0,0,2380,2381,6,113,-1,0,2381,2383,1,0,0,0, + 2382,2375,1,0,0,0,2382,2376,1,0,0,0,2383,227,1,0,0,0,2384,2385,3,126,63, + 0,2385,2386,6,114,-1,0,2386,2398,1,0,0,0,2387,2391,5,17,0,0,2388,2389, + 3,302,151,0,2389,2390,6,114,-1,0,2390,2392,1,0,0,0,2391,2388,1,0,0,0,2392, + 2393,1,0,0,0,2393,2391,1,0,0,0,2393,2394,1,0,0,0,2394,2395,1,0,0,0,2395, + 2396,5,18,0,0,2396,2398,1,0,0,0,2397,2384,1,0,0,0,2397,2387,1,0,0,0,2398, + 229,1,0,0,0,2399,2400,3,232,116,0,2400,2401,6,115,-1,0,2401,2403,1,0,0, + 0,2402,2399,1,0,0,0,2403,2406,1,0,0,0,2404,2402,1,0,0,0,2404,2405,1,0, + 0,0,2405,231,1,0,0,0,2406,2404,1,0,0,0,2407,2408,5,42,0,0,2408,2409,5, + 136,0,0,2409,2410,5,43,0,0,2410,2425,6,116,-1,0,2411,2412,5,42,0,0,2412, + 2413,5,137,0,0,2413,2414,5,43,0,0,2414,2425,6,116,-1,0,2415,2416,5,42, + 0,0,2416,2417,5,138,0,0,2417,2418,5,43,0,0,2418,2425,6,116,-1,0,2419,2420, + 5,42,0,0,2420,2421,3,32,16,0,2421,2422,5,43,0,0,2422,2423,6,116,-1,0,2423, + 2425,1,0,0,0,2424,2407,1,0,0,0,2424,2411,1,0,0,0,2424,2415,1,0,0,0,2424, + 2419,1,0,0,0,2425,233,1,0,0,0,2426,2435,5,139,0,0,2427,2428,3,236,118, + 0,2428,2429,6,117,-1,0,2429,2434,1,0,0,0,2430,2431,3,238,119,0,2431,2432, + 6,117,-1,0,2432,2434,1,0,0,0,2433,2427,1,0,0,0,2433,2430,1,0,0,0,2434, + 2437,1,0,0,0,2435,2433,1,0,0,0,2435,2436,1,0,0,0,2436,2438,1,0,0,0,2437, + 2435,1,0,0,0,2438,2439,3,170,85,0,2439,2440,3,230,115,0,2440,2441,3,138, + 69,0,2441,2442,3,226,113,0,2442,2443,3,242,121,0,2443,2444,3,182,91,0, + 2444,2450,3,112,56,0,2445,2446,3,244,122,0,2446,2447,6,117,-1,0,2447,2449, + 1,0,0,0,2448,2445,1,0,0,0,2449,2452,1,0,0,0,2450,2448,1,0,0,0,2450,2451, + 1,0,0,0,2451,2453,1,0,0,0,2452,2450,1,0,0,0,2453,2454,6,117,-1,0,2454, + 235,1,0,0,0,2455,2456,5,123,0,0,2456,2498,6,118,-1,0,2457,2458,5,51,0, + 0,2458,2498,6,118,-1,0,2459,2460,5,52,0,0,2460,2498,6,118,-1,0,2461,2462, + 5,63,0,0,2462,2498,6,118,-1,0,2463,2464,5,140,0,0,2464,2498,6,118,-1,0, + 2465,2466,5,68,0,0,2466,2498,6,118,-1,0,2467,2468,5,141,0,0,2468,2498, + 6,118,-1,0,2469,2470,5,142,0,0,2470,2498,6,118,-1,0,2471,2472,5,54,0,0, + 2472,2498,6,118,-1,0,2473,2474,5,64,0,0,2474,2498,6,118,-1,0,2475,2476, + 5,65,0,0,2476,2498,6,118,-1,0,2477,2478,5,66,0,0,2478,2498,6,118,-1,0, + 2479,2480,5,125,0,0,2480,2498,6,118,-1,0,2481,2482,5,143,0,0,2482,2498, + 6,118,-1,0,2483,2484,5,144,0,0,2484,2498,6,118,-1,0,2485,2486,5,69,0,0, + 2486,2498,6,118,-1,0,2487,2488,5,145,0,0,2488,2498,6,118,-1,0,2489,2490, + 5,146,0,0,2490,2498,6,118,-1,0,2491,2492,5,70,0,0,2492,2493,5,30,0,0,2493, + 2494,3,32,16,0,2494,2495,5,31,0,0,2495,2496,6,118,-1,0,2496,2498,1,0,0, + 0,2497,2455,1,0,0,0,2497,2457,1,0,0,0,2497,2459,1,0,0,0,2497,2461,1,0, + 0,0,2497,2463,1,0,0,0,2497,2465,1,0,0,0,2497,2467,1,0,0,0,2497,2469,1, + 0,0,0,2497,2471,1,0,0,0,2497,2473,1,0,0,0,2497,2475,1,0,0,0,2497,2477, + 1,0,0,0,2497,2479,1,0,0,0,2497,2481,1,0,0,0,2497,2483,1,0,0,0,2497,2485, + 1,0,0,0,2497,2487,1,0,0,0,2497,2489,1,0,0,0,2497,2491,1,0,0,0,2498,237, + 1,0,0,0,2499,2500,5,147,0,0,2500,2509,5,30,0,0,2501,2502,3,6,3,0,2502, + 2507,6,119,-1,0,2503,2504,5,34,0,0,2504,2505,3,6,3,0,2505,2506,6,119,-1, + 0,2506,2508,1,0,0,0,2507,2503,1,0,0,0,2507,2508,1,0,0,0,2508,2510,1,0, + 0,0,2509,2501,1,0,0,0,2509,2510,1,0,0,0,2510,2516,1,0,0,0,2511,2512,3, + 240,120,0,2512,2513,6,119,-1,0,2513,2515,1,0,0,0,2514,2511,1,0,0,0,2515, + 2518,1,0,0,0,2516,2514,1,0,0,0,2516,2517,1,0,0,0,2517,2519,1,0,0,0,2518, + 2516,1,0,0,0,2519,2523,5,31,0,0,2520,2521,5,147,0,0,2521,2523,5,85,0,0, + 2522,2499,1,0,0,0,2522,2520,1,0,0,0,2523,239,1,0,0,0,2524,2525,5,148,0, + 0,2525,2567,6,120,-1,0,2526,2527,5,224,0,0,2527,2567,6,120,-1,0,2528,2529, + 5,57,0,0,2529,2567,6,120,-1,0,2530,2531,5,58,0,0,2531,2567,6,120,-1,0, + 2532,2533,5,149,0,0,2533,2567,6,120,-1,0,2534,2535,5,150,0,0,2535,2567, + 6,120,-1,0,2536,2537,5,248,0,0,2537,2567,6,120,-1,0,2538,2539,5,249,0, + 0,2539,2567,6,120,-1,0,2540,2541,5,250,0,0,2541,2567,6,120,-1,0,2542,2543, + 5,251,0,0,2543,2567,6,120,-1,0,2544,2545,5,151,0,0,2545,2546,5,75,0,0, + 2546,2547,5,152,0,0,2547,2567,6,120,-1,0,2548,2549,5,151,0,0,2549,2550, + 5,75,0,0,2550,2551,5,153,0,0,2551,2567,6,120,-1,0,2552,2553,5,154,0,0, + 2553,2554,5,75,0,0,2554,2555,5,152,0,0,2555,2567,6,120,-1,0,2556,2557, + 5,154,0,0,2557,2558,5,75,0,0,2558,2559,5,153,0,0,2559,2567,6,120,-1,0, + 2560,2561,5,70,0,0,2561,2562,5,30,0,0,2562,2563,3,32,16,0,2563,2564,5, + 31,0,0,2564,2565,6,120,-1,0,2565,2567,1,0,0,0,2566,2524,1,0,0,0,2566,2526, + 1,0,0,0,2566,2528,1,0,0,0,2566,2530,1,0,0,0,2566,2532,1,0,0,0,2566,2534, + 1,0,0,0,2566,2536,1,0,0,0,2566,2538,1,0,0,0,2566,2540,1,0,0,0,2566,2542, + 1,0,0,0,2566,2544,1,0,0,0,2566,2548,1,0,0,0,2566,2552,1,0,0,0,2566,2556, + 1,0,0,0,2566,2560,1,0,0,0,2567,241,1,0,0,0,2568,2569,5,116,0,0,2569,2576, + 6,121,-1,0,2570,2571,5,155,0,0,2571,2576,6,121,-1,0,2572,2573,3,2,1,0, + 2573,2574,6,121,-1,0,2574,2576,1,0,0,0,2575,2568,1,0,0,0,2575,2570,1,0, + 0,0,2575,2572,1,0,0,0,2576,243,1,0,0,0,2577,2578,5,1,0,0,2578,2616,6,122, + -1,0,2579,2580,5,2,0,0,2580,2616,6,122,-1,0,2581,2582,5,156,0,0,2582,2616, + 6,122,-1,0,2583,2584,5,3,0,0,2584,2616,6,122,-1,0,2585,2586,5,4,0,0,2586, + 2616,6,122,-1,0,2587,2588,5,247,0,0,2588,2616,6,122,-1,0,2589,2590,5,5, + 0,0,2590,2616,6,122,-1,0,2591,2592,5,6,0,0,2592,2616,6,122,-1,0,2593,2594, + 5,7,0,0,2594,2616,6,122,-1,0,2595,2596,5,8,0,0,2596,2616,6,122,-1,0,2597, + 2598,5,9,0,0,2598,2616,6,122,-1,0,2599,2600,5,10,0,0,2600,2616,6,122,-1, + 0,2601,2602,5,11,0,0,2602,2616,6,122,-1,0,2603,2604,5,12,0,0,2604,2616, + 6,122,-1,0,2605,2606,5,13,0,0,2606,2616,6,122,-1,0,2607,2608,5,14,0,0, + 2608,2616,6,122,-1,0,2609,2610,5,70,0,0,2610,2611,5,30,0,0,2611,2612,3, + 32,16,0,2612,2613,5,31,0,0,2613,2614,6,122,-1,0,2614,2616,1,0,0,0,2615, + 2577,1,0,0,0,2615,2579,1,0,0,0,2615,2581,1,0,0,0,2615,2583,1,0,0,0,2615, + 2585,1,0,0,0,2615,2587,1,0,0,0,2615,2589,1,0,0,0,2615,2591,1,0,0,0,2615, + 2593,1,0,0,0,2615,2595,1,0,0,0,2615,2597,1,0,0,0,2615,2599,1,0,0,0,2615, + 2601,1,0,0,0,2615,2603,1,0,0,0,2615,2605,1,0,0,0,2615,2607,1,0,0,0,2615, + 2609,1,0,0,0,2616,245,1,0,0,0,2617,2619,3,248,124,0,2618,2617,1,0,0,0, + 2619,2622,1,0,0,0,2620,2618,1,0,0,0,2620,2621,1,0,0,0,2621,247,1,0,0,0, + 2622,2620,1,0,0,0,2623,2661,3,100,50,0,2624,2625,5,296,0,0,2625,2626,3, + 32,16,0,2626,2627,6,124,-1,0,2627,2661,1,0,0,0,2628,2661,3,266,133,0,2629, + 2630,5,297,0,0,2630,2631,3,32,16,0,2631,2632,6,124,-1,0,2632,2661,1,0, + 0,0,2633,2634,5,298,0,0,2634,2661,6,124,-1,0,2635,2636,5,299,0,0,2636, + 2661,6,124,-1,0,2637,2661,3,260,130,0,2638,2661,3,264,132,0,2639,2661, + 3,250,125,0,2640,2641,3,284,142,0,2641,2642,6,124,-1,0,2642,2661,1,0,0, + 0,2643,2644,3,152,76,0,2644,2645,6,124,-1,0,2645,2661,1,0,0,0,2646,2647, + 3,88,44,0,2647,2648,6,124,-1,0,2648,2661,1,0,0,0,2649,2650,3,26,13,0,2650, + 2651,6,124,-1,0,2651,2661,1,0,0,0,2652,2653,3,262,131,0,2653,2654,6,124, + -1,0,2654,2661,1,0,0,0,2655,2661,3,40,20,0,2656,2661,3,252,126,0,2657, + 2661,3,254,127,0,2658,2661,3,256,128,0,2659,2661,3,258,129,0,2660,2623, + 1,0,0,0,2660,2624,1,0,0,0,2660,2628,1,0,0,0,2660,2629,1,0,0,0,2660,2633, + 1,0,0,0,2660,2635,1,0,0,0,2660,2637,1,0,0,0,2660,2638,1,0,0,0,2660,2639, + 1,0,0,0,2660,2640,1,0,0,0,2660,2643,1,0,0,0,2660,2646,1,0,0,0,2660,2649, + 1,0,0,0,2660,2652,1,0,0,0,2660,2655,1,0,0,0,2660,2656,1,0,0,0,2660,2657, + 1,0,0,0,2660,2658,1,0,0,0,2660,2659,1,0,0,0,2661,249,1,0,0,0,2662,2664, + 5,300,0,0,2663,2665,5,157,0,0,2664,2663,1,0,0,0,2664,2665,1,0,0,0,2665, + 2666,1,0,0,0,2666,2667,3,112,56,0,2667,251,1,0,0,0,2668,2669,5,301,0,0, + 2669,2670,5,42,0,0,2670,2671,3,32,16,0,2671,2674,5,43,0,0,2672,2673,5, + 34,0,0,2673,2675,3,0,0,0,2674,2672,1,0,0,0,2674,2675,1,0,0,0,2675,253, + 1,0,0,0,2676,2677,5,303,0,0,2677,2678,3,32,16,0,2678,2679,5,75,0,0,2679, + 2680,3,32,16,0,2680,255,1,0,0,0,2681,2682,5,302,0,0,2682,2683,3,124,62, + 0,2683,2684,5,176,0,0,2684,2685,3,242,121,0,2685,2697,1,0,0,0,2686,2687, + 5,302,0,0,2687,2688,5,226,0,0,2688,2689,3,170,85,0,2689,2690,3,138,69, + 0,2690,2691,3,124,62,0,2691,2692,5,176,0,0,2692,2693,3,242,121,0,2693, + 2694,3,194,97,0,2694,2695,3,112,56,0,2695,2697,1,0,0,0,2696,2681,1,0,0, + 0,2696,2686,1,0,0,0,2697,257,1,0,0,0,2698,2699,5,255,0,0,2699,2700,5,196, + 0,0,2700,2701,5,42,0,0,2701,2702,3,32,16,0,2702,2708,5,43,0,0,2703,2704, + 3,330,165,0,2704,2705,6,129,-1,0,2705,2707,1,0,0,0,2706,2703,1,0,0,0,2707, + 2710,1,0,0,0,2708,2706,1,0,0,0,2708,2709,1,0,0,0,2709,2764,1,0,0,0,2710, + 2708,1,0,0,0,2711,2712,5,255,0,0,2712,2713,5,196,0,0,2713,2719,3,2,1,0, + 2714,2715,3,330,165,0,2715,2716,6,129,-1,0,2716,2718,1,0,0,0,2717,2714, + 1,0,0,0,2718,2721,1,0,0,0,2719,2717,1,0,0,0,2719,2720,1,0,0,0,2720,2764, + 1,0,0,0,2721,2719,1,0,0,0,2722,2723,5,255,0,0,2723,2724,5,256,0,0,2724, + 2725,5,42,0,0,2725,2726,3,32,16,0,2726,2727,5,43,0,0,2727,2728,5,28,0, + 0,2728,2734,3,124,62,0,2729,2730,3,330,165,0,2730,2731,6,129,-1,0,2731, + 2733,1,0,0,0,2732,2729,1,0,0,0,2733,2736,1,0,0,0,2734,2732,1,0,0,0,2734, + 2735,1,0,0,0,2735,2764,1,0,0,0,2736,2734,1,0,0,0,2737,2738,5,255,0,0,2738, + 2739,5,256,0,0,2739,2740,3,2,1,0,2740,2741,5,28,0,0,2741,2747,3,124,62, + 0,2742,2743,3,330,165,0,2743,2744,6,129,-1,0,2744,2746,1,0,0,0,2745,2742, + 1,0,0,0,2746,2749,1,0,0,0,2747,2745,1,0,0,0,2747,2748,1,0,0,0,2748,2764, + 1,0,0,0,2749,2747,1,0,0,0,2750,2751,5,255,0,0,2751,2752,5,42,0,0,2752, + 2753,3,32,16,0,2753,2754,5,43,0,0,2754,2760,3,206,103,0,2755,2756,3,330, + 165,0,2756,2757,6,129,-1,0,2757,2759,1,0,0,0,2758,2755,1,0,0,0,2759,2762, + 1,0,0,0,2760,2758,1,0,0,0,2760,2761,1,0,0,0,2761,2764,1,0,0,0,2762,2760, + 1,0,0,0,2763,2698,1,0,0,0,2763,2711,1,0,0,0,2763,2722,1,0,0,0,2763,2737, + 1,0,0,0,2763,2750,1,0,0,0,2764,259,1,0,0,0,2765,2766,3,0,0,0,2766,2767, + 5,75,0,0,2767,2768,6,130,-1,0,2768,261,1,0,0,0,2769,2772,3,44,22,0,2770, + 2772,3,46,23,0,2771,2769,1,0,0,0,2771,2770,1,0,0,0,2772,263,1,0,0,0,2773, + 2774,5,17,0,0,2774,2775,3,246,123,0,2775,2776,5,18,0,0,2776,265,1,0,0, + 0,2777,2778,3,270,135,0,2778,2779,3,268,134,0,2779,267,1,0,0,0,2780,2781, + 3,272,136,0,2781,2782,6,134,-1,0,2782,2784,1,0,0,0,2783,2780,1,0,0,0,2784, + 2785,1,0,0,0,2785,2783,1,0,0,0,2785,2786,1,0,0,0,2786,269,1,0,0,0,2787, + 2788,5,158,0,0,2788,2789,3,264,132,0,2789,2790,6,135,-1,0,2790,2804,1, + 0,0,0,2791,2792,5,158,0,0,2792,2793,3,0,0,0,2793,2794,5,159,0,0,2794,2795, + 3,0,0,0,2795,2796,6,135,-1,0,2796,2804,1,0,0,0,2797,2798,5,158,0,0,2798, + 2799,3,32,16,0,2799,2800,5,159,0,0,2800,2801,3,32,16,0,2801,2802,6,135, + -1,0,2802,2804,1,0,0,0,2803,2787,1,0,0,0,2803,2791,1,0,0,0,2803,2797,1, + 0,0,0,2804,271,1,0,0,0,2805,2806,3,276,138,0,2806,2807,3,282,141,0,2807, + 2808,6,136,-1,0,2808,2822,1,0,0,0,2809,2810,3,274,137,0,2810,2811,3,282, + 141,0,2811,2812,6,136,-1,0,2812,2822,1,0,0,0,2813,2814,3,278,139,0,2814, + 2815,3,282,141,0,2815,2816,6,136,-1,0,2816,2822,1,0,0,0,2817,2818,3,280, + 140,0,2818,2819,3,282,141,0,2819,2820,6,136,-1,0,2820,2822,1,0,0,0,2821, + 2805,1,0,0,0,2821,2809,1,0,0,0,2821,2813,1,0,0,0,2821,2817,1,0,0,0,2822, + 273,1,0,0,0,2823,2824,5,160,0,0,2824,2825,3,264,132,0,2825,2826,6,137, + -1,0,2826,2836,1,0,0,0,2827,2828,5,160,0,0,2828,2829,3,0,0,0,2829,2830, + 6,137,-1,0,2830,2836,1,0,0,0,2831,2832,5,160,0,0,2832,2833,3,32,16,0,2833, + 2834,6,137,-1,0,2834,2836,1,0,0,0,2835,2823,1,0,0,0,2835,2827,1,0,0,0, + 2835,2831,1,0,0,0,2836,275,1,0,0,0,2837,2838,5,161,0,0,2838,2839,3,124, + 62,0,2839,277,1,0,0,0,2840,2841,5,162,0,0,2841,279,1,0,0,0,2842,2843,5, + 163,0,0,2843,281,1,0,0,0,2844,2845,3,264,132,0,2845,2846,6,141,-1,0,2846, + 2860,1,0,0,0,2847,2848,5,164,0,0,2848,2849,3,0,0,0,2849,2850,5,159,0,0, + 2850,2851,3,0,0,0,2851,2852,6,141,-1,0,2852,2860,1,0,0,0,2853,2854,5,164, + 0,0,2854,2855,3,32,16,0,2855,2856,5,159,0,0,2856,2857,3,32,16,0,2857,2858, + 6,141,-1,0,2858,2860,1,0,0,0,2859,2844,1,0,0,0,2859,2847,1,0,0,0,2859, + 2853,1,0,0,0,2860,283,1,0,0,0,2861,2862,3,286,143,0,2862,2863,3,290,145, + 0,2863,285,1,0,0,0,2864,2865,5,165,0,0,2865,2866,3,288,144,0,2866,2867, + 3,0,0,0,2867,2868,5,36,0,0,2868,2872,1,0,0,0,2869,2870,5,165,0,0,2870, + 2872,3,288,144,0,2871,2864,1,0,0,0,2871,2869,1,0,0,0,2872,287,1,0,0,0, + 2873,2877,1,0,0,0,2874,2877,5,166,0,0,2875,2877,5,2,0,0,2876,2873,1,0, + 0,0,2876,2874,1,0,0,0,2876,2875,1,0,0,0,2877,289,1,0,0,0,2878,2879,5,17, + 0,0,2879,2880,3,292,146,0,2880,2881,5,18,0,0,2881,2888,1,0,0,0,2882,2884, + 3,296,148,0,2883,2882,1,0,0,0,2884,2885,1,0,0,0,2885,2883,1,0,0,0,2885, + 2886,1,0,0,0,2886,2888,1,0,0,0,2887,2878,1,0,0,0,2887,2883,1,0,0,0,2888, + 291,1,0,0,0,2889,2890,3,296,148,0,2890,2891,5,28,0,0,2891,2893,1,0,0,0, + 2892,2889,1,0,0,0,2893,2896,1,0,0,0,2894,2892,1,0,0,0,2894,2895,1,0,0, + 0,2895,2897,1,0,0,0,2896,2894,1,0,0,0,2897,2898,3,296,148,0,2898,293,1, + 0,0,0,2899,2905,1,0,0,0,2900,2901,5,42,0,0,2901,2902,3,32,16,0,2902,2903, + 5,43,0,0,2903,2905,1,0,0,0,2904,2899,1,0,0,0,2904,2900,1,0,0,0,2905,295, + 1,0,0,0,2906,2907,5,181,0,0,2907,2908,5,262,0,0,2908,2909,5,30,0,0,2909, + 2910,3,6,3,0,2910,2911,5,31,0,0,2911,2973,1,0,0,0,2912,2913,5,260,0,0, + 2913,2914,5,30,0,0,2914,2915,3,0,0,0,2915,2916,5,31,0,0,2916,2973,1,0, + 0,0,2917,2918,5,260,0,0,2918,2973,3,0,0,0,2919,2920,5,84,0,0,2920,2921, + 5,30,0,0,2921,2922,3,300,150,0,2922,2923,5,31,0,0,2923,2973,1,0,0,0,2924, + 2925,5,188,0,0,2925,2926,5,30,0,0,2926,2927,3,36,18,0,2927,2928,5,31,0, + 0,2928,2929,3,294,147,0,2929,2973,1,0,0,0,2930,2931,5,189,0,0,2931,2932, + 5,30,0,0,2932,2933,3,36,18,0,2933,2934,5,31,0,0,2934,2935,3,294,147,0, + 2935,2973,1,0,0,0,2936,2937,5,187,0,0,2937,2938,5,30,0,0,2938,2939,3,34, + 17,0,2939,2940,5,31,0,0,2940,2941,3,294,147,0,2941,2973,1,0,0,0,2942,2943, + 5,186,0,0,2943,2944,5,30,0,0,2944,2945,3,32,16,0,2945,2946,5,31,0,0,2946, + 2947,3,294,147,0,2947,2973,1,0,0,0,2948,2949,5,185,0,0,2949,2950,5,30, + 0,0,2950,2951,3,32,16,0,2951,2952,5,31,0,0,2952,2953,3,294,147,0,2953, + 2973,1,0,0,0,2954,2955,5,184,0,0,2955,2956,5,30,0,0,2956,2957,3,32,16, + 0,2957,2958,5,31,0,0,2958,2959,3,294,147,0,2959,2973,1,0,0,0,2960,2961, + 5,188,0,0,2961,2973,3,294,147,0,2962,2963,5,189,0,0,2963,2973,3,294,147, + 0,2964,2965,5,187,0,0,2965,2973,3,294,147,0,2966,2967,5,186,0,0,2967,2973, + 3,294,147,0,2968,2969,5,185,0,0,2969,2973,3,294,147,0,2970,2971,5,184, + 0,0,2971,2973,3,294,147,0,2972,2906,1,0,0,0,2972,2912,1,0,0,0,2972,2917, + 1,0,0,0,2972,2919,1,0,0,0,2972,2924,1,0,0,0,2972,2930,1,0,0,0,2972,2936, + 1,0,0,0,2972,2942,1,0,0,0,2972,2948,1,0,0,0,2972,2954,1,0,0,0,2972,2960, + 1,0,0,0,2972,2962,1,0,0,0,2972,2964,1,0,0,0,2972,2966,1,0,0,0,2972,2968, + 1,0,0,0,2972,2970,1,0,0,0,2973,297,1,0,0,0,2974,2975,5,188,0,0,2975,2976, + 5,30,0,0,2976,2977,3,36,18,0,2977,2978,5,31,0,0,2978,3050,1,0,0,0,2979, + 2980,5,189,0,0,2980,2981,5,30,0,0,2981,2982,3,36,18,0,2982,2983,5,31,0, + 0,2983,3050,1,0,0,0,2984,2985,5,188,0,0,2985,2986,5,30,0,0,2986,2987,3, + 32,16,0,2987,2988,5,31,0,0,2988,3050,1,0,0,0,2989,2990,5,189,0,0,2990, + 2991,5,30,0,0,2991,2992,3,34,17,0,2992,2993,5,31,0,0,2993,3050,1,0,0,0, + 2994,2995,5,187,0,0,2995,2996,5,30,0,0,2996,2997,3,34,17,0,2997,2998,5, + 31,0,0,2998,3050,1,0,0,0,2999,3000,5,186,0,0,3000,3001,5,30,0,0,3001,3002, + 3,32,16,0,3002,3003,5,31,0,0,3003,3050,1,0,0,0,3004,3005,5,185,0,0,3005, + 3006,5,30,0,0,3006,3007,3,32,16,0,3007,3008,5,31,0,0,3008,3050,1,0,0,0, + 3009,3010,5,184,0,0,3010,3011,5,30,0,0,3011,3012,3,32,16,0,3012,3013,5, + 31,0,0,3013,3050,1,0,0,0,3014,3015,5,193,0,0,3015,3016,5,30,0,0,3016,3017, + 3,34,17,0,3017,3018,5,31,0,0,3018,3050,1,0,0,0,3019,3020,5,192,0,0,3020, + 3021,5,30,0,0,3021,3022,3,32,16,0,3022,3023,5,31,0,0,3023,3050,1,0,0,0, + 3024,3025,5,191,0,0,3025,3026,5,30,0,0,3026,3027,3,32,16,0,3027,3028,5, + 31,0,0,3028,3050,1,0,0,0,3029,3030,5,190,0,0,3030,3031,5,30,0,0,3031,3032, + 3,32,16,0,3032,3033,5,31,0,0,3033,3050,1,0,0,0,3034,3035,5,181,0,0,3035, + 3036,5,30,0,0,3036,3037,3,32,16,0,3037,3038,5,31,0,0,3038,3050,1,0,0,0, + 3039,3040,5,183,0,0,3040,3041,5,30,0,0,3041,3042,3,162,81,0,3042,3043, + 5,31,0,0,3043,3050,1,0,0,0,3044,3045,5,84,0,0,3045,3046,5,30,0,0,3046, + 3047,3,300,150,0,3047,3048,5,31,0,0,3048,3050,1,0,0,0,3049,2974,1,0,0, + 0,3049,2979,1,0,0,0,3049,2984,1,0,0,0,3049,2989,1,0,0,0,3049,2994,1,0, + 0,0,3049,2999,1,0,0,0,3049,3004,1,0,0,0,3049,3009,1,0,0,0,3049,3014,1, + 0,0,0,3049,3019,1,0,0,0,3049,3024,1,0,0,0,3049,3029,1,0,0,0,3049,3034, + 1,0,0,0,3049,3039,1,0,0,0,3049,3044,1,0,0,0,3050,299,1,0,0,0,3051,3052, + 3,302,151,0,3052,3053,6,150,-1,0,3053,3055,1,0,0,0,3054,3051,1,0,0,0,3055, + 3058,1,0,0,0,3056,3054,1,0,0,0,3056,3057,1,0,0,0,3057,301,1,0,0,0,3058, + 3056,1,0,0,0,3059,3060,7,10,0,0,3060,303,1,0,0,0,3061,3065,3,298,149,0, + 3062,3065,3,6,3,0,3063,3065,5,179,0,0,3064,3061,1,0,0,0,3064,3062,1,0, + 0,0,3064,3063,1,0,0,0,3065,305,1,0,0,0,3066,3215,3,298,149,0,3067,3068, + 5,182,0,0,3068,3069,5,30,0,0,3069,3070,5,179,0,0,3070,3215,5,31,0,0,3071, + 3072,5,182,0,0,3072,3073,5,30,0,0,3073,3074,5,264,0,0,3074,3215,5,31,0, + 0,3075,3076,5,196,0,0,3076,3077,5,30,0,0,3077,3078,5,39,0,0,3078,3079, + 5,264,0,0,3079,3215,5,31,0,0,3080,3081,5,196,0,0,3081,3082,5,30,0,0,3082, + 3083,3,116,58,0,3083,3084,5,31,0,0,3084,3215,1,0,0,0,3085,3086,5,196,0, + 0,3086,3087,5,30,0,0,3087,3088,5,179,0,0,3088,3215,5,31,0,0,3089,3090, + 5,197,0,0,3090,3091,5,30,0,0,3091,3092,3,306,153,0,3092,3093,5,31,0,0, + 3093,3215,1,0,0,0,3094,3095,5,188,0,0,3095,3096,5,42,0,0,3096,3097,3,32, + 16,0,3097,3098,5,43,0,0,3098,3099,5,30,0,0,3099,3100,3,308,154,0,3100, + 3101,5,31,0,0,3101,3215,1,0,0,0,3102,3103,5,189,0,0,3103,3104,5,42,0,0, + 3104,3105,3,32,16,0,3105,3106,5,43,0,0,3106,3107,5,30,0,0,3107,3108,3, + 310,155,0,3108,3109,5,31,0,0,3109,3215,1,0,0,0,3110,3111,5,187,0,0,3111, + 3112,5,42,0,0,3112,3113,3,32,16,0,3113,3114,5,43,0,0,3114,3115,5,30,0, + 0,3115,3116,3,312,156,0,3116,3117,5,31,0,0,3117,3215,1,0,0,0,3118,3119, + 5,186,0,0,3119,3120,5,42,0,0,3120,3121,3,32,16,0,3121,3122,5,43,0,0,3122, + 3123,5,30,0,0,3123,3124,3,314,157,0,3124,3125,5,31,0,0,3125,3215,1,0,0, + 0,3126,3127,5,185,0,0,3127,3128,5,42,0,0,3128,3129,3,32,16,0,3129,3130, + 5,43,0,0,3130,3131,5,30,0,0,3131,3132,3,316,158,0,3132,3133,5,31,0,0,3133, + 3215,1,0,0,0,3134,3135,5,184,0,0,3135,3136,5,42,0,0,3136,3137,3,32,16, + 0,3137,3138,5,43,0,0,3138,3139,5,30,0,0,3139,3140,3,318,159,0,3140,3141, + 5,31,0,0,3141,3215,1,0,0,0,3142,3143,5,193,0,0,3143,3144,5,42,0,0,3144, + 3145,3,32,16,0,3145,3146,5,43,0,0,3146,3147,5,30,0,0,3147,3148,3,312,156, + 0,3148,3149,5,31,0,0,3149,3215,1,0,0,0,3150,3151,5,192,0,0,3151,3152,5, + 42,0,0,3152,3153,3,32,16,0,3153,3154,5,43,0,0,3154,3155,5,30,0,0,3155, + 3156,3,314,157,0,3156,3157,5,31,0,0,3157,3215,1,0,0,0,3158,3159,5,191, + 0,0,3159,3160,5,42,0,0,3160,3161,3,32,16,0,3161,3162,5,43,0,0,3162,3163, + 5,30,0,0,3163,3164,3,316,158,0,3164,3165,5,31,0,0,3165,3215,1,0,0,0,3166, + 3167,5,190,0,0,3167,3168,5,42,0,0,3168,3169,3,32,16,0,3169,3170,5,43,0, + 0,3170,3171,5,30,0,0,3171,3172,3,318,159,0,3172,3173,5,31,0,0,3173,3215, + 1,0,0,0,3174,3175,5,181,0,0,3175,3176,5,42,0,0,3176,3177,3,32,16,0,3177, + 3178,5,43,0,0,3178,3179,5,30,0,0,3179,3180,3,316,158,0,3180,3181,5,31, + 0,0,3181,3215,1,0,0,0,3182,3183,5,183,0,0,3183,3184,5,42,0,0,3184,3185, + 3,32,16,0,3185,3186,5,43,0,0,3186,3187,5,30,0,0,3187,3188,3,320,160,0, + 3188,3189,5,31,0,0,3189,3215,1,0,0,0,3190,3191,5,182,0,0,3191,3192,5,42, + 0,0,3192,3193,3,32,16,0,3193,3194,5,43,0,0,3194,3195,5,30,0,0,3195,3196, + 3,322,161,0,3196,3197,5,31,0,0,3197,3215,1,0,0,0,3198,3199,5,196,0,0,3199, + 3200,5,42,0,0,3200,3201,3,32,16,0,3201,3202,5,43,0,0,3202,3203,5,30,0, + 0,3203,3204,3,324,162,0,3204,3205,5,31,0,0,3205,3215,1,0,0,0,3206,3207, + 5,197,0,0,3207,3208,5,42,0,0,3208,3209,3,32,16,0,3209,3210,5,43,0,0,3210, + 3211,5,30,0,0,3211,3212,3,328,164,0,3212,3213,5,31,0,0,3213,3215,1,0,0, + 0,3214,3066,1,0,0,0,3214,3067,1,0,0,0,3214,3071,1,0,0,0,3214,3075,1,0, + 0,0,3214,3080,1,0,0,0,3214,3085,1,0,0,0,3214,3089,1,0,0,0,3214,3094,1, + 0,0,0,3214,3102,1,0,0,0,3214,3110,1,0,0,0,3214,3118,1,0,0,0,3214,3126, + 1,0,0,0,3214,3134,1,0,0,0,3214,3142,1,0,0,0,3214,3150,1,0,0,0,3214,3158, + 1,0,0,0,3214,3166,1,0,0,0,3214,3174,1,0,0,0,3214,3182,1,0,0,0,3214,3190, + 1,0,0,0,3214,3198,1,0,0,0,3214,3206,1,0,0,0,3215,307,1,0,0,0,3216,3219, + 3,36,18,0,3217,3219,3,32,16,0,3218,3216,1,0,0,0,3218,3217,1,0,0,0,3219, + 3222,1,0,0,0,3220,3218,1,0,0,0,3220,3221,1,0,0,0,3221,309,1,0,0,0,3222, + 3220,1,0,0,0,3223,3226,3,36,18,0,3224,3226,3,34,17,0,3225,3223,1,0,0,0, + 3225,3224,1,0,0,0,3226,3229,1,0,0,0,3227,3225,1,0,0,0,3227,3228,1,0,0, + 0,3228,311,1,0,0,0,3229,3227,1,0,0,0,3230,3232,3,34,17,0,3231,3230,1,0, + 0,0,3232,3235,1,0,0,0,3233,3231,1,0,0,0,3233,3234,1,0,0,0,3234,313,1,0, + 0,0,3235,3233,1,0,0,0,3236,3238,3,32,16,0,3237,3236,1,0,0,0,3238,3241, + 1,0,0,0,3239,3237,1,0,0,0,3239,3240,1,0,0,0,3240,315,1,0,0,0,3241,3239, + 1,0,0,0,3242,3244,3,32,16,0,3243,3242,1,0,0,0,3244,3247,1,0,0,0,3245,3243, + 1,0,0,0,3245,3246,1,0,0,0,3246,317,1,0,0,0,3247,3245,1,0,0,0,3248,3250, + 3,32,16,0,3249,3248,1,0,0,0,3250,3253,1,0,0,0,3251,3249,1,0,0,0,3251,3252, + 1,0,0,0,3252,319,1,0,0,0,3253,3251,1,0,0,0,3254,3256,3,162,81,0,3255,3254, + 1,0,0,0,3256,3259,1,0,0,0,3257,3255,1,0,0,0,3257,3258,1,0,0,0,3258,321, + 1,0,0,0,3259,3257,1,0,0,0,3260,3262,7,11,0,0,3261,3260,1,0,0,0,3262,3265, + 1,0,0,0,3263,3261,1,0,0,0,3263,3264,1,0,0,0,3264,323,1,0,0,0,3265,3263, + 1,0,0,0,3266,3268,3,326,163,0,3267,3266,1,0,0,0,3268,3271,1,0,0,0,3269, + 3267,1,0,0,0,3269,3270,1,0,0,0,3270,325,1,0,0,0,3271,3269,1,0,0,0,3272, + 3277,5,179,0,0,3273,3274,5,39,0,0,3274,3277,5,264,0,0,3275,3277,3,116, + 58,0,3276,3272,1,0,0,0,3276,3273,1,0,0,0,3276,3275,1,0,0,0,3277,327,1, + 0,0,0,3278,3280,3,306,153,0,3279,3278,1,0,0,0,3280,3283,1,0,0,0,3281,3279, + 1,0,0,0,3281,3282,1,0,0,0,3282,329,1,0,0,0,3283,3281,1,0,0,0,3284,3288, + 3,44,22,0,3285,3288,3,46,23,0,3286,3288,3,2,1,0,3287,3284,1,0,0,0,3287, + 3285,1,0,0,0,3287,3286,1,0,0,0,3288,331,1,0,0,0,3289,3290,7,12,0,0,3290, + 3291,5,36,0,0,3291,3292,5,30,0,0,3292,3293,3,300,150,0,3293,3294,5,31, + 0,0,3294,3315,1,0,0,0,3295,3296,5,169,0,0,3296,3297,3,38,19,0,3297,3298, + 5,75,0,0,3298,3299,3,38,19,0,3299,3300,5,75,0,0,3300,3301,3,38,19,0,3301, + 3302,5,75,0,0,3302,3303,3,38,19,0,3303,3315,1,0,0,0,3304,3305,5,170,0, + 0,3305,3315,3,6,3,0,3306,3307,5,170,0,0,3307,3308,5,36,0,0,3308,3309,5, + 30,0,0,3309,3310,3,300,150,0,3310,3311,5,31,0,0,3311,3315,1,0,0,0,3312, + 3315,3,330,165,0,3313,3315,3,40,20,0,3314,3289,1,0,0,0,3314,3295,1,0,0, + 0,3314,3304,1,0,0,0,3314,3306,1,0,0,0,3314,3312,1,0,0,0,3314,3313,1,0, + 0,0,3315,333,1,0,0,0,3316,3317,5,25,0,0,3317,3318,5,40,0,0,3318,3319,3, + 98,49,0,3319,3320,3,2,1,0,3320,3329,1,0,0,0,3321,3322,5,25,0,0,3322,3323, + 5,40,0,0,3323,3324,3,98,49,0,3324,3325,3,2,1,0,3325,3326,5,34,0,0,3326, + 3327,3,2,1,0,3327,3329,1,0,0,0,3328,3316,1,0,0,0,3328,3321,1,0,0,0,3329, + 335,1,0,0,0,3330,3332,3,338,169,0,3331,3330,1,0,0,0,3332,3335,1,0,0,0, + 3333,3331,1,0,0,0,3333,3334,1,0,0,0,3334,337,1,0,0,0,3335,3333,1,0,0,0, + 3336,3337,5,180,0,0,3337,3338,5,36,0,0,3338,3339,5,30,0,0,3339,3340,3, + 300,150,0,3340,3341,5,31,0,0,3341,3351,1,0,0,0,3342,3351,3,332,166,0,3343, + 3344,5,171,0,0,3344,3345,5,36,0,0,3345,3346,5,30,0,0,3346,3347,3,300,150, + 0,3347,3348,5,31,0,0,3348,3351,1,0,0,0,3349,3351,5,55,0,0,3350,3336,1, + 0,0,0,3350,3342,1,0,0,0,3350,3343,1,0,0,0,3350,3349,1,0,0,0,3351,339,1, + 0,0,0,3352,3353,5,50,0,0,3353,3357,5,40,0,0,3354,3356,3,344,172,0,3355, + 3354,1,0,0,0,3356,3359,1,0,0,0,3357,3355,1,0,0,0,3357,3358,1,0,0,0,3358, + 3360,1,0,0,0,3359,3357,1,0,0,0,3360,3361,3,2,1,0,3361,341,1,0,0,0,3362, + 3366,5,301,0,0,3363,3365,3,344,172,0,3364,3363,1,0,0,0,3365,3368,1,0,0, + 0,3366,3364,1,0,0,0,3366,3367,1,0,0,0,3367,3369,1,0,0,0,3368,3366,1,0, + 0,0,3369,3370,3,2,1,0,3370,343,1,0,0,0,3371,3387,5,52,0,0,3372,3387,5, + 51,0,0,3373,3387,5,172,0,0,3374,3375,5,62,0,0,3375,3387,5,51,0,0,3376, + 3377,5,62,0,0,3377,3387,5,52,0,0,3378,3379,5,62,0,0,3379,3387,5,63,0,0, + 3380,3381,5,62,0,0,3381,3387,5,64,0,0,3382,3383,5,62,0,0,3383,3387,5,65, + 0,0,3384,3385,5,62,0,0,3385,3387,5,66,0,0,3386,3371,1,0,0,0,3386,3372, + 1,0,0,0,3386,3373,1,0,0,0,3386,3374,1,0,0,0,3386,3376,1,0,0,0,3386,3378, + 1,0,0,0,3386,3380,1,0,0,0,3386,3382,1,0,0,0,3386,3384,1,0,0,0,3387,345, + 1,0,0,0,3388,3390,3,348,174,0,3389,3388,1,0,0,0,3390,3393,1,0,0,0,3391, + 3389,1,0,0,0,3391,3392,1,0,0,0,3392,347,1,0,0,0,3393,3391,1,0,0,0,3394, + 3395,5,21,0,0,3395,3408,3,2,1,0,3396,3397,5,50,0,0,3397,3398,5,40,0,0, + 3398,3408,3,118,59,0,3399,3400,5,25,0,0,3400,3401,5,40,0,0,3401,3408,3, + 2,1,0,3402,3408,3,174,87,0,3403,3404,5,50,0,0,3404,3408,3,32,16,0,3405, + 3408,3,330,165,0,3406,3408,3,40,20,0,3407,3394,1,0,0,0,3407,3396,1,0,0, + 0,3407,3399,1,0,0,0,3407,3402,1,0,0,0,3407,3403,1,0,0,0,3407,3405,1,0, + 0,0,3407,3406,1,0,0,0,3408,349,1,0,0,0,3409,3413,5,274,0,0,3410,3412,3, + 352,176,0,3411,3410,1,0,0,0,3412,3415,1,0,0,0,3413,3411,1,0,0,0,3413,3414, + 1,0,0,0,3414,3416,1,0,0,0,3415,3413,1,0,0,0,3416,3429,3,2,1,0,3417,3421, + 5,274,0,0,3418,3420,3,352,176,0,3419,3418,1,0,0,0,3420,3423,1,0,0,0,3421, + 3419,1,0,0,0,3421,3422,1,0,0,0,3422,3424,1,0,0,0,3423,3421,1,0,0,0,3424, + 3425,3,2,1,0,3425,3426,5,34,0,0,3426,3427,3,2,1,0,3427,3429,1,0,0,0,3428, + 3409,1,0,0,0,3428,3417,1,0,0,0,3429,351,1,0,0,0,3430,3431,7,13,0,0,3431, + 353,1,0,0,0,3432,3434,3,356,178,0,3433,3432,1,0,0,0,3434,3437,1,0,0,0, + 3435,3433,1,0,0,0,3435,3436,1,0,0,0,3436,355,1,0,0,0,3437,3435,1,0,0,0, + 3438,3439,5,21,0,0,3439,3440,3,2,1,0,3440,3441,5,44,0,0,3441,3442,3,32, + 16,0,3442,3449,1,0,0,0,3443,3444,5,25,0,0,3444,3445,5,40,0,0,3445,3449, + 3,2,1,0,3446,3449,3,330,165,0,3447,3449,3,40,20,0,3448,3438,1,0,0,0,3448, + 3443,1,0,0,0,3448,3446,1,0,0,0,3448,3447,1,0,0,0,3449,357,1,0,0,0,181, 368,376,385,394,447,488,497,527,531,549,576,599,635,645,652,654,664,666, 673,684,692,713,715,731,776,781,786,791,799,909,915,931,937,943,950,978, 1056,1058,1072,1078,1087,1089,1098,1112,1126,1134,1142,1146,1185,1193, 1202,1210,1229,1239,1242,1266,1413,1423,1432,1435,1517,1526,1558,1618, 1658,1674,1684,1711,1735,1743,1747,1762,1769,1814,1824,1842,1860,1879, - 1900,1919,1934,1941,1951,1964,1969,1974,1983,1993,2079,2088,2101,2112, - 2120,2130,2132,2159,2166,2171,2178,2184,2194,2198,2205,2220,2226,2240, - 2253,2262,2273,2277,2284,2304,2309,2311,2324,2350,2357,2359,2364,2370, - 2399,2408,2431,2436,2476,2480,2490,2512,2524,2535,2550,2563,2576,2579, - 2587,2601,2619,2637,2651,2675,2687,2692,2701,2703,2710,2720,2788,2865, - 2872,2880,3030,3034,3036,3041,3043,3049,3055,3061,3067,3073,3079,3085, - 3092,3097,3103,3130,3144,3149,3166,3173,3182,3202,3207,3223,3229,3237, - 3244,3251,3264 + 1900,1919,1934,1942,1954,1974,1981,1986,1997,2009,2119,2131,2147,2161, + 2170,2183,2185,2228,2239,2246,2254,2262,2275,2281,2287,2292,2321,2329, + 2343,2348,2373,2382,2393,2397,2404,2424,2433,2435,2450,2497,2507,2509, + 2516,2522,2566,2575,2615,2620,2660,2664,2674,2696,2708,2719,2734,2747, + 2760,2763,2771,2785,2803,2821,2835,2859,2871,2876,2885,2887,2894,2904, + 2972,3049,3056,3064,3214,3218,3220,3225,3227,3233,3239,3245,3251,3257, + 3263,3269,3276,3281,3287,3314,3328,3333,3350,3357,3366,3386,3391,3407, + 3413,3421,3428,3435,3448 }; public static readonly ATN _ATN = diff --git a/src/tools/ilasm/tests/ILAssembler.Tests/EventTests.cs b/src/tools/ilasm/tests/ILAssembler.Tests/EventTests.cs index 6ea3a47b34bece..20ddd3f7a3beef 100644 --- a/src/tools/ilasm/tests/ILAssembler.Tests/EventTests.cs +++ b/src/tools/ilasm/tests/ILAssembler.Tests/EventTests.cs @@ -174,5 +174,26 @@ .event specialname rtspecialname MyDelegate Changed [0x01, 0x00, 0x00, 0x00], reader.GetBlobBytes(reader.GetCustomAttribute(Assert.Single(reader.GetCustomAttributes(eventHandle))).Value)); } + + [Fact] + public void EventWithoutType_EmitsNilEventType() + { + string source = """ + .assembly test { } + .class public auto ansi Test + { + .event Changed + { + } + } + """; + + using var pe = DocumentCompilerTestHelpers.CompileAndGetReader(source, new Options()); + var reader = pe.GetMetadataReader(); + var @event = reader.GetEventDefinition(Assert.Single(reader.EventDefinitions)); + + Assert.Equal("Changed", reader.GetString(@event.Name)); + Assert.True(@event.Type.IsNil); + } } } diff --git a/src/tools/ilasm/tests/ILAssembler.Tests/MethodTests.cs b/src/tools/ilasm/tests/ILAssembler.Tests/MethodTests.cs index 7b887213e7a268..016e8f188da778 100644 --- a/src/tools/ilasm/tests/ILAssembler.Tests/MethodTests.cs +++ b/src/tools/ilasm/tests/ILAssembler.Tests/MethodTests.cs @@ -498,6 +498,98 @@ .class public auto ansi Bar extends [mscorlib]System.Object Assert.Equal("Impl", reader.GetString(reader.GetMemberReference((MemberReferenceHandle)implementation.MethodBody).Name)); } + [Fact] + public void DeferredClassOverride_RemainsOwnedByOuterTypeAcrossNestedType() + { + string source = """ + .assembly extern mscorlib { } + .assembly extern External { } + .assembly TestOverride { } + .class public auto ansi Outer extends [mscorlib]System.Object + { + .override [External]IFoo::M with instance int32 Outer::Impl(string) + .class nested public auto ansi Inner extends [mscorlib]System.Object + { + .method public instance int32 Impl(string value) cil managed + { + ldc.i4.0 + ret + } + } + .method public instance int32 Impl(string value) cil managed + { + ldc.i4.1 + ret + } + } + """; + + using var pe = DocumentCompilerTestHelpers.CompileAndGetReader(source, new Options()); + var reader = pe.GetMetadataReader(); + var types = reader.TypeDefinitions + .ToDictionary( + handle => reader.GetString(reader.GetTypeDefinition(handle).Name), + handle => (Handle: handle, Definition: reader.GetTypeDefinition(handle))); + + var implementation = reader.GetMethodImplementation( + Assert.Single(types["Outer"].Definition.GetMethodImplementations())); + Assert.Empty(types["Inner"].Definition.GetMethodImplementations()); + Assert.Equal(HandleKind.MethodDefinition, implementation.MethodBody.Kind); + Assert.Equal( + types["Outer"].Handle, + reader.GetMethodDefinition((MethodDefinitionHandle)implementation.MethodBody).GetDeclaringType()); + } + + [Fact] + public void TruncatedNestedMethodHeader_DoesNotLeakMemberStateToFollowingDocument() + { + string malformedSource = """ + .assembly extern mscorlib { } + .assembly malformed { } + .class public auto ansi Outer extends [mscorlib]System.Object + { + .class nested public auto ansi Inner extends [mscorlib]System.Object + { + .method public static void Broken(int32 value + """; + string validSource = """ + .assembly extern mscorlib { } + .assembly valid { } + .class public auto ansi Following extends [mscorlib]System.Object + { + .method public static void Good() cil managed + { + ret + } + } + """; + + var compiler = new DocumentCompiler(); + var (malformedDiagnostics, _) = compiler.Compile( + new SourceText(malformedSource, "malformed.il"), + _ => default!, + _ => default!, + new Options { ErrorTolerant = true }); + var (validDiagnostics, result) = compiler.Compile( + new SourceText(validSource, "valid.il"), + _ => default!, + _ => default!, + new Options()); + + Assert.Contains(malformedDiagnostics, diagnostic => diagnostic.Id == "Parser"); + Assert.Empty(validDiagnostics); + Assert.NotNull(result); + var image = new BlobBuilder(); + result.Serialize(image); + using var pe = new PEReader(image.ToImmutableArray()); + var reader = pe.GetMetadataReader(); + var followingType = reader.TypeDefinitions + .Select(reader.GetTypeDefinition) + .Single(type => reader.GetString(type.Name) == "Following"); + MethodDefinitionHandle goodMethod = Assert.Single(followingType.GetMethods()); + Assert.Equal("Good", reader.GetString(reader.GetMethodDefinition(goodMethod).Name)); + } + [Fact] public void MultipleOverrides_EmitsAllMethodImpls() From 4676e7574be7215d660120bedc558e540ca6eff1 Mon Sep 17 00:00:00 2001 From: Jeremy Koritzinsky Date: Thu, 13 Aug 2026 16:18:25 -0700 Subject: [PATCH 09/16] Compile IL declarations during parsing Replace the top-level declaration, namespace-header, and class-header subtrees with direct dispatch and synthesized type headers. Preserve class attribute, generic constraint, inheritance, interface, and nested scope ordering while leaving shared directives in minimal islands. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: c986c103-8383-4db4-9b11-9be49dc68a05 --- src/tools/ilasm/README.md | 35 +- .../GrammarActions.Declarations.Actions.cs | 268 + .../Actions/GrammarActions.Declarations.cs | 225 +- .../Actions/GrammarActions.Manifest.cs | 56 +- .../Actions/GrammarActions.MethodBodies.cs | 14 - .../GrammarActions.Types.Headers.Actions.cs | 269 + .../GrammarActions.Types.Headers.Values.cs | 44 + .../Actions/GrammarActions.Types.Headers.cs | 284 + .../Actions/GrammarActions.Types.cs | 347 - .../src/ILAssembler/Actions/GrammarActions.cs | 8 + src/tools/ilasm/src/ILAssembler/gen/CIL.g4 | 258 +- .../ilasm/src/ILAssembler/gen/CIL.interp | 5 +- .../src/ILAssembler/gen/CILBaseVisitor.cs | 30 + .../ilasm/src/ILAssembler/gen/CILParser.cs | 6955 +++++++++-------- .../ilasm/src/ILAssembler/gen/CILVisitor.cs | 18 + .../DocumentCompilerTests.cs | 22 +- 16 files changed, 4808 insertions(+), 4030 deletions(-) create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.Actions.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.Actions.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.Values.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.cs diff --git a/src/tools/ilasm/README.md b/src/tools/ilasm/README.md index f6bf08130bd2dc..bc63180cb0432e 100644 --- a/src/tools/ilasm/README.md +++ b/src/tools/ilasm/README.md @@ -1,10 +1,11 @@ # ILAssembler ILAssembler compiles declarations while ANTLR parses the input. The parser uses -`UnbufferedTokenStream` with parse-tree construction disabled. Grammar actions retain bounded -subtrees only while `GrammarActions` processes a declaration or method-body item, so a complete -document or method body is never retained. Rules such as `bytes` stream their content into an -accumulator instead of building a subtree at all. +`UnbufferedTokenStream` with parse-tree construction disabled. Namespace, type, top-level, +class-member and method-body structure is action-driven, while shared directives retain bounded +subtrees for their existing visitors. A complete document, declaration body or method body is +never retained. Rules such as `bytes` stream their content into an accumulator instead of building +a subtree at all. `GrammarActions` is a single `internal sealed partial class` split across `src/ILAssembler/Actions/GrammarActions.*.cs`: @@ -18,7 +19,8 @@ accumulator instead of building a subtree at all. | `GrammarActions.CustomAttributes.cs` | Custom attribute values and serialization. | | `GrammarActions.Data.cs` | Data and blob declarations. | | `GrammarActions.Debug.cs` | Source and debug directives. | -| `GrammarActions.Declarations.cs` | Top-level `decl` dispatch and conversion. | +| `GrammarActions.Declarations.cs` | Parser-driven top-level declaration visitor guards. | +| `GrammarActions.Declarations.Actions.cs` | Direct top-level declarations and shared-directive dispatch. | | `GrammarActions.Instructions.cs` | Tree-free value instruction and method-item actions. | | `GrammarActions.Instructions.References.cs` | Reference and signature instruction actions. | | `GrammarActions.Literals.cs` | Literals, names and strings. | @@ -44,7 +46,10 @@ accumulator instead of building a subtree at all. | `GrammarActions.Signatures.References.cs` | Member-reference synthesis and materialization. | | `GrammarActions.Signatures.Types.cs` | Type-signature materialization and encoding. | | `GrammarActions.Signatures.Values.cs` | Internal synthesized signature value model. | -| `GrammarActions.Types.cs` | Namespace and type scopes and declaration conversion. | +| `GrammarActions.Types.cs` | Namespace and type scope ownership and shared type conversion. | +| `GrammarActions.Types.Headers.cs` | Namespace and type-header materialization and visitor guards. | +| `GrammarActions.Types.Headers.Actions.cs` | Namespace, type attribute, base and interface parser actions. | +| `GrammarActions.Types.Headers.Values.cs` | Internal synthesized type-header value model. | | `GrammarActions.Types.References.cs` | Type-name synthesis and resolution. | `CILParser.Actions.cs` holds the parse-tree mode helpers the grammar calls. @@ -61,12 +66,13 @@ ILAssembler entities and signature implementation values remain internal, so gen slots use `object` where an internal value or array crosses that boundary and `GrammarActions` provides the strongly typed accessors. -All type, signature, reference, marshalling, class-member, method-header, method-body directive and -exception-handling rules synthesize values without retaining structural subtrees. `scopeBlock` -records offsets under its context key without inspecting children. The remaining `BeginSubtree` -islands are `decl`, `nameSpaceHead`, `classHead`, `dataDecl`, `secDecl`, `extSourceSpec`, -`languageDecl`, `initOpt`, `customAttrDecl`, `customDescr`, `customDescrWithOwner` and -`customDescrInMethodBody`. +All namespace, type-header, top-level, type, signature, reference, marshalling, class-member, +method-header, method-body directive and exception-handling structure is action-driven. +`scopeBlock` records offsets under its context key without inspecting children. The remaining +`BeginSubtree` islands are the bounded shared roots `assemblyBlock`, `assemblyRefBlock`, +`exptypeBlock`, `manifestResBlock`, `dataDecl`, `fileDecl`, `vtableDecl`, `vtfixupDecl`, `secDecl`, +`extSourceSpec`, `languageDecl`, `typedefDecl`, `initOpt`, `customAttrDecl`, `customDescr`, +`customDescrWithOwner` and `customDescrInMethodBody`. Semantic state that a rule pushes must be released from that rule's `finally` clause and be keyed on the owning context, because ANTLR skips `@after` actions and the remainder of an alternative once a @@ -74,8 +80,9 @@ rule reports a syntax error. Inline actions placed after a subrule reference are they run only when the alternative completes. Only the parser actions walk the structural rules. The recursive `ICILVisitor` entry points for -`decls`, `classDecls`, `methodDecls`, `scopeBlock` and the SEH rules throw `UnreachableException` so -that there is exactly one live traversal algorithm. +`decl`, `decls`, `nameSpaceHead`, `classHead`, their synthesized dependency rules, `classDecls`, +`methodDecls`, `scopeBlock` and the SEH rules throw `UnreachableException` so that there is exactly +one live traversal algorithm. ## Build diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.Actions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.Actions.cs new file mode 100644 index 00000000000000..fe9c813afc0cf6 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.Actions.cs @@ -0,0 +1,268 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Immutable; +using System.Reflection; +using System.Reflection.PortableExecutable; +using Antlr4.Runtime; + +namespace ILAssembler; + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. +internal sealed partial class GrammarActions +{ + internal void BeginTopLevelDirective() => PrepareTopLevelDeclaration(); + + internal void ProcessTopLevelDataDeclaration(CILParser.DataDeclContext context) + { + if (!context.HasSyntaxError) + { + _ = VisitDataDecl(context); + } + } + + internal void ProcessTopLevelVTableDeclaration(CILParser.VtableDeclContext context) + { + if (!context.HasSyntaxError) + { + _ = VisitVtableDecl(context); + } + } + + internal void ProcessTopLevelVTableFixupDeclaration(CILParser.VtfixupDeclContext context) + { + if (!context.HasSyntaxError) + { + _ = VisitVtfixupDecl(context); + } + } + + internal void ProcessTopLevelSourceDirective(CILParser.ExtSourceSpecContext context) + { + if (!context.HasSyntaxError) + { + _ = VisitExtSourceSpec(context); + } + } + + internal void ProcessTopLevelFileDeclaration(CILParser.FileDeclContext context) + { + if (!context.HasSyntaxError) + { + _ = VisitFileDecl(context); + } + } + + internal void ProcessTopLevelAssembly(CILParser.AssemblyBlockContext context) + { + if (!context.HasSyntaxError) + { + _ = VisitAssemblyBlock(context); + } + } + + internal void ProcessTopLevelAssemblyReference(CILParser.AssemblyRefBlockContext context) + { + if (context.HasSyntaxError) + { + return; + } + + _currentAssemblyOrRef = VisitAssemblyRefHead(context.assemblyRefHead()).Value; + try + { + foreach (CILParser.AssemblyRefDeclContext declaration in + context.assemblyRefDecls().assemblyRefDecl()) + { + _ = VisitAssemblyRefDecl(declaration); + } + } + finally + { + _currentAssemblyOrRef = null; + } + } + + internal void ProcessTopLevelExportedType(CILParser.ExptypeBlockContext context) + { + if (context.HasSyntaxError) + { + return; + } + + (System.Reflection.TypeAttributes attributes, string dottedName) = + VisitExptypeHead(context.exptypeHead()).Value; + (string typeNamespace, string name) = + NameHelpers.SplitDottedNameToNamespaceAndName(dottedName); + (EntityRegistry.EntityBase? implementation, int typeDefinitionId, + ImmutableArray customAttributes) = + VisitExptypeDecls(context.exptypeDecls()).Value; + if (implementation is null) + { + ReportWarning( + DiagnosticIds.MissingExportedTypeImplementation, + string.Format( + DiagnosticMessageTemplates.MissingExportedTypeImplementation, + dottedName), + context.exptypeHead()); + return; + } + + EntityRegistry.ExportedTypeEntity exportedType = + _entityRegistry.GetOrCreateExportedType( + implementation, + typeNamespace, + name, + entity => + { + entity.Attributes = attributes; + entity.TypeDefinitionId = typeDefinitionId; + }); + foreach (EntityRegistry.CustomAttributeEntity attribute in customAttributes) + { + attribute.Owner = exportedType; + } + } + + internal void ProcessTopLevelManifestResource(CILParser.ManifestResBlockContext context) + { + if (context.HasSyntaxError) + { + return; + } + + (string name, string alias, ManifestResourceAttributes attributes) = + VisitManifestResHead(context.manifestResHead()).Value; + (EntityRegistry.EntityBase? implementation, uint offset, + ImmutableArray customAttributes) = + VisitManifestResDecls(context.manifestResDecls()).Value; + if (implementation is null) + { + offset = (uint)_manifestResources.Count; + byte[] resourceData = _resourceLocator(alias); + if (resourceData is null) + { + ReportError( + DiagnosticIds.FileNotFound, + string.Format(DiagnosticMessageTemplates.FileNotFound, alias), + context); + } + else + { + _manifestResources.WriteInt32(resourceData.Length); + _manifestResources.WriteBytes(resourceData); + } + } + + EntityRegistry.ManifestResourceEntity resource = + _entityRegistry.CreateManifestResource(name, offset); + resource.Attributes = attributes; + resource.Implementation = implementation; + foreach (EntityRegistry.CustomAttributeEntity attribute in customAttributes) + { + attribute.Owner = resource; + } + } + + internal void SetModuleHeader( + CILParser.ModuleHeadContext context, + string name, + bool isExternal) + { + context.Value = name; + context.HasName = true; + context.IsExternal = isExternal; + } + + internal void SetEmptyModuleHeader(CILParser.ModuleHeadContext context) + { + context.Value = string.Empty; + context.HasName = false; + context.IsExternal = false; + } + + internal void ProcessTopLevelModule(string? name, bool hasName, bool isExternal) + { + if (!hasName) + { + _entityRegistry.Module.Name = null; + } + else if (isExternal) + { + _entityRegistry.GetOrCreateModuleReference(name ?? string.Empty, _ => { }); + } + else + { + _entityRegistry.Module.Name = name; + } + } + + internal void ProcessTopLevelSecurityDeclaration(CILParser.SecDeclContext context) + { + if (!context.HasSyntaxError) + { + EntityRegistry.DeclarativeSecurityAttributeEntity? security = + VisitSecDecl(context).Value; + security?.Parent = _entityRegistry.Assembly; + } + } + + internal void ProcessTopLevelCustomAttribute(CILParser.CustomAttrDeclContext context) + { + if (!context.HasSyntaxError && + VisitCustomAttrDecl(context).Value is { } customAttribute) + { + customAttribute.Owner = + (EntityRegistry.EntityBase?)_lastFieldDefinition ?? _entityRegistry.Module; + } + } + + internal void ProcessTopLevelSubsystem(IToken value) + { + _subsystem = (Subsystem)ParseInt32(value); + } + + internal void ProcessTopLevelCorFlags(IToken value) + { + _corflags = (CorFlags)ParseInt32(value); + } + + internal void ProcessTopLevelAlignment(IToken value) + { + _alignment = ParseInt32(value); + } + + internal void ProcessTopLevelImageBase(IToken value) + { + _imageBase = ParseInt64(value); + } + + internal void ProcessTopLevelStackReserve(IToken value) + { + _stackReserve = ParseInt64(value); + } + + internal void ProcessTopLevelLanguageDirective(CILParser.LanguageDeclContext context) + { + if (!context.HasSyntaxError) + { + _ = VisitLanguageDecl(context); + } + } + + internal void ProcessTopLevelTypedef(CILParser.TypedefDeclContext context) + { + if (!context.HasSyntaxError) + { + _ = VisitTypedefDecl(context); + } + } + + internal void BeginTopLevelTypeList() => PrepareTopLevelDeclaration(); + + internal void ProcessTopLevelTypeListEntry(object? value) + => _ = ResolveClassName(GetClassNameValue(value)); + + private void PrepareTopLevelDeclaration() => ClearPendingCustomAttributeOwners(); +} +#pragma warning restore CA1822 diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.cs index cfdf24c12778bb..80b93c4ac99f00 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.cs @@ -1,228 +1,27 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System; -using System.Buffers.Binary; -using System.Collections.Generic; -using System.Collections.Immutable; using System.Diagnostics; -using System.Globalization; -using System.IO; -using System.Linq; -using System.Reflection; -using System.Reflection.Metadata; -using System.Reflection.Metadata.Ecma335; -using System.Reflection.PortableExecutable; -using System.Runtime.InteropServices; -using System.Security.Cryptography; -using System.Text; -using Antlr4.Runtime; -using Antlr4.Runtime.Misc; -using Antlr4.Runtime.Tree; namespace ILAssembler; internal sealed partial class GrammarActions { - internal void OnDeclaration(CILParser.DeclContext context) - { - if (context.classHead() is not null || - context.nameSpaceHead() is not null || - context.methodHead() is not null || - context.fieldDecl() is not null) - { - return; - } - - VisitDecl(context); - } - +#pragma warning disable CA1822 // Structural rules are driven by parser actions. public GrammarResult VisitDecl(CILParser.DeclContext context) - { - bool isTrailingCustomAttribute = context.customAttrDecl() is not null; - if (context.fieldDecl() is null && !isTrailingCustomAttribute) - { - _lastFieldDefinition = null; - } + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + public GrammarResult VisitDecls(CILParser.DeclsContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - if (context.nameSpaceHead() is not null || - context.classHead() is not null || - context.methodHead() is not null) - { - throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - } + public GrammarResult VisitAssemblyRefBlock(CILParser.AssemblyRefBlockContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - if (context.fieldDecl() is not null) - { - throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - } - if (context.dataDecl() is { } dataDecl) - { - _ = VisitDataDecl(dataDecl); - return GrammarResult.SentinelValue.Result; - } - if (context.vtableDecl() is { } vtable) - { - _ = VisitVtableDecl(vtable); - return GrammarResult.SentinelValue.Result; - } - if (context.vtfixupDecl() is { } vtFixup) - { - _ = VisitVtfixupDecl(vtFixup); - return GrammarResult.SentinelValue.Result; - } - if (context.extSourceSpec() is { } extSourceSpec) - { - _ = VisitExtSourceSpec(extSourceSpec); - return GrammarResult.SentinelValue.Result; - } - if (context.fileDecl() is { } fileDecl) - { - _ = VisitFileDecl(fileDecl); - return GrammarResult.SentinelValue.Result; - } - if (context.assemblyBlock() is { } assemblyBlock) - { - _ = VisitAssemblyBlock(assemblyBlock); - return GrammarResult.SentinelValue.Result; - } - if (context.assemblyRefHead() is { } assemblyRef) - { - var asmRef = VisitAssemblyRefHead(assemblyRef).Value; - _currentAssemblyOrRef = asmRef; - foreach (var decl in context.assemblyRefDecls().assemblyRefDecl()) - { - _ = VisitAssemblyRefDecl(decl); - } - _currentAssemblyOrRef = null; - } - if (context.exptypeHead() is { } exptypeHead) - { - var (attrs, dottedName) = VisitExptypeHead(exptypeHead).Value; - (string typeNamespace, string name) = NameHelpers.SplitDottedNameToNamespaceAndName(dottedName); - var (impl, typeDefId, customAttrs) = VisitExptypeDecls(context.exptypeDecls()).Value; - if (impl is null) - { - // COMPAT: Like native ilasm, warn and skip the exported type when implementation is not specified - ReportWarning(DiagnosticIds.MissingExportedTypeImplementation, - string.Format(DiagnosticMessageTemplates.MissingExportedTypeImplementation, dottedName), - exptypeHead); - return GrammarResult.SentinelValue.Result; - } - var exp = _entityRegistry.GetOrCreateExportedType(impl, typeNamespace, name, exp => - { - exp.Attributes = attrs; - exp.TypeDefinitionId = typeDefId; - }); - foreach (var attr in customAttrs) - { - attr.Owner = exp; - } - return GrammarResult.SentinelValue.Result; - } - if (context.manifestResHead() is { } manifestResHead) - { - var (name, alias, flags) = VisitManifestResHead(manifestResHead).Value; - var (implementation, offset, attrs) = VisitManifestResDecls(context.manifestResDecls()).Value; - if (implementation is null) - { - offset = (uint)_manifestResources.Count; - byte[] resourceData = _resourceLocator(alias); - if (resourceData is null) - { - ReportError(DiagnosticIds.FileNotFound, - string.Format(DiagnosticMessageTemplates.FileNotFound, alias), - context); - } - else - { - // ECMA-335: Each resource is prefixed with a 4-byte length - _manifestResources.WriteInt32(resourceData.Length); - _manifestResources.WriteBytes(resourceData); - } - } - var res = _entityRegistry.CreateManifestResource(name, offset); - res.Attributes = flags; - res.Implementation = implementation; - foreach (var attr in attrs) - { - attr.Owner = res; - } - return GrammarResult.SentinelValue.Result; - } - if (context.moduleHead() is { } moduleHead) - { - if (moduleHead.dottedName() is null) - { - _entityRegistry.Module.Name = null; - } - else if (moduleHead.ChildCount == 2) - { - _entityRegistry.Module.Name = VisitDottedName(moduleHead.dottedName()).Value; - } - else - { - var name = VisitDottedName(moduleHead.dottedName()).Value; - _entityRegistry.GetOrCreateModuleReference(name, _ => { }); - } - return GrammarResult.SentinelValue.Result; - } - if (context.subsystem() is { } subsystem) - { - _subsystem = (Subsystem)VisitSubsystem(subsystem).Value; - } - if (context.corflags() is { } corflags) - { - _corflags = (CorFlags)VisitCorflags(corflags).Value; - } - if (context.alignment() is { } alignment) - { - _alignment = VisitAlignment(alignment).Value; - } - if (context.imagebase() is { } imagebase) - { - _imageBase = VisitImagebase(imagebase).Value; - } - if (context.stackreserve() is { } stackreserve) - { - _stackReserve = VisitStackreserve(stackreserve).Value; - } - if (context.languageDecl() is { } languageDecl) - { - VisitLanguageDecl(languageDecl); - } - if (context.customAttrDecl() is { } topLevelCustomAttr) - { - if (VisitCustomAttrDecl(topLevelCustomAttr).Value is { } customAttr) - { - customAttr.Owner = (EntityRegistry.EntityBase?)_lastFieldDefinition ?? _entityRegistry.Module; - } - } - if (context.secDecl() is { } topSecDecl) - { - var declarativeSecurity = VisitSecDecl(topSecDecl).Value; - declarativeSecurity?.Parent = _entityRegistry.Assembly; - } - if (context.typedefDecl() is { } typedefDecl) - { - VisitTypedefDecl(typedefDecl); - } - if (context.typelist() is { } typelist) - { - foreach (var name in typelist.className()) - { - _ = VisitClassName(name); - } - } - if (context.mscorlib() is { } mscorlib) - { - VisitMscorlib(mscorlib); - } - return GrammarResult.SentinelValue.Result; - } + public GrammarResult VisitExptypeBlock(CILParser.ExptypeBlockContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); -#pragma warning disable CA1822 // Mark members as static - public GrammarResult VisitDecls(CILParser.DeclsContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + public GrammarResult VisitManifestResBlock(CILParser.ManifestResBlockContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); -#pragma warning restore CA1822 // Mark members as static +#pragma warning restore CA1822 } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.cs index 971007a1836309..010b11c3514c31 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.cs @@ -26,10 +26,8 @@ namespace ILAssembler internal sealed partial class GrammarActions : ICILVisitor { GrammarResult ICILVisitor.VisitAlignment(CILParser.AlignmentContext context) => VisitAlignment(context); - public GrammarResult.Literal VisitAlignment(CILParser.AlignmentContext context) - { - return VisitInt32(context.int32()); - } + public GrammarResult VisitAlignment(CILParser.AlignmentContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); GrammarResult ICILVisitor.VisitAsmAttr(CILParser.AsmAttrContext context) => VisitAsmAttr(context); public GrammarResult.Literal VisitAsmAttr(CILParser.AsmAttrContext context) @@ -175,8 +173,14 @@ public GrammarResult VisitAssemblyDecl(CILParser.AssemblyDeclContext context) else if (context.asmOrRefDecl() is { } asmOrRef) { _currentAssemblyOrRef = _entityRegistry.Assembly; - VisitAsmOrRefDecl(asmOrRef); - _currentAssemblyOrRef = null; + try + { + VisitAsmOrRefDecl(asmOrRef); + } + finally + { + _currentAssemblyOrRef = null; + } } return GrammarResult.SentinelValue.Result; } @@ -224,7 +228,8 @@ public GrammarResult VisitAssemblyRefDecl(CILParser.AssemblyRefDeclContext conte } GrammarResult ICILVisitor.VisitCorflags(CILParser.CorflagsContext context) => VisitCorflags(context); - public GrammarResult.Literal VisitCorflags(CILParser.CorflagsContext context) => VisitInt32(context.int32()); + public GrammarResult VisitCorflags(CILParser.CorflagsContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); public GrammarResult VisitExportHead(CILParser.ExportHeadContext context) => throw new NotImplementedException("Obsolete syntax"); GrammarResult ICILVisitor.VisitExptAttr(CILParser.ExptAttrContext context) => VisitExptAttr(context); @@ -406,7 +411,8 @@ public GrammarResult.Literal VisitFileEntry(CILParser.FileEntryContext con => context.ChildCount != 0 ? new(true) : new(false); GrammarResult ICILVisitor.VisitImagebase(CILParser.ImagebaseContext context) => VisitImagebase(context); - public GrammarResult.Literal VisitImagebase(CILParser.ImagebaseContext context) => VisitInt64(context.int64()); + public GrammarResult VisitImagebase(CILParser.ImagebaseContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); public GrammarResult VisitManifestResDecl(CILParser.ManifestResDeclContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); GrammarResult ICILVisitor.VisitManifestResDecls(CILParser.ManifestResDeclsContext context) => VisitManifestResDecls(context); @@ -477,30 +483,21 @@ public GrammarResult.Flag VisitManresAttr(CILParser. } public GrammarResult VisitModuleHead(CILParser.ModuleHeadContext context) - { - if (context.ChildCount > 2) - { - _ = _entityRegistry.GetOrCreateModuleReference(VisitDottedName(context.dottedName()).Value, _ => { }); - return GrammarResult.SentinelValue.Result; - } - - if (context.dottedName() is { } moduleName) - { - _entityRegistry.Module.Name = VisitDottedName(moduleName).Value; - } - return GrammarResult.SentinelValue.Result; - } + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); // .mscorlib directive indicates the assembly being compiled is mscorlib itself. // This is currently a no-op; the flag would be used to affect type resolution // when support for compiling mscorlib is added. - public GrammarResult VisitMscorlib(CILParser.MscorlibContext context) => GrammarResult.SentinelValue.Result; + public GrammarResult VisitMscorlib(CILParser.MscorlibContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); GrammarResult ICILVisitor.VisitStackreserve(CILParser.StackreserveContext context) => VisitStackreserve(context); - public GrammarResult.Literal VisitStackreserve(CILParser.StackreserveContext context) => VisitInt64(context.int64()); + public GrammarResult VisitStackreserve(CILParser.StackreserveContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); GrammarResult ICILVisitor.VisitSubsystem(CILParser.SubsystemContext context) => VisitSubsystem(context); - public GrammarResult.Literal VisitSubsystem(CILParser.SubsystemContext context) => VisitInt32(context.int32()); + public GrammarResult VisitSubsystem(CILParser.SubsystemContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); public GrammarResult VisitTypedefDecl(CILParser.TypedefDeclContext context) { @@ -610,16 +607,7 @@ public GrammarResult VisitTypedefDecl(CILParser.TypedefDeclContext context) } public GrammarResult VisitTypelist(CILParser.TypelistContext context) - { - foreach (var name in context.className()) - { - // We don't do anything with the class names here. - // We just go through the name resolution process to ensure that the names are valid - // and to provide TypeReference table rows. - _ = VisitClassName(name); - } - return GrammarResult.SentinelValue.Result; - } + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); public GrammarResult VisitVtableDecl(CILParser.VtableDeclContext context) { diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs index a6fcd294a966af..cc1baba827f03d 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs @@ -37,20 +37,6 @@ internal sealed partial class GrammarActions GrammarResult ICILVisitor.VisitHandlerBlock(CILParser.HandlerBlockContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - GrammarResult ICILVisitor.VisitImplClause(CILParser.ImplClauseContext context) => VisitImplClause(context); - public GrammarResult.Sequence VisitImplClause(CILParser.ImplClauseContext context) => context.implList() is {} implList ? VisitImplList(implList) : new(ImmutableArray.Empty); - - GrammarResult ICILVisitor.VisitImplList(CILParser.ImplListContext context) => VisitImplList(context); - public GrammarResult.Sequence VisitImplList(CILParser.ImplListContext context) - { - var builder = ImmutableArray.CreateBuilder(); - foreach (var impl in context.typeSpec()) - { - builder.Add(EntityRegistry.CreateUnrecordedInterfaceImplementation(_currentTypeDefinition.PeekOrDefault()!, VisitTypeSpec(impl).Value)); - } - return new(builder.ToImmutable()); - } - private void ValidateLabelReferences() { if (_currentMethod is null) diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.Actions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.Actions.cs new file mode 100644 index 00000000000000..1d9685f036c2f0 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.Actions.cs @@ -0,0 +1,269 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Reflection; +using Antlr4.Runtime; + +namespace ILAssembler; + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. +internal sealed partial class GrammarActions +{ + private readonly Stack _namespaceHeaderFrames = new(); + private readonly Stack _classHeaderFrames = new(); + private readonly Stack _interfaceListFrames = new(); + + private sealed record NamespaceHeaderFrame( + CILParser.NameSpaceHeadContext Owner, + int InitialSyntaxErrorCount); + + private sealed class ClassHeaderFrame + { + public ClassHeaderFrame(CILParser.ClassHeadContext owner, int initialSyntaxErrorCount) + { + Owner = owner; + InitialSyntaxErrorCount = initialSyntaxErrorCount; + } + + public CILParser.ClassHeadContext Owner { get; } + + public int InitialSyntaxErrorCount { get; } + + public ImmutableArray.Builder Attributes { get; } = + ImmutableArray.CreateBuilder(); + } + + private sealed class InterfaceListFrame + { + public InterfaceListFrame(CILParser.ImplListContext owner) + { + Owner = owner; + } + + public CILParser.ImplListContext Owner { get; } + + public ImmutableArray.Builder Interfaces { get; } = + ImmutableArray.CreateBuilder(); + } + + internal void BeginNamespaceHeader(CILParser.NameSpaceHeadContext context) + { + ClearPendingCustomAttributeOwners(); + _namespaceHeaderFrames.Push(new(context, _syntaxErrorCount)); + } + + internal void EndNamespaceHeader(CILParser.NameSpaceHeadContext context) + { + if (_namespaceHeaderFrames.Count == 0) + { + return; + } + + NamespaceHeaderFrame frame = _namespaceHeaderFrames.Peek(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + if (ReferenceEquals(frame.Owner, context)) + { + _namespaceHeaderFrames.Pop(); + } + } + + internal void BeginClassHeader(CILParser.ClassHeadContext context) + { + ClearPendingCustomAttributeOwners(); + _classHeaderFrames.Push(new(context, _syntaxErrorCount)); + } + + internal void AddClassHeaderAttribute(CILParser.ClassHeadContext context, object? value) + { + if (TryGetClassHeaderFrame(context) is { } frame) + { + frame.Attributes.Add(GetClassAttributeValue(value)); + } + } + + internal object CreateClassHeader( + CILParser.ClassHeadContext context, + IToken nameToken, + string fullName, + object? genericParameters, + object? baseType, + object? interfaces) + { + ClassHeaderFrame? frame = TryGetClassHeaderFrame(context); + if (frame is null || + frame.InitialSyntaxErrorCount != _syntaxErrorCount || + context.exception is not null) + { + return ClassHeaderValue.Error; + } + + return new ClassHeaderValue( + true, + nameToken, + fullName, + frame.Attributes.ToImmutable(), + GetGenericParameterDeclarations(genericParameters), + baseType as TypeSpecificationValue, + GetInterfaceTypes(interfaces)); + } + + internal void EndClassHeader(CILParser.ClassHeadContext context) + { + if (_classHeaderFrames.Count == 0) + { + return; + } + + ClassHeaderFrame frame = _classHeaderFrames.Peek(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + if (ReferenceEquals(frame.Owner, context)) + { + _classHeaderFrames.Pop(); + } + } + + internal object CreateClassAttribute(IToken token) + { + return token.Text switch + { + "public" => CreateClassAttribute( + TypeAttributes.Public, + TypeAttributes.VisibilityMask), + "private" => CreateClassAttribute( + TypeAttributes.NotPublic, + TypeAttributes.VisibilityMask), + "value" => CreateClassAttribute( + TypeAttributes.Sealed, + fallbackBase: EntityRegistry.WellKnownBaseType.System_ValueType, + requireSealed: true), + "enum" => CreateClassAttribute( + 0, + fallbackBase: EntityRegistry.WellKnownBaseType.System_Enum), + "interface" => CreateClassAttribute(TypeAttributes.Interface | TypeAttributes.Abstract), + "sealed" => CreateClassAttribute(TypeAttributes.Sealed), + "abstract" => CreateClassAttribute(TypeAttributes.Abstract), + "auto" => CreateClassAttribute(TypeAttributes.AutoLayout, TypeAttributes.LayoutMask), + "sequential" => CreateClassAttribute( + TypeAttributes.SequentialLayout, + TypeAttributes.LayoutMask), + "explicit" => CreateClassAttribute(TypeAttributes.ExplicitLayout), + "extended" => CreateClassAttribute(TypeAttributes.ExtendedLayout, TypeAttributes.LayoutMask), + "ansi" => CreateClassAttribute(TypeAttributes.AnsiClass, TypeAttributes.StringFormatMask), + "unicode" => CreateClassAttribute( + TypeAttributes.UnicodeClass, + TypeAttributes.StringFormatMask), + "autochar" => CreateClassAttribute( + TypeAttributes.AutoClass, + TypeAttributes.StringFormatMask), + "import" => CreateClassAttribute(TypeAttributes.Import), +#pragma warning disable SYSLIB0050 + "serializable" => CreateClassAttribute(TypeAttributes.Serializable), +#pragma warning restore SYSLIB0050 + "windowsruntime" => CreateClassAttribute(TypeAttributes.WindowsRuntime), + "beforefieldinit" => CreateClassAttribute(TypeAttributes.BeforeFieldInit), + "specialname" => CreateClassAttribute(TypeAttributes.SpecialName), + "rtspecialname" => CreateClassAttribute(TypeAttributes.RTSpecialName), + _ => throw new UnreachableException(), + }; + } + + internal object CreateNestedClassAttribute(IToken visibility) + { + TypeAttributes attribute = visibility.Text switch + { + "public" => TypeAttributes.NestedPublic, + "private" => TypeAttributes.NestedPrivate, + "family" => TypeAttributes.NestedFamily, + "assembly" => TypeAttributes.NestedAssembly, + "famandassem" => TypeAttributes.NestedFamANDAssem, + "famorassem" => TypeAttributes.NestedFamORAssem, + _ => throw new UnreachableException(), + }; + return CreateClassAttribute(attribute, TypeAttributes.VisibilityMask); + } + + internal object CreateRawClassAttribute(IToken token) + { + int value = ParseInt32(token); + bool requireSealed = false; + EntityRegistry.WellKnownBaseType? fallbackBase = null; + if ((value & 0x80000000) != 0) + { + requireSealed = true; + fallbackBase = EntityRegistry.WellKnownBaseType.System_ValueType; + } + if ((value & 0x40000000) != 0) + { + fallbackBase = EntityRegistry.WellKnownBaseType.System_Enum; + } + + value &= unchecked((int)~0xC0000000); + return new ClassAttributeValue( + new((TypeAttributes)value, 0, false), + fallbackBase, + requireSealed); + } + + internal object? CreateEmptyClassBase() => null; + + internal object CreateClassBase(object? value) => GetTypeSpecificationValue(value); + + internal object CreateEmptyInterfaceList() => ImmutableArray.Empty; + + internal void BeginInterfaceList(CILParser.ImplListContext context) + => _interfaceListFrames.Push(new(context)); + + internal void AddInterfaceType(CILParser.ImplListContext context, object? value) + { + if (TryGetInterfaceListFrame(context) is { } frame) + { + frame.Interfaces.Add(GetTypeSpecificationValue(value)); + } + } + + internal object EndInterfaceList(CILParser.ImplListContext context) + { + if (_interfaceListFrames.Count == 0) + { + return ImmutableArray.Empty; + } + + InterfaceListFrame frame = _interfaceListFrames.Peek(); + Debug.Assert(ReferenceEquals(frame.Owner, context)); + if (!ReferenceEquals(frame.Owner, context)) + { + return ImmutableArray.Empty; + } + + _interfaceListFrames.Pop(); + return frame.Interfaces.ToImmutable(); + } + + private static ClassAttributeValue CreateClassAttribute( + TypeAttributes value, + TypeAttributes groupMask = 0, + EntityRegistry.WellKnownBaseType? fallbackBase = null, + bool requireSealed = false) + => new(new(value, groupMask, true), fallbackBase, requireSealed); + + private ClassHeaderFrame? TryGetClassHeaderFrame(CILParser.ClassHeadContext context) + { + Debug.Assert(_classHeaderFrames.Count > 0); + ClassHeaderFrame? frame = _classHeaderFrames.Count == 0 ? null : _classHeaderFrames.Peek(); + Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); + return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; + } + + private InterfaceListFrame? TryGetInterfaceListFrame(CILParser.ImplListContext context) + { + Debug.Assert(_interfaceListFrames.Count > 0); + InterfaceListFrame? frame = + _interfaceListFrames.Count == 0 ? null : _interfaceListFrames.Peek(); + Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); + return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; + } +} +#pragma warning restore CA1822 diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.Values.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.Values.cs new file mode 100644 index 00000000000000..35d18c2ac75ee6 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.Values.cs @@ -0,0 +1,44 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Immutable; +using System.Reflection; +using Antlr4.Runtime; + +namespace ILAssembler; + +internal sealed partial class GrammarActions +{ + private sealed record ClassAttributeValue( + AttributeValue Attribute, + EntityRegistry.WellKnownBaseType? FallbackBase, + bool RequireSealed); + + private sealed record ClassHeaderValue( + bool IsValid, + IToken? NameToken, + string FullName, + ImmutableArray Attributes, + ImmutableArray GenericParameters, + TypeSpecificationValue? BaseType, + ImmutableArray Interfaces) + { + public static ClassHeaderValue Error { get; } = new( + false, + null, + string.Empty, + [], + [], + null, + []); + } + + private static ClassAttributeValue GetClassAttributeValue(object? value) + => value as ClassAttributeValue ?? new(new(0, 0, true), null, false); + + private static ClassHeaderValue GetClassHeaderValue(object? value) + => value as ClassHeaderValue ?? ClassHeaderValue.Error; + + private static ImmutableArray GetInterfaceTypes(object? value) + => value is ImmutableArray interfaces ? interfaces : []; +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.cs new file mode 100644 index 00000000000000..82e303645956a4 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.cs @@ -0,0 +1,284 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Immutable; +using System.Diagnostics; +using System.Reflection; +using Antlr4.Runtime; + +namespace ILAssembler; + +internal sealed partial class GrammarActions +{ + internal void BeginNamespace(CILParser.NameSpaceHeadContext context, string? namespaceName) + { + if (_namespaceHeaderFrames.Count == 0 || + !ReferenceEquals(_namespaceHeaderFrames.Peek().Owner, context) || + _namespaceHeaderFrames.Peek().InitialSyntaxErrorCount != _syntaxErrorCount || + context.exception is not null || + namespaceName is null) + { + return; + } + + string? outerNamespace = _currentNamespace.PeekOrDefault(); + _currentNamespace.Push( + string.IsNullOrEmpty(outerNamespace) + ? namespaceName + : $"{outerNamespace}.{namespaceName}"); + _namespaceOwners.Push(context.Parent); + } + + internal void BeginType(CILParser.ClassHeadContext context, object? value) + { + ClassHeaderValue header = GetClassHeaderValue(value); + if (!header.IsValid) + { + return; + } + + EntityRegistry.TypeDefinitionEntity typeDefinition = MaterializeClassHeader(context, header); + _currentTypeDefinition.Push(typeDefinition); + _typeOwners.Push(context.Parent); + } + + private EntityRegistry.TypeDefinitionEntity MaterializeClassHeader( + CILParser.ClassHeadContext context, + ClassHeaderValue header) + { + (string typeNamespace, string typeName) = GetTypeDefinitionName(header.FullName); + bool isNewType = false; + EntityRegistry.TypeDefinitionEntity typeDefinition = + _entityRegistry.GetOrCreateTypeDefinition( + _currentTypeDefinition.PeekOrDefault(), + typeNamespace, + typeName, + newTypeDefinition => + { + isNewType = true; + InitializeTypeDefinition(context, header, newTypeDefinition); + }); + + if (!isNewType) + { + MergeTypeDefinition(header, typeDefinition); + } + + return typeDefinition; + } + + private (string Namespace, string Name) GetTypeDefinitionName(string fullName) + { + int lastDot = fullName.LastIndexOf('.'); + if (lastDot == 0) + { + lastDot = -1; + } + + string typeNamespace; + if (_currentTypeDefinition.Count != 0) + { + typeNamespace = lastDot == -1 ? string.Empty : fullName.Substring(0, lastDot); + } + else if (lastDot == -1) + { + typeNamespace = _currentNamespace.PeekOrDefault() ?? string.Empty; + } + else + { + typeNamespace = + $"{_currentNamespace.PeekOrDefault()}{fullName.Substring(0, lastDot)}"; + } + + return ( + typeNamespace, + lastDot == -1 ? fullName : fullName.Substring(lastDot + 1)); + } + + private void InitializeTypeDefinition( + CILParser.ClassHeadContext context, + ClassHeaderValue header, + EntityRegistry.TypeDefinitionEntity typeDefinition) + { + EntityRegistry.WellKnownBaseType? fallbackBase = + _options.NoAutoInherit ? null : EntityRegistry.WellKnownBaseType.System_Object; + bool requireSealed = false; + TypeAttributes attributes = 0; + foreach (ClassAttributeValue classAttribute in header.Attributes) + { + if (classAttribute.FallbackBase is not null) + { + fallbackBase = classAttribute.FallbackBase; + } + + AttributeValue attribute = classAttribute.Attribute; + if (!attribute.ShouldAppend) + { + attributes = attribute.Value; + requireSealed = classAttribute.RequireSealed; + continue; + } + + requireSealed |= classAttribute.RequireSealed; + if (attribute.Value == TypeAttributes.RTSpecialName) + { + continue; + } + + attributes = ApplyAttribute(attributes, attribute); + } + + typeDefinition.Attributes = attributes; + RegisterGenericParameterNames( + typeDefinition, + typeDefinition.GenericParameters, + header.GenericParameters); + + _currentTypeDefinition.Push(typeDefinition); + try + { + MaterializeGenericParameterConstraints( + typeDefinition.GenericParameters, + typeDefinition.GenericParameterConstraints, + header.GenericParameters); + if (header.BaseType is not null) + { + typeDefinition.BaseType = ResolveTypeSpecification(header.BaseType); + } + + AddInterfaceImplementations(typeDefinition, header.Interfaces); + } + finally + { + _currentTypeDefinition.Pop(); + } + + if (typeDefinition.Attributes.HasFlag(TypeAttributes.Interface)) + { + fallbackBase = null; + } + + typeDefinition.BaseType ??= _entityRegistry.ResolveImplicitBaseType(fallbackBase); + if (!typeDefinition.Attributes.HasFlag(TypeAttributes.Sealed) && + (requireSealed || _entityRegistry.SystemValueTypeType.Equals(typeDefinition.BaseType))) + { + IToken location = header.NameToken ?? context.Start; + _diagnostics.Add( + new Diagnostic( + DiagnosticIds.UnsealedValueType, + DiagnosticSeverity.Error, + string.Format(DiagnosticMessageTemplates.UnsealedValueType, typeDefinition.Name), + Location.From(location, _documents))); + typeDefinition.Attributes |= TypeAttributes.Sealed; + } + } + + private void MergeTypeDefinition( + ClassHeaderValue header, + EntityRegistry.TypeDefinitionEntity typeDefinition) + { + TypeAttributes attributes = typeDefinition.Attributes; + foreach (ClassAttributeValue classAttribute in header.Attributes) + { + AttributeValue attribute = classAttribute.Attribute; + if (!attribute.ShouldAppend) + { + attributes = attribute.Value; + } + else if ((attribute.Value & TypeAttributes.Interface) != 0) + { + attributes |= TypeAttributes.Interface | TypeAttributes.Abstract; + } + else + { + attributes |= attribute.Value; + } + } + typeDefinition.Attributes = attributes; + + bool materializeConstraints = typeDefinition.GenericParameters.Count == 0; + if (materializeConstraints) + { + RegisterGenericParameterNames( + typeDefinition, + typeDefinition.GenericParameters, + header.GenericParameters); + } + + _currentTypeDefinition.Push(typeDefinition); + try + { + if (materializeConstraints) + { + MaterializeGenericParameterConstraints( + typeDefinition.GenericParameters, + typeDefinition.GenericParameterConstraints, + header.GenericParameters); + } + + if (header.BaseType is not null) + { + EntityRegistry.TypeEntity baseType = ResolveTypeSpecification(header.BaseType); + typeDefinition.BaseType ??= baseType; + } + + AddInterfaceImplementations(typeDefinition, header.Interfaces); + } + finally + { + _currentTypeDefinition.Pop(); + } + } + + private void AddInterfaceImplementations( + EntityRegistry.TypeDefinitionEntity typeDefinition, + ImmutableArray interfaces) + { + foreach (TypeSpecificationValue interfaceType in interfaces) + { + typeDefinition.InterfaceImplementations.Add( + EntityRegistry.CreateUnrecordedInterfaceImplementation( + typeDefinition, + ResolveTypeSpecification(interfaceType))); + } + } + +#pragma warning disable CA1822 // Structural rules are driven by parser actions. + GrammarResult ICILVisitor.VisitClassAttr(CILParser.ClassAttrContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + public GrammarResult VisitClassAttr(CILParser.ClassAttrContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitClassHead(CILParser.ClassHeadContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + public GrammarResult VisitClassHead(CILParser.ClassHeadContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitExtendsClause(CILParser.ExtendsClauseContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + public GrammarResult VisitExtendsClause(CILParser.ExtendsClauseContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitImplClause(CILParser.ImplClauseContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + public GrammarResult VisitImplClause(CILParser.ImplClauseContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitImplList(CILParser.ImplListContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + public GrammarResult VisitImplList(CILParser.ImplListContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitNameSpaceHead( + CILParser.NameSpaceHeadContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + public GrammarResult VisitNameSpaceHead(CILParser.NameSpaceHeadContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); +#pragma warning restore CA1822 +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs index 5951fa3c5ef5e4..cbe38e20787201 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs @@ -1,24 +1,10 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System; -using System.Buffers.Binary; using System.Collections.Generic; -using System.Collections.Immutable; using System.Diagnostics; -using System.Globalization; -using System.IO; -using System.Linq; -using System.Reflection; using System.Reflection.Metadata; -using System.Reflection.Metadata.Ecma335; -using System.Reflection.PortableExecutable; -using System.Runtime.InteropServices; -using System.Security.Cryptography; -using System.Text; using Antlr4.Runtime; -using Antlr4.Runtime.Misc; -using Antlr4.Runtime.Tree; namespace ILAssembler; @@ -27,22 +13,6 @@ internal sealed partial class GrammarActions private readonly Stack _namespaceOwners = new(); private readonly Stack _typeOwners = new(); - internal void BeginNamespace(CILParser.NameSpaceHeadContext context) - { - ClearPendingCustomAttributeOwners(); - string namespaceName = VisitNameSpaceHead(context).Value; - string? outerNamespace = _currentNamespace.PeekOrDefault(); - _currentNamespace.Push(string.IsNullOrEmpty(outerNamespace) ? namespaceName : $"{outerNamespace}.{namespaceName}"); - _namespaceOwners.Push(context.Parent); - } - - internal void BeginType(CILParser.ClassHeadContext context) - { - ClearPendingCustomAttributeOwners(); - _currentTypeDefinition.Push(VisitClassHead(context).Value); - _typeOwners.Push(context.Parent); - } - /// /// Releases the namespace, type and method state that a top-level declaration introduced. /// @@ -53,12 +23,6 @@ internal void BeginType(CILParser.ClassHeadContext context) internal void EndDeclaration(CILParser.DeclContext context) { EndScopesOwnedBy(context); - if (context.nameSpaceHead() is not null || - context.classHead() is not null || - context.methodHead() is not null) - { - ClearPendingCustomAttributeOwners(); - } } /// @@ -127,301 +91,8 @@ private void ClearPendingCustomAttributeOwners() } #pragma warning disable CA1822 // Mark members as static - GrammarResult ICILVisitor.VisitClassAttr(CILParser.ClassAttrContext context) => VisitClassAttr(context); - - public GrammarResult.Literal<(GrammarResult.Flag Attribute, EntityRegistry.WellKnownBaseType? FallbackBase, bool RequireSealed)> VisitClassAttr(CILParser.ClassAttrContext context) - { - if (context.int32() is CILParser.Int32Context int32) - { - int value = VisitInt32(int32).Value; - // COMPAT: The VALUE and ENUM keywords use sentinel values to pass through the fallback base type - // in ILASM. These sentinel values can be provided through the "pass the value of the flag" feature, - // so we detect those old flags here and provide the correct fallback type. - bool requireSealed = false; - EntityRegistry.WellKnownBaseType? fallbackBase = null; - if ((value & 0x80000000) != 0) - { - requireSealed = true; - fallbackBase = EntityRegistry.WellKnownBaseType.System_ValueType; - } - if ((value & 0x40000000) != 0) - { - fallbackBase = EntityRegistry.WellKnownBaseType.System_Enum; - } - // Mask off the sentinel bits - value &= unchecked((int)~0xC0000000); - // COMPAT: When explicit flags are provided they always supercede previously set flags - // (other than the sentinel values) - return new((new((TypeAttributes)value, ShouldAppend: false), fallbackBase, requireSealed)); - } - - if (context.ENUM() is not null) - { - // COMPAT: ilasm implies the Sealed flag when using the 'value' keyword in a type declaration - // even when the 'enum' keyword is used. - return new((new(context.VALUE() is not null ? TypeAttributes.Sealed : 0), EntityRegistry.WellKnownBaseType.System_Enum, false)); - } - else if (context.VALUE() is not null) - { - // COMPAT: ilasm implies the Sealed flag when using the 'value' keyword in a type declaration - return new((new(TypeAttributes.Sealed), EntityRegistry.WellKnownBaseType.System_ValueType, true)); - } - else if (context.EXPLICIT() is not null) - { - return new((new(TypeAttributes.ExplicitLayout), null, false)); - } - else if (context.INTERFACE() is not null) - { - // COMPAT: interface implies abstract - return new((new(TypeAttributes.Interface | TypeAttributes.Abstract), null, false)); - } - - switch (context.GetText()) - { - case "public": - return new((new(TypeAttributes.Public, TypeAttributes.VisibilityMask), null, false)); - case "private": - return new((new(TypeAttributes.NotPublic, TypeAttributes.VisibilityMask), null, false)); - case "nestedpublic": - return new((new(TypeAttributes.NestedPublic, TypeAttributes.VisibilityMask), null, false)); - case "nestedprivate": - return new((new(TypeAttributes.NestedPrivate, TypeAttributes.VisibilityMask), null, false)); - case "nestedfamily": - return new((new(TypeAttributes.NestedFamily, TypeAttributes.VisibilityMask), null, false)); - case "nestedassembly": - return new((new(TypeAttributes.NestedAssembly, TypeAttributes.VisibilityMask), null, false)); - case "nestedfamandassem": - return new((new(TypeAttributes.NestedFamANDAssem, TypeAttributes.VisibilityMask), null, false)); - case "nestedfamorassem": - return new((new(TypeAttributes.NestedFamORAssem, TypeAttributes.VisibilityMask), null, false)); - case "ansi": - return new((new(TypeAttributes.AnsiClass, TypeAttributes.StringFormatMask), null, false)); - case "autochar": - return new((new(TypeAttributes.AutoClass, TypeAttributes.StringFormatMask), null, false)); - case "unicode": - return new((new(TypeAttributes.UnicodeClass, TypeAttributes.StringFormatMask), null, false)); - case "auto": - return new((new(TypeAttributes.AutoLayout, TypeAttributes.LayoutMask), null, false)); - case "sequential": - return new((new(TypeAttributes.SequentialLayout, TypeAttributes.LayoutMask), null, false)); - case "extended": - return new((new(TypeAttributes.ExtendedLayout, TypeAttributes.LayoutMask), null, false)); - case "sealed": - return new((new(TypeAttributes.Sealed), null, false)); - case "abstract": - return new((new(TypeAttributes.Abstract), null, false)); - case "import": - return new((new(TypeAttributes.Import), null, false)); - case "serializable": -#pragma warning disable SYSLIB0050 - return new((new(TypeAttributes.Serializable), null, false)); -#pragma warning restore SYSLIB0050 - case "windowsruntime": - return new((new(TypeAttributes.WindowsRuntime), null, false)); - case "beforefieldinit": - return new((new(TypeAttributes.BeforeFieldInit), null, false)); - case "specialname": - return new((new(TypeAttributes.SpecialName), null, false)); - case "rtspecialname": - return new((new(TypeAttributes.RTSpecialName), null, false)); - default: - return new((new((TypeAttributes)Enum.Parse(typeof(TypeAttributes), context.GetText(), true)), null, false)); - } - } - public GrammarResult VisitClassDecls(CILParser.ClassDeclsContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitClassHead(CILParser.ClassHeadContext context) => VisitClassHead(context); - public GrammarResult.Literal VisitClassHead(CILParser.ClassHeadContext context) - { - string typeFullName = VisitDottedName(context.dottedName()).Value; - int typeFullNameLastDot = typeFullName.LastIndexOf('.'); - // A dot at position 0 is part of the name (e.g., ".GlobalStruct"), not a namespace separator - if (typeFullNameLastDot == 0) - { - typeFullNameLastDot = -1; - } - string typeNS; - if (_currentTypeDefinition.Count != 0) - { - if (typeFullNameLastDot == -1) - { - typeNS = string.Empty; - } - else - { - typeNS = typeFullName.Substring(0, typeFullNameLastDot); - } - } - else - { - if (typeFullNameLastDot == -1) - { - typeNS = _currentNamespace.PeekOrDefault() ?? string.Empty; - } - else - { - typeNS = $"{_currentNamespace.PeekOrDefault()}{typeFullName.Substring(0, typeFullNameLastDot)}"; - } - } - - bool isNewType = false; - - var typeDefinition = _entityRegistry.GetOrCreateTypeDefinition( - _currentTypeDefinition.PeekOrDefault(), - typeNS, - typeFullNameLastDot != -1 - ? typeFullName.Substring(typeFullNameLastDot + 1) - : typeFullName, - (newTypeDef) => - { - isNewType = true; - EntityRegistry.WellKnownBaseType? fallbackBase = _options.NoAutoInherit ? null : EntityRegistry.WellKnownBaseType.System_Object; - bool requireSealed = false; - var classAttrs = context.classAttr(); - newTypeDef.Attributes = classAttrs.Select(VisitClassAttr).Aggregate( - (TypeAttributes)0, - (acc, result) => - { - var (attribute, implicitBase, attrRequireSealed) = result.Value; - if (implicitBase is not null) - { - fallbackBase = implicitBase; - } - if (!attribute.ShouldAppend) - { - requireSealed = attrRequireSealed; - return attribute.Value; - } - requireSealed |= attrRequireSealed; - if (attribute.Value == TypeAttributes.RTSpecialName) - { - // COMPAT: ILASM ignores the rtspecialname directive on a type. - return acc; - } - if ((attribute.Value & TypeAttributes.Interface) != 0) - { - // COMPAT: interface implies abstract - return acc | TypeAttributes.Interface | TypeAttributes.Abstract; - } - // Use the Flag's | operator which handles group masks - // (visibility, layout, string format) correctly. - return acc | attribute; - }); - - - ImmutableArray genericParameters = - GetGenericParameterDeclarations(context.typarsClause().Value); - RegisterGenericParameterNames( - newTypeDef, - newTypeDef.GenericParameters, - genericParameters); - - // Push the type so that !T references in constraints, extends, and implements can resolve - _currentTypeDefinition.Push(newTypeDef); - - MaterializeGenericParameterConstraints( - newTypeDef.GenericParameters, - newTypeDef.GenericParameterConstraints, - genericParameters); - - if (context.extendsClause() is CILParser.ExtendsClauseContext extends) - { - newTypeDef.BaseType = VisitExtendsClause(context.extendsClause()).Value; - } - - if (context.implClause() is CILParser.ImplClauseContext impl) - { - newTypeDef.InterfaceImplementations.AddRange(VisitImplClause(context.implClause()).Value); - } - - _currentTypeDefinition.Pop(); - - // Interfaces should not have an implicit base type - if (newTypeDef.Attributes.HasFlag(TypeAttributes.Interface)) - { - fallbackBase = null; - } - - newTypeDef.BaseType ??= _entityRegistry.ResolveImplicitBaseType(fallbackBase); - - // When the user has provided a type definition for a type that directly inherits - // System.ValueType but has not sealed it, emit a warning and add the 'sealed' modifier. - if (!newTypeDef.Attributes.HasFlag(TypeAttributes.Sealed) && - (requireSealed // COMPAT: when both the sentinel values for 'value' and 'enum' are explicitly - // specified, the sealed modifier is required even though - // the base type isn't System.ValueType. - || _entityRegistry.SystemValueTypeType.Equals(newTypeDef.BaseType))) - { - _diagnostics.Add( - new Diagnostic( - DiagnosticIds.UnsealedValueType, - DiagnosticSeverity.Error, - string.Format(DiagnosticMessageTemplates.UnsealedValueType, newTypeDef.Name), - Location.From(context.dottedName().Stop, _documents))); - newTypeDef.Attributes |= TypeAttributes.Sealed; - } - }); - - if (!isNewType) - { - // Type was forward-referenced. Apply attributes, generic params, - // base type, and interface implementations that were deferred. - var classAttrs = context.classAttr(); - typeDefinition.Attributes = classAttrs.Select(VisitClassAttr).Aggregate( - typeDefinition.Attributes, - (acc, result) => - { - var (attribute, _, _) = result.Value; - if (!attribute.ShouldAppend) - return attribute.Value; - if ((attribute.Value & TypeAttributes.Interface) != 0) - return acc | TypeAttributes.Interface | TypeAttributes.Abstract; - return acc | attribute.Value; - }); - - if (typeDefinition.GenericParameters.Count == 0) - { - ImmutableArray genericParameters = - GetGenericParameterDeclarations(context.typarsClause().Value); - RegisterGenericParameterNames( - typeDefinition, - typeDefinition.GenericParameters, - genericParameters); - - _currentTypeDefinition.Push(typeDefinition); - - MaterializeGenericParameterConstraints( - typeDefinition.GenericParameters, - typeDefinition.GenericParameterConstraints, - genericParameters); - } - else - { - _currentTypeDefinition.Push(typeDefinition); - } - - if (context.extendsClause() is CILParser.ExtendsClauseContext extends && typeDefinition.BaseType is null) - { - typeDefinition.BaseType = VisitExtendsClause(extends).Value; - } - else - { - _ = context.extendsClause()?.Accept(this); - } - - if (context.implClause() is CILParser.ImplClauseContext impl) - { - typeDefinition.InterfaceImplementations.AddRange(VisitImplClause(impl).Value); - } - - _currentTypeDefinition.Pop(); - } - - return new(typeDefinition); - } - GrammarResult ICILVisitor.VisitClassName(CILParser.ClassNameContext context) => VisitClassName(context); public GrammarResult.Literal VisitClassName(CILParser.ClassNameContext context) @@ -462,23 +133,5 @@ public GrammarResult.FormattedBlob VisitClassSeqElement(CILParser.ClassSeqElemen : null); return new(blob); } - GrammarResult ICILVisitor.VisitExtendsClause(CILParser.ExtendsClauseContext context) => VisitExtendsClause(context); - - public GrammarResult.Literal VisitExtendsClause(CILParser.ExtendsClauseContext context) - { - if (context.typeSpec() is CILParser.TypeSpecContext typeSpec) - { - return new(VisitTypeSpec(typeSpec).Value); - } - else - { - return new(null); - } - } - - GrammarResult ICILVisitor.VisitNameSpaceHead(CILParser.NameSpaceHeadContext context) => VisitNameSpaceHead(context); - - public static GrammarResult.String VisitNameSpaceHead(CILParser.NameSpaceHeadContext context) => VisitDottedName(context.dottedName()); - #pragma warning restore CA1822 // Mark members as static } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs index de91c1d9eec55c..e4a45ba3338b8f 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs @@ -20,6 +20,7 @@ internal void BeginDocument() { Debug.Assert( _currentMethod is null + && _currentAssemblyOrRef is null && _typeOwners.Count == 0 && _namespaceOwners.Count == 0 && _scopeStack.Count == 0 @@ -49,10 +50,14 @@ _currentMethod is null && _propertyBodyFrames.Count == 0 && _eventBodyFrames.Count == 0 && _classGenericDirectiveFrames.Count == 0 + && _namespaceHeaderFrames.Count == 0 + && _classHeaderFrames.Count == 0 + && _interfaceListFrames.Count == 0 && _pendingClassMethodOverrides.Count == 0, "Per-document semantic state must be released by the owning rule's finally block."); EndMethod(); + _currentAssemblyOrRef = null; ResetTypeScopes(); ClearPendingCustomAttributeOwners(); _semanticRootFrames.Clear(); @@ -77,6 +82,9 @@ _currentMethod is null _propertyBodyFrames.Clear(); _eventBodyFrames.Clear(); _classGenericDirectiveFrames.Clear(); + _namespaceHeaderFrames.Clear(); + _classHeaderFrames.Clear(); + _interfaceListFrames.Clear(); _pendingClassMethodOverrides.Clear(); _syntaxErrorCount = 0; } diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 index 6367949684dbb3..d8989ec00b5413 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 @@ -450,49 +450,71 @@ decls finally {EndParseTreeMode();} decl -@init {BeginSubtree();} -@after {Actions.OnDeclaration(_localctx);} +@init {BeginStreaming();} : classHead '{' classDecls '}' | nameSpaceHead '{' decls '}' | methodHead '{' methodDecls '}' | fieldDecl - | dataDecl - | vtableDecl - | vtfixupDecl - | extSourceSpec - | fileDecl - | assemblyBlock - | assemblyRefHead '{' assemblyRefDecls '}' - | exptypeHead '{' exptypeDecls '}' - | manifestResHead '{' manifestResDecls '}' - | moduleHead - | secDecl - | customAttrDecl - | subsystem - | corflags - | alignment - | imagebase - | stackreserve - | languageDecl - | typedefDecl - | compControl + | {Actions.BeginTopLevelDirective();} + data = dataDecl {Actions.ProcessTopLevelDataDeclaration($data.ctx);} + | {Actions.BeginTopLevelDirective();} + vtable = vtableDecl {Actions.ProcessTopLevelVTableDeclaration($vtable.ctx);} + | {Actions.BeginTopLevelDirective();} + vtfixup = vtfixupDecl {Actions.ProcessTopLevelVTableFixupDeclaration($vtfixup.ctx);} + | {Actions.BeginTopLevelDirective();} + source = extSourceSpec {Actions.ProcessTopLevelSourceDirective($source.ctx);} + | {Actions.BeginTopLevelDirective();} + file = fileDecl {Actions.ProcessTopLevelFileDeclaration($file.ctx);} + | {Actions.BeginTopLevelDirective();} + assembly = assemblyBlock {Actions.ProcessTopLevelAssembly($assembly.ctx);} + | {Actions.BeginTopLevelDirective();} + assemblyReference = assemblyRefBlock + {Actions.ProcessTopLevelAssemblyReference($assemblyReference.ctx);} + | {Actions.BeginTopLevelDirective();} + exportedType = exptypeBlock {Actions.ProcessTopLevelExportedType($exportedType.ctx);} + | {Actions.BeginTopLevelDirective();} + resource = manifestResBlock {Actions.ProcessTopLevelManifestResource($resource.ctx);} + | {Actions.BeginTopLevelDirective();} + module = moduleHead + {Actions.ProcessTopLevelModule($module.Value, $module.HasName, $module.IsExternal);} + | {Actions.BeginTopLevelDirective();} + security = secDecl {Actions.ProcessTopLevelSecurityDeclaration($security.ctx);} + | attribute = customAttrDecl {Actions.ProcessTopLevelCustomAttribute($attribute.ctx);} + | {Actions.BeginTopLevelDirective();} subsystem + | {Actions.BeginTopLevelDirective();} corflags + | {Actions.BeginTopLevelDirective();} alignment + | {Actions.BeginTopLevelDirective();} imagebase + | {Actions.BeginTopLevelDirective();} stackreserve + | {Actions.BeginTopLevelDirective();} + language = languageDecl {Actions.ProcessTopLevelLanguageDirective($language.ctx);} + | {Actions.BeginTopLevelDirective();} + typedef = typedefDecl {Actions.ProcessTopLevelTypedef($typedef.ctx);} + | {Actions.BeginTopLevelDirective();} compControl | typelist - | mscorlib; + | {Actions.BeginTopLevelDirective();} mscorlib; finally {EndParseTreeMode(); Actions.EndDeclaration(_localctx);} -subsystem: '.subsystem' int32; +subsystem: + '.subsystem' value = int32 {Actions.ProcessTopLevelSubsystem($value.start);}; -corflags: '.corflags' int32; +corflags: + '.corflags' value = int32 {Actions.ProcessTopLevelCorFlags($value.start);}; -alignment: '.file' 'alignment' int32; +alignment: + '.file' 'alignment' value = int32 {Actions.ProcessTopLevelAlignment($value.start);}; -imagebase: '.imagebase' int64; +imagebase: + '.imagebase' value = int64 {Actions.ProcessTopLevelImageBase($value.start);}; -stackreserve: '.stackreserve' int64; +stackreserve: + '.stackreserve' value = int64 {Actions.ProcessTopLevelStackReserve($value.start);}; -assemblyBlock: +assemblyBlock returns [bool HasSyntaxError] +@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +: '.assembly' asmAttr dottedName '{' assemblyDecls '}'; +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} mscorlib: '.mscorlib'; @@ -506,7 +528,13 @@ finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParse languageString: SQSTRING | QSTRING; -typelist: '.typelist' '{' (className)* '}'; +typelist +@init {Actions.BeginTopLevelTypeList();} +: + '.typelist' '{' + (name = className {Actions.ProcessTopLevelTypeListEntry($name.Value);})* + '}' +; int32: INT32; int64: INT64 | INT32; @@ -534,12 +562,15 @@ compControl: /* Aliasing of types, type specs, methods, fields and custom attributes */ -typedefDecl: +typedefDecl returns [bool HasSyntaxError] +@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +: '.typedef' type 'as' dottedName | '.typedef' className 'as' dottedName | '.typedef' memberRef 'as' dottedName | '.typedef' customDescr 'as' dottedName | '.typedef' customDescrWithOwner 'as' dottedName; +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} /* Custom attribute declarations */ customDescr returns [bool HasSyntaxError] @@ -594,13 +625,21 @@ serializTypeElement: | ENUM className; /* Module declaration */ -moduleHead: - MODULE 'extern' dottedName - | MODULE dottedName - | MODULE; +moduleHead returns [string Value, bool HasName, bool IsExternal]: + MODULE 'extern' name = dottedName + {Actions.SetModuleHeader(_localctx, $name.Value, true);} + | MODULE name = dottedName + {Actions.SetModuleHeader(_localctx, $name.Value, false);} + | MODULE + {Actions.SetEmptyModuleHeader(_localctx);}; /* VTable Fixup table declaration */ -vtfixupDecl: '.vtfixup' '[' int32 ']' vtfixupAttr 'at' id; +vtfixupDecl returns [bool HasSyntaxError] +@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +: + '.vtfixup' '[' int32 ']' vtfixupAttr 'at' id +; +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} vtfixupAttr: /* EMPTY */ @@ -610,57 +649,82 @@ vtfixupAttr: | vtfixupAttr 'callmostderived' | vtfixupAttr 'retainappdomain'; -vtableDecl: '.vtable' '=' '(' bytes ')' /* deprecated */; +vtableDecl returns [bool HasSyntaxError] +@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +: + '.vtable' '=' '(' bytes ')' /* deprecated */ +; +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} /* Namespace and class declaration */ -nameSpaceHead -@init {BeginSubtree();} -@after {Actions.BeginNamespace(_localctx);} +nameSpaceHead returns [string Value] +@init {BeginStreaming(); Actions.BeginNamespaceHeader(_localctx);} +@after {Actions.BeginNamespace(_localctx, _localctx.Value);} : - '.namespace' dottedName + '.namespace' name = dottedName {_localctx.Value = $name.Value;} ; -finally {EndParseTreeMode();} +finally {Actions.EndNamespaceHeader(_localctx); EndParseTreeMode();} -classHead -@init {BeginSubtree();} -@after {Actions.BeginType(_localctx);} +classHead returns [object Value] +@init {BeginStreaming(); Actions.BeginClassHeader(_localctx);} +@after {Actions.BeginType(_localctx, _localctx.Value);} : - '.class' classAttr* dottedName typarsClause extendsClause implClause; -finally {EndParseTreeMode();} - - -classAttr: - 'public' - | 'private' - | VALUE - | ENUM - | INTERFACE - | 'sealed' - | 'abstract' - | 'auto' - | 'sequential' - | EXPLICIT - | 'extended' - | ANSI - | 'unicode' - | 'autochar' - | 'import' - | 'serializable' - | 'windowsruntime' - | 'nested' 'public' - | 'nested' 'private' - | 'nested' 'family' - | 'nested' 'assembly' - | 'nested' 'famandassem' - | 'nested' 'famorassem' - | 'beforefieldinit' - | 'specialname' - | 'rtspecialname' - | 'flags' '(' int32 ')'; - -extendsClause: /* EMPTY */ | 'extends' typeSpec; + '.class' + (attribute = classAttr {Actions.AddClassHeaderAttribute(_localctx, $attribute.Value);})* + name = dottedName genericParameters = typarsClause baseType = extendsClause interfaces = implClause + {_localctx.Value = Actions.CreateClassHeader( + _localctx, + $name.stop, + $name.Value, + $genericParameters.Value, + $baseType.Value, + $interfaces.Value);} +; +finally {Actions.EndClassHeader(_localctx); EndParseTreeMode();} + + +classAttr returns [object Value]: + attribute = 'public' {_localctx.Value = Actions.CreateClassAttribute($attribute);} + | attribute = 'private' {_localctx.Value = Actions.CreateClassAttribute($attribute);} + | attribute = VALUE {_localctx.Value = Actions.CreateClassAttribute($attribute);} + | attribute = ENUM {_localctx.Value = Actions.CreateClassAttribute($attribute);} + | attribute = INTERFACE {_localctx.Value = Actions.CreateClassAttribute($attribute);} + | attribute = 'sealed' {_localctx.Value = Actions.CreateClassAttribute($attribute);} + | attribute = 'abstract' {_localctx.Value = Actions.CreateClassAttribute($attribute);} + | attribute = 'auto' {_localctx.Value = Actions.CreateClassAttribute($attribute);} + | attribute = 'sequential' {_localctx.Value = Actions.CreateClassAttribute($attribute);} + | attribute = EXPLICIT {_localctx.Value = Actions.CreateClassAttribute($attribute);} + | attribute = 'extended' {_localctx.Value = Actions.CreateClassAttribute($attribute);} + | attribute = ANSI {_localctx.Value = Actions.CreateClassAttribute($attribute);} + | attribute = 'unicode' {_localctx.Value = Actions.CreateClassAttribute($attribute);} + | attribute = 'autochar' {_localctx.Value = Actions.CreateClassAttribute($attribute);} + | attribute = 'import' {_localctx.Value = Actions.CreateClassAttribute($attribute);} + | attribute = 'serializable' {_localctx.Value = Actions.CreateClassAttribute($attribute);} + | attribute = 'windowsruntime' {_localctx.Value = Actions.CreateClassAttribute($attribute);} + | 'nested' visibility = 'public' {_localctx.Value = Actions.CreateNestedClassAttribute($visibility);} + | 'nested' visibility = 'private' {_localctx.Value = Actions.CreateNestedClassAttribute($visibility);} + | 'nested' visibility = 'family' {_localctx.Value = Actions.CreateNestedClassAttribute($visibility);} + | 'nested' visibility = 'assembly' {_localctx.Value = Actions.CreateNestedClassAttribute($visibility);} + | 'nested' visibility = 'famandassem' {_localctx.Value = Actions.CreateNestedClassAttribute($visibility);} + | 'nested' visibility = 'famorassem' {_localctx.Value = Actions.CreateNestedClassAttribute($visibility);} + | attribute = 'beforefieldinit' {_localctx.Value = Actions.CreateClassAttribute($attribute);} + | attribute = 'specialname' {_localctx.Value = Actions.CreateClassAttribute($attribute);} + | attribute = 'rtspecialname' {_localctx.Value = Actions.CreateClassAttribute($attribute);} + | 'flags' '(' flags = int32 ')' {_localctx.Value = Actions.CreateRawClassAttribute($flags.start);}; + +extendsClause returns [object Value] +@init {_localctx.Value = Actions.CreateEmptyClassBase();} +: + /* EMPTY */ + | 'extends' baseType = typeSpec {_localctx.Value = Actions.CreateClassBase($baseType.Value);} +; -implClause: /* EMPTY */ | 'implements' implList; +implClause returns [object Value] +@init {_localctx.Value = Actions.CreateEmptyInterfaceList();} +: + /* EMPTY */ + | 'implements' interfaces = implList {_localctx.Value = $interfaces.Value;} +; classDecls @init {BeginStreaming();} @@ -669,7 +733,13 @@ classDecls ; finally {EndParseTreeMode();} -implList: (typeSpec ',')* typeSpec; +implList returns [object Value] +@init {Actions.BeginInterfaceList(_localctx);} +: + (interfaceType = typeSpec {Actions.AddInterfaceType(_localctx, $interfaceType.Value);} ',')* + lastInterfaceType = typeSpec {Actions.AddInterfaceType(_localctx, $lastInterfaceType.Value);} +; +finally {_localctx.Value = Actions.EndInterfaceList(_localctx);} /* External source declarations */ esHead: '.line' | '#line'; @@ -695,9 +765,12 @@ extSourceSpec returns [bool HasSyntaxError] finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} /* Manifest declarations */ -fileDecl: +fileDecl returns [bool HasSyntaxError] +@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +: '.file' fileAttr* dottedName fileEntry HASH '=' '(' bytes ')' fileEntry | '.file' fileAttr* dottedName fileEntry; +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} fileAttr: 'nometadata'; @@ -1817,6 +1890,13 @@ asmOrRefDecl: | customAttrDecl | compControl; +assemblyRefBlock returns [bool HasSyntaxError] +@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +: + assemblyRefHead '{' assemblyRefDecls '}' +; +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} + assemblyRefHead: '.assembly' 'extern' asmAttr dottedName | '.assembly' 'extern' asmAttr dottedName 'as' dottedName; @@ -1829,6 +1909,13 @@ assemblyRefDecl: | '.publickeytoken' '=' '(' bytes ')' | 'auto'; +exptypeBlock returns [bool HasSyntaxError] +@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +: + exptypeHead '{' exptypeDecls '}' +; +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} + exptypeHead: '.class' 'extern' exptAttr* dottedName; exportHead: '.export' exptAttr* dottedName; @@ -1855,6 +1942,13 @@ exptypeDecl: | customAttrDecl | compControl; +manifestResBlock returns [bool HasSyntaxError] +@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +: + manifestResHead '{' manifestResDecls '}' +; +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} + manifestResHead: MRESOURCE manresAttr* dottedName | MRESOURCE manresAttr* dottedName 'as' dottedName; diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.interp b/src/tools/ilasm/src/ILAssembler/gen/CIL.interp index 4929987f5e3fb1..bf523e40c36a7e 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.interp +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.interp @@ -782,14 +782,17 @@ classSeqElement objSeq customAttrDecl asmOrRefDecl +assemblyRefBlock assemblyRefHead assemblyRefDecls assemblyRefDecl +exptypeBlock exptypeHead exportHead exptAttr exptypeDecls exptypeDecl +manifestResBlock manifestResHead manresAttr manifestResDecls @@ -797,4 +800,4 @@ manifestResDecl atn: -[4, 1, 305, 3451, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 367, 8, 1, 10, 1, 12, 1, 370, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 377, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 5, 3, 384, 8, 3, 10, 3, 12, 3, 387, 9, 3, 1, 3, 1, 3, 1, 3, 1, 4, 5, 4, 393, 8, 4, 10, 4, 12, 4, 396, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 448, 8, 5, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 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, 489, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 5, 15, 496, 8, 15, 10, 15, 12, 15, 499, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 528, 8, 18, 1, 19, 1, 19, 3, 19, 532, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 550, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 577, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 600, 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, 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, 636, 8, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 646, 8, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 5, 27, 653, 8, 27, 10, 27, 12, 27, 656, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 665, 8, 28, 10, 28, 12, 28, 668, 9, 28, 1, 29, 1, 29, 1, 30, 1, 30, 3, 30, 674, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 685, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 693, 8, 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, 34, 1, 34, 1, 34, 1, 34, 5, 34, 714, 8, 34, 10, 34, 12, 34, 717, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 5, 37, 730, 8, 37, 10, 37, 12, 37, 733, 9, 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, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 777, 8, 38, 1, 39, 1, 39, 1, 39, 3, 39, 782, 8, 39, 1, 40, 1, 40, 1, 40, 3, 40, 787, 8, 40, 1, 41, 5, 41, 790, 8, 41, 10, 41, 12, 41, 793, 9, 41, 1, 42, 1, 42, 1, 42, 5, 42, 798, 8, 42, 10, 42, 12, 42, 801, 9, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 910, 8, 44, 1, 45, 1, 45, 5, 45, 914, 8, 45, 10, 45, 12, 45, 917, 9, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 930, 8, 45, 10, 45, 12, 45, 933, 9, 45, 1, 45, 1, 45, 1, 45, 3, 45, 938, 8, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 944, 8, 47, 1, 48, 1, 48, 1, 49, 5, 49, 949, 8, 49, 10, 49, 12, 49, 952, 9, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 979, 8, 50, 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, 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, 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, 1057, 8, 51, 3, 51, 1059, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1073, 8, 53, 1, 53, 1, 53, 5, 53, 1077, 8, 53, 10, 53, 12, 53, 1080, 9, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1088, 8, 53, 3, 53, 1090, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1097, 8, 54, 10, 54, 12, 54, 1100, 9, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1111, 8, 55, 10, 55, 12, 55, 1114, 9, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 5, 56, 1125, 8, 56, 10, 56, 12, 56, 1128, 9, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1135, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 1143, 8, 57, 1, 57, 1, 57, 3, 57, 1147, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1186, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 1192, 8, 59, 10, 59, 12, 59, 1195, 9, 59, 1, 59, 1, 59, 1, 59, 1, 60, 5, 60, 1201, 8, 60, 10, 60, 12, 60, 1204, 9, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1211, 8, 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, 3, 62, 1230, 8, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 5, 63, 1238, 8, 63, 10, 63, 12, 63, 1241, 9, 63, 3, 63, 1243, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 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, 1267, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1414, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1424, 8, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 5, 67, 1431, 8, 67, 10, 67, 12, 67, 1434, 9, 67, 3, 67, 1436, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1518, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 5, 69, 1525, 8, 69, 10, 69, 12, 69, 1528, 9, 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, 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, 1559, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1619, 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, 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, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1659, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1675, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1685, 8, 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, 3, 76, 1712, 8, 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, 1736, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 5, 77, 1742, 8, 77, 10, 77, 12, 77, 1745, 9, 77, 1, 77, 3, 77, 1748, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1763, 8, 78, 1, 79, 1, 79, 1, 79, 5, 79, 1768, 8, 79, 10, 79, 12, 79, 1771, 9, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1815, 8, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1825, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1843, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1861, 8, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1880, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1901, 8, 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, 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 1920, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1935, 8, 89, 1, 90, 1, 90, 1, 90, 1, 90, 5, 90, 1941, 8, 90, 10, 90, 12, 90, 1944, 9, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 1955, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 1975, 8, 92, 1, 93, 1, 93, 1, 93, 5, 93, 1980, 8, 93, 10, 93, 12, 93, 1983, 9, 93, 1, 94, 1, 94, 3, 94, 1987, 8, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 5, 95, 1996, 8, 95, 10, 95, 12, 95, 1999, 9, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 3, 97, 2010, 8, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2118, 8, 99, 10, 99, 12, 99, 2121, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2130, 8, 99, 10, 99, 12, 99, 2133, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2146, 8, 99, 10, 99, 12, 99, 2149, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2160, 8, 99, 10, 99, 12, 99, 2163, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 2171, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 2184, 8, 100, 10, 100, 12, 100, 2187, 9, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 2229, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 2240, 8, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 3, 103, 2247, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 2255, 8, 104, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2261, 8, 105, 10, 105, 12, 105, 2264, 9, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2274, 8, 105, 10, 105, 12, 105, 2277, 9, 105, 1, 105, 1, 105, 1, 105, 3, 105, 2282, 8, 105, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 2288, 8, 106, 1, 107, 5, 107, 2291, 8, 107, 10, 107, 12, 107, 2294, 9, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 2322, 8, 108, 1, 109, 1, 109, 1, 109, 1, 109, 5, 109, 2328, 8, 109, 10, 109, 12, 109, 2331, 9, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 2344, 8, 110, 1, 111, 5, 111, 2347, 8, 111, 10, 111, 12, 111, 2350, 9, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 2374, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 2383, 8, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 4, 114, 2392, 8, 114, 11, 114, 12, 114, 2393, 1, 114, 1, 114, 3, 114, 2398, 8, 114, 1, 115, 1, 115, 1, 115, 5, 115, 2403, 8, 115, 10, 115, 12, 115, 2406, 9, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 2425, 8, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2434, 8, 117, 10, 117, 12, 117, 2437, 9, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2449, 8, 117, 10, 117, 12, 117, 2452, 9, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2498, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2508, 8, 119, 3, 119, 2510, 8, 119, 1, 119, 1, 119, 1, 119, 5, 119, 2515, 8, 119, 10, 119, 12, 119, 2518, 9, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2523, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2567, 8, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 2576, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2616, 8, 122, 1, 123, 5, 123, 2619, 8, 123, 10, 123, 12, 123, 2622, 9, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2661, 8, 124, 1, 125, 1, 125, 3, 125, 2665, 8, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, 2675, 8, 126, 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, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 2697, 8, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2707, 8, 129, 10, 129, 12, 129, 2710, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2718, 8, 129, 10, 129, 12, 129, 2721, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2733, 8, 129, 10, 129, 12, 129, 2736, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2746, 8, 129, 10, 129, 12, 129, 2749, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2759, 8, 129, 10, 129, 12, 129, 2762, 9, 129, 3, 129, 2764, 8, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 3, 131, 2772, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 4, 134, 2784, 8, 134, 11, 134, 12, 134, 2785, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 3, 135, 2804, 8, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 3, 136, 2822, 8, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 2836, 8, 137, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 2860, 8, 141, 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 2872, 8, 143, 1, 144, 1, 144, 1, 144, 3, 144, 2877, 8, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 4, 145, 2884, 8, 145, 11, 145, 12, 145, 2885, 3, 145, 2888, 8, 145, 1, 146, 1, 146, 1, 146, 5, 146, 2893, 8, 146, 10, 146, 12, 146, 2896, 9, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 2905, 8, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 3, 148, 2973, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 3050, 8, 149, 1, 150, 1, 150, 1, 150, 5, 150, 3055, 8, 150, 10, 150, 12, 150, 3058, 9, 150, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 3, 152, 3065, 8, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 3, 153, 3215, 8, 153, 1, 154, 1, 154, 5, 154, 3219, 8, 154, 10, 154, 12, 154, 3222, 9, 154, 1, 155, 1, 155, 5, 155, 3226, 8, 155, 10, 155, 12, 155, 3229, 9, 155, 1, 156, 5, 156, 3232, 8, 156, 10, 156, 12, 156, 3235, 9, 156, 1, 157, 5, 157, 3238, 8, 157, 10, 157, 12, 157, 3241, 9, 157, 1, 158, 5, 158, 3244, 8, 158, 10, 158, 12, 158, 3247, 9, 158, 1, 159, 5, 159, 3250, 8, 159, 10, 159, 12, 159, 3253, 9, 159, 1, 160, 5, 160, 3256, 8, 160, 10, 160, 12, 160, 3259, 9, 160, 1, 161, 5, 161, 3262, 8, 161, 10, 161, 12, 161, 3265, 9, 161, 1, 162, 5, 162, 3268, 8, 162, 10, 162, 12, 162, 3271, 9, 162, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 3277, 8, 163, 1, 164, 5, 164, 3280, 8, 164, 10, 164, 12, 164, 3283, 9, 164, 1, 165, 1, 165, 1, 165, 3, 165, 3288, 8, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 3, 166, 3315, 8, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 3, 167, 3329, 8, 167, 1, 168, 5, 168, 3332, 8, 168, 10, 168, 12, 168, 3335, 9, 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, 169, 3, 169, 3351, 8, 169, 1, 170, 1, 170, 1, 170, 5, 170, 3356, 8, 170, 10, 170, 12, 170, 3359, 9, 170, 1, 170, 1, 170, 1, 171, 1, 171, 5, 171, 3365, 8, 171, 10, 171, 12, 171, 3368, 9, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, 172, 3387, 8, 172, 1, 173, 5, 173, 3390, 8, 173, 10, 173, 12, 173, 3393, 9, 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, 3, 174, 3408, 8, 174, 1, 175, 1, 175, 5, 175, 3412, 8, 175, 10, 175, 12, 175, 3415, 9, 175, 1, 175, 1, 175, 1, 175, 5, 175, 3420, 8, 175, 10, 175, 12, 175, 3423, 9, 175, 1, 175, 1, 175, 1, 175, 1, 175, 3, 175, 3429, 8, 175, 1, 176, 1, 176, 1, 177, 5, 177, 3434, 8, 177, 10, 177, 12, 177, 3437, 9, 177, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 3, 178, 3449, 8, 178, 1, 178, 0, 1, 68, 179, 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, 0, 14, 6, 0, 1, 15, 199, 199, 243, 243, 247, 247, 264, 264, 289, 289, 5, 0, 16, 16, 199, 199, 243, 243, 264, 264, 288, 289, 1, 0, 263, 264, 1, 0, 173, 174, 1, 0, 37, 38, 1, 0, 73, 74, 3, 0, 2, 2, 61, 61, 77, 83, 2, 0, 229, 229, 260, 261, 1, 0, 95, 96, 1, 0, 97, 111, 2, 0, 173, 173, 289, 290, 2, 0, 179, 179, 264, 264, 1, 0, 167, 168, 1, 0, 51, 52, 3915, 0, 358, 1, 0, 0, 0, 2, 376, 1, 0, 0, 0, 4, 378, 1, 0, 0, 0, 6, 385, 1, 0, 0, 0, 8, 394, 1, 0, 0, 0, 10, 447, 1, 0, 0, 0, 12, 449, 1, 0, 0, 0, 14, 452, 1, 0, 0, 0, 16, 455, 1, 0, 0, 0, 18, 459, 1, 0, 0, 0, 20, 462, 1, 0, 0, 0, 22, 465, 1, 0, 0, 0, 24, 472, 1, 0, 0, 0, 26, 488, 1, 0, 0, 0, 28, 490, 1, 0, 0, 0, 30, 492, 1, 0, 0, 0, 32, 502, 1, 0, 0, 0, 34, 504, 1, 0, 0, 0, 36, 527, 1, 0, 0, 0, 38, 531, 1, 0, 0, 0, 40, 549, 1, 0, 0, 0, 42, 576, 1, 0, 0, 0, 44, 599, 1, 0, 0, 0, 46, 635, 1, 0, 0, 0, 48, 637, 1, 0, 0, 0, 50, 645, 1, 0, 0, 0, 52, 647, 1, 0, 0, 0, 54, 654, 1, 0, 0, 0, 56, 666, 1, 0, 0, 0, 58, 669, 1, 0, 0, 0, 60, 671, 1, 0, 0, 0, 62, 684, 1, 0, 0, 0, 64, 692, 1, 0, 0, 0, 66, 694, 1, 0, 0, 0, 68, 702, 1, 0, 0, 0, 70, 718, 1, 0, 0, 0, 72, 724, 1, 0, 0, 0, 74, 727, 1, 0, 0, 0, 76, 776, 1, 0, 0, 0, 78, 781, 1, 0, 0, 0, 80, 786, 1, 0, 0, 0, 82, 791, 1, 0, 0, 0, 84, 799, 1, 0, 0, 0, 86, 804, 1, 0, 0, 0, 88, 909, 1, 0, 0, 0, 90, 937, 1, 0, 0, 0, 92, 939, 1, 0, 0, 0, 94, 943, 1, 0, 0, 0, 96, 945, 1, 0, 0, 0, 98, 950, 1, 0, 0, 0, 100, 978, 1, 0, 0, 0, 102, 1058, 1, 0, 0, 0, 104, 1060, 1, 0, 0, 0, 106, 1089, 1, 0, 0, 0, 108, 1091, 1, 0, 0, 0, 110, 1105, 1, 0, 0, 0, 112, 1134, 1, 0, 0, 0, 114, 1146, 1, 0, 0, 0, 116, 1185, 1, 0, 0, 0, 118, 1193, 1, 0, 0, 0, 120, 1202, 1, 0, 0, 0, 122, 1210, 1, 0, 0, 0, 124, 1229, 1, 0, 0, 0, 126, 1242, 1, 0, 0, 0, 128, 1266, 1, 0, 0, 0, 130, 1413, 1, 0, 0, 0, 132, 1423, 1, 0, 0, 0, 134, 1435, 1, 0, 0, 0, 136, 1517, 1, 0, 0, 0, 138, 1519, 1, 0, 0, 0, 140, 1558, 1, 0, 0, 0, 142, 1618, 1, 0, 0, 0, 144, 1658, 1, 0, 0, 0, 146, 1674, 1, 0, 0, 0, 148, 1676, 1, 0, 0, 0, 150, 1680, 1, 0, 0, 0, 152, 1735, 1, 0, 0, 0, 154, 1747, 1, 0, 0, 0, 156, 1762, 1, 0, 0, 0, 158, 1769, 1, 0, 0, 0, 160, 1774, 1, 0, 0, 0, 162, 1778, 1, 0, 0, 0, 164, 1814, 1, 0, 0, 0, 166, 1816, 1, 0, 0, 0, 168, 1860, 1, 0, 0, 0, 170, 1879, 1, 0, 0, 0, 172, 1900, 1, 0, 0, 0, 174, 1902, 1, 0, 0, 0, 176, 1919, 1, 0, 0, 0, 178, 1934, 1, 0, 0, 0, 180, 1942, 1, 0, 0, 0, 182, 1954, 1, 0, 0, 0, 184, 1974, 1, 0, 0, 0, 186, 1981, 1, 0, 0, 0, 188, 1984, 1, 0, 0, 0, 190, 1997, 1, 0, 0, 0, 192, 2003, 1, 0, 0, 0, 194, 2009, 1, 0, 0, 0, 196, 2013, 1, 0, 0, 0, 198, 2170, 1, 0, 0, 0, 200, 2172, 1, 0, 0, 0, 202, 2228, 1, 0, 0, 0, 204, 2239, 1, 0, 0, 0, 206, 2246, 1, 0, 0, 0, 208, 2254, 1, 0, 0, 0, 210, 2281, 1, 0, 0, 0, 212, 2287, 1, 0, 0, 0, 214, 2292, 1, 0, 0, 0, 216, 2321, 1, 0, 0, 0, 218, 2323, 1, 0, 0, 0, 220, 2343, 1, 0, 0, 0, 222, 2348, 1, 0, 0, 0, 224, 2373, 1, 0, 0, 0, 226, 2382, 1, 0, 0, 0, 228, 2397, 1, 0, 0, 0, 230, 2404, 1, 0, 0, 0, 232, 2424, 1, 0, 0, 0, 234, 2426, 1, 0, 0, 0, 236, 2497, 1, 0, 0, 0, 238, 2522, 1, 0, 0, 0, 240, 2566, 1, 0, 0, 0, 242, 2575, 1, 0, 0, 0, 244, 2615, 1, 0, 0, 0, 246, 2620, 1, 0, 0, 0, 248, 2660, 1, 0, 0, 0, 250, 2662, 1, 0, 0, 0, 252, 2668, 1, 0, 0, 0, 254, 2676, 1, 0, 0, 0, 256, 2696, 1, 0, 0, 0, 258, 2763, 1, 0, 0, 0, 260, 2765, 1, 0, 0, 0, 262, 2771, 1, 0, 0, 0, 264, 2773, 1, 0, 0, 0, 266, 2777, 1, 0, 0, 0, 268, 2783, 1, 0, 0, 0, 270, 2803, 1, 0, 0, 0, 272, 2821, 1, 0, 0, 0, 274, 2835, 1, 0, 0, 0, 276, 2837, 1, 0, 0, 0, 278, 2840, 1, 0, 0, 0, 280, 2842, 1, 0, 0, 0, 282, 2859, 1, 0, 0, 0, 284, 2861, 1, 0, 0, 0, 286, 2871, 1, 0, 0, 0, 288, 2876, 1, 0, 0, 0, 290, 2887, 1, 0, 0, 0, 292, 2894, 1, 0, 0, 0, 294, 2904, 1, 0, 0, 0, 296, 2972, 1, 0, 0, 0, 298, 3049, 1, 0, 0, 0, 300, 3056, 1, 0, 0, 0, 302, 3059, 1, 0, 0, 0, 304, 3064, 1, 0, 0, 0, 306, 3214, 1, 0, 0, 0, 308, 3220, 1, 0, 0, 0, 310, 3227, 1, 0, 0, 0, 312, 3233, 1, 0, 0, 0, 314, 3239, 1, 0, 0, 0, 316, 3245, 1, 0, 0, 0, 318, 3251, 1, 0, 0, 0, 320, 3257, 1, 0, 0, 0, 322, 3263, 1, 0, 0, 0, 324, 3269, 1, 0, 0, 0, 326, 3276, 1, 0, 0, 0, 328, 3281, 1, 0, 0, 0, 330, 3287, 1, 0, 0, 0, 332, 3314, 1, 0, 0, 0, 334, 3328, 1, 0, 0, 0, 336, 3333, 1, 0, 0, 0, 338, 3350, 1, 0, 0, 0, 340, 3352, 1, 0, 0, 0, 342, 3362, 1, 0, 0, 0, 344, 3386, 1, 0, 0, 0, 346, 3391, 1, 0, 0, 0, 348, 3407, 1, 0, 0, 0, 350, 3428, 1, 0, 0, 0, 352, 3430, 1, 0, 0, 0, 354, 3435, 1, 0, 0, 0, 356, 3448, 1, 0, 0, 0, 358, 359, 7, 0, 0, 0, 359, 1, 1, 0, 0, 0, 360, 361, 5, 288, 0, 0, 361, 377, 6, 1, -1, 0, 362, 363, 3, 4, 2, 0, 363, 364, 6, 1, -1, 0, 364, 365, 5, 265, 0, 0, 365, 367, 1, 0, 0, 0, 366, 362, 1, 0, 0, 0, 367, 370, 1, 0, 0, 0, 368, 366, 1, 0, 0, 0, 368, 369, 1, 0, 0, 0, 369, 371, 1, 0, 0, 0, 370, 368, 1, 0, 0, 0, 371, 372, 3, 4, 2, 0, 372, 373, 6, 1, -1, 0, 373, 377, 1, 0, 0, 0, 374, 375, 5, 264, 0, 0, 375, 377, 6, 1, -1, 0, 376, 360, 1, 0, 0, 0, 376, 368, 1, 0, 0, 0, 376, 374, 1, 0, 0, 0, 377, 3, 1, 0, 0, 0, 378, 379, 7, 1, 0, 0, 379, 5, 1, 0, 0, 0, 380, 381, 5, 263, 0, 0, 381, 382, 6, 3, -1, 0, 382, 384, 5, 266, 0, 0, 383, 380, 1, 0, 0, 0, 384, 387, 1, 0, 0, 0, 385, 383, 1, 0, 0, 0, 385, 386, 1, 0, 0, 0, 386, 388, 1, 0, 0, 0, 387, 385, 1, 0, 0, 0, 388, 389, 5, 263, 0, 0, 389, 390, 6, 3, -1, 0, 390, 7, 1, 0, 0, 0, 391, 393, 3, 10, 5, 0, 392, 391, 1, 0, 0, 0, 393, 396, 1, 0, 0, 0, 394, 392, 1, 0, 0, 0, 394, 395, 1, 0, 0, 0, 395, 9, 1, 0, 0, 0, 396, 394, 1, 0, 0, 0, 397, 398, 3, 74, 37, 0, 398, 399, 5, 17, 0, 0, 399, 400, 3, 82, 41, 0, 400, 401, 5, 18, 0, 0, 401, 448, 1, 0, 0, 0, 402, 403, 3, 72, 36, 0, 403, 404, 5, 17, 0, 0, 404, 405, 3, 8, 4, 0, 405, 406, 5, 18, 0, 0, 406, 448, 1, 0, 0, 0, 407, 408, 3, 234, 117, 0, 408, 409, 5, 17, 0, 0, 409, 410, 3, 246, 123, 0, 410, 411, 5, 18, 0, 0, 411, 448, 1, 0, 0, 0, 412, 448, 3, 200, 100, 0, 413, 448, 3, 284, 142, 0, 414, 448, 3, 70, 35, 0, 415, 448, 3, 66, 33, 0, 416, 448, 3, 88, 44, 0, 417, 448, 3, 90, 45, 0, 418, 448, 3, 22, 11, 0, 419, 420, 3, 334, 167, 0, 420, 421, 5, 17, 0, 0, 421, 422, 3, 336, 168, 0, 422, 423, 5, 18, 0, 0, 423, 448, 1, 0, 0, 0, 424, 425, 3, 340, 170, 0, 425, 426, 5, 17, 0, 0, 426, 427, 3, 346, 173, 0, 427, 428, 5, 18, 0, 0, 428, 448, 1, 0, 0, 0, 429, 430, 3, 350, 175, 0, 430, 431, 5, 17, 0, 0, 431, 432, 3, 354, 177, 0, 432, 433, 5, 18, 0, 0, 433, 448, 1, 0, 0, 0, 434, 448, 3, 64, 32, 0, 435, 448, 3, 152, 76, 0, 436, 448, 3, 330, 165, 0, 437, 448, 3, 12, 6, 0, 438, 448, 3, 14, 7, 0, 439, 448, 3, 16, 8, 0, 440, 448, 3, 18, 9, 0, 441, 448, 3, 20, 10, 0, 442, 448, 3, 26, 13, 0, 443, 448, 3, 42, 21, 0, 444, 448, 3, 40, 20, 0, 445, 448, 3, 30, 15, 0, 446, 448, 3, 24, 12, 0, 447, 397, 1, 0, 0, 0, 447, 402, 1, 0, 0, 0, 447, 407, 1, 0, 0, 0, 447, 412, 1, 0, 0, 0, 447, 413, 1, 0, 0, 0, 447, 414, 1, 0, 0, 0, 447, 415, 1, 0, 0, 0, 447, 416, 1, 0, 0, 0, 447, 417, 1, 0, 0, 0, 447, 418, 1, 0, 0, 0, 447, 419, 1, 0, 0, 0, 447, 424, 1, 0, 0, 0, 447, 429, 1, 0, 0, 0, 447, 434, 1, 0, 0, 0, 447, 435, 1, 0, 0, 0, 447, 436, 1, 0, 0, 0, 447, 437, 1, 0, 0, 0, 447, 438, 1, 0, 0, 0, 447, 439, 1, 0, 0, 0, 447, 440, 1, 0, 0, 0, 447, 441, 1, 0, 0, 0, 447, 442, 1, 0, 0, 0, 447, 443, 1, 0, 0, 0, 447, 444, 1, 0, 0, 0, 447, 445, 1, 0, 0, 0, 447, 446, 1, 0, 0, 0, 448, 11, 1, 0, 0, 0, 449, 450, 5, 19, 0, 0, 450, 451, 3, 32, 16, 0, 451, 13, 1, 0, 0, 0, 452, 453, 5, 20, 0, 0, 453, 454, 3, 32, 16, 0, 454, 15, 1, 0, 0, 0, 455, 456, 5, 21, 0, 0, 456, 457, 5, 22, 0, 0, 457, 458, 3, 32, 16, 0, 458, 17, 1, 0, 0, 0, 459, 460, 5, 23, 0, 0, 460, 461, 3, 34, 17, 0, 461, 19, 1, 0, 0, 0, 462, 463, 5, 24, 0, 0, 463, 464, 3, 34, 17, 0, 464, 21, 1, 0, 0, 0, 465, 466, 5, 25, 0, 0, 466, 467, 3, 98, 49, 0, 467, 468, 3, 2, 1, 0, 468, 469, 5, 17, 0, 0, 469, 470, 3, 120, 60, 0, 470, 471, 5, 18, 0, 0, 471, 23, 1, 0, 0, 0, 472, 473, 5, 26, 0, 0, 473, 25, 1, 0, 0, 0, 474, 475, 5, 27, 0, 0, 475, 489, 3, 28, 14, 0, 476, 477, 5, 27, 0, 0, 477, 478, 3, 28, 14, 0, 478, 479, 5, 28, 0, 0, 479, 480, 3, 28, 14, 0, 480, 489, 1, 0, 0, 0, 481, 482, 5, 27, 0, 0, 482, 483, 3, 28, 14, 0, 483, 484, 5, 28, 0, 0, 484, 485, 3, 28, 14, 0, 485, 486, 5, 28, 0, 0, 486, 487, 3, 28, 14, 0, 487, 489, 1, 0, 0, 0, 488, 474, 1, 0, 0, 0, 488, 476, 1, 0, 0, 0, 488, 481, 1, 0, 0, 0, 489, 27, 1, 0, 0, 0, 490, 491, 7, 2, 0, 0, 491, 29, 1, 0, 0, 0, 492, 493, 5, 29, 0, 0, 493, 497, 5, 17, 0, 0, 494, 496, 3, 116, 58, 0, 495, 494, 1, 0, 0, 0, 496, 499, 1, 0, 0, 0, 497, 495, 1, 0, 0, 0, 497, 498, 1, 0, 0, 0, 498, 500, 1, 0, 0, 0, 499, 497, 1, 0, 0, 0, 500, 501, 5, 18, 0, 0, 501, 31, 1, 0, 0, 0, 502, 503, 5, 173, 0, 0, 503, 33, 1, 0, 0, 0, 504, 505, 7, 3, 0, 0, 505, 35, 1, 0, 0, 0, 506, 507, 5, 175, 0, 0, 507, 528, 6, 18, -1, 0, 508, 509, 3, 32, 16, 0, 509, 510, 5, 265, 0, 0, 510, 511, 6, 18, -1, 0, 511, 528, 1, 0, 0, 0, 512, 513, 3, 32, 16, 0, 513, 514, 6, 18, -1, 0, 514, 528, 1, 0, 0, 0, 515, 516, 5, 188, 0, 0, 516, 517, 5, 30, 0, 0, 517, 518, 3, 32, 16, 0, 518, 519, 5, 31, 0, 0, 519, 520, 6, 18, -1, 0, 520, 528, 1, 0, 0, 0, 521, 522, 5, 189, 0, 0, 522, 523, 5, 30, 0, 0, 523, 524, 3, 34, 17, 0, 524, 525, 5, 31, 0, 0, 525, 526, 6, 18, -1, 0, 526, 528, 1, 0, 0, 0, 527, 506, 1, 0, 0, 0, 527, 508, 1, 0, 0, 0, 527, 512, 1, 0, 0, 0, 527, 515, 1, 0, 0, 0, 527, 521, 1, 0, 0, 0, 528, 37, 1, 0, 0, 0, 529, 532, 3, 32, 16, 0, 530, 532, 5, 262, 0, 0, 531, 529, 1, 0, 0, 0, 531, 530, 1, 0, 0, 0, 532, 39, 1, 0, 0, 0, 533, 534, 5, 267, 0, 0, 534, 550, 5, 289, 0, 0, 535, 536, 5, 267, 0, 0, 536, 537, 5, 289, 0, 0, 537, 550, 5, 263, 0, 0, 538, 539, 5, 268, 0, 0, 539, 550, 5, 289, 0, 0, 540, 541, 5, 269, 0, 0, 541, 550, 5, 289, 0, 0, 542, 543, 5, 270, 0, 0, 543, 550, 5, 289, 0, 0, 544, 550, 5, 271, 0, 0, 545, 550, 5, 272, 0, 0, 546, 547, 5, 273, 0, 0, 547, 550, 5, 263, 0, 0, 548, 550, 5, 32, 0, 0, 549, 533, 1, 0, 0, 0, 549, 535, 1, 0, 0, 0, 549, 538, 1, 0, 0, 0, 549, 540, 1, 0, 0, 0, 549, 542, 1, 0, 0, 0, 549, 544, 1, 0, 0, 0, 549, 545, 1, 0, 0, 0, 549, 546, 1, 0, 0, 0, 549, 548, 1, 0, 0, 0, 550, 41, 1, 0, 0, 0, 551, 552, 5, 33, 0, 0, 552, 553, 3, 138, 69, 0, 553, 554, 5, 34, 0, 0, 554, 555, 3, 2, 1, 0, 555, 577, 1, 0, 0, 0, 556, 557, 5, 33, 0, 0, 557, 558, 3, 116, 58, 0, 558, 559, 5, 34, 0, 0, 559, 560, 3, 2, 1, 0, 560, 577, 1, 0, 0, 0, 561, 562, 5, 33, 0, 0, 562, 563, 3, 176, 88, 0, 563, 564, 5, 34, 0, 0, 564, 565, 3, 2, 1, 0, 565, 577, 1, 0, 0, 0, 566, 567, 5, 33, 0, 0, 567, 568, 3, 44, 22, 0, 568, 569, 5, 34, 0, 0, 569, 570, 3, 2, 1, 0, 570, 577, 1, 0, 0, 0, 571, 572, 5, 33, 0, 0, 572, 573, 3, 46, 23, 0, 573, 574, 5, 34, 0, 0, 574, 575, 3, 2, 1, 0, 575, 577, 1, 0, 0, 0, 576, 551, 1, 0, 0, 0, 576, 556, 1, 0, 0, 0, 576, 561, 1, 0, 0, 0, 576, 566, 1, 0, 0, 0, 576, 571, 1, 0, 0, 0, 577, 43, 1, 0, 0, 0, 578, 579, 5, 35, 0, 0, 579, 600, 3, 48, 24, 0, 580, 581, 5, 35, 0, 0, 581, 582, 3, 48, 24, 0, 582, 583, 5, 36, 0, 0, 583, 584, 3, 6, 3, 0, 584, 600, 1, 0, 0, 0, 585, 586, 5, 35, 0, 0, 586, 587, 3, 48, 24, 0, 587, 588, 5, 36, 0, 0, 588, 589, 5, 17, 0, 0, 589, 590, 3, 52, 26, 0, 590, 591, 5, 18, 0, 0, 591, 600, 1, 0, 0, 0, 592, 593, 5, 35, 0, 0, 593, 594, 3, 48, 24, 0, 594, 595, 5, 36, 0, 0, 595, 596, 5, 30, 0, 0, 596, 597, 3, 300, 150, 0, 597, 598, 5, 31, 0, 0, 598, 600, 1, 0, 0, 0, 599, 578, 1, 0, 0, 0, 599, 580, 1, 0, 0, 0, 599, 585, 1, 0, 0, 0, 599, 592, 1, 0, 0, 0, 600, 45, 1, 0, 0, 0, 601, 602, 5, 35, 0, 0, 602, 603, 5, 30, 0, 0, 603, 604, 3, 50, 25, 0, 604, 605, 5, 31, 0, 0, 605, 606, 3, 48, 24, 0, 606, 636, 1, 0, 0, 0, 607, 608, 5, 35, 0, 0, 608, 609, 5, 30, 0, 0, 609, 610, 3, 50, 25, 0, 610, 611, 5, 31, 0, 0, 611, 612, 3, 48, 24, 0, 612, 613, 5, 36, 0, 0, 613, 614, 3, 6, 3, 0, 614, 636, 1, 0, 0, 0, 615, 616, 5, 35, 0, 0, 616, 617, 5, 30, 0, 0, 617, 618, 3, 50, 25, 0, 618, 619, 5, 31, 0, 0, 619, 620, 3, 48, 24, 0, 620, 621, 5, 36, 0, 0, 621, 622, 5, 17, 0, 0, 622, 623, 3, 52, 26, 0, 623, 624, 5, 18, 0, 0, 624, 636, 1, 0, 0, 0, 625, 626, 5, 35, 0, 0, 626, 627, 5, 30, 0, 0, 627, 628, 3, 50, 25, 0, 628, 629, 5, 31, 0, 0, 629, 630, 3, 48, 24, 0, 630, 631, 5, 36, 0, 0, 631, 632, 5, 30, 0, 0, 632, 633, 3, 300, 150, 0, 633, 634, 5, 31, 0, 0, 634, 636, 1, 0, 0, 0, 635, 601, 1, 0, 0, 0, 635, 607, 1, 0, 0, 0, 635, 615, 1, 0, 0, 0, 635, 625, 1, 0, 0, 0, 636, 47, 1, 0, 0, 0, 637, 638, 3, 168, 84, 0, 638, 49, 1, 0, 0, 0, 639, 640, 3, 124, 62, 0, 640, 641, 6, 25, -1, 0, 641, 646, 1, 0, 0, 0, 642, 643, 3, 176, 88, 0, 643, 644, 6, 25, -1, 0, 644, 646, 1, 0, 0, 0, 645, 639, 1, 0, 0, 0, 645, 642, 1, 0, 0, 0, 646, 51, 1, 0, 0, 0, 647, 648, 3, 54, 27, 0, 648, 649, 3, 56, 28, 0, 649, 53, 1, 0, 0, 0, 650, 653, 3, 306, 153, 0, 651, 653, 3, 40, 20, 0, 652, 650, 1, 0, 0, 0, 652, 651, 1, 0, 0, 0, 653, 656, 1, 0, 0, 0, 654, 652, 1, 0, 0, 0, 654, 655, 1, 0, 0, 0, 655, 55, 1, 0, 0, 0, 656, 654, 1, 0, 0, 0, 657, 658, 3, 58, 29, 0, 658, 659, 3, 60, 30, 0, 659, 660, 3, 2, 1, 0, 660, 661, 5, 36, 0, 0, 661, 662, 3, 306, 153, 0, 662, 665, 1, 0, 0, 0, 663, 665, 3, 40, 20, 0, 664, 657, 1, 0, 0, 0, 664, 663, 1, 0, 0, 0, 665, 668, 1, 0, 0, 0, 666, 664, 1, 0, 0, 0, 666, 667, 1, 0, 0, 0, 667, 57, 1, 0, 0, 0, 668, 666, 1, 0, 0, 0, 669, 670, 7, 4, 0, 0, 670, 59, 1, 0, 0, 0, 671, 673, 3, 62, 31, 0, 672, 674, 5, 261, 0, 0, 673, 672, 1, 0, 0, 0, 673, 674, 1, 0, 0, 0, 674, 61, 1, 0, 0, 0, 675, 685, 3, 144, 72, 0, 676, 685, 3, 2, 1, 0, 677, 685, 5, 196, 0, 0, 678, 685, 5, 197, 0, 0, 679, 680, 5, 202, 0, 0, 680, 681, 5, 39, 0, 0, 681, 685, 5, 264, 0, 0, 682, 683, 5, 202, 0, 0, 683, 685, 3, 116, 58, 0, 684, 675, 1, 0, 0, 0, 684, 676, 1, 0, 0, 0, 684, 677, 1, 0, 0, 0, 684, 678, 1, 0, 0, 0, 684, 679, 1, 0, 0, 0, 684, 682, 1, 0, 0, 0, 685, 63, 1, 0, 0, 0, 686, 687, 5, 198, 0, 0, 687, 688, 5, 40, 0, 0, 688, 693, 3, 2, 1, 0, 689, 690, 5, 198, 0, 0, 690, 693, 3, 2, 1, 0, 691, 693, 5, 198, 0, 0, 692, 686, 1, 0, 0, 0, 692, 689, 1, 0, 0, 0, 692, 691, 1, 0, 0, 0, 693, 65, 1, 0, 0, 0, 694, 695, 5, 41, 0, 0, 695, 696, 5, 42, 0, 0, 696, 697, 3, 32, 16, 0, 697, 698, 5, 43, 0, 0, 698, 699, 3, 68, 34, 0, 699, 700, 5, 44, 0, 0, 700, 701, 3, 0, 0, 0, 701, 67, 1, 0, 0, 0, 702, 715, 6, 34, -1, 0, 703, 704, 10, 5, 0, 0, 704, 714, 5, 186, 0, 0, 705, 706, 10, 4, 0, 0, 706, 714, 5, 187, 0, 0, 707, 708, 10, 3, 0, 0, 708, 714, 5, 45, 0, 0, 709, 710, 10, 2, 0, 0, 710, 714, 5, 46, 0, 0, 711, 712, 10, 1, 0, 0, 712, 714, 5, 47, 0, 0, 713, 703, 1, 0, 0, 0, 713, 705, 1, 0, 0, 0, 713, 707, 1, 0, 0, 0, 713, 709, 1, 0, 0, 0, 713, 711, 1, 0, 0, 0, 714, 717, 1, 0, 0, 0, 715, 713, 1, 0, 0, 0, 715, 716, 1, 0, 0, 0, 716, 69, 1, 0, 0, 0, 717, 715, 1, 0, 0, 0, 718, 719, 5, 48, 0, 0, 719, 720, 5, 36, 0, 0, 720, 721, 5, 30, 0, 0, 721, 722, 3, 300, 150, 0, 722, 723, 5, 31, 0, 0, 723, 71, 1, 0, 0, 0, 724, 725, 5, 49, 0, 0, 725, 726, 3, 2, 1, 0, 726, 73, 1, 0, 0, 0, 727, 731, 5, 50, 0, 0, 728, 730, 3, 76, 38, 0, 729, 728, 1, 0, 0, 0, 730, 733, 1, 0, 0, 0, 731, 729, 1, 0, 0, 0, 731, 732, 1, 0, 0, 0, 732, 734, 1, 0, 0, 0, 733, 731, 1, 0, 0, 0, 734, 735, 3, 2, 1, 0, 735, 736, 3, 182, 91, 0, 736, 737, 3, 78, 39, 0, 737, 738, 3, 80, 40, 0, 738, 75, 1, 0, 0, 0, 739, 777, 5, 51, 0, 0, 740, 777, 5, 52, 0, 0, 741, 777, 5, 199, 0, 0, 742, 777, 5, 202, 0, 0, 743, 777, 5, 221, 0, 0, 744, 777, 5, 53, 0, 0, 745, 777, 5, 54, 0, 0, 746, 777, 5, 55, 0, 0, 747, 777, 5, 56, 0, 0, 748, 777, 5, 244, 0, 0, 749, 777, 5, 15, 0, 0, 750, 777, 5, 224, 0, 0, 751, 777, 5, 57, 0, 0, 752, 777, 5, 58, 0, 0, 753, 777, 5, 59, 0, 0, 754, 777, 5, 60, 0, 0, 755, 777, 5, 61, 0, 0, 756, 757, 5, 62, 0, 0, 757, 777, 5, 51, 0, 0, 758, 759, 5, 62, 0, 0, 759, 777, 5, 52, 0, 0, 760, 761, 5, 62, 0, 0, 761, 777, 5, 63, 0, 0, 762, 763, 5, 62, 0, 0, 763, 777, 5, 64, 0, 0, 764, 765, 5, 62, 0, 0, 765, 777, 5, 65, 0, 0, 766, 767, 5, 62, 0, 0, 767, 777, 5, 66, 0, 0, 768, 777, 5, 67, 0, 0, 769, 777, 5, 68, 0, 0, 770, 777, 5, 69, 0, 0, 771, 772, 5, 70, 0, 0, 772, 773, 5, 30, 0, 0, 773, 774, 3, 32, 16, 0, 774, 775, 5, 31, 0, 0, 775, 777, 1, 0, 0, 0, 776, 739, 1, 0, 0, 0, 776, 740, 1, 0, 0, 0, 776, 741, 1, 0, 0, 0, 776, 742, 1, 0, 0, 0, 776, 743, 1, 0, 0, 0, 776, 744, 1, 0, 0, 0, 776, 745, 1, 0, 0, 0, 776, 746, 1, 0, 0, 0, 776, 747, 1, 0, 0, 0, 776, 748, 1, 0, 0, 0, 776, 749, 1, 0, 0, 0, 776, 750, 1, 0, 0, 0, 776, 751, 1, 0, 0, 0, 776, 752, 1, 0, 0, 0, 776, 753, 1, 0, 0, 0, 776, 754, 1, 0, 0, 0, 776, 755, 1, 0, 0, 0, 776, 756, 1, 0, 0, 0, 776, 758, 1, 0, 0, 0, 776, 760, 1, 0, 0, 0, 776, 762, 1, 0, 0, 0, 776, 764, 1, 0, 0, 0, 776, 766, 1, 0, 0, 0, 776, 768, 1, 0, 0, 0, 776, 769, 1, 0, 0, 0, 776, 770, 1, 0, 0, 0, 776, 771, 1, 0, 0, 0, 777, 77, 1, 0, 0, 0, 778, 782, 1, 0, 0, 0, 779, 780, 5, 71, 0, 0, 780, 782, 3, 124, 62, 0, 781, 778, 1, 0, 0, 0, 781, 779, 1, 0, 0, 0, 782, 79, 1, 0, 0, 0, 783, 787, 1, 0, 0, 0, 784, 785, 5, 72, 0, 0, 785, 787, 3, 84, 42, 0, 786, 783, 1, 0, 0, 0, 786, 784, 1, 0, 0, 0, 787, 81, 1, 0, 0, 0, 788, 790, 3, 198, 99, 0, 789, 788, 1, 0, 0, 0, 790, 793, 1, 0, 0, 0, 791, 789, 1, 0, 0, 0, 791, 792, 1, 0, 0, 0, 792, 83, 1, 0, 0, 0, 793, 791, 1, 0, 0, 0, 794, 795, 3, 124, 62, 0, 795, 796, 5, 28, 0, 0, 796, 798, 1, 0, 0, 0, 797, 794, 1, 0, 0, 0, 798, 801, 1, 0, 0, 0, 799, 797, 1, 0, 0, 0, 799, 800, 1, 0, 0, 0, 800, 802, 1, 0, 0, 0, 801, 799, 1, 0, 0, 0, 802, 803, 3, 124, 62, 0, 803, 85, 1, 0, 0, 0, 804, 805, 7, 5, 0, 0, 805, 87, 1, 0, 0, 0, 806, 807, 3, 86, 43, 0, 807, 808, 3, 32, 16, 0, 808, 809, 5, 264, 0, 0, 809, 910, 1, 0, 0, 0, 810, 811, 3, 86, 43, 0, 811, 812, 3, 32, 16, 0, 812, 910, 1, 0, 0, 0, 813, 814, 3, 86, 43, 0, 814, 815, 3, 32, 16, 0, 815, 816, 5, 75, 0, 0, 816, 817, 3, 32, 16, 0, 817, 818, 5, 264, 0, 0, 818, 910, 1, 0, 0, 0, 819, 820, 3, 86, 43, 0, 820, 821, 3, 32, 16, 0, 821, 822, 5, 75, 0, 0, 822, 823, 3, 32, 16, 0, 823, 910, 1, 0, 0, 0, 824, 825, 3, 86, 43, 0, 825, 826, 3, 32, 16, 0, 826, 827, 5, 75, 0, 0, 827, 828, 3, 32, 16, 0, 828, 829, 5, 28, 0, 0, 829, 830, 3, 32, 16, 0, 830, 831, 5, 264, 0, 0, 831, 910, 1, 0, 0, 0, 832, 833, 3, 86, 43, 0, 833, 834, 3, 32, 16, 0, 834, 835, 5, 75, 0, 0, 835, 836, 3, 32, 16, 0, 836, 837, 5, 28, 0, 0, 837, 838, 3, 32, 16, 0, 838, 910, 1, 0, 0, 0, 839, 840, 3, 86, 43, 0, 840, 841, 3, 32, 16, 0, 841, 842, 5, 28, 0, 0, 842, 843, 3, 32, 16, 0, 843, 844, 5, 75, 0, 0, 844, 845, 3, 32, 16, 0, 845, 846, 5, 264, 0, 0, 846, 910, 1, 0, 0, 0, 847, 848, 3, 86, 43, 0, 848, 849, 3, 32, 16, 0, 849, 850, 5, 28, 0, 0, 850, 851, 3, 32, 16, 0, 851, 852, 5, 75, 0, 0, 852, 853, 3, 32, 16, 0, 853, 910, 1, 0, 0, 0, 854, 855, 3, 86, 43, 0, 855, 856, 3, 32, 16, 0, 856, 857, 5, 28, 0, 0, 857, 858, 3, 32, 16, 0, 858, 859, 5, 75, 0, 0, 859, 860, 3, 32, 16, 0, 860, 861, 5, 28, 0, 0, 861, 862, 3, 32, 16, 0, 862, 863, 5, 264, 0, 0, 863, 910, 1, 0, 0, 0, 864, 865, 3, 86, 43, 0, 865, 866, 3, 32, 16, 0, 866, 867, 5, 28, 0, 0, 867, 868, 3, 32, 16, 0, 868, 869, 5, 75, 0, 0, 869, 870, 3, 32, 16, 0, 870, 871, 5, 28, 0, 0, 871, 872, 3, 32, 16, 0, 872, 910, 1, 0, 0, 0, 873, 874, 3, 86, 43, 0, 874, 875, 3, 32, 16, 0, 875, 876, 5, 263, 0, 0, 876, 910, 1, 0, 0, 0, 877, 878, 3, 86, 43, 0, 878, 879, 3, 32, 16, 0, 879, 880, 5, 75, 0, 0, 880, 881, 3, 32, 16, 0, 881, 882, 5, 263, 0, 0, 882, 910, 1, 0, 0, 0, 883, 884, 3, 86, 43, 0, 884, 885, 3, 32, 16, 0, 885, 886, 5, 75, 0, 0, 886, 887, 3, 32, 16, 0, 887, 888, 5, 28, 0, 0, 888, 889, 3, 32, 16, 0, 889, 890, 5, 263, 0, 0, 890, 910, 1, 0, 0, 0, 891, 892, 3, 86, 43, 0, 892, 893, 3, 32, 16, 0, 893, 894, 5, 28, 0, 0, 894, 895, 3, 32, 16, 0, 895, 896, 5, 75, 0, 0, 896, 897, 3, 32, 16, 0, 897, 898, 5, 263, 0, 0, 898, 910, 1, 0, 0, 0, 899, 900, 3, 86, 43, 0, 900, 901, 3, 32, 16, 0, 901, 902, 5, 28, 0, 0, 902, 903, 3, 32, 16, 0, 903, 904, 5, 75, 0, 0, 904, 905, 3, 32, 16, 0, 905, 906, 5, 28, 0, 0, 906, 907, 3, 32, 16, 0, 907, 908, 5, 263, 0, 0, 908, 910, 1, 0, 0, 0, 909, 806, 1, 0, 0, 0, 909, 810, 1, 0, 0, 0, 909, 813, 1, 0, 0, 0, 909, 819, 1, 0, 0, 0, 909, 824, 1, 0, 0, 0, 909, 832, 1, 0, 0, 0, 909, 839, 1, 0, 0, 0, 909, 847, 1, 0, 0, 0, 909, 854, 1, 0, 0, 0, 909, 864, 1, 0, 0, 0, 909, 873, 1, 0, 0, 0, 909, 877, 1, 0, 0, 0, 909, 883, 1, 0, 0, 0, 909, 891, 1, 0, 0, 0, 909, 899, 1, 0, 0, 0, 910, 89, 1, 0, 0, 0, 911, 915, 5, 21, 0, 0, 912, 914, 3, 92, 46, 0, 913, 912, 1, 0, 0, 0, 914, 917, 1, 0, 0, 0, 915, 913, 1, 0, 0, 0, 915, 916, 1, 0, 0, 0, 916, 918, 1, 0, 0, 0, 917, 915, 1, 0, 0, 0, 918, 919, 3, 2, 1, 0, 919, 920, 3, 94, 47, 0, 920, 921, 5, 180, 0, 0, 921, 922, 5, 36, 0, 0, 922, 923, 5, 30, 0, 0, 923, 924, 3, 300, 150, 0, 924, 925, 5, 31, 0, 0, 925, 926, 3, 94, 47, 0, 926, 938, 1, 0, 0, 0, 927, 931, 5, 21, 0, 0, 928, 930, 3, 92, 46, 0, 929, 928, 1, 0, 0, 0, 930, 933, 1, 0, 0, 0, 931, 929, 1, 0, 0, 0, 931, 932, 1, 0, 0, 0, 932, 934, 1, 0, 0, 0, 933, 931, 1, 0, 0, 0, 934, 935, 3, 2, 1, 0, 935, 936, 3, 94, 47, 0, 936, 938, 1, 0, 0, 0, 937, 911, 1, 0, 0, 0, 937, 927, 1, 0, 0, 0, 938, 91, 1, 0, 0, 0, 939, 940, 5, 76, 0, 0, 940, 93, 1, 0, 0, 0, 941, 944, 1, 0, 0, 0, 942, 944, 5, 298, 0, 0, 943, 941, 1, 0, 0, 0, 943, 942, 1, 0, 0, 0, 944, 95, 1, 0, 0, 0, 945, 946, 7, 6, 0, 0, 946, 97, 1, 0, 0, 0, 947, 949, 3, 96, 48, 0, 948, 947, 1, 0, 0, 0, 949, 952, 1, 0, 0, 0, 950, 948, 1, 0, 0, 0, 950, 951, 1, 0, 0, 0, 951, 99, 1, 0, 0, 0, 952, 950, 1, 0, 0, 0, 953, 979, 3, 102, 51, 0, 954, 955, 5, 280, 0, 0, 955, 956, 3, 168, 84, 0, 956, 957, 6, 50, -1, 0, 957, 979, 1, 0, 0, 0, 958, 959, 5, 286, 0, 0, 959, 960, 3, 178, 89, 0, 960, 961, 6, 50, -1, 0, 961, 979, 1, 0, 0, 0, 962, 963, 5, 286, 0, 0, 963, 964, 3, 174, 87, 0, 964, 965, 6, 50, -1, 0, 965, 979, 1, 0, 0, 0, 966, 967, 5, 284, 0, 0, 967, 968, 3, 124, 62, 0, 968, 969, 6, 50, -1, 0, 969, 979, 1, 0, 0, 0, 970, 971, 5, 281, 0, 0, 971, 972, 3, 104, 52, 0, 972, 973, 6, 50, -1, 0, 973, 979, 1, 0, 0, 0, 974, 975, 5, 287, 0, 0, 975, 976, 3, 50, 25, 0, 976, 977, 6, 50, -1, 0, 977, 979, 1, 0, 0, 0, 978, 953, 1, 0, 0, 0, 978, 954, 1, 0, 0, 0, 978, 958, 1, 0, 0, 0, 978, 962, 1, 0, 0, 0, 978, 966, 1, 0, 0, 0, 978, 970, 1, 0, 0, 0, 978, 974, 1, 0, 0, 0, 979, 101, 1, 0, 0, 0, 980, 981, 5, 275, 0, 0, 981, 1059, 6, 51, -1, 0, 982, 983, 5, 276, 0, 0, 983, 984, 3, 32, 16, 0, 984, 985, 6, 51, -1, 0, 985, 1059, 1, 0, 0, 0, 986, 987, 5, 276, 0, 0, 987, 988, 3, 0, 0, 0, 988, 989, 6, 51, -1, 0, 989, 1059, 1, 0, 0, 0, 990, 991, 5, 277, 0, 0, 991, 992, 3, 32, 16, 0, 992, 993, 6, 51, -1, 0, 993, 1059, 1, 0, 0, 0, 994, 995, 5, 278, 0, 0, 995, 996, 3, 34, 17, 0, 996, 997, 6, 51, -1, 0, 997, 1059, 1, 0, 0, 0, 998, 999, 5, 279, 0, 0, 999, 1000, 3, 36, 18, 0, 1000, 1001, 6, 51, -1, 0, 1001, 1059, 1, 0, 0, 0, 1002, 1003, 5, 279, 0, 0, 1003, 1004, 3, 34, 17, 0, 1004, 1005, 6, 51, -1, 0, 1005, 1059, 1, 0, 0, 0, 1006, 1007, 5, 279, 0, 0, 1007, 1008, 5, 30, 0, 0, 1008, 1009, 3, 300, 150, 0, 1009, 1010, 5, 31, 0, 0, 1010, 1011, 6, 51, -1, 0, 1011, 1059, 1, 0, 0, 0, 1012, 1013, 5, 279, 0, 0, 1013, 1014, 5, 84, 0, 0, 1014, 1015, 5, 30, 0, 0, 1015, 1016, 3, 300, 150, 0, 1016, 1017, 5, 31, 0, 0, 1017, 1018, 6, 51, -1, 0, 1018, 1059, 1, 0, 0, 0, 1019, 1020, 5, 282, 0, 0, 1020, 1021, 3, 32, 16, 0, 1021, 1022, 6, 51, -1, 0, 1022, 1059, 1, 0, 0, 0, 1023, 1024, 5, 282, 0, 0, 1024, 1025, 3, 0, 0, 0, 1025, 1026, 6, 51, -1, 0, 1026, 1059, 1, 0, 0, 0, 1027, 1028, 5, 285, 0, 0, 1028, 1029, 3, 6, 3, 0, 1029, 1030, 6, 51, -1, 0, 1030, 1059, 1, 0, 0, 0, 1031, 1032, 5, 285, 0, 0, 1032, 1033, 5, 224, 0, 0, 1033, 1034, 5, 30, 0, 0, 1034, 1035, 3, 6, 3, 0, 1035, 1036, 5, 31, 0, 0, 1036, 1037, 6, 51, -1, 0, 1037, 1059, 1, 0, 0, 0, 1038, 1039, 5, 285, 0, 0, 1039, 1040, 5, 84, 0, 0, 1040, 1041, 5, 30, 0, 0, 1041, 1042, 3, 300, 150, 0, 1042, 1043, 5, 31, 0, 0, 1043, 1044, 6, 51, -1, 0, 1044, 1059, 1, 0, 0, 0, 1045, 1046, 5, 287, 0, 0, 1046, 1047, 3, 32, 16, 0, 1047, 1048, 6, 51, -1, 0, 1048, 1059, 1, 0, 0, 0, 1049, 1050, 5, 283, 0, 0, 1050, 1056, 6, 51, -1, 0, 1051, 1052, 5, 30, 0, 0, 1052, 1053, 3, 106, 53, 0, 1053, 1054, 5, 31, 0, 0, 1054, 1057, 1, 0, 0, 0, 1055, 1057, 5, 85, 0, 0, 1056, 1051, 1, 0, 0, 0, 1056, 1055, 1, 0, 0, 0, 1057, 1059, 1, 0, 0, 0, 1058, 980, 1, 0, 0, 0, 1058, 982, 1, 0, 0, 0, 1058, 986, 1, 0, 0, 0, 1058, 990, 1, 0, 0, 0, 1058, 994, 1, 0, 0, 0, 1058, 998, 1, 0, 0, 0, 1058, 1002, 1, 0, 0, 0, 1058, 1006, 1, 0, 0, 0, 1058, 1012, 1, 0, 0, 0, 1058, 1019, 1, 0, 0, 0, 1058, 1023, 1, 0, 0, 0, 1058, 1027, 1, 0, 0, 0, 1058, 1031, 1, 0, 0, 0, 1058, 1038, 1, 0, 0, 0, 1058, 1045, 1, 0, 0, 0, 1058, 1049, 1, 0, 0, 0, 1059, 103, 1, 0, 0, 0, 1060, 1061, 3, 170, 85, 0, 1061, 1062, 3, 138, 69, 0, 1062, 1063, 3, 112, 56, 0, 1063, 1064, 6, 52, -1, 0, 1064, 105, 1, 0, 0, 0, 1065, 1090, 1, 0, 0, 0, 1066, 1067, 3, 0, 0, 0, 1067, 1068, 6, 53, -1, 0, 1068, 1073, 1, 0, 0, 0, 1069, 1070, 3, 32, 16, 0, 1070, 1071, 6, 53, -1, 0, 1071, 1073, 1, 0, 0, 0, 1072, 1066, 1, 0, 0, 0, 1072, 1069, 1, 0, 0, 0, 1073, 1074, 1, 0, 0, 0, 1074, 1075, 5, 28, 0, 0, 1075, 1077, 1, 0, 0, 0, 1076, 1072, 1, 0, 0, 0, 1077, 1080, 1, 0, 0, 0, 1078, 1076, 1, 0, 0, 0, 1078, 1079, 1, 0, 0, 0, 1079, 1087, 1, 0, 0, 0, 1080, 1078, 1, 0, 0, 0, 1081, 1082, 3, 0, 0, 0, 1082, 1083, 6, 53, -1, 0, 1083, 1088, 1, 0, 0, 0, 1084, 1085, 3, 32, 16, 0, 1085, 1086, 6, 53, -1, 0, 1086, 1088, 1, 0, 0, 0, 1087, 1081, 1, 0, 0, 0, 1087, 1084, 1, 0, 0, 0, 1088, 1090, 1, 0, 0, 0, 1089, 1065, 1, 0, 0, 0, 1089, 1078, 1, 0, 0, 0, 1090, 107, 1, 0, 0, 0, 1091, 1098, 5, 86, 0, 0, 1092, 1093, 3, 138, 69, 0, 1093, 1094, 6, 54, -1, 0, 1094, 1095, 5, 28, 0, 0, 1095, 1097, 1, 0, 0, 0, 1096, 1092, 1, 0, 0, 0, 1097, 1100, 1, 0, 0, 0, 1098, 1096, 1, 0, 0, 0, 1098, 1099, 1, 0, 0, 0, 1099, 1101, 1, 0, 0, 0, 1100, 1098, 1, 0, 0, 0, 1101, 1102, 3, 138, 69, 0, 1102, 1103, 6, 54, -1, 0, 1103, 1104, 5, 87, 0, 0, 1104, 109, 1, 0, 0, 0, 1105, 1112, 5, 42, 0, 0, 1106, 1107, 3, 146, 73, 0, 1107, 1108, 6, 55, -1, 0, 1108, 1109, 5, 28, 0, 0, 1109, 1111, 1, 0, 0, 0, 1110, 1106, 1, 0, 0, 0, 1111, 1114, 1, 0, 0, 0, 1112, 1110, 1, 0, 0, 0, 1112, 1113, 1, 0, 0, 0, 1113, 1115, 1, 0, 0, 0, 1114, 1112, 1, 0, 0, 0, 1115, 1116, 3, 146, 73, 0, 1116, 1117, 6, 55, -1, 0, 1117, 1118, 5, 43, 0, 0, 1118, 111, 1, 0, 0, 0, 1119, 1126, 5, 30, 0, 0, 1120, 1121, 3, 114, 57, 0, 1121, 1122, 6, 56, -1, 0, 1122, 1123, 5, 28, 0, 0, 1123, 1125, 1, 0, 0, 0, 1124, 1120, 1, 0, 0, 0, 1125, 1128, 1, 0, 0, 0, 1126, 1124, 1, 0, 0, 0, 1126, 1127, 1, 0, 0, 0, 1127, 1129, 1, 0, 0, 0, 1128, 1126, 1, 0, 0, 0, 1129, 1130, 3, 114, 57, 0, 1130, 1131, 6, 56, -1, 0, 1131, 1132, 5, 31, 0, 0, 1132, 1135, 1, 0, 0, 0, 1133, 1135, 5, 85, 0, 0, 1134, 1119, 1, 0, 0, 0, 1134, 1133, 1, 0, 0, 0, 1135, 113, 1, 0, 0, 0, 1136, 1137, 5, 177, 0, 0, 1137, 1147, 6, 57, -1, 0, 1138, 1139, 3, 230, 115, 0, 1139, 1140, 3, 138, 69, 0, 1140, 1142, 3, 226, 113, 0, 1141, 1143, 3, 0, 0, 0, 1142, 1141, 1, 0, 0, 0, 1142, 1143, 1, 0, 0, 0, 1143, 1144, 1, 0, 0, 0, 1144, 1145, 6, 57, -1, 0, 1145, 1147, 1, 0, 0, 0, 1146, 1136, 1, 0, 0, 0, 1146, 1138, 1, 0, 0, 0, 1147, 115, 1, 0, 0, 0, 1148, 1149, 5, 42, 0, 0, 1149, 1150, 3, 2, 1, 0, 1150, 1151, 5, 43, 0, 0, 1151, 1152, 3, 118, 59, 0, 1152, 1153, 6, 58, -1, 0, 1153, 1186, 1, 0, 0, 0, 1154, 1155, 5, 42, 0, 0, 1155, 1156, 3, 174, 87, 0, 1156, 1157, 5, 43, 0, 0, 1157, 1158, 3, 118, 59, 0, 1158, 1159, 6, 58, -1, 0, 1159, 1186, 1, 0, 0, 0, 1160, 1161, 5, 42, 0, 0, 1161, 1162, 5, 262, 0, 0, 1162, 1163, 5, 43, 0, 0, 1163, 1164, 3, 118, 59, 0, 1164, 1165, 6, 58, -1, 0, 1165, 1186, 1, 0, 0, 0, 1166, 1167, 5, 42, 0, 0, 1167, 1168, 5, 198, 0, 0, 1168, 1169, 3, 2, 1, 0, 1169, 1170, 5, 43, 0, 0, 1170, 1171, 3, 118, 59, 0, 1171, 1172, 6, 58, -1, 0, 1172, 1186, 1, 0, 0, 0, 1173, 1174, 3, 118, 59, 0, 1174, 1175, 6, 58, -1, 0, 1175, 1186, 1, 0, 0, 0, 1176, 1177, 3, 174, 87, 0, 1177, 1178, 6, 58, -1, 0, 1178, 1186, 1, 0, 0, 0, 1179, 1180, 5, 257, 0, 0, 1180, 1186, 6, 58, -1, 0, 1181, 1182, 5, 258, 0, 0, 1182, 1186, 6, 58, -1, 0, 1183, 1184, 5, 259, 0, 0, 1184, 1186, 6, 58, -1, 0, 1185, 1148, 1, 0, 0, 0, 1185, 1154, 1, 0, 0, 0, 1185, 1160, 1, 0, 0, 0, 1185, 1166, 1, 0, 0, 0, 1185, 1173, 1, 0, 0, 0, 1185, 1176, 1, 0, 0, 0, 1185, 1179, 1, 0, 0, 0, 1185, 1181, 1, 0, 0, 0, 1185, 1183, 1, 0, 0, 0, 1186, 117, 1, 0, 0, 0, 1187, 1188, 3, 2, 1, 0, 1188, 1189, 6, 59, -1, 0, 1189, 1190, 5, 88, 0, 0, 1190, 1192, 1, 0, 0, 0, 1191, 1187, 1, 0, 0, 0, 1192, 1195, 1, 0, 0, 0, 1193, 1191, 1, 0, 0, 0, 1193, 1194, 1, 0, 0, 0, 1194, 1196, 1, 0, 0, 0, 1195, 1193, 1, 0, 0, 0, 1196, 1197, 3, 2, 1, 0, 1197, 1198, 6, 59, -1, 0, 1198, 119, 1, 0, 0, 0, 1199, 1201, 3, 122, 61, 0, 1200, 1199, 1, 0, 0, 0, 1201, 1204, 1, 0, 0, 0, 1202, 1200, 1, 0, 0, 0, 1202, 1203, 1, 0, 0, 0, 1203, 121, 1, 0, 0, 0, 1204, 1202, 1, 0, 0, 0, 1205, 1206, 5, 180, 0, 0, 1206, 1207, 5, 89, 0, 0, 1207, 1211, 3, 32, 16, 0, 1208, 1211, 3, 152, 76, 0, 1209, 1211, 3, 332, 166, 0, 1210, 1205, 1, 0, 0, 0, 1210, 1208, 1, 0, 0, 0, 1210, 1209, 1, 0, 0, 0, 1211, 123, 1, 0, 0, 0, 1212, 1213, 3, 116, 58, 0, 1213, 1214, 6, 62, -1, 0, 1214, 1230, 1, 0, 0, 0, 1215, 1216, 5, 42, 0, 0, 1216, 1217, 3, 2, 1, 0, 1217, 1218, 5, 43, 0, 0, 1218, 1219, 6, 62, -1, 0, 1219, 1230, 1, 0, 0, 0, 1220, 1221, 5, 42, 0, 0, 1221, 1222, 5, 198, 0, 0, 1222, 1223, 3, 2, 1, 0, 1223, 1224, 5, 43, 0, 0, 1224, 1225, 6, 62, -1, 0, 1225, 1230, 1, 0, 0, 0, 1226, 1227, 3, 138, 69, 0, 1227, 1228, 6, 62, -1, 0, 1228, 1230, 1, 0, 0, 0, 1229, 1212, 1, 0, 0, 0, 1229, 1215, 1, 0, 0, 0, 1229, 1220, 1, 0, 0, 0, 1229, 1226, 1, 0, 0, 0, 1230, 125, 1, 0, 0, 0, 1231, 1243, 1, 0, 0, 0, 1232, 1233, 3, 130, 65, 0, 1233, 1239, 6, 63, -1, 0, 1234, 1235, 3, 128, 64, 0, 1235, 1236, 6, 63, -1, 0, 1236, 1238, 1, 0, 0, 0, 1237, 1234, 1, 0, 0, 0, 1238, 1241, 1, 0, 0, 0, 1239, 1237, 1, 0, 0, 0, 1239, 1240, 1, 0, 0, 0, 1240, 1243, 1, 0, 0, 0, 1241, 1239, 1, 0, 0, 0, 1242, 1231, 1, 0, 0, 0, 1242, 1232, 1, 0, 0, 0, 1243, 127, 1, 0, 0, 0, 1244, 1245, 5, 262, 0, 0, 1245, 1267, 6, 64, -1, 0, 1246, 1247, 5, 261, 0, 0, 1247, 1267, 6, 64, -1, 0, 1248, 1249, 5, 42, 0, 0, 1249, 1250, 3, 32, 16, 0, 1250, 1251, 5, 43, 0, 0, 1251, 1252, 6, 64, -1, 0, 1252, 1267, 1, 0, 0, 0, 1253, 1254, 5, 42, 0, 0, 1254, 1255, 3, 32, 16, 0, 1255, 1256, 5, 266, 0, 0, 1256, 1257, 3, 32, 16, 0, 1257, 1258, 5, 43, 0, 0, 1258, 1259, 6, 64, -1, 0, 1259, 1267, 1, 0, 0, 0, 1260, 1261, 5, 42, 0, 0, 1261, 1262, 5, 266, 0, 0, 1262, 1263, 3, 32, 16, 0, 1263, 1264, 5, 43, 0, 0, 1264, 1265, 6, 64, -1, 0, 1265, 1267, 1, 0, 0, 0, 1266, 1244, 1, 0, 0, 0, 1266, 1246, 1, 0, 0, 0, 1266, 1248, 1, 0, 0, 0, 1266, 1253, 1, 0, 0, 0, 1266, 1260, 1, 0, 0, 0, 1267, 129, 1, 0, 0, 0, 1268, 1414, 6, 65, -1, 0, 1269, 1270, 5, 203, 0, 0, 1270, 1271, 5, 30, 0, 0, 1271, 1272, 3, 6, 3, 0, 1272, 1273, 5, 28, 0, 0, 1273, 1274, 3, 6, 3, 0, 1274, 1275, 5, 28, 0, 0, 1275, 1276, 3, 6, 3, 0, 1276, 1277, 5, 28, 0, 0, 1277, 1278, 3, 6, 3, 0, 1278, 1279, 5, 31, 0, 0, 1279, 1280, 6, 65, -1, 0, 1280, 1414, 1, 0, 0, 0, 1281, 1282, 5, 203, 0, 0, 1282, 1283, 5, 30, 0, 0, 1283, 1284, 3, 6, 3, 0, 1284, 1285, 5, 28, 0, 0, 1285, 1286, 3, 6, 3, 0, 1286, 1287, 5, 31, 0, 0, 1287, 1288, 6, 65, -1, 0, 1288, 1414, 1, 0, 0, 0, 1289, 1290, 5, 204, 0, 0, 1290, 1291, 5, 205, 0, 0, 1291, 1292, 5, 42, 0, 0, 1292, 1293, 3, 32, 16, 0, 1293, 1294, 5, 43, 0, 0, 1294, 1295, 6, 65, -1, 0, 1295, 1414, 1, 0, 0, 0, 1296, 1297, 5, 204, 0, 0, 1297, 1298, 5, 206, 0, 0, 1298, 1299, 5, 42, 0, 0, 1299, 1300, 3, 32, 16, 0, 1300, 1301, 5, 43, 0, 0, 1301, 1302, 3, 126, 63, 0, 1302, 1303, 6, 65, -1, 0, 1303, 1414, 1, 0, 0, 0, 1304, 1305, 5, 207, 0, 0, 1305, 1414, 6, 65, -1, 0, 1306, 1307, 5, 208, 0, 0, 1307, 1414, 6, 65, -1, 0, 1308, 1309, 5, 209, 0, 0, 1309, 1414, 6, 65, -1, 0, 1310, 1311, 5, 201, 0, 0, 1311, 1414, 6, 65, -1, 0, 1312, 1313, 5, 183, 0, 0, 1313, 1414, 6, 65, -1, 0, 1314, 1315, 5, 184, 0, 0, 1315, 1414, 6, 65, -1, 0, 1316, 1317, 5, 185, 0, 0, 1317, 1414, 6, 65, -1, 0, 1318, 1319, 5, 186, 0, 0, 1319, 1414, 6, 65, -1, 0, 1320, 1321, 5, 187, 0, 0, 1321, 1414, 6, 65, -1, 0, 1322, 1323, 5, 188, 0, 0, 1323, 1414, 6, 65, -1, 0, 1324, 1325, 5, 189, 0, 0, 1325, 1414, 6, 65, -1, 0, 1326, 1327, 5, 210, 0, 0, 1327, 1414, 6, 65, -1, 0, 1328, 1329, 5, 190, 0, 0, 1329, 1414, 6, 65, -1, 0, 1330, 1331, 5, 191, 0, 0, 1331, 1414, 6, 65, -1, 0, 1332, 1333, 5, 192, 0, 0, 1333, 1414, 6, 65, -1, 0, 1334, 1335, 5, 193, 0, 0, 1335, 1414, 6, 65, -1, 0, 1336, 1337, 5, 211, 0, 0, 1337, 1414, 6, 65, -1, 0, 1338, 1339, 5, 212, 0, 0, 1339, 1414, 6, 65, -1, 0, 1340, 1341, 5, 213, 0, 0, 1341, 1414, 6, 65, -1, 0, 1342, 1343, 5, 214, 0, 0, 1343, 1414, 6, 65, -1, 0, 1344, 1345, 5, 215, 0, 0, 1345, 1414, 6, 65, -1, 0, 1346, 1347, 5, 216, 0, 0, 1347, 1414, 6, 65, -1, 0, 1348, 1349, 5, 217, 0, 0, 1349, 1414, 6, 65, -1, 0, 1350, 1351, 5, 218, 0, 0, 1351, 1352, 3, 132, 66, 0, 1352, 1353, 6, 65, -1, 0, 1353, 1414, 1, 0, 0, 0, 1354, 1355, 5, 219, 0, 0, 1355, 1356, 3, 132, 66, 0, 1356, 1357, 6, 65, -1, 0, 1357, 1414, 1, 0, 0, 0, 1358, 1359, 5, 220, 0, 0, 1359, 1414, 6, 65, -1, 0, 1360, 1361, 5, 221, 0, 0, 1361, 1362, 3, 132, 66, 0, 1362, 1363, 6, 65, -1, 0, 1363, 1414, 1, 0, 0, 0, 1364, 1365, 5, 222, 0, 0, 1365, 1366, 3, 134, 67, 0, 1366, 1367, 6, 65, -1, 0, 1367, 1414, 1, 0, 0, 0, 1368, 1369, 5, 222, 0, 0, 1369, 1370, 3, 134, 67, 0, 1370, 1371, 5, 28, 0, 0, 1371, 1372, 3, 6, 3, 0, 1372, 1373, 6, 65, -1, 0, 1373, 1414, 1, 0, 0, 0, 1374, 1375, 5, 194, 0, 0, 1375, 1414, 6, 65, -1, 0, 1376, 1377, 5, 195, 0, 0, 1377, 1414, 6, 65, -1, 0, 1378, 1379, 5, 90, 0, 0, 1379, 1380, 5, 184, 0, 0, 1380, 1414, 6, 65, -1, 0, 1381, 1382, 5, 90, 0, 0, 1382, 1383, 5, 185, 0, 0, 1383, 1414, 6, 65, -1, 0, 1384, 1385, 5, 90, 0, 0, 1385, 1386, 5, 186, 0, 0, 1386, 1414, 6, 65, -1, 0, 1387, 1388, 5, 90, 0, 0, 1388, 1389, 5, 187, 0, 0, 1389, 1414, 6, 65, -1, 0, 1390, 1391, 5, 62, 0, 0, 1391, 1392, 5, 220, 0, 0, 1392, 1414, 6, 65, -1, 0, 1393, 1394, 5, 223, 0, 0, 1394, 1414, 6, 65, -1, 0, 1395, 1396, 5, 224, 0, 0, 1396, 1397, 5, 213, 0, 0, 1397, 1414, 6, 65, -1, 0, 1398, 1399, 5, 225, 0, 0, 1399, 1414, 6, 65, -1, 0, 1400, 1401, 5, 207, 0, 0, 1401, 1402, 5, 183, 0, 0, 1402, 1414, 6, 65, -1, 0, 1403, 1404, 5, 226, 0, 0, 1404, 1414, 6, 65, -1, 0, 1405, 1406, 5, 228, 0, 0, 1406, 1414, 6, 65, -1, 0, 1407, 1408, 5, 34, 0, 0, 1408, 1409, 5, 227, 0, 0, 1409, 1414, 6, 65, -1, 0, 1410, 1411, 3, 2, 1, 0, 1411, 1412, 6, 65, -1, 0, 1412, 1414, 1, 0, 0, 0, 1413, 1268, 1, 0, 0, 0, 1413, 1269, 1, 0, 0, 0, 1413, 1281, 1, 0, 0, 0, 1413, 1289, 1, 0, 0, 0, 1413, 1296, 1, 0, 0, 0, 1413, 1304, 1, 0, 0, 0, 1413, 1306, 1, 0, 0, 0, 1413, 1308, 1, 0, 0, 0, 1413, 1310, 1, 0, 0, 0, 1413, 1312, 1, 0, 0, 0, 1413, 1314, 1, 0, 0, 0, 1413, 1316, 1, 0, 0, 0, 1413, 1318, 1, 0, 0, 0, 1413, 1320, 1, 0, 0, 0, 1413, 1322, 1, 0, 0, 0, 1413, 1324, 1, 0, 0, 0, 1413, 1326, 1, 0, 0, 0, 1413, 1328, 1, 0, 0, 0, 1413, 1330, 1, 0, 0, 0, 1413, 1332, 1, 0, 0, 0, 1413, 1334, 1, 0, 0, 0, 1413, 1336, 1, 0, 0, 0, 1413, 1338, 1, 0, 0, 0, 1413, 1340, 1, 0, 0, 0, 1413, 1342, 1, 0, 0, 0, 1413, 1344, 1, 0, 0, 0, 1413, 1346, 1, 0, 0, 0, 1413, 1348, 1, 0, 0, 0, 1413, 1350, 1, 0, 0, 0, 1413, 1354, 1, 0, 0, 0, 1413, 1358, 1, 0, 0, 0, 1413, 1360, 1, 0, 0, 0, 1413, 1364, 1, 0, 0, 0, 1413, 1368, 1, 0, 0, 0, 1413, 1374, 1, 0, 0, 0, 1413, 1376, 1, 0, 0, 0, 1413, 1378, 1, 0, 0, 0, 1413, 1381, 1, 0, 0, 0, 1413, 1384, 1, 0, 0, 0, 1413, 1387, 1, 0, 0, 0, 1413, 1390, 1, 0, 0, 0, 1413, 1393, 1, 0, 0, 0, 1413, 1395, 1, 0, 0, 0, 1413, 1398, 1, 0, 0, 0, 1413, 1400, 1, 0, 0, 0, 1413, 1403, 1, 0, 0, 0, 1413, 1405, 1, 0, 0, 0, 1413, 1407, 1, 0, 0, 0, 1413, 1410, 1, 0, 0, 0, 1414, 131, 1, 0, 0, 0, 1415, 1424, 1, 0, 0, 0, 1416, 1417, 5, 30, 0, 0, 1417, 1418, 5, 91, 0, 0, 1418, 1419, 5, 36, 0, 0, 1419, 1420, 3, 32, 16, 0, 1420, 1421, 5, 31, 0, 0, 1421, 1422, 6, 66, -1, 0, 1422, 1424, 1, 0, 0, 0, 1423, 1415, 1, 0, 0, 0, 1423, 1416, 1, 0, 0, 0, 1424, 133, 1, 0, 0, 0, 1425, 1436, 1, 0, 0, 0, 1426, 1427, 3, 136, 68, 0, 1427, 1432, 6, 67, -1, 0, 1428, 1429, 7, 7, 0, 0, 1429, 1431, 6, 67, -1, 0, 1430, 1428, 1, 0, 0, 0, 1431, 1434, 1, 0, 0, 0, 1432, 1430, 1, 0, 0, 0, 1432, 1433, 1, 0, 0, 0, 1433, 1436, 1, 0, 0, 0, 1434, 1432, 1, 0, 0, 0, 1435, 1425, 1, 0, 0, 0, 1435, 1426, 1, 0, 0, 0, 1436, 135, 1, 0, 0, 0, 1437, 1438, 5, 178, 0, 0, 1438, 1518, 6, 68, -1, 0, 1439, 1440, 5, 207, 0, 0, 1440, 1518, 6, 68, -1, 0, 1441, 1442, 5, 208, 0, 0, 1442, 1518, 6, 68, -1, 0, 1443, 1444, 5, 201, 0, 0, 1444, 1518, 6, 68, -1, 0, 1445, 1446, 5, 183, 0, 0, 1446, 1518, 6, 68, -1, 0, 1447, 1448, 5, 184, 0, 0, 1448, 1518, 6, 68, -1, 0, 1449, 1450, 5, 185, 0, 0, 1450, 1518, 6, 68, -1, 0, 1451, 1452, 5, 186, 0, 0, 1452, 1518, 6, 68, -1, 0, 1453, 1454, 5, 187, 0, 0, 1454, 1518, 6, 68, -1, 0, 1455, 1456, 5, 188, 0, 0, 1456, 1518, 6, 68, -1, 0, 1457, 1458, 5, 189, 0, 0, 1458, 1518, 6, 68, -1, 0, 1459, 1460, 5, 190, 0, 0, 1460, 1518, 6, 68, -1, 0, 1461, 1462, 5, 191, 0, 0, 1462, 1518, 6, 68, -1, 0, 1463, 1464, 5, 192, 0, 0, 1464, 1518, 6, 68, -1, 0, 1465, 1466, 5, 193, 0, 0, 1466, 1518, 6, 68, -1, 0, 1467, 1468, 5, 262, 0, 0, 1468, 1518, 6, 68, -1, 0, 1469, 1470, 5, 211, 0, 0, 1470, 1518, 6, 68, -1, 0, 1471, 1472, 5, 212, 0, 0, 1472, 1518, 6, 68, -1, 0, 1473, 1474, 5, 213, 0, 0, 1474, 1518, 6, 68, -1, 0, 1475, 1476, 5, 214, 0, 0, 1476, 1518, 6, 68, -1, 0, 1477, 1478, 5, 215, 0, 0, 1478, 1518, 6, 68, -1, 0, 1479, 1480, 5, 218, 0, 0, 1480, 1518, 6, 68, -1, 0, 1481, 1482, 5, 219, 0, 0, 1482, 1518, 6, 68, -1, 0, 1483, 1484, 5, 222, 0, 0, 1484, 1518, 6, 68, -1, 0, 1485, 1486, 5, 194, 0, 0, 1486, 1518, 6, 68, -1, 0, 1487, 1488, 5, 195, 0, 0, 1488, 1518, 6, 68, -1, 0, 1489, 1490, 5, 210, 0, 0, 1490, 1518, 6, 68, -1, 0, 1491, 1492, 5, 230, 0, 0, 1492, 1518, 6, 68, -1, 0, 1493, 1494, 5, 231, 0, 0, 1494, 1518, 6, 68, -1, 0, 1495, 1496, 5, 232, 0, 0, 1496, 1518, 6, 68, -1, 0, 1497, 1498, 5, 233, 0, 0, 1498, 1518, 6, 68, -1, 0, 1499, 1500, 5, 234, 0, 0, 1500, 1518, 6, 68, -1, 0, 1501, 1502, 5, 235, 0, 0, 1502, 1518, 6, 68, -1, 0, 1503, 1504, 5, 236, 0, 0, 1504, 1518, 6, 68, -1, 0, 1505, 1506, 5, 237, 0, 0, 1506, 1518, 6, 68, -1, 0, 1507, 1508, 5, 238, 0, 0, 1508, 1518, 6, 68, -1, 0, 1509, 1510, 5, 239, 0, 0, 1510, 1518, 6, 68, -1, 0, 1511, 1512, 5, 240, 0, 0, 1512, 1518, 6, 68, -1, 0, 1513, 1514, 5, 241, 0, 0, 1514, 1518, 6, 68, -1, 0, 1515, 1516, 5, 242, 0, 0, 1516, 1518, 6, 68, -1, 0, 1517, 1437, 1, 0, 0, 0, 1517, 1439, 1, 0, 0, 0, 1517, 1441, 1, 0, 0, 0, 1517, 1443, 1, 0, 0, 0, 1517, 1445, 1, 0, 0, 0, 1517, 1447, 1, 0, 0, 0, 1517, 1449, 1, 0, 0, 0, 1517, 1451, 1, 0, 0, 0, 1517, 1453, 1, 0, 0, 0, 1517, 1455, 1, 0, 0, 0, 1517, 1457, 1, 0, 0, 0, 1517, 1459, 1, 0, 0, 0, 1517, 1461, 1, 0, 0, 0, 1517, 1463, 1, 0, 0, 0, 1517, 1465, 1, 0, 0, 0, 1517, 1467, 1, 0, 0, 0, 1517, 1469, 1, 0, 0, 0, 1517, 1471, 1, 0, 0, 0, 1517, 1473, 1, 0, 0, 0, 1517, 1475, 1, 0, 0, 0, 1517, 1477, 1, 0, 0, 0, 1517, 1479, 1, 0, 0, 0, 1517, 1481, 1, 0, 0, 0, 1517, 1483, 1, 0, 0, 0, 1517, 1485, 1, 0, 0, 0, 1517, 1487, 1, 0, 0, 0, 1517, 1489, 1, 0, 0, 0, 1517, 1491, 1, 0, 0, 0, 1517, 1493, 1, 0, 0, 0, 1517, 1495, 1, 0, 0, 0, 1517, 1497, 1, 0, 0, 0, 1517, 1499, 1, 0, 0, 0, 1517, 1501, 1, 0, 0, 0, 1517, 1503, 1, 0, 0, 0, 1517, 1505, 1, 0, 0, 0, 1517, 1507, 1, 0, 0, 0, 1517, 1509, 1, 0, 0, 0, 1517, 1511, 1, 0, 0, 0, 1517, 1513, 1, 0, 0, 0, 1517, 1515, 1, 0, 0, 0, 1518, 137, 1, 0, 0, 0, 1519, 1520, 3, 142, 71, 0, 1520, 1526, 6, 69, -1, 0, 1521, 1522, 3, 140, 70, 0, 1522, 1523, 6, 69, -1, 0, 1523, 1525, 1, 0, 0, 0, 1524, 1521, 1, 0, 0, 0, 1525, 1528, 1, 0, 0, 0, 1526, 1524, 1, 0, 0, 0, 1526, 1527, 1, 0, 0, 0, 1527, 139, 1, 0, 0, 0, 1528, 1526, 1, 0, 0, 0, 1529, 1530, 5, 261, 0, 0, 1530, 1559, 6, 70, -1, 0, 1531, 1532, 5, 42, 0, 0, 1532, 1533, 5, 43, 0, 0, 1533, 1559, 6, 70, -1, 0, 1534, 1535, 3, 110, 55, 0, 1535, 1536, 6, 70, -1, 0, 1536, 1559, 1, 0, 0, 0, 1537, 1538, 5, 260, 0, 0, 1538, 1559, 6, 70, -1, 0, 1539, 1540, 5, 262, 0, 0, 1540, 1559, 6, 70, -1, 0, 1541, 1542, 5, 92, 0, 0, 1542, 1559, 6, 70, -1, 0, 1543, 1544, 5, 93, 0, 0, 1544, 1545, 5, 30, 0, 0, 1545, 1546, 3, 124, 62, 0, 1546, 1547, 5, 31, 0, 0, 1547, 1548, 6, 70, -1, 0, 1548, 1559, 1, 0, 0, 0, 1549, 1550, 5, 94, 0, 0, 1550, 1551, 5, 30, 0, 0, 1551, 1552, 3, 124, 62, 0, 1552, 1553, 5, 31, 0, 0, 1553, 1554, 6, 70, -1, 0, 1554, 1559, 1, 0, 0, 0, 1555, 1556, 3, 108, 54, 0, 1556, 1557, 6, 70, -1, 0, 1557, 1559, 1, 0, 0, 0, 1558, 1529, 1, 0, 0, 0, 1558, 1531, 1, 0, 0, 0, 1558, 1534, 1, 0, 0, 0, 1558, 1537, 1, 0, 0, 0, 1558, 1539, 1, 0, 0, 0, 1558, 1541, 1, 0, 0, 0, 1558, 1543, 1, 0, 0, 0, 1558, 1549, 1, 0, 0, 0, 1558, 1555, 1, 0, 0, 0, 1559, 141, 1, 0, 0, 0, 1560, 1561, 5, 39, 0, 0, 1561, 1562, 3, 116, 58, 0, 1562, 1563, 6, 71, -1, 0, 1563, 1619, 1, 0, 0, 0, 1564, 1565, 5, 197, 0, 0, 1565, 1619, 6, 71, -1, 0, 1566, 1567, 5, 199, 0, 0, 1567, 1568, 5, 39, 0, 0, 1568, 1569, 3, 116, 58, 0, 1569, 1570, 6, 71, -1, 0, 1570, 1619, 1, 0, 0, 0, 1571, 1572, 5, 200, 0, 0, 1572, 1573, 3, 116, 58, 0, 1573, 1574, 6, 71, -1, 0, 1574, 1619, 1, 0, 0, 0, 1575, 1576, 5, 226, 0, 0, 1576, 1577, 3, 170, 85, 0, 1577, 1578, 3, 138, 69, 0, 1578, 1579, 5, 262, 0, 0, 1579, 1580, 3, 112, 56, 0, 1580, 1581, 6, 71, -1, 0, 1581, 1619, 1, 0, 0, 0, 1582, 1583, 5, 253, 0, 0, 1583, 1584, 3, 32, 16, 0, 1584, 1585, 6, 71, -1, 0, 1585, 1619, 1, 0, 0, 0, 1586, 1587, 5, 252, 0, 0, 1587, 1588, 3, 32, 16, 0, 1588, 1589, 6, 71, -1, 0, 1589, 1619, 1, 0, 0, 0, 1590, 1591, 5, 253, 0, 0, 1591, 1592, 3, 2, 1, 0, 1592, 1593, 6, 71, -1, 0, 1593, 1619, 1, 0, 0, 0, 1594, 1595, 5, 252, 0, 0, 1595, 1596, 3, 2, 1, 0, 1596, 1597, 6, 71, -1, 0, 1597, 1619, 1, 0, 0, 0, 1598, 1599, 5, 254, 0, 0, 1599, 1619, 6, 71, -1, 0, 1600, 1601, 5, 201, 0, 0, 1601, 1619, 6, 71, -1, 0, 1602, 1603, 3, 148, 74, 0, 1603, 1604, 6, 71, -1, 0, 1604, 1619, 1, 0, 0, 0, 1605, 1606, 3, 150, 75, 0, 1606, 1607, 6, 71, -1, 0, 1607, 1619, 1, 0, 0, 0, 1608, 1609, 3, 144, 72, 0, 1609, 1610, 6, 71, -1, 0, 1610, 1619, 1, 0, 0, 0, 1611, 1612, 3, 2, 1, 0, 1612, 1613, 6, 71, -1, 0, 1613, 1619, 1, 0, 0, 0, 1614, 1615, 5, 177, 0, 0, 1615, 1616, 3, 138, 69, 0, 1616, 1617, 6, 71, -1, 0, 1617, 1619, 1, 0, 0, 0, 1618, 1560, 1, 0, 0, 0, 1618, 1564, 1, 0, 0, 0, 1618, 1566, 1, 0, 0, 0, 1618, 1571, 1, 0, 0, 0, 1618, 1575, 1, 0, 0, 0, 1618, 1582, 1, 0, 0, 0, 1618, 1586, 1, 0, 0, 0, 1618, 1590, 1, 0, 0, 0, 1618, 1594, 1, 0, 0, 0, 1618, 1598, 1, 0, 0, 0, 1618, 1600, 1, 0, 0, 0, 1618, 1602, 1, 0, 0, 0, 1618, 1605, 1, 0, 0, 0, 1618, 1608, 1, 0, 0, 0, 1618, 1611, 1, 0, 0, 0, 1618, 1614, 1, 0, 0, 0, 1619, 143, 1, 0, 0, 0, 1620, 1621, 5, 181, 0, 0, 1621, 1659, 6, 72, -1, 0, 1622, 1623, 5, 182, 0, 0, 1623, 1659, 6, 72, -1, 0, 1624, 1625, 5, 183, 0, 0, 1625, 1659, 6, 72, -1, 0, 1626, 1627, 5, 184, 0, 0, 1627, 1659, 6, 72, -1, 0, 1628, 1629, 5, 185, 0, 0, 1629, 1659, 6, 72, -1, 0, 1630, 1631, 5, 186, 0, 0, 1631, 1659, 6, 72, -1, 0, 1632, 1633, 5, 187, 0, 0, 1633, 1659, 6, 72, -1, 0, 1634, 1635, 5, 188, 0, 0, 1635, 1659, 6, 72, -1, 0, 1636, 1637, 5, 189, 0, 0, 1637, 1659, 6, 72, -1, 0, 1638, 1639, 5, 190, 0, 0, 1639, 1659, 6, 72, -1, 0, 1640, 1641, 5, 191, 0, 0, 1641, 1659, 6, 72, -1, 0, 1642, 1643, 5, 192, 0, 0, 1643, 1659, 6, 72, -1, 0, 1644, 1645, 5, 193, 0, 0, 1645, 1659, 6, 72, -1, 0, 1646, 1647, 5, 90, 0, 0, 1647, 1648, 5, 184, 0, 0, 1648, 1659, 6, 72, -1, 0, 1649, 1650, 5, 90, 0, 0, 1650, 1651, 5, 185, 0, 0, 1651, 1659, 6, 72, -1, 0, 1652, 1653, 5, 90, 0, 0, 1653, 1654, 5, 186, 0, 0, 1654, 1659, 6, 72, -1, 0, 1655, 1656, 5, 90, 0, 0, 1656, 1657, 5, 187, 0, 0, 1657, 1659, 6, 72, -1, 0, 1658, 1620, 1, 0, 0, 0, 1658, 1622, 1, 0, 0, 0, 1658, 1624, 1, 0, 0, 0, 1658, 1626, 1, 0, 0, 0, 1658, 1628, 1, 0, 0, 0, 1658, 1630, 1, 0, 0, 0, 1658, 1632, 1, 0, 0, 0, 1658, 1634, 1, 0, 0, 0, 1658, 1636, 1, 0, 0, 0, 1658, 1638, 1, 0, 0, 0, 1658, 1640, 1, 0, 0, 0, 1658, 1642, 1, 0, 0, 0, 1658, 1644, 1, 0, 0, 0, 1658, 1646, 1, 0, 0, 0, 1658, 1649, 1, 0, 0, 0, 1658, 1652, 1, 0, 0, 0, 1658, 1655, 1, 0, 0, 0, 1659, 145, 1, 0, 0, 0, 1660, 1675, 1, 0, 0, 0, 1661, 1675, 5, 177, 0, 0, 1662, 1663, 3, 32, 16, 0, 1663, 1664, 6, 73, -1, 0, 1664, 1675, 1, 0, 0, 0, 1665, 1666, 3, 32, 16, 0, 1666, 1667, 5, 177, 0, 0, 1667, 1668, 3, 32, 16, 0, 1668, 1669, 6, 73, -1, 0, 1669, 1675, 1, 0, 0, 0, 1670, 1671, 3, 32, 16, 0, 1671, 1672, 5, 177, 0, 0, 1672, 1673, 6, 73, -1, 0, 1673, 1675, 1, 0, 0, 0, 1674, 1660, 1, 0, 0, 0, 1674, 1661, 1, 0, 0, 0, 1674, 1662, 1, 0, 0, 0, 1674, 1665, 1, 0, 0, 0, 1674, 1670, 1, 0, 0, 0, 1675, 147, 1, 0, 0, 0, 1676, 1677, 5, 1, 0, 0, 1677, 1678, 5, 194, 0, 0, 1678, 1679, 6, 74, -1, 0, 1679, 149, 1, 0, 0, 0, 1680, 1684, 5, 1, 0, 0, 1681, 1682, 5, 90, 0, 0, 1682, 1685, 5, 194, 0, 0, 1683, 1685, 5, 195, 0, 0, 1684, 1681, 1, 0, 0, 0, 1684, 1683, 1, 0, 0, 0, 1685, 1686, 1, 0, 0, 0, 1686, 1687, 6, 75, -1, 0, 1687, 151, 1, 0, 0, 0, 1688, 1689, 5, 294, 0, 0, 1689, 1690, 3, 166, 83, 0, 1690, 1691, 3, 124, 62, 0, 1691, 1692, 5, 30, 0, 0, 1692, 1693, 3, 158, 79, 0, 1693, 1694, 5, 31, 0, 0, 1694, 1736, 1, 0, 0, 0, 1695, 1696, 5, 294, 0, 0, 1696, 1697, 3, 166, 83, 0, 1697, 1698, 3, 124, 62, 0, 1698, 1699, 5, 36, 0, 0, 1699, 1700, 5, 17, 0, 0, 1700, 1701, 3, 52, 26, 0, 1701, 1702, 5, 18, 0, 0, 1702, 1736, 1, 0, 0, 0, 1703, 1704, 5, 294, 0, 0, 1704, 1705, 3, 166, 83, 0, 1705, 1706, 3, 124, 62, 0, 1706, 1736, 1, 0, 0, 0, 1707, 1708, 5, 295, 0, 0, 1708, 1709, 3, 166, 83, 0, 1709, 1711, 5, 36, 0, 0, 1710, 1712, 5, 84, 0, 0, 1711, 1710, 1, 0, 0, 0, 1711, 1712, 1, 0, 0, 0, 1712, 1713, 1, 0, 0, 0, 1713, 1714, 5, 30, 0, 0, 1714, 1715, 3, 300, 150, 0, 1715, 1716, 5, 31, 0, 0, 1716, 1736, 1, 0, 0, 0, 1717, 1718, 5, 295, 0, 0, 1718, 1719, 3, 166, 83, 0, 1719, 1720, 5, 84, 0, 0, 1720, 1721, 5, 30, 0, 0, 1721, 1722, 3, 300, 150, 0, 1722, 1723, 5, 31, 0, 0, 1723, 1736, 1, 0, 0, 0, 1724, 1725, 5, 295, 0, 0, 1725, 1726, 3, 166, 83, 0, 1726, 1727, 3, 6, 3, 0, 1727, 1736, 1, 0, 0, 0, 1728, 1729, 5, 295, 0, 0, 1729, 1730, 3, 166, 83, 0, 1730, 1731, 5, 36, 0, 0, 1731, 1732, 5, 17, 0, 0, 1732, 1733, 3, 154, 77, 0, 1733, 1734, 5, 18, 0, 0, 1734, 1736, 1, 0, 0, 0, 1735, 1688, 1, 0, 0, 0, 1735, 1695, 1, 0, 0, 0, 1735, 1703, 1, 0, 0, 0, 1735, 1707, 1, 0, 0, 0, 1735, 1717, 1, 0, 0, 0, 1735, 1724, 1, 0, 0, 0, 1735, 1728, 1, 0, 0, 0, 1736, 153, 1, 0, 0, 0, 1737, 1748, 1, 0, 0, 0, 1738, 1739, 3, 156, 78, 0, 1739, 1740, 5, 28, 0, 0, 1740, 1742, 1, 0, 0, 0, 1741, 1738, 1, 0, 0, 0, 1742, 1745, 1, 0, 0, 0, 1743, 1741, 1, 0, 0, 0, 1743, 1744, 1, 0, 0, 0, 1744, 1746, 1, 0, 0, 0, 1745, 1743, 1, 0, 0, 0, 1746, 1748, 3, 156, 78, 0, 1747, 1737, 1, 0, 0, 0, 1747, 1743, 1, 0, 0, 0, 1748, 155, 1, 0, 0, 0, 1749, 1750, 5, 39, 0, 0, 1750, 1751, 5, 264, 0, 0, 1751, 1752, 5, 36, 0, 0, 1752, 1753, 5, 17, 0, 0, 1753, 1754, 3, 56, 28, 0, 1754, 1755, 5, 18, 0, 0, 1755, 1763, 1, 0, 0, 0, 1756, 1757, 3, 124, 62, 0, 1757, 1758, 5, 36, 0, 0, 1758, 1759, 5, 17, 0, 0, 1759, 1760, 3, 56, 28, 0, 1760, 1761, 5, 18, 0, 0, 1761, 1763, 1, 0, 0, 0, 1762, 1749, 1, 0, 0, 0, 1762, 1756, 1, 0, 0, 0, 1763, 157, 1, 0, 0, 0, 1764, 1765, 3, 160, 80, 0, 1765, 1766, 5, 28, 0, 0, 1766, 1768, 1, 0, 0, 0, 1767, 1764, 1, 0, 0, 0, 1768, 1771, 1, 0, 0, 0, 1769, 1767, 1, 0, 0, 0, 1769, 1770, 1, 0, 0, 0, 1770, 1772, 1, 0, 0, 0, 1771, 1769, 1, 0, 0, 0, 1772, 1773, 3, 160, 80, 0, 1773, 159, 1, 0, 0, 0, 1774, 1775, 3, 6, 3, 0, 1775, 1776, 5, 36, 0, 0, 1776, 1777, 3, 164, 82, 0, 1777, 161, 1, 0, 0, 0, 1778, 1779, 7, 8, 0, 0, 1779, 163, 1, 0, 0, 0, 1780, 1815, 3, 162, 81, 0, 1781, 1815, 3, 32, 16, 0, 1782, 1783, 5, 186, 0, 0, 1783, 1784, 5, 30, 0, 0, 1784, 1785, 3, 32, 16, 0, 1785, 1786, 5, 31, 0, 0, 1786, 1815, 1, 0, 0, 0, 1787, 1815, 3, 6, 3, 0, 1788, 1789, 3, 116, 58, 0, 1789, 1790, 5, 30, 0, 0, 1790, 1791, 5, 184, 0, 0, 1791, 1792, 5, 75, 0, 0, 1792, 1793, 3, 32, 16, 0, 1793, 1794, 5, 31, 0, 0, 1794, 1815, 1, 0, 0, 0, 1795, 1796, 3, 116, 58, 0, 1796, 1797, 5, 30, 0, 0, 1797, 1798, 5, 185, 0, 0, 1798, 1799, 5, 75, 0, 0, 1799, 1800, 3, 32, 16, 0, 1800, 1801, 5, 31, 0, 0, 1801, 1815, 1, 0, 0, 0, 1802, 1803, 3, 116, 58, 0, 1803, 1804, 5, 30, 0, 0, 1804, 1805, 5, 186, 0, 0, 1805, 1806, 5, 75, 0, 0, 1806, 1807, 3, 32, 16, 0, 1807, 1808, 5, 31, 0, 0, 1808, 1815, 1, 0, 0, 0, 1809, 1810, 3, 116, 58, 0, 1810, 1811, 5, 30, 0, 0, 1811, 1812, 3, 32, 16, 0, 1812, 1813, 5, 31, 0, 0, 1813, 1815, 1, 0, 0, 0, 1814, 1780, 1, 0, 0, 0, 1814, 1781, 1, 0, 0, 0, 1814, 1782, 1, 0, 0, 0, 1814, 1787, 1, 0, 0, 0, 1814, 1788, 1, 0, 0, 0, 1814, 1795, 1, 0, 0, 0, 1814, 1802, 1, 0, 0, 0, 1814, 1809, 1, 0, 0, 0, 1815, 165, 1, 0, 0, 0, 1816, 1817, 7, 9, 0, 0, 1817, 167, 1, 0, 0, 0, 1818, 1819, 3, 170, 85, 0, 1819, 1820, 3, 138, 69, 0, 1820, 1821, 3, 124, 62, 0, 1821, 1822, 5, 176, 0, 0, 1822, 1824, 3, 242, 121, 0, 1823, 1825, 3, 108, 54, 0, 1824, 1823, 1, 0, 0, 0, 1824, 1825, 1, 0, 0, 0, 1825, 1826, 1, 0, 0, 0, 1826, 1827, 3, 112, 56, 0, 1827, 1828, 6, 84, -1, 0, 1828, 1861, 1, 0, 0, 0, 1829, 1830, 3, 170, 85, 0, 1830, 1831, 3, 138, 69, 0, 1831, 1832, 3, 124, 62, 0, 1832, 1833, 5, 176, 0, 0, 1833, 1834, 3, 242, 121, 0, 1834, 1835, 3, 196, 98, 0, 1835, 1836, 3, 112, 56, 0, 1836, 1837, 6, 84, -1, 0, 1837, 1861, 1, 0, 0, 0, 1838, 1839, 3, 170, 85, 0, 1839, 1840, 3, 138, 69, 0, 1840, 1842, 3, 242, 121, 0, 1841, 1843, 3, 108, 54, 0, 1842, 1841, 1, 0, 0, 0, 1842, 1843, 1, 0, 0, 0, 1843, 1844, 1, 0, 0, 0, 1844, 1845, 3, 112, 56, 0, 1845, 1846, 6, 84, -1, 0, 1846, 1861, 1, 0, 0, 0, 1847, 1848, 3, 170, 85, 0, 1848, 1849, 3, 138, 69, 0, 1849, 1850, 3, 242, 121, 0, 1850, 1851, 3, 196, 98, 0, 1851, 1852, 3, 112, 56, 0, 1852, 1853, 6, 84, -1, 0, 1853, 1861, 1, 0, 0, 0, 1854, 1855, 3, 174, 87, 0, 1855, 1856, 6, 84, -1, 0, 1856, 1861, 1, 0, 0, 0, 1857, 1858, 3, 2, 1, 0, 1858, 1859, 6, 84, -1, 0, 1859, 1861, 1, 0, 0, 0, 1860, 1818, 1, 0, 0, 0, 1860, 1829, 1, 0, 0, 0, 1860, 1838, 1, 0, 0, 0, 1860, 1847, 1, 0, 0, 0, 1860, 1854, 1, 0, 0, 0, 1860, 1857, 1, 0, 0, 0, 1861, 169, 1, 0, 0, 0, 1862, 1863, 5, 243, 0, 0, 1863, 1864, 3, 170, 85, 0, 1864, 1865, 6, 85, -1, 0, 1865, 1880, 1, 0, 0, 0, 1866, 1867, 5, 244, 0, 0, 1867, 1868, 3, 170, 85, 0, 1868, 1869, 6, 85, -1, 0, 1869, 1880, 1, 0, 0, 0, 1870, 1871, 3, 172, 86, 0, 1871, 1872, 6, 85, -1, 0, 1872, 1880, 1, 0, 0, 0, 1873, 1874, 5, 112, 0, 0, 1874, 1875, 5, 30, 0, 0, 1875, 1876, 3, 32, 16, 0, 1876, 1877, 5, 31, 0, 0, 1877, 1878, 6, 85, -1, 0, 1878, 1880, 1, 0, 0, 0, 1879, 1862, 1, 0, 0, 0, 1879, 1866, 1, 0, 0, 0, 1879, 1870, 1, 0, 0, 0, 1879, 1873, 1, 0, 0, 0, 1880, 171, 1, 0, 0, 0, 1881, 1901, 1, 0, 0, 0, 1882, 1883, 5, 245, 0, 0, 1883, 1901, 6, 86, -1, 0, 1884, 1885, 5, 246, 0, 0, 1885, 1901, 6, 86, -1, 0, 1886, 1887, 5, 247, 0, 0, 1887, 1888, 5, 248, 0, 0, 1888, 1901, 6, 86, -1, 0, 1889, 1890, 5, 247, 0, 0, 1890, 1891, 5, 249, 0, 0, 1891, 1901, 6, 86, -1, 0, 1892, 1893, 5, 247, 0, 0, 1893, 1894, 5, 250, 0, 0, 1894, 1901, 6, 86, -1, 0, 1895, 1896, 5, 247, 0, 0, 1896, 1897, 5, 251, 0, 0, 1897, 1901, 6, 86, -1, 0, 1898, 1899, 5, 247, 0, 0, 1899, 1901, 6, 86, -1, 0, 1900, 1881, 1, 0, 0, 0, 1900, 1882, 1, 0, 0, 0, 1900, 1884, 1, 0, 0, 0, 1900, 1886, 1, 0, 0, 0, 1900, 1889, 1, 0, 0, 0, 1900, 1892, 1, 0, 0, 0, 1900, 1895, 1, 0, 0, 0, 1900, 1898, 1, 0, 0, 0, 1901, 173, 1, 0, 0, 0, 1902, 1903, 5, 113, 0, 0, 1903, 1904, 5, 30, 0, 0, 1904, 1905, 3, 32, 16, 0, 1905, 1906, 5, 31, 0, 0, 1906, 1907, 6, 87, -1, 0, 1907, 175, 1, 0, 0, 0, 1908, 1909, 5, 226, 0, 0, 1909, 1910, 3, 168, 84, 0, 1910, 1911, 6, 88, -1, 0, 1911, 1920, 1, 0, 0, 0, 1912, 1913, 5, 37, 0, 0, 1913, 1914, 3, 178, 89, 0, 1914, 1915, 6, 88, -1, 0, 1915, 1920, 1, 0, 0, 0, 1916, 1917, 3, 174, 87, 0, 1917, 1918, 6, 88, -1, 0, 1918, 1920, 1, 0, 0, 0, 1919, 1908, 1, 0, 0, 0, 1919, 1912, 1, 0, 0, 0, 1919, 1916, 1, 0, 0, 0, 1920, 177, 1, 0, 0, 0, 1921, 1922, 3, 138, 69, 0, 1922, 1923, 3, 124, 62, 0, 1923, 1924, 5, 176, 0, 0, 1924, 1925, 3, 2, 1, 0, 1925, 1926, 6, 89, -1, 0, 1926, 1935, 1, 0, 0, 0, 1927, 1928, 3, 138, 69, 0, 1928, 1929, 3, 2, 1, 0, 1929, 1930, 6, 89, -1, 0, 1930, 1935, 1, 0, 0, 0, 1931, 1932, 3, 2, 1, 0, 1932, 1933, 6, 89, -1, 0, 1933, 1935, 1, 0, 0, 0, 1934, 1921, 1, 0, 0, 0, 1934, 1927, 1, 0, 0, 0, 1934, 1931, 1, 0, 0, 0, 1935, 179, 1, 0, 0, 0, 1936, 1937, 3, 124, 62, 0, 1937, 1938, 6, 90, -1, 0, 1938, 1939, 5, 28, 0, 0, 1939, 1941, 1, 0, 0, 0, 1940, 1936, 1, 0, 0, 0, 1941, 1944, 1, 0, 0, 0, 1942, 1940, 1, 0, 0, 0, 1942, 1943, 1, 0, 0, 0, 1943, 1945, 1, 0, 0, 0, 1944, 1942, 1, 0, 0, 0, 1945, 1946, 3, 124, 62, 0, 1946, 1947, 6, 90, -1, 0, 1947, 181, 1, 0, 0, 0, 1948, 1955, 1, 0, 0, 0, 1949, 1950, 5, 86, 0, 0, 1950, 1951, 3, 190, 95, 0, 1951, 1952, 5, 87, 0, 0, 1952, 1953, 6, 91, -1, 0, 1953, 1955, 1, 0, 0, 0, 1954, 1948, 1, 0, 0, 0, 1954, 1949, 1, 0, 0, 0, 1955, 183, 1, 0, 0, 0, 1956, 1957, 5, 266, 0, 0, 1957, 1975, 6, 92, -1, 0, 1958, 1959, 5, 114, 0, 0, 1959, 1975, 6, 92, -1, 0, 1960, 1961, 5, 39, 0, 0, 1961, 1975, 6, 92, -1, 0, 1962, 1963, 5, 200, 0, 0, 1963, 1975, 6, 92, -1, 0, 1964, 1965, 5, 115, 0, 0, 1965, 1975, 6, 92, -1, 0, 1966, 1967, 5, 116, 0, 0, 1967, 1975, 6, 92, -1, 0, 1968, 1969, 5, 70, 0, 0, 1969, 1970, 5, 30, 0, 0, 1970, 1971, 3, 32, 16, 0, 1971, 1972, 5, 31, 0, 0, 1972, 1973, 6, 92, -1, 0, 1973, 1975, 1, 0, 0, 0, 1974, 1956, 1, 0, 0, 0, 1974, 1958, 1, 0, 0, 0, 1974, 1960, 1, 0, 0, 0, 1974, 1962, 1, 0, 0, 0, 1974, 1964, 1, 0, 0, 0, 1974, 1966, 1, 0, 0, 0, 1974, 1968, 1, 0, 0, 0, 1975, 185, 1, 0, 0, 0, 1976, 1977, 3, 184, 92, 0, 1977, 1978, 6, 93, -1, 0, 1978, 1980, 1, 0, 0, 0, 1979, 1976, 1, 0, 0, 0, 1980, 1983, 1, 0, 0, 0, 1981, 1979, 1, 0, 0, 0, 1981, 1982, 1, 0, 0, 0, 1982, 187, 1, 0, 0, 0, 1983, 1981, 1, 0, 0, 0, 1984, 1986, 3, 186, 93, 0, 1985, 1987, 3, 192, 96, 0, 1986, 1985, 1, 0, 0, 0, 1986, 1987, 1, 0, 0, 0, 1987, 1988, 1, 0, 0, 0, 1988, 1989, 3, 2, 1, 0, 1989, 1990, 6, 94, -1, 0, 1990, 189, 1, 0, 0, 0, 1991, 1992, 3, 188, 94, 0, 1992, 1993, 6, 95, -1, 0, 1993, 1994, 5, 28, 0, 0, 1994, 1996, 1, 0, 0, 0, 1995, 1991, 1, 0, 0, 0, 1996, 1999, 1, 0, 0, 0, 1997, 1995, 1, 0, 0, 0, 1997, 1998, 1, 0, 0, 0, 1998, 2000, 1, 0, 0, 0, 1999, 1997, 1, 0, 0, 0, 2000, 2001, 3, 188, 94, 0, 2001, 2002, 6, 95, -1, 0, 2002, 191, 1, 0, 0, 0, 2003, 2004, 5, 30, 0, 0, 2004, 2005, 3, 180, 90, 0, 2005, 2006, 5, 31, 0, 0, 2006, 2007, 6, 96, -1, 0, 2007, 193, 1, 0, 0, 0, 2008, 2010, 3, 196, 98, 0, 2009, 2008, 1, 0, 0, 0, 2009, 2010, 1, 0, 0, 0, 2010, 2011, 1, 0, 0, 0, 2011, 2012, 6, 97, -1, 0, 2012, 195, 1, 0, 0, 0, 2013, 2014, 5, 86, 0, 0, 2014, 2015, 5, 42, 0, 0, 2015, 2016, 3, 32, 16, 0, 2016, 2017, 5, 43, 0, 0, 2017, 2018, 5, 87, 0, 0, 2018, 2019, 6, 98, -1, 0, 2019, 197, 1, 0, 0, 0, 2020, 2021, 3, 234, 117, 0, 2021, 2022, 5, 17, 0, 0, 2022, 2023, 3, 246, 123, 0, 2023, 2024, 5, 18, 0, 0, 2024, 2171, 1, 0, 0, 0, 2025, 2026, 3, 74, 37, 0, 2026, 2027, 5, 17, 0, 0, 2027, 2028, 3, 82, 41, 0, 2028, 2029, 5, 18, 0, 0, 2029, 2171, 1, 0, 0, 0, 2030, 2031, 3, 210, 105, 0, 2031, 2032, 6, 99, -1, 0, 2032, 2033, 5, 17, 0, 0, 2033, 2034, 3, 214, 107, 0, 2034, 2035, 5, 18, 0, 0, 2035, 2171, 1, 0, 0, 0, 2036, 2037, 3, 218, 109, 0, 2037, 2038, 6, 99, -1, 0, 2038, 2039, 5, 17, 0, 0, 2039, 2040, 3, 222, 111, 0, 2040, 2041, 5, 18, 0, 0, 2041, 2171, 1, 0, 0, 0, 2042, 2171, 3, 200, 100, 0, 2043, 2044, 3, 284, 142, 0, 2044, 2045, 6, 99, -1, 0, 2045, 2171, 1, 0, 0, 0, 2046, 2047, 3, 152, 76, 0, 2047, 2048, 6, 99, -1, 0, 2048, 2171, 1, 0, 0, 0, 2049, 2050, 3, 88, 44, 0, 2050, 2051, 6, 99, -1, 0, 2051, 2171, 1, 0, 0, 0, 2052, 2053, 3, 330, 165, 0, 2053, 2054, 6, 99, -1, 0, 2054, 2171, 1, 0, 0, 0, 2055, 2056, 5, 117, 0, 0, 2056, 2057, 3, 32, 16, 0, 2057, 2058, 6, 99, -1, 0, 2058, 2171, 1, 0, 0, 0, 2059, 2060, 5, 118, 0, 0, 2060, 2061, 3, 32, 16, 0, 2061, 2062, 6, 99, -1, 0, 2062, 2171, 1, 0, 0, 0, 2063, 2064, 3, 342, 171, 0, 2064, 2065, 5, 17, 0, 0, 2065, 2066, 3, 346, 173, 0, 2066, 2067, 5, 18, 0, 0, 2067, 2068, 6, 99, -1, 0, 2068, 2171, 1, 0, 0, 0, 2069, 2070, 5, 302, 0, 0, 2070, 2071, 3, 124, 62, 0, 2071, 2072, 5, 176, 0, 0, 2072, 2073, 3, 242, 121, 0, 2073, 2074, 5, 119, 0, 0, 2074, 2075, 3, 170, 85, 0, 2075, 2076, 3, 138, 69, 0, 2076, 2077, 3, 124, 62, 0, 2077, 2078, 5, 176, 0, 0, 2078, 2079, 3, 242, 121, 0, 2079, 2080, 3, 112, 56, 0, 2080, 2081, 6, 99, -1, 0, 2081, 2171, 1, 0, 0, 0, 2082, 2083, 5, 302, 0, 0, 2083, 2084, 5, 226, 0, 0, 2084, 2085, 3, 170, 85, 0, 2085, 2086, 3, 138, 69, 0, 2086, 2087, 3, 124, 62, 0, 2087, 2088, 5, 176, 0, 0, 2088, 2089, 3, 242, 121, 0, 2089, 2090, 3, 194, 97, 0, 2090, 2091, 3, 112, 56, 0, 2091, 2092, 5, 119, 0, 0, 2092, 2093, 5, 226, 0, 0, 2093, 2094, 3, 170, 85, 0, 2094, 2095, 3, 138, 69, 0, 2095, 2096, 3, 124, 62, 0, 2096, 2097, 5, 176, 0, 0, 2097, 2098, 3, 242, 121, 0, 2098, 2099, 3, 194, 97, 0, 2099, 2100, 3, 112, 56, 0, 2100, 2101, 6, 99, -1, 0, 2101, 2171, 1, 0, 0, 0, 2102, 2103, 3, 26, 13, 0, 2103, 2104, 6, 99, -1, 0, 2104, 2171, 1, 0, 0, 0, 2105, 2106, 3, 40, 20, 0, 2106, 2107, 6, 99, -1, 0, 2107, 2171, 1, 0, 0, 0, 2108, 2109, 5, 255, 0, 0, 2109, 2110, 5, 196, 0, 0, 2110, 2111, 5, 42, 0, 0, 2111, 2112, 3, 32, 16, 0, 2112, 2113, 5, 43, 0, 0, 2113, 2119, 6, 99, -1, 0, 2114, 2115, 3, 330, 165, 0, 2115, 2116, 6, 99, -1, 0, 2116, 2118, 1, 0, 0, 0, 2117, 2114, 1, 0, 0, 0, 2118, 2121, 1, 0, 0, 0, 2119, 2117, 1, 0, 0, 0, 2119, 2120, 1, 0, 0, 0, 2120, 2171, 1, 0, 0, 0, 2121, 2119, 1, 0, 0, 0, 2122, 2123, 5, 255, 0, 0, 2123, 2124, 5, 196, 0, 0, 2124, 2125, 3, 2, 1, 0, 2125, 2131, 6, 99, -1, 0, 2126, 2127, 3, 330, 165, 0, 2127, 2128, 6, 99, -1, 0, 2128, 2130, 1, 0, 0, 0, 2129, 2126, 1, 0, 0, 0, 2130, 2133, 1, 0, 0, 0, 2131, 2129, 1, 0, 0, 0, 2131, 2132, 1, 0, 0, 0, 2132, 2171, 1, 0, 0, 0, 2133, 2131, 1, 0, 0, 0, 2134, 2135, 5, 255, 0, 0, 2135, 2136, 5, 256, 0, 0, 2136, 2137, 5, 42, 0, 0, 2137, 2138, 3, 32, 16, 0, 2138, 2139, 5, 43, 0, 0, 2139, 2140, 5, 28, 0, 0, 2140, 2141, 3, 124, 62, 0, 2141, 2147, 6, 99, -1, 0, 2142, 2143, 3, 330, 165, 0, 2143, 2144, 6, 99, -1, 0, 2144, 2146, 1, 0, 0, 0, 2145, 2142, 1, 0, 0, 0, 2146, 2149, 1, 0, 0, 0, 2147, 2145, 1, 0, 0, 0, 2147, 2148, 1, 0, 0, 0, 2148, 2171, 1, 0, 0, 0, 2149, 2147, 1, 0, 0, 0, 2150, 2151, 5, 255, 0, 0, 2151, 2152, 5, 256, 0, 0, 2152, 2153, 3, 2, 1, 0, 2153, 2154, 5, 28, 0, 0, 2154, 2155, 3, 124, 62, 0, 2155, 2161, 6, 99, -1, 0, 2156, 2157, 3, 330, 165, 0, 2157, 2158, 6, 99, -1, 0, 2158, 2160, 1, 0, 0, 0, 2159, 2156, 1, 0, 0, 0, 2160, 2163, 1, 0, 0, 0, 2161, 2159, 1, 0, 0, 0, 2161, 2162, 1, 0, 0, 0, 2162, 2171, 1, 0, 0, 0, 2163, 2161, 1, 0, 0, 0, 2164, 2165, 5, 120, 0, 0, 2165, 2166, 5, 196, 0, 0, 2166, 2167, 3, 124, 62, 0, 2167, 2168, 3, 44, 22, 0, 2168, 2169, 6, 99, -1, 0, 2169, 2171, 1, 0, 0, 0, 2170, 2020, 1, 0, 0, 0, 2170, 2025, 1, 0, 0, 0, 2170, 2030, 1, 0, 0, 0, 2170, 2036, 1, 0, 0, 0, 2170, 2042, 1, 0, 0, 0, 2170, 2043, 1, 0, 0, 0, 2170, 2046, 1, 0, 0, 0, 2170, 2049, 1, 0, 0, 0, 2170, 2052, 1, 0, 0, 0, 2170, 2055, 1, 0, 0, 0, 2170, 2059, 1, 0, 0, 0, 2170, 2063, 1, 0, 0, 0, 2170, 2069, 1, 0, 0, 0, 2170, 2082, 1, 0, 0, 0, 2170, 2102, 1, 0, 0, 0, 2170, 2105, 1, 0, 0, 0, 2170, 2108, 1, 0, 0, 0, 2170, 2122, 1, 0, 0, 0, 2170, 2134, 1, 0, 0, 0, 2170, 2150, 1, 0, 0, 0, 2170, 2164, 1, 0, 0, 0, 2171, 199, 1, 0, 0, 0, 2172, 2173, 5, 121, 0, 0, 2173, 2185, 3, 208, 104, 0, 2174, 2175, 3, 202, 101, 0, 2175, 2176, 6, 100, -1, 0, 2176, 2184, 1, 0, 0, 0, 2177, 2178, 5, 122, 0, 0, 2178, 2179, 5, 30, 0, 0, 2179, 2180, 3, 228, 114, 0, 2180, 2181, 5, 31, 0, 0, 2181, 2182, 6, 100, -1, 0, 2182, 2184, 1, 0, 0, 0, 2183, 2174, 1, 0, 0, 0, 2183, 2177, 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, 2189, 3, 138, 69, 0, 2189, 2190, 3, 2, 1, 0, 2190, 2191, 3, 204, 102, 0, 2191, 2192, 3, 206, 103, 0, 2192, 2193, 6, 100, -1, 0, 2193, 201, 1, 0, 0, 0, 2194, 2195, 5, 123, 0, 0, 2195, 2229, 6, 101, -1, 0, 2196, 2197, 5, 51, 0, 0, 2197, 2229, 6, 101, -1, 0, 2198, 2199, 5, 52, 0, 0, 2199, 2229, 6, 101, -1, 0, 2200, 2201, 5, 63, 0, 0, 2201, 2229, 6, 101, -1, 0, 2202, 2203, 5, 124, 0, 0, 2203, 2229, 6, 101, -1, 0, 2204, 2205, 5, 69, 0, 0, 2205, 2229, 6, 101, -1, 0, 2206, 2207, 5, 68, 0, 0, 2207, 2229, 6, 101, -1, 0, 2208, 2209, 5, 64, 0, 0, 2209, 2229, 6, 101, -1, 0, 2210, 2211, 5, 65, 0, 0, 2211, 2229, 6, 101, -1, 0, 2212, 2213, 5, 66, 0, 0, 2213, 2229, 6, 101, -1, 0, 2214, 2215, 5, 125, 0, 0, 2215, 2229, 6, 101, -1, 0, 2216, 2217, 5, 126, 0, 0, 2217, 2229, 6, 101, -1, 0, 2218, 2219, 5, 127, 0, 0, 2219, 2229, 6, 101, -1, 0, 2220, 2221, 5, 16, 0, 0, 2221, 2229, 6, 101, -1, 0, 2222, 2223, 5, 70, 0, 0, 2223, 2224, 5, 30, 0, 0, 2224, 2225, 3, 32, 16, 0, 2225, 2226, 5, 31, 0, 0, 2226, 2227, 6, 101, -1, 0, 2227, 2229, 1, 0, 0, 0, 2228, 2194, 1, 0, 0, 0, 2228, 2196, 1, 0, 0, 0, 2228, 2198, 1, 0, 0, 0, 2228, 2200, 1, 0, 0, 0, 2228, 2202, 1, 0, 0, 0, 2228, 2204, 1, 0, 0, 0, 2228, 2206, 1, 0, 0, 0, 2228, 2208, 1, 0, 0, 0, 2228, 2210, 1, 0, 0, 0, 2228, 2212, 1, 0, 0, 0, 2228, 2214, 1, 0, 0, 0, 2228, 2216, 1, 0, 0, 0, 2228, 2218, 1, 0, 0, 0, 2228, 2220, 1, 0, 0, 0, 2228, 2222, 1, 0, 0, 0, 2229, 203, 1, 0, 0, 0, 2230, 2240, 1, 0, 0, 0, 2231, 2232, 5, 44, 0, 0, 2232, 2233, 3, 0, 0, 0, 2233, 2234, 6, 102, -1, 0, 2234, 2240, 1, 0, 0, 0, 2235, 2236, 5, 44, 0, 0, 2236, 2237, 3, 32, 16, 0, 2237, 2238, 6, 102, -1, 0, 2238, 2240, 1, 0, 0, 0, 2239, 2230, 1, 0, 0, 0, 2239, 2231, 1, 0, 0, 0, 2239, 2235, 1, 0, 0, 0, 2240, 205, 1, 0, 0, 0, 2241, 2247, 1, 0, 0, 0, 2242, 2243, 5, 36, 0, 0, 2243, 2244, 3, 304, 152, 0, 2244, 2245, 6, 103, -1, 0, 2245, 2247, 1, 0, 0, 0, 2246, 2241, 1, 0, 0, 0, 2246, 2242, 1, 0, 0, 0, 2247, 207, 1, 0, 0, 0, 2248, 2255, 1, 0, 0, 0, 2249, 2250, 5, 42, 0, 0, 2250, 2251, 3, 32, 16, 0, 2251, 2252, 5, 43, 0, 0, 2252, 2253, 6, 104, -1, 0, 2253, 2255, 1, 0, 0, 0, 2254, 2248, 1, 0, 0, 0, 2254, 2249, 1, 0, 0, 0, 2255, 209, 1, 0, 0, 0, 2256, 2262, 5, 128, 0, 0, 2257, 2258, 3, 212, 106, 0, 2258, 2259, 6, 105, -1, 0, 2259, 2261, 1, 0, 0, 0, 2260, 2257, 1, 0, 0, 0, 2261, 2264, 1, 0, 0, 0, 2262, 2260, 1, 0, 0, 0, 2262, 2263, 1, 0, 0, 0, 2263, 2265, 1, 0, 0, 0, 2264, 2262, 1, 0, 0, 0, 2265, 2266, 3, 124, 62, 0, 2266, 2267, 3, 2, 1, 0, 2267, 2268, 6, 105, -1, 0, 2268, 2282, 1, 0, 0, 0, 2269, 2275, 5, 128, 0, 0, 2270, 2271, 3, 212, 106, 0, 2271, 2272, 6, 105, -1, 0, 2272, 2274, 1, 0, 0, 0, 2273, 2270, 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, 2279, 3, 2, 1, 0, 2279, 2280, 6, 105, -1, 0, 2280, 2282, 1, 0, 0, 0, 2281, 2256, 1, 0, 0, 0, 2281, 2269, 1, 0, 0, 0, 2282, 211, 1, 0, 0, 0, 2283, 2284, 5, 69, 0, 0, 2284, 2288, 6, 106, -1, 0, 2285, 2286, 5, 68, 0, 0, 2286, 2288, 6, 106, -1, 0, 2287, 2283, 1, 0, 0, 0, 2287, 2285, 1, 0, 0, 0, 2288, 213, 1, 0, 0, 0, 2289, 2291, 3, 216, 108, 0, 2290, 2289, 1, 0, 0, 0, 2291, 2294, 1, 0, 0, 0, 2292, 2290, 1, 0, 0, 0, 2292, 2293, 1, 0, 0, 0, 2293, 215, 1, 0, 0, 0, 2294, 2292, 1, 0, 0, 0, 2295, 2296, 5, 129, 0, 0, 2296, 2297, 3, 168, 84, 0, 2297, 2298, 6, 108, -1, 0, 2298, 2322, 1, 0, 0, 0, 2299, 2300, 5, 130, 0, 0, 2300, 2301, 3, 168, 84, 0, 2301, 2302, 6, 108, -1, 0, 2302, 2322, 1, 0, 0, 0, 2303, 2304, 5, 131, 0, 0, 2304, 2305, 3, 168, 84, 0, 2305, 2306, 6, 108, -1, 0, 2306, 2322, 1, 0, 0, 0, 2307, 2308, 5, 132, 0, 0, 2308, 2309, 3, 168, 84, 0, 2309, 2310, 6, 108, -1, 0, 2310, 2322, 1, 0, 0, 0, 2311, 2312, 3, 88, 44, 0, 2312, 2313, 6, 108, -1, 0, 2313, 2322, 1, 0, 0, 0, 2314, 2315, 3, 330, 165, 0, 2315, 2316, 6, 108, -1, 0, 2316, 2322, 1, 0, 0, 0, 2317, 2318, 3, 26, 13, 0, 2318, 2319, 6, 108, -1, 0, 2319, 2322, 1, 0, 0, 0, 2320, 2322, 3, 40, 20, 0, 2321, 2295, 1, 0, 0, 0, 2321, 2299, 1, 0, 0, 0, 2321, 2303, 1, 0, 0, 0, 2321, 2307, 1, 0, 0, 0, 2321, 2311, 1, 0, 0, 0, 2321, 2314, 1, 0, 0, 0, 2321, 2317, 1, 0, 0, 0, 2321, 2320, 1, 0, 0, 0, 2322, 217, 1, 0, 0, 0, 2323, 2329, 5, 133, 0, 0, 2324, 2325, 3, 220, 110, 0, 2325, 2326, 6, 109, -1, 0, 2326, 2328, 1, 0, 0, 0, 2327, 2324, 1, 0, 0, 0, 2328, 2331, 1, 0, 0, 0, 2329, 2327, 1, 0, 0, 0, 2329, 2330, 1, 0, 0, 0, 2330, 2332, 1, 0, 0, 0, 2331, 2329, 1, 0, 0, 0, 2332, 2333, 3, 170, 85, 0, 2333, 2334, 3, 138, 69, 0, 2334, 2335, 3, 2, 1, 0, 2335, 2336, 3, 112, 56, 0, 2336, 2337, 3, 206, 103, 0, 2337, 2338, 6, 109, -1, 0, 2338, 219, 1, 0, 0, 0, 2339, 2340, 5, 69, 0, 0, 2340, 2344, 6, 110, -1, 0, 2341, 2342, 5, 68, 0, 0, 2342, 2344, 6, 110, -1, 0, 2343, 2339, 1, 0, 0, 0, 2343, 2341, 1, 0, 0, 0, 2344, 221, 1, 0, 0, 0, 2345, 2347, 3, 224, 112, 0, 2346, 2345, 1, 0, 0, 0, 2347, 2350, 1, 0, 0, 0, 2348, 2346, 1, 0, 0, 0, 2348, 2349, 1, 0, 0, 0, 2349, 223, 1, 0, 0, 0, 2350, 2348, 1, 0, 0, 0, 2351, 2352, 5, 134, 0, 0, 2352, 2353, 3, 168, 84, 0, 2353, 2354, 6, 112, -1, 0, 2354, 2374, 1, 0, 0, 0, 2355, 2356, 5, 135, 0, 0, 2356, 2357, 3, 168, 84, 0, 2357, 2358, 6, 112, -1, 0, 2358, 2374, 1, 0, 0, 0, 2359, 2360, 5, 132, 0, 0, 2360, 2361, 3, 168, 84, 0, 2361, 2362, 6, 112, -1, 0, 2362, 2374, 1, 0, 0, 0, 2363, 2364, 3, 330, 165, 0, 2364, 2365, 6, 112, -1, 0, 2365, 2374, 1, 0, 0, 0, 2366, 2367, 3, 88, 44, 0, 2367, 2368, 6, 112, -1, 0, 2368, 2374, 1, 0, 0, 0, 2369, 2370, 3, 26, 13, 0, 2370, 2371, 6, 112, -1, 0, 2371, 2374, 1, 0, 0, 0, 2372, 2374, 3, 40, 20, 0, 2373, 2351, 1, 0, 0, 0, 2373, 2355, 1, 0, 0, 0, 2373, 2359, 1, 0, 0, 0, 2373, 2363, 1, 0, 0, 0, 2373, 2366, 1, 0, 0, 0, 2373, 2369, 1, 0, 0, 0, 2373, 2372, 1, 0, 0, 0, 2374, 225, 1, 0, 0, 0, 2375, 2383, 6, 113, -1, 0, 2376, 2377, 5, 122, 0, 0, 2377, 2378, 5, 30, 0, 0, 2378, 2379, 3, 228, 114, 0, 2379, 2380, 5, 31, 0, 0, 2380, 2381, 6, 113, -1, 0, 2381, 2383, 1, 0, 0, 0, 2382, 2375, 1, 0, 0, 0, 2382, 2376, 1, 0, 0, 0, 2383, 227, 1, 0, 0, 0, 2384, 2385, 3, 126, 63, 0, 2385, 2386, 6, 114, -1, 0, 2386, 2398, 1, 0, 0, 0, 2387, 2391, 5, 17, 0, 0, 2388, 2389, 3, 302, 151, 0, 2389, 2390, 6, 114, -1, 0, 2390, 2392, 1, 0, 0, 0, 2391, 2388, 1, 0, 0, 0, 2392, 2393, 1, 0, 0, 0, 2393, 2391, 1, 0, 0, 0, 2393, 2394, 1, 0, 0, 0, 2394, 2395, 1, 0, 0, 0, 2395, 2396, 5, 18, 0, 0, 2396, 2398, 1, 0, 0, 0, 2397, 2384, 1, 0, 0, 0, 2397, 2387, 1, 0, 0, 0, 2398, 229, 1, 0, 0, 0, 2399, 2400, 3, 232, 116, 0, 2400, 2401, 6, 115, -1, 0, 2401, 2403, 1, 0, 0, 0, 2402, 2399, 1, 0, 0, 0, 2403, 2406, 1, 0, 0, 0, 2404, 2402, 1, 0, 0, 0, 2404, 2405, 1, 0, 0, 0, 2405, 231, 1, 0, 0, 0, 2406, 2404, 1, 0, 0, 0, 2407, 2408, 5, 42, 0, 0, 2408, 2409, 5, 136, 0, 0, 2409, 2410, 5, 43, 0, 0, 2410, 2425, 6, 116, -1, 0, 2411, 2412, 5, 42, 0, 0, 2412, 2413, 5, 137, 0, 0, 2413, 2414, 5, 43, 0, 0, 2414, 2425, 6, 116, -1, 0, 2415, 2416, 5, 42, 0, 0, 2416, 2417, 5, 138, 0, 0, 2417, 2418, 5, 43, 0, 0, 2418, 2425, 6, 116, -1, 0, 2419, 2420, 5, 42, 0, 0, 2420, 2421, 3, 32, 16, 0, 2421, 2422, 5, 43, 0, 0, 2422, 2423, 6, 116, -1, 0, 2423, 2425, 1, 0, 0, 0, 2424, 2407, 1, 0, 0, 0, 2424, 2411, 1, 0, 0, 0, 2424, 2415, 1, 0, 0, 0, 2424, 2419, 1, 0, 0, 0, 2425, 233, 1, 0, 0, 0, 2426, 2435, 5, 139, 0, 0, 2427, 2428, 3, 236, 118, 0, 2428, 2429, 6, 117, -1, 0, 2429, 2434, 1, 0, 0, 0, 2430, 2431, 3, 238, 119, 0, 2431, 2432, 6, 117, -1, 0, 2432, 2434, 1, 0, 0, 0, 2433, 2427, 1, 0, 0, 0, 2433, 2430, 1, 0, 0, 0, 2434, 2437, 1, 0, 0, 0, 2435, 2433, 1, 0, 0, 0, 2435, 2436, 1, 0, 0, 0, 2436, 2438, 1, 0, 0, 0, 2437, 2435, 1, 0, 0, 0, 2438, 2439, 3, 170, 85, 0, 2439, 2440, 3, 230, 115, 0, 2440, 2441, 3, 138, 69, 0, 2441, 2442, 3, 226, 113, 0, 2442, 2443, 3, 242, 121, 0, 2443, 2444, 3, 182, 91, 0, 2444, 2450, 3, 112, 56, 0, 2445, 2446, 3, 244, 122, 0, 2446, 2447, 6, 117, -1, 0, 2447, 2449, 1, 0, 0, 0, 2448, 2445, 1, 0, 0, 0, 2449, 2452, 1, 0, 0, 0, 2450, 2448, 1, 0, 0, 0, 2450, 2451, 1, 0, 0, 0, 2451, 2453, 1, 0, 0, 0, 2452, 2450, 1, 0, 0, 0, 2453, 2454, 6, 117, -1, 0, 2454, 235, 1, 0, 0, 0, 2455, 2456, 5, 123, 0, 0, 2456, 2498, 6, 118, -1, 0, 2457, 2458, 5, 51, 0, 0, 2458, 2498, 6, 118, -1, 0, 2459, 2460, 5, 52, 0, 0, 2460, 2498, 6, 118, -1, 0, 2461, 2462, 5, 63, 0, 0, 2462, 2498, 6, 118, -1, 0, 2463, 2464, 5, 140, 0, 0, 2464, 2498, 6, 118, -1, 0, 2465, 2466, 5, 68, 0, 0, 2466, 2498, 6, 118, -1, 0, 2467, 2468, 5, 141, 0, 0, 2468, 2498, 6, 118, -1, 0, 2469, 2470, 5, 142, 0, 0, 2470, 2498, 6, 118, -1, 0, 2471, 2472, 5, 54, 0, 0, 2472, 2498, 6, 118, -1, 0, 2473, 2474, 5, 64, 0, 0, 2474, 2498, 6, 118, -1, 0, 2475, 2476, 5, 65, 0, 0, 2476, 2498, 6, 118, -1, 0, 2477, 2478, 5, 66, 0, 0, 2478, 2498, 6, 118, -1, 0, 2479, 2480, 5, 125, 0, 0, 2480, 2498, 6, 118, -1, 0, 2481, 2482, 5, 143, 0, 0, 2482, 2498, 6, 118, -1, 0, 2483, 2484, 5, 144, 0, 0, 2484, 2498, 6, 118, -1, 0, 2485, 2486, 5, 69, 0, 0, 2486, 2498, 6, 118, -1, 0, 2487, 2488, 5, 145, 0, 0, 2488, 2498, 6, 118, -1, 0, 2489, 2490, 5, 146, 0, 0, 2490, 2498, 6, 118, -1, 0, 2491, 2492, 5, 70, 0, 0, 2492, 2493, 5, 30, 0, 0, 2493, 2494, 3, 32, 16, 0, 2494, 2495, 5, 31, 0, 0, 2495, 2496, 6, 118, -1, 0, 2496, 2498, 1, 0, 0, 0, 2497, 2455, 1, 0, 0, 0, 2497, 2457, 1, 0, 0, 0, 2497, 2459, 1, 0, 0, 0, 2497, 2461, 1, 0, 0, 0, 2497, 2463, 1, 0, 0, 0, 2497, 2465, 1, 0, 0, 0, 2497, 2467, 1, 0, 0, 0, 2497, 2469, 1, 0, 0, 0, 2497, 2471, 1, 0, 0, 0, 2497, 2473, 1, 0, 0, 0, 2497, 2475, 1, 0, 0, 0, 2497, 2477, 1, 0, 0, 0, 2497, 2479, 1, 0, 0, 0, 2497, 2481, 1, 0, 0, 0, 2497, 2483, 1, 0, 0, 0, 2497, 2485, 1, 0, 0, 0, 2497, 2487, 1, 0, 0, 0, 2497, 2489, 1, 0, 0, 0, 2497, 2491, 1, 0, 0, 0, 2498, 237, 1, 0, 0, 0, 2499, 2500, 5, 147, 0, 0, 2500, 2509, 5, 30, 0, 0, 2501, 2502, 3, 6, 3, 0, 2502, 2507, 6, 119, -1, 0, 2503, 2504, 5, 34, 0, 0, 2504, 2505, 3, 6, 3, 0, 2505, 2506, 6, 119, -1, 0, 2506, 2508, 1, 0, 0, 0, 2507, 2503, 1, 0, 0, 0, 2507, 2508, 1, 0, 0, 0, 2508, 2510, 1, 0, 0, 0, 2509, 2501, 1, 0, 0, 0, 2509, 2510, 1, 0, 0, 0, 2510, 2516, 1, 0, 0, 0, 2511, 2512, 3, 240, 120, 0, 2512, 2513, 6, 119, -1, 0, 2513, 2515, 1, 0, 0, 0, 2514, 2511, 1, 0, 0, 0, 2515, 2518, 1, 0, 0, 0, 2516, 2514, 1, 0, 0, 0, 2516, 2517, 1, 0, 0, 0, 2517, 2519, 1, 0, 0, 0, 2518, 2516, 1, 0, 0, 0, 2519, 2523, 5, 31, 0, 0, 2520, 2521, 5, 147, 0, 0, 2521, 2523, 5, 85, 0, 0, 2522, 2499, 1, 0, 0, 0, 2522, 2520, 1, 0, 0, 0, 2523, 239, 1, 0, 0, 0, 2524, 2525, 5, 148, 0, 0, 2525, 2567, 6, 120, -1, 0, 2526, 2527, 5, 224, 0, 0, 2527, 2567, 6, 120, -1, 0, 2528, 2529, 5, 57, 0, 0, 2529, 2567, 6, 120, -1, 0, 2530, 2531, 5, 58, 0, 0, 2531, 2567, 6, 120, -1, 0, 2532, 2533, 5, 149, 0, 0, 2533, 2567, 6, 120, -1, 0, 2534, 2535, 5, 150, 0, 0, 2535, 2567, 6, 120, -1, 0, 2536, 2537, 5, 248, 0, 0, 2537, 2567, 6, 120, -1, 0, 2538, 2539, 5, 249, 0, 0, 2539, 2567, 6, 120, -1, 0, 2540, 2541, 5, 250, 0, 0, 2541, 2567, 6, 120, -1, 0, 2542, 2543, 5, 251, 0, 0, 2543, 2567, 6, 120, -1, 0, 2544, 2545, 5, 151, 0, 0, 2545, 2546, 5, 75, 0, 0, 2546, 2547, 5, 152, 0, 0, 2547, 2567, 6, 120, -1, 0, 2548, 2549, 5, 151, 0, 0, 2549, 2550, 5, 75, 0, 0, 2550, 2551, 5, 153, 0, 0, 2551, 2567, 6, 120, -1, 0, 2552, 2553, 5, 154, 0, 0, 2553, 2554, 5, 75, 0, 0, 2554, 2555, 5, 152, 0, 0, 2555, 2567, 6, 120, -1, 0, 2556, 2557, 5, 154, 0, 0, 2557, 2558, 5, 75, 0, 0, 2558, 2559, 5, 153, 0, 0, 2559, 2567, 6, 120, -1, 0, 2560, 2561, 5, 70, 0, 0, 2561, 2562, 5, 30, 0, 0, 2562, 2563, 3, 32, 16, 0, 2563, 2564, 5, 31, 0, 0, 2564, 2565, 6, 120, -1, 0, 2565, 2567, 1, 0, 0, 0, 2566, 2524, 1, 0, 0, 0, 2566, 2526, 1, 0, 0, 0, 2566, 2528, 1, 0, 0, 0, 2566, 2530, 1, 0, 0, 0, 2566, 2532, 1, 0, 0, 0, 2566, 2534, 1, 0, 0, 0, 2566, 2536, 1, 0, 0, 0, 2566, 2538, 1, 0, 0, 0, 2566, 2540, 1, 0, 0, 0, 2566, 2542, 1, 0, 0, 0, 2566, 2544, 1, 0, 0, 0, 2566, 2548, 1, 0, 0, 0, 2566, 2552, 1, 0, 0, 0, 2566, 2556, 1, 0, 0, 0, 2566, 2560, 1, 0, 0, 0, 2567, 241, 1, 0, 0, 0, 2568, 2569, 5, 116, 0, 0, 2569, 2576, 6, 121, -1, 0, 2570, 2571, 5, 155, 0, 0, 2571, 2576, 6, 121, -1, 0, 2572, 2573, 3, 2, 1, 0, 2573, 2574, 6, 121, -1, 0, 2574, 2576, 1, 0, 0, 0, 2575, 2568, 1, 0, 0, 0, 2575, 2570, 1, 0, 0, 0, 2575, 2572, 1, 0, 0, 0, 2576, 243, 1, 0, 0, 0, 2577, 2578, 5, 1, 0, 0, 2578, 2616, 6, 122, -1, 0, 2579, 2580, 5, 2, 0, 0, 2580, 2616, 6, 122, -1, 0, 2581, 2582, 5, 156, 0, 0, 2582, 2616, 6, 122, -1, 0, 2583, 2584, 5, 3, 0, 0, 2584, 2616, 6, 122, -1, 0, 2585, 2586, 5, 4, 0, 0, 2586, 2616, 6, 122, -1, 0, 2587, 2588, 5, 247, 0, 0, 2588, 2616, 6, 122, -1, 0, 2589, 2590, 5, 5, 0, 0, 2590, 2616, 6, 122, -1, 0, 2591, 2592, 5, 6, 0, 0, 2592, 2616, 6, 122, -1, 0, 2593, 2594, 5, 7, 0, 0, 2594, 2616, 6, 122, -1, 0, 2595, 2596, 5, 8, 0, 0, 2596, 2616, 6, 122, -1, 0, 2597, 2598, 5, 9, 0, 0, 2598, 2616, 6, 122, -1, 0, 2599, 2600, 5, 10, 0, 0, 2600, 2616, 6, 122, -1, 0, 2601, 2602, 5, 11, 0, 0, 2602, 2616, 6, 122, -1, 0, 2603, 2604, 5, 12, 0, 0, 2604, 2616, 6, 122, -1, 0, 2605, 2606, 5, 13, 0, 0, 2606, 2616, 6, 122, -1, 0, 2607, 2608, 5, 14, 0, 0, 2608, 2616, 6, 122, -1, 0, 2609, 2610, 5, 70, 0, 0, 2610, 2611, 5, 30, 0, 0, 2611, 2612, 3, 32, 16, 0, 2612, 2613, 5, 31, 0, 0, 2613, 2614, 6, 122, -1, 0, 2614, 2616, 1, 0, 0, 0, 2615, 2577, 1, 0, 0, 0, 2615, 2579, 1, 0, 0, 0, 2615, 2581, 1, 0, 0, 0, 2615, 2583, 1, 0, 0, 0, 2615, 2585, 1, 0, 0, 0, 2615, 2587, 1, 0, 0, 0, 2615, 2589, 1, 0, 0, 0, 2615, 2591, 1, 0, 0, 0, 2615, 2593, 1, 0, 0, 0, 2615, 2595, 1, 0, 0, 0, 2615, 2597, 1, 0, 0, 0, 2615, 2599, 1, 0, 0, 0, 2615, 2601, 1, 0, 0, 0, 2615, 2603, 1, 0, 0, 0, 2615, 2605, 1, 0, 0, 0, 2615, 2607, 1, 0, 0, 0, 2615, 2609, 1, 0, 0, 0, 2616, 245, 1, 0, 0, 0, 2617, 2619, 3, 248, 124, 0, 2618, 2617, 1, 0, 0, 0, 2619, 2622, 1, 0, 0, 0, 2620, 2618, 1, 0, 0, 0, 2620, 2621, 1, 0, 0, 0, 2621, 247, 1, 0, 0, 0, 2622, 2620, 1, 0, 0, 0, 2623, 2661, 3, 100, 50, 0, 2624, 2625, 5, 296, 0, 0, 2625, 2626, 3, 32, 16, 0, 2626, 2627, 6, 124, -1, 0, 2627, 2661, 1, 0, 0, 0, 2628, 2661, 3, 266, 133, 0, 2629, 2630, 5, 297, 0, 0, 2630, 2631, 3, 32, 16, 0, 2631, 2632, 6, 124, -1, 0, 2632, 2661, 1, 0, 0, 0, 2633, 2634, 5, 298, 0, 0, 2634, 2661, 6, 124, -1, 0, 2635, 2636, 5, 299, 0, 0, 2636, 2661, 6, 124, -1, 0, 2637, 2661, 3, 260, 130, 0, 2638, 2661, 3, 264, 132, 0, 2639, 2661, 3, 250, 125, 0, 2640, 2641, 3, 284, 142, 0, 2641, 2642, 6, 124, -1, 0, 2642, 2661, 1, 0, 0, 0, 2643, 2644, 3, 152, 76, 0, 2644, 2645, 6, 124, -1, 0, 2645, 2661, 1, 0, 0, 0, 2646, 2647, 3, 88, 44, 0, 2647, 2648, 6, 124, -1, 0, 2648, 2661, 1, 0, 0, 0, 2649, 2650, 3, 26, 13, 0, 2650, 2651, 6, 124, -1, 0, 2651, 2661, 1, 0, 0, 0, 2652, 2653, 3, 262, 131, 0, 2653, 2654, 6, 124, -1, 0, 2654, 2661, 1, 0, 0, 0, 2655, 2661, 3, 40, 20, 0, 2656, 2661, 3, 252, 126, 0, 2657, 2661, 3, 254, 127, 0, 2658, 2661, 3, 256, 128, 0, 2659, 2661, 3, 258, 129, 0, 2660, 2623, 1, 0, 0, 0, 2660, 2624, 1, 0, 0, 0, 2660, 2628, 1, 0, 0, 0, 2660, 2629, 1, 0, 0, 0, 2660, 2633, 1, 0, 0, 0, 2660, 2635, 1, 0, 0, 0, 2660, 2637, 1, 0, 0, 0, 2660, 2638, 1, 0, 0, 0, 2660, 2639, 1, 0, 0, 0, 2660, 2640, 1, 0, 0, 0, 2660, 2643, 1, 0, 0, 0, 2660, 2646, 1, 0, 0, 0, 2660, 2649, 1, 0, 0, 0, 2660, 2652, 1, 0, 0, 0, 2660, 2655, 1, 0, 0, 0, 2660, 2656, 1, 0, 0, 0, 2660, 2657, 1, 0, 0, 0, 2660, 2658, 1, 0, 0, 0, 2660, 2659, 1, 0, 0, 0, 2661, 249, 1, 0, 0, 0, 2662, 2664, 5, 300, 0, 0, 2663, 2665, 5, 157, 0, 0, 2664, 2663, 1, 0, 0, 0, 2664, 2665, 1, 0, 0, 0, 2665, 2666, 1, 0, 0, 0, 2666, 2667, 3, 112, 56, 0, 2667, 251, 1, 0, 0, 0, 2668, 2669, 5, 301, 0, 0, 2669, 2670, 5, 42, 0, 0, 2670, 2671, 3, 32, 16, 0, 2671, 2674, 5, 43, 0, 0, 2672, 2673, 5, 34, 0, 0, 2673, 2675, 3, 0, 0, 0, 2674, 2672, 1, 0, 0, 0, 2674, 2675, 1, 0, 0, 0, 2675, 253, 1, 0, 0, 0, 2676, 2677, 5, 303, 0, 0, 2677, 2678, 3, 32, 16, 0, 2678, 2679, 5, 75, 0, 0, 2679, 2680, 3, 32, 16, 0, 2680, 255, 1, 0, 0, 0, 2681, 2682, 5, 302, 0, 0, 2682, 2683, 3, 124, 62, 0, 2683, 2684, 5, 176, 0, 0, 2684, 2685, 3, 242, 121, 0, 2685, 2697, 1, 0, 0, 0, 2686, 2687, 5, 302, 0, 0, 2687, 2688, 5, 226, 0, 0, 2688, 2689, 3, 170, 85, 0, 2689, 2690, 3, 138, 69, 0, 2690, 2691, 3, 124, 62, 0, 2691, 2692, 5, 176, 0, 0, 2692, 2693, 3, 242, 121, 0, 2693, 2694, 3, 194, 97, 0, 2694, 2695, 3, 112, 56, 0, 2695, 2697, 1, 0, 0, 0, 2696, 2681, 1, 0, 0, 0, 2696, 2686, 1, 0, 0, 0, 2697, 257, 1, 0, 0, 0, 2698, 2699, 5, 255, 0, 0, 2699, 2700, 5, 196, 0, 0, 2700, 2701, 5, 42, 0, 0, 2701, 2702, 3, 32, 16, 0, 2702, 2708, 5, 43, 0, 0, 2703, 2704, 3, 330, 165, 0, 2704, 2705, 6, 129, -1, 0, 2705, 2707, 1, 0, 0, 0, 2706, 2703, 1, 0, 0, 0, 2707, 2710, 1, 0, 0, 0, 2708, 2706, 1, 0, 0, 0, 2708, 2709, 1, 0, 0, 0, 2709, 2764, 1, 0, 0, 0, 2710, 2708, 1, 0, 0, 0, 2711, 2712, 5, 255, 0, 0, 2712, 2713, 5, 196, 0, 0, 2713, 2719, 3, 2, 1, 0, 2714, 2715, 3, 330, 165, 0, 2715, 2716, 6, 129, -1, 0, 2716, 2718, 1, 0, 0, 0, 2717, 2714, 1, 0, 0, 0, 2718, 2721, 1, 0, 0, 0, 2719, 2717, 1, 0, 0, 0, 2719, 2720, 1, 0, 0, 0, 2720, 2764, 1, 0, 0, 0, 2721, 2719, 1, 0, 0, 0, 2722, 2723, 5, 255, 0, 0, 2723, 2724, 5, 256, 0, 0, 2724, 2725, 5, 42, 0, 0, 2725, 2726, 3, 32, 16, 0, 2726, 2727, 5, 43, 0, 0, 2727, 2728, 5, 28, 0, 0, 2728, 2734, 3, 124, 62, 0, 2729, 2730, 3, 330, 165, 0, 2730, 2731, 6, 129, -1, 0, 2731, 2733, 1, 0, 0, 0, 2732, 2729, 1, 0, 0, 0, 2733, 2736, 1, 0, 0, 0, 2734, 2732, 1, 0, 0, 0, 2734, 2735, 1, 0, 0, 0, 2735, 2764, 1, 0, 0, 0, 2736, 2734, 1, 0, 0, 0, 2737, 2738, 5, 255, 0, 0, 2738, 2739, 5, 256, 0, 0, 2739, 2740, 3, 2, 1, 0, 2740, 2741, 5, 28, 0, 0, 2741, 2747, 3, 124, 62, 0, 2742, 2743, 3, 330, 165, 0, 2743, 2744, 6, 129, -1, 0, 2744, 2746, 1, 0, 0, 0, 2745, 2742, 1, 0, 0, 0, 2746, 2749, 1, 0, 0, 0, 2747, 2745, 1, 0, 0, 0, 2747, 2748, 1, 0, 0, 0, 2748, 2764, 1, 0, 0, 0, 2749, 2747, 1, 0, 0, 0, 2750, 2751, 5, 255, 0, 0, 2751, 2752, 5, 42, 0, 0, 2752, 2753, 3, 32, 16, 0, 2753, 2754, 5, 43, 0, 0, 2754, 2760, 3, 206, 103, 0, 2755, 2756, 3, 330, 165, 0, 2756, 2757, 6, 129, -1, 0, 2757, 2759, 1, 0, 0, 0, 2758, 2755, 1, 0, 0, 0, 2759, 2762, 1, 0, 0, 0, 2760, 2758, 1, 0, 0, 0, 2760, 2761, 1, 0, 0, 0, 2761, 2764, 1, 0, 0, 0, 2762, 2760, 1, 0, 0, 0, 2763, 2698, 1, 0, 0, 0, 2763, 2711, 1, 0, 0, 0, 2763, 2722, 1, 0, 0, 0, 2763, 2737, 1, 0, 0, 0, 2763, 2750, 1, 0, 0, 0, 2764, 259, 1, 0, 0, 0, 2765, 2766, 3, 0, 0, 0, 2766, 2767, 5, 75, 0, 0, 2767, 2768, 6, 130, -1, 0, 2768, 261, 1, 0, 0, 0, 2769, 2772, 3, 44, 22, 0, 2770, 2772, 3, 46, 23, 0, 2771, 2769, 1, 0, 0, 0, 2771, 2770, 1, 0, 0, 0, 2772, 263, 1, 0, 0, 0, 2773, 2774, 5, 17, 0, 0, 2774, 2775, 3, 246, 123, 0, 2775, 2776, 5, 18, 0, 0, 2776, 265, 1, 0, 0, 0, 2777, 2778, 3, 270, 135, 0, 2778, 2779, 3, 268, 134, 0, 2779, 267, 1, 0, 0, 0, 2780, 2781, 3, 272, 136, 0, 2781, 2782, 6, 134, -1, 0, 2782, 2784, 1, 0, 0, 0, 2783, 2780, 1, 0, 0, 0, 2784, 2785, 1, 0, 0, 0, 2785, 2783, 1, 0, 0, 0, 2785, 2786, 1, 0, 0, 0, 2786, 269, 1, 0, 0, 0, 2787, 2788, 5, 158, 0, 0, 2788, 2789, 3, 264, 132, 0, 2789, 2790, 6, 135, -1, 0, 2790, 2804, 1, 0, 0, 0, 2791, 2792, 5, 158, 0, 0, 2792, 2793, 3, 0, 0, 0, 2793, 2794, 5, 159, 0, 0, 2794, 2795, 3, 0, 0, 0, 2795, 2796, 6, 135, -1, 0, 2796, 2804, 1, 0, 0, 0, 2797, 2798, 5, 158, 0, 0, 2798, 2799, 3, 32, 16, 0, 2799, 2800, 5, 159, 0, 0, 2800, 2801, 3, 32, 16, 0, 2801, 2802, 6, 135, -1, 0, 2802, 2804, 1, 0, 0, 0, 2803, 2787, 1, 0, 0, 0, 2803, 2791, 1, 0, 0, 0, 2803, 2797, 1, 0, 0, 0, 2804, 271, 1, 0, 0, 0, 2805, 2806, 3, 276, 138, 0, 2806, 2807, 3, 282, 141, 0, 2807, 2808, 6, 136, -1, 0, 2808, 2822, 1, 0, 0, 0, 2809, 2810, 3, 274, 137, 0, 2810, 2811, 3, 282, 141, 0, 2811, 2812, 6, 136, -1, 0, 2812, 2822, 1, 0, 0, 0, 2813, 2814, 3, 278, 139, 0, 2814, 2815, 3, 282, 141, 0, 2815, 2816, 6, 136, -1, 0, 2816, 2822, 1, 0, 0, 0, 2817, 2818, 3, 280, 140, 0, 2818, 2819, 3, 282, 141, 0, 2819, 2820, 6, 136, -1, 0, 2820, 2822, 1, 0, 0, 0, 2821, 2805, 1, 0, 0, 0, 2821, 2809, 1, 0, 0, 0, 2821, 2813, 1, 0, 0, 0, 2821, 2817, 1, 0, 0, 0, 2822, 273, 1, 0, 0, 0, 2823, 2824, 5, 160, 0, 0, 2824, 2825, 3, 264, 132, 0, 2825, 2826, 6, 137, -1, 0, 2826, 2836, 1, 0, 0, 0, 2827, 2828, 5, 160, 0, 0, 2828, 2829, 3, 0, 0, 0, 2829, 2830, 6, 137, -1, 0, 2830, 2836, 1, 0, 0, 0, 2831, 2832, 5, 160, 0, 0, 2832, 2833, 3, 32, 16, 0, 2833, 2834, 6, 137, -1, 0, 2834, 2836, 1, 0, 0, 0, 2835, 2823, 1, 0, 0, 0, 2835, 2827, 1, 0, 0, 0, 2835, 2831, 1, 0, 0, 0, 2836, 275, 1, 0, 0, 0, 2837, 2838, 5, 161, 0, 0, 2838, 2839, 3, 124, 62, 0, 2839, 277, 1, 0, 0, 0, 2840, 2841, 5, 162, 0, 0, 2841, 279, 1, 0, 0, 0, 2842, 2843, 5, 163, 0, 0, 2843, 281, 1, 0, 0, 0, 2844, 2845, 3, 264, 132, 0, 2845, 2846, 6, 141, -1, 0, 2846, 2860, 1, 0, 0, 0, 2847, 2848, 5, 164, 0, 0, 2848, 2849, 3, 0, 0, 0, 2849, 2850, 5, 159, 0, 0, 2850, 2851, 3, 0, 0, 0, 2851, 2852, 6, 141, -1, 0, 2852, 2860, 1, 0, 0, 0, 2853, 2854, 5, 164, 0, 0, 2854, 2855, 3, 32, 16, 0, 2855, 2856, 5, 159, 0, 0, 2856, 2857, 3, 32, 16, 0, 2857, 2858, 6, 141, -1, 0, 2858, 2860, 1, 0, 0, 0, 2859, 2844, 1, 0, 0, 0, 2859, 2847, 1, 0, 0, 0, 2859, 2853, 1, 0, 0, 0, 2860, 283, 1, 0, 0, 0, 2861, 2862, 3, 286, 143, 0, 2862, 2863, 3, 290, 145, 0, 2863, 285, 1, 0, 0, 0, 2864, 2865, 5, 165, 0, 0, 2865, 2866, 3, 288, 144, 0, 2866, 2867, 3, 0, 0, 0, 2867, 2868, 5, 36, 0, 0, 2868, 2872, 1, 0, 0, 0, 2869, 2870, 5, 165, 0, 0, 2870, 2872, 3, 288, 144, 0, 2871, 2864, 1, 0, 0, 0, 2871, 2869, 1, 0, 0, 0, 2872, 287, 1, 0, 0, 0, 2873, 2877, 1, 0, 0, 0, 2874, 2877, 5, 166, 0, 0, 2875, 2877, 5, 2, 0, 0, 2876, 2873, 1, 0, 0, 0, 2876, 2874, 1, 0, 0, 0, 2876, 2875, 1, 0, 0, 0, 2877, 289, 1, 0, 0, 0, 2878, 2879, 5, 17, 0, 0, 2879, 2880, 3, 292, 146, 0, 2880, 2881, 5, 18, 0, 0, 2881, 2888, 1, 0, 0, 0, 2882, 2884, 3, 296, 148, 0, 2883, 2882, 1, 0, 0, 0, 2884, 2885, 1, 0, 0, 0, 2885, 2883, 1, 0, 0, 0, 2885, 2886, 1, 0, 0, 0, 2886, 2888, 1, 0, 0, 0, 2887, 2878, 1, 0, 0, 0, 2887, 2883, 1, 0, 0, 0, 2888, 291, 1, 0, 0, 0, 2889, 2890, 3, 296, 148, 0, 2890, 2891, 5, 28, 0, 0, 2891, 2893, 1, 0, 0, 0, 2892, 2889, 1, 0, 0, 0, 2893, 2896, 1, 0, 0, 0, 2894, 2892, 1, 0, 0, 0, 2894, 2895, 1, 0, 0, 0, 2895, 2897, 1, 0, 0, 0, 2896, 2894, 1, 0, 0, 0, 2897, 2898, 3, 296, 148, 0, 2898, 293, 1, 0, 0, 0, 2899, 2905, 1, 0, 0, 0, 2900, 2901, 5, 42, 0, 0, 2901, 2902, 3, 32, 16, 0, 2902, 2903, 5, 43, 0, 0, 2903, 2905, 1, 0, 0, 0, 2904, 2899, 1, 0, 0, 0, 2904, 2900, 1, 0, 0, 0, 2905, 295, 1, 0, 0, 0, 2906, 2907, 5, 181, 0, 0, 2907, 2908, 5, 262, 0, 0, 2908, 2909, 5, 30, 0, 0, 2909, 2910, 3, 6, 3, 0, 2910, 2911, 5, 31, 0, 0, 2911, 2973, 1, 0, 0, 0, 2912, 2913, 5, 260, 0, 0, 2913, 2914, 5, 30, 0, 0, 2914, 2915, 3, 0, 0, 0, 2915, 2916, 5, 31, 0, 0, 2916, 2973, 1, 0, 0, 0, 2917, 2918, 5, 260, 0, 0, 2918, 2973, 3, 0, 0, 0, 2919, 2920, 5, 84, 0, 0, 2920, 2921, 5, 30, 0, 0, 2921, 2922, 3, 300, 150, 0, 2922, 2923, 5, 31, 0, 0, 2923, 2973, 1, 0, 0, 0, 2924, 2925, 5, 188, 0, 0, 2925, 2926, 5, 30, 0, 0, 2926, 2927, 3, 36, 18, 0, 2927, 2928, 5, 31, 0, 0, 2928, 2929, 3, 294, 147, 0, 2929, 2973, 1, 0, 0, 0, 2930, 2931, 5, 189, 0, 0, 2931, 2932, 5, 30, 0, 0, 2932, 2933, 3, 36, 18, 0, 2933, 2934, 5, 31, 0, 0, 2934, 2935, 3, 294, 147, 0, 2935, 2973, 1, 0, 0, 0, 2936, 2937, 5, 187, 0, 0, 2937, 2938, 5, 30, 0, 0, 2938, 2939, 3, 34, 17, 0, 2939, 2940, 5, 31, 0, 0, 2940, 2941, 3, 294, 147, 0, 2941, 2973, 1, 0, 0, 0, 2942, 2943, 5, 186, 0, 0, 2943, 2944, 5, 30, 0, 0, 2944, 2945, 3, 32, 16, 0, 2945, 2946, 5, 31, 0, 0, 2946, 2947, 3, 294, 147, 0, 2947, 2973, 1, 0, 0, 0, 2948, 2949, 5, 185, 0, 0, 2949, 2950, 5, 30, 0, 0, 2950, 2951, 3, 32, 16, 0, 2951, 2952, 5, 31, 0, 0, 2952, 2953, 3, 294, 147, 0, 2953, 2973, 1, 0, 0, 0, 2954, 2955, 5, 184, 0, 0, 2955, 2956, 5, 30, 0, 0, 2956, 2957, 3, 32, 16, 0, 2957, 2958, 5, 31, 0, 0, 2958, 2959, 3, 294, 147, 0, 2959, 2973, 1, 0, 0, 0, 2960, 2961, 5, 188, 0, 0, 2961, 2973, 3, 294, 147, 0, 2962, 2963, 5, 189, 0, 0, 2963, 2973, 3, 294, 147, 0, 2964, 2965, 5, 187, 0, 0, 2965, 2973, 3, 294, 147, 0, 2966, 2967, 5, 186, 0, 0, 2967, 2973, 3, 294, 147, 0, 2968, 2969, 5, 185, 0, 0, 2969, 2973, 3, 294, 147, 0, 2970, 2971, 5, 184, 0, 0, 2971, 2973, 3, 294, 147, 0, 2972, 2906, 1, 0, 0, 0, 2972, 2912, 1, 0, 0, 0, 2972, 2917, 1, 0, 0, 0, 2972, 2919, 1, 0, 0, 0, 2972, 2924, 1, 0, 0, 0, 2972, 2930, 1, 0, 0, 0, 2972, 2936, 1, 0, 0, 0, 2972, 2942, 1, 0, 0, 0, 2972, 2948, 1, 0, 0, 0, 2972, 2954, 1, 0, 0, 0, 2972, 2960, 1, 0, 0, 0, 2972, 2962, 1, 0, 0, 0, 2972, 2964, 1, 0, 0, 0, 2972, 2966, 1, 0, 0, 0, 2972, 2968, 1, 0, 0, 0, 2972, 2970, 1, 0, 0, 0, 2973, 297, 1, 0, 0, 0, 2974, 2975, 5, 188, 0, 0, 2975, 2976, 5, 30, 0, 0, 2976, 2977, 3, 36, 18, 0, 2977, 2978, 5, 31, 0, 0, 2978, 3050, 1, 0, 0, 0, 2979, 2980, 5, 189, 0, 0, 2980, 2981, 5, 30, 0, 0, 2981, 2982, 3, 36, 18, 0, 2982, 2983, 5, 31, 0, 0, 2983, 3050, 1, 0, 0, 0, 2984, 2985, 5, 188, 0, 0, 2985, 2986, 5, 30, 0, 0, 2986, 2987, 3, 32, 16, 0, 2987, 2988, 5, 31, 0, 0, 2988, 3050, 1, 0, 0, 0, 2989, 2990, 5, 189, 0, 0, 2990, 2991, 5, 30, 0, 0, 2991, 2992, 3, 34, 17, 0, 2992, 2993, 5, 31, 0, 0, 2993, 3050, 1, 0, 0, 0, 2994, 2995, 5, 187, 0, 0, 2995, 2996, 5, 30, 0, 0, 2996, 2997, 3, 34, 17, 0, 2997, 2998, 5, 31, 0, 0, 2998, 3050, 1, 0, 0, 0, 2999, 3000, 5, 186, 0, 0, 3000, 3001, 5, 30, 0, 0, 3001, 3002, 3, 32, 16, 0, 3002, 3003, 5, 31, 0, 0, 3003, 3050, 1, 0, 0, 0, 3004, 3005, 5, 185, 0, 0, 3005, 3006, 5, 30, 0, 0, 3006, 3007, 3, 32, 16, 0, 3007, 3008, 5, 31, 0, 0, 3008, 3050, 1, 0, 0, 0, 3009, 3010, 5, 184, 0, 0, 3010, 3011, 5, 30, 0, 0, 3011, 3012, 3, 32, 16, 0, 3012, 3013, 5, 31, 0, 0, 3013, 3050, 1, 0, 0, 0, 3014, 3015, 5, 193, 0, 0, 3015, 3016, 5, 30, 0, 0, 3016, 3017, 3, 34, 17, 0, 3017, 3018, 5, 31, 0, 0, 3018, 3050, 1, 0, 0, 0, 3019, 3020, 5, 192, 0, 0, 3020, 3021, 5, 30, 0, 0, 3021, 3022, 3, 32, 16, 0, 3022, 3023, 5, 31, 0, 0, 3023, 3050, 1, 0, 0, 0, 3024, 3025, 5, 191, 0, 0, 3025, 3026, 5, 30, 0, 0, 3026, 3027, 3, 32, 16, 0, 3027, 3028, 5, 31, 0, 0, 3028, 3050, 1, 0, 0, 0, 3029, 3030, 5, 190, 0, 0, 3030, 3031, 5, 30, 0, 0, 3031, 3032, 3, 32, 16, 0, 3032, 3033, 5, 31, 0, 0, 3033, 3050, 1, 0, 0, 0, 3034, 3035, 5, 181, 0, 0, 3035, 3036, 5, 30, 0, 0, 3036, 3037, 3, 32, 16, 0, 3037, 3038, 5, 31, 0, 0, 3038, 3050, 1, 0, 0, 0, 3039, 3040, 5, 183, 0, 0, 3040, 3041, 5, 30, 0, 0, 3041, 3042, 3, 162, 81, 0, 3042, 3043, 5, 31, 0, 0, 3043, 3050, 1, 0, 0, 0, 3044, 3045, 5, 84, 0, 0, 3045, 3046, 5, 30, 0, 0, 3046, 3047, 3, 300, 150, 0, 3047, 3048, 5, 31, 0, 0, 3048, 3050, 1, 0, 0, 0, 3049, 2974, 1, 0, 0, 0, 3049, 2979, 1, 0, 0, 0, 3049, 2984, 1, 0, 0, 0, 3049, 2989, 1, 0, 0, 0, 3049, 2994, 1, 0, 0, 0, 3049, 2999, 1, 0, 0, 0, 3049, 3004, 1, 0, 0, 0, 3049, 3009, 1, 0, 0, 0, 3049, 3014, 1, 0, 0, 0, 3049, 3019, 1, 0, 0, 0, 3049, 3024, 1, 0, 0, 0, 3049, 3029, 1, 0, 0, 0, 3049, 3034, 1, 0, 0, 0, 3049, 3039, 1, 0, 0, 0, 3049, 3044, 1, 0, 0, 0, 3050, 299, 1, 0, 0, 0, 3051, 3052, 3, 302, 151, 0, 3052, 3053, 6, 150, -1, 0, 3053, 3055, 1, 0, 0, 0, 3054, 3051, 1, 0, 0, 0, 3055, 3058, 1, 0, 0, 0, 3056, 3054, 1, 0, 0, 0, 3056, 3057, 1, 0, 0, 0, 3057, 301, 1, 0, 0, 0, 3058, 3056, 1, 0, 0, 0, 3059, 3060, 7, 10, 0, 0, 3060, 303, 1, 0, 0, 0, 3061, 3065, 3, 298, 149, 0, 3062, 3065, 3, 6, 3, 0, 3063, 3065, 5, 179, 0, 0, 3064, 3061, 1, 0, 0, 0, 3064, 3062, 1, 0, 0, 0, 3064, 3063, 1, 0, 0, 0, 3065, 305, 1, 0, 0, 0, 3066, 3215, 3, 298, 149, 0, 3067, 3068, 5, 182, 0, 0, 3068, 3069, 5, 30, 0, 0, 3069, 3070, 5, 179, 0, 0, 3070, 3215, 5, 31, 0, 0, 3071, 3072, 5, 182, 0, 0, 3072, 3073, 5, 30, 0, 0, 3073, 3074, 5, 264, 0, 0, 3074, 3215, 5, 31, 0, 0, 3075, 3076, 5, 196, 0, 0, 3076, 3077, 5, 30, 0, 0, 3077, 3078, 5, 39, 0, 0, 3078, 3079, 5, 264, 0, 0, 3079, 3215, 5, 31, 0, 0, 3080, 3081, 5, 196, 0, 0, 3081, 3082, 5, 30, 0, 0, 3082, 3083, 3, 116, 58, 0, 3083, 3084, 5, 31, 0, 0, 3084, 3215, 1, 0, 0, 0, 3085, 3086, 5, 196, 0, 0, 3086, 3087, 5, 30, 0, 0, 3087, 3088, 5, 179, 0, 0, 3088, 3215, 5, 31, 0, 0, 3089, 3090, 5, 197, 0, 0, 3090, 3091, 5, 30, 0, 0, 3091, 3092, 3, 306, 153, 0, 3092, 3093, 5, 31, 0, 0, 3093, 3215, 1, 0, 0, 0, 3094, 3095, 5, 188, 0, 0, 3095, 3096, 5, 42, 0, 0, 3096, 3097, 3, 32, 16, 0, 3097, 3098, 5, 43, 0, 0, 3098, 3099, 5, 30, 0, 0, 3099, 3100, 3, 308, 154, 0, 3100, 3101, 5, 31, 0, 0, 3101, 3215, 1, 0, 0, 0, 3102, 3103, 5, 189, 0, 0, 3103, 3104, 5, 42, 0, 0, 3104, 3105, 3, 32, 16, 0, 3105, 3106, 5, 43, 0, 0, 3106, 3107, 5, 30, 0, 0, 3107, 3108, 3, 310, 155, 0, 3108, 3109, 5, 31, 0, 0, 3109, 3215, 1, 0, 0, 0, 3110, 3111, 5, 187, 0, 0, 3111, 3112, 5, 42, 0, 0, 3112, 3113, 3, 32, 16, 0, 3113, 3114, 5, 43, 0, 0, 3114, 3115, 5, 30, 0, 0, 3115, 3116, 3, 312, 156, 0, 3116, 3117, 5, 31, 0, 0, 3117, 3215, 1, 0, 0, 0, 3118, 3119, 5, 186, 0, 0, 3119, 3120, 5, 42, 0, 0, 3120, 3121, 3, 32, 16, 0, 3121, 3122, 5, 43, 0, 0, 3122, 3123, 5, 30, 0, 0, 3123, 3124, 3, 314, 157, 0, 3124, 3125, 5, 31, 0, 0, 3125, 3215, 1, 0, 0, 0, 3126, 3127, 5, 185, 0, 0, 3127, 3128, 5, 42, 0, 0, 3128, 3129, 3, 32, 16, 0, 3129, 3130, 5, 43, 0, 0, 3130, 3131, 5, 30, 0, 0, 3131, 3132, 3, 316, 158, 0, 3132, 3133, 5, 31, 0, 0, 3133, 3215, 1, 0, 0, 0, 3134, 3135, 5, 184, 0, 0, 3135, 3136, 5, 42, 0, 0, 3136, 3137, 3, 32, 16, 0, 3137, 3138, 5, 43, 0, 0, 3138, 3139, 5, 30, 0, 0, 3139, 3140, 3, 318, 159, 0, 3140, 3141, 5, 31, 0, 0, 3141, 3215, 1, 0, 0, 0, 3142, 3143, 5, 193, 0, 0, 3143, 3144, 5, 42, 0, 0, 3144, 3145, 3, 32, 16, 0, 3145, 3146, 5, 43, 0, 0, 3146, 3147, 5, 30, 0, 0, 3147, 3148, 3, 312, 156, 0, 3148, 3149, 5, 31, 0, 0, 3149, 3215, 1, 0, 0, 0, 3150, 3151, 5, 192, 0, 0, 3151, 3152, 5, 42, 0, 0, 3152, 3153, 3, 32, 16, 0, 3153, 3154, 5, 43, 0, 0, 3154, 3155, 5, 30, 0, 0, 3155, 3156, 3, 314, 157, 0, 3156, 3157, 5, 31, 0, 0, 3157, 3215, 1, 0, 0, 0, 3158, 3159, 5, 191, 0, 0, 3159, 3160, 5, 42, 0, 0, 3160, 3161, 3, 32, 16, 0, 3161, 3162, 5, 43, 0, 0, 3162, 3163, 5, 30, 0, 0, 3163, 3164, 3, 316, 158, 0, 3164, 3165, 5, 31, 0, 0, 3165, 3215, 1, 0, 0, 0, 3166, 3167, 5, 190, 0, 0, 3167, 3168, 5, 42, 0, 0, 3168, 3169, 3, 32, 16, 0, 3169, 3170, 5, 43, 0, 0, 3170, 3171, 5, 30, 0, 0, 3171, 3172, 3, 318, 159, 0, 3172, 3173, 5, 31, 0, 0, 3173, 3215, 1, 0, 0, 0, 3174, 3175, 5, 181, 0, 0, 3175, 3176, 5, 42, 0, 0, 3176, 3177, 3, 32, 16, 0, 3177, 3178, 5, 43, 0, 0, 3178, 3179, 5, 30, 0, 0, 3179, 3180, 3, 316, 158, 0, 3180, 3181, 5, 31, 0, 0, 3181, 3215, 1, 0, 0, 0, 3182, 3183, 5, 183, 0, 0, 3183, 3184, 5, 42, 0, 0, 3184, 3185, 3, 32, 16, 0, 3185, 3186, 5, 43, 0, 0, 3186, 3187, 5, 30, 0, 0, 3187, 3188, 3, 320, 160, 0, 3188, 3189, 5, 31, 0, 0, 3189, 3215, 1, 0, 0, 0, 3190, 3191, 5, 182, 0, 0, 3191, 3192, 5, 42, 0, 0, 3192, 3193, 3, 32, 16, 0, 3193, 3194, 5, 43, 0, 0, 3194, 3195, 5, 30, 0, 0, 3195, 3196, 3, 322, 161, 0, 3196, 3197, 5, 31, 0, 0, 3197, 3215, 1, 0, 0, 0, 3198, 3199, 5, 196, 0, 0, 3199, 3200, 5, 42, 0, 0, 3200, 3201, 3, 32, 16, 0, 3201, 3202, 5, 43, 0, 0, 3202, 3203, 5, 30, 0, 0, 3203, 3204, 3, 324, 162, 0, 3204, 3205, 5, 31, 0, 0, 3205, 3215, 1, 0, 0, 0, 3206, 3207, 5, 197, 0, 0, 3207, 3208, 5, 42, 0, 0, 3208, 3209, 3, 32, 16, 0, 3209, 3210, 5, 43, 0, 0, 3210, 3211, 5, 30, 0, 0, 3211, 3212, 3, 328, 164, 0, 3212, 3213, 5, 31, 0, 0, 3213, 3215, 1, 0, 0, 0, 3214, 3066, 1, 0, 0, 0, 3214, 3067, 1, 0, 0, 0, 3214, 3071, 1, 0, 0, 0, 3214, 3075, 1, 0, 0, 0, 3214, 3080, 1, 0, 0, 0, 3214, 3085, 1, 0, 0, 0, 3214, 3089, 1, 0, 0, 0, 3214, 3094, 1, 0, 0, 0, 3214, 3102, 1, 0, 0, 0, 3214, 3110, 1, 0, 0, 0, 3214, 3118, 1, 0, 0, 0, 3214, 3126, 1, 0, 0, 0, 3214, 3134, 1, 0, 0, 0, 3214, 3142, 1, 0, 0, 0, 3214, 3150, 1, 0, 0, 0, 3214, 3158, 1, 0, 0, 0, 3214, 3166, 1, 0, 0, 0, 3214, 3174, 1, 0, 0, 0, 3214, 3182, 1, 0, 0, 0, 3214, 3190, 1, 0, 0, 0, 3214, 3198, 1, 0, 0, 0, 3214, 3206, 1, 0, 0, 0, 3215, 307, 1, 0, 0, 0, 3216, 3219, 3, 36, 18, 0, 3217, 3219, 3, 32, 16, 0, 3218, 3216, 1, 0, 0, 0, 3218, 3217, 1, 0, 0, 0, 3219, 3222, 1, 0, 0, 0, 3220, 3218, 1, 0, 0, 0, 3220, 3221, 1, 0, 0, 0, 3221, 309, 1, 0, 0, 0, 3222, 3220, 1, 0, 0, 0, 3223, 3226, 3, 36, 18, 0, 3224, 3226, 3, 34, 17, 0, 3225, 3223, 1, 0, 0, 0, 3225, 3224, 1, 0, 0, 0, 3226, 3229, 1, 0, 0, 0, 3227, 3225, 1, 0, 0, 0, 3227, 3228, 1, 0, 0, 0, 3228, 311, 1, 0, 0, 0, 3229, 3227, 1, 0, 0, 0, 3230, 3232, 3, 34, 17, 0, 3231, 3230, 1, 0, 0, 0, 3232, 3235, 1, 0, 0, 0, 3233, 3231, 1, 0, 0, 0, 3233, 3234, 1, 0, 0, 0, 3234, 313, 1, 0, 0, 0, 3235, 3233, 1, 0, 0, 0, 3236, 3238, 3, 32, 16, 0, 3237, 3236, 1, 0, 0, 0, 3238, 3241, 1, 0, 0, 0, 3239, 3237, 1, 0, 0, 0, 3239, 3240, 1, 0, 0, 0, 3240, 315, 1, 0, 0, 0, 3241, 3239, 1, 0, 0, 0, 3242, 3244, 3, 32, 16, 0, 3243, 3242, 1, 0, 0, 0, 3244, 3247, 1, 0, 0, 0, 3245, 3243, 1, 0, 0, 0, 3245, 3246, 1, 0, 0, 0, 3246, 317, 1, 0, 0, 0, 3247, 3245, 1, 0, 0, 0, 3248, 3250, 3, 32, 16, 0, 3249, 3248, 1, 0, 0, 0, 3250, 3253, 1, 0, 0, 0, 3251, 3249, 1, 0, 0, 0, 3251, 3252, 1, 0, 0, 0, 3252, 319, 1, 0, 0, 0, 3253, 3251, 1, 0, 0, 0, 3254, 3256, 3, 162, 81, 0, 3255, 3254, 1, 0, 0, 0, 3256, 3259, 1, 0, 0, 0, 3257, 3255, 1, 0, 0, 0, 3257, 3258, 1, 0, 0, 0, 3258, 321, 1, 0, 0, 0, 3259, 3257, 1, 0, 0, 0, 3260, 3262, 7, 11, 0, 0, 3261, 3260, 1, 0, 0, 0, 3262, 3265, 1, 0, 0, 0, 3263, 3261, 1, 0, 0, 0, 3263, 3264, 1, 0, 0, 0, 3264, 323, 1, 0, 0, 0, 3265, 3263, 1, 0, 0, 0, 3266, 3268, 3, 326, 163, 0, 3267, 3266, 1, 0, 0, 0, 3268, 3271, 1, 0, 0, 0, 3269, 3267, 1, 0, 0, 0, 3269, 3270, 1, 0, 0, 0, 3270, 325, 1, 0, 0, 0, 3271, 3269, 1, 0, 0, 0, 3272, 3277, 5, 179, 0, 0, 3273, 3274, 5, 39, 0, 0, 3274, 3277, 5, 264, 0, 0, 3275, 3277, 3, 116, 58, 0, 3276, 3272, 1, 0, 0, 0, 3276, 3273, 1, 0, 0, 0, 3276, 3275, 1, 0, 0, 0, 3277, 327, 1, 0, 0, 0, 3278, 3280, 3, 306, 153, 0, 3279, 3278, 1, 0, 0, 0, 3280, 3283, 1, 0, 0, 0, 3281, 3279, 1, 0, 0, 0, 3281, 3282, 1, 0, 0, 0, 3282, 329, 1, 0, 0, 0, 3283, 3281, 1, 0, 0, 0, 3284, 3288, 3, 44, 22, 0, 3285, 3288, 3, 46, 23, 0, 3286, 3288, 3, 2, 1, 0, 3287, 3284, 1, 0, 0, 0, 3287, 3285, 1, 0, 0, 0, 3287, 3286, 1, 0, 0, 0, 3288, 331, 1, 0, 0, 0, 3289, 3290, 7, 12, 0, 0, 3290, 3291, 5, 36, 0, 0, 3291, 3292, 5, 30, 0, 0, 3292, 3293, 3, 300, 150, 0, 3293, 3294, 5, 31, 0, 0, 3294, 3315, 1, 0, 0, 0, 3295, 3296, 5, 169, 0, 0, 3296, 3297, 3, 38, 19, 0, 3297, 3298, 5, 75, 0, 0, 3298, 3299, 3, 38, 19, 0, 3299, 3300, 5, 75, 0, 0, 3300, 3301, 3, 38, 19, 0, 3301, 3302, 5, 75, 0, 0, 3302, 3303, 3, 38, 19, 0, 3303, 3315, 1, 0, 0, 0, 3304, 3305, 5, 170, 0, 0, 3305, 3315, 3, 6, 3, 0, 3306, 3307, 5, 170, 0, 0, 3307, 3308, 5, 36, 0, 0, 3308, 3309, 5, 30, 0, 0, 3309, 3310, 3, 300, 150, 0, 3310, 3311, 5, 31, 0, 0, 3311, 3315, 1, 0, 0, 0, 3312, 3315, 3, 330, 165, 0, 3313, 3315, 3, 40, 20, 0, 3314, 3289, 1, 0, 0, 0, 3314, 3295, 1, 0, 0, 0, 3314, 3304, 1, 0, 0, 0, 3314, 3306, 1, 0, 0, 0, 3314, 3312, 1, 0, 0, 0, 3314, 3313, 1, 0, 0, 0, 3315, 333, 1, 0, 0, 0, 3316, 3317, 5, 25, 0, 0, 3317, 3318, 5, 40, 0, 0, 3318, 3319, 3, 98, 49, 0, 3319, 3320, 3, 2, 1, 0, 3320, 3329, 1, 0, 0, 0, 3321, 3322, 5, 25, 0, 0, 3322, 3323, 5, 40, 0, 0, 3323, 3324, 3, 98, 49, 0, 3324, 3325, 3, 2, 1, 0, 3325, 3326, 5, 34, 0, 0, 3326, 3327, 3, 2, 1, 0, 3327, 3329, 1, 0, 0, 0, 3328, 3316, 1, 0, 0, 0, 3328, 3321, 1, 0, 0, 0, 3329, 335, 1, 0, 0, 0, 3330, 3332, 3, 338, 169, 0, 3331, 3330, 1, 0, 0, 0, 3332, 3335, 1, 0, 0, 0, 3333, 3331, 1, 0, 0, 0, 3333, 3334, 1, 0, 0, 0, 3334, 337, 1, 0, 0, 0, 3335, 3333, 1, 0, 0, 0, 3336, 3337, 5, 180, 0, 0, 3337, 3338, 5, 36, 0, 0, 3338, 3339, 5, 30, 0, 0, 3339, 3340, 3, 300, 150, 0, 3340, 3341, 5, 31, 0, 0, 3341, 3351, 1, 0, 0, 0, 3342, 3351, 3, 332, 166, 0, 3343, 3344, 5, 171, 0, 0, 3344, 3345, 5, 36, 0, 0, 3345, 3346, 5, 30, 0, 0, 3346, 3347, 3, 300, 150, 0, 3347, 3348, 5, 31, 0, 0, 3348, 3351, 1, 0, 0, 0, 3349, 3351, 5, 55, 0, 0, 3350, 3336, 1, 0, 0, 0, 3350, 3342, 1, 0, 0, 0, 3350, 3343, 1, 0, 0, 0, 3350, 3349, 1, 0, 0, 0, 3351, 339, 1, 0, 0, 0, 3352, 3353, 5, 50, 0, 0, 3353, 3357, 5, 40, 0, 0, 3354, 3356, 3, 344, 172, 0, 3355, 3354, 1, 0, 0, 0, 3356, 3359, 1, 0, 0, 0, 3357, 3355, 1, 0, 0, 0, 3357, 3358, 1, 0, 0, 0, 3358, 3360, 1, 0, 0, 0, 3359, 3357, 1, 0, 0, 0, 3360, 3361, 3, 2, 1, 0, 3361, 341, 1, 0, 0, 0, 3362, 3366, 5, 301, 0, 0, 3363, 3365, 3, 344, 172, 0, 3364, 3363, 1, 0, 0, 0, 3365, 3368, 1, 0, 0, 0, 3366, 3364, 1, 0, 0, 0, 3366, 3367, 1, 0, 0, 0, 3367, 3369, 1, 0, 0, 0, 3368, 3366, 1, 0, 0, 0, 3369, 3370, 3, 2, 1, 0, 3370, 343, 1, 0, 0, 0, 3371, 3387, 5, 52, 0, 0, 3372, 3387, 5, 51, 0, 0, 3373, 3387, 5, 172, 0, 0, 3374, 3375, 5, 62, 0, 0, 3375, 3387, 5, 51, 0, 0, 3376, 3377, 5, 62, 0, 0, 3377, 3387, 5, 52, 0, 0, 3378, 3379, 5, 62, 0, 0, 3379, 3387, 5, 63, 0, 0, 3380, 3381, 5, 62, 0, 0, 3381, 3387, 5, 64, 0, 0, 3382, 3383, 5, 62, 0, 0, 3383, 3387, 5, 65, 0, 0, 3384, 3385, 5, 62, 0, 0, 3385, 3387, 5, 66, 0, 0, 3386, 3371, 1, 0, 0, 0, 3386, 3372, 1, 0, 0, 0, 3386, 3373, 1, 0, 0, 0, 3386, 3374, 1, 0, 0, 0, 3386, 3376, 1, 0, 0, 0, 3386, 3378, 1, 0, 0, 0, 3386, 3380, 1, 0, 0, 0, 3386, 3382, 1, 0, 0, 0, 3386, 3384, 1, 0, 0, 0, 3387, 345, 1, 0, 0, 0, 3388, 3390, 3, 348, 174, 0, 3389, 3388, 1, 0, 0, 0, 3390, 3393, 1, 0, 0, 0, 3391, 3389, 1, 0, 0, 0, 3391, 3392, 1, 0, 0, 0, 3392, 347, 1, 0, 0, 0, 3393, 3391, 1, 0, 0, 0, 3394, 3395, 5, 21, 0, 0, 3395, 3408, 3, 2, 1, 0, 3396, 3397, 5, 50, 0, 0, 3397, 3398, 5, 40, 0, 0, 3398, 3408, 3, 118, 59, 0, 3399, 3400, 5, 25, 0, 0, 3400, 3401, 5, 40, 0, 0, 3401, 3408, 3, 2, 1, 0, 3402, 3408, 3, 174, 87, 0, 3403, 3404, 5, 50, 0, 0, 3404, 3408, 3, 32, 16, 0, 3405, 3408, 3, 330, 165, 0, 3406, 3408, 3, 40, 20, 0, 3407, 3394, 1, 0, 0, 0, 3407, 3396, 1, 0, 0, 0, 3407, 3399, 1, 0, 0, 0, 3407, 3402, 1, 0, 0, 0, 3407, 3403, 1, 0, 0, 0, 3407, 3405, 1, 0, 0, 0, 3407, 3406, 1, 0, 0, 0, 3408, 349, 1, 0, 0, 0, 3409, 3413, 5, 274, 0, 0, 3410, 3412, 3, 352, 176, 0, 3411, 3410, 1, 0, 0, 0, 3412, 3415, 1, 0, 0, 0, 3413, 3411, 1, 0, 0, 0, 3413, 3414, 1, 0, 0, 0, 3414, 3416, 1, 0, 0, 0, 3415, 3413, 1, 0, 0, 0, 3416, 3429, 3, 2, 1, 0, 3417, 3421, 5, 274, 0, 0, 3418, 3420, 3, 352, 176, 0, 3419, 3418, 1, 0, 0, 0, 3420, 3423, 1, 0, 0, 0, 3421, 3419, 1, 0, 0, 0, 3421, 3422, 1, 0, 0, 0, 3422, 3424, 1, 0, 0, 0, 3423, 3421, 1, 0, 0, 0, 3424, 3425, 3, 2, 1, 0, 3425, 3426, 5, 34, 0, 0, 3426, 3427, 3, 2, 1, 0, 3427, 3429, 1, 0, 0, 0, 3428, 3409, 1, 0, 0, 0, 3428, 3417, 1, 0, 0, 0, 3429, 351, 1, 0, 0, 0, 3430, 3431, 7, 13, 0, 0, 3431, 353, 1, 0, 0, 0, 3432, 3434, 3, 356, 178, 0, 3433, 3432, 1, 0, 0, 0, 3434, 3437, 1, 0, 0, 0, 3435, 3433, 1, 0, 0, 0, 3435, 3436, 1, 0, 0, 0, 3436, 355, 1, 0, 0, 0, 3437, 3435, 1, 0, 0, 0, 3438, 3439, 5, 21, 0, 0, 3439, 3440, 3, 2, 1, 0, 3440, 3441, 5, 44, 0, 0, 3441, 3442, 3, 32, 16, 0, 3442, 3449, 1, 0, 0, 0, 3443, 3444, 5, 25, 0, 0, 3444, 3445, 5, 40, 0, 0, 3445, 3449, 3, 2, 1, 0, 3446, 3449, 3, 330, 165, 0, 3447, 3449, 3, 40, 20, 0, 3448, 3438, 1, 0, 0, 0, 3448, 3443, 1, 0, 0, 0, 3448, 3446, 1, 0, 0, 0, 3448, 3447, 1, 0, 0, 0, 3449, 357, 1, 0, 0, 0, 181, 368, 376, 385, 394, 447, 488, 497, 527, 531, 549, 576, 599, 635, 645, 652, 654, 664, 666, 673, 684, 692, 713, 715, 731, 776, 781, 786, 791, 799, 909, 915, 931, 937, 943, 950, 978, 1056, 1058, 1072, 1078, 1087, 1089, 1098, 1112, 1126, 1134, 1142, 1146, 1185, 1193, 1202, 1210, 1229, 1239, 1242, 1266, 1413, 1423, 1432, 1435, 1517, 1526, 1558, 1618, 1658, 1674, 1684, 1711, 1735, 1743, 1747, 1762, 1769, 1814, 1824, 1842, 1860, 1879, 1900, 1919, 1934, 1942, 1954, 1974, 1981, 1986, 1997, 2009, 2119, 2131, 2147, 2161, 2170, 2183, 2185, 2228, 2239, 2246, 2254, 2262, 2275, 2281, 2287, 2292, 2321, 2329, 2343, 2348, 2373, 2382, 2393, 2397, 2404, 2424, 2433, 2435, 2450, 2497, 2507, 2509, 2516, 2522, 2566, 2575, 2615, 2620, 2660, 2664, 2674, 2696, 2708, 2719, 2734, 2747, 2760, 2763, 2771, 2785, 2803, 2821, 2835, 2859, 2871, 2876, 2885, 2887, 2894, 2904, 2972, 3049, 3056, 3064, 3214, 3218, 3220, 3225, 3227, 3233, 3239, 3245, 3251, 3257, 3263, 3269, 3276, 3281, 3287, 3314, 3328, 3333, 3350, 3357, 3366, 3386, 3391, 3407, 3413, 3421, 3428, 3435, 3448] \ No newline at end of file +[4, 1, 305, 3557, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 373, 8, 1, 10, 1, 12, 1, 376, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 383, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 5, 3, 390, 8, 3, 10, 3, 12, 3, 393, 9, 3, 1, 3, 1, 3, 1, 3, 1, 4, 5, 4, 399, 8, 4, 10, 4, 12, 4, 402, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 490, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 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, 536, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 5, 15, 545, 8, 15, 10, 15, 12, 15, 548, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 577, 8, 18, 1, 19, 1, 19, 3, 19, 581, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 599, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 626, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 649, 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, 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, 685, 8, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 695, 8, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 5, 27, 702, 8, 27, 10, 27, 12, 27, 705, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 714, 8, 28, 10, 28, 12, 28, 717, 9, 28, 1, 29, 1, 29, 1, 30, 1, 30, 3, 30, 723, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 734, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 747, 8, 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, 34, 1, 34, 1, 34, 1, 34, 5, 34, 768, 8, 34, 10, 34, 12, 34, 771, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 5, 37, 787, 8, 37, 10, 37, 12, 37, 790, 9, 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, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 862, 8, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 869, 8, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 876, 8, 40, 1, 41, 5, 41, 879, 8, 41, 10, 41, 12, 41, 882, 9, 41, 1, 42, 1, 42, 1, 42, 1, 42, 5, 42, 888, 8, 42, 10, 42, 12, 42, 891, 9, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 1001, 8, 44, 1, 45, 1, 45, 5, 45, 1005, 8, 45, 10, 45, 12, 45, 1008, 9, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 1021, 8, 45, 10, 45, 12, 45, 1024, 9, 45, 1, 45, 1, 45, 1, 45, 3, 45, 1029, 8, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 1035, 8, 47, 1, 48, 1, 48, 1, 49, 5, 49, 1040, 8, 49, 10, 49, 12, 49, 1043, 9, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 1070, 8, 50, 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, 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, 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, 1148, 8, 51, 3, 51, 1150, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1164, 8, 53, 1, 53, 1, 53, 5, 53, 1168, 8, 53, 10, 53, 12, 53, 1171, 9, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1179, 8, 53, 3, 53, 1181, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1188, 8, 54, 10, 54, 12, 54, 1191, 9, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1202, 8, 55, 10, 55, 12, 55, 1205, 9, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 5, 56, 1216, 8, 56, 10, 56, 12, 56, 1219, 9, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1226, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 1234, 8, 57, 1, 57, 1, 57, 3, 57, 1238, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1277, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 1283, 8, 59, 10, 59, 12, 59, 1286, 9, 59, 1, 59, 1, 59, 1, 59, 1, 60, 5, 60, 1292, 8, 60, 10, 60, 12, 60, 1295, 9, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1302, 8, 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, 3, 62, 1321, 8, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 5, 63, 1329, 8, 63, 10, 63, 12, 63, 1332, 9, 63, 3, 63, 1334, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 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, 1358, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1505, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1515, 8, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 5, 67, 1522, 8, 67, 10, 67, 12, 67, 1525, 9, 67, 3, 67, 1527, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1609, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 5, 69, 1616, 8, 69, 10, 69, 12, 69, 1619, 9, 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, 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, 1650, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1710, 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, 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, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1750, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1766, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1776, 8, 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, 3, 76, 1803, 8, 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, 1827, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 5, 77, 1833, 8, 77, 10, 77, 12, 77, 1836, 9, 77, 1, 77, 3, 77, 1839, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1854, 8, 78, 1, 79, 1, 79, 1, 79, 5, 79, 1859, 8, 79, 10, 79, 12, 79, 1862, 9, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1906, 8, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1916, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1934, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1952, 8, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1971, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1992, 8, 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, 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 2011, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 2026, 8, 89, 1, 90, 1, 90, 1, 90, 1, 90, 5, 90, 2032, 8, 90, 10, 90, 12, 90, 2035, 9, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 2046, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 2066, 8, 92, 1, 93, 1, 93, 1, 93, 5, 93, 2071, 8, 93, 10, 93, 12, 93, 2074, 9, 93, 1, 94, 1, 94, 3, 94, 2078, 8, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 5, 95, 2087, 8, 95, 10, 95, 12, 95, 2090, 9, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 3, 97, 2101, 8, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2209, 8, 99, 10, 99, 12, 99, 2212, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2221, 8, 99, 10, 99, 12, 99, 2224, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2237, 8, 99, 10, 99, 12, 99, 2240, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2251, 8, 99, 10, 99, 12, 99, 2254, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 2262, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 2275, 8, 100, 10, 100, 12, 100, 2278, 9, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 2320, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 2331, 8, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 3, 103, 2338, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 2346, 8, 104, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2352, 8, 105, 10, 105, 12, 105, 2355, 9, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2365, 8, 105, 10, 105, 12, 105, 2368, 9, 105, 1, 105, 1, 105, 1, 105, 3, 105, 2373, 8, 105, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 2379, 8, 106, 1, 107, 5, 107, 2382, 8, 107, 10, 107, 12, 107, 2385, 9, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 2413, 8, 108, 1, 109, 1, 109, 1, 109, 1, 109, 5, 109, 2419, 8, 109, 10, 109, 12, 109, 2422, 9, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 2435, 8, 110, 1, 111, 5, 111, 2438, 8, 111, 10, 111, 12, 111, 2441, 9, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 2465, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 2474, 8, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 4, 114, 2483, 8, 114, 11, 114, 12, 114, 2484, 1, 114, 1, 114, 3, 114, 2489, 8, 114, 1, 115, 1, 115, 1, 115, 5, 115, 2494, 8, 115, 10, 115, 12, 115, 2497, 9, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 2516, 8, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2525, 8, 117, 10, 117, 12, 117, 2528, 9, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2540, 8, 117, 10, 117, 12, 117, 2543, 9, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2589, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2599, 8, 119, 3, 119, 2601, 8, 119, 1, 119, 1, 119, 1, 119, 5, 119, 2606, 8, 119, 10, 119, 12, 119, 2609, 9, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2614, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2658, 8, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 2667, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2707, 8, 122, 1, 123, 5, 123, 2710, 8, 123, 10, 123, 12, 123, 2713, 9, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2752, 8, 124, 1, 125, 1, 125, 3, 125, 2756, 8, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, 2766, 8, 126, 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, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 2788, 8, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2798, 8, 129, 10, 129, 12, 129, 2801, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2809, 8, 129, 10, 129, 12, 129, 2812, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2824, 8, 129, 10, 129, 12, 129, 2827, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2837, 8, 129, 10, 129, 12, 129, 2840, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2850, 8, 129, 10, 129, 12, 129, 2853, 9, 129, 3, 129, 2855, 8, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 3, 131, 2863, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 4, 134, 2875, 8, 134, 11, 134, 12, 134, 2876, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 3, 135, 2895, 8, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 3, 136, 2913, 8, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 2927, 8, 137, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 2951, 8, 141, 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 2963, 8, 143, 1, 144, 1, 144, 1, 144, 3, 144, 2968, 8, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 4, 145, 2975, 8, 145, 11, 145, 12, 145, 2976, 3, 145, 2979, 8, 145, 1, 146, 1, 146, 1, 146, 5, 146, 2984, 8, 146, 10, 146, 12, 146, 2987, 9, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 2996, 8, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 3, 148, 3064, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 3141, 8, 149, 1, 150, 1, 150, 1, 150, 5, 150, 3146, 8, 150, 10, 150, 12, 150, 3149, 9, 150, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 3, 152, 3156, 8, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 3, 153, 3306, 8, 153, 1, 154, 1, 154, 5, 154, 3310, 8, 154, 10, 154, 12, 154, 3313, 9, 154, 1, 155, 1, 155, 5, 155, 3317, 8, 155, 10, 155, 12, 155, 3320, 9, 155, 1, 156, 5, 156, 3323, 8, 156, 10, 156, 12, 156, 3326, 9, 156, 1, 157, 5, 157, 3329, 8, 157, 10, 157, 12, 157, 3332, 9, 157, 1, 158, 5, 158, 3335, 8, 158, 10, 158, 12, 158, 3338, 9, 158, 1, 159, 5, 159, 3341, 8, 159, 10, 159, 12, 159, 3344, 9, 159, 1, 160, 5, 160, 3347, 8, 160, 10, 160, 12, 160, 3350, 9, 160, 1, 161, 5, 161, 3353, 8, 161, 10, 161, 12, 161, 3356, 9, 161, 1, 162, 5, 162, 3359, 8, 162, 10, 162, 12, 162, 3362, 9, 162, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 3368, 8, 163, 1, 164, 5, 164, 3371, 8, 164, 10, 164, 12, 164, 3374, 9, 164, 1, 165, 1, 165, 1, 165, 3, 165, 3379, 8, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 3, 166, 3406, 8, 166, 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, 168, 3, 168, 3425, 8, 168, 1, 169, 5, 169, 3428, 8, 169, 10, 169, 12, 169, 3431, 9, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 3447, 8, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 5, 172, 3457, 8, 172, 10, 172, 12, 172, 3460, 9, 172, 1, 172, 1, 172, 1, 173, 1, 173, 5, 173, 3466, 8, 173, 10, 173, 12, 173, 3469, 9, 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, 3, 174, 3488, 8, 174, 1, 175, 5, 175, 3491, 8, 175, 10, 175, 12, 175, 3494, 9, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 3, 176, 3509, 8, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 178, 1, 178, 5, 178, 3518, 8, 178, 10, 178, 12, 178, 3521, 9, 178, 1, 178, 1, 178, 1, 178, 5, 178, 3526, 8, 178, 10, 178, 12, 178, 3529, 9, 178, 1, 178, 1, 178, 1, 178, 1, 178, 3, 178, 3535, 8, 178, 1, 179, 1, 179, 1, 180, 5, 180, 3540, 8, 180, 10, 180, 12, 180, 3543, 9, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 3, 181, 3555, 8, 181, 1, 181, 0, 1, 68, 182, 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, 0, 14, 6, 0, 1, 15, 199, 199, 243, 243, 247, 247, 264, 264, 289, 289, 5, 0, 16, 16, 199, 199, 243, 243, 264, 264, 288, 289, 1, 0, 263, 264, 1, 0, 173, 174, 1, 0, 37, 38, 1, 0, 73, 74, 3, 0, 2, 2, 61, 61, 77, 83, 2, 0, 229, 229, 260, 261, 1, 0, 95, 96, 1, 0, 97, 111, 2, 0, 173, 173, 289, 290, 2, 0, 179, 179, 264, 264, 1, 0, 167, 168, 1, 0, 51, 52, 4018, 0, 364, 1, 0, 0, 0, 2, 382, 1, 0, 0, 0, 4, 384, 1, 0, 0, 0, 6, 391, 1, 0, 0, 0, 8, 400, 1, 0, 0, 0, 10, 489, 1, 0, 0, 0, 12, 491, 1, 0, 0, 0, 14, 495, 1, 0, 0, 0, 16, 499, 1, 0, 0, 0, 18, 504, 1, 0, 0, 0, 20, 508, 1, 0, 0, 0, 22, 512, 1, 0, 0, 0, 24, 519, 1, 0, 0, 0, 26, 535, 1, 0, 0, 0, 28, 537, 1, 0, 0, 0, 30, 539, 1, 0, 0, 0, 32, 551, 1, 0, 0, 0, 34, 553, 1, 0, 0, 0, 36, 576, 1, 0, 0, 0, 38, 580, 1, 0, 0, 0, 40, 598, 1, 0, 0, 0, 42, 625, 1, 0, 0, 0, 44, 648, 1, 0, 0, 0, 46, 684, 1, 0, 0, 0, 48, 686, 1, 0, 0, 0, 50, 694, 1, 0, 0, 0, 52, 696, 1, 0, 0, 0, 54, 703, 1, 0, 0, 0, 56, 715, 1, 0, 0, 0, 58, 718, 1, 0, 0, 0, 60, 720, 1, 0, 0, 0, 62, 733, 1, 0, 0, 0, 64, 746, 1, 0, 0, 0, 66, 748, 1, 0, 0, 0, 68, 756, 1, 0, 0, 0, 70, 772, 1, 0, 0, 0, 72, 778, 1, 0, 0, 0, 74, 782, 1, 0, 0, 0, 76, 861, 1, 0, 0, 0, 78, 868, 1, 0, 0, 0, 80, 875, 1, 0, 0, 0, 82, 880, 1, 0, 0, 0, 84, 889, 1, 0, 0, 0, 86, 895, 1, 0, 0, 0, 88, 1000, 1, 0, 0, 0, 90, 1028, 1, 0, 0, 0, 92, 1030, 1, 0, 0, 0, 94, 1034, 1, 0, 0, 0, 96, 1036, 1, 0, 0, 0, 98, 1041, 1, 0, 0, 0, 100, 1069, 1, 0, 0, 0, 102, 1149, 1, 0, 0, 0, 104, 1151, 1, 0, 0, 0, 106, 1180, 1, 0, 0, 0, 108, 1182, 1, 0, 0, 0, 110, 1196, 1, 0, 0, 0, 112, 1225, 1, 0, 0, 0, 114, 1237, 1, 0, 0, 0, 116, 1276, 1, 0, 0, 0, 118, 1284, 1, 0, 0, 0, 120, 1293, 1, 0, 0, 0, 122, 1301, 1, 0, 0, 0, 124, 1320, 1, 0, 0, 0, 126, 1333, 1, 0, 0, 0, 128, 1357, 1, 0, 0, 0, 130, 1504, 1, 0, 0, 0, 132, 1514, 1, 0, 0, 0, 134, 1526, 1, 0, 0, 0, 136, 1608, 1, 0, 0, 0, 138, 1610, 1, 0, 0, 0, 140, 1649, 1, 0, 0, 0, 142, 1709, 1, 0, 0, 0, 144, 1749, 1, 0, 0, 0, 146, 1765, 1, 0, 0, 0, 148, 1767, 1, 0, 0, 0, 150, 1771, 1, 0, 0, 0, 152, 1826, 1, 0, 0, 0, 154, 1838, 1, 0, 0, 0, 156, 1853, 1, 0, 0, 0, 158, 1860, 1, 0, 0, 0, 160, 1865, 1, 0, 0, 0, 162, 1869, 1, 0, 0, 0, 164, 1905, 1, 0, 0, 0, 166, 1907, 1, 0, 0, 0, 168, 1951, 1, 0, 0, 0, 170, 1970, 1, 0, 0, 0, 172, 1991, 1, 0, 0, 0, 174, 1993, 1, 0, 0, 0, 176, 2010, 1, 0, 0, 0, 178, 2025, 1, 0, 0, 0, 180, 2033, 1, 0, 0, 0, 182, 2045, 1, 0, 0, 0, 184, 2065, 1, 0, 0, 0, 186, 2072, 1, 0, 0, 0, 188, 2075, 1, 0, 0, 0, 190, 2088, 1, 0, 0, 0, 192, 2094, 1, 0, 0, 0, 194, 2100, 1, 0, 0, 0, 196, 2104, 1, 0, 0, 0, 198, 2261, 1, 0, 0, 0, 200, 2263, 1, 0, 0, 0, 202, 2319, 1, 0, 0, 0, 204, 2330, 1, 0, 0, 0, 206, 2337, 1, 0, 0, 0, 208, 2345, 1, 0, 0, 0, 210, 2372, 1, 0, 0, 0, 212, 2378, 1, 0, 0, 0, 214, 2383, 1, 0, 0, 0, 216, 2412, 1, 0, 0, 0, 218, 2414, 1, 0, 0, 0, 220, 2434, 1, 0, 0, 0, 222, 2439, 1, 0, 0, 0, 224, 2464, 1, 0, 0, 0, 226, 2473, 1, 0, 0, 0, 228, 2488, 1, 0, 0, 0, 230, 2495, 1, 0, 0, 0, 232, 2515, 1, 0, 0, 0, 234, 2517, 1, 0, 0, 0, 236, 2588, 1, 0, 0, 0, 238, 2613, 1, 0, 0, 0, 240, 2657, 1, 0, 0, 0, 242, 2666, 1, 0, 0, 0, 244, 2706, 1, 0, 0, 0, 246, 2711, 1, 0, 0, 0, 248, 2751, 1, 0, 0, 0, 250, 2753, 1, 0, 0, 0, 252, 2759, 1, 0, 0, 0, 254, 2767, 1, 0, 0, 0, 256, 2787, 1, 0, 0, 0, 258, 2854, 1, 0, 0, 0, 260, 2856, 1, 0, 0, 0, 262, 2862, 1, 0, 0, 0, 264, 2864, 1, 0, 0, 0, 266, 2868, 1, 0, 0, 0, 268, 2874, 1, 0, 0, 0, 270, 2894, 1, 0, 0, 0, 272, 2912, 1, 0, 0, 0, 274, 2926, 1, 0, 0, 0, 276, 2928, 1, 0, 0, 0, 278, 2931, 1, 0, 0, 0, 280, 2933, 1, 0, 0, 0, 282, 2950, 1, 0, 0, 0, 284, 2952, 1, 0, 0, 0, 286, 2962, 1, 0, 0, 0, 288, 2967, 1, 0, 0, 0, 290, 2978, 1, 0, 0, 0, 292, 2985, 1, 0, 0, 0, 294, 2995, 1, 0, 0, 0, 296, 3063, 1, 0, 0, 0, 298, 3140, 1, 0, 0, 0, 300, 3147, 1, 0, 0, 0, 302, 3150, 1, 0, 0, 0, 304, 3155, 1, 0, 0, 0, 306, 3305, 1, 0, 0, 0, 308, 3311, 1, 0, 0, 0, 310, 3318, 1, 0, 0, 0, 312, 3324, 1, 0, 0, 0, 314, 3330, 1, 0, 0, 0, 316, 3336, 1, 0, 0, 0, 318, 3342, 1, 0, 0, 0, 320, 3348, 1, 0, 0, 0, 322, 3354, 1, 0, 0, 0, 324, 3360, 1, 0, 0, 0, 326, 3367, 1, 0, 0, 0, 328, 3372, 1, 0, 0, 0, 330, 3378, 1, 0, 0, 0, 332, 3405, 1, 0, 0, 0, 334, 3407, 1, 0, 0, 0, 336, 3424, 1, 0, 0, 0, 338, 3429, 1, 0, 0, 0, 340, 3446, 1, 0, 0, 0, 342, 3448, 1, 0, 0, 0, 344, 3453, 1, 0, 0, 0, 346, 3463, 1, 0, 0, 0, 348, 3487, 1, 0, 0, 0, 350, 3492, 1, 0, 0, 0, 352, 3508, 1, 0, 0, 0, 354, 3510, 1, 0, 0, 0, 356, 3534, 1, 0, 0, 0, 358, 3536, 1, 0, 0, 0, 360, 3541, 1, 0, 0, 0, 362, 3554, 1, 0, 0, 0, 364, 365, 7, 0, 0, 0, 365, 1, 1, 0, 0, 0, 366, 367, 5, 288, 0, 0, 367, 383, 6, 1, -1, 0, 368, 369, 3, 4, 2, 0, 369, 370, 6, 1, -1, 0, 370, 371, 5, 265, 0, 0, 371, 373, 1, 0, 0, 0, 372, 368, 1, 0, 0, 0, 373, 376, 1, 0, 0, 0, 374, 372, 1, 0, 0, 0, 374, 375, 1, 0, 0, 0, 375, 377, 1, 0, 0, 0, 376, 374, 1, 0, 0, 0, 377, 378, 3, 4, 2, 0, 378, 379, 6, 1, -1, 0, 379, 383, 1, 0, 0, 0, 380, 381, 5, 264, 0, 0, 381, 383, 6, 1, -1, 0, 382, 366, 1, 0, 0, 0, 382, 374, 1, 0, 0, 0, 382, 380, 1, 0, 0, 0, 383, 3, 1, 0, 0, 0, 384, 385, 7, 1, 0, 0, 385, 5, 1, 0, 0, 0, 386, 387, 5, 263, 0, 0, 387, 388, 6, 3, -1, 0, 388, 390, 5, 266, 0, 0, 389, 386, 1, 0, 0, 0, 390, 393, 1, 0, 0, 0, 391, 389, 1, 0, 0, 0, 391, 392, 1, 0, 0, 0, 392, 394, 1, 0, 0, 0, 393, 391, 1, 0, 0, 0, 394, 395, 5, 263, 0, 0, 395, 396, 6, 3, -1, 0, 396, 7, 1, 0, 0, 0, 397, 399, 3, 10, 5, 0, 398, 397, 1, 0, 0, 0, 399, 402, 1, 0, 0, 0, 400, 398, 1, 0, 0, 0, 400, 401, 1, 0, 0, 0, 401, 9, 1, 0, 0, 0, 402, 400, 1, 0, 0, 0, 403, 404, 3, 74, 37, 0, 404, 405, 5, 17, 0, 0, 405, 406, 3, 82, 41, 0, 406, 407, 5, 18, 0, 0, 407, 490, 1, 0, 0, 0, 408, 409, 3, 72, 36, 0, 409, 410, 5, 17, 0, 0, 410, 411, 3, 8, 4, 0, 411, 412, 5, 18, 0, 0, 412, 490, 1, 0, 0, 0, 413, 414, 3, 234, 117, 0, 414, 415, 5, 17, 0, 0, 415, 416, 3, 246, 123, 0, 416, 417, 5, 18, 0, 0, 417, 490, 1, 0, 0, 0, 418, 490, 3, 200, 100, 0, 419, 420, 6, 5, -1, 0, 420, 421, 3, 284, 142, 0, 421, 422, 6, 5, -1, 0, 422, 490, 1, 0, 0, 0, 423, 424, 6, 5, -1, 0, 424, 425, 3, 70, 35, 0, 425, 426, 6, 5, -1, 0, 426, 490, 1, 0, 0, 0, 427, 428, 6, 5, -1, 0, 428, 429, 3, 66, 33, 0, 429, 430, 6, 5, -1, 0, 430, 490, 1, 0, 0, 0, 431, 432, 6, 5, -1, 0, 432, 433, 3, 88, 44, 0, 433, 434, 6, 5, -1, 0, 434, 490, 1, 0, 0, 0, 435, 436, 6, 5, -1, 0, 436, 437, 3, 90, 45, 0, 437, 438, 6, 5, -1, 0, 438, 490, 1, 0, 0, 0, 439, 440, 6, 5, -1, 0, 440, 441, 3, 22, 11, 0, 441, 442, 6, 5, -1, 0, 442, 490, 1, 0, 0, 0, 443, 444, 6, 5, -1, 0, 444, 445, 3, 334, 167, 0, 445, 446, 6, 5, -1, 0, 446, 490, 1, 0, 0, 0, 447, 448, 6, 5, -1, 0, 448, 449, 3, 342, 171, 0, 449, 450, 6, 5, -1, 0, 450, 490, 1, 0, 0, 0, 451, 452, 6, 5, -1, 0, 452, 453, 3, 354, 177, 0, 453, 454, 6, 5, -1, 0, 454, 490, 1, 0, 0, 0, 455, 456, 6, 5, -1, 0, 456, 457, 3, 64, 32, 0, 457, 458, 6, 5, -1, 0, 458, 490, 1, 0, 0, 0, 459, 460, 6, 5, -1, 0, 460, 461, 3, 152, 76, 0, 461, 462, 6, 5, -1, 0, 462, 490, 1, 0, 0, 0, 463, 464, 3, 330, 165, 0, 464, 465, 6, 5, -1, 0, 465, 490, 1, 0, 0, 0, 466, 467, 6, 5, -1, 0, 467, 490, 3, 12, 6, 0, 468, 469, 6, 5, -1, 0, 469, 490, 3, 14, 7, 0, 470, 471, 6, 5, -1, 0, 471, 490, 3, 16, 8, 0, 472, 473, 6, 5, -1, 0, 473, 490, 3, 18, 9, 0, 474, 475, 6, 5, -1, 0, 475, 490, 3, 20, 10, 0, 476, 477, 6, 5, -1, 0, 477, 478, 3, 26, 13, 0, 478, 479, 6, 5, -1, 0, 479, 490, 1, 0, 0, 0, 480, 481, 6, 5, -1, 0, 481, 482, 3, 42, 21, 0, 482, 483, 6, 5, -1, 0, 483, 490, 1, 0, 0, 0, 484, 485, 6, 5, -1, 0, 485, 490, 3, 40, 20, 0, 486, 490, 3, 30, 15, 0, 487, 488, 6, 5, -1, 0, 488, 490, 3, 24, 12, 0, 489, 403, 1, 0, 0, 0, 489, 408, 1, 0, 0, 0, 489, 413, 1, 0, 0, 0, 489, 418, 1, 0, 0, 0, 489, 419, 1, 0, 0, 0, 489, 423, 1, 0, 0, 0, 489, 427, 1, 0, 0, 0, 489, 431, 1, 0, 0, 0, 489, 435, 1, 0, 0, 0, 489, 439, 1, 0, 0, 0, 489, 443, 1, 0, 0, 0, 489, 447, 1, 0, 0, 0, 489, 451, 1, 0, 0, 0, 489, 455, 1, 0, 0, 0, 489, 459, 1, 0, 0, 0, 489, 463, 1, 0, 0, 0, 489, 466, 1, 0, 0, 0, 489, 468, 1, 0, 0, 0, 489, 470, 1, 0, 0, 0, 489, 472, 1, 0, 0, 0, 489, 474, 1, 0, 0, 0, 489, 476, 1, 0, 0, 0, 489, 480, 1, 0, 0, 0, 489, 484, 1, 0, 0, 0, 489, 486, 1, 0, 0, 0, 489, 487, 1, 0, 0, 0, 490, 11, 1, 0, 0, 0, 491, 492, 5, 19, 0, 0, 492, 493, 3, 32, 16, 0, 493, 494, 6, 6, -1, 0, 494, 13, 1, 0, 0, 0, 495, 496, 5, 20, 0, 0, 496, 497, 3, 32, 16, 0, 497, 498, 6, 7, -1, 0, 498, 15, 1, 0, 0, 0, 499, 500, 5, 21, 0, 0, 500, 501, 5, 22, 0, 0, 501, 502, 3, 32, 16, 0, 502, 503, 6, 8, -1, 0, 503, 17, 1, 0, 0, 0, 504, 505, 5, 23, 0, 0, 505, 506, 3, 34, 17, 0, 506, 507, 6, 9, -1, 0, 507, 19, 1, 0, 0, 0, 508, 509, 5, 24, 0, 0, 509, 510, 3, 34, 17, 0, 510, 511, 6, 10, -1, 0, 511, 21, 1, 0, 0, 0, 512, 513, 5, 25, 0, 0, 513, 514, 3, 98, 49, 0, 514, 515, 3, 2, 1, 0, 515, 516, 5, 17, 0, 0, 516, 517, 3, 120, 60, 0, 517, 518, 5, 18, 0, 0, 518, 23, 1, 0, 0, 0, 519, 520, 5, 26, 0, 0, 520, 25, 1, 0, 0, 0, 521, 522, 5, 27, 0, 0, 522, 536, 3, 28, 14, 0, 523, 524, 5, 27, 0, 0, 524, 525, 3, 28, 14, 0, 525, 526, 5, 28, 0, 0, 526, 527, 3, 28, 14, 0, 527, 536, 1, 0, 0, 0, 528, 529, 5, 27, 0, 0, 529, 530, 3, 28, 14, 0, 530, 531, 5, 28, 0, 0, 531, 532, 3, 28, 14, 0, 532, 533, 5, 28, 0, 0, 533, 534, 3, 28, 14, 0, 534, 536, 1, 0, 0, 0, 535, 521, 1, 0, 0, 0, 535, 523, 1, 0, 0, 0, 535, 528, 1, 0, 0, 0, 536, 27, 1, 0, 0, 0, 537, 538, 7, 2, 0, 0, 538, 29, 1, 0, 0, 0, 539, 540, 5, 29, 0, 0, 540, 546, 5, 17, 0, 0, 541, 542, 3, 116, 58, 0, 542, 543, 6, 15, -1, 0, 543, 545, 1, 0, 0, 0, 544, 541, 1, 0, 0, 0, 545, 548, 1, 0, 0, 0, 546, 544, 1, 0, 0, 0, 546, 547, 1, 0, 0, 0, 547, 549, 1, 0, 0, 0, 548, 546, 1, 0, 0, 0, 549, 550, 5, 18, 0, 0, 550, 31, 1, 0, 0, 0, 551, 552, 5, 173, 0, 0, 552, 33, 1, 0, 0, 0, 553, 554, 7, 3, 0, 0, 554, 35, 1, 0, 0, 0, 555, 556, 5, 175, 0, 0, 556, 577, 6, 18, -1, 0, 557, 558, 3, 32, 16, 0, 558, 559, 5, 265, 0, 0, 559, 560, 6, 18, -1, 0, 560, 577, 1, 0, 0, 0, 561, 562, 3, 32, 16, 0, 562, 563, 6, 18, -1, 0, 563, 577, 1, 0, 0, 0, 564, 565, 5, 188, 0, 0, 565, 566, 5, 30, 0, 0, 566, 567, 3, 32, 16, 0, 567, 568, 5, 31, 0, 0, 568, 569, 6, 18, -1, 0, 569, 577, 1, 0, 0, 0, 570, 571, 5, 189, 0, 0, 571, 572, 5, 30, 0, 0, 572, 573, 3, 34, 17, 0, 573, 574, 5, 31, 0, 0, 574, 575, 6, 18, -1, 0, 575, 577, 1, 0, 0, 0, 576, 555, 1, 0, 0, 0, 576, 557, 1, 0, 0, 0, 576, 561, 1, 0, 0, 0, 576, 564, 1, 0, 0, 0, 576, 570, 1, 0, 0, 0, 577, 37, 1, 0, 0, 0, 578, 581, 3, 32, 16, 0, 579, 581, 5, 262, 0, 0, 580, 578, 1, 0, 0, 0, 580, 579, 1, 0, 0, 0, 581, 39, 1, 0, 0, 0, 582, 583, 5, 267, 0, 0, 583, 599, 5, 289, 0, 0, 584, 585, 5, 267, 0, 0, 585, 586, 5, 289, 0, 0, 586, 599, 5, 263, 0, 0, 587, 588, 5, 268, 0, 0, 588, 599, 5, 289, 0, 0, 589, 590, 5, 269, 0, 0, 590, 599, 5, 289, 0, 0, 591, 592, 5, 270, 0, 0, 592, 599, 5, 289, 0, 0, 593, 599, 5, 271, 0, 0, 594, 599, 5, 272, 0, 0, 595, 596, 5, 273, 0, 0, 596, 599, 5, 263, 0, 0, 597, 599, 5, 32, 0, 0, 598, 582, 1, 0, 0, 0, 598, 584, 1, 0, 0, 0, 598, 587, 1, 0, 0, 0, 598, 589, 1, 0, 0, 0, 598, 591, 1, 0, 0, 0, 598, 593, 1, 0, 0, 0, 598, 594, 1, 0, 0, 0, 598, 595, 1, 0, 0, 0, 598, 597, 1, 0, 0, 0, 599, 41, 1, 0, 0, 0, 600, 601, 5, 33, 0, 0, 601, 602, 3, 138, 69, 0, 602, 603, 5, 34, 0, 0, 603, 604, 3, 2, 1, 0, 604, 626, 1, 0, 0, 0, 605, 606, 5, 33, 0, 0, 606, 607, 3, 116, 58, 0, 607, 608, 5, 34, 0, 0, 608, 609, 3, 2, 1, 0, 609, 626, 1, 0, 0, 0, 610, 611, 5, 33, 0, 0, 611, 612, 3, 176, 88, 0, 612, 613, 5, 34, 0, 0, 613, 614, 3, 2, 1, 0, 614, 626, 1, 0, 0, 0, 615, 616, 5, 33, 0, 0, 616, 617, 3, 44, 22, 0, 617, 618, 5, 34, 0, 0, 618, 619, 3, 2, 1, 0, 619, 626, 1, 0, 0, 0, 620, 621, 5, 33, 0, 0, 621, 622, 3, 46, 23, 0, 622, 623, 5, 34, 0, 0, 623, 624, 3, 2, 1, 0, 624, 626, 1, 0, 0, 0, 625, 600, 1, 0, 0, 0, 625, 605, 1, 0, 0, 0, 625, 610, 1, 0, 0, 0, 625, 615, 1, 0, 0, 0, 625, 620, 1, 0, 0, 0, 626, 43, 1, 0, 0, 0, 627, 628, 5, 35, 0, 0, 628, 649, 3, 48, 24, 0, 629, 630, 5, 35, 0, 0, 630, 631, 3, 48, 24, 0, 631, 632, 5, 36, 0, 0, 632, 633, 3, 6, 3, 0, 633, 649, 1, 0, 0, 0, 634, 635, 5, 35, 0, 0, 635, 636, 3, 48, 24, 0, 636, 637, 5, 36, 0, 0, 637, 638, 5, 17, 0, 0, 638, 639, 3, 52, 26, 0, 639, 640, 5, 18, 0, 0, 640, 649, 1, 0, 0, 0, 641, 642, 5, 35, 0, 0, 642, 643, 3, 48, 24, 0, 643, 644, 5, 36, 0, 0, 644, 645, 5, 30, 0, 0, 645, 646, 3, 300, 150, 0, 646, 647, 5, 31, 0, 0, 647, 649, 1, 0, 0, 0, 648, 627, 1, 0, 0, 0, 648, 629, 1, 0, 0, 0, 648, 634, 1, 0, 0, 0, 648, 641, 1, 0, 0, 0, 649, 45, 1, 0, 0, 0, 650, 651, 5, 35, 0, 0, 651, 652, 5, 30, 0, 0, 652, 653, 3, 50, 25, 0, 653, 654, 5, 31, 0, 0, 654, 655, 3, 48, 24, 0, 655, 685, 1, 0, 0, 0, 656, 657, 5, 35, 0, 0, 657, 658, 5, 30, 0, 0, 658, 659, 3, 50, 25, 0, 659, 660, 5, 31, 0, 0, 660, 661, 3, 48, 24, 0, 661, 662, 5, 36, 0, 0, 662, 663, 3, 6, 3, 0, 663, 685, 1, 0, 0, 0, 664, 665, 5, 35, 0, 0, 665, 666, 5, 30, 0, 0, 666, 667, 3, 50, 25, 0, 667, 668, 5, 31, 0, 0, 668, 669, 3, 48, 24, 0, 669, 670, 5, 36, 0, 0, 670, 671, 5, 17, 0, 0, 671, 672, 3, 52, 26, 0, 672, 673, 5, 18, 0, 0, 673, 685, 1, 0, 0, 0, 674, 675, 5, 35, 0, 0, 675, 676, 5, 30, 0, 0, 676, 677, 3, 50, 25, 0, 677, 678, 5, 31, 0, 0, 678, 679, 3, 48, 24, 0, 679, 680, 5, 36, 0, 0, 680, 681, 5, 30, 0, 0, 681, 682, 3, 300, 150, 0, 682, 683, 5, 31, 0, 0, 683, 685, 1, 0, 0, 0, 684, 650, 1, 0, 0, 0, 684, 656, 1, 0, 0, 0, 684, 664, 1, 0, 0, 0, 684, 674, 1, 0, 0, 0, 685, 47, 1, 0, 0, 0, 686, 687, 3, 168, 84, 0, 687, 49, 1, 0, 0, 0, 688, 689, 3, 124, 62, 0, 689, 690, 6, 25, -1, 0, 690, 695, 1, 0, 0, 0, 691, 692, 3, 176, 88, 0, 692, 693, 6, 25, -1, 0, 693, 695, 1, 0, 0, 0, 694, 688, 1, 0, 0, 0, 694, 691, 1, 0, 0, 0, 695, 51, 1, 0, 0, 0, 696, 697, 3, 54, 27, 0, 697, 698, 3, 56, 28, 0, 698, 53, 1, 0, 0, 0, 699, 702, 3, 306, 153, 0, 700, 702, 3, 40, 20, 0, 701, 699, 1, 0, 0, 0, 701, 700, 1, 0, 0, 0, 702, 705, 1, 0, 0, 0, 703, 701, 1, 0, 0, 0, 703, 704, 1, 0, 0, 0, 704, 55, 1, 0, 0, 0, 705, 703, 1, 0, 0, 0, 706, 707, 3, 58, 29, 0, 707, 708, 3, 60, 30, 0, 708, 709, 3, 2, 1, 0, 709, 710, 5, 36, 0, 0, 710, 711, 3, 306, 153, 0, 711, 714, 1, 0, 0, 0, 712, 714, 3, 40, 20, 0, 713, 706, 1, 0, 0, 0, 713, 712, 1, 0, 0, 0, 714, 717, 1, 0, 0, 0, 715, 713, 1, 0, 0, 0, 715, 716, 1, 0, 0, 0, 716, 57, 1, 0, 0, 0, 717, 715, 1, 0, 0, 0, 718, 719, 7, 4, 0, 0, 719, 59, 1, 0, 0, 0, 720, 722, 3, 62, 31, 0, 721, 723, 5, 261, 0, 0, 722, 721, 1, 0, 0, 0, 722, 723, 1, 0, 0, 0, 723, 61, 1, 0, 0, 0, 724, 734, 3, 144, 72, 0, 725, 734, 3, 2, 1, 0, 726, 734, 5, 196, 0, 0, 727, 734, 5, 197, 0, 0, 728, 729, 5, 202, 0, 0, 729, 730, 5, 39, 0, 0, 730, 734, 5, 264, 0, 0, 731, 732, 5, 202, 0, 0, 732, 734, 3, 116, 58, 0, 733, 724, 1, 0, 0, 0, 733, 725, 1, 0, 0, 0, 733, 726, 1, 0, 0, 0, 733, 727, 1, 0, 0, 0, 733, 728, 1, 0, 0, 0, 733, 731, 1, 0, 0, 0, 734, 63, 1, 0, 0, 0, 735, 736, 5, 198, 0, 0, 736, 737, 5, 40, 0, 0, 737, 738, 3, 2, 1, 0, 738, 739, 6, 32, -1, 0, 739, 747, 1, 0, 0, 0, 740, 741, 5, 198, 0, 0, 741, 742, 3, 2, 1, 0, 742, 743, 6, 32, -1, 0, 743, 747, 1, 0, 0, 0, 744, 745, 5, 198, 0, 0, 745, 747, 6, 32, -1, 0, 746, 735, 1, 0, 0, 0, 746, 740, 1, 0, 0, 0, 746, 744, 1, 0, 0, 0, 747, 65, 1, 0, 0, 0, 748, 749, 5, 41, 0, 0, 749, 750, 5, 42, 0, 0, 750, 751, 3, 32, 16, 0, 751, 752, 5, 43, 0, 0, 752, 753, 3, 68, 34, 0, 753, 754, 5, 44, 0, 0, 754, 755, 3, 0, 0, 0, 755, 67, 1, 0, 0, 0, 756, 769, 6, 34, -1, 0, 757, 758, 10, 5, 0, 0, 758, 768, 5, 186, 0, 0, 759, 760, 10, 4, 0, 0, 760, 768, 5, 187, 0, 0, 761, 762, 10, 3, 0, 0, 762, 768, 5, 45, 0, 0, 763, 764, 10, 2, 0, 0, 764, 768, 5, 46, 0, 0, 765, 766, 10, 1, 0, 0, 766, 768, 5, 47, 0, 0, 767, 757, 1, 0, 0, 0, 767, 759, 1, 0, 0, 0, 767, 761, 1, 0, 0, 0, 767, 763, 1, 0, 0, 0, 767, 765, 1, 0, 0, 0, 768, 771, 1, 0, 0, 0, 769, 767, 1, 0, 0, 0, 769, 770, 1, 0, 0, 0, 770, 69, 1, 0, 0, 0, 771, 769, 1, 0, 0, 0, 772, 773, 5, 48, 0, 0, 773, 774, 5, 36, 0, 0, 774, 775, 5, 30, 0, 0, 775, 776, 3, 300, 150, 0, 776, 777, 5, 31, 0, 0, 777, 71, 1, 0, 0, 0, 778, 779, 5, 49, 0, 0, 779, 780, 3, 2, 1, 0, 780, 781, 6, 36, -1, 0, 781, 73, 1, 0, 0, 0, 782, 788, 5, 50, 0, 0, 783, 784, 3, 76, 38, 0, 784, 785, 6, 37, -1, 0, 785, 787, 1, 0, 0, 0, 786, 783, 1, 0, 0, 0, 787, 790, 1, 0, 0, 0, 788, 786, 1, 0, 0, 0, 788, 789, 1, 0, 0, 0, 789, 791, 1, 0, 0, 0, 790, 788, 1, 0, 0, 0, 791, 792, 3, 2, 1, 0, 792, 793, 3, 182, 91, 0, 793, 794, 3, 78, 39, 0, 794, 795, 3, 80, 40, 0, 795, 796, 6, 37, -1, 0, 796, 75, 1, 0, 0, 0, 797, 798, 5, 51, 0, 0, 798, 862, 6, 38, -1, 0, 799, 800, 5, 52, 0, 0, 800, 862, 6, 38, -1, 0, 801, 802, 5, 199, 0, 0, 802, 862, 6, 38, -1, 0, 803, 804, 5, 202, 0, 0, 804, 862, 6, 38, -1, 0, 805, 806, 5, 221, 0, 0, 806, 862, 6, 38, -1, 0, 807, 808, 5, 53, 0, 0, 808, 862, 6, 38, -1, 0, 809, 810, 5, 54, 0, 0, 810, 862, 6, 38, -1, 0, 811, 812, 5, 55, 0, 0, 812, 862, 6, 38, -1, 0, 813, 814, 5, 56, 0, 0, 814, 862, 6, 38, -1, 0, 815, 816, 5, 244, 0, 0, 816, 862, 6, 38, -1, 0, 817, 818, 5, 15, 0, 0, 818, 862, 6, 38, -1, 0, 819, 820, 5, 224, 0, 0, 820, 862, 6, 38, -1, 0, 821, 822, 5, 57, 0, 0, 822, 862, 6, 38, -1, 0, 823, 824, 5, 58, 0, 0, 824, 862, 6, 38, -1, 0, 825, 826, 5, 59, 0, 0, 826, 862, 6, 38, -1, 0, 827, 828, 5, 60, 0, 0, 828, 862, 6, 38, -1, 0, 829, 830, 5, 61, 0, 0, 830, 862, 6, 38, -1, 0, 831, 832, 5, 62, 0, 0, 832, 833, 5, 51, 0, 0, 833, 862, 6, 38, -1, 0, 834, 835, 5, 62, 0, 0, 835, 836, 5, 52, 0, 0, 836, 862, 6, 38, -1, 0, 837, 838, 5, 62, 0, 0, 838, 839, 5, 63, 0, 0, 839, 862, 6, 38, -1, 0, 840, 841, 5, 62, 0, 0, 841, 842, 5, 64, 0, 0, 842, 862, 6, 38, -1, 0, 843, 844, 5, 62, 0, 0, 844, 845, 5, 65, 0, 0, 845, 862, 6, 38, -1, 0, 846, 847, 5, 62, 0, 0, 847, 848, 5, 66, 0, 0, 848, 862, 6, 38, -1, 0, 849, 850, 5, 67, 0, 0, 850, 862, 6, 38, -1, 0, 851, 852, 5, 68, 0, 0, 852, 862, 6, 38, -1, 0, 853, 854, 5, 69, 0, 0, 854, 862, 6, 38, -1, 0, 855, 856, 5, 70, 0, 0, 856, 857, 5, 30, 0, 0, 857, 858, 3, 32, 16, 0, 858, 859, 5, 31, 0, 0, 859, 860, 6, 38, -1, 0, 860, 862, 1, 0, 0, 0, 861, 797, 1, 0, 0, 0, 861, 799, 1, 0, 0, 0, 861, 801, 1, 0, 0, 0, 861, 803, 1, 0, 0, 0, 861, 805, 1, 0, 0, 0, 861, 807, 1, 0, 0, 0, 861, 809, 1, 0, 0, 0, 861, 811, 1, 0, 0, 0, 861, 813, 1, 0, 0, 0, 861, 815, 1, 0, 0, 0, 861, 817, 1, 0, 0, 0, 861, 819, 1, 0, 0, 0, 861, 821, 1, 0, 0, 0, 861, 823, 1, 0, 0, 0, 861, 825, 1, 0, 0, 0, 861, 827, 1, 0, 0, 0, 861, 829, 1, 0, 0, 0, 861, 831, 1, 0, 0, 0, 861, 834, 1, 0, 0, 0, 861, 837, 1, 0, 0, 0, 861, 840, 1, 0, 0, 0, 861, 843, 1, 0, 0, 0, 861, 846, 1, 0, 0, 0, 861, 849, 1, 0, 0, 0, 861, 851, 1, 0, 0, 0, 861, 853, 1, 0, 0, 0, 861, 855, 1, 0, 0, 0, 862, 77, 1, 0, 0, 0, 863, 869, 1, 0, 0, 0, 864, 865, 5, 71, 0, 0, 865, 866, 3, 124, 62, 0, 866, 867, 6, 39, -1, 0, 867, 869, 1, 0, 0, 0, 868, 863, 1, 0, 0, 0, 868, 864, 1, 0, 0, 0, 869, 79, 1, 0, 0, 0, 870, 876, 1, 0, 0, 0, 871, 872, 5, 72, 0, 0, 872, 873, 3, 84, 42, 0, 873, 874, 6, 40, -1, 0, 874, 876, 1, 0, 0, 0, 875, 870, 1, 0, 0, 0, 875, 871, 1, 0, 0, 0, 876, 81, 1, 0, 0, 0, 877, 879, 3, 198, 99, 0, 878, 877, 1, 0, 0, 0, 879, 882, 1, 0, 0, 0, 880, 878, 1, 0, 0, 0, 880, 881, 1, 0, 0, 0, 881, 83, 1, 0, 0, 0, 882, 880, 1, 0, 0, 0, 883, 884, 3, 124, 62, 0, 884, 885, 6, 42, -1, 0, 885, 886, 5, 28, 0, 0, 886, 888, 1, 0, 0, 0, 887, 883, 1, 0, 0, 0, 888, 891, 1, 0, 0, 0, 889, 887, 1, 0, 0, 0, 889, 890, 1, 0, 0, 0, 890, 892, 1, 0, 0, 0, 891, 889, 1, 0, 0, 0, 892, 893, 3, 124, 62, 0, 893, 894, 6, 42, -1, 0, 894, 85, 1, 0, 0, 0, 895, 896, 7, 5, 0, 0, 896, 87, 1, 0, 0, 0, 897, 898, 3, 86, 43, 0, 898, 899, 3, 32, 16, 0, 899, 900, 5, 264, 0, 0, 900, 1001, 1, 0, 0, 0, 901, 902, 3, 86, 43, 0, 902, 903, 3, 32, 16, 0, 903, 1001, 1, 0, 0, 0, 904, 905, 3, 86, 43, 0, 905, 906, 3, 32, 16, 0, 906, 907, 5, 75, 0, 0, 907, 908, 3, 32, 16, 0, 908, 909, 5, 264, 0, 0, 909, 1001, 1, 0, 0, 0, 910, 911, 3, 86, 43, 0, 911, 912, 3, 32, 16, 0, 912, 913, 5, 75, 0, 0, 913, 914, 3, 32, 16, 0, 914, 1001, 1, 0, 0, 0, 915, 916, 3, 86, 43, 0, 916, 917, 3, 32, 16, 0, 917, 918, 5, 75, 0, 0, 918, 919, 3, 32, 16, 0, 919, 920, 5, 28, 0, 0, 920, 921, 3, 32, 16, 0, 921, 922, 5, 264, 0, 0, 922, 1001, 1, 0, 0, 0, 923, 924, 3, 86, 43, 0, 924, 925, 3, 32, 16, 0, 925, 926, 5, 75, 0, 0, 926, 927, 3, 32, 16, 0, 927, 928, 5, 28, 0, 0, 928, 929, 3, 32, 16, 0, 929, 1001, 1, 0, 0, 0, 930, 931, 3, 86, 43, 0, 931, 932, 3, 32, 16, 0, 932, 933, 5, 28, 0, 0, 933, 934, 3, 32, 16, 0, 934, 935, 5, 75, 0, 0, 935, 936, 3, 32, 16, 0, 936, 937, 5, 264, 0, 0, 937, 1001, 1, 0, 0, 0, 938, 939, 3, 86, 43, 0, 939, 940, 3, 32, 16, 0, 940, 941, 5, 28, 0, 0, 941, 942, 3, 32, 16, 0, 942, 943, 5, 75, 0, 0, 943, 944, 3, 32, 16, 0, 944, 1001, 1, 0, 0, 0, 945, 946, 3, 86, 43, 0, 946, 947, 3, 32, 16, 0, 947, 948, 5, 28, 0, 0, 948, 949, 3, 32, 16, 0, 949, 950, 5, 75, 0, 0, 950, 951, 3, 32, 16, 0, 951, 952, 5, 28, 0, 0, 952, 953, 3, 32, 16, 0, 953, 954, 5, 264, 0, 0, 954, 1001, 1, 0, 0, 0, 955, 956, 3, 86, 43, 0, 956, 957, 3, 32, 16, 0, 957, 958, 5, 28, 0, 0, 958, 959, 3, 32, 16, 0, 959, 960, 5, 75, 0, 0, 960, 961, 3, 32, 16, 0, 961, 962, 5, 28, 0, 0, 962, 963, 3, 32, 16, 0, 963, 1001, 1, 0, 0, 0, 964, 965, 3, 86, 43, 0, 965, 966, 3, 32, 16, 0, 966, 967, 5, 263, 0, 0, 967, 1001, 1, 0, 0, 0, 968, 969, 3, 86, 43, 0, 969, 970, 3, 32, 16, 0, 970, 971, 5, 75, 0, 0, 971, 972, 3, 32, 16, 0, 972, 973, 5, 263, 0, 0, 973, 1001, 1, 0, 0, 0, 974, 975, 3, 86, 43, 0, 975, 976, 3, 32, 16, 0, 976, 977, 5, 75, 0, 0, 977, 978, 3, 32, 16, 0, 978, 979, 5, 28, 0, 0, 979, 980, 3, 32, 16, 0, 980, 981, 5, 263, 0, 0, 981, 1001, 1, 0, 0, 0, 982, 983, 3, 86, 43, 0, 983, 984, 3, 32, 16, 0, 984, 985, 5, 28, 0, 0, 985, 986, 3, 32, 16, 0, 986, 987, 5, 75, 0, 0, 987, 988, 3, 32, 16, 0, 988, 989, 5, 263, 0, 0, 989, 1001, 1, 0, 0, 0, 990, 991, 3, 86, 43, 0, 991, 992, 3, 32, 16, 0, 992, 993, 5, 28, 0, 0, 993, 994, 3, 32, 16, 0, 994, 995, 5, 75, 0, 0, 995, 996, 3, 32, 16, 0, 996, 997, 5, 28, 0, 0, 997, 998, 3, 32, 16, 0, 998, 999, 5, 263, 0, 0, 999, 1001, 1, 0, 0, 0, 1000, 897, 1, 0, 0, 0, 1000, 901, 1, 0, 0, 0, 1000, 904, 1, 0, 0, 0, 1000, 910, 1, 0, 0, 0, 1000, 915, 1, 0, 0, 0, 1000, 923, 1, 0, 0, 0, 1000, 930, 1, 0, 0, 0, 1000, 938, 1, 0, 0, 0, 1000, 945, 1, 0, 0, 0, 1000, 955, 1, 0, 0, 0, 1000, 964, 1, 0, 0, 0, 1000, 968, 1, 0, 0, 0, 1000, 974, 1, 0, 0, 0, 1000, 982, 1, 0, 0, 0, 1000, 990, 1, 0, 0, 0, 1001, 89, 1, 0, 0, 0, 1002, 1006, 5, 21, 0, 0, 1003, 1005, 3, 92, 46, 0, 1004, 1003, 1, 0, 0, 0, 1005, 1008, 1, 0, 0, 0, 1006, 1004, 1, 0, 0, 0, 1006, 1007, 1, 0, 0, 0, 1007, 1009, 1, 0, 0, 0, 1008, 1006, 1, 0, 0, 0, 1009, 1010, 3, 2, 1, 0, 1010, 1011, 3, 94, 47, 0, 1011, 1012, 5, 180, 0, 0, 1012, 1013, 5, 36, 0, 0, 1013, 1014, 5, 30, 0, 0, 1014, 1015, 3, 300, 150, 0, 1015, 1016, 5, 31, 0, 0, 1016, 1017, 3, 94, 47, 0, 1017, 1029, 1, 0, 0, 0, 1018, 1022, 5, 21, 0, 0, 1019, 1021, 3, 92, 46, 0, 1020, 1019, 1, 0, 0, 0, 1021, 1024, 1, 0, 0, 0, 1022, 1020, 1, 0, 0, 0, 1022, 1023, 1, 0, 0, 0, 1023, 1025, 1, 0, 0, 0, 1024, 1022, 1, 0, 0, 0, 1025, 1026, 3, 2, 1, 0, 1026, 1027, 3, 94, 47, 0, 1027, 1029, 1, 0, 0, 0, 1028, 1002, 1, 0, 0, 0, 1028, 1018, 1, 0, 0, 0, 1029, 91, 1, 0, 0, 0, 1030, 1031, 5, 76, 0, 0, 1031, 93, 1, 0, 0, 0, 1032, 1035, 1, 0, 0, 0, 1033, 1035, 5, 298, 0, 0, 1034, 1032, 1, 0, 0, 0, 1034, 1033, 1, 0, 0, 0, 1035, 95, 1, 0, 0, 0, 1036, 1037, 7, 6, 0, 0, 1037, 97, 1, 0, 0, 0, 1038, 1040, 3, 96, 48, 0, 1039, 1038, 1, 0, 0, 0, 1040, 1043, 1, 0, 0, 0, 1041, 1039, 1, 0, 0, 0, 1041, 1042, 1, 0, 0, 0, 1042, 99, 1, 0, 0, 0, 1043, 1041, 1, 0, 0, 0, 1044, 1070, 3, 102, 51, 0, 1045, 1046, 5, 280, 0, 0, 1046, 1047, 3, 168, 84, 0, 1047, 1048, 6, 50, -1, 0, 1048, 1070, 1, 0, 0, 0, 1049, 1050, 5, 286, 0, 0, 1050, 1051, 3, 178, 89, 0, 1051, 1052, 6, 50, -1, 0, 1052, 1070, 1, 0, 0, 0, 1053, 1054, 5, 286, 0, 0, 1054, 1055, 3, 174, 87, 0, 1055, 1056, 6, 50, -1, 0, 1056, 1070, 1, 0, 0, 0, 1057, 1058, 5, 284, 0, 0, 1058, 1059, 3, 124, 62, 0, 1059, 1060, 6, 50, -1, 0, 1060, 1070, 1, 0, 0, 0, 1061, 1062, 5, 281, 0, 0, 1062, 1063, 3, 104, 52, 0, 1063, 1064, 6, 50, -1, 0, 1064, 1070, 1, 0, 0, 0, 1065, 1066, 5, 287, 0, 0, 1066, 1067, 3, 50, 25, 0, 1067, 1068, 6, 50, -1, 0, 1068, 1070, 1, 0, 0, 0, 1069, 1044, 1, 0, 0, 0, 1069, 1045, 1, 0, 0, 0, 1069, 1049, 1, 0, 0, 0, 1069, 1053, 1, 0, 0, 0, 1069, 1057, 1, 0, 0, 0, 1069, 1061, 1, 0, 0, 0, 1069, 1065, 1, 0, 0, 0, 1070, 101, 1, 0, 0, 0, 1071, 1072, 5, 275, 0, 0, 1072, 1150, 6, 51, -1, 0, 1073, 1074, 5, 276, 0, 0, 1074, 1075, 3, 32, 16, 0, 1075, 1076, 6, 51, -1, 0, 1076, 1150, 1, 0, 0, 0, 1077, 1078, 5, 276, 0, 0, 1078, 1079, 3, 0, 0, 0, 1079, 1080, 6, 51, -1, 0, 1080, 1150, 1, 0, 0, 0, 1081, 1082, 5, 277, 0, 0, 1082, 1083, 3, 32, 16, 0, 1083, 1084, 6, 51, -1, 0, 1084, 1150, 1, 0, 0, 0, 1085, 1086, 5, 278, 0, 0, 1086, 1087, 3, 34, 17, 0, 1087, 1088, 6, 51, -1, 0, 1088, 1150, 1, 0, 0, 0, 1089, 1090, 5, 279, 0, 0, 1090, 1091, 3, 36, 18, 0, 1091, 1092, 6, 51, -1, 0, 1092, 1150, 1, 0, 0, 0, 1093, 1094, 5, 279, 0, 0, 1094, 1095, 3, 34, 17, 0, 1095, 1096, 6, 51, -1, 0, 1096, 1150, 1, 0, 0, 0, 1097, 1098, 5, 279, 0, 0, 1098, 1099, 5, 30, 0, 0, 1099, 1100, 3, 300, 150, 0, 1100, 1101, 5, 31, 0, 0, 1101, 1102, 6, 51, -1, 0, 1102, 1150, 1, 0, 0, 0, 1103, 1104, 5, 279, 0, 0, 1104, 1105, 5, 84, 0, 0, 1105, 1106, 5, 30, 0, 0, 1106, 1107, 3, 300, 150, 0, 1107, 1108, 5, 31, 0, 0, 1108, 1109, 6, 51, -1, 0, 1109, 1150, 1, 0, 0, 0, 1110, 1111, 5, 282, 0, 0, 1111, 1112, 3, 32, 16, 0, 1112, 1113, 6, 51, -1, 0, 1113, 1150, 1, 0, 0, 0, 1114, 1115, 5, 282, 0, 0, 1115, 1116, 3, 0, 0, 0, 1116, 1117, 6, 51, -1, 0, 1117, 1150, 1, 0, 0, 0, 1118, 1119, 5, 285, 0, 0, 1119, 1120, 3, 6, 3, 0, 1120, 1121, 6, 51, -1, 0, 1121, 1150, 1, 0, 0, 0, 1122, 1123, 5, 285, 0, 0, 1123, 1124, 5, 224, 0, 0, 1124, 1125, 5, 30, 0, 0, 1125, 1126, 3, 6, 3, 0, 1126, 1127, 5, 31, 0, 0, 1127, 1128, 6, 51, -1, 0, 1128, 1150, 1, 0, 0, 0, 1129, 1130, 5, 285, 0, 0, 1130, 1131, 5, 84, 0, 0, 1131, 1132, 5, 30, 0, 0, 1132, 1133, 3, 300, 150, 0, 1133, 1134, 5, 31, 0, 0, 1134, 1135, 6, 51, -1, 0, 1135, 1150, 1, 0, 0, 0, 1136, 1137, 5, 287, 0, 0, 1137, 1138, 3, 32, 16, 0, 1138, 1139, 6, 51, -1, 0, 1139, 1150, 1, 0, 0, 0, 1140, 1141, 5, 283, 0, 0, 1141, 1147, 6, 51, -1, 0, 1142, 1143, 5, 30, 0, 0, 1143, 1144, 3, 106, 53, 0, 1144, 1145, 5, 31, 0, 0, 1145, 1148, 1, 0, 0, 0, 1146, 1148, 5, 85, 0, 0, 1147, 1142, 1, 0, 0, 0, 1147, 1146, 1, 0, 0, 0, 1148, 1150, 1, 0, 0, 0, 1149, 1071, 1, 0, 0, 0, 1149, 1073, 1, 0, 0, 0, 1149, 1077, 1, 0, 0, 0, 1149, 1081, 1, 0, 0, 0, 1149, 1085, 1, 0, 0, 0, 1149, 1089, 1, 0, 0, 0, 1149, 1093, 1, 0, 0, 0, 1149, 1097, 1, 0, 0, 0, 1149, 1103, 1, 0, 0, 0, 1149, 1110, 1, 0, 0, 0, 1149, 1114, 1, 0, 0, 0, 1149, 1118, 1, 0, 0, 0, 1149, 1122, 1, 0, 0, 0, 1149, 1129, 1, 0, 0, 0, 1149, 1136, 1, 0, 0, 0, 1149, 1140, 1, 0, 0, 0, 1150, 103, 1, 0, 0, 0, 1151, 1152, 3, 170, 85, 0, 1152, 1153, 3, 138, 69, 0, 1153, 1154, 3, 112, 56, 0, 1154, 1155, 6, 52, -1, 0, 1155, 105, 1, 0, 0, 0, 1156, 1181, 1, 0, 0, 0, 1157, 1158, 3, 0, 0, 0, 1158, 1159, 6, 53, -1, 0, 1159, 1164, 1, 0, 0, 0, 1160, 1161, 3, 32, 16, 0, 1161, 1162, 6, 53, -1, 0, 1162, 1164, 1, 0, 0, 0, 1163, 1157, 1, 0, 0, 0, 1163, 1160, 1, 0, 0, 0, 1164, 1165, 1, 0, 0, 0, 1165, 1166, 5, 28, 0, 0, 1166, 1168, 1, 0, 0, 0, 1167, 1163, 1, 0, 0, 0, 1168, 1171, 1, 0, 0, 0, 1169, 1167, 1, 0, 0, 0, 1169, 1170, 1, 0, 0, 0, 1170, 1178, 1, 0, 0, 0, 1171, 1169, 1, 0, 0, 0, 1172, 1173, 3, 0, 0, 0, 1173, 1174, 6, 53, -1, 0, 1174, 1179, 1, 0, 0, 0, 1175, 1176, 3, 32, 16, 0, 1176, 1177, 6, 53, -1, 0, 1177, 1179, 1, 0, 0, 0, 1178, 1172, 1, 0, 0, 0, 1178, 1175, 1, 0, 0, 0, 1179, 1181, 1, 0, 0, 0, 1180, 1156, 1, 0, 0, 0, 1180, 1169, 1, 0, 0, 0, 1181, 107, 1, 0, 0, 0, 1182, 1189, 5, 86, 0, 0, 1183, 1184, 3, 138, 69, 0, 1184, 1185, 6, 54, -1, 0, 1185, 1186, 5, 28, 0, 0, 1186, 1188, 1, 0, 0, 0, 1187, 1183, 1, 0, 0, 0, 1188, 1191, 1, 0, 0, 0, 1189, 1187, 1, 0, 0, 0, 1189, 1190, 1, 0, 0, 0, 1190, 1192, 1, 0, 0, 0, 1191, 1189, 1, 0, 0, 0, 1192, 1193, 3, 138, 69, 0, 1193, 1194, 6, 54, -1, 0, 1194, 1195, 5, 87, 0, 0, 1195, 109, 1, 0, 0, 0, 1196, 1203, 5, 42, 0, 0, 1197, 1198, 3, 146, 73, 0, 1198, 1199, 6, 55, -1, 0, 1199, 1200, 5, 28, 0, 0, 1200, 1202, 1, 0, 0, 0, 1201, 1197, 1, 0, 0, 0, 1202, 1205, 1, 0, 0, 0, 1203, 1201, 1, 0, 0, 0, 1203, 1204, 1, 0, 0, 0, 1204, 1206, 1, 0, 0, 0, 1205, 1203, 1, 0, 0, 0, 1206, 1207, 3, 146, 73, 0, 1207, 1208, 6, 55, -1, 0, 1208, 1209, 5, 43, 0, 0, 1209, 111, 1, 0, 0, 0, 1210, 1217, 5, 30, 0, 0, 1211, 1212, 3, 114, 57, 0, 1212, 1213, 6, 56, -1, 0, 1213, 1214, 5, 28, 0, 0, 1214, 1216, 1, 0, 0, 0, 1215, 1211, 1, 0, 0, 0, 1216, 1219, 1, 0, 0, 0, 1217, 1215, 1, 0, 0, 0, 1217, 1218, 1, 0, 0, 0, 1218, 1220, 1, 0, 0, 0, 1219, 1217, 1, 0, 0, 0, 1220, 1221, 3, 114, 57, 0, 1221, 1222, 6, 56, -1, 0, 1222, 1223, 5, 31, 0, 0, 1223, 1226, 1, 0, 0, 0, 1224, 1226, 5, 85, 0, 0, 1225, 1210, 1, 0, 0, 0, 1225, 1224, 1, 0, 0, 0, 1226, 113, 1, 0, 0, 0, 1227, 1228, 5, 177, 0, 0, 1228, 1238, 6, 57, -1, 0, 1229, 1230, 3, 230, 115, 0, 1230, 1231, 3, 138, 69, 0, 1231, 1233, 3, 226, 113, 0, 1232, 1234, 3, 0, 0, 0, 1233, 1232, 1, 0, 0, 0, 1233, 1234, 1, 0, 0, 0, 1234, 1235, 1, 0, 0, 0, 1235, 1236, 6, 57, -1, 0, 1236, 1238, 1, 0, 0, 0, 1237, 1227, 1, 0, 0, 0, 1237, 1229, 1, 0, 0, 0, 1238, 115, 1, 0, 0, 0, 1239, 1240, 5, 42, 0, 0, 1240, 1241, 3, 2, 1, 0, 1241, 1242, 5, 43, 0, 0, 1242, 1243, 3, 118, 59, 0, 1243, 1244, 6, 58, -1, 0, 1244, 1277, 1, 0, 0, 0, 1245, 1246, 5, 42, 0, 0, 1246, 1247, 3, 174, 87, 0, 1247, 1248, 5, 43, 0, 0, 1248, 1249, 3, 118, 59, 0, 1249, 1250, 6, 58, -1, 0, 1250, 1277, 1, 0, 0, 0, 1251, 1252, 5, 42, 0, 0, 1252, 1253, 5, 262, 0, 0, 1253, 1254, 5, 43, 0, 0, 1254, 1255, 3, 118, 59, 0, 1255, 1256, 6, 58, -1, 0, 1256, 1277, 1, 0, 0, 0, 1257, 1258, 5, 42, 0, 0, 1258, 1259, 5, 198, 0, 0, 1259, 1260, 3, 2, 1, 0, 1260, 1261, 5, 43, 0, 0, 1261, 1262, 3, 118, 59, 0, 1262, 1263, 6, 58, -1, 0, 1263, 1277, 1, 0, 0, 0, 1264, 1265, 3, 118, 59, 0, 1265, 1266, 6, 58, -1, 0, 1266, 1277, 1, 0, 0, 0, 1267, 1268, 3, 174, 87, 0, 1268, 1269, 6, 58, -1, 0, 1269, 1277, 1, 0, 0, 0, 1270, 1271, 5, 257, 0, 0, 1271, 1277, 6, 58, -1, 0, 1272, 1273, 5, 258, 0, 0, 1273, 1277, 6, 58, -1, 0, 1274, 1275, 5, 259, 0, 0, 1275, 1277, 6, 58, -1, 0, 1276, 1239, 1, 0, 0, 0, 1276, 1245, 1, 0, 0, 0, 1276, 1251, 1, 0, 0, 0, 1276, 1257, 1, 0, 0, 0, 1276, 1264, 1, 0, 0, 0, 1276, 1267, 1, 0, 0, 0, 1276, 1270, 1, 0, 0, 0, 1276, 1272, 1, 0, 0, 0, 1276, 1274, 1, 0, 0, 0, 1277, 117, 1, 0, 0, 0, 1278, 1279, 3, 2, 1, 0, 1279, 1280, 6, 59, -1, 0, 1280, 1281, 5, 88, 0, 0, 1281, 1283, 1, 0, 0, 0, 1282, 1278, 1, 0, 0, 0, 1283, 1286, 1, 0, 0, 0, 1284, 1282, 1, 0, 0, 0, 1284, 1285, 1, 0, 0, 0, 1285, 1287, 1, 0, 0, 0, 1286, 1284, 1, 0, 0, 0, 1287, 1288, 3, 2, 1, 0, 1288, 1289, 6, 59, -1, 0, 1289, 119, 1, 0, 0, 0, 1290, 1292, 3, 122, 61, 0, 1291, 1290, 1, 0, 0, 0, 1292, 1295, 1, 0, 0, 0, 1293, 1291, 1, 0, 0, 0, 1293, 1294, 1, 0, 0, 0, 1294, 121, 1, 0, 0, 0, 1295, 1293, 1, 0, 0, 0, 1296, 1297, 5, 180, 0, 0, 1297, 1298, 5, 89, 0, 0, 1298, 1302, 3, 32, 16, 0, 1299, 1302, 3, 152, 76, 0, 1300, 1302, 3, 332, 166, 0, 1301, 1296, 1, 0, 0, 0, 1301, 1299, 1, 0, 0, 0, 1301, 1300, 1, 0, 0, 0, 1302, 123, 1, 0, 0, 0, 1303, 1304, 3, 116, 58, 0, 1304, 1305, 6, 62, -1, 0, 1305, 1321, 1, 0, 0, 0, 1306, 1307, 5, 42, 0, 0, 1307, 1308, 3, 2, 1, 0, 1308, 1309, 5, 43, 0, 0, 1309, 1310, 6, 62, -1, 0, 1310, 1321, 1, 0, 0, 0, 1311, 1312, 5, 42, 0, 0, 1312, 1313, 5, 198, 0, 0, 1313, 1314, 3, 2, 1, 0, 1314, 1315, 5, 43, 0, 0, 1315, 1316, 6, 62, -1, 0, 1316, 1321, 1, 0, 0, 0, 1317, 1318, 3, 138, 69, 0, 1318, 1319, 6, 62, -1, 0, 1319, 1321, 1, 0, 0, 0, 1320, 1303, 1, 0, 0, 0, 1320, 1306, 1, 0, 0, 0, 1320, 1311, 1, 0, 0, 0, 1320, 1317, 1, 0, 0, 0, 1321, 125, 1, 0, 0, 0, 1322, 1334, 1, 0, 0, 0, 1323, 1324, 3, 130, 65, 0, 1324, 1330, 6, 63, -1, 0, 1325, 1326, 3, 128, 64, 0, 1326, 1327, 6, 63, -1, 0, 1327, 1329, 1, 0, 0, 0, 1328, 1325, 1, 0, 0, 0, 1329, 1332, 1, 0, 0, 0, 1330, 1328, 1, 0, 0, 0, 1330, 1331, 1, 0, 0, 0, 1331, 1334, 1, 0, 0, 0, 1332, 1330, 1, 0, 0, 0, 1333, 1322, 1, 0, 0, 0, 1333, 1323, 1, 0, 0, 0, 1334, 127, 1, 0, 0, 0, 1335, 1336, 5, 262, 0, 0, 1336, 1358, 6, 64, -1, 0, 1337, 1338, 5, 261, 0, 0, 1338, 1358, 6, 64, -1, 0, 1339, 1340, 5, 42, 0, 0, 1340, 1341, 3, 32, 16, 0, 1341, 1342, 5, 43, 0, 0, 1342, 1343, 6, 64, -1, 0, 1343, 1358, 1, 0, 0, 0, 1344, 1345, 5, 42, 0, 0, 1345, 1346, 3, 32, 16, 0, 1346, 1347, 5, 266, 0, 0, 1347, 1348, 3, 32, 16, 0, 1348, 1349, 5, 43, 0, 0, 1349, 1350, 6, 64, -1, 0, 1350, 1358, 1, 0, 0, 0, 1351, 1352, 5, 42, 0, 0, 1352, 1353, 5, 266, 0, 0, 1353, 1354, 3, 32, 16, 0, 1354, 1355, 5, 43, 0, 0, 1355, 1356, 6, 64, -1, 0, 1356, 1358, 1, 0, 0, 0, 1357, 1335, 1, 0, 0, 0, 1357, 1337, 1, 0, 0, 0, 1357, 1339, 1, 0, 0, 0, 1357, 1344, 1, 0, 0, 0, 1357, 1351, 1, 0, 0, 0, 1358, 129, 1, 0, 0, 0, 1359, 1505, 6, 65, -1, 0, 1360, 1361, 5, 203, 0, 0, 1361, 1362, 5, 30, 0, 0, 1362, 1363, 3, 6, 3, 0, 1363, 1364, 5, 28, 0, 0, 1364, 1365, 3, 6, 3, 0, 1365, 1366, 5, 28, 0, 0, 1366, 1367, 3, 6, 3, 0, 1367, 1368, 5, 28, 0, 0, 1368, 1369, 3, 6, 3, 0, 1369, 1370, 5, 31, 0, 0, 1370, 1371, 6, 65, -1, 0, 1371, 1505, 1, 0, 0, 0, 1372, 1373, 5, 203, 0, 0, 1373, 1374, 5, 30, 0, 0, 1374, 1375, 3, 6, 3, 0, 1375, 1376, 5, 28, 0, 0, 1376, 1377, 3, 6, 3, 0, 1377, 1378, 5, 31, 0, 0, 1378, 1379, 6, 65, -1, 0, 1379, 1505, 1, 0, 0, 0, 1380, 1381, 5, 204, 0, 0, 1381, 1382, 5, 205, 0, 0, 1382, 1383, 5, 42, 0, 0, 1383, 1384, 3, 32, 16, 0, 1384, 1385, 5, 43, 0, 0, 1385, 1386, 6, 65, -1, 0, 1386, 1505, 1, 0, 0, 0, 1387, 1388, 5, 204, 0, 0, 1388, 1389, 5, 206, 0, 0, 1389, 1390, 5, 42, 0, 0, 1390, 1391, 3, 32, 16, 0, 1391, 1392, 5, 43, 0, 0, 1392, 1393, 3, 126, 63, 0, 1393, 1394, 6, 65, -1, 0, 1394, 1505, 1, 0, 0, 0, 1395, 1396, 5, 207, 0, 0, 1396, 1505, 6, 65, -1, 0, 1397, 1398, 5, 208, 0, 0, 1398, 1505, 6, 65, -1, 0, 1399, 1400, 5, 209, 0, 0, 1400, 1505, 6, 65, -1, 0, 1401, 1402, 5, 201, 0, 0, 1402, 1505, 6, 65, -1, 0, 1403, 1404, 5, 183, 0, 0, 1404, 1505, 6, 65, -1, 0, 1405, 1406, 5, 184, 0, 0, 1406, 1505, 6, 65, -1, 0, 1407, 1408, 5, 185, 0, 0, 1408, 1505, 6, 65, -1, 0, 1409, 1410, 5, 186, 0, 0, 1410, 1505, 6, 65, -1, 0, 1411, 1412, 5, 187, 0, 0, 1412, 1505, 6, 65, -1, 0, 1413, 1414, 5, 188, 0, 0, 1414, 1505, 6, 65, -1, 0, 1415, 1416, 5, 189, 0, 0, 1416, 1505, 6, 65, -1, 0, 1417, 1418, 5, 210, 0, 0, 1418, 1505, 6, 65, -1, 0, 1419, 1420, 5, 190, 0, 0, 1420, 1505, 6, 65, -1, 0, 1421, 1422, 5, 191, 0, 0, 1422, 1505, 6, 65, -1, 0, 1423, 1424, 5, 192, 0, 0, 1424, 1505, 6, 65, -1, 0, 1425, 1426, 5, 193, 0, 0, 1426, 1505, 6, 65, -1, 0, 1427, 1428, 5, 211, 0, 0, 1428, 1505, 6, 65, -1, 0, 1429, 1430, 5, 212, 0, 0, 1430, 1505, 6, 65, -1, 0, 1431, 1432, 5, 213, 0, 0, 1432, 1505, 6, 65, -1, 0, 1433, 1434, 5, 214, 0, 0, 1434, 1505, 6, 65, -1, 0, 1435, 1436, 5, 215, 0, 0, 1436, 1505, 6, 65, -1, 0, 1437, 1438, 5, 216, 0, 0, 1438, 1505, 6, 65, -1, 0, 1439, 1440, 5, 217, 0, 0, 1440, 1505, 6, 65, -1, 0, 1441, 1442, 5, 218, 0, 0, 1442, 1443, 3, 132, 66, 0, 1443, 1444, 6, 65, -1, 0, 1444, 1505, 1, 0, 0, 0, 1445, 1446, 5, 219, 0, 0, 1446, 1447, 3, 132, 66, 0, 1447, 1448, 6, 65, -1, 0, 1448, 1505, 1, 0, 0, 0, 1449, 1450, 5, 220, 0, 0, 1450, 1505, 6, 65, -1, 0, 1451, 1452, 5, 221, 0, 0, 1452, 1453, 3, 132, 66, 0, 1453, 1454, 6, 65, -1, 0, 1454, 1505, 1, 0, 0, 0, 1455, 1456, 5, 222, 0, 0, 1456, 1457, 3, 134, 67, 0, 1457, 1458, 6, 65, -1, 0, 1458, 1505, 1, 0, 0, 0, 1459, 1460, 5, 222, 0, 0, 1460, 1461, 3, 134, 67, 0, 1461, 1462, 5, 28, 0, 0, 1462, 1463, 3, 6, 3, 0, 1463, 1464, 6, 65, -1, 0, 1464, 1505, 1, 0, 0, 0, 1465, 1466, 5, 194, 0, 0, 1466, 1505, 6, 65, -1, 0, 1467, 1468, 5, 195, 0, 0, 1468, 1505, 6, 65, -1, 0, 1469, 1470, 5, 90, 0, 0, 1470, 1471, 5, 184, 0, 0, 1471, 1505, 6, 65, -1, 0, 1472, 1473, 5, 90, 0, 0, 1473, 1474, 5, 185, 0, 0, 1474, 1505, 6, 65, -1, 0, 1475, 1476, 5, 90, 0, 0, 1476, 1477, 5, 186, 0, 0, 1477, 1505, 6, 65, -1, 0, 1478, 1479, 5, 90, 0, 0, 1479, 1480, 5, 187, 0, 0, 1480, 1505, 6, 65, -1, 0, 1481, 1482, 5, 62, 0, 0, 1482, 1483, 5, 220, 0, 0, 1483, 1505, 6, 65, -1, 0, 1484, 1485, 5, 223, 0, 0, 1485, 1505, 6, 65, -1, 0, 1486, 1487, 5, 224, 0, 0, 1487, 1488, 5, 213, 0, 0, 1488, 1505, 6, 65, -1, 0, 1489, 1490, 5, 225, 0, 0, 1490, 1505, 6, 65, -1, 0, 1491, 1492, 5, 207, 0, 0, 1492, 1493, 5, 183, 0, 0, 1493, 1505, 6, 65, -1, 0, 1494, 1495, 5, 226, 0, 0, 1495, 1505, 6, 65, -1, 0, 1496, 1497, 5, 228, 0, 0, 1497, 1505, 6, 65, -1, 0, 1498, 1499, 5, 34, 0, 0, 1499, 1500, 5, 227, 0, 0, 1500, 1505, 6, 65, -1, 0, 1501, 1502, 3, 2, 1, 0, 1502, 1503, 6, 65, -1, 0, 1503, 1505, 1, 0, 0, 0, 1504, 1359, 1, 0, 0, 0, 1504, 1360, 1, 0, 0, 0, 1504, 1372, 1, 0, 0, 0, 1504, 1380, 1, 0, 0, 0, 1504, 1387, 1, 0, 0, 0, 1504, 1395, 1, 0, 0, 0, 1504, 1397, 1, 0, 0, 0, 1504, 1399, 1, 0, 0, 0, 1504, 1401, 1, 0, 0, 0, 1504, 1403, 1, 0, 0, 0, 1504, 1405, 1, 0, 0, 0, 1504, 1407, 1, 0, 0, 0, 1504, 1409, 1, 0, 0, 0, 1504, 1411, 1, 0, 0, 0, 1504, 1413, 1, 0, 0, 0, 1504, 1415, 1, 0, 0, 0, 1504, 1417, 1, 0, 0, 0, 1504, 1419, 1, 0, 0, 0, 1504, 1421, 1, 0, 0, 0, 1504, 1423, 1, 0, 0, 0, 1504, 1425, 1, 0, 0, 0, 1504, 1427, 1, 0, 0, 0, 1504, 1429, 1, 0, 0, 0, 1504, 1431, 1, 0, 0, 0, 1504, 1433, 1, 0, 0, 0, 1504, 1435, 1, 0, 0, 0, 1504, 1437, 1, 0, 0, 0, 1504, 1439, 1, 0, 0, 0, 1504, 1441, 1, 0, 0, 0, 1504, 1445, 1, 0, 0, 0, 1504, 1449, 1, 0, 0, 0, 1504, 1451, 1, 0, 0, 0, 1504, 1455, 1, 0, 0, 0, 1504, 1459, 1, 0, 0, 0, 1504, 1465, 1, 0, 0, 0, 1504, 1467, 1, 0, 0, 0, 1504, 1469, 1, 0, 0, 0, 1504, 1472, 1, 0, 0, 0, 1504, 1475, 1, 0, 0, 0, 1504, 1478, 1, 0, 0, 0, 1504, 1481, 1, 0, 0, 0, 1504, 1484, 1, 0, 0, 0, 1504, 1486, 1, 0, 0, 0, 1504, 1489, 1, 0, 0, 0, 1504, 1491, 1, 0, 0, 0, 1504, 1494, 1, 0, 0, 0, 1504, 1496, 1, 0, 0, 0, 1504, 1498, 1, 0, 0, 0, 1504, 1501, 1, 0, 0, 0, 1505, 131, 1, 0, 0, 0, 1506, 1515, 1, 0, 0, 0, 1507, 1508, 5, 30, 0, 0, 1508, 1509, 5, 91, 0, 0, 1509, 1510, 5, 36, 0, 0, 1510, 1511, 3, 32, 16, 0, 1511, 1512, 5, 31, 0, 0, 1512, 1513, 6, 66, -1, 0, 1513, 1515, 1, 0, 0, 0, 1514, 1506, 1, 0, 0, 0, 1514, 1507, 1, 0, 0, 0, 1515, 133, 1, 0, 0, 0, 1516, 1527, 1, 0, 0, 0, 1517, 1518, 3, 136, 68, 0, 1518, 1523, 6, 67, -1, 0, 1519, 1520, 7, 7, 0, 0, 1520, 1522, 6, 67, -1, 0, 1521, 1519, 1, 0, 0, 0, 1522, 1525, 1, 0, 0, 0, 1523, 1521, 1, 0, 0, 0, 1523, 1524, 1, 0, 0, 0, 1524, 1527, 1, 0, 0, 0, 1525, 1523, 1, 0, 0, 0, 1526, 1516, 1, 0, 0, 0, 1526, 1517, 1, 0, 0, 0, 1527, 135, 1, 0, 0, 0, 1528, 1529, 5, 178, 0, 0, 1529, 1609, 6, 68, -1, 0, 1530, 1531, 5, 207, 0, 0, 1531, 1609, 6, 68, -1, 0, 1532, 1533, 5, 208, 0, 0, 1533, 1609, 6, 68, -1, 0, 1534, 1535, 5, 201, 0, 0, 1535, 1609, 6, 68, -1, 0, 1536, 1537, 5, 183, 0, 0, 1537, 1609, 6, 68, -1, 0, 1538, 1539, 5, 184, 0, 0, 1539, 1609, 6, 68, -1, 0, 1540, 1541, 5, 185, 0, 0, 1541, 1609, 6, 68, -1, 0, 1542, 1543, 5, 186, 0, 0, 1543, 1609, 6, 68, -1, 0, 1544, 1545, 5, 187, 0, 0, 1545, 1609, 6, 68, -1, 0, 1546, 1547, 5, 188, 0, 0, 1547, 1609, 6, 68, -1, 0, 1548, 1549, 5, 189, 0, 0, 1549, 1609, 6, 68, -1, 0, 1550, 1551, 5, 190, 0, 0, 1551, 1609, 6, 68, -1, 0, 1552, 1553, 5, 191, 0, 0, 1553, 1609, 6, 68, -1, 0, 1554, 1555, 5, 192, 0, 0, 1555, 1609, 6, 68, -1, 0, 1556, 1557, 5, 193, 0, 0, 1557, 1609, 6, 68, -1, 0, 1558, 1559, 5, 262, 0, 0, 1559, 1609, 6, 68, -1, 0, 1560, 1561, 5, 211, 0, 0, 1561, 1609, 6, 68, -1, 0, 1562, 1563, 5, 212, 0, 0, 1563, 1609, 6, 68, -1, 0, 1564, 1565, 5, 213, 0, 0, 1565, 1609, 6, 68, -1, 0, 1566, 1567, 5, 214, 0, 0, 1567, 1609, 6, 68, -1, 0, 1568, 1569, 5, 215, 0, 0, 1569, 1609, 6, 68, -1, 0, 1570, 1571, 5, 218, 0, 0, 1571, 1609, 6, 68, -1, 0, 1572, 1573, 5, 219, 0, 0, 1573, 1609, 6, 68, -1, 0, 1574, 1575, 5, 222, 0, 0, 1575, 1609, 6, 68, -1, 0, 1576, 1577, 5, 194, 0, 0, 1577, 1609, 6, 68, -1, 0, 1578, 1579, 5, 195, 0, 0, 1579, 1609, 6, 68, -1, 0, 1580, 1581, 5, 210, 0, 0, 1581, 1609, 6, 68, -1, 0, 1582, 1583, 5, 230, 0, 0, 1583, 1609, 6, 68, -1, 0, 1584, 1585, 5, 231, 0, 0, 1585, 1609, 6, 68, -1, 0, 1586, 1587, 5, 232, 0, 0, 1587, 1609, 6, 68, -1, 0, 1588, 1589, 5, 233, 0, 0, 1589, 1609, 6, 68, -1, 0, 1590, 1591, 5, 234, 0, 0, 1591, 1609, 6, 68, -1, 0, 1592, 1593, 5, 235, 0, 0, 1593, 1609, 6, 68, -1, 0, 1594, 1595, 5, 236, 0, 0, 1595, 1609, 6, 68, -1, 0, 1596, 1597, 5, 237, 0, 0, 1597, 1609, 6, 68, -1, 0, 1598, 1599, 5, 238, 0, 0, 1599, 1609, 6, 68, -1, 0, 1600, 1601, 5, 239, 0, 0, 1601, 1609, 6, 68, -1, 0, 1602, 1603, 5, 240, 0, 0, 1603, 1609, 6, 68, -1, 0, 1604, 1605, 5, 241, 0, 0, 1605, 1609, 6, 68, -1, 0, 1606, 1607, 5, 242, 0, 0, 1607, 1609, 6, 68, -1, 0, 1608, 1528, 1, 0, 0, 0, 1608, 1530, 1, 0, 0, 0, 1608, 1532, 1, 0, 0, 0, 1608, 1534, 1, 0, 0, 0, 1608, 1536, 1, 0, 0, 0, 1608, 1538, 1, 0, 0, 0, 1608, 1540, 1, 0, 0, 0, 1608, 1542, 1, 0, 0, 0, 1608, 1544, 1, 0, 0, 0, 1608, 1546, 1, 0, 0, 0, 1608, 1548, 1, 0, 0, 0, 1608, 1550, 1, 0, 0, 0, 1608, 1552, 1, 0, 0, 0, 1608, 1554, 1, 0, 0, 0, 1608, 1556, 1, 0, 0, 0, 1608, 1558, 1, 0, 0, 0, 1608, 1560, 1, 0, 0, 0, 1608, 1562, 1, 0, 0, 0, 1608, 1564, 1, 0, 0, 0, 1608, 1566, 1, 0, 0, 0, 1608, 1568, 1, 0, 0, 0, 1608, 1570, 1, 0, 0, 0, 1608, 1572, 1, 0, 0, 0, 1608, 1574, 1, 0, 0, 0, 1608, 1576, 1, 0, 0, 0, 1608, 1578, 1, 0, 0, 0, 1608, 1580, 1, 0, 0, 0, 1608, 1582, 1, 0, 0, 0, 1608, 1584, 1, 0, 0, 0, 1608, 1586, 1, 0, 0, 0, 1608, 1588, 1, 0, 0, 0, 1608, 1590, 1, 0, 0, 0, 1608, 1592, 1, 0, 0, 0, 1608, 1594, 1, 0, 0, 0, 1608, 1596, 1, 0, 0, 0, 1608, 1598, 1, 0, 0, 0, 1608, 1600, 1, 0, 0, 0, 1608, 1602, 1, 0, 0, 0, 1608, 1604, 1, 0, 0, 0, 1608, 1606, 1, 0, 0, 0, 1609, 137, 1, 0, 0, 0, 1610, 1611, 3, 142, 71, 0, 1611, 1617, 6, 69, -1, 0, 1612, 1613, 3, 140, 70, 0, 1613, 1614, 6, 69, -1, 0, 1614, 1616, 1, 0, 0, 0, 1615, 1612, 1, 0, 0, 0, 1616, 1619, 1, 0, 0, 0, 1617, 1615, 1, 0, 0, 0, 1617, 1618, 1, 0, 0, 0, 1618, 139, 1, 0, 0, 0, 1619, 1617, 1, 0, 0, 0, 1620, 1621, 5, 261, 0, 0, 1621, 1650, 6, 70, -1, 0, 1622, 1623, 5, 42, 0, 0, 1623, 1624, 5, 43, 0, 0, 1624, 1650, 6, 70, -1, 0, 1625, 1626, 3, 110, 55, 0, 1626, 1627, 6, 70, -1, 0, 1627, 1650, 1, 0, 0, 0, 1628, 1629, 5, 260, 0, 0, 1629, 1650, 6, 70, -1, 0, 1630, 1631, 5, 262, 0, 0, 1631, 1650, 6, 70, -1, 0, 1632, 1633, 5, 92, 0, 0, 1633, 1650, 6, 70, -1, 0, 1634, 1635, 5, 93, 0, 0, 1635, 1636, 5, 30, 0, 0, 1636, 1637, 3, 124, 62, 0, 1637, 1638, 5, 31, 0, 0, 1638, 1639, 6, 70, -1, 0, 1639, 1650, 1, 0, 0, 0, 1640, 1641, 5, 94, 0, 0, 1641, 1642, 5, 30, 0, 0, 1642, 1643, 3, 124, 62, 0, 1643, 1644, 5, 31, 0, 0, 1644, 1645, 6, 70, -1, 0, 1645, 1650, 1, 0, 0, 0, 1646, 1647, 3, 108, 54, 0, 1647, 1648, 6, 70, -1, 0, 1648, 1650, 1, 0, 0, 0, 1649, 1620, 1, 0, 0, 0, 1649, 1622, 1, 0, 0, 0, 1649, 1625, 1, 0, 0, 0, 1649, 1628, 1, 0, 0, 0, 1649, 1630, 1, 0, 0, 0, 1649, 1632, 1, 0, 0, 0, 1649, 1634, 1, 0, 0, 0, 1649, 1640, 1, 0, 0, 0, 1649, 1646, 1, 0, 0, 0, 1650, 141, 1, 0, 0, 0, 1651, 1652, 5, 39, 0, 0, 1652, 1653, 3, 116, 58, 0, 1653, 1654, 6, 71, -1, 0, 1654, 1710, 1, 0, 0, 0, 1655, 1656, 5, 197, 0, 0, 1656, 1710, 6, 71, -1, 0, 1657, 1658, 5, 199, 0, 0, 1658, 1659, 5, 39, 0, 0, 1659, 1660, 3, 116, 58, 0, 1660, 1661, 6, 71, -1, 0, 1661, 1710, 1, 0, 0, 0, 1662, 1663, 5, 200, 0, 0, 1663, 1664, 3, 116, 58, 0, 1664, 1665, 6, 71, -1, 0, 1665, 1710, 1, 0, 0, 0, 1666, 1667, 5, 226, 0, 0, 1667, 1668, 3, 170, 85, 0, 1668, 1669, 3, 138, 69, 0, 1669, 1670, 5, 262, 0, 0, 1670, 1671, 3, 112, 56, 0, 1671, 1672, 6, 71, -1, 0, 1672, 1710, 1, 0, 0, 0, 1673, 1674, 5, 253, 0, 0, 1674, 1675, 3, 32, 16, 0, 1675, 1676, 6, 71, -1, 0, 1676, 1710, 1, 0, 0, 0, 1677, 1678, 5, 252, 0, 0, 1678, 1679, 3, 32, 16, 0, 1679, 1680, 6, 71, -1, 0, 1680, 1710, 1, 0, 0, 0, 1681, 1682, 5, 253, 0, 0, 1682, 1683, 3, 2, 1, 0, 1683, 1684, 6, 71, -1, 0, 1684, 1710, 1, 0, 0, 0, 1685, 1686, 5, 252, 0, 0, 1686, 1687, 3, 2, 1, 0, 1687, 1688, 6, 71, -1, 0, 1688, 1710, 1, 0, 0, 0, 1689, 1690, 5, 254, 0, 0, 1690, 1710, 6, 71, -1, 0, 1691, 1692, 5, 201, 0, 0, 1692, 1710, 6, 71, -1, 0, 1693, 1694, 3, 148, 74, 0, 1694, 1695, 6, 71, -1, 0, 1695, 1710, 1, 0, 0, 0, 1696, 1697, 3, 150, 75, 0, 1697, 1698, 6, 71, -1, 0, 1698, 1710, 1, 0, 0, 0, 1699, 1700, 3, 144, 72, 0, 1700, 1701, 6, 71, -1, 0, 1701, 1710, 1, 0, 0, 0, 1702, 1703, 3, 2, 1, 0, 1703, 1704, 6, 71, -1, 0, 1704, 1710, 1, 0, 0, 0, 1705, 1706, 5, 177, 0, 0, 1706, 1707, 3, 138, 69, 0, 1707, 1708, 6, 71, -1, 0, 1708, 1710, 1, 0, 0, 0, 1709, 1651, 1, 0, 0, 0, 1709, 1655, 1, 0, 0, 0, 1709, 1657, 1, 0, 0, 0, 1709, 1662, 1, 0, 0, 0, 1709, 1666, 1, 0, 0, 0, 1709, 1673, 1, 0, 0, 0, 1709, 1677, 1, 0, 0, 0, 1709, 1681, 1, 0, 0, 0, 1709, 1685, 1, 0, 0, 0, 1709, 1689, 1, 0, 0, 0, 1709, 1691, 1, 0, 0, 0, 1709, 1693, 1, 0, 0, 0, 1709, 1696, 1, 0, 0, 0, 1709, 1699, 1, 0, 0, 0, 1709, 1702, 1, 0, 0, 0, 1709, 1705, 1, 0, 0, 0, 1710, 143, 1, 0, 0, 0, 1711, 1712, 5, 181, 0, 0, 1712, 1750, 6, 72, -1, 0, 1713, 1714, 5, 182, 0, 0, 1714, 1750, 6, 72, -1, 0, 1715, 1716, 5, 183, 0, 0, 1716, 1750, 6, 72, -1, 0, 1717, 1718, 5, 184, 0, 0, 1718, 1750, 6, 72, -1, 0, 1719, 1720, 5, 185, 0, 0, 1720, 1750, 6, 72, -1, 0, 1721, 1722, 5, 186, 0, 0, 1722, 1750, 6, 72, -1, 0, 1723, 1724, 5, 187, 0, 0, 1724, 1750, 6, 72, -1, 0, 1725, 1726, 5, 188, 0, 0, 1726, 1750, 6, 72, -1, 0, 1727, 1728, 5, 189, 0, 0, 1728, 1750, 6, 72, -1, 0, 1729, 1730, 5, 190, 0, 0, 1730, 1750, 6, 72, -1, 0, 1731, 1732, 5, 191, 0, 0, 1732, 1750, 6, 72, -1, 0, 1733, 1734, 5, 192, 0, 0, 1734, 1750, 6, 72, -1, 0, 1735, 1736, 5, 193, 0, 0, 1736, 1750, 6, 72, -1, 0, 1737, 1738, 5, 90, 0, 0, 1738, 1739, 5, 184, 0, 0, 1739, 1750, 6, 72, -1, 0, 1740, 1741, 5, 90, 0, 0, 1741, 1742, 5, 185, 0, 0, 1742, 1750, 6, 72, -1, 0, 1743, 1744, 5, 90, 0, 0, 1744, 1745, 5, 186, 0, 0, 1745, 1750, 6, 72, -1, 0, 1746, 1747, 5, 90, 0, 0, 1747, 1748, 5, 187, 0, 0, 1748, 1750, 6, 72, -1, 0, 1749, 1711, 1, 0, 0, 0, 1749, 1713, 1, 0, 0, 0, 1749, 1715, 1, 0, 0, 0, 1749, 1717, 1, 0, 0, 0, 1749, 1719, 1, 0, 0, 0, 1749, 1721, 1, 0, 0, 0, 1749, 1723, 1, 0, 0, 0, 1749, 1725, 1, 0, 0, 0, 1749, 1727, 1, 0, 0, 0, 1749, 1729, 1, 0, 0, 0, 1749, 1731, 1, 0, 0, 0, 1749, 1733, 1, 0, 0, 0, 1749, 1735, 1, 0, 0, 0, 1749, 1737, 1, 0, 0, 0, 1749, 1740, 1, 0, 0, 0, 1749, 1743, 1, 0, 0, 0, 1749, 1746, 1, 0, 0, 0, 1750, 145, 1, 0, 0, 0, 1751, 1766, 1, 0, 0, 0, 1752, 1766, 5, 177, 0, 0, 1753, 1754, 3, 32, 16, 0, 1754, 1755, 6, 73, -1, 0, 1755, 1766, 1, 0, 0, 0, 1756, 1757, 3, 32, 16, 0, 1757, 1758, 5, 177, 0, 0, 1758, 1759, 3, 32, 16, 0, 1759, 1760, 6, 73, -1, 0, 1760, 1766, 1, 0, 0, 0, 1761, 1762, 3, 32, 16, 0, 1762, 1763, 5, 177, 0, 0, 1763, 1764, 6, 73, -1, 0, 1764, 1766, 1, 0, 0, 0, 1765, 1751, 1, 0, 0, 0, 1765, 1752, 1, 0, 0, 0, 1765, 1753, 1, 0, 0, 0, 1765, 1756, 1, 0, 0, 0, 1765, 1761, 1, 0, 0, 0, 1766, 147, 1, 0, 0, 0, 1767, 1768, 5, 1, 0, 0, 1768, 1769, 5, 194, 0, 0, 1769, 1770, 6, 74, -1, 0, 1770, 149, 1, 0, 0, 0, 1771, 1775, 5, 1, 0, 0, 1772, 1773, 5, 90, 0, 0, 1773, 1776, 5, 194, 0, 0, 1774, 1776, 5, 195, 0, 0, 1775, 1772, 1, 0, 0, 0, 1775, 1774, 1, 0, 0, 0, 1776, 1777, 1, 0, 0, 0, 1777, 1778, 6, 75, -1, 0, 1778, 151, 1, 0, 0, 0, 1779, 1780, 5, 294, 0, 0, 1780, 1781, 3, 166, 83, 0, 1781, 1782, 3, 124, 62, 0, 1782, 1783, 5, 30, 0, 0, 1783, 1784, 3, 158, 79, 0, 1784, 1785, 5, 31, 0, 0, 1785, 1827, 1, 0, 0, 0, 1786, 1787, 5, 294, 0, 0, 1787, 1788, 3, 166, 83, 0, 1788, 1789, 3, 124, 62, 0, 1789, 1790, 5, 36, 0, 0, 1790, 1791, 5, 17, 0, 0, 1791, 1792, 3, 52, 26, 0, 1792, 1793, 5, 18, 0, 0, 1793, 1827, 1, 0, 0, 0, 1794, 1795, 5, 294, 0, 0, 1795, 1796, 3, 166, 83, 0, 1796, 1797, 3, 124, 62, 0, 1797, 1827, 1, 0, 0, 0, 1798, 1799, 5, 295, 0, 0, 1799, 1800, 3, 166, 83, 0, 1800, 1802, 5, 36, 0, 0, 1801, 1803, 5, 84, 0, 0, 1802, 1801, 1, 0, 0, 0, 1802, 1803, 1, 0, 0, 0, 1803, 1804, 1, 0, 0, 0, 1804, 1805, 5, 30, 0, 0, 1805, 1806, 3, 300, 150, 0, 1806, 1807, 5, 31, 0, 0, 1807, 1827, 1, 0, 0, 0, 1808, 1809, 5, 295, 0, 0, 1809, 1810, 3, 166, 83, 0, 1810, 1811, 5, 84, 0, 0, 1811, 1812, 5, 30, 0, 0, 1812, 1813, 3, 300, 150, 0, 1813, 1814, 5, 31, 0, 0, 1814, 1827, 1, 0, 0, 0, 1815, 1816, 5, 295, 0, 0, 1816, 1817, 3, 166, 83, 0, 1817, 1818, 3, 6, 3, 0, 1818, 1827, 1, 0, 0, 0, 1819, 1820, 5, 295, 0, 0, 1820, 1821, 3, 166, 83, 0, 1821, 1822, 5, 36, 0, 0, 1822, 1823, 5, 17, 0, 0, 1823, 1824, 3, 154, 77, 0, 1824, 1825, 5, 18, 0, 0, 1825, 1827, 1, 0, 0, 0, 1826, 1779, 1, 0, 0, 0, 1826, 1786, 1, 0, 0, 0, 1826, 1794, 1, 0, 0, 0, 1826, 1798, 1, 0, 0, 0, 1826, 1808, 1, 0, 0, 0, 1826, 1815, 1, 0, 0, 0, 1826, 1819, 1, 0, 0, 0, 1827, 153, 1, 0, 0, 0, 1828, 1839, 1, 0, 0, 0, 1829, 1830, 3, 156, 78, 0, 1830, 1831, 5, 28, 0, 0, 1831, 1833, 1, 0, 0, 0, 1832, 1829, 1, 0, 0, 0, 1833, 1836, 1, 0, 0, 0, 1834, 1832, 1, 0, 0, 0, 1834, 1835, 1, 0, 0, 0, 1835, 1837, 1, 0, 0, 0, 1836, 1834, 1, 0, 0, 0, 1837, 1839, 3, 156, 78, 0, 1838, 1828, 1, 0, 0, 0, 1838, 1834, 1, 0, 0, 0, 1839, 155, 1, 0, 0, 0, 1840, 1841, 5, 39, 0, 0, 1841, 1842, 5, 264, 0, 0, 1842, 1843, 5, 36, 0, 0, 1843, 1844, 5, 17, 0, 0, 1844, 1845, 3, 56, 28, 0, 1845, 1846, 5, 18, 0, 0, 1846, 1854, 1, 0, 0, 0, 1847, 1848, 3, 124, 62, 0, 1848, 1849, 5, 36, 0, 0, 1849, 1850, 5, 17, 0, 0, 1850, 1851, 3, 56, 28, 0, 1851, 1852, 5, 18, 0, 0, 1852, 1854, 1, 0, 0, 0, 1853, 1840, 1, 0, 0, 0, 1853, 1847, 1, 0, 0, 0, 1854, 157, 1, 0, 0, 0, 1855, 1856, 3, 160, 80, 0, 1856, 1857, 5, 28, 0, 0, 1857, 1859, 1, 0, 0, 0, 1858, 1855, 1, 0, 0, 0, 1859, 1862, 1, 0, 0, 0, 1860, 1858, 1, 0, 0, 0, 1860, 1861, 1, 0, 0, 0, 1861, 1863, 1, 0, 0, 0, 1862, 1860, 1, 0, 0, 0, 1863, 1864, 3, 160, 80, 0, 1864, 159, 1, 0, 0, 0, 1865, 1866, 3, 6, 3, 0, 1866, 1867, 5, 36, 0, 0, 1867, 1868, 3, 164, 82, 0, 1868, 161, 1, 0, 0, 0, 1869, 1870, 7, 8, 0, 0, 1870, 163, 1, 0, 0, 0, 1871, 1906, 3, 162, 81, 0, 1872, 1906, 3, 32, 16, 0, 1873, 1874, 5, 186, 0, 0, 1874, 1875, 5, 30, 0, 0, 1875, 1876, 3, 32, 16, 0, 1876, 1877, 5, 31, 0, 0, 1877, 1906, 1, 0, 0, 0, 1878, 1906, 3, 6, 3, 0, 1879, 1880, 3, 116, 58, 0, 1880, 1881, 5, 30, 0, 0, 1881, 1882, 5, 184, 0, 0, 1882, 1883, 5, 75, 0, 0, 1883, 1884, 3, 32, 16, 0, 1884, 1885, 5, 31, 0, 0, 1885, 1906, 1, 0, 0, 0, 1886, 1887, 3, 116, 58, 0, 1887, 1888, 5, 30, 0, 0, 1888, 1889, 5, 185, 0, 0, 1889, 1890, 5, 75, 0, 0, 1890, 1891, 3, 32, 16, 0, 1891, 1892, 5, 31, 0, 0, 1892, 1906, 1, 0, 0, 0, 1893, 1894, 3, 116, 58, 0, 1894, 1895, 5, 30, 0, 0, 1895, 1896, 5, 186, 0, 0, 1896, 1897, 5, 75, 0, 0, 1897, 1898, 3, 32, 16, 0, 1898, 1899, 5, 31, 0, 0, 1899, 1906, 1, 0, 0, 0, 1900, 1901, 3, 116, 58, 0, 1901, 1902, 5, 30, 0, 0, 1902, 1903, 3, 32, 16, 0, 1903, 1904, 5, 31, 0, 0, 1904, 1906, 1, 0, 0, 0, 1905, 1871, 1, 0, 0, 0, 1905, 1872, 1, 0, 0, 0, 1905, 1873, 1, 0, 0, 0, 1905, 1878, 1, 0, 0, 0, 1905, 1879, 1, 0, 0, 0, 1905, 1886, 1, 0, 0, 0, 1905, 1893, 1, 0, 0, 0, 1905, 1900, 1, 0, 0, 0, 1906, 165, 1, 0, 0, 0, 1907, 1908, 7, 9, 0, 0, 1908, 167, 1, 0, 0, 0, 1909, 1910, 3, 170, 85, 0, 1910, 1911, 3, 138, 69, 0, 1911, 1912, 3, 124, 62, 0, 1912, 1913, 5, 176, 0, 0, 1913, 1915, 3, 242, 121, 0, 1914, 1916, 3, 108, 54, 0, 1915, 1914, 1, 0, 0, 0, 1915, 1916, 1, 0, 0, 0, 1916, 1917, 1, 0, 0, 0, 1917, 1918, 3, 112, 56, 0, 1918, 1919, 6, 84, -1, 0, 1919, 1952, 1, 0, 0, 0, 1920, 1921, 3, 170, 85, 0, 1921, 1922, 3, 138, 69, 0, 1922, 1923, 3, 124, 62, 0, 1923, 1924, 5, 176, 0, 0, 1924, 1925, 3, 242, 121, 0, 1925, 1926, 3, 196, 98, 0, 1926, 1927, 3, 112, 56, 0, 1927, 1928, 6, 84, -1, 0, 1928, 1952, 1, 0, 0, 0, 1929, 1930, 3, 170, 85, 0, 1930, 1931, 3, 138, 69, 0, 1931, 1933, 3, 242, 121, 0, 1932, 1934, 3, 108, 54, 0, 1933, 1932, 1, 0, 0, 0, 1933, 1934, 1, 0, 0, 0, 1934, 1935, 1, 0, 0, 0, 1935, 1936, 3, 112, 56, 0, 1936, 1937, 6, 84, -1, 0, 1937, 1952, 1, 0, 0, 0, 1938, 1939, 3, 170, 85, 0, 1939, 1940, 3, 138, 69, 0, 1940, 1941, 3, 242, 121, 0, 1941, 1942, 3, 196, 98, 0, 1942, 1943, 3, 112, 56, 0, 1943, 1944, 6, 84, -1, 0, 1944, 1952, 1, 0, 0, 0, 1945, 1946, 3, 174, 87, 0, 1946, 1947, 6, 84, -1, 0, 1947, 1952, 1, 0, 0, 0, 1948, 1949, 3, 2, 1, 0, 1949, 1950, 6, 84, -1, 0, 1950, 1952, 1, 0, 0, 0, 1951, 1909, 1, 0, 0, 0, 1951, 1920, 1, 0, 0, 0, 1951, 1929, 1, 0, 0, 0, 1951, 1938, 1, 0, 0, 0, 1951, 1945, 1, 0, 0, 0, 1951, 1948, 1, 0, 0, 0, 1952, 169, 1, 0, 0, 0, 1953, 1954, 5, 243, 0, 0, 1954, 1955, 3, 170, 85, 0, 1955, 1956, 6, 85, -1, 0, 1956, 1971, 1, 0, 0, 0, 1957, 1958, 5, 244, 0, 0, 1958, 1959, 3, 170, 85, 0, 1959, 1960, 6, 85, -1, 0, 1960, 1971, 1, 0, 0, 0, 1961, 1962, 3, 172, 86, 0, 1962, 1963, 6, 85, -1, 0, 1963, 1971, 1, 0, 0, 0, 1964, 1965, 5, 112, 0, 0, 1965, 1966, 5, 30, 0, 0, 1966, 1967, 3, 32, 16, 0, 1967, 1968, 5, 31, 0, 0, 1968, 1969, 6, 85, -1, 0, 1969, 1971, 1, 0, 0, 0, 1970, 1953, 1, 0, 0, 0, 1970, 1957, 1, 0, 0, 0, 1970, 1961, 1, 0, 0, 0, 1970, 1964, 1, 0, 0, 0, 1971, 171, 1, 0, 0, 0, 1972, 1992, 1, 0, 0, 0, 1973, 1974, 5, 245, 0, 0, 1974, 1992, 6, 86, -1, 0, 1975, 1976, 5, 246, 0, 0, 1976, 1992, 6, 86, -1, 0, 1977, 1978, 5, 247, 0, 0, 1978, 1979, 5, 248, 0, 0, 1979, 1992, 6, 86, -1, 0, 1980, 1981, 5, 247, 0, 0, 1981, 1982, 5, 249, 0, 0, 1982, 1992, 6, 86, -1, 0, 1983, 1984, 5, 247, 0, 0, 1984, 1985, 5, 250, 0, 0, 1985, 1992, 6, 86, -1, 0, 1986, 1987, 5, 247, 0, 0, 1987, 1988, 5, 251, 0, 0, 1988, 1992, 6, 86, -1, 0, 1989, 1990, 5, 247, 0, 0, 1990, 1992, 6, 86, -1, 0, 1991, 1972, 1, 0, 0, 0, 1991, 1973, 1, 0, 0, 0, 1991, 1975, 1, 0, 0, 0, 1991, 1977, 1, 0, 0, 0, 1991, 1980, 1, 0, 0, 0, 1991, 1983, 1, 0, 0, 0, 1991, 1986, 1, 0, 0, 0, 1991, 1989, 1, 0, 0, 0, 1992, 173, 1, 0, 0, 0, 1993, 1994, 5, 113, 0, 0, 1994, 1995, 5, 30, 0, 0, 1995, 1996, 3, 32, 16, 0, 1996, 1997, 5, 31, 0, 0, 1997, 1998, 6, 87, -1, 0, 1998, 175, 1, 0, 0, 0, 1999, 2000, 5, 226, 0, 0, 2000, 2001, 3, 168, 84, 0, 2001, 2002, 6, 88, -1, 0, 2002, 2011, 1, 0, 0, 0, 2003, 2004, 5, 37, 0, 0, 2004, 2005, 3, 178, 89, 0, 2005, 2006, 6, 88, -1, 0, 2006, 2011, 1, 0, 0, 0, 2007, 2008, 3, 174, 87, 0, 2008, 2009, 6, 88, -1, 0, 2009, 2011, 1, 0, 0, 0, 2010, 1999, 1, 0, 0, 0, 2010, 2003, 1, 0, 0, 0, 2010, 2007, 1, 0, 0, 0, 2011, 177, 1, 0, 0, 0, 2012, 2013, 3, 138, 69, 0, 2013, 2014, 3, 124, 62, 0, 2014, 2015, 5, 176, 0, 0, 2015, 2016, 3, 2, 1, 0, 2016, 2017, 6, 89, -1, 0, 2017, 2026, 1, 0, 0, 0, 2018, 2019, 3, 138, 69, 0, 2019, 2020, 3, 2, 1, 0, 2020, 2021, 6, 89, -1, 0, 2021, 2026, 1, 0, 0, 0, 2022, 2023, 3, 2, 1, 0, 2023, 2024, 6, 89, -1, 0, 2024, 2026, 1, 0, 0, 0, 2025, 2012, 1, 0, 0, 0, 2025, 2018, 1, 0, 0, 0, 2025, 2022, 1, 0, 0, 0, 2026, 179, 1, 0, 0, 0, 2027, 2028, 3, 124, 62, 0, 2028, 2029, 6, 90, -1, 0, 2029, 2030, 5, 28, 0, 0, 2030, 2032, 1, 0, 0, 0, 2031, 2027, 1, 0, 0, 0, 2032, 2035, 1, 0, 0, 0, 2033, 2031, 1, 0, 0, 0, 2033, 2034, 1, 0, 0, 0, 2034, 2036, 1, 0, 0, 0, 2035, 2033, 1, 0, 0, 0, 2036, 2037, 3, 124, 62, 0, 2037, 2038, 6, 90, -1, 0, 2038, 181, 1, 0, 0, 0, 2039, 2046, 1, 0, 0, 0, 2040, 2041, 5, 86, 0, 0, 2041, 2042, 3, 190, 95, 0, 2042, 2043, 5, 87, 0, 0, 2043, 2044, 6, 91, -1, 0, 2044, 2046, 1, 0, 0, 0, 2045, 2039, 1, 0, 0, 0, 2045, 2040, 1, 0, 0, 0, 2046, 183, 1, 0, 0, 0, 2047, 2048, 5, 266, 0, 0, 2048, 2066, 6, 92, -1, 0, 2049, 2050, 5, 114, 0, 0, 2050, 2066, 6, 92, -1, 0, 2051, 2052, 5, 39, 0, 0, 2052, 2066, 6, 92, -1, 0, 2053, 2054, 5, 200, 0, 0, 2054, 2066, 6, 92, -1, 0, 2055, 2056, 5, 115, 0, 0, 2056, 2066, 6, 92, -1, 0, 2057, 2058, 5, 116, 0, 0, 2058, 2066, 6, 92, -1, 0, 2059, 2060, 5, 70, 0, 0, 2060, 2061, 5, 30, 0, 0, 2061, 2062, 3, 32, 16, 0, 2062, 2063, 5, 31, 0, 0, 2063, 2064, 6, 92, -1, 0, 2064, 2066, 1, 0, 0, 0, 2065, 2047, 1, 0, 0, 0, 2065, 2049, 1, 0, 0, 0, 2065, 2051, 1, 0, 0, 0, 2065, 2053, 1, 0, 0, 0, 2065, 2055, 1, 0, 0, 0, 2065, 2057, 1, 0, 0, 0, 2065, 2059, 1, 0, 0, 0, 2066, 185, 1, 0, 0, 0, 2067, 2068, 3, 184, 92, 0, 2068, 2069, 6, 93, -1, 0, 2069, 2071, 1, 0, 0, 0, 2070, 2067, 1, 0, 0, 0, 2071, 2074, 1, 0, 0, 0, 2072, 2070, 1, 0, 0, 0, 2072, 2073, 1, 0, 0, 0, 2073, 187, 1, 0, 0, 0, 2074, 2072, 1, 0, 0, 0, 2075, 2077, 3, 186, 93, 0, 2076, 2078, 3, 192, 96, 0, 2077, 2076, 1, 0, 0, 0, 2077, 2078, 1, 0, 0, 0, 2078, 2079, 1, 0, 0, 0, 2079, 2080, 3, 2, 1, 0, 2080, 2081, 6, 94, -1, 0, 2081, 189, 1, 0, 0, 0, 2082, 2083, 3, 188, 94, 0, 2083, 2084, 6, 95, -1, 0, 2084, 2085, 5, 28, 0, 0, 2085, 2087, 1, 0, 0, 0, 2086, 2082, 1, 0, 0, 0, 2087, 2090, 1, 0, 0, 0, 2088, 2086, 1, 0, 0, 0, 2088, 2089, 1, 0, 0, 0, 2089, 2091, 1, 0, 0, 0, 2090, 2088, 1, 0, 0, 0, 2091, 2092, 3, 188, 94, 0, 2092, 2093, 6, 95, -1, 0, 2093, 191, 1, 0, 0, 0, 2094, 2095, 5, 30, 0, 0, 2095, 2096, 3, 180, 90, 0, 2096, 2097, 5, 31, 0, 0, 2097, 2098, 6, 96, -1, 0, 2098, 193, 1, 0, 0, 0, 2099, 2101, 3, 196, 98, 0, 2100, 2099, 1, 0, 0, 0, 2100, 2101, 1, 0, 0, 0, 2101, 2102, 1, 0, 0, 0, 2102, 2103, 6, 97, -1, 0, 2103, 195, 1, 0, 0, 0, 2104, 2105, 5, 86, 0, 0, 2105, 2106, 5, 42, 0, 0, 2106, 2107, 3, 32, 16, 0, 2107, 2108, 5, 43, 0, 0, 2108, 2109, 5, 87, 0, 0, 2109, 2110, 6, 98, -1, 0, 2110, 197, 1, 0, 0, 0, 2111, 2112, 3, 234, 117, 0, 2112, 2113, 5, 17, 0, 0, 2113, 2114, 3, 246, 123, 0, 2114, 2115, 5, 18, 0, 0, 2115, 2262, 1, 0, 0, 0, 2116, 2117, 3, 74, 37, 0, 2117, 2118, 5, 17, 0, 0, 2118, 2119, 3, 82, 41, 0, 2119, 2120, 5, 18, 0, 0, 2120, 2262, 1, 0, 0, 0, 2121, 2122, 3, 210, 105, 0, 2122, 2123, 6, 99, -1, 0, 2123, 2124, 5, 17, 0, 0, 2124, 2125, 3, 214, 107, 0, 2125, 2126, 5, 18, 0, 0, 2126, 2262, 1, 0, 0, 0, 2127, 2128, 3, 218, 109, 0, 2128, 2129, 6, 99, -1, 0, 2129, 2130, 5, 17, 0, 0, 2130, 2131, 3, 222, 111, 0, 2131, 2132, 5, 18, 0, 0, 2132, 2262, 1, 0, 0, 0, 2133, 2262, 3, 200, 100, 0, 2134, 2135, 3, 284, 142, 0, 2135, 2136, 6, 99, -1, 0, 2136, 2262, 1, 0, 0, 0, 2137, 2138, 3, 152, 76, 0, 2138, 2139, 6, 99, -1, 0, 2139, 2262, 1, 0, 0, 0, 2140, 2141, 3, 88, 44, 0, 2141, 2142, 6, 99, -1, 0, 2142, 2262, 1, 0, 0, 0, 2143, 2144, 3, 330, 165, 0, 2144, 2145, 6, 99, -1, 0, 2145, 2262, 1, 0, 0, 0, 2146, 2147, 5, 117, 0, 0, 2147, 2148, 3, 32, 16, 0, 2148, 2149, 6, 99, -1, 0, 2149, 2262, 1, 0, 0, 0, 2150, 2151, 5, 118, 0, 0, 2151, 2152, 3, 32, 16, 0, 2152, 2153, 6, 99, -1, 0, 2153, 2262, 1, 0, 0, 0, 2154, 2155, 3, 346, 173, 0, 2155, 2156, 5, 17, 0, 0, 2156, 2157, 3, 350, 175, 0, 2157, 2158, 5, 18, 0, 0, 2158, 2159, 6, 99, -1, 0, 2159, 2262, 1, 0, 0, 0, 2160, 2161, 5, 302, 0, 0, 2161, 2162, 3, 124, 62, 0, 2162, 2163, 5, 176, 0, 0, 2163, 2164, 3, 242, 121, 0, 2164, 2165, 5, 119, 0, 0, 2165, 2166, 3, 170, 85, 0, 2166, 2167, 3, 138, 69, 0, 2167, 2168, 3, 124, 62, 0, 2168, 2169, 5, 176, 0, 0, 2169, 2170, 3, 242, 121, 0, 2170, 2171, 3, 112, 56, 0, 2171, 2172, 6, 99, -1, 0, 2172, 2262, 1, 0, 0, 0, 2173, 2174, 5, 302, 0, 0, 2174, 2175, 5, 226, 0, 0, 2175, 2176, 3, 170, 85, 0, 2176, 2177, 3, 138, 69, 0, 2177, 2178, 3, 124, 62, 0, 2178, 2179, 5, 176, 0, 0, 2179, 2180, 3, 242, 121, 0, 2180, 2181, 3, 194, 97, 0, 2181, 2182, 3, 112, 56, 0, 2182, 2183, 5, 119, 0, 0, 2183, 2184, 5, 226, 0, 0, 2184, 2185, 3, 170, 85, 0, 2185, 2186, 3, 138, 69, 0, 2186, 2187, 3, 124, 62, 0, 2187, 2188, 5, 176, 0, 0, 2188, 2189, 3, 242, 121, 0, 2189, 2190, 3, 194, 97, 0, 2190, 2191, 3, 112, 56, 0, 2191, 2192, 6, 99, -1, 0, 2192, 2262, 1, 0, 0, 0, 2193, 2194, 3, 26, 13, 0, 2194, 2195, 6, 99, -1, 0, 2195, 2262, 1, 0, 0, 0, 2196, 2197, 3, 40, 20, 0, 2197, 2198, 6, 99, -1, 0, 2198, 2262, 1, 0, 0, 0, 2199, 2200, 5, 255, 0, 0, 2200, 2201, 5, 196, 0, 0, 2201, 2202, 5, 42, 0, 0, 2202, 2203, 3, 32, 16, 0, 2203, 2204, 5, 43, 0, 0, 2204, 2210, 6, 99, -1, 0, 2205, 2206, 3, 330, 165, 0, 2206, 2207, 6, 99, -1, 0, 2207, 2209, 1, 0, 0, 0, 2208, 2205, 1, 0, 0, 0, 2209, 2212, 1, 0, 0, 0, 2210, 2208, 1, 0, 0, 0, 2210, 2211, 1, 0, 0, 0, 2211, 2262, 1, 0, 0, 0, 2212, 2210, 1, 0, 0, 0, 2213, 2214, 5, 255, 0, 0, 2214, 2215, 5, 196, 0, 0, 2215, 2216, 3, 2, 1, 0, 2216, 2222, 6, 99, -1, 0, 2217, 2218, 3, 330, 165, 0, 2218, 2219, 6, 99, -1, 0, 2219, 2221, 1, 0, 0, 0, 2220, 2217, 1, 0, 0, 0, 2221, 2224, 1, 0, 0, 0, 2222, 2220, 1, 0, 0, 0, 2222, 2223, 1, 0, 0, 0, 2223, 2262, 1, 0, 0, 0, 2224, 2222, 1, 0, 0, 0, 2225, 2226, 5, 255, 0, 0, 2226, 2227, 5, 256, 0, 0, 2227, 2228, 5, 42, 0, 0, 2228, 2229, 3, 32, 16, 0, 2229, 2230, 5, 43, 0, 0, 2230, 2231, 5, 28, 0, 0, 2231, 2232, 3, 124, 62, 0, 2232, 2238, 6, 99, -1, 0, 2233, 2234, 3, 330, 165, 0, 2234, 2235, 6, 99, -1, 0, 2235, 2237, 1, 0, 0, 0, 2236, 2233, 1, 0, 0, 0, 2237, 2240, 1, 0, 0, 0, 2238, 2236, 1, 0, 0, 0, 2238, 2239, 1, 0, 0, 0, 2239, 2262, 1, 0, 0, 0, 2240, 2238, 1, 0, 0, 0, 2241, 2242, 5, 255, 0, 0, 2242, 2243, 5, 256, 0, 0, 2243, 2244, 3, 2, 1, 0, 2244, 2245, 5, 28, 0, 0, 2245, 2246, 3, 124, 62, 0, 2246, 2252, 6, 99, -1, 0, 2247, 2248, 3, 330, 165, 0, 2248, 2249, 6, 99, -1, 0, 2249, 2251, 1, 0, 0, 0, 2250, 2247, 1, 0, 0, 0, 2251, 2254, 1, 0, 0, 0, 2252, 2250, 1, 0, 0, 0, 2252, 2253, 1, 0, 0, 0, 2253, 2262, 1, 0, 0, 0, 2254, 2252, 1, 0, 0, 0, 2255, 2256, 5, 120, 0, 0, 2256, 2257, 5, 196, 0, 0, 2257, 2258, 3, 124, 62, 0, 2258, 2259, 3, 44, 22, 0, 2259, 2260, 6, 99, -1, 0, 2260, 2262, 1, 0, 0, 0, 2261, 2111, 1, 0, 0, 0, 2261, 2116, 1, 0, 0, 0, 2261, 2121, 1, 0, 0, 0, 2261, 2127, 1, 0, 0, 0, 2261, 2133, 1, 0, 0, 0, 2261, 2134, 1, 0, 0, 0, 2261, 2137, 1, 0, 0, 0, 2261, 2140, 1, 0, 0, 0, 2261, 2143, 1, 0, 0, 0, 2261, 2146, 1, 0, 0, 0, 2261, 2150, 1, 0, 0, 0, 2261, 2154, 1, 0, 0, 0, 2261, 2160, 1, 0, 0, 0, 2261, 2173, 1, 0, 0, 0, 2261, 2193, 1, 0, 0, 0, 2261, 2196, 1, 0, 0, 0, 2261, 2199, 1, 0, 0, 0, 2261, 2213, 1, 0, 0, 0, 2261, 2225, 1, 0, 0, 0, 2261, 2241, 1, 0, 0, 0, 2261, 2255, 1, 0, 0, 0, 2262, 199, 1, 0, 0, 0, 2263, 2264, 5, 121, 0, 0, 2264, 2276, 3, 208, 104, 0, 2265, 2266, 3, 202, 101, 0, 2266, 2267, 6, 100, -1, 0, 2267, 2275, 1, 0, 0, 0, 2268, 2269, 5, 122, 0, 0, 2269, 2270, 5, 30, 0, 0, 2270, 2271, 3, 228, 114, 0, 2271, 2272, 5, 31, 0, 0, 2272, 2273, 6, 100, -1, 0, 2273, 2275, 1, 0, 0, 0, 2274, 2265, 1, 0, 0, 0, 2274, 2268, 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, 2280, 3, 138, 69, 0, 2280, 2281, 3, 2, 1, 0, 2281, 2282, 3, 204, 102, 0, 2282, 2283, 3, 206, 103, 0, 2283, 2284, 6, 100, -1, 0, 2284, 201, 1, 0, 0, 0, 2285, 2286, 5, 123, 0, 0, 2286, 2320, 6, 101, -1, 0, 2287, 2288, 5, 51, 0, 0, 2288, 2320, 6, 101, -1, 0, 2289, 2290, 5, 52, 0, 0, 2290, 2320, 6, 101, -1, 0, 2291, 2292, 5, 63, 0, 0, 2292, 2320, 6, 101, -1, 0, 2293, 2294, 5, 124, 0, 0, 2294, 2320, 6, 101, -1, 0, 2295, 2296, 5, 69, 0, 0, 2296, 2320, 6, 101, -1, 0, 2297, 2298, 5, 68, 0, 0, 2298, 2320, 6, 101, -1, 0, 2299, 2300, 5, 64, 0, 0, 2300, 2320, 6, 101, -1, 0, 2301, 2302, 5, 65, 0, 0, 2302, 2320, 6, 101, -1, 0, 2303, 2304, 5, 66, 0, 0, 2304, 2320, 6, 101, -1, 0, 2305, 2306, 5, 125, 0, 0, 2306, 2320, 6, 101, -1, 0, 2307, 2308, 5, 126, 0, 0, 2308, 2320, 6, 101, -1, 0, 2309, 2310, 5, 127, 0, 0, 2310, 2320, 6, 101, -1, 0, 2311, 2312, 5, 16, 0, 0, 2312, 2320, 6, 101, -1, 0, 2313, 2314, 5, 70, 0, 0, 2314, 2315, 5, 30, 0, 0, 2315, 2316, 3, 32, 16, 0, 2316, 2317, 5, 31, 0, 0, 2317, 2318, 6, 101, -1, 0, 2318, 2320, 1, 0, 0, 0, 2319, 2285, 1, 0, 0, 0, 2319, 2287, 1, 0, 0, 0, 2319, 2289, 1, 0, 0, 0, 2319, 2291, 1, 0, 0, 0, 2319, 2293, 1, 0, 0, 0, 2319, 2295, 1, 0, 0, 0, 2319, 2297, 1, 0, 0, 0, 2319, 2299, 1, 0, 0, 0, 2319, 2301, 1, 0, 0, 0, 2319, 2303, 1, 0, 0, 0, 2319, 2305, 1, 0, 0, 0, 2319, 2307, 1, 0, 0, 0, 2319, 2309, 1, 0, 0, 0, 2319, 2311, 1, 0, 0, 0, 2319, 2313, 1, 0, 0, 0, 2320, 203, 1, 0, 0, 0, 2321, 2331, 1, 0, 0, 0, 2322, 2323, 5, 44, 0, 0, 2323, 2324, 3, 0, 0, 0, 2324, 2325, 6, 102, -1, 0, 2325, 2331, 1, 0, 0, 0, 2326, 2327, 5, 44, 0, 0, 2327, 2328, 3, 32, 16, 0, 2328, 2329, 6, 102, -1, 0, 2329, 2331, 1, 0, 0, 0, 2330, 2321, 1, 0, 0, 0, 2330, 2322, 1, 0, 0, 0, 2330, 2326, 1, 0, 0, 0, 2331, 205, 1, 0, 0, 0, 2332, 2338, 1, 0, 0, 0, 2333, 2334, 5, 36, 0, 0, 2334, 2335, 3, 304, 152, 0, 2335, 2336, 6, 103, -1, 0, 2336, 2338, 1, 0, 0, 0, 2337, 2332, 1, 0, 0, 0, 2337, 2333, 1, 0, 0, 0, 2338, 207, 1, 0, 0, 0, 2339, 2346, 1, 0, 0, 0, 2340, 2341, 5, 42, 0, 0, 2341, 2342, 3, 32, 16, 0, 2342, 2343, 5, 43, 0, 0, 2343, 2344, 6, 104, -1, 0, 2344, 2346, 1, 0, 0, 0, 2345, 2339, 1, 0, 0, 0, 2345, 2340, 1, 0, 0, 0, 2346, 209, 1, 0, 0, 0, 2347, 2353, 5, 128, 0, 0, 2348, 2349, 3, 212, 106, 0, 2349, 2350, 6, 105, -1, 0, 2350, 2352, 1, 0, 0, 0, 2351, 2348, 1, 0, 0, 0, 2352, 2355, 1, 0, 0, 0, 2353, 2351, 1, 0, 0, 0, 2353, 2354, 1, 0, 0, 0, 2354, 2356, 1, 0, 0, 0, 2355, 2353, 1, 0, 0, 0, 2356, 2357, 3, 124, 62, 0, 2357, 2358, 3, 2, 1, 0, 2358, 2359, 6, 105, -1, 0, 2359, 2373, 1, 0, 0, 0, 2360, 2366, 5, 128, 0, 0, 2361, 2362, 3, 212, 106, 0, 2362, 2363, 6, 105, -1, 0, 2363, 2365, 1, 0, 0, 0, 2364, 2361, 1, 0, 0, 0, 2365, 2368, 1, 0, 0, 0, 2366, 2364, 1, 0, 0, 0, 2366, 2367, 1, 0, 0, 0, 2367, 2369, 1, 0, 0, 0, 2368, 2366, 1, 0, 0, 0, 2369, 2370, 3, 2, 1, 0, 2370, 2371, 6, 105, -1, 0, 2371, 2373, 1, 0, 0, 0, 2372, 2347, 1, 0, 0, 0, 2372, 2360, 1, 0, 0, 0, 2373, 211, 1, 0, 0, 0, 2374, 2375, 5, 69, 0, 0, 2375, 2379, 6, 106, -1, 0, 2376, 2377, 5, 68, 0, 0, 2377, 2379, 6, 106, -1, 0, 2378, 2374, 1, 0, 0, 0, 2378, 2376, 1, 0, 0, 0, 2379, 213, 1, 0, 0, 0, 2380, 2382, 3, 216, 108, 0, 2381, 2380, 1, 0, 0, 0, 2382, 2385, 1, 0, 0, 0, 2383, 2381, 1, 0, 0, 0, 2383, 2384, 1, 0, 0, 0, 2384, 215, 1, 0, 0, 0, 2385, 2383, 1, 0, 0, 0, 2386, 2387, 5, 129, 0, 0, 2387, 2388, 3, 168, 84, 0, 2388, 2389, 6, 108, -1, 0, 2389, 2413, 1, 0, 0, 0, 2390, 2391, 5, 130, 0, 0, 2391, 2392, 3, 168, 84, 0, 2392, 2393, 6, 108, -1, 0, 2393, 2413, 1, 0, 0, 0, 2394, 2395, 5, 131, 0, 0, 2395, 2396, 3, 168, 84, 0, 2396, 2397, 6, 108, -1, 0, 2397, 2413, 1, 0, 0, 0, 2398, 2399, 5, 132, 0, 0, 2399, 2400, 3, 168, 84, 0, 2400, 2401, 6, 108, -1, 0, 2401, 2413, 1, 0, 0, 0, 2402, 2403, 3, 88, 44, 0, 2403, 2404, 6, 108, -1, 0, 2404, 2413, 1, 0, 0, 0, 2405, 2406, 3, 330, 165, 0, 2406, 2407, 6, 108, -1, 0, 2407, 2413, 1, 0, 0, 0, 2408, 2409, 3, 26, 13, 0, 2409, 2410, 6, 108, -1, 0, 2410, 2413, 1, 0, 0, 0, 2411, 2413, 3, 40, 20, 0, 2412, 2386, 1, 0, 0, 0, 2412, 2390, 1, 0, 0, 0, 2412, 2394, 1, 0, 0, 0, 2412, 2398, 1, 0, 0, 0, 2412, 2402, 1, 0, 0, 0, 2412, 2405, 1, 0, 0, 0, 2412, 2408, 1, 0, 0, 0, 2412, 2411, 1, 0, 0, 0, 2413, 217, 1, 0, 0, 0, 2414, 2420, 5, 133, 0, 0, 2415, 2416, 3, 220, 110, 0, 2416, 2417, 6, 109, -1, 0, 2417, 2419, 1, 0, 0, 0, 2418, 2415, 1, 0, 0, 0, 2419, 2422, 1, 0, 0, 0, 2420, 2418, 1, 0, 0, 0, 2420, 2421, 1, 0, 0, 0, 2421, 2423, 1, 0, 0, 0, 2422, 2420, 1, 0, 0, 0, 2423, 2424, 3, 170, 85, 0, 2424, 2425, 3, 138, 69, 0, 2425, 2426, 3, 2, 1, 0, 2426, 2427, 3, 112, 56, 0, 2427, 2428, 3, 206, 103, 0, 2428, 2429, 6, 109, -1, 0, 2429, 219, 1, 0, 0, 0, 2430, 2431, 5, 69, 0, 0, 2431, 2435, 6, 110, -1, 0, 2432, 2433, 5, 68, 0, 0, 2433, 2435, 6, 110, -1, 0, 2434, 2430, 1, 0, 0, 0, 2434, 2432, 1, 0, 0, 0, 2435, 221, 1, 0, 0, 0, 2436, 2438, 3, 224, 112, 0, 2437, 2436, 1, 0, 0, 0, 2438, 2441, 1, 0, 0, 0, 2439, 2437, 1, 0, 0, 0, 2439, 2440, 1, 0, 0, 0, 2440, 223, 1, 0, 0, 0, 2441, 2439, 1, 0, 0, 0, 2442, 2443, 5, 134, 0, 0, 2443, 2444, 3, 168, 84, 0, 2444, 2445, 6, 112, -1, 0, 2445, 2465, 1, 0, 0, 0, 2446, 2447, 5, 135, 0, 0, 2447, 2448, 3, 168, 84, 0, 2448, 2449, 6, 112, -1, 0, 2449, 2465, 1, 0, 0, 0, 2450, 2451, 5, 132, 0, 0, 2451, 2452, 3, 168, 84, 0, 2452, 2453, 6, 112, -1, 0, 2453, 2465, 1, 0, 0, 0, 2454, 2455, 3, 330, 165, 0, 2455, 2456, 6, 112, -1, 0, 2456, 2465, 1, 0, 0, 0, 2457, 2458, 3, 88, 44, 0, 2458, 2459, 6, 112, -1, 0, 2459, 2465, 1, 0, 0, 0, 2460, 2461, 3, 26, 13, 0, 2461, 2462, 6, 112, -1, 0, 2462, 2465, 1, 0, 0, 0, 2463, 2465, 3, 40, 20, 0, 2464, 2442, 1, 0, 0, 0, 2464, 2446, 1, 0, 0, 0, 2464, 2450, 1, 0, 0, 0, 2464, 2454, 1, 0, 0, 0, 2464, 2457, 1, 0, 0, 0, 2464, 2460, 1, 0, 0, 0, 2464, 2463, 1, 0, 0, 0, 2465, 225, 1, 0, 0, 0, 2466, 2474, 6, 113, -1, 0, 2467, 2468, 5, 122, 0, 0, 2468, 2469, 5, 30, 0, 0, 2469, 2470, 3, 228, 114, 0, 2470, 2471, 5, 31, 0, 0, 2471, 2472, 6, 113, -1, 0, 2472, 2474, 1, 0, 0, 0, 2473, 2466, 1, 0, 0, 0, 2473, 2467, 1, 0, 0, 0, 2474, 227, 1, 0, 0, 0, 2475, 2476, 3, 126, 63, 0, 2476, 2477, 6, 114, -1, 0, 2477, 2489, 1, 0, 0, 0, 2478, 2482, 5, 17, 0, 0, 2479, 2480, 3, 302, 151, 0, 2480, 2481, 6, 114, -1, 0, 2481, 2483, 1, 0, 0, 0, 2482, 2479, 1, 0, 0, 0, 2483, 2484, 1, 0, 0, 0, 2484, 2482, 1, 0, 0, 0, 2484, 2485, 1, 0, 0, 0, 2485, 2486, 1, 0, 0, 0, 2486, 2487, 5, 18, 0, 0, 2487, 2489, 1, 0, 0, 0, 2488, 2475, 1, 0, 0, 0, 2488, 2478, 1, 0, 0, 0, 2489, 229, 1, 0, 0, 0, 2490, 2491, 3, 232, 116, 0, 2491, 2492, 6, 115, -1, 0, 2492, 2494, 1, 0, 0, 0, 2493, 2490, 1, 0, 0, 0, 2494, 2497, 1, 0, 0, 0, 2495, 2493, 1, 0, 0, 0, 2495, 2496, 1, 0, 0, 0, 2496, 231, 1, 0, 0, 0, 2497, 2495, 1, 0, 0, 0, 2498, 2499, 5, 42, 0, 0, 2499, 2500, 5, 136, 0, 0, 2500, 2501, 5, 43, 0, 0, 2501, 2516, 6, 116, -1, 0, 2502, 2503, 5, 42, 0, 0, 2503, 2504, 5, 137, 0, 0, 2504, 2505, 5, 43, 0, 0, 2505, 2516, 6, 116, -1, 0, 2506, 2507, 5, 42, 0, 0, 2507, 2508, 5, 138, 0, 0, 2508, 2509, 5, 43, 0, 0, 2509, 2516, 6, 116, -1, 0, 2510, 2511, 5, 42, 0, 0, 2511, 2512, 3, 32, 16, 0, 2512, 2513, 5, 43, 0, 0, 2513, 2514, 6, 116, -1, 0, 2514, 2516, 1, 0, 0, 0, 2515, 2498, 1, 0, 0, 0, 2515, 2502, 1, 0, 0, 0, 2515, 2506, 1, 0, 0, 0, 2515, 2510, 1, 0, 0, 0, 2516, 233, 1, 0, 0, 0, 2517, 2526, 5, 139, 0, 0, 2518, 2519, 3, 236, 118, 0, 2519, 2520, 6, 117, -1, 0, 2520, 2525, 1, 0, 0, 0, 2521, 2522, 3, 238, 119, 0, 2522, 2523, 6, 117, -1, 0, 2523, 2525, 1, 0, 0, 0, 2524, 2518, 1, 0, 0, 0, 2524, 2521, 1, 0, 0, 0, 2525, 2528, 1, 0, 0, 0, 2526, 2524, 1, 0, 0, 0, 2526, 2527, 1, 0, 0, 0, 2527, 2529, 1, 0, 0, 0, 2528, 2526, 1, 0, 0, 0, 2529, 2530, 3, 170, 85, 0, 2530, 2531, 3, 230, 115, 0, 2531, 2532, 3, 138, 69, 0, 2532, 2533, 3, 226, 113, 0, 2533, 2534, 3, 242, 121, 0, 2534, 2535, 3, 182, 91, 0, 2535, 2541, 3, 112, 56, 0, 2536, 2537, 3, 244, 122, 0, 2537, 2538, 6, 117, -1, 0, 2538, 2540, 1, 0, 0, 0, 2539, 2536, 1, 0, 0, 0, 2540, 2543, 1, 0, 0, 0, 2541, 2539, 1, 0, 0, 0, 2541, 2542, 1, 0, 0, 0, 2542, 2544, 1, 0, 0, 0, 2543, 2541, 1, 0, 0, 0, 2544, 2545, 6, 117, -1, 0, 2545, 235, 1, 0, 0, 0, 2546, 2547, 5, 123, 0, 0, 2547, 2589, 6, 118, -1, 0, 2548, 2549, 5, 51, 0, 0, 2549, 2589, 6, 118, -1, 0, 2550, 2551, 5, 52, 0, 0, 2551, 2589, 6, 118, -1, 0, 2552, 2553, 5, 63, 0, 0, 2553, 2589, 6, 118, -1, 0, 2554, 2555, 5, 140, 0, 0, 2555, 2589, 6, 118, -1, 0, 2556, 2557, 5, 68, 0, 0, 2557, 2589, 6, 118, -1, 0, 2558, 2559, 5, 141, 0, 0, 2559, 2589, 6, 118, -1, 0, 2560, 2561, 5, 142, 0, 0, 2561, 2589, 6, 118, -1, 0, 2562, 2563, 5, 54, 0, 0, 2563, 2589, 6, 118, -1, 0, 2564, 2565, 5, 64, 0, 0, 2565, 2589, 6, 118, -1, 0, 2566, 2567, 5, 65, 0, 0, 2567, 2589, 6, 118, -1, 0, 2568, 2569, 5, 66, 0, 0, 2569, 2589, 6, 118, -1, 0, 2570, 2571, 5, 125, 0, 0, 2571, 2589, 6, 118, -1, 0, 2572, 2573, 5, 143, 0, 0, 2573, 2589, 6, 118, -1, 0, 2574, 2575, 5, 144, 0, 0, 2575, 2589, 6, 118, -1, 0, 2576, 2577, 5, 69, 0, 0, 2577, 2589, 6, 118, -1, 0, 2578, 2579, 5, 145, 0, 0, 2579, 2589, 6, 118, -1, 0, 2580, 2581, 5, 146, 0, 0, 2581, 2589, 6, 118, -1, 0, 2582, 2583, 5, 70, 0, 0, 2583, 2584, 5, 30, 0, 0, 2584, 2585, 3, 32, 16, 0, 2585, 2586, 5, 31, 0, 0, 2586, 2587, 6, 118, -1, 0, 2587, 2589, 1, 0, 0, 0, 2588, 2546, 1, 0, 0, 0, 2588, 2548, 1, 0, 0, 0, 2588, 2550, 1, 0, 0, 0, 2588, 2552, 1, 0, 0, 0, 2588, 2554, 1, 0, 0, 0, 2588, 2556, 1, 0, 0, 0, 2588, 2558, 1, 0, 0, 0, 2588, 2560, 1, 0, 0, 0, 2588, 2562, 1, 0, 0, 0, 2588, 2564, 1, 0, 0, 0, 2588, 2566, 1, 0, 0, 0, 2588, 2568, 1, 0, 0, 0, 2588, 2570, 1, 0, 0, 0, 2588, 2572, 1, 0, 0, 0, 2588, 2574, 1, 0, 0, 0, 2588, 2576, 1, 0, 0, 0, 2588, 2578, 1, 0, 0, 0, 2588, 2580, 1, 0, 0, 0, 2588, 2582, 1, 0, 0, 0, 2589, 237, 1, 0, 0, 0, 2590, 2591, 5, 147, 0, 0, 2591, 2600, 5, 30, 0, 0, 2592, 2593, 3, 6, 3, 0, 2593, 2598, 6, 119, -1, 0, 2594, 2595, 5, 34, 0, 0, 2595, 2596, 3, 6, 3, 0, 2596, 2597, 6, 119, -1, 0, 2597, 2599, 1, 0, 0, 0, 2598, 2594, 1, 0, 0, 0, 2598, 2599, 1, 0, 0, 0, 2599, 2601, 1, 0, 0, 0, 2600, 2592, 1, 0, 0, 0, 2600, 2601, 1, 0, 0, 0, 2601, 2607, 1, 0, 0, 0, 2602, 2603, 3, 240, 120, 0, 2603, 2604, 6, 119, -1, 0, 2604, 2606, 1, 0, 0, 0, 2605, 2602, 1, 0, 0, 0, 2606, 2609, 1, 0, 0, 0, 2607, 2605, 1, 0, 0, 0, 2607, 2608, 1, 0, 0, 0, 2608, 2610, 1, 0, 0, 0, 2609, 2607, 1, 0, 0, 0, 2610, 2614, 5, 31, 0, 0, 2611, 2612, 5, 147, 0, 0, 2612, 2614, 5, 85, 0, 0, 2613, 2590, 1, 0, 0, 0, 2613, 2611, 1, 0, 0, 0, 2614, 239, 1, 0, 0, 0, 2615, 2616, 5, 148, 0, 0, 2616, 2658, 6, 120, -1, 0, 2617, 2618, 5, 224, 0, 0, 2618, 2658, 6, 120, -1, 0, 2619, 2620, 5, 57, 0, 0, 2620, 2658, 6, 120, -1, 0, 2621, 2622, 5, 58, 0, 0, 2622, 2658, 6, 120, -1, 0, 2623, 2624, 5, 149, 0, 0, 2624, 2658, 6, 120, -1, 0, 2625, 2626, 5, 150, 0, 0, 2626, 2658, 6, 120, -1, 0, 2627, 2628, 5, 248, 0, 0, 2628, 2658, 6, 120, -1, 0, 2629, 2630, 5, 249, 0, 0, 2630, 2658, 6, 120, -1, 0, 2631, 2632, 5, 250, 0, 0, 2632, 2658, 6, 120, -1, 0, 2633, 2634, 5, 251, 0, 0, 2634, 2658, 6, 120, -1, 0, 2635, 2636, 5, 151, 0, 0, 2636, 2637, 5, 75, 0, 0, 2637, 2638, 5, 152, 0, 0, 2638, 2658, 6, 120, -1, 0, 2639, 2640, 5, 151, 0, 0, 2640, 2641, 5, 75, 0, 0, 2641, 2642, 5, 153, 0, 0, 2642, 2658, 6, 120, -1, 0, 2643, 2644, 5, 154, 0, 0, 2644, 2645, 5, 75, 0, 0, 2645, 2646, 5, 152, 0, 0, 2646, 2658, 6, 120, -1, 0, 2647, 2648, 5, 154, 0, 0, 2648, 2649, 5, 75, 0, 0, 2649, 2650, 5, 153, 0, 0, 2650, 2658, 6, 120, -1, 0, 2651, 2652, 5, 70, 0, 0, 2652, 2653, 5, 30, 0, 0, 2653, 2654, 3, 32, 16, 0, 2654, 2655, 5, 31, 0, 0, 2655, 2656, 6, 120, -1, 0, 2656, 2658, 1, 0, 0, 0, 2657, 2615, 1, 0, 0, 0, 2657, 2617, 1, 0, 0, 0, 2657, 2619, 1, 0, 0, 0, 2657, 2621, 1, 0, 0, 0, 2657, 2623, 1, 0, 0, 0, 2657, 2625, 1, 0, 0, 0, 2657, 2627, 1, 0, 0, 0, 2657, 2629, 1, 0, 0, 0, 2657, 2631, 1, 0, 0, 0, 2657, 2633, 1, 0, 0, 0, 2657, 2635, 1, 0, 0, 0, 2657, 2639, 1, 0, 0, 0, 2657, 2643, 1, 0, 0, 0, 2657, 2647, 1, 0, 0, 0, 2657, 2651, 1, 0, 0, 0, 2658, 241, 1, 0, 0, 0, 2659, 2660, 5, 116, 0, 0, 2660, 2667, 6, 121, -1, 0, 2661, 2662, 5, 155, 0, 0, 2662, 2667, 6, 121, -1, 0, 2663, 2664, 3, 2, 1, 0, 2664, 2665, 6, 121, -1, 0, 2665, 2667, 1, 0, 0, 0, 2666, 2659, 1, 0, 0, 0, 2666, 2661, 1, 0, 0, 0, 2666, 2663, 1, 0, 0, 0, 2667, 243, 1, 0, 0, 0, 2668, 2669, 5, 1, 0, 0, 2669, 2707, 6, 122, -1, 0, 2670, 2671, 5, 2, 0, 0, 2671, 2707, 6, 122, -1, 0, 2672, 2673, 5, 156, 0, 0, 2673, 2707, 6, 122, -1, 0, 2674, 2675, 5, 3, 0, 0, 2675, 2707, 6, 122, -1, 0, 2676, 2677, 5, 4, 0, 0, 2677, 2707, 6, 122, -1, 0, 2678, 2679, 5, 247, 0, 0, 2679, 2707, 6, 122, -1, 0, 2680, 2681, 5, 5, 0, 0, 2681, 2707, 6, 122, -1, 0, 2682, 2683, 5, 6, 0, 0, 2683, 2707, 6, 122, -1, 0, 2684, 2685, 5, 7, 0, 0, 2685, 2707, 6, 122, -1, 0, 2686, 2687, 5, 8, 0, 0, 2687, 2707, 6, 122, -1, 0, 2688, 2689, 5, 9, 0, 0, 2689, 2707, 6, 122, -1, 0, 2690, 2691, 5, 10, 0, 0, 2691, 2707, 6, 122, -1, 0, 2692, 2693, 5, 11, 0, 0, 2693, 2707, 6, 122, -1, 0, 2694, 2695, 5, 12, 0, 0, 2695, 2707, 6, 122, -1, 0, 2696, 2697, 5, 13, 0, 0, 2697, 2707, 6, 122, -1, 0, 2698, 2699, 5, 14, 0, 0, 2699, 2707, 6, 122, -1, 0, 2700, 2701, 5, 70, 0, 0, 2701, 2702, 5, 30, 0, 0, 2702, 2703, 3, 32, 16, 0, 2703, 2704, 5, 31, 0, 0, 2704, 2705, 6, 122, -1, 0, 2705, 2707, 1, 0, 0, 0, 2706, 2668, 1, 0, 0, 0, 2706, 2670, 1, 0, 0, 0, 2706, 2672, 1, 0, 0, 0, 2706, 2674, 1, 0, 0, 0, 2706, 2676, 1, 0, 0, 0, 2706, 2678, 1, 0, 0, 0, 2706, 2680, 1, 0, 0, 0, 2706, 2682, 1, 0, 0, 0, 2706, 2684, 1, 0, 0, 0, 2706, 2686, 1, 0, 0, 0, 2706, 2688, 1, 0, 0, 0, 2706, 2690, 1, 0, 0, 0, 2706, 2692, 1, 0, 0, 0, 2706, 2694, 1, 0, 0, 0, 2706, 2696, 1, 0, 0, 0, 2706, 2698, 1, 0, 0, 0, 2706, 2700, 1, 0, 0, 0, 2707, 245, 1, 0, 0, 0, 2708, 2710, 3, 248, 124, 0, 2709, 2708, 1, 0, 0, 0, 2710, 2713, 1, 0, 0, 0, 2711, 2709, 1, 0, 0, 0, 2711, 2712, 1, 0, 0, 0, 2712, 247, 1, 0, 0, 0, 2713, 2711, 1, 0, 0, 0, 2714, 2752, 3, 100, 50, 0, 2715, 2716, 5, 296, 0, 0, 2716, 2717, 3, 32, 16, 0, 2717, 2718, 6, 124, -1, 0, 2718, 2752, 1, 0, 0, 0, 2719, 2752, 3, 266, 133, 0, 2720, 2721, 5, 297, 0, 0, 2721, 2722, 3, 32, 16, 0, 2722, 2723, 6, 124, -1, 0, 2723, 2752, 1, 0, 0, 0, 2724, 2725, 5, 298, 0, 0, 2725, 2752, 6, 124, -1, 0, 2726, 2727, 5, 299, 0, 0, 2727, 2752, 6, 124, -1, 0, 2728, 2752, 3, 260, 130, 0, 2729, 2752, 3, 264, 132, 0, 2730, 2752, 3, 250, 125, 0, 2731, 2732, 3, 284, 142, 0, 2732, 2733, 6, 124, -1, 0, 2733, 2752, 1, 0, 0, 0, 2734, 2735, 3, 152, 76, 0, 2735, 2736, 6, 124, -1, 0, 2736, 2752, 1, 0, 0, 0, 2737, 2738, 3, 88, 44, 0, 2738, 2739, 6, 124, -1, 0, 2739, 2752, 1, 0, 0, 0, 2740, 2741, 3, 26, 13, 0, 2741, 2742, 6, 124, -1, 0, 2742, 2752, 1, 0, 0, 0, 2743, 2744, 3, 262, 131, 0, 2744, 2745, 6, 124, -1, 0, 2745, 2752, 1, 0, 0, 0, 2746, 2752, 3, 40, 20, 0, 2747, 2752, 3, 252, 126, 0, 2748, 2752, 3, 254, 127, 0, 2749, 2752, 3, 256, 128, 0, 2750, 2752, 3, 258, 129, 0, 2751, 2714, 1, 0, 0, 0, 2751, 2715, 1, 0, 0, 0, 2751, 2719, 1, 0, 0, 0, 2751, 2720, 1, 0, 0, 0, 2751, 2724, 1, 0, 0, 0, 2751, 2726, 1, 0, 0, 0, 2751, 2728, 1, 0, 0, 0, 2751, 2729, 1, 0, 0, 0, 2751, 2730, 1, 0, 0, 0, 2751, 2731, 1, 0, 0, 0, 2751, 2734, 1, 0, 0, 0, 2751, 2737, 1, 0, 0, 0, 2751, 2740, 1, 0, 0, 0, 2751, 2743, 1, 0, 0, 0, 2751, 2746, 1, 0, 0, 0, 2751, 2747, 1, 0, 0, 0, 2751, 2748, 1, 0, 0, 0, 2751, 2749, 1, 0, 0, 0, 2751, 2750, 1, 0, 0, 0, 2752, 249, 1, 0, 0, 0, 2753, 2755, 5, 300, 0, 0, 2754, 2756, 5, 157, 0, 0, 2755, 2754, 1, 0, 0, 0, 2755, 2756, 1, 0, 0, 0, 2756, 2757, 1, 0, 0, 0, 2757, 2758, 3, 112, 56, 0, 2758, 251, 1, 0, 0, 0, 2759, 2760, 5, 301, 0, 0, 2760, 2761, 5, 42, 0, 0, 2761, 2762, 3, 32, 16, 0, 2762, 2765, 5, 43, 0, 0, 2763, 2764, 5, 34, 0, 0, 2764, 2766, 3, 0, 0, 0, 2765, 2763, 1, 0, 0, 0, 2765, 2766, 1, 0, 0, 0, 2766, 253, 1, 0, 0, 0, 2767, 2768, 5, 303, 0, 0, 2768, 2769, 3, 32, 16, 0, 2769, 2770, 5, 75, 0, 0, 2770, 2771, 3, 32, 16, 0, 2771, 255, 1, 0, 0, 0, 2772, 2773, 5, 302, 0, 0, 2773, 2774, 3, 124, 62, 0, 2774, 2775, 5, 176, 0, 0, 2775, 2776, 3, 242, 121, 0, 2776, 2788, 1, 0, 0, 0, 2777, 2778, 5, 302, 0, 0, 2778, 2779, 5, 226, 0, 0, 2779, 2780, 3, 170, 85, 0, 2780, 2781, 3, 138, 69, 0, 2781, 2782, 3, 124, 62, 0, 2782, 2783, 5, 176, 0, 0, 2783, 2784, 3, 242, 121, 0, 2784, 2785, 3, 194, 97, 0, 2785, 2786, 3, 112, 56, 0, 2786, 2788, 1, 0, 0, 0, 2787, 2772, 1, 0, 0, 0, 2787, 2777, 1, 0, 0, 0, 2788, 257, 1, 0, 0, 0, 2789, 2790, 5, 255, 0, 0, 2790, 2791, 5, 196, 0, 0, 2791, 2792, 5, 42, 0, 0, 2792, 2793, 3, 32, 16, 0, 2793, 2799, 5, 43, 0, 0, 2794, 2795, 3, 330, 165, 0, 2795, 2796, 6, 129, -1, 0, 2796, 2798, 1, 0, 0, 0, 2797, 2794, 1, 0, 0, 0, 2798, 2801, 1, 0, 0, 0, 2799, 2797, 1, 0, 0, 0, 2799, 2800, 1, 0, 0, 0, 2800, 2855, 1, 0, 0, 0, 2801, 2799, 1, 0, 0, 0, 2802, 2803, 5, 255, 0, 0, 2803, 2804, 5, 196, 0, 0, 2804, 2810, 3, 2, 1, 0, 2805, 2806, 3, 330, 165, 0, 2806, 2807, 6, 129, -1, 0, 2807, 2809, 1, 0, 0, 0, 2808, 2805, 1, 0, 0, 0, 2809, 2812, 1, 0, 0, 0, 2810, 2808, 1, 0, 0, 0, 2810, 2811, 1, 0, 0, 0, 2811, 2855, 1, 0, 0, 0, 2812, 2810, 1, 0, 0, 0, 2813, 2814, 5, 255, 0, 0, 2814, 2815, 5, 256, 0, 0, 2815, 2816, 5, 42, 0, 0, 2816, 2817, 3, 32, 16, 0, 2817, 2818, 5, 43, 0, 0, 2818, 2819, 5, 28, 0, 0, 2819, 2825, 3, 124, 62, 0, 2820, 2821, 3, 330, 165, 0, 2821, 2822, 6, 129, -1, 0, 2822, 2824, 1, 0, 0, 0, 2823, 2820, 1, 0, 0, 0, 2824, 2827, 1, 0, 0, 0, 2825, 2823, 1, 0, 0, 0, 2825, 2826, 1, 0, 0, 0, 2826, 2855, 1, 0, 0, 0, 2827, 2825, 1, 0, 0, 0, 2828, 2829, 5, 255, 0, 0, 2829, 2830, 5, 256, 0, 0, 2830, 2831, 3, 2, 1, 0, 2831, 2832, 5, 28, 0, 0, 2832, 2838, 3, 124, 62, 0, 2833, 2834, 3, 330, 165, 0, 2834, 2835, 6, 129, -1, 0, 2835, 2837, 1, 0, 0, 0, 2836, 2833, 1, 0, 0, 0, 2837, 2840, 1, 0, 0, 0, 2838, 2836, 1, 0, 0, 0, 2838, 2839, 1, 0, 0, 0, 2839, 2855, 1, 0, 0, 0, 2840, 2838, 1, 0, 0, 0, 2841, 2842, 5, 255, 0, 0, 2842, 2843, 5, 42, 0, 0, 2843, 2844, 3, 32, 16, 0, 2844, 2845, 5, 43, 0, 0, 2845, 2851, 3, 206, 103, 0, 2846, 2847, 3, 330, 165, 0, 2847, 2848, 6, 129, -1, 0, 2848, 2850, 1, 0, 0, 0, 2849, 2846, 1, 0, 0, 0, 2850, 2853, 1, 0, 0, 0, 2851, 2849, 1, 0, 0, 0, 2851, 2852, 1, 0, 0, 0, 2852, 2855, 1, 0, 0, 0, 2853, 2851, 1, 0, 0, 0, 2854, 2789, 1, 0, 0, 0, 2854, 2802, 1, 0, 0, 0, 2854, 2813, 1, 0, 0, 0, 2854, 2828, 1, 0, 0, 0, 2854, 2841, 1, 0, 0, 0, 2855, 259, 1, 0, 0, 0, 2856, 2857, 3, 0, 0, 0, 2857, 2858, 5, 75, 0, 0, 2858, 2859, 6, 130, -1, 0, 2859, 261, 1, 0, 0, 0, 2860, 2863, 3, 44, 22, 0, 2861, 2863, 3, 46, 23, 0, 2862, 2860, 1, 0, 0, 0, 2862, 2861, 1, 0, 0, 0, 2863, 263, 1, 0, 0, 0, 2864, 2865, 5, 17, 0, 0, 2865, 2866, 3, 246, 123, 0, 2866, 2867, 5, 18, 0, 0, 2867, 265, 1, 0, 0, 0, 2868, 2869, 3, 270, 135, 0, 2869, 2870, 3, 268, 134, 0, 2870, 267, 1, 0, 0, 0, 2871, 2872, 3, 272, 136, 0, 2872, 2873, 6, 134, -1, 0, 2873, 2875, 1, 0, 0, 0, 2874, 2871, 1, 0, 0, 0, 2875, 2876, 1, 0, 0, 0, 2876, 2874, 1, 0, 0, 0, 2876, 2877, 1, 0, 0, 0, 2877, 269, 1, 0, 0, 0, 2878, 2879, 5, 158, 0, 0, 2879, 2880, 3, 264, 132, 0, 2880, 2881, 6, 135, -1, 0, 2881, 2895, 1, 0, 0, 0, 2882, 2883, 5, 158, 0, 0, 2883, 2884, 3, 0, 0, 0, 2884, 2885, 5, 159, 0, 0, 2885, 2886, 3, 0, 0, 0, 2886, 2887, 6, 135, -1, 0, 2887, 2895, 1, 0, 0, 0, 2888, 2889, 5, 158, 0, 0, 2889, 2890, 3, 32, 16, 0, 2890, 2891, 5, 159, 0, 0, 2891, 2892, 3, 32, 16, 0, 2892, 2893, 6, 135, -1, 0, 2893, 2895, 1, 0, 0, 0, 2894, 2878, 1, 0, 0, 0, 2894, 2882, 1, 0, 0, 0, 2894, 2888, 1, 0, 0, 0, 2895, 271, 1, 0, 0, 0, 2896, 2897, 3, 276, 138, 0, 2897, 2898, 3, 282, 141, 0, 2898, 2899, 6, 136, -1, 0, 2899, 2913, 1, 0, 0, 0, 2900, 2901, 3, 274, 137, 0, 2901, 2902, 3, 282, 141, 0, 2902, 2903, 6, 136, -1, 0, 2903, 2913, 1, 0, 0, 0, 2904, 2905, 3, 278, 139, 0, 2905, 2906, 3, 282, 141, 0, 2906, 2907, 6, 136, -1, 0, 2907, 2913, 1, 0, 0, 0, 2908, 2909, 3, 280, 140, 0, 2909, 2910, 3, 282, 141, 0, 2910, 2911, 6, 136, -1, 0, 2911, 2913, 1, 0, 0, 0, 2912, 2896, 1, 0, 0, 0, 2912, 2900, 1, 0, 0, 0, 2912, 2904, 1, 0, 0, 0, 2912, 2908, 1, 0, 0, 0, 2913, 273, 1, 0, 0, 0, 2914, 2915, 5, 160, 0, 0, 2915, 2916, 3, 264, 132, 0, 2916, 2917, 6, 137, -1, 0, 2917, 2927, 1, 0, 0, 0, 2918, 2919, 5, 160, 0, 0, 2919, 2920, 3, 0, 0, 0, 2920, 2921, 6, 137, -1, 0, 2921, 2927, 1, 0, 0, 0, 2922, 2923, 5, 160, 0, 0, 2923, 2924, 3, 32, 16, 0, 2924, 2925, 6, 137, -1, 0, 2925, 2927, 1, 0, 0, 0, 2926, 2914, 1, 0, 0, 0, 2926, 2918, 1, 0, 0, 0, 2926, 2922, 1, 0, 0, 0, 2927, 275, 1, 0, 0, 0, 2928, 2929, 5, 161, 0, 0, 2929, 2930, 3, 124, 62, 0, 2930, 277, 1, 0, 0, 0, 2931, 2932, 5, 162, 0, 0, 2932, 279, 1, 0, 0, 0, 2933, 2934, 5, 163, 0, 0, 2934, 281, 1, 0, 0, 0, 2935, 2936, 3, 264, 132, 0, 2936, 2937, 6, 141, -1, 0, 2937, 2951, 1, 0, 0, 0, 2938, 2939, 5, 164, 0, 0, 2939, 2940, 3, 0, 0, 0, 2940, 2941, 5, 159, 0, 0, 2941, 2942, 3, 0, 0, 0, 2942, 2943, 6, 141, -1, 0, 2943, 2951, 1, 0, 0, 0, 2944, 2945, 5, 164, 0, 0, 2945, 2946, 3, 32, 16, 0, 2946, 2947, 5, 159, 0, 0, 2947, 2948, 3, 32, 16, 0, 2948, 2949, 6, 141, -1, 0, 2949, 2951, 1, 0, 0, 0, 2950, 2935, 1, 0, 0, 0, 2950, 2938, 1, 0, 0, 0, 2950, 2944, 1, 0, 0, 0, 2951, 283, 1, 0, 0, 0, 2952, 2953, 3, 286, 143, 0, 2953, 2954, 3, 290, 145, 0, 2954, 285, 1, 0, 0, 0, 2955, 2956, 5, 165, 0, 0, 2956, 2957, 3, 288, 144, 0, 2957, 2958, 3, 0, 0, 0, 2958, 2959, 5, 36, 0, 0, 2959, 2963, 1, 0, 0, 0, 2960, 2961, 5, 165, 0, 0, 2961, 2963, 3, 288, 144, 0, 2962, 2955, 1, 0, 0, 0, 2962, 2960, 1, 0, 0, 0, 2963, 287, 1, 0, 0, 0, 2964, 2968, 1, 0, 0, 0, 2965, 2968, 5, 166, 0, 0, 2966, 2968, 5, 2, 0, 0, 2967, 2964, 1, 0, 0, 0, 2967, 2965, 1, 0, 0, 0, 2967, 2966, 1, 0, 0, 0, 2968, 289, 1, 0, 0, 0, 2969, 2970, 5, 17, 0, 0, 2970, 2971, 3, 292, 146, 0, 2971, 2972, 5, 18, 0, 0, 2972, 2979, 1, 0, 0, 0, 2973, 2975, 3, 296, 148, 0, 2974, 2973, 1, 0, 0, 0, 2975, 2976, 1, 0, 0, 0, 2976, 2974, 1, 0, 0, 0, 2976, 2977, 1, 0, 0, 0, 2977, 2979, 1, 0, 0, 0, 2978, 2969, 1, 0, 0, 0, 2978, 2974, 1, 0, 0, 0, 2979, 291, 1, 0, 0, 0, 2980, 2981, 3, 296, 148, 0, 2981, 2982, 5, 28, 0, 0, 2982, 2984, 1, 0, 0, 0, 2983, 2980, 1, 0, 0, 0, 2984, 2987, 1, 0, 0, 0, 2985, 2983, 1, 0, 0, 0, 2985, 2986, 1, 0, 0, 0, 2986, 2988, 1, 0, 0, 0, 2987, 2985, 1, 0, 0, 0, 2988, 2989, 3, 296, 148, 0, 2989, 293, 1, 0, 0, 0, 2990, 2996, 1, 0, 0, 0, 2991, 2992, 5, 42, 0, 0, 2992, 2993, 3, 32, 16, 0, 2993, 2994, 5, 43, 0, 0, 2994, 2996, 1, 0, 0, 0, 2995, 2990, 1, 0, 0, 0, 2995, 2991, 1, 0, 0, 0, 2996, 295, 1, 0, 0, 0, 2997, 2998, 5, 181, 0, 0, 2998, 2999, 5, 262, 0, 0, 2999, 3000, 5, 30, 0, 0, 3000, 3001, 3, 6, 3, 0, 3001, 3002, 5, 31, 0, 0, 3002, 3064, 1, 0, 0, 0, 3003, 3004, 5, 260, 0, 0, 3004, 3005, 5, 30, 0, 0, 3005, 3006, 3, 0, 0, 0, 3006, 3007, 5, 31, 0, 0, 3007, 3064, 1, 0, 0, 0, 3008, 3009, 5, 260, 0, 0, 3009, 3064, 3, 0, 0, 0, 3010, 3011, 5, 84, 0, 0, 3011, 3012, 5, 30, 0, 0, 3012, 3013, 3, 300, 150, 0, 3013, 3014, 5, 31, 0, 0, 3014, 3064, 1, 0, 0, 0, 3015, 3016, 5, 188, 0, 0, 3016, 3017, 5, 30, 0, 0, 3017, 3018, 3, 36, 18, 0, 3018, 3019, 5, 31, 0, 0, 3019, 3020, 3, 294, 147, 0, 3020, 3064, 1, 0, 0, 0, 3021, 3022, 5, 189, 0, 0, 3022, 3023, 5, 30, 0, 0, 3023, 3024, 3, 36, 18, 0, 3024, 3025, 5, 31, 0, 0, 3025, 3026, 3, 294, 147, 0, 3026, 3064, 1, 0, 0, 0, 3027, 3028, 5, 187, 0, 0, 3028, 3029, 5, 30, 0, 0, 3029, 3030, 3, 34, 17, 0, 3030, 3031, 5, 31, 0, 0, 3031, 3032, 3, 294, 147, 0, 3032, 3064, 1, 0, 0, 0, 3033, 3034, 5, 186, 0, 0, 3034, 3035, 5, 30, 0, 0, 3035, 3036, 3, 32, 16, 0, 3036, 3037, 5, 31, 0, 0, 3037, 3038, 3, 294, 147, 0, 3038, 3064, 1, 0, 0, 0, 3039, 3040, 5, 185, 0, 0, 3040, 3041, 5, 30, 0, 0, 3041, 3042, 3, 32, 16, 0, 3042, 3043, 5, 31, 0, 0, 3043, 3044, 3, 294, 147, 0, 3044, 3064, 1, 0, 0, 0, 3045, 3046, 5, 184, 0, 0, 3046, 3047, 5, 30, 0, 0, 3047, 3048, 3, 32, 16, 0, 3048, 3049, 5, 31, 0, 0, 3049, 3050, 3, 294, 147, 0, 3050, 3064, 1, 0, 0, 0, 3051, 3052, 5, 188, 0, 0, 3052, 3064, 3, 294, 147, 0, 3053, 3054, 5, 189, 0, 0, 3054, 3064, 3, 294, 147, 0, 3055, 3056, 5, 187, 0, 0, 3056, 3064, 3, 294, 147, 0, 3057, 3058, 5, 186, 0, 0, 3058, 3064, 3, 294, 147, 0, 3059, 3060, 5, 185, 0, 0, 3060, 3064, 3, 294, 147, 0, 3061, 3062, 5, 184, 0, 0, 3062, 3064, 3, 294, 147, 0, 3063, 2997, 1, 0, 0, 0, 3063, 3003, 1, 0, 0, 0, 3063, 3008, 1, 0, 0, 0, 3063, 3010, 1, 0, 0, 0, 3063, 3015, 1, 0, 0, 0, 3063, 3021, 1, 0, 0, 0, 3063, 3027, 1, 0, 0, 0, 3063, 3033, 1, 0, 0, 0, 3063, 3039, 1, 0, 0, 0, 3063, 3045, 1, 0, 0, 0, 3063, 3051, 1, 0, 0, 0, 3063, 3053, 1, 0, 0, 0, 3063, 3055, 1, 0, 0, 0, 3063, 3057, 1, 0, 0, 0, 3063, 3059, 1, 0, 0, 0, 3063, 3061, 1, 0, 0, 0, 3064, 297, 1, 0, 0, 0, 3065, 3066, 5, 188, 0, 0, 3066, 3067, 5, 30, 0, 0, 3067, 3068, 3, 36, 18, 0, 3068, 3069, 5, 31, 0, 0, 3069, 3141, 1, 0, 0, 0, 3070, 3071, 5, 189, 0, 0, 3071, 3072, 5, 30, 0, 0, 3072, 3073, 3, 36, 18, 0, 3073, 3074, 5, 31, 0, 0, 3074, 3141, 1, 0, 0, 0, 3075, 3076, 5, 188, 0, 0, 3076, 3077, 5, 30, 0, 0, 3077, 3078, 3, 32, 16, 0, 3078, 3079, 5, 31, 0, 0, 3079, 3141, 1, 0, 0, 0, 3080, 3081, 5, 189, 0, 0, 3081, 3082, 5, 30, 0, 0, 3082, 3083, 3, 34, 17, 0, 3083, 3084, 5, 31, 0, 0, 3084, 3141, 1, 0, 0, 0, 3085, 3086, 5, 187, 0, 0, 3086, 3087, 5, 30, 0, 0, 3087, 3088, 3, 34, 17, 0, 3088, 3089, 5, 31, 0, 0, 3089, 3141, 1, 0, 0, 0, 3090, 3091, 5, 186, 0, 0, 3091, 3092, 5, 30, 0, 0, 3092, 3093, 3, 32, 16, 0, 3093, 3094, 5, 31, 0, 0, 3094, 3141, 1, 0, 0, 0, 3095, 3096, 5, 185, 0, 0, 3096, 3097, 5, 30, 0, 0, 3097, 3098, 3, 32, 16, 0, 3098, 3099, 5, 31, 0, 0, 3099, 3141, 1, 0, 0, 0, 3100, 3101, 5, 184, 0, 0, 3101, 3102, 5, 30, 0, 0, 3102, 3103, 3, 32, 16, 0, 3103, 3104, 5, 31, 0, 0, 3104, 3141, 1, 0, 0, 0, 3105, 3106, 5, 193, 0, 0, 3106, 3107, 5, 30, 0, 0, 3107, 3108, 3, 34, 17, 0, 3108, 3109, 5, 31, 0, 0, 3109, 3141, 1, 0, 0, 0, 3110, 3111, 5, 192, 0, 0, 3111, 3112, 5, 30, 0, 0, 3112, 3113, 3, 32, 16, 0, 3113, 3114, 5, 31, 0, 0, 3114, 3141, 1, 0, 0, 0, 3115, 3116, 5, 191, 0, 0, 3116, 3117, 5, 30, 0, 0, 3117, 3118, 3, 32, 16, 0, 3118, 3119, 5, 31, 0, 0, 3119, 3141, 1, 0, 0, 0, 3120, 3121, 5, 190, 0, 0, 3121, 3122, 5, 30, 0, 0, 3122, 3123, 3, 32, 16, 0, 3123, 3124, 5, 31, 0, 0, 3124, 3141, 1, 0, 0, 0, 3125, 3126, 5, 181, 0, 0, 3126, 3127, 5, 30, 0, 0, 3127, 3128, 3, 32, 16, 0, 3128, 3129, 5, 31, 0, 0, 3129, 3141, 1, 0, 0, 0, 3130, 3131, 5, 183, 0, 0, 3131, 3132, 5, 30, 0, 0, 3132, 3133, 3, 162, 81, 0, 3133, 3134, 5, 31, 0, 0, 3134, 3141, 1, 0, 0, 0, 3135, 3136, 5, 84, 0, 0, 3136, 3137, 5, 30, 0, 0, 3137, 3138, 3, 300, 150, 0, 3138, 3139, 5, 31, 0, 0, 3139, 3141, 1, 0, 0, 0, 3140, 3065, 1, 0, 0, 0, 3140, 3070, 1, 0, 0, 0, 3140, 3075, 1, 0, 0, 0, 3140, 3080, 1, 0, 0, 0, 3140, 3085, 1, 0, 0, 0, 3140, 3090, 1, 0, 0, 0, 3140, 3095, 1, 0, 0, 0, 3140, 3100, 1, 0, 0, 0, 3140, 3105, 1, 0, 0, 0, 3140, 3110, 1, 0, 0, 0, 3140, 3115, 1, 0, 0, 0, 3140, 3120, 1, 0, 0, 0, 3140, 3125, 1, 0, 0, 0, 3140, 3130, 1, 0, 0, 0, 3140, 3135, 1, 0, 0, 0, 3141, 299, 1, 0, 0, 0, 3142, 3143, 3, 302, 151, 0, 3143, 3144, 6, 150, -1, 0, 3144, 3146, 1, 0, 0, 0, 3145, 3142, 1, 0, 0, 0, 3146, 3149, 1, 0, 0, 0, 3147, 3145, 1, 0, 0, 0, 3147, 3148, 1, 0, 0, 0, 3148, 301, 1, 0, 0, 0, 3149, 3147, 1, 0, 0, 0, 3150, 3151, 7, 10, 0, 0, 3151, 303, 1, 0, 0, 0, 3152, 3156, 3, 298, 149, 0, 3153, 3156, 3, 6, 3, 0, 3154, 3156, 5, 179, 0, 0, 3155, 3152, 1, 0, 0, 0, 3155, 3153, 1, 0, 0, 0, 3155, 3154, 1, 0, 0, 0, 3156, 305, 1, 0, 0, 0, 3157, 3306, 3, 298, 149, 0, 3158, 3159, 5, 182, 0, 0, 3159, 3160, 5, 30, 0, 0, 3160, 3161, 5, 179, 0, 0, 3161, 3306, 5, 31, 0, 0, 3162, 3163, 5, 182, 0, 0, 3163, 3164, 5, 30, 0, 0, 3164, 3165, 5, 264, 0, 0, 3165, 3306, 5, 31, 0, 0, 3166, 3167, 5, 196, 0, 0, 3167, 3168, 5, 30, 0, 0, 3168, 3169, 5, 39, 0, 0, 3169, 3170, 5, 264, 0, 0, 3170, 3306, 5, 31, 0, 0, 3171, 3172, 5, 196, 0, 0, 3172, 3173, 5, 30, 0, 0, 3173, 3174, 3, 116, 58, 0, 3174, 3175, 5, 31, 0, 0, 3175, 3306, 1, 0, 0, 0, 3176, 3177, 5, 196, 0, 0, 3177, 3178, 5, 30, 0, 0, 3178, 3179, 5, 179, 0, 0, 3179, 3306, 5, 31, 0, 0, 3180, 3181, 5, 197, 0, 0, 3181, 3182, 5, 30, 0, 0, 3182, 3183, 3, 306, 153, 0, 3183, 3184, 5, 31, 0, 0, 3184, 3306, 1, 0, 0, 0, 3185, 3186, 5, 188, 0, 0, 3186, 3187, 5, 42, 0, 0, 3187, 3188, 3, 32, 16, 0, 3188, 3189, 5, 43, 0, 0, 3189, 3190, 5, 30, 0, 0, 3190, 3191, 3, 308, 154, 0, 3191, 3192, 5, 31, 0, 0, 3192, 3306, 1, 0, 0, 0, 3193, 3194, 5, 189, 0, 0, 3194, 3195, 5, 42, 0, 0, 3195, 3196, 3, 32, 16, 0, 3196, 3197, 5, 43, 0, 0, 3197, 3198, 5, 30, 0, 0, 3198, 3199, 3, 310, 155, 0, 3199, 3200, 5, 31, 0, 0, 3200, 3306, 1, 0, 0, 0, 3201, 3202, 5, 187, 0, 0, 3202, 3203, 5, 42, 0, 0, 3203, 3204, 3, 32, 16, 0, 3204, 3205, 5, 43, 0, 0, 3205, 3206, 5, 30, 0, 0, 3206, 3207, 3, 312, 156, 0, 3207, 3208, 5, 31, 0, 0, 3208, 3306, 1, 0, 0, 0, 3209, 3210, 5, 186, 0, 0, 3210, 3211, 5, 42, 0, 0, 3211, 3212, 3, 32, 16, 0, 3212, 3213, 5, 43, 0, 0, 3213, 3214, 5, 30, 0, 0, 3214, 3215, 3, 314, 157, 0, 3215, 3216, 5, 31, 0, 0, 3216, 3306, 1, 0, 0, 0, 3217, 3218, 5, 185, 0, 0, 3218, 3219, 5, 42, 0, 0, 3219, 3220, 3, 32, 16, 0, 3220, 3221, 5, 43, 0, 0, 3221, 3222, 5, 30, 0, 0, 3222, 3223, 3, 316, 158, 0, 3223, 3224, 5, 31, 0, 0, 3224, 3306, 1, 0, 0, 0, 3225, 3226, 5, 184, 0, 0, 3226, 3227, 5, 42, 0, 0, 3227, 3228, 3, 32, 16, 0, 3228, 3229, 5, 43, 0, 0, 3229, 3230, 5, 30, 0, 0, 3230, 3231, 3, 318, 159, 0, 3231, 3232, 5, 31, 0, 0, 3232, 3306, 1, 0, 0, 0, 3233, 3234, 5, 193, 0, 0, 3234, 3235, 5, 42, 0, 0, 3235, 3236, 3, 32, 16, 0, 3236, 3237, 5, 43, 0, 0, 3237, 3238, 5, 30, 0, 0, 3238, 3239, 3, 312, 156, 0, 3239, 3240, 5, 31, 0, 0, 3240, 3306, 1, 0, 0, 0, 3241, 3242, 5, 192, 0, 0, 3242, 3243, 5, 42, 0, 0, 3243, 3244, 3, 32, 16, 0, 3244, 3245, 5, 43, 0, 0, 3245, 3246, 5, 30, 0, 0, 3246, 3247, 3, 314, 157, 0, 3247, 3248, 5, 31, 0, 0, 3248, 3306, 1, 0, 0, 0, 3249, 3250, 5, 191, 0, 0, 3250, 3251, 5, 42, 0, 0, 3251, 3252, 3, 32, 16, 0, 3252, 3253, 5, 43, 0, 0, 3253, 3254, 5, 30, 0, 0, 3254, 3255, 3, 316, 158, 0, 3255, 3256, 5, 31, 0, 0, 3256, 3306, 1, 0, 0, 0, 3257, 3258, 5, 190, 0, 0, 3258, 3259, 5, 42, 0, 0, 3259, 3260, 3, 32, 16, 0, 3260, 3261, 5, 43, 0, 0, 3261, 3262, 5, 30, 0, 0, 3262, 3263, 3, 318, 159, 0, 3263, 3264, 5, 31, 0, 0, 3264, 3306, 1, 0, 0, 0, 3265, 3266, 5, 181, 0, 0, 3266, 3267, 5, 42, 0, 0, 3267, 3268, 3, 32, 16, 0, 3268, 3269, 5, 43, 0, 0, 3269, 3270, 5, 30, 0, 0, 3270, 3271, 3, 316, 158, 0, 3271, 3272, 5, 31, 0, 0, 3272, 3306, 1, 0, 0, 0, 3273, 3274, 5, 183, 0, 0, 3274, 3275, 5, 42, 0, 0, 3275, 3276, 3, 32, 16, 0, 3276, 3277, 5, 43, 0, 0, 3277, 3278, 5, 30, 0, 0, 3278, 3279, 3, 320, 160, 0, 3279, 3280, 5, 31, 0, 0, 3280, 3306, 1, 0, 0, 0, 3281, 3282, 5, 182, 0, 0, 3282, 3283, 5, 42, 0, 0, 3283, 3284, 3, 32, 16, 0, 3284, 3285, 5, 43, 0, 0, 3285, 3286, 5, 30, 0, 0, 3286, 3287, 3, 322, 161, 0, 3287, 3288, 5, 31, 0, 0, 3288, 3306, 1, 0, 0, 0, 3289, 3290, 5, 196, 0, 0, 3290, 3291, 5, 42, 0, 0, 3291, 3292, 3, 32, 16, 0, 3292, 3293, 5, 43, 0, 0, 3293, 3294, 5, 30, 0, 0, 3294, 3295, 3, 324, 162, 0, 3295, 3296, 5, 31, 0, 0, 3296, 3306, 1, 0, 0, 0, 3297, 3298, 5, 197, 0, 0, 3298, 3299, 5, 42, 0, 0, 3299, 3300, 3, 32, 16, 0, 3300, 3301, 5, 43, 0, 0, 3301, 3302, 5, 30, 0, 0, 3302, 3303, 3, 328, 164, 0, 3303, 3304, 5, 31, 0, 0, 3304, 3306, 1, 0, 0, 0, 3305, 3157, 1, 0, 0, 0, 3305, 3158, 1, 0, 0, 0, 3305, 3162, 1, 0, 0, 0, 3305, 3166, 1, 0, 0, 0, 3305, 3171, 1, 0, 0, 0, 3305, 3176, 1, 0, 0, 0, 3305, 3180, 1, 0, 0, 0, 3305, 3185, 1, 0, 0, 0, 3305, 3193, 1, 0, 0, 0, 3305, 3201, 1, 0, 0, 0, 3305, 3209, 1, 0, 0, 0, 3305, 3217, 1, 0, 0, 0, 3305, 3225, 1, 0, 0, 0, 3305, 3233, 1, 0, 0, 0, 3305, 3241, 1, 0, 0, 0, 3305, 3249, 1, 0, 0, 0, 3305, 3257, 1, 0, 0, 0, 3305, 3265, 1, 0, 0, 0, 3305, 3273, 1, 0, 0, 0, 3305, 3281, 1, 0, 0, 0, 3305, 3289, 1, 0, 0, 0, 3305, 3297, 1, 0, 0, 0, 3306, 307, 1, 0, 0, 0, 3307, 3310, 3, 36, 18, 0, 3308, 3310, 3, 32, 16, 0, 3309, 3307, 1, 0, 0, 0, 3309, 3308, 1, 0, 0, 0, 3310, 3313, 1, 0, 0, 0, 3311, 3309, 1, 0, 0, 0, 3311, 3312, 1, 0, 0, 0, 3312, 309, 1, 0, 0, 0, 3313, 3311, 1, 0, 0, 0, 3314, 3317, 3, 36, 18, 0, 3315, 3317, 3, 34, 17, 0, 3316, 3314, 1, 0, 0, 0, 3316, 3315, 1, 0, 0, 0, 3317, 3320, 1, 0, 0, 0, 3318, 3316, 1, 0, 0, 0, 3318, 3319, 1, 0, 0, 0, 3319, 311, 1, 0, 0, 0, 3320, 3318, 1, 0, 0, 0, 3321, 3323, 3, 34, 17, 0, 3322, 3321, 1, 0, 0, 0, 3323, 3326, 1, 0, 0, 0, 3324, 3322, 1, 0, 0, 0, 3324, 3325, 1, 0, 0, 0, 3325, 313, 1, 0, 0, 0, 3326, 3324, 1, 0, 0, 0, 3327, 3329, 3, 32, 16, 0, 3328, 3327, 1, 0, 0, 0, 3329, 3332, 1, 0, 0, 0, 3330, 3328, 1, 0, 0, 0, 3330, 3331, 1, 0, 0, 0, 3331, 315, 1, 0, 0, 0, 3332, 3330, 1, 0, 0, 0, 3333, 3335, 3, 32, 16, 0, 3334, 3333, 1, 0, 0, 0, 3335, 3338, 1, 0, 0, 0, 3336, 3334, 1, 0, 0, 0, 3336, 3337, 1, 0, 0, 0, 3337, 317, 1, 0, 0, 0, 3338, 3336, 1, 0, 0, 0, 3339, 3341, 3, 32, 16, 0, 3340, 3339, 1, 0, 0, 0, 3341, 3344, 1, 0, 0, 0, 3342, 3340, 1, 0, 0, 0, 3342, 3343, 1, 0, 0, 0, 3343, 319, 1, 0, 0, 0, 3344, 3342, 1, 0, 0, 0, 3345, 3347, 3, 162, 81, 0, 3346, 3345, 1, 0, 0, 0, 3347, 3350, 1, 0, 0, 0, 3348, 3346, 1, 0, 0, 0, 3348, 3349, 1, 0, 0, 0, 3349, 321, 1, 0, 0, 0, 3350, 3348, 1, 0, 0, 0, 3351, 3353, 7, 11, 0, 0, 3352, 3351, 1, 0, 0, 0, 3353, 3356, 1, 0, 0, 0, 3354, 3352, 1, 0, 0, 0, 3354, 3355, 1, 0, 0, 0, 3355, 323, 1, 0, 0, 0, 3356, 3354, 1, 0, 0, 0, 3357, 3359, 3, 326, 163, 0, 3358, 3357, 1, 0, 0, 0, 3359, 3362, 1, 0, 0, 0, 3360, 3358, 1, 0, 0, 0, 3360, 3361, 1, 0, 0, 0, 3361, 325, 1, 0, 0, 0, 3362, 3360, 1, 0, 0, 0, 3363, 3368, 5, 179, 0, 0, 3364, 3365, 5, 39, 0, 0, 3365, 3368, 5, 264, 0, 0, 3366, 3368, 3, 116, 58, 0, 3367, 3363, 1, 0, 0, 0, 3367, 3364, 1, 0, 0, 0, 3367, 3366, 1, 0, 0, 0, 3368, 327, 1, 0, 0, 0, 3369, 3371, 3, 306, 153, 0, 3370, 3369, 1, 0, 0, 0, 3371, 3374, 1, 0, 0, 0, 3372, 3370, 1, 0, 0, 0, 3372, 3373, 1, 0, 0, 0, 3373, 329, 1, 0, 0, 0, 3374, 3372, 1, 0, 0, 0, 3375, 3379, 3, 44, 22, 0, 3376, 3379, 3, 46, 23, 0, 3377, 3379, 3, 2, 1, 0, 3378, 3375, 1, 0, 0, 0, 3378, 3376, 1, 0, 0, 0, 3378, 3377, 1, 0, 0, 0, 3379, 331, 1, 0, 0, 0, 3380, 3381, 7, 12, 0, 0, 3381, 3382, 5, 36, 0, 0, 3382, 3383, 5, 30, 0, 0, 3383, 3384, 3, 300, 150, 0, 3384, 3385, 5, 31, 0, 0, 3385, 3406, 1, 0, 0, 0, 3386, 3387, 5, 169, 0, 0, 3387, 3388, 3, 38, 19, 0, 3388, 3389, 5, 75, 0, 0, 3389, 3390, 3, 38, 19, 0, 3390, 3391, 5, 75, 0, 0, 3391, 3392, 3, 38, 19, 0, 3392, 3393, 5, 75, 0, 0, 3393, 3394, 3, 38, 19, 0, 3394, 3406, 1, 0, 0, 0, 3395, 3396, 5, 170, 0, 0, 3396, 3406, 3, 6, 3, 0, 3397, 3398, 5, 170, 0, 0, 3398, 3399, 5, 36, 0, 0, 3399, 3400, 5, 30, 0, 0, 3400, 3401, 3, 300, 150, 0, 3401, 3402, 5, 31, 0, 0, 3402, 3406, 1, 0, 0, 0, 3403, 3406, 3, 330, 165, 0, 3404, 3406, 3, 40, 20, 0, 3405, 3380, 1, 0, 0, 0, 3405, 3386, 1, 0, 0, 0, 3405, 3395, 1, 0, 0, 0, 3405, 3397, 1, 0, 0, 0, 3405, 3403, 1, 0, 0, 0, 3405, 3404, 1, 0, 0, 0, 3406, 333, 1, 0, 0, 0, 3407, 3408, 3, 336, 168, 0, 3408, 3409, 5, 17, 0, 0, 3409, 3410, 3, 338, 169, 0, 3410, 3411, 5, 18, 0, 0, 3411, 335, 1, 0, 0, 0, 3412, 3413, 5, 25, 0, 0, 3413, 3414, 5, 40, 0, 0, 3414, 3415, 3, 98, 49, 0, 3415, 3416, 3, 2, 1, 0, 3416, 3425, 1, 0, 0, 0, 3417, 3418, 5, 25, 0, 0, 3418, 3419, 5, 40, 0, 0, 3419, 3420, 3, 98, 49, 0, 3420, 3421, 3, 2, 1, 0, 3421, 3422, 5, 34, 0, 0, 3422, 3423, 3, 2, 1, 0, 3423, 3425, 1, 0, 0, 0, 3424, 3412, 1, 0, 0, 0, 3424, 3417, 1, 0, 0, 0, 3425, 337, 1, 0, 0, 0, 3426, 3428, 3, 340, 170, 0, 3427, 3426, 1, 0, 0, 0, 3428, 3431, 1, 0, 0, 0, 3429, 3427, 1, 0, 0, 0, 3429, 3430, 1, 0, 0, 0, 3430, 339, 1, 0, 0, 0, 3431, 3429, 1, 0, 0, 0, 3432, 3433, 5, 180, 0, 0, 3433, 3434, 5, 36, 0, 0, 3434, 3435, 5, 30, 0, 0, 3435, 3436, 3, 300, 150, 0, 3436, 3437, 5, 31, 0, 0, 3437, 3447, 1, 0, 0, 0, 3438, 3447, 3, 332, 166, 0, 3439, 3440, 5, 171, 0, 0, 3440, 3441, 5, 36, 0, 0, 3441, 3442, 5, 30, 0, 0, 3442, 3443, 3, 300, 150, 0, 3443, 3444, 5, 31, 0, 0, 3444, 3447, 1, 0, 0, 0, 3445, 3447, 5, 55, 0, 0, 3446, 3432, 1, 0, 0, 0, 3446, 3438, 1, 0, 0, 0, 3446, 3439, 1, 0, 0, 0, 3446, 3445, 1, 0, 0, 0, 3447, 341, 1, 0, 0, 0, 3448, 3449, 3, 344, 172, 0, 3449, 3450, 5, 17, 0, 0, 3450, 3451, 3, 350, 175, 0, 3451, 3452, 5, 18, 0, 0, 3452, 343, 1, 0, 0, 0, 3453, 3454, 5, 50, 0, 0, 3454, 3458, 5, 40, 0, 0, 3455, 3457, 3, 348, 174, 0, 3456, 3455, 1, 0, 0, 0, 3457, 3460, 1, 0, 0, 0, 3458, 3456, 1, 0, 0, 0, 3458, 3459, 1, 0, 0, 0, 3459, 3461, 1, 0, 0, 0, 3460, 3458, 1, 0, 0, 0, 3461, 3462, 3, 2, 1, 0, 3462, 345, 1, 0, 0, 0, 3463, 3467, 5, 301, 0, 0, 3464, 3466, 3, 348, 174, 0, 3465, 3464, 1, 0, 0, 0, 3466, 3469, 1, 0, 0, 0, 3467, 3465, 1, 0, 0, 0, 3467, 3468, 1, 0, 0, 0, 3468, 3470, 1, 0, 0, 0, 3469, 3467, 1, 0, 0, 0, 3470, 3471, 3, 2, 1, 0, 3471, 347, 1, 0, 0, 0, 3472, 3488, 5, 52, 0, 0, 3473, 3488, 5, 51, 0, 0, 3474, 3488, 5, 172, 0, 0, 3475, 3476, 5, 62, 0, 0, 3476, 3488, 5, 51, 0, 0, 3477, 3478, 5, 62, 0, 0, 3478, 3488, 5, 52, 0, 0, 3479, 3480, 5, 62, 0, 0, 3480, 3488, 5, 63, 0, 0, 3481, 3482, 5, 62, 0, 0, 3482, 3488, 5, 64, 0, 0, 3483, 3484, 5, 62, 0, 0, 3484, 3488, 5, 65, 0, 0, 3485, 3486, 5, 62, 0, 0, 3486, 3488, 5, 66, 0, 0, 3487, 3472, 1, 0, 0, 0, 3487, 3473, 1, 0, 0, 0, 3487, 3474, 1, 0, 0, 0, 3487, 3475, 1, 0, 0, 0, 3487, 3477, 1, 0, 0, 0, 3487, 3479, 1, 0, 0, 0, 3487, 3481, 1, 0, 0, 0, 3487, 3483, 1, 0, 0, 0, 3487, 3485, 1, 0, 0, 0, 3488, 349, 1, 0, 0, 0, 3489, 3491, 3, 352, 176, 0, 3490, 3489, 1, 0, 0, 0, 3491, 3494, 1, 0, 0, 0, 3492, 3490, 1, 0, 0, 0, 3492, 3493, 1, 0, 0, 0, 3493, 351, 1, 0, 0, 0, 3494, 3492, 1, 0, 0, 0, 3495, 3496, 5, 21, 0, 0, 3496, 3509, 3, 2, 1, 0, 3497, 3498, 5, 50, 0, 0, 3498, 3499, 5, 40, 0, 0, 3499, 3509, 3, 118, 59, 0, 3500, 3501, 5, 25, 0, 0, 3501, 3502, 5, 40, 0, 0, 3502, 3509, 3, 2, 1, 0, 3503, 3509, 3, 174, 87, 0, 3504, 3505, 5, 50, 0, 0, 3505, 3509, 3, 32, 16, 0, 3506, 3509, 3, 330, 165, 0, 3507, 3509, 3, 40, 20, 0, 3508, 3495, 1, 0, 0, 0, 3508, 3497, 1, 0, 0, 0, 3508, 3500, 1, 0, 0, 0, 3508, 3503, 1, 0, 0, 0, 3508, 3504, 1, 0, 0, 0, 3508, 3506, 1, 0, 0, 0, 3508, 3507, 1, 0, 0, 0, 3509, 353, 1, 0, 0, 0, 3510, 3511, 3, 356, 178, 0, 3511, 3512, 5, 17, 0, 0, 3512, 3513, 3, 360, 180, 0, 3513, 3514, 5, 18, 0, 0, 3514, 355, 1, 0, 0, 0, 3515, 3519, 5, 274, 0, 0, 3516, 3518, 3, 358, 179, 0, 3517, 3516, 1, 0, 0, 0, 3518, 3521, 1, 0, 0, 0, 3519, 3517, 1, 0, 0, 0, 3519, 3520, 1, 0, 0, 0, 3520, 3522, 1, 0, 0, 0, 3521, 3519, 1, 0, 0, 0, 3522, 3535, 3, 2, 1, 0, 3523, 3527, 5, 274, 0, 0, 3524, 3526, 3, 358, 179, 0, 3525, 3524, 1, 0, 0, 0, 3526, 3529, 1, 0, 0, 0, 3527, 3525, 1, 0, 0, 0, 3527, 3528, 1, 0, 0, 0, 3528, 3530, 1, 0, 0, 0, 3529, 3527, 1, 0, 0, 0, 3530, 3531, 3, 2, 1, 0, 3531, 3532, 5, 34, 0, 0, 3532, 3533, 3, 2, 1, 0, 3533, 3535, 1, 0, 0, 0, 3534, 3515, 1, 0, 0, 0, 3534, 3523, 1, 0, 0, 0, 3535, 357, 1, 0, 0, 0, 3536, 3537, 7, 13, 0, 0, 3537, 359, 1, 0, 0, 0, 3538, 3540, 3, 362, 181, 0, 3539, 3538, 1, 0, 0, 0, 3540, 3543, 1, 0, 0, 0, 3541, 3539, 1, 0, 0, 0, 3541, 3542, 1, 0, 0, 0, 3542, 361, 1, 0, 0, 0, 3543, 3541, 1, 0, 0, 0, 3544, 3545, 5, 21, 0, 0, 3545, 3546, 3, 2, 1, 0, 3546, 3547, 5, 44, 0, 0, 3547, 3548, 3, 32, 16, 0, 3548, 3555, 1, 0, 0, 0, 3549, 3550, 5, 25, 0, 0, 3550, 3551, 5, 40, 0, 0, 3551, 3555, 3, 2, 1, 0, 3552, 3555, 3, 330, 165, 0, 3553, 3555, 3, 40, 20, 0, 3554, 3544, 1, 0, 0, 0, 3554, 3549, 1, 0, 0, 0, 3554, 3552, 1, 0, 0, 0, 3554, 3553, 1, 0, 0, 0, 3555, 363, 1, 0, 0, 0, 181, 374, 382, 391, 400, 489, 535, 546, 576, 580, 598, 625, 648, 684, 694, 701, 703, 713, 715, 722, 733, 746, 767, 769, 788, 861, 868, 875, 880, 889, 1000, 1006, 1022, 1028, 1034, 1041, 1069, 1147, 1149, 1163, 1169, 1178, 1180, 1189, 1203, 1217, 1225, 1233, 1237, 1276, 1284, 1293, 1301, 1320, 1330, 1333, 1357, 1504, 1514, 1523, 1526, 1608, 1617, 1649, 1709, 1749, 1765, 1775, 1802, 1826, 1834, 1838, 1853, 1860, 1905, 1915, 1933, 1951, 1970, 1991, 2010, 2025, 2033, 2045, 2065, 2072, 2077, 2088, 2100, 2210, 2222, 2238, 2252, 2261, 2274, 2276, 2319, 2330, 2337, 2345, 2353, 2366, 2372, 2378, 2383, 2412, 2420, 2434, 2439, 2464, 2473, 2484, 2488, 2495, 2515, 2524, 2526, 2541, 2588, 2598, 2600, 2607, 2613, 2657, 2666, 2706, 2711, 2751, 2755, 2765, 2787, 2799, 2810, 2825, 2838, 2851, 2854, 2862, 2876, 2894, 2912, 2926, 2950, 2962, 2967, 2976, 2978, 2985, 2995, 3063, 3140, 3147, 3155, 3305, 3309, 3311, 3316, 3318, 3324, 3330, 3336, 3342, 3348, 3354, 3360, 3367, 3372, 3378, 3405, 3424, 3429, 3446, 3458, 3467, 3487, 3492, 3508, 3519, 3527, 3534, 3541, 3554] \ No newline at end of file diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILBaseVisitor.cs b/src/tools/ilasm/src/ILAssembler/gen/CILBaseVisitor.cs index 9e101306c41a2d..3f53a66a969763 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILBaseVisitor.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILBaseVisitor.cs @@ -1829,6 +1829,16 @@ public partial class CILBaseVisitor : AbstractParseTreeVisitor, /// The visitor result. public virtual Result VisitAsmOrRefDecl([NotNull] CILParser.AsmOrRefDeclContext context) { return VisitChildren(context); } /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitAssemblyRefBlock([NotNull] CILParser.AssemblyRefBlockContext context) { return VisitChildren(context); } + /// /// Visit a parse tree produced by . /// /// The default implementation returns the result of calling @@ -1859,6 +1869,16 @@ public partial class CILBaseVisitor : AbstractParseTreeVisitor, /// The visitor result. public virtual Result VisitAssemblyRefDecl([NotNull] CILParser.AssemblyRefDeclContext context) { return VisitChildren(context); } /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitExptypeBlock([NotNull] CILParser.ExptypeBlockContext context) { return VisitChildren(context); } + /// /// Visit a parse tree produced by . /// /// The default implementation returns the result of calling @@ -1909,6 +1929,16 @@ public partial class CILBaseVisitor : AbstractParseTreeVisitor, /// The visitor result. public virtual Result VisitExptypeDecl([NotNull] CILParser.ExptypeDeclContext context) { return VisitChildren(context); } /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitManifestResBlock([NotNull] CILParser.ManifestResBlockContext context) { return VisitChildren(context); } + /// /// Visit a parse tree produced by . /// /// The default implementation returns the result of calling diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs index 0249f26925167e..ba1fbafedaca4b 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs @@ -134,11 +134,11 @@ public const int RULE_f32seq = 154, RULE_f64seq = 155, RULE_i64seq = 156, RULE_i32seq = 157, RULE_i16seq = 158, RULE_i8seq = 159, RULE_boolSeq = 160, RULE_sqstringSeq = 161, RULE_classSeq = 162, RULE_classSeqElement = 163, RULE_objSeq = 164, RULE_customAttrDecl = 165, - RULE_asmOrRefDecl = 166, RULE_assemblyRefHead = 167, RULE_assemblyRefDecls = 168, - RULE_assemblyRefDecl = 169, RULE_exptypeHead = 170, RULE_exportHead = 171, - RULE_exptAttr = 172, RULE_exptypeDecls = 173, RULE_exptypeDecl = 174, - RULE_manifestResHead = 175, RULE_manresAttr = 176, RULE_manifestResDecls = 177, - RULE_manifestResDecl = 178; + RULE_asmOrRefDecl = 166, RULE_assemblyRefBlock = 167, RULE_assemblyRefHead = 168, + RULE_assemblyRefDecls = 169, RULE_assemblyRefDecl = 170, RULE_exptypeBlock = 171, + RULE_exptypeHead = 172, RULE_exportHead = 173, RULE_exptAttr = 174, RULE_exptypeDecls = 175, + RULE_exptypeDecl = 176, RULE_manifestResBlock = 177, RULE_manifestResHead = 178, + RULE_manresAttr = 179, RULE_manifestResDecls = 180, RULE_manifestResDecl = 181; public static readonly string[] ruleNames = { "id", "dottedName", "dottedNamePart", "compQstring", "decls", "decl", "subsystem", "corflags", "alignment", "imagebase", "stackreserve", "assemblyBlock", @@ -169,9 +169,10 @@ public const int "ddHead", "tls", "ddBody", "ddItemList", "ddItemCount", "ddItem", "fieldSerInit", "bytes", "hexbyte", "fieldInit", "serInit", "f32seq", "f64seq", "i64seq", "i32seq", "i16seq", "i8seq", "boolSeq", "sqstringSeq", "classSeq", "classSeqElement", - "objSeq", "customAttrDecl", "asmOrRefDecl", "assemblyRefHead", "assemblyRefDecls", - "assemblyRefDecl", "exptypeHead", "exportHead", "exptAttr", "exptypeDecls", - "exptypeDecl", "manifestResHead", "manresAttr", "manifestResDecls", "manifestResDecl" + "objSeq", "customAttrDecl", "asmOrRefDecl", "assemblyRefBlock", "assemblyRefHead", + "assemblyRefDecls", "assemblyRefDecl", "exptypeBlock", "exptypeHead", + "exportHead", "exptAttr", "exptypeDecls", "exptypeDecl", "manifestResBlock", + "manifestResHead", "manresAttr", "manifestResDecls", "manifestResDecl" }; private static readonly string[] _LiteralNames = { @@ -322,7 +323,7 @@ public IdContext id() { try { EnterOuterAlt(_localctx, 1); { - State = 358; + State = 364; _la = TokenStream.LA(1); if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 65534L) != 0) || ((((_la - 199)) & ~0x3f) == 0 && ((1L << (_la - 199)) & 299067162755073L) != 0) || _la==SQSTRING || _la==ID) ) { ErrorHandler.RecoverInline(this); @@ -382,13 +383,13 @@ public DottedNameContext dottedName() { Actions.BeginDottedName(_localctx); try { int _alt; - State = 376; + State = 382; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,1,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 360; + State = 366; _localctx.direct = Match(DOTTEDNAME); Actions.AddDottedNameToken(_localctx, _localctx.direct); } @@ -397,26 +398,26 @@ public DottedNameContext dottedName() { EnterOuterAlt(_localctx, 2); { { - State = 368; + State = 374; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,0,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 362; + State = 368; _localctx.part = dottedNamePart(); Actions.AddDottedNamePart(_localctx, _localctx.part.Value); - State = 364; + State = 370; Match(DOT); } } } - State = 370; + State = 376; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,0,Context); } - State = 371; + State = 377; _localctx.tail = dottedNamePart(); Actions.AddDottedNamePart(_localctx, _localctx.tail.Value); } @@ -425,7 +426,7 @@ public DottedNameContext dottedName() { case 3: EnterOuterAlt(_localctx, 3); { - State = 374; + State = 380; _localctx.quoted = Match(SQSTRING); Actions.AddDottedNameToken(_localctx, _localctx.quoted); } @@ -472,7 +473,7 @@ public DottedNamePartContext dottedNamePart() { try { EnterOuterAlt(_localctx, 1); { - State = 378; + State = 384; _la = TokenStream.LA(1); if ( !(_la==T__15 || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50331649L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -530,26 +531,26 @@ public CompQstringContext compQstring() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 385; + State = 391; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,2,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 380; + State = 386; _localctx.head = Match(QSTRING); Actions.AddComposedStringPart(_localctx, _localctx.head); - State = 382; + State = 388; Match(PLUS); } } } - State = 387; + State = 393; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,2,Context); } - State = 388; + State = 394; _localctx.tail = Match(QSTRING); Actions.AddComposedStringPart(_localctx, _localctx.tail); } @@ -595,17 +596,17 @@ public DeclsContext decls() { try { EnterOuterAlt(_localctx, 1); { - State = 394; + State = 400; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1972571905523712L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 281474976710659L) != 0) || ((((_la - 139)) & ~0x3f) == 0 && ((1L << (_la - 139)) & 1729382256977379329L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 6860956837609473L) != 0)) { { { - State = 391; + State = 397; decl(); } } - State = 396; + State = 402; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -624,6 +625,20 @@ public DeclsContext decls() { } public partial class DeclContext : ParserRuleContext { + public DataDeclContext data; + public VtableDeclContext vtable; + public VtfixupDeclContext vtfixup; + public ExtSourceSpecContext source; + public FileDeclContext file; + public AssemblyBlockContext assembly; + public AssemblyRefBlockContext assemblyReference; + public ExptypeBlockContext exportedType; + public ManifestResBlockContext resource; + public ModuleHeadContext module; + public SecDeclContext security; + public CustomAttrDeclContext attribute; + public LanguageDeclContext language; + public TypedefDeclContext typedef; [System.Diagnostics.DebuggerNonUserCode] public ClassHeadContext classHead() { return GetRuleContext(0); } @@ -663,23 +678,14 @@ [System.Diagnostics.DebuggerNonUserCode] public FileDeclContext fileDecl() { [System.Diagnostics.DebuggerNonUserCode] public AssemblyBlockContext assemblyBlock() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public AssemblyRefHeadContext assemblyRefHead() { - return GetRuleContext(0); - } - [System.Diagnostics.DebuggerNonUserCode] public AssemblyRefDeclsContext assemblyRefDecls() { - return GetRuleContext(0); - } - [System.Diagnostics.DebuggerNonUserCode] public ExptypeHeadContext exptypeHead() { - return GetRuleContext(0); - } - [System.Diagnostics.DebuggerNonUserCode] public ExptypeDeclsContext exptypeDecls() { - return GetRuleContext(0); + [System.Diagnostics.DebuggerNonUserCode] public AssemblyRefBlockContext assemblyRefBlock() { + return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public ManifestResHeadContext manifestResHead() { - return GetRuleContext(0); + [System.Diagnostics.DebuggerNonUserCode] public ExptypeBlockContext exptypeBlock() { + return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public ManifestResDeclsContext manifestResDecls() { - return GetRuleContext(0); + [System.Diagnostics.DebuggerNonUserCode] public ManifestResBlockContext manifestResBlock() { + return GetRuleContext(0); } [System.Diagnostics.DebuggerNonUserCode] public ModuleHeadContext moduleHead() { return GetRuleContext(0); @@ -737,232 +743,246 @@ public override TResult Accept(IParseTreeVisitor visitor) { public DeclContext decl() { DeclContext _localctx = new DeclContext(Context, State); EnterRule(_localctx, 10, RULE_decl); - BeginSubtree(); + BeginStreaming(); try { - State = 447; + State = 489; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,4,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 397; + State = 403; classHead(); - State = 398; + State = 404; Match(T__16); - State = 399; + State = 405; classDecls(); - State = 400; + State = 406; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 402; + State = 408; nameSpaceHead(); - State = 403; + State = 409; Match(T__16); - State = 404; + State = 410; decls(); - State = 405; + State = 411; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 407; + State = 413; methodHead(); - State = 408; + State = 414; Match(T__16); - State = 409; + State = 415; methodDecls(); - State = 410; + State = 416; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 412; + State = 418; fieldDecl(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 413; - dataDecl(); + Actions.BeginTopLevelDirective(); + State = 420; + _localctx.data = dataDecl(); + Actions.ProcessTopLevelDataDeclaration(_localctx.data); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 414; - vtableDecl(); + Actions.BeginTopLevelDirective(); + State = 424; + _localctx.vtable = vtableDecl(); + Actions.ProcessTopLevelVTableDeclaration(_localctx.vtable); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 415; - vtfixupDecl(); + Actions.BeginTopLevelDirective(); + State = 428; + _localctx.vtfixup = vtfixupDecl(); + Actions.ProcessTopLevelVTableFixupDeclaration(_localctx.vtfixup); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 416; - extSourceSpec(); + Actions.BeginTopLevelDirective(); + State = 432; + _localctx.source = extSourceSpec(); + Actions.ProcessTopLevelSourceDirective(_localctx.source); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 417; - fileDecl(); + Actions.BeginTopLevelDirective(); + State = 436; + _localctx.file = fileDecl(); + Actions.ProcessTopLevelFileDeclaration(_localctx.file); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 418; - assemblyBlock(); + Actions.BeginTopLevelDirective(); + State = 440; + _localctx.assembly = assemblyBlock(); + Actions.ProcessTopLevelAssembly(_localctx.assembly); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 419; - assemblyRefHead(); - State = 420; - Match(T__16); - State = 421; - assemblyRefDecls(); - State = 422; - Match(T__17); + Actions.BeginTopLevelDirective(); + State = 444; + _localctx.assemblyReference = assemblyRefBlock(); + Actions.ProcessTopLevelAssemblyReference(_localctx.assemblyReference); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 424; - exptypeHead(); - State = 425; - Match(T__16); - State = 426; - exptypeDecls(); - State = 427; - Match(T__17); + Actions.BeginTopLevelDirective(); + State = 448; + _localctx.exportedType = exptypeBlock(); + Actions.ProcessTopLevelExportedType(_localctx.exportedType); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 429; - manifestResHead(); - State = 430; - Match(T__16); - State = 431; - manifestResDecls(); - State = 432; - Match(T__17); + Actions.BeginTopLevelDirective(); + State = 452; + _localctx.resource = manifestResBlock(); + Actions.ProcessTopLevelManifestResource(_localctx.resource); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 434; - moduleHead(); + Actions.BeginTopLevelDirective(); + State = 456; + _localctx.module = moduleHead(); + Actions.ProcessTopLevelModule(_localctx.module.Value, _localctx.module.HasName, _localctx.module.IsExternal); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 435; - secDecl(); + Actions.BeginTopLevelDirective(); + State = 460; + _localctx.security = secDecl(); + Actions.ProcessTopLevelSecurityDeclaration(_localctx.security); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 436; - customAttrDecl(); + State = 463; + _localctx.attribute = customAttrDecl(); + Actions.ProcessTopLevelCustomAttribute(_localctx.attribute); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 437; + Actions.BeginTopLevelDirective(); + State = 467; subsystem(); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 438; + Actions.BeginTopLevelDirective(); + State = 469; corflags(); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 439; + Actions.BeginTopLevelDirective(); + State = 471; alignment(); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 440; + Actions.BeginTopLevelDirective(); + State = 473; imagebase(); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 441; + Actions.BeginTopLevelDirective(); + State = 475; stackreserve(); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 442; - languageDecl(); + Actions.BeginTopLevelDirective(); + State = 477; + _localctx.language = languageDecl(); + Actions.ProcessTopLevelLanguageDirective(_localctx.language); } break; case 23: EnterOuterAlt(_localctx, 23); { - State = 443; - typedefDecl(); + Actions.BeginTopLevelDirective(); + State = 481; + _localctx.typedef = typedefDecl(); + Actions.ProcessTopLevelTypedef(_localctx.typedef); } break; case 24: EnterOuterAlt(_localctx, 24); { - State = 444; + Actions.BeginTopLevelDirective(); + State = 485; compControl(); } break; case 25: EnterOuterAlt(_localctx, 25); { - State = 445; + State = 486; typelist(); } break; case 26: EnterOuterAlt(_localctx, 26); { - State = 446; + Actions.BeginTopLevelDirective(); + State = 488; mscorlib(); } break; } - Context.Stop = TokenStream.LT(-1); - Actions.OnDeclaration(_localctx); } catch (RecognitionException re) { _localctx.exception = re; @@ -977,6 +997,7 @@ public DeclContext decl() { } public partial class SubsystemContext : ParserRuleContext { + public Int32Context value; [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); } @@ -1000,10 +1021,11 @@ public SubsystemContext subsystem() { try { EnterOuterAlt(_localctx, 1); { - State = 449; + State = 491; Match(T__18); - State = 450; - int32(); + State = 492; + _localctx.value = int32(); + Actions.ProcessTopLevelSubsystem((_localctx.value!=null?(_localctx.value.Start):null)); } } catch (RecognitionException re) { @@ -1018,6 +1040,7 @@ public SubsystemContext subsystem() { } public partial class CorflagsContext : ParserRuleContext { + public Int32Context value; [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); } @@ -1041,10 +1064,11 @@ public CorflagsContext corflags() { try { EnterOuterAlt(_localctx, 1); { - State = 452; + State = 495; Match(T__19); - State = 453; - int32(); + State = 496; + _localctx.value = int32(); + Actions.ProcessTopLevelCorFlags((_localctx.value!=null?(_localctx.value.Start):null)); } } catch (RecognitionException re) { @@ -1059,6 +1083,7 @@ public CorflagsContext corflags() { } public partial class AlignmentContext : ParserRuleContext { + public Int32Context value; [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); } @@ -1082,12 +1107,13 @@ public AlignmentContext alignment() { try { EnterOuterAlt(_localctx, 1); { - State = 455; + State = 499; Match(T__20); - State = 456; + State = 500; Match(T__21); - State = 457; - int32(); + State = 501; + _localctx.value = int32(); + Actions.ProcessTopLevelAlignment((_localctx.value!=null?(_localctx.value.Start):null)); } } catch (RecognitionException re) { @@ -1102,6 +1128,7 @@ public AlignmentContext alignment() { } public partial class ImagebaseContext : ParserRuleContext { + public Int64Context value; [System.Diagnostics.DebuggerNonUserCode] public Int64Context int64() { return GetRuleContext(0); } @@ -1125,10 +1152,11 @@ public ImagebaseContext imagebase() { try { EnterOuterAlt(_localctx, 1); { - State = 459; + State = 504; Match(T__22); - State = 460; - int64(); + State = 505; + _localctx.value = int64(); + Actions.ProcessTopLevelImageBase((_localctx.value!=null?(_localctx.value.Start):null)); } } catch (RecognitionException re) { @@ -1143,6 +1171,7 @@ public ImagebaseContext imagebase() { } public partial class StackreserveContext : ParserRuleContext { + public Int64Context value; [System.Diagnostics.DebuggerNonUserCode] public Int64Context int64() { return GetRuleContext(0); } @@ -1166,10 +1195,11 @@ public StackreserveContext stackreserve() { try { EnterOuterAlt(_localctx, 1); { - State = 462; + State = 508; Match(T__23); - State = 463; - int64(); + State = 509; + _localctx.value = int64(); + Actions.ProcessTopLevelStackReserve((_localctx.value!=null?(_localctx.value.Start):null)); } } catch (RecognitionException re) { @@ -1184,6 +1214,7 @@ public StackreserveContext stackreserve() { } public partial class AssemblyBlockContext : ParserRuleContext { + public bool HasSyntaxError; [System.Diagnostics.DebuggerNonUserCode] public AsmAttrContext asmAttr() { return GetRuleContext(0); } @@ -1210,20 +1241,21 @@ public override TResult Accept(IParseTreeVisitor visitor) { public AssemblyBlockContext assemblyBlock() { AssemblyBlockContext _localctx = new AssemblyBlockContext(Context, State); EnterRule(_localctx, 22, RULE_assemblyBlock); + BeginSubtree(); Actions.BeginSemanticRoot(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 465; + State = 512; Match(T__24); - State = 466; + State = 513; asmAttr(); - State = 467; + State = 514; dottedName(); - State = 468; + State = 515; Match(T__16); - State = 469; + State = 516; assemblyDecls(); - State = 470; + State = 517; Match(T__17); } } @@ -1233,6 +1265,7 @@ public AssemblyBlockContext assemblyBlock() { ErrorHandler.Recover(this, re); } finally { + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; @@ -1259,7 +1292,7 @@ public MscorlibContext mscorlib() { try { EnterOuterAlt(_localctx, 1); { - State = 472; + State = 519; Match(T__25); } } @@ -1301,45 +1334,45 @@ public LanguageDeclContext languageDecl() { EnterRule(_localctx, 26, RULE_languageDecl); BeginSubtree(); Actions.BeginSemanticRoot(_localctx); try { - State = 488; + State = 535; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,5,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 474; + State = 521; Match(T__26); - State = 475; + State = 522; languageString(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 476; + State = 523; Match(T__26); - State = 477; + State = 524; languageString(); - State = 478; + State = 525; Match(T__27); - State = 479; + State = 526; languageString(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 481; + State = 528; Match(T__26); - State = 482; + State = 529; languageString(); - State = 483; + State = 530; Match(T__27); - State = 484; + State = 531; languageString(); - State = 485; + State = 532; Match(T__27); - State = 486; + State = 533; languageString(); } break; @@ -1381,7 +1414,7 @@ public LanguageStringContext languageString() { try { EnterOuterAlt(_localctx, 1); { - State = 490; + State = 537; _la = TokenStream.LA(1); if ( !(_la==QSTRING || _la==SQSTRING) ) { ErrorHandler.RecoverInline(this); @@ -1404,6 +1437,7 @@ public LanguageStringContext languageString() { } public partial class TypelistContext : ParserRuleContext { + public ClassNameContext name; [System.Diagnostics.DebuggerNonUserCode] public ClassNameContext[] className() { return GetRuleContexts(); } @@ -1427,29 +1461,31 @@ public override TResult Accept(IParseTreeVisitor visitor) { public TypelistContext typelist() { TypelistContext _localctx = new TypelistContext(Context, State); EnterRule(_localctx, 30, RULE_typelist); + Actions.BeginTopLevelTypeList(); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 492; + State = 539; Match(T__28); - State = 493; + State = 540; Match(T__16); - State = 497; + State = 546; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__15 || _la==T__41 || _la==T__112 || ((((_la - 199)) & ~0x3f) == 0 && ((1L << (_la - 199)) & 2017630225248026625L) != 0) || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50331649L) != 0)) { { { - State = 494; - className(); + State = 541; + _localctx.name = className(); + Actions.ProcessTopLevelTypeListEntry(_localctx.name.Value); } } - State = 499; + State = 548; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 500; + State = 549; Match(T__17); } } @@ -1486,7 +1522,7 @@ public Int32Context int32() { try { EnterOuterAlt(_localctx, 1); { - State = 502; + State = 551; Match(INT32); } } @@ -1525,7 +1561,7 @@ public Int64Context int64() { try { EnterOuterAlt(_localctx, 1); { - State = 504; + State = 553; _la = TokenStream.LA(1); if ( !(_la==INT32 || _la==INT64) ) { ErrorHandler.RecoverInline(this); @@ -1582,13 +1618,13 @@ public Float64Context float64() { Float64Context _localctx = new Float64Context(Context, State); EnterRule(_localctx, 36, RULE_float64); try { - State = 527; + State = 576; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,7,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 506; + State = 555; _localctx.@decimal = Match(FLOAT64); _localctx.Value = Actions.ParseFloatingLiteral(_localctx.@decimal); } @@ -1596,9 +1632,9 @@ public Float64Context float64() { case 2: EnterOuterAlt(_localctx, 2); { - State = 508; + State = 557; _localctx.trailing = int32(); - State = 509; + State = 558; Match(DOT); _localctx.Value = Actions.ParseFloatingInteger((_localctx.trailing!=null?(_localctx.trailing.Start):null)); } @@ -1606,7 +1642,7 @@ public Float64Context float64() { case 3: EnterOuterAlt(_localctx, 3); { - State = 512; + State = 561; _localctx.integer = int32(); _localctx.Value = Actions.ParseFloatingInteger((_localctx.integer!=null?(_localctx.integer.Start):null)); } @@ -1614,13 +1650,13 @@ public Float64Context float64() { case 4: EnterOuterAlt(_localctx, 4); { - State = 515; + State = 564; Match(FLOAT32); - State = 516; + State = 565; Match(T__29); - State = 517; + State = 566; _localctx.singleBits = int32(); - State = 518; + State = 567; Match(T__30); _localctx.Value = Actions.ParseFloat32Bits((_localctx.singleBits!=null?(_localctx.singleBits.Start):null)); } @@ -1628,13 +1664,13 @@ public Float64Context float64() { case 5: EnterOuterAlt(_localctx, 5); { - State = 521; + State = 570; Match(FLOAT64_); - State = 522; + State = 571; Match(T__29); - State = 523; + State = 572; _localctx.doubleBits = int64(); - State = 524; + State = 573; Match(T__30); _localctx.Value = Actions.ParseFloat64Bits((_localctx.doubleBits!=null?(_localctx.doubleBits.Start):null)); } @@ -1675,20 +1711,20 @@ public IntOrWildcardContext intOrWildcard() { IntOrWildcardContext _localctx = new IntOrWildcardContext(Context, State); EnterRule(_localctx, 38, RULE_intOrWildcard); try { - State = 531; + State = 580; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case INT32: EnterOuterAlt(_localctx, 1); { - State = 529; + State = 578; int32(); } break; case PTR: EnterOuterAlt(_localctx, 2); { - State = 530; + State = 579; Match(PTR); } break; @@ -1735,83 +1771,83 @@ public CompControlContext compControl() { CompControlContext _localctx = new CompControlContext(Context, State); EnterRule(_localctx, 40, RULE_compControl); try { - State = 549; + State = 598; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,9,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 533; + State = 582; Match(PP_DEFINE); - State = 534; + State = 583; Match(ID); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 535; + State = 584; Match(PP_DEFINE); - State = 536; + State = 585; Match(ID); - State = 537; + State = 586; Match(QSTRING); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 538; + State = 587; Match(PP_UNDEF); - State = 539; + State = 588; Match(ID); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 540; + State = 589; Match(PP_IFDEF); - State = 541; + State = 590; Match(ID); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 542; + State = 591; Match(PP_IFNDEF); - State = 543; + State = 592; Match(ID); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 544; + State = 593; Match(PP_ELSE); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 545; + State = 594; Match(PP_ENDIF); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 546; + State = 595; Match(PP_INCLUDE); - State = 547; + State = 596; Match(QSTRING); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 548; + State = 597; Match(T__31); } break; @@ -1829,6 +1865,7 @@ public CompControlContext compControl() { } public partial class TypedefDeclContext : ParserRuleContext { + public bool HasSyntaxError; [System.Diagnostics.DebuggerNonUserCode] public TypeContext type() { return GetRuleContext(0); } @@ -1864,72 +1901,73 @@ public override TResult Accept(IParseTreeVisitor visitor) { public TypedefDeclContext typedefDecl() { TypedefDeclContext _localctx = new TypedefDeclContext(Context, State); EnterRule(_localctx, 42, RULE_typedefDecl); + BeginSubtree(); Actions.BeginSemanticRoot(_localctx); try { - State = 576; + State = 625; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,10,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 551; + State = 600; Match(T__32); - State = 552; + State = 601; type(); - State = 553; + State = 602; Match(T__33); - State = 554; + State = 603; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 556; + State = 605; Match(T__32); - State = 557; + State = 606; className(); - State = 558; + State = 607; Match(T__33); - State = 559; + State = 608; dottedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 561; + State = 610; Match(T__32); - State = 562; + State = 611; memberRef(); - State = 563; + State = 612; Match(T__33); - State = 564; + State = 613; dottedName(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 566; + State = 615; Match(T__32); - State = 567; + State = 616; customDescr(); - State = 568; + State = 617; Match(T__33); - State = 569; + State = 618; dottedName(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 571; + State = 620; Match(T__32); - State = 572; + State = 621; customDescrWithOwner(); - State = 573; + State = 622; Match(T__33); - State = 574; + State = 623; dottedName(); } break; @@ -1941,6 +1979,7 @@ public TypedefDeclContext typedefDecl() { ErrorHandler.Recover(this, re); } finally { + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; @@ -1979,62 +2018,62 @@ public CustomDescrContext customDescr() { EnterRule(_localctx, 44, RULE_customDescr); BeginSubtree(); Actions.BeginSemanticRoot(_localctx); try { - State = 599; + State = 648; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,11,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 578; + State = 627; Match(T__34); - State = 579; + State = 628; customType(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 580; + State = 629; Match(T__34); - State = 581; + State = 630; customType(); - State = 582; + State = 631; Match(T__35); - State = 583; + State = 632; compQstring(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 585; + State = 634; Match(T__34); - State = 586; + State = 635; customType(); - State = 587; + State = 636; Match(T__35); - State = 588; + State = 637; Match(T__16); - State = 589; + State = 638; customBlobDescr(); - State = 590; + State = 639; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 592; + State = 641; Match(T__34); - State = 593; + State = 642; customType(); - State = 594; + State = 643; Match(T__35); - State = 595; + State = 644; Match(T__29); - State = 596; + State = 645; bytes(); - State = 597; + State = 646; Match(T__30); } break; @@ -2088,86 +2127,86 @@ public CustomDescrWithOwnerContext customDescrWithOwner() { EnterRule(_localctx, 46, RULE_customDescrWithOwner); BeginSubtree(); Actions.BeginSemanticRoot(_localctx); try { - State = 635; + State = 684; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,12,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 601; + State = 650; Match(T__34); - State = 602; + State = 651; Match(T__29); - State = 603; + State = 652; ownerType(); - State = 604; + State = 653; Match(T__30); - State = 605; + State = 654; customType(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 607; + State = 656; Match(T__34); - State = 608; + State = 657; Match(T__29); - State = 609; + State = 658; ownerType(); - State = 610; + State = 659; Match(T__30); - State = 611; + State = 660; customType(); - State = 612; + State = 661; Match(T__35); - State = 613; + State = 662; compQstring(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 615; + State = 664; Match(T__34); - State = 616; + State = 665; Match(T__29); - State = 617; + State = 666; ownerType(); - State = 618; + State = 667; Match(T__30); - State = 619; + State = 668; customType(); - State = 620; + State = 669; Match(T__35); - State = 621; + State = 670; Match(T__16); - State = 622; + State = 671; customBlobDescr(); - State = 623; + State = 672; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 625; + State = 674; Match(T__34); - State = 626; + State = 675; Match(T__29); - State = 627; + State = 676; ownerType(); - State = 628; + State = 677; Match(T__30); - State = 629; + State = 678; customType(); - State = 630; + State = 679; Match(T__35); - State = 631; + State = 680; Match(T__29); - State = 632; + State = 681; bytes(); - State = 633; + State = 682; Match(T__30); } break; @@ -2209,7 +2248,7 @@ public CustomTypeContext customType() { try { EnterOuterAlt(_localctx, 1); { - State = 637; + State = 686; methodRef(); } } @@ -2254,13 +2293,13 @@ public OwnerTypeContext ownerType() { EnterRule(_localctx, 50, RULE_ownerType); Actions.BeginSemanticRoot(_localctx); try { - State = 645; + State = 694; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,13,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 639; + State = 688; _localctx.typeValue = typeSpec(); _localctx.Value = Actions.CreateTypeOwner(_localctx.typeValue.Value); } @@ -2268,7 +2307,7 @@ public OwnerTypeContext ownerType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 642; + State = 691; _localctx.member = memberRef(); _localctx.Value = Actions.CreateMemberOwner(_localctx.member.Value); } @@ -2314,9 +2353,9 @@ public CustomBlobDescrContext customBlobDescr() { try { EnterOuterAlt(_localctx, 1); { - State = 647; + State = 696; customBlobArgs(); - State = 648; + State = 697; customBlobNVPairs(); } } @@ -2365,13 +2404,13 @@ public CustomBlobArgsContext customBlobArgs() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 654; + State = 703; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,15,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { - State = 652; + State = 701; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__83: @@ -2391,7 +2430,7 @@ public CustomBlobArgsContext customBlobArgs() { case TYPE: case OBJECT: { - State = 650; + State = 699; serInit(); } break; @@ -2404,7 +2443,7 @@ public CustomBlobArgsContext customBlobArgs() { case PP_ENDIF: case PP_INCLUDE: { - State = 651; + State = 700; compControl(); } break; @@ -2413,7 +2452,7 @@ public CustomBlobArgsContext customBlobArgs() { } } } - State = 656; + State = 705; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,15,Context); } @@ -2482,26 +2521,26 @@ public CustomBlobNVPairsContext customBlobNVPairs() { try { EnterOuterAlt(_localctx, 1); { - State = 666; + State = 715; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 416611827712L) != 0) || ((((_la - 267)) & ~0x3f) == 0 && ((1L << (_la - 267)) & 127L) != 0)) { { - State = 664; + State = 713; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__36: case T__37: { - State = 657; + State = 706; fieldOrProp(); - State = 658; + State = 707; serializType(); - State = 659; + State = 708; dottedName(); - State = 660; + State = 709; Match(T__35); - State = 661; + State = 710; serInit(); } break; @@ -2514,7 +2553,7 @@ public CustomBlobNVPairsContext customBlobNVPairs() { case PP_ENDIF: case PP_INCLUDE: { - State = 663; + State = 712; compControl(); } break; @@ -2522,7 +2561,7 @@ public CustomBlobNVPairsContext customBlobNVPairs() { throw new NoViableAltException(this); } } - State = 668; + State = 717; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -2561,7 +2600,7 @@ public FieldOrPropContext fieldOrProp() { try { EnterOuterAlt(_localctx, 1); { - State = 669; + State = 718; _la = TokenStream.LA(1); if ( !(_la==T__36 || _la==T__37) ) { ErrorHandler.RecoverInline(this); @@ -2609,14 +2648,14 @@ public SerializTypeContext serializType() { try { EnterOuterAlt(_localctx, 1); { - State = 671; + State = 720; serializTypeElement(); - State = 673; + State = 722; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==ARRAY_TYPE_NO_BOUNDS) { { - State = 672; + State = 721; Match(ARRAY_TYPE_NO_BOUNDS); } } @@ -2666,54 +2705,54 @@ public SerializTypeElementContext serializTypeElement() { SerializTypeElementContext _localctx = new SerializTypeElementContext(Context, State); EnterRule(_localctx, 62, RULE_serializTypeElement); try { - State = 684; + State = 733; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,19,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 675; + State = 724; simpleType(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 676; + State = 725; dottedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 677; + State = 726; Match(TYPE); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 678; + State = 727; Match(OBJECT); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 679; + State = 728; Match(ENUM); - State = 680; + State = 729; Match(T__38); - State = 681; + State = 730; Match(SQSTRING); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 682; + State = 731; Match(ENUM); - State = 683; + State = 732; className(); } break; @@ -2731,6 +2770,10 @@ public SerializTypeElementContext serializTypeElement() { } public partial class ModuleHeadContext : ParserRuleContext { + public string Value; + public bool HasName; + public bool IsExternal; + public DottedNameContext name; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode MODULE() { return GetToken(CILParser.MODULE, 0); } [System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() { return GetRuleContext(0); @@ -2753,34 +2796,37 @@ public ModuleHeadContext moduleHead() { ModuleHeadContext _localctx = new ModuleHeadContext(Context, State); EnterRule(_localctx, 64, RULE_moduleHead); try { - State = 692; + State = 746; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,20,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 686; + State = 735; Match(MODULE); - State = 687; + State = 736; Match(T__39); - State = 688; - dottedName(); + State = 737; + _localctx.name = dottedName(); + Actions.SetModuleHeader(_localctx, _localctx.name.Value, true); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 689; + State = 740; Match(MODULE); - State = 690; - dottedName(); + State = 741; + _localctx.name = dottedName(); + Actions.SetModuleHeader(_localctx, _localctx.name.Value, false); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 691; + State = 744; Match(MODULE); + Actions.SetEmptyModuleHeader(_localctx); } break; } @@ -2797,6 +2843,7 @@ public ModuleHeadContext moduleHead() { } public partial class VtfixupDeclContext : ParserRuleContext { + public bool HasSyntaxError; [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); } @@ -2823,22 +2870,23 @@ public override TResult Accept(IParseTreeVisitor visitor) { public VtfixupDeclContext vtfixupDecl() { VtfixupDeclContext _localctx = new VtfixupDeclContext(Context, State); EnterRule(_localctx, 66, RULE_vtfixupDecl); + BeginSubtree(); Actions.BeginSemanticRoot(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 694; + State = 748; Match(T__40); - State = 695; + State = 749; Match(T__41); - State = 696; + State = 750; int32(); - State = 697; + State = 751; Match(T__42); - State = 698; + State = 752; vtfixupAttr(0); - State = 699; + State = 753; Match(T__43); - State = 700; + State = 754; id(); } } @@ -2848,6 +2896,7 @@ public VtfixupDeclContext vtfixupDecl() { ErrorHandler.Recover(this, re); } finally { + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; @@ -2891,7 +2940,7 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { } Context.Stop = TokenStream.LT(-1); - State = 715; + State = 769; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,22,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { @@ -2900,16 +2949,16 @@ private VtfixupAttrContext vtfixupAttr(int _p) { TriggerExitRuleEvent(); _prevctx = _localctx; { - State = 713; + State = 767; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,21,Context) ) { case 1: { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 703; + State = 757; if (!(Precpred(Context, 5))) throw new FailedPredicateException(this, "Precpred(Context, 5)"); - State = 704; + State = 758; Match(INT32_); } break; @@ -2917,9 +2966,9 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 705; + State = 759; if (!(Precpred(Context, 4))) throw new FailedPredicateException(this, "Precpred(Context, 4)"); - State = 706; + State = 760; Match(INT64_); } break; @@ -2927,9 +2976,9 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 707; + State = 761; if (!(Precpred(Context, 3))) throw new FailedPredicateException(this, "Precpred(Context, 3)"); - State = 708; + State = 762; Match(T__44); } break; @@ -2937,9 +2986,9 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 709; + State = 763; if (!(Precpred(Context, 2))) throw new FailedPredicateException(this, "Precpred(Context, 2)"); - State = 710; + State = 764; Match(T__45); } break; @@ -2947,16 +2996,16 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 711; + State = 765; if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)"); - State = 712; + State = 766; Match(T__46); } break; } } } - State = 717; + State = 771; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,22,Context); } @@ -2974,6 +3023,7 @@ private VtfixupAttrContext vtfixupAttr(int _p) { } public partial class VtableDeclContext : ParserRuleContext { + public bool HasSyntaxError; [System.Diagnostics.DebuggerNonUserCode] public BytesContext bytes() { return GetRuleContext(0); } @@ -2994,18 +3044,19 @@ public override TResult Accept(IParseTreeVisitor visitor) { public VtableDeclContext vtableDecl() { VtableDeclContext _localctx = new VtableDeclContext(Context, State); EnterRule(_localctx, 70, RULE_vtableDecl); + BeginSubtree(); Actions.BeginSemanticRoot(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 718; + State = 772; Match(T__47); - State = 719; + State = 773; Match(T__35); - State = 720; + State = 774; Match(T__29); - State = 721; + State = 775; bytes(); - State = 722; + State = 776; Match(T__30); } } @@ -3015,12 +3066,15 @@ public VtableDeclContext vtableDecl() { ErrorHandler.Recover(this, re); } finally { + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; } public partial class NameSpaceHeadContext : ParserRuleContext { + public string Value; + public DottedNameContext name; [System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() { return GetRuleContext(0); } @@ -3041,17 +3095,18 @@ public override TResult Accept(IParseTreeVisitor visitor) { public NameSpaceHeadContext nameSpaceHead() { NameSpaceHeadContext _localctx = new NameSpaceHeadContext(Context, State); EnterRule(_localctx, 72, RULE_nameSpaceHead); - BeginSubtree(); + BeginStreaming(); Actions.BeginNamespaceHeader(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 724; + State = 778; Match(T__48); - State = 725; - dottedName(); + State = 779; + _localctx.name = dottedName(); + _localctx.Value = _localctx.name.Value; } Context.Stop = TokenStream.LT(-1); - Actions.BeginNamespace(_localctx); + Actions.BeginNamespace(_localctx, _localctx.Value); } catch (RecognitionException re) { _localctx.exception = re; @@ -3059,13 +3114,19 @@ public NameSpaceHeadContext nameSpaceHead() { ErrorHandler.Recover(this, re); } finally { - EndParseTreeMode(); + Actions.EndNamespaceHeader(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; } public partial class ClassHeadContext : ParserRuleContext { + public object Value; + public ClassAttrContext attribute; + public DottedNameContext name; + public TyparsClauseContext genericParameters; + public ExtendsClauseContext baseType; + public ImplClauseContext interfaces; [System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() { return GetRuleContext(0); } @@ -3101,40 +3162,48 @@ public override TResult Accept(IParseTreeVisitor visitor) { public ClassHeadContext classHead() { ClassHeadContext _localctx = new ClassHeadContext(Context, State); EnterRule(_localctx, 74, RULE_classHead); - BeginSubtree(); + BeginStreaming(); Actions.BeginClassHeader(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 727; + State = 782; Match(T__49); - State = 731; + State = 788; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,23,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 728; - classAttr(); + State = 783; + _localctx.attribute = classAttr(); + Actions.AddClassHeaderAttribute(_localctx, _localctx.attribute.Value); } } } - State = 733; + State = 790; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,23,Context); } - State = 734; - dottedName(); - State = 735; - typarsClause(); - State = 736; - extendsClause(); - State = 737; - implClause(); + State = 791; + _localctx.name = dottedName(); + State = 792; + _localctx.genericParameters = typarsClause(); + State = 793; + _localctx.baseType = extendsClause(); + State = 794; + _localctx.interfaces = implClause(); + _localctx.Value = Actions.CreateClassHeader( + _localctx, + (_localctx.name!=null?(_localctx.name.Stop):null), + _localctx.name.Value, + _localctx.genericParameters.Value, + _localctx.baseType.Value, + _localctx.interfaces.Value); } Context.Stop = TokenStream.LT(-1); - Actions.BeginType(_localctx); + Actions.BeginType(_localctx, _localctx.Value); } catch (RecognitionException re) { _localctx.exception = re; @@ -3142,13 +3211,17 @@ public ClassHeadContext classHead() { ErrorHandler.Recover(this, re); } finally { - EndParseTreeMode(); + Actions.EndClassHeader(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; } public partial class ClassAttrContext : ParserRuleContext { + public object Value; + public IToken attribute; + public IToken visibility; + public Int32Context flags; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VALUE() { return GetToken(CILParser.VALUE, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ENUM() { return GetToken(CILParser.ENUM, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INTERFACE() { return GetToken(CILParser.INTERFACE, 0); } @@ -3175,214 +3248,241 @@ public ClassAttrContext classAttr() { ClassAttrContext _localctx = new ClassAttrContext(Context, State); EnterRule(_localctx, 76, RULE_classAttr); try { - State = 776; + State = 861; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,24,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 739; - Match(T__50); + State = 797; + _localctx.attribute = Match(T__50); + _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 740; - Match(T__51); + State = 799; + _localctx.attribute = Match(T__51); + _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 741; - Match(VALUE); + State = 801; + _localctx.attribute = Match(VALUE); + _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 742; - Match(ENUM); + State = 803; + _localctx.attribute = Match(ENUM); + _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 743; - Match(INTERFACE); + State = 805; + _localctx.attribute = Match(INTERFACE); + _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 744; - Match(T__52); + State = 807; + _localctx.attribute = Match(T__52); + _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 745; - Match(T__53); + State = 809; + _localctx.attribute = Match(T__53); + _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 746; - Match(T__54); + State = 811; + _localctx.attribute = Match(T__54); + _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 747; - Match(T__55); + State = 813; + _localctx.attribute = Match(T__55); + _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 748; - Match(EXPLICIT); + State = 815; + _localctx.attribute = Match(EXPLICIT); + _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 749; - Match(T__14); + State = 817; + _localctx.attribute = Match(T__14); + _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 750; - Match(ANSI); + State = 819; + _localctx.attribute = Match(ANSI); + _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 751; - Match(T__56); + State = 821; + _localctx.attribute = Match(T__56); + _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 752; - Match(T__57); + State = 823; + _localctx.attribute = Match(T__57); + _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 753; - Match(T__58); + State = 825; + _localctx.attribute = Match(T__58); + _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 754; - Match(T__59); + State = 827; + _localctx.attribute = Match(T__59); + _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 755; - Match(T__60); + State = 829; + _localctx.attribute = Match(T__60); + _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 756; + State = 831; Match(T__61); - State = 757; - Match(T__50); + State = 832; + _localctx.visibility = Match(T__50); + _localctx.Value = Actions.CreateNestedClassAttribute(_localctx.visibility); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 758; + State = 834; Match(T__61); - State = 759; - Match(T__51); + State = 835; + _localctx.visibility = Match(T__51); + _localctx.Value = Actions.CreateNestedClassAttribute(_localctx.visibility); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 760; + State = 837; Match(T__61); - State = 761; - Match(T__62); + State = 838; + _localctx.visibility = Match(T__62); + _localctx.Value = Actions.CreateNestedClassAttribute(_localctx.visibility); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 762; + State = 840; Match(T__61); - State = 763; - Match(T__63); + State = 841; + _localctx.visibility = Match(T__63); + _localctx.Value = Actions.CreateNestedClassAttribute(_localctx.visibility); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 764; + State = 843; Match(T__61); - State = 765; - Match(T__64); + State = 844; + _localctx.visibility = Match(T__64); + _localctx.Value = Actions.CreateNestedClassAttribute(_localctx.visibility); } break; case 23: EnterOuterAlt(_localctx, 23); { - State = 766; + State = 846; Match(T__61); - State = 767; - Match(T__65); + State = 847; + _localctx.visibility = Match(T__65); + _localctx.Value = Actions.CreateNestedClassAttribute(_localctx.visibility); } break; case 24: EnterOuterAlt(_localctx, 24); { - State = 768; - Match(T__66); + State = 849; + _localctx.attribute = Match(T__66); + _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } break; case 25: EnterOuterAlt(_localctx, 25); { - State = 769; - Match(T__67); + State = 851; + _localctx.attribute = Match(T__67); + _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } break; case 26: EnterOuterAlt(_localctx, 26); { - State = 770; - Match(T__68); + State = 853; + _localctx.attribute = Match(T__68); + _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } break; case 27: EnterOuterAlt(_localctx, 27); { - State = 771; + State = 855; Match(T__69); - State = 772; + State = 856; Match(T__29); - State = 773; - int32(); - State = 774; + State = 857; + _localctx.flags = int32(); + State = 858; Match(T__30); + _localctx.Value = Actions.CreateRawClassAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } break; } @@ -3399,6 +3499,8 @@ public ClassAttrContext classAttr() { } public partial class ExtendsClauseContext : ParserRuleContext { + public object Value; + public TypeSpecContext baseType; [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() { return GetRuleContext(0); } @@ -3419,8 +3521,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { public ExtendsClauseContext extendsClause() { ExtendsClauseContext _localctx = new ExtendsClauseContext(Context, State); EnterRule(_localctx, 78, RULE_extendsClause); + _localctx.Value = Actions.CreateEmptyClassBase(); try { - State = 781; + State = 868; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -3432,10 +3535,11 @@ public ExtendsClauseContext extendsClause() { case T__70: EnterOuterAlt(_localctx, 2); { - State = 779; + State = 864; Match(T__70); - State = 780; - typeSpec(); + State = 865; + _localctx.baseType = typeSpec(); + _localctx.Value = Actions.CreateClassBase(_localctx.baseType.Value); } break; default: @@ -3454,6 +3558,8 @@ public ExtendsClauseContext extendsClause() { } public partial class ImplClauseContext : ParserRuleContext { + public object Value; + public ImplListContext interfaces; [System.Diagnostics.DebuggerNonUserCode] public ImplListContext implList() { return GetRuleContext(0); } @@ -3474,8 +3580,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { public ImplClauseContext implClause() { ImplClauseContext _localctx = new ImplClauseContext(Context, State); EnterRule(_localctx, 80, RULE_implClause); + _localctx.Value = Actions.CreateEmptyInterfaceList(); try { - State = 786; + State = 875; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -3486,10 +3593,11 @@ public ImplClauseContext implClause() { case T__71: EnterOuterAlt(_localctx, 2); { - State = 784; + State = 871; Match(T__71); - State = 785; - implList(); + State = 872; + _localctx.interfaces = implList(); + _localctx.Value = _localctx.interfaces.Value; } break; default: @@ -3536,17 +3644,17 @@ public ClassDeclsContext classDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 791; + State = 880; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1125938695831552L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 1189425290649010179L) != 0) || ((((_la - 139)) & ~0x3f) == 0 && ((1L << (_la - 139)) & 1152921504673955841L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 871552083145265153L) != 0)) { { { - State = 788; + State = 877; classDecl(); } } - State = 793; + State = 882; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -3565,6 +3673,9 @@ public ClassDeclsContext classDecls() { } public partial class ImplListContext : ParserRuleContext { + public object Value; + public TypeSpecContext interfaceType; + public TypeSpecContext lastInterfaceType; [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext[] typeSpec() { return GetRuleContexts(); } @@ -3588,30 +3699,33 @@ public override TResult Accept(IParseTreeVisitor visitor) { public ImplListContext implList() { ImplListContext _localctx = new ImplListContext(Context, State); EnterRule(_localctx, 84, RULE_implList); + Actions.BeginInterfaceList(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 799; + State = 889; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,28,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 794; - typeSpec(); - State = 795; + State = 883; + _localctx.interfaceType = typeSpec(); + Actions.AddInterfaceType(_localctx, _localctx.interfaceType.Value); + State = 885; Match(T__27); } } } - State = 801; + State = 891; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,28,Context); } - State = 802; - typeSpec(); + State = 892; + _localctx.lastInterfaceType = typeSpec(); + Actions.AddInterfaceType(_localctx, _localctx.lastInterfaceType.Value); } } catch (RecognitionException re) { @@ -3620,6 +3734,7 @@ public ImplListContext implList() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndInterfaceList(_localctx); ExitRule(); } return _localctx; @@ -3647,7 +3762,7 @@ public EsHeadContext esHead() { try { EnterOuterAlt(_localctx, 1); { - State = 804; + State = 895; _la = TokenStream.LA(1); if ( !(_la==T__72 || _la==T__73) ) { ErrorHandler.RecoverInline(this); @@ -3701,257 +3816,257 @@ public ExtSourceSpecContext extSourceSpec() { EnterRule(_localctx, 88, RULE_extSourceSpec); BeginSubtree(); Actions.BeginSemanticRoot(_localctx); try { - State = 909; + State = 1000; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,29,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 806; + State = 897; esHead(); - State = 807; + State = 898; int32(); - State = 808; + State = 899; Match(SQSTRING); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 810; + State = 901; esHead(); - State = 811; + State = 902; int32(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 813; + State = 904; esHead(); - State = 814; + State = 905; int32(); - State = 815; + State = 906; Match(T__74); - State = 816; + State = 907; int32(); - State = 817; + State = 908; Match(SQSTRING); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 819; + State = 910; esHead(); - State = 820; + State = 911; int32(); - State = 821; + State = 912; Match(T__74); - State = 822; + State = 913; int32(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 824; + State = 915; esHead(); - State = 825; + State = 916; int32(); - State = 826; + State = 917; Match(T__74); - State = 827; + State = 918; int32(); - State = 828; + State = 919; Match(T__27); - State = 829; + State = 920; int32(); - State = 830; + State = 921; Match(SQSTRING); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 832; + State = 923; esHead(); - State = 833; + State = 924; int32(); - State = 834; + State = 925; Match(T__74); - State = 835; + State = 926; int32(); - State = 836; + State = 927; Match(T__27); - State = 837; + State = 928; int32(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 839; + State = 930; esHead(); - State = 840; + State = 931; int32(); - State = 841; + State = 932; Match(T__27); - State = 842; + State = 933; int32(); - State = 843; + State = 934; Match(T__74); - State = 844; + State = 935; int32(); - State = 845; + State = 936; Match(SQSTRING); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 847; + State = 938; esHead(); - State = 848; + State = 939; int32(); - State = 849; + State = 940; Match(T__27); - State = 850; + State = 941; int32(); - State = 851; + State = 942; Match(T__74); - State = 852; + State = 943; int32(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 854; + State = 945; esHead(); - State = 855; + State = 946; int32(); - State = 856; + State = 947; Match(T__27); - State = 857; + State = 948; int32(); - State = 858; + State = 949; Match(T__74); - State = 859; + State = 950; int32(); - State = 860; + State = 951; Match(T__27); - State = 861; + State = 952; int32(); - State = 862; + State = 953; Match(SQSTRING); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 864; + State = 955; esHead(); - State = 865; + State = 956; int32(); - State = 866; + State = 957; Match(T__27); - State = 867; + State = 958; int32(); - State = 868; + State = 959; Match(T__74); - State = 869; + State = 960; int32(); - State = 870; + State = 961; Match(T__27); - State = 871; + State = 962; int32(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 873; + State = 964; esHead(); - State = 874; + State = 965; int32(); - State = 875; + State = 966; Match(QSTRING); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 877; + State = 968; esHead(); - State = 878; + State = 969; int32(); - State = 879; + State = 970; Match(T__74); - State = 880; + State = 971; int32(); - State = 881; + State = 972; Match(QSTRING); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 883; + State = 974; esHead(); - State = 884; + State = 975; int32(); - State = 885; + State = 976; Match(T__74); - State = 886; + State = 977; int32(); - State = 887; + State = 978; Match(T__27); - State = 888; + State = 979; int32(); - State = 889; + State = 980; Match(QSTRING); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 891; + State = 982; esHead(); - State = 892; + State = 983; int32(); - State = 893; + State = 984; Match(T__27); - State = 894; + State = 985; int32(); - State = 895; + State = 986; Match(T__74); - State = 896; + State = 987; int32(); - State = 897; + State = 988; Match(QSTRING); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 899; + State = 990; esHead(); - State = 900; + State = 991; int32(); - State = 901; + State = 992; Match(T__27); - State = 902; + State = 993; int32(); - State = 903; + State = 994; Match(T__74); - State = 904; + State = 995; int32(); - State = 905; + State = 996; Match(T__27); - State = 906; + State = 997; int32(); - State = 907; + State = 998; Match(QSTRING); } break; @@ -3970,6 +4085,7 @@ public ExtSourceSpecContext extSourceSpec() { } public partial class FileDeclContext : ParserRuleContext { + public bool HasSyntaxError; [System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() { return GetRuleContext(0); } @@ -4006,70 +4122,71 @@ public override TResult Accept(IParseTreeVisitor visitor) { public FileDeclContext fileDecl() { FileDeclContext _localctx = new FileDeclContext(Context, State); EnterRule(_localctx, 90, RULE_fileDecl); + BeginSubtree(); Actions.BeginSemanticRoot(_localctx); int _la; try { - State = 937; + State = 1028; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,32,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 911; + State = 1002; Match(T__20); - State = 915; + State = 1006; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__75) { { { - State = 912; + State = 1003; fileAttr(); } } - State = 917; + State = 1008; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 918; + State = 1009; dottedName(); - State = 919; + State = 1010; fileEntry(); - State = 920; + State = 1011; Match(HASH); - State = 921; + State = 1012; Match(T__35); - State = 922; + State = 1013; Match(T__29); - State = 923; + State = 1014; bytes(); - State = 924; + State = 1015; Match(T__30); - State = 925; + State = 1016; fileEntry(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 927; + State = 1018; Match(T__20); - State = 931; + State = 1022; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__75) { { { - State = 928; + State = 1019; fileAttr(); } } - State = 933; + State = 1024; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 934; + State = 1025; dottedName(); - State = 935; + State = 1026; fileEntry(); } break; @@ -4081,6 +4198,7 @@ public FileDeclContext fileDecl() { ErrorHandler.Recover(this, re); } finally { + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; @@ -4107,7 +4225,7 @@ public FileAttrContext fileAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 939; + State = 1030; Match(T__75); } } @@ -4142,7 +4260,7 @@ public FileEntryContext fileEntry() { FileEntryContext _localctx = new FileEntryContext(Context, State); EnterRule(_localctx, 94, RULE_fileEntry); try { - State = 943; + State = 1034; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -4192,7 +4310,7 @@ public FileEntryContext fileEntry() { case ENTRYPOINT: EnterOuterAlt(_localctx, 2); { - State = 942; + State = 1033; Match(ENTRYPOINT); } break; @@ -4233,7 +4351,7 @@ public AsmAttrAnyContext asmAttrAny() { try { EnterOuterAlt(_localctx, 1); { - State = 945; + State = 1036; _la = TokenStream.LA(1); if ( !(_la==T__1 || _la==T__60 || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 127L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -4283,17 +4401,17 @@ public AsmAttrContext asmAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 950; + State = 1041; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__1 || _la==T__60 || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 127L) != 0)) { { { - State = 947; + State = 1038; asmAttrAny(); } } - State = 952; + State = 1043; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -4362,22 +4480,22 @@ public InstrContext instr() { InstrContext _localctx = new InstrContext(Context, State); EnterRule(_localctx, 100, RULE_instr); try { - State = 978; + State = 1069; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,35,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 953; + State = 1044; simpleInstr(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 954; + State = 1045; _localctx.op = Match(INSTR_METHOD); - State = 955; + State = 1046; _localctx.methodOperand = methodRef(); Actions.EmitMethodReferenceInstruction(_localctx.op, _localctx.methodOperand); } @@ -4385,9 +4503,9 @@ public InstrContext instr() { case 3: EnterOuterAlt(_localctx, 3); { - State = 958; + State = 1049; _localctx.op = Match(INSTR_FIELD); - State = 959; + State = 1050; _localctx.fieldOperand = fieldRef(); Actions.EmitFieldReferenceInstruction(_localctx.op, _localctx.fieldOperand); } @@ -4395,9 +4513,9 @@ public InstrContext instr() { case 4: EnterOuterAlt(_localctx, 4); { - State = 962; + State = 1053; _localctx.op = Match(INSTR_FIELD); - State = 963; + State = 1054; _localctx.metadataOperand = mdtoken(); Actions.EmitMetadataTokenInstruction(_localctx.op, _localctx.metadataOperand); } @@ -4405,9 +4523,9 @@ public InstrContext instr() { case 5: EnterOuterAlt(_localctx, 5); { - State = 966; + State = 1057; _localctx.op = Match(INSTR_TYPE); - State = 967; + State = 1058; _localctx.typeOperand = typeSpec(); Actions.EmitTypeReferenceInstruction(_localctx.op, _localctx.typeOperand); } @@ -4415,9 +4533,9 @@ public InstrContext instr() { case 6: EnterOuterAlt(_localctx, 6); { - State = 970; + State = 1061; _localctx.op = Match(INSTR_SIG); - State = 971; + State = 1062; _localctx.signatureOperand = calliSignature(); Actions.EmitCalliInstruction(_localctx.op, _localctx.signatureOperand); } @@ -4425,9 +4543,9 @@ public InstrContext instr() { case 7: EnterOuterAlt(_localctx, 7); { - State = 974; + State = 1065; _localctx.op = Match(INSTR_TOK); - State = 975; + State = 1066; _localctx.ownerOperand = ownerType(); Actions.EmitOwnerTokenInstruction(_localctx.op, _localctx.ownerOperand); } @@ -4509,13 +4627,13 @@ public SimpleInstrContext simpleInstr() { SimpleInstrContext _localctx = new SimpleInstrContext(Context, State); EnterRule(_localctx, 102, RULE_simpleInstr); try { - State = 1058; + State = 1149; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,37,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 980; + State = 1071; _localctx.op = Match(INSTR_NONE); Actions.EmitNoOperandInstruction(_localctx.op); } @@ -4523,9 +4641,9 @@ public SimpleInstrContext simpleInstr() { case 2: EnterOuterAlt(_localctx, 2); { - State = 982; + State = 1073; _localctx.op = Match(INSTR_VAR); - State = 983; + State = 1074; _localctx.index = int32(); Actions.EmitVariableIndexInstruction(_localctx.op, (_localctx.index!=null?(_localctx.index.Start):null)); } @@ -4533,9 +4651,9 @@ public SimpleInstrContext simpleInstr() { case 3: EnterOuterAlt(_localctx, 3); { - State = 986; + State = 1077; _localctx.op = Match(INSTR_VAR); - State = 987; + State = 1078; _localctx.name = id(); Actions.EmitVariableNameInstruction(_localctx.op, (_localctx.name!=null?(_localctx.name.Start):null)); } @@ -4543,9 +4661,9 @@ public SimpleInstrContext simpleInstr() { case 4: EnterOuterAlt(_localctx, 4); { - State = 990; + State = 1081; _localctx.op = Match(INSTR_I); - State = 991; + State = 1082; _localctx.value32 = int32(); Actions.EmitInt32Instruction(_localctx.op, (_localctx.value32!=null?(_localctx.value32.Start):null)); } @@ -4553,9 +4671,9 @@ public SimpleInstrContext simpleInstr() { case 5: EnterOuterAlt(_localctx, 5); { - State = 994; + State = 1085; _localctx.op = Match(INSTR_I8); - State = 995; + State = 1086; _localctx.value64 = int64(); Actions.EmitInt64Instruction(_localctx.op, (_localctx.value64!=null?(_localctx.value64.Start):null)); } @@ -4563,9 +4681,9 @@ public SimpleInstrContext simpleInstr() { case 6: EnterOuterAlt(_localctx, 6); { - State = 998; + State = 1089; _localctx.op = Match(INSTR_R); - State = 999; + State = 1090; _localctx.value = float64(); Actions.EmitFloatingInstruction(_localctx.op, _localctx.value.Value); } @@ -4573,9 +4691,9 @@ public SimpleInstrContext simpleInstr() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1002; + State = 1093; _localctx.op = Match(INSTR_R); - State = 1003; + State = 1094; _localctx.integerValue = int64(); Actions.EmitFloatingInstruction(_localctx.op, (_localctx.integerValue!=null?(_localctx.integerValue.Start):null)); } @@ -4583,13 +4701,13 @@ public SimpleInstrContext simpleInstr() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1006; + State = 1097; _localctx.op = Match(INSTR_R); - State = 1007; + State = 1098; Match(T__29); - State = 1008; + State = 1099; _localctx.rawFloat = bytes(); - State = 1009; + State = 1100; Match(T__30); Actions.EmitRawFloatingInstruction(_localctx.op, _localctx.rawFloat.Value, (_localctx.rawFloat!=null?(_localctx.rawFloat.Start):null)); } @@ -4597,15 +4715,15 @@ public SimpleInstrContext simpleInstr() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1012; + State = 1103; _localctx.op = Match(INSTR_R); - State = 1013; + State = 1104; Match(T__83); - State = 1014; + State = 1105; Match(T__29); - State = 1015; + State = 1106; _localctx.rawFloat = bytes(); - State = 1016; + State = 1107; Match(T__30); Actions.EmitRawFloatingInstruction(_localctx.op, _localctx.rawFloat.Value, (_localctx.rawFloat!=null?(_localctx.rawFloat.Start):null)); } @@ -4613,9 +4731,9 @@ public SimpleInstrContext simpleInstr() { case 10: EnterOuterAlt(_localctx, 10); { - State = 1019; + State = 1110; _localctx.op = Match(INSTR_BRTARGET); - State = 1020; + State = 1111; _localctx.offset = int32(); Actions.EmitBranchOffsetInstruction(_localctx.op, (_localctx.offset!=null?(_localctx.offset.Start):null)); } @@ -4623,9 +4741,9 @@ public SimpleInstrContext simpleInstr() { case 11: EnterOuterAlt(_localctx, 11); { - State = 1023; + State = 1114; _localctx.op = Match(INSTR_BRTARGET); - State = 1024; + State = 1115; _localctx.label = id(); Actions.EmitBranchLabelInstruction(_localctx.op, (_localctx.label!=null?(_localctx.label.Start):null)); } @@ -4633,9 +4751,9 @@ public SimpleInstrContext simpleInstr() { case 12: EnterOuterAlt(_localctx, 12); { - State = 1027; + State = 1118; _localctx.op = Match(INSTR_STRING); - State = 1028; + State = 1119; _localctx.userString = compQstring(); Actions.EmitStringInstruction(_localctx.op, _localctx.userString.Value); } @@ -4643,15 +4761,15 @@ public SimpleInstrContext simpleInstr() { case 13: EnterOuterAlt(_localctx, 13); { - State = 1031; + State = 1122; _localctx.op = Match(INSTR_STRING); - State = 1032; + State = 1123; Match(ANSI); - State = 1033; + State = 1124; Match(T__29); - State = 1034; + State = 1125; _localctx.ansiString = compQstring(); - State = 1035; + State = 1126; Match(T__30); Actions.EmitAnsiStringInstruction(_localctx.op, _localctx.ansiString.Value); } @@ -4659,15 +4777,15 @@ public SimpleInstrContext simpleInstr() { case 14: EnterOuterAlt(_localctx, 14); { - State = 1038; + State = 1129; _localctx.op = Match(INSTR_STRING); - State = 1039; + State = 1130; Match(T__83); - State = 1040; + State = 1131; Match(T__29); - State = 1041; + State = 1132; _localctx.rawString = bytes(); - State = 1042; + State = 1133; Match(T__30); Actions.EmitRawStringInstruction(_localctx.op, _localctx.rawString.Value); } @@ -4675,9 +4793,9 @@ public SimpleInstrContext simpleInstr() { case 15: EnterOuterAlt(_localctx, 15); { - State = 1045; + State = 1136; _localctx.op = Match(INSTR_TOK); - State = 1046; + State = 1137; _localctx.rawToken = int32(); Actions.EmitRawTokenInstruction(_localctx.op, (_localctx.rawToken!=null?(_localctx.rawToken.Start):null)); } @@ -4685,25 +4803,25 @@ public SimpleInstrContext simpleInstr() { case 16: EnterOuterAlt(_localctx, 16); { - State = 1049; + State = 1140; _localctx.op = Match(INSTR_SWITCH); Actions.BeginSwitchInstruction(_localctx, _localctx.op); - State = 1056; + State = 1147; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__29: { - State = 1051; + State = 1142; Match(T__29); - State = 1052; + State = 1143; labels(); - State = 1053; + State = 1144; Match(T__30); } break; case T__84: { - State = 1055; + State = 1146; Match(T__84); } break; @@ -4764,11 +4882,11 @@ public CalliSignatureContext calliSignature() { try { EnterOuterAlt(_localctx, 1); { - State = 1060; + State = 1151; _localctx.convention = callConv(); - State = 1061; + State = 1152; _localctx.returnType = type(); - State = 1062; + State = 1153; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateCalliSignature(_localctx.convention.Value, _localctx.returnType.Value, _localctx.arguments.Value); } @@ -4821,7 +4939,7 @@ public LabelsContext labels() { EnterRule(_localctx, 106, RULE_labels); try { int _alt; - State = 1089; + State = 1180; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__30: @@ -4852,14 +4970,14 @@ public LabelsContext labels() { case ID: EnterOuterAlt(_localctx, 2); { - State = 1078; + State = 1169; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,39,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1072; + State = 1163; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -4883,14 +5001,14 @@ public LabelsContext labels() { case SQSTRING: case ID: { - State = 1066; + State = 1157; _localctx.headLabel = id(); Actions.AddSwitchLabel((_localctx.headLabel!=null?(_localctx.headLabel.Start):null)); } break; case INT32: { - State = 1069; + State = 1160; _localctx.headOffset = int32(); Actions.AddSwitchOffset((_localctx.headOffset!=null?(_localctx.headOffset.Start):null)); } @@ -4898,16 +5016,16 @@ public LabelsContext labels() { default: throw new NoViableAltException(this); } - State = 1074; + State = 1165; Match(T__27); } } } - State = 1080; + State = 1171; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,39,Context); } - State = 1087; + State = 1178; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -4931,14 +5049,14 @@ public LabelsContext labels() { case SQSTRING: case ID: { - State = 1081; + State = 1172; _localctx.tailLabel = id(); Actions.AddSwitchLabel((_localctx.tailLabel!=null?(_localctx.tailLabel.Start):null)); } break; case INT32: { - State = 1084; + State = 1175; _localctx.tailOffset = int32(); Actions.AddSwitchOffset((_localctx.tailOffset!=null?(_localctx.tailOffset.Start):null)); } @@ -4995,31 +5113,31 @@ public TypeArgsContext typeArgs() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1091; + State = 1182; Match(T__85); - State = 1098; + State = 1189; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,42,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1092; + State = 1183; _localctx.argument = type(); Actions.AddTypeArgument(_localctx, _localctx.argument.Value); - State = 1094; + State = 1185; Match(T__27); } } } - State = 1100; + State = 1191; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,42,Context); } - State = 1101; + State = 1192; _localctx.lastArgument = type(); Actions.AddTypeArgument(_localctx, _localctx.lastArgument.Value); - State = 1103; + State = 1194; Match(T__86); } } @@ -5067,31 +5185,31 @@ public BoundsContext bounds() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1105; + State = 1196; Match(T__41); - State = 1112; + State = 1203; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,43,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1106; + State = 1197; _localctx.item = bound(); Actions.AddBound(_localctx, _localctx.item); - State = 1108; + State = 1199; Match(T__27); } } } - State = 1114; + State = 1205; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,43,Context); } - State = 1115; + State = 1206; _localctx.lastItem = bound(); Actions.AddBound(_localctx, _localctx.lastItem); - State = 1117; + State = 1208; Match(T__42); } } @@ -5137,44 +5255,44 @@ public SigArgsContext sigArgs() { Actions.BeginSignatureArguments(_localctx); try { int _alt; - State = 1134; + State = 1225; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__29: EnterOuterAlt(_localctx, 1); { - State = 1119; + State = 1210; Match(T__29); - State = 1126; + State = 1217; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,44,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1120; + State = 1211; _localctx.argument = sigArg(); Actions.AddSignatureArgument(_localctx, _localctx.argument.Value); - State = 1122; + State = 1213; Match(T__27); } } } - State = 1128; + State = 1219; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,44,Context); } - State = 1129; + State = 1220; _localctx.lastArgument = sigArg(); Actions.AddSignatureArgument(_localctx, _localctx.lastArgument.Value); - State = 1131; + State = 1222; Match(T__30); } break; case T__84: EnterOuterAlt(_localctx, 2); { - State = 1133; + State = 1224; Match(T__84); } break; @@ -5232,13 +5350,13 @@ public SigArgContext sigArg() { EnterRule(_localctx, 114, RULE_sigArg); int _la; try { - State = 1146; + State = 1237; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,47,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1136; + State = 1227; Match(ELLIPSIS); _localctx.Value = Actions.CreateSentinelSignatureArgument(); } @@ -5246,18 +5364,18 @@ public SigArgContext sigArg() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1138; + State = 1229; _localctx.attributes = paramAttr(); - State = 1139; + State = 1230; _localctx.argumentType = type(); - State = 1140; + State = 1231; _localctx.marshalling = marshalClause(); - State = 1142; + State = 1233; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 65534L) != 0) || ((((_la - 199)) & ~0x3f) == 0 && ((1L << (_la - 199)) & 299067162755073L) != 0) || _la==SQSTRING || _la==ID) { { - State = 1141; + State = 1232; _localctx.name = id(); } } @@ -5317,19 +5435,19 @@ public ClassNameContext className() { ClassNameContext _localctx = new ClassNameContext(Context, State); EnterRule(_localctx, 116, RULE_className); try { - State = 1185; + State = 1276; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,48,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1148; + State = 1239; Match(T__41); - State = 1149; + State = 1240; _localctx.assemblyName = dottedName(); - State = 1150; + State = 1241; Match(T__42); - State = 1151; + State = 1242; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreateAssemblyQualifiedClassName(_localctx.assemblyName.Value, _localctx.typeName.Value); } @@ -5337,13 +5455,13 @@ public ClassNameContext className() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1154; + State = 1245; Match(T__41); - State = 1155; + State = 1246; _localctx.scopeToken = mdtoken(); - State = 1156; + State = 1247; Match(T__42); - State = 1157; + State = 1248; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreateTokenQualifiedClassName(_localctx.scopeToken.Value, _localctx.typeName.Value); } @@ -5351,13 +5469,13 @@ public ClassNameContext className() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1160; + State = 1251; Match(T__41); - State = 1161; + State = 1252; Match(PTR); - State = 1162; + State = 1253; Match(T__42); - State = 1163; + State = 1254; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreatePointerQualifiedClassName(_localctx.typeName.Value); } @@ -5365,15 +5483,15 @@ public ClassNameContext className() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1166; + State = 1257; Match(T__41); - State = 1167; + State = 1258; Match(MODULE); - State = 1168; + State = 1259; _localctx.moduleName = dottedName(); - State = 1169; + State = 1260; Match(T__42); - State = 1170; + State = 1261; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreateModuleQualifiedClassName(_localctx.Start, _localctx.moduleName.Value, _localctx.typeName.Value); } @@ -5381,7 +5499,7 @@ public ClassNameContext className() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1173; + State = 1264; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreateUnqualifiedClassName(_localctx.typeName.Value); } @@ -5389,7 +5507,7 @@ public ClassNameContext className() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1176; + State = 1267; _localctx.typeToken = mdtoken(); _localctx.Value = Actions.CreateTokenClassName(_localctx.typeToken.Value); } @@ -5397,7 +5515,7 @@ public ClassNameContext className() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1179; + State = 1270; Match(THIS); _localctx.Value = Actions.CreateThisClassName(_localctx.Start); } @@ -5405,7 +5523,7 @@ public ClassNameContext className() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1181; + State = 1272; Match(BASE); _localctx.Value = Actions.CreateBaseClassName(_localctx.Start); } @@ -5413,7 +5531,7 @@ public ClassNameContext className() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1183; + State = 1274; Match(NESTER); _localctx.Value = Actions.CreateNesterClassName(_localctx.Start); } @@ -5463,26 +5581,26 @@ public SlashedNameContext slashedName() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1193; + State = 1284; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,49,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1187; + State = 1278; _localctx.part = dottedName(); Actions.AddSlashedNamePart(_localctx, _localctx.part.Value); - State = 1189; + State = 1280; Match(T__87); } } } - State = 1195; + State = 1286; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,49,Context); } - State = 1196; + State = 1287; _localctx.lastPart = dottedName(); Actions.AddSlashedNamePart(_localctx, _localctx.lastPart.Value); } @@ -5527,17 +5645,17 @@ public AssemblyDeclsContext assemblyDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 1202; + State = 1293; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38654771200L) != 0) || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & 4294975503L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 6860954690125825L) != 0)) { { { - State = 1199; + State = 1290; assemblyDecl(); } } - State = 1204; + State = 1295; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -5583,18 +5701,18 @@ public AssemblyDeclContext assemblyDecl() { AssemblyDeclContext _localctx = new AssemblyDeclContext(Context, State); EnterRule(_localctx, 122, RULE_assemblyDecl); try { - State = 1210; + State = 1301; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case HASH: EnterOuterAlt(_localctx, 1); { { - State = 1205; + State = 1296; Match(HASH); - State = 1206; + State = 1297; Match(T__88); - State = 1207; + State = 1298; int32(); } } @@ -5603,7 +5721,7 @@ public AssemblyDeclContext assemblyDecl() { case PERMISSIONSET: EnterOuterAlt(_localctx, 2); { - State = 1208; + State = 1299; secDecl(); } break; @@ -5628,7 +5746,7 @@ public AssemblyDeclContext assemblyDecl() { case ID: EnterOuterAlt(_localctx, 3); { - State = 1209; + State = 1300; asmOrRefDecl(); } break; @@ -5683,13 +5801,13 @@ public TypeSpecContext typeSpec() { EnterRule(_localctx, 124, RULE_typeSpec); Actions.BeginSemanticRoot(_localctx); try { - State = 1229; + State = 1320; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,52,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1212; + State = 1303; _localctx.classType = className(); _localctx.Value = Actions.CreateClassTypeSpecification(_localctx.classType.Value); } @@ -5697,11 +5815,11 @@ public TypeSpecContext typeSpec() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1215; + State = 1306; Match(T__41); - State = 1216; + State = 1307; _localctx.assemblyName = dottedName(); - State = 1217; + State = 1308; Match(T__42); _localctx.Value = Actions.CreateAssemblyTypeSpecification(_localctx.assemblyName.Value); } @@ -5709,13 +5827,13 @@ public TypeSpecContext typeSpec() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1220; + State = 1311; Match(T__41); - State = 1221; + State = 1312; Match(MODULE); - State = 1222; + State = 1313; _localctx.moduleName = dottedName(); - State = 1223; + State = 1314; Match(T__42); _localctx.Value = Actions.CreateModuleTypeSpecification(_localctx.moduleName.Value); } @@ -5723,7 +5841,7 @@ public TypeSpecContext typeSpec() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1226; + State = 1317; _localctx.signatureType = type(); _localctx.Value = Actions.CreateSignatureTypeSpecification(_localctx.signatureType.Value); } @@ -5775,7 +5893,7 @@ public NativeTypeContext nativeType() { Actions.BeginNativeType(_localctx); try { int _alt; - State = 1242; + State = 1333; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,54,Context) ) { case 1: @@ -5786,23 +5904,23 @@ public NativeTypeContext nativeType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1232; + State = 1323; _localctx.element = nativeTypeElement(); Actions.SetNativeTypeElement(_localctx, _localctx.element.Value); - State = 1239; + State = 1330; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,53,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1234; + State = 1325; _localctx.info = nativeTypeArrayPointerInfo(); Actions.AddNativeTypeArrayPointerInfo(_localctx, _localctx.info.Value); } } } - State = 1241; + State = 1332; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,53,Context); } @@ -5907,14 +6025,14 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { NativeTypeArrayPointerInfoContext _localctx = new NativeTypeArrayPointerInfoContext(Context, State); EnterRule(_localctx, 128, RULE_nativeTypeArrayPointerInfo); try { - State = 1266; + State = 1357; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,55,Context) ) { case 1: _localctx = new PointerNativeTypeContext(_localctx); EnterOuterAlt(_localctx, 1); { - State = 1244; + State = 1335; Match(PTR); _localctx.Value = Actions.CreatePointerNativeType(); } @@ -5923,7 +6041,7 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeNoSizeDataContext(_localctx); EnterOuterAlt(_localctx, 2); { - State = 1246; + State = 1337; Match(ARRAY_TYPE_NO_BOUNDS); _localctx.Value = Actions.CreatePointerArrayTypeNoSizeData(); } @@ -5932,11 +6050,11 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeSizeContext(_localctx); EnterOuterAlt(_localctx, 3); { - State = 1248; + State = 1339; Match(T__41); - State = 1249; + State = 1340; ((PointerArrayTypeSizeContext)_localctx).size = int32(); - State = 1250; + State = 1341; Match(T__42); _localctx.Value = Actions.CreatePointerArrayTypeSize((((PointerArrayTypeSizeContext)_localctx).size!=null?(((PointerArrayTypeSizeContext)_localctx).size.Start):null)); } @@ -5945,15 +6063,15 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeSizeParamIndexContext(_localctx); EnterOuterAlt(_localctx, 4); { - State = 1253; + State = 1344; Match(T__41); - State = 1254; + State = 1345; ((PointerArrayTypeSizeParamIndexContext)_localctx).size = int32(); - State = 1255; + State = 1346; Match(PLUS); - State = 1256; + State = 1347; ((PointerArrayTypeSizeParamIndexContext)_localctx).parameterIndex = int32(); - State = 1257; + State = 1348; Match(T__42); _localctx.Value = Actions.CreatePointerArrayTypeSizeParamIndex((((PointerArrayTypeSizeParamIndexContext)_localctx).size!=null?(((PointerArrayTypeSizeParamIndexContext)_localctx).size.Start):null), (((PointerArrayTypeSizeParamIndexContext)_localctx).parameterIndex!=null?(((PointerArrayTypeSizeParamIndexContext)_localctx).parameterIndex.Start):null)); } @@ -5962,13 +6080,13 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeParamIndexContext(_localctx); EnterOuterAlt(_localctx, 5); { - State = 1260; + State = 1351; Match(T__41); - State = 1261; + State = 1352; Match(PLUS); - State = 1262; + State = 1353; ((PointerArrayTypeParamIndexContext)_localctx).parameterIndex = int32(); - State = 1263; + State = 1354; Match(T__42); _localctx.Value = Actions.CreatePointerArrayTypeParamIndex((((PointerArrayTypeParamIndexContext)_localctx).parameterIndex!=null?(((PointerArrayTypeParamIndexContext)_localctx).parameterIndex.Start):null)); } @@ -6080,7 +6198,7 @@ public NativeTypeElementContext nativeTypeElement() { NativeTypeElementContext _localctx = new NativeTypeElementContext(Context, State); EnterRule(_localctx, 130, RULE_nativeTypeElement); try { - State = 1413; + State = 1504; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,56,Context) ) { case 1: @@ -6092,25 +6210,25 @@ public NativeTypeElementContext nativeTypeElement() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1269; + State = 1360; _localctx.marshalType = Match(CUSTOM); - State = 1270; + State = 1361; Match(T__29); - State = 1271; + State = 1362; _localctx.guid = compQstring(); - State = 1272; + State = 1363; Match(T__27); - State = 1273; + State = 1364; _localctx.nativeTypeName = compQstring(); - State = 1274; + State = 1365; Match(T__27); - State = 1275; + State = 1366; _localctx.marshallerType = compQstring(); - State = 1276; + State = 1367; Match(T__27); - State = 1277; + State = 1368; _localctx.cookie = compQstring(); - State = 1278; + State = 1369; Match(T__30); _localctx.Value = Actions.CreateDeprecatedCustomMarshallerNativeType( _localctx, _localctx.guid.Value, _localctx.nativeTypeName.Value, _localctx.marshallerType.Value, _localctx.cookie.Value); @@ -6119,17 +6237,17 @@ public NativeTypeElementContext nativeTypeElement() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1281; + State = 1372; _localctx.marshalType = Match(CUSTOM); - State = 1282; + State = 1373; Match(T__29); - State = 1283; + State = 1374; _localctx.marshallerType = compQstring(); - State = 1284; + State = 1375; Match(T__27); - State = 1285; + State = 1376; _localctx.cookie = compQstring(); - State = 1286; + State = 1377; Match(T__30); _localctx.Value = Actions.CreateCustomMarshallerNativeType(_localctx.marshallerType.Value, _localctx.cookie.Value); } @@ -6137,15 +6255,15 @@ public NativeTypeElementContext nativeTypeElement() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1289; + State = 1380; Match(FIXED); - State = 1290; + State = 1381; _localctx.marshalType = Match(SYSSTRING); - State = 1291; + State = 1382; Match(T__41); - State = 1292; + State = 1383; _localctx.size = int32(); - State = 1293; + State = 1384; Match(T__42); _localctx.Value = Actions.CreateFixedSysStringNativeType((_localctx.size!=null?(_localctx.size.Start):null)); } @@ -6153,17 +6271,17 @@ public NativeTypeElementContext nativeTypeElement() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1296; + State = 1387; Match(FIXED); - State = 1297; + State = 1388; _localctx.marshalType = Match(ARRAY); - State = 1298; + State = 1389; Match(T__41); - State = 1299; + State = 1390; _localctx.size = int32(); - State = 1300; + State = 1391; Match(T__42); - State = 1301; + State = 1392; _localctx.element = nativeType(); _localctx.Value = Actions.CreateFixedArrayNativeType((_localctx.size!=null?(_localctx.size.Start):null), _localctx.element.Value); } @@ -6171,7 +6289,7 @@ public NativeTypeElementContext nativeTypeElement() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1304; + State = 1395; _localctx.marshalType = Match(VARIANT); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6179,7 +6297,7 @@ public NativeTypeElementContext nativeTypeElement() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1306; + State = 1397; _localctx.marshalType = Match(CURRENCY); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6187,7 +6305,7 @@ public NativeTypeElementContext nativeTypeElement() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1308; + State = 1399; _localctx.marshalType = Match(SYSCHAR); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6195,7 +6313,7 @@ public NativeTypeElementContext nativeTypeElement() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1310; + State = 1401; _localctx.marshalType = Match(VOID); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6203,7 +6321,7 @@ public NativeTypeElementContext nativeTypeElement() { case 10: EnterOuterAlt(_localctx, 10); { - State = 1312; + State = 1403; _localctx.marshalType = Match(BOOL); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6211,7 +6329,7 @@ public NativeTypeElementContext nativeTypeElement() { case 11: EnterOuterAlt(_localctx, 11); { - State = 1314; + State = 1405; _localctx.marshalType = Match(INT8); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6219,7 +6337,7 @@ public NativeTypeElementContext nativeTypeElement() { case 12: EnterOuterAlt(_localctx, 12); { - State = 1316; + State = 1407; _localctx.marshalType = Match(INT16); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6227,7 +6345,7 @@ public NativeTypeElementContext nativeTypeElement() { case 13: EnterOuterAlt(_localctx, 13); { - State = 1318; + State = 1409; _localctx.marshalType = Match(INT32_); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6235,7 +6353,7 @@ public NativeTypeElementContext nativeTypeElement() { case 14: EnterOuterAlt(_localctx, 14); { - State = 1320; + State = 1411; _localctx.marshalType = Match(INT64_); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6243,7 +6361,7 @@ public NativeTypeElementContext nativeTypeElement() { case 15: EnterOuterAlt(_localctx, 15); { - State = 1322; + State = 1413; _localctx.marshalType = Match(FLOAT32); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6251,7 +6369,7 @@ public NativeTypeElementContext nativeTypeElement() { case 16: EnterOuterAlt(_localctx, 16); { - State = 1324; + State = 1415; _localctx.marshalType = Match(FLOAT64_); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6259,7 +6377,7 @@ public NativeTypeElementContext nativeTypeElement() { case 17: EnterOuterAlt(_localctx, 17); { - State = 1326; + State = 1417; _localctx.marshalType = Match(ERROR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6267,7 +6385,7 @@ public NativeTypeElementContext nativeTypeElement() { case 18: EnterOuterAlt(_localctx, 18); { - State = 1328; + State = 1419; _localctx.marshalType = Match(UINT8); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6275,7 +6393,7 @@ public NativeTypeElementContext nativeTypeElement() { case 19: EnterOuterAlt(_localctx, 19); { - State = 1330; + State = 1421; _localctx.marshalType = Match(UINT16); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6283,7 +6401,7 @@ public NativeTypeElementContext nativeTypeElement() { case 20: EnterOuterAlt(_localctx, 20); { - State = 1332; + State = 1423; _localctx.marshalType = Match(UINT32); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6291,7 +6409,7 @@ public NativeTypeElementContext nativeTypeElement() { case 21: EnterOuterAlt(_localctx, 21); { - State = 1334; + State = 1425; _localctx.marshalType = Match(UINT64); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6299,7 +6417,7 @@ public NativeTypeElementContext nativeTypeElement() { case 22: EnterOuterAlt(_localctx, 22); { - State = 1336; + State = 1427; _localctx.marshalType = Match(DECIMAL); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6307,7 +6425,7 @@ public NativeTypeElementContext nativeTypeElement() { case 23: EnterOuterAlt(_localctx, 23); { - State = 1338; + State = 1429; _localctx.marshalType = Match(DATE); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6315,7 +6433,7 @@ public NativeTypeElementContext nativeTypeElement() { case 24: EnterOuterAlt(_localctx, 24); { - State = 1340; + State = 1431; _localctx.marshalType = Match(BSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6323,7 +6441,7 @@ public NativeTypeElementContext nativeTypeElement() { case 25: EnterOuterAlt(_localctx, 25); { - State = 1342; + State = 1433; _localctx.marshalType = Match(LPSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6331,7 +6449,7 @@ public NativeTypeElementContext nativeTypeElement() { case 26: EnterOuterAlt(_localctx, 26); { - State = 1344; + State = 1435; _localctx.marshalType = Match(LPWSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6339,7 +6457,7 @@ public NativeTypeElementContext nativeTypeElement() { case 27: EnterOuterAlt(_localctx, 27); { - State = 1346; + State = 1437; _localctx.marshalType = Match(LPTSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6347,7 +6465,7 @@ public NativeTypeElementContext nativeTypeElement() { case 28: EnterOuterAlt(_localctx, 28); { - State = 1348; + State = 1439; _localctx.marshalType = Match(OBJECTREF); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6355,9 +6473,9 @@ public NativeTypeElementContext nativeTypeElement() { case 29: EnterOuterAlt(_localctx, 29); { - State = 1350; + State = 1441; _localctx.marshalType = Match(IUNKNOWN); - State = 1351; + State = 1442; _localctx.index = iidParamIndex(); _localctx.Value = Actions.CreateIidNativeType(_localctx.marshalType, _localctx.index.Value); } @@ -6365,9 +6483,9 @@ public NativeTypeElementContext nativeTypeElement() { case 30: EnterOuterAlt(_localctx, 30); { - State = 1354; + State = 1445; _localctx.marshalType = Match(IDISPATCH); - State = 1355; + State = 1446; _localctx.index = iidParamIndex(); _localctx.Value = Actions.CreateIidNativeType(_localctx.marshalType, _localctx.index.Value); } @@ -6375,7 +6493,7 @@ public NativeTypeElementContext nativeTypeElement() { case 31: EnterOuterAlt(_localctx, 31); { - State = 1358; + State = 1449; _localctx.marshalType = Match(STRUCT); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6383,9 +6501,9 @@ public NativeTypeElementContext nativeTypeElement() { case 32: EnterOuterAlt(_localctx, 32); { - State = 1360; + State = 1451; _localctx.marshalType = Match(INTERFACE); - State = 1361; + State = 1452; _localctx.index = iidParamIndex(); _localctx.Value = Actions.CreateIidNativeType(_localctx.marshalType, _localctx.index.Value); } @@ -6393,9 +6511,9 @@ public NativeTypeElementContext nativeTypeElement() { case 33: EnterOuterAlt(_localctx, 33); { - State = 1364; + State = 1455; _localctx.marshalType = Match(SAFEARRAY); - State = 1365; + State = 1456; _localctx.variant = variantType(); _localctx.Value = Actions.CreateSafeArrayNativeType(_localctx.variant.Value, null); } @@ -6403,13 +6521,13 @@ public NativeTypeElementContext nativeTypeElement() { case 34: EnterOuterAlt(_localctx, 34); { - State = 1368; + State = 1459; _localctx.marshalType = Match(SAFEARRAY); - State = 1369; + State = 1460; _localctx.variant = variantType(); - State = 1370; + State = 1461; Match(T__27); - State = 1371; + State = 1462; _localctx.userDefinedType = compQstring(); _localctx.Value = Actions.CreateSafeArrayNativeType(_localctx.variant.Value, _localctx.userDefinedType.Value); } @@ -6417,7 +6535,7 @@ public NativeTypeElementContext nativeTypeElement() { case 35: EnterOuterAlt(_localctx, 35); { - State = 1374; + State = 1465; _localctx.marshalType = Match(INT); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6425,7 +6543,7 @@ public NativeTypeElementContext nativeTypeElement() { case 36: EnterOuterAlt(_localctx, 36); { - State = 1376; + State = 1467; _localctx.marshalType = Match(UINT); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6433,9 +6551,9 @@ public NativeTypeElementContext nativeTypeElement() { case 37: EnterOuterAlt(_localctx, 37); { - State = 1378; + State = 1469; Match(T__89); - State = 1379; + State = 1470; _localctx.unsignedMarshalType = Match(INT8); _localctx.Value = Actions.CreateUnsignedNativeType(_localctx.unsignedMarshalType); } @@ -6443,9 +6561,9 @@ public NativeTypeElementContext nativeTypeElement() { case 38: EnterOuterAlt(_localctx, 38); { - State = 1381; + State = 1472; Match(T__89); - State = 1382; + State = 1473; _localctx.unsignedMarshalType = Match(INT16); _localctx.Value = Actions.CreateUnsignedNativeType(_localctx.unsignedMarshalType); } @@ -6453,9 +6571,9 @@ public NativeTypeElementContext nativeTypeElement() { case 39: EnterOuterAlt(_localctx, 39); { - State = 1384; + State = 1475; Match(T__89); - State = 1385; + State = 1476; _localctx.unsignedMarshalType = Match(INT32_); _localctx.Value = Actions.CreateUnsignedNativeType(_localctx.unsignedMarshalType); } @@ -6463,9 +6581,9 @@ public NativeTypeElementContext nativeTypeElement() { case 40: EnterOuterAlt(_localctx, 40); { - State = 1387; + State = 1478; Match(T__89); - State = 1388; + State = 1479; _localctx.unsignedMarshalType = Match(INT64_); _localctx.Value = Actions.CreateUnsignedNativeType(_localctx.unsignedMarshalType); } @@ -6473,9 +6591,9 @@ public NativeTypeElementContext nativeTypeElement() { case 41: EnterOuterAlt(_localctx, 41); { - State = 1390; + State = 1481; Match(T__61); - State = 1391; + State = 1482; _localctx.marshalType = Match(STRUCT); _localctx.Value = Actions.CreateNestedStructNativeType(_localctx); } @@ -6483,7 +6601,7 @@ public NativeTypeElementContext nativeTypeElement() { case 42: EnterOuterAlt(_localctx, 42); { - State = 1393; + State = 1484; _localctx.marshalType = Match(BYVALSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6491,9 +6609,9 @@ public NativeTypeElementContext nativeTypeElement() { case 43: EnterOuterAlt(_localctx, 43); { - State = 1395; + State = 1486; Match(ANSI); - State = 1396; + State = 1487; _localctx.marshalType = Match(BSTR); _localctx.Value = Actions.CreateAnsiBstrNativeType(); } @@ -6501,7 +6619,7 @@ public NativeTypeElementContext nativeTypeElement() { case 44: EnterOuterAlt(_localctx, 44); { - State = 1398; + State = 1489; _localctx.marshalType = Match(TBSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6509,9 +6627,9 @@ public NativeTypeElementContext nativeTypeElement() { case 45: EnterOuterAlt(_localctx, 45); { - State = 1400; + State = 1491; Match(VARIANT); - State = 1401; + State = 1492; _localctx.marshalBool = Match(BOOL); _localctx.Value = Actions.CreateVariantBoolNativeType(); } @@ -6519,7 +6637,7 @@ public NativeTypeElementContext nativeTypeElement() { case 46: EnterOuterAlt(_localctx, 46); { - State = 1403; + State = 1494; _localctx.marshalType = Match(METHOD); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6527,7 +6645,7 @@ public NativeTypeElementContext nativeTypeElement() { case 47: EnterOuterAlt(_localctx, 47); { - State = 1405; + State = 1496; _localctx.marshalType = Match(LPSTRUCT); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6535,9 +6653,9 @@ public NativeTypeElementContext nativeTypeElement() { case 48: EnterOuterAlt(_localctx, 48); { - State = 1407; + State = 1498; Match(T__33); - State = 1408; + State = 1499; _localctx.marshalType = Match(ANY); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6545,7 +6663,7 @@ public NativeTypeElementContext nativeTypeElement() { case 49: EnterOuterAlt(_localctx, 49); { - State = 1410; + State = 1501; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateNativeTypeTypedef(_localctx, _localctx.alias.Value); } @@ -6587,7 +6705,7 @@ public IidParamIndexContext iidParamIndex() { IidParamIndexContext _localctx = new IidParamIndexContext(Context, State); EnterRule(_localctx, 132, RULE_iidParamIndex); try { - State = 1423; + State = 1514; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__30: @@ -6601,15 +6719,15 @@ public IidParamIndexContext iidParamIndex() { case T__29: EnterOuterAlt(_localctx, 2); { - State = 1416; + State = 1507; Match(T__29); - State = 1417; + State = 1508; Match(T__90); - State = 1418; + State = 1509; Match(T__35); - State = 1419; + State = 1510; _localctx.index = int32(); - State = 1420; + State = 1511; Match(T__30); _localctx.Value = Actions.GetIidParamIndex((_localctx.index!=null?(_localctx.index.Start):null)); } @@ -6669,7 +6787,7 @@ public VariantTypeContext variantType() { int _la; try { int _alt; - State = 1435; + State = 1526; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,59,Context) ) { case 1: @@ -6680,17 +6798,17 @@ public VariantTypeContext variantType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1426; + State = 1517; _localctx.element = variantTypeElement(); Actions.SetVariantTypeElement(_localctx, _localctx.element.Value); - State = 1432; + State = 1523; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,58,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1428; + State = 1519; _localctx.modifier = TokenStream.LT(1); _la = TokenStream.LA(1); if ( !(((((_la - 229)) & ~0x3f) == 0 && ((1L << (_la - 229)) & 6442450945L) != 0)) ) { @@ -6704,7 +6822,7 @@ public VariantTypeContext variantType() { } } } - State = 1434; + State = 1525; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,58,Context); } @@ -6785,13 +6903,13 @@ public VariantTypeElementContext variantTypeElement() { VariantTypeElementContext _localctx = new VariantTypeElementContext(Context, State); EnterRule(_localctx, 136, RULE_variantTypeElement); try { - State = 1517; + State = 1608; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case NULL: EnterOuterAlt(_localctx, 1); { - State = 1437; + State = 1528; _localctx.value = Match(NULL); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6799,7 +6917,7 @@ public VariantTypeElementContext variantTypeElement() { case VARIANT: EnterOuterAlt(_localctx, 2); { - State = 1439; + State = 1530; _localctx.value = Match(VARIANT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6807,7 +6925,7 @@ public VariantTypeElementContext variantTypeElement() { case CURRENCY: EnterOuterAlt(_localctx, 3); { - State = 1441; + State = 1532; _localctx.value = Match(CURRENCY); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6815,7 +6933,7 @@ public VariantTypeElementContext variantTypeElement() { case VOID: EnterOuterAlt(_localctx, 4); { - State = 1443; + State = 1534; _localctx.value = Match(VOID); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6823,7 +6941,7 @@ public VariantTypeElementContext variantTypeElement() { case BOOL: EnterOuterAlt(_localctx, 5); { - State = 1445; + State = 1536; _localctx.value = Match(BOOL); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6831,7 +6949,7 @@ public VariantTypeElementContext variantTypeElement() { case INT8: EnterOuterAlt(_localctx, 6); { - State = 1447; + State = 1538; _localctx.value = Match(INT8); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6839,7 +6957,7 @@ public VariantTypeElementContext variantTypeElement() { case INT16: EnterOuterAlt(_localctx, 7); { - State = 1449; + State = 1540; _localctx.value = Match(INT16); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6847,7 +6965,7 @@ public VariantTypeElementContext variantTypeElement() { case INT32_: EnterOuterAlt(_localctx, 8); { - State = 1451; + State = 1542; _localctx.value = Match(INT32_); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6855,7 +6973,7 @@ public VariantTypeElementContext variantTypeElement() { case INT64_: EnterOuterAlt(_localctx, 9); { - State = 1453; + State = 1544; _localctx.value = Match(INT64_); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6863,7 +6981,7 @@ public VariantTypeElementContext variantTypeElement() { case FLOAT32: EnterOuterAlt(_localctx, 10); { - State = 1455; + State = 1546; _localctx.value = Match(FLOAT32); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6871,7 +6989,7 @@ public VariantTypeElementContext variantTypeElement() { case FLOAT64_: EnterOuterAlt(_localctx, 11); { - State = 1457; + State = 1548; _localctx.value = Match(FLOAT64_); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6879,7 +6997,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT8: EnterOuterAlt(_localctx, 12); { - State = 1459; + State = 1550; _localctx.value = Match(UINT8); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6887,7 +7005,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT16: EnterOuterAlt(_localctx, 13); { - State = 1461; + State = 1552; _localctx.value = Match(UINT16); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6895,7 +7013,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT32: EnterOuterAlt(_localctx, 14); { - State = 1463; + State = 1554; _localctx.value = Match(UINT32); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6903,7 +7021,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT64: EnterOuterAlt(_localctx, 15); { - State = 1465; + State = 1556; _localctx.value = Match(UINT64); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6911,7 +7029,7 @@ public VariantTypeElementContext variantTypeElement() { case PTR: EnterOuterAlt(_localctx, 16); { - State = 1467; + State = 1558; _localctx.value = Match(PTR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6919,7 +7037,7 @@ public VariantTypeElementContext variantTypeElement() { case DECIMAL: EnterOuterAlt(_localctx, 17); { - State = 1469; + State = 1560; _localctx.value = Match(DECIMAL); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6927,7 +7045,7 @@ public VariantTypeElementContext variantTypeElement() { case DATE: EnterOuterAlt(_localctx, 18); { - State = 1471; + State = 1562; _localctx.value = Match(DATE); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6935,7 +7053,7 @@ public VariantTypeElementContext variantTypeElement() { case BSTR: EnterOuterAlt(_localctx, 19); { - State = 1473; + State = 1564; _localctx.value = Match(BSTR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6943,7 +7061,7 @@ public VariantTypeElementContext variantTypeElement() { case LPSTR: EnterOuterAlt(_localctx, 20); { - State = 1475; + State = 1566; _localctx.value = Match(LPSTR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6951,7 +7069,7 @@ public VariantTypeElementContext variantTypeElement() { case LPWSTR: EnterOuterAlt(_localctx, 21); { - State = 1477; + State = 1568; _localctx.value = Match(LPWSTR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6959,7 +7077,7 @@ public VariantTypeElementContext variantTypeElement() { case IUNKNOWN: EnterOuterAlt(_localctx, 22); { - State = 1479; + State = 1570; _localctx.value = Match(IUNKNOWN); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6967,7 +7085,7 @@ public VariantTypeElementContext variantTypeElement() { case IDISPATCH: EnterOuterAlt(_localctx, 23); { - State = 1481; + State = 1572; _localctx.value = Match(IDISPATCH); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6975,7 +7093,7 @@ public VariantTypeElementContext variantTypeElement() { case SAFEARRAY: EnterOuterAlt(_localctx, 24); { - State = 1483; + State = 1574; _localctx.value = Match(SAFEARRAY); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6983,7 +7101,7 @@ public VariantTypeElementContext variantTypeElement() { case INT: EnterOuterAlt(_localctx, 25); { - State = 1485; + State = 1576; _localctx.value = Match(INT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6991,7 +7109,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT: EnterOuterAlt(_localctx, 26); { - State = 1487; + State = 1578; _localctx.value = Match(UINT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6999,7 +7117,7 @@ public VariantTypeElementContext variantTypeElement() { case ERROR: EnterOuterAlt(_localctx, 27); { - State = 1489; + State = 1580; _localctx.value = Match(ERROR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7007,7 +7125,7 @@ public VariantTypeElementContext variantTypeElement() { case HRESULT: EnterOuterAlt(_localctx, 28); { - State = 1491; + State = 1582; _localctx.value = Match(HRESULT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7015,7 +7133,7 @@ public VariantTypeElementContext variantTypeElement() { case CARRAY: EnterOuterAlt(_localctx, 29); { - State = 1493; + State = 1584; _localctx.value = Match(CARRAY); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7023,7 +7141,7 @@ public VariantTypeElementContext variantTypeElement() { case USERDEFINED: EnterOuterAlt(_localctx, 30); { - State = 1495; + State = 1586; _localctx.value = Match(USERDEFINED); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7031,7 +7149,7 @@ public VariantTypeElementContext variantTypeElement() { case RECORD: EnterOuterAlt(_localctx, 31); { - State = 1497; + State = 1588; _localctx.value = Match(RECORD); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7039,7 +7157,7 @@ public VariantTypeElementContext variantTypeElement() { case FILETIME: EnterOuterAlt(_localctx, 32); { - State = 1499; + State = 1590; _localctx.value = Match(FILETIME); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7047,7 +7165,7 @@ public VariantTypeElementContext variantTypeElement() { case BLOB: EnterOuterAlt(_localctx, 33); { - State = 1501; + State = 1592; _localctx.value = Match(BLOB); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7055,7 +7173,7 @@ public VariantTypeElementContext variantTypeElement() { case STREAM: EnterOuterAlt(_localctx, 34); { - State = 1503; + State = 1594; _localctx.value = Match(STREAM); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7063,7 +7181,7 @@ public VariantTypeElementContext variantTypeElement() { case STORAGE: EnterOuterAlt(_localctx, 35); { - State = 1505; + State = 1596; _localctx.value = Match(STORAGE); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7071,7 +7189,7 @@ public VariantTypeElementContext variantTypeElement() { case STREAMED_OBJECT: EnterOuterAlt(_localctx, 36); { - State = 1507; + State = 1598; _localctx.value = Match(STREAMED_OBJECT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7079,7 +7197,7 @@ public VariantTypeElementContext variantTypeElement() { case STORED_OBJECT: EnterOuterAlt(_localctx, 37); { - State = 1509; + State = 1600; _localctx.value = Match(STORED_OBJECT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7087,7 +7205,7 @@ public VariantTypeElementContext variantTypeElement() { case BLOB_OBJECT: EnterOuterAlt(_localctx, 38); { - State = 1511; + State = 1602; _localctx.value = Match(BLOB_OBJECT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7095,7 +7213,7 @@ public VariantTypeElementContext variantTypeElement() { case CF: EnterOuterAlt(_localctx, 39); { - State = 1513; + State = 1604; _localctx.value = Match(CF); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7103,7 +7221,7 @@ public VariantTypeElementContext variantTypeElement() { case CLSID: EnterOuterAlt(_localctx, 40); { - State = 1515; + State = 1606; _localctx.value = Match(CLSID); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7158,23 +7276,23 @@ public TypeContext type() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1519; + State = 1610; _localctx.element = elementType(); Actions.SetTypeSignatureElement(_localctx, _localctx.element.Value); - State = 1526; + State = 1617; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,61,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1521; + State = 1612; _localctx.modifier = typeModifiers(); Actions.AddTypeSignatureModifier(_localctx, _localctx.modifier.Value); } } } - State = 1528; + State = 1619; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,61,Context); } @@ -7303,14 +7421,14 @@ public TypeModifiersContext typeModifiers() { TypeModifiersContext _localctx = new TypeModifiersContext(Context, State); EnterRule(_localctx, 140, RULE_typeModifiers); try { - State = 1558; + State = 1649; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,62,Context) ) { case 1: _localctx = new SZArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 1); { - State = 1529; + State = 1620; Match(ARRAY_TYPE_NO_BOUNDS); _localctx.Value = Actions.CreateSzArrayTypeModifier(); } @@ -7319,9 +7437,9 @@ public TypeModifiersContext typeModifiers() { _localctx = new SZArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 2); { - State = 1531; + State = 1622; Match(T__41); - State = 1532; + State = 1623; Match(T__42); _localctx.Value = Actions.CreateSzArrayTypeModifier(); } @@ -7330,7 +7448,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new ArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 3); { - State = 1534; + State = 1625; ((ArrayModifierContext)_localctx).arrayBounds = bounds(); _localctx.Value = Actions.CreateArrayTypeModifier(((ArrayModifierContext)_localctx).arrayBounds.Value); } @@ -7339,7 +7457,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new ByRefModifierContext(_localctx); EnterOuterAlt(_localctx, 4); { - State = 1537; + State = 1628; Match(REF); _localctx.Value = Actions.CreateByReferenceTypeModifier(); } @@ -7348,7 +7466,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new PtrModifierContext(_localctx); EnterOuterAlt(_localctx, 5); { - State = 1539; + State = 1630; Match(PTR); _localctx.Value = Actions.CreatePointerTypeModifier(); } @@ -7357,7 +7475,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new PinnedModifierContext(_localctx); EnterOuterAlt(_localctx, 6); { - State = 1541; + State = 1632; Match(T__91); _localctx.Value = Actions.CreatePinnedTypeModifier(); } @@ -7366,13 +7484,13 @@ public TypeModifiersContext typeModifiers() { _localctx = new RequiredModifierContext(_localctx); EnterOuterAlt(_localctx, 7); { - State = 1543; + State = 1634; Match(T__92); - State = 1544; + State = 1635; Match(T__29); - State = 1545; + State = 1636; ((RequiredModifierContext)_localctx).modifierType = typeSpec(); - State = 1546; + State = 1637; Match(T__30); _localctx.Value = Actions.CreateCustomTypeModifier(((RequiredModifierContext)_localctx).modifierType.Value, true); } @@ -7381,13 +7499,13 @@ public TypeModifiersContext typeModifiers() { _localctx = new OptionalModifierContext(_localctx); EnterOuterAlt(_localctx, 8); { - State = 1549; + State = 1640; Match(T__93); - State = 1550; + State = 1641; Match(T__29); - State = 1551; + State = 1642; ((OptionalModifierContext)_localctx).modifierType = typeSpec(); - State = 1552; + State = 1643; Match(T__30); _localctx.Value = Actions.CreateCustomTypeModifier(((OptionalModifierContext)_localctx).modifierType.Value, false); } @@ -7396,7 +7514,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new GenericArgumentsModifierContext(_localctx); EnterOuterAlt(_localctx, 9); { - State = 1555; + State = 1646; ((GenericArgumentsModifierContext)_localctx).arguments = typeArgs(); _localctx.Value = Actions.CreateGenericArgumentsModifier(((GenericArgumentsModifierContext)_localctx).arguments.Value); } @@ -7484,15 +7602,15 @@ public ElementTypeContext elementType() { ElementTypeContext _localctx = new ElementTypeContext(Context, State); EnterRule(_localctx, 142, RULE_elementType); try { - State = 1618; + State = 1709; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,63,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1560; + State = 1651; Match(T__38); - State = 1561; + State = 1652; _localctx.classType = className(); _localctx.Value = Actions.CreateClassElementType(_localctx.classType.Value, false); } @@ -7500,7 +7618,7 @@ public ElementTypeContext elementType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1564; + State = 1655; Match(OBJECT); _localctx.Value = Actions.CreateObjectElementType(); } @@ -7508,11 +7626,11 @@ public ElementTypeContext elementType() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1566; + State = 1657; Match(VALUE); - State = 1567; + State = 1658; Match(T__38); - State = 1568; + State = 1659; _localctx.valueClassType = className(); _localctx.Value = Actions.CreateClassElementType(_localctx.valueClassType.Value, true); } @@ -7520,9 +7638,9 @@ public ElementTypeContext elementType() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1571; + State = 1662; Match(VALUETYPE); - State = 1572; + State = 1663; _localctx.valueType = className(); _localctx.Value = Actions.CreateClassElementType(_localctx.valueType.Value, true); } @@ -7530,15 +7648,15 @@ public ElementTypeContext elementType() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1575; + State = 1666; Match(METHOD); - State = 1576; + State = 1667; _localctx.convention = callConv(); - State = 1577; + State = 1668; _localctx.returnType = type(); - State = 1578; + State = 1669; Match(PTR); - State = 1579; + State = 1670; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateFunctionPointerElementType(_localctx.convention.Value, _localctx.returnType.Value, _localctx.arguments.Value); } @@ -7546,9 +7664,9 @@ public ElementTypeContext elementType() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1582; + State = 1673; Match(METHOD_TYPE_PARAMETER); - State = 1583; + State = 1674; _localctx.parameterIndex = int32(); _localctx.Value = Actions.CreateIndexedGenericParameterElementType(true, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null)); } @@ -7556,9 +7674,9 @@ public ElementTypeContext elementType() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1586; + State = 1677; Match(TYPE_PARAMETER); - State = 1587; + State = 1678; _localctx.parameterIndex = int32(); _localctx.Value = Actions.CreateIndexedGenericParameterElementType(false, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null)); } @@ -7566,9 +7684,9 @@ public ElementTypeContext elementType() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1590; + State = 1681; Match(METHOD_TYPE_PARAMETER); - State = 1591; + State = 1682; _localctx.parameterName = dottedName(); _localctx.Value = Actions.CreateNamedGenericParameterElementType(_localctx.Start, true, _localctx.parameterName.Value); } @@ -7576,9 +7694,9 @@ public ElementTypeContext elementType() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1594; + State = 1685; Match(TYPE_PARAMETER); - State = 1595; + State = 1686; _localctx.parameterName = dottedName(); _localctx.Value = Actions.CreateNamedGenericParameterElementType(_localctx.Start, false, _localctx.parameterName.Value); } @@ -7586,7 +7704,7 @@ public ElementTypeContext elementType() { case 10: EnterOuterAlt(_localctx, 10); { - State = 1598; + State = 1689; Match(TYPEDREF); _localctx.Value = Actions.CreateTypedReferenceElementType(); } @@ -7594,7 +7712,7 @@ public ElementTypeContext elementType() { case 11: EnterOuterAlt(_localctx, 11); { - State = 1600; + State = 1691; Match(VOID); _localctx.Value = Actions.CreateVoidElementType(); } @@ -7602,7 +7720,7 @@ public ElementTypeContext elementType() { case 12: EnterOuterAlt(_localctx, 12); { - State = 1602; + State = 1693; _localctx.signedNative = nativeInt(); _localctx.Value = Actions.CreatePrimitiveElementType(_localctx.signedNative.Value); } @@ -7610,7 +7728,7 @@ public ElementTypeContext elementType() { case 13: EnterOuterAlt(_localctx, 13); { - State = 1605; + State = 1696; _localctx.unsignedNative = nativeUint(); _localctx.Value = Actions.CreatePrimitiveElementType(_localctx.unsignedNative.Value); } @@ -7618,7 +7736,7 @@ public ElementTypeContext elementType() { case 14: EnterOuterAlt(_localctx, 14); { - State = 1608; + State = 1699; _localctx.primitive = simpleType(); _localctx.Value = Actions.CreatePrimitiveElementType(_localctx.primitive.Value); } @@ -7626,7 +7744,7 @@ public ElementTypeContext elementType() { case 15: EnterOuterAlt(_localctx, 15); { - State = 1611; + State = 1702; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateTypedefElementType(_localctx.Start, _localctx.alias.Value); } @@ -7634,9 +7752,9 @@ public ElementTypeContext elementType() { case 16: EnterOuterAlt(_localctx, 16); { - State = 1614; + State = 1705; Match(ELLIPSIS); - State = 1615; + State = 1706; _localctx.sentinelType = type(); _localctx.Value = Actions.CreateSentinelElementType(_localctx.sentinelType.Value); } @@ -7688,13 +7806,13 @@ public SimpleTypeContext simpleType() { SimpleTypeContext _localctx = new SimpleTypeContext(Context, State); EnterRule(_localctx, 144, RULE_simpleType); try { - State = 1658; + State = 1749; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,64,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1620; + State = 1711; _localctx.value = Match(CHAR); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7702,7 +7820,7 @@ public SimpleTypeContext simpleType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1622; + State = 1713; _localctx.value = Match(STRING); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7710,7 +7828,7 @@ public SimpleTypeContext simpleType() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1624; + State = 1715; _localctx.value = Match(BOOL); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7718,7 +7836,7 @@ public SimpleTypeContext simpleType() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1626; + State = 1717; _localctx.value = Match(INT8); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7726,7 +7844,7 @@ public SimpleTypeContext simpleType() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1628; + State = 1719; _localctx.value = Match(INT16); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7734,7 +7852,7 @@ public SimpleTypeContext simpleType() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1630; + State = 1721; _localctx.value = Match(INT32_); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7742,7 +7860,7 @@ public SimpleTypeContext simpleType() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1632; + State = 1723; _localctx.value = Match(INT64_); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7750,7 +7868,7 @@ public SimpleTypeContext simpleType() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1634; + State = 1725; _localctx.value = Match(FLOAT32); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7758,7 +7876,7 @@ public SimpleTypeContext simpleType() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1636; + State = 1727; _localctx.value = Match(FLOAT64_); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7766,7 +7884,7 @@ public SimpleTypeContext simpleType() { case 10: EnterOuterAlt(_localctx, 10); { - State = 1638; + State = 1729; _localctx.value = Match(UINT8); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7774,7 +7892,7 @@ public SimpleTypeContext simpleType() { case 11: EnterOuterAlt(_localctx, 11); { - State = 1640; + State = 1731; _localctx.value = Match(UINT16); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7782,7 +7900,7 @@ public SimpleTypeContext simpleType() { case 12: EnterOuterAlt(_localctx, 12); { - State = 1642; + State = 1733; _localctx.value = Match(UINT32); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7790,7 +7908,7 @@ public SimpleTypeContext simpleType() { case 13: EnterOuterAlt(_localctx, 13); { - State = 1644; + State = 1735; _localctx.value = Match(UINT64); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7798,9 +7916,9 @@ public SimpleTypeContext simpleType() { case 14: EnterOuterAlt(_localctx, 14); { - State = 1646; + State = 1737; Match(T__89); - State = 1647; + State = 1738; _localctx.value = Match(INT8); _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } @@ -7808,9 +7926,9 @@ public SimpleTypeContext simpleType() { case 15: EnterOuterAlt(_localctx, 15); { - State = 1649; + State = 1740; Match(T__89); - State = 1650; + State = 1741; _localctx.value = Match(INT16); _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } @@ -7818,9 +7936,9 @@ public SimpleTypeContext simpleType() { case 16: EnterOuterAlt(_localctx, 16); { - State = 1652; + State = 1743; Match(T__89); - State = 1653; + State = 1744; _localctx.value = Match(INT32_); _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } @@ -7828,9 +7946,9 @@ public SimpleTypeContext simpleType() { case 17: EnterOuterAlt(_localctx, 17); { - State = 1655; + State = 1746; Match(T__89); - State = 1656; + State = 1747; _localctx.value = Match(INT64_); _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } @@ -7882,7 +8000,7 @@ public BoundContext bound() { EnterRule(_localctx, 146, RULE_bound); Actions.InitializeBound(_localctx); try { - State = 1674; + State = 1765; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,65,Context) ) { case 1: @@ -7893,14 +8011,14 @@ public BoundContext bound() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1661; + State = 1752; Match(ELLIPSIS); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1662; + State = 1753; _localctx.size = int32(); Actions.SetBoundSize(_localctx, (_localctx.size!=null?(_localctx.size.Start):null)); } @@ -7908,11 +8026,11 @@ public BoundContext bound() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1665; + State = 1756; _localctx.lower = int32(); - State = 1666; + State = 1757; Match(ELLIPSIS); - State = 1667; + State = 1758; _localctx.upper = int32(); Actions.SetBoundRange(_localctx, (_localctx.lower!=null?(_localctx.lower.Start):null), (_localctx.upper!=null?(_localctx.upper.Start):null)); } @@ -7920,9 +8038,9 @@ public BoundContext bound() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1670; + State = 1761; _localctx.lower = int32(); - State = 1671; + State = 1762; Match(ELLIPSIS); Actions.SetBoundLower(_localctx, (_localctx.lower!=null?(_localctx.lower.Start):null)); } @@ -7963,9 +8081,9 @@ public NativeIntContext nativeInt() { try { EnterOuterAlt(_localctx, 1); { - State = 1676; + State = 1767; Match(T__0); - State = 1677; + State = 1768; Match(INT); _localctx.Value = Actions.GetNativeIntType(); } @@ -8005,22 +8123,22 @@ public NativeUintContext nativeUint() { try { EnterOuterAlt(_localctx, 1); { - State = 1680; + State = 1771; Match(T__0); - State = 1684; + State = 1775; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__89: { - State = 1681; + State = 1772; Match(T__89); - State = 1682; + State = 1773; Match(INT); } break; case UINT: { - State = 1683; + State = 1774; Match(UINT); } break; @@ -8086,125 +8204,125 @@ public SecDeclContext secDecl() { BeginSubtree(); Actions.BeginSemanticRoot(_localctx); int _la; try { - State = 1735; + State = 1826; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,68,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1688; + State = 1779; Match(PERMISSION); - State = 1689; + State = 1780; secAction(); - State = 1690; + State = 1781; typeSpec(); - State = 1691; + State = 1782; Match(T__29); - State = 1692; + State = 1783; nameValPairs(); - State = 1693; + State = 1784; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1695; + State = 1786; Match(PERMISSION); - State = 1696; + State = 1787; secAction(); - State = 1697; + State = 1788; typeSpec(); - State = 1698; + State = 1789; Match(T__35); - State = 1699; + State = 1790; Match(T__16); - State = 1700; + State = 1791; customBlobDescr(); - State = 1701; + State = 1792; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1703; + State = 1794; Match(PERMISSION); - State = 1704; + State = 1795; secAction(); - State = 1705; + State = 1796; typeSpec(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1707; + State = 1798; Match(PERMISSIONSET); - State = 1708; + State = 1799; secAction(); - State = 1709; + State = 1800; Match(T__35); - State = 1711; + State = 1802; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__83) { { - State = 1710; + State = 1801; Match(T__83); } } - State = 1713; + State = 1804; Match(T__29); - State = 1714; + State = 1805; bytes(); - State = 1715; + State = 1806; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1717; + State = 1808; Match(PERMISSIONSET); - State = 1718; + State = 1809; secAction(); - State = 1719; + State = 1810; Match(T__83); - State = 1720; + State = 1811; Match(T__29); - State = 1721; + State = 1812; bytes(); - State = 1722; + State = 1813; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1724; + State = 1815; Match(PERMISSIONSET); - State = 1725; + State = 1816; secAction(); - State = 1726; + State = 1817; compQstring(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1728; + State = 1819; Match(PERMISSIONSET); - State = 1729; + State = 1820; secAction(); - State = 1730; + State = 1821; Match(T__35); - State = 1731; + State = 1822; Match(T__16); - State = 1732; + State = 1823; secAttrSetBlob(); - State = 1733; + State = 1824; Match(T__17); } break; @@ -8248,7 +8366,7 @@ public SecAttrSetBlobContext secAttrSetBlob() { EnterRule(_localctx, 154, RULE_secAttrSetBlob); try { int _alt; - State = 1747; + State = 1838; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__17: @@ -8293,25 +8411,25 @@ public SecAttrSetBlobContext secAttrSetBlob() { case ID: EnterOuterAlt(_localctx, 2); { - State = 1743; + State = 1834; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,69,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1738; + State = 1829; secAttrBlob(); - State = 1739; + State = 1830; Match(T__27); } } } - State = 1745; + State = 1836; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,69,Context); } - State = 1746; + State = 1837; secAttrBlob(); } break; @@ -8356,38 +8474,38 @@ public SecAttrBlobContext secAttrBlob() { SecAttrBlobContext _localctx = new SecAttrBlobContext(Context, State); EnterRule(_localctx, 156, RULE_secAttrBlob); try { - State = 1762; + State = 1853; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,71,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1749; + State = 1840; Match(T__38); - State = 1750; + State = 1841; Match(SQSTRING); - State = 1751; + State = 1842; Match(T__35); - State = 1752; + State = 1843; Match(T__16); - State = 1753; + State = 1844; customBlobNVPairs(); - State = 1754; + State = 1845; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1756; + State = 1847; typeSpec(); - State = 1757; + State = 1848; Match(T__35); - State = 1758; + State = 1849; Match(T__16); - State = 1759; + State = 1850; customBlobNVPairs(); - State = 1760; + State = 1851; Match(T__17); } break; @@ -8432,25 +8550,25 @@ public NameValPairsContext nameValPairs() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1769; + State = 1860; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,72,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1764; + State = 1855; nameValPair(); - State = 1765; + State = 1856; Match(T__27); } } } - State = 1771; + State = 1862; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,72,Context); } - State = 1772; + State = 1863; nameValPair(); } } @@ -8492,11 +8610,11 @@ public NameValPairContext nameValPair() { try { EnterOuterAlt(_localctx, 1); { - State = 1774; + State = 1865; compQstring(); - State = 1775; + State = 1866; Match(T__35); - State = 1776; + State = 1867; caValue(); } } @@ -8533,7 +8651,7 @@ public TruefalseContext truefalse() { try { EnterOuterAlt(_localctx, 1); { - State = 1778; + State = 1869; _la = TokenStream.LA(1); if ( !(_la==T__94 || _la==T__95) ) { ErrorHandler.RecoverInline(this); @@ -8589,104 +8707,104 @@ public CaValueContext caValue() { CaValueContext _localctx = new CaValueContext(Context, State); EnterRule(_localctx, 164, RULE_caValue); try { - State = 1814; + State = 1905; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,73,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1780; + State = 1871; truefalse(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1781; + State = 1872; int32(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1782; + State = 1873; Match(INT32_); - State = 1783; + State = 1874; Match(T__29); - State = 1784; + State = 1875; int32(); - State = 1785; + State = 1876; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1787; + State = 1878; compQstring(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1788; + State = 1879; className(); - State = 1789; + State = 1880; Match(T__29); - State = 1790; + State = 1881; Match(INT8); - State = 1791; + State = 1882; Match(T__74); - State = 1792; + State = 1883; int32(); - State = 1793; + State = 1884; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1795; + State = 1886; className(); - State = 1796; + State = 1887; Match(T__29); - State = 1797; + State = 1888; Match(INT16); - State = 1798; + State = 1889; Match(T__74); - State = 1799; + State = 1890; int32(); - State = 1800; + State = 1891; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1802; + State = 1893; className(); - State = 1803; + State = 1894; Match(T__29); - State = 1804; + State = 1895; Match(INT32_); - State = 1805; + State = 1896; Match(T__74); - State = 1806; + State = 1897; int32(); - State = 1807; + State = 1898; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1809; + State = 1900; className(); - State = 1810; + State = 1901; Match(T__29); - State = 1811; + State = 1902; int32(); - State = 1812; + State = 1903; Match(T__30); } break; @@ -8725,7 +8843,7 @@ public SecActionContext secAction() { try { EnterOuterAlt(_localctx, 1); { - State = 1816; + State = 1907; _la = TokenStream.LA(1); if ( !(((((_la - 97)) & ~0x3f) == 0 && ((1L << (_la - 97)) & 32767L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -8807,33 +8925,33 @@ public MethodRefContext methodRef() { Actions.BeginSemanticRoot(_localctx); int _la; try { - State = 1860; + State = 1951; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,76,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1818; + State = 1909; _localctx.convention = callConv(); - State = 1819; + State = 1910; _localctx.returnType = type(); - State = 1820; + State = 1911; _localctx.owner = typeSpec(); - State = 1821; + State = 1912; Match(DCOLON); - State = 1822; + State = 1913; _localctx.name = methodName(); - State = 1824; + State = 1915; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 1823; + State = 1914; _localctx.genericArguments = typeArgs(); } } - State = 1826; + State = 1917; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, _localctx.owner.Value, _localctx.name.Value, _localctx.genericArguments, null, _localctx.arguments.Value); } @@ -8841,19 +8959,19 @@ public MethodRefContext methodRef() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1829; + State = 1920; _localctx.convention = callConv(); - State = 1830; + State = 1921; _localctx.returnType = type(); - State = 1831; + State = 1922; _localctx.owner = typeSpec(); - State = 1832; + State = 1923; Match(DCOLON); - State = 1833; + State = 1924; _localctx.name = methodName(); - State = 1834; + State = 1925; _localctx.genericArity = genArityNotEmpty(); - State = 1835; + State = 1926; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, _localctx.owner.Value, _localctx.name.Value, null, _localctx.genericArity.Value, _localctx.arguments.Value); } @@ -8861,23 +8979,23 @@ public MethodRefContext methodRef() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1838; + State = 1929; _localctx.convention = callConv(); - State = 1839; + State = 1930; _localctx.returnType = type(); - State = 1840; + State = 1931; _localctx.name = methodName(); - State = 1842; + State = 1933; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 1841; + State = 1932; _localctx.genericArguments = typeArgs(); } } - State = 1844; + State = 1935; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, null, _localctx.name.Value, _localctx.genericArguments, null, _localctx.arguments.Value); } @@ -8885,15 +9003,15 @@ public MethodRefContext methodRef() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1847; + State = 1938; _localctx.convention = callConv(); - State = 1848; + State = 1939; _localctx.returnType = type(); - State = 1849; + State = 1940; _localctx.name = methodName(); - State = 1850; + State = 1941; _localctx.genericArity = genArityNotEmpty(); - State = 1851; + State = 1942; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, null, _localctx.name.Value, null, _localctx.genericArity.Value, _localctx.arguments.Value); } @@ -8901,7 +9019,7 @@ public MethodRefContext methodRef() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1854; + State = 1945; _localctx.token = mdtoken(); _localctx.Value = Actions.CreateTokenMethodReference(_localctx.token.Value); } @@ -8909,7 +9027,7 @@ public MethodRefContext methodRef() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1857; + State = 1948; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateTypedefMethodReference(_localctx.Start, _localctx.alias.Value); } @@ -8962,15 +9080,15 @@ public CallConvContext callConv() { CallConvContext _localctx = new CallConvContext(Context, State); EnterRule(_localctx, 170, RULE_callConv); try { - State = 1879; + State = 1970; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,77,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1862; + State = 1953; Match(INSTANCE); - State = 1863; + State = 1954; _localctx.inner = callConv(); _localctx.Value = Actions.AddInstanceCallingConvention(_localctx.inner.Value); } @@ -8978,9 +9096,9 @@ public CallConvContext callConv() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1866; + State = 1957; Match(EXPLICIT); - State = 1867; + State = 1958; _localctx.inner = callConv(); _localctx.Value = Actions.AddExplicitCallingConvention(_localctx.inner.Value); } @@ -8988,7 +9106,7 @@ public CallConvContext callConv() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1870; + State = 1961; _localctx.kind = callKind(); _localctx.Value = _localctx.kind.Value; } @@ -8996,13 +9114,13 @@ public CallConvContext callConv() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1873; + State = 1964; Match(T__111); - State = 1874; + State = 1965; Match(T__29); - State = 1875; + State = 1966; _localctx.raw = int32(); - State = 1876; + State = 1967; Match(T__30); _localctx.Value = Actions.GetRawCallingConvention((_localctx.raw!=null?(_localctx.raw.Start):null)); } @@ -9049,7 +9167,7 @@ public CallKindContext callKind() { EnterRule(_localctx, 172, RULE_callKind); _localctx.Value = Actions.GetDefaultCallingConvention(); try { - State = 1900; + State = 1991; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,78,Context) ) { case 1: @@ -9060,7 +9178,7 @@ public CallKindContext callKind() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1882; + State = 1973; _localctx.kind = Match(DEFAULT); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9068,7 +9186,7 @@ public CallKindContext callKind() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1884; + State = 1975; _localctx.kind = Match(VARARG); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9076,9 +9194,9 @@ public CallKindContext callKind() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1886; + State = 1977; Match(UNMANAGED); - State = 1887; + State = 1978; _localctx.kind = Match(CDECL); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9086,9 +9204,9 @@ public CallKindContext callKind() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1889; + State = 1980; Match(UNMANAGED); - State = 1890; + State = 1981; _localctx.kind = Match(STDCALL); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9096,9 +9214,9 @@ public CallKindContext callKind() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1892; + State = 1983; Match(UNMANAGED); - State = 1893; + State = 1984; _localctx.kind = Match(THISCALL); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9106,9 +9224,9 @@ public CallKindContext callKind() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1895; + State = 1986; Match(UNMANAGED); - State = 1896; + State = 1987; _localctx.kind = Match(FASTCALL); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9116,7 +9234,7 @@ public CallKindContext callKind() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1898; + State = 1989; _localctx.kind = Match(UNMANAGED); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9162,13 +9280,13 @@ public MdtokenContext mdtoken() { try { EnterOuterAlt(_localctx, 1); { - State = 1902; + State = 1993; Match(T__112); - State = 1903; + State = 1994; Match(T__29); - State = 1904; + State = 1995; _localctx.token = int32(); - State = 1905; + State = 1996; Match(T__30); _localctx.Value = Actions.ParseInt32((_localctx.token!=null?(_localctx.token.Start):null)); } @@ -9218,15 +9336,15 @@ public MemberRefContext memberRef() { MemberRefContext _localctx = new MemberRefContext(Context, State); EnterRule(_localctx, 176, RULE_memberRef); try { - State = 1919; + State = 2010; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case METHOD: EnterOuterAlt(_localctx, 1); { - State = 1908; + State = 1999; Match(METHOD); - State = 1909; + State = 2000; _localctx.method = methodRef(); _localctx.Value = Actions.CreateMethodMemberReference(_localctx.method.Value); } @@ -9234,9 +9352,9 @@ public MemberRefContext memberRef() { case T__36: EnterOuterAlt(_localctx, 2); { - State = 1912; + State = 2003; Match(T__36); - State = 1913; + State = 2004; _localctx.field = fieldRef(); _localctx.Value = Actions.CreateFieldMemberReference(_localctx.field.Value); } @@ -9244,7 +9362,7 @@ public MemberRefContext memberRef() { case T__112: EnterOuterAlt(_localctx, 3); { - State = 1916; + State = 2007; _localctx.token = mdtoken(); _localctx.Value = Actions.CreateTokenMemberReference(_localctx.token.Value); } @@ -9300,19 +9418,19 @@ public FieldRefContext fieldRef() { EnterRule(_localctx, 178, RULE_fieldRef); Actions.BeginSemanticRoot(_localctx); try { - State = 1934; + State = 2025; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,80,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1921; + State = 2012; _localctx.fieldType = type(); - State = 1922; + State = 2013; _localctx.owner = typeSpec(); - State = 1923; + State = 2014; Match(DCOLON); - State = 1924; + State = 2015; _localctx.name = dottedName(); _localctx.Value = Actions.CreateFieldReference(_localctx.fieldType.Value, _localctx.owner.Value, _localctx.name.Value); } @@ -9320,9 +9438,9 @@ public FieldRefContext fieldRef() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1927; + State = 2018; _localctx.fieldType = type(); - State = 1928; + State = 2019; _localctx.name = dottedName(); _localctx.Value = Actions.CreateFieldReference(_localctx.fieldType.Value, null, _localctx.name.Value); } @@ -9330,7 +9448,7 @@ public FieldRefContext fieldRef() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1931; + State = 2022; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateTypedefFieldReference(_localctx.Start, _localctx.alias.Value); } @@ -9381,26 +9499,26 @@ public TypeListContext typeList() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1942; + State = 2033; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,81,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1936; + State = 2027; _localctx.item = typeSpec(); Actions.AddGenericType(_localctx, _localctx.item.Value); - State = 1938; + State = 2029; Match(T__27); } } } - State = 1944; + State = 2035; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,81,Context); } - State = 1945; + State = 2036; _localctx.tail = typeSpec(); Actions.AddGenericType(_localctx, _localctx.tail.Value); } @@ -9442,7 +9560,7 @@ public TyparsClauseContext typarsClause() { EnterRule(_localctx, 182, RULE_typarsClause); _localctx.Value = Actions.CreateEmptyGenericParameterList(); try { - State = 1954; + State = 2045; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -9457,11 +9575,11 @@ public TyparsClauseContext typarsClause() { case T__85: EnterOuterAlt(_localctx, 2); { - State = 1949; + State = 2040; Match(T__85); - State = 1950; + State = 2041; _localctx.parameters = typars(); - State = 1951; + State = 2042; Match(T__86); _localctx.Value = _localctx.parameters.Value; } @@ -9513,13 +9631,13 @@ public TyparAttribContext typarAttrib() { TyparAttribContext _localctx = new TyparAttribContext(Context, State); EnterRule(_localctx, 184, RULE_typarAttrib); try { - State = 1974; + State = 2065; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case PLUS: EnterOuterAlt(_localctx, 1); { - State = 1956; + State = 2047; _localctx.covariant = Match(PLUS); _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.covariant); } @@ -9527,7 +9645,7 @@ public TyparAttribContext typarAttrib() { case T__113: EnterOuterAlt(_localctx, 2); { - State = 1958; + State = 2049; _localctx.contravariant = Match(T__113); _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.contravariant); } @@ -9535,7 +9653,7 @@ public TyparAttribContext typarAttrib() { case T__38: EnterOuterAlt(_localctx, 3); { - State = 1960; + State = 2051; _localctx.@class = Match(T__38); _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.@class); } @@ -9543,7 +9661,7 @@ public TyparAttribContext typarAttrib() { case VALUETYPE: EnterOuterAlt(_localctx, 4); { - State = 1962; + State = 2053; _localctx.valuetype = Match(VALUETYPE); _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.valuetype); } @@ -9551,7 +9669,7 @@ public TyparAttribContext typarAttrib() { case T__114: EnterOuterAlt(_localctx, 5); { - State = 1964; + State = 2055; _localctx.byrefLike = Match(T__114); _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.byrefLike); } @@ -9559,7 +9677,7 @@ public TyparAttribContext typarAttrib() { case T__115: EnterOuterAlt(_localctx, 6); { - State = 1966; + State = 2057; _localctx.ctor = Match(T__115); _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.ctor); } @@ -9567,13 +9685,13 @@ public TyparAttribContext typarAttrib() { case T__69: EnterOuterAlt(_localctx, 7); { - State = 1968; + State = 2059; Match(T__69); - State = 1969; + State = 2060; Match(T__29); - State = 1970; + State = 2061; _localctx.flags = int32(); - State = 1971; + State = 2062; Match(T__30); _localctx.Value = Actions.CreateRawGenericParameterAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } @@ -9624,18 +9742,18 @@ public TyparAttribsContext typarAttribs() { try { EnterOuterAlt(_localctx, 1); { - State = 1981; + State = 2072; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__38 || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & 123145302310913L) != 0) || _la==VALUETYPE || _la==PLUS) { { { - State = 1976; + State = 2067; _localctx.attribute = typarAttrib(); Actions.AddGenericParameterAttribute(_localctx, _localctx.attribute.Value); } } - State = 1983; + State = 2074; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -9688,19 +9806,19 @@ public TyparContext typar() { try { EnterOuterAlt(_localctx, 1); { - State = 1984; + State = 2075; _localctx.attributes = typarAttribs(); - State = 1986; + State = 2077; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__29) { { - State = 1985; + State = 2076; _localctx.constraints = tyBound(); } } - State = 1988; + State = 2079; _localctx.name = dottedName(); _localctx.Value = Actions.CreateGenericParameterDeclaration(_localctx.attributes.Value, _localctx.constraints, _localctx.name.Value); } @@ -9748,26 +9866,26 @@ public TyparsContext typars() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1997; + State = 2088; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,86,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1991; + State = 2082; _localctx.parameter = typar(); Actions.AddGenericParameter(_localctx, _localctx.parameter.Value); - State = 1993; + State = 2084; Match(T__27); } } } - State = 1999; + State = 2090; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,86,Context); } - State = 2000; + State = 2091; _localctx.tail = typar(); Actions.AddGenericParameter(_localctx, _localctx.tail.Value); } @@ -9810,11 +9928,11 @@ public TyBoundContext tyBound() { try { EnterOuterAlt(_localctx, 1); { - State = 2003; + State = 2094; Match(T__29); - State = 2004; + State = 2095; _localctx.constraints = typeList(); - State = 2005; + State = 2096; Match(T__30); _localctx.Value = _localctx.constraints.Value; } @@ -9857,12 +9975,12 @@ public GenArityContext genArity() { try { EnterOuterAlt(_localctx, 1); { - State = 2009; + State = 2100; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 2008; + State = 2099; _localctx.value = genArityNotEmpty(); } } @@ -9907,15 +10025,15 @@ public GenArityNotEmptyContext genArityNotEmpty() { try { EnterOuterAlt(_localctx, 1); { - State = 2013; + State = 2104; Match(T__85); - State = 2014; + State = 2105; Match(T__41); - State = 2015; + State = 2106; _localctx.value = int32(); - State = 2016; + State = 2107; Match(T__42); - State = 2017; + State = 2108; Match(T__86); _localctx.Value = Actions.ParseInt32((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -10091,74 +10209,74 @@ public ClassDeclContext classDecl() { BeginStreaming(); try { int _alt; - State = 2170; + State = 2261; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,92,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2020; + State = 2111; methodHead(); - State = 2021; + State = 2112; Match(T__16); - State = 2022; + State = 2113; methodDecls(); - State = 2023; + State = 2114; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2025; + State = 2116; classHead(); - State = 2026; + State = 2117; Match(T__16); - State = 2027; + State = 2118; classDecls(); - State = 2028; + State = 2119; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2030; + State = 2121; _localctx.eventHeader = eventHead(); Actions.BeginEvent(_localctx, _localctx.eventHeader.Value); - State = 2032; + State = 2123; Match(T__16); - State = 2033; + State = 2124; eventDecls(); - State = 2034; + State = 2125; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2036; + State = 2127; _localctx.property = propHead(); Actions.BeginProperty(_localctx, _localctx.property.Value); - State = 2038; + State = 2129; Match(T__16); - State = 2039; + State = 2130; propDecls(); - State = 2040; + State = 2131; Match(T__17); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2042; + State = 2133; fieldDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2043; + State = 2134; _localctx.data = dataDecl(); Actions.ProcessClassDataDeclaration(_localctx.data); } @@ -10166,7 +10284,7 @@ public ClassDeclContext classDecl() { case 7: EnterOuterAlt(_localctx, 7); { - State = 2046; + State = 2137; _localctx.security = secDecl(); Actions.ProcessClassSecurityDeclaration(_localctx.security); } @@ -10174,7 +10292,7 @@ public ClassDeclContext classDecl() { case 8: EnterOuterAlt(_localctx, 8); { - State = 2049; + State = 2140; _localctx.source = extSourceSpec(); Actions.ProcessClassSourceDirective(_localctx.source); } @@ -10182,7 +10300,7 @@ public ClassDeclContext classDecl() { case 9: EnterOuterAlt(_localctx, 9); { - State = 2052; + State = 2143; _localctx.attribute = customAttrDecl(); Actions.ProcessClassCustomAttribute(_localctx.attribute); } @@ -10190,9 +10308,9 @@ public ClassDeclContext classDecl() { case 10: EnterOuterAlt(_localctx, 10); { - State = 2055; + State = 2146; Match(T__116); - State = 2056; + State = 2147; _localctx.size = int32(); Actions.SetClassSize((_localctx.size!=null?(_localctx.size.Start):null)); } @@ -10200,9 +10318,9 @@ public ClassDeclContext classDecl() { case 11: EnterOuterAlt(_localctx, 11); { - State = 2059; + State = 2150; Match(T__117); - State = 2060; + State = 2151; _localctx.packing = int32(); Actions.SetClassPackingSize((_localctx.packing!=null?(_localctx.packing.Start):null)); } @@ -10210,13 +10328,13 @@ public ClassDeclContext classDecl() { case 12: EnterOuterAlt(_localctx, 12); { - State = 2063; + State = 2154; _localctx.export = exportHead(); - State = 2064; + State = 2155; Match(T__16); - State = 2065; + State = 2156; _localctx.exportDeclarations = exptypeDecls(); - State = 2066; + State = 2157; Match(T__17); Actions.ProcessClassExport(_localctx.export, _localctx.exportDeclarations); } @@ -10224,27 +10342,27 @@ public ClassDeclContext classDecl() { case 13: EnterOuterAlt(_localctx, 13); { - State = 2069; + State = 2160; Match(OVERRIDE); - State = 2070; + State = 2161; _localctx.declarationOwner = typeSpec(); - State = 2071; + State = 2162; Match(DCOLON); - State = 2072; + State = 2163; _localctx.declarationName = methodName(); - State = 2073; + State = 2164; Match(T__118); - State = 2074; + State = 2165; _localctx.bodyConvention = callConv(); - State = 2075; + State = 2166; _localctx.bodyReturnType = type(); - State = 2076; + State = 2167; _localctx.bodyOwner = typeSpec(); - State = 2077; + State = 2168; Match(DCOLON); - State = 2078; + State = 2169; _localctx.bodyName = methodName(); - State = 2079; + State = 2170; _localctx.bodyArguments = sigArgs(); Actions.AddClassMethodOverride( _localctx, @@ -10260,41 +10378,41 @@ public ClassDeclContext classDecl() { case 14: EnterOuterAlt(_localctx, 14); { - State = 2082; + State = 2173; Match(OVERRIDE); - State = 2083; + State = 2174; Match(METHOD); - State = 2084; + State = 2175; _localctx.declarationConvention = callConv(); - State = 2085; + State = 2176; _localctx.declarationReturnType = type(); - State = 2086; + State = 2177; _localctx.declarationOwner = typeSpec(); - State = 2087; + State = 2178; Match(DCOLON); - State = 2088; + State = 2179; _localctx.declarationName = methodName(); - State = 2089; + State = 2180; _localctx.declarationArity = genArity(); - State = 2090; + State = 2181; _localctx.declarationArguments = sigArgs(); - State = 2091; + State = 2182; Match(T__118); - State = 2092; + State = 2183; Match(METHOD); - State = 2093; + State = 2184; _localctx.bodyConvention = callConv(); - State = 2094; + State = 2185; _localctx.bodyReturnType = type(); - State = 2095; + State = 2186; _localctx.bodyOwner = typeSpec(); - State = 2096; + State = 2187; Match(DCOLON); - State = 2097; + State = 2188; _localctx.bodyName = methodName(); - State = 2098; + State = 2189; _localctx.bodyArity = genArity(); - State = 2099; + State = 2190; _localctx.bodyArguments = sigArgs(); Actions.AddClassMethodOverride( _localctx, @@ -10315,7 +10433,7 @@ public ClassDeclContext classDecl() { case 15: EnterOuterAlt(_localctx, 15); { - State = 2102; + State = 2193; _localctx.language = languageDecl(); Actions.ProcessClassLanguageDirective(_localctx.language); } @@ -10323,7 +10441,7 @@ public ClassDeclContext classDecl() { case 16: EnterOuterAlt(_localctx, 16); { - State = 2105; + State = 2196; compControl(); Actions.ProcessClassCompilerControl(); } @@ -10331,31 +10449,31 @@ public ClassDeclContext classDecl() { case 17: EnterOuterAlt(_localctx, 17); { - State = 2108; + State = 2199; Match(PARAM); - State = 2109; + State = 2200; Match(TYPE); - State = 2110; + State = 2201; Match(T__41); - State = 2111; + State = 2202; _localctx.parameterIndex = int32(); - State = 2112; + State = 2203; Match(T__42); Actions.BeginClassGenericParameterDirective(_localctx, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null)); - State = 2119; + State = 2210; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2114; + State = 2205; _localctx.attribute = customAttrDecl(); Actions.AddClassGenericDirectiveAttribute(_localctx, _localctx.attribute); } } } - State = 2121; + State = 2212; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); } @@ -10364,27 +10482,27 @@ public ClassDeclContext classDecl() { case 18: EnterOuterAlt(_localctx, 18); { - State = 2122; + State = 2213; Match(PARAM); - State = 2123; + State = 2214; Match(TYPE); - State = 2124; + State = 2215; _localctx.parameterName = dottedName(); Actions.BeginClassGenericParameterDirective(_localctx, _localctx.parameterName.Value); - State = 2131; + State = 2222; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2126; + State = 2217; _localctx.attribute = customAttrDecl(); Actions.AddClassGenericDirectiveAttribute(_localctx, _localctx.attribute); } } } - State = 2133; + State = 2224; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); } @@ -10393,35 +10511,35 @@ public ClassDeclContext classDecl() { case 19: EnterOuterAlt(_localctx, 19); { - State = 2134; + State = 2225; Match(PARAM); - State = 2135; + State = 2226; Match(CONSTRAINT); - State = 2136; + State = 2227; Match(T__41); - State = 2137; + State = 2228; _localctx.parameterIndex = int32(); - State = 2138; + State = 2229; Match(T__42); - State = 2139; + State = 2230; Match(T__27); - State = 2140; + State = 2231; _localctx.constraintType = typeSpec(); Actions.BeginClassGenericConstraintDirective(_localctx, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null), _localctx.constraintType.Value); - State = 2147; + State = 2238; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2142; + State = 2233; _localctx.attribute = customAttrDecl(); Actions.AddClassGenericDirectiveAttribute(_localctx, _localctx.attribute); } } } - State = 2149; + State = 2240; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); } @@ -10430,31 +10548,31 @@ public ClassDeclContext classDecl() { case 20: EnterOuterAlt(_localctx, 20); { - State = 2150; + State = 2241; Match(PARAM); - State = 2151; + State = 2242; Match(CONSTRAINT); - State = 2152; + State = 2243; _localctx.parameterName = dottedName(); - State = 2153; + State = 2244; Match(T__27); - State = 2154; + State = 2245; _localctx.constraintType = typeSpec(); Actions.BeginClassGenericConstraintDirective(_localctx, _localctx.parameterName.Value, _localctx.constraintType.Value); - State = 2161; + State = 2252; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2156; + State = 2247; _localctx.attribute = customAttrDecl(); Actions.AddClassGenericDirectiveAttribute(_localctx, _localctx.attribute); } } } - State = 2163; + State = 2254; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); } @@ -10463,13 +10581,13 @@ public ClassDeclContext classDecl() { case 21: EnterOuterAlt(_localctx, 21); { - State = 2164; + State = 2255; Match(T__119); - State = 2165; + State = 2256; Match(TYPE); - State = 2166; + State = 2257; _localctx.interfaceType = typeSpec(); - State = 2167; + State = 2258; _localctx.interfaceAttribute = customDescr(); Actions.AddInterfaceImplementationAttribute(_localctx, _localctx.interfaceType.Value, _localctx.interfaceAttribute); } @@ -10546,17 +10664,17 @@ public FieldDeclContext fieldDecl() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 2172; + State = 2263; Match(T__120); - State = 2173; + State = 2264; _localctx.offset = repeatOpt(); - State = 2185; + State = 2276; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,94,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { - State = 2183; + State = 2274; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -10575,20 +10693,20 @@ public FieldDeclContext fieldDecl() { case T__125: case T__126: { - State = 2174; + State = 2265; _localctx.attribute = fieldAttr(); Actions.AddFieldAttribute(_localctx, _localctx.attribute.Value); } break; case T__121: { - State = 2177; + State = 2268; Match(T__121); - State = 2178; + State = 2269; Match(T__29); - State = 2179; + State = 2270; _localctx.marshalling = marshalBlob(); - State = 2180; + State = 2271; Match(T__30); Actions.SetFieldMarshalling(_localctx, _localctx.marshalling.Value); } @@ -10598,17 +10716,17 @@ public FieldDeclContext fieldDecl() { } } } - State = 2187; + State = 2278; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,94,Context); } - State = 2188; + State = 2279; _localctx.fieldType = type(); - State = 2189; + State = 2280; _localctx.name = dottedName(); - State = 2190; + State = 2281; _localctx.data = atOpt(); - State = 2191; + State = 2282; _localctx.initializer = initOpt(); _localctx.Value = Actions.CreateFieldDeclaration( _localctx, @@ -10658,13 +10776,13 @@ public FieldAttrContext fieldAttr() { FieldAttrContext _localctx = new FieldAttrContext(Context, State); EnterRule(_localctx, 202, RULE_fieldAttr); try { - State = 2228; + State = 2319; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__122: EnterOuterAlt(_localctx, 1); { - State = 2194; + State = 2285; _localctx.attribute = Match(T__122); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10672,7 +10790,7 @@ public FieldAttrContext fieldAttr() { case T__50: EnterOuterAlt(_localctx, 2); { - State = 2196; + State = 2287; _localctx.attribute = Match(T__50); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10680,7 +10798,7 @@ public FieldAttrContext fieldAttr() { case T__51: EnterOuterAlt(_localctx, 3); { - State = 2198; + State = 2289; _localctx.attribute = Match(T__51); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10688,7 +10806,7 @@ public FieldAttrContext fieldAttr() { case T__62: EnterOuterAlt(_localctx, 4); { - State = 2200; + State = 2291; _localctx.attribute = Match(T__62); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10696,7 +10814,7 @@ public FieldAttrContext fieldAttr() { case T__123: EnterOuterAlt(_localctx, 5); { - State = 2202; + State = 2293; _localctx.attribute = Match(T__123); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10704,7 +10822,7 @@ public FieldAttrContext fieldAttr() { case T__68: EnterOuterAlt(_localctx, 6); { - State = 2204; + State = 2295; _localctx.attribute = Match(T__68); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10712,7 +10830,7 @@ public FieldAttrContext fieldAttr() { case T__67: EnterOuterAlt(_localctx, 7); { - State = 2206; + State = 2297; _localctx.attribute = Match(T__67); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10720,7 +10838,7 @@ public FieldAttrContext fieldAttr() { case T__63: EnterOuterAlt(_localctx, 8); { - State = 2208; + State = 2299; _localctx.attribute = Match(T__63); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10728,7 +10846,7 @@ public FieldAttrContext fieldAttr() { case T__64: EnterOuterAlt(_localctx, 9); { - State = 2210; + State = 2301; _localctx.attribute = Match(T__64); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10736,7 +10854,7 @@ public FieldAttrContext fieldAttr() { case T__65: EnterOuterAlt(_localctx, 10); { - State = 2212; + State = 2303; _localctx.attribute = Match(T__65); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10744,7 +10862,7 @@ public FieldAttrContext fieldAttr() { case T__124: EnterOuterAlt(_localctx, 11); { - State = 2214; + State = 2305; _localctx.attribute = Match(T__124); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10752,7 +10870,7 @@ public FieldAttrContext fieldAttr() { case T__125: EnterOuterAlt(_localctx, 12); { - State = 2216; + State = 2307; _localctx.attribute = Match(T__125); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10760,7 +10878,7 @@ public FieldAttrContext fieldAttr() { case T__126: EnterOuterAlt(_localctx, 13); { - State = 2218; + State = 2309; _localctx.attribute = Match(T__126); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10768,7 +10886,7 @@ public FieldAttrContext fieldAttr() { case T__15: EnterOuterAlt(_localctx, 14); { - State = 2220; + State = 2311; _localctx.attribute = Match(T__15); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10776,13 +10894,13 @@ public FieldAttrContext fieldAttr() { case T__69: EnterOuterAlt(_localctx, 15); { - State = 2222; + State = 2313; Match(T__69); - State = 2223; + State = 2314; Match(T__29); - State = 2224; + State = 2315; _localctx.flags = int32(); - State = 2225; + State = 2316; Match(T__30); _localctx.Value = Actions.CreateRawFieldAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } @@ -10830,7 +10948,7 @@ public AtOptContext atOpt() { AtOptContext _localctx = new AtOptContext(Context, State); EnterRule(_localctx, 204, RULE_atOpt); try { - State = 2239; + State = 2330; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,96,Context) ) { case 1: @@ -10841,9 +10959,9 @@ public AtOptContext atOpt() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2231; + State = 2322; Match(T__43); - State = 2232; + State = 2323; _localctx.name = id(); _localctx.Value = Actions.GetFieldDataName((_localctx.name!=null?(_localctx.name.Start):null)); } @@ -10851,9 +10969,9 @@ public AtOptContext atOpt() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2235; + State = 2326; Match(T__43); - State = 2236; + State = 2327; _localctx.offset = int32(); _localctx.Value = Actions.GetFieldDataOffset((_localctx.offset!=null?(_localctx.offset.Start):null)); } @@ -10897,7 +11015,7 @@ public InitOptContext initOpt() { EnterRule(_localctx, 206, RULE_initOpt); BeginSubtree(); Actions.BeginFieldInitializer(_localctx); try { - State = 2246; + State = 2337; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -10991,9 +11109,9 @@ public InitOptContext initOpt() { case T__35: EnterOuterAlt(_localctx, 2); { - State = 2242; + State = 2333; Match(T__35); - State = 2243; + State = 2334; _localctx.initializer = fieldInit(); Actions.SetFieldInitializer(_localctx, _localctx.initializer); } @@ -11039,7 +11157,7 @@ public RepeatOptContext repeatOpt() { RepeatOptContext _localctx = new RepeatOptContext(Context, State); EnterRule(_localctx, 208, RULE_repeatOpt); try { - State = 2254; + State = 2345; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -11094,11 +11212,11 @@ public RepeatOptContext repeatOpt() { case T__41: EnterOuterAlt(_localctx, 2); { - State = 2249; + State = 2340; Match(T__41); - State = 2250; + State = 2341; _localctx.offset = int32(); - State = 2251; + State = 2342; Match(T__42); Actions.SetFieldOffset(_localctx, (_localctx.offset!=null?(_localctx.offset.Start):null)); } @@ -11155,32 +11273,32 @@ public EventHeadContext eventHead() { Actions.BeginEventHeader(_localctx); int _la; try { - State = 2281; + State = 2372; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,101,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2256; + State = 2347; Match(T__127); - State = 2262; + State = 2353; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 2257; + State = 2348; _localctx.attribute = eventAttr(); Actions.AddEventAttribute(_localctx, _localctx.attribute.Value); } } - State = 2264; + State = 2355; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2265; + State = 2356; _localctx.eventType = typeSpec(); - State = 2266; + State = 2357; _localctx.name = dottedName(); _localctx.Value = Actions.CreateEventHeader(_localctx, _localctx.eventType.Value, _localctx.name.Value); } @@ -11188,24 +11306,24 @@ public EventHeadContext eventHead() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2269; + State = 2360; Match(T__127); - State = 2275; + State = 2366; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 2270; + State = 2361; _localctx.attribute = eventAttr(); Actions.AddEventAttribute(_localctx, _localctx.attribute.Value); } } - State = 2277; + State = 2368; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2278; + State = 2369; _localctx.name = dottedName(); _localctx.Value = Actions.CreateEventHeader(_localctx, null, _localctx.name.Value); } @@ -11245,13 +11363,13 @@ public EventAttrContext eventAttr() { EventAttrContext _localctx = new EventAttrContext(Context, State); EnterRule(_localctx, 212, RULE_eventAttr); try { - State = 2287; + State = 2378; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__68: EnterOuterAlt(_localctx, 1); { - State = 2283; + State = 2374; _localctx.attribute = Match(T__68); _localctx.Value = Actions.CreateEventAttribute(_localctx.attribute); } @@ -11259,7 +11377,7 @@ public EventAttrContext eventAttr() { case T__67: EnterOuterAlt(_localctx, 2); { - State = 2285; + State = 2376; _localctx.attribute = Match(T__67); _localctx.Value = Actions.CreateEventAttribute(_localctx.attribute); } @@ -11307,17 +11425,17 @@ public EventDeclsContext eventDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2292; + State = 2383; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38788988928L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 1080863910568919043L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 2289; + State = 2380; eventDecl(); } } - State = 2294; + State = 2385; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11372,15 +11490,15 @@ public EventDeclContext eventDecl() { EventDeclContext _localctx = new EventDeclContext(Context, State); EnterRule(_localctx, 216, RULE_eventDecl); try { - State = 2321; + State = 2412; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__128: EnterOuterAlt(_localctx, 1); { - State = 2295; + State = 2386; Match(T__128); - State = 2296; + State = 2387; _localctx.accessor = methodRef(); Actions.AddEventAdder(_localctx, _localctx.accessor.Value); } @@ -11388,9 +11506,9 @@ public EventDeclContext eventDecl() { case T__129: EnterOuterAlt(_localctx, 2); { - State = 2299; + State = 2390; Match(T__129); - State = 2300; + State = 2391; _localctx.accessor = methodRef(); Actions.AddEventRemover(_localctx, _localctx.accessor.Value); } @@ -11398,9 +11516,9 @@ public EventDeclContext eventDecl() { case T__130: EnterOuterAlt(_localctx, 3); { - State = 2303; + State = 2394; Match(T__130); - State = 2304; + State = 2395; _localctx.accessor = methodRef(); Actions.AddEventRaiser(_localctx, _localctx.accessor.Value); } @@ -11408,9 +11526,9 @@ public EventDeclContext eventDecl() { case T__131: EnterOuterAlt(_localctx, 4); { - State = 2307; + State = 2398; Match(T__131); - State = 2308; + State = 2399; _localctx.accessor = methodRef(); Actions.AddEventOther(_localctx, _localctx.accessor.Value); } @@ -11419,7 +11537,7 @@ public EventDeclContext eventDecl() { case T__73: EnterOuterAlt(_localctx, 5); { - State = 2311; + State = 2402; _localctx.source = extSourceSpec(); Actions.ProcessEventSourceDirective(_localctx.source); } @@ -11433,7 +11551,7 @@ public EventDeclContext eventDecl() { case ID: EnterOuterAlt(_localctx, 6); { - State = 2314; + State = 2405; _localctx.attribute = customAttrDecl(); Actions.AddEventCustomAttribute(_localctx, _localctx.attribute); } @@ -11441,7 +11559,7 @@ public EventDeclContext eventDecl() { case T__26: EnterOuterAlt(_localctx, 7); { - State = 2317; + State = 2408; _localctx.language = languageDecl(); Actions.ProcessEventLanguageDirective(_localctx.language); } @@ -11456,7 +11574,7 @@ public EventDeclContext eventDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 8); { - State = 2320; + State = 2411; compControl(); } break; @@ -11526,32 +11644,32 @@ public PropHeadContext propHead() { try { EnterOuterAlt(_localctx, 1); { - State = 2323; + State = 2414; Match(T__132); - State = 2329; + State = 2420; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 2324; + State = 2415; _localctx.attribute = propAttr(); Actions.AddPropertyAttribute(_localctx, _localctx.attribute.Value); } } - State = 2331; + State = 2422; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2332; + State = 2423; _localctx.convention = callConv(); - State = 2333; + State = 2424; _localctx.propertyType = type(); - State = 2334; + State = 2425; _localctx.name = dottedName(); - State = 2335; + State = 2426; _localctx.arguments = sigArgs(); - State = 2336; + State = 2427; _localctx.initializer = initOpt(); _localctx.Value = Actions.CreatePropertyHeader( _localctx, @@ -11595,13 +11713,13 @@ public PropAttrContext propAttr() { PropAttrContext _localctx = new PropAttrContext(Context, State); EnterRule(_localctx, 220, RULE_propAttr); try { - State = 2343; + State = 2434; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__68: EnterOuterAlt(_localctx, 1); { - State = 2339; + State = 2430; _localctx.attribute = Match(T__68); _localctx.Value = Actions.CreatePropertyAttribute(_localctx.attribute); } @@ -11609,7 +11727,7 @@ public PropAttrContext propAttr() { case T__67: EnterOuterAlt(_localctx, 2); { - State = 2341; + State = 2432; _localctx.attribute = Match(T__67); _localctx.Value = Actions.CreatePropertyAttribute(_localctx.attribute); } @@ -11657,17 +11775,17 @@ public PropDeclsContext propDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2348; + State = 2439; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38788988928L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 7493989779944505347L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 2345; + State = 2436; propDecl(); } } - State = 2350; + State = 2441; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11722,15 +11840,15 @@ public PropDeclContext propDecl() { PropDeclContext _localctx = new PropDeclContext(Context, State); EnterRule(_localctx, 224, RULE_propDecl); try { - State = 2373; + State = 2464; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__133: EnterOuterAlt(_localctx, 1); { - State = 2351; + State = 2442; Match(T__133); - State = 2352; + State = 2443; _localctx.accessor = methodRef(); Actions.AddPropertySetter(_localctx, _localctx.accessor.Value); } @@ -11738,9 +11856,9 @@ public PropDeclContext propDecl() { case T__134: EnterOuterAlt(_localctx, 2); { - State = 2355; + State = 2446; Match(T__134); - State = 2356; + State = 2447; _localctx.accessor = methodRef(); Actions.AddPropertyGetter(_localctx, _localctx.accessor.Value); } @@ -11748,9 +11866,9 @@ public PropDeclContext propDecl() { case T__131: EnterOuterAlt(_localctx, 3); { - State = 2359; + State = 2450; Match(T__131); - State = 2360; + State = 2451; _localctx.accessor = methodRef(); Actions.AddPropertyOther(_localctx, _localctx.accessor.Value); } @@ -11764,7 +11882,7 @@ public PropDeclContext propDecl() { case ID: EnterOuterAlt(_localctx, 4); { - State = 2363; + State = 2454; _localctx.attribute = customAttrDecl(); Actions.AddPropertyCustomAttribute(_localctx, _localctx.attribute); } @@ -11773,7 +11891,7 @@ public PropDeclContext propDecl() { case T__73: EnterOuterAlt(_localctx, 5); { - State = 2366; + State = 2457; _localctx.source = extSourceSpec(); Actions.ProcessPropertySourceDirective(_localctx.source); } @@ -11781,7 +11899,7 @@ public PropDeclContext propDecl() { case T__26: EnterOuterAlt(_localctx, 6); { - State = 2369; + State = 2460; _localctx.language = languageDecl(); Actions.ProcessPropertyLanguageDirective(_localctx.language); } @@ -11796,7 +11914,7 @@ public PropDeclContext propDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 7); { - State = 2372; + State = 2463; compControl(); } break; @@ -11839,7 +11957,7 @@ public MarshalClauseContext marshalClause() { MarshalClauseContext _localctx = new MarshalClauseContext(Context, State); EnterRule(_localctx, 226, RULE_marshalClause); try { - State = 2382; + State = 2473; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -11876,13 +11994,13 @@ public MarshalClauseContext marshalClause() { case T__121: EnterOuterAlt(_localctx, 2); { - State = 2376; + State = 2467; Match(T__121); - State = 2377; + State = 2468; Match(T__29); - State = 2378; + State = 2469; _localctx.value = marshalBlob(); - State = 2379; + State = 2470; Match(T__30); _localctx.Value = Actions.CompleteMarshalClause(_localctx.value.Value); } @@ -11935,7 +12053,7 @@ public MarshalBlobContext marshalBlob() { Actions.BeginMarshalBlob(_localctx); int _la; try { - State = 2397; + State = 2488; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -11990,7 +12108,7 @@ public MarshalBlobContext marshalBlob() { case ID: EnterOuterAlt(_localctx, 1); { - State = 2384; + State = 2475; _localctx.nativeValue = nativeType(); Actions.SetMarshalBlobNativeType(_localctx, _localctx.nativeValue.Value); } @@ -11998,24 +12116,24 @@ public MarshalBlobContext marshalBlob() { case T__16: EnterOuterAlt(_localctx, 2); { - State = 2387; + State = 2478; Match(T__16); - State = 2391; + State = 2482; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2388; + State = 2479; _localctx.rawByte = hexbyte(); Actions.AddMarshalBlobByte(_localctx, _localctx.rawByte.Value); } } - State = 2393; + State = 2484; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( _la==INT32 || _la==ID || _la==HEXBYTE ); - State = 2395; + State = 2486; Match(T__17); } break; @@ -12066,18 +12184,18 @@ public ParamAttrContext paramAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 2404; + State = 2495; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__41) { { { - State = 2399; + State = 2490; _localctx.element = paramAttrElement(); Actions.AddParameterAttribute(_localctx, _localctx.element); } } - State = 2406; + State = 2497; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -12121,17 +12239,17 @@ public ParamAttrElementContext paramAttrElement() { ParamAttrElementContext _localctx = new ParamAttrElementContext(Context, State); EnterRule(_localctx, 232, RULE_paramAttrElement); try { - State = 2424; + State = 2515; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,113,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2407; + State = 2498; Match(T__41); - State = 2408; + State = 2499; _localctx.attribute = Match(T__135); - State = 2409; + State = 2500; Match(T__42); Actions.SetParameterAttributeElement(_localctx, _localctx.attribute); } @@ -12139,11 +12257,11 @@ public ParamAttrElementContext paramAttrElement() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2411; + State = 2502; Match(T__41); - State = 2412; + State = 2503; _localctx.attribute = Match(T__136); - State = 2413; + State = 2504; Match(T__42); Actions.SetParameterAttributeElement(_localctx, _localctx.attribute); } @@ -12151,11 +12269,11 @@ public ParamAttrElementContext paramAttrElement() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2415; + State = 2506; Match(T__41); - State = 2416; + State = 2507; _localctx.attribute = Match(T__137); - State = 2417; + State = 2508; Match(T__42); Actions.SetParameterAttributeElement(_localctx, _localctx.attribute); } @@ -12163,11 +12281,11 @@ public ParamAttrElementContext paramAttrElement() { case 4: EnterOuterAlt(_localctx, 4); { - State = 2419; + State = 2510; Match(T__41); - State = 2420; + State = 2511; _localctx.raw = int32(); - State = 2421; + State = 2512; Match(T__42); Actions.SetRawParameterAttributeElement(_localctx, (_localctx.raw!=null?(_localctx.raw.Start):null)); } @@ -12258,14 +12376,14 @@ public MethodHeadContext methodHead() { try { EnterOuterAlt(_localctx, 1); { - State = 2426; + State = 2517; Match(T__138); - State = 2435; + State = 2526; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & 978955L) != 0) || ((((_la - 123)) & ~0x3f) == 0 && ((1L << (_la - 123)) & 33423365L) != 0)) { { - State = 2433; + State = 2524; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__50: @@ -12288,14 +12406,14 @@ public MethodHeadContext methodHead() { case T__144: case T__145: { - State = 2427; + State = 2518; _localctx.attribute = methAttr(); Actions.AddMethodAttribute(_localctx, _localctx.attribute.Value); } break; case T__146: { - State = 2430; + State = 2521; _localctx.pInvoke = pinvImpl(); Actions.AddPInvoke(_localctx, _localctx.pInvoke.Value); } @@ -12304,36 +12422,36 @@ public MethodHeadContext methodHead() { throw new NoViableAltException(this); } } - State = 2437; + State = 2528; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2438; + State = 2529; _localctx.convention = callConv(); - State = 2439; + State = 2530; _localctx.returnAttributes = paramAttr(); - State = 2440; + State = 2531; _localctx.returnType = type(); - State = 2441; + State = 2532; _localctx.returnMarshalling = marshalClause(); - State = 2442; + State = 2533; _localctx.name = methodName(); - State = 2443; + State = 2534; _localctx.genericParameters = typarsClause(); - State = 2444; + State = 2535; _localctx.arguments = sigArgs(); - State = 2450; + State = 2541; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 32766L) != 0) || _la==T__69 || _la==T__155 || _la==UNMANAGED) { { { - State = 2445; + State = 2536; _localctx.implementation = implAttr(); Actions.AddMethodImplementationAttribute(_localctx, _localctx.implementation.Value); } } - State = 2452; + State = 2543; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -12387,13 +12505,13 @@ public MethAttrContext methAttr() { MethAttrContext _localctx = new MethAttrContext(Context, State); EnterRule(_localctx, 236, RULE_methAttr); try { - State = 2497; + State = 2588; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__122: EnterOuterAlt(_localctx, 1); { - State = 2455; + State = 2546; _localctx.attribute = Match(T__122); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12401,7 +12519,7 @@ public MethAttrContext methAttr() { case T__50: EnterOuterAlt(_localctx, 2); { - State = 2457; + State = 2548; _localctx.attribute = Match(T__50); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12409,7 +12527,7 @@ public MethAttrContext methAttr() { case T__51: EnterOuterAlt(_localctx, 3); { - State = 2459; + State = 2550; _localctx.attribute = Match(T__51); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12417,7 +12535,7 @@ public MethAttrContext methAttr() { case T__62: EnterOuterAlt(_localctx, 4); { - State = 2461; + State = 2552; _localctx.attribute = Match(T__62); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12425,7 +12543,7 @@ public MethAttrContext methAttr() { case T__139: EnterOuterAlt(_localctx, 5); { - State = 2463; + State = 2554; _localctx.attribute = Match(T__139); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12433,7 +12551,7 @@ public MethAttrContext methAttr() { case T__67: EnterOuterAlt(_localctx, 6); { - State = 2465; + State = 2556; _localctx.attribute = Match(T__67); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12441,7 +12559,7 @@ public MethAttrContext methAttr() { case T__140: EnterOuterAlt(_localctx, 7); { - State = 2467; + State = 2558; _localctx.attribute = Match(T__140); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12449,7 +12567,7 @@ public MethAttrContext methAttr() { case T__141: EnterOuterAlt(_localctx, 8); { - State = 2469; + State = 2560; _localctx.attribute = Match(T__141); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12457,7 +12575,7 @@ public MethAttrContext methAttr() { case T__53: EnterOuterAlt(_localctx, 9); { - State = 2471; + State = 2562; _localctx.attribute = Match(T__53); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12465,7 +12583,7 @@ public MethAttrContext methAttr() { case T__63: EnterOuterAlt(_localctx, 10); { - State = 2473; + State = 2564; _localctx.attribute = Match(T__63); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12473,7 +12591,7 @@ public MethAttrContext methAttr() { case T__64: EnterOuterAlt(_localctx, 11); { - State = 2475; + State = 2566; _localctx.attribute = Match(T__64); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12481,7 +12599,7 @@ public MethAttrContext methAttr() { case T__65: EnterOuterAlt(_localctx, 12); { - State = 2477; + State = 2568; _localctx.attribute = Match(T__65); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12489,7 +12607,7 @@ public MethAttrContext methAttr() { case T__124: EnterOuterAlt(_localctx, 13); { - State = 2479; + State = 2570; _localctx.attribute = Match(T__124); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12497,7 +12615,7 @@ public MethAttrContext methAttr() { case T__142: EnterOuterAlt(_localctx, 14); { - State = 2481; + State = 2572; _localctx.attribute = Match(T__142); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12505,7 +12623,7 @@ public MethAttrContext methAttr() { case T__143: EnterOuterAlt(_localctx, 15); { - State = 2483; + State = 2574; _localctx.attribute = Match(T__143); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12513,7 +12631,7 @@ public MethAttrContext methAttr() { case T__68: EnterOuterAlt(_localctx, 16); { - State = 2485; + State = 2576; _localctx.attribute = Match(T__68); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12521,7 +12639,7 @@ public MethAttrContext methAttr() { case T__144: EnterOuterAlt(_localctx, 17); { - State = 2487; + State = 2578; _localctx.attribute = Match(T__144); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12529,7 +12647,7 @@ public MethAttrContext methAttr() { case T__145: EnterOuterAlt(_localctx, 18); { - State = 2489; + State = 2580; _localctx.attribute = Match(T__145); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12537,13 +12655,13 @@ public MethAttrContext methAttr() { case T__69: EnterOuterAlt(_localctx, 19); { - State = 2491; + State = 2582; Match(T__69); - State = 2492; + State = 2583; Match(T__29); - State = 2493; + State = 2584; _localctx.flags = int32(); - State = 2494; + State = 2585; Match(T__30); _localctx.Value = Actions.CreateRawMethodAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } @@ -12600,32 +12718,32 @@ public PinvImplContext pinvImpl() { Actions.BeginPInvoke(_localctx); int _la; try { - State = 2522; + State = 2613; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,121,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2499; + State = 2590; Match(T__146); - State = 2500; + State = 2591; Match(T__29); - State = 2509; + State = 2600; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==QSTRING) { { - State = 2501; + State = 2592; _localctx.module = compQstring(); Actions.SetPInvokeModule(_localctx, _localctx.module.Value); - State = 2507; + State = 2598; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__33) { { - State = 2503; + State = 2594; Match(T__33); - State = 2504; + State = 2595; _localctx.entryPoint = compQstring(); Actions.SetPInvokeEntryPoint(_localctx, _localctx.entryPoint.Value); } @@ -12634,31 +12752,31 @@ public PinvImplContext pinvImpl() { } } - State = 2516; + State = 2607; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 57)) & ~0x3f) == 0 && ((1L << (_la - 57)) & 8195L) != 0) || ((((_la - 148)) & ~0x3f) == 0 && ((1L << (_la - 148)) & 79L) != 0) || ((((_la - 224)) & ~0x3f) == 0 && ((1L << (_la - 224)) & 251658241L) != 0)) { { { - State = 2511; + State = 2602; _localctx.attribute = pinvAttr(); Actions.AddPInvokeAttribute(_localctx, _localctx.attribute.Value); } } - State = 2518; + State = 2609; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2519; + State = 2610; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2520; + State = 2611; Match(T__146); - State = 2521; + State = 2612; Match(T__84); } break; @@ -12707,13 +12825,13 @@ public PinvAttrContext pinvAttr() { PinvAttrContext _localctx = new PinvAttrContext(Context, State); EnterRule(_localctx, 240, RULE_pinvAttr); try { - State = 2566; + State = 2657; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,122,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2524; + State = 2615; _localctx.attribute = Match(T__147); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12721,7 +12839,7 @@ public PinvAttrContext pinvAttr() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2526; + State = 2617; _localctx.attribute = Match(ANSI); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12729,7 +12847,7 @@ public PinvAttrContext pinvAttr() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2528; + State = 2619; _localctx.attribute = Match(T__56); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12737,7 +12855,7 @@ public PinvAttrContext pinvAttr() { case 4: EnterOuterAlt(_localctx, 4); { - State = 2530; + State = 2621; _localctx.attribute = Match(T__57); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12745,7 +12863,7 @@ public PinvAttrContext pinvAttr() { case 5: EnterOuterAlt(_localctx, 5); { - State = 2532; + State = 2623; _localctx.attribute = Match(T__148); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12753,7 +12871,7 @@ public PinvAttrContext pinvAttr() { case 6: EnterOuterAlt(_localctx, 6); { - State = 2534; + State = 2625; _localctx.attribute = Match(T__149); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12761,7 +12879,7 @@ public PinvAttrContext pinvAttr() { case 7: EnterOuterAlt(_localctx, 7); { - State = 2536; + State = 2627; _localctx.attribute = Match(CDECL); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12769,7 +12887,7 @@ public PinvAttrContext pinvAttr() { case 8: EnterOuterAlt(_localctx, 8); { - State = 2538; + State = 2629; _localctx.attribute = Match(STDCALL); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12777,7 +12895,7 @@ public PinvAttrContext pinvAttr() { case 9: EnterOuterAlt(_localctx, 9); { - State = 2540; + State = 2631; _localctx.attribute = Match(THISCALL); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12785,7 +12903,7 @@ public PinvAttrContext pinvAttr() { case 10: EnterOuterAlt(_localctx, 10); { - State = 2542; + State = 2633; _localctx.attribute = Match(FASTCALL); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12793,11 +12911,11 @@ public PinvAttrContext pinvAttr() { case 11: EnterOuterAlt(_localctx, 11); { - State = 2544; + State = 2635; Match(T__150); - State = 2545; + State = 2636; Match(T__74); - State = 2546; + State = 2637; _localctx.setting = Match(T__151); _localctx.Value = Actions.CreateBestFitPInvokeAttribute(_localctx.setting); } @@ -12805,11 +12923,11 @@ public PinvAttrContext pinvAttr() { case 12: EnterOuterAlt(_localctx, 12); { - State = 2548; + State = 2639; Match(T__150); - State = 2549; + State = 2640; Match(T__74); - State = 2550; + State = 2641; _localctx.setting = Match(T__152); _localctx.Value = Actions.CreateBestFitPInvokeAttribute(_localctx.setting); } @@ -12817,11 +12935,11 @@ public PinvAttrContext pinvAttr() { case 13: EnterOuterAlt(_localctx, 13); { - State = 2552; + State = 2643; Match(T__153); - State = 2553; + State = 2644; Match(T__74); - State = 2554; + State = 2645; _localctx.setting = Match(T__151); _localctx.Value = Actions.CreateCharMapErrorPInvokeAttribute(_localctx.setting); } @@ -12829,11 +12947,11 @@ public PinvAttrContext pinvAttr() { case 14: EnterOuterAlt(_localctx, 14); { - State = 2556; + State = 2647; Match(T__153); - State = 2557; + State = 2648; Match(T__74); - State = 2558; + State = 2649; _localctx.setting = Match(T__152); _localctx.Value = Actions.CreateCharMapErrorPInvokeAttribute(_localctx.setting); } @@ -12841,13 +12959,13 @@ public PinvAttrContext pinvAttr() { case 15: EnterOuterAlt(_localctx, 15); { - State = 2560; + State = 2651; Match(T__69); - State = 2561; + State = 2652; Match(T__29); - State = 2562; + State = 2653; _localctx.flags = int32(); - State = 2563; + State = 2654; Match(T__30); _localctx.Value = Actions.CreateRawPInvokeAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } @@ -12891,13 +13009,13 @@ public MethodNameContext methodName() { MethodNameContext _localctx = new MethodNameContext(Context, State); EnterRule(_localctx, 242, RULE_methodName); try { - State = 2575; + State = 2666; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__115: EnterOuterAlt(_localctx, 1); { - State = 2568; + State = 2659; _localctx.ctorName = Match(T__115); _localctx.Value = Actions.GetMethodName(_localctx.ctorName); } @@ -12905,7 +13023,7 @@ public MethodNameContext methodName() { case T__154: EnterOuterAlt(_localctx, 2); { - State = 2570; + State = 2661; _localctx.cctorName = Match(T__154); _localctx.Value = Actions.GetMethodName(_localctx.cctorName); } @@ -12918,7 +13036,7 @@ public MethodNameContext methodName() { case ID: EnterOuterAlt(_localctx, 3); { - State = 2572; + State = 2663; _localctx.dotted = dottedName(); _localctx.Value = _localctx.dotted.Value; } @@ -12964,13 +13082,13 @@ public ImplAttrContext implAttr() { ImplAttrContext _localctx = new ImplAttrContext(Context, State); EnterRule(_localctx, 244, RULE_implAttr); try { - State = 2615; + State = 2706; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: EnterOuterAlt(_localctx, 1); { - State = 2577; + State = 2668; _localctx.attribute = Match(T__0); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -12978,7 +13096,7 @@ public ImplAttrContext implAttr() { case T__1: EnterOuterAlt(_localctx, 2); { - State = 2579; + State = 2670; _localctx.attribute = Match(T__1); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -12986,7 +13104,7 @@ public ImplAttrContext implAttr() { case T__155: EnterOuterAlt(_localctx, 3); { - State = 2581; + State = 2672; _localctx.attribute = Match(T__155); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -12994,7 +13112,7 @@ public ImplAttrContext implAttr() { case T__2: EnterOuterAlt(_localctx, 4); { - State = 2583; + State = 2674; _localctx.attribute = Match(T__2); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13002,7 +13120,7 @@ public ImplAttrContext implAttr() { case T__3: EnterOuterAlt(_localctx, 5); { - State = 2585; + State = 2676; _localctx.attribute = Match(T__3); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13010,7 +13128,7 @@ public ImplAttrContext implAttr() { case UNMANAGED: EnterOuterAlt(_localctx, 6); { - State = 2587; + State = 2678; _localctx.attribute = Match(UNMANAGED); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13018,7 +13136,7 @@ public ImplAttrContext implAttr() { case T__4: EnterOuterAlt(_localctx, 7); { - State = 2589; + State = 2680; _localctx.attribute = Match(T__4); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13026,7 +13144,7 @@ public ImplAttrContext implAttr() { case T__5: EnterOuterAlt(_localctx, 8); { - State = 2591; + State = 2682; _localctx.attribute = Match(T__5); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13034,7 +13152,7 @@ public ImplAttrContext implAttr() { case T__6: EnterOuterAlt(_localctx, 9); { - State = 2593; + State = 2684; _localctx.attribute = Match(T__6); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13042,7 +13160,7 @@ public ImplAttrContext implAttr() { case T__7: EnterOuterAlt(_localctx, 10); { - State = 2595; + State = 2686; _localctx.attribute = Match(T__7); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13050,7 +13168,7 @@ public ImplAttrContext implAttr() { case T__8: EnterOuterAlt(_localctx, 11); { - State = 2597; + State = 2688; _localctx.attribute = Match(T__8); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13058,7 +13176,7 @@ public ImplAttrContext implAttr() { case T__9: EnterOuterAlt(_localctx, 12); { - State = 2599; + State = 2690; _localctx.attribute = Match(T__9); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13066,7 +13184,7 @@ public ImplAttrContext implAttr() { case T__10: EnterOuterAlt(_localctx, 13); { - State = 2601; + State = 2692; _localctx.attribute = Match(T__10); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13074,7 +13192,7 @@ public ImplAttrContext implAttr() { case T__11: EnterOuterAlt(_localctx, 14); { - State = 2603; + State = 2694; _localctx.attribute = Match(T__11); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13082,7 +13200,7 @@ public ImplAttrContext implAttr() { case T__12: EnterOuterAlt(_localctx, 15); { - State = 2605; + State = 2696; _localctx.attribute = Match(T__12); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13090,7 +13208,7 @@ public ImplAttrContext implAttr() { case T__13: EnterOuterAlt(_localctx, 16); { - State = 2607; + State = 2698; _localctx.attribute = Match(T__13); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13098,13 +13216,13 @@ public ImplAttrContext implAttr() { case T__69: EnterOuterAlt(_localctx, 17); { - State = 2609; + State = 2700; Match(T__69); - State = 2610; + State = 2701; Match(T__29); - State = 2611; + State = 2702; _localctx.flags = int32(); - State = 2612; + State = 2703; Match(T__30); _localctx.Value = Actions.CreateRawMethodImplementationAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } @@ -13153,17 +13271,17 @@ public MethodDeclsContext methodDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2620; + State = 2711; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38789119998L) != 0) || _la==T__72 || _la==T__73 || ((((_la - 158)) & ~0x3f) == 0 && ((1L << (_la - 158)) & 2199023255681L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 2303696760354115601L) != 0)) { { { - State = 2617; + State = 2708; methodDecl(); } } - State = 2622; + State = 2713; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -13258,7 +13376,7 @@ public MethodDeclContext methodDecl() { MethodDeclContext _localctx = new MethodDeclContext(Context, State); EnterRule(_localctx, 248, RULE_methodDecl); try { - State = 2660; + State = 2751; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case INSTR_NONE: @@ -13276,16 +13394,16 @@ public MethodDeclContext methodDecl() { case INSTR_TOK: EnterOuterAlt(_localctx, 1); { - State = 2623; + State = 2714; instr(); } break; case EMITBYTE: EnterOuterAlt(_localctx, 2); { - State = 2624; + State = 2715; Match(EMITBYTE); - State = 2625; + State = 2716; _localctx.value = int32(); Actions.EmitByte((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -13293,16 +13411,16 @@ public MethodDeclContext methodDecl() { case T__157: EnterOuterAlt(_localctx, 3); { - State = 2628; + State = 2719; sehBlock(); } break; case MAXSTACK: EnterOuterAlt(_localctx, 4); { - State = 2629; + State = 2720; Match(MAXSTACK); - State = 2630; + State = 2721; _localctx.value = int32(); Actions.SetMaxStack((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -13310,7 +13428,7 @@ public MethodDeclContext methodDecl() { case ENTRYPOINT: EnterOuterAlt(_localctx, 5); { - State = 2633; + State = 2724; Match(ENTRYPOINT); Actions.SetEntryPoint(); } @@ -13318,7 +13436,7 @@ public MethodDeclContext methodDecl() { case ZEROINIT: EnterOuterAlt(_localctx, 6); { - State = 2635; + State = 2726; Match(ZEROINIT); Actions.SetZeroInit(); } @@ -13345,28 +13463,28 @@ public MethodDeclContext methodDecl() { case ID: EnterOuterAlt(_localctx, 7); { - State = 2637; + State = 2728; labelDecl(); } break; case T__16: EnterOuterAlt(_localctx, 8); { - State = 2638; + State = 2729; scopeBlock(); } break; case LOCALS: EnterOuterAlt(_localctx, 9); { - State = 2639; + State = 2730; localsDecl(); } break; case T__164: EnterOuterAlt(_localctx, 10); { - State = 2640; + State = 2731; _localctx.declaration = dataDecl(); Actions.ProcessMethodDataDeclaration(_localctx.declaration); } @@ -13375,7 +13493,7 @@ public MethodDeclContext methodDecl() { case PERMISSIONSET: EnterOuterAlt(_localctx, 11); { - State = 2643; + State = 2734; _localctx.security = secDecl(); Actions.ProcessMethodSecurityDeclaration(_localctx.security); } @@ -13384,7 +13502,7 @@ public MethodDeclContext methodDecl() { case T__73: EnterOuterAlt(_localctx, 12); { - State = 2646; + State = 2737; _localctx.source = extSourceSpec(); Actions.ProcessMethodSourceDirective(_localctx.source); } @@ -13392,7 +13510,7 @@ public MethodDeclContext methodDecl() { case T__26: EnterOuterAlt(_localctx, 13); { - State = 2649; + State = 2740; _localctx.language = languageDecl(); Actions.ProcessMethodLanguageDirective(_localctx.language); } @@ -13400,7 +13518,7 @@ public MethodDeclContext methodDecl() { case T__34: EnterOuterAlt(_localctx, 14); { - State = 2652; + State = 2743; _localctx.attribute = customDescrInMethodBody(); Actions.ProcessMethodCustomAttribute(_localctx.attribute); } @@ -13415,35 +13533,35 @@ public MethodDeclContext methodDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 15); { - State = 2655; + State = 2746; compControl(); } break; case EXPORT: EnterOuterAlt(_localctx, 16); { - State = 2656; + State = 2747; exportDecl(); } break; case VTENTRY: EnterOuterAlt(_localctx, 17); { - State = 2657; + State = 2748; vtentryDecl(); } break; case OVERRIDE: EnterOuterAlt(_localctx, 18); { - State = 2658; + State = 2749; overrideDecl(); } break; case PARAM: EnterOuterAlt(_localctx, 19); { - State = 2659; + State = 2750; parameterDecl(); } break; @@ -13491,19 +13609,19 @@ public LocalsDeclContext localsDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2662; + State = 2753; Match(LOCALS); - State = 2664; + State = 2755; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__156) { { - State = 2663; + State = 2754; _localctx.initialize = Match(T__156); } } - State = 2666; + State = 2757; _localctx.arguments = sigArgs(); } } @@ -13551,22 +13669,22 @@ public ExportDeclContext exportDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2668; + State = 2759; Match(EXPORT); - State = 2669; + State = 2760; Match(T__41); - State = 2670; + State = 2761; _localctx.ordinal = int32(); - State = 2671; + State = 2762; Match(T__42); - State = 2674; + State = 2765; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__33) { { - State = 2672; + State = 2763; Match(T__33); - State = 2673; + State = 2764; _localctx.alias = id(); } } @@ -13616,13 +13734,13 @@ public VtentryDeclContext vtentryDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2676; + State = 2767; Match(VTENTRY); - State = 2677; + State = 2768; _localctx.table = int32(); - State = 2678; + State = 2769; Match(T__74); - State = 2679; + State = 2770; _localctx.slot = int32(); } } @@ -13685,42 +13803,42 @@ public OverrideDeclContext overrideDecl() { EnterRule(_localctx, 256, RULE_overrideDecl); Actions.BeginSemanticRoot(_localctx); try { - State = 2696; + State = 2787; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,129,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2681; + State = 2772; Match(OVERRIDE); - State = 2682; + State = 2773; _localctx.owner = typeSpec(); - State = 2683; + State = 2774; Match(DCOLON); - State = 2684; + State = 2775; _localctx.name = methodName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2686; + State = 2777; Match(OVERRIDE); - State = 2687; + State = 2778; Match(METHOD); - State = 2688; + State = 2779; _localctx.convention = callConv(); - State = 2689; + State = 2780; _localctx.returnType = type(); - State = 2690; + State = 2781; _localctx.owner = typeSpec(); - State = 2691; + State = 2782; Match(DCOLON); - State = 2692; + State = 2783; _localctx.name = methodName(); - State = 2693; + State = 2784; _localctx.arity = genArity(); - State = 2694; + State = 2785; _localctx.arguments = sigArgs(); } break; @@ -13788,36 +13906,36 @@ public ParameterDeclContext parameterDecl() { Actions.BeginParameterDirective(_localctx); try { int _alt; - State = 2763; + State = 2854; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,135,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2698; + State = 2789; Match(PARAM); - State = 2699; + State = 2790; Match(TYPE); - State = 2700; + State = 2791; Match(T__41); - State = 2701; + State = 2792; _localctx.genericIndex = int32(); - State = 2702; + State = 2793; Match(T__42); - State = 2708; + State = 2799; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,130,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2703; + State = 2794; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2710; + State = 2801; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,130,Context); } @@ -13826,26 +13944,26 @@ public ParameterDeclContext parameterDecl() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2711; + State = 2802; Match(PARAM); - State = 2712; + State = 2803; Match(TYPE); - State = 2713; + State = 2804; _localctx.genericName = dottedName(); - State = 2719; + State = 2810; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,131,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2714; + State = 2805; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2721; + State = 2812; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,131,Context); } @@ -13854,34 +13972,34 @@ public ParameterDeclContext parameterDecl() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2722; + State = 2813; Match(PARAM); - State = 2723; + State = 2814; Match(CONSTRAINT); - State = 2724; + State = 2815; Match(T__41); - State = 2725; + State = 2816; _localctx.constraintIndex = int32(); - State = 2726; + State = 2817; Match(T__42); - State = 2727; + State = 2818; Match(T__27); - State = 2728; + State = 2819; _localctx.constraintType = typeSpec(); - State = 2734; + State = 2825; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,132,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2729; + State = 2820; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2736; + State = 2827; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,132,Context); } @@ -13890,30 +14008,30 @@ public ParameterDeclContext parameterDecl() { case 4: EnterOuterAlt(_localctx, 4); { - State = 2737; + State = 2828; Match(PARAM); - State = 2738; + State = 2829; Match(CONSTRAINT); - State = 2739; + State = 2830; _localctx.constraintName = dottedName(); - State = 2740; + State = 2831; Match(T__27); - State = 2741; + State = 2832; _localctx.constraintType = typeSpec(); - State = 2747; + State = 2838; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,133,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2742; + State = 2833; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2749; + State = 2840; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,133,Context); } @@ -13922,30 +14040,30 @@ public ParameterDeclContext parameterDecl() { case 5: EnterOuterAlt(_localctx, 5); { - State = 2750; + State = 2841; Match(PARAM); - State = 2751; + State = 2842; Match(T__41); - State = 2752; + State = 2843; _localctx.parameterIndex = int32(); - State = 2753; + State = 2844; Match(T__42); - State = 2754; + State = 2845; _localctx.initializer = initOpt(); - State = 2760; + State = 2851; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,134,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2755; + State = 2846; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2762; + State = 2853; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,134,Context); } @@ -13990,9 +14108,9 @@ public LabelDeclContext labelDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2765; + State = 2856; _localctx.name = id(); - State = 2766; + State = 2857; Match(T__74); Actions.DefineLabel((_localctx.name!=null?(_localctx.name.Start):null)); } @@ -14035,20 +14153,20 @@ public CustomDescrInMethodBodyContext customDescrInMethodBody() { EnterRule(_localctx, 262, RULE_customDescrInMethodBody); BeginSubtree(); Actions.BeginSemanticRoot(_localctx); try { - State = 2771; + State = 2862; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,136,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2769; + State = 2860; customDescr(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2770; + State = 2861; customDescrWithOwner(); } break; @@ -14091,11 +14209,11 @@ public ScopeBlockContext scopeBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 2773; + State = 2864; Match(T__16); - State = 2774; + State = 2865; methodDecls(); - State = 2775; + State = 2866; Match(T__17); } } @@ -14141,9 +14259,9 @@ public SehBlockContext sehBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 2777; + State = 2868; _localctx.tryRange = tryBlock(); - State = 2778; + State = 2869; _localctx.clauses = sehClauses(); } } @@ -14190,18 +14308,18 @@ public SehClausesContext sehClauses() { try { EnterOuterAlt(_localctx, 1); { - State = 2783; + State = 2874; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2780; + State = 2871; _localctx.clause = sehClause(); Actions.AddExceptionClause(_localctx, _localctx.clause.Value); } } - State = 2785; + State = 2876; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( ((((_la - 160)) & ~0x3f) == 0 && ((1L << (_la - 160)) & 15L) != 0) ); @@ -14259,15 +14377,15 @@ public TryBlockContext tryBlock() { TryBlockContext _localctx = new TryBlockContext(Context, State); EnterRule(_localctx, 270, RULE_tryBlock); try { - State = 2803; + State = 2894; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,138,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2787; + State = 2878; Match(T__157); - State = 2788; + State = 2879; _localctx.body = scopeBlock(); _localctx.Value = Actions.CreateScopeExceptionRange(_localctx.body); } @@ -14275,13 +14393,13 @@ public TryBlockContext tryBlock() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2791; + State = 2882; Match(T__157); - State = 2792; + State = 2883; _localctx.startLabel = id(); - State = 2793; + State = 2884; Match(T__158); - State = 2794; + State = 2885; _localctx.endLabel = id(); _localctx.Value = Actions.CreateLabelExceptionRange((_localctx.startLabel!=null?(_localctx.startLabel.Start):null), (_localctx.endLabel!=null?(_localctx.endLabel.Start):null)); } @@ -14289,13 +14407,13 @@ public TryBlockContext tryBlock() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2797; + State = 2888; Match(T__157); - State = 2798; + State = 2889; _localctx.startOffset = int32(); - State = 2799; + State = 2890; Match(T__158); - State = 2800; + State = 2891; _localctx.endOffset = int32(); _localctx.Value = Actions.CreateOffsetExceptionRange((_localctx.startOffset!=null?(_localctx.startOffset.Start):null), (_localctx.endOffset!=null?(_localctx.endOffset.Start):null)); } @@ -14351,15 +14469,15 @@ public SehClauseContext sehClause() { SehClauseContext _localctx = new SehClauseContext(Context, State); EnterRule(_localctx, 272, RULE_sehClause); try { - State = 2821; + State = 2912; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__160: EnterOuterAlt(_localctx, 1); { - State = 2805; + State = 2896; _localctx.caught = catchClause(); - State = 2806; + State = 2897; _localctx.handler = handlerBlock(); _localctx.Value = Actions.CreateCatchExceptionClause(_localctx.caught.Value, _localctx.handler.Value); } @@ -14367,9 +14485,9 @@ public SehClauseContext sehClause() { case T__159: EnterOuterAlt(_localctx, 2); { - State = 2809; + State = 2900; _localctx.filtered = filterClause(); - State = 2810; + State = 2901; _localctx.handler = handlerBlock(); _localctx.Value = Actions.CreateFilterExceptionClause(_localctx.filtered.Value, _localctx.handler.Value); } @@ -14377,9 +14495,9 @@ public SehClauseContext sehClause() { case T__161: EnterOuterAlt(_localctx, 3); { - State = 2813; + State = 2904; finallyClause(); - State = 2814; + State = 2905; _localctx.handler = handlerBlock(); _localctx.Value = Actions.CreateFinallyExceptionClause(_localctx.handler.Value); } @@ -14387,9 +14505,9 @@ public SehClauseContext sehClause() { case T__162: EnterOuterAlt(_localctx, 4); { - State = 2817; + State = 2908; faultClause(); - State = 2818; + State = 2909; _localctx.handler = handlerBlock(); _localctx.Value = Actions.CreateFaultExceptionClause(_localctx.handler.Value); } @@ -14441,15 +14559,15 @@ public FilterClauseContext filterClause() { FilterClauseContext _localctx = new FilterClauseContext(Context, State); EnterRule(_localctx, 274, RULE_filterClause); try { - State = 2835; + State = 2926; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,140,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2823; + State = 2914; Match(T__159); - State = 2824; + State = 2915; _localctx.body = scopeBlock(); _localctx.Value = Actions.CreateScopeFilter(_localctx.body); } @@ -14457,9 +14575,9 @@ public FilterClauseContext filterClause() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2827; + State = 2918; Match(T__159); - State = 2828; + State = 2919; _localctx.label = id(); _localctx.Value = Actions.CreateLabelFilter((_localctx.label!=null?(_localctx.label.Start):null)); } @@ -14467,9 +14585,9 @@ public FilterClauseContext filterClause() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2831; + State = 2922; Match(T__159); - State = 2832; + State = 2923; _localctx.offset = int32(); _localctx.Value = Actions.CreateOffsetFilter((_localctx.offset!=null?(_localctx.offset.Start):null)); } @@ -14514,9 +14632,9 @@ public CatchClauseContext catchClause() { try { EnterOuterAlt(_localctx, 1); { - State = 2837; + State = 2928; Match(T__160); - State = 2838; + State = 2929; _localctx.catchType = typeSpec(); } } @@ -14553,7 +14671,7 @@ public FinallyClauseContext finallyClause() { try { EnterOuterAlt(_localctx, 1); { - State = 2840; + State = 2931; Match(T__161); } } @@ -14589,7 +14707,7 @@ public FaultClauseContext faultClause() { try { EnterOuterAlt(_localctx, 1); { - State = 2842; + State = 2933; Match(T__162); } } @@ -14644,13 +14762,13 @@ public HandlerBlockContext handlerBlock() { HandlerBlockContext _localctx = new HandlerBlockContext(Context, State); EnterRule(_localctx, 282, RULE_handlerBlock); try { - State = 2859; + State = 2950; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,141,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2844; + State = 2935; _localctx.body = scopeBlock(); _localctx.Value = Actions.CreateScopeExceptionRange(_localctx.body); } @@ -14658,13 +14776,13 @@ public HandlerBlockContext handlerBlock() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2847; + State = 2938; Match(T__163); - State = 2848; + State = 2939; _localctx.startLabel = id(); - State = 2849; + State = 2940; Match(T__158); - State = 2850; + State = 2941; _localctx.endLabel = id(); _localctx.Value = Actions.CreateLabelExceptionRange((_localctx.startLabel!=null?(_localctx.startLabel.Start):null), (_localctx.endLabel!=null?(_localctx.endLabel.Start):null)); } @@ -14672,13 +14790,13 @@ public HandlerBlockContext handlerBlock() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2853; + State = 2944; Match(T__163); - State = 2854; + State = 2945; _localctx.startOffset = int32(); - State = 2855; + State = 2946; Match(T__158); - State = 2856; + State = 2947; _localctx.endOffset = int32(); _localctx.Value = Actions.CreateOffsetExceptionRange((_localctx.startOffset!=null?(_localctx.startOffset.Start):null), (_localctx.endOffset!=null?(_localctx.endOffset.Start):null)); } @@ -14725,9 +14843,9 @@ public DataDeclContext dataDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2861; + State = 2952; ddHead(); - State = 2862; + State = 2953; ddBody(); } } @@ -14768,28 +14886,28 @@ public DdHeadContext ddHead() { DdHeadContext _localctx = new DdHeadContext(Context, State); EnterRule(_localctx, 286, RULE_ddHead); try { - State = 2871; + State = 2962; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,142,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2864; + State = 2955; Match(T__164); - State = 2865; + State = 2956; tls(); - State = 2866; + State = 2957; id(); - State = 2867; + State = 2958; Match(T__35); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2869; + State = 2960; Match(T__164); - State = 2870; + State = 2961; tls(); } break; @@ -14825,7 +14943,7 @@ public TlsContext tls() { TlsContext _localctx = new TlsContext(Context, State); EnterRule(_localctx, 288, RULE_tls); try { - State = 2876; + State = 2967; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,143,Context) ) { case 1: @@ -14836,14 +14954,14 @@ public TlsContext tls() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2874; + State = 2965; Match(T__165); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2875; + State = 2966; Match(T__1); } break; @@ -14889,17 +15007,17 @@ public DdBodyContext ddBody() { EnterRule(_localctx, 290, RULE_ddBody); int _la; try { - State = 2887; + State = 2978; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: EnterOuterAlt(_localctx, 1); { - State = 2878; + State = 2969; Match(T__16); - State = 2879; + State = 2970; ddItemList(); - State = 2880; + State = 2971; Match(T__17); } break; @@ -14914,17 +15032,17 @@ public DdBodyContext ddBody() { case REF: EnterOuterAlt(_localctx, 2); { - State = 2883; + State = 2974; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2882; + State = 2973; ddItem(); } } - State = 2885; + State = 2976; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( _la==T__83 || ((((_la - 181)) & ~0x3f) == 0 && ((1L << (_la - 181)) & 505L) != 0) || _la==REF ); @@ -14973,25 +15091,25 @@ public DdItemListContext ddItemList() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 2894; + State = 2985; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,146,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2889; + State = 2980; ddItem(); - State = 2890; + State = 2981; Match(T__27); } } } - State = 2896; + State = 2987; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,146,Context); } - State = 2897; + State = 2988; ddItem(); } } @@ -15028,7 +15146,7 @@ public DdItemCountContext ddItemCount() { DdItemCountContext _localctx = new DdItemCountContext(Context, State); EnterRule(_localctx, 294, RULE_ddItemCount); try { - State = 2904; + State = 2995; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -15132,11 +15250,11 @@ public DdItemCountContext ddItemCount() { case T__41: EnterOuterAlt(_localctx, 2); { - State = 2900; + State = 2991; Match(T__41); - State = 2901; + State = 2992; int32(); - State = 2902; + State = 2993; Match(T__42); } break; @@ -15204,200 +15322,200 @@ public DdItemContext ddItem() { DdItemContext _localctx = new DdItemContext(Context, State); EnterRule(_localctx, 296, RULE_ddItem); try { - State = 2972; + State = 3063; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,148,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2906; + State = 2997; Match(CHAR); - State = 2907; + State = 2998; Match(PTR); - State = 2908; + State = 2999; Match(T__29); - State = 2909; + State = 3000; compQstring(); - State = 2910; + State = 3001; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2912; + State = 3003; Match(REF); - State = 2913; + State = 3004; Match(T__29); - State = 2914; + State = 3005; id(); - State = 2915; + State = 3006; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2917; + State = 3008; Match(REF); - State = 2918; + State = 3009; id(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2919; + State = 3010; Match(T__83); - State = 2920; + State = 3011; Match(T__29); - State = 2921; + State = 3012; bytes(); - State = 2922; + State = 3013; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2924; + State = 3015; Match(FLOAT32); - State = 2925; + State = 3016; Match(T__29); - State = 2926; + State = 3017; float64(); - State = 2927; + State = 3018; Match(T__30); - State = 2928; + State = 3019; ddItemCount(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2930; + State = 3021; Match(FLOAT64_); - State = 2931; + State = 3022; Match(T__29); - State = 2932; + State = 3023; float64(); - State = 2933; + State = 3024; Match(T__30); - State = 2934; + State = 3025; ddItemCount(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 2936; + State = 3027; Match(INT64_); - State = 2937; + State = 3028; Match(T__29); - State = 2938; + State = 3029; int64(); - State = 2939; + State = 3030; Match(T__30); - State = 2940; + State = 3031; ddItemCount(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 2942; + State = 3033; Match(INT32_); - State = 2943; + State = 3034; Match(T__29); - State = 2944; + State = 3035; int32(); - State = 2945; + State = 3036; Match(T__30); - State = 2946; + State = 3037; ddItemCount(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 2948; + State = 3039; Match(INT16); - State = 2949; + State = 3040; Match(T__29); - State = 2950; + State = 3041; int32(); - State = 2951; + State = 3042; Match(T__30); - State = 2952; + State = 3043; ddItemCount(); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 2954; + State = 3045; Match(INT8); - State = 2955; + State = 3046; Match(T__29); - State = 2956; + State = 3047; int32(); - State = 2957; + State = 3048; Match(T__30); - State = 2958; + State = 3049; ddItemCount(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 2960; + State = 3051; Match(FLOAT32); - State = 2961; + State = 3052; ddItemCount(); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 2962; + State = 3053; Match(FLOAT64_); - State = 2963; + State = 3054; ddItemCount(); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 2964; + State = 3055; Match(INT64_); - State = 2965; + State = 3056; ddItemCount(); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 2966; + State = 3057; Match(INT32_); - State = 2967; + State = 3058; ddItemCount(); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 2968; + State = 3059; Match(INT16); - State = 2969; + State = 3060; ddItemCount(); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 2970; + State = 3061; Match(INT8); - State = 2971; + State = 3062; ddItemCount(); } break; @@ -15460,201 +15578,201 @@ public FieldSerInitContext fieldSerInit() { FieldSerInitContext _localctx = new FieldSerInitContext(Context, State); EnterRule(_localctx, 298, RULE_fieldSerInit); try { - State = 3049; + State = 3140; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,149,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2974; + State = 3065; Match(FLOAT32); - State = 2975; + State = 3066; Match(T__29); - State = 2976; + State = 3067; float64(); - State = 2977; + State = 3068; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2979; + State = 3070; Match(FLOAT64_); - State = 2980; + State = 3071; Match(T__29); - State = 2981; + State = 3072; float64(); - State = 2982; + State = 3073; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2984; + State = 3075; Match(FLOAT32); - State = 2985; + State = 3076; Match(T__29); - State = 2986; + State = 3077; int32(); - State = 2987; + State = 3078; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2989; + State = 3080; Match(FLOAT64_); - State = 2990; + State = 3081; Match(T__29); - State = 2991; + State = 3082; int64(); - State = 2992; + State = 3083; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2994; + State = 3085; Match(INT64_); - State = 2995; + State = 3086; Match(T__29); - State = 2996; + State = 3087; int64(); - State = 2997; + State = 3088; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2999; + State = 3090; Match(INT32_); - State = 3000; + State = 3091; Match(T__29); - State = 3001; + State = 3092; int32(); - State = 3002; + State = 3093; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 3004; + State = 3095; Match(INT16); - State = 3005; + State = 3096; Match(T__29); - State = 3006; + State = 3097; int32(); - State = 3007; + State = 3098; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 3009; + State = 3100; Match(INT8); - State = 3010; + State = 3101; Match(T__29); - State = 3011; + State = 3102; int32(); - State = 3012; + State = 3103; Match(T__30); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 3014; + State = 3105; Match(UINT64); - State = 3015; + State = 3106; Match(T__29); - State = 3016; + State = 3107; int64(); - State = 3017; + State = 3108; Match(T__30); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 3019; + State = 3110; Match(UINT32); - State = 3020; + State = 3111; Match(T__29); - State = 3021; + State = 3112; int32(); - State = 3022; + State = 3113; Match(T__30); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 3024; + State = 3115; Match(UINT16); - State = 3025; + State = 3116; Match(T__29); - State = 3026; + State = 3117; int32(); - State = 3027; + State = 3118; Match(T__30); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 3029; + State = 3120; Match(UINT8); - State = 3030; + State = 3121; Match(T__29); - State = 3031; + State = 3122; int32(); - State = 3032; + State = 3123; Match(T__30); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 3034; + State = 3125; Match(CHAR); - State = 3035; + State = 3126; Match(T__29); - State = 3036; + State = 3127; int32(); - State = 3037; + State = 3128; Match(T__30); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 3039; + State = 3130; Match(BOOL); - State = 3040; + State = 3131; Match(T__29); - State = 3041; + State = 3132; truefalse(); - State = 3042; + State = 3133; Match(T__30); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 3044; + State = 3135; Match(T__83); - State = 3045; + State = 3136; Match(T__29); - State = 3046; + State = 3137; bytes(); - State = 3047; + State = 3138; Match(T__30); } break; @@ -15702,18 +15820,18 @@ public BytesContext bytes() { try { EnterOuterAlt(_localctx, 1); { - State = 3056; + State = 3147; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32 || _la==ID || _la==HEXBYTE) { { { - State = 3051; + State = 3142; _localctx.b = hexbyte(); Actions.AddByte(_localctx.b.Value); } } - State = 3058; + State = 3149; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15757,7 +15875,7 @@ public HexbyteContext hexbyte() { try { EnterOuterAlt(_localctx, 1); { - State = 3059; + State = 3150; _la = TokenStream.LA(1); if ( !(_la==INT32 || _la==ID || _la==HEXBYTE) ) { ErrorHandler.RecoverInline(this); @@ -15807,7 +15925,7 @@ public FieldInitContext fieldInit() { FieldInitContext _localctx = new FieldInitContext(Context, State); EnterRule(_localctx, 304, RULE_fieldInit); try { - State = 3064; + State = 3155; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__83: @@ -15825,21 +15943,21 @@ public FieldInitContext fieldInit() { case UINT64: EnterOuterAlt(_localctx, 1); { - State = 3061; + State = 3152; fieldSerInit(); } break; case QSTRING: EnterOuterAlt(_localctx, 2); { - State = 3062; + State = 3153; compQstring(); } break; case NULLREF: EnterOuterAlt(_localctx, 3); { - State = 3063; + State = 3154; Match(NULLREF); } break; @@ -15936,378 +16054,378 @@ public SerInitContext serInit() { SerInitContext _localctx = new SerInitContext(Context, State); EnterRule(_localctx, 306, RULE_serInit); try { - State = 3214; + State = 3305; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,152,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3066; + State = 3157; fieldSerInit(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3067; + State = 3158; Match(STRING); - State = 3068; + State = 3159; Match(T__29); - State = 3069; + State = 3160; Match(NULLREF); - State = 3070; + State = 3161; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3071; + State = 3162; Match(STRING); - State = 3072; + State = 3163; Match(T__29); - State = 3073; + State = 3164; Match(SQSTRING); - State = 3074; + State = 3165; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 3075; + State = 3166; Match(TYPE); - State = 3076; + State = 3167; Match(T__29); - State = 3077; + State = 3168; Match(T__38); - State = 3078; + State = 3169; Match(SQSTRING); - State = 3079; + State = 3170; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 3080; + State = 3171; Match(TYPE); - State = 3081; + State = 3172; Match(T__29); - State = 3082; + State = 3173; className(); - State = 3083; + State = 3174; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 3085; + State = 3176; Match(TYPE); - State = 3086; + State = 3177; Match(T__29); - State = 3087; + State = 3178; Match(NULLREF); - State = 3088; + State = 3179; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 3089; + State = 3180; Match(OBJECT); - State = 3090; + State = 3181; Match(T__29); - State = 3091; + State = 3182; serInit(); - State = 3092; + State = 3183; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 3094; + State = 3185; Match(FLOAT32); - State = 3095; + State = 3186; Match(T__41); - State = 3096; + State = 3187; int32(); - State = 3097; + State = 3188; Match(T__42); - State = 3098; + State = 3189; Match(T__29); - State = 3099; + State = 3190; f32seq(); - State = 3100; + State = 3191; Match(T__30); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 3102; + State = 3193; Match(FLOAT64_); - State = 3103; + State = 3194; Match(T__41); - State = 3104; + State = 3195; int32(); - State = 3105; + State = 3196; Match(T__42); - State = 3106; + State = 3197; Match(T__29); - State = 3107; + State = 3198; f64seq(); - State = 3108; + State = 3199; Match(T__30); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 3110; + State = 3201; Match(INT64_); - State = 3111; + State = 3202; Match(T__41); - State = 3112; + State = 3203; int32(); - State = 3113; + State = 3204; Match(T__42); - State = 3114; + State = 3205; Match(T__29); - State = 3115; + State = 3206; i64seq(); - State = 3116; + State = 3207; Match(T__30); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 3118; + State = 3209; Match(INT32_); - State = 3119; + State = 3210; Match(T__41); - State = 3120; + State = 3211; int32(); - State = 3121; + State = 3212; Match(T__42); - State = 3122; + State = 3213; Match(T__29); - State = 3123; + State = 3214; i32seq(); - State = 3124; + State = 3215; Match(T__30); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 3126; + State = 3217; Match(INT16); - State = 3127; + State = 3218; Match(T__41); - State = 3128; + State = 3219; int32(); - State = 3129; + State = 3220; Match(T__42); - State = 3130; + State = 3221; Match(T__29); - State = 3131; + State = 3222; i16seq(); - State = 3132; + State = 3223; Match(T__30); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 3134; + State = 3225; Match(INT8); - State = 3135; + State = 3226; Match(T__41); - State = 3136; + State = 3227; int32(); - State = 3137; + State = 3228; Match(T__42); - State = 3138; + State = 3229; Match(T__29); - State = 3139; + State = 3230; i8seq(); - State = 3140; + State = 3231; Match(T__30); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 3142; + State = 3233; Match(UINT64); - State = 3143; + State = 3234; Match(T__41); - State = 3144; + State = 3235; int32(); - State = 3145; + State = 3236; Match(T__42); - State = 3146; + State = 3237; Match(T__29); - State = 3147; + State = 3238; i64seq(); - State = 3148; + State = 3239; Match(T__30); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 3150; + State = 3241; Match(UINT32); - State = 3151; + State = 3242; Match(T__41); - State = 3152; + State = 3243; int32(); - State = 3153; + State = 3244; Match(T__42); - State = 3154; + State = 3245; Match(T__29); - State = 3155; + State = 3246; i32seq(); - State = 3156; + State = 3247; Match(T__30); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 3158; + State = 3249; Match(UINT16); - State = 3159; + State = 3250; Match(T__41); - State = 3160; + State = 3251; int32(); - State = 3161; + State = 3252; Match(T__42); - State = 3162; + State = 3253; Match(T__29); - State = 3163; + State = 3254; i16seq(); - State = 3164; + State = 3255; Match(T__30); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 3166; + State = 3257; Match(UINT8); - State = 3167; + State = 3258; Match(T__41); - State = 3168; + State = 3259; int32(); - State = 3169; + State = 3260; Match(T__42); - State = 3170; + State = 3261; Match(T__29); - State = 3171; + State = 3262; i8seq(); - State = 3172; + State = 3263; Match(T__30); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 3174; + State = 3265; Match(CHAR); - State = 3175; + State = 3266; Match(T__41); - State = 3176; + State = 3267; int32(); - State = 3177; + State = 3268; Match(T__42); - State = 3178; + State = 3269; Match(T__29); - State = 3179; + State = 3270; i16seq(); - State = 3180; + State = 3271; Match(T__30); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 3182; + State = 3273; Match(BOOL); - State = 3183; + State = 3274; Match(T__41); - State = 3184; + State = 3275; int32(); - State = 3185; + State = 3276; Match(T__42); - State = 3186; + State = 3277; Match(T__29); - State = 3187; + State = 3278; boolSeq(); - State = 3188; + State = 3279; Match(T__30); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 3190; + State = 3281; Match(STRING); - State = 3191; + State = 3282; Match(T__41); - State = 3192; + State = 3283; int32(); - State = 3193; + State = 3284; Match(T__42); - State = 3194; + State = 3285; Match(T__29); - State = 3195; + State = 3286; sqstringSeq(); - State = 3196; + State = 3287; Match(T__30); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 3198; + State = 3289; Match(TYPE); - State = 3199; + State = 3290; Match(T__41); - State = 3200; + State = 3291; int32(); - State = 3201; + State = 3292; Match(T__42); - State = 3202; + State = 3293; Match(T__29); - State = 3203; + State = 3294; classSeq(); - State = 3204; + State = 3295; Match(T__30); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 3206; + State = 3297; Match(OBJECT); - State = 3207; + State = 3298; Match(T__41); - State = 3208; + State = 3299; int32(); - State = 3209; + State = 3300; Match(T__42); - State = 3210; + State = 3301; Match(T__29); - State = 3211; + State = 3302; objSeq(); - State = 3212; + State = 3303; Match(T__30); } break; @@ -16358,29 +16476,29 @@ public F32seqContext f32seq() { try { EnterOuterAlt(_localctx, 1); { - State = 3220; + State = 3311; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 98309L) != 0)) { { - State = 3218; + State = 3309; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,153,Context) ) { case 1: { - State = 3216; + State = 3307; float64(); } break; case 2: { - State = 3217; + State = 3308; int32(); } break; } } - State = 3222; + State = 3313; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16431,29 +16549,29 @@ public F64seqContext f64seq() { try { EnterOuterAlt(_localctx, 1); { - State = 3227; + State = 3318; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 98311L) != 0)) { { - State = 3225; + State = 3316; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,155,Context) ) { case 1: { - State = 3223; + State = 3314; float64(); } break; case 2: { - State = 3224; + State = 3315; int64(); } break; } } - State = 3229; + State = 3320; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16498,17 +16616,17 @@ public I64seqContext i64seq() { try { EnterOuterAlt(_localctx, 1); { - State = 3233; + State = 3324; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32 || _la==INT64) { { { - State = 3230; + State = 3321; int64(); } } - State = 3235; + State = 3326; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16553,17 +16671,17 @@ public I32seqContext i32seq() { try { EnterOuterAlt(_localctx, 1); { - State = 3239; + State = 3330; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 3236; + State = 3327; int32(); } } - State = 3241; + State = 3332; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16608,17 +16726,17 @@ public I16seqContext i16seq() { try { EnterOuterAlt(_localctx, 1); { - State = 3245; + State = 3336; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 3242; + State = 3333; int32(); } } - State = 3247; + State = 3338; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16663,17 +16781,17 @@ public I8seqContext i8seq() { try { EnterOuterAlt(_localctx, 1); { - State = 3251; + State = 3342; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 3248; + State = 3339; int32(); } } - State = 3253; + State = 3344; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16718,17 +16836,17 @@ public BoolSeqContext boolSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 3257; + State = 3348; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__94 || _la==T__95) { { { - State = 3254; + State = 3345; truefalse(); } } - State = 3259; + State = 3350; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16775,13 +16893,13 @@ public SqstringSeqContext sqstringSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 3263; + State = 3354; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==NULLREF || _la==SQSTRING) { { { - State = 3260; + State = 3351; _la = TokenStream.LA(1); if ( !(_la==NULLREF || _la==SQSTRING) ) { ErrorHandler.RecoverInline(this); @@ -16792,7 +16910,7 @@ public SqstringSeqContext sqstringSeq() { } } } - State = 3265; + State = 3356; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16837,17 +16955,17 @@ public ClassSeqContext classSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 3269; + State = 3360; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4947802390528L) != 0) || _la==T__112 || _la==NULLREF || _la==VALUE || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 105553118478337L) != 0)) { { { - State = 3266; + State = 3357; classSeqElement(); } } - State = 3271; + State = 3362; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16888,22 +17006,22 @@ public ClassSeqElementContext classSeqElement() { ClassSeqElementContext _localctx = new ClassSeqElementContext(Context, State); EnterRule(_localctx, 326, RULE_classSeqElement); try { - State = 3276; + State = 3367; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case NULLREF: EnterOuterAlt(_localctx, 1); { - State = 3272; + State = 3363; Match(NULLREF); } break; case T__38: EnterOuterAlt(_localctx, 2); { - State = 3273; + State = 3364; Match(T__38); - State = 3274; + State = 3365; Match(SQSTRING); } break; @@ -16920,7 +17038,7 @@ public ClassSeqElementContext classSeqElement() { case ID: EnterOuterAlt(_localctx, 3); { - State = 3275; + State = 3366; className(); } break; @@ -16967,17 +17085,17 @@ public ObjSeqContext objSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 3281; + State = 3372; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__83 || ((((_la - 181)) & ~0x3f) == 0 && ((1L << (_la - 181)) & 106495L) != 0)) { { { - State = 3278; + State = 3369; serInit(); } } - State = 3283; + State = 3374; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17024,27 +17142,27 @@ public CustomAttrDeclContext customAttrDecl() { EnterRule(_localctx, 330, RULE_customAttrDecl); BeginSubtree(); Actions.BeginSemanticRoot(_localctx); try { - State = 3287; + State = 3378; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,166,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3284; + State = 3375; customDescr(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3285; + State = 3376; customDescrWithOwner(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3286; + State = 3377; dottedName(); } break; @@ -17100,13 +17218,13 @@ public AsmOrRefDeclContext asmOrRefDecl() { EnterRule(_localctx, 332, RULE_asmOrRefDecl); int _la; try { - State = 3314; + State = 3405; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,167,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3289; + State = 3380; _la = TokenStream.LA(1); if ( !(_la==T__166 || _la==T__167) ) { ErrorHandler.RecoverInline(this); @@ -17115,72 +17233,72 @@ public AsmOrRefDeclContext asmOrRefDecl() { ErrorHandler.ReportMatch(this); Consume(); } - State = 3290; + State = 3381; Match(T__35); - State = 3291; + State = 3382; Match(T__29); - State = 3292; + State = 3383; bytes(); - State = 3293; + State = 3384; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3295; + State = 3386; Match(T__168); - State = 3296; + State = 3387; intOrWildcard(); - State = 3297; + State = 3388; Match(T__74); - State = 3298; + State = 3389; intOrWildcard(); - State = 3299; + State = 3390; Match(T__74); - State = 3300; + State = 3391; intOrWildcard(); - State = 3301; + State = 3392; Match(T__74); - State = 3302; + State = 3393; intOrWildcard(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3304; + State = 3395; Match(T__169); - State = 3305; + State = 3396; compQstring(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 3306; + State = 3397; Match(T__169); - State = 3307; + State = 3398; Match(T__35); - State = 3308; + State = 3399; Match(T__29); - State = 3309; + State = 3400; bytes(); - State = 3310; + State = 3401; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 3312; + State = 3403; customAttrDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 3313; + State = 3404; compControl(); } break; @@ -17197,6 +17315,57 @@ public AsmOrRefDeclContext asmOrRefDecl() { return _localctx; } + public partial class AssemblyRefBlockContext : ParserRuleContext { + public bool HasSyntaxError; + [System.Diagnostics.DebuggerNonUserCode] public AssemblyRefHeadContext assemblyRefHead() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public AssemblyRefDeclsContext assemblyRefDecls() { + return GetRuleContext(0); + } + public AssemblyRefBlockContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_assemblyRefBlock; } } + [System.Diagnostics.DebuggerNonUserCode] + public override TResult Accept(IParseTreeVisitor visitor) { + ICILVisitor typedVisitor = visitor as ICILVisitor; + if (typedVisitor != null) return typedVisitor.VisitAssemblyRefBlock(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public AssemblyRefBlockContext assemblyRefBlock() { + AssemblyRefBlockContext _localctx = new AssemblyRefBlockContext(Context, State); + EnterRule(_localctx, 334, RULE_assemblyRefBlock); + BeginSubtree(); Actions.BeginSemanticRoot(_localctx); + try { + EnterOuterAlt(_localctx, 1); + { + State = 3407; + assemblyRefHead(); + State = 3408; + Match(T__16); + State = 3409; + assemblyRefDecls(); + State = 3410; + Match(T__17); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); + ExitRule(); + } + return _localctx; + } + public partial class AssemblyRefHeadContext : ParserRuleContext { [System.Diagnostics.DebuggerNonUserCode] public AsmAttrContext asmAttr() { return GetRuleContext(0); @@ -17223,38 +17392,38 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public AssemblyRefHeadContext assemblyRefHead() { AssemblyRefHeadContext _localctx = new AssemblyRefHeadContext(Context, State); - EnterRule(_localctx, 334, RULE_assemblyRefHead); + EnterRule(_localctx, 336, RULE_assemblyRefHead); try { - State = 3328; + State = 3424; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,168,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3316; + State = 3412; Match(T__24); - State = 3317; + State = 3413; Match(T__39); - State = 3318; + State = 3414; asmAttr(); - State = 3319; + State = 3415; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3321; + State = 3417; Match(T__24); - State = 3322; + State = 3418; Match(T__39); - State = 3323; + State = 3419; asmAttr(); - State = 3324; + State = 3420; dottedName(); - State = 3325; + State = 3421; Match(T__33); - State = 3326; + State = 3422; dottedName(); } break; @@ -17294,22 +17463,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public AssemblyRefDeclsContext assemblyRefDecls() { AssemblyRefDeclsContext _localctx = new AssemblyRefDeclsContext(Context, State); - EnterRule(_localctx, 336, RULE_assemblyRefDecls); + EnterRule(_localctx, 338, RULE_assemblyRefDecls); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3333; + State = 3429; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 36028835673735168L) != 0) || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & 4294975519L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 105555249070081L) != 0)) { { { - State = 3330; + State = 3426; assemblyRefDecl(); } } - State = 3335; + State = 3431; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17350,23 +17519,23 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public AssemblyRefDeclContext assemblyRefDecl() { AssemblyRefDeclContext _localctx = new AssemblyRefDeclContext(Context, State); - EnterRule(_localctx, 338, RULE_assemblyRefDecl); + EnterRule(_localctx, 340, RULE_assemblyRefDecl); try { - State = 3350; + State = 3446; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case HASH: EnterOuterAlt(_localctx, 1); { - State = 3336; + State = 3432; Match(HASH); - State = 3337; + State = 3433; Match(T__35); - State = 3338; + State = 3434; Match(T__29); - State = 3339; + State = 3435; bytes(); - State = 3340; + State = 3436; Match(T__30); } break; @@ -17391,29 +17560,29 @@ public AssemblyRefDeclContext assemblyRefDecl() { case ID: EnterOuterAlt(_localctx, 2); { - State = 3342; + State = 3438; asmOrRefDecl(); } break; case T__170: EnterOuterAlt(_localctx, 3); { - State = 3343; + State = 3439; Match(T__170); - State = 3344; + State = 3440; Match(T__35); - State = 3345; + State = 3441; Match(T__29); - State = 3346; + State = 3442; bytes(); - State = 3347; + State = 3443; Match(T__30); } break; case T__54: EnterOuterAlt(_localctx, 4); { - State = 3349; + State = 3445; Match(T__54); } break; @@ -17432,6 +17601,57 @@ public AssemblyRefDeclContext assemblyRefDecl() { return _localctx; } + public partial class ExptypeBlockContext : ParserRuleContext { + public bool HasSyntaxError; + [System.Diagnostics.DebuggerNonUserCode] public ExptypeHeadContext exptypeHead() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public ExptypeDeclsContext exptypeDecls() { + return GetRuleContext(0); + } + public ExptypeBlockContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_exptypeBlock; } } + [System.Diagnostics.DebuggerNonUserCode] + public override TResult Accept(IParseTreeVisitor visitor) { + ICILVisitor typedVisitor = visitor as ICILVisitor; + if (typedVisitor != null) return typedVisitor.VisitExptypeBlock(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ExptypeBlockContext exptypeBlock() { + ExptypeBlockContext _localctx = new ExptypeBlockContext(Context, State); + EnterRule(_localctx, 342, RULE_exptypeBlock); + BeginSubtree(); Actions.BeginSemanticRoot(_localctx); + try { + EnterOuterAlt(_localctx, 1); + { + State = 3448; + exptypeHead(); + State = 3449; + Match(T__16); + State = 3450; + exptypeDecls(); + State = 3451; + Match(T__17); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); + ExitRule(); + } + return _localctx; + } + public partial class ExptypeHeadContext : ParserRuleContext { [System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() { return GetRuleContext(0); @@ -17458,30 +17678,30 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ExptypeHeadContext exptypeHead() { ExptypeHeadContext _localctx = new ExptypeHeadContext(Context, State); - EnterRule(_localctx, 340, RULE_exptypeHead); + EnterRule(_localctx, 344, RULE_exptypeHead); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3352; + State = 3453; Match(T__49); - State = 3353; + State = 3454; Match(T__39); - State = 3357; + State = 3458; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4618441417868443648L) != 0) || _la==T__171) { { { - State = 3354; + State = 3455; exptAttr(); } } - State = 3359; + State = 3460; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 3360; + State = 3461; dottedName(); } } @@ -17523,28 +17743,28 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ExportHeadContext exportHead() { ExportHeadContext _localctx = new ExportHeadContext(Context, State); - EnterRule(_localctx, 342, RULE_exportHead); + EnterRule(_localctx, 346, RULE_exportHead); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3362; + State = 3463; Match(EXPORT); - State = 3366; + State = 3467; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4618441417868443648L) != 0) || _la==T__171) { { { - State = 3363; + State = 3464; exptAttr(); } } - State = 3368; + State = 3469; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 3369; + State = 3470; dottedName(); } } @@ -17576,83 +17796,83 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ExptAttrContext exptAttr() { ExptAttrContext _localctx = new ExptAttrContext(Context, State); - EnterRule(_localctx, 344, RULE_exptAttr); + EnterRule(_localctx, 348, RULE_exptAttr); try { - State = 3386; + State = 3487; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,173,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3371; + State = 3472; Match(T__51); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3372; + State = 3473; Match(T__50); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3373; + State = 3474; Match(T__171); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 3374; + State = 3475; Match(T__61); - State = 3375; + State = 3476; Match(T__50); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 3376; + State = 3477; Match(T__61); - State = 3377; + State = 3478; Match(T__51); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 3378; + State = 3479; Match(T__61); - State = 3379; + State = 3480; Match(T__62); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 3380; + State = 3481; Match(T__61); - State = 3381; + State = 3482; Match(T__63); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 3382; + State = 3483; Match(T__61); - State = 3383; + State = 3484; Match(T__64); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 3384; + State = 3485; Match(T__61); - State = 3385; + State = 3486; Match(T__65); } break; @@ -17692,22 +17912,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ExptypeDeclsContext exptypeDecls() { ExptypeDeclsContext _localctx = new ExptypeDeclsContext(Context, State); - EnterRule(_localctx, 346, RULE_exptypeDecls); + EnterRule(_localctx, 350, RULE_exptypeDecls); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3391; + State = 3492; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1125938597265408L) != 0) || _la==T__112 || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 3388; + State = 3489; exptypeDecl(); } } - State = 3393; + State = 3494; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17759,69 +17979,69 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ExptypeDeclContext exptypeDecl() { ExptypeDeclContext _localctx = new ExptypeDeclContext(Context, State); - EnterRule(_localctx, 348, RULE_exptypeDecl); + EnterRule(_localctx, 352, RULE_exptypeDecl); try { - State = 3407; + State = 3508; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,175,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3394; + State = 3495; Match(T__20); - State = 3395; + State = 3496; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3396; + State = 3497; Match(T__49); - State = 3397; + State = 3498; Match(T__39); - State = 3398; + State = 3499; slashedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3399; + State = 3500; Match(T__24); - State = 3400; + State = 3501; Match(T__39); - State = 3401; + State = 3502; dottedName(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 3402; + State = 3503; mdtoken(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 3403; + State = 3504; Match(T__49); - State = 3404; + State = 3505; int32(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 3405; + State = 3506; customAttrDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 3406; + State = 3507; compControl(); } break; @@ -17838,6 +18058,57 @@ public ExptypeDeclContext exptypeDecl() { return _localctx; } + public partial class ManifestResBlockContext : ParserRuleContext { + public bool HasSyntaxError; + [System.Diagnostics.DebuggerNonUserCode] public ManifestResHeadContext manifestResHead() { + return GetRuleContext(0); + } + [System.Diagnostics.DebuggerNonUserCode] public ManifestResDeclsContext manifestResDecls() { + return GetRuleContext(0); + } + public ManifestResBlockContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_manifestResBlock; } } + [System.Diagnostics.DebuggerNonUserCode] + public override TResult Accept(IParseTreeVisitor visitor) { + ICILVisitor typedVisitor = visitor as ICILVisitor; + if (typedVisitor != null) return typedVisitor.VisitManifestResBlock(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ManifestResBlockContext manifestResBlock() { + ManifestResBlockContext _localctx = new ManifestResBlockContext(Context, State); + EnterRule(_localctx, 354, RULE_manifestResBlock); + BeginSubtree(); Actions.BeginSemanticRoot(_localctx); + try { + EnterOuterAlt(_localctx, 1); + { + State = 3510; + manifestResHead(); + State = 3511; + Match(T__16); + State = 3512; + manifestResDecls(); + State = 3513; + Match(T__17); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); + ExitRule(); + } + return _localctx; + } + public partial class ManifestResHeadContext : ParserRuleContext { [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode MRESOURCE() { return GetToken(CILParser.MRESOURCE, 0); } [System.Diagnostics.DebuggerNonUserCode] public DottedNameContext[] dottedName() { @@ -17868,59 +18139,59 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ManifestResHeadContext manifestResHead() { ManifestResHeadContext _localctx = new ManifestResHeadContext(Context, State); - EnterRule(_localctx, 350, RULE_manifestResHead); + EnterRule(_localctx, 356, RULE_manifestResHead); int _la; try { - State = 3428; + State = 3534; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,178,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3409; + State = 3515; Match(MRESOURCE); - State = 3413; + State = 3519; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__50 || _la==T__51) { { { - State = 3410; + State = 3516; manresAttr(); } } - State = 3415; + State = 3521; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 3416; + State = 3522; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3417; + State = 3523; Match(MRESOURCE); - State = 3421; + State = 3527; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__50 || _la==T__51) { { { - State = 3418; + State = 3524; manresAttr(); } } - State = 3423; + State = 3529; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 3424; + State = 3530; dottedName(); - State = 3425; + State = 3531; Match(T__33); - State = 3426; + State = 3532; dottedName(); } break; @@ -17954,12 +18225,12 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ManresAttrContext manresAttr() { ManresAttrContext _localctx = new ManresAttrContext(Context, State); - EnterRule(_localctx, 352, RULE_manresAttr); + EnterRule(_localctx, 358, RULE_manresAttr); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3430; + State = 3536; _la = TokenStream.LA(1); if ( !(_la==T__50 || _la==T__51) ) { ErrorHandler.RecoverInline(this); @@ -18004,22 +18275,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ManifestResDeclsContext manifestResDecls() { ManifestResDeclsContext _localctx = new ManifestResDeclsContext(Context, State); - EnterRule(_localctx, 354, RULE_manifestResDecls); + EnterRule(_localctx, 360, RULE_manifestResDecls); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3435; + State = 3541; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38690422784L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 3432; + State = 3538; manifestResDecl(); } } - State = 3437; + State = 3543; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -18065,32 +18336,32 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ManifestResDeclContext manifestResDecl() { ManifestResDeclContext _localctx = new ManifestResDeclContext(Context, State); - EnterRule(_localctx, 356, RULE_manifestResDecl); + EnterRule(_localctx, 362, RULE_manifestResDecl); try { - State = 3448; + State = 3554; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__20: EnterOuterAlt(_localctx, 1); { - State = 3438; + State = 3544; Match(T__20); - State = 3439; + State = 3545; dottedName(); - State = 3440; + State = 3546; Match(T__43); - State = 3441; + State = 3547; int32(); } break; case T__24: EnterOuterAlt(_localctx, 2); { - State = 3443; + State = 3549; Match(T__24); - State = 3444; + State = 3550; Match(T__39); - State = 3445; + State = 3551; dottedName(); } break; @@ -18103,7 +18374,7 @@ public ManifestResDeclContext manifestResDecl() { case ID: EnterOuterAlt(_localctx, 3); { - State = 3446; + State = 3552; customAttrDecl(); } break; @@ -18117,7 +18388,7 @@ public ManifestResDeclContext manifestResDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 4); { - State = 3447; + State = 3553; compControl(); } break; @@ -18154,7 +18425,7 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { } private static int[] _serializedATN = { - 4,1,305,3451,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, + 4,1,305,3557,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, @@ -18181,39 +18452,45 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 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,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,5,1,367,8,1,10, - 1,12,1,370,9,1,1,1,1,1,1,1,1,1,1,1,3,1,377,8,1,1,2,1,2,1,3,1,3,1,3,5,3, - 384,8,3,10,3,12,3,387,9,3,1,3,1,3,1,3,1,4,5,4,393,8,4,10,4,12,4,396,9, - 4,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5, + 2,177,7,177,2,178,7,178,2,179,7,179,2,180,7,180,2,181,7,181,1,0,1,0,1, + 1,1,1,1,1,1,1,1,1,1,1,5,1,373,8,1,10,1,12,1,376,9,1,1,1,1,1,1,1,1,1,1, + 1,3,1,383,8,1,1,2,1,2,1,3,1,3,1,3,5,3,390,8,3,10,3,12,3,393,9,3,1,3,1, + 3,1,3,1,4,5,4,399,8,4,10,4,12,4,402,9,4,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1, + 5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5, + 1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1, + 5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5, 1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1, - 5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,448, - 8,5,1,6,1,6,1,6,1,7,1,7,1,7,1,8,1,8,1,8,1,8,1,9,1,9,1,9,1,10,1,10,1,10, - 1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,12,1,12,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,489,8,13,1,14,1,14,1, - 15,1,15,1,15,5,15,496,8,15,10,15,12,15,499,9,15,1,15,1,15,1,16,1,16,1, - 17,1,17,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1, - 18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,3,18,528,8,18,1,19,1,19,3,19, - 532,8,19,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1, - 20,1,20,1,20,1,20,3,20,550,8,20,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21, - 1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21, - 1,21,1,21,1,21,3,21,577,8,21,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1, - 22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,3,22,600, - 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,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,636,8,23,1,24,1,24,1,25,1,25,1, - 25,1,25,1,25,1,25,3,25,646,8,25,1,26,1,26,1,26,1,27,1,27,5,27,653,8,27, - 10,27,12,27,656,9,27,1,28,1,28,1,28,1,28,1,28,1,28,1,28,5,28,665,8,28, - 10,28,12,28,668,9,28,1,29,1,29,1,30,1,30,3,30,674,8,30,1,31,1,31,1,31, - 1,31,1,31,1,31,1,31,1,31,1,31,3,31,685,8,31,1,32,1,32,1,32,1,32,1,32,1, - 32,3,32,693,8,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,34,1,34,1,34,1,34,5,34,714,8,34,10,34,12,34,717, - 9,34,1,35,1,35,1,35,1,35,1,35,1,35,1,36,1,36,1,36,1,37,1,37,5,37,730,8, - 37,10,37,12,37,733,9,37,1,37,1,37,1,37,1,37,1,37,1,38,1,38,1,38,1,38,1, + 5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,490,8,5,1,6,1,6,1,6,1,6,1,7,1,7, + 1,7,1,7,1,8,1,8,1,8,1,8,1,8,1,9,1,9,1,9,1,9,1,10,1,10,1,10,1,10,1,11,1, + 11,1,11,1,11,1,11,1,11,1,11,1,12,1,12,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,536,8,13,1,14,1,14,1,15,1,15, + 1,15,1,15,1,15,5,15,545,8,15,10,15,12,15,548,9,15,1,15,1,15,1,16,1,16, + 1,17,1,17,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18, + 1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,3,18,577,8,18,1,19,1,19,3, + 19,581,8,19,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20, + 1,20,1,20,1,20,1,20,3,20,599,8,20,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1, + 21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1, + 21,1,21,1,21,1,21,3,21,626,8,21,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22, + 1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,3,22, + 649,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,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,685,8,23,1,24,1,24,1,25,1,25, + 1,25,1,25,1,25,1,25,3,25,695,8,25,1,26,1,26,1,26,1,27,1,27,5,27,702,8, + 27,10,27,12,27,705,9,27,1,28,1,28,1,28,1,28,1,28,1,28,1,28,5,28,714,8, + 28,10,28,12,28,717,9,28,1,29,1,29,1,30,1,30,3,30,723,8,30,1,31,1,31,1, + 31,1,31,1,31,1,31,1,31,1,31,1,31,3,31,734,8,31,1,32,1,32,1,32,1,32,1,32, + 1,32,1,32,1,32,1,32,1,32,1,32,3,32,747,8,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,34,1,34,1,34,1,34,5, + 34,768,8,34,10,34,12,34,771,9,34,1,35,1,35,1,35,1,35,1,35,1,35,1,36,1, + 36,1,36,1,36,1,37,1,37,1,37,1,37,5,37,787,8,37,10,37,12,37,790,9,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,38,1, 38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1, 38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1, - 38,1,38,1,38,1,38,1,38,3,38,777,8,38,1,39,1,39,1,39,3,39,782,8,39,1,40, - 1,40,1,40,3,40,787,8,40,1,41,5,41,790,8,41,10,41,12,41,793,9,41,1,42,1, - 42,1,42,5,42,798,8,42,10,42,12,42,801,9,42,1,42,1,42,1,43,1,43,1,44,1, + 38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1, + 38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,3, + 38,862,8,38,1,39,1,39,1,39,1,39,1,39,3,39,869,8,39,1,40,1,40,1,40,1,40, + 1,40,3,40,876,8,40,1,41,5,41,879,8,41,10,41,12,41,882,9,41,1,42,1,42,1, + 42,1,42,5,42,888,8,42,10,42,12,42,891,9,42,1,42,1,42,1,42,1,43,1,43,1, 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, @@ -18221,35 +18498,35 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, - 44,1,44,1,44,1,44,3,44,910,8,44,1,45,1,45,5,45,914,8,45,10,45,12,45,917, - 9,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,5,45,930,8, - 45,10,45,12,45,933,9,45,1,45,1,45,1,45,3,45,938,8,45,1,46,1,46,1,47,1, - 47,3,47,944,8,47,1,48,1,48,1,49,5,49,949,8,49,10,49,12,49,952,9,49,1,50, - 1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50, - 1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,3,50,979,8,50,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,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,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,1057,8,51,3,51,1059,8,51,1,52,1,52,1,52,1, - 52,1,52,1,53,1,53,1,53,1,53,1,53,1,53,1,53,3,53,1073,8,53,1,53,1,53,5, - 53,1077,8,53,10,53,12,53,1080,9,53,1,53,1,53,1,53,1,53,1,53,1,53,3,53, - 1088,8,53,3,53,1090,8,53,1,54,1,54,1,54,1,54,1,54,5,54,1097,8,54,10,54, - 12,54,1100,9,54,1,54,1,54,1,54,1,54,1,55,1,55,1,55,1,55,1,55,5,55,1111, - 8,55,10,55,12,55,1114,9,55,1,55,1,55,1,55,1,55,1,56,1,56,1,56,1,56,1,56, - 5,56,1125,8,56,10,56,12,56,1128,9,56,1,56,1,56,1,56,1,56,1,56,3,56,1135, - 8,56,1,57,1,57,1,57,1,57,1,57,1,57,3,57,1143,8,57,1,57,1,57,3,57,1147, - 8,57,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58, + 44,1,44,1,44,1,44,1,44,3,44,1001,8,44,1,45,1,45,5,45,1005,8,45,10,45,12, + 45,1008,9,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,5, + 45,1021,8,45,10,45,12,45,1024,9,45,1,45,1,45,1,45,3,45,1029,8,45,1,46, + 1,46,1,47,1,47,3,47,1035,8,47,1,48,1,48,1,49,5,49,1040,8,49,10,49,12,49, + 1043,9,49,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50, + 1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,3,50, + 1070,8,50,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,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,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,1148,8,51,3,51,1150,8,51, + 1,52,1,52,1,52,1,52,1,52,1,53,1,53,1,53,1,53,1,53,1,53,1,53,3,53,1164, + 8,53,1,53,1,53,5,53,1168,8,53,10,53,12,53,1171,9,53,1,53,1,53,1,53,1,53, + 1,53,1,53,3,53,1179,8,53,3,53,1181,8,53,1,54,1,54,1,54,1,54,1,54,5,54, + 1188,8,54,10,54,12,54,1191,9,54,1,54,1,54,1,54,1,54,1,55,1,55,1,55,1,55, + 1,55,5,55,1202,8,55,10,55,12,55,1205,9,55,1,55,1,55,1,55,1,55,1,56,1,56, + 1,56,1,56,1,56,5,56,1216,8,56,10,56,12,56,1219,9,56,1,56,1,56,1,56,1,56, + 1,56,3,56,1226,8,56,1,57,1,57,1,57,1,57,1,57,1,57,3,57,1234,8,57,1,57, + 1,57,3,57,1238,8,57,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58, 1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58, - 1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,3,58,1186,8,58,1,59, - 1,59,1,59,1,59,5,59,1192,8,59,10,59,12,59,1195,9,59,1,59,1,59,1,59,1,60, - 5,60,1201,8,60,10,60,12,60,1204,9,60,1,61,1,61,1,61,1,61,1,61,3,61,1211, - 8,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,3,62,1230,8,62,1,63,1,63,1,63,1,63,1,63,1,63,5,63, - 1238,8,63,10,63,12,63,1241,9,63,3,63,1243,8,63,1,64,1,64,1,64,1,64,1,64, + 1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,3,58, + 1277,8,58,1,59,1,59,1,59,1,59,5,59,1283,8,59,10,59,12,59,1286,9,59,1,59, + 1,59,1,59,1,60,5,60,1292,8,60,10,60,12,60,1295,9,60,1,61,1,61,1,61,1,61, + 1,61,3,61,1302,8,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,3,62,1321,8,62,1,63,1,63,1,63,1,63, + 1,63,1,63,5,63,1329,8,63,10,63,12,63,1332,9,63,3,63,1334,8,63,1,64,1,64, 1,64,1,64,1,64,1,64,1,64,1,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,1267,8,64,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, + 1,64,1,64,1,64,1,64,1,64,1,64,3,64,1358,8,64,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, @@ -18259,146 +18536,146 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, - 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,3,65,1414,8,65, - 1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,3,66,1424,8,66,1,67,1,67,1,67, - 1,67,1,67,5,67,1431,8,67,10,67,12,67,1434,9,67,3,67,1436,8,67,1,68,1,68, - 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, + 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, + 3,65,1505,8,65,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,3,66,1515,8,66, + 1,67,1,67,1,67,1,67,1,67,5,67,1522,8,67,10,67,12,67,1525,9,67,3,67,1527, + 8,67,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, - 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,3,68,1518,8,68,1,69,1,69,1,69, - 1,69,1,69,5,69,1525,8,69,10,69,12,69,1528,9,69,1,70,1,70,1,70,1,70,1,70, + 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,3,68,1609,8,68, + 1,69,1,69,1,69,1,69,1,69,5,69,1616,8,69,10,69,12,69,1619,9,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,1,70, - 1,70,1,70,1,70,1,70,1,70,1,70,1,70,1,70,1,70,1,70,3,70,1559,8,70,1,71, - 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, + 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, + 1650,8,70,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, - 1,71,3,71,1619,8,71,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72, + 1,71,1,71,1,71,1,71,3,71,1710,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,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,1,72,1,72,1,72,1,72,1,72, - 3,72,1659,8,72,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73, - 1,73,1,73,1,73,3,73,1675,8,73,1,74,1,74,1,74,1,74,1,75,1,75,1,75,1,75, - 3,75,1685,8,75,1,75,1,75,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76, + 1,72,1,72,1,72,3,72,1750,8,72,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73, + 1,73,1,73,1,73,1,73,1,73,1,73,3,73,1766,8,73,1,74,1,74,1,74,1,74,1,75, + 1,75,1,75,1,75,3,75,1776,8,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, - 3,76,1712,8,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,1736,8,76, - 1,77,1,77,1,77,1,77,5,77,1742,8,77,10,77,12,77,1745,9,77,1,77,3,77,1748, - 8,77,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78, - 3,78,1763,8,78,1,79,1,79,1,79,5,79,1768,8,79,10,79,12,79,1771,9,79,1,79, - 1,79,1,80,1,80,1,80,1,80,1,81,1,81,1,82,1,82,1,82,1,82,1,82,1,82,1,82, + 1,76,1,76,1,76,3,76,1803,8,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,1827,8,76,1,77,1,77,1,77,1,77,5,77,1833,8,77,10,77,12,77,1836,9,77, + 1,77,3,77,1839,8,77,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78, + 1,78,1,78,1,78,3,78,1854,8,78,1,79,1,79,1,79,5,79,1859,8,79,10,79,12,79, + 1862,9,79,1,79,1,79,1,80,1,80,1,80,1,80,1,81,1,81,1,82,1,82,1,82,1,82, + 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, - 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,3,82, - 1815,8,82,1,83,1,83,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1825,8,84,1,84, - 1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84, - 1,84,3,84,1843,8,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84, - 1,84,1,84,1,84,1,84,1,84,1,84,3,84,1861,8,84,1,85,1,85,1,85,1,85,1,85, - 1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,3,85,1880, - 8,85,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86, - 1,86,1,86,1,86,1,86,1,86,1,86,3,86,1901,8,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,88,1,88,1,88,1,88,1,88,3,88,1920, - 8,88,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89, - 3,89,1935,8,89,1,90,1,90,1,90,1,90,5,90,1941,8,90,10,90,12,90,1944,9,90, - 1,90,1,90,1,90,1,91,1,91,1,91,1,91,1,91,1,91,3,91,1955,8,91,1,92,1,92, - 1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92, - 1,92,1,92,3,92,1975,8,92,1,93,1,93,1,93,5,93,1980,8,93,10,93,12,93,1983, - 9,93,1,94,1,94,3,94,1987,8,94,1,94,1,94,1,94,1,95,1,95,1,95,1,95,5,95, - 1996,8,95,10,95,12,95,1999,9,95,1,95,1,95,1,95,1,96,1,96,1,96,1,96,1,96, - 1,97,3,97,2010,8,97,1,97,1,97,1,98,1,98,1,98,1,98,1,98,1,98,1,98,1,99, + 1,82,1,82,3,82,1906,8,82,1,83,1,83,1,84,1,84,1,84,1,84,1,84,1,84,3,84, + 1916,8,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84, + 1,84,1,84,1,84,1,84,3,84,1934,8,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84, + 1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1952,8,84,1,85,1,85, + 1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85, + 1,85,3,85,1971,8,85,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86, + 1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,3,86,1992,8,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,88,1,88,1,88,1,88, + 1,88,3,88,2011,8,88,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89, + 1,89,1,89,1,89,3,89,2026,8,89,1,90,1,90,1,90,1,90,5,90,2032,8,90,10,90, + 12,90,2035,9,90,1,90,1,90,1,90,1,91,1,91,1,91,1,91,1,91,1,91,3,91,2046, + 8,91,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92, + 1,92,1,92,1,92,1,92,1,92,3,92,2066,8,92,1,93,1,93,1,93,5,93,2071,8,93, + 10,93,12,93,2074,9,93,1,94,1,94,3,94,2078,8,94,1,94,1,94,1,94,1,95,1,95, + 1,95,1,95,5,95,2087,8,95,10,95,12,95,2090,9,95,1,95,1,95,1,95,1,96,1,96, + 1,96,1,96,1,96,1,97,3,97,2101,8,97,1,97,1,97,1,98,1,98,1,98,1,98,1,98, + 1,98,1,98,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, - 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,2118, - 8,99,10,99,12,99,2121,9,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,2130, - 8,99,10,99,12,99,2133,9,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, - 1,99,1,99,5,99,2146,8,99,10,99,12,99,2149,9,99,1,99,1,99,1,99,1,99,1,99, - 1,99,1,99,1,99,1,99,5,99,2160,8,99,10,99,12,99,2163,9,99,1,99,1,99,1,99, - 1,99,1,99,1,99,3,99,2171,8,99,1,100,1,100,1,100,1,100,1,100,1,100,1,100, - 1,100,1,100,1,100,1,100,5,100,2184,8,100,10,100,12,100,2187,9,100,1,100, - 1,100,1,100,1,100,1,100,1,100,1,101,1,101,1,101,1,101,1,101,1,101,1,101, + 1,99,5,99,2209,8,99,10,99,12,99,2212,9,99,1,99,1,99,1,99,1,99,1,99,1,99, + 1,99,5,99,2221,8,99,10,99,12,99,2224,9,99,1,99,1,99,1,99,1,99,1,99,1,99, + 1,99,1,99,1,99,1,99,1,99,5,99,2237,8,99,10,99,12,99,2240,9,99,1,99,1,99, + 1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,2251,8,99,10,99,12,99,2254,9,99, + 1,99,1,99,1,99,1,99,1,99,1,99,3,99,2262,8,99,1,100,1,100,1,100,1,100,1, + 100,1,100,1,100,1,100,1,100,1,100,1,100,5,100,2275,8,100,10,100,12,100, + 2278,9,100,1,100,1,100,1,100,1,100,1,100,1,100,1,101,1,101,1,101,1,101, 1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101, 1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101, - 1,101,1,101,1,101,3,101,2229,8,101,1,102,1,102,1,102,1,102,1,102,1,102, - 1,102,1,102,1,102,3,102,2240,8,102,1,103,1,103,1,103,1,103,1,103,3,103, - 2247,8,103,1,104,1,104,1,104,1,104,1,104,1,104,3,104,2255,8,104,1,105, - 1,105,1,105,1,105,5,105,2261,8,105,10,105,12,105,2264,9,105,1,105,1,105, - 1,105,1,105,1,105,1,105,1,105,1,105,5,105,2274,8,105,10,105,12,105,2277, - 9,105,1,105,1,105,1,105,3,105,2282,8,105,1,106,1,106,1,106,1,106,3,106, - 2288,8,106,1,107,5,107,2291,8,107,10,107,12,107,2294,9,107,1,108,1,108, + 1,101,1,101,1,101,1,101,1,101,1,101,3,101,2320,8,101,1,102,1,102,1,102, + 1,102,1,102,1,102,1,102,1,102,1,102,3,102,2331,8,102,1,103,1,103,1,103, + 1,103,1,103,3,103,2338,8,103,1,104,1,104,1,104,1,104,1,104,1,104,3,104, + 2346,8,104,1,105,1,105,1,105,1,105,5,105,2352,8,105,10,105,12,105,2355, + 9,105,1,105,1,105,1,105,1,105,1,105,1,105,1,105,1,105,5,105,2365,8,105, + 10,105,12,105,2368,9,105,1,105,1,105,1,105,3,105,2373,8,105,1,106,1,106, + 1,106,1,106,3,106,2379,8,106,1,107,5,107,2382,8,107,10,107,12,107,2385, + 9,107,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108, 1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108, - 1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108, - 3,108,2322,8,108,1,109,1,109,1,109,1,109,5,109,2328,8,109,10,109,12,109, - 2331,9,109,1,109,1,109,1,109,1,109,1,109,1,109,1,109,1,110,1,110,1,110, - 1,110,3,110,2344,8,110,1,111,5,111,2347,8,111,10,111,12,111,2350,9,111, + 1,108,1,108,1,108,3,108,2413,8,108,1,109,1,109,1,109,1,109,5,109,2419, + 8,109,10,109,12,109,2422,9,109,1,109,1,109,1,109,1,109,1,109,1,109,1,109, + 1,110,1,110,1,110,1,110,3,110,2435,8,110,1,111,5,111,2438,8,111,10,111, + 12,111,2441,9,111,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112, 1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112, - 1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,3,112,2374, - 8,112,1,113,1,113,1,113,1,113,1,113,1,113,1,113,3,113,2383,8,113,1,114, - 1,114,1,114,1,114,1,114,1,114,1,114,4,114,2392,8,114,11,114,12,114,2393, - 1,114,1,114,3,114,2398,8,114,1,115,1,115,1,115,5,115,2403,8,115,10,115, - 12,115,2406,9,115,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116, - 1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,3,116,2425,8,116,1,117, - 1,117,1,117,1,117,1,117,1,117,1,117,5,117,2434,8,117,10,117,12,117,2437, - 9,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,5,117, - 2449,8,117,10,117,12,117,2452,9,117,1,117,1,117,1,118,1,118,1,118,1,118, + 1,112,3,112,2465,8,112,1,113,1,113,1,113,1,113,1,113,1,113,1,113,3,113, + 2474,8,113,1,114,1,114,1,114,1,114,1,114,1,114,1,114,4,114,2483,8,114, + 11,114,12,114,2484,1,114,1,114,3,114,2489,8,114,1,115,1,115,1,115,5,115, + 2494,8,115,10,115,12,115,2497,9,115,1,116,1,116,1,116,1,116,1,116,1,116, + 1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,3,116, + 2516,8,116,1,117,1,117,1,117,1,117,1,117,1,117,1,117,5,117,2525,8,117, + 10,117,12,117,2528,9,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117, + 1,117,1,117,5,117,2540,8,117,10,117,12,117,2543,9,117,1,117,1,117,1,118, 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, - 1,118,1,118,3,118,2498,8,118,1,119,1,119,1,119,1,119,1,119,1,119,1,119, - 1,119,3,119,2508,8,119,3,119,2510,8,119,1,119,1,119,1,119,5,119,2515,8, - 119,10,119,12,119,2518,9,119,1,119,1,119,1,119,3,119,2523,8,119,1,120, - 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, + 1,118,1,118,1,118,1,118,1,118,3,118,2589,8,118,1,119,1,119,1,119,1,119, + 1,119,1,119,1,119,1,119,3,119,2599,8,119,3,119,2601,8,119,1,119,1,119, + 1,119,5,119,2606,8,119,10,119,12,119,2609,9,119,1,119,1,119,1,119,3,119, + 2614,8,119,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, - 1,120,1,120,1,120,1,120,1,120,3,120,2567,8,120,1,121,1,121,1,121,1,121, - 1,121,1,121,1,121,3,121,2576,8,121,1,122,1,122,1,122,1,122,1,122,1,122, + 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,3,120,2658,8,120,1,121, + 1,121,1,121,1,121,1,121,1,121,1,121,3,121,2667,8,121,1,122,1,122,1,122, 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, - 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,3,122,2616,8,122,1,123, - 5,123,2619,8,123,10,123,12,123,2622,9,123,1,124,1,124,1,124,1,124,1,124, + 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,3,122, + 2707,8,122,1,123,5,123,2710,8,123,10,123,12,123,2713,9,123,1,124,1,124, 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, - 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,3,124,2661,8,124,1,125, - 1,125,3,125,2665,8,125,1,125,1,125,1,126,1,126,1,126,1,126,1,126,1,126, - 3,126,2675,8,126,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,128,1,128,1,128,1,128,1,128,1,128,1,128,3,128, - 2697,8,128,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,5,129,2707, - 8,129,10,129,12,129,2710,9,129,1,129,1,129,1,129,1,129,1,129,1,129,5,129, - 2718,8,129,10,129,12,129,2721,9,129,1,129,1,129,1,129,1,129,1,129,1,129, - 1,129,1,129,1,129,1,129,5,129,2733,8,129,10,129,12,129,2736,9,129,1,129, - 1,129,1,129,1,129,1,129,1,129,1,129,1,129,5,129,2746,8,129,10,129,12,129, - 2749,9,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,5,129,2759, - 8,129,10,129,12,129,2762,9,129,3,129,2764,8,129,1,130,1,130,1,130,1,130, - 1,131,1,131,3,131,2772,8,131,1,132,1,132,1,132,1,132,1,133,1,133,1,133, - 1,134,1,134,1,134,4,134,2784,8,134,11,134,12,134,2785,1,135,1,135,1,135, + 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,3,124, + 2752,8,124,1,125,1,125,3,125,2756,8,125,1,125,1,125,1,126,1,126,1,126, + 1,126,1,126,1,126,3,126,2766,8,126,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,128,1,128,1,128,1,128,1,128, + 1,128,1,128,3,128,2788,8,128,1,129,1,129,1,129,1,129,1,129,1,129,1,129, + 1,129,5,129,2798,8,129,10,129,12,129,2801,9,129,1,129,1,129,1,129,1,129, + 1,129,1,129,5,129,2809,8,129,10,129,12,129,2812,9,129,1,129,1,129,1,129, + 1,129,1,129,1,129,1,129,1,129,1,129,1,129,5,129,2824,8,129,10,129,12,129, + 2827,9,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,5,129,2837, + 8,129,10,129,12,129,2840,9,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129, + 1,129,5,129,2850,8,129,10,129,12,129,2853,9,129,3,129,2855,8,129,1,130, + 1,130,1,130,1,130,1,131,1,131,3,131,2863,8,131,1,132,1,132,1,132,1,132, + 1,133,1,133,1,133,1,134,1,134,1,134,4,134,2875,8,134,11,134,12,134,2876, 1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135, - 1,135,3,135,2804,8,135,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136, - 1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,3,136,2822,8,136,1,137, - 1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,3,137, - 2836,8,137,1,138,1,138,1,138,1,139,1,139,1,140,1,140,1,141,1,141,1,141, + 1,135,1,135,1,135,1,135,3,135,2895,8,135,1,136,1,136,1,136,1,136,1,136, + 1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,3,136, + 2913,8,136,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137, + 1,137,1,137,3,137,2927,8,137,1,138,1,138,1,138,1,139,1,139,1,140,1,140, 1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141, - 3,141,2860,8,141,1,142,1,142,1,142,1,143,1,143,1,143,1,143,1,143,1,143, - 1,143,3,143,2872,8,143,1,144,1,144,1,144,3,144,2877,8,144,1,145,1,145, - 1,145,1,145,1,145,4,145,2884,8,145,11,145,12,145,2885,3,145,2888,8,145, - 1,146,1,146,1,146,5,146,2893,8,146,10,146,12,146,2896,9,146,1,146,1,146, - 1,147,1,147,1,147,1,147,1,147,3,147,2905,8,147,1,148,1,148,1,148,1,148, + 1,141,1,141,1,141,3,141,2951,8,141,1,142,1,142,1,142,1,143,1,143,1,143, + 1,143,1,143,1,143,1,143,3,143,2963,8,143,1,144,1,144,1,144,3,144,2968, + 8,144,1,145,1,145,1,145,1,145,1,145,4,145,2975,8,145,11,145,12,145,2976, + 3,145,2979,8,145,1,146,1,146,1,146,5,146,2984,8,146,10,146,12,146,2987, + 9,146,1,146,1,146,1,147,1,147,1,147,1,147,1,147,3,147,2996,8,147,1,148, 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, - 1,148,1,148,3,148,2973,8,148,1,149,1,149,1,149,1,149,1,149,1,149,1,149, + 1,148,1,148,1,148,1,148,1,148,3,148,3064,8,148,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, - 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,3,149,3050,8,149,1,150, - 1,150,1,150,5,150,3055,8,150,10,150,12,150,3058,9,150,1,151,1,151,1,152, - 1,152,1,152,3,152,3065,8,152,1,153,1,153,1,153,1,153,1,153,1,153,1,153, + 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,3,149, + 3141,8,149,1,150,1,150,1,150,5,150,3146,8,150,10,150,12,150,3149,9,150, + 1,151,1,151,1,152,1,152,1,152,3,152,3156,8,152,1,153,1,153,1,153,1,153, 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, @@ -18410,1075 +18687,1105 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, - 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,3,153,3215,8,153, - 1,154,1,154,5,154,3219,8,154,10,154,12,154,3222,9,154,1,155,1,155,5,155, - 3226,8,155,10,155,12,155,3229,9,155,1,156,5,156,3232,8,156,10,156,12,156, - 3235,9,156,1,157,5,157,3238,8,157,10,157,12,157,3241,9,157,1,158,5,158, - 3244,8,158,10,158,12,158,3247,9,158,1,159,5,159,3250,8,159,10,159,12,159, - 3253,9,159,1,160,5,160,3256,8,160,10,160,12,160,3259,9,160,1,161,5,161, - 3262,8,161,10,161,12,161,3265,9,161,1,162,5,162,3268,8,162,10,162,12,162, - 3271,9,162,1,163,1,163,1,163,1,163,3,163,3277,8,163,1,164,5,164,3280,8, - 164,10,164,12,164,3283,9,164,1,165,1,165,1,165,3,165,3288,8,165,1,166, - 1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166, + 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, + 3,153,3306,8,153,1,154,1,154,5,154,3310,8,154,10,154,12,154,3313,9,154, + 1,155,1,155,5,155,3317,8,155,10,155,12,155,3320,9,155,1,156,5,156,3323, + 8,156,10,156,12,156,3326,9,156,1,157,5,157,3329,8,157,10,157,12,157,3332, + 9,157,1,158,5,158,3335,8,158,10,158,12,158,3338,9,158,1,159,5,159,3341, + 8,159,10,159,12,159,3344,9,159,1,160,5,160,3347,8,160,10,160,12,160,3350, + 9,160,1,161,5,161,3353,8,161,10,161,12,161,3356,9,161,1,162,5,162,3359, + 8,162,10,162,12,162,3362,9,162,1,163,1,163,1,163,1,163,3,163,3368,8,163, + 1,164,5,164,3371,8,164,10,164,12,164,3374,9,164,1,165,1,165,1,165,3,165, + 3379,8,165,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166, 1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166, - 3,166,3315,8,166,1,167,1,167,1,167,1,167,1,167,1,167,1,167,1,167,1,167, - 1,167,1,167,1,167,3,167,3329,8,167,1,168,5,168,3332,8,168,10,168,12,168, - 3335,9,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,169,3,169,3351,8,169,1,170,1,170,1,170,5,170,3356, - 8,170,10,170,12,170,3359,9,170,1,170,1,170,1,171,1,171,5,171,3365,8,171, - 10,171,12,171,3368,9,171,1,171,1,171,1,172,1,172,1,172,1,172,1,172,1,172, - 1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,3,172,3387,8,172, - 1,173,5,173,3390,8,173,10,173,12,173,3393,9,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,3,174,3408,8,174, - 1,175,1,175,5,175,3412,8,175,10,175,12,175,3415,9,175,1,175,1,175,1,175, - 5,175,3420,8,175,10,175,12,175,3423,9,175,1,175,1,175,1,175,1,175,3,175, - 3429,8,175,1,176,1,176,1,177,5,177,3434,8,177,10,177,12,177,3437,9,177, - 1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,3,178,3449, - 8,178,1,178,0,1,68,179,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,0,14,6,0,1,15,199,199,243,243,247, - 247,264,264,289,289,5,0,16,16,199,199,243,243,264,264,288,289,1,0,263, - 264,1,0,173,174,1,0,37,38,1,0,73,74,3,0,2,2,61,61,77,83,2,0,229,229,260, - 261,1,0,95,96,1,0,97,111,2,0,173,173,289,290,2,0,179,179,264,264,1,0,167, - 168,1,0,51,52,3915,0,358,1,0,0,0,2,376,1,0,0,0,4,378,1,0,0,0,6,385,1,0, - 0,0,8,394,1,0,0,0,10,447,1,0,0,0,12,449,1,0,0,0,14,452,1,0,0,0,16,455, - 1,0,0,0,18,459,1,0,0,0,20,462,1,0,0,0,22,465,1,0,0,0,24,472,1,0,0,0,26, - 488,1,0,0,0,28,490,1,0,0,0,30,492,1,0,0,0,32,502,1,0,0,0,34,504,1,0,0, - 0,36,527,1,0,0,0,38,531,1,0,0,0,40,549,1,0,0,0,42,576,1,0,0,0,44,599,1, - 0,0,0,46,635,1,0,0,0,48,637,1,0,0,0,50,645,1,0,0,0,52,647,1,0,0,0,54,654, - 1,0,0,0,56,666,1,0,0,0,58,669,1,0,0,0,60,671,1,0,0,0,62,684,1,0,0,0,64, - 692,1,0,0,0,66,694,1,0,0,0,68,702,1,0,0,0,70,718,1,0,0,0,72,724,1,0,0, - 0,74,727,1,0,0,0,76,776,1,0,0,0,78,781,1,0,0,0,80,786,1,0,0,0,82,791,1, - 0,0,0,84,799,1,0,0,0,86,804,1,0,0,0,88,909,1,0,0,0,90,937,1,0,0,0,92,939, - 1,0,0,0,94,943,1,0,0,0,96,945,1,0,0,0,98,950,1,0,0,0,100,978,1,0,0,0,102, - 1058,1,0,0,0,104,1060,1,0,0,0,106,1089,1,0,0,0,108,1091,1,0,0,0,110,1105, - 1,0,0,0,112,1134,1,0,0,0,114,1146,1,0,0,0,116,1185,1,0,0,0,118,1193,1, - 0,0,0,120,1202,1,0,0,0,122,1210,1,0,0,0,124,1229,1,0,0,0,126,1242,1,0, - 0,0,128,1266,1,0,0,0,130,1413,1,0,0,0,132,1423,1,0,0,0,134,1435,1,0,0, - 0,136,1517,1,0,0,0,138,1519,1,0,0,0,140,1558,1,0,0,0,142,1618,1,0,0,0, - 144,1658,1,0,0,0,146,1674,1,0,0,0,148,1676,1,0,0,0,150,1680,1,0,0,0,152, - 1735,1,0,0,0,154,1747,1,0,0,0,156,1762,1,0,0,0,158,1769,1,0,0,0,160,1774, - 1,0,0,0,162,1778,1,0,0,0,164,1814,1,0,0,0,166,1816,1,0,0,0,168,1860,1, - 0,0,0,170,1879,1,0,0,0,172,1900,1,0,0,0,174,1902,1,0,0,0,176,1919,1,0, - 0,0,178,1934,1,0,0,0,180,1942,1,0,0,0,182,1954,1,0,0,0,184,1974,1,0,0, - 0,186,1981,1,0,0,0,188,1984,1,0,0,0,190,1997,1,0,0,0,192,2003,1,0,0,0, - 194,2009,1,0,0,0,196,2013,1,0,0,0,198,2170,1,0,0,0,200,2172,1,0,0,0,202, - 2228,1,0,0,0,204,2239,1,0,0,0,206,2246,1,0,0,0,208,2254,1,0,0,0,210,2281, - 1,0,0,0,212,2287,1,0,0,0,214,2292,1,0,0,0,216,2321,1,0,0,0,218,2323,1, - 0,0,0,220,2343,1,0,0,0,222,2348,1,0,0,0,224,2373,1,0,0,0,226,2382,1,0, - 0,0,228,2397,1,0,0,0,230,2404,1,0,0,0,232,2424,1,0,0,0,234,2426,1,0,0, - 0,236,2497,1,0,0,0,238,2522,1,0,0,0,240,2566,1,0,0,0,242,2575,1,0,0,0, - 244,2615,1,0,0,0,246,2620,1,0,0,0,248,2660,1,0,0,0,250,2662,1,0,0,0,252, - 2668,1,0,0,0,254,2676,1,0,0,0,256,2696,1,0,0,0,258,2763,1,0,0,0,260,2765, - 1,0,0,0,262,2771,1,0,0,0,264,2773,1,0,0,0,266,2777,1,0,0,0,268,2783,1, - 0,0,0,270,2803,1,0,0,0,272,2821,1,0,0,0,274,2835,1,0,0,0,276,2837,1,0, - 0,0,278,2840,1,0,0,0,280,2842,1,0,0,0,282,2859,1,0,0,0,284,2861,1,0,0, - 0,286,2871,1,0,0,0,288,2876,1,0,0,0,290,2887,1,0,0,0,292,2894,1,0,0,0, - 294,2904,1,0,0,0,296,2972,1,0,0,0,298,3049,1,0,0,0,300,3056,1,0,0,0,302, - 3059,1,0,0,0,304,3064,1,0,0,0,306,3214,1,0,0,0,308,3220,1,0,0,0,310,3227, - 1,0,0,0,312,3233,1,0,0,0,314,3239,1,0,0,0,316,3245,1,0,0,0,318,3251,1, - 0,0,0,320,3257,1,0,0,0,322,3263,1,0,0,0,324,3269,1,0,0,0,326,3276,1,0, - 0,0,328,3281,1,0,0,0,330,3287,1,0,0,0,332,3314,1,0,0,0,334,3328,1,0,0, - 0,336,3333,1,0,0,0,338,3350,1,0,0,0,340,3352,1,0,0,0,342,3362,1,0,0,0, - 344,3386,1,0,0,0,346,3391,1,0,0,0,348,3407,1,0,0,0,350,3428,1,0,0,0,352, - 3430,1,0,0,0,354,3435,1,0,0,0,356,3448,1,0,0,0,358,359,7,0,0,0,359,1,1, - 0,0,0,360,361,5,288,0,0,361,377,6,1,-1,0,362,363,3,4,2,0,363,364,6,1,-1, - 0,364,365,5,265,0,0,365,367,1,0,0,0,366,362,1,0,0,0,367,370,1,0,0,0,368, - 366,1,0,0,0,368,369,1,0,0,0,369,371,1,0,0,0,370,368,1,0,0,0,371,372,3, - 4,2,0,372,373,6,1,-1,0,373,377,1,0,0,0,374,375,5,264,0,0,375,377,6,1,-1, - 0,376,360,1,0,0,0,376,368,1,0,0,0,376,374,1,0,0,0,377,3,1,0,0,0,378,379, - 7,1,0,0,379,5,1,0,0,0,380,381,5,263,0,0,381,382,6,3,-1,0,382,384,5,266, - 0,0,383,380,1,0,0,0,384,387,1,0,0,0,385,383,1,0,0,0,385,386,1,0,0,0,386, - 388,1,0,0,0,387,385,1,0,0,0,388,389,5,263,0,0,389,390,6,3,-1,0,390,7,1, - 0,0,0,391,393,3,10,5,0,392,391,1,0,0,0,393,396,1,0,0,0,394,392,1,0,0,0, - 394,395,1,0,0,0,395,9,1,0,0,0,396,394,1,0,0,0,397,398,3,74,37,0,398,399, - 5,17,0,0,399,400,3,82,41,0,400,401,5,18,0,0,401,448,1,0,0,0,402,403,3, - 72,36,0,403,404,5,17,0,0,404,405,3,8,4,0,405,406,5,18,0,0,406,448,1,0, - 0,0,407,408,3,234,117,0,408,409,5,17,0,0,409,410,3,246,123,0,410,411,5, - 18,0,0,411,448,1,0,0,0,412,448,3,200,100,0,413,448,3,284,142,0,414,448, - 3,70,35,0,415,448,3,66,33,0,416,448,3,88,44,0,417,448,3,90,45,0,418,448, - 3,22,11,0,419,420,3,334,167,0,420,421,5,17,0,0,421,422,3,336,168,0,422, - 423,5,18,0,0,423,448,1,0,0,0,424,425,3,340,170,0,425,426,5,17,0,0,426, - 427,3,346,173,0,427,428,5,18,0,0,428,448,1,0,0,0,429,430,3,350,175,0,430, - 431,5,17,0,0,431,432,3,354,177,0,432,433,5,18,0,0,433,448,1,0,0,0,434, - 448,3,64,32,0,435,448,3,152,76,0,436,448,3,330,165,0,437,448,3,12,6,0, - 438,448,3,14,7,0,439,448,3,16,8,0,440,448,3,18,9,0,441,448,3,20,10,0,442, - 448,3,26,13,0,443,448,3,42,21,0,444,448,3,40,20,0,445,448,3,30,15,0,446, - 448,3,24,12,0,447,397,1,0,0,0,447,402,1,0,0,0,447,407,1,0,0,0,447,412, - 1,0,0,0,447,413,1,0,0,0,447,414,1,0,0,0,447,415,1,0,0,0,447,416,1,0,0, - 0,447,417,1,0,0,0,447,418,1,0,0,0,447,419,1,0,0,0,447,424,1,0,0,0,447, - 429,1,0,0,0,447,434,1,0,0,0,447,435,1,0,0,0,447,436,1,0,0,0,447,437,1, - 0,0,0,447,438,1,0,0,0,447,439,1,0,0,0,447,440,1,0,0,0,447,441,1,0,0,0, - 447,442,1,0,0,0,447,443,1,0,0,0,447,444,1,0,0,0,447,445,1,0,0,0,447,446, - 1,0,0,0,448,11,1,0,0,0,449,450,5,19,0,0,450,451,3,32,16,0,451,13,1,0,0, - 0,452,453,5,20,0,0,453,454,3,32,16,0,454,15,1,0,0,0,455,456,5,21,0,0,456, - 457,5,22,0,0,457,458,3,32,16,0,458,17,1,0,0,0,459,460,5,23,0,0,460,461, - 3,34,17,0,461,19,1,0,0,0,462,463,5,24,0,0,463,464,3,34,17,0,464,21,1,0, - 0,0,465,466,5,25,0,0,466,467,3,98,49,0,467,468,3,2,1,0,468,469,5,17,0, - 0,469,470,3,120,60,0,470,471,5,18,0,0,471,23,1,0,0,0,472,473,5,26,0,0, - 473,25,1,0,0,0,474,475,5,27,0,0,475,489,3,28,14,0,476,477,5,27,0,0,477, - 478,3,28,14,0,478,479,5,28,0,0,479,480,3,28,14,0,480,489,1,0,0,0,481,482, - 5,27,0,0,482,483,3,28,14,0,483,484,5,28,0,0,484,485,3,28,14,0,485,486, - 5,28,0,0,486,487,3,28,14,0,487,489,1,0,0,0,488,474,1,0,0,0,488,476,1,0, - 0,0,488,481,1,0,0,0,489,27,1,0,0,0,490,491,7,2,0,0,491,29,1,0,0,0,492, - 493,5,29,0,0,493,497,5,17,0,0,494,496,3,116,58,0,495,494,1,0,0,0,496,499, - 1,0,0,0,497,495,1,0,0,0,497,498,1,0,0,0,498,500,1,0,0,0,499,497,1,0,0, - 0,500,501,5,18,0,0,501,31,1,0,0,0,502,503,5,173,0,0,503,33,1,0,0,0,504, - 505,7,3,0,0,505,35,1,0,0,0,506,507,5,175,0,0,507,528,6,18,-1,0,508,509, - 3,32,16,0,509,510,5,265,0,0,510,511,6,18,-1,0,511,528,1,0,0,0,512,513, - 3,32,16,0,513,514,6,18,-1,0,514,528,1,0,0,0,515,516,5,188,0,0,516,517, - 5,30,0,0,517,518,3,32,16,0,518,519,5,31,0,0,519,520,6,18,-1,0,520,528, - 1,0,0,0,521,522,5,189,0,0,522,523,5,30,0,0,523,524,3,34,17,0,524,525,5, - 31,0,0,525,526,6,18,-1,0,526,528,1,0,0,0,527,506,1,0,0,0,527,508,1,0,0, - 0,527,512,1,0,0,0,527,515,1,0,0,0,527,521,1,0,0,0,528,37,1,0,0,0,529,532, - 3,32,16,0,530,532,5,262,0,0,531,529,1,0,0,0,531,530,1,0,0,0,532,39,1,0, - 0,0,533,534,5,267,0,0,534,550,5,289,0,0,535,536,5,267,0,0,536,537,5,289, - 0,0,537,550,5,263,0,0,538,539,5,268,0,0,539,550,5,289,0,0,540,541,5,269, - 0,0,541,550,5,289,0,0,542,543,5,270,0,0,543,550,5,289,0,0,544,550,5,271, - 0,0,545,550,5,272,0,0,546,547,5,273,0,0,547,550,5,263,0,0,548,550,5,32, - 0,0,549,533,1,0,0,0,549,535,1,0,0,0,549,538,1,0,0,0,549,540,1,0,0,0,549, - 542,1,0,0,0,549,544,1,0,0,0,549,545,1,0,0,0,549,546,1,0,0,0,549,548,1, - 0,0,0,550,41,1,0,0,0,551,552,5,33,0,0,552,553,3,138,69,0,553,554,5,34, - 0,0,554,555,3,2,1,0,555,577,1,0,0,0,556,557,5,33,0,0,557,558,3,116,58, - 0,558,559,5,34,0,0,559,560,3,2,1,0,560,577,1,0,0,0,561,562,5,33,0,0,562, - 563,3,176,88,0,563,564,5,34,0,0,564,565,3,2,1,0,565,577,1,0,0,0,566,567, - 5,33,0,0,567,568,3,44,22,0,568,569,5,34,0,0,569,570,3,2,1,0,570,577,1, - 0,0,0,571,572,5,33,0,0,572,573,3,46,23,0,573,574,5,34,0,0,574,575,3,2, - 1,0,575,577,1,0,0,0,576,551,1,0,0,0,576,556,1,0,0,0,576,561,1,0,0,0,576, - 566,1,0,0,0,576,571,1,0,0,0,577,43,1,0,0,0,578,579,5,35,0,0,579,600,3, - 48,24,0,580,581,5,35,0,0,581,582,3,48,24,0,582,583,5,36,0,0,583,584,3, - 6,3,0,584,600,1,0,0,0,585,586,5,35,0,0,586,587,3,48,24,0,587,588,5,36, - 0,0,588,589,5,17,0,0,589,590,3,52,26,0,590,591,5,18,0,0,591,600,1,0,0, - 0,592,593,5,35,0,0,593,594,3,48,24,0,594,595,5,36,0,0,595,596,5,30,0,0, - 596,597,3,300,150,0,597,598,5,31,0,0,598,600,1,0,0,0,599,578,1,0,0,0,599, - 580,1,0,0,0,599,585,1,0,0,0,599,592,1,0,0,0,600,45,1,0,0,0,601,602,5,35, - 0,0,602,603,5,30,0,0,603,604,3,50,25,0,604,605,5,31,0,0,605,606,3,48,24, - 0,606,636,1,0,0,0,607,608,5,35,0,0,608,609,5,30,0,0,609,610,3,50,25,0, - 610,611,5,31,0,0,611,612,3,48,24,0,612,613,5,36,0,0,613,614,3,6,3,0,614, - 636,1,0,0,0,615,616,5,35,0,0,616,617,5,30,0,0,617,618,3,50,25,0,618,619, - 5,31,0,0,619,620,3,48,24,0,620,621,5,36,0,0,621,622,5,17,0,0,622,623,3, - 52,26,0,623,624,5,18,0,0,624,636,1,0,0,0,625,626,5,35,0,0,626,627,5,30, - 0,0,627,628,3,50,25,0,628,629,5,31,0,0,629,630,3,48,24,0,630,631,5,36, - 0,0,631,632,5,30,0,0,632,633,3,300,150,0,633,634,5,31,0,0,634,636,1,0, - 0,0,635,601,1,0,0,0,635,607,1,0,0,0,635,615,1,0,0,0,635,625,1,0,0,0,636, - 47,1,0,0,0,637,638,3,168,84,0,638,49,1,0,0,0,639,640,3,124,62,0,640,641, - 6,25,-1,0,641,646,1,0,0,0,642,643,3,176,88,0,643,644,6,25,-1,0,644,646, - 1,0,0,0,645,639,1,0,0,0,645,642,1,0,0,0,646,51,1,0,0,0,647,648,3,54,27, - 0,648,649,3,56,28,0,649,53,1,0,0,0,650,653,3,306,153,0,651,653,3,40,20, - 0,652,650,1,0,0,0,652,651,1,0,0,0,653,656,1,0,0,0,654,652,1,0,0,0,654, - 655,1,0,0,0,655,55,1,0,0,0,656,654,1,0,0,0,657,658,3,58,29,0,658,659,3, - 60,30,0,659,660,3,2,1,0,660,661,5,36,0,0,661,662,3,306,153,0,662,665,1, - 0,0,0,663,665,3,40,20,0,664,657,1,0,0,0,664,663,1,0,0,0,665,668,1,0,0, - 0,666,664,1,0,0,0,666,667,1,0,0,0,667,57,1,0,0,0,668,666,1,0,0,0,669,670, - 7,4,0,0,670,59,1,0,0,0,671,673,3,62,31,0,672,674,5,261,0,0,673,672,1,0, - 0,0,673,674,1,0,0,0,674,61,1,0,0,0,675,685,3,144,72,0,676,685,3,2,1,0, - 677,685,5,196,0,0,678,685,5,197,0,0,679,680,5,202,0,0,680,681,5,39,0,0, - 681,685,5,264,0,0,682,683,5,202,0,0,683,685,3,116,58,0,684,675,1,0,0,0, - 684,676,1,0,0,0,684,677,1,0,0,0,684,678,1,0,0,0,684,679,1,0,0,0,684,682, - 1,0,0,0,685,63,1,0,0,0,686,687,5,198,0,0,687,688,5,40,0,0,688,693,3,2, - 1,0,689,690,5,198,0,0,690,693,3,2,1,0,691,693,5,198,0,0,692,686,1,0,0, - 0,692,689,1,0,0,0,692,691,1,0,0,0,693,65,1,0,0,0,694,695,5,41,0,0,695, - 696,5,42,0,0,696,697,3,32,16,0,697,698,5,43,0,0,698,699,3,68,34,0,699, - 700,5,44,0,0,700,701,3,0,0,0,701,67,1,0,0,0,702,715,6,34,-1,0,703,704, - 10,5,0,0,704,714,5,186,0,0,705,706,10,4,0,0,706,714,5,187,0,0,707,708, - 10,3,0,0,708,714,5,45,0,0,709,710,10,2,0,0,710,714,5,46,0,0,711,712,10, - 1,0,0,712,714,5,47,0,0,713,703,1,0,0,0,713,705,1,0,0,0,713,707,1,0,0,0, - 713,709,1,0,0,0,713,711,1,0,0,0,714,717,1,0,0,0,715,713,1,0,0,0,715,716, - 1,0,0,0,716,69,1,0,0,0,717,715,1,0,0,0,718,719,5,48,0,0,719,720,5,36,0, - 0,720,721,5,30,0,0,721,722,3,300,150,0,722,723,5,31,0,0,723,71,1,0,0,0, - 724,725,5,49,0,0,725,726,3,2,1,0,726,73,1,0,0,0,727,731,5,50,0,0,728,730, - 3,76,38,0,729,728,1,0,0,0,730,733,1,0,0,0,731,729,1,0,0,0,731,732,1,0, - 0,0,732,734,1,0,0,0,733,731,1,0,0,0,734,735,3,2,1,0,735,736,3,182,91,0, - 736,737,3,78,39,0,737,738,3,80,40,0,738,75,1,0,0,0,739,777,5,51,0,0,740, - 777,5,52,0,0,741,777,5,199,0,0,742,777,5,202,0,0,743,777,5,221,0,0,744, - 777,5,53,0,0,745,777,5,54,0,0,746,777,5,55,0,0,747,777,5,56,0,0,748,777, - 5,244,0,0,749,777,5,15,0,0,750,777,5,224,0,0,751,777,5,57,0,0,752,777, - 5,58,0,0,753,777,5,59,0,0,754,777,5,60,0,0,755,777,5,61,0,0,756,757,5, - 62,0,0,757,777,5,51,0,0,758,759,5,62,0,0,759,777,5,52,0,0,760,761,5,62, - 0,0,761,777,5,63,0,0,762,763,5,62,0,0,763,777,5,64,0,0,764,765,5,62,0, - 0,765,777,5,65,0,0,766,767,5,62,0,0,767,777,5,66,0,0,768,777,5,67,0,0, - 769,777,5,68,0,0,770,777,5,69,0,0,771,772,5,70,0,0,772,773,5,30,0,0,773, - 774,3,32,16,0,774,775,5,31,0,0,775,777,1,0,0,0,776,739,1,0,0,0,776,740, - 1,0,0,0,776,741,1,0,0,0,776,742,1,0,0,0,776,743,1,0,0,0,776,744,1,0,0, - 0,776,745,1,0,0,0,776,746,1,0,0,0,776,747,1,0,0,0,776,748,1,0,0,0,776, - 749,1,0,0,0,776,750,1,0,0,0,776,751,1,0,0,0,776,752,1,0,0,0,776,753,1, - 0,0,0,776,754,1,0,0,0,776,755,1,0,0,0,776,756,1,0,0,0,776,758,1,0,0,0, - 776,760,1,0,0,0,776,762,1,0,0,0,776,764,1,0,0,0,776,766,1,0,0,0,776,768, - 1,0,0,0,776,769,1,0,0,0,776,770,1,0,0,0,776,771,1,0,0,0,777,77,1,0,0,0, - 778,782,1,0,0,0,779,780,5,71,0,0,780,782,3,124,62,0,781,778,1,0,0,0,781, - 779,1,0,0,0,782,79,1,0,0,0,783,787,1,0,0,0,784,785,5,72,0,0,785,787,3, - 84,42,0,786,783,1,0,0,0,786,784,1,0,0,0,787,81,1,0,0,0,788,790,3,198,99, - 0,789,788,1,0,0,0,790,793,1,0,0,0,791,789,1,0,0,0,791,792,1,0,0,0,792, - 83,1,0,0,0,793,791,1,0,0,0,794,795,3,124,62,0,795,796,5,28,0,0,796,798, - 1,0,0,0,797,794,1,0,0,0,798,801,1,0,0,0,799,797,1,0,0,0,799,800,1,0,0, - 0,800,802,1,0,0,0,801,799,1,0,0,0,802,803,3,124,62,0,803,85,1,0,0,0,804, - 805,7,5,0,0,805,87,1,0,0,0,806,807,3,86,43,0,807,808,3,32,16,0,808,809, - 5,264,0,0,809,910,1,0,0,0,810,811,3,86,43,0,811,812,3,32,16,0,812,910, - 1,0,0,0,813,814,3,86,43,0,814,815,3,32,16,0,815,816,5,75,0,0,816,817,3, - 32,16,0,817,818,5,264,0,0,818,910,1,0,0,0,819,820,3,86,43,0,820,821,3, - 32,16,0,821,822,5,75,0,0,822,823,3,32,16,0,823,910,1,0,0,0,824,825,3,86, - 43,0,825,826,3,32,16,0,826,827,5,75,0,0,827,828,3,32,16,0,828,829,5,28, - 0,0,829,830,3,32,16,0,830,831,5,264,0,0,831,910,1,0,0,0,832,833,3,86,43, - 0,833,834,3,32,16,0,834,835,5,75,0,0,835,836,3,32,16,0,836,837,5,28,0, - 0,837,838,3,32,16,0,838,910,1,0,0,0,839,840,3,86,43,0,840,841,3,32,16, - 0,841,842,5,28,0,0,842,843,3,32,16,0,843,844,5,75,0,0,844,845,3,32,16, - 0,845,846,5,264,0,0,846,910,1,0,0,0,847,848,3,86,43,0,848,849,3,32,16, - 0,849,850,5,28,0,0,850,851,3,32,16,0,851,852,5,75,0,0,852,853,3,32,16, - 0,853,910,1,0,0,0,854,855,3,86,43,0,855,856,3,32,16,0,856,857,5,28,0,0, - 857,858,3,32,16,0,858,859,5,75,0,0,859,860,3,32,16,0,860,861,5,28,0,0, - 861,862,3,32,16,0,862,863,5,264,0,0,863,910,1,0,0,0,864,865,3,86,43,0, - 865,866,3,32,16,0,866,867,5,28,0,0,867,868,3,32,16,0,868,869,5,75,0,0, - 869,870,3,32,16,0,870,871,5,28,0,0,871,872,3,32,16,0,872,910,1,0,0,0,873, - 874,3,86,43,0,874,875,3,32,16,0,875,876,5,263,0,0,876,910,1,0,0,0,877, - 878,3,86,43,0,878,879,3,32,16,0,879,880,5,75,0,0,880,881,3,32,16,0,881, - 882,5,263,0,0,882,910,1,0,0,0,883,884,3,86,43,0,884,885,3,32,16,0,885, - 886,5,75,0,0,886,887,3,32,16,0,887,888,5,28,0,0,888,889,3,32,16,0,889, - 890,5,263,0,0,890,910,1,0,0,0,891,892,3,86,43,0,892,893,3,32,16,0,893, - 894,5,28,0,0,894,895,3,32,16,0,895,896,5,75,0,0,896,897,3,32,16,0,897, - 898,5,263,0,0,898,910,1,0,0,0,899,900,3,86,43,0,900,901,3,32,16,0,901, - 902,5,28,0,0,902,903,3,32,16,0,903,904,5,75,0,0,904,905,3,32,16,0,905, - 906,5,28,0,0,906,907,3,32,16,0,907,908,5,263,0,0,908,910,1,0,0,0,909,806, - 1,0,0,0,909,810,1,0,0,0,909,813,1,0,0,0,909,819,1,0,0,0,909,824,1,0,0, - 0,909,832,1,0,0,0,909,839,1,0,0,0,909,847,1,0,0,0,909,854,1,0,0,0,909, - 864,1,0,0,0,909,873,1,0,0,0,909,877,1,0,0,0,909,883,1,0,0,0,909,891,1, - 0,0,0,909,899,1,0,0,0,910,89,1,0,0,0,911,915,5,21,0,0,912,914,3,92,46, - 0,913,912,1,0,0,0,914,917,1,0,0,0,915,913,1,0,0,0,915,916,1,0,0,0,916, - 918,1,0,0,0,917,915,1,0,0,0,918,919,3,2,1,0,919,920,3,94,47,0,920,921, - 5,180,0,0,921,922,5,36,0,0,922,923,5,30,0,0,923,924,3,300,150,0,924,925, - 5,31,0,0,925,926,3,94,47,0,926,938,1,0,0,0,927,931,5,21,0,0,928,930,3, - 92,46,0,929,928,1,0,0,0,930,933,1,0,0,0,931,929,1,0,0,0,931,932,1,0,0, - 0,932,934,1,0,0,0,933,931,1,0,0,0,934,935,3,2,1,0,935,936,3,94,47,0,936, - 938,1,0,0,0,937,911,1,0,0,0,937,927,1,0,0,0,938,91,1,0,0,0,939,940,5,76, - 0,0,940,93,1,0,0,0,941,944,1,0,0,0,942,944,5,298,0,0,943,941,1,0,0,0,943, - 942,1,0,0,0,944,95,1,0,0,0,945,946,7,6,0,0,946,97,1,0,0,0,947,949,3,96, - 48,0,948,947,1,0,0,0,949,952,1,0,0,0,950,948,1,0,0,0,950,951,1,0,0,0,951, - 99,1,0,0,0,952,950,1,0,0,0,953,979,3,102,51,0,954,955,5,280,0,0,955,956, - 3,168,84,0,956,957,6,50,-1,0,957,979,1,0,0,0,958,959,5,286,0,0,959,960, - 3,178,89,0,960,961,6,50,-1,0,961,979,1,0,0,0,962,963,5,286,0,0,963,964, - 3,174,87,0,964,965,6,50,-1,0,965,979,1,0,0,0,966,967,5,284,0,0,967,968, - 3,124,62,0,968,969,6,50,-1,0,969,979,1,0,0,0,970,971,5,281,0,0,971,972, - 3,104,52,0,972,973,6,50,-1,0,973,979,1,0,0,0,974,975,5,287,0,0,975,976, - 3,50,25,0,976,977,6,50,-1,0,977,979,1,0,0,0,978,953,1,0,0,0,978,954,1, - 0,0,0,978,958,1,0,0,0,978,962,1,0,0,0,978,966,1,0,0,0,978,970,1,0,0,0, - 978,974,1,0,0,0,979,101,1,0,0,0,980,981,5,275,0,0,981,1059,6,51,-1,0,982, - 983,5,276,0,0,983,984,3,32,16,0,984,985,6,51,-1,0,985,1059,1,0,0,0,986, - 987,5,276,0,0,987,988,3,0,0,0,988,989,6,51,-1,0,989,1059,1,0,0,0,990,991, - 5,277,0,0,991,992,3,32,16,0,992,993,6,51,-1,0,993,1059,1,0,0,0,994,995, - 5,278,0,0,995,996,3,34,17,0,996,997,6,51,-1,0,997,1059,1,0,0,0,998,999, - 5,279,0,0,999,1000,3,36,18,0,1000,1001,6,51,-1,0,1001,1059,1,0,0,0,1002, - 1003,5,279,0,0,1003,1004,3,34,17,0,1004,1005,6,51,-1,0,1005,1059,1,0,0, - 0,1006,1007,5,279,0,0,1007,1008,5,30,0,0,1008,1009,3,300,150,0,1009,1010, - 5,31,0,0,1010,1011,6,51,-1,0,1011,1059,1,0,0,0,1012,1013,5,279,0,0,1013, - 1014,5,84,0,0,1014,1015,5,30,0,0,1015,1016,3,300,150,0,1016,1017,5,31, - 0,0,1017,1018,6,51,-1,0,1018,1059,1,0,0,0,1019,1020,5,282,0,0,1020,1021, - 3,32,16,0,1021,1022,6,51,-1,0,1022,1059,1,0,0,0,1023,1024,5,282,0,0,1024, - 1025,3,0,0,0,1025,1026,6,51,-1,0,1026,1059,1,0,0,0,1027,1028,5,285,0,0, - 1028,1029,3,6,3,0,1029,1030,6,51,-1,0,1030,1059,1,0,0,0,1031,1032,5,285, - 0,0,1032,1033,5,224,0,0,1033,1034,5,30,0,0,1034,1035,3,6,3,0,1035,1036, - 5,31,0,0,1036,1037,6,51,-1,0,1037,1059,1,0,0,0,1038,1039,5,285,0,0,1039, - 1040,5,84,0,0,1040,1041,5,30,0,0,1041,1042,3,300,150,0,1042,1043,5,31, - 0,0,1043,1044,6,51,-1,0,1044,1059,1,0,0,0,1045,1046,5,287,0,0,1046,1047, - 3,32,16,0,1047,1048,6,51,-1,0,1048,1059,1,0,0,0,1049,1050,5,283,0,0,1050, - 1056,6,51,-1,0,1051,1052,5,30,0,0,1052,1053,3,106,53,0,1053,1054,5,31, - 0,0,1054,1057,1,0,0,0,1055,1057,5,85,0,0,1056,1051,1,0,0,0,1056,1055,1, - 0,0,0,1057,1059,1,0,0,0,1058,980,1,0,0,0,1058,982,1,0,0,0,1058,986,1,0, - 0,0,1058,990,1,0,0,0,1058,994,1,0,0,0,1058,998,1,0,0,0,1058,1002,1,0,0, - 0,1058,1006,1,0,0,0,1058,1012,1,0,0,0,1058,1019,1,0,0,0,1058,1023,1,0, - 0,0,1058,1027,1,0,0,0,1058,1031,1,0,0,0,1058,1038,1,0,0,0,1058,1045,1, - 0,0,0,1058,1049,1,0,0,0,1059,103,1,0,0,0,1060,1061,3,170,85,0,1061,1062, - 3,138,69,0,1062,1063,3,112,56,0,1063,1064,6,52,-1,0,1064,105,1,0,0,0,1065, - 1090,1,0,0,0,1066,1067,3,0,0,0,1067,1068,6,53,-1,0,1068,1073,1,0,0,0,1069, - 1070,3,32,16,0,1070,1071,6,53,-1,0,1071,1073,1,0,0,0,1072,1066,1,0,0,0, - 1072,1069,1,0,0,0,1073,1074,1,0,0,0,1074,1075,5,28,0,0,1075,1077,1,0,0, - 0,1076,1072,1,0,0,0,1077,1080,1,0,0,0,1078,1076,1,0,0,0,1078,1079,1,0, - 0,0,1079,1087,1,0,0,0,1080,1078,1,0,0,0,1081,1082,3,0,0,0,1082,1083,6, - 53,-1,0,1083,1088,1,0,0,0,1084,1085,3,32,16,0,1085,1086,6,53,-1,0,1086, - 1088,1,0,0,0,1087,1081,1,0,0,0,1087,1084,1,0,0,0,1088,1090,1,0,0,0,1089, - 1065,1,0,0,0,1089,1078,1,0,0,0,1090,107,1,0,0,0,1091,1098,5,86,0,0,1092, - 1093,3,138,69,0,1093,1094,6,54,-1,0,1094,1095,5,28,0,0,1095,1097,1,0,0, - 0,1096,1092,1,0,0,0,1097,1100,1,0,0,0,1098,1096,1,0,0,0,1098,1099,1,0, - 0,0,1099,1101,1,0,0,0,1100,1098,1,0,0,0,1101,1102,3,138,69,0,1102,1103, - 6,54,-1,0,1103,1104,5,87,0,0,1104,109,1,0,0,0,1105,1112,5,42,0,0,1106, - 1107,3,146,73,0,1107,1108,6,55,-1,0,1108,1109,5,28,0,0,1109,1111,1,0,0, - 0,1110,1106,1,0,0,0,1111,1114,1,0,0,0,1112,1110,1,0,0,0,1112,1113,1,0, - 0,0,1113,1115,1,0,0,0,1114,1112,1,0,0,0,1115,1116,3,146,73,0,1116,1117, - 6,55,-1,0,1117,1118,5,43,0,0,1118,111,1,0,0,0,1119,1126,5,30,0,0,1120, - 1121,3,114,57,0,1121,1122,6,56,-1,0,1122,1123,5,28,0,0,1123,1125,1,0,0, - 0,1124,1120,1,0,0,0,1125,1128,1,0,0,0,1126,1124,1,0,0,0,1126,1127,1,0, - 0,0,1127,1129,1,0,0,0,1128,1126,1,0,0,0,1129,1130,3,114,57,0,1130,1131, - 6,56,-1,0,1131,1132,5,31,0,0,1132,1135,1,0,0,0,1133,1135,5,85,0,0,1134, - 1119,1,0,0,0,1134,1133,1,0,0,0,1135,113,1,0,0,0,1136,1137,5,177,0,0,1137, - 1147,6,57,-1,0,1138,1139,3,230,115,0,1139,1140,3,138,69,0,1140,1142,3, - 226,113,0,1141,1143,3,0,0,0,1142,1141,1,0,0,0,1142,1143,1,0,0,0,1143,1144, - 1,0,0,0,1144,1145,6,57,-1,0,1145,1147,1,0,0,0,1146,1136,1,0,0,0,1146,1138, - 1,0,0,0,1147,115,1,0,0,0,1148,1149,5,42,0,0,1149,1150,3,2,1,0,1150,1151, - 5,43,0,0,1151,1152,3,118,59,0,1152,1153,6,58,-1,0,1153,1186,1,0,0,0,1154, - 1155,5,42,0,0,1155,1156,3,174,87,0,1156,1157,5,43,0,0,1157,1158,3,118, - 59,0,1158,1159,6,58,-1,0,1159,1186,1,0,0,0,1160,1161,5,42,0,0,1161,1162, - 5,262,0,0,1162,1163,5,43,0,0,1163,1164,3,118,59,0,1164,1165,6,58,-1,0, - 1165,1186,1,0,0,0,1166,1167,5,42,0,0,1167,1168,5,198,0,0,1168,1169,3,2, - 1,0,1169,1170,5,43,0,0,1170,1171,3,118,59,0,1171,1172,6,58,-1,0,1172,1186, - 1,0,0,0,1173,1174,3,118,59,0,1174,1175,6,58,-1,0,1175,1186,1,0,0,0,1176, - 1177,3,174,87,0,1177,1178,6,58,-1,0,1178,1186,1,0,0,0,1179,1180,5,257, - 0,0,1180,1186,6,58,-1,0,1181,1182,5,258,0,0,1182,1186,6,58,-1,0,1183,1184, - 5,259,0,0,1184,1186,6,58,-1,0,1185,1148,1,0,0,0,1185,1154,1,0,0,0,1185, - 1160,1,0,0,0,1185,1166,1,0,0,0,1185,1173,1,0,0,0,1185,1176,1,0,0,0,1185, - 1179,1,0,0,0,1185,1181,1,0,0,0,1185,1183,1,0,0,0,1186,117,1,0,0,0,1187, - 1188,3,2,1,0,1188,1189,6,59,-1,0,1189,1190,5,88,0,0,1190,1192,1,0,0,0, - 1191,1187,1,0,0,0,1192,1195,1,0,0,0,1193,1191,1,0,0,0,1193,1194,1,0,0, - 0,1194,1196,1,0,0,0,1195,1193,1,0,0,0,1196,1197,3,2,1,0,1197,1198,6,59, - -1,0,1198,119,1,0,0,0,1199,1201,3,122,61,0,1200,1199,1,0,0,0,1201,1204, - 1,0,0,0,1202,1200,1,0,0,0,1202,1203,1,0,0,0,1203,121,1,0,0,0,1204,1202, - 1,0,0,0,1205,1206,5,180,0,0,1206,1207,5,89,0,0,1207,1211,3,32,16,0,1208, - 1211,3,152,76,0,1209,1211,3,332,166,0,1210,1205,1,0,0,0,1210,1208,1,0, - 0,0,1210,1209,1,0,0,0,1211,123,1,0,0,0,1212,1213,3,116,58,0,1213,1214, - 6,62,-1,0,1214,1230,1,0,0,0,1215,1216,5,42,0,0,1216,1217,3,2,1,0,1217, - 1218,5,43,0,0,1218,1219,6,62,-1,0,1219,1230,1,0,0,0,1220,1221,5,42,0,0, - 1221,1222,5,198,0,0,1222,1223,3,2,1,0,1223,1224,5,43,0,0,1224,1225,6,62, - -1,0,1225,1230,1,0,0,0,1226,1227,3,138,69,0,1227,1228,6,62,-1,0,1228,1230, - 1,0,0,0,1229,1212,1,0,0,0,1229,1215,1,0,0,0,1229,1220,1,0,0,0,1229,1226, - 1,0,0,0,1230,125,1,0,0,0,1231,1243,1,0,0,0,1232,1233,3,130,65,0,1233,1239, - 6,63,-1,0,1234,1235,3,128,64,0,1235,1236,6,63,-1,0,1236,1238,1,0,0,0,1237, - 1234,1,0,0,0,1238,1241,1,0,0,0,1239,1237,1,0,0,0,1239,1240,1,0,0,0,1240, - 1243,1,0,0,0,1241,1239,1,0,0,0,1242,1231,1,0,0,0,1242,1232,1,0,0,0,1243, - 127,1,0,0,0,1244,1245,5,262,0,0,1245,1267,6,64,-1,0,1246,1247,5,261,0, - 0,1247,1267,6,64,-1,0,1248,1249,5,42,0,0,1249,1250,3,32,16,0,1250,1251, - 5,43,0,0,1251,1252,6,64,-1,0,1252,1267,1,0,0,0,1253,1254,5,42,0,0,1254, - 1255,3,32,16,0,1255,1256,5,266,0,0,1256,1257,3,32,16,0,1257,1258,5,43, - 0,0,1258,1259,6,64,-1,0,1259,1267,1,0,0,0,1260,1261,5,42,0,0,1261,1262, - 5,266,0,0,1262,1263,3,32,16,0,1263,1264,5,43,0,0,1264,1265,6,64,-1,0,1265, - 1267,1,0,0,0,1266,1244,1,0,0,0,1266,1246,1,0,0,0,1266,1248,1,0,0,0,1266, - 1253,1,0,0,0,1266,1260,1,0,0,0,1267,129,1,0,0,0,1268,1414,6,65,-1,0,1269, - 1270,5,203,0,0,1270,1271,5,30,0,0,1271,1272,3,6,3,0,1272,1273,5,28,0,0, - 1273,1274,3,6,3,0,1274,1275,5,28,0,0,1275,1276,3,6,3,0,1276,1277,5,28, - 0,0,1277,1278,3,6,3,0,1278,1279,5,31,0,0,1279,1280,6,65,-1,0,1280,1414, - 1,0,0,0,1281,1282,5,203,0,0,1282,1283,5,30,0,0,1283,1284,3,6,3,0,1284, - 1285,5,28,0,0,1285,1286,3,6,3,0,1286,1287,5,31,0,0,1287,1288,6,65,-1,0, - 1288,1414,1,0,0,0,1289,1290,5,204,0,0,1290,1291,5,205,0,0,1291,1292,5, - 42,0,0,1292,1293,3,32,16,0,1293,1294,5,43,0,0,1294,1295,6,65,-1,0,1295, - 1414,1,0,0,0,1296,1297,5,204,0,0,1297,1298,5,206,0,0,1298,1299,5,42,0, - 0,1299,1300,3,32,16,0,1300,1301,5,43,0,0,1301,1302,3,126,63,0,1302,1303, - 6,65,-1,0,1303,1414,1,0,0,0,1304,1305,5,207,0,0,1305,1414,6,65,-1,0,1306, - 1307,5,208,0,0,1307,1414,6,65,-1,0,1308,1309,5,209,0,0,1309,1414,6,65, - -1,0,1310,1311,5,201,0,0,1311,1414,6,65,-1,0,1312,1313,5,183,0,0,1313, - 1414,6,65,-1,0,1314,1315,5,184,0,0,1315,1414,6,65,-1,0,1316,1317,5,185, - 0,0,1317,1414,6,65,-1,0,1318,1319,5,186,0,0,1319,1414,6,65,-1,0,1320,1321, - 5,187,0,0,1321,1414,6,65,-1,0,1322,1323,5,188,0,0,1323,1414,6,65,-1,0, - 1324,1325,5,189,0,0,1325,1414,6,65,-1,0,1326,1327,5,210,0,0,1327,1414, - 6,65,-1,0,1328,1329,5,190,0,0,1329,1414,6,65,-1,0,1330,1331,5,191,0,0, - 1331,1414,6,65,-1,0,1332,1333,5,192,0,0,1333,1414,6,65,-1,0,1334,1335, - 5,193,0,0,1335,1414,6,65,-1,0,1336,1337,5,211,0,0,1337,1414,6,65,-1,0, - 1338,1339,5,212,0,0,1339,1414,6,65,-1,0,1340,1341,5,213,0,0,1341,1414, - 6,65,-1,0,1342,1343,5,214,0,0,1343,1414,6,65,-1,0,1344,1345,5,215,0,0, - 1345,1414,6,65,-1,0,1346,1347,5,216,0,0,1347,1414,6,65,-1,0,1348,1349, - 5,217,0,0,1349,1414,6,65,-1,0,1350,1351,5,218,0,0,1351,1352,3,132,66,0, - 1352,1353,6,65,-1,0,1353,1414,1,0,0,0,1354,1355,5,219,0,0,1355,1356,3, - 132,66,0,1356,1357,6,65,-1,0,1357,1414,1,0,0,0,1358,1359,5,220,0,0,1359, - 1414,6,65,-1,0,1360,1361,5,221,0,0,1361,1362,3,132,66,0,1362,1363,6,65, - -1,0,1363,1414,1,0,0,0,1364,1365,5,222,0,0,1365,1366,3,134,67,0,1366,1367, - 6,65,-1,0,1367,1414,1,0,0,0,1368,1369,5,222,0,0,1369,1370,3,134,67,0,1370, - 1371,5,28,0,0,1371,1372,3,6,3,0,1372,1373,6,65,-1,0,1373,1414,1,0,0,0, - 1374,1375,5,194,0,0,1375,1414,6,65,-1,0,1376,1377,5,195,0,0,1377,1414, - 6,65,-1,0,1378,1379,5,90,0,0,1379,1380,5,184,0,0,1380,1414,6,65,-1,0,1381, - 1382,5,90,0,0,1382,1383,5,185,0,0,1383,1414,6,65,-1,0,1384,1385,5,90,0, - 0,1385,1386,5,186,0,0,1386,1414,6,65,-1,0,1387,1388,5,90,0,0,1388,1389, - 5,187,0,0,1389,1414,6,65,-1,0,1390,1391,5,62,0,0,1391,1392,5,220,0,0,1392, - 1414,6,65,-1,0,1393,1394,5,223,0,0,1394,1414,6,65,-1,0,1395,1396,5,224, - 0,0,1396,1397,5,213,0,0,1397,1414,6,65,-1,0,1398,1399,5,225,0,0,1399,1414, - 6,65,-1,0,1400,1401,5,207,0,0,1401,1402,5,183,0,0,1402,1414,6,65,-1,0, - 1403,1404,5,226,0,0,1404,1414,6,65,-1,0,1405,1406,5,228,0,0,1406,1414, - 6,65,-1,0,1407,1408,5,34,0,0,1408,1409,5,227,0,0,1409,1414,6,65,-1,0,1410, - 1411,3,2,1,0,1411,1412,6,65,-1,0,1412,1414,1,0,0,0,1413,1268,1,0,0,0,1413, - 1269,1,0,0,0,1413,1281,1,0,0,0,1413,1289,1,0,0,0,1413,1296,1,0,0,0,1413, - 1304,1,0,0,0,1413,1306,1,0,0,0,1413,1308,1,0,0,0,1413,1310,1,0,0,0,1413, - 1312,1,0,0,0,1413,1314,1,0,0,0,1413,1316,1,0,0,0,1413,1318,1,0,0,0,1413, - 1320,1,0,0,0,1413,1322,1,0,0,0,1413,1324,1,0,0,0,1413,1326,1,0,0,0,1413, - 1328,1,0,0,0,1413,1330,1,0,0,0,1413,1332,1,0,0,0,1413,1334,1,0,0,0,1413, - 1336,1,0,0,0,1413,1338,1,0,0,0,1413,1340,1,0,0,0,1413,1342,1,0,0,0,1413, - 1344,1,0,0,0,1413,1346,1,0,0,0,1413,1348,1,0,0,0,1413,1350,1,0,0,0,1413, - 1354,1,0,0,0,1413,1358,1,0,0,0,1413,1360,1,0,0,0,1413,1364,1,0,0,0,1413, - 1368,1,0,0,0,1413,1374,1,0,0,0,1413,1376,1,0,0,0,1413,1378,1,0,0,0,1413, - 1381,1,0,0,0,1413,1384,1,0,0,0,1413,1387,1,0,0,0,1413,1390,1,0,0,0,1413, - 1393,1,0,0,0,1413,1395,1,0,0,0,1413,1398,1,0,0,0,1413,1400,1,0,0,0,1413, - 1403,1,0,0,0,1413,1405,1,0,0,0,1413,1407,1,0,0,0,1413,1410,1,0,0,0,1414, - 131,1,0,0,0,1415,1424,1,0,0,0,1416,1417,5,30,0,0,1417,1418,5,91,0,0,1418, - 1419,5,36,0,0,1419,1420,3,32,16,0,1420,1421,5,31,0,0,1421,1422,6,66,-1, - 0,1422,1424,1,0,0,0,1423,1415,1,0,0,0,1423,1416,1,0,0,0,1424,133,1,0,0, - 0,1425,1436,1,0,0,0,1426,1427,3,136,68,0,1427,1432,6,67,-1,0,1428,1429, - 7,7,0,0,1429,1431,6,67,-1,0,1430,1428,1,0,0,0,1431,1434,1,0,0,0,1432,1430, - 1,0,0,0,1432,1433,1,0,0,0,1433,1436,1,0,0,0,1434,1432,1,0,0,0,1435,1425, - 1,0,0,0,1435,1426,1,0,0,0,1436,135,1,0,0,0,1437,1438,5,178,0,0,1438,1518, - 6,68,-1,0,1439,1440,5,207,0,0,1440,1518,6,68,-1,0,1441,1442,5,208,0,0, - 1442,1518,6,68,-1,0,1443,1444,5,201,0,0,1444,1518,6,68,-1,0,1445,1446, - 5,183,0,0,1446,1518,6,68,-1,0,1447,1448,5,184,0,0,1448,1518,6,68,-1,0, - 1449,1450,5,185,0,0,1450,1518,6,68,-1,0,1451,1452,5,186,0,0,1452,1518, - 6,68,-1,0,1453,1454,5,187,0,0,1454,1518,6,68,-1,0,1455,1456,5,188,0,0, - 1456,1518,6,68,-1,0,1457,1458,5,189,0,0,1458,1518,6,68,-1,0,1459,1460, - 5,190,0,0,1460,1518,6,68,-1,0,1461,1462,5,191,0,0,1462,1518,6,68,-1,0, - 1463,1464,5,192,0,0,1464,1518,6,68,-1,0,1465,1466,5,193,0,0,1466,1518, - 6,68,-1,0,1467,1468,5,262,0,0,1468,1518,6,68,-1,0,1469,1470,5,211,0,0, - 1470,1518,6,68,-1,0,1471,1472,5,212,0,0,1472,1518,6,68,-1,0,1473,1474, - 5,213,0,0,1474,1518,6,68,-1,0,1475,1476,5,214,0,0,1476,1518,6,68,-1,0, - 1477,1478,5,215,0,0,1478,1518,6,68,-1,0,1479,1480,5,218,0,0,1480,1518, - 6,68,-1,0,1481,1482,5,219,0,0,1482,1518,6,68,-1,0,1483,1484,5,222,0,0, - 1484,1518,6,68,-1,0,1485,1486,5,194,0,0,1486,1518,6,68,-1,0,1487,1488, - 5,195,0,0,1488,1518,6,68,-1,0,1489,1490,5,210,0,0,1490,1518,6,68,-1,0, - 1491,1492,5,230,0,0,1492,1518,6,68,-1,0,1493,1494,5,231,0,0,1494,1518, - 6,68,-1,0,1495,1496,5,232,0,0,1496,1518,6,68,-1,0,1497,1498,5,233,0,0, - 1498,1518,6,68,-1,0,1499,1500,5,234,0,0,1500,1518,6,68,-1,0,1501,1502, - 5,235,0,0,1502,1518,6,68,-1,0,1503,1504,5,236,0,0,1504,1518,6,68,-1,0, - 1505,1506,5,237,0,0,1506,1518,6,68,-1,0,1507,1508,5,238,0,0,1508,1518, - 6,68,-1,0,1509,1510,5,239,0,0,1510,1518,6,68,-1,0,1511,1512,5,240,0,0, - 1512,1518,6,68,-1,0,1513,1514,5,241,0,0,1514,1518,6,68,-1,0,1515,1516, - 5,242,0,0,1516,1518,6,68,-1,0,1517,1437,1,0,0,0,1517,1439,1,0,0,0,1517, - 1441,1,0,0,0,1517,1443,1,0,0,0,1517,1445,1,0,0,0,1517,1447,1,0,0,0,1517, - 1449,1,0,0,0,1517,1451,1,0,0,0,1517,1453,1,0,0,0,1517,1455,1,0,0,0,1517, - 1457,1,0,0,0,1517,1459,1,0,0,0,1517,1461,1,0,0,0,1517,1463,1,0,0,0,1517, - 1465,1,0,0,0,1517,1467,1,0,0,0,1517,1469,1,0,0,0,1517,1471,1,0,0,0,1517, - 1473,1,0,0,0,1517,1475,1,0,0,0,1517,1477,1,0,0,0,1517,1479,1,0,0,0,1517, - 1481,1,0,0,0,1517,1483,1,0,0,0,1517,1485,1,0,0,0,1517,1487,1,0,0,0,1517, - 1489,1,0,0,0,1517,1491,1,0,0,0,1517,1493,1,0,0,0,1517,1495,1,0,0,0,1517, - 1497,1,0,0,0,1517,1499,1,0,0,0,1517,1501,1,0,0,0,1517,1503,1,0,0,0,1517, - 1505,1,0,0,0,1517,1507,1,0,0,0,1517,1509,1,0,0,0,1517,1511,1,0,0,0,1517, - 1513,1,0,0,0,1517,1515,1,0,0,0,1518,137,1,0,0,0,1519,1520,3,142,71,0,1520, - 1526,6,69,-1,0,1521,1522,3,140,70,0,1522,1523,6,69,-1,0,1523,1525,1,0, - 0,0,1524,1521,1,0,0,0,1525,1528,1,0,0,0,1526,1524,1,0,0,0,1526,1527,1, - 0,0,0,1527,139,1,0,0,0,1528,1526,1,0,0,0,1529,1530,5,261,0,0,1530,1559, - 6,70,-1,0,1531,1532,5,42,0,0,1532,1533,5,43,0,0,1533,1559,6,70,-1,0,1534, - 1535,3,110,55,0,1535,1536,6,70,-1,0,1536,1559,1,0,0,0,1537,1538,5,260, - 0,0,1538,1559,6,70,-1,0,1539,1540,5,262,0,0,1540,1559,6,70,-1,0,1541,1542, - 5,92,0,0,1542,1559,6,70,-1,0,1543,1544,5,93,0,0,1544,1545,5,30,0,0,1545, - 1546,3,124,62,0,1546,1547,5,31,0,0,1547,1548,6,70,-1,0,1548,1559,1,0,0, - 0,1549,1550,5,94,0,0,1550,1551,5,30,0,0,1551,1552,3,124,62,0,1552,1553, - 5,31,0,0,1553,1554,6,70,-1,0,1554,1559,1,0,0,0,1555,1556,3,108,54,0,1556, - 1557,6,70,-1,0,1557,1559,1,0,0,0,1558,1529,1,0,0,0,1558,1531,1,0,0,0,1558, - 1534,1,0,0,0,1558,1537,1,0,0,0,1558,1539,1,0,0,0,1558,1541,1,0,0,0,1558, - 1543,1,0,0,0,1558,1549,1,0,0,0,1558,1555,1,0,0,0,1559,141,1,0,0,0,1560, - 1561,5,39,0,0,1561,1562,3,116,58,0,1562,1563,6,71,-1,0,1563,1619,1,0,0, - 0,1564,1565,5,197,0,0,1565,1619,6,71,-1,0,1566,1567,5,199,0,0,1567,1568, - 5,39,0,0,1568,1569,3,116,58,0,1569,1570,6,71,-1,0,1570,1619,1,0,0,0,1571, - 1572,5,200,0,0,1572,1573,3,116,58,0,1573,1574,6,71,-1,0,1574,1619,1,0, - 0,0,1575,1576,5,226,0,0,1576,1577,3,170,85,0,1577,1578,3,138,69,0,1578, - 1579,5,262,0,0,1579,1580,3,112,56,0,1580,1581,6,71,-1,0,1581,1619,1,0, - 0,0,1582,1583,5,253,0,0,1583,1584,3,32,16,0,1584,1585,6,71,-1,0,1585,1619, - 1,0,0,0,1586,1587,5,252,0,0,1587,1588,3,32,16,0,1588,1589,6,71,-1,0,1589, - 1619,1,0,0,0,1590,1591,5,253,0,0,1591,1592,3,2,1,0,1592,1593,6,71,-1,0, - 1593,1619,1,0,0,0,1594,1595,5,252,0,0,1595,1596,3,2,1,0,1596,1597,6,71, - -1,0,1597,1619,1,0,0,0,1598,1599,5,254,0,0,1599,1619,6,71,-1,0,1600,1601, - 5,201,0,0,1601,1619,6,71,-1,0,1602,1603,3,148,74,0,1603,1604,6,71,-1,0, - 1604,1619,1,0,0,0,1605,1606,3,150,75,0,1606,1607,6,71,-1,0,1607,1619,1, - 0,0,0,1608,1609,3,144,72,0,1609,1610,6,71,-1,0,1610,1619,1,0,0,0,1611, - 1612,3,2,1,0,1612,1613,6,71,-1,0,1613,1619,1,0,0,0,1614,1615,5,177,0,0, - 1615,1616,3,138,69,0,1616,1617,6,71,-1,0,1617,1619,1,0,0,0,1618,1560,1, - 0,0,0,1618,1564,1,0,0,0,1618,1566,1,0,0,0,1618,1571,1,0,0,0,1618,1575, - 1,0,0,0,1618,1582,1,0,0,0,1618,1586,1,0,0,0,1618,1590,1,0,0,0,1618,1594, - 1,0,0,0,1618,1598,1,0,0,0,1618,1600,1,0,0,0,1618,1602,1,0,0,0,1618,1605, - 1,0,0,0,1618,1608,1,0,0,0,1618,1611,1,0,0,0,1618,1614,1,0,0,0,1619,143, - 1,0,0,0,1620,1621,5,181,0,0,1621,1659,6,72,-1,0,1622,1623,5,182,0,0,1623, - 1659,6,72,-1,0,1624,1625,5,183,0,0,1625,1659,6,72,-1,0,1626,1627,5,184, - 0,0,1627,1659,6,72,-1,0,1628,1629,5,185,0,0,1629,1659,6,72,-1,0,1630,1631, - 5,186,0,0,1631,1659,6,72,-1,0,1632,1633,5,187,0,0,1633,1659,6,72,-1,0, - 1634,1635,5,188,0,0,1635,1659,6,72,-1,0,1636,1637,5,189,0,0,1637,1659, - 6,72,-1,0,1638,1639,5,190,0,0,1639,1659,6,72,-1,0,1640,1641,5,191,0,0, - 1641,1659,6,72,-1,0,1642,1643,5,192,0,0,1643,1659,6,72,-1,0,1644,1645, - 5,193,0,0,1645,1659,6,72,-1,0,1646,1647,5,90,0,0,1647,1648,5,184,0,0,1648, - 1659,6,72,-1,0,1649,1650,5,90,0,0,1650,1651,5,185,0,0,1651,1659,6,72,-1, - 0,1652,1653,5,90,0,0,1653,1654,5,186,0,0,1654,1659,6,72,-1,0,1655,1656, - 5,90,0,0,1656,1657,5,187,0,0,1657,1659,6,72,-1,0,1658,1620,1,0,0,0,1658, - 1622,1,0,0,0,1658,1624,1,0,0,0,1658,1626,1,0,0,0,1658,1628,1,0,0,0,1658, - 1630,1,0,0,0,1658,1632,1,0,0,0,1658,1634,1,0,0,0,1658,1636,1,0,0,0,1658, - 1638,1,0,0,0,1658,1640,1,0,0,0,1658,1642,1,0,0,0,1658,1644,1,0,0,0,1658, - 1646,1,0,0,0,1658,1649,1,0,0,0,1658,1652,1,0,0,0,1658,1655,1,0,0,0,1659, - 145,1,0,0,0,1660,1675,1,0,0,0,1661,1675,5,177,0,0,1662,1663,3,32,16,0, - 1663,1664,6,73,-1,0,1664,1675,1,0,0,0,1665,1666,3,32,16,0,1666,1667,5, - 177,0,0,1667,1668,3,32,16,0,1668,1669,6,73,-1,0,1669,1675,1,0,0,0,1670, - 1671,3,32,16,0,1671,1672,5,177,0,0,1672,1673,6,73,-1,0,1673,1675,1,0,0, - 0,1674,1660,1,0,0,0,1674,1661,1,0,0,0,1674,1662,1,0,0,0,1674,1665,1,0, - 0,0,1674,1670,1,0,0,0,1675,147,1,0,0,0,1676,1677,5,1,0,0,1677,1678,5,194, - 0,0,1678,1679,6,74,-1,0,1679,149,1,0,0,0,1680,1684,5,1,0,0,1681,1682,5, - 90,0,0,1682,1685,5,194,0,0,1683,1685,5,195,0,0,1684,1681,1,0,0,0,1684, - 1683,1,0,0,0,1685,1686,1,0,0,0,1686,1687,6,75,-1,0,1687,151,1,0,0,0,1688, - 1689,5,294,0,0,1689,1690,3,166,83,0,1690,1691,3,124,62,0,1691,1692,5,30, - 0,0,1692,1693,3,158,79,0,1693,1694,5,31,0,0,1694,1736,1,0,0,0,1695,1696, - 5,294,0,0,1696,1697,3,166,83,0,1697,1698,3,124,62,0,1698,1699,5,36,0,0, - 1699,1700,5,17,0,0,1700,1701,3,52,26,0,1701,1702,5,18,0,0,1702,1736,1, - 0,0,0,1703,1704,5,294,0,0,1704,1705,3,166,83,0,1705,1706,3,124,62,0,1706, - 1736,1,0,0,0,1707,1708,5,295,0,0,1708,1709,3,166,83,0,1709,1711,5,36,0, - 0,1710,1712,5,84,0,0,1711,1710,1,0,0,0,1711,1712,1,0,0,0,1712,1713,1,0, - 0,0,1713,1714,5,30,0,0,1714,1715,3,300,150,0,1715,1716,5,31,0,0,1716,1736, - 1,0,0,0,1717,1718,5,295,0,0,1718,1719,3,166,83,0,1719,1720,5,84,0,0,1720, - 1721,5,30,0,0,1721,1722,3,300,150,0,1722,1723,5,31,0,0,1723,1736,1,0,0, - 0,1724,1725,5,295,0,0,1725,1726,3,166,83,0,1726,1727,3,6,3,0,1727,1736, - 1,0,0,0,1728,1729,5,295,0,0,1729,1730,3,166,83,0,1730,1731,5,36,0,0,1731, - 1732,5,17,0,0,1732,1733,3,154,77,0,1733,1734,5,18,0,0,1734,1736,1,0,0, - 0,1735,1688,1,0,0,0,1735,1695,1,0,0,0,1735,1703,1,0,0,0,1735,1707,1,0, - 0,0,1735,1717,1,0,0,0,1735,1724,1,0,0,0,1735,1728,1,0,0,0,1736,153,1,0, - 0,0,1737,1748,1,0,0,0,1738,1739,3,156,78,0,1739,1740,5,28,0,0,1740,1742, - 1,0,0,0,1741,1738,1,0,0,0,1742,1745,1,0,0,0,1743,1741,1,0,0,0,1743,1744, - 1,0,0,0,1744,1746,1,0,0,0,1745,1743,1,0,0,0,1746,1748,3,156,78,0,1747, - 1737,1,0,0,0,1747,1743,1,0,0,0,1748,155,1,0,0,0,1749,1750,5,39,0,0,1750, - 1751,5,264,0,0,1751,1752,5,36,0,0,1752,1753,5,17,0,0,1753,1754,3,56,28, - 0,1754,1755,5,18,0,0,1755,1763,1,0,0,0,1756,1757,3,124,62,0,1757,1758, - 5,36,0,0,1758,1759,5,17,0,0,1759,1760,3,56,28,0,1760,1761,5,18,0,0,1761, - 1763,1,0,0,0,1762,1749,1,0,0,0,1762,1756,1,0,0,0,1763,157,1,0,0,0,1764, - 1765,3,160,80,0,1765,1766,5,28,0,0,1766,1768,1,0,0,0,1767,1764,1,0,0,0, - 1768,1771,1,0,0,0,1769,1767,1,0,0,0,1769,1770,1,0,0,0,1770,1772,1,0,0, - 0,1771,1769,1,0,0,0,1772,1773,3,160,80,0,1773,159,1,0,0,0,1774,1775,3, - 6,3,0,1775,1776,5,36,0,0,1776,1777,3,164,82,0,1777,161,1,0,0,0,1778,1779, - 7,8,0,0,1779,163,1,0,0,0,1780,1815,3,162,81,0,1781,1815,3,32,16,0,1782, - 1783,5,186,0,0,1783,1784,5,30,0,0,1784,1785,3,32,16,0,1785,1786,5,31,0, - 0,1786,1815,1,0,0,0,1787,1815,3,6,3,0,1788,1789,3,116,58,0,1789,1790,5, - 30,0,0,1790,1791,5,184,0,0,1791,1792,5,75,0,0,1792,1793,3,32,16,0,1793, - 1794,5,31,0,0,1794,1815,1,0,0,0,1795,1796,3,116,58,0,1796,1797,5,30,0, - 0,1797,1798,5,185,0,0,1798,1799,5,75,0,0,1799,1800,3,32,16,0,1800,1801, - 5,31,0,0,1801,1815,1,0,0,0,1802,1803,3,116,58,0,1803,1804,5,30,0,0,1804, - 1805,5,186,0,0,1805,1806,5,75,0,0,1806,1807,3,32,16,0,1807,1808,5,31,0, - 0,1808,1815,1,0,0,0,1809,1810,3,116,58,0,1810,1811,5,30,0,0,1811,1812, - 3,32,16,0,1812,1813,5,31,0,0,1813,1815,1,0,0,0,1814,1780,1,0,0,0,1814, - 1781,1,0,0,0,1814,1782,1,0,0,0,1814,1787,1,0,0,0,1814,1788,1,0,0,0,1814, - 1795,1,0,0,0,1814,1802,1,0,0,0,1814,1809,1,0,0,0,1815,165,1,0,0,0,1816, - 1817,7,9,0,0,1817,167,1,0,0,0,1818,1819,3,170,85,0,1819,1820,3,138,69, - 0,1820,1821,3,124,62,0,1821,1822,5,176,0,0,1822,1824,3,242,121,0,1823, - 1825,3,108,54,0,1824,1823,1,0,0,0,1824,1825,1,0,0,0,1825,1826,1,0,0,0, - 1826,1827,3,112,56,0,1827,1828,6,84,-1,0,1828,1861,1,0,0,0,1829,1830,3, - 170,85,0,1830,1831,3,138,69,0,1831,1832,3,124,62,0,1832,1833,5,176,0,0, - 1833,1834,3,242,121,0,1834,1835,3,196,98,0,1835,1836,3,112,56,0,1836,1837, - 6,84,-1,0,1837,1861,1,0,0,0,1838,1839,3,170,85,0,1839,1840,3,138,69,0, - 1840,1842,3,242,121,0,1841,1843,3,108,54,0,1842,1841,1,0,0,0,1842,1843, - 1,0,0,0,1843,1844,1,0,0,0,1844,1845,3,112,56,0,1845,1846,6,84,-1,0,1846, - 1861,1,0,0,0,1847,1848,3,170,85,0,1848,1849,3,138,69,0,1849,1850,3,242, - 121,0,1850,1851,3,196,98,0,1851,1852,3,112,56,0,1852,1853,6,84,-1,0,1853, - 1861,1,0,0,0,1854,1855,3,174,87,0,1855,1856,6,84,-1,0,1856,1861,1,0,0, - 0,1857,1858,3,2,1,0,1858,1859,6,84,-1,0,1859,1861,1,0,0,0,1860,1818,1, - 0,0,0,1860,1829,1,0,0,0,1860,1838,1,0,0,0,1860,1847,1,0,0,0,1860,1854, - 1,0,0,0,1860,1857,1,0,0,0,1861,169,1,0,0,0,1862,1863,5,243,0,0,1863,1864, - 3,170,85,0,1864,1865,6,85,-1,0,1865,1880,1,0,0,0,1866,1867,5,244,0,0,1867, - 1868,3,170,85,0,1868,1869,6,85,-1,0,1869,1880,1,0,0,0,1870,1871,3,172, - 86,0,1871,1872,6,85,-1,0,1872,1880,1,0,0,0,1873,1874,5,112,0,0,1874,1875, - 5,30,0,0,1875,1876,3,32,16,0,1876,1877,5,31,0,0,1877,1878,6,85,-1,0,1878, - 1880,1,0,0,0,1879,1862,1,0,0,0,1879,1866,1,0,0,0,1879,1870,1,0,0,0,1879, - 1873,1,0,0,0,1880,171,1,0,0,0,1881,1901,1,0,0,0,1882,1883,5,245,0,0,1883, - 1901,6,86,-1,0,1884,1885,5,246,0,0,1885,1901,6,86,-1,0,1886,1887,5,247, - 0,0,1887,1888,5,248,0,0,1888,1901,6,86,-1,0,1889,1890,5,247,0,0,1890,1891, - 5,249,0,0,1891,1901,6,86,-1,0,1892,1893,5,247,0,0,1893,1894,5,250,0,0, - 1894,1901,6,86,-1,0,1895,1896,5,247,0,0,1896,1897,5,251,0,0,1897,1901, - 6,86,-1,0,1898,1899,5,247,0,0,1899,1901,6,86,-1,0,1900,1881,1,0,0,0,1900, - 1882,1,0,0,0,1900,1884,1,0,0,0,1900,1886,1,0,0,0,1900,1889,1,0,0,0,1900, - 1892,1,0,0,0,1900,1895,1,0,0,0,1900,1898,1,0,0,0,1901,173,1,0,0,0,1902, - 1903,5,113,0,0,1903,1904,5,30,0,0,1904,1905,3,32,16,0,1905,1906,5,31,0, - 0,1906,1907,6,87,-1,0,1907,175,1,0,0,0,1908,1909,5,226,0,0,1909,1910,3, - 168,84,0,1910,1911,6,88,-1,0,1911,1920,1,0,0,0,1912,1913,5,37,0,0,1913, - 1914,3,178,89,0,1914,1915,6,88,-1,0,1915,1920,1,0,0,0,1916,1917,3,174, - 87,0,1917,1918,6,88,-1,0,1918,1920,1,0,0,0,1919,1908,1,0,0,0,1919,1912, - 1,0,0,0,1919,1916,1,0,0,0,1920,177,1,0,0,0,1921,1922,3,138,69,0,1922,1923, - 3,124,62,0,1923,1924,5,176,0,0,1924,1925,3,2,1,0,1925,1926,6,89,-1,0,1926, - 1935,1,0,0,0,1927,1928,3,138,69,0,1928,1929,3,2,1,0,1929,1930,6,89,-1, - 0,1930,1935,1,0,0,0,1931,1932,3,2,1,0,1932,1933,6,89,-1,0,1933,1935,1, - 0,0,0,1934,1921,1,0,0,0,1934,1927,1,0,0,0,1934,1931,1,0,0,0,1935,179,1, - 0,0,0,1936,1937,3,124,62,0,1937,1938,6,90,-1,0,1938,1939,5,28,0,0,1939, - 1941,1,0,0,0,1940,1936,1,0,0,0,1941,1944,1,0,0,0,1942,1940,1,0,0,0,1942, - 1943,1,0,0,0,1943,1945,1,0,0,0,1944,1942,1,0,0,0,1945,1946,3,124,62,0, - 1946,1947,6,90,-1,0,1947,181,1,0,0,0,1948,1955,1,0,0,0,1949,1950,5,86, - 0,0,1950,1951,3,190,95,0,1951,1952,5,87,0,0,1952,1953,6,91,-1,0,1953,1955, - 1,0,0,0,1954,1948,1,0,0,0,1954,1949,1,0,0,0,1955,183,1,0,0,0,1956,1957, - 5,266,0,0,1957,1975,6,92,-1,0,1958,1959,5,114,0,0,1959,1975,6,92,-1,0, - 1960,1961,5,39,0,0,1961,1975,6,92,-1,0,1962,1963,5,200,0,0,1963,1975,6, - 92,-1,0,1964,1965,5,115,0,0,1965,1975,6,92,-1,0,1966,1967,5,116,0,0,1967, - 1975,6,92,-1,0,1968,1969,5,70,0,0,1969,1970,5,30,0,0,1970,1971,3,32,16, - 0,1971,1972,5,31,0,0,1972,1973,6,92,-1,0,1973,1975,1,0,0,0,1974,1956,1, - 0,0,0,1974,1958,1,0,0,0,1974,1960,1,0,0,0,1974,1962,1,0,0,0,1974,1964, - 1,0,0,0,1974,1966,1,0,0,0,1974,1968,1,0,0,0,1975,185,1,0,0,0,1976,1977, - 3,184,92,0,1977,1978,6,93,-1,0,1978,1980,1,0,0,0,1979,1976,1,0,0,0,1980, - 1983,1,0,0,0,1981,1979,1,0,0,0,1981,1982,1,0,0,0,1982,187,1,0,0,0,1983, - 1981,1,0,0,0,1984,1986,3,186,93,0,1985,1987,3,192,96,0,1986,1985,1,0,0, - 0,1986,1987,1,0,0,0,1987,1988,1,0,0,0,1988,1989,3,2,1,0,1989,1990,6,94, - -1,0,1990,189,1,0,0,0,1991,1992,3,188,94,0,1992,1993,6,95,-1,0,1993,1994, - 5,28,0,0,1994,1996,1,0,0,0,1995,1991,1,0,0,0,1996,1999,1,0,0,0,1997,1995, - 1,0,0,0,1997,1998,1,0,0,0,1998,2000,1,0,0,0,1999,1997,1,0,0,0,2000,2001, - 3,188,94,0,2001,2002,6,95,-1,0,2002,191,1,0,0,0,2003,2004,5,30,0,0,2004, - 2005,3,180,90,0,2005,2006,5,31,0,0,2006,2007,6,96,-1,0,2007,193,1,0,0, - 0,2008,2010,3,196,98,0,2009,2008,1,0,0,0,2009,2010,1,0,0,0,2010,2011,1, - 0,0,0,2011,2012,6,97,-1,0,2012,195,1,0,0,0,2013,2014,5,86,0,0,2014,2015, - 5,42,0,0,2015,2016,3,32,16,0,2016,2017,5,43,0,0,2017,2018,5,87,0,0,2018, - 2019,6,98,-1,0,2019,197,1,0,0,0,2020,2021,3,234,117,0,2021,2022,5,17,0, - 0,2022,2023,3,246,123,0,2023,2024,5,18,0,0,2024,2171,1,0,0,0,2025,2026, - 3,74,37,0,2026,2027,5,17,0,0,2027,2028,3,82,41,0,2028,2029,5,18,0,0,2029, - 2171,1,0,0,0,2030,2031,3,210,105,0,2031,2032,6,99,-1,0,2032,2033,5,17, - 0,0,2033,2034,3,214,107,0,2034,2035,5,18,0,0,2035,2171,1,0,0,0,2036,2037, - 3,218,109,0,2037,2038,6,99,-1,0,2038,2039,5,17,0,0,2039,2040,3,222,111, - 0,2040,2041,5,18,0,0,2041,2171,1,0,0,0,2042,2171,3,200,100,0,2043,2044, - 3,284,142,0,2044,2045,6,99,-1,0,2045,2171,1,0,0,0,2046,2047,3,152,76,0, - 2047,2048,6,99,-1,0,2048,2171,1,0,0,0,2049,2050,3,88,44,0,2050,2051,6, - 99,-1,0,2051,2171,1,0,0,0,2052,2053,3,330,165,0,2053,2054,6,99,-1,0,2054, - 2171,1,0,0,0,2055,2056,5,117,0,0,2056,2057,3,32,16,0,2057,2058,6,99,-1, - 0,2058,2171,1,0,0,0,2059,2060,5,118,0,0,2060,2061,3,32,16,0,2061,2062, - 6,99,-1,0,2062,2171,1,0,0,0,2063,2064,3,342,171,0,2064,2065,5,17,0,0,2065, - 2066,3,346,173,0,2066,2067,5,18,0,0,2067,2068,6,99,-1,0,2068,2171,1,0, - 0,0,2069,2070,5,302,0,0,2070,2071,3,124,62,0,2071,2072,5,176,0,0,2072, - 2073,3,242,121,0,2073,2074,5,119,0,0,2074,2075,3,170,85,0,2075,2076,3, - 138,69,0,2076,2077,3,124,62,0,2077,2078,5,176,0,0,2078,2079,3,242,121, - 0,2079,2080,3,112,56,0,2080,2081,6,99,-1,0,2081,2171,1,0,0,0,2082,2083, - 5,302,0,0,2083,2084,5,226,0,0,2084,2085,3,170,85,0,2085,2086,3,138,69, - 0,2086,2087,3,124,62,0,2087,2088,5,176,0,0,2088,2089,3,242,121,0,2089, - 2090,3,194,97,0,2090,2091,3,112,56,0,2091,2092,5,119,0,0,2092,2093,5,226, - 0,0,2093,2094,3,170,85,0,2094,2095,3,138,69,0,2095,2096,3,124,62,0,2096, - 2097,5,176,0,0,2097,2098,3,242,121,0,2098,2099,3,194,97,0,2099,2100,3, - 112,56,0,2100,2101,6,99,-1,0,2101,2171,1,0,0,0,2102,2103,3,26,13,0,2103, - 2104,6,99,-1,0,2104,2171,1,0,0,0,2105,2106,3,40,20,0,2106,2107,6,99,-1, - 0,2107,2171,1,0,0,0,2108,2109,5,255,0,0,2109,2110,5,196,0,0,2110,2111, - 5,42,0,0,2111,2112,3,32,16,0,2112,2113,5,43,0,0,2113,2119,6,99,-1,0,2114, - 2115,3,330,165,0,2115,2116,6,99,-1,0,2116,2118,1,0,0,0,2117,2114,1,0,0, - 0,2118,2121,1,0,0,0,2119,2117,1,0,0,0,2119,2120,1,0,0,0,2120,2171,1,0, - 0,0,2121,2119,1,0,0,0,2122,2123,5,255,0,0,2123,2124,5,196,0,0,2124,2125, - 3,2,1,0,2125,2131,6,99,-1,0,2126,2127,3,330,165,0,2127,2128,6,99,-1,0, - 2128,2130,1,0,0,0,2129,2126,1,0,0,0,2130,2133,1,0,0,0,2131,2129,1,0,0, - 0,2131,2132,1,0,0,0,2132,2171,1,0,0,0,2133,2131,1,0,0,0,2134,2135,5,255, - 0,0,2135,2136,5,256,0,0,2136,2137,5,42,0,0,2137,2138,3,32,16,0,2138,2139, - 5,43,0,0,2139,2140,5,28,0,0,2140,2141,3,124,62,0,2141,2147,6,99,-1,0,2142, - 2143,3,330,165,0,2143,2144,6,99,-1,0,2144,2146,1,0,0,0,2145,2142,1,0,0, - 0,2146,2149,1,0,0,0,2147,2145,1,0,0,0,2147,2148,1,0,0,0,2148,2171,1,0, - 0,0,2149,2147,1,0,0,0,2150,2151,5,255,0,0,2151,2152,5,256,0,0,2152,2153, - 3,2,1,0,2153,2154,5,28,0,0,2154,2155,3,124,62,0,2155,2161,6,99,-1,0,2156, - 2157,3,330,165,0,2157,2158,6,99,-1,0,2158,2160,1,0,0,0,2159,2156,1,0,0, - 0,2160,2163,1,0,0,0,2161,2159,1,0,0,0,2161,2162,1,0,0,0,2162,2171,1,0, - 0,0,2163,2161,1,0,0,0,2164,2165,5,120,0,0,2165,2166,5,196,0,0,2166,2167, - 3,124,62,0,2167,2168,3,44,22,0,2168,2169,6,99,-1,0,2169,2171,1,0,0,0,2170, - 2020,1,0,0,0,2170,2025,1,0,0,0,2170,2030,1,0,0,0,2170,2036,1,0,0,0,2170, - 2042,1,0,0,0,2170,2043,1,0,0,0,2170,2046,1,0,0,0,2170,2049,1,0,0,0,2170, - 2052,1,0,0,0,2170,2055,1,0,0,0,2170,2059,1,0,0,0,2170,2063,1,0,0,0,2170, - 2069,1,0,0,0,2170,2082,1,0,0,0,2170,2102,1,0,0,0,2170,2105,1,0,0,0,2170, - 2108,1,0,0,0,2170,2122,1,0,0,0,2170,2134,1,0,0,0,2170,2150,1,0,0,0,2170, - 2164,1,0,0,0,2171,199,1,0,0,0,2172,2173,5,121,0,0,2173,2185,3,208,104, - 0,2174,2175,3,202,101,0,2175,2176,6,100,-1,0,2176,2184,1,0,0,0,2177,2178, - 5,122,0,0,2178,2179,5,30,0,0,2179,2180,3,228,114,0,2180,2181,5,31,0,0, - 2181,2182,6,100,-1,0,2182,2184,1,0,0,0,2183,2174,1,0,0,0,2183,2177,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,2189,3,138,69,0,2189,2190,3,2,1,0,2190,2191, - 3,204,102,0,2191,2192,3,206,103,0,2192,2193,6,100,-1,0,2193,201,1,0,0, - 0,2194,2195,5,123,0,0,2195,2229,6,101,-1,0,2196,2197,5,51,0,0,2197,2229, - 6,101,-1,0,2198,2199,5,52,0,0,2199,2229,6,101,-1,0,2200,2201,5,63,0,0, - 2201,2229,6,101,-1,0,2202,2203,5,124,0,0,2203,2229,6,101,-1,0,2204,2205, - 5,69,0,0,2205,2229,6,101,-1,0,2206,2207,5,68,0,0,2207,2229,6,101,-1,0, - 2208,2209,5,64,0,0,2209,2229,6,101,-1,0,2210,2211,5,65,0,0,2211,2229,6, - 101,-1,0,2212,2213,5,66,0,0,2213,2229,6,101,-1,0,2214,2215,5,125,0,0,2215, - 2229,6,101,-1,0,2216,2217,5,126,0,0,2217,2229,6,101,-1,0,2218,2219,5,127, - 0,0,2219,2229,6,101,-1,0,2220,2221,5,16,0,0,2221,2229,6,101,-1,0,2222, - 2223,5,70,0,0,2223,2224,5,30,0,0,2224,2225,3,32,16,0,2225,2226,5,31,0, - 0,2226,2227,6,101,-1,0,2227,2229,1,0,0,0,2228,2194,1,0,0,0,2228,2196,1, - 0,0,0,2228,2198,1,0,0,0,2228,2200,1,0,0,0,2228,2202,1,0,0,0,2228,2204, - 1,0,0,0,2228,2206,1,0,0,0,2228,2208,1,0,0,0,2228,2210,1,0,0,0,2228,2212, - 1,0,0,0,2228,2214,1,0,0,0,2228,2216,1,0,0,0,2228,2218,1,0,0,0,2228,2220, - 1,0,0,0,2228,2222,1,0,0,0,2229,203,1,0,0,0,2230,2240,1,0,0,0,2231,2232, - 5,44,0,0,2232,2233,3,0,0,0,2233,2234,6,102,-1,0,2234,2240,1,0,0,0,2235, - 2236,5,44,0,0,2236,2237,3,32,16,0,2237,2238,6,102,-1,0,2238,2240,1,0,0, - 0,2239,2230,1,0,0,0,2239,2231,1,0,0,0,2239,2235,1,0,0,0,2240,205,1,0,0, - 0,2241,2247,1,0,0,0,2242,2243,5,36,0,0,2243,2244,3,304,152,0,2244,2245, - 6,103,-1,0,2245,2247,1,0,0,0,2246,2241,1,0,0,0,2246,2242,1,0,0,0,2247, - 207,1,0,0,0,2248,2255,1,0,0,0,2249,2250,5,42,0,0,2250,2251,3,32,16,0,2251, - 2252,5,43,0,0,2252,2253,6,104,-1,0,2253,2255,1,0,0,0,2254,2248,1,0,0,0, - 2254,2249,1,0,0,0,2255,209,1,0,0,0,2256,2262,5,128,0,0,2257,2258,3,212, - 106,0,2258,2259,6,105,-1,0,2259,2261,1,0,0,0,2260,2257,1,0,0,0,2261,2264, - 1,0,0,0,2262,2260,1,0,0,0,2262,2263,1,0,0,0,2263,2265,1,0,0,0,2264,2262, - 1,0,0,0,2265,2266,3,124,62,0,2266,2267,3,2,1,0,2267,2268,6,105,-1,0,2268, - 2282,1,0,0,0,2269,2275,5,128,0,0,2270,2271,3,212,106,0,2271,2272,6,105, - -1,0,2272,2274,1,0,0,0,2273,2270,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,2279, - 3,2,1,0,2279,2280,6,105,-1,0,2280,2282,1,0,0,0,2281,2256,1,0,0,0,2281, - 2269,1,0,0,0,2282,211,1,0,0,0,2283,2284,5,69,0,0,2284,2288,6,106,-1,0, - 2285,2286,5,68,0,0,2286,2288,6,106,-1,0,2287,2283,1,0,0,0,2287,2285,1, - 0,0,0,2288,213,1,0,0,0,2289,2291,3,216,108,0,2290,2289,1,0,0,0,2291,2294, - 1,0,0,0,2292,2290,1,0,0,0,2292,2293,1,0,0,0,2293,215,1,0,0,0,2294,2292, - 1,0,0,0,2295,2296,5,129,0,0,2296,2297,3,168,84,0,2297,2298,6,108,-1,0, - 2298,2322,1,0,0,0,2299,2300,5,130,0,0,2300,2301,3,168,84,0,2301,2302,6, - 108,-1,0,2302,2322,1,0,0,0,2303,2304,5,131,0,0,2304,2305,3,168,84,0,2305, - 2306,6,108,-1,0,2306,2322,1,0,0,0,2307,2308,5,132,0,0,2308,2309,3,168, - 84,0,2309,2310,6,108,-1,0,2310,2322,1,0,0,0,2311,2312,3,88,44,0,2312,2313, - 6,108,-1,0,2313,2322,1,0,0,0,2314,2315,3,330,165,0,2315,2316,6,108,-1, - 0,2316,2322,1,0,0,0,2317,2318,3,26,13,0,2318,2319,6,108,-1,0,2319,2322, - 1,0,0,0,2320,2322,3,40,20,0,2321,2295,1,0,0,0,2321,2299,1,0,0,0,2321,2303, - 1,0,0,0,2321,2307,1,0,0,0,2321,2311,1,0,0,0,2321,2314,1,0,0,0,2321,2317, - 1,0,0,0,2321,2320,1,0,0,0,2322,217,1,0,0,0,2323,2329,5,133,0,0,2324,2325, - 3,220,110,0,2325,2326,6,109,-1,0,2326,2328,1,0,0,0,2327,2324,1,0,0,0,2328, - 2331,1,0,0,0,2329,2327,1,0,0,0,2329,2330,1,0,0,0,2330,2332,1,0,0,0,2331, - 2329,1,0,0,0,2332,2333,3,170,85,0,2333,2334,3,138,69,0,2334,2335,3,2,1, - 0,2335,2336,3,112,56,0,2336,2337,3,206,103,0,2337,2338,6,109,-1,0,2338, - 219,1,0,0,0,2339,2340,5,69,0,0,2340,2344,6,110,-1,0,2341,2342,5,68,0,0, - 2342,2344,6,110,-1,0,2343,2339,1,0,0,0,2343,2341,1,0,0,0,2344,221,1,0, - 0,0,2345,2347,3,224,112,0,2346,2345,1,0,0,0,2347,2350,1,0,0,0,2348,2346, - 1,0,0,0,2348,2349,1,0,0,0,2349,223,1,0,0,0,2350,2348,1,0,0,0,2351,2352, - 5,134,0,0,2352,2353,3,168,84,0,2353,2354,6,112,-1,0,2354,2374,1,0,0,0, - 2355,2356,5,135,0,0,2356,2357,3,168,84,0,2357,2358,6,112,-1,0,2358,2374, - 1,0,0,0,2359,2360,5,132,0,0,2360,2361,3,168,84,0,2361,2362,6,112,-1,0, - 2362,2374,1,0,0,0,2363,2364,3,330,165,0,2364,2365,6,112,-1,0,2365,2374, - 1,0,0,0,2366,2367,3,88,44,0,2367,2368,6,112,-1,0,2368,2374,1,0,0,0,2369, - 2370,3,26,13,0,2370,2371,6,112,-1,0,2371,2374,1,0,0,0,2372,2374,3,40,20, - 0,2373,2351,1,0,0,0,2373,2355,1,0,0,0,2373,2359,1,0,0,0,2373,2363,1,0, - 0,0,2373,2366,1,0,0,0,2373,2369,1,0,0,0,2373,2372,1,0,0,0,2374,225,1,0, - 0,0,2375,2383,6,113,-1,0,2376,2377,5,122,0,0,2377,2378,5,30,0,0,2378,2379, - 3,228,114,0,2379,2380,5,31,0,0,2380,2381,6,113,-1,0,2381,2383,1,0,0,0, - 2382,2375,1,0,0,0,2382,2376,1,0,0,0,2383,227,1,0,0,0,2384,2385,3,126,63, - 0,2385,2386,6,114,-1,0,2386,2398,1,0,0,0,2387,2391,5,17,0,0,2388,2389, - 3,302,151,0,2389,2390,6,114,-1,0,2390,2392,1,0,0,0,2391,2388,1,0,0,0,2392, - 2393,1,0,0,0,2393,2391,1,0,0,0,2393,2394,1,0,0,0,2394,2395,1,0,0,0,2395, - 2396,5,18,0,0,2396,2398,1,0,0,0,2397,2384,1,0,0,0,2397,2387,1,0,0,0,2398, - 229,1,0,0,0,2399,2400,3,232,116,0,2400,2401,6,115,-1,0,2401,2403,1,0,0, - 0,2402,2399,1,0,0,0,2403,2406,1,0,0,0,2404,2402,1,0,0,0,2404,2405,1,0, - 0,0,2405,231,1,0,0,0,2406,2404,1,0,0,0,2407,2408,5,42,0,0,2408,2409,5, - 136,0,0,2409,2410,5,43,0,0,2410,2425,6,116,-1,0,2411,2412,5,42,0,0,2412, - 2413,5,137,0,0,2413,2414,5,43,0,0,2414,2425,6,116,-1,0,2415,2416,5,42, - 0,0,2416,2417,5,138,0,0,2417,2418,5,43,0,0,2418,2425,6,116,-1,0,2419,2420, - 5,42,0,0,2420,2421,3,32,16,0,2421,2422,5,43,0,0,2422,2423,6,116,-1,0,2423, - 2425,1,0,0,0,2424,2407,1,0,0,0,2424,2411,1,0,0,0,2424,2415,1,0,0,0,2424, - 2419,1,0,0,0,2425,233,1,0,0,0,2426,2435,5,139,0,0,2427,2428,3,236,118, - 0,2428,2429,6,117,-1,0,2429,2434,1,0,0,0,2430,2431,3,238,119,0,2431,2432, - 6,117,-1,0,2432,2434,1,0,0,0,2433,2427,1,0,0,0,2433,2430,1,0,0,0,2434, - 2437,1,0,0,0,2435,2433,1,0,0,0,2435,2436,1,0,0,0,2436,2438,1,0,0,0,2437, - 2435,1,0,0,0,2438,2439,3,170,85,0,2439,2440,3,230,115,0,2440,2441,3,138, - 69,0,2441,2442,3,226,113,0,2442,2443,3,242,121,0,2443,2444,3,182,91,0, - 2444,2450,3,112,56,0,2445,2446,3,244,122,0,2446,2447,6,117,-1,0,2447,2449, - 1,0,0,0,2448,2445,1,0,0,0,2449,2452,1,0,0,0,2450,2448,1,0,0,0,2450,2451, - 1,0,0,0,2451,2453,1,0,0,0,2452,2450,1,0,0,0,2453,2454,6,117,-1,0,2454, - 235,1,0,0,0,2455,2456,5,123,0,0,2456,2498,6,118,-1,0,2457,2458,5,51,0, - 0,2458,2498,6,118,-1,0,2459,2460,5,52,0,0,2460,2498,6,118,-1,0,2461,2462, - 5,63,0,0,2462,2498,6,118,-1,0,2463,2464,5,140,0,0,2464,2498,6,118,-1,0, - 2465,2466,5,68,0,0,2466,2498,6,118,-1,0,2467,2468,5,141,0,0,2468,2498, - 6,118,-1,0,2469,2470,5,142,0,0,2470,2498,6,118,-1,0,2471,2472,5,54,0,0, - 2472,2498,6,118,-1,0,2473,2474,5,64,0,0,2474,2498,6,118,-1,0,2475,2476, - 5,65,0,0,2476,2498,6,118,-1,0,2477,2478,5,66,0,0,2478,2498,6,118,-1,0, - 2479,2480,5,125,0,0,2480,2498,6,118,-1,0,2481,2482,5,143,0,0,2482,2498, - 6,118,-1,0,2483,2484,5,144,0,0,2484,2498,6,118,-1,0,2485,2486,5,69,0,0, - 2486,2498,6,118,-1,0,2487,2488,5,145,0,0,2488,2498,6,118,-1,0,2489,2490, - 5,146,0,0,2490,2498,6,118,-1,0,2491,2492,5,70,0,0,2492,2493,5,30,0,0,2493, - 2494,3,32,16,0,2494,2495,5,31,0,0,2495,2496,6,118,-1,0,2496,2498,1,0,0, - 0,2497,2455,1,0,0,0,2497,2457,1,0,0,0,2497,2459,1,0,0,0,2497,2461,1,0, - 0,0,2497,2463,1,0,0,0,2497,2465,1,0,0,0,2497,2467,1,0,0,0,2497,2469,1, - 0,0,0,2497,2471,1,0,0,0,2497,2473,1,0,0,0,2497,2475,1,0,0,0,2497,2477, - 1,0,0,0,2497,2479,1,0,0,0,2497,2481,1,0,0,0,2497,2483,1,0,0,0,2497,2485, - 1,0,0,0,2497,2487,1,0,0,0,2497,2489,1,0,0,0,2497,2491,1,0,0,0,2498,237, - 1,0,0,0,2499,2500,5,147,0,0,2500,2509,5,30,0,0,2501,2502,3,6,3,0,2502, - 2507,6,119,-1,0,2503,2504,5,34,0,0,2504,2505,3,6,3,0,2505,2506,6,119,-1, - 0,2506,2508,1,0,0,0,2507,2503,1,0,0,0,2507,2508,1,0,0,0,2508,2510,1,0, - 0,0,2509,2501,1,0,0,0,2509,2510,1,0,0,0,2510,2516,1,0,0,0,2511,2512,3, - 240,120,0,2512,2513,6,119,-1,0,2513,2515,1,0,0,0,2514,2511,1,0,0,0,2515, - 2518,1,0,0,0,2516,2514,1,0,0,0,2516,2517,1,0,0,0,2517,2519,1,0,0,0,2518, - 2516,1,0,0,0,2519,2523,5,31,0,0,2520,2521,5,147,0,0,2521,2523,5,85,0,0, - 2522,2499,1,0,0,0,2522,2520,1,0,0,0,2523,239,1,0,0,0,2524,2525,5,148,0, - 0,2525,2567,6,120,-1,0,2526,2527,5,224,0,0,2527,2567,6,120,-1,0,2528,2529, - 5,57,0,0,2529,2567,6,120,-1,0,2530,2531,5,58,0,0,2531,2567,6,120,-1,0, - 2532,2533,5,149,0,0,2533,2567,6,120,-1,0,2534,2535,5,150,0,0,2535,2567, - 6,120,-1,0,2536,2537,5,248,0,0,2537,2567,6,120,-1,0,2538,2539,5,249,0, - 0,2539,2567,6,120,-1,0,2540,2541,5,250,0,0,2541,2567,6,120,-1,0,2542,2543, - 5,251,0,0,2543,2567,6,120,-1,0,2544,2545,5,151,0,0,2545,2546,5,75,0,0, - 2546,2547,5,152,0,0,2547,2567,6,120,-1,0,2548,2549,5,151,0,0,2549,2550, - 5,75,0,0,2550,2551,5,153,0,0,2551,2567,6,120,-1,0,2552,2553,5,154,0,0, - 2553,2554,5,75,0,0,2554,2555,5,152,0,0,2555,2567,6,120,-1,0,2556,2557, - 5,154,0,0,2557,2558,5,75,0,0,2558,2559,5,153,0,0,2559,2567,6,120,-1,0, - 2560,2561,5,70,0,0,2561,2562,5,30,0,0,2562,2563,3,32,16,0,2563,2564,5, - 31,0,0,2564,2565,6,120,-1,0,2565,2567,1,0,0,0,2566,2524,1,0,0,0,2566,2526, - 1,0,0,0,2566,2528,1,0,0,0,2566,2530,1,0,0,0,2566,2532,1,0,0,0,2566,2534, - 1,0,0,0,2566,2536,1,0,0,0,2566,2538,1,0,0,0,2566,2540,1,0,0,0,2566,2542, - 1,0,0,0,2566,2544,1,0,0,0,2566,2548,1,0,0,0,2566,2552,1,0,0,0,2566,2556, - 1,0,0,0,2566,2560,1,0,0,0,2567,241,1,0,0,0,2568,2569,5,116,0,0,2569,2576, - 6,121,-1,0,2570,2571,5,155,0,0,2571,2576,6,121,-1,0,2572,2573,3,2,1,0, - 2573,2574,6,121,-1,0,2574,2576,1,0,0,0,2575,2568,1,0,0,0,2575,2570,1,0, - 0,0,2575,2572,1,0,0,0,2576,243,1,0,0,0,2577,2578,5,1,0,0,2578,2616,6,122, - -1,0,2579,2580,5,2,0,0,2580,2616,6,122,-1,0,2581,2582,5,156,0,0,2582,2616, - 6,122,-1,0,2583,2584,5,3,0,0,2584,2616,6,122,-1,0,2585,2586,5,4,0,0,2586, - 2616,6,122,-1,0,2587,2588,5,247,0,0,2588,2616,6,122,-1,0,2589,2590,5,5, - 0,0,2590,2616,6,122,-1,0,2591,2592,5,6,0,0,2592,2616,6,122,-1,0,2593,2594, - 5,7,0,0,2594,2616,6,122,-1,0,2595,2596,5,8,0,0,2596,2616,6,122,-1,0,2597, - 2598,5,9,0,0,2598,2616,6,122,-1,0,2599,2600,5,10,0,0,2600,2616,6,122,-1, - 0,2601,2602,5,11,0,0,2602,2616,6,122,-1,0,2603,2604,5,12,0,0,2604,2616, - 6,122,-1,0,2605,2606,5,13,0,0,2606,2616,6,122,-1,0,2607,2608,5,14,0,0, - 2608,2616,6,122,-1,0,2609,2610,5,70,0,0,2610,2611,5,30,0,0,2611,2612,3, - 32,16,0,2612,2613,5,31,0,0,2613,2614,6,122,-1,0,2614,2616,1,0,0,0,2615, - 2577,1,0,0,0,2615,2579,1,0,0,0,2615,2581,1,0,0,0,2615,2583,1,0,0,0,2615, - 2585,1,0,0,0,2615,2587,1,0,0,0,2615,2589,1,0,0,0,2615,2591,1,0,0,0,2615, - 2593,1,0,0,0,2615,2595,1,0,0,0,2615,2597,1,0,0,0,2615,2599,1,0,0,0,2615, - 2601,1,0,0,0,2615,2603,1,0,0,0,2615,2605,1,0,0,0,2615,2607,1,0,0,0,2615, - 2609,1,0,0,0,2616,245,1,0,0,0,2617,2619,3,248,124,0,2618,2617,1,0,0,0, - 2619,2622,1,0,0,0,2620,2618,1,0,0,0,2620,2621,1,0,0,0,2621,247,1,0,0,0, - 2622,2620,1,0,0,0,2623,2661,3,100,50,0,2624,2625,5,296,0,0,2625,2626,3, - 32,16,0,2626,2627,6,124,-1,0,2627,2661,1,0,0,0,2628,2661,3,266,133,0,2629, - 2630,5,297,0,0,2630,2631,3,32,16,0,2631,2632,6,124,-1,0,2632,2661,1,0, - 0,0,2633,2634,5,298,0,0,2634,2661,6,124,-1,0,2635,2636,5,299,0,0,2636, - 2661,6,124,-1,0,2637,2661,3,260,130,0,2638,2661,3,264,132,0,2639,2661, - 3,250,125,0,2640,2641,3,284,142,0,2641,2642,6,124,-1,0,2642,2661,1,0,0, - 0,2643,2644,3,152,76,0,2644,2645,6,124,-1,0,2645,2661,1,0,0,0,2646,2647, - 3,88,44,0,2647,2648,6,124,-1,0,2648,2661,1,0,0,0,2649,2650,3,26,13,0,2650, - 2651,6,124,-1,0,2651,2661,1,0,0,0,2652,2653,3,262,131,0,2653,2654,6,124, - -1,0,2654,2661,1,0,0,0,2655,2661,3,40,20,0,2656,2661,3,252,126,0,2657, - 2661,3,254,127,0,2658,2661,3,256,128,0,2659,2661,3,258,129,0,2660,2623, - 1,0,0,0,2660,2624,1,0,0,0,2660,2628,1,0,0,0,2660,2629,1,0,0,0,2660,2633, - 1,0,0,0,2660,2635,1,0,0,0,2660,2637,1,0,0,0,2660,2638,1,0,0,0,2660,2639, - 1,0,0,0,2660,2640,1,0,0,0,2660,2643,1,0,0,0,2660,2646,1,0,0,0,2660,2649, - 1,0,0,0,2660,2652,1,0,0,0,2660,2655,1,0,0,0,2660,2656,1,0,0,0,2660,2657, - 1,0,0,0,2660,2658,1,0,0,0,2660,2659,1,0,0,0,2661,249,1,0,0,0,2662,2664, - 5,300,0,0,2663,2665,5,157,0,0,2664,2663,1,0,0,0,2664,2665,1,0,0,0,2665, - 2666,1,0,0,0,2666,2667,3,112,56,0,2667,251,1,0,0,0,2668,2669,5,301,0,0, - 2669,2670,5,42,0,0,2670,2671,3,32,16,0,2671,2674,5,43,0,0,2672,2673,5, - 34,0,0,2673,2675,3,0,0,0,2674,2672,1,0,0,0,2674,2675,1,0,0,0,2675,253, - 1,0,0,0,2676,2677,5,303,0,0,2677,2678,3,32,16,0,2678,2679,5,75,0,0,2679, - 2680,3,32,16,0,2680,255,1,0,0,0,2681,2682,5,302,0,0,2682,2683,3,124,62, - 0,2683,2684,5,176,0,0,2684,2685,3,242,121,0,2685,2697,1,0,0,0,2686,2687, - 5,302,0,0,2687,2688,5,226,0,0,2688,2689,3,170,85,0,2689,2690,3,138,69, - 0,2690,2691,3,124,62,0,2691,2692,5,176,0,0,2692,2693,3,242,121,0,2693, - 2694,3,194,97,0,2694,2695,3,112,56,0,2695,2697,1,0,0,0,2696,2681,1,0,0, - 0,2696,2686,1,0,0,0,2697,257,1,0,0,0,2698,2699,5,255,0,0,2699,2700,5,196, - 0,0,2700,2701,5,42,0,0,2701,2702,3,32,16,0,2702,2708,5,43,0,0,2703,2704, - 3,330,165,0,2704,2705,6,129,-1,0,2705,2707,1,0,0,0,2706,2703,1,0,0,0,2707, - 2710,1,0,0,0,2708,2706,1,0,0,0,2708,2709,1,0,0,0,2709,2764,1,0,0,0,2710, - 2708,1,0,0,0,2711,2712,5,255,0,0,2712,2713,5,196,0,0,2713,2719,3,2,1,0, - 2714,2715,3,330,165,0,2715,2716,6,129,-1,0,2716,2718,1,0,0,0,2717,2714, - 1,0,0,0,2718,2721,1,0,0,0,2719,2717,1,0,0,0,2719,2720,1,0,0,0,2720,2764, - 1,0,0,0,2721,2719,1,0,0,0,2722,2723,5,255,0,0,2723,2724,5,256,0,0,2724, - 2725,5,42,0,0,2725,2726,3,32,16,0,2726,2727,5,43,0,0,2727,2728,5,28,0, - 0,2728,2734,3,124,62,0,2729,2730,3,330,165,0,2730,2731,6,129,-1,0,2731, - 2733,1,0,0,0,2732,2729,1,0,0,0,2733,2736,1,0,0,0,2734,2732,1,0,0,0,2734, - 2735,1,0,0,0,2735,2764,1,0,0,0,2736,2734,1,0,0,0,2737,2738,5,255,0,0,2738, - 2739,5,256,0,0,2739,2740,3,2,1,0,2740,2741,5,28,0,0,2741,2747,3,124,62, - 0,2742,2743,3,330,165,0,2743,2744,6,129,-1,0,2744,2746,1,0,0,0,2745,2742, - 1,0,0,0,2746,2749,1,0,0,0,2747,2745,1,0,0,0,2747,2748,1,0,0,0,2748,2764, - 1,0,0,0,2749,2747,1,0,0,0,2750,2751,5,255,0,0,2751,2752,5,42,0,0,2752, - 2753,3,32,16,0,2753,2754,5,43,0,0,2754,2760,3,206,103,0,2755,2756,3,330, - 165,0,2756,2757,6,129,-1,0,2757,2759,1,0,0,0,2758,2755,1,0,0,0,2759,2762, - 1,0,0,0,2760,2758,1,0,0,0,2760,2761,1,0,0,0,2761,2764,1,0,0,0,2762,2760, - 1,0,0,0,2763,2698,1,0,0,0,2763,2711,1,0,0,0,2763,2722,1,0,0,0,2763,2737, - 1,0,0,0,2763,2750,1,0,0,0,2764,259,1,0,0,0,2765,2766,3,0,0,0,2766,2767, - 5,75,0,0,2767,2768,6,130,-1,0,2768,261,1,0,0,0,2769,2772,3,44,22,0,2770, - 2772,3,46,23,0,2771,2769,1,0,0,0,2771,2770,1,0,0,0,2772,263,1,0,0,0,2773, - 2774,5,17,0,0,2774,2775,3,246,123,0,2775,2776,5,18,0,0,2776,265,1,0,0, - 0,2777,2778,3,270,135,0,2778,2779,3,268,134,0,2779,267,1,0,0,0,2780,2781, - 3,272,136,0,2781,2782,6,134,-1,0,2782,2784,1,0,0,0,2783,2780,1,0,0,0,2784, - 2785,1,0,0,0,2785,2783,1,0,0,0,2785,2786,1,0,0,0,2786,269,1,0,0,0,2787, - 2788,5,158,0,0,2788,2789,3,264,132,0,2789,2790,6,135,-1,0,2790,2804,1, - 0,0,0,2791,2792,5,158,0,0,2792,2793,3,0,0,0,2793,2794,5,159,0,0,2794,2795, - 3,0,0,0,2795,2796,6,135,-1,0,2796,2804,1,0,0,0,2797,2798,5,158,0,0,2798, - 2799,3,32,16,0,2799,2800,5,159,0,0,2800,2801,3,32,16,0,2801,2802,6,135, - -1,0,2802,2804,1,0,0,0,2803,2787,1,0,0,0,2803,2791,1,0,0,0,2803,2797,1, - 0,0,0,2804,271,1,0,0,0,2805,2806,3,276,138,0,2806,2807,3,282,141,0,2807, - 2808,6,136,-1,0,2808,2822,1,0,0,0,2809,2810,3,274,137,0,2810,2811,3,282, - 141,0,2811,2812,6,136,-1,0,2812,2822,1,0,0,0,2813,2814,3,278,139,0,2814, - 2815,3,282,141,0,2815,2816,6,136,-1,0,2816,2822,1,0,0,0,2817,2818,3,280, - 140,0,2818,2819,3,282,141,0,2819,2820,6,136,-1,0,2820,2822,1,0,0,0,2821, - 2805,1,0,0,0,2821,2809,1,0,0,0,2821,2813,1,0,0,0,2821,2817,1,0,0,0,2822, - 273,1,0,0,0,2823,2824,5,160,0,0,2824,2825,3,264,132,0,2825,2826,6,137, - -1,0,2826,2836,1,0,0,0,2827,2828,5,160,0,0,2828,2829,3,0,0,0,2829,2830, - 6,137,-1,0,2830,2836,1,0,0,0,2831,2832,5,160,0,0,2832,2833,3,32,16,0,2833, - 2834,6,137,-1,0,2834,2836,1,0,0,0,2835,2823,1,0,0,0,2835,2827,1,0,0,0, - 2835,2831,1,0,0,0,2836,275,1,0,0,0,2837,2838,5,161,0,0,2838,2839,3,124, - 62,0,2839,277,1,0,0,0,2840,2841,5,162,0,0,2841,279,1,0,0,0,2842,2843,5, - 163,0,0,2843,281,1,0,0,0,2844,2845,3,264,132,0,2845,2846,6,141,-1,0,2846, - 2860,1,0,0,0,2847,2848,5,164,0,0,2848,2849,3,0,0,0,2849,2850,5,159,0,0, - 2850,2851,3,0,0,0,2851,2852,6,141,-1,0,2852,2860,1,0,0,0,2853,2854,5,164, - 0,0,2854,2855,3,32,16,0,2855,2856,5,159,0,0,2856,2857,3,32,16,0,2857,2858, - 6,141,-1,0,2858,2860,1,0,0,0,2859,2844,1,0,0,0,2859,2847,1,0,0,0,2859, - 2853,1,0,0,0,2860,283,1,0,0,0,2861,2862,3,286,143,0,2862,2863,3,290,145, - 0,2863,285,1,0,0,0,2864,2865,5,165,0,0,2865,2866,3,288,144,0,2866,2867, - 3,0,0,0,2867,2868,5,36,0,0,2868,2872,1,0,0,0,2869,2870,5,165,0,0,2870, - 2872,3,288,144,0,2871,2864,1,0,0,0,2871,2869,1,0,0,0,2872,287,1,0,0,0, - 2873,2877,1,0,0,0,2874,2877,5,166,0,0,2875,2877,5,2,0,0,2876,2873,1,0, - 0,0,2876,2874,1,0,0,0,2876,2875,1,0,0,0,2877,289,1,0,0,0,2878,2879,5,17, - 0,0,2879,2880,3,292,146,0,2880,2881,5,18,0,0,2881,2888,1,0,0,0,2882,2884, - 3,296,148,0,2883,2882,1,0,0,0,2884,2885,1,0,0,0,2885,2883,1,0,0,0,2885, - 2886,1,0,0,0,2886,2888,1,0,0,0,2887,2878,1,0,0,0,2887,2883,1,0,0,0,2888, - 291,1,0,0,0,2889,2890,3,296,148,0,2890,2891,5,28,0,0,2891,2893,1,0,0,0, - 2892,2889,1,0,0,0,2893,2896,1,0,0,0,2894,2892,1,0,0,0,2894,2895,1,0,0, - 0,2895,2897,1,0,0,0,2896,2894,1,0,0,0,2897,2898,3,296,148,0,2898,293,1, - 0,0,0,2899,2905,1,0,0,0,2900,2901,5,42,0,0,2901,2902,3,32,16,0,2902,2903, - 5,43,0,0,2903,2905,1,0,0,0,2904,2899,1,0,0,0,2904,2900,1,0,0,0,2905,295, - 1,0,0,0,2906,2907,5,181,0,0,2907,2908,5,262,0,0,2908,2909,5,30,0,0,2909, - 2910,3,6,3,0,2910,2911,5,31,0,0,2911,2973,1,0,0,0,2912,2913,5,260,0,0, - 2913,2914,5,30,0,0,2914,2915,3,0,0,0,2915,2916,5,31,0,0,2916,2973,1,0, - 0,0,2917,2918,5,260,0,0,2918,2973,3,0,0,0,2919,2920,5,84,0,0,2920,2921, - 5,30,0,0,2921,2922,3,300,150,0,2922,2923,5,31,0,0,2923,2973,1,0,0,0,2924, - 2925,5,188,0,0,2925,2926,5,30,0,0,2926,2927,3,36,18,0,2927,2928,5,31,0, - 0,2928,2929,3,294,147,0,2929,2973,1,0,0,0,2930,2931,5,189,0,0,2931,2932, - 5,30,0,0,2932,2933,3,36,18,0,2933,2934,5,31,0,0,2934,2935,3,294,147,0, - 2935,2973,1,0,0,0,2936,2937,5,187,0,0,2937,2938,5,30,0,0,2938,2939,3,34, - 17,0,2939,2940,5,31,0,0,2940,2941,3,294,147,0,2941,2973,1,0,0,0,2942,2943, - 5,186,0,0,2943,2944,5,30,0,0,2944,2945,3,32,16,0,2945,2946,5,31,0,0,2946, - 2947,3,294,147,0,2947,2973,1,0,0,0,2948,2949,5,185,0,0,2949,2950,5,30, - 0,0,2950,2951,3,32,16,0,2951,2952,5,31,0,0,2952,2953,3,294,147,0,2953, - 2973,1,0,0,0,2954,2955,5,184,0,0,2955,2956,5,30,0,0,2956,2957,3,32,16, - 0,2957,2958,5,31,0,0,2958,2959,3,294,147,0,2959,2973,1,0,0,0,2960,2961, - 5,188,0,0,2961,2973,3,294,147,0,2962,2963,5,189,0,0,2963,2973,3,294,147, - 0,2964,2965,5,187,0,0,2965,2973,3,294,147,0,2966,2967,5,186,0,0,2967,2973, - 3,294,147,0,2968,2969,5,185,0,0,2969,2973,3,294,147,0,2970,2971,5,184, - 0,0,2971,2973,3,294,147,0,2972,2906,1,0,0,0,2972,2912,1,0,0,0,2972,2917, - 1,0,0,0,2972,2919,1,0,0,0,2972,2924,1,0,0,0,2972,2930,1,0,0,0,2972,2936, - 1,0,0,0,2972,2942,1,0,0,0,2972,2948,1,0,0,0,2972,2954,1,0,0,0,2972,2960, - 1,0,0,0,2972,2962,1,0,0,0,2972,2964,1,0,0,0,2972,2966,1,0,0,0,2972,2968, - 1,0,0,0,2972,2970,1,0,0,0,2973,297,1,0,0,0,2974,2975,5,188,0,0,2975,2976, - 5,30,0,0,2976,2977,3,36,18,0,2977,2978,5,31,0,0,2978,3050,1,0,0,0,2979, - 2980,5,189,0,0,2980,2981,5,30,0,0,2981,2982,3,36,18,0,2982,2983,5,31,0, - 0,2983,3050,1,0,0,0,2984,2985,5,188,0,0,2985,2986,5,30,0,0,2986,2987,3, - 32,16,0,2987,2988,5,31,0,0,2988,3050,1,0,0,0,2989,2990,5,189,0,0,2990, - 2991,5,30,0,0,2991,2992,3,34,17,0,2992,2993,5,31,0,0,2993,3050,1,0,0,0, - 2994,2995,5,187,0,0,2995,2996,5,30,0,0,2996,2997,3,34,17,0,2997,2998,5, - 31,0,0,2998,3050,1,0,0,0,2999,3000,5,186,0,0,3000,3001,5,30,0,0,3001,3002, - 3,32,16,0,3002,3003,5,31,0,0,3003,3050,1,0,0,0,3004,3005,5,185,0,0,3005, - 3006,5,30,0,0,3006,3007,3,32,16,0,3007,3008,5,31,0,0,3008,3050,1,0,0,0, - 3009,3010,5,184,0,0,3010,3011,5,30,0,0,3011,3012,3,32,16,0,3012,3013,5, - 31,0,0,3013,3050,1,0,0,0,3014,3015,5,193,0,0,3015,3016,5,30,0,0,3016,3017, - 3,34,17,0,3017,3018,5,31,0,0,3018,3050,1,0,0,0,3019,3020,5,192,0,0,3020, - 3021,5,30,0,0,3021,3022,3,32,16,0,3022,3023,5,31,0,0,3023,3050,1,0,0,0, - 3024,3025,5,191,0,0,3025,3026,5,30,0,0,3026,3027,3,32,16,0,3027,3028,5, - 31,0,0,3028,3050,1,0,0,0,3029,3030,5,190,0,0,3030,3031,5,30,0,0,3031,3032, - 3,32,16,0,3032,3033,5,31,0,0,3033,3050,1,0,0,0,3034,3035,5,181,0,0,3035, - 3036,5,30,0,0,3036,3037,3,32,16,0,3037,3038,5,31,0,0,3038,3050,1,0,0,0, - 3039,3040,5,183,0,0,3040,3041,5,30,0,0,3041,3042,3,162,81,0,3042,3043, - 5,31,0,0,3043,3050,1,0,0,0,3044,3045,5,84,0,0,3045,3046,5,30,0,0,3046, - 3047,3,300,150,0,3047,3048,5,31,0,0,3048,3050,1,0,0,0,3049,2974,1,0,0, - 0,3049,2979,1,0,0,0,3049,2984,1,0,0,0,3049,2989,1,0,0,0,3049,2994,1,0, - 0,0,3049,2999,1,0,0,0,3049,3004,1,0,0,0,3049,3009,1,0,0,0,3049,3014,1, - 0,0,0,3049,3019,1,0,0,0,3049,3024,1,0,0,0,3049,3029,1,0,0,0,3049,3034, - 1,0,0,0,3049,3039,1,0,0,0,3049,3044,1,0,0,0,3050,299,1,0,0,0,3051,3052, - 3,302,151,0,3052,3053,6,150,-1,0,3053,3055,1,0,0,0,3054,3051,1,0,0,0,3055, - 3058,1,0,0,0,3056,3054,1,0,0,0,3056,3057,1,0,0,0,3057,301,1,0,0,0,3058, - 3056,1,0,0,0,3059,3060,7,10,0,0,3060,303,1,0,0,0,3061,3065,3,298,149,0, - 3062,3065,3,6,3,0,3063,3065,5,179,0,0,3064,3061,1,0,0,0,3064,3062,1,0, - 0,0,3064,3063,1,0,0,0,3065,305,1,0,0,0,3066,3215,3,298,149,0,3067,3068, - 5,182,0,0,3068,3069,5,30,0,0,3069,3070,5,179,0,0,3070,3215,5,31,0,0,3071, - 3072,5,182,0,0,3072,3073,5,30,0,0,3073,3074,5,264,0,0,3074,3215,5,31,0, - 0,3075,3076,5,196,0,0,3076,3077,5,30,0,0,3077,3078,5,39,0,0,3078,3079, - 5,264,0,0,3079,3215,5,31,0,0,3080,3081,5,196,0,0,3081,3082,5,30,0,0,3082, - 3083,3,116,58,0,3083,3084,5,31,0,0,3084,3215,1,0,0,0,3085,3086,5,196,0, - 0,3086,3087,5,30,0,0,3087,3088,5,179,0,0,3088,3215,5,31,0,0,3089,3090, - 5,197,0,0,3090,3091,5,30,0,0,3091,3092,3,306,153,0,3092,3093,5,31,0,0, - 3093,3215,1,0,0,0,3094,3095,5,188,0,0,3095,3096,5,42,0,0,3096,3097,3,32, - 16,0,3097,3098,5,43,0,0,3098,3099,5,30,0,0,3099,3100,3,308,154,0,3100, - 3101,5,31,0,0,3101,3215,1,0,0,0,3102,3103,5,189,0,0,3103,3104,5,42,0,0, - 3104,3105,3,32,16,0,3105,3106,5,43,0,0,3106,3107,5,30,0,0,3107,3108,3, - 310,155,0,3108,3109,5,31,0,0,3109,3215,1,0,0,0,3110,3111,5,187,0,0,3111, - 3112,5,42,0,0,3112,3113,3,32,16,0,3113,3114,5,43,0,0,3114,3115,5,30,0, - 0,3115,3116,3,312,156,0,3116,3117,5,31,0,0,3117,3215,1,0,0,0,3118,3119, - 5,186,0,0,3119,3120,5,42,0,0,3120,3121,3,32,16,0,3121,3122,5,43,0,0,3122, - 3123,5,30,0,0,3123,3124,3,314,157,0,3124,3125,5,31,0,0,3125,3215,1,0,0, - 0,3126,3127,5,185,0,0,3127,3128,5,42,0,0,3128,3129,3,32,16,0,3129,3130, - 5,43,0,0,3130,3131,5,30,0,0,3131,3132,3,316,158,0,3132,3133,5,31,0,0,3133, - 3215,1,0,0,0,3134,3135,5,184,0,0,3135,3136,5,42,0,0,3136,3137,3,32,16, - 0,3137,3138,5,43,0,0,3138,3139,5,30,0,0,3139,3140,3,318,159,0,3140,3141, - 5,31,0,0,3141,3215,1,0,0,0,3142,3143,5,193,0,0,3143,3144,5,42,0,0,3144, - 3145,3,32,16,0,3145,3146,5,43,0,0,3146,3147,5,30,0,0,3147,3148,3,312,156, - 0,3148,3149,5,31,0,0,3149,3215,1,0,0,0,3150,3151,5,192,0,0,3151,3152,5, - 42,0,0,3152,3153,3,32,16,0,3153,3154,5,43,0,0,3154,3155,5,30,0,0,3155, - 3156,3,314,157,0,3156,3157,5,31,0,0,3157,3215,1,0,0,0,3158,3159,5,191, - 0,0,3159,3160,5,42,0,0,3160,3161,3,32,16,0,3161,3162,5,43,0,0,3162,3163, - 5,30,0,0,3163,3164,3,316,158,0,3164,3165,5,31,0,0,3165,3215,1,0,0,0,3166, - 3167,5,190,0,0,3167,3168,5,42,0,0,3168,3169,3,32,16,0,3169,3170,5,43,0, - 0,3170,3171,5,30,0,0,3171,3172,3,318,159,0,3172,3173,5,31,0,0,3173,3215, - 1,0,0,0,3174,3175,5,181,0,0,3175,3176,5,42,0,0,3176,3177,3,32,16,0,3177, - 3178,5,43,0,0,3178,3179,5,30,0,0,3179,3180,3,316,158,0,3180,3181,5,31, - 0,0,3181,3215,1,0,0,0,3182,3183,5,183,0,0,3183,3184,5,42,0,0,3184,3185, - 3,32,16,0,3185,3186,5,43,0,0,3186,3187,5,30,0,0,3187,3188,3,320,160,0, - 3188,3189,5,31,0,0,3189,3215,1,0,0,0,3190,3191,5,182,0,0,3191,3192,5,42, - 0,0,3192,3193,3,32,16,0,3193,3194,5,43,0,0,3194,3195,5,30,0,0,3195,3196, - 3,322,161,0,3196,3197,5,31,0,0,3197,3215,1,0,0,0,3198,3199,5,196,0,0,3199, - 3200,5,42,0,0,3200,3201,3,32,16,0,3201,3202,5,43,0,0,3202,3203,5,30,0, - 0,3203,3204,3,324,162,0,3204,3205,5,31,0,0,3205,3215,1,0,0,0,3206,3207, - 5,197,0,0,3207,3208,5,42,0,0,3208,3209,3,32,16,0,3209,3210,5,43,0,0,3210, - 3211,5,30,0,0,3211,3212,3,328,164,0,3212,3213,5,31,0,0,3213,3215,1,0,0, - 0,3214,3066,1,0,0,0,3214,3067,1,0,0,0,3214,3071,1,0,0,0,3214,3075,1,0, - 0,0,3214,3080,1,0,0,0,3214,3085,1,0,0,0,3214,3089,1,0,0,0,3214,3094,1, - 0,0,0,3214,3102,1,0,0,0,3214,3110,1,0,0,0,3214,3118,1,0,0,0,3214,3126, - 1,0,0,0,3214,3134,1,0,0,0,3214,3142,1,0,0,0,3214,3150,1,0,0,0,3214,3158, - 1,0,0,0,3214,3166,1,0,0,0,3214,3174,1,0,0,0,3214,3182,1,0,0,0,3214,3190, - 1,0,0,0,3214,3198,1,0,0,0,3214,3206,1,0,0,0,3215,307,1,0,0,0,3216,3219, - 3,36,18,0,3217,3219,3,32,16,0,3218,3216,1,0,0,0,3218,3217,1,0,0,0,3219, - 3222,1,0,0,0,3220,3218,1,0,0,0,3220,3221,1,0,0,0,3221,309,1,0,0,0,3222, - 3220,1,0,0,0,3223,3226,3,36,18,0,3224,3226,3,34,17,0,3225,3223,1,0,0,0, - 3225,3224,1,0,0,0,3226,3229,1,0,0,0,3227,3225,1,0,0,0,3227,3228,1,0,0, - 0,3228,311,1,0,0,0,3229,3227,1,0,0,0,3230,3232,3,34,17,0,3231,3230,1,0, - 0,0,3232,3235,1,0,0,0,3233,3231,1,0,0,0,3233,3234,1,0,0,0,3234,313,1,0, - 0,0,3235,3233,1,0,0,0,3236,3238,3,32,16,0,3237,3236,1,0,0,0,3238,3241, - 1,0,0,0,3239,3237,1,0,0,0,3239,3240,1,0,0,0,3240,315,1,0,0,0,3241,3239, - 1,0,0,0,3242,3244,3,32,16,0,3243,3242,1,0,0,0,3244,3247,1,0,0,0,3245,3243, - 1,0,0,0,3245,3246,1,0,0,0,3246,317,1,0,0,0,3247,3245,1,0,0,0,3248,3250, - 3,32,16,0,3249,3248,1,0,0,0,3250,3253,1,0,0,0,3251,3249,1,0,0,0,3251,3252, - 1,0,0,0,3252,319,1,0,0,0,3253,3251,1,0,0,0,3254,3256,3,162,81,0,3255,3254, - 1,0,0,0,3256,3259,1,0,0,0,3257,3255,1,0,0,0,3257,3258,1,0,0,0,3258,321, - 1,0,0,0,3259,3257,1,0,0,0,3260,3262,7,11,0,0,3261,3260,1,0,0,0,3262,3265, - 1,0,0,0,3263,3261,1,0,0,0,3263,3264,1,0,0,0,3264,323,1,0,0,0,3265,3263, - 1,0,0,0,3266,3268,3,326,163,0,3267,3266,1,0,0,0,3268,3271,1,0,0,0,3269, - 3267,1,0,0,0,3269,3270,1,0,0,0,3270,325,1,0,0,0,3271,3269,1,0,0,0,3272, - 3277,5,179,0,0,3273,3274,5,39,0,0,3274,3277,5,264,0,0,3275,3277,3,116, - 58,0,3276,3272,1,0,0,0,3276,3273,1,0,0,0,3276,3275,1,0,0,0,3277,327,1, - 0,0,0,3278,3280,3,306,153,0,3279,3278,1,0,0,0,3280,3283,1,0,0,0,3281,3279, - 1,0,0,0,3281,3282,1,0,0,0,3282,329,1,0,0,0,3283,3281,1,0,0,0,3284,3288, - 3,44,22,0,3285,3288,3,46,23,0,3286,3288,3,2,1,0,3287,3284,1,0,0,0,3287, - 3285,1,0,0,0,3287,3286,1,0,0,0,3288,331,1,0,0,0,3289,3290,7,12,0,0,3290, - 3291,5,36,0,0,3291,3292,5,30,0,0,3292,3293,3,300,150,0,3293,3294,5,31, - 0,0,3294,3315,1,0,0,0,3295,3296,5,169,0,0,3296,3297,3,38,19,0,3297,3298, - 5,75,0,0,3298,3299,3,38,19,0,3299,3300,5,75,0,0,3300,3301,3,38,19,0,3301, - 3302,5,75,0,0,3302,3303,3,38,19,0,3303,3315,1,0,0,0,3304,3305,5,170,0, - 0,3305,3315,3,6,3,0,3306,3307,5,170,0,0,3307,3308,5,36,0,0,3308,3309,5, - 30,0,0,3309,3310,3,300,150,0,3310,3311,5,31,0,0,3311,3315,1,0,0,0,3312, - 3315,3,330,165,0,3313,3315,3,40,20,0,3314,3289,1,0,0,0,3314,3295,1,0,0, - 0,3314,3304,1,0,0,0,3314,3306,1,0,0,0,3314,3312,1,0,0,0,3314,3313,1,0, - 0,0,3315,333,1,0,0,0,3316,3317,5,25,0,0,3317,3318,5,40,0,0,3318,3319,3, - 98,49,0,3319,3320,3,2,1,0,3320,3329,1,0,0,0,3321,3322,5,25,0,0,3322,3323, - 5,40,0,0,3323,3324,3,98,49,0,3324,3325,3,2,1,0,3325,3326,5,34,0,0,3326, - 3327,3,2,1,0,3327,3329,1,0,0,0,3328,3316,1,0,0,0,3328,3321,1,0,0,0,3329, - 335,1,0,0,0,3330,3332,3,338,169,0,3331,3330,1,0,0,0,3332,3335,1,0,0,0, - 3333,3331,1,0,0,0,3333,3334,1,0,0,0,3334,337,1,0,0,0,3335,3333,1,0,0,0, - 3336,3337,5,180,0,0,3337,3338,5,36,0,0,3338,3339,5,30,0,0,3339,3340,3, - 300,150,0,3340,3341,5,31,0,0,3341,3351,1,0,0,0,3342,3351,3,332,166,0,3343, - 3344,5,171,0,0,3344,3345,5,36,0,0,3345,3346,5,30,0,0,3346,3347,3,300,150, - 0,3347,3348,5,31,0,0,3348,3351,1,0,0,0,3349,3351,5,55,0,0,3350,3336,1, - 0,0,0,3350,3342,1,0,0,0,3350,3343,1,0,0,0,3350,3349,1,0,0,0,3351,339,1, - 0,0,0,3352,3353,5,50,0,0,3353,3357,5,40,0,0,3354,3356,3,344,172,0,3355, - 3354,1,0,0,0,3356,3359,1,0,0,0,3357,3355,1,0,0,0,3357,3358,1,0,0,0,3358, - 3360,1,0,0,0,3359,3357,1,0,0,0,3360,3361,3,2,1,0,3361,341,1,0,0,0,3362, - 3366,5,301,0,0,3363,3365,3,344,172,0,3364,3363,1,0,0,0,3365,3368,1,0,0, - 0,3366,3364,1,0,0,0,3366,3367,1,0,0,0,3367,3369,1,0,0,0,3368,3366,1,0, - 0,0,3369,3370,3,2,1,0,3370,343,1,0,0,0,3371,3387,5,52,0,0,3372,3387,5, - 51,0,0,3373,3387,5,172,0,0,3374,3375,5,62,0,0,3375,3387,5,51,0,0,3376, - 3377,5,62,0,0,3377,3387,5,52,0,0,3378,3379,5,62,0,0,3379,3387,5,63,0,0, - 3380,3381,5,62,0,0,3381,3387,5,64,0,0,3382,3383,5,62,0,0,3383,3387,5,65, - 0,0,3384,3385,5,62,0,0,3385,3387,5,66,0,0,3386,3371,1,0,0,0,3386,3372, - 1,0,0,0,3386,3373,1,0,0,0,3386,3374,1,0,0,0,3386,3376,1,0,0,0,3386,3378, - 1,0,0,0,3386,3380,1,0,0,0,3386,3382,1,0,0,0,3386,3384,1,0,0,0,3387,345, - 1,0,0,0,3388,3390,3,348,174,0,3389,3388,1,0,0,0,3390,3393,1,0,0,0,3391, - 3389,1,0,0,0,3391,3392,1,0,0,0,3392,347,1,0,0,0,3393,3391,1,0,0,0,3394, - 3395,5,21,0,0,3395,3408,3,2,1,0,3396,3397,5,50,0,0,3397,3398,5,40,0,0, - 3398,3408,3,118,59,0,3399,3400,5,25,0,0,3400,3401,5,40,0,0,3401,3408,3, - 2,1,0,3402,3408,3,174,87,0,3403,3404,5,50,0,0,3404,3408,3,32,16,0,3405, - 3408,3,330,165,0,3406,3408,3,40,20,0,3407,3394,1,0,0,0,3407,3396,1,0,0, - 0,3407,3399,1,0,0,0,3407,3402,1,0,0,0,3407,3403,1,0,0,0,3407,3405,1,0, - 0,0,3407,3406,1,0,0,0,3408,349,1,0,0,0,3409,3413,5,274,0,0,3410,3412,3, - 352,176,0,3411,3410,1,0,0,0,3412,3415,1,0,0,0,3413,3411,1,0,0,0,3413,3414, - 1,0,0,0,3414,3416,1,0,0,0,3415,3413,1,0,0,0,3416,3429,3,2,1,0,3417,3421, - 5,274,0,0,3418,3420,3,352,176,0,3419,3418,1,0,0,0,3420,3423,1,0,0,0,3421, - 3419,1,0,0,0,3421,3422,1,0,0,0,3422,3424,1,0,0,0,3423,3421,1,0,0,0,3424, - 3425,3,2,1,0,3425,3426,5,34,0,0,3426,3427,3,2,1,0,3427,3429,1,0,0,0,3428, - 3409,1,0,0,0,3428,3417,1,0,0,0,3429,351,1,0,0,0,3430,3431,7,13,0,0,3431, - 353,1,0,0,0,3432,3434,3,356,178,0,3433,3432,1,0,0,0,3434,3437,1,0,0,0, - 3435,3433,1,0,0,0,3435,3436,1,0,0,0,3436,355,1,0,0,0,3437,3435,1,0,0,0, - 3438,3439,5,21,0,0,3439,3440,3,2,1,0,3440,3441,5,44,0,0,3441,3442,3,32, - 16,0,3442,3449,1,0,0,0,3443,3444,5,25,0,0,3444,3445,5,40,0,0,3445,3449, - 3,2,1,0,3446,3449,3,330,165,0,3447,3449,3,40,20,0,3448,3438,1,0,0,0,3448, - 3443,1,0,0,0,3448,3446,1,0,0,0,3448,3447,1,0,0,0,3449,357,1,0,0,0,181, - 368,376,385,394,447,488,497,527,531,549,576,599,635,645,652,654,664,666, - 673,684,692,713,715,731,776,781,786,791,799,909,915,931,937,943,950,978, - 1056,1058,1072,1078,1087,1089,1098,1112,1126,1134,1142,1146,1185,1193, - 1202,1210,1229,1239,1242,1266,1413,1423,1432,1435,1517,1526,1558,1618, - 1658,1674,1684,1711,1735,1743,1747,1762,1769,1814,1824,1842,1860,1879, - 1900,1919,1934,1942,1954,1974,1981,1986,1997,2009,2119,2131,2147,2161, - 2170,2183,2185,2228,2239,2246,2254,2262,2275,2281,2287,2292,2321,2329, - 2343,2348,2373,2382,2393,2397,2404,2424,2433,2435,2450,2497,2507,2509, - 2516,2522,2566,2575,2615,2620,2660,2664,2674,2696,2708,2719,2734,2747, - 2760,2763,2771,2785,2803,2821,2835,2859,2871,2876,2885,2887,2894,2904, - 2972,3049,3056,3064,3214,3218,3220,3225,3227,3233,3239,3245,3251,3257, - 3263,3269,3276,3281,3287,3314,3328,3333,3350,3357,3366,3386,3391,3407, - 3413,3421,3428,3435,3448 + 1,166,1,166,1,166,3,166,3406,8,166,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,168,3,168, + 3425,8,168,1,169,5,169,3428,8,169,10,169,12,169,3431,9,169,1,170,1,170, + 1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170, + 3,170,3447,8,170,1,171,1,171,1,171,1,171,1,171,1,172,1,172,1,172,5,172, + 3457,8,172,10,172,12,172,3460,9,172,1,172,1,172,1,173,1,173,5,173,3466, + 8,173,10,173,12,173,3469,9,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,3,174,3488, + 8,174,1,175,5,175,3491,8,175,10,175,12,175,3494,9,175,1,176,1,176,1,176, + 1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176,3,176,3509, + 8,176,1,177,1,177,1,177,1,177,1,177,1,178,1,178,5,178,3518,8,178,10,178, + 12,178,3521,9,178,1,178,1,178,1,178,5,178,3526,8,178,10,178,12,178,3529, + 9,178,1,178,1,178,1,178,1,178,3,178,3535,8,178,1,179,1,179,1,180,5,180, + 3540,8,180,10,180,12,180,3543,9,180,1,181,1,181,1,181,1,181,1,181,1,181, + 1,181,1,181,1,181,1,181,3,181,3555,8,181,1,181,0,1,68,182,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,0,14,6,0,1,15,199,199,243,243,247,247,264,264,289,289,5,0, + 16,16,199,199,243,243,264,264,288,289,1,0,263,264,1,0,173,174,1,0,37,38, + 1,0,73,74,3,0,2,2,61,61,77,83,2,0,229,229,260,261,1,0,95,96,1,0,97,111, + 2,0,173,173,289,290,2,0,179,179,264,264,1,0,167,168,1,0,51,52,4018,0,364, + 1,0,0,0,2,382,1,0,0,0,4,384,1,0,0,0,6,391,1,0,0,0,8,400,1,0,0,0,10,489, + 1,0,0,0,12,491,1,0,0,0,14,495,1,0,0,0,16,499,1,0,0,0,18,504,1,0,0,0,20, + 508,1,0,0,0,22,512,1,0,0,0,24,519,1,0,0,0,26,535,1,0,0,0,28,537,1,0,0, + 0,30,539,1,0,0,0,32,551,1,0,0,0,34,553,1,0,0,0,36,576,1,0,0,0,38,580,1, + 0,0,0,40,598,1,0,0,0,42,625,1,0,0,0,44,648,1,0,0,0,46,684,1,0,0,0,48,686, + 1,0,0,0,50,694,1,0,0,0,52,696,1,0,0,0,54,703,1,0,0,0,56,715,1,0,0,0,58, + 718,1,0,0,0,60,720,1,0,0,0,62,733,1,0,0,0,64,746,1,0,0,0,66,748,1,0,0, + 0,68,756,1,0,0,0,70,772,1,0,0,0,72,778,1,0,0,0,74,782,1,0,0,0,76,861,1, + 0,0,0,78,868,1,0,0,0,80,875,1,0,0,0,82,880,1,0,0,0,84,889,1,0,0,0,86,895, + 1,0,0,0,88,1000,1,0,0,0,90,1028,1,0,0,0,92,1030,1,0,0,0,94,1034,1,0,0, + 0,96,1036,1,0,0,0,98,1041,1,0,0,0,100,1069,1,0,0,0,102,1149,1,0,0,0,104, + 1151,1,0,0,0,106,1180,1,0,0,0,108,1182,1,0,0,0,110,1196,1,0,0,0,112,1225, + 1,0,0,0,114,1237,1,0,0,0,116,1276,1,0,0,0,118,1284,1,0,0,0,120,1293,1, + 0,0,0,122,1301,1,0,0,0,124,1320,1,0,0,0,126,1333,1,0,0,0,128,1357,1,0, + 0,0,130,1504,1,0,0,0,132,1514,1,0,0,0,134,1526,1,0,0,0,136,1608,1,0,0, + 0,138,1610,1,0,0,0,140,1649,1,0,0,0,142,1709,1,0,0,0,144,1749,1,0,0,0, + 146,1765,1,0,0,0,148,1767,1,0,0,0,150,1771,1,0,0,0,152,1826,1,0,0,0,154, + 1838,1,0,0,0,156,1853,1,0,0,0,158,1860,1,0,0,0,160,1865,1,0,0,0,162,1869, + 1,0,0,0,164,1905,1,0,0,0,166,1907,1,0,0,0,168,1951,1,0,0,0,170,1970,1, + 0,0,0,172,1991,1,0,0,0,174,1993,1,0,0,0,176,2010,1,0,0,0,178,2025,1,0, + 0,0,180,2033,1,0,0,0,182,2045,1,0,0,0,184,2065,1,0,0,0,186,2072,1,0,0, + 0,188,2075,1,0,0,0,190,2088,1,0,0,0,192,2094,1,0,0,0,194,2100,1,0,0,0, + 196,2104,1,0,0,0,198,2261,1,0,0,0,200,2263,1,0,0,0,202,2319,1,0,0,0,204, + 2330,1,0,0,0,206,2337,1,0,0,0,208,2345,1,0,0,0,210,2372,1,0,0,0,212,2378, + 1,0,0,0,214,2383,1,0,0,0,216,2412,1,0,0,0,218,2414,1,0,0,0,220,2434,1, + 0,0,0,222,2439,1,0,0,0,224,2464,1,0,0,0,226,2473,1,0,0,0,228,2488,1,0, + 0,0,230,2495,1,0,0,0,232,2515,1,0,0,0,234,2517,1,0,0,0,236,2588,1,0,0, + 0,238,2613,1,0,0,0,240,2657,1,0,0,0,242,2666,1,0,0,0,244,2706,1,0,0,0, + 246,2711,1,0,0,0,248,2751,1,0,0,0,250,2753,1,0,0,0,252,2759,1,0,0,0,254, + 2767,1,0,0,0,256,2787,1,0,0,0,258,2854,1,0,0,0,260,2856,1,0,0,0,262,2862, + 1,0,0,0,264,2864,1,0,0,0,266,2868,1,0,0,0,268,2874,1,0,0,0,270,2894,1, + 0,0,0,272,2912,1,0,0,0,274,2926,1,0,0,0,276,2928,1,0,0,0,278,2931,1,0, + 0,0,280,2933,1,0,0,0,282,2950,1,0,0,0,284,2952,1,0,0,0,286,2962,1,0,0, + 0,288,2967,1,0,0,0,290,2978,1,0,0,0,292,2985,1,0,0,0,294,2995,1,0,0,0, + 296,3063,1,0,0,0,298,3140,1,0,0,0,300,3147,1,0,0,0,302,3150,1,0,0,0,304, + 3155,1,0,0,0,306,3305,1,0,0,0,308,3311,1,0,0,0,310,3318,1,0,0,0,312,3324, + 1,0,0,0,314,3330,1,0,0,0,316,3336,1,0,0,0,318,3342,1,0,0,0,320,3348,1, + 0,0,0,322,3354,1,0,0,0,324,3360,1,0,0,0,326,3367,1,0,0,0,328,3372,1,0, + 0,0,330,3378,1,0,0,0,332,3405,1,0,0,0,334,3407,1,0,0,0,336,3424,1,0,0, + 0,338,3429,1,0,0,0,340,3446,1,0,0,0,342,3448,1,0,0,0,344,3453,1,0,0,0, + 346,3463,1,0,0,0,348,3487,1,0,0,0,350,3492,1,0,0,0,352,3508,1,0,0,0,354, + 3510,1,0,0,0,356,3534,1,0,0,0,358,3536,1,0,0,0,360,3541,1,0,0,0,362,3554, + 1,0,0,0,364,365,7,0,0,0,365,1,1,0,0,0,366,367,5,288,0,0,367,383,6,1,-1, + 0,368,369,3,4,2,0,369,370,6,1,-1,0,370,371,5,265,0,0,371,373,1,0,0,0,372, + 368,1,0,0,0,373,376,1,0,0,0,374,372,1,0,0,0,374,375,1,0,0,0,375,377,1, + 0,0,0,376,374,1,0,0,0,377,378,3,4,2,0,378,379,6,1,-1,0,379,383,1,0,0,0, + 380,381,5,264,0,0,381,383,6,1,-1,0,382,366,1,0,0,0,382,374,1,0,0,0,382, + 380,1,0,0,0,383,3,1,0,0,0,384,385,7,1,0,0,385,5,1,0,0,0,386,387,5,263, + 0,0,387,388,6,3,-1,0,388,390,5,266,0,0,389,386,1,0,0,0,390,393,1,0,0,0, + 391,389,1,0,0,0,391,392,1,0,0,0,392,394,1,0,0,0,393,391,1,0,0,0,394,395, + 5,263,0,0,395,396,6,3,-1,0,396,7,1,0,0,0,397,399,3,10,5,0,398,397,1,0, + 0,0,399,402,1,0,0,0,400,398,1,0,0,0,400,401,1,0,0,0,401,9,1,0,0,0,402, + 400,1,0,0,0,403,404,3,74,37,0,404,405,5,17,0,0,405,406,3,82,41,0,406,407, + 5,18,0,0,407,490,1,0,0,0,408,409,3,72,36,0,409,410,5,17,0,0,410,411,3, + 8,4,0,411,412,5,18,0,0,412,490,1,0,0,0,413,414,3,234,117,0,414,415,5,17, + 0,0,415,416,3,246,123,0,416,417,5,18,0,0,417,490,1,0,0,0,418,490,3,200, + 100,0,419,420,6,5,-1,0,420,421,3,284,142,0,421,422,6,5,-1,0,422,490,1, + 0,0,0,423,424,6,5,-1,0,424,425,3,70,35,0,425,426,6,5,-1,0,426,490,1,0, + 0,0,427,428,6,5,-1,0,428,429,3,66,33,0,429,430,6,5,-1,0,430,490,1,0,0, + 0,431,432,6,5,-1,0,432,433,3,88,44,0,433,434,6,5,-1,0,434,490,1,0,0,0, + 435,436,6,5,-1,0,436,437,3,90,45,0,437,438,6,5,-1,0,438,490,1,0,0,0,439, + 440,6,5,-1,0,440,441,3,22,11,0,441,442,6,5,-1,0,442,490,1,0,0,0,443,444, + 6,5,-1,0,444,445,3,334,167,0,445,446,6,5,-1,0,446,490,1,0,0,0,447,448, + 6,5,-1,0,448,449,3,342,171,0,449,450,6,5,-1,0,450,490,1,0,0,0,451,452, + 6,5,-1,0,452,453,3,354,177,0,453,454,6,5,-1,0,454,490,1,0,0,0,455,456, + 6,5,-1,0,456,457,3,64,32,0,457,458,6,5,-1,0,458,490,1,0,0,0,459,460,6, + 5,-1,0,460,461,3,152,76,0,461,462,6,5,-1,0,462,490,1,0,0,0,463,464,3,330, + 165,0,464,465,6,5,-1,0,465,490,1,0,0,0,466,467,6,5,-1,0,467,490,3,12,6, + 0,468,469,6,5,-1,0,469,490,3,14,7,0,470,471,6,5,-1,0,471,490,3,16,8,0, + 472,473,6,5,-1,0,473,490,3,18,9,0,474,475,6,5,-1,0,475,490,3,20,10,0,476, + 477,6,5,-1,0,477,478,3,26,13,0,478,479,6,5,-1,0,479,490,1,0,0,0,480,481, + 6,5,-1,0,481,482,3,42,21,0,482,483,6,5,-1,0,483,490,1,0,0,0,484,485,6, + 5,-1,0,485,490,3,40,20,0,486,490,3,30,15,0,487,488,6,5,-1,0,488,490,3, + 24,12,0,489,403,1,0,0,0,489,408,1,0,0,0,489,413,1,0,0,0,489,418,1,0,0, + 0,489,419,1,0,0,0,489,423,1,0,0,0,489,427,1,0,0,0,489,431,1,0,0,0,489, + 435,1,0,0,0,489,439,1,0,0,0,489,443,1,0,0,0,489,447,1,0,0,0,489,451,1, + 0,0,0,489,455,1,0,0,0,489,459,1,0,0,0,489,463,1,0,0,0,489,466,1,0,0,0, + 489,468,1,0,0,0,489,470,1,0,0,0,489,472,1,0,0,0,489,474,1,0,0,0,489,476, + 1,0,0,0,489,480,1,0,0,0,489,484,1,0,0,0,489,486,1,0,0,0,489,487,1,0,0, + 0,490,11,1,0,0,0,491,492,5,19,0,0,492,493,3,32,16,0,493,494,6,6,-1,0,494, + 13,1,0,0,0,495,496,5,20,0,0,496,497,3,32,16,0,497,498,6,7,-1,0,498,15, + 1,0,0,0,499,500,5,21,0,0,500,501,5,22,0,0,501,502,3,32,16,0,502,503,6, + 8,-1,0,503,17,1,0,0,0,504,505,5,23,0,0,505,506,3,34,17,0,506,507,6,9,-1, + 0,507,19,1,0,0,0,508,509,5,24,0,0,509,510,3,34,17,0,510,511,6,10,-1,0, + 511,21,1,0,0,0,512,513,5,25,0,0,513,514,3,98,49,0,514,515,3,2,1,0,515, + 516,5,17,0,0,516,517,3,120,60,0,517,518,5,18,0,0,518,23,1,0,0,0,519,520, + 5,26,0,0,520,25,1,0,0,0,521,522,5,27,0,0,522,536,3,28,14,0,523,524,5,27, + 0,0,524,525,3,28,14,0,525,526,5,28,0,0,526,527,3,28,14,0,527,536,1,0,0, + 0,528,529,5,27,0,0,529,530,3,28,14,0,530,531,5,28,0,0,531,532,3,28,14, + 0,532,533,5,28,0,0,533,534,3,28,14,0,534,536,1,0,0,0,535,521,1,0,0,0,535, + 523,1,0,0,0,535,528,1,0,0,0,536,27,1,0,0,0,537,538,7,2,0,0,538,29,1,0, + 0,0,539,540,5,29,0,0,540,546,5,17,0,0,541,542,3,116,58,0,542,543,6,15, + -1,0,543,545,1,0,0,0,544,541,1,0,0,0,545,548,1,0,0,0,546,544,1,0,0,0,546, + 547,1,0,0,0,547,549,1,0,0,0,548,546,1,0,0,0,549,550,5,18,0,0,550,31,1, + 0,0,0,551,552,5,173,0,0,552,33,1,0,0,0,553,554,7,3,0,0,554,35,1,0,0,0, + 555,556,5,175,0,0,556,577,6,18,-1,0,557,558,3,32,16,0,558,559,5,265,0, + 0,559,560,6,18,-1,0,560,577,1,0,0,0,561,562,3,32,16,0,562,563,6,18,-1, + 0,563,577,1,0,0,0,564,565,5,188,0,0,565,566,5,30,0,0,566,567,3,32,16,0, + 567,568,5,31,0,0,568,569,6,18,-1,0,569,577,1,0,0,0,570,571,5,189,0,0,571, + 572,5,30,0,0,572,573,3,34,17,0,573,574,5,31,0,0,574,575,6,18,-1,0,575, + 577,1,0,0,0,576,555,1,0,0,0,576,557,1,0,0,0,576,561,1,0,0,0,576,564,1, + 0,0,0,576,570,1,0,0,0,577,37,1,0,0,0,578,581,3,32,16,0,579,581,5,262,0, + 0,580,578,1,0,0,0,580,579,1,0,0,0,581,39,1,0,0,0,582,583,5,267,0,0,583, + 599,5,289,0,0,584,585,5,267,0,0,585,586,5,289,0,0,586,599,5,263,0,0,587, + 588,5,268,0,0,588,599,5,289,0,0,589,590,5,269,0,0,590,599,5,289,0,0,591, + 592,5,270,0,0,592,599,5,289,0,0,593,599,5,271,0,0,594,599,5,272,0,0,595, + 596,5,273,0,0,596,599,5,263,0,0,597,599,5,32,0,0,598,582,1,0,0,0,598,584, + 1,0,0,0,598,587,1,0,0,0,598,589,1,0,0,0,598,591,1,0,0,0,598,593,1,0,0, + 0,598,594,1,0,0,0,598,595,1,0,0,0,598,597,1,0,0,0,599,41,1,0,0,0,600,601, + 5,33,0,0,601,602,3,138,69,0,602,603,5,34,0,0,603,604,3,2,1,0,604,626,1, + 0,0,0,605,606,5,33,0,0,606,607,3,116,58,0,607,608,5,34,0,0,608,609,3,2, + 1,0,609,626,1,0,0,0,610,611,5,33,0,0,611,612,3,176,88,0,612,613,5,34,0, + 0,613,614,3,2,1,0,614,626,1,0,0,0,615,616,5,33,0,0,616,617,3,44,22,0,617, + 618,5,34,0,0,618,619,3,2,1,0,619,626,1,0,0,0,620,621,5,33,0,0,621,622, + 3,46,23,0,622,623,5,34,0,0,623,624,3,2,1,0,624,626,1,0,0,0,625,600,1,0, + 0,0,625,605,1,0,0,0,625,610,1,0,0,0,625,615,1,0,0,0,625,620,1,0,0,0,626, + 43,1,0,0,0,627,628,5,35,0,0,628,649,3,48,24,0,629,630,5,35,0,0,630,631, + 3,48,24,0,631,632,5,36,0,0,632,633,3,6,3,0,633,649,1,0,0,0,634,635,5,35, + 0,0,635,636,3,48,24,0,636,637,5,36,0,0,637,638,5,17,0,0,638,639,3,52,26, + 0,639,640,5,18,0,0,640,649,1,0,0,0,641,642,5,35,0,0,642,643,3,48,24,0, + 643,644,5,36,0,0,644,645,5,30,0,0,645,646,3,300,150,0,646,647,5,31,0,0, + 647,649,1,0,0,0,648,627,1,0,0,0,648,629,1,0,0,0,648,634,1,0,0,0,648,641, + 1,0,0,0,649,45,1,0,0,0,650,651,5,35,0,0,651,652,5,30,0,0,652,653,3,50, + 25,0,653,654,5,31,0,0,654,655,3,48,24,0,655,685,1,0,0,0,656,657,5,35,0, + 0,657,658,5,30,0,0,658,659,3,50,25,0,659,660,5,31,0,0,660,661,3,48,24, + 0,661,662,5,36,0,0,662,663,3,6,3,0,663,685,1,0,0,0,664,665,5,35,0,0,665, + 666,5,30,0,0,666,667,3,50,25,0,667,668,5,31,0,0,668,669,3,48,24,0,669, + 670,5,36,0,0,670,671,5,17,0,0,671,672,3,52,26,0,672,673,5,18,0,0,673,685, + 1,0,0,0,674,675,5,35,0,0,675,676,5,30,0,0,676,677,3,50,25,0,677,678,5, + 31,0,0,678,679,3,48,24,0,679,680,5,36,0,0,680,681,5,30,0,0,681,682,3,300, + 150,0,682,683,5,31,0,0,683,685,1,0,0,0,684,650,1,0,0,0,684,656,1,0,0,0, + 684,664,1,0,0,0,684,674,1,0,0,0,685,47,1,0,0,0,686,687,3,168,84,0,687, + 49,1,0,0,0,688,689,3,124,62,0,689,690,6,25,-1,0,690,695,1,0,0,0,691,692, + 3,176,88,0,692,693,6,25,-1,0,693,695,1,0,0,0,694,688,1,0,0,0,694,691,1, + 0,0,0,695,51,1,0,0,0,696,697,3,54,27,0,697,698,3,56,28,0,698,53,1,0,0, + 0,699,702,3,306,153,0,700,702,3,40,20,0,701,699,1,0,0,0,701,700,1,0,0, + 0,702,705,1,0,0,0,703,701,1,0,0,0,703,704,1,0,0,0,704,55,1,0,0,0,705,703, + 1,0,0,0,706,707,3,58,29,0,707,708,3,60,30,0,708,709,3,2,1,0,709,710,5, + 36,0,0,710,711,3,306,153,0,711,714,1,0,0,0,712,714,3,40,20,0,713,706,1, + 0,0,0,713,712,1,0,0,0,714,717,1,0,0,0,715,713,1,0,0,0,715,716,1,0,0,0, + 716,57,1,0,0,0,717,715,1,0,0,0,718,719,7,4,0,0,719,59,1,0,0,0,720,722, + 3,62,31,0,721,723,5,261,0,0,722,721,1,0,0,0,722,723,1,0,0,0,723,61,1,0, + 0,0,724,734,3,144,72,0,725,734,3,2,1,0,726,734,5,196,0,0,727,734,5,197, + 0,0,728,729,5,202,0,0,729,730,5,39,0,0,730,734,5,264,0,0,731,732,5,202, + 0,0,732,734,3,116,58,0,733,724,1,0,0,0,733,725,1,0,0,0,733,726,1,0,0,0, + 733,727,1,0,0,0,733,728,1,0,0,0,733,731,1,0,0,0,734,63,1,0,0,0,735,736, + 5,198,0,0,736,737,5,40,0,0,737,738,3,2,1,0,738,739,6,32,-1,0,739,747,1, + 0,0,0,740,741,5,198,0,0,741,742,3,2,1,0,742,743,6,32,-1,0,743,747,1,0, + 0,0,744,745,5,198,0,0,745,747,6,32,-1,0,746,735,1,0,0,0,746,740,1,0,0, + 0,746,744,1,0,0,0,747,65,1,0,0,0,748,749,5,41,0,0,749,750,5,42,0,0,750, + 751,3,32,16,0,751,752,5,43,0,0,752,753,3,68,34,0,753,754,5,44,0,0,754, + 755,3,0,0,0,755,67,1,0,0,0,756,769,6,34,-1,0,757,758,10,5,0,0,758,768, + 5,186,0,0,759,760,10,4,0,0,760,768,5,187,0,0,761,762,10,3,0,0,762,768, + 5,45,0,0,763,764,10,2,0,0,764,768,5,46,0,0,765,766,10,1,0,0,766,768,5, + 47,0,0,767,757,1,0,0,0,767,759,1,0,0,0,767,761,1,0,0,0,767,763,1,0,0,0, + 767,765,1,0,0,0,768,771,1,0,0,0,769,767,1,0,0,0,769,770,1,0,0,0,770,69, + 1,0,0,0,771,769,1,0,0,0,772,773,5,48,0,0,773,774,5,36,0,0,774,775,5,30, + 0,0,775,776,3,300,150,0,776,777,5,31,0,0,777,71,1,0,0,0,778,779,5,49,0, + 0,779,780,3,2,1,0,780,781,6,36,-1,0,781,73,1,0,0,0,782,788,5,50,0,0,783, + 784,3,76,38,0,784,785,6,37,-1,0,785,787,1,0,0,0,786,783,1,0,0,0,787,790, + 1,0,0,0,788,786,1,0,0,0,788,789,1,0,0,0,789,791,1,0,0,0,790,788,1,0,0, + 0,791,792,3,2,1,0,792,793,3,182,91,0,793,794,3,78,39,0,794,795,3,80,40, + 0,795,796,6,37,-1,0,796,75,1,0,0,0,797,798,5,51,0,0,798,862,6,38,-1,0, + 799,800,5,52,0,0,800,862,6,38,-1,0,801,802,5,199,0,0,802,862,6,38,-1,0, + 803,804,5,202,0,0,804,862,6,38,-1,0,805,806,5,221,0,0,806,862,6,38,-1, + 0,807,808,5,53,0,0,808,862,6,38,-1,0,809,810,5,54,0,0,810,862,6,38,-1, + 0,811,812,5,55,0,0,812,862,6,38,-1,0,813,814,5,56,0,0,814,862,6,38,-1, + 0,815,816,5,244,0,0,816,862,6,38,-1,0,817,818,5,15,0,0,818,862,6,38,-1, + 0,819,820,5,224,0,0,820,862,6,38,-1,0,821,822,5,57,0,0,822,862,6,38,-1, + 0,823,824,5,58,0,0,824,862,6,38,-1,0,825,826,5,59,0,0,826,862,6,38,-1, + 0,827,828,5,60,0,0,828,862,6,38,-1,0,829,830,5,61,0,0,830,862,6,38,-1, + 0,831,832,5,62,0,0,832,833,5,51,0,0,833,862,6,38,-1,0,834,835,5,62,0,0, + 835,836,5,52,0,0,836,862,6,38,-1,0,837,838,5,62,0,0,838,839,5,63,0,0,839, + 862,6,38,-1,0,840,841,5,62,0,0,841,842,5,64,0,0,842,862,6,38,-1,0,843, + 844,5,62,0,0,844,845,5,65,0,0,845,862,6,38,-1,0,846,847,5,62,0,0,847,848, + 5,66,0,0,848,862,6,38,-1,0,849,850,5,67,0,0,850,862,6,38,-1,0,851,852, + 5,68,0,0,852,862,6,38,-1,0,853,854,5,69,0,0,854,862,6,38,-1,0,855,856, + 5,70,0,0,856,857,5,30,0,0,857,858,3,32,16,0,858,859,5,31,0,0,859,860,6, + 38,-1,0,860,862,1,0,0,0,861,797,1,0,0,0,861,799,1,0,0,0,861,801,1,0,0, + 0,861,803,1,0,0,0,861,805,1,0,0,0,861,807,1,0,0,0,861,809,1,0,0,0,861, + 811,1,0,0,0,861,813,1,0,0,0,861,815,1,0,0,0,861,817,1,0,0,0,861,819,1, + 0,0,0,861,821,1,0,0,0,861,823,1,0,0,0,861,825,1,0,0,0,861,827,1,0,0,0, + 861,829,1,0,0,0,861,831,1,0,0,0,861,834,1,0,0,0,861,837,1,0,0,0,861,840, + 1,0,0,0,861,843,1,0,0,0,861,846,1,0,0,0,861,849,1,0,0,0,861,851,1,0,0, + 0,861,853,1,0,0,0,861,855,1,0,0,0,862,77,1,0,0,0,863,869,1,0,0,0,864,865, + 5,71,0,0,865,866,3,124,62,0,866,867,6,39,-1,0,867,869,1,0,0,0,868,863, + 1,0,0,0,868,864,1,0,0,0,869,79,1,0,0,0,870,876,1,0,0,0,871,872,5,72,0, + 0,872,873,3,84,42,0,873,874,6,40,-1,0,874,876,1,0,0,0,875,870,1,0,0,0, + 875,871,1,0,0,0,876,81,1,0,0,0,877,879,3,198,99,0,878,877,1,0,0,0,879, + 882,1,0,0,0,880,878,1,0,0,0,880,881,1,0,0,0,881,83,1,0,0,0,882,880,1,0, + 0,0,883,884,3,124,62,0,884,885,6,42,-1,0,885,886,5,28,0,0,886,888,1,0, + 0,0,887,883,1,0,0,0,888,891,1,0,0,0,889,887,1,0,0,0,889,890,1,0,0,0,890, + 892,1,0,0,0,891,889,1,0,0,0,892,893,3,124,62,0,893,894,6,42,-1,0,894,85, + 1,0,0,0,895,896,7,5,0,0,896,87,1,0,0,0,897,898,3,86,43,0,898,899,3,32, + 16,0,899,900,5,264,0,0,900,1001,1,0,0,0,901,902,3,86,43,0,902,903,3,32, + 16,0,903,1001,1,0,0,0,904,905,3,86,43,0,905,906,3,32,16,0,906,907,5,75, + 0,0,907,908,3,32,16,0,908,909,5,264,0,0,909,1001,1,0,0,0,910,911,3,86, + 43,0,911,912,3,32,16,0,912,913,5,75,0,0,913,914,3,32,16,0,914,1001,1,0, + 0,0,915,916,3,86,43,0,916,917,3,32,16,0,917,918,5,75,0,0,918,919,3,32, + 16,0,919,920,5,28,0,0,920,921,3,32,16,0,921,922,5,264,0,0,922,1001,1,0, + 0,0,923,924,3,86,43,0,924,925,3,32,16,0,925,926,5,75,0,0,926,927,3,32, + 16,0,927,928,5,28,0,0,928,929,3,32,16,0,929,1001,1,0,0,0,930,931,3,86, + 43,0,931,932,3,32,16,0,932,933,5,28,0,0,933,934,3,32,16,0,934,935,5,75, + 0,0,935,936,3,32,16,0,936,937,5,264,0,0,937,1001,1,0,0,0,938,939,3,86, + 43,0,939,940,3,32,16,0,940,941,5,28,0,0,941,942,3,32,16,0,942,943,5,75, + 0,0,943,944,3,32,16,0,944,1001,1,0,0,0,945,946,3,86,43,0,946,947,3,32, + 16,0,947,948,5,28,0,0,948,949,3,32,16,0,949,950,5,75,0,0,950,951,3,32, + 16,0,951,952,5,28,0,0,952,953,3,32,16,0,953,954,5,264,0,0,954,1001,1,0, + 0,0,955,956,3,86,43,0,956,957,3,32,16,0,957,958,5,28,0,0,958,959,3,32, + 16,0,959,960,5,75,0,0,960,961,3,32,16,0,961,962,5,28,0,0,962,963,3,32, + 16,0,963,1001,1,0,0,0,964,965,3,86,43,0,965,966,3,32,16,0,966,967,5,263, + 0,0,967,1001,1,0,0,0,968,969,3,86,43,0,969,970,3,32,16,0,970,971,5,75, + 0,0,971,972,3,32,16,0,972,973,5,263,0,0,973,1001,1,0,0,0,974,975,3,86, + 43,0,975,976,3,32,16,0,976,977,5,75,0,0,977,978,3,32,16,0,978,979,5,28, + 0,0,979,980,3,32,16,0,980,981,5,263,0,0,981,1001,1,0,0,0,982,983,3,86, + 43,0,983,984,3,32,16,0,984,985,5,28,0,0,985,986,3,32,16,0,986,987,5,75, + 0,0,987,988,3,32,16,0,988,989,5,263,0,0,989,1001,1,0,0,0,990,991,3,86, + 43,0,991,992,3,32,16,0,992,993,5,28,0,0,993,994,3,32,16,0,994,995,5,75, + 0,0,995,996,3,32,16,0,996,997,5,28,0,0,997,998,3,32,16,0,998,999,5,263, + 0,0,999,1001,1,0,0,0,1000,897,1,0,0,0,1000,901,1,0,0,0,1000,904,1,0,0, + 0,1000,910,1,0,0,0,1000,915,1,0,0,0,1000,923,1,0,0,0,1000,930,1,0,0,0, + 1000,938,1,0,0,0,1000,945,1,0,0,0,1000,955,1,0,0,0,1000,964,1,0,0,0,1000, + 968,1,0,0,0,1000,974,1,0,0,0,1000,982,1,0,0,0,1000,990,1,0,0,0,1001,89, + 1,0,0,0,1002,1006,5,21,0,0,1003,1005,3,92,46,0,1004,1003,1,0,0,0,1005, + 1008,1,0,0,0,1006,1004,1,0,0,0,1006,1007,1,0,0,0,1007,1009,1,0,0,0,1008, + 1006,1,0,0,0,1009,1010,3,2,1,0,1010,1011,3,94,47,0,1011,1012,5,180,0,0, + 1012,1013,5,36,0,0,1013,1014,5,30,0,0,1014,1015,3,300,150,0,1015,1016, + 5,31,0,0,1016,1017,3,94,47,0,1017,1029,1,0,0,0,1018,1022,5,21,0,0,1019, + 1021,3,92,46,0,1020,1019,1,0,0,0,1021,1024,1,0,0,0,1022,1020,1,0,0,0,1022, + 1023,1,0,0,0,1023,1025,1,0,0,0,1024,1022,1,0,0,0,1025,1026,3,2,1,0,1026, + 1027,3,94,47,0,1027,1029,1,0,0,0,1028,1002,1,0,0,0,1028,1018,1,0,0,0,1029, + 91,1,0,0,0,1030,1031,5,76,0,0,1031,93,1,0,0,0,1032,1035,1,0,0,0,1033,1035, + 5,298,0,0,1034,1032,1,0,0,0,1034,1033,1,0,0,0,1035,95,1,0,0,0,1036,1037, + 7,6,0,0,1037,97,1,0,0,0,1038,1040,3,96,48,0,1039,1038,1,0,0,0,1040,1043, + 1,0,0,0,1041,1039,1,0,0,0,1041,1042,1,0,0,0,1042,99,1,0,0,0,1043,1041, + 1,0,0,0,1044,1070,3,102,51,0,1045,1046,5,280,0,0,1046,1047,3,168,84,0, + 1047,1048,6,50,-1,0,1048,1070,1,0,0,0,1049,1050,5,286,0,0,1050,1051,3, + 178,89,0,1051,1052,6,50,-1,0,1052,1070,1,0,0,0,1053,1054,5,286,0,0,1054, + 1055,3,174,87,0,1055,1056,6,50,-1,0,1056,1070,1,0,0,0,1057,1058,5,284, + 0,0,1058,1059,3,124,62,0,1059,1060,6,50,-1,0,1060,1070,1,0,0,0,1061,1062, + 5,281,0,0,1062,1063,3,104,52,0,1063,1064,6,50,-1,0,1064,1070,1,0,0,0,1065, + 1066,5,287,0,0,1066,1067,3,50,25,0,1067,1068,6,50,-1,0,1068,1070,1,0,0, + 0,1069,1044,1,0,0,0,1069,1045,1,0,0,0,1069,1049,1,0,0,0,1069,1053,1,0, + 0,0,1069,1057,1,0,0,0,1069,1061,1,0,0,0,1069,1065,1,0,0,0,1070,101,1,0, + 0,0,1071,1072,5,275,0,0,1072,1150,6,51,-1,0,1073,1074,5,276,0,0,1074,1075, + 3,32,16,0,1075,1076,6,51,-1,0,1076,1150,1,0,0,0,1077,1078,5,276,0,0,1078, + 1079,3,0,0,0,1079,1080,6,51,-1,0,1080,1150,1,0,0,0,1081,1082,5,277,0,0, + 1082,1083,3,32,16,0,1083,1084,6,51,-1,0,1084,1150,1,0,0,0,1085,1086,5, + 278,0,0,1086,1087,3,34,17,0,1087,1088,6,51,-1,0,1088,1150,1,0,0,0,1089, + 1090,5,279,0,0,1090,1091,3,36,18,0,1091,1092,6,51,-1,0,1092,1150,1,0,0, + 0,1093,1094,5,279,0,0,1094,1095,3,34,17,0,1095,1096,6,51,-1,0,1096,1150, + 1,0,0,0,1097,1098,5,279,0,0,1098,1099,5,30,0,0,1099,1100,3,300,150,0,1100, + 1101,5,31,0,0,1101,1102,6,51,-1,0,1102,1150,1,0,0,0,1103,1104,5,279,0, + 0,1104,1105,5,84,0,0,1105,1106,5,30,0,0,1106,1107,3,300,150,0,1107,1108, + 5,31,0,0,1108,1109,6,51,-1,0,1109,1150,1,0,0,0,1110,1111,5,282,0,0,1111, + 1112,3,32,16,0,1112,1113,6,51,-1,0,1113,1150,1,0,0,0,1114,1115,5,282,0, + 0,1115,1116,3,0,0,0,1116,1117,6,51,-1,0,1117,1150,1,0,0,0,1118,1119,5, + 285,0,0,1119,1120,3,6,3,0,1120,1121,6,51,-1,0,1121,1150,1,0,0,0,1122,1123, + 5,285,0,0,1123,1124,5,224,0,0,1124,1125,5,30,0,0,1125,1126,3,6,3,0,1126, + 1127,5,31,0,0,1127,1128,6,51,-1,0,1128,1150,1,0,0,0,1129,1130,5,285,0, + 0,1130,1131,5,84,0,0,1131,1132,5,30,0,0,1132,1133,3,300,150,0,1133,1134, + 5,31,0,0,1134,1135,6,51,-1,0,1135,1150,1,0,0,0,1136,1137,5,287,0,0,1137, + 1138,3,32,16,0,1138,1139,6,51,-1,0,1139,1150,1,0,0,0,1140,1141,5,283,0, + 0,1141,1147,6,51,-1,0,1142,1143,5,30,0,0,1143,1144,3,106,53,0,1144,1145, + 5,31,0,0,1145,1148,1,0,0,0,1146,1148,5,85,0,0,1147,1142,1,0,0,0,1147,1146, + 1,0,0,0,1148,1150,1,0,0,0,1149,1071,1,0,0,0,1149,1073,1,0,0,0,1149,1077, + 1,0,0,0,1149,1081,1,0,0,0,1149,1085,1,0,0,0,1149,1089,1,0,0,0,1149,1093, + 1,0,0,0,1149,1097,1,0,0,0,1149,1103,1,0,0,0,1149,1110,1,0,0,0,1149,1114, + 1,0,0,0,1149,1118,1,0,0,0,1149,1122,1,0,0,0,1149,1129,1,0,0,0,1149,1136, + 1,0,0,0,1149,1140,1,0,0,0,1150,103,1,0,0,0,1151,1152,3,170,85,0,1152,1153, + 3,138,69,0,1153,1154,3,112,56,0,1154,1155,6,52,-1,0,1155,105,1,0,0,0,1156, + 1181,1,0,0,0,1157,1158,3,0,0,0,1158,1159,6,53,-1,0,1159,1164,1,0,0,0,1160, + 1161,3,32,16,0,1161,1162,6,53,-1,0,1162,1164,1,0,0,0,1163,1157,1,0,0,0, + 1163,1160,1,0,0,0,1164,1165,1,0,0,0,1165,1166,5,28,0,0,1166,1168,1,0,0, + 0,1167,1163,1,0,0,0,1168,1171,1,0,0,0,1169,1167,1,0,0,0,1169,1170,1,0, + 0,0,1170,1178,1,0,0,0,1171,1169,1,0,0,0,1172,1173,3,0,0,0,1173,1174,6, + 53,-1,0,1174,1179,1,0,0,0,1175,1176,3,32,16,0,1176,1177,6,53,-1,0,1177, + 1179,1,0,0,0,1178,1172,1,0,0,0,1178,1175,1,0,0,0,1179,1181,1,0,0,0,1180, + 1156,1,0,0,0,1180,1169,1,0,0,0,1181,107,1,0,0,0,1182,1189,5,86,0,0,1183, + 1184,3,138,69,0,1184,1185,6,54,-1,0,1185,1186,5,28,0,0,1186,1188,1,0,0, + 0,1187,1183,1,0,0,0,1188,1191,1,0,0,0,1189,1187,1,0,0,0,1189,1190,1,0, + 0,0,1190,1192,1,0,0,0,1191,1189,1,0,0,0,1192,1193,3,138,69,0,1193,1194, + 6,54,-1,0,1194,1195,5,87,0,0,1195,109,1,0,0,0,1196,1203,5,42,0,0,1197, + 1198,3,146,73,0,1198,1199,6,55,-1,0,1199,1200,5,28,0,0,1200,1202,1,0,0, + 0,1201,1197,1,0,0,0,1202,1205,1,0,0,0,1203,1201,1,0,0,0,1203,1204,1,0, + 0,0,1204,1206,1,0,0,0,1205,1203,1,0,0,0,1206,1207,3,146,73,0,1207,1208, + 6,55,-1,0,1208,1209,5,43,0,0,1209,111,1,0,0,0,1210,1217,5,30,0,0,1211, + 1212,3,114,57,0,1212,1213,6,56,-1,0,1213,1214,5,28,0,0,1214,1216,1,0,0, + 0,1215,1211,1,0,0,0,1216,1219,1,0,0,0,1217,1215,1,0,0,0,1217,1218,1,0, + 0,0,1218,1220,1,0,0,0,1219,1217,1,0,0,0,1220,1221,3,114,57,0,1221,1222, + 6,56,-1,0,1222,1223,5,31,0,0,1223,1226,1,0,0,0,1224,1226,5,85,0,0,1225, + 1210,1,0,0,0,1225,1224,1,0,0,0,1226,113,1,0,0,0,1227,1228,5,177,0,0,1228, + 1238,6,57,-1,0,1229,1230,3,230,115,0,1230,1231,3,138,69,0,1231,1233,3, + 226,113,0,1232,1234,3,0,0,0,1233,1232,1,0,0,0,1233,1234,1,0,0,0,1234,1235, + 1,0,0,0,1235,1236,6,57,-1,0,1236,1238,1,0,0,0,1237,1227,1,0,0,0,1237,1229, + 1,0,0,0,1238,115,1,0,0,0,1239,1240,5,42,0,0,1240,1241,3,2,1,0,1241,1242, + 5,43,0,0,1242,1243,3,118,59,0,1243,1244,6,58,-1,0,1244,1277,1,0,0,0,1245, + 1246,5,42,0,0,1246,1247,3,174,87,0,1247,1248,5,43,0,0,1248,1249,3,118, + 59,0,1249,1250,6,58,-1,0,1250,1277,1,0,0,0,1251,1252,5,42,0,0,1252,1253, + 5,262,0,0,1253,1254,5,43,0,0,1254,1255,3,118,59,0,1255,1256,6,58,-1,0, + 1256,1277,1,0,0,0,1257,1258,5,42,0,0,1258,1259,5,198,0,0,1259,1260,3,2, + 1,0,1260,1261,5,43,0,0,1261,1262,3,118,59,0,1262,1263,6,58,-1,0,1263,1277, + 1,0,0,0,1264,1265,3,118,59,0,1265,1266,6,58,-1,0,1266,1277,1,0,0,0,1267, + 1268,3,174,87,0,1268,1269,6,58,-1,0,1269,1277,1,0,0,0,1270,1271,5,257, + 0,0,1271,1277,6,58,-1,0,1272,1273,5,258,0,0,1273,1277,6,58,-1,0,1274,1275, + 5,259,0,0,1275,1277,6,58,-1,0,1276,1239,1,0,0,0,1276,1245,1,0,0,0,1276, + 1251,1,0,0,0,1276,1257,1,0,0,0,1276,1264,1,0,0,0,1276,1267,1,0,0,0,1276, + 1270,1,0,0,0,1276,1272,1,0,0,0,1276,1274,1,0,0,0,1277,117,1,0,0,0,1278, + 1279,3,2,1,0,1279,1280,6,59,-1,0,1280,1281,5,88,0,0,1281,1283,1,0,0,0, + 1282,1278,1,0,0,0,1283,1286,1,0,0,0,1284,1282,1,0,0,0,1284,1285,1,0,0, + 0,1285,1287,1,0,0,0,1286,1284,1,0,0,0,1287,1288,3,2,1,0,1288,1289,6,59, + -1,0,1289,119,1,0,0,0,1290,1292,3,122,61,0,1291,1290,1,0,0,0,1292,1295, + 1,0,0,0,1293,1291,1,0,0,0,1293,1294,1,0,0,0,1294,121,1,0,0,0,1295,1293, + 1,0,0,0,1296,1297,5,180,0,0,1297,1298,5,89,0,0,1298,1302,3,32,16,0,1299, + 1302,3,152,76,0,1300,1302,3,332,166,0,1301,1296,1,0,0,0,1301,1299,1,0, + 0,0,1301,1300,1,0,0,0,1302,123,1,0,0,0,1303,1304,3,116,58,0,1304,1305, + 6,62,-1,0,1305,1321,1,0,0,0,1306,1307,5,42,0,0,1307,1308,3,2,1,0,1308, + 1309,5,43,0,0,1309,1310,6,62,-1,0,1310,1321,1,0,0,0,1311,1312,5,42,0,0, + 1312,1313,5,198,0,0,1313,1314,3,2,1,0,1314,1315,5,43,0,0,1315,1316,6,62, + -1,0,1316,1321,1,0,0,0,1317,1318,3,138,69,0,1318,1319,6,62,-1,0,1319,1321, + 1,0,0,0,1320,1303,1,0,0,0,1320,1306,1,0,0,0,1320,1311,1,0,0,0,1320,1317, + 1,0,0,0,1321,125,1,0,0,0,1322,1334,1,0,0,0,1323,1324,3,130,65,0,1324,1330, + 6,63,-1,0,1325,1326,3,128,64,0,1326,1327,6,63,-1,0,1327,1329,1,0,0,0,1328, + 1325,1,0,0,0,1329,1332,1,0,0,0,1330,1328,1,0,0,0,1330,1331,1,0,0,0,1331, + 1334,1,0,0,0,1332,1330,1,0,0,0,1333,1322,1,0,0,0,1333,1323,1,0,0,0,1334, + 127,1,0,0,0,1335,1336,5,262,0,0,1336,1358,6,64,-1,0,1337,1338,5,261,0, + 0,1338,1358,6,64,-1,0,1339,1340,5,42,0,0,1340,1341,3,32,16,0,1341,1342, + 5,43,0,0,1342,1343,6,64,-1,0,1343,1358,1,0,0,0,1344,1345,5,42,0,0,1345, + 1346,3,32,16,0,1346,1347,5,266,0,0,1347,1348,3,32,16,0,1348,1349,5,43, + 0,0,1349,1350,6,64,-1,0,1350,1358,1,0,0,0,1351,1352,5,42,0,0,1352,1353, + 5,266,0,0,1353,1354,3,32,16,0,1354,1355,5,43,0,0,1355,1356,6,64,-1,0,1356, + 1358,1,0,0,0,1357,1335,1,0,0,0,1357,1337,1,0,0,0,1357,1339,1,0,0,0,1357, + 1344,1,0,0,0,1357,1351,1,0,0,0,1358,129,1,0,0,0,1359,1505,6,65,-1,0,1360, + 1361,5,203,0,0,1361,1362,5,30,0,0,1362,1363,3,6,3,0,1363,1364,5,28,0,0, + 1364,1365,3,6,3,0,1365,1366,5,28,0,0,1366,1367,3,6,3,0,1367,1368,5,28, + 0,0,1368,1369,3,6,3,0,1369,1370,5,31,0,0,1370,1371,6,65,-1,0,1371,1505, + 1,0,0,0,1372,1373,5,203,0,0,1373,1374,5,30,0,0,1374,1375,3,6,3,0,1375, + 1376,5,28,0,0,1376,1377,3,6,3,0,1377,1378,5,31,0,0,1378,1379,6,65,-1,0, + 1379,1505,1,0,0,0,1380,1381,5,204,0,0,1381,1382,5,205,0,0,1382,1383,5, + 42,0,0,1383,1384,3,32,16,0,1384,1385,5,43,0,0,1385,1386,6,65,-1,0,1386, + 1505,1,0,0,0,1387,1388,5,204,0,0,1388,1389,5,206,0,0,1389,1390,5,42,0, + 0,1390,1391,3,32,16,0,1391,1392,5,43,0,0,1392,1393,3,126,63,0,1393,1394, + 6,65,-1,0,1394,1505,1,0,0,0,1395,1396,5,207,0,0,1396,1505,6,65,-1,0,1397, + 1398,5,208,0,0,1398,1505,6,65,-1,0,1399,1400,5,209,0,0,1400,1505,6,65, + -1,0,1401,1402,5,201,0,0,1402,1505,6,65,-1,0,1403,1404,5,183,0,0,1404, + 1505,6,65,-1,0,1405,1406,5,184,0,0,1406,1505,6,65,-1,0,1407,1408,5,185, + 0,0,1408,1505,6,65,-1,0,1409,1410,5,186,0,0,1410,1505,6,65,-1,0,1411,1412, + 5,187,0,0,1412,1505,6,65,-1,0,1413,1414,5,188,0,0,1414,1505,6,65,-1,0, + 1415,1416,5,189,0,0,1416,1505,6,65,-1,0,1417,1418,5,210,0,0,1418,1505, + 6,65,-1,0,1419,1420,5,190,0,0,1420,1505,6,65,-1,0,1421,1422,5,191,0,0, + 1422,1505,6,65,-1,0,1423,1424,5,192,0,0,1424,1505,6,65,-1,0,1425,1426, + 5,193,0,0,1426,1505,6,65,-1,0,1427,1428,5,211,0,0,1428,1505,6,65,-1,0, + 1429,1430,5,212,0,0,1430,1505,6,65,-1,0,1431,1432,5,213,0,0,1432,1505, + 6,65,-1,0,1433,1434,5,214,0,0,1434,1505,6,65,-1,0,1435,1436,5,215,0,0, + 1436,1505,6,65,-1,0,1437,1438,5,216,0,0,1438,1505,6,65,-1,0,1439,1440, + 5,217,0,0,1440,1505,6,65,-1,0,1441,1442,5,218,0,0,1442,1443,3,132,66,0, + 1443,1444,6,65,-1,0,1444,1505,1,0,0,0,1445,1446,5,219,0,0,1446,1447,3, + 132,66,0,1447,1448,6,65,-1,0,1448,1505,1,0,0,0,1449,1450,5,220,0,0,1450, + 1505,6,65,-1,0,1451,1452,5,221,0,0,1452,1453,3,132,66,0,1453,1454,6,65, + -1,0,1454,1505,1,0,0,0,1455,1456,5,222,0,0,1456,1457,3,134,67,0,1457,1458, + 6,65,-1,0,1458,1505,1,0,0,0,1459,1460,5,222,0,0,1460,1461,3,134,67,0,1461, + 1462,5,28,0,0,1462,1463,3,6,3,0,1463,1464,6,65,-1,0,1464,1505,1,0,0,0, + 1465,1466,5,194,0,0,1466,1505,6,65,-1,0,1467,1468,5,195,0,0,1468,1505, + 6,65,-1,0,1469,1470,5,90,0,0,1470,1471,5,184,0,0,1471,1505,6,65,-1,0,1472, + 1473,5,90,0,0,1473,1474,5,185,0,0,1474,1505,6,65,-1,0,1475,1476,5,90,0, + 0,1476,1477,5,186,0,0,1477,1505,6,65,-1,0,1478,1479,5,90,0,0,1479,1480, + 5,187,0,0,1480,1505,6,65,-1,0,1481,1482,5,62,0,0,1482,1483,5,220,0,0,1483, + 1505,6,65,-1,0,1484,1485,5,223,0,0,1485,1505,6,65,-1,0,1486,1487,5,224, + 0,0,1487,1488,5,213,0,0,1488,1505,6,65,-1,0,1489,1490,5,225,0,0,1490,1505, + 6,65,-1,0,1491,1492,5,207,0,0,1492,1493,5,183,0,0,1493,1505,6,65,-1,0, + 1494,1495,5,226,0,0,1495,1505,6,65,-1,0,1496,1497,5,228,0,0,1497,1505, + 6,65,-1,0,1498,1499,5,34,0,0,1499,1500,5,227,0,0,1500,1505,6,65,-1,0,1501, + 1502,3,2,1,0,1502,1503,6,65,-1,0,1503,1505,1,0,0,0,1504,1359,1,0,0,0,1504, + 1360,1,0,0,0,1504,1372,1,0,0,0,1504,1380,1,0,0,0,1504,1387,1,0,0,0,1504, + 1395,1,0,0,0,1504,1397,1,0,0,0,1504,1399,1,0,0,0,1504,1401,1,0,0,0,1504, + 1403,1,0,0,0,1504,1405,1,0,0,0,1504,1407,1,0,0,0,1504,1409,1,0,0,0,1504, + 1411,1,0,0,0,1504,1413,1,0,0,0,1504,1415,1,0,0,0,1504,1417,1,0,0,0,1504, + 1419,1,0,0,0,1504,1421,1,0,0,0,1504,1423,1,0,0,0,1504,1425,1,0,0,0,1504, + 1427,1,0,0,0,1504,1429,1,0,0,0,1504,1431,1,0,0,0,1504,1433,1,0,0,0,1504, + 1435,1,0,0,0,1504,1437,1,0,0,0,1504,1439,1,0,0,0,1504,1441,1,0,0,0,1504, + 1445,1,0,0,0,1504,1449,1,0,0,0,1504,1451,1,0,0,0,1504,1455,1,0,0,0,1504, + 1459,1,0,0,0,1504,1465,1,0,0,0,1504,1467,1,0,0,0,1504,1469,1,0,0,0,1504, + 1472,1,0,0,0,1504,1475,1,0,0,0,1504,1478,1,0,0,0,1504,1481,1,0,0,0,1504, + 1484,1,0,0,0,1504,1486,1,0,0,0,1504,1489,1,0,0,0,1504,1491,1,0,0,0,1504, + 1494,1,0,0,0,1504,1496,1,0,0,0,1504,1498,1,0,0,0,1504,1501,1,0,0,0,1505, + 131,1,0,0,0,1506,1515,1,0,0,0,1507,1508,5,30,0,0,1508,1509,5,91,0,0,1509, + 1510,5,36,0,0,1510,1511,3,32,16,0,1511,1512,5,31,0,0,1512,1513,6,66,-1, + 0,1513,1515,1,0,0,0,1514,1506,1,0,0,0,1514,1507,1,0,0,0,1515,133,1,0,0, + 0,1516,1527,1,0,0,0,1517,1518,3,136,68,0,1518,1523,6,67,-1,0,1519,1520, + 7,7,0,0,1520,1522,6,67,-1,0,1521,1519,1,0,0,0,1522,1525,1,0,0,0,1523,1521, + 1,0,0,0,1523,1524,1,0,0,0,1524,1527,1,0,0,0,1525,1523,1,0,0,0,1526,1516, + 1,0,0,0,1526,1517,1,0,0,0,1527,135,1,0,0,0,1528,1529,5,178,0,0,1529,1609, + 6,68,-1,0,1530,1531,5,207,0,0,1531,1609,6,68,-1,0,1532,1533,5,208,0,0, + 1533,1609,6,68,-1,0,1534,1535,5,201,0,0,1535,1609,6,68,-1,0,1536,1537, + 5,183,0,0,1537,1609,6,68,-1,0,1538,1539,5,184,0,0,1539,1609,6,68,-1,0, + 1540,1541,5,185,0,0,1541,1609,6,68,-1,0,1542,1543,5,186,0,0,1543,1609, + 6,68,-1,0,1544,1545,5,187,0,0,1545,1609,6,68,-1,0,1546,1547,5,188,0,0, + 1547,1609,6,68,-1,0,1548,1549,5,189,0,0,1549,1609,6,68,-1,0,1550,1551, + 5,190,0,0,1551,1609,6,68,-1,0,1552,1553,5,191,0,0,1553,1609,6,68,-1,0, + 1554,1555,5,192,0,0,1555,1609,6,68,-1,0,1556,1557,5,193,0,0,1557,1609, + 6,68,-1,0,1558,1559,5,262,0,0,1559,1609,6,68,-1,0,1560,1561,5,211,0,0, + 1561,1609,6,68,-1,0,1562,1563,5,212,0,0,1563,1609,6,68,-1,0,1564,1565, + 5,213,0,0,1565,1609,6,68,-1,0,1566,1567,5,214,0,0,1567,1609,6,68,-1,0, + 1568,1569,5,215,0,0,1569,1609,6,68,-1,0,1570,1571,5,218,0,0,1571,1609, + 6,68,-1,0,1572,1573,5,219,0,0,1573,1609,6,68,-1,0,1574,1575,5,222,0,0, + 1575,1609,6,68,-1,0,1576,1577,5,194,0,0,1577,1609,6,68,-1,0,1578,1579, + 5,195,0,0,1579,1609,6,68,-1,0,1580,1581,5,210,0,0,1581,1609,6,68,-1,0, + 1582,1583,5,230,0,0,1583,1609,6,68,-1,0,1584,1585,5,231,0,0,1585,1609, + 6,68,-1,0,1586,1587,5,232,0,0,1587,1609,6,68,-1,0,1588,1589,5,233,0,0, + 1589,1609,6,68,-1,0,1590,1591,5,234,0,0,1591,1609,6,68,-1,0,1592,1593, + 5,235,0,0,1593,1609,6,68,-1,0,1594,1595,5,236,0,0,1595,1609,6,68,-1,0, + 1596,1597,5,237,0,0,1597,1609,6,68,-1,0,1598,1599,5,238,0,0,1599,1609, + 6,68,-1,0,1600,1601,5,239,0,0,1601,1609,6,68,-1,0,1602,1603,5,240,0,0, + 1603,1609,6,68,-1,0,1604,1605,5,241,0,0,1605,1609,6,68,-1,0,1606,1607, + 5,242,0,0,1607,1609,6,68,-1,0,1608,1528,1,0,0,0,1608,1530,1,0,0,0,1608, + 1532,1,0,0,0,1608,1534,1,0,0,0,1608,1536,1,0,0,0,1608,1538,1,0,0,0,1608, + 1540,1,0,0,0,1608,1542,1,0,0,0,1608,1544,1,0,0,0,1608,1546,1,0,0,0,1608, + 1548,1,0,0,0,1608,1550,1,0,0,0,1608,1552,1,0,0,0,1608,1554,1,0,0,0,1608, + 1556,1,0,0,0,1608,1558,1,0,0,0,1608,1560,1,0,0,0,1608,1562,1,0,0,0,1608, + 1564,1,0,0,0,1608,1566,1,0,0,0,1608,1568,1,0,0,0,1608,1570,1,0,0,0,1608, + 1572,1,0,0,0,1608,1574,1,0,0,0,1608,1576,1,0,0,0,1608,1578,1,0,0,0,1608, + 1580,1,0,0,0,1608,1582,1,0,0,0,1608,1584,1,0,0,0,1608,1586,1,0,0,0,1608, + 1588,1,0,0,0,1608,1590,1,0,0,0,1608,1592,1,0,0,0,1608,1594,1,0,0,0,1608, + 1596,1,0,0,0,1608,1598,1,0,0,0,1608,1600,1,0,0,0,1608,1602,1,0,0,0,1608, + 1604,1,0,0,0,1608,1606,1,0,0,0,1609,137,1,0,0,0,1610,1611,3,142,71,0,1611, + 1617,6,69,-1,0,1612,1613,3,140,70,0,1613,1614,6,69,-1,0,1614,1616,1,0, + 0,0,1615,1612,1,0,0,0,1616,1619,1,0,0,0,1617,1615,1,0,0,0,1617,1618,1, + 0,0,0,1618,139,1,0,0,0,1619,1617,1,0,0,0,1620,1621,5,261,0,0,1621,1650, + 6,70,-1,0,1622,1623,5,42,0,0,1623,1624,5,43,0,0,1624,1650,6,70,-1,0,1625, + 1626,3,110,55,0,1626,1627,6,70,-1,0,1627,1650,1,0,0,0,1628,1629,5,260, + 0,0,1629,1650,6,70,-1,0,1630,1631,5,262,0,0,1631,1650,6,70,-1,0,1632,1633, + 5,92,0,0,1633,1650,6,70,-1,0,1634,1635,5,93,0,0,1635,1636,5,30,0,0,1636, + 1637,3,124,62,0,1637,1638,5,31,0,0,1638,1639,6,70,-1,0,1639,1650,1,0,0, + 0,1640,1641,5,94,0,0,1641,1642,5,30,0,0,1642,1643,3,124,62,0,1643,1644, + 5,31,0,0,1644,1645,6,70,-1,0,1645,1650,1,0,0,0,1646,1647,3,108,54,0,1647, + 1648,6,70,-1,0,1648,1650,1,0,0,0,1649,1620,1,0,0,0,1649,1622,1,0,0,0,1649, + 1625,1,0,0,0,1649,1628,1,0,0,0,1649,1630,1,0,0,0,1649,1632,1,0,0,0,1649, + 1634,1,0,0,0,1649,1640,1,0,0,0,1649,1646,1,0,0,0,1650,141,1,0,0,0,1651, + 1652,5,39,0,0,1652,1653,3,116,58,0,1653,1654,6,71,-1,0,1654,1710,1,0,0, + 0,1655,1656,5,197,0,0,1656,1710,6,71,-1,0,1657,1658,5,199,0,0,1658,1659, + 5,39,0,0,1659,1660,3,116,58,0,1660,1661,6,71,-1,0,1661,1710,1,0,0,0,1662, + 1663,5,200,0,0,1663,1664,3,116,58,0,1664,1665,6,71,-1,0,1665,1710,1,0, + 0,0,1666,1667,5,226,0,0,1667,1668,3,170,85,0,1668,1669,3,138,69,0,1669, + 1670,5,262,0,0,1670,1671,3,112,56,0,1671,1672,6,71,-1,0,1672,1710,1,0, + 0,0,1673,1674,5,253,0,0,1674,1675,3,32,16,0,1675,1676,6,71,-1,0,1676,1710, + 1,0,0,0,1677,1678,5,252,0,0,1678,1679,3,32,16,0,1679,1680,6,71,-1,0,1680, + 1710,1,0,0,0,1681,1682,5,253,0,0,1682,1683,3,2,1,0,1683,1684,6,71,-1,0, + 1684,1710,1,0,0,0,1685,1686,5,252,0,0,1686,1687,3,2,1,0,1687,1688,6,71, + -1,0,1688,1710,1,0,0,0,1689,1690,5,254,0,0,1690,1710,6,71,-1,0,1691,1692, + 5,201,0,0,1692,1710,6,71,-1,0,1693,1694,3,148,74,0,1694,1695,6,71,-1,0, + 1695,1710,1,0,0,0,1696,1697,3,150,75,0,1697,1698,6,71,-1,0,1698,1710,1, + 0,0,0,1699,1700,3,144,72,0,1700,1701,6,71,-1,0,1701,1710,1,0,0,0,1702, + 1703,3,2,1,0,1703,1704,6,71,-1,0,1704,1710,1,0,0,0,1705,1706,5,177,0,0, + 1706,1707,3,138,69,0,1707,1708,6,71,-1,0,1708,1710,1,0,0,0,1709,1651,1, + 0,0,0,1709,1655,1,0,0,0,1709,1657,1,0,0,0,1709,1662,1,0,0,0,1709,1666, + 1,0,0,0,1709,1673,1,0,0,0,1709,1677,1,0,0,0,1709,1681,1,0,0,0,1709,1685, + 1,0,0,0,1709,1689,1,0,0,0,1709,1691,1,0,0,0,1709,1693,1,0,0,0,1709,1696, + 1,0,0,0,1709,1699,1,0,0,0,1709,1702,1,0,0,0,1709,1705,1,0,0,0,1710,143, + 1,0,0,0,1711,1712,5,181,0,0,1712,1750,6,72,-1,0,1713,1714,5,182,0,0,1714, + 1750,6,72,-1,0,1715,1716,5,183,0,0,1716,1750,6,72,-1,0,1717,1718,5,184, + 0,0,1718,1750,6,72,-1,0,1719,1720,5,185,0,0,1720,1750,6,72,-1,0,1721,1722, + 5,186,0,0,1722,1750,6,72,-1,0,1723,1724,5,187,0,0,1724,1750,6,72,-1,0, + 1725,1726,5,188,0,0,1726,1750,6,72,-1,0,1727,1728,5,189,0,0,1728,1750, + 6,72,-1,0,1729,1730,5,190,0,0,1730,1750,6,72,-1,0,1731,1732,5,191,0,0, + 1732,1750,6,72,-1,0,1733,1734,5,192,0,0,1734,1750,6,72,-1,0,1735,1736, + 5,193,0,0,1736,1750,6,72,-1,0,1737,1738,5,90,0,0,1738,1739,5,184,0,0,1739, + 1750,6,72,-1,0,1740,1741,5,90,0,0,1741,1742,5,185,0,0,1742,1750,6,72,-1, + 0,1743,1744,5,90,0,0,1744,1745,5,186,0,0,1745,1750,6,72,-1,0,1746,1747, + 5,90,0,0,1747,1748,5,187,0,0,1748,1750,6,72,-1,0,1749,1711,1,0,0,0,1749, + 1713,1,0,0,0,1749,1715,1,0,0,0,1749,1717,1,0,0,0,1749,1719,1,0,0,0,1749, + 1721,1,0,0,0,1749,1723,1,0,0,0,1749,1725,1,0,0,0,1749,1727,1,0,0,0,1749, + 1729,1,0,0,0,1749,1731,1,0,0,0,1749,1733,1,0,0,0,1749,1735,1,0,0,0,1749, + 1737,1,0,0,0,1749,1740,1,0,0,0,1749,1743,1,0,0,0,1749,1746,1,0,0,0,1750, + 145,1,0,0,0,1751,1766,1,0,0,0,1752,1766,5,177,0,0,1753,1754,3,32,16,0, + 1754,1755,6,73,-1,0,1755,1766,1,0,0,0,1756,1757,3,32,16,0,1757,1758,5, + 177,0,0,1758,1759,3,32,16,0,1759,1760,6,73,-1,0,1760,1766,1,0,0,0,1761, + 1762,3,32,16,0,1762,1763,5,177,0,0,1763,1764,6,73,-1,0,1764,1766,1,0,0, + 0,1765,1751,1,0,0,0,1765,1752,1,0,0,0,1765,1753,1,0,0,0,1765,1756,1,0, + 0,0,1765,1761,1,0,0,0,1766,147,1,0,0,0,1767,1768,5,1,0,0,1768,1769,5,194, + 0,0,1769,1770,6,74,-1,0,1770,149,1,0,0,0,1771,1775,5,1,0,0,1772,1773,5, + 90,0,0,1773,1776,5,194,0,0,1774,1776,5,195,0,0,1775,1772,1,0,0,0,1775, + 1774,1,0,0,0,1776,1777,1,0,0,0,1777,1778,6,75,-1,0,1778,151,1,0,0,0,1779, + 1780,5,294,0,0,1780,1781,3,166,83,0,1781,1782,3,124,62,0,1782,1783,5,30, + 0,0,1783,1784,3,158,79,0,1784,1785,5,31,0,0,1785,1827,1,0,0,0,1786,1787, + 5,294,0,0,1787,1788,3,166,83,0,1788,1789,3,124,62,0,1789,1790,5,36,0,0, + 1790,1791,5,17,0,0,1791,1792,3,52,26,0,1792,1793,5,18,0,0,1793,1827,1, + 0,0,0,1794,1795,5,294,0,0,1795,1796,3,166,83,0,1796,1797,3,124,62,0,1797, + 1827,1,0,0,0,1798,1799,5,295,0,0,1799,1800,3,166,83,0,1800,1802,5,36,0, + 0,1801,1803,5,84,0,0,1802,1801,1,0,0,0,1802,1803,1,0,0,0,1803,1804,1,0, + 0,0,1804,1805,5,30,0,0,1805,1806,3,300,150,0,1806,1807,5,31,0,0,1807,1827, + 1,0,0,0,1808,1809,5,295,0,0,1809,1810,3,166,83,0,1810,1811,5,84,0,0,1811, + 1812,5,30,0,0,1812,1813,3,300,150,0,1813,1814,5,31,0,0,1814,1827,1,0,0, + 0,1815,1816,5,295,0,0,1816,1817,3,166,83,0,1817,1818,3,6,3,0,1818,1827, + 1,0,0,0,1819,1820,5,295,0,0,1820,1821,3,166,83,0,1821,1822,5,36,0,0,1822, + 1823,5,17,0,0,1823,1824,3,154,77,0,1824,1825,5,18,0,0,1825,1827,1,0,0, + 0,1826,1779,1,0,0,0,1826,1786,1,0,0,0,1826,1794,1,0,0,0,1826,1798,1,0, + 0,0,1826,1808,1,0,0,0,1826,1815,1,0,0,0,1826,1819,1,0,0,0,1827,153,1,0, + 0,0,1828,1839,1,0,0,0,1829,1830,3,156,78,0,1830,1831,5,28,0,0,1831,1833, + 1,0,0,0,1832,1829,1,0,0,0,1833,1836,1,0,0,0,1834,1832,1,0,0,0,1834,1835, + 1,0,0,0,1835,1837,1,0,0,0,1836,1834,1,0,0,0,1837,1839,3,156,78,0,1838, + 1828,1,0,0,0,1838,1834,1,0,0,0,1839,155,1,0,0,0,1840,1841,5,39,0,0,1841, + 1842,5,264,0,0,1842,1843,5,36,0,0,1843,1844,5,17,0,0,1844,1845,3,56,28, + 0,1845,1846,5,18,0,0,1846,1854,1,0,0,0,1847,1848,3,124,62,0,1848,1849, + 5,36,0,0,1849,1850,5,17,0,0,1850,1851,3,56,28,0,1851,1852,5,18,0,0,1852, + 1854,1,0,0,0,1853,1840,1,0,0,0,1853,1847,1,0,0,0,1854,157,1,0,0,0,1855, + 1856,3,160,80,0,1856,1857,5,28,0,0,1857,1859,1,0,0,0,1858,1855,1,0,0,0, + 1859,1862,1,0,0,0,1860,1858,1,0,0,0,1860,1861,1,0,0,0,1861,1863,1,0,0, + 0,1862,1860,1,0,0,0,1863,1864,3,160,80,0,1864,159,1,0,0,0,1865,1866,3, + 6,3,0,1866,1867,5,36,0,0,1867,1868,3,164,82,0,1868,161,1,0,0,0,1869,1870, + 7,8,0,0,1870,163,1,0,0,0,1871,1906,3,162,81,0,1872,1906,3,32,16,0,1873, + 1874,5,186,0,0,1874,1875,5,30,0,0,1875,1876,3,32,16,0,1876,1877,5,31,0, + 0,1877,1906,1,0,0,0,1878,1906,3,6,3,0,1879,1880,3,116,58,0,1880,1881,5, + 30,0,0,1881,1882,5,184,0,0,1882,1883,5,75,0,0,1883,1884,3,32,16,0,1884, + 1885,5,31,0,0,1885,1906,1,0,0,0,1886,1887,3,116,58,0,1887,1888,5,30,0, + 0,1888,1889,5,185,0,0,1889,1890,5,75,0,0,1890,1891,3,32,16,0,1891,1892, + 5,31,0,0,1892,1906,1,0,0,0,1893,1894,3,116,58,0,1894,1895,5,30,0,0,1895, + 1896,5,186,0,0,1896,1897,5,75,0,0,1897,1898,3,32,16,0,1898,1899,5,31,0, + 0,1899,1906,1,0,0,0,1900,1901,3,116,58,0,1901,1902,5,30,0,0,1902,1903, + 3,32,16,0,1903,1904,5,31,0,0,1904,1906,1,0,0,0,1905,1871,1,0,0,0,1905, + 1872,1,0,0,0,1905,1873,1,0,0,0,1905,1878,1,0,0,0,1905,1879,1,0,0,0,1905, + 1886,1,0,0,0,1905,1893,1,0,0,0,1905,1900,1,0,0,0,1906,165,1,0,0,0,1907, + 1908,7,9,0,0,1908,167,1,0,0,0,1909,1910,3,170,85,0,1910,1911,3,138,69, + 0,1911,1912,3,124,62,0,1912,1913,5,176,0,0,1913,1915,3,242,121,0,1914, + 1916,3,108,54,0,1915,1914,1,0,0,0,1915,1916,1,0,0,0,1916,1917,1,0,0,0, + 1917,1918,3,112,56,0,1918,1919,6,84,-1,0,1919,1952,1,0,0,0,1920,1921,3, + 170,85,0,1921,1922,3,138,69,0,1922,1923,3,124,62,0,1923,1924,5,176,0,0, + 1924,1925,3,242,121,0,1925,1926,3,196,98,0,1926,1927,3,112,56,0,1927,1928, + 6,84,-1,0,1928,1952,1,0,0,0,1929,1930,3,170,85,0,1930,1931,3,138,69,0, + 1931,1933,3,242,121,0,1932,1934,3,108,54,0,1933,1932,1,0,0,0,1933,1934, + 1,0,0,0,1934,1935,1,0,0,0,1935,1936,3,112,56,0,1936,1937,6,84,-1,0,1937, + 1952,1,0,0,0,1938,1939,3,170,85,0,1939,1940,3,138,69,0,1940,1941,3,242, + 121,0,1941,1942,3,196,98,0,1942,1943,3,112,56,0,1943,1944,6,84,-1,0,1944, + 1952,1,0,0,0,1945,1946,3,174,87,0,1946,1947,6,84,-1,0,1947,1952,1,0,0, + 0,1948,1949,3,2,1,0,1949,1950,6,84,-1,0,1950,1952,1,0,0,0,1951,1909,1, + 0,0,0,1951,1920,1,0,0,0,1951,1929,1,0,0,0,1951,1938,1,0,0,0,1951,1945, + 1,0,0,0,1951,1948,1,0,0,0,1952,169,1,0,0,0,1953,1954,5,243,0,0,1954,1955, + 3,170,85,0,1955,1956,6,85,-1,0,1956,1971,1,0,0,0,1957,1958,5,244,0,0,1958, + 1959,3,170,85,0,1959,1960,6,85,-1,0,1960,1971,1,0,0,0,1961,1962,3,172, + 86,0,1962,1963,6,85,-1,0,1963,1971,1,0,0,0,1964,1965,5,112,0,0,1965,1966, + 5,30,0,0,1966,1967,3,32,16,0,1967,1968,5,31,0,0,1968,1969,6,85,-1,0,1969, + 1971,1,0,0,0,1970,1953,1,0,0,0,1970,1957,1,0,0,0,1970,1961,1,0,0,0,1970, + 1964,1,0,0,0,1971,171,1,0,0,0,1972,1992,1,0,0,0,1973,1974,5,245,0,0,1974, + 1992,6,86,-1,0,1975,1976,5,246,0,0,1976,1992,6,86,-1,0,1977,1978,5,247, + 0,0,1978,1979,5,248,0,0,1979,1992,6,86,-1,0,1980,1981,5,247,0,0,1981,1982, + 5,249,0,0,1982,1992,6,86,-1,0,1983,1984,5,247,0,0,1984,1985,5,250,0,0, + 1985,1992,6,86,-1,0,1986,1987,5,247,0,0,1987,1988,5,251,0,0,1988,1992, + 6,86,-1,0,1989,1990,5,247,0,0,1990,1992,6,86,-1,0,1991,1972,1,0,0,0,1991, + 1973,1,0,0,0,1991,1975,1,0,0,0,1991,1977,1,0,0,0,1991,1980,1,0,0,0,1991, + 1983,1,0,0,0,1991,1986,1,0,0,0,1991,1989,1,0,0,0,1992,173,1,0,0,0,1993, + 1994,5,113,0,0,1994,1995,5,30,0,0,1995,1996,3,32,16,0,1996,1997,5,31,0, + 0,1997,1998,6,87,-1,0,1998,175,1,0,0,0,1999,2000,5,226,0,0,2000,2001,3, + 168,84,0,2001,2002,6,88,-1,0,2002,2011,1,0,0,0,2003,2004,5,37,0,0,2004, + 2005,3,178,89,0,2005,2006,6,88,-1,0,2006,2011,1,0,0,0,2007,2008,3,174, + 87,0,2008,2009,6,88,-1,0,2009,2011,1,0,0,0,2010,1999,1,0,0,0,2010,2003, + 1,0,0,0,2010,2007,1,0,0,0,2011,177,1,0,0,0,2012,2013,3,138,69,0,2013,2014, + 3,124,62,0,2014,2015,5,176,0,0,2015,2016,3,2,1,0,2016,2017,6,89,-1,0,2017, + 2026,1,0,0,0,2018,2019,3,138,69,0,2019,2020,3,2,1,0,2020,2021,6,89,-1, + 0,2021,2026,1,0,0,0,2022,2023,3,2,1,0,2023,2024,6,89,-1,0,2024,2026,1, + 0,0,0,2025,2012,1,0,0,0,2025,2018,1,0,0,0,2025,2022,1,0,0,0,2026,179,1, + 0,0,0,2027,2028,3,124,62,0,2028,2029,6,90,-1,0,2029,2030,5,28,0,0,2030, + 2032,1,0,0,0,2031,2027,1,0,0,0,2032,2035,1,0,0,0,2033,2031,1,0,0,0,2033, + 2034,1,0,0,0,2034,2036,1,0,0,0,2035,2033,1,0,0,0,2036,2037,3,124,62,0, + 2037,2038,6,90,-1,0,2038,181,1,0,0,0,2039,2046,1,0,0,0,2040,2041,5,86, + 0,0,2041,2042,3,190,95,0,2042,2043,5,87,0,0,2043,2044,6,91,-1,0,2044,2046, + 1,0,0,0,2045,2039,1,0,0,0,2045,2040,1,0,0,0,2046,183,1,0,0,0,2047,2048, + 5,266,0,0,2048,2066,6,92,-1,0,2049,2050,5,114,0,0,2050,2066,6,92,-1,0, + 2051,2052,5,39,0,0,2052,2066,6,92,-1,0,2053,2054,5,200,0,0,2054,2066,6, + 92,-1,0,2055,2056,5,115,0,0,2056,2066,6,92,-1,0,2057,2058,5,116,0,0,2058, + 2066,6,92,-1,0,2059,2060,5,70,0,0,2060,2061,5,30,0,0,2061,2062,3,32,16, + 0,2062,2063,5,31,0,0,2063,2064,6,92,-1,0,2064,2066,1,0,0,0,2065,2047,1, + 0,0,0,2065,2049,1,0,0,0,2065,2051,1,0,0,0,2065,2053,1,0,0,0,2065,2055, + 1,0,0,0,2065,2057,1,0,0,0,2065,2059,1,0,0,0,2066,185,1,0,0,0,2067,2068, + 3,184,92,0,2068,2069,6,93,-1,0,2069,2071,1,0,0,0,2070,2067,1,0,0,0,2071, + 2074,1,0,0,0,2072,2070,1,0,0,0,2072,2073,1,0,0,0,2073,187,1,0,0,0,2074, + 2072,1,0,0,0,2075,2077,3,186,93,0,2076,2078,3,192,96,0,2077,2076,1,0,0, + 0,2077,2078,1,0,0,0,2078,2079,1,0,0,0,2079,2080,3,2,1,0,2080,2081,6,94, + -1,0,2081,189,1,0,0,0,2082,2083,3,188,94,0,2083,2084,6,95,-1,0,2084,2085, + 5,28,0,0,2085,2087,1,0,0,0,2086,2082,1,0,0,0,2087,2090,1,0,0,0,2088,2086, + 1,0,0,0,2088,2089,1,0,0,0,2089,2091,1,0,0,0,2090,2088,1,0,0,0,2091,2092, + 3,188,94,0,2092,2093,6,95,-1,0,2093,191,1,0,0,0,2094,2095,5,30,0,0,2095, + 2096,3,180,90,0,2096,2097,5,31,0,0,2097,2098,6,96,-1,0,2098,193,1,0,0, + 0,2099,2101,3,196,98,0,2100,2099,1,0,0,0,2100,2101,1,0,0,0,2101,2102,1, + 0,0,0,2102,2103,6,97,-1,0,2103,195,1,0,0,0,2104,2105,5,86,0,0,2105,2106, + 5,42,0,0,2106,2107,3,32,16,0,2107,2108,5,43,0,0,2108,2109,5,87,0,0,2109, + 2110,6,98,-1,0,2110,197,1,0,0,0,2111,2112,3,234,117,0,2112,2113,5,17,0, + 0,2113,2114,3,246,123,0,2114,2115,5,18,0,0,2115,2262,1,0,0,0,2116,2117, + 3,74,37,0,2117,2118,5,17,0,0,2118,2119,3,82,41,0,2119,2120,5,18,0,0,2120, + 2262,1,0,0,0,2121,2122,3,210,105,0,2122,2123,6,99,-1,0,2123,2124,5,17, + 0,0,2124,2125,3,214,107,0,2125,2126,5,18,0,0,2126,2262,1,0,0,0,2127,2128, + 3,218,109,0,2128,2129,6,99,-1,0,2129,2130,5,17,0,0,2130,2131,3,222,111, + 0,2131,2132,5,18,0,0,2132,2262,1,0,0,0,2133,2262,3,200,100,0,2134,2135, + 3,284,142,0,2135,2136,6,99,-1,0,2136,2262,1,0,0,0,2137,2138,3,152,76,0, + 2138,2139,6,99,-1,0,2139,2262,1,0,0,0,2140,2141,3,88,44,0,2141,2142,6, + 99,-1,0,2142,2262,1,0,0,0,2143,2144,3,330,165,0,2144,2145,6,99,-1,0,2145, + 2262,1,0,0,0,2146,2147,5,117,0,0,2147,2148,3,32,16,0,2148,2149,6,99,-1, + 0,2149,2262,1,0,0,0,2150,2151,5,118,0,0,2151,2152,3,32,16,0,2152,2153, + 6,99,-1,0,2153,2262,1,0,0,0,2154,2155,3,346,173,0,2155,2156,5,17,0,0,2156, + 2157,3,350,175,0,2157,2158,5,18,0,0,2158,2159,6,99,-1,0,2159,2262,1,0, + 0,0,2160,2161,5,302,0,0,2161,2162,3,124,62,0,2162,2163,5,176,0,0,2163, + 2164,3,242,121,0,2164,2165,5,119,0,0,2165,2166,3,170,85,0,2166,2167,3, + 138,69,0,2167,2168,3,124,62,0,2168,2169,5,176,0,0,2169,2170,3,242,121, + 0,2170,2171,3,112,56,0,2171,2172,6,99,-1,0,2172,2262,1,0,0,0,2173,2174, + 5,302,0,0,2174,2175,5,226,0,0,2175,2176,3,170,85,0,2176,2177,3,138,69, + 0,2177,2178,3,124,62,0,2178,2179,5,176,0,0,2179,2180,3,242,121,0,2180, + 2181,3,194,97,0,2181,2182,3,112,56,0,2182,2183,5,119,0,0,2183,2184,5,226, + 0,0,2184,2185,3,170,85,0,2185,2186,3,138,69,0,2186,2187,3,124,62,0,2187, + 2188,5,176,0,0,2188,2189,3,242,121,0,2189,2190,3,194,97,0,2190,2191,3, + 112,56,0,2191,2192,6,99,-1,0,2192,2262,1,0,0,0,2193,2194,3,26,13,0,2194, + 2195,6,99,-1,0,2195,2262,1,0,0,0,2196,2197,3,40,20,0,2197,2198,6,99,-1, + 0,2198,2262,1,0,0,0,2199,2200,5,255,0,0,2200,2201,5,196,0,0,2201,2202, + 5,42,0,0,2202,2203,3,32,16,0,2203,2204,5,43,0,0,2204,2210,6,99,-1,0,2205, + 2206,3,330,165,0,2206,2207,6,99,-1,0,2207,2209,1,0,0,0,2208,2205,1,0,0, + 0,2209,2212,1,0,0,0,2210,2208,1,0,0,0,2210,2211,1,0,0,0,2211,2262,1,0, + 0,0,2212,2210,1,0,0,0,2213,2214,5,255,0,0,2214,2215,5,196,0,0,2215,2216, + 3,2,1,0,2216,2222,6,99,-1,0,2217,2218,3,330,165,0,2218,2219,6,99,-1,0, + 2219,2221,1,0,0,0,2220,2217,1,0,0,0,2221,2224,1,0,0,0,2222,2220,1,0,0, + 0,2222,2223,1,0,0,0,2223,2262,1,0,0,0,2224,2222,1,0,0,0,2225,2226,5,255, + 0,0,2226,2227,5,256,0,0,2227,2228,5,42,0,0,2228,2229,3,32,16,0,2229,2230, + 5,43,0,0,2230,2231,5,28,0,0,2231,2232,3,124,62,0,2232,2238,6,99,-1,0,2233, + 2234,3,330,165,0,2234,2235,6,99,-1,0,2235,2237,1,0,0,0,2236,2233,1,0,0, + 0,2237,2240,1,0,0,0,2238,2236,1,0,0,0,2238,2239,1,0,0,0,2239,2262,1,0, + 0,0,2240,2238,1,0,0,0,2241,2242,5,255,0,0,2242,2243,5,256,0,0,2243,2244, + 3,2,1,0,2244,2245,5,28,0,0,2245,2246,3,124,62,0,2246,2252,6,99,-1,0,2247, + 2248,3,330,165,0,2248,2249,6,99,-1,0,2249,2251,1,0,0,0,2250,2247,1,0,0, + 0,2251,2254,1,0,0,0,2252,2250,1,0,0,0,2252,2253,1,0,0,0,2253,2262,1,0, + 0,0,2254,2252,1,0,0,0,2255,2256,5,120,0,0,2256,2257,5,196,0,0,2257,2258, + 3,124,62,0,2258,2259,3,44,22,0,2259,2260,6,99,-1,0,2260,2262,1,0,0,0,2261, + 2111,1,0,0,0,2261,2116,1,0,0,0,2261,2121,1,0,0,0,2261,2127,1,0,0,0,2261, + 2133,1,0,0,0,2261,2134,1,0,0,0,2261,2137,1,0,0,0,2261,2140,1,0,0,0,2261, + 2143,1,0,0,0,2261,2146,1,0,0,0,2261,2150,1,0,0,0,2261,2154,1,0,0,0,2261, + 2160,1,0,0,0,2261,2173,1,0,0,0,2261,2193,1,0,0,0,2261,2196,1,0,0,0,2261, + 2199,1,0,0,0,2261,2213,1,0,0,0,2261,2225,1,0,0,0,2261,2241,1,0,0,0,2261, + 2255,1,0,0,0,2262,199,1,0,0,0,2263,2264,5,121,0,0,2264,2276,3,208,104, + 0,2265,2266,3,202,101,0,2266,2267,6,100,-1,0,2267,2275,1,0,0,0,2268,2269, + 5,122,0,0,2269,2270,5,30,0,0,2270,2271,3,228,114,0,2271,2272,5,31,0,0, + 2272,2273,6,100,-1,0,2273,2275,1,0,0,0,2274,2265,1,0,0,0,2274,2268,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,2280,3,138,69,0,2280,2281,3,2,1,0,2281,2282, + 3,204,102,0,2282,2283,3,206,103,0,2283,2284,6,100,-1,0,2284,201,1,0,0, + 0,2285,2286,5,123,0,0,2286,2320,6,101,-1,0,2287,2288,5,51,0,0,2288,2320, + 6,101,-1,0,2289,2290,5,52,0,0,2290,2320,6,101,-1,0,2291,2292,5,63,0,0, + 2292,2320,6,101,-1,0,2293,2294,5,124,0,0,2294,2320,6,101,-1,0,2295,2296, + 5,69,0,0,2296,2320,6,101,-1,0,2297,2298,5,68,0,0,2298,2320,6,101,-1,0, + 2299,2300,5,64,0,0,2300,2320,6,101,-1,0,2301,2302,5,65,0,0,2302,2320,6, + 101,-1,0,2303,2304,5,66,0,0,2304,2320,6,101,-1,0,2305,2306,5,125,0,0,2306, + 2320,6,101,-1,0,2307,2308,5,126,0,0,2308,2320,6,101,-1,0,2309,2310,5,127, + 0,0,2310,2320,6,101,-1,0,2311,2312,5,16,0,0,2312,2320,6,101,-1,0,2313, + 2314,5,70,0,0,2314,2315,5,30,0,0,2315,2316,3,32,16,0,2316,2317,5,31,0, + 0,2317,2318,6,101,-1,0,2318,2320,1,0,0,0,2319,2285,1,0,0,0,2319,2287,1, + 0,0,0,2319,2289,1,0,0,0,2319,2291,1,0,0,0,2319,2293,1,0,0,0,2319,2295, + 1,0,0,0,2319,2297,1,0,0,0,2319,2299,1,0,0,0,2319,2301,1,0,0,0,2319,2303, + 1,0,0,0,2319,2305,1,0,0,0,2319,2307,1,0,0,0,2319,2309,1,0,0,0,2319,2311, + 1,0,0,0,2319,2313,1,0,0,0,2320,203,1,0,0,0,2321,2331,1,0,0,0,2322,2323, + 5,44,0,0,2323,2324,3,0,0,0,2324,2325,6,102,-1,0,2325,2331,1,0,0,0,2326, + 2327,5,44,0,0,2327,2328,3,32,16,0,2328,2329,6,102,-1,0,2329,2331,1,0,0, + 0,2330,2321,1,0,0,0,2330,2322,1,0,0,0,2330,2326,1,0,0,0,2331,205,1,0,0, + 0,2332,2338,1,0,0,0,2333,2334,5,36,0,0,2334,2335,3,304,152,0,2335,2336, + 6,103,-1,0,2336,2338,1,0,0,0,2337,2332,1,0,0,0,2337,2333,1,0,0,0,2338, + 207,1,0,0,0,2339,2346,1,0,0,0,2340,2341,5,42,0,0,2341,2342,3,32,16,0,2342, + 2343,5,43,0,0,2343,2344,6,104,-1,0,2344,2346,1,0,0,0,2345,2339,1,0,0,0, + 2345,2340,1,0,0,0,2346,209,1,0,0,0,2347,2353,5,128,0,0,2348,2349,3,212, + 106,0,2349,2350,6,105,-1,0,2350,2352,1,0,0,0,2351,2348,1,0,0,0,2352,2355, + 1,0,0,0,2353,2351,1,0,0,0,2353,2354,1,0,0,0,2354,2356,1,0,0,0,2355,2353, + 1,0,0,0,2356,2357,3,124,62,0,2357,2358,3,2,1,0,2358,2359,6,105,-1,0,2359, + 2373,1,0,0,0,2360,2366,5,128,0,0,2361,2362,3,212,106,0,2362,2363,6,105, + -1,0,2363,2365,1,0,0,0,2364,2361,1,0,0,0,2365,2368,1,0,0,0,2366,2364,1, + 0,0,0,2366,2367,1,0,0,0,2367,2369,1,0,0,0,2368,2366,1,0,0,0,2369,2370, + 3,2,1,0,2370,2371,6,105,-1,0,2371,2373,1,0,0,0,2372,2347,1,0,0,0,2372, + 2360,1,0,0,0,2373,211,1,0,0,0,2374,2375,5,69,0,0,2375,2379,6,106,-1,0, + 2376,2377,5,68,0,0,2377,2379,6,106,-1,0,2378,2374,1,0,0,0,2378,2376,1, + 0,0,0,2379,213,1,0,0,0,2380,2382,3,216,108,0,2381,2380,1,0,0,0,2382,2385, + 1,0,0,0,2383,2381,1,0,0,0,2383,2384,1,0,0,0,2384,215,1,0,0,0,2385,2383, + 1,0,0,0,2386,2387,5,129,0,0,2387,2388,3,168,84,0,2388,2389,6,108,-1,0, + 2389,2413,1,0,0,0,2390,2391,5,130,0,0,2391,2392,3,168,84,0,2392,2393,6, + 108,-1,0,2393,2413,1,0,0,0,2394,2395,5,131,0,0,2395,2396,3,168,84,0,2396, + 2397,6,108,-1,0,2397,2413,1,0,0,0,2398,2399,5,132,0,0,2399,2400,3,168, + 84,0,2400,2401,6,108,-1,0,2401,2413,1,0,0,0,2402,2403,3,88,44,0,2403,2404, + 6,108,-1,0,2404,2413,1,0,0,0,2405,2406,3,330,165,0,2406,2407,6,108,-1, + 0,2407,2413,1,0,0,0,2408,2409,3,26,13,0,2409,2410,6,108,-1,0,2410,2413, + 1,0,0,0,2411,2413,3,40,20,0,2412,2386,1,0,0,0,2412,2390,1,0,0,0,2412,2394, + 1,0,0,0,2412,2398,1,0,0,0,2412,2402,1,0,0,0,2412,2405,1,0,0,0,2412,2408, + 1,0,0,0,2412,2411,1,0,0,0,2413,217,1,0,0,0,2414,2420,5,133,0,0,2415,2416, + 3,220,110,0,2416,2417,6,109,-1,0,2417,2419,1,0,0,0,2418,2415,1,0,0,0,2419, + 2422,1,0,0,0,2420,2418,1,0,0,0,2420,2421,1,0,0,0,2421,2423,1,0,0,0,2422, + 2420,1,0,0,0,2423,2424,3,170,85,0,2424,2425,3,138,69,0,2425,2426,3,2,1, + 0,2426,2427,3,112,56,0,2427,2428,3,206,103,0,2428,2429,6,109,-1,0,2429, + 219,1,0,0,0,2430,2431,5,69,0,0,2431,2435,6,110,-1,0,2432,2433,5,68,0,0, + 2433,2435,6,110,-1,0,2434,2430,1,0,0,0,2434,2432,1,0,0,0,2435,221,1,0, + 0,0,2436,2438,3,224,112,0,2437,2436,1,0,0,0,2438,2441,1,0,0,0,2439,2437, + 1,0,0,0,2439,2440,1,0,0,0,2440,223,1,0,0,0,2441,2439,1,0,0,0,2442,2443, + 5,134,0,0,2443,2444,3,168,84,0,2444,2445,6,112,-1,0,2445,2465,1,0,0,0, + 2446,2447,5,135,0,0,2447,2448,3,168,84,0,2448,2449,6,112,-1,0,2449,2465, + 1,0,0,0,2450,2451,5,132,0,0,2451,2452,3,168,84,0,2452,2453,6,112,-1,0, + 2453,2465,1,0,0,0,2454,2455,3,330,165,0,2455,2456,6,112,-1,0,2456,2465, + 1,0,0,0,2457,2458,3,88,44,0,2458,2459,6,112,-1,0,2459,2465,1,0,0,0,2460, + 2461,3,26,13,0,2461,2462,6,112,-1,0,2462,2465,1,0,0,0,2463,2465,3,40,20, + 0,2464,2442,1,0,0,0,2464,2446,1,0,0,0,2464,2450,1,0,0,0,2464,2454,1,0, + 0,0,2464,2457,1,0,0,0,2464,2460,1,0,0,0,2464,2463,1,0,0,0,2465,225,1,0, + 0,0,2466,2474,6,113,-1,0,2467,2468,5,122,0,0,2468,2469,5,30,0,0,2469,2470, + 3,228,114,0,2470,2471,5,31,0,0,2471,2472,6,113,-1,0,2472,2474,1,0,0,0, + 2473,2466,1,0,0,0,2473,2467,1,0,0,0,2474,227,1,0,0,0,2475,2476,3,126,63, + 0,2476,2477,6,114,-1,0,2477,2489,1,0,0,0,2478,2482,5,17,0,0,2479,2480, + 3,302,151,0,2480,2481,6,114,-1,0,2481,2483,1,0,0,0,2482,2479,1,0,0,0,2483, + 2484,1,0,0,0,2484,2482,1,0,0,0,2484,2485,1,0,0,0,2485,2486,1,0,0,0,2486, + 2487,5,18,0,0,2487,2489,1,0,0,0,2488,2475,1,0,0,0,2488,2478,1,0,0,0,2489, + 229,1,0,0,0,2490,2491,3,232,116,0,2491,2492,6,115,-1,0,2492,2494,1,0,0, + 0,2493,2490,1,0,0,0,2494,2497,1,0,0,0,2495,2493,1,0,0,0,2495,2496,1,0, + 0,0,2496,231,1,0,0,0,2497,2495,1,0,0,0,2498,2499,5,42,0,0,2499,2500,5, + 136,0,0,2500,2501,5,43,0,0,2501,2516,6,116,-1,0,2502,2503,5,42,0,0,2503, + 2504,5,137,0,0,2504,2505,5,43,0,0,2505,2516,6,116,-1,0,2506,2507,5,42, + 0,0,2507,2508,5,138,0,0,2508,2509,5,43,0,0,2509,2516,6,116,-1,0,2510,2511, + 5,42,0,0,2511,2512,3,32,16,0,2512,2513,5,43,0,0,2513,2514,6,116,-1,0,2514, + 2516,1,0,0,0,2515,2498,1,0,0,0,2515,2502,1,0,0,0,2515,2506,1,0,0,0,2515, + 2510,1,0,0,0,2516,233,1,0,0,0,2517,2526,5,139,0,0,2518,2519,3,236,118, + 0,2519,2520,6,117,-1,0,2520,2525,1,0,0,0,2521,2522,3,238,119,0,2522,2523, + 6,117,-1,0,2523,2525,1,0,0,0,2524,2518,1,0,0,0,2524,2521,1,0,0,0,2525, + 2528,1,0,0,0,2526,2524,1,0,0,0,2526,2527,1,0,0,0,2527,2529,1,0,0,0,2528, + 2526,1,0,0,0,2529,2530,3,170,85,0,2530,2531,3,230,115,0,2531,2532,3,138, + 69,0,2532,2533,3,226,113,0,2533,2534,3,242,121,0,2534,2535,3,182,91,0, + 2535,2541,3,112,56,0,2536,2537,3,244,122,0,2537,2538,6,117,-1,0,2538,2540, + 1,0,0,0,2539,2536,1,0,0,0,2540,2543,1,0,0,0,2541,2539,1,0,0,0,2541,2542, + 1,0,0,0,2542,2544,1,0,0,0,2543,2541,1,0,0,0,2544,2545,6,117,-1,0,2545, + 235,1,0,0,0,2546,2547,5,123,0,0,2547,2589,6,118,-1,0,2548,2549,5,51,0, + 0,2549,2589,6,118,-1,0,2550,2551,5,52,0,0,2551,2589,6,118,-1,0,2552,2553, + 5,63,0,0,2553,2589,6,118,-1,0,2554,2555,5,140,0,0,2555,2589,6,118,-1,0, + 2556,2557,5,68,0,0,2557,2589,6,118,-1,0,2558,2559,5,141,0,0,2559,2589, + 6,118,-1,0,2560,2561,5,142,0,0,2561,2589,6,118,-1,0,2562,2563,5,54,0,0, + 2563,2589,6,118,-1,0,2564,2565,5,64,0,0,2565,2589,6,118,-1,0,2566,2567, + 5,65,0,0,2567,2589,6,118,-1,0,2568,2569,5,66,0,0,2569,2589,6,118,-1,0, + 2570,2571,5,125,0,0,2571,2589,6,118,-1,0,2572,2573,5,143,0,0,2573,2589, + 6,118,-1,0,2574,2575,5,144,0,0,2575,2589,6,118,-1,0,2576,2577,5,69,0,0, + 2577,2589,6,118,-1,0,2578,2579,5,145,0,0,2579,2589,6,118,-1,0,2580,2581, + 5,146,0,0,2581,2589,6,118,-1,0,2582,2583,5,70,0,0,2583,2584,5,30,0,0,2584, + 2585,3,32,16,0,2585,2586,5,31,0,0,2586,2587,6,118,-1,0,2587,2589,1,0,0, + 0,2588,2546,1,0,0,0,2588,2548,1,0,0,0,2588,2550,1,0,0,0,2588,2552,1,0, + 0,0,2588,2554,1,0,0,0,2588,2556,1,0,0,0,2588,2558,1,0,0,0,2588,2560,1, + 0,0,0,2588,2562,1,0,0,0,2588,2564,1,0,0,0,2588,2566,1,0,0,0,2588,2568, + 1,0,0,0,2588,2570,1,0,0,0,2588,2572,1,0,0,0,2588,2574,1,0,0,0,2588,2576, + 1,0,0,0,2588,2578,1,0,0,0,2588,2580,1,0,0,0,2588,2582,1,0,0,0,2589,237, + 1,0,0,0,2590,2591,5,147,0,0,2591,2600,5,30,0,0,2592,2593,3,6,3,0,2593, + 2598,6,119,-1,0,2594,2595,5,34,0,0,2595,2596,3,6,3,0,2596,2597,6,119,-1, + 0,2597,2599,1,0,0,0,2598,2594,1,0,0,0,2598,2599,1,0,0,0,2599,2601,1,0, + 0,0,2600,2592,1,0,0,0,2600,2601,1,0,0,0,2601,2607,1,0,0,0,2602,2603,3, + 240,120,0,2603,2604,6,119,-1,0,2604,2606,1,0,0,0,2605,2602,1,0,0,0,2606, + 2609,1,0,0,0,2607,2605,1,0,0,0,2607,2608,1,0,0,0,2608,2610,1,0,0,0,2609, + 2607,1,0,0,0,2610,2614,5,31,0,0,2611,2612,5,147,0,0,2612,2614,5,85,0,0, + 2613,2590,1,0,0,0,2613,2611,1,0,0,0,2614,239,1,0,0,0,2615,2616,5,148,0, + 0,2616,2658,6,120,-1,0,2617,2618,5,224,0,0,2618,2658,6,120,-1,0,2619,2620, + 5,57,0,0,2620,2658,6,120,-1,0,2621,2622,5,58,0,0,2622,2658,6,120,-1,0, + 2623,2624,5,149,0,0,2624,2658,6,120,-1,0,2625,2626,5,150,0,0,2626,2658, + 6,120,-1,0,2627,2628,5,248,0,0,2628,2658,6,120,-1,0,2629,2630,5,249,0, + 0,2630,2658,6,120,-1,0,2631,2632,5,250,0,0,2632,2658,6,120,-1,0,2633,2634, + 5,251,0,0,2634,2658,6,120,-1,0,2635,2636,5,151,0,0,2636,2637,5,75,0,0, + 2637,2638,5,152,0,0,2638,2658,6,120,-1,0,2639,2640,5,151,0,0,2640,2641, + 5,75,0,0,2641,2642,5,153,0,0,2642,2658,6,120,-1,0,2643,2644,5,154,0,0, + 2644,2645,5,75,0,0,2645,2646,5,152,0,0,2646,2658,6,120,-1,0,2647,2648, + 5,154,0,0,2648,2649,5,75,0,0,2649,2650,5,153,0,0,2650,2658,6,120,-1,0, + 2651,2652,5,70,0,0,2652,2653,5,30,0,0,2653,2654,3,32,16,0,2654,2655,5, + 31,0,0,2655,2656,6,120,-1,0,2656,2658,1,0,0,0,2657,2615,1,0,0,0,2657,2617, + 1,0,0,0,2657,2619,1,0,0,0,2657,2621,1,0,0,0,2657,2623,1,0,0,0,2657,2625, + 1,0,0,0,2657,2627,1,0,0,0,2657,2629,1,0,0,0,2657,2631,1,0,0,0,2657,2633, + 1,0,0,0,2657,2635,1,0,0,0,2657,2639,1,0,0,0,2657,2643,1,0,0,0,2657,2647, + 1,0,0,0,2657,2651,1,0,0,0,2658,241,1,0,0,0,2659,2660,5,116,0,0,2660,2667, + 6,121,-1,0,2661,2662,5,155,0,0,2662,2667,6,121,-1,0,2663,2664,3,2,1,0, + 2664,2665,6,121,-1,0,2665,2667,1,0,0,0,2666,2659,1,0,0,0,2666,2661,1,0, + 0,0,2666,2663,1,0,0,0,2667,243,1,0,0,0,2668,2669,5,1,0,0,2669,2707,6,122, + -1,0,2670,2671,5,2,0,0,2671,2707,6,122,-1,0,2672,2673,5,156,0,0,2673,2707, + 6,122,-1,0,2674,2675,5,3,0,0,2675,2707,6,122,-1,0,2676,2677,5,4,0,0,2677, + 2707,6,122,-1,0,2678,2679,5,247,0,0,2679,2707,6,122,-1,0,2680,2681,5,5, + 0,0,2681,2707,6,122,-1,0,2682,2683,5,6,0,0,2683,2707,6,122,-1,0,2684,2685, + 5,7,0,0,2685,2707,6,122,-1,0,2686,2687,5,8,0,0,2687,2707,6,122,-1,0,2688, + 2689,5,9,0,0,2689,2707,6,122,-1,0,2690,2691,5,10,0,0,2691,2707,6,122,-1, + 0,2692,2693,5,11,0,0,2693,2707,6,122,-1,0,2694,2695,5,12,0,0,2695,2707, + 6,122,-1,0,2696,2697,5,13,0,0,2697,2707,6,122,-1,0,2698,2699,5,14,0,0, + 2699,2707,6,122,-1,0,2700,2701,5,70,0,0,2701,2702,5,30,0,0,2702,2703,3, + 32,16,0,2703,2704,5,31,0,0,2704,2705,6,122,-1,0,2705,2707,1,0,0,0,2706, + 2668,1,0,0,0,2706,2670,1,0,0,0,2706,2672,1,0,0,0,2706,2674,1,0,0,0,2706, + 2676,1,0,0,0,2706,2678,1,0,0,0,2706,2680,1,0,0,0,2706,2682,1,0,0,0,2706, + 2684,1,0,0,0,2706,2686,1,0,0,0,2706,2688,1,0,0,0,2706,2690,1,0,0,0,2706, + 2692,1,0,0,0,2706,2694,1,0,0,0,2706,2696,1,0,0,0,2706,2698,1,0,0,0,2706, + 2700,1,0,0,0,2707,245,1,0,0,0,2708,2710,3,248,124,0,2709,2708,1,0,0,0, + 2710,2713,1,0,0,0,2711,2709,1,0,0,0,2711,2712,1,0,0,0,2712,247,1,0,0,0, + 2713,2711,1,0,0,0,2714,2752,3,100,50,0,2715,2716,5,296,0,0,2716,2717,3, + 32,16,0,2717,2718,6,124,-1,0,2718,2752,1,0,0,0,2719,2752,3,266,133,0,2720, + 2721,5,297,0,0,2721,2722,3,32,16,0,2722,2723,6,124,-1,0,2723,2752,1,0, + 0,0,2724,2725,5,298,0,0,2725,2752,6,124,-1,0,2726,2727,5,299,0,0,2727, + 2752,6,124,-1,0,2728,2752,3,260,130,0,2729,2752,3,264,132,0,2730,2752, + 3,250,125,0,2731,2732,3,284,142,0,2732,2733,6,124,-1,0,2733,2752,1,0,0, + 0,2734,2735,3,152,76,0,2735,2736,6,124,-1,0,2736,2752,1,0,0,0,2737,2738, + 3,88,44,0,2738,2739,6,124,-1,0,2739,2752,1,0,0,0,2740,2741,3,26,13,0,2741, + 2742,6,124,-1,0,2742,2752,1,0,0,0,2743,2744,3,262,131,0,2744,2745,6,124, + -1,0,2745,2752,1,0,0,0,2746,2752,3,40,20,0,2747,2752,3,252,126,0,2748, + 2752,3,254,127,0,2749,2752,3,256,128,0,2750,2752,3,258,129,0,2751,2714, + 1,0,0,0,2751,2715,1,0,0,0,2751,2719,1,0,0,0,2751,2720,1,0,0,0,2751,2724, + 1,0,0,0,2751,2726,1,0,0,0,2751,2728,1,0,0,0,2751,2729,1,0,0,0,2751,2730, + 1,0,0,0,2751,2731,1,0,0,0,2751,2734,1,0,0,0,2751,2737,1,0,0,0,2751,2740, + 1,0,0,0,2751,2743,1,0,0,0,2751,2746,1,0,0,0,2751,2747,1,0,0,0,2751,2748, + 1,0,0,0,2751,2749,1,0,0,0,2751,2750,1,0,0,0,2752,249,1,0,0,0,2753,2755, + 5,300,0,0,2754,2756,5,157,0,0,2755,2754,1,0,0,0,2755,2756,1,0,0,0,2756, + 2757,1,0,0,0,2757,2758,3,112,56,0,2758,251,1,0,0,0,2759,2760,5,301,0,0, + 2760,2761,5,42,0,0,2761,2762,3,32,16,0,2762,2765,5,43,0,0,2763,2764,5, + 34,0,0,2764,2766,3,0,0,0,2765,2763,1,0,0,0,2765,2766,1,0,0,0,2766,253, + 1,0,0,0,2767,2768,5,303,0,0,2768,2769,3,32,16,0,2769,2770,5,75,0,0,2770, + 2771,3,32,16,0,2771,255,1,0,0,0,2772,2773,5,302,0,0,2773,2774,3,124,62, + 0,2774,2775,5,176,0,0,2775,2776,3,242,121,0,2776,2788,1,0,0,0,2777,2778, + 5,302,0,0,2778,2779,5,226,0,0,2779,2780,3,170,85,0,2780,2781,3,138,69, + 0,2781,2782,3,124,62,0,2782,2783,5,176,0,0,2783,2784,3,242,121,0,2784, + 2785,3,194,97,0,2785,2786,3,112,56,0,2786,2788,1,0,0,0,2787,2772,1,0,0, + 0,2787,2777,1,0,0,0,2788,257,1,0,0,0,2789,2790,5,255,0,0,2790,2791,5,196, + 0,0,2791,2792,5,42,0,0,2792,2793,3,32,16,0,2793,2799,5,43,0,0,2794,2795, + 3,330,165,0,2795,2796,6,129,-1,0,2796,2798,1,0,0,0,2797,2794,1,0,0,0,2798, + 2801,1,0,0,0,2799,2797,1,0,0,0,2799,2800,1,0,0,0,2800,2855,1,0,0,0,2801, + 2799,1,0,0,0,2802,2803,5,255,0,0,2803,2804,5,196,0,0,2804,2810,3,2,1,0, + 2805,2806,3,330,165,0,2806,2807,6,129,-1,0,2807,2809,1,0,0,0,2808,2805, + 1,0,0,0,2809,2812,1,0,0,0,2810,2808,1,0,0,0,2810,2811,1,0,0,0,2811,2855, + 1,0,0,0,2812,2810,1,0,0,0,2813,2814,5,255,0,0,2814,2815,5,256,0,0,2815, + 2816,5,42,0,0,2816,2817,3,32,16,0,2817,2818,5,43,0,0,2818,2819,5,28,0, + 0,2819,2825,3,124,62,0,2820,2821,3,330,165,0,2821,2822,6,129,-1,0,2822, + 2824,1,0,0,0,2823,2820,1,0,0,0,2824,2827,1,0,0,0,2825,2823,1,0,0,0,2825, + 2826,1,0,0,0,2826,2855,1,0,0,0,2827,2825,1,0,0,0,2828,2829,5,255,0,0,2829, + 2830,5,256,0,0,2830,2831,3,2,1,0,2831,2832,5,28,0,0,2832,2838,3,124,62, + 0,2833,2834,3,330,165,0,2834,2835,6,129,-1,0,2835,2837,1,0,0,0,2836,2833, + 1,0,0,0,2837,2840,1,0,0,0,2838,2836,1,0,0,0,2838,2839,1,0,0,0,2839,2855, + 1,0,0,0,2840,2838,1,0,0,0,2841,2842,5,255,0,0,2842,2843,5,42,0,0,2843, + 2844,3,32,16,0,2844,2845,5,43,0,0,2845,2851,3,206,103,0,2846,2847,3,330, + 165,0,2847,2848,6,129,-1,0,2848,2850,1,0,0,0,2849,2846,1,0,0,0,2850,2853, + 1,0,0,0,2851,2849,1,0,0,0,2851,2852,1,0,0,0,2852,2855,1,0,0,0,2853,2851, + 1,0,0,0,2854,2789,1,0,0,0,2854,2802,1,0,0,0,2854,2813,1,0,0,0,2854,2828, + 1,0,0,0,2854,2841,1,0,0,0,2855,259,1,0,0,0,2856,2857,3,0,0,0,2857,2858, + 5,75,0,0,2858,2859,6,130,-1,0,2859,261,1,0,0,0,2860,2863,3,44,22,0,2861, + 2863,3,46,23,0,2862,2860,1,0,0,0,2862,2861,1,0,0,0,2863,263,1,0,0,0,2864, + 2865,5,17,0,0,2865,2866,3,246,123,0,2866,2867,5,18,0,0,2867,265,1,0,0, + 0,2868,2869,3,270,135,0,2869,2870,3,268,134,0,2870,267,1,0,0,0,2871,2872, + 3,272,136,0,2872,2873,6,134,-1,0,2873,2875,1,0,0,0,2874,2871,1,0,0,0,2875, + 2876,1,0,0,0,2876,2874,1,0,0,0,2876,2877,1,0,0,0,2877,269,1,0,0,0,2878, + 2879,5,158,0,0,2879,2880,3,264,132,0,2880,2881,6,135,-1,0,2881,2895,1, + 0,0,0,2882,2883,5,158,0,0,2883,2884,3,0,0,0,2884,2885,5,159,0,0,2885,2886, + 3,0,0,0,2886,2887,6,135,-1,0,2887,2895,1,0,0,0,2888,2889,5,158,0,0,2889, + 2890,3,32,16,0,2890,2891,5,159,0,0,2891,2892,3,32,16,0,2892,2893,6,135, + -1,0,2893,2895,1,0,0,0,2894,2878,1,0,0,0,2894,2882,1,0,0,0,2894,2888,1, + 0,0,0,2895,271,1,0,0,0,2896,2897,3,276,138,0,2897,2898,3,282,141,0,2898, + 2899,6,136,-1,0,2899,2913,1,0,0,0,2900,2901,3,274,137,0,2901,2902,3,282, + 141,0,2902,2903,6,136,-1,0,2903,2913,1,0,0,0,2904,2905,3,278,139,0,2905, + 2906,3,282,141,0,2906,2907,6,136,-1,0,2907,2913,1,0,0,0,2908,2909,3,280, + 140,0,2909,2910,3,282,141,0,2910,2911,6,136,-1,0,2911,2913,1,0,0,0,2912, + 2896,1,0,0,0,2912,2900,1,0,0,0,2912,2904,1,0,0,0,2912,2908,1,0,0,0,2913, + 273,1,0,0,0,2914,2915,5,160,0,0,2915,2916,3,264,132,0,2916,2917,6,137, + -1,0,2917,2927,1,0,0,0,2918,2919,5,160,0,0,2919,2920,3,0,0,0,2920,2921, + 6,137,-1,0,2921,2927,1,0,0,0,2922,2923,5,160,0,0,2923,2924,3,32,16,0,2924, + 2925,6,137,-1,0,2925,2927,1,0,0,0,2926,2914,1,0,0,0,2926,2918,1,0,0,0, + 2926,2922,1,0,0,0,2927,275,1,0,0,0,2928,2929,5,161,0,0,2929,2930,3,124, + 62,0,2930,277,1,0,0,0,2931,2932,5,162,0,0,2932,279,1,0,0,0,2933,2934,5, + 163,0,0,2934,281,1,0,0,0,2935,2936,3,264,132,0,2936,2937,6,141,-1,0,2937, + 2951,1,0,0,0,2938,2939,5,164,0,0,2939,2940,3,0,0,0,2940,2941,5,159,0,0, + 2941,2942,3,0,0,0,2942,2943,6,141,-1,0,2943,2951,1,0,0,0,2944,2945,5,164, + 0,0,2945,2946,3,32,16,0,2946,2947,5,159,0,0,2947,2948,3,32,16,0,2948,2949, + 6,141,-1,0,2949,2951,1,0,0,0,2950,2935,1,0,0,0,2950,2938,1,0,0,0,2950, + 2944,1,0,0,0,2951,283,1,0,0,0,2952,2953,3,286,143,0,2953,2954,3,290,145, + 0,2954,285,1,0,0,0,2955,2956,5,165,0,0,2956,2957,3,288,144,0,2957,2958, + 3,0,0,0,2958,2959,5,36,0,0,2959,2963,1,0,0,0,2960,2961,5,165,0,0,2961, + 2963,3,288,144,0,2962,2955,1,0,0,0,2962,2960,1,0,0,0,2963,287,1,0,0,0, + 2964,2968,1,0,0,0,2965,2968,5,166,0,0,2966,2968,5,2,0,0,2967,2964,1,0, + 0,0,2967,2965,1,0,0,0,2967,2966,1,0,0,0,2968,289,1,0,0,0,2969,2970,5,17, + 0,0,2970,2971,3,292,146,0,2971,2972,5,18,0,0,2972,2979,1,0,0,0,2973,2975, + 3,296,148,0,2974,2973,1,0,0,0,2975,2976,1,0,0,0,2976,2974,1,0,0,0,2976, + 2977,1,0,0,0,2977,2979,1,0,0,0,2978,2969,1,0,0,0,2978,2974,1,0,0,0,2979, + 291,1,0,0,0,2980,2981,3,296,148,0,2981,2982,5,28,0,0,2982,2984,1,0,0,0, + 2983,2980,1,0,0,0,2984,2987,1,0,0,0,2985,2983,1,0,0,0,2985,2986,1,0,0, + 0,2986,2988,1,0,0,0,2987,2985,1,0,0,0,2988,2989,3,296,148,0,2989,293,1, + 0,0,0,2990,2996,1,0,0,0,2991,2992,5,42,0,0,2992,2993,3,32,16,0,2993,2994, + 5,43,0,0,2994,2996,1,0,0,0,2995,2990,1,0,0,0,2995,2991,1,0,0,0,2996,295, + 1,0,0,0,2997,2998,5,181,0,0,2998,2999,5,262,0,0,2999,3000,5,30,0,0,3000, + 3001,3,6,3,0,3001,3002,5,31,0,0,3002,3064,1,0,0,0,3003,3004,5,260,0,0, + 3004,3005,5,30,0,0,3005,3006,3,0,0,0,3006,3007,5,31,0,0,3007,3064,1,0, + 0,0,3008,3009,5,260,0,0,3009,3064,3,0,0,0,3010,3011,5,84,0,0,3011,3012, + 5,30,0,0,3012,3013,3,300,150,0,3013,3014,5,31,0,0,3014,3064,1,0,0,0,3015, + 3016,5,188,0,0,3016,3017,5,30,0,0,3017,3018,3,36,18,0,3018,3019,5,31,0, + 0,3019,3020,3,294,147,0,3020,3064,1,0,0,0,3021,3022,5,189,0,0,3022,3023, + 5,30,0,0,3023,3024,3,36,18,0,3024,3025,5,31,0,0,3025,3026,3,294,147,0, + 3026,3064,1,0,0,0,3027,3028,5,187,0,0,3028,3029,5,30,0,0,3029,3030,3,34, + 17,0,3030,3031,5,31,0,0,3031,3032,3,294,147,0,3032,3064,1,0,0,0,3033,3034, + 5,186,0,0,3034,3035,5,30,0,0,3035,3036,3,32,16,0,3036,3037,5,31,0,0,3037, + 3038,3,294,147,0,3038,3064,1,0,0,0,3039,3040,5,185,0,0,3040,3041,5,30, + 0,0,3041,3042,3,32,16,0,3042,3043,5,31,0,0,3043,3044,3,294,147,0,3044, + 3064,1,0,0,0,3045,3046,5,184,0,0,3046,3047,5,30,0,0,3047,3048,3,32,16, + 0,3048,3049,5,31,0,0,3049,3050,3,294,147,0,3050,3064,1,0,0,0,3051,3052, + 5,188,0,0,3052,3064,3,294,147,0,3053,3054,5,189,0,0,3054,3064,3,294,147, + 0,3055,3056,5,187,0,0,3056,3064,3,294,147,0,3057,3058,5,186,0,0,3058,3064, + 3,294,147,0,3059,3060,5,185,0,0,3060,3064,3,294,147,0,3061,3062,5,184, + 0,0,3062,3064,3,294,147,0,3063,2997,1,0,0,0,3063,3003,1,0,0,0,3063,3008, + 1,0,0,0,3063,3010,1,0,0,0,3063,3015,1,0,0,0,3063,3021,1,0,0,0,3063,3027, + 1,0,0,0,3063,3033,1,0,0,0,3063,3039,1,0,0,0,3063,3045,1,0,0,0,3063,3051, + 1,0,0,0,3063,3053,1,0,0,0,3063,3055,1,0,0,0,3063,3057,1,0,0,0,3063,3059, + 1,0,0,0,3063,3061,1,0,0,0,3064,297,1,0,0,0,3065,3066,5,188,0,0,3066,3067, + 5,30,0,0,3067,3068,3,36,18,0,3068,3069,5,31,0,0,3069,3141,1,0,0,0,3070, + 3071,5,189,0,0,3071,3072,5,30,0,0,3072,3073,3,36,18,0,3073,3074,5,31,0, + 0,3074,3141,1,0,0,0,3075,3076,5,188,0,0,3076,3077,5,30,0,0,3077,3078,3, + 32,16,0,3078,3079,5,31,0,0,3079,3141,1,0,0,0,3080,3081,5,189,0,0,3081, + 3082,5,30,0,0,3082,3083,3,34,17,0,3083,3084,5,31,0,0,3084,3141,1,0,0,0, + 3085,3086,5,187,0,0,3086,3087,5,30,0,0,3087,3088,3,34,17,0,3088,3089,5, + 31,0,0,3089,3141,1,0,0,0,3090,3091,5,186,0,0,3091,3092,5,30,0,0,3092,3093, + 3,32,16,0,3093,3094,5,31,0,0,3094,3141,1,0,0,0,3095,3096,5,185,0,0,3096, + 3097,5,30,0,0,3097,3098,3,32,16,0,3098,3099,5,31,0,0,3099,3141,1,0,0,0, + 3100,3101,5,184,0,0,3101,3102,5,30,0,0,3102,3103,3,32,16,0,3103,3104,5, + 31,0,0,3104,3141,1,0,0,0,3105,3106,5,193,0,0,3106,3107,5,30,0,0,3107,3108, + 3,34,17,0,3108,3109,5,31,0,0,3109,3141,1,0,0,0,3110,3111,5,192,0,0,3111, + 3112,5,30,0,0,3112,3113,3,32,16,0,3113,3114,5,31,0,0,3114,3141,1,0,0,0, + 3115,3116,5,191,0,0,3116,3117,5,30,0,0,3117,3118,3,32,16,0,3118,3119,5, + 31,0,0,3119,3141,1,0,0,0,3120,3121,5,190,0,0,3121,3122,5,30,0,0,3122,3123, + 3,32,16,0,3123,3124,5,31,0,0,3124,3141,1,0,0,0,3125,3126,5,181,0,0,3126, + 3127,5,30,0,0,3127,3128,3,32,16,0,3128,3129,5,31,0,0,3129,3141,1,0,0,0, + 3130,3131,5,183,0,0,3131,3132,5,30,0,0,3132,3133,3,162,81,0,3133,3134, + 5,31,0,0,3134,3141,1,0,0,0,3135,3136,5,84,0,0,3136,3137,5,30,0,0,3137, + 3138,3,300,150,0,3138,3139,5,31,0,0,3139,3141,1,0,0,0,3140,3065,1,0,0, + 0,3140,3070,1,0,0,0,3140,3075,1,0,0,0,3140,3080,1,0,0,0,3140,3085,1,0, + 0,0,3140,3090,1,0,0,0,3140,3095,1,0,0,0,3140,3100,1,0,0,0,3140,3105,1, + 0,0,0,3140,3110,1,0,0,0,3140,3115,1,0,0,0,3140,3120,1,0,0,0,3140,3125, + 1,0,0,0,3140,3130,1,0,0,0,3140,3135,1,0,0,0,3141,299,1,0,0,0,3142,3143, + 3,302,151,0,3143,3144,6,150,-1,0,3144,3146,1,0,0,0,3145,3142,1,0,0,0,3146, + 3149,1,0,0,0,3147,3145,1,0,0,0,3147,3148,1,0,0,0,3148,301,1,0,0,0,3149, + 3147,1,0,0,0,3150,3151,7,10,0,0,3151,303,1,0,0,0,3152,3156,3,298,149,0, + 3153,3156,3,6,3,0,3154,3156,5,179,0,0,3155,3152,1,0,0,0,3155,3153,1,0, + 0,0,3155,3154,1,0,0,0,3156,305,1,0,0,0,3157,3306,3,298,149,0,3158,3159, + 5,182,0,0,3159,3160,5,30,0,0,3160,3161,5,179,0,0,3161,3306,5,31,0,0,3162, + 3163,5,182,0,0,3163,3164,5,30,0,0,3164,3165,5,264,0,0,3165,3306,5,31,0, + 0,3166,3167,5,196,0,0,3167,3168,5,30,0,0,3168,3169,5,39,0,0,3169,3170, + 5,264,0,0,3170,3306,5,31,0,0,3171,3172,5,196,0,0,3172,3173,5,30,0,0,3173, + 3174,3,116,58,0,3174,3175,5,31,0,0,3175,3306,1,0,0,0,3176,3177,5,196,0, + 0,3177,3178,5,30,0,0,3178,3179,5,179,0,0,3179,3306,5,31,0,0,3180,3181, + 5,197,0,0,3181,3182,5,30,0,0,3182,3183,3,306,153,0,3183,3184,5,31,0,0, + 3184,3306,1,0,0,0,3185,3186,5,188,0,0,3186,3187,5,42,0,0,3187,3188,3,32, + 16,0,3188,3189,5,43,0,0,3189,3190,5,30,0,0,3190,3191,3,308,154,0,3191, + 3192,5,31,0,0,3192,3306,1,0,0,0,3193,3194,5,189,0,0,3194,3195,5,42,0,0, + 3195,3196,3,32,16,0,3196,3197,5,43,0,0,3197,3198,5,30,0,0,3198,3199,3, + 310,155,0,3199,3200,5,31,0,0,3200,3306,1,0,0,0,3201,3202,5,187,0,0,3202, + 3203,5,42,0,0,3203,3204,3,32,16,0,3204,3205,5,43,0,0,3205,3206,5,30,0, + 0,3206,3207,3,312,156,0,3207,3208,5,31,0,0,3208,3306,1,0,0,0,3209,3210, + 5,186,0,0,3210,3211,5,42,0,0,3211,3212,3,32,16,0,3212,3213,5,43,0,0,3213, + 3214,5,30,0,0,3214,3215,3,314,157,0,3215,3216,5,31,0,0,3216,3306,1,0,0, + 0,3217,3218,5,185,0,0,3218,3219,5,42,0,0,3219,3220,3,32,16,0,3220,3221, + 5,43,0,0,3221,3222,5,30,0,0,3222,3223,3,316,158,0,3223,3224,5,31,0,0,3224, + 3306,1,0,0,0,3225,3226,5,184,0,0,3226,3227,5,42,0,0,3227,3228,3,32,16, + 0,3228,3229,5,43,0,0,3229,3230,5,30,0,0,3230,3231,3,318,159,0,3231,3232, + 5,31,0,0,3232,3306,1,0,0,0,3233,3234,5,193,0,0,3234,3235,5,42,0,0,3235, + 3236,3,32,16,0,3236,3237,5,43,0,0,3237,3238,5,30,0,0,3238,3239,3,312,156, + 0,3239,3240,5,31,0,0,3240,3306,1,0,0,0,3241,3242,5,192,0,0,3242,3243,5, + 42,0,0,3243,3244,3,32,16,0,3244,3245,5,43,0,0,3245,3246,5,30,0,0,3246, + 3247,3,314,157,0,3247,3248,5,31,0,0,3248,3306,1,0,0,0,3249,3250,5,191, + 0,0,3250,3251,5,42,0,0,3251,3252,3,32,16,0,3252,3253,5,43,0,0,3253,3254, + 5,30,0,0,3254,3255,3,316,158,0,3255,3256,5,31,0,0,3256,3306,1,0,0,0,3257, + 3258,5,190,0,0,3258,3259,5,42,0,0,3259,3260,3,32,16,0,3260,3261,5,43,0, + 0,3261,3262,5,30,0,0,3262,3263,3,318,159,0,3263,3264,5,31,0,0,3264,3306, + 1,0,0,0,3265,3266,5,181,0,0,3266,3267,5,42,0,0,3267,3268,3,32,16,0,3268, + 3269,5,43,0,0,3269,3270,5,30,0,0,3270,3271,3,316,158,0,3271,3272,5,31, + 0,0,3272,3306,1,0,0,0,3273,3274,5,183,0,0,3274,3275,5,42,0,0,3275,3276, + 3,32,16,0,3276,3277,5,43,0,0,3277,3278,5,30,0,0,3278,3279,3,320,160,0, + 3279,3280,5,31,0,0,3280,3306,1,0,0,0,3281,3282,5,182,0,0,3282,3283,5,42, + 0,0,3283,3284,3,32,16,0,3284,3285,5,43,0,0,3285,3286,5,30,0,0,3286,3287, + 3,322,161,0,3287,3288,5,31,0,0,3288,3306,1,0,0,0,3289,3290,5,196,0,0,3290, + 3291,5,42,0,0,3291,3292,3,32,16,0,3292,3293,5,43,0,0,3293,3294,5,30,0, + 0,3294,3295,3,324,162,0,3295,3296,5,31,0,0,3296,3306,1,0,0,0,3297,3298, + 5,197,0,0,3298,3299,5,42,0,0,3299,3300,3,32,16,0,3300,3301,5,43,0,0,3301, + 3302,5,30,0,0,3302,3303,3,328,164,0,3303,3304,5,31,0,0,3304,3306,1,0,0, + 0,3305,3157,1,0,0,0,3305,3158,1,0,0,0,3305,3162,1,0,0,0,3305,3166,1,0, + 0,0,3305,3171,1,0,0,0,3305,3176,1,0,0,0,3305,3180,1,0,0,0,3305,3185,1, + 0,0,0,3305,3193,1,0,0,0,3305,3201,1,0,0,0,3305,3209,1,0,0,0,3305,3217, + 1,0,0,0,3305,3225,1,0,0,0,3305,3233,1,0,0,0,3305,3241,1,0,0,0,3305,3249, + 1,0,0,0,3305,3257,1,0,0,0,3305,3265,1,0,0,0,3305,3273,1,0,0,0,3305,3281, + 1,0,0,0,3305,3289,1,0,0,0,3305,3297,1,0,0,0,3306,307,1,0,0,0,3307,3310, + 3,36,18,0,3308,3310,3,32,16,0,3309,3307,1,0,0,0,3309,3308,1,0,0,0,3310, + 3313,1,0,0,0,3311,3309,1,0,0,0,3311,3312,1,0,0,0,3312,309,1,0,0,0,3313, + 3311,1,0,0,0,3314,3317,3,36,18,0,3315,3317,3,34,17,0,3316,3314,1,0,0,0, + 3316,3315,1,0,0,0,3317,3320,1,0,0,0,3318,3316,1,0,0,0,3318,3319,1,0,0, + 0,3319,311,1,0,0,0,3320,3318,1,0,0,0,3321,3323,3,34,17,0,3322,3321,1,0, + 0,0,3323,3326,1,0,0,0,3324,3322,1,0,0,0,3324,3325,1,0,0,0,3325,313,1,0, + 0,0,3326,3324,1,0,0,0,3327,3329,3,32,16,0,3328,3327,1,0,0,0,3329,3332, + 1,0,0,0,3330,3328,1,0,0,0,3330,3331,1,0,0,0,3331,315,1,0,0,0,3332,3330, + 1,0,0,0,3333,3335,3,32,16,0,3334,3333,1,0,0,0,3335,3338,1,0,0,0,3336,3334, + 1,0,0,0,3336,3337,1,0,0,0,3337,317,1,0,0,0,3338,3336,1,0,0,0,3339,3341, + 3,32,16,0,3340,3339,1,0,0,0,3341,3344,1,0,0,0,3342,3340,1,0,0,0,3342,3343, + 1,0,0,0,3343,319,1,0,0,0,3344,3342,1,0,0,0,3345,3347,3,162,81,0,3346,3345, + 1,0,0,0,3347,3350,1,0,0,0,3348,3346,1,0,0,0,3348,3349,1,0,0,0,3349,321, + 1,0,0,0,3350,3348,1,0,0,0,3351,3353,7,11,0,0,3352,3351,1,0,0,0,3353,3356, + 1,0,0,0,3354,3352,1,0,0,0,3354,3355,1,0,0,0,3355,323,1,0,0,0,3356,3354, + 1,0,0,0,3357,3359,3,326,163,0,3358,3357,1,0,0,0,3359,3362,1,0,0,0,3360, + 3358,1,0,0,0,3360,3361,1,0,0,0,3361,325,1,0,0,0,3362,3360,1,0,0,0,3363, + 3368,5,179,0,0,3364,3365,5,39,0,0,3365,3368,5,264,0,0,3366,3368,3,116, + 58,0,3367,3363,1,0,0,0,3367,3364,1,0,0,0,3367,3366,1,0,0,0,3368,327,1, + 0,0,0,3369,3371,3,306,153,0,3370,3369,1,0,0,0,3371,3374,1,0,0,0,3372,3370, + 1,0,0,0,3372,3373,1,0,0,0,3373,329,1,0,0,0,3374,3372,1,0,0,0,3375,3379, + 3,44,22,0,3376,3379,3,46,23,0,3377,3379,3,2,1,0,3378,3375,1,0,0,0,3378, + 3376,1,0,0,0,3378,3377,1,0,0,0,3379,331,1,0,0,0,3380,3381,7,12,0,0,3381, + 3382,5,36,0,0,3382,3383,5,30,0,0,3383,3384,3,300,150,0,3384,3385,5,31, + 0,0,3385,3406,1,0,0,0,3386,3387,5,169,0,0,3387,3388,3,38,19,0,3388,3389, + 5,75,0,0,3389,3390,3,38,19,0,3390,3391,5,75,0,0,3391,3392,3,38,19,0,3392, + 3393,5,75,0,0,3393,3394,3,38,19,0,3394,3406,1,0,0,0,3395,3396,5,170,0, + 0,3396,3406,3,6,3,0,3397,3398,5,170,0,0,3398,3399,5,36,0,0,3399,3400,5, + 30,0,0,3400,3401,3,300,150,0,3401,3402,5,31,0,0,3402,3406,1,0,0,0,3403, + 3406,3,330,165,0,3404,3406,3,40,20,0,3405,3380,1,0,0,0,3405,3386,1,0,0, + 0,3405,3395,1,0,0,0,3405,3397,1,0,0,0,3405,3403,1,0,0,0,3405,3404,1,0, + 0,0,3406,333,1,0,0,0,3407,3408,3,336,168,0,3408,3409,5,17,0,0,3409,3410, + 3,338,169,0,3410,3411,5,18,0,0,3411,335,1,0,0,0,3412,3413,5,25,0,0,3413, + 3414,5,40,0,0,3414,3415,3,98,49,0,3415,3416,3,2,1,0,3416,3425,1,0,0,0, + 3417,3418,5,25,0,0,3418,3419,5,40,0,0,3419,3420,3,98,49,0,3420,3421,3, + 2,1,0,3421,3422,5,34,0,0,3422,3423,3,2,1,0,3423,3425,1,0,0,0,3424,3412, + 1,0,0,0,3424,3417,1,0,0,0,3425,337,1,0,0,0,3426,3428,3,340,170,0,3427, + 3426,1,0,0,0,3428,3431,1,0,0,0,3429,3427,1,0,0,0,3429,3430,1,0,0,0,3430, + 339,1,0,0,0,3431,3429,1,0,0,0,3432,3433,5,180,0,0,3433,3434,5,36,0,0,3434, + 3435,5,30,0,0,3435,3436,3,300,150,0,3436,3437,5,31,0,0,3437,3447,1,0,0, + 0,3438,3447,3,332,166,0,3439,3440,5,171,0,0,3440,3441,5,36,0,0,3441,3442, + 5,30,0,0,3442,3443,3,300,150,0,3443,3444,5,31,0,0,3444,3447,1,0,0,0,3445, + 3447,5,55,0,0,3446,3432,1,0,0,0,3446,3438,1,0,0,0,3446,3439,1,0,0,0,3446, + 3445,1,0,0,0,3447,341,1,0,0,0,3448,3449,3,344,172,0,3449,3450,5,17,0,0, + 3450,3451,3,350,175,0,3451,3452,5,18,0,0,3452,343,1,0,0,0,3453,3454,5, + 50,0,0,3454,3458,5,40,0,0,3455,3457,3,348,174,0,3456,3455,1,0,0,0,3457, + 3460,1,0,0,0,3458,3456,1,0,0,0,3458,3459,1,0,0,0,3459,3461,1,0,0,0,3460, + 3458,1,0,0,0,3461,3462,3,2,1,0,3462,345,1,0,0,0,3463,3467,5,301,0,0,3464, + 3466,3,348,174,0,3465,3464,1,0,0,0,3466,3469,1,0,0,0,3467,3465,1,0,0,0, + 3467,3468,1,0,0,0,3468,3470,1,0,0,0,3469,3467,1,0,0,0,3470,3471,3,2,1, + 0,3471,347,1,0,0,0,3472,3488,5,52,0,0,3473,3488,5,51,0,0,3474,3488,5,172, + 0,0,3475,3476,5,62,0,0,3476,3488,5,51,0,0,3477,3478,5,62,0,0,3478,3488, + 5,52,0,0,3479,3480,5,62,0,0,3480,3488,5,63,0,0,3481,3482,5,62,0,0,3482, + 3488,5,64,0,0,3483,3484,5,62,0,0,3484,3488,5,65,0,0,3485,3486,5,62,0,0, + 3486,3488,5,66,0,0,3487,3472,1,0,0,0,3487,3473,1,0,0,0,3487,3474,1,0,0, + 0,3487,3475,1,0,0,0,3487,3477,1,0,0,0,3487,3479,1,0,0,0,3487,3481,1,0, + 0,0,3487,3483,1,0,0,0,3487,3485,1,0,0,0,3488,349,1,0,0,0,3489,3491,3,352, + 176,0,3490,3489,1,0,0,0,3491,3494,1,0,0,0,3492,3490,1,0,0,0,3492,3493, + 1,0,0,0,3493,351,1,0,0,0,3494,3492,1,0,0,0,3495,3496,5,21,0,0,3496,3509, + 3,2,1,0,3497,3498,5,50,0,0,3498,3499,5,40,0,0,3499,3509,3,118,59,0,3500, + 3501,5,25,0,0,3501,3502,5,40,0,0,3502,3509,3,2,1,0,3503,3509,3,174,87, + 0,3504,3505,5,50,0,0,3505,3509,3,32,16,0,3506,3509,3,330,165,0,3507,3509, + 3,40,20,0,3508,3495,1,0,0,0,3508,3497,1,0,0,0,3508,3500,1,0,0,0,3508,3503, + 1,0,0,0,3508,3504,1,0,0,0,3508,3506,1,0,0,0,3508,3507,1,0,0,0,3509,353, + 1,0,0,0,3510,3511,3,356,178,0,3511,3512,5,17,0,0,3512,3513,3,360,180,0, + 3513,3514,5,18,0,0,3514,355,1,0,0,0,3515,3519,5,274,0,0,3516,3518,3,358, + 179,0,3517,3516,1,0,0,0,3518,3521,1,0,0,0,3519,3517,1,0,0,0,3519,3520, + 1,0,0,0,3520,3522,1,0,0,0,3521,3519,1,0,0,0,3522,3535,3,2,1,0,3523,3527, + 5,274,0,0,3524,3526,3,358,179,0,3525,3524,1,0,0,0,3526,3529,1,0,0,0,3527, + 3525,1,0,0,0,3527,3528,1,0,0,0,3528,3530,1,0,0,0,3529,3527,1,0,0,0,3530, + 3531,3,2,1,0,3531,3532,5,34,0,0,3532,3533,3,2,1,0,3533,3535,1,0,0,0,3534, + 3515,1,0,0,0,3534,3523,1,0,0,0,3535,357,1,0,0,0,3536,3537,7,13,0,0,3537, + 359,1,0,0,0,3538,3540,3,362,181,0,3539,3538,1,0,0,0,3540,3543,1,0,0,0, + 3541,3539,1,0,0,0,3541,3542,1,0,0,0,3542,361,1,0,0,0,3543,3541,1,0,0,0, + 3544,3545,5,21,0,0,3545,3546,3,2,1,0,3546,3547,5,44,0,0,3547,3548,3,32, + 16,0,3548,3555,1,0,0,0,3549,3550,5,25,0,0,3550,3551,5,40,0,0,3551,3555, + 3,2,1,0,3552,3555,3,330,165,0,3553,3555,3,40,20,0,3554,3544,1,0,0,0,3554, + 3549,1,0,0,0,3554,3552,1,0,0,0,3554,3553,1,0,0,0,3555,363,1,0,0,0,181, + 374,382,391,400,489,535,546,576,580,598,625,648,684,694,701,703,713,715, + 722,733,746,767,769,788,861,868,875,880,889,1000,1006,1022,1028,1034,1041, + 1069,1147,1149,1163,1169,1178,1180,1189,1203,1217,1225,1233,1237,1276, + 1284,1293,1301,1320,1330,1333,1357,1504,1514,1523,1526,1608,1617,1649, + 1709,1749,1765,1775,1802,1826,1834,1838,1853,1860,1905,1915,1933,1951, + 1970,1991,2010,2025,2033,2045,2065,2072,2077,2088,2100,2210,2222,2238, + 2252,2261,2274,2276,2319,2330,2337,2345,2353,2366,2372,2378,2383,2412, + 2420,2434,2439,2464,2473,2484,2488,2495,2515,2524,2526,2541,2588,2598, + 2600,2607,2613,2657,2666,2706,2711,2751,2755,2765,2787,2799,2810,2825, + 2838,2851,2854,2862,2876,2894,2912,2926,2950,2962,2967,2976,2978,2985, + 2995,3063,3140,3147,3155,3305,3309,3311,3316,3318,3324,3330,3336,3342, + 3348,3354,3360,3367,3372,3378,3405,3424,3429,3446,3458,3467,3487,3492, + 3508,3519,3527,3534,3541,3554 }; public static readonly ATN _ATN = diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILVisitor.cs b/src/tools/ilasm/src/ILAssembler/gen/CILVisitor.cs index e937296823f511..f7acff204efcf9 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILVisitor.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILVisitor.cs @@ -1114,6 +1114,12 @@ public interface ICILVisitor : IParseTreeVisitor { /// The visitor result. Result VisitAsmOrRefDecl([NotNull] CILParser.AsmOrRefDeclContext context); /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitAssemblyRefBlock([NotNull] CILParser.AssemblyRefBlockContext context); + /// /// Visit a parse tree produced by . /// /// The parse tree. @@ -1132,6 +1138,12 @@ public interface ICILVisitor : IParseTreeVisitor { /// The visitor result. Result VisitAssemblyRefDecl([NotNull] CILParser.AssemblyRefDeclContext context); /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitExptypeBlock([NotNull] CILParser.ExptypeBlockContext context); + /// /// Visit a parse tree produced by . /// /// The parse tree. @@ -1162,6 +1174,12 @@ public interface ICILVisitor : IParseTreeVisitor { /// The visitor result. Result VisitExptypeDecl([NotNull] CILParser.ExptypeDeclContext context); /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitManifestResBlock([NotNull] CILParser.ManifestResBlockContext context); + /// /// Visit a parse tree produced by . /// /// The parse tree. diff --git a/src/tools/ilasm/tests/ILAssembler.Tests/DocumentCompilerTests.cs b/src/tools/ilasm/tests/ILAssembler.Tests/DocumentCompilerTests.cs index a20843d6c19ce5..8fc79e9ea39886 100644 --- a/src/tools/ilasm/tests/ILAssembler.Tests/DocumentCompilerTests.cs +++ b/src/tools/ilasm/tests/ILAssembler.Tests/DocumentCompilerTests.cs @@ -131,6 +131,26 @@ .class public auto ansi Following { } """)] + [InlineData(""" + .assembly extern mscorlib { } + .assembly test { } + .namespace + { + } + .class public auto ansi Following + { + } + """)] + [InlineData(""" + .assembly extern mscorlib { } + .assembly test { } + .class public auto ansi Broken extends + { + } + .class public auto ansi Following + { + } + """)] [InlineData(""" .assembly extern mscorlib { } .assembly test { } @@ -155,7 +175,7 @@ .class public auto ansi Following { } """)] - public void SyntaxErrorInDeclarationBody_DoesNotLeakScopesIntoFollowingDeclarations(string source) + public void SyntaxErrorInDeclaration_DoesNotLeakScopesIntoFollowingDeclarations(string source) { var compiler = new DocumentCompiler(); var (diagnostics, image) = compiler.Compile( From 47d634c4958f5f215cadbae6421ee058875a76e8 Mon Sep 17 00:00:00 2001 From: Jeremy Koritzinsky Date: Thu, 13 Aug 2026 17:21:22 -0700 Subject: [PATCH 10/16] Synthesize custom attributes and initializers Convert custom attribute descriptors, named arguments, serialized values, arrays, object sequences, and field/parameter initializers to semantic values. Remove their parse-tree islands while preserving pseudo-attribute lowering and owner binding. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: c986c103-8383-4db4-9b11-9be49dc68a05 --- src/tools/ilasm/README.md | 8 +- ...GrammarActions.CustomAttributes.Actions.cs | 386 + ...ammarActions.CustomAttributes.Sequences.cs | 307 + ...rActions.CustomAttributes.Serialization.cs | 449 ++ .../GrammarActions.CustomAttributes.Values.cs | 132 + .../GrammarActions.CustomAttributes.cs | 730 -- .../Actions/GrammarActions.Literals.cs | 6 +- .../Actions/GrammarActions.Members.Fields.cs | 46 - .../Actions/GrammarActions.Security.cs | 52 + .../Actions/GrammarActions.Types.cs | 35 - .../src/ILAssembler/Actions/GrammarActions.cs | 6 + src/tools/ilasm/src/ILAssembler/gen/CIL.g4 | 317 +- .../ilasm/src/ILAssembler/gen/CIL.interp | 2 +- .../ilasm/src/ILAssembler/gen/CILParser.cs | 6813 +++++++++-------- .../ILAssembler.Tests/CustomAttributeTests.cs | 132 + 15 files changed, 5255 insertions(+), 4166 deletions(-) create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Actions.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Sequences.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Serialization.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Values.cs delete mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.cs diff --git a/src/tools/ilasm/README.md b/src/tools/ilasm/README.md index bc63180cb0432e..11179cbeaf0b90 100644 --- a/src/tools/ilasm/README.md +++ b/src/tools/ilasm/README.md @@ -16,7 +16,10 @@ a subtree at all. | `GrammarActions.BuildImage.cs` | PE and portable PDB construction. | | `GrammarActions.Bytes.cs` | `bytearray` accumulation. | | `GrammarActions.Conversions.cs` | `GrammarResult`, shared state and core visitor plumbing. | -| `GrammarActions.CustomAttributes.cs` | Custom attribute values and serialization. | +| `GrammarActions.CustomAttributes.Actions.cs` | Custom attribute descriptors, declarations and blob lists. | +| `GrammarActions.CustomAttributes.Sequences.cs` | Custom attribute scalar-array sequence synthesis. | +| `GrammarActions.CustomAttributes.Serialization.cs` | Serialized attribute values and field/parameter initializers. | +| `GrammarActions.CustomAttributes.Values.cs` | Internal synthesized custom attribute value model. | | `GrammarActions.Data.cs` | Data and blob declarations. | | `GrammarActions.Debug.cs` | Source and debug directives. | | `GrammarActions.Declarations.cs` | Parser-driven top-level declaration visitor guards. | @@ -71,8 +74,7 @@ method-header, method-body directive and exception-handling structure is action- `scopeBlock` records offsets under its context key without inspecting children. The remaining `BeginSubtree` islands are the bounded shared roots `assemblyBlock`, `assemblyRefBlock`, `exptypeBlock`, `manifestResBlock`, `dataDecl`, `fileDecl`, `vtableDecl`, `vtfixupDecl`, `secDecl`, -`extSourceSpec`, `languageDecl`, `typedefDecl`, `initOpt`, `customAttrDecl`, `customDescr`, -`customDescrWithOwner` and `customDescrInMethodBody`. +`extSourceSpec`, `languageDecl` and `typedefDecl`. Semantic state that a rule pushes must be released from that rule's `finally` clause and be keyed on the owning context, because ANTLR skips `@after` actions and the remainder of an alternative once a diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Actions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Actions.cs new file mode 100644 index 00000000000000..cc52485eac84e9 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Actions.cs @@ -0,0 +1,386 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Reflection.Metadata; +using Antlr4.Runtime; + +namespace ILAssembler; + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. +internal sealed partial class GrammarActions +{ + private readonly Stack _customBlobArgumentFrames = new(); + private readonly Stack _customBlobNamedArgumentFrames = new(); + + private sealed class CustomBlobArgumentsFrame + { + public CustomBlobArgumentsFrame(CILParser.CustomBlobArgsContext owner) + { + Owner = owner; + } + + public CILParser.CustomBlobArgsContext Owner { get; } + + public ImmutableArray.Builder? Values { get; set; } + } + + private sealed class CustomBlobNamedArgumentsFrame + { + public CustomBlobNamedArgumentsFrame(CILParser.CustomBlobNVPairsContext owner) + { + Owner = owner; + } + + public CILParser.CustomBlobNVPairsContext Owner { get; } + + public ImmutableArray.Builder? Values { get; set; } + } + + internal object CreateCustomAttributeType(object? constructor) + => GetMethodReferenceValue(constructor); + + internal object CreateDefaultCustomAttribute(object? constructor) + => CreateCustomAttributeDescriptor( + constructor, + new RawCustomAttributeBlobValue(CreateDefaultCustomAttributeBlob()), + null); + + internal object CreateStringCustomAttribute(object? constructor, string value) + => CreateCustomAttributeDescriptor( + constructor, + new RawCustomAttributeBlobValue(CreateStringBlob(value)), + null); + + internal object CreateStructuredCustomAttribute(object? constructor, object? value) + => CreateCustomAttributeDescriptor( + constructor, + value as CustomAttributeBlobValue + ?? new RawCustomAttributeBlobValue(new BlobBuilder()), + null); + + internal object CreateRawCustomAttribute(object? constructor, ImmutableArray value) + => CreateCustomAttributeDescriptor( + constructor, + new RawCustomAttributeBlobValue(CreateRawBlob(value)), + null); + + internal object CreateDefaultOwnedCustomAttribute(object? owner, object? constructor) + => CreateCustomAttributeDescriptor( + constructor, + new RawCustomAttributeBlobValue(CreateDefaultCustomAttributeBlob()), + GetOwnerTypeValue(owner)); + + internal object CreateStringOwnedCustomAttribute(object? owner, object? constructor, string value) + => CreateCustomAttributeDescriptor( + constructor, + new RawCustomAttributeBlobValue(CreateStringBlob(value)), + GetOwnerTypeValue(owner)); + + internal object CreateStructuredOwnedCustomAttribute( + object? owner, + object? constructor, + object? value) + => CreateCustomAttributeDescriptor( + constructor, + value as CustomAttributeBlobValue + ?? new RawCustomAttributeBlobValue(new BlobBuilder()), + GetOwnerTypeValue(owner)); + + internal object CreateRawOwnedCustomAttribute( + object? owner, + object? constructor, + ImmutableArray value) + => CreateCustomAttributeDescriptor( + constructor, + new RawCustomAttributeBlobValue(CreateRawBlob(value)), + GetOwnerTypeValue(owner)); + + internal object CreateCustomAttributeDeclaration(object? value) + => GetCustomAttributeDescriptorValue(value); + + internal object CreateCustomAttributeTypedef(string alias) + => new CustomAttributeTypedefValue(alias); + + private static CustomAttributeDescriptorValue CreateCustomAttributeDescriptor( + object? constructor, + CustomAttributeBlobValue value, + OwnerTypeValue? owner) + => new(GetMethodReferenceValue(constructor), value, owner); + + private static BlobBuilder CreateStringBlob(string value) + { + BlobBuilder blob = new(); + blob.WriteUTF8(value); + return blob; + } + + private static BlobBuilder CreateRawBlob(ImmutableArray value) + { + BlobBuilder blob = new(value.Length); + blob.WriteBytes(value); + return blob; + } + + internal object CreateCustomAttributeBlob(object? arguments, object? namedArguments) + => new StructuredCustomAttributeBlobValue( + arguments is ImmutableArray argumentValues + ? argumentValues + : [], + namedArguments is ImmutableArray namedArgumentValues + ? namedArgumentValues + : []); + + internal void BeginCustomBlobArguments(CILParser.CustomBlobArgsContext context) + => _customBlobArgumentFrames.Push(new(context)); + + internal void AddCustomBlobArgument(CILParser.CustomBlobArgsContext context, object? value) + { + if (TryGetCustomBlobArgumentsFrame(context) is { } frame) + { + (frame.Values ??= + ImmutableArray.CreateBuilder()) + .Add(GetSerializedInitializerValue(value)); + } + } + + internal object EndCustomBlobArguments(CILParser.CustomBlobArgsContext context) + { + if (TryGetCustomBlobArgumentsFrame(context) is not { } frame) + { + return ImmutableArray.Empty; + } + + _customBlobArgumentFrames.Pop(); + return frame.Values?.ToImmutable() ?? ImmutableArray.Empty; + } + + internal void BeginCustomBlobNamedArguments(CILParser.CustomBlobNVPairsContext context) + => _customBlobNamedArgumentFrames.Push(new(context)); + + internal void AddCustomBlobNamedArgument( + CILParser.CustomBlobNVPairsContext context, + byte kind, + object? type, + string name, + object? value) + { + if (TryGetCustomBlobNamedArgumentsFrame(context) is not { } frame) + { + return; + } + + (frame.Values ??= + ImmutableArray.CreateBuilder()) + .Add(new( + kind, + GetSerializationTypeValue(type), + name, + GetSerializedInitializerValue(value))); + } + + internal object EndCustomBlobNamedArguments(CILParser.CustomBlobNVPairsContext context) + { + if (TryGetCustomBlobNamedArgumentsFrame(context) is not { } frame) + { + return ImmutableArray.Empty; + } + + _customBlobNamedArgumentFrames.Pop(); + return frame.Values?.ToImmutable() + ?? ImmutableArray.Empty; + } + + private CustomBlobArgumentsFrame? TryGetCustomBlobArgumentsFrame( + CILParser.CustomBlobArgsContext context) + { + Debug.Assert(_customBlobArgumentFrames.Count > 0); + CustomBlobArgumentsFrame? frame = + _customBlobArgumentFrames.Count == 0 ? null : _customBlobArgumentFrames.Peek(); + Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); + return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; + } + + private CustomBlobNamedArgumentsFrame? TryGetCustomBlobNamedArgumentsFrame( + CILParser.CustomBlobNVPairsContext context) + { + Debug.Assert(_customBlobNamedArgumentFrames.Count > 0); + CustomBlobNamedArgumentsFrame? frame = + _customBlobNamedArgumentFrames.Count == 0 ? null : _customBlobNamedArgumentFrames.Peek(); + Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); + return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; + } + + private BlobBuilder MaterializeCustomAttributeBlob(CustomAttributeBlobValue value) + { + if (value is RawCustomAttributeBlobValue raw) + { + return raw.Value; + } + + StructuredCustomAttributeBlobValue structured = + (StructuredCustomAttributeBlobValue)value; + BlobBuilder result = new(); + result.WriteUInt16(CustomAttributeBlobFormatVersion); + foreach (SerializedInitializerValue argument in structured.Arguments) + { + MaterializeSerializedInitializer(argument).WriteContentTo(result); + } + + WriteCustomBlobNamedArguments(result, structured.NamedArguments); + return result; + } + + private void WriteCustomBlobNamedArguments( + BlobBuilder result, + ImmutableArray namedArguments) + { + result.WriteInt16((short)namedArguments.Length); + foreach (CustomAttributeNamedArgumentValue argument in namedArguments) + { + result.WriteByte(argument.Kind); + MaterializeSerializationType(argument.Type).WriteContentTo(result); + result.WriteSerializedString(argument.Name); + MaterializeSerializedInitializer(argument.Value).WriteContentTo(result); + } + } + + private EntityRegistry.CustomAttributeEntity MaterializeCustomAttribute( + CustomAttributeDescriptorValue descriptor, + IToken location) + { + EntityRegistry.EntityBase constructor = MaterializeMethodReference(descriptor.Constructor); + BlobBuilder value = MaterializeCustomAttributeBlob(descriptor.Value); + EntityRegistry.CustomAttributeEntity attribute = + _entityRegistry.CreateCustomAttribute(constructor, value); + attribute.Location = Location.From(location, _documents); + if (descriptor.Owner is { } owner) + { + attribute.Owner = MaterializeOwnerType(owner); + } + + return attribute; + } + + private EntityRegistry.CustomAttributeEntity? MaterializeCustomAttributeDeclaration( + object? value, + IToken location) + { + if (value is CustomAttributeTypedefValue typedef) + { + if (TryResolveTypedefAsCustomAttribute(typedef.Alias) is not { } resolved) + { + return null; + } + + EntityRegistry.CustomAttributeEntity typedefAttribute = + _entityRegistry.CreateCustomAttribute(resolved.Constructor, resolved.Value); + typedefAttribute.Location = Location.From(location, _documents); + return typedefAttribute; + } + + if (value is not CustomAttributeDescriptorValue descriptor) + { + return null; + } + + EntityRegistry.CustomAttributeEntity attribute = MaterializeCustomAttribute(descriptor, location); + return descriptor.Owner is null ? attribute : null; + } + + GrammarResult ICILVisitor.VisitCustomAttrDecl( + CILParser.CustomAttrDeclContext context) + => VisitCustomAttrDecl(context); + + public GrammarResult.Literal VisitCustomAttrDecl( + CILParser.CustomAttrDeclContext context) + => new(MaterializeCustomAttributeDeclaration(context.Value, context.Start)); + + GrammarResult ICILVisitor.VisitCustomBlobArgs( + CILParser.CustomBlobArgsContext context) + => VisitCustomBlobArgs(context); + + public GrammarResult.FormattedBlob VisitCustomBlobArgs( + CILParser.CustomBlobArgsContext context) + { + BlobBuilder result = new(); + if (context.Value is ImmutableArray arguments) + { + foreach (SerializedInitializerValue argument in arguments) + { + MaterializeSerializedInitializer(argument).WriteContentTo(result); + } + } + + return new(result); + } + + GrammarResult ICILVisitor.VisitCustomBlobDescr( + CILParser.CustomBlobDescrContext context) + => VisitCustomBlobDescr(context); + + public GrammarResult.FormattedBlob VisitCustomBlobDescr( + CILParser.CustomBlobDescrContext context) + => new(MaterializeCustomAttributeBlob( + context.Value as CustomAttributeBlobValue + ?? new RawCustomAttributeBlobValue(new BlobBuilder()))); + + GrammarResult ICILVisitor.VisitCustomBlobNVPairs( + CILParser.CustomBlobNVPairsContext context) + => VisitCustomBlobNVPairs(context); + + public GrammarResult.FormattedBlob VisitCustomBlobNVPairs( + CILParser.CustomBlobNVPairsContext context) + { + BlobBuilder result = new(); + WriteCustomBlobNamedArguments( + result, + context.Value is ImmutableArray values + ? values + : []); + return new(result); + } + + GrammarResult ICILVisitor.VisitCustomDescr(CILParser.CustomDescrContext context) + => VisitCustomDescr(context); + + public GrammarResult.Literal VisitCustomDescr( + CILParser.CustomDescrContext context) + => new(MaterializeCustomAttribute( + GetCustomAttributeDescriptorValue(context.Value), + context.Start)); + + GrammarResult ICILVisitor.VisitCustomDescrInMethodBody( + CILParser.CustomDescrInMethodBodyContext context) + => VisitCustomDescrInMethodBody(context); + + public GrammarResult.Literal VisitCustomDescrInMethodBody( + CILParser.CustomDescrInMethodBodyContext context) + => new(MaterializeCustomAttributeDeclaration(context.Value, context.Start)); + + GrammarResult ICILVisitor.VisitCustomDescrWithOwner( + CILParser.CustomDescrWithOwnerContext context) + => VisitCustomDescrWithOwner(context); + + public GrammarResult.Literal VisitCustomDescrWithOwner( + CILParser.CustomDescrWithOwnerContext context) + => new(MaterializeCustomAttribute( + GetCustomAttributeDescriptorValue(context.Value), + context.Start)); + + GrammarResult ICILVisitor.VisitCustomType(CILParser.CustomTypeContext context) + => VisitCustomType(context); + + public GrammarResult.Literal VisitCustomType( + CILParser.CustomTypeContext context) + => new(MaterializeMethodReference(GetMethodReferenceValue(context.Value))); + + GrammarResult ICILVisitor.VisitOwnerType(CILParser.OwnerTypeContext context) + => VisitOwnerType(context); + + public GrammarResult.Literal VisitOwnerType( + CILParser.OwnerTypeContext context) + => new(MaterializeOwnerType(GetOwnerTypeValue(context.Value))); +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Sequences.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Sequences.cs new file mode 100644 index 00000000000000..630dfa58baa262 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Sequences.cs @@ -0,0 +1,307 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Reflection.Metadata; +using Antlr4.Runtime; + +namespace ILAssembler; + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. +internal sealed partial class GrammarActions +{ + private readonly Stack _serializationSequenceFrames = new(); + + private sealed class SerializationSequenceFrame + { + public SerializationSequenceFrame(ParserRuleContext owner) + { + Owner = owner; + } + + public ParserRuleContext Owner { get; } + + public BlobBuilder? Value { get; set; } + + public ImmutableArray.Builder? ClassValues { get; set; } + + public ImmutableArray.Builder? ObjectValues { get; set; } + } + + internal void BeginSerializationSequence(ParserRuleContext context) + => _serializationSequenceFrames.Push(new(context)); + + internal void AddFloat32SequenceValue(ParserRuleContext context, double value) + { + if (TryGetSerializationSequenceFrame(context) is { } frame) + { + (frame.Value ??= new BlobBuilder()).WriteSingle((float)value); + } + } + + internal void AddFloat32SequenceValue(ParserRuleContext context, IToken value) + { + if (TryGetSerializationSequenceFrame(context) is { } frame) + { + (frame.Value ??= new BlobBuilder()).WriteSingle(ParseInt32(value)); + } + } + + internal void AddFloat64SequenceValue(ParserRuleContext context, double value) + { + if (TryGetSerializationSequenceFrame(context) is { } frame) + { + (frame.Value ??= new BlobBuilder()).WriteDouble(value); + } + } + + internal void AddFloat64SequenceValue(ParserRuleContext context, IToken value) + { + if (TryGetSerializationSequenceFrame(context) is { } frame) + { + (frame.Value ??= new BlobBuilder()).WriteDouble(ParseInt64(value)); + } + } + + internal void AddInt64SequenceValue(ParserRuleContext context, IToken value) + { + if (TryGetSerializationSequenceFrame(context) is { } frame) + { + (frame.Value ??= new BlobBuilder()).WriteInt64(ParseInt64(value)); + } + } + + internal void AddInt32SequenceValue(ParserRuleContext context, IToken value) + { + if (TryGetSerializationSequenceFrame(context) is { } frame) + { + (frame.Value ??= new BlobBuilder()).WriteInt32(ParseInt32(value)); + } + } + + internal void AddInt16SequenceValue(ParserRuleContext context, IToken value) + { + if (TryGetSerializationSequenceFrame(context) is { } frame) + { + (frame.Value ??= new BlobBuilder()).WriteInt16((short)ParseInt32(value)); + } + } + + internal void AddInt8SequenceValue(ParserRuleContext context, IToken value) + { + if (TryGetSerializationSequenceFrame(context) is { } frame) + { + (frame.Value ??= new BlobBuilder()).WriteByte((byte)ParseInt32(value)); + } + } + + internal void AddBooleanSequenceValue(ParserRuleContext context, bool value) + { + if (TryGetSerializationSequenceFrame(context) is { } frame) + { + (frame.Value ??= new BlobBuilder()).WriteBoolean(value); + } + } + + internal void AddStringSequenceValue(ParserRuleContext context, IToken value) + { + if (TryGetSerializationSequenceFrame(context) is { } frame) + { + (frame.Value ??= new BlobBuilder()).WriteSerializedString( + value.Type == CILParser.NULLREF + ? null + : StringHelpers.ParseQuotedString(value.Text)); + } + } + + internal void AddClassSequenceValue(ParserRuleContext context, object? value) + { + if (TryGetSerializationSequenceFrame(context) is { } frame && + value is ClassSequenceElementValue element) + { + (frame.ClassValues ??= + ImmutableArray.CreateBuilder()).Add(element); + } + } + + internal void AddObjectSequenceValue(ParserRuleContext context, object? value) + { + if (TryGetSerializationSequenceFrame(context) is { } frame) + { + (frame.ObjectValues ??= + ImmutableArray.CreateBuilder()) + .Add(GetSerializedInitializerValue(value)); + } + } + + internal BlobBuilder EndSerializationSequence(ParserRuleContext context) + { + if (TryGetSerializationSequenceFrame(context) is not { } frame) + { + return new BlobBuilder(); + } + + _serializationSequenceFrames.Pop(); + return frame.Value ?? new BlobBuilder(); + } + + internal object EndClassSerializationSequence(ParserRuleContext context) + { + if (TryGetSerializationSequenceFrame(context) is not { } frame) + { + return new ClassSerializedSequenceValue([]); + } + + _serializationSequenceFrames.Pop(); + return new ClassSerializedSequenceValue(frame.ClassValues?.ToImmutable() ?? []); + } + + internal object EndObjectSerializationSequence(ParserRuleContext context) + { + if (TryGetSerializationSequenceFrame(context) is not { } frame) + { + return new ObjectSerializedSequenceValue([]); + } + + _serializationSequenceFrames.Pop(); + return new ObjectSerializedSequenceValue(frame.ObjectValues?.ToImmutable() ?? []); + } + + private SerializationSequenceFrame? TryGetSerializationSequenceFrame(ParserRuleContext context) + { + Debug.Assert(_serializationSequenceFrames.Count > 0); + SerializationSequenceFrame? frame = + _serializationSequenceFrames.Count == 0 ? null : _serializationSequenceFrames.Peek(); + Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); + return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; + } + + internal object CreateNullClassSequenceValue() + => new StringClassSequenceElementValue(null); + + internal object CreateQuotedClassSequenceValue(IToken value) + => new StringClassSequenceElementValue(StringHelpers.ParseQuotedString(value.Text)); + + internal object CreateClassSequenceValue(object? className) + => new TypeClassSequenceElementValue(GetClassNameValue(className)); + + private BlobBuilder MaterializeSerializedSequence(SerializedSequenceValue sequence) + { + if (sequence is RawSerializedSequenceValue raw) + { + return raw.Value; + } + + BlobBuilder blob = new(); + switch (sequence) + { + case ClassSerializedSequenceValue classes: + foreach (ClassSequenceElementValue value in classes.Values) + { + MaterializeClassSequenceElement(value).WriteContentTo(blob); + } + break; + case ObjectSerializedSequenceValue objects: + foreach (SerializedInitializerValue value in objects.Values) + { + SerializedInitializerValue initializer = value; + while (initializer is ObjectSerializedInitializerValue boxed) + { + initializer = boxed.Value; + } + + MaterializeSerializationType(initializer.Type).WriteContentTo(blob); + MaterializeSerializedInitializer(initializer).WriteContentTo(blob); + } + break; + } + + return blob; + } + + private BlobBuilder MaterializeClassSequenceElement(ClassSequenceElementValue value) + { + BlobBuilder blob = new(); + blob.WriteSerializedString(value switch + { + StringClassSequenceElementValue text => text.Value, + TypeClassSequenceElementValue type => GetReflectionNotation(type.ClassName), + _ => null + }); + return blob; + } + + GrammarResult ICILVisitor.VisitBoolSeq(CILParser.BoolSeqContext context) + => VisitBoolSeq(context); + + public static GrammarResult.FormattedBlob VisitBoolSeq(CILParser.BoolSeqContext context) + => new(context.Value ?? new BlobBuilder()); + + GrammarResult ICILVisitor.VisitClassSeq(CILParser.ClassSeqContext context) + => VisitClassSeq(context); + + public GrammarResult.FormattedBlob VisitClassSeq(CILParser.ClassSeqContext context) + => new(MaterializeSerializedSequence(GetSerializedSequenceValue(context.Value))); + + GrammarResult ICILVisitor.VisitClassSeqElement( + CILParser.ClassSeqElementContext context) + => VisitClassSeqElement(context); + + public GrammarResult.FormattedBlob VisitClassSeqElement( + CILParser.ClassSeqElementContext context) + => new(MaterializeClassSequenceElement( + context.Value as ClassSequenceElementValue + ?? new StringClassSequenceElementValue(null))); + + GrammarResult ICILVisitor.VisitF32seq(CILParser.F32seqContext context) + => VisitF32seq(context); + + public static GrammarResult.FormattedBlob VisitF32seq(CILParser.F32seqContext context) + => new(context.Value ?? new BlobBuilder()); + + GrammarResult ICILVisitor.VisitF64seq(CILParser.F64seqContext context) + => VisitF64seq(context); + + public static GrammarResult.FormattedBlob VisitF64seq(CILParser.F64seqContext context) + => new(context.Value ?? new BlobBuilder()); + + GrammarResult ICILVisitor.VisitI16seq(CILParser.I16seqContext context) + => VisitI16seq(context); + + public static GrammarResult.FormattedBlob VisitI16seq(CILParser.I16seqContext context) + => new(context.Value ?? new BlobBuilder()); + + GrammarResult ICILVisitor.VisitI32seq(CILParser.I32seqContext context) + => VisitI32seq(context); + + public static GrammarResult.FormattedBlob VisitI32seq(CILParser.I32seqContext context) + => new(context.Value ?? new BlobBuilder()); + + GrammarResult ICILVisitor.VisitI64seq(CILParser.I64seqContext context) + => VisitI64seq(context); + + public static GrammarResult.FormattedBlob VisitI64seq(CILParser.I64seqContext context) + => new(context.Value ?? new BlobBuilder()); + + GrammarResult ICILVisitor.VisitI8seq(CILParser.I8seqContext context) + => VisitI8seq(context); + + public static GrammarResult.FormattedBlob VisitI8seq(CILParser.I8seqContext context) + => new(context.Value ?? new BlobBuilder()); + + GrammarResult ICILVisitor.VisitObjSeq(CILParser.ObjSeqContext context) + => VisitObjSeq(context); + + public GrammarResult.FormattedBlob VisitObjSeq(CILParser.ObjSeqContext context) + => new(MaterializeSerializedSequence(GetSerializedSequenceValue(context.Value))); + + GrammarResult ICILVisitor.VisitSqstringSeq( + CILParser.SqstringSeqContext context) + => VisitSqstringSeq(context); + + public static GrammarResult.FormattedBlob VisitSqstringSeq( + CILParser.SqstringSeqContext context) + => new(context.Value ?? new BlobBuilder()); +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Serialization.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Serialization.cs new file mode 100644 index 00000000000000..693b96b32349aa --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Serialization.cs @@ -0,0 +1,449 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Reflection.Metadata; +using System.Text; +using Antlr4.Runtime; + +namespace ILAssembler; + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. +internal sealed partial class GrammarActions +{ + internal byte GetCustomAttributeNamedArgumentKind(IToken token) + => (byte)(token.Text == "field" + ? CustomAttributeNamedArgumentKind.Field + : CustomAttributeNamedArgumentKind.Property); + + internal object CreateSerializationType(object? element, IToken? array) + { + SerializationTypeValue value = GetSerializationTypeValue(element); + return array is null ? value : new ArraySerializationTypeValue(value); + } + + internal object CreatePrimitiveSerializationType(byte type) + => new SimpleSerializationTypeValue((SerializationTypeCode)type); + + internal object CreateSerializationTypeTypedef( + CILParser.SerializTypeElementContext context, + string alias) + => new TypedefSerializationTypeValue(context.Start, alias); + + internal object CreateSimpleSerializationType(IToken type) + => new SimpleSerializationTypeValue(GetSerializationTypeCode(type.Type)); + + internal object CreateEnumSerializationType(IToken name) + => new StringEnumSerializationTypeValue(StringHelpers.ParseQuotedString(name.Text)); + + internal object CreateEnumSerializationType(object? className) + => new ClassEnumSerializationTypeValue(GetClassNameValue(className)); + + internal BlobBuilder CreateFloat32SerializedInitializer( + CILParser.Float64Context context, + double value) + { + float serializedValue = IsPlainInteger(context) && + ParseIntegerValue(context.Start.Text.AsSpan(), out long rawValue) + ? BitConverter.Int32BitsToSingle((int)rawValue) + : (float)value; + BlobBuilder blob = CreateSerializedInitializer(SerializationTypeCode.Single); + blob.WriteSingle(serializedValue); + return blob; + } + + internal BlobBuilder CreateFloat64SerializedInitializer( + CILParser.Float64Context context, + double value) + { + double serializedValue = IsPlainInteger(context) && + ParseIntegerValue(context.Start.Text.AsSpan(), out long rawValue) + ? BitConverter.Int64BitsToDouble(rawValue) + : value; + BlobBuilder blob = CreateSerializedInitializer(SerializationTypeCode.Double); + blob.WriteDouble(serializedValue); + return blob; + } + + private static bool IsPlainInteger(CILParser.Float64Context context) + => context.Start.Type == CILParser.INT32 && + context.Stop is { Type: CILParser.INT32 }; + + internal BlobBuilder CreateFloat32BitsSerializedInitializer(IToken value) + { + BlobBuilder blob = CreateSerializedInitializer(SerializationTypeCode.Single); + blob.WriteSingle(BitConverter.Int32BitsToSingle(ParseInt32(value))); + return blob; + } + + internal BlobBuilder CreateFloat64BitsSerializedInitializer(IToken value) + { + BlobBuilder blob = CreateSerializedInitializer(SerializationTypeCode.Double); + blob.WriteDouble(BitConverter.Int64BitsToDouble(ParseInt64(value))); + return blob; + } + + internal BlobBuilder CreateIntegerSerializedInitializer(IToken type, IToken value) + { + BlobBuilder blob = CreateSerializedInitializer(GetSerializationTypeCode(type.Type)); + switch (type.Type) + { + case CILParser.INT8: + case CILParser.UINT8: + blob.WriteByte((byte)ParseInt32(value)); + break; + case CILParser.CHAR: + case CILParser.INT16: + case CILParser.UINT16: + blob.WriteInt16((short)ParseInt32(value)); + break; + case CILParser.INT32_: + case CILParser.UINT32: + blob.WriteInt32(ParseInt32(value)); + break; + case CILParser.INT64_: + case CILParser.UINT64: + blob.WriteInt64(ParseInt64(value)); + break; + default: + throw new UnreachableException(); + } + + return blob; + } + + internal BlobBuilder CreateBooleanSerializedInitializer(IToken type, bool value) + { + Debug.Assert(type.Type == CILParser.BOOL); + BlobBuilder blob = CreateSerializedInitializer(SerializationTypeCode.Boolean); + blob.WriteBoolean(value); + return blob; + } + + internal BlobBuilder CreateByteArraySerializedInitializer(ImmutableArray value) + { + BlobBuilder blob = CreateSerializedInitializer( + SerializationTypeCode.String, + value.Length + 1); + blob.WriteBytes(value); + return blob; + } + + private static BlobBuilder CreateSerializedInitializer( + SerializationTypeCode type, + int capacity = 9) + { + BlobBuilder blob = new(capacity); + blob.WriteByte((byte)type); + return blob; + } + + internal object? CreateFieldInitializer(BlobBuilder value) + => ExtractConstantFromSerInit(value); + + internal object CreateFieldInitializer(string value) => value; + + internal object? CreateNullFieldInitializer() => null; + + internal void BeginFieldInitializer(CILParser.InitOptContext context) + { + BeginSemanticRoot(context); + context.Value = NoConstantSentinel.Instance; + } + + internal void SetFieldInitializer(CILParser.InitOptContext context, object? value) + => context.Value = value; + + internal bool EndFieldInitializer(CILParser.InitOptContext context) + => EndSemanticRoot(context); + + internal object CreateScalarSerializedValue( + CILParser.SerInitContext context, + CILParser.FieldSerInitContext initializer, + BlobBuilder value) + { + if (initializer.Start.Text == "bytearray") + { + return new InvalidByteArraySerializedInitializerValue(context.Start); + } + + ImmutableArray encodedValue = value.ToImmutableArray(); + BlobBuilder serializedValue = new(Math.Max(0, encodedValue.Length - 1)); + if (encodedValue.Length > 1) + { + serializedValue.WriteBytes(encodedValue.AsSpan().Slice(1).ToArray()); + } + + SerializationTypeValue type = encodedValue.Length == 0 + ? new RawSerializationTypeValue(new BlobBuilder()) + : new SimpleSerializationTypeValue((SerializationTypeCode)encodedValue[0]); + return new RawSerializedInitializerValue(type, serializedValue); + } + + internal object CreateStringSerializedValue() + => CreateSerializedStringValue(SerializationTypeCode.String, null); + + internal object CreateStringSerializedValue(IToken value) + => CreateSerializedStringValue( + SerializationTypeCode.String, + StringHelpers.ParseQuotedString(value.Text)); + + internal object CreateTypeSerializedValue(IToken value) + => CreateSerializedStringValue( + SerializationTypeCode.Type, + StringHelpers.ParseQuotedString(value.Text)); + + internal object CreateTypeSerializedValue(object? className) + => new ClassNameSerializedInitializerValue(GetClassNameValue(className)); + + internal object CreateNullTypeSerializedValue() + => CreateSerializedStringValue(SerializationTypeCode.Type, null); + + private static RawSerializedInitializerValue CreateSerializedStringValue( + SerializationTypeCode type, + string? value) + { + BlobBuilder serializedValue = new(); + serializedValue.WriteSerializedString(value); + return new RawSerializedInitializerValue( + new SimpleSerializationTypeValue(type), + serializedValue); + } + + internal object CreateObjectSerializedValue(object? value) + => new ObjectSerializedInitializerValue(GetSerializedInitializerValue(value)); + + internal object CreateArraySerializedValue( + IToken elementType, + IToken length, + object? values) + => new ArraySerializedInitializerValue( + new ArraySerializationTypeValue( + new SimpleSerializationTypeValue(GetSerializationTypeCode(elementType.Type))), + ParseInt32(length), + GetSerializedSequenceValue(values)); + + private BlobBuilder MaterializeSerializationType(SerializationTypeValue value) + { + if (value is RawSerializationTypeValue raw) + { + return raw.Value; + } + + BlobBuilder blob = new(); + switch (value) + { + case SimpleSerializationTypeValue simple: + blob.WriteByte((byte)simple.Type); + break; + case ArraySerializationTypeValue array: + blob.WriteByte((byte)SerializationTypeCode.SZArray); + MaterializeSerializationType(array.ElementType).WriteContentTo(blob); + break; + case StringEnumSerializationTypeValue stringEnum: + blob.WriteByte((byte)SerializationTypeCode.Enum); + blob.WriteSerializedString(stringEnum.Name); + break; + case ClassEnumSerializationTypeValue classEnum: + blob.WriteByte((byte)SerializationTypeCode.Enum); + blob.WriteSerializedString(GetReflectionNotation(classEnum.ClassName)); + break; + case TypedefSerializationTypeValue typedef: + ReportError( + DiagnosticIds.TypedefNotFound, + string.Format(DiagnosticMessageTemplates.TypedefNotFound, typedef.Alias), + typedef.Token); + break; + } + + return blob; + } + + private BlobBuilder MaterializeSerializedInitializer(SerializedInitializerValue value) + { + if (value is RawSerializedInitializerValue raw) + { + return raw.Value; + } + + BlobBuilder blob = new(); + switch (value) + { + case ClassNameSerializedInitializerValue className: + blob.WriteSerializedString(GetReflectionNotation(className.ClassName)); + break; + case ObjectSerializedInitializerValue boxed: + MaterializeSerializationType(boxed.Value.Type).WriteContentTo(blob); + MaterializeSerializedInitializer(boxed.Value).WriteContentTo(blob); + break; + case InvalidByteArraySerializedInitializerValue invalid: + ReportError( + DiagnosticIds.InvalidMetadataToken, + "bytearray is not a valid structured custom attribute value", + invalid.Token); + blob.WriteSerializedString(null); + break; + case ArraySerializedInitializerValue array: + blob.WriteInt32(array.Length); + MaterializeSerializedSequence(array.Values).WriteContentTo(blob); + break; + } + + return blob; + } + + private string GetReflectionNotation(ClassNameValue className) + { + EntityRegistry.TypeEntity type = ResolveClassName(className); + return (type as EntityRegistry.IHasReflectionNotation)?.ReflectionNotation ?? string.Empty; + } + + private static SerializationTypeCode GetSerializationTypeCode(int tokenType) + => tokenType switch + { + CILParser.INT8 => SerializationTypeCode.SByte, + CILParser.UINT8 => SerializationTypeCode.Byte, + CILParser.INT16 => SerializationTypeCode.Int16, + CILParser.UINT16 => SerializationTypeCode.UInt16, + CILParser.INT32_ => SerializationTypeCode.Int32, + CILParser.UINT32 => SerializationTypeCode.UInt32, + CILParser.INT64_ => SerializationTypeCode.Int64, + CILParser.UINT64 => SerializationTypeCode.UInt64, + CILParser.FLOAT32 => SerializationTypeCode.Single, + CILParser.FLOAT64_ => SerializationTypeCode.Double, + CILParser.CHAR => SerializationTypeCode.Char, + CILParser.BOOL => SerializationTypeCode.Boolean, + CILParser.STRING => SerializationTypeCode.String, + CILParser.TYPE => SerializationTypeCode.Type, + CILParser.OBJECT => SerializationTypeCode.TaggedObject, + _ => throw new UnreachableException() + }; + + private static object? ExtractConstantFromSerInit(BlobBuilder blob) + { + ImmutableArray bytes = blob.ToImmutableArray(); + if (bytes.Length == 0) + { + return null; + } + + SerializationTypeCode typeCode = (SerializationTypeCode)bytes[0]; + ReadOnlySpan valueBytes = bytes.AsSpan().Slice(1); + return typeCode switch + { + SerializationTypeCode.Boolean => valueBytes.Length >= 1 && valueBytes[0] != 0, + SerializationTypeCode.Char => valueBytes.Length >= 2 ? BitConverter.ToChar(valueBytes) : '\0', + SerializationTypeCode.SByte => valueBytes.Length >= 1 ? (sbyte)valueBytes[0] : (sbyte)0, + SerializationTypeCode.Byte => valueBytes.Length >= 1 ? valueBytes[0] : (byte)0, + SerializationTypeCode.Int16 => valueBytes.Length >= 2 ? BitConverter.ToInt16(valueBytes) : (short)0, + SerializationTypeCode.UInt16 => valueBytes.Length >= 2 ? BitConverter.ToUInt16(valueBytes) : (ushort)0, + SerializationTypeCode.Int32 => valueBytes.Length >= 4 ? BitConverter.ToInt32(valueBytes) : 0, + SerializationTypeCode.UInt32 => valueBytes.Length >= 4 ? BitConverter.ToUInt32(valueBytes) : 0u, + SerializationTypeCode.Int64 => valueBytes.Length >= 8 ? BitConverter.ToInt64(valueBytes) : 0L, + SerializationTypeCode.UInt64 => valueBytes.Length >= 8 ? BitConverter.ToUInt64(valueBytes) : 0uL, + SerializationTypeCode.Single => valueBytes.Length >= 4 ? BitConverter.ToSingle(valueBytes) : 0f, + SerializationTypeCode.Double => valueBytes.Length >= 8 ? BitConverter.ToDouble(valueBytes) : 0d, + SerializationTypeCode.String => Encoding.Unicode.GetString(valueBytes), + SerializationTypeCode.Type => ExtractSerString(valueBytes), + SerializationTypeCode.SZArray => valueBytes.ToArray(), + SerializationTypeCode.TaggedObject => valueBytes.ToArray(), + SerializationTypeCode.Enum => valueBytes.ToArray(), + _ => bytes.AsSpan().ToArray() + }; + } + + private static string? ExtractSerString(ReadOnlySpan bytes) + { + if (bytes.Length == 0 || bytes[0] == 0xFF) + { + return null; + } + + int length; + int bytesRead; + if ((bytes[0] & 0x80) == 0) + { + length = bytes[0]; + bytesRead = 1; + } + else if ((bytes[0] & 0xC0) == 0x80) + { + if (bytes.Length < 2) + { + return null; + } + + length = ((bytes[0] & 0x3F) << 8) | bytes[1]; + bytesRead = 2; + } + else + { + if (bytes.Length < 4) + { + return null; + } + + length = ((bytes[0] & 0x1F) << 24) | + (bytes[1] << 16) | + (bytes[2] << 8) | + bytes[3]; + bytesRead = 4; + } + + return bytes.Length < bytesRead + length + ? null + : Encoding.UTF8.GetString(bytes.Slice(bytesRead, length)); + } + + GrammarResult ICILVisitor.VisitFieldInit(CILParser.FieldInitContext context) + => VisitFieldInit(context); + + public static GrammarResult.Literal VisitFieldInit( + CILParser.FieldInitContext context) + => new(context.Value); + + GrammarResult ICILVisitor.VisitFieldOrProp(CILParser.FieldOrPropContext context) + => VisitFieldOrProp(context); + + public static GrammarResult.Literal VisitFieldOrProp( + CILParser.FieldOrPropContext context) + => new((CustomAttributeNamedArgumentKind)context.Value); + + GrammarResult ICILVisitor.VisitFieldSerInit( + CILParser.FieldSerInitContext context) + => VisitFieldSerInit(context); + + public static GrammarResult.FormattedBlob VisitFieldSerInit( + CILParser.FieldSerInitContext context) + => new(context.Value ?? new BlobBuilder()); + + GrammarResult ICILVisitor.VisitInitOpt(CILParser.InitOptContext context) + => VisitInitOpt(context); + + public static GrammarResult.Literal VisitInitOpt(CILParser.InitOptContext context) + => new(context.Value); + + GrammarResult ICILVisitor.VisitSerializType( + CILParser.SerializTypeContext context) + => VisitSerializType(context); + + public GrammarResult.FormattedBlob VisitSerializType( + CILParser.SerializTypeContext context) + => new(MaterializeSerializationType(GetSerializationTypeValue(context.Value))); + + GrammarResult ICILVisitor.VisitSerializTypeElement( + CILParser.SerializTypeElementContext context) + => VisitSerializTypeElement(context); + + public GrammarResult.FormattedBlob VisitSerializTypeElement( + CILParser.SerializTypeElementContext context) + => new(MaterializeSerializationType(GetSerializationTypeValue(context.Value))); + + GrammarResult ICILVisitor.VisitSerInit(CILParser.SerInitContext context) + => VisitSerInit(context); + + public GrammarResult.FormattedBlob VisitSerInit(CILParser.SerInitContext context) + => new(MaterializeSerializedInitializer(GetSerializedInitializerValue(context.Value))); +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Values.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Values.cs new file mode 100644 index 00000000000000..2fa2a399783539 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Values.cs @@ -0,0 +1,132 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Immutable; +using System.Reflection.Metadata; +using Antlr4.Runtime; + +namespace ILAssembler; + +internal sealed partial class GrammarActions +{ + private sealed record CustomAttributeDescriptorValue( + MethodReferenceValue Constructor, + CustomAttributeBlobValue Value, + OwnerTypeValue? Owner); + + private sealed record CustomAttributeTypedefValue(string Alias); + + private abstract record CustomAttributeBlobValue; + + private sealed record RawCustomAttributeBlobValue(BlobBuilder Value) + : CustomAttributeBlobValue; + + private sealed record StructuredCustomAttributeBlobValue( + ImmutableArray Arguments, + ImmutableArray NamedArguments) + : CustomAttributeBlobValue; + + private sealed record CustomAttributeNamedArgumentValue( + byte Kind, + SerializationTypeValue Type, + string Name, + SerializedInitializerValue Value); + + private abstract record SerializationTypeValue; + + private sealed record RawSerializationTypeValue(BlobBuilder Value) + : SerializationTypeValue; + + private sealed record SimpleSerializationTypeValue(SerializationTypeCode Type) + : SerializationTypeValue; + + private sealed record ArraySerializationTypeValue(SerializationTypeValue ElementType) + : SerializationTypeValue; + + private sealed record StringEnumSerializationTypeValue(string Name) + : SerializationTypeValue; + + private sealed record ClassEnumSerializationTypeValue(ClassNameValue ClassName) + : SerializationTypeValue; + + private sealed record TypedefSerializationTypeValue(IToken Token, string Alias) + : SerializationTypeValue; + + private abstract record SerializedInitializerValue(SerializationTypeValue Type); + + private sealed record RawSerializedInitializerValue( + SerializationTypeValue Type, + BlobBuilder Value) + : SerializedInitializerValue(Type); + + private sealed record ClassNameSerializedInitializerValue(ClassNameValue ClassName) + : SerializedInitializerValue(new SimpleSerializationTypeValue(SerializationTypeCode.Type)); + + private sealed record ObjectSerializedInitializerValue(SerializedInitializerValue Value) + : SerializedInitializerValue( + new SimpleSerializationTypeValue(SerializationTypeCode.TaggedObject)); + + private sealed record InvalidByteArraySerializedInitializerValue(IToken Token) + : SerializedInitializerValue( + new SimpleSerializationTypeValue(SerializationTypeCode.String)); + + private sealed record ArraySerializedInitializerValue( + SerializationTypeValue Type, + int Length, + SerializedSequenceValue Values) + : SerializedInitializerValue(Type); + + private abstract record SerializedSequenceValue; + + private sealed record RawSerializedSequenceValue(BlobBuilder Value) + : SerializedSequenceValue; + + private sealed record ClassSerializedSequenceValue( + ImmutableArray Values) + : SerializedSequenceValue; + + private sealed record ObjectSerializedSequenceValue( + ImmutableArray Values) + : SerializedSequenceValue; + + private abstract record ClassSequenceElementValue; + + private sealed record StringClassSequenceElementValue(string? Value) + : ClassSequenceElementValue; + + private sealed record TypeClassSequenceElementValue(ClassNameValue ClassName) + : ClassSequenceElementValue; + + private static CustomAttributeDescriptorValue GetCustomAttributeDescriptorValue(object? value) + => value as CustomAttributeDescriptorValue + ?? new( + MethodReferenceValue.Error, + new RawCustomAttributeBlobValue(CreateDefaultCustomAttributeBlob()), + null); + + private static SerializedInitializerValue GetSerializedInitializerValue(object? value) + => value as SerializedInitializerValue + ?? new RawSerializedInitializerValue( + new RawSerializationTypeValue(new BlobBuilder()), + new BlobBuilder()); + + private static SerializationTypeValue GetSerializationTypeValue(object? value) + => value as SerializationTypeValue + ?? new RawSerializationTypeValue(new BlobBuilder()); + + private static SerializedSequenceValue GetSerializedSequenceValue(object? value) + => value switch + { + SerializedSequenceValue sequence => sequence, + BlobBuilder blob => new RawSerializedSequenceValue(blob), + _ => new RawSerializedSequenceValue(new BlobBuilder()) + }; + + private static BlobBuilder CreateDefaultCustomAttributeBlob() + { + BlobBuilder value = new(); + value.WriteUInt16(CustomAttributeBlobFormatVersion); + value.WriteUInt16(0); + return value; + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.cs deleted file mode 100644 index e8a7a5f74ffca4..00000000000000 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.cs +++ /dev/null @@ -1,730 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System; -using System.Buffers.Binary; -using System.Collections.Generic; -using System.Collections.Immutable; -using System.Diagnostics; -using System.Globalization; -using System.IO; -using System.Linq; -using System.Reflection; -using System.Reflection.Metadata; -using System.Reflection.Metadata.Ecma335; -using System.Reflection.PortableExecutable; -using System.Runtime.InteropServices; -using System.Security.Cryptography; -using System.Text; -using Antlr4.Runtime; -using Antlr4.Runtime.Misc; -using Antlr4.Runtime.Tree; - -namespace ILAssembler -{ -#pragma warning disable CA1822 // Mark members as static - internal sealed partial class GrammarActions : ICILVisitor - { - GrammarResult ICILVisitor.VisitBoolSeq(CILParser.BoolSeqContext context) => VisitBoolSeq(context); - public static GrammarResult.FormattedBlob VisitBoolSeq(CILParser.BoolSeqContext context) - { - var builder = ImmutableArray.CreateBuilder(); - - foreach (var item in context.truefalse()) - { - builder.AddRange(VisitTruefalse(item).Value); - } - - return new(builder.ToImmutable().SerializeSequence()); - } - - GrammarResult ICILVisitor.VisitCaValue(CILParser.CaValueContext context) => VisitCaValue(context); - public GrammarResult.FormattedBlob VisitCaValue(CILParser.CaValueContext context) - { - BlobBuilder blob = new(); - if (context.truefalse() is CILParser.TruefalseContext truefalse) - { - blob.WriteByte((byte)SerializationTypeCode.Boolean); - blob.WriteBoolean(VisitTruefalse(truefalse).Value); - } - else if (context.compQstring() is CILParser.CompQstringContext str) - { - blob.WriteUTF8(VisitCompQstring(str).Value); - blob.WriteByte(0); - } - else if (context.className() is CILParser.ClassNameContext className) - { - var name = VisitClassName(className).Value; - blob.WriteByte((byte)SerializationTypeCode.Enum); - blob.WriteUTF8((name as EntityRegistry.IHasReflectionNotation)?.ReflectionNotation ?? ""); - blob.WriteByte(0); - byte size = 4; - if (context.INT8() is not null) - { - size = 1; - } - else if (context.INT16() is not null) - { - size = 2; - } - blob.WriteByte(size); - blob.WriteInt32(VisitInt32(context.int32()).Value); - } - else - { - blob.WriteByte((byte)SerializationTypeCode.Int32); - blob.WriteInt32(VisitInt32(context.int32()).Value); - } - return new(blob); - } - - GrammarResult ICILVisitor.VisitCustomAttrDecl(CILParser.CustomAttrDeclContext context) => VisitCustomAttrDecl(context); - public GrammarResult.Literal VisitCustomAttrDecl(CILParser.CustomAttrDeclContext context) - { - if (context.dottedName() is { } dottedName) - { - // This is a typedef reference for a custom attribute - string alias = VisitDottedName(dottedName).Value; - var resolved = TryResolveTypedefAsCustomAttribute(alias); - if (resolved is not null) - { - var typedefAttribute = _entityRegistry.CreateCustomAttribute(resolved.Value.Constructor, resolved.Value.Value); - typedefAttribute.Location = Location.From(context.Start, _documents); - return new(typedefAttribute); - } - // Typedef not found - could report diagnostic here - return new(null); - } - if (context.customDescrWithOwner() is {} descrWithOwner) - { - // Visit the custom attribute descriptor to record it, - // but don't return it as it will already have its owner recorded. - _ = VisitCustomDescrWithOwner(descrWithOwner); - return new(null); - } - if (context.customDescr() is {} descr) - { -#nullable disable // Disable nullability to work around lack of variance. - return VisitCustomDescr(descr); -#nullable restore - } - throw new UnreachableException(); - } - - GrammarResult ICILVisitor.VisitCustomDescrInMethodBody(CILParser.CustomDescrInMethodBodyContext context) => VisitCustomDescrInMethodBody(context); - public GrammarResult.Literal VisitCustomDescrInMethodBody(CILParser.CustomDescrInMethodBodyContext context) - { - if (context.customDescrWithOwner() is {} descrWithOwner) - { - // Visit the custom attribute descriptor to record it, - // but don't return it as it will already have its owner recorded. - _ = VisitCustomDescrWithOwner(descrWithOwner); - return new(null); - } - if (context.customDescr() is {} descr) - { -#nullable disable // Disable nullability to work around lack of variance. - return VisitCustomDescr(descr); -#nullable restore - } - throw new UnreachableException(); - } - - GrammarResult ICILVisitor.VisitCustomBlobArgs(CILParser.CustomBlobArgsContext context) => VisitCustomBlobArgs(context); - public GrammarResult.FormattedBlob VisitCustomBlobArgs(CILParser.CustomBlobArgsContext context) - { - BlobBuilder blob = new(); - foreach (var item in context.serInit()) - { - VisitSerInit(item).Value.WriteContentTo(blob); - } - return new(blob); - } - - GrammarResult ICILVisitor.VisitCustomBlobDescr(CILParser.CustomBlobDescrContext context) => VisitCustomBlobDescr(context); - public GrammarResult.FormattedBlob VisitCustomBlobDescr(CILParser.CustomBlobDescrContext context) - { - var blob = new BlobBuilder(); - // Custom attribute blob prolog is a 2-byte unsigned integer (ECMA-335 II.23.3) - blob.WriteUInt16(CustomAttributeBlobFormatVersion); - VisitCustomBlobArgs(context.customBlobArgs()).Value.WriteContentTo(blob); - VisitCustomBlobNVPairs(context.customBlobNVPairs()).Value.WriteContentTo(blob); - return new(blob); - } - - GrammarResult ICILVisitor.VisitCustomBlobNVPairs(CILParser.CustomBlobNVPairsContext context) => VisitCustomBlobNVPairs(context); - public GrammarResult.FormattedBlob VisitCustomBlobNVPairs(CILParser.CustomBlobNVPairsContext context) - { - var blob = new BlobBuilder(); - var fieldOrProps = context.fieldOrProp(); - var types = context.serializType(); - var names = context.dottedName(); - var values = context.serInit(); - - blob.WriteInt16((short)fieldOrProps.Length); - - for (int i = 0; i < fieldOrProps.Length; i++) - { - var fieldOrProp = fieldOrProps[i].GetText() == "field" ? CustomAttributeNamedArgumentKind.Field : CustomAttributeNamedArgumentKind.Property; - var type = VisitSerializType(types[i]).Value; - var name = VisitDottedName(names[i]).Value; - var value = VisitSerInit(values[i]).Value; - blob.WriteByte((byte)fieldOrProp); - type.WriteContentTo(blob); - blob.WriteSerializedString(name); - value.WriteContentTo(blob); - } - return new(blob); - } - - GrammarResult ICILVisitor.VisitCustomDescr(CILParser.CustomDescrContext context) => VisitCustomDescr(context); - public GrammarResult.Literal VisitCustomDescr(CILParser.CustomDescrContext context) - { - var ctor = VisitCustomType(context.customType()).Value; - BlobBuilder value; - if (context.customBlobDescr() is {} customBlobDescr) - { - value = VisitCustomBlobDescr(customBlobDescr).Value; - } - else if (context.bytes() is {} bytes) - { - value = new(); - value.WriteBytes(VisitBytes(bytes)); - } - else if (context.compQstring() is {} str) - { - value = new(); - value.WriteUTF8(VisitCompQstring(str).Value); - // COMPAT: We treat this string as a string-reprensentation of a blob, - // so we don't emit the null terminator. - } - else - { - value = new(); - value.WriteUInt16(CustomAttributeBlobFormatVersion); - value.WriteUInt16(0); - } - - var attribute = _entityRegistry.CreateCustomAttribute(ctor, value); - attribute.Location = Location.From(context.Start, _documents); - return new(attribute); - } - - GrammarResult ICILVisitor.VisitCustomDescrWithOwner(CILParser.CustomDescrWithOwnerContext context) => VisitCustomDescrWithOwner(context); - - public GrammarResult.Literal VisitCustomDescrWithOwner(CILParser.CustomDescrWithOwnerContext context) - { - var ctor = VisitCustomType(context.customType()).Value; - BlobBuilder value; - if (context.customBlobDescr() is {} customBlobDescr) - { - value = VisitCustomBlobDescr(customBlobDescr).Value; - } - else if (context.bytes() is {} bytes) - { - value = new(); - value.WriteBytes(VisitBytes(bytes)); - } - else if (context.compQstring() is {} str) - { - value = new(); - value.WriteUTF8(VisitCompQstring(str).Value); - // COMPAT: We treat this string as a string-reprensentation of a blob, - // so we don't emit the null terminator. - } - else - { - value = new(); - value.WriteUInt16(CustomAttributeBlobFormatVersion); - value.WriteUInt16(0); - } - - var attr = _entityRegistry.CreateCustomAttribute(ctor, value); - - attr.Location = Location.From(context.Start, _documents); - attr.Owner = VisitOwnerType(context.ownerType()).Value; - - return new(attr); - } - - GrammarResult ICILVisitor.VisitCustomType(CILParser.CustomTypeContext context) => VisitCustomType(context); - public GrammarResult.Literal VisitCustomType(CILParser.CustomTypeContext context) => VisitMethodRef(context.methodRef()); - - GrammarResult ICILVisitor.VisitF32seq(CILParser.F32seqContext context) => VisitF32seq(context); - public GrammarResult.FormattedBlob VisitF32seq(CILParser.F32seqContext context) - { - var builder = ImmutableArray.CreateBuilder(context.ChildCount); - - foreach (var item in context.children ?? []) - { - builder.Add((float)(item switch - { - CILParser.Int32Context int32 => VisitInt32(int32).Value, - CILParser.Float64Context float64 => VisitFloat64(float64).Value, - _ => throw new UnreachableException() - })); - } - return new(builder.ToImmutable().SerializeSequence()); - } - GrammarResult ICILVisitor.VisitF64seq(CILParser.F64seqContext context) => VisitF64seq(context); - public GrammarResult.FormattedBlob VisitF64seq(CILParser.F64seqContext context) - { - var builder = ImmutableArray.CreateBuilder(context.ChildCount); - - foreach (var item in context.children ?? []) - { - builder.Add((double)(item switch - { - CILParser.Int64Context int64 => VisitInt64(int64).Value, - CILParser.Float64Context float64 => VisitFloat64(float64).Value, - _ => throw new UnreachableException() - })); - } - return new(builder.ToImmutable().SerializeSequence()); - } - - private static object? ExtractConstantFromSerInit(BlobBuilder blob) - { - var bytes = blob.ToImmutableArray(); - if (bytes.Length == 0) - { - return null; - } - - var typeCode = (SerializationTypeCode)bytes[0]; - var valueBytes = bytes.AsSpan().Slice(1); - - return typeCode switch - { - SerializationTypeCode.Boolean => valueBytes.Length >= 1 && valueBytes[0] != 0, - SerializationTypeCode.Char => valueBytes.Length >= 2 ? BitConverter.ToChar(valueBytes) : '\0', - SerializationTypeCode.SByte => valueBytes.Length >= 1 ? (sbyte)valueBytes[0] : (sbyte)0, - SerializationTypeCode.Byte => valueBytes.Length >= 1 ? valueBytes[0] : (byte)0, - SerializationTypeCode.Int16 => valueBytes.Length >= 2 ? BitConverter.ToInt16(valueBytes) : (short)0, - SerializationTypeCode.UInt16 => valueBytes.Length >= 2 ? BitConverter.ToUInt16(valueBytes) : (ushort)0, - SerializationTypeCode.Int32 => valueBytes.Length >= 4 ? BitConverter.ToInt32(valueBytes) : 0, - SerializationTypeCode.UInt32 => valueBytes.Length >= 4 ? BitConverter.ToUInt32(valueBytes) : 0u, - SerializationTypeCode.Int64 => valueBytes.Length >= 8 ? BitConverter.ToInt64(valueBytes) : 0L, - SerializationTypeCode.UInt64 => valueBytes.Length >= 8 ? BitConverter.ToUInt64(valueBytes) : 0uL, - SerializationTypeCode.Single => valueBytes.Length >= 4 ? BitConverter.ToSingle(valueBytes) : 0f, - SerializationTypeCode.Double => valueBytes.Length >= 8 ? BitConverter.ToDouble(valueBytes) : 0d, - SerializationTypeCode.String => Encoding.Unicode.GetString(valueBytes), - // Type is encoded as a SerString (compressed length followed by UTF-8 type name) - SerializationTypeCode.Type => ExtractSerString(valueBytes), - // SZArray: element type followed by element count followed by elements - // Return the raw bytes for arrays since we can't easily represent them - SerializationTypeCode.SZArray => valueBytes.ToArray(), - // TaggedObject: type tag followed by value - return raw bytes - SerializationTypeCode.TaggedObject => valueBytes.ToArray(), - // Enum: type name (SerString) followed by underlying value - return raw bytes - SerializationTypeCode.Enum => valueBytes.ToArray(), - // For unknown/future type codes, return the raw bytes to preserve the data - _ => bytes.AsSpan().ToArray() - }; - } - - /// - /// Extracts a SerString (compressed length + UTF-8 string) from the given bytes. - /// Returns null if the first byte is 0xFF (null string marker). - /// - private static string? ExtractSerString(ReadOnlySpan bytes) - { - if (bytes.Length == 0) - { - return null; - } - // 0xFF indicates null string - if (bytes[0] == 0xFF) - { - return null; - } - // Decode compressed length - int length; - int bytesRead; - if ((bytes[0] & 0x80) == 0) - { - // 1-byte length - length = bytes[0]; - bytesRead = 1; - } - else if ((bytes[0] & 0xC0) == 0x80) - { - // 2-byte length - if (bytes.Length < 2) return null; - length = ((bytes[0] & 0x3F) << 8) | bytes[1]; - bytesRead = 2; - } - else - { - // 4-byte length - if (bytes.Length < 4) return null; - length = ((bytes[0] & 0x1F) << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]; - bytesRead = 4; - } - if (bytes.Length < bytesRead + length) - { - return null; - } - return Encoding.UTF8.GetString(bytes.Slice(bytesRead, length)); - } - - GrammarResult ICILVisitor.VisitFieldSerInit(CILParser.FieldSerInitContext context) => VisitFieldSerInit(context); - public GrammarResult.FormattedBlob VisitFieldSerInit(CILParser.FieldSerInitContext context) - { - // The max length for the majority of the blobs is 9 bytes. 1 for the type of blob, 8 for the max 64-bit value. - // Byte arrays can be larger, so we handle that case separately. - const int CommonMaxBlobLength = 9; - BlobBuilder builder; - var bytesNode = context.bytes(); - if (bytesNode is not null) - { - ImmutableArray bytesResult = VisitBytes(bytesNode); - // Our blob length is the number of bytes in the byte array + the code for the byte array. - builder = new BlobBuilder(bytesResult.Length + 1); - builder.WriteByte((byte)SerializationTypeCode.String); - builder.WriteBytes(bytesResult); - return new(builder); - } - builder = new BlobBuilder(CommonMaxBlobLength); - - int tokenType = ((ITerminalNode)context.GetChild(0)).Symbol.Type; - - builder.WriteByte((byte)GetTypeCodeForToken(tokenType)); - - switch (tokenType) - { - case CILParser.BOOL: - builder.WriteBoolean(VisitTruefalse(context.truefalse()).Value); - break; - case CILParser.INT8: - case CILParser.UINT8: - builder.WriteByte((byte)VisitInt32(context.int32()).Value); - break; - case CILParser.CHAR: - case CILParser.INT16: - case CILParser.UINT16: - builder.WriteInt16((short)VisitInt32(context.int32()).Value); - break; - case CILParser.INT32_: - case CILParser.UINT32: - builder.WriteInt32(VisitInt32(context.int32()).Value); - break; - case CILParser.INT64_: - case CILParser.UINT64: - builder.WriteInt64(VisitInt64(context.int64()).Value); - break; - case CILParser.FLOAT32: - { - if (context.float64() is CILParser.Float64Context float64) - { - string text = float64.GetText(); - if (!text.Contains('.') && - text.IndexOf('e') < 0 && - text.IndexOf('E') < 0 && - ParseIntegerValue(text.AsSpan(), out long rawValue)) - { - builder.WriteSingle(BitConverter.Int32BitsToSingle((int)rawValue)); - } - else - { - builder.WriteSingle((float)VisitFloat64(float64).Value); - } - } - if (context.int32() is CILParser.Int32Context int32) - { - int value = VisitInt32(int32).Value; - builder.WriteSingle(BitConverter.Int32BitsToSingle(value)); - } - break; - } - case CILParser.FLOAT64_: - { - if (context.float64() is CILParser.Float64Context float64) - { - string text = float64.GetText(); - if (!text.Contains('.') && - text.IndexOf('e') < 0 && - text.IndexOf('E') < 0 && - ParseIntegerValue(text.AsSpan(), out long rawValue)) - { - builder.WriteDouble(BitConverter.Int64BitsToDouble(rawValue)); - } - else - { - builder.WriteDouble(VisitFloat64(float64).Value); - } - } - if (context.int64() is CILParser.Int64Context int64) - { - long value = VisitInt64(int64).Value; - builder.WriteDouble(BitConverter.Int64BitsToDouble(value)); - } - break; - } - } - - return new(builder); - } - GrammarResult ICILVisitor.VisitI16seq(CILParser.I16seqContext context) => VisitI16seq(context); - public GrammarResult.FormattedBlob VisitI16seq(CILParser.I16seqContext context) - { - var values = context.int32(); - var builder = ImmutableArray.CreateBuilder(values.Length); - foreach (var value in values) - { - builder.Add((short)VisitInt32(value).Value); - } - return new(builder.MoveToImmutable().SerializeSequence()); - } - GrammarResult ICILVisitor.VisitI32seq(CILParser.I32seqContext context) => VisitI32seq(context); - public GrammarResult.FormattedBlob VisitI32seq(CILParser.I32seqContext context) - { - var values = context.int32(); - var builder = ImmutableArray.CreateBuilder(values.Length); - foreach (var value in values) - { - builder.Add(VisitInt32(value).Value); - } - return new(builder.MoveToImmutable().SerializeSequence()); - } - - GrammarResult ICILVisitor.VisitI8seq(CILParser.I8seqContext context) => VisitI8seq(context); - public GrammarResult.FormattedBlob VisitI8seq(CILParser.I8seqContext context) - { - var values = context.int32(); - var builder = ImmutableArray.CreateBuilder(values.Length); - foreach (var value in values) - { - builder.Add((byte)VisitInt32(value).Value); - } - return new(builder.MoveToImmutable().SerializeSequence()); - } - - GrammarResult ICILVisitor.VisitI64seq(CILParser.I64seqContext context) => VisitI64seq(context); - public GrammarResult.FormattedBlob VisitI64seq(CILParser.I64seqContext context) - { - var values = context.int64(); - var builder = ImmutableArray.CreateBuilder(values.Length); - foreach (var value in values) - { - builder.Add(VisitInt64(value).Value); - } - return new(builder.MoveToImmutable().SerializeSequence()); - } - - GrammarResult ICILVisitor.VisitNameValPair(CILParser.NameValPairContext context) => VisitNameValPair(context); - public GrammarResult.Literal> VisitNameValPair(CILParser.NameValPairContext context) - { - return new(new(VisitCompQstring(context.compQstring()).Value, VisitCaValue(context.caValue()).Value)); - } - - GrammarResult ICILVisitor.VisitNameValPairs(CILParser.NameValPairsContext context) => VisitNameValPairs(context); - public GrammarResult.Sequence> VisitNameValPairs(CILParser.NameValPairsContext context) => new(context.nameValPair().Select(pair => VisitNameValPair(pair).Value).ToImmutableArray()); - - GrammarResult ICILVisitor.VisitObjSeq(CILParser.ObjSeqContext context) => VisitObjSeq(context); - public GrammarResult.FormattedBlob VisitObjSeq(CILParser.ObjSeqContext context) - { - BlobBuilder objSeqBlob = new(); - foreach (var item in context.serInit()) - { - // Each element in object[] is encoded as FieldOrPropType + value, - // where FieldOrPropType is the concrete type (bool, int32, string, etc.), - // NOT TaggedObject (0x51). The object(...) wrapper is used to explicitly - // box a value but does not change the element's concrete type in the encoding. - // Unwrap any object(...) wrappers to get the actual typed inner element. - CILParser.SerInitContext actualItem = item; - while (actualItem.serInit() is { } inner) - { - actualItem = inner; - } - WriteCustomAttributeFieldOrPropType(objSeqBlob, actualItem); - objSeqBlob.LinkSuffix(VisitSerInit(actualItem).Value); - } - return new(objSeqBlob); - } - - GrammarResult ICILVisitor.VisitOwnerType(CILParser.OwnerTypeContext context) => VisitOwnerType(context); - - public GrammarResult.Literal VisitOwnerType(CILParser.OwnerTypeContext context) - => new(MaterializeOwnerType(GetOwnerTypeValue(context.Value))); - - GrammarResult ICILVisitor.VisitSerializType(CILParser.SerializTypeContext context) => VisitSerializType(context); - public GrammarResult.FormattedBlob VisitSerializType(CILParser.SerializTypeContext context) - { - var blob = new BlobBuilder(); - if (context.ARRAY_TYPE_NO_BOUNDS() is not null) - { - blob.WriteByte((byte)SerializationTypeCode.SZArray); - } - VisitSerializTypeElement(context.serializTypeElement()).Value.WriteContentTo(blob); - return new(blob); - } - - GrammarResult ICILVisitor.VisitSerializTypeElement(CILParser.SerializTypeElementContext context) => VisitSerializTypeElement(context); - public GrammarResult.FormattedBlob VisitSerializTypeElement(CILParser.SerializTypeElementContext context) - { - if (context.simpleType() is CILParser.SimpleTypeContext simpleType) - { - BlobBuilder blob = new(1); - blob.WriteByte((byte)VisitSimpleType(simpleType).Value); - return new(blob); - } - if (context.dottedName() is CILParser.DottedNameContext dottedName) - { - // Serialization type typedefs are not yet fully supported - string alias = VisitDottedName(dottedName).Value; - ReportError(DiagnosticIds.TypedefNotFound, string.Format(DiagnosticMessageTemplates.TypedefNotFound, alias), context); - return new(new BlobBuilder(1)); - } - if (context.TYPE() is not null) - { - BlobBuilder blob = new BlobBuilder(1); - blob.WriteByte((byte)SerializationTypeCode.Type); - return new(blob); - } - if (context.OBJECT() is not null) - { - BlobBuilder blob = new BlobBuilder(1); - blob.WriteByte((byte)SerializationTypeCode.TaggedObject); - return new(blob); - } - if (context.ENUM() is not null) - { - BlobBuilder blob = new BlobBuilder(); - blob.WriteByte((byte)SerializationTypeCode.Enum); - if (context.SQSTRING() is ITerminalNode sqString) - { - blob.WriteSerializedString(StringHelpers.ParseQuotedString(sqString.GetText())); - } - else - { - Debug.Assert(context.className() is not null); - blob.WriteSerializedString((VisitClassName(context.className()).Value as EntityRegistry.IHasReflectionNotation)?.ReflectionNotation ?? ""); - } - return new(blob); - } - throw new UnreachableException(); - } - - GrammarResult ICILVisitor.VisitSerInit(CILParser.SerInitContext context) => VisitSerInit(context); - public GrammarResult.FormattedBlob VisitSerInit(CILParser.SerInitContext context) - { - if (context.fieldSerInit() is CILParser.FieldSerInitContext fieldSerInit) - { - if (fieldSerInit.bytes() is not null) - { - ReportError( - DiagnosticIds.InvalidMetadataToken, - "bytearray is not a valid structured custom attribute value", - context); - var invalidValue = new BlobBuilder(); - invalidValue.WriteSerializedString(null); - return new(invalidValue); - } - - ImmutableArray encodedValue = VisitFieldSerInit(fieldSerInit).Value.ToImmutableArray(); - var value = new BlobBuilder(Math.Max(0, encodedValue.Length - 1)); - if (encodedValue.Length > 1) - { - value.WriteBytes(encodedValue.AsSpan().Slice(1).ToArray()); - } - return new(value); - } - - if (context.serInit() is CILParser.SerInitContext serInit) - { - Debug.Assert(context.OBJECT() is not null); - BlobBuilder taggedObjectBlob = new(); - WriteCustomAttributeFieldOrPropType(taggedObjectBlob, serInit); - taggedObjectBlob.LinkSuffix(VisitSerInit(serInit).Value); - return new(taggedObjectBlob); - } - - if (context.int32() is not CILParser.Int32Context arrLength) - { - BlobBuilder blob = new(); - if (context.className() is CILParser.ClassNameContext className) - { - blob.WriteSerializedString(VisitClassName(className).Value is EntityRegistry.IHasReflectionNotation reflection ? reflection.ReflectionNotation : string.Empty); - } - else - { - blob.WriteSerializedString( - context.SQSTRING() is { } stringNode - ? StringHelpers.ParseQuotedString(stringNode.Symbol.Text) - : null); - } - return new(blob); - } - - BlobBuilder arrayHeader = new(sizeof(int)); - arrayHeader.WriteInt32(VisitInt32(arrLength).Value); - var sequenceResult = (GrammarResult.FormattedBlob)Visit(context.GetRuleContext(1)); - arrayHeader.LinkSuffix(sequenceResult.Value); - return new(arrayHeader); - } - - private static void WriteCustomAttributeFieldOrPropType( - BlobBuilder builder, - CILParser.SerInitContext context) - { - int tokenType = context.fieldSerInit() is { } fieldSerInit - ? ((ITerminalNode)fieldSerInit.GetChild(0)).Symbol.Type - : ((ITerminalNode)context.GetChild(0)).Symbol.Type; - if (context.fieldSerInit()?.bytes() is not null) - { - builder.WriteByte((byte)SerializationTypeCode.String); - return; - } - if (context.int32() is not null) - { - builder.WriteByte((byte)SerializationTypeCode.SZArray); - } - - builder.WriteByte((byte)GetTypeCodeForToken(tokenType)); - } - - private static SerializationTypeCode GetTypeCodeForToken(int tokenType) - { - return tokenType switch - { - CILParser.INT8 => SerializationTypeCode.SByte, - CILParser.UINT8 => SerializationTypeCode.Byte, - CILParser.INT16 => SerializationTypeCode.Int16, - CILParser.UINT16 => SerializationTypeCode.UInt16, - CILParser.INT32_ => SerializationTypeCode.Int32, - CILParser.UINT32 => SerializationTypeCode.UInt32, - CILParser.INT64_ => SerializationTypeCode.Int64, - CILParser.UINT64 => SerializationTypeCode.UInt64, - CILParser.FLOAT32 => SerializationTypeCode.Single, - CILParser.FLOAT64_ => SerializationTypeCode.Double, - CILParser.CHAR => SerializationTypeCode.Char, - CILParser.BOOL => SerializationTypeCode.Boolean, - CILParser.STRING => SerializationTypeCode.String, - CILParser.TYPE => SerializationTypeCode.Type, - CILParser.OBJECT => SerializationTypeCode.TaggedObject, - _ => throw new UnreachableException() - }; - } - - GrammarResult ICILVisitor.VisitSqstringSeq(CILParser.SqstringSeqContext context) => VisitSqstringSeq(context); - - public static GrammarResult.FormattedBlob VisitSqstringSeq(CILParser.SqstringSeqContext context) - { - var strings = ImmutableArray.CreateBuilder(context.ChildCount); - foreach (var child in context.children ?? []) - { - string? str = null; - - if (child is ITerminalNode { Symbol: { Type: CILParser.SQSTRING, Text: string stringValue } }) - { - str = StringHelpers.ParseQuotedString(stringValue); - } - - strings.Add(str); - } - return new(strings.MoveToImmutable().SerializeSequence()); - } - - } -} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs index e215c4a7ff62db..7bd640eeaafa50 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs @@ -314,10 +314,10 @@ public static GrammarResult.Literal VisitSlashedName(CILParser.Slashed GrammarResult ICILVisitor.VisitTruefalse(CILParser.TruefalseContext context) => VisitTruefalse(context); + internal bool ParseBoolean(IToken token) => bool.Parse(token.Text); + public static GrammarResult.Literal VisitTruefalse(CILParser.TruefalseContext context) - { - return new(bool.Parse(context.GetText())); - } + => new(context.Value); } } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Fields.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Fields.cs index d7dc5d33c93379..eb70ed5b12e11a 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Fields.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Fields.cs @@ -194,22 +194,6 @@ internal string GetFieldDataName(IToken token) internal string GetFieldDataOffset(IToken token) => ParseInt32(token).ToString(CultureInfo.InvariantCulture); - internal void BeginFieldInitializer(CILParser.InitOptContext context) - { - BeginSemanticRoot(context); - context.Value = NoConstantSentinel.Instance; - } - - internal void SetFieldInitializer( - CILParser.InitOptContext context, - CILParser.FieldInitContext initializer) - { - context.Value = VisitFieldInit(initializer).Value; - } - - internal bool EndFieldInitializer(CILParser.InitOptContext context) - => EndSemanticRoot(context); - internal void SetFieldOffset(CILParser.RepeatOptContext context, IToken token) { context.Value = ParseInt32(token); @@ -236,30 +220,6 @@ public static GrammarResult.Flag VisitFieldAttr( GrammarResult ICILVisitor.VisitFieldDecl(CILParser.FieldDeclContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - GrammarResult ICILVisitor.VisitFieldInit(CILParser.FieldInitContext context) - => VisitFieldInit(context); - - public GrammarResult.Literal VisitFieldInit(CILParser.FieldInitContext context) - { - if (context.NULLREF() is not null) - { - return new(null); - } - if (context.compQstring() is { } composedString) - { - return new(VisitCompQstring(composedString).Value); - } - if (context.fieldSerInit() is { } serializedInitializer) - { - return new(ExtractConstantFromSerInit(VisitFieldSerInit(serializedInitializer).Value)); - } - - return new(null); - } - - GrammarResult ICILVisitor.VisitFieldOrProp(CILParser.FieldOrPropContext context) - => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - GrammarResult ICILVisitor.VisitFieldRef(CILParser.FieldRefContext context) => VisitFieldRef(context); @@ -267,12 +227,6 @@ GrammarResult ICILVisitor.VisitFieldRef(CILParser.FieldRefContext CILParser.FieldRefContext context) => new(MaterializeFieldReference(GetFieldReferenceValue(context.Value))); - GrammarResult ICILVisitor.VisitInitOpt(CILParser.InitOptContext context) - => VisitInitOpt(context); - - public static GrammarResult.Literal VisitInitOpt(CILParser.InitOptContext context) - => new(context.Value); - GrammarResult ICILVisitor.VisitMemberRef(CILParser.MemberRefContext context) => VisitMemberRef(context); diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs index d3d1af7f621adf..8d41f4fee1714f 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs @@ -48,6 +48,44 @@ public static GrammarResult.Literal VisitSecAction(CI _ => throw new UnreachableException() }; } + + GrammarResult ICILVisitor.VisitCaValue(CILParser.CaValueContext context) => VisitCaValue(context); + public GrammarResult.FormattedBlob VisitCaValue(CILParser.CaValueContext context) + { + BlobBuilder blob = new(); + if (context.truefalse() is CILParser.TruefalseContext truefalse) + { + blob.WriteByte((byte)SerializationTypeCode.Boolean); + blob.WriteBoolean(VisitTruefalse(truefalse).Value); + } + else if (context.compQstring() is CILParser.CompQstringContext str) + { + blob.WriteUTF8(VisitCompQstring(str).Value); + blob.WriteByte(0); + } + else if (context.className() is CILParser.ClassNameContext className) + { + EntityRegistry.TypeEntity name = VisitClassName(className).Value; + blob.WriteByte((byte)SerializationTypeCode.Enum); + blob.WriteUTF8( + (name as EntityRegistry.IHasReflectionNotation)?.ReflectionNotation ?? string.Empty); + blob.WriteByte(0); + byte size = context.INT8() is not null + ? (byte)1 + : context.INT16() is not null + ? (byte)2 + : (byte)4; + blob.WriteByte(size); + blob.WriteInt32(VisitInt32(context.int32()).Value); + } + else + { + blob.WriteByte((byte)SerializationTypeCode.Int32); + blob.WriteInt32(VisitInt32(context.int32()).Value); + } + + return new(blob); + } GrammarResult ICILVisitor.VisitSecAttrBlob(CILParser.SecAttrBlobContext context) => VisitSecAttrBlob(context); public GrammarResult.FormattedBlob VisitSecAttrBlob(CILParser.SecAttrBlobContext context) { @@ -118,5 +156,19 @@ public GrammarResult.FormattedBlob VisitSecAttrSetBlob(CILParser.SecAttrSetBlobC return new(_entityRegistry.CreateDeclarativeSecurityAttribute(action, value)); } + GrammarResult ICILVisitor.VisitNameValPair(CILParser.NameValPairContext context) => VisitNameValPair(context); + public GrammarResult.Literal> VisitNameValPair(CILParser.NameValPairContext context) + { + return new(new( + VisitCompQstring(context.compQstring()).Value, + VisitCaValue(context.caValue()).Value)); + } + + GrammarResult ICILVisitor.VisitNameValPairs(CILParser.NameValPairsContext context) => VisitNameValPairs(context); + public GrammarResult.Sequence> VisitNameValPairs(CILParser.NameValPairsContext context) + => new(context.nameValPair() + .Select(pair => VisitNameValPair(pair).Value) + .ToImmutableArray()); + } } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs index cbe38e20787201..0d0abc664a955d 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs @@ -98,40 +98,5 @@ private void ClearPendingCustomAttributeOwners() public GrammarResult.Literal VisitClassName(CILParser.ClassNameContext context) => new(ResolveClassName(GetClassNameValue(context.Value))); - GrammarResult ICILVisitor.VisitClassSeq(CILParser.ClassSeqContext context) => VisitClassSeq(context); - public GrammarResult.FormattedBlob VisitClassSeq(CILParser.ClassSeqContext context) - { - BlobBuilder objSeqBlob = new(0); - foreach (var item in context.classSeqElement()) - { - objSeqBlob.LinkSuffix(VisitClassSeqElement(item).Value); - } - return new(objSeqBlob); - } - - GrammarResult ICILVisitor.VisitClassSeqElement(CILParser.ClassSeqElementContext context) => VisitClassSeqElement(context); - - public GrammarResult.FormattedBlob VisitClassSeqElement(CILParser.ClassSeqElementContext context) - { - BlobBuilder blob = new(); - if (context.className() is CILParser.ClassNameContext className) - { - if (VisitClassName(className).Value is EntityRegistry.IHasReflectionNotation notation) - { - blob.WriteSerializedString(notation.ReflectionNotation); - } - else - { - blob.WriteSerializedString(""); - } - return new(blob); - } - - blob.WriteSerializedString( - context.SQSTRING() is { } stringNode - ? StringHelpers.ParseQuotedString(stringNode.Symbol.Text) - : null); - return new(blob); - } #pragma warning restore CA1822 // Mark members as static } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs index e4a45ba3338b8f..2619aadd87f419 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs @@ -53,6 +53,9 @@ _currentMethod is null && _namespaceHeaderFrames.Count == 0 && _classHeaderFrames.Count == 0 && _interfaceListFrames.Count == 0 + && _customBlobArgumentFrames.Count == 0 + && _customBlobNamedArgumentFrames.Count == 0 + && _serializationSequenceFrames.Count == 0 && _pendingClassMethodOverrides.Count == 0, "Per-document semantic state must be released by the owning rule's finally block."); @@ -85,6 +88,9 @@ _currentMethod is null _namespaceHeaderFrames.Clear(); _classHeaderFrames.Clear(); _interfaceListFrames.Clear(); + _customBlobArgumentFrames.Clear(); + _customBlobNamedArgumentFrames.Clear(); + _serializationSequenceFrames.Clear(); _pendingClassMethodOverrides.Clear(); _syntaxErrorCount = 0; } diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 index d8989ec00b5413..98eefb2aec44c3 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 @@ -573,25 +573,34 @@ typedefDecl returns [bool HasSyntaxError] finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} /* Custom attribute declarations */ -customDescr returns [bool HasSyntaxError] -@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +customDescr returns [object Value, bool HasSyntaxError] +@init {Actions.BeginSemanticRoot(_localctx);} : - '.custom' customType - | '.custom' customType '=' compQstring - | '.custom' customType '=' '{' customBlobDescr '}' - | '.custom' customType '=' '(' bytes ')'; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} + '.custom' constructor = customType + {_localctx.Value = Actions.CreateDefaultCustomAttribute($constructor.Value);} + | '.custom' constructor = customType '=' stringValue = compQstring + {_localctx.Value = Actions.CreateStringCustomAttribute($constructor.Value, $stringValue.Value);} + | '.custom' constructor = customType '=' '{' structuredValue = customBlobDescr '}' + {_localctx.Value = Actions.CreateStructuredCustomAttribute($constructor.Value, $structuredValue.Value);} + | '.custom' constructor = customType '=' '(' rawValue = bytes ')' + {_localctx.Value = Actions.CreateRawCustomAttribute($constructor.Value, $rawValue.Value);}; +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} -customDescrWithOwner returns [bool HasSyntaxError] -@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +customDescrWithOwner returns [object Value, bool HasSyntaxError] +@init {Actions.BeginSemanticRoot(_localctx);} : - '.custom' '(' ownerType ')' customType - | '.custom' '(' ownerType ')' customType '=' compQstring - | '.custom' '(' ownerType ')' customType '=' '{' customBlobDescr '}' - | '.custom' '(' ownerType ')' customType '=' '(' bytes ')'; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} + '.custom' '(' owner = ownerType ')' constructor = customType + {_localctx.Value = Actions.CreateDefaultOwnedCustomAttribute($owner.Value, $constructor.Value);} + | '.custom' '(' owner = ownerType ')' constructor = customType '=' stringValue = compQstring + {_localctx.Value = Actions.CreateStringOwnedCustomAttribute($owner.Value, $constructor.Value, $stringValue.Value);} + | '.custom' '(' owner = ownerType ')' constructor = customType '=' '{' structuredValue = customBlobDescr '}' + {_localctx.Value = Actions.CreateStructuredOwnedCustomAttribute($owner.Value, $constructor.Value, $structuredValue.Value);} + | '.custom' '(' owner = ownerType ')' constructor = customType '=' '(' rawValue = bytes ')' + {_localctx.Value = Actions.CreateRawOwnedCustomAttribute($owner.Value, $constructor.Value, $rawValue.Value);}; +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} -customType: methodRef; +customType returns [object Value]: + constructor = methodRef {_localctx.Value = Actions.CreateCustomAttributeType($constructor.Value);}; ownerType returns [object Value, bool HasSyntaxError] @@ -603,26 +612,47 @@ returns [object Value, bool HasSyntaxError] finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} /* Verbal description of custom attribute initialization blob */ -customBlobDescr: customBlobArgs customBlobNVPairs; +customBlobDescr returns [object Value]: + arguments = customBlobArgs namedArguments = customBlobNVPairs + {_localctx.Value = Actions.CreateCustomAttributeBlob($arguments.Value, $namedArguments.Value);}; -customBlobArgs: (serInit | compControl)*; +customBlobArgs returns [object Value] +@init {Actions.BeginCustomBlobArguments(_localctx);} +: + (argument = serInit {Actions.AddCustomBlobArgument(_localctx, $argument.Value);} | compControl)* +; +finally {_localctx.Value = Actions.EndCustomBlobArguments(_localctx);} -customBlobNVPairs: ( - fieldOrProp serializType dottedName '=' serInit +customBlobNVPairs returns [object Value] +@init {Actions.BeginCustomBlobNamedArguments(_localctx);} +: + ( + kind = fieldOrProp argumentType = serializType name = dottedName '=' value = serInit + {Actions.AddCustomBlobNamedArgument( + _localctx, + $kind.Value, + $argumentType.Value, + $name.Value, + $value.Value);} | compControl - )*; + )* +; +finally {_localctx.Value = Actions.EndCustomBlobNamedArguments(_localctx);} -fieldOrProp: 'field' | 'property'; +fieldOrProp returns [byte Value]: + kind = ('field' | 'property') {_localctx.Value = Actions.GetCustomAttributeNamedArgumentKind($kind);}; -serializType: serializTypeElement (ARRAY_TYPE_NO_BOUNDS)?; +serializType returns [object Value]: + element = serializTypeElement array = ARRAY_TYPE_NO_BOUNDS? + {_localctx.Value = Actions.CreateSerializationType($element.Value, $array);}; -serializTypeElement: - simpleType - | dottedName /* typedef */ - | TYPE - | OBJECT - | ENUM 'class' SQSTRING - | ENUM className; +serializTypeElement returns [object Value]: + primitive = simpleType {_localctx.Value = Actions.CreatePrimitiveSerializationType($primitive.Value);} + | alias = dottedName {_localctx.Value = Actions.CreateSerializationTypeTypedef(_localctx, $alias.Value);} /* typedef */ + | simpleTypeToken = TYPE {_localctx.Value = Actions.CreateSimpleSerializationType($simpleTypeToken);} + | simpleTypeToken = OBJECT {_localctx.Value = Actions.CreateSimpleSerializationType($simpleTypeToken);} + | ENUM 'class' quotedName = SQSTRING {_localctx.Value = Actions.CreateEnumSerializationType($quotedName);} + | ENUM classNameValue = className {_localctx.Value = Actions.CreateEnumSerializationType($classNameValue.Value);}; /* Module declaration */ moduleHead returns [string Value, bool HasName, bool IsExternal]: @@ -1141,7 +1171,11 @@ nameValPairs: (nameValPair ',')* nameValPair; nameValPair: compQstring '=' caValue; -truefalse: 'true' | 'false'; +truefalse returns [bool Value] +@after {_localctx.Value = Actions.ParseBoolean(_localctx.Start);} +: + 'true' + | 'false'; caValue: truefalse @@ -1397,12 +1431,12 @@ atOpt returns [string Value]: | 'at' offset = int32 {_localctx.Value = Actions.GetFieldDataOffset($offset.start);}; initOpt returns [object Value, bool HasSyntaxError] -@init {BeginSubtree(); Actions.BeginFieldInitializer(_localctx);} +@init {Actions.BeginFieldInitializer(_localctx);} : /* EMPTY */ - | '=' initializer = fieldInit {Actions.SetFieldInitializer(_localctx, $initializer.ctx);} + | '=' initializer = fieldInit {Actions.SetFieldInitializer(_localctx, $initializer.Value);} ; -finally {_localctx.HasSyntaxError = Actions.EndFieldInitializer(_localctx); EndParseTreeMode();} +finally {_localctx.HasSyntaxError = Actions.EndFieldInitializer(_localctx);} repeatOpt returns [int Value, bool HasValue]: /* EMPTY */ @@ -1683,12 +1717,12 @@ finally {Actions.EndParameterDirective(_localctx);} labelDecl: name = id ':' {Actions.DefineLabel($name.start);}; -customDescrInMethodBody returns [bool HasSyntaxError] -@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +customDescrInMethodBody returns [object Value, bool HasSyntaxError] +@init {Actions.BeginSemanticRoot(_localctx);} : - customDescr - | customDescrWithOwner; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} + directAttribute = customDescr {_localctx.Value = Actions.CreateCustomAttributeDeclaration($directAttribute.Value);} + | ownedAttribute = customDescrWithOwner {_localctx.Value = Actions.CreateCustomAttributeDeclaration($ownedAttribute.Value);}; +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} scopeBlock @init {Actions.BeginScope(_localctx);} @@ -1790,22 +1824,38 @@ ddItem: | INT8 ddItemCount; /* Default values declaration for fields, parameters and verbal form of CA blob description */ -fieldSerInit: - FLOAT32 '(' float64 ')' - | FLOAT64_ '(' float64 ')' - | FLOAT32 '(' int32 ')' - | FLOAT64_ '(' int64 ')' - | INT64_ '(' int64 ')' - | INT32_ '(' int32 ')' - | INT16 '(' int32 ')' - | INT8 '(' int32 ')' - | UINT64 '(' int64 ')' - | UINT32 '(' int32 ')' - | UINT16 '(' int32 ')' - | UINT8 '(' int32 ')' - | CHAR '(' int32 ')' - | BOOL '(' truefalse ')' - | 'bytearray' '(' bytes ')'; +fieldSerInit returns [System.Reflection.Metadata.BlobBuilder Value]: + FLOAT32 '(' float32Value = float64 ')' + {_localctx.Value = Actions.CreateFloat32SerializedInitializer($float32Value.ctx, $float32Value.Value);} + | FLOAT64_ '(' float64Value = float64 ')' + {_localctx.Value = Actions.CreateFloat64SerializedInitializer($float64Value.ctx, $float64Value.Value);} + | FLOAT32 '(' float32Bits = int32 ')' + {_localctx.Value = Actions.CreateFloat32BitsSerializedInitializer($float32Bits.start);} + | FLOAT64_ '(' float64Bits = int64 ')' + {_localctx.Value = Actions.CreateFloat64BitsSerializedInitializer($float64Bits.start);} + | int64Type = INT64_ '(' int64Value = int64 ')' + {_localctx.Value = Actions.CreateIntegerSerializedInitializer($int64Type, $int64Value.start);} + | int32Type = INT32_ '(' int32Value = int32 ')' + {_localctx.Value = Actions.CreateIntegerSerializedInitializer($int32Type, $int32Value.start);} + | int16Type = INT16 '(' int16Value = int32 ')' + {_localctx.Value = Actions.CreateIntegerSerializedInitializer($int16Type, $int16Value.start);} + | int8Type = INT8 '(' int8Value = int32 ')' + {_localctx.Value = Actions.CreateIntegerSerializedInitializer($int8Type, $int8Value.start);} + | uint64Type = UINT64 '(' uint64Value = int64 ')' + {_localctx.Value = Actions.CreateIntegerSerializedInitializer($uint64Type, $uint64Value.start);} + | uint32Type = UINT32 '(' uint32Value = int32 ')' + {_localctx.Value = Actions.CreateIntegerSerializedInitializer($uint32Type, $uint32Value.start);} + | uint16Type = UINT16 '(' uint16Value = int32 ')' + {_localctx.Value = Actions.CreateIntegerSerializedInitializer($uint16Type, $uint16Value.start);} + | uint8Type = UINT8 '(' uint8Value = int32 ')' + {_localctx.Value = Actions.CreateIntegerSerializedInitializer($uint8Type, $uint8Value.start);} + | charType = CHAR '(' charValue = int32 ')' + {_localctx.Value = Actions.CreateIntegerSerializedInitializer($charType, $charValue.start);} + | boolType = BOOL '(' boolValue = truefalse ')' + {_localctx.Value = Actions.CreateBooleanSerializedInitializer($boolType, $boolValue.Value);} + | 'bytearray' '(' byteArrayValue = bytes ')' + {_localctx.Value = Actions.CreateByteArraySerializedInitializer($byteArrayValue.Value);}; +finally {_localctx.Value ??= new System.Reflection.Metadata.BlobBuilder();} bytes returns [System.Collections.Immutable.ImmutableArray Value] @@ -1824,62 +1874,137 @@ returns [byte Value] | HEXBYTE ; /* Field/parameter initialization */ -fieldInit: fieldSerInit | compQstring | NULLREF; +fieldInit returns [object Value]: + serializedValue = fieldSerInit {_localctx.Value = Actions.CreateFieldInitializer($serializedValue.Value);} + | stringValue = compQstring {_localctx.Value = Actions.CreateFieldInitializer($stringValue.Value);} + | NULLREF {_localctx.Value = Actions.CreateNullFieldInitializer();}; /* Values for verbal form of CA blob description */ -serInit: - fieldSerInit - | STRING '(' NULLREF ')' - | STRING '(' SQSTRING ')' - | TYPE '(' 'class' SQSTRING ')' - | TYPE '(' className ')' - | TYPE '(' NULLREF ')' - | OBJECT '(' serInit ')' - | FLOAT32 '[' int32 ']' '(' f32seq ')' - | FLOAT64_ '[' int32 ']' '(' f64seq ')' - | INT64_ '[' int32 ']' '(' i64seq ')' - | INT32_ '[' int32 ']' '(' i32seq ')' - | INT16 '[' int32 ']' '(' i16seq ')' - | INT8 '[' int32 ']' '(' i8seq ')' - | UINT64 '[' int32 ']' '(' i64seq ')' - | UINT32 '[' int32 ']' '(' i32seq ')' - | UINT16 '[' int32 ']' '(' i16seq ')' - | UINT8 '[' int32 ']' '(' i8seq ')' - | CHAR '[' int32 ']' '(' i16seq ')' - | BOOL '[' int32 ']' '(' boolSeq ')' - | STRING '[' int32 ']' '(' sqstringSeq ')' - | TYPE '[' int32 ']' '(' classSeq ')' - | OBJECT '[' int32 ']' '(' objSeq ')'; - -f32seq: (float64 | int32)*; +serInit returns [object Value]: + scalarValue = fieldSerInit + {_localctx.Value = Actions.CreateScalarSerializedValue(_localctx, $scalarValue.ctx, $scalarValue.Value);} + | STRING '(' NULLREF ')' {_localctx.Value = Actions.CreateStringSerializedValue();} + | STRING '(' stringToken = SQSTRING ')' {_localctx.Value = Actions.CreateStringSerializedValue($stringToken);} + | TYPE '(' 'class' typeToken = SQSTRING ')' {_localctx.Value = Actions.CreateTypeSerializedValue($typeToken);} + | TYPE '(' typeName = className ')' {_localctx.Value = Actions.CreateTypeSerializedValue($typeName.Value);} + | TYPE '(' NULLREF ')' {_localctx.Value = Actions.CreateNullTypeSerializedValue();} + | OBJECT '(' objectValue = serInit ')' {_localctx.Value = Actions.CreateObjectSerializedValue($objectValue.Value);} + | f32ElementToken = FLOAT32 '[' f32Length = int32 ']' '(' f32Values = f32seq ')' + {_localctx.Value = Actions.CreateArraySerializedValue($f32ElementToken, $f32Length.start, $f32Values.Value);} + | f64ElementToken = FLOAT64_ '[' f64Length = int32 ']' '(' f64Values = f64seq ')' + {_localctx.Value = Actions.CreateArraySerializedValue($f64ElementToken, $f64Length.start, $f64Values.Value);} + | i64ElementToken = INT64_ '[' i64Length = int32 ']' '(' i64Values = i64seq ')' + {_localctx.Value = Actions.CreateArraySerializedValue($i64ElementToken, $i64Length.start, $i64Values.Value);} + | i32ElementToken = INT32_ '[' i32Length = int32 ']' '(' i32Values = i32seq ')' + {_localctx.Value = Actions.CreateArraySerializedValue($i32ElementToken, $i32Length.start, $i32Values.Value);} + | i16ElementToken = INT16 '[' i16Length = int32 ']' '(' i16Values = i16seq ')' + {_localctx.Value = Actions.CreateArraySerializedValue($i16ElementToken, $i16Length.start, $i16Values.Value);} + | i8ElementToken = INT8 '[' i8Length = int32 ']' '(' i8Values = i8seq ')' + {_localctx.Value = Actions.CreateArraySerializedValue($i8ElementToken, $i8Length.start, $i8Values.Value);} + | u64ElementToken = UINT64 '[' u64Length = int32 ']' '(' u64Values = i64seq ')' + {_localctx.Value = Actions.CreateArraySerializedValue($u64ElementToken, $u64Length.start, $u64Values.Value);} + | u32ElementToken = UINT32 '[' u32Length = int32 ']' '(' u32Values = i32seq ')' + {_localctx.Value = Actions.CreateArraySerializedValue($u32ElementToken, $u32Length.start, $u32Values.Value);} + | u16ElementToken = UINT16 '[' u16Length = int32 ']' '(' u16Values = i16seq ')' + {_localctx.Value = Actions.CreateArraySerializedValue($u16ElementToken, $u16Length.start, $u16Values.Value);} + | u8ElementToken = UINT8 '[' u8Length = int32 ']' '(' u8Values = i8seq ')' + {_localctx.Value = Actions.CreateArraySerializedValue($u8ElementToken, $u8Length.start, $u8Values.Value);} + | charElementToken = CHAR '[' charLength = int32 ']' '(' charValues = i16seq ')' + {_localctx.Value = Actions.CreateArraySerializedValue($charElementToken, $charLength.start, $charValues.Value);} + | boolElementToken = BOOL '[' boolLength = int32 ']' '(' boolValues = boolSeq ')' + {_localctx.Value = Actions.CreateArraySerializedValue($boolElementToken, $boolLength.start, $boolValues.Value);} + | stringElementToken = STRING '[' stringLength = int32 ']' '(' stringValues = sqstringSeq ')' + {_localctx.Value = Actions.CreateArraySerializedValue($stringElementToken, $stringLength.start, $stringValues.Value);} + | typeElementToken = TYPE '[' typeLength = int32 ']' '(' typeValues = classSeq ')' + {_localctx.Value = Actions.CreateArraySerializedValue($typeElementToken, $typeLength.start, $typeValues.Value);} + | objectElementToken = OBJECT '[' objectLength = int32 ']' '(' objectValues = objSeq ')' + {_localctx.Value = Actions.CreateArraySerializedValue($objectElementToken, $objectLength.start, $objectValues.Value);}; + +f32seq returns [System.Reflection.Metadata.BlobBuilder Value] +@init {Actions.BeginSerializationSequence(_localctx);} +: + (floatingValue = float64 {Actions.AddFloat32SequenceValue(_localctx, $floatingValue.Value);} + | integerValue = int32 {Actions.AddFloat32SequenceValue(_localctx, $integerValue.start);})* +; +finally {_localctx.Value = Actions.EndSerializationSequence(_localctx);} -f64seq: (float64 | int64)*; +f64seq returns [System.Reflection.Metadata.BlobBuilder Value] +@init {Actions.BeginSerializationSequence(_localctx);} +: + (floatingValue = float64 {Actions.AddFloat64SequenceValue(_localctx, $floatingValue.Value);} + | integerValue = int64 {Actions.AddFloat64SequenceValue(_localctx, $integerValue.start);})* +; +finally {_localctx.Value = Actions.EndSerializationSequence(_localctx);} -i64seq: int64*; +i64seq returns [System.Reflection.Metadata.BlobBuilder Value] +@init {Actions.BeginSerializationSequence(_localctx);} +: + (value = int64 {Actions.AddInt64SequenceValue(_localctx, $value.start);})* +; +finally {_localctx.Value = Actions.EndSerializationSequence(_localctx);} -i32seq: int32*; +i32seq returns [System.Reflection.Metadata.BlobBuilder Value] +@init {Actions.BeginSerializationSequence(_localctx);} +: + (value = int32 {Actions.AddInt32SequenceValue(_localctx, $value.start);})* +; +finally {_localctx.Value = Actions.EndSerializationSequence(_localctx);} -i16seq: int32*; +i16seq returns [System.Reflection.Metadata.BlobBuilder Value] +@init {Actions.BeginSerializationSequence(_localctx);} +: + (value = int32 {Actions.AddInt16SequenceValue(_localctx, $value.start);})* +; +finally {_localctx.Value = Actions.EndSerializationSequence(_localctx);} -i8seq: int32*; +i8seq returns [System.Reflection.Metadata.BlobBuilder Value] +@init {Actions.BeginSerializationSequence(_localctx);} +: + (value = int32 {Actions.AddInt8SequenceValue(_localctx, $value.start);})* +; +finally {_localctx.Value = Actions.EndSerializationSequence(_localctx);} -boolSeq: truefalse*; +boolSeq returns [System.Reflection.Metadata.BlobBuilder Value] +@init {Actions.BeginSerializationSequence(_localctx);} +: + (value = truefalse {Actions.AddBooleanSequenceValue(_localctx, $value.Value);})* +; +finally {_localctx.Value = Actions.EndSerializationSequence(_localctx);} -sqstringSeq: (NULLREF | SQSTRING)*; +sqstringSeq returns [System.Reflection.Metadata.BlobBuilder Value] +@init {Actions.BeginSerializationSequence(_localctx);} +: + (nullValue = NULLREF {Actions.AddStringSequenceValue(_localctx, $nullValue);} + | stringValue = SQSTRING {Actions.AddStringSequenceValue(_localctx, $stringValue);})* +; +finally {_localctx.Value = Actions.EndSerializationSequence(_localctx);} -classSeq: classSeqElement*; +classSeq returns [object Value] +@init {Actions.BeginSerializationSequence(_localctx);} +: + (value = classSeqElement {Actions.AddClassSequenceValue(_localctx, $value.Value);})* +; +finally {_localctx.Value = Actions.EndClassSerializationSequence(_localctx);} -classSeqElement: NULLREF | 'class' SQSTRING | className; +classSeqElement returns [object Value]: + NULLREF {_localctx.Value = Actions.CreateNullClassSequenceValue();} + | 'class' quotedValue = SQSTRING {_localctx.Value = Actions.CreateQuotedClassSequenceValue($quotedValue);} + | typeValue = className {_localctx.Value = Actions.CreateClassSequenceValue($typeValue.Value);}; -objSeq: serInit*; +objSeq returns [object Value] +@init {Actions.BeginSerializationSequence(_localctx);} +: + (value = serInit {Actions.AddObjectSequenceValue(_localctx, $value.Value);})* +; +finally {_localctx.Value = Actions.EndObjectSerializationSequence(_localctx);} -customAttrDecl returns [bool HasSyntaxError] -@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +customAttrDecl returns [object Value, bool HasSyntaxError] +@init {Actions.BeginSemanticRoot(_localctx);} : - customDescr - | customDescrWithOwner - | dottedName /* typedef */; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} + directAttribute = customDescr {_localctx.Value = Actions.CreateCustomAttributeDeclaration($directAttribute.Value);} + | ownedAttribute = customDescrWithOwner {_localctx.Value = Actions.CreateCustomAttributeDeclaration($ownedAttribute.Value);} + | alias = dottedName {_localctx.Value = Actions.CreateCustomAttributeTypedef($alias.Value);}; +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} /* Assembly References */ asmOrRefDecl: diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.interp b/src/tools/ilasm/src/ILAssembler/gen/CIL.interp index bf523e40c36a7e..aaa9b19bb6ccd6 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.interp +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.interp @@ -800,4 +800,4 @@ manifestResDecl atn: -[4, 1, 305, 3557, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 373, 8, 1, 10, 1, 12, 1, 376, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 383, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 5, 3, 390, 8, 3, 10, 3, 12, 3, 393, 9, 3, 1, 3, 1, 3, 1, 3, 1, 4, 5, 4, 399, 8, 4, 10, 4, 12, 4, 402, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 490, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 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, 536, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 5, 15, 545, 8, 15, 10, 15, 12, 15, 548, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 577, 8, 18, 1, 19, 1, 19, 3, 19, 581, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 599, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 626, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 649, 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, 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, 685, 8, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 695, 8, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 5, 27, 702, 8, 27, 10, 27, 12, 27, 705, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 714, 8, 28, 10, 28, 12, 28, 717, 9, 28, 1, 29, 1, 29, 1, 30, 1, 30, 3, 30, 723, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 734, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 747, 8, 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, 34, 1, 34, 1, 34, 1, 34, 5, 34, 768, 8, 34, 10, 34, 12, 34, 771, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 5, 37, 787, 8, 37, 10, 37, 12, 37, 790, 9, 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, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 862, 8, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 869, 8, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 876, 8, 40, 1, 41, 5, 41, 879, 8, 41, 10, 41, 12, 41, 882, 9, 41, 1, 42, 1, 42, 1, 42, 1, 42, 5, 42, 888, 8, 42, 10, 42, 12, 42, 891, 9, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 1001, 8, 44, 1, 45, 1, 45, 5, 45, 1005, 8, 45, 10, 45, 12, 45, 1008, 9, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 1021, 8, 45, 10, 45, 12, 45, 1024, 9, 45, 1, 45, 1, 45, 1, 45, 3, 45, 1029, 8, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 1035, 8, 47, 1, 48, 1, 48, 1, 49, 5, 49, 1040, 8, 49, 10, 49, 12, 49, 1043, 9, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 1070, 8, 50, 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, 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, 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, 1148, 8, 51, 3, 51, 1150, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1164, 8, 53, 1, 53, 1, 53, 5, 53, 1168, 8, 53, 10, 53, 12, 53, 1171, 9, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1179, 8, 53, 3, 53, 1181, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1188, 8, 54, 10, 54, 12, 54, 1191, 9, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1202, 8, 55, 10, 55, 12, 55, 1205, 9, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 5, 56, 1216, 8, 56, 10, 56, 12, 56, 1219, 9, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1226, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 1234, 8, 57, 1, 57, 1, 57, 3, 57, 1238, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1277, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 1283, 8, 59, 10, 59, 12, 59, 1286, 9, 59, 1, 59, 1, 59, 1, 59, 1, 60, 5, 60, 1292, 8, 60, 10, 60, 12, 60, 1295, 9, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1302, 8, 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, 3, 62, 1321, 8, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 5, 63, 1329, 8, 63, 10, 63, 12, 63, 1332, 9, 63, 3, 63, 1334, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 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, 1358, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1505, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1515, 8, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 5, 67, 1522, 8, 67, 10, 67, 12, 67, 1525, 9, 67, 3, 67, 1527, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1609, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 5, 69, 1616, 8, 69, 10, 69, 12, 69, 1619, 9, 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, 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, 1650, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1710, 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, 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, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1750, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1766, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1776, 8, 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, 3, 76, 1803, 8, 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, 1827, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 5, 77, 1833, 8, 77, 10, 77, 12, 77, 1836, 9, 77, 1, 77, 3, 77, 1839, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1854, 8, 78, 1, 79, 1, 79, 1, 79, 5, 79, 1859, 8, 79, 10, 79, 12, 79, 1862, 9, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1906, 8, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1916, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1934, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1952, 8, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1971, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1992, 8, 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, 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 2011, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 2026, 8, 89, 1, 90, 1, 90, 1, 90, 1, 90, 5, 90, 2032, 8, 90, 10, 90, 12, 90, 2035, 9, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 2046, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 2066, 8, 92, 1, 93, 1, 93, 1, 93, 5, 93, 2071, 8, 93, 10, 93, 12, 93, 2074, 9, 93, 1, 94, 1, 94, 3, 94, 2078, 8, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 5, 95, 2087, 8, 95, 10, 95, 12, 95, 2090, 9, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 3, 97, 2101, 8, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2209, 8, 99, 10, 99, 12, 99, 2212, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2221, 8, 99, 10, 99, 12, 99, 2224, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2237, 8, 99, 10, 99, 12, 99, 2240, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2251, 8, 99, 10, 99, 12, 99, 2254, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 2262, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 2275, 8, 100, 10, 100, 12, 100, 2278, 9, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 2320, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 2331, 8, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 3, 103, 2338, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 2346, 8, 104, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2352, 8, 105, 10, 105, 12, 105, 2355, 9, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2365, 8, 105, 10, 105, 12, 105, 2368, 9, 105, 1, 105, 1, 105, 1, 105, 3, 105, 2373, 8, 105, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 2379, 8, 106, 1, 107, 5, 107, 2382, 8, 107, 10, 107, 12, 107, 2385, 9, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 2413, 8, 108, 1, 109, 1, 109, 1, 109, 1, 109, 5, 109, 2419, 8, 109, 10, 109, 12, 109, 2422, 9, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 2435, 8, 110, 1, 111, 5, 111, 2438, 8, 111, 10, 111, 12, 111, 2441, 9, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 2465, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 2474, 8, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 4, 114, 2483, 8, 114, 11, 114, 12, 114, 2484, 1, 114, 1, 114, 3, 114, 2489, 8, 114, 1, 115, 1, 115, 1, 115, 5, 115, 2494, 8, 115, 10, 115, 12, 115, 2497, 9, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 2516, 8, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2525, 8, 117, 10, 117, 12, 117, 2528, 9, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2540, 8, 117, 10, 117, 12, 117, 2543, 9, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2589, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2599, 8, 119, 3, 119, 2601, 8, 119, 1, 119, 1, 119, 1, 119, 5, 119, 2606, 8, 119, 10, 119, 12, 119, 2609, 9, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2614, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2658, 8, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 2667, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2707, 8, 122, 1, 123, 5, 123, 2710, 8, 123, 10, 123, 12, 123, 2713, 9, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2752, 8, 124, 1, 125, 1, 125, 3, 125, 2756, 8, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, 2766, 8, 126, 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, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 2788, 8, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2798, 8, 129, 10, 129, 12, 129, 2801, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2809, 8, 129, 10, 129, 12, 129, 2812, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2824, 8, 129, 10, 129, 12, 129, 2827, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2837, 8, 129, 10, 129, 12, 129, 2840, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2850, 8, 129, 10, 129, 12, 129, 2853, 9, 129, 3, 129, 2855, 8, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 3, 131, 2863, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 4, 134, 2875, 8, 134, 11, 134, 12, 134, 2876, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 3, 135, 2895, 8, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 3, 136, 2913, 8, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 2927, 8, 137, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 2951, 8, 141, 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 2963, 8, 143, 1, 144, 1, 144, 1, 144, 3, 144, 2968, 8, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 4, 145, 2975, 8, 145, 11, 145, 12, 145, 2976, 3, 145, 2979, 8, 145, 1, 146, 1, 146, 1, 146, 5, 146, 2984, 8, 146, 10, 146, 12, 146, 2987, 9, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 2996, 8, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 3, 148, 3064, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 3141, 8, 149, 1, 150, 1, 150, 1, 150, 5, 150, 3146, 8, 150, 10, 150, 12, 150, 3149, 9, 150, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 3, 152, 3156, 8, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 3, 153, 3306, 8, 153, 1, 154, 1, 154, 5, 154, 3310, 8, 154, 10, 154, 12, 154, 3313, 9, 154, 1, 155, 1, 155, 5, 155, 3317, 8, 155, 10, 155, 12, 155, 3320, 9, 155, 1, 156, 5, 156, 3323, 8, 156, 10, 156, 12, 156, 3326, 9, 156, 1, 157, 5, 157, 3329, 8, 157, 10, 157, 12, 157, 3332, 9, 157, 1, 158, 5, 158, 3335, 8, 158, 10, 158, 12, 158, 3338, 9, 158, 1, 159, 5, 159, 3341, 8, 159, 10, 159, 12, 159, 3344, 9, 159, 1, 160, 5, 160, 3347, 8, 160, 10, 160, 12, 160, 3350, 9, 160, 1, 161, 5, 161, 3353, 8, 161, 10, 161, 12, 161, 3356, 9, 161, 1, 162, 5, 162, 3359, 8, 162, 10, 162, 12, 162, 3362, 9, 162, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 3368, 8, 163, 1, 164, 5, 164, 3371, 8, 164, 10, 164, 12, 164, 3374, 9, 164, 1, 165, 1, 165, 1, 165, 3, 165, 3379, 8, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 3, 166, 3406, 8, 166, 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, 168, 3, 168, 3425, 8, 168, 1, 169, 5, 169, 3428, 8, 169, 10, 169, 12, 169, 3431, 9, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 3447, 8, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 5, 172, 3457, 8, 172, 10, 172, 12, 172, 3460, 9, 172, 1, 172, 1, 172, 1, 173, 1, 173, 5, 173, 3466, 8, 173, 10, 173, 12, 173, 3469, 9, 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, 3, 174, 3488, 8, 174, 1, 175, 5, 175, 3491, 8, 175, 10, 175, 12, 175, 3494, 9, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 3, 176, 3509, 8, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 178, 1, 178, 5, 178, 3518, 8, 178, 10, 178, 12, 178, 3521, 9, 178, 1, 178, 1, 178, 1, 178, 5, 178, 3526, 8, 178, 10, 178, 12, 178, 3529, 9, 178, 1, 178, 1, 178, 1, 178, 1, 178, 3, 178, 3535, 8, 178, 1, 179, 1, 179, 1, 180, 5, 180, 3540, 8, 180, 10, 180, 12, 180, 3543, 9, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 3, 181, 3555, 8, 181, 1, 181, 0, 1, 68, 182, 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, 0, 14, 6, 0, 1, 15, 199, 199, 243, 243, 247, 247, 264, 264, 289, 289, 5, 0, 16, 16, 199, 199, 243, 243, 264, 264, 288, 289, 1, 0, 263, 264, 1, 0, 173, 174, 1, 0, 37, 38, 1, 0, 73, 74, 3, 0, 2, 2, 61, 61, 77, 83, 2, 0, 229, 229, 260, 261, 1, 0, 95, 96, 1, 0, 97, 111, 2, 0, 173, 173, 289, 290, 2, 0, 179, 179, 264, 264, 1, 0, 167, 168, 1, 0, 51, 52, 4018, 0, 364, 1, 0, 0, 0, 2, 382, 1, 0, 0, 0, 4, 384, 1, 0, 0, 0, 6, 391, 1, 0, 0, 0, 8, 400, 1, 0, 0, 0, 10, 489, 1, 0, 0, 0, 12, 491, 1, 0, 0, 0, 14, 495, 1, 0, 0, 0, 16, 499, 1, 0, 0, 0, 18, 504, 1, 0, 0, 0, 20, 508, 1, 0, 0, 0, 22, 512, 1, 0, 0, 0, 24, 519, 1, 0, 0, 0, 26, 535, 1, 0, 0, 0, 28, 537, 1, 0, 0, 0, 30, 539, 1, 0, 0, 0, 32, 551, 1, 0, 0, 0, 34, 553, 1, 0, 0, 0, 36, 576, 1, 0, 0, 0, 38, 580, 1, 0, 0, 0, 40, 598, 1, 0, 0, 0, 42, 625, 1, 0, 0, 0, 44, 648, 1, 0, 0, 0, 46, 684, 1, 0, 0, 0, 48, 686, 1, 0, 0, 0, 50, 694, 1, 0, 0, 0, 52, 696, 1, 0, 0, 0, 54, 703, 1, 0, 0, 0, 56, 715, 1, 0, 0, 0, 58, 718, 1, 0, 0, 0, 60, 720, 1, 0, 0, 0, 62, 733, 1, 0, 0, 0, 64, 746, 1, 0, 0, 0, 66, 748, 1, 0, 0, 0, 68, 756, 1, 0, 0, 0, 70, 772, 1, 0, 0, 0, 72, 778, 1, 0, 0, 0, 74, 782, 1, 0, 0, 0, 76, 861, 1, 0, 0, 0, 78, 868, 1, 0, 0, 0, 80, 875, 1, 0, 0, 0, 82, 880, 1, 0, 0, 0, 84, 889, 1, 0, 0, 0, 86, 895, 1, 0, 0, 0, 88, 1000, 1, 0, 0, 0, 90, 1028, 1, 0, 0, 0, 92, 1030, 1, 0, 0, 0, 94, 1034, 1, 0, 0, 0, 96, 1036, 1, 0, 0, 0, 98, 1041, 1, 0, 0, 0, 100, 1069, 1, 0, 0, 0, 102, 1149, 1, 0, 0, 0, 104, 1151, 1, 0, 0, 0, 106, 1180, 1, 0, 0, 0, 108, 1182, 1, 0, 0, 0, 110, 1196, 1, 0, 0, 0, 112, 1225, 1, 0, 0, 0, 114, 1237, 1, 0, 0, 0, 116, 1276, 1, 0, 0, 0, 118, 1284, 1, 0, 0, 0, 120, 1293, 1, 0, 0, 0, 122, 1301, 1, 0, 0, 0, 124, 1320, 1, 0, 0, 0, 126, 1333, 1, 0, 0, 0, 128, 1357, 1, 0, 0, 0, 130, 1504, 1, 0, 0, 0, 132, 1514, 1, 0, 0, 0, 134, 1526, 1, 0, 0, 0, 136, 1608, 1, 0, 0, 0, 138, 1610, 1, 0, 0, 0, 140, 1649, 1, 0, 0, 0, 142, 1709, 1, 0, 0, 0, 144, 1749, 1, 0, 0, 0, 146, 1765, 1, 0, 0, 0, 148, 1767, 1, 0, 0, 0, 150, 1771, 1, 0, 0, 0, 152, 1826, 1, 0, 0, 0, 154, 1838, 1, 0, 0, 0, 156, 1853, 1, 0, 0, 0, 158, 1860, 1, 0, 0, 0, 160, 1865, 1, 0, 0, 0, 162, 1869, 1, 0, 0, 0, 164, 1905, 1, 0, 0, 0, 166, 1907, 1, 0, 0, 0, 168, 1951, 1, 0, 0, 0, 170, 1970, 1, 0, 0, 0, 172, 1991, 1, 0, 0, 0, 174, 1993, 1, 0, 0, 0, 176, 2010, 1, 0, 0, 0, 178, 2025, 1, 0, 0, 0, 180, 2033, 1, 0, 0, 0, 182, 2045, 1, 0, 0, 0, 184, 2065, 1, 0, 0, 0, 186, 2072, 1, 0, 0, 0, 188, 2075, 1, 0, 0, 0, 190, 2088, 1, 0, 0, 0, 192, 2094, 1, 0, 0, 0, 194, 2100, 1, 0, 0, 0, 196, 2104, 1, 0, 0, 0, 198, 2261, 1, 0, 0, 0, 200, 2263, 1, 0, 0, 0, 202, 2319, 1, 0, 0, 0, 204, 2330, 1, 0, 0, 0, 206, 2337, 1, 0, 0, 0, 208, 2345, 1, 0, 0, 0, 210, 2372, 1, 0, 0, 0, 212, 2378, 1, 0, 0, 0, 214, 2383, 1, 0, 0, 0, 216, 2412, 1, 0, 0, 0, 218, 2414, 1, 0, 0, 0, 220, 2434, 1, 0, 0, 0, 222, 2439, 1, 0, 0, 0, 224, 2464, 1, 0, 0, 0, 226, 2473, 1, 0, 0, 0, 228, 2488, 1, 0, 0, 0, 230, 2495, 1, 0, 0, 0, 232, 2515, 1, 0, 0, 0, 234, 2517, 1, 0, 0, 0, 236, 2588, 1, 0, 0, 0, 238, 2613, 1, 0, 0, 0, 240, 2657, 1, 0, 0, 0, 242, 2666, 1, 0, 0, 0, 244, 2706, 1, 0, 0, 0, 246, 2711, 1, 0, 0, 0, 248, 2751, 1, 0, 0, 0, 250, 2753, 1, 0, 0, 0, 252, 2759, 1, 0, 0, 0, 254, 2767, 1, 0, 0, 0, 256, 2787, 1, 0, 0, 0, 258, 2854, 1, 0, 0, 0, 260, 2856, 1, 0, 0, 0, 262, 2862, 1, 0, 0, 0, 264, 2864, 1, 0, 0, 0, 266, 2868, 1, 0, 0, 0, 268, 2874, 1, 0, 0, 0, 270, 2894, 1, 0, 0, 0, 272, 2912, 1, 0, 0, 0, 274, 2926, 1, 0, 0, 0, 276, 2928, 1, 0, 0, 0, 278, 2931, 1, 0, 0, 0, 280, 2933, 1, 0, 0, 0, 282, 2950, 1, 0, 0, 0, 284, 2952, 1, 0, 0, 0, 286, 2962, 1, 0, 0, 0, 288, 2967, 1, 0, 0, 0, 290, 2978, 1, 0, 0, 0, 292, 2985, 1, 0, 0, 0, 294, 2995, 1, 0, 0, 0, 296, 3063, 1, 0, 0, 0, 298, 3140, 1, 0, 0, 0, 300, 3147, 1, 0, 0, 0, 302, 3150, 1, 0, 0, 0, 304, 3155, 1, 0, 0, 0, 306, 3305, 1, 0, 0, 0, 308, 3311, 1, 0, 0, 0, 310, 3318, 1, 0, 0, 0, 312, 3324, 1, 0, 0, 0, 314, 3330, 1, 0, 0, 0, 316, 3336, 1, 0, 0, 0, 318, 3342, 1, 0, 0, 0, 320, 3348, 1, 0, 0, 0, 322, 3354, 1, 0, 0, 0, 324, 3360, 1, 0, 0, 0, 326, 3367, 1, 0, 0, 0, 328, 3372, 1, 0, 0, 0, 330, 3378, 1, 0, 0, 0, 332, 3405, 1, 0, 0, 0, 334, 3407, 1, 0, 0, 0, 336, 3424, 1, 0, 0, 0, 338, 3429, 1, 0, 0, 0, 340, 3446, 1, 0, 0, 0, 342, 3448, 1, 0, 0, 0, 344, 3453, 1, 0, 0, 0, 346, 3463, 1, 0, 0, 0, 348, 3487, 1, 0, 0, 0, 350, 3492, 1, 0, 0, 0, 352, 3508, 1, 0, 0, 0, 354, 3510, 1, 0, 0, 0, 356, 3534, 1, 0, 0, 0, 358, 3536, 1, 0, 0, 0, 360, 3541, 1, 0, 0, 0, 362, 3554, 1, 0, 0, 0, 364, 365, 7, 0, 0, 0, 365, 1, 1, 0, 0, 0, 366, 367, 5, 288, 0, 0, 367, 383, 6, 1, -1, 0, 368, 369, 3, 4, 2, 0, 369, 370, 6, 1, -1, 0, 370, 371, 5, 265, 0, 0, 371, 373, 1, 0, 0, 0, 372, 368, 1, 0, 0, 0, 373, 376, 1, 0, 0, 0, 374, 372, 1, 0, 0, 0, 374, 375, 1, 0, 0, 0, 375, 377, 1, 0, 0, 0, 376, 374, 1, 0, 0, 0, 377, 378, 3, 4, 2, 0, 378, 379, 6, 1, -1, 0, 379, 383, 1, 0, 0, 0, 380, 381, 5, 264, 0, 0, 381, 383, 6, 1, -1, 0, 382, 366, 1, 0, 0, 0, 382, 374, 1, 0, 0, 0, 382, 380, 1, 0, 0, 0, 383, 3, 1, 0, 0, 0, 384, 385, 7, 1, 0, 0, 385, 5, 1, 0, 0, 0, 386, 387, 5, 263, 0, 0, 387, 388, 6, 3, -1, 0, 388, 390, 5, 266, 0, 0, 389, 386, 1, 0, 0, 0, 390, 393, 1, 0, 0, 0, 391, 389, 1, 0, 0, 0, 391, 392, 1, 0, 0, 0, 392, 394, 1, 0, 0, 0, 393, 391, 1, 0, 0, 0, 394, 395, 5, 263, 0, 0, 395, 396, 6, 3, -1, 0, 396, 7, 1, 0, 0, 0, 397, 399, 3, 10, 5, 0, 398, 397, 1, 0, 0, 0, 399, 402, 1, 0, 0, 0, 400, 398, 1, 0, 0, 0, 400, 401, 1, 0, 0, 0, 401, 9, 1, 0, 0, 0, 402, 400, 1, 0, 0, 0, 403, 404, 3, 74, 37, 0, 404, 405, 5, 17, 0, 0, 405, 406, 3, 82, 41, 0, 406, 407, 5, 18, 0, 0, 407, 490, 1, 0, 0, 0, 408, 409, 3, 72, 36, 0, 409, 410, 5, 17, 0, 0, 410, 411, 3, 8, 4, 0, 411, 412, 5, 18, 0, 0, 412, 490, 1, 0, 0, 0, 413, 414, 3, 234, 117, 0, 414, 415, 5, 17, 0, 0, 415, 416, 3, 246, 123, 0, 416, 417, 5, 18, 0, 0, 417, 490, 1, 0, 0, 0, 418, 490, 3, 200, 100, 0, 419, 420, 6, 5, -1, 0, 420, 421, 3, 284, 142, 0, 421, 422, 6, 5, -1, 0, 422, 490, 1, 0, 0, 0, 423, 424, 6, 5, -1, 0, 424, 425, 3, 70, 35, 0, 425, 426, 6, 5, -1, 0, 426, 490, 1, 0, 0, 0, 427, 428, 6, 5, -1, 0, 428, 429, 3, 66, 33, 0, 429, 430, 6, 5, -1, 0, 430, 490, 1, 0, 0, 0, 431, 432, 6, 5, -1, 0, 432, 433, 3, 88, 44, 0, 433, 434, 6, 5, -1, 0, 434, 490, 1, 0, 0, 0, 435, 436, 6, 5, -1, 0, 436, 437, 3, 90, 45, 0, 437, 438, 6, 5, -1, 0, 438, 490, 1, 0, 0, 0, 439, 440, 6, 5, -1, 0, 440, 441, 3, 22, 11, 0, 441, 442, 6, 5, -1, 0, 442, 490, 1, 0, 0, 0, 443, 444, 6, 5, -1, 0, 444, 445, 3, 334, 167, 0, 445, 446, 6, 5, -1, 0, 446, 490, 1, 0, 0, 0, 447, 448, 6, 5, -1, 0, 448, 449, 3, 342, 171, 0, 449, 450, 6, 5, -1, 0, 450, 490, 1, 0, 0, 0, 451, 452, 6, 5, -1, 0, 452, 453, 3, 354, 177, 0, 453, 454, 6, 5, -1, 0, 454, 490, 1, 0, 0, 0, 455, 456, 6, 5, -1, 0, 456, 457, 3, 64, 32, 0, 457, 458, 6, 5, -1, 0, 458, 490, 1, 0, 0, 0, 459, 460, 6, 5, -1, 0, 460, 461, 3, 152, 76, 0, 461, 462, 6, 5, -1, 0, 462, 490, 1, 0, 0, 0, 463, 464, 3, 330, 165, 0, 464, 465, 6, 5, -1, 0, 465, 490, 1, 0, 0, 0, 466, 467, 6, 5, -1, 0, 467, 490, 3, 12, 6, 0, 468, 469, 6, 5, -1, 0, 469, 490, 3, 14, 7, 0, 470, 471, 6, 5, -1, 0, 471, 490, 3, 16, 8, 0, 472, 473, 6, 5, -1, 0, 473, 490, 3, 18, 9, 0, 474, 475, 6, 5, -1, 0, 475, 490, 3, 20, 10, 0, 476, 477, 6, 5, -1, 0, 477, 478, 3, 26, 13, 0, 478, 479, 6, 5, -1, 0, 479, 490, 1, 0, 0, 0, 480, 481, 6, 5, -1, 0, 481, 482, 3, 42, 21, 0, 482, 483, 6, 5, -1, 0, 483, 490, 1, 0, 0, 0, 484, 485, 6, 5, -1, 0, 485, 490, 3, 40, 20, 0, 486, 490, 3, 30, 15, 0, 487, 488, 6, 5, -1, 0, 488, 490, 3, 24, 12, 0, 489, 403, 1, 0, 0, 0, 489, 408, 1, 0, 0, 0, 489, 413, 1, 0, 0, 0, 489, 418, 1, 0, 0, 0, 489, 419, 1, 0, 0, 0, 489, 423, 1, 0, 0, 0, 489, 427, 1, 0, 0, 0, 489, 431, 1, 0, 0, 0, 489, 435, 1, 0, 0, 0, 489, 439, 1, 0, 0, 0, 489, 443, 1, 0, 0, 0, 489, 447, 1, 0, 0, 0, 489, 451, 1, 0, 0, 0, 489, 455, 1, 0, 0, 0, 489, 459, 1, 0, 0, 0, 489, 463, 1, 0, 0, 0, 489, 466, 1, 0, 0, 0, 489, 468, 1, 0, 0, 0, 489, 470, 1, 0, 0, 0, 489, 472, 1, 0, 0, 0, 489, 474, 1, 0, 0, 0, 489, 476, 1, 0, 0, 0, 489, 480, 1, 0, 0, 0, 489, 484, 1, 0, 0, 0, 489, 486, 1, 0, 0, 0, 489, 487, 1, 0, 0, 0, 490, 11, 1, 0, 0, 0, 491, 492, 5, 19, 0, 0, 492, 493, 3, 32, 16, 0, 493, 494, 6, 6, -1, 0, 494, 13, 1, 0, 0, 0, 495, 496, 5, 20, 0, 0, 496, 497, 3, 32, 16, 0, 497, 498, 6, 7, -1, 0, 498, 15, 1, 0, 0, 0, 499, 500, 5, 21, 0, 0, 500, 501, 5, 22, 0, 0, 501, 502, 3, 32, 16, 0, 502, 503, 6, 8, -1, 0, 503, 17, 1, 0, 0, 0, 504, 505, 5, 23, 0, 0, 505, 506, 3, 34, 17, 0, 506, 507, 6, 9, -1, 0, 507, 19, 1, 0, 0, 0, 508, 509, 5, 24, 0, 0, 509, 510, 3, 34, 17, 0, 510, 511, 6, 10, -1, 0, 511, 21, 1, 0, 0, 0, 512, 513, 5, 25, 0, 0, 513, 514, 3, 98, 49, 0, 514, 515, 3, 2, 1, 0, 515, 516, 5, 17, 0, 0, 516, 517, 3, 120, 60, 0, 517, 518, 5, 18, 0, 0, 518, 23, 1, 0, 0, 0, 519, 520, 5, 26, 0, 0, 520, 25, 1, 0, 0, 0, 521, 522, 5, 27, 0, 0, 522, 536, 3, 28, 14, 0, 523, 524, 5, 27, 0, 0, 524, 525, 3, 28, 14, 0, 525, 526, 5, 28, 0, 0, 526, 527, 3, 28, 14, 0, 527, 536, 1, 0, 0, 0, 528, 529, 5, 27, 0, 0, 529, 530, 3, 28, 14, 0, 530, 531, 5, 28, 0, 0, 531, 532, 3, 28, 14, 0, 532, 533, 5, 28, 0, 0, 533, 534, 3, 28, 14, 0, 534, 536, 1, 0, 0, 0, 535, 521, 1, 0, 0, 0, 535, 523, 1, 0, 0, 0, 535, 528, 1, 0, 0, 0, 536, 27, 1, 0, 0, 0, 537, 538, 7, 2, 0, 0, 538, 29, 1, 0, 0, 0, 539, 540, 5, 29, 0, 0, 540, 546, 5, 17, 0, 0, 541, 542, 3, 116, 58, 0, 542, 543, 6, 15, -1, 0, 543, 545, 1, 0, 0, 0, 544, 541, 1, 0, 0, 0, 545, 548, 1, 0, 0, 0, 546, 544, 1, 0, 0, 0, 546, 547, 1, 0, 0, 0, 547, 549, 1, 0, 0, 0, 548, 546, 1, 0, 0, 0, 549, 550, 5, 18, 0, 0, 550, 31, 1, 0, 0, 0, 551, 552, 5, 173, 0, 0, 552, 33, 1, 0, 0, 0, 553, 554, 7, 3, 0, 0, 554, 35, 1, 0, 0, 0, 555, 556, 5, 175, 0, 0, 556, 577, 6, 18, -1, 0, 557, 558, 3, 32, 16, 0, 558, 559, 5, 265, 0, 0, 559, 560, 6, 18, -1, 0, 560, 577, 1, 0, 0, 0, 561, 562, 3, 32, 16, 0, 562, 563, 6, 18, -1, 0, 563, 577, 1, 0, 0, 0, 564, 565, 5, 188, 0, 0, 565, 566, 5, 30, 0, 0, 566, 567, 3, 32, 16, 0, 567, 568, 5, 31, 0, 0, 568, 569, 6, 18, -1, 0, 569, 577, 1, 0, 0, 0, 570, 571, 5, 189, 0, 0, 571, 572, 5, 30, 0, 0, 572, 573, 3, 34, 17, 0, 573, 574, 5, 31, 0, 0, 574, 575, 6, 18, -1, 0, 575, 577, 1, 0, 0, 0, 576, 555, 1, 0, 0, 0, 576, 557, 1, 0, 0, 0, 576, 561, 1, 0, 0, 0, 576, 564, 1, 0, 0, 0, 576, 570, 1, 0, 0, 0, 577, 37, 1, 0, 0, 0, 578, 581, 3, 32, 16, 0, 579, 581, 5, 262, 0, 0, 580, 578, 1, 0, 0, 0, 580, 579, 1, 0, 0, 0, 581, 39, 1, 0, 0, 0, 582, 583, 5, 267, 0, 0, 583, 599, 5, 289, 0, 0, 584, 585, 5, 267, 0, 0, 585, 586, 5, 289, 0, 0, 586, 599, 5, 263, 0, 0, 587, 588, 5, 268, 0, 0, 588, 599, 5, 289, 0, 0, 589, 590, 5, 269, 0, 0, 590, 599, 5, 289, 0, 0, 591, 592, 5, 270, 0, 0, 592, 599, 5, 289, 0, 0, 593, 599, 5, 271, 0, 0, 594, 599, 5, 272, 0, 0, 595, 596, 5, 273, 0, 0, 596, 599, 5, 263, 0, 0, 597, 599, 5, 32, 0, 0, 598, 582, 1, 0, 0, 0, 598, 584, 1, 0, 0, 0, 598, 587, 1, 0, 0, 0, 598, 589, 1, 0, 0, 0, 598, 591, 1, 0, 0, 0, 598, 593, 1, 0, 0, 0, 598, 594, 1, 0, 0, 0, 598, 595, 1, 0, 0, 0, 598, 597, 1, 0, 0, 0, 599, 41, 1, 0, 0, 0, 600, 601, 5, 33, 0, 0, 601, 602, 3, 138, 69, 0, 602, 603, 5, 34, 0, 0, 603, 604, 3, 2, 1, 0, 604, 626, 1, 0, 0, 0, 605, 606, 5, 33, 0, 0, 606, 607, 3, 116, 58, 0, 607, 608, 5, 34, 0, 0, 608, 609, 3, 2, 1, 0, 609, 626, 1, 0, 0, 0, 610, 611, 5, 33, 0, 0, 611, 612, 3, 176, 88, 0, 612, 613, 5, 34, 0, 0, 613, 614, 3, 2, 1, 0, 614, 626, 1, 0, 0, 0, 615, 616, 5, 33, 0, 0, 616, 617, 3, 44, 22, 0, 617, 618, 5, 34, 0, 0, 618, 619, 3, 2, 1, 0, 619, 626, 1, 0, 0, 0, 620, 621, 5, 33, 0, 0, 621, 622, 3, 46, 23, 0, 622, 623, 5, 34, 0, 0, 623, 624, 3, 2, 1, 0, 624, 626, 1, 0, 0, 0, 625, 600, 1, 0, 0, 0, 625, 605, 1, 0, 0, 0, 625, 610, 1, 0, 0, 0, 625, 615, 1, 0, 0, 0, 625, 620, 1, 0, 0, 0, 626, 43, 1, 0, 0, 0, 627, 628, 5, 35, 0, 0, 628, 649, 3, 48, 24, 0, 629, 630, 5, 35, 0, 0, 630, 631, 3, 48, 24, 0, 631, 632, 5, 36, 0, 0, 632, 633, 3, 6, 3, 0, 633, 649, 1, 0, 0, 0, 634, 635, 5, 35, 0, 0, 635, 636, 3, 48, 24, 0, 636, 637, 5, 36, 0, 0, 637, 638, 5, 17, 0, 0, 638, 639, 3, 52, 26, 0, 639, 640, 5, 18, 0, 0, 640, 649, 1, 0, 0, 0, 641, 642, 5, 35, 0, 0, 642, 643, 3, 48, 24, 0, 643, 644, 5, 36, 0, 0, 644, 645, 5, 30, 0, 0, 645, 646, 3, 300, 150, 0, 646, 647, 5, 31, 0, 0, 647, 649, 1, 0, 0, 0, 648, 627, 1, 0, 0, 0, 648, 629, 1, 0, 0, 0, 648, 634, 1, 0, 0, 0, 648, 641, 1, 0, 0, 0, 649, 45, 1, 0, 0, 0, 650, 651, 5, 35, 0, 0, 651, 652, 5, 30, 0, 0, 652, 653, 3, 50, 25, 0, 653, 654, 5, 31, 0, 0, 654, 655, 3, 48, 24, 0, 655, 685, 1, 0, 0, 0, 656, 657, 5, 35, 0, 0, 657, 658, 5, 30, 0, 0, 658, 659, 3, 50, 25, 0, 659, 660, 5, 31, 0, 0, 660, 661, 3, 48, 24, 0, 661, 662, 5, 36, 0, 0, 662, 663, 3, 6, 3, 0, 663, 685, 1, 0, 0, 0, 664, 665, 5, 35, 0, 0, 665, 666, 5, 30, 0, 0, 666, 667, 3, 50, 25, 0, 667, 668, 5, 31, 0, 0, 668, 669, 3, 48, 24, 0, 669, 670, 5, 36, 0, 0, 670, 671, 5, 17, 0, 0, 671, 672, 3, 52, 26, 0, 672, 673, 5, 18, 0, 0, 673, 685, 1, 0, 0, 0, 674, 675, 5, 35, 0, 0, 675, 676, 5, 30, 0, 0, 676, 677, 3, 50, 25, 0, 677, 678, 5, 31, 0, 0, 678, 679, 3, 48, 24, 0, 679, 680, 5, 36, 0, 0, 680, 681, 5, 30, 0, 0, 681, 682, 3, 300, 150, 0, 682, 683, 5, 31, 0, 0, 683, 685, 1, 0, 0, 0, 684, 650, 1, 0, 0, 0, 684, 656, 1, 0, 0, 0, 684, 664, 1, 0, 0, 0, 684, 674, 1, 0, 0, 0, 685, 47, 1, 0, 0, 0, 686, 687, 3, 168, 84, 0, 687, 49, 1, 0, 0, 0, 688, 689, 3, 124, 62, 0, 689, 690, 6, 25, -1, 0, 690, 695, 1, 0, 0, 0, 691, 692, 3, 176, 88, 0, 692, 693, 6, 25, -1, 0, 693, 695, 1, 0, 0, 0, 694, 688, 1, 0, 0, 0, 694, 691, 1, 0, 0, 0, 695, 51, 1, 0, 0, 0, 696, 697, 3, 54, 27, 0, 697, 698, 3, 56, 28, 0, 698, 53, 1, 0, 0, 0, 699, 702, 3, 306, 153, 0, 700, 702, 3, 40, 20, 0, 701, 699, 1, 0, 0, 0, 701, 700, 1, 0, 0, 0, 702, 705, 1, 0, 0, 0, 703, 701, 1, 0, 0, 0, 703, 704, 1, 0, 0, 0, 704, 55, 1, 0, 0, 0, 705, 703, 1, 0, 0, 0, 706, 707, 3, 58, 29, 0, 707, 708, 3, 60, 30, 0, 708, 709, 3, 2, 1, 0, 709, 710, 5, 36, 0, 0, 710, 711, 3, 306, 153, 0, 711, 714, 1, 0, 0, 0, 712, 714, 3, 40, 20, 0, 713, 706, 1, 0, 0, 0, 713, 712, 1, 0, 0, 0, 714, 717, 1, 0, 0, 0, 715, 713, 1, 0, 0, 0, 715, 716, 1, 0, 0, 0, 716, 57, 1, 0, 0, 0, 717, 715, 1, 0, 0, 0, 718, 719, 7, 4, 0, 0, 719, 59, 1, 0, 0, 0, 720, 722, 3, 62, 31, 0, 721, 723, 5, 261, 0, 0, 722, 721, 1, 0, 0, 0, 722, 723, 1, 0, 0, 0, 723, 61, 1, 0, 0, 0, 724, 734, 3, 144, 72, 0, 725, 734, 3, 2, 1, 0, 726, 734, 5, 196, 0, 0, 727, 734, 5, 197, 0, 0, 728, 729, 5, 202, 0, 0, 729, 730, 5, 39, 0, 0, 730, 734, 5, 264, 0, 0, 731, 732, 5, 202, 0, 0, 732, 734, 3, 116, 58, 0, 733, 724, 1, 0, 0, 0, 733, 725, 1, 0, 0, 0, 733, 726, 1, 0, 0, 0, 733, 727, 1, 0, 0, 0, 733, 728, 1, 0, 0, 0, 733, 731, 1, 0, 0, 0, 734, 63, 1, 0, 0, 0, 735, 736, 5, 198, 0, 0, 736, 737, 5, 40, 0, 0, 737, 738, 3, 2, 1, 0, 738, 739, 6, 32, -1, 0, 739, 747, 1, 0, 0, 0, 740, 741, 5, 198, 0, 0, 741, 742, 3, 2, 1, 0, 742, 743, 6, 32, -1, 0, 743, 747, 1, 0, 0, 0, 744, 745, 5, 198, 0, 0, 745, 747, 6, 32, -1, 0, 746, 735, 1, 0, 0, 0, 746, 740, 1, 0, 0, 0, 746, 744, 1, 0, 0, 0, 747, 65, 1, 0, 0, 0, 748, 749, 5, 41, 0, 0, 749, 750, 5, 42, 0, 0, 750, 751, 3, 32, 16, 0, 751, 752, 5, 43, 0, 0, 752, 753, 3, 68, 34, 0, 753, 754, 5, 44, 0, 0, 754, 755, 3, 0, 0, 0, 755, 67, 1, 0, 0, 0, 756, 769, 6, 34, -1, 0, 757, 758, 10, 5, 0, 0, 758, 768, 5, 186, 0, 0, 759, 760, 10, 4, 0, 0, 760, 768, 5, 187, 0, 0, 761, 762, 10, 3, 0, 0, 762, 768, 5, 45, 0, 0, 763, 764, 10, 2, 0, 0, 764, 768, 5, 46, 0, 0, 765, 766, 10, 1, 0, 0, 766, 768, 5, 47, 0, 0, 767, 757, 1, 0, 0, 0, 767, 759, 1, 0, 0, 0, 767, 761, 1, 0, 0, 0, 767, 763, 1, 0, 0, 0, 767, 765, 1, 0, 0, 0, 768, 771, 1, 0, 0, 0, 769, 767, 1, 0, 0, 0, 769, 770, 1, 0, 0, 0, 770, 69, 1, 0, 0, 0, 771, 769, 1, 0, 0, 0, 772, 773, 5, 48, 0, 0, 773, 774, 5, 36, 0, 0, 774, 775, 5, 30, 0, 0, 775, 776, 3, 300, 150, 0, 776, 777, 5, 31, 0, 0, 777, 71, 1, 0, 0, 0, 778, 779, 5, 49, 0, 0, 779, 780, 3, 2, 1, 0, 780, 781, 6, 36, -1, 0, 781, 73, 1, 0, 0, 0, 782, 788, 5, 50, 0, 0, 783, 784, 3, 76, 38, 0, 784, 785, 6, 37, -1, 0, 785, 787, 1, 0, 0, 0, 786, 783, 1, 0, 0, 0, 787, 790, 1, 0, 0, 0, 788, 786, 1, 0, 0, 0, 788, 789, 1, 0, 0, 0, 789, 791, 1, 0, 0, 0, 790, 788, 1, 0, 0, 0, 791, 792, 3, 2, 1, 0, 792, 793, 3, 182, 91, 0, 793, 794, 3, 78, 39, 0, 794, 795, 3, 80, 40, 0, 795, 796, 6, 37, -1, 0, 796, 75, 1, 0, 0, 0, 797, 798, 5, 51, 0, 0, 798, 862, 6, 38, -1, 0, 799, 800, 5, 52, 0, 0, 800, 862, 6, 38, -1, 0, 801, 802, 5, 199, 0, 0, 802, 862, 6, 38, -1, 0, 803, 804, 5, 202, 0, 0, 804, 862, 6, 38, -1, 0, 805, 806, 5, 221, 0, 0, 806, 862, 6, 38, -1, 0, 807, 808, 5, 53, 0, 0, 808, 862, 6, 38, -1, 0, 809, 810, 5, 54, 0, 0, 810, 862, 6, 38, -1, 0, 811, 812, 5, 55, 0, 0, 812, 862, 6, 38, -1, 0, 813, 814, 5, 56, 0, 0, 814, 862, 6, 38, -1, 0, 815, 816, 5, 244, 0, 0, 816, 862, 6, 38, -1, 0, 817, 818, 5, 15, 0, 0, 818, 862, 6, 38, -1, 0, 819, 820, 5, 224, 0, 0, 820, 862, 6, 38, -1, 0, 821, 822, 5, 57, 0, 0, 822, 862, 6, 38, -1, 0, 823, 824, 5, 58, 0, 0, 824, 862, 6, 38, -1, 0, 825, 826, 5, 59, 0, 0, 826, 862, 6, 38, -1, 0, 827, 828, 5, 60, 0, 0, 828, 862, 6, 38, -1, 0, 829, 830, 5, 61, 0, 0, 830, 862, 6, 38, -1, 0, 831, 832, 5, 62, 0, 0, 832, 833, 5, 51, 0, 0, 833, 862, 6, 38, -1, 0, 834, 835, 5, 62, 0, 0, 835, 836, 5, 52, 0, 0, 836, 862, 6, 38, -1, 0, 837, 838, 5, 62, 0, 0, 838, 839, 5, 63, 0, 0, 839, 862, 6, 38, -1, 0, 840, 841, 5, 62, 0, 0, 841, 842, 5, 64, 0, 0, 842, 862, 6, 38, -1, 0, 843, 844, 5, 62, 0, 0, 844, 845, 5, 65, 0, 0, 845, 862, 6, 38, -1, 0, 846, 847, 5, 62, 0, 0, 847, 848, 5, 66, 0, 0, 848, 862, 6, 38, -1, 0, 849, 850, 5, 67, 0, 0, 850, 862, 6, 38, -1, 0, 851, 852, 5, 68, 0, 0, 852, 862, 6, 38, -1, 0, 853, 854, 5, 69, 0, 0, 854, 862, 6, 38, -1, 0, 855, 856, 5, 70, 0, 0, 856, 857, 5, 30, 0, 0, 857, 858, 3, 32, 16, 0, 858, 859, 5, 31, 0, 0, 859, 860, 6, 38, -1, 0, 860, 862, 1, 0, 0, 0, 861, 797, 1, 0, 0, 0, 861, 799, 1, 0, 0, 0, 861, 801, 1, 0, 0, 0, 861, 803, 1, 0, 0, 0, 861, 805, 1, 0, 0, 0, 861, 807, 1, 0, 0, 0, 861, 809, 1, 0, 0, 0, 861, 811, 1, 0, 0, 0, 861, 813, 1, 0, 0, 0, 861, 815, 1, 0, 0, 0, 861, 817, 1, 0, 0, 0, 861, 819, 1, 0, 0, 0, 861, 821, 1, 0, 0, 0, 861, 823, 1, 0, 0, 0, 861, 825, 1, 0, 0, 0, 861, 827, 1, 0, 0, 0, 861, 829, 1, 0, 0, 0, 861, 831, 1, 0, 0, 0, 861, 834, 1, 0, 0, 0, 861, 837, 1, 0, 0, 0, 861, 840, 1, 0, 0, 0, 861, 843, 1, 0, 0, 0, 861, 846, 1, 0, 0, 0, 861, 849, 1, 0, 0, 0, 861, 851, 1, 0, 0, 0, 861, 853, 1, 0, 0, 0, 861, 855, 1, 0, 0, 0, 862, 77, 1, 0, 0, 0, 863, 869, 1, 0, 0, 0, 864, 865, 5, 71, 0, 0, 865, 866, 3, 124, 62, 0, 866, 867, 6, 39, -1, 0, 867, 869, 1, 0, 0, 0, 868, 863, 1, 0, 0, 0, 868, 864, 1, 0, 0, 0, 869, 79, 1, 0, 0, 0, 870, 876, 1, 0, 0, 0, 871, 872, 5, 72, 0, 0, 872, 873, 3, 84, 42, 0, 873, 874, 6, 40, -1, 0, 874, 876, 1, 0, 0, 0, 875, 870, 1, 0, 0, 0, 875, 871, 1, 0, 0, 0, 876, 81, 1, 0, 0, 0, 877, 879, 3, 198, 99, 0, 878, 877, 1, 0, 0, 0, 879, 882, 1, 0, 0, 0, 880, 878, 1, 0, 0, 0, 880, 881, 1, 0, 0, 0, 881, 83, 1, 0, 0, 0, 882, 880, 1, 0, 0, 0, 883, 884, 3, 124, 62, 0, 884, 885, 6, 42, -1, 0, 885, 886, 5, 28, 0, 0, 886, 888, 1, 0, 0, 0, 887, 883, 1, 0, 0, 0, 888, 891, 1, 0, 0, 0, 889, 887, 1, 0, 0, 0, 889, 890, 1, 0, 0, 0, 890, 892, 1, 0, 0, 0, 891, 889, 1, 0, 0, 0, 892, 893, 3, 124, 62, 0, 893, 894, 6, 42, -1, 0, 894, 85, 1, 0, 0, 0, 895, 896, 7, 5, 0, 0, 896, 87, 1, 0, 0, 0, 897, 898, 3, 86, 43, 0, 898, 899, 3, 32, 16, 0, 899, 900, 5, 264, 0, 0, 900, 1001, 1, 0, 0, 0, 901, 902, 3, 86, 43, 0, 902, 903, 3, 32, 16, 0, 903, 1001, 1, 0, 0, 0, 904, 905, 3, 86, 43, 0, 905, 906, 3, 32, 16, 0, 906, 907, 5, 75, 0, 0, 907, 908, 3, 32, 16, 0, 908, 909, 5, 264, 0, 0, 909, 1001, 1, 0, 0, 0, 910, 911, 3, 86, 43, 0, 911, 912, 3, 32, 16, 0, 912, 913, 5, 75, 0, 0, 913, 914, 3, 32, 16, 0, 914, 1001, 1, 0, 0, 0, 915, 916, 3, 86, 43, 0, 916, 917, 3, 32, 16, 0, 917, 918, 5, 75, 0, 0, 918, 919, 3, 32, 16, 0, 919, 920, 5, 28, 0, 0, 920, 921, 3, 32, 16, 0, 921, 922, 5, 264, 0, 0, 922, 1001, 1, 0, 0, 0, 923, 924, 3, 86, 43, 0, 924, 925, 3, 32, 16, 0, 925, 926, 5, 75, 0, 0, 926, 927, 3, 32, 16, 0, 927, 928, 5, 28, 0, 0, 928, 929, 3, 32, 16, 0, 929, 1001, 1, 0, 0, 0, 930, 931, 3, 86, 43, 0, 931, 932, 3, 32, 16, 0, 932, 933, 5, 28, 0, 0, 933, 934, 3, 32, 16, 0, 934, 935, 5, 75, 0, 0, 935, 936, 3, 32, 16, 0, 936, 937, 5, 264, 0, 0, 937, 1001, 1, 0, 0, 0, 938, 939, 3, 86, 43, 0, 939, 940, 3, 32, 16, 0, 940, 941, 5, 28, 0, 0, 941, 942, 3, 32, 16, 0, 942, 943, 5, 75, 0, 0, 943, 944, 3, 32, 16, 0, 944, 1001, 1, 0, 0, 0, 945, 946, 3, 86, 43, 0, 946, 947, 3, 32, 16, 0, 947, 948, 5, 28, 0, 0, 948, 949, 3, 32, 16, 0, 949, 950, 5, 75, 0, 0, 950, 951, 3, 32, 16, 0, 951, 952, 5, 28, 0, 0, 952, 953, 3, 32, 16, 0, 953, 954, 5, 264, 0, 0, 954, 1001, 1, 0, 0, 0, 955, 956, 3, 86, 43, 0, 956, 957, 3, 32, 16, 0, 957, 958, 5, 28, 0, 0, 958, 959, 3, 32, 16, 0, 959, 960, 5, 75, 0, 0, 960, 961, 3, 32, 16, 0, 961, 962, 5, 28, 0, 0, 962, 963, 3, 32, 16, 0, 963, 1001, 1, 0, 0, 0, 964, 965, 3, 86, 43, 0, 965, 966, 3, 32, 16, 0, 966, 967, 5, 263, 0, 0, 967, 1001, 1, 0, 0, 0, 968, 969, 3, 86, 43, 0, 969, 970, 3, 32, 16, 0, 970, 971, 5, 75, 0, 0, 971, 972, 3, 32, 16, 0, 972, 973, 5, 263, 0, 0, 973, 1001, 1, 0, 0, 0, 974, 975, 3, 86, 43, 0, 975, 976, 3, 32, 16, 0, 976, 977, 5, 75, 0, 0, 977, 978, 3, 32, 16, 0, 978, 979, 5, 28, 0, 0, 979, 980, 3, 32, 16, 0, 980, 981, 5, 263, 0, 0, 981, 1001, 1, 0, 0, 0, 982, 983, 3, 86, 43, 0, 983, 984, 3, 32, 16, 0, 984, 985, 5, 28, 0, 0, 985, 986, 3, 32, 16, 0, 986, 987, 5, 75, 0, 0, 987, 988, 3, 32, 16, 0, 988, 989, 5, 263, 0, 0, 989, 1001, 1, 0, 0, 0, 990, 991, 3, 86, 43, 0, 991, 992, 3, 32, 16, 0, 992, 993, 5, 28, 0, 0, 993, 994, 3, 32, 16, 0, 994, 995, 5, 75, 0, 0, 995, 996, 3, 32, 16, 0, 996, 997, 5, 28, 0, 0, 997, 998, 3, 32, 16, 0, 998, 999, 5, 263, 0, 0, 999, 1001, 1, 0, 0, 0, 1000, 897, 1, 0, 0, 0, 1000, 901, 1, 0, 0, 0, 1000, 904, 1, 0, 0, 0, 1000, 910, 1, 0, 0, 0, 1000, 915, 1, 0, 0, 0, 1000, 923, 1, 0, 0, 0, 1000, 930, 1, 0, 0, 0, 1000, 938, 1, 0, 0, 0, 1000, 945, 1, 0, 0, 0, 1000, 955, 1, 0, 0, 0, 1000, 964, 1, 0, 0, 0, 1000, 968, 1, 0, 0, 0, 1000, 974, 1, 0, 0, 0, 1000, 982, 1, 0, 0, 0, 1000, 990, 1, 0, 0, 0, 1001, 89, 1, 0, 0, 0, 1002, 1006, 5, 21, 0, 0, 1003, 1005, 3, 92, 46, 0, 1004, 1003, 1, 0, 0, 0, 1005, 1008, 1, 0, 0, 0, 1006, 1004, 1, 0, 0, 0, 1006, 1007, 1, 0, 0, 0, 1007, 1009, 1, 0, 0, 0, 1008, 1006, 1, 0, 0, 0, 1009, 1010, 3, 2, 1, 0, 1010, 1011, 3, 94, 47, 0, 1011, 1012, 5, 180, 0, 0, 1012, 1013, 5, 36, 0, 0, 1013, 1014, 5, 30, 0, 0, 1014, 1015, 3, 300, 150, 0, 1015, 1016, 5, 31, 0, 0, 1016, 1017, 3, 94, 47, 0, 1017, 1029, 1, 0, 0, 0, 1018, 1022, 5, 21, 0, 0, 1019, 1021, 3, 92, 46, 0, 1020, 1019, 1, 0, 0, 0, 1021, 1024, 1, 0, 0, 0, 1022, 1020, 1, 0, 0, 0, 1022, 1023, 1, 0, 0, 0, 1023, 1025, 1, 0, 0, 0, 1024, 1022, 1, 0, 0, 0, 1025, 1026, 3, 2, 1, 0, 1026, 1027, 3, 94, 47, 0, 1027, 1029, 1, 0, 0, 0, 1028, 1002, 1, 0, 0, 0, 1028, 1018, 1, 0, 0, 0, 1029, 91, 1, 0, 0, 0, 1030, 1031, 5, 76, 0, 0, 1031, 93, 1, 0, 0, 0, 1032, 1035, 1, 0, 0, 0, 1033, 1035, 5, 298, 0, 0, 1034, 1032, 1, 0, 0, 0, 1034, 1033, 1, 0, 0, 0, 1035, 95, 1, 0, 0, 0, 1036, 1037, 7, 6, 0, 0, 1037, 97, 1, 0, 0, 0, 1038, 1040, 3, 96, 48, 0, 1039, 1038, 1, 0, 0, 0, 1040, 1043, 1, 0, 0, 0, 1041, 1039, 1, 0, 0, 0, 1041, 1042, 1, 0, 0, 0, 1042, 99, 1, 0, 0, 0, 1043, 1041, 1, 0, 0, 0, 1044, 1070, 3, 102, 51, 0, 1045, 1046, 5, 280, 0, 0, 1046, 1047, 3, 168, 84, 0, 1047, 1048, 6, 50, -1, 0, 1048, 1070, 1, 0, 0, 0, 1049, 1050, 5, 286, 0, 0, 1050, 1051, 3, 178, 89, 0, 1051, 1052, 6, 50, -1, 0, 1052, 1070, 1, 0, 0, 0, 1053, 1054, 5, 286, 0, 0, 1054, 1055, 3, 174, 87, 0, 1055, 1056, 6, 50, -1, 0, 1056, 1070, 1, 0, 0, 0, 1057, 1058, 5, 284, 0, 0, 1058, 1059, 3, 124, 62, 0, 1059, 1060, 6, 50, -1, 0, 1060, 1070, 1, 0, 0, 0, 1061, 1062, 5, 281, 0, 0, 1062, 1063, 3, 104, 52, 0, 1063, 1064, 6, 50, -1, 0, 1064, 1070, 1, 0, 0, 0, 1065, 1066, 5, 287, 0, 0, 1066, 1067, 3, 50, 25, 0, 1067, 1068, 6, 50, -1, 0, 1068, 1070, 1, 0, 0, 0, 1069, 1044, 1, 0, 0, 0, 1069, 1045, 1, 0, 0, 0, 1069, 1049, 1, 0, 0, 0, 1069, 1053, 1, 0, 0, 0, 1069, 1057, 1, 0, 0, 0, 1069, 1061, 1, 0, 0, 0, 1069, 1065, 1, 0, 0, 0, 1070, 101, 1, 0, 0, 0, 1071, 1072, 5, 275, 0, 0, 1072, 1150, 6, 51, -1, 0, 1073, 1074, 5, 276, 0, 0, 1074, 1075, 3, 32, 16, 0, 1075, 1076, 6, 51, -1, 0, 1076, 1150, 1, 0, 0, 0, 1077, 1078, 5, 276, 0, 0, 1078, 1079, 3, 0, 0, 0, 1079, 1080, 6, 51, -1, 0, 1080, 1150, 1, 0, 0, 0, 1081, 1082, 5, 277, 0, 0, 1082, 1083, 3, 32, 16, 0, 1083, 1084, 6, 51, -1, 0, 1084, 1150, 1, 0, 0, 0, 1085, 1086, 5, 278, 0, 0, 1086, 1087, 3, 34, 17, 0, 1087, 1088, 6, 51, -1, 0, 1088, 1150, 1, 0, 0, 0, 1089, 1090, 5, 279, 0, 0, 1090, 1091, 3, 36, 18, 0, 1091, 1092, 6, 51, -1, 0, 1092, 1150, 1, 0, 0, 0, 1093, 1094, 5, 279, 0, 0, 1094, 1095, 3, 34, 17, 0, 1095, 1096, 6, 51, -1, 0, 1096, 1150, 1, 0, 0, 0, 1097, 1098, 5, 279, 0, 0, 1098, 1099, 5, 30, 0, 0, 1099, 1100, 3, 300, 150, 0, 1100, 1101, 5, 31, 0, 0, 1101, 1102, 6, 51, -1, 0, 1102, 1150, 1, 0, 0, 0, 1103, 1104, 5, 279, 0, 0, 1104, 1105, 5, 84, 0, 0, 1105, 1106, 5, 30, 0, 0, 1106, 1107, 3, 300, 150, 0, 1107, 1108, 5, 31, 0, 0, 1108, 1109, 6, 51, -1, 0, 1109, 1150, 1, 0, 0, 0, 1110, 1111, 5, 282, 0, 0, 1111, 1112, 3, 32, 16, 0, 1112, 1113, 6, 51, -1, 0, 1113, 1150, 1, 0, 0, 0, 1114, 1115, 5, 282, 0, 0, 1115, 1116, 3, 0, 0, 0, 1116, 1117, 6, 51, -1, 0, 1117, 1150, 1, 0, 0, 0, 1118, 1119, 5, 285, 0, 0, 1119, 1120, 3, 6, 3, 0, 1120, 1121, 6, 51, -1, 0, 1121, 1150, 1, 0, 0, 0, 1122, 1123, 5, 285, 0, 0, 1123, 1124, 5, 224, 0, 0, 1124, 1125, 5, 30, 0, 0, 1125, 1126, 3, 6, 3, 0, 1126, 1127, 5, 31, 0, 0, 1127, 1128, 6, 51, -1, 0, 1128, 1150, 1, 0, 0, 0, 1129, 1130, 5, 285, 0, 0, 1130, 1131, 5, 84, 0, 0, 1131, 1132, 5, 30, 0, 0, 1132, 1133, 3, 300, 150, 0, 1133, 1134, 5, 31, 0, 0, 1134, 1135, 6, 51, -1, 0, 1135, 1150, 1, 0, 0, 0, 1136, 1137, 5, 287, 0, 0, 1137, 1138, 3, 32, 16, 0, 1138, 1139, 6, 51, -1, 0, 1139, 1150, 1, 0, 0, 0, 1140, 1141, 5, 283, 0, 0, 1141, 1147, 6, 51, -1, 0, 1142, 1143, 5, 30, 0, 0, 1143, 1144, 3, 106, 53, 0, 1144, 1145, 5, 31, 0, 0, 1145, 1148, 1, 0, 0, 0, 1146, 1148, 5, 85, 0, 0, 1147, 1142, 1, 0, 0, 0, 1147, 1146, 1, 0, 0, 0, 1148, 1150, 1, 0, 0, 0, 1149, 1071, 1, 0, 0, 0, 1149, 1073, 1, 0, 0, 0, 1149, 1077, 1, 0, 0, 0, 1149, 1081, 1, 0, 0, 0, 1149, 1085, 1, 0, 0, 0, 1149, 1089, 1, 0, 0, 0, 1149, 1093, 1, 0, 0, 0, 1149, 1097, 1, 0, 0, 0, 1149, 1103, 1, 0, 0, 0, 1149, 1110, 1, 0, 0, 0, 1149, 1114, 1, 0, 0, 0, 1149, 1118, 1, 0, 0, 0, 1149, 1122, 1, 0, 0, 0, 1149, 1129, 1, 0, 0, 0, 1149, 1136, 1, 0, 0, 0, 1149, 1140, 1, 0, 0, 0, 1150, 103, 1, 0, 0, 0, 1151, 1152, 3, 170, 85, 0, 1152, 1153, 3, 138, 69, 0, 1153, 1154, 3, 112, 56, 0, 1154, 1155, 6, 52, -1, 0, 1155, 105, 1, 0, 0, 0, 1156, 1181, 1, 0, 0, 0, 1157, 1158, 3, 0, 0, 0, 1158, 1159, 6, 53, -1, 0, 1159, 1164, 1, 0, 0, 0, 1160, 1161, 3, 32, 16, 0, 1161, 1162, 6, 53, -1, 0, 1162, 1164, 1, 0, 0, 0, 1163, 1157, 1, 0, 0, 0, 1163, 1160, 1, 0, 0, 0, 1164, 1165, 1, 0, 0, 0, 1165, 1166, 5, 28, 0, 0, 1166, 1168, 1, 0, 0, 0, 1167, 1163, 1, 0, 0, 0, 1168, 1171, 1, 0, 0, 0, 1169, 1167, 1, 0, 0, 0, 1169, 1170, 1, 0, 0, 0, 1170, 1178, 1, 0, 0, 0, 1171, 1169, 1, 0, 0, 0, 1172, 1173, 3, 0, 0, 0, 1173, 1174, 6, 53, -1, 0, 1174, 1179, 1, 0, 0, 0, 1175, 1176, 3, 32, 16, 0, 1176, 1177, 6, 53, -1, 0, 1177, 1179, 1, 0, 0, 0, 1178, 1172, 1, 0, 0, 0, 1178, 1175, 1, 0, 0, 0, 1179, 1181, 1, 0, 0, 0, 1180, 1156, 1, 0, 0, 0, 1180, 1169, 1, 0, 0, 0, 1181, 107, 1, 0, 0, 0, 1182, 1189, 5, 86, 0, 0, 1183, 1184, 3, 138, 69, 0, 1184, 1185, 6, 54, -1, 0, 1185, 1186, 5, 28, 0, 0, 1186, 1188, 1, 0, 0, 0, 1187, 1183, 1, 0, 0, 0, 1188, 1191, 1, 0, 0, 0, 1189, 1187, 1, 0, 0, 0, 1189, 1190, 1, 0, 0, 0, 1190, 1192, 1, 0, 0, 0, 1191, 1189, 1, 0, 0, 0, 1192, 1193, 3, 138, 69, 0, 1193, 1194, 6, 54, -1, 0, 1194, 1195, 5, 87, 0, 0, 1195, 109, 1, 0, 0, 0, 1196, 1203, 5, 42, 0, 0, 1197, 1198, 3, 146, 73, 0, 1198, 1199, 6, 55, -1, 0, 1199, 1200, 5, 28, 0, 0, 1200, 1202, 1, 0, 0, 0, 1201, 1197, 1, 0, 0, 0, 1202, 1205, 1, 0, 0, 0, 1203, 1201, 1, 0, 0, 0, 1203, 1204, 1, 0, 0, 0, 1204, 1206, 1, 0, 0, 0, 1205, 1203, 1, 0, 0, 0, 1206, 1207, 3, 146, 73, 0, 1207, 1208, 6, 55, -1, 0, 1208, 1209, 5, 43, 0, 0, 1209, 111, 1, 0, 0, 0, 1210, 1217, 5, 30, 0, 0, 1211, 1212, 3, 114, 57, 0, 1212, 1213, 6, 56, -1, 0, 1213, 1214, 5, 28, 0, 0, 1214, 1216, 1, 0, 0, 0, 1215, 1211, 1, 0, 0, 0, 1216, 1219, 1, 0, 0, 0, 1217, 1215, 1, 0, 0, 0, 1217, 1218, 1, 0, 0, 0, 1218, 1220, 1, 0, 0, 0, 1219, 1217, 1, 0, 0, 0, 1220, 1221, 3, 114, 57, 0, 1221, 1222, 6, 56, -1, 0, 1222, 1223, 5, 31, 0, 0, 1223, 1226, 1, 0, 0, 0, 1224, 1226, 5, 85, 0, 0, 1225, 1210, 1, 0, 0, 0, 1225, 1224, 1, 0, 0, 0, 1226, 113, 1, 0, 0, 0, 1227, 1228, 5, 177, 0, 0, 1228, 1238, 6, 57, -1, 0, 1229, 1230, 3, 230, 115, 0, 1230, 1231, 3, 138, 69, 0, 1231, 1233, 3, 226, 113, 0, 1232, 1234, 3, 0, 0, 0, 1233, 1232, 1, 0, 0, 0, 1233, 1234, 1, 0, 0, 0, 1234, 1235, 1, 0, 0, 0, 1235, 1236, 6, 57, -1, 0, 1236, 1238, 1, 0, 0, 0, 1237, 1227, 1, 0, 0, 0, 1237, 1229, 1, 0, 0, 0, 1238, 115, 1, 0, 0, 0, 1239, 1240, 5, 42, 0, 0, 1240, 1241, 3, 2, 1, 0, 1241, 1242, 5, 43, 0, 0, 1242, 1243, 3, 118, 59, 0, 1243, 1244, 6, 58, -1, 0, 1244, 1277, 1, 0, 0, 0, 1245, 1246, 5, 42, 0, 0, 1246, 1247, 3, 174, 87, 0, 1247, 1248, 5, 43, 0, 0, 1248, 1249, 3, 118, 59, 0, 1249, 1250, 6, 58, -1, 0, 1250, 1277, 1, 0, 0, 0, 1251, 1252, 5, 42, 0, 0, 1252, 1253, 5, 262, 0, 0, 1253, 1254, 5, 43, 0, 0, 1254, 1255, 3, 118, 59, 0, 1255, 1256, 6, 58, -1, 0, 1256, 1277, 1, 0, 0, 0, 1257, 1258, 5, 42, 0, 0, 1258, 1259, 5, 198, 0, 0, 1259, 1260, 3, 2, 1, 0, 1260, 1261, 5, 43, 0, 0, 1261, 1262, 3, 118, 59, 0, 1262, 1263, 6, 58, -1, 0, 1263, 1277, 1, 0, 0, 0, 1264, 1265, 3, 118, 59, 0, 1265, 1266, 6, 58, -1, 0, 1266, 1277, 1, 0, 0, 0, 1267, 1268, 3, 174, 87, 0, 1268, 1269, 6, 58, -1, 0, 1269, 1277, 1, 0, 0, 0, 1270, 1271, 5, 257, 0, 0, 1271, 1277, 6, 58, -1, 0, 1272, 1273, 5, 258, 0, 0, 1273, 1277, 6, 58, -1, 0, 1274, 1275, 5, 259, 0, 0, 1275, 1277, 6, 58, -1, 0, 1276, 1239, 1, 0, 0, 0, 1276, 1245, 1, 0, 0, 0, 1276, 1251, 1, 0, 0, 0, 1276, 1257, 1, 0, 0, 0, 1276, 1264, 1, 0, 0, 0, 1276, 1267, 1, 0, 0, 0, 1276, 1270, 1, 0, 0, 0, 1276, 1272, 1, 0, 0, 0, 1276, 1274, 1, 0, 0, 0, 1277, 117, 1, 0, 0, 0, 1278, 1279, 3, 2, 1, 0, 1279, 1280, 6, 59, -1, 0, 1280, 1281, 5, 88, 0, 0, 1281, 1283, 1, 0, 0, 0, 1282, 1278, 1, 0, 0, 0, 1283, 1286, 1, 0, 0, 0, 1284, 1282, 1, 0, 0, 0, 1284, 1285, 1, 0, 0, 0, 1285, 1287, 1, 0, 0, 0, 1286, 1284, 1, 0, 0, 0, 1287, 1288, 3, 2, 1, 0, 1288, 1289, 6, 59, -1, 0, 1289, 119, 1, 0, 0, 0, 1290, 1292, 3, 122, 61, 0, 1291, 1290, 1, 0, 0, 0, 1292, 1295, 1, 0, 0, 0, 1293, 1291, 1, 0, 0, 0, 1293, 1294, 1, 0, 0, 0, 1294, 121, 1, 0, 0, 0, 1295, 1293, 1, 0, 0, 0, 1296, 1297, 5, 180, 0, 0, 1297, 1298, 5, 89, 0, 0, 1298, 1302, 3, 32, 16, 0, 1299, 1302, 3, 152, 76, 0, 1300, 1302, 3, 332, 166, 0, 1301, 1296, 1, 0, 0, 0, 1301, 1299, 1, 0, 0, 0, 1301, 1300, 1, 0, 0, 0, 1302, 123, 1, 0, 0, 0, 1303, 1304, 3, 116, 58, 0, 1304, 1305, 6, 62, -1, 0, 1305, 1321, 1, 0, 0, 0, 1306, 1307, 5, 42, 0, 0, 1307, 1308, 3, 2, 1, 0, 1308, 1309, 5, 43, 0, 0, 1309, 1310, 6, 62, -1, 0, 1310, 1321, 1, 0, 0, 0, 1311, 1312, 5, 42, 0, 0, 1312, 1313, 5, 198, 0, 0, 1313, 1314, 3, 2, 1, 0, 1314, 1315, 5, 43, 0, 0, 1315, 1316, 6, 62, -1, 0, 1316, 1321, 1, 0, 0, 0, 1317, 1318, 3, 138, 69, 0, 1318, 1319, 6, 62, -1, 0, 1319, 1321, 1, 0, 0, 0, 1320, 1303, 1, 0, 0, 0, 1320, 1306, 1, 0, 0, 0, 1320, 1311, 1, 0, 0, 0, 1320, 1317, 1, 0, 0, 0, 1321, 125, 1, 0, 0, 0, 1322, 1334, 1, 0, 0, 0, 1323, 1324, 3, 130, 65, 0, 1324, 1330, 6, 63, -1, 0, 1325, 1326, 3, 128, 64, 0, 1326, 1327, 6, 63, -1, 0, 1327, 1329, 1, 0, 0, 0, 1328, 1325, 1, 0, 0, 0, 1329, 1332, 1, 0, 0, 0, 1330, 1328, 1, 0, 0, 0, 1330, 1331, 1, 0, 0, 0, 1331, 1334, 1, 0, 0, 0, 1332, 1330, 1, 0, 0, 0, 1333, 1322, 1, 0, 0, 0, 1333, 1323, 1, 0, 0, 0, 1334, 127, 1, 0, 0, 0, 1335, 1336, 5, 262, 0, 0, 1336, 1358, 6, 64, -1, 0, 1337, 1338, 5, 261, 0, 0, 1338, 1358, 6, 64, -1, 0, 1339, 1340, 5, 42, 0, 0, 1340, 1341, 3, 32, 16, 0, 1341, 1342, 5, 43, 0, 0, 1342, 1343, 6, 64, -1, 0, 1343, 1358, 1, 0, 0, 0, 1344, 1345, 5, 42, 0, 0, 1345, 1346, 3, 32, 16, 0, 1346, 1347, 5, 266, 0, 0, 1347, 1348, 3, 32, 16, 0, 1348, 1349, 5, 43, 0, 0, 1349, 1350, 6, 64, -1, 0, 1350, 1358, 1, 0, 0, 0, 1351, 1352, 5, 42, 0, 0, 1352, 1353, 5, 266, 0, 0, 1353, 1354, 3, 32, 16, 0, 1354, 1355, 5, 43, 0, 0, 1355, 1356, 6, 64, -1, 0, 1356, 1358, 1, 0, 0, 0, 1357, 1335, 1, 0, 0, 0, 1357, 1337, 1, 0, 0, 0, 1357, 1339, 1, 0, 0, 0, 1357, 1344, 1, 0, 0, 0, 1357, 1351, 1, 0, 0, 0, 1358, 129, 1, 0, 0, 0, 1359, 1505, 6, 65, -1, 0, 1360, 1361, 5, 203, 0, 0, 1361, 1362, 5, 30, 0, 0, 1362, 1363, 3, 6, 3, 0, 1363, 1364, 5, 28, 0, 0, 1364, 1365, 3, 6, 3, 0, 1365, 1366, 5, 28, 0, 0, 1366, 1367, 3, 6, 3, 0, 1367, 1368, 5, 28, 0, 0, 1368, 1369, 3, 6, 3, 0, 1369, 1370, 5, 31, 0, 0, 1370, 1371, 6, 65, -1, 0, 1371, 1505, 1, 0, 0, 0, 1372, 1373, 5, 203, 0, 0, 1373, 1374, 5, 30, 0, 0, 1374, 1375, 3, 6, 3, 0, 1375, 1376, 5, 28, 0, 0, 1376, 1377, 3, 6, 3, 0, 1377, 1378, 5, 31, 0, 0, 1378, 1379, 6, 65, -1, 0, 1379, 1505, 1, 0, 0, 0, 1380, 1381, 5, 204, 0, 0, 1381, 1382, 5, 205, 0, 0, 1382, 1383, 5, 42, 0, 0, 1383, 1384, 3, 32, 16, 0, 1384, 1385, 5, 43, 0, 0, 1385, 1386, 6, 65, -1, 0, 1386, 1505, 1, 0, 0, 0, 1387, 1388, 5, 204, 0, 0, 1388, 1389, 5, 206, 0, 0, 1389, 1390, 5, 42, 0, 0, 1390, 1391, 3, 32, 16, 0, 1391, 1392, 5, 43, 0, 0, 1392, 1393, 3, 126, 63, 0, 1393, 1394, 6, 65, -1, 0, 1394, 1505, 1, 0, 0, 0, 1395, 1396, 5, 207, 0, 0, 1396, 1505, 6, 65, -1, 0, 1397, 1398, 5, 208, 0, 0, 1398, 1505, 6, 65, -1, 0, 1399, 1400, 5, 209, 0, 0, 1400, 1505, 6, 65, -1, 0, 1401, 1402, 5, 201, 0, 0, 1402, 1505, 6, 65, -1, 0, 1403, 1404, 5, 183, 0, 0, 1404, 1505, 6, 65, -1, 0, 1405, 1406, 5, 184, 0, 0, 1406, 1505, 6, 65, -1, 0, 1407, 1408, 5, 185, 0, 0, 1408, 1505, 6, 65, -1, 0, 1409, 1410, 5, 186, 0, 0, 1410, 1505, 6, 65, -1, 0, 1411, 1412, 5, 187, 0, 0, 1412, 1505, 6, 65, -1, 0, 1413, 1414, 5, 188, 0, 0, 1414, 1505, 6, 65, -1, 0, 1415, 1416, 5, 189, 0, 0, 1416, 1505, 6, 65, -1, 0, 1417, 1418, 5, 210, 0, 0, 1418, 1505, 6, 65, -1, 0, 1419, 1420, 5, 190, 0, 0, 1420, 1505, 6, 65, -1, 0, 1421, 1422, 5, 191, 0, 0, 1422, 1505, 6, 65, -1, 0, 1423, 1424, 5, 192, 0, 0, 1424, 1505, 6, 65, -1, 0, 1425, 1426, 5, 193, 0, 0, 1426, 1505, 6, 65, -1, 0, 1427, 1428, 5, 211, 0, 0, 1428, 1505, 6, 65, -1, 0, 1429, 1430, 5, 212, 0, 0, 1430, 1505, 6, 65, -1, 0, 1431, 1432, 5, 213, 0, 0, 1432, 1505, 6, 65, -1, 0, 1433, 1434, 5, 214, 0, 0, 1434, 1505, 6, 65, -1, 0, 1435, 1436, 5, 215, 0, 0, 1436, 1505, 6, 65, -1, 0, 1437, 1438, 5, 216, 0, 0, 1438, 1505, 6, 65, -1, 0, 1439, 1440, 5, 217, 0, 0, 1440, 1505, 6, 65, -1, 0, 1441, 1442, 5, 218, 0, 0, 1442, 1443, 3, 132, 66, 0, 1443, 1444, 6, 65, -1, 0, 1444, 1505, 1, 0, 0, 0, 1445, 1446, 5, 219, 0, 0, 1446, 1447, 3, 132, 66, 0, 1447, 1448, 6, 65, -1, 0, 1448, 1505, 1, 0, 0, 0, 1449, 1450, 5, 220, 0, 0, 1450, 1505, 6, 65, -1, 0, 1451, 1452, 5, 221, 0, 0, 1452, 1453, 3, 132, 66, 0, 1453, 1454, 6, 65, -1, 0, 1454, 1505, 1, 0, 0, 0, 1455, 1456, 5, 222, 0, 0, 1456, 1457, 3, 134, 67, 0, 1457, 1458, 6, 65, -1, 0, 1458, 1505, 1, 0, 0, 0, 1459, 1460, 5, 222, 0, 0, 1460, 1461, 3, 134, 67, 0, 1461, 1462, 5, 28, 0, 0, 1462, 1463, 3, 6, 3, 0, 1463, 1464, 6, 65, -1, 0, 1464, 1505, 1, 0, 0, 0, 1465, 1466, 5, 194, 0, 0, 1466, 1505, 6, 65, -1, 0, 1467, 1468, 5, 195, 0, 0, 1468, 1505, 6, 65, -1, 0, 1469, 1470, 5, 90, 0, 0, 1470, 1471, 5, 184, 0, 0, 1471, 1505, 6, 65, -1, 0, 1472, 1473, 5, 90, 0, 0, 1473, 1474, 5, 185, 0, 0, 1474, 1505, 6, 65, -1, 0, 1475, 1476, 5, 90, 0, 0, 1476, 1477, 5, 186, 0, 0, 1477, 1505, 6, 65, -1, 0, 1478, 1479, 5, 90, 0, 0, 1479, 1480, 5, 187, 0, 0, 1480, 1505, 6, 65, -1, 0, 1481, 1482, 5, 62, 0, 0, 1482, 1483, 5, 220, 0, 0, 1483, 1505, 6, 65, -1, 0, 1484, 1485, 5, 223, 0, 0, 1485, 1505, 6, 65, -1, 0, 1486, 1487, 5, 224, 0, 0, 1487, 1488, 5, 213, 0, 0, 1488, 1505, 6, 65, -1, 0, 1489, 1490, 5, 225, 0, 0, 1490, 1505, 6, 65, -1, 0, 1491, 1492, 5, 207, 0, 0, 1492, 1493, 5, 183, 0, 0, 1493, 1505, 6, 65, -1, 0, 1494, 1495, 5, 226, 0, 0, 1495, 1505, 6, 65, -1, 0, 1496, 1497, 5, 228, 0, 0, 1497, 1505, 6, 65, -1, 0, 1498, 1499, 5, 34, 0, 0, 1499, 1500, 5, 227, 0, 0, 1500, 1505, 6, 65, -1, 0, 1501, 1502, 3, 2, 1, 0, 1502, 1503, 6, 65, -1, 0, 1503, 1505, 1, 0, 0, 0, 1504, 1359, 1, 0, 0, 0, 1504, 1360, 1, 0, 0, 0, 1504, 1372, 1, 0, 0, 0, 1504, 1380, 1, 0, 0, 0, 1504, 1387, 1, 0, 0, 0, 1504, 1395, 1, 0, 0, 0, 1504, 1397, 1, 0, 0, 0, 1504, 1399, 1, 0, 0, 0, 1504, 1401, 1, 0, 0, 0, 1504, 1403, 1, 0, 0, 0, 1504, 1405, 1, 0, 0, 0, 1504, 1407, 1, 0, 0, 0, 1504, 1409, 1, 0, 0, 0, 1504, 1411, 1, 0, 0, 0, 1504, 1413, 1, 0, 0, 0, 1504, 1415, 1, 0, 0, 0, 1504, 1417, 1, 0, 0, 0, 1504, 1419, 1, 0, 0, 0, 1504, 1421, 1, 0, 0, 0, 1504, 1423, 1, 0, 0, 0, 1504, 1425, 1, 0, 0, 0, 1504, 1427, 1, 0, 0, 0, 1504, 1429, 1, 0, 0, 0, 1504, 1431, 1, 0, 0, 0, 1504, 1433, 1, 0, 0, 0, 1504, 1435, 1, 0, 0, 0, 1504, 1437, 1, 0, 0, 0, 1504, 1439, 1, 0, 0, 0, 1504, 1441, 1, 0, 0, 0, 1504, 1445, 1, 0, 0, 0, 1504, 1449, 1, 0, 0, 0, 1504, 1451, 1, 0, 0, 0, 1504, 1455, 1, 0, 0, 0, 1504, 1459, 1, 0, 0, 0, 1504, 1465, 1, 0, 0, 0, 1504, 1467, 1, 0, 0, 0, 1504, 1469, 1, 0, 0, 0, 1504, 1472, 1, 0, 0, 0, 1504, 1475, 1, 0, 0, 0, 1504, 1478, 1, 0, 0, 0, 1504, 1481, 1, 0, 0, 0, 1504, 1484, 1, 0, 0, 0, 1504, 1486, 1, 0, 0, 0, 1504, 1489, 1, 0, 0, 0, 1504, 1491, 1, 0, 0, 0, 1504, 1494, 1, 0, 0, 0, 1504, 1496, 1, 0, 0, 0, 1504, 1498, 1, 0, 0, 0, 1504, 1501, 1, 0, 0, 0, 1505, 131, 1, 0, 0, 0, 1506, 1515, 1, 0, 0, 0, 1507, 1508, 5, 30, 0, 0, 1508, 1509, 5, 91, 0, 0, 1509, 1510, 5, 36, 0, 0, 1510, 1511, 3, 32, 16, 0, 1511, 1512, 5, 31, 0, 0, 1512, 1513, 6, 66, -1, 0, 1513, 1515, 1, 0, 0, 0, 1514, 1506, 1, 0, 0, 0, 1514, 1507, 1, 0, 0, 0, 1515, 133, 1, 0, 0, 0, 1516, 1527, 1, 0, 0, 0, 1517, 1518, 3, 136, 68, 0, 1518, 1523, 6, 67, -1, 0, 1519, 1520, 7, 7, 0, 0, 1520, 1522, 6, 67, -1, 0, 1521, 1519, 1, 0, 0, 0, 1522, 1525, 1, 0, 0, 0, 1523, 1521, 1, 0, 0, 0, 1523, 1524, 1, 0, 0, 0, 1524, 1527, 1, 0, 0, 0, 1525, 1523, 1, 0, 0, 0, 1526, 1516, 1, 0, 0, 0, 1526, 1517, 1, 0, 0, 0, 1527, 135, 1, 0, 0, 0, 1528, 1529, 5, 178, 0, 0, 1529, 1609, 6, 68, -1, 0, 1530, 1531, 5, 207, 0, 0, 1531, 1609, 6, 68, -1, 0, 1532, 1533, 5, 208, 0, 0, 1533, 1609, 6, 68, -1, 0, 1534, 1535, 5, 201, 0, 0, 1535, 1609, 6, 68, -1, 0, 1536, 1537, 5, 183, 0, 0, 1537, 1609, 6, 68, -1, 0, 1538, 1539, 5, 184, 0, 0, 1539, 1609, 6, 68, -1, 0, 1540, 1541, 5, 185, 0, 0, 1541, 1609, 6, 68, -1, 0, 1542, 1543, 5, 186, 0, 0, 1543, 1609, 6, 68, -1, 0, 1544, 1545, 5, 187, 0, 0, 1545, 1609, 6, 68, -1, 0, 1546, 1547, 5, 188, 0, 0, 1547, 1609, 6, 68, -1, 0, 1548, 1549, 5, 189, 0, 0, 1549, 1609, 6, 68, -1, 0, 1550, 1551, 5, 190, 0, 0, 1551, 1609, 6, 68, -1, 0, 1552, 1553, 5, 191, 0, 0, 1553, 1609, 6, 68, -1, 0, 1554, 1555, 5, 192, 0, 0, 1555, 1609, 6, 68, -1, 0, 1556, 1557, 5, 193, 0, 0, 1557, 1609, 6, 68, -1, 0, 1558, 1559, 5, 262, 0, 0, 1559, 1609, 6, 68, -1, 0, 1560, 1561, 5, 211, 0, 0, 1561, 1609, 6, 68, -1, 0, 1562, 1563, 5, 212, 0, 0, 1563, 1609, 6, 68, -1, 0, 1564, 1565, 5, 213, 0, 0, 1565, 1609, 6, 68, -1, 0, 1566, 1567, 5, 214, 0, 0, 1567, 1609, 6, 68, -1, 0, 1568, 1569, 5, 215, 0, 0, 1569, 1609, 6, 68, -1, 0, 1570, 1571, 5, 218, 0, 0, 1571, 1609, 6, 68, -1, 0, 1572, 1573, 5, 219, 0, 0, 1573, 1609, 6, 68, -1, 0, 1574, 1575, 5, 222, 0, 0, 1575, 1609, 6, 68, -1, 0, 1576, 1577, 5, 194, 0, 0, 1577, 1609, 6, 68, -1, 0, 1578, 1579, 5, 195, 0, 0, 1579, 1609, 6, 68, -1, 0, 1580, 1581, 5, 210, 0, 0, 1581, 1609, 6, 68, -1, 0, 1582, 1583, 5, 230, 0, 0, 1583, 1609, 6, 68, -1, 0, 1584, 1585, 5, 231, 0, 0, 1585, 1609, 6, 68, -1, 0, 1586, 1587, 5, 232, 0, 0, 1587, 1609, 6, 68, -1, 0, 1588, 1589, 5, 233, 0, 0, 1589, 1609, 6, 68, -1, 0, 1590, 1591, 5, 234, 0, 0, 1591, 1609, 6, 68, -1, 0, 1592, 1593, 5, 235, 0, 0, 1593, 1609, 6, 68, -1, 0, 1594, 1595, 5, 236, 0, 0, 1595, 1609, 6, 68, -1, 0, 1596, 1597, 5, 237, 0, 0, 1597, 1609, 6, 68, -1, 0, 1598, 1599, 5, 238, 0, 0, 1599, 1609, 6, 68, -1, 0, 1600, 1601, 5, 239, 0, 0, 1601, 1609, 6, 68, -1, 0, 1602, 1603, 5, 240, 0, 0, 1603, 1609, 6, 68, -1, 0, 1604, 1605, 5, 241, 0, 0, 1605, 1609, 6, 68, -1, 0, 1606, 1607, 5, 242, 0, 0, 1607, 1609, 6, 68, -1, 0, 1608, 1528, 1, 0, 0, 0, 1608, 1530, 1, 0, 0, 0, 1608, 1532, 1, 0, 0, 0, 1608, 1534, 1, 0, 0, 0, 1608, 1536, 1, 0, 0, 0, 1608, 1538, 1, 0, 0, 0, 1608, 1540, 1, 0, 0, 0, 1608, 1542, 1, 0, 0, 0, 1608, 1544, 1, 0, 0, 0, 1608, 1546, 1, 0, 0, 0, 1608, 1548, 1, 0, 0, 0, 1608, 1550, 1, 0, 0, 0, 1608, 1552, 1, 0, 0, 0, 1608, 1554, 1, 0, 0, 0, 1608, 1556, 1, 0, 0, 0, 1608, 1558, 1, 0, 0, 0, 1608, 1560, 1, 0, 0, 0, 1608, 1562, 1, 0, 0, 0, 1608, 1564, 1, 0, 0, 0, 1608, 1566, 1, 0, 0, 0, 1608, 1568, 1, 0, 0, 0, 1608, 1570, 1, 0, 0, 0, 1608, 1572, 1, 0, 0, 0, 1608, 1574, 1, 0, 0, 0, 1608, 1576, 1, 0, 0, 0, 1608, 1578, 1, 0, 0, 0, 1608, 1580, 1, 0, 0, 0, 1608, 1582, 1, 0, 0, 0, 1608, 1584, 1, 0, 0, 0, 1608, 1586, 1, 0, 0, 0, 1608, 1588, 1, 0, 0, 0, 1608, 1590, 1, 0, 0, 0, 1608, 1592, 1, 0, 0, 0, 1608, 1594, 1, 0, 0, 0, 1608, 1596, 1, 0, 0, 0, 1608, 1598, 1, 0, 0, 0, 1608, 1600, 1, 0, 0, 0, 1608, 1602, 1, 0, 0, 0, 1608, 1604, 1, 0, 0, 0, 1608, 1606, 1, 0, 0, 0, 1609, 137, 1, 0, 0, 0, 1610, 1611, 3, 142, 71, 0, 1611, 1617, 6, 69, -1, 0, 1612, 1613, 3, 140, 70, 0, 1613, 1614, 6, 69, -1, 0, 1614, 1616, 1, 0, 0, 0, 1615, 1612, 1, 0, 0, 0, 1616, 1619, 1, 0, 0, 0, 1617, 1615, 1, 0, 0, 0, 1617, 1618, 1, 0, 0, 0, 1618, 139, 1, 0, 0, 0, 1619, 1617, 1, 0, 0, 0, 1620, 1621, 5, 261, 0, 0, 1621, 1650, 6, 70, -1, 0, 1622, 1623, 5, 42, 0, 0, 1623, 1624, 5, 43, 0, 0, 1624, 1650, 6, 70, -1, 0, 1625, 1626, 3, 110, 55, 0, 1626, 1627, 6, 70, -1, 0, 1627, 1650, 1, 0, 0, 0, 1628, 1629, 5, 260, 0, 0, 1629, 1650, 6, 70, -1, 0, 1630, 1631, 5, 262, 0, 0, 1631, 1650, 6, 70, -1, 0, 1632, 1633, 5, 92, 0, 0, 1633, 1650, 6, 70, -1, 0, 1634, 1635, 5, 93, 0, 0, 1635, 1636, 5, 30, 0, 0, 1636, 1637, 3, 124, 62, 0, 1637, 1638, 5, 31, 0, 0, 1638, 1639, 6, 70, -1, 0, 1639, 1650, 1, 0, 0, 0, 1640, 1641, 5, 94, 0, 0, 1641, 1642, 5, 30, 0, 0, 1642, 1643, 3, 124, 62, 0, 1643, 1644, 5, 31, 0, 0, 1644, 1645, 6, 70, -1, 0, 1645, 1650, 1, 0, 0, 0, 1646, 1647, 3, 108, 54, 0, 1647, 1648, 6, 70, -1, 0, 1648, 1650, 1, 0, 0, 0, 1649, 1620, 1, 0, 0, 0, 1649, 1622, 1, 0, 0, 0, 1649, 1625, 1, 0, 0, 0, 1649, 1628, 1, 0, 0, 0, 1649, 1630, 1, 0, 0, 0, 1649, 1632, 1, 0, 0, 0, 1649, 1634, 1, 0, 0, 0, 1649, 1640, 1, 0, 0, 0, 1649, 1646, 1, 0, 0, 0, 1650, 141, 1, 0, 0, 0, 1651, 1652, 5, 39, 0, 0, 1652, 1653, 3, 116, 58, 0, 1653, 1654, 6, 71, -1, 0, 1654, 1710, 1, 0, 0, 0, 1655, 1656, 5, 197, 0, 0, 1656, 1710, 6, 71, -1, 0, 1657, 1658, 5, 199, 0, 0, 1658, 1659, 5, 39, 0, 0, 1659, 1660, 3, 116, 58, 0, 1660, 1661, 6, 71, -1, 0, 1661, 1710, 1, 0, 0, 0, 1662, 1663, 5, 200, 0, 0, 1663, 1664, 3, 116, 58, 0, 1664, 1665, 6, 71, -1, 0, 1665, 1710, 1, 0, 0, 0, 1666, 1667, 5, 226, 0, 0, 1667, 1668, 3, 170, 85, 0, 1668, 1669, 3, 138, 69, 0, 1669, 1670, 5, 262, 0, 0, 1670, 1671, 3, 112, 56, 0, 1671, 1672, 6, 71, -1, 0, 1672, 1710, 1, 0, 0, 0, 1673, 1674, 5, 253, 0, 0, 1674, 1675, 3, 32, 16, 0, 1675, 1676, 6, 71, -1, 0, 1676, 1710, 1, 0, 0, 0, 1677, 1678, 5, 252, 0, 0, 1678, 1679, 3, 32, 16, 0, 1679, 1680, 6, 71, -1, 0, 1680, 1710, 1, 0, 0, 0, 1681, 1682, 5, 253, 0, 0, 1682, 1683, 3, 2, 1, 0, 1683, 1684, 6, 71, -1, 0, 1684, 1710, 1, 0, 0, 0, 1685, 1686, 5, 252, 0, 0, 1686, 1687, 3, 2, 1, 0, 1687, 1688, 6, 71, -1, 0, 1688, 1710, 1, 0, 0, 0, 1689, 1690, 5, 254, 0, 0, 1690, 1710, 6, 71, -1, 0, 1691, 1692, 5, 201, 0, 0, 1692, 1710, 6, 71, -1, 0, 1693, 1694, 3, 148, 74, 0, 1694, 1695, 6, 71, -1, 0, 1695, 1710, 1, 0, 0, 0, 1696, 1697, 3, 150, 75, 0, 1697, 1698, 6, 71, -1, 0, 1698, 1710, 1, 0, 0, 0, 1699, 1700, 3, 144, 72, 0, 1700, 1701, 6, 71, -1, 0, 1701, 1710, 1, 0, 0, 0, 1702, 1703, 3, 2, 1, 0, 1703, 1704, 6, 71, -1, 0, 1704, 1710, 1, 0, 0, 0, 1705, 1706, 5, 177, 0, 0, 1706, 1707, 3, 138, 69, 0, 1707, 1708, 6, 71, -1, 0, 1708, 1710, 1, 0, 0, 0, 1709, 1651, 1, 0, 0, 0, 1709, 1655, 1, 0, 0, 0, 1709, 1657, 1, 0, 0, 0, 1709, 1662, 1, 0, 0, 0, 1709, 1666, 1, 0, 0, 0, 1709, 1673, 1, 0, 0, 0, 1709, 1677, 1, 0, 0, 0, 1709, 1681, 1, 0, 0, 0, 1709, 1685, 1, 0, 0, 0, 1709, 1689, 1, 0, 0, 0, 1709, 1691, 1, 0, 0, 0, 1709, 1693, 1, 0, 0, 0, 1709, 1696, 1, 0, 0, 0, 1709, 1699, 1, 0, 0, 0, 1709, 1702, 1, 0, 0, 0, 1709, 1705, 1, 0, 0, 0, 1710, 143, 1, 0, 0, 0, 1711, 1712, 5, 181, 0, 0, 1712, 1750, 6, 72, -1, 0, 1713, 1714, 5, 182, 0, 0, 1714, 1750, 6, 72, -1, 0, 1715, 1716, 5, 183, 0, 0, 1716, 1750, 6, 72, -1, 0, 1717, 1718, 5, 184, 0, 0, 1718, 1750, 6, 72, -1, 0, 1719, 1720, 5, 185, 0, 0, 1720, 1750, 6, 72, -1, 0, 1721, 1722, 5, 186, 0, 0, 1722, 1750, 6, 72, -1, 0, 1723, 1724, 5, 187, 0, 0, 1724, 1750, 6, 72, -1, 0, 1725, 1726, 5, 188, 0, 0, 1726, 1750, 6, 72, -1, 0, 1727, 1728, 5, 189, 0, 0, 1728, 1750, 6, 72, -1, 0, 1729, 1730, 5, 190, 0, 0, 1730, 1750, 6, 72, -1, 0, 1731, 1732, 5, 191, 0, 0, 1732, 1750, 6, 72, -1, 0, 1733, 1734, 5, 192, 0, 0, 1734, 1750, 6, 72, -1, 0, 1735, 1736, 5, 193, 0, 0, 1736, 1750, 6, 72, -1, 0, 1737, 1738, 5, 90, 0, 0, 1738, 1739, 5, 184, 0, 0, 1739, 1750, 6, 72, -1, 0, 1740, 1741, 5, 90, 0, 0, 1741, 1742, 5, 185, 0, 0, 1742, 1750, 6, 72, -1, 0, 1743, 1744, 5, 90, 0, 0, 1744, 1745, 5, 186, 0, 0, 1745, 1750, 6, 72, -1, 0, 1746, 1747, 5, 90, 0, 0, 1747, 1748, 5, 187, 0, 0, 1748, 1750, 6, 72, -1, 0, 1749, 1711, 1, 0, 0, 0, 1749, 1713, 1, 0, 0, 0, 1749, 1715, 1, 0, 0, 0, 1749, 1717, 1, 0, 0, 0, 1749, 1719, 1, 0, 0, 0, 1749, 1721, 1, 0, 0, 0, 1749, 1723, 1, 0, 0, 0, 1749, 1725, 1, 0, 0, 0, 1749, 1727, 1, 0, 0, 0, 1749, 1729, 1, 0, 0, 0, 1749, 1731, 1, 0, 0, 0, 1749, 1733, 1, 0, 0, 0, 1749, 1735, 1, 0, 0, 0, 1749, 1737, 1, 0, 0, 0, 1749, 1740, 1, 0, 0, 0, 1749, 1743, 1, 0, 0, 0, 1749, 1746, 1, 0, 0, 0, 1750, 145, 1, 0, 0, 0, 1751, 1766, 1, 0, 0, 0, 1752, 1766, 5, 177, 0, 0, 1753, 1754, 3, 32, 16, 0, 1754, 1755, 6, 73, -1, 0, 1755, 1766, 1, 0, 0, 0, 1756, 1757, 3, 32, 16, 0, 1757, 1758, 5, 177, 0, 0, 1758, 1759, 3, 32, 16, 0, 1759, 1760, 6, 73, -1, 0, 1760, 1766, 1, 0, 0, 0, 1761, 1762, 3, 32, 16, 0, 1762, 1763, 5, 177, 0, 0, 1763, 1764, 6, 73, -1, 0, 1764, 1766, 1, 0, 0, 0, 1765, 1751, 1, 0, 0, 0, 1765, 1752, 1, 0, 0, 0, 1765, 1753, 1, 0, 0, 0, 1765, 1756, 1, 0, 0, 0, 1765, 1761, 1, 0, 0, 0, 1766, 147, 1, 0, 0, 0, 1767, 1768, 5, 1, 0, 0, 1768, 1769, 5, 194, 0, 0, 1769, 1770, 6, 74, -1, 0, 1770, 149, 1, 0, 0, 0, 1771, 1775, 5, 1, 0, 0, 1772, 1773, 5, 90, 0, 0, 1773, 1776, 5, 194, 0, 0, 1774, 1776, 5, 195, 0, 0, 1775, 1772, 1, 0, 0, 0, 1775, 1774, 1, 0, 0, 0, 1776, 1777, 1, 0, 0, 0, 1777, 1778, 6, 75, -1, 0, 1778, 151, 1, 0, 0, 0, 1779, 1780, 5, 294, 0, 0, 1780, 1781, 3, 166, 83, 0, 1781, 1782, 3, 124, 62, 0, 1782, 1783, 5, 30, 0, 0, 1783, 1784, 3, 158, 79, 0, 1784, 1785, 5, 31, 0, 0, 1785, 1827, 1, 0, 0, 0, 1786, 1787, 5, 294, 0, 0, 1787, 1788, 3, 166, 83, 0, 1788, 1789, 3, 124, 62, 0, 1789, 1790, 5, 36, 0, 0, 1790, 1791, 5, 17, 0, 0, 1791, 1792, 3, 52, 26, 0, 1792, 1793, 5, 18, 0, 0, 1793, 1827, 1, 0, 0, 0, 1794, 1795, 5, 294, 0, 0, 1795, 1796, 3, 166, 83, 0, 1796, 1797, 3, 124, 62, 0, 1797, 1827, 1, 0, 0, 0, 1798, 1799, 5, 295, 0, 0, 1799, 1800, 3, 166, 83, 0, 1800, 1802, 5, 36, 0, 0, 1801, 1803, 5, 84, 0, 0, 1802, 1801, 1, 0, 0, 0, 1802, 1803, 1, 0, 0, 0, 1803, 1804, 1, 0, 0, 0, 1804, 1805, 5, 30, 0, 0, 1805, 1806, 3, 300, 150, 0, 1806, 1807, 5, 31, 0, 0, 1807, 1827, 1, 0, 0, 0, 1808, 1809, 5, 295, 0, 0, 1809, 1810, 3, 166, 83, 0, 1810, 1811, 5, 84, 0, 0, 1811, 1812, 5, 30, 0, 0, 1812, 1813, 3, 300, 150, 0, 1813, 1814, 5, 31, 0, 0, 1814, 1827, 1, 0, 0, 0, 1815, 1816, 5, 295, 0, 0, 1816, 1817, 3, 166, 83, 0, 1817, 1818, 3, 6, 3, 0, 1818, 1827, 1, 0, 0, 0, 1819, 1820, 5, 295, 0, 0, 1820, 1821, 3, 166, 83, 0, 1821, 1822, 5, 36, 0, 0, 1822, 1823, 5, 17, 0, 0, 1823, 1824, 3, 154, 77, 0, 1824, 1825, 5, 18, 0, 0, 1825, 1827, 1, 0, 0, 0, 1826, 1779, 1, 0, 0, 0, 1826, 1786, 1, 0, 0, 0, 1826, 1794, 1, 0, 0, 0, 1826, 1798, 1, 0, 0, 0, 1826, 1808, 1, 0, 0, 0, 1826, 1815, 1, 0, 0, 0, 1826, 1819, 1, 0, 0, 0, 1827, 153, 1, 0, 0, 0, 1828, 1839, 1, 0, 0, 0, 1829, 1830, 3, 156, 78, 0, 1830, 1831, 5, 28, 0, 0, 1831, 1833, 1, 0, 0, 0, 1832, 1829, 1, 0, 0, 0, 1833, 1836, 1, 0, 0, 0, 1834, 1832, 1, 0, 0, 0, 1834, 1835, 1, 0, 0, 0, 1835, 1837, 1, 0, 0, 0, 1836, 1834, 1, 0, 0, 0, 1837, 1839, 3, 156, 78, 0, 1838, 1828, 1, 0, 0, 0, 1838, 1834, 1, 0, 0, 0, 1839, 155, 1, 0, 0, 0, 1840, 1841, 5, 39, 0, 0, 1841, 1842, 5, 264, 0, 0, 1842, 1843, 5, 36, 0, 0, 1843, 1844, 5, 17, 0, 0, 1844, 1845, 3, 56, 28, 0, 1845, 1846, 5, 18, 0, 0, 1846, 1854, 1, 0, 0, 0, 1847, 1848, 3, 124, 62, 0, 1848, 1849, 5, 36, 0, 0, 1849, 1850, 5, 17, 0, 0, 1850, 1851, 3, 56, 28, 0, 1851, 1852, 5, 18, 0, 0, 1852, 1854, 1, 0, 0, 0, 1853, 1840, 1, 0, 0, 0, 1853, 1847, 1, 0, 0, 0, 1854, 157, 1, 0, 0, 0, 1855, 1856, 3, 160, 80, 0, 1856, 1857, 5, 28, 0, 0, 1857, 1859, 1, 0, 0, 0, 1858, 1855, 1, 0, 0, 0, 1859, 1862, 1, 0, 0, 0, 1860, 1858, 1, 0, 0, 0, 1860, 1861, 1, 0, 0, 0, 1861, 1863, 1, 0, 0, 0, 1862, 1860, 1, 0, 0, 0, 1863, 1864, 3, 160, 80, 0, 1864, 159, 1, 0, 0, 0, 1865, 1866, 3, 6, 3, 0, 1866, 1867, 5, 36, 0, 0, 1867, 1868, 3, 164, 82, 0, 1868, 161, 1, 0, 0, 0, 1869, 1870, 7, 8, 0, 0, 1870, 163, 1, 0, 0, 0, 1871, 1906, 3, 162, 81, 0, 1872, 1906, 3, 32, 16, 0, 1873, 1874, 5, 186, 0, 0, 1874, 1875, 5, 30, 0, 0, 1875, 1876, 3, 32, 16, 0, 1876, 1877, 5, 31, 0, 0, 1877, 1906, 1, 0, 0, 0, 1878, 1906, 3, 6, 3, 0, 1879, 1880, 3, 116, 58, 0, 1880, 1881, 5, 30, 0, 0, 1881, 1882, 5, 184, 0, 0, 1882, 1883, 5, 75, 0, 0, 1883, 1884, 3, 32, 16, 0, 1884, 1885, 5, 31, 0, 0, 1885, 1906, 1, 0, 0, 0, 1886, 1887, 3, 116, 58, 0, 1887, 1888, 5, 30, 0, 0, 1888, 1889, 5, 185, 0, 0, 1889, 1890, 5, 75, 0, 0, 1890, 1891, 3, 32, 16, 0, 1891, 1892, 5, 31, 0, 0, 1892, 1906, 1, 0, 0, 0, 1893, 1894, 3, 116, 58, 0, 1894, 1895, 5, 30, 0, 0, 1895, 1896, 5, 186, 0, 0, 1896, 1897, 5, 75, 0, 0, 1897, 1898, 3, 32, 16, 0, 1898, 1899, 5, 31, 0, 0, 1899, 1906, 1, 0, 0, 0, 1900, 1901, 3, 116, 58, 0, 1901, 1902, 5, 30, 0, 0, 1902, 1903, 3, 32, 16, 0, 1903, 1904, 5, 31, 0, 0, 1904, 1906, 1, 0, 0, 0, 1905, 1871, 1, 0, 0, 0, 1905, 1872, 1, 0, 0, 0, 1905, 1873, 1, 0, 0, 0, 1905, 1878, 1, 0, 0, 0, 1905, 1879, 1, 0, 0, 0, 1905, 1886, 1, 0, 0, 0, 1905, 1893, 1, 0, 0, 0, 1905, 1900, 1, 0, 0, 0, 1906, 165, 1, 0, 0, 0, 1907, 1908, 7, 9, 0, 0, 1908, 167, 1, 0, 0, 0, 1909, 1910, 3, 170, 85, 0, 1910, 1911, 3, 138, 69, 0, 1911, 1912, 3, 124, 62, 0, 1912, 1913, 5, 176, 0, 0, 1913, 1915, 3, 242, 121, 0, 1914, 1916, 3, 108, 54, 0, 1915, 1914, 1, 0, 0, 0, 1915, 1916, 1, 0, 0, 0, 1916, 1917, 1, 0, 0, 0, 1917, 1918, 3, 112, 56, 0, 1918, 1919, 6, 84, -1, 0, 1919, 1952, 1, 0, 0, 0, 1920, 1921, 3, 170, 85, 0, 1921, 1922, 3, 138, 69, 0, 1922, 1923, 3, 124, 62, 0, 1923, 1924, 5, 176, 0, 0, 1924, 1925, 3, 242, 121, 0, 1925, 1926, 3, 196, 98, 0, 1926, 1927, 3, 112, 56, 0, 1927, 1928, 6, 84, -1, 0, 1928, 1952, 1, 0, 0, 0, 1929, 1930, 3, 170, 85, 0, 1930, 1931, 3, 138, 69, 0, 1931, 1933, 3, 242, 121, 0, 1932, 1934, 3, 108, 54, 0, 1933, 1932, 1, 0, 0, 0, 1933, 1934, 1, 0, 0, 0, 1934, 1935, 1, 0, 0, 0, 1935, 1936, 3, 112, 56, 0, 1936, 1937, 6, 84, -1, 0, 1937, 1952, 1, 0, 0, 0, 1938, 1939, 3, 170, 85, 0, 1939, 1940, 3, 138, 69, 0, 1940, 1941, 3, 242, 121, 0, 1941, 1942, 3, 196, 98, 0, 1942, 1943, 3, 112, 56, 0, 1943, 1944, 6, 84, -1, 0, 1944, 1952, 1, 0, 0, 0, 1945, 1946, 3, 174, 87, 0, 1946, 1947, 6, 84, -1, 0, 1947, 1952, 1, 0, 0, 0, 1948, 1949, 3, 2, 1, 0, 1949, 1950, 6, 84, -1, 0, 1950, 1952, 1, 0, 0, 0, 1951, 1909, 1, 0, 0, 0, 1951, 1920, 1, 0, 0, 0, 1951, 1929, 1, 0, 0, 0, 1951, 1938, 1, 0, 0, 0, 1951, 1945, 1, 0, 0, 0, 1951, 1948, 1, 0, 0, 0, 1952, 169, 1, 0, 0, 0, 1953, 1954, 5, 243, 0, 0, 1954, 1955, 3, 170, 85, 0, 1955, 1956, 6, 85, -1, 0, 1956, 1971, 1, 0, 0, 0, 1957, 1958, 5, 244, 0, 0, 1958, 1959, 3, 170, 85, 0, 1959, 1960, 6, 85, -1, 0, 1960, 1971, 1, 0, 0, 0, 1961, 1962, 3, 172, 86, 0, 1962, 1963, 6, 85, -1, 0, 1963, 1971, 1, 0, 0, 0, 1964, 1965, 5, 112, 0, 0, 1965, 1966, 5, 30, 0, 0, 1966, 1967, 3, 32, 16, 0, 1967, 1968, 5, 31, 0, 0, 1968, 1969, 6, 85, -1, 0, 1969, 1971, 1, 0, 0, 0, 1970, 1953, 1, 0, 0, 0, 1970, 1957, 1, 0, 0, 0, 1970, 1961, 1, 0, 0, 0, 1970, 1964, 1, 0, 0, 0, 1971, 171, 1, 0, 0, 0, 1972, 1992, 1, 0, 0, 0, 1973, 1974, 5, 245, 0, 0, 1974, 1992, 6, 86, -1, 0, 1975, 1976, 5, 246, 0, 0, 1976, 1992, 6, 86, -1, 0, 1977, 1978, 5, 247, 0, 0, 1978, 1979, 5, 248, 0, 0, 1979, 1992, 6, 86, -1, 0, 1980, 1981, 5, 247, 0, 0, 1981, 1982, 5, 249, 0, 0, 1982, 1992, 6, 86, -1, 0, 1983, 1984, 5, 247, 0, 0, 1984, 1985, 5, 250, 0, 0, 1985, 1992, 6, 86, -1, 0, 1986, 1987, 5, 247, 0, 0, 1987, 1988, 5, 251, 0, 0, 1988, 1992, 6, 86, -1, 0, 1989, 1990, 5, 247, 0, 0, 1990, 1992, 6, 86, -1, 0, 1991, 1972, 1, 0, 0, 0, 1991, 1973, 1, 0, 0, 0, 1991, 1975, 1, 0, 0, 0, 1991, 1977, 1, 0, 0, 0, 1991, 1980, 1, 0, 0, 0, 1991, 1983, 1, 0, 0, 0, 1991, 1986, 1, 0, 0, 0, 1991, 1989, 1, 0, 0, 0, 1992, 173, 1, 0, 0, 0, 1993, 1994, 5, 113, 0, 0, 1994, 1995, 5, 30, 0, 0, 1995, 1996, 3, 32, 16, 0, 1996, 1997, 5, 31, 0, 0, 1997, 1998, 6, 87, -1, 0, 1998, 175, 1, 0, 0, 0, 1999, 2000, 5, 226, 0, 0, 2000, 2001, 3, 168, 84, 0, 2001, 2002, 6, 88, -1, 0, 2002, 2011, 1, 0, 0, 0, 2003, 2004, 5, 37, 0, 0, 2004, 2005, 3, 178, 89, 0, 2005, 2006, 6, 88, -1, 0, 2006, 2011, 1, 0, 0, 0, 2007, 2008, 3, 174, 87, 0, 2008, 2009, 6, 88, -1, 0, 2009, 2011, 1, 0, 0, 0, 2010, 1999, 1, 0, 0, 0, 2010, 2003, 1, 0, 0, 0, 2010, 2007, 1, 0, 0, 0, 2011, 177, 1, 0, 0, 0, 2012, 2013, 3, 138, 69, 0, 2013, 2014, 3, 124, 62, 0, 2014, 2015, 5, 176, 0, 0, 2015, 2016, 3, 2, 1, 0, 2016, 2017, 6, 89, -1, 0, 2017, 2026, 1, 0, 0, 0, 2018, 2019, 3, 138, 69, 0, 2019, 2020, 3, 2, 1, 0, 2020, 2021, 6, 89, -1, 0, 2021, 2026, 1, 0, 0, 0, 2022, 2023, 3, 2, 1, 0, 2023, 2024, 6, 89, -1, 0, 2024, 2026, 1, 0, 0, 0, 2025, 2012, 1, 0, 0, 0, 2025, 2018, 1, 0, 0, 0, 2025, 2022, 1, 0, 0, 0, 2026, 179, 1, 0, 0, 0, 2027, 2028, 3, 124, 62, 0, 2028, 2029, 6, 90, -1, 0, 2029, 2030, 5, 28, 0, 0, 2030, 2032, 1, 0, 0, 0, 2031, 2027, 1, 0, 0, 0, 2032, 2035, 1, 0, 0, 0, 2033, 2031, 1, 0, 0, 0, 2033, 2034, 1, 0, 0, 0, 2034, 2036, 1, 0, 0, 0, 2035, 2033, 1, 0, 0, 0, 2036, 2037, 3, 124, 62, 0, 2037, 2038, 6, 90, -1, 0, 2038, 181, 1, 0, 0, 0, 2039, 2046, 1, 0, 0, 0, 2040, 2041, 5, 86, 0, 0, 2041, 2042, 3, 190, 95, 0, 2042, 2043, 5, 87, 0, 0, 2043, 2044, 6, 91, -1, 0, 2044, 2046, 1, 0, 0, 0, 2045, 2039, 1, 0, 0, 0, 2045, 2040, 1, 0, 0, 0, 2046, 183, 1, 0, 0, 0, 2047, 2048, 5, 266, 0, 0, 2048, 2066, 6, 92, -1, 0, 2049, 2050, 5, 114, 0, 0, 2050, 2066, 6, 92, -1, 0, 2051, 2052, 5, 39, 0, 0, 2052, 2066, 6, 92, -1, 0, 2053, 2054, 5, 200, 0, 0, 2054, 2066, 6, 92, -1, 0, 2055, 2056, 5, 115, 0, 0, 2056, 2066, 6, 92, -1, 0, 2057, 2058, 5, 116, 0, 0, 2058, 2066, 6, 92, -1, 0, 2059, 2060, 5, 70, 0, 0, 2060, 2061, 5, 30, 0, 0, 2061, 2062, 3, 32, 16, 0, 2062, 2063, 5, 31, 0, 0, 2063, 2064, 6, 92, -1, 0, 2064, 2066, 1, 0, 0, 0, 2065, 2047, 1, 0, 0, 0, 2065, 2049, 1, 0, 0, 0, 2065, 2051, 1, 0, 0, 0, 2065, 2053, 1, 0, 0, 0, 2065, 2055, 1, 0, 0, 0, 2065, 2057, 1, 0, 0, 0, 2065, 2059, 1, 0, 0, 0, 2066, 185, 1, 0, 0, 0, 2067, 2068, 3, 184, 92, 0, 2068, 2069, 6, 93, -1, 0, 2069, 2071, 1, 0, 0, 0, 2070, 2067, 1, 0, 0, 0, 2071, 2074, 1, 0, 0, 0, 2072, 2070, 1, 0, 0, 0, 2072, 2073, 1, 0, 0, 0, 2073, 187, 1, 0, 0, 0, 2074, 2072, 1, 0, 0, 0, 2075, 2077, 3, 186, 93, 0, 2076, 2078, 3, 192, 96, 0, 2077, 2076, 1, 0, 0, 0, 2077, 2078, 1, 0, 0, 0, 2078, 2079, 1, 0, 0, 0, 2079, 2080, 3, 2, 1, 0, 2080, 2081, 6, 94, -1, 0, 2081, 189, 1, 0, 0, 0, 2082, 2083, 3, 188, 94, 0, 2083, 2084, 6, 95, -1, 0, 2084, 2085, 5, 28, 0, 0, 2085, 2087, 1, 0, 0, 0, 2086, 2082, 1, 0, 0, 0, 2087, 2090, 1, 0, 0, 0, 2088, 2086, 1, 0, 0, 0, 2088, 2089, 1, 0, 0, 0, 2089, 2091, 1, 0, 0, 0, 2090, 2088, 1, 0, 0, 0, 2091, 2092, 3, 188, 94, 0, 2092, 2093, 6, 95, -1, 0, 2093, 191, 1, 0, 0, 0, 2094, 2095, 5, 30, 0, 0, 2095, 2096, 3, 180, 90, 0, 2096, 2097, 5, 31, 0, 0, 2097, 2098, 6, 96, -1, 0, 2098, 193, 1, 0, 0, 0, 2099, 2101, 3, 196, 98, 0, 2100, 2099, 1, 0, 0, 0, 2100, 2101, 1, 0, 0, 0, 2101, 2102, 1, 0, 0, 0, 2102, 2103, 6, 97, -1, 0, 2103, 195, 1, 0, 0, 0, 2104, 2105, 5, 86, 0, 0, 2105, 2106, 5, 42, 0, 0, 2106, 2107, 3, 32, 16, 0, 2107, 2108, 5, 43, 0, 0, 2108, 2109, 5, 87, 0, 0, 2109, 2110, 6, 98, -1, 0, 2110, 197, 1, 0, 0, 0, 2111, 2112, 3, 234, 117, 0, 2112, 2113, 5, 17, 0, 0, 2113, 2114, 3, 246, 123, 0, 2114, 2115, 5, 18, 0, 0, 2115, 2262, 1, 0, 0, 0, 2116, 2117, 3, 74, 37, 0, 2117, 2118, 5, 17, 0, 0, 2118, 2119, 3, 82, 41, 0, 2119, 2120, 5, 18, 0, 0, 2120, 2262, 1, 0, 0, 0, 2121, 2122, 3, 210, 105, 0, 2122, 2123, 6, 99, -1, 0, 2123, 2124, 5, 17, 0, 0, 2124, 2125, 3, 214, 107, 0, 2125, 2126, 5, 18, 0, 0, 2126, 2262, 1, 0, 0, 0, 2127, 2128, 3, 218, 109, 0, 2128, 2129, 6, 99, -1, 0, 2129, 2130, 5, 17, 0, 0, 2130, 2131, 3, 222, 111, 0, 2131, 2132, 5, 18, 0, 0, 2132, 2262, 1, 0, 0, 0, 2133, 2262, 3, 200, 100, 0, 2134, 2135, 3, 284, 142, 0, 2135, 2136, 6, 99, -1, 0, 2136, 2262, 1, 0, 0, 0, 2137, 2138, 3, 152, 76, 0, 2138, 2139, 6, 99, -1, 0, 2139, 2262, 1, 0, 0, 0, 2140, 2141, 3, 88, 44, 0, 2141, 2142, 6, 99, -1, 0, 2142, 2262, 1, 0, 0, 0, 2143, 2144, 3, 330, 165, 0, 2144, 2145, 6, 99, -1, 0, 2145, 2262, 1, 0, 0, 0, 2146, 2147, 5, 117, 0, 0, 2147, 2148, 3, 32, 16, 0, 2148, 2149, 6, 99, -1, 0, 2149, 2262, 1, 0, 0, 0, 2150, 2151, 5, 118, 0, 0, 2151, 2152, 3, 32, 16, 0, 2152, 2153, 6, 99, -1, 0, 2153, 2262, 1, 0, 0, 0, 2154, 2155, 3, 346, 173, 0, 2155, 2156, 5, 17, 0, 0, 2156, 2157, 3, 350, 175, 0, 2157, 2158, 5, 18, 0, 0, 2158, 2159, 6, 99, -1, 0, 2159, 2262, 1, 0, 0, 0, 2160, 2161, 5, 302, 0, 0, 2161, 2162, 3, 124, 62, 0, 2162, 2163, 5, 176, 0, 0, 2163, 2164, 3, 242, 121, 0, 2164, 2165, 5, 119, 0, 0, 2165, 2166, 3, 170, 85, 0, 2166, 2167, 3, 138, 69, 0, 2167, 2168, 3, 124, 62, 0, 2168, 2169, 5, 176, 0, 0, 2169, 2170, 3, 242, 121, 0, 2170, 2171, 3, 112, 56, 0, 2171, 2172, 6, 99, -1, 0, 2172, 2262, 1, 0, 0, 0, 2173, 2174, 5, 302, 0, 0, 2174, 2175, 5, 226, 0, 0, 2175, 2176, 3, 170, 85, 0, 2176, 2177, 3, 138, 69, 0, 2177, 2178, 3, 124, 62, 0, 2178, 2179, 5, 176, 0, 0, 2179, 2180, 3, 242, 121, 0, 2180, 2181, 3, 194, 97, 0, 2181, 2182, 3, 112, 56, 0, 2182, 2183, 5, 119, 0, 0, 2183, 2184, 5, 226, 0, 0, 2184, 2185, 3, 170, 85, 0, 2185, 2186, 3, 138, 69, 0, 2186, 2187, 3, 124, 62, 0, 2187, 2188, 5, 176, 0, 0, 2188, 2189, 3, 242, 121, 0, 2189, 2190, 3, 194, 97, 0, 2190, 2191, 3, 112, 56, 0, 2191, 2192, 6, 99, -1, 0, 2192, 2262, 1, 0, 0, 0, 2193, 2194, 3, 26, 13, 0, 2194, 2195, 6, 99, -1, 0, 2195, 2262, 1, 0, 0, 0, 2196, 2197, 3, 40, 20, 0, 2197, 2198, 6, 99, -1, 0, 2198, 2262, 1, 0, 0, 0, 2199, 2200, 5, 255, 0, 0, 2200, 2201, 5, 196, 0, 0, 2201, 2202, 5, 42, 0, 0, 2202, 2203, 3, 32, 16, 0, 2203, 2204, 5, 43, 0, 0, 2204, 2210, 6, 99, -1, 0, 2205, 2206, 3, 330, 165, 0, 2206, 2207, 6, 99, -1, 0, 2207, 2209, 1, 0, 0, 0, 2208, 2205, 1, 0, 0, 0, 2209, 2212, 1, 0, 0, 0, 2210, 2208, 1, 0, 0, 0, 2210, 2211, 1, 0, 0, 0, 2211, 2262, 1, 0, 0, 0, 2212, 2210, 1, 0, 0, 0, 2213, 2214, 5, 255, 0, 0, 2214, 2215, 5, 196, 0, 0, 2215, 2216, 3, 2, 1, 0, 2216, 2222, 6, 99, -1, 0, 2217, 2218, 3, 330, 165, 0, 2218, 2219, 6, 99, -1, 0, 2219, 2221, 1, 0, 0, 0, 2220, 2217, 1, 0, 0, 0, 2221, 2224, 1, 0, 0, 0, 2222, 2220, 1, 0, 0, 0, 2222, 2223, 1, 0, 0, 0, 2223, 2262, 1, 0, 0, 0, 2224, 2222, 1, 0, 0, 0, 2225, 2226, 5, 255, 0, 0, 2226, 2227, 5, 256, 0, 0, 2227, 2228, 5, 42, 0, 0, 2228, 2229, 3, 32, 16, 0, 2229, 2230, 5, 43, 0, 0, 2230, 2231, 5, 28, 0, 0, 2231, 2232, 3, 124, 62, 0, 2232, 2238, 6, 99, -1, 0, 2233, 2234, 3, 330, 165, 0, 2234, 2235, 6, 99, -1, 0, 2235, 2237, 1, 0, 0, 0, 2236, 2233, 1, 0, 0, 0, 2237, 2240, 1, 0, 0, 0, 2238, 2236, 1, 0, 0, 0, 2238, 2239, 1, 0, 0, 0, 2239, 2262, 1, 0, 0, 0, 2240, 2238, 1, 0, 0, 0, 2241, 2242, 5, 255, 0, 0, 2242, 2243, 5, 256, 0, 0, 2243, 2244, 3, 2, 1, 0, 2244, 2245, 5, 28, 0, 0, 2245, 2246, 3, 124, 62, 0, 2246, 2252, 6, 99, -1, 0, 2247, 2248, 3, 330, 165, 0, 2248, 2249, 6, 99, -1, 0, 2249, 2251, 1, 0, 0, 0, 2250, 2247, 1, 0, 0, 0, 2251, 2254, 1, 0, 0, 0, 2252, 2250, 1, 0, 0, 0, 2252, 2253, 1, 0, 0, 0, 2253, 2262, 1, 0, 0, 0, 2254, 2252, 1, 0, 0, 0, 2255, 2256, 5, 120, 0, 0, 2256, 2257, 5, 196, 0, 0, 2257, 2258, 3, 124, 62, 0, 2258, 2259, 3, 44, 22, 0, 2259, 2260, 6, 99, -1, 0, 2260, 2262, 1, 0, 0, 0, 2261, 2111, 1, 0, 0, 0, 2261, 2116, 1, 0, 0, 0, 2261, 2121, 1, 0, 0, 0, 2261, 2127, 1, 0, 0, 0, 2261, 2133, 1, 0, 0, 0, 2261, 2134, 1, 0, 0, 0, 2261, 2137, 1, 0, 0, 0, 2261, 2140, 1, 0, 0, 0, 2261, 2143, 1, 0, 0, 0, 2261, 2146, 1, 0, 0, 0, 2261, 2150, 1, 0, 0, 0, 2261, 2154, 1, 0, 0, 0, 2261, 2160, 1, 0, 0, 0, 2261, 2173, 1, 0, 0, 0, 2261, 2193, 1, 0, 0, 0, 2261, 2196, 1, 0, 0, 0, 2261, 2199, 1, 0, 0, 0, 2261, 2213, 1, 0, 0, 0, 2261, 2225, 1, 0, 0, 0, 2261, 2241, 1, 0, 0, 0, 2261, 2255, 1, 0, 0, 0, 2262, 199, 1, 0, 0, 0, 2263, 2264, 5, 121, 0, 0, 2264, 2276, 3, 208, 104, 0, 2265, 2266, 3, 202, 101, 0, 2266, 2267, 6, 100, -1, 0, 2267, 2275, 1, 0, 0, 0, 2268, 2269, 5, 122, 0, 0, 2269, 2270, 5, 30, 0, 0, 2270, 2271, 3, 228, 114, 0, 2271, 2272, 5, 31, 0, 0, 2272, 2273, 6, 100, -1, 0, 2273, 2275, 1, 0, 0, 0, 2274, 2265, 1, 0, 0, 0, 2274, 2268, 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, 2280, 3, 138, 69, 0, 2280, 2281, 3, 2, 1, 0, 2281, 2282, 3, 204, 102, 0, 2282, 2283, 3, 206, 103, 0, 2283, 2284, 6, 100, -1, 0, 2284, 201, 1, 0, 0, 0, 2285, 2286, 5, 123, 0, 0, 2286, 2320, 6, 101, -1, 0, 2287, 2288, 5, 51, 0, 0, 2288, 2320, 6, 101, -1, 0, 2289, 2290, 5, 52, 0, 0, 2290, 2320, 6, 101, -1, 0, 2291, 2292, 5, 63, 0, 0, 2292, 2320, 6, 101, -1, 0, 2293, 2294, 5, 124, 0, 0, 2294, 2320, 6, 101, -1, 0, 2295, 2296, 5, 69, 0, 0, 2296, 2320, 6, 101, -1, 0, 2297, 2298, 5, 68, 0, 0, 2298, 2320, 6, 101, -1, 0, 2299, 2300, 5, 64, 0, 0, 2300, 2320, 6, 101, -1, 0, 2301, 2302, 5, 65, 0, 0, 2302, 2320, 6, 101, -1, 0, 2303, 2304, 5, 66, 0, 0, 2304, 2320, 6, 101, -1, 0, 2305, 2306, 5, 125, 0, 0, 2306, 2320, 6, 101, -1, 0, 2307, 2308, 5, 126, 0, 0, 2308, 2320, 6, 101, -1, 0, 2309, 2310, 5, 127, 0, 0, 2310, 2320, 6, 101, -1, 0, 2311, 2312, 5, 16, 0, 0, 2312, 2320, 6, 101, -1, 0, 2313, 2314, 5, 70, 0, 0, 2314, 2315, 5, 30, 0, 0, 2315, 2316, 3, 32, 16, 0, 2316, 2317, 5, 31, 0, 0, 2317, 2318, 6, 101, -1, 0, 2318, 2320, 1, 0, 0, 0, 2319, 2285, 1, 0, 0, 0, 2319, 2287, 1, 0, 0, 0, 2319, 2289, 1, 0, 0, 0, 2319, 2291, 1, 0, 0, 0, 2319, 2293, 1, 0, 0, 0, 2319, 2295, 1, 0, 0, 0, 2319, 2297, 1, 0, 0, 0, 2319, 2299, 1, 0, 0, 0, 2319, 2301, 1, 0, 0, 0, 2319, 2303, 1, 0, 0, 0, 2319, 2305, 1, 0, 0, 0, 2319, 2307, 1, 0, 0, 0, 2319, 2309, 1, 0, 0, 0, 2319, 2311, 1, 0, 0, 0, 2319, 2313, 1, 0, 0, 0, 2320, 203, 1, 0, 0, 0, 2321, 2331, 1, 0, 0, 0, 2322, 2323, 5, 44, 0, 0, 2323, 2324, 3, 0, 0, 0, 2324, 2325, 6, 102, -1, 0, 2325, 2331, 1, 0, 0, 0, 2326, 2327, 5, 44, 0, 0, 2327, 2328, 3, 32, 16, 0, 2328, 2329, 6, 102, -1, 0, 2329, 2331, 1, 0, 0, 0, 2330, 2321, 1, 0, 0, 0, 2330, 2322, 1, 0, 0, 0, 2330, 2326, 1, 0, 0, 0, 2331, 205, 1, 0, 0, 0, 2332, 2338, 1, 0, 0, 0, 2333, 2334, 5, 36, 0, 0, 2334, 2335, 3, 304, 152, 0, 2335, 2336, 6, 103, -1, 0, 2336, 2338, 1, 0, 0, 0, 2337, 2332, 1, 0, 0, 0, 2337, 2333, 1, 0, 0, 0, 2338, 207, 1, 0, 0, 0, 2339, 2346, 1, 0, 0, 0, 2340, 2341, 5, 42, 0, 0, 2341, 2342, 3, 32, 16, 0, 2342, 2343, 5, 43, 0, 0, 2343, 2344, 6, 104, -1, 0, 2344, 2346, 1, 0, 0, 0, 2345, 2339, 1, 0, 0, 0, 2345, 2340, 1, 0, 0, 0, 2346, 209, 1, 0, 0, 0, 2347, 2353, 5, 128, 0, 0, 2348, 2349, 3, 212, 106, 0, 2349, 2350, 6, 105, -1, 0, 2350, 2352, 1, 0, 0, 0, 2351, 2348, 1, 0, 0, 0, 2352, 2355, 1, 0, 0, 0, 2353, 2351, 1, 0, 0, 0, 2353, 2354, 1, 0, 0, 0, 2354, 2356, 1, 0, 0, 0, 2355, 2353, 1, 0, 0, 0, 2356, 2357, 3, 124, 62, 0, 2357, 2358, 3, 2, 1, 0, 2358, 2359, 6, 105, -1, 0, 2359, 2373, 1, 0, 0, 0, 2360, 2366, 5, 128, 0, 0, 2361, 2362, 3, 212, 106, 0, 2362, 2363, 6, 105, -1, 0, 2363, 2365, 1, 0, 0, 0, 2364, 2361, 1, 0, 0, 0, 2365, 2368, 1, 0, 0, 0, 2366, 2364, 1, 0, 0, 0, 2366, 2367, 1, 0, 0, 0, 2367, 2369, 1, 0, 0, 0, 2368, 2366, 1, 0, 0, 0, 2369, 2370, 3, 2, 1, 0, 2370, 2371, 6, 105, -1, 0, 2371, 2373, 1, 0, 0, 0, 2372, 2347, 1, 0, 0, 0, 2372, 2360, 1, 0, 0, 0, 2373, 211, 1, 0, 0, 0, 2374, 2375, 5, 69, 0, 0, 2375, 2379, 6, 106, -1, 0, 2376, 2377, 5, 68, 0, 0, 2377, 2379, 6, 106, -1, 0, 2378, 2374, 1, 0, 0, 0, 2378, 2376, 1, 0, 0, 0, 2379, 213, 1, 0, 0, 0, 2380, 2382, 3, 216, 108, 0, 2381, 2380, 1, 0, 0, 0, 2382, 2385, 1, 0, 0, 0, 2383, 2381, 1, 0, 0, 0, 2383, 2384, 1, 0, 0, 0, 2384, 215, 1, 0, 0, 0, 2385, 2383, 1, 0, 0, 0, 2386, 2387, 5, 129, 0, 0, 2387, 2388, 3, 168, 84, 0, 2388, 2389, 6, 108, -1, 0, 2389, 2413, 1, 0, 0, 0, 2390, 2391, 5, 130, 0, 0, 2391, 2392, 3, 168, 84, 0, 2392, 2393, 6, 108, -1, 0, 2393, 2413, 1, 0, 0, 0, 2394, 2395, 5, 131, 0, 0, 2395, 2396, 3, 168, 84, 0, 2396, 2397, 6, 108, -1, 0, 2397, 2413, 1, 0, 0, 0, 2398, 2399, 5, 132, 0, 0, 2399, 2400, 3, 168, 84, 0, 2400, 2401, 6, 108, -1, 0, 2401, 2413, 1, 0, 0, 0, 2402, 2403, 3, 88, 44, 0, 2403, 2404, 6, 108, -1, 0, 2404, 2413, 1, 0, 0, 0, 2405, 2406, 3, 330, 165, 0, 2406, 2407, 6, 108, -1, 0, 2407, 2413, 1, 0, 0, 0, 2408, 2409, 3, 26, 13, 0, 2409, 2410, 6, 108, -1, 0, 2410, 2413, 1, 0, 0, 0, 2411, 2413, 3, 40, 20, 0, 2412, 2386, 1, 0, 0, 0, 2412, 2390, 1, 0, 0, 0, 2412, 2394, 1, 0, 0, 0, 2412, 2398, 1, 0, 0, 0, 2412, 2402, 1, 0, 0, 0, 2412, 2405, 1, 0, 0, 0, 2412, 2408, 1, 0, 0, 0, 2412, 2411, 1, 0, 0, 0, 2413, 217, 1, 0, 0, 0, 2414, 2420, 5, 133, 0, 0, 2415, 2416, 3, 220, 110, 0, 2416, 2417, 6, 109, -1, 0, 2417, 2419, 1, 0, 0, 0, 2418, 2415, 1, 0, 0, 0, 2419, 2422, 1, 0, 0, 0, 2420, 2418, 1, 0, 0, 0, 2420, 2421, 1, 0, 0, 0, 2421, 2423, 1, 0, 0, 0, 2422, 2420, 1, 0, 0, 0, 2423, 2424, 3, 170, 85, 0, 2424, 2425, 3, 138, 69, 0, 2425, 2426, 3, 2, 1, 0, 2426, 2427, 3, 112, 56, 0, 2427, 2428, 3, 206, 103, 0, 2428, 2429, 6, 109, -1, 0, 2429, 219, 1, 0, 0, 0, 2430, 2431, 5, 69, 0, 0, 2431, 2435, 6, 110, -1, 0, 2432, 2433, 5, 68, 0, 0, 2433, 2435, 6, 110, -1, 0, 2434, 2430, 1, 0, 0, 0, 2434, 2432, 1, 0, 0, 0, 2435, 221, 1, 0, 0, 0, 2436, 2438, 3, 224, 112, 0, 2437, 2436, 1, 0, 0, 0, 2438, 2441, 1, 0, 0, 0, 2439, 2437, 1, 0, 0, 0, 2439, 2440, 1, 0, 0, 0, 2440, 223, 1, 0, 0, 0, 2441, 2439, 1, 0, 0, 0, 2442, 2443, 5, 134, 0, 0, 2443, 2444, 3, 168, 84, 0, 2444, 2445, 6, 112, -1, 0, 2445, 2465, 1, 0, 0, 0, 2446, 2447, 5, 135, 0, 0, 2447, 2448, 3, 168, 84, 0, 2448, 2449, 6, 112, -1, 0, 2449, 2465, 1, 0, 0, 0, 2450, 2451, 5, 132, 0, 0, 2451, 2452, 3, 168, 84, 0, 2452, 2453, 6, 112, -1, 0, 2453, 2465, 1, 0, 0, 0, 2454, 2455, 3, 330, 165, 0, 2455, 2456, 6, 112, -1, 0, 2456, 2465, 1, 0, 0, 0, 2457, 2458, 3, 88, 44, 0, 2458, 2459, 6, 112, -1, 0, 2459, 2465, 1, 0, 0, 0, 2460, 2461, 3, 26, 13, 0, 2461, 2462, 6, 112, -1, 0, 2462, 2465, 1, 0, 0, 0, 2463, 2465, 3, 40, 20, 0, 2464, 2442, 1, 0, 0, 0, 2464, 2446, 1, 0, 0, 0, 2464, 2450, 1, 0, 0, 0, 2464, 2454, 1, 0, 0, 0, 2464, 2457, 1, 0, 0, 0, 2464, 2460, 1, 0, 0, 0, 2464, 2463, 1, 0, 0, 0, 2465, 225, 1, 0, 0, 0, 2466, 2474, 6, 113, -1, 0, 2467, 2468, 5, 122, 0, 0, 2468, 2469, 5, 30, 0, 0, 2469, 2470, 3, 228, 114, 0, 2470, 2471, 5, 31, 0, 0, 2471, 2472, 6, 113, -1, 0, 2472, 2474, 1, 0, 0, 0, 2473, 2466, 1, 0, 0, 0, 2473, 2467, 1, 0, 0, 0, 2474, 227, 1, 0, 0, 0, 2475, 2476, 3, 126, 63, 0, 2476, 2477, 6, 114, -1, 0, 2477, 2489, 1, 0, 0, 0, 2478, 2482, 5, 17, 0, 0, 2479, 2480, 3, 302, 151, 0, 2480, 2481, 6, 114, -1, 0, 2481, 2483, 1, 0, 0, 0, 2482, 2479, 1, 0, 0, 0, 2483, 2484, 1, 0, 0, 0, 2484, 2482, 1, 0, 0, 0, 2484, 2485, 1, 0, 0, 0, 2485, 2486, 1, 0, 0, 0, 2486, 2487, 5, 18, 0, 0, 2487, 2489, 1, 0, 0, 0, 2488, 2475, 1, 0, 0, 0, 2488, 2478, 1, 0, 0, 0, 2489, 229, 1, 0, 0, 0, 2490, 2491, 3, 232, 116, 0, 2491, 2492, 6, 115, -1, 0, 2492, 2494, 1, 0, 0, 0, 2493, 2490, 1, 0, 0, 0, 2494, 2497, 1, 0, 0, 0, 2495, 2493, 1, 0, 0, 0, 2495, 2496, 1, 0, 0, 0, 2496, 231, 1, 0, 0, 0, 2497, 2495, 1, 0, 0, 0, 2498, 2499, 5, 42, 0, 0, 2499, 2500, 5, 136, 0, 0, 2500, 2501, 5, 43, 0, 0, 2501, 2516, 6, 116, -1, 0, 2502, 2503, 5, 42, 0, 0, 2503, 2504, 5, 137, 0, 0, 2504, 2505, 5, 43, 0, 0, 2505, 2516, 6, 116, -1, 0, 2506, 2507, 5, 42, 0, 0, 2507, 2508, 5, 138, 0, 0, 2508, 2509, 5, 43, 0, 0, 2509, 2516, 6, 116, -1, 0, 2510, 2511, 5, 42, 0, 0, 2511, 2512, 3, 32, 16, 0, 2512, 2513, 5, 43, 0, 0, 2513, 2514, 6, 116, -1, 0, 2514, 2516, 1, 0, 0, 0, 2515, 2498, 1, 0, 0, 0, 2515, 2502, 1, 0, 0, 0, 2515, 2506, 1, 0, 0, 0, 2515, 2510, 1, 0, 0, 0, 2516, 233, 1, 0, 0, 0, 2517, 2526, 5, 139, 0, 0, 2518, 2519, 3, 236, 118, 0, 2519, 2520, 6, 117, -1, 0, 2520, 2525, 1, 0, 0, 0, 2521, 2522, 3, 238, 119, 0, 2522, 2523, 6, 117, -1, 0, 2523, 2525, 1, 0, 0, 0, 2524, 2518, 1, 0, 0, 0, 2524, 2521, 1, 0, 0, 0, 2525, 2528, 1, 0, 0, 0, 2526, 2524, 1, 0, 0, 0, 2526, 2527, 1, 0, 0, 0, 2527, 2529, 1, 0, 0, 0, 2528, 2526, 1, 0, 0, 0, 2529, 2530, 3, 170, 85, 0, 2530, 2531, 3, 230, 115, 0, 2531, 2532, 3, 138, 69, 0, 2532, 2533, 3, 226, 113, 0, 2533, 2534, 3, 242, 121, 0, 2534, 2535, 3, 182, 91, 0, 2535, 2541, 3, 112, 56, 0, 2536, 2537, 3, 244, 122, 0, 2537, 2538, 6, 117, -1, 0, 2538, 2540, 1, 0, 0, 0, 2539, 2536, 1, 0, 0, 0, 2540, 2543, 1, 0, 0, 0, 2541, 2539, 1, 0, 0, 0, 2541, 2542, 1, 0, 0, 0, 2542, 2544, 1, 0, 0, 0, 2543, 2541, 1, 0, 0, 0, 2544, 2545, 6, 117, -1, 0, 2545, 235, 1, 0, 0, 0, 2546, 2547, 5, 123, 0, 0, 2547, 2589, 6, 118, -1, 0, 2548, 2549, 5, 51, 0, 0, 2549, 2589, 6, 118, -1, 0, 2550, 2551, 5, 52, 0, 0, 2551, 2589, 6, 118, -1, 0, 2552, 2553, 5, 63, 0, 0, 2553, 2589, 6, 118, -1, 0, 2554, 2555, 5, 140, 0, 0, 2555, 2589, 6, 118, -1, 0, 2556, 2557, 5, 68, 0, 0, 2557, 2589, 6, 118, -1, 0, 2558, 2559, 5, 141, 0, 0, 2559, 2589, 6, 118, -1, 0, 2560, 2561, 5, 142, 0, 0, 2561, 2589, 6, 118, -1, 0, 2562, 2563, 5, 54, 0, 0, 2563, 2589, 6, 118, -1, 0, 2564, 2565, 5, 64, 0, 0, 2565, 2589, 6, 118, -1, 0, 2566, 2567, 5, 65, 0, 0, 2567, 2589, 6, 118, -1, 0, 2568, 2569, 5, 66, 0, 0, 2569, 2589, 6, 118, -1, 0, 2570, 2571, 5, 125, 0, 0, 2571, 2589, 6, 118, -1, 0, 2572, 2573, 5, 143, 0, 0, 2573, 2589, 6, 118, -1, 0, 2574, 2575, 5, 144, 0, 0, 2575, 2589, 6, 118, -1, 0, 2576, 2577, 5, 69, 0, 0, 2577, 2589, 6, 118, -1, 0, 2578, 2579, 5, 145, 0, 0, 2579, 2589, 6, 118, -1, 0, 2580, 2581, 5, 146, 0, 0, 2581, 2589, 6, 118, -1, 0, 2582, 2583, 5, 70, 0, 0, 2583, 2584, 5, 30, 0, 0, 2584, 2585, 3, 32, 16, 0, 2585, 2586, 5, 31, 0, 0, 2586, 2587, 6, 118, -1, 0, 2587, 2589, 1, 0, 0, 0, 2588, 2546, 1, 0, 0, 0, 2588, 2548, 1, 0, 0, 0, 2588, 2550, 1, 0, 0, 0, 2588, 2552, 1, 0, 0, 0, 2588, 2554, 1, 0, 0, 0, 2588, 2556, 1, 0, 0, 0, 2588, 2558, 1, 0, 0, 0, 2588, 2560, 1, 0, 0, 0, 2588, 2562, 1, 0, 0, 0, 2588, 2564, 1, 0, 0, 0, 2588, 2566, 1, 0, 0, 0, 2588, 2568, 1, 0, 0, 0, 2588, 2570, 1, 0, 0, 0, 2588, 2572, 1, 0, 0, 0, 2588, 2574, 1, 0, 0, 0, 2588, 2576, 1, 0, 0, 0, 2588, 2578, 1, 0, 0, 0, 2588, 2580, 1, 0, 0, 0, 2588, 2582, 1, 0, 0, 0, 2589, 237, 1, 0, 0, 0, 2590, 2591, 5, 147, 0, 0, 2591, 2600, 5, 30, 0, 0, 2592, 2593, 3, 6, 3, 0, 2593, 2598, 6, 119, -1, 0, 2594, 2595, 5, 34, 0, 0, 2595, 2596, 3, 6, 3, 0, 2596, 2597, 6, 119, -1, 0, 2597, 2599, 1, 0, 0, 0, 2598, 2594, 1, 0, 0, 0, 2598, 2599, 1, 0, 0, 0, 2599, 2601, 1, 0, 0, 0, 2600, 2592, 1, 0, 0, 0, 2600, 2601, 1, 0, 0, 0, 2601, 2607, 1, 0, 0, 0, 2602, 2603, 3, 240, 120, 0, 2603, 2604, 6, 119, -1, 0, 2604, 2606, 1, 0, 0, 0, 2605, 2602, 1, 0, 0, 0, 2606, 2609, 1, 0, 0, 0, 2607, 2605, 1, 0, 0, 0, 2607, 2608, 1, 0, 0, 0, 2608, 2610, 1, 0, 0, 0, 2609, 2607, 1, 0, 0, 0, 2610, 2614, 5, 31, 0, 0, 2611, 2612, 5, 147, 0, 0, 2612, 2614, 5, 85, 0, 0, 2613, 2590, 1, 0, 0, 0, 2613, 2611, 1, 0, 0, 0, 2614, 239, 1, 0, 0, 0, 2615, 2616, 5, 148, 0, 0, 2616, 2658, 6, 120, -1, 0, 2617, 2618, 5, 224, 0, 0, 2618, 2658, 6, 120, -1, 0, 2619, 2620, 5, 57, 0, 0, 2620, 2658, 6, 120, -1, 0, 2621, 2622, 5, 58, 0, 0, 2622, 2658, 6, 120, -1, 0, 2623, 2624, 5, 149, 0, 0, 2624, 2658, 6, 120, -1, 0, 2625, 2626, 5, 150, 0, 0, 2626, 2658, 6, 120, -1, 0, 2627, 2628, 5, 248, 0, 0, 2628, 2658, 6, 120, -1, 0, 2629, 2630, 5, 249, 0, 0, 2630, 2658, 6, 120, -1, 0, 2631, 2632, 5, 250, 0, 0, 2632, 2658, 6, 120, -1, 0, 2633, 2634, 5, 251, 0, 0, 2634, 2658, 6, 120, -1, 0, 2635, 2636, 5, 151, 0, 0, 2636, 2637, 5, 75, 0, 0, 2637, 2638, 5, 152, 0, 0, 2638, 2658, 6, 120, -1, 0, 2639, 2640, 5, 151, 0, 0, 2640, 2641, 5, 75, 0, 0, 2641, 2642, 5, 153, 0, 0, 2642, 2658, 6, 120, -1, 0, 2643, 2644, 5, 154, 0, 0, 2644, 2645, 5, 75, 0, 0, 2645, 2646, 5, 152, 0, 0, 2646, 2658, 6, 120, -1, 0, 2647, 2648, 5, 154, 0, 0, 2648, 2649, 5, 75, 0, 0, 2649, 2650, 5, 153, 0, 0, 2650, 2658, 6, 120, -1, 0, 2651, 2652, 5, 70, 0, 0, 2652, 2653, 5, 30, 0, 0, 2653, 2654, 3, 32, 16, 0, 2654, 2655, 5, 31, 0, 0, 2655, 2656, 6, 120, -1, 0, 2656, 2658, 1, 0, 0, 0, 2657, 2615, 1, 0, 0, 0, 2657, 2617, 1, 0, 0, 0, 2657, 2619, 1, 0, 0, 0, 2657, 2621, 1, 0, 0, 0, 2657, 2623, 1, 0, 0, 0, 2657, 2625, 1, 0, 0, 0, 2657, 2627, 1, 0, 0, 0, 2657, 2629, 1, 0, 0, 0, 2657, 2631, 1, 0, 0, 0, 2657, 2633, 1, 0, 0, 0, 2657, 2635, 1, 0, 0, 0, 2657, 2639, 1, 0, 0, 0, 2657, 2643, 1, 0, 0, 0, 2657, 2647, 1, 0, 0, 0, 2657, 2651, 1, 0, 0, 0, 2658, 241, 1, 0, 0, 0, 2659, 2660, 5, 116, 0, 0, 2660, 2667, 6, 121, -1, 0, 2661, 2662, 5, 155, 0, 0, 2662, 2667, 6, 121, -1, 0, 2663, 2664, 3, 2, 1, 0, 2664, 2665, 6, 121, -1, 0, 2665, 2667, 1, 0, 0, 0, 2666, 2659, 1, 0, 0, 0, 2666, 2661, 1, 0, 0, 0, 2666, 2663, 1, 0, 0, 0, 2667, 243, 1, 0, 0, 0, 2668, 2669, 5, 1, 0, 0, 2669, 2707, 6, 122, -1, 0, 2670, 2671, 5, 2, 0, 0, 2671, 2707, 6, 122, -1, 0, 2672, 2673, 5, 156, 0, 0, 2673, 2707, 6, 122, -1, 0, 2674, 2675, 5, 3, 0, 0, 2675, 2707, 6, 122, -1, 0, 2676, 2677, 5, 4, 0, 0, 2677, 2707, 6, 122, -1, 0, 2678, 2679, 5, 247, 0, 0, 2679, 2707, 6, 122, -1, 0, 2680, 2681, 5, 5, 0, 0, 2681, 2707, 6, 122, -1, 0, 2682, 2683, 5, 6, 0, 0, 2683, 2707, 6, 122, -1, 0, 2684, 2685, 5, 7, 0, 0, 2685, 2707, 6, 122, -1, 0, 2686, 2687, 5, 8, 0, 0, 2687, 2707, 6, 122, -1, 0, 2688, 2689, 5, 9, 0, 0, 2689, 2707, 6, 122, -1, 0, 2690, 2691, 5, 10, 0, 0, 2691, 2707, 6, 122, -1, 0, 2692, 2693, 5, 11, 0, 0, 2693, 2707, 6, 122, -1, 0, 2694, 2695, 5, 12, 0, 0, 2695, 2707, 6, 122, -1, 0, 2696, 2697, 5, 13, 0, 0, 2697, 2707, 6, 122, -1, 0, 2698, 2699, 5, 14, 0, 0, 2699, 2707, 6, 122, -1, 0, 2700, 2701, 5, 70, 0, 0, 2701, 2702, 5, 30, 0, 0, 2702, 2703, 3, 32, 16, 0, 2703, 2704, 5, 31, 0, 0, 2704, 2705, 6, 122, -1, 0, 2705, 2707, 1, 0, 0, 0, 2706, 2668, 1, 0, 0, 0, 2706, 2670, 1, 0, 0, 0, 2706, 2672, 1, 0, 0, 0, 2706, 2674, 1, 0, 0, 0, 2706, 2676, 1, 0, 0, 0, 2706, 2678, 1, 0, 0, 0, 2706, 2680, 1, 0, 0, 0, 2706, 2682, 1, 0, 0, 0, 2706, 2684, 1, 0, 0, 0, 2706, 2686, 1, 0, 0, 0, 2706, 2688, 1, 0, 0, 0, 2706, 2690, 1, 0, 0, 0, 2706, 2692, 1, 0, 0, 0, 2706, 2694, 1, 0, 0, 0, 2706, 2696, 1, 0, 0, 0, 2706, 2698, 1, 0, 0, 0, 2706, 2700, 1, 0, 0, 0, 2707, 245, 1, 0, 0, 0, 2708, 2710, 3, 248, 124, 0, 2709, 2708, 1, 0, 0, 0, 2710, 2713, 1, 0, 0, 0, 2711, 2709, 1, 0, 0, 0, 2711, 2712, 1, 0, 0, 0, 2712, 247, 1, 0, 0, 0, 2713, 2711, 1, 0, 0, 0, 2714, 2752, 3, 100, 50, 0, 2715, 2716, 5, 296, 0, 0, 2716, 2717, 3, 32, 16, 0, 2717, 2718, 6, 124, -1, 0, 2718, 2752, 1, 0, 0, 0, 2719, 2752, 3, 266, 133, 0, 2720, 2721, 5, 297, 0, 0, 2721, 2722, 3, 32, 16, 0, 2722, 2723, 6, 124, -1, 0, 2723, 2752, 1, 0, 0, 0, 2724, 2725, 5, 298, 0, 0, 2725, 2752, 6, 124, -1, 0, 2726, 2727, 5, 299, 0, 0, 2727, 2752, 6, 124, -1, 0, 2728, 2752, 3, 260, 130, 0, 2729, 2752, 3, 264, 132, 0, 2730, 2752, 3, 250, 125, 0, 2731, 2732, 3, 284, 142, 0, 2732, 2733, 6, 124, -1, 0, 2733, 2752, 1, 0, 0, 0, 2734, 2735, 3, 152, 76, 0, 2735, 2736, 6, 124, -1, 0, 2736, 2752, 1, 0, 0, 0, 2737, 2738, 3, 88, 44, 0, 2738, 2739, 6, 124, -1, 0, 2739, 2752, 1, 0, 0, 0, 2740, 2741, 3, 26, 13, 0, 2741, 2742, 6, 124, -1, 0, 2742, 2752, 1, 0, 0, 0, 2743, 2744, 3, 262, 131, 0, 2744, 2745, 6, 124, -1, 0, 2745, 2752, 1, 0, 0, 0, 2746, 2752, 3, 40, 20, 0, 2747, 2752, 3, 252, 126, 0, 2748, 2752, 3, 254, 127, 0, 2749, 2752, 3, 256, 128, 0, 2750, 2752, 3, 258, 129, 0, 2751, 2714, 1, 0, 0, 0, 2751, 2715, 1, 0, 0, 0, 2751, 2719, 1, 0, 0, 0, 2751, 2720, 1, 0, 0, 0, 2751, 2724, 1, 0, 0, 0, 2751, 2726, 1, 0, 0, 0, 2751, 2728, 1, 0, 0, 0, 2751, 2729, 1, 0, 0, 0, 2751, 2730, 1, 0, 0, 0, 2751, 2731, 1, 0, 0, 0, 2751, 2734, 1, 0, 0, 0, 2751, 2737, 1, 0, 0, 0, 2751, 2740, 1, 0, 0, 0, 2751, 2743, 1, 0, 0, 0, 2751, 2746, 1, 0, 0, 0, 2751, 2747, 1, 0, 0, 0, 2751, 2748, 1, 0, 0, 0, 2751, 2749, 1, 0, 0, 0, 2751, 2750, 1, 0, 0, 0, 2752, 249, 1, 0, 0, 0, 2753, 2755, 5, 300, 0, 0, 2754, 2756, 5, 157, 0, 0, 2755, 2754, 1, 0, 0, 0, 2755, 2756, 1, 0, 0, 0, 2756, 2757, 1, 0, 0, 0, 2757, 2758, 3, 112, 56, 0, 2758, 251, 1, 0, 0, 0, 2759, 2760, 5, 301, 0, 0, 2760, 2761, 5, 42, 0, 0, 2761, 2762, 3, 32, 16, 0, 2762, 2765, 5, 43, 0, 0, 2763, 2764, 5, 34, 0, 0, 2764, 2766, 3, 0, 0, 0, 2765, 2763, 1, 0, 0, 0, 2765, 2766, 1, 0, 0, 0, 2766, 253, 1, 0, 0, 0, 2767, 2768, 5, 303, 0, 0, 2768, 2769, 3, 32, 16, 0, 2769, 2770, 5, 75, 0, 0, 2770, 2771, 3, 32, 16, 0, 2771, 255, 1, 0, 0, 0, 2772, 2773, 5, 302, 0, 0, 2773, 2774, 3, 124, 62, 0, 2774, 2775, 5, 176, 0, 0, 2775, 2776, 3, 242, 121, 0, 2776, 2788, 1, 0, 0, 0, 2777, 2778, 5, 302, 0, 0, 2778, 2779, 5, 226, 0, 0, 2779, 2780, 3, 170, 85, 0, 2780, 2781, 3, 138, 69, 0, 2781, 2782, 3, 124, 62, 0, 2782, 2783, 5, 176, 0, 0, 2783, 2784, 3, 242, 121, 0, 2784, 2785, 3, 194, 97, 0, 2785, 2786, 3, 112, 56, 0, 2786, 2788, 1, 0, 0, 0, 2787, 2772, 1, 0, 0, 0, 2787, 2777, 1, 0, 0, 0, 2788, 257, 1, 0, 0, 0, 2789, 2790, 5, 255, 0, 0, 2790, 2791, 5, 196, 0, 0, 2791, 2792, 5, 42, 0, 0, 2792, 2793, 3, 32, 16, 0, 2793, 2799, 5, 43, 0, 0, 2794, 2795, 3, 330, 165, 0, 2795, 2796, 6, 129, -1, 0, 2796, 2798, 1, 0, 0, 0, 2797, 2794, 1, 0, 0, 0, 2798, 2801, 1, 0, 0, 0, 2799, 2797, 1, 0, 0, 0, 2799, 2800, 1, 0, 0, 0, 2800, 2855, 1, 0, 0, 0, 2801, 2799, 1, 0, 0, 0, 2802, 2803, 5, 255, 0, 0, 2803, 2804, 5, 196, 0, 0, 2804, 2810, 3, 2, 1, 0, 2805, 2806, 3, 330, 165, 0, 2806, 2807, 6, 129, -1, 0, 2807, 2809, 1, 0, 0, 0, 2808, 2805, 1, 0, 0, 0, 2809, 2812, 1, 0, 0, 0, 2810, 2808, 1, 0, 0, 0, 2810, 2811, 1, 0, 0, 0, 2811, 2855, 1, 0, 0, 0, 2812, 2810, 1, 0, 0, 0, 2813, 2814, 5, 255, 0, 0, 2814, 2815, 5, 256, 0, 0, 2815, 2816, 5, 42, 0, 0, 2816, 2817, 3, 32, 16, 0, 2817, 2818, 5, 43, 0, 0, 2818, 2819, 5, 28, 0, 0, 2819, 2825, 3, 124, 62, 0, 2820, 2821, 3, 330, 165, 0, 2821, 2822, 6, 129, -1, 0, 2822, 2824, 1, 0, 0, 0, 2823, 2820, 1, 0, 0, 0, 2824, 2827, 1, 0, 0, 0, 2825, 2823, 1, 0, 0, 0, 2825, 2826, 1, 0, 0, 0, 2826, 2855, 1, 0, 0, 0, 2827, 2825, 1, 0, 0, 0, 2828, 2829, 5, 255, 0, 0, 2829, 2830, 5, 256, 0, 0, 2830, 2831, 3, 2, 1, 0, 2831, 2832, 5, 28, 0, 0, 2832, 2838, 3, 124, 62, 0, 2833, 2834, 3, 330, 165, 0, 2834, 2835, 6, 129, -1, 0, 2835, 2837, 1, 0, 0, 0, 2836, 2833, 1, 0, 0, 0, 2837, 2840, 1, 0, 0, 0, 2838, 2836, 1, 0, 0, 0, 2838, 2839, 1, 0, 0, 0, 2839, 2855, 1, 0, 0, 0, 2840, 2838, 1, 0, 0, 0, 2841, 2842, 5, 255, 0, 0, 2842, 2843, 5, 42, 0, 0, 2843, 2844, 3, 32, 16, 0, 2844, 2845, 5, 43, 0, 0, 2845, 2851, 3, 206, 103, 0, 2846, 2847, 3, 330, 165, 0, 2847, 2848, 6, 129, -1, 0, 2848, 2850, 1, 0, 0, 0, 2849, 2846, 1, 0, 0, 0, 2850, 2853, 1, 0, 0, 0, 2851, 2849, 1, 0, 0, 0, 2851, 2852, 1, 0, 0, 0, 2852, 2855, 1, 0, 0, 0, 2853, 2851, 1, 0, 0, 0, 2854, 2789, 1, 0, 0, 0, 2854, 2802, 1, 0, 0, 0, 2854, 2813, 1, 0, 0, 0, 2854, 2828, 1, 0, 0, 0, 2854, 2841, 1, 0, 0, 0, 2855, 259, 1, 0, 0, 0, 2856, 2857, 3, 0, 0, 0, 2857, 2858, 5, 75, 0, 0, 2858, 2859, 6, 130, -1, 0, 2859, 261, 1, 0, 0, 0, 2860, 2863, 3, 44, 22, 0, 2861, 2863, 3, 46, 23, 0, 2862, 2860, 1, 0, 0, 0, 2862, 2861, 1, 0, 0, 0, 2863, 263, 1, 0, 0, 0, 2864, 2865, 5, 17, 0, 0, 2865, 2866, 3, 246, 123, 0, 2866, 2867, 5, 18, 0, 0, 2867, 265, 1, 0, 0, 0, 2868, 2869, 3, 270, 135, 0, 2869, 2870, 3, 268, 134, 0, 2870, 267, 1, 0, 0, 0, 2871, 2872, 3, 272, 136, 0, 2872, 2873, 6, 134, -1, 0, 2873, 2875, 1, 0, 0, 0, 2874, 2871, 1, 0, 0, 0, 2875, 2876, 1, 0, 0, 0, 2876, 2874, 1, 0, 0, 0, 2876, 2877, 1, 0, 0, 0, 2877, 269, 1, 0, 0, 0, 2878, 2879, 5, 158, 0, 0, 2879, 2880, 3, 264, 132, 0, 2880, 2881, 6, 135, -1, 0, 2881, 2895, 1, 0, 0, 0, 2882, 2883, 5, 158, 0, 0, 2883, 2884, 3, 0, 0, 0, 2884, 2885, 5, 159, 0, 0, 2885, 2886, 3, 0, 0, 0, 2886, 2887, 6, 135, -1, 0, 2887, 2895, 1, 0, 0, 0, 2888, 2889, 5, 158, 0, 0, 2889, 2890, 3, 32, 16, 0, 2890, 2891, 5, 159, 0, 0, 2891, 2892, 3, 32, 16, 0, 2892, 2893, 6, 135, -1, 0, 2893, 2895, 1, 0, 0, 0, 2894, 2878, 1, 0, 0, 0, 2894, 2882, 1, 0, 0, 0, 2894, 2888, 1, 0, 0, 0, 2895, 271, 1, 0, 0, 0, 2896, 2897, 3, 276, 138, 0, 2897, 2898, 3, 282, 141, 0, 2898, 2899, 6, 136, -1, 0, 2899, 2913, 1, 0, 0, 0, 2900, 2901, 3, 274, 137, 0, 2901, 2902, 3, 282, 141, 0, 2902, 2903, 6, 136, -1, 0, 2903, 2913, 1, 0, 0, 0, 2904, 2905, 3, 278, 139, 0, 2905, 2906, 3, 282, 141, 0, 2906, 2907, 6, 136, -1, 0, 2907, 2913, 1, 0, 0, 0, 2908, 2909, 3, 280, 140, 0, 2909, 2910, 3, 282, 141, 0, 2910, 2911, 6, 136, -1, 0, 2911, 2913, 1, 0, 0, 0, 2912, 2896, 1, 0, 0, 0, 2912, 2900, 1, 0, 0, 0, 2912, 2904, 1, 0, 0, 0, 2912, 2908, 1, 0, 0, 0, 2913, 273, 1, 0, 0, 0, 2914, 2915, 5, 160, 0, 0, 2915, 2916, 3, 264, 132, 0, 2916, 2917, 6, 137, -1, 0, 2917, 2927, 1, 0, 0, 0, 2918, 2919, 5, 160, 0, 0, 2919, 2920, 3, 0, 0, 0, 2920, 2921, 6, 137, -1, 0, 2921, 2927, 1, 0, 0, 0, 2922, 2923, 5, 160, 0, 0, 2923, 2924, 3, 32, 16, 0, 2924, 2925, 6, 137, -1, 0, 2925, 2927, 1, 0, 0, 0, 2926, 2914, 1, 0, 0, 0, 2926, 2918, 1, 0, 0, 0, 2926, 2922, 1, 0, 0, 0, 2927, 275, 1, 0, 0, 0, 2928, 2929, 5, 161, 0, 0, 2929, 2930, 3, 124, 62, 0, 2930, 277, 1, 0, 0, 0, 2931, 2932, 5, 162, 0, 0, 2932, 279, 1, 0, 0, 0, 2933, 2934, 5, 163, 0, 0, 2934, 281, 1, 0, 0, 0, 2935, 2936, 3, 264, 132, 0, 2936, 2937, 6, 141, -1, 0, 2937, 2951, 1, 0, 0, 0, 2938, 2939, 5, 164, 0, 0, 2939, 2940, 3, 0, 0, 0, 2940, 2941, 5, 159, 0, 0, 2941, 2942, 3, 0, 0, 0, 2942, 2943, 6, 141, -1, 0, 2943, 2951, 1, 0, 0, 0, 2944, 2945, 5, 164, 0, 0, 2945, 2946, 3, 32, 16, 0, 2946, 2947, 5, 159, 0, 0, 2947, 2948, 3, 32, 16, 0, 2948, 2949, 6, 141, -1, 0, 2949, 2951, 1, 0, 0, 0, 2950, 2935, 1, 0, 0, 0, 2950, 2938, 1, 0, 0, 0, 2950, 2944, 1, 0, 0, 0, 2951, 283, 1, 0, 0, 0, 2952, 2953, 3, 286, 143, 0, 2953, 2954, 3, 290, 145, 0, 2954, 285, 1, 0, 0, 0, 2955, 2956, 5, 165, 0, 0, 2956, 2957, 3, 288, 144, 0, 2957, 2958, 3, 0, 0, 0, 2958, 2959, 5, 36, 0, 0, 2959, 2963, 1, 0, 0, 0, 2960, 2961, 5, 165, 0, 0, 2961, 2963, 3, 288, 144, 0, 2962, 2955, 1, 0, 0, 0, 2962, 2960, 1, 0, 0, 0, 2963, 287, 1, 0, 0, 0, 2964, 2968, 1, 0, 0, 0, 2965, 2968, 5, 166, 0, 0, 2966, 2968, 5, 2, 0, 0, 2967, 2964, 1, 0, 0, 0, 2967, 2965, 1, 0, 0, 0, 2967, 2966, 1, 0, 0, 0, 2968, 289, 1, 0, 0, 0, 2969, 2970, 5, 17, 0, 0, 2970, 2971, 3, 292, 146, 0, 2971, 2972, 5, 18, 0, 0, 2972, 2979, 1, 0, 0, 0, 2973, 2975, 3, 296, 148, 0, 2974, 2973, 1, 0, 0, 0, 2975, 2976, 1, 0, 0, 0, 2976, 2974, 1, 0, 0, 0, 2976, 2977, 1, 0, 0, 0, 2977, 2979, 1, 0, 0, 0, 2978, 2969, 1, 0, 0, 0, 2978, 2974, 1, 0, 0, 0, 2979, 291, 1, 0, 0, 0, 2980, 2981, 3, 296, 148, 0, 2981, 2982, 5, 28, 0, 0, 2982, 2984, 1, 0, 0, 0, 2983, 2980, 1, 0, 0, 0, 2984, 2987, 1, 0, 0, 0, 2985, 2983, 1, 0, 0, 0, 2985, 2986, 1, 0, 0, 0, 2986, 2988, 1, 0, 0, 0, 2987, 2985, 1, 0, 0, 0, 2988, 2989, 3, 296, 148, 0, 2989, 293, 1, 0, 0, 0, 2990, 2996, 1, 0, 0, 0, 2991, 2992, 5, 42, 0, 0, 2992, 2993, 3, 32, 16, 0, 2993, 2994, 5, 43, 0, 0, 2994, 2996, 1, 0, 0, 0, 2995, 2990, 1, 0, 0, 0, 2995, 2991, 1, 0, 0, 0, 2996, 295, 1, 0, 0, 0, 2997, 2998, 5, 181, 0, 0, 2998, 2999, 5, 262, 0, 0, 2999, 3000, 5, 30, 0, 0, 3000, 3001, 3, 6, 3, 0, 3001, 3002, 5, 31, 0, 0, 3002, 3064, 1, 0, 0, 0, 3003, 3004, 5, 260, 0, 0, 3004, 3005, 5, 30, 0, 0, 3005, 3006, 3, 0, 0, 0, 3006, 3007, 5, 31, 0, 0, 3007, 3064, 1, 0, 0, 0, 3008, 3009, 5, 260, 0, 0, 3009, 3064, 3, 0, 0, 0, 3010, 3011, 5, 84, 0, 0, 3011, 3012, 5, 30, 0, 0, 3012, 3013, 3, 300, 150, 0, 3013, 3014, 5, 31, 0, 0, 3014, 3064, 1, 0, 0, 0, 3015, 3016, 5, 188, 0, 0, 3016, 3017, 5, 30, 0, 0, 3017, 3018, 3, 36, 18, 0, 3018, 3019, 5, 31, 0, 0, 3019, 3020, 3, 294, 147, 0, 3020, 3064, 1, 0, 0, 0, 3021, 3022, 5, 189, 0, 0, 3022, 3023, 5, 30, 0, 0, 3023, 3024, 3, 36, 18, 0, 3024, 3025, 5, 31, 0, 0, 3025, 3026, 3, 294, 147, 0, 3026, 3064, 1, 0, 0, 0, 3027, 3028, 5, 187, 0, 0, 3028, 3029, 5, 30, 0, 0, 3029, 3030, 3, 34, 17, 0, 3030, 3031, 5, 31, 0, 0, 3031, 3032, 3, 294, 147, 0, 3032, 3064, 1, 0, 0, 0, 3033, 3034, 5, 186, 0, 0, 3034, 3035, 5, 30, 0, 0, 3035, 3036, 3, 32, 16, 0, 3036, 3037, 5, 31, 0, 0, 3037, 3038, 3, 294, 147, 0, 3038, 3064, 1, 0, 0, 0, 3039, 3040, 5, 185, 0, 0, 3040, 3041, 5, 30, 0, 0, 3041, 3042, 3, 32, 16, 0, 3042, 3043, 5, 31, 0, 0, 3043, 3044, 3, 294, 147, 0, 3044, 3064, 1, 0, 0, 0, 3045, 3046, 5, 184, 0, 0, 3046, 3047, 5, 30, 0, 0, 3047, 3048, 3, 32, 16, 0, 3048, 3049, 5, 31, 0, 0, 3049, 3050, 3, 294, 147, 0, 3050, 3064, 1, 0, 0, 0, 3051, 3052, 5, 188, 0, 0, 3052, 3064, 3, 294, 147, 0, 3053, 3054, 5, 189, 0, 0, 3054, 3064, 3, 294, 147, 0, 3055, 3056, 5, 187, 0, 0, 3056, 3064, 3, 294, 147, 0, 3057, 3058, 5, 186, 0, 0, 3058, 3064, 3, 294, 147, 0, 3059, 3060, 5, 185, 0, 0, 3060, 3064, 3, 294, 147, 0, 3061, 3062, 5, 184, 0, 0, 3062, 3064, 3, 294, 147, 0, 3063, 2997, 1, 0, 0, 0, 3063, 3003, 1, 0, 0, 0, 3063, 3008, 1, 0, 0, 0, 3063, 3010, 1, 0, 0, 0, 3063, 3015, 1, 0, 0, 0, 3063, 3021, 1, 0, 0, 0, 3063, 3027, 1, 0, 0, 0, 3063, 3033, 1, 0, 0, 0, 3063, 3039, 1, 0, 0, 0, 3063, 3045, 1, 0, 0, 0, 3063, 3051, 1, 0, 0, 0, 3063, 3053, 1, 0, 0, 0, 3063, 3055, 1, 0, 0, 0, 3063, 3057, 1, 0, 0, 0, 3063, 3059, 1, 0, 0, 0, 3063, 3061, 1, 0, 0, 0, 3064, 297, 1, 0, 0, 0, 3065, 3066, 5, 188, 0, 0, 3066, 3067, 5, 30, 0, 0, 3067, 3068, 3, 36, 18, 0, 3068, 3069, 5, 31, 0, 0, 3069, 3141, 1, 0, 0, 0, 3070, 3071, 5, 189, 0, 0, 3071, 3072, 5, 30, 0, 0, 3072, 3073, 3, 36, 18, 0, 3073, 3074, 5, 31, 0, 0, 3074, 3141, 1, 0, 0, 0, 3075, 3076, 5, 188, 0, 0, 3076, 3077, 5, 30, 0, 0, 3077, 3078, 3, 32, 16, 0, 3078, 3079, 5, 31, 0, 0, 3079, 3141, 1, 0, 0, 0, 3080, 3081, 5, 189, 0, 0, 3081, 3082, 5, 30, 0, 0, 3082, 3083, 3, 34, 17, 0, 3083, 3084, 5, 31, 0, 0, 3084, 3141, 1, 0, 0, 0, 3085, 3086, 5, 187, 0, 0, 3086, 3087, 5, 30, 0, 0, 3087, 3088, 3, 34, 17, 0, 3088, 3089, 5, 31, 0, 0, 3089, 3141, 1, 0, 0, 0, 3090, 3091, 5, 186, 0, 0, 3091, 3092, 5, 30, 0, 0, 3092, 3093, 3, 32, 16, 0, 3093, 3094, 5, 31, 0, 0, 3094, 3141, 1, 0, 0, 0, 3095, 3096, 5, 185, 0, 0, 3096, 3097, 5, 30, 0, 0, 3097, 3098, 3, 32, 16, 0, 3098, 3099, 5, 31, 0, 0, 3099, 3141, 1, 0, 0, 0, 3100, 3101, 5, 184, 0, 0, 3101, 3102, 5, 30, 0, 0, 3102, 3103, 3, 32, 16, 0, 3103, 3104, 5, 31, 0, 0, 3104, 3141, 1, 0, 0, 0, 3105, 3106, 5, 193, 0, 0, 3106, 3107, 5, 30, 0, 0, 3107, 3108, 3, 34, 17, 0, 3108, 3109, 5, 31, 0, 0, 3109, 3141, 1, 0, 0, 0, 3110, 3111, 5, 192, 0, 0, 3111, 3112, 5, 30, 0, 0, 3112, 3113, 3, 32, 16, 0, 3113, 3114, 5, 31, 0, 0, 3114, 3141, 1, 0, 0, 0, 3115, 3116, 5, 191, 0, 0, 3116, 3117, 5, 30, 0, 0, 3117, 3118, 3, 32, 16, 0, 3118, 3119, 5, 31, 0, 0, 3119, 3141, 1, 0, 0, 0, 3120, 3121, 5, 190, 0, 0, 3121, 3122, 5, 30, 0, 0, 3122, 3123, 3, 32, 16, 0, 3123, 3124, 5, 31, 0, 0, 3124, 3141, 1, 0, 0, 0, 3125, 3126, 5, 181, 0, 0, 3126, 3127, 5, 30, 0, 0, 3127, 3128, 3, 32, 16, 0, 3128, 3129, 5, 31, 0, 0, 3129, 3141, 1, 0, 0, 0, 3130, 3131, 5, 183, 0, 0, 3131, 3132, 5, 30, 0, 0, 3132, 3133, 3, 162, 81, 0, 3133, 3134, 5, 31, 0, 0, 3134, 3141, 1, 0, 0, 0, 3135, 3136, 5, 84, 0, 0, 3136, 3137, 5, 30, 0, 0, 3137, 3138, 3, 300, 150, 0, 3138, 3139, 5, 31, 0, 0, 3139, 3141, 1, 0, 0, 0, 3140, 3065, 1, 0, 0, 0, 3140, 3070, 1, 0, 0, 0, 3140, 3075, 1, 0, 0, 0, 3140, 3080, 1, 0, 0, 0, 3140, 3085, 1, 0, 0, 0, 3140, 3090, 1, 0, 0, 0, 3140, 3095, 1, 0, 0, 0, 3140, 3100, 1, 0, 0, 0, 3140, 3105, 1, 0, 0, 0, 3140, 3110, 1, 0, 0, 0, 3140, 3115, 1, 0, 0, 0, 3140, 3120, 1, 0, 0, 0, 3140, 3125, 1, 0, 0, 0, 3140, 3130, 1, 0, 0, 0, 3140, 3135, 1, 0, 0, 0, 3141, 299, 1, 0, 0, 0, 3142, 3143, 3, 302, 151, 0, 3143, 3144, 6, 150, -1, 0, 3144, 3146, 1, 0, 0, 0, 3145, 3142, 1, 0, 0, 0, 3146, 3149, 1, 0, 0, 0, 3147, 3145, 1, 0, 0, 0, 3147, 3148, 1, 0, 0, 0, 3148, 301, 1, 0, 0, 0, 3149, 3147, 1, 0, 0, 0, 3150, 3151, 7, 10, 0, 0, 3151, 303, 1, 0, 0, 0, 3152, 3156, 3, 298, 149, 0, 3153, 3156, 3, 6, 3, 0, 3154, 3156, 5, 179, 0, 0, 3155, 3152, 1, 0, 0, 0, 3155, 3153, 1, 0, 0, 0, 3155, 3154, 1, 0, 0, 0, 3156, 305, 1, 0, 0, 0, 3157, 3306, 3, 298, 149, 0, 3158, 3159, 5, 182, 0, 0, 3159, 3160, 5, 30, 0, 0, 3160, 3161, 5, 179, 0, 0, 3161, 3306, 5, 31, 0, 0, 3162, 3163, 5, 182, 0, 0, 3163, 3164, 5, 30, 0, 0, 3164, 3165, 5, 264, 0, 0, 3165, 3306, 5, 31, 0, 0, 3166, 3167, 5, 196, 0, 0, 3167, 3168, 5, 30, 0, 0, 3168, 3169, 5, 39, 0, 0, 3169, 3170, 5, 264, 0, 0, 3170, 3306, 5, 31, 0, 0, 3171, 3172, 5, 196, 0, 0, 3172, 3173, 5, 30, 0, 0, 3173, 3174, 3, 116, 58, 0, 3174, 3175, 5, 31, 0, 0, 3175, 3306, 1, 0, 0, 0, 3176, 3177, 5, 196, 0, 0, 3177, 3178, 5, 30, 0, 0, 3178, 3179, 5, 179, 0, 0, 3179, 3306, 5, 31, 0, 0, 3180, 3181, 5, 197, 0, 0, 3181, 3182, 5, 30, 0, 0, 3182, 3183, 3, 306, 153, 0, 3183, 3184, 5, 31, 0, 0, 3184, 3306, 1, 0, 0, 0, 3185, 3186, 5, 188, 0, 0, 3186, 3187, 5, 42, 0, 0, 3187, 3188, 3, 32, 16, 0, 3188, 3189, 5, 43, 0, 0, 3189, 3190, 5, 30, 0, 0, 3190, 3191, 3, 308, 154, 0, 3191, 3192, 5, 31, 0, 0, 3192, 3306, 1, 0, 0, 0, 3193, 3194, 5, 189, 0, 0, 3194, 3195, 5, 42, 0, 0, 3195, 3196, 3, 32, 16, 0, 3196, 3197, 5, 43, 0, 0, 3197, 3198, 5, 30, 0, 0, 3198, 3199, 3, 310, 155, 0, 3199, 3200, 5, 31, 0, 0, 3200, 3306, 1, 0, 0, 0, 3201, 3202, 5, 187, 0, 0, 3202, 3203, 5, 42, 0, 0, 3203, 3204, 3, 32, 16, 0, 3204, 3205, 5, 43, 0, 0, 3205, 3206, 5, 30, 0, 0, 3206, 3207, 3, 312, 156, 0, 3207, 3208, 5, 31, 0, 0, 3208, 3306, 1, 0, 0, 0, 3209, 3210, 5, 186, 0, 0, 3210, 3211, 5, 42, 0, 0, 3211, 3212, 3, 32, 16, 0, 3212, 3213, 5, 43, 0, 0, 3213, 3214, 5, 30, 0, 0, 3214, 3215, 3, 314, 157, 0, 3215, 3216, 5, 31, 0, 0, 3216, 3306, 1, 0, 0, 0, 3217, 3218, 5, 185, 0, 0, 3218, 3219, 5, 42, 0, 0, 3219, 3220, 3, 32, 16, 0, 3220, 3221, 5, 43, 0, 0, 3221, 3222, 5, 30, 0, 0, 3222, 3223, 3, 316, 158, 0, 3223, 3224, 5, 31, 0, 0, 3224, 3306, 1, 0, 0, 0, 3225, 3226, 5, 184, 0, 0, 3226, 3227, 5, 42, 0, 0, 3227, 3228, 3, 32, 16, 0, 3228, 3229, 5, 43, 0, 0, 3229, 3230, 5, 30, 0, 0, 3230, 3231, 3, 318, 159, 0, 3231, 3232, 5, 31, 0, 0, 3232, 3306, 1, 0, 0, 0, 3233, 3234, 5, 193, 0, 0, 3234, 3235, 5, 42, 0, 0, 3235, 3236, 3, 32, 16, 0, 3236, 3237, 5, 43, 0, 0, 3237, 3238, 5, 30, 0, 0, 3238, 3239, 3, 312, 156, 0, 3239, 3240, 5, 31, 0, 0, 3240, 3306, 1, 0, 0, 0, 3241, 3242, 5, 192, 0, 0, 3242, 3243, 5, 42, 0, 0, 3243, 3244, 3, 32, 16, 0, 3244, 3245, 5, 43, 0, 0, 3245, 3246, 5, 30, 0, 0, 3246, 3247, 3, 314, 157, 0, 3247, 3248, 5, 31, 0, 0, 3248, 3306, 1, 0, 0, 0, 3249, 3250, 5, 191, 0, 0, 3250, 3251, 5, 42, 0, 0, 3251, 3252, 3, 32, 16, 0, 3252, 3253, 5, 43, 0, 0, 3253, 3254, 5, 30, 0, 0, 3254, 3255, 3, 316, 158, 0, 3255, 3256, 5, 31, 0, 0, 3256, 3306, 1, 0, 0, 0, 3257, 3258, 5, 190, 0, 0, 3258, 3259, 5, 42, 0, 0, 3259, 3260, 3, 32, 16, 0, 3260, 3261, 5, 43, 0, 0, 3261, 3262, 5, 30, 0, 0, 3262, 3263, 3, 318, 159, 0, 3263, 3264, 5, 31, 0, 0, 3264, 3306, 1, 0, 0, 0, 3265, 3266, 5, 181, 0, 0, 3266, 3267, 5, 42, 0, 0, 3267, 3268, 3, 32, 16, 0, 3268, 3269, 5, 43, 0, 0, 3269, 3270, 5, 30, 0, 0, 3270, 3271, 3, 316, 158, 0, 3271, 3272, 5, 31, 0, 0, 3272, 3306, 1, 0, 0, 0, 3273, 3274, 5, 183, 0, 0, 3274, 3275, 5, 42, 0, 0, 3275, 3276, 3, 32, 16, 0, 3276, 3277, 5, 43, 0, 0, 3277, 3278, 5, 30, 0, 0, 3278, 3279, 3, 320, 160, 0, 3279, 3280, 5, 31, 0, 0, 3280, 3306, 1, 0, 0, 0, 3281, 3282, 5, 182, 0, 0, 3282, 3283, 5, 42, 0, 0, 3283, 3284, 3, 32, 16, 0, 3284, 3285, 5, 43, 0, 0, 3285, 3286, 5, 30, 0, 0, 3286, 3287, 3, 322, 161, 0, 3287, 3288, 5, 31, 0, 0, 3288, 3306, 1, 0, 0, 0, 3289, 3290, 5, 196, 0, 0, 3290, 3291, 5, 42, 0, 0, 3291, 3292, 3, 32, 16, 0, 3292, 3293, 5, 43, 0, 0, 3293, 3294, 5, 30, 0, 0, 3294, 3295, 3, 324, 162, 0, 3295, 3296, 5, 31, 0, 0, 3296, 3306, 1, 0, 0, 0, 3297, 3298, 5, 197, 0, 0, 3298, 3299, 5, 42, 0, 0, 3299, 3300, 3, 32, 16, 0, 3300, 3301, 5, 43, 0, 0, 3301, 3302, 5, 30, 0, 0, 3302, 3303, 3, 328, 164, 0, 3303, 3304, 5, 31, 0, 0, 3304, 3306, 1, 0, 0, 0, 3305, 3157, 1, 0, 0, 0, 3305, 3158, 1, 0, 0, 0, 3305, 3162, 1, 0, 0, 0, 3305, 3166, 1, 0, 0, 0, 3305, 3171, 1, 0, 0, 0, 3305, 3176, 1, 0, 0, 0, 3305, 3180, 1, 0, 0, 0, 3305, 3185, 1, 0, 0, 0, 3305, 3193, 1, 0, 0, 0, 3305, 3201, 1, 0, 0, 0, 3305, 3209, 1, 0, 0, 0, 3305, 3217, 1, 0, 0, 0, 3305, 3225, 1, 0, 0, 0, 3305, 3233, 1, 0, 0, 0, 3305, 3241, 1, 0, 0, 0, 3305, 3249, 1, 0, 0, 0, 3305, 3257, 1, 0, 0, 0, 3305, 3265, 1, 0, 0, 0, 3305, 3273, 1, 0, 0, 0, 3305, 3281, 1, 0, 0, 0, 3305, 3289, 1, 0, 0, 0, 3305, 3297, 1, 0, 0, 0, 3306, 307, 1, 0, 0, 0, 3307, 3310, 3, 36, 18, 0, 3308, 3310, 3, 32, 16, 0, 3309, 3307, 1, 0, 0, 0, 3309, 3308, 1, 0, 0, 0, 3310, 3313, 1, 0, 0, 0, 3311, 3309, 1, 0, 0, 0, 3311, 3312, 1, 0, 0, 0, 3312, 309, 1, 0, 0, 0, 3313, 3311, 1, 0, 0, 0, 3314, 3317, 3, 36, 18, 0, 3315, 3317, 3, 34, 17, 0, 3316, 3314, 1, 0, 0, 0, 3316, 3315, 1, 0, 0, 0, 3317, 3320, 1, 0, 0, 0, 3318, 3316, 1, 0, 0, 0, 3318, 3319, 1, 0, 0, 0, 3319, 311, 1, 0, 0, 0, 3320, 3318, 1, 0, 0, 0, 3321, 3323, 3, 34, 17, 0, 3322, 3321, 1, 0, 0, 0, 3323, 3326, 1, 0, 0, 0, 3324, 3322, 1, 0, 0, 0, 3324, 3325, 1, 0, 0, 0, 3325, 313, 1, 0, 0, 0, 3326, 3324, 1, 0, 0, 0, 3327, 3329, 3, 32, 16, 0, 3328, 3327, 1, 0, 0, 0, 3329, 3332, 1, 0, 0, 0, 3330, 3328, 1, 0, 0, 0, 3330, 3331, 1, 0, 0, 0, 3331, 315, 1, 0, 0, 0, 3332, 3330, 1, 0, 0, 0, 3333, 3335, 3, 32, 16, 0, 3334, 3333, 1, 0, 0, 0, 3335, 3338, 1, 0, 0, 0, 3336, 3334, 1, 0, 0, 0, 3336, 3337, 1, 0, 0, 0, 3337, 317, 1, 0, 0, 0, 3338, 3336, 1, 0, 0, 0, 3339, 3341, 3, 32, 16, 0, 3340, 3339, 1, 0, 0, 0, 3341, 3344, 1, 0, 0, 0, 3342, 3340, 1, 0, 0, 0, 3342, 3343, 1, 0, 0, 0, 3343, 319, 1, 0, 0, 0, 3344, 3342, 1, 0, 0, 0, 3345, 3347, 3, 162, 81, 0, 3346, 3345, 1, 0, 0, 0, 3347, 3350, 1, 0, 0, 0, 3348, 3346, 1, 0, 0, 0, 3348, 3349, 1, 0, 0, 0, 3349, 321, 1, 0, 0, 0, 3350, 3348, 1, 0, 0, 0, 3351, 3353, 7, 11, 0, 0, 3352, 3351, 1, 0, 0, 0, 3353, 3356, 1, 0, 0, 0, 3354, 3352, 1, 0, 0, 0, 3354, 3355, 1, 0, 0, 0, 3355, 323, 1, 0, 0, 0, 3356, 3354, 1, 0, 0, 0, 3357, 3359, 3, 326, 163, 0, 3358, 3357, 1, 0, 0, 0, 3359, 3362, 1, 0, 0, 0, 3360, 3358, 1, 0, 0, 0, 3360, 3361, 1, 0, 0, 0, 3361, 325, 1, 0, 0, 0, 3362, 3360, 1, 0, 0, 0, 3363, 3368, 5, 179, 0, 0, 3364, 3365, 5, 39, 0, 0, 3365, 3368, 5, 264, 0, 0, 3366, 3368, 3, 116, 58, 0, 3367, 3363, 1, 0, 0, 0, 3367, 3364, 1, 0, 0, 0, 3367, 3366, 1, 0, 0, 0, 3368, 327, 1, 0, 0, 0, 3369, 3371, 3, 306, 153, 0, 3370, 3369, 1, 0, 0, 0, 3371, 3374, 1, 0, 0, 0, 3372, 3370, 1, 0, 0, 0, 3372, 3373, 1, 0, 0, 0, 3373, 329, 1, 0, 0, 0, 3374, 3372, 1, 0, 0, 0, 3375, 3379, 3, 44, 22, 0, 3376, 3379, 3, 46, 23, 0, 3377, 3379, 3, 2, 1, 0, 3378, 3375, 1, 0, 0, 0, 3378, 3376, 1, 0, 0, 0, 3378, 3377, 1, 0, 0, 0, 3379, 331, 1, 0, 0, 0, 3380, 3381, 7, 12, 0, 0, 3381, 3382, 5, 36, 0, 0, 3382, 3383, 5, 30, 0, 0, 3383, 3384, 3, 300, 150, 0, 3384, 3385, 5, 31, 0, 0, 3385, 3406, 1, 0, 0, 0, 3386, 3387, 5, 169, 0, 0, 3387, 3388, 3, 38, 19, 0, 3388, 3389, 5, 75, 0, 0, 3389, 3390, 3, 38, 19, 0, 3390, 3391, 5, 75, 0, 0, 3391, 3392, 3, 38, 19, 0, 3392, 3393, 5, 75, 0, 0, 3393, 3394, 3, 38, 19, 0, 3394, 3406, 1, 0, 0, 0, 3395, 3396, 5, 170, 0, 0, 3396, 3406, 3, 6, 3, 0, 3397, 3398, 5, 170, 0, 0, 3398, 3399, 5, 36, 0, 0, 3399, 3400, 5, 30, 0, 0, 3400, 3401, 3, 300, 150, 0, 3401, 3402, 5, 31, 0, 0, 3402, 3406, 1, 0, 0, 0, 3403, 3406, 3, 330, 165, 0, 3404, 3406, 3, 40, 20, 0, 3405, 3380, 1, 0, 0, 0, 3405, 3386, 1, 0, 0, 0, 3405, 3395, 1, 0, 0, 0, 3405, 3397, 1, 0, 0, 0, 3405, 3403, 1, 0, 0, 0, 3405, 3404, 1, 0, 0, 0, 3406, 333, 1, 0, 0, 0, 3407, 3408, 3, 336, 168, 0, 3408, 3409, 5, 17, 0, 0, 3409, 3410, 3, 338, 169, 0, 3410, 3411, 5, 18, 0, 0, 3411, 335, 1, 0, 0, 0, 3412, 3413, 5, 25, 0, 0, 3413, 3414, 5, 40, 0, 0, 3414, 3415, 3, 98, 49, 0, 3415, 3416, 3, 2, 1, 0, 3416, 3425, 1, 0, 0, 0, 3417, 3418, 5, 25, 0, 0, 3418, 3419, 5, 40, 0, 0, 3419, 3420, 3, 98, 49, 0, 3420, 3421, 3, 2, 1, 0, 3421, 3422, 5, 34, 0, 0, 3422, 3423, 3, 2, 1, 0, 3423, 3425, 1, 0, 0, 0, 3424, 3412, 1, 0, 0, 0, 3424, 3417, 1, 0, 0, 0, 3425, 337, 1, 0, 0, 0, 3426, 3428, 3, 340, 170, 0, 3427, 3426, 1, 0, 0, 0, 3428, 3431, 1, 0, 0, 0, 3429, 3427, 1, 0, 0, 0, 3429, 3430, 1, 0, 0, 0, 3430, 339, 1, 0, 0, 0, 3431, 3429, 1, 0, 0, 0, 3432, 3433, 5, 180, 0, 0, 3433, 3434, 5, 36, 0, 0, 3434, 3435, 5, 30, 0, 0, 3435, 3436, 3, 300, 150, 0, 3436, 3437, 5, 31, 0, 0, 3437, 3447, 1, 0, 0, 0, 3438, 3447, 3, 332, 166, 0, 3439, 3440, 5, 171, 0, 0, 3440, 3441, 5, 36, 0, 0, 3441, 3442, 5, 30, 0, 0, 3442, 3443, 3, 300, 150, 0, 3443, 3444, 5, 31, 0, 0, 3444, 3447, 1, 0, 0, 0, 3445, 3447, 5, 55, 0, 0, 3446, 3432, 1, 0, 0, 0, 3446, 3438, 1, 0, 0, 0, 3446, 3439, 1, 0, 0, 0, 3446, 3445, 1, 0, 0, 0, 3447, 341, 1, 0, 0, 0, 3448, 3449, 3, 344, 172, 0, 3449, 3450, 5, 17, 0, 0, 3450, 3451, 3, 350, 175, 0, 3451, 3452, 5, 18, 0, 0, 3452, 343, 1, 0, 0, 0, 3453, 3454, 5, 50, 0, 0, 3454, 3458, 5, 40, 0, 0, 3455, 3457, 3, 348, 174, 0, 3456, 3455, 1, 0, 0, 0, 3457, 3460, 1, 0, 0, 0, 3458, 3456, 1, 0, 0, 0, 3458, 3459, 1, 0, 0, 0, 3459, 3461, 1, 0, 0, 0, 3460, 3458, 1, 0, 0, 0, 3461, 3462, 3, 2, 1, 0, 3462, 345, 1, 0, 0, 0, 3463, 3467, 5, 301, 0, 0, 3464, 3466, 3, 348, 174, 0, 3465, 3464, 1, 0, 0, 0, 3466, 3469, 1, 0, 0, 0, 3467, 3465, 1, 0, 0, 0, 3467, 3468, 1, 0, 0, 0, 3468, 3470, 1, 0, 0, 0, 3469, 3467, 1, 0, 0, 0, 3470, 3471, 3, 2, 1, 0, 3471, 347, 1, 0, 0, 0, 3472, 3488, 5, 52, 0, 0, 3473, 3488, 5, 51, 0, 0, 3474, 3488, 5, 172, 0, 0, 3475, 3476, 5, 62, 0, 0, 3476, 3488, 5, 51, 0, 0, 3477, 3478, 5, 62, 0, 0, 3478, 3488, 5, 52, 0, 0, 3479, 3480, 5, 62, 0, 0, 3480, 3488, 5, 63, 0, 0, 3481, 3482, 5, 62, 0, 0, 3482, 3488, 5, 64, 0, 0, 3483, 3484, 5, 62, 0, 0, 3484, 3488, 5, 65, 0, 0, 3485, 3486, 5, 62, 0, 0, 3486, 3488, 5, 66, 0, 0, 3487, 3472, 1, 0, 0, 0, 3487, 3473, 1, 0, 0, 0, 3487, 3474, 1, 0, 0, 0, 3487, 3475, 1, 0, 0, 0, 3487, 3477, 1, 0, 0, 0, 3487, 3479, 1, 0, 0, 0, 3487, 3481, 1, 0, 0, 0, 3487, 3483, 1, 0, 0, 0, 3487, 3485, 1, 0, 0, 0, 3488, 349, 1, 0, 0, 0, 3489, 3491, 3, 352, 176, 0, 3490, 3489, 1, 0, 0, 0, 3491, 3494, 1, 0, 0, 0, 3492, 3490, 1, 0, 0, 0, 3492, 3493, 1, 0, 0, 0, 3493, 351, 1, 0, 0, 0, 3494, 3492, 1, 0, 0, 0, 3495, 3496, 5, 21, 0, 0, 3496, 3509, 3, 2, 1, 0, 3497, 3498, 5, 50, 0, 0, 3498, 3499, 5, 40, 0, 0, 3499, 3509, 3, 118, 59, 0, 3500, 3501, 5, 25, 0, 0, 3501, 3502, 5, 40, 0, 0, 3502, 3509, 3, 2, 1, 0, 3503, 3509, 3, 174, 87, 0, 3504, 3505, 5, 50, 0, 0, 3505, 3509, 3, 32, 16, 0, 3506, 3509, 3, 330, 165, 0, 3507, 3509, 3, 40, 20, 0, 3508, 3495, 1, 0, 0, 0, 3508, 3497, 1, 0, 0, 0, 3508, 3500, 1, 0, 0, 0, 3508, 3503, 1, 0, 0, 0, 3508, 3504, 1, 0, 0, 0, 3508, 3506, 1, 0, 0, 0, 3508, 3507, 1, 0, 0, 0, 3509, 353, 1, 0, 0, 0, 3510, 3511, 3, 356, 178, 0, 3511, 3512, 5, 17, 0, 0, 3512, 3513, 3, 360, 180, 0, 3513, 3514, 5, 18, 0, 0, 3514, 355, 1, 0, 0, 0, 3515, 3519, 5, 274, 0, 0, 3516, 3518, 3, 358, 179, 0, 3517, 3516, 1, 0, 0, 0, 3518, 3521, 1, 0, 0, 0, 3519, 3517, 1, 0, 0, 0, 3519, 3520, 1, 0, 0, 0, 3520, 3522, 1, 0, 0, 0, 3521, 3519, 1, 0, 0, 0, 3522, 3535, 3, 2, 1, 0, 3523, 3527, 5, 274, 0, 0, 3524, 3526, 3, 358, 179, 0, 3525, 3524, 1, 0, 0, 0, 3526, 3529, 1, 0, 0, 0, 3527, 3525, 1, 0, 0, 0, 3527, 3528, 1, 0, 0, 0, 3528, 3530, 1, 0, 0, 0, 3529, 3527, 1, 0, 0, 0, 3530, 3531, 3, 2, 1, 0, 3531, 3532, 5, 34, 0, 0, 3532, 3533, 3, 2, 1, 0, 3533, 3535, 1, 0, 0, 0, 3534, 3515, 1, 0, 0, 0, 3534, 3523, 1, 0, 0, 0, 3535, 357, 1, 0, 0, 0, 3536, 3537, 7, 13, 0, 0, 3537, 359, 1, 0, 0, 0, 3538, 3540, 3, 362, 181, 0, 3539, 3538, 1, 0, 0, 0, 3540, 3543, 1, 0, 0, 0, 3541, 3539, 1, 0, 0, 0, 3541, 3542, 1, 0, 0, 0, 3542, 361, 1, 0, 0, 0, 3543, 3541, 1, 0, 0, 0, 3544, 3545, 5, 21, 0, 0, 3545, 3546, 3, 2, 1, 0, 3546, 3547, 5, 44, 0, 0, 3547, 3548, 3, 32, 16, 0, 3548, 3555, 1, 0, 0, 0, 3549, 3550, 5, 25, 0, 0, 3550, 3551, 5, 40, 0, 0, 3551, 3555, 3, 2, 1, 0, 3552, 3555, 3, 330, 165, 0, 3553, 3555, 3, 40, 20, 0, 3554, 3544, 1, 0, 0, 0, 3554, 3549, 1, 0, 0, 0, 3554, 3552, 1, 0, 0, 0, 3554, 3553, 1, 0, 0, 0, 3555, 363, 1, 0, 0, 0, 181, 374, 382, 391, 400, 489, 535, 546, 576, 580, 598, 625, 648, 684, 694, 701, 703, 713, 715, 722, 733, 746, 767, 769, 788, 861, 868, 875, 880, 889, 1000, 1006, 1022, 1028, 1034, 1041, 1069, 1147, 1149, 1163, 1169, 1178, 1180, 1189, 1203, 1217, 1225, 1233, 1237, 1276, 1284, 1293, 1301, 1320, 1330, 1333, 1357, 1504, 1514, 1523, 1526, 1608, 1617, 1649, 1709, 1749, 1765, 1775, 1802, 1826, 1834, 1838, 1853, 1860, 1905, 1915, 1933, 1951, 1970, 1991, 2010, 2025, 2033, 2045, 2065, 2072, 2077, 2088, 2100, 2210, 2222, 2238, 2252, 2261, 2274, 2276, 2319, 2330, 2337, 2345, 2353, 2366, 2372, 2378, 2383, 2412, 2420, 2434, 2439, 2464, 2473, 2484, 2488, 2495, 2515, 2524, 2526, 2541, 2588, 2598, 2600, 2607, 2613, 2657, 2666, 2706, 2711, 2751, 2755, 2765, 2787, 2799, 2810, 2825, 2838, 2851, 2854, 2862, 2876, 2894, 2912, 2926, 2950, 2962, 2967, 2976, 2978, 2985, 2995, 3063, 3140, 3147, 3155, 3305, 3309, 3311, 3316, 3318, 3324, 3330, 3336, 3342, 3348, 3354, 3360, 3367, 3372, 3378, 3405, 3424, 3429, 3446, 3458, 3467, 3487, 3492, 3508, 3519, 3527, 3534, 3541, 3554] \ No newline at end of file +[4, 1, 305, 3665, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 373, 8, 1, 10, 1, 12, 1, 376, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 383, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 5, 3, 390, 8, 3, 10, 3, 12, 3, 393, 9, 3, 1, 3, 1, 3, 1, 3, 1, 4, 5, 4, 399, 8, 4, 10, 4, 12, 4, 402, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 490, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 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, 536, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 5, 15, 545, 8, 15, 10, 15, 12, 15, 548, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 577, 8, 18, 1, 19, 1, 19, 3, 19, 581, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 599, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 626, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 654, 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, 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, 694, 8, 23, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 705, 8, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 5, 27, 715, 8, 27, 10, 27, 12, 27, 718, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 728, 8, 28, 10, 28, 12, 28, 731, 9, 28, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 3, 30, 738, 8, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 760, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 773, 8, 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, 34, 1, 34, 1, 34, 1, 34, 5, 34, 794, 8, 34, 10, 34, 12, 34, 797, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 5, 37, 813, 8, 37, 10, 37, 12, 37, 816, 9, 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, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 888, 8, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 895, 8, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 902, 8, 40, 1, 41, 5, 41, 905, 8, 41, 10, 41, 12, 41, 908, 9, 41, 1, 42, 1, 42, 1, 42, 1, 42, 5, 42, 914, 8, 42, 10, 42, 12, 42, 917, 9, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 1027, 8, 44, 1, 45, 1, 45, 5, 45, 1031, 8, 45, 10, 45, 12, 45, 1034, 9, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 1047, 8, 45, 10, 45, 12, 45, 1050, 9, 45, 1, 45, 1, 45, 1, 45, 3, 45, 1055, 8, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 1061, 8, 47, 1, 48, 1, 48, 1, 49, 5, 49, 1066, 8, 49, 10, 49, 12, 49, 1069, 9, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 1096, 8, 50, 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, 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, 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, 1174, 8, 51, 3, 51, 1176, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1190, 8, 53, 1, 53, 1, 53, 5, 53, 1194, 8, 53, 10, 53, 12, 53, 1197, 9, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1205, 8, 53, 3, 53, 1207, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1214, 8, 54, 10, 54, 12, 54, 1217, 9, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1228, 8, 55, 10, 55, 12, 55, 1231, 9, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 5, 56, 1242, 8, 56, 10, 56, 12, 56, 1245, 9, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1252, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 1260, 8, 57, 1, 57, 1, 57, 3, 57, 1264, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1303, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 1309, 8, 59, 10, 59, 12, 59, 1312, 9, 59, 1, 59, 1, 59, 1, 59, 1, 60, 5, 60, 1318, 8, 60, 10, 60, 12, 60, 1321, 9, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1328, 8, 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, 3, 62, 1347, 8, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 5, 63, 1355, 8, 63, 10, 63, 12, 63, 1358, 9, 63, 3, 63, 1360, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 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, 1384, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1531, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1541, 8, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 5, 67, 1548, 8, 67, 10, 67, 12, 67, 1551, 9, 67, 3, 67, 1553, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1635, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 5, 69, 1642, 8, 69, 10, 69, 12, 69, 1645, 9, 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, 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, 1676, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1736, 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, 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, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1776, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1792, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1802, 8, 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, 3, 76, 1829, 8, 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, 1853, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 5, 77, 1859, 8, 77, 10, 77, 12, 77, 1862, 9, 77, 1, 77, 3, 77, 1865, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1880, 8, 78, 1, 79, 1, 79, 1, 79, 5, 79, 1885, 8, 79, 10, 79, 12, 79, 1888, 9, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1932, 8, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1942, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1960, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1978, 8, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1997, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 2018, 8, 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, 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 2037, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 2052, 8, 89, 1, 90, 1, 90, 1, 90, 1, 90, 5, 90, 2058, 8, 90, 10, 90, 12, 90, 2061, 9, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 2072, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 2092, 8, 92, 1, 93, 1, 93, 1, 93, 5, 93, 2097, 8, 93, 10, 93, 12, 93, 2100, 9, 93, 1, 94, 1, 94, 3, 94, 2104, 8, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 5, 95, 2113, 8, 95, 10, 95, 12, 95, 2116, 9, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 3, 97, 2127, 8, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2235, 8, 99, 10, 99, 12, 99, 2238, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2247, 8, 99, 10, 99, 12, 99, 2250, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2263, 8, 99, 10, 99, 12, 99, 2266, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2277, 8, 99, 10, 99, 12, 99, 2280, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 2288, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 2301, 8, 100, 10, 100, 12, 100, 2304, 9, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 2346, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 2357, 8, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 3, 103, 2364, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 2372, 8, 104, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2378, 8, 105, 10, 105, 12, 105, 2381, 9, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2391, 8, 105, 10, 105, 12, 105, 2394, 9, 105, 1, 105, 1, 105, 1, 105, 3, 105, 2399, 8, 105, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 2405, 8, 106, 1, 107, 5, 107, 2408, 8, 107, 10, 107, 12, 107, 2411, 9, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 2439, 8, 108, 1, 109, 1, 109, 1, 109, 1, 109, 5, 109, 2445, 8, 109, 10, 109, 12, 109, 2448, 9, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 2461, 8, 110, 1, 111, 5, 111, 2464, 8, 111, 10, 111, 12, 111, 2467, 9, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 2491, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 2500, 8, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 4, 114, 2509, 8, 114, 11, 114, 12, 114, 2510, 1, 114, 1, 114, 3, 114, 2515, 8, 114, 1, 115, 1, 115, 1, 115, 5, 115, 2520, 8, 115, 10, 115, 12, 115, 2523, 9, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 2542, 8, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2551, 8, 117, 10, 117, 12, 117, 2554, 9, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2566, 8, 117, 10, 117, 12, 117, 2569, 9, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2615, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2625, 8, 119, 3, 119, 2627, 8, 119, 1, 119, 1, 119, 1, 119, 5, 119, 2632, 8, 119, 10, 119, 12, 119, 2635, 9, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2640, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2684, 8, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 2693, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2733, 8, 122, 1, 123, 5, 123, 2736, 8, 123, 10, 123, 12, 123, 2739, 9, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2778, 8, 124, 1, 125, 1, 125, 3, 125, 2782, 8, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, 2792, 8, 126, 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, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 2814, 8, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2824, 8, 129, 10, 129, 12, 129, 2827, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2835, 8, 129, 10, 129, 12, 129, 2838, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2850, 8, 129, 10, 129, 12, 129, 2853, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2863, 8, 129, 10, 129, 12, 129, 2866, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2876, 8, 129, 10, 129, 12, 129, 2879, 9, 129, 3, 129, 2881, 8, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 2893, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 4, 134, 2905, 8, 134, 11, 134, 12, 134, 2906, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 3, 135, 2925, 8, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 3, 136, 2943, 8, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 2957, 8, 137, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 2981, 8, 141, 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 2993, 8, 143, 1, 144, 1, 144, 1, 144, 3, 144, 2998, 8, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 4, 145, 3005, 8, 145, 11, 145, 12, 145, 3006, 3, 145, 3009, 8, 145, 1, 146, 1, 146, 1, 146, 5, 146, 3014, 8, 146, 10, 146, 12, 146, 3017, 9, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 3026, 8, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 3, 148, 3094, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 3186, 8, 149, 1, 150, 1, 150, 1, 150, 5, 150, 3191, 8, 150, 10, 150, 12, 150, 3194, 9, 150, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 3, 152, 3206, 8, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 3, 153, 3379, 8, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 5, 154, 3387, 8, 154, 10, 154, 12, 154, 3390, 9, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 5, 155, 3398, 8, 155, 10, 155, 12, 155, 3401, 9, 155, 1, 156, 1, 156, 1, 156, 5, 156, 3406, 8, 156, 10, 156, 12, 156, 3409, 9, 156, 1, 157, 1, 157, 1, 157, 5, 157, 3414, 8, 157, 10, 157, 12, 157, 3417, 9, 157, 1, 158, 1, 158, 1, 158, 5, 158, 3422, 8, 158, 10, 158, 12, 158, 3425, 9, 158, 1, 159, 1, 159, 1, 159, 5, 159, 3430, 8, 159, 10, 159, 12, 159, 3433, 9, 159, 1, 160, 1, 160, 1, 160, 5, 160, 3438, 8, 160, 10, 160, 12, 160, 3441, 9, 160, 1, 161, 1, 161, 1, 161, 1, 161, 5, 161, 3447, 8, 161, 10, 161, 12, 161, 3450, 9, 161, 1, 162, 1, 162, 1, 162, 5, 162, 3455, 8, 162, 10, 162, 12, 162, 3458, 9, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 3468, 8, 163, 1, 164, 1, 164, 1, 164, 5, 164, 3473, 8, 164, 10, 164, 12, 164, 3476, 9, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 3, 165, 3487, 8, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 3, 166, 3514, 8, 166, 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, 168, 3, 168, 3533, 8, 168, 1, 169, 5, 169, 3536, 8, 169, 10, 169, 12, 169, 3539, 9, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 3555, 8, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 5, 172, 3565, 8, 172, 10, 172, 12, 172, 3568, 9, 172, 1, 172, 1, 172, 1, 173, 1, 173, 5, 173, 3574, 8, 173, 10, 173, 12, 173, 3577, 9, 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, 3, 174, 3596, 8, 174, 1, 175, 5, 175, 3599, 8, 175, 10, 175, 12, 175, 3602, 9, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 3, 176, 3617, 8, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 178, 1, 178, 5, 178, 3626, 8, 178, 10, 178, 12, 178, 3629, 9, 178, 1, 178, 1, 178, 1, 178, 5, 178, 3634, 8, 178, 10, 178, 12, 178, 3637, 9, 178, 1, 178, 1, 178, 1, 178, 1, 178, 3, 178, 3643, 8, 178, 1, 179, 1, 179, 1, 180, 5, 180, 3648, 8, 180, 10, 180, 12, 180, 3651, 9, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 3, 181, 3663, 8, 181, 1, 181, 0, 1, 68, 182, 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, 0, 13, 6, 0, 1, 15, 199, 199, 243, 243, 247, 247, 264, 264, 289, 289, 5, 0, 16, 16, 199, 199, 243, 243, 264, 264, 288, 289, 1, 0, 263, 264, 1, 0, 173, 174, 1, 0, 37, 38, 1, 0, 73, 74, 3, 0, 2, 2, 61, 61, 77, 83, 2, 0, 229, 229, 260, 261, 1, 0, 95, 96, 1, 0, 97, 111, 2, 0, 173, 173, 289, 290, 1, 0, 167, 168, 1, 0, 51, 52, 4127, 0, 364, 1, 0, 0, 0, 2, 382, 1, 0, 0, 0, 4, 384, 1, 0, 0, 0, 6, 391, 1, 0, 0, 0, 8, 400, 1, 0, 0, 0, 10, 489, 1, 0, 0, 0, 12, 491, 1, 0, 0, 0, 14, 495, 1, 0, 0, 0, 16, 499, 1, 0, 0, 0, 18, 504, 1, 0, 0, 0, 20, 508, 1, 0, 0, 0, 22, 512, 1, 0, 0, 0, 24, 519, 1, 0, 0, 0, 26, 535, 1, 0, 0, 0, 28, 537, 1, 0, 0, 0, 30, 539, 1, 0, 0, 0, 32, 551, 1, 0, 0, 0, 34, 553, 1, 0, 0, 0, 36, 576, 1, 0, 0, 0, 38, 580, 1, 0, 0, 0, 40, 598, 1, 0, 0, 0, 42, 625, 1, 0, 0, 0, 44, 653, 1, 0, 0, 0, 46, 693, 1, 0, 0, 0, 48, 695, 1, 0, 0, 0, 50, 704, 1, 0, 0, 0, 52, 706, 1, 0, 0, 0, 54, 716, 1, 0, 0, 0, 56, 729, 1, 0, 0, 0, 58, 732, 1, 0, 0, 0, 60, 735, 1, 0, 0, 0, 62, 759, 1, 0, 0, 0, 64, 772, 1, 0, 0, 0, 66, 774, 1, 0, 0, 0, 68, 782, 1, 0, 0, 0, 70, 798, 1, 0, 0, 0, 72, 804, 1, 0, 0, 0, 74, 808, 1, 0, 0, 0, 76, 887, 1, 0, 0, 0, 78, 894, 1, 0, 0, 0, 80, 901, 1, 0, 0, 0, 82, 906, 1, 0, 0, 0, 84, 915, 1, 0, 0, 0, 86, 921, 1, 0, 0, 0, 88, 1026, 1, 0, 0, 0, 90, 1054, 1, 0, 0, 0, 92, 1056, 1, 0, 0, 0, 94, 1060, 1, 0, 0, 0, 96, 1062, 1, 0, 0, 0, 98, 1067, 1, 0, 0, 0, 100, 1095, 1, 0, 0, 0, 102, 1175, 1, 0, 0, 0, 104, 1177, 1, 0, 0, 0, 106, 1206, 1, 0, 0, 0, 108, 1208, 1, 0, 0, 0, 110, 1222, 1, 0, 0, 0, 112, 1251, 1, 0, 0, 0, 114, 1263, 1, 0, 0, 0, 116, 1302, 1, 0, 0, 0, 118, 1310, 1, 0, 0, 0, 120, 1319, 1, 0, 0, 0, 122, 1327, 1, 0, 0, 0, 124, 1346, 1, 0, 0, 0, 126, 1359, 1, 0, 0, 0, 128, 1383, 1, 0, 0, 0, 130, 1530, 1, 0, 0, 0, 132, 1540, 1, 0, 0, 0, 134, 1552, 1, 0, 0, 0, 136, 1634, 1, 0, 0, 0, 138, 1636, 1, 0, 0, 0, 140, 1675, 1, 0, 0, 0, 142, 1735, 1, 0, 0, 0, 144, 1775, 1, 0, 0, 0, 146, 1791, 1, 0, 0, 0, 148, 1793, 1, 0, 0, 0, 150, 1797, 1, 0, 0, 0, 152, 1852, 1, 0, 0, 0, 154, 1864, 1, 0, 0, 0, 156, 1879, 1, 0, 0, 0, 158, 1886, 1, 0, 0, 0, 160, 1891, 1, 0, 0, 0, 162, 1895, 1, 0, 0, 0, 164, 1931, 1, 0, 0, 0, 166, 1933, 1, 0, 0, 0, 168, 1977, 1, 0, 0, 0, 170, 1996, 1, 0, 0, 0, 172, 2017, 1, 0, 0, 0, 174, 2019, 1, 0, 0, 0, 176, 2036, 1, 0, 0, 0, 178, 2051, 1, 0, 0, 0, 180, 2059, 1, 0, 0, 0, 182, 2071, 1, 0, 0, 0, 184, 2091, 1, 0, 0, 0, 186, 2098, 1, 0, 0, 0, 188, 2101, 1, 0, 0, 0, 190, 2114, 1, 0, 0, 0, 192, 2120, 1, 0, 0, 0, 194, 2126, 1, 0, 0, 0, 196, 2130, 1, 0, 0, 0, 198, 2287, 1, 0, 0, 0, 200, 2289, 1, 0, 0, 0, 202, 2345, 1, 0, 0, 0, 204, 2356, 1, 0, 0, 0, 206, 2363, 1, 0, 0, 0, 208, 2371, 1, 0, 0, 0, 210, 2398, 1, 0, 0, 0, 212, 2404, 1, 0, 0, 0, 214, 2409, 1, 0, 0, 0, 216, 2438, 1, 0, 0, 0, 218, 2440, 1, 0, 0, 0, 220, 2460, 1, 0, 0, 0, 222, 2465, 1, 0, 0, 0, 224, 2490, 1, 0, 0, 0, 226, 2499, 1, 0, 0, 0, 228, 2514, 1, 0, 0, 0, 230, 2521, 1, 0, 0, 0, 232, 2541, 1, 0, 0, 0, 234, 2543, 1, 0, 0, 0, 236, 2614, 1, 0, 0, 0, 238, 2639, 1, 0, 0, 0, 240, 2683, 1, 0, 0, 0, 242, 2692, 1, 0, 0, 0, 244, 2732, 1, 0, 0, 0, 246, 2737, 1, 0, 0, 0, 248, 2777, 1, 0, 0, 0, 250, 2779, 1, 0, 0, 0, 252, 2785, 1, 0, 0, 0, 254, 2793, 1, 0, 0, 0, 256, 2813, 1, 0, 0, 0, 258, 2880, 1, 0, 0, 0, 260, 2882, 1, 0, 0, 0, 262, 2892, 1, 0, 0, 0, 264, 2894, 1, 0, 0, 0, 266, 2898, 1, 0, 0, 0, 268, 2904, 1, 0, 0, 0, 270, 2924, 1, 0, 0, 0, 272, 2942, 1, 0, 0, 0, 274, 2956, 1, 0, 0, 0, 276, 2958, 1, 0, 0, 0, 278, 2961, 1, 0, 0, 0, 280, 2963, 1, 0, 0, 0, 282, 2980, 1, 0, 0, 0, 284, 2982, 1, 0, 0, 0, 286, 2992, 1, 0, 0, 0, 288, 2997, 1, 0, 0, 0, 290, 3008, 1, 0, 0, 0, 292, 3015, 1, 0, 0, 0, 294, 3025, 1, 0, 0, 0, 296, 3093, 1, 0, 0, 0, 298, 3185, 1, 0, 0, 0, 300, 3192, 1, 0, 0, 0, 302, 3195, 1, 0, 0, 0, 304, 3205, 1, 0, 0, 0, 306, 3378, 1, 0, 0, 0, 308, 3388, 1, 0, 0, 0, 310, 3399, 1, 0, 0, 0, 312, 3407, 1, 0, 0, 0, 314, 3415, 1, 0, 0, 0, 316, 3423, 1, 0, 0, 0, 318, 3431, 1, 0, 0, 0, 320, 3439, 1, 0, 0, 0, 322, 3448, 1, 0, 0, 0, 324, 3456, 1, 0, 0, 0, 326, 3467, 1, 0, 0, 0, 328, 3474, 1, 0, 0, 0, 330, 3486, 1, 0, 0, 0, 332, 3513, 1, 0, 0, 0, 334, 3515, 1, 0, 0, 0, 336, 3532, 1, 0, 0, 0, 338, 3537, 1, 0, 0, 0, 340, 3554, 1, 0, 0, 0, 342, 3556, 1, 0, 0, 0, 344, 3561, 1, 0, 0, 0, 346, 3571, 1, 0, 0, 0, 348, 3595, 1, 0, 0, 0, 350, 3600, 1, 0, 0, 0, 352, 3616, 1, 0, 0, 0, 354, 3618, 1, 0, 0, 0, 356, 3642, 1, 0, 0, 0, 358, 3644, 1, 0, 0, 0, 360, 3649, 1, 0, 0, 0, 362, 3662, 1, 0, 0, 0, 364, 365, 7, 0, 0, 0, 365, 1, 1, 0, 0, 0, 366, 367, 5, 288, 0, 0, 367, 383, 6, 1, -1, 0, 368, 369, 3, 4, 2, 0, 369, 370, 6, 1, -1, 0, 370, 371, 5, 265, 0, 0, 371, 373, 1, 0, 0, 0, 372, 368, 1, 0, 0, 0, 373, 376, 1, 0, 0, 0, 374, 372, 1, 0, 0, 0, 374, 375, 1, 0, 0, 0, 375, 377, 1, 0, 0, 0, 376, 374, 1, 0, 0, 0, 377, 378, 3, 4, 2, 0, 378, 379, 6, 1, -1, 0, 379, 383, 1, 0, 0, 0, 380, 381, 5, 264, 0, 0, 381, 383, 6, 1, -1, 0, 382, 366, 1, 0, 0, 0, 382, 374, 1, 0, 0, 0, 382, 380, 1, 0, 0, 0, 383, 3, 1, 0, 0, 0, 384, 385, 7, 1, 0, 0, 385, 5, 1, 0, 0, 0, 386, 387, 5, 263, 0, 0, 387, 388, 6, 3, -1, 0, 388, 390, 5, 266, 0, 0, 389, 386, 1, 0, 0, 0, 390, 393, 1, 0, 0, 0, 391, 389, 1, 0, 0, 0, 391, 392, 1, 0, 0, 0, 392, 394, 1, 0, 0, 0, 393, 391, 1, 0, 0, 0, 394, 395, 5, 263, 0, 0, 395, 396, 6, 3, -1, 0, 396, 7, 1, 0, 0, 0, 397, 399, 3, 10, 5, 0, 398, 397, 1, 0, 0, 0, 399, 402, 1, 0, 0, 0, 400, 398, 1, 0, 0, 0, 400, 401, 1, 0, 0, 0, 401, 9, 1, 0, 0, 0, 402, 400, 1, 0, 0, 0, 403, 404, 3, 74, 37, 0, 404, 405, 5, 17, 0, 0, 405, 406, 3, 82, 41, 0, 406, 407, 5, 18, 0, 0, 407, 490, 1, 0, 0, 0, 408, 409, 3, 72, 36, 0, 409, 410, 5, 17, 0, 0, 410, 411, 3, 8, 4, 0, 411, 412, 5, 18, 0, 0, 412, 490, 1, 0, 0, 0, 413, 414, 3, 234, 117, 0, 414, 415, 5, 17, 0, 0, 415, 416, 3, 246, 123, 0, 416, 417, 5, 18, 0, 0, 417, 490, 1, 0, 0, 0, 418, 490, 3, 200, 100, 0, 419, 420, 6, 5, -1, 0, 420, 421, 3, 284, 142, 0, 421, 422, 6, 5, -1, 0, 422, 490, 1, 0, 0, 0, 423, 424, 6, 5, -1, 0, 424, 425, 3, 70, 35, 0, 425, 426, 6, 5, -1, 0, 426, 490, 1, 0, 0, 0, 427, 428, 6, 5, -1, 0, 428, 429, 3, 66, 33, 0, 429, 430, 6, 5, -1, 0, 430, 490, 1, 0, 0, 0, 431, 432, 6, 5, -1, 0, 432, 433, 3, 88, 44, 0, 433, 434, 6, 5, -1, 0, 434, 490, 1, 0, 0, 0, 435, 436, 6, 5, -1, 0, 436, 437, 3, 90, 45, 0, 437, 438, 6, 5, -1, 0, 438, 490, 1, 0, 0, 0, 439, 440, 6, 5, -1, 0, 440, 441, 3, 22, 11, 0, 441, 442, 6, 5, -1, 0, 442, 490, 1, 0, 0, 0, 443, 444, 6, 5, -1, 0, 444, 445, 3, 334, 167, 0, 445, 446, 6, 5, -1, 0, 446, 490, 1, 0, 0, 0, 447, 448, 6, 5, -1, 0, 448, 449, 3, 342, 171, 0, 449, 450, 6, 5, -1, 0, 450, 490, 1, 0, 0, 0, 451, 452, 6, 5, -1, 0, 452, 453, 3, 354, 177, 0, 453, 454, 6, 5, -1, 0, 454, 490, 1, 0, 0, 0, 455, 456, 6, 5, -1, 0, 456, 457, 3, 64, 32, 0, 457, 458, 6, 5, -1, 0, 458, 490, 1, 0, 0, 0, 459, 460, 6, 5, -1, 0, 460, 461, 3, 152, 76, 0, 461, 462, 6, 5, -1, 0, 462, 490, 1, 0, 0, 0, 463, 464, 3, 330, 165, 0, 464, 465, 6, 5, -1, 0, 465, 490, 1, 0, 0, 0, 466, 467, 6, 5, -1, 0, 467, 490, 3, 12, 6, 0, 468, 469, 6, 5, -1, 0, 469, 490, 3, 14, 7, 0, 470, 471, 6, 5, -1, 0, 471, 490, 3, 16, 8, 0, 472, 473, 6, 5, -1, 0, 473, 490, 3, 18, 9, 0, 474, 475, 6, 5, -1, 0, 475, 490, 3, 20, 10, 0, 476, 477, 6, 5, -1, 0, 477, 478, 3, 26, 13, 0, 478, 479, 6, 5, -1, 0, 479, 490, 1, 0, 0, 0, 480, 481, 6, 5, -1, 0, 481, 482, 3, 42, 21, 0, 482, 483, 6, 5, -1, 0, 483, 490, 1, 0, 0, 0, 484, 485, 6, 5, -1, 0, 485, 490, 3, 40, 20, 0, 486, 490, 3, 30, 15, 0, 487, 488, 6, 5, -1, 0, 488, 490, 3, 24, 12, 0, 489, 403, 1, 0, 0, 0, 489, 408, 1, 0, 0, 0, 489, 413, 1, 0, 0, 0, 489, 418, 1, 0, 0, 0, 489, 419, 1, 0, 0, 0, 489, 423, 1, 0, 0, 0, 489, 427, 1, 0, 0, 0, 489, 431, 1, 0, 0, 0, 489, 435, 1, 0, 0, 0, 489, 439, 1, 0, 0, 0, 489, 443, 1, 0, 0, 0, 489, 447, 1, 0, 0, 0, 489, 451, 1, 0, 0, 0, 489, 455, 1, 0, 0, 0, 489, 459, 1, 0, 0, 0, 489, 463, 1, 0, 0, 0, 489, 466, 1, 0, 0, 0, 489, 468, 1, 0, 0, 0, 489, 470, 1, 0, 0, 0, 489, 472, 1, 0, 0, 0, 489, 474, 1, 0, 0, 0, 489, 476, 1, 0, 0, 0, 489, 480, 1, 0, 0, 0, 489, 484, 1, 0, 0, 0, 489, 486, 1, 0, 0, 0, 489, 487, 1, 0, 0, 0, 490, 11, 1, 0, 0, 0, 491, 492, 5, 19, 0, 0, 492, 493, 3, 32, 16, 0, 493, 494, 6, 6, -1, 0, 494, 13, 1, 0, 0, 0, 495, 496, 5, 20, 0, 0, 496, 497, 3, 32, 16, 0, 497, 498, 6, 7, -1, 0, 498, 15, 1, 0, 0, 0, 499, 500, 5, 21, 0, 0, 500, 501, 5, 22, 0, 0, 501, 502, 3, 32, 16, 0, 502, 503, 6, 8, -1, 0, 503, 17, 1, 0, 0, 0, 504, 505, 5, 23, 0, 0, 505, 506, 3, 34, 17, 0, 506, 507, 6, 9, -1, 0, 507, 19, 1, 0, 0, 0, 508, 509, 5, 24, 0, 0, 509, 510, 3, 34, 17, 0, 510, 511, 6, 10, -1, 0, 511, 21, 1, 0, 0, 0, 512, 513, 5, 25, 0, 0, 513, 514, 3, 98, 49, 0, 514, 515, 3, 2, 1, 0, 515, 516, 5, 17, 0, 0, 516, 517, 3, 120, 60, 0, 517, 518, 5, 18, 0, 0, 518, 23, 1, 0, 0, 0, 519, 520, 5, 26, 0, 0, 520, 25, 1, 0, 0, 0, 521, 522, 5, 27, 0, 0, 522, 536, 3, 28, 14, 0, 523, 524, 5, 27, 0, 0, 524, 525, 3, 28, 14, 0, 525, 526, 5, 28, 0, 0, 526, 527, 3, 28, 14, 0, 527, 536, 1, 0, 0, 0, 528, 529, 5, 27, 0, 0, 529, 530, 3, 28, 14, 0, 530, 531, 5, 28, 0, 0, 531, 532, 3, 28, 14, 0, 532, 533, 5, 28, 0, 0, 533, 534, 3, 28, 14, 0, 534, 536, 1, 0, 0, 0, 535, 521, 1, 0, 0, 0, 535, 523, 1, 0, 0, 0, 535, 528, 1, 0, 0, 0, 536, 27, 1, 0, 0, 0, 537, 538, 7, 2, 0, 0, 538, 29, 1, 0, 0, 0, 539, 540, 5, 29, 0, 0, 540, 546, 5, 17, 0, 0, 541, 542, 3, 116, 58, 0, 542, 543, 6, 15, -1, 0, 543, 545, 1, 0, 0, 0, 544, 541, 1, 0, 0, 0, 545, 548, 1, 0, 0, 0, 546, 544, 1, 0, 0, 0, 546, 547, 1, 0, 0, 0, 547, 549, 1, 0, 0, 0, 548, 546, 1, 0, 0, 0, 549, 550, 5, 18, 0, 0, 550, 31, 1, 0, 0, 0, 551, 552, 5, 173, 0, 0, 552, 33, 1, 0, 0, 0, 553, 554, 7, 3, 0, 0, 554, 35, 1, 0, 0, 0, 555, 556, 5, 175, 0, 0, 556, 577, 6, 18, -1, 0, 557, 558, 3, 32, 16, 0, 558, 559, 5, 265, 0, 0, 559, 560, 6, 18, -1, 0, 560, 577, 1, 0, 0, 0, 561, 562, 3, 32, 16, 0, 562, 563, 6, 18, -1, 0, 563, 577, 1, 0, 0, 0, 564, 565, 5, 188, 0, 0, 565, 566, 5, 30, 0, 0, 566, 567, 3, 32, 16, 0, 567, 568, 5, 31, 0, 0, 568, 569, 6, 18, -1, 0, 569, 577, 1, 0, 0, 0, 570, 571, 5, 189, 0, 0, 571, 572, 5, 30, 0, 0, 572, 573, 3, 34, 17, 0, 573, 574, 5, 31, 0, 0, 574, 575, 6, 18, -1, 0, 575, 577, 1, 0, 0, 0, 576, 555, 1, 0, 0, 0, 576, 557, 1, 0, 0, 0, 576, 561, 1, 0, 0, 0, 576, 564, 1, 0, 0, 0, 576, 570, 1, 0, 0, 0, 577, 37, 1, 0, 0, 0, 578, 581, 3, 32, 16, 0, 579, 581, 5, 262, 0, 0, 580, 578, 1, 0, 0, 0, 580, 579, 1, 0, 0, 0, 581, 39, 1, 0, 0, 0, 582, 583, 5, 267, 0, 0, 583, 599, 5, 289, 0, 0, 584, 585, 5, 267, 0, 0, 585, 586, 5, 289, 0, 0, 586, 599, 5, 263, 0, 0, 587, 588, 5, 268, 0, 0, 588, 599, 5, 289, 0, 0, 589, 590, 5, 269, 0, 0, 590, 599, 5, 289, 0, 0, 591, 592, 5, 270, 0, 0, 592, 599, 5, 289, 0, 0, 593, 599, 5, 271, 0, 0, 594, 599, 5, 272, 0, 0, 595, 596, 5, 273, 0, 0, 596, 599, 5, 263, 0, 0, 597, 599, 5, 32, 0, 0, 598, 582, 1, 0, 0, 0, 598, 584, 1, 0, 0, 0, 598, 587, 1, 0, 0, 0, 598, 589, 1, 0, 0, 0, 598, 591, 1, 0, 0, 0, 598, 593, 1, 0, 0, 0, 598, 594, 1, 0, 0, 0, 598, 595, 1, 0, 0, 0, 598, 597, 1, 0, 0, 0, 599, 41, 1, 0, 0, 0, 600, 601, 5, 33, 0, 0, 601, 602, 3, 138, 69, 0, 602, 603, 5, 34, 0, 0, 603, 604, 3, 2, 1, 0, 604, 626, 1, 0, 0, 0, 605, 606, 5, 33, 0, 0, 606, 607, 3, 116, 58, 0, 607, 608, 5, 34, 0, 0, 608, 609, 3, 2, 1, 0, 609, 626, 1, 0, 0, 0, 610, 611, 5, 33, 0, 0, 611, 612, 3, 176, 88, 0, 612, 613, 5, 34, 0, 0, 613, 614, 3, 2, 1, 0, 614, 626, 1, 0, 0, 0, 615, 616, 5, 33, 0, 0, 616, 617, 3, 44, 22, 0, 617, 618, 5, 34, 0, 0, 618, 619, 3, 2, 1, 0, 619, 626, 1, 0, 0, 0, 620, 621, 5, 33, 0, 0, 621, 622, 3, 46, 23, 0, 622, 623, 5, 34, 0, 0, 623, 624, 3, 2, 1, 0, 624, 626, 1, 0, 0, 0, 625, 600, 1, 0, 0, 0, 625, 605, 1, 0, 0, 0, 625, 610, 1, 0, 0, 0, 625, 615, 1, 0, 0, 0, 625, 620, 1, 0, 0, 0, 626, 43, 1, 0, 0, 0, 627, 628, 5, 35, 0, 0, 628, 629, 3, 48, 24, 0, 629, 630, 6, 22, -1, 0, 630, 654, 1, 0, 0, 0, 631, 632, 5, 35, 0, 0, 632, 633, 3, 48, 24, 0, 633, 634, 5, 36, 0, 0, 634, 635, 3, 6, 3, 0, 635, 636, 6, 22, -1, 0, 636, 654, 1, 0, 0, 0, 637, 638, 5, 35, 0, 0, 638, 639, 3, 48, 24, 0, 639, 640, 5, 36, 0, 0, 640, 641, 5, 17, 0, 0, 641, 642, 3, 52, 26, 0, 642, 643, 5, 18, 0, 0, 643, 644, 6, 22, -1, 0, 644, 654, 1, 0, 0, 0, 645, 646, 5, 35, 0, 0, 646, 647, 3, 48, 24, 0, 647, 648, 5, 36, 0, 0, 648, 649, 5, 30, 0, 0, 649, 650, 3, 300, 150, 0, 650, 651, 5, 31, 0, 0, 651, 652, 6, 22, -1, 0, 652, 654, 1, 0, 0, 0, 653, 627, 1, 0, 0, 0, 653, 631, 1, 0, 0, 0, 653, 637, 1, 0, 0, 0, 653, 645, 1, 0, 0, 0, 654, 45, 1, 0, 0, 0, 655, 656, 5, 35, 0, 0, 656, 657, 5, 30, 0, 0, 657, 658, 3, 50, 25, 0, 658, 659, 5, 31, 0, 0, 659, 660, 3, 48, 24, 0, 660, 661, 6, 23, -1, 0, 661, 694, 1, 0, 0, 0, 662, 663, 5, 35, 0, 0, 663, 664, 5, 30, 0, 0, 664, 665, 3, 50, 25, 0, 665, 666, 5, 31, 0, 0, 666, 667, 3, 48, 24, 0, 667, 668, 5, 36, 0, 0, 668, 669, 3, 6, 3, 0, 669, 670, 6, 23, -1, 0, 670, 694, 1, 0, 0, 0, 671, 672, 5, 35, 0, 0, 672, 673, 5, 30, 0, 0, 673, 674, 3, 50, 25, 0, 674, 675, 5, 31, 0, 0, 675, 676, 3, 48, 24, 0, 676, 677, 5, 36, 0, 0, 677, 678, 5, 17, 0, 0, 678, 679, 3, 52, 26, 0, 679, 680, 5, 18, 0, 0, 680, 681, 6, 23, -1, 0, 681, 694, 1, 0, 0, 0, 682, 683, 5, 35, 0, 0, 683, 684, 5, 30, 0, 0, 684, 685, 3, 50, 25, 0, 685, 686, 5, 31, 0, 0, 686, 687, 3, 48, 24, 0, 687, 688, 5, 36, 0, 0, 688, 689, 5, 30, 0, 0, 689, 690, 3, 300, 150, 0, 690, 691, 5, 31, 0, 0, 691, 692, 6, 23, -1, 0, 692, 694, 1, 0, 0, 0, 693, 655, 1, 0, 0, 0, 693, 662, 1, 0, 0, 0, 693, 671, 1, 0, 0, 0, 693, 682, 1, 0, 0, 0, 694, 47, 1, 0, 0, 0, 695, 696, 3, 168, 84, 0, 696, 697, 6, 24, -1, 0, 697, 49, 1, 0, 0, 0, 698, 699, 3, 124, 62, 0, 699, 700, 6, 25, -1, 0, 700, 705, 1, 0, 0, 0, 701, 702, 3, 176, 88, 0, 702, 703, 6, 25, -1, 0, 703, 705, 1, 0, 0, 0, 704, 698, 1, 0, 0, 0, 704, 701, 1, 0, 0, 0, 705, 51, 1, 0, 0, 0, 706, 707, 3, 54, 27, 0, 707, 708, 3, 56, 28, 0, 708, 709, 6, 26, -1, 0, 709, 53, 1, 0, 0, 0, 710, 711, 3, 306, 153, 0, 711, 712, 6, 27, -1, 0, 712, 715, 1, 0, 0, 0, 713, 715, 3, 40, 20, 0, 714, 710, 1, 0, 0, 0, 714, 713, 1, 0, 0, 0, 715, 718, 1, 0, 0, 0, 716, 714, 1, 0, 0, 0, 716, 717, 1, 0, 0, 0, 717, 55, 1, 0, 0, 0, 718, 716, 1, 0, 0, 0, 719, 720, 3, 58, 29, 0, 720, 721, 3, 60, 30, 0, 721, 722, 3, 2, 1, 0, 722, 723, 5, 36, 0, 0, 723, 724, 3, 306, 153, 0, 724, 725, 6, 28, -1, 0, 725, 728, 1, 0, 0, 0, 726, 728, 3, 40, 20, 0, 727, 719, 1, 0, 0, 0, 727, 726, 1, 0, 0, 0, 728, 731, 1, 0, 0, 0, 729, 727, 1, 0, 0, 0, 729, 730, 1, 0, 0, 0, 730, 57, 1, 0, 0, 0, 731, 729, 1, 0, 0, 0, 732, 733, 7, 4, 0, 0, 733, 734, 6, 29, -1, 0, 734, 59, 1, 0, 0, 0, 735, 737, 3, 62, 31, 0, 736, 738, 5, 261, 0, 0, 737, 736, 1, 0, 0, 0, 737, 738, 1, 0, 0, 0, 738, 739, 1, 0, 0, 0, 739, 740, 6, 30, -1, 0, 740, 61, 1, 0, 0, 0, 741, 742, 3, 144, 72, 0, 742, 743, 6, 31, -1, 0, 743, 760, 1, 0, 0, 0, 744, 745, 3, 2, 1, 0, 745, 746, 6, 31, -1, 0, 746, 760, 1, 0, 0, 0, 747, 748, 5, 196, 0, 0, 748, 760, 6, 31, -1, 0, 749, 750, 5, 197, 0, 0, 750, 760, 6, 31, -1, 0, 751, 752, 5, 202, 0, 0, 752, 753, 5, 39, 0, 0, 753, 754, 5, 264, 0, 0, 754, 760, 6, 31, -1, 0, 755, 756, 5, 202, 0, 0, 756, 757, 3, 116, 58, 0, 757, 758, 6, 31, -1, 0, 758, 760, 1, 0, 0, 0, 759, 741, 1, 0, 0, 0, 759, 744, 1, 0, 0, 0, 759, 747, 1, 0, 0, 0, 759, 749, 1, 0, 0, 0, 759, 751, 1, 0, 0, 0, 759, 755, 1, 0, 0, 0, 760, 63, 1, 0, 0, 0, 761, 762, 5, 198, 0, 0, 762, 763, 5, 40, 0, 0, 763, 764, 3, 2, 1, 0, 764, 765, 6, 32, -1, 0, 765, 773, 1, 0, 0, 0, 766, 767, 5, 198, 0, 0, 767, 768, 3, 2, 1, 0, 768, 769, 6, 32, -1, 0, 769, 773, 1, 0, 0, 0, 770, 771, 5, 198, 0, 0, 771, 773, 6, 32, -1, 0, 772, 761, 1, 0, 0, 0, 772, 766, 1, 0, 0, 0, 772, 770, 1, 0, 0, 0, 773, 65, 1, 0, 0, 0, 774, 775, 5, 41, 0, 0, 775, 776, 5, 42, 0, 0, 776, 777, 3, 32, 16, 0, 777, 778, 5, 43, 0, 0, 778, 779, 3, 68, 34, 0, 779, 780, 5, 44, 0, 0, 780, 781, 3, 0, 0, 0, 781, 67, 1, 0, 0, 0, 782, 795, 6, 34, -1, 0, 783, 784, 10, 5, 0, 0, 784, 794, 5, 186, 0, 0, 785, 786, 10, 4, 0, 0, 786, 794, 5, 187, 0, 0, 787, 788, 10, 3, 0, 0, 788, 794, 5, 45, 0, 0, 789, 790, 10, 2, 0, 0, 790, 794, 5, 46, 0, 0, 791, 792, 10, 1, 0, 0, 792, 794, 5, 47, 0, 0, 793, 783, 1, 0, 0, 0, 793, 785, 1, 0, 0, 0, 793, 787, 1, 0, 0, 0, 793, 789, 1, 0, 0, 0, 793, 791, 1, 0, 0, 0, 794, 797, 1, 0, 0, 0, 795, 793, 1, 0, 0, 0, 795, 796, 1, 0, 0, 0, 796, 69, 1, 0, 0, 0, 797, 795, 1, 0, 0, 0, 798, 799, 5, 48, 0, 0, 799, 800, 5, 36, 0, 0, 800, 801, 5, 30, 0, 0, 801, 802, 3, 300, 150, 0, 802, 803, 5, 31, 0, 0, 803, 71, 1, 0, 0, 0, 804, 805, 5, 49, 0, 0, 805, 806, 3, 2, 1, 0, 806, 807, 6, 36, -1, 0, 807, 73, 1, 0, 0, 0, 808, 814, 5, 50, 0, 0, 809, 810, 3, 76, 38, 0, 810, 811, 6, 37, -1, 0, 811, 813, 1, 0, 0, 0, 812, 809, 1, 0, 0, 0, 813, 816, 1, 0, 0, 0, 814, 812, 1, 0, 0, 0, 814, 815, 1, 0, 0, 0, 815, 817, 1, 0, 0, 0, 816, 814, 1, 0, 0, 0, 817, 818, 3, 2, 1, 0, 818, 819, 3, 182, 91, 0, 819, 820, 3, 78, 39, 0, 820, 821, 3, 80, 40, 0, 821, 822, 6, 37, -1, 0, 822, 75, 1, 0, 0, 0, 823, 824, 5, 51, 0, 0, 824, 888, 6, 38, -1, 0, 825, 826, 5, 52, 0, 0, 826, 888, 6, 38, -1, 0, 827, 828, 5, 199, 0, 0, 828, 888, 6, 38, -1, 0, 829, 830, 5, 202, 0, 0, 830, 888, 6, 38, -1, 0, 831, 832, 5, 221, 0, 0, 832, 888, 6, 38, -1, 0, 833, 834, 5, 53, 0, 0, 834, 888, 6, 38, -1, 0, 835, 836, 5, 54, 0, 0, 836, 888, 6, 38, -1, 0, 837, 838, 5, 55, 0, 0, 838, 888, 6, 38, -1, 0, 839, 840, 5, 56, 0, 0, 840, 888, 6, 38, -1, 0, 841, 842, 5, 244, 0, 0, 842, 888, 6, 38, -1, 0, 843, 844, 5, 15, 0, 0, 844, 888, 6, 38, -1, 0, 845, 846, 5, 224, 0, 0, 846, 888, 6, 38, -1, 0, 847, 848, 5, 57, 0, 0, 848, 888, 6, 38, -1, 0, 849, 850, 5, 58, 0, 0, 850, 888, 6, 38, -1, 0, 851, 852, 5, 59, 0, 0, 852, 888, 6, 38, -1, 0, 853, 854, 5, 60, 0, 0, 854, 888, 6, 38, -1, 0, 855, 856, 5, 61, 0, 0, 856, 888, 6, 38, -1, 0, 857, 858, 5, 62, 0, 0, 858, 859, 5, 51, 0, 0, 859, 888, 6, 38, -1, 0, 860, 861, 5, 62, 0, 0, 861, 862, 5, 52, 0, 0, 862, 888, 6, 38, -1, 0, 863, 864, 5, 62, 0, 0, 864, 865, 5, 63, 0, 0, 865, 888, 6, 38, -1, 0, 866, 867, 5, 62, 0, 0, 867, 868, 5, 64, 0, 0, 868, 888, 6, 38, -1, 0, 869, 870, 5, 62, 0, 0, 870, 871, 5, 65, 0, 0, 871, 888, 6, 38, -1, 0, 872, 873, 5, 62, 0, 0, 873, 874, 5, 66, 0, 0, 874, 888, 6, 38, -1, 0, 875, 876, 5, 67, 0, 0, 876, 888, 6, 38, -1, 0, 877, 878, 5, 68, 0, 0, 878, 888, 6, 38, -1, 0, 879, 880, 5, 69, 0, 0, 880, 888, 6, 38, -1, 0, 881, 882, 5, 70, 0, 0, 882, 883, 5, 30, 0, 0, 883, 884, 3, 32, 16, 0, 884, 885, 5, 31, 0, 0, 885, 886, 6, 38, -1, 0, 886, 888, 1, 0, 0, 0, 887, 823, 1, 0, 0, 0, 887, 825, 1, 0, 0, 0, 887, 827, 1, 0, 0, 0, 887, 829, 1, 0, 0, 0, 887, 831, 1, 0, 0, 0, 887, 833, 1, 0, 0, 0, 887, 835, 1, 0, 0, 0, 887, 837, 1, 0, 0, 0, 887, 839, 1, 0, 0, 0, 887, 841, 1, 0, 0, 0, 887, 843, 1, 0, 0, 0, 887, 845, 1, 0, 0, 0, 887, 847, 1, 0, 0, 0, 887, 849, 1, 0, 0, 0, 887, 851, 1, 0, 0, 0, 887, 853, 1, 0, 0, 0, 887, 855, 1, 0, 0, 0, 887, 857, 1, 0, 0, 0, 887, 860, 1, 0, 0, 0, 887, 863, 1, 0, 0, 0, 887, 866, 1, 0, 0, 0, 887, 869, 1, 0, 0, 0, 887, 872, 1, 0, 0, 0, 887, 875, 1, 0, 0, 0, 887, 877, 1, 0, 0, 0, 887, 879, 1, 0, 0, 0, 887, 881, 1, 0, 0, 0, 888, 77, 1, 0, 0, 0, 889, 895, 1, 0, 0, 0, 890, 891, 5, 71, 0, 0, 891, 892, 3, 124, 62, 0, 892, 893, 6, 39, -1, 0, 893, 895, 1, 0, 0, 0, 894, 889, 1, 0, 0, 0, 894, 890, 1, 0, 0, 0, 895, 79, 1, 0, 0, 0, 896, 902, 1, 0, 0, 0, 897, 898, 5, 72, 0, 0, 898, 899, 3, 84, 42, 0, 899, 900, 6, 40, -1, 0, 900, 902, 1, 0, 0, 0, 901, 896, 1, 0, 0, 0, 901, 897, 1, 0, 0, 0, 902, 81, 1, 0, 0, 0, 903, 905, 3, 198, 99, 0, 904, 903, 1, 0, 0, 0, 905, 908, 1, 0, 0, 0, 906, 904, 1, 0, 0, 0, 906, 907, 1, 0, 0, 0, 907, 83, 1, 0, 0, 0, 908, 906, 1, 0, 0, 0, 909, 910, 3, 124, 62, 0, 910, 911, 6, 42, -1, 0, 911, 912, 5, 28, 0, 0, 912, 914, 1, 0, 0, 0, 913, 909, 1, 0, 0, 0, 914, 917, 1, 0, 0, 0, 915, 913, 1, 0, 0, 0, 915, 916, 1, 0, 0, 0, 916, 918, 1, 0, 0, 0, 917, 915, 1, 0, 0, 0, 918, 919, 3, 124, 62, 0, 919, 920, 6, 42, -1, 0, 920, 85, 1, 0, 0, 0, 921, 922, 7, 5, 0, 0, 922, 87, 1, 0, 0, 0, 923, 924, 3, 86, 43, 0, 924, 925, 3, 32, 16, 0, 925, 926, 5, 264, 0, 0, 926, 1027, 1, 0, 0, 0, 927, 928, 3, 86, 43, 0, 928, 929, 3, 32, 16, 0, 929, 1027, 1, 0, 0, 0, 930, 931, 3, 86, 43, 0, 931, 932, 3, 32, 16, 0, 932, 933, 5, 75, 0, 0, 933, 934, 3, 32, 16, 0, 934, 935, 5, 264, 0, 0, 935, 1027, 1, 0, 0, 0, 936, 937, 3, 86, 43, 0, 937, 938, 3, 32, 16, 0, 938, 939, 5, 75, 0, 0, 939, 940, 3, 32, 16, 0, 940, 1027, 1, 0, 0, 0, 941, 942, 3, 86, 43, 0, 942, 943, 3, 32, 16, 0, 943, 944, 5, 75, 0, 0, 944, 945, 3, 32, 16, 0, 945, 946, 5, 28, 0, 0, 946, 947, 3, 32, 16, 0, 947, 948, 5, 264, 0, 0, 948, 1027, 1, 0, 0, 0, 949, 950, 3, 86, 43, 0, 950, 951, 3, 32, 16, 0, 951, 952, 5, 75, 0, 0, 952, 953, 3, 32, 16, 0, 953, 954, 5, 28, 0, 0, 954, 955, 3, 32, 16, 0, 955, 1027, 1, 0, 0, 0, 956, 957, 3, 86, 43, 0, 957, 958, 3, 32, 16, 0, 958, 959, 5, 28, 0, 0, 959, 960, 3, 32, 16, 0, 960, 961, 5, 75, 0, 0, 961, 962, 3, 32, 16, 0, 962, 963, 5, 264, 0, 0, 963, 1027, 1, 0, 0, 0, 964, 965, 3, 86, 43, 0, 965, 966, 3, 32, 16, 0, 966, 967, 5, 28, 0, 0, 967, 968, 3, 32, 16, 0, 968, 969, 5, 75, 0, 0, 969, 970, 3, 32, 16, 0, 970, 1027, 1, 0, 0, 0, 971, 972, 3, 86, 43, 0, 972, 973, 3, 32, 16, 0, 973, 974, 5, 28, 0, 0, 974, 975, 3, 32, 16, 0, 975, 976, 5, 75, 0, 0, 976, 977, 3, 32, 16, 0, 977, 978, 5, 28, 0, 0, 978, 979, 3, 32, 16, 0, 979, 980, 5, 264, 0, 0, 980, 1027, 1, 0, 0, 0, 981, 982, 3, 86, 43, 0, 982, 983, 3, 32, 16, 0, 983, 984, 5, 28, 0, 0, 984, 985, 3, 32, 16, 0, 985, 986, 5, 75, 0, 0, 986, 987, 3, 32, 16, 0, 987, 988, 5, 28, 0, 0, 988, 989, 3, 32, 16, 0, 989, 1027, 1, 0, 0, 0, 990, 991, 3, 86, 43, 0, 991, 992, 3, 32, 16, 0, 992, 993, 5, 263, 0, 0, 993, 1027, 1, 0, 0, 0, 994, 995, 3, 86, 43, 0, 995, 996, 3, 32, 16, 0, 996, 997, 5, 75, 0, 0, 997, 998, 3, 32, 16, 0, 998, 999, 5, 263, 0, 0, 999, 1027, 1, 0, 0, 0, 1000, 1001, 3, 86, 43, 0, 1001, 1002, 3, 32, 16, 0, 1002, 1003, 5, 75, 0, 0, 1003, 1004, 3, 32, 16, 0, 1004, 1005, 5, 28, 0, 0, 1005, 1006, 3, 32, 16, 0, 1006, 1007, 5, 263, 0, 0, 1007, 1027, 1, 0, 0, 0, 1008, 1009, 3, 86, 43, 0, 1009, 1010, 3, 32, 16, 0, 1010, 1011, 5, 28, 0, 0, 1011, 1012, 3, 32, 16, 0, 1012, 1013, 5, 75, 0, 0, 1013, 1014, 3, 32, 16, 0, 1014, 1015, 5, 263, 0, 0, 1015, 1027, 1, 0, 0, 0, 1016, 1017, 3, 86, 43, 0, 1017, 1018, 3, 32, 16, 0, 1018, 1019, 5, 28, 0, 0, 1019, 1020, 3, 32, 16, 0, 1020, 1021, 5, 75, 0, 0, 1021, 1022, 3, 32, 16, 0, 1022, 1023, 5, 28, 0, 0, 1023, 1024, 3, 32, 16, 0, 1024, 1025, 5, 263, 0, 0, 1025, 1027, 1, 0, 0, 0, 1026, 923, 1, 0, 0, 0, 1026, 927, 1, 0, 0, 0, 1026, 930, 1, 0, 0, 0, 1026, 936, 1, 0, 0, 0, 1026, 941, 1, 0, 0, 0, 1026, 949, 1, 0, 0, 0, 1026, 956, 1, 0, 0, 0, 1026, 964, 1, 0, 0, 0, 1026, 971, 1, 0, 0, 0, 1026, 981, 1, 0, 0, 0, 1026, 990, 1, 0, 0, 0, 1026, 994, 1, 0, 0, 0, 1026, 1000, 1, 0, 0, 0, 1026, 1008, 1, 0, 0, 0, 1026, 1016, 1, 0, 0, 0, 1027, 89, 1, 0, 0, 0, 1028, 1032, 5, 21, 0, 0, 1029, 1031, 3, 92, 46, 0, 1030, 1029, 1, 0, 0, 0, 1031, 1034, 1, 0, 0, 0, 1032, 1030, 1, 0, 0, 0, 1032, 1033, 1, 0, 0, 0, 1033, 1035, 1, 0, 0, 0, 1034, 1032, 1, 0, 0, 0, 1035, 1036, 3, 2, 1, 0, 1036, 1037, 3, 94, 47, 0, 1037, 1038, 5, 180, 0, 0, 1038, 1039, 5, 36, 0, 0, 1039, 1040, 5, 30, 0, 0, 1040, 1041, 3, 300, 150, 0, 1041, 1042, 5, 31, 0, 0, 1042, 1043, 3, 94, 47, 0, 1043, 1055, 1, 0, 0, 0, 1044, 1048, 5, 21, 0, 0, 1045, 1047, 3, 92, 46, 0, 1046, 1045, 1, 0, 0, 0, 1047, 1050, 1, 0, 0, 0, 1048, 1046, 1, 0, 0, 0, 1048, 1049, 1, 0, 0, 0, 1049, 1051, 1, 0, 0, 0, 1050, 1048, 1, 0, 0, 0, 1051, 1052, 3, 2, 1, 0, 1052, 1053, 3, 94, 47, 0, 1053, 1055, 1, 0, 0, 0, 1054, 1028, 1, 0, 0, 0, 1054, 1044, 1, 0, 0, 0, 1055, 91, 1, 0, 0, 0, 1056, 1057, 5, 76, 0, 0, 1057, 93, 1, 0, 0, 0, 1058, 1061, 1, 0, 0, 0, 1059, 1061, 5, 298, 0, 0, 1060, 1058, 1, 0, 0, 0, 1060, 1059, 1, 0, 0, 0, 1061, 95, 1, 0, 0, 0, 1062, 1063, 7, 6, 0, 0, 1063, 97, 1, 0, 0, 0, 1064, 1066, 3, 96, 48, 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, 99, 1, 0, 0, 0, 1069, 1067, 1, 0, 0, 0, 1070, 1096, 3, 102, 51, 0, 1071, 1072, 5, 280, 0, 0, 1072, 1073, 3, 168, 84, 0, 1073, 1074, 6, 50, -1, 0, 1074, 1096, 1, 0, 0, 0, 1075, 1076, 5, 286, 0, 0, 1076, 1077, 3, 178, 89, 0, 1077, 1078, 6, 50, -1, 0, 1078, 1096, 1, 0, 0, 0, 1079, 1080, 5, 286, 0, 0, 1080, 1081, 3, 174, 87, 0, 1081, 1082, 6, 50, -1, 0, 1082, 1096, 1, 0, 0, 0, 1083, 1084, 5, 284, 0, 0, 1084, 1085, 3, 124, 62, 0, 1085, 1086, 6, 50, -1, 0, 1086, 1096, 1, 0, 0, 0, 1087, 1088, 5, 281, 0, 0, 1088, 1089, 3, 104, 52, 0, 1089, 1090, 6, 50, -1, 0, 1090, 1096, 1, 0, 0, 0, 1091, 1092, 5, 287, 0, 0, 1092, 1093, 3, 50, 25, 0, 1093, 1094, 6, 50, -1, 0, 1094, 1096, 1, 0, 0, 0, 1095, 1070, 1, 0, 0, 0, 1095, 1071, 1, 0, 0, 0, 1095, 1075, 1, 0, 0, 0, 1095, 1079, 1, 0, 0, 0, 1095, 1083, 1, 0, 0, 0, 1095, 1087, 1, 0, 0, 0, 1095, 1091, 1, 0, 0, 0, 1096, 101, 1, 0, 0, 0, 1097, 1098, 5, 275, 0, 0, 1098, 1176, 6, 51, -1, 0, 1099, 1100, 5, 276, 0, 0, 1100, 1101, 3, 32, 16, 0, 1101, 1102, 6, 51, -1, 0, 1102, 1176, 1, 0, 0, 0, 1103, 1104, 5, 276, 0, 0, 1104, 1105, 3, 0, 0, 0, 1105, 1106, 6, 51, -1, 0, 1106, 1176, 1, 0, 0, 0, 1107, 1108, 5, 277, 0, 0, 1108, 1109, 3, 32, 16, 0, 1109, 1110, 6, 51, -1, 0, 1110, 1176, 1, 0, 0, 0, 1111, 1112, 5, 278, 0, 0, 1112, 1113, 3, 34, 17, 0, 1113, 1114, 6, 51, -1, 0, 1114, 1176, 1, 0, 0, 0, 1115, 1116, 5, 279, 0, 0, 1116, 1117, 3, 36, 18, 0, 1117, 1118, 6, 51, -1, 0, 1118, 1176, 1, 0, 0, 0, 1119, 1120, 5, 279, 0, 0, 1120, 1121, 3, 34, 17, 0, 1121, 1122, 6, 51, -1, 0, 1122, 1176, 1, 0, 0, 0, 1123, 1124, 5, 279, 0, 0, 1124, 1125, 5, 30, 0, 0, 1125, 1126, 3, 300, 150, 0, 1126, 1127, 5, 31, 0, 0, 1127, 1128, 6, 51, -1, 0, 1128, 1176, 1, 0, 0, 0, 1129, 1130, 5, 279, 0, 0, 1130, 1131, 5, 84, 0, 0, 1131, 1132, 5, 30, 0, 0, 1132, 1133, 3, 300, 150, 0, 1133, 1134, 5, 31, 0, 0, 1134, 1135, 6, 51, -1, 0, 1135, 1176, 1, 0, 0, 0, 1136, 1137, 5, 282, 0, 0, 1137, 1138, 3, 32, 16, 0, 1138, 1139, 6, 51, -1, 0, 1139, 1176, 1, 0, 0, 0, 1140, 1141, 5, 282, 0, 0, 1141, 1142, 3, 0, 0, 0, 1142, 1143, 6, 51, -1, 0, 1143, 1176, 1, 0, 0, 0, 1144, 1145, 5, 285, 0, 0, 1145, 1146, 3, 6, 3, 0, 1146, 1147, 6, 51, -1, 0, 1147, 1176, 1, 0, 0, 0, 1148, 1149, 5, 285, 0, 0, 1149, 1150, 5, 224, 0, 0, 1150, 1151, 5, 30, 0, 0, 1151, 1152, 3, 6, 3, 0, 1152, 1153, 5, 31, 0, 0, 1153, 1154, 6, 51, -1, 0, 1154, 1176, 1, 0, 0, 0, 1155, 1156, 5, 285, 0, 0, 1156, 1157, 5, 84, 0, 0, 1157, 1158, 5, 30, 0, 0, 1158, 1159, 3, 300, 150, 0, 1159, 1160, 5, 31, 0, 0, 1160, 1161, 6, 51, -1, 0, 1161, 1176, 1, 0, 0, 0, 1162, 1163, 5, 287, 0, 0, 1163, 1164, 3, 32, 16, 0, 1164, 1165, 6, 51, -1, 0, 1165, 1176, 1, 0, 0, 0, 1166, 1167, 5, 283, 0, 0, 1167, 1173, 6, 51, -1, 0, 1168, 1169, 5, 30, 0, 0, 1169, 1170, 3, 106, 53, 0, 1170, 1171, 5, 31, 0, 0, 1171, 1174, 1, 0, 0, 0, 1172, 1174, 5, 85, 0, 0, 1173, 1168, 1, 0, 0, 0, 1173, 1172, 1, 0, 0, 0, 1174, 1176, 1, 0, 0, 0, 1175, 1097, 1, 0, 0, 0, 1175, 1099, 1, 0, 0, 0, 1175, 1103, 1, 0, 0, 0, 1175, 1107, 1, 0, 0, 0, 1175, 1111, 1, 0, 0, 0, 1175, 1115, 1, 0, 0, 0, 1175, 1119, 1, 0, 0, 0, 1175, 1123, 1, 0, 0, 0, 1175, 1129, 1, 0, 0, 0, 1175, 1136, 1, 0, 0, 0, 1175, 1140, 1, 0, 0, 0, 1175, 1144, 1, 0, 0, 0, 1175, 1148, 1, 0, 0, 0, 1175, 1155, 1, 0, 0, 0, 1175, 1162, 1, 0, 0, 0, 1175, 1166, 1, 0, 0, 0, 1176, 103, 1, 0, 0, 0, 1177, 1178, 3, 170, 85, 0, 1178, 1179, 3, 138, 69, 0, 1179, 1180, 3, 112, 56, 0, 1180, 1181, 6, 52, -1, 0, 1181, 105, 1, 0, 0, 0, 1182, 1207, 1, 0, 0, 0, 1183, 1184, 3, 0, 0, 0, 1184, 1185, 6, 53, -1, 0, 1185, 1190, 1, 0, 0, 0, 1186, 1187, 3, 32, 16, 0, 1187, 1188, 6, 53, -1, 0, 1188, 1190, 1, 0, 0, 0, 1189, 1183, 1, 0, 0, 0, 1189, 1186, 1, 0, 0, 0, 1190, 1191, 1, 0, 0, 0, 1191, 1192, 5, 28, 0, 0, 1192, 1194, 1, 0, 0, 0, 1193, 1189, 1, 0, 0, 0, 1194, 1197, 1, 0, 0, 0, 1195, 1193, 1, 0, 0, 0, 1195, 1196, 1, 0, 0, 0, 1196, 1204, 1, 0, 0, 0, 1197, 1195, 1, 0, 0, 0, 1198, 1199, 3, 0, 0, 0, 1199, 1200, 6, 53, -1, 0, 1200, 1205, 1, 0, 0, 0, 1201, 1202, 3, 32, 16, 0, 1202, 1203, 6, 53, -1, 0, 1203, 1205, 1, 0, 0, 0, 1204, 1198, 1, 0, 0, 0, 1204, 1201, 1, 0, 0, 0, 1205, 1207, 1, 0, 0, 0, 1206, 1182, 1, 0, 0, 0, 1206, 1195, 1, 0, 0, 0, 1207, 107, 1, 0, 0, 0, 1208, 1215, 5, 86, 0, 0, 1209, 1210, 3, 138, 69, 0, 1210, 1211, 6, 54, -1, 0, 1211, 1212, 5, 28, 0, 0, 1212, 1214, 1, 0, 0, 0, 1213, 1209, 1, 0, 0, 0, 1214, 1217, 1, 0, 0, 0, 1215, 1213, 1, 0, 0, 0, 1215, 1216, 1, 0, 0, 0, 1216, 1218, 1, 0, 0, 0, 1217, 1215, 1, 0, 0, 0, 1218, 1219, 3, 138, 69, 0, 1219, 1220, 6, 54, -1, 0, 1220, 1221, 5, 87, 0, 0, 1221, 109, 1, 0, 0, 0, 1222, 1229, 5, 42, 0, 0, 1223, 1224, 3, 146, 73, 0, 1224, 1225, 6, 55, -1, 0, 1225, 1226, 5, 28, 0, 0, 1226, 1228, 1, 0, 0, 0, 1227, 1223, 1, 0, 0, 0, 1228, 1231, 1, 0, 0, 0, 1229, 1227, 1, 0, 0, 0, 1229, 1230, 1, 0, 0, 0, 1230, 1232, 1, 0, 0, 0, 1231, 1229, 1, 0, 0, 0, 1232, 1233, 3, 146, 73, 0, 1233, 1234, 6, 55, -1, 0, 1234, 1235, 5, 43, 0, 0, 1235, 111, 1, 0, 0, 0, 1236, 1243, 5, 30, 0, 0, 1237, 1238, 3, 114, 57, 0, 1238, 1239, 6, 56, -1, 0, 1239, 1240, 5, 28, 0, 0, 1240, 1242, 1, 0, 0, 0, 1241, 1237, 1, 0, 0, 0, 1242, 1245, 1, 0, 0, 0, 1243, 1241, 1, 0, 0, 0, 1243, 1244, 1, 0, 0, 0, 1244, 1246, 1, 0, 0, 0, 1245, 1243, 1, 0, 0, 0, 1246, 1247, 3, 114, 57, 0, 1247, 1248, 6, 56, -1, 0, 1248, 1249, 5, 31, 0, 0, 1249, 1252, 1, 0, 0, 0, 1250, 1252, 5, 85, 0, 0, 1251, 1236, 1, 0, 0, 0, 1251, 1250, 1, 0, 0, 0, 1252, 113, 1, 0, 0, 0, 1253, 1254, 5, 177, 0, 0, 1254, 1264, 6, 57, -1, 0, 1255, 1256, 3, 230, 115, 0, 1256, 1257, 3, 138, 69, 0, 1257, 1259, 3, 226, 113, 0, 1258, 1260, 3, 0, 0, 0, 1259, 1258, 1, 0, 0, 0, 1259, 1260, 1, 0, 0, 0, 1260, 1261, 1, 0, 0, 0, 1261, 1262, 6, 57, -1, 0, 1262, 1264, 1, 0, 0, 0, 1263, 1253, 1, 0, 0, 0, 1263, 1255, 1, 0, 0, 0, 1264, 115, 1, 0, 0, 0, 1265, 1266, 5, 42, 0, 0, 1266, 1267, 3, 2, 1, 0, 1267, 1268, 5, 43, 0, 0, 1268, 1269, 3, 118, 59, 0, 1269, 1270, 6, 58, -1, 0, 1270, 1303, 1, 0, 0, 0, 1271, 1272, 5, 42, 0, 0, 1272, 1273, 3, 174, 87, 0, 1273, 1274, 5, 43, 0, 0, 1274, 1275, 3, 118, 59, 0, 1275, 1276, 6, 58, -1, 0, 1276, 1303, 1, 0, 0, 0, 1277, 1278, 5, 42, 0, 0, 1278, 1279, 5, 262, 0, 0, 1279, 1280, 5, 43, 0, 0, 1280, 1281, 3, 118, 59, 0, 1281, 1282, 6, 58, -1, 0, 1282, 1303, 1, 0, 0, 0, 1283, 1284, 5, 42, 0, 0, 1284, 1285, 5, 198, 0, 0, 1285, 1286, 3, 2, 1, 0, 1286, 1287, 5, 43, 0, 0, 1287, 1288, 3, 118, 59, 0, 1288, 1289, 6, 58, -1, 0, 1289, 1303, 1, 0, 0, 0, 1290, 1291, 3, 118, 59, 0, 1291, 1292, 6, 58, -1, 0, 1292, 1303, 1, 0, 0, 0, 1293, 1294, 3, 174, 87, 0, 1294, 1295, 6, 58, -1, 0, 1295, 1303, 1, 0, 0, 0, 1296, 1297, 5, 257, 0, 0, 1297, 1303, 6, 58, -1, 0, 1298, 1299, 5, 258, 0, 0, 1299, 1303, 6, 58, -1, 0, 1300, 1301, 5, 259, 0, 0, 1301, 1303, 6, 58, -1, 0, 1302, 1265, 1, 0, 0, 0, 1302, 1271, 1, 0, 0, 0, 1302, 1277, 1, 0, 0, 0, 1302, 1283, 1, 0, 0, 0, 1302, 1290, 1, 0, 0, 0, 1302, 1293, 1, 0, 0, 0, 1302, 1296, 1, 0, 0, 0, 1302, 1298, 1, 0, 0, 0, 1302, 1300, 1, 0, 0, 0, 1303, 117, 1, 0, 0, 0, 1304, 1305, 3, 2, 1, 0, 1305, 1306, 6, 59, -1, 0, 1306, 1307, 5, 88, 0, 0, 1307, 1309, 1, 0, 0, 0, 1308, 1304, 1, 0, 0, 0, 1309, 1312, 1, 0, 0, 0, 1310, 1308, 1, 0, 0, 0, 1310, 1311, 1, 0, 0, 0, 1311, 1313, 1, 0, 0, 0, 1312, 1310, 1, 0, 0, 0, 1313, 1314, 3, 2, 1, 0, 1314, 1315, 6, 59, -1, 0, 1315, 119, 1, 0, 0, 0, 1316, 1318, 3, 122, 61, 0, 1317, 1316, 1, 0, 0, 0, 1318, 1321, 1, 0, 0, 0, 1319, 1317, 1, 0, 0, 0, 1319, 1320, 1, 0, 0, 0, 1320, 121, 1, 0, 0, 0, 1321, 1319, 1, 0, 0, 0, 1322, 1323, 5, 180, 0, 0, 1323, 1324, 5, 89, 0, 0, 1324, 1328, 3, 32, 16, 0, 1325, 1328, 3, 152, 76, 0, 1326, 1328, 3, 332, 166, 0, 1327, 1322, 1, 0, 0, 0, 1327, 1325, 1, 0, 0, 0, 1327, 1326, 1, 0, 0, 0, 1328, 123, 1, 0, 0, 0, 1329, 1330, 3, 116, 58, 0, 1330, 1331, 6, 62, -1, 0, 1331, 1347, 1, 0, 0, 0, 1332, 1333, 5, 42, 0, 0, 1333, 1334, 3, 2, 1, 0, 1334, 1335, 5, 43, 0, 0, 1335, 1336, 6, 62, -1, 0, 1336, 1347, 1, 0, 0, 0, 1337, 1338, 5, 42, 0, 0, 1338, 1339, 5, 198, 0, 0, 1339, 1340, 3, 2, 1, 0, 1340, 1341, 5, 43, 0, 0, 1341, 1342, 6, 62, -1, 0, 1342, 1347, 1, 0, 0, 0, 1343, 1344, 3, 138, 69, 0, 1344, 1345, 6, 62, -1, 0, 1345, 1347, 1, 0, 0, 0, 1346, 1329, 1, 0, 0, 0, 1346, 1332, 1, 0, 0, 0, 1346, 1337, 1, 0, 0, 0, 1346, 1343, 1, 0, 0, 0, 1347, 125, 1, 0, 0, 0, 1348, 1360, 1, 0, 0, 0, 1349, 1350, 3, 130, 65, 0, 1350, 1356, 6, 63, -1, 0, 1351, 1352, 3, 128, 64, 0, 1352, 1353, 6, 63, -1, 0, 1353, 1355, 1, 0, 0, 0, 1354, 1351, 1, 0, 0, 0, 1355, 1358, 1, 0, 0, 0, 1356, 1354, 1, 0, 0, 0, 1356, 1357, 1, 0, 0, 0, 1357, 1360, 1, 0, 0, 0, 1358, 1356, 1, 0, 0, 0, 1359, 1348, 1, 0, 0, 0, 1359, 1349, 1, 0, 0, 0, 1360, 127, 1, 0, 0, 0, 1361, 1362, 5, 262, 0, 0, 1362, 1384, 6, 64, -1, 0, 1363, 1364, 5, 261, 0, 0, 1364, 1384, 6, 64, -1, 0, 1365, 1366, 5, 42, 0, 0, 1366, 1367, 3, 32, 16, 0, 1367, 1368, 5, 43, 0, 0, 1368, 1369, 6, 64, -1, 0, 1369, 1384, 1, 0, 0, 0, 1370, 1371, 5, 42, 0, 0, 1371, 1372, 3, 32, 16, 0, 1372, 1373, 5, 266, 0, 0, 1373, 1374, 3, 32, 16, 0, 1374, 1375, 5, 43, 0, 0, 1375, 1376, 6, 64, -1, 0, 1376, 1384, 1, 0, 0, 0, 1377, 1378, 5, 42, 0, 0, 1378, 1379, 5, 266, 0, 0, 1379, 1380, 3, 32, 16, 0, 1380, 1381, 5, 43, 0, 0, 1381, 1382, 6, 64, -1, 0, 1382, 1384, 1, 0, 0, 0, 1383, 1361, 1, 0, 0, 0, 1383, 1363, 1, 0, 0, 0, 1383, 1365, 1, 0, 0, 0, 1383, 1370, 1, 0, 0, 0, 1383, 1377, 1, 0, 0, 0, 1384, 129, 1, 0, 0, 0, 1385, 1531, 6, 65, -1, 0, 1386, 1387, 5, 203, 0, 0, 1387, 1388, 5, 30, 0, 0, 1388, 1389, 3, 6, 3, 0, 1389, 1390, 5, 28, 0, 0, 1390, 1391, 3, 6, 3, 0, 1391, 1392, 5, 28, 0, 0, 1392, 1393, 3, 6, 3, 0, 1393, 1394, 5, 28, 0, 0, 1394, 1395, 3, 6, 3, 0, 1395, 1396, 5, 31, 0, 0, 1396, 1397, 6, 65, -1, 0, 1397, 1531, 1, 0, 0, 0, 1398, 1399, 5, 203, 0, 0, 1399, 1400, 5, 30, 0, 0, 1400, 1401, 3, 6, 3, 0, 1401, 1402, 5, 28, 0, 0, 1402, 1403, 3, 6, 3, 0, 1403, 1404, 5, 31, 0, 0, 1404, 1405, 6, 65, -1, 0, 1405, 1531, 1, 0, 0, 0, 1406, 1407, 5, 204, 0, 0, 1407, 1408, 5, 205, 0, 0, 1408, 1409, 5, 42, 0, 0, 1409, 1410, 3, 32, 16, 0, 1410, 1411, 5, 43, 0, 0, 1411, 1412, 6, 65, -1, 0, 1412, 1531, 1, 0, 0, 0, 1413, 1414, 5, 204, 0, 0, 1414, 1415, 5, 206, 0, 0, 1415, 1416, 5, 42, 0, 0, 1416, 1417, 3, 32, 16, 0, 1417, 1418, 5, 43, 0, 0, 1418, 1419, 3, 126, 63, 0, 1419, 1420, 6, 65, -1, 0, 1420, 1531, 1, 0, 0, 0, 1421, 1422, 5, 207, 0, 0, 1422, 1531, 6, 65, -1, 0, 1423, 1424, 5, 208, 0, 0, 1424, 1531, 6, 65, -1, 0, 1425, 1426, 5, 209, 0, 0, 1426, 1531, 6, 65, -1, 0, 1427, 1428, 5, 201, 0, 0, 1428, 1531, 6, 65, -1, 0, 1429, 1430, 5, 183, 0, 0, 1430, 1531, 6, 65, -1, 0, 1431, 1432, 5, 184, 0, 0, 1432, 1531, 6, 65, -1, 0, 1433, 1434, 5, 185, 0, 0, 1434, 1531, 6, 65, -1, 0, 1435, 1436, 5, 186, 0, 0, 1436, 1531, 6, 65, -1, 0, 1437, 1438, 5, 187, 0, 0, 1438, 1531, 6, 65, -1, 0, 1439, 1440, 5, 188, 0, 0, 1440, 1531, 6, 65, -1, 0, 1441, 1442, 5, 189, 0, 0, 1442, 1531, 6, 65, -1, 0, 1443, 1444, 5, 210, 0, 0, 1444, 1531, 6, 65, -1, 0, 1445, 1446, 5, 190, 0, 0, 1446, 1531, 6, 65, -1, 0, 1447, 1448, 5, 191, 0, 0, 1448, 1531, 6, 65, -1, 0, 1449, 1450, 5, 192, 0, 0, 1450, 1531, 6, 65, -1, 0, 1451, 1452, 5, 193, 0, 0, 1452, 1531, 6, 65, -1, 0, 1453, 1454, 5, 211, 0, 0, 1454, 1531, 6, 65, -1, 0, 1455, 1456, 5, 212, 0, 0, 1456, 1531, 6, 65, -1, 0, 1457, 1458, 5, 213, 0, 0, 1458, 1531, 6, 65, -1, 0, 1459, 1460, 5, 214, 0, 0, 1460, 1531, 6, 65, -1, 0, 1461, 1462, 5, 215, 0, 0, 1462, 1531, 6, 65, -1, 0, 1463, 1464, 5, 216, 0, 0, 1464, 1531, 6, 65, -1, 0, 1465, 1466, 5, 217, 0, 0, 1466, 1531, 6, 65, -1, 0, 1467, 1468, 5, 218, 0, 0, 1468, 1469, 3, 132, 66, 0, 1469, 1470, 6, 65, -1, 0, 1470, 1531, 1, 0, 0, 0, 1471, 1472, 5, 219, 0, 0, 1472, 1473, 3, 132, 66, 0, 1473, 1474, 6, 65, -1, 0, 1474, 1531, 1, 0, 0, 0, 1475, 1476, 5, 220, 0, 0, 1476, 1531, 6, 65, -1, 0, 1477, 1478, 5, 221, 0, 0, 1478, 1479, 3, 132, 66, 0, 1479, 1480, 6, 65, -1, 0, 1480, 1531, 1, 0, 0, 0, 1481, 1482, 5, 222, 0, 0, 1482, 1483, 3, 134, 67, 0, 1483, 1484, 6, 65, -1, 0, 1484, 1531, 1, 0, 0, 0, 1485, 1486, 5, 222, 0, 0, 1486, 1487, 3, 134, 67, 0, 1487, 1488, 5, 28, 0, 0, 1488, 1489, 3, 6, 3, 0, 1489, 1490, 6, 65, -1, 0, 1490, 1531, 1, 0, 0, 0, 1491, 1492, 5, 194, 0, 0, 1492, 1531, 6, 65, -1, 0, 1493, 1494, 5, 195, 0, 0, 1494, 1531, 6, 65, -1, 0, 1495, 1496, 5, 90, 0, 0, 1496, 1497, 5, 184, 0, 0, 1497, 1531, 6, 65, -1, 0, 1498, 1499, 5, 90, 0, 0, 1499, 1500, 5, 185, 0, 0, 1500, 1531, 6, 65, -1, 0, 1501, 1502, 5, 90, 0, 0, 1502, 1503, 5, 186, 0, 0, 1503, 1531, 6, 65, -1, 0, 1504, 1505, 5, 90, 0, 0, 1505, 1506, 5, 187, 0, 0, 1506, 1531, 6, 65, -1, 0, 1507, 1508, 5, 62, 0, 0, 1508, 1509, 5, 220, 0, 0, 1509, 1531, 6, 65, -1, 0, 1510, 1511, 5, 223, 0, 0, 1511, 1531, 6, 65, -1, 0, 1512, 1513, 5, 224, 0, 0, 1513, 1514, 5, 213, 0, 0, 1514, 1531, 6, 65, -1, 0, 1515, 1516, 5, 225, 0, 0, 1516, 1531, 6, 65, -1, 0, 1517, 1518, 5, 207, 0, 0, 1518, 1519, 5, 183, 0, 0, 1519, 1531, 6, 65, -1, 0, 1520, 1521, 5, 226, 0, 0, 1521, 1531, 6, 65, -1, 0, 1522, 1523, 5, 228, 0, 0, 1523, 1531, 6, 65, -1, 0, 1524, 1525, 5, 34, 0, 0, 1525, 1526, 5, 227, 0, 0, 1526, 1531, 6, 65, -1, 0, 1527, 1528, 3, 2, 1, 0, 1528, 1529, 6, 65, -1, 0, 1529, 1531, 1, 0, 0, 0, 1530, 1385, 1, 0, 0, 0, 1530, 1386, 1, 0, 0, 0, 1530, 1398, 1, 0, 0, 0, 1530, 1406, 1, 0, 0, 0, 1530, 1413, 1, 0, 0, 0, 1530, 1421, 1, 0, 0, 0, 1530, 1423, 1, 0, 0, 0, 1530, 1425, 1, 0, 0, 0, 1530, 1427, 1, 0, 0, 0, 1530, 1429, 1, 0, 0, 0, 1530, 1431, 1, 0, 0, 0, 1530, 1433, 1, 0, 0, 0, 1530, 1435, 1, 0, 0, 0, 1530, 1437, 1, 0, 0, 0, 1530, 1439, 1, 0, 0, 0, 1530, 1441, 1, 0, 0, 0, 1530, 1443, 1, 0, 0, 0, 1530, 1445, 1, 0, 0, 0, 1530, 1447, 1, 0, 0, 0, 1530, 1449, 1, 0, 0, 0, 1530, 1451, 1, 0, 0, 0, 1530, 1453, 1, 0, 0, 0, 1530, 1455, 1, 0, 0, 0, 1530, 1457, 1, 0, 0, 0, 1530, 1459, 1, 0, 0, 0, 1530, 1461, 1, 0, 0, 0, 1530, 1463, 1, 0, 0, 0, 1530, 1465, 1, 0, 0, 0, 1530, 1467, 1, 0, 0, 0, 1530, 1471, 1, 0, 0, 0, 1530, 1475, 1, 0, 0, 0, 1530, 1477, 1, 0, 0, 0, 1530, 1481, 1, 0, 0, 0, 1530, 1485, 1, 0, 0, 0, 1530, 1491, 1, 0, 0, 0, 1530, 1493, 1, 0, 0, 0, 1530, 1495, 1, 0, 0, 0, 1530, 1498, 1, 0, 0, 0, 1530, 1501, 1, 0, 0, 0, 1530, 1504, 1, 0, 0, 0, 1530, 1507, 1, 0, 0, 0, 1530, 1510, 1, 0, 0, 0, 1530, 1512, 1, 0, 0, 0, 1530, 1515, 1, 0, 0, 0, 1530, 1517, 1, 0, 0, 0, 1530, 1520, 1, 0, 0, 0, 1530, 1522, 1, 0, 0, 0, 1530, 1524, 1, 0, 0, 0, 1530, 1527, 1, 0, 0, 0, 1531, 131, 1, 0, 0, 0, 1532, 1541, 1, 0, 0, 0, 1533, 1534, 5, 30, 0, 0, 1534, 1535, 5, 91, 0, 0, 1535, 1536, 5, 36, 0, 0, 1536, 1537, 3, 32, 16, 0, 1537, 1538, 5, 31, 0, 0, 1538, 1539, 6, 66, -1, 0, 1539, 1541, 1, 0, 0, 0, 1540, 1532, 1, 0, 0, 0, 1540, 1533, 1, 0, 0, 0, 1541, 133, 1, 0, 0, 0, 1542, 1553, 1, 0, 0, 0, 1543, 1544, 3, 136, 68, 0, 1544, 1549, 6, 67, -1, 0, 1545, 1546, 7, 7, 0, 0, 1546, 1548, 6, 67, -1, 0, 1547, 1545, 1, 0, 0, 0, 1548, 1551, 1, 0, 0, 0, 1549, 1547, 1, 0, 0, 0, 1549, 1550, 1, 0, 0, 0, 1550, 1553, 1, 0, 0, 0, 1551, 1549, 1, 0, 0, 0, 1552, 1542, 1, 0, 0, 0, 1552, 1543, 1, 0, 0, 0, 1553, 135, 1, 0, 0, 0, 1554, 1555, 5, 178, 0, 0, 1555, 1635, 6, 68, -1, 0, 1556, 1557, 5, 207, 0, 0, 1557, 1635, 6, 68, -1, 0, 1558, 1559, 5, 208, 0, 0, 1559, 1635, 6, 68, -1, 0, 1560, 1561, 5, 201, 0, 0, 1561, 1635, 6, 68, -1, 0, 1562, 1563, 5, 183, 0, 0, 1563, 1635, 6, 68, -1, 0, 1564, 1565, 5, 184, 0, 0, 1565, 1635, 6, 68, -1, 0, 1566, 1567, 5, 185, 0, 0, 1567, 1635, 6, 68, -1, 0, 1568, 1569, 5, 186, 0, 0, 1569, 1635, 6, 68, -1, 0, 1570, 1571, 5, 187, 0, 0, 1571, 1635, 6, 68, -1, 0, 1572, 1573, 5, 188, 0, 0, 1573, 1635, 6, 68, -1, 0, 1574, 1575, 5, 189, 0, 0, 1575, 1635, 6, 68, -1, 0, 1576, 1577, 5, 190, 0, 0, 1577, 1635, 6, 68, -1, 0, 1578, 1579, 5, 191, 0, 0, 1579, 1635, 6, 68, -1, 0, 1580, 1581, 5, 192, 0, 0, 1581, 1635, 6, 68, -1, 0, 1582, 1583, 5, 193, 0, 0, 1583, 1635, 6, 68, -1, 0, 1584, 1585, 5, 262, 0, 0, 1585, 1635, 6, 68, -1, 0, 1586, 1587, 5, 211, 0, 0, 1587, 1635, 6, 68, -1, 0, 1588, 1589, 5, 212, 0, 0, 1589, 1635, 6, 68, -1, 0, 1590, 1591, 5, 213, 0, 0, 1591, 1635, 6, 68, -1, 0, 1592, 1593, 5, 214, 0, 0, 1593, 1635, 6, 68, -1, 0, 1594, 1595, 5, 215, 0, 0, 1595, 1635, 6, 68, -1, 0, 1596, 1597, 5, 218, 0, 0, 1597, 1635, 6, 68, -1, 0, 1598, 1599, 5, 219, 0, 0, 1599, 1635, 6, 68, -1, 0, 1600, 1601, 5, 222, 0, 0, 1601, 1635, 6, 68, -1, 0, 1602, 1603, 5, 194, 0, 0, 1603, 1635, 6, 68, -1, 0, 1604, 1605, 5, 195, 0, 0, 1605, 1635, 6, 68, -1, 0, 1606, 1607, 5, 210, 0, 0, 1607, 1635, 6, 68, -1, 0, 1608, 1609, 5, 230, 0, 0, 1609, 1635, 6, 68, -1, 0, 1610, 1611, 5, 231, 0, 0, 1611, 1635, 6, 68, -1, 0, 1612, 1613, 5, 232, 0, 0, 1613, 1635, 6, 68, -1, 0, 1614, 1615, 5, 233, 0, 0, 1615, 1635, 6, 68, -1, 0, 1616, 1617, 5, 234, 0, 0, 1617, 1635, 6, 68, -1, 0, 1618, 1619, 5, 235, 0, 0, 1619, 1635, 6, 68, -1, 0, 1620, 1621, 5, 236, 0, 0, 1621, 1635, 6, 68, -1, 0, 1622, 1623, 5, 237, 0, 0, 1623, 1635, 6, 68, -1, 0, 1624, 1625, 5, 238, 0, 0, 1625, 1635, 6, 68, -1, 0, 1626, 1627, 5, 239, 0, 0, 1627, 1635, 6, 68, -1, 0, 1628, 1629, 5, 240, 0, 0, 1629, 1635, 6, 68, -1, 0, 1630, 1631, 5, 241, 0, 0, 1631, 1635, 6, 68, -1, 0, 1632, 1633, 5, 242, 0, 0, 1633, 1635, 6, 68, -1, 0, 1634, 1554, 1, 0, 0, 0, 1634, 1556, 1, 0, 0, 0, 1634, 1558, 1, 0, 0, 0, 1634, 1560, 1, 0, 0, 0, 1634, 1562, 1, 0, 0, 0, 1634, 1564, 1, 0, 0, 0, 1634, 1566, 1, 0, 0, 0, 1634, 1568, 1, 0, 0, 0, 1634, 1570, 1, 0, 0, 0, 1634, 1572, 1, 0, 0, 0, 1634, 1574, 1, 0, 0, 0, 1634, 1576, 1, 0, 0, 0, 1634, 1578, 1, 0, 0, 0, 1634, 1580, 1, 0, 0, 0, 1634, 1582, 1, 0, 0, 0, 1634, 1584, 1, 0, 0, 0, 1634, 1586, 1, 0, 0, 0, 1634, 1588, 1, 0, 0, 0, 1634, 1590, 1, 0, 0, 0, 1634, 1592, 1, 0, 0, 0, 1634, 1594, 1, 0, 0, 0, 1634, 1596, 1, 0, 0, 0, 1634, 1598, 1, 0, 0, 0, 1634, 1600, 1, 0, 0, 0, 1634, 1602, 1, 0, 0, 0, 1634, 1604, 1, 0, 0, 0, 1634, 1606, 1, 0, 0, 0, 1634, 1608, 1, 0, 0, 0, 1634, 1610, 1, 0, 0, 0, 1634, 1612, 1, 0, 0, 0, 1634, 1614, 1, 0, 0, 0, 1634, 1616, 1, 0, 0, 0, 1634, 1618, 1, 0, 0, 0, 1634, 1620, 1, 0, 0, 0, 1634, 1622, 1, 0, 0, 0, 1634, 1624, 1, 0, 0, 0, 1634, 1626, 1, 0, 0, 0, 1634, 1628, 1, 0, 0, 0, 1634, 1630, 1, 0, 0, 0, 1634, 1632, 1, 0, 0, 0, 1635, 137, 1, 0, 0, 0, 1636, 1637, 3, 142, 71, 0, 1637, 1643, 6, 69, -1, 0, 1638, 1639, 3, 140, 70, 0, 1639, 1640, 6, 69, -1, 0, 1640, 1642, 1, 0, 0, 0, 1641, 1638, 1, 0, 0, 0, 1642, 1645, 1, 0, 0, 0, 1643, 1641, 1, 0, 0, 0, 1643, 1644, 1, 0, 0, 0, 1644, 139, 1, 0, 0, 0, 1645, 1643, 1, 0, 0, 0, 1646, 1647, 5, 261, 0, 0, 1647, 1676, 6, 70, -1, 0, 1648, 1649, 5, 42, 0, 0, 1649, 1650, 5, 43, 0, 0, 1650, 1676, 6, 70, -1, 0, 1651, 1652, 3, 110, 55, 0, 1652, 1653, 6, 70, -1, 0, 1653, 1676, 1, 0, 0, 0, 1654, 1655, 5, 260, 0, 0, 1655, 1676, 6, 70, -1, 0, 1656, 1657, 5, 262, 0, 0, 1657, 1676, 6, 70, -1, 0, 1658, 1659, 5, 92, 0, 0, 1659, 1676, 6, 70, -1, 0, 1660, 1661, 5, 93, 0, 0, 1661, 1662, 5, 30, 0, 0, 1662, 1663, 3, 124, 62, 0, 1663, 1664, 5, 31, 0, 0, 1664, 1665, 6, 70, -1, 0, 1665, 1676, 1, 0, 0, 0, 1666, 1667, 5, 94, 0, 0, 1667, 1668, 5, 30, 0, 0, 1668, 1669, 3, 124, 62, 0, 1669, 1670, 5, 31, 0, 0, 1670, 1671, 6, 70, -1, 0, 1671, 1676, 1, 0, 0, 0, 1672, 1673, 3, 108, 54, 0, 1673, 1674, 6, 70, -1, 0, 1674, 1676, 1, 0, 0, 0, 1675, 1646, 1, 0, 0, 0, 1675, 1648, 1, 0, 0, 0, 1675, 1651, 1, 0, 0, 0, 1675, 1654, 1, 0, 0, 0, 1675, 1656, 1, 0, 0, 0, 1675, 1658, 1, 0, 0, 0, 1675, 1660, 1, 0, 0, 0, 1675, 1666, 1, 0, 0, 0, 1675, 1672, 1, 0, 0, 0, 1676, 141, 1, 0, 0, 0, 1677, 1678, 5, 39, 0, 0, 1678, 1679, 3, 116, 58, 0, 1679, 1680, 6, 71, -1, 0, 1680, 1736, 1, 0, 0, 0, 1681, 1682, 5, 197, 0, 0, 1682, 1736, 6, 71, -1, 0, 1683, 1684, 5, 199, 0, 0, 1684, 1685, 5, 39, 0, 0, 1685, 1686, 3, 116, 58, 0, 1686, 1687, 6, 71, -1, 0, 1687, 1736, 1, 0, 0, 0, 1688, 1689, 5, 200, 0, 0, 1689, 1690, 3, 116, 58, 0, 1690, 1691, 6, 71, -1, 0, 1691, 1736, 1, 0, 0, 0, 1692, 1693, 5, 226, 0, 0, 1693, 1694, 3, 170, 85, 0, 1694, 1695, 3, 138, 69, 0, 1695, 1696, 5, 262, 0, 0, 1696, 1697, 3, 112, 56, 0, 1697, 1698, 6, 71, -1, 0, 1698, 1736, 1, 0, 0, 0, 1699, 1700, 5, 253, 0, 0, 1700, 1701, 3, 32, 16, 0, 1701, 1702, 6, 71, -1, 0, 1702, 1736, 1, 0, 0, 0, 1703, 1704, 5, 252, 0, 0, 1704, 1705, 3, 32, 16, 0, 1705, 1706, 6, 71, -1, 0, 1706, 1736, 1, 0, 0, 0, 1707, 1708, 5, 253, 0, 0, 1708, 1709, 3, 2, 1, 0, 1709, 1710, 6, 71, -1, 0, 1710, 1736, 1, 0, 0, 0, 1711, 1712, 5, 252, 0, 0, 1712, 1713, 3, 2, 1, 0, 1713, 1714, 6, 71, -1, 0, 1714, 1736, 1, 0, 0, 0, 1715, 1716, 5, 254, 0, 0, 1716, 1736, 6, 71, -1, 0, 1717, 1718, 5, 201, 0, 0, 1718, 1736, 6, 71, -1, 0, 1719, 1720, 3, 148, 74, 0, 1720, 1721, 6, 71, -1, 0, 1721, 1736, 1, 0, 0, 0, 1722, 1723, 3, 150, 75, 0, 1723, 1724, 6, 71, -1, 0, 1724, 1736, 1, 0, 0, 0, 1725, 1726, 3, 144, 72, 0, 1726, 1727, 6, 71, -1, 0, 1727, 1736, 1, 0, 0, 0, 1728, 1729, 3, 2, 1, 0, 1729, 1730, 6, 71, -1, 0, 1730, 1736, 1, 0, 0, 0, 1731, 1732, 5, 177, 0, 0, 1732, 1733, 3, 138, 69, 0, 1733, 1734, 6, 71, -1, 0, 1734, 1736, 1, 0, 0, 0, 1735, 1677, 1, 0, 0, 0, 1735, 1681, 1, 0, 0, 0, 1735, 1683, 1, 0, 0, 0, 1735, 1688, 1, 0, 0, 0, 1735, 1692, 1, 0, 0, 0, 1735, 1699, 1, 0, 0, 0, 1735, 1703, 1, 0, 0, 0, 1735, 1707, 1, 0, 0, 0, 1735, 1711, 1, 0, 0, 0, 1735, 1715, 1, 0, 0, 0, 1735, 1717, 1, 0, 0, 0, 1735, 1719, 1, 0, 0, 0, 1735, 1722, 1, 0, 0, 0, 1735, 1725, 1, 0, 0, 0, 1735, 1728, 1, 0, 0, 0, 1735, 1731, 1, 0, 0, 0, 1736, 143, 1, 0, 0, 0, 1737, 1738, 5, 181, 0, 0, 1738, 1776, 6, 72, -1, 0, 1739, 1740, 5, 182, 0, 0, 1740, 1776, 6, 72, -1, 0, 1741, 1742, 5, 183, 0, 0, 1742, 1776, 6, 72, -1, 0, 1743, 1744, 5, 184, 0, 0, 1744, 1776, 6, 72, -1, 0, 1745, 1746, 5, 185, 0, 0, 1746, 1776, 6, 72, -1, 0, 1747, 1748, 5, 186, 0, 0, 1748, 1776, 6, 72, -1, 0, 1749, 1750, 5, 187, 0, 0, 1750, 1776, 6, 72, -1, 0, 1751, 1752, 5, 188, 0, 0, 1752, 1776, 6, 72, -1, 0, 1753, 1754, 5, 189, 0, 0, 1754, 1776, 6, 72, -1, 0, 1755, 1756, 5, 190, 0, 0, 1756, 1776, 6, 72, -1, 0, 1757, 1758, 5, 191, 0, 0, 1758, 1776, 6, 72, -1, 0, 1759, 1760, 5, 192, 0, 0, 1760, 1776, 6, 72, -1, 0, 1761, 1762, 5, 193, 0, 0, 1762, 1776, 6, 72, -1, 0, 1763, 1764, 5, 90, 0, 0, 1764, 1765, 5, 184, 0, 0, 1765, 1776, 6, 72, -1, 0, 1766, 1767, 5, 90, 0, 0, 1767, 1768, 5, 185, 0, 0, 1768, 1776, 6, 72, -1, 0, 1769, 1770, 5, 90, 0, 0, 1770, 1771, 5, 186, 0, 0, 1771, 1776, 6, 72, -1, 0, 1772, 1773, 5, 90, 0, 0, 1773, 1774, 5, 187, 0, 0, 1774, 1776, 6, 72, -1, 0, 1775, 1737, 1, 0, 0, 0, 1775, 1739, 1, 0, 0, 0, 1775, 1741, 1, 0, 0, 0, 1775, 1743, 1, 0, 0, 0, 1775, 1745, 1, 0, 0, 0, 1775, 1747, 1, 0, 0, 0, 1775, 1749, 1, 0, 0, 0, 1775, 1751, 1, 0, 0, 0, 1775, 1753, 1, 0, 0, 0, 1775, 1755, 1, 0, 0, 0, 1775, 1757, 1, 0, 0, 0, 1775, 1759, 1, 0, 0, 0, 1775, 1761, 1, 0, 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, 145, 1, 0, 0, 0, 1777, 1792, 1, 0, 0, 0, 1778, 1792, 5, 177, 0, 0, 1779, 1780, 3, 32, 16, 0, 1780, 1781, 6, 73, -1, 0, 1781, 1792, 1, 0, 0, 0, 1782, 1783, 3, 32, 16, 0, 1783, 1784, 5, 177, 0, 0, 1784, 1785, 3, 32, 16, 0, 1785, 1786, 6, 73, -1, 0, 1786, 1792, 1, 0, 0, 0, 1787, 1788, 3, 32, 16, 0, 1788, 1789, 5, 177, 0, 0, 1789, 1790, 6, 73, -1, 0, 1790, 1792, 1, 0, 0, 0, 1791, 1777, 1, 0, 0, 0, 1791, 1778, 1, 0, 0, 0, 1791, 1779, 1, 0, 0, 0, 1791, 1782, 1, 0, 0, 0, 1791, 1787, 1, 0, 0, 0, 1792, 147, 1, 0, 0, 0, 1793, 1794, 5, 1, 0, 0, 1794, 1795, 5, 194, 0, 0, 1795, 1796, 6, 74, -1, 0, 1796, 149, 1, 0, 0, 0, 1797, 1801, 5, 1, 0, 0, 1798, 1799, 5, 90, 0, 0, 1799, 1802, 5, 194, 0, 0, 1800, 1802, 5, 195, 0, 0, 1801, 1798, 1, 0, 0, 0, 1801, 1800, 1, 0, 0, 0, 1802, 1803, 1, 0, 0, 0, 1803, 1804, 6, 75, -1, 0, 1804, 151, 1, 0, 0, 0, 1805, 1806, 5, 294, 0, 0, 1806, 1807, 3, 166, 83, 0, 1807, 1808, 3, 124, 62, 0, 1808, 1809, 5, 30, 0, 0, 1809, 1810, 3, 158, 79, 0, 1810, 1811, 5, 31, 0, 0, 1811, 1853, 1, 0, 0, 0, 1812, 1813, 5, 294, 0, 0, 1813, 1814, 3, 166, 83, 0, 1814, 1815, 3, 124, 62, 0, 1815, 1816, 5, 36, 0, 0, 1816, 1817, 5, 17, 0, 0, 1817, 1818, 3, 52, 26, 0, 1818, 1819, 5, 18, 0, 0, 1819, 1853, 1, 0, 0, 0, 1820, 1821, 5, 294, 0, 0, 1821, 1822, 3, 166, 83, 0, 1822, 1823, 3, 124, 62, 0, 1823, 1853, 1, 0, 0, 0, 1824, 1825, 5, 295, 0, 0, 1825, 1826, 3, 166, 83, 0, 1826, 1828, 5, 36, 0, 0, 1827, 1829, 5, 84, 0, 0, 1828, 1827, 1, 0, 0, 0, 1828, 1829, 1, 0, 0, 0, 1829, 1830, 1, 0, 0, 0, 1830, 1831, 5, 30, 0, 0, 1831, 1832, 3, 300, 150, 0, 1832, 1833, 5, 31, 0, 0, 1833, 1853, 1, 0, 0, 0, 1834, 1835, 5, 295, 0, 0, 1835, 1836, 3, 166, 83, 0, 1836, 1837, 5, 84, 0, 0, 1837, 1838, 5, 30, 0, 0, 1838, 1839, 3, 300, 150, 0, 1839, 1840, 5, 31, 0, 0, 1840, 1853, 1, 0, 0, 0, 1841, 1842, 5, 295, 0, 0, 1842, 1843, 3, 166, 83, 0, 1843, 1844, 3, 6, 3, 0, 1844, 1853, 1, 0, 0, 0, 1845, 1846, 5, 295, 0, 0, 1846, 1847, 3, 166, 83, 0, 1847, 1848, 5, 36, 0, 0, 1848, 1849, 5, 17, 0, 0, 1849, 1850, 3, 154, 77, 0, 1850, 1851, 5, 18, 0, 0, 1851, 1853, 1, 0, 0, 0, 1852, 1805, 1, 0, 0, 0, 1852, 1812, 1, 0, 0, 0, 1852, 1820, 1, 0, 0, 0, 1852, 1824, 1, 0, 0, 0, 1852, 1834, 1, 0, 0, 0, 1852, 1841, 1, 0, 0, 0, 1852, 1845, 1, 0, 0, 0, 1853, 153, 1, 0, 0, 0, 1854, 1865, 1, 0, 0, 0, 1855, 1856, 3, 156, 78, 0, 1856, 1857, 5, 28, 0, 0, 1857, 1859, 1, 0, 0, 0, 1858, 1855, 1, 0, 0, 0, 1859, 1862, 1, 0, 0, 0, 1860, 1858, 1, 0, 0, 0, 1860, 1861, 1, 0, 0, 0, 1861, 1863, 1, 0, 0, 0, 1862, 1860, 1, 0, 0, 0, 1863, 1865, 3, 156, 78, 0, 1864, 1854, 1, 0, 0, 0, 1864, 1860, 1, 0, 0, 0, 1865, 155, 1, 0, 0, 0, 1866, 1867, 5, 39, 0, 0, 1867, 1868, 5, 264, 0, 0, 1868, 1869, 5, 36, 0, 0, 1869, 1870, 5, 17, 0, 0, 1870, 1871, 3, 56, 28, 0, 1871, 1872, 5, 18, 0, 0, 1872, 1880, 1, 0, 0, 0, 1873, 1874, 3, 124, 62, 0, 1874, 1875, 5, 36, 0, 0, 1875, 1876, 5, 17, 0, 0, 1876, 1877, 3, 56, 28, 0, 1877, 1878, 5, 18, 0, 0, 1878, 1880, 1, 0, 0, 0, 1879, 1866, 1, 0, 0, 0, 1879, 1873, 1, 0, 0, 0, 1880, 157, 1, 0, 0, 0, 1881, 1882, 3, 160, 80, 0, 1882, 1883, 5, 28, 0, 0, 1883, 1885, 1, 0, 0, 0, 1884, 1881, 1, 0, 0, 0, 1885, 1888, 1, 0, 0, 0, 1886, 1884, 1, 0, 0, 0, 1886, 1887, 1, 0, 0, 0, 1887, 1889, 1, 0, 0, 0, 1888, 1886, 1, 0, 0, 0, 1889, 1890, 3, 160, 80, 0, 1890, 159, 1, 0, 0, 0, 1891, 1892, 3, 6, 3, 0, 1892, 1893, 5, 36, 0, 0, 1893, 1894, 3, 164, 82, 0, 1894, 161, 1, 0, 0, 0, 1895, 1896, 7, 8, 0, 0, 1896, 163, 1, 0, 0, 0, 1897, 1932, 3, 162, 81, 0, 1898, 1932, 3, 32, 16, 0, 1899, 1900, 5, 186, 0, 0, 1900, 1901, 5, 30, 0, 0, 1901, 1902, 3, 32, 16, 0, 1902, 1903, 5, 31, 0, 0, 1903, 1932, 1, 0, 0, 0, 1904, 1932, 3, 6, 3, 0, 1905, 1906, 3, 116, 58, 0, 1906, 1907, 5, 30, 0, 0, 1907, 1908, 5, 184, 0, 0, 1908, 1909, 5, 75, 0, 0, 1909, 1910, 3, 32, 16, 0, 1910, 1911, 5, 31, 0, 0, 1911, 1932, 1, 0, 0, 0, 1912, 1913, 3, 116, 58, 0, 1913, 1914, 5, 30, 0, 0, 1914, 1915, 5, 185, 0, 0, 1915, 1916, 5, 75, 0, 0, 1916, 1917, 3, 32, 16, 0, 1917, 1918, 5, 31, 0, 0, 1918, 1932, 1, 0, 0, 0, 1919, 1920, 3, 116, 58, 0, 1920, 1921, 5, 30, 0, 0, 1921, 1922, 5, 186, 0, 0, 1922, 1923, 5, 75, 0, 0, 1923, 1924, 3, 32, 16, 0, 1924, 1925, 5, 31, 0, 0, 1925, 1932, 1, 0, 0, 0, 1926, 1927, 3, 116, 58, 0, 1927, 1928, 5, 30, 0, 0, 1928, 1929, 3, 32, 16, 0, 1929, 1930, 5, 31, 0, 0, 1930, 1932, 1, 0, 0, 0, 1931, 1897, 1, 0, 0, 0, 1931, 1898, 1, 0, 0, 0, 1931, 1899, 1, 0, 0, 0, 1931, 1904, 1, 0, 0, 0, 1931, 1905, 1, 0, 0, 0, 1931, 1912, 1, 0, 0, 0, 1931, 1919, 1, 0, 0, 0, 1931, 1926, 1, 0, 0, 0, 1932, 165, 1, 0, 0, 0, 1933, 1934, 7, 9, 0, 0, 1934, 167, 1, 0, 0, 0, 1935, 1936, 3, 170, 85, 0, 1936, 1937, 3, 138, 69, 0, 1937, 1938, 3, 124, 62, 0, 1938, 1939, 5, 176, 0, 0, 1939, 1941, 3, 242, 121, 0, 1940, 1942, 3, 108, 54, 0, 1941, 1940, 1, 0, 0, 0, 1941, 1942, 1, 0, 0, 0, 1942, 1943, 1, 0, 0, 0, 1943, 1944, 3, 112, 56, 0, 1944, 1945, 6, 84, -1, 0, 1945, 1978, 1, 0, 0, 0, 1946, 1947, 3, 170, 85, 0, 1947, 1948, 3, 138, 69, 0, 1948, 1949, 3, 124, 62, 0, 1949, 1950, 5, 176, 0, 0, 1950, 1951, 3, 242, 121, 0, 1951, 1952, 3, 196, 98, 0, 1952, 1953, 3, 112, 56, 0, 1953, 1954, 6, 84, -1, 0, 1954, 1978, 1, 0, 0, 0, 1955, 1956, 3, 170, 85, 0, 1956, 1957, 3, 138, 69, 0, 1957, 1959, 3, 242, 121, 0, 1958, 1960, 3, 108, 54, 0, 1959, 1958, 1, 0, 0, 0, 1959, 1960, 1, 0, 0, 0, 1960, 1961, 1, 0, 0, 0, 1961, 1962, 3, 112, 56, 0, 1962, 1963, 6, 84, -1, 0, 1963, 1978, 1, 0, 0, 0, 1964, 1965, 3, 170, 85, 0, 1965, 1966, 3, 138, 69, 0, 1966, 1967, 3, 242, 121, 0, 1967, 1968, 3, 196, 98, 0, 1968, 1969, 3, 112, 56, 0, 1969, 1970, 6, 84, -1, 0, 1970, 1978, 1, 0, 0, 0, 1971, 1972, 3, 174, 87, 0, 1972, 1973, 6, 84, -1, 0, 1973, 1978, 1, 0, 0, 0, 1974, 1975, 3, 2, 1, 0, 1975, 1976, 6, 84, -1, 0, 1976, 1978, 1, 0, 0, 0, 1977, 1935, 1, 0, 0, 0, 1977, 1946, 1, 0, 0, 0, 1977, 1955, 1, 0, 0, 0, 1977, 1964, 1, 0, 0, 0, 1977, 1971, 1, 0, 0, 0, 1977, 1974, 1, 0, 0, 0, 1978, 169, 1, 0, 0, 0, 1979, 1980, 5, 243, 0, 0, 1980, 1981, 3, 170, 85, 0, 1981, 1982, 6, 85, -1, 0, 1982, 1997, 1, 0, 0, 0, 1983, 1984, 5, 244, 0, 0, 1984, 1985, 3, 170, 85, 0, 1985, 1986, 6, 85, -1, 0, 1986, 1997, 1, 0, 0, 0, 1987, 1988, 3, 172, 86, 0, 1988, 1989, 6, 85, -1, 0, 1989, 1997, 1, 0, 0, 0, 1990, 1991, 5, 112, 0, 0, 1991, 1992, 5, 30, 0, 0, 1992, 1993, 3, 32, 16, 0, 1993, 1994, 5, 31, 0, 0, 1994, 1995, 6, 85, -1, 0, 1995, 1997, 1, 0, 0, 0, 1996, 1979, 1, 0, 0, 0, 1996, 1983, 1, 0, 0, 0, 1996, 1987, 1, 0, 0, 0, 1996, 1990, 1, 0, 0, 0, 1997, 171, 1, 0, 0, 0, 1998, 2018, 1, 0, 0, 0, 1999, 2000, 5, 245, 0, 0, 2000, 2018, 6, 86, -1, 0, 2001, 2002, 5, 246, 0, 0, 2002, 2018, 6, 86, -1, 0, 2003, 2004, 5, 247, 0, 0, 2004, 2005, 5, 248, 0, 0, 2005, 2018, 6, 86, -1, 0, 2006, 2007, 5, 247, 0, 0, 2007, 2008, 5, 249, 0, 0, 2008, 2018, 6, 86, -1, 0, 2009, 2010, 5, 247, 0, 0, 2010, 2011, 5, 250, 0, 0, 2011, 2018, 6, 86, -1, 0, 2012, 2013, 5, 247, 0, 0, 2013, 2014, 5, 251, 0, 0, 2014, 2018, 6, 86, -1, 0, 2015, 2016, 5, 247, 0, 0, 2016, 2018, 6, 86, -1, 0, 2017, 1998, 1, 0, 0, 0, 2017, 1999, 1, 0, 0, 0, 2017, 2001, 1, 0, 0, 0, 2017, 2003, 1, 0, 0, 0, 2017, 2006, 1, 0, 0, 0, 2017, 2009, 1, 0, 0, 0, 2017, 2012, 1, 0, 0, 0, 2017, 2015, 1, 0, 0, 0, 2018, 173, 1, 0, 0, 0, 2019, 2020, 5, 113, 0, 0, 2020, 2021, 5, 30, 0, 0, 2021, 2022, 3, 32, 16, 0, 2022, 2023, 5, 31, 0, 0, 2023, 2024, 6, 87, -1, 0, 2024, 175, 1, 0, 0, 0, 2025, 2026, 5, 226, 0, 0, 2026, 2027, 3, 168, 84, 0, 2027, 2028, 6, 88, -1, 0, 2028, 2037, 1, 0, 0, 0, 2029, 2030, 5, 37, 0, 0, 2030, 2031, 3, 178, 89, 0, 2031, 2032, 6, 88, -1, 0, 2032, 2037, 1, 0, 0, 0, 2033, 2034, 3, 174, 87, 0, 2034, 2035, 6, 88, -1, 0, 2035, 2037, 1, 0, 0, 0, 2036, 2025, 1, 0, 0, 0, 2036, 2029, 1, 0, 0, 0, 2036, 2033, 1, 0, 0, 0, 2037, 177, 1, 0, 0, 0, 2038, 2039, 3, 138, 69, 0, 2039, 2040, 3, 124, 62, 0, 2040, 2041, 5, 176, 0, 0, 2041, 2042, 3, 2, 1, 0, 2042, 2043, 6, 89, -1, 0, 2043, 2052, 1, 0, 0, 0, 2044, 2045, 3, 138, 69, 0, 2045, 2046, 3, 2, 1, 0, 2046, 2047, 6, 89, -1, 0, 2047, 2052, 1, 0, 0, 0, 2048, 2049, 3, 2, 1, 0, 2049, 2050, 6, 89, -1, 0, 2050, 2052, 1, 0, 0, 0, 2051, 2038, 1, 0, 0, 0, 2051, 2044, 1, 0, 0, 0, 2051, 2048, 1, 0, 0, 0, 2052, 179, 1, 0, 0, 0, 2053, 2054, 3, 124, 62, 0, 2054, 2055, 6, 90, -1, 0, 2055, 2056, 5, 28, 0, 0, 2056, 2058, 1, 0, 0, 0, 2057, 2053, 1, 0, 0, 0, 2058, 2061, 1, 0, 0, 0, 2059, 2057, 1, 0, 0, 0, 2059, 2060, 1, 0, 0, 0, 2060, 2062, 1, 0, 0, 0, 2061, 2059, 1, 0, 0, 0, 2062, 2063, 3, 124, 62, 0, 2063, 2064, 6, 90, -1, 0, 2064, 181, 1, 0, 0, 0, 2065, 2072, 1, 0, 0, 0, 2066, 2067, 5, 86, 0, 0, 2067, 2068, 3, 190, 95, 0, 2068, 2069, 5, 87, 0, 0, 2069, 2070, 6, 91, -1, 0, 2070, 2072, 1, 0, 0, 0, 2071, 2065, 1, 0, 0, 0, 2071, 2066, 1, 0, 0, 0, 2072, 183, 1, 0, 0, 0, 2073, 2074, 5, 266, 0, 0, 2074, 2092, 6, 92, -1, 0, 2075, 2076, 5, 114, 0, 0, 2076, 2092, 6, 92, -1, 0, 2077, 2078, 5, 39, 0, 0, 2078, 2092, 6, 92, -1, 0, 2079, 2080, 5, 200, 0, 0, 2080, 2092, 6, 92, -1, 0, 2081, 2082, 5, 115, 0, 0, 2082, 2092, 6, 92, -1, 0, 2083, 2084, 5, 116, 0, 0, 2084, 2092, 6, 92, -1, 0, 2085, 2086, 5, 70, 0, 0, 2086, 2087, 5, 30, 0, 0, 2087, 2088, 3, 32, 16, 0, 2088, 2089, 5, 31, 0, 0, 2089, 2090, 6, 92, -1, 0, 2090, 2092, 1, 0, 0, 0, 2091, 2073, 1, 0, 0, 0, 2091, 2075, 1, 0, 0, 0, 2091, 2077, 1, 0, 0, 0, 2091, 2079, 1, 0, 0, 0, 2091, 2081, 1, 0, 0, 0, 2091, 2083, 1, 0, 0, 0, 2091, 2085, 1, 0, 0, 0, 2092, 185, 1, 0, 0, 0, 2093, 2094, 3, 184, 92, 0, 2094, 2095, 6, 93, -1, 0, 2095, 2097, 1, 0, 0, 0, 2096, 2093, 1, 0, 0, 0, 2097, 2100, 1, 0, 0, 0, 2098, 2096, 1, 0, 0, 0, 2098, 2099, 1, 0, 0, 0, 2099, 187, 1, 0, 0, 0, 2100, 2098, 1, 0, 0, 0, 2101, 2103, 3, 186, 93, 0, 2102, 2104, 3, 192, 96, 0, 2103, 2102, 1, 0, 0, 0, 2103, 2104, 1, 0, 0, 0, 2104, 2105, 1, 0, 0, 0, 2105, 2106, 3, 2, 1, 0, 2106, 2107, 6, 94, -1, 0, 2107, 189, 1, 0, 0, 0, 2108, 2109, 3, 188, 94, 0, 2109, 2110, 6, 95, -1, 0, 2110, 2111, 5, 28, 0, 0, 2111, 2113, 1, 0, 0, 0, 2112, 2108, 1, 0, 0, 0, 2113, 2116, 1, 0, 0, 0, 2114, 2112, 1, 0, 0, 0, 2114, 2115, 1, 0, 0, 0, 2115, 2117, 1, 0, 0, 0, 2116, 2114, 1, 0, 0, 0, 2117, 2118, 3, 188, 94, 0, 2118, 2119, 6, 95, -1, 0, 2119, 191, 1, 0, 0, 0, 2120, 2121, 5, 30, 0, 0, 2121, 2122, 3, 180, 90, 0, 2122, 2123, 5, 31, 0, 0, 2123, 2124, 6, 96, -1, 0, 2124, 193, 1, 0, 0, 0, 2125, 2127, 3, 196, 98, 0, 2126, 2125, 1, 0, 0, 0, 2126, 2127, 1, 0, 0, 0, 2127, 2128, 1, 0, 0, 0, 2128, 2129, 6, 97, -1, 0, 2129, 195, 1, 0, 0, 0, 2130, 2131, 5, 86, 0, 0, 2131, 2132, 5, 42, 0, 0, 2132, 2133, 3, 32, 16, 0, 2133, 2134, 5, 43, 0, 0, 2134, 2135, 5, 87, 0, 0, 2135, 2136, 6, 98, -1, 0, 2136, 197, 1, 0, 0, 0, 2137, 2138, 3, 234, 117, 0, 2138, 2139, 5, 17, 0, 0, 2139, 2140, 3, 246, 123, 0, 2140, 2141, 5, 18, 0, 0, 2141, 2288, 1, 0, 0, 0, 2142, 2143, 3, 74, 37, 0, 2143, 2144, 5, 17, 0, 0, 2144, 2145, 3, 82, 41, 0, 2145, 2146, 5, 18, 0, 0, 2146, 2288, 1, 0, 0, 0, 2147, 2148, 3, 210, 105, 0, 2148, 2149, 6, 99, -1, 0, 2149, 2150, 5, 17, 0, 0, 2150, 2151, 3, 214, 107, 0, 2151, 2152, 5, 18, 0, 0, 2152, 2288, 1, 0, 0, 0, 2153, 2154, 3, 218, 109, 0, 2154, 2155, 6, 99, -1, 0, 2155, 2156, 5, 17, 0, 0, 2156, 2157, 3, 222, 111, 0, 2157, 2158, 5, 18, 0, 0, 2158, 2288, 1, 0, 0, 0, 2159, 2288, 3, 200, 100, 0, 2160, 2161, 3, 284, 142, 0, 2161, 2162, 6, 99, -1, 0, 2162, 2288, 1, 0, 0, 0, 2163, 2164, 3, 152, 76, 0, 2164, 2165, 6, 99, -1, 0, 2165, 2288, 1, 0, 0, 0, 2166, 2167, 3, 88, 44, 0, 2167, 2168, 6, 99, -1, 0, 2168, 2288, 1, 0, 0, 0, 2169, 2170, 3, 330, 165, 0, 2170, 2171, 6, 99, -1, 0, 2171, 2288, 1, 0, 0, 0, 2172, 2173, 5, 117, 0, 0, 2173, 2174, 3, 32, 16, 0, 2174, 2175, 6, 99, -1, 0, 2175, 2288, 1, 0, 0, 0, 2176, 2177, 5, 118, 0, 0, 2177, 2178, 3, 32, 16, 0, 2178, 2179, 6, 99, -1, 0, 2179, 2288, 1, 0, 0, 0, 2180, 2181, 3, 346, 173, 0, 2181, 2182, 5, 17, 0, 0, 2182, 2183, 3, 350, 175, 0, 2183, 2184, 5, 18, 0, 0, 2184, 2185, 6, 99, -1, 0, 2185, 2288, 1, 0, 0, 0, 2186, 2187, 5, 302, 0, 0, 2187, 2188, 3, 124, 62, 0, 2188, 2189, 5, 176, 0, 0, 2189, 2190, 3, 242, 121, 0, 2190, 2191, 5, 119, 0, 0, 2191, 2192, 3, 170, 85, 0, 2192, 2193, 3, 138, 69, 0, 2193, 2194, 3, 124, 62, 0, 2194, 2195, 5, 176, 0, 0, 2195, 2196, 3, 242, 121, 0, 2196, 2197, 3, 112, 56, 0, 2197, 2198, 6, 99, -1, 0, 2198, 2288, 1, 0, 0, 0, 2199, 2200, 5, 302, 0, 0, 2200, 2201, 5, 226, 0, 0, 2201, 2202, 3, 170, 85, 0, 2202, 2203, 3, 138, 69, 0, 2203, 2204, 3, 124, 62, 0, 2204, 2205, 5, 176, 0, 0, 2205, 2206, 3, 242, 121, 0, 2206, 2207, 3, 194, 97, 0, 2207, 2208, 3, 112, 56, 0, 2208, 2209, 5, 119, 0, 0, 2209, 2210, 5, 226, 0, 0, 2210, 2211, 3, 170, 85, 0, 2211, 2212, 3, 138, 69, 0, 2212, 2213, 3, 124, 62, 0, 2213, 2214, 5, 176, 0, 0, 2214, 2215, 3, 242, 121, 0, 2215, 2216, 3, 194, 97, 0, 2216, 2217, 3, 112, 56, 0, 2217, 2218, 6, 99, -1, 0, 2218, 2288, 1, 0, 0, 0, 2219, 2220, 3, 26, 13, 0, 2220, 2221, 6, 99, -1, 0, 2221, 2288, 1, 0, 0, 0, 2222, 2223, 3, 40, 20, 0, 2223, 2224, 6, 99, -1, 0, 2224, 2288, 1, 0, 0, 0, 2225, 2226, 5, 255, 0, 0, 2226, 2227, 5, 196, 0, 0, 2227, 2228, 5, 42, 0, 0, 2228, 2229, 3, 32, 16, 0, 2229, 2230, 5, 43, 0, 0, 2230, 2236, 6, 99, -1, 0, 2231, 2232, 3, 330, 165, 0, 2232, 2233, 6, 99, -1, 0, 2233, 2235, 1, 0, 0, 0, 2234, 2231, 1, 0, 0, 0, 2235, 2238, 1, 0, 0, 0, 2236, 2234, 1, 0, 0, 0, 2236, 2237, 1, 0, 0, 0, 2237, 2288, 1, 0, 0, 0, 2238, 2236, 1, 0, 0, 0, 2239, 2240, 5, 255, 0, 0, 2240, 2241, 5, 196, 0, 0, 2241, 2242, 3, 2, 1, 0, 2242, 2248, 6, 99, -1, 0, 2243, 2244, 3, 330, 165, 0, 2244, 2245, 6, 99, -1, 0, 2245, 2247, 1, 0, 0, 0, 2246, 2243, 1, 0, 0, 0, 2247, 2250, 1, 0, 0, 0, 2248, 2246, 1, 0, 0, 0, 2248, 2249, 1, 0, 0, 0, 2249, 2288, 1, 0, 0, 0, 2250, 2248, 1, 0, 0, 0, 2251, 2252, 5, 255, 0, 0, 2252, 2253, 5, 256, 0, 0, 2253, 2254, 5, 42, 0, 0, 2254, 2255, 3, 32, 16, 0, 2255, 2256, 5, 43, 0, 0, 2256, 2257, 5, 28, 0, 0, 2257, 2258, 3, 124, 62, 0, 2258, 2264, 6, 99, -1, 0, 2259, 2260, 3, 330, 165, 0, 2260, 2261, 6, 99, -1, 0, 2261, 2263, 1, 0, 0, 0, 2262, 2259, 1, 0, 0, 0, 2263, 2266, 1, 0, 0, 0, 2264, 2262, 1, 0, 0, 0, 2264, 2265, 1, 0, 0, 0, 2265, 2288, 1, 0, 0, 0, 2266, 2264, 1, 0, 0, 0, 2267, 2268, 5, 255, 0, 0, 2268, 2269, 5, 256, 0, 0, 2269, 2270, 3, 2, 1, 0, 2270, 2271, 5, 28, 0, 0, 2271, 2272, 3, 124, 62, 0, 2272, 2278, 6, 99, -1, 0, 2273, 2274, 3, 330, 165, 0, 2274, 2275, 6, 99, -1, 0, 2275, 2277, 1, 0, 0, 0, 2276, 2273, 1, 0, 0, 0, 2277, 2280, 1, 0, 0, 0, 2278, 2276, 1, 0, 0, 0, 2278, 2279, 1, 0, 0, 0, 2279, 2288, 1, 0, 0, 0, 2280, 2278, 1, 0, 0, 0, 2281, 2282, 5, 120, 0, 0, 2282, 2283, 5, 196, 0, 0, 2283, 2284, 3, 124, 62, 0, 2284, 2285, 3, 44, 22, 0, 2285, 2286, 6, 99, -1, 0, 2286, 2288, 1, 0, 0, 0, 2287, 2137, 1, 0, 0, 0, 2287, 2142, 1, 0, 0, 0, 2287, 2147, 1, 0, 0, 0, 2287, 2153, 1, 0, 0, 0, 2287, 2159, 1, 0, 0, 0, 2287, 2160, 1, 0, 0, 0, 2287, 2163, 1, 0, 0, 0, 2287, 2166, 1, 0, 0, 0, 2287, 2169, 1, 0, 0, 0, 2287, 2172, 1, 0, 0, 0, 2287, 2176, 1, 0, 0, 0, 2287, 2180, 1, 0, 0, 0, 2287, 2186, 1, 0, 0, 0, 2287, 2199, 1, 0, 0, 0, 2287, 2219, 1, 0, 0, 0, 2287, 2222, 1, 0, 0, 0, 2287, 2225, 1, 0, 0, 0, 2287, 2239, 1, 0, 0, 0, 2287, 2251, 1, 0, 0, 0, 2287, 2267, 1, 0, 0, 0, 2287, 2281, 1, 0, 0, 0, 2288, 199, 1, 0, 0, 0, 2289, 2290, 5, 121, 0, 0, 2290, 2302, 3, 208, 104, 0, 2291, 2292, 3, 202, 101, 0, 2292, 2293, 6, 100, -1, 0, 2293, 2301, 1, 0, 0, 0, 2294, 2295, 5, 122, 0, 0, 2295, 2296, 5, 30, 0, 0, 2296, 2297, 3, 228, 114, 0, 2297, 2298, 5, 31, 0, 0, 2298, 2299, 6, 100, -1, 0, 2299, 2301, 1, 0, 0, 0, 2300, 2291, 1, 0, 0, 0, 2300, 2294, 1, 0, 0, 0, 2301, 2304, 1, 0, 0, 0, 2302, 2300, 1, 0, 0, 0, 2302, 2303, 1, 0, 0, 0, 2303, 2305, 1, 0, 0, 0, 2304, 2302, 1, 0, 0, 0, 2305, 2306, 3, 138, 69, 0, 2306, 2307, 3, 2, 1, 0, 2307, 2308, 3, 204, 102, 0, 2308, 2309, 3, 206, 103, 0, 2309, 2310, 6, 100, -1, 0, 2310, 201, 1, 0, 0, 0, 2311, 2312, 5, 123, 0, 0, 2312, 2346, 6, 101, -1, 0, 2313, 2314, 5, 51, 0, 0, 2314, 2346, 6, 101, -1, 0, 2315, 2316, 5, 52, 0, 0, 2316, 2346, 6, 101, -1, 0, 2317, 2318, 5, 63, 0, 0, 2318, 2346, 6, 101, -1, 0, 2319, 2320, 5, 124, 0, 0, 2320, 2346, 6, 101, -1, 0, 2321, 2322, 5, 69, 0, 0, 2322, 2346, 6, 101, -1, 0, 2323, 2324, 5, 68, 0, 0, 2324, 2346, 6, 101, -1, 0, 2325, 2326, 5, 64, 0, 0, 2326, 2346, 6, 101, -1, 0, 2327, 2328, 5, 65, 0, 0, 2328, 2346, 6, 101, -1, 0, 2329, 2330, 5, 66, 0, 0, 2330, 2346, 6, 101, -1, 0, 2331, 2332, 5, 125, 0, 0, 2332, 2346, 6, 101, -1, 0, 2333, 2334, 5, 126, 0, 0, 2334, 2346, 6, 101, -1, 0, 2335, 2336, 5, 127, 0, 0, 2336, 2346, 6, 101, -1, 0, 2337, 2338, 5, 16, 0, 0, 2338, 2346, 6, 101, -1, 0, 2339, 2340, 5, 70, 0, 0, 2340, 2341, 5, 30, 0, 0, 2341, 2342, 3, 32, 16, 0, 2342, 2343, 5, 31, 0, 0, 2343, 2344, 6, 101, -1, 0, 2344, 2346, 1, 0, 0, 0, 2345, 2311, 1, 0, 0, 0, 2345, 2313, 1, 0, 0, 0, 2345, 2315, 1, 0, 0, 0, 2345, 2317, 1, 0, 0, 0, 2345, 2319, 1, 0, 0, 0, 2345, 2321, 1, 0, 0, 0, 2345, 2323, 1, 0, 0, 0, 2345, 2325, 1, 0, 0, 0, 2345, 2327, 1, 0, 0, 0, 2345, 2329, 1, 0, 0, 0, 2345, 2331, 1, 0, 0, 0, 2345, 2333, 1, 0, 0, 0, 2345, 2335, 1, 0, 0, 0, 2345, 2337, 1, 0, 0, 0, 2345, 2339, 1, 0, 0, 0, 2346, 203, 1, 0, 0, 0, 2347, 2357, 1, 0, 0, 0, 2348, 2349, 5, 44, 0, 0, 2349, 2350, 3, 0, 0, 0, 2350, 2351, 6, 102, -1, 0, 2351, 2357, 1, 0, 0, 0, 2352, 2353, 5, 44, 0, 0, 2353, 2354, 3, 32, 16, 0, 2354, 2355, 6, 102, -1, 0, 2355, 2357, 1, 0, 0, 0, 2356, 2347, 1, 0, 0, 0, 2356, 2348, 1, 0, 0, 0, 2356, 2352, 1, 0, 0, 0, 2357, 205, 1, 0, 0, 0, 2358, 2364, 1, 0, 0, 0, 2359, 2360, 5, 36, 0, 0, 2360, 2361, 3, 304, 152, 0, 2361, 2362, 6, 103, -1, 0, 2362, 2364, 1, 0, 0, 0, 2363, 2358, 1, 0, 0, 0, 2363, 2359, 1, 0, 0, 0, 2364, 207, 1, 0, 0, 0, 2365, 2372, 1, 0, 0, 0, 2366, 2367, 5, 42, 0, 0, 2367, 2368, 3, 32, 16, 0, 2368, 2369, 5, 43, 0, 0, 2369, 2370, 6, 104, -1, 0, 2370, 2372, 1, 0, 0, 0, 2371, 2365, 1, 0, 0, 0, 2371, 2366, 1, 0, 0, 0, 2372, 209, 1, 0, 0, 0, 2373, 2379, 5, 128, 0, 0, 2374, 2375, 3, 212, 106, 0, 2375, 2376, 6, 105, -1, 0, 2376, 2378, 1, 0, 0, 0, 2377, 2374, 1, 0, 0, 0, 2378, 2381, 1, 0, 0, 0, 2379, 2377, 1, 0, 0, 0, 2379, 2380, 1, 0, 0, 0, 2380, 2382, 1, 0, 0, 0, 2381, 2379, 1, 0, 0, 0, 2382, 2383, 3, 124, 62, 0, 2383, 2384, 3, 2, 1, 0, 2384, 2385, 6, 105, -1, 0, 2385, 2399, 1, 0, 0, 0, 2386, 2392, 5, 128, 0, 0, 2387, 2388, 3, 212, 106, 0, 2388, 2389, 6, 105, -1, 0, 2389, 2391, 1, 0, 0, 0, 2390, 2387, 1, 0, 0, 0, 2391, 2394, 1, 0, 0, 0, 2392, 2390, 1, 0, 0, 0, 2392, 2393, 1, 0, 0, 0, 2393, 2395, 1, 0, 0, 0, 2394, 2392, 1, 0, 0, 0, 2395, 2396, 3, 2, 1, 0, 2396, 2397, 6, 105, -1, 0, 2397, 2399, 1, 0, 0, 0, 2398, 2373, 1, 0, 0, 0, 2398, 2386, 1, 0, 0, 0, 2399, 211, 1, 0, 0, 0, 2400, 2401, 5, 69, 0, 0, 2401, 2405, 6, 106, -1, 0, 2402, 2403, 5, 68, 0, 0, 2403, 2405, 6, 106, -1, 0, 2404, 2400, 1, 0, 0, 0, 2404, 2402, 1, 0, 0, 0, 2405, 213, 1, 0, 0, 0, 2406, 2408, 3, 216, 108, 0, 2407, 2406, 1, 0, 0, 0, 2408, 2411, 1, 0, 0, 0, 2409, 2407, 1, 0, 0, 0, 2409, 2410, 1, 0, 0, 0, 2410, 215, 1, 0, 0, 0, 2411, 2409, 1, 0, 0, 0, 2412, 2413, 5, 129, 0, 0, 2413, 2414, 3, 168, 84, 0, 2414, 2415, 6, 108, -1, 0, 2415, 2439, 1, 0, 0, 0, 2416, 2417, 5, 130, 0, 0, 2417, 2418, 3, 168, 84, 0, 2418, 2419, 6, 108, -1, 0, 2419, 2439, 1, 0, 0, 0, 2420, 2421, 5, 131, 0, 0, 2421, 2422, 3, 168, 84, 0, 2422, 2423, 6, 108, -1, 0, 2423, 2439, 1, 0, 0, 0, 2424, 2425, 5, 132, 0, 0, 2425, 2426, 3, 168, 84, 0, 2426, 2427, 6, 108, -1, 0, 2427, 2439, 1, 0, 0, 0, 2428, 2429, 3, 88, 44, 0, 2429, 2430, 6, 108, -1, 0, 2430, 2439, 1, 0, 0, 0, 2431, 2432, 3, 330, 165, 0, 2432, 2433, 6, 108, -1, 0, 2433, 2439, 1, 0, 0, 0, 2434, 2435, 3, 26, 13, 0, 2435, 2436, 6, 108, -1, 0, 2436, 2439, 1, 0, 0, 0, 2437, 2439, 3, 40, 20, 0, 2438, 2412, 1, 0, 0, 0, 2438, 2416, 1, 0, 0, 0, 2438, 2420, 1, 0, 0, 0, 2438, 2424, 1, 0, 0, 0, 2438, 2428, 1, 0, 0, 0, 2438, 2431, 1, 0, 0, 0, 2438, 2434, 1, 0, 0, 0, 2438, 2437, 1, 0, 0, 0, 2439, 217, 1, 0, 0, 0, 2440, 2446, 5, 133, 0, 0, 2441, 2442, 3, 220, 110, 0, 2442, 2443, 6, 109, -1, 0, 2443, 2445, 1, 0, 0, 0, 2444, 2441, 1, 0, 0, 0, 2445, 2448, 1, 0, 0, 0, 2446, 2444, 1, 0, 0, 0, 2446, 2447, 1, 0, 0, 0, 2447, 2449, 1, 0, 0, 0, 2448, 2446, 1, 0, 0, 0, 2449, 2450, 3, 170, 85, 0, 2450, 2451, 3, 138, 69, 0, 2451, 2452, 3, 2, 1, 0, 2452, 2453, 3, 112, 56, 0, 2453, 2454, 3, 206, 103, 0, 2454, 2455, 6, 109, -1, 0, 2455, 219, 1, 0, 0, 0, 2456, 2457, 5, 69, 0, 0, 2457, 2461, 6, 110, -1, 0, 2458, 2459, 5, 68, 0, 0, 2459, 2461, 6, 110, -1, 0, 2460, 2456, 1, 0, 0, 0, 2460, 2458, 1, 0, 0, 0, 2461, 221, 1, 0, 0, 0, 2462, 2464, 3, 224, 112, 0, 2463, 2462, 1, 0, 0, 0, 2464, 2467, 1, 0, 0, 0, 2465, 2463, 1, 0, 0, 0, 2465, 2466, 1, 0, 0, 0, 2466, 223, 1, 0, 0, 0, 2467, 2465, 1, 0, 0, 0, 2468, 2469, 5, 134, 0, 0, 2469, 2470, 3, 168, 84, 0, 2470, 2471, 6, 112, -1, 0, 2471, 2491, 1, 0, 0, 0, 2472, 2473, 5, 135, 0, 0, 2473, 2474, 3, 168, 84, 0, 2474, 2475, 6, 112, -1, 0, 2475, 2491, 1, 0, 0, 0, 2476, 2477, 5, 132, 0, 0, 2477, 2478, 3, 168, 84, 0, 2478, 2479, 6, 112, -1, 0, 2479, 2491, 1, 0, 0, 0, 2480, 2481, 3, 330, 165, 0, 2481, 2482, 6, 112, -1, 0, 2482, 2491, 1, 0, 0, 0, 2483, 2484, 3, 88, 44, 0, 2484, 2485, 6, 112, -1, 0, 2485, 2491, 1, 0, 0, 0, 2486, 2487, 3, 26, 13, 0, 2487, 2488, 6, 112, -1, 0, 2488, 2491, 1, 0, 0, 0, 2489, 2491, 3, 40, 20, 0, 2490, 2468, 1, 0, 0, 0, 2490, 2472, 1, 0, 0, 0, 2490, 2476, 1, 0, 0, 0, 2490, 2480, 1, 0, 0, 0, 2490, 2483, 1, 0, 0, 0, 2490, 2486, 1, 0, 0, 0, 2490, 2489, 1, 0, 0, 0, 2491, 225, 1, 0, 0, 0, 2492, 2500, 6, 113, -1, 0, 2493, 2494, 5, 122, 0, 0, 2494, 2495, 5, 30, 0, 0, 2495, 2496, 3, 228, 114, 0, 2496, 2497, 5, 31, 0, 0, 2497, 2498, 6, 113, -1, 0, 2498, 2500, 1, 0, 0, 0, 2499, 2492, 1, 0, 0, 0, 2499, 2493, 1, 0, 0, 0, 2500, 227, 1, 0, 0, 0, 2501, 2502, 3, 126, 63, 0, 2502, 2503, 6, 114, -1, 0, 2503, 2515, 1, 0, 0, 0, 2504, 2508, 5, 17, 0, 0, 2505, 2506, 3, 302, 151, 0, 2506, 2507, 6, 114, -1, 0, 2507, 2509, 1, 0, 0, 0, 2508, 2505, 1, 0, 0, 0, 2509, 2510, 1, 0, 0, 0, 2510, 2508, 1, 0, 0, 0, 2510, 2511, 1, 0, 0, 0, 2511, 2512, 1, 0, 0, 0, 2512, 2513, 5, 18, 0, 0, 2513, 2515, 1, 0, 0, 0, 2514, 2501, 1, 0, 0, 0, 2514, 2504, 1, 0, 0, 0, 2515, 229, 1, 0, 0, 0, 2516, 2517, 3, 232, 116, 0, 2517, 2518, 6, 115, -1, 0, 2518, 2520, 1, 0, 0, 0, 2519, 2516, 1, 0, 0, 0, 2520, 2523, 1, 0, 0, 0, 2521, 2519, 1, 0, 0, 0, 2521, 2522, 1, 0, 0, 0, 2522, 231, 1, 0, 0, 0, 2523, 2521, 1, 0, 0, 0, 2524, 2525, 5, 42, 0, 0, 2525, 2526, 5, 136, 0, 0, 2526, 2527, 5, 43, 0, 0, 2527, 2542, 6, 116, -1, 0, 2528, 2529, 5, 42, 0, 0, 2529, 2530, 5, 137, 0, 0, 2530, 2531, 5, 43, 0, 0, 2531, 2542, 6, 116, -1, 0, 2532, 2533, 5, 42, 0, 0, 2533, 2534, 5, 138, 0, 0, 2534, 2535, 5, 43, 0, 0, 2535, 2542, 6, 116, -1, 0, 2536, 2537, 5, 42, 0, 0, 2537, 2538, 3, 32, 16, 0, 2538, 2539, 5, 43, 0, 0, 2539, 2540, 6, 116, -1, 0, 2540, 2542, 1, 0, 0, 0, 2541, 2524, 1, 0, 0, 0, 2541, 2528, 1, 0, 0, 0, 2541, 2532, 1, 0, 0, 0, 2541, 2536, 1, 0, 0, 0, 2542, 233, 1, 0, 0, 0, 2543, 2552, 5, 139, 0, 0, 2544, 2545, 3, 236, 118, 0, 2545, 2546, 6, 117, -1, 0, 2546, 2551, 1, 0, 0, 0, 2547, 2548, 3, 238, 119, 0, 2548, 2549, 6, 117, -1, 0, 2549, 2551, 1, 0, 0, 0, 2550, 2544, 1, 0, 0, 0, 2550, 2547, 1, 0, 0, 0, 2551, 2554, 1, 0, 0, 0, 2552, 2550, 1, 0, 0, 0, 2552, 2553, 1, 0, 0, 0, 2553, 2555, 1, 0, 0, 0, 2554, 2552, 1, 0, 0, 0, 2555, 2556, 3, 170, 85, 0, 2556, 2557, 3, 230, 115, 0, 2557, 2558, 3, 138, 69, 0, 2558, 2559, 3, 226, 113, 0, 2559, 2560, 3, 242, 121, 0, 2560, 2561, 3, 182, 91, 0, 2561, 2567, 3, 112, 56, 0, 2562, 2563, 3, 244, 122, 0, 2563, 2564, 6, 117, -1, 0, 2564, 2566, 1, 0, 0, 0, 2565, 2562, 1, 0, 0, 0, 2566, 2569, 1, 0, 0, 0, 2567, 2565, 1, 0, 0, 0, 2567, 2568, 1, 0, 0, 0, 2568, 2570, 1, 0, 0, 0, 2569, 2567, 1, 0, 0, 0, 2570, 2571, 6, 117, -1, 0, 2571, 235, 1, 0, 0, 0, 2572, 2573, 5, 123, 0, 0, 2573, 2615, 6, 118, -1, 0, 2574, 2575, 5, 51, 0, 0, 2575, 2615, 6, 118, -1, 0, 2576, 2577, 5, 52, 0, 0, 2577, 2615, 6, 118, -1, 0, 2578, 2579, 5, 63, 0, 0, 2579, 2615, 6, 118, -1, 0, 2580, 2581, 5, 140, 0, 0, 2581, 2615, 6, 118, -1, 0, 2582, 2583, 5, 68, 0, 0, 2583, 2615, 6, 118, -1, 0, 2584, 2585, 5, 141, 0, 0, 2585, 2615, 6, 118, -1, 0, 2586, 2587, 5, 142, 0, 0, 2587, 2615, 6, 118, -1, 0, 2588, 2589, 5, 54, 0, 0, 2589, 2615, 6, 118, -1, 0, 2590, 2591, 5, 64, 0, 0, 2591, 2615, 6, 118, -1, 0, 2592, 2593, 5, 65, 0, 0, 2593, 2615, 6, 118, -1, 0, 2594, 2595, 5, 66, 0, 0, 2595, 2615, 6, 118, -1, 0, 2596, 2597, 5, 125, 0, 0, 2597, 2615, 6, 118, -1, 0, 2598, 2599, 5, 143, 0, 0, 2599, 2615, 6, 118, -1, 0, 2600, 2601, 5, 144, 0, 0, 2601, 2615, 6, 118, -1, 0, 2602, 2603, 5, 69, 0, 0, 2603, 2615, 6, 118, -1, 0, 2604, 2605, 5, 145, 0, 0, 2605, 2615, 6, 118, -1, 0, 2606, 2607, 5, 146, 0, 0, 2607, 2615, 6, 118, -1, 0, 2608, 2609, 5, 70, 0, 0, 2609, 2610, 5, 30, 0, 0, 2610, 2611, 3, 32, 16, 0, 2611, 2612, 5, 31, 0, 0, 2612, 2613, 6, 118, -1, 0, 2613, 2615, 1, 0, 0, 0, 2614, 2572, 1, 0, 0, 0, 2614, 2574, 1, 0, 0, 0, 2614, 2576, 1, 0, 0, 0, 2614, 2578, 1, 0, 0, 0, 2614, 2580, 1, 0, 0, 0, 2614, 2582, 1, 0, 0, 0, 2614, 2584, 1, 0, 0, 0, 2614, 2586, 1, 0, 0, 0, 2614, 2588, 1, 0, 0, 0, 2614, 2590, 1, 0, 0, 0, 2614, 2592, 1, 0, 0, 0, 2614, 2594, 1, 0, 0, 0, 2614, 2596, 1, 0, 0, 0, 2614, 2598, 1, 0, 0, 0, 2614, 2600, 1, 0, 0, 0, 2614, 2602, 1, 0, 0, 0, 2614, 2604, 1, 0, 0, 0, 2614, 2606, 1, 0, 0, 0, 2614, 2608, 1, 0, 0, 0, 2615, 237, 1, 0, 0, 0, 2616, 2617, 5, 147, 0, 0, 2617, 2626, 5, 30, 0, 0, 2618, 2619, 3, 6, 3, 0, 2619, 2624, 6, 119, -1, 0, 2620, 2621, 5, 34, 0, 0, 2621, 2622, 3, 6, 3, 0, 2622, 2623, 6, 119, -1, 0, 2623, 2625, 1, 0, 0, 0, 2624, 2620, 1, 0, 0, 0, 2624, 2625, 1, 0, 0, 0, 2625, 2627, 1, 0, 0, 0, 2626, 2618, 1, 0, 0, 0, 2626, 2627, 1, 0, 0, 0, 2627, 2633, 1, 0, 0, 0, 2628, 2629, 3, 240, 120, 0, 2629, 2630, 6, 119, -1, 0, 2630, 2632, 1, 0, 0, 0, 2631, 2628, 1, 0, 0, 0, 2632, 2635, 1, 0, 0, 0, 2633, 2631, 1, 0, 0, 0, 2633, 2634, 1, 0, 0, 0, 2634, 2636, 1, 0, 0, 0, 2635, 2633, 1, 0, 0, 0, 2636, 2640, 5, 31, 0, 0, 2637, 2638, 5, 147, 0, 0, 2638, 2640, 5, 85, 0, 0, 2639, 2616, 1, 0, 0, 0, 2639, 2637, 1, 0, 0, 0, 2640, 239, 1, 0, 0, 0, 2641, 2642, 5, 148, 0, 0, 2642, 2684, 6, 120, -1, 0, 2643, 2644, 5, 224, 0, 0, 2644, 2684, 6, 120, -1, 0, 2645, 2646, 5, 57, 0, 0, 2646, 2684, 6, 120, -1, 0, 2647, 2648, 5, 58, 0, 0, 2648, 2684, 6, 120, -1, 0, 2649, 2650, 5, 149, 0, 0, 2650, 2684, 6, 120, -1, 0, 2651, 2652, 5, 150, 0, 0, 2652, 2684, 6, 120, -1, 0, 2653, 2654, 5, 248, 0, 0, 2654, 2684, 6, 120, -1, 0, 2655, 2656, 5, 249, 0, 0, 2656, 2684, 6, 120, -1, 0, 2657, 2658, 5, 250, 0, 0, 2658, 2684, 6, 120, -1, 0, 2659, 2660, 5, 251, 0, 0, 2660, 2684, 6, 120, -1, 0, 2661, 2662, 5, 151, 0, 0, 2662, 2663, 5, 75, 0, 0, 2663, 2664, 5, 152, 0, 0, 2664, 2684, 6, 120, -1, 0, 2665, 2666, 5, 151, 0, 0, 2666, 2667, 5, 75, 0, 0, 2667, 2668, 5, 153, 0, 0, 2668, 2684, 6, 120, -1, 0, 2669, 2670, 5, 154, 0, 0, 2670, 2671, 5, 75, 0, 0, 2671, 2672, 5, 152, 0, 0, 2672, 2684, 6, 120, -1, 0, 2673, 2674, 5, 154, 0, 0, 2674, 2675, 5, 75, 0, 0, 2675, 2676, 5, 153, 0, 0, 2676, 2684, 6, 120, -1, 0, 2677, 2678, 5, 70, 0, 0, 2678, 2679, 5, 30, 0, 0, 2679, 2680, 3, 32, 16, 0, 2680, 2681, 5, 31, 0, 0, 2681, 2682, 6, 120, -1, 0, 2682, 2684, 1, 0, 0, 0, 2683, 2641, 1, 0, 0, 0, 2683, 2643, 1, 0, 0, 0, 2683, 2645, 1, 0, 0, 0, 2683, 2647, 1, 0, 0, 0, 2683, 2649, 1, 0, 0, 0, 2683, 2651, 1, 0, 0, 0, 2683, 2653, 1, 0, 0, 0, 2683, 2655, 1, 0, 0, 0, 2683, 2657, 1, 0, 0, 0, 2683, 2659, 1, 0, 0, 0, 2683, 2661, 1, 0, 0, 0, 2683, 2665, 1, 0, 0, 0, 2683, 2669, 1, 0, 0, 0, 2683, 2673, 1, 0, 0, 0, 2683, 2677, 1, 0, 0, 0, 2684, 241, 1, 0, 0, 0, 2685, 2686, 5, 116, 0, 0, 2686, 2693, 6, 121, -1, 0, 2687, 2688, 5, 155, 0, 0, 2688, 2693, 6, 121, -1, 0, 2689, 2690, 3, 2, 1, 0, 2690, 2691, 6, 121, -1, 0, 2691, 2693, 1, 0, 0, 0, 2692, 2685, 1, 0, 0, 0, 2692, 2687, 1, 0, 0, 0, 2692, 2689, 1, 0, 0, 0, 2693, 243, 1, 0, 0, 0, 2694, 2695, 5, 1, 0, 0, 2695, 2733, 6, 122, -1, 0, 2696, 2697, 5, 2, 0, 0, 2697, 2733, 6, 122, -1, 0, 2698, 2699, 5, 156, 0, 0, 2699, 2733, 6, 122, -1, 0, 2700, 2701, 5, 3, 0, 0, 2701, 2733, 6, 122, -1, 0, 2702, 2703, 5, 4, 0, 0, 2703, 2733, 6, 122, -1, 0, 2704, 2705, 5, 247, 0, 0, 2705, 2733, 6, 122, -1, 0, 2706, 2707, 5, 5, 0, 0, 2707, 2733, 6, 122, -1, 0, 2708, 2709, 5, 6, 0, 0, 2709, 2733, 6, 122, -1, 0, 2710, 2711, 5, 7, 0, 0, 2711, 2733, 6, 122, -1, 0, 2712, 2713, 5, 8, 0, 0, 2713, 2733, 6, 122, -1, 0, 2714, 2715, 5, 9, 0, 0, 2715, 2733, 6, 122, -1, 0, 2716, 2717, 5, 10, 0, 0, 2717, 2733, 6, 122, -1, 0, 2718, 2719, 5, 11, 0, 0, 2719, 2733, 6, 122, -1, 0, 2720, 2721, 5, 12, 0, 0, 2721, 2733, 6, 122, -1, 0, 2722, 2723, 5, 13, 0, 0, 2723, 2733, 6, 122, -1, 0, 2724, 2725, 5, 14, 0, 0, 2725, 2733, 6, 122, -1, 0, 2726, 2727, 5, 70, 0, 0, 2727, 2728, 5, 30, 0, 0, 2728, 2729, 3, 32, 16, 0, 2729, 2730, 5, 31, 0, 0, 2730, 2731, 6, 122, -1, 0, 2731, 2733, 1, 0, 0, 0, 2732, 2694, 1, 0, 0, 0, 2732, 2696, 1, 0, 0, 0, 2732, 2698, 1, 0, 0, 0, 2732, 2700, 1, 0, 0, 0, 2732, 2702, 1, 0, 0, 0, 2732, 2704, 1, 0, 0, 0, 2732, 2706, 1, 0, 0, 0, 2732, 2708, 1, 0, 0, 0, 2732, 2710, 1, 0, 0, 0, 2732, 2712, 1, 0, 0, 0, 2732, 2714, 1, 0, 0, 0, 2732, 2716, 1, 0, 0, 0, 2732, 2718, 1, 0, 0, 0, 2732, 2720, 1, 0, 0, 0, 2732, 2722, 1, 0, 0, 0, 2732, 2724, 1, 0, 0, 0, 2732, 2726, 1, 0, 0, 0, 2733, 245, 1, 0, 0, 0, 2734, 2736, 3, 248, 124, 0, 2735, 2734, 1, 0, 0, 0, 2736, 2739, 1, 0, 0, 0, 2737, 2735, 1, 0, 0, 0, 2737, 2738, 1, 0, 0, 0, 2738, 247, 1, 0, 0, 0, 2739, 2737, 1, 0, 0, 0, 2740, 2778, 3, 100, 50, 0, 2741, 2742, 5, 296, 0, 0, 2742, 2743, 3, 32, 16, 0, 2743, 2744, 6, 124, -1, 0, 2744, 2778, 1, 0, 0, 0, 2745, 2778, 3, 266, 133, 0, 2746, 2747, 5, 297, 0, 0, 2747, 2748, 3, 32, 16, 0, 2748, 2749, 6, 124, -1, 0, 2749, 2778, 1, 0, 0, 0, 2750, 2751, 5, 298, 0, 0, 2751, 2778, 6, 124, -1, 0, 2752, 2753, 5, 299, 0, 0, 2753, 2778, 6, 124, -1, 0, 2754, 2778, 3, 260, 130, 0, 2755, 2778, 3, 264, 132, 0, 2756, 2778, 3, 250, 125, 0, 2757, 2758, 3, 284, 142, 0, 2758, 2759, 6, 124, -1, 0, 2759, 2778, 1, 0, 0, 0, 2760, 2761, 3, 152, 76, 0, 2761, 2762, 6, 124, -1, 0, 2762, 2778, 1, 0, 0, 0, 2763, 2764, 3, 88, 44, 0, 2764, 2765, 6, 124, -1, 0, 2765, 2778, 1, 0, 0, 0, 2766, 2767, 3, 26, 13, 0, 2767, 2768, 6, 124, -1, 0, 2768, 2778, 1, 0, 0, 0, 2769, 2770, 3, 262, 131, 0, 2770, 2771, 6, 124, -1, 0, 2771, 2778, 1, 0, 0, 0, 2772, 2778, 3, 40, 20, 0, 2773, 2778, 3, 252, 126, 0, 2774, 2778, 3, 254, 127, 0, 2775, 2778, 3, 256, 128, 0, 2776, 2778, 3, 258, 129, 0, 2777, 2740, 1, 0, 0, 0, 2777, 2741, 1, 0, 0, 0, 2777, 2745, 1, 0, 0, 0, 2777, 2746, 1, 0, 0, 0, 2777, 2750, 1, 0, 0, 0, 2777, 2752, 1, 0, 0, 0, 2777, 2754, 1, 0, 0, 0, 2777, 2755, 1, 0, 0, 0, 2777, 2756, 1, 0, 0, 0, 2777, 2757, 1, 0, 0, 0, 2777, 2760, 1, 0, 0, 0, 2777, 2763, 1, 0, 0, 0, 2777, 2766, 1, 0, 0, 0, 2777, 2769, 1, 0, 0, 0, 2777, 2772, 1, 0, 0, 0, 2777, 2773, 1, 0, 0, 0, 2777, 2774, 1, 0, 0, 0, 2777, 2775, 1, 0, 0, 0, 2777, 2776, 1, 0, 0, 0, 2778, 249, 1, 0, 0, 0, 2779, 2781, 5, 300, 0, 0, 2780, 2782, 5, 157, 0, 0, 2781, 2780, 1, 0, 0, 0, 2781, 2782, 1, 0, 0, 0, 2782, 2783, 1, 0, 0, 0, 2783, 2784, 3, 112, 56, 0, 2784, 251, 1, 0, 0, 0, 2785, 2786, 5, 301, 0, 0, 2786, 2787, 5, 42, 0, 0, 2787, 2788, 3, 32, 16, 0, 2788, 2791, 5, 43, 0, 0, 2789, 2790, 5, 34, 0, 0, 2790, 2792, 3, 0, 0, 0, 2791, 2789, 1, 0, 0, 0, 2791, 2792, 1, 0, 0, 0, 2792, 253, 1, 0, 0, 0, 2793, 2794, 5, 303, 0, 0, 2794, 2795, 3, 32, 16, 0, 2795, 2796, 5, 75, 0, 0, 2796, 2797, 3, 32, 16, 0, 2797, 255, 1, 0, 0, 0, 2798, 2799, 5, 302, 0, 0, 2799, 2800, 3, 124, 62, 0, 2800, 2801, 5, 176, 0, 0, 2801, 2802, 3, 242, 121, 0, 2802, 2814, 1, 0, 0, 0, 2803, 2804, 5, 302, 0, 0, 2804, 2805, 5, 226, 0, 0, 2805, 2806, 3, 170, 85, 0, 2806, 2807, 3, 138, 69, 0, 2807, 2808, 3, 124, 62, 0, 2808, 2809, 5, 176, 0, 0, 2809, 2810, 3, 242, 121, 0, 2810, 2811, 3, 194, 97, 0, 2811, 2812, 3, 112, 56, 0, 2812, 2814, 1, 0, 0, 0, 2813, 2798, 1, 0, 0, 0, 2813, 2803, 1, 0, 0, 0, 2814, 257, 1, 0, 0, 0, 2815, 2816, 5, 255, 0, 0, 2816, 2817, 5, 196, 0, 0, 2817, 2818, 5, 42, 0, 0, 2818, 2819, 3, 32, 16, 0, 2819, 2825, 5, 43, 0, 0, 2820, 2821, 3, 330, 165, 0, 2821, 2822, 6, 129, -1, 0, 2822, 2824, 1, 0, 0, 0, 2823, 2820, 1, 0, 0, 0, 2824, 2827, 1, 0, 0, 0, 2825, 2823, 1, 0, 0, 0, 2825, 2826, 1, 0, 0, 0, 2826, 2881, 1, 0, 0, 0, 2827, 2825, 1, 0, 0, 0, 2828, 2829, 5, 255, 0, 0, 2829, 2830, 5, 196, 0, 0, 2830, 2836, 3, 2, 1, 0, 2831, 2832, 3, 330, 165, 0, 2832, 2833, 6, 129, -1, 0, 2833, 2835, 1, 0, 0, 0, 2834, 2831, 1, 0, 0, 0, 2835, 2838, 1, 0, 0, 0, 2836, 2834, 1, 0, 0, 0, 2836, 2837, 1, 0, 0, 0, 2837, 2881, 1, 0, 0, 0, 2838, 2836, 1, 0, 0, 0, 2839, 2840, 5, 255, 0, 0, 2840, 2841, 5, 256, 0, 0, 2841, 2842, 5, 42, 0, 0, 2842, 2843, 3, 32, 16, 0, 2843, 2844, 5, 43, 0, 0, 2844, 2845, 5, 28, 0, 0, 2845, 2851, 3, 124, 62, 0, 2846, 2847, 3, 330, 165, 0, 2847, 2848, 6, 129, -1, 0, 2848, 2850, 1, 0, 0, 0, 2849, 2846, 1, 0, 0, 0, 2850, 2853, 1, 0, 0, 0, 2851, 2849, 1, 0, 0, 0, 2851, 2852, 1, 0, 0, 0, 2852, 2881, 1, 0, 0, 0, 2853, 2851, 1, 0, 0, 0, 2854, 2855, 5, 255, 0, 0, 2855, 2856, 5, 256, 0, 0, 2856, 2857, 3, 2, 1, 0, 2857, 2858, 5, 28, 0, 0, 2858, 2864, 3, 124, 62, 0, 2859, 2860, 3, 330, 165, 0, 2860, 2861, 6, 129, -1, 0, 2861, 2863, 1, 0, 0, 0, 2862, 2859, 1, 0, 0, 0, 2863, 2866, 1, 0, 0, 0, 2864, 2862, 1, 0, 0, 0, 2864, 2865, 1, 0, 0, 0, 2865, 2881, 1, 0, 0, 0, 2866, 2864, 1, 0, 0, 0, 2867, 2868, 5, 255, 0, 0, 2868, 2869, 5, 42, 0, 0, 2869, 2870, 3, 32, 16, 0, 2870, 2871, 5, 43, 0, 0, 2871, 2877, 3, 206, 103, 0, 2872, 2873, 3, 330, 165, 0, 2873, 2874, 6, 129, -1, 0, 2874, 2876, 1, 0, 0, 0, 2875, 2872, 1, 0, 0, 0, 2876, 2879, 1, 0, 0, 0, 2877, 2875, 1, 0, 0, 0, 2877, 2878, 1, 0, 0, 0, 2878, 2881, 1, 0, 0, 0, 2879, 2877, 1, 0, 0, 0, 2880, 2815, 1, 0, 0, 0, 2880, 2828, 1, 0, 0, 0, 2880, 2839, 1, 0, 0, 0, 2880, 2854, 1, 0, 0, 0, 2880, 2867, 1, 0, 0, 0, 2881, 259, 1, 0, 0, 0, 2882, 2883, 3, 0, 0, 0, 2883, 2884, 5, 75, 0, 0, 2884, 2885, 6, 130, -1, 0, 2885, 261, 1, 0, 0, 0, 2886, 2887, 3, 44, 22, 0, 2887, 2888, 6, 131, -1, 0, 2888, 2893, 1, 0, 0, 0, 2889, 2890, 3, 46, 23, 0, 2890, 2891, 6, 131, -1, 0, 2891, 2893, 1, 0, 0, 0, 2892, 2886, 1, 0, 0, 0, 2892, 2889, 1, 0, 0, 0, 2893, 263, 1, 0, 0, 0, 2894, 2895, 5, 17, 0, 0, 2895, 2896, 3, 246, 123, 0, 2896, 2897, 5, 18, 0, 0, 2897, 265, 1, 0, 0, 0, 2898, 2899, 3, 270, 135, 0, 2899, 2900, 3, 268, 134, 0, 2900, 267, 1, 0, 0, 0, 2901, 2902, 3, 272, 136, 0, 2902, 2903, 6, 134, -1, 0, 2903, 2905, 1, 0, 0, 0, 2904, 2901, 1, 0, 0, 0, 2905, 2906, 1, 0, 0, 0, 2906, 2904, 1, 0, 0, 0, 2906, 2907, 1, 0, 0, 0, 2907, 269, 1, 0, 0, 0, 2908, 2909, 5, 158, 0, 0, 2909, 2910, 3, 264, 132, 0, 2910, 2911, 6, 135, -1, 0, 2911, 2925, 1, 0, 0, 0, 2912, 2913, 5, 158, 0, 0, 2913, 2914, 3, 0, 0, 0, 2914, 2915, 5, 159, 0, 0, 2915, 2916, 3, 0, 0, 0, 2916, 2917, 6, 135, -1, 0, 2917, 2925, 1, 0, 0, 0, 2918, 2919, 5, 158, 0, 0, 2919, 2920, 3, 32, 16, 0, 2920, 2921, 5, 159, 0, 0, 2921, 2922, 3, 32, 16, 0, 2922, 2923, 6, 135, -1, 0, 2923, 2925, 1, 0, 0, 0, 2924, 2908, 1, 0, 0, 0, 2924, 2912, 1, 0, 0, 0, 2924, 2918, 1, 0, 0, 0, 2925, 271, 1, 0, 0, 0, 2926, 2927, 3, 276, 138, 0, 2927, 2928, 3, 282, 141, 0, 2928, 2929, 6, 136, -1, 0, 2929, 2943, 1, 0, 0, 0, 2930, 2931, 3, 274, 137, 0, 2931, 2932, 3, 282, 141, 0, 2932, 2933, 6, 136, -1, 0, 2933, 2943, 1, 0, 0, 0, 2934, 2935, 3, 278, 139, 0, 2935, 2936, 3, 282, 141, 0, 2936, 2937, 6, 136, -1, 0, 2937, 2943, 1, 0, 0, 0, 2938, 2939, 3, 280, 140, 0, 2939, 2940, 3, 282, 141, 0, 2940, 2941, 6, 136, -1, 0, 2941, 2943, 1, 0, 0, 0, 2942, 2926, 1, 0, 0, 0, 2942, 2930, 1, 0, 0, 0, 2942, 2934, 1, 0, 0, 0, 2942, 2938, 1, 0, 0, 0, 2943, 273, 1, 0, 0, 0, 2944, 2945, 5, 160, 0, 0, 2945, 2946, 3, 264, 132, 0, 2946, 2947, 6, 137, -1, 0, 2947, 2957, 1, 0, 0, 0, 2948, 2949, 5, 160, 0, 0, 2949, 2950, 3, 0, 0, 0, 2950, 2951, 6, 137, -1, 0, 2951, 2957, 1, 0, 0, 0, 2952, 2953, 5, 160, 0, 0, 2953, 2954, 3, 32, 16, 0, 2954, 2955, 6, 137, -1, 0, 2955, 2957, 1, 0, 0, 0, 2956, 2944, 1, 0, 0, 0, 2956, 2948, 1, 0, 0, 0, 2956, 2952, 1, 0, 0, 0, 2957, 275, 1, 0, 0, 0, 2958, 2959, 5, 161, 0, 0, 2959, 2960, 3, 124, 62, 0, 2960, 277, 1, 0, 0, 0, 2961, 2962, 5, 162, 0, 0, 2962, 279, 1, 0, 0, 0, 2963, 2964, 5, 163, 0, 0, 2964, 281, 1, 0, 0, 0, 2965, 2966, 3, 264, 132, 0, 2966, 2967, 6, 141, -1, 0, 2967, 2981, 1, 0, 0, 0, 2968, 2969, 5, 164, 0, 0, 2969, 2970, 3, 0, 0, 0, 2970, 2971, 5, 159, 0, 0, 2971, 2972, 3, 0, 0, 0, 2972, 2973, 6, 141, -1, 0, 2973, 2981, 1, 0, 0, 0, 2974, 2975, 5, 164, 0, 0, 2975, 2976, 3, 32, 16, 0, 2976, 2977, 5, 159, 0, 0, 2977, 2978, 3, 32, 16, 0, 2978, 2979, 6, 141, -1, 0, 2979, 2981, 1, 0, 0, 0, 2980, 2965, 1, 0, 0, 0, 2980, 2968, 1, 0, 0, 0, 2980, 2974, 1, 0, 0, 0, 2981, 283, 1, 0, 0, 0, 2982, 2983, 3, 286, 143, 0, 2983, 2984, 3, 290, 145, 0, 2984, 285, 1, 0, 0, 0, 2985, 2986, 5, 165, 0, 0, 2986, 2987, 3, 288, 144, 0, 2987, 2988, 3, 0, 0, 0, 2988, 2989, 5, 36, 0, 0, 2989, 2993, 1, 0, 0, 0, 2990, 2991, 5, 165, 0, 0, 2991, 2993, 3, 288, 144, 0, 2992, 2985, 1, 0, 0, 0, 2992, 2990, 1, 0, 0, 0, 2993, 287, 1, 0, 0, 0, 2994, 2998, 1, 0, 0, 0, 2995, 2998, 5, 166, 0, 0, 2996, 2998, 5, 2, 0, 0, 2997, 2994, 1, 0, 0, 0, 2997, 2995, 1, 0, 0, 0, 2997, 2996, 1, 0, 0, 0, 2998, 289, 1, 0, 0, 0, 2999, 3000, 5, 17, 0, 0, 3000, 3001, 3, 292, 146, 0, 3001, 3002, 5, 18, 0, 0, 3002, 3009, 1, 0, 0, 0, 3003, 3005, 3, 296, 148, 0, 3004, 3003, 1, 0, 0, 0, 3005, 3006, 1, 0, 0, 0, 3006, 3004, 1, 0, 0, 0, 3006, 3007, 1, 0, 0, 0, 3007, 3009, 1, 0, 0, 0, 3008, 2999, 1, 0, 0, 0, 3008, 3004, 1, 0, 0, 0, 3009, 291, 1, 0, 0, 0, 3010, 3011, 3, 296, 148, 0, 3011, 3012, 5, 28, 0, 0, 3012, 3014, 1, 0, 0, 0, 3013, 3010, 1, 0, 0, 0, 3014, 3017, 1, 0, 0, 0, 3015, 3013, 1, 0, 0, 0, 3015, 3016, 1, 0, 0, 0, 3016, 3018, 1, 0, 0, 0, 3017, 3015, 1, 0, 0, 0, 3018, 3019, 3, 296, 148, 0, 3019, 293, 1, 0, 0, 0, 3020, 3026, 1, 0, 0, 0, 3021, 3022, 5, 42, 0, 0, 3022, 3023, 3, 32, 16, 0, 3023, 3024, 5, 43, 0, 0, 3024, 3026, 1, 0, 0, 0, 3025, 3020, 1, 0, 0, 0, 3025, 3021, 1, 0, 0, 0, 3026, 295, 1, 0, 0, 0, 3027, 3028, 5, 181, 0, 0, 3028, 3029, 5, 262, 0, 0, 3029, 3030, 5, 30, 0, 0, 3030, 3031, 3, 6, 3, 0, 3031, 3032, 5, 31, 0, 0, 3032, 3094, 1, 0, 0, 0, 3033, 3034, 5, 260, 0, 0, 3034, 3035, 5, 30, 0, 0, 3035, 3036, 3, 0, 0, 0, 3036, 3037, 5, 31, 0, 0, 3037, 3094, 1, 0, 0, 0, 3038, 3039, 5, 260, 0, 0, 3039, 3094, 3, 0, 0, 0, 3040, 3041, 5, 84, 0, 0, 3041, 3042, 5, 30, 0, 0, 3042, 3043, 3, 300, 150, 0, 3043, 3044, 5, 31, 0, 0, 3044, 3094, 1, 0, 0, 0, 3045, 3046, 5, 188, 0, 0, 3046, 3047, 5, 30, 0, 0, 3047, 3048, 3, 36, 18, 0, 3048, 3049, 5, 31, 0, 0, 3049, 3050, 3, 294, 147, 0, 3050, 3094, 1, 0, 0, 0, 3051, 3052, 5, 189, 0, 0, 3052, 3053, 5, 30, 0, 0, 3053, 3054, 3, 36, 18, 0, 3054, 3055, 5, 31, 0, 0, 3055, 3056, 3, 294, 147, 0, 3056, 3094, 1, 0, 0, 0, 3057, 3058, 5, 187, 0, 0, 3058, 3059, 5, 30, 0, 0, 3059, 3060, 3, 34, 17, 0, 3060, 3061, 5, 31, 0, 0, 3061, 3062, 3, 294, 147, 0, 3062, 3094, 1, 0, 0, 0, 3063, 3064, 5, 186, 0, 0, 3064, 3065, 5, 30, 0, 0, 3065, 3066, 3, 32, 16, 0, 3066, 3067, 5, 31, 0, 0, 3067, 3068, 3, 294, 147, 0, 3068, 3094, 1, 0, 0, 0, 3069, 3070, 5, 185, 0, 0, 3070, 3071, 5, 30, 0, 0, 3071, 3072, 3, 32, 16, 0, 3072, 3073, 5, 31, 0, 0, 3073, 3074, 3, 294, 147, 0, 3074, 3094, 1, 0, 0, 0, 3075, 3076, 5, 184, 0, 0, 3076, 3077, 5, 30, 0, 0, 3077, 3078, 3, 32, 16, 0, 3078, 3079, 5, 31, 0, 0, 3079, 3080, 3, 294, 147, 0, 3080, 3094, 1, 0, 0, 0, 3081, 3082, 5, 188, 0, 0, 3082, 3094, 3, 294, 147, 0, 3083, 3084, 5, 189, 0, 0, 3084, 3094, 3, 294, 147, 0, 3085, 3086, 5, 187, 0, 0, 3086, 3094, 3, 294, 147, 0, 3087, 3088, 5, 186, 0, 0, 3088, 3094, 3, 294, 147, 0, 3089, 3090, 5, 185, 0, 0, 3090, 3094, 3, 294, 147, 0, 3091, 3092, 5, 184, 0, 0, 3092, 3094, 3, 294, 147, 0, 3093, 3027, 1, 0, 0, 0, 3093, 3033, 1, 0, 0, 0, 3093, 3038, 1, 0, 0, 0, 3093, 3040, 1, 0, 0, 0, 3093, 3045, 1, 0, 0, 0, 3093, 3051, 1, 0, 0, 0, 3093, 3057, 1, 0, 0, 0, 3093, 3063, 1, 0, 0, 0, 3093, 3069, 1, 0, 0, 0, 3093, 3075, 1, 0, 0, 0, 3093, 3081, 1, 0, 0, 0, 3093, 3083, 1, 0, 0, 0, 3093, 3085, 1, 0, 0, 0, 3093, 3087, 1, 0, 0, 0, 3093, 3089, 1, 0, 0, 0, 3093, 3091, 1, 0, 0, 0, 3094, 297, 1, 0, 0, 0, 3095, 3096, 5, 188, 0, 0, 3096, 3097, 5, 30, 0, 0, 3097, 3098, 3, 36, 18, 0, 3098, 3099, 5, 31, 0, 0, 3099, 3100, 6, 149, -1, 0, 3100, 3186, 1, 0, 0, 0, 3101, 3102, 5, 189, 0, 0, 3102, 3103, 5, 30, 0, 0, 3103, 3104, 3, 36, 18, 0, 3104, 3105, 5, 31, 0, 0, 3105, 3106, 6, 149, -1, 0, 3106, 3186, 1, 0, 0, 0, 3107, 3108, 5, 188, 0, 0, 3108, 3109, 5, 30, 0, 0, 3109, 3110, 3, 32, 16, 0, 3110, 3111, 5, 31, 0, 0, 3111, 3112, 6, 149, -1, 0, 3112, 3186, 1, 0, 0, 0, 3113, 3114, 5, 189, 0, 0, 3114, 3115, 5, 30, 0, 0, 3115, 3116, 3, 34, 17, 0, 3116, 3117, 5, 31, 0, 0, 3117, 3118, 6, 149, -1, 0, 3118, 3186, 1, 0, 0, 0, 3119, 3120, 5, 187, 0, 0, 3120, 3121, 5, 30, 0, 0, 3121, 3122, 3, 34, 17, 0, 3122, 3123, 5, 31, 0, 0, 3123, 3124, 6, 149, -1, 0, 3124, 3186, 1, 0, 0, 0, 3125, 3126, 5, 186, 0, 0, 3126, 3127, 5, 30, 0, 0, 3127, 3128, 3, 32, 16, 0, 3128, 3129, 5, 31, 0, 0, 3129, 3130, 6, 149, -1, 0, 3130, 3186, 1, 0, 0, 0, 3131, 3132, 5, 185, 0, 0, 3132, 3133, 5, 30, 0, 0, 3133, 3134, 3, 32, 16, 0, 3134, 3135, 5, 31, 0, 0, 3135, 3136, 6, 149, -1, 0, 3136, 3186, 1, 0, 0, 0, 3137, 3138, 5, 184, 0, 0, 3138, 3139, 5, 30, 0, 0, 3139, 3140, 3, 32, 16, 0, 3140, 3141, 5, 31, 0, 0, 3141, 3142, 6, 149, -1, 0, 3142, 3186, 1, 0, 0, 0, 3143, 3144, 5, 193, 0, 0, 3144, 3145, 5, 30, 0, 0, 3145, 3146, 3, 34, 17, 0, 3146, 3147, 5, 31, 0, 0, 3147, 3148, 6, 149, -1, 0, 3148, 3186, 1, 0, 0, 0, 3149, 3150, 5, 192, 0, 0, 3150, 3151, 5, 30, 0, 0, 3151, 3152, 3, 32, 16, 0, 3152, 3153, 5, 31, 0, 0, 3153, 3154, 6, 149, -1, 0, 3154, 3186, 1, 0, 0, 0, 3155, 3156, 5, 191, 0, 0, 3156, 3157, 5, 30, 0, 0, 3157, 3158, 3, 32, 16, 0, 3158, 3159, 5, 31, 0, 0, 3159, 3160, 6, 149, -1, 0, 3160, 3186, 1, 0, 0, 0, 3161, 3162, 5, 190, 0, 0, 3162, 3163, 5, 30, 0, 0, 3163, 3164, 3, 32, 16, 0, 3164, 3165, 5, 31, 0, 0, 3165, 3166, 6, 149, -1, 0, 3166, 3186, 1, 0, 0, 0, 3167, 3168, 5, 181, 0, 0, 3168, 3169, 5, 30, 0, 0, 3169, 3170, 3, 32, 16, 0, 3170, 3171, 5, 31, 0, 0, 3171, 3172, 6, 149, -1, 0, 3172, 3186, 1, 0, 0, 0, 3173, 3174, 5, 183, 0, 0, 3174, 3175, 5, 30, 0, 0, 3175, 3176, 3, 162, 81, 0, 3176, 3177, 5, 31, 0, 0, 3177, 3178, 6, 149, -1, 0, 3178, 3186, 1, 0, 0, 0, 3179, 3180, 5, 84, 0, 0, 3180, 3181, 5, 30, 0, 0, 3181, 3182, 3, 300, 150, 0, 3182, 3183, 5, 31, 0, 0, 3183, 3184, 6, 149, -1, 0, 3184, 3186, 1, 0, 0, 0, 3185, 3095, 1, 0, 0, 0, 3185, 3101, 1, 0, 0, 0, 3185, 3107, 1, 0, 0, 0, 3185, 3113, 1, 0, 0, 0, 3185, 3119, 1, 0, 0, 0, 3185, 3125, 1, 0, 0, 0, 3185, 3131, 1, 0, 0, 0, 3185, 3137, 1, 0, 0, 0, 3185, 3143, 1, 0, 0, 0, 3185, 3149, 1, 0, 0, 0, 3185, 3155, 1, 0, 0, 0, 3185, 3161, 1, 0, 0, 0, 3185, 3167, 1, 0, 0, 0, 3185, 3173, 1, 0, 0, 0, 3185, 3179, 1, 0, 0, 0, 3186, 299, 1, 0, 0, 0, 3187, 3188, 3, 302, 151, 0, 3188, 3189, 6, 150, -1, 0, 3189, 3191, 1, 0, 0, 0, 3190, 3187, 1, 0, 0, 0, 3191, 3194, 1, 0, 0, 0, 3192, 3190, 1, 0, 0, 0, 3192, 3193, 1, 0, 0, 0, 3193, 301, 1, 0, 0, 0, 3194, 3192, 1, 0, 0, 0, 3195, 3196, 7, 10, 0, 0, 3196, 303, 1, 0, 0, 0, 3197, 3198, 3, 298, 149, 0, 3198, 3199, 6, 152, -1, 0, 3199, 3206, 1, 0, 0, 0, 3200, 3201, 3, 6, 3, 0, 3201, 3202, 6, 152, -1, 0, 3202, 3206, 1, 0, 0, 0, 3203, 3204, 5, 179, 0, 0, 3204, 3206, 6, 152, -1, 0, 3205, 3197, 1, 0, 0, 0, 3205, 3200, 1, 0, 0, 0, 3205, 3203, 1, 0, 0, 0, 3206, 305, 1, 0, 0, 0, 3207, 3208, 3, 298, 149, 0, 3208, 3209, 6, 153, -1, 0, 3209, 3379, 1, 0, 0, 0, 3210, 3211, 5, 182, 0, 0, 3211, 3212, 5, 30, 0, 0, 3212, 3213, 5, 179, 0, 0, 3213, 3214, 5, 31, 0, 0, 3214, 3379, 6, 153, -1, 0, 3215, 3216, 5, 182, 0, 0, 3216, 3217, 5, 30, 0, 0, 3217, 3218, 5, 264, 0, 0, 3218, 3219, 5, 31, 0, 0, 3219, 3379, 6, 153, -1, 0, 3220, 3221, 5, 196, 0, 0, 3221, 3222, 5, 30, 0, 0, 3222, 3223, 5, 39, 0, 0, 3223, 3224, 5, 264, 0, 0, 3224, 3225, 5, 31, 0, 0, 3225, 3379, 6, 153, -1, 0, 3226, 3227, 5, 196, 0, 0, 3227, 3228, 5, 30, 0, 0, 3228, 3229, 3, 116, 58, 0, 3229, 3230, 5, 31, 0, 0, 3230, 3231, 6, 153, -1, 0, 3231, 3379, 1, 0, 0, 0, 3232, 3233, 5, 196, 0, 0, 3233, 3234, 5, 30, 0, 0, 3234, 3235, 5, 179, 0, 0, 3235, 3236, 5, 31, 0, 0, 3236, 3379, 6, 153, -1, 0, 3237, 3238, 5, 197, 0, 0, 3238, 3239, 5, 30, 0, 0, 3239, 3240, 3, 306, 153, 0, 3240, 3241, 5, 31, 0, 0, 3241, 3242, 6, 153, -1, 0, 3242, 3379, 1, 0, 0, 0, 3243, 3244, 5, 188, 0, 0, 3244, 3245, 5, 42, 0, 0, 3245, 3246, 3, 32, 16, 0, 3246, 3247, 5, 43, 0, 0, 3247, 3248, 5, 30, 0, 0, 3248, 3249, 3, 308, 154, 0, 3249, 3250, 5, 31, 0, 0, 3250, 3251, 6, 153, -1, 0, 3251, 3379, 1, 0, 0, 0, 3252, 3253, 5, 189, 0, 0, 3253, 3254, 5, 42, 0, 0, 3254, 3255, 3, 32, 16, 0, 3255, 3256, 5, 43, 0, 0, 3256, 3257, 5, 30, 0, 0, 3257, 3258, 3, 310, 155, 0, 3258, 3259, 5, 31, 0, 0, 3259, 3260, 6, 153, -1, 0, 3260, 3379, 1, 0, 0, 0, 3261, 3262, 5, 187, 0, 0, 3262, 3263, 5, 42, 0, 0, 3263, 3264, 3, 32, 16, 0, 3264, 3265, 5, 43, 0, 0, 3265, 3266, 5, 30, 0, 0, 3266, 3267, 3, 312, 156, 0, 3267, 3268, 5, 31, 0, 0, 3268, 3269, 6, 153, -1, 0, 3269, 3379, 1, 0, 0, 0, 3270, 3271, 5, 186, 0, 0, 3271, 3272, 5, 42, 0, 0, 3272, 3273, 3, 32, 16, 0, 3273, 3274, 5, 43, 0, 0, 3274, 3275, 5, 30, 0, 0, 3275, 3276, 3, 314, 157, 0, 3276, 3277, 5, 31, 0, 0, 3277, 3278, 6, 153, -1, 0, 3278, 3379, 1, 0, 0, 0, 3279, 3280, 5, 185, 0, 0, 3280, 3281, 5, 42, 0, 0, 3281, 3282, 3, 32, 16, 0, 3282, 3283, 5, 43, 0, 0, 3283, 3284, 5, 30, 0, 0, 3284, 3285, 3, 316, 158, 0, 3285, 3286, 5, 31, 0, 0, 3286, 3287, 6, 153, -1, 0, 3287, 3379, 1, 0, 0, 0, 3288, 3289, 5, 184, 0, 0, 3289, 3290, 5, 42, 0, 0, 3290, 3291, 3, 32, 16, 0, 3291, 3292, 5, 43, 0, 0, 3292, 3293, 5, 30, 0, 0, 3293, 3294, 3, 318, 159, 0, 3294, 3295, 5, 31, 0, 0, 3295, 3296, 6, 153, -1, 0, 3296, 3379, 1, 0, 0, 0, 3297, 3298, 5, 193, 0, 0, 3298, 3299, 5, 42, 0, 0, 3299, 3300, 3, 32, 16, 0, 3300, 3301, 5, 43, 0, 0, 3301, 3302, 5, 30, 0, 0, 3302, 3303, 3, 312, 156, 0, 3303, 3304, 5, 31, 0, 0, 3304, 3305, 6, 153, -1, 0, 3305, 3379, 1, 0, 0, 0, 3306, 3307, 5, 192, 0, 0, 3307, 3308, 5, 42, 0, 0, 3308, 3309, 3, 32, 16, 0, 3309, 3310, 5, 43, 0, 0, 3310, 3311, 5, 30, 0, 0, 3311, 3312, 3, 314, 157, 0, 3312, 3313, 5, 31, 0, 0, 3313, 3314, 6, 153, -1, 0, 3314, 3379, 1, 0, 0, 0, 3315, 3316, 5, 191, 0, 0, 3316, 3317, 5, 42, 0, 0, 3317, 3318, 3, 32, 16, 0, 3318, 3319, 5, 43, 0, 0, 3319, 3320, 5, 30, 0, 0, 3320, 3321, 3, 316, 158, 0, 3321, 3322, 5, 31, 0, 0, 3322, 3323, 6, 153, -1, 0, 3323, 3379, 1, 0, 0, 0, 3324, 3325, 5, 190, 0, 0, 3325, 3326, 5, 42, 0, 0, 3326, 3327, 3, 32, 16, 0, 3327, 3328, 5, 43, 0, 0, 3328, 3329, 5, 30, 0, 0, 3329, 3330, 3, 318, 159, 0, 3330, 3331, 5, 31, 0, 0, 3331, 3332, 6, 153, -1, 0, 3332, 3379, 1, 0, 0, 0, 3333, 3334, 5, 181, 0, 0, 3334, 3335, 5, 42, 0, 0, 3335, 3336, 3, 32, 16, 0, 3336, 3337, 5, 43, 0, 0, 3337, 3338, 5, 30, 0, 0, 3338, 3339, 3, 316, 158, 0, 3339, 3340, 5, 31, 0, 0, 3340, 3341, 6, 153, -1, 0, 3341, 3379, 1, 0, 0, 0, 3342, 3343, 5, 183, 0, 0, 3343, 3344, 5, 42, 0, 0, 3344, 3345, 3, 32, 16, 0, 3345, 3346, 5, 43, 0, 0, 3346, 3347, 5, 30, 0, 0, 3347, 3348, 3, 320, 160, 0, 3348, 3349, 5, 31, 0, 0, 3349, 3350, 6, 153, -1, 0, 3350, 3379, 1, 0, 0, 0, 3351, 3352, 5, 182, 0, 0, 3352, 3353, 5, 42, 0, 0, 3353, 3354, 3, 32, 16, 0, 3354, 3355, 5, 43, 0, 0, 3355, 3356, 5, 30, 0, 0, 3356, 3357, 3, 322, 161, 0, 3357, 3358, 5, 31, 0, 0, 3358, 3359, 6, 153, -1, 0, 3359, 3379, 1, 0, 0, 0, 3360, 3361, 5, 196, 0, 0, 3361, 3362, 5, 42, 0, 0, 3362, 3363, 3, 32, 16, 0, 3363, 3364, 5, 43, 0, 0, 3364, 3365, 5, 30, 0, 0, 3365, 3366, 3, 324, 162, 0, 3366, 3367, 5, 31, 0, 0, 3367, 3368, 6, 153, -1, 0, 3368, 3379, 1, 0, 0, 0, 3369, 3370, 5, 197, 0, 0, 3370, 3371, 5, 42, 0, 0, 3371, 3372, 3, 32, 16, 0, 3372, 3373, 5, 43, 0, 0, 3373, 3374, 5, 30, 0, 0, 3374, 3375, 3, 328, 164, 0, 3375, 3376, 5, 31, 0, 0, 3376, 3377, 6, 153, -1, 0, 3377, 3379, 1, 0, 0, 0, 3378, 3207, 1, 0, 0, 0, 3378, 3210, 1, 0, 0, 0, 3378, 3215, 1, 0, 0, 0, 3378, 3220, 1, 0, 0, 0, 3378, 3226, 1, 0, 0, 0, 3378, 3232, 1, 0, 0, 0, 3378, 3237, 1, 0, 0, 0, 3378, 3243, 1, 0, 0, 0, 3378, 3252, 1, 0, 0, 0, 3378, 3261, 1, 0, 0, 0, 3378, 3270, 1, 0, 0, 0, 3378, 3279, 1, 0, 0, 0, 3378, 3288, 1, 0, 0, 0, 3378, 3297, 1, 0, 0, 0, 3378, 3306, 1, 0, 0, 0, 3378, 3315, 1, 0, 0, 0, 3378, 3324, 1, 0, 0, 0, 3378, 3333, 1, 0, 0, 0, 3378, 3342, 1, 0, 0, 0, 3378, 3351, 1, 0, 0, 0, 3378, 3360, 1, 0, 0, 0, 3378, 3369, 1, 0, 0, 0, 3379, 307, 1, 0, 0, 0, 3380, 3381, 3, 36, 18, 0, 3381, 3382, 6, 154, -1, 0, 3382, 3387, 1, 0, 0, 0, 3383, 3384, 3, 32, 16, 0, 3384, 3385, 6, 154, -1, 0, 3385, 3387, 1, 0, 0, 0, 3386, 3380, 1, 0, 0, 0, 3386, 3383, 1, 0, 0, 0, 3387, 3390, 1, 0, 0, 0, 3388, 3386, 1, 0, 0, 0, 3388, 3389, 1, 0, 0, 0, 3389, 309, 1, 0, 0, 0, 3390, 3388, 1, 0, 0, 0, 3391, 3392, 3, 36, 18, 0, 3392, 3393, 6, 155, -1, 0, 3393, 3398, 1, 0, 0, 0, 3394, 3395, 3, 34, 17, 0, 3395, 3396, 6, 155, -1, 0, 3396, 3398, 1, 0, 0, 0, 3397, 3391, 1, 0, 0, 0, 3397, 3394, 1, 0, 0, 0, 3398, 3401, 1, 0, 0, 0, 3399, 3397, 1, 0, 0, 0, 3399, 3400, 1, 0, 0, 0, 3400, 311, 1, 0, 0, 0, 3401, 3399, 1, 0, 0, 0, 3402, 3403, 3, 34, 17, 0, 3403, 3404, 6, 156, -1, 0, 3404, 3406, 1, 0, 0, 0, 3405, 3402, 1, 0, 0, 0, 3406, 3409, 1, 0, 0, 0, 3407, 3405, 1, 0, 0, 0, 3407, 3408, 1, 0, 0, 0, 3408, 313, 1, 0, 0, 0, 3409, 3407, 1, 0, 0, 0, 3410, 3411, 3, 32, 16, 0, 3411, 3412, 6, 157, -1, 0, 3412, 3414, 1, 0, 0, 0, 3413, 3410, 1, 0, 0, 0, 3414, 3417, 1, 0, 0, 0, 3415, 3413, 1, 0, 0, 0, 3415, 3416, 1, 0, 0, 0, 3416, 315, 1, 0, 0, 0, 3417, 3415, 1, 0, 0, 0, 3418, 3419, 3, 32, 16, 0, 3419, 3420, 6, 158, -1, 0, 3420, 3422, 1, 0, 0, 0, 3421, 3418, 1, 0, 0, 0, 3422, 3425, 1, 0, 0, 0, 3423, 3421, 1, 0, 0, 0, 3423, 3424, 1, 0, 0, 0, 3424, 317, 1, 0, 0, 0, 3425, 3423, 1, 0, 0, 0, 3426, 3427, 3, 32, 16, 0, 3427, 3428, 6, 159, -1, 0, 3428, 3430, 1, 0, 0, 0, 3429, 3426, 1, 0, 0, 0, 3430, 3433, 1, 0, 0, 0, 3431, 3429, 1, 0, 0, 0, 3431, 3432, 1, 0, 0, 0, 3432, 319, 1, 0, 0, 0, 3433, 3431, 1, 0, 0, 0, 3434, 3435, 3, 162, 81, 0, 3435, 3436, 6, 160, -1, 0, 3436, 3438, 1, 0, 0, 0, 3437, 3434, 1, 0, 0, 0, 3438, 3441, 1, 0, 0, 0, 3439, 3437, 1, 0, 0, 0, 3439, 3440, 1, 0, 0, 0, 3440, 321, 1, 0, 0, 0, 3441, 3439, 1, 0, 0, 0, 3442, 3443, 5, 179, 0, 0, 3443, 3447, 6, 161, -1, 0, 3444, 3445, 5, 264, 0, 0, 3445, 3447, 6, 161, -1, 0, 3446, 3442, 1, 0, 0, 0, 3446, 3444, 1, 0, 0, 0, 3447, 3450, 1, 0, 0, 0, 3448, 3446, 1, 0, 0, 0, 3448, 3449, 1, 0, 0, 0, 3449, 323, 1, 0, 0, 0, 3450, 3448, 1, 0, 0, 0, 3451, 3452, 3, 326, 163, 0, 3452, 3453, 6, 162, -1, 0, 3453, 3455, 1, 0, 0, 0, 3454, 3451, 1, 0, 0, 0, 3455, 3458, 1, 0, 0, 0, 3456, 3454, 1, 0, 0, 0, 3456, 3457, 1, 0, 0, 0, 3457, 325, 1, 0, 0, 0, 3458, 3456, 1, 0, 0, 0, 3459, 3460, 5, 179, 0, 0, 3460, 3468, 6, 163, -1, 0, 3461, 3462, 5, 39, 0, 0, 3462, 3463, 5, 264, 0, 0, 3463, 3468, 6, 163, -1, 0, 3464, 3465, 3, 116, 58, 0, 3465, 3466, 6, 163, -1, 0, 3466, 3468, 1, 0, 0, 0, 3467, 3459, 1, 0, 0, 0, 3467, 3461, 1, 0, 0, 0, 3467, 3464, 1, 0, 0, 0, 3468, 327, 1, 0, 0, 0, 3469, 3470, 3, 306, 153, 0, 3470, 3471, 6, 164, -1, 0, 3471, 3473, 1, 0, 0, 0, 3472, 3469, 1, 0, 0, 0, 3473, 3476, 1, 0, 0, 0, 3474, 3472, 1, 0, 0, 0, 3474, 3475, 1, 0, 0, 0, 3475, 329, 1, 0, 0, 0, 3476, 3474, 1, 0, 0, 0, 3477, 3478, 3, 44, 22, 0, 3478, 3479, 6, 165, -1, 0, 3479, 3487, 1, 0, 0, 0, 3480, 3481, 3, 46, 23, 0, 3481, 3482, 6, 165, -1, 0, 3482, 3487, 1, 0, 0, 0, 3483, 3484, 3, 2, 1, 0, 3484, 3485, 6, 165, -1, 0, 3485, 3487, 1, 0, 0, 0, 3486, 3477, 1, 0, 0, 0, 3486, 3480, 1, 0, 0, 0, 3486, 3483, 1, 0, 0, 0, 3487, 331, 1, 0, 0, 0, 3488, 3489, 7, 11, 0, 0, 3489, 3490, 5, 36, 0, 0, 3490, 3491, 5, 30, 0, 0, 3491, 3492, 3, 300, 150, 0, 3492, 3493, 5, 31, 0, 0, 3493, 3514, 1, 0, 0, 0, 3494, 3495, 5, 169, 0, 0, 3495, 3496, 3, 38, 19, 0, 3496, 3497, 5, 75, 0, 0, 3497, 3498, 3, 38, 19, 0, 3498, 3499, 5, 75, 0, 0, 3499, 3500, 3, 38, 19, 0, 3500, 3501, 5, 75, 0, 0, 3501, 3502, 3, 38, 19, 0, 3502, 3514, 1, 0, 0, 0, 3503, 3504, 5, 170, 0, 0, 3504, 3514, 3, 6, 3, 0, 3505, 3506, 5, 170, 0, 0, 3506, 3507, 5, 36, 0, 0, 3507, 3508, 5, 30, 0, 0, 3508, 3509, 3, 300, 150, 0, 3509, 3510, 5, 31, 0, 0, 3510, 3514, 1, 0, 0, 0, 3511, 3514, 3, 330, 165, 0, 3512, 3514, 3, 40, 20, 0, 3513, 3488, 1, 0, 0, 0, 3513, 3494, 1, 0, 0, 0, 3513, 3503, 1, 0, 0, 0, 3513, 3505, 1, 0, 0, 0, 3513, 3511, 1, 0, 0, 0, 3513, 3512, 1, 0, 0, 0, 3514, 333, 1, 0, 0, 0, 3515, 3516, 3, 336, 168, 0, 3516, 3517, 5, 17, 0, 0, 3517, 3518, 3, 338, 169, 0, 3518, 3519, 5, 18, 0, 0, 3519, 335, 1, 0, 0, 0, 3520, 3521, 5, 25, 0, 0, 3521, 3522, 5, 40, 0, 0, 3522, 3523, 3, 98, 49, 0, 3523, 3524, 3, 2, 1, 0, 3524, 3533, 1, 0, 0, 0, 3525, 3526, 5, 25, 0, 0, 3526, 3527, 5, 40, 0, 0, 3527, 3528, 3, 98, 49, 0, 3528, 3529, 3, 2, 1, 0, 3529, 3530, 5, 34, 0, 0, 3530, 3531, 3, 2, 1, 0, 3531, 3533, 1, 0, 0, 0, 3532, 3520, 1, 0, 0, 0, 3532, 3525, 1, 0, 0, 0, 3533, 337, 1, 0, 0, 0, 3534, 3536, 3, 340, 170, 0, 3535, 3534, 1, 0, 0, 0, 3536, 3539, 1, 0, 0, 0, 3537, 3535, 1, 0, 0, 0, 3537, 3538, 1, 0, 0, 0, 3538, 339, 1, 0, 0, 0, 3539, 3537, 1, 0, 0, 0, 3540, 3541, 5, 180, 0, 0, 3541, 3542, 5, 36, 0, 0, 3542, 3543, 5, 30, 0, 0, 3543, 3544, 3, 300, 150, 0, 3544, 3545, 5, 31, 0, 0, 3545, 3555, 1, 0, 0, 0, 3546, 3555, 3, 332, 166, 0, 3547, 3548, 5, 171, 0, 0, 3548, 3549, 5, 36, 0, 0, 3549, 3550, 5, 30, 0, 0, 3550, 3551, 3, 300, 150, 0, 3551, 3552, 5, 31, 0, 0, 3552, 3555, 1, 0, 0, 0, 3553, 3555, 5, 55, 0, 0, 3554, 3540, 1, 0, 0, 0, 3554, 3546, 1, 0, 0, 0, 3554, 3547, 1, 0, 0, 0, 3554, 3553, 1, 0, 0, 0, 3555, 341, 1, 0, 0, 0, 3556, 3557, 3, 344, 172, 0, 3557, 3558, 5, 17, 0, 0, 3558, 3559, 3, 350, 175, 0, 3559, 3560, 5, 18, 0, 0, 3560, 343, 1, 0, 0, 0, 3561, 3562, 5, 50, 0, 0, 3562, 3566, 5, 40, 0, 0, 3563, 3565, 3, 348, 174, 0, 3564, 3563, 1, 0, 0, 0, 3565, 3568, 1, 0, 0, 0, 3566, 3564, 1, 0, 0, 0, 3566, 3567, 1, 0, 0, 0, 3567, 3569, 1, 0, 0, 0, 3568, 3566, 1, 0, 0, 0, 3569, 3570, 3, 2, 1, 0, 3570, 345, 1, 0, 0, 0, 3571, 3575, 5, 301, 0, 0, 3572, 3574, 3, 348, 174, 0, 3573, 3572, 1, 0, 0, 0, 3574, 3577, 1, 0, 0, 0, 3575, 3573, 1, 0, 0, 0, 3575, 3576, 1, 0, 0, 0, 3576, 3578, 1, 0, 0, 0, 3577, 3575, 1, 0, 0, 0, 3578, 3579, 3, 2, 1, 0, 3579, 347, 1, 0, 0, 0, 3580, 3596, 5, 52, 0, 0, 3581, 3596, 5, 51, 0, 0, 3582, 3596, 5, 172, 0, 0, 3583, 3584, 5, 62, 0, 0, 3584, 3596, 5, 51, 0, 0, 3585, 3586, 5, 62, 0, 0, 3586, 3596, 5, 52, 0, 0, 3587, 3588, 5, 62, 0, 0, 3588, 3596, 5, 63, 0, 0, 3589, 3590, 5, 62, 0, 0, 3590, 3596, 5, 64, 0, 0, 3591, 3592, 5, 62, 0, 0, 3592, 3596, 5, 65, 0, 0, 3593, 3594, 5, 62, 0, 0, 3594, 3596, 5, 66, 0, 0, 3595, 3580, 1, 0, 0, 0, 3595, 3581, 1, 0, 0, 0, 3595, 3582, 1, 0, 0, 0, 3595, 3583, 1, 0, 0, 0, 3595, 3585, 1, 0, 0, 0, 3595, 3587, 1, 0, 0, 0, 3595, 3589, 1, 0, 0, 0, 3595, 3591, 1, 0, 0, 0, 3595, 3593, 1, 0, 0, 0, 3596, 349, 1, 0, 0, 0, 3597, 3599, 3, 352, 176, 0, 3598, 3597, 1, 0, 0, 0, 3599, 3602, 1, 0, 0, 0, 3600, 3598, 1, 0, 0, 0, 3600, 3601, 1, 0, 0, 0, 3601, 351, 1, 0, 0, 0, 3602, 3600, 1, 0, 0, 0, 3603, 3604, 5, 21, 0, 0, 3604, 3617, 3, 2, 1, 0, 3605, 3606, 5, 50, 0, 0, 3606, 3607, 5, 40, 0, 0, 3607, 3617, 3, 118, 59, 0, 3608, 3609, 5, 25, 0, 0, 3609, 3610, 5, 40, 0, 0, 3610, 3617, 3, 2, 1, 0, 3611, 3617, 3, 174, 87, 0, 3612, 3613, 5, 50, 0, 0, 3613, 3617, 3, 32, 16, 0, 3614, 3617, 3, 330, 165, 0, 3615, 3617, 3, 40, 20, 0, 3616, 3603, 1, 0, 0, 0, 3616, 3605, 1, 0, 0, 0, 3616, 3608, 1, 0, 0, 0, 3616, 3611, 1, 0, 0, 0, 3616, 3612, 1, 0, 0, 0, 3616, 3614, 1, 0, 0, 0, 3616, 3615, 1, 0, 0, 0, 3617, 353, 1, 0, 0, 0, 3618, 3619, 3, 356, 178, 0, 3619, 3620, 5, 17, 0, 0, 3620, 3621, 3, 360, 180, 0, 3621, 3622, 5, 18, 0, 0, 3622, 355, 1, 0, 0, 0, 3623, 3627, 5, 274, 0, 0, 3624, 3626, 3, 358, 179, 0, 3625, 3624, 1, 0, 0, 0, 3626, 3629, 1, 0, 0, 0, 3627, 3625, 1, 0, 0, 0, 3627, 3628, 1, 0, 0, 0, 3628, 3630, 1, 0, 0, 0, 3629, 3627, 1, 0, 0, 0, 3630, 3643, 3, 2, 1, 0, 3631, 3635, 5, 274, 0, 0, 3632, 3634, 3, 358, 179, 0, 3633, 3632, 1, 0, 0, 0, 3634, 3637, 1, 0, 0, 0, 3635, 3633, 1, 0, 0, 0, 3635, 3636, 1, 0, 0, 0, 3636, 3638, 1, 0, 0, 0, 3637, 3635, 1, 0, 0, 0, 3638, 3639, 3, 2, 1, 0, 3639, 3640, 5, 34, 0, 0, 3640, 3641, 3, 2, 1, 0, 3641, 3643, 1, 0, 0, 0, 3642, 3623, 1, 0, 0, 0, 3642, 3631, 1, 0, 0, 0, 3643, 357, 1, 0, 0, 0, 3644, 3645, 7, 12, 0, 0, 3645, 359, 1, 0, 0, 0, 3646, 3648, 3, 362, 181, 0, 3647, 3646, 1, 0, 0, 0, 3648, 3651, 1, 0, 0, 0, 3649, 3647, 1, 0, 0, 0, 3649, 3650, 1, 0, 0, 0, 3650, 361, 1, 0, 0, 0, 3651, 3649, 1, 0, 0, 0, 3652, 3653, 5, 21, 0, 0, 3653, 3654, 3, 2, 1, 0, 3654, 3655, 5, 44, 0, 0, 3655, 3656, 3, 32, 16, 0, 3656, 3663, 1, 0, 0, 0, 3657, 3658, 5, 25, 0, 0, 3658, 3659, 5, 40, 0, 0, 3659, 3663, 3, 2, 1, 0, 3660, 3663, 3, 330, 165, 0, 3661, 3663, 3, 40, 20, 0, 3662, 3652, 1, 0, 0, 0, 3662, 3657, 1, 0, 0, 0, 3662, 3660, 1, 0, 0, 0, 3662, 3661, 1, 0, 0, 0, 3663, 363, 1, 0, 0, 0, 182, 374, 382, 391, 400, 489, 535, 546, 576, 580, 598, 625, 653, 693, 704, 714, 716, 727, 729, 737, 759, 772, 793, 795, 814, 887, 894, 901, 906, 915, 1026, 1032, 1048, 1054, 1060, 1067, 1095, 1173, 1175, 1189, 1195, 1204, 1206, 1215, 1229, 1243, 1251, 1259, 1263, 1302, 1310, 1319, 1327, 1346, 1356, 1359, 1383, 1530, 1540, 1549, 1552, 1634, 1643, 1675, 1735, 1775, 1791, 1801, 1828, 1852, 1860, 1864, 1879, 1886, 1931, 1941, 1959, 1977, 1996, 2017, 2036, 2051, 2059, 2071, 2091, 2098, 2103, 2114, 2126, 2236, 2248, 2264, 2278, 2287, 2300, 2302, 2345, 2356, 2363, 2371, 2379, 2392, 2398, 2404, 2409, 2438, 2446, 2460, 2465, 2490, 2499, 2510, 2514, 2521, 2541, 2550, 2552, 2567, 2614, 2624, 2626, 2633, 2639, 2683, 2692, 2732, 2737, 2777, 2781, 2791, 2813, 2825, 2836, 2851, 2864, 2877, 2880, 2892, 2906, 2924, 2942, 2956, 2980, 2992, 2997, 3006, 3008, 3015, 3025, 3093, 3185, 3192, 3205, 3378, 3386, 3388, 3397, 3399, 3407, 3415, 3423, 3431, 3439, 3446, 3448, 3456, 3467, 3474, 3486, 3513, 3532, 3537, 3554, 3566, 3575, 3595, 3600, 3616, 3627, 3635, 3642, 3649, 3662] \ No newline at end of file diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs index ba1fbafedaca4b..27d2b0dcca1051 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs @@ -1986,7 +1986,12 @@ public TypedefDeclContext typedefDecl() { } public partial class CustomDescrContext : ParserRuleContext { + public object Value; public bool HasSyntaxError; + public CustomTypeContext constructor; + public CompQstringContext stringValue; + public CustomBlobDescrContext structuredValue; + public BytesContext rawValue; [System.Diagnostics.DebuggerNonUserCode] public CustomTypeContext customType() { return GetRuleContext(0); } @@ -2016,9 +2021,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { public CustomDescrContext customDescr() { CustomDescrContext _localctx = new CustomDescrContext(Context, State); EnterRule(_localctx, 44, RULE_customDescr); - BeginSubtree(); Actions.BeginSemanticRoot(_localctx); + Actions.BeginSemanticRoot(_localctx); try { - State = 648; + State = 653; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,11,Context) ) { case 1: @@ -2027,54 +2032,58 @@ public CustomDescrContext customDescr() { State = 627; Match(T__34); State = 628; - customType(); + _localctx.constructor = customType(); + _localctx.Value = Actions.CreateDefaultCustomAttribute(_localctx.constructor.Value); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 629; - Match(T__34); - State = 630; - customType(); State = 631; - Match(T__35); + Match(T__34); State = 632; - compQstring(); + _localctx.constructor = customType(); + State = 633; + Match(T__35); + State = 634; + _localctx.stringValue = compQstring(); + _localctx.Value = Actions.CreateStringCustomAttribute(_localctx.constructor.Value, _localctx.stringValue.Value); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 634; - Match(T__34); - State = 635; - customType(); - State = 636; - Match(T__35); State = 637; - Match(T__16); + Match(T__34); State = 638; - customBlobDescr(); + _localctx.constructor = customType(); State = 639; + Match(T__35); + State = 640; + Match(T__16); + State = 641; + _localctx.structuredValue = customBlobDescr(); + State = 642; Match(T__17); + _localctx.Value = Actions.CreateStructuredCustomAttribute(_localctx.constructor.Value, _localctx.structuredValue.Value); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 641; + State = 645; Match(T__34); - State = 642; - customType(); - State = 643; + State = 646; + _localctx.constructor = customType(); + State = 647; Match(T__35); - State = 644; + State = 648; Match(T__29); - State = 645; - bytes(); - State = 646; + State = 649; + _localctx.rawValue = bytes(); + State = 650; Match(T__30); + _localctx.Value = Actions.CreateRawCustomAttribute(_localctx.constructor.Value, _localctx.rawValue.Value); } break; } @@ -2085,14 +2094,20 @@ public CustomDescrContext customDescr() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); ExitRule(); } return _localctx; } public partial class CustomDescrWithOwnerContext : ParserRuleContext { + public object Value; public bool HasSyntaxError; + public OwnerTypeContext owner; + public CustomTypeContext constructor; + public CompQstringContext stringValue; + public CustomBlobDescrContext structuredValue; + public BytesContext rawValue; [System.Diagnostics.DebuggerNonUserCode] public OwnerTypeContext ownerType() { return GetRuleContext(0); } @@ -2125,89 +2140,93 @@ public override TResult Accept(IParseTreeVisitor visitor) { public CustomDescrWithOwnerContext customDescrWithOwner() { CustomDescrWithOwnerContext _localctx = new CustomDescrWithOwnerContext(Context, State); EnterRule(_localctx, 46, RULE_customDescrWithOwner); - BeginSubtree(); Actions.BeginSemanticRoot(_localctx); + Actions.BeginSemanticRoot(_localctx); try { - State = 684; + State = 693; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,12,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 650; + State = 655; Match(T__34); - State = 651; + State = 656; Match(T__29); - State = 652; - ownerType(); - State = 653; + State = 657; + _localctx.owner = ownerType(); + State = 658; Match(T__30); - State = 654; - customType(); + State = 659; + _localctx.constructor = customType(); + _localctx.Value = Actions.CreateDefaultOwnedCustomAttribute(_localctx.owner.Value, _localctx.constructor.Value); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 656; + State = 662; Match(T__34); - State = 657; + State = 663; Match(T__29); - State = 658; - ownerType(); - State = 659; + State = 664; + _localctx.owner = ownerType(); + State = 665; Match(T__30); - State = 660; - customType(); - State = 661; + State = 666; + _localctx.constructor = customType(); + State = 667; Match(T__35); - State = 662; - compQstring(); + State = 668; + _localctx.stringValue = compQstring(); + _localctx.Value = Actions.CreateStringOwnedCustomAttribute(_localctx.owner.Value, _localctx.constructor.Value, _localctx.stringValue.Value); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 664; + State = 671; Match(T__34); - State = 665; + State = 672; Match(T__29); - State = 666; - ownerType(); - State = 667; + State = 673; + _localctx.owner = ownerType(); + State = 674; Match(T__30); - State = 668; - customType(); - State = 669; + State = 675; + _localctx.constructor = customType(); + State = 676; Match(T__35); - State = 670; + State = 677; Match(T__16); - State = 671; - customBlobDescr(); - State = 672; + State = 678; + _localctx.structuredValue = customBlobDescr(); + State = 679; Match(T__17); + _localctx.Value = Actions.CreateStructuredOwnedCustomAttribute(_localctx.owner.Value, _localctx.constructor.Value, _localctx.structuredValue.Value); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 674; + State = 682; Match(T__34); - State = 675; + State = 683; Match(T__29); - State = 676; - ownerType(); - State = 677; + State = 684; + _localctx.owner = ownerType(); + State = 685; Match(T__30); - State = 678; - customType(); - State = 679; + State = 686; + _localctx.constructor = customType(); + State = 687; Match(T__35); - State = 680; + State = 688; Match(T__29); - State = 681; - bytes(); - State = 682; + State = 689; + _localctx.rawValue = bytes(); + State = 690; Match(T__30); + _localctx.Value = Actions.CreateRawOwnedCustomAttribute(_localctx.owner.Value, _localctx.constructor.Value, _localctx.rawValue.Value); } break; } @@ -2218,13 +2237,15 @@ public CustomDescrWithOwnerContext customDescrWithOwner() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); ExitRule(); } return _localctx; } public partial class CustomTypeContext : ParserRuleContext { + public object Value; + public MethodRefContext constructor; [System.Diagnostics.DebuggerNonUserCode] public MethodRefContext methodRef() { return GetRuleContext(0); } @@ -2248,8 +2269,9 @@ public CustomTypeContext customType() { try { EnterOuterAlt(_localctx, 1); { - State = 686; - methodRef(); + State = 695; + _localctx.constructor = methodRef(); + _localctx.Value = Actions.CreateCustomAttributeType(_localctx.constructor.Value); } } catch (RecognitionException re) { @@ -2293,13 +2315,13 @@ public OwnerTypeContext ownerType() { EnterRule(_localctx, 50, RULE_ownerType); Actions.BeginSemanticRoot(_localctx); try { - State = 694; + State = 704; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,13,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 688; + State = 698; _localctx.typeValue = typeSpec(); _localctx.Value = Actions.CreateTypeOwner(_localctx.typeValue.Value); } @@ -2307,7 +2329,7 @@ public OwnerTypeContext ownerType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 691; + State = 701; _localctx.member = memberRef(); _localctx.Value = Actions.CreateMemberOwner(_localctx.member.Value); } @@ -2327,6 +2349,9 @@ public OwnerTypeContext ownerType() { } public partial class CustomBlobDescrContext : ParserRuleContext { + public object Value; + public CustomBlobArgsContext arguments; + public CustomBlobNVPairsContext namedArguments; [System.Diagnostics.DebuggerNonUserCode] public CustomBlobArgsContext customBlobArgs() { return GetRuleContext(0); } @@ -2353,10 +2378,11 @@ public CustomBlobDescrContext customBlobDescr() { try { EnterOuterAlt(_localctx, 1); { - State = 696; - customBlobArgs(); - State = 697; - customBlobNVPairs(); + State = 706; + _localctx.arguments = customBlobArgs(); + State = 707; + _localctx.namedArguments = customBlobNVPairs(); + _localctx.Value = Actions.CreateCustomAttributeBlob(_localctx.arguments.Value, _localctx.namedArguments.Value); } } catch (RecognitionException re) { @@ -2371,18 +2397,20 @@ public CustomBlobDescrContext customBlobDescr() { } public partial class CustomBlobArgsContext : ParserRuleContext { - [System.Diagnostics.DebuggerNonUserCode] public SerInitContext[] serInit() { - return GetRuleContexts(); - } - [System.Diagnostics.DebuggerNonUserCode] public SerInitContext serInit(int i) { - return GetRuleContext(i); - } + public object Value; + public SerInitContext argument; [System.Diagnostics.DebuggerNonUserCode] public CompControlContext[] compControl() { return GetRuleContexts(); } [System.Diagnostics.DebuggerNonUserCode] public CompControlContext compControl(int i) { return GetRuleContext(i); } + [System.Diagnostics.DebuggerNonUserCode] public SerInitContext[] serInit() { + return GetRuleContexts(); + } + [System.Diagnostics.DebuggerNonUserCode] public SerInitContext serInit(int i) { + return GetRuleContext(i); + } public CustomBlobArgsContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { @@ -2400,17 +2428,18 @@ public override TResult Accept(IParseTreeVisitor visitor) { public CustomBlobArgsContext customBlobArgs() { CustomBlobArgsContext _localctx = new CustomBlobArgsContext(Context, State); EnterRule(_localctx, 54, RULE_customBlobArgs); + Actions.BeginCustomBlobArguments(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 703; + State = 716; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,15,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { - State = 701; + State = 714; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__83: @@ -2430,8 +2459,9 @@ public CustomBlobArgsContext customBlobArgs() { case TYPE: case OBJECT: { - State = 699; - serInit(); + State = 710; + _localctx.argument = serInit(); + Actions.AddCustomBlobArgument(_localctx, _localctx.argument.Value); } break; case T__31: @@ -2443,7 +2473,7 @@ public CustomBlobArgsContext customBlobArgs() { case PP_ENDIF: case PP_INCLUDE: { - State = 700; + State = 713; compControl(); } break; @@ -2452,7 +2482,7 @@ public CustomBlobArgsContext customBlobArgs() { } } } - State = 705; + State = 718; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,15,Context); } @@ -2464,12 +2494,24 @@ public CustomBlobArgsContext customBlobArgs() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndCustomBlobArguments(_localctx); ExitRule(); } return _localctx; } public partial class CustomBlobNVPairsContext : ParserRuleContext { + public object Value; + public FieldOrPropContext kind; + public SerializTypeContext argumentType; + public DottedNameContext name; + public SerInitContext value; + [System.Diagnostics.DebuggerNonUserCode] public CompControlContext[] compControl() { + return GetRuleContexts(); + } + [System.Diagnostics.DebuggerNonUserCode] public CompControlContext compControl(int i) { + return GetRuleContext(i); + } [System.Diagnostics.DebuggerNonUserCode] public FieldOrPropContext[] fieldOrProp() { return GetRuleContexts(); } @@ -2494,12 +2536,6 @@ [System.Diagnostics.DebuggerNonUserCode] public SerInitContext[] serInit() { [System.Diagnostics.DebuggerNonUserCode] public SerInitContext serInit(int i) { return GetRuleContext(i); } - [System.Diagnostics.DebuggerNonUserCode] public CompControlContext[] compControl() { - return GetRuleContexts(); - } - [System.Diagnostics.DebuggerNonUserCode] public CompControlContext compControl(int i) { - return GetRuleContext(i); - } public CustomBlobNVPairsContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { @@ -2517,31 +2553,38 @@ public override TResult Accept(IParseTreeVisitor visitor) { public CustomBlobNVPairsContext customBlobNVPairs() { CustomBlobNVPairsContext _localctx = new CustomBlobNVPairsContext(Context, State); EnterRule(_localctx, 56, RULE_customBlobNVPairs); + Actions.BeginCustomBlobNamedArguments(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 715; + State = 729; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 416611827712L) != 0) || ((((_la - 267)) & ~0x3f) == 0 && ((1L << (_la - 267)) & 127L) != 0)) { { - State = 713; + State = 727; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__36: case T__37: { - State = 706; - fieldOrProp(); - State = 707; - serializType(); - State = 708; - dottedName(); - State = 709; + State = 719; + _localctx.kind = fieldOrProp(); + State = 720; + _localctx.argumentType = serializType(); + State = 721; + _localctx.name = dottedName(); + State = 722; Match(T__35); - State = 710; - serInit(); + State = 723; + _localctx.value = serInit(); + Actions.AddCustomBlobNamedArgument( + _localctx, + _localctx.kind.Value, + _localctx.argumentType.Value, + _localctx.name.Value, + _localctx.value.Value); } break; case T__31: @@ -2553,7 +2596,7 @@ public CustomBlobNVPairsContext customBlobNVPairs() { case PP_ENDIF: case PP_INCLUDE: { - State = 712; + State = 726; compControl(); } break; @@ -2561,7 +2604,7 @@ public CustomBlobNVPairsContext customBlobNVPairs() { throw new NoViableAltException(this); } } - State = 717; + State = 731; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -2573,12 +2616,15 @@ public CustomBlobNVPairsContext customBlobNVPairs() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndCustomBlobNamedArguments(_localctx); ExitRule(); } return _localctx; } public partial class FieldOrPropContext : ParserRuleContext { + public byte Value; + public IToken kind; public FieldOrPropContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { @@ -2600,15 +2646,17 @@ public FieldOrPropContext fieldOrProp() { try { EnterOuterAlt(_localctx, 1); { - State = 718; + State = 732; + _localctx.kind = TokenStream.LT(1); _la = TokenStream.LA(1); if ( !(_la==T__36 || _la==T__37) ) { - ErrorHandler.RecoverInline(this); + _localctx.kind = ErrorHandler.RecoverInline(this); } else { ErrorHandler.ReportMatch(this); Consume(); } + _localctx.Value = Actions.GetCustomAttributeNamedArgumentKind(_localctx.kind); } } catch (RecognitionException re) { @@ -2623,6 +2671,9 @@ public FieldOrPropContext fieldOrProp() { } public partial class SerializTypeContext : ParserRuleContext { + public object Value; + public SerializTypeElementContext element; + public IToken array; [System.Diagnostics.DebuggerNonUserCode] public SerializTypeElementContext serializTypeElement() { return GetRuleContext(0); } @@ -2648,18 +2699,19 @@ public SerializTypeContext serializType() { try { EnterOuterAlt(_localctx, 1); { - State = 720; - serializTypeElement(); - State = 722; + State = 735; + _localctx.element = serializTypeElement(); + State = 737; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==ARRAY_TYPE_NO_BOUNDS) { { - State = 721; - Match(ARRAY_TYPE_NO_BOUNDS); + State = 736; + _localctx.array = Match(ARRAY_TYPE_NO_BOUNDS); } } + _localctx.Value = Actions.CreateSerializationType(_localctx.element.Value, _localctx.array); } } catch (RecognitionException re) { @@ -2674,6 +2726,12 @@ public SerializTypeContext serializType() { } public partial class SerializTypeElementContext : ParserRuleContext { + public object Value; + public SimpleTypeContext primitive; + public DottedNameContext alias; + public IToken simpleTypeToken; + public IToken quotedName; + public ClassNameContext classNameValue; [System.Diagnostics.DebuggerNonUserCode] public SimpleTypeContext simpleType() { return GetRuleContext(0); } @@ -2705,55 +2763,61 @@ public SerializTypeElementContext serializTypeElement() { SerializTypeElementContext _localctx = new SerializTypeElementContext(Context, State); EnterRule(_localctx, 62, RULE_serializTypeElement); try { - State = 733; + State = 759; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,19,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 724; - simpleType(); + State = 741; + _localctx.primitive = simpleType(); + _localctx.Value = Actions.CreatePrimitiveSerializationType(_localctx.primitive.Value); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 725; - dottedName(); + State = 744; + _localctx.alias = dottedName(); + _localctx.Value = Actions.CreateSerializationTypeTypedef(_localctx, _localctx.alias.Value); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 726; - Match(TYPE); + State = 747; + _localctx.simpleTypeToken = Match(TYPE); + _localctx.Value = Actions.CreateSimpleSerializationType(_localctx.simpleTypeToken); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 727; - Match(OBJECT); + State = 749; + _localctx.simpleTypeToken = Match(OBJECT); + _localctx.Value = Actions.CreateSimpleSerializationType(_localctx.simpleTypeToken); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 728; + State = 751; Match(ENUM); - State = 729; + State = 752; Match(T__38); - State = 730; - Match(SQSTRING); + State = 753; + _localctx.quotedName = Match(SQSTRING); + _localctx.Value = Actions.CreateEnumSerializationType(_localctx.quotedName); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 731; + State = 755; Match(ENUM); - State = 732; - className(); + State = 756; + _localctx.classNameValue = className(); + _localctx.Value = Actions.CreateEnumSerializationType(_localctx.classNameValue.Value); } break; } @@ -2796,17 +2860,17 @@ public ModuleHeadContext moduleHead() { ModuleHeadContext _localctx = new ModuleHeadContext(Context, State); EnterRule(_localctx, 64, RULE_moduleHead); try { - State = 746; + State = 772; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,20,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 735; + State = 761; Match(MODULE); - State = 736; + State = 762; Match(T__39); - State = 737; + State = 763; _localctx.name = dottedName(); Actions.SetModuleHeader(_localctx, _localctx.name.Value, true); } @@ -2814,9 +2878,9 @@ public ModuleHeadContext moduleHead() { case 2: EnterOuterAlt(_localctx, 2); { - State = 740; + State = 766; Match(MODULE); - State = 741; + State = 767; _localctx.name = dottedName(); Actions.SetModuleHeader(_localctx, _localctx.name.Value, false); } @@ -2824,7 +2888,7 @@ public ModuleHeadContext moduleHead() { case 3: EnterOuterAlt(_localctx, 3); { - State = 744; + State = 770; Match(MODULE); Actions.SetEmptyModuleHeader(_localctx); } @@ -2874,19 +2938,19 @@ public VtfixupDeclContext vtfixupDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 748; + State = 774; Match(T__40); - State = 749; + State = 775; Match(T__41); - State = 750; + State = 776; int32(); - State = 751; + State = 777; Match(T__42); - State = 752; + State = 778; vtfixupAttr(0); - State = 753; + State = 779; Match(T__43); - State = 754; + State = 780; id(); } } @@ -2940,7 +3004,7 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { } Context.Stop = TokenStream.LT(-1); - State = 769; + State = 795; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,22,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { @@ -2949,16 +3013,16 @@ private VtfixupAttrContext vtfixupAttr(int _p) { TriggerExitRuleEvent(); _prevctx = _localctx; { - State = 767; + State = 793; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,21,Context) ) { case 1: { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 757; + State = 783; if (!(Precpred(Context, 5))) throw new FailedPredicateException(this, "Precpred(Context, 5)"); - State = 758; + State = 784; Match(INT32_); } break; @@ -2966,9 +3030,9 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 759; + State = 785; if (!(Precpred(Context, 4))) throw new FailedPredicateException(this, "Precpred(Context, 4)"); - State = 760; + State = 786; Match(INT64_); } break; @@ -2976,9 +3040,9 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 761; + State = 787; if (!(Precpred(Context, 3))) throw new FailedPredicateException(this, "Precpred(Context, 3)"); - State = 762; + State = 788; Match(T__44); } break; @@ -2986,9 +3050,9 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 763; + State = 789; if (!(Precpred(Context, 2))) throw new FailedPredicateException(this, "Precpred(Context, 2)"); - State = 764; + State = 790; Match(T__45); } break; @@ -2996,16 +3060,16 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 765; + State = 791; if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)"); - State = 766; + State = 792; Match(T__46); } break; } } } - State = 771; + State = 797; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,22,Context); } @@ -3048,15 +3112,15 @@ public VtableDeclContext vtableDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 772; + State = 798; Match(T__47); - State = 773; + State = 799; Match(T__35); - State = 774; + State = 800; Match(T__29); - State = 775; + State = 801; bytes(); - State = 776; + State = 802; Match(T__30); } } @@ -3099,9 +3163,9 @@ public NameSpaceHeadContext nameSpaceHead() { try { EnterOuterAlt(_localctx, 1); { - State = 778; + State = 804; Match(T__48); - State = 779; + State = 805; _localctx.name = dottedName(); _localctx.Value = _localctx.name.Value; } @@ -3167,32 +3231,32 @@ public ClassHeadContext classHead() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 782; + State = 808; Match(T__49); - State = 788; + State = 814; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,23,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 783; + State = 809; _localctx.attribute = classAttr(); Actions.AddClassHeaderAttribute(_localctx, _localctx.attribute.Value); } } } - State = 790; + State = 816; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,23,Context); } - State = 791; + State = 817; _localctx.name = dottedName(); - State = 792; + State = 818; _localctx.genericParameters = typarsClause(); - State = 793; + State = 819; _localctx.baseType = extendsClause(); - State = 794; + State = 820; _localctx.interfaces = implClause(); _localctx.Value = Actions.CreateClassHeader( _localctx, @@ -3248,13 +3312,13 @@ public ClassAttrContext classAttr() { ClassAttrContext _localctx = new ClassAttrContext(Context, State); EnterRule(_localctx, 76, RULE_classAttr); try { - State = 861; + State = 887; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,24,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 797; + State = 823; _localctx.attribute = Match(T__50); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3262,7 +3326,7 @@ public ClassAttrContext classAttr() { case 2: EnterOuterAlt(_localctx, 2); { - State = 799; + State = 825; _localctx.attribute = Match(T__51); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3270,7 +3334,7 @@ public ClassAttrContext classAttr() { case 3: EnterOuterAlt(_localctx, 3); { - State = 801; + State = 827; _localctx.attribute = Match(VALUE); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3278,7 +3342,7 @@ public ClassAttrContext classAttr() { case 4: EnterOuterAlt(_localctx, 4); { - State = 803; + State = 829; _localctx.attribute = Match(ENUM); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3286,7 +3350,7 @@ public ClassAttrContext classAttr() { case 5: EnterOuterAlt(_localctx, 5); { - State = 805; + State = 831; _localctx.attribute = Match(INTERFACE); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3294,7 +3358,7 @@ public ClassAttrContext classAttr() { case 6: EnterOuterAlt(_localctx, 6); { - State = 807; + State = 833; _localctx.attribute = Match(T__52); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3302,7 +3366,7 @@ public ClassAttrContext classAttr() { case 7: EnterOuterAlt(_localctx, 7); { - State = 809; + State = 835; _localctx.attribute = Match(T__53); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3310,7 +3374,7 @@ public ClassAttrContext classAttr() { case 8: EnterOuterAlt(_localctx, 8); { - State = 811; + State = 837; _localctx.attribute = Match(T__54); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3318,7 +3382,7 @@ public ClassAttrContext classAttr() { case 9: EnterOuterAlt(_localctx, 9); { - State = 813; + State = 839; _localctx.attribute = Match(T__55); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3326,7 +3390,7 @@ public ClassAttrContext classAttr() { case 10: EnterOuterAlt(_localctx, 10); { - State = 815; + State = 841; _localctx.attribute = Match(EXPLICIT); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3334,7 +3398,7 @@ public ClassAttrContext classAttr() { case 11: EnterOuterAlt(_localctx, 11); { - State = 817; + State = 843; _localctx.attribute = Match(T__14); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3342,7 +3406,7 @@ public ClassAttrContext classAttr() { case 12: EnterOuterAlt(_localctx, 12); { - State = 819; + State = 845; _localctx.attribute = Match(ANSI); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3350,7 +3414,7 @@ public ClassAttrContext classAttr() { case 13: EnterOuterAlt(_localctx, 13); { - State = 821; + State = 847; _localctx.attribute = Match(T__56); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3358,7 +3422,7 @@ public ClassAttrContext classAttr() { case 14: EnterOuterAlt(_localctx, 14); { - State = 823; + State = 849; _localctx.attribute = Match(T__57); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3366,7 +3430,7 @@ public ClassAttrContext classAttr() { case 15: EnterOuterAlt(_localctx, 15); { - State = 825; + State = 851; _localctx.attribute = Match(T__58); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3374,7 +3438,7 @@ public ClassAttrContext classAttr() { case 16: EnterOuterAlt(_localctx, 16); { - State = 827; + State = 853; _localctx.attribute = Match(T__59); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3382,7 +3446,7 @@ public ClassAttrContext classAttr() { case 17: EnterOuterAlt(_localctx, 17); { - State = 829; + State = 855; _localctx.attribute = Match(T__60); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3390,9 +3454,9 @@ public ClassAttrContext classAttr() { case 18: EnterOuterAlt(_localctx, 18); { - State = 831; + State = 857; Match(T__61); - State = 832; + State = 858; _localctx.visibility = Match(T__50); _localctx.Value = Actions.CreateNestedClassAttribute(_localctx.visibility); } @@ -3400,9 +3464,9 @@ public ClassAttrContext classAttr() { case 19: EnterOuterAlt(_localctx, 19); { - State = 834; + State = 860; Match(T__61); - State = 835; + State = 861; _localctx.visibility = Match(T__51); _localctx.Value = Actions.CreateNestedClassAttribute(_localctx.visibility); } @@ -3410,9 +3474,9 @@ public ClassAttrContext classAttr() { case 20: EnterOuterAlt(_localctx, 20); { - State = 837; + State = 863; Match(T__61); - State = 838; + State = 864; _localctx.visibility = Match(T__62); _localctx.Value = Actions.CreateNestedClassAttribute(_localctx.visibility); } @@ -3420,9 +3484,9 @@ public ClassAttrContext classAttr() { case 21: EnterOuterAlt(_localctx, 21); { - State = 840; + State = 866; Match(T__61); - State = 841; + State = 867; _localctx.visibility = Match(T__63); _localctx.Value = Actions.CreateNestedClassAttribute(_localctx.visibility); } @@ -3430,9 +3494,9 @@ public ClassAttrContext classAttr() { case 22: EnterOuterAlt(_localctx, 22); { - State = 843; + State = 869; Match(T__61); - State = 844; + State = 870; _localctx.visibility = Match(T__64); _localctx.Value = Actions.CreateNestedClassAttribute(_localctx.visibility); } @@ -3440,9 +3504,9 @@ public ClassAttrContext classAttr() { case 23: EnterOuterAlt(_localctx, 23); { - State = 846; + State = 872; Match(T__61); - State = 847; + State = 873; _localctx.visibility = Match(T__65); _localctx.Value = Actions.CreateNestedClassAttribute(_localctx.visibility); } @@ -3450,7 +3514,7 @@ public ClassAttrContext classAttr() { case 24: EnterOuterAlt(_localctx, 24); { - State = 849; + State = 875; _localctx.attribute = Match(T__66); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3458,7 +3522,7 @@ public ClassAttrContext classAttr() { case 25: EnterOuterAlt(_localctx, 25); { - State = 851; + State = 877; _localctx.attribute = Match(T__67); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3466,7 +3530,7 @@ public ClassAttrContext classAttr() { case 26: EnterOuterAlt(_localctx, 26); { - State = 853; + State = 879; _localctx.attribute = Match(T__68); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3474,13 +3538,13 @@ public ClassAttrContext classAttr() { case 27: EnterOuterAlt(_localctx, 27); { - State = 855; + State = 881; Match(T__69); - State = 856; + State = 882; Match(T__29); - State = 857; + State = 883; _localctx.flags = int32(); - State = 858; + State = 884; Match(T__30); _localctx.Value = Actions.CreateRawClassAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } @@ -3523,7 +3587,7 @@ public ExtendsClauseContext extendsClause() { EnterRule(_localctx, 78, RULE_extendsClause); _localctx.Value = Actions.CreateEmptyClassBase(); try { - State = 868; + State = 894; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -3535,9 +3599,9 @@ public ExtendsClauseContext extendsClause() { case T__70: EnterOuterAlt(_localctx, 2); { - State = 864; + State = 890; Match(T__70); - State = 865; + State = 891; _localctx.baseType = typeSpec(); _localctx.Value = Actions.CreateClassBase(_localctx.baseType.Value); } @@ -3582,7 +3646,7 @@ public ImplClauseContext implClause() { EnterRule(_localctx, 80, RULE_implClause); _localctx.Value = Actions.CreateEmptyInterfaceList(); try { - State = 875; + State = 901; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -3593,9 +3657,9 @@ public ImplClauseContext implClause() { case T__71: EnterOuterAlt(_localctx, 2); { - State = 871; + State = 897; Match(T__71); - State = 872; + State = 898; _localctx.interfaces = implList(); _localctx.Value = _localctx.interfaces.Value; } @@ -3644,17 +3708,17 @@ public ClassDeclsContext classDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 880; + State = 906; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1125938695831552L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 1189425290649010179L) != 0) || ((((_la - 139)) & ~0x3f) == 0 && ((1L << (_la - 139)) & 1152921504673955841L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 871552083145265153L) != 0)) { { { - State = 877; + State = 903; classDecl(); } } - State = 882; + State = 908; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -3704,26 +3768,26 @@ public ImplListContext implList() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 889; + State = 915; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,28,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 883; + State = 909; _localctx.interfaceType = typeSpec(); Actions.AddInterfaceType(_localctx, _localctx.interfaceType.Value); - State = 885; + State = 911; Match(T__27); } } } - State = 891; + State = 917; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,28,Context); } - State = 892; + State = 918; _localctx.lastInterfaceType = typeSpec(); Actions.AddInterfaceType(_localctx, _localctx.lastInterfaceType.Value); } @@ -3762,7 +3826,7 @@ public EsHeadContext esHead() { try { EnterOuterAlt(_localctx, 1); { - State = 895; + State = 921; _la = TokenStream.LA(1); if ( !(_la==T__72 || _la==T__73) ) { ErrorHandler.RecoverInline(this); @@ -3816,257 +3880,257 @@ public ExtSourceSpecContext extSourceSpec() { EnterRule(_localctx, 88, RULE_extSourceSpec); BeginSubtree(); Actions.BeginSemanticRoot(_localctx); try { - State = 1000; + State = 1026; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,29,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 897; + State = 923; esHead(); - State = 898; + State = 924; int32(); - State = 899; + State = 925; Match(SQSTRING); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 901; + State = 927; esHead(); - State = 902; + State = 928; int32(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 904; + State = 930; esHead(); - State = 905; + State = 931; int32(); - State = 906; + State = 932; Match(T__74); - State = 907; + State = 933; int32(); - State = 908; + State = 934; Match(SQSTRING); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 910; + State = 936; esHead(); - State = 911; + State = 937; int32(); - State = 912; + State = 938; Match(T__74); - State = 913; + State = 939; int32(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 915; + State = 941; esHead(); - State = 916; + State = 942; int32(); - State = 917; + State = 943; Match(T__74); - State = 918; + State = 944; int32(); - State = 919; + State = 945; Match(T__27); - State = 920; + State = 946; int32(); - State = 921; + State = 947; Match(SQSTRING); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 923; + State = 949; esHead(); - State = 924; + State = 950; int32(); - State = 925; + State = 951; Match(T__74); - State = 926; + State = 952; int32(); - State = 927; + State = 953; Match(T__27); - State = 928; + State = 954; int32(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 930; + State = 956; esHead(); - State = 931; + State = 957; int32(); - State = 932; + State = 958; Match(T__27); - State = 933; + State = 959; int32(); - State = 934; + State = 960; Match(T__74); - State = 935; + State = 961; int32(); - State = 936; + State = 962; Match(SQSTRING); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 938; + State = 964; esHead(); - State = 939; + State = 965; int32(); - State = 940; + State = 966; Match(T__27); - State = 941; + State = 967; int32(); - State = 942; + State = 968; Match(T__74); - State = 943; + State = 969; int32(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 945; + State = 971; esHead(); - State = 946; + State = 972; int32(); - State = 947; + State = 973; Match(T__27); - State = 948; + State = 974; int32(); - State = 949; + State = 975; Match(T__74); - State = 950; + State = 976; int32(); - State = 951; + State = 977; Match(T__27); - State = 952; + State = 978; int32(); - State = 953; + State = 979; Match(SQSTRING); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 955; + State = 981; esHead(); - State = 956; + State = 982; int32(); - State = 957; + State = 983; Match(T__27); - State = 958; + State = 984; int32(); - State = 959; + State = 985; Match(T__74); - State = 960; + State = 986; int32(); - State = 961; + State = 987; Match(T__27); - State = 962; + State = 988; int32(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 964; + State = 990; esHead(); - State = 965; + State = 991; int32(); - State = 966; + State = 992; Match(QSTRING); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 968; + State = 994; esHead(); - State = 969; + State = 995; int32(); - State = 970; + State = 996; Match(T__74); - State = 971; + State = 997; int32(); - State = 972; + State = 998; Match(QSTRING); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 974; + State = 1000; esHead(); - State = 975; + State = 1001; int32(); - State = 976; + State = 1002; Match(T__74); - State = 977; + State = 1003; int32(); - State = 978; + State = 1004; Match(T__27); - State = 979; + State = 1005; int32(); - State = 980; + State = 1006; Match(QSTRING); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 982; + State = 1008; esHead(); - State = 983; + State = 1009; int32(); - State = 984; + State = 1010; Match(T__27); - State = 985; + State = 1011; int32(); - State = 986; + State = 1012; Match(T__74); - State = 987; + State = 1013; int32(); - State = 988; + State = 1014; Match(QSTRING); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 990; + State = 1016; esHead(); - State = 991; + State = 1017; int32(); - State = 992; + State = 1018; Match(T__27); - State = 993; + State = 1019; int32(); - State = 994; + State = 1020; Match(T__74); - State = 995; + State = 1021; int32(); - State = 996; + State = 1022; Match(T__27); - State = 997; + State = 1023; int32(); - State = 998; + State = 1024; Match(QSTRING); } break; @@ -4125,68 +4189,68 @@ public FileDeclContext fileDecl() { BeginSubtree(); Actions.BeginSemanticRoot(_localctx); int _la; try { - State = 1028; + State = 1054; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,32,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1002; + State = 1028; Match(T__20); - State = 1006; + State = 1032; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__75) { { { - State = 1003; + State = 1029; fileAttr(); } } - State = 1008; + State = 1034; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 1009; + State = 1035; dottedName(); - State = 1010; + State = 1036; fileEntry(); - State = 1011; + State = 1037; Match(HASH); - State = 1012; + State = 1038; Match(T__35); - State = 1013; + State = 1039; Match(T__29); - State = 1014; + State = 1040; bytes(); - State = 1015; + State = 1041; Match(T__30); - State = 1016; + State = 1042; fileEntry(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1018; + State = 1044; Match(T__20); - State = 1022; + State = 1048; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__75) { { { - State = 1019; + State = 1045; fileAttr(); } } - State = 1024; + State = 1050; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 1025; + State = 1051; dottedName(); - State = 1026; + State = 1052; fileEntry(); } break; @@ -4225,7 +4289,7 @@ public FileAttrContext fileAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 1030; + State = 1056; Match(T__75); } } @@ -4260,7 +4324,7 @@ public FileEntryContext fileEntry() { FileEntryContext _localctx = new FileEntryContext(Context, State); EnterRule(_localctx, 94, RULE_fileEntry); try { - State = 1034; + State = 1060; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -4310,7 +4374,7 @@ public FileEntryContext fileEntry() { case ENTRYPOINT: EnterOuterAlt(_localctx, 2); { - State = 1033; + State = 1059; Match(ENTRYPOINT); } break; @@ -4351,7 +4415,7 @@ public AsmAttrAnyContext asmAttrAny() { try { EnterOuterAlt(_localctx, 1); { - State = 1036; + State = 1062; _la = TokenStream.LA(1); if ( !(_la==T__1 || _la==T__60 || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 127L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -4401,17 +4465,17 @@ public AsmAttrContext asmAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 1041; + State = 1067; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__1 || _la==T__60 || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 127L) != 0)) { { { - State = 1038; + State = 1064; asmAttrAny(); } } - State = 1043; + State = 1069; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -4480,22 +4544,22 @@ public InstrContext instr() { InstrContext _localctx = new InstrContext(Context, State); EnterRule(_localctx, 100, RULE_instr); try { - State = 1069; + State = 1095; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,35,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1044; + State = 1070; simpleInstr(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1045; + State = 1071; _localctx.op = Match(INSTR_METHOD); - State = 1046; + State = 1072; _localctx.methodOperand = methodRef(); Actions.EmitMethodReferenceInstruction(_localctx.op, _localctx.methodOperand); } @@ -4503,9 +4567,9 @@ public InstrContext instr() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1049; + State = 1075; _localctx.op = Match(INSTR_FIELD); - State = 1050; + State = 1076; _localctx.fieldOperand = fieldRef(); Actions.EmitFieldReferenceInstruction(_localctx.op, _localctx.fieldOperand); } @@ -4513,9 +4577,9 @@ public InstrContext instr() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1053; + State = 1079; _localctx.op = Match(INSTR_FIELD); - State = 1054; + State = 1080; _localctx.metadataOperand = mdtoken(); Actions.EmitMetadataTokenInstruction(_localctx.op, _localctx.metadataOperand); } @@ -4523,9 +4587,9 @@ public InstrContext instr() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1057; + State = 1083; _localctx.op = Match(INSTR_TYPE); - State = 1058; + State = 1084; _localctx.typeOperand = typeSpec(); Actions.EmitTypeReferenceInstruction(_localctx.op, _localctx.typeOperand); } @@ -4533,9 +4597,9 @@ public InstrContext instr() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1061; + State = 1087; _localctx.op = Match(INSTR_SIG); - State = 1062; + State = 1088; _localctx.signatureOperand = calliSignature(); Actions.EmitCalliInstruction(_localctx.op, _localctx.signatureOperand); } @@ -4543,9 +4607,9 @@ public InstrContext instr() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1065; + State = 1091; _localctx.op = Match(INSTR_TOK); - State = 1066; + State = 1092; _localctx.ownerOperand = ownerType(); Actions.EmitOwnerTokenInstruction(_localctx.op, _localctx.ownerOperand); } @@ -4627,13 +4691,13 @@ public SimpleInstrContext simpleInstr() { SimpleInstrContext _localctx = new SimpleInstrContext(Context, State); EnterRule(_localctx, 102, RULE_simpleInstr); try { - State = 1149; + State = 1175; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,37,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1071; + State = 1097; _localctx.op = Match(INSTR_NONE); Actions.EmitNoOperandInstruction(_localctx.op); } @@ -4641,9 +4705,9 @@ public SimpleInstrContext simpleInstr() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1073; + State = 1099; _localctx.op = Match(INSTR_VAR); - State = 1074; + State = 1100; _localctx.index = int32(); Actions.EmitVariableIndexInstruction(_localctx.op, (_localctx.index!=null?(_localctx.index.Start):null)); } @@ -4651,9 +4715,9 @@ public SimpleInstrContext simpleInstr() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1077; + State = 1103; _localctx.op = Match(INSTR_VAR); - State = 1078; + State = 1104; _localctx.name = id(); Actions.EmitVariableNameInstruction(_localctx.op, (_localctx.name!=null?(_localctx.name.Start):null)); } @@ -4661,9 +4725,9 @@ public SimpleInstrContext simpleInstr() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1081; + State = 1107; _localctx.op = Match(INSTR_I); - State = 1082; + State = 1108; _localctx.value32 = int32(); Actions.EmitInt32Instruction(_localctx.op, (_localctx.value32!=null?(_localctx.value32.Start):null)); } @@ -4671,9 +4735,9 @@ public SimpleInstrContext simpleInstr() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1085; + State = 1111; _localctx.op = Match(INSTR_I8); - State = 1086; + State = 1112; _localctx.value64 = int64(); Actions.EmitInt64Instruction(_localctx.op, (_localctx.value64!=null?(_localctx.value64.Start):null)); } @@ -4681,9 +4745,9 @@ public SimpleInstrContext simpleInstr() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1089; + State = 1115; _localctx.op = Match(INSTR_R); - State = 1090; + State = 1116; _localctx.value = float64(); Actions.EmitFloatingInstruction(_localctx.op, _localctx.value.Value); } @@ -4691,9 +4755,9 @@ public SimpleInstrContext simpleInstr() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1093; + State = 1119; _localctx.op = Match(INSTR_R); - State = 1094; + State = 1120; _localctx.integerValue = int64(); Actions.EmitFloatingInstruction(_localctx.op, (_localctx.integerValue!=null?(_localctx.integerValue.Start):null)); } @@ -4701,13 +4765,13 @@ public SimpleInstrContext simpleInstr() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1097; + State = 1123; _localctx.op = Match(INSTR_R); - State = 1098; + State = 1124; Match(T__29); - State = 1099; + State = 1125; _localctx.rawFloat = bytes(); - State = 1100; + State = 1126; Match(T__30); Actions.EmitRawFloatingInstruction(_localctx.op, _localctx.rawFloat.Value, (_localctx.rawFloat!=null?(_localctx.rawFloat.Start):null)); } @@ -4715,15 +4779,15 @@ public SimpleInstrContext simpleInstr() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1103; + State = 1129; _localctx.op = Match(INSTR_R); - State = 1104; + State = 1130; Match(T__83); - State = 1105; + State = 1131; Match(T__29); - State = 1106; + State = 1132; _localctx.rawFloat = bytes(); - State = 1107; + State = 1133; Match(T__30); Actions.EmitRawFloatingInstruction(_localctx.op, _localctx.rawFloat.Value, (_localctx.rawFloat!=null?(_localctx.rawFloat.Start):null)); } @@ -4731,9 +4795,9 @@ public SimpleInstrContext simpleInstr() { case 10: EnterOuterAlt(_localctx, 10); { - State = 1110; + State = 1136; _localctx.op = Match(INSTR_BRTARGET); - State = 1111; + State = 1137; _localctx.offset = int32(); Actions.EmitBranchOffsetInstruction(_localctx.op, (_localctx.offset!=null?(_localctx.offset.Start):null)); } @@ -4741,9 +4805,9 @@ public SimpleInstrContext simpleInstr() { case 11: EnterOuterAlt(_localctx, 11); { - State = 1114; + State = 1140; _localctx.op = Match(INSTR_BRTARGET); - State = 1115; + State = 1141; _localctx.label = id(); Actions.EmitBranchLabelInstruction(_localctx.op, (_localctx.label!=null?(_localctx.label.Start):null)); } @@ -4751,9 +4815,9 @@ public SimpleInstrContext simpleInstr() { case 12: EnterOuterAlt(_localctx, 12); { - State = 1118; + State = 1144; _localctx.op = Match(INSTR_STRING); - State = 1119; + State = 1145; _localctx.userString = compQstring(); Actions.EmitStringInstruction(_localctx.op, _localctx.userString.Value); } @@ -4761,15 +4825,15 @@ public SimpleInstrContext simpleInstr() { case 13: EnterOuterAlt(_localctx, 13); { - State = 1122; + State = 1148; _localctx.op = Match(INSTR_STRING); - State = 1123; + State = 1149; Match(ANSI); - State = 1124; + State = 1150; Match(T__29); - State = 1125; + State = 1151; _localctx.ansiString = compQstring(); - State = 1126; + State = 1152; Match(T__30); Actions.EmitAnsiStringInstruction(_localctx.op, _localctx.ansiString.Value); } @@ -4777,15 +4841,15 @@ public SimpleInstrContext simpleInstr() { case 14: EnterOuterAlt(_localctx, 14); { - State = 1129; + State = 1155; _localctx.op = Match(INSTR_STRING); - State = 1130; + State = 1156; Match(T__83); - State = 1131; + State = 1157; Match(T__29); - State = 1132; + State = 1158; _localctx.rawString = bytes(); - State = 1133; + State = 1159; Match(T__30); Actions.EmitRawStringInstruction(_localctx.op, _localctx.rawString.Value); } @@ -4793,9 +4857,9 @@ public SimpleInstrContext simpleInstr() { case 15: EnterOuterAlt(_localctx, 15); { - State = 1136; + State = 1162; _localctx.op = Match(INSTR_TOK); - State = 1137; + State = 1163; _localctx.rawToken = int32(); Actions.EmitRawTokenInstruction(_localctx.op, (_localctx.rawToken!=null?(_localctx.rawToken.Start):null)); } @@ -4803,25 +4867,25 @@ public SimpleInstrContext simpleInstr() { case 16: EnterOuterAlt(_localctx, 16); { - State = 1140; + State = 1166; _localctx.op = Match(INSTR_SWITCH); Actions.BeginSwitchInstruction(_localctx, _localctx.op); - State = 1147; + State = 1173; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__29: { - State = 1142; + State = 1168; Match(T__29); - State = 1143; + State = 1169; labels(); - State = 1144; + State = 1170; Match(T__30); } break; case T__84: { - State = 1146; + State = 1172; Match(T__84); } break; @@ -4882,11 +4946,11 @@ public CalliSignatureContext calliSignature() { try { EnterOuterAlt(_localctx, 1); { - State = 1151; + State = 1177; _localctx.convention = callConv(); - State = 1152; + State = 1178; _localctx.returnType = type(); - State = 1153; + State = 1179; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateCalliSignature(_localctx.convention.Value, _localctx.returnType.Value, _localctx.arguments.Value); } @@ -4939,7 +5003,7 @@ public LabelsContext labels() { EnterRule(_localctx, 106, RULE_labels); try { int _alt; - State = 1180; + State = 1206; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__30: @@ -4970,14 +5034,14 @@ public LabelsContext labels() { case ID: EnterOuterAlt(_localctx, 2); { - State = 1169; + State = 1195; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,39,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1163; + State = 1189; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -5001,14 +5065,14 @@ public LabelsContext labels() { case SQSTRING: case ID: { - State = 1157; + State = 1183; _localctx.headLabel = id(); Actions.AddSwitchLabel((_localctx.headLabel!=null?(_localctx.headLabel.Start):null)); } break; case INT32: { - State = 1160; + State = 1186; _localctx.headOffset = int32(); Actions.AddSwitchOffset((_localctx.headOffset!=null?(_localctx.headOffset.Start):null)); } @@ -5016,16 +5080,16 @@ public LabelsContext labels() { default: throw new NoViableAltException(this); } - State = 1165; + State = 1191; Match(T__27); } } } - State = 1171; + State = 1197; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,39,Context); } - State = 1178; + State = 1204; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -5049,14 +5113,14 @@ public LabelsContext labels() { case SQSTRING: case ID: { - State = 1172; + State = 1198; _localctx.tailLabel = id(); Actions.AddSwitchLabel((_localctx.tailLabel!=null?(_localctx.tailLabel.Start):null)); } break; case INT32: { - State = 1175; + State = 1201; _localctx.tailOffset = int32(); Actions.AddSwitchOffset((_localctx.tailOffset!=null?(_localctx.tailOffset.Start):null)); } @@ -5113,31 +5177,31 @@ public TypeArgsContext typeArgs() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1182; + State = 1208; Match(T__85); - State = 1189; + State = 1215; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,42,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1183; + State = 1209; _localctx.argument = type(); Actions.AddTypeArgument(_localctx, _localctx.argument.Value); - State = 1185; + State = 1211; Match(T__27); } } } - State = 1191; + State = 1217; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,42,Context); } - State = 1192; + State = 1218; _localctx.lastArgument = type(); Actions.AddTypeArgument(_localctx, _localctx.lastArgument.Value); - State = 1194; + State = 1220; Match(T__86); } } @@ -5185,31 +5249,31 @@ public BoundsContext bounds() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1196; + State = 1222; Match(T__41); - State = 1203; + State = 1229; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,43,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1197; + State = 1223; _localctx.item = bound(); Actions.AddBound(_localctx, _localctx.item); - State = 1199; + State = 1225; Match(T__27); } } } - State = 1205; + State = 1231; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,43,Context); } - State = 1206; + State = 1232; _localctx.lastItem = bound(); Actions.AddBound(_localctx, _localctx.lastItem); - State = 1208; + State = 1234; Match(T__42); } } @@ -5255,44 +5319,44 @@ public SigArgsContext sigArgs() { Actions.BeginSignatureArguments(_localctx); try { int _alt; - State = 1225; + State = 1251; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__29: EnterOuterAlt(_localctx, 1); { - State = 1210; + State = 1236; Match(T__29); - State = 1217; + State = 1243; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,44,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1211; + State = 1237; _localctx.argument = sigArg(); Actions.AddSignatureArgument(_localctx, _localctx.argument.Value); - State = 1213; + State = 1239; Match(T__27); } } } - State = 1219; + State = 1245; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,44,Context); } - State = 1220; + State = 1246; _localctx.lastArgument = sigArg(); Actions.AddSignatureArgument(_localctx, _localctx.lastArgument.Value); - State = 1222; + State = 1248; Match(T__30); } break; case T__84: EnterOuterAlt(_localctx, 2); { - State = 1224; + State = 1250; Match(T__84); } break; @@ -5350,13 +5414,13 @@ public SigArgContext sigArg() { EnterRule(_localctx, 114, RULE_sigArg); int _la; try { - State = 1237; + State = 1263; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,47,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1227; + State = 1253; Match(ELLIPSIS); _localctx.Value = Actions.CreateSentinelSignatureArgument(); } @@ -5364,18 +5428,18 @@ public SigArgContext sigArg() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1229; + State = 1255; _localctx.attributes = paramAttr(); - State = 1230; + State = 1256; _localctx.argumentType = type(); - State = 1231; + State = 1257; _localctx.marshalling = marshalClause(); - State = 1233; + State = 1259; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 65534L) != 0) || ((((_la - 199)) & ~0x3f) == 0 && ((1L << (_la - 199)) & 299067162755073L) != 0) || _la==SQSTRING || _la==ID) { { - State = 1232; + State = 1258; _localctx.name = id(); } } @@ -5435,19 +5499,19 @@ public ClassNameContext className() { ClassNameContext _localctx = new ClassNameContext(Context, State); EnterRule(_localctx, 116, RULE_className); try { - State = 1276; + State = 1302; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,48,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1239; + State = 1265; Match(T__41); - State = 1240; + State = 1266; _localctx.assemblyName = dottedName(); - State = 1241; + State = 1267; Match(T__42); - State = 1242; + State = 1268; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreateAssemblyQualifiedClassName(_localctx.assemblyName.Value, _localctx.typeName.Value); } @@ -5455,13 +5519,13 @@ public ClassNameContext className() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1245; + State = 1271; Match(T__41); - State = 1246; + State = 1272; _localctx.scopeToken = mdtoken(); - State = 1247; + State = 1273; Match(T__42); - State = 1248; + State = 1274; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreateTokenQualifiedClassName(_localctx.scopeToken.Value, _localctx.typeName.Value); } @@ -5469,13 +5533,13 @@ public ClassNameContext className() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1251; + State = 1277; Match(T__41); - State = 1252; + State = 1278; Match(PTR); - State = 1253; + State = 1279; Match(T__42); - State = 1254; + State = 1280; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreatePointerQualifiedClassName(_localctx.typeName.Value); } @@ -5483,15 +5547,15 @@ public ClassNameContext className() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1257; + State = 1283; Match(T__41); - State = 1258; + State = 1284; Match(MODULE); - State = 1259; + State = 1285; _localctx.moduleName = dottedName(); - State = 1260; + State = 1286; Match(T__42); - State = 1261; + State = 1287; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreateModuleQualifiedClassName(_localctx.Start, _localctx.moduleName.Value, _localctx.typeName.Value); } @@ -5499,7 +5563,7 @@ public ClassNameContext className() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1264; + State = 1290; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreateUnqualifiedClassName(_localctx.typeName.Value); } @@ -5507,7 +5571,7 @@ public ClassNameContext className() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1267; + State = 1293; _localctx.typeToken = mdtoken(); _localctx.Value = Actions.CreateTokenClassName(_localctx.typeToken.Value); } @@ -5515,7 +5579,7 @@ public ClassNameContext className() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1270; + State = 1296; Match(THIS); _localctx.Value = Actions.CreateThisClassName(_localctx.Start); } @@ -5523,7 +5587,7 @@ public ClassNameContext className() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1272; + State = 1298; Match(BASE); _localctx.Value = Actions.CreateBaseClassName(_localctx.Start); } @@ -5531,7 +5595,7 @@ public ClassNameContext className() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1274; + State = 1300; Match(NESTER); _localctx.Value = Actions.CreateNesterClassName(_localctx.Start); } @@ -5581,26 +5645,26 @@ public SlashedNameContext slashedName() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1284; + State = 1310; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,49,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1278; + State = 1304; _localctx.part = dottedName(); Actions.AddSlashedNamePart(_localctx, _localctx.part.Value); - State = 1280; + State = 1306; Match(T__87); } } } - State = 1286; + State = 1312; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,49,Context); } - State = 1287; + State = 1313; _localctx.lastPart = dottedName(); Actions.AddSlashedNamePart(_localctx, _localctx.lastPart.Value); } @@ -5645,17 +5709,17 @@ public AssemblyDeclsContext assemblyDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 1293; + State = 1319; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38654771200L) != 0) || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & 4294975503L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 6860954690125825L) != 0)) { { { - State = 1290; + State = 1316; assemblyDecl(); } } - State = 1295; + State = 1321; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -5701,18 +5765,18 @@ public AssemblyDeclContext assemblyDecl() { AssemblyDeclContext _localctx = new AssemblyDeclContext(Context, State); EnterRule(_localctx, 122, RULE_assemblyDecl); try { - State = 1301; + State = 1327; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case HASH: EnterOuterAlt(_localctx, 1); { { - State = 1296; + State = 1322; Match(HASH); - State = 1297; + State = 1323; Match(T__88); - State = 1298; + State = 1324; int32(); } } @@ -5721,7 +5785,7 @@ public AssemblyDeclContext assemblyDecl() { case PERMISSIONSET: EnterOuterAlt(_localctx, 2); { - State = 1299; + State = 1325; secDecl(); } break; @@ -5746,7 +5810,7 @@ public AssemblyDeclContext assemblyDecl() { case ID: EnterOuterAlt(_localctx, 3); { - State = 1300; + State = 1326; asmOrRefDecl(); } break; @@ -5801,13 +5865,13 @@ public TypeSpecContext typeSpec() { EnterRule(_localctx, 124, RULE_typeSpec); Actions.BeginSemanticRoot(_localctx); try { - State = 1320; + State = 1346; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,52,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1303; + State = 1329; _localctx.classType = className(); _localctx.Value = Actions.CreateClassTypeSpecification(_localctx.classType.Value); } @@ -5815,11 +5879,11 @@ public TypeSpecContext typeSpec() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1306; + State = 1332; Match(T__41); - State = 1307; + State = 1333; _localctx.assemblyName = dottedName(); - State = 1308; + State = 1334; Match(T__42); _localctx.Value = Actions.CreateAssemblyTypeSpecification(_localctx.assemblyName.Value); } @@ -5827,13 +5891,13 @@ public TypeSpecContext typeSpec() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1311; + State = 1337; Match(T__41); - State = 1312; + State = 1338; Match(MODULE); - State = 1313; + State = 1339; _localctx.moduleName = dottedName(); - State = 1314; + State = 1340; Match(T__42); _localctx.Value = Actions.CreateModuleTypeSpecification(_localctx.moduleName.Value); } @@ -5841,7 +5905,7 @@ public TypeSpecContext typeSpec() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1317; + State = 1343; _localctx.signatureType = type(); _localctx.Value = Actions.CreateSignatureTypeSpecification(_localctx.signatureType.Value); } @@ -5893,7 +5957,7 @@ public NativeTypeContext nativeType() { Actions.BeginNativeType(_localctx); try { int _alt; - State = 1333; + State = 1359; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,54,Context) ) { case 1: @@ -5904,23 +5968,23 @@ public NativeTypeContext nativeType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1323; + State = 1349; _localctx.element = nativeTypeElement(); Actions.SetNativeTypeElement(_localctx, _localctx.element.Value); - State = 1330; + State = 1356; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,53,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1325; + State = 1351; _localctx.info = nativeTypeArrayPointerInfo(); Actions.AddNativeTypeArrayPointerInfo(_localctx, _localctx.info.Value); } } } - State = 1332; + State = 1358; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,53,Context); } @@ -6025,14 +6089,14 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { NativeTypeArrayPointerInfoContext _localctx = new NativeTypeArrayPointerInfoContext(Context, State); EnterRule(_localctx, 128, RULE_nativeTypeArrayPointerInfo); try { - State = 1357; + State = 1383; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,55,Context) ) { case 1: _localctx = new PointerNativeTypeContext(_localctx); EnterOuterAlt(_localctx, 1); { - State = 1335; + State = 1361; Match(PTR); _localctx.Value = Actions.CreatePointerNativeType(); } @@ -6041,7 +6105,7 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeNoSizeDataContext(_localctx); EnterOuterAlt(_localctx, 2); { - State = 1337; + State = 1363; Match(ARRAY_TYPE_NO_BOUNDS); _localctx.Value = Actions.CreatePointerArrayTypeNoSizeData(); } @@ -6050,11 +6114,11 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeSizeContext(_localctx); EnterOuterAlt(_localctx, 3); { - State = 1339; + State = 1365; Match(T__41); - State = 1340; + State = 1366; ((PointerArrayTypeSizeContext)_localctx).size = int32(); - State = 1341; + State = 1367; Match(T__42); _localctx.Value = Actions.CreatePointerArrayTypeSize((((PointerArrayTypeSizeContext)_localctx).size!=null?(((PointerArrayTypeSizeContext)_localctx).size.Start):null)); } @@ -6063,15 +6127,15 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeSizeParamIndexContext(_localctx); EnterOuterAlt(_localctx, 4); { - State = 1344; + State = 1370; Match(T__41); - State = 1345; + State = 1371; ((PointerArrayTypeSizeParamIndexContext)_localctx).size = int32(); - State = 1346; + State = 1372; Match(PLUS); - State = 1347; + State = 1373; ((PointerArrayTypeSizeParamIndexContext)_localctx).parameterIndex = int32(); - State = 1348; + State = 1374; Match(T__42); _localctx.Value = Actions.CreatePointerArrayTypeSizeParamIndex((((PointerArrayTypeSizeParamIndexContext)_localctx).size!=null?(((PointerArrayTypeSizeParamIndexContext)_localctx).size.Start):null), (((PointerArrayTypeSizeParamIndexContext)_localctx).parameterIndex!=null?(((PointerArrayTypeSizeParamIndexContext)_localctx).parameterIndex.Start):null)); } @@ -6080,13 +6144,13 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeParamIndexContext(_localctx); EnterOuterAlt(_localctx, 5); { - State = 1351; + State = 1377; Match(T__41); - State = 1352; + State = 1378; Match(PLUS); - State = 1353; + State = 1379; ((PointerArrayTypeParamIndexContext)_localctx).parameterIndex = int32(); - State = 1354; + State = 1380; Match(T__42); _localctx.Value = Actions.CreatePointerArrayTypeParamIndex((((PointerArrayTypeParamIndexContext)_localctx).parameterIndex!=null?(((PointerArrayTypeParamIndexContext)_localctx).parameterIndex.Start):null)); } @@ -6198,7 +6262,7 @@ public NativeTypeElementContext nativeTypeElement() { NativeTypeElementContext _localctx = new NativeTypeElementContext(Context, State); EnterRule(_localctx, 130, RULE_nativeTypeElement); try { - State = 1504; + State = 1530; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,56,Context) ) { case 1: @@ -6210,25 +6274,25 @@ public NativeTypeElementContext nativeTypeElement() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1360; + State = 1386; _localctx.marshalType = Match(CUSTOM); - State = 1361; + State = 1387; Match(T__29); - State = 1362; + State = 1388; _localctx.guid = compQstring(); - State = 1363; + State = 1389; Match(T__27); - State = 1364; + State = 1390; _localctx.nativeTypeName = compQstring(); - State = 1365; + State = 1391; Match(T__27); - State = 1366; + State = 1392; _localctx.marshallerType = compQstring(); - State = 1367; + State = 1393; Match(T__27); - State = 1368; + State = 1394; _localctx.cookie = compQstring(); - State = 1369; + State = 1395; Match(T__30); _localctx.Value = Actions.CreateDeprecatedCustomMarshallerNativeType( _localctx, _localctx.guid.Value, _localctx.nativeTypeName.Value, _localctx.marshallerType.Value, _localctx.cookie.Value); @@ -6237,17 +6301,17 @@ public NativeTypeElementContext nativeTypeElement() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1372; + State = 1398; _localctx.marshalType = Match(CUSTOM); - State = 1373; + State = 1399; Match(T__29); - State = 1374; + State = 1400; _localctx.marshallerType = compQstring(); - State = 1375; + State = 1401; Match(T__27); - State = 1376; + State = 1402; _localctx.cookie = compQstring(); - State = 1377; + State = 1403; Match(T__30); _localctx.Value = Actions.CreateCustomMarshallerNativeType(_localctx.marshallerType.Value, _localctx.cookie.Value); } @@ -6255,15 +6319,15 @@ public NativeTypeElementContext nativeTypeElement() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1380; + State = 1406; Match(FIXED); - State = 1381; + State = 1407; _localctx.marshalType = Match(SYSSTRING); - State = 1382; + State = 1408; Match(T__41); - State = 1383; + State = 1409; _localctx.size = int32(); - State = 1384; + State = 1410; Match(T__42); _localctx.Value = Actions.CreateFixedSysStringNativeType((_localctx.size!=null?(_localctx.size.Start):null)); } @@ -6271,17 +6335,17 @@ public NativeTypeElementContext nativeTypeElement() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1387; + State = 1413; Match(FIXED); - State = 1388; + State = 1414; _localctx.marshalType = Match(ARRAY); - State = 1389; + State = 1415; Match(T__41); - State = 1390; + State = 1416; _localctx.size = int32(); - State = 1391; + State = 1417; Match(T__42); - State = 1392; + State = 1418; _localctx.element = nativeType(); _localctx.Value = Actions.CreateFixedArrayNativeType((_localctx.size!=null?(_localctx.size.Start):null), _localctx.element.Value); } @@ -6289,7 +6353,7 @@ public NativeTypeElementContext nativeTypeElement() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1395; + State = 1421; _localctx.marshalType = Match(VARIANT); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6297,7 +6361,7 @@ public NativeTypeElementContext nativeTypeElement() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1397; + State = 1423; _localctx.marshalType = Match(CURRENCY); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6305,7 +6369,7 @@ public NativeTypeElementContext nativeTypeElement() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1399; + State = 1425; _localctx.marshalType = Match(SYSCHAR); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6313,7 +6377,7 @@ public NativeTypeElementContext nativeTypeElement() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1401; + State = 1427; _localctx.marshalType = Match(VOID); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6321,7 +6385,7 @@ public NativeTypeElementContext nativeTypeElement() { case 10: EnterOuterAlt(_localctx, 10); { - State = 1403; + State = 1429; _localctx.marshalType = Match(BOOL); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6329,7 +6393,7 @@ public NativeTypeElementContext nativeTypeElement() { case 11: EnterOuterAlt(_localctx, 11); { - State = 1405; + State = 1431; _localctx.marshalType = Match(INT8); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6337,7 +6401,7 @@ public NativeTypeElementContext nativeTypeElement() { case 12: EnterOuterAlt(_localctx, 12); { - State = 1407; + State = 1433; _localctx.marshalType = Match(INT16); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6345,7 +6409,7 @@ public NativeTypeElementContext nativeTypeElement() { case 13: EnterOuterAlt(_localctx, 13); { - State = 1409; + State = 1435; _localctx.marshalType = Match(INT32_); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6353,7 +6417,7 @@ public NativeTypeElementContext nativeTypeElement() { case 14: EnterOuterAlt(_localctx, 14); { - State = 1411; + State = 1437; _localctx.marshalType = Match(INT64_); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6361,7 +6425,7 @@ public NativeTypeElementContext nativeTypeElement() { case 15: EnterOuterAlt(_localctx, 15); { - State = 1413; + State = 1439; _localctx.marshalType = Match(FLOAT32); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6369,7 +6433,7 @@ public NativeTypeElementContext nativeTypeElement() { case 16: EnterOuterAlt(_localctx, 16); { - State = 1415; + State = 1441; _localctx.marshalType = Match(FLOAT64_); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6377,7 +6441,7 @@ public NativeTypeElementContext nativeTypeElement() { case 17: EnterOuterAlt(_localctx, 17); { - State = 1417; + State = 1443; _localctx.marshalType = Match(ERROR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6385,7 +6449,7 @@ public NativeTypeElementContext nativeTypeElement() { case 18: EnterOuterAlt(_localctx, 18); { - State = 1419; + State = 1445; _localctx.marshalType = Match(UINT8); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6393,7 +6457,7 @@ public NativeTypeElementContext nativeTypeElement() { case 19: EnterOuterAlt(_localctx, 19); { - State = 1421; + State = 1447; _localctx.marshalType = Match(UINT16); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6401,7 +6465,7 @@ public NativeTypeElementContext nativeTypeElement() { case 20: EnterOuterAlt(_localctx, 20); { - State = 1423; + State = 1449; _localctx.marshalType = Match(UINT32); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6409,7 +6473,7 @@ public NativeTypeElementContext nativeTypeElement() { case 21: EnterOuterAlt(_localctx, 21); { - State = 1425; + State = 1451; _localctx.marshalType = Match(UINT64); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6417,7 +6481,7 @@ public NativeTypeElementContext nativeTypeElement() { case 22: EnterOuterAlt(_localctx, 22); { - State = 1427; + State = 1453; _localctx.marshalType = Match(DECIMAL); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6425,7 +6489,7 @@ public NativeTypeElementContext nativeTypeElement() { case 23: EnterOuterAlt(_localctx, 23); { - State = 1429; + State = 1455; _localctx.marshalType = Match(DATE); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6433,7 +6497,7 @@ public NativeTypeElementContext nativeTypeElement() { case 24: EnterOuterAlt(_localctx, 24); { - State = 1431; + State = 1457; _localctx.marshalType = Match(BSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6441,7 +6505,7 @@ public NativeTypeElementContext nativeTypeElement() { case 25: EnterOuterAlt(_localctx, 25); { - State = 1433; + State = 1459; _localctx.marshalType = Match(LPSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6449,7 +6513,7 @@ public NativeTypeElementContext nativeTypeElement() { case 26: EnterOuterAlt(_localctx, 26); { - State = 1435; + State = 1461; _localctx.marshalType = Match(LPWSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6457,7 +6521,7 @@ public NativeTypeElementContext nativeTypeElement() { case 27: EnterOuterAlt(_localctx, 27); { - State = 1437; + State = 1463; _localctx.marshalType = Match(LPTSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6465,7 +6529,7 @@ public NativeTypeElementContext nativeTypeElement() { case 28: EnterOuterAlt(_localctx, 28); { - State = 1439; + State = 1465; _localctx.marshalType = Match(OBJECTREF); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6473,9 +6537,9 @@ public NativeTypeElementContext nativeTypeElement() { case 29: EnterOuterAlt(_localctx, 29); { - State = 1441; + State = 1467; _localctx.marshalType = Match(IUNKNOWN); - State = 1442; + State = 1468; _localctx.index = iidParamIndex(); _localctx.Value = Actions.CreateIidNativeType(_localctx.marshalType, _localctx.index.Value); } @@ -6483,9 +6547,9 @@ public NativeTypeElementContext nativeTypeElement() { case 30: EnterOuterAlt(_localctx, 30); { - State = 1445; + State = 1471; _localctx.marshalType = Match(IDISPATCH); - State = 1446; + State = 1472; _localctx.index = iidParamIndex(); _localctx.Value = Actions.CreateIidNativeType(_localctx.marshalType, _localctx.index.Value); } @@ -6493,7 +6557,7 @@ public NativeTypeElementContext nativeTypeElement() { case 31: EnterOuterAlt(_localctx, 31); { - State = 1449; + State = 1475; _localctx.marshalType = Match(STRUCT); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6501,9 +6565,9 @@ public NativeTypeElementContext nativeTypeElement() { case 32: EnterOuterAlt(_localctx, 32); { - State = 1451; + State = 1477; _localctx.marshalType = Match(INTERFACE); - State = 1452; + State = 1478; _localctx.index = iidParamIndex(); _localctx.Value = Actions.CreateIidNativeType(_localctx.marshalType, _localctx.index.Value); } @@ -6511,9 +6575,9 @@ public NativeTypeElementContext nativeTypeElement() { case 33: EnterOuterAlt(_localctx, 33); { - State = 1455; + State = 1481; _localctx.marshalType = Match(SAFEARRAY); - State = 1456; + State = 1482; _localctx.variant = variantType(); _localctx.Value = Actions.CreateSafeArrayNativeType(_localctx.variant.Value, null); } @@ -6521,13 +6585,13 @@ public NativeTypeElementContext nativeTypeElement() { case 34: EnterOuterAlt(_localctx, 34); { - State = 1459; + State = 1485; _localctx.marshalType = Match(SAFEARRAY); - State = 1460; + State = 1486; _localctx.variant = variantType(); - State = 1461; + State = 1487; Match(T__27); - State = 1462; + State = 1488; _localctx.userDefinedType = compQstring(); _localctx.Value = Actions.CreateSafeArrayNativeType(_localctx.variant.Value, _localctx.userDefinedType.Value); } @@ -6535,7 +6599,7 @@ public NativeTypeElementContext nativeTypeElement() { case 35: EnterOuterAlt(_localctx, 35); { - State = 1465; + State = 1491; _localctx.marshalType = Match(INT); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6543,7 +6607,7 @@ public NativeTypeElementContext nativeTypeElement() { case 36: EnterOuterAlt(_localctx, 36); { - State = 1467; + State = 1493; _localctx.marshalType = Match(UINT); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6551,9 +6615,9 @@ public NativeTypeElementContext nativeTypeElement() { case 37: EnterOuterAlt(_localctx, 37); { - State = 1469; + State = 1495; Match(T__89); - State = 1470; + State = 1496; _localctx.unsignedMarshalType = Match(INT8); _localctx.Value = Actions.CreateUnsignedNativeType(_localctx.unsignedMarshalType); } @@ -6561,9 +6625,9 @@ public NativeTypeElementContext nativeTypeElement() { case 38: EnterOuterAlt(_localctx, 38); { - State = 1472; + State = 1498; Match(T__89); - State = 1473; + State = 1499; _localctx.unsignedMarshalType = Match(INT16); _localctx.Value = Actions.CreateUnsignedNativeType(_localctx.unsignedMarshalType); } @@ -6571,9 +6635,9 @@ public NativeTypeElementContext nativeTypeElement() { case 39: EnterOuterAlt(_localctx, 39); { - State = 1475; + State = 1501; Match(T__89); - State = 1476; + State = 1502; _localctx.unsignedMarshalType = Match(INT32_); _localctx.Value = Actions.CreateUnsignedNativeType(_localctx.unsignedMarshalType); } @@ -6581,9 +6645,9 @@ public NativeTypeElementContext nativeTypeElement() { case 40: EnterOuterAlt(_localctx, 40); { - State = 1478; + State = 1504; Match(T__89); - State = 1479; + State = 1505; _localctx.unsignedMarshalType = Match(INT64_); _localctx.Value = Actions.CreateUnsignedNativeType(_localctx.unsignedMarshalType); } @@ -6591,9 +6655,9 @@ public NativeTypeElementContext nativeTypeElement() { case 41: EnterOuterAlt(_localctx, 41); { - State = 1481; + State = 1507; Match(T__61); - State = 1482; + State = 1508; _localctx.marshalType = Match(STRUCT); _localctx.Value = Actions.CreateNestedStructNativeType(_localctx); } @@ -6601,7 +6665,7 @@ public NativeTypeElementContext nativeTypeElement() { case 42: EnterOuterAlt(_localctx, 42); { - State = 1484; + State = 1510; _localctx.marshalType = Match(BYVALSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6609,9 +6673,9 @@ public NativeTypeElementContext nativeTypeElement() { case 43: EnterOuterAlt(_localctx, 43); { - State = 1486; + State = 1512; Match(ANSI); - State = 1487; + State = 1513; _localctx.marshalType = Match(BSTR); _localctx.Value = Actions.CreateAnsiBstrNativeType(); } @@ -6619,7 +6683,7 @@ public NativeTypeElementContext nativeTypeElement() { case 44: EnterOuterAlt(_localctx, 44); { - State = 1489; + State = 1515; _localctx.marshalType = Match(TBSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6627,9 +6691,9 @@ public NativeTypeElementContext nativeTypeElement() { case 45: EnterOuterAlt(_localctx, 45); { - State = 1491; + State = 1517; Match(VARIANT); - State = 1492; + State = 1518; _localctx.marshalBool = Match(BOOL); _localctx.Value = Actions.CreateVariantBoolNativeType(); } @@ -6637,7 +6701,7 @@ public NativeTypeElementContext nativeTypeElement() { case 46: EnterOuterAlt(_localctx, 46); { - State = 1494; + State = 1520; _localctx.marshalType = Match(METHOD); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6645,7 +6709,7 @@ public NativeTypeElementContext nativeTypeElement() { case 47: EnterOuterAlt(_localctx, 47); { - State = 1496; + State = 1522; _localctx.marshalType = Match(LPSTRUCT); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6653,9 +6717,9 @@ public NativeTypeElementContext nativeTypeElement() { case 48: EnterOuterAlt(_localctx, 48); { - State = 1498; + State = 1524; Match(T__33); - State = 1499; + State = 1525; _localctx.marshalType = Match(ANY); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6663,7 +6727,7 @@ public NativeTypeElementContext nativeTypeElement() { case 49: EnterOuterAlt(_localctx, 49); { - State = 1501; + State = 1527; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateNativeTypeTypedef(_localctx, _localctx.alias.Value); } @@ -6705,7 +6769,7 @@ public IidParamIndexContext iidParamIndex() { IidParamIndexContext _localctx = new IidParamIndexContext(Context, State); EnterRule(_localctx, 132, RULE_iidParamIndex); try { - State = 1514; + State = 1540; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__30: @@ -6719,15 +6783,15 @@ public IidParamIndexContext iidParamIndex() { case T__29: EnterOuterAlt(_localctx, 2); { - State = 1507; + State = 1533; Match(T__29); - State = 1508; + State = 1534; Match(T__90); - State = 1509; + State = 1535; Match(T__35); - State = 1510; + State = 1536; _localctx.index = int32(); - State = 1511; + State = 1537; Match(T__30); _localctx.Value = Actions.GetIidParamIndex((_localctx.index!=null?(_localctx.index.Start):null)); } @@ -6787,7 +6851,7 @@ public VariantTypeContext variantType() { int _la; try { int _alt; - State = 1526; + State = 1552; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,59,Context) ) { case 1: @@ -6798,17 +6862,17 @@ public VariantTypeContext variantType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1517; + State = 1543; _localctx.element = variantTypeElement(); Actions.SetVariantTypeElement(_localctx, _localctx.element.Value); - State = 1523; + State = 1549; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,58,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1519; + State = 1545; _localctx.modifier = TokenStream.LT(1); _la = TokenStream.LA(1); if ( !(((((_la - 229)) & ~0x3f) == 0 && ((1L << (_la - 229)) & 6442450945L) != 0)) ) { @@ -6822,7 +6886,7 @@ public VariantTypeContext variantType() { } } } - State = 1525; + State = 1551; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,58,Context); } @@ -6903,13 +6967,13 @@ public VariantTypeElementContext variantTypeElement() { VariantTypeElementContext _localctx = new VariantTypeElementContext(Context, State); EnterRule(_localctx, 136, RULE_variantTypeElement); try { - State = 1608; + State = 1634; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case NULL: EnterOuterAlt(_localctx, 1); { - State = 1528; + State = 1554; _localctx.value = Match(NULL); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6917,7 +6981,7 @@ public VariantTypeElementContext variantTypeElement() { case VARIANT: EnterOuterAlt(_localctx, 2); { - State = 1530; + State = 1556; _localctx.value = Match(VARIANT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6925,7 +6989,7 @@ public VariantTypeElementContext variantTypeElement() { case CURRENCY: EnterOuterAlt(_localctx, 3); { - State = 1532; + State = 1558; _localctx.value = Match(CURRENCY); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6933,7 +6997,7 @@ public VariantTypeElementContext variantTypeElement() { case VOID: EnterOuterAlt(_localctx, 4); { - State = 1534; + State = 1560; _localctx.value = Match(VOID); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6941,7 +7005,7 @@ public VariantTypeElementContext variantTypeElement() { case BOOL: EnterOuterAlt(_localctx, 5); { - State = 1536; + State = 1562; _localctx.value = Match(BOOL); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6949,7 +7013,7 @@ public VariantTypeElementContext variantTypeElement() { case INT8: EnterOuterAlt(_localctx, 6); { - State = 1538; + State = 1564; _localctx.value = Match(INT8); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6957,7 +7021,7 @@ public VariantTypeElementContext variantTypeElement() { case INT16: EnterOuterAlt(_localctx, 7); { - State = 1540; + State = 1566; _localctx.value = Match(INT16); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6965,7 +7029,7 @@ public VariantTypeElementContext variantTypeElement() { case INT32_: EnterOuterAlt(_localctx, 8); { - State = 1542; + State = 1568; _localctx.value = Match(INT32_); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6973,7 +7037,7 @@ public VariantTypeElementContext variantTypeElement() { case INT64_: EnterOuterAlt(_localctx, 9); { - State = 1544; + State = 1570; _localctx.value = Match(INT64_); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6981,7 +7045,7 @@ public VariantTypeElementContext variantTypeElement() { case FLOAT32: EnterOuterAlt(_localctx, 10); { - State = 1546; + State = 1572; _localctx.value = Match(FLOAT32); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6989,7 +7053,7 @@ public VariantTypeElementContext variantTypeElement() { case FLOAT64_: EnterOuterAlt(_localctx, 11); { - State = 1548; + State = 1574; _localctx.value = Match(FLOAT64_); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6997,7 +7061,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT8: EnterOuterAlt(_localctx, 12); { - State = 1550; + State = 1576; _localctx.value = Match(UINT8); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7005,7 +7069,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT16: EnterOuterAlt(_localctx, 13); { - State = 1552; + State = 1578; _localctx.value = Match(UINT16); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7013,7 +7077,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT32: EnterOuterAlt(_localctx, 14); { - State = 1554; + State = 1580; _localctx.value = Match(UINT32); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7021,7 +7085,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT64: EnterOuterAlt(_localctx, 15); { - State = 1556; + State = 1582; _localctx.value = Match(UINT64); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7029,7 +7093,7 @@ public VariantTypeElementContext variantTypeElement() { case PTR: EnterOuterAlt(_localctx, 16); { - State = 1558; + State = 1584; _localctx.value = Match(PTR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7037,7 +7101,7 @@ public VariantTypeElementContext variantTypeElement() { case DECIMAL: EnterOuterAlt(_localctx, 17); { - State = 1560; + State = 1586; _localctx.value = Match(DECIMAL); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7045,7 +7109,7 @@ public VariantTypeElementContext variantTypeElement() { case DATE: EnterOuterAlt(_localctx, 18); { - State = 1562; + State = 1588; _localctx.value = Match(DATE); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7053,7 +7117,7 @@ public VariantTypeElementContext variantTypeElement() { case BSTR: EnterOuterAlt(_localctx, 19); { - State = 1564; + State = 1590; _localctx.value = Match(BSTR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7061,7 +7125,7 @@ public VariantTypeElementContext variantTypeElement() { case LPSTR: EnterOuterAlt(_localctx, 20); { - State = 1566; + State = 1592; _localctx.value = Match(LPSTR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7069,7 +7133,7 @@ public VariantTypeElementContext variantTypeElement() { case LPWSTR: EnterOuterAlt(_localctx, 21); { - State = 1568; + State = 1594; _localctx.value = Match(LPWSTR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7077,7 +7141,7 @@ public VariantTypeElementContext variantTypeElement() { case IUNKNOWN: EnterOuterAlt(_localctx, 22); { - State = 1570; + State = 1596; _localctx.value = Match(IUNKNOWN); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7085,7 +7149,7 @@ public VariantTypeElementContext variantTypeElement() { case IDISPATCH: EnterOuterAlt(_localctx, 23); { - State = 1572; + State = 1598; _localctx.value = Match(IDISPATCH); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7093,7 +7157,7 @@ public VariantTypeElementContext variantTypeElement() { case SAFEARRAY: EnterOuterAlt(_localctx, 24); { - State = 1574; + State = 1600; _localctx.value = Match(SAFEARRAY); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7101,7 +7165,7 @@ public VariantTypeElementContext variantTypeElement() { case INT: EnterOuterAlt(_localctx, 25); { - State = 1576; + State = 1602; _localctx.value = Match(INT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7109,7 +7173,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT: EnterOuterAlt(_localctx, 26); { - State = 1578; + State = 1604; _localctx.value = Match(UINT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7117,7 +7181,7 @@ public VariantTypeElementContext variantTypeElement() { case ERROR: EnterOuterAlt(_localctx, 27); { - State = 1580; + State = 1606; _localctx.value = Match(ERROR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7125,7 +7189,7 @@ public VariantTypeElementContext variantTypeElement() { case HRESULT: EnterOuterAlt(_localctx, 28); { - State = 1582; + State = 1608; _localctx.value = Match(HRESULT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7133,7 +7197,7 @@ public VariantTypeElementContext variantTypeElement() { case CARRAY: EnterOuterAlt(_localctx, 29); { - State = 1584; + State = 1610; _localctx.value = Match(CARRAY); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7141,7 +7205,7 @@ public VariantTypeElementContext variantTypeElement() { case USERDEFINED: EnterOuterAlt(_localctx, 30); { - State = 1586; + State = 1612; _localctx.value = Match(USERDEFINED); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7149,7 +7213,7 @@ public VariantTypeElementContext variantTypeElement() { case RECORD: EnterOuterAlt(_localctx, 31); { - State = 1588; + State = 1614; _localctx.value = Match(RECORD); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7157,7 +7221,7 @@ public VariantTypeElementContext variantTypeElement() { case FILETIME: EnterOuterAlt(_localctx, 32); { - State = 1590; + State = 1616; _localctx.value = Match(FILETIME); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7165,7 +7229,7 @@ public VariantTypeElementContext variantTypeElement() { case BLOB: EnterOuterAlt(_localctx, 33); { - State = 1592; + State = 1618; _localctx.value = Match(BLOB); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7173,7 +7237,7 @@ public VariantTypeElementContext variantTypeElement() { case STREAM: EnterOuterAlt(_localctx, 34); { - State = 1594; + State = 1620; _localctx.value = Match(STREAM); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7181,7 +7245,7 @@ public VariantTypeElementContext variantTypeElement() { case STORAGE: EnterOuterAlt(_localctx, 35); { - State = 1596; + State = 1622; _localctx.value = Match(STORAGE); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7189,7 +7253,7 @@ public VariantTypeElementContext variantTypeElement() { case STREAMED_OBJECT: EnterOuterAlt(_localctx, 36); { - State = 1598; + State = 1624; _localctx.value = Match(STREAMED_OBJECT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7197,7 +7261,7 @@ public VariantTypeElementContext variantTypeElement() { case STORED_OBJECT: EnterOuterAlt(_localctx, 37); { - State = 1600; + State = 1626; _localctx.value = Match(STORED_OBJECT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7205,7 +7269,7 @@ public VariantTypeElementContext variantTypeElement() { case BLOB_OBJECT: EnterOuterAlt(_localctx, 38); { - State = 1602; + State = 1628; _localctx.value = Match(BLOB_OBJECT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7213,7 +7277,7 @@ public VariantTypeElementContext variantTypeElement() { case CF: EnterOuterAlt(_localctx, 39); { - State = 1604; + State = 1630; _localctx.value = Match(CF); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7221,7 +7285,7 @@ public VariantTypeElementContext variantTypeElement() { case CLSID: EnterOuterAlt(_localctx, 40); { - State = 1606; + State = 1632; _localctx.value = Match(CLSID); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7276,23 +7340,23 @@ public TypeContext type() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1610; + State = 1636; _localctx.element = elementType(); Actions.SetTypeSignatureElement(_localctx, _localctx.element.Value); - State = 1617; + State = 1643; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,61,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1612; + State = 1638; _localctx.modifier = typeModifiers(); Actions.AddTypeSignatureModifier(_localctx, _localctx.modifier.Value); } } } - State = 1619; + State = 1645; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,61,Context); } @@ -7421,14 +7485,14 @@ public TypeModifiersContext typeModifiers() { TypeModifiersContext _localctx = new TypeModifiersContext(Context, State); EnterRule(_localctx, 140, RULE_typeModifiers); try { - State = 1649; + State = 1675; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,62,Context) ) { case 1: _localctx = new SZArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 1); { - State = 1620; + State = 1646; Match(ARRAY_TYPE_NO_BOUNDS); _localctx.Value = Actions.CreateSzArrayTypeModifier(); } @@ -7437,9 +7501,9 @@ public TypeModifiersContext typeModifiers() { _localctx = new SZArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 2); { - State = 1622; + State = 1648; Match(T__41); - State = 1623; + State = 1649; Match(T__42); _localctx.Value = Actions.CreateSzArrayTypeModifier(); } @@ -7448,7 +7512,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new ArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 3); { - State = 1625; + State = 1651; ((ArrayModifierContext)_localctx).arrayBounds = bounds(); _localctx.Value = Actions.CreateArrayTypeModifier(((ArrayModifierContext)_localctx).arrayBounds.Value); } @@ -7457,7 +7521,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new ByRefModifierContext(_localctx); EnterOuterAlt(_localctx, 4); { - State = 1628; + State = 1654; Match(REF); _localctx.Value = Actions.CreateByReferenceTypeModifier(); } @@ -7466,7 +7530,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new PtrModifierContext(_localctx); EnterOuterAlt(_localctx, 5); { - State = 1630; + State = 1656; Match(PTR); _localctx.Value = Actions.CreatePointerTypeModifier(); } @@ -7475,7 +7539,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new PinnedModifierContext(_localctx); EnterOuterAlt(_localctx, 6); { - State = 1632; + State = 1658; Match(T__91); _localctx.Value = Actions.CreatePinnedTypeModifier(); } @@ -7484,13 +7548,13 @@ public TypeModifiersContext typeModifiers() { _localctx = new RequiredModifierContext(_localctx); EnterOuterAlt(_localctx, 7); { - State = 1634; + State = 1660; Match(T__92); - State = 1635; + State = 1661; Match(T__29); - State = 1636; + State = 1662; ((RequiredModifierContext)_localctx).modifierType = typeSpec(); - State = 1637; + State = 1663; Match(T__30); _localctx.Value = Actions.CreateCustomTypeModifier(((RequiredModifierContext)_localctx).modifierType.Value, true); } @@ -7499,13 +7563,13 @@ public TypeModifiersContext typeModifiers() { _localctx = new OptionalModifierContext(_localctx); EnterOuterAlt(_localctx, 8); { - State = 1640; + State = 1666; Match(T__93); - State = 1641; + State = 1667; Match(T__29); - State = 1642; + State = 1668; ((OptionalModifierContext)_localctx).modifierType = typeSpec(); - State = 1643; + State = 1669; Match(T__30); _localctx.Value = Actions.CreateCustomTypeModifier(((OptionalModifierContext)_localctx).modifierType.Value, false); } @@ -7514,7 +7578,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new GenericArgumentsModifierContext(_localctx); EnterOuterAlt(_localctx, 9); { - State = 1646; + State = 1672; ((GenericArgumentsModifierContext)_localctx).arguments = typeArgs(); _localctx.Value = Actions.CreateGenericArgumentsModifier(((GenericArgumentsModifierContext)_localctx).arguments.Value); } @@ -7602,15 +7666,15 @@ public ElementTypeContext elementType() { ElementTypeContext _localctx = new ElementTypeContext(Context, State); EnterRule(_localctx, 142, RULE_elementType); try { - State = 1709; + State = 1735; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,63,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1651; + State = 1677; Match(T__38); - State = 1652; + State = 1678; _localctx.classType = className(); _localctx.Value = Actions.CreateClassElementType(_localctx.classType.Value, false); } @@ -7618,7 +7682,7 @@ public ElementTypeContext elementType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1655; + State = 1681; Match(OBJECT); _localctx.Value = Actions.CreateObjectElementType(); } @@ -7626,11 +7690,11 @@ public ElementTypeContext elementType() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1657; + State = 1683; Match(VALUE); - State = 1658; + State = 1684; Match(T__38); - State = 1659; + State = 1685; _localctx.valueClassType = className(); _localctx.Value = Actions.CreateClassElementType(_localctx.valueClassType.Value, true); } @@ -7638,9 +7702,9 @@ public ElementTypeContext elementType() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1662; + State = 1688; Match(VALUETYPE); - State = 1663; + State = 1689; _localctx.valueType = className(); _localctx.Value = Actions.CreateClassElementType(_localctx.valueType.Value, true); } @@ -7648,15 +7712,15 @@ public ElementTypeContext elementType() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1666; + State = 1692; Match(METHOD); - State = 1667; + State = 1693; _localctx.convention = callConv(); - State = 1668; + State = 1694; _localctx.returnType = type(); - State = 1669; + State = 1695; Match(PTR); - State = 1670; + State = 1696; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateFunctionPointerElementType(_localctx.convention.Value, _localctx.returnType.Value, _localctx.arguments.Value); } @@ -7664,9 +7728,9 @@ public ElementTypeContext elementType() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1673; + State = 1699; Match(METHOD_TYPE_PARAMETER); - State = 1674; + State = 1700; _localctx.parameterIndex = int32(); _localctx.Value = Actions.CreateIndexedGenericParameterElementType(true, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null)); } @@ -7674,9 +7738,9 @@ public ElementTypeContext elementType() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1677; + State = 1703; Match(TYPE_PARAMETER); - State = 1678; + State = 1704; _localctx.parameterIndex = int32(); _localctx.Value = Actions.CreateIndexedGenericParameterElementType(false, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null)); } @@ -7684,9 +7748,9 @@ public ElementTypeContext elementType() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1681; + State = 1707; Match(METHOD_TYPE_PARAMETER); - State = 1682; + State = 1708; _localctx.parameterName = dottedName(); _localctx.Value = Actions.CreateNamedGenericParameterElementType(_localctx.Start, true, _localctx.parameterName.Value); } @@ -7694,9 +7758,9 @@ public ElementTypeContext elementType() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1685; + State = 1711; Match(TYPE_PARAMETER); - State = 1686; + State = 1712; _localctx.parameterName = dottedName(); _localctx.Value = Actions.CreateNamedGenericParameterElementType(_localctx.Start, false, _localctx.parameterName.Value); } @@ -7704,7 +7768,7 @@ public ElementTypeContext elementType() { case 10: EnterOuterAlt(_localctx, 10); { - State = 1689; + State = 1715; Match(TYPEDREF); _localctx.Value = Actions.CreateTypedReferenceElementType(); } @@ -7712,7 +7776,7 @@ public ElementTypeContext elementType() { case 11: EnterOuterAlt(_localctx, 11); { - State = 1691; + State = 1717; Match(VOID); _localctx.Value = Actions.CreateVoidElementType(); } @@ -7720,7 +7784,7 @@ public ElementTypeContext elementType() { case 12: EnterOuterAlt(_localctx, 12); { - State = 1693; + State = 1719; _localctx.signedNative = nativeInt(); _localctx.Value = Actions.CreatePrimitiveElementType(_localctx.signedNative.Value); } @@ -7728,7 +7792,7 @@ public ElementTypeContext elementType() { case 13: EnterOuterAlt(_localctx, 13); { - State = 1696; + State = 1722; _localctx.unsignedNative = nativeUint(); _localctx.Value = Actions.CreatePrimitiveElementType(_localctx.unsignedNative.Value); } @@ -7736,7 +7800,7 @@ public ElementTypeContext elementType() { case 14: EnterOuterAlt(_localctx, 14); { - State = 1699; + State = 1725; _localctx.primitive = simpleType(); _localctx.Value = Actions.CreatePrimitiveElementType(_localctx.primitive.Value); } @@ -7744,7 +7808,7 @@ public ElementTypeContext elementType() { case 15: EnterOuterAlt(_localctx, 15); { - State = 1702; + State = 1728; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateTypedefElementType(_localctx.Start, _localctx.alias.Value); } @@ -7752,9 +7816,9 @@ public ElementTypeContext elementType() { case 16: EnterOuterAlt(_localctx, 16); { - State = 1705; + State = 1731; Match(ELLIPSIS); - State = 1706; + State = 1732; _localctx.sentinelType = type(); _localctx.Value = Actions.CreateSentinelElementType(_localctx.sentinelType.Value); } @@ -7806,13 +7870,13 @@ public SimpleTypeContext simpleType() { SimpleTypeContext _localctx = new SimpleTypeContext(Context, State); EnterRule(_localctx, 144, RULE_simpleType); try { - State = 1749; + State = 1775; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,64,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1711; + State = 1737; _localctx.value = Match(CHAR); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7820,7 +7884,7 @@ public SimpleTypeContext simpleType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1713; + State = 1739; _localctx.value = Match(STRING); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7828,7 +7892,7 @@ public SimpleTypeContext simpleType() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1715; + State = 1741; _localctx.value = Match(BOOL); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7836,7 +7900,7 @@ public SimpleTypeContext simpleType() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1717; + State = 1743; _localctx.value = Match(INT8); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7844,7 +7908,7 @@ public SimpleTypeContext simpleType() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1719; + State = 1745; _localctx.value = Match(INT16); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7852,7 +7916,7 @@ public SimpleTypeContext simpleType() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1721; + State = 1747; _localctx.value = Match(INT32_); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7860,7 +7924,7 @@ public SimpleTypeContext simpleType() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1723; + State = 1749; _localctx.value = Match(INT64_); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7868,7 +7932,7 @@ public SimpleTypeContext simpleType() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1725; + State = 1751; _localctx.value = Match(FLOAT32); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7876,7 +7940,7 @@ public SimpleTypeContext simpleType() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1727; + State = 1753; _localctx.value = Match(FLOAT64_); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7884,7 +7948,7 @@ public SimpleTypeContext simpleType() { case 10: EnterOuterAlt(_localctx, 10); { - State = 1729; + State = 1755; _localctx.value = Match(UINT8); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7892,7 +7956,7 @@ public SimpleTypeContext simpleType() { case 11: EnterOuterAlt(_localctx, 11); { - State = 1731; + State = 1757; _localctx.value = Match(UINT16); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7900,7 +7964,7 @@ public SimpleTypeContext simpleType() { case 12: EnterOuterAlt(_localctx, 12); { - State = 1733; + State = 1759; _localctx.value = Match(UINT32); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7908,7 +7972,7 @@ public SimpleTypeContext simpleType() { case 13: EnterOuterAlt(_localctx, 13); { - State = 1735; + State = 1761; _localctx.value = Match(UINT64); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7916,9 +7980,9 @@ public SimpleTypeContext simpleType() { case 14: EnterOuterAlt(_localctx, 14); { - State = 1737; + State = 1763; Match(T__89); - State = 1738; + State = 1764; _localctx.value = Match(INT8); _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } @@ -7926,9 +7990,9 @@ public SimpleTypeContext simpleType() { case 15: EnterOuterAlt(_localctx, 15); { - State = 1740; + State = 1766; Match(T__89); - State = 1741; + State = 1767; _localctx.value = Match(INT16); _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } @@ -7936,9 +8000,9 @@ public SimpleTypeContext simpleType() { case 16: EnterOuterAlt(_localctx, 16); { - State = 1743; + State = 1769; Match(T__89); - State = 1744; + State = 1770; _localctx.value = Match(INT32_); _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } @@ -7946,9 +8010,9 @@ public SimpleTypeContext simpleType() { case 17: EnterOuterAlt(_localctx, 17); { - State = 1746; + State = 1772; Match(T__89); - State = 1747; + State = 1773; _localctx.value = Match(INT64_); _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } @@ -8000,7 +8064,7 @@ public BoundContext bound() { EnterRule(_localctx, 146, RULE_bound); Actions.InitializeBound(_localctx); try { - State = 1765; + State = 1791; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,65,Context) ) { case 1: @@ -8011,14 +8075,14 @@ public BoundContext bound() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1752; + State = 1778; Match(ELLIPSIS); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1753; + State = 1779; _localctx.size = int32(); Actions.SetBoundSize(_localctx, (_localctx.size!=null?(_localctx.size.Start):null)); } @@ -8026,11 +8090,11 @@ public BoundContext bound() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1756; + State = 1782; _localctx.lower = int32(); - State = 1757; + State = 1783; Match(ELLIPSIS); - State = 1758; + State = 1784; _localctx.upper = int32(); Actions.SetBoundRange(_localctx, (_localctx.lower!=null?(_localctx.lower.Start):null), (_localctx.upper!=null?(_localctx.upper.Start):null)); } @@ -8038,9 +8102,9 @@ public BoundContext bound() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1761; + State = 1787; _localctx.lower = int32(); - State = 1762; + State = 1788; Match(ELLIPSIS); Actions.SetBoundLower(_localctx, (_localctx.lower!=null?(_localctx.lower.Start):null)); } @@ -8081,9 +8145,9 @@ public NativeIntContext nativeInt() { try { EnterOuterAlt(_localctx, 1); { - State = 1767; + State = 1793; Match(T__0); - State = 1768; + State = 1794; Match(INT); _localctx.Value = Actions.GetNativeIntType(); } @@ -8123,22 +8187,22 @@ public NativeUintContext nativeUint() { try { EnterOuterAlt(_localctx, 1); { - State = 1771; + State = 1797; Match(T__0); - State = 1775; + State = 1801; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__89: { - State = 1772; + State = 1798; Match(T__89); - State = 1773; + State = 1799; Match(INT); } break; case UINT: { - State = 1774; + State = 1800; Match(UINT); } break; @@ -8204,125 +8268,125 @@ public SecDeclContext secDecl() { BeginSubtree(); Actions.BeginSemanticRoot(_localctx); int _la; try { - State = 1826; + State = 1852; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,68,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1779; + State = 1805; Match(PERMISSION); - State = 1780; + State = 1806; secAction(); - State = 1781; + State = 1807; typeSpec(); - State = 1782; + State = 1808; Match(T__29); - State = 1783; + State = 1809; nameValPairs(); - State = 1784; + State = 1810; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1786; + State = 1812; Match(PERMISSION); - State = 1787; + State = 1813; secAction(); - State = 1788; + State = 1814; typeSpec(); - State = 1789; + State = 1815; Match(T__35); - State = 1790; + State = 1816; Match(T__16); - State = 1791; + State = 1817; customBlobDescr(); - State = 1792; + State = 1818; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1794; + State = 1820; Match(PERMISSION); - State = 1795; + State = 1821; secAction(); - State = 1796; + State = 1822; typeSpec(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1798; + State = 1824; Match(PERMISSIONSET); - State = 1799; + State = 1825; secAction(); - State = 1800; + State = 1826; Match(T__35); - State = 1802; + State = 1828; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__83) { { - State = 1801; + State = 1827; Match(T__83); } } - State = 1804; + State = 1830; Match(T__29); - State = 1805; + State = 1831; bytes(); - State = 1806; + State = 1832; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1808; + State = 1834; Match(PERMISSIONSET); - State = 1809; + State = 1835; secAction(); - State = 1810; + State = 1836; Match(T__83); - State = 1811; + State = 1837; Match(T__29); - State = 1812; + State = 1838; bytes(); - State = 1813; + State = 1839; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1815; + State = 1841; Match(PERMISSIONSET); - State = 1816; + State = 1842; secAction(); - State = 1817; + State = 1843; compQstring(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1819; + State = 1845; Match(PERMISSIONSET); - State = 1820; + State = 1846; secAction(); - State = 1821; + State = 1847; Match(T__35); - State = 1822; + State = 1848; Match(T__16); - State = 1823; + State = 1849; secAttrSetBlob(); - State = 1824; + State = 1850; Match(T__17); } break; @@ -8366,7 +8430,7 @@ public SecAttrSetBlobContext secAttrSetBlob() { EnterRule(_localctx, 154, RULE_secAttrSetBlob); try { int _alt; - State = 1838; + State = 1864; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__17: @@ -8411,25 +8475,25 @@ public SecAttrSetBlobContext secAttrSetBlob() { case ID: EnterOuterAlt(_localctx, 2); { - State = 1834; + State = 1860; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,69,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1829; + State = 1855; secAttrBlob(); - State = 1830; + State = 1856; Match(T__27); } } } - State = 1836; + State = 1862; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,69,Context); } - State = 1837; + State = 1863; secAttrBlob(); } break; @@ -8474,38 +8538,38 @@ public SecAttrBlobContext secAttrBlob() { SecAttrBlobContext _localctx = new SecAttrBlobContext(Context, State); EnterRule(_localctx, 156, RULE_secAttrBlob); try { - State = 1853; + State = 1879; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,71,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1840; + State = 1866; Match(T__38); - State = 1841; + State = 1867; Match(SQSTRING); - State = 1842; + State = 1868; Match(T__35); - State = 1843; + State = 1869; Match(T__16); - State = 1844; + State = 1870; customBlobNVPairs(); - State = 1845; + State = 1871; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1847; + State = 1873; typeSpec(); - State = 1848; + State = 1874; Match(T__35); - State = 1849; + State = 1875; Match(T__16); - State = 1850; + State = 1876; customBlobNVPairs(); - State = 1851; + State = 1877; Match(T__17); } break; @@ -8550,25 +8614,25 @@ public NameValPairsContext nameValPairs() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1860; + State = 1886; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,72,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1855; + State = 1881; nameValPair(); - State = 1856; + State = 1882; Match(T__27); } } } - State = 1862; + State = 1888; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,72,Context); } - State = 1863; + State = 1889; nameValPair(); } } @@ -8610,11 +8674,11 @@ public NameValPairContext nameValPair() { try { EnterOuterAlt(_localctx, 1); { - State = 1865; + State = 1891; compQstring(); - State = 1866; + State = 1892; Match(T__35); - State = 1867; + State = 1893; caValue(); } } @@ -8630,6 +8694,7 @@ public NameValPairContext nameValPair() { } public partial class TruefalseContext : ParserRuleContext { + public bool Value; public TruefalseContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { @@ -8651,7 +8716,7 @@ public TruefalseContext truefalse() { try { EnterOuterAlt(_localctx, 1); { - State = 1869; + State = 1895; _la = TokenStream.LA(1); if ( !(_la==T__94 || _la==T__95) ) { ErrorHandler.RecoverInline(this); @@ -8661,6 +8726,8 @@ public TruefalseContext truefalse() { Consume(); } } + Context.Stop = TokenStream.LT(-1); + _localctx.Value = Actions.ParseBoolean(_localctx.Start); } catch (RecognitionException re) { _localctx.exception = re; @@ -8707,104 +8774,104 @@ public CaValueContext caValue() { CaValueContext _localctx = new CaValueContext(Context, State); EnterRule(_localctx, 164, RULE_caValue); try { - State = 1905; + State = 1931; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,73,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1871; + State = 1897; truefalse(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1872; + State = 1898; int32(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1873; + State = 1899; Match(INT32_); - State = 1874; + State = 1900; Match(T__29); - State = 1875; + State = 1901; int32(); - State = 1876; + State = 1902; Match(T__30); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1878; + State = 1904; compQstring(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1879; + State = 1905; className(); - State = 1880; + State = 1906; Match(T__29); - State = 1881; + State = 1907; Match(INT8); - State = 1882; + State = 1908; Match(T__74); - State = 1883; + State = 1909; int32(); - State = 1884; + State = 1910; Match(T__30); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1886; + State = 1912; className(); - State = 1887; + State = 1913; Match(T__29); - State = 1888; + State = 1914; Match(INT16); - State = 1889; + State = 1915; Match(T__74); - State = 1890; + State = 1916; int32(); - State = 1891; + State = 1917; Match(T__30); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1893; + State = 1919; className(); - State = 1894; + State = 1920; Match(T__29); - State = 1895; + State = 1921; Match(INT32_); - State = 1896; + State = 1922; Match(T__74); - State = 1897; + State = 1923; int32(); - State = 1898; + State = 1924; Match(T__30); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1900; + State = 1926; className(); - State = 1901; + State = 1927; Match(T__29); - State = 1902; + State = 1928; int32(); - State = 1903; + State = 1929; Match(T__30); } break; @@ -8843,7 +8910,7 @@ public SecActionContext secAction() { try { EnterOuterAlt(_localctx, 1); { - State = 1907; + State = 1933; _la = TokenStream.LA(1); if ( !(((((_la - 97)) & ~0x3f) == 0 && ((1L << (_la - 97)) & 32767L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -8925,33 +8992,33 @@ public MethodRefContext methodRef() { Actions.BeginSemanticRoot(_localctx); int _la; try { - State = 1951; + State = 1977; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,76,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1909; + State = 1935; _localctx.convention = callConv(); - State = 1910; + State = 1936; _localctx.returnType = type(); - State = 1911; + State = 1937; _localctx.owner = typeSpec(); - State = 1912; + State = 1938; Match(DCOLON); - State = 1913; + State = 1939; _localctx.name = methodName(); - State = 1915; + State = 1941; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 1914; + State = 1940; _localctx.genericArguments = typeArgs(); } } - State = 1917; + State = 1943; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, _localctx.owner.Value, _localctx.name.Value, _localctx.genericArguments, null, _localctx.arguments.Value); } @@ -8959,19 +9026,19 @@ public MethodRefContext methodRef() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1920; + State = 1946; _localctx.convention = callConv(); - State = 1921; + State = 1947; _localctx.returnType = type(); - State = 1922; + State = 1948; _localctx.owner = typeSpec(); - State = 1923; + State = 1949; Match(DCOLON); - State = 1924; + State = 1950; _localctx.name = methodName(); - State = 1925; + State = 1951; _localctx.genericArity = genArityNotEmpty(); - State = 1926; + State = 1952; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, _localctx.owner.Value, _localctx.name.Value, null, _localctx.genericArity.Value, _localctx.arguments.Value); } @@ -8979,23 +9046,23 @@ public MethodRefContext methodRef() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1929; + State = 1955; _localctx.convention = callConv(); - State = 1930; + State = 1956; _localctx.returnType = type(); - State = 1931; + State = 1957; _localctx.name = methodName(); - State = 1933; + State = 1959; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 1932; + State = 1958; _localctx.genericArguments = typeArgs(); } } - State = 1935; + State = 1961; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, null, _localctx.name.Value, _localctx.genericArguments, null, _localctx.arguments.Value); } @@ -9003,15 +9070,15 @@ public MethodRefContext methodRef() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1938; + State = 1964; _localctx.convention = callConv(); - State = 1939; + State = 1965; _localctx.returnType = type(); - State = 1940; + State = 1966; _localctx.name = methodName(); - State = 1941; + State = 1967; _localctx.genericArity = genArityNotEmpty(); - State = 1942; + State = 1968; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, null, _localctx.name.Value, null, _localctx.genericArity.Value, _localctx.arguments.Value); } @@ -9019,7 +9086,7 @@ public MethodRefContext methodRef() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1945; + State = 1971; _localctx.token = mdtoken(); _localctx.Value = Actions.CreateTokenMethodReference(_localctx.token.Value); } @@ -9027,7 +9094,7 @@ public MethodRefContext methodRef() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1948; + State = 1974; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateTypedefMethodReference(_localctx.Start, _localctx.alias.Value); } @@ -9080,15 +9147,15 @@ public CallConvContext callConv() { CallConvContext _localctx = new CallConvContext(Context, State); EnterRule(_localctx, 170, RULE_callConv); try { - State = 1970; + State = 1996; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,77,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1953; + State = 1979; Match(INSTANCE); - State = 1954; + State = 1980; _localctx.inner = callConv(); _localctx.Value = Actions.AddInstanceCallingConvention(_localctx.inner.Value); } @@ -9096,9 +9163,9 @@ public CallConvContext callConv() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1957; + State = 1983; Match(EXPLICIT); - State = 1958; + State = 1984; _localctx.inner = callConv(); _localctx.Value = Actions.AddExplicitCallingConvention(_localctx.inner.Value); } @@ -9106,7 +9173,7 @@ public CallConvContext callConv() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1961; + State = 1987; _localctx.kind = callKind(); _localctx.Value = _localctx.kind.Value; } @@ -9114,13 +9181,13 @@ public CallConvContext callConv() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1964; + State = 1990; Match(T__111); - State = 1965; + State = 1991; Match(T__29); - State = 1966; + State = 1992; _localctx.raw = int32(); - State = 1967; + State = 1993; Match(T__30); _localctx.Value = Actions.GetRawCallingConvention((_localctx.raw!=null?(_localctx.raw.Start):null)); } @@ -9167,7 +9234,7 @@ public CallKindContext callKind() { EnterRule(_localctx, 172, RULE_callKind); _localctx.Value = Actions.GetDefaultCallingConvention(); try { - State = 1991; + State = 2017; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,78,Context) ) { case 1: @@ -9178,7 +9245,7 @@ public CallKindContext callKind() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1973; + State = 1999; _localctx.kind = Match(DEFAULT); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9186,7 +9253,7 @@ public CallKindContext callKind() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1975; + State = 2001; _localctx.kind = Match(VARARG); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9194,9 +9261,9 @@ public CallKindContext callKind() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1977; + State = 2003; Match(UNMANAGED); - State = 1978; + State = 2004; _localctx.kind = Match(CDECL); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9204,9 +9271,9 @@ public CallKindContext callKind() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1980; + State = 2006; Match(UNMANAGED); - State = 1981; + State = 2007; _localctx.kind = Match(STDCALL); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9214,9 +9281,9 @@ public CallKindContext callKind() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1983; + State = 2009; Match(UNMANAGED); - State = 1984; + State = 2010; _localctx.kind = Match(THISCALL); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9224,9 +9291,9 @@ public CallKindContext callKind() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1986; + State = 2012; Match(UNMANAGED); - State = 1987; + State = 2013; _localctx.kind = Match(FASTCALL); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9234,7 +9301,7 @@ public CallKindContext callKind() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1989; + State = 2015; _localctx.kind = Match(UNMANAGED); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9280,13 +9347,13 @@ public MdtokenContext mdtoken() { try { EnterOuterAlt(_localctx, 1); { - State = 1993; + State = 2019; Match(T__112); - State = 1994; + State = 2020; Match(T__29); - State = 1995; + State = 2021; _localctx.token = int32(); - State = 1996; + State = 2022; Match(T__30); _localctx.Value = Actions.ParseInt32((_localctx.token!=null?(_localctx.token.Start):null)); } @@ -9336,15 +9403,15 @@ public MemberRefContext memberRef() { MemberRefContext _localctx = new MemberRefContext(Context, State); EnterRule(_localctx, 176, RULE_memberRef); try { - State = 2010; + State = 2036; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case METHOD: EnterOuterAlt(_localctx, 1); { - State = 1999; + State = 2025; Match(METHOD); - State = 2000; + State = 2026; _localctx.method = methodRef(); _localctx.Value = Actions.CreateMethodMemberReference(_localctx.method.Value); } @@ -9352,9 +9419,9 @@ public MemberRefContext memberRef() { case T__36: EnterOuterAlt(_localctx, 2); { - State = 2003; + State = 2029; Match(T__36); - State = 2004; + State = 2030; _localctx.field = fieldRef(); _localctx.Value = Actions.CreateFieldMemberReference(_localctx.field.Value); } @@ -9362,7 +9429,7 @@ public MemberRefContext memberRef() { case T__112: EnterOuterAlt(_localctx, 3); { - State = 2007; + State = 2033; _localctx.token = mdtoken(); _localctx.Value = Actions.CreateTokenMemberReference(_localctx.token.Value); } @@ -9418,19 +9485,19 @@ public FieldRefContext fieldRef() { EnterRule(_localctx, 178, RULE_fieldRef); Actions.BeginSemanticRoot(_localctx); try { - State = 2025; + State = 2051; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,80,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2012; + State = 2038; _localctx.fieldType = type(); - State = 2013; + State = 2039; _localctx.owner = typeSpec(); - State = 2014; + State = 2040; Match(DCOLON); - State = 2015; + State = 2041; _localctx.name = dottedName(); _localctx.Value = Actions.CreateFieldReference(_localctx.fieldType.Value, _localctx.owner.Value, _localctx.name.Value); } @@ -9438,9 +9505,9 @@ public FieldRefContext fieldRef() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2018; + State = 2044; _localctx.fieldType = type(); - State = 2019; + State = 2045; _localctx.name = dottedName(); _localctx.Value = Actions.CreateFieldReference(_localctx.fieldType.Value, null, _localctx.name.Value); } @@ -9448,7 +9515,7 @@ public FieldRefContext fieldRef() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2022; + State = 2048; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateTypedefFieldReference(_localctx.Start, _localctx.alias.Value); } @@ -9499,26 +9566,26 @@ public TypeListContext typeList() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 2033; + State = 2059; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,81,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2027; + State = 2053; _localctx.item = typeSpec(); Actions.AddGenericType(_localctx, _localctx.item.Value); - State = 2029; + State = 2055; Match(T__27); } } } - State = 2035; + State = 2061; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,81,Context); } - State = 2036; + State = 2062; _localctx.tail = typeSpec(); Actions.AddGenericType(_localctx, _localctx.tail.Value); } @@ -9560,7 +9627,7 @@ public TyparsClauseContext typarsClause() { EnterRule(_localctx, 182, RULE_typarsClause); _localctx.Value = Actions.CreateEmptyGenericParameterList(); try { - State = 2045; + State = 2071; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -9575,11 +9642,11 @@ public TyparsClauseContext typarsClause() { case T__85: EnterOuterAlt(_localctx, 2); { - State = 2040; + State = 2066; Match(T__85); - State = 2041; + State = 2067; _localctx.parameters = typars(); - State = 2042; + State = 2068; Match(T__86); _localctx.Value = _localctx.parameters.Value; } @@ -9631,13 +9698,13 @@ public TyparAttribContext typarAttrib() { TyparAttribContext _localctx = new TyparAttribContext(Context, State); EnterRule(_localctx, 184, RULE_typarAttrib); try { - State = 2065; + State = 2091; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case PLUS: EnterOuterAlt(_localctx, 1); { - State = 2047; + State = 2073; _localctx.covariant = Match(PLUS); _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.covariant); } @@ -9645,7 +9712,7 @@ public TyparAttribContext typarAttrib() { case T__113: EnterOuterAlt(_localctx, 2); { - State = 2049; + State = 2075; _localctx.contravariant = Match(T__113); _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.contravariant); } @@ -9653,7 +9720,7 @@ public TyparAttribContext typarAttrib() { case T__38: EnterOuterAlt(_localctx, 3); { - State = 2051; + State = 2077; _localctx.@class = Match(T__38); _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.@class); } @@ -9661,7 +9728,7 @@ public TyparAttribContext typarAttrib() { case VALUETYPE: EnterOuterAlt(_localctx, 4); { - State = 2053; + State = 2079; _localctx.valuetype = Match(VALUETYPE); _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.valuetype); } @@ -9669,7 +9736,7 @@ public TyparAttribContext typarAttrib() { case T__114: EnterOuterAlt(_localctx, 5); { - State = 2055; + State = 2081; _localctx.byrefLike = Match(T__114); _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.byrefLike); } @@ -9677,7 +9744,7 @@ public TyparAttribContext typarAttrib() { case T__115: EnterOuterAlt(_localctx, 6); { - State = 2057; + State = 2083; _localctx.ctor = Match(T__115); _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.ctor); } @@ -9685,13 +9752,13 @@ public TyparAttribContext typarAttrib() { case T__69: EnterOuterAlt(_localctx, 7); { - State = 2059; + State = 2085; Match(T__69); - State = 2060; + State = 2086; Match(T__29); - State = 2061; + State = 2087; _localctx.flags = int32(); - State = 2062; + State = 2088; Match(T__30); _localctx.Value = Actions.CreateRawGenericParameterAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } @@ -9742,18 +9809,18 @@ public TyparAttribsContext typarAttribs() { try { EnterOuterAlt(_localctx, 1); { - State = 2072; + State = 2098; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__38 || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & 123145302310913L) != 0) || _la==VALUETYPE || _la==PLUS) { { { - State = 2067; + State = 2093; _localctx.attribute = typarAttrib(); Actions.AddGenericParameterAttribute(_localctx, _localctx.attribute.Value); } } - State = 2074; + State = 2100; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -9806,19 +9873,19 @@ public TyparContext typar() { try { EnterOuterAlt(_localctx, 1); { - State = 2075; + State = 2101; _localctx.attributes = typarAttribs(); - State = 2077; + State = 2103; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__29) { { - State = 2076; + State = 2102; _localctx.constraints = tyBound(); } } - State = 2079; + State = 2105; _localctx.name = dottedName(); _localctx.Value = Actions.CreateGenericParameterDeclaration(_localctx.attributes.Value, _localctx.constraints, _localctx.name.Value); } @@ -9866,26 +9933,26 @@ public TyparsContext typars() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 2088; + State = 2114; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,86,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2082; + State = 2108; _localctx.parameter = typar(); Actions.AddGenericParameter(_localctx, _localctx.parameter.Value); - State = 2084; + State = 2110; Match(T__27); } } } - State = 2090; + State = 2116; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,86,Context); } - State = 2091; + State = 2117; _localctx.tail = typar(); Actions.AddGenericParameter(_localctx, _localctx.tail.Value); } @@ -9928,11 +9995,11 @@ public TyBoundContext tyBound() { try { EnterOuterAlt(_localctx, 1); { - State = 2094; + State = 2120; Match(T__29); - State = 2095; + State = 2121; _localctx.constraints = typeList(); - State = 2096; + State = 2122; Match(T__30); _localctx.Value = _localctx.constraints.Value; } @@ -9975,12 +10042,12 @@ public GenArityContext genArity() { try { EnterOuterAlt(_localctx, 1); { - State = 2100; + State = 2126; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 2099; + State = 2125; _localctx.value = genArityNotEmpty(); } } @@ -10025,15 +10092,15 @@ public GenArityNotEmptyContext genArityNotEmpty() { try { EnterOuterAlt(_localctx, 1); { - State = 2104; + State = 2130; Match(T__85); - State = 2105; + State = 2131; Match(T__41); - State = 2106; + State = 2132; _localctx.value = int32(); - State = 2107; + State = 2133; Match(T__42); - State = 2108; + State = 2134; Match(T__86); _localctx.Value = Actions.ParseInt32((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -10209,74 +10276,74 @@ public ClassDeclContext classDecl() { BeginStreaming(); try { int _alt; - State = 2261; + State = 2287; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,92,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2111; + State = 2137; methodHead(); - State = 2112; + State = 2138; Match(T__16); - State = 2113; + State = 2139; methodDecls(); - State = 2114; + State = 2140; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2116; + State = 2142; classHead(); - State = 2117; + State = 2143; Match(T__16); - State = 2118; + State = 2144; classDecls(); - State = 2119; + State = 2145; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2121; + State = 2147; _localctx.eventHeader = eventHead(); Actions.BeginEvent(_localctx, _localctx.eventHeader.Value); - State = 2123; + State = 2149; Match(T__16); - State = 2124; + State = 2150; eventDecls(); - State = 2125; + State = 2151; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2127; + State = 2153; _localctx.property = propHead(); Actions.BeginProperty(_localctx, _localctx.property.Value); - State = 2129; + State = 2155; Match(T__16); - State = 2130; + State = 2156; propDecls(); - State = 2131; + State = 2157; Match(T__17); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2133; + State = 2159; fieldDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2134; + State = 2160; _localctx.data = dataDecl(); Actions.ProcessClassDataDeclaration(_localctx.data); } @@ -10284,7 +10351,7 @@ public ClassDeclContext classDecl() { case 7: EnterOuterAlt(_localctx, 7); { - State = 2137; + State = 2163; _localctx.security = secDecl(); Actions.ProcessClassSecurityDeclaration(_localctx.security); } @@ -10292,7 +10359,7 @@ public ClassDeclContext classDecl() { case 8: EnterOuterAlt(_localctx, 8); { - State = 2140; + State = 2166; _localctx.source = extSourceSpec(); Actions.ProcessClassSourceDirective(_localctx.source); } @@ -10300,7 +10367,7 @@ public ClassDeclContext classDecl() { case 9: EnterOuterAlt(_localctx, 9); { - State = 2143; + State = 2169; _localctx.attribute = customAttrDecl(); Actions.ProcessClassCustomAttribute(_localctx.attribute); } @@ -10308,9 +10375,9 @@ public ClassDeclContext classDecl() { case 10: EnterOuterAlt(_localctx, 10); { - State = 2146; + State = 2172; Match(T__116); - State = 2147; + State = 2173; _localctx.size = int32(); Actions.SetClassSize((_localctx.size!=null?(_localctx.size.Start):null)); } @@ -10318,9 +10385,9 @@ public ClassDeclContext classDecl() { case 11: EnterOuterAlt(_localctx, 11); { - State = 2150; + State = 2176; Match(T__117); - State = 2151; + State = 2177; _localctx.packing = int32(); Actions.SetClassPackingSize((_localctx.packing!=null?(_localctx.packing.Start):null)); } @@ -10328,13 +10395,13 @@ public ClassDeclContext classDecl() { case 12: EnterOuterAlt(_localctx, 12); { - State = 2154; + State = 2180; _localctx.export = exportHead(); - State = 2155; + State = 2181; Match(T__16); - State = 2156; + State = 2182; _localctx.exportDeclarations = exptypeDecls(); - State = 2157; + State = 2183; Match(T__17); Actions.ProcessClassExport(_localctx.export, _localctx.exportDeclarations); } @@ -10342,27 +10409,27 @@ public ClassDeclContext classDecl() { case 13: EnterOuterAlt(_localctx, 13); { - State = 2160; + State = 2186; Match(OVERRIDE); - State = 2161; + State = 2187; _localctx.declarationOwner = typeSpec(); - State = 2162; + State = 2188; Match(DCOLON); - State = 2163; + State = 2189; _localctx.declarationName = methodName(); - State = 2164; + State = 2190; Match(T__118); - State = 2165; + State = 2191; _localctx.bodyConvention = callConv(); - State = 2166; + State = 2192; _localctx.bodyReturnType = type(); - State = 2167; + State = 2193; _localctx.bodyOwner = typeSpec(); - State = 2168; + State = 2194; Match(DCOLON); - State = 2169; + State = 2195; _localctx.bodyName = methodName(); - State = 2170; + State = 2196; _localctx.bodyArguments = sigArgs(); Actions.AddClassMethodOverride( _localctx, @@ -10378,41 +10445,41 @@ public ClassDeclContext classDecl() { case 14: EnterOuterAlt(_localctx, 14); { - State = 2173; + State = 2199; Match(OVERRIDE); - State = 2174; + State = 2200; Match(METHOD); - State = 2175; + State = 2201; _localctx.declarationConvention = callConv(); - State = 2176; + State = 2202; _localctx.declarationReturnType = type(); - State = 2177; + State = 2203; _localctx.declarationOwner = typeSpec(); - State = 2178; + State = 2204; Match(DCOLON); - State = 2179; + State = 2205; _localctx.declarationName = methodName(); - State = 2180; + State = 2206; _localctx.declarationArity = genArity(); - State = 2181; + State = 2207; _localctx.declarationArguments = sigArgs(); - State = 2182; + State = 2208; Match(T__118); - State = 2183; + State = 2209; Match(METHOD); - State = 2184; + State = 2210; _localctx.bodyConvention = callConv(); - State = 2185; + State = 2211; _localctx.bodyReturnType = type(); - State = 2186; + State = 2212; _localctx.bodyOwner = typeSpec(); - State = 2187; + State = 2213; Match(DCOLON); - State = 2188; + State = 2214; _localctx.bodyName = methodName(); - State = 2189; + State = 2215; _localctx.bodyArity = genArity(); - State = 2190; + State = 2216; _localctx.bodyArguments = sigArgs(); Actions.AddClassMethodOverride( _localctx, @@ -10433,7 +10500,7 @@ public ClassDeclContext classDecl() { case 15: EnterOuterAlt(_localctx, 15); { - State = 2193; + State = 2219; _localctx.language = languageDecl(); Actions.ProcessClassLanguageDirective(_localctx.language); } @@ -10441,7 +10508,7 @@ public ClassDeclContext classDecl() { case 16: EnterOuterAlt(_localctx, 16); { - State = 2196; + State = 2222; compControl(); Actions.ProcessClassCompilerControl(); } @@ -10449,31 +10516,31 @@ public ClassDeclContext classDecl() { case 17: EnterOuterAlt(_localctx, 17); { - State = 2199; + State = 2225; Match(PARAM); - State = 2200; + State = 2226; Match(TYPE); - State = 2201; + State = 2227; Match(T__41); - State = 2202; + State = 2228; _localctx.parameterIndex = int32(); - State = 2203; + State = 2229; Match(T__42); Actions.BeginClassGenericParameterDirective(_localctx, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null)); - State = 2210; + State = 2236; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2205; + State = 2231; _localctx.attribute = customAttrDecl(); Actions.AddClassGenericDirectiveAttribute(_localctx, _localctx.attribute); } } } - State = 2212; + State = 2238; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); } @@ -10482,27 +10549,27 @@ public ClassDeclContext classDecl() { case 18: EnterOuterAlt(_localctx, 18); { - State = 2213; + State = 2239; Match(PARAM); - State = 2214; + State = 2240; Match(TYPE); - State = 2215; + State = 2241; _localctx.parameterName = dottedName(); Actions.BeginClassGenericParameterDirective(_localctx, _localctx.parameterName.Value); - State = 2222; + State = 2248; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2217; + State = 2243; _localctx.attribute = customAttrDecl(); Actions.AddClassGenericDirectiveAttribute(_localctx, _localctx.attribute); } } } - State = 2224; + State = 2250; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); } @@ -10511,35 +10578,35 @@ public ClassDeclContext classDecl() { case 19: EnterOuterAlt(_localctx, 19); { - State = 2225; + State = 2251; Match(PARAM); - State = 2226; + State = 2252; Match(CONSTRAINT); - State = 2227; + State = 2253; Match(T__41); - State = 2228; + State = 2254; _localctx.parameterIndex = int32(); - State = 2229; + State = 2255; Match(T__42); - State = 2230; + State = 2256; Match(T__27); - State = 2231; + State = 2257; _localctx.constraintType = typeSpec(); Actions.BeginClassGenericConstraintDirective(_localctx, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null), _localctx.constraintType.Value); - State = 2238; + State = 2264; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2233; + State = 2259; _localctx.attribute = customAttrDecl(); Actions.AddClassGenericDirectiveAttribute(_localctx, _localctx.attribute); } } } - State = 2240; + State = 2266; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); } @@ -10548,31 +10615,31 @@ public ClassDeclContext classDecl() { case 20: EnterOuterAlt(_localctx, 20); { - State = 2241; + State = 2267; Match(PARAM); - State = 2242; + State = 2268; Match(CONSTRAINT); - State = 2243; + State = 2269; _localctx.parameterName = dottedName(); - State = 2244; + State = 2270; Match(T__27); - State = 2245; + State = 2271; _localctx.constraintType = typeSpec(); Actions.BeginClassGenericConstraintDirective(_localctx, _localctx.parameterName.Value, _localctx.constraintType.Value); - State = 2252; + State = 2278; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2247; + State = 2273; _localctx.attribute = customAttrDecl(); Actions.AddClassGenericDirectiveAttribute(_localctx, _localctx.attribute); } } } - State = 2254; + State = 2280; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); } @@ -10581,13 +10648,13 @@ public ClassDeclContext classDecl() { case 21: EnterOuterAlt(_localctx, 21); { - State = 2255; + State = 2281; Match(T__119); - State = 2256; + State = 2282; Match(TYPE); - State = 2257; + State = 2283; _localctx.interfaceType = typeSpec(); - State = 2258; + State = 2284; _localctx.interfaceAttribute = customDescr(); Actions.AddInterfaceImplementationAttribute(_localctx, _localctx.interfaceType.Value, _localctx.interfaceAttribute); } @@ -10664,17 +10731,17 @@ public FieldDeclContext fieldDecl() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 2263; + State = 2289; Match(T__120); - State = 2264; + State = 2290; _localctx.offset = repeatOpt(); - State = 2276; + State = 2302; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,94,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { - State = 2274; + State = 2300; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -10693,20 +10760,20 @@ public FieldDeclContext fieldDecl() { case T__125: case T__126: { - State = 2265; + State = 2291; _localctx.attribute = fieldAttr(); Actions.AddFieldAttribute(_localctx, _localctx.attribute.Value); } break; case T__121: { - State = 2268; + State = 2294; Match(T__121); - State = 2269; + State = 2295; Match(T__29); - State = 2270; + State = 2296; _localctx.marshalling = marshalBlob(); - State = 2271; + State = 2297; Match(T__30); Actions.SetFieldMarshalling(_localctx, _localctx.marshalling.Value); } @@ -10716,17 +10783,17 @@ public FieldDeclContext fieldDecl() { } } } - State = 2278; + State = 2304; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,94,Context); } - State = 2279; + State = 2305; _localctx.fieldType = type(); - State = 2280; + State = 2306; _localctx.name = dottedName(); - State = 2281; + State = 2307; _localctx.data = atOpt(); - State = 2282; + State = 2308; _localctx.initializer = initOpt(); _localctx.Value = Actions.CreateFieldDeclaration( _localctx, @@ -10776,13 +10843,13 @@ public FieldAttrContext fieldAttr() { FieldAttrContext _localctx = new FieldAttrContext(Context, State); EnterRule(_localctx, 202, RULE_fieldAttr); try { - State = 2319; + State = 2345; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__122: EnterOuterAlt(_localctx, 1); { - State = 2285; + State = 2311; _localctx.attribute = Match(T__122); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10790,7 +10857,7 @@ public FieldAttrContext fieldAttr() { case T__50: EnterOuterAlt(_localctx, 2); { - State = 2287; + State = 2313; _localctx.attribute = Match(T__50); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10798,7 +10865,7 @@ public FieldAttrContext fieldAttr() { case T__51: EnterOuterAlt(_localctx, 3); { - State = 2289; + State = 2315; _localctx.attribute = Match(T__51); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10806,7 +10873,7 @@ public FieldAttrContext fieldAttr() { case T__62: EnterOuterAlt(_localctx, 4); { - State = 2291; + State = 2317; _localctx.attribute = Match(T__62); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10814,7 +10881,7 @@ public FieldAttrContext fieldAttr() { case T__123: EnterOuterAlt(_localctx, 5); { - State = 2293; + State = 2319; _localctx.attribute = Match(T__123); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10822,7 +10889,7 @@ public FieldAttrContext fieldAttr() { case T__68: EnterOuterAlt(_localctx, 6); { - State = 2295; + State = 2321; _localctx.attribute = Match(T__68); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10830,7 +10897,7 @@ public FieldAttrContext fieldAttr() { case T__67: EnterOuterAlt(_localctx, 7); { - State = 2297; + State = 2323; _localctx.attribute = Match(T__67); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10838,7 +10905,7 @@ public FieldAttrContext fieldAttr() { case T__63: EnterOuterAlt(_localctx, 8); { - State = 2299; + State = 2325; _localctx.attribute = Match(T__63); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10846,7 +10913,7 @@ public FieldAttrContext fieldAttr() { case T__64: EnterOuterAlt(_localctx, 9); { - State = 2301; + State = 2327; _localctx.attribute = Match(T__64); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10854,7 +10921,7 @@ public FieldAttrContext fieldAttr() { case T__65: EnterOuterAlt(_localctx, 10); { - State = 2303; + State = 2329; _localctx.attribute = Match(T__65); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10862,7 +10929,7 @@ public FieldAttrContext fieldAttr() { case T__124: EnterOuterAlt(_localctx, 11); { - State = 2305; + State = 2331; _localctx.attribute = Match(T__124); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10870,7 +10937,7 @@ public FieldAttrContext fieldAttr() { case T__125: EnterOuterAlt(_localctx, 12); { - State = 2307; + State = 2333; _localctx.attribute = Match(T__125); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10878,7 +10945,7 @@ public FieldAttrContext fieldAttr() { case T__126: EnterOuterAlt(_localctx, 13); { - State = 2309; + State = 2335; _localctx.attribute = Match(T__126); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10886,7 +10953,7 @@ public FieldAttrContext fieldAttr() { case T__15: EnterOuterAlt(_localctx, 14); { - State = 2311; + State = 2337; _localctx.attribute = Match(T__15); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10894,13 +10961,13 @@ public FieldAttrContext fieldAttr() { case T__69: EnterOuterAlt(_localctx, 15); { - State = 2313; + State = 2339; Match(T__69); - State = 2314; + State = 2340; Match(T__29); - State = 2315; + State = 2341; _localctx.flags = int32(); - State = 2316; + State = 2342; Match(T__30); _localctx.Value = Actions.CreateRawFieldAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } @@ -10948,7 +11015,7 @@ public AtOptContext atOpt() { AtOptContext _localctx = new AtOptContext(Context, State); EnterRule(_localctx, 204, RULE_atOpt); try { - State = 2330; + State = 2356; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,96,Context) ) { case 1: @@ -10959,9 +11026,9 @@ public AtOptContext atOpt() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2322; + State = 2348; Match(T__43); - State = 2323; + State = 2349; _localctx.name = id(); _localctx.Value = Actions.GetFieldDataName((_localctx.name!=null?(_localctx.name.Start):null)); } @@ -10969,9 +11036,9 @@ public AtOptContext atOpt() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2326; + State = 2352; Match(T__43); - State = 2327; + State = 2353; _localctx.offset = int32(); _localctx.Value = Actions.GetFieldDataOffset((_localctx.offset!=null?(_localctx.offset.Start):null)); } @@ -11013,9 +11080,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { public InitOptContext initOpt() { InitOptContext _localctx = new InitOptContext(Context, State); EnterRule(_localctx, 206, RULE_initOpt); - BeginSubtree(); Actions.BeginFieldInitializer(_localctx); + Actions.BeginFieldInitializer(_localctx); try { - State = 2337; + State = 2363; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -11109,11 +11176,11 @@ public InitOptContext initOpt() { case T__35: EnterOuterAlt(_localctx, 2); { - State = 2333; + State = 2359; Match(T__35); - State = 2334; + State = 2360; _localctx.initializer = fieldInit(); - Actions.SetFieldInitializer(_localctx, _localctx.initializer); + Actions.SetFieldInitializer(_localctx, _localctx.initializer.Value); } break; default: @@ -11126,7 +11193,7 @@ public InitOptContext initOpt() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndFieldInitializer(_localctx); EndParseTreeMode(); + _localctx.HasSyntaxError = Actions.EndFieldInitializer(_localctx); ExitRule(); } return _localctx; @@ -11157,7 +11224,7 @@ public RepeatOptContext repeatOpt() { RepeatOptContext _localctx = new RepeatOptContext(Context, State); EnterRule(_localctx, 208, RULE_repeatOpt); try { - State = 2345; + State = 2371; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -11212,11 +11279,11 @@ public RepeatOptContext repeatOpt() { case T__41: EnterOuterAlt(_localctx, 2); { - State = 2340; + State = 2366; Match(T__41); - State = 2341; + State = 2367; _localctx.offset = int32(); - State = 2342; + State = 2368; Match(T__42); Actions.SetFieldOffset(_localctx, (_localctx.offset!=null?(_localctx.offset.Start):null)); } @@ -11273,32 +11340,32 @@ public EventHeadContext eventHead() { Actions.BeginEventHeader(_localctx); int _la; try { - State = 2372; + State = 2398; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,101,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2347; + State = 2373; Match(T__127); - State = 2353; + State = 2379; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 2348; + State = 2374; _localctx.attribute = eventAttr(); Actions.AddEventAttribute(_localctx, _localctx.attribute.Value); } } - State = 2355; + State = 2381; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2356; + State = 2382; _localctx.eventType = typeSpec(); - State = 2357; + State = 2383; _localctx.name = dottedName(); _localctx.Value = Actions.CreateEventHeader(_localctx, _localctx.eventType.Value, _localctx.name.Value); } @@ -11306,24 +11373,24 @@ public EventHeadContext eventHead() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2360; + State = 2386; Match(T__127); - State = 2366; + State = 2392; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 2361; + State = 2387; _localctx.attribute = eventAttr(); Actions.AddEventAttribute(_localctx, _localctx.attribute.Value); } } - State = 2368; + State = 2394; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2369; + State = 2395; _localctx.name = dottedName(); _localctx.Value = Actions.CreateEventHeader(_localctx, null, _localctx.name.Value); } @@ -11363,13 +11430,13 @@ public EventAttrContext eventAttr() { EventAttrContext _localctx = new EventAttrContext(Context, State); EnterRule(_localctx, 212, RULE_eventAttr); try { - State = 2378; + State = 2404; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__68: EnterOuterAlt(_localctx, 1); { - State = 2374; + State = 2400; _localctx.attribute = Match(T__68); _localctx.Value = Actions.CreateEventAttribute(_localctx.attribute); } @@ -11377,7 +11444,7 @@ public EventAttrContext eventAttr() { case T__67: EnterOuterAlt(_localctx, 2); { - State = 2376; + State = 2402; _localctx.attribute = Match(T__67); _localctx.Value = Actions.CreateEventAttribute(_localctx.attribute); } @@ -11425,17 +11492,17 @@ public EventDeclsContext eventDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2383; + State = 2409; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38788988928L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 1080863910568919043L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 2380; + State = 2406; eventDecl(); } } - State = 2385; + State = 2411; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11490,15 +11557,15 @@ public EventDeclContext eventDecl() { EventDeclContext _localctx = new EventDeclContext(Context, State); EnterRule(_localctx, 216, RULE_eventDecl); try { - State = 2412; + State = 2438; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__128: EnterOuterAlt(_localctx, 1); { - State = 2386; + State = 2412; Match(T__128); - State = 2387; + State = 2413; _localctx.accessor = methodRef(); Actions.AddEventAdder(_localctx, _localctx.accessor.Value); } @@ -11506,9 +11573,9 @@ public EventDeclContext eventDecl() { case T__129: EnterOuterAlt(_localctx, 2); { - State = 2390; + State = 2416; Match(T__129); - State = 2391; + State = 2417; _localctx.accessor = methodRef(); Actions.AddEventRemover(_localctx, _localctx.accessor.Value); } @@ -11516,9 +11583,9 @@ public EventDeclContext eventDecl() { case T__130: EnterOuterAlt(_localctx, 3); { - State = 2394; + State = 2420; Match(T__130); - State = 2395; + State = 2421; _localctx.accessor = methodRef(); Actions.AddEventRaiser(_localctx, _localctx.accessor.Value); } @@ -11526,9 +11593,9 @@ public EventDeclContext eventDecl() { case T__131: EnterOuterAlt(_localctx, 4); { - State = 2398; + State = 2424; Match(T__131); - State = 2399; + State = 2425; _localctx.accessor = methodRef(); Actions.AddEventOther(_localctx, _localctx.accessor.Value); } @@ -11537,7 +11604,7 @@ public EventDeclContext eventDecl() { case T__73: EnterOuterAlt(_localctx, 5); { - State = 2402; + State = 2428; _localctx.source = extSourceSpec(); Actions.ProcessEventSourceDirective(_localctx.source); } @@ -11551,7 +11618,7 @@ public EventDeclContext eventDecl() { case ID: EnterOuterAlt(_localctx, 6); { - State = 2405; + State = 2431; _localctx.attribute = customAttrDecl(); Actions.AddEventCustomAttribute(_localctx, _localctx.attribute); } @@ -11559,7 +11626,7 @@ public EventDeclContext eventDecl() { case T__26: EnterOuterAlt(_localctx, 7); { - State = 2408; + State = 2434; _localctx.language = languageDecl(); Actions.ProcessEventLanguageDirective(_localctx.language); } @@ -11574,7 +11641,7 @@ public EventDeclContext eventDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 8); { - State = 2411; + State = 2437; compControl(); } break; @@ -11644,32 +11711,32 @@ public PropHeadContext propHead() { try { EnterOuterAlt(_localctx, 1); { - State = 2414; + State = 2440; Match(T__132); - State = 2420; + State = 2446; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 2415; + State = 2441; _localctx.attribute = propAttr(); Actions.AddPropertyAttribute(_localctx, _localctx.attribute.Value); } } - State = 2422; + State = 2448; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2423; + State = 2449; _localctx.convention = callConv(); - State = 2424; + State = 2450; _localctx.propertyType = type(); - State = 2425; + State = 2451; _localctx.name = dottedName(); - State = 2426; + State = 2452; _localctx.arguments = sigArgs(); - State = 2427; + State = 2453; _localctx.initializer = initOpt(); _localctx.Value = Actions.CreatePropertyHeader( _localctx, @@ -11713,13 +11780,13 @@ public PropAttrContext propAttr() { PropAttrContext _localctx = new PropAttrContext(Context, State); EnterRule(_localctx, 220, RULE_propAttr); try { - State = 2434; + State = 2460; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__68: EnterOuterAlt(_localctx, 1); { - State = 2430; + State = 2456; _localctx.attribute = Match(T__68); _localctx.Value = Actions.CreatePropertyAttribute(_localctx.attribute); } @@ -11727,7 +11794,7 @@ public PropAttrContext propAttr() { case T__67: EnterOuterAlt(_localctx, 2); { - State = 2432; + State = 2458; _localctx.attribute = Match(T__67); _localctx.Value = Actions.CreatePropertyAttribute(_localctx.attribute); } @@ -11775,17 +11842,17 @@ public PropDeclsContext propDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2439; + State = 2465; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38788988928L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 7493989779944505347L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 2436; + State = 2462; propDecl(); } } - State = 2441; + State = 2467; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11840,15 +11907,15 @@ public PropDeclContext propDecl() { PropDeclContext _localctx = new PropDeclContext(Context, State); EnterRule(_localctx, 224, RULE_propDecl); try { - State = 2464; + State = 2490; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__133: EnterOuterAlt(_localctx, 1); { - State = 2442; + State = 2468; Match(T__133); - State = 2443; + State = 2469; _localctx.accessor = methodRef(); Actions.AddPropertySetter(_localctx, _localctx.accessor.Value); } @@ -11856,9 +11923,9 @@ public PropDeclContext propDecl() { case T__134: EnterOuterAlt(_localctx, 2); { - State = 2446; + State = 2472; Match(T__134); - State = 2447; + State = 2473; _localctx.accessor = methodRef(); Actions.AddPropertyGetter(_localctx, _localctx.accessor.Value); } @@ -11866,9 +11933,9 @@ public PropDeclContext propDecl() { case T__131: EnterOuterAlt(_localctx, 3); { - State = 2450; + State = 2476; Match(T__131); - State = 2451; + State = 2477; _localctx.accessor = methodRef(); Actions.AddPropertyOther(_localctx, _localctx.accessor.Value); } @@ -11882,7 +11949,7 @@ public PropDeclContext propDecl() { case ID: EnterOuterAlt(_localctx, 4); { - State = 2454; + State = 2480; _localctx.attribute = customAttrDecl(); Actions.AddPropertyCustomAttribute(_localctx, _localctx.attribute); } @@ -11891,7 +11958,7 @@ public PropDeclContext propDecl() { case T__73: EnterOuterAlt(_localctx, 5); { - State = 2457; + State = 2483; _localctx.source = extSourceSpec(); Actions.ProcessPropertySourceDirective(_localctx.source); } @@ -11899,7 +11966,7 @@ public PropDeclContext propDecl() { case T__26: EnterOuterAlt(_localctx, 6); { - State = 2460; + State = 2486; _localctx.language = languageDecl(); Actions.ProcessPropertyLanguageDirective(_localctx.language); } @@ -11914,7 +11981,7 @@ public PropDeclContext propDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 7); { - State = 2463; + State = 2489; compControl(); } break; @@ -11957,7 +12024,7 @@ public MarshalClauseContext marshalClause() { MarshalClauseContext _localctx = new MarshalClauseContext(Context, State); EnterRule(_localctx, 226, RULE_marshalClause); try { - State = 2473; + State = 2499; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -11994,13 +12061,13 @@ public MarshalClauseContext marshalClause() { case T__121: EnterOuterAlt(_localctx, 2); { - State = 2467; + State = 2493; Match(T__121); - State = 2468; + State = 2494; Match(T__29); - State = 2469; + State = 2495; _localctx.value = marshalBlob(); - State = 2470; + State = 2496; Match(T__30); _localctx.Value = Actions.CompleteMarshalClause(_localctx.value.Value); } @@ -12053,7 +12120,7 @@ public MarshalBlobContext marshalBlob() { Actions.BeginMarshalBlob(_localctx); int _la; try { - State = 2488; + State = 2514; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -12108,7 +12175,7 @@ public MarshalBlobContext marshalBlob() { case ID: EnterOuterAlt(_localctx, 1); { - State = 2475; + State = 2501; _localctx.nativeValue = nativeType(); Actions.SetMarshalBlobNativeType(_localctx, _localctx.nativeValue.Value); } @@ -12116,24 +12183,24 @@ public MarshalBlobContext marshalBlob() { case T__16: EnterOuterAlt(_localctx, 2); { - State = 2478; + State = 2504; Match(T__16); - State = 2482; + State = 2508; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2479; + State = 2505; _localctx.rawByte = hexbyte(); Actions.AddMarshalBlobByte(_localctx, _localctx.rawByte.Value); } } - State = 2484; + State = 2510; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( _la==INT32 || _la==ID || _la==HEXBYTE ); - State = 2486; + State = 2512; Match(T__17); } break; @@ -12184,18 +12251,18 @@ public ParamAttrContext paramAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 2495; + State = 2521; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__41) { { { - State = 2490; + State = 2516; _localctx.element = paramAttrElement(); Actions.AddParameterAttribute(_localctx, _localctx.element); } } - State = 2497; + State = 2523; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -12239,17 +12306,17 @@ public ParamAttrElementContext paramAttrElement() { ParamAttrElementContext _localctx = new ParamAttrElementContext(Context, State); EnterRule(_localctx, 232, RULE_paramAttrElement); try { - State = 2515; + State = 2541; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,113,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2498; + State = 2524; Match(T__41); - State = 2499; + State = 2525; _localctx.attribute = Match(T__135); - State = 2500; + State = 2526; Match(T__42); Actions.SetParameterAttributeElement(_localctx, _localctx.attribute); } @@ -12257,11 +12324,11 @@ public ParamAttrElementContext paramAttrElement() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2502; + State = 2528; Match(T__41); - State = 2503; + State = 2529; _localctx.attribute = Match(T__136); - State = 2504; + State = 2530; Match(T__42); Actions.SetParameterAttributeElement(_localctx, _localctx.attribute); } @@ -12269,11 +12336,11 @@ public ParamAttrElementContext paramAttrElement() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2506; + State = 2532; Match(T__41); - State = 2507; + State = 2533; _localctx.attribute = Match(T__137); - State = 2508; + State = 2534; Match(T__42); Actions.SetParameterAttributeElement(_localctx, _localctx.attribute); } @@ -12281,11 +12348,11 @@ public ParamAttrElementContext paramAttrElement() { case 4: EnterOuterAlt(_localctx, 4); { - State = 2510; + State = 2536; Match(T__41); - State = 2511; + State = 2537; _localctx.raw = int32(); - State = 2512; + State = 2538; Match(T__42); Actions.SetRawParameterAttributeElement(_localctx, (_localctx.raw!=null?(_localctx.raw.Start):null)); } @@ -12376,14 +12443,14 @@ public MethodHeadContext methodHead() { try { EnterOuterAlt(_localctx, 1); { - State = 2517; + State = 2543; Match(T__138); - State = 2526; + State = 2552; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & 978955L) != 0) || ((((_la - 123)) & ~0x3f) == 0 && ((1L << (_la - 123)) & 33423365L) != 0)) { { - State = 2524; + State = 2550; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__50: @@ -12406,14 +12473,14 @@ public MethodHeadContext methodHead() { case T__144: case T__145: { - State = 2518; + State = 2544; _localctx.attribute = methAttr(); Actions.AddMethodAttribute(_localctx, _localctx.attribute.Value); } break; case T__146: { - State = 2521; + State = 2547; _localctx.pInvoke = pinvImpl(); Actions.AddPInvoke(_localctx, _localctx.pInvoke.Value); } @@ -12422,36 +12489,36 @@ public MethodHeadContext methodHead() { throw new NoViableAltException(this); } } - State = 2528; + State = 2554; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2529; + State = 2555; _localctx.convention = callConv(); - State = 2530; + State = 2556; _localctx.returnAttributes = paramAttr(); - State = 2531; + State = 2557; _localctx.returnType = type(); - State = 2532; + State = 2558; _localctx.returnMarshalling = marshalClause(); - State = 2533; + State = 2559; _localctx.name = methodName(); - State = 2534; + State = 2560; _localctx.genericParameters = typarsClause(); - State = 2535; + State = 2561; _localctx.arguments = sigArgs(); - State = 2541; + State = 2567; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 32766L) != 0) || _la==T__69 || _la==T__155 || _la==UNMANAGED) { { { - State = 2536; + State = 2562; _localctx.implementation = implAttr(); Actions.AddMethodImplementationAttribute(_localctx, _localctx.implementation.Value); } } - State = 2543; + State = 2569; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -12505,13 +12572,13 @@ public MethAttrContext methAttr() { MethAttrContext _localctx = new MethAttrContext(Context, State); EnterRule(_localctx, 236, RULE_methAttr); try { - State = 2588; + State = 2614; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__122: EnterOuterAlt(_localctx, 1); { - State = 2546; + State = 2572; _localctx.attribute = Match(T__122); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12519,7 +12586,7 @@ public MethAttrContext methAttr() { case T__50: EnterOuterAlt(_localctx, 2); { - State = 2548; + State = 2574; _localctx.attribute = Match(T__50); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12527,7 +12594,7 @@ public MethAttrContext methAttr() { case T__51: EnterOuterAlt(_localctx, 3); { - State = 2550; + State = 2576; _localctx.attribute = Match(T__51); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12535,7 +12602,7 @@ public MethAttrContext methAttr() { case T__62: EnterOuterAlt(_localctx, 4); { - State = 2552; + State = 2578; _localctx.attribute = Match(T__62); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12543,7 +12610,7 @@ public MethAttrContext methAttr() { case T__139: EnterOuterAlt(_localctx, 5); { - State = 2554; + State = 2580; _localctx.attribute = Match(T__139); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12551,7 +12618,7 @@ public MethAttrContext methAttr() { case T__67: EnterOuterAlt(_localctx, 6); { - State = 2556; + State = 2582; _localctx.attribute = Match(T__67); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12559,7 +12626,7 @@ public MethAttrContext methAttr() { case T__140: EnterOuterAlt(_localctx, 7); { - State = 2558; + State = 2584; _localctx.attribute = Match(T__140); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12567,7 +12634,7 @@ public MethAttrContext methAttr() { case T__141: EnterOuterAlt(_localctx, 8); { - State = 2560; + State = 2586; _localctx.attribute = Match(T__141); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12575,7 +12642,7 @@ public MethAttrContext methAttr() { case T__53: EnterOuterAlt(_localctx, 9); { - State = 2562; + State = 2588; _localctx.attribute = Match(T__53); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12583,7 +12650,7 @@ public MethAttrContext methAttr() { case T__63: EnterOuterAlt(_localctx, 10); { - State = 2564; + State = 2590; _localctx.attribute = Match(T__63); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12591,7 +12658,7 @@ public MethAttrContext methAttr() { case T__64: EnterOuterAlt(_localctx, 11); { - State = 2566; + State = 2592; _localctx.attribute = Match(T__64); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12599,7 +12666,7 @@ public MethAttrContext methAttr() { case T__65: EnterOuterAlt(_localctx, 12); { - State = 2568; + State = 2594; _localctx.attribute = Match(T__65); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12607,7 +12674,7 @@ public MethAttrContext methAttr() { case T__124: EnterOuterAlt(_localctx, 13); { - State = 2570; + State = 2596; _localctx.attribute = Match(T__124); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12615,7 +12682,7 @@ public MethAttrContext methAttr() { case T__142: EnterOuterAlt(_localctx, 14); { - State = 2572; + State = 2598; _localctx.attribute = Match(T__142); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12623,7 +12690,7 @@ public MethAttrContext methAttr() { case T__143: EnterOuterAlt(_localctx, 15); { - State = 2574; + State = 2600; _localctx.attribute = Match(T__143); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12631,7 +12698,7 @@ public MethAttrContext methAttr() { case T__68: EnterOuterAlt(_localctx, 16); { - State = 2576; + State = 2602; _localctx.attribute = Match(T__68); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12639,7 +12706,7 @@ public MethAttrContext methAttr() { case T__144: EnterOuterAlt(_localctx, 17); { - State = 2578; + State = 2604; _localctx.attribute = Match(T__144); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12647,7 +12714,7 @@ public MethAttrContext methAttr() { case T__145: EnterOuterAlt(_localctx, 18); { - State = 2580; + State = 2606; _localctx.attribute = Match(T__145); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12655,13 +12722,13 @@ public MethAttrContext methAttr() { case T__69: EnterOuterAlt(_localctx, 19); { - State = 2582; + State = 2608; Match(T__69); - State = 2583; + State = 2609; Match(T__29); - State = 2584; + State = 2610; _localctx.flags = int32(); - State = 2585; + State = 2611; Match(T__30); _localctx.Value = Actions.CreateRawMethodAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } @@ -12718,32 +12785,32 @@ public PinvImplContext pinvImpl() { Actions.BeginPInvoke(_localctx); int _la; try { - State = 2613; + State = 2639; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,121,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2590; + State = 2616; Match(T__146); - State = 2591; + State = 2617; Match(T__29); - State = 2600; + State = 2626; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==QSTRING) { { - State = 2592; + State = 2618; _localctx.module = compQstring(); Actions.SetPInvokeModule(_localctx, _localctx.module.Value); - State = 2598; + State = 2624; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__33) { { - State = 2594; + State = 2620; Match(T__33); - State = 2595; + State = 2621; _localctx.entryPoint = compQstring(); Actions.SetPInvokeEntryPoint(_localctx, _localctx.entryPoint.Value); } @@ -12752,31 +12819,31 @@ public PinvImplContext pinvImpl() { } } - State = 2607; + State = 2633; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 57)) & ~0x3f) == 0 && ((1L << (_la - 57)) & 8195L) != 0) || ((((_la - 148)) & ~0x3f) == 0 && ((1L << (_la - 148)) & 79L) != 0) || ((((_la - 224)) & ~0x3f) == 0 && ((1L << (_la - 224)) & 251658241L) != 0)) { { { - State = 2602; + State = 2628; _localctx.attribute = pinvAttr(); Actions.AddPInvokeAttribute(_localctx, _localctx.attribute.Value); } } - State = 2609; + State = 2635; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2610; + State = 2636; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2611; + State = 2637; Match(T__146); - State = 2612; + State = 2638; Match(T__84); } break; @@ -12825,13 +12892,13 @@ public PinvAttrContext pinvAttr() { PinvAttrContext _localctx = new PinvAttrContext(Context, State); EnterRule(_localctx, 240, RULE_pinvAttr); try { - State = 2657; + State = 2683; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,122,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2615; + State = 2641; _localctx.attribute = Match(T__147); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12839,7 +12906,7 @@ public PinvAttrContext pinvAttr() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2617; + State = 2643; _localctx.attribute = Match(ANSI); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12847,7 +12914,7 @@ public PinvAttrContext pinvAttr() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2619; + State = 2645; _localctx.attribute = Match(T__56); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12855,7 +12922,7 @@ public PinvAttrContext pinvAttr() { case 4: EnterOuterAlt(_localctx, 4); { - State = 2621; + State = 2647; _localctx.attribute = Match(T__57); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12863,7 +12930,7 @@ public PinvAttrContext pinvAttr() { case 5: EnterOuterAlt(_localctx, 5); { - State = 2623; + State = 2649; _localctx.attribute = Match(T__148); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12871,7 +12938,7 @@ public PinvAttrContext pinvAttr() { case 6: EnterOuterAlt(_localctx, 6); { - State = 2625; + State = 2651; _localctx.attribute = Match(T__149); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12879,7 +12946,7 @@ public PinvAttrContext pinvAttr() { case 7: EnterOuterAlt(_localctx, 7); { - State = 2627; + State = 2653; _localctx.attribute = Match(CDECL); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12887,7 +12954,7 @@ public PinvAttrContext pinvAttr() { case 8: EnterOuterAlt(_localctx, 8); { - State = 2629; + State = 2655; _localctx.attribute = Match(STDCALL); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12895,7 +12962,7 @@ public PinvAttrContext pinvAttr() { case 9: EnterOuterAlt(_localctx, 9); { - State = 2631; + State = 2657; _localctx.attribute = Match(THISCALL); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12903,7 +12970,7 @@ public PinvAttrContext pinvAttr() { case 10: EnterOuterAlt(_localctx, 10); { - State = 2633; + State = 2659; _localctx.attribute = Match(FASTCALL); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12911,11 +12978,11 @@ public PinvAttrContext pinvAttr() { case 11: EnterOuterAlt(_localctx, 11); { - State = 2635; + State = 2661; Match(T__150); - State = 2636; + State = 2662; Match(T__74); - State = 2637; + State = 2663; _localctx.setting = Match(T__151); _localctx.Value = Actions.CreateBestFitPInvokeAttribute(_localctx.setting); } @@ -12923,11 +12990,11 @@ public PinvAttrContext pinvAttr() { case 12: EnterOuterAlt(_localctx, 12); { - State = 2639; + State = 2665; Match(T__150); - State = 2640; + State = 2666; Match(T__74); - State = 2641; + State = 2667; _localctx.setting = Match(T__152); _localctx.Value = Actions.CreateBestFitPInvokeAttribute(_localctx.setting); } @@ -12935,11 +13002,11 @@ public PinvAttrContext pinvAttr() { case 13: EnterOuterAlt(_localctx, 13); { - State = 2643; + State = 2669; Match(T__153); - State = 2644; + State = 2670; Match(T__74); - State = 2645; + State = 2671; _localctx.setting = Match(T__151); _localctx.Value = Actions.CreateCharMapErrorPInvokeAttribute(_localctx.setting); } @@ -12947,11 +13014,11 @@ public PinvAttrContext pinvAttr() { case 14: EnterOuterAlt(_localctx, 14); { - State = 2647; + State = 2673; Match(T__153); - State = 2648; + State = 2674; Match(T__74); - State = 2649; + State = 2675; _localctx.setting = Match(T__152); _localctx.Value = Actions.CreateCharMapErrorPInvokeAttribute(_localctx.setting); } @@ -12959,13 +13026,13 @@ public PinvAttrContext pinvAttr() { case 15: EnterOuterAlt(_localctx, 15); { - State = 2651; + State = 2677; Match(T__69); - State = 2652; + State = 2678; Match(T__29); - State = 2653; + State = 2679; _localctx.flags = int32(); - State = 2654; + State = 2680; Match(T__30); _localctx.Value = Actions.CreateRawPInvokeAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } @@ -13009,13 +13076,13 @@ public MethodNameContext methodName() { MethodNameContext _localctx = new MethodNameContext(Context, State); EnterRule(_localctx, 242, RULE_methodName); try { - State = 2666; + State = 2692; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__115: EnterOuterAlt(_localctx, 1); { - State = 2659; + State = 2685; _localctx.ctorName = Match(T__115); _localctx.Value = Actions.GetMethodName(_localctx.ctorName); } @@ -13023,7 +13090,7 @@ public MethodNameContext methodName() { case T__154: EnterOuterAlt(_localctx, 2); { - State = 2661; + State = 2687; _localctx.cctorName = Match(T__154); _localctx.Value = Actions.GetMethodName(_localctx.cctorName); } @@ -13036,7 +13103,7 @@ public MethodNameContext methodName() { case ID: EnterOuterAlt(_localctx, 3); { - State = 2663; + State = 2689; _localctx.dotted = dottedName(); _localctx.Value = _localctx.dotted.Value; } @@ -13082,13 +13149,13 @@ public ImplAttrContext implAttr() { ImplAttrContext _localctx = new ImplAttrContext(Context, State); EnterRule(_localctx, 244, RULE_implAttr); try { - State = 2706; + State = 2732; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: EnterOuterAlt(_localctx, 1); { - State = 2668; + State = 2694; _localctx.attribute = Match(T__0); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13096,7 +13163,7 @@ public ImplAttrContext implAttr() { case T__1: EnterOuterAlt(_localctx, 2); { - State = 2670; + State = 2696; _localctx.attribute = Match(T__1); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13104,7 +13171,7 @@ public ImplAttrContext implAttr() { case T__155: EnterOuterAlt(_localctx, 3); { - State = 2672; + State = 2698; _localctx.attribute = Match(T__155); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13112,7 +13179,7 @@ public ImplAttrContext implAttr() { case T__2: EnterOuterAlt(_localctx, 4); { - State = 2674; + State = 2700; _localctx.attribute = Match(T__2); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13120,7 +13187,7 @@ public ImplAttrContext implAttr() { case T__3: EnterOuterAlt(_localctx, 5); { - State = 2676; + State = 2702; _localctx.attribute = Match(T__3); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13128,7 +13195,7 @@ public ImplAttrContext implAttr() { case UNMANAGED: EnterOuterAlt(_localctx, 6); { - State = 2678; + State = 2704; _localctx.attribute = Match(UNMANAGED); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13136,7 +13203,7 @@ public ImplAttrContext implAttr() { case T__4: EnterOuterAlt(_localctx, 7); { - State = 2680; + State = 2706; _localctx.attribute = Match(T__4); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13144,7 +13211,7 @@ public ImplAttrContext implAttr() { case T__5: EnterOuterAlt(_localctx, 8); { - State = 2682; + State = 2708; _localctx.attribute = Match(T__5); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13152,7 +13219,7 @@ public ImplAttrContext implAttr() { case T__6: EnterOuterAlt(_localctx, 9); { - State = 2684; + State = 2710; _localctx.attribute = Match(T__6); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13160,7 +13227,7 @@ public ImplAttrContext implAttr() { case T__7: EnterOuterAlt(_localctx, 10); { - State = 2686; + State = 2712; _localctx.attribute = Match(T__7); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13168,7 +13235,7 @@ public ImplAttrContext implAttr() { case T__8: EnterOuterAlt(_localctx, 11); { - State = 2688; + State = 2714; _localctx.attribute = Match(T__8); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13176,7 +13243,7 @@ public ImplAttrContext implAttr() { case T__9: EnterOuterAlt(_localctx, 12); { - State = 2690; + State = 2716; _localctx.attribute = Match(T__9); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13184,7 +13251,7 @@ public ImplAttrContext implAttr() { case T__10: EnterOuterAlt(_localctx, 13); { - State = 2692; + State = 2718; _localctx.attribute = Match(T__10); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13192,7 +13259,7 @@ public ImplAttrContext implAttr() { case T__11: EnterOuterAlt(_localctx, 14); { - State = 2694; + State = 2720; _localctx.attribute = Match(T__11); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13200,7 +13267,7 @@ public ImplAttrContext implAttr() { case T__12: EnterOuterAlt(_localctx, 15); { - State = 2696; + State = 2722; _localctx.attribute = Match(T__12); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13208,7 +13275,7 @@ public ImplAttrContext implAttr() { case T__13: EnterOuterAlt(_localctx, 16); { - State = 2698; + State = 2724; _localctx.attribute = Match(T__13); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13216,13 +13283,13 @@ public ImplAttrContext implAttr() { case T__69: EnterOuterAlt(_localctx, 17); { - State = 2700; + State = 2726; Match(T__69); - State = 2701; + State = 2727; Match(T__29); - State = 2702; + State = 2728; _localctx.flags = int32(); - State = 2703; + State = 2729; Match(T__30); _localctx.Value = Actions.CreateRawMethodImplementationAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } @@ -13271,17 +13338,17 @@ public MethodDeclsContext methodDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2711; + State = 2737; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38789119998L) != 0) || _la==T__72 || _la==T__73 || ((((_la - 158)) & ~0x3f) == 0 && ((1L << (_la - 158)) & 2199023255681L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 2303696760354115601L) != 0)) { { { - State = 2708; + State = 2734; methodDecl(); } } - State = 2713; + State = 2739; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -13376,7 +13443,7 @@ public MethodDeclContext methodDecl() { MethodDeclContext _localctx = new MethodDeclContext(Context, State); EnterRule(_localctx, 248, RULE_methodDecl); try { - State = 2751; + State = 2777; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case INSTR_NONE: @@ -13394,16 +13461,16 @@ public MethodDeclContext methodDecl() { case INSTR_TOK: EnterOuterAlt(_localctx, 1); { - State = 2714; + State = 2740; instr(); } break; case EMITBYTE: EnterOuterAlt(_localctx, 2); { - State = 2715; + State = 2741; Match(EMITBYTE); - State = 2716; + State = 2742; _localctx.value = int32(); Actions.EmitByte((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -13411,16 +13478,16 @@ public MethodDeclContext methodDecl() { case T__157: EnterOuterAlt(_localctx, 3); { - State = 2719; + State = 2745; sehBlock(); } break; case MAXSTACK: EnterOuterAlt(_localctx, 4); { - State = 2720; + State = 2746; Match(MAXSTACK); - State = 2721; + State = 2747; _localctx.value = int32(); Actions.SetMaxStack((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -13428,7 +13495,7 @@ public MethodDeclContext methodDecl() { case ENTRYPOINT: EnterOuterAlt(_localctx, 5); { - State = 2724; + State = 2750; Match(ENTRYPOINT); Actions.SetEntryPoint(); } @@ -13436,7 +13503,7 @@ public MethodDeclContext methodDecl() { case ZEROINIT: EnterOuterAlt(_localctx, 6); { - State = 2726; + State = 2752; Match(ZEROINIT); Actions.SetZeroInit(); } @@ -13463,28 +13530,28 @@ public MethodDeclContext methodDecl() { case ID: EnterOuterAlt(_localctx, 7); { - State = 2728; + State = 2754; labelDecl(); } break; case T__16: EnterOuterAlt(_localctx, 8); { - State = 2729; + State = 2755; scopeBlock(); } break; case LOCALS: EnterOuterAlt(_localctx, 9); { - State = 2730; + State = 2756; localsDecl(); } break; case T__164: EnterOuterAlt(_localctx, 10); { - State = 2731; + State = 2757; _localctx.declaration = dataDecl(); Actions.ProcessMethodDataDeclaration(_localctx.declaration); } @@ -13493,7 +13560,7 @@ public MethodDeclContext methodDecl() { case PERMISSIONSET: EnterOuterAlt(_localctx, 11); { - State = 2734; + State = 2760; _localctx.security = secDecl(); Actions.ProcessMethodSecurityDeclaration(_localctx.security); } @@ -13502,7 +13569,7 @@ public MethodDeclContext methodDecl() { case T__73: EnterOuterAlt(_localctx, 12); { - State = 2737; + State = 2763; _localctx.source = extSourceSpec(); Actions.ProcessMethodSourceDirective(_localctx.source); } @@ -13510,7 +13577,7 @@ public MethodDeclContext methodDecl() { case T__26: EnterOuterAlt(_localctx, 13); { - State = 2740; + State = 2766; _localctx.language = languageDecl(); Actions.ProcessMethodLanguageDirective(_localctx.language); } @@ -13518,7 +13585,7 @@ public MethodDeclContext methodDecl() { case T__34: EnterOuterAlt(_localctx, 14); { - State = 2743; + State = 2769; _localctx.attribute = customDescrInMethodBody(); Actions.ProcessMethodCustomAttribute(_localctx.attribute); } @@ -13533,35 +13600,35 @@ public MethodDeclContext methodDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 15); { - State = 2746; + State = 2772; compControl(); } break; case EXPORT: EnterOuterAlt(_localctx, 16); { - State = 2747; + State = 2773; exportDecl(); } break; case VTENTRY: EnterOuterAlt(_localctx, 17); { - State = 2748; + State = 2774; vtentryDecl(); } break; case OVERRIDE: EnterOuterAlt(_localctx, 18); { - State = 2749; + State = 2775; overrideDecl(); } break; case PARAM: EnterOuterAlt(_localctx, 19); { - State = 2750; + State = 2776; parameterDecl(); } break; @@ -13609,19 +13676,19 @@ public LocalsDeclContext localsDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2753; + State = 2779; Match(LOCALS); - State = 2755; + State = 2781; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__156) { { - State = 2754; + State = 2780; _localctx.initialize = Match(T__156); } } - State = 2757; + State = 2783; _localctx.arguments = sigArgs(); } } @@ -13669,22 +13736,22 @@ public ExportDeclContext exportDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2759; + State = 2785; Match(EXPORT); - State = 2760; + State = 2786; Match(T__41); - State = 2761; + State = 2787; _localctx.ordinal = int32(); - State = 2762; + State = 2788; Match(T__42); - State = 2765; + State = 2791; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__33) { { - State = 2763; + State = 2789; Match(T__33); - State = 2764; + State = 2790; _localctx.alias = id(); } } @@ -13734,13 +13801,13 @@ public VtentryDeclContext vtentryDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2767; + State = 2793; Match(VTENTRY); - State = 2768; + State = 2794; _localctx.table = int32(); - State = 2769; + State = 2795; Match(T__74); - State = 2770; + State = 2796; _localctx.slot = int32(); } } @@ -13803,42 +13870,42 @@ public OverrideDeclContext overrideDecl() { EnterRule(_localctx, 256, RULE_overrideDecl); Actions.BeginSemanticRoot(_localctx); try { - State = 2787; + State = 2813; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,129,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2772; + State = 2798; Match(OVERRIDE); - State = 2773; + State = 2799; _localctx.owner = typeSpec(); - State = 2774; + State = 2800; Match(DCOLON); - State = 2775; + State = 2801; _localctx.name = methodName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2777; + State = 2803; Match(OVERRIDE); - State = 2778; + State = 2804; Match(METHOD); - State = 2779; + State = 2805; _localctx.convention = callConv(); - State = 2780; + State = 2806; _localctx.returnType = type(); - State = 2781; + State = 2807; _localctx.owner = typeSpec(); - State = 2782; + State = 2808; Match(DCOLON); - State = 2783; + State = 2809; _localctx.name = methodName(); - State = 2784; + State = 2810; _localctx.arity = genArity(); - State = 2785; + State = 2811; _localctx.arguments = sigArgs(); } break; @@ -13906,36 +13973,36 @@ public ParameterDeclContext parameterDecl() { Actions.BeginParameterDirective(_localctx); try { int _alt; - State = 2854; + State = 2880; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,135,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2789; + State = 2815; Match(PARAM); - State = 2790; + State = 2816; Match(TYPE); - State = 2791; + State = 2817; Match(T__41); - State = 2792; + State = 2818; _localctx.genericIndex = int32(); - State = 2793; + State = 2819; Match(T__42); - State = 2799; + State = 2825; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,130,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2794; + State = 2820; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2801; + State = 2827; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,130,Context); } @@ -13944,26 +14011,26 @@ public ParameterDeclContext parameterDecl() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2802; + State = 2828; Match(PARAM); - State = 2803; + State = 2829; Match(TYPE); - State = 2804; + State = 2830; _localctx.genericName = dottedName(); - State = 2810; + State = 2836; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,131,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2805; + State = 2831; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2812; + State = 2838; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,131,Context); } @@ -13972,34 +14039,34 @@ public ParameterDeclContext parameterDecl() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2813; + State = 2839; Match(PARAM); - State = 2814; + State = 2840; Match(CONSTRAINT); - State = 2815; + State = 2841; Match(T__41); - State = 2816; + State = 2842; _localctx.constraintIndex = int32(); - State = 2817; + State = 2843; Match(T__42); - State = 2818; + State = 2844; Match(T__27); - State = 2819; + State = 2845; _localctx.constraintType = typeSpec(); - State = 2825; + State = 2851; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,132,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2820; + State = 2846; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2827; + State = 2853; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,132,Context); } @@ -14008,30 +14075,30 @@ public ParameterDeclContext parameterDecl() { case 4: EnterOuterAlt(_localctx, 4); { - State = 2828; + State = 2854; Match(PARAM); - State = 2829; + State = 2855; Match(CONSTRAINT); - State = 2830; + State = 2856; _localctx.constraintName = dottedName(); - State = 2831; + State = 2857; Match(T__27); - State = 2832; + State = 2858; _localctx.constraintType = typeSpec(); - State = 2838; + State = 2864; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,133,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2833; + State = 2859; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2840; + State = 2866; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,133,Context); } @@ -14040,30 +14107,30 @@ public ParameterDeclContext parameterDecl() { case 5: EnterOuterAlt(_localctx, 5); { - State = 2841; + State = 2867; Match(PARAM); - State = 2842; + State = 2868; Match(T__41); - State = 2843; + State = 2869; _localctx.parameterIndex = int32(); - State = 2844; + State = 2870; Match(T__42); - State = 2845; + State = 2871; _localctx.initializer = initOpt(); - State = 2851; + State = 2877; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,134,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2846; + State = 2872; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2853; + State = 2879; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,134,Context); } @@ -14108,9 +14175,9 @@ public LabelDeclContext labelDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2856; + State = 2882; _localctx.name = id(); - State = 2857; + State = 2883; Match(T__74); Actions.DefineLabel((_localctx.name!=null?(_localctx.name.Start):null)); } @@ -14127,7 +14194,10 @@ public LabelDeclContext labelDecl() { } public partial class CustomDescrInMethodBodyContext : ParserRuleContext { + public object Value; public bool HasSyntaxError; + public CustomDescrContext directAttribute; + public CustomDescrWithOwnerContext ownedAttribute; [System.Diagnostics.DebuggerNonUserCode] public CustomDescrContext customDescr() { return GetRuleContext(0); } @@ -14151,23 +14221,25 @@ public override TResult Accept(IParseTreeVisitor visitor) { public CustomDescrInMethodBodyContext customDescrInMethodBody() { CustomDescrInMethodBodyContext _localctx = new CustomDescrInMethodBodyContext(Context, State); EnterRule(_localctx, 262, RULE_customDescrInMethodBody); - BeginSubtree(); Actions.BeginSemanticRoot(_localctx); + Actions.BeginSemanticRoot(_localctx); try { - State = 2862; + State = 2892; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,136,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2860; - customDescr(); + State = 2886; + _localctx.directAttribute = customDescr(); + _localctx.Value = Actions.CreateCustomAttributeDeclaration(_localctx.directAttribute.Value); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2861; - customDescrWithOwner(); + State = 2889; + _localctx.ownedAttribute = customDescrWithOwner(); + _localctx.Value = Actions.CreateCustomAttributeDeclaration(_localctx.ownedAttribute.Value); } break; } @@ -14178,7 +14250,7 @@ public CustomDescrInMethodBodyContext customDescrInMethodBody() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); ExitRule(); } return _localctx; @@ -14209,11 +14281,11 @@ public ScopeBlockContext scopeBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 2864; + State = 2894; Match(T__16); - State = 2865; + State = 2895; methodDecls(); - State = 2866; + State = 2896; Match(T__17); } } @@ -14259,9 +14331,9 @@ public SehBlockContext sehBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 2868; + State = 2898; _localctx.tryRange = tryBlock(); - State = 2869; + State = 2899; _localctx.clauses = sehClauses(); } } @@ -14308,18 +14380,18 @@ public SehClausesContext sehClauses() { try { EnterOuterAlt(_localctx, 1); { - State = 2874; + State = 2904; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2871; + State = 2901; _localctx.clause = sehClause(); Actions.AddExceptionClause(_localctx, _localctx.clause.Value); } } - State = 2876; + State = 2906; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( ((((_la - 160)) & ~0x3f) == 0 && ((1L << (_la - 160)) & 15L) != 0) ); @@ -14377,15 +14449,15 @@ public TryBlockContext tryBlock() { TryBlockContext _localctx = new TryBlockContext(Context, State); EnterRule(_localctx, 270, RULE_tryBlock); try { - State = 2894; + State = 2924; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,138,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2878; + State = 2908; Match(T__157); - State = 2879; + State = 2909; _localctx.body = scopeBlock(); _localctx.Value = Actions.CreateScopeExceptionRange(_localctx.body); } @@ -14393,13 +14465,13 @@ public TryBlockContext tryBlock() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2882; + State = 2912; Match(T__157); - State = 2883; + State = 2913; _localctx.startLabel = id(); - State = 2884; + State = 2914; Match(T__158); - State = 2885; + State = 2915; _localctx.endLabel = id(); _localctx.Value = Actions.CreateLabelExceptionRange((_localctx.startLabel!=null?(_localctx.startLabel.Start):null), (_localctx.endLabel!=null?(_localctx.endLabel.Start):null)); } @@ -14407,13 +14479,13 @@ public TryBlockContext tryBlock() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2888; + State = 2918; Match(T__157); - State = 2889; + State = 2919; _localctx.startOffset = int32(); - State = 2890; + State = 2920; Match(T__158); - State = 2891; + State = 2921; _localctx.endOffset = int32(); _localctx.Value = Actions.CreateOffsetExceptionRange((_localctx.startOffset!=null?(_localctx.startOffset.Start):null), (_localctx.endOffset!=null?(_localctx.endOffset.Start):null)); } @@ -14469,15 +14541,15 @@ public SehClauseContext sehClause() { SehClauseContext _localctx = new SehClauseContext(Context, State); EnterRule(_localctx, 272, RULE_sehClause); try { - State = 2912; + State = 2942; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__160: EnterOuterAlt(_localctx, 1); { - State = 2896; + State = 2926; _localctx.caught = catchClause(); - State = 2897; + State = 2927; _localctx.handler = handlerBlock(); _localctx.Value = Actions.CreateCatchExceptionClause(_localctx.caught.Value, _localctx.handler.Value); } @@ -14485,9 +14557,9 @@ public SehClauseContext sehClause() { case T__159: EnterOuterAlt(_localctx, 2); { - State = 2900; + State = 2930; _localctx.filtered = filterClause(); - State = 2901; + State = 2931; _localctx.handler = handlerBlock(); _localctx.Value = Actions.CreateFilterExceptionClause(_localctx.filtered.Value, _localctx.handler.Value); } @@ -14495,9 +14567,9 @@ public SehClauseContext sehClause() { case T__161: EnterOuterAlt(_localctx, 3); { - State = 2904; + State = 2934; finallyClause(); - State = 2905; + State = 2935; _localctx.handler = handlerBlock(); _localctx.Value = Actions.CreateFinallyExceptionClause(_localctx.handler.Value); } @@ -14505,9 +14577,9 @@ public SehClauseContext sehClause() { case T__162: EnterOuterAlt(_localctx, 4); { - State = 2908; + State = 2938; faultClause(); - State = 2909; + State = 2939; _localctx.handler = handlerBlock(); _localctx.Value = Actions.CreateFaultExceptionClause(_localctx.handler.Value); } @@ -14559,15 +14631,15 @@ public FilterClauseContext filterClause() { FilterClauseContext _localctx = new FilterClauseContext(Context, State); EnterRule(_localctx, 274, RULE_filterClause); try { - State = 2926; + State = 2956; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,140,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2914; + State = 2944; Match(T__159); - State = 2915; + State = 2945; _localctx.body = scopeBlock(); _localctx.Value = Actions.CreateScopeFilter(_localctx.body); } @@ -14575,9 +14647,9 @@ public FilterClauseContext filterClause() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2918; + State = 2948; Match(T__159); - State = 2919; + State = 2949; _localctx.label = id(); _localctx.Value = Actions.CreateLabelFilter((_localctx.label!=null?(_localctx.label.Start):null)); } @@ -14585,9 +14657,9 @@ public FilterClauseContext filterClause() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2922; + State = 2952; Match(T__159); - State = 2923; + State = 2953; _localctx.offset = int32(); _localctx.Value = Actions.CreateOffsetFilter((_localctx.offset!=null?(_localctx.offset.Start):null)); } @@ -14632,9 +14704,9 @@ public CatchClauseContext catchClause() { try { EnterOuterAlt(_localctx, 1); { - State = 2928; + State = 2958; Match(T__160); - State = 2929; + State = 2959; _localctx.catchType = typeSpec(); } } @@ -14671,7 +14743,7 @@ public FinallyClauseContext finallyClause() { try { EnterOuterAlt(_localctx, 1); { - State = 2931; + State = 2961; Match(T__161); } } @@ -14707,7 +14779,7 @@ public FaultClauseContext faultClause() { try { EnterOuterAlt(_localctx, 1); { - State = 2933; + State = 2963; Match(T__162); } } @@ -14762,13 +14834,13 @@ public HandlerBlockContext handlerBlock() { HandlerBlockContext _localctx = new HandlerBlockContext(Context, State); EnterRule(_localctx, 282, RULE_handlerBlock); try { - State = 2950; + State = 2980; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,141,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2935; + State = 2965; _localctx.body = scopeBlock(); _localctx.Value = Actions.CreateScopeExceptionRange(_localctx.body); } @@ -14776,13 +14848,13 @@ public HandlerBlockContext handlerBlock() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2938; + State = 2968; Match(T__163); - State = 2939; + State = 2969; _localctx.startLabel = id(); - State = 2940; + State = 2970; Match(T__158); - State = 2941; + State = 2971; _localctx.endLabel = id(); _localctx.Value = Actions.CreateLabelExceptionRange((_localctx.startLabel!=null?(_localctx.startLabel.Start):null), (_localctx.endLabel!=null?(_localctx.endLabel.Start):null)); } @@ -14790,13 +14862,13 @@ public HandlerBlockContext handlerBlock() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2944; + State = 2974; Match(T__163); - State = 2945; + State = 2975; _localctx.startOffset = int32(); - State = 2946; + State = 2976; Match(T__158); - State = 2947; + State = 2977; _localctx.endOffset = int32(); _localctx.Value = Actions.CreateOffsetExceptionRange((_localctx.startOffset!=null?(_localctx.startOffset.Start):null), (_localctx.endOffset!=null?(_localctx.endOffset.Start):null)); } @@ -14843,9 +14915,9 @@ public DataDeclContext dataDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2952; + State = 2982; ddHead(); - State = 2953; + State = 2983; ddBody(); } } @@ -14886,28 +14958,28 @@ public DdHeadContext ddHead() { DdHeadContext _localctx = new DdHeadContext(Context, State); EnterRule(_localctx, 286, RULE_ddHead); try { - State = 2962; + State = 2992; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,142,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2955; + State = 2985; Match(T__164); - State = 2956; + State = 2986; tls(); - State = 2957; + State = 2987; id(); - State = 2958; + State = 2988; Match(T__35); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2960; + State = 2990; Match(T__164); - State = 2961; + State = 2991; tls(); } break; @@ -14943,7 +15015,7 @@ public TlsContext tls() { TlsContext _localctx = new TlsContext(Context, State); EnterRule(_localctx, 288, RULE_tls); try { - State = 2967; + State = 2997; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,143,Context) ) { case 1: @@ -14954,14 +15026,14 @@ public TlsContext tls() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2965; + State = 2995; Match(T__165); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2966; + State = 2996; Match(T__1); } break; @@ -15007,17 +15079,17 @@ public DdBodyContext ddBody() { EnterRule(_localctx, 290, RULE_ddBody); int _la; try { - State = 2978; + State = 3008; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: EnterOuterAlt(_localctx, 1); { - State = 2969; + State = 2999; Match(T__16); - State = 2970; + State = 3000; ddItemList(); - State = 2971; + State = 3001; Match(T__17); } break; @@ -15032,17 +15104,17 @@ public DdBodyContext ddBody() { case REF: EnterOuterAlt(_localctx, 2); { - State = 2974; + State = 3004; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2973; + State = 3003; ddItem(); } } - State = 2976; + State = 3006; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( _la==T__83 || ((((_la - 181)) & ~0x3f) == 0 && ((1L << (_la - 181)) & 505L) != 0) || _la==REF ); @@ -15091,25 +15163,25 @@ public DdItemListContext ddItemList() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 2985; + State = 3015; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,146,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2980; + State = 3010; ddItem(); - State = 2981; + State = 3011; Match(T__27); } } } - State = 2987; + State = 3017; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,146,Context); } - State = 2988; + State = 3018; ddItem(); } } @@ -15146,7 +15218,7 @@ public DdItemCountContext ddItemCount() { DdItemCountContext _localctx = new DdItemCountContext(Context, State); EnterRule(_localctx, 294, RULE_ddItemCount); try { - State = 2995; + State = 3025; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -15250,11 +15322,11 @@ public DdItemCountContext ddItemCount() { case T__41: EnterOuterAlt(_localctx, 2); { - State = 2991; + State = 3021; Match(T__41); - State = 2992; + State = 3022; int32(); - State = 2993; + State = 3023; Match(T__42); } break; @@ -15322,200 +15394,200 @@ public DdItemContext ddItem() { DdItemContext _localctx = new DdItemContext(Context, State); EnterRule(_localctx, 296, RULE_ddItem); try { - State = 3063; + State = 3093; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,148,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2997; + State = 3027; Match(CHAR); - State = 2998; + State = 3028; Match(PTR); - State = 2999; + State = 3029; Match(T__29); - State = 3000; + State = 3030; compQstring(); - State = 3001; + State = 3031; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3003; + State = 3033; Match(REF); - State = 3004; + State = 3034; Match(T__29); - State = 3005; + State = 3035; id(); - State = 3006; + State = 3036; Match(T__30); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3008; + State = 3038; Match(REF); - State = 3009; + State = 3039; id(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 3010; + State = 3040; Match(T__83); - State = 3011; + State = 3041; Match(T__29); - State = 3012; + State = 3042; bytes(); - State = 3013; + State = 3043; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 3015; + State = 3045; Match(FLOAT32); - State = 3016; + State = 3046; Match(T__29); - State = 3017; + State = 3047; float64(); - State = 3018; + State = 3048; Match(T__30); - State = 3019; + State = 3049; ddItemCount(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 3021; + State = 3051; Match(FLOAT64_); - State = 3022; + State = 3052; Match(T__29); - State = 3023; + State = 3053; float64(); - State = 3024; + State = 3054; Match(T__30); - State = 3025; + State = 3055; ddItemCount(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 3027; + State = 3057; Match(INT64_); - State = 3028; + State = 3058; Match(T__29); - State = 3029; + State = 3059; int64(); - State = 3030; + State = 3060; Match(T__30); - State = 3031; + State = 3061; ddItemCount(); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 3033; + State = 3063; Match(INT32_); - State = 3034; + State = 3064; Match(T__29); - State = 3035; + State = 3065; int32(); - State = 3036; + State = 3066; Match(T__30); - State = 3037; + State = 3067; ddItemCount(); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 3039; + State = 3069; Match(INT16); - State = 3040; + State = 3070; Match(T__29); - State = 3041; + State = 3071; int32(); - State = 3042; + State = 3072; Match(T__30); - State = 3043; + State = 3073; ddItemCount(); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 3045; + State = 3075; Match(INT8); - State = 3046; + State = 3076; Match(T__29); - State = 3047; + State = 3077; int32(); - State = 3048; + State = 3078; Match(T__30); - State = 3049; + State = 3079; ddItemCount(); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 3051; + State = 3081; Match(FLOAT32); - State = 3052; + State = 3082; ddItemCount(); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 3053; + State = 3083; Match(FLOAT64_); - State = 3054; + State = 3084; ddItemCount(); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 3055; + State = 3085; Match(INT64_); - State = 3056; + State = 3086; ddItemCount(); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 3057; + State = 3087; Match(INT32_); - State = 3058; + State = 3088; ddItemCount(); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 3059; + State = 3089; Match(INT16); - State = 3060; + State = 3090; ddItemCount(); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 3061; + State = 3091; Match(INT8); - State = 3062; + State = 3092; ddItemCount(); } break; @@ -15533,6 +15605,32 @@ public DdItemContext ddItem() { } public partial class FieldSerInitContext : ParserRuleContext { + public System.Reflection.Metadata.BlobBuilder Value; + public Float64Context float32Value; + public Float64Context float64Value; + public Int32Context float32Bits; + public Int64Context float64Bits; + public IToken int64Type; + public Int64Context int64Value; + public IToken int32Type; + public Int32Context int32Value; + public IToken int16Type; + public Int32Context int16Value; + public IToken int8Type; + public Int32Context int8Value; + public IToken uint64Type; + public Int64Context uint64Value; + public IToken uint32Type; + public Int32Context uint32Value; + public IToken uint16Type; + public Int32Context uint16Value; + public IToken uint8Type; + public Int32Context uint8Value; + public IToken charType; + public Int32Context charValue; + public IToken boolType; + public TruefalseContext boolValue; + public BytesContext byteArrayValue; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT32() { return GetToken(CILParser.FLOAT32, 0); } [System.Diagnostics.DebuggerNonUserCode] public Float64Context float64() { return GetRuleContext(0); @@ -15578,202 +15676,217 @@ public FieldSerInitContext fieldSerInit() { FieldSerInitContext _localctx = new FieldSerInitContext(Context, State); EnterRule(_localctx, 298, RULE_fieldSerInit); try { - State = 3140; + State = 3185; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,149,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3065; + State = 3095; Match(FLOAT32); - State = 3066; + State = 3096; Match(T__29); - State = 3067; - float64(); - State = 3068; + State = 3097; + _localctx.float32Value = float64(); + State = 3098; Match(T__30); + _localctx.Value = Actions.CreateFloat32SerializedInitializer(_localctx.float32Value, _localctx.float32Value.Value); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3070; + State = 3101; Match(FLOAT64_); - State = 3071; + State = 3102; Match(T__29); - State = 3072; - float64(); - State = 3073; + State = 3103; + _localctx.float64Value = float64(); + State = 3104; Match(T__30); + _localctx.Value = Actions.CreateFloat64SerializedInitializer(_localctx.float64Value, _localctx.float64Value.Value); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3075; + State = 3107; Match(FLOAT32); - State = 3076; + State = 3108; Match(T__29); - State = 3077; - int32(); - State = 3078; + State = 3109; + _localctx.float32Bits = int32(); + State = 3110; Match(T__30); + _localctx.Value = Actions.CreateFloat32BitsSerializedInitializer((_localctx.float32Bits!=null?(_localctx.float32Bits.Start):null)); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 3080; + State = 3113; Match(FLOAT64_); - State = 3081; + State = 3114; Match(T__29); - State = 3082; - int64(); - State = 3083; + State = 3115; + _localctx.float64Bits = int64(); + State = 3116; Match(T__30); + _localctx.Value = Actions.CreateFloat64BitsSerializedInitializer((_localctx.float64Bits!=null?(_localctx.float64Bits.Start):null)); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 3085; - Match(INT64_); - State = 3086; + State = 3119; + _localctx.int64Type = Match(INT64_); + State = 3120; Match(T__29); - State = 3087; - int64(); - State = 3088; + State = 3121; + _localctx.int64Value = int64(); + State = 3122; Match(T__30); + _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.int64Type, (_localctx.int64Value!=null?(_localctx.int64Value.Start):null)); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 3090; - Match(INT32_); - State = 3091; + State = 3125; + _localctx.int32Type = Match(INT32_); + State = 3126; Match(T__29); - State = 3092; - int32(); - State = 3093; + State = 3127; + _localctx.int32Value = int32(); + State = 3128; Match(T__30); + _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.int32Type, (_localctx.int32Value!=null?(_localctx.int32Value.Start):null)); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 3095; - Match(INT16); - State = 3096; + State = 3131; + _localctx.int16Type = Match(INT16); + State = 3132; Match(T__29); - State = 3097; - int32(); - State = 3098; + State = 3133; + _localctx.int16Value = int32(); + State = 3134; Match(T__30); + _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.int16Type, (_localctx.int16Value!=null?(_localctx.int16Value.Start):null)); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 3100; - Match(INT8); - State = 3101; + State = 3137; + _localctx.int8Type = Match(INT8); + State = 3138; Match(T__29); - State = 3102; - int32(); - State = 3103; + State = 3139; + _localctx.int8Value = int32(); + State = 3140; Match(T__30); + _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.int8Type, (_localctx.int8Value!=null?(_localctx.int8Value.Start):null)); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 3105; - Match(UINT64); - State = 3106; + State = 3143; + _localctx.uint64Type = Match(UINT64); + State = 3144; Match(T__29); - State = 3107; - int64(); - State = 3108; + State = 3145; + _localctx.uint64Value = int64(); + State = 3146; Match(T__30); + _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.uint64Type, (_localctx.uint64Value!=null?(_localctx.uint64Value.Start):null)); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 3110; - Match(UINT32); - State = 3111; + State = 3149; + _localctx.uint32Type = Match(UINT32); + State = 3150; Match(T__29); - State = 3112; - int32(); - State = 3113; + State = 3151; + _localctx.uint32Value = int32(); + State = 3152; Match(T__30); + _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.uint32Type, (_localctx.uint32Value!=null?(_localctx.uint32Value.Start):null)); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 3115; - Match(UINT16); - State = 3116; + State = 3155; + _localctx.uint16Type = Match(UINT16); + State = 3156; Match(T__29); - State = 3117; - int32(); - State = 3118; + State = 3157; + _localctx.uint16Value = int32(); + State = 3158; Match(T__30); + _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.uint16Type, (_localctx.uint16Value!=null?(_localctx.uint16Value.Start):null)); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 3120; - Match(UINT8); - State = 3121; + State = 3161; + _localctx.uint8Type = Match(UINT8); + State = 3162; Match(T__29); - State = 3122; - int32(); - State = 3123; + State = 3163; + _localctx.uint8Value = int32(); + State = 3164; Match(T__30); + _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.uint8Type, (_localctx.uint8Value!=null?(_localctx.uint8Value.Start):null)); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 3125; - Match(CHAR); - State = 3126; + State = 3167; + _localctx.charType = Match(CHAR); + State = 3168; Match(T__29); - State = 3127; - int32(); - State = 3128; + State = 3169; + _localctx.charValue = int32(); + State = 3170; Match(T__30); + _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.charType, (_localctx.charValue!=null?(_localctx.charValue.Start):null)); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 3130; - Match(BOOL); - State = 3131; + State = 3173; + _localctx.boolType = Match(BOOL); + State = 3174; Match(T__29); - State = 3132; - truefalse(); - State = 3133; + State = 3175; + _localctx.boolValue = truefalse(); + State = 3176; Match(T__30); + _localctx.Value = Actions.CreateBooleanSerializedInitializer(_localctx.boolType, _localctx.boolValue.Value); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 3135; + State = 3179; Match(T__83); - State = 3136; + State = 3180; Match(T__29); - State = 3137; - bytes(); - State = 3138; + State = 3181; + _localctx.byteArrayValue = bytes(); + State = 3182; Match(T__30); + _localctx.Value = Actions.CreateByteArraySerializedInitializer(_localctx.byteArrayValue.Value); } break; } @@ -15784,6 +15897,7 @@ public FieldSerInitContext fieldSerInit() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value ??= new System.Reflection.Metadata.BlobBuilder(); ExitRule(); } return _localctx; @@ -15820,18 +15934,18 @@ public BytesContext bytes() { try { EnterOuterAlt(_localctx, 1); { - State = 3147; + State = 3192; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32 || _la==ID || _la==HEXBYTE) { { { - State = 3142; + State = 3187; _localctx.b = hexbyte(); Actions.AddByte(_localctx.b.Value); } } - State = 3149; + State = 3194; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15875,7 +15989,7 @@ public HexbyteContext hexbyte() { try { EnterOuterAlt(_localctx, 1); { - State = 3150; + State = 3195; _la = TokenStream.LA(1); if ( !(_la==INT32 || _la==ID || _la==HEXBYTE) ) { ErrorHandler.RecoverInline(this); @@ -15900,6 +16014,9 @@ public HexbyteContext hexbyte() { } public partial class FieldInitContext : ParserRuleContext { + public object Value; + public FieldSerInitContext serializedValue; + public CompQstringContext stringValue; [System.Diagnostics.DebuggerNonUserCode] public FieldSerInitContext fieldSerInit() { return GetRuleContext(0); } @@ -15925,7 +16042,7 @@ public FieldInitContext fieldInit() { FieldInitContext _localctx = new FieldInitContext(Context, State); EnterRule(_localctx, 304, RULE_fieldInit); try { - State = 3155; + State = 3205; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__83: @@ -15943,22 +16060,25 @@ public FieldInitContext fieldInit() { case UINT64: EnterOuterAlt(_localctx, 1); { - State = 3152; - fieldSerInit(); + State = 3197; + _localctx.serializedValue = fieldSerInit(); + _localctx.Value = Actions.CreateFieldInitializer(_localctx.serializedValue.Value); } break; case QSTRING: EnterOuterAlt(_localctx, 2); { - State = 3153; - compQstring(); + State = 3200; + _localctx.stringValue = compQstring(); + _localctx.Value = Actions.CreateFieldInitializer(_localctx.stringValue.Value); } break; case NULLREF: EnterOuterAlt(_localctx, 3); { - State = 3154; + State = 3203; Match(NULLREF); + _localctx.Value = Actions.CreateNullFieldInitializer(); } break; default: @@ -15977,6 +16097,57 @@ public FieldInitContext fieldInit() { } public partial class SerInitContext : ParserRuleContext { + public object Value; + public FieldSerInitContext scalarValue; + public IToken stringToken; + public IToken typeToken; + public ClassNameContext typeName; + public SerInitContext objectValue; + public IToken f32ElementToken; + public Int32Context f32Length; + public F32seqContext f32Values; + public IToken f64ElementToken; + public Int32Context f64Length; + public F64seqContext f64Values; + public IToken i64ElementToken; + public Int32Context i64Length; + public I64seqContext i64Values; + public IToken i32ElementToken; + public Int32Context i32Length; + public I32seqContext i32Values; + public IToken i16ElementToken; + public Int32Context i16Length; + public I16seqContext i16Values; + public IToken i8ElementToken; + public Int32Context i8Length; + public I8seqContext i8Values; + public IToken u64ElementToken; + public Int32Context u64Length; + public I64seqContext u64Values; + public IToken u32ElementToken; + public Int32Context u32Length; + public I32seqContext u32Values; + public IToken u16ElementToken; + public Int32Context u16Length; + public I16seqContext u16Values; + public IToken u8ElementToken; + public Int32Context u8Length; + public I8seqContext u8Values; + public IToken charElementToken; + public Int32Context charLength; + public I16seqContext charValues; + public IToken boolElementToken; + public Int32Context boolLength; + public BoolSeqContext boolValues; + public IToken stringElementToken; + public Int32Context stringLength; + public SqstringSeqContext stringValues; + public IToken typeElementToken; + public Int32Context typeLength; + public ClassSeqContext typeValues; + public IToken objectElementToken; + public Int32Context objectLength; + public ObjSeqContext objectValues; [System.Diagnostics.DebuggerNonUserCode] public FieldSerInitContext fieldSerInit() { return GetRuleContext(0); } @@ -16054,379 +16225,401 @@ public SerInitContext serInit() { SerInitContext _localctx = new SerInitContext(Context, State); EnterRule(_localctx, 306, RULE_serInit); try { - State = 3305; + State = 3378; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,152,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3157; - fieldSerInit(); + State = 3207; + _localctx.scalarValue = fieldSerInit(); + _localctx.Value = Actions.CreateScalarSerializedValue(_localctx, _localctx.scalarValue, _localctx.scalarValue.Value); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3158; + State = 3210; Match(STRING); - State = 3159; + State = 3211; Match(T__29); - State = 3160; + State = 3212; Match(NULLREF); - State = 3161; + State = 3213; Match(T__30); + _localctx.Value = Actions.CreateStringSerializedValue(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3162; + State = 3215; Match(STRING); - State = 3163; + State = 3216; Match(T__29); - State = 3164; - Match(SQSTRING); - State = 3165; + State = 3217; + _localctx.stringToken = Match(SQSTRING); + State = 3218; Match(T__30); + _localctx.Value = Actions.CreateStringSerializedValue(_localctx.stringToken); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 3166; + State = 3220; Match(TYPE); - State = 3167; + State = 3221; Match(T__29); - State = 3168; + State = 3222; Match(T__38); - State = 3169; - Match(SQSTRING); - State = 3170; + State = 3223; + _localctx.typeToken = Match(SQSTRING); + State = 3224; Match(T__30); + _localctx.Value = Actions.CreateTypeSerializedValue(_localctx.typeToken); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 3171; + State = 3226; Match(TYPE); - State = 3172; + State = 3227; Match(T__29); - State = 3173; - className(); - State = 3174; + State = 3228; + _localctx.typeName = className(); + State = 3229; Match(T__30); + _localctx.Value = Actions.CreateTypeSerializedValue(_localctx.typeName.Value); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 3176; + State = 3232; Match(TYPE); - State = 3177; + State = 3233; Match(T__29); - State = 3178; + State = 3234; Match(NULLREF); - State = 3179; + State = 3235; Match(T__30); + _localctx.Value = Actions.CreateNullTypeSerializedValue(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 3180; + State = 3237; Match(OBJECT); - State = 3181; + State = 3238; Match(T__29); - State = 3182; - serInit(); - State = 3183; + State = 3239; + _localctx.objectValue = serInit(); + State = 3240; Match(T__30); + _localctx.Value = Actions.CreateObjectSerializedValue(_localctx.objectValue.Value); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 3185; - Match(FLOAT32); - State = 3186; + State = 3243; + _localctx.f32ElementToken = Match(FLOAT32); + State = 3244; Match(T__41); - State = 3187; - int32(); - State = 3188; + State = 3245; + _localctx.f32Length = int32(); + State = 3246; Match(T__42); - State = 3189; + State = 3247; Match(T__29); - State = 3190; - f32seq(); - State = 3191; + State = 3248; + _localctx.f32Values = f32seq(); + State = 3249; Match(T__30); + _localctx.Value = Actions.CreateArraySerializedValue(_localctx.f32ElementToken, (_localctx.f32Length!=null?(_localctx.f32Length.Start):null), _localctx.f32Values.Value); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 3193; - Match(FLOAT64_); - State = 3194; + State = 3252; + _localctx.f64ElementToken = Match(FLOAT64_); + State = 3253; Match(T__41); - State = 3195; - int32(); - State = 3196; + State = 3254; + _localctx.f64Length = int32(); + State = 3255; Match(T__42); - State = 3197; + State = 3256; Match(T__29); - State = 3198; - f64seq(); - State = 3199; + State = 3257; + _localctx.f64Values = f64seq(); + State = 3258; Match(T__30); + _localctx.Value = Actions.CreateArraySerializedValue(_localctx.f64ElementToken, (_localctx.f64Length!=null?(_localctx.f64Length.Start):null), _localctx.f64Values.Value); } break; case 10: EnterOuterAlt(_localctx, 10); { - State = 3201; - Match(INT64_); - State = 3202; + State = 3261; + _localctx.i64ElementToken = Match(INT64_); + State = 3262; Match(T__41); - State = 3203; - int32(); - State = 3204; + State = 3263; + _localctx.i64Length = int32(); + State = 3264; Match(T__42); - State = 3205; + State = 3265; Match(T__29); - State = 3206; - i64seq(); - State = 3207; + State = 3266; + _localctx.i64Values = i64seq(); + State = 3267; Match(T__30); + _localctx.Value = Actions.CreateArraySerializedValue(_localctx.i64ElementToken, (_localctx.i64Length!=null?(_localctx.i64Length.Start):null), _localctx.i64Values.Value); } break; case 11: EnterOuterAlt(_localctx, 11); { - State = 3209; - Match(INT32_); - State = 3210; + State = 3270; + _localctx.i32ElementToken = Match(INT32_); + State = 3271; Match(T__41); - State = 3211; - int32(); - State = 3212; + State = 3272; + _localctx.i32Length = int32(); + State = 3273; Match(T__42); - State = 3213; + State = 3274; Match(T__29); - State = 3214; - i32seq(); - State = 3215; + State = 3275; + _localctx.i32Values = i32seq(); + State = 3276; Match(T__30); + _localctx.Value = Actions.CreateArraySerializedValue(_localctx.i32ElementToken, (_localctx.i32Length!=null?(_localctx.i32Length.Start):null), _localctx.i32Values.Value); } break; case 12: EnterOuterAlt(_localctx, 12); { - State = 3217; - Match(INT16); - State = 3218; + State = 3279; + _localctx.i16ElementToken = Match(INT16); + State = 3280; Match(T__41); - State = 3219; - int32(); - State = 3220; + State = 3281; + _localctx.i16Length = int32(); + State = 3282; Match(T__42); - State = 3221; + State = 3283; Match(T__29); - State = 3222; - i16seq(); - State = 3223; + State = 3284; + _localctx.i16Values = i16seq(); + State = 3285; Match(T__30); + _localctx.Value = Actions.CreateArraySerializedValue(_localctx.i16ElementToken, (_localctx.i16Length!=null?(_localctx.i16Length.Start):null), _localctx.i16Values.Value); } break; case 13: EnterOuterAlt(_localctx, 13); { - State = 3225; - Match(INT8); - State = 3226; + State = 3288; + _localctx.i8ElementToken = Match(INT8); + State = 3289; Match(T__41); - State = 3227; - int32(); - State = 3228; + State = 3290; + _localctx.i8Length = int32(); + State = 3291; Match(T__42); - State = 3229; + State = 3292; Match(T__29); - State = 3230; - i8seq(); - State = 3231; + State = 3293; + _localctx.i8Values = i8seq(); + State = 3294; Match(T__30); + _localctx.Value = Actions.CreateArraySerializedValue(_localctx.i8ElementToken, (_localctx.i8Length!=null?(_localctx.i8Length.Start):null), _localctx.i8Values.Value); } break; case 14: EnterOuterAlt(_localctx, 14); { - State = 3233; - Match(UINT64); - State = 3234; + State = 3297; + _localctx.u64ElementToken = Match(UINT64); + State = 3298; Match(T__41); - State = 3235; - int32(); - State = 3236; + State = 3299; + _localctx.u64Length = int32(); + State = 3300; Match(T__42); - State = 3237; + State = 3301; Match(T__29); - State = 3238; - i64seq(); - State = 3239; + State = 3302; + _localctx.u64Values = i64seq(); + State = 3303; Match(T__30); + _localctx.Value = Actions.CreateArraySerializedValue(_localctx.u64ElementToken, (_localctx.u64Length!=null?(_localctx.u64Length.Start):null), _localctx.u64Values.Value); } break; case 15: EnterOuterAlt(_localctx, 15); { - State = 3241; - Match(UINT32); - State = 3242; + State = 3306; + _localctx.u32ElementToken = Match(UINT32); + State = 3307; Match(T__41); - State = 3243; - int32(); - State = 3244; + State = 3308; + _localctx.u32Length = int32(); + State = 3309; Match(T__42); - State = 3245; + State = 3310; Match(T__29); - State = 3246; - i32seq(); - State = 3247; + State = 3311; + _localctx.u32Values = i32seq(); + State = 3312; Match(T__30); + _localctx.Value = Actions.CreateArraySerializedValue(_localctx.u32ElementToken, (_localctx.u32Length!=null?(_localctx.u32Length.Start):null), _localctx.u32Values.Value); } break; case 16: EnterOuterAlt(_localctx, 16); { - State = 3249; - Match(UINT16); - State = 3250; + State = 3315; + _localctx.u16ElementToken = Match(UINT16); + State = 3316; Match(T__41); - State = 3251; - int32(); - State = 3252; + State = 3317; + _localctx.u16Length = int32(); + State = 3318; Match(T__42); - State = 3253; + State = 3319; Match(T__29); - State = 3254; - i16seq(); - State = 3255; + State = 3320; + _localctx.u16Values = i16seq(); + State = 3321; Match(T__30); + _localctx.Value = Actions.CreateArraySerializedValue(_localctx.u16ElementToken, (_localctx.u16Length!=null?(_localctx.u16Length.Start):null), _localctx.u16Values.Value); } break; case 17: EnterOuterAlt(_localctx, 17); { - State = 3257; - Match(UINT8); - State = 3258; + State = 3324; + _localctx.u8ElementToken = Match(UINT8); + State = 3325; Match(T__41); - State = 3259; - int32(); - State = 3260; + State = 3326; + _localctx.u8Length = int32(); + State = 3327; Match(T__42); - State = 3261; + State = 3328; Match(T__29); - State = 3262; - i8seq(); - State = 3263; + State = 3329; + _localctx.u8Values = i8seq(); + State = 3330; Match(T__30); + _localctx.Value = Actions.CreateArraySerializedValue(_localctx.u8ElementToken, (_localctx.u8Length!=null?(_localctx.u8Length.Start):null), _localctx.u8Values.Value); } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 3265; - Match(CHAR); - State = 3266; + State = 3333; + _localctx.charElementToken = Match(CHAR); + State = 3334; Match(T__41); - State = 3267; - int32(); - State = 3268; + State = 3335; + _localctx.charLength = int32(); + State = 3336; Match(T__42); - State = 3269; + State = 3337; Match(T__29); - State = 3270; - i16seq(); - State = 3271; + State = 3338; + _localctx.charValues = i16seq(); + State = 3339; Match(T__30); + _localctx.Value = Actions.CreateArraySerializedValue(_localctx.charElementToken, (_localctx.charLength!=null?(_localctx.charLength.Start):null), _localctx.charValues.Value); } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 3273; - Match(BOOL); - State = 3274; + State = 3342; + _localctx.boolElementToken = Match(BOOL); + State = 3343; Match(T__41); - State = 3275; - int32(); - State = 3276; + State = 3344; + _localctx.boolLength = int32(); + State = 3345; Match(T__42); - State = 3277; + State = 3346; Match(T__29); - State = 3278; - boolSeq(); - State = 3279; + State = 3347; + _localctx.boolValues = boolSeq(); + State = 3348; Match(T__30); + _localctx.Value = Actions.CreateArraySerializedValue(_localctx.boolElementToken, (_localctx.boolLength!=null?(_localctx.boolLength.Start):null), _localctx.boolValues.Value); } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 3281; - Match(STRING); - State = 3282; + State = 3351; + _localctx.stringElementToken = Match(STRING); + State = 3352; Match(T__41); - State = 3283; - int32(); - State = 3284; + State = 3353; + _localctx.stringLength = int32(); + State = 3354; Match(T__42); - State = 3285; + State = 3355; Match(T__29); - State = 3286; - sqstringSeq(); - State = 3287; + State = 3356; + _localctx.stringValues = sqstringSeq(); + State = 3357; Match(T__30); + _localctx.Value = Actions.CreateArraySerializedValue(_localctx.stringElementToken, (_localctx.stringLength!=null?(_localctx.stringLength.Start):null), _localctx.stringValues.Value); } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 3289; - Match(TYPE); - State = 3290; + State = 3360; + _localctx.typeElementToken = Match(TYPE); + State = 3361; Match(T__41); - State = 3291; - int32(); - State = 3292; + State = 3362; + _localctx.typeLength = int32(); + State = 3363; Match(T__42); - State = 3293; + State = 3364; Match(T__29); - State = 3294; - classSeq(); - State = 3295; + State = 3365; + _localctx.typeValues = classSeq(); + State = 3366; Match(T__30); + _localctx.Value = Actions.CreateArraySerializedValue(_localctx.typeElementToken, (_localctx.typeLength!=null?(_localctx.typeLength.Start):null), _localctx.typeValues.Value); } break; case 22: EnterOuterAlt(_localctx, 22); { - State = 3297; - Match(OBJECT); - State = 3298; + State = 3369; + _localctx.objectElementToken = Match(OBJECT); + State = 3370; Match(T__41); - State = 3299; - int32(); - State = 3300; + State = 3371; + _localctx.objectLength = int32(); + State = 3372; Match(T__42); - State = 3301; + State = 3373; Match(T__29); - State = 3302; - objSeq(); - State = 3303; + State = 3374; + _localctx.objectValues = objSeq(); + State = 3375; Match(T__30); + _localctx.Value = Actions.CreateArraySerializedValue(_localctx.objectElementToken, (_localctx.objectLength!=null?(_localctx.objectLength.Start):null), _localctx.objectValues.Value); } break; } @@ -16443,6 +16636,9 @@ public SerInitContext serInit() { } public partial class F32seqContext : ParserRuleContext { + public System.Reflection.Metadata.BlobBuilder Value; + public Float64Context floatingValue; + public Int32Context integerValue; [System.Diagnostics.DebuggerNonUserCode] public Float64Context[] float64() { return GetRuleContexts(); } @@ -16472,33 +16668,36 @@ public override TResult Accept(IParseTreeVisitor visitor) { public F32seqContext f32seq() { F32seqContext _localctx = new F32seqContext(Context, State); EnterRule(_localctx, 308, RULE_f32seq); + Actions.BeginSerializationSequence(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3311; + State = 3388; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 98309L) != 0)) { { - State = 3309; + State = 3386; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,153,Context) ) { case 1: { - State = 3307; - float64(); + State = 3380; + _localctx.floatingValue = float64(); + Actions.AddFloat32SequenceValue(_localctx, _localctx.floatingValue.Value); } break; case 2: { - State = 3308; - int32(); + State = 3383; + _localctx.integerValue = int32(); + Actions.AddFloat32SequenceValue(_localctx, (_localctx.integerValue!=null?(_localctx.integerValue.Start):null)); } break; } } - State = 3313; + State = 3390; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16510,12 +16709,16 @@ public F32seqContext f32seq() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndSerializationSequence(_localctx); ExitRule(); } return _localctx; } public partial class F64seqContext : ParserRuleContext { + public System.Reflection.Metadata.BlobBuilder Value; + public Float64Context floatingValue; + public Int64Context integerValue; [System.Diagnostics.DebuggerNonUserCode] public Float64Context[] float64() { return GetRuleContexts(); } @@ -16545,33 +16748,36 @@ public override TResult Accept(IParseTreeVisitor visitor) { public F64seqContext f64seq() { F64seqContext _localctx = new F64seqContext(Context, State); EnterRule(_localctx, 310, RULE_f64seq); + Actions.BeginSerializationSequence(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3318; + State = 3399; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 98311L) != 0)) { { - State = 3316; + State = 3397; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,155,Context) ) { case 1: { - State = 3314; - float64(); + State = 3391; + _localctx.floatingValue = float64(); + Actions.AddFloat64SequenceValue(_localctx, _localctx.floatingValue.Value); } break; case 2: { - State = 3315; - int64(); + State = 3394; + _localctx.integerValue = int64(); + Actions.AddFloat64SequenceValue(_localctx, (_localctx.integerValue!=null?(_localctx.integerValue.Start):null)); } break; } } - State = 3320; + State = 3401; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16583,12 +16789,15 @@ public F64seqContext f64seq() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndSerializationSequence(_localctx); ExitRule(); } return _localctx; } public partial class I64seqContext : ParserRuleContext { + public System.Reflection.Metadata.BlobBuilder Value; + public Int64Context value; [System.Diagnostics.DebuggerNonUserCode] public Int64Context[] int64() { return GetRuleContexts(); } @@ -16612,21 +16821,23 @@ public override TResult Accept(IParseTreeVisitor visitor) { public I64seqContext i64seq() { I64seqContext _localctx = new I64seqContext(Context, State); EnterRule(_localctx, 312, RULE_i64seq); + Actions.BeginSerializationSequence(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3324; + State = 3407; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32 || _la==INT64) { { { - State = 3321; - int64(); + State = 3402; + _localctx.value = int64(); + Actions.AddInt64SequenceValue(_localctx, (_localctx.value!=null?(_localctx.value.Start):null)); } } - State = 3326; + State = 3409; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16638,12 +16849,15 @@ public I64seqContext i64seq() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndSerializationSequence(_localctx); ExitRule(); } return _localctx; } public partial class I32seqContext : ParserRuleContext { + public System.Reflection.Metadata.BlobBuilder Value; + public Int32Context value; [System.Diagnostics.DebuggerNonUserCode] public Int32Context[] int32() { return GetRuleContexts(); } @@ -16667,21 +16881,23 @@ public override TResult Accept(IParseTreeVisitor visitor) { public I32seqContext i32seq() { I32seqContext _localctx = new I32seqContext(Context, State); EnterRule(_localctx, 314, RULE_i32seq); + Actions.BeginSerializationSequence(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3330; + State = 3415; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 3327; - int32(); + State = 3410; + _localctx.value = int32(); + Actions.AddInt32SequenceValue(_localctx, (_localctx.value!=null?(_localctx.value.Start):null)); } } - State = 3332; + State = 3417; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16693,12 +16909,15 @@ public I32seqContext i32seq() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndSerializationSequence(_localctx); ExitRule(); } return _localctx; } public partial class I16seqContext : ParserRuleContext { + public System.Reflection.Metadata.BlobBuilder Value; + public Int32Context value; [System.Diagnostics.DebuggerNonUserCode] public Int32Context[] int32() { return GetRuleContexts(); } @@ -16722,21 +16941,23 @@ public override TResult Accept(IParseTreeVisitor visitor) { public I16seqContext i16seq() { I16seqContext _localctx = new I16seqContext(Context, State); EnterRule(_localctx, 316, RULE_i16seq); + Actions.BeginSerializationSequence(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3336; + State = 3423; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 3333; - int32(); + State = 3418; + _localctx.value = int32(); + Actions.AddInt16SequenceValue(_localctx, (_localctx.value!=null?(_localctx.value.Start):null)); } } - State = 3338; + State = 3425; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16748,12 +16969,15 @@ public I16seqContext i16seq() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndSerializationSequence(_localctx); ExitRule(); } return _localctx; } public partial class I8seqContext : ParserRuleContext { + public System.Reflection.Metadata.BlobBuilder Value; + public Int32Context value; [System.Diagnostics.DebuggerNonUserCode] public Int32Context[] int32() { return GetRuleContexts(); } @@ -16777,21 +17001,23 @@ public override TResult Accept(IParseTreeVisitor visitor) { public I8seqContext i8seq() { I8seqContext _localctx = new I8seqContext(Context, State); EnterRule(_localctx, 318, RULE_i8seq); + Actions.BeginSerializationSequence(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3342; + State = 3431; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 3339; - int32(); + State = 3426; + _localctx.value = int32(); + Actions.AddInt8SequenceValue(_localctx, (_localctx.value!=null?(_localctx.value.Start):null)); } } - State = 3344; + State = 3433; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16803,12 +17029,15 @@ public I8seqContext i8seq() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndSerializationSequence(_localctx); ExitRule(); } return _localctx; } public partial class BoolSeqContext : ParserRuleContext { + public System.Reflection.Metadata.BlobBuilder Value; + public TruefalseContext value; [System.Diagnostics.DebuggerNonUserCode] public TruefalseContext[] truefalse() { return GetRuleContexts(); } @@ -16832,21 +17061,23 @@ public override TResult Accept(IParseTreeVisitor visitor) { public BoolSeqContext boolSeq() { BoolSeqContext _localctx = new BoolSeqContext(Context, State); EnterRule(_localctx, 320, RULE_boolSeq); + Actions.BeginSerializationSequence(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3348; + State = 3439; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__94 || _la==T__95) { { { - State = 3345; - truefalse(); + State = 3434; + _localctx.value = truefalse(); + Actions.AddBooleanSequenceValue(_localctx, _localctx.value.Value); } } - State = 3350; + State = 3441; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16858,12 +17089,16 @@ public BoolSeqContext boolSeq() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndSerializationSequence(_localctx); ExitRule(); } return _localctx; } public partial class SqstringSeqContext : ParserRuleContext { + public System.Reflection.Metadata.BlobBuilder Value; + public IToken nullValue; + public IToken stringValue; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] NULLREF() { return GetTokens(CILParser.NULLREF); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode NULLREF(int i) { return GetToken(CILParser.NULLREF, i); @@ -16889,28 +17124,38 @@ public override TResult Accept(IParseTreeVisitor visitor) { public SqstringSeqContext sqstringSeq() { SqstringSeqContext _localctx = new SqstringSeqContext(Context, State); EnterRule(_localctx, 322, RULE_sqstringSeq); + Actions.BeginSerializationSequence(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3354; + State = 3448; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==NULLREF || _la==SQSTRING) { { - { - State = 3351; - _la = TokenStream.LA(1); - if ( !(_la==NULLREF || _la==SQSTRING) ) { - ErrorHandler.RecoverInline(this); - } - else { - ErrorHandler.ReportMatch(this); - Consume(); - } + State = 3446; + ErrorHandler.Sync(this); + switch (TokenStream.LA(1)) { + case NULLREF: + { + State = 3442; + _localctx.nullValue = Match(NULLREF); + Actions.AddStringSequenceValue(_localctx, _localctx.nullValue); + } + break; + case SQSTRING: + { + State = 3444; + _localctx.stringValue = Match(SQSTRING); + Actions.AddStringSequenceValue(_localctx, _localctx.stringValue); + } + break; + default: + throw new NoViableAltException(this); } } - State = 3356; + State = 3450; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16922,12 +17167,15 @@ public SqstringSeqContext sqstringSeq() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndSerializationSequence(_localctx); ExitRule(); } return _localctx; } public partial class ClassSeqContext : ParserRuleContext { + public object Value; + public ClassSeqElementContext value; [System.Diagnostics.DebuggerNonUserCode] public ClassSeqElementContext[] classSeqElement() { return GetRuleContexts(); } @@ -16951,21 +17199,23 @@ public override TResult Accept(IParseTreeVisitor visitor) { public ClassSeqContext classSeq() { ClassSeqContext _localctx = new ClassSeqContext(Context, State); EnterRule(_localctx, 324, RULE_classSeq); + Actions.BeginSerializationSequence(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3360; + State = 3456; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4947802390528L) != 0) || _la==T__112 || _la==NULLREF || _la==VALUE || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 105553118478337L) != 0)) { { { - State = 3357; - classSeqElement(); + State = 3451; + _localctx.value = classSeqElement(); + Actions.AddClassSequenceValue(_localctx, _localctx.value.Value); } } - State = 3362; + State = 3458; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16977,12 +17227,16 @@ public ClassSeqContext classSeq() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndClassSerializationSequence(_localctx); ExitRule(); } return _localctx; } public partial class ClassSeqElementContext : ParserRuleContext { + public object Value; + public IToken quotedValue; + public ClassNameContext typeValue; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode NULLREF() { return GetToken(CILParser.NULLREF, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SQSTRING() { return GetToken(CILParser.SQSTRING, 0); } [System.Diagnostics.DebuggerNonUserCode] public ClassNameContext className() { @@ -17006,23 +17260,25 @@ public ClassSeqElementContext classSeqElement() { ClassSeqElementContext _localctx = new ClassSeqElementContext(Context, State); EnterRule(_localctx, 326, RULE_classSeqElement); try { - State = 3367; + State = 3467; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case NULLREF: EnterOuterAlt(_localctx, 1); { - State = 3363; + State = 3459; Match(NULLREF); + _localctx.Value = Actions.CreateNullClassSequenceValue(); } break; case T__38: EnterOuterAlt(_localctx, 2); { - State = 3364; + State = 3461; Match(T__38); - State = 3365; - Match(SQSTRING); + State = 3462; + _localctx.quotedValue = Match(SQSTRING); + _localctx.Value = Actions.CreateQuotedClassSequenceValue(_localctx.quotedValue); } break; case T__15: @@ -17038,8 +17294,9 @@ public ClassSeqElementContext classSeqElement() { case ID: EnterOuterAlt(_localctx, 3); { - State = 3366; - className(); + State = 3464; + _localctx.typeValue = className(); + _localctx.Value = Actions.CreateClassSequenceValue(_localctx.typeValue.Value); } break; default: @@ -17058,6 +17315,8 @@ public ClassSeqElementContext classSeqElement() { } public partial class ObjSeqContext : ParserRuleContext { + public object Value; + public SerInitContext value; [System.Diagnostics.DebuggerNonUserCode] public SerInitContext[] serInit() { return GetRuleContexts(); } @@ -17081,21 +17340,23 @@ public override TResult Accept(IParseTreeVisitor visitor) { public ObjSeqContext objSeq() { ObjSeqContext _localctx = new ObjSeqContext(Context, State); EnterRule(_localctx, 328, RULE_objSeq); + Actions.BeginSerializationSequence(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3372; + State = 3474; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__83 || ((((_la - 181)) & ~0x3f) == 0 && ((1L << (_la - 181)) & 106495L) != 0)) { { { - State = 3369; - serInit(); + State = 3469; + _localctx.value = serInit(); + Actions.AddObjectSequenceValue(_localctx, _localctx.value.Value); } } - State = 3374; + State = 3476; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17107,13 +17368,18 @@ public ObjSeqContext objSeq() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndObjectSerializationSequence(_localctx); ExitRule(); } return _localctx; } public partial class CustomAttrDeclContext : ParserRuleContext { + public object Value; public bool HasSyntaxError; + public CustomDescrContext directAttribute; + public CustomDescrWithOwnerContext ownedAttribute; + public DottedNameContext alias; [System.Diagnostics.DebuggerNonUserCode] public CustomDescrContext customDescr() { return GetRuleContext(0); } @@ -17140,30 +17406,33 @@ public override TResult Accept(IParseTreeVisitor visitor) { public CustomAttrDeclContext customAttrDecl() { CustomAttrDeclContext _localctx = new CustomAttrDeclContext(Context, State); EnterRule(_localctx, 330, RULE_customAttrDecl); - BeginSubtree(); Actions.BeginSemanticRoot(_localctx); + Actions.BeginSemanticRoot(_localctx); try { - State = 3378; + State = 3486; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,166,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,167,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3375; - customDescr(); + State = 3477; + _localctx.directAttribute = customDescr(); + _localctx.Value = Actions.CreateCustomAttributeDeclaration(_localctx.directAttribute.Value); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3376; - customDescrWithOwner(); + State = 3480; + _localctx.ownedAttribute = customDescrWithOwner(); + _localctx.Value = Actions.CreateCustomAttributeDeclaration(_localctx.ownedAttribute.Value); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3377; - dottedName(); + State = 3483; + _localctx.alias = dottedName(); + _localctx.Value = Actions.CreateCustomAttributeTypedef(_localctx.alias.Value); } break; } @@ -17174,7 +17443,7 @@ public CustomAttrDeclContext customAttrDecl() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); ExitRule(); } return _localctx; @@ -17218,13 +17487,13 @@ public AsmOrRefDeclContext asmOrRefDecl() { EnterRule(_localctx, 332, RULE_asmOrRefDecl); int _la; try { - State = 3405; + State = 3513; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,167,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,168,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3380; + State = 3488; _la = TokenStream.LA(1); if ( !(_la==T__166 || _la==T__167) ) { ErrorHandler.RecoverInline(this); @@ -17233,72 +17502,72 @@ public AsmOrRefDeclContext asmOrRefDecl() { ErrorHandler.ReportMatch(this); Consume(); } - State = 3381; + State = 3489; Match(T__35); - State = 3382; + State = 3490; Match(T__29); - State = 3383; + State = 3491; bytes(); - State = 3384; + State = 3492; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3386; + State = 3494; Match(T__168); - State = 3387; + State = 3495; intOrWildcard(); - State = 3388; + State = 3496; Match(T__74); - State = 3389; + State = 3497; intOrWildcard(); - State = 3390; + State = 3498; Match(T__74); - State = 3391; + State = 3499; intOrWildcard(); - State = 3392; + State = 3500; Match(T__74); - State = 3393; + State = 3501; intOrWildcard(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3395; + State = 3503; Match(T__169); - State = 3396; + State = 3504; compQstring(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 3397; + State = 3505; Match(T__169); - State = 3398; + State = 3506; Match(T__35); - State = 3399; + State = 3507; Match(T__29); - State = 3400; + State = 3508; bytes(); - State = 3401; + State = 3509; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 3403; + State = 3511; customAttrDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 3404; + State = 3512; compControl(); } break; @@ -17344,13 +17613,13 @@ public AssemblyRefBlockContext assemblyRefBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 3407; + State = 3515; assemblyRefHead(); - State = 3408; + State = 3516; Match(T__16); - State = 3409; + State = 3517; assemblyRefDecls(); - State = 3410; + State = 3518; Match(T__17); } } @@ -17394,36 +17663,36 @@ public AssemblyRefHeadContext assemblyRefHead() { AssemblyRefHeadContext _localctx = new AssemblyRefHeadContext(Context, State); EnterRule(_localctx, 336, RULE_assemblyRefHead); try { - State = 3424; + State = 3532; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,168,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,169,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3412; + State = 3520; Match(T__24); - State = 3413; + State = 3521; Match(T__39); - State = 3414; + State = 3522; asmAttr(); - State = 3415; + State = 3523; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3417; + State = 3525; Match(T__24); - State = 3418; + State = 3526; Match(T__39); - State = 3419; + State = 3527; asmAttr(); - State = 3420; + State = 3528; dottedName(); - State = 3421; + State = 3529; Match(T__33); - State = 3422; + State = 3530; dottedName(); } break; @@ -17468,17 +17737,17 @@ public AssemblyRefDeclsContext assemblyRefDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 3429; + State = 3537; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 36028835673735168L) != 0) || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & 4294975519L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 105555249070081L) != 0)) { { { - State = 3426; + State = 3534; assemblyRefDecl(); } } - State = 3431; + State = 3539; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17521,21 +17790,21 @@ public AssemblyRefDeclContext assemblyRefDecl() { AssemblyRefDeclContext _localctx = new AssemblyRefDeclContext(Context, State); EnterRule(_localctx, 340, RULE_assemblyRefDecl); try { - State = 3446; + State = 3554; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case HASH: EnterOuterAlt(_localctx, 1); { - State = 3432; + State = 3540; Match(HASH); - State = 3433; + State = 3541; Match(T__35); - State = 3434; + State = 3542; Match(T__29); - State = 3435; + State = 3543; bytes(); - State = 3436; + State = 3544; Match(T__30); } break; @@ -17560,29 +17829,29 @@ public AssemblyRefDeclContext assemblyRefDecl() { case ID: EnterOuterAlt(_localctx, 2); { - State = 3438; + State = 3546; asmOrRefDecl(); } break; case T__170: EnterOuterAlt(_localctx, 3); { - State = 3439; + State = 3547; Match(T__170); - State = 3440; + State = 3548; Match(T__35); - State = 3441; + State = 3549; Match(T__29); - State = 3442; + State = 3550; bytes(); - State = 3443; + State = 3551; Match(T__30); } break; case T__54: EnterOuterAlt(_localctx, 4); { - State = 3445; + State = 3553; Match(T__54); } break; @@ -17630,13 +17899,13 @@ public ExptypeBlockContext exptypeBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 3448; + State = 3556; exptypeHead(); - State = 3449; + State = 3557; Match(T__16); - State = 3450; + State = 3558; exptypeDecls(); - State = 3451; + State = 3559; Match(T__17); } } @@ -17683,25 +17952,25 @@ public ExptypeHeadContext exptypeHead() { try { EnterOuterAlt(_localctx, 1); { - State = 3453; + State = 3561; Match(T__49); - State = 3454; + State = 3562; Match(T__39); - State = 3458; + State = 3566; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4618441417868443648L) != 0) || _la==T__171) { { { - State = 3455; + State = 3563; exptAttr(); } } - State = 3460; + State = 3568; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 3461; + State = 3569; dottedName(); } } @@ -17748,23 +18017,23 @@ public ExportHeadContext exportHead() { try { EnterOuterAlt(_localctx, 1); { - State = 3463; + State = 3571; Match(EXPORT); - State = 3467; + State = 3575; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4618441417868443648L) != 0) || _la==T__171) { { { - State = 3464; + State = 3572; exptAttr(); } } - State = 3469; + State = 3577; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 3470; + State = 3578; dottedName(); } } @@ -17798,81 +18067,81 @@ public ExptAttrContext exptAttr() { ExptAttrContext _localctx = new ExptAttrContext(Context, State); EnterRule(_localctx, 348, RULE_exptAttr); try { - State = 3487; + State = 3595; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,173,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,174,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3472; + State = 3580; Match(T__51); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3473; + State = 3581; Match(T__50); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3474; + State = 3582; Match(T__171); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 3475; + State = 3583; Match(T__61); - State = 3476; + State = 3584; Match(T__50); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 3477; + State = 3585; Match(T__61); - State = 3478; + State = 3586; Match(T__51); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 3479; + State = 3587; Match(T__61); - State = 3480; + State = 3588; Match(T__62); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 3481; + State = 3589; Match(T__61); - State = 3482; + State = 3590; Match(T__63); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 3483; + State = 3591; Match(T__61); - State = 3484; + State = 3592; Match(T__64); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 3485; + State = 3593; Match(T__61); - State = 3486; + State = 3594; Match(T__65); } break; @@ -17917,17 +18186,17 @@ public ExptypeDeclsContext exptypeDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 3492; + State = 3600; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1125938597265408L) != 0) || _la==T__112 || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 3489; + State = 3597; exptypeDecl(); } } - State = 3494; + State = 3602; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17981,67 +18250,67 @@ public ExptypeDeclContext exptypeDecl() { ExptypeDeclContext _localctx = new ExptypeDeclContext(Context, State); EnterRule(_localctx, 352, RULE_exptypeDecl); try { - State = 3508; + State = 3616; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,175,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,176,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3495; + State = 3603; Match(T__20); - State = 3496; + State = 3604; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3497; + State = 3605; Match(T__49); - State = 3498; + State = 3606; Match(T__39); - State = 3499; + State = 3607; slashedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3500; + State = 3608; Match(T__24); - State = 3501; + State = 3609; Match(T__39); - State = 3502; + State = 3610; dottedName(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 3503; + State = 3611; mdtoken(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 3504; + State = 3612; Match(T__49); - State = 3505; + State = 3613; int32(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 3506; + State = 3614; customAttrDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 3507; + State = 3615; compControl(); } break; @@ -18087,13 +18356,13 @@ public ManifestResBlockContext manifestResBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 3510; + State = 3618; manifestResHead(); - State = 3511; + State = 3619; Match(T__16); - State = 3512; + State = 3620; manifestResDecls(); - State = 3513; + State = 3621; Match(T__17); } } @@ -18142,56 +18411,56 @@ public ManifestResHeadContext manifestResHead() { EnterRule(_localctx, 356, RULE_manifestResHead); int _la; try { - State = 3534; + State = 3642; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,178,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,179,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3515; + State = 3623; Match(MRESOURCE); - State = 3519; + State = 3627; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__50 || _la==T__51) { { { - State = 3516; + State = 3624; manresAttr(); } } - State = 3521; + State = 3629; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 3522; + State = 3630; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3523; + State = 3631; Match(MRESOURCE); - State = 3527; + State = 3635; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__50 || _la==T__51) { { { - State = 3524; + State = 3632; manresAttr(); } } - State = 3529; + State = 3637; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 3530; + State = 3638; dottedName(); - State = 3531; + State = 3639; Match(T__33); - State = 3532; + State = 3640; dottedName(); } break; @@ -18230,7 +18499,7 @@ public ManresAttrContext manresAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 3536; + State = 3644; _la = TokenStream.LA(1); if ( !(_la==T__50 || _la==T__51) ) { ErrorHandler.RecoverInline(this); @@ -18280,17 +18549,17 @@ public ManifestResDeclsContext manifestResDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 3541; + State = 3649; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38690422784L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 3538; + State = 3646; manifestResDecl(); } } - State = 3543; + State = 3651; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -18338,30 +18607,30 @@ public ManifestResDeclContext manifestResDecl() { ManifestResDeclContext _localctx = new ManifestResDeclContext(Context, State); EnterRule(_localctx, 362, RULE_manifestResDecl); try { - State = 3554; + State = 3662; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__20: EnterOuterAlt(_localctx, 1); { - State = 3544; + State = 3652; Match(T__20); - State = 3545; + State = 3653; dottedName(); - State = 3546; + State = 3654; Match(T__43); - State = 3547; + State = 3655; int32(); } break; case T__24: EnterOuterAlt(_localctx, 2); { - State = 3549; + State = 3657; Match(T__24); - State = 3550; + State = 3658; Match(T__39); - State = 3551; + State = 3659; dottedName(); } break; @@ -18374,7 +18643,7 @@ public ManifestResDeclContext manifestResDecl() { case ID: EnterOuterAlt(_localctx, 3); { - State = 3552; + State = 3660; customAttrDecl(); } break; @@ -18388,7 +18657,7 @@ public ManifestResDeclContext manifestResDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 4); { - State = 3553; + State = 3661; compControl(); } break; @@ -18425,7 +18694,7 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { } private static int[] _serializedATN = { - 4,1,305,3557,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, + 4,1,305,3665,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, @@ -18471,62 +18740,64 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 1,20,1,20,1,20,1,20,3,20,599,8,20,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1, 21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1, 21,1,21,1,21,1,21,3,21,626,8,21,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22, - 1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,3,22, - 649,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, + 1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22, + 1,22,1,22,1,22,1,22,3,22,654,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,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,685,8,23,1,24,1,24,1,25,1,25, - 1,25,1,25,1,25,1,25,3,25,695,8,25,1,26,1,26,1,26,1,27,1,27,5,27,702,8, - 27,10,27,12,27,705,9,27,1,28,1,28,1,28,1,28,1,28,1,28,1,28,5,28,714,8, - 28,10,28,12,28,717,9,28,1,29,1,29,1,30,1,30,3,30,723,8,30,1,31,1,31,1, - 31,1,31,1,31,1,31,1,31,1,31,1,31,3,31,734,8,31,1,32,1,32,1,32,1,32,1,32, - 1,32,1,32,1,32,1,32,1,32,1,32,3,32,747,8,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,34,1,34,1,34,1,34,5, - 34,768,8,34,10,34,12,34,771,9,34,1,35,1,35,1,35,1,35,1,35,1,35,1,36,1, - 36,1,36,1,36,1,37,1,37,1,37,1,37,5,37,787,8,37,10,37,12,37,790,9,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,38,1, + 23,1,23,1,23,3,23,694,8,23,1,24,1,24,1,24,1,25,1,25,1,25,1,25,1,25,1,25, + 3,25,705,8,25,1,26,1,26,1,26,1,26,1,27,1,27,1,27,1,27,5,27,715,8,27,10, + 27,12,27,718,9,27,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,5,28,728,8,28, + 10,28,12,28,731,9,28,1,29,1,29,1,29,1,30,1,30,3,30,738,8,30,1,30,1,30, + 1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31, + 1,31,1,31,1,31,1,31,3,31,760,8,31,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1, + 32,1,32,1,32,1,32,3,32,773,8,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,34,1,34,1,34,1,34,5,34,794,8,34,10, + 34,12,34,797,9,34,1,35,1,35,1,35,1,35,1,35,1,35,1,36,1,36,1,36,1,36,1, + 37,1,37,1,37,1,37,5,37,813,8,37,10,37,12,37,816,9,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,38,1,38,1,38,1,38,1, 38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1, 38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1, 38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1, - 38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,3, - 38,862,8,38,1,39,1,39,1,39,1,39,1,39,3,39,869,8,39,1,40,1,40,1,40,1,40, - 1,40,3,40,876,8,40,1,41,5,41,879,8,41,10,41,12,41,882,9,41,1,42,1,42,1, - 42,1,42,5,42,888,8,42,10,42,12,42,891,9,42,1,42,1,42,1,42,1,43,1,43,1, - 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, - 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, - 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, - 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, - 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, - 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, - 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1, - 44,1,44,1,44,1,44,1,44,3,44,1001,8,44,1,45,1,45,5,45,1005,8,45,10,45,12, - 45,1008,9,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,5, - 45,1021,8,45,10,45,12,45,1024,9,45,1,45,1,45,1,45,3,45,1029,8,45,1,46, - 1,46,1,47,1,47,3,47,1035,8,47,1,48,1,48,1,49,5,49,1040,8,49,10,49,12,49, - 1043,9,49,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50, - 1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,3,50, - 1070,8,50,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51, + 38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,3,38,888,8,38,1,39, + 1,39,1,39,1,39,1,39,3,39,895,8,39,1,40,1,40,1,40,1,40,1,40,3,40,902,8, + 40,1,41,5,41,905,8,41,10,41,12,41,908,9,41,1,42,1,42,1,42,1,42,5,42,914, + 8,42,10,42,12,42,917,9,42,1,42,1,42,1,42,1,43,1,43,1,44,1,44,1,44,1,44, + 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, + 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, + 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, + 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, + 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, + 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, + 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, + 1,44,3,44,1027,8,44,1,45,1,45,5,45,1031,8,45,10,45,12,45,1034,9,45,1,45, + 1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,5,45,1047,8,45,10,45, + 12,45,1050,9,45,1,45,1,45,1,45,3,45,1055,8,45,1,46,1,46,1,47,1,47,3,47, + 1061,8,47,1,48,1,48,1,49,5,49,1066,8,49,10,49,12,49,1069,9,49,1,50,1,50, + 1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50, + 1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,3,50,1096,8,50,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, 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,1,51,1,51,1,51,1,51,1,51,1,51,3,51,1148,8,51,3,51,1150,8,51, - 1,52,1,52,1,52,1,52,1,52,1,53,1,53,1,53,1,53,1,53,1,53,1,53,3,53,1164, - 8,53,1,53,1,53,5,53,1168,8,53,10,53,12,53,1171,9,53,1,53,1,53,1,53,1,53, - 1,53,1,53,3,53,1179,8,53,3,53,1181,8,53,1,54,1,54,1,54,1,54,1,54,5,54, - 1188,8,54,10,54,12,54,1191,9,54,1,54,1,54,1,54,1,54,1,55,1,55,1,55,1,55, - 1,55,5,55,1202,8,55,10,55,12,55,1205,9,55,1,55,1,55,1,55,1,55,1,56,1,56, - 1,56,1,56,1,56,5,56,1216,8,56,10,56,12,56,1219,9,56,1,56,1,56,1,56,1,56, - 1,56,3,56,1226,8,56,1,57,1,57,1,57,1,57,1,57,1,57,3,57,1234,8,57,1,57, - 1,57,3,57,1238,8,57,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58, + 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,1174,8,51,3,51,1176,8,51,1,52,1,52,1,52,1,52, + 1,52,1,53,1,53,1,53,1,53,1,53,1,53,1,53,3,53,1190,8,53,1,53,1,53,5,53, + 1194,8,53,10,53,12,53,1197,9,53,1,53,1,53,1,53,1,53,1,53,1,53,3,53,1205, + 8,53,3,53,1207,8,53,1,54,1,54,1,54,1,54,1,54,5,54,1214,8,54,10,54,12,54, + 1217,9,54,1,54,1,54,1,54,1,54,1,55,1,55,1,55,1,55,1,55,5,55,1228,8,55, + 10,55,12,55,1231,9,55,1,55,1,55,1,55,1,55,1,56,1,56,1,56,1,56,1,56,5,56, + 1242,8,56,10,56,12,56,1245,9,56,1,56,1,56,1,56,1,56,1,56,3,56,1252,8,56, + 1,57,1,57,1,57,1,57,1,57,1,57,3,57,1260,8,57,1,57,1,57,3,57,1264,8,57, + 1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58, 1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58, - 1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,3,58, - 1277,8,58,1,59,1,59,1,59,1,59,5,59,1283,8,59,10,59,12,59,1286,9,59,1,59, - 1,59,1,59,1,60,5,60,1292,8,60,10,60,12,60,1295,9,60,1,61,1,61,1,61,1,61, - 1,61,3,61,1302,8,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,3,62,1321,8,62,1,63,1,63,1,63,1,63, - 1,63,1,63,5,63,1329,8,63,10,63,12,63,1332,9,63,3,63,1334,8,63,1,64,1,64, + 1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,3,58,1303,8,58,1,59,1,59, + 1,59,1,59,5,59,1309,8,59,10,59,12,59,1312,9,59,1,59,1,59,1,59,1,60,5,60, + 1318,8,60,10,60,12,60,1321,9,60,1,61,1,61,1,61,1,61,1,61,3,61,1328,8,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,3,62,1347,8,62,1,63,1,63,1,63,1,63,1,63,1,63,5,63,1355, + 8,63,10,63,12,63,1358,9,63,3,63,1360,8,63,1,64,1,64,1,64,1,64,1,64,1,64, 1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,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,1358,8,64,1,65,1,65,1,65,1,65,1,65, + 1,64,1,64,3,64,1384,8,64,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, @@ -18536,146 +18807,149 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, - 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, - 3,65,1505,8,65,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,3,66,1515,8,66, - 1,67,1,67,1,67,1,67,1,67,5,67,1522,8,67,10,67,12,67,1525,9,67,3,67,1527, - 8,67,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, + 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,3,65,1531,8,65,1,66, + 1,66,1,66,1,66,1,66,1,66,1,66,1,66,3,66,1541,8,66,1,67,1,67,1,67,1,67, + 1,67,5,67,1548,8,67,10,67,12,67,1551,9,67,3,67,1553,8,67,1,68,1,68,1,68, + 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, - 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,3,68,1609,8,68, - 1,69,1,69,1,69,1,69,1,69,5,69,1616,8,69,10,69,12,69,1619,9,69,1,70,1,70, + 1,68,1,68,1,68,1,68,1,68,1,68,1,68,3,68,1635,8,68,1,69,1,69,1,69,1,69, + 1,69,5,69,1642,8,69,10,69,12,69,1645,9,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,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,1,70,1,70,1,70,3,70, - 1650,8,70,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, + 1,70,1,70,1,70,1,70,1,70,1,70,1,70,1,70,1,70,3,70,1676,8,70,1,71,1,71, 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, - 1,71,1,71,1,71,1,71,3,71,1710,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,1,72,1,72,1,72,1,72,1,72,1,72, + 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, + 3,71,1736,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,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,1750,8,72,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73, - 1,73,1,73,1,73,1,73,1,73,1,73,3,73,1766,8,73,1,74,1,74,1,74,1,74,1,75, - 1,75,1,75,1,75,3,75,1776,8,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,3,76,1803,8,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,1827,8,76,1,77,1,77,1,77,1,77,5,77,1833,8,77,10,77,12,77,1836,9,77, - 1,77,3,77,1839,8,77,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78, - 1,78,1,78,1,78,3,78,1854,8,78,1,79,1,79,1,79,5,79,1859,8,79,10,79,12,79, - 1862,9,79,1,79,1,79,1,80,1,80,1,80,1,80,1,81,1,81,1,82,1,82,1,82,1,82, + 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, + 1776,8,72,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73, + 1,73,1,73,3,73,1792,8,73,1,74,1,74,1,74,1,74,1,75,1,75,1,75,1,75,3,75, + 1802,8,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,3,76, + 1829,8,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,1853,8,76,1,77, + 1,77,1,77,1,77,5,77,1859,8,77,10,77,12,77,1862,9,77,1,77,3,77,1865,8,77, + 1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,3,78, + 1880,8,78,1,79,1,79,1,79,5,79,1885,8,79,10,79,12,79,1888,9,79,1,79,1,79, + 1,80,1,80,1,80,1,80,1,81,1,81,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, - 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, - 1,82,1,82,3,82,1906,8,82,1,83,1,83,1,84,1,84,1,84,1,84,1,84,1,84,3,84, - 1916,8,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84, - 1,84,1,84,1,84,1,84,3,84,1934,8,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84, - 1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1952,8,84,1,85,1,85, - 1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85, - 1,85,3,85,1971,8,85,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86, - 1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,3,86,1992,8,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,88,1,88,1,88,1,88, - 1,88,3,88,2011,8,88,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89, - 1,89,1,89,1,89,3,89,2026,8,89,1,90,1,90,1,90,1,90,5,90,2032,8,90,10,90, - 12,90,2035,9,90,1,90,1,90,1,90,1,91,1,91,1,91,1,91,1,91,1,91,3,91,2046, - 8,91,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92, - 1,92,1,92,1,92,1,92,1,92,3,92,2066,8,92,1,93,1,93,1,93,5,93,2071,8,93, - 10,93,12,93,2074,9,93,1,94,1,94,3,94,2078,8,94,1,94,1,94,1,94,1,95,1,95, - 1,95,1,95,5,95,2087,8,95,10,95,12,95,2090,9,95,1,95,1,95,1,95,1,96,1,96, - 1,96,1,96,1,96,1,97,3,97,2101,8,97,1,97,1,97,1,98,1,98,1,98,1,98,1,98, - 1,98,1,98,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, + 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,3,82,1932, + 8,82,1,83,1,83,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1942,8,84,1,84,1,84, + 1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84, + 3,84,1960,8,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84, + 1,84,1,84,1,84,1,84,1,84,3,84,1978,8,84,1,85,1,85,1,85,1,85,1,85,1,85, + 1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,3,85,1997,8,85, + 1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86, + 1,86,1,86,1,86,1,86,1,86,3,86,2018,8,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,88,1,88,1,88,1,88,1,88,3,88,2037,8,88, + 1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,3,89, + 2052,8,89,1,90,1,90,1,90,1,90,5,90,2058,8,90,10,90,12,90,2061,9,90,1,90, + 1,90,1,90,1,91,1,91,1,91,1,91,1,91,1,91,3,91,2072,8,91,1,92,1,92,1,92, + 1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92, + 1,92,3,92,2092,8,92,1,93,1,93,1,93,5,93,2097,8,93,10,93,12,93,2100,9,93, + 1,94,1,94,3,94,2104,8,94,1,94,1,94,1,94,1,95,1,95,1,95,1,95,5,95,2113, + 8,95,10,95,12,95,2116,9,95,1,95,1,95,1,95,1,96,1,96,1,96,1,96,1,96,1,97, + 3,97,2127,8,97,1,97,1,97,1,98,1,98,1,98,1,98,1,98,1,98,1,98,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, - 1,99,5,99,2209,8,99,10,99,12,99,2212,9,99,1,99,1,99,1,99,1,99,1,99,1,99, - 1,99,5,99,2221,8,99,10,99,12,99,2224,9,99,1,99,1,99,1,99,1,99,1,99,1,99, - 1,99,1,99,1,99,1,99,1,99,5,99,2237,8,99,10,99,12,99,2240,9,99,1,99,1,99, - 1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,2251,8,99,10,99,12,99,2254,9,99, - 1,99,1,99,1,99,1,99,1,99,1,99,3,99,2262,8,99,1,100,1,100,1,100,1,100,1, - 100,1,100,1,100,1,100,1,100,1,100,1,100,5,100,2275,8,100,10,100,12,100, - 2278,9,100,1,100,1,100,1,100,1,100,1,100,1,100,1,101,1,101,1,101,1,101, + 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,2235,8,99, + 10,99,12,99,2238,9,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,2247,8,99, + 10,99,12,99,2250,9,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, + 1,99,5,99,2263,8,99,10,99,12,99,2266,9,99,1,99,1,99,1,99,1,99,1,99,1,99, + 1,99,1,99,1,99,5,99,2277,8,99,10,99,12,99,2280,9,99,1,99,1,99,1,99,1,99, + 1,99,1,99,3,99,2288,8,99,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100, + 1,100,1,100,1,100,5,100,2301,8,100,10,100,12,100,2304,9,100,1,100,1,100, + 1,100,1,100,1,100,1,100,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101, 1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101, 1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101, - 1,101,1,101,1,101,1,101,1,101,1,101,3,101,2320,8,101,1,102,1,102,1,102, - 1,102,1,102,1,102,1,102,1,102,1,102,3,102,2331,8,102,1,103,1,103,1,103, - 1,103,1,103,3,103,2338,8,103,1,104,1,104,1,104,1,104,1,104,1,104,3,104, - 2346,8,104,1,105,1,105,1,105,1,105,5,105,2352,8,105,10,105,12,105,2355, - 9,105,1,105,1,105,1,105,1,105,1,105,1,105,1,105,1,105,5,105,2365,8,105, - 10,105,12,105,2368,9,105,1,105,1,105,1,105,3,105,2373,8,105,1,106,1,106, - 1,106,1,106,3,106,2379,8,106,1,107,5,107,2382,8,107,10,107,12,107,2385, - 9,107,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108, + 1,101,1,101,3,101,2346,8,101,1,102,1,102,1,102,1,102,1,102,1,102,1,102, + 1,102,1,102,3,102,2357,8,102,1,103,1,103,1,103,1,103,1,103,3,103,2364, + 8,103,1,104,1,104,1,104,1,104,1,104,1,104,3,104,2372,8,104,1,105,1,105, + 1,105,1,105,5,105,2378,8,105,10,105,12,105,2381,9,105,1,105,1,105,1,105, + 1,105,1,105,1,105,1,105,1,105,5,105,2391,8,105,10,105,12,105,2394,9,105, + 1,105,1,105,1,105,3,105,2399,8,105,1,106,1,106,1,106,1,106,3,106,2405, + 8,106,1,107,5,107,2408,8,107,10,107,12,107,2411,9,107,1,108,1,108,1,108, 1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108, - 1,108,1,108,1,108,3,108,2413,8,108,1,109,1,109,1,109,1,109,5,109,2419, - 8,109,10,109,12,109,2422,9,109,1,109,1,109,1,109,1,109,1,109,1,109,1,109, - 1,110,1,110,1,110,1,110,3,110,2435,8,110,1,111,5,111,2438,8,111,10,111, - 12,111,2441,9,111,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112, + 1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,3,108, + 2439,8,108,1,109,1,109,1,109,1,109,5,109,2445,8,109,10,109,12,109,2448, + 9,109,1,109,1,109,1,109,1,109,1,109,1,109,1,109,1,110,1,110,1,110,1,110, + 3,110,2461,8,110,1,111,5,111,2464,8,111,10,111,12,111,2467,9,111,1,112, 1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112, - 1,112,3,112,2465,8,112,1,113,1,113,1,113,1,113,1,113,1,113,1,113,3,113, - 2474,8,113,1,114,1,114,1,114,1,114,1,114,1,114,1,114,4,114,2483,8,114, - 11,114,12,114,2484,1,114,1,114,3,114,2489,8,114,1,115,1,115,1,115,5,115, - 2494,8,115,10,115,12,115,2497,9,115,1,116,1,116,1,116,1,116,1,116,1,116, - 1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,3,116, - 2516,8,116,1,117,1,117,1,117,1,117,1,117,1,117,1,117,5,117,2525,8,117, - 10,117,12,117,2528,9,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117, - 1,117,1,117,5,117,2540,8,117,10,117,12,117,2543,9,117,1,117,1,117,1,118, + 1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,3,112,2491,8,112, + 1,113,1,113,1,113,1,113,1,113,1,113,1,113,3,113,2500,8,113,1,114,1,114, + 1,114,1,114,1,114,1,114,1,114,4,114,2509,8,114,11,114,12,114,2510,1,114, + 1,114,3,114,2515,8,114,1,115,1,115,1,115,5,115,2520,8,115,10,115,12,115, + 2523,9,115,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116, + 1,116,1,116,1,116,1,116,1,116,1,116,1,116,3,116,2542,8,116,1,117,1,117, + 1,117,1,117,1,117,1,117,1,117,5,117,2551,8,117,10,117,12,117,2554,9,117, + 1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,5,117,2566, + 8,117,10,117,12,117,2569,9,117,1,117,1,117,1,118,1,118,1,118,1,118,1,118, 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, - 1,118,1,118,1,118,1,118,1,118,3,118,2589,8,118,1,119,1,119,1,119,1,119, - 1,119,1,119,1,119,1,119,3,119,2599,8,119,3,119,2601,8,119,1,119,1,119, - 1,119,5,119,2606,8,119,10,119,12,119,2609,9,119,1,119,1,119,1,119,3,119, - 2614,8,119,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, + 1,118,3,118,2615,8,118,1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119, + 3,119,2625,8,119,3,119,2627,8,119,1,119,1,119,1,119,5,119,2632,8,119,10, + 119,12,119,2635,9,119,1,119,1,119,1,119,3,119,2640,8,119,1,120,1,120,1, + 120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, - 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,3,120,2658,8,120,1,121, - 1,121,1,121,1,121,1,121,1,121,1,121,3,121,2667,8,121,1,122,1,122,1,122, + 1,120,1,120,1,120,1,120,3,120,2684,8,120,1,121,1,121,1,121,1,121,1,121, + 1,121,1,121,3,121,2693,8,121,1,122,1,122,1,122,1,122,1,122,1,122,1,122, 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, - 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,3,122, - 2707,8,122,1,123,5,123,2710,8,123,10,123,12,123,2713,9,123,1,124,1,124, + 1,122,1,122,1,122,1,122,1,122,1,122,1,122,3,122,2733,8,122,1,123,5,123, + 2736,8,123,10,123,12,123,2739,9,123,1,124,1,124,1,124,1,124,1,124,1,124, 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, - 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,3,124, - 2752,8,124,1,125,1,125,3,125,2756,8,125,1,125,1,125,1,126,1,126,1,126, - 1,126,1,126,1,126,3,126,2766,8,126,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,128,1,128,1,128,1,128,1,128, - 1,128,1,128,3,128,2788,8,128,1,129,1,129,1,129,1,129,1,129,1,129,1,129, - 1,129,5,129,2798,8,129,10,129,12,129,2801,9,129,1,129,1,129,1,129,1,129, - 1,129,1,129,5,129,2809,8,129,10,129,12,129,2812,9,129,1,129,1,129,1,129, - 1,129,1,129,1,129,1,129,1,129,1,129,1,129,5,129,2824,8,129,10,129,12,129, - 2827,9,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,5,129,2837, - 8,129,10,129,12,129,2840,9,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129, - 1,129,5,129,2850,8,129,10,129,12,129,2853,9,129,3,129,2855,8,129,1,130, - 1,130,1,130,1,130,1,131,1,131,3,131,2863,8,131,1,132,1,132,1,132,1,132, - 1,133,1,133,1,133,1,134,1,134,1,134,4,134,2875,8,134,11,134,12,134,2876, + 1,124,1,124,1,124,1,124,1,124,1,124,1,124,3,124,2778,8,124,1,125,1,125, + 3,125,2782,8,125,1,125,1,125,1,126,1,126,1,126,1,126,1,126,1,126,3,126, + 2792,8,126,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,128,1,128,1,128,1,128,1,128,1,128,1,128,3,128,2814, + 8,128,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,5,129,2824,8,129, + 10,129,12,129,2827,9,129,1,129,1,129,1,129,1,129,1,129,1,129,5,129,2835, + 8,129,10,129,12,129,2838,9,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129, + 1,129,1,129,1,129,5,129,2850,8,129,10,129,12,129,2853,9,129,1,129,1,129, + 1,129,1,129,1,129,1,129,1,129,1,129,5,129,2863,8,129,10,129,12,129,2866, + 9,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,5,129,2876,8,129, + 10,129,12,129,2879,9,129,3,129,2881,8,129,1,130,1,130,1,130,1,130,1,131, + 1,131,1,131,1,131,1,131,1,131,3,131,2893,8,131,1,132,1,132,1,132,1,132, + 1,133,1,133,1,133,1,134,1,134,1,134,4,134,2905,8,134,11,134,12,134,2906, 1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135, - 1,135,1,135,1,135,1,135,3,135,2895,8,135,1,136,1,136,1,136,1,136,1,136, + 1,135,1,135,1,135,1,135,3,135,2925,8,135,1,136,1,136,1,136,1,136,1,136, 1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,3,136, - 2913,8,136,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137, - 1,137,1,137,3,137,2927,8,137,1,138,1,138,1,138,1,139,1,139,1,140,1,140, + 2943,8,136,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137, + 1,137,1,137,3,137,2957,8,137,1,138,1,138,1,138,1,139,1,139,1,140,1,140, 1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141, - 1,141,1,141,1,141,3,141,2951,8,141,1,142,1,142,1,142,1,143,1,143,1,143, - 1,143,1,143,1,143,1,143,3,143,2963,8,143,1,144,1,144,1,144,3,144,2968, - 8,144,1,145,1,145,1,145,1,145,1,145,4,145,2975,8,145,11,145,12,145,2976, - 3,145,2979,8,145,1,146,1,146,1,146,5,146,2984,8,146,10,146,12,146,2987, - 9,146,1,146,1,146,1,147,1,147,1,147,1,147,1,147,3,147,2996,8,147,1,148, + 1,141,1,141,1,141,3,141,2981,8,141,1,142,1,142,1,142,1,143,1,143,1,143, + 1,143,1,143,1,143,1,143,3,143,2993,8,143,1,144,1,144,1,144,3,144,2998, + 8,144,1,145,1,145,1,145,1,145,1,145,4,145,3005,8,145,11,145,12,145,3006, + 3,145,3009,8,145,1,146,1,146,1,146,5,146,3014,8,146,10,146,12,146,3017, + 9,146,1,146,1,146,1,147,1,147,1,147,1,147,1,147,3,147,3026,8,147,1,148, 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, - 1,148,1,148,1,148,1,148,1,148,3,148,3064,8,148,1,149,1,149,1,149,1,149, + 1,148,1,148,1,148,1,148,1,148,3,148,3094,8,148,1,149,1,149,1,149,1,149, + 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, - 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,3,149, - 3141,8,149,1,150,1,150,1,150,5,150,3146,8,150,10,150,12,150,3149,9,150, - 1,151,1,151,1,152,1,152,1,152,3,152,3156,8,152,1,153,1,153,1,153,1,153, + 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, + 1,149,1,149,3,149,3186,8,149,1,150,1,150,1,150,5,150,3191,8,150,10,150, + 12,150,3194,9,150,1,151,1,151,1,152,1,152,1,152,1,152,1,152,1,152,1,152, + 1,152,3,152,3206,8,152,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, + 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, @@ -18688,1104 +18962,1139 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, - 3,153,3306,8,153,1,154,1,154,5,154,3310,8,154,10,154,12,154,3313,9,154, - 1,155,1,155,5,155,3317,8,155,10,155,12,155,3320,9,155,1,156,5,156,3323, - 8,156,10,156,12,156,3326,9,156,1,157,5,157,3329,8,157,10,157,12,157,3332, - 9,157,1,158,5,158,3335,8,158,10,158,12,158,3338,9,158,1,159,5,159,3341, - 8,159,10,159,12,159,3344,9,159,1,160,5,160,3347,8,160,10,160,12,160,3350, - 9,160,1,161,5,161,3353,8,161,10,161,12,161,3356,9,161,1,162,5,162,3359, - 8,162,10,162,12,162,3362,9,162,1,163,1,163,1,163,1,163,3,163,3368,8,163, - 1,164,5,164,3371,8,164,10,164,12,164,3374,9,164,1,165,1,165,1,165,3,165, - 3379,8,165,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166, + 1,153,1,153,1,153,1,153,1,153,1,153,1,153,3,153,3379,8,153,1,154,1,154, + 1,154,1,154,1,154,1,154,5,154,3387,8,154,10,154,12,154,3390,9,154,1,155, + 1,155,1,155,1,155,1,155,1,155,5,155,3398,8,155,10,155,12,155,3401,9,155, + 1,156,1,156,1,156,5,156,3406,8,156,10,156,12,156,3409,9,156,1,157,1,157, + 1,157,5,157,3414,8,157,10,157,12,157,3417,9,157,1,158,1,158,1,158,5,158, + 3422,8,158,10,158,12,158,3425,9,158,1,159,1,159,1,159,5,159,3430,8,159, + 10,159,12,159,3433,9,159,1,160,1,160,1,160,5,160,3438,8,160,10,160,12, + 160,3441,9,160,1,161,1,161,1,161,1,161,5,161,3447,8,161,10,161,12,161, + 3450,9,161,1,162,1,162,1,162,5,162,3455,8,162,10,162,12,162,3458,9,162, + 1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,3,163,3468,8,163,1,164, + 1,164,1,164,5,164,3473,8,164,10,164,12,164,3476,9,164,1,165,1,165,1,165, + 1,165,1,165,1,165,1,165,1,165,1,165,3,165,3487,8,165,1,166,1,166,1,166, 1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166, - 1,166,1,166,1,166,3,166,3406,8,166,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,168,3,168, - 3425,8,168,1,169,5,169,3428,8,169,10,169,12,169,3431,9,169,1,170,1,170, - 1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170, - 3,170,3447,8,170,1,171,1,171,1,171,1,171,1,171,1,172,1,172,1,172,5,172, - 3457,8,172,10,172,12,172,3460,9,172,1,172,1,172,1,173,1,173,5,173,3466, - 8,173,10,173,12,173,3469,9,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,3,174,3488, - 8,174,1,175,5,175,3491,8,175,10,175,12,175,3494,9,175,1,176,1,176,1,176, - 1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176,3,176,3509, - 8,176,1,177,1,177,1,177,1,177,1,177,1,178,1,178,5,178,3518,8,178,10,178, - 12,178,3521,9,178,1,178,1,178,1,178,5,178,3526,8,178,10,178,12,178,3529, - 9,178,1,178,1,178,1,178,1,178,3,178,3535,8,178,1,179,1,179,1,180,5,180, - 3540,8,180,10,180,12,180,3543,9,180,1,181,1,181,1,181,1,181,1,181,1,181, - 1,181,1,181,1,181,1,181,3,181,3555,8,181,1,181,0,1,68,182,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,0,14,6,0,1,15,199,199,243,243,247,247,264,264,289,289,5,0, - 16,16,199,199,243,243,264,264,288,289,1,0,263,264,1,0,173,174,1,0,37,38, - 1,0,73,74,3,0,2,2,61,61,77,83,2,0,229,229,260,261,1,0,95,96,1,0,97,111, - 2,0,173,173,289,290,2,0,179,179,264,264,1,0,167,168,1,0,51,52,4018,0,364, - 1,0,0,0,2,382,1,0,0,0,4,384,1,0,0,0,6,391,1,0,0,0,8,400,1,0,0,0,10,489, - 1,0,0,0,12,491,1,0,0,0,14,495,1,0,0,0,16,499,1,0,0,0,18,504,1,0,0,0,20, - 508,1,0,0,0,22,512,1,0,0,0,24,519,1,0,0,0,26,535,1,0,0,0,28,537,1,0,0, - 0,30,539,1,0,0,0,32,551,1,0,0,0,34,553,1,0,0,0,36,576,1,0,0,0,38,580,1, - 0,0,0,40,598,1,0,0,0,42,625,1,0,0,0,44,648,1,0,0,0,46,684,1,0,0,0,48,686, - 1,0,0,0,50,694,1,0,0,0,52,696,1,0,0,0,54,703,1,0,0,0,56,715,1,0,0,0,58, - 718,1,0,0,0,60,720,1,0,0,0,62,733,1,0,0,0,64,746,1,0,0,0,66,748,1,0,0, - 0,68,756,1,0,0,0,70,772,1,0,0,0,72,778,1,0,0,0,74,782,1,0,0,0,76,861,1, - 0,0,0,78,868,1,0,0,0,80,875,1,0,0,0,82,880,1,0,0,0,84,889,1,0,0,0,86,895, - 1,0,0,0,88,1000,1,0,0,0,90,1028,1,0,0,0,92,1030,1,0,0,0,94,1034,1,0,0, - 0,96,1036,1,0,0,0,98,1041,1,0,0,0,100,1069,1,0,0,0,102,1149,1,0,0,0,104, - 1151,1,0,0,0,106,1180,1,0,0,0,108,1182,1,0,0,0,110,1196,1,0,0,0,112,1225, - 1,0,0,0,114,1237,1,0,0,0,116,1276,1,0,0,0,118,1284,1,0,0,0,120,1293,1, - 0,0,0,122,1301,1,0,0,0,124,1320,1,0,0,0,126,1333,1,0,0,0,128,1357,1,0, - 0,0,130,1504,1,0,0,0,132,1514,1,0,0,0,134,1526,1,0,0,0,136,1608,1,0,0, - 0,138,1610,1,0,0,0,140,1649,1,0,0,0,142,1709,1,0,0,0,144,1749,1,0,0,0, - 146,1765,1,0,0,0,148,1767,1,0,0,0,150,1771,1,0,0,0,152,1826,1,0,0,0,154, - 1838,1,0,0,0,156,1853,1,0,0,0,158,1860,1,0,0,0,160,1865,1,0,0,0,162,1869, - 1,0,0,0,164,1905,1,0,0,0,166,1907,1,0,0,0,168,1951,1,0,0,0,170,1970,1, - 0,0,0,172,1991,1,0,0,0,174,1993,1,0,0,0,176,2010,1,0,0,0,178,2025,1,0, - 0,0,180,2033,1,0,0,0,182,2045,1,0,0,0,184,2065,1,0,0,0,186,2072,1,0,0, - 0,188,2075,1,0,0,0,190,2088,1,0,0,0,192,2094,1,0,0,0,194,2100,1,0,0,0, - 196,2104,1,0,0,0,198,2261,1,0,0,0,200,2263,1,0,0,0,202,2319,1,0,0,0,204, - 2330,1,0,0,0,206,2337,1,0,0,0,208,2345,1,0,0,0,210,2372,1,0,0,0,212,2378, - 1,0,0,0,214,2383,1,0,0,0,216,2412,1,0,0,0,218,2414,1,0,0,0,220,2434,1, - 0,0,0,222,2439,1,0,0,0,224,2464,1,0,0,0,226,2473,1,0,0,0,228,2488,1,0, - 0,0,230,2495,1,0,0,0,232,2515,1,0,0,0,234,2517,1,0,0,0,236,2588,1,0,0, - 0,238,2613,1,0,0,0,240,2657,1,0,0,0,242,2666,1,0,0,0,244,2706,1,0,0,0, - 246,2711,1,0,0,0,248,2751,1,0,0,0,250,2753,1,0,0,0,252,2759,1,0,0,0,254, - 2767,1,0,0,0,256,2787,1,0,0,0,258,2854,1,0,0,0,260,2856,1,0,0,0,262,2862, - 1,0,0,0,264,2864,1,0,0,0,266,2868,1,0,0,0,268,2874,1,0,0,0,270,2894,1, - 0,0,0,272,2912,1,0,0,0,274,2926,1,0,0,0,276,2928,1,0,0,0,278,2931,1,0, - 0,0,280,2933,1,0,0,0,282,2950,1,0,0,0,284,2952,1,0,0,0,286,2962,1,0,0, - 0,288,2967,1,0,0,0,290,2978,1,0,0,0,292,2985,1,0,0,0,294,2995,1,0,0,0, - 296,3063,1,0,0,0,298,3140,1,0,0,0,300,3147,1,0,0,0,302,3150,1,0,0,0,304, - 3155,1,0,0,0,306,3305,1,0,0,0,308,3311,1,0,0,0,310,3318,1,0,0,0,312,3324, - 1,0,0,0,314,3330,1,0,0,0,316,3336,1,0,0,0,318,3342,1,0,0,0,320,3348,1, - 0,0,0,322,3354,1,0,0,0,324,3360,1,0,0,0,326,3367,1,0,0,0,328,3372,1,0, - 0,0,330,3378,1,0,0,0,332,3405,1,0,0,0,334,3407,1,0,0,0,336,3424,1,0,0, - 0,338,3429,1,0,0,0,340,3446,1,0,0,0,342,3448,1,0,0,0,344,3453,1,0,0,0, - 346,3463,1,0,0,0,348,3487,1,0,0,0,350,3492,1,0,0,0,352,3508,1,0,0,0,354, - 3510,1,0,0,0,356,3534,1,0,0,0,358,3536,1,0,0,0,360,3541,1,0,0,0,362,3554, - 1,0,0,0,364,365,7,0,0,0,365,1,1,0,0,0,366,367,5,288,0,0,367,383,6,1,-1, - 0,368,369,3,4,2,0,369,370,6,1,-1,0,370,371,5,265,0,0,371,373,1,0,0,0,372, - 368,1,0,0,0,373,376,1,0,0,0,374,372,1,0,0,0,374,375,1,0,0,0,375,377,1, - 0,0,0,376,374,1,0,0,0,377,378,3,4,2,0,378,379,6,1,-1,0,379,383,1,0,0,0, - 380,381,5,264,0,0,381,383,6,1,-1,0,382,366,1,0,0,0,382,374,1,0,0,0,382, - 380,1,0,0,0,383,3,1,0,0,0,384,385,7,1,0,0,385,5,1,0,0,0,386,387,5,263, - 0,0,387,388,6,3,-1,0,388,390,5,266,0,0,389,386,1,0,0,0,390,393,1,0,0,0, - 391,389,1,0,0,0,391,392,1,0,0,0,392,394,1,0,0,0,393,391,1,0,0,0,394,395, - 5,263,0,0,395,396,6,3,-1,0,396,7,1,0,0,0,397,399,3,10,5,0,398,397,1,0, - 0,0,399,402,1,0,0,0,400,398,1,0,0,0,400,401,1,0,0,0,401,9,1,0,0,0,402, - 400,1,0,0,0,403,404,3,74,37,0,404,405,5,17,0,0,405,406,3,82,41,0,406,407, - 5,18,0,0,407,490,1,0,0,0,408,409,3,72,36,0,409,410,5,17,0,0,410,411,3, - 8,4,0,411,412,5,18,0,0,412,490,1,0,0,0,413,414,3,234,117,0,414,415,5,17, - 0,0,415,416,3,246,123,0,416,417,5,18,0,0,417,490,1,0,0,0,418,490,3,200, - 100,0,419,420,6,5,-1,0,420,421,3,284,142,0,421,422,6,5,-1,0,422,490,1, - 0,0,0,423,424,6,5,-1,0,424,425,3,70,35,0,425,426,6,5,-1,0,426,490,1,0, - 0,0,427,428,6,5,-1,0,428,429,3,66,33,0,429,430,6,5,-1,0,430,490,1,0,0, - 0,431,432,6,5,-1,0,432,433,3,88,44,0,433,434,6,5,-1,0,434,490,1,0,0,0, - 435,436,6,5,-1,0,436,437,3,90,45,0,437,438,6,5,-1,0,438,490,1,0,0,0,439, - 440,6,5,-1,0,440,441,3,22,11,0,441,442,6,5,-1,0,442,490,1,0,0,0,443,444, - 6,5,-1,0,444,445,3,334,167,0,445,446,6,5,-1,0,446,490,1,0,0,0,447,448, - 6,5,-1,0,448,449,3,342,171,0,449,450,6,5,-1,0,450,490,1,0,0,0,451,452, - 6,5,-1,0,452,453,3,354,177,0,453,454,6,5,-1,0,454,490,1,0,0,0,455,456, - 6,5,-1,0,456,457,3,64,32,0,457,458,6,5,-1,0,458,490,1,0,0,0,459,460,6, - 5,-1,0,460,461,3,152,76,0,461,462,6,5,-1,0,462,490,1,0,0,0,463,464,3,330, - 165,0,464,465,6,5,-1,0,465,490,1,0,0,0,466,467,6,5,-1,0,467,490,3,12,6, - 0,468,469,6,5,-1,0,469,490,3,14,7,0,470,471,6,5,-1,0,471,490,3,16,8,0, - 472,473,6,5,-1,0,473,490,3,18,9,0,474,475,6,5,-1,0,475,490,3,20,10,0,476, - 477,6,5,-1,0,477,478,3,26,13,0,478,479,6,5,-1,0,479,490,1,0,0,0,480,481, - 6,5,-1,0,481,482,3,42,21,0,482,483,6,5,-1,0,483,490,1,0,0,0,484,485,6, - 5,-1,0,485,490,3,40,20,0,486,490,3,30,15,0,487,488,6,5,-1,0,488,490,3, - 24,12,0,489,403,1,0,0,0,489,408,1,0,0,0,489,413,1,0,0,0,489,418,1,0,0, - 0,489,419,1,0,0,0,489,423,1,0,0,0,489,427,1,0,0,0,489,431,1,0,0,0,489, - 435,1,0,0,0,489,439,1,0,0,0,489,443,1,0,0,0,489,447,1,0,0,0,489,451,1, - 0,0,0,489,455,1,0,0,0,489,459,1,0,0,0,489,463,1,0,0,0,489,466,1,0,0,0, - 489,468,1,0,0,0,489,470,1,0,0,0,489,472,1,0,0,0,489,474,1,0,0,0,489,476, - 1,0,0,0,489,480,1,0,0,0,489,484,1,0,0,0,489,486,1,0,0,0,489,487,1,0,0, - 0,490,11,1,0,0,0,491,492,5,19,0,0,492,493,3,32,16,0,493,494,6,6,-1,0,494, - 13,1,0,0,0,495,496,5,20,0,0,496,497,3,32,16,0,497,498,6,7,-1,0,498,15, - 1,0,0,0,499,500,5,21,0,0,500,501,5,22,0,0,501,502,3,32,16,0,502,503,6, - 8,-1,0,503,17,1,0,0,0,504,505,5,23,0,0,505,506,3,34,17,0,506,507,6,9,-1, - 0,507,19,1,0,0,0,508,509,5,24,0,0,509,510,3,34,17,0,510,511,6,10,-1,0, - 511,21,1,0,0,0,512,513,5,25,0,0,513,514,3,98,49,0,514,515,3,2,1,0,515, - 516,5,17,0,0,516,517,3,120,60,0,517,518,5,18,0,0,518,23,1,0,0,0,519,520, - 5,26,0,0,520,25,1,0,0,0,521,522,5,27,0,0,522,536,3,28,14,0,523,524,5,27, - 0,0,524,525,3,28,14,0,525,526,5,28,0,0,526,527,3,28,14,0,527,536,1,0,0, - 0,528,529,5,27,0,0,529,530,3,28,14,0,530,531,5,28,0,0,531,532,3,28,14, - 0,532,533,5,28,0,0,533,534,3,28,14,0,534,536,1,0,0,0,535,521,1,0,0,0,535, - 523,1,0,0,0,535,528,1,0,0,0,536,27,1,0,0,0,537,538,7,2,0,0,538,29,1,0, - 0,0,539,540,5,29,0,0,540,546,5,17,0,0,541,542,3,116,58,0,542,543,6,15, - -1,0,543,545,1,0,0,0,544,541,1,0,0,0,545,548,1,0,0,0,546,544,1,0,0,0,546, - 547,1,0,0,0,547,549,1,0,0,0,548,546,1,0,0,0,549,550,5,18,0,0,550,31,1, - 0,0,0,551,552,5,173,0,0,552,33,1,0,0,0,553,554,7,3,0,0,554,35,1,0,0,0, - 555,556,5,175,0,0,556,577,6,18,-1,0,557,558,3,32,16,0,558,559,5,265,0, - 0,559,560,6,18,-1,0,560,577,1,0,0,0,561,562,3,32,16,0,562,563,6,18,-1, - 0,563,577,1,0,0,0,564,565,5,188,0,0,565,566,5,30,0,0,566,567,3,32,16,0, - 567,568,5,31,0,0,568,569,6,18,-1,0,569,577,1,0,0,0,570,571,5,189,0,0,571, - 572,5,30,0,0,572,573,3,34,17,0,573,574,5,31,0,0,574,575,6,18,-1,0,575, - 577,1,0,0,0,576,555,1,0,0,0,576,557,1,0,0,0,576,561,1,0,0,0,576,564,1, - 0,0,0,576,570,1,0,0,0,577,37,1,0,0,0,578,581,3,32,16,0,579,581,5,262,0, - 0,580,578,1,0,0,0,580,579,1,0,0,0,581,39,1,0,0,0,582,583,5,267,0,0,583, - 599,5,289,0,0,584,585,5,267,0,0,585,586,5,289,0,0,586,599,5,263,0,0,587, - 588,5,268,0,0,588,599,5,289,0,0,589,590,5,269,0,0,590,599,5,289,0,0,591, - 592,5,270,0,0,592,599,5,289,0,0,593,599,5,271,0,0,594,599,5,272,0,0,595, - 596,5,273,0,0,596,599,5,263,0,0,597,599,5,32,0,0,598,582,1,0,0,0,598,584, - 1,0,0,0,598,587,1,0,0,0,598,589,1,0,0,0,598,591,1,0,0,0,598,593,1,0,0, - 0,598,594,1,0,0,0,598,595,1,0,0,0,598,597,1,0,0,0,599,41,1,0,0,0,600,601, - 5,33,0,0,601,602,3,138,69,0,602,603,5,34,0,0,603,604,3,2,1,0,604,626,1, - 0,0,0,605,606,5,33,0,0,606,607,3,116,58,0,607,608,5,34,0,0,608,609,3,2, - 1,0,609,626,1,0,0,0,610,611,5,33,0,0,611,612,3,176,88,0,612,613,5,34,0, - 0,613,614,3,2,1,0,614,626,1,0,0,0,615,616,5,33,0,0,616,617,3,44,22,0,617, - 618,5,34,0,0,618,619,3,2,1,0,619,626,1,0,0,0,620,621,5,33,0,0,621,622, - 3,46,23,0,622,623,5,34,0,0,623,624,3,2,1,0,624,626,1,0,0,0,625,600,1,0, - 0,0,625,605,1,0,0,0,625,610,1,0,0,0,625,615,1,0,0,0,625,620,1,0,0,0,626, - 43,1,0,0,0,627,628,5,35,0,0,628,649,3,48,24,0,629,630,5,35,0,0,630,631, - 3,48,24,0,631,632,5,36,0,0,632,633,3,6,3,0,633,649,1,0,0,0,634,635,5,35, - 0,0,635,636,3,48,24,0,636,637,5,36,0,0,637,638,5,17,0,0,638,639,3,52,26, - 0,639,640,5,18,0,0,640,649,1,0,0,0,641,642,5,35,0,0,642,643,3,48,24,0, - 643,644,5,36,0,0,644,645,5,30,0,0,645,646,3,300,150,0,646,647,5,31,0,0, - 647,649,1,0,0,0,648,627,1,0,0,0,648,629,1,0,0,0,648,634,1,0,0,0,648,641, - 1,0,0,0,649,45,1,0,0,0,650,651,5,35,0,0,651,652,5,30,0,0,652,653,3,50, - 25,0,653,654,5,31,0,0,654,655,3,48,24,0,655,685,1,0,0,0,656,657,5,35,0, - 0,657,658,5,30,0,0,658,659,3,50,25,0,659,660,5,31,0,0,660,661,3,48,24, - 0,661,662,5,36,0,0,662,663,3,6,3,0,663,685,1,0,0,0,664,665,5,35,0,0,665, - 666,5,30,0,0,666,667,3,50,25,0,667,668,5,31,0,0,668,669,3,48,24,0,669, - 670,5,36,0,0,670,671,5,17,0,0,671,672,3,52,26,0,672,673,5,18,0,0,673,685, - 1,0,0,0,674,675,5,35,0,0,675,676,5,30,0,0,676,677,3,50,25,0,677,678,5, - 31,0,0,678,679,3,48,24,0,679,680,5,36,0,0,680,681,5,30,0,0,681,682,3,300, - 150,0,682,683,5,31,0,0,683,685,1,0,0,0,684,650,1,0,0,0,684,656,1,0,0,0, - 684,664,1,0,0,0,684,674,1,0,0,0,685,47,1,0,0,0,686,687,3,168,84,0,687, - 49,1,0,0,0,688,689,3,124,62,0,689,690,6,25,-1,0,690,695,1,0,0,0,691,692, - 3,176,88,0,692,693,6,25,-1,0,693,695,1,0,0,0,694,688,1,0,0,0,694,691,1, - 0,0,0,695,51,1,0,0,0,696,697,3,54,27,0,697,698,3,56,28,0,698,53,1,0,0, - 0,699,702,3,306,153,0,700,702,3,40,20,0,701,699,1,0,0,0,701,700,1,0,0, - 0,702,705,1,0,0,0,703,701,1,0,0,0,703,704,1,0,0,0,704,55,1,0,0,0,705,703, - 1,0,0,0,706,707,3,58,29,0,707,708,3,60,30,0,708,709,3,2,1,0,709,710,5, - 36,0,0,710,711,3,306,153,0,711,714,1,0,0,0,712,714,3,40,20,0,713,706,1, - 0,0,0,713,712,1,0,0,0,714,717,1,0,0,0,715,713,1,0,0,0,715,716,1,0,0,0, - 716,57,1,0,0,0,717,715,1,0,0,0,718,719,7,4,0,0,719,59,1,0,0,0,720,722, - 3,62,31,0,721,723,5,261,0,0,722,721,1,0,0,0,722,723,1,0,0,0,723,61,1,0, - 0,0,724,734,3,144,72,0,725,734,3,2,1,0,726,734,5,196,0,0,727,734,5,197, - 0,0,728,729,5,202,0,0,729,730,5,39,0,0,730,734,5,264,0,0,731,732,5,202, - 0,0,732,734,3,116,58,0,733,724,1,0,0,0,733,725,1,0,0,0,733,726,1,0,0,0, - 733,727,1,0,0,0,733,728,1,0,0,0,733,731,1,0,0,0,734,63,1,0,0,0,735,736, - 5,198,0,0,736,737,5,40,0,0,737,738,3,2,1,0,738,739,6,32,-1,0,739,747,1, - 0,0,0,740,741,5,198,0,0,741,742,3,2,1,0,742,743,6,32,-1,0,743,747,1,0, - 0,0,744,745,5,198,0,0,745,747,6,32,-1,0,746,735,1,0,0,0,746,740,1,0,0, - 0,746,744,1,0,0,0,747,65,1,0,0,0,748,749,5,41,0,0,749,750,5,42,0,0,750, - 751,3,32,16,0,751,752,5,43,0,0,752,753,3,68,34,0,753,754,5,44,0,0,754, - 755,3,0,0,0,755,67,1,0,0,0,756,769,6,34,-1,0,757,758,10,5,0,0,758,768, - 5,186,0,0,759,760,10,4,0,0,760,768,5,187,0,0,761,762,10,3,0,0,762,768, - 5,45,0,0,763,764,10,2,0,0,764,768,5,46,0,0,765,766,10,1,0,0,766,768,5, - 47,0,0,767,757,1,0,0,0,767,759,1,0,0,0,767,761,1,0,0,0,767,763,1,0,0,0, - 767,765,1,0,0,0,768,771,1,0,0,0,769,767,1,0,0,0,769,770,1,0,0,0,770,69, - 1,0,0,0,771,769,1,0,0,0,772,773,5,48,0,0,773,774,5,36,0,0,774,775,5,30, - 0,0,775,776,3,300,150,0,776,777,5,31,0,0,777,71,1,0,0,0,778,779,5,49,0, - 0,779,780,3,2,1,0,780,781,6,36,-1,0,781,73,1,0,0,0,782,788,5,50,0,0,783, - 784,3,76,38,0,784,785,6,37,-1,0,785,787,1,0,0,0,786,783,1,0,0,0,787,790, - 1,0,0,0,788,786,1,0,0,0,788,789,1,0,0,0,789,791,1,0,0,0,790,788,1,0,0, - 0,791,792,3,2,1,0,792,793,3,182,91,0,793,794,3,78,39,0,794,795,3,80,40, - 0,795,796,6,37,-1,0,796,75,1,0,0,0,797,798,5,51,0,0,798,862,6,38,-1,0, - 799,800,5,52,0,0,800,862,6,38,-1,0,801,802,5,199,0,0,802,862,6,38,-1,0, - 803,804,5,202,0,0,804,862,6,38,-1,0,805,806,5,221,0,0,806,862,6,38,-1, - 0,807,808,5,53,0,0,808,862,6,38,-1,0,809,810,5,54,0,0,810,862,6,38,-1, - 0,811,812,5,55,0,0,812,862,6,38,-1,0,813,814,5,56,0,0,814,862,6,38,-1, - 0,815,816,5,244,0,0,816,862,6,38,-1,0,817,818,5,15,0,0,818,862,6,38,-1, - 0,819,820,5,224,0,0,820,862,6,38,-1,0,821,822,5,57,0,0,822,862,6,38,-1, - 0,823,824,5,58,0,0,824,862,6,38,-1,0,825,826,5,59,0,0,826,862,6,38,-1, - 0,827,828,5,60,0,0,828,862,6,38,-1,0,829,830,5,61,0,0,830,862,6,38,-1, - 0,831,832,5,62,0,0,832,833,5,51,0,0,833,862,6,38,-1,0,834,835,5,62,0,0, - 835,836,5,52,0,0,836,862,6,38,-1,0,837,838,5,62,0,0,838,839,5,63,0,0,839, - 862,6,38,-1,0,840,841,5,62,0,0,841,842,5,64,0,0,842,862,6,38,-1,0,843, - 844,5,62,0,0,844,845,5,65,0,0,845,862,6,38,-1,0,846,847,5,62,0,0,847,848, - 5,66,0,0,848,862,6,38,-1,0,849,850,5,67,0,0,850,862,6,38,-1,0,851,852, - 5,68,0,0,852,862,6,38,-1,0,853,854,5,69,0,0,854,862,6,38,-1,0,855,856, - 5,70,0,0,856,857,5,30,0,0,857,858,3,32,16,0,858,859,5,31,0,0,859,860,6, - 38,-1,0,860,862,1,0,0,0,861,797,1,0,0,0,861,799,1,0,0,0,861,801,1,0,0, - 0,861,803,1,0,0,0,861,805,1,0,0,0,861,807,1,0,0,0,861,809,1,0,0,0,861, - 811,1,0,0,0,861,813,1,0,0,0,861,815,1,0,0,0,861,817,1,0,0,0,861,819,1, - 0,0,0,861,821,1,0,0,0,861,823,1,0,0,0,861,825,1,0,0,0,861,827,1,0,0,0, - 861,829,1,0,0,0,861,831,1,0,0,0,861,834,1,0,0,0,861,837,1,0,0,0,861,840, - 1,0,0,0,861,843,1,0,0,0,861,846,1,0,0,0,861,849,1,0,0,0,861,851,1,0,0, - 0,861,853,1,0,0,0,861,855,1,0,0,0,862,77,1,0,0,0,863,869,1,0,0,0,864,865, - 5,71,0,0,865,866,3,124,62,0,866,867,6,39,-1,0,867,869,1,0,0,0,868,863, - 1,0,0,0,868,864,1,0,0,0,869,79,1,0,0,0,870,876,1,0,0,0,871,872,5,72,0, - 0,872,873,3,84,42,0,873,874,6,40,-1,0,874,876,1,0,0,0,875,870,1,0,0,0, - 875,871,1,0,0,0,876,81,1,0,0,0,877,879,3,198,99,0,878,877,1,0,0,0,879, - 882,1,0,0,0,880,878,1,0,0,0,880,881,1,0,0,0,881,83,1,0,0,0,882,880,1,0, - 0,0,883,884,3,124,62,0,884,885,6,42,-1,0,885,886,5,28,0,0,886,888,1,0, - 0,0,887,883,1,0,0,0,888,891,1,0,0,0,889,887,1,0,0,0,889,890,1,0,0,0,890, - 892,1,0,0,0,891,889,1,0,0,0,892,893,3,124,62,0,893,894,6,42,-1,0,894,85, - 1,0,0,0,895,896,7,5,0,0,896,87,1,0,0,0,897,898,3,86,43,0,898,899,3,32, - 16,0,899,900,5,264,0,0,900,1001,1,0,0,0,901,902,3,86,43,0,902,903,3,32, - 16,0,903,1001,1,0,0,0,904,905,3,86,43,0,905,906,3,32,16,0,906,907,5,75, - 0,0,907,908,3,32,16,0,908,909,5,264,0,0,909,1001,1,0,0,0,910,911,3,86, - 43,0,911,912,3,32,16,0,912,913,5,75,0,0,913,914,3,32,16,0,914,1001,1,0, - 0,0,915,916,3,86,43,0,916,917,3,32,16,0,917,918,5,75,0,0,918,919,3,32, - 16,0,919,920,5,28,0,0,920,921,3,32,16,0,921,922,5,264,0,0,922,1001,1,0, - 0,0,923,924,3,86,43,0,924,925,3,32,16,0,925,926,5,75,0,0,926,927,3,32, - 16,0,927,928,5,28,0,0,928,929,3,32,16,0,929,1001,1,0,0,0,930,931,3,86, - 43,0,931,932,3,32,16,0,932,933,5,28,0,0,933,934,3,32,16,0,934,935,5,75, - 0,0,935,936,3,32,16,0,936,937,5,264,0,0,937,1001,1,0,0,0,938,939,3,86, - 43,0,939,940,3,32,16,0,940,941,5,28,0,0,941,942,3,32,16,0,942,943,5,75, - 0,0,943,944,3,32,16,0,944,1001,1,0,0,0,945,946,3,86,43,0,946,947,3,32, - 16,0,947,948,5,28,0,0,948,949,3,32,16,0,949,950,5,75,0,0,950,951,3,32, - 16,0,951,952,5,28,0,0,952,953,3,32,16,0,953,954,5,264,0,0,954,1001,1,0, - 0,0,955,956,3,86,43,0,956,957,3,32,16,0,957,958,5,28,0,0,958,959,3,32, - 16,0,959,960,5,75,0,0,960,961,3,32,16,0,961,962,5,28,0,0,962,963,3,32, - 16,0,963,1001,1,0,0,0,964,965,3,86,43,0,965,966,3,32,16,0,966,967,5,263, - 0,0,967,1001,1,0,0,0,968,969,3,86,43,0,969,970,3,32,16,0,970,971,5,75, - 0,0,971,972,3,32,16,0,972,973,5,263,0,0,973,1001,1,0,0,0,974,975,3,86, - 43,0,975,976,3,32,16,0,976,977,5,75,0,0,977,978,3,32,16,0,978,979,5,28, - 0,0,979,980,3,32,16,0,980,981,5,263,0,0,981,1001,1,0,0,0,982,983,3,86, - 43,0,983,984,3,32,16,0,984,985,5,28,0,0,985,986,3,32,16,0,986,987,5,75, - 0,0,987,988,3,32,16,0,988,989,5,263,0,0,989,1001,1,0,0,0,990,991,3,86, - 43,0,991,992,3,32,16,0,992,993,5,28,0,0,993,994,3,32,16,0,994,995,5,75, - 0,0,995,996,3,32,16,0,996,997,5,28,0,0,997,998,3,32,16,0,998,999,5,263, - 0,0,999,1001,1,0,0,0,1000,897,1,0,0,0,1000,901,1,0,0,0,1000,904,1,0,0, - 0,1000,910,1,0,0,0,1000,915,1,0,0,0,1000,923,1,0,0,0,1000,930,1,0,0,0, - 1000,938,1,0,0,0,1000,945,1,0,0,0,1000,955,1,0,0,0,1000,964,1,0,0,0,1000, - 968,1,0,0,0,1000,974,1,0,0,0,1000,982,1,0,0,0,1000,990,1,0,0,0,1001,89, - 1,0,0,0,1002,1006,5,21,0,0,1003,1005,3,92,46,0,1004,1003,1,0,0,0,1005, - 1008,1,0,0,0,1006,1004,1,0,0,0,1006,1007,1,0,0,0,1007,1009,1,0,0,0,1008, - 1006,1,0,0,0,1009,1010,3,2,1,0,1010,1011,3,94,47,0,1011,1012,5,180,0,0, - 1012,1013,5,36,0,0,1013,1014,5,30,0,0,1014,1015,3,300,150,0,1015,1016, - 5,31,0,0,1016,1017,3,94,47,0,1017,1029,1,0,0,0,1018,1022,5,21,0,0,1019, - 1021,3,92,46,0,1020,1019,1,0,0,0,1021,1024,1,0,0,0,1022,1020,1,0,0,0,1022, - 1023,1,0,0,0,1023,1025,1,0,0,0,1024,1022,1,0,0,0,1025,1026,3,2,1,0,1026, - 1027,3,94,47,0,1027,1029,1,0,0,0,1028,1002,1,0,0,0,1028,1018,1,0,0,0,1029, - 91,1,0,0,0,1030,1031,5,76,0,0,1031,93,1,0,0,0,1032,1035,1,0,0,0,1033,1035, - 5,298,0,0,1034,1032,1,0,0,0,1034,1033,1,0,0,0,1035,95,1,0,0,0,1036,1037, - 7,6,0,0,1037,97,1,0,0,0,1038,1040,3,96,48,0,1039,1038,1,0,0,0,1040,1043, - 1,0,0,0,1041,1039,1,0,0,0,1041,1042,1,0,0,0,1042,99,1,0,0,0,1043,1041, - 1,0,0,0,1044,1070,3,102,51,0,1045,1046,5,280,0,0,1046,1047,3,168,84,0, - 1047,1048,6,50,-1,0,1048,1070,1,0,0,0,1049,1050,5,286,0,0,1050,1051,3, - 178,89,0,1051,1052,6,50,-1,0,1052,1070,1,0,0,0,1053,1054,5,286,0,0,1054, - 1055,3,174,87,0,1055,1056,6,50,-1,0,1056,1070,1,0,0,0,1057,1058,5,284, - 0,0,1058,1059,3,124,62,0,1059,1060,6,50,-1,0,1060,1070,1,0,0,0,1061,1062, - 5,281,0,0,1062,1063,3,104,52,0,1063,1064,6,50,-1,0,1064,1070,1,0,0,0,1065, - 1066,5,287,0,0,1066,1067,3,50,25,0,1067,1068,6,50,-1,0,1068,1070,1,0,0, - 0,1069,1044,1,0,0,0,1069,1045,1,0,0,0,1069,1049,1,0,0,0,1069,1053,1,0, - 0,0,1069,1057,1,0,0,0,1069,1061,1,0,0,0,1069,1065,1,0,0,0,1070,101,1,0, - 0,0,1071,1072,5,275,0,0,1072,1150,6,51,-1,0,1073,1074,5,276,0,0,1074,1075, - 3,32,16,0,1075,1076,6,51,-1,0,1076,1150,1,0,0,0,1077,1078,5,276,0,0,1078, - 1079,3,0,0,0,1079,1080,6,51,-1,0,1080,1150,1,0,0,0,1081,1082,5,277,0,0, - 1082,1083,3,32,16,0,1083,1084,6,51,-1,0,1084,1150,1,0,0,0,1085,1086,5, - 278,0,0,1086,1087,3,34,17,0,1087,1088,6,51,-1,0,1088,1150,1,0,0,0,1089, - 1090,5,279,0,0,1090,1091,3,36,18,0,1091,1092,6,51,-1,0,1092,1150,1,0,0, - 0,1093,1094,5,279,0,0,1094,1095,3,34,17,0,1095,1096,6,51,-1,0,1096,1150, - 1,0,0,0,1097,1098,5,279,0,0,1098,1099,5,30,0,0,1099,1100,3,300,150,0,1100, - 1101,5,31,0,0,1101,1102,6,51,-1,0,1102,1150,1,0,0,0,1103,1104,5,279,0, - 0,1104,1105,5,84,0,0,1105,1106,5,30,0,0,1106,1107,3,300,150,0,1107,1108, - 5,31,0,0,1108,1109,6,51,-1,0,1109,1150,1,0,0,0,1110,1111,5,282,0,0,1111, - 1112,3,32,16,0,1112,1113,6,51,-1,0,1113,1150,1,0,0,0,1114,1115,5,282,0, - 0,1115,1116,3,0,0,0,1116,1117,6,51,-1,0,1117,1150,1,0,0,0,1118,1119,5, - 285,0,0,1119,1120,3,6,3,0,1120,1121,6,51,-1,0,1121,1150,1,0,0,0,1122,1123, - 5,285,0,0,1123,1124,5,224,0,0,1124,1125,5,30,0,0,1125,1126,3,6,3,0,1126, - 1127,5,31,0,0,1127,1128,6,51,-1,0,1128,1150,1,0,0,0,1129,1130,5,285,0, - 0,1130,1131,5,84,0,0,1131,1132,5,30,0,0,1132,1133,3,300,150,0,1133,1134, - 5,31,0,0,1134,1135,6,51,-1,0,1135,1150,1,0,0,0,1136,1137,5,287,0,0,1137, - 1138,3,32,16,0,1138,1139,6,51,-1,0,1139,1150,1,0,0,0,1140,1141,5,283,0, - 0,1141,1147,6,51,-1,0,1142,1143,5,30,0,0,1143,1144,3,106,53,0,1144,1145, - 5,31,0,0,1145,1148,1,0,0,0,1146,1148,5,85,0,0,1147,1142,1,0,0,0,1147,1146, - 1,0,0,0,1148,1150,1,0,0,0,1149,1071,1,0,0,0,1149,1073,1,0,0,0,1149,1077, - 1,0,0,0,1149,1081,1,0,0,0,1149,1085,1,0,0,0,1149,1089,1,0,0,0,1149,1093, - 1,0,0,0,1149,1097,1,0,0,0,1149,1103,1,0,0,0,1149,1110,1,0,0,0,1149,1114, - 1,0,0,0,1149,1118,1,0,0,0,1149,1122,1,0,0,0,1149,1129,1,0,0,0,1149,1136, - 1,0,0,0,1149,1140,1,0,0,0,1150,103,1,0,0,0,1151,1152,3,170,85,0,1152,1153, - 3,138,69,0,1153,1154,3,112,56,0,1154,1155,6,52,-1,0,1155,105,1,0,0,0,1156, - 1181,1,0,0,0,1157,1158,3,0,0,0,1158,1159,6,53,-1,0,1159,1164,1,0,0,0,1160, - 1161,3,32,16,0,1161,1162,6,53,-1,0,1162,1164,1,0,0,0,1163,1157,1,0,0,0, - 1163,1160,1,0,0,0,1164,1165,1,0,0,0,1165,1166,5,28,0,0,1166,1168,1,0,0, - 0,1167,1163,1,0,0,0,1168,1171,1,0,0,0,1169,1167,1,0,0,0,1169,1170,1,0, - 0,0,1170,1178,1,0,0,0,1171,1169,1,0,0,0,1172,1173,3,0,0,0,1173,1174,6, - 53,-1,0,1174,1179,1,0,0,0,1175,1176,3,32,16,0,1176,1177,6,53,-1,0,1177, - 1179,1,0,0,0,1178,1172,1,0,0,0,1178,1175,1,0,0,0,1179,1181,1,0,0,0,1180, - 1156,1,0,0,0,1180,1169,1,0,0,0,1181,107,1,0,0,0,1182,1189,5,86,0,0,1183, - 1184,3,138,69,0,1184,1185,6,54,-1,0,1185,1186,5,28,0,0,1186,1188,1,0,0, - 0,1187,1183,1,0,0,0,1188,1191,1,0,0,0,1189,1187,1,0,0,0,1189,1190,1,0, - 0,0,1190,1192,1,0,0,0,1191,1189,1,0,0,0,1192,1193,3,138,69,0,1193,1194, - 6,54,-1,0,1194,1195,5,87,0,0,1195,109,1,0,0,0,1196,1203,5,42,0,0,1197, - 1198,3,146,73,0,1198,1199,6,55,-1,0,1199,1200,5,28,0,0,1200,1202,1,0,0, - 0,1201,1197,1,0,0,0,1202,1205,1,0,0,0,1203,1201,1,0,0,0,1203,1204,1,0, - 0,0,1204,1206,1,0,0,0,1205,1203,1,0,0,0,1206,1207,3,146,73,0,1207,1208, - 6,55,-1,0,1208,1209,5,43,0,0,1209,111,1,0,0,0,1210,1217,5,30,0,0,1211, - 1212,3,114,57,0,1212,1213,6,56,-1,0,1213,1214,5,28,0,0,1214,1216,1,0,0, - 0,1215,1211,1,0,0,0,1216,1219,1,0,0,0,1217,1215,1,0,0,0,1217,1218,1,0, - 0,0,1218,1220,1,0,0,0,1219,1217,1,0,0,0,1220,1221,3,114,57,0,1221,1222, - 6,56,-1,0,1222,1223,5,31,0,0,1223,1226,1,0,0,0,1224,1226,5,85,0,0,1225, - 1210,1,0,0,0,1225,1224,1,0,0,0,1226,113,1,0,0,0,1227,1228,5,177,0,0,1228, - 1238,6,57,-1,0,1229,1230,3,230,115,0,1230,1231,3,138,69,0,1231,1233,3, - 226,113,0,1232,1234,3,0,0,0,1233,1232,1,0,0,0,1233,1234,1,0,0,0,1234,1235, - 1,0,0,0,1235,1236,6,57,-1,0,1236,1238,1,0,0,0,1237,1227,1,0,0,0,1237,1229, - 1,0,0,0,1238,115,1,0,0,0,1239,1240,5,42,0,0,1240,1241,3,2,1,0,1241,1242, - 5,43,0,0,1242,1243,3,118,59,0,1243,1244,6,58,-1,0,1244,1277,1,0,0,0,1245, - 1246,5,42,0,0,1246,1247,3,174,87,0,1247,1248,5,43,0,0,1248,1249,3,118, - 59,0,1249,1250,6,58,-1,0,1250,1277,1,0,0,0,1251,1252,5,42,0,0,1252,1253, - 5,262,0,0,1253,1254,5,43,0,0,1254,1255,3,118,59,0,1255,1256,6,58,-1,0, - 1256,1277,1,0,0,0,1257,1258,5,42,0,0,1258,1259,5,198,0,0,1259,1260,3,2, - 1,0,1260,1261,5,43,0,0,1261,1262,3,118,59,0,1262,1263,6,58,-1,0,1263,1277, - 1,0,0,0,1264,1265,3,118,59,0,1265,1266,6,58,-1,0,1266,1277,1,0,0,0,1267, - 1268,3,174,87,0,1268,1269,6,58,-1,0,1269,1277,1,0,0,0,1270,1271,5,257, - 0,0,1271,1277,6,58,-1,0,1272,1273,5,258,0,0,1273,1277,6,58,-1,0,1274,1275, - 5,259,0,0,1275,1277,6,58,-1,0,1276,1239,1,0,0,0,1276,1245,1,0,0,0,1276, - 1251,1,0,0,0,1276,1257,1,0,0,0,1276,1264,1,0,0,0,1276,1267,1,0,0,0,1276, - 1270,1,0,0,0,1276,1272,1,0,0,0,1276,1274,1,0,0,0,1277,117,1,0,0,0,1278, - 1279,3,2,1,0,1279,1280,6,59,-1,0,1280,1281,5,88,0,0,1281,1283,1,0,0,0, - 1282,1278,1,0,0,0,1283,1286,1,0,0,0,1284,1282,1,0,0,0,1284,1285,1,0,0, - 0,1285,1287,1,0,0,0,1286,1284,1,0,0,0,1287,1288,3,2,1,0,1288,1289,6,59, - -1,0,1289,119,1,0,0,0,1290,1292,3,122,61,0,1291,1290,1,0,0,0,1292,1295, - 1,0,0,0,1293,1291,1,0,0,0,1293,1294,1,0,0,0,1294,121,1,0,0,0,1295,1293, - 1,0,0,0,1296,1297,5,180,0,0,1297,1298,5,89,0,0,1298,1302,3,32,16,0,1299, - 1302,3,152,76,0,1300,1302,3,332,166,0,1301,1296,1,0,0,0,1301,1299,1,0, - 0,0,1301,1300,1,0,0,0,1302,123,1,0,0,0,1303,1304,3,116,58,0,1304,1305, - 6,62,-1,0,1305,1321,1,0,0,0,1306,1307,5,42,0,0,1307,1308,3,2,1,0,1308, - 1309,5,43,0,0,1309,1310,6,62,-1,0,1310,1321,1,0,0,0,1311,1312,5,42,0,0, - 1312,1313,5,198,0,0,1313,1314,3,2,1,0,1314,1315,5,43,0,0,1315,1316,6,62, - -1,0,1316,1321,1,0,0,0,1317,1318,3,138,69,0,1318,1319,6,62,-1,0,1319,1321, - 1,0,0,0,1320,1303,1,0,0,0,1320,1306,1,0,0,0,1320,1311,1,0,0,0,1320,1317, - 1,0,0,0,1321,125,1,0,0,0,1322,1334,1,0,0,0,1323,1324,3,130,65,0,1324,1330, - 6,63,-1,0,1325,1326,3,128,64,0,1326,1327,6,63,-1,0,1327,1329,1,0,0,0,1328, - 1325,1,0,0,0,1329,1332,1,0,0,0,1330,1328,1,0,0,0,1330,1331,1,0,0,0,1331, - 1334,1,0,0,0,1332,1330,1,0,0,0,1333,1322,1,0,0,0,1333,1323,1,0,0,0,1334, - 127,1,0,0,0,1335,1336,5,262,0,0,1336,1358,6,64,-1,0,1337,1338,5,261,0, - 0,1338,1358,6,64,-1,0,1339,1340,5,42,0,0,1340,1341,3,32,16,0,1341,1342, - 5,43,0,0,1342,1343,6,64,-1,0,1343,1358,1,0,0,0,1344,1345,5,42,0,0,1345, - 1346,3,32,16,0,1346,1347,5,266,0,0,1347,1348,3,32,16,0,1348,1349,5,43, - 0,0,1349,1350,6,64,-1,0,1350,1358,1,0,0,0,1351,1352,5,42,0,0,1352,1353, - 5,266,0,0,1353,1354,3,32,16,0,1354,1355,5,43,0,0,1355,1356,6,64,-1,0,1356, - 1358,1,0,0,0,1357,1335,1,0,0,0,1357,1337,1,0,0,0,1357,1339,1,0,0,0,1357, - 1344,1,0,0,0,1357,1351,1,0,0,0,1358,129,1,0,0,0,1359,1505,6,65,-1,0,1360, - 1361,5,203,0,0,1361,1362,5,30,0,0,1362,1363,3,6,3,0,1363,1364,5,28,0,0, - 1364,1365,3,6,3,0,1365,1366,5,28,0,0,1366,1367,3,6,3,0,1367,1368,5,28, - 0,0,1368,1369,3,6,3,0,1369,1370,5,31,0,0,1370,1371,6,65,-1,0,1371,1505, - 1,0,0,0,1372,1373,5,203,0,0,1373,1374,5,30,0,0,1374,1375,3,6,3,0,1375, - 1376,5,28,0,0,1376,1377,3,6,3,0,1377,1378,5,31,0,0,1378,1379,6,65,-1,0, - 1379,1505,1,0,0,0,1380,1381,5,204,0,0,1381,1382,5,205,0,0,1382,1383,5, - 42,0,0,1383,1384,3,32,16,0,1384,1385,5,43,0,0,1385,1386,6,65,-1,0,1386, - 1505,1,0,0,0,1387,1388,5,204,0,0,1388,1389,5,206,0,0,1389,1390,5,42,0, - 0,1390,1391,3,32,16,0,1391,1392,5,43,0,0,1392,1393,3,126,63,0,1393,1394, - 6,65,-1,0,1394,1505,1,0,0,0,1395,1396,5,207,0,0,1396,1505,6,65,-1,0,1397, - 1398,5,208,0,0,1398,1505,6,65,-1,0,1399,1400,5,209,0,0,1400,1505,6,65, - -1,0,1401,1402,5,201,0,0,1402,1505,6,65,-1,0,1403,1404,5,183,0,0,1404, - 1505,6,65,-1,0,1405,1406,5,184,0,0,1406,1505,6,65,-1,0,1407,1408,5,185, - 0,0,1408,1505,6,65,-1,0,1409,1410,5,186,0,0,1410,1505,6,65,-1,0,1411,1412, - 5,187,0,0,1412,1505,6,65,-1,0,1413,1414,5,188,0,0,1414,1505,6,65,-1,0, - 1415,1416,5,189,0,0,1416,1505,6,65,-1,0,1417,1418,5,210,0,0,1418,1505, - 6,65,-1,0,1419,1420,5,190,0,0,1420,1505,6,65,-1,0,1421,1422,5,191,0,0, - 1422,1505,6,65,-1,0,1423,1424,5,192,0,0,1424,1505,6,65,-1,0,1425,1426, - 5,193,0,0,1426,1505,6,65,-1,0,1427,1428,5,211,0,0,1428,1505,6,65,-1,0, - 1429,1430,5,212,0,0,1430,1505,6,65,-1,0,1431,1432,5,213,0,0,1432,1505, - 6,65,-1,0,1433,1434,5,214,0,0,1434,1505,6,65,-1,0,1435,1436,5,215,0,0, - 1436,1505,6,65,-1,0,1437,1438,5,216,0,0,1438,1505,6,65,-1,0,1439,1440, - 5,217,0,0,1440,1505,6,65,-1,0,1441,1442,5,218,0,0,1442,1443,3,132,66,0, - 1443,1444,6,65,-1,0,1444,1505,1,0,0,0,1445,1446,5,219,0,0,1446,1447,3, - 132,66,0,1447,1448,6,65,-1,0,1448,1505,1,0,0,0,1449,1450,5,220,0,0,1450, - 1505,6,65,-1,0,1451,1452,5,221,0,0,1452,1453,3,132,66,0,1453,1454,6,65, - -1,0,1454,1505,1,0,0,0,1455,1456,5,222,0,0,1456,1457,3,134,67,0,1457,1458, - 6,65,-1,0,1458,1505,1,0,0,0,1459,1460,5,222,0,0,1460,1461,3,134,67,0,1461, - 1462,5,28,0,0,1462,1463,3,6,3,0,1463,1464,6,65,-1,0,1464,1505,1,0,0,0, - 1465,1466,5,194,0,0,1466,1505,6,65,-1,0,1467,1468,5,195,0,0,1468,1505, - 6,65,-1,0,1469,1470,5,90,0,0,1470,1471,5,184,0,0,1471,1505,6,65,-1,0,1472, - 1473,5,90,0,0,1473,1474,5,185,0,0,1474,1505,6,65,-1,0,1475,1476,5,90,0, - 0,1476,1477,5,186,0,0,1477,1505,6,65,-1,0,1478,1479,5,90,0,0,1479,1480, - 5,187,0,0,1480,1505,6,65,-1,0,1481,1482,5,62,0,0,1482,1483,5,220,0,0,1483, - 1505,6,65,-1,0,1484,1485,5,223,0,0,1485,1505,6,65,-1,0,1486,1487,5,224, - 0,0,1487,1488,5,213,0,0,1488,1505,6,65,-1,0,1489,1490,5,225,0,0,1490,1505, - 6,65,-1,0,1491,1492,5,207,0,0,1492,1493,5,183,0,0,1493,1505,6,65,-1,0, - 1494,1495,5,226,0,0,1495,1505,6,65,-1,0,1496,1497,5,228,0,0,1497,1505, - 6,65,-1,0,1498,1499,5,34,0,0,1499,1500,5,227,0,0,1500,1505,6,65,-1,0,1501, - 1502,3,2,1,0,1502,1503,6,65,-1,0,1503,1505,1,0,0,0,1504,1359,1,0,0,0,1504, - 1360,1,0,0,0,1504,1372,1,0,0,0,1504,1380,1,0,0,0,1504,1387,1,0,0,0,1504, - 1395,1,0,0,0,1504,1397,1,0,0,0,1504,1399,1,0,0,0,1504,1401,1,0,0,0,1504, - 1403,1,0,0,0,1504,1405,1,0,0,0,1504,1407,1,0,0,0,1504,1409,1,0,0,0,1504, - 1411,1,0,0,0,1504,1413,1,0,0,0,1504,1415,1,0,0,0,1504,1417,1,0,0,0,1504, - 1419,1,0,0,0,1504,1421,1,0,0,0,1504,1423,1,0,0,0,1504,1425,1,0,0,0,1504, - 1427,1,0,0,0,1504,1429,1,0,0,0,1504,1431,1,0,0,0,1504,1433,1,0,0,0,1504, - 1435,1,0,0,0,1504,1437,1,0,0,0,1504,1439,1,0,0,0,1504,1441,1,0,0,0,1504, - 1445,1,0,0,0,1504,1449,1,0,0,0,1504,1451,1,0,0,0,1504,1455,1,0,0,0,1504, - 1459,1,0,0,0,1504,1465,1,0,0,0,1504,1467,1,0,0,0,1504,1469,1,0,0,0,1504, - 1472,1,0,0,0,1504,1475,1,0,0,0,1504,1478,1,0,0,0,1504,1481,1,0,0,0,1504, - 1484,1,0,0,0,1504,1486,1,0,0,0,1504,1489,1,0,0,0,1504,1491,1,0,0,0,1504, - 1494,1,0,0,0,1504,1496,1,0,0,0,1504,1498,1,0,0,0,1504,1501,1,0,0,0,1505, - 131,1,0,0,0,1506,1515,1,0,0,0,1507,1508,5,30,0,0,1508,1509,5,91,0,0,1509, - 1510,5,36,0,0,1510,1511,3,32,16,0,1511,1512,5,31,0,0,1512,1513,6,66,-1, - 0,1513,1515,1,0,0,0,1514,1506,1,0,0,0,1514,1507,1,0,0,0,1515,133,1,0,0, - 0,1516,1527,1,0,0,0,1517,1518,3,136,68,0,1518,1523,6,67,-1,0,1519,1520, - 7,7,0,0,1520,1522,6,67,-1,0,1521,1519,1,0,0,0,1522,1525,1,0,0,0,1523,1521, - 1,0,0,0,1523,1524,1,0,0,0,1524,1527,1,0,0,0,1525,1523,1,0,0,0,1526,1516, - 1,0,0,0,1526,1517,1,0,0,0,1527,135,1,0,0,0,1528,1529,5,178,0,0,1529,1609, - 6,68,-1,0,1530,1531,5,207,0,0,1531,1609,6,68,-1,0,1532,1533,5,208,0,0, - 1533,1609,6,68,-1,0,1534,1535,5,201,0,0,1535,1609,6,68,-1,0,1536,1537, - 5,183,0,0,1537,1609,6,68,-1,0,1538,1539,5,184,0,0,1539,1609,6,68,-1,0, - 1540,1541,5,185,0,0,1541,1609,6,68,-1,0,1542,1543,5,186,0,0,1543,1609, - 6,68,-1,0,1544,1545,5,187,0,0,1545,1609,6,68,-1,0,1546,1547,5,188,0,0, - 1547,1609,6,68,-1,0,1548,1549,5,189,0,0,1549,1609,6,68,-1,0,1550,1551, - 5,190,0,0,1551,1609,6,68,-1,0,1552,1553,5,191,0,0,1553,1609,6,68,-1,0, - 1554,1555,5,192,0,0,1555,1609,6,68,-1,0,1556,1557,5,193,0,0,1557,1609, - 6,68,-1,0,1558,1559,5,262,0,0,1559,1609,6,68,-1,0,1560,1561,5,211,0,0, - 1561,1609,6,68,-1,0,1562,1563,5,212,0,0,1563,1609,6,68,-1,0,1564,1565, - 5,213,0,0,1565,1609,6,68,-1,0,1566,1567,5,214,0,0,1567,1609,6,68,-1,0, - 1568,1569,5,215,0,0,1569,1609,6,68,-1,0,1570,1571,5,218,0,0,1571,1609, - 6,68,-1,0,1572,1573,5,219,0,0,1573,1609,6,68,-1,0,1574,1575,5,222,0,0, - 1575,1609,6,68,-1,0,1576,1577,5,194,0,0,1577,1609,6,68,-1,0,1578,1579, - 5,195,0,0,1579,1609,6,68,-1,0,1580,1581,5,210,0,0,1581,1609,6,68,-1,0, - 1582,1583,5,230,0,0,1583,1609,6,68,-1,0,1584,1585,5,231,0,0,1585,1609, - 6,68,-1,0,1586,1587,5,232,0,0,1587,1609,6,68,-1,0,1588,1589,5,233,0,0, - 1589,1609,6,68,-1,0,1590,1591,5,234,0,0,1591,1609,6,68,-1,0,1592,1593, - 5,235,0,0,1593,1609,6,68,-1,0,1594,1595,5,236,0,0,1595,1609,6,68,-1,0, - 1596,1597,5,237,0,0,1597,1609,6,68,-1,0,1598,1599,5,238,0,0,1599,1609, - 6,68,-1,0,1600,1601,5,239,0,0,1601,1609,6,68,-1,0,1602,1603,5,240,0,0, - 1603,1609,6,68,-1,0,1604,1605,5,241,0,0,1605,1609,6,68,-1,0,1606,1607, - 5,242,0,0,1607,1609,6,68,-1,0,1608,1528,1,0,0,0,1608,1530,1,0,0,0,1608, - 1532,1,0,0,0,1608,1534,1,0,0,0,1608,1536,1,0,0,0,1608,1538,1,0,0,0,1608, - 1540,1,0,0,0,1608,1542,1,0,0,0,1608,1544,1,0,0,0,1608,1546,1,0,0,0,1608, - 1548,1,0,0,0,1608,1550,1,0,0,0,1608,1552,1,0,0,0,1608,1554,1,0,0,0,1608, - 1556,1,0,0,0,1608,1558,1,0,0,0,1608,1560,1,0,0,0,1608,1562,1,0,0,0,1608, - 1564,1,0,0,0,1608,1566,1,0,0,0,1608,1568,1,0,0,0,1608,1570,1,0,0,0,1608, - 1572,1,0,0,0,1608,1574,1,0,0,0,1608,1576,1,0,0,0,1608,1578,1,0,0,0,1608, - 1580,1,0,0,0,1608,1582,1,0,0,0,1608,1584,1,0,0,0,1608,1586,1,0,0,0,1608, - 1588,1,0,0,0,1608,1590,1,0,0,0,1608,1592,1,0,0,0,1608,1594,1,0,0,0,1608, - 1596,1,0,0,0,1608,1598,1,0,0,0,1608,1600,1,0,0,0,1608,1602,1,0,0,0,1608, - 1604,1,0,0,0,1608,1606,1,0,0,0,1609,137,1,0,0,0,1610,1611,3,142,71,0,1611, - 1617,6,69,-1,0,1612,1613,3,140,70,0,1613,1614,6,69,-1,0,1614,1616,1,0, - 0,0,1615,1612,1,0,0,0,1616,1619,1,0,0,0,1617,1615,1,0,0,0,1617,1618,1, - 0,0,0,1618,139,1,0,0,0,1619,1617,1,0,0,0,1620,1621,5,261,0,0,1621,1650, - 6,70,-1,0,1622,1623,5,42,0,0,1623,1624,5,43,0,0,1624,1650,6,70,-1,0,1625, - 1626,3,110,55,0,1626,1627,6,70,-1,0,1627,1650,1,0,0,0,1628,1629,5,260, - 0,0,1629,1650,6,70,-1,0,1630,1631,5,262,0,0,1631,1650,6,70,-1,0,1632,1633, - 5,92,0,0,1633,1650,6,70,-1,0,1634,1635,5,93,0,0,1635,1636,5,30,0,0,1636, - 1637,3,124,62,0,1637,1638,5,31,0,0,1638,1639,6,70,-1,0,1639,1650,1,0,0, - 0,1640,1641,5,94,0,0,1641,1642,5,30,0,0,1642,1643,3,124,62,0,1643,1644, - 5,31,0,0,1644,1645,6,70,-1,0,1645,1650,1,0,0,0,1646,1647,3,108,54,0,1647, - 1648,6,70,-1,0,1648,1650,1,0,0,0,1649,1620,1,0,0,0,1649,1622,1,0,0,0,1649, - 1625,1,0,0,0,1649,1628,1,0,0,0,1649,1630,1,0,0,0,1649,1632,1,0,0,0,1649, - 1634,1,0,0,0,1649,1640,1,0,0,0,1649,1646,1,0,0,0,1650,141,1,0,0,0,1651, - 1652,5,39,0,0,1652,1653,3,116,58,0,1653,1654,6,71,-1,0,1654,1710,1,0,0, - 0,1655,1656,5,197,0,0,1656,1710,6,71,-1,0,1657,1658,5,199,0,0,1658,1659, - 5,39,0,0,1659,1660,3,116,58,0,1660,1661,6,71,-1,0,1661,1710,1,0,0,0,1662, - 1663,5,200,0,0,1663,1664,3,116,58,0,1664,1665,6,71,-1,0,1665,1710,1,0, - 0,0,1666,1667,5,226,0,0,1667,1668,3,170,85,0,1668,1669,3,138,69,0,1669, - 1670,5,262,0,0,1670,1671,3,112,56,0,1671,1672,6,71,-1,0,1672,1710,1,0, - 0,0,1673,1674,5,253,0,0,1674,1675,3,32,16,0,1675,1676,6,71,-1,0,1676,1710, - 1,0,0,0,1677,1678,5,252,0,0,1678,1679,3,32,16,0,1679,1680,6,71,-1,0,1680, - 1710,1,0,0,0,1681,1682,5,253,0,0,1682,1683,3,2,1,0,1683,1684,6,71,-1,0, - 1684,1710,1,0,0,0,1685,1686,5,252,0,0,1686,1687,3,2,1,0,1687,1688,6,71, - -1,0,1688,1710,1,0,0,0,1689,1690,5,254,0,0,1690,1710,6,71,-1,0,1691,1692, - 5,201,0,0,1692,1710,6,71,-1,0,1693,1694,3,148,74,0,1694,1695,6,71,-1,0, - 1695,1710,1,0,0,0,1696,1697,3,150,75,0,1697,1698,6,71,-1,0,1698,1710,1, - 0,0,0,1699,1700,3,144,72,0,1700,1701,6,71,-1,0,1701,1710,1,0,0,0,1702, - 1703,3,2,1,0,1703,1704,6,71,-1,0,1704,1710,1,0,0,0,1705,1706,5,177,0,0, - 1706,1707,3,138,69,0,1707,1708,6,71,-1,0,1708,1710,1,0,0,0,1709,1651,1, - 0,0,0,1709,1655,1,0,0,0,1709,1657,1,0,0,0,1709,1662,1,0,0,0,1709,1666, - 1,0,0,0,1709,1673,1,0,0,0,1709,1677,1,0,0,0,1709,1681,1,0,0,0,1709,1685, - 1,0,0,0,1709,1689,1,0,0,0,1709,1691,1,0,0,0,1709,1693,1,0,0,0,1709,1696, - 1,0,0,0,1709,1699,1,0,0,0,1709,1702,1,0,0,0,1709,1705,1,0,0,0,1710,143, - 1,0,0,0,1711,1712,5,181,0,0,1712,1750,6,72,-1,0,1713,1714,5,182,0,0,1714, - 1750,6,72,-1,0,1715,1716,5,183,0,0,1716,1750,6,72,-1,0,1717,1718,5,184, - 0,0,1718,1750,6,72,-1,0,1719,1720,5,185,0,0,1720,1750,6,72,-1,0,1721,1722, - 5,186,0,0,1722,1750,6,72,-1,0,1723,1724,5,187,0,0,1724,1750,6,72,-1,0, - 1725,1726,5,188,0,0,1726,1750,6,72,-1,0,1727,1728,5,189,0,0,1728,1750, - 6,72,-1,0,1729,1730,5,190,0,0,1730,1750,6,72,-1,0,1731,1732,5,191,0,0, - 1732,1750,6,72,-1,0,1733,1734,5,192,0,0,1734,1750,6,72,-1,0,1735,1736, - 5,193,0,0,1736,1750,6,72,-1,0,1737,1738,5,90,0,0,1738,1739,5,184,0,0,1739, - 1750,6,72,-1,0,1740,1741,5,90,0,0,1741,1742,5,185,0,0,1742,1750,6,72,-1, - 0,1743,1744,5,90,0,0,1744,1745,5,186,0,0,1745,1750,6,72,-1,0,1746,1747, - 5,90,0,0,1747,1748,5,187,0,0,1748,1750,6,72,-1,0,1749,1711,1,0,0,0,1749, - 1713,1,0,0,0,1749,1715,1,0,0,0,1749,1717,1,0,0,0,1749,1719,1,0,0,0,1749, - 1721,1,0,0,0,1749,1723,1,0,0,0,1749,1725,1,0,0,0,1749,1727,1,0,0,0,1749, - 1729,1,0,0,0,1749,1731,1,0,0,0,1749,1733,1,0,0,0,1749,1735,1,0,0,0,1749, - 1737,1,0,0,0,1749,1740,1,0,0,0,1749,1743,1,0,0,0,1749,1746,1,0,0,0,1750, - 145,1,0,0,0,1751,1766,1,0,0,0,1752,1766,5,177,0,0,1753,1754,3,32,16,0, - 1754,1755,6,73,-1,0,1755,1766,1,0,0,0,1756,1757,3,32,16,0,1757,1758,5, - 177,0,0,1758,1759,3,32,16,0,1759,1760,6,73,-1,0,1760,1766,1,0,0,0,1761, - 1762,3,32,16,0,1762,1763,5,177,0,0,1763,1764,6,73,-1,0,1764,1766,1,0,0, - 0,1765,1751,1,0,0,0,1765,1752,1,0,0,0,1765,1753,1,0,0,0,1765,1756,1,0, - 0,0,1765,1761,1,0,0,0,1766,147,1,0,0,0,1767,1768,5,1,0,0,1768,1769,5,194, - 0,0,1769,1770,6,74,-1,0,1770,149,1,0,0,0,1771,1775,5,1,0,0,1772,1773,5, - 90,0,0,1773,1776,5,194,0,0,1774,1776,5,195,0,0,1775,1772,1,0,0,0,1775, - 1774,1,0,0,0,1776,1777,1,0,0,0,1777,1778,6,75,-1,0,1778,151,1,0,0,0,1779, - 1780,5,294,0,0,1780,1781,3,166,83,0,1781,1782,3,124,62,0,1782,1783,5,30, - 0,0,1783,1784,3,158,79,0,1784,1785,5,31,0,0,1785,1827,1,0,0,0,1786,1787, - 5,294,0,0,1787,1788,3,166,83,0,1788,1789,3,124,62,0,1789,1790,5,36,0,0, - 1790,1791,5,17,0,0,1791,1792,3,52,26,0,1792,1793,5,18,0,0,1793,1827,1, - 0,0,0,1794,1795,5,294,0,0,1795,1796,3,166,83,0,1796,1797,3,124,62,0,1797, - 1827,1,0,0,0,1798,1799,5,295,0,0,1799,1800,3,166,83,0,1800,1802,5,36,0, - 0,1801,1803,5,84,0,0,1802,1801,1,0,0,0,1802,1803,1,0,0,0,1803,1804,1,0, - 0,0,1804,1805,5,30,0,0,1805,1806,3,300,150,0,1806,1807,5,31,0,0,1807,1827, - 1,0,0,0,1808,1809,5,295,0,0,1809,1810,3,166,83,0,1810,1811,5,84,0,0,1811, - 1812,5,30,0,0,1812,1813,3,300,150,0,1813,1814,5,31,0,0,1814,1827,1,0,0, - 0,1815,1816,5,295,0,0,1816,1817,3,166,83,0,1817,1818,3,6,3,0,1818,1827, - 1,0,0,0,1819,1820,5,295,0,0,1820,1821,3,166,83,0,1821,1822,5,36,0,0,1822, - 1823,5,17,0,0,1823,1824,3,154,77,0,1824,1825,5,18,0,0,1825,1827,1,0,0, - 0,1826,1779,1,0,0,0,1826,1786,1,0,0,0,1826,1794,1,0,0,0,1826,1798,1,0, - 0,0,1826,1808,1,0,0,0,1826,1815,1,0,0,0,1826,1819,1,0,0,0,1827,153,1,0, - 0,0,1828,1839,1,0,0,0,1829,1830,3,156,78,0,1830,1831,5,28,0,0,1831,1833, - 1,0,0,0,1832,1829,1,0,0,0,1833,1836,1,0,0,0,1834,1832,1,0,0,0,1834,1835, - 1,0,0,0,1835,1837,1,0,0,0,1836,1834,1,0,0,0,1837,1839,3,156,78,0,1838, - 1828,1,0,0,0,1838,1834,1,0,0,0,1839,155,1,0,0,0,1840,1841,5,39,0,0,1841, - 1842,5,264,0,0,1842,1843,5,36,0,0,1843,1844,5,17,0,0,1844,1845,3,56,28, - 0,1845,1846,5,18,0,0,1846,1854,1,0,0,0,1847,1848,3,124,62,0,1848,1849, - 5,36,0,0,1849,1850,5,17,0,0,1850,1851,3,56,28,0,1851,1852,5,18,0,0,1852, - 1854,1,0,0,0,1853,1840,1,0,0,0,1853,1847,1,0,0,0,1854,157,1,0,0,0,1855, - 1856,3,160,80,0,1856,1857,5,28,0,0,1857,1859,1,0,0,0,1858,1855,1,0,0,0, - 1859,1862,1,0,0,0,1860,1858,1,0,0,0,1860,1861,1,0,0,0,1861,1863,1,0,0, - 0,1862,1860,1,0,0,0,1863,1864,3,160,80,0,1864,159,1,0,0,0,1865,1866,3, - 6,3,0,1866,1867,5,36,0,0,1867,1868,3,164,82,0,1868,161,1,0,0,0,1869,1870, - 7,8,0,0,1870,163,1,0,0,0,1871,1906,3,162,81,0,1872,1906,3,32,16,0,1873, - 1874,5,186,0,0,1874,1875,5,30,0,0,1875,1876,3,32,16,0,1876,1877,5,31,0, - 0,1877,1906,1,0,0,0,1878,1906,3,6,3,0,1879,1880,3,116,58,0,1880,1881,5, - 30,0,0,1881,1882,5,184,0,0,1882,1883,5,75,0,0,1883,1884,3,32,16,0,1884, - 1885,5,31,0,0,1885,1906,1,0,0,0,1886,1887,3,116,58,0,1887,1888,5,30,0, - 0,1888,1889,5,185,0,0,1889,1890,5,75,0,0,1890,1891,3,32,16,0,1891,1892, - 5,31,0,0,1892,1906,1,0,0,0,1893,1894,3,116,58,0,1894,1895,5,30,0,0,1895, - 1896,5,186,0,0,1896,1897,5,75,0,0,1897,1898,3,32,16,0,1898,1899,5,31,0, - 0,1899,1906,1,0,0,0,1900,1901,3,116,58,0,1901,1902,5,30,0,0,1902,1903, - 3,32,16,0,1903,1904,5,31,0,0,1904,1906,1,0,0,0,1905,1871,1,0,0,0,1905, - 1872,1,0,0,0,1905,1873,1,0,0,0,1905,1878,1,0,0,0,1905,1879,1,0,0,0,1905, - 1886,1,0,0,0,1905,1893,1,0,0,0,1905,1900,1,0,0,0,1906,165,1,0,0,0,1907, - 1908,7,9,0,0,1908,167,1,0,0,0,1909,1910,3,170,85,0,1910,1911,3,138,69, - 0,1911,1912,3,124,62,0,1912,1913,5,176,0,0,1913,1915,3,242,121,0,1914, - 1916,3,108,54,0,1915,1914,1,0,0,0,1915,1916,1,0,0,0,1916,1917,1,0,0,0, - 1917,1918,3,112,56,0,1918,1919,6,84,-1,0,1919,1952,1,0,0,0,1920,1921,3, - 170,85,0,1921,1922,3,138,69,0,1922,1923,3,124,62,0,1923,1924,5,176,0,0, - 1924,1925,3,242,121,0,1925,1926,3,196,98,0,1926,1927,3,112,56,0,1927,1928, - 6,84,-1,0,1928,1952,1,0,0,0,1929,1930,3,170,85,0,1930,1931,3,138,69,0, - 1931,1933,3,242,121,0,1932,1934,3,108,54,0,1933,1932,1,0,0,0,1933,1934, - 1,0,0,0,1934,1935,1,0,0,0,1935,1936,3,112,56,0,1936,1937,6,84,-1,0,1937, - 1952,1,0,0,0,1938,1939,3,170,85,0,1939,1940,3,138,69,0,1940,1941,3,242, - 121,0,1941,1942,3,196,98,0,1942,1943,3,112,56,0,1943,1944,6,84,-1,0,1944, - 1952,1,0,0,0,1945,1946,3,174,87,0,1946,1947,6,84,-1,0,1947,1952,1,0,0, - 0,1948,1949,3,2,1,0,1949,1950,6,84,-1,0,1950,1952,1,0,0,0,1951,1909,1, - 0,0,0,1951,1920,1,0,0,0,1951,1929,1,0,0,0,1951,1938,1,0,0,0,1951,1945, - 1,0,0,0,1951,1948,1,0,0,0,1952,169,1,0,0,0,1953,1954,5,243,0,0,1954,1955, - 3,170,85,0,1955,1956,6,85,-1,0,1956,1971,1,0,0,0,1957,1958,5,244,0,0,1958, - 1959,3,170,85,0,1959,1960,6,85,-1,0,1960,1971,1,0,0,0,1961,1962,3,172, - 86,0,1962,1963,6,85,-1,0,1963,1971,1,0,0,0,1964,1965,5,112,0,0,1965,1966, - 5,30,0,0,1966,1967,3,32,16,0,1967,1968,5,31,0,0,1968,1969,6,85,-1,0,1969, - 1971,1,0,0,0,1970,1953,1,0,0,0,1970,1957,1,0,0,0,1970,1961,1,0,0,0,1970, - 1964,1,0,0,0,1971,171,1,0,0,0,1972,1992,1,0,0,0,1973,1974,5,245,0,0,1974, - 1992,6,86,-1,0,1975,1976,5,246,0,0,1976,1992,6,86,-1,0,1977,1978,5,247, - 0,0,1978,1979,5,248,0,0,1979,1992,6,86,-1,0,1980,1981,5,247,0,0,1981,1982, - 5,249,0,0,1982,1992,6,86,-1,0,1983,1984,5,247,0,0,1984,1985,5,250,0,0, - 1985,1992,6,86,-1,0,1986,1987,5,247,0,0,1987,1988,5,251,0,0,1988,1992, - 6,86,-1,0,1989,1990,5,247,0,0,1990,1992,6,86,-1,0,1991,1972,1,0,0,0,1991, - 1973,1,0,0,0,1991,1975,1,0,0,0,1991,1977,1,0,0,0,1991,1980,1,0,0,0,1991, - 1983,1,0,0,0,1991,1986,1,0,0,0,1991,1989,1,0,0,0,1992,173,1,0,0,0,1993, - 1994,5,113,0,0,1994,1995,5,30,0,0,1995,1996,3,32,16,0,1996,1997,5,31,0, - 0,1997,1998,6,87,-1,0,1998,175,1,0,0,0,1999,2000,5,226,0,0,2000,2001,3, - 168,84,0,2001,2002,6,88,-1,0,2002,2011,1,0,0,0,2003,2004,5,37,0,0,2004, - 2005,3,178,89,0,2005,2006,6,88,-1,0,2006,2011,1,0,0,0,2007,2008,3,174, - 87,0,2008,2009,6,88,-1,0,2009,2011,1,0,0,0,2010,1999,1,0,0,0,2010,2003, - 1,0,0,0,2010,2007,1,0,0,0,2011,177,1,0,0,0,2012,2013,3,138,69,0,2013,2014, - 3,124,62,0,2014,2015,5,176,0,0,2015,2016,3,2,1,0,2016,2017,6,89,-1,0,2017, - 2026,1,0,0,0,2018,2019,3,138,69,0,2019,2020,3,2,1,0,2020,2021,6,89,-1, - 0,2021,2026,1,0,0,0,2022,2023,3,2,1,0,2023,2024,6,89,-1,0,2024,2026,1, - 0,0,0,2025,2012,1,0,0,0,2025,2018,1,0,0,0,2025,2022,1,0,0,0,2026,179,1, - 0,0,0,2027,2028,3,124,62,0,2028,2029,6,90,-1,0,2029,2030,5,28,0,0,2030, - 2032,1,0,0,0,2031,2027,1,0,0,0,2032,2035,1,0,0,0,2033,2031,1,0,0,0,2033, - 2034,1,0,0,0,2034,2036,1,0,0,0,2035,2033,1,0,0,0,2036,2037,3,124,62,0, - 2037,2038,6,90,-1,0,2038,181,1,0,0,0,2039,2046,1,0,0,0,2040,2041,5,86, - 0,0,2041,2042,3,190,95,0,2042,2043,5,87,0,0,2043,2044,6,91,-1,0,2044,2046, - 1,0,0,0,2045,2039,1,0,0,0,2045,2040,1,0,0,0,2046,183,1,0,0,0,2047,2048, - 5,266,0,0,2048,2066,6,92,-1,0,2049,2050,5,114,0,0,2050,2066,6,92,-1,0, - 2051,2052,5,39,0,0,2052,2066,6,92,-1,0,2053,2054,5,200,0,0,2054,2066,6, - 92,-1,0,2055,2056,5,115,0,0,2056,2066,6,92,-1,0,2057,2058,5,116,0,0,2058, - 2066,6,92,-1,0,2059,2060,5,70,0,0,2060,2061,5,30,0,0,2061,2062,3,32,16, - 0,2062,2063,5,31,0,0,2063,2064,6,92,-1,0,2064,2066,1,0,0,0,2065,2047,1, - 0,0,0,2065,2049,1,0,0,0,2065,2051,1,0,0,0,2065,2053,1,0,0,0,2065,2055, - 1,0,0,0,2065,2057,1,0,0,0,2065,2059,1,0,0,0,2066,185,1,0,0,0,2067,2068, - 3,184,92,0,2068,2069,6,93,-1,0,2069,2071,1,0,0,0,2070,2067,1,0,0,0,2071, - 2074,1,0,0,0,2072,2070,1,0,0,0,2072,2073,1,0,0,0,2073,187,1,0,0,0,2074, - 2072,1,0,0,0,2075,2077,3,186,93,0,2076,2078,3,192,96,0,2077,2076,1,0,0, - 0,2077,2078,1,0,0,0,2078,2079,1,0,0,0,2079,2080,3,2,1,0,2080,2081,6,94, - -1,0,2081,189,1,0,0,0,2082,2083,3,188,94,0,2083,2084,6,95,-1,0,2084,2085, - 5,28,0,0,2085,2087,1,0,0,0,2086,2082,1,0,0,0,2087,2090,1,0,0,0,2088,2086, - 1,0,0,0,2088,2089,1,0,0,0,2089,2091,1,0,0,0,2090,2088,1,0,0,0,2091,2092, - 3,188,94,0,2092,2093,6,95,-1,0,2093,191,1,0,0,0,2094,2095,5,30,0,0,2095, - 2096,3,180,90,0,2096,2097,5,31,0,0,2097,2098,6,96,-1,0,2098,193,1,0,0, - 0,2099,2101,3,196,98,0,2100,2099,1,0,0,0,2100,2101,1,0,0,0,2101,2102,1, - 0,0,0,2102,2103,6,97,-1,0,2103,195,1,0,0,0,2104,2105,5,86,0,0,2105,2106, - 5,42,0,0,2106,2107,3,32,16,0,2107,2108,5,43,0,0,2108,2109,5,87,0,0,2109, - 2110,6,98,-1,0,2110,197,1,0,0,0,2111,2112,3,234,117,0,2112,2113,5,17,0, - 0,2113,2114,3,246,123,0,2114,2115,5,18,0,0,2115,2262,1,0,0,0,2116,2117, - 3,74,37,0,2117,2118,5,17,0,0,2118,2119,3,82,41,0,2119,2120,5,18,0,0,2120, - 2262,1,0,0,0,2121,2122,3,210,105,0,2122,2123,6,99,-1,0,2123,2124,5,17, - 0,0,2124,2125,3,214,107,0,2125,2126,5,18,0,0,2126,2262,1,0,0,0,2127,2128, - 3,218,109,0,2128,2129,6,99,-1,0,2129,2130,5,17,0,0,2130,2131,3,222,111, - 0,2131,2132,5,18,0,0,2132,2262,1,0,0,0,2133,2262,3,200,100,0,2134,2135, - 3,284,142,0,2135,2136,6,99,-1,0,2136,2262,1,0,0,0,2137,2138,3,152,76,0, - 2138,2139,6,99,-1,0,2139,2262,1,0,0,0,2140,2141,3,88,44,0,2141,2142,6, - 99,-1,0,2142,2262,1,0,0,0,2143,2144,3,330,165,0,2144,2145,6,99,-1,0,2145, - 2262,1,0,0,0,2146,2147,5,117,0,0,2147,2148,3,32,16,0,2148,2149,6,99,-1, - 0,2149,2262,1,0,0,0,2150,2151,5,118,0,0,2151,2152,3,32,16,0,2152,2153, - 6,99,-1,0,2153,2262,1,0,0,0,2154,2155,3,346,173,0,2155,2156,5,17,0,0,2156, - 2157,3,350,175,0,2157,2158,5,18,0,0,2158,2159,6,99,-1,0,2159,2262,1,0, - 0,0,2160,2161,5,302,0,0,2161,2162,3,124,62,0,2162,2163,5,176,0,0,2163, - 2164,3,242,121,0,2164,2165,5,119,0,0,2165,2166,3,170,85,0,2166,2167,3, - 138,69,0,2167,2168,3,124,62,0,2168,2169,5,176,0,0,2169,2170,3,242,121, - 0,2170,2171,3,112,56,0,2171,2172,6,99,-1,0,2172,2262,1,0,0,0,2173,2174, - 5,302,0,0,2174,2175,5,226,0,0,2175,2176,3,170,85,0,2176,2177,3,138,69, - 0,2177,2178,3,124,62,0,2178,2179,5,176,0,0,2179,2180,3,242,121,0,2180, - 2181,3,194,97,0,2181,2182,3,112,56,0,2182,2183,5,119,0,0,2183,2184,5,226, - 0,0,2184,2185,3,170,85,0,2185,2186,3,138,69,0,2186,2187,3,124,62,0,2187, - 2188,5,176,0,0,2188,2189,3,242,121,0,2189,2190,3,194,97,0,2190,2191,3, - 112,56,0,2191,2192,6,99,-1,0,2192,2262,1,0,0,0,2193,2194,3,26,13,0,2194, - 2195,6,99,-1,0,2195,2262,1,0,0,0,2196,2197,3,40,20,0,2197,2198,6,99,-1, - 0,2198,2262,1,0,0,0,2199,2200,5,255,0,0,2200,2201,5,196,0,0,2201,2202, - 5,42,0,0,2202,2203,3,32,16,0,2203,2204,5,43,0,0,2204,2210,6,99,-1,0,2205, - 2206,3,330,165,0,2206,2207,6,99,-1,0,2207,2209,1,0,0,0,2208,2205,1,0,0, - 0,2209,2212,1,0,0,0,2210,2208,1,0,0,0,2210,2211,1,0,0,0,2211,2262,1,0, - 0,0,2212,2210,1,0,0,0,2213,2214,5,255,0,0,2214,2215,5,196,0,0,2215,2216, - 3,2,1,0,2216,2222,6,99,-1,0,2217,2218,3,330,165,0,2218,2219,6,99,-1,0, - 2219,2221,1,0,0,0,2220,2217,1,0,0,0,2221,2224,1,0,0,0,2222,2220,1,0,0, - 0,2222,2223,1,0,0,0,2223,2262,1,0,0,0,2224,2222,1,0,0,0,2225,2226,5,255, - 0,0,2226,2227,5,256,0,0,2227,2228,5,42,0,0,2228,2229,3,32,16,0,2229,2230, - 5,43,0,0,2230,2231,5,28,0,0,2231,2232,3,124,62,0,2232,2238,6,99,-1,0,2233, - 2234,3,330,165,0,2234,2235,6,99,-1,0,2235,2237,1,0,0,0,2236,2233,1,0,0, - 0,2237,2240,1,0,0,0,2238,2236,1,0,0,0,2238,2239,1,0,0,0,2239,2262,1,0, - 0,0,2240,2238,1,0,0,0,2241,2242,5,255,0,0,2242,2243,5,256,0,0,2243,2244, - 3,2,1,0,2244,2245,5,28,0,0,2245,2246,3,124,62,0,2246,2252,6,99,-1,0,2247, - 2248,3,330,165,0,2248,2249,6,99,-1,0,2249,2251,1,0,0,0,2250,2247,1,0,0, - 0,2251,2254,1,0,0,0,2252,2250,1,0,0,0,2252,2253,1,0,0,0,2253,2262,1,0, - 0,0,2254,2252,1,0,0,0,2255,2256,5,120,0,0,2256,2257,5,196,0,0,2257,2258, - 3,124,62,0,2258,2259,3,44,22,0,2259,2260,6,99,-1,0,2260,2262,1,0,0,0,2261, - 2111,1,0,0,0,2261,2116,1,0,0,0,2261,2121,1,0,0,0,2261,2127,1,0,0,0,2261, - 2133,1,0,0,0,2261,2134,1,0,0,0,2261,2137,1,0,0,0,2261,2140,1,0,0,0,2261, - 2143,1,0,0,0,2261,2146,1,0,0,0,2261,2150,1,0,0,0,2261,2154,1,0,0,0,2261, - 2160,1,0,0,0,2261,2173,1,0,0,0,2261,2193,1,0,0,0,2261,2196,1,0,0,0,2261, - 2199,1,0,0,0,2261,2213,1,0,0,0,2261,2225,1,0,0,0,2261,2241,1,0,0,0,2261, - 2255,1,0,0,0,2262,199,1,0,0,0,2263,2264,5,121,0,0,2264,2276,3,208,104, - 0,2265,2266,3,202,101,0,2266,2267,6,100,-1,0,2267,2275,1,0,0,0,2268,2269, - 5,122,0,0,2269,2270,5,30,0,0,2270,2271,3,228,114,0,2271,2272,5,31,0,0, - 2272,2273,6,100,-1,0,2273,2275,1,0,0,0,2274,2265,1,0,0,0,2274,2268,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,2280,3,138,69,0,2280,2281,3,2,1,0,2281,2282, - 3,204,102,0,2282,2283,3,206,103,0,2283,2284,6,100,-1,0,2284,201,1,0,0, - 0,2285,2286,5,123,0,0,2286,2320,6,101,-1,0,2287,2288,5,51,0,0,2288,2320, - 6,101,-1,0,2289,2290,5,52,0,0,2290,2320,6,101,-1,0,2291,2292,5,63,0,0, - 2292,2320,6,101,-1,0,2293,2294,5,124,0,0,2294,2320,6,101,-1,0,2295,2296, - 5,69,0,0,2296,2320,6,101,-1,0,2297,2298,5,68,0,0,2298,2320,6,101,-1,0, - 2299,2300,5,64,0,0,2300,2320,6,101,-1,0,2301,2302,5,65,0,0,2302,2320,6, - 101,-1,0,2303,2304,5,66,0,0,2304,2320,6,101,-1,0,2305,2306,5,125,0,0,2306, - 2320,6,101,-1,0,2307,2308,5,126,0,0,2308,2320,6,101,-1,0,2309,2310,5,127, - 0,0,2310,2320,6,101,-1,0,2311,2312,5,16,0,0,2312,2320,6,101,-1,0,2313, - 2314,5,70,0,0,2314,2315,5,30,0,0,2315,2316,3,32,16,0,2316,2317,5,31,0, - 0,2317,2318,6,101,-1,0,2318,2320,1,0,0,0,2319,2285,1,0,0,0,2319,2287,1, - 0,0,0,2319,2289,1,0,0,0,2319,2291,1,0,0,0,2319,2293,1,0,0,0,2319,2295, - 1,0,0,0,2319,2297,1,0,0,0,2319,2299,1,0,0,0,2319,2301,1,0,0,0,2319,2303, - 1,0,0,0,2319,2305,1,0,0,0,2319,2307,1,0,0,0,2319,2309,1,0,0,0,2319,2311, - 1,0,0,0,2319,2313,1,0,0,0,2320,203,1,0,0,0,2321,2331,1,0,0,0,2322,2323, - 5,44,0,0,2323,2324,3,0,0,0,2324,2325,6,102,-1,0,2325,2331,1,0,0,0,2326, - 2327,5,44,0,0,2327,2328,3,32,16,0,2328,2329,6,102,-1,0,2329,2331,1,0,0, - 0,2330,2321,1,0,0,0,2330,2322,1,0,0,0,2330,2326,1,0,0,0,2331,205,1,0,0, - 0,2332,2338,1,0,0,0,2333,2334,5,36,0,0,2334,2335,3,304,152,0,2335,2336, - 6,103,-1,0,2336,2338,1,0,0,0,2337,2332,1,0,0,0,2337,2333,1,0,0,0,2338, - 207,1,0,0,0,2339,2346,1,0,0,0,2340,2341,5,42,0,0,2341,2342,3,32,16,0,2342, - 2343,5,43,0,0,2343,2344,6,104,-1,0,2344,2346,1,0,0,0,2345,2339,1,0,0,0, - 2345,2340,1,0,0,0,2346,209,1,0,0,0,2347,2353,5,128,0,0,2348,2349,3,212, - 106,0,2349,2350,6,105,-1,0,2350,2352,1,0,0,0,2351,2348,1,0,0,0,2352,2355, - 1,0,0,0,2353,2351,1,0,0,0,2353,2354,1,0,0,0,2354,2356,1,0,0,0,2355,2353, - 1,0,0,0,2356,2357,3,124,62,0,2357,2358,3,2,1,0,2358,2359,6,105,-1,0,2359, - 2373,1,0,0,0,2360,2366,5,128,0,0,2361,2362,3,212,106,0,2362,2363,6,105, - -1,0,2363,2365,1,0,0,0,2364,2361,1,0,0,0,2365,2368,1,0,0,0,2366,2364,1, - 0,0,0,2366,2367,1,0,0,0,2367,2369,1,0,0,0,2368,2366,1,0,0,0,2369,2370, - 3,2,1,0,2370,2371,6,105,-1,0,2371,2373,1,0,0,0,2372,2347,1,0,0,0,2372, - 2360,1,0,0,0,2373,211,1,0,0,0,2374,2375,5,69,0,0,2375,2379,6,106,-1,0, - 2376,2377,5,68,0,0,2377,2379,6,106,-1,0,2378,2374,1,0,0,0,2378,2376,1, - 0,0,0,2379,213,1,0,0,0,2380,2382,3,216,108,0,2381,2380,1,0,0,0,2382,2385, - 1,0,0,0,2383,2381,1,0,0,0,2383,2384,1,0,0,0,2384,215,1,0,0,0,2385,2383, - 1,0,0,0,2386,2387,5,129,0,0,2387,2388,3,168,84,0,2388,2389,6,108,-1,0, - 2389,2413,1,0,0,0,2390,2391,5,130,0,0,2391,2392,3,168,84,0,2392,2393,6, - 108,-1,0,2393,2413,1,0,0,0,2394,2395,5,131,0,0,2395,2396,3,168,84,0,2396, - 2397,6,108,-1,0,2397,2413,1,0,0,0,2398,2399,5,132,0,0,2399,2400,3,168, - 84,0,2400,2401,6,108,-1,0,2401,2413,1,0,0,0,2402,2403,3,88,44,0,2403,2404, - 6,108,-1,0,2404,2413,1,0,0,0,2405,2406,3,330,165,0,2406,2407,6,108,-1, - 0,2407,2413,1,0,0,0,2408,2409,3,26,13,0,2409,2410,6,108,-1,0,2410,2413, - 1,0,0,0,2411,2413,3,40,20,0,2412,2386,1,0,0,0,2412,2390,1,0,0,0,2412,2394, - 1,0,0,0,2412,2398,1,0,0,0,2412,2402,1,0,0,0,2412,2405,1,0,0,0,2412,2408, - 1,0,0,0,2412,2411,1,0,0,0,2413,217,1,0,0,0,2414,2420,5,133,0,0,2415,2416, - 3,220,110,0,2416,2417,6,109,-1,0,2417,2419,1,0,0,0,2418,2415,1,0,0,0,2419, - 2422,1,0,0,0,2420,2418,1,0,0,0,2420,2421,1,0,0,0,2421,2423,1,0,0,0,2422, - 2420,1,0,0,0,2423,2424,3,170,85,0,2424,2425,3,138,69,0,2425,2426,3,2,1, - 0,2426,2427,3,112,56,0,2427,2428,3,206,103,0,2428,2429,6,109,-1,0,2429, - 219,1,0,0,0,2430,2431,5,69,0,0,2431,2435,6,110,-1,0,2432,2433,5,68,0,0, - 2433,2435,6,110,-1,0,2434,2430,1,0,0,0,2434,2432,1,0,0,0,2435,221,1,0, - 0,0,2436,2438,3,224,112,0,2437,2436,1,0,0,0,2438,2441,1,0,0,0,2439,2437, - 1,0,0,0,2439,2440,1,0,0,0,2440,223,1,0,0,0,2441,2439,1,0,0,0,2442,2443, - 5,134,0,0,2443,2444,3,168,84,0,2444,2445,6,112,-1,0,2445,2465,1,0,0,0, - 2446,2447,5,135,0,0,2447,2448,3,168,84,0,2448,2449,6,112,-1,0,2449,2465, - 1,0,0,0,2450,2451,5,132,0,0,2451,2452,3,168,84,0,2452,2453,6,112,-1,0, - 2453,2465,1,0,0,0,2454,2455,3,330,165,0,2455,2456,6,112,-1,0,2456,2465, - 1,0,0,0,2457,2458,3,88,44,0,2458,2459,6,112,-1,0,2459,2465,1,0,0,0,2460, - 2461,3,26,13,0,2461,2462,6,112,-1,0,2462,2465,1,0,0,0,2463,2465,3,40,20, - 0,2464,2442,1,0,0,0,2464,2446,1,0,0,0,2464,2450,1,0,0,0,2464,2454,1,0, - 0,0,2464,2457,1,0,0,0,2464,2460,1,0,0,0,2464,2463,1,0,0,0,2465,225,1,0, - 0,0,2466,2474,6,113,-1,0,2467,2468,5,122,0,0,2468,2469,5,30,0,0,2469,2470, - 3,228,114,0,2470,2471,5,31,0,0,2471,2472,6,113,-1,0,2472,2474,1,0,0,0, - 2473,2466,1,0,0,0,2473,2467,1,0,0,0,2474,227,1,0,0,0,2475,2476,3,126,63, - 0,2476,2477,6,114,-1,0,2477,2489,1,0,0,0,2478,2482,5,17,0,0,2479,2480, - 3,302,151,0,2480,2481,6,114,-1,0,2481,2483,1,0,0,0,2482,2479,1,0,0,0,2483, - 2484,1,0,0,0,2484,2482,1,0,0,0,2484,2485,1,0,0,0,2485,2486,1,0,0,0,2486, - 2487,5,18,0,0,2487,2489,1,0,0,0,2488,2475,1,0,0,0,2488,2478,1,0,0,0,2489, - 229,1,0,0,0,2490,2491,3,232,116,0,2491,2492,6,115,-1,0,2492,2494,1,0,0, - 0,2493,2490,1,0,0,0,2494,2497,1,0,0,0,2495,2493,1,0,0,0,2495,2496,1,0, - 0,0,2496,231,1,0,0,0,2497,2495,1,0,0,0,2498,2499,5,42,0,0,2499,2500,5, - 136,0,0,2500,2501,5,43,0,0,2501,2516,6,116,-1,0,2502,2503,5,42,0,0,2503, - 2504,5,137,0,0,2504,2505,5,43,0,0,2505,2516,6,116,-1,0,2506,2507,5,42, - 0,0,2507,2508,5,138,0,0,2508,2509,5,43,0,0,2509,2516,6,116,-1,0,2510,2511, - 5,42,0,0,2511,2512,3,32,16,0,2512,2513,5,43,0,0,2513,2514,6,116,-1,0,2514, - 2516,1,0,0,0,2515,2498,1,0,0,0,2515,2502,1,0,0,0,2515,2506,1,0,0,0,2515, - 2510,1,0,0,0,2516,233,1,0,0,0,2517,2526,5,139,0,0,2518,2519,3,236,118, - 0,2519,2520,6,117,-1,0,2520,2525,1,0,0,0,2521,2522,3,238,119,0,2522,2523, - 6,117,-1,0,2523,2525,1,0,0,0,2524,2518,1,0,0,0,2524,2521,1,0,0,0,2525, - 2528,1,0,0,0,2526,2524,1,0,0,0,2526,2527,1,0,0,0,2527,2529,1,0,0,0,2528, - 2526,1,0,0,0,2529,2530,3,170,85,0,2530,2531,3,230,115,0,2531,2532,3,138, - 69,0,2532,2533,3,226,113,0,2533,2534,3,242,121,0,2534,2535,3,182,91,0, - 2535,2541,3,112,56,0,2536,2537,3,244,122,0,2537,2538,6,117,-1,0,2538,2540, - 1,0,0,0,2539,2536,1,0,0,0,2540,2543,1,0,0,0,2541,2539,1,0,0,0,2541,2542, - 1,0,0,0,2542,2544,1,0,0,0,2543,2541,1,0,0,0,2544,2545,6,117,-1,0,2545, - 235,1,0,0,0,2546,2547,5,123,0,0,2547,2589,6,118,-1,0,2548,2549,5,51,0, - 0,2549,2589,6,118,-1,0,2550,2551,5,52,0,0,2551,2589,6,118,-1,0,2552,2553, - 5,63,0,0,2553,2589,6,118,-1,0,2554,2555,5,140,0,0,2555,2589,6,118,-1,0, - 2556,2557,5,68,0,0,2557,2589,6,118,-1,0,2558,2559,5,141,0,0,2559,2589, - 6,118,-1,0,2560,2561,5,142,0,0,2561,2589,6,118,-1,0,2562,2563,5,54,0,0, - 2563,2589,6,118,-1,0,2564,2565,5,64,0,0,2565,2589,6,118,-1,0,2566,2567, - 5,65,0,0,2567,2589,6,118,-1,0,2568,2569,5,66,0,0,2569,2589,6,118,-1,0, - 2570,2571,5,125,0,0,2571,2589,6,118,-1,0,2572,2573,5,143,0,0,2573,2589, - 6,118,-1,0,2574,2575,5,144,0,0,2575,2589,6,118,-1,0,2576,2577,5,69,0,0, - 2577,2589,6,118,-1,0,2578,2579,5,145,0,0,2579,2589,6,118,-1,0,2580,2581, - 5,146,0,0,2581,2589,6,118,-1,0,2582,2583,5,70,0,0,2583,2584,5,30,0,0,2584, - 2585,3,32,16,0,2585,2586,5,31,0,0,2586,2587,6,118,-1,0,2587,2589,1,0,0, - 0,2588,2546,1,0,0,0,2588,2548,1,0,0,0,2588,2550,1,0,0,0,2588,2552,1,0, - 0,0,2588,2554,1,0,0,0,2588,2556,1,0,0,0,2588,2558,1,0,0,0,2588,2560,1, - 0,0,0,2588,2562,1,0,0,0,2588,2564,1,0,0,0,2588,2566,1,0,0,0,2588,2568, - 1,0,0,0,2588,2570,1,0,0,0,2588,2572,1,0,0,0,2588,2574,1,0,0,0,2588,2576, - 1,0,0,0,2588,2578,1,0,0,0,2588,2580,1,0,0,0,2588,2582,1,0,0,0,2589,237, - 1,0,0,0,2590,2591,5,147,0,0,2591,2600,5,30,0,0,2592,2593,3,6,3,0,2593, - 2598,6,119,-1,0,2594,2595,5,34,0,0,2595,2596,3,6,3,0,2596,2597,6,119,-1, - 0,2597,2599,1,0,0,0,2598,2594,1,0,0,0,2598,2599,1,0,0,0,2599,2601,1,0, - 0,0,2600,2592,1,0,0,0,2600,2601,1,0,0,0,2601,2607,1,0,0,0,2602,2603,3, - 240,120,0,2603,2604,6,119,-1,0,2604,2606,1,0,0,0,2605,2602,1,0,0,0,2606, - 2609,1,0,0,0,2607,2605,1,0,0,0,2607,2608,1,0,0,0,2608,2610,1,0,0,0,2609, - 2607,1,0,0,0,2610,2614,5,31,0,0,2611,2612,5,147,0,0,2612,2614,5,85,0,0, - 2613,2590,1,0,0,0,2613,2611,1,0,0,0,2614,239,1,0,0,0,2615,2616,5,148,0, - 0,2616,2658,6,120,-1,0,2617,2618,5,224,0,0,2618,2658,6,120,-1,0,2619,2620, - 5,57,0,0,2620,2658,6,120,-1,0,2621,2622,5,58,0,0,2622,2658,6,120,-1,0, - 2623,2624,5,149,0,0,2624,2658,6,120,-1,0,2625,2626,5,150,0,0,2626,2658, - 6,120,-1,0,2627,2628,5,248,0,0,2628,2658,6,120,-1,0,2629,2630,5,249,0, - 0,2630,2658,6,120,-1,0,2631,2632,5,250,0,0,2632,2658,6,120,-1,0,2633,2634, - 5,251,0,0,2634,2658,6,120,-1,0,2635,2636,5,151,0,0,2636,2637,5,75,0,0, - 2637,2638,5,152,0,0,2638,2658,6,120,-1,0,2639,2640,5,151,0,0,2640,2641, - 5,75,0,0,2641,2642,5,153,0,0,2642,2658,6,120,-1,0,2643,2644,5,154,0,0, - 2644,2645,5,75,0,0,2645,2646,5,152,0,0,2646,2658,6,120,-1,0,2647,2648, - 5,154,0,0,2648,2649,5,75,0,0,2649,2650,5,153,0,0,2650,2658,6,120,-1,0, - 2651,2652,5,70,0,0,2652,2653,5,30,0,0,2653,2654,3,32,16,0,2654,2655,5, - 31,0,0,2655,2656,6,120,-1,0,2656,2658,1,0,0,0,2657,2615,1,0,0,0,2657,2617, - 1,0,0,0,2657,2619,1,0,0,0,2657,2621,1,0,0,0,2657,2623,1,0,0,0,2657,2625, - 1,0,0,0,2657,2627,1,0,0,0,2657,2629,1,0,0,0,2657,2631,1,0,0,0,2657,2633, - 1,0,0,0,2657,2635,1,0,0,0,2657,2639,1,0,0,0,2657,2643,1,0,0,0,2657,2647, - 1,0,0,0,2657,2651,1,0,0,0,2658,241,1,0,0,0,2659,2660,5,116,0,0,2660,2667, - 6,121,-1,0,2661,2662,5,155,0,0,2662,2667,6,121,-1,0,2663,2664,3,2,1,0, - 2664,2665,6,121,-1,0,2665,2667,1,0,0,0,2666,2659,1,0,0,0,2666,2661,1,0, - 0,0,2666,2663,1,0,0,0,2667,243,1,0,0,0,2668,2669,5,1,0,0,2669,2707,6,122, - -1,0,2670,2671,5,2,0,0,2671,2707,6,122,-1,0,2672,2673,5,156,0,0,2673,2707, - 6,122,-1,0,2674,2675,5,3,0,0,2675,2707,6,122,-1,0,2676,2677,5,4,0,0,2677, - 2707,6,122,-1,0,2678,2679,5,247,0,0,2679,2707,6,122,-1,0,2680,2681,5,5, - 0,0,2681,2707,6,122,-1,0,2682,2683,5,6,0,0,2683,2707,6,122,-1,0,2684,2685, - 5,7,0,0,2685,2707,6,122,-1,0,2686,2687,5,8,0,0,2687,2707,6,122,-1,0,2688, - 2689,5,9,0,0,2689,2707,6,122,-1,0,2690,2691,5,10,0,0,2691,2707,6,122,-1, - 0,2692,2693,5,11,0,0,2693,2707,6,122,-1,0,2694,2695,5,12,0,0,2695,2707, - 6,122,-1,0,2696,2697,5,13,0,0,2697,2707,6,122,-1,0,2698,2699,5,14,0,0, - 2699,2707,6,122,-1,0,2700,2701,5,70,0,0,2701,2702,5,30,0,0,2702,2703,3, - 32,16,0,2703,2704,5,31,0,0,2704,2705,6,122,-1,0,2705,2707,1,0,0,0,2706, - 2668,1,0,0,0,2706,2670,1,0,0,0,2706,2672,1,0,0,0,2706,2674,1,0,0,0,2706, - 2676,1,0,0,0,2706,2678,1,0,0,0,2706,2680,1,0,0,0,2706,2682,1,0,0,0,2706, - 2684,1,0,0,0,2706,2686,1,0,0,0,2706,2688,1,0,0,0,2706,2690,1,0,0,0,2706, - 2692,1,0,0,0,2706,2694,1,0,0,0,2706,2696,1,0,0,0,2706,2698,1,0,0,0,2706, - 2700,1,0,0,0,2707,245,1,0,0,0,2708,2710,3,248,124,0,2709,2708,1,0,0,0, - 2710,2713,1,0,0,0,2711,2709,1,0,0,0,2711,2712,1,0,0,0,2712,247,1,0,0,0, - 2713,2711,1,0,0,0,2714,2752,3,100,50,0,2715,2716,5,296,0,0,2716,2717,3, - 32,16,0,2717,2718,6,124,-1,0,2718,2752,1,0,0,0,2719,2752,3,266,133,0,2720, - 2721,5,297,0,0,2721,2722,3,32,16,0,2722,2723,6,124,-1,0,2723,2752,1,0, - 0,0,2724,2725,5,298,0,0,2725,2752,6,124,-1,0,2726,2727,5,299,0,0,2727, - 2752,6,124,-1,0,2728,2752,3,260,130,0,2729,2752,3,264,132,0,2730,2752, - 3,250,125,0,2731,2732,3,284,142,0,2732,2733,6,124,-1,0,2733,2752,1,0,0, - 0,2734,2735,3,152,76,0,2735,2736,6,124,-1,0,2736,2752,1,0,0,0,2737,2738, - 3,88,44,0,2738,2739,6,124,-1,0,2739,2752,1,0,0,0,2740,2741,3,26,13,0,2741, - 2742,6,124,-1,0,2742,2752,1,0,0,0,2743,2744,3,262,131,0,2744,2745,6,124, - -1,0,2745,2752,1,0,0,0,2746,2752,3,40,20,0,2747,2752,3,252,126,0,2748, - 2752,3,254,127,0,2749,2752,3,256,128,0,2750,2752,3,258,129,0,2751,2714, - 1,0,0,0,2751,2715,1,0,0,0,2751,2719,1,0,0,0,2751,2720,1,0,0,0,2751,2724, - 1,0,0,0,2751,2726,1,0,0,0,2751,2728,1,0,0,0,2751,2729,1,0,0,0,2751,2730, - 1,0,0,0,2751,2731,1,0,0,0,2751,2734,1,0,0,0,2751,2737,1,0,0,0,2751,2740, - 1,0,0,0,2751,2743,1,0,0,0,2751,2746,1,0,0,0,2751,2747,1,0,0,0,2751,2748, - 1,0,0,0,2751,2749,1,0,0,0,2751,2750,1,0,0,0,2752,249,1,0,0,0,2753,2755, - 5,300,0,0,2754,2756,5,157,0,0,2755,2754,1,0,0,0,2755,2756,1,0,0,0,2756, - 2757,1,0,0,0,2757,2758,3,112,56,0,2758,251,1,0,0,0,2759,2760,5,301,0,0, - 2760,2761,5,42,0,0,2761,2762,3,32,16,0,2762,2765,5,43,0,0,2763,2764,5, - 34,0,0,2764,2766,3,0,0,0,2765,2763,1,0,0,0,2765,2766,1,0,0,0,2766,253, - 1,0,0,0,2767,2768,5,303,0,0,2768,2769,3,32,16,0,2769,2770,5,75,0,0,2770, - 2771,3,32,16,0,2771,255,1,0,0,0,2772,2773,5,302,0,0,2773,2774,3,124,62, - 0,2774,2775,5,176,0,0,2775,2776,3,242,121,0,2776,2788,1,0,0,0,2777,2778, - 5,302,0,0,2778,2779,5,226,0,0,2779,2780,3,170,85,0,2780,2781,3,138,69, - 0,2781,2782,3,124,62,0,2782,2783,5,176,0,0,2783,2784,3,242,121,0,2784, - 2785,3,194,97,0,2785,2786,3,112,56,0,2786,2788,1,0,0,0,2787,2772,1,0,0, - 0,2787,2777,1,0,0,0,2788,257,1,0,0,0,2789,2790,5,255,0,0,2790,2791,5,196, - 0,0,2791,2792,5,42,0,0,2792,2793,3,32,16,0,2793,2799,5,43,0,0,2794,2795, - 3,330,165,0,2795,2796,6,129,-1,0,2796,2798,1,0,0,0,2797,2794,1,0,0,0,2798, - 2801,1,0,0,0,2799,2797,1,0,0,0,2799,2800,1,0,0,0,2800,2855,1,0,0,0,2801, - 2799,1,0,0,0,2802,2803,5,255,0,0,2803,2804,5,196,0,0,2804,2810,3,2,1,0, - 2805,2806,3,330,165,0,2806,2807,6,129,-1,0,2807,2809,1,0,0,0,2808,2805, - 1,0,0,0,2809,2812,1,0,0,0,2810,2808,1,0,0,0,2810,2811,1,0,0,0,2811,2855, - 1,0,0,0,2812,2810,1,0,0,0,2813,2814,5,255,0,0,2814,2815,5,256,0,0,2815, - 2816,5,42,0,0,2816,2817,3,32,16,0,2817,2818,5,43,0,0,2818,2819,5,28,0, - 0,2819,2825,3,124,62,0,2820,2821,3,330,165,0,2821,2822,6,129,-1,0,2822, - 2824,1,0,0,0,2823,2820,1,0,0,0,2824,2827,1,0,0,0,2825,2823,1,0,0,0,2825, - 2826,1,0,0,0,2826,2855,1,0,0,0,2827,2825,1,0,0,0,2828,2829,5,255,0,0,2829, - 2830,5,256,0,0,2830,2831,3,2,1,0,2831,2832,5,28,0,0,2832,2838,3,124,62, - 0,2833,2834,3,330,165,0,2834,2835,6,129,-1,0,2835,2837,1,0,0,0,2836,2833, - 1,0,0,0,2837,2840,1,0,0,0,2838,2836,1,0,0,0,2838,2839,1,0,0,0,2839,2855, - 1,0,0,0,2840,2838,1,0,0,0,2841,2842,5,255,0,0,2842,2843,5,42,0,0,2843, - 2844,3,32,16,0,2844,2845,5,43,0,0,2845,2851,3,206,103,0,2846,2847,3,330, - 165,0,2847,2848,6,129,-1,0,2848,2850,1,0,0,0,2849,2846,1,0,0,0,2850,2853, - 1,0,0,0,2851,2849,1,0,0,0,2851,2852,1,0,0,0,2852,2855,1,0,0,0,2853,2851, - 1,0,0,0,2854,2789,1,0,0,0,2854,2802,1,0,0,0,2854,2813,1,0,0,0,2854,2828, - 1,0,0,0,2854,2841,1,0,0,0,2855,259,1,0,0,0,2856,2857,3,0,0,0,2857,2858, - 5,75,0,0,2858,2859,6,130,-1,0,2859,261,1,0,0,0,2860,2863,3,44,22,0,2861, - 2863,3,46,23,0,2862,2860,1,0,0,0,2862,2861,1,0,0,0,2863,263,1,0,0,0,2864, - 2865,5,17,0,0,2865,2866,3,246,123,0,2866,2867,5,18,0,0,2867,265,1,0,0, - 0,2868,2869,3,270,135,0,2869,2870,3,268,134,0,2870,267,1,0,0,0,2871,2872, - 3,272,136,0,2872,2873,6,134,-1,0,2873,2875,1,0,0,0,2874,2871,1,0,0,0,2875, - 2876,1,0,0,0,2876,2874,1,0,0,0,2876,2877,1,0,0,0,2877,269,1,0,0,0,2878, - 2879,5,158,0,0,2879,2880,3,264,132,0,2880,2881,6,135,-1,0,2881,2895,1, - 0,0,0,2882,2883,5,158,0,0,2883,2884,3,0,0,0,2884,2885,5,159,0,0,2885,2886, - 3,0,0,0,2886,2887,6,135,-1,0,2887,2895,1,0,0,0,2888,2889,5,158,0,0,2889, - 2890,3,32,16,0,2890,2891,5,159,0,0,2891,2892,3,32,16,0,2892,2893,6,135, - -1,0,2893,2895,1,0,0,0,2894,2878,1,0,0,0,2894,2882,1,0,0,0,2894,2888,1, - 0,0,0,2895,271,1,0,0,0,2896,2897,3,276,138,0,2897,2898,3,282,141,0,2898, - 2899,6,136,-1,0,2899,2913,1,0,0,0,2900,2901,3,274,137,0,2901,2902,3,282, - 141,0,2902,2903,6,136,-1,0,2903,2913,1,0,0,0,2904,2905,3,278,139,0,2905, - 2906,3,282,141,0,2906,2907,6,136,-1,0,2907,2913,1,0,0,0,2908,2909,3,280, - 140,0,2909,2910,3,282,141,0,2910,2911,6,136,-1,0,2911,2913,1,0,0,0,2912, - 2896,1,0,0,0,2912,2900,1,0,0,0,2912,2904,1,0,0,0,2912,2908,1,0,0,0,2913, - 273,1,0,0,0,2914,2915,5,160,0,0,2915,2916,3,264,132,0,2916,2917,6,137, - -1,0,2917,2927,1,0,0,0,2918,2919,5,160,0,0,2919,2920,3,0,0,0,2920,2921, - 6,137,-1,0,2921,2927,1,0,0,0,2922,2923,5,160,0,0,2923,2924,3,32,16,0,2924, - 2925,6,137,-1,0,2925,2927,1,0,0,0,2926,2914,1,0,0,0,2926,2918,1,0,0,0, - 2926,2922,1,0,0,0,2927,275,1,0,0,0,2928,2929,5,161,0,0,2929,2930,3,124, - 62,0,2930,277,1,0,0,0,2931,2932,5,162,0,0,2932,279,1,0,0,0,2933,2934,5, - 163,0,0,2934,281,1,0,0,0,2935,2936,3,264,132,0,2936,2937,6,141,-1,0,2937, - 2951,1,0,0,0,2938,2939,5,164,0,0,2939,2940,3,0,0,0,2940,2941,5,159,0,0, - 2941,2942,3,0,0,0,2942,2943,6,141,-1,0,2943,2951,1,0,0,0,2944,2945,5,164, - 0,0,2945,2946,3,32,16,0,2946,2947,5,159,0,0,2947,2948,3,32,16,0,2948,2949, - 6,141,-1,0,2949,2951,1,0,0,0,2950,2935,1,0,0,0,2950,2938,1,0,0,0,2950, - 2944,1,0,0,0,2951,283,1,0,0,0,2952,2953,3,286,143,0,2953,2954,3,290,145, - 0,2954,285,1,0,0,0,2955,2956,5,165,0,0,2956,2957,3,288,144,0,2957,2958, - 3,0,0,0,2958,2959,5,36,0,0,2959,2963,1,0,0,0,2960,2961,5,165,0,0,2961, - 2963,3,288,144,0,2962,2955,1,0,0,0,2962,2960,1,0,0,0,2963,287,1,0,0,0, - 2964,2968,1,0,0,0,2965,2968,5,166,0,0,2966,2968,5,2,0,0,2967,2964,1,0, - 0,0,2967,2965,1,0,0,0,2967,2966,1,0,0,0,2968,289,1,0,0,0,2969,2970,5,17, - 0,0,2970,2971,3,292,146,0,2971,2972,5,18,0,0,2972,2979,1,0,0,0,2973,2975, - 3,296,148,0,2974,2973,1,0,0,0,2975,2976,1,0,0,0,2976,2974,1,0,0,0,2976, - 2977,1,0,0,0,2977,2979,1,0,0,0,2978,2969,1,0,0,0,2978,2974,1,0,0,0,2979, - 291,1,0,0,0,2980,2981,3,296,148,0,2981,2982,5,28,0,0,2982,2984,1,0,0,0, - 2983,2980,1,0,0,0,2984,2987,1,0,0,0,2985,2983,1,0,0,0,2985,2986,1,0,0, - 0,2986,2988,1,0,0,0,2987,2985,1,0,0,0,2988,2989,3,296,148,0,2989,293,1, - 0,0,0,2990,2996,1,0,0,0,2991,2992,5,42,0,0,2992,2993,3,32,16,0,2993,2994, - 5,43,0,0,2994,2996,1,0,0,0,2995,2990,1,0,0,0,2995,2991,1,0,0,0,2996,295, - 1,0,0,0,2997,2998,5,181,0,0,2998,2999,5,262,0,0,2999,3000,5,30,0,0,3000, - 3001,3,6,3,0,3001,3002,5,31,0,0,3002,3064,1,0,0,0,3003,3004,5,260,0,0, - 3004,3005,5,30,0,0,3005,3006,3,0,0,0,3006,3007,5,31,0,0,3007,3064,1,0, - 0,0,3008,3009,5,260,0,0,3009,3064,3,0,0,0,3010,3011,5,84,0,0,3011,3012, - 5,30,0,0,3012,3013,3,300,150,0,3013,3014,5,31,0,0,3014,3064,1,0,0,0,3015, - 3016,5,188,0,0,3016,3017,5,30,0,0,3017,3018,3,36,18,0,3018,3019,5,31,0, - 0,3019,3020,3,294,147,0,3020,3064,1,0,0,0,3021,3022,5,189,0,0,3022,3023, - 5,30,0,0,3023,3024,3,36,18,0,3024,3025,5,31,0,0,3025,3026,3,294,147,0, - 3026,3064,1,0,0,0,3027,3028,5,187,0,0,3028,3029,5,30,0,0,3029,3030,3,34, - 17,0,3030,3031,5,31,0,0,3031,3032,3,294,147,0,3032,3064,1,0,0,0,3033,3034, - 5,186,0,0,3034,3035,5,30,0,0,3035,3036,3,32,16,0,3036,3037,5,31,0,0,3037, - 3038,3,294,147,0,3038,3064,1,0,0,0,3039,3040,5,185,0,0,3040,3041,5,30, - 0,0,3041,3042,3,32,16,0,3042,3043,5,31,0,0,3043,3044,3,294,147,0,3044, - 3064,1,0,0,0,3045,3046,5,184,0,0,3046,3047,5,30,0,0,3047,3048,3,32,16, - 0,3048,3049,5,31,0,0,3049,3050,3,294,147,0,3050,3064,1,0,0,0,3051,3052, - 5,188,0,0,3052,3064,3,294,147,0,3053,3054,5,189,0,0,3054,3064,3,294,147, - 0,3055,3056,5,187,0,0,3056,3064,3,294,147,0,3057,3058,5,186,0,0,3058,3064, - 3,294,147,0,3059,3060,5,185,0,0,3060,3064,3,294,147,0,3061,3062,5,184, - 0,0,3062,3064,3,294,147,0,3063,2997,1,0,0,0,3063,3003,1,0,0,0,3063,3008, - 1,0,0,0,3063,3010,1,0,0,0,3063,3015,1,0,0,0,3063,3021,1,0,0,0,3063,3027, - 1,0,0,0,3063,3033,1,0,0,0,3063,3039,1,0,0,0,3063,3045,1,0,0,0,3063,3051, - 1,0,0,0,3063,3053,1,0,0,0,3063,3055,1,0,0,0,3063,3057,1,0,0,0,3063,3059, - 1,0,0,0,3063,3061,1,0,0,0,3064,297,1,0,0,0,3065,3066,5,188,0,0,3066,3067, - 5,30,0,0,3067,3068,3,36,18,0,3068,3069,5,31,0,0,3069,3141,1,0,0,0,3070, - 3071,5,189,0,0,3071,3072,5,30,0,0,3072,3073,3,36,18,0,3073,3074,5,31,0, - 0,3074,3141,1,0,0,0,3075,3076,5,188,0,0,3076,3077,5,30,0,0,3077,3078,3, - 32,16,0,3078,3079,5,31,0,0,3079,3141,1,0,0,0,3080,3081,5,189,0,0,3081, - 3082,5,30,0,0,3082,3083,3,34,17,0,3083,3084,5,31,0,0,3084,3141,1,0,0,0, - 3085,3086,5,187,0,0,3086,3087,5,30,0,0,3087,3088,3,34,17,0,3088,3089,5, - 31,0,0,3089,3141,1,0,0,0,3090,3091,5,186,0,0,3091,3092,5,30,0,0,3092,3093, - 3,32,16,0,3093,3094,5,31,0,0,3094,3141,1,0,0,0,3095,3096,5,185,0,0,3096, - 3097,5,30,0,0,3097,3098,3,32,16,0,3098,3099,5,31,0,0,3099,3141,1,0,0,0, - 3100,3101,5,184,0,0,3101,3102,5,30,0,0,3102,3103,3,32,16,0,3103,3104,5, - 31,0,0,3104,3141,1,0,0,0,3105,3106,5,193,0,0,3106,3107,5,30,0,0,3107,3108, - 3,34,17,0,3108,3109,5,31,0,0,3109,3141,1,0,0,0,3110,3111,5,192,0,0,3111, - 3112,5,30,0,0,3112,3113,3,32,16,0,3113,3114,5,31,0,0,3114,3141,1,0,0,0, - 3115,3116,5,191,0,0,3116,3117,5,30,0,0,3117,3118,3,32,16,0,3118,3119,5, - 31,0,0,3119,3141,1,0,0,0,3120,3121,5,190,0,0,3121,3122,5,30,0,0,3122,3123, - 3,32,16,0,3123,3124,5,31,0,0,3124,3141,1,0,0,0,3125,3126,5,181,0,0,3126, - 3127,5,30,0,0,3127,3128,3,32,16,0,3128,3129,5,31,0,0,3129,3141,1,0,0,0, - 3130,3131,5,183,0,0,3131,3132,5,30,0,0,3132,3133,3,162,81,0,3133,3134, - 5,31,0,0,3134,3141,1,0,0,0,3135,3136,5,84,0,0,3136,3137,5,30,0,0,3137, - 3138,3,300,150,0,3138,3139,5,31,0,0,3139,3141,1,0,0,0,3140,3065,1,0,0, - 0,3140,3070,1,0,0,0,3140,3075,1,0,0,0,3140,3080,1,0,0,0,3140,3085,1,0, - 0,0,3140,3090,1,0,0,0,3140,3095,1,0,0,0,3140,3100,1,0,0,0,3140,3105,1, - 0,0,0,3140,3110,1,0,0,0,3140,3115,1,0,0,0,3140,3120,1,0,0,0,3140,3125, - 1,0,0,0,3140,3130,1,0,0,0,3140,3135,1,0,0,0,3141,299,1,0,0,0,3142,3143, - 3,302,151,0,3143,3144,6,150,-1,0,3144,3146,1,0,0,0,3145,3142,1,0,0,0,3146, - 3149,1,0,0,0,3147,3145,1,0,0,0,3147,3148,1,0,0,0,3148,301,1,0,0,0,3149, - 3147,1,0,0,0,3150,3151,7,10,0,0,3151,303,1,0,0,0,3152,3156,3,298,149,0, - 3153,3156,3,6,3,0,3154,3156,5,179,0,0,3155,3152,1,0,0,0,3155,3153,1,0, - 0,0,3155,3154,1,0,0,0,3156,305,1,0,0,0,3157,3306,3,298,149,0,3158,3159, - 5,182,0,0,3159,3160,5,30,0,0,3160,3161,5,179,0,0,3161,3306,5,31,0,0,3162, - 3163,5,182,0,0,3163,3164,5,30,0,0,3164,3165,5,264,0,0,3165,3306,5,31,0, - 0,3166,3167,5,196,0,0,3167,3168,5,30,0,0,3168,3169,5,39,0,0,3169,3170, - 5,264,0,0,3170,3306,5,31,0,0,3171,3172,5,196,0,0,3172,3173,5,30,0,0,3173, - 3174,3,116,58,0,3174,3175,5,31,0,0,3175,3306,1,0,0,0,3176,3177,5,196,0, - 0,3177,3178,5,30,0,0,3178,3179,5,179,0,0,3179,3306,5,31,0,0,3180,3181, - 5,197,0,0,3181,3182,5,30,0,0,3182,3183,3,306,153,0,3183,3184,5,31,0,0, - 3184,3306,1,0,0,0,3185,3186,5,188,0,0,3186,3187,5,42,0,0,3187,3188,3,32, - 16,0,3188,3189,5,43,0,0,3189,3190,5,30,0,0,3190,3191,3,308,154,0,3191, - 3192,5,31,0,0,3192,3306,1,0,0,0,3193,3194,5,189,0,0,3194,3195,5,42,0,0, - 3195,3196,3,32,16,0,3196,3197,5,43,0,0,3197,3198,5,30,0,0,3198,3199,3, - 310,155,0,3199,3200,5,31,0,0,3200,3306,1,0,0,0,3201,3202,5,187,0,0,3202, - 3203,5,42,0,0,3203,3204,3,32,16,0,3204,3205,5,43,0,0,3205,3206,5,30,0, - 0,3206,3207,3,312,156,0,3207,3208,5,31,0,0,3208,3306,1,0,0,0,3209,3210, - 5,186,0,0,3210,3211,5,42,0,0,3211,3212,3,32,16,0,3212,3213,5,43,0,0,3213, - 3214,5,30,0,0,3214,3215,3,314,157,0,3215,3216,5,31,0,0,3216,3306,1,0,0, - 0,3217,3218,5,185,0,0,3218,3219,5,42,0,0,3219,3220,3,32,16,0,3220,3221, - 5,43,0,0,3221,3222,5,30,0,0,3222,3223,3,316,158,0,3223,3224,5,31,0,0,3224, - 3306,1,0,0,0,3225,3226,5,184,0,0,3226,3227,5,42,0,0,3227,3228,3,32,16, - 0,3228,3229,5,43,0,0,3229,3230,5,30,0,0,3230,3231,3,318,159,0,3231,3232, - 5,31,0,0,3232,3306,1,0,0,0,3233,3234,5,193,0,0,3234,3235,5,42,0,0,3235, - 3236,3,32,16,0,3236,3237,5,43,0,0,3237,3238,5,30,0,0,3238,3239,3,312,156, - 0,3239,3240,5,31,0,0,3240,3306,1,0,0,0,3241,3242,5,192,0,0,3242,3243,5, - 42,0,0,3243,3244,3,32,16,0,3244,3245,5,43,0,0,3245,3246,5,30,0,0,3246, - 3247,3,314,157,0,3247,3248,5,31,0,0,3248,3306,1,0,0,0,3249,3250,5,191, - 0,0,3250,3251,5,42,0,0,3251,3252,3,32,16,0,3252,3253,5,43,0,0,3253,3254, - 5,30,0,0,3254,3255,3,316,158,0,3255,3256,5,31,0,0,3256,3306,1,0,0,0,3257, - 3258,5,190,0,0,3258,3259,5,42,0,0,3259,3260,3,32,16,0,3260,3261,5,43,0, - 0,3261,3262,5,30,0,0,3262,3263,3,318,159,0,3263,3264,5,31,0,0,3264,3306, - 1,0,0,0,3265,3266,5,181,0,0,3266,3267,5,42,0,0,3267,3268,3,32,16,0,3268, - 3269,5,43,0,0,3269,3270,5,30,0,0,3270,3271,3,316,158,0,3271,3272,5,31, - 0,0,3272,3306,1,0,0,0,3273,3274,5,183,0,0,3274,3275,5,42,0,0,3275,3276, - 3,32,16,0,3276,3277,5,43,0,0,3277,3278,5,30,0,0,3278,3279,3,320,160,0, - 3279,3280,5,31,0,0,3280,3306,1,0,0,0,3281,3282,5,182,0,0,3282,3283,5,42, - 0,0,3283,3284,3,32,16,0,3284,3285,5,43,0,0,3285,3286,5,30,0,0,3286,3287, - 3,322,161,0,3287,3288,5,31,0,0,3288,3306,1,0,0,0,3289,3290,5,196,0,0,3290, - 3291,5,42,0,0,3291,3292,3,32,16,0,3292,3293,5,43,0,0,3293,3294,5,30,0, - 0,3294,3295,3,324,162,0,3295,3296,5,31,0,0,3296,3306,1,0,0,0,3297,3298, - 5,197,0,0,3298,3299,5,42,0,0,3299,3300,3,32,16,0,3300,3301,5,43,0,0,3301, - 3302,5,30,0,0,3302,3303,3,328,164,0,3303,3304,5,31,0,0,3304,3306,1,0,0, - 0,3305,3157,1,0,0,0,3305,3158,1,0,0,0,3305,3162,1,0,0,0,3305,3166,1,0, - 0,0,3305,3171,1,0,0,0,3305,3176,1,0,0,0,3305,3180,1,0,0,0,3305,3185,1, - 0,0,0,3305,3193,1,0,0,0,3305,3201,1,0,0,0,3305,3209,1,0,0,0,3305,3217, - 1,0,0,0,3305,3225,1,0,0,0,3305,3233,1,0,0,0,3305,3241,1,0,0,0,3305,3249, - 1,0,0,0,3305,3257,1,0,0,0,3305,3265,1,0,0,0,3305,3273,1,0,0,0,3305,3281, - 1,0,0,0,3305,3289,1,0,0,0,3305,3297,1,0,0,0,3306,307,1,0,0,0,3307,3310, - 3,36,18,0,3308,3310,3,32,16,0,3309,3307,1,0,0,0,3309,3308,1,0,0,0,3310, - 3313,1,0,0,0,3311,3309,1,0,0,0,3311,3312,1,0,0,0,3312,309,1,0,0,0,3313, - 3311,1,0,0,0,3314,3317,3,36,18,0,3315,3317,3,34,17,0,3316,3314,1,0,0,0, - 3316,3315,1,0,0,0,3317,3320,1,0,0,0,3318,3316,1,0,0,0,3318,3319,1,0,0, - 0,3319,311,1,0,0,0,3320,3318,1,0,0,0,3321,3323,3,34,17,0,3322,3321,1,0, - 0,0,3323,3326,1,0,0,0,3324,3322,1,0,0,0,3324,3325,1,0,0,0,3325,313,1,0, - 0,0,3326,3324,1,0,0,0,3327,3329,3,32,16,0,3328,3327,1,0,0,0,3329,3332, - 1,0,0,0,3330,3328,1,0,0,0,3330,3331,1,0,0,0,3331,315,1,0,0,0,3332,3330, - 1,0,0,0,3333,3335,3,32,16,0,3334,3333,1,0,0,0,3335,3338,1,0,0,0,3336,3334, - 1,0,0,0,3336,3337,1,0,0,0,3337,317,1,0,0,0,3338,3336,1,0,0,0,3339,3341, - 3,32,16,0,3340,3339,1,0,0,0,3341,3344,1,0,0,0,3342,3340,1,0,0,0,3342,3343, - 1,0,0,0,3343,319,1,0,0,0,3344,3342,1,0,0,0,3345,3347,3,162,81,0,3346,3345, - 1,0,0,0,3347,3350,1,0,0,0,3348,3346,1,0,0,0,3348,3349,1,0,0,0,3349,321, - 1,0,0,0,3350,3348,1,0,0,0,3351,3353,7,11,0,0,3352,3351,1,0,0,0,3353,3356, - 1,0,0,0,3354,3352,1,0,0,0,3354,3355,1,0,0,0,3355,323,1,0,0,0,3356,3354, - 1,0,0,0,3357,3359,3,326,163,0,3358,3357,1,0,0,0,3359,3362,1,0,0,0,3360, - 3358,1,0,0,0,3360,3361,1,0,0,0,3361,325,1,0,0,0,3362,3360,1,0,0,0,3363, - 3368,5,179,0,0,3364,3365,5,39,0,0,3365,3368,5,264,0,0,3366,3368,3,116, - 58,0,3367,3363,1,0,0,0,3367,3364,1,0,0,0,3367,3366,1,0,0,0,3368,327,1, - 0,0,0,3369,3371,3,306,153,0,3370,3369,1,0,0,0,3371,3374,1,0,0,0,3372,3370, - 1,0,0,0,3372,3373,1,0,0,0,3373,329,1,0,0,0,3374,3372,1,0,0,0,3375,3379, - 3,44,22,0,3376,3379,3,46,23,0,3377,3379,3,2,1,0,3378,3375,1,0,0,0,3378, - 3376,1,0,0,0,3378,3377,1,0,0,0,3379,331,1,0,0,0,3380,3381,7,12,0,0,3381, - 3382,5,36,0,0,3382,3383,5,30,0,0,3383,3384,3,300,150,0,3384,3385,5,31, - 0,0,3385,3406,1,0,0,0,3386,3387,5,169,0,0,3387,3388,3,38,19,0,3388,3389, - 5,75,0,0,3389,3390,3,38,19,0,3390,3391,5,75,0,0,3391,3392,3,38,19,0,3392, - 3393,5,75,0,0,3393,3394,3,38,19,0,3394,3406,1,0,0,0,3395,3396,5,170,0, - 0,3396,3406,3,6,3,0,3397,3398,5,170,0,0,3398,3399,5,36,0,0,3399,3400,5, - 30,0,0,3400,3401,3,300,150,0,3401,3402,5,31,0,0,3402,3406,1,0,0,0,3403, - 3406,3,330,165,0,3404,3406,3,40,20,0,3405,3380,1,0,0,0,3405,3386,1,0,0, - 0,3405,3395,1,0,0,0,3405,3397,1,0,0,0,3405,3403,1,0,0,0,3405,3404,1,0, - 0,0,3406,333,1,0,0,0,3407,3408,3,336,168,0,3408,3409,5,17,0,0,3409,3410, - 3,338,169,0,3410,3411,5,18,0,0,3411,335,1,0,0,0,3412,3413,5,25,0,0,3413, - 3414,5,40,0,0,3414,3415,3,98,49,0,3415,3416,3,2,1,0,3416,3425,1,0,0,0, - 3417,3418,5,25,0,0,3418,3419,5,40,0,0,3419,3420,3,98,49,0,3420,3421,3, - 2,1,0,3421,3422,5,34,0,0,3422,3423,3,2,1,0,3423,3425,1,0,0,0,3424,3412, - 1,0,0,0,3424,3417,1,0,0,0,3425,337,1,0,0,0,3426,3428,3,340,170,0,3427, - 3426,1,0,0,0,3428,3431,1,0,0,0,3429,3427,1,0,0,0,3429,3430,1,0,0,0,3430, - 339,1,0,0,0,3431,3429,1,0,0,0,3432,3433,5,180,0,0,3433,3434,5,36,0,0,3434, - 3435,5,30,0,0,3435,3436,3,300,150,0,3436,3437,5,31,0,0,3437,3447,1,0,0, - 0,3438,3447,3,332,166,0,3439,3440,5,171,0,0,3440,3441,5,36,0,0,3441,3442, - 5,30,0,0,3442,3443,3,300,150,0,3443,3444,5,31,0,0,3444,3447,1,0,0,0,3445, - 3447,5,55,0,0,3446,3432,1,0,0,0,3446,3438,1,0,0,0,3446,3439,1,0,0,0,3446, - 3445,1,0,0,0,3447,341,1,0,0,0,3448,3449,3,344,172,0,3449,3450,5,17,0,0, - 3450,3451,3,350,175,0,3451,3452,5,18,0,0,3452,343,1,0,0,0,3453,3454,5, - 50,0,0,3454,3458,5,40,0,0,3455,3457,3,348,174,0,3456,3455,1,0,0,0,3457, - 3460,1,0,0,0,3458,3456,1,0,0,0,3458,3459,1,0,0,0,3459,3461,1,0,0,0,3460, - 3458,1,0,0,0,3461,3462,3,2,1,0,3462,345,1,0,0,0,3463,3467,5,301,0,0,3464, - 3466,3,348,174,0,3465,3464,1,0,0,0,3466,3469,1,0,0,0,3467,3465,1,0,0,0, - 3467,3468,1,0,0,0,3468,3470,1,0,0,0,3469,3467,1,0,0,0,3470,3471,3,2,1, - 0,3471,347,1,0,0,0,3472,3488,5,52,0,0,3473,3488,5,51,0,0,3474,3488,5,172, - 0,0,3475,3476,5,62,0,0,3476,3488,5,51,0,0,3477,3478,5,62,0,0,3478,3488, - 5,52,0,0,3479,3480,5,62,0,0,3480,3488,5,63,0,0,3481,3482,5,62,0,0,3482, - 3488,5,64,0,0,3483,3484,5,62,0,0,3484,3488,5,65,0,0,3485,3486,5,62,0,0, - 3486,3488,5,66,0,0,3487,3472,1,0,0,0,3487,3473,1,0,0,0,3487,3474,1,0,0, - 0,3487,3475,1,0,0,0,3487,3477,1,0,0,0,3487,3479,1,0,0,0,3487,3481,1,0, - 0,0,3487,3483,1,0,0,0,3487,3485,1,0,0,0,3488,349,1,0,0,0,3489,3491,3,352, - 176,0,3490,3489,1,0,0,0,3491,3494,1,0,0,0,3492,3490,1,0,0,0,3492,3493, - 1,0,0,0,3493,351,1,0,0,0,3494,3492,1,0,0,0,3495,3496,5,21,0,0,3496,3509, - 3,2,1,0,3497,3498,5,50,0,0,3498,3499,5,40,0,0,3499,3509,3,118,59,0,3500, - 3501,5,25,0,0,3501,3502,5,40,0,0,3502,3509,3,2,1,0,3503,3509,3,174,87, - 0,3504,3505,5,50,0,0,3505,3509,3,32,16,0,3506,3509,3,330,165,0,3507,3509, - 3,40,20,0,3508,3495,1,0,0,0,3508,3497,1,0,0,0,3508,3500,1,0,0,0,3508,3503, - 1,0,0,0,3508,3504,1,0,0,0,3508,3506,1,0,0,0,3508,3507,1,0,0,0,3509,353, - 1,0,0,0,3510,3511,3,356,178,0,3511,3512,5,17,0,0,3512,3513,3,360,180,0, - 3513,3514,5,18,0,0,3514,355,1,0,0,0,3515,3519,5,274,0,0,3516,3518,3,358, - 179,0,3517,3516,1,0,0,0,3518,3521,1,0,0,0,3519,3517,1,0,0,0,3519,3520, - 1,0,0,0,3520,3522,1,0,0,0,3521,3519,1,0,0,0,3522,3535,3,2,1,0,3523,3527, - 5,274,0,0,3524,3526,3,358,179,0,3525,3524,1,0,0,0,3526,3529,1,0,0,0,3527, - 3525,1,0,0,0,3527,3528,1,0,0,0,3528,3530,1,0,0,0,3529,3527,1,0,0,0,3530, - 3531,3,2,1,0,3531,3532,5,34,0,0,3532,3533,3,2,1,0,3533,3535,1,0,0,0,3534, - 3515,1,0,0,0,3534,3523,1,0,0,0,3535,357,1,0,0,0,3536,3537,7,13,0,0,3537, - 359,1,0,0,0,3538,3540,3,362,181,0,3539,3538,1,0,0,0,3540,3543,1,0,0,0, - 3541,3539,1,0,0,0,3541,3542,1,0,0,0,3542,361,1,0,0,0,3543,3541,1,0,0,0, - 3544,3545,5,21,0,0,3545,3546,3,2,1,0,3546,3547,5,44,0,0,3547,3548,3,32, - 16,0,3548,3555,1,0,0,0,3549,3550,5,25,0,0,3550,3551,5,40,0,0,3551,3555, - 3,2,1,0,3552,3555,3,330,165,0,3553,3555,3,40,20,0,3554,3544,1,0,0,0,3554, - 3549,1,0,0,0,3554,3552,1,0,0,0,3554,3553,1,0,0,0,3555,363,1,0,0,0,181, - 374,382,391,400,489,535,546,576,580,598,625,648,684,694,701,703,713,715, - 722,733,746,767,769,788,861,868,875,880,889,1000,1006,1022,1028,1034,1041, - 1069,1147,1149,1163,1169,1178,1180,1189,1203,1217,1225,1233,1237,1276, - 1284,1293,1301,1320,1330,1333,1357,1504,1514,1523,1526,1608,1617,1649, - 1709,1749,1765,1775,1802,1826,1834,1838,1853,1860,1905,1915,1933,1951, - 1970,1991,2010,2025,2033,2045,2065,2072,2077,2088,2100,2210,2222,2238, - 2252,2261,2274,2276,2319,2330,2337,2345,2353,2366,2372,2378,2383,2412, - 2420,2434,2439,2464,2473,2484,2488,2495,2515,2524,2526,2541,2588,2598, - 2600,2607,2613,2657,2666,2706,2711,2751,2755,2765,2787,2799,2810,2825, - 2838,2851,2854,2862,2876,2894,2912,2926,2950,2962,2967,2976,2978,2985, - 2995,3063,3140,3147,3155,3305,3309,3311,3316,3318,3324,3330,3336,3342, - 3348,3354,3360,3367,3372,3378,3405,3424,3429,3446,3458,3467,3487,3492, - 3508,3519,3527,3534,3541,3554 + 1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,3,166,3514, + 8,166,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,168,3,168,3533,8,168,1,169,5,169,3536, + 8,169,10,169,12,169,3539,9,169,1,170,1,170,1,170,1,170,1,170,1,170,1,170, + 1,170,1,170,1,170,1,170,1,170,1,170,1,170,3,170,3555,8,170,1,171,1,171, + 1,171,1,171,1,171,1,172,1,172,1,172,5,172,3565,8,172,10,172,12,172,3568, + 9,172,1,172,1,172,1,173,1,173,5,173,3574,8,173,10,173,12,173,3577,9,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,3,174,3596,8,174,1,175,5,175,3599,8,175, + 10,175,12,175,3602,9,175,1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176, + 1,176,1,176,1,176,1,176,1,176,3,176,3617,8,176,1,177,1,177,1,177,1,177, + 1,177,1,178,1,178,5,178,3626,8,178,10,178,12,178,3629,9,178,1,178,1,178, + 1,178,5,178,3634,8,178,10,178,12,178,3637,9,178,1,178,1,178,1,178,1,178, + 3,178,3643,8,178,1,179,1,179,1,180,5,180,3648,8,180,10,180,12,180,3651, + 9,180,1,181,1,181,1,181,1,181,1,181,1,181,1,181,1,181,1,181,1,181,3,181, + 3663,8,181,1,181,0,1,68,182,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,0,13,6,0,1,15, + 199,199,243,243,247,247,264,264,289,289,5,0,16,16,199,199,243,243,264, + 264,288,289,1,0,263,264,1,0,173,174,1,0,37,38,1,0,73,74,3,0,2,2,61,61, + 77,83,2,0,229,229,260,261,1,0,95,96,1,0,97,111,2,0,173,173,289,290,1,0, + 167,168,1,0,51,52,4127,0,364,1,0,0,0,2,382,1,0,0,0,4,384,1,0,0,0,6,391, + 1,0,0,0,8,400,1,0,0,0,10,489,1,0,0,0,12,491,1,0,0,0,14,495,1,0,0,0,16, + 499,1,0,0,0,18,504,1,0,0,0,20,508,1,0,0,0,22,512,1,0,0,0,24,519,1,0,0, + 0,26,535,1,0,0,0,28,537,1,0,0,0,30,539,1,0,0,0,32,551,1,0,0,0,34,553,1, + 0,0,0,36,576,1,0,0,0,38,580,1,0,0,0,40,598,1,0,0,0,42,625,1,0,0,0,44,653, + 1,0,0,0,46,693,1,0,0,0,48,695,1,0,0,0,50,704,1,0,0,0,52,706,1,0,0,0,54, + 716,1,0,0,0,56,729,1,0,0,0,58,732,1,0,0,0,60,735,1,0,0,0,62,759,1,0,0, + 0,64,772,1,0,0,0,66,774,1,0,0,0,68,782,1,0,0,0,70,798,1,0,0,0,72,804,1, + 0,0,0,74,808,1,0,0,0,76,887,1,0,0,0,78,894,1,0,0,0,80,901,1,0,0,0,82,906, + 1,0,0,0,84,915,1,0,0,0,86,921,1,0,0,0,88,1026,1,0,0,0,90,1054,1,0,0,0, + 92,1056,1,0,0,0,94,1060,1,0,0,0,96,1062,1,0,0,0,98,1067,1,0,0,0,100,1095, + 1,0,0,0,102,1175,1,0,0,0,104,1177,1,0,0,0,106,1206,1,0,0,0,108,1208,1, + 0,0,0,110,1222,1,0,0,0,112,1251,1,0,0,0,114,1263,1,0,0,0,116,1302,1,0, + 0,0,118,1310,1,0,0,0,120,1319,1,0,0,0,122,1327,1,0,0,0,124,1346,1,0,0, + 0,126,1359,1,0,0,0,128,1383,1,0,0,0,130,1530,1,0,0,0,132,1540,1,0,0,0, + 134,1552,1,0,0,0,136,1634,1,0,0,0,138,1636,1,0,0,0,140,1675,1,0,0,0,142, + 1735,1,0,0,0,144,1775,1,0,0,0,146,1791,1,0,0,0,148,1793,1,0,0,0,150,1797, + 1,0,0,0,152,1852,1,0,0,0,154,1864,1,0,0,0,156,1879,1,0,0,0,158,1886,1, + 0,0,0,160,1891,1,0,0,0,162,1895,1,0,0,0,164,1931,1,0,0,0,166,1933,1,0, + 0,0,168,1977,1,0,0,0,170,1996,1,0,0,0,172,2017,1,0,0,0,174,2019,1,0,0, + 0,176,2036,1,0,0,0,178,2051,1,0,0,0,180,2059,1,0,0,0,182,2071,1,0,0,0, + 184,2091,1,0,0,0,186,2098,1,0,0,0,188,2101,1,0,0,0,190,2114,1,0,0,0,192, + 2120,1,0,0,0,194,2126,1,0,0,0,196,2130,1,0,0,0,198,2287,1,0,0,0,200,2289, + 1,0,0,0,202,2345,1,0,0,0,204,2356,1,0,0,0,206,2363,1,0,0,0,208,2371,1, + 0,0,0,210,2398,1,0,0,0,212,2404,1,0,0,0,214,2409,1,0,0,0,216,2438,1,0, + 0,0,218,2440,1,0,0,0,220,2460,1,0,0,0,222,2465,1,0,0,0,224,2490,1,0,0, + 0,226,2499,1,0,0,0,228,2514,1,0,0,0,230,2521,1,0,0,0,232,2541,1,0,0,0, + 234,2543,1,0,0,0,236,2614,1,0,0,0,238,2639,1,0,0,0,240,2683,1,0,0,0,242, + 2692,1,0,0,0,244,2732,1,0,0,0,246,2737,1,0,0,0,248,2777,1,0,0,0,250,2779, + 1,0,0,0,252,2785,1,0,0,0,254,2793,1,0,0,0,256,2813,1,0,0,0,258,2880,1, + 0,0,0,260,2882,1,0,0,0,262,2892,1,0,0,0,264,2894,1,0,0,0,266,2898,1,0, + 0,0,268,2904,1,0,0,0,270,2924,1,0,0,0,272,2942,1,0,0,0,274,2956,1,0,0, + 0,276,2958,1,0,0,0,278,2961,1,0,0,0,280,2963,1,0,0,0,282,2980,1,0,0,0, + 284,2982,1,0,0,0,286,2992,1,0,0,0,288,2997,1,0,0,0,290,3008,1,0,0,0,292, + 3015,1,0,0,0,294,3025,1,0,0,0,296,3093,1,0,0,0,298,3185,1,0,0,0,300,3192, + 1,0,0,0,302,3195,1,0,0,0,304,3205,1,0,0,0,306,3378,1,0,0,0,308,3388,1, + 0,0,0,310,3399,1,0,0,0,312,3407,1,0,0,0,314,3415,1,0,0,0,316,3423,1,0, + 0,0,318,3431,1,0,0,0,320,3439,1,0,0,0,322,3448,1,0,0,0,324,3456,1,0,0, + 0,326,3467,1,0,0,0,328,3474,1,0,0,0,330,3486,1,0,0,0,332,3513,1,0,0,0, + 334,3515,1,0,0,0,336,3532,1,0,0,0,338,3537,1,0,0,0,340,3554,1,0,0,0,342, + 3556,1,0,0,0,344,3561,1,0,0,0,346,3571,1,0,0,0,348,3595,1,0,0,0,350,3600, + 1,0,0,0,352,3616,1,0,0,0,354,3618,1,0,0,0,356,3642,1,0,0,0,358,3644,1, + 0,0,0,360,3649,1,0,0,0,362,3662,1,0,0,0,364,365,7,0,0,0,365,1,1,0,0,0, + 366,367,5,288,0,0,367,383,6,1,-1,0,368,369,3,4,2,0,369,370,6,1,-1,0,370, + 371,5,265,0,0,371,373,1,0,0,0,372,368,1,0,0,0,373,376,1,0,0,0,374,372, + 1,0,0,0,374,375,1,0,0,0,375,377,1,0,0,0,376,374,1,0,0,0,377,378,3,4,2, + 0,378,379,6,1,-1,0,379,383,1,0,0,0,380,381,5,264,0,0,381,383,6,1,-1,0, + 382,366,1,0,0,0,382,374,1,0,0,0,382,380,1,0,0,0,383,3,1,0,0,0,384,385, + 7,1,0,0,385,5,1,0,0,0,386,387,5,263,0,0,387,388,6,3,-1,0,388,390,5,266, + 0,0,389,386,1,0,0,0,390,393,1,0,0,0,391,389,1,0,0,0,391,392,1,0,0,0,392, + 394,1,0,0,0,393,391,1,0,0,0,394,395,5,263,0,0,395,396,6,3,-1,0,396,7,1, + 0,0,0,397,399,3,10,5,0,398,397,1,0,0,0,399,402,1,0,0,0,400,398,1,0,0,0, + 400,401,1,0,0,0,401,9,1,0,0,0,402,400,1,0,0,0,403,404,3,74,37,0,404,405, + 5,17,0,0,405,406,3,82,41,0,406,407,5,18,0,0,407,490,1,0,0,0,408,409,3, + 72,36,0,409,410,5,17,0,0,410,411,3,8,4,0,411,412,5,18,0,0,412,490,1,0, + 0,0,413,414,3,234,117,0,414,415,5,17,0,0,415,416,3,246,123,0,416,417,5, + 18,0,0,417,490,1,0,0,0,418,490,3,200,100,0,419,420,6,5,-1,0,420,421,3, + 284,142,0,421,422,6,5,-1,0,422,490,1,0,0,0,423,424,6,5,-1,0,424,425,3, + 70,35,0,425,426,6,5,-1,0,426,490,1,0,0,0,427,428,6,5,-1,0,428,429,3,66, + 33,0,429,430,6,5,-1,0,430,490,1,0,0,0,431,432,6,5,-1,0,432,433,3,88,44, + 0,433,434,6,5,-1,0,434,490,1,0,0,0,435,436,6,5,-1,0,436,437,3,90,45,0, + 437,438,6,5,-1,0,438,490,1,0,0,0,439,440,6,5,-1,0,440,441,3,22,11,0,441, + 442,6,5,-1,0,442,490,1,0,0,0,443,444,6,5,-1,0,444,445,3,334,167,0,445, + 446,6,5,-1,0,446,490,1,0,0,0,447,448,6,5,-1,0,448,449,3,342,171,0,449, + 450,6,5,-1,0,450,490,1,0,0,0,451,452,6,5,-1,0,452,453,3,354,177,0,453, + 454,6,5,-1,0,454,490,1,0,0,0,455,456,6,5,-1,0,456,457,3,64,32,0,457,458, + 6,5,-1,0,458,490,1,0,0,0,459,460,6,5,-1,0,460,461,3,152,76,0,461,462,6, + 5,-1,0,462,490,1,0,0,0,463,464,3,330,165,0,464,465,6,5,-1,0,465,490,1, + 0,0,0,466,467,6,5,-1,0,467,490,3,12,6,0,468,469,6,5,-1,0,469,490,3,14, + 7,0,470,471,6,5,-1,0,471,490,3,16,8,0,472,473,6,5,-1,0,473,490,3,18,9, + 0,474,475,6,5,-1,0,475,490,3,20,10,0,476,477,6,5,-1,0,477,478,3,26,13, + 0,478,479,6,5,-1,0,479,490,1,0,0,0,480,481,6,5,-1,0,481,482,3,42,21,0, + 482,483,6,5,-1,0,483,490,1,0,0,0,484,485,6,5,-1,0,485,490,3,40,20,0,486, + 490,3,30,15,0,487,488,6,5,-1,0,488,490,3,24,12,0,489,403,1,0,0,0,489,408, + 1,0,0,0,489,413,1,0,0,0,489,418,1,0,0,0,489,419,1,0,0,0,489,423,1,0,0, + 0,489,427,1,0,0,0,489,431,1,0,0,0,489,435,1,0,0,0,489,439,1,0,0,0,489, + 443,1,0,0,0,489,447,1,0,0,0,489,451,1,0,0,0,489,455,1,0,0,0,489,459,1, + 0,0,0,489,463,1,0,0,0,489,466,1,0,0,0,489,468,1,0,0,0,489,470,1,0,0,0, + 489,472,1,0,0,0,489,474,1,0,0,0,489,476,1,0,0,0,489,480,1,0,0,0,489,484, + 1,0,0,0,489,486,1,0,0,0,489,487,1,0,0,0,490,11,1,0,0,0,491,492,5,19,0, + 0,492,493,3,32,16,0,493,494,6,6,-1,0,494,13,1,0,0,0,495,496,5,20,0,0,496, + 497,3,32,16,0,497,498,6,7,-1,0,498,15,1,0,0,0,499,500,5,21,0,0,500,501, + 5,22,0,0,501,502,3,32,16,0,502,503,6,8,-1,0,503,17,1,0,0,0,504,505,5,23, + 0,0,505,506,3,34,17,0,506,507,6,9,-1,0,507,19,1,0,0,0,508,509,5,24,0,0, + 509,510,3,34,17,0,510,511,6,10,-1,0,511,21,1,0,0,0,512,513,5,25,0,0,513, + 514,3,98,49,0,514,515,3,2,1,0,515,516,5,17,0,0,516,517,3,120,60,0,517, + 518,5,18,0,0,518,23,1,0,0,0,519,520,5,26,0,0,520,25,1,0,0,0,521,522,5, + 27,0,0,522,536,3,28,14,0,523,524,5,27,0,0,524,525,3,28,14,0,525,526,5, + 28,0,0,526,527,3,28,14,0,527,536,1,0,0,0,528,529,5,27,0,0,529,530,3,28, + 14,0,530,531,5,28,0,0,531,532,3,28,14,0,532,533,5,28,0,0,533,534,3,28, + 14,0,534,536,1,0,0,0,535,521,1,0,0,0,535,523,1,0,0,0,535,528,1,0,0,0,536, + 27,1,0,0,0,537,538,7,2,0,0,538,29,1,0,0,0,539,540,5,29,0,0,540,546,5,17, + 0,0,541,542,3,116,58,0,542,543,6,15,-1,0,543,545,1,0,0,0,544,541,1,0,0, + 0,545,548,1,0,0,0,546,544,1,0,0,0,546,547,1,0,0,0,547,549,1,0,0,0,548, + 546,1,0,0,0,549,550,5,18,0,0,550,31,1,0,0,0,551,552,5,173,0,0,552,33,1, + 0,0,0,553,554,7,3,0,0,554,35,1,0,0,0,555,556,5,175,0,0,556,577,6,18,-1, + 0,557,558,3,32,16,0,558,559,5,265,0,0,559,560,6,18,-1,0,560,577,1,0,0, + 0,561,562,3,32,16,0,562,563,6,18,-1,0,563,577,1,0,0,0,564,565,5,188,0, + 0,565,566,5,30,0,0,566,567,3,32,16,0,567,568,5,31,0,0,568,569,6,18,-1, + 0,569,577,1,0,0,0,570,571,5,189,0,0,571,572,5,30,0,0,572,573,3,34,17,0, + 573,574,5,31,0,0,574,575,6,18,-1,0,575,577,1,0,0,0,576,555,1,0,0,0,576, + 557,1,0,0,0,576,561,1,0,0,0,576,564,1,0,0,0,576,570,1,0,0,0,577,37,1,0, + 0,0,578,581,3,32,16,0,579,581,5,262,0,0,580,578,1,0,0,0,580,579,1,0,0, + 0,581,39,1,0,0,0,582,583,5,267,0,0,583,599,5,289,0,0,584,585,5,267,0,0, + 585,586,5,289,0,0,586,599,5,263,0,0,587,588,5,268,0,0,588,599,5,289,0, + 0,589,590,5,269,0,0,590,599,5,289,0,0,591,592,5,270,0,0,592,599,5,289, + 0,0,593,599,5,271,0,0,594,599,5,272,0,0,595,596,5,273,0,0,596,599,5,263, + 0,0,597,599,5,32,0,0,598,582,1,0,0,0,598,584,1,0,0,0,598,587,1,0,0,0,598, + 589,1,0,0,0,598,591,1,0,0,0,598,593,1,0,0,0,598,594,1,0,0,0,598,595,1, + 0,0,0,598,597,1,0,0,0,599,41,1,0,0,0,600,601,5,33,0,0,601,602,3,138,69, + 0,602,603,5,34,0,0,603,604,3,2,1,0,604,626,1,0,0,0,605,606,5,33,0,0,606, + 607,3,116,58,0,607,608,5,34,0,0,608,609,3,2,1,0,609,626,1,0,0,0,610,611, + 5,33,0,0,611,612,3,176,88,0,612,613,5,34,0,0,613,614,3,2,1,0,614,626,1, + 0,0,0,615,616,5,33,0,0,616,617,3,44,22,0,617,618,5,34,0,0,618,619,3,2, + 1,0,619,626,1,0,0,0,620,621,5,33,0,0,621,622,3,46,23,0,622,623,5,34,0, + 0,623,624,3,2,1,0,624,626,1,0,0,0,625,600,1,0,0,0,625,605,1,0,0,0,625, + 610,1,0,0,0,625,615,1,0,0,0,625,620,1,0,0,0,626,43,1,0,0,0,627,628,5,35, + 0,0,628,629,3,48,24,0,629,630,6,22,-1,0,630,654,1,0,0,0,631,632,5,35,0, + 0,632,633,3,48,24,0,633,634,5,36,0,0,634,635,3,6,3,0,635,636,6,22,-1,0, + 636,654,1,0,0,0,637,638,5,35,0,0,638,639,3,48,24,0,639,640,5,36,0,0,640, + 641,5,17,0,0,641,642,3,52,26,0,642,643,5,18,0,0,643,644,6,22,-1,0,644, + 654,1,0,0,0,645,646,5,35,0,0,646,647,3,48,24,0,647,648,5,36,0,0,648,649, + 5,30,0,0,649,650,3,300,150,0,650,651,5,31,0,0,651,652,6,22,-1,0,652,654, + 1,0,0,0,653,627,1,0,0,0,653,631,1,0,0,0,653,637,1,0,0,0,653,645,1,0,0, + 0,654,45,1,0,0,0,655,656,5,35,0,0,656,657,5,30,0,0,657,658,3,50,25,0,658, + 659,5,31,0,0,659,660,3,48,24,0,660,661,6,23,-1,0,661,694,1,0,0,0,662,663, + 5,35,0,0,663,664,5,30,0,0,664,665,3,50,25,0,665,666,5,31,0,0,666,667,3, + 48,24,0,667,668,5,36,0,0,668,669,3,6,3,0,669,670,6,23,-1,0,670,694,1,0, + 0,0,671,672,5,35,0,0,672,673,5,30,0,0,673,674,3,50,25,0,674,675,5,31,0, + 0,675,676,3,48,24,0,676,677,5,36,0,0,677,678,5,17,0,0,678,679,3,52,26, + 0,679,680,5,18,0,0,680,681,6,23,-1,0,681,694,1,0,0,0,682,683,5,35,0,0, + 683,684,5,30,0,0,684,685,3,50,25,0,685,686,5,31,0,0,686,687,3,48,24,0, + 687,688,5,36,0,0,688,689,5,30,0,0,689,690,3,300,150,0,690,691,5,31,0,0, + 691,692,6,23,-1,0,692,694,1,0,0,0,693,655,1,0,0,0,693,662,1,0,0,0,693, + 671,1,0,0,0,693,682,1,0,0,0,694,47,1,0,0,0,695,696,3,168,84,0,696,697, + 6,24,-1,0,697,49,1,0,0,0,698,699,3,124,62,0,699,700,6,25,-1,0,700,705, + 1,0,0,0,701,702,3,176,88,0,702,703,6,25,-1,0,703,705,1,0,0,0,704,698,1, + 0,0,0,704,701,1,0,0,0,705,51,1,0,0,0,706,707,3,54,27,0,707,708,3,56,28, + 0,708,709,6,26,-1,0,709,53,1,0,0,0,710,711,3,306,153,0,711,712,6,27,-1, + 0,712,715,1,0,0,0,713,715,3,40,20,0,714,710,1,0,0,0,714,713,1,0,0,0,715, + 718,1,0,0,0,716,714,1,0,0,0,716,717,1,0,0,0,717,55,1,0,0,0,718,716,1,0, + 0,0,719,720,3,58,29,0,720,721,3,60,30,0,721,722,3,2,1,0,722,723,5,36,0, + 0,723,724,3,306,153,0,724,725,6,28,-1,0,725,728,1,0,0,0,726,728,3,40,20, + 0,727,719,1,0,0,0,727,726,1,0,0,0,728,731,1,0,0,0,729,727,1,0,0,0,729, + 730,1,0,0,0,730,57,1,0,0,0,731,729,1,0,0,0,732,733,7,4,0,0,733,734,6,29, + -1,0,734,59,1,0,0,0,735,737,3,62,31,0,736,738,5,261,0,0,737,736,1,0,0, + 0,737,738,1,0,0,0,738,739,1,0,0,0,739,740,6,30,-1,0,740,61,1,0,0,0,741, + 742,3,144,72,0,742,743,6,31,-1,0,743,760,1,0,0,0,744,745,3,2,1,0,745,746, + 6,31,-1,0,746,760,1,0,0,0,747,748,5,196,0,0,748,760,6,31,-1,0,749,750, + 5,197,0,0,750,760,6,31,-1,0,751,752,5,202,0,0,752,753,5,39,0,0,753,754, + 5,264,0,0,754,760,6,31,-1,0,755,756,5,202,0,0,756,757,3,116,58,0,757,758, + 6,31,-1,0,758,760,1,0,0,0,759,741,1,0,0,0,759,744,1,0,0,0,759,747,1,0, + 0,0,759,749,1,0,0,0,759,751,1,0,0,0,759,755,1,0,0,0,760,63,1,0,0,0,761, + 762,5,198,0,0,762,763,5,40,0,0,763,764,3,2,1,0,764,765,6,32,-1,0,765,773, + 1,0,0,0,766,767,5,198,0,0,767,768,3,2,1,0,768,769,6,32,-1,0,769,773,1, + 0,0,0,770,771,5,198,0,0,771,773,6,32,-1,0,772,761,1,0,0,0,772,766,1,0, + 0,0,772,770,1,0,0,0,773,65,1,0,0,0,774,775,5,41,0,0,775,776,5,42,0,0,776, + 777,3,32,16,0,777,778,5,43,0,0,778,779,3,68,34,0,779,780,5,44,0,0,780, + 781,3,0,0,0,781,67,1,0,0,0,782,795,6,34,-1,0,783,784,10,5,0,0,784,794, + 5,186,0,0,785,786,10,4,0,0,786,794,5,187,0,0,787,788,10,3,0,0,788,794, + 5,45,0,0,789,790,10,2,0,0,790,794,5,46,0,0,791,792,10,1,0,0,792,794,5, + 47,0,0,793,783,1,0,0,0,793,785,1,0,0,0,793,787,1,0,0,0,793,789,1,0,0,0, + 793,791,1,0,0,0,794,797,1,0,0,0,795,793,1,0,0,0,795,796,1,0,0,0,796,69, + 1,0,0,0,797,795,1,0,0,0,798,799,5,48,0,0,799,800,5,36,0,0,800,801,5,30, + 0,0,801,802,3,300,150,0,802,803,5,31,0,0,803,71,1,0,0,0,804,805,5,49,0, + 0,805,806,3,2,1,0,806,807,6,36,-1,0,807,73,1,0,0,0,808,814,5,50,0,0,809, + 810,3,76,38,0,810,811,6,37,-1,0,811,813,1,0,0,0,812,809,1,0,0,0,813,816, + 1,0,0,0,814,812,1,0,0,0,814,815,1,0,0,0,815,817,1,0,0,0,816,814,1,0,0, + 0,817,818,3,2,1,0,818,819,3,182,91,0,819,820,3,78,39,0,820,821,3,80,40, + 0,821,822,6,37,-1,0,822,75,1,0,0,0,823,824,5,51,0,0,824,888,6,38,-1,0, + 825,826,5,52,0,0,826,888,6,38,-1,0,827,828,5,199,0,0,828,888,6,38,-1,0, + 829,830,5,202,0,0,830,888,6,38,-1,0,831,832,5,221,0,0,832,888,6,38,-1, + 0,833,834,5,53,0,0,834,888,6,38,-1,0,835,836,5,54,0,0,836,888,6,38,-1, + 0,837,838,5,55,0,0,838,888,6,38,-1,0,839,840,5,56,0,0,840,888,6,38,-1, + 0,841,842,5,244,0,0,842,888,6,38,-1,0,843,844,5,15,0,0,844,888,6,38,-1, + 0,845,846,5,224,0,0,846,888,6,38,-1,0,847,848,5,57,0,0,848,888,6,38,-1, + 0,849,850,5,58,0,0,850,888,6,38,-1,0,851,852,5,59,0,0,852,888,6,38,-1, + 0,853,854,5,60,0,0,854,888,6,38,-1,0,855,856,5,61,0,0,856,888,6,38,-1, + 0,857,858,5,62,0,0,858,859,5,51,0,0,859,888,6,38,-1,0,860,861,5,62,0,0, + 861,862,5,52,0,0,862,888,6,38,-1,0,863,864,5,62,0,0,864,865,5,63,0,0,865, + 888,6,38,-1,0,866,867,5,62,0,0,867,868,5,64,0,0,868,888,6,38,-1,0,869, + 870,5,62,0,0,870,871,5,65,0,0,871,888,6,38,-1,0,872,873,5,62,0,0,873,874, + 5,66,0,0,874,888,6,38,-1,0,875,876,5,67,0,0,876,888,6,38,-1,0,877,878, + 5,68,0,0,878,888,6,38,-1,0,879,880,5,69,0,0,880,888,6,38,-1,0,881,882, + 5,70,0,0,882,883,5,30,0,0,883,884,3,32,16,0,884,885,5,31,0,0,885,886,6, + 38,-1,0,886,888,1,0,0,0,887,823,1,0,0,0,887,825,1,0,0,0,887,827,1,0,0, + 0,887,829,1,0,0,0,887,831,1,0,0,0,887,833,1,0,0,0,887,835,1,0,0,0,887, + 837,1,0,0,0,887,839,1,0,0,0,887,841,1,0,0,0,887,843,1,0,0,0,887,845,1, + 0,0,0,887,847,1,0,0,0,887,849,1,0,0,0,887,851,1,0,0,0,887,853,1,0,0,0, + 887,855,1,0,0,0,887,857,1,0,0,0,887,860,1,0,0,0,887,863,1,0,0,0,887,866, + 1,0,0,0,887,869,1,0,0,0,887,872,1,0,0,0,887,875,1,0,0,0,887,877,1,0,0, + 0,887,879,1,0,0,0,887,881,1,0,0,0,888,77,1,0,0,0,889,895,1,0,0,0,890,891, + 5,71,0,0,891,892,3,124,62,0,892,893,6,39,-1,0,893,895,1,0,0,0,894,889, + 1,0,0,0,894,890,1,0,0,0,895,79,1,0,0,0,896,902,1,0,0,0,897,898,5,72,0, + 0,898,899,3,84,42,0,899,900,6,40,-1,0,900,902,1,0,0,0,901,896,1,0,0,0, + 901,897,1,0,0,0,902,81,1,0,0,0,903,905,3,198,99,0,904,903,1,0,0,0,905, + 908,1,0,0,0,906,904,1,0,0,0,906,907,1,0,0,0,907,83,1,0,0,0,908,906,1,0, + 0,0,909,910,3,124,62,0,910,911,6,42,-1,0,911,912,5,28,0,0,912,914,1,0, + 0,0,913,909,1,0,0,0,914,917,1,0,0,0,915,913,1,0,0,0,915,916,1,0,0,0,916, + 918,1,0,0,0,917,915,1,0,0,0,918,919,3,124,62,0,919,920,6,42,-1,0,920,85, + 1,0,0,0,921,922,7,5,0,0,922,87,1,0,0,0,923,924,3,86,43,0,924,925,3,32, + 16,0,925,926,5,264,0,0,926,1027,1,0,0,0,927,928,3,86,43,0,928,929,3,32, + 16,0,929,1027,1,0,0,0,930,931,3,86,43,0,931,932,3,32,16,0,932,933,5,75, + 0,0,933,934,3,32,16,0,934,935,5,264,0,0,935,1027,1,0,0,0,936,937,3,86, + 43,0,937,938,3,32,16,0,938,939,5,75,0,0,939,940,3,32,16,0,940,1027,1,0, + 0,0,941,942,3,86,43,0,942,943,3,32,16,0,943,944,5,75,0,0,944,945,3,32, + 16,0,945,946,5,28,0,0,946,947,3,32,16,0,947,948,5,264,0,0,948,1027,1,0, + 0,0,949,950,3,86,43,0,950,951,3,32,16,0,951,952,5,75,0,0,952,953,3,32, + 16,0,953,954,5,28,0,0,954,955,3,32,16,0,955,1027,1,0,0,0,956,957,3,86, + 43,0,957,958,3,32,16,0,958,959,5,28,0,0,959,960,3,32,16,0,960,961,5,75, + 0,0,961,962,3,32,16,0,962,963,5,264,0,0,963,1027,1,0,0,0,964,965,3,86, + 43,0,965,966,3,32,16,0,966,967,5,28,0,0,967,968,3,32,16,0,968,969,5,75, + 0,0,969,970,3,32,16,0,970,1027,1,0,0,0,971,972,3,86,43,0,972,973,3,32, + 16,0,973,974,5,28,0,0,974,975,3,32,16,0,975,976,5,75,0,0,976,977,3,32, + 16,0,977,978,5,28,0,0,978,979,3,32,16,0,979,980,5,264,0,0,980,1027,1,0, + 0,0,981,982,3,86,43,0,982,983,3,32,16,0,983,984,5,28,0,0,984,985,3,32, + 16,0,985,986,5,75,0,0,986,987,3,32,16,0,987,988,5,28,0,0,988,989,3,32, + 16,0,989,1027,1,0,0,0,990,991,3,86,43,0,991,992,3,32,16,0,992,993,5,263, + 0,0,993,1027,1,0,0,0,994,995,3,86,43,0,995,996,3,32,16,0,996,997,5,75, + 0,0,997,998,3,32,16,0,998,999,5,263,0,0,999,1027,1,0,0,0,1000,1001,3,86, + 43,0,1001,1002,3,32,16,0,1002,1003,5,75,0,0,1003,1004,3,32,16,0,1004,1005, + 5,28,0,0,1005,1006,3,32,16,0,1006,1007,5,263,0,0,1007,1027,1,0,0,0,1008, + 1009,3,86,43,0,1009,1010,3,32,16,0,1010,1011,5,28,0,0,1011,1012,3,32,16, + 0,1012,1013,5,75,0,0,1013,1014,3,32,16,0,1014,1015,5,263,0,0,1015,1027, + 1,0,0,0,1016,1017,3,86,43,0,1017,1018,3,32,16,0,1018,1019,5,28,0,0,1019, + 1020,3,32,16,0,1020,1021,5,75,0,0,1021,1022,3,32,16,0,1022,1023,5,28,0, + 0,1023,1024,3,32,16,0,1024,1025,5,263,0,0,1025,1027,1,0,0,0,1026,923,1, + 0,0,0,1026,927,1,0,0,0,1026,930,1,0,0,0,1026,936,1,0,0,0,1026,941,1,0, + 0,0,1026,949,1,0,0,0,1026,956,1,0,0,0,1026,964,1,0,0,0,1026,971,1,0,0, + 0,1026,981,1,0,0,0,1026,990,1,0,0,0,1026,994,1,0,0,0,1026,1000,1,0,0,0, + 1026,1008,1,0,0,0,1026,1016,1,0,0,0,1027,89,1,0,0,0,1028,1032,5,21,0,0, + 1029,1031,3,92,46,0,1030,1029,1,0,0,0,1031,1034,1,0,0,0,1032,1030,1,0, + 0,0,1032,1033,1,0,0,0,1033,1035,1,0,0,0,1034,1032,1,0,0,0,1035,1036,3, + 2,1,0,1036,1037,3,94,47,0,1037,1038,5,180,0,0,1038,1039,5,36,0,0,1039, + 1040,5,30,0,0,1040,1041,3,300,150,0,1041,1042,5,31,0,0,1042,1043,3,94, + 47,0,1043,1055,1,0,0,0,1044,1048,5,21,0,0,1045,1047,3,92,46,0,1046,1045, + 1,0,0,0,1047,1050,1,0,0,0,1048,1046,1,0,0,0,1048,1049,1,0,0,0,1049,1051, + 1,0,0,0,1050,1048,1,0,0,0,1051,1052,3,2,1,0,1052,1053,3,94,47,0,1053,1055, + 1,0,0,0,1054,1028,1,0,0,0,1054,1044,1,0,0,0,1055,91,1,0,0,0,1056,1057, + 5,76,0,0,1057,93,1,0,0,0,1058,1061,1,0,0,0,1059,1061,5,298,0,0,1060,1058, + 1,0,0,0,1060,1059,1,0,0,0,1061,95,1,0,0,0,1062,1063,7,6,0,0,1063,97,1, + 0,0,0,1064,1066,3,96,48,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,99,1,0,0,0,1069,1067,1,0,0,0,1070,1096, + 3,102,51,0,1071,1072,5,280,0,0,1072,1073,3,168,84,0,1073,1074,6,50,-1, + 0,1074,1096,1,0,0,0,1075,1076,5,286,0,0,1076,1077,3,178,89,0,1077,1078, + 6,50,-1,0,1078,1096,1,0,0,0,1079,1080,5,286,0,0,1080,1081,3,174,87,0,1081, + 1082,6,50,-1,0,1082,1096,1,0,0,0,1083,1084,5,284,0,0,1084,1085,3,124,62, + 0,1085,1086,6,50,-1,0,1086,1096,1,0,0,0,1087,1088,5,281,0,0,1088,1089, + 3,104,52,0,1089,1090,6,50,-1,0,1090,1096,1,0,0,0,1091,1092,5,287,0,0,1092, + 1093,3,50,25,0,1093,1094,6,50,-1,0,1094,1096,1,0,0,0,1095,1070,1,0,0,0, + 1095,1071,1,0,0,0,1095,1075,1,0,0,0,1095,1079,1,0,0,0,1095,1083,1,0,0, + 0,1095,1087,1,0,0,0,1095,1091,1,0,0,0,1096,101,1,0,0,0,1097,1098,5,275, + 0,0,1098,1176,6,51,-1,0,1099,1100,5,276,0,0,1100,1101,3,32,16,0,1101,1102, + 6,51,-1,0,1102,1176,1,0,0,0,1103,1104,5,276,0,0,1104,1105,3,0,0,0,1105, + 1106,6,51,-1,0,1106,1176,1,0,0,0,1107,1108,5,277,0,0,1108,1109,3,32,16, + 0,1109,1110,6,51,-1,0,1110,1176,1,0,0,0,1111,1112,5,278,0,0,1112,1113, + 3,34,17,0,1113,1114,6,51,-1,0,1114,1176,1,0,0,0,1115,1116,5,279,0,0,1116, + 1117,3,36,18,0,1117,1118,6,51,-1,0,1118,1176,1,0,0,0,1119,1120,5,279,0, + 0,1120,1121,3,34,17,0,1121,1122,6,51,-1,0,1122,1176,1,0,0,0,1123,1124, + 5,279,0,0,1124,1125,5,30,0,0,1125,1126,3,300,150,0,1126,1127,5,31,0,0, + 1127,1128,6,51,-1,0,1128,1176,1,0,0,0,1129,1130,5,279,0,0,1130,1131,5, + 84,0,0,1131,1132,5,30,0,0,1132,1133,3,300,150,0,1133,1134,5,31,0,0,1134, + 1135,6,51,-1,0,1135,1176,1,0,0,0,1136,1137,5,282,0,0,1137,1138,3,32,16, + 0,1138,1139,6,51,-1,0,1139,1176,1,0,0,0,1140,1141,5,282,0,0,1141,1142, + 3,0,0,0,1142,1143,6,51,-1,0,1143,1176,1,0,0,0,1144,1145,5,285,0,0,1145, + 1146,3,6,3,0,1146,1147,6,51,-1,0,1147,1176,1,0,0,0,1148,1149,5,285,0,0, + 1149,1150,5,224,0,0,1150,1151,5,30,0,0,1151,1152,3,6,3,0,1152,1153,5,31, + 0,0,1153,1154,6,51,-1,0,1154,1176,1,0,0,0,1155,1156,5,285,0,0,1156,1157, + 5,84,0,0,1157,1158,5,30,0,0,1158,1159,3,300,150,0,1159,1160,5,31,0,0,1160, + 1161,6,51,-1,0,1161,1176,1,0,0,0,1162,1163,5,287,0,0,1163,1164,3,32,16, + 0,1164,1165,6,51,-1,0,1165,1176,1,0,0,0,1166,1167,5,283,0,0,1167,1173, + 6,51,-1,0,1168,1169,5,30,0,0,1169,1170,3,106,53,0,1170,1171,5,31,0,0,1171, + 1174,1,0,0,0,1172,1174,5,85,0,0,1173,1168,1,0,0,0,1173,1172,1,0,0,0,1174, + 1176,1,0,0,0,1175,1097,1,0,0,0,1175,1099,1,0,0,0,1175,1103,1,0,0,0,1175, + 1107,1,0,0,0,1175,1111,1,0,0,0,1175,1115,1,0,0,0,1175,1119,1,0,0,0,1175, + 1123,1,0,0,0,1175,1129,1,0,0,0,1175,1136,1,0,0,0,1175,1140,1,0,0,0,1175, + 1144,1,0,0,0,1175,1148,1,0,0,0,1175,1155,1,0,0,0,1175,1162,1,0,0,0,1175, + 1166,1,0,0,0,1176,103,1,0,0,0,1177,1178,3,170,85,0,1178,1179,3,138,69, + 0,1179,1180,3,112,56,0,1180,1181,6,52,-1,0,1181,105,1,0,0,0,1182,1207, + 1,0,0,0,1183,1184,3,0,0,0,1184,1185,6,53,-1,0,1185,1190,1,0,0,0,1186,1187, + 3,32,16,0,1187,1188,6,53,-1,0,1188,1190,1,0,0,0,1189,1183,1,0,0,0,1189, + 1186,1,0,0,0,1190,1191,1,0,0,0,1191,1192,5,28,0,0,1192,1194,1,0,0,0,1193, + 1189,1,0,0,0,1194,1197,1,0,0,0,1195,1193,1,0,0,0,1195,1196,1,0,0,0,1196, + 1204,1,0,0,0,1197,1195,1,0,0,0,1198,1199,3,0,0,0,1199,1200,6,53,-1,0,1200, + 1205,1,0,0,0,1201,1202,3,32,16,0,1202,1203,6,53,-1,0,1203,1205,1,0,0,0, + 1204,1198,1,0,0,0,1204,1201,1,0,0,0,1205,1207,1,0,0,0,1206,1182,1,0,0, + 0,1206,1195,1,0,0,0,1207,107,1,0,0,0,1208,1215,5,86,0,0,1209,1210,3,138, + 69,0,1210,1211,6,54,-1,0,1211,1212,5,28,0,0,1212,1214,1,0,0,0,1213,1209, + 1,0,0,0,1214,1217,1,0,0,0,1215,1213,1,0,0,0,1215,1216,1,0,0,0,1216,1218, + 1,0,0,0,1217,1215,1,0,0,0,1218,1219,3,138,69,0,1219,1220,6,54,-1,0,1220, + 1221,5,87,0,0,1221,109,1,0,0,0,1222,1229,5,42,0,0,1223,1224,3,146,73,0, + 1224,1225,6,55,-1,0,1225,1226,5,28,0,0,1226,1228,1,0,0,0,1227,1223,1,0, + 0,0,1228,1231,1,0,0,0,1229,1227,1,0,0,0,1229,1230,1,0,0,0,1230,1232,1, + 0,0,0,1231,1229,1,0,0,0,1232,1233,3,146,73,0,1233,1234,6,55,-1,0,1234, + 1235,5,43,0,0,1235,111,1,0,0,0,1236,1243,5,30,0,0,1237,1238,3,114,57,0, + 1238,1239,6,56,-1,0,1239,1240,5,28,0,0,1240,1242,1,0,0,0,1241,1237,1,0, + 0,0,1242,1245,1,0,0,0,1243,1241,1,0,0,0,1243,1244,1,0,0,0,1244,1246,1, + 0,0,0,1245,1243,1,0,0,0,1246,1247,3,114,57,0,1247,1248,6,56,-1,0,1248, + 1249,5,31,0,0,1249,1252,1,0,0,0,1250,1252,5,85,0,0,1251,1236,1,0,0,0,1251, + 1250,1,0,0,0,1252,113,1,0,0,0,1253,1254,5,177,0,0,1254,1264,6,57,-1,0, + 1255,1256,3,230,115,0,1256,1257,3,138,69,0,1257,1259,3,226,113,0,1258, + 1260,3,0,0,0,1259,1258,1,0,0,0,1259,1260,1,0,0,0,1260,1261,1,0,0,0,1261, + 1262,6,57,-1,0,1262,1264,1,0,0,0,1263,1253,1,0,0,0,1263,1255,1,0,0,0,1264, + 115,1,0,0,0,1265,1266,5,42,0,0,1266,1267,3,2,1,0,1267,1268,5,43,0,0,1268, + 1269,3,118,59,0,1269,1270,6,58,-1,0,1270,1303,1,0,0,0,1271,1272,5,42,0, + 0,1272,1273,3,174,87,0,1273,1274,5,43,0,0,1274,1275,3,118,59,0,1275,1276, + 6,58,-1,0,1276,1303,1,0,0,0,1277,1278,5,42,0,0,1278,1279,5,262,0,0,1279, + 1280,5,43,0,0,1280,1281,3,118,59,0,1281,1282,6,58,-1,0,1282,1303,1,0,0, + 0,1283,1284,5,42,0,0,1284,1285,5,198,0,0,1285,1286,3,2,1,0,1286,1287,5, + 43,0,0,1287,1288,3,118,59,0,1288,1289,6,58,-1,0,1289,1303,1,0,0,0,1290, + 1291,3,118,59,0,1291,1292,6,58,-1,0,1292,1303,1,0,0,0,1293,1294,3,174, + 87,0,1294,1295,6,58,-1,0,1295,1303,1,0,0,0,1296,1297,5,257,0,0,1297,1303, + 6,58,-1,0,1298,1299,5,258,0,0,1299,1303,6,58,-1,0,1300,1301,5,259,0,0, + 1301,1303,6,58,-1,0,1302,1265,1,0,0,0,1302,1271,1,0,0,0,1302,1277,1,0, + 0,0,1302,1283,1,0,0,0,1302,1290,1,0,0,0,1302,1293,1,0,0,0,1302,1296,1, + 0,0,0,1302,1298,1,0,0,0,1302,1300,1,0,0,0,1303,117,1,0,0,0,1304,1305,3, + 2,1,0,1305,1306,6,59,-1,0,1306,1307,5,88,0,0,1307,1309,1,0,0,0,1308,1304, + 1,0,0,0,1309,1312,1,0,0,0,1310,1308,1,0,0,0,1310,1311,1,0,0,0,1311,1313, + 1,0,0,0,1312,1310,1,0,0,0,1313,1314,3,2,1,0,1314,1315,6,59,-1,0,1315,119, + 1,0,0,0,1316,1318,3,122,61,0,1317,1316,1,0,0,0,1318,1321,1,0,0,0,1319, + 1317,1,0,0,0,1319,1320,1,0,0,0,1320,121,1,0,0,0,1321,1319,1,0,0,0,1322, + 1323,5,180,0,0,1323,1324,5,89,0,0,1324,1328,3,32,16,0,1325,1328,3,152, + 76,0,1326,1328,3,332,166,0,1327,1322,1,0,0,0,1327,1325,1,0,0,0,1327,1326, + 1,0,0,0,1328,123,1,0,0,0,1329,1330,3,116,58,0,1330,1331,6,62,-1,0,1331, + 1347,1,0,0,0,1332,1333,5,42,0,0,1333,1334,3,2,1,0,1334,1335,5,43,0,0,1335, + 1336,6,62,-1,0,1336,1347,1,0,0,0,1337,1338,5,42,0,0,1338,1339,5,198,0, + 0,1339,1340,3,2,1,0,1340,1341,5,43,0,0,1341,1342,6,62,-1,0,1342,1347,1, + 0,0,0,1343,1344,3,138,69,0,1344,1345,6,62,-1,0,1345,1347,1,0,0,0,1346, + 1329,1,0,0,0,1346,1332,1,0,0,0,1346,1337,1,0,0,0,1346,1343,1,0,0,0,1347, + 125,1,0,0,0,1348,1360,1,0,0,0,1349,1350,3,130,65,0,1350,1356,6,63,-1,0, + 1351,1352,3,128,64,0,1352,1353,6,63,-1,0,1353,1355,1,0,0,0,1354,1351,1, + 0,0,0,1355,1358,1,0,0,0,1356,1354,1,0,0,0,1356,1357,1,0,0,0,1357,1360, + 1,0,0,0,1358,1356,1,0,0,0,1359,1348,1,0,0,0,1359,1349,1,0,0,0,1360,127, + 1,0,0,0,1361,1362,5,262,0,0,1362,1384,6,64,-1,0,1363,1364,5,261,0,0,1364, + 1384,6,64,-1,0,1365,1366,5,42,0,0,1366,1367,3,32,16,0,1367,1368,5,43,0, + 0,1368,1369,6,64,-1,0,1369,1384,1,0,0,0,1370,1371,5,42,0,0,1371,1372,3, + 32,16,0,1372,1373,5,266,0,0,1373,1374,3,32,16,0,1374,1375,5,43,0,0,1375, + 1376,6,64,-1,0,1376,1384,1,0,0,0,1377,1378,5,42,0,0,1378,1379,5,266,0, + 0,1379,1380,3,32,16,0,1380,1381,5,43,0,0,1381,1382,6,64,-1,0,1382,1384, + 1,0,0,0,1383,1361,1,0,0,0,1383,1363,1,0,0,0,1383,1365,1,0,0,0,1383,1370, + 1,0,0,0,1383,1377,1,0,0,0,1384,129,1,0,0,0,1385,1531,6,65,-1,0,1386,1387, + 5,203,0,0,1387,1388,5,30,0,0,1388,1389,3,6,3,0,1389,1390,5,28,0,0,1390, + 1391,3,6,3,0,1391,1392,5,28,0,0,1392,1393,3,6,3,0,1393,1394,5,28,0,0,1394, + 1395,3,6,3,0,1395,1396,5,31,0,0,1396,1397,6,65,-1,0,1397,1531,1,0,0,0, + 1398,1399,5,203,0,0,1399,1400,5,30,0,0,1400,1401,3,6,3,0,1401,1402,5,28, + 0,0,1402,1403,3,6,3,0,1403,1404,5,31,0,0,1404,1405,6,65,-1,0,1405,1531, + 1,0,0,0,1406,1407,5,204,0,0,1407,1408,5,205,0,0,1408,1409,5,42,0,0,1409, + 1410,3,32,16,0,1410,1411,5,43,0,0,1411,1412,6,65,-1,0,1412,1531,1,0,0, + 0,1413,1414,5,204,0,0,1414,1415,5,206,0,0,1415,1416,5,42,0,0,1416,1417, + 3,32,16,0,1417,1418,5,43,0,0,1418,1419,3,126,63,0,1419,1420,6,65,-1,0, + 1420,1531,1,0,0,0,1421,1422,5,207,0,0,1422,1531,6,65,-1,0,1423,1424,5, + 208,0,0,1424,1531,6,65,-1,0,1425,1426,5,209,0,0,1426,1531,6,65,-1,0,1427, + 1428,5,201,0,0,1428,1531,6,65,-1,0,1429,1430,5,183,0,0,1430,1531,6,65, + -1,0,1431,1432,5,184,0,0,1432,1531,6,65,-1,0,1433,1434,5,185,0,0,1434, + 1531,6,65,-1,0,1435,1436,5,186,0,0,1436,1531,6,65,-1,0,1437,1438,5,187, + 0,0,1438,1531,6,65,-1,0,1439,1440,5,188,0,0,1440,1531,6,65,-1,0,1441,1442, + 5,189,0,0,1442,1531,6,65,-1,0,1443,1444,5,210,0,0,1444,1531,6,65,-1,0, + 1445,1446,5,190,0,0,1446,1531,6,65,-1,0,1447,1448,5,191,0,0,1448,1531, + 6,65,-1,0,1449,1450,5,192,0,0,1450,1531,6,65,-1,0,1451,1452,5,193,0,0, + 1452,1531,6,65,-1,0,1453,1454,5,211,0,0,1454,1531,6,65,-1,0,1455,1456, + 5,212,0,0,1456,1531,6,65,-1,0,1457,1458,5,213,0,0,1458,1531,6,65,-1,0, + 1459,1460,5,214,0,0,1460,1531,6,65,-1,0,1461,1462,5,215,0,0,1462,1531, + 6,65,-1,0,1463,1464,5,216,0,0,1464,1531,6,65,-1,0,1465,1466,5,217,0,0, + 1466,1531,6,65,-1,0,1467,1468,5,218,0,0,1468,1469,3,132,66,0,1469,1470, + 6,65,-1,0,1470,1531,1,0,0,0,1471,1472,5,219,0,0,1472,1473,3,132,66,0,1473, + 1474,6,65,-1,0,1474,1531,1,0,0,0,1475,1476,5,220,0,0,1476,1531,6,65,-1, + 0,1477,1478,5,221,0,0,1478,1479,3,132,66,0,1479,1480,6,65,-1,0,1480,1531, + 1,0,0,0,1481,1482,5,222,0,0,1482,1483,3,134,67,0,1483,1484,6,65,-1,0,1484, + 1531,1,0,0,0,1485,1486,5,222,0,0,1486,1487,3,134,67,0,1487,1488,5,28,0, + 0,1488,1489,3,6,3,0,1489,1490,6,65,-1,0,1490,1531,1,0,0,0,1491,1492,5, + 194,0,0,1492,1531,6,65,-1,0,1493,1494,5,195,0,0,1494,1531,6,65,-1,0,1495, + 1496,5,90,0,0,1496,1497,5,184,0,0,1497,1531,6,65,-1,0,1498,1499,5,90,0, + 0,1499,1500,5,185,0,0,1500,1531,6,65,-1,0,1501,1502,5,90,0,0,1502,1503, + 5,186,0,0,1503,1531,6,65,-1,0,1504,1505,5,90,0,0,1505,1506,5,187,0,0,1506, + 1531,6,65,-1,0,1507,1508,5,62,0,0,1508,1509,5,220,0,0,1509,1531,6,65,-1, + 0,1510,1511,5,223,0,0,1511,1531,6,65,-1,0,1512,1513,5,224,0,0,1513,1514, + 5,213,0,0,1514,1531,6,65,-1,0,1515,1516,5,225,0,0,1516,1531,6,65,-1,0, + 1517,1518,5,207,0,0,1518,1519,5,183,0,0,1519,1531,6,65,-1,0,1520,1521, + 5,226,0,0,1521,1531,6,65,-1,0,1522,1523,5,228,0,0,1523,1531,6,65,-1,0, + 1524,1525,5,34,0,0,1525,1526,5,227,0,0,1526,1531,6,65,-1,0,1527,1528,3, + 2,1,0,1528,1529,6,65,-1,0,1529,1531,1,0,0,0,1530,1385,1,0,0,0,1530,1386, + 1,0,0,0,1530,1398,1,0,0,0,1530,1406,1,0,0,0,1530,1413,1,0,0,0,1530,1421, + 1,0,0,0,1530,1423,1,0,0,0,1530,1425,1,0,0,0,1530,1427,1,0,0,0,1530,1429, + 1,0,0,0,1530,1431,1,0,0,0,1530,1433,1,0,0,0,1530,1435,1,0,0,0,1530,1437, + 1,0,0,0,1530,1439,1,0,0,0,1530,1441,1,0,0,0,1530,1443,1,0,0,0,1530,1445, + 1,0,0,0,1530,1447,1,0,0,0,1530,1449,1,0,0,0,1530,1451,1,0,0,0,1530,1453, + 1,0,0,0,1530,1455,1,0,0,0,1530,1457,1,0,0,0,1530,1459,1,0,0,0,1530,1461, + 1,0,0,0,1530,1463,1,0,0,0,1530,1465,1,0,0,0,1530,1467,1,0,0,0,1530,1471, + 1,0,0,0,1530,1475,1,0,0,0,1530,1477,1,0,0,0,1530,1481,1,0,0,0,1530,1485, + 1,0,0,0,1530,1491,1,0,0,0,1530,1493,1,0,0,0,1530,1495,1,0,0,0,1530,1498, + 1,0,0,0,1530,1501,1,0,0,0,1530,1504,1,0,0,0,1530,1507,1,0,0,0,1530,1510, + 1,0,0,0,1530,1512,1,0,0,0,1530,1515,1,0,0,0,1530,1517,1,0,0,0,1530,1520, + 1,0,0,0,1530,1522,1,0,0,0,1530,1524,1,0,0,0,1530,1527,1,0,0,0,1531,131, + 1,0,0,0,1532,1541,1,0,0,0,1533,1534,5,30,0,0,1534,1535,5,91,0,0,1535,1536, + 5,36,0,0,1536,1537,3,32,16,0,1537,1538,5,31,0,0,1538,1539,6,66,-1,0,1539, + 1541,1,0,0,0,1540,1532,1,0,0,0,1540,1533,1,0,0,0,1541,133,1,0,0,0,1542, + 1553,1,0,0,0,1543,1544,3,136,68,0,1544,1549,6,67,-1,0,1545,1546,7,7,0, + 0,1546,1548,6,67,-1,0,1547,1545,1,0,0,0,1548,1551,1,0,0,0,1549,1547,1, + 0,0,0,1549,1550,1,0,0,0,1550,1553,1,0,0,0,1551,1549,1,0,0,0,1552,1542, + 1,0,0,0,1552,1543,1,0,0,0,1553,135,1,0,0,0,1554,1555,5,178,0,0,1555,1635, + 6,68,-1,0,1556,1557,5,207,0,0,1557,1635,6,68,-1,0,1558,1559,5,208,0,0, + 1559,1635,6,68,-1,0,1560,1561,5,201,0,0,1561,1635,6,68,-1,0,1562,1563, + 5,183,0,0,1563,1635,6,68,-1,0,1564,1565,5,184,0,0,1565,1635,6,68,-1,0, + 1566,1567,5,185,0,0,1567,1635,6,68,-1,0,1568,1569,5,186,0,0,1569,1635, + 6,68,-1,0,1570,1571,5,187,0,0,1571,1635,6,68,-1,0,1572,1573,5,188,0,0, + 1573,1635,6,68,-1,0,1574,1575,5,189,0,0,1575,1635,6,68,-1,0,1576,1577, + 5,190,0,0,1577,1635,6,68,-1,0,1578,1579,5,191,0,0,1579,1635,6,68,-1,0, + 1580,1581,5,192,0,0,1581,1635,6,68,-1,0,1582,1583,5,193,0,0,1583,1635, + 6,68,-1,0,1584,1585,5,262,0,0,1585,1635,6,68,-1,0,1586,1587,5,211,0,0, + 1587,1635,6,68,-1,0,1588,1589,5,212,0,0,1589,1635,6,68,-1,0,1590,1591, + 5,213,0,0,1591,1635,6,68,-1,0,1592,1593,5,214,0,0,1593,1635,6,68,-1,0, + 1594,1595,5,215,0,0,1595,1635,6,68,-1,0,1596,1597,5,218,0,0,1597,1635, + 6,68,-1,0,1598,1599,5,219,0,0,1599,1635,6,68,-1,0,1600,1601,5,222,0,0, + 1601,1635,6,68,-1,0,1602,1603,5,194,0,0,1603,1635,6,68,-1,0,1604,1605, + 5,195,0,0,1605,1635,6,68,-1,0,1606,1607,5,210,0,0,1607,1635,6,68,-1,0, + 1608,1609,5,230,0,0,1609,1635,6,68,-1,0,1610,1611,5,231,0,0,1611,1635, + 6,68,-1,0,1612,1613,5,232,0,0,1613,1635,6,68,-1,0,1614,1615,5,233,0,0, + 1615,1635,6,68,-1,0,1616,1617,5,234,0,0,1617,1635,6,68,-1,0,1618,1619, + 5,235,0,0,1619,1635,6,68,-1,0,1620,1621,5,236,0,0,1621,1635,6,68,-1,0, + 1622,1623,5,237,0,0,1623,1635,6,68,-1,0,1624,1625,5,238,0,0,1625,1635, + 6,68,-1,0,1626,1627,5,239,0,0,1627,1635,6,68,-1,0,1628,1629,5,240,0,0, + 1629,1635,6,68,-1,0,1630,1631,5,241,0,0,1631,1635,6,68,-1,0,1632,1633, + 5,242,0,0,1633,1635,6,68,-1,0,1634,1554,1,0,0,0,1634,1556,1,0,0,0,1634, + 1558,1,0,0,0,1634,1560,1,0,0,0,1634,1562,1,0,0,0,1634,1564,1,0,0,0,1634, + 1566,1,0,0,0,1634,1568,1,0,0,0,1634,1570,1,0,0,0,1634,1572,1,0,0,0,1634, + 1574,1,0,0,0,1634,1576,1,0,0,0,1634,1578,1,0,0,0,1634,1580,1,0,0,0,1634, + 1582,1,0,0,0,1634,1584,1,0,0,0,1634,1586,1,0,0,0,1634,1588,1,0,0,0,1634, + 1590,1,0,0,0,1634,1592,1,0,0,0,1634,1594,1,0,0,0,1634,1596,1,0,0,0,1634, + 1598,1,0,0,0,1634,1600,1,0,0,0,1634,1602,1,0,0,0,1634,1604,1,0,0,0,1634, + 1606,1,0,0,0,1634,1608,1,0,0,0,1634,1610,1,0,0,0,1634,1612,1,0,0,0,1634, + 1614,1,0,0,0,1634,1616,1,0,0,0,1634,1618,1,0,0,0,1634,1620,1,0,0,0,1634, + 1622,1,0,0,0,1634,1624,1,0,0,0,1634,1626,1,0,0,0,1634,1628,1,0,0,0,1634, + 1630,1,0,0,0,1634,1632,1,0,0,0,1635,137,1,0,0,0,1636,1637,3,142,71,0,1637, + 1643,6,69,-1,0,1638,1639,3,140,70,0,1639,1640,6,69,-1,0,1640,1642,1,0, + 0,0,1641,1638,1,0,0,0,1642,1645,1,0,0,0,1643,1641,1,0,0,0,1643,1644,1, + 0,0,0,1644,139,1,0,0,0,1645,1643,1,0,0,0,1646,1647,5,261,0,0,1647,1676, + 6,70,-1,0,1648,1649,5,42,0,0,1649,1650,5,43,0,0,1650,1676,6,70,-1,0,1651, + 1652,3,110,55,0,1652,1653,6,70,-1,0,1653,1676,1,0,0,0,1654,1655,5,260, + 0,0,1655,1676,6,70,-1,0,1656,1657,5,262,0,0,1657,1676,6,70,-1,0,1658,1659, + 5,92,0,0,1659,1676,6,70,-1,0,1660,1661,5,93,0,0,1661,1662,5,30,0,0,1662, + 1663,3,124,62,0,1663,1664,5,31,0,0,1664,1665,6,70,-1,0,1665,1676,1,0,0, + 0,1666,1667,5,94,0,0,1667,1668,5,30,0,0,1668,1669,3,124,62,0,1669,1670, + 5,31,0,0,1670,1671,6,70,-1,0,1671,1676,1,0,0,0,1672,1673,3,108,54,0,1673, + 1674,6,70,-1,0,1674,1676,1,0,0,0,1675,1646,1,0,0,0,1675,1648,1,0,0,0,1675, + 1651,1,0,0,0,1675,1654,1,0,0,0,1675,1656,1,0,0,0,1675,1658,1,0,0,0,1675, + 1660,1,0,0,0,1675,1666,1,0,0,0,1675,1672,1,0,0,0,1676,141,1,0,0,0,1677, + 1678,5,39,0,0,1678,1679,3,116,58,0,1679,1680,6,71,-1,0,1680,1736,1,0,0, + 0,1681,1682,5,197,0,0,1682,1736,6,71,-1,0,1683,1684,5,199,0,0,1684,1685, + 5,39,0,0,1685,1686,3,116,58,0,1686,1687,6,71,-1,0,1687,1736,1,0,0,0,1688, + 1689,5,200,0,0,1689,1690,3,116,58,0,1690,1691,6,71,-1,0,1691,1736,1,0, + 0,0,1692,1693,5,226,0,0,1693,1694,3,170,85,0,1694,1695,3,138,69,0,1695, + 1696,5,262,0,0,1696,1697,3,112,56,0,1697,1698,6,71,-1,0,1698,1736,1,0, + 0,0,1699,1700,5,253,0,0,1700,1701,3,32,16,0,1701,1702,6,71,-1,0,1702,1736, + 1,0,0,0,1703,1704,5,252,0,0,1704,1705,3,32,16,0,1705,1706,6,71,-1,0,1706, + 1736,1,0,0,0,1707,1708,5,253,0,0,1708,1709,3,2,1,0,1709,1710,6,71,-1,0, + 1710,1736,1,0,0,0,1711,1712,5,252,0,0,1712,1713,3,2,1,0,1713,1714,6,71, + -1,0,1714,1736,1,0,0,0,1715,1716,5,254,0,0,1716,1736,6,71,-1,0,1717,1718, + 5,201,0,0,1718,1736,6,71,-1,0,1719,1720,3,148,74,0,1720,1721,6,71,-1,0, + 1721,1736,1,0,0,0,1722,1723,3,150,75,0,1723,1724,6,71,-1,0,1724,1736,1, + 0,0,0,1725,1726,3,144,72,0,1726,1727,6,71,-1,0,1727,1736,1,0,0,0,1728, + 1729,3,2,1,0,1729,1730,6,71,-1,0,1730,1736,1,0,0,0,1731,1732,5,177,0,0, + 1732,1733,3,138,69,0,1733,1734,6,71,-1,0,1734,1736,1,0,0,0,1735,1677,1, + 0,0,0,1735,1681,1,0,0,0,1735,1683,1,0,0,0,1735,1688,1,0,0,0,1735,1692, + 1,0,0,0,1735,1699,1,0,0,0,1735,1703,1,0,0,0,1735,1707,1,0,0,0,1735,1711, + 1,0,0,0,1735,1715,1,0,0,0,1735,1717,1,0,0,0,1735,1719,1,0,0,0,1735,1722, + 1,0,0,0,1735,1725,1,0,0,0,1735,1728,1,0,0,0,1735,1731,1,0,0,0,1736,143, + 1,0,0,0,1737,1738,5,181,0,0,1738,1776,6,72,-1,0,1739,1740,5,182,0,0,1740, + 1776,6,72,-1,0,1741,1742,5,183,0,0,1742,1776,6,72,-1,0,1743,1744,5,184, + 0,0,1744,1776,6,72,-1,0,1745,1746,5,185,0,0,1746,1776,6,72,-1,0,1747,1748, + 5,186,0,0,1748,1776,6,72,-1,0,1749,1750,5,187,0,0,1750,1776,6,72,-1,0, + 1751,1752,5,188,0,0,1752,1776,6,72,-1,0,1753,1754,5,189,0,0,1754,1776, + 6,72,-1,0,1755,1756,5,190,0,0,1756,1776,6,72,-1,0,1757,1758,5,191,0,0, + 1758,1776,6,72,-1,0,1759,1760,5,192,0,0,1760,1776,6,72,-1,0,1761,1762, + 5,193,0,0,1762,1776,6,72,-1,0,1763,1764,5,90,0,0,1764,1765,5,184,0,0,1765, + 1776,6,72,-1,0,1766,1767,5,90,0,0,1767,1768,5,185,0,0,1768,1776,6,72,-1, + 0,1769,1770,5,90,0,0,1770,1771,5,186,0,0,1771,1776,6,72,-1,0,1772,1773, + 5,90,0,0,1773,1774,5,187,0,0,1774,1776,6,72,-1,0,1775,1737,1,0,0,0,1775, + 1739,1,0,0,0,1775,1741,1,0,0,0,1775,1743,1,0,0,0,1775,1745,1,0,0,0,1775, + 1747,1,0,0,0,1775,1749,1,0,0,0,1775,1751,1,0,0,0,1775,1753,1,0,0,0,1775, + 1755,1,0,0,0,1775,1757,1,0,0,0,1775,1759,1,0,0,0,1775,1761,1,0,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, + 145,1,0,0,0,1777,1792,1,0,0,0,1778,1792,5,177,0,0,1779,1780,3,32,16,0, + 1780,1781,6,73,-1,0,1781,1792,1,0,0,0,1782,1783,3,32,16,0,1783,1784,5, + 177,0,0,1784,1785,3,32,16,0,1785,1786,6,73,-1,0,1786,1792,1,0,0,0,1787, + 1788,3,32,16,0,1788,1789,5,177,0,0,1789,1790,6,73,-1,0,1790,1792,1,0,0, + 0,1791,1777,1,0,0,0,1791,1778,1,0,0,0,1791,1779,1,0,0,0,1791,1782,1,0, + 0,0,1791,1787,1,0,0,0,1792,147,1,0,0,0,1793,1794,5,1,0,0,1794,1795,5,194, + 0,0,1795,1796,6,74,-1,0,1796,149,1,0,0,0,1797,1801,5,1,0,0,1798,1799,5, + 90,0,0,1799,1802,5,194,0,0,1800,1802,5,195,0,0,1801,1798,1,0,0,0,1801, + 1800,1,0,0,0,1802,1803,1,0,0,0,1803,1804,6,75,-1,0,1804,151,1,0,0,0,1805, + 1806,5,294,0,0,1806,1807,3,166,83,0,1807,1808,3,124,62,0,1808,1809,5,30, + 0,0,1809,1810,3,158,79,0,1810,1811,5,31,0,0,1811,1853,1,0,0,0,1812,1813, + 5,294,0,0,1813,1814,3,166,83,0,1814,1815,3,124,62,0,1815,1816,5,36,0,0, + 1816,1817,5,17,0,0,1817,1818,3,52,26,0,1818,1819,5,18,0,0,1819,1853,1, + 0,0,0,1820,1821,5,294,0,0,1821,1822,3,166,83,0,1822,1823,3,124,62,0,1823, + 1853,1,0,0,0,1824,1825,5,295,0,0,1825,1826,3,166,83,0,1826,1828,5,36,0, + 0,1827,1829,5,84,0,0,1828,1827,1,0,0,0,1828,1829,1,0,0,0,1829,1830,1,0, + 0,0,1830,1831,5,30,0,0,1831,1832,3,300,150,0,1832,1833,5,31,0,0,1833,1853, + 1,0,0,0,1834,1835,5,295,0,0,1835,1836,3,166,83,0,1836,1837,5,84,0,0,1837, + 1838,5,30,0,0,1838,1839,3,300,150,0,1839,1840,5,31,0,0,1840,1853,1,0,0, + 0,1841,1842,5,295,0,0,1842,1843,3,166,83,0,1843,1844,3,6,3,0,1844,1853, + 1,0,0,0,1845,1846,5,295,0,0,1846,1847,3,166,83,0,1847,1848,5,36,0,0,1848, + 1849,5,17,0,0,1849,1850,3,154,77,0,1850,1851,5,18,0,0,1851,1853,1,0,0, + 0,1852,1805,1,0,0,0,1852,1812,1,0,0,0,1852,1820,1,0,0,0,1852,1824,1,0, + 0,0,1852,1834,1,0,0,0,1852,1841,1,0,0,0,1852,1845,1,0,0,0,1853,153,1,0, + 0,0,1854,1865,1,0,0,0,1855,1856,3,156,78,0,1856,1857,5,28,0,0,1857,1859, + 1,0,0,0,1858,1855,1,0,0,0,1859,1862,1,0,0,0,1860,1858,1,0,0,0,1860,1861, + 1,0,0,0,1861,1863,1,0,0,0,1862,1860,1,0,0,0,1863,1865,3,156,78,0,1864, + 1854,1,0,0,0,1864,1860,1,0,0,0,1865,155,1,0,0,0,1866,1867,5,39,0,0,1867, + 1868,5,264,0,0,1868,1869,5,36,0,0,1869,1870,5,17,0,0,1870,1871,3,56,28, + 0,1871,1872,5,18,0,0,1872,1880,1,0,0,0,1873,1874,3,124,62,0,1874,1875, + 5,36,0,0,1875,1876,5,17,0,0,1876,1877,3,56,28,0,1877,1878,5,18,0,0,1878, + 1880,1,0,0,0,1879,1866,1,0,0,0,1879,1873,1,0,0,0,1880,157,1,0,0,0,1881, + 1882,3,160,80,0,1882,1883,5,28,0,0,1883,1885,1,0,0,0,1884,1881,1,0,0,0, + 1885,1888,1,0,0,0,1886,1884,1,0,0,0,1886,1887,1,0,0,0,1887,1889,1,0,0, + 0,1888,1886,1,0,0,0,1889,1890,3,160,80,0,1890,159,1,0,0,0,1891,1892,3, + 6,3,0,1892,1893,5,36,0,0,1893,1894,3,164,82,0,1894,161,1,0,0,0,1895,1896, + 7,8,0,0,1896,163,1,0,0,0,1897,1932,3,162,81,0,1898,1932,3,32,16,0,1899, + 1900,5,186,0,0,1900,1901,5,30,0,0,1901,1902,3,32,16,0,1902,1903,5,31,0, + 0,1903,1932,1,0,0,0,1904,1932,3,6,3,0,1905,1906,3,116,58,0,1906,1907,5, + 30,0,0,1907,1908,5,184,0,0,1908,1909,5,75,0,0,1909,1910,3,32,16,0,1910, + 1911,5,31,0,0,1911,1932,1,0,0,0,1912,1913,3,116,58,0,1913,1914,5,30,0, + 0,1914,1915,5,185,0,0,1915,1916,5,75,0,0,1916,1917,3,32,16,0,1917,1918, + 5,31,0,0,1918,1932,1,0,0,0,1919,1920,3,116,58,0,1920,1921,5,30,0,0,1921, + 1922,5,186,0,0,1922,1923,5,75,0,0,1923,1924,3,32,16,0,1924,1925,5,31,0, + 0,1925,1932,1,0,0,0,1926,1927,3,116,58,0,1927,1928,5,30,0,0,1928,1929, + 3,32,16,0,1929,1930,5,31,0,0,1930,1932,1,0,0,0,1931,1897,1,0,0,0,1931, + 1898,1,0,0,0,1931,1899,1,0,0,0,1931,1904,1,0,0,0,1931,1905,1,0,0,0,1931, + 1912,1,0,0,0,1931,1919,1,0,0,0,1931,1926,1,0,0,0,1932,165,1,0,0,0,1933, + 1934,7,9,0,0,1934,167,1,0,0,0,1935,1936,3,170,85,0,1936,1937,3,138,69, + 0,1937,1938,3,124,62,0,1938,1939,5,176,0,0,1939,1941,3,242,121,0,1940, + 1942,3,108,54,0,1941,1940,1,0,0,0,1941,1942,1,0,0,0,1942,1943,1,0,0,0, + 1943,1944,3,112,56,0,1944,1945,6,84,-1,0,1945,1978,1,0,0,0,1946,1947,3, + 170,85,0,1947,1948,3,138,69,0,1948,1949,3,124,62,0,1949,1950,5,176,0,0, + 1950,1951,3,242,121,0,1951,1952,3,196,98,0,1952,1953,3,112,56,0,1953,1954, + 6,84,-1,0,1954,1978,1,0,0,0,1955,1956,3,170,85,0,1956,1957,3,138,69,0, + 1957,1959,3,242,121,0,1958,1960,3,108,54,0,1959,1958,1,0,0,0,1959,1960, + 1,0,0,0,1960,1961,1,0,0,0,1961,1962,3,112,56,0,1962,1963,6,84,-1,0,1963, + 1978,1,0,0,0,1964,1965,3,170,85,0,1965,1966,3,138,69,0,1966,1967,3,242, + 121,0,1967,1968,3,196,98,0,1968,1969,3,112,56,0,1969,1970,6,84,-1,0,1970, + 1978,1,0,0,0,1971,1972,3,174,87,0,1972,1973,6,84,-1,0,1973,1978,1,0,0, + 0,1974,1975,3,2,1,0,1975,1976,6,84,-1,0,1976,1978,1,0,0,0,1977,1935,1, + 0,0,0,1977,1946,1,0,0,0,1977,1955,1,0,0,0,1977,1964,1,0,0,0,1977,1971, + 1,0,0,0,1977,1974,1,0,0,0,1978,169,1,0,0,0,1979,1980,5,243,0,0,1980,1981, + 3,170,85,0,1981,1982,6,85,-1,0,1982,1997,1,0,0,0,1983,1984,5,244,0,0,1984, + 1985,3,170,85,0,1985,1986,6,85,-1,0,1986,1997,1,0,0,0,1987,1988,3,172, + 86,0,1988,1989,6,85,-1,0,1989,1997,1,0,0,0,1990,1991,5,112,0,0,1991,1992, + 5,30,0,0,1992,1993,3,32,16,0,1993,1994,5,31,0,0,1994,1995,6,85,-1,0,1995, + 1997,1,0,0,0,1996,1979,1,0,0,0,1996,1983,1,0,0,0,1996,1987,1,0,0,0,1996, + 1990,1,0,0,0,1997,171,1,0,0,0,1998,2018,1,0,0,0,1999,2000,5,245,0,0,2000, + 2018,6,86,-1,0,2001,2002,5,246,0,0,2002,2018,6,86,-1,0,2003,2004,5,247, + 0,0,2004,2005,5,248,0,0,2005,2018,6,86,-1,0,2006,2007,5,247,0,0,2007,2008, + 5,249,0,0,2008,2018,6,86,-1,0,2009,2010,5,247,0,0,2010,2011,5,250,0,0, + 2011,2018,6,86,-1,0,2012,2013,5,247,0,0,2013,2014,5,251,0,0,2014,2018, + 6,86,-1,0,2015,2016,5,247,0,0,2016,2018,6,86,-1,0,2017,1998,1,0,0,0,2017, + 1999,1,0,0,0,2017,2001,1,0,0,0,2017,2003,1,0,0,0,2017,2006,1,0,0,0,2017, + 2009,1,0,0,0,2017,2012,1,0,0,0,2017,2015,1,0,0,0,2018,173,1,0,0,0,2019, + 2020,5,113,0,0,2020,2021,5,30,0,0,2021,2022,3,32,16,0,2022,2023,5,31,0, + 0,2023,2024,6,87,-1,0,2024,175,1,0,0,0,2025,2026,5,226,0,0,2026,2027,3, + 168,84,0,2027,2028,6,88,-1,0,2028,2037,1,0,0,0,2029,2030,5,37,0,0,2030, + 2031,3,178,89,0,2031,2032,6,88,-1,0,2032,2037,1,0,0,0,2033,2034,3,174, + 87,0,2034,2035,6,88,-1,0,2035,2037,1,0,0,0,2036,2025,1,0,0,0,2036,2029, + 1,0,0,0,2036,2033,1,0,0,0,2037,177,1,0,0,0,2038,2039,3,138,69,0,2039,2040, + 3,124,62,0,2040,2041,5,176,0,0,2041,2042,3,2,1,0,2042,2043,6,89,-1,0,2043, + 2052,1,0,0,0,2044,2045,3,138,69,0,2045,2046,3,2,1,0,2046,2047,6,89,-1, + 0,2047,2052,1,0,0,0,2048,2049,3,2,1,0,2049,2050,6,89,-1,0,2050,2052,1, + 0,0,0,2051,2038,1,0,0,0,2051,2044,1,0,0,0,2051,2048,1,0,0,0,2052,179,1, + 0,0,0,2053,2054,3,124,62,0,2054,2055,6,90,-1,0,2055,2056,5,28,0,0,2056, + 2058,1,0,0,0,2057,2053,1,0,0,0,2058,2061,1,0,0,0,2059,2057,1,0,0,0,2059, + 2060,1,0,0,0,2060,2062,1,0,0,0,2061,2059,1,0,0,0,2062,2063,3,124,62,0, + 2063,2064,6,90,-1,0,2064,181,1,0,0,0,2065,2072,1,0,0,0,2066,2067,5,86, + 0,0,2067,2068,3,190,95,0,2068,2069,5,87,0,0,2069,2070,6,91,-1,0,2070,2072, + 1,0,0,0,2071,2065,1,0,0,0,2071,2066,1,0,0,0,2072,183,1,0,0,0,2073,2074, + 5,266,0,0,2074,2092,6,92,-1,0,2075,2076,5,114,0,0,2076,2092,6,92,-1,0, + 2077,2078,5,39,0,0,2078,2092,6,92,-1,0,2079,2080,5,200,0,0,2080,2092,6, + 92,-1,0,2081,2082,5,115,0,0,2082,2092,6,92,-1,0,2083,2084,5,116,0,0,2084, + 2092,6,92,-1,0,2085,2086,5,70,0,0,2086,2087,5,30,0,0,2087,2088,3,32,16, + 0,2088,2089,5,31,0,0,2089,2090,6,92,-1,0,2090,2092,1,0,0,0,2091,2073,1, + 0,0,0,2091,2075,1,0,0,0,2091,2077,1,0,0,0,2091,2079,1,0,0,0,2091,2081, + 1,0,0,0,2091,2083,1,0,0,0,2091,2085,1,0,0,0,2092,185,1,0,0,0,2093,2094, + 3,184,92,0,2094,2095,6,93,-1,0,2095,2097,1,0,0,0,2096,2093,1,0,0,0,2097, + 2100,1,0,0,0,2098,2096,1,0,0,0,2098,2099,1,0,0,0,2099,187,1,0,0,0,2100, + 2098,1,0,0,0,2101,2103,3,186,93,0,2102,2104,3,192,96,0,2103,2102,1,0,0, + 0,2103,2104,1,0,0,0,2104,2105,1,0,0,0,2105,2106,3,2,1,0,2106,2107,6,94, + -1,0,2107,189,1,0,0,0,2108,2109,3,188,94,0,2109,2110,6,95,-1,0,2110,2111, + 5,28,0,0,2111,2113,1,0,0,0,2112,2108,1,0,0,0,2113,2116,1,0,0,0,2114,2112, + 1,0,0,0,2114,2115,1,0,0,0,2115,2117,1,0,0,0,2116,2114,1,0,0,0,2117,2118, + 3,188,94,0,2118,2119,6,95,-1,0,2119,191,1,0,0,0,2120,2121,5,30,0,0,2121, + 2122,3,180,90,0,2122,2123,5,31,0,0,2123,2124,6,96,-1,0,2124,193,1,0,0, + 0,2125,2127,3,196,98,0,2126,2125,1,0,0,0,2126,2127,1,0,0,0,2127,2128,1, + 0,0,0,2128,2129,6,97,-1,0,2129,195,1,0,0,0,2130,2131,5,86,0,0,2131,2132, + 5,42,0,0,2132,2133,3,32,16,0,2133,2134,5,43,0,0,2134,2135,5,87,0,0,2135, + 2136,6,98,-1,0,2136,197,1,0,0,0,2137,2138,3,234,117,0,2138,2139,5,17,0, + 0,2139,2140,3,246,123,0,2140,2141,5,18,0,0,2141,2288,1,0,0,0,2142,2143, + 3,74,37,0,2143,2144,5,17,0,0,2144,2145,3,82,41,0,2145,2146,5,18,0,0,2146, + 2288,1,0,0,0,2147,2148,3,210,105,0,2148,2149,6,99,-1,0,2149,2150,5,17, + 0,0,2150,2151,3,214,107,0,2151,2152,5,18,0,0,2152,2288,1,0,0,0,2153,2154, + 3,218,109,0,2154,2155,6,99,-1,0,2155,2156,5,17,0,0,2156,2157,3,222,111, + 0,2157,2158,5,18,0,0,2158,2288,1,0,0,0,2159,2288,3,200,100,0,2160,2161, + 3,284,142,0,2161,2162,6,99,-1,0,2162,2288,1,0,0,0,2163,2164,3,152,76,0, + 2164,2165,6,99,-1,0,2165,2288,1,0,0,0,2166,2167,3,88,44,0,2167,2168,6, + 99,-1,0,2168,2288,1,0,0,0,2169,2170,3,330,165,0,2170,2171,6,99,-1,0,2171, + 2288,1,0,0,0,2172,2173,5,117,0,0,2173,2174,3,32,16,0,2174,2175,6,99,-1, + 0,2175,2288,1,0,0,0,2176,2177,5,118,0,0,2177,2178,3,32,16,0,2178,2179, + 6,99,-1,0,2179,2288,1,0,0,0,2180,2181,3,346,173,0,2181,2182,5,17,0,0,2182, + 2183,3,350,175,0,2183,2184,5,18,0,0,2184,2185,6,99,-1,0,2185,2288,1,0, + 0,0,2186,2187,5,302,0,0,2187,2188,3,124,62,0,2188,2189,5,176,0,0,2189, + 2190,3,242,121,0,2190,2191,5,119,0,0,2191,2192,3,170,85,0,2192,2193,3, + 138,69,0,2193,2194,3,124,62,0,2194,2195,5,176,0,0,2195,2196,3,242,121, + 0,2196,2197,3,112,56,0,2197,2198,6,99,-1,0,2198,2288,1,0,0,0,2199,2200, + 5,302,0,0,2200,2201,5,226,0,0,2201,2202,3,170,85,0,2202,2203,3,138,69, + 0,2203,2204,3,124,62,0,2204,2205,5,176,0,0,2205,2206,3,242,121,0,2206, + 2207,3,194,97,0,2207,2208,3,112,56,0,2208,2209,5,119,0,0,2209,2210,5,226, + 0,0,2210,2211,3,170,85,0,2211,2212,3,138,69,0,2212,2213,3,124,62,0,2213, + 2214,5,176,0,0,2214,2215,3,242,121,0,2215,2216,3,194,97,0,2216,2217,3, + 112,56,0,2217,2218,6,99,-1,0,2218,2288,1,0,0,0,2219,2220,3,26,13,0,2220, + 2221,6,99,-1,0,2221,2288,1,0,0,0,2222,2223,3,40,20,0,2223,2224,6,99,-1, + 0,2224,2288,1,0,0,0,2225,2226,5,255,0,0,2226,2227,5,196,0,0,2227,2228, + 5,42,0,0,2228,2229,3,32,16,0,2229,2230,5,43,0,0,2230,2236,6,99,-1,0,2231, + 2232,3,330,165,0,2232,2233,6,99,-1,0,2233,2235,1,0,0,0,2234,2231,1,0,0, + 0,2235,2238,1,0,0,0,2236,2234,1,0,0,0,2236,2237,1,0,0,0,2237,2288,1,0, + 0,0,2238,2236,1,0,0,0,2239,2240,5,255,0,0,2240,2241,5,196,0,0,2241,2242, + 3,2,1,0,2242,2248,6,99,-1,0,2243,2244,3,330,165,0,2244,2245,6,99,-1,0, + 2245,2247,1,0,0,0,2246,2243,1,0,0,0,2247,2250,1,0,0,0,2248,2246,1,0,0, + 0,2248,2249,1,0,0,0,2249,2288,1,0,0,0,2250,2248,1,0,0,0,2251,2252,5,255, + 0,0,2252,2253,5,256,0,0,2253,2254,5,42,0,0,2254,2255,3,32,16,0,2255,2256, + 5,43,0,0,2256,2257,5,28,0,0,2257,2258,3,124,62,0,2258,2264,6,99,-1,0,2259, + 2260,3,330,165,0,2260,2261,6,99,-1,0,2261,2263,1,0,0,0,2262,2259,1,0,0, + 0,2263,2266,1,0,0,0,2264,2262,1,0,0,0,2264,2265,1,0,0,0,2265,2288,1,0, + 0,0,2266,2264,1,0,0,0,2267,2268,5,255,0,0,2268,2269,5,256,0,0,2269,2270, + 3,2,1,0,2270,2271,5,28,0,0,2271,2272,3,124,62,0,2272,2278,6,99,-1,0,2273, + 2274,3,330,165,0,2274,2275,6,99,-1,0,2275,2277,1,0,0,0,2276,2273,1,0,0, + 0,2277,2280,1,0,0,0,2278,2276,1,0,0,0,2278,2279,1,0,0,0,2279,2288,1,0, + 0,0,2280,2278,1,0,0,0,2281,2282,5,120,0,0,2282,2283,5,196,0,0,2283,2284, + 3,124,62,0,2284,2285,3,44,22,0,2285,2286,6,99,-1,0,2286,2288,1,0,0,0,2287, + 2137,1,0,0,0,2287,2142,1,0,0,0,2287,2147,1,0,0,0,2287,2153,1,0,0,0,2287, + 2159,1,0,0,0,2287,2160,1,0,0,0,2287,2163,1,0,0,0,2287,2166,1,0,0,0,2287, + 2169,1,0,0,0,2287,2172,1,0,0,0,2287,2176,1,0,0,0,2287,2180,1,0,0,0,2287, + 2186,1,0,0,0,2287,2199,1,0,0,0,2287,2219,1,0,0,0,2287,2222,1,0,0,0,2287, + 2225,1,0,0,0,2287,2239,1,0,0,0,2287,2251,1,0,0,0,2287,2267,1,0,0,0,2287, + 2281,1,0,0,0,2288,199,1,0,0,0,2289,2290,5,121,0,0,2290,2302,3,208,104, + 0,2291,2292,3,202,101,0,2292,2293,6,100,-1,0,2293,2301,1,0,0,0,2294,2295, + 5,122,0,0,2295,2296,5,30,0,0,2296,2297,3,228,114,0,2297,2298,5,31,0,0, + 2298,2299,6,100,-1,0,2299,2301,1,0,0,0,2300,2291,1,0,0,0,2300,2294,1,0, + 0,0,2301,2304,1,0,0,0,2302,2300,1,0,0,0,2302,2303,1,0,0,0,2303,2305,1, + 0,0,0,2304,2302,1,0,0,0,2305,2306,3,138,69,0,2306,2307,3,2,1,0,2307,2308, + 3,204,102,0,2308,2309,3,206,103,0,2309,2310,6,100,-1,0,2310,201,1,0,0, + 0,2311,2312,5,123,0,0,2312,2346,6,101,-1,0,2313,2314,5,51,0,0,2314,2346, + 6,101,-1,0,2315,2316,5,52,0,0,2316,2346,6,101,-1,0,2317,2318,5,63,0,0, + 2318,2346,6,101,-1,0,2319,2320,5,124,0,0,2320,2346,6,101,-1,0,2321,2322, + 5,69,0,0,2322,2346,6,101,-1,0,2323,2324,5,68,0,0,2324,2346,6,101,-1,0, + 2325,2326,5,64,0,0,2326,2346,6,101,-1,0,2327,2328,5,65,0,0,2328,2346,6, + 101,-1,0,2329,2330,5,66,0,0,2330,2346,6,101,-1,0,2331,2332,5,125,0,0,2332, + 2346,6,101,-1,0,2333,2334,5,126,0,0,2334,2346,6,101,-1,0,2335,2336,5,127, + 0,0,2336,2346,6,101,-1,0,2337,2338,5,16,0,0,2338,2346,6,101,-1,0,2339, + 2340,5,70,0,0,2340,2341,5,30,0,0,2341,2342,3,32,16,0,2342,2343,5,31,0, + 0,2343,2344,6,101,-1,0,2344,2346,1,0,0,0,2345,2311,1,0,0,0,2345,2313,1, + 0,0,0,2345,2315,1,0,0,0,2345,2317,1,0,0,0,2345,2319,1,0,0,0,2345,2321, + 1,0,0,0,2345,2323,1,0,0,0,2345,2325,1,0,0,0,2345,2327,1,0,0,0,2345,2329, + 1,0,0,0,2345,2331,1,0,0,0,2345,2333,1,0,0,0,2345,2335,1,0,0,0,2345,2337, + 1,0,0,0,2345,2339,1,0,0,0,2346,203,1,0,0,0,2347,2357,1,0,0,0,2348,2349, + 5,44,0,0,2349,2350,3,0,0,0,2350,2351,6,102,-1,0,2351,2357,1,0,0,0,2352, + 2353,5,44,0,0,2353,2354,3,32,16,0,2354,2355,6,102,-1,0,2355,2357,1,0,0, + 0,2356,2347,1,0,0,0,2356,2348,1,0,0,0,2356,2352,1,0,0,0,2357,205,1,0,0, + 0,2358,2364,1,0,0,0,2359,2360,5,36,0,0,2360,2361,3,304,152,0,2361,2362, + 6,103,-1,0,2362,2364,1,0,0,0,2363,2358,1,0,0,0,2363,2359,1,0,0,0,2364, + 207,1,0,0,0,2365,2372,1,0,0,0,2366,2367,5,42,0,0,2367,2368,3,32,16,0,2368, + 2369,5,43,0,0,2369,2370,6,104,-1,0,2370,2372,1,0,0,0,2371,2365,1,0,0,0, + 2371,2366,1,0,0,0,2372,209,1,0,0,0,2373,2379,5,128,0,0,2374,2375,3,212, + 106,0,2375,2376,6,105,-1,0,2376,2378,1,0,0,0,2377,2374,1,0,0,0,2378,2381, + 1,0,0,0,2379,2377,1,0,0,0,2379,2380,1,0,0,0,2380,2382,1,0,0,0,2381,2379, + 1,0,0,0,2382,2383,3,124,62,0,2383,2384,3,2,1,0,2384,2385,6,105,-1,0,2385, + 2399,1,0,0,0,2386,2392,5,128,0,0,2387,2388,3,212,106,0,2388,2389,6,105, + -1,0,2389,2391,1,0,0,0,2390,2387,1,0,0,0,2391,2394,1,0,0,0,2392,2390,1, + 0,0,0,2392,2393,1,0,0,0,2393,2395,1,0,0,0,2394,2392,1,0,0,0,2395,2396, + 3,2,1,0,2396,2397,6,105,-1,0,2397,2399,1,0,0,0,2398,2373,1,0,0,0,2398, + 2386,1,0,0,0,2399,211,1,0,0,0,2400,2401,5,69,0,0,2401,2405,6,106,-1,0, + 2402,2403,5,68,0,0,2403,2405,6,106,-1,0,2404,2400,1,0,0,0,2404,2402,1, + 0,0,0,2405,213,1,0,0,0,2406,2408,3,216,108,0,2407,2406,1,0,0,0,2408,2411, + 1,0,0,0,2409,2407,1,0,0,0,2409,2410,1,0,0,0,2410,215,1,0,0,0,2411,2409, + 1,0,0,0,2412,2413,5,129,0,0,2413,2414,3,168,84,0,2414,2415,6,108,-1,0, + 2415,2439,1,0,0,0,2416,2417,5,130,0,0,2417,2418,3,168,84,0,2418,2419,6, + 108,-1,0,2419,2439,1,0,0,0,2420,2421,5,131,0,0,2421,2422,3,168,84,0,2422, + 2423,6,108,-1,0,2423,2439,1,0,0,0,2424,2425,5,132,0,0,2425,2426,3,168, + 84,0,2426,2427,6,108,-1,0,2427,2439,1,0,0,0,2428,2429,3,88,44,0,2429,2430, + 6,108,-1,0,2430,2439,1,0,0,0,2431,2432,3,330,165,0,2432,2433,6,108,-1, + 0,2433,2439,1,0,0,0,2434,2435,3,26,13,0,2435,2436,6,108,-1,0,2436,2439, + 1,0,0,0,2437,2439,3,40,20,0,2438,2412,1,0,0,0,2438,2416,1,0,0,0,2438,2420, + 1,0,0,0,2438,2424,1,0,0,0,2438,2428,1,0,0,0,2438,2431,1,0,0,0,2438,2434, + 1,0,0,0,2438,2437,1,0,0,0,2439,217,1,0,0,0,2440,2446,5,133,0,0,2441,2442, + 3,220,110,0,2442,2443,6,109,-1,0,2443,2445,1,0,0,0,2444,2441,1,0,0,0,2445, + 2448,1,0,0,0,2446,2444,1,0,0,0,2446,2447,1,0,0,0,2447,2449,1,0,0,0,2448, + 2446,1,0,0,0,2449,2450,3,170,85,0,2450,2451,3,138,69,0,2451,2452,3,2,1, + 0,2452,2453,3,112,56,0,2453,2454,3,206,103,0,2454,2455,6,109,-1,0,2455, + 219,1,0,0,0,2456,2457,5,69,0,0,2457,2461,6,110,-1,0,2458,2459,5,68,0,0, + 2459,2461,6,110,-1,0,2460,2456,1,0,0,0,2460,2458,1,0,0,0,2461,221,1,0, + 0,0,2462,2464,3,224,112,0,2463,2462,1,0,0,0,2464,2467,1,0,0,0,2465,2463, + 1,0,0,0,2465,2466,1,0,0,0,2466,223,1,0,0,0,2467,2465,1,0,0,0,2468,2469, + 5,134,0,0,2469,2470,3,168,84,0,2470,2471,6,112,-1,0,2471,2491,1,0,0,0, + 2472,2473,5,135,0,0,2473,2474,3,168,84,0,2474,2475,6,112,-1,0,2475,2491, + 1,0,0,0,2476,2477,5,132,0,0,2477,2478,3,168,84,0,2478,2479,6,112,-1,0, + 2479,2491,1,0,0,0,2480,2481,3,330,165,0,2481,2482,6,112,-1,0,2482,2491, + 1,0,0,0,2483,2484,3,88,44,0,2484,2485,6,112,-1,0,2485,2491,1,0,0,0,2486, + 2487,3,26,13,0,2487,2488,6,112,-1,0,2488,2491,1,0,0,0,2489,2491,3,40,20, + 0,2490,2468,1,0,0,0,2490,2472,1,0,0,0,2490,2476,1,0,0,0,2490,2480,1,0, + 0,0,2490,2483,1,0,0,0,2490,2486,1,0,0,0,2490,2489,1,0,0,0,2491,225,1,0, + 0,0,2492,2500,6,113,-1,0,2493,2494,5,122,0,0,2494,2495,5,30,0,0,2495,2496, + 3,228,114,0,2496,2497,5,31,0,0,2497,2498,6,113,-1,0,2498,2500,1,0,0,0, + 2499,2492,1,0,0,0,2499,2493,1,0,0,0,2500,227,1,0,0,0,2501,2502,3,126,63, + 0,2502,2503,6,114,-1,0,2503,2515,1,0,0,0,2504,2508,5,17,0,0,2505,2506, + 3,302,151,0,2506,2507,6,114,-1,0,2507,2509,1,0,0,0,2508,2505,1,0,0,0,2509, + 2510,1,0,0,0,2510,2508,1,0,0,0,2510,2511,1,0,0,0,2511,2512,1,0,0,0,2512, + 2513,5,18,0,0,2513,2515,1,0,0,0,2514,2501,1,0,0,0,2514,2504,1,0,0,0,2515, + 229,1,0,0,0,2516,2517,3,232,116,0,2517,2518,6,115,-1,0,2518,2520,1,0,0, + 0,2519,2516,1,0,0,0,2520,2523,1,0,0,0,2521,2519,1,0,0,0,2521,2522,1,0, + 0,0,2522,231,1,0,0,0,2523,2521,1,0,0,0,2524,2525,5,42,0,0,2525,2526,5, + 136,0,0,2526,2527,5,43,0,0,2527,2542,6,116,-1,0,2528,2529,5,42,0,0,2529, + 2530,5,137,0,0,2530,2531,5,43,0,0,2531,2542,6,116,-1,0,2532,2533,5,42, + 0,0,2533,2534,5,138,0,0,2534,2535,5,43,0,0,2535,2542,6,116,-1,0,2536,2537, + 5,42,0,0,2537,2538,3,32,16,0,2538,2539,5,43,0,0,2539,2540,6,116,-1,0,2540, + 2542,1,0,0,0,2541,2524,1,0,0,0,2541,2528,1,0,0,0,2541,2532,1,0,0,0,2541, + 2536,1,0,0,0,2542,233,1,0,0,0,2543,2552,5,139,0,0,2544,2545,3,236,118, + 0,2545,2546,6,117,-1,0,2546,2551,1,0,0,0,2547,2548,3,238,119,0,2548,2549, + 6,117,-1,0,2549,2551,1,0,0,0,2550,2544,1,0,0,0,2550,2547,1,0,0,0,2551, + 2554,1,0,0,0,2552,2550,1,0,0,0,2552,2553,1,0,0,0,2553,2555,1,0,0,0,2554, + 2552,1,0,0,0,2555,2556,3,170,85,0,2556,2557,3,230,115,0,2557,2558,3,138, + 69,0,2558,2559,3,226,113,0,2559,2560,3,242,121,0,2560,2561,3,182,91,0, + 2561,2567,3,112,56,0,2562,2563,3,244,122,0,2563,2564,6,117,-1,0,2564,2566, + 1,0,0,0,2565,2562,1,0,0,0,2566,2569,1,0,0,0,2567,2565,1,0,0,0,2567,2568, + 1,0,0,0,2568,2570,1,0,0,0,2569,2567,1,0,0,0,2570,2571,6,117,-1,0,2571, + 235,1,0,0,0,2572,2573,5,123,0,0,2573,2615,6,118,-1,0,2574,2575,5,51,0, + 0,2575,2615,6,118,-1,0,2576,2577,5,52,0,0,2577,2615,6,118,-1,0,2578,2579, + 5,63,0,0,2579,2615,6,118,-1,0,2580,2581,5,140,0,0,2581,2615,6,118,-1,0, + 2582,2583,5,68,0,0,2583,2615,6,118,-1,0,2584,2585,5,141,0,0,2585,2615, + 6,118,-1,0,2586,2587,5,142,0,0,2587,2615,6,118,-1,0,2588,2589,5,54,0,0, + 2589,2615,6,118,-1,0,2590,2591,5,64,0,0,2591,2615,6,118,-1,0,2592,2593, + 5,65,0,0,2593,2615,6,118,-1,0,2594,2595,5,66,0,0,2595,2615,6,118,-1,0, + 2596,2597,5,125,0,0,2597,2615,6,118,-1,0,2598,2599,5,143,0,0,2599,2615, + 6,118,-1,0,2600,2601,5,144,0,0,2601,2615,6,118,-1,0,2602,2603,5,69,0,0, + 2603,2615,6,118,-1,0,2604,2605,5,145,0,0,2605,2615,6,118,-1,0,2606,2607, + 5,146,0,0,2607,2615,6,118,-1,0,2608,2609,5,70,0,0,2609,2610,5,30,0,0,2610, + 2611,3,32,16,0,2611,2612,5,31,0,0,2612,2613,6,118,-1,0,2613,2615,1,0,0, + 0,2614,2572,1,0,0,0,2614,2574,1,0,0,0,2614,2576,1,0,0,0,2614,2578,1,0, + 0,0,2614,2580,1,0,0,0,2614,2582,1,0,0,0,2614,2584,1,0,0,0,2614,2586,1, + 0,0,0,2614,2588,1,0,0,0,2614,2590,1,0,0,0,2614,2592,1,0,0,0,2614,2594, + 1,0,0,0,2614,2596,1,0,0,0,2614,2598,1,0,0,0,2614,2600,1,0,0,0,2614,2602, + 1,0,0,0,2614,2604,1,0,0,0,2614,2606,1,0,0,0,2614,2608,1,0,0,0,2615,237, + 1,0,0,0,2616,2617,5,147,0,0,2617,2626,5,30,0,0,2618,2619,3,6,3,0,2619, + 2624,6,119,-1,0,2620,2621,5,34,0,0,2621,2622,3,6,3,0,2622,2623,6,119,-1, + 0,2623,2625,1,0,0,0,2624,2620,1,0,0,0,2624,2625,1,0,0,0,2625,2627,1,0, + 0,0,2626,2618,1,0,0,0,2626,2627,1,0,0,0,2627,2633,1,0,0,0,2628,2629,3, + 240,120,0,2629,2630,6,119,-1,0,2630,2632,1,0,0,0,2631,2628,1,0,0,0,2632, + 2635,1,0,0,0,2633,2631,1,0,0,0,2633,2634,1,0,0,0,2634,2636,1,0,0,0,2635, + 2633,1,0,0,0,2636,2640,5,31,0,0,2637,2638,5,147,0,0,2638,2640,5,85,0,0, + 2639,2616,1,0,0,0,2639,2637,1,0,0,0,2640,239,1,0,0,0,2641,2642,5,148,0, + 0,2642,2684,6,120,-1,0,2643,2644,5,224,0,0,2644,2684,6,120,-1,0,2645,2646, + 5,57,0,0,2646,2684,6,120,-1,0,2647,2648,5,58,0,0,2648,2684,6,120,-1,0, + 2649,2650,5,149,0,0,2650,2684,6,120,-1,0,2651,2652,5,150,0,0,2652,2684, + 6,120,-1,0,2653,2654,5,248,0,0,2654,2684,6,120,-1,0,2655,2656,5,249,0, + 0,2656,2684,6,120,-1,0,2657,2658,5,250,0,0,2658,2684,6,120,-1,0,2659,2660, + 5,251,0,0,2660,2684,6,120,-1,0,2661,2662,5,151,0,0,2662,2663,5,75,0,0, + 2663,2664,5,152,0,0,2664,2684,6,120,-1,0,2665,2666,5,151,0,0,2666,2667, + 5,75,0,0,2667,2668,5,153,0,0,2668,2684,6,120,-1,0,2669,2670,5,154,0,0, + 2670,2671,5,75,0,0,2671,2672,5,152,0,0,2672,2684,6,120,-1,0,2673,2674, + 5,154,0,0,2674,2675,5,75,0,0,2675,2676,5,153,0,0,2676,2684,6,120,-1,0, + 2677,2678,5,70,0,0,2678,2679,5,30,0,0,2679,2680,3,32,16,0,2680,2681,5, + 31,0,0,2681,2682,6,120,-1,0,2682,2684,1,0,0,0,2683,2641,1,0,0,0,2683,2643, + 1,0,0,0,2683,2645,1,0,0,0,2683,2647,1,0,0,0,2683,2649,1,0,0,0,2683,2651, + 1,0,0,0,2683,2653,1,0,0,0,2683,2655,1,0,0,0,2683,2657,1,0,0,0,2683,2659, + 1,0,0,0,2683,2661,1,0,0,0,2683,2665,1,0,0,0,2683,2669,1,0,0,0,2683,2673, + 1,0,0,0,2683,2677,1,0,0,0,2684,241,1,0,0,0,2685,2686,5,116,0,0,2686,2693, + 6,121,-1,0,2687,2688,5,155,0,0,2688,2693,6,121,-1,0,2689,2690,3,2,1,0, + 2690,2691,6,121,-1,0,2691,2693,1,0,0,0,2692,2685,1,0,0,0,2692,2687,1,0, + 0,0,2692,2689,1,0,0,0,2693,243,1,0,0,0,2694,2695,5,1,0,0,2695,2733,6,122, + -1,0,2696,2697,5,2,0,0,2697,2733,6,122,-1,0,2698,2699,5,156,0,0,2699,2733, + 6,122,-1,0,2700,2701,5,3,0,0,2701,2733,6,122,-1,0,2702,2703,5,4,0,0,2703, + 2733,6,122,-1,0,2704,2705,5,247,0,0,2705,2733,6,122,-1,0,2706,2707,5,5, + 0,0,2707,2733,6,122,-1,0,2708,2709,5,6,0,0,2709,2733,6,122,-1,0,2710,2711, + 5,7,0,0,2711,2733,6,122,-1,0,2712,2713,5,8,0,0,2713,2733,6,122,-1,0,2714, + 2715,5,9,0,0,2715,2733,6,122,-1,0,2716,2717,5,10,0,0,2717,2733,6,122,-1, + 0,2718,2719,5,11,0,0,2719,2733,6,122,-1,0,2720,2721,5,12,0,0,2721,2733, + 6,122,-1,0,2722,2723,5,13,0,0,2723,2733,6,122,-1,0,2724,2725,5,14,0,0, + 2725,2733,6,122,-1,0,2726,2727,5,70,0,0,2727,2728,5,30,0,0,2728,2729,3, + 32,16,0,2729,2730,5,31,0,0,2730,2731,6,122,-1,0,2731,2733,1,0,0,0,2732, + 2694,1,0,0,0,2732,2696,1,0,0,0,2732,2698,1,0,0,0,2732,2700,1,0,0,0,2732, + 2702,1,0,0,0,2732,2704,1,0,0,0,2732,2706,1,0,0,0,2732,2708,1,0,0,0,2732, + 2710,1,0,0,0,2732,2712,1,0,0,0,2732,2714,1,0,0,0,2732,2716,1,0,0,0,2732, + 2718,1,0,0,0,2732,2720,1,0,0,0,2732,2722,1,0,0,0,2732,2724,1,0,0,0,2732, + 2726,1,0,0,0,2733,245,1,0,0,0,2734,2736,3,248,124,0,2735,2734,1,0,0,0, + 2736,2739,1,0,0,0,2737,2735,1,0,0,0,2737,2738,1,0,0,0,2738,247,1,0,0,0, + 2739,2737,1,0,0,0,2740,2778,3,100,50,0,2741,2742,5,296,0,0,2742,2743,3, + 32,16,0,2743,2744,6,124,-1,0,2744,2778,1,0,0,0,2745,2778,3,266,133,0,2746, + 2747,5,297,0,0,2747,2748,3,32,16,0,2748,2749,6,124,-1,0,2749,2778,1,0, + 0,0,2750,2751,5,298,0,0,2751,2778,6,124,-1,0,2752,2753,5,299,0,0,2753, + 2778,6,124,-1,0,2754,2778,3,260,130,0,2755,2778,3,264,132,0,2756,2778, + 3,250,125,0,2757,2758,3,284,142,0,2758,2759,6,124,-1,0,2759,2778,1,0,0, + 0,2760,2761,3,152,76,0,2761,2762,6,124,-1,0,2762,2778,1,0,0,0,2763,2764, + 3,88,44,0,2764,2765,6,124,-1,0,2765,2778,1,0,0,0,2766,2767,3,26,13,0,2767, + 2768,6,124,-1,0,2768,2778,1,0,0,0,2769,2770,3,262,131,0,2770,2771,6,124, + -1,0,2771,2778,1,0,0,0,2772,2778,3,40,20,0,2773,2778,3,252,126,0,2774, + 2778,3,254,127,0,2775,2778,3,256,128,0,2776,2778,3,258,129,0,2777,2740, + 1,0,0,0,2777,2741,1,0,0,0,2777,2745,1,0,0,0,2777,2746,1,0,0,0,2777,2750, + 1,0,0,0,2777,2752,1,0,0,0,2777,2754,1,0,0,0,2777,2755,1,0,0,0,2777,2756, + 1,0,0,0,2777,2757,1,0,0,0,2777,2760,1,0,0,0,2777,2763,1,0,0,0,2777,2766, + 1,0,0,0,2777,2769,1,0,0,0,2777,2772,1,0,0,0,2777,2773,1,0,0,0,2777,2774, + 1,0,0,0,2777,2775,1,0,0,0,2777,2776,1,0,0,0,2778,249,1,0,0,0,2779,2781, + 5,300,0,0,2780,2782,5,157,0,0,2781,2780,1,0,0,0,2781,2782,1,0,0,0,2782, + 2783,1,0,0,0,2783,2784,3,112,56,0,2784,251,1,0,0,0,2785,2786,5,301,0,0, + 2786,2787,5,42,0,0,2787,2788,3,32,16,0,2788,2791,5,43,0,0,2789,2790,5, + 34,0,0,2790,2792,3,0,0,0,2791,2789,1,0,0,0,2791,2792,1,0,0,0,2792,253, + 1,0,0,0,2793,2794,5,303,0,0,2794,2795,3,32,16,0,2795,2796,5,75,0,0,2796, + 2797,3,32,16,0,2797,255,1,0,0,0,2798,2799,5,302,0,0,2799,2800,3,124,62, + 0,2800,2801,5,176,0,0,2801,2802,3,242,121,0,2802,2814,1,0,0,0,2803,2804, + 5,302,0,0,2804,2805,5,226,0,0,2805,2806,3,170,85,0,2806,2807,3,138,69, + 0,2807,2808,3,124,62,0,2808,2809,5,176,0,0,2809,2810,3,242,121,0,2810, + 2811,3,194,97,0,2811,2812,3,112,56,0,2812,2814,1,0,0,0,2813,2798,1,0,0, + 0,2813,2803,1,0,0,0,2814,257,1,0,0,0,2815,2816,5,255,0,0,2816,2817,5,196, + 0,0,2817,2818,5,42,0,0,2818,2819,3,32,16,0,2819,2825,5,43,0,0,2820,2821, + 3,330,165,0,2821,2822,6,129,-1,0,2822,2824,1,0,0,0,2823,2820,1,0,0,0,2824, + 2827,1,0,0,0,2825,2823,1,0,0,0,2825,2826,1,0,0,0,2826,2881,1,0,0,0,2827, + 2825,1,0,0,0,2828,2829,5,255,0,0,2829,2830,5,196,0,0,2830,2836,3,2,1,0, + 2831,2832,3,330,165,0,2832,2833,6,129,-1,0,2833,2835,1,0,0,0,2834,2831, + 1,0,0,0,2835,2838,1,0,0,0,2836,2834,1,0,0,0,2836,2837,1,0,0,0,2837,2881, + 1,0,0,0,2838,2836,1,0,0,0,2839,2840,5,255,0,0,2840,2841,5,256,0,0,2841, + 2842,5,42,0,0,2842,2843,3,32,16,0,2843,2844,5,43,0,0,2844,2845,5,28,0, + 0,2845,2851,3,124,62,0,2846,2847,3,330,165,0,2847,2848,6,129,-1,0,2848, + 2850,1,0,0,0,2849,2846,1,0,0,0,2850,2853,1,0,0,0,2851,2849,1,0,0,0,2851, + 2852,1,0,0,0,2852,2881,1,0,0,0,2853,2851,1,0,0,0,2854,2855,5,255,0,0,2855, + 2856,5,256,0,0,2856,2857,3,2,1,0,2857,2858,5,28,0,0,2858,2864,3,124,62, + 0,2859,2860,3,330,165,0,2860,2861,6,129,-1,0,2861,2863,1,0,0,0,2862,2859, + 1,0,0,0,2863,2866,1,0,0,0,2864,2862,1,0,0,0,2864,2865,1,0,0,0,2865,2881, + 1,0,0,0,2866,2864,1,0,0,0,2867,2868,5,255,0,0,2868,2869,5,42,0,0,2869, + 2870,3,32,16,0,2870,2871,5,43,0,0,2871,2877,3,206,103,0,2872,2873,3,330, + 165,0,2873,2874,6,129,-1,0,2874,2876,1,0,0,0,2875,2872,1,0,0,0,2876,2879, + 1,0,0,0,2877,2875,1,0,0,0,2877,2878,1,0,0,0,2878,2881,1,0,0,0,2879,2877, + 1,0,0,0,2880,2815,1,0,0,0,2880,2828,1,0,0,0,2880,2839,1,0,0,0,2880,2854, + 1,0,0,0,2880,2867,1,0,0,0,2881,259,1,0,0,0,2882,2883,3,0,0,0,2883,2884, + 5,75,0,0,2884,2885,6,130,-1,0,2885,261,1,0,0,0,2886,2887,3,44,22,0,2887, + 2888,6,131,-1,0,2888,2893,1,0,0,0,2889,2890,3,46,23,0,2890,2891,6,131, + -1,0,2891,2893,1,0,0,0,2892,2886,1,0,0,0,2892,2889,1,0,0,0,2893,263,1, + 0,0,0,2894,2895,5,17,0,0,2895,2896,3,246,123,0,2896,2897,5,18,0,0,2897, + 265,1,0,0,0,2898,2899,3,270,135,0,2899,2900,3,268,134,0,2900,267,1,0,0, + 0,2901,2902,3,272,136,0,2902,2903,6,134,-1,0,2903,2905,1,0,0,0,2904,2901, + 1,0,0,0,2905,2906,1,0,0,0,2906,2904,1,0,0,0,2906,2907,1,0,0,0,2907,269, + 1,0,0,0,2908,2909,5,158,0,0,2909,2910,3,264,132,0,2910,2911,6,135,-1,0, + 2911,2925,1,0,0,0,2912,2913,5,158,0,0,2913,2914,3,0,0,0,2914,2915,5,159, + 0,0,2915,2916,3,0,0,0,2916,2917,6,135,-1,0,2917,2925,1,0,0,0,2918,2919, + 5,158,0,0,2919,2920,3,32,16,0,2920,2921,5,159,0,0,2921,2922,3,32,16,0, + 2922,2923,6,135,-1,0,2923,2925,1,0,0,0,2924,2908,1,0,0,0,2924,2912,1,0, + 0,0,2924,2918,1,0,0,0,2925,271,1,0,0,0,2926,2927,3,276,138,0,2927,2928, + 3,282,141,0,2928,2929,6,136,-1,0,2929,2943,1,0,0,0,2930,2931,3,274,137, + 0,2931,2932,3,282,141,0,2932,2933,6,136,-1,0,2933,2943,1,0,0,0,2934,2935, + 3,278,139,0,2935,2936,3,282,141,0,2936,2937,6,136,-1,0,2937,2943,1,0,0, + 0,2938,2939,3,280,140,0,2939,2940,3,282,141,0,2940,2941,6,136,-1,0,2941, + 2943,1,0,0,0,2942,2926,1,0,0,0,2942,2930,1,0,0,0,2942,2934,1,0,0,0,2942, + 2938,1,0,0,0,2943,273,1,0,0,0,2944,2945,5,160,0,0,2945,2946,3,264,132, + 0,2946,2947,6,137,-1,0,2947,2957,1,0,0,0,2948,2949,5,160,0,0,2949,2950, + 3,0,0,0,2950,2951,6,137,-1,0,2951,2957,1,0,0,0,2952,2953,5,160,0,0,2953, + 2954,3,32,16,0,2954,2955,6,137,-1,0,2955,2957,1,0,0,0,2956,2944,1,0,0, + 0,2956,2948,1,0,0,0,2956,2952,1,0,0,0,2957,275,1,0,0,0,2958,2959,5,161, + 0,0,2959,2960,3,124,62,0,2960,277,1,0,0,0,2961,2962,5,162,0,0,2962,279, + 1,0,0,0,2963,2964,5,163,0,0,2964,281,1,0,0,0,2965,2966,3,264,132,0,2966, + 2967,6,141,-1,0,2967,2981,1,0,0,0,2968,2969,5,164,0,0,2969,2970,3,0,0, + 0,2970,2971,5,159,0,0,2971,2972,3,0,0,0,2972,2973,6,141,-1,0,2973,2981, + 1,0,0,0,2974,2975,5,164,0,0,2975,2976,3,32,16,0,2976,2977,5,159,0,0,2977, + 2978,3,32,16,0,2978,2979,6,141,-1,0,2979,2981,1,0,0,0,2980,2965,1,0,0, + 0,2980,2968,1,0,0,0,2980,2974,1,0,0,0,2981,283,1,0,0,0,2982,2983,3,286, + 143,0,2983,2984,3,290,145,0,2984,285,1,0,0,0,2985,2986,5,165,0,0,2986, + 2987,3,288,144,0,2987,2988,3,0,0,0,2988,2989,5,36,0,0,2989,2993,1,0,0, + 0,2990,2991,5,165,0,0,2991,2993,3,288,144,0,2992,2985,1,0,0,0,2992,2990, + 1,0,0,0,2993,287,1,0,0,0,2994,2998,1,0,0,0,2995,2998,5,166,0,0,2996,2998, + 5,2,0,0,2997,2994,1,0,0,0,2997,2995,1,0,0,0,2997,2996,1,0,0,0,2998,289, + 1,0,0,0,2999,3000,5,17,0,0,3000,3001,3,292,146,0,3001,3002,5,18,0,0,3002, + 3009,1,0,0,0,3003,3005,3,296,148,0,3004,3003,1,0,0,0,3005,3006,1,0,0,0, + 3006,3004,1,0,0,0,3006,3007,1,0,0,0,3007,3009,1,0,0,0,3008,2999,1,0,0, + 0,3008,3004,1,0,0,0,3009,291,1,0,0,0,3010,3011,3,296,148,0,3011,3012,5, + 28,0,0,3012,3014,1,0,0,0,3013,3010,1,0,0,0,3014,3017,1,0,0,0,3015,3013, + 1,0,0,0,3015,3016,1,0,0,0,3016,3018,1,0,0,0,3017,3015,1,0,0,0,3018,3019, + 3,296,148,0,3019,293,1,0,0,0,3020,3026,1,0,0,0,3021,3022,5,42,0,0,3022, + 3023,3,32,16,0,3023,3024,5,43,0,0,3024,3026,1,0,0,0,3025,3020,1,0,0,0, + 3025,3021,1,0,0,0,3026,295,1,0,0,0,3027,3028,5,181,0,0,3028,3029,5,262, + 0,0,3029,3030,5,30,0,0,3030,3031,3,6,3,0,3031,3032,5,31,0,0,3032,3094, + 1,0,0,0,3033,3034,5,260,0,0,3034,3035,5,30,0,0,3035,3036,3,0,0,0,3036, + 3037,5,31,0,0,3037,3094,1,0,0,0,3038,3039,5,260,0,0,3039,3094,3,0,0,0, + 3040,3041,5,84,0,0,3041,3042,5,30,0,0,3042,3043,3,300,150,0,3043,3044, + 5,31,0,0,3044,3094,1,0,0,0,3045,3046,5,188,0,0,3046,3047,5,30,0,0,3047, + 3048,3,36,18,0,3048,3049,5,31,0,0,3049,3050,3,294,147,0,3050,3094,1,0, + 0,0,3051,3052,5,189,0,0,3052,3053,5,30,0,0,3053,3054,3,36,18,0,3054,3055, + 5,31,0,0,3055,3056,3,294,147,0,3056,3094,1,0,0,0,3057,3058,5,187,0,0,3058, + 3059,5,30,0,0,3059,3060,3,34,17,0,3060,3061,5,31,0,0,3061,3062,3,294,147, + 0,3062,3094,1,0,0,0,3063,3064,5,186,0,0,3064,3065,5,30,0,0,3065,3066,3, + 32,16,0,3066,3067,5,31,0,0,3067,3068,3,294,147,0,3068,3094,1,0,0,0,3069, + 3070,5,185,0,0,3070,3071,5,30,0,0,3071,3072,3,32,16,0,3072,3073,5,31,0, + 0,3073,3074,3,294,147,0,3074,3094,1,0,0,0,3075,3076,5,184,0,0,3076,3077, + 5,30,0,0,3077,3078,3,32,16,0,3078,3079,5,31,0,0,3079,3080,3,294,147,0, + 3080,3094,1,0,0,0,3081,3082,5,188,0,0,3082,3094,3,294,147,0,3083,3084, + 5,189,0,0,3084,3094,3,294,147,0,3085,3086,5,187,0,0,3086,3094,3,294,147, + 0,3087,3088,5,186,0,0,3088,3094,3,294,147,0,3089,3090,5,185,0,0,3090,3094, + 3,294,147,0,3091,3092,5,184,0,0,3092,3094,3,294,147,0,3093,3027,1,0,0, + 0,3093,3033,1,0,0,0,3093,3038,1,0,0,0,3093,3040,1,0,0,0,3093,3045,1,0, + 0,0,3093,3051,1,0,0,0,3093,3057,1,0,0,0,3093,3063,1,0,0,0,3093,3069,1, + 0,0,0,3093,3075,1,0,0,0,3093,3081,1,0,0,0,3093,3083,1,0,0,0,3093,3085, + 1,0,0,0,3093,3087,1,0,0,0,3093,3089,1,0,0,0,3093,3091,1,0,0,0,3094,297, + 1,0,0,0,3095,3096,5,188,0,0,3096,3097,5,30,0,0,3097,3098,3,36,18,0,3098, + 3099,5,31,0,0,3099,3100,6,149,-1,0,3100,3186,1,0,0,0,3101,3102,5,189,0, + 0,3102,3103,5,30,0,0,3103,3104,3,36,18,0,3104,3105,5,31,0,0,3105,3106, + 6,149,-1,0,3106,3186,1,0,0,0,3107,3108,5,188,0,0,3108,3109,5,30,0,0,3109, + 3110,3,32,16,0,3110,3111,5,31,0,0,3111,3112,6,149,-1,0,3112,3186,1,0,0, + 0,3113,3114,5,189,0,0,3114,3115,5,30,0,0,3115,3116,3,34,17,0,3116,3117, + 5,31,0,0,3117,3118,6,149,-1,0,3118,3186,1,0,0,0,3119,3120,5,187,0,0,3120, + 3121,5,30,0,0,3121,3122,3,34,17,0,3122,3123,5,31,0,0,3123,3124,6,149,-1, + 0,3124,3186,1,0,0,0,3125,3126,5,186,0,0,3126,3127,5,30,0,0,3127,3128,3, + 32,16,0,3128,3129,5,31,0,0,3129,3130,6,149,-1,0,3130,3186,1,0,0,0,3131, + 3132,5,185,0,0,3132,3133,5,30,0,0,3133,3134,3,32,16,0,3134,3135,5,31,0, + 0,3135,3136,6,149,-1,0,3136,3186,1,0,0,0,3137,3138,5,184,0,0,3138,3139, + 5,30,0,0,3139,3140,3,32,16,0,3140,3141,5,31,0,0,3141,3142,6,149,-1,0,3142, + 3186,1,0,0,0,3143,3144,5,193,0,0,3144,3145,5,30,0,0,3145,3146,3,34,17, + 0,3146,3147,5,31,0,0,3147,3148,6,149,-1,0,3148,3186,1,0,0,0,3149,3150, + 5,192,0,0,3150,3151,5,30,0,0,3151,3152,3,32,16,0,3152,3153,5,31,0,0,3153, + 3154,6,149,-1,0,3154,3186,1,0,0,0,3155,3156,5,191,0,0,3156,3157,5,30,0, + 0,3157,3158,3,32,16,0,3158,3159,5,31,0,0,3159,3160,6,149,-1,0,3160,3186, + 1,0,0,0,3161,3162,5,190,0,0,3162,3163,5,30,0,0,3163,3164,3,32,16,0,3164, + 3165,5,31,0,0,3165,3166,6,149,-1,0,3166,3186,1,0,0,0,3167,3168,5,181,0, + 0,3168,3169,5,30,0,0,3169,3170,3,32,16,0,3170,3171,5,31,0,0,3171,3172, + 6,149,-1,0,3172,3186,1,0,0,0,3173,3174,5,183,0,0,3174,3175,5,30,0,0,3175, + 3176,3,162,81,0,3176,3177,5,31,0,0,3177,3178,6,149,-1,0,3178,3186,1,0, + 0,0,3179,3180,5,84,0,0,3180,3181,5,30,0,0,3181,3182,3,300,150,0,3182,3183, + 5,31,0,0,3183,3184,6,149,-1,0,3184,3186,1,0,0,0,3185,3095,1,0,0,0,3185, + 3101,1,0,0,0,3185,3107,1,0,0,0,3185,3113,1,0,0,0,3185,3119,1,0,0,0,3185, + 3125,1,0,0,0,3185,3131,1,0,0,0,3185,3137,1,0,0,0,3185,3143,1,0,0,0,3185, + 3149,1,0,0,0,3185,3155,1,0,0,0,3185,3161,1,0,0,0,3185,3167,1,0,0,0,3185, + 3173,1,0,0,0,3185,3179,1,0,0,0,3186,299,1,0,0,0,3187,3188,3,302,151,0, + 3188,3189,6,150,-1,0,3189,3191,1,0,0,0,3190,3187,1,0,0,0,3191,3194,1,0, + 0,0,3192,3190,1,0,0,0,3192,3193,1,0,0,0,3193,301,1,0,0,0,3194,3192,1,0, + 0,0,3195,3196,7,10,0,0,3196,303,1,0,0,0,3197,3198,3,298,149,0,3198,3199, + 6,152,-1,0,3199,3206,1,0,0,0,3200,3201,3,6,3,0,3201,3202,6,152,-1,0,3202, + 3206,1,0,0,0,3203,3204,5,179,0,0,3204,3206,6,152,-1,0,3205,3197,1,0,0, + 0,3205,3200,1,0,0,0,3205,3203,1,0,0,0,3206,305,1,0,0,0,3207,3208,3,298, + 149,0,3208,3209,6,153,-1,0,3209,3379,1,0,0,0,3210,3211,5,182,0,0,3211, + 3212,5,30,0,0,3212,3213,5,179,0,0,3213,3214,5,31,0,0,3214,3379,6,153,-1, + 0,3215,3216,5,182,0,0,3216,3217,5,30,0,0,3217,3218,5,264,0,0,3218,3219, + 5,31,0,0,3219,3379,6,153,-1,0,3220,3221,5,196,0,0,3221,3222,5,30,0,0,3222, + 3223,5,39,0,0,3223,3224,5,264,0,0,3224,3225,5,31,0,0,3225,3379,6,153,-1, + 0,3226,3227,5,196,0,0,3227,3228,5,30,0,0,3228,3229,3,116,58,0,3229,3230, + 5,31,0,0,3230,3231,6,153,-1,0,3231,3379,1,0,0,0,3232,3233,5,196,0,0,3233, + 3234,5,30,0,0,3234,3235,5,179,0,0,3235,3236,5,31,0,0,3236,3379,6,153,-1, + 0,3237,3238,5,197,0,0,3238,3239,5,30,0,0,3239,3240,3,306,153,0,3240,3241, + 5,31,0,0,3241,3242,6,153,-1,0,3242,3379,1,0,0,0,3243,3244,5,188,0,0,3244, + 3245,5,42,0,0,3245,3246,3,32,16,0,3246,3247,5,43,0,0,3247,3248,5,30,0, + 0,3248,3249,3,308,154,0,3249,3250,5,31,0,0,3250,3251,6,153,-1,0,3251,3379, + 1,0,0,0,3252,3253,5,189,0,0,3253,3254,5,42,0,0,3254,3255,3,32,16,0,3255, + 3256,5,43,0,0,3256,3257,5,30,0,0,3257,3258,3,310,155,0,3258,3259,5,31, + 0,0,3259,3260,6,153,-1,0,3260,3379,1,0,0,0,3261,3262,5,187,0,0,3262,3263, + 5,42,0,0,3263,3264,3,32,16,0,3264,3265,5,43,0,0,3265,3266,5,30,0,0,3266, + 3267,3,312,156,0,3267,3268,5,31,0,0,3268,3269,6,153,-1,0,3269,3379,1,0, + 0,0,3270,3271,5,186,0,0,3271,3272,5,42,0,0,3272,3273,3,32,16,0,3273,3274, + 5,43,0,0,3274,3275,5,30,0,0,3275,3276,3,314,157,0,3276,3277,5,31,0,0,3277, + 3278,6,153,-1,0,3278,3379,1,0,0,0,3279,3280,5,185,0,0,3280,3281,5,42,0, + 0,3281,3282,3,32,16,0,3282,3283,5,43,0,0,3283,3284,5,30,0,0,3284,3285, + 3,316,158,0,3285,3286,5,31,0,0,3286,3287,6,153,-1,0,3287,3379,1,0,0,0, + 3288,3289,5,184,0,0,3289,3290,5,42,0,0,3290,3291,3,32,16,0,3291,3292,5, + 43,0,0,3292,3293,5,30,0,0,3293,3294,3,318,159,0,3294,3295,5,31,0,0,3295, + 3296,6,153,-1,0,3296,3379,1,0,0,0,3297,3298,5,193,0,0,3298,3299,5,42,0, + 0,3299,3300,3,32,16,0,3300,3301,5,43,0,0,3301,3302,5,30,0,0,3302,3303, + 3,312,156,0,3303,3304,5,31,0,0,3304,3305,6,153,-1,0,3305,3379,1,0,0,0, + 3306,3307,5,192,0,0,3307,3308,5,42,0,0,3308,3309,3,32,16,0,3309,3310,5, + 43,0,0,3310,3311,5,30,0,0,3311,3312,3,314,157,0,3312,3313,5,31,0,0,3313, + 3314,6,153,-1,0,3314,3379,1,0,0,0,3315,3316,5,191,0,0,3316,3317,5,42,0, + 0,3317,3318,3,32,16,0,3318,3319,5,43,0,0,3319,3320,5,30,0,0,3320,3321, + 3,316,158,0,3321,3322,5,31,0,0,3322,3323,6,153,-1,0,3323,3379,1,0,0,0, + 3324,3325,5,190,0,0,3325,3326,5,42,0,0,3326,3327,3,32,16,0,3327,3328,5, + 43,0,0,3328,3329,5,30,0,0,3329,3330,3,318,159,0,3330,3331,5,31,0,0,3331, + 3332,6,153,-1,0,3332,3379,1,0,0,0,3333,3334,5,181,0,0,3334,3335,5,42,0, + 0,3335,3336,3,32,16,0,3336,3337,5,43,0,0,3337,3338,5,30,0,0,3338,3339, + 3,316,158,0,3339,3340,5,31,0,0,3340,3341,6,153,-1,0,3341,3379,1,0,0,0, + 3342,3343,5,183,0,0,3343,3344,5,42,0,0,3344,3345,3,32,16,0,3345,3346,5, + 43,0,0,3346,3347,5,30,0,0,3347,3348,3,320,160,0,3348,3349,5,31,0,0,3349, + 3350,6,153,-1,0,3350,3379,1,0,0,0,3351,3352,5,182,0,0,3352,3353,5,42,0, + 0,3353,3354,3,32,16,0,3354,3355,5,43,0,0,3355,3356,5,30,0,0,3356,3357, + 3,322,161,0,3357,3358,5,31,0,0,3358,3359,6,153,-1,0,3359,3379,1,0,0,0, + 3360,3361,5,196,0,0,3361,3362,5,42,0,0,3362,3363,3,32,16,0,3363,3364,5, + 43,0,0,3364,3365,5,30,0,0,3365,3366,3,324,162,0,3366,3367,5,31,0,0,3367, + 3368,6,153,-1,0,3368,3379,1,0,0,0,3369,3370,5,197,0,0,3370,3371,5,42,0, + 0,3371,3372,3,32,16,0,3372,3373,5,43,0,0,3373,3374,5,30,0,0,3374,3375, + 3,328,164,0,3375,3376,5,31,0,0,3376,3377,6,153,-1,0,3377,3379,1,0,0,0, + 3378,3207,1,0,0,0,3378,3210,1,0,0,0,3378,3215,1,0,0,0,3378,3220,1,0,0, + 0,3378,3226,1,0,0,0,3378,3232,1,0,0,0,3378,3237,1,0,0,0,3378,3243,1,0, + 0,0,3378,3252,1,0,0,0,3378,3261,1,0,0,0,3378,3270,1,0,0,0,3378,3279,1, + 0,0,0,3378,3288,1,0,0,0,3378,3297,1,0,0,0,3378,3306,1,0,0,0,3378,3315, + 1,0,0,0,3378,3324,1,0,0,0,3378,3333,1,0,0,0,3378,3342,1,0,0,0,3378,3351, + 1,0,0,0,3378,3360,1,0,0,0,3378,3369,1,0,0,0,3379,307,1,0,0,0,3380,3381, + 3,36,18,0,3381,3382,6,154,-1,0,3382,3387,1,0,0,0,3383,3384,3,32,16,0,3384, + 3385,6,154,-1,0,3385,3387,1,0,0,0,3386,3380,1,0,0,0,3386,3383,1,0,0,0, + 3387,3390,1,0,0,0,3388,3386,1,0,0,0,3388,3389,1,0,0,0,3389,309,1,0,0,0, + 3390,3388,1,0,0,0,3391,3392,3,36,18,0,3392,3393,6,155,-1,0,3393,3398,1, + 0,0,0,3394,3395,3,34,17,0,3395,3396,6,155,-1,0,3396,3398,1,0,0,0,3397, + 3391,1,0,0,0,3397,3394,1,0,0,0,3398,3401,1,0,0,0,3399,3397,1,0,0,0,3399, + 3400,1,0,0,0,3400,311,1,0,0,0,3401,3399,1,0,0,0,3402,3403,3,34,17,0,3403, + 3404,6,156,-1,0,3404,3406,1,0,0,0,3405,3402,1,0,0,0,3406,3409,1,0,0,0, + 3407,3405,1,0,0,0,3407,3408,1,0,0,0,3408,313,1,0,0,0,3409,3407,1,0,0,0, + 3410,3411,3,32,16,0,3411,3412,6,157,-1,0,3412,3414,1,0,0,0,3413,3410,1, + 0,0,0,3414,3417,1,0,0,0,3415,3413,1,0,0,0,3415,3416,1,0,0,0,3416,315,1, + 0,0,0,3417,3415,1,0,0,0,3418,3419,3,32,16,0,3419,3420,6,158,-1,0,3420, + 3422,1,0,0,0,3421,3418,1,0,0,0,3422,3425,1,0,0,0,3423,3421,1,0,0,0,3423, + 3424,1,0,0,0,3424,317,1,0,0,0,3425,3423,1,0,0,0,3426,3427,3,32,16,0,3427, + 3428,6,159,-1,0,3428,3430,1,0,0,0,3429,3426,1,0,0,0,3430,3433,1,0,0,0, + 3431,3429,1,0,0,0,3431,3432,1,0,0,0,3432,319,1,0,0,0,3433,3431,1,0,0,0, + 3434,3435,3,162,81,0,3435,3436,6,160,-1,0,3436,3438,1,0,0,0,3437,3434, + 1,0,0,0,3438,3441,1,0,0,0,3439,3437,1,0,0,0,3439,3440,1,0,0,0,3440,321, + 1,0,0,0,3441,3439,1,0,0,0,3442,3443,5,179,0,0,3443,3447,6,161,-1,0,3444, + 3445,5,264,0,0,3445,3447,6,161,-1,0,3446,3442,1,0,0,0,3446,3444,1,0,0, + 0,3447,3450,1,0,0,0,3448,3446,1,0,0,0,3448,3449,1,0,0,0,3449,323,1,0,0, + 0,3450,3448,1,0,0,0,3451,3452,3,326,163,0,3452,3453,6,162,-1,0,3453,3455, + 1,0,0,0,3454,3451,1,0,0,0,3455,3458,1,0,0,0,3456,3454,1,0,0,0,3456,3457, + 1,0,0,0,3457,325,1,0,0,0,3458,3456,1,0,0,0,3459,3460,5,179,0,0,3460,3468, + 6,163,-1,0,3461,3462,5,39,0,0,3462,3463,5,264,0,0,3463,3468,6,163,-1,0, + 3464,3465,3,116,58,0,3465,3466,6,163,-1,0,3466,3468,1,0,0,0,3467,3459, + 1,0,0,0,3467,3461,1,0,0,0,3467,3464,1,0,0,0,3468,327,1,0,0,0,3469,3470, + 3,306,153,0,3470,3471,6,164,-1,0,3471,3473,1,0,0,0,3472,3469,1,0,0,0,3473, + 3476,1,0,0,0,3474,3472,1,0,0,0,3474,3475,1,0,0,0,3475,329,1,0,0,0,3476, + 3474,1,0,0,0,3477,3478,3,44,22,0,3478,3479,6,165,-1,0,3479,3487,1,0,0, + 0,3480,3481,3,46,23,0,3481,3482,6,165,-1,0,3482,3487,1,0,0,0,3483,3484, + 3,2,1,0,3484,3485,6,165,-1,0,3485,3487,1,0,0,0,3486,3477,1,0,0,0,3486, + 3480,1,0,0,0,3486,3483,1,0,0,0,3487,331,1,0,0,0,3488,3489,7,11,0,0,3489, + 3490,5,36,0,0,3490,3491,5,30,0,0,3491,3492,3,300,150,0,3492,3493,5,31, + 0,0,3493,3514,1,0,0,0,3494,3495,5,169,0,0,3495,3496,3,38,19,0,3496,3497, + 5,75,0,0,3497,3498,3,38,19,0,3498,3499,5,75,0,0,3499,3500,3,38,19,0,3500, + 3501,5,75,0,0,3501,3502,3,38,19,0,3502,3514,1,0,0,0,3503,3504,5,170,0, + 0,3504,3514,3,6,3,0,3505,3506,5,170,0,0,3506,3507,5,36,0,0,3507,3508,5, + 30,0,0,3508,3509,3,300,150,0,3509,3510,5,31,0,0,3510,3514,1,0,0,0,3511, + 3514,3,330,165,0,3512,3514,3,40,20,0,3513,3488,1,0,0,0,3513,3494,1,0,0, + 0,3513,3503,1,0,0,0,3513,3505,1,0,0,0,3513,3511,1,0,0,0,3513,3512,1,0, + 0,0,3514,333,1,0,0,0,3515,3516,3,336,168,0,3516,3517,5,17,0,0,3517,3518, + 3,338,169,0,3518,3519,5,18,0,0,3519,335,1,0,0,0,3520,3521,5,25,0,0,3521, + 3522,5,40,0,0,3522,3523,3,98,49,0,3523,3524,3,2,1,0,3524,3533,1,0,0,0, + 3525,3526,5,25,0,0,3526,3527,5,40,0,0,3527,3528,3,98,49,0,3528,3529,3, + 2,1,0,3529,3530,5,34,0,0,3530,3531,3,2,1,0,3531,3533,1,0,0,0,3532,3520, + 1,0,0,0,3532,3525,1,0,0,0,3533,337,1,0,0,0,3534,3536,3,340,170,0,3535, + 3534,1,0,0,0,3536,3539,1,0,0,0,3537,3535,1,0,0,0,3537,3538,1,0,0,0,3538, + 339,1,0,0,0,3539,3537,1,0,0,0,3540,3541,5,180,0,0,3541,3542,5,36,0,0,3542, + 3543,5,30,0,0,3543,3544,3,300,150,0,3544,3545,5,31,0,0,3545,3555,1,0,0, + 0,3546,3555,3,332,166,0,3547,3548,5,171,0,0,3548,3549,5,36,0,0,3549,3550, + 5,30,0,0,3550,3551,3,300,150,0,3551,3552,5,31,0,0,3552,3555,1,0,0,0,3553, + 3555,5,55,0,0,3554,3540,1,0,0,0,3554,3546,1,0,0,0,3554,3547,1,0,0,0,3554, + 3553,1,0,0,0,3555,341,1,0,0,0,3556,3557,3,344,172,0,3557,3558,5,17,0,0, + 3558,3559,3,350,175,0,3559,3560,5,18,0,0,3560,343,1,0,0,0,3561,3562,5, + 50,0,0,3562,3566,5,40,0,0,3563,3565,3,348,174,0,3564,3563,1,0,0,0,3565, + 3568,1,0,0,0,3566,3564,1,0,0,0,3566,3567,1,0,0,0,3567,3569,1,0,0,0,3568, + 3566,1,0,0,0,3569,3570,3,2,1,0,3570,345,1,0,0,0,3571,3575,5,301,0,0,3572, + 3574,3,348,174,0,3573,3572,1,0,0,0,3574,3577,1,0,0,0,3575,3573,1,0,0,0, + 3575,3576,1,0,0,0,3576,3578,1,0,0,0,3577,3575,1,0,0,0,3578,3579,3,2,1, + 0,3579,347,1,0,0,0,3580,3596,5,52,0,0,3581,3596,5,51,0,0,3582,3596,5,172, + 0,0,3583,3584,5,62,0,0,3584,3596,5,51,0,0,3585,3586,5,62,0,0,3586,3596, + 5,52,0,0,3587,3588,5,62,0,0,3588,3596,5,63,0,0,3589,3590,5,62,0,0,3590, + 3596,5,64,0,0,3591,3592,5,62,0,0,3592,3596,5,65,0,0,3593,3594,5,62,0,0, + 3594,3596,5,66,0,0,3595,3580,1,0,0,0,3595,3581,1,0,0,0,3595,3582,1,0,0, + 0,3595,3583,1,0,0,0,3595,3585,1,0,0,0,3595,3587,1,0,0,0,3595,3589,1,0, + 0,0,3595,3591,1,0,0,0,3595,3593,1,0,0,0,3596,349,1,0,0,0,3597,3599,3,352, + 176,0,3598,3597,1,0,0,0,3599,3602,1,0,0,0,3600,3598,1,0,0,0,3600,3601, + 1,0,0,0,3601,351,1,0,0,0,3602,3600,1,0,0,0,3603,3604,5,21,0,0,3604,3617, + 3,2,1,0,3605,3606,5,50,0,0,3606,3607,5,40,0,0,3607,3617,3,118,59,0,3608, + 3609,5,25,0,0,3609,3610,5,40,0,0,3610,3617,3,2,1,0,3611,3617,3,174,87, + 0,3612,3613,5,50,0,0,3613,3617,3,32,16,0,3614,3617,3,330,165,0,3615,3617, + 3,40,20,0,3616,3603,1,0,0,0,3616,3605,1,0,0,0,3616,3608,1,0,0,0,3616,3611, + 1,0,0,0,3616,3612,1,0,0,0,3616,3614,1,0,0,0,3616,3615,1,0,0,0,3617,353, + 1,0,0,0,3618,3619,3,356,178,0,3619,3620,5,17,0,0,3620,3621,3,360,180,0, + 3621,3622,5,18,0,0,3622,355,1,0,0,0,3623,3627,5,274,0,0,3624,3626,3,358, + 179,0,3625,3624,1,0,0,0,3626,3629,1,0,0,0,3627,3625,1,0,0,0,3627,3628, + 1,0,0,0,3628,3630,1,0,0,0,3629,3627,1,0,0,0,3630,3643,3,2,1,0,3631,3635, + 5,274,0,0,3632,3634,3,358,179,0,3633,3632,1,0,0,0,3634,3637,1,0,0,0,3635, + 3633,1,0,0,0,3635,3636,1,0,0,0,3636,3638,1,0,0,0,3637,3635,1,0,0,0,3638, + 3639,3,2,1,0,3639,3640,5,34,0,0,3640,3641,3,2,1,0,3641,3643,1,0,0,0,3642, + 3623,1,0,0,0,3642,3631,1,0,0,0,3643,357,1,0,0,0,3644,3645,7,12,0,0,3645, + 359,1,0,0,0,3646,3648,3,362,181,0,3647,3646,1,0,0,0,3648,3651,1,0,0,0, + 3649,3647,1,0,0,0,3649,3650,1,0,0,0,3650,361,1,0,0,0,3651,3649,1,0,0,0, + 3652,3653,5,21,0,0,3653,3654,3,2,1,0,3654,3655,5,44,0,0,3655,3656,3,32, + 16,0,3656,3663,1,0,0,0,3657,3658,5,25,0,0,3658,3659,5,40,0,0,3659,3663, + 3,2,1,0,3660,3663,3,330,165,0,3661,3663,3,40,20,0,3662,3652,1,0,0,0,3662, + 3657,1,0,0,0,3662,3660,1,0,0,0,3662,3661,1,0,0,0,3663,363,1,0,0,0,182, + 374,382,391,400,489,535,546,576,580,598,625,653,693,704,714,716,727,729, + 737,759,772,793,795,814,887,894,901,906,915,1026,1032,1048,1054,1060,1067, + 1095,1173,1175,1189,1195,1204,1206,1215,1229,1243,1251,1259,1263,1302, + 1310,1319,1327,1346,1356,1359,1383,1530,1540,1549,1552,1634,1643,1675, + 1735,1775,1791,1801,1828,1852,1860,1864,1879,1886,1931,1941,1959,1977, + 1996,2017,2036,2051,2059,2071,2091,2098,2103,2114,2126,2236,2248,2264, + 2278,2287,2300,2302,2345,2356,2363,2371,2379,2392,2398,2404,2409,2438, + 2446,2460,2465,2490,2499,2510,2514,2521,2541,2550,2552,2567,2614,2624, + 2626,2633,2639,2683,2692,2732,2737,2777,2781,2791,2813,2825,2836,2851, + 2864,2877,2880,2892,2906,2924,2942,2956,2980,2992,2997,3006,3008,3015, + 3025,3093,3185,3192,3205,3378,3386,3388,3397,3399,3407,3415,3423,3431, + 3439,3446,3448,3456,3467,3474,3486,3513,3532,3537,3554,3566,3575,3595, + 3600,3616,3627,3635,3642,3649,3662 }; public static readonly ATN _ATN = diff --git a/src/tools/ilasm/tests/ILAssembler.Tests/CustomAttributeTests.cs b/src/tools/ilasm/tests/ILAssembler.Tests/CustomAttributeTests.cs index b2824811baac86..6f734e891616d9 100644 --- a/src/tools/ilasm/tests/ILAssembler.Tests/CustomAttributeTests.cs +++ b/src/tools/ilasm/tests/ILAssembler.Tests/CustomAttributeTests.cs @@ -815,6 +815,138 @@ .class public auto ansi Test extends [mscorlib]System.Object }); } + [Fact] + public void CustomAttribute_ObjectArrayWithNestedArrays_DecodesProperly() + { + string source = """ + .assembly extern mscorlib { } + .assembly test { } + .class public auto ansi sealed ObjArrAttribute extends [mscorlib]System.Attribute + { + .method public specialname rtspecialname instance void .ctor(object[] values) cil managed + { + ldarg.0 + call instance void [mscorlib]System.Attribute::.ctor() + ret + } + } + .class public auto ansi Test extends [mscorlib]System.Object + { + .custom instance void ObjArrAttribute::.ctor(object[]) = { + object[2](int32[2](1 2) object(string[2]('alpha' nullref))) + } + } + """; + + using var pe = DocumentCompilerTestHelpers.CompileAndGetReader(source, new Options()); + var reader = pe.GetMetadataReader(); + var testType = reader.TypeDefinitions + .Single(handle => reader.GetString(reader.GetTypeDefinition(handle).Name) == "Test"); + var attribute = reader.GetCustomAttribute(Assert.Single(reader.GetCustomAttributes(testType))); + CustomAttributeValue value = attribute.DecodeValue(DocumentCompilerTestHelpers.Decoder); + ImmutableArray> elements = + Assert.IsType>>( + Assert.Single(value.FixedArguments).Value); + + Assert.Collection( + elements, + element => + { + Assert.Equal("int32[]", element.Type); + AssertArrayValue(element.Value, 1, 2); + }, + element => + { + Assert.Equal("string[]", element.Type); + AssertArrayValue(element.Value, "alpha", null); + }); + } + + [Theory] + [InlineData(""" + .assembly extern mscorlib { } + .assembly test { } + .class public auto ansi Test extends [mscorlib]System.Object + { + .custom instance void [mscorlib]System.ObsoleteAttribute::.ctor(int32) = { + float32('a') + } + } + """)] + [InlineData(""" + .assembly extern mscorlib { } + .assembly test { } + .class public auto ansi Test extends [mscorlib]System.Object + { + .field public static literal float32 F = float32('a') + } + """)] + [InlineData(""" + .assembly extern mscorlib { } + .assembly test { } + .class public auto ansi Test extends [mscorlib]System.Object + { + .method public static void M(float32 value) cil managed + { + .param [1] = float32('a') + ret + } + } + """)] + public void MalformedScalarInitializer_ReportsDiagnosticsInsteadOfThrowing(string source) + { + ImmutableArray diagnostics = + DocumentCompilerTestHelpers.CompileAndGetDiagnostics(source, new Options()); + + Assert.Contains(diagnostics, diagnostic => diagnostic.Id == "Parser"); + } + + [Fact] + public void MalformedNestedCustomAttributeSequence_DoesNotLeakFramesIntoNextDocument() + { + ImmutableArray documents = + [ + new SourceText(""" + .assembly extern mscorlib { } + .assembly test { } + .class public auto ansi Broken extends [mscorlib]System.Object + { + .custom instance void [mscorlib]System.ObsoleteAttribute::.ctor(object[]) = { + object[2](type[1]([Discarded]Namespace.Type) + """, "broken.il"), + new SourceText(""" + .class public auto ansi Following extends [mscorlib]System.Object + { + .custom instance void [mscorlib]System.ObsoleteAttribute::.ctor() = { } + } + """, "following.il") + ]; + + DocumentCompiler compiler = new(); + var (diagnostics, result) = compiler.Compile( + documents, + _ => { Assert.Fail("Expected no includes"); return default; }, + _ => { Assert.Fail("Expected no resources"); return default; }, + new Options { ErrorTolerant = true }); + + Assert.Contains(diagnostics, diagnostic => diagnostic.Id == "Parser"); + Assert.NotNull(result); + + BlobBuilder image = new(); + result!.Serialize(image); + using PEReader pe = new(image.ToImmutableArray()); + MetadataReader reader = pe.GetMetadataReader(); + TypeDefinitionHandle followingHandle = reader.TypeDefinitions + .Single(handle => reader.GetString(reader.GetTypeDefinition(handle).Name) == "Following"); + + Assert.DoesNotContain( + reader.AssemblyReferences.Select(reader.GetAssemblyReference), + reference => reader.GetString(reference.Name) == "Discarded"); + AssertCustomAttributeBlob( + reader, + Assert.Single(reader.GetCustomAttributes(followingHandle))); + } + private static string TypeWithAttribute(string attributeType, string constructor = ".ctor()", string value = "( 01 00 00 00 )") => $$""" .assembly extern mscorlib { } .assembly test { } From c377560426c079e1894ff5644ddae4b6f16b109f Mon Sep 17 00:00:00 2001 From: Jeremy Koritzinsky Date: Thu, 13 Aug 2026 18:27:04 -0700 Subject: [PATCH 11/16] Compile shared IL directives during parsing Stream data declaration items and synthesize declarative security, source mapping, and language directives. Remove their shared parse-tree islands while preserving label fixups, parent ownership, and PDB state. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: c986c103-8383-4db4-9b11-9be49dc68a05 --- src/tools/ilasm/README.md | 23 +- .../Actions/GrammarActions.Data.cs | 367 +- .../Actions/GrammarActions.Debug.cs | 364 +- .../GrammarActions.Declarations.Actions.cs | 21 +- .../Actions/GrammarActions.Members.Class.cs | 15 +- ...GrammarActions.Members.PropertiesEvents.cs | 28 +- .../GrammarActions.MethodBodies.Directives.cs | 25 +- .../Actions/GrammarActions.Security.cs | 538 +- .../src/ILAssembler/Actions/GrammarActions.cs | 7 + src/tools/ilasm/src/ILAssembler/gen/CIL.g4 | 227 +- .../ilasm/src/ILAssembler/gen/CIL.interp | 2 +- .../ilasm/src/ILAssembler/gen/CILParser.cs | 7095 ++++++++--------- .../tests/ILAssembler.Tests/DataTests.cs | 88 + .../tests/ILAssembler.Tests/SecurityTests.cs | 92 + .../ILAssembler.Tests/SourceDirectiveTests.cs | 112 + 15 files changed, 4887 insertions(+), 4117 deletions(-) diff --git a/src/tools/ilasm/README.md b/src/tools/ilasm/README.md index 11179cbeaf0b90..6fb69e052647cd 100644 --- a/src/tools/ilasm/README.md +++ b/src/tools/ilasm/README.md @@ -2,10 +2,9 @@ ILAssembler compiles declarations while ANTLR parses the input. The parser uses `UnbufferedTokenStream` with parse-tree construction disabled. Namespace, type, top-level, -class-member and method-body structure is action-driven, while shared directives retain bounded -subtrees for their existing visitors. A complete document, declaration body or method body is -never retained. Rules such as `bytes` stream their content into an accumulator instead of building -a subtree at all. +class-member, method-body and shared-directive structure is action-driven. A complete document, +declaration body or method body is never retained. Rules such as `bytes` stream their content into +an accumulator instead of building a subtree at all. `GrammarActions` is a single `internal sealed partial class` split across `src/ILAssembler/Actions/GrammarActions.*.cs`: @@ -20,8 +19,8 @@ a subtree at all. | `GrammarActions.CustomAttributes.Sequences.cs` | Custom attribute scalar-array sequence synthesis. | | `GrammarActions.CustomAttributes.Serialization.cs` | Serialized attribute values and field/parameter initializers. | | `GrammarActions.CustomAttributes.Values.cs` | Internal synthesized custom attribute value model. | -| `GrammarActions.Data.cs` | Data and blob declarations. | -| `GrammarActions.Debug.cs` | Source and debug directives. | +| `GrammarActions.Data.cs` | Streaming mapped-data declarations, labels and reference fixups. | +| `GrammarActions.Debug.cs` | Direct source-location, document and language directives. | | `GrammarActions.Declarations.cs` | Parser-driven top-level declaration visitor guards. | | `GrammarActions.Declarations.Actions.cs` | Direct top-level declarations and shared-directive dispatch. | | `GrammarActions.Instructions.cs` | Tree-free value instruction and method-item actions. | @@ -43,7 +42,7 @@ a subtree at all. | `GrammarActions.MethodBodies.Directives.cs` | Direct method-body directives and parameter ownership. | | `GrammarActions.MethodBodies.ExceptionHandling.cs` | Lexical scopes and synthesized exception regions. | | `GrammarActions.MethodBodies.Values.cs` | Internal method-body directive and exception-region values. | -| `GrammarActions.Security.cs` | Declarative security conversion. | +| `GrammarActions.Security.cs` | Synthesized declarative-security values and permission sets. | | `GrammarActions.Signatures.cs` | Signature visitor compatibility wrappers. | | `GrammarActions.Signatures.Actions.cs` | Signature grammar actions and repetition frames. | | `GrammarActions.Signatures.References.cs` | Member-reference synthesis and materialization. | @@ -70,11 +69,11 @@ slots use `object` where an internal value or array crosses that boundary and `G provides the strongly typed accessors. All namespace, type-header, top-level, type, signature, reference, marshalling, class-member, -method-header, method-body directive and exception-handling structure is action-driven. -`scopeBlock` records offsets under its context key without inspecting children. The remaining -`BeginSubtree` islands are the bounded shared roots `assemblyBlock`, `assemblyRefBlock`, -`exptypeBlock`, `manifestResBlock`, `dataDecl`, `fileDecl`, `vtableDecl`, `vtfixupDecl`, `secDecl`, -`extSourceSpec`, `languageDecl` and `typedefDecl`. +method-header, method-body directive, exception-handling, data, security, source and language +structure is action-driven. `scopeBlock` records offsets under its context key without inspecting +children. The remaining `BeginSubtree` islands are the manifest-family roots `assemblyBlock`, +`assemblyRefBlock`, `exptypeBlock`, `manifestResBlock`, `fileDecl`, `vtableDecl`, `vtfixupDecl` and +`typedefDecl`. Semantic state that a rule pushes must be released from that rule's `finally` clause and be keyed on the owning context, because ANTLR skips `@after` actions and the remainder of an alternative once a diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Data.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Data.cs index eb313fb17fc681..7facba615efca1 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Data.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Data.cs @@ -1,150 +1,295 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System; -using System.Buffers.Binary; using System.Collections.Generic; using System.Collections.Immutable; using System.Diagnostics; -using System.Globalization; -using System.IO; -using System.Linq; -using System.Reflection; using System.Reflection.Metadata; -using System.Reflection.Metadata.Ecma335; -using System.Reflection.PortableExecutable; -using System.Runtime.InteropServices; -using System.Security.Cryptography; -using System.Text; using Antlr4.Runtime; -using Antlr4.Runtime.Misc; -using Antlr4.Runtime.Tree; -namespace ILAssembler +namespace ILAssembler; + +internal sealed partial class GrammarActions { -#pragma warning disable CA1822 // Mark members as static - internal sealed partial class GrammarActions : ICILVisitor + private readonly Stack _dataDeclarationFrames = new(); + + private sealed class DataDeclarationFrame { - public GrammarResult VisitDataDecl(CILParser.DataDeclContext context) + public DataDeclarationFrame(CILParser.DataDeclContext owner, bool shouldCommit) { - _ = VisitDdHead(context.ddHead()); - _ = VisitDdBody(context.ddBody()); - return GrammarResult.SentinelValue.Result; + Owner = owner; + ShouldCommit = shouldCommit; } - public GrammarResult VisitDdBody(CILParser.DdBodyContext context) + + public CILParser.DataDeclContext Owner { get; } + + public bool ShouldCommit { get; } + + public BlobBuilder Data { get; } = new(); + + public Dictionary>? ReferenceFixups { get; set; } + + public string? Name { get; set; } + + public byte Section { get; set; } + } + + internal void BeginDataDeclaration(CILParser.DataDeclContext context) + { + BeginSemanticRoot(context); + _dataDeclarationFrames.Push(new( + context, + context.Parent is not CILParser.MethodDeclContext || _currentMethod is not null)); + } + + internal void EndDataDeclaration(CILParser.DataDeclContext context) + { + bool hasSyntaxError = EndSemanticRoot(context); + context.HasSyntaxError = hasSyntaxError; + + DataDeclarationFrame? frame = TryGetDataDeclarationFrame(context); + if (frame is null) { - if (context.ddItemList() is CILParser.DdItemListContext ddItemList) - { - _ = VisitDdItemList(ddItemList); - } - else - { - foreach (var item in context.ddItem()) - { - _ = VisitDdItem(item); - } - } - return GrammarResult.SentinelValue.Result; + return; } - public GrammarResult VisitDdHead(CILParser.DdHeadContext context) + + _dataDeclarationFrames.Pop(); + if (hasSyntaxError || !frame.ShouldCommit) { - if (context.id() is CILParser.IdContext id) - { - string name = VisitId(id).Value; - if (!_mappedFieldDataNames.ContainsKey(name)) - { - _mappedFieldDataNames.Add(name, _mappedFieldData.Count); - } - } - return GrammarResult.SentinelValue.Result; + return; } - public GrammarResult VisitDdItem(CILParser.DdItemContext context) + + int declarationOffset = _mappedFieldData.Count; + if (frame.Name is not null && !_mappedFieldDataNames.ContainsKey(frame.Name)) { - if (context.compQstring() is CILParser.CompQstringContext str) - { - var value = VisitCompQstring(str).Value; - _mappedFieldData.WriteUTF16(value); - return GrammarResult.SentinelValue.Result; - } - else if (context.id() is CILParser.IdContext id) - { - // Reference to another data label - this will be patched with the target's RVA - // during PE serialization by VTableExportPEBuilder.ApplyDataLabelFixups() - string name = VisitId(id).Value; - if (!_mappedFieldDataReferenceFixups.TryGetValue(name, out var fixups)) - { - _mappedFieldDataReferenceFixups[name] = fixups = new(); - } + _mappedFieldDataNames.Add(frame.Name, declarationOffset); + } - // Reserve 4 bytes for the RVA that will be patched later - fixups.Add(_mappedFieldData.ReserveBytes(4)); - return GrammarResult.SentinelValue.Result; - } - else if (context.bytes() is CILParser.BytesContext bytes) + _mappedFieldData.LinkSuffix(frame.Data); + if (frame.ReferenceFixups is null) + { + return; + } + + foreach ((string target, List declarationFixups) in frame.ReferenceFixups) + { + if (!_mappedFieldDataReferenceFixups.TryGetValue(target, out List? fixups)) { - _mappedFieldData.WriteBytes(VisitBytes(bytes)); - return GrammarResult.SentinelValue.Result; + _mappedFieldDataReferenceFixups.Add(target, fixups = new()); } - int itemCount = VisitDdItemCount(context.ddItemCount()).Value; + fixups.AddRange(declarationFixups); + } + } - if (context.INT8() is not null) - { - _mappedFieldData.WriteBytes(context.int32() is CILParser.Int32Context int32 ? (byte)VisitInt32(int32).Value : (byte)0, itemCount); - } - else if (context.INT16() is not null) - { - for (int i = 0; i < itemCount; i++) - { - _mappedFieldData.WriteInt16(context.int32() is CILParser.Int32Context int32 ? (short)VisitInt32(int32).Value : (short)0); - } - } - else if (context.INT32_() is not null) + internal void SetDataDeclarationHeader( + CILParser.DdHeadContext context, + byte section, + IToken name) + { + if (TryGetDataDeclarationFrame(context) is { } frame) + { + frame.Section = section; + frame.Name = ParseIdentifier(name); + } + } + + internal void SetAnonymousDataDeclarationHeader(CILParser.DdHeadContext context, byte section) + { + if (TryGetDataDeclarationFrame(context) is { } frame) + { + frame.Section = section; + } + } + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. + internal byte GetMappedDataSection() => 0; + + internal byte GetTlsDataSection() => 1; + + internal byte GetCilDataSection() => 2; +#pragma warning restore CA1822 + + internal int ParseDataItemCount(IToken token) => ParseInt32(token); + + internal void AddDataString(CILParser.DdItemContext context, string value) + { + TryGetDataDeclarationFrame(context)?.Data.WriteUTF16(value); + } + + internal void AddDataReference(CILParser.DdItemContext context, IToken targetToken) + { + if (TryGetDataDeclarationFrame(context) is not { } frame) + { + return; + } + + string target = ParseIdentifier(targetToken); + Dictionary> fixups = + frame.ReferenceFixups ??= new Dictionary>(); + if (!fixups.TryGetValue(target, out List? targetFixups)) + { + fixups.Add(target, targetFixups = new()); + } + + targetFixups.Add(frame.Data.ReserveBytes(sizeof(int))); + } + + internal void AddDataBytes( + CILParser.DdItemContext context, + ImmutableArray value) + { + TryGetDataDeclarationFrame(context)?.Data.WriteBytes(value); + } + + internal void AddFloatingPointData( + CILParser.DdItemContext context, + IToken kind, + double value, + int count) + { + if (count <= 0 || TryGetDataDeclarationFrame(context) is not { } frame) + { + return; + } + + if (kind.Text == "float32") + { + float single = (float)value; + for (int i = 0; i < count; i++) { - for (int i = 0; i < itemCount; i++) - { - _mappedFieldData.WriteInt32(context.int32() is CILParser.Int32Context int32 ? VisitInt32(int32).Value : 0); - } + frame.Data.WriteSingle(single); } - else if (context.INT64_() is not null) + } + else + { + Debug.Assert(kind.Text == "float64"); + for (int i = 0; i < count; i++) { - for (int i = 0; i < itemCount; i++) - { - _mappedFieldData.WriteInt64(context.int64() is CILParser.Int64Context int64 ? VisitInt64(int64).Value : 0); - } + frame.Data.WriteDouble(value); } - else if (context.FLOAT32() is not null) - { - for (int i = 0; i < itemCount; i++) + } + } + + internal void AddInt64Data( + CILParser.DdItemContext context, + IToken kind, + IToken value, + int count) + { + Debug.Assert(kind.Text == "int64"); + if (count <= 0 || TryGetDataDeclarationFrame(context) is not { } frame) + { + return; + } + + long parsedValue = ParseInt64(value); + for (int i = 0; i < count; i++) + { + frame.Data.WriteInt64(parsedValue); + } + } + + internal void AddIntegerData( + CILParser.DdItemContext context, + IToken kind, + IToken value, + int count) + { + if (count <= 0 || TryGetDataDeclarationFrame(context) is not { } frame) + { + return; + } + + int parsedValue = ParseInt32(value); + switch (kind.Text) + { + case "int8": + frame.Data.WriteBytes((byte)parsedValue, count); + break; + case "int16": + for (int i = 0; i < count; i++) { - _mappedFieldData.WriteSingle(context.float64() is CILParser.Float64Context float64 ? (float)VisitFloat64(float64).Value : 0); + frame.Data.WriteInt16((short)parsedValue); } - } - else if (context.FLOAT64_() is not null) - { - for (int i = 0; i < itemCount; i++) + break; + default: + Debug.Assert(kind.Text == "int32"); + for (int i = 0; i < count; i++) { - _mappedFieldData.WriteDouble(context.float64() is CILParser.Float64Context float64 ? VisitFloat64(float64).Value : 0); + frame.Data.WriteInt32(parsedValue); } - } - return GrammarResult.SentinelValue.Result; + break; } - GrammarResult ICILVisitor.VisitDdItemCount(CILParser.DdItemCountContext context) => VisitDdItemCount(context); - public GrammarResult.Literal VisitDdItemCount(CILParser.DdItemCountContext context) => new(context.int32() is CILParser.Int32Context ? VisitInt32(context.int32()).Value : 1); - public GrammarResult VisitDdItemList(CILParser.DdItemListContext context) + } + + internal void AddZeroData(CILParser.DdItemContext context, IToken kind, int count) + { + if (count <= 0 || TryGetDataDeclarationFrame(context) is not { } frame) { - foreach (var item in context.ddItem()) - { - VisitDdItem(item); - } - return GrammarResult.SentinelValue.Result; + return; } - public GrammarResult VisitTls(CILParser.TlsContext context) + + int elementSize = kind.Text switch + { + "int8" => sizeof(byte), + "int16" => sizeof(short), + "int32" or "float32" => sizeof(int), + "int64" or "float64" => sizeof(long), + _ => throw new UnreachableException(), + }; + frame.Data.WriteBytes(0, checked(elementSize * count)); + } + + private DataDeclarationFrame? TryGetDataDeclarationFrame(ParserRuleContext context) + { + Debug.Assert(_dataDeclarationFrames.Count > 0); + DataDeclarationFrame? frame = + _dataDeclarationFrames.Count == 0 ? null : _dataDeclarationFrames.Peek(); + CILParser.DataDeclContext? owner = FindDataDeclarationOwner(context); + Debug.Assert(frame is null || ReferenceEquals(frame.Owner, owner)); + return frame is not null && ReferenceEquals(frame.Owner, owner) ? frame : null; + } + + private static CILParser.DataDeclContext? FindDataDeclarationOwner(RuleContext context) + { + for (RuleContext? current = context; current is not null; current = current.Parent) { - // TODO-SRM: System.Reflection.Metadata doesn't provide APIs to point a data declaration at a TLS slot or into the IL stream. - // We have tests for the TLS case (CoreCLR only supports it on Win-x86), but not for the IL case. - return GrammarResult.SentinelValue.Result; + if (current is CILParser.DataDeclContext declaration) + { + return declaration; + } } + return null; } + +#pragma warning disable CA1822 // Structural rules are driven by parser actions. + public GrammarResult VisitDataDecl(CILParser.DataDeclContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + public GrammarResult VisitDdHead(CILParser.DdHeadContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + public GrammarResult VisitDdBody(CILParser.DdBodyContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + public GrammarResult VisitDdItemList(CILParser.DdItemListContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + public GrammarResult VisitDdItem(CILParser.DdItemContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitDdItemCount(CILParser.DdItemCountContext context) + => VisitDdItemCount(context); + + public static GrammarResult.Literal VisitDdItemCount(CILParser.DdItemCountContext context) + => new(context.Value); + + GrammarResult ICILVisitor.VisitTls(CILParser.TlsContext context) + => VisitTls(context); + + public static GrammarResult.Literal VisitTls(CILParser.TlsContext context) + => new(context.Value); +#pragma warning restore CA1822 } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Debug.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Debug.cs index 6079a0816c9a27..aec271e76ddf2c 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Debug.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Debug.cs @@ -2,175 +2,251 @@ // The .NET Foundation licenses this file to you under the MIT license. using System; -using System.Buffers.Binary; using System.Collections.Generic; -using System.Collections.Immutable; using System.Diagnostics; -using System.Globalization; -using System.IO; -using System.Linq; -using System.Reflection; -using System.Reflection.Metadata; -using System.Reflection.Metadata.Ecma335; -using System.Reflection.PortableExecutable; -using System.Runtime.InteropServices; -using System.Security.Cryptography; -using System.Text; using Antlr4.Runtime; -using Antlr4.Runtime.Misc; -using Antlr4.Runtime.Tree; -namespace ILAssembler +namespace ILAssembler; + +internal sealed partial class GrammarActions { -#pragma warning disable CA1822 // Mark members as static - internal sealed partial class GrammarActions : ICILVisitor + private sealed record SourceDirectiveValue( + bool AutoIncrement, + int StartLine, + int StartColumn, + int EndLine, + int EndColumn, + string? DocumentPath); + + private sealed record LanguageDirectiveValue( + string Language, + string? Vendor, + string? DocumentType); + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. + internal bool IsAutoIncrementSourceDirective(IToken token) => token.Text == "#line"; +#pragma warning restore CA1822 + + internal object CreateSourceLine(bool autoIncrement, IToken line, IToken? path) { - public GrammarResult VisitCompControl(CILParser.CompControlContext context) + int lineNumber = ParseInt32(line); + return CreateSourceDirective(autoIncrement, lineNumber, 0, lineNumber, 0, path); + } + + internal object CreateSourceColumn( + bool autoIncrement, + IToken line, + IToken column, + IToken? path) + { + int lineNumber = ParseInt32(line); + int columnNumber = ParseInt32(column); + return CreateSourceDirective( + autoIncrement, + lineNumber, + columnNumber, + lineNumber, + columnNumber, + path); + } + + internal object CreateSourceColumnRange( + bool autoIncrement, + IToken line, + IToken startColumn, + IToken endColumn, + IToken? path) + { + int lineNumber = ParseInt32(line); + return CreateSourceDirective( + autoIncrement, + lineNumber, + ParseInt32(startColumn), + lineNumber, + ParseInt32(endColumn), + path); + } + + internal object CreateSourceLineRange( + bool autoIncrement, + IToken startLine, + IToken endLine, + IToken column, + IToken? path) + { + int columnNumber = ParseInt32(column); + return CreateSourceDirective( + autoIncrement, + ParseInt32(startLine), + columnNumber, + ParseInt32(endLine), + columnNumber, + path); + } + + internal object CreateSourceRange( + bool autoIncrement, + IToken startLine, + IToken endLine, + IToken startColumn, + IToken endColumn, + IToken? path) + => CreateSourceDirective( + autoIncrement, + ParseInt32(startLine), + ParseInt32(startColumn), + ParseInt32(endLine), + ParseInt32(endColumn), + path); + + private static SourceDirectiveValue CreateSourceDirective( + bool autoIncrement, + int startLine, + int startColumn, + int endLine, + int endColumn, + IToken? path) + => new( + autoIncrement, + startLine, + startColumn, + endLine, + endColumn, + path is null ? null : StringHelpers.ParseQuotedString(path.Text)); + + internal void EndSourceDirective(CILParser.ExtSourceSpecContext context) + { + context.HasSyntaxError = EndSemanticRoot(context); + if (context.HasSyntaxError || + context.Value is not SourceDirectiveValue value || + !CanApplySharedDirective(context)) { - // All compilation control directives that need special handling will be handled - // directly in the token stream before parsing. - // Any that reach here can be ignored. - return GrammarResult.SentinelValue.Result; + context.Value = null; + return; } - // esHead is '.line' or '#line' - this is just the keyword, actual parsing is in VisitExtSourceSpec. - public GrammarResult VisitEsHead(CILParser.EsHeadContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); + ApplySourceDirective(value); + } - public GrammarResult VisitExtSourceSpec(CILParser.ExtSourceSpecContext context) + private void ApplySourceDirective(SourceDirectiveValue value) + { + if (value.DocumentPath is not null) { - // Parse .line directive to extract source location info - // Grammar: esHead int32 (',' int32)? (':' int32 (',' int32)?)? (SQSTRING | QSTRING)? - var int32s = context.int32(); - var sqstring = context.SQSTRING(); - var qstring = context.QSTRING(); - - // Extract line/column info based on number of int32s - int startLine = 0, endLine = 0, startColumn = 0, endColumn = 0; + _currentDocumentPath = value.DocumentPath; + } - if (int32s.Length >= 1) - { - startLine = VisitInt32(int32s[0]).Value; - endLine = startLine; - } - if (int32s.Length >= 2) - { - // Could be endLine or startColumn depending on separator - string contextText = context.GetText(); - if (contextText.Contains(',') && contextText.IndexOf(',') < contextText.IndexOf(':')) - { - // Format: startLine,endLine:... - endLine = VisitInt32(int32s[1]).Value; - } - else - { - // Format: line:column... - startColumn = VisitInt32(int32s[1]).Value; - endColumn = startColumn; - } - } - if (int32s.Length >= 3) - { - startColumn = VisitInt32(int32s[2]).Value; - endColumn = startColumn; - } - if (int32s.Length >= 4) - { - endColumn = VisitInt32(int32s[3]).Value; - } + if (_currentMethod is null || _currentDocumentPath is null) + { + return; + } - // Extract filename if present - string? filePath = null; - if (sqstring is not null) - { - filePath = StringHelpers.ParseQuotedString(sqstring.GetText()); - } - else if (qstring is not null) - { - filePath = StringHelpers.ParseQuotedString(qstring.GetText()); - } + int ilOffset = _currentMethod.Definition.MethodBody.Offset; + _currentMethod.Definition.DebugInfo.DocumentPath ??= _currentDocumentPath; - // Update current document path if specified - if (filePath is not null) + EntityRegistry.SequencePoint sequencePoint; + if (value.StartLine == 0xFEEFEE) + { + sequencePoint = EntityRegistry.SequencePoint.Hidden(ilOffset); + } + else + { + int endColumn = value.EndColumn; + if (value.EndLine == value.StartLine && endColumn == value.StartColumn) { - _currentDocumentPath = filePath; + endColumn++; } - // If we're in a method, record the sequence point - if (_currentMethod is not null && _currentDocumentPath is not null) - { - int ilOffset = _currentMethod.Definition.MethodBody.Offset; - _currentMethod.Definition.DebugInfo.DocumentPath ??= _currentDocumentPath; - - // 0xFEEFEE indicates a hidden sequence point - if (startLine == 0xFEEFEE) - { - AddSequencePoint(EntityRegistry.SequencePoint.Hidden(ilOffset)); - } - else - { - if (endLine == startLine && endColumn == startColumn) - { - endColumn++; - } - - AddSequencePoint( - new EntityRegistry.SequencePoint( - ilOffset, - startLine, - startColumn, - endLine, - endColumn)); - } - - void AddSequencePoint(EntityRegistry.SequencePoint sequencePoint) - { - List sequencePoints = - _currentMethod.Definition.DebugInfo.SequencePoints; - if (sequencePoints.Count > 0 && sequencePoints[^1].ILOffset == ilOffset) - { - sequencePoints[^1] = sequencePoint; - } - else - { - sequencePoints.Add(sequencePoint); - } - } - } + sequencePoint = new EntityRegistry.SequencePoint( + ilOffset, + value.StartLine, + value.StartColumn, + value.EndLine, + endColumn); + } - return GrammarResult.SentinelValue.Result; + List sequencePoints = + _currentMethod.Definition.DebugInfo.SequencePoints; + if (sequencePoints.Count > 0 && sequencePoints[^1].ILOffset == ilOffset) + { + sequencePoints[^1] = sequencePoint; } + else + { + sequencePoints.Add(sequencePoint); + } + } + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. + internal string ParseLanguageString(IToken token) + => StringHelpers.ParseQuotedString(token.Text); + + internal object CreateLanguageDirective(string language) + => new LanguageDirectiveValue(language, null, null); - public GrammarResult VisitLanguageDecl(CILParser.LanguageDeclContext context) + internal object CreateLanguageDirective(string language, string vendor) + => new LanguageDirectiveValue(language, vendor, null); + + internal object CreateLanguageDirective( + string language, + string vendor, + string documentType) + => new LanguageDirectiveValue(language, vendor, documentType); +#pragma warning restore CA1822 + + internal void EndLanguageDirective(CILParser.LanguageDeclContext context) + { + context.HasSyntaxError = EndSemanticRoot(context); + if (context.HasSyntaxError || + context.Value is not LanguageDirectiveValue value || + !CanApplySharedDirective(context)) { - // .language languageString (',' languageString (',' languageString)?)? - // First GUID: language (e.g., C#, VB, IL) - // Second GUID: vendor (optional) - // Third GUID: document type (optional) - var strings = context.languageString(); - if (strings.Length >= 1 && Guid.TryParse(VisitLanguageString(strings[0]).Value, out var languageGuid)) - { - _currentLanguageGuid = languageGuid; - } - if (strings.Length >= 2 && Guid.TryParse(VisitLanguageString(strings[1]).Value, out var vendorGuid)) - { - _currentLanguageVendorGuid = vendorGuid; - } - if (strings.Length >= 3 && Guid.TryParse(VisitLanguageString(strings[2]).Value, out var docTypeGuid)) - { - _currentDocumentTypeGuid = docTypeGuid; - } - return GrammarResult.SentinelValue.Result; + context.Value = null; + return; } - GrammarResult ICILVisitor.VisitLanguageString(CILParser.LanguageStringContext context) => VisitLanguageString(context); - public GrammarResult.String VisitLanguageString(CILParser.LanguageStringContext context) + if (Guid.TryParse(value.Language, out Guid language)) { - if (context.SQSTRING() is not null) - { - return new(StringHelpers.ParseQuotedString(context.SQSTRING().GetText())); - } - return new(StringHelpers.ParseQuotedString(context.QSTRING().GetText())); + _currentLanguageGuid = language; + } + if (value.Vendor is not null && Guid.TryParse(value.Vendor, out Guid vendor)) + { + _currentLanguageVendorGuid = vendor; + } + if (value.DocumentType is not null && + Guid.TryParse(value.DocumentType, out Guid documentType)) + { + _currentDocumentTypeGuid = documentType; } + } + private bool CanApplySharedDirective(ParserRuleContext context) + => context.Parent is not CILParser.MethodDeclContext || _currentMethod is not null; + + public GrammarResult VisitCompControl(CILParser.CompControlContext context) + { + // Compilation control directives that require handling are consumed by the preprocessor. + return GrammarResult.SentinelValue.Result; } + +#pragma warning disable CA1822 // Parser actions own these directive side effects. + GrammarResult ICILVisitor.VisitEsHead(CILParser.EsHeadContext context) + => VisitEsHead(context); + + public static GrammarResult.Literal VisitEsHead(CILParser.EsHeadContext context) + => new(context.AutoIncrement); + + public GrammarResult VisitExtSourceSpec(CILParser.ExtSourceSpecContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + public GrammarResult VisitLanguageDecl(CILParser.LanguageDeclContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitLanguageString( + CILParser.LanguageStringContext context) + => VisitLanguageString(context); + + public static GrammarResult.String VisitLanguageString( + CILParser.LanguageStringContext context) + => new(context.Value ?? string.Empty); +#pragma warning restore CA1822 } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.Actions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.Actions.cs index fe9c813afc0cf6..5df26ad62a55d5 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.Actions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.Actions.cs @@ -14,12 +14,7 @@ internal sealed partial class GrammarActions internal void BeginTopLevelDirective() => PrepareTopLevelDeclaration(); internal void ProcessTopLevelDataDeclaration(CILParser.DataDeclContext context) - { - if (!context.HasSyntaxError) - { - _ = VisitDataDecl(context); - } - } + => _ = context; internal void ProcessTopLevelVTableDeclaration(CILParser.VtableDeclContext context) { @@ -38,12 +33,7 @@ internal void ProcessTopLevelVTableFixupDeclaration(CILParser.VtfixupDeclContext } internal void ProcessTopLevelSourceDirective(CILParser.ExtSourceSpecContext context) - { - if (!context.HasSyntaxError) - { - _ = VisitExtSourceSpec(context); - } - } + => _ = context; internal void ProcessTopLevelFileDeclaration(CILParser.FileDeclContext context) { @@ -243,12 +233,7 @@ internal void ProcessTopLevelStackReserve(IToken value) } internal void ProcessTopLevelLanguageDirective(CILParser.LanguageDeclContext context) - { - if (!context.HasSyntaxError) - { - _ = VisitLanguageDecl(context); - } - } + => _ = context; internal void ProcessTopLevelTypedef(CILParser.TypedefDeclContext context) { diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Class.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Class.cs index f02f11de84b623..602fb45b37f6d1 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Class.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Class.cs @@ -36,10 +36,7 @@ private void PrepareClassMember() internal void ProcessClassDataDeclaration(CILParser.DataDeclContext context) { PrepareClassMember(); - if (!context.HasSyntaxError) - { - _ = VisitDataDecl(context); - } + _ = context; } internal void ProcessClassSecurityDeclaration(CILParser.SecDeclContext context) @@ -57,19 +54,13 @@ internal void ProcessClassSecurityDeclaration(CILParser.SecDeclContext context) internal void ProcessClassSourceDirective(CILParser.ExtSourceSpecContext context) { PrepareClassMember(); - if (!context.HasSyntaxError) - { - _ = VisitExtSourceSpec(context); - } + _ = context; } internal void ProcessClassLanguageDirective(CILParser.LanguageDeclContext context) { PrepareClassMember(); - if (!context.HasSyntaxError) - { - _ = VisitLanguageDecl(context); - } + _ = context; } internal void ProcessClassCustomAttribute(CILParser.CustomAttrDeclContext context) diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.PropertiesEvents.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.PropertiesEvents.cs index 6b8f99e4148185..e9a32ddac182c8 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.PropertiesEvents.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.PropertiesEvents.cs @@ -188,20 +188,10 @@ internal void AddPropertyCustomAttribute( } internal void ProcessPropertySourceDirective(CILParser.ExtSourceSpecContext context) - { - if (!context.HasSyntaxError) - { - _ = VisitExtSourceSpec(context); - } - } + => _ = context; internal void ProcessPropertyLanguageDirective(CILParser.LanguageDeclContext context) - { - if (!context.HasSyntaxError) - { - _ = VisitLanguageDecl(context); - } - } + => _ = context; internal void BeginEventHeader(CILParser.EventHeadContext context) => _eventHeaderFrames.Push(new(context, _syntaxErrorCount)); @@ -322,20 +312,10 @@ internal void AddEventCustomAttribute( } internal void ProcessEventSourceDirective(CILParser.ExtSourceSpecContext context) - { - if (!context.HasSyntaxError) - { - _ = VisitExtSourceSpec(context); - } - } + => _ = context; internal void ProcessEventLanguageDirective(CILParser.LanguageDeclContext context) - { - if (!context.HasSyntaxError) - { - _ = VisitLanguageDecl(context); - } - } + => _ = context; private void EndPropertyAndEventBodies(CILParser.ClassDeclContext context) { diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.Directives.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.Directives.cs index 89ef0e03391002..742827814f1cc5 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.Directives.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.Directives.cs @@ -304,13 +304,10 @@ private void ApplyCustomAttributes( } } +#pragma warning disable CA1822 // Parser actions own these directive side effects. internal void ProcessMethodDataDeclaration(CILParser.DataDeclContext context) - { - if (_currentMethod is not null && !context.HasSyntaxError) - { - _ = VisitDataDecl(context); - } - } + => _ = context; +#pragma warning restore CA1822 internal void ProcessMethodSecurityDeclaration(CILParser.SecDeclContext context) { @@ -323,21 +320,13 @@ internal void ProcessMethodSecurityDeclaration(CILParser.SecDeclContext context) security?.Parent = _currentMethod.Definition; } +#pragma warning disable CA1822 // Parser actions own these directive side effects. internal void ProcessMethodSourceDirective(CILParser.ExtSourceSpecContext context) - { - if (_currentMethod is not null && !context.HasSyntaxError) - { - _ = VisitExtSourceSpec(context); - } - } + => _ = context; internal void ProcessMethodLanguageDirective(CILParser.LanguageDeclContext context) - { - if (_currentMethod is not null && !context.HasSyntaxError) - { - _ = VisitLanguageDecl(context); - } - } + => _ = context; +#pragma warning restore CA1822 internal void ProcessMethodCustomAttribute(CILParser.CustomDescrInMethodBodyContext context) { diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs index 8d41f4fee1714f..35e8fc1e0897a8 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs @@ -1,174 +1,442 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System; -using System.Buffers.Binary; using System.Collections.Generic; using System.Collections.Immutable; using System.Diagnostics; -using System.Globalization; -using System.IO; -using System.Linq; using System.Reflection; using System.Reflection.Metadata; -using System.Reflection.Metadata.Ecma335; -using System.Reflection.PortableExecutable; -using System.Runtime.InteropServices; -using System.Security.Cryptography; -using System.Text; using Antlr4.Runtime; -using Antlr4.Runtime.Misc; -using Antlr4.Runtime.Tree; -namespace ILAssembler +namespace ILAssembler; + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. +internal sealed partial class GrammarActions { -#pragma warning disable CA1822 // Mark members as static - internal sealed partial class GrammarActions : ICILVisitor + private readonly Stack _securityAttributeSetFrames = new(); + private readonly Stack _securityNameValuePairFrames = new(); + + private abstract record SecurityDeclarationValue(DeclarativeSecurityAction Action); + + private sealed record PermissionDeclarationValue( + DeclarativeSecurityAction Action, + object PermissionType, + object? Value) : SecurityDeclarationValue(Action); + + private sealed record RawPermissionSetValue( + DeclarativeSecurityAction Action, + ImmutableArray Value) : SecurityDeclarationValue(Action); + + private sealed record StringPermissionSetValue( + DeclarativeSecurityAction Action, + string Value) : SecurityDeclarationValue(Action); + + private sealed record AttributePermissionSetValue( + DeclarativeSecurityAction Action, + ImmutableArray Attributes) : SecurityDeclarationValue(Action); + + private sealed record SecurityAttributeValue( + string? Name, + TypeSpecificationValue? Type, + ImmutableArray Arguments); + + private sealed record SecurityNameValuePairValue(string Name, SecurityCaValue Value); + + private abstract record SecurityCaValue; + + private sealed record SecurityBooleanValue(bool Value) : SecurityCaValue; + + private sealed record SecurityInt32Value(int Value) : SecurityCaValue; + + private sealed record SecurityStringValue(string Value) : SecurityCaValue; + + private sealed record SecurityEnumValue( + ClassNameValue Type, + byte Size, + int Value) : SecurityCaValue; + + private sealed class SecurityAttributeSetFrame { - GrammarResult ICILVisitor.VisitSecAction(CILParser.SecActionContext context) => VisitSecAction(context); - public static GrammarResult.Literal VisitSecAction(CILParser.SecActionContext context) + public SecurityAttributeSetFrame(CILParser.SecAttrSetBlobContext owner) { - return context.GetText() switch - { - "request" => new(DeclarativeSecurityAction.Request), - "demand" => new(DeclarativeSecurityAction.Demand), - "assert" => new(DeclarativeSecurityAction.Assert), - "deny" => new(DeclarativeSecurityAction.Deny), - "permitonly" => new(DeclarativeSecurityAction.PermitOnly), - "linkcheck" => new(DeclarativeSecurityAction.LinkDemand), - "inheritcheck" => new(DeclarativeSecurityAction.InheritanceDemand), - "reqmin" => new(DeclarativeSecurityAction.RequestMinimum), - "reqopt" => new(DeclarativeSecurityAction.RequestOptional), - "reqrefuse" => new(DeclarativeSecurityAction.RequestRefuse), - "prejitgrant" => new(DeclarativeSecurityAction.PrejitGrant), - "prejitdeny" => new(DeclarativeSecurityAction.PrejitDeny), - "noncasdemand" => new(DeclarativeSecurityAction.NonCasDemand), - "noncaslinkdemand" => new(DeclarativeSecurityAction.NonCasLinkDemand), - "noncasinheritance" => new(DeclarativeSecurityAction.NonCasInheritanceDemand), - _ => throw new UnreachableException() - }; + Owner = owner; } - GrammarResult ICILVisitor.VisitCaValue(CILParser.CaValueContext context) => VisitCaValue(context); - public GrammarResult.FormattedBlob VisitCaValue(CILParser.CaValueContext context) + public CILParser.SecAttrSetBlobContext Owner { get; } + + public ImmutableArray.Builder? Attributes { get; set; } + } + + private sealed class SecurityNameValuePairsFrame + { + public SecurityNameValuePairsFrame(CILParser.NameValPairsContext owner) { - BlobBuilder blob = new(); - if (context.truefalse() is CILParser.TruefalseContext truefalse) - { - blob.WriteByte((byte)SerializationTypeCode.Boolean); - blob.WriteBoolean(VisitTruefalse(truefalse).Value); - } - else if (context.compQstring() is CILParser.CompQstringContext str) - { - blob.WriteUTF8(VisitCompQstring(str).Value); - blob.WriteByte(0); - } - else if (context.className() is CILParser.ClassNameContext className) - { - EntityRegistry.TypeEntity name = VisitClassName(className).Value; - blob.WriteByte((byte)SerializationTypeCode.Enum); - blob.WriteUTF8( - (name as EntityRegistry.IHasReflectionNotation)?.ReflectionNotation ?? string.Empty); - blob.WriteByte(0); - byte size = context.INT8() is not null - ? (byte)1 - : context.INT16() is not null - ? (byte)2 - : (byte)4; - blob.WriteByte(size); - blob.WriteInt32(VisitInt32(context.int32()).Value); - } - else - { - blob.WriteByte((byte)SerializationTypeCode.Int32); - blob.WriteInt32(VisitInt32(context.int32()).Value); - } + Owner = owner; + } + + public CILParser.NameValPairsContext Owner { get; } + + public ImmutableArray.Builder? Pairs { get; set; } + } - return new(blob); + internal DeclarativeSecurityAction ParseSecurityAction(IToken token) + => token.Text switch + { + "request" => DeclarativeSecurityAction.Request, + "demand" => DeclarativeSecurityAction.Demand, + "assert" => DeclarativeSecurityAction.Assert, + "deny" => DeclarativeSecurityAction.Deny, + "permitonly" => DeclarativeSecurityAction.PermitOnly, + "linkcheck" => DeclarativeSecurityAction.LinkDemand, + "inheritcheck" => DeclarativeSecurityAction.InheritanceDemand, + "reqmin" => DeclarativeSecurityAction.RequestMinimum, + "reqopt" => DeclarativeSecurityAction.RequestOptional, + "reqrefuse" => DeclarativeSecurityAction.RequestRefuse, + "prejitgrant" => DeclarativeSecurityAction.PrejitGrant, + "prejitdeny" => DeclarativeSecurityAction.PrejitDeny, + "noncasdemand" => DeclarativeSecurityAction.NonCasDemand, + "noncaslinkdemand" => DeclarativeSecurityAction.NonCasLinkDemand, + "noncasinheritance" => DeclarativeSecurityAction.NonCasInheritanceDemand, + _ => throw new UnreachableException(), + }; + + internal object CreateNamedPermissionDeclaration( + DeclarativeSecurityAction action, + object? permissionType, + object? pairs) + => new PermissionDeclarationValue( + action, + GetTypeSpecificationValue(permissionType), + pairs); + + internal object CreateStructuredPermissionDeclaration( + DeclarativeSecurityAction action, + object? permissionType, + object? value) + => new PermissionDeclarationValue( + action, + GetTypeSpecificationValue(permissionType), + value); + + internal object CreateEmptyPermissionDeclaration( + DeclarativeSecurityAction action, + object? permissionType) + => new PermissionDeclarationValue( + action, + GetTypeSpecificationValue(permissionType), + null); + + internal object CreateRawPermissionSetDeclaration( + DeclarativeSecurityAction action, + ImmutableArray value) + => new RawPermissionSetValue(action, value); + + internal object CreateStringPermissionSetDeclaration( + DeclarativeSecurityAction action, + string value) + => new StringPermissionSetValue(action, value); + + internal object CreateAttributePermissionSetDeclaration( + DeclarativeSecurityAction action, + object? value) + => new AttributePermissionSetValue(action, GetSecurityAttributes(value)); + + internal void EndSecurityDeclaration(CILParser.SecDeclContext context) + { + context.HasSyntaxError = EndSemanticRoot(context); + if (context.HasSyntaxError) + { + context.Value = null; } - GrammarResult ICILVisitor.VisitSecAttrBlob(CILParser.SecAttrBlobContext context) => VisitSecAttrBlob(context); - public GrammarResult.FormattedBlob VisitSecAttrBlob(CILParser.SecAttrBlobContext context) + } + + internal void BeginSecurityAttributeSet(CILParser.SecAttrSetBlobContext context) + => _securityAttributeSetFrames.Push(new(context)); + + internal void AddSecurityAttribute( + CILParser.SecAttrSetBlobContext context, + object? value) + { + if (TryGetSecurityAttributeSetFrame(context) is { } frame && + value is SecurityAttributeValue attribute) { - var blob = new BlobBuilder(); + (frame.Attributes ??= ImmutableArray.CreateBuilder()) + .Add(attribute); + } + } - string attributeName = string.Empty; + internal object EndSecurityAttributeSet(CILParser.SecAttrSetBlobContext context) + { + if (TryGetSecurityAttributeSetFrame(context) is not { } frame) + { + return ImmutableArray.Empty; + } - if (context.typeSpec() is CILParser.TypeSpecContext typeSpec && VisitTypeSpec(typeSpec).Value is EntityRegistry.IHasReflectionNotation reflectionNotation) - { - attributeName = reflectionNotation.ReflectionNotation; - } - else if (context.SQSTRING() is { } sqstring) - { - attributeName = StringHelpers.ParseQuotedString(sqstring.GetText()); - } + _securityAttributeSetFrames.Pop(); + return frame.Attributes?.ToImmutable() ?? ImmutableArray.Empty; + } + + internal object CreateNamedSecurityAttribute(IToken name, object? arguments) + => new SecurityAttributeValue( + StringHelpers.ParseQuotedString(name.Text), + null, + GetSecurityAttributeArguments(arguments)); - blob.WriteSerializedString(attributeName); - VisitCustomBlobNVPairs(context.customBlobNVPairs()).Value.WriteContentTo(blob); + internal object CreateTypedSecurityAttribute(object? type, object? arguments) + => new SecurityAttributeValue( + null, + GetTypeSpecificationValue(type), + GetSecurityAttributeArguments(arguments)); - return new(blob); + internal void BeginSecurityNameValuePairs(CILParser.NameValPairsContext context) + => _securityNameValuePairFrames.Push(new(context)); + + internal void AddSecurityNameValuePair(CILParser.NameValPairsContext context, object? value) + { + if (TryGetSecurityNameValuePairsFrame(context) is { } frame && + value is SecurityNameValuePairValue pair) + { + (frame.Pairs ??= ImmutableArray.CreateBuilder()) + .Add(pair); } + } - GrammarResult ICILVisitor.VisitSecAttrSetBlob(CILParser.SecAttrSetBlobContext context) => VisitSecAttrSetBlob(context); - public GrammarResult.FormattedBlob VisitSecAttrSetBlob(CILParser.SecAttrSetBlobContext context) + internal object EndSecurityNameValuePairs(CILParser.NameValPairsContext context) + { + if (TryGetSecurityNameValuePairsFrame(context) is not { } frame) { - BlobBuilder blob = new(); - var secAttributes = context.secAttrBlob(); - blob.WriteByte((byte)'.'); - blob.WriteCompressedInteger(secAttributes.Length); - foreach (var secAttribute in secAttributes) + return ImmutableArray.Empty; + } + + _securityNameValuePairFrames.Pop(); + return frame.Pairs?.ToImmutable() ?? ImmutableArray.Empty; + } + + internal object CreateSecurityNameValuePair(string name, object? value) + => new SecurityNameValuePairValue(name, GetSecurityCaValue(value)); + + internal object CreateSecurityBooleanValue(bool value) => new SecurityBooleanValue(value); + + internal object CreateSecurityInt32Value(IToken value) + => new SecurityInt32Value(ParseInt32(value)); + + internal object CreateSecurityStringValue(string value) => new SecurityStringValue(value); + + internal object CreateSecurityEnumValue(object? type, IToken kind, IToken value) + => new SecurityEnumValue( + GetClassNameValue(type), + kind.Text switch { - VisitSecAttrBlob(secAttribute).Value.WriteContentTo(blob); - } - return new(blob); + "int8" => 1, + "int16" => 2, + "int32" => 4, + _ => throw new UnreachableException(), + }, + ParseInt32(value)); + + internal object CreateSecurityEnumValue(object? type, IToken value) + => new SecurityEnumValue(GetClassNameValue(type), 4, ParseInt32(value)); + + private EntityRegistry.DeclarativeSecurityAttributeEntity? MaterializeSecurityDeclaration( + SecurityDeclarationValue value, + CILParser.SecDeclContext context) + { + if (value is PermissionDeclarationValue) + { + ReportError( + DiagnosticIds.UnsupportedSecurityDeclaration, + DiagnosticMessageTemplates.UnsupportedSecurityDeclaration, + context); + return null; } - GrammarResult ICILVisitor.VisitSecDecl(CILParser.SecDeclContext context) => VisitSecDecl(context); - public GrammarResult.Literal VisitSecDecl(CILParser.SecDeclContext context) + BlobBuilder permissionSet = value switch { - if (context.PERMISSION() is not null) - { - ReportError(DiagnosticIds.UnsupportedSecurityDeclaration, - DiagnosticMessageTemplates.UnsupportedSecurityDeclaration, - context); - return new(null); - } - DeclarativeSecurityAction action = VisitSecAction(context.secAction()).Value; - BlobBuilder value; - if (context.secAttrSetBlob() is CILParser.SecAttrSetBlobContext setBlob) - { - value = VisitSecAttrSetBlob(setBlob).Value; - } - else if (context.bytes() is CILParser.BytesContext bytes) - { - value = new(); - value.WriteBytes(VisitBytes(bytes)); - } - else if (context.compQstring() is CILParser.CompQstringContext str) - { - value = new BlobBuilder(); - value.WriteUTF16(VisitCompQstring(str).Value); - value.WriteUTF16("\0"); - } - else - { + RawPermissionSetValue raw => CreateRawPermissionSet(raw.Value), + StringPermissionSetValue text => CreateStringPermissionSet(text.Value), + AttributePermissionSetValue attributes => + MaterializeSecurityAttributeSet(attributes.Attributes), + _ => throw new UnreachableException(), + }; + return _entityRegistry.CreateDeclarativeSecurityAttribute(value.Action, permissionSet); + } + + private static BlobBuilder CreateRawPermissionSet(ImmutableArray value) + { + BlobBuilder blob = new(value.Length); + blob.WriteBytes(value); + return blob; + } + + private static BlobBuilder CreateStringPermissionSet(string value) + { + BlobBuilder blob = new(); + blob.WriteUTF16(value); + blob.WriteUTF16("\0"); + return blob; + } + + private BlobBuilder MaterializeSecurityAttributeSet( + ImmutableArray attributes) + { + BlobBuilder blob = new(); + blob.WriteByte((byte)'.'); + blob.WriteCompressedInteger(attributes.Length); + foreach (SecurityAttributeValue attribute in attributes) + { + MaterializeSecurityAttribute(attribute).WriteContentTo(blob); + } + + return blob; + } + + private BlobBuilder MaterializeSecurityAttribute(SecurityAttributeValue attribute) + { + string attributeName = attribute.Name ?? string.Empty; + if (attribute.Type is { } type && + ResolveTypeSpecification(type) is EntityRegistry.IHasReflectionNotation reflectionNotation) + { + attributeName = reflectionNotation.ReflectionNotation; + } + + BlobBuilder blob = new(); + blob.WriteSerializedString(attributeName); + WriteCustomBlobNamedArguments(blob, attribute.Arguments); + return blob; + } + + private BlobBuilder MaterializeSecurityCaValue(SecurityCaValue value) + { + BlobBuilder blob = new(); + switch (value) + { + case SecurityBooleanValue boolean: + blob.WriteByte((byte)SerializationTypeCode.Boolean); + blob.WriteBoolean(boolean.Value); + break; + case SecurityInt32Value integer: + blob.WriteByte((byte)SerializationTypeCode.Int32); + blob.WriteInt32(integer.Value); + break; + case SecurityStringValue text: + blob.WriteUTF8(text.Value); + blob.WriteByte(0); + break; + case SecurityEnumValue enumeration: + blob.WriteByte((byte)SerializationTypeCode.Enum); + EntityRegistry.TypeEntity enumType = ResolveClassName(enumeration.Type); + blob.WriteUTF8( + (enumType as EntityRegistry.IHasReflectionNotation)?.ReflectionNotation + ?? string.Empty); + blob.WriteByte(0); + blob.WriteByte(enumeration.Size); + blob.WriteInt32(enumeration.Value); + break; + default: throw new UnreachableException(); - } - return new(_entityRegistry.CreateDeclarativeSecurityAttribute(action, value)); } - GrammarResult ICILVisitor.VisitNameValPair(CILParser.NameValPairContext context) => VisitNameValPair(context); - public GrammarResult.Literal> VisitNameValPair(CILParser.NameValPairContext context) + return blob; + } + + private static ImmutableArray GetSecurityAttributes(object? value) + => value is ImmutableArray attributes ? attributes : []; + + private static ImmutableArray GetSecurityAttributeArguments( + object? value) + => value is ImmutableArray arguments ? arguments : []; + + private static SecurityCaValue GetSecurityCaValue(object? value) + => value as SecurityCaValue ?? new SecurityInt32Value(0); + + private SecurityAttributeSetFrame? TryGetSecurityAttributeSetFrame( + CILParser.SecAttrSetBlobContext context) + { + Debug.Assert(_securityAttributeSetFrames.Count > 0); + SecurityAttributeSetFrame? frame = + _securityAttributeSetFrames.Count == 0 ? null : _securityAttributeSetFrames.Peek(); + Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); + return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; + } + + private SecurityNameValuePairsFrame? TryGetSecurityNameValuePairsFrame( + CILParser.NameValPairsContext context) + { + Debug.Assert(_securityNameValuePairFrames.Count > 0); + SecurityNameValuePairsFrame? frame = + _securityNameValuePairFrames.Count == 0 ? null : _securityNameValuePairFrames.Peek(); + Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); + return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; + } + + GrammarResult ICILVisitor.VisitSecAction(CILParser.SecActionContext context) + => VisitSecAction(context); + + public static GrammarResult.Literal VisitSecAction( + CILParser.SecActionContext context) + => new(context.Value); + + GrammarResult ICILVisitor.VisitSecDecl(CILParser.SecDeclContext context) + => VisitSecDecl(context); + + public GrammarResult.Literal VisitSecDecl( + CILParser.SecDeclContext context) + => new( + context.Value is SecurityDeclarationValue value + ? MaterializeSecurityDeclaration(value, context) + : null); + + GrammarResult ICILVisitor.VisitSecAttrSetBlob( + CILParser.SecAttrSetBlobContext context) + => VisitSecAttrSetBlob(context); + + public GrammarResult.FormattedBlob VisitSecAttrSetBlob( + CILParser.SecAttrSetBlobContext context) + => new(MaterializeSecurityAttributeSet(GetSecurityAttributes(context.Value))); + + GrammarResult ICILVisitor.VisitSecAttrBlob(CILParser.SecAttrBlobContext context) + => VisitSecAttrBlob(context); + + public GrammarResult.FormattedBlob VisitSecAttrBlob(CILParser.SecAttrBlobContext context) + => new( + MaterializeSecurityAttribute( + context.Value as SecurityAttributeValue + ?? new SecurityAttributeValue(string.Empty, null, []))); + + GrammarResult ICILVisitor.VisitNameValPairs(CILParser.NameValPairsContext context) + => VisitNameValPairs(context); + + public GrammarResult.Sequence> VisitNameValPairs( + CILParser.NameValPairsContext context) + { + ImmutableArray values = + context.Value is ImmutableArray pairs ? pairs : []; + ImmutableArray>.Builder result = + ImmutableArray.CreateBuilder>(values.Length); + foreach (SecurityNameValuePairValue pair in values) { - return new(new( - VisitCompQstring(context.compQstring()).Value, - VisitCaValue(context.caValue()).Value)); + result.Add(new(pair.Name, MaterializeSecurityCaValue(pair.Value))); } - GrammarResult ICILVisitor.VisitNameValPairs(CILParser.NameValPairsContext context) => VisitNameValPairs(context); - public GrammarResult.Sequence> VisitNameValPairs(CILParser.NameValPairsContext context) - => new(context.nameValPair() - .Select(pair => VisitNameValPair(pair).Value) - .ToImmutableArray()); + return new(result.MoveToImmutable()); + } + + GrammarResult ICILVisitor.VisitNameValPair(CILParser.NameValPairContext context) + => VisitNameValPair(context); + public GrammarResult.Literal> VisitNameValPair( + CILParser.NameValPairContext context) + { + SecurityNameValuePairValue value = + context.Value as SecurityNameValuePairValue + ?? new SecurityNameValuePairValue(string.Empty, new SecurityInt32Value(0)); + return new(new(value.Name, MaterializeSecurityCaValue(value.Value))); } + + GrammarResult ICILVisitor.VisitCaValue(CILParser.CaValueContext context) + => VisitCaValue(context); + + public GrammarResult.FormattedBlob VisitCaValue(CILParser.CaValueContext context) + => new(MaterializeSecurityCaValue(GetSecurityCaValue(context.Value))); } +#pragma warning restore CA1822 diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs index 2619aadd87f419..e6fa14032ce1d9 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs @@ -56,6 +56,9 @@ _currentMethod is null && _customBlobArgumentFrames.Count == 0 && _customBlobNamedArgumentFrames.Count == 0 && _serializationSequenceFrames.Count == 0 + && _dataDeclarationFrames.Count == 0 + && _securityAttributeSetFrames.Count == 0 + && _securityNameValuePairFrames.Count == 0 && _pendingClassMethodOverrides.Count == 0, "Per-document semantic state must be released by the owning rule's finally block."); @@ -91,7 +94,11 @@ _currentMethod is null _customBlobArgumentFrames.Clear(); _customBlobNamedArgumentFrames.Clear(); _serializationSequenceFrames.Clear(); + _dataDeclarationFrames.Clear(); + _securityAttributeSetFrames.Clear(); + _securityNameValuePairFrames.Clear(); _pendingClassMethodOverrides.Clear(); + _currentDocumentPath = null; _syntaxErrorCount = 0; } } diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 index 98eefb2aec44c3..76ce82555f4ddd 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 @@ -441,6 +441,8 @@ finally {_localctx.Value = Actions.EndComposedString(_localctx); EndParseTreeMod WS: [ \t\r\n] -> skip; SINGLE_LINE_COMMENT: '//' ~[\r\n]* -> skip; COMMENT: '/*' .*? '*/' -> skip; +PERMISSION: '.permission'; +PERMISSIONSET: '.permissionset'; decls @init {BeginStreaming();} @@ -518,15 +520,22 @@ finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParse mscorlib: '.mscorlib'; -languageDecl returns [bool HasSyntaxError] -@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +languageDecl returns [object Value, bool HasSyntaxError] +@init {BeginStreaming(); Actions.BeginSemanticRoot(_localctx);} : - '.language' languageString - | '.language' languageString ',' languageString - | '.language' languageString ',' languageString ',' languageString; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} + '.language' language = languageString + {_localctx.Value = Actions.CreateLanguageDirective($language.Value);} + | '.language' language = languageString ',' vendor = languageString + {_localctx.Value = Actions.CreateLanguageDirective($language.Value, $vendor.Value);} + | '.language' language = languageString ',' vendor = languageString ',' documentType = languageString + {_localctx.Value = Actions.CreateLanguageDirective($language.Value, $vendor.Value, $documentType.Value);}; +finally {Actions.EndLanguageDirective(_localctx); EndParseTreeMode();} -languageString: SQSTRING | QSTRING; +languageString returns [string Value] +@after {_localctx.Value = Actions.ParseLanguageString(_localctx.Start);} +: + SQSTRING + | QSTRING; typelist @init {Actions.BeginTopLevelTypeList();} @@ -772,27 +781,43 @@ implList returns [object Value] finally {_localctx.Value = Actions.EndInterfaceList(_localctx);} /* External source declarations */ -esHead: '.line' | '#line'; - -extSourceSpec returns [bool HasSyntaxError] -@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} -: - esHead int32 SQSTRING - | esHead int32 - | esHead int32 ':' int32 SQSTRING - | esHead int32 ':' int32 - | esHead int32 ':' int32 ',' int32 SQSTRING - | esHead int32 ':' int32 ',' int32 - | esHead int32 ',' int32 ':' int32 SQSTRING - | esHead int32 ',' int32 ':' int32 - | esHead int32 ',' int32 ':' int32 ',' int32 SQSTRING - | esHead int32 ',' int32 ':' int32 ',' int32 - | esHead int32 QSTRING - | esHead int32 ':' int32 QSTRING - | esHead int32 ':' int32 ',' int32 QSTRING - | esHead int32 ',' int32 ':' int32 QSTRING - | esHead int32 ',' int32 ':' int32 ',' int32 QSTRING; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} +esHead returns [bool AutoIncrement] +@after {_localctx.AutoIncrement = Actions.IsAutoIncrementSourceDirective(_localctx.Start);} +: + '.line' + | '#line'; + +extSourceSpec returns [object Value, bool HasSyntaxError] +@init {BeginStreaming(); Actions.BeginSemanticRoot(_localctx);} +: + head = esHead line = int32 path = (SQSTRING | QSTRING)? + {_localctx.Value = Actions.CreateSourceLine($head.AutoIncrement, $line.start, $path);} + | head = esHead line = int32 ':' column = int32 path = (SQSTRING | QSTRING)? + {_localctx.Value = Actions.CreateSourceColumn($head.AutoIncrement, $line.start, $column.start, $path);} + | head = esHead line = int32 ':' startColumn = int32 ',' endColumn = int32 path = (SQSTRING | QSTRING)? + {_localctx.Value = Actions.CreateSourceColumnRange( + $head.AutoIncrement, + $line.start, + $startColumn.start, + $endColumn.start, + $path);} + | head = esHead startLine = int32 ',' endLine = int32 ':' column = int32 path = (SQSTRING | QSTRING)? + {_localctx.Value = Actions.CreateSourceLineRange( + $head.AutoIncrement, + $startLine.start, + $endLine.start, + $column.start, + $path);} + | head = esHead startLine = int32 ',' endLine = int32 ':' startColumn = int32 ',' endColumn = int32 + path = (SQSTRING | QSTRING)? + {_localctx.Value = Actions.CreateSourceRange( + $head.AutoIncrement, + $startLine.start, + $endLine.start, + $startColumn.start, + $endColumn.start, + $path);}; +finally {Actions.EndSourceDirective(_localctx); EndParseTreeMode();} /* Manifest declarations */ fileDecl returns [bool HasSyntaxError] @@ -1146,30 +1171,57 @@ nativeUint returns [byte Value]: 'native' ('unsigned' INT | UINT) {_localctx.Value = Actions.GetNativeUIntType();}; /* Security declarations */ -secDecl returns [bool HasSyntaxError] -@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +secDecl returns [object Value, bool HasSyntaxError] +@init {BeginStreaming(); Actions.BeginSemanticRoot(_localctx);} +: + PERMISSION action = secAction permissionType = typeSpec '(' pairs = nameValPairs ')' + {_localctx.Value = Actions.CreateNamedPermissionDeclaration( + $action.Value, + $permissionType.Value, + $pairs.Value);} + | PERMISSION action = secAction permissionType = typeSpec '=' '{' structuredValue = customBlobDescr '}' + {_localctx.Value = Actions.CreateStructuredPermissionDeclaration( + $action.Value, + $permissionType.Value, + $structuredValue.Value);} + | PERMISSION action = secAction permissionType = typeSpec + {_localctx.Value = Actions.CreateEmptyPermissionDeclaration($action.Value, $permissionType.Value);} + | PERMISSIONSET action = secAction '=' 'bytearray'? '(' rawValue = bytes ')' + {_localctx.Value = Actions.CreateRawPermissionSetDeclaration($action.Value, $rawValue.Value);} + | PERMISSIONSET action = secAction 'bytearray' '(' rawValue = bytes ')' + {_localctx.Value = Actions.CreateRawPermissionSetDeclaration($action.Value, $rawValue.Value);} + | PERMISSIONSET action = secAction textValue = compQstring + {_localctx.Value = Actions.CreateStringPermissionSetDeclaration($action.Value, $textValue.Value);} + | PERMISSIONSET action = secAction '=' '{' attributes = secAttrSetBlob '}' + {_localctx.Value = Actions.CreateAttributePermissionSetDeclaration($action.Value, $attributes.Value);}; +finally {Actions.EndSecurityDeclaration(_localctx); EndParseTreeMode();} + +secAttrSetBlob returns [object Value] +@init {Actions.BeginSecurityAttributeSet(_localctx);} : - PERMISSION secAction typeSpec '(' nameValPairs ')' - | PERMISSION secAction typeSpec '=' '{' customBlobDescr '}' - | PERMISSION secAction typeSpec - | PERMISSIONSET secAction '=' 'bytearray'? '(' bytes ')' - | PERMISSIONSET secAction 'bytearray' '(' bytes ')' - | PERMISSIONSET secAction compQstring - | PERMISSIONSET secAction '=' '{' secAttrSetBlob '}'; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} - - PERMISSION: '.permission'; - PERMISSIONSET: '.permissionset'; - - secAttrSetBlob: | (secAttrBlob ',')* secAttrBlob; + /* EMPTY */ + | (attribute = secAttrBlob {Actions.AddSecurityAttribute(_localctx, $attribute.Value);} ',')* + tail = secAttrBlob {Actions.AddSecurityAttribute(_localctx, $tail.Value);} +; +finally {_localctx.Value = Actions.EndSecurityAttributeSet(_localctx);} -secAttrBlob: - 'class' SQSTRING '=' '{' customBlobNVPairs '}' - | typeSpec '=' '{' customBlobNVPairs '}'; +secAttrBlob returns [object Value]: + 'class' name = SQSTRING '=' '{' arguments = customBlobNVPairs '}' + {_localctx.Value = Actions.CreateNamedSecurityAttribute($name, $arguments.Value);} + | securityType = typeSpec '=' '{' arguments = customBlobNVPairs '}' + {_localctx.Value = Actions.CreateTypedSecurityAttribute($securityType.Value, $arguments.Value);}; -nameValPairs: (nameValPair ',')* nameValPair; +nameValPairs returns [object Value] +@init {Actions.BeginSecurityNameValuePairs(_localctx);} +: + (pair = nameValPair {Actions.AddSecurityNameValuePair(_localctx, $pair.Value);} ',')* + tail = nameValPair {Actions.AddSecurityNameValuePair(_localctx, $tail.Value);} +; +finally {_localctx.Value = Actions.EndSecurityNameValuePairs(_localctx);} -nameValPair: compQstring '=' caValue; +nameValPair returns [object Value]: + name = compQstring '=' value = caValue + {_localctx.Value = Actions.CreateSecurityNameValuePair($name.Value, $value.Value);}; truefalse returns [bool Value] @after {_localctx.Value = Actions.ParseBoolean(_localctx.Start);} @@ -1177,17 +1229,23 @@ truefalse returns [bool Value] 'true' | 'false'; -caValue: - truefalse - | int32 - | INT32_ '(' int32 ')' - | compQstring - | className '(' INT8 ':' int32 ')' - | className '(' INT16 ':' int32 ')' - | className '(' INT32_ ':' int32 ')' - | className '(' int32 ')'; - -secAction: +caValue returns [object Value]: + booleanValue = truefalse {_localctx.Value = Actions.CreateSecurityBooleanValue($booleanValue.Value);} + | integerValue = int32 {_localctx.Value = Actions.CreateSecurityInt32Value($integerValue.start);} + | INT32_ '(' integerValue = int32 ')' {_localctx.Value = Actions.CreateSecurityInt32Value($integerValue.start);} + | textValue = compQstring {_localctx.Value = Actions.CreateSecurityStringValue($textValue.Value);} + | enumType = className '(' kind = INT8 ':' enumValue = int32 ')' + {_localctx.Value = Actions.CreateSecurityEnumValue($enumType.Value, $kind, $enumValue.start);} + | enumType = className '(' kind = INT16 ':' enumValue = int32 ')' + {_localctx.Value = Actions.CreateSecurityEnumValue($enumType.Value, $kind, $enumValue.start);} + | enumType = className '(' kind = INT32_ ':' enumValue = int32 ')' + {_localctx.Value = Actions.CreateSecurityEnumValue($enumType.Value, $kind, $enumValue.start);} + | enumType = className '(' enumValue = int32 ')' + {_localctx.Value = Actions.CreateSecurityEnumValue($enumType.Value, $enumValue.start);}; + +secAction returns [System.Reflection.DeclarativeSecurityAction Value] +@after {_localctx.Value = Actions.ParseSecurityAction(_localctx.Start);} +: 'request' | 'demand' | 'assert' @@ -1789,39 +1847,48 @@ handlerBlock returns [object Value]: /* Data declaration */ dataDecl returns [bool HasSyntaxError] -@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +@init {BeginStreaming(); Actions.BeginDataDeclaration(_localctx);} : ddHead ddBody ; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} +finally {Actions.EndDataDeclaration(_localctx); EndParseTreeMode();} -ddHead: '.data' tls id '=' | '.data' tls; +ddHead: + '.data' section = tls name = id '=' + {Actions.SetDataDeclarationHeader(_localctx, $section.Value, $name.start);} + | '.data' section = tls + {Actions.SetAnonymousDataDeclarationHeader(_localctx, $section.Value);}; -tls: /* EMPTY */ | 'tls' | 'cil'; +tls returns [byte Value] +@init {_localctx.Value = Actions.GetMappedDataSection();} +: + /* EMPTY */ + | 'tls' {_localctx.Value = Actions.GetTlsDataSection();} + | 'cil' {_localctx.Value = Actions.GetCilDataSection();}; ddBody: '{' ddItemList '}' | ddItem+; ddItemList: (ddItem ',')* ddItem; -ddItemCount: /* EMPTY */ | '[' int32 ']'; +ddItemCount returns [int Value] +@init {_localctx.Value = 1;} +: + /* EMPTY */ + | '[' count = int32 ']' {_localctx.Value = Actions.ParseDataItemCount($count.start);}; ddItem: - CHAR PTR '(' compQstring ')' - | REF '(' id ')' - | REF id - | 'bytearray' '(' bytes ')' - | FLOAT32 '(' float64 ')' ddItemCount - | FLOAT64_ '(' float64 ')' ddItemCount - | INT64_ '(' int64 ')' ddItemCount - | INT32_ '(' int32 ')' ddItemCount - | INT16 '(' int32 ')' ddItemCount - | INT8 '(' int32 ')' ddItemCount - | FLOAT32 ddItemCount - | FLOAT64_ ddItemCount - | INT64_ ddItemCount - | INT32_ ddItemCount - | INT16 ddItemCount - | INT8 ddItemCount; + CHAR PTR '(' stringValue = compQstring ')' {Actions.AddDataString(_localctx, $stringValue.Value);} + | REF '(' target = id ')' {Actions.AddDataReference(_localctx, $target.start);} + | REF target = id {Actions.AddDataReference(_localctx, $target.start);} + | 'bytearray' '(' byteValue = bytes ')' {Actions.AddDataBytes(_localctx, $byteValue.Value);} + | kind = (FLOAT32 | FLOAT64_) '(' floatingValue = float64 ')' count = ddItemCount + {Actions.AddFloatingPointData(_localctx, $kind, $floatingValue.Value, $count.Value);} + | kind = INT64_ '(' int64Value = int64 ')' count = ddItemCount + {Actions.AddInt64Data(_localctx, $kind, $int64Value.start, $count.Value);} + | kind = (INT32_ | INT16 | INT8) '(' integerValue = int32 ')' count = ddItemCount + {Actions.AddIntegerData(_localctx, $kind, $integerValue.start, $count.Value);} + | kind = (FLOAT32 | FLOAT64_ | INT64_ | INT32_ | INT16 | INT8) count = ddItemCount + {Actions.AddZeroData(_localctx, $kind, $count.Value);}; /* Default values declaration for fields, parameters and verbal form of CA blob description */ fieldSerInit returns [System.Reflection.Metadata.BlobBuilder Value]: diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.interp b/src/tools/ilasm/src/ILAssembler/gen/CIL.interp index aaa9b19bb6ccd6..0755f16acc7c1f 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.interp +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.interp @@ -800,4 +800,4 @@ manifestResDecl atn: -[4, 1, 305, 3665, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 373, 8, 1, 10, 1, 12, 1, 376, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 383, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 5, 3, 390, 8, 3, 10, 3, 12, 3, 393, 9, 3, 1, 3, 1, 3, 1, 3, 1, 4, 5, 4, 399, 8, 4, 10, 4, 12, 4, 402, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 490, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 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, 536, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 5, 15, 545, 8, 15, 10, 15, 12, 15, 548, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 577, 8, 18, 1, 19, 1, 19, 3, 19, 581, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 599, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 626, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 654, 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, 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, 694, 8, 23, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 705, 8, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 5, 27, 715, 8, 27, 10, 27, 12, 27, 718, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 728, 8, 28, 10, 28, 12, 28, 731, 9, 28, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 3, 30, 738, 8, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 760, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 773, 8, 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, 34, 1, 34, 1, 34, 1, 34, 5, 34, 794, 8, 34, 10, 34, 12, 34, 797, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 5, 37, 813, 8, 37, 10, 37, 12, 37, 816, 9, 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, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 888, 8, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 895, 8, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 902, 8, 40, 1, 41, 5, 41, 905, 8, 41, 10, 41, 12, 41, 908, 9, 41, 1, 42, 1, 42, 1, 42, 1, 42, 5, 42, 914, 8, 42, 10, 42, 12, 42, 917, 9, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 1027, 8, 44, 1, 45, 1, 45, 5, 45, 1031, 8, 45, 10, 45, 12, 45, 1034, 9, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 1047, 8, 45, 10, 45, 12, 45, 1050, 9, 45, 1, 45, 1, 45, 1, 45, 3, 45, 1055, 8, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 1061, 8, 47, 1, 48, 1, 48, 1, 49, 5, 49, 1066, 8, 49, 10, 49, 12, 49, 1069, 9, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 1096, 8, 50, 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, 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, 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, 1174, 8, 51, 3, 51, 1176, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1190, 8, 53, 1, 53, 1, 53, 5, 53, 1194, 8, 53, 10, 53, 12, 53, 1197, 9, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1205, 8, 53, 3, 53, 1207, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1214, 8, 54, 10, 54, 12, 54, 1217, 9, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1228, 8, 55, 10, 55, 12, 55, 1231, 9, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 5, 56, 1242, 8, 56, 10, 56, 12, 56, 1245, 9, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1252, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 1260, 8, 57, 1, 57, 1, 57, 3, 57, 1264, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1303, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 1309, 8, 59, 10, 59, 12, 59, 1312, 9, 59, 1, 59, 1, 59, 1, 59, 1, 60, 5, 60, 1318, 8, 60, 10, 60, 12, 60, 1321, 9, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1328, 8, 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, 3, 62, 1347, 8, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 5, 63, 1355, 8, 63, 10, 63, 12, 63, 1358, 9, 63, 3, 63, 1360, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 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, 1384, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1531, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1541, 8, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 5, 67, 1548, 8, 67, 10, 67, 12, 67, 1551, 9, 67, 3, 67, 1553, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1635, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 5, 69, 1642, 8, 69, 10, 69, 12, 69, 1645, 9, 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, 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, 1676, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1736, 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, 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, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1776, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1792, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1802, 8, 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, 3, 76, 1829, 8, 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, 1853, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 5, 77, 1859, 8, 77, 10, 77, 12, 77, 1862, 9, 77, 1, 77, 3, 77, 1865, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1880, 8, 78, 1, 79, 1, 79, 1, 79, 5, 79, 1885, 8, 79, 10, 79, 12, 79, 1888, 9, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1932, 8, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1942, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1960, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1978, 8, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1997, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 2018, 8, 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, 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 2037, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 2052, 8, 89, 1, 90, 1, 90, 1, 90, 1, 90, 5, 90, 2058, 8, 90, 10, 90, 12, 90, 2061, 9, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 2072, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 2092, 8, 92, 1, 93, 1, 93, 1, 93, 5, 93, 2097, 8, 93, 10, 93, 12, 93, 2100, 9, 93, 1, 94, 1, 94, 3, 94, 2104, 8, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 5, 95, 2113, 8, 95, 10, 95, 12, 95, 2116, 9, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 3, 97, 2127, 8, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2235, 8, 99, 10, 99, 12, 99, 2238, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2247, 8, 99, 10, 99, 12, 99, 2250, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2263, 8, 99, 10, 99, 12, 99, 2266, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2277, 8, 99, 10, 99, 12, 99, 2280, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 2288, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 2301, 8, 100, 10, 100, 12, 100, 2304, 9, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 2346, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 2357, 8, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 3, 103, 2364, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 2372, 8, 104, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2378, 8, 105, 10, 105, 12, 105, 2381, 9, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2391, 8, 105, 10, 105, 12, 105, 2394, 9, 105, 1, 105, 1, 105, 1, 105, 3, 105, 2399, 8, 105, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 2405, 8, 106, 1, 107, 5, 107, 2408, 8, 107, 10, 107, 12, 107, 2411, 9, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 2439, 8, 108, 1, 109, 1, 109, 1, 109, 1, 109, 5, 109, 2445, 8, 109, 10, 109, 12, 109, 2448, 9, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 2461, 8, 110, 1, 111, 5, 111, 2464, 8, 111, 10, 111, 12, 111, 2467, 9, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 2491, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 2500, 8, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 4, 114, 2509, 8, 114, 11, 114, 12, 114, 2510, 1, 114, 1, 114, 3, 114, 2515, 8, 114, 1, 115, 1, 115, 1, 115, 5, 115, 2520, 8, 115, 10, 115, 12, 115, 2523, 9, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 2542, 8, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2551, 8, 117, 10, 117, 12, 117, 2554, 9, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2566, 8, 117, 10, 117, 12, 117, 2569, 9, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2615, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2625, 8, 119, 3, 119, 2627, 8, 119, 1, 119, 1, 119, 1, 119, 5, 119, 2632, 8, 119, 10, 119, 12, 119, 2635, 9, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2640, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2684, 8, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 2693, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2733, 8, 122, 1, 123, 5, 123, 2736, 8, 123, 10, 123, 12, 123, 2739, 9, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2778, 8, 124, 1, 125, 1, 125, 3, 125, 2782, 8, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, 2792, 8, 126, 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, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 2814, 8, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2824, 8, 129, 10, 129, 12, 129, 2827, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2835, 8, 129, 10, 129, 12, 129, 2838, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2850, 8, 129, 10, 129, 12, 129, 2853, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2863, 8, 129, 10, 129, 12, 129, 2866, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2876, 8, 129, 10, 129, 12, 129, 2879, 9, 129, 3, 129, 2881, 8, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 2893, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 4, 134, 2905, 8, 134, 11, 134, 12, 134, 2906, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 3, 135, 2925, 8, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 3, 136, 2943, 8, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 2957, 8, 137, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 2981, 8, 141, 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 2993, 8, 143, 1, 144, 1, 144, 1, 144, 3, 144, 2998, 8, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 4, 145, 3005, 8, 145, 11, 145, 12, 145, 3006, 3, 145, 3009, 8, 145, 1, 146, 1, 146, 1, 146, 5, 146, 3014, 8, 146, 10, 146, 12, 146, 3017, 9, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 3026, 8, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 3, 148, 3094, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 3186, 8, 149, 1, 150, 1, 150, 1, 150, 5, 150, 3191, 8, 150, 10, 150, 12, 150, 3194, 9, 150, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 3, 152, 3206, 8, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 3, 153, 3379, 8, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 5, 154, 3387, 8, 154, 10, 154, 12, 154, 3390, 9, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 5, 155, 3398, 8, 155, 10, 155, 12, 155, 3401, 9, 155, 1, 156, 1, 156, 1, 156, 5, 156, 3406, 8, 156, 10, 156, 12, 156, 3409, 9, 156, 1, 157, 1, 157, 1, 157, 5, 157, 3414, 8, 157, 10, 157, 12, 157, 3417, 9, 157, 1, 158, 1, 158, 1, 158, 5, 158, 3422, 8, 158, 10, 158, 12, 158, 3425, 9, 158, 1, 159, 1, 159, 1, 159, 5, 159, 3430, 8, 159, 10, 159, 12, 159, 3433, 9, 159, 1, 160, 1, 160, 1, 160, 5, 160, 3438, 8, 160, 10, 160, 12, 160, 3441, 9, 160, 1, 161, 1, 161, 1, 161, 1, 161, 5, 161, 3447, 8, 161, 10, 161, 12, 161, 3450, 9, 161, 1, 162, 1, 162, 1, 162, 5, 162, 3455, 8, 162, 10, 162, 12, 162, 3458, 9, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 3468, 8, 163, 1, 164, 1, 164, 1, 164, 5, 164, 3473, 8, 164, 10, 164, 12, 164, 3476, 9, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 3, 165, 3487, 8, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 3, 166, 3514, 8, 166, 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, 168, 3, 168, 3533, 8, 168, 1, 169, 5, 169, 3536, 8, 169, 10, 169, 12, 169, 3539, 9, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 3555, 8, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 5, 172, 3565, 8, 172, 10, 172, 12, 172, 3568, 9, 172, 1, 172, 1, 172, 1, 173, 1, 173, 5, 173, 3574, 8, 173, 10, 173, 12, 173, 3577, 9, 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, 3, 174, 3596, 8, 174, 1, 175, 5, 175, 3599, 8, 175, 10, 175, 12, 175, 3602, 9, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 3, 176, 3617, 8, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 178, 1, 178, 5, 178, 3626, 8, 178, 10, 178, 12, 178, 3629, 9, 178, 1, 178, 1, 178, 1, 178, 5, 178, 3634, 8, 178, 10, 178, 12, 178, 3637, 9, 178, 1, 178, 1, 178, 1, 178, 1, 178, 3, 178, 3643, 8, 178, 1, 179, 1, 179, 1, 180, 5, 180, 3648, 8, 180, 10, 180, 12, 180, 3651, 9, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 3, 181, 3663, 8, 181, 1, 181, 0, 1, 68, 182, 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, 0, 13, 6, 0, 1, 15, 199, 199, 243, 243, 247, 247, 264, 264, 289, 289, 5, 0, 16, 16, 199, 199, 243, 243, 264, 264, 288, 289, 1, 0, 263, 264, 1, 0, 173, 174, 1, 0, 37, 38, 1, 0, 73, 74, 3, 0, 2, 2, 61, 61, 77, 83, 2, 0, 229, 229, 260, 261, 1, 0, 95, 96, 1, 0, 97, 111, 2, 0, 173, 173, 289, 290, 1, 0, 167, 168, 1, 0, 51, 52, 4127, 0, 364, 1, 0, 0, 0, 2, 382, 1, 0, 0, 0, 4, 384, 1, 0, 0, 0, 6, 391, 1, 0, 0, 0, 8, 400, 1, 0, 0, 0, 10, 489, 1, 0, 0, 0, 12, 491, 1, 0, 0, 0, 14, 495, 1, 0, 0, 0, 16, 499, 1, 0, 0, 0, 18, 504, 1, 0, 0, 0, 20, 508, 1, 0, 0, 0, 22, 512, 1, 0, 0, 0, 24, 519, 1, 0, 0, 0, 26, 535, 1, 0, 0, 0, 28, 537, 1, 0, 0, 0, 30, 539, 1, 0, 0, 0, 32, 551, 1, 0, 0, 0, 34, 553, 1, 0, 0, 0, 36, 576, 1, 0, 0, 0, 38, 580, 1, 0, 0, 0, 40, 598, 1, 0, 0, 0, 42, 625, 1, 0, 0, 0, 44, 653, 1, 0, 0, 0, 46, 693, 1, 0, 0, 0, 48, 695, 1, 0, 0, 0, 50, 704, 1, 0, 0, 0, 52, 706, 1, 0, 0, 0, 54, 716, 1, 0, 0, 0, 56, 729, 1, 0, 0, 0, 58, 732, 1, 0, 0, 0, 60, 735, 1, 0, 0, 0, 62, 759, 1, 0, 0, 0, 64, 772, 1, 0, 0, 0, 66, 774, 1, 0, 0, 0, 68, 782, 1, 0, 0, 0, 70, 798, 1, 0, 0, 0, 72, 804, 1, 0, 0, 0, 74, 808, 1, 0, 0, 0, 76, 887, 1, 0, 0, 0, 78, 894, 1, 0, 0, 0, 80, 901, 1, 0, 0, 0, 82, 906, 1, 0, 0, 0, 84, 915, 1, 0, 0, 0, 86, 921, 1, 0, 0, 0, 88, 1026, 1, 0, 0, 0, 90, 1054, 1, 0, 0, 0, 92, 1056, 1, 0, 0, 0, 94, 1060, 1, 0, 0, 0, 96, 1062, 1, 0, 0, 0, 98, 1067, 1, 0, 0, 0, 100, 1095, 1, 0, 0, 0, 102, 1175, 1, 0, 0, 0, 104, 1177, 1, 0, 0, 0, 106, 1206, 1, 0, 0, 0, 108, 1208, 1, 0, 0, 0, 110, 1222, 1, 0, 0, 0, 112, 1251, 1, 0, 0, 0, 114, 1263, 1, 0, 0, 0, 116, 1302, 1, 0, 0, 0, 118, 1310, 1, 0, 0, 0, 120, 1319, 1, 0, 0, 0, 122, 1327, 1, 0, 0, 0, 124, 1346, 1, 0, 0, 0, 126, 1359, 1, 0, 0, 0, 128, 1383, 1, 0, 0, 0, 130, 1530, 1, 0, 0, 0, 132, 1540, 1, 0, 0, 0, 134, 1552, 1, 0, 0, 0, 136, 1634, 1, 0, 0, 0, 138, 1636, 1, 0, 0, 0, 140, 1675, 1, 0, 0, 0, 142, 1735, 1, 0, 0, 0, 144, 1775, 1, 0, 0, 0, 146, 1791, 1, 0, 0, 0, 148, 1793, 1, 0, 0, 0, 150, 1797, 1, 0, 0, 0, 152, 1852, 1, 0, 0, 0, 154, 1864, 1, 0, 0, 0, 156, 1879, 1, 0, 0, 0, 158, 1886, 1, 0, 0, 0, 160, 1891, 1, 0, 0, 0, 162, 1895, 1, 0, 0, 0, 164, 1931, 1, 0, 0, 0, 166, 1933, 1, 0, 0, 0, 168, 1977, 1, 0, 0, 0, 170, 1996, 1, 0, 0, 0, 172, 2017, 1, 0, 0, 0, 174, 2019, 1, 0, 0, 0, 176, 2036, 1, 0, 0, 0, 178, 2051, 1, 0, 0, 0, 180, 2059, 1, 0, 0, 0, 182, 2071, 1, 0, 0, 0, 184, 2091, 1, 0, 0, 0, 186, 2098, 1, 0, 0, 0, 188, 2101, 1, 0, 0, 0, 190, 2114, 1, 0, 0, 0, 192, 2120, 1, 0, 0, 0, 194, 2126, 1, 0, 0, 0, 196, 2130, 1, 0, 0, 0, 198, 2287, 1, 0, 0, 0, 200, 2289, 1, 0, 0, 0, 202, 2345, 1, 0, 0, 0, 204, 2356, 1, 0, 0, 0, 206, 2363, 1, 0, 0, 0, 208, 2371, 1, 0, 0, 0, 210, 2398, 1, 0, 0, 0, 212, 2404, 1, 0, 0, 0, 214, 2409, 1, 0, 0, 0, 216, 2438, 1, 0, 0, 0, 218, 2440, 1, 0, 0, 0, 220, 2460, 1, 0, 0, 0, 222, 2465, 1, 0, 0, 0, 224, 2490, 1, 0, 0, 0, 226, 2499, 1, 0, 0, 0, 228, 2514, 1, 0, 0, 0, 230, 2521, 1, 0, 0, 0, 232, 2541, 1, 0, 0, 0, 234, 2543, 1, 0, 0, 0, 236, 2614, 1, 0, 0, 0, 238, 2639, 1, 0, 0, 0, 240, 2683, 1, 0, 0, 0, 242, 2692, 1, 0, 0, 0, 244, 2732, 1, 0, 0, 0, 246, 2737, 1, 0, 0, 0, 248, 2777, 1, 0, 0, 0, 250, 2779, 1, 0, 0, 0, 252, 2785, 1, 0, 0, 0, 254, 2793, 1, 0, 0, 0, 256, 2813, 1, 0, 0, 0, 258, 2880, 1, 0, 0, 0, 260, 2882, 1, 0, 0, 0, 262, 2892, 1, 0, 0, 0, 264, 2894, 1, 0, 0, 0, 266, 2898, 1, 0, 0, 0, 268, 2904, 1, 0, 0, 0, 270, 2924, 1, 0, 0, 0, 272, 2942, 1, 0, 0, 0, 274, 2956, 1, 0, 0, 0, 276, 2958, 1, 0, 0, 0, 278, 2961, 1, 0, 0, 0, 280, 2963, 1, 0, 0, 0, 282, 2980, 1, 0, 0, 0, 284, 2982, 1, 0, 0, 0, 286, 2992, 1, 0, 0, 0, 288, 2997, 1, 0, 0, 0, 290, 3008, 1, 0, 0, 0, 292, 3015, 1, 0, 0, 0, 294, 3025, 1, 0, 0, 0, 296, 3093, 1, 0, 0, 0, 298, 3185, 1, 0, 0, 0, 300, 3192, 1, 0, 0, 0, 302, 3195, 1, 0, 0, 0, 304, 3205, 1, 0, 0, 0, 306, 3378, 1, 0, 0, 0, 308, 3388, 1, 0, 0, 0, 310, 3399, 1, 0, 0, 0, 312, 3407, 1, 0, 0, 0, 314, 3415, 1, 0, 0, 0, 316, 3423, 1, 0, 0, 0, 318, 3431, 1, 0, 0, 0, 320, 3439, 1, 0, 0, 0, 322, 3448, 1, 0, 0, 0, 324, 3456, 1, 0, 0, 0, 326, 3467, 1, 0, 0, 0, 328, 3474, 1, 0, 0, 0, 330, 3486, 1, 0, 0, 0, 332, 3513, 1, 0, 0, 0, 334, 3515, 1, 0, 0, 0, 336, 3532, 1, 0, 0, 0, 338, 3537, 1, 0, 0, 0, 340, 3554, 1, 0, 0, 0, 342, 3556, 1, 0, 0, 0, 344, 3561, 1, 0, 0, 0, 346, 3571, 1, 0, 0, 0, 348, 3595, 1, 0, 0, 0, 350, 3600, 1, 0, 0, 0, 352, 3616, 1, 0, 0, 0, 354, 3618, 1, 0, 0, 0, 356, 3642, 1, 0, 0, 0, 358, 3644, 1, 0, 0, 0, 360, 3649, 1, 0, 0, 0, 362, 3662, 1, 0, 0, 0, 364, 365, 7, 0, 0, 0, 365, 1, 1, 0, 0, 0, 366, 367, 5, 288, 0, 0, 367, 383, 6, 1, -1, 0, 368, 369, 3, 4, 2, 0, 369, 370, 6, 1, -1, 0, 370, 371, 5, 265, 0, 0, 371, 373, 1, 0, 0, 0, 372, 368, 1, 0, 0, 0, 373, 376, 1, 0, 0, 0, 374, 372, 1, 0, 0, 0, 374, 375, 1, 0, 0, 0, 375, 377, 1, 0, 0, 0, 376, 374, 1, 0, 0, 0, 377, 378, 3, 4, 2, 0, 378, 379, 6, 1, -1, 0, 379, 383, 1, 0, 0, 0, 380, 381, 5, 264, 0, 0, 381, 383, 6, 1, -1, 0, 382, 366, 1, 0, 0, 0, 382, 374, 1, 0, 0, 0, 382, 380, 1, 0, 0, 0, 383, 3, 1, 0, 0, 0, 384, 385, 7, 1, 0, 0, 385, 5, 1, 0, 0, 0, 386, 387, 5, 263, 0, 0, 387, 388, 6, 3, -1, 0, 388, 390, 5, 266, 0, 0, 389, 386, 1, 0, 0, 0, 390, 393, 1, 0, 0, 0, 391, 389, 1, 0, 0, 0, 391, 392, 1, 0, 0, 0, 392, 394, 1, 0, 0, 0, 393, 391, 1, 0, 0, 0, 394, 395, 5, 263, 0, 0, 395, 396, 6, 3, -1, 0, 396, 7, 1, 0, 0, 0, 397, 399, 3, 10, 5, 0, 398, 397, 1, 0, 0, 0, 399, 402, 1, 0, 0, 0, 400, 398, 1, 0, 0, 0, 400, 401, 1, 0, 0, 0, 401, 9, 1, 0, 0, 0, 402, 400, 1, 0, 0, 0, 403, 404, 3, 74, 37, 0, 404, 405, 5, 17, 0, 0, 405, 406, 3, 82, 41, 0, 406, 407, 5, 18, 0, 0, 407, 490, 1, 0, 0, 0, 408, 409, 3, 72, 36, 0, 409, 410, 5, 17, 0, 0, 410, 411, 3, 8, 4, 0, 411, 412, 5, 18, 0, 0, 412, 490, 1, 0, 0, 0, 413, 414, 3, 234, 117, 0, 414, 415, 5, 17, 0, 0, 415, 416, 3, 246, 123, 0, 416, 417, 5, 18, 0, 0, 417, 490, 1, 0, 0, 0, 418, 490, 3, 200, 100, 0, 419, 420, 6, 5, -1, 0, 420, 421, 3, 284, 142, 0, 421, 422, 6, 5, -1, 0, 422, 490, 1, 0, 0, 0, 423, 424, 6, 5, -1, 0, 424, 425, 3, 70, 35, 0, 425, 426, 6, 5, -1, 0, 426, 490, 1, 0, 0, 0, 427, 428, 6, 5, -1, 0, 428, 429, 3, 66, 33, 0, 429, 430, 6, 5, -1, 0, 430, 490, 1, 0, 0, 0, 431, 432, 6, 5, -1, 0, 432, 433, 3, 88, 44, 0, 433, 434, 6, 5, -1, 0, 434, 490, 1, 0, 0, 0, 435, 436, 6, 5, -1, 0, 436, 437, 3, 90, 45, 0, 437, 438, 6, 5, -1, 0, 438, 490, 1, 0, 0, 0, 439, 440, 6, 5, -1, 0, 440, 441, 3, 22, 11, 0, 441, 442, 6, 5, -1, 0, 442, 490, 1, 0, 0, 0, 443, 444, 6, 5, -1, 0, 444, 445, 3, 334, 167, 0, 445, 446, 6, 5, -1, 0, 446, 490, 1, 0, 0, 0, 447, 448, 6, 5, -1, 0, 448, 449, 3, 342, 171, 0, 449, 450, 6, 5, -1, 0, 450, 490, 1, 0, 0, 0, 451, 452, 6, 5, -1, 0, 452, 453, 3, 354, 177, 0, 453, 454, 6, 5, -1, 0, 454, 490, 1, 0, 0, 0, 455, 456, 6, 5, -1, 0, 456, 457, 3, 64, 32, 0, 457, 458, 6, 5, -1, 0, 458, 490, 1, 0, 0, 0, 459, 460, 6, 5, -1, 0, 460, 461, 3, 152, 76, 0, 461, 462, 6, 5, -1, 0, 462, 490, 1, 0, 0, 0, 463, 464, 3, 330, 165, 0, 464, 465, 6, 5, -1, 0, 465, 490, 1, 0, 0, 0, 466, 467, 6, 5, -1, 0, 467, 490, 3, 12, 6, 0, 468, 469, 6, 5, -1, 0, 469, 490, 3, 14, 7, 0, 470, 471, 6, 5, -1, 0, 471, 490, 3, 16, 8, 0, 472, 473, 6, 5, -1, 0, 473, 490, 3, 18, 9, 0, 474, 475, 6, 5, -1, 0, 475, 490, 3, 20, 10, 0, 476, 477, 6, 5, -1, 0, 477, 478, 3, 26, 13, 0, 478, 479, 6, 5, -1, 0, 479, 490, 1, 0, 0, 0, 480, 481, 6, 5, -1, 0, 481, 482, 3, 42, 21, 0, 482, 483, 6, 5, -1, 0, 483, 490, 1, 0, 0, 0, 484, 485, 6, 5, -1, 0, 485, 490, 3, 40, 20, 0, 486, 490, 3, 30, 15, 0, 487, 488, 6, 5, -1, 0, 488, 490, 3, 24, 12, 0, 489, 403, 1, 0, 0, 0, 489, 408, 1, 0, 0, 0, 489, 413, 1, 0, 0, 0, 489, 418, 1, 0, 0, 0, 489, 419, 1, 0, 0, 0, 489, 423, 1, 0, 0, 0, 489, 427, 1, 0, 0, 0, 489, 431, 1, 0, 0, 0, 489, 435, 1, 0, 0, 0, 489, 439, 1, 0, 0, 0, 489, 443, 1, 0, 0, 0, 489, 447, 1, 0, 0, 0, 489, 451, 1, 0, 0, 0, 489, 455, 1, 0, 0, 0, 489, 459, 1, 0, 0, 0, 489, 463, 1, 0, 0, 0, 489, 466, 1, 0, 0, 0, 489, 468, 1, 0, 0, 0, 489, 470, 1, 0, 0, 0, 489, 472, 1, 0, 0, 0, 489, 474, 1, 0, 0, 0, 489, 476, 1, 0, 0, 0, 489, 480, 1, 0, 0, 0, 489, 484, 1, 0, 0, 0, 489, 486, 1, 0, 0, 0, 489, 487, 1, 0, 0, 0, 490, 11, 1, 0, 0, 0, 491, 492, 5, 19, 0, 0, 492, 493, 3, 32, 16, 0, 493, 494, 6, 6, -1, 0, 494, 13, 1, 0, 0, 0, 495, 496, 5, 20, 0, 0, 496, 497, 3, 32, 16, 0, 497, 498, 6, 7, -1, 0, 498, 15, 1, 0, 0, 0, 499, 500, 5, 21, 0, 0, 500, 501, 5, 22, 0, 0, 501, 502, 3, 32, 16, 0, 502, 503, 6, 8, -1, 0, 503, 17, 1, 0, 0, 0, 504, 505, 5, 23, 0, 0, 505, 506, 3, 34, 17, 0, 506, 507, 6, 9, -1, 0, 507, 19, 1, 0, 0, 0, 508, 509, 5, 24, 0, 0, 509, 510, 3, 34, 17, 0, 510, 511, 6, 10, -1, 0, 511, 21, 1, 0, 0, 0, 512, 513, 5, 25, 0, 0, 513, 514, 3, 98, 49, 0, 514, 515, 3, 2, 1, 0, 515, 516, 5, 17, 0, 0, 516, 517, 3, 120, 60, 0, 517, 518, 5, 18, 0, 0, 518, 23, 1, 0, 0, 0, 519, 520, 5, 26, 0, 0, 520, 25, 1, 0, 0, 0, 521, 522, 5, 27, 0, 0, 522, 536, 3, 28, 14, 0, 523, 524, 5, 27, 0, 0, 524, 525, 3, 28, 14, 0, 525, 526, 5, 28, 0, 0, 526, 527, 3, 28, 14, 0, 527, 536, 1, 0, 0, 0, 528, 529, 5, 27, 0, 0, 529, 530, 3, 28, 14, 0, 530, 531, 5, 28, 0, 0, 531, 532, 3, 28, 14, 0, 532, 533, 5, 28, 0, 0, 533, 534, 3, 28, 14, 0, 534, 536, 1, 0, 0, 0, 535, 521, 1, 0, 0, 0, 535, 523, 1, 0, 0, 0, 535, 528, 1, 0, 0, 0, 536, 27, 1, 0, 0, 0, 537, 538, 7, 2, 0, 0, 538, 29, 1, 0, 0, 0, 539, 540, 5, 29, 0, 0, 540, 546, 5, 17, 0, 0, 541, 542, 3, 116, 58, 0, 542, 543, 6, 15, -1, 0, 543, 545, 1, 0, 0, 0, 544, 541, 1, 0, 0, 0, 545, 548, 1, 0, 0, 0, 546, 544, 1, 0, 0, 0, 546, 547, 1, 0, 0, 0, 547, 549, 1, 0, 0, 0, 548, 546, 1, 0, 0, 0, 549, 550, 5, 18, 0, 0, 550, 31, 1, 0, 0, 0, 551, 552, 5, 173, 0, 0, 552, 33, 1, 0, 0, 0, 553, 554, 7, 3, 0, 0, 554, 35, 1, 0, 0, 0, 555, 556, 5, 175, 0, 0, 556, 577, 6, 18, -1, 0, 557, 558, 3, 32, 16, 0, 558, 559, 5, 265, 0, 0, 559, 560, 6, 18, -1, 0, 560, 577, 1, 0, 0, 0, 561, 562, 3, 32, 16, 0, 562, 563, 6, 18, -1, 0, 563, 577, 1, 0, 0, 0, 564, 565, 5, 188, 0, 0, 565, 566, 5, 30, 0, 0, 566, 567, 3, 32, 16, 0, 567, 568, 5, 31, 0, 0, 568, 569, 6, 18, -1, 0, 569, 577, 1, 0, 0, 0, 570, 571, 5, 189, 0, 0, 571, 572, 5, 30, 0, 0, 572, 573, 3, 34, 17, 0, 573, 574, 5, 31, 0, 0, 574, 575, 6, 18, -1, 0, 575, 577, 1, 0, 0, 0, 576, 555, 1, 0, 0, 0, 576, 557, 1, 0, 0, 0, 576, 561, 1, 0, 0, 0, 576, 564, 1, 0, 0, 0, 576, 570, 1, 0, 0, 0, 577, 37, 1, 0, 0, 0, 578, 581, 3, 32, 16, 0, 579, 581, 5, 262, 0, 0, 580, 578, 1, 0, 0, 0, 580, 579, 1, 0, 0, 0, 581, 39, 1, 0, 0, 0, 582, 583, 5, 267, 0, 0, 583, 599, 5, 289, 0, 0, 584, 585, 5, 267, 0, 0, 585, 586, 5, 289, 0, 0, 586, 599, 5, 263, 0, 0, 587, 588, 5, 268, 0, 0, 588, 599, 5, 289, 0, 0, 589, 590, 5, 269, 0, 0, 590, 599, 5, 289, 0, 0, 591, 592, 5, 270, 0, 0, 592, 599, 5, 289, 0, 0, 593, 599, 5, 271, 0, 0, 594, 599, 5, 272, 0, 0, 595, 596, 5, 273, 0, 0, 596, 599, 5, 263, 0, 0, 597, 599, 5, 32, 0, 0, 598, 582, 1, 0, 0, 0, 598, 584, 1, 0, 0, 0, 598, 587, 1, 0, 0, 0, 598, 589, 1, 0, 0, 0, 598, 591, 1, 0, 0, 0, 598, 593, 1, 0, 0, 0, 598, 594, 1, 0, 0, 0, 598, 595, 1, 0, 0, 0, 598, 597, 1, 0, 0, 0, 599, 41, 1, 0, 0, 0, 600, 601, 5, 33, 0, 0, 601, 602, 3, 138, 69, 0, 602, 603, 5, 34, 0, 0, 603, 604, 3, 2, 1, 0, 604, 626, 1, 0, 0, 0, 605, 606, 5, 33, 0, 0, 606, 607, 3, 116, 58, 0, 607, 608, 5, 34, 0, 0, 608, 609, 3, 2, 1, 0, 609, 626, 1, 0, 0, 0, 610, 611, 5, 33, 0, 0, 611, 612, 3, 176, 88, 0, 612, 613, 5, 34, 0, 0, 613, 614, 3, 2, 1, 0, 614, 626, 1, 0, 0, 0, 615, 616, 5, 33, 0, 0, 616, 617, 3, 44, 22, 0, 617, 618, 5, 34, 0, 0, 618, 619, 3, 2, 1, 0, 619, 626, 1, 0, 0, 0, 620, 621, 5, 33, 0, 0, 621, 622, 3, 46, 23, 0, 622, 623, 5, 34, 0, 0, 623, 624, 3, 2, 1, 0, 624, 626, 1, 0, 0, 0, 625, 600, 1, 0, 0, 0, 625, 605, 1, 0, 0, 0, 625, 610, 1, 0, 0, 0, 625, 615, 1, 0, 0, 0, 625, 620, 1, 0, 0, 0, 626, 43, 1, 0, 0, 0, 627, 628, 5, 35, 0, 0, 628, 629, 3, 48, 24, 0, 629, 630, 6, 22, -1, 0, 630, 654, 1, 0, 0, 0, 631, 632, 5, 35, 0, 0, 632, 633, 3, 48, 24, 0, 633, 634, 5, 36, 0, 0, 634, 635, 3, 6, 3, 0, 635, 636, 6, 22, -1, 0, 636, 654, 1, 0, 0, 0, 637, 638, 5, 35, 0, 0, 638, 639, 3, 48, 24, 0, 639, 640, 5, 36, 0, 0, 640, 641, 5, 17, 0, 0, 641, 642, 3, 52, 26, 0, 642, 643, 5, 18, 0, 0, 643, 644, 6, 22, -1, 0, 644, 654, 1, 0, 0, 0, 645, 646, 5, 35, 0, 0, 646, 647, 3, 48, 24, 0, 647, 648, 5, 36, 0, 0, 648, 649, 5, 30, 0, 0, 649, 650, 3, 300, 150, 0, 650, 651, 5, 31, 0, 0, 651, 652, 6, 22, -1, 0, 652, 654, 1, 0, 0, 0, 653, 627, 1, 0, 0, 0, 653, 631, 1, 0, 0, 0, 653, 637, 1, 0, 0, 0, 653, 645, 1, 0, 0, 0, 654, 45, 1, 0, 0, 0, 655, 656, 5, 35, 0, 0, 656, 657, 5, 30, 0, 0, 657, 658, 3, 50, 25, 0, 658, 659, 5, 31, 0, 0, 659, 660, 3, 48, 24, 0, 660, 661, 6, 23, -1, 0, 661, 694, 1, 0, 0, 0, 662, 663, 5, 35, 0, 0, 663, 664, 5, 30, 0, 0, 664, 665, 3, 50, 25, 0, 665, 666, 5, 31, 0, 0, 666, 667, 3, 48, 24, 0, 667, 668, 5, 36, 0, 0, 668, 669, 3, 6, 3, 0, 669, 670, 6, 23, -1, 0, 670, 694, 1, 0, 0, 0, 671, 672, 5, 35, 0, 0, 672, 673, 5, 30, 0, 0, 673, 674, 3, 50, 25, 0, 674, 675, 5, 31, 0, 0, 675, 676, 3, 48, 24, 0, 676, 677, 5, 36, 0, 0, 677, 678, 5, 17, 0, 0, 678, 679, 3, 52, 26, 0, 679, 680, 5, 18, 0, 0, 680, 681, 6, 23, -1, 0, 681, 694, 1, 0, 0, 0, 682, 683, 5, 35, 0, 0, 683, 684, 5, 30, 0, 0, 684, 685, 3, 50, 25, 0, 685, 686, 5, 31, 0, 0, 686, 687, 3, 48, 24, 0, 687, 688, 5, 36, 0, 0, 688, 689, 5, 30, 0, 0, 689, 690, 3, 300, 150, 0, 690, 691, 5, 31, 0, 0, 691, 692, 6, 23, -1, 0, 692, 694, 1, 0, 0, 0, 693, 655, 1, 0, 0, 0, 693, 662, 1, 0, 0, 0, 693, 671, 1, 0, 0, 0, 693, 682, 1, 0, 0, 0, 694, 47, 1, 0, 0, 0, 695, 696, 3, 168, 84, 0, 696, 697, 6, 24, -1, 0, 697, 49, 1, 0, 0, 0, 698, 699, 3, 124, 62, 0, 699, 700, 6, 25, -1, 0, 700, 705, 1, 0, 0, 0, 701, 702, 3, 176, 88, 0, 702, 703, 6, 25, -1, 0, 703, 705, 1, 0, 0, 0, 704, 698, 1, 0, 0, 0, 704, 701, 1, 0, 0, 0, 705, 51, 1, 0, 0, 0, 706, 707, 3, 54, 27, 0, 707, 708, 3, 56, 28, 0, 708, 709, 6, 26, -1, 0, 709, 53, 1, 0, 0, 0, 710, 711, 3, 306, 153, 0, 711, 712, 6, 27, -1, 0, 712, 715, 1, 0, 0, 0, 713, 715, 3, 40, 20, 0, 714, 710, 1, 0, 0, 0, 714, 713, 1, 0, 0, 0, 715, 718, 1, 0, 0, 0, 716, 714, 1, 0, 0, 0, 716, 717, 1, 0, 0, 0, 717, 55, 1, 0, 0, 0, 718, 716, 1, 0, 0, 0, 719, 720, 3, 58, 29, 0, 720, 721, 3, 60, 30, 0, 721, 722, 3, 2, 1, 0, 722, 723, 5, 36, 0, 0, 723, 724, 3, 306, 153, 0, 724, 725, 6, 28, -1, 0, 725, 728, 1, 0, 0, 0, 726, 728, 3, 40, 20, 0, 727, 719, 1, 0, 0, 0, 727, 726, 1, 0, 0, 0, 728, 731, 1, 0, 0, 0, 729, 727, 1, 0, 0, 0, 729, 730, 1, 0, 0, 0, 730, 57, 1, 0, 0, 0, 731, 729, 1, 0, 0, 0, 732, 733, 7, 4, 0, 0, 733, 734, 6, 29, -1, 0, 734, 59, 1, 0, 0, 0, 735, 737, 3, 62, 31, 0, 736, 738, 5, 261, 0, 0, 737, 736, 1, 0, 0, 0, 737, 738, 1, 0, 0, 0, 738, 739, 1, 0, 0, 0, 739, 740, 6, 30, -1, 0, 740, 61, 1, 0, 0, 0, 741, 742, 3, 144, 72, 0, 742, 743, 6, 31, -1, 0, 743, 760, 1, 0, 0, 0, 744, 745, 3, 2, 1, 0, 745, 746, 6, 31, -1, 0, 746, 760, 1, 0, 0, 0, 747, 748, 5, 196, 0, 0, 748, 760, 6, 31, -1, 0, 749, 750, 5, 197, 0, 0, 750, 760, 6, 31, -1, 0, 751, 752, 5, 202, 0, 0, 752, 753, 5, 39, 0, 0, 753, 754, 5, 264, 0, 0, 754, 760, 6, 31, -1, 0, 755, 756, 5, 202, 0, 0, 756, 757, 3, 116, 58, 0, 757, 758, 6, 31, -1, 0, 758, 760, 1, 0, 0, 0, 759, 741, 1, 0, 0, 0, 759, 744, 1, 0, 0, 0, 759, 747, 1, 0, 0, 0, 759, 749, 1, 0, 0, 0, 759, 751, 1, 0, 0, 0, 759, 755, 1, 0, 0, 0, 760, 63, 1, 0, 0, 0, 761, 762, 5, 198, 0, 0, 762, 763, 5, 40, 0, 0, 763, 764, 3, 2, 1, 0, 764, 765, 6, 32, -1, 0, 765, 773, 1, 0, 0, 0, 766, 767, 5, 198, 0, 0, 767, 768, 3, 2, 1, 0, 768, 769, 6, 32, -1, 0, 769, 773, 1, 0, 0, 0, 770, 771, 5, 198, 0, 0, 771, 773, 6, 32, -1, 0, 772, 761, 1, 0, 0, 0, 772, 766, 1, 0, 0, 0, 772, 770, 1, 0, 0, 0, 773, 65, 1, 0, 0, 0, 774, 775, 5, 41, 0, 0, 775, 776, 5, 42, 0, 0, 776, 777, 3, 32, 16, 0, 777, 778, 5, 43, 0, 0, 778, 779, 3, 68, 34, 0, 779, 780, 5, 44, 0, 0, 780, 781, 3, 0, 0, 0, 781, 67, 1, 0, 0, 0, 782, 795, 6, 34, -1, 0, 783, 784, 10, 5, 0, 0, 784, 794, 5, 186, 0, 0, 785, 786, 10, 4, 0, 0, 786, 794, 5, 187, 0, 0, 787, 788, 10, 3, 0, 0, 788, 794, 5, 45, 0, 0, 789, 790, 10, 2, 0, 0, 790, 794, 5, 46, 0, 0, 791, 792, 10, 1, 0, 0, 792, 794, 5, 47, 0, 0, 793, 783, 1, 0, 0, 0, 793, 785, 1, 0, 0, 0, 793, 787, 1, 0, 0, 0, 793, 789, 1, 0, 0, 0, 793, 791, 1, 0, 0, 0, 794, 797, 1, 0, 0, 0, 795, 793, 1, 0, 0, 0, 795, 796, 1, 0, 0, 0, 796, 69, 1, 0, 0, 0, 797, 795, 1, 0, 0, 0, 798, 799, 5, 48, 0, 0, 799, 800, 5, 36, 0, 0, 800, 801, 5, 30, 0, 0, 801, 802, 3, 300, 150, 0, 802, 803, 5, 31, 0, 0, 803, 71, 1, 0, 0, 0, 804, 805, 5, 49, 0, 0, 805, 806, 3, 2, 1, 0, 806, 807, 6, 36, -1, 0, 807, 73, 1, 0, 0, 0, 808, 814, 5, 50, 0, 0, 809, 810, 3, 76, 38, 0, 810, 811, 6, 37, -1, 0, 811, 813, 1, 0, 0, 0, 812, 809, 1, 0, 0, 0, 813, 816, 1, 0, 0, 0, 814, 812, 1, 0, 0, 0, 814, 815, 1, 0, 0, 0, 815, 817, 1, 0, 0, 0, 816, 814, 1, 0, 0, 0, 817, 818, 3, 2, 1, 0, 818, 819, 3, 182, 91, 0, 819, 820, 3, 78, 39, 0, 820, 821, 3, 80, 40, 0, 821, 822, 6, 37, -1, 0, 822, 75, 1, 0, 0, 0, 823, 824, 5, 51, 0, 0, 824, 888, 6, 38, -1, 0, 825, 826, 5, 52, 0, 0, 826, 888, 6, 38, -1, 0, 827, 828, 5, 199, 0, 0, 828, 888, 6, 38, -1, 0, 829, 830, 5, 202, 0, 0, 830, 888, 6, 38, -1, 0, 831, 832, 5, 221, 0, 0, 832, 888, 6, 38, -1, 0, 833, 834, 5, 53, 0, 0, 834, 888, 6, 38, -1, 0, 835, 836, 5, 54, 0, 0, 836, 888, 6, 38, -1, 0, 837, 838, 5, 55, 0, 0, 838, 888, 6, 38, -1, 0, 839, 840, 5, 56, 0, 0, 840, 888, 6, 38, -1, 0, 841, 842, 5, 244, 0, 0, 842, 888, 6, 38, -1, 0, 843, 844, 5, 15, 0, 0, 844, 888, 6, 38, -1, 0, 845, 846, 5, 224, 0, 0, 846, 888, 6, 38, -1, 0, 847, 848, 5, 57, 0, 0, 848, 888, 6, 38, -1, 0, 849, 850, 5, 58, 0, 0, 850, 888, 6, 38, -1, 0, 851, 852, 5, 59, 0, 0, 852, 888, 6, 38, -1, 0, 853, 854, 5, 60, 0, 0, 854, 888, 6, 38, -1, 0, 855, 856, 5, 61, 0, 0, 856, 888, 6, 38, -1, 0, 857, 858, 5, 62, 0, 0, 858, 859, 5, 51, 0, 0, 859, 888, 6, 38, -1, 0, 860, 861, 5, 62, 0, 0, 861, 862, 5, 52, 0, 0, 862, 888, 6, 38, -1, 0, 863, 864, 5, 62, 0, 0, 864, 865, 5, 63, 0, 0, 865, 888, 6, 38, -1, 0, 866, 867, 5, 62, 0, 0, 867, 868, 5, 64, 0, 0, 868, 888, 6, 38, -1, 0, 869, 870, 5, 62, 0, 0, 870, 871, 5, 65, 0, 0, 871, 888, 6, 38, -1, 0, 872, 873, 5, 62, 0, 0, 873, 874, 5, 66, 0, 0, 874, 888, 6, 38, -1, 0, 875, 876, 5, 67, 0, 0, 876, 888, 6, 38, -1, 0, 877, 878, 5, 68, 0, 0, 878, 888, 6, 38, -1, 0, 879, 880, 5, 69, 0, 0, 880, 888, 6, 38, -1, 0, 881, 882, 5, 70, 0, 0, 882, 883, 5, 30, 0, 0, 883, 884, 3, 32, 16, 0, 884, 885, 5, 31, 0, 0, 885, 886, 6, 38, -1, 0, 886, 888, 1, 0, 0, 0, 887, 823, 1, 0, 0, 0, 887, 825, 1, 0, 0, 0, 887, 827, 1, 0, 0, 0, 887, 829, 1, 0, 0, 0, 887, 831, 1, 0, 0, 0, 887, 833, 1, 0, 0, 0, 887, 835, 1, 0, 0, 0, 887, 837, 1, 0, 0, 0, 887, 839, 1, 0, 0, 0, 887, 841, 1, 0, 0, 0, 887, 843, 1, 0, 0, 0, 887, 845, 1, 0, 0, 0, 887, 847, 1, 0, 0, 0, 887, 849, 1, 0, 0, 0, 887, 851, 1, 0, 0, 0, 887, 853, 1, 0, 0, 0, 887, 855, 1, 0, 0, 0, 887, 857, 1, 0, 0, 0, 887, 860, 1, 0, 0, 0, 887, 863, 1, 0, 0, 0, 887, 866, 1, 0, 0, 0, 887, 869, 1, 0, 0, 0, 887, 872, 1, 0, 0, 0, 887, 875, 1, 0, 0, 0, 887, 877, 1, 0, 0, 0, 887, 879, 1, 0, 0, 0, 887, 881, 1, 0, 0, 0, 888, 77, 1, 0, 0, 0, 889, 895, 1, 0, 0, 0, 890, 891, 5, 71, 0, 0, 891, 892, 3, 124, 62, 0, 892, 893, 6, 39, -1, 0, 893, 895, 1, 0, 0, 0, 894, 889, 1, 0, 0, 0, 894, 890, 1, 0, 0, 0, 895, 79, 1, 0, 0, 0, 896, 902, 1, 0, 0, 0, 897, 898, 5, 72, 0, 0, 898, 899, 3, 84, 42, 0, 899, 900, 6, 40, -1, 0, 900, 902, 1, 0, 0, 0, 901, 896, 1, 0, 0, 0, 901, 897, 1, 0, 0, 0, 902, 81, 1, 0, 0, 0, 903, 905, 3, 198, 99, 0, 904, 903, 1, 0, 0, 0, 905, 908, 1, 0, 0, 0, 906, 904, 1, 0, 0, 0, 906, 907, 1, 0, 0, 0, 907, 83, 1, 0, 0, 0, 908, 906, 1, 0, 0, 0, 909, 910, 3, 124, 62, 0, 910, 911, 6, 42, -1, 0, 911, 912, 5, 28, 0, 0, 912, 914, 1, 0, 0, 0, 913, 909, 1, 0, 0, 0, 914, 917, 1, 0, 0, 0, 915, 913, 1, 0, 0, 0, 915, 916, 1, 0, 0, 0, 916, 918, 1, 0, 0, 0, 917, 915, 1, 0, 0, 0, 918, 919, 3, 124, 62, 0, 919, 920, 6, 42, -1, 0, 920, 85, 1, 0, 0, 0, 921, 922, 7, 5, 0, 0, 922, 87, 1, 0, 0, 0, 923, 924, 3, 86, 43, 0, 924, 925, 3, 32, 16, 0, 925, 926, 5, 264, 0, 0, 926, 1027, 1, 0, 0, 0, 927, 928, 3, 86, 43, 0, 928, 929, 3, 32, 16, 0, 929, 1027, 1, 0, 0, 0, 930, 931, 3, 86, 43, 0, 931, 932, 3, 32, 16, 0, 932, 933, 5, 75, 0, 0, 933, 934, 3, 32, 16, 0, 934, 935, 5, 264, 0, 0, 935, 1027, 1, 0, 0, 0, 936, 937, 3, 86, 43, 0, 937, 938, 3, 32, 16, 0, 938, 939, 5, 75, 0, 0, 939, 940, 3, 32, 16, 0, 940, 1027, 1, 0, 0, 0, 941, 942, 3, 86, 43, 0, 942, 943, 3, 32, 16, 0, 943, 944, 5, 75, 0, 0, 944, 945, 3, 32, 16, 0, 945, 946, 5, 28, 0, 0, 946, 947, 3, 32, 16, 0, 947, 948, 5, 264, 0, 0, 948, 1027, 1, 0, 0, 0, 949, 950, 3, 86, 43, 0, 950, 951, 3, 32, 16, 0, 951, 952, 5, 75, 0, 0, 952, 953, 3, 32, 16, 0, 953, 954, 5, 28, 0, 0, 954, 955, 3, 32, 16, 0, 955, 1027, 1, 0, 0, 0, 956, 957, 3, 86, 43, 0, 957, 958, 3, 32, 16, 0, 958, 959, 5, 28, 0, 0, 959, 960, 3, 32, 16, 0, 960, 961, 5, 75, 0, 0, 961, 962, 3, 32, 16, 0, 962, 963, 5, 264, 0, 0, 963, 1027, 1, 0, 0, 0, 964, 965, 3, 86, 43, 0, 965, 966, 3, 32, 16, 0, 966, 967, 5, 28, 0, 0, 967, 968, 3, 32, 16, 0, 968, 969, 5, 75, 0, 0, 969, 970, 3, 32, 16, 0, 970, 1027, 1, 0, 0, 0, 971, 972, 3, 86, 43, 0, 972, 973, 3, 32, 16, 0, 973, 974, 5, 28, 0, 0, 974, 975, 3, 32, 16, 0, 975, 976, 5, 75, 0, 0, 976, 977, 3, 32, 16, 0, 977, 978, 5, 28, 0, 0, 978, 979, 3, 32, 16, 0, 979, 980, 5, 264, 0, 0, 980, 1027, 1, 0, 0, 0, 981, 982, 3, 86, 43, 0, 982, 983, 3, 32, 16, 0, 983, 984, 5, 28, 0, 0, 984, 985, 3, 32, 16, 0, 985, 986, 5, 75, 0, 0, 986, 987, 3, 32, 16, 0, 987, 988, 5, 28, 0, 0, 988, 989, 3, 32, 16, 0, 989, 1027, 1, 0, 0, 0, 990, 991, 3, 86, 43, 0, 991, 992, 3, 32, 16, 0, 992, 993, 5, 263, 0, 0, 993, 1027, 1, 0, 0, 0, 994, 995, 3, 86, 43, 0, 995, 996, 3, 32, 16, 0, 996, 997, 5, 75, 0, 0, 997, 998, 3, 32, 16, 0, 998, 999, 5, 263, 0, 0, 999, 1027, 1, 0, 0, 0, 1000, 1001, 3, 86, 43, 0, 1001, 1002, 3, 32, 16, 0, 1002, 1003, 5, 75, 0, 0, 1003, 1004, 3, 32, 16, 0, 1004, 1005, 5, 28, 0, 0, 1005, 1006, 3, 32, 16, 0, 1006, 1007, 5, 263, 0, 0, 1007, 1027, 1, 0, 0, 0, 1008, 1009, 3, 86, 43, 0, 1009, 1010, 3, 32, 16, 0, 1010, 1011, 5, 28, 0, 0, 1011, 1012, 3, 32, 16, 0, 1012, 1013, 5, 75, 0, 0, 1013, 1014, 3, 32, 16, 0, 1014, 1015, 5, 263, 0, 0, 1015, 1027, 1, 0, 0, 0, 1016, 1017, 3, 86, 43, 0, 1017, 1018, 3, 32, 16, 0, 1018, 1019, 5, 28, 0, 0, 1019, 1020, 3, 32, 16, 0, 1020, 1021, 5, 75, 0, 0, 1021, 1022, 3, 32, 16, 0, 1022, 1023, 5, 28, 0, 0, 1023, 1024, 3, 32, 16, 0, 1024, 1025, 5, 263, 0, 0, 1025, 1027, 1, 0, 0, 0, 1026, 923, 1, 0, 0, 0, 1026, 927, 1, 0, 0, 0, 1026, 930, 1, 0, 0, 0, 1026, 936, 1, 0, 0, 0, 1026, 941, 1, 0, 0, 0, 1026, 949, 1, 0, 0, 0, 1026, 956, 1, 0, 0, 0, 1026, 964, 1, 0, 0, 0, 1026, 971, 1, 0, 0, 0, 1026, 981, 1, 0, 0, 0, 1026, 990, 1, 0, 0, 0, 1026, 994, 1, 0, 0, 0, 1026, 1000, 1, 0, 0, 0, 1026, 1008, 1, 0, 0, 0, 1026, 1016, 1, 0, 0, 0, 1027, 89, 1, 0, 0, 0, 1028, 1032, 5, 21, 0, 0, 1029, 1031, 3, 92, 46, 0, 1030, 1029, 1, 0, 0, 0, 1031, 1034, 1, 0, 0, 0, 1032, 1030, 1, 0, 0, 0, 1032, 1033, 1, 0, 0, 0, 1033, 1035, 1, 0, 0, 0, 1034, 1032, 1, 0, 0, 0, 1035, 1036, 3, 2, 1, 0, 1036, 1037, 3, 94, 47, 0, 1037, 1038, 5, 180, 0, 0, 1038, 1039, 5, 36, 0, 0, 1039, 1040, 5, 30, 0, 0, 1040, 1041, 3, 300, 150, 0, 1041, 1042, 5, 31, 0, 0, 1042, 1043, 3, 94, 47, 0, 1043, 1055, 1, 0, 0, 0, 1044, 1048, 5, 21, 0, 0, 1045, 1047, 3, 92, 46, 0, 1046, 1045, 1, 0, 0, 0, 1047, 1050, 1, 0, 0, 0, 1048, 1046, 1, 0, 0, 0, 1048, 1049, 1, 0, 0, 0, 1049, 1051, 1, 0, 0, 0, 1050, 1048, 1, 0, 0, 0, 1051, 1052, 3, 2, 1, 0, 1052, 1053, 3, 94, 47, 0, 1053, 1055, 1, 0, 0, 0, 1054, 1028, 1, 0, 0, 0, 1054, 1044, 1, 0, 0, 0, 1055, 91, 1, 0, 0, 0, 1056, 1057, 5, 76, 0, 0, 1057, 93, 1, 0, 0, 0, 1058, 1061, 1, 0, 0, 0, 1059, 1061, 5, 298, 0, 0, 1060, 1058, 1, 0, 0, 0, 1060, 1059, 1, 0, 0, 0, 1061, 95, 1, 0, 0, 0, 1062, 1063, 7, 6, 0, 0, 1063, 97, 1, 0, 0, 0, 1064, 1066, 3, 96, 48, 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, 99, 1, 0, 0, 0, 1069, 1067, 1, 0, 0, 0, 1070, 1096, 3, 102, 51, 0, 1071, 1072, 5, 280, 0, 0, 1072, 1073, 3, 168, 84, 0, 1073, 1074, 6, 50, -1, 0, 1074, 1096, 1, 0, 0, 0, 1075, 1076, 5, 286, 0, 0, 1076, 1077, 3, 178, 89, 0, 1077, 1078, 6, 50, -1, 0, 1078, 1096, 1, 0, 0, 0, 1079, 1080, 5, 286, 0, 0, 1080, 1081, 3, 174, 87, 0, 1081, 1082, 6, 50, -1, 0, 1082, 1096, 1, 0, 0, 0, 1083, 1084, 5, 284, 0, 0, 1084, 1085, 3, 124, 62, 0, 1085, 1086, 6, 50, -1, 0, 1086, 1096, 1, 0, 0, 0, 1087, 1088, 5, 281, 0, 0, 1088, 1089, 3, 104, 52, 0, 1089, 1090, 6, 50, -1, 0, 1090, 1096, 1, 0, 0, 0, 1091, 1092, 5, 287, 0, 0, 1092, 1093, 3, 50, 25, 0, 1093, 1094, 6, 50, -1, 0, 1094, 1096, 1, 0, 0, 0, 1095, 1070, 1, 0, 0, 0, 1095, 1071, 1, 0, 0, 0, 1095, 1075, 1, 0, 0, 0, 1095, 1079, 1, 0, 0, 0, 1095, 1083, 1, 0, 0, 0, 1095, 1087, 1, 0, 0, 0, 1095, 1091, 1, 0, 0, 0, 1096, 101, 1, 0, 0, 0, 1097, 1098, 5, 275, 0, 0, 1098, 1176, 6, 51, -1, 0, 1099, 1100, 5, 276, 0, 0, 1100, 1101, 3, 32, 16, 0, 1101, 1102, 6, 51, -1, 0, 1102, 1176, 1, 0, 0, 0, 1103, 1104, 5, 276, 0, 0, 1104, 1105, 3, 0, 0, 0, 1105, 1106, 6, 51, -1, 0, 1106, 1176, 1, 0, 0, 0, 1107, 1108, 5, 277, 0, 0, 1108, 1109, 3, 32, 16, 0, 1109, 1110, 6, 51, -1, 0, 1110, 1176, 1, 0, 0, 0, 1111, 1112, 5, 278, 0, 0, 1112, 1113, 3, 34, 17, 0, 1113, 1114, 6, 51, -1, 0, 1114, 1176, 1, 0, 0, 0, 1115, 1116, 5, 279, 0, 0, 1116, 1117, 3, 36, 18, 0, 1117, 1118, 6, 51, -1, 0, 1118, 1176, 1, 0, 0, 0, 1119, 1120, 5, 279, 0, 0, 1120, 1121, 3, 34, 17, 0, 1121, 1122, 6, 51, -1, 0, 1122, 1176, 1, 0, 0, 0, 1123, 1124, 5, 279, 0, 0, 1124, 1125, 5, 30, 0, 0, 1125, 1126, 3, 300, 150, 0, 1126, 1127, 5, 31, 0, 0, 1127, 1128, 6, 51, -1, 0, 1128, 1176, 1, 0, 0, 0, 1129, 1130, 5, 279, 0, 0, 1130, 1131, 5, 84, 0, 0, 1131, 1132, 5, 30, 0, 0, 1132, 1133, 3, 300, 150, 0, 1133, 1134, 5, 31, 0, 0, 1134, 1135, 6, 51, -1, 0, 1135, 1176, 1, 0, 0, 0, 1136, 1137, 5, 282, 0, 0, 1137, 1138, 3, 32, 16, 0, 1138, 1139, 6, 51, -1, 0, 1139, 1176, 1, 0, 0, 0, 1140, 1141, 5, 282, 0, 0, 1141, 1142, 3, 0, 0, 0, 1142, 1143, 6, 51, -1, 0, 1143, 1176, 1, 0, 0, 0, 1144, 1145, 5, 285, 0, 0, 1145, 1146, 3, 6, 3, 0, 1146, 1147, 6, 51, -1, 0, 1147, 1176, 1, 0, 0, 0, 1148, 1149, 5, 285, 0, 0, 1149, 1150, 5, 224, 0, 0, 1150, 1151, 5, 30, 0, 0, 1151, 1152, 3, 6, 3, 0, 1152, 1153, 5, 31, 0, 0, 1153, 1154, 6, 51, -1, 0, 1154, 1176, 1, 0, 0, 0, 1155, 1156, 5, 285, 0, 0, 1156, 1157, 5, 84, 0, 0, 1157, 1158, 5, 30, 0, 0, 1158, 1159, 3, 300, 150, 0, 1159, 1160, 5, 31, 0, 0, 1160, 1161, 6, 51, -1, 0, 1161, 1176, 1, 0, 0, 0, 1162, 1163, 5, 287, 0, 0, 1163, 1164, 3, 32, 16, 0, 1164, 1165, 6, 51, -1, 0, 1165, 1176, 1, 0, 0, 0, 1166, 1167, 5, 283, 0, 0, 1167, 1173, 6, 51, -1, 0, 1168, 1169, 5, 30, 0, 0, 1169, 1170, 3, 106, 53, 0, 1170, 1171, 5, 31, 0, 0, 1171, 1174, 1, 0, 0, 0, 1172, 1174, 5, 85, 0, 0, 1173, 1168, 1, 0, 0, 0, 1173, 1172, 1, 0, 0, 0, 1174, 1176, 1, 0, 0, 0, 1175, 1097, 1, 0, 0, 0, 1175, 1099, 1, 0, 0, 0, 1175, 1103, 1, 0, 0, 0, 1175, 1107, 1, 0, 0, 0, 1175, 1111, 1, 0, 0, 0, 1175, 1115, 1, 0, 0, 0, 1175, 1119, 1, 0, 0, 0, 1175, 1123, 1, 0, 0, 0, 1175, 1129, 1, 0, 0, 0, 1175, 1136, 1, 0, 0, 0, 1175, 1140, 1, 0, 0, 0, 1175, 1144, 1, 0, 0, 0, 1175, 1148, 1, 0, 0, 0, 1175, 1155, 1, 0, 0, 0, 1175, 1162, 1, 0, 0, 0, 1175, 1166, 1, 0, 0, 0, 1176, 103, 1, 0, 0, 0, 1177, 1178, 3, 170, 85, 0, 1178, 1179, 3, 138, 69, 0, 1179, 1180, 3, 112, 56, 0, 1180, 1181, 6, 52, -1, 0, 1181, 105, 1, 0, 0, 0, 1182, 1207, 1, 0, 0, 0, 1183, 1184, 3, 0, 0, 0, 1184, 1185, 6, 53, -1, 0, 1185, 1190, 1, 0, 0, 0, 1186, 1187, 3, 32, 16, 0, 1187, 1188, 6, 53, -1, 0, 1188, 1190, 1, 0, 0, 0, 1189, 1183, 1, 0, 0, 0, 1189, 1186, 1, 0, 0, 0, 1190, 1191, 1, 0, 0, 0, 1191, 1192, 5, 28, 0, 0, 1192, 1194, 1, 0, 0, 0, 1193, 1189, 1, 0, 0, 0, 1194, 1197, 1, 0, 0, 0, 1195, 1193, 1, 0, 0, 0, 1195, 1196, 1, 0, 0, 0, 1196, 1204, 1, 0, 0, 0, 1197, 1195, 1, 0, 0, 0, 1198, 1199, 3, 0, 0, 0, 1199, 1200, 6, 53, -1, 0, 1200, 1205, 1, 0, 0, 0, 1201, 1202, 3, 32, 16, 0, 1202, 1203, 6, 53, -1, 0, 1203, 1205, 1, 0, 0, 0, 1204, 1198, 1, 0, 0, 0, 1204, 1201, 1, 0, 0, 0, 1205, 1207, 1, 0, 0, 0, 1206, 1182, 1, 0, 0, 0, 1206, 1195, 1, 0, 0, 0, 1207, 107, 1, 0, 0, 0, 1208, 1215, 5, 86, 0, 0, 1209, 1210, 3, 138, 69, 0, 1210, 1211, 6, 54, -1, 0, 1211, 1212, 5, 28, 0, 0, 1212, 1214, 1, 0, 0, 0, 1213, 1209, 1, 0, 0, 0, 1214, 1217, 1, 0, 0, 0, 1215, 1213, 1, 0, 0, 0, 1215, 1216, 1, 0, 0, 0, 1216, 1218, 1, 0, 0, 0, 1217, 1215, 1, 0, 0, 0, 1218, 1219, 3, 138, 69, 0, 1219, 1220, 6, 54, -1, 0, 1220, 1221, 5, 87, 0, 0, 1221, 109, 1, 0, 0, 0, 1222, 1229, 5, 42, 0, 0, 1223, 1224, 3, 146, 73, 0, 1224, 1225, 6, 55, -1, 0, 1225, 1226, 5, 28, 0, 0, 1226, 1228, 1, 0, 0, 0, 1227, 1223, 1, 0, 0, 0, 1228, 1231, 1, 0, 0, 0, 1229, 1227, 1, 0, 0, 0, 1229, 1230, 1, 0, 0, 0, 1230, 1232, 1, 0, 0, 0, 1231, 1229, 1, 0, 0, 0, 1232, 1233, 3, 146, 73, 0, 1233, 1234, 6, 55, -1, 0, 1234, 1235, 5, 43, 0, 0, 1235, 111, 1, 0, 0, 0, 1236, 1243, 5, 30, 0, 0, 1237, 1238, 3, 114, 57, 0, 1238, 1239, 6, 56, -1, 0, 1239, 1240, 5, 28, 0, 0, 1240, 1242, 1, 0, 0, 0, 1241, 1237, 1, 0, 0, 0, 1242, 1245, 1, 0, 0, 0, 1243, 1241, 1, 0, 0, 0, 1243, 1244, 1, 0, 0, 0, 1244, 1246, 1, 0, 0, 0, 1245, 1243, 1, 0, 0, 0, 1246, 1247, 3, 114, 57, 0, 1247, 1248, 6, 56, -1, 0, 1248, 1249, 5, 31, 0, 0, 1249, 1252, 1, 0, 0, 0, 1250, 1252, 5, 85, 0, 0, 1251, 1236, 1, 0, 0, 0, 1251, 1250, 1, 0, 0, 0, 1252, 113, 1, 0, 0, 0, 1253, 1254, 5, 177, 0, 0, 1254, 1264, 6, 57, -1, 0, 1255, 1256, 3, 230, 115, 0, 1256, 1257, 3, 138, 69, 0, 1257, 1259, 3, 226, 113, 0, 1258, 1260, 3, 0, 0, 0, 1259, 1258, 1, 0, 0, 0, 1259, 1260, 1, 0, 0, 0, 1260, 1261, 1, 0, 0, 0, 1261, 1262, 6, 57, -1, 0, 1262, 1264, 1, 0, 0, 0, 1263, 1253, 1, 0, 0, 0, 1263, 1255, 1, 0, 0, 0, 1264, 115, 1, 0, 0, 0, 1265, 1266, 5, 42, 0, 0, 1266, 1267, 3, 2, 1, 0, 1267, 1268, 5, 43, 0, 0, 1268, 1269, 3, 118, 59, 0, 1269, 1270, 6, 58, -1, 0, 1270, 1303, 1, 0, 0, 0, 1271, 1272, 5, 42, 0, 0, 1272, 1273, 3, 174, 87, 0, 1273, 1274, 5, 43, 0, 0, 1274, 1275, 3, 118, 59, 0, 1275, 1276, 6, 58, -1, 0, 1276, 1303, 1, 0, 0, 0, 1277, 1278, 5, 42, 0, 0, 1278, 1279, 5, 262, 0, 0, 1279, 1280, 5, 43, 0, 0, 1280, 1281, 3, 118, 59, 0, 1281, 1282, 6, 58, -1, 0, 1282, 1303, 1, 0, 0, 0, 1283, 1284, 5, 42, 0, 0, 1284, 1285, 5, 198, 0, 0, 1285, 1286, 3, 2, 1, 0, 1286, 1287, 5, 43, 0, 0, 1287, 1288, 3, 118, 59, 0, 1288, 1289, 6, 58, -1, 0, 1289, 1303, 1, 0, 0, 0, 1290, 1291, 3, 118, 59, 0, 1291, 1292, 6, 58, -1, 0, 1292, 1303, 1, 0, 0, 0, 1293, 1294, 3, 174, 87, 0, 1294, 1295, 6, 58, -1, 0, 1295, 1303, 1, 0, 0, 0, 1296, 1297, 5, 257, 0, 0, 1297, 1303, 6, 58, -1, 0, 1298, 1299, 5, 258, 0, 0, 1299, 1303, 6, 58, -1, 0, 1300, 1301, 5, 259, 0, 0, 1301, 1303, 6, 58, -1, 0, 1302, 1265, 1, 0, 0, 0, 1302, 1271, 1, 0, 0, 0, 1302, 1277, 1, 0, 0, 0, 1302, 1283, 1, 0, 0, 0, 1302, 1290, 1, 0, 0, 0, 1302, 1293, 1, 0, 0, 0, 1302, 1296, 1, 0, 0, 0, 1302, 1298, 1, 0, 0, 0, 1302, 1300, 1, 0, 0, 0, 1303, 117, 1, 0, 0, 0, 1304, 1305, 3, 2, 1, 0, 1305, 1306, 6, 59, -1, 0, 1306, 1307, 5, 88, 0, 0, 1307, 1309, 1, 0, 0, 0, 1308, 1304, 1, 0, 0, 0, 1309, 1312, 1, 0, 0, 0, 1310, 1308, 1, 0, 0, 0, 1310, 1311, 1, 0, 0, 0, 1311, 1313, 1, 0, 0, 0, 1312, 1310, 1, 0, 0, 0, 1313, 1314, 3, 2, 1, 0, 1314, 1315, 6, 59, -1, 0, 1315, 119, 1, 0, 0, 0, 1316, 1318, 3, 122, 61, 0, 1317, 1316, 1, 0, 0, 0, 1318, 1321, 1, 0, 0, 0, 1319, 1317, 1, 0, 0, 0, 1319, 1320, 1, 0, 0, 0, 1320, 121, 1, 0, 0, 0, 1321, 1319, 1, 0, 0, 0, 1322, 1323, 5, 180, 0, 0, 1323, 1324, 5, 89, 0, 0, 1324, 1328, 3, 32, 16, 0, 1325, 1328, 3, 152, 76, 0, 1326, 1328, 3, 332, 166, 0, 1327, 1322, 1, 0, 0, 0, 1327, 1325, 1, 0, 0, 0, 1327, 1326, 1, 0, 0, 0, 1328, 123, 1, 0, 0, 0, 1329, 1330, 3, 116, 58, 0, 1330, 1331, 6, 62, -1, 0, 1331, 1347, 1, 0, 0, 0, 1332, 1333, 5, 42, 0, 0, 1333, 1334, 3, 2, 1, 0, 1334, 1335, 5, 43, 0, 0, 1335, 1336, 6, 62, -1, 0, 1336, 1347, 1, 0, 0, 0, 1337, 1338, 5, 42, 0, 0, 1338, 1339, 5, 198, 0, 0, 1339, 1340, 3, 2, 1, 0, 1340, 1341, 5, 43, 0, 0, 1341, 1342, 6, 62, -1, 0, 1342, 1347, 1, 0, 0, 0, 1343, 1344, 3, 138, 69, 0, 1344, 1345, 6, 62, -1, 0, 1345, 1347, 1, 0, 0, 0, 1346, 1329, 1, 0, 0, 0, 1346, 1332, 1, 0, 0, 0, 1346, 1337, 1, 0, 0, 0, 1346, 1343, 1, 0, 0, 0, 1347, 125, 1, 0, 0, 0, 1348, 1360, 1, 0, 0, 0, 1349, 1350, 3, 130, 65, 0, 1350, 1356, 6, 63, -1, 0, 1351, 1352, 3, 128, 64, 0, 1352, 1353, 6, 63, -1, 0, 1353, 1355, 1, 0, 0, 0, 1354, 1351, 1, 0, 0, 0, 1355, 1358, 1, 0, 0, 0, 1356, 1354, 1, 0, 0, 0, 1356, 1357, 1, 0, 0, 0, 1357, 1360, 1, 0, 0, 0, 1358, 1356, 1, 0, 0, 0, 1359, 1348, 1, 0, 0, 0, 1359, 1349, 1, 0, 0, 0, 1360, 127, 1, 0, 0, 0, 1361, 1362, 5, 262, 0, 0, 1362, 1384, 6, 64, -1, 0, 1363, 1364, 5, 261, 0, 0, 1364, 1384, 6, 64, -1, 0, 1365, 1366, 5, 42, 0, 0, 1366, 1367, 3, 32, 16, 0, 1367, 1368, 5, 43, 0, 0, 1368, 1369, 6, 64, -1, 0, 1369, 1384, 1, 0, 0, 0, 1370, 1371, 5, 42, 0, 0, 1371, 1372, 3, 32, 16, 0, 1372, 1373, 5, 266, 0, 0, 1373, 1374, 3, 32, 16, 0, 1374, 1375, 5, 43, 0, 0, 1375, 1376, 6, 64, -1, 0, 1376, 1384, 1, 0, 0, 0, 1377, 1378, 5, 42, 0, 0, 1378, 1379, 5, 266, 0, 0, 1379, 1380, 3, 32, 16, 0, 1380, 1381, 5, 43, 0, 0, 1381, 1382, 6, 64, -1, 0, 1382, 1384, 1, 0, 0, 0, 1383, 1361, 1, 0, 0, 0, 1383, 1363, 1, 0, 0, 0, 1383, 1365, 1, 0, 0, 0, 1383, 1370, 1, 0, 0, 0, 1383, 1377, 1, 0, 0, 0, 1384, 129, 1, 0, 0, 0, 1385, 1531, 6, 65, -1, 0, 1386, 1387, 5, 203, 0, 0, 1387, 1388, 5, 30, 0, 0, 1388, 1389, 3, 6, 3, 0, 1389, 1390, 5, 28, 0, 0, 1390, 1391, 3, 6, 3, 0, 1391, 1392, 5, 28, 0, 0, 1392, 1393, 3, 6, 3, 0, 1393, 1394, 5, 28, 0, 0, 1394, 1395, 3, 6, 3, 0, 1395, 1396, 5, 31, 0, 0, 1396, 1397, 6, 65, -1, 0, 1397, 1531, 1, 0, 0, 0, 1398, 1399, 5, 203, 0, 0, 1399, 1400, 5, 30, 0, 0, 1400, 1401, 3, 6, 3, 0, 1401, 1402, 5, 28, 0, 0, 1402, 1403, 3, 6, 3, 0, 1403, 1404, 5, 31, 0, 0, 1404, 1405, 6, 65, -1, 0, 1405, 1531, 1, 0, 0, 0, 1406, 1407, 5, 204, 0, 0, 1407, 1408, 5, 205, 0, 0, 1408, 1409, 5, 42, 0, 0, 1409, 1410, 3, 32, 16, 0, 1410, 1411, 5, 43, 0, 0, 1411, 1412, 6, 65, -1, 0, 1412, 1531, 1, 0, 0, 0, 1413, 1414, 5, 204, 0, 0, 1414, 1415, 5, 206, 0, 0, 1415, 1416, 5, 42, 0, 0, 1416, 1417, 3, 32, 16, 0, 1417, 1418, 5, 43, 0, 0, 1418, 1419, 3, 126, 63, 0, 1419, 1420, 6, 65, -1, 0, 1420, 1531, 1, 0, 0, 0, 1421, 1422, 5, 207, 0, 0, 1422, 1531, 6, 65, -1, 0, 1423, 1424, 5, 208, 0, 0, 1424, 1531, 6, 65, -1, 0, 1425, 1426, 5, 209, 0, 0, 1426, 1531, 6, 65, -1, 0, 1427, 1428, 5, 201, 0, 0, 1428, 1531, 6, 65, -1, 0, 1429, 1430, 5, 183, 0, 0, 1430, 1531, 6, 65, -1, 0, 1431, 1432, 5, 184, 0, 0, 1432, 1531, 6, 65, -1, 0, 1433, 1434, 5, 185, 0, 0, 1434, 1531, 6, 65, -1, 0, 1435, 1436, 5, 186, 0, 0, 1436, 1531, 6, 65, -1, 0, 1437, 1438, 5, 187, 0, 0, 1438, 1531, 6, 65, -1, 0, 1439, 1440, 5, 188, 0, 0, 1440, 1531, 6, 65, -1, 0, 1441, 1442, 5, 189, 0, 0, 1442, 1531, 6, 65, -1, 0, 1443, 1444, 5, 210, 0, 0, 1444, 1531, 6, 65, -1, 0, 1445, 1446, 5, 190, 0, 0, 1446, 1531, 6, 65, -1, 0, 1447, 1448, 5, 191, 0, 0, 1448, 1531, 6, 65, -1, 0, 1449, 1450, 5, 192, 0, 0, 1450, 1531, 6, 65, -1, 0, 1451, 1452, 5, 193, 0, 0, 1452, 1531, 6, 65, -1, 0, 1453, 1454, 5, 211, 0, 0, 1454, 1531, 6, 65, -1, 0, 1455, 1456, 5, 212, 0, 0, 1456, 1531, 6, 65, -1, 0, 1457, 1458, 5, 213, 0, 0, 1458, 1531, 6, 65, -1, 0, 1459, 1460, 5, 214, 0, 0, 1460, 1531, 6, 65, -1, 0, 1461, 1462, 5, 215, 0, 0, 1462, 1531, 6, 65, -1, 0, 1463, 1464, 5, 216, 0, 0, 1464, 1531, 6, 65, -1, 0, 1465, 1466, 5, 217, 0, 0, 1466, 1531, 6, 65, -1, 0, 1467, 1468, 5, 218, 0, 0, 1468, 1469, 3, 132, 66, 0, 1469, 1470, 6, 65, -1, 0, 1470, 1531, 1, 0, 0, 0, 1471, 1472, 5, 219, 0, 0, 1472, 1473, 3, 132, 66, 0, 1473, 1474, 6, 65, -1, 0, 1474, 1531, 1, 0, 0, 0, 1475, 1476, 5, 220, 0, 0, 1476, 1531, 6, 65, -1, 0, 1477, 1478, 5, 221, 0, 0, 1478, 1479, 3, 132, 66, 0, 1479, 1480, 6, 65, -1, 0, 1480, 1531, 1, 0, 0, 0, 1481, 1482, 5, 222, 0, 0, 1482, 1483, 3, 134, 67, 0, 1483, 1484, 6, 65, -1, 0, 1484, 1531, 1, 0, 0, 0, 1485, 1486, 5, 222, 0, 0, 1486, 1487, 3, 134, 67, 0, 1487, 1488, 5, 28, 0, 0, 1488, 1489, 3, 6, 3, 0, 1489, 1490, 6, 65, -1, 0, 1490, 1531, 1, 0, 0, 0, 1491, 1492, 5, 194, 0, 0, 1492, 1531, 6, 65, -1, 0, 1493, 1494, 5, 195, 0, 0, 1494, 1531, 6, 65, -1, 0, 1495, 1496, 5, 90, 0, 0, 1496, 1497, 5, 184, 0, 0, 1497, 1531, 6, 65, -1, 0, 1498, 1499, 5, 90, 0, 0, 1499, 1500, 5, 185, 0, 0, 1500, 1531, 6, 65, -1, 0, 1501, 1502, 5, 90, 0, 0, 1502, 1503, 5, 186, 0, 0, 1503, 1531, 6, 65, -1, 0, 1504, 1505, 5, 90, 0, 0, 1505, 1506, 5, 187, 0, 0, 1506, 1531, 6, 65, -1, 0, 1507, 1508, 5, 62, 0, 0, 1508, 1509, 5, 220, 0, 0, 1509, 1531, 6, 65, -1, 0, 1510, 1511, 5, 223, 0, 0, 1511, 1531, 6, 65, -1, 0, 1512, 1513, 5, 224, 0, 0, 1513, 1514, 5, 213, 0, 0, 1514, 1531, 6, 65, -1, 0, 1515, 1516, 5, 225, 0, 0, 1516, 1531, 6, 65, -1, 0, 1517, 1518, 5, 207, 0, 0, 1518, 1519, 5, 183, 0, 0, 1519, 1531, 6, 65, -1, 0, 1520, 1521, 5, 226, 0, 0, 1521, 1531, 6, 65, -1, 0, 1522, 1523, 5, 228, 0, 0, 1523, 1531, 6, 65, -1, 0, 1524, 1525, 5, 34, 0, 0, 1525, 1526, 5, 227, 0, 0, 1526, 1531, 6, 65, -1, 0, 1527, 1528, 3, 2, 1, 0, 1528, 1529, 6, 65, -1, 0, 1529, 1531, 1, 0, 0, 0, 1530, 1385, 1, 0, 0, 0, 1530, 1386, 1, 0, 0, 0, 1530, 1398, 1, 0, 0, 0, 1530, 1406, 1, 0, 0, 0, 1530, 1413, 1, 0, 0, 0, 1530, 1421, 1, 0, 0, 0, 1530, 1423, 1, 0, 0, 0, 1530, 1425, 1, 0, 0, 0, 1530, 1427, 1, 0, 0, 0, 1530, 1429, 1, 0, 0, 0, 1530, 1431, 1, 0, 0, 0, 1530, 1433, 1, 0, 0, 0, 1530, 1435, 1, 0, 0, 0, 1530, 1437, 1, 0, 0, 0, 1530, 1439, 1, 0, 0, 0, 1530, 1441, 1, 0, 0, 0, 1530, 1443, 1, 0, 0, 0, 1530, 1445, 1, 0, 0, 0, 1530, 1447, 1, 0, 0, 0, 1530, 1449, 1, 0, 0, 0, 1530, 1451, 1, 0, 0, 0, 1530, 1453, 1, 0, 0, 0, 1530, 1455, 1, 0, 0, 0, 1530, 1457, 1, 0, 0, 0, 1530, 1459, 1, 0, 0, 0, 1530, 1461, 1, 0, 0, 0, 1530, 1463, 1, 0, 0, 0, 1530, 1465, 1, 0, 0, 0, 1530, 1467, 1, 0, 0, 0, 1530, 1471, 1, 0, 0, 0, 1530, 1475, 1, 0, 0, 0, 1530, 1477, 1, 0, 0, 0, 1530, 1481, 1, 0, 0, 0, 1530, 1485, 1, 0, 0, 0, 1530, 1491, 1, 0, 0, 0, 1530, 1493, 1, 0, 0, 0, 1530, 1495, 1, 0, 0, 0, 1530, 1498, 1, 0, 0, 0, 1530, 1501, 1, 0, 0, 0, 1530, 1504, 1, 0, 0, 0, 1530, 1507, 1, 0, 0, 0, 1530, 1510, 1, 0, 0, 0, 1530, 1512, 1, 0, 0, 0, 1530, 1515, 1, 0, 0, 0, 1530, 1517, 1, 0, 0, 0, 1530, 1520, 1, 0, 0, 0, 1530, 1522, 1, 0, 0, 0, 1530, 1524, 1, 0, 0, 0, 1530, 1527, 1, 0, 0, 0, 1531, 131, 1, 0, 0, 0, 1532, 1541, 1, 0, 0, 0, 1533, 1534, 5, 30, 0, 0, 1534, 1535, 5, 91, 0, 0, 1535, 1536, 5, 36, 0, 0, 1536, 1537, 3, 32, 16, 0, 1537, 1538, 5, 31, 0, 0, 1538, 1539, 6, 66, -1, 0, 1539, 1541, 1, 0, 0, 0, 1540, 1532, 1, 0, 0, 0, 1540, 1533, 1, 0, 0, 0, 1541, 133, 1, 0, 0, 0, 1542, 1553, 1, 0, 0, 0, 1543, 1544, 3, 136, 68, 0, 1544, 1549, 6, 67, -1, 0, 1545, 1546, 7, 7, 0, 0, 1546, 1548, 6, 67, -1, 0, 1547, 1545, 1, 0, 0, 0, 1548, 1551, 1, 0, 0, 0, 1549, 1547, 1, 0, 0, 0, 1549, 1550, 1, 0, 0, 0, 1550, 1553, 1, 0, 0, 0, 1551, 1549, 1, 0, 0, 0, 1552, 1542, 1, 0, 0, 0, 1552, 1543, 1, 0, 0, 0, 1553, 135, 1, 0, 0, 0, 1554, 1555, 5, 178, 0, 0, 1555, 1635, 6, 68, -1, 0, 1556, 1557, 5, 207, 0, 0, 1557, 1635, 6, 68, -1, 0, 1558, 1559, 5, 208, 0, 0, 1559, 1635, 6, 68, -1, 0, 1560, 1561, 5, 201, 0, 0, 1561, 1635, 6, 68, -1, 0, 1562, 1563, 5, 183, 0, 0, 1563, 1635, 6, 68, -1, 0, 1564, 1565, 5, 184, 0, 0, 1565, 1635, 6, 68, -1, 0, 1566, 1567, 5, 185, 0, 0, 1567, 1635, 6, 68, -1, 0, 1568, 1569, 5, 186, 0, 0, 1569, 1635, 6, 68, -1, 0, 1570, 1571, 5, 187, 0, 0, 1571, 1635, 6, 68, -1, 0, 1572, 1573, 5, 188, 0, 0, 1573, 1635, 6, 68, -1, 0, 1574, 1575, 5, 189, 0, 0, 1575, 1635, 6, 68, -1, 0, 1576, 1577, 5, 190, 0, 0, 1577, 1635, 6, 68, -1, 0, 1578, 1579, 5, 191, 0, 0, 1579, 1635, 6, 68, -1, 0, 1580, 1581, 5, 192, 0, 0, 1581, 1635, 6, 68, -1, 0, 1582, 1583, 5, 193, 0, 0, 1583, 1635, 6, 68, -1, 0, 1584, 1585, 5, 262, 0, 0, 1585, 1635, 6, 68, -1, 0, 1586, 1587, 5, 211, 0, 0, 1587, 1635, 6, 68, -1, 0, 1588, 1589, 5, 212, 0, 0, 1589, 1635, 6, 68, -1, 0, 1590, 1591, 5, 213, 0, 0, 1591, 1635, 6, 68, -1, 0, 1592, 1593, 5, 214, 0, 0, 1593, 1635, 6, 68, -1, 0, 1594, 1595, 5, 215, 0, 0, 1595, 1635, 6, 68, -1, 0, 1596, 1597, 5, 218, 0, 0, 1597, 1635, 6, 68, -1, 0, 1598, 1599, 5, 219, 0, 0, 1599, 1635, 6, 68, -1, 0, 1600, 1601, 5, 222, 0, 0, 1601, 1635, 6, 68, -1, 0, 1602, 1603, 5, 194, 0, 0, 1603, 1635, 6, 68, -1, 0, 1604, 1605, 5, 195, 0, 0, 1605, 1635, 6, 68, -1, 0, 1606, 1607, 5, 210, 0, 0, 1607, 1635, 6, 68, -1, 0, 1608, 1609, 5, 230, 0, 0, 1609, 1635, 6, 68, -1, 0, 1610, 1611, 5, 231, 0, 0, 1611, 1635, 6, 68, -1, 0, 1612, 1613, 5, 232, 0, 0, 1613, 1635, 6, 68, -1, 0, 1614, 1615, 5, 233, 0, 0, 1615, 1635, 6, 68, -1, 0, 1616, 1617, 5, 234, 0, 0, 1617, 1635, 6, 68, -1, 0, 1618, 1619, 5, 235, 0, 0, 1619, 1635, 6, 68, -1, 0, 1620, 1621, 5, 236, 0, 0, 1621, 1635, 6, 68, -1, 0, 1622, 1623, 5, 237, 0, 0, 1623, 1635, 6, 68, -1, 0, 1624, 1625, 5, 238, 0, 0, 1625, 1635, 6, 68, -1, 0, 1626, 1627, 5, 239, 0, 0, 1627, 1635, 6, 68, -1, 0, 1628, 1629, 5, 240, 0, 0, 1629, 1635, 6, 68, -1, 0, 1630, 1631, 5, 241, 0, 0, 1631, 1635, 6, 68, -1, 0, 1632, 1633, 5, 242, 0, 0, 1633, 1635, 6, 68, -1, 0, 1634, 1554, 1, 0, 0, 0, 1634, 1556, 1, 0, 0, 0, 1634, 1558, 1, 0, 0, 0, 1634, 1560, 1, 0, 0, 0, 1634, 1562, 1, 0, 0, 0, 1634, 1564, 1, 0, 0, 0, 1634, 1566, 1, 0, 0, 0, 1634, 1568, 1, 0, 0, 0, 1634, 1570, 1, 0, 0, 0, 1634, 1572, 1, 0, 0, 0, 1634, 1574, 1, 0, 0, 0, 1634, 1576, 1, 0, 0, 0, 1634, 1578, 1, 0, 0, 0, 1634, 1580, 1, 0, 0, 0, 1634, 1582, 1, 0, 0, 0, 1634, 1584, 1, 0, 0, 0, 1634, 1586, 1, 0, 0, 0, 1634, 1588, 1, 0, 0, 0, 1634, 1590, 1, 0, 0, 0, 1634, 1592, 1, 0, 0, 0, 1634, 1594, 1, 0, 0, 0, 1634, 1596, 1, 0, 0, 0, 1634, 1598, 1, 0, 0, 0, 1634, 1600, 1, 0, 0, 0, 1634, 1602, 1, 0, 0, 0, 1634, 1604, 1, 0, 0, 0, 1634, 1606, 1, 0, 0, 0, 1634, 1608, 1, 0, 0, 0, 1634, 1610, 1, 0, 0, 0, 1634, 1612, 1, 0, 0, 0, 1634, 1614, 1, 0, 0, 0, 1634, 1616, 1, 0, 0, 0, 1634, 1618, 1, 0, 0, 0, 1634, 1620, 1, 0, 0, 0, 1634, 1622, 1, 0, 0, 0, 1634, 1624, 1, 0, 0, 0, 1634, 1626, 1, 0, 0, 0, 1634, 1628, 1, 0, 0, 0, 1634, 1630, 1, 0, 0, 0, 1634, 1632, 1, 0, 0, 0, 1635, 137, 1, 0, 0, 0, 1636, 1637, 3, 142, 71, 0, 1637, 1643, 6, 69, -1, 0, 1638, 1639, 3, 140, 70, 0, 1639, 1640, 6, 69, -1, 0, 1640, 1642, 1, 0, 0, 0, 1641, 1638, 1, 0, 0, 0, 1642, 1645, 1, 0, 0, 0, 1643, 1641, 1, 0, 0, 0, 1643, 1644, 1, 0, 0, 0, 1644, 139, 1, 0, 0, 0, 1645, 1643, 1, 0, 0, 0, 1646, 1647, 5, 261, 0, 0, 1647, 1676, 6, 70, -1, 0, 1648, 1649, 5, 42, 0, 0, 1649, 1650, 5, 43, 0, 0, 1650, 1676, 6, 70, -1, 0, 1651, 1652, 3, 110, 55, 0, 1652, 1653, 6, 70, -1, 0, 1653, 1676, 1, 0, 0, 0, 1654, 1655, 5, 260, 0, 0, 1655, 1676, 6, 70, -1, 0, 1656, 1657, 5, 262, 0, 0, 1657, 1676, 6, 70, -1, 0, 1658, 1659, 5, 92, 0, 0, 1659, 1676, 6, 70, -1, 0, 1660, 1661, 5, 93, 0, 0, 1661, 1662, 5, 30, 0, 0, 1662, 1663, 3, 124, 62, 0, 1663, 1664, 5, 31, 0, 0, 1664, 1665, 6, 70, -1, 0, 1665, 1676, 1, 0, 0, 0, 1666, 1667, 5, 94, 0, 0, 1667, 1668, 5, 30, 0, 0, 1668, 1669, 3, 124, 62, 0, 1669, 1670, 5, 31, 0, 0, 1670, 1671, 6, 70, -1, 0, 1671, 1676, 1, 0, 0, 0, 1672, 1673, 3, 108, 54, 0, 1673, 1674, 6, 70, -1, 0, 1674, 1676, 1, 0, 0, 0, 1675, 1646, 1, 0, 0, 0, 1675, 1648, 1, 0, 0, 0, 1675, 1651, 1, 0, 0, 0, 1675, 1654, 1, 0, 0, 0, 1675, 1656, 1, 0, 0, 0, 1675, 1658, 1, 0, 0, 0, 1675, 1660, 1, 0, 0, 0, 1675, 1666, 1, 0, 0, 0, 1675, 1672, 1, 0, 0, 0, 1676, 141, 1, 0, 0, 0, 1677, 1678, 5, 39, 0, 0, 1678, 1679, 3, 116, 58, 0, 1679, 1680, 6, 71, -1, 0, 1680, 1736, 1, 0, 0, 0, 1681, 1682, 5, 197, 0, 0, 1682, 1736, 6, 71, -1, 0, 1683, 1684, 5, 199, 0, 0, 1684, 1685, 5, 39, 0, 0, 1685, 1686, 3, 116, 58, 0, 1686, 1687, 6, 71, -1, 0, 1687, 1736, 1, 0, 0, 0, 1688, 1689, 5, 200, 0, 0, 1689, 1690, 3, 116, 58, 0, 1690, 1691, 6, 71, -1, 0, 1691, 1736, 1, 0, 0, 0, 1692, 1693, 5, 226, 0, 0, 1693, 1694, 3, 170, 85, 0, 1694, 1695, 3, 138, 69, 0, 1695, 1696, 5, 262, 0, 0, 1696, 1697, 3, 112, 56, 0, 1697, 1698, 6, 71, -1, 0, 1698, 1736, 1, 0, 0, 0, 1699, 1700, 5, 253, 0, 0, 1700, 1701, 3, 32, 16, 0, 1701, 1702, 6, 71, -1, 0, 1702, 1736, 1, 0, 0, 0, 1703, 1704, 5, 252, 0, 0, 1704, 1705, 3, 32, 16, 0, 1705, 1706, 6, 71, -1, 0, 1706, 1736, 1, 0, 0, 0, 1707, 1708, 5, 253, 0, 0, 1708, 1709, 3, 2, 1, 0, 1709, 1710, 6, 71, -1, 0, 1710, 1736, 1, 0, 0, 0, 1711, 1712, 5, 252, 0, 0, 1712, 1713, 3, 2, 1, 0, 1713, 1714, 6, 71, -1, 0, 1714, 1736, 1, 0, 0, 0, 1715, 1716, 5, 254, 0, 0, 1716, 1736, 6, 71, -1, 0, 1717, 1718, 5, 201, 0, 0, 1718, 1736, 6, 71, -1, 0, 1719, 1720, 3, 148, 74, 0, 1720, 1721, 6, 71, -1, 0, 1721, 1736, 1, 0, 0, 0, 1722, 1723, 3, 150, 75, 0, 1723, 1724, 6, 71, -1, 0, 1724, 1736, 1, 0, 0, 0, 1725, 1726, 3, 144, 72, 0, 1726, 1727, 6, 71, -1, 0, 1727, 1736, 1, 0, 0, 0, 1728, 1729, 3, 2, 1, 0, 1729, 1730, 6, 71, -1, 0, 1730, 1736, 1, 0, 0, 0, 1731, 1732, 5, 177, 0, 0, 1732, 1733, 3, 138, 69, 0, 1733, 1734, 6, 71, -1, 0, 1734, 1736, 1, 0, 0, 0, 1735, 1677, 1, 0, 0, 0, 1735, 1681, 1, 0, 0, 0, 1735, 1683, 1, 0, 0, 0, 1735, 1688, 1, 0, 0, 0, 1735, 1692, 1, 0, 0, 0, 1735, 1699, 1, 0, 0, 0, 1735, 1703, 1, 0, 0, 0, 1735, 1707, 1, 0, 0, 0, 1735, 1711, 1, 0, 0, 0, 1735, 1715, 1, 0, 0, 0, 1735, 1717, 1, 0, 0, 0, 1735, 1719, 1, 0, 0, 0, 1735, 1722, 1, 0, 0, 0, 1735, 1725, 1, 0, 0, 0, 1735, 1728, 1, 0, 0, 0, 1735, 1731, 1, 0, 0, 0, 1736, 143, 1, 0, 0, 0, 1737, 1738, 5, 181, 0, 0, 1738, 1776, 6, 72, -1, 0, 1739, 1740, 5, 182, 0, 0, 1740, 1776, 6, 72, -1, 0, 1741, 1742, 5, 183, 0, 0, 1742, 1776, 6, 72, -1, 0, 1743, 1744, 5, 184, 0, 0, 1744, 1776, 6, 72, -1, 0, 1745, 1746, 5, 185, 0, 0, 1746, 1776, 6, 72, -1, 0, 1747, 1748, 5, 186, 0, 0, 1748, 1776, 6, 72, -1, 0, 1749, 1750, 5, 187, 0, 0, 1750, 1776, 6, 72, -1, 0, 1751, 1752, 5, 188, 0, 0, 1752, 1776, 6, 72, -1, 0, 1753, 1754, 5, 189, 0, 0, 1754, 1776, 6, 72, -1, 0, 1755, 1756, 5, 190, 0, 0, 1756, 1776, 6, 72, -1, 0, 1757, 1758, 5, 191, 0, 0, 1758, 1776, 6, 72, -1, 0, 1759, 1760, 5, 192, 0, 0, 1760, 1776, 6, 72, -1, 0, 1761, 1762, 5, 193, 0, 0, 1762, 1776, 6, 72, -1, 0, 1763, 1764, 5, 90, 0, 0, 1764, 1765, 5, 184, 0, 0, 1765, 1776, 6, 72, -1, 0, 1766, 1767, 5, 90, 0, 0, 1767, 1768, 5, 185, 0, 0, 1768, 1776, 6, 72, -1, 0, 1769, 1770, 5, 90, 0, 0, 1770, 1771, 5, 186, 0, 0, 1771, 1776, 6, 72, -1, 0, 1772, 1773, 5, 90, 0, 0, 1773, 1774, 5, 187, 0, 0, 1774, 1776, 6, 72, -1, 0, 1775, 1737, 1, 0, 0, 0, 1775, 1739, 1, 0, 0, 0, 1775, 1741, 1, 0, 0, 0, 1775, 1743, 1, 0, 0, 0, 1775, 1745, 1, 0, 0, 0, 1775, 1747, 1, 0, 0, 0, 1775, 1749, 1, 0, 0, 0, 1775, 1751, 1, 0, 0, 0, 1775, 1753, 1, 0, 0, 0, 1775, 1755, 1, 0, 0, 0, 1775, 1757, 1, 0, 0, 0, 1775, 1759, 1, 0, 0, 0, 1775, 1761, 1, 0, 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, 145, 1, 0, 0, 0, 1777, 1792, 1, 0, 0, 0, 1778, 1792, 5, 177, 0, 0, 1779, 1780, 3, 32, 16, 0, 1780, 1781, 6, 73, -1, 0, 1781, 1792, 1, 0, 0, 0, 1782, 1783, 3, 32, 16, 0, 1783, 1784, 5, 177, 0, 0, 1784, 1785, 3, 32, 16, 0, 1785, 1786, 6, 73, -1, 0, 1786, 1792, 1, 0, 0, 0, 1787, 1788, 3, 32, 16, 0, 1788, 1789, 5, 177, 0, 0, 1789, 1790, 6, 73, -1, 0, 1790, 1792, 1, 0, 0, 0, 1791, 1777, 1, 0, 0, 0, 1791, 1778, 1, 0, 0, 0, 1791, 1779, 1, 0, 0, 0, 1791, 1782, 1, 0, 0, 0, 1791, 1787, 1, 0, 0, 0, 1792, 147, 1, 0, 0, 0, 1793, 1794, 5, 1, 0, 0, 1794, 1795, 5, 194, 0, 0, 1795, 1796, 6, 74, -1, 0, 1796, 149, 1, 0, 0, 0, 1797, 1801, 5, 1, 0, 0, 1798, 1799, 5, 90, 0, 0, 1799, 1802, 5, 194, 0, 0, 1800, 1802, 5, 195, 0, 0, 1801, 1798, 1, 0, 0, 0, 1801, 1800, 1, 0, 0, 0, 1802, 1803, 1, 0, 0, 0, 1803, 1804, 6, 75, -1, 0, 1804, 151, 1, 0, 0, 0, 1805, 1806, 5, 294, 0, 0, 1806, 1807, 3, 166, 83, 0, 1807, 1808, 3, 124, 62, 0, 1808, 1809, 5, 30, 0, 0, 1809, 1810, 3, 158, 79, 0, 1810, 1811, 5, 31, 0, 0, 1811, 1853, 1, 0, 0, 0, 1812, 1813, 5, 294, 0, 0, 1813, 1814, 3, 166, 83, 0, 1814, 1815, 3, 124, 62, 0, 1815, 1816, 5, 36, 0, 0, 1816, 1817, 5, 17, 0, 0, 1817, 1818, 3, 52, 26, 0, 1818, 1819, 5, 18, 0, 0, 1819, 1853, 1, 0, 0, 0, 1820, 1821, 5, 294, 0, 0, 1821, 1822, 3, 166, 83, 0, 1822, 1823, 3, 124, 62, 0, 1823, 1853, 1, 0, 0, 0, 1824, 1825, 5, 295, 0, 0, 1825, 1826, 3, 166, 83, 0, 1826, 1828, 5, 36, 0, 0, 1827, 1829, 5, 84, 0, 0, 1828, 1827, 1, 0, 0, 0, 1828, 1829, 1, 0, 0, 0, 1829, 1830, 1, 0, 0, 0, 1830, 1831, 5, 30, 0, 0, 1831, 1832, 3, 300, 150, 0, 1832, 1833, 5, 31, 0, 0, 1833, 1853, 1, 0, 0, 0, 1834, 1835, 5, 295, 0, 0, 1835, 1836, 3, 166, 83, 0, 1836, 1837, 5, 84, 0, 0, 1837, 1838, 5, 30, 0, 0, 1838, 1839, 3, 300, 150, 0, 1839, 1840, 5, 31, 0, 0, 1840, 1853, 1, 0, 0, 0, 1841, 1842, 5, 295, 0, 0, 1842, 1843, 3, 166, 83, 0, 1843, 1844, 3, 6, 3, 0, 1844, 1853, 1, 0, 0, 0, 1845, 1846, 5, 295, 0, 0, 1846, 1847, 3, 166, 83, 0, 1847, 1848, 5, 36, 0, 0, 1848, 1849, 5, 17, 0, 0, 1849, 1850, 3, 154, 77, 0, 1850, 1851, 5, 18, 0, 0, 1851, 1853, 1, 0, 0, 0, 1852, 1805, 1, 0, 0, 0, 1852, 1812, 1, 0, 0, 0, 1852, 1820, 1, 0, 0, 0, 1852, 1824, 1, 0, 0, 0, 1852, 1834, 1, 0, 0, 0, 1852, 1841, 1, 0, 0, 0, 1852, 1845, 1, 0, 0, 0, 1853, 153, 1, 0, 0, 0, 1854, 1865, 1, 0, 0, 0, 1855, 1856, 3, 156, 78, 0, 1856, 1857, 5, 28, 0, 0, 1857, 1859, 1, 0, 0, 0, 1858, 1855, 1, 0, 0, 0, 1859, 1862, 1, 0, 0, 0, 1860, 1858, 1, 0, 0, 0, 1860, 1861, 1, 0, 0, 0, 1861, 1863, 1, 0, 0, 0, 1862, 1860, 1, 0, 0, 0, 1863, 1865, 3, 156, 78, 0, 1864, 1854, 1, 0, 0, 0, 1864, 1860, 1, 0, 0, 0, 1865, 155, 1, 0, 0, 0, 1866, 1867, 5, 39, 0, 0, 1867, 1868, 5, 264, 0, 0, 1868, 1869, 5, 36, 0, 0, 1869, 1870, 5, 17, 0, 0, 1870, 1871, 3, 56, 28, 0, 1871, 1872, 5, 18, 0, 0, 1872, 1880, 1, 0, 0, 0, 1873, 1874, 3, 124, 62, 0, 1874, 1875, 5, 36, 0, 0, 1875, 1876, 5, 17, 0, 0, 1876, 1877, 3, 56, 28, 0, 1877, 1878, 5, 18, 0, 0, 1878, 1880, 1, 0, 0, 0, 1879, 1866, 1, 0, 0, 0, 1879, 1873, 1, 0, 0, 0, 1880, 157, 1, 0, 0, 0, 1881, 1882, 3, 160, 80, 0, 1882, 1883, 5, 28, 0, 0, 1883, 1885, 1, 0, 0, 0, 1884, 1881, 1, 0, 0, 0, 1885, 1888, 1, 0, 0, 0, 1886, 1884, 1, 0, 0, 0, 1886, 1887, 1, 0, 0, 0, 1887, 1889, 1, 0, 0, 0, 1888, 1886, 1, 0, 0, 0, 1889, 1890, 3, 160, 80, 0, 1890, 159, 1, 0, 0, 0, 1891, 1892, 3, 6, 3, 0, 1892, 1893, 5, 36, 0, 0, 1893, 1894, 3, 164, 82, 0, 1894, 161, 1, 0, 0, 0, 1895, 1896, 7, 8, 0, 0, 1896, 163, 1, 0, 0, 0, 1897, 1932, 3, 162, 81, 0, 1898, 1932, 3, 32, 16, 0, 1899, 1900, 5, 186, 0, 0, 1900, 1901, 5, 30, 0, 0, 1901, 1902, 3, 32, 16, 0, 1902, 1903, 5, 31, 0, 0, 1903, 1932, 1, 0, 0, 0, 1904, 1932, 3, 6, 3, 0, 1905, 1906, 3, 116, 58, 0, 1906, 1907, 5, 30, 0, 0, 1907, 1908, 5, 184, 0, 0, 1908, 1909, 5, 75, 0, 0, 1909, 1910, 3, 32, 16, 0, 1910, 1911, 5, 31, 0, 0, 1911, 1932, 1, 0, 0, 0, 1912, 1913, 3, 116, 58, 0, 1913, 1914, 5, 30, 0, 0, 1914, 1915, 5, 185, 0, 0, 1915, 1916, 5, 75, 0, 0, 1916, 1917, 3, 32, 16, 0, 1917, 1918, 5, 31, 0, 0, 1918, 1932, 1, 0, 0, 0, 1919, 1920, 3, 116, 58, 0, 1920, 1921, 5, 30, 0, 0, 1921, 1922, 5, 186, 0, 0, 1922, 1923, 5, 75, 0, 0, 1923, 1924, 3, 32, 16, 0, 1924, 1925, 5, 31, 0, 0, 1925, 1932, 1, 0, 0, 0, 1926, 1927, 3, 116, 58, 0, 1927, 1928, 5, 30, 0, 0, 1928, 1929, 3, 32, 16, 0, 1929, 1930, 5, 31, 0, 0, 1930, 1932, 1, 0, 0, 0, 1931, 1897, 1, 0, 0, 0, 1931, 1898, 1, 0, 0, 0, 1931, 1899, 1, 0, 0, 0, 1931, 1904, 1, 0, 0, 0, 1931, 1905, 1, 0, 0, 0, 1931, 1912, 1, 0, 0, 0, 1931, 1919, 1, 0, 0, 0, 1931, 1926, 1, 0, 0, 0, 1932, 165, 1, 0, 0, 0, 1933, 1934, 7, 9, 0, 0, 1934, 167, 1, 0, 0, 0, 1935, 1936, 3, 170, 85, 0, 1936, 1937, 3, 138, 69, 0, 1937, 1938, 3, 124, 62, 0, 1938, 1939, 5, 176, 0, 0, 1939, 1941, 3, 242, 121, 0, 1940, 1942, 3, 108, 54, 0, 1941, 1940, 1, 0, 0, 0, 1941, 1942, 1, 0, 0, 0, 1942, 1943, 1, 0, 0, 0, 1943, 1944, 3, 112, 56, 0, 1944, 1945, 6, 84, -1, 0, 1945, 1978, 1, 0, 0, 0, 1946, 1947, 3, 170, 85, 0, 1947, 1948, 3, 138, 69, 0, 1948, 1949, 3, 124, 62, 0, 1949, 1950, 5, 176, 0, 0, 1950, 1951, 3, 242, 121, 0, 1951, 1952, 3, 196, 98, 0, 1952, 1953, 3, 112, 56, 0, 1953, 1954, 6, 84, -1, 0, 1954, 1978, 1, 0, 0, 0, 1955, 1956, 3, 170, 85, 0, 1956, 1957, 3, 138, 69, 0, 1957, 1959, 3, 242, 121, 0, 1958, 1960, 3, 108, 54, 0, 1959, 1958, 1, 0, 0, 0, 1959, 1960, 1, 0, 0, 0, 1960, 1961, 1, 0, 0, 0, 1961, 1962, 3, 112, 56, 0, 1962, 1963, 6, 84, -1, 0, 1963, 1978, 1, 0, 0, 0, 1964, 1965, 3, 170, 85, 0, 1965, 1966, 3, 138, 69, 0, 1966, 1967, 3, 242, 121, 0, 1967, 1968, 3, 196, 98, 0, 1968, 1969, 3, 112, 56, 0, 1969, 1970, 6, 84, -1, 0, 1970, 1978, 1, 0, 0, 0, 1971, 1972, 3, 174, 87, 0, 1972, 1973, 6, 84, -1, 0, 1973, 1978, 1, 0, 0, 0, 1974, 1975, 3, 2, 1, 0, 1975, 1976, 6, 84, -1, 0, 1976, 1978, 1, 0, 0, 0, 1977, 1935, 1, 0, 0, 0, 1977, 1946, 1, 0, 0, 0, 1977, 1955, 1, 0, 0, 0, 1977, 1964, 1, 0, 0, 0, 1977, 1971, 1, 0, 0, 0, 1977, 1974, 1, 0, 0, 0, 1978, 169, 1, 0, 0, 0, 1979, 1980, 5, 243, 0, 0, 1980, 1981, 3, 170, 85, 0, 1981, 1982, 6, 85, -1, 0, 1982, 1997, 1, 0, 0, 0, 1983, 1984, 5, 244, 0, 0, 1984, 1985, 3, 170, 85, 0, 1985, 1986, 6, 85, -1, 0, 1986, 1997, 1, 0, 0, 0, 1987, 1988, 3, 172, 86, 0, 1988, 1989, 6, 85, -1, 0, 1989, 1997, 1, 0, 0, 0, 1990, 1991, 5, 112, 0, 0, 1991, 1992, 5, 30, 0, 0, 1992, 1993, 3, 32, 16, 0, 1993, 1994, 5, 31, 0, 0, 1994, 1995, 6, 85, -1, 0, 1995, 1997, 1, 0, 0, 0, 1996, 1979, 1, 0, 0, 0, 1996, 1983, 1, 0, 0, 0, 1996, 1987, 1, 0, 0, 0, 1996, 1990, 1, 0, 0, 0, 1997, 171, 1, 0, 0, 0, 1998, 2018, 1, 0, 0, 0, 1999, 2000, 5, 245, 0, 0, 2000, 2018, 6, 86, -1, 0, 2001, 2002, 5, 246, 0, 0, 2002, 2018, 6, 86, -1, 0, 2003, 2004, 5, 247, 0, 0, 2004, 2005, 5, 248, 0, 0, 2005, 2018, 6, 86, -1, 0, 2006, 2007, 5, 247, 0, 0, 2007, 2008, 5, 249, 0, 0, 2008, 2018, 6, 86, -1, 0, 2009, 2010, 5, 247, 0, 0, 2010, 2011, 5, 250, 0, 0, 2011, 2018, 6, 86, -1, 0, 2012, 2013, 5, 247, 0, 0, 2013, 2014, 5, 251, 0, 0, 2014, 2018, 6, 86, -1, 0, 2015, 2016, 5, 247, 0, 0, 2016, 2018, 6, 86, -1, 0, 2017, 1998, 1, 0, 0, 0, 2017, 1999, 1, 0, 0, 0, 2017, 2001, 1, 0, 0, 0, 2017, 2003, 1, 0, 0, 0, 2017, 2006, 1, 0, 0, 0, 2017, 2009, 1, 0, 0, 0, 2017, 2012, 1, 0, 0, 0, 2017, 2015, 1, 0, 0, 0, 2018, 173, 1, 0, 0, 0, 2019, 2020, 5, 113, 0, 0, 2020, 2021, 5, 30, 0, 0, 2021, 2022, 3, 32, 16, 0, 2022, 2023, 5, 31, 0, 0, 2023, 2024, 6, 87, -1, 0, 2024, 175, 1, 0, 0, 0, 2025, 2026, 5, 226, 0, 0, 2026, 2027, 3, 168, 84, 0, 2027, 2028, 6, 88, -1, 0, 2028, 2037, 1, 0, 0, 0, 2029, 2030, 5, 37, 0, 0, 2030, 2031, 3, 178, 89, 0, 2031, 2032, 6, 88, -1, 0, 2032, 2037, 1, 0, 0, 0, 2033, 2034, 3, 174, 87, 0, 2034, 2035, 6, 88, -1, 0, 2035, 2037, 1, 0, 0, 0, 2036, 2025, 1, 0, 0, 0, 2036, 2029, 1, 0, 0, 0, 2036, 2033, 1, 0, 0, 0, 2037, 177, 1, 0, 0, 0, 2038, 2039, 3, 138, 69, 0, 2039, 2040, 3, 124, 62, 0, 2040, 2041, 5, 176, 0, 0, 2041, 2042, 3, 2, 1, 0, 2042, 2043, 6, 89, -1, 0, 2043, 2052, 1, 0, 0, 0, 2044, 2045, 3, 138, 69, 0, 2045, 2046, 3, 2, 1, 0, 2046, 2047, 6, 89, -1, 0, 2047, 2052, 1, 0, 0, 0, 2048, 2049, 3, 2, 1, 0, 2049, 2050, 6, 89, -1, 0, 2050, 2052, 1, 0, 0, 0, 2051, 2038, 1, 0, 0, 0, 2051, 2044, 1, 0, 0, 0, 2051, 2048, 1, 0, 0, 0, 2052, 179, 1, 0, 0, 0, 2053, 2054, 3, 124, 62, 0, 2054, 2055, 6, 90, -1, 0, 2055, 2056, 5, 28, 0, 0, 2056, 2058, 1, 0, 0, 0, 2057, 2053, 1, 0, 0, 0, 2058, 2061, 1, 0, 0, 0, 2059, 2057, 1, 0, 0, 0, 2059, 2060, 1, 0, 0, 0, 2060, 2062, 1, 0, 0, 0, 2061, 2059, 1, 0, 0, 0, 2062, 2063, 3, 124, 62, 0, 2063, 2064, 6, 90, -1, 0, 2064, 181, 1, 0, 0, 0, 2065, 2072, 1, 0, 0, 0, 2066, 2067, 5, 86, 0, 0, 2067, 2068, 3, 190, 95, 0, 2068, 2069, 5, 87, 0, 0, 2069, 2070, 6, 91, -1, 0, 2070, 2072, 1, 0, 0, 0, 2071, 2065, 1, 0, 0, 0, 2071, 2066, 1, 0, 0, 0, 2072, 183, 1, 0, 0, 0, 2073, 2074, 5, 266, 0, 0, 2074, 2092, 6, 92, -1, 0, 2075, 2076, 5, 114, 0, 0, 2076, 2092, 6, 92, -1, 0, 2077, 2078, 5, 39, 0, 0, 2078, 2092, 6, 92, -1, 0, 2079, 2080, 5, 200, 0, 0, 2080, 2092, 6, 92, -1, 0, 2081, 2082, 5, 115, 0, 0, 2082, 2092, 6, 92, -1, 0, 2083, 2084, 5, 116, 0, 0, 2084, 2092, 6, 92, -1, 0, 2085, 2086, 5, 70, 0, 0, 2086, 2087, 5, 30, 0, 0, 2087, 2088, 3, 32, 16, 0, 2088, 2089, 5, 31, 0, 0, 2089, 2090, 6, 92, -1, 0, 2090, 2092, 1, 0, 0, 0, 2091, 2073, 1, 0, 0, 0, 2091, 2075, 1, 0, 0, 0, 2091, 2077, 1, 0, 0, 0, 2091, 2079, 1, 0, 0, 0, 2091, 2081, 1, 0, 0, 0, 2091, 2083, 1, 0, 0, 0, 2091, 2085, 1, 0, 0, 0, 2092, 185, 1, 0, 0, 0, 2093, 2094, 3, 184, 92, 0, 2094, 2095, 6, 93, -1, 0, 2095, 2097, 1, 0, 0, 0, 2096, 2093, 1, 0, 0, 0, 2097, 2100, 1, 0, 0, 0, 2098, 2096, 1, 0, 0, 0, 2098, 2099, 1, 0, 0, 0, 2099, 187, 1, 0, 0, 0, 2100, 2098, 1, 0, 0, 0, 2101, 2103, 3, 186, 93, 0, 2102, 2104, 3, 192, 96, 0, 2103, 2102, 1, 0, 0, 0, 2103, 2104, 1, 0, 0, 0, 2104, 2105, 1, 0, 0, 0, 2105, 2106, 3, 2, 1, 0, 2106, 2107, 6, 94, -1, 0, 2107, 189, 1, 0, 0, 0, 2108, 2109, 3, 188, 94, 0, 2109, 2110, 6, 95, -1, 0, 2110, 2111, 5, 28, 0, 0, 2111, 2113, 1, 0, 0, 0, 2112, 2108, 1, 0, 0, 0, 2113, 2116, 1, 0, 0, 0, 2114, 2112, 1, 0, 0, 0, 2114, 2115, 1, 0, 0, 0, 2115, 2117, 1, 0, 0, 0, 2116, 2114, 1, 0, 0, 0, 2117, 2118, 3, 188, 94, 0, 2118, 2119, 6, 95, -1, 0, 2119, 191, 1, 0, 0, 0, 2120, 2121, 5, 30, 0, 0, 2121, 2122, 3, 180, 90, 0, 2122, 2123, 5, 31, 0, 0, 2123, 2124, 6, 96, -1, 0, 2124, 193, 1, 0, 0, 0, 2125, 2127, 3, 196, 98, 0, 2126, 2125, 1, 0, 0, 0, 2126, 2127, 1, 0, 0, 0, 2127, 2128, 1, 0, 0, 0, 2128, 2129, 6, 97, -1, 0, 2129, 195, 1, 0, 0, 0, 2130, 2131, 5, 86, 0, 0, 2131, 2132, 5, 42, 0, 0, 2132, 2133, 3, 32, 16, 0, 2133, 2134, 5, 43, 0, 0, 2134, 2135, 5, 87, 0, 0, 2135, 2136, 6, 98, -1, 0, 2136, 197, 1, 0, 0, 0, 2137, 2138, 3, 234, 117, 0, 2138, 2139, 5, 17, 0, 0, 2139, 2140, 3, 246, 123, 0, 2140, 2141, 5, 18, 0, 0, 2141, 2288, 1, 0, 0, 0, 2142, 2143, 3, 74, 37, 0, 2143, 2144, 5, 17, 0, 0, 2144, 2145, 3, 82, 41, 0, 2145, 2146, 5, 18, 0, 0, 2146, 2288, 1, 0, 0, 0, 2147, 2148, 3, 210, 105, 0, 2148, 2149, 6, 99, -1, 0, 2149, 2150, 5, 17, 0, 0, 2150, 2151, 3, 214, 107, 0, 2151, 2152, 5, 18, 0, 0, 2152, 2288, 1, 0, 0, 0, 2153, 2154, 3, 218, 109, 0, 2154, 2155, 6, 99, -1, 0, 2155, 2156, 5, 17, 0, 0, 2156, 2157, 3, 222, 111, 0, 2157, 2158, 5, 18, 0, 0, 2158, 2288, 1, 0, 0, 0, 2159, 2288, 3, 200, 100, 0, 2160, 2161, 3, 284, 142, 0, 2161, 2162, 6, 99, -1, 0, 2162, 2288, 1, 0, 0, 0, 2163, 2164, 3, 152, 76, 0, 2164, 2165, 6, 99, -1, 0, 2165, 2288, 1, 0, 0, 0, 2166, 2167, 3, 88, 44, 0, 2167, 2168, 6, 99, -1, 0, 2168, 2288, 1, 0, 0, 0, 2169, 2170, 3, 330, 165, 0, 2170, 2171, 6, 99, -1, 0, 2171, 2288, 1, 0, 0, 0, 2172, 2173, 5, 117, 0, 0, 2173, 2174, 3, 32, 16, 0, 2174, 2175, 6, 99, -1, 0, 2175, 2288, 1, 0, 0, 0, 2176, 2177, 5, 118, 0, 0, 2177, 2178, 3, 32, 16, 0, 2178, 2179, 6, 99, -1, 0, 2179, 2288, 1, 0, 0, 0, 2180, 2181, 3, 346, 173, 0, 2181, 2182, 5, 17, 0, 0, 2182, 2183, 3, 350, 175, 0, 2183, 2184, 5, 18, 0, 0, 2184, 2185, 6, 99, -1, 0, 2185, 2288, 1, 0, 0, 0, 2186, 2187, 5, 302, 0, 0, 2187, 2188, 3, 124, 62, 0, 2188, 2189, 5, 176, 0, 0, 2189, 2190, 3, 242, 121, 0, 2190, 2191, 5, 119, 0, 0, 2191, 2192, 3, 170, 85, 0, 2192, 2193, 3, 138, 69, 0, 2193, 2194, 3, 124, 62, 0, 2194, 2195, 5, 176, 0, 0, 2195, 2196, 3, 242, 121, 0, 2196, 2197, 3, 112, 56, 0, 2197, 2198, 6, 99, -1, 0, 2198, 2288, 1, 0, 0, 0, 2199, 2200, 5, 302, 0, 0, 2200, 2201, 5, 226, 0, 0, 2201, 2202, 3, 170, 85, 0, 2202, 2203, 3, 138, 69, 0, 2203, 2204, 3, 124, 62, 0, 2204, 2205, 5, 176, 0, 0, 2205, 2206, 3, 242, 121, 0, 2206, 2207, 3, 194, 97, 0, 2207, 2208, 3, 112, 56, 0, 2208, 2209, 5, 119, 0, 0, 2209, 2210, 5, 226, 0, 0, 2210, 2211, 3, 170, 85, 0, 2211, 2212, 3, 138, 69, 0, 2212, 2213, 3, 124, 62, 0, 2213, 2214, 5, 176, 0, 0, 2214, 2215, 3, 242, 121, 0, 2215, 2216, 3, 194, 97, 0, 2216, 2217, 3, 112, 56, 0, 2217, 2218, 6, 99, -1, 0, 2218, 2288, 1, 0, 0, 0, 2219, 2220, 3, 26, 13, 0, 2220, 2221, 6, 99, -1, 0, 2221, 2288, 1, 0, 0, 0, 2222, 2223, 3, 40, 20, 0, 2223, 2224, 6, 99, -1, 0, 2224, 2288, 1, 0, 0, 0, 2225, 2226, 5, 255, 0, 0, 2226, 2227, 5, 196, 0, 0, 2227, 2228, 5, 42, 0, 0, 2228, 2229, 3, 32, 16, 0, 2229, 2230, 5, 43, 0, 0, 2230, 2236, 6, 99, -1, 0, 2231, 2232, 3, 330, 165, 0, 2232, 2233, 6, 99, -1, 0, 2233, 2235, 1, 0, 0, 0, 2234, 2231, 1, 0, 0, 0, 2235, 2238, 1, 0, 0, 0, 2236, 2234, 1, 0, 0, 0, 2236, 2237, 1, 0, 0, 0, 2237, 2288, 1, 0, 0, 0, 2238, 2236, 1, 0, 0, 0, 2239, 2240, 5, 255, 0, 0, 2240, 2241, 5, 196, 0, 0, 2241, 2242, 3, 2, 1, 0, 2242, 2248, 6, 99, -1, 0, 2243, 2244, 3, 330, 165, 0, 2244, 2245, 6, 99, -1, 0, 2245, 2247, 1, 0, 0, 0, 2246, 2243, 1, 0, 0, 0, 2247, 2250, 1, 0, 0, 0, 2248, 2246, 1, 0, 0, 0, 2248, 2249, 1, 0, 0, 0, 2249, 2288, 1, 0, 0, 0, 2250, 2248, 1, 0, 0, 0, 2251, 2252, 5, 255, 0, 0, 2252, 2253, 5, 256, 0, 0, 2253, 2254, 5, 42, 0, 0, 2254, 2255, 3, 32, 16, 0, 2255, 2256, 5, 43, 0, 0, 2256, 2257, 5, 28, 0, 0, 2257, 2258, 3, 124, 62, 0, 2258, 2264, 6, 99, -1, 0, 2259, 2260, 3, 330, 165, 0, 2260, 2261, 6, 99, -1, 0, 2261, 2263, 1, 0, 0, 0, 2262, 2259, 1, 0, 0, 0, 2263, 2266, 1, 0, 0, 0, 2264, 2262, 1, 0, 0, 0, 2264, 2265, 1, 0, 0, 0, 2265, 2288, 1, 0, 0, 0, 2266, 2264, 1, 0, 0, 0, 2267, 2268, 5, 255, 0, 0, 2268, 2269, 5, 256, 0, 0, 2269, 2270, 3, 2, 1, 0, 2270, 2271, 5, 28, 0, 0, 2271, 2272, 3, 124, 62, 0, 2272, 2278, 6, 99, -1, 0, 2273, 2274, 3, 330, 165, 0, 2274, 2275, 6, 99, -1, 0, 2275, 2277, 1, 0, 0, 0, 2276, 2273, 1, 0, 0, 0, 2277, 2280, 1, 0, 0, 0, 2278, 2276, 1, 0, 0, 0, 2278, 2279, 1, 0, 0, 0, 2279, 2288, 1, 0, 0, 0, 2280, 2278, 1, 0, 0, 0, 2281, 2282, 5, 120, 0, 0, 2282, 2283, 5, 196, 0, 0, 2283, 2284, 3, 124, 62, 0, 2284, 2285, 3, 44, 22, 0, 2285, 2286, 6, 99, -1, 0, 2286, 2288, 1, 0, 0, 0, 2287, 2137, 1, 0, 0, 0, 2287, 2142, 1, 0, 0, 0, 2287, 2147, 1, 0, 0, 0, 2287, 2153, 1, 0, 0, 0, 2287, 2159, 1, 0, 0, 0, 2287, 2160, 1, 0, 0, 0, 2287, 2163, 1, 0, 0, 0, 2287, 2166, 1, 0, 0, 0, 2287, 2169, 1, 0, 0, 0, 2287, 2172, 1, 0, 0, 0, 2287, 2176, 1, 0, 0, 0, 2287, 2180, 1, 0, 0, 0, 2287, 2186, 1, 0, 0, 0, 2287, 2199, 1, 0, 0, 0, 2287, 2219, 1, 0, 0, 0, 2287, 2222, 1, 0, 0, 0, 2287, 2225, 1, 0, 0, 0, 2287, 2239, 1, 0, 0, 0, 2287, 2251, 1, 0, 0, 0, 2287, 2267, 1, 0, 0, 0, 2287, 2281, 1, 0, 0, 0, 2288, 199, 1, 0, 0, 0, 2289, 2290, 5, 121, 0, 0, 2290, 2302, 3, 208, 104, 0, 2291, 2292, 3, 202, 101, 0, 2292, 2293, 6, 100, -1, 0, 2293, 2301, 1, 0, 0, 0, 2294, 2295, 5, 122, 0, 0, 2295, 2296, 5, 30, 0, 0, 2296, 2297, 3, 228, 114, 0, 2297, 2298, 5, 31, 0, 0, 2298, 2299, 6, 100, -1, 0, 2299, 2301, 1, 0, 0, 0, 2300, 2291, 1, 0, 0, 0, 2300, 2294, 1, 0, 0, 0, 2301, 2304, 1, 0, 0, 0, 2302, 2300, 1, 0, 0, 0, 2302, 2303, 1, 0, 0, 0, 2303, 2305, 1, 0, 0, 0, 2304, 2302, 1, 0, 0, 0, 2305, 2306, 3, 138, 69, 0, 2306, 2307, 3, 2, 1, 0, 2307, 2308, 3, 204, 102, 0, 2308, 2309, 3, 206, 103, 0, 2309, 2310, 6, 100, -1, 0, 2310, 201, 1, 0, 0, 0, 2311, 2312, 5, 123, 0, 0, 2312, 2346, 6, 101, -1, 0, 2313, 2314, 5, 51, 0, 0, 2314, 2346, 6, 101, -1, 0, 2315, 2316, 5, 52, 0, 0, 2316, 2346, 6, 101, -1, 0, 2317, 2318, 5, 63, 0, 0, 2318, 2346, 6, 101, -1, 0, 2319, 2320, 5, 124, 0, 0, 2320, 2346, 6, 101, -1, 0, 2321, 2322, 5, 69, 0, 0, 2322, 2346, 6, 101, -1, 0, 2323, 2324, 5, 68, 0, 0, 2324, 2346, 6, 101, -1, 0, 2325, 2326, 5, 64, 0, 0, 2326, 2346, 6, 101, -1, 0, 2327, 2328, 5, 65, 0, 0, 2328, 2346, 6, 101, -1, 0, 2329, 2330, 5, 66, 0, 0, 2330, 2346, 6, 101, -1, 0, 2331, 2332, 5, 125, 0, 0, 2332, 2346, 6, 101, -1, 0, 2333, 2334, 5, 126, 0, 0, 2334, 2346, 6, 101, -1, 0, 2335, 2336, 5, 127, 0, 0, 2336, 2346, 6, 101, -1, 0, 2337, 2338, 5, 16, 0, 0, 2338, 2346, 6, 101, -1, 0, 2339, 2340, 5, 70, 0, 0, 2340, 2341, 5, 30, 0, 0, 2341, 2342, 3, 32, 16, 0, 2342, 2343, 5, 31, 0, 0, 2343, 2344, 6, 101, -1, 0, 2344, 2346, 1, 0, 0, 0, 2345, 2311, 1, 0, 0, 0, 2345, 2313, 1, 0, 0, 0, 2345, 2315, 1, 0, 0, 0, 2345, 2317, 1, 0, 0, 0, 2345, 2319, 1, 0, 0, 0, 2345, 2321, 1, 0, 0, 0, 2345, 2323, 1, 0, 0, 0, 2345, 2325, 1, 0, 0, 0, 2345, 2327, 1, 0, 0, 0, 2345, 2329, 1, 0, 0, 0, 2345, 2331, 1, 0, 0, 0, 2345, 2333, 1, 0, 0, 0, 2345, 2335, 1, 0, 0, 0, 2345, 2337, 1, 0, 0, 0, 2345, 2339, 1, 0, 0, 0, 2346, 203, 1, 0, 0, 0, 2347, 2357, 1, 0, 0, 0, 2348, 2349, 5, 44, 0, 0, 2349, 2350, 3, 0, 0, 0, 2350, 2351, 6, 102, -1, 0, 2351, 2357, 1, 0, 0, 0, 2352, 2353, 5, 44, 0, 0, 2353, 2354, 3, 32, 16, 0, 2354, 2355, 6, 102, -1, 0, 2355, 2357, 1, 0, 0, 0, 2356, 2347, 1, 0, 0, 0, 2356, 2348, 1, 0, 0, 0, 2356, 2352, 1, 0, 0, 0, 2357, 205, 1, 0, 0, 0, 2358, 2364, 1, 0, 0, 0, 2359, 2360, 5, 36, 0, 0, 2360, 2361, 3, 304, 152, 0, 2361, 2362, 6, 103, -1, 0, 2362, 2364, 1, 0, 0, 0, 2363, 2358, 1, 0, 0, 0, 2363, 2359, 1, 0, 0, 0, 2364, 207, 1, 0, 0, 0, 2365, 2372, 1, 0, 0, 0, 2366, 2367, 5, 42, 0, 0, 2367, 2368, 3, 32, 16, 0, 2368, 2369, 5, 43, 0, 0, 2369, 2370, 6, 104, -1, 0, 2370, 2372, 1, 0, 0, 0, 2371, 2365, 1, 0, 0, 0, 2371, 2366, 1, 0, 0, 0, 2372, 209, 1, 0, 0, 0, 2373, 2379, 5, 128, 0, 0, 2374, 2375, 3, 212, 106, 0, 2375, 2376, 6, 105, -1, 0, 2376, 2378, 1, 0, 0, 0, 2377, 2374, 1, 0, 0, 0, 2378, 2381, 1, 0, 0, 0, 2379, 2377, 1, 0, 0, 0, 2379, 2380, 1, 0, 0, 0, 2380, 2382, 1, 0, 0, 0, 2381, 2379, 1, 0, 0, 0, 2382, 2383, 3, 124, 62, 0, 2383, 2384, 3, 2, 1, 0, 2384, 2385, 6, 105, -1, 0, 2385, 2399, 1, 0, 0, 0, 2386, 2392, 5, 128, 0, 0, 2387, 2388, 3, 212, 106, 0, 2388, 2389, 6, 105, -1, 0, 2389, 2391, 1, 0, 0, 0, 2390, 2387, 1, 0, 0, 0, 2391, 2394, 1, 0, 0, 0, 2392, 2390, 1, 0, 0, 0, 2392, 2393, 1, 0, 0, 0, 2393, 2395, 1, 0, 0, 0, 2394, 2392, 1, 0, 0, 0, 2395, 2396, 3, 2, 1, 0, 2396, 2397, 6, 105, -1, 0, 2397, 2399, 1, 0, 0, 0, 2398, 2373, 1, 0, 0, 0, 2398, 2386, 1, 0, 0, 0, 2399, 211, 1, 0, 0, 0, 2400, 2401, 5, 69, 0, 0, 2401, 2405, 6, 106, -1, 0, 2402, 2403, 5, 68, 0, 0, 2403, 2405, 6, 106, -1, 0, 2404, 2400, 1, 0, 0, 0, 2404, 2402, 1, 0, 0, 0, 2405, 213, 1, 0, 0, 0, 2406, 2408, 3, 216, 108, 0, 2407, 2406, 1, 0, 0, 0, 2408, 2411, 1, 0, 0, 0, 2409, 2407, 1, 0, 0, 0, 2409, 2410, 1, 0, 0, 0, 2410, 215, 1, 0, 0, 0, 2411, 2409, 1, 0, 0, 0, 2412, 2413, 5, 129, 0, 0, 2413, 2414, 3, 168, 84, 0, 2414, 2415, 6, 108, -1, 0, 2415, 2439, 1, 0, 0, 0, 2416, 2417, 5, 130, 0, 0, 2417, 2418, 3, 168, 84, 0, 2418, 2419, 6, 108, -1, 0, 2419, 2439, 1, 0, 0, 0, 2420, 2421, 5, 131, 0, 0, 2421, 2422, 3, 168, 84, 0, 2422, 2423, 6, 108, -1, 0, 2423, 2439, 1, 0, 0, 0, 2424, 2425, 5, 132, 0, 0, 2425, 2426, 3, 168, 84, 0, 2426, 2427, 6, 108, -1, 0, 2427, 2439, 1, 0, 0, 0, 2428, 2429, 3, 88, 44, 0, 2429, 2430, 6, 108, -1, 0, 2430, 2439, 1, 0, 0, 0, 2431, 2432, 3, 330, 165, 0, 2432, 2433, 6, 108, -1, 0, 2433, 2439, 1, 0, 0, 0, 2434, 2435, 3, 26, 13, 0, 2435, 2436, 6, 108, -1, 0, 2436, 2439, 1, 0, 0, 0, 2437, 2439, 3, 40, 20, 0, 2438, 2412, 1, 0, 0, 0, 2438, 2416, 1, 0, 0, 0, 2438, 2420, 1, 0, 0, 0, 2438, 2424, 1, 0, 0, 0, 2438, 2428, 1, 0, 0, 0, 2438, 2431, 1, 0, 0, 0, 2438, 2434, 1, 0, 0, 0, 2438, 2437, 1, 0, 0, 0, 2439, 217, 1, 0, 0, 0, 2440, 2446, 5, 133, 0, 0, 2441, 2442, 3, 220, 110, 0, 2442, 2443, 6, 109, -1, 0, 2443, 2445, 1, 0, 0, 0, 2444, 2441, 1, 0, 0, 0, 2445, 2448, 1, 0, 0, 0, 2446, 2444, 1, 0, 0, 0, 2446, 2447, 1, 0, 0, 0, 2447, 2449, 1, 0, 0, 0, 2448, 2446, 1, 0, 0, 0, 2449, 2450, 3, 170, 85, 0, 2450, 2451, 3, 138, 69, 0, 2451, 2452, 3, 2, 1, 0, 2452, 2453, 3, 112, 56, 0, 2453, 2454, 3, 206, 103, 0, 2454, 2455, 6, 109, -1, 0, 2455, 219, 1, 0, 0, 0, 2456, 2457, 5, 69, 0, 0, 2457, 2461, 6, 110, -1, 0, 2458, 2459, 5, 68, 0, 0, 2459, 2461, 6, 110, -1, 0, 2460, 2456, 1, 0, 0, 0, 2460, 2458, 1, 0, 0, 0, 2461, 221, 1, 0, 0, 0, 2462, 2464, 3, 224, 112, 0, 2463, 2462, 1, 0, 0, 0, 2464, 2467, 1, 0, 0, 0, 2465, 2463, 1, 0, 0, 0, 2465, 2466, 1, 0, 0, 0, 2466, 223, 1, 0, 0, 0, 2467, 2465, 1, 0, 0, 0, 2468, 2469, 5, 134, 0, 0, 2469, 2470, 3, 168, 84, 0, 2470, 2471, 6, 112, -1, 0, 2471, 2491, 1, 0, 0, 0, 2472, 2473, 5, 135, 0, 0, 2473, 2474, 3, 168, 84, 0, 2474, 2475, 6, 112, -1, 0, 2475, 2491, 1, 0, 0, 0, 2476, 2477, 5, 132, 0, 0, 2477, 2478, 3, 168, 84, 0, 2478, 2479, 6, 112, -1, 0, 2479, 2491, 1, 0, 0, 0, 2480, 2481, 3, 330, 165, 0, 2481, 2482, 6, 112, -1, 0, 2482, 2491, 1, 0, 0, 0, 2483, 2484, 3, 88, 44, 0, 2484, 2485, 6, 112, -1, 0, 2485, 2491, 1, 0, 0, 0, 2486, 2487, 3, 26, 13, 0, 2487, 2488, 6, 112, -1, 0, 2488, 2491, 1, 0, 0, 0, 2489, 2491, 3, 40, 20, 0, 2490, 2468, 1, 0, 0, 0, 2490, 2472, 1, 0, 0, 0, 2490, 2476, 1, 0, 0, 0, 2490, 2480, 1, 0, 0, 0, 2490, 2483, 1, 0, 0, 0, 2490, 2486, 1, 0, 0, 0, 2490, 2489, 1, 0, 0, 0, 2491, 225, 1, 0, 0, 0, 2492, 2500, 6, 113, -1, 0, 2493, 2494, 5, 122, 0, 0, 2494, 2495, 5, 30, 0, 0, 2495, 2496, 3, 228, 114, 0, 2496, 2497, 5, 31, 0, 0, 2497, 2498, 6, 113, -1, 0, 2498, 2500, 1, 0, 0, 0, 2499, 2492, 1, 0, 0, 0, 2499, 2493, 1, 0, 0, 0, 2500, 227, 1, 0, 0, 0, 2501, 2502, 3, 126, 63, 0, 2502, 2503, 6, 114, -1, 0, 2503, 2515, 1, 0, 0, 0, 2504, 2508, 5, 17, 0, 0, 2505, 2506, 3, 302, 151, 0, 2506, 2507, 6, 114, -1, 0, 2507, 2509, 1, 0, 0, 0, 2508, 2505, 1, 0, 0, 0, 2509, 2510, 1, 0, 0, 0, 2510, 2508, 1, 0, 0, 0, 2510, 2511, 1, 0, 0, 0, 2511, 2512, 1, 0, 0, 0, 2512, 2513, 5, 18, 0, 0, 2513, 2515, 1, 0, 0, 0, 2514, 2501, 1, 0, 0, 0, 2514, 2504, 1, 0, 0, 0, 2515, 229, 1, 0, 0, 0, 2516, 2517, 3, 232, 116, 0, 2517, 2518, 6, 115, -1, 0, 2518, 2520, 1, 0, 0, 0, 2519, 2516, 1, 0, 0, 0, 2520, 2523, 1, 0, 0, 0, 2521, 2519, 1, 0, 0, 0, 2521, 2522, 1, 0, 0, 0, 2522, 231, 1, 0, 0, 0, 2523, 2521, 1, 0, 0, 0, 2524, 2525, 5, 42, 0, 0, 2525, 2526, 5, 136, 0, 0, 2526, 2527, 5, 43, 0, 0, 2527, 2542, 6, 116, -1, 0, 2528, 2529, 5, 42, 0, 0, 2529, 2530, 5, 137, 0, 0, 2530, 2531, 5, 43, 0, 0, 2531, 2542, 6, 116, -1, 0, 2532, 2533, 5, 42, 0, 0, 2533, 2534, 5, 138, 0, 0, 2534, 2535, 5, 43, 0, 0, 2535, 2542, 6, 116, -1, 0, 2536, 2537, 5, 42, 0, 0, 2537, 2538, 3, 32, 16, 0, 2538, 2539, 5, 43, 0, 0, 2539, 2540, 6, 116, -1, 0, 2540, 2542, 1, 0, 0, 0, 2541, 2524, 1, 0, 0, 0, 2541, 2528, 1, 0, 0, 0, 2541, 2532, 1, 0, 0, 0, 2541, 2536, 1, 0, 0, 0, 2542, 233, 1, 0, 0, 0, 2543, 2552, 5, 139, 0, 0, 2544, 2545, 3, 236, 118, 0, 2545, 2546, 6, 117, -1, 0, 2546, 2551, 1, 0, 0, 0, 2547, 2548, 3, 238, 119, 0, 2548, 2549, 6, 117, -1, 0, 2549, 2551, 1, 0, 0, 0, 2550, 2544, 1, 0, 0, 0, 2550, 2547, 1, 0, 0, 0, 2551, 2554, 1, 0, 0, 0, 2552, 2550, 1, 0, 0, 0, 2552, 2553, 1, 0, 0, 0, 2553, 2555, 1, 0, 0, 0, 2554, 2552, 1, 0, 0, 0, 2555, 2556, 3, 170, 85, 0, 2556, 2557, 3, 230, 115, 0, 2557, 2558, 3, 138, 69, 0, 2558, 2559, 3, 226, 113, 0, 2559, 2560, 3, 242, 121, 0, 2560, 2561, 3, 182, 91, 0, 2561, 2567, 3, 112, 56, 0, 2562, 2563, 3, 244, 122, 0, 2563, 2564, 6, 117, -1, 0, 2564, 2566, 1, 0, 0, 0, 2565, 2562, 1, 0, 0, 0, 2566, 2569, 1, 0, 0, 0, 2567, 2565, 1, 0, 0, 0, 2567, 2568, 1, 0, 0, 0, 2568, 2570, 1, 0, 0, 0, 2569, 2567, 1, 0, 0, 0, 2570, 2571, 6, 117, -1, 0, 2571, 235, 1, 0, 0, 0, 2572, 2573, 5, 123, 0, 0, 2573, 2615, 6, 118, -1, 0, 2574, 2575, 5, 51, 0, 0, 2575, 2615, 6, 118, -1, 0, 2576, 2577, 5, 52, 0, 0, 2577, 2615, 6, 118, -1, 0, 2578, 2579, 5, 63, 0, 0, 2579, 2615, 6, 118, -1, 0, 2580, 2581, 5, 140, 0, 0, 2581, 2615, 6, 118, -1, 0, 2582, 2583, 5, 68, 0, 0, 2583, 2615, 6, 118, -1, 0, 2584, 2585, 5, 141, 0, 0, 2585, 2615, 6, 118, -1, 0, 2586, 2587, 5, 142, 0, 0, 2587, 2615, 6, 118, -1, 0, 2588, 2589, 5, 54, 0, 0, 2589, 2615, 6, 118, -1, 0, 2590, 2591, 5, 64, 0, 0, 2591, 2615, 6, 118, -1, 0, 2592, 2593, 5, 65, 0, 0, 2593, 2615, 6, 118, -1, 0, 2594, 2595, 5, 66, 0, 0, 2595, 2615, 6, 118, -1, 0, 2596, 2597, 5, 125, 0, 0, 2597, 2615, 6, 118, -1, 0, 2598, 2599, 5, 143, 0, 0, 2599, 2615, 6, 118, -1, 0, 2600, 2601, 5, 144, 0, 0, 2601, 2615, 6, 118, -1, 0, 2602, 2603, 5, 69, 0, 0, 2603, 2615, 6, 118, -1, 0, 2604, 2605, 5, 145, 0, 0, 2605, 2615, 6, 118, -1, 0, 2606, 2607, 5, 146, 0, 0, 2607, 2615, 6, 118, -1, 0, 2608, 2609, 5, 70, 0, 0, 2609, 2610, 5, 30, 0, 0, 2610, 2611, 3, 32, 16, 0, 2611, 2612, 5, 31, 0, 0, 2612, 2613, 6, 118, -1, 0, 2613, 2615, 1, 0, 0, 0, 2614, 2572, 1, 0, 0, 0, 2614, 2574, 1, 0, 0, 0, 2614, 2576, 1, 0, 0, 0, 2614, 2578, 1, 0, 0, 0, 2614, 2580, 1, 0, 0, 0, 2614, 2582, 1, 0, 0, 0, 2614, 2584, 1, 0, 0, 0, 2614, 2586, 1, 0, 0, 0, 2614, 2588, 1, 0, 0, 0, 2614, 2590, 1, 0, 0, 0, 2614, 2592, 1, 0, 0, 0, 2614, 2594, 1, 0, 0, 0, 2614, 2596, 1, 0, 0, 0, 2614, 2598, 1, 0, 0, 0, 2614, 2600, 1, 0, 0, 0, 2614, 2602, 1, 0, 0, 0, 2614, 2604, 1, 0, 0, 0, 2614, 2606, 1, 0, 0, 0, 2614, 2608, 1, 0, 0, 0, 2615, 237, 1, 0, 0, 0, 2616, 2617, 5, 147, 0, 0, 2617, 2626, 5, 30, 0, 0, 2618, 2619, 3, 6, 3, 0, 2619, 2624, 6, 119, -1, 0, 2620, 2621, 5, 34, 0, 0, 2621, 2622, 3, 6, 3, 0, 2622, 2623, 6, 119, -1, 0, 2623, 2625, 1, 0, 0, 0, 2624, 2620, 1, 0, 0, 0, 2624, 2625, 1, 0, 0, 0, 2625, 2627, 1, 0, 0, 0, 2626, 2618, 1, 0, 0, 0, 2626, 2627, 1, 0, 0, 0, 2627, 2633, 1, 0, 0, 0, 2628, 2629, 3, 240, 120, 0, 2629, 2630, 6, 119, -1, 0, 2630, 2632, 1, 0, 0, 0, 2631, 2628, 1, 0, 0, 0, 2632, 2635, 1, 0, 0, 0, 2633, 2631, 1, 0, 0, 0, 2633, 2634, 1, 0, 0, 0, 2634, 2636, 1, 0, 0, 0, 2635, 2633, 1, 0, 0, 0, 2636, 2640, 5, 31, 0, 0, 2637, 2638, 5, 147, 0, 0, 2638, 2640, 5, 85, 0, 0, 2639, 2616, 1, 0, 0, 0, 2639, 2637, 1, 0, 0, 0, 2640, 239, 1, 0, 0, 0, 2641, 2642, 5, 148, 0, 0, 2642, 2684, 6, 120, -1, 0, 2643, 2644, 5, 224, 0, 0, 2644, 2684, 6, 120, -1, 0, 2645, 2646, 5, 57, 0, 0, 2646, 2684, 6, 120, -1, 0, 2647, 2648, 5, 58, 0, 0, 2648, 2684, 6, 120, -1, 0, 2649, 2650, 5, 149, 0, 0, 2650, 2684, 6, 120, -1, 0, 2651, 2652, 5, 150, 0, 0, 2652, 2684, 6, 120, -1, 0, 2653, 2654, 5, 248, 0, 0, 2654, 2684, 6, 120, -1, 0, 2655, 2656, 5, 249, 0, 0, 2656, 2684, 6, 120, -1, 0, 2657, 2658, 5, 250, 0, 0, 2658, 2684, 6, 120, -1, 0, 2659, 2660, 5, 251, 0, 0, 2660, 2684, 6, 120, -1, 0, 2661, 2662, 5, 151, 0, 0, 2662, 2663, 5, 75, 0, 0, 2663, 2664, 5, 152, 0, 0, 2664, 2684, 6, 120, -1, 0, 2665, 2666, 5, 151, 0, 0, 2666, 2667, 5, 75, 0, 0, 2667, 2668, 5, 153, 0, 0, 2668, 2684, 6, 120, -1, 0, 2669, 2670, 5, 154, 0, 0, 2670, 2671, 5, 75, 0, 0, 2671, 2672, 5, 152, 0, 0, 2672, 2684, 6, 120, -1, 0, 2673, 2674, 5, 154, 0, 0, 2674, 2675, 5, 75, 0, 0, 2675, 2676, 5, 153, 0, 0, 2676, 2684, 6, 120, -1, 0, 2677, 2678, 5, 70, 0, 0, 2678, 2679, 5, 30, 0, 0, 2679, 2680, 3, 32, 16, 0, 2680, 2681, 5, 31, 0, 0, 2681, 2682, 6, 120, -1, 0, 2682, 2684, 1, 0, 0, 0, 2683, 2641, 1, 0, 0, 0, 2683, 2643, 1, 0, 0, 0, 2683, 2645, 1, 0, 0, 0, 2683, 2647, 1, 0, 0, 0, 2683, 2649, 1, 0, 0, 0, 2683, 2651, 1, 0, 0, 0, 2683, 2653, 1, 0, 0, 0, 2683, 2655, 1, 0, 0, 0, 2683, 2657, 1, 0, 0, 0, 2683, 2659, 1, 0, 0, 0, 2683, 2661, 1, 0, 0, 0, 2683, 2665, 1, 0, 0, 0, 2683, 2669, 1, 0, 0, 0, 2683, 2673, 1, 0, 0, 0, 2683, 2677, 1, 0, 0, 0, 2684, 241, 1, 0, 0, 0, 2685, 2686, 5, 116, 0, 0, 2686, 2693, 6, 121, -1, 0, 2687, 2688, 5, 155, 0, 0, 2688, 2693, 6, 121, -1, 0, 2689, 2690, 3, 2, 1, 0, 2690, 2691, 6, 121, -1, 0, 2691, 2693, 1, 0, 0, 0, 2692, 2685, 1, 0, 0, 0, 2692, 2687, 1, 0, 0, 0, 2692, 2689, 1, 0, 0, 0, 2693, 243, 1, 0, 0, 0, 2694, 2695, 5, 1, 0, 0, 2695, 2733, 6, 122, -1, 0, 2696, 2697, 5, 2, 0, 0, 2697, 2733, 6, 122, -1, 0, 2698, 2699, 5, 156, 0, 0, 2699, 2733, 6, 122, -1, 0, 2700, 2701, 5, 3, 0, 0, 2701, 2733, 6, 122, -1, 0, 2702, 2703, 5, 4, 0, 0, 2703, 2733, 6, 122, -1, 0, 2704, 2705, 5, 247, 0, 0, 2705, 2733, 6, 122, -1, 0, 2706, 2707, 5, 5, 0, 0, 2707, 2733, 6, 122, -1, 0, 2708, 2709, 5, 6, 0, 0, 2709, 2733, 6, 122, -1, 0, 2710, 2711, 5, 7, 0, 0, 2711, 2733, 6, 122, -1, 0, 2712, 2713, 5, 8, 0, 0, 2713, 2733, 6, 122, -1, 0, 2714, 2715, 5, 9, 0, 0, 2715, 2733, 6, 122, -1, 0, 2716, 2717, 5, 10, 0, 0, 2717, 2733, 6, 122, -1, 0, 2718, 2719, 5, 11, 0, 0, 2719, 2733, 6, 122, -1, 0, 2720, 2721, 5, 12, 0, 0, 2721, 2733, 6, 122, -1, 0, 2722, 2723, 5, 13, 0, 0, 2723, 2733, 6, 122, -1, 0, 2724, 2725, 5, 14, 0, 0, 2725, 2733, 6, 122, -1, 0, 2726, 2727, 5, 70, 0, 0, 2727, 2728, 5, 30, 0, 0, 2728, 2729, 3, 32, 16, 0, 2729, 2730, 5, 31, 0, 0, 2730, 2731, 6, 122, -1, 0, 2731, 2733, 1, 0, 0, 0, 2732, 2694, 1, 0, 0, 0, 2732, 2696, 1, 0, 0, 0, 2732, 2698, 1, 0, 0, 0, 2732, 2700, 1, 0, 0, 0, 2732, 2702, 1, 0, 0, 0, 2732, 2704, 1, 0, 0, 0, 2732, 2706, 1, 0, 0, 0, 2732, 2708, 1, 0, 0, 0, 2732, 2710, 1, 0, 0, 0, 2732, 2712, 1, 0, 0, 0, 2732, 2714, 1, 0, 0, 0, 2732, 2716, 1, 0, 0, 0, 2732, 2718, 1, 0, 0, 0, 2732, 2720, 1, 0, 0, 0, 2732, 2722, 1, 0, 0, 0, 2732, 2724, 1, 0, 0, 0, 2732, 2726, 1, 0, 0, 0, 2733, 245, 1, 0, 0, 0, 2734, 2736, 3, 248, 124, 0, 2735, 2734, 1, 0, 0, 0, 2736, 2739, 1, 0, 0, 0, 2737, 2735, 1, 0, 0, 0, 2737, 2738, 1, 0, 0, 0, 2738, 247, 1, 0, 0, 0, 2739, 2737, 1, 0, 0, 0, 2740, 2778, 3, 100, 50, 0, 2741, 2742, 5, 296, 0, 0, 2742, 2743, 3, 32, 16, 0, 2743, 2744, 6, 124, -1, 0, 2744, 2778, 1, 0, 0, 0, 2745, 2778, 3, 266, 133, 0, 2746, 2747, 5, 297, 0, 0, 2747, 2748, 3, 32, 16, 0, 2748, 2749, 6, 124, -1, 0, 2749, 2778, 1, 0, 0, 0, 2750, 2751, 5, 298, 0, 0, 2751, 2778, 6, 124, -1, 0, 2752, 2753, 5, 299, 0, 0, 2753, 2778, 6, 124, -1, 0, 2754, 2778, 3, 260, 130, 0, 2755, 2778, 3, 264, 132, 0, 2756, 2778, 3, 250, 125, 0, 2757, 2758, 3, 284, 142, 0, 2758, 2759, 6, 124, -1, 0, 2759, 2778, 1, 0, 0, 0, 2760, 2761, 3, 152, 76, 0, 2761, 2762, 6, 124, -1, 0, 2762, 2778, 1, 0, 0, 0, 2763, 2764, 3, 88, 44, 0, 2764, 2765, 6, 124, -1, 0, 2765, 2778, 1, 0, 0, 0, 2766, 2767, 3, 26, 13, 0, 2767, 2768, 6, 124, -1, 0, 2768, 2778, 1, 0, 0, 0, 2769, 2770, 3, 262, 131, 0, 2770, 2771, 6, 124, -1, 0, 2771, 2778, 1, 0, 0, 0, 2772, 2778, 3, 40, 20, 0, 2773, 2778, 3, 252, 126, 0, 2774, 2778, 3, 254, 127, 0, 2775, 2778, 3, 256, 128, 0, 2776, 2778, 3, 258, 129, 0, 2777, 2740, 1, 0, 0, 0, 2777, 2741, 1, 0, 0, 0, 2777, 2745, 1, 0, 0, 0, 2777, 2746, 1, 0, 0, 0, 2777, 2750, 1, 0, 0, 0, 2777, 2752, 1, 0, 0, 0, 2777, 2754, 1, 0, 0, 0, 2777, 2755, 1, 0, 0, 0, 2777, 2756, 1, 0, 0, 0, 2777, 2757, 1, 0, 0, 0, 2777, 2760, 1, 0, 0, 0, 2777, 2763, 1, 0, 0, 0, 2777, 2766, 1, 0, 0, 0, 2777, 2769, 1, 0, 0, 0, 2777, 2772, 1, 0, 0, 0, 2777, 2773, 1, 0, 0, 0, 2777, 2774, 1, 0, 0, 0, 2777, 2775, 1, 0, 0, 0, 2777, 2776, 1, 0, 0, 0, 2778, 249, 1, 0, 0, 0, 2779, 2781, 5, 300, 0, 0, 2780, 2782, 5, 157, 0, 0, 2781, 2780, 1, 0, 0, 0, 2781, 2782, 1, 0, 0, 0, 2782, 2783, 1, 0, 0, 0, 2783, 2784, 3, 112, 56, 0, 2784, 251, 1, 0, 0, 0, 2785, 2786, 5, 301, 0, 0, 2786, 2787, 5, 42, 0, 0, 2787, 2788, 3, 32, 16, 0, 2788, 2791, 5, 43, 0, 0, 2789, 2790, 5, 34, 0, 0, 2790, 2792, 3, 0, 0, 0, 2791, 2789, 1, 0, 0, 0, 2791, 2792, 1, 0, 0, 0, 2792, 253, 1, 0, 0, 0, 2793, 2794, 5, 303, 0, 0, 2794, 2795, 3, 32, 16, 0, 2795, 2796, 5, 75, 0, 0, 2796, 2797, 3, 32, 16, 0, 2797, 255, 1, 0, 0, 0, 2798, 2799, 5, 302, 0, 0, 2799, 2800, 3, 124, 62, 0, 2800, 2801, 5, 176, 0, 0, 2801, 2802, 3, 242, 121, 0, 2802, 2814, 1, 0, 0, 0, 2803, 2804, 5, 302, 0, 0, 2804, 2805, 5, 226, 0, 0, 2805, 2806, 3, 170, 85, 0, 2806, 2807, 3, 138, 69, 0, 2807, 2808, 3, 124, 62, 0, 2808, 2809, 5, 176, 0, 0, 2809, 2810, 3, 242, 121, 0, 2810, 2811, 3, 194, 97, 0, 2811, 2812, 3, 112, 56, 0, 2812, 2814, 1, 0, 0, 0, 2813, 2798, 1, 0, 0, 0, 2813, 2803, 1, 0, 0, 0, 2814, 257, 1, 0, 0, 0, 2815, 2816, 5, 255, 0, 0, 2816, 2817, 5, 196, 0, 0, 2817, 2818, 5, 42, 0, 0, 2818, 2819, 3, 32, 16, 0, 2819, 2825, 5, 43, 0, 0, 2820, 2821, 3, 330, 165, 0, 2821, 2822, 6, 129, -1, 0, 2822, 2824, 1, 0, 0, 0, 2823, 2820, 1, 0, 0, 0, 2824, 2827, 1, 0, 0, 0, 2825, 2823, 1, 0, 0, 0, 2825, 2826, 1, 0, 0, 0, 2826, 2881, 1, 0, 0, 0, 2827, 2825, 1, 0, 0, 0, 2828, 2829, 5, 255, 0, 0, 2829, 2830, 5, 196, 0, 0, 2830, 2836, 3, 2, 1, 0, 2831, 2832, 3, 330, 165, 0, 2832, 2833, 6, 129, -1, 0, 2833, 2835, 1, 0, 0, 0, 2834, 2831, 1, 0, 0, 0, 2835, 2838, 1, 0, 0, 0, 2836, 2834, 1, 0, 0, 0, 2836, 2837, 1, 0, 0, 0, 2837, 2881, 1, 0, 0, 0, 2838, 2836, 1, 0, 0, 0, 2839, 2840, 5, 255, 0, 0, 2840, 2841, 5, 256, 0, 0, 2841, 2842, 5, 42, 0, 0, 2842, 2843, 3, 32, 16, 0, 2843, 2844, 5, 43, 0, 0, 2844, 2845, 5, 28, 0, 0, 2845, 2851, 3, 124, 62, 0, 2846, 2847, 3, 330, 165, 0, 2847, 2848, 6, 129, -1, 0, 2848, 2850, 1, 0, 0, 0, 2849, 2846, 1, 0, 0, 0, 2850, 2853, 1, 0, 0, 0, 2851, 2849, 1, 0, 0, 0, 2851, 2852, 1, 0, 0, 0, 2852, 2881, 1, 0, 0, 0, 2853, 2851, 1, 0, 0, 0, 2854, 2855, 5, 255, 0, 0, 2855, 2856, 5, 256, 0, 0, 2856, 2857, 3, 2, 1, 0, 2857, 2858, 5, 28, 0, 0, 2858, 2864, 3, 124, 62, 0, 2859, 2860, 3, 330, 165, 0, 2860, 2861, 6, 129, -1, 0, 2861, 2863, 1, 0, 0, 0, 2862, 2859, 1, 0, 0, 0, 2863, 2866, 1, 0, 0, 0, 2864, 2862, 1, 0, 0, 0, 2864, 2865, 1, 0, 0, 0, 2865, 2881, 1, 0, 0, 0, 2866, 2864, 1, 0, 0, 0, 2867, 2868, 5, 255, 0, 0, 2868, 2869, 5, 42, 0, 0, 2869, 2870, 3, 32, 16, 0, 2870, 2871, 5, 43, 0, 0, 2871, 2877, 3, 206, 103, 0, 2872, 2873, 3, 330, 165, 0, 2873, 2874, 6, 129, -1, 0, 2874, 2876, 1, 0, 0, 0, 2875, 2872, 1, 0, 0, 0, 2876, 2879, 1, 0, 0, 0, 2877, 2875, 1, 0, 0, 0, 2877, 2878, 1, 0, 0, 0, 2878, 2881, 1, 0, 0, 0, 2879, 2877, 1, 0, 0, 0, 2880, 2815, 1, 0, 0, 0, 2880, 2828, 1, 0, 0, 0, 2880, 2839, 1, 0, 0, 0, 2880, 2854, 1, 0, 0, 0, 2880, 2867, 1, 0, 0, 0, 2881, 259, 1, 0, 0, 0, 2882, 2883, 3, 0, 0, 0, 2883, 2884, 5, 75, 0, 0, 2884, 2885, 6, 130, -1, 0, 2885, 261, 1, 0, 0, 0, 2886, 2887, 3, 44, 22, 0, 2887, 2888, 6, 131, -1, 0, 2888, 2893, 1, 0, 0, 0, 2889, 2890, 3, 46, 23, 0, 2890, 2891, 6, 131, -1, 0, 2891, 2893, 1, 0, 0, 0, 2892, 2886, 1, 0, 0, 0, 2892, 2889, 1, 0, 0, 0, 2893, 263, 1, 0, 0, 0, 2894, 2895, 5, 17, 0, 0, 2895, 2896, 3, 246, 123, 0, 2896, 2897, 5, 18, 0, 0, 2897, 265, 1, 0, 0, 0, 2898, 2899, 3, 270, 135, 0, 2899, 2900, 3, 268, 134, 0, 2900, 267, 1, 0, 0, 0, 2901, 2902, 3, 272, 136, 0, 2902, 2903, 6, 134, -1, 0, 2903, 2905, 1, 0, 0, 0, 2904, 2901, 1, 0, 0, 0, 2905, 2906, 1, 0, 0, 0, 2906, 2904, 1, 0, 0, 0, 2906, 2907, 1, 0, 0, 0, 2907, 269, 1, 0, 0, 0, 2908, 2909, 5, 158, 0, 0, 2909, 2910, 3, 264, 132, 0, 2910, 2911, 6, 135, -1, 0, 2911, 2925, 1, 0, 0, 0, 2912, 2913, 5, 158, 0, 0, 2913, 2914, 3, 0, 0, 0, 2914, 2915, 5, 159, 0, 0, 2915, 2916, 3, 0, 0, 0, 2916, 2917, 6, 135, -1, 0, 2917, 2925, 1, 0, 0, 0, 2918, 2919, 5, 158, 0, 0, 2919, 2920, 3, 32, 16, 0, 2920, 2921, 5, 159, 0, 0, 2921, 2922, 3, 32, 16, 0, 2922, 2923, 6, 135, -1, 0, 2923, 2925, 1, 0, 0, 0, 2924, 2908, 1, 0, 0, 0, 2924, 2912, 1, 0, 0, 0, 2924, 2918, 1, 0, 0, 0, 2925, 271, 1, 0, 0, 0, 2926, 2927, 3, 276, 138, 0, 2927, 2928, 3, 282, 141, 0, 2928, 2929, 6, 136, -1, 0, 2929, 2943, 1, 0, 0, 0, 2930, 2931, 3, 274, 137, 0, 2931, 2932, 3, 282, 141, 0, 2932, 2933, 6, 136, -1, 0, 2933, 2943, 1, 0, 0, 0, 2934, 2935, 3, 278, 139, 0, 2935, 2936, 3, 282, 141, 0, 2936, 2937, 6, 136, -1, 0, 2937, 2943, 1, 0, 0, 0, 2938, 2939, 3, 280, 140, 0, 2939, 2940, 3, 282, 141, 0, 2940, 2941, 6, 136, -1, 0, 2941, 2943, 1, 0, 0, 0, 2942, 2926, 1, 0, 0, 0, 2942, 2930, 1, 0, 0, 0, 2942, 2934, 1, 0, 0, 0, 2942, 2938, 1, 0, 0, 0, 2943, 273, 1, 0, 0, 0, 2944, 2945, 5, 160, 0, 0, 2945, 2946, 3, 264, 132, 0, 2946, 2947, 6, 137, -1, 0, 2947, 2957, 1, 0, 0, 0, 2948, 2949, 5, 160, 0, 0, 2949, 2950, 3, 0, 0, 0, 2950, 2951, 6, 137, -1, 0, 2951, 2957, 1, 0, 0, 0, 2952, 2953, 5, 160, 0, 0, 2953, 2954, 3, 32, 16, 0, 2954, 2955, 6, 137, -1, 0, 2955, 2957, 1, 0, 0, 0, 2956, 2944, 1, 0, 0, 0, 2956, 2948, 1, 0, 0, 0, 2956, 2952, 1, 0, 0, 0, 2957, 275, 1, 0, 0, 0, 2958, 2959, 5, 161, 0, 0, 2959, 2960, 3, 124, 62, 0, 2960, 277, 1, 0, 0, 0, 2961, 2962, 5, 162, 0, 0, 2962, 279, 1, 0, 0, 0, 2963, 2964, 5, 163, 0, 0, 2964, 281, 1, 0, 0, 0, 2965, 2966, 3, 264, 132, 0, 2966, 2967, 6, 141, -1, 0, 2967, 2981, 1, 0, 0, 0, 2968, 2969, 5, 164, 0, 0, 2969, 2970, 3, 0, 0, 0, 2970, 2971, 5, 159, 0, 0, 2971, 2972, 3, 0, 0, 0, 2972, 2973, 6, 141, -1, 0, 2973, 2981, 1, 0, 0, 0, 2974, 2975, 5, 164, 0, 0, 2975, 2976, 3, 32, 16, 0, 2976, 2977, 5, 159, 0, 0, 2977, 2978, 3, 32, 16, 0, 2978, 2979, 6, 141, -1, 0, 2979, 2981, 1, 0, 0, 0, 2980, 2965, 1, 0, 0, 0, 2980, 2968, 1, 0, 0, 0, 2980, 2974, 1, 0, 0, 0, 2981, 283, 1, 0, 0, 0, 2982, 2983, 3, 286, 143, 0, 2983, 2984, 3, 290, 145, 0, 2984, 285, 1, 0, 0, 0, 2985, 2986, 5, 165, 0, 0, 2986, 2987, 3, 288, 144, 0, 2987, 2988, 3, 0, 0, 0, 2988, 2989, 5, 36, 0, 0, 2989, 2993, 1, 0, 0, 0, 2990, 2991, 5, 165, 0, 0, 2991, 2993, 3, 288, 144, 0, 2992, 2985, 1, 0, 0, 0, 2992, 2990, 1, 0, 0, 0, 2993, 287, 1, 0, 0, 0, 2994, 2998, 1, 0, 0, 0, 2995, 2998, 5, 166, 0, 0, 2996, 2998, 5, 2, 0, 0, 2997, 2994, 1, 0, 0, 0, 2997, 2995, 1, 0, 0, 0, 2997, 2996, 1, 0, 0, 0, 2998, 289, 1, 0, 0, 0, 2999, 3000, 5, 17, 0, 0, 3000, 3001, 3, 292, 146, 0, 3001, 3002, 5, 18, 0, 0, 3002, 3009, 1, 0, 0, 0, 3003, 3005, 3, 296, 148, 0, 3004, 3003, 1, 0, 0, 0, 3005, 3006, 1, 0, 0, 0, 3006, 3004, 1, 0, 0, 0, 3006, 3007, 1, 0, 0, 0, 3007, 3009, 1, 0, 0, 0, 3008, 2999, 1, 0, 0, 0, 3008, 3004, 1, 0, 0, 0, 3009, 291, 1, 0, 0, 0, 3010, 3011, 3, 296, 148, 0, 3011, 3012, 5, 28, 0, 0, 3012, 3014, 1, 0, 0, 0, 3013, 3010, 1, 0, 0, 0, 3014, 3017, 1, 0, 0, 0, 3015, 3013, 1, 0, 0, 0, 3015, 3016, 1, 0, 0, 0, 3016, 3018, 1, 0, 0, 0, 3017, 3015, 1, 0, 0, 0, 3018, 3019, 3, 296, 148, 0, 3019, 293, 1, 0, 0, 0, 3020, 3026, 1, 0, 0, 0, 3021, 3022, 5, 42, 0, 0, 3022, 3023, 3, 32, 16, 0, 3023, 3024, 5, 43, 0, 0, 3024, 3026, 1, 0, 0, 0, 3025, 3020, 1, 0, 0, 0, 3025, 3021, 1, 0, 0, 0, 3026, 295, 1, 0, 0, 0, 3027, 3028, 5, 181, 0, 0, 3028, 3029, 5, 262, 0, 0, 3029, 3030, 5, 30, 0, 0, 3030, 3031, 3, 6, 3, 0, 3031, 3032, 5, 31, 0, 0, 3032, 3094, 1, 0, 0, 0, 3033, 3034, 5, 260, 0, 0, 3034, 3035, 5, 30, 0, 0, 3035, 3036, 3, 0, 0, 0, 3036, 3037, 5, 31, 0, 0, 3037, 3094, 1, 0, 0, 0, 3038, 3039, 5, 260, 0, 0, 3039, 3094, 3, 0, 0, 0, 3040, 3041, 5, 84, 0, 0, 3041, 3042, 5, 30, 0, 0, 3042, 3043, 3, 300, 150, 0, 3043, 3044, 5, 31, 0, 0, 3044, 3094, 1, 0, 0, 0, 3045, 3046, 5, 188, 0, 0, 3046, 3047, 5, 30, 0, 0, 3047, 3048, 3, 36, 18, 0, 3048, 3049, 5, 31, 0, 0, 3049, 3050, 3, 294, 147, 0, 3050, 3094, 1, 0, 0, 0, 3051, 3052, 5, 189, 0, 0, 3052, 3053, 5, 30, 0, 0, 3053, 3054, 3, 36, 18, 0, 3054, 3055, 5, 31, 0, 0, 3055, 3056, 3, 294, 147, 0, 3056, 3094, 1, 0, 0, 0, 3057, 3058, 5, 187, 0, 0, 3058, 3059, 5, 30, 0, 0, 3059, 3060, 3, 34, 17, 0, 3060, 3061, 5, 31, 0, 0, 3061, 3062, 3, 294, 147, 0, 3062, 3094, 1, 0, 0, 0, 3063, 3064, 5, 186, 0, 0, 3064, 3065, 5, 30, 0, 0, 3065, 3066, 3, 32, 16, 0, 3066, 3067, 5, 31, 0, 0, 3067, 3068, 3, 294, 147, 0, 3068, 3094, 1, 0, 0, 0, 3069, 3070, 5, 185, 0, 0, 3070, 3071, 5, 30, 0, 0, 3071, 3072, 3, 32, 16, 0, 3072, 3073, 5, 31, 0, 0, 3073, 3074, 3, 294, 147, 0, 3074, 3094, 1, 0, 0, 0, 3075, 3076, 5, 184, 0, 0, 3076, 3077, 5, 30, 0, 0, 3077, 3078, 3, 32, 16, 0, 3078, 3079, 5, 31, 0, 0, 3079, 3080, 3, 294, 147, 0, 3080, 3094, 1, 0, 0, 0, 3081, 3082, 5, 188, 0, 0, 3082, 3094, 3, 294, 147, 0, 3083, 3084, 5, 189, 0, 0, 3084, 3094, 3, 294, 147, 0, 3085, 3086, 5, 187, 0, 0, 3086, 3094, 3, 294, 147, 0, 3087, 3088, 5, 186, 0, 0, 3088, 3094, 3, 294, 147, 0, 3089, 3090, 5, 185, 0, 0, 3090, 3094, 3, 294, 147, 0, 3091, 3092, 5, 184, 0, 0, 3092, 3094, 3, 294, 147, 0, 3093, 3027, 1, 0, 0, 0, 3093, 3033, 1, 0, 0, 0, 3093, 3038, 1, 0, 0, 0, 3093, 3040, 1, 0, 0, 0, 3093, 3045, 1, 0, 0, 0, 3093, 3051, 1, 0, 0, 0, 3093, 3057, 1, 0, 0, 0, 3093, 3063, 1, 0, 0, 0, 3093, 3069, 1, 0, 0, 0, 3093, 3075, 1, 0, 0, 0, 3093, 3081, 1, 0, 0, 0, 3093, 3083, 1, 0, 0, 0, 3093, 3085, 1, 0, 0, 0, 3093, 3087, 1, 0, 0, 0, 3093, 3089, 1, 0, 0, 0, 3093, 3091, 1, 0, 0, 0, 3094, 297, 1, 0, 0, 0, 3095, 3096, 5, 188, 0, 0, 3096, 3097, 5, 30, 0, 0, 3097, 3098, 3, 36, 18, 0, 3098, 3099, 5, 31, 0, 0, 3099, 3100, 6, 149, -1, 0, 3100, 3186, 1, 0, 0, 0, 3101, 3102, 5, 189, 0, 0, 3102, 3103, 5, 30, 0, 0, 3103, 3104, 3, 36, 18, 0, 3104, 3105, 5, 31, 0, 0, 3105, 3106, 6, 149, -1, 0, 3106, 3186, 1, 0, 0, 0, 3107, 3108, 5, 188, 0, 0, 3108, 3109, 5, 30, 0, 0, 3109, 3110, 3, 32, 16, 0, 3110, 3111, 5, 31, 0, 0, 3111, 3112, 6, 149, -1, 0, 3112, 3186, 1, 0, 0, 0, 3113, 3114, 5, 189, 0, 0, 3114, 3115, 5, 30, 0, 0, 3115, 3116, 3, 34, 17, 0, 3116, 3117, 5, 31, 0, 0, 3117, 3118, 6, 149, -1, 0, 3118, 3186, 1, 0, 0, 0, 3119, 3120, 5, 187, 0, 0, 3120, 3121, 5, 30, 0, 0, 3121, 3122, 3, 34, 17, 0, 3122, 3123, 5, 31, 0, 0, 3123, 3124, 6, 149, -1, 0, 3124, 3186, 1, 0, 0, 0, 3125, 3126, 5, 186, 0, 0, 3126, 3127, 5, 30, 0, 0, 3127, 3128, 3, 32, 16, 0, 3128, 3129, 5, 31, 0, 0, 3129, 3130, 6, 149, -1, 0, 3130, 3186, 1, 0, 0, 0, 3131, 3132, 5, 185, 0, 0, 3132, 3133, 5, 30, 0, 0, 3133, 3134, 3, 32, 16, 0, 3134, 3135, 5, 31, 0, 0, 3135, 3136, 6, 149, -1, 0, 3136, 3186, 1, 0, 0, 0, 3137, 3138, 5, 184, 0, 0, 3138, 3139, 5, 30, 0, 0, 3139, 3140, 3, 32, 16, 0, 3140, 3141, 5, 31, 0, 0, 3141, 3142, 6, 149, -1, 0, 3142, 3186, 1, 0, 0, 0, 3143, 3144, 5, 193, 0, 0, 3144, 3145, 5, 30, 0, 0, 3145, 3146, 3, 34, 17, 0, 3146, 3147, 5, 31, 0, 0, 3147, 3148, 6, 149, -1, 0, 3148, 3186, 1, 0, 0, 0, 3149, 3150, 5, 192, 0, 0, 3150, 3151, 5, 30, 0, 0, 3151, 3152, 3, 32, 16, 0, 3152, 3153, 5, 31, 0, 0, 3153, 3154, 6, 149, -1, 0, 3154, 3186, 1, 0, 0, 0, 3155, 3156, 5, 191, 0, 0, 3156, 3157, 5, 30, 0, 0, 3157, 3158, 3, 32, 16, 0, 3158, 3159, 5, 31, 0, 0, 3159, 3160, 6, 149, -1, 0, 3160, 3186, 1, 0, 0, 0, 3161, 3162, 5, 190, 0, 0, 3162, 3163, 5, 30, 0, 0, 3163, 3164, 3, 32, 16, 0, 3164, 3165, 5, 31, 0, 0, 3165, 3166, 6, 149, -1, 0, 3166, 3186, 1, 0, 0, 0, 3167, 3168, 5, 181, 0, 0, 3168, 3169, 5, 30, 0, 0, 3169, 3170, 3, 32, 16, 0, 3170, 3171, 5, 31, 0, 0, 3171, 3172, 6, 149, -1, 0, 3172, 3186, 1, 0, 0, 0, 3173, 3174, 5, 183, 0, 0, 3174, 3175, 5, 30, 0, 0, 3175, 3176, 3, 162, 81, 0, 3176, 3177, 5, 31, 0, 0, 3177, 3178, 6, 149, -1, 0, 3178, 3186, 1, 0, 0, 0, 3179, 3180, 5, 84, 0, 0, 3180, 3181, 5, 30, 0, 0, 3181, 3182, 3, 300, 150, 0, 3182, 3183, 5, 31, 0, 0, 3183, 3184, 6, 149, -1, 0, 3184, 3186, 1, 0, 0, 0, 3185, 3095, 1, 0, 0, 0, 3185, 3101, 1, 0, 0, 0, 3185, 3107, 1, 0, 0, 0, 3185, 3113, 1, 0, 0, 0, 3185, 3119, 1, 0, 0, 0, 3185, 3125, 1, 0, 0, 0, 3185, 3131, 1, 0, 0, 0, 3185, 3137, 1, 0, 0, 0, 3185, 3143, 1, 0, 0, 0, 3185, 3149, 1, 0, 0, 0, 3185, 3155, 1, 0, 0, 0, 3185, 3161, 1, 0, 0, 0, 3185, 3167, 1, 0, 0, 0, 3185, 3173, 1, 0, 0, 0, 3185, 3179, 1, 0, 0, 0, 3186, 299, 1, 0, 0, 0, 3187, 3188, 3, 302, 151, 0, 3188, 3189, 6, 150, -1, 0, 3189, 3191, 1, 0, 0, 0, 3190, 3187, 1, 0, 0, 0, 3191, 3194, 1, 0, 0, 0, 3192, 3190, 1, 0, 0, 0, 3192, 3193, 1, 0, 0, 0, 3193, 301, 1, 0, 0, 0, 3194, 3192, 1, 0, 0, 0, 3195, 3196, 7, 10, 0, 0, 3196, 303, 1, 0, 0, 0, 3197, 3198, 3, 298, 149, 0, 3198, 3199, 6, 152, -1, 0, 3199, 3206, 1, 0, 0, 0, 3200, 3201, 3, 6, 3, 0, 3201, 3202, 6, 152, -1, 0, 3202, 3206, 1, 0, 0, 0, 3203, 3204, 5, 179, 0, 0, 3204, 3206, 6, 152, -1, 0, 3205, 3197, 1, 0, 0, 0, 3205, 3200, 1, 0, 0, 0, 3205, 3203, 1, 0, 0, 0, 3206, 305, 1, 0, 0, 0, 3207, 3208, 3, 298, 149, 0, 3208, 3209, 6, 153, -1, 0, 3209, 3379, 1, 0, 0, 0, 3210, 3211, 5, 182, 0, 0, 3211, 3212, 5, 30, 0, 0, 3212, 3213, 5, 179, 0, 0, 3213, 3214, 5, 31, 0, 0, 3214, 3379, 6, 153, -1, 0, 3215, 3216, 5, 182, 0, 0, 3216, 3217, 5, 30, 0, 0, 3217, 3218, 5, 264, 0, 0, 3218, 3219, 5, 31, 0, 0, 3219, 3379, 6, 153, -1, 0, 3220, 3221, 5, 196, 0, 0, 3221, 3222, 5, 30, 0, 0, 3222, 3223, 5, 39, 0, 0, 3223, 3224, 5, 264, 0, 0, 3224, 3225, 5, 31, 0, 0, 3225, 3379, 6, 153, -1, 0, 3226, 3227, 5, 196, 0, 0, 3227, 3228, 5, 30, 0, 0, 3228, 3229, 3, 116, 58, 0, 3229, 3230, 5, 31, 0, 0, 3230, 3231, 6, 153, -1, 0, 3231, 3379, 1, 0, 0, 0, 3232, 3233, 5, 196, 0, 0, 3233, 3234, 5, 30, 0, 0, 3234, 3235, 5, 179, 0, 0, 3235, 3236, 5, 31, 0, 0, 3236, 3379, 6, 153, -1, 0, 3237, 3238, 5, 197, 0, 0, 3238, 3239, 5, 30, 0, 0, 3239, 3240, 3, 306, 153, 0, 3240, 3241, 5, 31, 0, 0, 3241, 3242, 6, 153, -1, 0, 3242, 3379, 1, 0, 0, 0, 3243, 3244, 5, 188, 0, 0, 3244, 3245, 5, 42, 0, 0, 3245, 3246, 3, 32, 16, 0, 3246, 3247, 5, 43, 0, 0, 3247, 3248, 5, 30, 0, 0, 3248, 3249, 3, 308, 154, 0, 3249, 3250, 5, 31, 0, 0, 3250, 3251, 6, 153, -1, 0, 3251, 3379, 1, 0, 0, 0, 3252, 3253, 5, 189, 0, 0, 3253, 3254, 5, 42, 0, 0, 3254, 3255, 3, 32, 16, 0, 3255, 3256, 5, 43, 0, 0, 3256, 3257, 5, 30, 0, 0, 3257, 3258, 3, 310, 155, 0, 3258, 3259, 5, 31, 0, 0, 3259, 3260, 6, 153, -1, 0, 3260, 3379, 1, 0, 0, 0, 3261, 3262, 5, 187, 0, 0, 3262, 3263, 5, 42, 0, 0, 3263, 3264, 3, 32, 16, 0, 3264, 3265, 5, 43, 0, 0, 3265, 3266, 5, 30, 0, 0, 3266, 3267, 3, 312, 156, 0, 3267, 3268, 5, 31, 0, 0, 3268, 3269, 6, 153, -1, 0, 3269, 3379, 1, 0, 0, 0, 3270, 3271, 5, 186, 0, 0, 3271, 3272, 5, 42, 0, 0, 3272, 3273, 3, 32, 16, 0, 3273, 3274, 5, 43, 0, 0, 3274, 3275, 5, 30, 0, 0, 3275, 3276, 3, 314, 157, 0, 3276, 3277, 5, 31, 0, 0, 3277, 3278, 6, 153, -1, 0, 3278, 3379, 1, 0, 0, 0, 3279, 3280, 5, 185, 0, 0, 3280, 3281, 5, 42, 0, 0, 3281, 3282, 3, 32, 16, 0, 3282, 3283, 5, 43, 0, 0, 3283, 3284, 5, 30, 0, 0, 3284, 3285, 3, 316, 158, 0, 3285, 3286, 5, 31, 0, 0, 3286, 3287, 6, 153, -1, 0, 3287, 3379, 1, 0, 0, 0, 3288, 3289, 5, 184, 0, 0, 3289, 3290, 5, 42, 0, 0, 3290, 3291, 3, 32, 16, 0, 3291, 3292, 5, 43, 0, 0, 3292, 3293, 5, 30, 0, 0, 3293, 3294, 3, 318, 159, 0, 3294, 3295, 5, 31, 0, 0, 3295, 3296, 6, 153, -1, 0, 3296, 3379, 1, 0, 0, 0, 3297, 3298, 5, 193, 0, 0, 3298, 3299, 5, 42, 0, 0, 3299, 3300, 3, 32, 16, 0, 3300, 3301, 5, 43, 0, 0, 3301, 3302, 5, 30, 0, 0, 3302, 3303, 3, 312, 156, 0, 3303, 3304, 5, 31, 0, 0, 3304, 3305, 6, 153, -1, 0, 3305, 3379, 1, 0, 0, 0, 3306, 3307, 5, 192, 0, 0, 3307, 3308, 5, 42, 0, 0, 3308, 3309, 3, 32, 16, 0, 3309, 3310, 5, 43, 0, 0, 3310, 3311, 5, 30, 0, 0, 3311, 3312, 3, 314, 157, 0, 3312, 3313, 5, 31, 0, 0, 3313, 3314, 6, 153, -1, 0, 3314, 3379, 1, 0, 0, 0, 3315, 3316, 5, 191, 0, 0, 3316, 3317, 5, 42, 0, 0, 3317, 3318, 3, 32, 16, 0, 3318, 3319, 5, 43, 0, 0, 3319, 3320, 5, 30, 0, 0, 3320, 3321, 3, 316, 158, 0, 3321, 3322, 5, 31, 0, 0, 3322, 3323, 6, 153, -1, 0, 3323, 3379, 1, 0, 0, 0, 3324, 3325, 5, 190, 0, 0, 3325, 3326, 5, 42, 0, 0, 3326, 3327, 3, 32, 16, 0, 3327, 3328, 5, 43, 0, 0, 3328, 3329, 5, 30, 0, 0, 3329, 3330, 3, 318, 159, 0, 3330, 3331, 5, 31, 0, 0, 3331, 3332, 6, 153, -1, 0, 3332, 3379, 1, 0, 0, 0, 3333, 3334, 5, 181, 0, 0, 3334, 3335, 5, 42, 0, 0, 3335, 3336, 3, 32, 16, 0, 3336, 3337, 5, 43, 0, 0, 3337, 3338, 5, 30, 0, 0, 3338, 3339, 3, 316, 158, 0, 3339, 3340, 5, 31, 0, 0, 3340, 3341, 6, 153, -1, 0, 3341, 3379, 1, 0, 0, 0, 3342, 3343, 5, 183, 0, 0, 3343, 3344, 5, 42, 0, 0, 3344, 3345, 3, 32, 16, 0, 3345, 3346, 5, 43, 0, 0, 3346, 3347, 5, 30, 0, 0, 3347, 3348, 3, 320, 160, 0, 3348, 3349, 5, 31, 0, 0, 3349, 3350, 6, 153, -1, 0, 3350, 3379, 1, 0, 0, 0, 3351, 3352, 5, 182, 0, 0, 3352, 3353, 5, 42, 0, 0, 3353, 3354, 3, 32, 16, 0, 3354, 3355, 5, 43, 0, 0, 3355, 3356, 5, 30, 0, 0, 3356, 3357, 3, 322, 161, 0, 3357, 3358, 5, 31, 0, 0, 3358, 3359, 6, 153, -1, 0, 3359, 3379, 1, 0, 0, 0, 3360, 3361, 5, 196, 0, 0, 3361, 3362, 5, 42, 0, 0, 3362, 3363, 3, 32, 16, 0, 3363, 3364, 5, 43, 0, 0, 3364, 3365, 5, 30, 0, 0, 3365, 3366, 3, 324, 162, 0, 3366, 3367, 5, 31, 0, 0, 3367, 3368, 6, 153, -1, 0, 3368, 3379, 1, 0, 0, 0, 3369, 3370, 5, 197, 0, 0, 3370, 3371, 5, 42, 0, 0, 3371, 3372, 3, 32, 16, 0, 3372, 3373, 5, 43, 0, 0, 3373, 3374, 5, 30, 0, 0, 3374, 3375, 3, 328, 164, 0, 3375, 3376, 5, 31, 0, 0, 3376, 3377, 6, 153, -1, 0, 3377, 3379, 1, 0, 0, 0, 3378, 3207, 1, 0, 0, 0, 3378, 3210, 1, 0, 0, 0, 3378, 3215, 1, 0, 0, 0, 3378, 3220, 1, 0, 0, 0, 3378, 3226, 1, 0, 0, 0, 3378, 3232, 1, 0, 0, 0, 3378, 3237, 1, 0, 0, 0, 3378, 3243, 1, 0, 0, 0, 3378, 3252, 1, 0, 0, 0, 3378, 3261, 1, 0, 0, 0, 3378, 3270, 1, 0, 0, 0, 3378, 3279, 1, 0, 0, 0, 3378, 3288, 1, 0, 0, 0, 3378, 3297, 1, 0, 0, 0, 3378, 3306, 1, 0, 0, 0, 3378, 3315, 1, 0, 0, 0, 3378, 3324, 1, 0, 0, 0, 3378, 3333, 1, 0, 0, 0, 3378, 3342, 1, 0, 0, 0, 3378, 3351, 1, 0, 0, 0, 3378, 3360, 1, 0, 0, 0, 3378, 3369, 1, 0, 0, 0, 3379, 307, 1, 0, 0, 0, 3380, 3381, 3, 36, 18, 0, 3381, 3382, 6, 154, -1, 0, 3382, 3387, 1, 0, 0, 0, 3383, 3384, 3, 32, 16, 0, 3384, 3385, 6, 154, -1, 0, 3385, 3387, 1, 0, 0, 0, 3386, 3380, 1, 0, 0, 0, 3386, 3383, 1, 0, 0, 0, 3387, 3390, 1, 0, 0, 0, 3388, 3386, 1, 0, 0, 0, 3388, 3389, 1, 0, 0, 0, 3389, 309, 1, 0, 0, 0, 3390, 3388, 1, 0, 0, 0, 3391, 3392, 3, 36, 18, 0, 3392, 3393, 6, 155, -1, 0, 3393, 3398, 1, 0, 0, 0, 3394, 3395, 3, 34, 17, 0, 3395, 3396, 6, 155, -1, 0, 3396, 3398, 1, 0, 0, 0, 3397, 3391, 1, 0, 0, 0, 3397, 3394, 1, 0, 0, 0, 3398, 3401, 1, 0, 0, 0, 3399, 3397, 1, 0, 0, 0, 3399, 3400, 1, 0, 0, 0, 3400, 311, 1, 0, 0, 0, 3401, 3399, 1, 0, 0, 0, 3402, 3403, 3, 34, 17, 0, 3403, 3404, 6, 156, -1, 0, 3404, 3406, 1, 0, 0, 0, 3405, 3402, 1, 0, 0, 0, 3406, 3409, 1, 0, 0, 0, 3407, 3405, 1, 0, 0, 0, 3407, 3408, 1, 0, 0, 0, 3408, 313, 1, 0, 0, 0, 3409, 3407, 1, 0, 0, 0, 3410, 3411, 3, 32, 16, 0, 3411, 3412, 6, 157, -1, 0, 3412, 3414, 1, 0, 0, 0, 3413, 3410, 1, 0, 0, 0, 3414, 3417, 1, 0, 0, 0, 3415, 3413, 1, 0, 0, 0, 3415, 3416, 1, 0, 0, 0, 3416, 315, 1, 0, 0, 0, 3417, 3415, 1, 0, 0, 0, 3418, 3419, 3, 32, 16, 0, 3419, 3420, 6, 158, -1, 0, 3420, 3422, 1, 0, 0, 0, 3421, 3418, 1, 0, 0, 0, 3422, 3425, 1, 0, 0, 0, 3423, 3421, 1, 0, 0, 0, 3423, 3424, 1, 0, 0, 0, 3424, 317, 1, 0, 0, 0, 3425, 3423, 1, 0, 0, 0, 3426, 3427, 3, 32, 16, 0, 3427, 3428, 6, 159, -1, 0, 3428, 3430, 1, 0, 0, 0, 3429, 3426, 1, 0, 0, 0, 3430, 3433, 1, 0, 0, 0, 3431, 3429, 1, 0, 0, 0, 3431, 3432, 1, 0, 0, 0, 3432, 319, 1, 0, 0, 0, 3433, 3431, 1, 0, 0, 0, 3434, 3435, 3, 162, 81, 0, 3435, 3436, 6, 160, -1, 0, 3436, 3438, 1, 0, 0, 0, 3437, 3434, 1, 0, 0, 0, 3438, 3441, 1, 0, 0, 0, 3439, 3437, 1, 0, 0, 0, 3439, 3440, 1, 0, 0, 0, 3440, 321, 1, 0, 0, 0, 3441, 3439, 1, 0, 0, 0, 3442, 3443, 5, 179, 0, 0, 3443, 3447, 6, 161, -1, 0, 3444, 3445, 5, 264, 0, 0, 3445, 3447, 6, 161, -1, 0, 3446, 3442, 1, 0, 0, 0, 3446, 3444, 1, 0, 0, 0, 3447, 3450, 1, 0, 0, 0, 3448, 3446, 1, 0, 0, 0, 3448, 3449, 1, 0, 0, 0, 3449, 323, 1, 0, 0, 0, 3450, 3448, 1, 0, 0, 0, 3451, 3452, 3, 326, 163, 0, 3452, 3453, 6, 162, -1, 0, 3453, 3455, 1, 0, 0, 0, 3454, 3451, 1, 0, 0, 0, 3455, 3458, 1, 0, 0, 0, 3456, 3454, 1, 0, 0, 0, 3456, 3457, 1, 0, 0, 0, 3457, 325, 1, 0, 0, 0, 3458, 3456, 1, 0, 0, 0, 3459, 3460, 5, 179, 0, 0, 3460, 3468, 6, 163, -1, 0, 3461, 3462, 5, 39, 0, 0, 3462, 3463, 5, 264, 0, 0, 3463, 3468, 6, 163, -1, 0, 3464, 3465, 3, 116, 58, 0, 3465, 3466, 6, 163, -1, 0, 3466, 3468, 1, 0, 0, 0, 3467, 3459, 1, 0, 0, 0, 3467, 3461, 1, 0, 0, 0, 3467, 3464, 1, 0, 0, 0, 3468, 327, 1, 0, 0, 0, 3469, 3470, 3, 306, 153, 0, 3470, 3471, 6, 164, -1, 0, 3471, 3473, 1, 0, 0, 0, 3472, 3469, 1, 0, 0, 0, 3473, 3476, 1, 0, 0, 0, 3474, 3472, 1, 0, 0, 0, 3474, 3475, 1, 0, 0, 0, 3475, 329, 1, 0, 0, 0, 3476, 3474, 1, 0, 0, 0, 3477, 3478, 3, 44, 22, 0, 3478, 3479, 6, 165, -1, 0, 3479, 3487, 1, 0, 0, 0, 3480, 3481, 3, 46, 23, 0, 3481, 3482, 6, 165, -1, 0, 3482, 3487, 1, 0, 0, 0, 3483, 3484, 3, 2, 1, 0, 3484, 3485, 6, 165, -1, 0, 3485, 3487, 1, 0, 0, 0, 3486, 3477, 1, 0, 0, 0, 3486, 3480, 1, 0, 0, 0, 3486, 3483, 1, 0, 0, 0, 3487, 331, 1, 0, 0, 0, 3488, 3489, 7, 11, 0, 0, 3489, 3490, 5, 36, 0, 0, 3490, 3491, 5, 30, 0, 0, 3491, 3492, 3, 300, 150, 0, 3492, 3493, 5, 31, 0, 0, 3493, 3514, 1, 0, 0, 0, 3494, 3495, 5, 169, 0, 0, 3495, 3496, 3, 38, 19, 0, 3496, 3497, 5, 75, 0, 0, 3497, 3498, 3, 38, 19, 0, 3498, 3499, 5, 75, 0, 0, 3499, 3500, 3, 38, 19, 0, 3500, 3501, 5, 75, 0, 0, 3501, 3502, 3, 38, 19, 0, 3502, 3514, 1, 0, 0, 0, 3503, 3504, 5, 170, 0, 0, 3504, 3514, 3, 6, 3, 0, 3505, 3506, 5, 170, 0, 0, 3506, 3507, 5, 36, 0, 0, 3507, 3508, 5, 30, 0, 0, 3508, 3509, 3, 300, 150, 0, 3509, 3510, 5, 31, 0, 0, 3510, 3514, 1, 0, 0, 0, 3511, 3514, 3, 330, 165, 0, 3512, 3514, 3, 40, 20, 0, 3513, 3488, 1, 0, 0, 0, 3513, 3494, 1, 0, 0, 0, 3513, 3503, 1, 0, 0, 0, 3513, 3505, 1, 0, 0, 0, 3513, 3511, 1, 0, 0, 0, 3513, 3512, 1, 0, 0, 0, 3514, 333, 1, 0, 0, 0, 3515, 3516, 3, 336, 168, 0, 3516, 3517, 5, 17, 0, 0, 3517, 3518, 3, 338, 169, 0, 3518, 3519, 5, 18, 0, 0, 3519, 335, 1, 0, 0, 0, 3520, 3521, 5, 25, 0, 0, 3521, 3522, 5, 40, 0, 0, 3522, 3523, 3, 98, 49, 0, 3523, 3524, 3, 2, 1, 0, 3524, 3533, 1, 0, 0, 0, 3525, 3526, 5, 25, 0, 0, 3526, 3527, 5, 40, 0, 0, 3527, 3528, 3, 98, 49, 0, 3528, 3529, 3, 2, 1, 0, 3529, 3530, 5, 34, 0, 0, 3530, 3531, 3, 2, 1, 0, 3531, 3533, 1, 0, 0, 0, 3532, 3520, 1, 0, 0, 0, 3532, 3525, 1, 0, 0, 0, 3533, 337, 1, 0, 0, 0, 3534, 3536, 3, 340, 170, 0, 3535, 3534, 1, 0, 0, 0, 3536, 3539, 1, 0, 0, 0, 3537, 3535, 1, 0, 0, 0, 3537, 3538, 1, 0, 0, 0, 3538, 339, 1, 0, 0, 0, 3539, 3537, 1, 0, 0, 0, 3540, 3541, 5, 180, 0, 0, 3541, 3542, 5, 36, 0, 0, 3542, 3543, 5, 30, 0, 0, 3543, 3544, 3, 300, 150, 0, 3544, 3545, 5, 31, 0, 0, 3545, 3555, 1, 0, 0, 0, 3546, 3555, 3, 332, 166, 0, 3547, 3548, 5, 171, 0, 0, 3548, 3549, 5, 36, 0, 0, 3549, 3550, 5, 30, 0, 0, 3550, 3551, 3, 300, 150, 0, 3551, 3552, 5, 31, 0, 0, 3552, 3555, 1, 0, 0, 0, 3553, 3555, 5, 55, 0, 0, 3554, 3540, 1, 0, 0, 0, 3554, 3546, 1, 0, 0, 0, 3554, 3547, 1, 0, 0, 0, 3554, 3553, 1, 0, 0, 0, 3555, 341, 1, 0, 0, 0, 3556, 3557, 3, 344, 172, 0, 3557, 3558, 5, 17, 0, 0, 3558, 3559, 3, 350, 175, 0, 3559, 3560, 5, 18, 0, 0, 3560, 343, 1, 0, 0, 0, 3561, 3562, 5, 50, 0, 0, 3562, 3566, 5, 40, 0, 0, 3563, 3565, 3, 348, 174, 0, 3564, 3563, 1, 0, 0, 0, 3565, 3568, 1, 0, 0, 0, 3566, 3564, 1, 0, 0, 0, 3566, 3567, 1, 0, 0, 0, 3567, 3569, 1, 0, 0, 0, 3568, 3566, 1, 0, 0, 0, 3569, 3570, 3, 2, 1, 0, 3570, 345, 1, 0, 0, 0, 3571, 3575, 5, 301, 0, 0, 3572, 3574, 3, 348, 174, 0, 3573, 3572, 1, 0, 0, 0, 3574, 3577, 1, 0, 0, 0, 3575, 3573, 1, 0, 0, 0, 3575, 3576, 1, 0, 0, 0, 3576, 3578, 1, 0, 0, 0, 3577, 3575, 1, 0, 0, 0, 3578, 3579, 3, 2, 1, 0, 3579, 347, 1, 0, 0, 0, 3580, 3596, 5, 52, 0, 0, 3581, 3596, 5, 51, 0, 0, 3582, 3596, 5, 172, 0, 0, 3583, 3584, 5, 62, 0, 0, 3584, 3596, 5, 51, 0, 0, 3585, 3586, 5, 62, 0, 0, 3586, 3596, 5, 52, 0, 0, 3587, 3588, 5, 62, 0, 0, 3588, 3596, 5, 63, 0, 0, 3589, 3590, 5, 62, 0, 0, 3590, 3596, 5, 64, 0, 0, 3591, 3592, 5, 62, 0, 0, 3592, 3596, 5, 65, 0, 0, 3593, 3594, 5, 62, 0, 0, 3594, 3596, 5, 66, 0, 0, 3595, 3580, 1, 0, 0, 0, 3595, 3581, 1, 0, 0, 0, 3595, 3582, 1, 0, 0, 0, 3595, 3583, 1, 0, 0, 0, 3595, 3585, 1, 0, 0, 0, 3595, 3587, 1, 0, 0, 0, 3595, 3589, 1, 0, 0, 0, 3595, 3591, 1, 0, 0, 0, 3595, 3593, 1, 0, 0, 0, 3596, 349, 1, 0, 0, 0, 3597, 3599, 3, 352, 176, 0, 3598, 3597, 1, 0, 0, 0, 3599, 3602, 1, 0, 0, 0, 3600, 3598, 1, 0, 0, 0, 3600, 3601, 1, 0, 0, 0, 3601, 351, 1, 0, 0, 0, 3602, 3600, 1, 0, 0, 0, 3603, 3604, 5, 21, 0, 0, 3604, 3617, 3, 2, 1, 0, 3605, 3606, 5, 50, 0, 0, 3606, 3607, 5, 40, 0, 0, 3607, 3617, 3, 118, 59, 0, 3608, 3609, 5, 25, 0, 0, 3609, 3610, 5, 40, 0, 0, 3610, 3617, 3, 2, 1, 0, 3611, 3617, 3, 174, 87, 0, 3612, 3613, 5, 50, 0, 0, 3613, 3617, 3, 32, 16, 0, 3614, 3617, 3, 330, 165, 0, 3615, 3617, 3, 40, 20, 0, 3616, 3603, 1, 0, 0, 0, 3616, 3605, 1, 0, 0, 0, 3616, 3608, 1, 0, 0, 0, 3616, 3611, 1, 0, 0, 0, 3616, 3612, 1, 0, 0, 0, 3616, 3614, 1, 0, 0, 0, 3616, 3615, 1, 0, 0, 0, 3617, 353, 1, 0, 0, 0, 3618, 3619, 3, 356, 178, 0, 3619, 3620, 5, 17, 0, 0, 3620, 3621, 3, 360, 180, 0, 3621, 3622, 5, 18, 0, 0, 3622, 355, 1, 0, 0, 0, 3623, 3627, 5, 274, 0, 0, 3624, 3626, 3, 358, 179, 0, 3625, 3624, 1, 0, 0, 0, 3626, 3629, 1, 0, 0, 0, 3627, 3625, 1, 0, 0, 0, 3627, 3628, 1, 0, 0, 0, 3628, 3630, 1, 0, 0, 0, 3629, 3627, 1, 0, 0, 0, 3630, 3643, 3, 2, 1, 0, 3631, 3635, 5, 274, 0, 0, 3632, 3634, 3, 358, 179, 0, 3633, 3632, 1, 0, 0, 0, 3634, 3637, 1, 0, 0, 0, 3635, 3633, 1, 0, 0, 0, 3635, 3636, 1, 0, 0, 0, 3636, 3638, 1, 0, 0, 0, 3637, 3635, 1, 0, 0, 0, 3638, 3639, 3, 2, 1, 0, 3639, 3640, 5, 34, 0, 0, 3640, 3641, 3, 2, 1, 0, 3641, 3643, 1, 0, 0, 0, 3642, 3623, 1, 0, 0, 0, 3642, 3631, 1, 0, 0, 0, 3643, 357, 1, 0, 0, 0, 3644, 3645, 7, 12, 0, 0, 3645, 359, 1, 0, 0, 0, 3646, 3648, 3, 362, 181, 0, 3647, 3646, 1, 0, 0, 0, 3648, 3651, 1, 0, 0, 0, 3649, 3647, 1, 0, 0, 0, 3649, 3650, 1, 0, 0, 0, 3650, 361, 1, 0, 0, 0, 3651, 3649, 1, 0, 0, 0, 3652, 3653, 5, 21, 0, 0, 3653, 3654, 3, 2, 1, 0, 3654, 3655, 5, 44, 0, 0, 3655, 3656, 3, 32, 16, 0, 3656, 3663, 1, 0, 0, 0, 3657, 3658, 5, 25, 0, 0, 3658, 3659, 5, 40, 0, 0, 3659, 3663, 3, 2, 1, 0, 3660, 3663, 3, 330, 165, 0, 3661, 3663, 3, 40, 20, 0, 3662, 3652, 1, 0, 0, 0, 3662, 3657, 1, 0, 0, 0, 3662, 3660, 1, 0, 0, 0, 3662, 3661, 1, 0, 0, 0, 3663, 363, 1, 0, 0, 0, 182, 374, 382, 391, 400, 489, 535, 546, 576, 580, 598, 625, 653, 693, 704, 714, 716, 727, 729, 737, 759, 772, 793, 795, 814, 887, 894, 901, 906, 915, 1026, 1032, 1048, 1054, 1060, 1067, 1095, 1173, 1175, 1189, 1195, 1204, 1206, 1215, 1229, 1243, 1251, 1259, 1263, 1302, 1310, 1319, 1327, 1346, 1356, 1359, 1383, 1530, 1540, 1549, 1552, 1634, 1643, 1675, 1735, 1775, 1791, 1801, 1828, 1852, 1860, 1864, 1879, 1886, 1931, 1941, 1959, 1977, 1996, 2017, 2036, 2051, 2059, 2071, 2091, 2098, 2103, 2114, 2126, 2236, 2248, 2264, 2278, 2287, 2300, 2302, 2345, 2356, 2363, 2371, 2379, 2392, 2398, 2404, 2409, 2438, 2446, 2460, 2465, 2490, 2499, 2510, 2514, 2521, 2541, 2550, 2552, 2567, 2614, 2624, 2626, 2633, 2639, 2683, 2692, 2732, 2737, 2777, 2781, 2791, 2813, 2825, 2836, 2851, 2864, 2877, 2880, 2892, 2906, 2924, 2942, 2956, 2980, 2992, 2997, 3006, 3008, 3015, 3025, 3093, 3185, 3192, 3205, 3378, 3386, 3388, 3397, 3399, 3407, 3415, 3423, 3431, 3439, 3446, 3448, 3456, 3467, 3474, 3486, 3513, 3532, 3537, 3554, 3566, 3575, 3595, 3600, 3616, 3627, 3635, 3642, 3649, 3662] \ No newline at end of file +[4, 1, 305, 3631, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 373, 8, 1, 10, 1, 12, 1, 376, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 383, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 5, 3, 390, 8, 3, 10, 3, 12, 3, 393, 9, 3, 1, 3, 1, 3, 1, 3, 1, 4, 5, 4, 399, 8, 4, 10, 4, 12, 4, 402, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 490, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 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, 540, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 5, 15, 549, 8, 15, 10, 15, 12, 15, 552, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 581, 8, 18, 1, 19, 1, 19, 3, 19, 585, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 603, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 630, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 658, 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, 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, 698, 8, 23, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 709, 8, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 5, 27, 719, 8, 27, 10, 27, 12, 27, 722, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 732, 8, 28, 10, 28, 12, 28, 735, 9, 28, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 3, 30, 742, 8, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 764, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 777, 8, 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, 34, 1, 34, 1, 34, 1, 34, 5, 34, 798, 8, 34, 10, 34, 12, 34, 801, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 5, 37, 817, 8, 37, 10, 37, 12, 37, 820, 9, 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, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 892, 8, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 899, 8, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 906, 8, 40, 1, 41, 5, 41, 909, 8, 41, 10, 41, 12, 41, 912, 9, 41, 1, 42, 1, 42, 1, 42, 1, 42, 5, 42, 918, 8, 42, 10, 42, 12, 42, 921, 9, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 3, 44, 931, 8, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 940, 8, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 951, 8, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 962, 8, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 975, 8, 44, 1, 44, 1, 44, 3, 44, 979, 8, 44, 1, 45, 1, 45, 5, 45, 983, 8, 45, 10, 45, 12, 45, 986, 9, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 999, 8, 45, 10, 45, 12, 45, 1002, 9, 45, 1, 45, 1, 45, 1, 45, 3, 45, 1007, 8, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 1013, 8, 47, 1, 48, 1, 48, 1, 49, 5, 49, 1018, 8, 49, 10, 49, 12, 49, 1021, 9, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 1048, 8, 50, 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, 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, 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, 1126, 8, 51, 3, 51, 1128, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1142, 8, 53, 1, 53, 1, 53, 5, 53, 1146, 8, 53, 10, 53, 12, 53, 1149, 9, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1157, 8, 53, 3, 53, 1159, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1166, 8, 54, 10, 54, 12, 54, 1169, 9, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1180, 8, 55, 10, 55, 12, 55, 1183, 9, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 5, 56, 1194, 8, 56, 10, 56, 12, 56, 1197, 9, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1204, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 1212, 8, 57, 1, 57, 1, 57, 3, 57, 1216, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1255, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 1261, 8, 59, 10, 59, 12, 59, 1264, 9, 59, 1, 59, 1, 59, 1, 59, 1, 60, 5, 60, 1270, 8, 60, 10, 60, 12, 60, 1273, 9, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1280, 8, 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, 3, 62, 1299, 8, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 5, 63, 1307, 8, 63, 10, 63, 12, 63, 1310, 9, 63, 3, 63, 1312, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 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, 1336, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1483, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1493, 8, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 5, 67, 1500, 8, 67, 10, 67, 12, 67, 1503, 9, 67, 3, 67, 1505, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1587, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 5, 69, 1594, 8, 69, 10, 69, 12, 69, 1597, 9, 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, 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, 1628, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1688, 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, 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, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1728, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1744, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1754, 8, 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, 3, 76, 1784, 8, 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, 1812, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 5, 77, 1819, 8, 77, 10, 77, 12, 77, 1822, 9, 77, 1, 77, 1, 77, 1, 77, 3, 77, 1827, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1844, 8, 78, 1, 79, 1, 79, 1, 79, 1, 79, 5, 79, 1850, 8, 79, 10, 79, 12, 79, 1853, 9, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1910, 8, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1920, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1938, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1956, 8, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1975, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1996, 8, 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, 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 2015, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 2030, 8, 89, 1, 90, 1, 90, 1, 90, 1, 90, 5, 90, 2036, 8, 90, 10, 90, 12, 90, 2039, 9, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 2050, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 2070, 8, 92, 1, 93, 1, 93, 1, 93, 5, 93, 2075, 8, 93, 10, 93, 12, 93, 2078, 9, 93, 1, 94, 1, 94, 3, 94, 2082, 8, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 5, 95, 2091, 8, 95, 10, 95, 12, 95, 2094, 9, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 3, 97, 2105, 8, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2213, 8, 99, 10, 99, 12, 99, 2216, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2225, 8, 99, 10, 99, 12, 99, 2228, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2241, 8, 99, 10, 99, 12, 99, 2244, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2255, 8, 99, 10, 99, 12, 99, 2258, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 2266, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 2279, 8, 100, 10, 100, 12, 100, 2282, 9, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 2324, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 2335, 8, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 3, 103, 2342, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 2350, 8, 104, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2356, 8, 105, 10, 105, 12, 105, 2359, 9, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2369, 8, 105, 10, 105, 12, 105, 2372, 9, 105, 1, 105, 1, 105, 1, 105, 3, 105, 2377, 8, 105, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 2383, 8, 106, 1, 107, 5, 107, 2386, 8, 107, 10, 107, 12, 107, 2389, 9, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 2417, 8, 108, 1, 109, 1, 109, 1, 109, 1, 109, 5, 109, 2423, 8, 109, 10, 109, 12, 109, 2426, 9, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 2439, 8, 110, 1, 111, 5, 111, 2442, 8, 111, 10, 111, 12, 111, 2445, 9, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 2469, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 2478, 8, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 4, 114, 2487, 8, 114, 11, 114, 12, 114, 2488, 1, 114, 1, 114, 3, 114, 2493, 8, 114, 1, 115, 1, 115, 1, 115, 5, 115, 2498, 8, 115, 10, 115, 12, 115, 2501, 9, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 2520, 8, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2529, 8, 117, 10, 117, 12, 117, 2532, 9, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2544, 8, 117, 10, 117, 12, 117, 2547, 9, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2593, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2603, 8, 119, 3, 119, 2605, 8, 119, 1, 119, 1, 119, 1, 119, 5, 119, 2610, 8, 119, 10, 119, 12, 119, 2613, 9, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2618, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2662, 8, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 2671, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2711, 8, 122, 1, 123, 5, 123, 2714, 8, 123, 10, 123, 12, 123, 2717, 9, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2756, 8, 124, 1, 125, 1, 125, 3, 125, 2760, 8, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, 2770, 8, 126, 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, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 2792, 8, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2802, 8, 129, 10, 129, 12, 129, 2805, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2813, 8, 129, 10, 129, 12, 129, 2816, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2828, 8, 129, 10, 129, 12, 129, 2831, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2841, 8, 129, 10, 129, 12, 129, 2844, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2854, 8, 129, 10, 129, 12, 129, 2857, 9, 129, 3, 129, 2859, 8, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 2871, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 4, 134, 2883, 8, 134, 11, 134, 12, 134, 2884, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 3, 135, 2903, 8, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 3, 136, 2921, 8, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 2935, 8, 137, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 2959, 8, 141, 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, 3, 143, 2974, 8, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 3, 144, 2981, 8, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 4, 145, 2988, 8, 145, 11, 145, 12, 145, 2989, 3, 145, 2992, 8, 145, 1, 146, 1, 146, 1, 146, 5, 146, 2997, 8, 146, 10, 146, 12, 146, 3000, 9, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 3010, 8, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 3, 148, 3060, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 3152, 8, 149, 1, 150, 1, 150, 1, 150, 5, 150, 3157, 8, 150, 10, 150, 12, 150, 3160, 9, 150, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 3, 152, 3172, 8, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 3, 153, 3345, 8, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 5, 154, 3353, 8, 154, 10, 154, 12, 154, 3356, 9, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 5, 155, 3364, 8, 155, 10, 155, 12, 155, 3367, 9, 155, 1, 156, 1, 156, 1, 156, 5, 156, 3372, 8, 156, 10, 156, 12, 156, 3375, 9, 156, 1, 157, 1, 157, 1, 157, 5, 157, 3380, 8, 157, 10, 157, 12, 157, 3383, 9, 157, 1, 158, 1, 158, 1, 158, 5, 158, 3388, 8, 158, 10, 158, 12, 158, 3391, 9, 158, 1, 159, 1, 159, 1, 159, 5, 159, 3396, 8, 159, 10, 159, 12, 159, 3399, 9, 159, 1, 160, 1, 160, 1, 160, 5, 160, 3404, 8, 160, 10, 160, 12, 160, 3407, 9, 160, 1, 161, 1, 161, 1, 161, 1, 161, 5, 161, 3413, 8, 161, 10, 161, 12, 161, 3416, 9, 161, 1, 162, 1, 162, 1, 162, 5, 162, 3421, 8, 162, 10, 162, 12, 162, 3424, 9, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 3434, 8, 163, 1, 164, 1, 164, 1, 164, 5, 164, 3439, 8, 164, 10, 164, 12, 164, 3442, 9, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 3, 165, 3453, 8, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 3, 166, 3480, 8, 166, 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, 168, 3, 168, 3499, 8, 168, 1, 169, 5, 169, 3502, 8, 169, 10, 169, 12, 169, 3505, 9, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 3521, 8, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 5, 172, 3531, 8, 172, 10, 172, 12, 172, 3534, 9, 172, 1, 172, 1, 172, 1, 173, 1, 173, 5, 173, 3540, 8, 173, 10, 173, 12, 173, 3543, 9, 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, 3, 174, 3562, 8, 174, 1, 175, 5, 175, 3565, 8, 175, 10, 175, 12, 175, 3568, 9, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 3, 176, 3583, 8, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 178, 1, 178, 5, 178, 3592, 8, 178, 10, 178, 12, 178, 3595, 9, 178, 1, 178, 1, 178, 1, 178, 5, 178, 3600, 8, 178, 10, 178, 12, 178, 3603, 9, 178, 1, 178, 1, 178, 1, 178, 1, 178, 3, 178, 3609, 8, 178, 1, 179, 1, 179, 1, 180, 5, 180, 3614, 8, 180, 10, 180, 12, 180, 3617, 9, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 3, 181, 3629, 8, 181, 1, 181, 0, 1, 68, 182, 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, 0, 16, 6, 0, 1, 15, 199, 199, 243, 243, 247, 247, 264, 264, 289, 289, 5, 0, 16, 16, 199, 199, 243, 243, 264, 264, 288, 289, 1, 0, 263, 264, 1, 0, 173, 174, 1, 0, 37, 38, 1, 0, 73, 74, 3, 0, 2, 2, 61, 61, 77, 83, 2, 0, 229, 229, 260, 261, 1, 0, 95, 96, 1, 0, 97, 111, 1, 0, 188, 189, 1, 0, 184, 186, 1, 0, 184, 189, 2, 0, 173, 173, 289, 290, 1, 0, 167, 168, 1, 0, 51, 52, 4080, 0, 364, 1, 0, 0, 0, 2, 382, 1, 0, 0, 0, 4, 384, 1, 0, 0, 0, 6, 391, 1, 0, 0, 0, 8, 400, 1, 0, 0, 0, 10, 489, 1, 0, 0, 0, 12, 491, 1, 0, 0, 0, 14, 495, 1, 0, 0, 0, 16, 499, 1, 0, 0, 0, 18, 504, 1, 0, 0, 0, 20, 508, 1, 0, 0, 0, 22, 512, 1, 0, 0, 0, 24, 519, 1, 0, 0, 0, 26, 539, 1, 0, 0, 0, 28, 541, 1, 0, 0, 0, 30, 543, 1, 0, 0, 0, 32, 555, 1, 0, 0, 0, 34, 557, 1, 0, 0, 0, 36, 580, 1, 0, 0, 0, 38, 584, 1, 0, 0, 0, 40, 602, 1, 0, 0, 0, 42, 629, 1, 0, 0, 0, 44, 657, 1, 0, 0, 0, 46, 697, 1, 0, 0, 0, 48, 699, 1, 0, 0, 0, 50, 708, 1, 0, 0, 0, 52, 710, 1, 0, 0, 0, 54, 720, 1, 0, 0, 0, 56, 733, 1, 0, 0, 0, 58, 736, 1, 0, 0, 0, 60, 739, 1, 0, 0, 0, 62, 763, 1, 0, 0, 0, 64, 776, 1, 0, 0, 0, 66, 778, 1, 0, 0, 0, 68, 786, 1, 0, 0, 0, 70, 802, 1, 0, 0, 0, 72, 808, 1, 0, 0, 0, 74, 812, 1, 0, 0, 0, 76, 891, 1, 0, 0, 0, 78, 898, 1, 0, 0, 0, 80, 905, 1, 0, 0, 0, 82, 910, 1, 0, 0, 0, 84, 919, 1, 0, 0, 0, 86, 925, 1, 0, 0, 0, 88, 978, 1, 0, 0, 0, 90, 1006, 1, 0, 0, 0, 92, 1008, 1, 0, 0, 0, 94, 1012, 1, 0, 0, 0, 96, 1014, 1, 0, 0, 0, 98, 1019, 1, 0, 0, 0, 100, 1047, 1, 0, 0, 0, 102, 1127, 1, 0, 0, 0, 104, 1129, 1, 0, 0, 0, 106, 1158, 1, 0, 0, 0, 108, 1160, 1, 0, 0, 0, 110, 1174, 1, 0, 0, 0, 112, 1203, 1, 0, 0, 0, 114, 1215, 1, 0, 0, 0, 116, 1254, 1, 0, 0, 0, 118, 1262, 1, 0, 0, 0, 120, 1271, 1, 0, 0, 0, 122, 1279, 1, 0, 0, 0, 124, 1298, 1, 0, 0, 0, 126, 1311, 1, 0, 0, 0, 128, 1335, 1, 0, 0, 0, 130, 1482, 1, 0, 0, 0, 132, 1492, 1, 0, 0, 0, 134, 1504, 1, 0, 0, 0, 136, 1586, 1, 0, 0, 0, 138, 1588, 1, 0, 0, 0, 140, 1627, 1, 0, 0, 0, 142, 1687, 1, 0, 0, 0, 144, 1727, 1, 0, 0, 0, 146, 1743, 1, 0, 0, 0, 148, 1745, 1, 0, 0, 0, 150, 1749, 1, 0, 0, 0, 152, 1811, 1, 0, 0, 0, 154, 1826, 1, 0, 0, 0, 156, 1843, 1, 0, 0, 0, 158, 1851, 1, 0, 0, 0, 160, 1857, 1, 0, 0, 0, 162, 1862, 1, 0, 0, 0, 164, 1909, 1, 0, 0, 0, 166, 1911, 1, 0, 0, 0, 168, 1955, 1, 0, 0, 0, 170, 1974, 1, 0, 0, 0, 172, 1995, 1, 0, 0, 0, 174, 1997, 1, 0, 0, 0, 176, 2014, 1, 0, 0, 0, 178, 2029, 1, 0, 0, 0, 180, 2037, 1, 0, 0, 0, 182, 2049, 1, 0, 0, 0, 184, 2069, 1, 0, 0, 0, 186, 2076, 1, 0, 0, 0, 188, 2079, 1, 0, 0, 0, 190, 2092, 1, 0, 0, 0, 192, 2098, 1, 0, 0, 0, 194, 2104, 1, 0, 0, 0, 196, 2108, 1, 0, 0, 0, 198, 2265, 1, 0, 0, 0, 200, 2267, 1, 0, 0, 0, 202, 2323, 1, 0, 0, 0, 204, 2334, 1, 0, 0, 0, 206, 2341, 1, 0, 0, 0, 208, 2349, 1, 0, 0, 0, 210, 2376, 1, 0, 0, 0, 212, 2382, 1, 0, 0, 0, 214, 2387, 1, 0, 0, 0, 216, 2416, 1, 0, 0, 0, 218, 2418, 1, 0, 0, 0, 220, 2438, 1, 0, 0, 0, 222, 2443, 1, 0, 0, 0, 224, 2468, 1, 0, 0, 0, 226, 2477, 1, 0, 0, 0, 228, 2492, 1, 0, 0, 0, 230, 2499, 1, 0, 0, 0, 232, 2519, 1, 0, 0, 0, 234, 2521, 1, 0, 0, 0, 236, 2592, 1, 0, 0, 0, 238, 2617, 1, 0, 0, 0, 240, 2661, 1, 0, 0, 0, 242, 2670, 1, 0, 0, 0, 244, 2710, 1, 0, 0, 0, 246, 2715, 1, 0, 0, 0, 248, 2755, 1, 0, 0, 0, 250, 2757, 1, 0, 0, 0, 252, 2763, 1, 0, 0, 0, 254, 2771, 1, 0, 0, 0, 256, 2791, 1, 0, 0, 0, 258, 2858, 1, 0, 0, 0, 260, 2860, 1, 0, 0, 0, 262, 2870, 1, 0, 0, 0, 264, 2872, 1, 0, 0, 0, 266, 2876, 1, 0, 0, 0, 268, 2882, 1, 0, 0, 0, 270, 2902, 1, 0, 0, 0, 272, 2920, 1, 0, 0, 0, 274, 2934, 1, 0, 0, 0, 276, 2936, 1, 0, 0, 0, 278, 2939, 1, 0, 0, 0, 280, 2941, 1, 0, 0, 0, 282, 2958, 1, 0, 0, 0, 284, 2960, 1, 0, 0, 0, 286, 2973, 1, 0, 0, 0, 288, 2980, 1, 0, 0, 0, 290, 2991, 1, 0, 0, 0, 292, 2998, 1, 0, 0, 0, 294, 3009, 1, 0, 0, 0, 296, 3059, 1, 0, 0, 0, 298, 3151, 1, 0, 0, 0, 300, 3158, 1, 0, 0, 0, 302, 3161, 1, 0, 0, 0, 304, 3171, 1, 0, 0, 0, 306, 3344, 1, 0, 0, 0, 308, 3354, 1, 0, 0, 0, 310, 3365, 1, 0, 0, 0, 312, 3373, 1, 0, 0, 0, 314, 3381, 1, 0, 0, 0, 316, 3389, 1, 0, 0, 0, 318, 3397, 1, 0, 0, 0, 320, 3405, 1, 0, 0, 0, 322, 3414, 1, 0, 0, 0, 324, 3422, 1, 0, 0, 0, 326, 3433, 1, 0, 0, 0, 328, 3440, 1, 0, 0, 0, 330, 3452, 1, 0, 0, 0, 332, 3479, 1, 0, 0, 0, 334, 3481, 1, 0, 0, 0, 336, 3498, 1, 0, 0, 0, 338, 3503, 1, 0, 0, 0, 340, 3520, 1, 0, 0, 0, 342, 3522, 1, 0, 0, 0, 344, 3527, 1, 0, 0, 0, 346, 3537, 1, 0, 0, 0, 348, 3561, 1, 0, 0, 0, 350, 3566, 1, 0, 0, 0, 352, 3582, 1, 0, 0, 0, 354, 3584, 1, 0, 0, 0, 356, 3608, 1, 0, 0, 0, 358, 3610, 1, 0, 0, 0, 360, 3615, 1, 0, 0, 0, 362, 3628, 1, 0, 0, 0, 364, 365, 7, 0, 0, 0, 365, 1, 1, 0, 0, 0, 366, 367, 5, 288, 0, 0, 367, 383, 6, 1, -1, 0, 368, 369, 3, 4, 2, 0, 369, 370, 6, 1, -1, 0, 370, 371, 5, 265, 0, 0, 371, 373, 1, 0, 0, 0, 372, 368, 1, 0, 0, 0, 373, 376, 1, 0, 0, 0, 374, 372, 1, 0, 0, 0, 374, 375, 1, 0, 0, 0, 375, 377, 1, 0, 0, 0, 376, 374, 1, 0, 0, 0, 377, 378, 3, 4, 2, 0, 378, 379, 6, 1, -1, 0, 379, 383, 1, 0, 0, 0, 380, 381, 5, 264, 0, 0, 381, 383, 6, 1, -1, 0, 382, 366, 1, 0, 0, 0, 382, 374, 1, 0, 0, 0, 382, 380, 1, 0, 0, 0, 383, 3, 1, 0, 0, 0, 384, 385, 7, 1, 0, 0, 385, 5, 1, 0, 0, 0, 386, 387, 5, 263, 0, 0, 387, 388, 6, 3, -1, 0, 388, 390, 5, 266, 0, 0, 389, 386, 1, 0, 0, 0, 390, 393, 1, 0, 0, 0, 391, 389, 1, 0, 0, 0, 391, 392, 1, 0, 0, 0, 392, 394, 1, 0, 0, 0, 393, 391, 1, 0, 0, 0, 394, 395, 5, 263, 0, 0, 395, 396, 6, 3, -1, 0, 396, 7, 1, 0, 0, 0, 397, 399, 3, 10, 5, 0, 398, 397, 1, 0, 0, 0, 399, 402, 1, 0, 0, 0, 400, 398, 1, 0, 0, 0, 400, 401, 1, 0, 0, 0, 401, 9, 1, 0, 0, 0, 402, 400, 1, 0, 0, 0, 403, 404, 3, 74, 37, 0, 404, 405, 5, 17, 0, 0, 405, 406, 3, 82, 41, 0, 406, 407, 5, 18, 0, 0, 407, 490, 1, 0, 0, 0, 408, 409, 3, 72, 36, 0, 409, 410, 5, 17, 0, 0, 410, 411, 3, 8, 4, 0, 411, 412, 5, 18, 0, 0, 412, 490, 1, 0, 0, 0, 413, 414, 3, 234, 117, 0, 414, 415, 5, 17, 0, 0, 415, 416, 3, 246, 123, 0, 416, 417, 5, 18, 0, 0, 417, 490, 1, 0, 0, 0, 418, 490, 3, 200, 100, 0, 419, 420, 6, 5, -1, 0, 420, 421, 3, 284, 142, 0, 421, 422, 6, 5, -1, 0, 422, 490, 1, 0, 0, 0, 423, 424, 6, 5, -1, 0, 424, 425, 3, 70, 35, 0, 425, 426, 6, 5, -1, 0, 426, 490, 1, 0, 0, 0, 427, 428, 6, 5, -1, 0, 428, 429, 3, 66, 33, 0, 429, 430, 6, 5, -1, 0, 430, 490, 1, 0, 0, 0, 431, 432, 6, 5, -1, 0, 432, 433, 3, 88, 44, 0, 433, 434, 6, 5, -1, 0, 434, 490, 1, 0, 0, 0, 435, 436, 6, 5, -1, 0, 436, 437, 3, 90, 45, 0, 437, 438, 6, 5, -1, 0, 438, 490, 1, 0, 0, 0, 439, 440, 6, 5, -1, 0, 440, 441, 3, 22, 11, 0, 441, 442, 6, 5, -1, 0, 442, 490, 1, 0, 0, 0, 443, 444, 6, 5, -1, 0, 444, 445, 3, 334, 167, 0, 445, 446, 6, 5, -1, 0, 446, 490, 1, 0, 0, 0, 447, 448, 6, 5, -1, 0, 448, 449, 3, 342, 171, 0, 449, 450, 6, 5, -1, 0, 450, 490, 1, 0, 0, 0, 451, 452, 6, 5, -1, 0, 452, 453, 3, 354, 177, 0, 453, 454, 6, 5, -1, 0, 454, 490, 1, 0, 0, 0, 455, 456, 6, 5, -1, 0, 456, 457, 3, 64, 32, 0, 457, 458, 6, 5, -1, 0, 458, 490, 1, 0, 0, 0, 459, 460, 6, 5, -1, 0, 460, 461, 3, 152, 76, 0, 461, 462, 6, 5, -1, 0, 462, 490, 1, 0, 0, 0, 463, 464, 3, 330, 165, 0, 464, 465, 6, 5, -1, 0, 465, 490, 1, 0, 0, 0, 466, 467, 6, 5, -1, 0, 467, 490, 3, 12, 6, 0, 468, 469, 6, 5, -1, 0, 469, 490, 3, 14, 7, 0, 470, 471, 6, 5, -1, 0, 471, 490, 3, 16, 8, 0, 472, 473, 6, 5, -1, 0, 473, 490, 3, 18, 9, 0, 474, 475, 6, 5, -1, 0, 475, 490, 3, 20, 10, 0, 476, 477, 6, 5, -1, 0, 477, 478, 3, 26, 13, 0, 478, 479, 6, 5, -1, 0, 479, 490, 1, 0, 0, 0, 480, 481, 6, 5, -1, 0, 481, 482, 3, 42, 21, 0, 482, 483, 6, 5, -1, 0, 483, 490, 1, 0, 0, 0, 484, 485, 6, 5, -1, 0, 485, 490, 3, 40, 20, 0, 486, 490, 3, 30, 15, 0, 487, 488, 6, 5, -1, 0, 488, 490, 3, 24, 12, 0, 489, 403, 1, 0, 0, 0, 489, 408, 1, 0, 0, 0, 489, 413, 1, 0, 0, 0, 489, 418, 1, 0, 0, 0, 489, 419, 1, 0, 0, 0, 489, 423, 1, 0, 0, 0, 489, 427, 1, 0, 0, 0, 489, 431, 1, 0, 0, 0, 489, 435, 1, 0, 0, 0, 489, 439, 1, 0, 0, 0, 489, 443, 1, 0, 0, 0, 489, 447, 1, 0, 0, 0, 489, 451, 1, 0, 0, 0, 489, 455, 1, 0, 0, 0, 489, 459, 1, 0, 0, 0, 489, 463, 1, 0, 0, 0, 489, 466, 1, 0, 0, 0, 489, 468, 1, 0, 0, 0, 489, 470, 1, 0, 0, 0, 489, 472, 1, 0, 0, 0, 489, 474, 1, 0, 0, 0, 489, 476, 1, 0, 0, 0, 489, 480, 1, 0, 0, 0, 489, 484, 1, 0, 0, 0, 489, 486, 1, 0, 0, 0, 489, 487, 1, 0, 0, 0, 490, 11, 1, 0, 0, 0, 491, 492, 5, 19, 0, 0, 492, 493, 3, 32, 16, 0, 493, 494, 6, 6, -1, 0, 494, 13, 1, 0, 0, 0, 495, 496, 5, 20, 0, 0, 496, 497, 3, 32, 16, 0, 497, 498, 6, 7, -1, 0, 498, 15, 1, 0, 0, 0, 499, 500, 5, 21, 0, 0, 500, 501, 5, 22, 0, 0, 501, 502, 3, 32, 16, 0, 502, 503, 6, 8, -1, 0, 503, 17, 1, 0, 0, 0, 504, 505, 5, 23, 0, 0, 505, 506, 3, 34, 17, 0, 506, 507, 6, 9, -1, 0, 507, 19, 1, 0, 0, 0, 508, 509, 5, 24, 0, 0, 509, 510, 3, 34, 17, 0, 510, 511, 6, 10, -1, 0, 511, 21, 1, 0, 0, 0, 512, 513, 5, 25, 0, 0, 513, 514, 3, 98, 49, 0, 514, 515, 3, 2, 1, 0, 515, 516, 5, 17, 0, 0, 516, 517, 3, 120, 60, 0, 517, 518, 5, 18, 0, 0, 518, 23, 1, 0, 0, 0, 519, 520, 5, 26, 0, 0, 520, 25, 1, 0, 0, 0, 521, 522, 5, 27, 0, 0, 522, 523, 3, 28, 14, 0, 523, 524, 6, 13, -1, 0, 524, 540, 1, 0, 0, 0, 525, 526, 5, 27, 0, 0, 526, 527, 3, 28, 14, 0, 527, 528, 5, 28, 0, 0, 528, 529, 3, 28, 14, 0, 529, 530, 6, 13, -1, 0, 530, 540, 1, 0, 0, 0, 531, 532, 5, 27, 0, 0, 532, 533, 3, 28, 14, 0, 533, 534, 5, 28, 0, 0, 534, 535, 3, 28, 14, 0, 535, 536, 5, 28, 0, 0, 536, 537, 3, 28, 14, 0, 537, 538, 6, 13, -1, 0, 538, 540, 1, 0, 0, 0, 539, 521, 1, 0, 0, 0, 539, 525, 1, 0, 0, 0, 539, 531, 1, 0, 0, 0, 540, 27, 1, 0, 0, 0, 541, 542, 7, 2, 0, 0, 542, 29, 1, 0, 0, 0, 543, 544, 5, 29, 0, 0, 544, 550, 5, 17, 0, 0, 545, 546, 3, 116, 58, 0, 546, 547, 6, 15, -1, 0, 547, 549, 1, 0, 0, 0, 548, 545, 1, 0, 0, 0, 549, 552, 1, 0, 0, 0, 550, 548, 1, 0, 0, 0, 550, 551, 1, 0, 0, 0, 551, 553, 1, 0, 0, 0, 552, 550, 1, 0, 0, 0, 553, 554, 5, 18, 0, 0, 554, 31, 1, 0, 0, 0, 555, 556, 5, 173, 0, 0, 556, 33, 1, 0, 0, 0, 557, 558, 7, 3, 0, 0, 558, 35, 1, 0, 0, 0, 559, 560, 5, 175, 0, 0, 560, 581, 6, 18, -1, 0, 561, 562, 3, 32, 16, 0, 562, 563, 5, 265, 0, 0, 563, 564, 6, 18, -1, 0, 564, 581, 1, 0, 0, 0, 565, 566, 3, 32, 16, 0, 566, 567, 6, 18, -1, 0, 567, 581, 1, 0, 0, 0, 568, 569, 5, 188, 0, 0, 569, 570, 5, 30, 0, 0, 570, 571, 3, 32, 16, 0, 571, 572, 5, 31, 0, 0, 572, 573, 6, 18, -1, 0, 573, 581, 1, 0, 0, 0, 574, 575, 5, 189, 0, 0, 575, 576, 5, 30, 0, 0, 576, 577, 3, 34, 17, 0, 577, 578, 5, 31, 0, 0, 578, 579, 6, 18, -1, 0, 579, 581, 1, 0, 0, 0, 580, 559, 1, 0, 0, 0, 580, 561, 1, 0, 0, 0, 580, 565, 1, 0, 0, 0, 580, 568, 1, 0, 0, 0, 580, 574, 1, 0, 0, 0, 581, 37, 1, 0, 0, 0, 582, 585, 3, 32, 16, 0, 583, 585, 5, 262, 0, 0, 584, 582, 1, 0, 0, 0, 584, 583, 1, 0, 0, 0, 585, 39, 1, 0, 0, 0, 586, 587, 5, 267, 0, 0, 587, 603, 5, 289, 0, 0, 588, 589, 5, 267, 0, 0, 589, 590, 5, 289, 0, 0, 590, 603, 5, 263, 0, 0, 591, 592, 5, 268, 0, 0, 592, 603, 5, 289, 0, 0, 593, 594, 5, 269, 0, 0, 594, 603, 5, 289, 0, 0, 595, 596, 5, 270, 0, 0, 596, 603, 5, 289, 0, 0, 597, 603, 5, 271, 0, 0, 598, 603, 5, 272, 0, 0, 599, 600, 5, 273, 0, 0, 600, 603, 5, 263, 0, 0, 601, 603, 5, 32, 0, 0, 602, 586, 1, 0, 0, 0, 602, 588, 1, 0, 0, 0, 602, 591, 1, 0, 0, 0, 602, 593, 1, 0, 0, 0, 602, 595, 1, 0, 0, 0, 602, 597, 1, 0, 0, 0, 602, 598, 1, 0, 0, 0, 602, 599, 1, 0, 0, 0, 602, 601, 1, 0, 0, 0, 603, 41, 1, 0, 0, 0, 604, 605, 5, 33, 0, 0, 605, 606, 3, 138, 69, 0, 606, 607, 5, 34, 0, 0, 607, 608, 3, 2, 1, 0, 608, 630, 1, 0, 0, 0, 609, 610, 5, 33, 0, 0, 610, 611, 3, 116, 58, 0, 611, 612, 5, 34, 0, 0, 612, 613, 3, 2, 1, 0, 613, 630, 1, 0, 0, 0, 614, 615, 5, 33, 0, 0, 615, 616, 3, 176, 88, 0, 616, 617, 5, 34, 0, 0, 617, 618, 3, 2, 1, 0, 618, 630, 1, 0, 0, 0, 619, 620, 5, 33, 0, 0, 620, 621, 3, 44, 22, 0, 621, 622, 5, 34, 0, 0, 622, 623, 3, 2, 1, 0, 623, 630, 1, 0, 0, 0, 624, 625, 5, 33, 0, 0, 625, 626, 3, 46, 23, 0, 626, 627, 5, 34, 0, 0, 627, 628, 3, 2, 1, 0, 628, 630, 1, 0, 0, 0, 629, 604, 1, 0, 0, 0, 629, 609, 1, 0, 0, 0, 629, 614, 1, 0, 0, 0, 629, 619, 1, 0, 0, 0, 629, 624, 1, 0, 0, 0, 630, 43, 1, 0, 0, 0, 631, 632, 5, 35, 0, 0, 632, 633, 3, 48, 24, 0, 633, 634, 6, 22, -1, 0, 634, 658, 1, 0, 0, 0, 635, 636, 5, 35, 0, 0, 636, 637, 3, 48, 24, 0, 637, 638, 5, 36, 0, 0, 638, 639, 3, 6, 3, 0, 639, 640, 6, 22, -1, 0, 640, 658, 1, 0, 0, 0, 641, 642, 5, 35, 0, 0, 642, 643, 3, 48, 24, 0, 643, 644, 5, 36, 0, 0, 644, 645, 5, 17, 0, 0, 645, 646, 3, 52, 26, 0, 646, 647, 5, 18, 0, 0, 647, 648, 6, 22, -1, 0, 648, 658, 1, 0, 0, 0, 649, 650, 5, 35, 0, 0, 650, 651, 3, 48, 24, 0, 651, 652, 5, 36, 0, 0, 652, 653, 5, 30, 0, 0, 653, 654, 3, 300, 150, 0, 654, 655, 5, 31, 0, 0, 655, 656, 6, 22, -1, 0, 656, 658, 1, 0, 0, 0, 657, 631, 1, 0, 0, 0, 657, 635, 1, 0, 0, 0, 657, 641, 1, 0, 0, 0, 657, 649, 1, 0, 0, 0, 658, 45, 1, 0, 0, 0, 659, 660, 5, 35, 0, 0, 660, 661, 5, 30, 0, 0, 661, 662, 3, 50, 25, 0, 662, 663, 5, 31, 0, 0, 663, 664, 3, 48, 24, 0, 664, 665, 6, 23, -1, 0, 665, 698, 1, 0, 0, 0, 666, 667, 5, 35, 0, 0, 667, 668, 5, 30, 0, 0, 668, 669, 3, 50, 25, 0, 669, 670, 5, 31, 0, 0, 670, 671, 3, 48, 24, 0, 671, 672, 5, 36, 0, 0, 672, 673, 3, 6, 3, 0, 673, 674, 6, 23, -1, 0, 674, 698, 1, 0, 0, 0, 675, 676, 5, 35, 0, 0, 676, 677, 5, 30, 0, 0, 677, 678, 3, 50, 25, 0, 678, 679, 5, 31, 0, 0, 679, 680, 3, 48, 24, 0, 680, 681, 5, 36, 0, 0, 681, 682, 5, 17, 0, 0, 682, 683, 3, 52, 26, 0, 683, 684, 5, 18, 0, 0, 684, 685, 6, 23, -1, 0, 685, 698, 1, 0, 0, 0, 686, 687, 5, 35, 0, 0, 687, 688, 5, 30, 0, 0, 688, 689, 3, 50, 25, 0, 689, 690, 5, 31, 0, 0, 690, 691, 3, 48, 24, 0, 691, 692, 5, 36, 0, 0, 692, 693, 5, 30, 0, 0, 693, 694, 3, 300, 150, 0, 694, 695, 5, 31, 0, 0, 695, 696, 6, 23, -1, 0, 696, 698, 1, 0, 0, 0, 697, 659, 1, 0, 0, 0, 697, 666, 1, 0, 0, 0, 697, 675, 1, 0, 0, 0, 697, 686, 1, 0, 0, 0, 698, 47, 1, 0, 0, 0, 699, 700, 3, 168, 84, 0, 700, 701, 6, 24, -1, 0, 701, 49, 1, 0, 0, 0, 702, 703, 3, 124, 62, 0, 703, 704, 6, 25, -1, 0, 704, 709, 1, 0, 0, 0, 705, 706, 3, 176, 88, 0, 706, 707, 6, 25, -1, 0, 707, 709, 1, 0, 0, 0, 708, 702, 1, 0, 0, 0, 708, 705, 1, 0, 0, 0, 709, 51, 1, 0, 0, 0, 710, 711, 3, 54, 27, 0, 711, 712, 3, 56, 28, 0, 712, 713, 6, 26, -1, 0, 713, 53, 1, 0, 0, 0, 714, 715, 3, 306, 153, 0, 715, 716, 6, 27, -1, 0, 716, 719, 1, 0, 0, 0, 717, 719, 3, 40, 20, 0, 718, 714, 1, 0, 0, 0, 718, 717, 1, 0, 0, 0, 719, 722, 1, 0, 0, 0, 720, 718, 1, 0, 0, 0, 720, 721, 1, 0, 0, 0, 721, 55, 1, 0, 0, 0, 722, 720, 1, 0, 0, 0, 723, 724, 3, 58, 29, 0, 724, 725, 3, 60, 30, 0, 725, 726, 3, 2, 1, 0, 726, 727, 5, 36, 0, 0, 727, 728, 3, 306, 153, 0, 728, 729, 6, 28, -1, 0, 729, 732, 1, 0, 0, 0, 730, 732, 3, 40, 20, 0, 731, 723, 1, 0, 0, 0, 731, 730, 1, 0, 0, 0, 732, 735, 1, 0, 0, 0, 733, 731, 1, 0, 0, 0, 733, 734, 1, 0, 0, 0, 734, 57, 1, 0, 0, 0, 735, 733, 1, 0, 0, 0, 736, 737, 7, 4, 0, 0, 737, 738, 6, 29, -1, 0, 738, 59, 1, 0, 0, 0, 739, 741, 3, 62, 31, 0, 740, 742, 5, 261, 0, 0, 741, 740, 1, 0, 0, 0, 741, 742, 1, 0, 0, 0, 742, 743, 1, 0, 0, 0, 743, 744, 6, 30, -1, 0, 744, 61, 1, 0, 0, 0, 745, 746, 3, 144, 72, 0, 746, 747, 6, 31, -1, 0, 747, 764, 1, 0, 0, 0, 748, 749, 3, 2, 1, 0, 749, 750, 6, 31, -1, 0, 750, 764, 1, 0, 0, 0, 751, 752, 5, 196, 0, 0, 752, 764, 6, 31, -1, 0, 753, 754, 5, 197, 0, 0, 754, 764, 6, 31, -1, 0, 755, 756, 5, 202, 0, 0, 756, 757, 5, 39, 0, 0, 757, 758, 5, 264, 0, 0, 758, 764, 6, 31, -1, 0, 759, 760, 5, 202, 0, 0, 760, 761, 3, 116, 58, 0, 761, 762, 6, 31, -1, 0, 762, 764, 1, 0, 0, 0, 763, 745, 1, 0, 0, 0, 763, 748, 1, 0, 0, 0, 763, 751, 1, 0, 0, 0, 763, 753, 1, 0, 0, 0, 763, 755, 1, 0, 0, 0, 763, 759, 1, 0, 0, 0, 764, 63, 1, 0, 0, 0, 765, 766, 5, 198, 0, 0, 766, 767, 5, 40, 0, 0, 767, 768, 3, 2, 1, 0, 768, 769, 6, 32, -1, 0, 769, 777, 1, 0, 0, 0, 770, 771, 5, 198, 0, 0, 771, 772, 3, 2, 1, 0, 772, 773, 6, 32, -1, 0, 773, 777, 1, 0, 0, 0, 774, 775, 5, 198, 0, 0, 775, 777, 6, 32, -1, 0, 776, 765, 1, 0, 0, 0, 776, 770, 1, 0, 0, 0, 776, 774, 1, 0, 0, 0, 777, 65, 1, 0, 0, 0, 778, 779, 5, 41, 0, 0, 779, 780, 5, 42, 0, 0, 780, 781, 3, 32, 16, 0, 781, 782, 5, 43, 0, 0, 782, 783, 3, 68, 34, 0, 783, 784, 5, 44, 0, 0, 784, 785, 3, 0, 0, 0, 785, 67, 1, 0, 0, 0, 786, 799, 6, 34, -1, 0, 787, 788, 10, 5, 0, 0, 788, 798, 5, 186, 0, 0, 789, 790, 10, 4, 0, 0, 790, 798, 5, 187, 0, 0, 791, 792, 10, 3, 0, 0, 792, 798, 5, 45, 0, 0, 793, 794, 10, 2, 0, 0, 794, 798, 5, 46, 0, 0, 795, 796, 10, 1, 0, 0, 796, 798, 5, 47, 0, 0, 797, 787, 1, 0, 0, 0, 797, 789, 1, 0, 0, 0, 797, 791, 1, 0, 0, 0, 797, 793, 1, 0, 0, 0, 797, 795, 1, 0, 0, 0, 798, 801, 1, 0, 0, 0, 799, 797, 1, 0, 0, 0, 799, 800, 1, 0, 0, 0, 800, 69, 1, 0, 0, 0, 801, 799, 1, 0, 0, 0, 802, 803, 5, 48, 0, 0, 803, 804, 5, 36, 0, 0, 804, 805, 5, 30, 0, 0, 805, 806, 3, 300, 150, 0, 806, 807, 5, 31, 0, 0, 807, 71, 1, 0, 0, 0, 808, 809, 5, 49, 0, 0, 809, 810, 3, 2, 1, 0, 810, 811, 6, 36, -1, 0, 811, 73, 1, 0, 0, 0, 812, 818, 5, 50, 0, 0, 813, 814, 3, 76, 38, 0, 814, 815, 6, 37, -1, 0, 815, 817, 1, 0, 0, 0, 816, 813, 1, 0, 0, 0, 817, 820, 1, 0, 0, 0, 818, 816, 1, 0, 0, 0, 818, 819, 1, 0, 0, 0, 819, 821, 1, 0, 0, 0, 820, 818, 1, 0, 0, 0, 821, 822, 3, 2, 1, 0, 822, 823, 3, 182, 91, 0, 823, 824, 3, 78, 39, 0, 824, 825, 3, 80, 40, 0, 825, 826, 6, 37, -1, 0, 826, 75, 1, 0, 0, 0, 827, 828, 5, 51, 0, 0, 828, 892, 6, 38, -1, 0, 829, 830, 5, 52, 0, 0, 830, 892, 6, 38, -1, 0, 831, 832, 5, 199, 0, 0, 832, 892, 6, 38, -1, 0, 833, 834, 5, 202, 0, 0, 834, 892, 6, 38, -1, 0, 835, 836, 5, 221, 0, 0, 836, 892, 6, 38, -1, 0, 837, 838, 5, 53, 0, 0, 838, 892, 6, 38, -1, 0, 839, 840, 5, 54, 0, 0, 840, 892, 6, 38, -1, 0, 841, 842, 5, 55, 0, 0, 842, 892, 6, 38, -1, 0, 843, 844, 5, 56, 0, 0, 844, 892, 6, 38, -1, 0, 845, 846, 5, 244, 0, 0, 846, 892, 6, 38, -1, 0, 847, 848, 5, 15, 0, 0, 848, 892, 6, 38, -1, 0, 849, 850, 5, 224, 0, 0, 850, 892, 6, 38, -1, 0, 851, 852, 5, 57, 0, 0, 852, 892, 6, 38, -1, 0, 853, 854, 5, 58, 0, 0, 854, 892, 6, 38, -1, 0, 855, 856, 5, 59, 0, 0, 856, 892, 6, 38, -1, 0, 857, 858, 5, 60, 0, 0, 858, 892, 6, 38, -1, 0, 859, 860, 5, 61, 0, 0, 860, 892, 6, 38, -1, 0, 861, 862, 5, 62, 0, 0, 862, 863, 5, 51, 0, 0, 863, 892, 6, 38, -1, 0, 864, 865, 5, 62, 0, 0, 865, 866, 5, 52, 0, 0, 866, 892, 6, 38, -1, 0, 867, 868, 5, 62, 0, 0, 868, 869, 5, 63, 0, 0, 869, 892, 6, 38, -1, 0, 870, 871, 5, 62, 0, 0, 871, 872, 5, 64, 0, 0, 872, 892, 6, 38, -1, 0, 873, 874, 5, 62, 0, 0, 874, 875, 5, 65, 0, 0, 875, 892, 6, 38, -1, 0, 876, 877, 5, 62, 0, 0, 877, 878, 5, 66, 0, 0, 878, 892, 6, 38, -1, 0, 879, 880, 5, 67, 0, 0, 880, 892, 6, 38, -1, 0, 881, 882, 5, 68, 0, 0, 882, 892, 6, 38, -1, 0, 883, 884, 5, 69, 0, 0, 884, 892, 6, 38, -1, 0, 885, 886, 5, 70, 0, 0, 886, 887, 5, 30, 0, 0, 887, 888, 3, 32, 16, 0, 888, 889, 5, 31, 0, 0, 889, 890, 6, 38, -1, 0, 890, 892, 1, 0, 0, 0, 891, 827, 1, 0, 0, 0, 891, 829, 1, 0, 0, 0, 891, 831, 1, 0, 0, 0, 891, 833, 1, 0, 0, 0, 891, 835, 1, 0, 0, 0, 891, 837, 1, 0, 0, 0, 891, 839, 1, 0, 0, 0, 891, 841, 1, 0, 0, 0, 891, 843, 1, 0, 0, 0, 891, 845, 1, 0, 0, 0, 891, 847, 1, 0, 0, 0, 891, 849, 1, 0, 0, 0, 891, 851, 1, 0, 0, 0, 891, 853, 1, 0, 0, 0, 891, 855, 1, 0, 0, 0, 891, 857, 1, 0, 0, 0, 891, 859, 1, 0, 0, 0, 891, 861, 1, 0, 0, 0, 891, 864, 1, 0, 0, 0, 891, 867, 1, 0, 0, 0, 891, 870, 1, 0, 0, 0, 891, 873, 1, 0, 0, 0, 891, 876, 1, 0, 0, 0, 891, 879, 1, 0, 0, 0, 891, 881, 1, 0, 0, 0, 891, 883, 1, 0, 0, 0, 891, 885, 1, 0, 0, 0, 892, 77, 1, 0, 0, 0, 893, 899, 1, 0, 0, 0, 894, 895, 5, 71, 0, 0, 895, 896, 3, 124, 62, 0, 896, 897, 6, 39, -1, 0, 897, 899, 1, 0, 0, 0, 898, 893, 1, 0, 0, 0, 898, 894, 1, 0, 0, 0, 899, 79, 1, 0, 0, 0, 900, 906, 1, 0, 0, 0, 901, 902, 5, 72, 0, 0, 902, 903, 3, 84, 42, 0, 903, 904, 6, 40, -1, 0, 904, 906, 1, 0, 0, 0, 905, 900, 1, 0, 0, 0, 905, 901, 1, 0, 0, 0, 906, 81, 1, 0, 0, 0, 907, 909, 3, 198, 99, 0, 908, 907, 1, 0, 0, 0, 909, 912, 1, 0, 0, 0, 910, 908, 1, 0, 0, 0, 910, 911, 1, 0, 0, 0, 911, 83, 1, 0, 0, 0, 912, 910, 1, 0, 0, 0, 913, 914, 3, 124, 62, 0, 914, 915, 6, 42, -1, 0, 915, 916, 5, 28, 0, 0, 916, 918, 1, 0, 0, 0, 917, 913, 1, 0, 0, 0, 918, 921, 1, 0, 0, 0, 919, 917, 1, 0, 0, 0, 919, 920, 1, 0, 0, 0, 920, 922, 1, 0, 0, 0, 921, 919, 1, 0, 0, 0, 922, 923, 3, 124, 62, 0, 923, 924, 6, 42, -1, 0, 924, 85, 1, 0, 0, 0, 925, 926, 7, 5, 0, 0, 926, 87, 1, 0, 0, 0, 927, 928, 3, 86, 43, 0, 928, 930, 3, 32, 16, 0, 929, 931, 7, 2, 0, 0, 930, 929, 1, 0, 0, 0, 930, 931, 1, 0, 0, 0, 931, 932, 1, 0, 0, 0, 932, 933, 6, 44, -1, 0, 933, 979, 1, 0, 0, 0, 934, 935, 3, 86, 43, 0, 935, 936, 3, 32, 16, 0, 936, 937, 5, 75, 0, 0, 937, 939, 3, 32, 16, 0, 938, 940, 7, 2, 0, 0, 939, 938, 1, 0, 0, 0, 939, 940, 1, 0, 0, 0, 940, 941, 1, 0, 0, 0, 941, 942, 6, 44, -1, 0, 942, 979, 1, 0, 0, 0, 943, 944, 3, 86, 43, 0, 944, 945, 3, 32, 16, 0, 945, 946, 5, 75, 0, 0, 946, 947, 3, 32, 16, 0, 947, 948, 5, 28, 0, 0, 948, 950, 3, 32, 16, 0, 949, 951, 7, 2, 0, 0, 950, 949, 1, 0, 0, 0, 950, 951, 1, 0, 0, 0, 951, 952, 1, 0, 0, 0, 952, 953, 6, 44, -1, 0, 953, 979, 1, 0, 0, 0, 954, 955, 3, 86, 43, 0, 955, 956, 3, 32, 16, 0, 956, 957, 5, 28, 0, 0, 957, 958, 3, 32, 16, 0, 958, 959, 5, 75, 0, 0, 959, 961, 3, 32, 16, 0, 960, 962, 7, 2, 0, 0, 961, 960, 1, 0, 0, 0, 961, 962, 1, 0, 0, 0, 962, 963, 1, 0, 0, 0, 963, 964, 6, 44, -1, 0, 964, 979, 1, 0, 0, 0, 965, 966, 3, 86, 43, 0, 966, 967, 3, 32, 16, 0, 967, 968, 5, 28, 0, 0, 968, 969, 3, 32, 16, 0, 969, 970, 5, 75, 0, 0, 970, 971, 3, 32, 16, 0, 971, 972, 5, 28, 0, 0, 972, 974, 3, 32, 16, 0, 973, 975, 7, 2, 0, 0, 974, 973, 1, 0, 0, 0, 974, 975, 1, 0, 0, 0, 975, 976, 1, 0, 0, 0, 976, 977, 6, 44, -1, 0, 977, 979, 1, 0, 0, 0, 978, 927, 1, 0, 0, 0, 978, 934, 1, 0, 0, 0, 978, 943, 1, 0, 0, 0, 978, 954, 1, 0, 0, 0, 978, 965, 1, 0, 0, 0, 979, 89, 1, 0, 0, 0, 980, 984, 5, 21, 0, 0, 981, 983, 3, 92, 46, 0, 982, 981, 1, 0, 0, 0, 983, 986, 1, 0, 0, 0, 984, 982, 1, 0, 0, 0, 984, 985, 1, 0, 0, 0, 985, 987, 1, 0, 0, 0, 986, 984, 1, 0, 0, 0, 987, 988, 3, 2, 1, 0, 988, 989, 3, 94, 47, 0, 989, 990, 5, 180, 0, 0, 990, 991, 5, 36, 0, 0, 991, 992, 5, 30, 0, 0, 992, 993, 3, 300, 150, 0, 993, 994, 5, 31, 0, 0, 994, 995, 3, 94, 47, 0, 995, 1007, 1, 0, 0, 0, 996, 1000, 5, 21, 0, 0, 997, 999, 3, 92, 46, 0, 998, 997, 1, 0, 0, 0, 999, 1002, 1, 0, 0, 0, 1000, 998, 1, 0, 0, 0, 1000, 1001, 1, 0, 0, 0, 1001, 1003, 1, 0, 0, 0, 1002, 1000, 1, 0, 0, 0, 1003, 1004, 3, 2, 1, 0, 1004, 1005, 3, 94, 47, 0, 1005, 1007, 1, 0, 0, 0, 1006, 980, 1, 0, 0, 0, 1006, 996, 1, 0, 0, 0, 1007, 91, 1, 0, 0, 0, 1008, 1009, 5, 76, 0, 0, 1009, 93, 1, 0, 0, 0, 1010, 1013, 1, 0, 0, 0, 1011, 1013, 5, 298, 0, 0, 1012, 1010, 1, 0, 0, 0, 1012, 1011, 1, 0, 0, 0, 1013, 95, 1, 0, 0, 0, 1014, 1015, 7, 6, 0, 0, 1015, 97, 1, 0, 0, 0, 1016, 1018, 3, 96, 48, 0, 1017, 1016, 1, 0, 0, 0, 1018, 1021, 1, 0, 0, 0, 1019, 1017, 1, 0, 0, 0, 1019, 1020, 1, 0, 0, 0, 1020, 99, 1, 0, 0, 0, 1021, 1019, 1, 0, 0, 0, 1022, 1048, 3, 102, 51, 0, 1023, 1024, 5, 280, 0, 0, 1024, 1025, 3, 168, 84, 0, 1025, 1026, 6, 50, -1, 0, 1026, 1048, 1, 0, 0, 0, 1027, 1028, 5, 286, 0, 0, 1028, 1029, 3, 178, 89, 0, 1029, 1030, 6, 50, -1, 0, 1030, 1048, 1, 0, 0, 0, 1031, 1032, 5, 286, 0, 0, 1032, 1033, 3, 174, 87, 0, 1033, 1034, 6, 50, -1, 0, 1034, 1048, 1, 0, 0, 0, 1035, 1036, 5, 284, 0, 0, 1036, 1037, 3, 124, 62, 0, 1037, 1038, 6, 50, -1, 0, 1038, 1048, 1, 0, 0, 0, 1039, 1040, 5, 281, 0, 0, 1040, 1041, 3, 104, 52, 0, 1041, 1042, 6, 50, -1, 0, 1042, 1048, 1, 0, 0, 0, 1043, 1044, 5, 287, 0, 0, 1044, 1045, 3, 50, 25, 0, 1045, 1046, 6, 50, -1, 0, 1046, 1048, 1, 0, 0, 0, 1047, 1022, 1, 0, 0, 0, 1047, 1023, 1, 0, 0, 0, 1047, 1027, 1, 0, 0, 0, 1047, 1031, 1, 0, 0, 0, 1047, 1035, 1, 0, 0, 0, 1047, 1039, 1, 0, 0, 0, 1047, 1043, 1, 0, 0, 0, 1048, 101, 1, 0, 0, 0, 1049, 1050, 5, 275, 0, 0, 1050, 1128, 6, 51, -1, 0, 1051, 1052, 5, 276, 0, 0, 1052, 1053, 3, 32, 16, 0, 1053, 1054, 6, 51, -1, 0, 1054, 1128, 1, 0, 0, 0, 1055, 1056, 5, 276, 0, 0, 1056, 1057, 3, 0, 0, 0, 1057, 1058, 6, 51, -1, 0, 1058, 1128, 1, 0, 0, 0, 1059, 1060, 5, 277, 0, 0, 1060, 1061, 3, 32, 16, 0, 1061, 1062, 6, 51, -1, 0, 1062, 1128, 1, 0, 0, 0, 1063, 1064, 5, 278, 0, 0, 1064, 1065, 3, 34, 17, 0, 1065, 1066, 6, 51, -1, 0, 1066, 1128, 1, 0, 0, 0, 1067, 1068, 5, 279, 0, 0, 1068, 1069, 3, 36, 18, 0, 1069, 1070, 6, 51, -1, 0, 1070, 1128, 1, 0, 0, 0, 1071, 1072, 5, 279, 0, 0, 1072, 1073, 3, 34, 17, 0, 1073, 1074, 6, 51, -1, 0, 1074, 1128, 1, 0, 0, 0, 1075, 1076, 5, 279, 0, 0, 1076, 1077, 5, 30, 0, 0, 1077, 1078, 3, 300, 150, 0, 1078, 1079, 5, 31, 0, 0, 1079, 1080, 6, 51, -1, 0, 1080, 1128, 1, 0, 0, 0, 1081, 1082, 5, 279, 0, 0, 1082, 1083, 5, 84, 0, 0, 1083, 1084, 5, 30, 0, 0, 1084, 1085, 3, 300, 150, 0, 1085, 1086, 5, 31, 0, 0, 1086, 1087, 6, 51, -1, 0, 1087, 1128, 1, 0, 0, 0, 1088, 1089, 5, 282, 0, 0, 1089, 1090, 3, 32, 16, 0, 1090, 1091, 6, 51, -1, 0, 1091, 1128, 1, 0, 0, 0, 1092, 1093, 5, 282, 0, 0, 1093, 1094, 3, 0, 0, 0, 1094, 1095, 6, 51, -1, 0, 1095, 1128, 1, 0, 0, 0, 1096, 1097, 5, 285, 0, 0, 1097, 1098, 3, 6, 3, 0, 1098, 1099, 6, 51, -1, 0, 1099, 1128, 1, 0, 0, 0, 1100, 1101, 5, 285, 0, 0, 1101, 1102, 5, 224, 0, 0, 1102, 1103, 5, 30, 0, 0, 1103, 1104, 3, 6, 3, 0, 1104, 1105, 5, 31, 0, 0, 1105, 1106, 6, 51, -1, 0, 1106, 1128, 1, 0, 0, 0, 1107, 1108, 5, 285, 0, 0, 1108, 1109, 5, 84, 0, 0, 1109, 1110, 5, 30, 0, 0, 1110, 1111, 3, 300, 150, 0, 1111, 1112, 5, 31, 0, 0, 1112, 1113, 6, 51, -1, 0, 1113, 1128, 1, 0, 0, 0, 1114, 1115, 5, 287, 0, 0, 1115, 1116, 3, 32, 16, 0, 1116, 1117, 6, 51, -1, 0, 1117, 1128, 1, 0, 0, 0, 1118, 1119, 5, 283, 0, 0, 1119, 1125, 6, 51, -1, 0, 1120, 1121, 5, 30, 0, 0, 1121, 1122, 3, 106, 53, 0, 1122, 1123, 5, 31, 0, 0, 1123, 1126, 1, 0, 0, 0, 1124, 1126, 5, 85, 0, 0, 1125, 1120, 1, 0, 0, 0, 1125, 1124, 1, 0, 0, 0, 1126, 1128, 1, 0, 0, 0, 1127, 1049, 1, 0, 0, 0, 1127, 1051, 1, 0, 0, 0, 1127, 1055, 1, 0, 0, 0, 1127, 1059, 1, 0, 0, 0, 1127, 1063, 1, 0, 0, 0, 1127, 1067, 1, 0, 0, 0, 1127, 1071, 1, 0, 0, 0, 1127, 1075, 1, 0, 0, 0, 1127, 1081, 1, 0, 0, 0, 1127, 1088, 1, 0, 0, 0, 1127, 1092, 1, 0, 0, 0, 1127, 1096, 1, 0, 0, 0, 1127, 1100, 1, 0, 0, 0, 1127, 1107, 1, 0, 0, 0, 1127, 1114, 1, 0, 0, 0, 1127, 1118, 1, 0, 0, 0, 1128, 103, 1, 0, 0, 0, 1129, 1130, 3, 170, 85, 0, 1130, 1131, 3, 138, 69, 0, 1131, 1132, 3, 112, 56, 0, 1132, 1133, 6, 52, -1, 0, 1133, 105, 1, 0, 0, 0, 1134, 1159, 1, 0, 0, 0, 1135, 1136, 3, 0, 0, 0, 1136, 1137, 6, 53, -1, 0, 1137, 1142, 1, 0, 0, 0, 1138, 1139, 3, 32, 16, 0, 1139, 1140, 6, 53, -1, 0, 1140, 1142, 1, 0, 0, 0, 1141, 1135, 1, 0, 0, 0, 1141, 1138, 1, 0, 0, 0, 1142, 1143, 1, 0, 0, 0, 1143, 1144, 5, 28, 0, 0, 1144, 1146, 1, 0, 0, 0, 1145, 1141, 1, 0, 0, 0, 1146, 1149, 1, 0, 0, 0, 1147, 1145, 1, 0, 0, 0, 1147, 1148, 1, 0, 0, 0, 1148, 1156, 1, 0, 0, 0, 1149, 1147, 1, 0, 0, 0, 1150, 1151, 3, 0, 0, 0, 1151, 1152, 6, 53, -1, 0, 1152, 1157, 1, 0, 0, 0, 1153, 1154, 3, 32, 16, 0, 1154, 1155, 6, 53, -1, 0, 1155, 1157, 1, 0, 0, 0, 1156, 1150, 1, 0, 0, 0, 1156, 1153, 1, 0, 0, 0, 1157, 1159, 1, 0, 0, 0, 1158, 1134, 1, 0, 0, 0, 1158, 1147, 1, 0, 0, 0, 1159, 107, 1, 0, 0, 0, 1160, 1167, 5, 86, 0, 0, 1161, 1162, 3, 138, 69, 0, 1162, 1163, 6, 54, -1, 0, 1163, 1164, 5, 28, 0, 0, 1164, 1166, 1, 0, 0, 0, 1165, 1161, 1, 0, 0, 0, 1166, 1169, 1, 0, 0, 0, 1167, 1165, 1, 0, 0, 0, 1167, 1168, 1, 0, 0, 0, 1168, 1170, 1, 0, 0, 0, 1169, 1167, 1, 0, 0, 0, 1170, 1171, 3, 138, 69, 0, 1171, 1172, 6, 54, -1, 0, 1172, 1173, 5, 87, 0, 0, 1173, 109, 1, 0, 0, 0, 1174, 1181, 5, 42, 0, 0, 1175, 1176, 3, 146, 73, 0, 1176, 1177, 6, 55, -1, 0, 1177, 1178, 5, 28, 0, 0, 1178, 1180, 1, 0, 0, 0, 1179, 1175, 1, 0, 0, 0, 1180, 1183, 1, 0, 0, 0, 1181, 1179, 1, 0, 0, 0, 1181, 1182, 1, 0, 0, 0, 1182, 1184, 1, 0, 0, 0, 1183, 1181, 1, 0, 0, 0, 1184, 1185, 3, 146, 73, 0, 1185, 1186, 6, 55, -1, 0, 1186, 1187, 5, 43, 0, 0, 1187, 111, 1, 0, 0, 0, 1188, 1195, 5, 30, 0, 0, 1189, 1190, 3, 114, 57, 0, 1190, 1191, 6, 56, -1, 0, 1191, 1192, 5, 28, 0, 0, 1192, 1194, 1, 0, 0, 0, 1193, 1189, 1, 0, 0, 0, 1194, 1197, 1, 0, 0, 0, 1195, 1193, 1, 0, 0, 0, 1195, 1196, 1, 0, 0, 0, 1196, 1198, 1, 0, 0, 0, 1197, 1195, 1, 0, 0, 0, 1198, 1199, 3, 114, 57, 0, 1199, 1200, 6, 56, -1, 0, 1200, 1201, 5, 31, 0, 0, 1201, 1204, 1, 0, 0, 0, 1202, 1204, 5, 85, 0, 0, 1203, 1188, 1, 0, 0, 0, 1203, 1202, 1, 0, 0, 0, 1204, 113, 1, 0, 0, 0, 1205, 1206, 5, 177, 0, 0, 1206, 1216, 6, 57, -1, 0, 1207, 1208, 3, 230, 115, 0, 1208, 1209, 3, 138, 69, 0, 1209, 1211, 3, 226, 113, 0, 1210, 1212, 3, 0, 0, 0, 1211, 1210, 1, 0, 0, 0, 1211, 1212, 1, 0, 0, 0, 1212, 1213, 1, 0, 0, 0, 1213, 1214, 6, 57, -1, 0, 1214, 1216, 1, 0, 0, 0, 1215, 1205, 1, 0, 0, 0, 1215, 1207, 1, 0, 0, 0, 1216, 115, 1, 0, 0, 0, 1217, 1218, 5, 42, 0, 0, 1218, 1219, 3, 2, 1, 0, 1219, 1220, 5, 43, 0, 0, 1220, 1221, 3, 118, 59, 0, 1221, 1222, 6, 58, -1, 0, 1222, 1255, 1, 0, 0, 0, 1223, 1224, 5, 42, 0, 0, 1224, 1225, 3, 174, 87, 0, 1225, 1226, 5, 43, 0, 0, 1226, 1227, 3, 118, 59, 0, 1227, 1228, 6, 58, -1, 0, 1228, 1255, 1, 0, 0, 0, 1229, 1230, 5, 42, 0, 0, 1230, 1231, 5, 262, 0, 0, 1231, 1232, 5, 43, 0, 0, 1232, 1233, 3, 118, 59, 0, 1233, 1234, 6, 58, -1, 0, 1234, 1255, 1, 0, 0, 0, 1235, 1236, 5, 42, 0, 0, 1236, 1237, 5, 198, 0, 0, 1237, 1238, 3, 2, 1, 0, 1238, 1239, 5, 43, 0, 0, 1239, 1240, 3, 118, 59, 0, 1240, 1241, 6, 58, -1, 0, 1241, 1255, 1, 0, 0, 0, 1242, 1243, 3, 118, 59, 0, 1243, 1244, 6, 58, -1, 0, 1244, 1255, 1, 0, 0, 0, 1245, 1246, 3, 174, 87, 0, 1246, 1247, 6, 58, -1, 0, 1247, 1255, 1, 0, 0, 0, 1248, 1249, 5, 257, 0, 0, 1249, 1255, 6, 58, -1, 0, 1250, 1251, 5, 258, 0, 0, 1251, 1255, 6, 58, -1, 0, 1252, 1253, 5, 259, 0, 0, 1253, 1255, 6, 58, -1, 0, 1254, 1217, 1, 0, 0, 0, 1254, 1223, 1, 0, 0, 0, 1254, 1229, 1, 0, 0, 0, 1254, 1235, 1, 0, 0, 0, 1254, 1242, 1, 0, 0, 0, 1254, 1245, 1, 0, 0, 0, 1254, 1248, 1, 0, 0, 0, 1254, 1250, 1, 0, 0, 0, 1254, 1252, 1, 0, 0, 0, 1255, 117, 1, 0, 0, 0, 1256, 1257, 3, 2, 1, 0, 1257, 1258, 6, 59, -1, 0, 1258, 1259, 5, 88, 0, 0, 1259, 1261, 1, 0, 0, 0, 1260, 1256, 1, 0, 0, 0, 1261, 1264, 1, 0, 0, 0, 1262, 1260, 1, 0, 0, 0, 1262, 1263, 1, 0, 0, 0, 1263, 1265, 1, 0, 0, 0, 1264, 1262, 1, 0, 0, 0, 1265, 1266, 3, 2, 1, 0, 1266, 1267, 6, 59, -1, 0, 1267, 119, 1, 0, 0, 0, 1268, 1270, 3, 122, 61, 0, 1269, 1268, 1, 0, 0, 0, 1270, 1273, 1, 0, 0, 0, 1271, 1269, 1, 0, 0, 0, 1271, 1272, 1, 0, 0, 0, 1272, 121, 1, 0, 0, 0, 1273, 1271, 1, 0, 0, 0, 1274, 1275, 5, 180, 0, 0, 1275, 1276, 5, 89, 0, 0, 1276, 1280, 3, 32, 16, 0, 1277, 1280, 3, 152, 76, 0, 1278, 1280, 3, 332, 166, 0, 1279, 1274, 1, 0, 0, 0, 1279, 1277, 1, 0, 0, 0, 1279, 1278, 1, 0, 0, 0, 1280, 123, 1, 0, 0, 0, 1281, 1282, 3, 116, 58, 0, 1282, 1283, 6, 62, -1, 0, 1283, 1299, 1, 0, 0, 0, 1284, 1285, 5, 42, 0, 0, 1285, 1286, 3, 2, 1, 0, 1286, 1287, 5, 43, 0, 0, 1287, 1288, 6, 62, -1, 0, 1288, 1299, 1, 0, 0, 0, 1289, 1290, 5, 42, 0, 0, 1290, 1291, 5, 198, 0, 0, 1291, 1292, 3, 2, 1, 0, 1292, 1293, 5, 43, 0, 0, 1293, 1294, 6, 62, -1, 0, 1294, 1299, 1, 0, 0, 0, 1295, 1296, 3, 138, 69, 0, 1296, 1297, 6, 62, -1, 0, 1297, 1299, 1, 0, 0, 0, 1298, 1281, 1, 0, 0, 0, 1298, 1284, 1, 0, 0, 0, 1298, 1289, 1, 0, 0, 0, 1298, 1295, 1, 0, 0, 0, 1299, 125, 1, 0, 0, 0, 1300, 1312, 1, 0, 0, 0, 1301, 1302, 3, 130, 65, 0, 1302, 1308, 6, 63, -1, 0, 1303, 1304, 3, 128, 64, 0, 1304, 1305, 6, 63, -1, 0, 1305, 1307, 1, 0, 0, 0, 1306, 1303, 1, 0, 0, 0, 1307, 1310, 1, 0, 0, 0, 1308, 1306, 1, 0, 0, 0, 1308, 1309, 1, 0, 0, 0, 1309, 1312, 1, 0, 0, 0, 1310, 1308, 1, 0, 0, 0, 1311, 1300, 1, 0, 0, 0, 1311, 1301, 1, 0, 0, 0, 1312, 127, 1, 0, 0, 0, 1313, 1314, 5, 262, 0, 0, 1314, 1336, 6, 64, -1, 0, 1315, 1316, 5, 261, 0, 0, 1316, 1336, 6, 64, -1, 0, 1317, 1318, 5, 42, 0, 0, 1318, 1319, 3, 32, 16, 0, 1319, 1320, 5, 43, 0, 0, 1320, 1321, 6, 64, -1, 0, 1321, 1336, 1, 0, 0, 0, 1322, 1323, 5, 42, 0, 0, 1323, 1324, 3, 32, 16, 0, 1324, 1325, 5, 266, 0, 0, 1325, 1326, 3, 32, 16, 0, 1326, 1327, 5, 43, 0, 0, 1327, 1328, 6, 64, -1, 0, 1328, 1336, 1, 0, 0, 0, 1329, 1330, 5, 42, 0, 0, 1330, 1331, 5, 266, 0, 0, 1331, 1332, 3, 32, 16, 0, 1332, 1333, 5, 43, 0, 0, 1333, 1334, 6, 64, -1, 0, 1334, 1336, 1, 0, 0, 0, 1335, 1313, 1, 0, 0, 0, 1335, 1315, 1, 0, 0, 0, 1335, 1317, 1, 0, 0, 0, 1335, 1322, 1, 0, 0, 0, 1335, 1329, 1, 0, 0, 0, 1336, 129, 1, 0, 0, 0, 1337, 1483, 6, 65, -1, 0, 1338, 1339, 5, 203, 0, 0, 1339, 1340, 5, 30, 0, 0, 1340, 1341, 3, 6, 3, 0, 1341, 1342, 5, 28, 0, 0, 1342, 1343, 3, 6, 3, 0, 1343, 1344, 5, 28, 0, 0, 1344, 1345, 3, 6, 3, 0, 1345, 1346, 5, 28, 0, 0, 1346, 1347, 3, 6, 3, 0, 1347, 1348, 5, 31, 0, 0, 1348, 1349, 6, 65, -1, 0, 1349, 1483, 1, 0, 0, 0, 1350, 1351, 5, 203, 0, 0, 1351, 1352, 5, 30, 0, 0, 1352, 1353, 3, 6, 3, 0, 1353, 1354, 5, 28, 0, 0, 1354, 1355, 3, 6, 3, 0, 1355, 1356, 5, 31, 0, 0, 1356, 1357, 6, 65, -1, 0, 1357, 1483, 1, 0, 0, 0, 1358, 1359, 5, 204, 0, 0, 1359, 1360, 5, 205, 0, 0, 1360, 1361, 5, 42, 0, 0, 1361, 1362, 3, 32, 16, 0, 1362, 1363, 5, 43, 0, 0, 1363, 1364, 6, 65, -1, 0, 1364, 1483, 1, 0, 0, 0, 1365, 1366, 5, 204, 0, 0, 1366, 1367, 5, 206, 0, 0, 1367, 1368, 5, 42, 0, 0, 1368, 1369, 3, 32, 16, 0, 1369, 1370, 5, 43, 0, 0, 1370, 1371, 3, 126, 63, 0, 1371, 1372, 6, 65, -1, 0, 1372, 1483, 1, 0, 0, 0, 1373, 1374, 5, 207, 0, 0, 1374, 1483, 6, 65, -1, 0, 1375, 1376, 5, 208, 0, 0, 1376, 1483, 6, 65, -1, 0, 1377, 1378, 5, 209, 0, 0, 1378, 1483, 6, 65, -1, 0, 1379, 1380, 5, 201, 0, 0, 1380, 1483, 6, 65, -1, 0, 1381, 1382, 5, 183, 0, 0, 1382, 1483, 6, 65, -1, 0, 1383, 1384, 5, 184, 0, 0, 1384, 1483, 6, 65, -1, 0, 1385, 1386, 5, 185, 0, 0, 1386, 1483, 6, 65, -1, 0, 1387, 1388, 5, 186, 0, 0, 1388, 1483, 6, 65, -1, 0, 1389, 1390, 5, 187, 0, 0, 1390, 1483, 6, 65, -1, 0, 1391, 1392, 5, 188, 0, 0, 1392, 1483, 6, 65, -1, 0, 1393, 1394, 5, 189, 0, 0, 1394, 1483, 6, 65, -1, 0, 1395, 1396, 5, 210, 0, 0, 1396, 1483, 6, 65, -1, 0, 1397, 1398, 5, 190, 0, 0, 1398, 1483, 6, 65, -1, 0, 1399, 1400, 5, 191, 0, 0, 1400, 1483, 6, 65, -1, 0, 1401, 1402, 5, 192, 0, 0, 1402, 1483, 6, 65, -1, 0, 1403, 1404, 5, 193, 0, 0, 1404, 1483, 6, 65, -1, 0, 1405, 1406, 5, 211, 0, 0, 1406, 1483, 6, 65, -1, 0, 1407, 1408, 5, 212, 0, 0, 1408, 1483, 6, 65, -1, 0, 1409, 1410, 5, 213, 0, 0, 1410, 1483, 6, 65, -1, 0, 1411, 1412, 5, 214, 0, 0, 1412, 1483, 6, 65, -1, 0, 1413, 1414, 5, 215, 0, 0, 1414, 1483, 6, 65, -1, 0, 1415, 1416, 5, 216, 0, 0, 1416, 1483, 6, 65, -1, 0, 1417, 1418, 5, 217, 0, 0, 1418, 1483, 6, 65, -1, 0, 1419, 1420, 5, 218, 0, 0, 1420, 1421, 3, 132, 66, 0, 1421, 1422, 6, 65, -1, 0, 1422, 1483, 1, 0, 0, 0, 1423, 1424, 5, 219, 0, 0, 1424, 1425, 3, 132, 66, 0, 1425, 1426, 6, 65, -1, 0, 1426, 1483, 1, 0, 0, 0, 1427, 1428, 5, 220, 0, 0, 1428, 1483, 6, 65, -1, 0, 1429, 1430, 5, 221, 0, 0, 1430, 1431, 3, 132, 66, 0, 1431, 1432, 6, 65, -1, 0, 1432, 1483, 1, 0, 0, 0, 1433, 1434, 5, 222, 0, 0, 1434, 1435, 3, 134, 67, 0, 1435, 1436, 6, 65, -1, 0, 1436, 1483, 1, 0, 0, 0, 1437, 1438, 5, 222, 0, 0, 1438, 1439, 3, 134, 67, 0, 1439, 1440, 5, 28, 0, 0, 1440, 1441, 3, 6, 3, 0, 1441, 1442, 6, 65, -1, 0, 1442, 1483, 1, 0, 0, 0, 1443, 1444, 5, 194, 0, 0, 1444, 1483, 6, 65, -1, 0, 1445, 1446, 5, 195, 0, 0, 1446, 1483, 6, 65, -1, 0, 1447, 1448, 5, 90, 0, 0, 1448, 1449, 5, 184, 0, 0, 1449, 1483, 6, 65, -1, 0, 1450, 1451, 5, 90, 0, 0, 1451, 1452, 5, 185, 0, 0, 1452, 1483, 6, 65, -1, 0, 1453, 1454, 5, 90, 0, 0, 1454, 1455, 5, 186, 0, 0, 1455, 1483, 6, 65, -1, 0, 1456, 1457, 5, 90, 0, 0, 1457, 1458, 5, 187, 0, 0, 1458, 1483, 6, 65, -1, 0, 1459, 1460, 5, 62, 0, 0, 1460, 1461, 5, 220, 0, 0, 1461, 1483, 6, 65, -1, 0, 1462, 1463, 5, 223, 0, 0, 1463, 1483, 6, 65, -1, 0, 1464, 1465, 5, 224, 0, 0, 1465, 1466, 5, 213, 0, 0, 1466, 1483, 6, 65, -1, 0, 1467, 1468, 5, 225, 0, 0, 1468, 1483, 6, 65, -1, 0, 1469, 1470, 5, 207, 0, 0, 1470, 1471, 5, 183, 0, 0, 1471, 1483, 6, 65, -1, 0, 1472, 1473, 5, 226, 0, 0, 1473, 1483, 6, 65, -1, 0, 1474, 1475, 5, 228, 0, 0, 1475, 1483, 6, 65, -1, 0, 1476, 1477, 5, 34, 0, 0, 1477, 1478, 5, 227, 0, 0, 1478, 1483, 6, 65, -1, 0, 1479, 1480, 3, 2, 1, 0, 1480, 1481, 6, 65, -1, 0, 1481, 1483, 1, 0, 0, 0, 1482, 1337, 1, 0, 0, 0, 1482, 1338, 1, 0, 0, 0, 1482, 1350, 1, 0, 0, 0, 1482, 1358, 1, 0, 0, 0, 1482, 1365, 1, 0, 0, 0, 1482, 1373, 1, 0, 0, 0, 1482, 1375, 1, 0, 0, 0, 1482, 1377, 1, 0, 0, 0, 1482, 1379, 1, 0, 0, 0, 1482, 1381, 1, 0, 0, 0, 1482, 1383, 1, 0, 0, 0, 1482, 1385, 1, 0, 0, 0, 1482, 1387, 1, 0, 0, 0, 1482, 1389, 1, 0, 0, 0, 1482, 1391, 1, 0, 0, 0, 1482, 1393, 1, 0, 0, 0, 1482, 1395, 1, 0, 0, 0, 1482, 1397, 1, 0, 0, 0, 1482, 1399, 1, 0, 0, 0, 1482, 1401, 1, 0, 0, 0, 1482, 1403, 1, 0, 0, 0, 1482, 1405, 1, 0, 0, 0, 1482, 1407, 1, 0, 0, 0, 1482, 1409, 1, 0, 0, 0, 1482, 1411, 1, 0, 0, 0, 1482, 1413, 1, 0, 0, 0, 1482, 1415, 1, 0, 0, 0, 1482, 1417, 1, 0, 0, 0, 1482, 1419, 1, 0, 0, 0, 1482, 1423, 1, 0, 0, 0, 1482, 1427, 1, 0, 0, 0, 1482, 1429, 1, 0, 0, 0, 1482, 1433, 1, 0, 0, 0, 1482, 1437, 1, 0, 0, 0, 1482, 1443, 1, 0, 0, 0, 1482, 1445, 1, 0, 0, 0, 1482, 1447, 1, 0, 0, 0, 1482, 1450, 1, 0, 0, 0, 1482, 1453, 1, 0, 0, 0, 1482, 1456, 1, 0, 0, 0, 1482, 1459, 1, 0, 0, 0, 1482, 1462, 1, 0, 0, 0, 1482, 1464, 1, 0, 0, 0, 1482, 1467, 1, 0, 0, 0, 1482, 1469, 1, 0, 0, 0, 1482, 1472, 1, 0, 0, 0, 1482, 1474, 1, 0, 0, 0, 1482, 1476, 1, 0, 0, 0, 1482, 1479, 1, 0, 0, 0, 1483, 131, 1, 0, 0, 0, 1484, 1493, 1, 0, 0, 0, 1485, 1486, 5, 30, 0, 0, 1486, 1487, 5, 91, 0, 0, 1487, 1488, 5, 36, 0, 0, 1488, 1489, 3, 32, 16, 0, 1489, 1490, 5, 31, 0, 0, 1490, 1491, 6, 66, -1, 0, 1491, 1493, 1, 0, 0, 0, 1492, 1484, 1, 0, 0, 0, 1492, 1485, 1, 0, 0, 0, 1493, 133, 1, 0, 0, 0, 1494, 1505, 1, 0, 0, 0, 1495, 1496, 3, 136, 68, 0, 1496, 1501, 6, 67, -1, 0, 1497, 1498, 7, 7, 0, 0, 1498, 1500, 6, 67, -1, 0, 1499, 1497, 1, 0, 0, 0, 1500, 1503, 1, 0, 0, 0, 1501, 1499, 1, 0, 0, 0, 1501, 1502, 1, 0, 0, 0, 1502, 1505, 1, 0, 0, 0, 1503, 1501, 1, 0, 0, 0, 1504, 1494, 1, 0, 0, 0, 1504, 1495, 1, 0, 0, 0, 1505, 135, 1, 0, 0, 0, 1506, 1507, 5, 178, 0, 0, 1507, 1587, 6, 68, -1, 0, 1508, 1509, 5, 207, 0, 0, 1509, 1587, 6, 68, -1, 0, 1510, 1511, 5, 208, 0, 0, 1511, 1587, 6, 68, -1, 0, 1512, 1513, 5, 201, 0, 0, 1513, 1587, 6, 68, -1, 0, 1514, 1515, 5, 183, 0, 0, 1515, 1587, 6, 68, -1, 0, 1516, 1517, 5, 184, 0, 0, 1517, 1587, 6, 68, -1, 0, 1518, 1519, 5, 185, 0, 0, 1519, 1587, 6, 68, -1, 0, 1520, 1521, 5, 186, 0, 0, 1521, 1587, 6, 68, -1, 0, 1522, 1523, 5, 187, 0, 0, 1523, 1587, 6, 68, -1, 0, 1524, 1525, 5, 188, 0, 0, 1525, 1587, 6, 68, -1, 0, 1526, 1527, 5, 189, 0, 0, 1527, 1587, 6, 68, -1, 0, 1528, 1529, 5, 190, 0, 0, 1529, 1587, 6, 68, -1, 0, 1530, 1531, 5, 191, 0, 0, 1531, 1587, 6, 68, -1, 0, 1532, 1533, 5, 192, 0, 0, 1533, 1587, 6, 68, -1, 0, 1534, 1535, 5, 193, 0, 0, 1535, 1587, 6, 68, -1, 0, 1536, 1537, 5, 262, 0, 0, 1537, 1587, 6, 68, -1, 0, 1538, 1539, 5, 211, 0, 0, 1539, 1587, 6, 68, -1, 0, 1540, 1541, 5, 212, 0, 0, 1541, 1587, 6, 68, -1, 0, 1542, 1543, 5, 213, 0, 0, 1543, 1587, 6, 68, -1, 0, 1544, 1545, 5, 214, 0, 0, 1545, 1587, 6, 68, -1, 0, 1546, 1547, 5, 215, 0, 0, 1547, 1587, 6, 68, -1, 0, 1548, 1549, 5, 218, 0, 0, 1549, 1587, 6, 68, -1, 0, 1550, 1551, 5, 219, 0, 0, 1551, 1587, 6, 68, -1, 0, 1552, 1553, 5, 222, 0, 0, 1553, 1587, 6, 68, -1, 0, 1554, 1555, 5, 194, 0, 0, 1555, 1587, 6, 68, -1, 0, 1556, 1557, 5, 195, 0, 0, 1557, 1587, 6, 68, -1, 0, 1558, 1559, 5, 210, 0, 0, 1559, 1587, 6, 68, -1, 0, 1560, 1561, 5, 230, 0, 0, 1561, 1587, 6, 68, -1, 0, 1562, 1563, 5, 231, 0, 0, 1563, 1587, 6, 68, -1, 0, 1564, 1565, 5, 232, 0, 0, 1565, 1587, 6, 68, -1, 0, 1566, 1567, 5, 233, 0, 0, 1567, 1587, 6, 68, -1, 0, 1568, 1569, 5, 234, 0, 0, 1569, 1587, 6, 68, -1, 0, 1570, 1571, 5, 235, 0, 0, 1571, 1587, 6, 68, -1, 0, 1572, 1573, 5, 236, 0, 0, 1573, 1587, 6, 68, -1, 0, 1574, 1575, 5, 237, 0, 0, 1575, 1587, 6, 68, -1, 0, 1576, 1577, 5, 238, 0, 0, 1577, 1587, 6, 68, -1, 0, 1578, 1579, 5, 239, 0, 0, 1579, 1587, 6, 68, -1, 0, 1580, 1581, 5, 240, 0, 0, 1581, 1587, 6, 68, -1, 0, 1582, 1583, 5, 241, 0, 0, 1583, 1587, 6, 68, -1, 0, 1584, 1585, 5, 242, 0, 0, 1585, 1587, 6, 68, -1, 0, 1586, 1506, 1, 0, 0, 0, 1586, 1508, 1, 0, 0, 0, 1586, 1510, 1, 0, 0, 0, 1586, 1512, 1, 0, 0, 0, 1586, 1514, 1, 0, 0, 0, 1586, 1516, 1, 0, 0, 0, 1586, 1518, 1, 0, 0, 0, 1586, 1520, 1, 0, 0, 0, 1586, 1522, 1, 0, 0, 0, 1586, 1524, 1, 0, 0, 0, 1586, 1526, 1, 0, 0, 0, 1586, 1528, 1, 0, 0, 0, 1586, 1530, 1, 0, 0, 0, 1586, 1532, 1, 0, 0, 0, 1586, 1534, 1, 0, 0, 0, 1586, 1536, 1, 0, 0, 0, 1586, 1538, 1, 0, 0, 0, 1586, 1540, 1, 0, 0, 0, 1586, 1542, 1, 0, 0, 0, 1586, 1544, 1, 0, 0, 0, 1586, 1546, 1, 0, 0, 0, 1586, 1548, 1, 0, 0, 0, 1586, 1550, 1, 0, 0, 0, 1586, 1552, 1, 0, 0, 0, 1586, 1554, 1, 0, 0, 0, 1586, 1556, 1, 0, 0, 0, 1586, 1558, 1, 0, 0, 0, 1586, 1560, 1, 0, 0, 0, 1586, 1562, 1, 0, 0, 0, 1586, 1564, 1, 0, 0, 0, 1586, 1566, 1, 0, 0, 0, 1586, 1568, 1, 0, 0, 0, 1586, 1570, 1, 0, 0, 0, 1586, 1572, 1, 0, 0, 0, 1586, 1574, 1, 0, 0, 0, 1586, 1576, 1, 0, 0, 0, 1586, 1578, 1, 0, 0, 0, 1586, 1580, 1, 0, 0, 0, 1586, 1582, 1, 0, 0, 0, 1586, 1584, 1, 0, 0, 0, 1587, 137, 1, 0, 0, 0, 1588, 1589, 3, 142, 71, 0, 1589, 1595, 6, 69, -1, 0, 1590, 1591, 3, 140, 70, 0, 1591, 1592, 6, 69, -1, 0, 1592, 1594, 1, 0, 0, 0, 1593, 1590, 1, 0, 0, 0, 1594, 1597, 1, 0, 0, 0, 1595, 1593, 1, 0, 0, 0, 1595, 1596, 1, 0, 0, 0, 1596, 139, 1, 0, 0, 0, 1597, 1595, 1, 0, 0, 0, 1598, 1599, 5, 261, 0, 0, 1599, 1628, 6, 70, -1, 0, 1600, 1601, 5, 42, 0, 0, 1601, 1602, 5, 43, 0, 0, 1602, 1628, 6, 70, -1, 0, 1603, 1604, 3, 110, 55, 0, 1604, 1605, 6, 70, -1, 0, 1605, 1628, 1, 0, 0, 0, 1606, 1607, 5, 260, 0, 0, 1607, 1628, 6, 70, -1, 0, 1608, 1609, 5, 262, 0, 0, 1609, 1628, 6, 70, -1, 0, 1610, 1611, 5, 92, 0, 0, 1611, 1628, 6, 70, -1, 0, 1612, 1613, 5, 93, 0, 0, 1613, 1614, 5, 30, 0, 0, 1614, 1615, 3, 124, 62, 0, 1615, 1616, 5, 31, 0, 0, 1616, 1617, 6, 70, -1, 0, 1617, 1628, 1, 0, 0, 0, 1618, 1619, 5, 94, 0, 0, 1619, 1620, 5, 30, 0, 0, 1620, 1621, 3, 124, 62, 0, 1621, 1622, 5, 31, 0, 0, 1622, 1623, 6, 70, -1, 0, 1623, 1628, 1, 0, 0, 0, 1624, 1625, 3, 108, 54, 0, 1625, 1626, 6, 70, -1, 0, 1626, 1628, 1, 0, 0, 0, 1627, 1598, 1, 0, 0, 0, 1627, 1600, 1, 0, 0, 0, 1627, 1603, 1, 0, 0, 0, 1627, 1606, 1, 0, 0, 0, 1627, 1608, 1, 0, 0, 0, 1627, 1610, 1, 0, 0, 0, 1627, 1612, 1, 0, 0, 0, 1627, 1618, 1, 0, 0, 0, 1627, 1624, 1, 0, 0, 0, 1628, 141, 1, 0, 0, 0, 1629, 1630, 5, 39, 0, 0, 1630, 1631, 3, 116, 58, 0, 1631, 1632, 6, 71, -1, 0, 1632, 1688, 1, 0, 0, 0, 1633, 1634, 5, 197, 0, 0, 1634, 1688, 6, 71, -1, 0, 1635, 1636, 5, 199, 0, 0, 1636, 1637, 5, 39, 0, 0, 1637, 1638, 3, 116, 58, 0, 1638, 1639, 6, 71, -1, 0, 1639, 1688, 1, 0, 0, 0, 1640, 1641, 5, 200, 0, 0, 1641, 1642, 3, 116, 58, 0, 1642, 1643, 6, 71, -1, 0, 1643, 1688, 1, 0, 0, 0, 1644, 1645, 5, 226, 0, 0, 1645, 1646, 3, 170, 85, 0, 1646, 1647, 3, 138, 69, 0, 1647, 1648, 5, 262, 0, 0, 1648, 1649, 3, 112, 56, 0, 1649, 1650, 6, 71, -1, 0, 1650, 1688, 1, 0, 0, 0, 1651, 1652, 5, 253, 0, 0, 1652, 1653, 3, 32, 16, 0, 1653, 1654, 6, 71, -1, 0, 1654, 1688, 1, 0, 0, 0, 1655, 1656, 5, 252, 0, 0, 1656, 1657, 3, 32, 16, 0, 1657, 1658, 6, 71, -1, 0, 1658, 1688, 1, 0, 0, 0, 1659, 1660, 5, 253, 0, 0, 1660, 1661, 3, 2, 1, 0, 1661, 1662, 6, 71, -1, 0, 1662, 1688, 1, 0, 0, 0, 1663, 1664, 5, 252, 0, 0, 1664, 1665, 3, 2, 1, 0, 1665, 1666, 6, 71, -1, 0, 1666, 1688, 1, 0, 0, 0, 1667, 1668, 5, 254, 0, 0, 1668, 1688, 6, 71, -1, 0, 1669, 1670, 5, 201, 0, 0, 1670, 1688, 6, 71, -1, 0, 1671, 1672, 3, 148, 74, 0, 1672, 1673, 6, 71, -1, 0, 1673, 1688, 1, 0, 0, 0, 1674, 1675, 3, 150, 75, 0, 1675, 1676, 6, 71, -1, 0, 1676, 1688, 1, 0, 0, 0, 1677, 1678, 3, 144, 72, 0, 1678, 1679, 6, 71, -1, 0, 1679, 1688, 1, 0, 0, 0, 1680, 1681, 3, 2, 1, 0, 1681, 1682, 6, 71, -1, 0, 1682, 1688, 1, 0, 0, 0, 1683, 1684, 5, 177, 0, 0, 1684, 1685, 3, 138, 69, 0, 1685, 1686, 6, 71, -1, 0, 1686, 1688, 1, 0, 0, 0, 1687, 1629, 1, 0, 0, 0, 1687, 1633, 1, 0, 0, 0, 1687, 1635, 1, 0, 0, 0, 1687, 1640, 1, 0, 0, 0, 1687, 1644, 1, 0, 0, 0, 1687, 1651, 1, 0, 0, 0, 1687, 1655, 1, 0, 0, 0, 1687, 1659, 1, 0, 0, 0, 1687, 1663, 1, 0, 0, 0, 1687, 1667, 1, 0, 0, 0, 1687, 1669, 1, 0, 0, 0, 1687, 1671, 1, 0, 0, 0, 1687, 1674, 1, 0, 0, 0, 1687, 1677, 1, 0, 0, 0, 1687, 1680, 1, 0, 0, 0, 1687, 1683, 1, 0, 0, 0, 1688, 143, 1, 0, 0, 0, 1689, 1690, 5, 181, 0, 0, 1690, 1728, 6, 72, -1, 0, 1691, 1692, 5, 182, 0, 0, 1692, 1728, 6, 72, -1, 0, 1693, 1694, 5, 183, 0, 0, 1694, 1728, 6, 72, -1, 0, 1695, 1696, 5, 184, 0, 0, 1696, 1728, 6, 72, -1, 0, 1697, 1698, 5, 185, 0, 0, 1698, 1728, 6, 72, -1, 0, 1699, 1700, 5, 186, 0, 0, 1700, 1728, 6, 72, -1, 0, 1701, 1702, 5, 187, 0, 0, 1702, 1728, 6, 72, -1, 0, 1703, 1704, 5, 188, 0, 0, 1704, 1728, 6, 72, -1, 0, 1705, 1706, 5, 189, 0, 0, 1706, 1728, 6, 72, -1, 0, 1707, 1708, 5, 190, 0, 0, 1708, 1728, 6, 72, -1, 0, 1709, 1710, 5, 191, 0, 0, 1710, 1728, 6, 72, -1, 0, 1711, 1712, 5, 192, 0, 0, 1712, 1728, 6, 72, -1, 0, 1713, 1714, 5, 193, 0, 0, 1714, 1728, 6, 72, -1, 0, 1715, 1716, 5, 90, 0, 0, 1716, 1717, 5, 184, 0, 0, 1717, 1728, 6, 72, -1, 0, 1718, 1719, 5, 90, 0, 0, 1719, 1720, 5, 185, 0, 0, 1720, 1728, 6, 72, -1, 0, 1721, 1722, 5, 90, 0, 0, 1722, 1723, 5, 186, 0, 0, 1723, 1728, 6, 72, -1, 0, 1724, 1725, 5, 90, 0, 0, 1725, 1726, 5, 187, 0, 0, 1726, 1728, 6, 72, -1, 0, 1727, 1689, 1, 0, 0, 0, 1727, 1691, 1, 0, 0, 0, 1727, 1693, 1, 0, 0, 0, 1727, 1695, 1, 0, 0, 0, 1727, 1697, 1, 0, 0, 0, 1727, 1699, 1, 0, 0, 0, 1727, 1701, 1, 0, 0, 0, 1727, 1703, 1, 0, 0, 0, 1727, 1705, 1, 0, 0, 0, 1727, 1707, 1, 0, 0, 0, 1727, 1709, 1, 0, 0, 0, 1727, 1711, 1, 0, 0, 0, 1727, 1713, 1, 0, 0, 0, 1727, 1715, 1, 0, 0, 0, 1727, 1718, 1, 0, 0, 0, 1727, 1721, 1, 0, 0, 0, 1727, 1724, 1, 0, 0, 0, 1728, 145, 1, 0, 0, 0, 1729, 1744, 1, 0, 0, 0, 1730, 1744, 5, 177, 0, 0, 1731, 1732, 3, 32, 16, 0, 1732, 1733, 6, 73, -1, 0, 1733, 1744, 1, 0, 0, 0, 1734, 1735, 3, 32, 16, 0, 1735, 1736, 5, 177, 0, 0, 1736, 1737, 3, 32, 16, 0, 1737, 1738, 6, 73, -1, 0, 1738, 1744, 1, 0, 0, 0, 1739, 1740, 3, 32, 16, 0, 1740, 1741, 5, 177, 0, 0, 1741, 1742, 6, 73, -1, 0, 1742, 1744, 1, 0, 0, 0, 1743, 1729, 1, 0, 0, 0, 1743, 1730, 1, 0, 0, 0, 1743, 1731, 1, 0, 0, 0, 1743, 1734, 1, 0, 0, 0, 1743, 1739, 1, 0, 0, 0, 1744, 147, 1, 0, 0, 0, 1745, 1746, 5, 1, 0, 0, 1746, 1747, 5, 194, 0, 0, 1747, 1748, 6, 74, -1, 0, 1748, 149, 1, 0, 0, 0, 1749, 1753, 5, 1, 0, 0, 1750, 1751, 5, 90, 0, 0, 1751, 1754, 5, 194, 0, 0, 1752, 1754, 5, 195, 0, 0, 1753, 1750, 1, 0, 0, 0, 1753, 1752, 1, 0, 0, 0, 1754, 1755, 1, 0, 0, 0, 1755, 1756, 6, 75, -1, 0, 1756, 151, 1, 0, 0, 0, 1757, 1758, 5, 294, 0, 0, 1758, 1759, 3, 166, 83, 0, 1759, 1760, 3, 124, 62, 0, 1760, 1761, 5, 30, 0, 0, 1761, 1762, 3, 158, 79, 0, 1762, 1763, 5, 31, 0, 0, 1763, 1764, 6, 76, -1, 0, 1764, 1812, 1, 0, 0, 0, 1765, 1766, 5, 294, 0, 0, 1766, 1767, 3, 166, 83, 0, 1767, 1768, 3, 124, 62, 0, 1768, 1769, 5, 36, 0, 0, 1769, 1770, 5, 17, 0, 0, 1770, 1771, 3, 52, 26, 0, 1771, 1772, 5, 18, 0, 0, 1772, 1773, 6, 76, -1, 0, 1773, 1812, 1, 0, 0, 0, 1774, 1775, 5, 294, 0, 0, 1775, 1776, 3, 166, 83, 0, 1776, 1777, 3, 124, 62, 0, 1777, 1778, 6, 76, -1, 0, 1778, 1812, 1, 0, 0, 0, 1779, 1780, 5, 295, 0, 0, 1780, 1781, 3, 166, 83, 0, 1781, 1783, 5, 36, 0, 0, 1782, 1784, 5, 84, 0, 0, 1783, 1782, 1, 0, 0, 0, 1783, 1784, 1, 0, 0, 0, 1784, 1785, 1, 0, 0, 0, 1785, 1786, 5, 30, 0, 0, 1786, 1787, 3, 300, 150, 0, 1787, 1788, 5, 31, 0, 0, 1788, 1789, 6, 76, -1, 0, 1789, 1812, 1, 0, 0, 0, 1790, 1791, 5, 295, 0, 0, 1791, 1792, 3, 166, 83, 0, 1792, 1793, 5, 84, 0, 0, 1793, 1794, 5, 30, 0, 0, 1794, 1795, 3, 300, 150, 0, 1795, 1796, 5, 31, 0, 0, 1796, 1797, 6, 76, -1, 0, 1797, 1812, 1, 0, 0, 0, 1798, 1799, 5, 295, 0, 0, 1799, 1800, 3, 166, 83, 0, 1800, 1801, 3, 6, 3, 0, 1801, 1802, 6, 76, -1, 0, 1802, 1812, 1, 0, 0, 0, 1803, 1804, 5, 295, 0, 0, 1804, 1805, 3, 166, 83, 0, 1805, 1806, 5, 36, 0, 0, 1806, 1807, 5, 17, 0, 0, 1807, 1808, 3, 154, 77, 0, 1808, 1809, 5, 18, 0, 0, 1809, 1810, 6, 76, -1, 0, 1810, 1812, 1, 0, 0, 0, 1811, 1757, 1, 0, 0, 0, 1811, 1765, 1, 0, 0, 0, 1811, 1774, 1, 0, 0, 0, 1811, 1779, 1, 0, 0, 0, 1811, 1790, 1, 0, 0, 0, 1811, 1798, 1, 0, 0, 0, 1811, 1803, 1, 0, 0, 0, 1812, 153, 1, 0, 0, 0, 1813, 1827, 1, 0, 0, 0, 1814, 1815, 3, 156, 78, 0, 1815, 1816, 6, 77, -1, 0, 1816, 1817, 5, 28, 0, 0, 1817, 1819, 1, 0, 0, 0, 1818, 1814, 1, 0, 0, 0, 1819, 1822, 1, 0, 0, 0, 1820, 1818, 1, 0, 0, 0, 1820, 1821, 1, 0, 0, 0, 1821, 1823, 1, 0, 0, 0, 1822, 1820, 1, 0, 0, 0, 1823, 1824, 3, 156, 78, 0, 1824, 1825, 6, 77, -1, 0, 1825, 1827, 1, 0, 0, 0, 1826, 1813, 1, 0, 0, 0, 1826, 1820, 1, 0, 0, 0, 1827, 155, 1, 0, 0, 0, 1828, 1829, 5, 39, 0, 0, 1829, 1830, 5, 264, 0, 0, 1830, 1831, 5, 36, 0, 0, 1831, 1832, 5, 17, 0, 0, 1832, 1833, 3, 56, 28, 0, 1833, 1834, 5, 18, 0, 0, 1834, 1835, 6, 78, -1, 0, 1835, 1844, 1, 0, 0, 0, 1836, 1837, 3, 124, 62, 0, 1837, 1838, 5, 36, 0, 0, 1838, 1839, 5, 17, 0, 0, 1839, 1840, 3, 56, 28, 0, 1840, 1841, 5, 18, 0, 0, 1841, 1842, 6, 78, -1, 0, 1842, 1844, 1, 0, 0, 0, 1843, 1828, 1, 0, 0, 0, 1843, 1836, 1, 0, 0, 0, 1844, 157, 1, 0, 0, 0, 1845, 1846, 3, 160, 80, 0, 1846, 1847, 6, 79, -1, 0, 1847, 1848, 5, 28, 0, 0, 1848, 1850, 1, 0, 0, 0, 1849, 1845, 1, 0, 0, 0, 1850, 1853, 1, 0, 0, 0, 1851, 1849, 1, 0, 0, 0, 1851, 1852, 1, 0, 0, 0, 1852, 1854, 1, 0, 0, 0, 1853, 1851, 1, 0, 0, 0, 1854, 1855, 3, 160, 80, 0, 1855, 1856, 6, 79, -1, 0, 1856, 159, 1, 0, 0, 0, 1857, 1858, 3, 6, 3, 0, 1858, 1859, 5, 36, 0, 0, 1859, 1860, 3, 164, 82, 0, 1860, 1861, 6, 80, -1, 0, 1861, 161, 1, 0, 0, 0, 1862, 1863, 7, 8, 0, 0, 1863, 163, 1, 0, 0, 0, 1864, 1865, 3, 162, 81, 0, 1865, 1866, 6, 82, -1, 0, 1866, 1910, 1, 0, 0, 0, 1867, 1868, 3, 32, 16, 0, 1868, 1869, 6, 82, -1, 0, 1869, 1910, 1, 0, 0, 0, 1870, 1871, 5, 186, 0, 0, 1871, 1872, 5, 30, 0, 0, 1872, 1873, 3, 32, 16, 0, 1873, 1874, 5, 31, 0, 0, 1874, 1875, 6, 82, -1, 0, 1875, 1910, 1, 0, 0, 0, 1876, 1877, 3, 6, 3, 0, 1877, 1878, 6, 82, -1, 0, 1878, 1910, 1, 0, 0, 0, 1879, 1880, 3, 116, 58, 0, 1880, 1881, 5, 30, 0, 0, 1881, 1882, 5, 184, 0, 0, 1882, 1883, 5, 75, 0, 0, 1883, 1884, 3, 32, 16, 0, 1884, 1885, 5, 31, 0, 0, 1885, 1886, 6, 82, -1, 0, 1886, 1910, 1, 0, 0, 0, 1887, 1888, 3, 116, 58, 0, 1888, 1889, 5, 30, 0, 0, 1889, 1890, 5, 185, 0, 0, 1890, 1891, 5, 75, 0, 0, 1891, 1892, 3, 32, 16, 0, 1892, 1893, 5, 31, 0, 0, 1893, 1894, 6, 82, -1, 0, 1894, 1910, 1, 0, 0, 0, 1895, 1896, 3, 116, 58, 0, 1896, 1897, 5, 30, 0, 0, 1897, 1898, 5, 186, 0, 0, 1898, 1899, 5, 75, 0, 0, 1899, 1900, 3, 32, 16, 0, 1900, 1901, 5, 31, 0, 0, 1901, 1902, 6, 82, -1, 0, 1902, 1910, 1, 0, 0, 0, 1903, 1904, 3, 116, 58, 0, 1904, 1905, 5, 30, 0, 0, 1905, 1906, 3, 32, 16, 0, 1906, 1907, 5, 31, 0, 0, 1907, 1908, 6, 82, -1, 0, 1908, 1910, 1, 0, 0, 0, 1909, 1864, 1, 0, 0, 0, 1909, 1867, 1, 0, 0, 0, 1909, 1870, 1, 0, 0, 0, 1909, 1876, 1, 0, 0, 0, 1909, 1879, 1, 0, 0, 0, 1909, 1887, 1, 0, 0, 0, 1909, 1895, 1, 0, 0, 0, 1909, 1903, 1, 0, 0, 0, 1910, 165, 1, 0, 0, 0, 1911, 1912, 7, 9, 0, 0, 1912, 167, 1, 0, 0, 0, 1913, 1914, 3, 170, 85, 0, 1914, 1915, 3, 138, 69, 0, 1915, 1916, 3, 124, 62, 0, 1916, 1917, 5, 176, 0, 0, 1917, 1919, 3, 242, 121, 0, 1918, 1920, 3, 108, 54, 0, 1919, 1918, 1, 0, 0, 0, 1919, 1920, 1, 0, 0, 0, 1920, 1921, 1, 0, 0, 0, 1921, 1922, 3, 112, 56, 0, 1922, 1923, 6, 84, -1, 0, 1923, 1956, 1, 0, 0, 0, 1924, 1925, 3, 170, 85, 0, 1925, 1926, 3, 138, 69, 0, 1926, 1927, 3, 124, 62, 0, 1927, 1928, 5, 176, 0, 0, 1928, 1929, 3, 242, 121, 0, 1929, 1930, 3, 196, 98, 0, 1930, 1931, 3, 112, 56, 0, 1931, 1932, 6, 84, -1, 0, 1932, 1956, 1, 0, 0, 0, 1933, 1934, 3, 170, 85, 0, 1934, 1935, 3, 138, 69, 0, 1935, 1937, 3, 242, 121, 0, 1936, 1938, 3, 108, 54, 0, 1937, 1936, 1, 0, 0, 0, 1937, 1938, 1, 0, 0, 0, 1938, 1939, 1, 0, 0, 0, 1939, 1940, 3, 112, 56, 0, 1940, 1941, 6, 84, -1, 0, 1941, 1956, 1, 0, 0, 0, 1942, 1943, 3, 170, 85, 0, 1943, 1944, 3, 138, 69, 0, 1944, 1945, 3, 242, 121, 0, 1945, 1946, 3, 196, 98, 0, 1946, 1947, 3, 112, 56, 0, 1947, 1948, 6, 84, -1, 0, 1948, 1956, 1, 0, 0, 0, 1949, 1950, 3, 174, 87, 0, 1950, 1951, 6, 84, -1, 0, 1951, 1956, 1, 0, 0, 0, 1952, 1953, 3, 2, 1, 0, 1953, 1954, 6, 84, -1, 0, 1954, 1956, 1, 0, 0, 0, 1955, 1913, 1, 0, 0, 0, 1955, 1924, 1, 0, 0, 0, 1955, 1933, 1, 0, 0, 0, 1955, 1942, 1, 0, 0, 0, 1955, 1949, 1, 0, 0, 0, 1955, 1952, 1, 0, 0, 0, 1956, 169, 1, 0, 0, 0, 1957, 1958, 5, 243, 0, 0, 1958, 1959, 3, 170, 85, 0, 1959, 1960, 6, 85, -1, 0, 1960, 1975, 1, 0, 0, 0, 1961, 1962, 5, 244, 0, 0, 1962, 1963, 3, 170, 85, 0, 1963, 1964, 6, 85, -1, 0, 1964, 1975, 1, 0, 0, 0, 1965, 1966, 3, 172, 86, 0, 1966, 1967, 6, 85, -1, 0, 1967, 1975, 1, 0, 0, 0, 1968, 1969, 5, 112, 0, 0, 1969, 1970, 5, 30, 0, 0, 1970, 1971, 3, 32, 16, 0, 1971, 1972, 5, 31, 0, 0, 1972, 1973, 6, 85, -1, 0, 1973, 1975, 1, 0, 0, 0, 1974, 1957, 1, 0, 0, 0, 1974, 1961, 1, 0, 0, 0, 1974, 1965, 1, 0, 0, 0, 1974, 1968, 1, 0, 0, 0, 1975, 171, 1, 0, 0, 0, 1976, 1996, 1, 0, 0, 0, 1977, 1978, 5, 245, 0, 0, 1978, 1996, 6, 86, -1, 0, 1979, 1980, 5, 246, 0, 0, 1980, 1996, 6, 86, -1, 0, 1981, 1982, 5, 247, 0, 0, 1982, 1983, 5, 248, 0, 0, 1983, 1996, 6, 86, -1, 0, 1984, 1985, 5, 247, 0, 0, 1985, 1986, 5, 249, 0, 0, 1986, 1996, 6, 86, -1, 0, 1987, 1988, 5, 247, 0, 0, 1988, 1989, 5, 250, 0, 0, 1989, 1996, 6, 86, -1, 0, 1990, 1991, 5, 247, 0, 0, 1991, 1992, 5, 251, 0, 0, 1992, 1996, 6, 86, -1, 0, 1993, 1994, 5, 247, 0, 0, 1994, 1996, 6, 86, -1, 0, 1995, 1976, 1, 0, 0, 0, 1995, 1977, 1, 0, 0, 0, 1995, 1979, 1, 0, 0, 0, 1995, 1981, 1, 0, 0, 0, 1995, 1984, 1, 0, 0, 0, 1995, 1987, 1, 0, 0, 0, 1995, 1990, 1, 0, 0, 0, 1995, 1993, 1, 0, 0, 0, 1996, 173, 1, 0, 0, 0, 1997, 1998, 5, 113, 0, 0, 1998, 1999, 5, 30, 0, 0, 1999, 2000, 3, 32, 16, 0, 2000, 2001, 5, 31, 0, 0, 2001, 2002, 6, 87, -1, 0, 2002, 175, 1, 0, 0, 0, 2003, 2004, 5, 226, 0, 0, 2004, 2005, 3, 168, 84, 0, 2005, 2006, 6, 88, -1, 0, 2006, 2015, 1, 0, 0, 0, 2007, 2008, 5, 37, 0, 0, 2008, 2009, 3, 178, 89, 0, 2009, 2010, 6, 88, -1, 0, 2010, 2015, 1, 0, 0, 0, 2011, 2012, 3, 174, 87, 0, 2012, 2013, 6, 88, -1, 0, 2013, 2015, 1, 0, 0, 0, 2014, 2003, 1, 0, 0, 0, 2014, 2007, 1, 0, 0, 0, 2014, 2011, 1, 0, 0, 0, 2015, 177, 1, 0, 0, 0, 2016, 2017, 3, 138, 69, 0, 2017, 2018, 3, 124, 62, 0, 2018, 2019, 5, 176, 0, 0, 2019, 2020, 3, 2, 1, 0, 2020, 2021, 6, 89, -1, 0, 2021, 2030, 1, 0, 0, 0, 2022, 2023, 3, 138, 69, 0, 2023, 2024, 3, 2, 1, 0, 2024, 2025, 6, 89, -1, 0, 2025, 2030, 1, 0, 0, 0, 2026, 2027, 3, 2, 1, 0, 2027, 2028, 6, 89, -1, 0, 2028, 2030, 1, 0, 0, 0, 2029, 2016, 1, 0, 0, 0, 2029, 2022, 1, 0, 0, 0, 2029, 2026, 1, 0, 0, 0, 2030, 179, 1, 0, 0, 0, 2031, 2032, 3, 124, 62, 0, 2032, 2033, 6, 90, -1, 0, 2033, 2034, 5, 28, 0, 0, 2034, 2036, 1, 0, 0, 0, 2035, 2031, 1, 0, 0, 0, 2036, 2039, 1, 0, 0, 0, 2037, 2035, 1, 0, 0, 0, 2037, 2038, 1, 0, 0, 0, 2038, 2040, 1, 0, 0, 0, 2039, 2037, 1, 0, 0, 0, 2040, 2041, 3, 124, 62, 0, 2041, 2042, 6, 90, -1, 0, 2042, 181, 1, 0, 0, 0, 2043, 2050, 1, 0, 0, 0, 2044, 2045, 5, 86, 0, 0, 2045, 2046, 3, 190, 95, 0, 2046, 2047, 5, 87, 0, 0, 2047, 2048, 6, 91, -1, 0, 2048, 2050, 1, 0, 0, 0, 2049, 2043, 1, 0, 0, 0, 2049, 2044, 1, 0, 0, 0, 2050, 183, 1, 0, 0, 0, 2051, 2052, 5, 266, 0, 0, 2052, 2070, 6, 92, -1, 0, 2053, 2054, 5, 114, 0, 0, 2054, 2070, 6, 92, -1, 0, 2055, 2056, 5, 39, 0, 0, 2056, 2070, 6, 92, -1, 0, 2057, 2058, 5, 200, 0, 0, 2058, 2070, 6, 92, -1, 0, 2059, 2060, 5, 115, 0, 0, 2060, 2070, 6, 92, -1, 0, 2061, 2062, 5, 116, 0, 0, 2062, 2070, 6, 92, -1, 0, 2063, 2064, 5, 70, 0, 0, 2064, 2065, 5, 30, 0, 0, 2065, 2066, 3, 32, 16, 0, 2066, 2067, 5, 31, 0, 0, 2067, 2068, 6, 92, -1, 0, 2068, 2070, 1, 0, 0, 0, 2069, 2051, 1, 0, 0, 0, 2069, 2053, 1, 0, 0, 0, 2069, 2055, 1, 0, 0, 0, 2069, 2057, 1, 0, 0, 0, 2069, 2059, 1, 0, 0, 0, 2069, 2061, 1, 0, 0, 0, 2069, 2063, 1, 0, 0, 0, 2070, 185, 1, 0, 0, 0, 2071, 2072, 3, 184, 92, 0, 2072, 2073, 6, 93, -1, 0, 2073, 2075, 1, 0, 0, 0, 2074, 2071, 1, 0, 0, 0, 2075, 2078, 1, 0, 0, 0, 2076, 2074, 1, 0, 0, 0, 2076, 2077, 1, 0, 0, 0, 2077, 187, 1, 0, 0, 0, 2078, 2076, 1, 0, 0, 0, 2079, 2081, 3, 186, 93, 0, 2080, 2082, 3, 192, 96, 0, 2081, 2080, 1, 0, 0, 0, 2081, 2082, 1, 0, 0, 0, 2082, 2083, 1, 0, 0, 0, 2083, 2084, 3, 2, 1, 0, 2084, 2085, 6, 94, -1, 0, 2085, 189, 1, 0, 0, 0, 2086, 2087, 3, 188, 94, 0, 2087, 2088, 6, 95, -1, 0, 2088, 2089, 5, 28, 0, 0, 2089, 2091, 1, 0, 0, 0, 2090, 2086, 1, 0, 0, 0, 2091, 2094, 1, 0, 0, 0, 2092, 2090, 1, 0, 0, 0, 2092, 2093, 1, 0, 0, 0, 2093, 2095, 1, 0, 0, 0, 2094, 2092, 1, 0, 0, 0, 2095, 2096, 3, 188, 94, 0, 2096, 2097, 6, 95, -1, 0, 2097, 191, 1, 0, 0, 0, 2098, 2099, 5, 30, 0, 0, 2099, 2100, 3, 180, 90, 0, 2100, 2101, 5, 31, 0, 0, 2101, 2102, 6, 96, -1, 0, 2102, 193, 1, 0, 0, 0, 2103, 2105, 3, 196, 98, 0, 2104, 2103, 1, 0, 0, 0, 2104, 2105, 1, 0, 0, 0, 2105, 2106, 1, 0, 0, 0, 2106, 2107, 6, 97, -1, 0, 2107, 195, 1, 0, 0, 0, 2108, 2109, 5, 86, 0, 0, 2109, 2110, 5, 42, 0, 0, 2110, 2111, 3, 32, 16, 0, 2111, 2112, 5, 43, 0, 0, 2112, 2113, 5, 87, 0, 0, 2113, 2114, 6, 98, -1, 0, 2114, 197, 1, 0, 0, 0, 2115, 2116, 3, 234, 117, 0, 2116, 2117, 5, 17, 0, 0, 2117, 2118, 3, 246, 123, 0, 2118, 2119, 5, 18, 0, 0, 2119, 2266, 1, 0, 0, 0, 2120, 2121, 3, 74, 37, 0, 2121, 2122, 5, 17, 0, 0, 2122, 2123, 3, 82, 41, 0, 2123, 2124, 5, 18, 0, 0, 2124, 2266, 1, 0, 0, 0, 2125, 2126, 3, 210, 105, 0, 2126, 2127, 6, 99, -1, 0, 2127, 2128, 5, 17, 0, 0, 2128, 2129, 3, 214, 107, 0, 2129, 2130, 5, 18, 0, 0, 2130, 2266, 1, 0, 0, 0, 2131, 2132, 3, 218, 109, 0, 2132, 2133, 6, 99, -1, 0, 2133, 2134, 5, 17, 0, 0, 2134, 2135, 3, 222, 111, 0, 2135, 2136, 5, 18, 0, 0, 2136, 2266, 1, 0, 0, 0, 2137, 2266, 3, 200, 100, 0, 2138, 2139, 3, 284, 142, 0, 2139, 2140, 6, 99, -1, 0, 2140, 2266, 1, 0, 0, 0, 2141, 2142, 3, 152, 76, 0, 2142, 2143, 6, 99, -1, 0, 2143, 2266, 1, 0, 0, 0, 2144, 2145, 3, 88, 44, 0, 2145, 2146, 6, 99, -1, 0, 2146, 2266, 1, 0, 0, 0, 2147, 2148, 3, 330, 165, 0, 2148, 2149, 6, 99, -1, 0, 2149, 2266, 1, 0, 0, 0, 2150, 2151, 5, 117, 0, 0, 2151, 2152, 3, 32, 16, 0, 2152, 2153, 6, 99, -1, 0, 2153, 2266, 1, 0, 0, 0, 2154, 2155, 5, 118, 0, 0, 2155, 2156, 3, 32, 16, 0, 2156, 2157, 6, 99, -1, 0, 2157, 2266, 1, 0, 0, 0, 2158, 2159, 3, 346, 173, 0, 2159, 2160, 5, 17, 0, 0, 2160, 2161, 3, 350, 175, 0, 2161, 2162, 5, 18, 0, 0, 2162, 2163, 6, 99, -1, 0, 2163, 2266, 1, 0, 0, 0, 2164, 2165, 5, 302, 0, 0, 2165, 2166, 3, 124, 62, 0, 2166, 2167, 5, 176, 0, 0, 2167, 2168, 3, 242, 121, 0, 2168, 2169, 5, 119, 0, 0, 2169, 2170, 3, 170, 85, 0, 2170, 2171, 3, 138, 69, 0, 2171, 2172, 3, 124, 62, 0, 2172, 2173, 5, 176, 0, 0, 2173, 2174, 3, 242, 121, 0, 2174, 2175, 3, 112, 56, 0, 2175, 2176, 6, 99, -1, 0, 2176, 2266, 1, 0, 0, 0, 2177, 2178, 5, 302, 0, 0, 2178, 2179, 5, 226, 0, 0, 2179, 2180, 3, 170, 85, 0, 2180, 2181, 3, 138, 69, 0, 2181, 2182, 3, 124, 62, 0, 2182, 2183, 5, 176, 0, 0, 2183, 2184, 3, 242, 121, 0, 2184, 2185, 3, 194, 97, 0, 2185, 2186, 3, 112, 56, 0, 2186, 2187, 5, 119, 0, 0, 2187, 2188, 5, 226, 0, 0, 2188, 2189, 3, 170, 85, 0, 2189, 2190, 3, 138, 69, 0, 2190, 2191, 3, 124, 62, 0, 2191, 2192, 5, 176, 0, 0, 2192, 2193, 3, 242, 121, 0, 2193, 2194, 3, 194, 97, 0, 2194, 2195, 3, 112, 56, 0, 2195, 2196, 6, 99, -1, 0, 2196, 2266, 1, 0, 0, 0, 2197, 2198, 3, 26, 13, 0, 2198, 2199, 6, 99, -1, 0, 2199, 2266, 1, 0, 0, 0, 2200, 2201, 3, 40, 20, 0, 2201, 2202, 6, 99, -1, 0, 2202, 2266, 1, 0, 0, 0, 2203, 2204, 5, 255, 0, 0, 2204, 2205, 5, 196, 0, 0, 2205, 2206, 5, 42, 0, 0, 2206, 2207, 3, 32, 16, 0, 2207, 2208, 5, 43, 0, 0, 2208, 2214, 6, 99, -1, 0, 2209, 2210, 3, 330, 165, 0, 2210, 2211, 6, 99, -1, 0, 2211, 2213, 1, 0, 0, 0, 2212, 2209, 1, 0, 0, 0, 2213, 2216, 1, 0, 0, 0, 2214, 2212, 1, 0, 0, 0, 2214, 2215, 1, 0, 0, 0, 2215, 2266, 1, 0, 0, 0, 2216, 2214, 1, 0, 0, 0, 2217, 2218, 5, 255, 0, 0, 2218, 2219, 5, 196, 0, 0, 2219, 2220, 3, 2, 1, 0, 2220, 2226, 6, 99, -1, 0, 2221, 2222, 3, 330, 165, 0, 2222, 2223, 6, 99, -1, 0, 2223, 2225, 1, 0, 0, 0, 2224, 2221, 1, 0, 0, 0, 2225, 2228, 1, 0, 0, 0, 2226, 2224, 1, 0, 0, 0, 2226, 2227, 1, 0, 0, 0, 2227, 2266, 1, 0, 0, 0, 2228, 2226, 1, 0, 0, 0, 2229, 2230, 5, 255, 0, 0, 2230, 2231, 5, 256, 0, 0, 2231, 2232, 5, 42, 0, 0, 2232, 2233, 3, 32, 16, 0, 2233, 2234, 5, 43, 0, 0, 2234, 2235, 5, 28, 0, 0, 2235, 2236, 3, 124, 62, 0, 2236, 2242, 6, 99, -1, 0, 2237, 2238, 3, 330, 165, 0, 2238, 2239, 6, 99, -1, 0, 2239, 2241, 1, 0, 0, 0, 2240, 2237, 1, 0, 0, 0, 2241, 2244, 1, 0, 0, 0, 2242, 2240, 1, 0, 0, 0, 2242, 2243, 1, 0, 0, 0, 2243, 2266, 1, 0, 0, 0, 2244, 2242, 1, 0, 0, 0, 2245, 2246, 5, 255, 0, 0, 2246, 2247, 5, 256, 0, 0, 2247, 2248, 3, 2, 1, 0, 2248, 2249, 5, 28, 0, 0, 2249, 2250, 3, 124, 62, 0, 2250, 2256, 6, 99, -1, 0, 2251, 2252, 3, 330, 165, 0, 2252, 2253, 6, 99, -1, 0, 2253, 2255, 1, 0, 0, 0, 2254, 2251, 1, 0, 0, 0, 2255, 2258, 1, 0, 0, 0, 2256, 2254, 1, 0, 0, 0, 2256, 2257, 1, 0, 0, 0, 2257, 2266, 1, 0, 0, 0, 2258, 2256, 1, 0, 0, 0, 2259, 2260, 5, 120, 0, 0, 2260, 2261, 5, 196, 0, 0, 2261, 2262, 3, 124, 62, 0, 2262, 2263, 3, 44, 22, 0, 2263, 2264, 6, 99, -1, 0, 2264, 2266, 1, 0, 0, 0, 2265, 2115, 1, 0, 0, 0, 2265, 2120, 1, 0, 0, 0, 2265, 2125, 1, 0, 0, 0, 2265, 2131, 1, 0, 0, 0, 2265, 2137, 1, 0, 0, 0, 2265, 2138, 1, 0, 0, 0, 2265, 2141, 1, 0, 0, 0, 2265, 2144, 1, 0, 0, 0, 2265, 2147, 1, 0, 0, 0, 2265, 2150, 1, 0, 0, 0, 2265, 2154, 1, 0, 0, 0, 2265, 2158, 1, 0, 0, 0, 2265, 2164, 1, 0, 0, 0, 2265, 2177, 1, 0, 0, 0, 2265, 2197, 1, 0, 0, 0, 2265, 2200, 1, 0, 0, 0, 2265, 2203, 1, 0, 0, 0, 2265, 2217, 1, 0, 0, 0, 2265, 2229, 1, 0, 0, 0, 2265, 2245, 1, 0, 0, 0, 2265, 2259, 1, 0, 0, 0, 2266, 199, 1, 0, 0, 0, 2267, 2268, 5, 121, 0, 0, 2268, 2280, 3, 208, 104, 0, 2269, 2270, 3, 202, 101, 0, 2270, 2271, 6, 100, -1, 0, 2271, 2279, 1, 0, 0, 0, 2272, 2273, 5, 122, 0, 0, 2273, 2274, 5, 30, 0, 0, 2274, 2275, 3, 228, 114, 0, 2275, 2276, 5, 31, 0, 0, 2276, 2277, 6, 100, -1, 0, 2277, 2279, 1, 0, 0, 0, 2278, 2269, 1, 0, 0, 0, 2278, 2272, 1, 0, 0, 0, 2279, 2282, 1, 0, 0, 0, 2280, 2278, 1, 0, 0, 0, 2280, 2281, 1, 0, 0, 0, 2281, 2283, 1, 0, 0, 0, 2282, 2280, 1, 0, 0, 0, 2283, 2284, 3, 138, 69, 0, 2284, 2285, 3, 2, 1, 0, 2285, 2286, 3, 204, 102, 0, 2286, 2287, 3, 206, 103, 0, 2287, 2288, 6, 100, -1, 0, 2288, 201, 1, 0, 0, 0, 2289, 2290, 5, 123, 0, 0, 2290, 2324, 6, 101, -1, 0, 2291, 2292, 5, 51, 0, 0, 2292, 2324, 6, 101, -1, 0, 2293, 2294, 5, 52, 0, 0, 2294, 2324, 6, 101, -1, 0, 2295, 2296, 5, 63, 0, 0, 2296, 2324, 6, 101, -1, 0, 2297, 2298, 5, 124, 0, 0, 2298, 2324, 6, 101, -1, 0, 2299, 2300, 5, 69, 0, 0, 2300, 2324, 6, 101, -1, 0, 2301, 2302, 5, 68, 0, 0, 2302, 2324, 6, 101, -1, 0, 2303, 2304, 5, 64, 0, 0, 2304, 2324, 6, 101, -1, 0, 2305, 2306, 5, 65, 0, 0, 2306, 2324, 6, 101, -1, 0, 2307, 2308, 5, 66, 0, 0, 2308, 2324, 6, 101, -1, 0, 2309, 2310, 5, 125, 0, 0, 2310, 2324, 6, 101, -1, 0, 2311, 2312, 5, 126, 0, 0, 2312, 2324, 6, 101, -1, 0, 2313, 2314, 5, 127, 0, 0, 2314, 2324, 6, 101, -1, 0, 2315, 2316, 5, 16, 0, 0, 2316, 2324, 6, 101, -1, 0, 2317, 2318, 5, 70, 0, 0, 2318, 2319, 5, 30, 0, 0, 2319, 2320, 3, 32, 16, 0, 2320, 2321, 5, 31, 0, 0, 2321, 2322, 6, 101, -1, 0, 2322, 2324, 1, 0, 0, 0, 2323, 2289, 1, 0, 0, 0, 2323, 2291, 1, 0, 0, 0, 2323, 2293, 1, 0, 0, 0, 2323, 2295, 1, 0, 0, 0, 2323, 2297, 1, 0, 0, 0, 2323, 2299, 1, 0, 0, 0, 2323, 2301, 1, 0, 0, 0, 2323, 2303, 1, 0, 0, 0, 2323, 2305, 1, 0, 0, 0, 2323, 2307, 1, 0, 0, 0, 2323, 2309, 1, 0, 0, 0, 2323, 2311, 1, 0, 0, 0, 2323, 2313, 1, 0, 0, 0, 2323, 2315, 1, 0, 0, 0, 2323, 2317, 1, 0, 0, 0, 2324, 203, 1, 0, 0, 0, 2325, 2335, 1, 0, 0, 0, 2326, 2327, 5, 44, 0, 0, 2327, 2328, 3, 0, 0, 0, 2328, 2329, 6, 102, -1, 0, 2329, 2335, 1, 0, 0, 0, 2330, 2331, 5, 44, 0, 0, 2331, 2332, 3, 32, 16, 0, 2332, 2333, 6, 102, -1, 0, 2333, 2335, 1, 0, 0, 0, 2334, 2325, 1, 0, 0, 0, 2334, 2326, 1, 0, 0, 0, 2334, 2330, 1, 0, 0, 0, 2335, 205, 1, 0, 0, 0, 2336, 2342, 1, 0, 0, 0, 2337, 2338, 5, 36, 0, 0, 2338, 2339, 3, 304, 152, 0, 2339, 2340, 6, 103, -1, 0, 2340, 2342, 1, 0, 0, 0, 2341, 2336, 1, 0, 0, 0, 2341, 2337, 1, 0, 0, 0, 2342, 207, 1, 0, 0, 0, 2343, 2350, 1, 0, 0, 0, 2344, 2345, 5, 42, 0, 0, 2345, 2346, 3, 32, 16, 0, 2346, 2347, 5, 43, 0, 0, 2347, 2348, 6, 104, -1, 0, 2348, 2350, 1, 0, 0, 0, 2349, 2343, 1, 0, 0, 0, 2349, 2344, 1, 0, 0, 0, 2350, 209, 1, 0, 0, 0, 2351, 2357, 5, 128, 0, 0, 2352, 2353, 3, 212, 106, 0, 2353, 2354, 6, 105, -1, 0, 2354, 2356, 1, 0, 0, 0, 2355, 2352, 1, 0, 0, 0, 2356, 2359, 1, 0, 0, 0, 2357, 2355, 1, 0, 0, 0, 2357, 2358, 1, 0, 0, 0, 2358, 2360, 1, 0, 0, 0, 2359, 2357, 1, 0, 0, 0, 2360, 2361, 3, 124, 62, 0, 2361, 2362, 3, 2, 1, 0, 2362, 2363, 6, 105, -1, 0, 2363, 2377, 1, 0, 0, 0, 2364, 2370, 5, 128, 0, 0, 2365, 2366, 3, 212, 106, 0, 2366, 2367, 6, 105, -1, 0, 2367, 2369, 1, 0, 0, 0, 2368, 2365, 1, 0, 0, 0, 2369, 2372, 1, 0, 0, 0, 2370, 2368, 1, 0, 0, 0, 2370, 2371, 1, 0, 0, 0, 2371, 2373, 1, 0, 0, 0, 2372, 2370, 1, 0, 0, 0, 2373, 2374, 3, 2, 1, 0, 2374, 2375, 6, 105, -1, 0, 2375, 2377, 1, 0, 0, 0, 2376, 2351, 1, 0, 0, 0, 2376, 2364, 1, 0, 0, 0, 2377, 211, 1, 0, 0, 0, 2378, 2379, 5, 69, 0, 0, 2379, 2383, 6, 106, -1, 0, 2380, 2381, 5, 68, 0, 0, 2381, 2383, 6, 106, -1, 0, 2382, 2378, 1, 0, 0, 0, 2382, 2380, 1, 0, 0, 0, 2383, 213, 1, 0, 0, 0, 2384, 2386, 3, 216, 108, 0, 2385, 2384, 1, 0, 0, 0, 2386, 2389, 1, 0, 0, 0, 2387, 2385, 1, 0, 0, 0, 2387, 2388, 1, 0, 0, 0, 2388, 215, 1, 0, 0, 0, 2389, 2387, 1, 0, 0, 0, 2390, 2391, 5, 129, 0, 0, 2391, 2392, 3, 168, 84, 0, 2392, 2393, 6, 108, -1, 0, 2393, 2417, 1, 0, 0, 0, 2394, 2395, 5, 130, 0, 0, 2395, 2396, 3, 168, 84, 0, 2396, 2397, 6, 108, -1, 0, 2397, 2417, 1, 0, 0, 0, 2398, 2399, 5, 131, 0, 0, 2399, 2400, 3, 168, 84, 0, 2400, 2401, 6, 108, -1, 0, 2401, 2417, 1, 0, 0, 0, 2402, 2403, 5, 132, 0, 0, 2403, 2404, 3, 168, 84, 0, 2404, 2405, 6, 108, -1, 0, 2405, 2417, 1, 0, 0, 0, 2406, 2407, 3, 88, 44, 0, 2407, 2408, 6, 108, -1, 0, 2408, 2417, 1, 0, 0, 0, 2409, 2410, 3, 330, 165, 0, 2410, 2411, 6, 108, -1, 0, 2411, 2417, 1, 0, 0, 0, 2412, 2413, 3, 26, 13, 0, 2413, 2414, 6, 108, -1, 0, 2414, 2417, 1, 0, 0, 0, 2415, 2417, 3, 40, 20, 0, 2416, 2390, 1, 0, 0, 0, 2416, 2394, 1, 0, 0, 0, 2416, 2398, 1, 0, 0, 0, 2416, 2402, 1, 0, 0, 0, 2416, 2406, 1, 0, 0, 0, 2416, 2409, 1, 0, 0, 0, 2416, 2412, 1, 0, 0, 0, 2416, 2415, 1, 0, 0, 0, 2417, 217, 1, 0, 0, 0, 2418, 2424, 5, 133, 0, 0, 2419, 2420, 3, 220, 110, 0, 2420, 2421, 6, 109, -1, 0, 2421, 2423, 1, 0, 0, 0, 2422, 2419, 1, 0, 0, 0, 2423, 2426, 1, 0, 0, 0, 2424, 2422, 1, 0, 0, 0, 2424, 2425, 1, 0, 0, 0, 2425, 2427, 1, 0, 0, 0, 2426, 2424, 1, 0, 0, 0, 2427, 2428, 3, 170, 85, 0, 2428, 2429, 3, 138, 69, 0, 2429, 2430, 3, 2, 1, 0, 2430, 2431, 3, 112, 56, 0, 2431, 2432, 3, 206, 103, 0, 2432, 2433, 6, 109, -1, 0, 2433, 219, 1, 0, 0, 0, 2434, 2435, 5, 69, 0, 0, 2435, 2439, 6, 110, -1, 0, 2436, 2437, 5, 68, 0, 0, 2437, 2439, 6, 110, -1, 0, 2438, 2434, 1, 0, 0, 0, 2438, 2436, 1, 0, 0, 0, 2439, 221, 1, 0, 0, 0, 2440, 2442, 3, 224, 112, 0, 2441, 2440, 1, 0, 0, 0, 2442, 2445, 1, 0, 0, 0, 2443, 2441, 1, 0, 0, 0, 2443, 2444, 1, 0, 0, 0, 2444, 223, 1, 0, 0, 0, 2445, 2443, 1, 0, 0, 0, 2446, 2447, 5, 134, 0, 0, 2447, 2448, 3, 168, 84, 0, 2448, 2449, 6, 112, -1, 0, 2449, 2469, 1, 0, 0, 0, 2450, 2451, 5, 135, 0, 0, 2451, 2452, 3, 168, 84, 0, 2452, 2453, 6, 112, -1, 0, 2453, 2469, 1, 0, 0, 0, 2454, 2455, 5, 132, 0, 0, 2455, 2456, 3, 168, 84, 0, 2456, 2457, 6, 112, -1, 0, 2457, 2469, 1, 0, 0, 0, 2458, 2459, 3, 330, 165, 0, 2459, 2460, 6, 112, -1, 0, 2460, 2469, 1, 0, 0, 0, 2461, 2462, 3, 88, 44, 0, 2462, 2463, 6, 112, -1, 0, 2463, 2469, 1, 0, 0, 0, 2464, 2465, 3, 26, 13, 0, 2465, 2466, 6, 112, -1, 0, 2466, 2469, 1, 0, 0, 0, 2467, 2469, 3, 40, 20, 0, 2468, 2446, 1, 0, 0, 0, 2468, 2450, 1, 0, 0, 0, 2468, 2454, 1, 0, 0, 0, 2468, 2458, 1, 0, 0, 0, 2468, 2461, 1, 0, 0, 0, 2468, 2464, 1, 0, 0, 0, 2468, 2467, 1, 0, 0, 0, 2469, 225, 1, 0, 0, 0, 2470, 2478, 6, 113, -1, 0, 2471, 2472, 5, 122, 0, 0, 2472, 2473, 5, 30, 0, 0, 2473, 2474, 3, 228, 114, 0, 2474, 2475, 5, 31, 0, 0, 2475, 2476, 6, 113, -1, 0, 2476, 2478, 1, 0, 0, 0, 2477, 2470, 1, 0, 0, 0, 2477, 2471, 1, 0, 0, 0, 2478, 227, 1, 0, 0, 0, 2479, 2480, 3, 126, 63, 0, 2480, 2481, 6, 114, -1, 0, 2481, 2493, 1, 0, 0, 0, 2482, 2486, 5, 17, 0, 0, 2483, 2484, 3, 302, 151, 0, 2484, 2485, 6, 114, -1, 0, 2485, 2487, 1, 0, 0, 0, 2486, 2483, 1, 0, 0, 0, 2487, 2488, 1, 0, 0, 0, 2488, 2486, 1, 0, 0, 0, 2488, 2489, 1, 0, 0, 0, 2489, 2490, 1, 0, 0, 0, 2490, 2491, 5, 18, 0, 0, 2491, 2493, 1, 0, 0, 0, 2492, 2479, 1, 0, 0, 0, 2492, 2482, 1, 0, 0, 0, 2493, 229, 1, 0, 0, 0, 2494, 2495, 3, 232, 116, 0, 2495, 2496, 6, 115, -1, 0, 2496, 2498, 1, 0, 0, 0, 2497, 2494, 1, 0, 0, 0, 2498, 2501, 1, 0, 0, 0, 2499, 2497, 1, 0, 0, 0, 2499, 2500, 1, 0, 0, 0, 2500, 231, 1, 0, 0, 0, 2501, 2499, 1, 0, 0, 0, 2502, 2503, 5, 42, 0, 0, 2503, 2504, 5, 136, 0, 0, 2504, 2505, 5, 43, 0, 0, 2505, 2520, 6, 116, -1, 0, 2506, 2507, 5, 42, 0, 0, 2507, 2508, 5, 137, 0, 0, 2508, 2509, 5, 43, 0, 0, 2509, 2520, 6, 116, -1, 0, 2510, 2511, 5, 42, 0, 0, 2511, 2512, 5, 138, 0, 0, 2512, 2513, 5, 43, 0, 0, 2513, 2520, 6, 116, -1, 0, 2514, 2515, 5, 42, 0, 0, 2515, 2516, 3, 32, 16, 0, 2516, 2517, 5, 43, 0, 0, 2517, 2518, 6, 116, -1, 0, 2518, 2520, 1, 0, 0, 0, 2519, 2502, 1, 0, 0, 0, 2519, 2506, 1, 0, 0, 0, 2519, 2510, 1, 0, 0, 0, 2519, 2514, 1, 0, 0, 0, 2520, 233, 1, 0, 0, 0, 2521, 2530, 5, 139, 0, 0, 2522, 2523, 3, 236, 118, 0, 2523, 2524, 6, 117, -1, 0, 2524, 2529, 1, 0, 0, 0, 2525, 2526, 3, 238, 119, 0, 2526, 2527, 6, 117, -1, 0, 2527, 2529, 1, 0, 0, 0, 2528, 2522, 1, 0, 0, 0, 2528, 2525, 1, 0, 0, 0, 2529, 2532, 1, 0, 0, 0, 2530, 2528, 1, 0, 0, 0, 2530, 2531, 1, 0, 0, 0, 2531, 2533, 1, 0, 0, 0, 2532, 2530, 1, 0, 0, 0, 2533, 2534, 3, 170, 85, 0, 2534, 2535, 3, 230, 115, 0, 2535, 2536, 3, 138, 69, 0, 2536, 2537, 3, 226, 113, 0, 2537, 2538, 3, 242, 121, 0, 2538, 2539, 3, 182, 91, 0, 2539, 2545, 3, 112, 56, 0, 2540, 2541, 3, 244, 122, 0, 2541, 2542, 6, 117, -1, 0, 2542, 2544, 1, 0, 0, 0, 2543, 2540, 1, 0, 0, 0, 2544, 2547, 1, 0, 0, 0, 2545, 2543, 1, 0, 0, 0, 2545, 2546, 1, 0, 0, 0, 2546, 2548, 1, 0, 0, 0, 2547, 2545, 1, 0, 0, 0, 2548, 2549, 6, 117, -1, 0, 2549, 235, 1, 0, 0, 0, 2550, 2551, 5, 123, 0, 0, 2551, 2593, 6, 118, -1, 0, 2552, 2553, 5, 51, 0, 0, 2553, 2593, 6, 118, -1, 0, 2554, 2555, 5, 52, 0, 0, 2555, 2593, 6, 118, -1, 0, 2556, 2557, 5, 63, 0, 0, 2557, 2593, 6, 118, -1, 0, 2558, 2559, 5, 140, 0, 0, 2559, 2593, 6, 118, -1, 0, 2560, 2561, 5, 68, 0, 0, 2561, 2593, 6, 118, -1, 0, 2562, 2563, 5, 141, 0, 0, 2563, 2593, 6, 118, -1, 0, 2564, 2565, 5, 142, 0, 0, 2565, 2593, 6, 118, -1, 0, 2566, 2567, 5, 54, 0, 0, 2567, 2593, 6, 118, -1, 0, 2568, 2569, 5, 64, 0, 0, 2569, 2593, 6, 118, -1, 0, 2570, 2571, 5, 65, 0, 0, 2571, 2593, 6, 118, -1, 0, 2572, 2573, 5, 66, 0, 0, 2573, 2593, 6, 118, -1, 0, 2574, 2575, 5, 125, 0, 0, 2575, 2593, 6, 118, -1, 0, 2576, 2577, 5, 143, 0, 0, 2577, 2593, 6, 118, -1, 0, 2578, 2579, 5, 144, 0, 0, 2579, 2593, 6, 118, -1, 0, 2580, 2581, 5, 69, 0, 0, 2581, 2593, 6, 118, -1, 0, 2582, 2583, 5, 145, 0, 0, 2583, 2593, 6, 118, -1, 0, 2584, 2585, 5, 146, 0, 0, 2585, 2593, 6, 118, -1, 0, 2586, 2587, 5, 70, 0, 0, 2587, 2588, 5, 30, 0, 0, 2588, 2589, 3, 32, 16, 0, 2589, 2590, 5, 31, 0, 0, 2590, 2591, 6, 118, -1, 0, 2591, 2593, 1, 0, 0, 0, 2592, 2550, 1, 0, 0, 0, 2592, 2552, 1, 0, 0, 0, 2592, 2554, 1, 0, 0, 0, 2592, 2556, 1, 0, 0, 0, 2592, 2558, 1, 0, 0, 0, 2592, 2560, 1, 0, 0, 0, 2592, 2562, 1, 0, 0, 0, 2592, 2564, 1, 0, 0, 0, 2592, 2566, 1, 0, 0, 0, 2592, 2568, 1, 0, 0, 0, 2592, 2570, 1, 0, 0, 0, 2592, 2572, 1, 0, 0, 0, 2592, 2574, 1, 0, 0, 0, 2592, 2576, 1, 0, 0, 0, 2592, 2578, 1, 0, 0, 0, 2592, 2580, 1, 0, 0, 0, 2592, 2582, 1, 0, 0, 0, 2592, 2584, 1, 0, 0, 0, 2592, 2586, 1, 0, 0, 0, 2593, 237, 1, 0, 0, 0, 2594, 2595, 5, 147, 0, 0, 2595, 2604, 5, 30, 0, 0, 2596, 2597, 3, 6, 3, 0, 2597, 2602, 6, 119, -1, 0, 2598, 2599, 5, 34, 0, 0, 2599, 2600, 3, 6, 3, 0, 2600, 2601, 6, 119, -1, 0, 2601, 2603, 1, 0, 0, 0, 2602, 2598, 1, 0, 0, 0, 2602, 2603, 1, 0, 0, 0, 2603, 2605, 1, 0, 0, 0, 2604, 2596, 1, 0, 0, 0, 2604, 2605, 1, 0, 0, 0, 2605, 2611, 1, 0, 0, 0, 2606, 2607, 3, 240, 120, 0, 2607, 2608, 6, 119, -1, 0, 2608, 2610, 1, 0, 0, 0, 2609, 2606, 1, 0, 0, 0, 2610, 2613, 1, 0, 0, 0, 2611, 2609, 1, 0, 0, 0, 2611, 2612, 1, 0, 0, 0, 2612, 2614, 1, 0, 0, 0, 2613, 2611, 1, 0, 0, 0, 2614, 2618, 5, 31, 0, 0, 2615, 2616, 5, 147, 0, 0, 2616, 2618, 5, 85, 0, 0, 2617, 2594, 1, 0, 0, 0, 2617, 2615, 1, 0, 0, 0, 2618, 239, 1, 0, 0, 0, 2619, 2620, 5, 148, 0, 0, 2620, 2662, 6, 120, -1, 0, 2621, 2622, 5, 224, 0, 0, 2622, 2662, 6, 120, -1, 0, 2623, 2624, 5, 57, 0, 0, 2624, 2662, 6, 120, -1, 0, 2625, 2626, 5, 58, 0, 0, 2626, 2662, 6, 120, -1, 0, 2627, 2628, 5, 149, 0, 0, 2628, 2662, 6, 120, -1, 0, 2629, 2630, 5, 150, 0, 0, 2630, 2662, 6, 120, -1, 0, 2631, 2632, 5, 248, 0, 0, 2632, 2662, 6, 120, -1, 0, 2633, 2634, 5, 249, 0, 0, 2634, 2662, 6, 120, -1, 0, 2635, 2636, 5, 250, 0, 0, 2636, 2662, 6, 120, -1, 0, 2637, 2638, 5, 251, 0, 0, 2638, 2662, 6, 120, -1, 0, 2639, 2640, 5, 151, 0, 0, 2640, 2641, 5, 75, 0, 0, 2641, 2642, 5, 152, 0, 0, 2642, 2662, 6, 120, -1, 0, 2643, 2644, 5, 151, 0, 0, 2644, 2645, 5, 75, 0, 0, 2645, 2646, 5, 153, 0, 0, 2646, 2662, 6, 120, -1, 0, 2647, 2648, 5, 154, 0, 0, 2648, 2649, 5, 75, 0, 0, 2649, 2650, 5, 152, 0, 0, 2650, 2662, 6, 120, -1, 0, 2651, 2652, 5, 154, 0, 0, 2652, 2653, 5, 75, 0, 0, 2653, 2654, 5, 153, 0, 0, 2654, 2662, 6, 120, -1, 0, 2655, 2656, 5, 70, 0, 0, 2656, 2657, 5, 30, 0, 0, 2657, 2658, 3, 32, 16, 0, 2658, 2659, 5, 31, 0, 0, 2659, 2660, 6, 120, -1, 0, 2660, 2662, 1, 0, 0, 0, 2661, 2619, 1, 0, 0, 0, 2661, 2621, 1, 0, 0, 0, 2661, 2623, 1, 0, 0, 0, 2661, 2625, 1, 0, 0, 0, 2661, 2627, 1, 0, 0, 0, 2661, 2629, 1, 0, 0, 0, 2661, 2631, 1, 0, 0, 0, 2661, 2633, 1, 0, 0, 0, 2661, 2635, 1, 0, 0, 0, 2661, 2637, 1, 0, 0, 0, 2661, 2639, 1, 0, 0, 0, 2661, 2643, 1, 0, 0, 0, 2661, 2647, 1, 0, 0, 0, 2661, 2651, 1, 0, 0, 0, 2661, 2655, 1, 0, 0, 0, 2662, 241, 1, 0, 0, 0, 2663, 2664, 5, 116, 0, 0, 2664, 2671, 6, 121, -1, 0, 2665, 2666, 5, 155, 0, 0, 2666, 2671, 6, 121, -1, 0, 2667, 2668, 3, 2, 1, 0, 2668, 2669, 6, 121, -1, 0, 2669, 2671, 1, 0, 0, 0, 2670, 2663, 1, 0, 0, 0, 2670, 2665, 1, 0, 0, 0, 2670, 2667, 1, 0, 0, 0, 2671, 243, 1, 0, 0, 0, 2672, 2673, 5, 1, 0, 0, 2673, 2711, 6, 122, -1, 0, 2674, 2675, 5, 2, 0, 0, 2675, 2711, 6, 122, -1, 0, 2676, 2677, 5, 156, 0, 0, 2677, 2711, 6, 122, -1, 0, 2678, 2679, 5, 3, 0, 0, 2679, 2711, 6, 122, -1, 0, 2680, 2681, 5, 4, 0, 0, 2681, 2711, 6, 122, -1, 0, 2682, 2683, 5, 247, 0, 0, 2683, 2711, 6, 122, -1, 0, 2684, 2685, 5, 5, 0, 0, 2685, 2711, 6, 122, -1, 0, 2686, 2687, 5, 6, 0, 0, 2687, 2711, 6, 122, -1, 0, 2688, 2689, 5, 7, 0, 0, 2689, 2711, 6, 122, -1, 0, 2690, 2691, 5, 8, 0, 0, 2691, 2711, 6, 122, -1, 0, 2692, 2693, 5, 9, 0, 0, 2693, 2711, 6, 122, -1, 0, 2694, 2695, 5, 10, 0, 0, 2695, 2711, 6, 122, -1, 0, 2696, 2697, 5, 11, 0, 0, 2697, 2711, 6, 122, -1, 0, 2698, 2699, 5, 12, 0, 0, 2699, 2711, 6, 122, -1, 0, 2700, 2701, 5, 13, 0, 0, 2701, 2711, 6, 122, -1, 0, 2702, 2703, 5, 14, 0, 0, 2703, 2711, 6, 122, -1, 0, 2704, 2705, 5, 70, 0, 0, 2705, 2706, 5, 30, 0, 0, 2706, 2707, 3, 32, 16, 0, 2707, 2708, 5, 31, 0, 0, 2708, 2709, 6, 122, -1, 0, 2709, 2711, 1, 0, 0, 0, 2710, 2672, 1, 0, 0, 0, 2710, 2674, 1, 0, 0, 0, 2710, 2676, 1, 0, 0, 0, 2710, 2678, 1, 0, 0, 0, 2710, 2680, 1, 0, 0, 0, 2710, 2682, 1, 0, 0, 0, 2710, 2684, 1, 0, 0, 0, 2710, 2686, 1, 0, 0, 0, 2710, 2688, 1, 0, 0, 0, 2710, 2690, 1, 0, 0, 0, 2710, 2692, 1, 0, 0, 0, 2710, 2694, 1, 0, 0, 0, 2710, 2696, 1, 0, 0, 0, 2710, 2698, 1, 0, 0, 0, 2710, 2700, 1, 0, 0, 0, 2710, 2702, 1, 0, 0, 0, 2710, 2704, 1, 0, 0, 0, 2711, 245, 1, 0, 0, 0, 2712, 2714, 3, 248, 124, 0, 2713, 2712, 1, 0, 0, 0, 2714, 2717, 1, 0, 0, 0, 2715, 2713, 1, 0, 0, 0, 2715, 2716, 1, 0, 0, 0, 2716, 247, 1, 0, 0, 0, 2717, 2715, 1, 0, 0, 0, 2718, 2756, 3, 100, 50, 0, 2719, 2720, 5, 296, 0, 0, 2720, 2721, 3, 32, 16, 0, 2721, 2722, 6, 124, -1, 0, 2722, 2756, 1, 0, 0, 0, 2723, 2756, 3, 266, 133, 0, 2724, 2725, 5, 297, 0, 0, 2725, 2726, 3, 32, 16, 0, 2726, 2727, 6, 124, -1, 0, 2727, 2756, 1, 0, 0, 0, 2728, 2729, 5, 298, 0, 0, 2729, 2756, 6, 124, -1, 0, 2730, 2731, 5, 299, 0, 0, 2731, 2756, 6, 124, -1, 0, 2732, 2756, 3, 260, 130, 0, 2733, 2756, 3, 264, 132, 0, 2734, 2756, 3, 250, 125, 0, 2735, 2736, 3, 284, 142, 0, 2736, 2737, 6, 124, -1, 0, 2737, 2756, 1, 0, 0, 0, 2738, 2739, 3, 152, 76, 0, 2739, 2740, 6, 124, -1, 0, 2740, 2756, 1, 0, 0, 0, 2741, 2742, 3, 88, 44, 0, 2742, 2743, 6, 124, -1, 0, 2743, 2756, 1, 0, 0, 0, 2744, 2745, 3, 26, 13, 0, 2745, 2746, 6, 124, -1, 0, 2746, 2756, 1, 0, 0, 0, 2747, 2748, 3, 262, 131, 0, 2748, 2749, 6, 124, -1, 0, 2749, 2756, 1, 0, 0, 0, 2750, 2756, 3, 40, 20, 0, 2751, 2756, 3, 252, 126, 0, 2752, 2756, 3, 254, 127, 0, 2753, 2756, 3, 256, 128, 0, 2754, 2756, 3, 258, 129, 0, 2755, 2718, 1, 0, 0, 0, 2755, 2719, 1, 0, 0, 0, 2755, 2723, 1, 0, 0, 0, 2755, 2724, 1, 0, 0, 0, 2755, 2728, 1, 0, 0, 0, 2755, 2730, 1, 0, 0, 0, 2755, 2732, 1, 0, 0, 0, 2755, 2733, 1, 0, 0, 0, 2755, 2734, 1, 0, 0, 0, 2755, 2735, 1, 0, 0, 0, 2755, 2738, 1, 0, 0, 0, 2755, 2741, 1, 0, 0, 0, 2755, 2744, 1, 0, 0, 0, 2755, 2747, 1, 0, 0, 0, 2755, 2750, 1, 0, 0, 0, 2755, 2751, 1, 0, 0, 0, 2755, 2752, 1, 0, 0, 0, 2755, 2753, 1, 0, 0, 0, 2755, 2754, 1, 0, 0, 0, 2756, 249, 1, 0, 0, 0, 2757, 2759, 5, 300, 0, 0, 2758, 2760, 5, 157, 0, 0, 2759, 2758, 1, 0, 0, 0, 2759, 2760, 1, 0, 0, 0, 2760, 2761, 1, 0, 0, 0, 2761, 2762, 3, 112, 56, 0, 2762, 251, 1, 0, 0, 0, 2763, 2764, 5, 301, 0, 0, 2764, 2765, 5, 42, 0, 0, 2765, 2766, 3, 32, 16, 0, 2766, 2769, 5, 43, 0, 0, 2767, 2768, 5, 34, 0, 0, 2768, 2770, 3, 0, 0, 0, 2769, 2767, 1, 0, 0, 0, 2769, 2770, 1, 0, 0, 0, 2770, 253, 1, 0, 0, 0, 2771, 2772, 5, 303, 0, 0, 2772, 2773, 3, 32, 16, 0, 2773, 2774, 5, 75, 0, 0, 2774, 2775, 3, 32, 16, 0, 2775, 255, 1, 0, 0, 0, 2776, 2777, 5, 302, 0, 0, 2777, 2778, 3, 124, 62, 0, 2778, 2779, 5, 176, 0, 0, 2779, 2780, 3, 242, 121, 0, 2780, 2792, 1, 0, 0, 0, 2781, 2782, 5, 302, 0, 0, 2782, 2783, 5, 226, 0, 0, 2783, 2784, 3, 170, 85, 0, 2784, 2785, 3, 138, 69, 0, 2785, 2786, 3, 124, 62, 0, 2786, 2787, 5, 176, 0, 0, 2787, 2788, 3, 242, 121, 0, 2788, 2789, 3, 194, 97, 0, 2789, 2790, 3, 112, 56, 0, 2790, 2792, 1, 0, 0, 0, 2791, 2776, 1, 0, 0, 0, 2791, 2781, 1, 0, 0, 0, 2792, 257, 1, 0, 0, 0, 2793, 2794, 5, 255, 0, 0, 2794, 2795, 5, 196, 0, 0, 2795, 2796, 5, 42, 0, 0, 2796, 2797, 3, 32, 16, 0, 2797, 2803, 5, 43, 0, 0, 2798, 2799, 3, 330, 165, 0, 2799, 2800, 6, 129, -1, 0, 2800, 2802, 1, 0, 0, 0, 2801, 2798, 1, 0, 0, 0, 2802, 2805, 1, 0, 0, 0, 2803, 2801, 1, 0, 0, 0, 2803, 2804, 1, 0, 0, 0, 2804, 2859, 1, 0, 0, 0, 2805, 2803, 1, 0, 0, 0, 2806, 2807, 5, 255, 0, 0, 2807, 2808, 5, 196, 0, 0, 2808, 2814, 3, 2, 1, 0, 2809, 2810, 3, 330, 165, 0, 2810, 2811, 6, 129, -1, 0, 2811, 2813, 1, 0, 0, 0, 2812, 2809, 1, 0, 0, 0, 2813, 2816, 1, 0, 0, 0, 2814, 2812, 1, 0, 0, 0, 2814, 2815, 1, 0, 0, 0, 2815, 2859, 1, 0, 0, 0, 2816, 2814, 1, 0, 0, 0, 2817, 2818, 5, 255, 0, 0, 2818, 2819, 5, 256, 0, 0, 2819, 2820, 5, 42, 0, 0, 2820, 2821, 3, 32, 16, 0, 2821, 2822, 5, 43, 0, 0, 2822, 2823, 5, 28, 0, 0, 2823, 2829, 3, 124, 62, 0, 2824, 2825, 3, 330, 165, 0, 2825, 2826, 6, 129, -1, 0, 2826, 2828, 1, 0, 0, 0, 2827, 2824, 1, 0, 0, 0, 2828, 2831, 1, 0, 0, 0, 2829, 2827, 1, 0, 0, 0, 2829, 2830, 1, 0, 0, 0, 2830, 2859, 1, 0, 0, 0, 2831, 2829, 1, 0, 0, 0, 2832, 2833, 5, 255, 0, 0, 2833, 2834, 5, 256, 0, 0, 2834, 2835, 3, 2, 1, 0, 2835, 2836, 5, 28, 0, 0, 2836, 2842, 3, 124, 62, 0, 2837, 2838, 3, 330, 165, 0, 2838, 2839, 6, 129, -1, 0, 2839, 2841, 1, 0, 0, 0, 2840, 2837, 1, 0, 0, 0, 2841, 2844, 1, 0, 0, 0, 2842, 2840, 1, 0, 0, 0, 2842, 2843, 1, 0, 0, 0, 2843, 2859, 1, 0, 0, 0, 2844, 2842, 1, 0, 0, 0, 2845, 2846, 5, 255, 0, 0, 2846, 2847, 5, 42, 0, 0, 2847, 2848, 3, 32, 16, 0, 2848, 2849, 5, 43, 0, 0, 2849, 2855, 3, 206, 103, 0, 2850, 2851, 3, 330, 165, 0, 2851, 2852, 6, 129, -1, 0, 2852, 2854, 1, 0, 0, 0, 2853, 2850, 1, 0, 0, 0, 2854, 2857, 1, 0, 0, 0, 2855, 2853, 1, 0, 0, 0, 2855, 2856, 1, 0, 0, 0, 2856, 2859, 1, 0, 0, 0, 2857, 2855, 1, 0, 0, 0, 2858, 2793, 1, 0, 0, 0, 2858, 2806, 1, 0, 0, 0, 2858, 2817, 1, 0, 0, 0, 2858, 2832, 1, 0, 0, 0, 2858, 2845, 1, 0, 0, 0, 2859, 259, 1, 0, 0, 0, 2860, 2861, 3, 0, 0, 0, 2861, 2862, 5, 75, 0, 0, 2862, 2863, 6, 130, -1, 0, 2863, 261, 1, 0, 0, 0, 2864, 2865, 3, 44, 22, 0, 2865, 2866, 6, 131, -1, 0, 2866, 2871, 1, 0, 0, 0, 2867, 2868, 3, 46, 23, 0, 2868, 2869, 6, 131, -1, 0, 2869, 2871, 1, 0, 0, 0, 2870, 2864, 1, 0, 0, 0, 2870, 2867, 1, 0, 0, 0, 2871, 263, 1, 0, 0, 0, 2872, 2873, 5, 17, 0, 0, 2873, 2874, 3, 246, 123, 0, 2874, 2875, 5, 18, 0, 0, 2875, 265, 1, 0, 0, 0, 2876, 2877, 3, 270, 135, 0, 2877, 2878, 3, 268, 134, 0, 2878, 267, 1, 0, 0, 0, 2879, 2880, 3, 272, 136, 0, 2880, 2881, 6, 134, -1, 0, 2881, 2883, 1, 0, 0, 0, 2882, 2879, 1, 0, 0, 0, 2883, 2884, 1, 0, 0, 0, 2884, 2882, 1, 0, 0, 0, 2884, 2885, 1, 0, 0, 0, 2885, 269, 1, 0, 0, 0, 2886, 2887, 5, 158, 0, 0, 2887, 2888, 3, 264, 132, 0, 2888, 2889, 6, 135, -1, 0, 2889, 2903, 1, 0, 0, 0, 2890, 2891, 5, 158, 0, 0, 2891, 2892, 3, 0, 0, 0, 2892, 2893, 5, 159, 0, 0, 2893, 2894, 3, 0, 0, 0, 2894, 2895, 6, 135, -1, 0, 2895, 2903, 1, 0, 0, 0, 2896, 2897, 5, 158, 0, 0, 2897, 2898, 3, 32, 16, 0, 2898, 2899, 5, 159, 0, 0, 2899, 2900, 3, 32, 16, 0, 2900, 2901, 6, 135, -1, 0, 2901, 2903, 1, 0, 0, 0, 2902, 2886, 1, 0, 0, 0, 2902, 2890, 1, 0, 0, 0, 2902, 2896, 1, 0, 0, 0, 2903, 271, 1, 0, 0, 0, 2904, 2905, 3, 276, 138, 0, 2905, 2906, 3, 282, 141, 0, 2906, 2907, 6, 136, -1, 0, 2907, 2921, 1, 0, 0, 0, 2908, 2909, 3, 274, 137, 0, 2909, 2910, 3, 282, 141, 0, 2910, 2911, 6, 136, -1, 0, 2911, 2921, 1, 0, 0, 0, 2912, 2913, 3, 278, 139, 0, 2913, 2914, 3, 282, 141, 0, 2914, 2915, 6, 136, -1, 0, 2915, 2921, 1, 0, 0, 0, 2916, 2917, 3, 280, 140, 0, 2917, 2918, 3, 282, 141, 0, 2918, 2919, 6, 136, -1, 0, 2919, 2921, 1, 0, 0, 0, 2920, 2904, 1, 0, 0, 0, 2920, 2908, 1, 0, 0, 0, 2920, 2912, 1, 0, 0, 0, 2920, 2916, 1, 0, 0, 0, 2921, 273, 1, 0, 0, 0, 2922, 2923, 5, 160, 0, 0, 2923, 2924, 3, 264, 132, 0, 2924, 2925, 6, 137, -1, 0, 2925, 2935, 1, 0, 0, 0, 2926, 2927, 5, 160, 0, 0, 2927, 2928, 3, 0, 0, 0, 2928, 2929, 6, 137, -1, 0, 2929, 2935, 1, 0, 0, 0, 2930, 2931, 5, 160, 0, 0, 2931, 2932, 3, 32, 16, 0, 2932, 2933, 6, 137, -1, 0, 2933, 2935, 1, 0, 0, 0, 2934, 2922, 1, 0, 0, 0, 2934, 2926, 1, 0, 0, 0, 2934, 2930, 1, 0, 0, 0, 2935, 275, 1, 0, 0, 0, 2936, 2937, 5, 161, 0, 0, 2937, 2938, 3, 124, 62, 0, 2938, 277, 1, 0, 0, 0, 2939, 2940, 5, 162, 0, 0, 2940, 279, 1, 0, 0, 0, 2941, 2942, 5, 163, 0, 0, 2942, 281, 1, 0, 0, 0, 2943, 2944, 3, 264, 132, 0, 2944, 2945, 6, 141, -1, 0, 2945, 2959, 1, 0, 0, 0, 2946, 2947, 5, 164, 0, 0, 2947, 2948, 3, 0, 0, 0, 2948, 2949, 5, 159, 0, 0, 2949, 2950, 3, 0, 0, 0, 2950, 2951, 6, 141, -1, 0, 2951, 2959, 1, 0, 0, 0, 2952, 2953, 5, 164, 0, 0, 2953, 2954, 3, 32, 16, 0, 2954, 2955, 5, 159, 0, 0, 2955, 2956, 3, 32, 16, 0, 2956, 2957, 6, 141, -1, 0, 2957, 2959, 1, 0, 0, 0, 2958, 2943, 1, 0, 0, 0, 2958, 2946, 1, 0, 0, 0, 2958, 2952, 1, 0, 0, 0, 2959, 283, 1, 0, 0, 0, 2960, 2961, 3, 286, 143, 0, 2961, 2962, 3, 290, 145, 0, 2962, 285, 1, 0, 0, 0, 2963, 2964, 5, 165, 0, 0, 2964, 2965, 3, 288, 144, 0, 2965, 2966, 3, 0, 0, 0, 2966, 2967, 5, 36, 0, 0, 2967, 2968, 6, 143, -1, 0, 2968, 2974, 1, 0, 0, 0, 2969, 2970, 5, 165, 0, 0, 2970, 2971, 3, 288, 144, 0, 2971, 2972, 6, 143, -1, 0, 2972, 2974, 1, 0, 0, 0, 2973, 2963, 1, 0, 0, 0, 2973, 2969, 1, 0, 0, 0, 2974, 287, 1, 0, 0, 0, 2975, 2981, 1, 0, 0, 0, 2976, 2977, 5, 166, 0, 0, 2977, 2981, 6, 144, -1, 0, 2978, 2979, 5, 2, 0, 0, 2979, 2981, 6, 144, -1, 0, 2980, 2975, 1, 0, 0, 0, 2980, 2976, 1, 0, 0, 0, 2980, 2978, 1, 0, 0, 0, 2981, 289, 1, 0, 0, 0, 2982, 2983, 5, 17, 0, 0, 2983, 2984, 3, 292, 146, 0, 2984, 2985, 5, 18, 0, 0, 2985, 2992, 1, 0, 0, 0, 2986, 2988, 3, 296, 148, 0, 2987, 2986, 1, 0, 0, 0, 2988, 2989, 1, 0, 0, 0, 2989, 2987, 1, 0, 0, 0, 2989, 2990, 1, 0, 0, 0, 2990, 2992, 1, 0, 0, 0, 2991, 2982, 1, 0, 0, 0, 2991, 2987, 1, 0, 0, 0, 2992, 291, 1, 0, 0, 0, 2993, 2994, 3, 296, 148, 0, 2994, 2995, 5, 28, 0, 0, 2995, 2997, 1, 0, 0, 0, 2996, 2993, 1, 0, 0, 0, 2997, 3000, 1, 0, 0, 0, 2998, 2996, 1, 0, 0, 0, 2998, 2999, 1, 0, 0, 0, 2999, 3001, 1, 0, 0, 0, 3000, 2998, 1, 0, 0, 0, 3001, 3002, 3, 296, 148, 0, 3002, 293, 1, 0, 0, 0, 3003, 3010, 1, 0, 0, 0, 3004, 3005, 5, 42, 0, 0, 3005, 3006, 3, 32, 16, 0, 3006, 3007, 5, 43, 0, 0, 3007, 3008, 6, 147, -1, 0, 3008, 3010, 1, 0, 0, 0, 3009, 3003, 1, 0, 0, 0, 3009, 3004, 1, 0, 0, 0, 3010, 295, 1, 0, 0, 0, 3011, 3012, 5, 181, 0, 0, 3012, 3013, 5, 262, 0, 0, 3013, 3014, 5, 30, 0, 0, 3014, 3015, 3, 6, 3, 0, 3015, 3016, 5, 31, 0, 0, 3016, 3017, 6, 148, -1, 0, 3017, 3060, 1, 0, 0, 0, 3018, 3019, 5, 260, 0, 0, 3019, 3020, 5, 30, 0, 0, 3020, 3021, 3, 0, 0, 0, 3021, 3022, 5, 31, 0, 0, 3022, 3023, 6, 148, -1, 0, 3023, 3060, 1, 0, 0, 0, 3024, 3025, 5, 260, 0, 0, 3025, 3026, 3, 0, 0, 0, 3026, 3027, 6, 148, -1, 0, 3027, 3060, 1, 0, 0, 0, 3028, 3029, 5, 84, 0, 0, 3029, 3030, 5, 30, 0, 0, 3030, 3031, 3, 300, 150, 0, 3031, 3032, 5, 31, 0, 0, 3032, 3033, 6, 148, -1, 0, 3033, 3060, 1, 0, 0, 0, 3034, 3035, 7, 10, 0, 0, 3035, 3036, 5, 30, 0, 0, 3036, 3037, 3, 36, 18, 0, 3037, 3038, 5, 31, 0, 0, 3038, 3039, 3, 294, 147, 0, 3039, 3040, 6, 148, -1, 0, 3040, 3060, 1, 0, 0, 0, 3041, 3042, 5, 187, 0, 0, 3042, 3043, 5, 30, 0, 0, 3043, 3044, 3, 34, 17, 0, 3044, 3045, 5, 31, 0, 0, 3045, 3046, 3, 294, 147, 0, 3046, 3047, 6, 148, -1, 0, 3047, 3060, 1, 0, 0, 0, 3048, 3049, 7, 11, 0, 0, 3049, 3050, 5, 30, 0, 0, 3050, 3051, 3, 32, 16, 0, 3051, 3052, 5, 31, 0, 0, 3052, 3053, 3, 294, 147, 0, 3053, 3054, 6, 148, -1, 0, 3054, 3060, 1, 0, 0, 0, 3055, 3056, 7, 12, 0, 0, 3056, 3057, 3, 294, 147, 0, 3057, 3058, 6, 148, -1, 0, 3058, 3060, 1, 0, 0, 0, 3059, 3011, 1, 0, 0, 0, 3059, 3018, 1, 0, 0, 0, 3059, 3024, 1, 0, 0, 0, 3059, 3028, 1, 0, 0, 0, 3059, 3034, 1, 0, 0, 0, 3059, 3041, 1, 0, 0, 0, 3059, 3048, 1, 0, 0, 0, 3059, 3055, 1, 0, 0, 0, 3060, 297, 1, 0, 0, 0, 3061, 3062, 5, 188, 0, 0, 3062, 3063, 5, 30, 0, 0, 3063, 3064, 3, 36, 18, 0, 3064, 3065, 5, 31, 0, 0, 3065, 3066, 6, 149, -1, 0, 3066, 3152, 1, 0, 0, 0, 3067, 3068, 5, 189, 0, 0, 3068, 3069, 5, 30, 0, 0, 3069, 3070, 3, 36, 18, 0, 3070, 3071, 5, 31, 0, 0, 3071, 3072, 6, 149, -1, 0, 3072, 3152, 1, 0, 0, 0, 3073, 3074, 5, 188, 0, 0, 3074, 3075, 5, 30, 0, 0, 3075, 3076, 3, 32, 16, 0, 3076, 3077, 5, 31, 0, 0, 3077, 3078, 6, 149, -1, 0, 3078, 3152, 1, 0, 0, 0, 3079, 3080, 5, 189, 0, 0, 3080, 3081, 5, 30, 0, 0, 3081, 3082, 3, 34, 17, 0, 3082, 3083, 5, 31, 0, 0, 3083, 3084, 6, 149, -1, 0, 3084, 3152, 1, 0, 0, 0, 3085, 3086, 5, 187, 0, 0, 3086, 3087, 5, 30, 0, 0, 3087, 3088, 3, 34, 17, 0, 3088, 3089, 5, 31, 0, 0, 3089, 3090, 6, 149, -1, 0, 3090, 3152, 1, 0, 0, 0, 3091, 3092, 5, 186, 0, 0, 3092, 3093, 5, 30, 0, 0, 3093, 3094, 3, 32, 16, 0, 3094, 3095, 5, 31, 0, 0, 3095, 3096, 6, 149, -1, 0, 3096, 3152, 1, 0, 0, 0, 3097, 3098, 5, 185, 0, 0, 3098, 3099, 5, 30, 0, 0, 3099, 3100, 3, 32, 16, 0, 3100, 3101, 5, 31, 0, 0, 3101, 3102, 6, 149, -1, 0, 3102, 3152, 1, 0, 0, 0, 3103, 3104, 5, 184, 0, 0, 3104, 3105, 5, 30, 0, 0, 3105, 3106, 3, 32, 16, 0, 3106, 3107, 5, 31, 0, 0, 3107, 3108, 6, 149, -1, 0, 3108, 3152, 1, 0, 0, 0, 3109, 3110, 5, 193, 0, 0, 3110, 3111, 5, 30, 0, 0, 3111, 3112, 3, 34, 17, 0, 3112, 3113, 5, 31, 0, 0, 3113, 3114, 6, 149, -1, 0, 3114, 3152, 1, 0, 0, 0, 3115, 3116, 5, 192, 0, 0, 3116, 3117, 5, 30, 0, 0, 3117, 3118, 3, 32, 16, 0, 3118, 3119, 5, 31, 0, 0, 3119, 3120, 6, 149, -1, 0, 3120, 3152, 1, 0, 0, 0, 3121, 3122, 5, 191, 0, 0, 3122, 3123, 5, 30, 0, 0, 3123, 3124, 3, 32, 16, 0, 3124, 3125, 5, 31, 0, 0, 3125, 3126, 6, 149, -1, 0, 3126, 3152, 1, 0, 0, 0, 3127, 3128, 5, 190, 0, 0, 3128, 3129, 5, 30, 0, 0, 3129, 3130, 3, 32, 16, 0, 3130, 3131, 5, 31, 0, 0, 3131, 3132, 6, 149, -1, 0, 3132, 3152, 1, 0, 0, 0, 3133, 3134, 5, 181, 0, 0, 3134, 3135, 5, 30, 0, 0, 3135, 3136, 3, 32, 16, 0, 3136, 3137, 5, 31, 0, 0, 3137, 3138, 6, 149, -1, 0, 3138, 3152, 1, 0, 0, 0, 3139, 3140, 5, 183, 0, 0, 3140, 3141, 5, 30, 0, 0, 3141, 3142, 3, 162, 81, 0, 3142, 3143, 5, 31, 0, 0, 3143, 3144, 6, 149, -1, 0, 3144, 3152, 1, 0, 0, 0, 3145, 3146, 5, 84, 0, 0, 3146, 3147, 5, 30, 0, 0, 3147, 3148, 3, 300, 150, 0, 3148, 3149, 5, 31, 0, 0, 3149, 3150, 6, 149, -1, 0, 3150, 3152, 1, 0, 0, 0, 3151, 3061, 1, 0, 0, 0, 3151, 3067, 1, 0, 0, 0, 3151, 3073, 1, 0, 0, 0, 3151, 3079, 1, 0, 0, 0, 3151, 3085, 1, 0, 0, 0, 3151, 3091, 1, 0, 0, 0, 3151, 3097, 1, 0, 0, 0, 3151, 3103, 1, 0, 0, 0, 3151, 3109, 1, 0, 0, 0, 3151, 3115, 1, 0, 0, 0, 3151, 3121, 1, 0, 0, 0, 3151, 3127, 1, 0, 0, 0, 3151, 3133, 1, 0, 0, 0, 3151, 3139, 1, 0, 0, 0, 3151, 3145, 1, 0, 0, 0, 3152, 299, 1, 0, 0, 0, 3153, 3154, 3, 302, 151, 0, 3154, 3155, 6, 150, -1, 0, 3155, 3157, 1, 0, 0, 0, 3156, 3153, 1, 0, 0, 0, 3157, 3160, 1, 0, 0, 0, 3158, 3156, 1, 0, 0, 0, 3158, 3159, 1, 0, 0, 0, 3159, 301, 1, 0, 0, 0, 3160, 3158, 1, 0, 0, 0, 3161, 3162, 7, 13, 0, 0, 3162, 303, 1, 0, 0, 0, 3163, 3164, 3, 298, 149, 0, 3164, 3165, 6, 152, -1, 0, 3165, 3172, 1, 0, 0, 0, 3166, 3167, 3, 6, 3, 0, 3167, 3168, 6, 152, -1, 0, 3168, 3172, 1, 0, 0, 0, 3169, 3170, 5, 179, 0, 0, 3170, 3172, 6, 152, -1, 0, 3171, 3163, 1, 0, 0, 0, 3171, 3166, 1, 0, 0, 0, 3171, 3169, 1, 0, 0, 0, 3172, 305, 1, 0, 0, 0, 3173, 3174, 3, 298, 149, 0, 3174, 3175, 6, 153, -1, 0, 3175, 3345, 1, 0, 0, 0, 3176, 3177, 5, 182, 0, 0, 3177, 3178, 5, 30, 0, 0, 3178, 3179, 5, 179, 0, 0, 3179, 3180, 5, 31, 0, 0, 3180, 3345, 6, 153, -1, 0, 3181, 3182, 5, 182, 0, 0, 3182, 3183, 5, 30, 0, 0, 3183, 3184, 5, 264, 0, 0, 3184, 3185, 5, 31, 0, 0, 3185, 3345, 6, 153, -1, 0, 3186, 3187, 5, 196, 0, 0, 3187, 3188, 5, 30, 0, 0, 3188, 3189, 5, 39, 0, 0, 3189, 3190, 5, 264, 0, 0, 3190, 3191, 5, 31, 0, 0, 3191, 3345, 6, 153, -1, 0, 3192, 3193, 5, 196, 0, 0, 3193, 3194, 5, 30, 0, 0, 3194, 3195, 3, 116, 58, 0, 3195, 3196, 5, 31, 0, 0, 3196, 3197, 6, 153, -1, 0, 3197, 3345, 1, 0, 0, 0, 3198, 3199, 5, 196, 0, 0, 3199, 3200, 5, 30, 0, 0, 3200, 3201, 5, 179, 0, 0, 3201, 3202, 5, 31, 0, 0, 3202, 3345, 6, 153, -1, 0, 3203, 3204, 5, 197, 0, 0, 3204, 3205, 5, 30, 0, 0, 3205, 3206, 3, 306, 153, 0, 3206, 3207, 5, 31, 0, 0, 3207, 3208, 6, 153, -1, 0, 3208, 3345, 1, 0, 0, 0, 3209, 3210, 5, 188, 0, 0, 3210, 3211, 5, 42, 0, 0, 3211, 3212, 3, 32, 16, 0, 3212, 3213, 5, 43, 0, 0, 3213, 3214, 5, 30, 0, 0, 3214, 3215, 3, 308, 154, 0, 3215, 3216, 5, 31, 0, 0, 3216, 3217, 6, 153, -1, 0, 3217, 3345, 1, 0, 0, 0, 3218, 3219, 5, 189, 0, 0, 3219, 3220, 5, 42, 0, 0, 3220, 3221, 3, 32, 16, 0, 3221, 3222, 5, 43, 0, 0, 3222, 3223, 5, 30, 0, 0, 3223, 3224, 3, 310, 155, 0, 3224, 3225, 5, 31, 0, 0, 3225, 3226, 6, 153, -1, 0, 3226, 3345, 1, 0, 0, 0, 3227, 3228, 5, 187, 0, 0, 3228, 3229, 5, 42, 0, 0, 3229, 3230, 3, 32, 16, 0, 3230, 3231, 5, 43, 0, 0, 3231, 3232, 5, 30, 0, 0, 3232, 3233, 3, 312, 156, 0, 3233, 3234, 5, 31, 0, 0, 3234, 3235, 6, 153, -1, 0, 3235, 3345, 1, 0, 0, 0, 3236, 3237, 5, 186, 0, 0, 3237, 3238, 5, 42, 0, 0, 3238, 3239, 3, 32, 16, 0, 3239, 3240, 5, 43, 0, 0, 3240, 3241, 5, 30, 0, 0, 3241, 3242, 3, 314, 157, 0, 3242, 3243, 5, 31, 0, 0, 3243, 3244, 6, 153, -1, 0, 3244, 3345, 1, 0, 0, 0, 3245, 3246, 5, 185, 0, 0, 3246, 3247, 5, 42, 0, 0, 3247, 3248, 3, 32, 16, 0, 3248, 3249, 5, 43, 0, 0, 3249, 3250, 5, 30, 0, 0, 3250, 3251, 3, 316, 158, 0, 3251, 3252, 5, 31, 0, 0, 3252, 3253, 6, 153, -1, 0, 3253, 3345, 1, 0, 0, 0, 3254, 3255, 5, 184, 0, 0, 3255, 3256, 5, 42, 0, 0, 3256, 3257, 3, 32, 16, 0, 3257, 3258, 5, 43, 0, 0, 3258, 3259, 5, 30, 0, 0, 3259, 3260, 3, 318, 159, 0, 3260, 3261, 5, 31, 0, 0, 3261, 3262, 6, 153, -1, 0, 3262, 3345, 1, 0, 0, 0, 3263, 3264, 5, 193, 0, 0, 3264, 3265, 5, 42, 0, 0, 3265, 3266, 3, 32, 16, 0, 3266, 3267, 5, 43, 0, 0, 3267, 3268, 5, 30, 0, 0, 3268, 3269, 3, 312, 156, 0, 3269, 3270, 5, 31, 0, 0, 3270, 3271, 6, 153, -1, 0, 3271, 3345, 1, 0, 0, 0, 3272, 3273, 5, 192, 0, 0, 3273, 3274, 5, 42, 0, 0, 3274, 3275, 3, 32, 16, 0, 3275, 3276, 5, 43, 0, 0, 3276, 3277, 5, 30, 0, 0, 3277, 3278, 3, 314, 157, 0, 3278, 3279, 5, 31, 0, 0, 3279, 3280, 6, 153, -1, 0, 3280, 3345, 1, 0, 0, 0, 3281, 3282, 5, 191, 0, 0, 3282, 3283, 5, 42, 0, 0, 3283, 3284, 3, 32, 16, 0, 3284, 3285, 5, 43, 0, 0, 3285, 3286, 5, 30, 0, 0, 3286, 3287, 3, 316, 158, 0, 3287, 3288, 5, 31, 0, 0, 3288, 3289, 6, 153, -1, 0, 3289, 3345, 1, 0, 0, 0, 3290, 3291, 5, 190, 0, 0, 3291, 3292, 5, 42, 0, 0, 3292, 3293, 3, 32, 16, 0, 3293, 3294, 5, 43, 0, 0, 3294, 3295, 5, 30, 0, 0, 3295, 3296, 3, 318, 159, 0, 3296, 3297, 5, 31, 0, 0, 3297, 3298, 6, 153, -1, 0, 3298, 3345, 1, 0, 0, 0, 3299, 3300, 5, 181, 0, 0, 3300, 3301, 5, 42, 0, 0, 3301, 3302, 3, 32, 16, 0, 3302, 3303, 5, 43, 0, 0, 3303, 3304, 5, 30, 0, 0, 3304, 3305, 3, 316, 158, 0, 3305, 3306, 5, 31, 0, 0, 3306, 3307, 6, 153, -1, 0, 3307, 3345, 1, 0, 0, 0, 3308, 3309, 5, 183, 0, 0, 3309, 3310, 5, 42, 0, 0, 3310, 3311, 3, 32, 16, 0, 3311, 3312, 5, 43, 0, 0, 3312, 3313, 5, 30, 0, 0, 3313, 3314, 3, 320, 160, 0, 3314, 3315, 5, 31, 0, 0, 3315, 3316, 6, 153, -1, 0, 3316, 3345, 1, 0, 0, 0, 3317, 3318, 5, 182, 0, 0, 3318, 3319, 5, 42, 0, 0, 3319, 3320, 3, 32, 16, 0, 3320, 3321, 5, 43, 0, 0, 3321, 3322, 5, 30, 0, 0, 3322, 3323, 3, 322, 161, 0, 3323, 3324, 5, 31, 0, 0, 3324, 3325, 6, 153, -1, 0, 3325, 3345, 1, 0, 0, 0, 3326, 3327, 5, 196, 0, 0, 3327, 3328, 5, 42, 0, 0, 3328, 3329, 3, 32, 16, 0, 3329, 3330, 5, 43, 0, 0, 3330, 3331, 5, 30, 0, 0, 3331, 3332, 3, 324, 162, 0, 3332, 3333, 5, 31, 0, 0, 3333, 3334, 6, 153, -1, 0, 3334, 3345, 1, 0, 0, 0, 3335, 3336, 5, 197, 0, 0, 3336, 3337, 5, 42, 0, 0, 3337, 3338, 3, 32, 16, 0, 3338, 3339, 5, 43, 0, 0, 3339, 3340, 5, 30, 0, 0, 3340, 3341, 3, 328, 164, 0, 3341, 3342, 5, 31, 0, 0, 3342, 3343, 6, 153, -1, 0, 3343, 3345, 1, 0, 0, 0, 3344, 3173, 1, 0, 0, 0, 3344, 3176, 1, 0, 0, 0, 3344, 3181, 1, 0, 0, 0, 3344, 3186, 1, 0, 0, 0, 3344, 3192, 1, 0, 0, 0, 3344, 3198, 1, 0, 0, 0, 3344, 3203, 1, 0, 0, 0, 3344, 3209, 1, 0, 0, 0, 3344, 3218, 1, 0, 0, 0, 3344, 3227, 1, 0, 0, 0, 3344, 3236, 1, 0, 0, 0, 3344, 3245, 1, 0, 0, 0, 3344, 3254, 1, 0, 0, 0, 3344, 3263, 1, 0, 0, 0, 3344, 3272, 1, 0, 0, 0, 3344, 3281, 1, 0, 0, 0, 3344, 3290, 1, 0, 0, 0, 3344, 3299, 1, 0, 0, 0, 3344, 3308, 1, 0, 0, 0, 3344, 3317, 1, 0, 0, 0, 3344, 3326, 1, 0, 0, 0, 3344, 3335, 1, 0, 0, 0, 3345, 307, 1, 0, 0, 0, 3346, 3347, 3, 36, 18, 0, 3347, 3348, 6, 154, -1, 0, 3348, 3353, 1, 0, 0, 0, 3349, 3350, 3, 32, 16, 0, 3350, 3351, 6, 154, -1, 0, 3351, 3353, 1, 0, 0, 0, 3352, 3346, 1, 0, 0, 0, 3352, 3349, 1, 0, 0, 0, 3353, 3356, 1, 0, 0, 0, 3354, 3352, 1, 0, 0, 0, 3354, 3355, 1, 0, 0, 0, 3355, 309, 1, 0, 0, 0, 3356, 3354, 1, 0, 0, 0, 3357, 3358, 3, 36, 18, 0, 3358, 3359, 6, 155, -1, 0, 3359, 3364, 1, 0, 0, 0, 3360, 3361, 3, 34, 17, 0, 3361, 3362, 6, 155, -1, 0, 3362, 3364, 1, 0, 0, 0, 3363, 3357, 1, 0, 0, 0, 3363, 3360, 1, 0, 0, 0, 3364, 3367, 1, 0, 0, 0, 3365, 3363, 1, 0, 0, 0, 3365, 3366, 1, 0, 0, 0, 3366, 311, 1, 0, 0, 0, 3367, 3365, 1, 0, 0, 0, 3368, 3369, 3, 34, 17, 0, 3369, 3370, 6, 156, -1, 0, 3370, 3372, 1, 0, 0, 0, 3371, 3368, 1, 0, 0, 0, 3372, 3375, 1, 0, 0, 0, 3373, 3371, 1, 0, 0, 0, 3373, 3374, 1, 0, 0, 0, 3374, 313, 1, 0, 0, 0, 3375, 3373, 1, 0, 0, 0, 3376, 3377, 3, 32, 16, 0, 3377, 3378, 6, 157, -1, 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, 315, 1, 0, 0, 0, 3383, 3381, 1, 0, 0, 0, 3384, 3385, 3, 32, 16, 0, 3385, 3386, 6, 158, -1, 0, 3386, 3388, 1, 0, 0, 0, 3387, 3384, 1, 0, 0, 0, 3388, 3391, 1, 0, 0, 0, 3389, 3387, 1, 0, 0, 0, 3389, 3390, 1, 0, 0, 0, 3390, 317, 1, 0, 0, 0, 3391, 3389, 1, 0, 0, 0, 3392, 3393, 3, 32, 16, 0, 3393, 3394, 6, 159, -1, 0, 3394, 3396, 1, 0, 0, 0, 3395, 3392, 1, 0, 0, 0, 3396, 3399, 1, 0, 0, 0, 3397, 3395, 1, 0, 0, 0, 3397, 3398, 1, 0, 0, 0, 3398, 319, 1, 0, 0, 0, 3399, 3397, 1, 0, 0, 0, 3400, 3401, 3, 162, 81, 0, 3401, 3402, 6, 160, -1, 0, 3402, 3404, 1, 0, 0, 0, 3403, 3400, 1, 0, 0, 0, 3404, 3407, 1, 0, 0, 0, 3405, 3403, 1, 0, 0, 0, 3405, 3406, 1, 0, 0, 0, 3406, 321, 1, 0, 0, 0, 3407, 3405, 1, 0, 0, 0, 3408, 3409, 5, 179, 0, 0, 3409, 3413, 6, 161, -1, 0, 3410, 3411, 5, 264, 0, 0, 3411, 3413, 6, 161, -1, 0, 3412, 3408, 1, 0, 0, 0, 3412, 3410, 1, 0, 0, 0, 3413, 3416, 1, 0, 0, 0, 3414, 3412, 1, 0, 0, 0, 3414, 3415, 1, 0, 0, 0, 3415, 323, 1, 0, 0, 0, 3416, 3414, 1, 0, 0, 0, 3417, 3418, 3, 326, 163, 0, 3418, 3419, 6, 162, -1, 0, 3419, 3421, 1, 0, 0, 0, 3420, 3417, 1, 0, 0, 0, 3421, 3424, 1, 0, 0, 0, 3422, 3420, 1, 0, 0, 0, 3422, 3423, 1, 0, 0, 0, 3423, 325, 1, 0, 0, 0, 3424, 3422, 1, 0, 0, 0, 3425, 3426, 5, 179, 0, 0, 3426, 3434, 6, 163, -1, 0, 3427, 3428, 5, 39, 0, 0, 3428, 3429, 5, 264, 0, 0, 3429, 3434, 6, 163, -1, 0, 3430, 3431, 3, 116, 58, 0, 3431, 3432, 6, 163, -1, 0, 3432, 3434, 1, 0, 0, 0, 3433, 3425, 1, 0, 0, 0, 3433, 3427, 1, 0, 0, 0, 3433, 3430, 1, 0, 0, 0, 3434, 327, 1, 0, 0, 0, 3435, 3436, 3, 306, 153, 0, 3436, 3437, 6, 164, -1, 0, 3437, 3439, 1, 0, 0, 0, 3438, 3435, 1, 0, 0, 0, 3439, 3442, 1, 0, 0, 0, 3440, 3438, 1, 0, 0, 0, 3440, 3441, 1, 0, 0, 0, 3441, 329, 1, 0, 0, 0, 3442, 3440, 1, 0, 0, 0, 3443, 3444, 3, 44, 22, 0, 3444, 3445, 6, 165, -1, 0, 3445, 3453, 1, 0, 0, 0, 3446, 3447, 3, 46, 23, 0, 3447, 3448, 6, 165, -1, 0, 3448, 3453, 1, 0, 0, 0, 3449, 3450, 3, 2, 1, 0, 3450, 3451, 6, 165, -1, 0, 3451, 3453, 1, 0, 0, 0, 3452, 3443, 1, 0, 0, 0, 3452, 3446, 1, 0, 0, 0, 3452, 3449, 1, 0, 0, 0, 3453, 331, 1, 0, 0, 0, 3454, 3455, 7, 14, 0, 0, 3455, 3456, 5, 36, 0, 0, 3456, 3457, 5, 30, 0, 0, 3457, 3458, 3, 300, 150, 0, 3458, 3459, 5, 31, 0, 0, 3459, 3480, 1, 0, 0, 0, 3460, 3461, 5, 169, 0, 0, 3461, 3462, 3, 38, 19, 0, 3462, 3463, 5, 75, 0, 0, 3463, 3464, 3, 38, 19, 0, 3464, 3465, 5, 75, 0, 0, 3465, 3466, 3, 38, 19, 0, 3466, 3467, 5, 75, 0, 0, 3467, 3468, 3, 38, 19, 0, 3468, 3480, 1, 0, 0, 0, 3469, 3470, 5, 170, 0, 0, 3470, 3480, 3, 6, 3, 0, 3471, 3472, 5, 170, 0, 0, 3472, 3473, 5, 36, 0, 0, 3473, 3474, 5, 30, 0, 0, 3474, 3475, 3, 300, 150, 0, 3475, 3476, 5, 31, 0, 0, 3476, 3480, 1, 0, 0, 0, 3477, 3480, 3, 330, 165, 0, 3478, 3480, 3, 40, 20, 0, 3479, 3454, 1, 0, 0, 0, 3479, 3460, 1, 0, 0, 0, 3479, 3469, 1, 0, 0, 0, 3479, 3471, 1, 0, 0, 0, 3479, 3477, 1, 0, 0, 0, 3479, 3478, 1, 0, 0, 0, 3480, 333, 1, 0, 0, 0, 3481, 3482, 3, 336, 168, 0, 3482, 3483, 5, 17, 0, 0, 3483, 3484, 3, 338, 169, 0, 3484, 3485, 5, 18, 0, 0, 3485, 335, 1, 0, 0, 0, 3486, 3487, 5, 25, 0, 0, 3487, 3488, 5, 40, 0, 0, 3488, 3489, 3, 98, 49, 0, 3489, 3490, 3, 2, 1, 0, 3490, 3499, 1, 0, 0, 0, 3491, 3492, 5, 25, 0, 0, 3492, 3493, 5, 40, 0, 0, 3493, 3494, 3, 98, 49, 0, 3494, 3495, 3, 2, 1, 0, 3495, 3496, 5, 34, 0, 0, 3496, 3497, 3, 2, 1, 0, 3497, 3499, 1, 0, 0, 0, 3498, 3486, 1, 0, 0, 0, 3498, 3491, 1, 0, 0, 0, 3499, 337, 1, 0, 0, 0, 3500, 3502, 3, 340, 170, 0, 3501, 3500, 1, 0, 0, 0, 3502, 3505, 1, 0, 0, 0, 3503, 3501, 1, 0, 0, 0, 3503, 3504, 1, 0, 0, 0, 3504, 339, 1, 0, 0, 0, 3505, 3503, 1, 0, 0, 0, 3506, 3507, 5, 180, 0, 0, 3507, 3508, 5, 36, 0, 0, 3508, 3509, 5, 30, 0, 0, 3509, 3510, 3, 300, 150, 0, 3510, 3511, 5, 31, 0, 0, 3511, 3521, 1, 0, 0, 0, 3512, 3521, 3, 332, 166, 0, 3513, 3514, 5, 171, 0, 0, 3514, 3515, 5, 36, 0, 0, 3515, 3516, 5, 30, 0, 0, 3516, 3517, 3, 300, 150, 0, 3517, 3518, 5, 31, 0, 0, 3518, 3521, 1, 0, 0, 0, 3519, 3521, 5, 55, 0, 0, 3520, 3506, 1, 0, 0, 0, 3520, 3512, 1, 0, 0, 0, 3520, 3513, 1, 0, 0, 0, 3520, 3519, 1, 0, 0, 0, 3521, 341, 1, 0, 0, 0, 3522, 3523, 3, 344, 172, 0, 3523, 3524, 5, 17, 0, 0, 3524, 3525, 3, 350, 175, 0, 3525, 3526, 5, 18, 0, 0, 3526, 343, 1, 0, 0, 0, 3527, 3528, 5, 50, 0, 0, 3528, 3532, 5, 40, 0, 0, 3529, 3531, 3, 348, 174, 0, 3530, 3529, 1, 0, 0, 0, 3531, 3534, 1, 0, 0, 0, 3532, 3530, 1, 0, 0, 0, 3532, 3533, 1, 0, 0, 0, 3533, 3535, 1, 0, 0, 0, 3534, 3532, 1, 0, 0, 0, 3535, 3536, 3, 2, 1, 0, 3536, 345, 1, 0, 0, 0, 3537, 3541, 5, 301, 0, 0, 3538, 3540, 3, 348, 174, 0, 3539, 3538, 1, 0, 0, 0, 3540, 3543, 1, 0, 0, 0, 3541, 3539, 1, 0, 0, 0, 3541, 3542, 1, 0, 0, 0, 3542, 3544, 1, 0, 0, 0, 3543, 3541, 1, 0, 0, 0, 3544, 3545, 3, 2, 1, 0, 3545, 347, 1, 0, 0, 0, 3546, 3562, 5, 52, 0, 0, 3547, 3562, 5, 51, 0, 0, 3548, 3562, 5, 172, 0, 0, 3549, 3550, 5, 62, 0, 0, 3550, 3562, 5, 51, 0, 0, 3551, 3552, 5, 62, 0, 0, 3552, 3562, 5, 52, 0, 0, 3553, 3554, 5, 62, 0, 0, 3554, 3562, 5, 63, 0, 0, 3555, 3556, 5, 62, 0, 0, 3556, 3562, 5, 64, 0, 0, 3557, 3558, 5, 62, 0, 0, 3558, 3562, 5, 65, 0, 0, 3559, 3560, 5, 62, 0, 0, 3560, 3562, 5, 66, 0, 0, 3561, 3546, 1, 0, 0, 0, 3561, 3547, 1, 0, 0, 0, 3561, 3548, 1, 0, 0, 0, 3561, 3549, 1, 0, 0, 0, 3561, 3551, 1, 0, 0, 0, 3561, 3553, 1, 0, 0, 0, 3561, 3555, 1, 0, 0, 0, 3561, 3557, 1, 0, 0, 0, 3561, 3559, 1, 0, 0, 0, 3562, 349, 1, 0, 0, 0, 3563, 3565, 3, 352, 176, 0, 3564, 3563, 1, 0, 0, 0, 3565, 3568, 1, 0, 0, 0, 3566, 3564, 1, 0, 0, 0, 3566, 3567, 1, 0, 0, 0, 3567, 351, 1, 0, 0, 0, 3568, 3566, 1, 0, 0, 0, 3569, 3570, 5, 21, 0, 0, 3570, 3583, 3, 2, 1, 0, 3571, 3572, 5, 50, 0, 0, 3572, 3573, 5, 40, 0, 0, 3573, 3583, 3, 118, 59, 0, 3574, 3575, 5, 25, 0, 0, 3575, 3576, 5, 40, 0, 0, 3576, 3583, 3, 2, 1, 0, 3577, 3583, 3, 174, 87, 0, 3578, 3579, 5, 50, 0, 0, 3579, 3583, 3, 32, 16, 0, 3580, 3583, 3, 330, 165, 0, 3581, 3583, 3, 40, 20, 0, 3582, 3569, 1, 0, 0, 0, 3582, 3571, 1, 0, 0, 0, 3582, 3574, 1, 0, 0, 0, 3582, 3577, 1, 0, 0, 0, 3582, 3578, 1, 0, 0, 0, 3582, 3580, 1, 0, 0, 0, 3582, 3581, 1, 0, 0, 0, 3583, 353, 1, 0, 0, 0, 3584, 3585, 3, 356, 178, 0, 3585, 3586, 5, 17, 0, 0, 3586, 3587, 3, 360, 180, 0, 3587, 3588, 5, 18, 0, 0, 3588, 355, 1, 0, 0, 0, 3589, 3593, 5, 274, 0, 0, 3590, 3592, 3, 358, 179, 0, 3591, 3590, 1, 0, 0, 0, 3592, 3595, 1, 0, 0, 0, 3593, 3591, 1, 0, 0, 0, 3593, 3594, 1, 0, 0, 0, 3594, 3596, 1, 0, 0, 0, 3595, 3593, 1, 0, 0, 0, 3596, 3609, 3, 2, 1, 0, 3597, 3601, 5, 274, 0, 0, 3598, 3600, 3, 358, 179, 0, 3599, 3598, 1, 0, 0, 0, 3600, 3603, 1, 0, 0, 0, 3601, 3599, 1, 0, 0, 0, 3601, 3602, 1, 0, 0, 0, 3602, 3604, 1, 0, 0, 0, 3603, 3601, 1, 0, 0, 0, 3604, 3605, 3, 2, 1, 0, 3605, 3606, 5, 34, 0, 0, 3606, 3607, 3, 2, 1, 0, 3607, 3609, 1, 0, 0, 0, 3608, 3589, 1, 0, 0, 0, 3608, 3597, 1, 0, 0, 0, 3609, 357, 1, 0, 0, 0, 3610, 3611, 7, 15, 0, 0, 3611, 359, 1, 0, 0, 0, 3612, 3614, 3, 362, 181, 0, 3613, 3612, 1, 0, 0, 0, 3614, 3617, 1, 0, 0, 0, 3615, 3613, 1, 0, 0, 0, 3615, 3616, 1, 0, 0, 0, 3616, 361, 1, 0, 0, 0, 3617, 3615, 1, 0, 0, 0, 3618, 3619, 5, 21, 0, 0, 3619, 3620, 3, 2, 1, 0, 3620, 3621, 5, 44, 0, 0, 3621, 3622, 3, 32, 16, 0, 3622, 3629, 1, 0, 0, 0, 3623, 3624, 5, 25, 0, 0, 3624, 3625, 5, 40, 0, 0, 3625, 3629, 3, 2, 1, 0, 3626, 3629, 3, 330, 165, 0, 3627, 3629, 3, 40, 20, 0, 3628, 3618, 1, 0, 0, 0, 3628, 3623, 1, 0, 0, 0, 3628, 3626, 1, 0, 0, 0, 3628, 3627, 1, 0, 0, 0, 3629, 363, 1, 0, 0, 0, 187, 374, 382, 391, 400, 489, 539, 550, 580, 584, 602, 629, 657, 697, 708, 718, 720, 731, 733, 741, 763, 776, 797, 799, 818, 891, 898, 905, 910, 919, 930, 939, 950, 961, 974, 978, 984, 1000, 1006, 1012, 1019, 1047, 1125, 1127, 1141, 1147, 1156, 1158, 1167, 1181, 1195, 1203, 1211, 1215, 1254, 1262, 1271, 1279, 1298, 1308, 1311, 1335, 1482, 1492, 1501, 1504, 1586, 1595, 1627, 1687, 1727, 1743, 1753, 1783, 1811, 1820, 1826, 1843, 1851, 1909, 1919, 1937, 1955, 1974, 1995, 2014, 2029, 2037, 2049, 2069, 2076, 2081, 2092, 2104, 2214, 2226, 2242, 2256, 2265, 2278, 2280, 2323, 2334, 2341, 2349, 2357, 2370, 2376, 2382, 2387, 2416, 2424, 2438, 2443, 2468, 2477, 2488, 2492, 2499, 2519, 2528, 2530, 2545, 2592, 2602, 2604, 2611, 2617, 2661, 2670, 2710, 2715, 2755, 2759, 2769, 2791, 2803, 2814, 2829, 2842, 2855, 2858, 2870, 2884, 2902, 2920, 2934, 2958, 2973, 2980, 2989, 2991, 2998, 3009, 3059, 3151, 3158, 3171, 3344, 3352, 3354, 3363, 3365, 3373, 3381, 3389, 3397, 3405, 3412, 3414, 3422, 3433, 3440, 3452, 3479, 3498, 3503, 3520, 3532, 3541, 3561, 3566, 3582, 3593, 3601, 3608, 3615, 3628] \ No newline at end of file diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs index 27d2b0dcca1051..36d6dea038c269 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs @@ -1308,7 +1308,11 @@ public MscorlibContext mscorlib() { } public partial class LanguageDeclContext : ParserRuleContext { + public object Value; public bool HasSyntaxError; + public LanguageStringContext language; + public LanguageStringContext vendor; + public LanguageStringContext documentType; [System.Diagnostics.DebuggerNonUserCode] public LanguageStringContext[] languageString() { return GetRuleContexts(); } @@ -1332,9 +1336,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { public LanguageDeclContext languageDecl() { LanguageDeclContext _localctx = new LanguageDeclContext(Context, State); EnterRule(_localctx, 26, RULE_languageDecl); - BeginSubtree(); Actions.BeginSemanticRoot(_localctx); + BeginStreaming(); Actions.BeginSemanticRoot(_localctx); try { - State = 535; + State = 539; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,5,Context) ) { case 1: @@ -1343,37 +1347,40 @@ public LanguageDeclContext languageDecl() { State = 521; Match(T__26); State = 522; - languageString(); + _localctx.language = languageString(); + _localctx.Value = Actions.CreateLanguageDirective(_localctx.language.Value); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 523; - Match(T__26); - State = 524; - languageString(); State = 525; - Match(T__27); + Match(T__26); State = 526; - languageString(); + _localctx.language = languageString(); + State = 527; + Match(T__27); + State = 528; + _localctx.vendor = languageString(); + _localctx.Value = Actions.CreateLanguageDirective(_localctx.language.Value, _localctx.vendor.Value); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 528; - Match(T__26); - State = 529; - languageString(); - State = 530; - Match(T__27); State = 531; - languageString(); + Match(T__26); State = 532; - Match(T__27); + _localctx.language = languageString(); State = 533; - languageString(); + Match(T__27); + State = 534; + _localctx.vendor = languageString(); + State = 535; + Match(T__27); + State = 536; + _localctx.documentType = languageString(); + _localctx.Value = Actions.CreateLanguageDirective(_localctx.language.Value, _localctx.vendor.Value, _localctx.documentType.Value); } break; } @@ -1384,13 +1391,14 @@ public LanguageDeclContext languageDecl() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); + Actions.EndLanguageDirective(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; } public partial class LanguageStringContext : ParserRuleContext { + public string Value; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SQSTRING() { return GetToken(CILParser.SQSTRING, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode QSTRING() { return GetToken(CILParser.QSTRING, 0); } public LanguageStringContext(ParserRuleContext parent, int invokingState) @@ -1414,7 +1422,7 @@ public LanguageStringContext languageString() { try { EnterOuterAlt(_localctx, 1); { - State = 537; + State = 541; _la = TokenStream.LA(1); if ( !(_la==QSTRING || _la==SQSTRING) ) { ErrorHandler.RecoverInline(this); @@ -1424,6 +1432,8 @@ public LanguageStringContext languageString() { Consume(); } } + Context.Stop = TokenStream.LT(-1); + _localctx.Value = Actions.ParseLanguageString(_localctx.Start); } catch (RecognitionException re) { _localctx.exception = re; @@ -1466,26 +1476,26 @@ public TypelistContext typelist() { try { EnterOuterAlt(_localctx, 1); { - State = 539; + State = 543; Match(T__28); - State = 540; + State = 544; Match(T__16); - State = 546; + State = 550; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__15 || _la==T__41 || _la==T__112 || ((((_la - 199)) & ~0x3f) == 0 && ((1L << (_la - 199)) & 2017630225248026625L) != 0) || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50331649L) != 0)) { { { - State = 541; + State = 545; _localctx.name = className(); Actions.ProcessTopLevelTypeListEntry(_localctx.name.Value); } } - State = 548; + State = 552; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 549; + State = 553; Match(T__17); } } @@ -1522,7 +1532,7 @@ public Int32Context int32() { try { EnterOuterAlt(_localctx, 1); { - State = 551; + State = 555; Match(INT32); } } @@ -1561,7 +1571,7 @@ public Int64Context int64() { try { EnterOuterAlt(_localctx, 1); { - State = 553; + State = 557; _la = TokenStream.LA(1); if ( !(_la==INT32 || _la==INT64) ) { ErrorHandler.RecoverInline(this); @@ -1618,13 +1628,13 @@ public Float64Context float64() { Float64Context _localctx = new Float64Context(Context, State); EnterRule(_localctx, 36, RULE_float64); try { - State = 576; + State = 580; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,7,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 555; + State = 559; _localctx.@decimal = Match(FLOAT64); _localctx.Value = Actions.ParseFloatingLiteral(_localctx.@decimal); } @@ -1632,9 +1642,9 @@ public Float64Context float64() { case 2: EnterOuterAlt(_localctx, 2); { - State = 557; + State = 561; _localctx.trailing = int32(); - State = 558; + State = 562; Match(DOT); _localctx.Value = Actions.ParseFloatingInteger((_localctx.trailing!=null?(_localctx.trailing.Start):null)); } @@ -1642,7 +1652,7 @@ public Float64Context float64() { case 3: EnterOuterAlt(_localctx, 3); { - State = 561; + State = 565; _localctx.integer = int32(); _localctx.Value = Actions.ParseFloatingInteger((_localctx.integer!=null?(_localctx.integer.Start):null)); } @@ -1650,13 +1660,13 @@ public Float64Context float64() { case 4: EnterOuterAlt(_localctx, 4); { - State = 564; + State = 568; Match(FLOAT32); - State = 565; + State = 569; Match(T__29); - State = 566; + State = 570; _localctx.singleBits = int32(); - State = 567; + State = 571; Match(T__30); _localctx.Value = Actions.ParseFloat32Bits((_localctx.singleBits!=null?(_localctx.singleBits.Start):null)); } @@ -1664,13 +1674,13 @@ public Float64Context float64() { case 5: EnterOuterAlt(_localctx, 5); { - State = 570; + State = 574; Match(FLOAT64_); - State = 571; + State = 575; Match(T__29); - State = 572; + State = 576; _localctx.doubleBits = int64(); - State = 573; + State = 577; Match(T__30); _localctx.Value = Actions.ParseFloat64Bits((_localctx.doubleBits!=null?(_localctx.doubleBits.Start):null)); } @@ -1711,20 +1721,20 @@ public IntOrWildcardContext intOrWildcard() { IntOrWildcardContext _localctx = new IntOrWildcardContext(Context, State); EnterRule(_localctx, 38, RULE_intOrWildcard); try { - State = 580; + State = 584; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case INT32: EnterOuterAlt(_localctx, 1); { - State = 578; + State = 582; int32(); } break; case PTR: EnterOuterAlt(_localctx, 2); { - State = 579; + State = 583; Match(PTR); } break; @@ -1771,83 +1781,83 @@ public CompControlContext compControl() { CompControlContext _localctx = new CompControlContext(Context, State); EnterRule(_localctx, 40, RULE_compControl); try { - State = 598; + State = 602; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,9,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 582; + State = 586; Match(PP_DEFINE); - State = 583; + State = 587; Match(ID); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 584; + State = 588; Match(PP_DEFINE); - State = 585; + State = 589; Match(ID); - State = 586; + State = 590; Match(QSTRING); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 587; + State = 591; Match(PP_UNDEF); - State = 588; + State = 592; Match(ID); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 589; + State = 593; Match(PP_IFDEF); - State = 590; + State = 594; Match(ID); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 591; + State = 595; Match(PP_IFNDEF); - State = 592; + State = 596; Match(ID); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 593; + State = 597; Match(PP_ELSE); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 594; + State = 598; Match(PP_ENDIF); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 595; + State = 599; Match(PP_INCLUDE); - State = 596; + State = 600; Match(QSTRING); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 597; + State = 601; Match(T__31); } break; @@ -1903,71 +1913,71 @@ public TypedefDeclContext typedefDecl() { EnterRule(_localctx, 42, RULE_typedefDecl); BeginSubtree(); Actions.BeginSemanticRoot(_localctx); try { - State = 625; + State = 629; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,10,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 600; + State = 604; Match(T__32); - State = 601; + State = 605; type(); - State = 602; + State = 606; Match(T__33); - State = 603; + State = 607; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 605; + State = 609; Match(T__32); - State = 606; + State = 610; className(); - State = 607; + State = 611; Match(T__33); - State = 608; + State = 612; dottedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 610; + State = 614; Match(T__32); - State = 611; + State = 615; memberRef(); - State = 612; + State = 616; Match(T__33); - State = 613; + State = 617; dottedName(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 615; + State = 619; Match(T__32); - State = 616; + State = 620; customDescr(); - State = 617; + State = 621; Match(T__33); - State = 618; + State = 622; dottedName(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 620; + State = 624; Match(T__32); - State = 621; + State = 625; customDescrWithOwner(); - State = 622; + State = 626; Match(T__33); - State = 623; + State = 627; dottedName(); } break; @@ -2023,15 +2033,15 @@ public CustomDescrContext customDescr() { EnterRule(_localctx, 44, RULE_customDescr); Actions.BeginSemanticRoot(_localctx); try { - State = 653; + State = 657; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,11,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 627; + State = 631; Match(T__34); - State = 628; + State = 632; _localctx.constructor = customType(); _localctx.Value = Actions.CreateDefaultCustomAttribute(_localctx.constructor.Value); } @@ -2039,13 +2049,13 @@ public CustomDescrContext customDescr() { case 2: EnterOuterAlt(_localctx, 2); { - State = 631; + State = 635; Match(T__34); - State = 632; + State = 636; _localctx.constructor = customType(); - State = 633; + State = 637; Match(T__35); - State = 634; + State = 638; _localctx.stringValue = compQstring(); _localctx.Value = Actions.CreateStringCustomAttribute(_localctx.constructor.Value, _localctx.stringValue.Value); } @@ -2053,17 +2063,17 @@ public CustomDescrContext customDescr() { case 3: EnterOuterAlt(_localctx, 3); { - State = 637; + State = 641; Match(T__34); - State = 638; + State = 642; _localctx.constructor = customType(); - State = 639; + State = 643; Match(T__35); - State = 640; + State = 644; Match(T__16); - State = 641; + State = 645; _localctx.structuredValue = customBlobDescr(); - State = 642; + State = 646; Match(T__17); _localctx.Value = Actions.CreateStructuredCustomAttribute(_localctx.constructor.Value, _localctx.structuredValue.Value); } @@ -2071,17 +2081,17 @@ public CustomDescrContext customDescr() { case 4: EnterOuterAlt(_localctx, 4); { - State = 645; + State = 649; Match(T__34); - State = 646; + State = 650; _localctx.constructor = customType(); - State = 647; + State = 651; Match(T__35); - State = 648; + State = 652; Match(T__29); - State = 649; + State = 653; _localctx.rawValue = bytes(); - State = 650; + State = 654; Match(T__30); _localctx.Value = Actions.CreateRawCustomAttribute(_localctx.constructor.Value, _localctx.rawValue.Value); } @@ -2142,21 +2152,21 @@ public CustomDescrWithOwnerContext customDescrWithOwner() { EnterRule(_localctx, 46, RULE_customDescrWithOwner); Actions.BeginSemanticRoot(_localctx); try { - State = 693; + State = 697; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,12,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 655; + State = 659; Match(T__34); - State = 656; + State = 660; Match(T__29); - State = 657; + State = 661; _localctx.owner = ownerType(); - State = 658; + State = 662; Match(T__30); - State = 659; + State = 663; _localctx.constructor = customType(); _localctx.Value = Actions.CreateDefaultOwnedCustomAttribute(_localctx.owner.Value, _localctx.constructor.Value); } @@ -2164,19 +2174,19 @@ public CustomDescrWithOwnerContext customDescrWithOwner() { case 2: EnterOuterAlt(_localctx, 2); { - State = 662; + State = 666; Match(T__34); - State = 663; + State = 667; Match(T__29); - State = 664; + State = 668; _localctx.owner = ownerType(); - State = 665; + State = 669; Match(T__30); - State = 666; + State = 670; _localctx.constructor = customType(); - State = 667; + State = 671; Match(T__35); - State = 668; + State = 672; _localctx.stringValue = compQstring(); _localctx.Value = Actions.CreateStringOwnedCustomAttribute(_localctx.owner.Value, _localctx.constructor.Value, _localctx.stringValue.Value); } @@ -2184,23 +2194,23 @@ public CustomDescrWithOwnerContext customDescrWithOwner() { case 3: EnterOuterAlt(_localctx, 3); { - State = 671; + State = 675; Match(T__34); - State = 672; + State = 676; Match(T__29); - State = 673; + State = 677; _localctx.owner = ownerType(); - State = 674; + State = 678; Match(T__30); - State = 675; + State = 679; _localctx.constructor = customType(); - State = 676; + State = 680; Match(T__35); - State = 677; + State = 681; Match(T__16); - State = 678; + State = 682; _localctx.structuredValue = customBlobDescr(); - State = 679; + State = 683; Match(T__17); _localctx.Value = Actions.CreateStructuredOwnedCustomAttribute(_localctx.owner.Value, _localctx.constructor.Value, _localctx.structuredValue.Value); } @@ -2208,23 +2218,23 @@ public CustomDescrWithOwnerContext customDescrWithOwner() { case 4: EnterOuterAlt(_localctx, 4); { - State = 682; + State = 686; Match(T__34); - State = 683; + State = 687; Match(T__29); - State = 684; + State = 688; _localctx.owner = ownerType(); - State = 685; + State = 689; Match(T__30); - State = 686; + State = 690; _localctx.constructor = customType(); - State = 687; + State = 691; Match(T__35); - State = 688; + State = 692; Match(T__29); - State = 689; + State = 693; _localctx.rawValue = bytes(); - State = 690; + State = 694; Match(T__30); _localctx.Value = Actions.CreateRawOwnedCustomAttribute(_localctx.owner.Value, _localctx.constructor.Value, _localctx.rawValue.Value); } @@ -2269,7 +2279,7 @@ public CustomTypeContext customType() { try { EnterOuterAlt(_localctx, 1); { - State = 695; + State = 699; _localctx.constructor = methodRef(); _localctx.Value = Actions.CreateCustomAttributeType(_localctx.constructor.Value); } @@ -2315,13 +2325,13 @@ public OwnerTypeContext ownerType() { EnterRule(_localctx, 50, RULE_ownerType); Actions.BeginSemanticRoot(_localctx); try { - State = 704; + State = 708; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,13,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 698; + State = 702; _localctx.typeValue = typeSpec(); _localctx.Value = Actions.CreateTypeOwner(_localctx.typeValue.Value); } @@ -2329,7 +2339,7 @@ public OwnerTypeContext ownerType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 701; + State = 705; _localctx.member = memberRef(); _localctx.Value = Actions.CreateMemberOwner(_localctx.member.Value); } @@ -2378,9 +2388,9 @@ public CustomBlobDescrContext customBlobDescr() { try { EnterOuterAlt(_localctx, 1); { - State = 706; + State = 710; _localctx.arguments = customBlobArgs(); - State = 707; + State = 711; _localctx.namedArguments = customBlobNVPairs(); _localctx.Value = Actions.CreateCustomAttributeBlob(_localctx.arguments.Value, _localctx.namedArguments.Value); } @@ -2433,13 +2443,13 @@ public CustomBlobArgsContext customBlobArgs() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 716; + State = 720; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,15,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { - State = 714; + State = 718; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__83: @@ -2459,7 +2469,7 @@ public CustomBlobArgsContext customBlobArgs() { case TYPE: case OBJECT: { - State = 710; + State = 714; _localctx.argument = serInit(); Actions.AddCustomBlobArgument(_localctx, _localctx.argument.Value); } @@ -2473,7 +2483,7 @@ public CustomBlobArgsContext customBlobArgs() { case PP_ENDIF: case PP_INCLUDE: { - State = 713; + State = 717; compControl(); } break; @@ -2482,7 +2492,7 @@ public CustomBlobArgsContext customBlobArgs() { } } } - State = 718; + State = 722; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,15,Context); } @@ -2558,26 +2568,26 @@ public CustomBlobNVPairsContext customBlobNVPairs() { try { EnterOuterAlt(_localctx, 1); { - State = 729; + State = 733; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 416611827712L) != 0) || ((((_la - 267)) & ~0x3f) == 0 && ((1L << (_la - 267)) & 127L) != 0)) { { - State = 727; + State = 731; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__36: case T__37: { - State = 719; + State = 723; _localctx.kind = fieldOrProp(); - State = 720; + State = 724; _localctx.argumentType = serializType(); - State = 721; + State = 725; _localctx.name = dottedName(); - State = 722; + State = 726; Match(T__35); - State = 723; + State = 727; _localctx.value = serInit(); Actions.AddCustomBlobNamedArgument( _localctx, @@ -2596,7 +2606,7 @@ public CustomBlobNVPairsContext customBlobNVPairs() { case PP_ENDIF: case PP_INCLUDE: { - State = 726; + State = 730; compControl(); } break; @@ -2604,7 +2614,7 @@ public CustomBlobNVPairsContext customBlobNVPairs() { throw new NoViableAltException(this); } } - State = 731; + State = 735; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -2646,7 +2656,7 @@ public FieldOrPropContext fieldOrProp() { try { EnterOuterAlt(_localctx, 1); { - State = 732; + State = 736; _localctx.kind = TokenStream.LT(1); _la = TokenStream.LA(1); if ( !(_la==T__36 || _la==T__37) ) { @@ -2699,14 +2709,14 @@ public SerializTypeContext serializType() { try { EnterOuterAlt(_localctx, 1); { - State = 735; + State = 739; _localctx.element = serializTypeElement(); - State = 737; + State = 741; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==ARRAY_TYPE_NO_BOUNDS) { { - State = 736; + State = 740; _localctx.array = Match(ARRAY_TYPE_NO_BOUNDS); } } @@ -2763,13 +2773,13 @@ public SerializTypeElementContext serializTypeElement() { SerializTypeElementContext _localctx = new SerializTypeElementContext(Context, State); EnterRule(_localctx, 62, RULE_serializTypeElement); try { - State = 759; + State = 763; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,19,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 741; + State = 745; _localctx.primitive = simpleType(); _localctx.Value = Actions.CreatePrimitiveSerializationType(_localctx.primitive.Value); } @@ -2777,7 +2787,7 @@ public SerializTypeElementContext serializTypeElement() { case 2: EnterOuterAlt(_localctx, 2); { - State = 744; + State = 748; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateSerializationTypeTypedef(_localctx, _localctx.alias.Value); } @@ -2785,7 +2795,7 @@ public SerializTypeElementContext serializTypeElement() { case 3: EnterOuterAlt(_localctx, 3); { - State = 747; + State = 751; _localctx.simpleTypeToken = Match(TYPE); _localctx.Value = Actions.CreateSimpleSerializationType(_localctx.simpleTypeToken); } @@ -2793,7 +2803,7 @@ public SerializTypeElementContext serializTypeElement() { case 4: EnterOuterAlt(_localctx, 4); { - State = 749; + State = 753; _localctx.simpleTypeToken = Match(OBJECT); _localctx.Value = Actions.CreateSimpleSerializationType(_localctx.simpleTypeToken); } @@ -2801,11 +2811,11 @@ public SerializTypeElementContext serializTypeElement() { case 5: EnterOuterAlt(_localctx, 5); { - State = 751; + State = 755; Match(ENUM); - State = 752; + State = 756; Match(T__38); - State = 753; + State = 757; _localctx.quotedName = Match(SQSTRING); _localctx.Value = Actions.CreateEnumSerializationType(_localctx.quotedName); } @@ -2813,9 +2823,9 @@ public SerializTypeElementContext serializTypeElement() { case 6: EnterOuterAlt(_localctx, 6); { - State = 755; + State = 759; Match(ENUM); - State = 756; + State = 760; _localctx.classNameValue = className(); _localctx.Value = Actions.CreateEnumSerializationType(_localctx.classNameValue.Value); } @@ -2860,17 +2870,17 @@ public ModuleHeadContext moduleHead() { ModuleHeadContext _localctx = new ModuleHeadContext(Context, State); EnterRule(_localctx, 64, RULE_moduleHead); try { - State = 772; + State = 776; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,20,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 761; + State = 765; Match(MODULE); - State = 762; + State = 766; Match(T__39); - State = 763; + State = 767; _localctx.name = dottedName(); Actions.SetModuleHeader(_localctx, _localctx.name.Value, true); } @@ -2878,9 +2888,9 @@ public ModuleHeadContext moduleHead() { case 2: EnterOuterAlt(_localctx, 2); { - State = 766; + State = 770; Match(MODULE); - State = 767; + State = 771; _localctx.name = dottedName(); Actions.SetModuleHeader(_localctx, _localctx.name.Value, false); } @@ -2888,7 +2898,7 @@ public ModuleHeadContext moduleHead() { case 3: EnterOuterAlt(_localctx, 3); { - State = 770; + State = 774; Match(MODULE); Actions.SetEmptyModuleHeader(_localctx); } @@ -2938,19 +2948,19 @@ public VtfixupDeclContext vtfixupDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 774; + State = 778; Match(T__40); - State = 775; + State = 779; Match(T__41); - State = 776; + State = 780; int32(); - State = 777; + State = 781; Match(T__42); - State = 778; + State = 782; vtfixupAttr(0); - State = 779; + State = 783; Match(T__43); - State = 780; + State = 784; id(); } } @@ -3004,7 +3014,7 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { } Context.Stop = TokenStream.LT(-1); - State = 795; + State = 799; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,22,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { @@ -3013,16 +3023,16 @@ private VtfixupAttrContext vtfixupAttr(int _p) { TriggerExitRuleEvent(); _prevctx = _localctx; { - State = 793; + State = 797; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,21,Context) ) { case 1: { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 783; + State = 787; if (!(Precpred(Context, 5))) throw new FailedPredicateException(this, "Precpred(Context, 5)"); - State = 784; + State = 788; Match(INT32_); } break; @@ -3030,9 +3040,9 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 785; + State = 789; if (!(Precpred(Context, 4))) throw new FailedPredicateException(this, "Precpred(Context, 4)"); - State = 786; + State = 790; Match(INT64_); } break; @@ -3040,9 +3050,9 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 787; + State = 791; if (!(Precpred(Context, 3))) throw new FailedPredicateException(this, "Precpred(Context, 3)"); - State = 788; + State = 792; Match(T__44); } break; @@ -3050,9 +3060,9 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 789; + State = 793; if (!(Precpred(Context, 2))) throw new FailedPredicateException(this, "Precpred(Context, 2)"); - State = 790; + State = 794; Match(T__45); } break; @@ -3060,16 +3070,16 @@ private VtfixupAttrContext vtfixupAttr(int _p) { { _localctx = new VtfixupAttrContext(_parentctx, _parentState); PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 791; + State = 795; if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)"); - State = 792; + State = 796; Match(T__46); } break; } } } - State = 797; + State = 801; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,22,Context); } @@ -3112,15 +3122,15 @@ public VtableDeclContext vtableDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 798; + State = 802; Match(T__47); - State = 799; + State = 803; Match(T__35); - State = 800; + State = 804; Match(T__29); - State = 801; + State = 805; bytes(); - State = 802; + State = 806; Match(T__30); } } @@ -3163,9 +3173,9 @@ public NameSpaceHeadContext nameSpaceHead() { try { EnterOuterAlt(_localctx, 1); { - State = 804; + State = 808; Match(T__48); - State = 805; + State = 809; _localctx.name = dottedName(); _localctx.Value = _localctx.name.Value; } @@ -3231,32 +3241,32 @@ public ClassHeadContext classHead() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 808; + State = 812; Match(T__49); - State = 814; + State = 818; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,23,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 809; + State = 813; _localctx.attribute = classAttr(); Actions.AddClassHeaderAttribute(_localctx, _localctx.attribute.Value); } } } - State = 816; + State = 820; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,23,Context); } - State = 817; + State = 821; _localctx.name = dottedName(); - State = 818; + State = 822; _localctx.genericParameters = typarsClause(); - State = 819; + State = 823; _localctx.baseType = extendsClause(); - State = 820; + State = 824; _localctx.interfaces = implClause(); _localctx.Value = Actions.CreateClassHeader( _localctx, @@ -3312,13 +3322,13 @@ public ClassAttrContext classAttr() { ClassAttrContext _localctx = new ClassAttrContext(Context, State); EnterRule(_localctx, 76, RULE_classAttr); try { - State = 887; + State = 891; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,24,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 823; + State = 827; _localctx.attribute = Match(T__50); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3326,7 +3336,7 @@ public ClassAttrContext classAttr() { case 2: EnterOuterAlt(_localctx, 2); { - State = 825; + State = 829; _localctx.attribute = Match(T__51); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3334,7 +3344,7 @@ public ClassAttrContext classAttr() { case 3: EnterOuterAlt(_localctx, 3); { - State = 827; + State = 831; _localctx.attribute = Match(VALUE); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3342,7 +3352,7 @@ public ClassAttrContext classAttr() { case 4: EnterOuterAlt(_localctx, 4); { - State = 829; + State = 833; _localctx.attribute = Match(ENUM); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3350,7 +3360,7 @@ public ClassAttrContext classAttr() { case 5: EnterOuterAlt(_localctx, 5); { - State = 831; + State = 835; _localctx.attribute = Match(INTERFACE); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3358,7 +3368,7 @@ public ClassAttrContext classAttr() { case 6: EnterOuterAlt(_localctx, 6); { - State = 833; + State = 837; _localctx.attribute = Match(T__52); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3366,7 +3376,7 @@ public ClassAttrContext classAttr() { case 7: EnterOuterAlt(_localctx, 7); { - State = 835; + State = 839; _localctx.attribute = Match(T__53); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3374,7 +3384,7 @@ public ClassAttrContext classAttr() { case 8: EnterOuterAlt(_localctx, 8); { - State = 837; + State = 841; _localctx.attribute = Match(T__54); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3382,7 +3392,7 @@ public ClassAttrContext classAttr() { case 9: EnterOuterAlt(_localctx, 9); { - State = 839; + State = 843; _localctx.attribute = Match(T__55); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3390,7 +3400,7 @@ public ClassAttrContext classAttr() { case 10: EnterOuterAlt(_localctx, 10); { - State = 841; + State = 845; _localctx.attribute = Match(EXPLICIT); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3398,7 +3408,7 @@ public ClassAttrContext classAttr() { case 11: EnterOuterAlt(_localctx, 11); { - State = 843; + State = 847; _localctx.attribute = Match(T__14); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3406,7 +3416,7 @@ public ClassAttrContext classAttr() { case 12: EnterOuterAlt(_localctx, 12); { - State = 845; + State = 849; _localctx.attribute = Match(ANSI); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3414,7 +3424,7 @@ public ClassAttrContext classAttr() { case 13: EnterOuterAlt(_localctx, 13); { - State = 847; + State = 851; _localctx.attribute = Match(T__56); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3422,7 +3432,7 @@ public ClassAttrContext classAttr() { case 14: EnterOuterAlt(_localctx, 14); { - State = 849; + State = 853; _localctx.attribute = Match(T__57); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3430,7 +3440,7 @@ public ClassAttrContext classAttr() { case 15: EnterOuterAlt(_localctx, 15); { - State = 851; + State = 855; _localctx.attribute = Match(T__58); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3438,7 +3448,7 @@ public ClassAttrContext classAttr() { case 16: EnterOuterAlt(_localctx, 16); { - State = 853; + State = 857; _localctx.attribute = Match(T__59); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3446,7 +3456,7 @@ public ClassAttrContext classAttr() { case 17: EnterOuterAlt(_localctx, 17); { - State = 855; + State = 859; _localctx.attribute = Match(T__60); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3454,9 +3464,9 @@ public ClassAttrContext classAttr() { case 18: EnterOuterAlt(_localctx, 18); { - State = 857; + State = 861; Match(T__61); - State = 858; + State = 862; _localctx.visibility = Match(T__50); _localctx.Value = Actions.CreateNestedClassAttribute(_localctx.visibility); } @@ -3464,9 +3474,9 @@ public ClassAttrContext classAttr() { case 19: EnterOuterAlt(_localctx, 19); { - State = 860; + State = 864; Match(T__61); - State = 861; + State = 865; _localctx.visibility = Match(T__51); _localctx.Value = Actions.CreateNestedClassAttribute(_localctx.visibility); } @@ -3474,9 +3484,9 @@ public ClassAttrContext classAttr() { case 20: EnterOuterAlt(_localctx, 20); { - State = 863; + State = 867; Match(T__61); - State = 864; + State = 868; _localctx.visibility = Match(T__62); _localctx.Value = Actions.CreateNestedClassAttribute(_localctx.visibility); } @@ -3484,9 +3494,9 @@ public ClassAttrContext classAttr() { case 21: EnterOuterAlt(_localctx, 21); { - State = 866; + State = 870; Match(T__61); - State = 867; + State = 871; _localctx.visibility = Match(T__63); _localctx.Value = Actions.CreateNestedClassAttribute(_localctx.visibility); } @@ -3494,9 +3504,9 @@ public ClassAttrContext classAttr() { case 22: EnterOuterAlt(_localctx, 22); { - State = 869; + State = 873; Match(T__61); - State = 870; + State = 874; _localctx.visibility = Match(T__64); _localctx.Value = Actions.CreateNestedClassAttribute(_localctx.visibility); } @@ -3504,9 +3514,9 @@ public ClassAttrContext classAttr() { case 23: EnterOuterAlt(_localctx, 23); { - State = 872; + State = 876; Match(T__61); - State = 873; + State = 877; _localctx.visibility = Match(T__65); _localctx.Value = Actions.CreateNestedClassAttribute(_localctx.visibility); } @@ -3514,7 +3524,7 @@ public ClassAttrContext classAttr() { case 24: EnterOuterAlt(_localctx, 24); { - State = 875; + State = 879; _localctx.attribute = Match(T__66); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3522,7 +3532,7 @@ public ClassAttrContext classAttr() { case 25: EnterOuterAlt(_localctx, 25); { - State = 877; + State = 881; _localctx.attribute = Match(T__67); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3530,7 +3540,7 @@ public ClassAttrContext classAttr() { case 26: EnterOuterAlt(_localctx, 26); { - State = 879; + State = 883; _localctx.attribute = Match(T__68); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3538,13 +3548,13 @@ public ClassAttrContext classAttr() { case 27: EnterOuterAlt(_localctx, 27); { - State = 881; + State = 885; Match(T__69); - State = 882; + State = 886; Match(T__29); - State = 883; + State = 887; _localctx.flags = int32(); - State = 884; + State = 888; Match(T__30); _localctx.Value = Actions.CreateRawClassAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } @@ -3587,7 +3597,7 @@ public ExtendsClauseContext extendsClause() { EnterRule(_localctx, 78, RULE_extendsClause); _localctx.Value = Actions.CreateEmptyClassBase(); try { - State = 894; + State = 898; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -3599,9 +3609,9 @@ public ExtendsClauseContext extendsClause() { case T__70: EnterOuterAlt(_localctx, 2); { - State = 890; + State = 894; Match(T__70); - State = 891; + State = 895; _localctx.baseType = typeSpec(); _localctx.Value = Actions.CreateClassBase(_localctx.baseType.Value); } @@ -3646,7 +3656,7 @@ public ImplClauseContext implClause() { EnterRule(_localctx, 80, RULE_implClause); _localctx.Value = Actions.CreateEmptyInterfaceList(); try { - State = 901; + State = 905; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -3657,9 +3667,9 @@ public ImplClauseContext implClause() { case T__71: EnterOuterAlt(_localctx, 2); { - State = 897; + State = 901; Match(T__71); - State = 898; + State = 902; _localctx.interfaces = implList(); _localctx.Value = _localctx.interfaces.Value; } @@ -3708,17 +3718,17 @@ public ClassDeclsContext classDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 906; + State = 910; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1125938695831552L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 1189425290649010179L) != 0) || ((((_la - 139)) & ~0x3f) == 0 && ((1L << (_la - 139)) & 1152921504673955841L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 871552083145265153L) != 0)) { { { - State = 903; + State = 907; classDecl(); } } - State = 908; + State = 912; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -3768,26 +3778,26 @@ public ImplListContext implList() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 915; + State = 919; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,28,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 909; + State = 913; _localctx.interfaceType = typeSpec(); Actions.AddInterfaceType(_localctx, _localctx.interfaceType.Value); - State = 911; + State = 915; Match(T__27); } } } - State = 917; + State = 921; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,28,Context); } - State = 918; + State = 922; _localctx.lastInterfaceType = typeSpec(); Actions.AddInterfaceType(_localctx, _localctx.lastInterfaceType.Value); } @@ -3805,6 +3815,7 @@ public ImplListContext implList() { } public partial class EsHeadContext : ParserRuleContext { + public bool AutoIncrement; public EsHeadContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { @@ -3826,7 +3837,7 @@ public EsHeadContext esHead() { try { EnterOuterAlt(_localctx, 1); { - State = 921; + State = 925; _la = TokenStream.LA(1); if ( !(_la==T__72 || _la==T__73) ) { ErrorHandler.RecoverInline(this); @@ -3836,6 +3847,8 @@ public EsHeadContext esHead() { Consume(); } } + Context.Stop = TokenStream.LT(-1); + _localctx.AutoIncrement = Actions.IsAutoIncrementSourceDirective(_localctx.Start); } catch (RecognitionException re) { _localctx.exception = re; @@ -3849,7 +3862,16 @@ public EsHeadContext esHead() { } public partial class ExtSourceSpecContext : ParserRuleContext { + public object Value; public bool HasSyntaxError; + public EsHeadContext head; + public Int32Context line; + public IToken path; + public Int32Context column; + public Int32Context startColumn; + public Int32Context endColumn; + public Int32Context startLine; + public Int32Context endLine; [System.Diagnostics.DebuggerNonUserCode] public EsHeadContext esHead() { return GetRuleContext(0); } @@ -3878,260 +3900,198 @@ public override TResult Accept(IParseTreeVisitor visitor) { public ExtSourceSpecContext extSourceSpec() { ExtSourceSpecContext _localctx = new ExtSourceSpecContext(Context, State); EnterRule(_localctx, 88, RULE_extSourceSpec); - BeginSubtree(); Actions.BeginSemanticRoot(_localctx); + BeginStreaming(); Actions.BeginSemanticRoot(_localctx); + int _la; try { - State = 1026; + State = 978; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,29,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,34,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 923; - esHead(); - State = 924; - int32(); - State = 925; - Match(SQSTRING); - } - break; - case 2: - EnterOuterAlt(_localctx, 2); - { State = 927; - esHead(); + _localctx.head = esHead(); State = 928; - int32(); - } - break; - case 3: - EnterOuterAlt(_localctx, 3); - { + _localctx.line = int32(); State = 930; - esHead(); - State = 931; - int32(); - State = 932; - Match(T__74); - State = 933; - int32(); - State = 934; - Match(SQSTRING); + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,29,Context) ) { + case 1: + { + State = 929; + _localctx.path = TokenStream.LT(1); + _la = TokenStream.LA(1); + if ( !(_la==QSTRING || _la==SQSTRING) ) { + _localctx.path = ErrorHandler.RecoverInline(this); + } + else { + ErrorHandler.ReportMatch(this); + Consume(); + } + } + break; + } + _localctx.Value = Actions.CreateSourceLine(_localctx.head.AutoIncrement, (_localctx.line!=null?(_localctx.line.Start):null), _localctx.path); } break; - case 4: - EnterOuterAlt(_localctx, 4); + case 2: + EnterOuterAlt(_localctx, 2); { + State = 934; + _localctx.head = esHead(); + State = 935; + _localctx.line = int32(); State = 936; - esHead(); - State = 937; - int32(); - State = 938; Match(T__74); + State = 937; + _localctx.column = int32(); State = 939; - int32(); + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,30,Context) ) { + case 1: + { + State = 938; + _localctx.path = TokenStream.LT(1); + _la = TokenStream.LA(1); + if ( !(_la==QSTRING || _la==SQSTRING) ) { + _localctx.path = ErrorHandler.RecoverInline(this); + } + else { + ErrorHandler.ReportMatch(this); + Consume(); + } + } + break; + } + _localctx.Value = Actions.CreateSourceColumn(_localctx.head.AutoIncrement, (_localctx.line!=null?(_localctx.line.Start):null), (_localctx.column!=null?(_localctx.column.Start):null), _localctx.path); } break; - case 5: - EnterOuterAlt(_localctx, 5); + case 3: + EnterOuterAlt(_localctx, 3); { - State = 941; - esHead(); - State = 942; - int32(); State = 943; - Match(T__74); + _localctx.head = esHead(); State = 944; - int32(); + _localctx.line = int32(); State = 945; - Match(T__27); + Match(T__74); State = 946; - int32(); + _localctx.startColumn = int32(); State = 947; - Match(SQSTRING); - } - break; - case 6: - EnterOuterAlt(_localctx, 6); - { - State = 949; - esHead(); - State = 950; - int32(); - State = 951; - Match(T__74); - State = 952; - int32(); - State = 953; Match(T__27); - State = 954; - int32(); + State = 948; + _localctx.endColumn = int32(); + State = 950; + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,31,Context) ) { + case 1: + { + State = 949; + _localctx.path = TokenStream.LT(1); + _la = TokenStream.LA(1); + if ( !(_la==QSTRING || _la==SQSTRING) ) { + _localctx.path = ErrorHandler.RecoverInline(this); + } + else { + ErrorHandler.ReportMatch(this); + Consume(); + } + } + break; + } + _localctx.Value = Actions.CreateSourceColumnRange( + _localctx.head.AutoIncrement, + (_localctx.line!=null?(_localctx.line.Start):null), + (_localctx.startColumn!=null?(_localctx.startColumn.Start):null), + (_localctx.endColumn!=null?(_localctx.endColumn.Start):null), + _localctx.path); } break; - case 7: - EnterOuterAlt(_localctx, 7); + case 4: + EnterOuterAlt(_localctx, 4); { + State = 954; + _localctx.head = esHead(); + State = 955; + _localctx.startLine = int32(); State = 956; - esHead(); + Match(T__27); State = 957; - int32(); + _localctx.endLine = int32(); State = 958; - Match(T__27); - State = 959; - int32(); - State = 960; Match(T__74); + State = 959; + _localctx.column = int32(); State = 961; - int32(); - State = 962; - Match(SQSTRING); + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,32,Context) ) { + case 1: + { + State = 960; + _localctx.path = TokenStream.LT(1); + _la = TokenStream.LA(1); + if ( !(_la==QSTRING || _la==SQSTRING) ) { + _localctx.path = ErrorHandler.RecoverInline(this); + } + else { + ErrorHandler.ReportMatch(this); + Consume(); + } + } + break; + } + _localctx.Value = Actions.CreateSourceLineRange( + _localctx.head.AutoIncrement, + (_localctx.startLine!=null?(_localctx.startLine.Start):null), + (_localctx.endLine!=null?(_localctx.endLine.Start):null), + (_localctx.column!=null?(_localctx.column.Start):null), + _localctx.path); } break; - case 8: - EnterOuterAlt(_localctx, 8); + case 5: + EnterOuterAlt(_localctx, 5); { - State = 964; - esHead(); State = 965; - int32(); + _localctx.head = esHead(); State = 966; - Match(T__27); + _localctx.startLine = int32(); State = 967; - int32(); + Match(T__27); State = 968; - Match(T__74); + _localctx.endLine = int32(); State = 969; - int32(); - } - break; - case 9: - EnterOuterAlt(_localctx, 9); - { + Match(T__74); + State = 970; + _localctx.startColumn = int32(); State = 971; - esHead(); - State = 972; - int32(); - State = 973; Match(T__27); + State = 972; + _localctx.endColumn = int32(); State = 974; - int32(); - State = 975; - Match(T__74); - State = 976; - int32(); - State = 977; - Match(T__27); - State = 978; - int32(); - State = 979; - Match(SQSTRING); - } - break; - case 10: - EnterOuterAlt(_localctx, 10); - { - State = 981; - esHead(); - State = 982; - int32(); - State = 983; - Match(T__27); - State = 984; - int32(); - State = 985; - Match(T__74); - State = 986; - int32(); - State = 987; - Match(T__27); - State = 988; - int32(); - } - break; - case 11: - EnterOuterAlt(_localctx, 11); - { - State = 990; - esHead(); - State = 991; - int32(); - State = 992; - Match(QSTRING); - } - break; - case 12: - EnterOuterAlt(_localctx, 12); - { - State = 994; - esHead(); - State = 995; - int32(); - State = 996; - Match(T__74); - State = 997; - int32(); - State = 998; - Match(QSTRING); - } - break; - case 13: - EnterOuterAlt(_localctx, 13); - { - State = 1000; - esHead(); - State = 1001; - int32(); - State = 1002; - Match(T__74); - State = 1003; - int32(); - State = 1004; - Match(T__27); - State = 1005; - int32(); - State = 1006; - Match(QSTRING); - } - break; - case 14: - EnterOuterAlt(_localctx, 14); - { - State = 1008; - esHead(); - State = 1009; - int32(); - State = 1010; - Match(T__27); - State = 1011; - int32(); - State = 1012; - Match(T__74); - State = 1013; - int32(); - State = 1014; - Match(QSTRING); + ErrorHandler.Sync(this); + switch ( Interpreter.AdaptivePredict(TokenStream,33,Context) ) { + case 1: + { + State = 973; + _localctx.path = TokenStream.LT(1); + _la = TokenStream.LA(1); + if ( !(_la==QSTRING || _la==SQSTRING) ) { + _localctx.path = ErrorHandler.RecoverInline(this); + } + else { + ErrorHandler.ReportMatch(this); + Consume(); + } + } + break; } - break; - case 15: - EnterOuterAlt(_localctx, 15); - { - State = 1016; - esHead(); - State = 1017; - int32(); - State = 1018; - Match(T__27); - State = 1019; - int32(); - State = 1020; - Match(T__74); - State = 1021; - int32(); - State = 1022; - Match(T__27); - State = 1023; - int32(); - State = 1024; - Match(QSTRING); + _localctx.Value = Actions.CreateSourceRange( + _localctx.head.AutoIncrement, + (_localctx.startLine!=null?(_localctx.startLine.Start):null), + (_localctx.endLine!=null?(_localctx.endLine.Start):null), + (_localctx.startColumn!=null?(_localctx.startColumn.Start):null), + (_localctx.endColumn!=null?(_localctx.endColumn.Start):null), + _localctx.path); } break; } @@ -4142,7 +4102,7 @@ public ExtSourceSpecContext extSourceSpec() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); + Actions.EndSourceDirective(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; @@ -4189,68 +4149,68 @@ public FileDeclContext fileDecl() { BeginSubtree(); Actions.BeginSemanticRoot(_localctx); int _la; try { - State = 1054; + State = 1006; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,32,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,37,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1028; + State = 980; Match(T__20); - State = 1032; + State = 984; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__75) { { { - State = 1029; + State = 981; fileAttr(); } } - State = 1034; + State = 986; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 1035; + State = 987; dottedName(); - State = 1036; + State = 988; fileEntry(); - State = 1037; + State = 989; Match(HASH); - State = 1038; + State = 990; Match(T__35); - State = 1039; + State = 991; Match(T__29); - State = 1040; + State = 992; bytes(); - State = 1041; + State = 993; Match(T__30); - State = 1042; + State = 994; fileEntry(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1044; + State = 996; Match(T__20); - State = 1048; + State = 1000; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__75) { { { - State = 1045; + State = 997; fileAttr(); } } - State = 1050; + State = 1002; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 1051; + State = 1003; dottedName(); - State = 1052; + State = 1004; fileEntry(); } break; @@ -4289,7 +4249,7 @@ public FileAttrContext fileAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 1056; + State = 1008; Match(T__75); } } @@ -4324,7 +4284,7 @@ public FileEntryContext fileEntry() { FileEntryContext _localctx = new FileEntryContext(Context, State); EnterRule(_localctx, 94, RULE_fileEntry); try { - State = 1060; + State = 1012; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -4374,7 +4334,7 @@ public FileEntryContext fileEntry() { case ENTRYPOINT: EnterOuterAlt(_localctx, 2); { - State = 1059; + State = 1011; Match(ENTRYPOINT); } break; @@ -4415,7 +4375,7 @@ public AsmAttrAnyContext asmAttrAny() { try { EnterOuterAlt(_localctx, 1); { - State = 1062; + State = 1014; _la = TokenStream.LA(1); if ( !(_la==T__1 || _la==T__60 || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 127L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -4465,17 +4425,17 @@ public AsmAttrContext asmAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 1067; + State = 1019; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__1 || _la==T__60 || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 127L) != 0)) { { { - State = 1064; + State = 1016; asmAttrAny(); } } - State = 1069; + State = 1021; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -4544,22 +4504,22 @@ public InstrContext instr() { InstrContext _localctx = new InstrContext(Context, State); EnterRule(_localctx, 100, RULE_instr); try { - State = 1095; + State = 1047; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,35,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,40,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1070; + State = 1022; simpleInstr(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1071; + State = 1023; _localctx.op = Match(INSTR_METHOD); - State = 1072; + State = 1024; _localctx.methodOperand = methodRef(); Actions.EmitMethodReferenceInstruction(_localctx.op, _localctx.methodOperand); } @@ -4567,9 +4527,9 @@ public InstrContext instr() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1075; + State = 1027; _localctx.op = Match(INSTR_FIELD); - State = 1076; + State = 1028; _localctx.fieldOperand = fieldRef(); Actions.EmitFieldReferenceInstruction(_localctx.op, _localctx.fieldOperand); } @@ -4577,9 +4537,9 @@ public InstrContext instr() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1079; + State = 1031; _localctx.op = Match(INSTR_FIELD); - State = 1080; + State = 1032; _localctx.metadataOperand = mdtoken(); Actions.EmitMetadataTokenInstruction(_localctx.op, _localctx.metadataOperand); } @@ -4587,9 +4547,9 @@ public InstrContext instr() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1083; + State = 1035; _localctx.op = Match(INSTR_TYPE); - State = 1084; + State = 1036; _localctx.typeOperand = typeSpec(); Actions.EmitTypeReferenceInstruction(_localctx.op, _localctx.typeOperand); } @@ -4597,9 +4557,9 @@ public InstrContext instr() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1087; + State = 1039; _localctx.op = Match(INSTR_SIG); - State = 1088; + State = 1040; _localctx.signatureOperand = calliSignature(); Actions.EmitCalliInstruction(_localctx.op, _localctx.signatureOperand); } @@ -4607,9 +4567,9 @@ public InstrContext instr() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1091; + State = 1043; _localctx.op = Match(INSTR_TOK); - State = 1092; + State = 1044; _localctx.ownerOperand = ownerType(); Actions.EmitOwnerTokenInstruction(_localctx.op, _localctx.ownerOperand); } @@ -4691,13 +4651,13 @@ public SimpleInstrContext simpleInstr() { SimpleInstrContext _localctx = new SimpleInstrContext(Context, State); EnterRule(_localctx, 102, RULE_simpleInstr); try { - State = 1175; + State = 1127; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,37,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,42,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1097; + State = 1049; _localctx.op = Match(INSTR_NONE); Actions.EmitNoOperandInstruction(_localctx.op); } @@ -4705,9 +4665,9 @@ public SimpleInstrContext simpleInstr() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1099; + State = 1051; _localctx.op = Match(INSTR_VAR); - State = 1100; + State = 1052; _localctx.index = int32(); Actions.EmitVariableIndexInstruction(_localctx.op, (_localctx.index!=null?(_localctx.index.Start):null)); } @@ -4715,9 +4675,9 @@ public SimpleInstrContext simpleInstr() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1103; + State = 1055; _localctx.op = Match(INSTR_VAR); - State = 1104; + State = 1056; _localctx.name = id(); Actions.EmitVariableNameInstruction(_localctx.op, (_localctx.name!=null?(_localctx.name.Start):null)); } @@ -4725,9 +4685,9 @@ public SimpleInstrContext simpleInstr() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1107; + State = 1059; _localctx.op = Match(INSTR_I); - State = 1108; + State = 1060; _localctx.value32 = int32(); Actions.EmitInt32Instruction(_localctx.op, (_localctx.value32!=null?(_localctx.value32.Start):null)); } @@ -4735,9 +4695,9 @@ public SimpleInstrContext simpleInstr() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1111; + State = 1063; _localctx.op = Match(INSTR_I8); - State = 1112; + State = 1064; _localctx.value64 = int64(); Actions.EmitInt64Instruction(_localctx.op, (_localctx.value64!=null?(_localctx.value64.Start):null)); } @@ -4745,9 +4705,9 @@ public SimpleInstrContext simpleInstr() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1115; + State = 1067; _localctx.op = Match(INSTR_R); - State = 1116; + State = 1068; _localctx.value = float64(); Actions.EmitFloatingInstruction(_localctx.op, _localctx.value.Value); } @@ -4755,9 +4715,9 @@ public SimpleInstrContext simpleInstr() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1119; + State = 1071; _localctx.op = Match(INSTR_R); - State = 1120; + State = 1072; _localctx.integerValue = int64(); Actions.EmitFloatingInstruction(_localctx.op, (_localctx.integerValue!=null?(_localctx.integerValue.Start):null)); } @@ -4765,13 +4725,13 @@ public SimpleInstrContext simpleInstr() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1123; + State = 1075; _localctx.op = Match(INSTR_R); - State = 1124; + State = 1076; Match(T__29); - State = 1125; + State = 1077; _localctx.rawFloat = bytes(); - State = 1126; + State = 1078; Match(T__30); Actions.EmitRawFloatingInstruction(_localctx.op, _localctx.rawFloat.Value, (_localctx.rawFloat!=null?(_localctx.rawFloat.Start):null)); } @@ -4779,15 +4739,15 @@ public SimpleInstrContext simpleInstr() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1129; + State = 1081; _localctx.op = Match(INSTR_R); - State = 1130; + State = 1082; Match(T__83); - State = 1131; + State = 1083; Match(T__29); - State = 1132; + State = 1084; _localctx.rawFloat = bytes(); - State = 1133; + State = 1085; Match(T__30); Actions.EmitRawFloatingInstruction(_localctx.op, _localctx.rawFloat.Value, (_localctx.rawFloat!=null?(_localctx.rawFloat.Start):null)); } @@ -4795,9 +4755,9 @@ public SimpleInstrContext simpleInstr() { case 10: EnterOuterAlt(_localctx, 10); { - State = 1136; + State = 1088; _localctx.op = Match(INSTR_BRTARGET); - State = 1137; + State = 1089; _localctx.offset = int32(); Actions.EmitBranchOffsetInstruction(_localctx.op, (_localctx.offset!=null?(_localctx.offset.Start):null)); } @@ -4805,9 +4765,9 @@ public SimpleInstrContext simpleInstr() { case 11: EnterOuterAlt(_localctx, 11); { - State = 1140; + State = 1092; _localctx.op = Match(INSTR_BRTARGET); - State = 1141; + State = 1093; _localctx.label = id(); Actions.EmitBranchLabelInstruction(_localctx.op, (_localctx.label!=null?(_localctx.label.Start):null)); } @@ -4815,9 +4775,9 @@ public SimpleInstrContext simpleInstr() { case 12: EnterOuterAlt(_localctx, 12); { - State = 1144; + State = 1096; _localctx.op = Match(INSTR_STRING); - State = 1145; + State = 1097; _localctx.userString = compQstring(); Actions.EmitStringInstruction(_localctx.op, _localctx.userString.Value); } @@ -4825,15 +4785,15 @@ public SimpleInstrContext simpleInstr() { case 13: EnterOuterAlt(_localctx, 13); { - State = 1148; + State = 1100; _localctx.op = Match(INSTR_STRING); - State = 1149; + State = 1101; Match(ANSI); - State = 1150; + State = 1102; Match(T__29); - State = 1151; + State = 1103; _localctx.ansiString = compQstring(); - State = 1152; + State = 1104; Match(T__30); Actions.EmitAnsiStringInstruction(_localctx.op, _localctx.ansiString.Value); } @@ -4841,15 +4801,15 @@ public SimpleInstrContext simpleInstr() { case 14: EnterOuterAlt(_localctx, 14); { - State = 1155; + State = 1107; _localctx.op = Match(INSTR_STRING); - State = 1156; + State = 1108; Match(T__83); - State = 1157; + State = 1109; Match(T__29); - State = 1158; + State = 1110; _localctx.rawString = bytes(); - State = 1159; + State = 1111; Match(T__30); Actions.EmitRawStringInstruction(_localctx.op, _localctx.rawString.Value); } @@ -4857,9 +4817,9 @@ public SimpleInstrContext simpleInstr() { case 15: EnterOuterAlt(_localctx, 15); { - State = 1162; + State = 1114; _localctx.op = Match(INSTR_TOK); - State = 1163; + State = 1115; _localctx.rawToken = int32(); Actions.EmitRawTokenInstruction(_localctx.op, (_localctx.rawToken!=null?(_localctx.rawToken.Start):null)); } @@ -4867,25 +4827,25 @@ public SimpleInstrContext simpleInstr() { case 16: EnterOuterAlt(_localctx, 16); { - State = 1166; + State = 1118; _localctx.op = Match(INSTR_SWITCH); Actions.BeginSwitchInstruction(_localctx, _localctx.op); - State = 1173; + State = 1125; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__29: { - State = 1168; + State = 1120; Match(T__29); - State = 1169; + State = 1121; labels(); - State = 1170; + State = 1122; Match(T__30); } break; case T__84: { - State = 1172; + State = 1124; Match(T__84); } break; @@ -4946,11 +4906,11 @@ public CalliSignatureContext calliSignature() { try { EnterOuterAlt(_localctx, 1); { - State = 1177; + State = 1129; _localctx.convention = callConv(); - State = 1178; + State = 1130; _localctx.returnType = type(); - State = 1179; + State = 1131; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateCalliSignature(_localctx.convention.Value, _localctx.returnType.Value, _localctx.arguments.Value); } @@ -5003,7 +4963,7 @@ public LabelsContext labels() { EnterRule(_localctx, 106, RULE_labels); try { int _alt; - State = 1206; + State = 1158; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__30: @@ -5034,14 +4994,14 @@ public LabelsContext labels() { case ID: EnterOuterAlt(_localctx, 2); { - State = 1195; + State = 1147; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,39,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,44,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1189; + State = 1141; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -5065,14 +5025,14 @@ public LabelsContext labels() { case SQSTRING: case ID: { - State = 1183; + State = 1135; _localctx.headLabel = id(); Actions.AddSwitchLabel((_localctx.headLabel!=null?(_localctx.headLabel.Start):null)); } break; case INT32: { - State = 1186; + State = 1138; _localctx.headOffset = int32(); Actions.AddSwitchOffset((_localctx.headOffset!=null?(_localctx.headOffset.Start):null)); } @@ -5080,16 +5040,16 @@ public LabelsContext labels() { default: throw new NoViableAltException(this); } - State = 1191; + State = 1143; Match(T__27); } } } - State = 1197; + State = 1149; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,39,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,44,Context); } - State = 1204; + State = 1156; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -5113,14 +5073,14 @@ public LabelsContext labels() { case SQSTRING: case ID: { - State = 1198; + State = 1150; _localctx.tailLabel = id(); Actions.AddSwitchLabel((_localctx.tailLabel!=null?(_localctx.tailLabel.Start):null)); } break; case INT32: { - State = 1201; + State = 1153; _localctx.tailOffset = int32(); Actions.AddSwitchOffset((_localctx.tailOffset!=null?(_localctx.tailOffset.Start):null)); } @@ -5177,31 +5137,31 @@ public TypeArgsContext typeArgs() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1208; + State = 1160; Match(T__85); - State = 1215; + State = 1167; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,42,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,47,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1209; + State = 1161; _localctx.argument = type(); Actions.AddTypeArgument(_localctx, _localctx.argument.Value); - State = 1211; + State = 1163; Match(T__27); } } } - State = 1217; + State = 1169; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,42,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,47,Context); } - State = 1218; + State = 1170; _localctx.lastArgument = type(); Actions.AddTypeArgument(_localctx, _localctx.lastArgument.Value); - State = 1220; + State = 1172; Match(T__86); } } @@ -5249,31 +5209,31 @@ public BoundsContext bounds() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1222; + State = 1174; Match(T__41); - State = 1229; + State = 1181; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,43,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,48,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1223; + State = 1175; _localctx.item = bound(); Actions.AddBound(_localctx, _localctx.item); - State = 1225; + State = 1177; Match(T__27); } } } - State = 1231; + State = 1183; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,43,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,48,Context); } - State = 1232; + State = 1184; _localctx.lastItem = bound(); Actions.AddBound(_localctx, _localctx.lastItem); - State = 1234; + State = 1186; Match(T__42); } } @@ -5319,44 +5279,44 @@ public SigArgsContext sigArgs() { Actions.BeginSignatureArguments(_localctx); try { int _alt; - State = 1251; + State = 1203; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__29: EnterOuterAlt(_localctx, 1); { - State = 1236; + State = 1188; Match(T__29); - State = 1243; + State = 1195; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,44,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,49,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1237; + State = 1189; _localctx.argument = sigArg(); Actions.AddSignatureArgument(_localctx, _localctx.argument.Value); - State = 1239; + State = 1191; Match(T__27); } } } - State = 1245; + State = 1197; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,44,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,49,Context); } - State = 1246; + State = 1198; _localctx.lastArgument = sigArg(); Actions.AddSignatureArgument(_localctx, _localctx.lastArgument.Value); - State = 1248; + State = 1200; Match(T__30); } break; case T__84: EnterOuterAlt(_localctx, 2); { - State = 1250; + State = 1202; Match(T__84); } break; @@ -5414,13 +5374,13 @@ public SigArgContext sigArg() { EnterRule(_localctx, 114, RULE_sigArg); int _la; try { - State = 1263; + State = 1215; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,47,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,52,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1253; + State = 1205; Match(ELLIPSIS); _localctx.Value = Actions.CreateSentinelSignatureArgument(); } @@ -5428,18 +5388,18 @@ public SigArgContext sigArg() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1255; + State = 1207; _localctx.attributes = paramAttr(); - State = 1256; + State = 1208; _localctx.argumentType = type(); - State = 1257; + State = 1209; _localctx.marshalling = marshalClause(); - State = 1259; + State = 1211; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 65534L) != 0) || ((((_la - 199)) & ~0x3f) == 0 && ((1L << (_la - 199)) & 299067162755073L) != 0) || _la==SQSTRING || _la==ID) { { - State = 1258; + State = 1210; _localctx.name = id(); } } @@ -5499,19 +5459,19 @@ public ClassNameContext className() { ClassNameContext _localctx = new ClassNameContext(Context, State); EnterRule(_localctx, 116, RULE_className); try { - State = 1302; + State = 1254; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,48,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,53,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1265; + State = 1217; Match(T__41); - State = 1266; + State = 1218; _localctx.assemblyName = dottedName(); - State = 1267; + State = 1219; Match(T__42); - State = 1268; + State = 1220; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreateAssemblyQualifiedClassName(_localctx.assemblyName.Value, _localctx.typeName.Value); } @@ -5519,13 +5479,13 @@ public ClassNameContext className() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1271; + State = 1223; Match(T__41); - State = 1272; + State = 1224; _localctx.scopeToken = mdtoken(); - State = 1273; + State = 1225; Match(T__42); - State = 1274; + State = 1226; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreateTokenQualifiedClassName(_localctx.scopeToken.Value, _localctx.typeName.Value); } @@ -5533,13 +5493,13 @@ public ClassNameContext className() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1277; + State = 1229; Match(T__41); - State = 1278; + State = 1230; Match(PTR); - State = 1279; + State = 1231; Match(T__42); - State = 1280; + State = 1232; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreatePointerQualifiedClassName(_localctx.typeName.Value); } @@ -5547,15 +5507,15 @@ public ClassNameContext className() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1283; + State = 1235; Match(T__41); - State = 1284; + State = 1236; Match(MODULE); - State = 1285; + State = 1237; _localctx.moduleName = dottedName(); - State = 1286; + State = 1238; Match(T__42); - State = 1287; + State = 1239; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreateModuleQualifiedClassName(_localctx.Start, _localctx.moduleName.Value, _localctx.typeName.Value); } @@ -5563,7 +5523,7 @@ public ClassNameContext className() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1290; + State = 1242; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreateUnqualifiedClassName(_localctx.typeName.Value); } @@ -5571,7 +5531,7 @@ public ClassNameContext className() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1293; + State = 1245; _localctx.typeToken = mdtoken(); _localctx.Value = Actions.CreateTokenClassName(_localctx.typeToken.Value); } @@ -5579,7 +5539,7 @@ public ClassNameContext className() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1296; + State = 1248; Match(THIS); _localctx.Value = Actions.CreateThisClassName(_localctx.Start); } @@ -5587,7 +5547,7 @@ public ClassNameContext className() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1298; + State = 1250; Match(BASE); _localctx.Value = Actions.CreateBaseClassName(_localctx.Start); } @@ -5595,7 +5555,7 @@ public ClassNameContext className() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1300; + State = 1252; Match(NESTER); _localctx.Value = Actions.CreateNesterClassName(_localctx.Start); } @@ -5645,26 +5605,26 @@ public SlashedNameContext slashedName() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1310; + State = 1262; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,49,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,54,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1304; + State = 1256; _localctx.part = dottedName(); Actions.AddSlashedNamePart(_localctx, _localctx.part.Value); - State = 1306; + State = 1258; Match(T__87); } } } - State = 1312; + State = 1264; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,49,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,54,Context); } - State = 1313; + State = 1265; _localctx.lastPart = dottedName(); Actions.AddSlashedNamePart(_localctx, _localctx.lastPart.Value); } @@ -5709,17 +5669,17 @@ public AssemblyDeclsContext assemblyDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 1319; + State = 1271; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38654771200L) != 0) || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & 4294975503L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 6860954690125825L) != 0)) { { { - State = 1316; + State = 1268; assemblyDecl(); } } - State = 1321; + State = 1273; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -5765,18 +5725,18 @@ public AssemblyDeclContext assemblyDecl() { AssemblyDeclContext _localctx = new AssemblyDeclContext(Context, State); EnterRule(_localctx, 122, RULE_assemblyDecl); try { - State = 1327; + State = 1279; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case HASH: EnterOuterAlt(_localctx, 1); { { - State = 1322; + State = 1274; Match(HASH); - State = 1323; + State = 1275; Match(T__88); - State = 1324; + State = 1276; int32(); } } @@ -5785,7 +5745,7 @@ public AssemblyDeclContext assemblyDecl() { case PERMISSIONSET: EnterOuterAlt(_localctx, 2); { - State = 1325; + State = 1277; secDecl(); } break; @@ -5810,7 +5770,7 @@ public AssemblyDeclContext assemblyDecl() { case ID: EnterOuterAlt(_localctx, 3); { - State = 1326; + State = 1278; asmOrRefDecl(); } break; @@ -5865,13 +5825,13 @@ public TypeSpecContext typeSpec() { EnterRule(_localctx, 124, RULE_typeSpec); Actions.BeginSemanticRoot(_localctx); try { - State = 1346; + State = 1298; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,52,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,57,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1329; + State = 1281; _localctx.classType = className(); _localctx.Value = Actions.CreateClassTypeSpecification(_localctx.classType.Value); } @@ -5879,11 +5839,11 @@ public TypeSpecContext typeSpec() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1332; + State = 1284; Match(T__41); - State = 1333; + State = 1285; _localctx.assemblyName = dottedName(); - State = 1334; + State = 1286; Match(T__42); _localctx.Value = Actions.CreateAssemblyTypeSpecification(_localctx.assemblyName.Value); } @@ -5891,13 +5851,13 @@ public TypeSpecContext typeSpec() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1337; + State = 1289; Match(T__41); - State = 1338; + State = 1290; Match(MODULE); - State = 1339; + State = 1291; _localctx.moduleName = dottedName(); - State = 1340; + State = 1292; Match(T__42); _localctx.Value = Actions.CreateModuleTypeSpecification(_localctx.moduleName.Value); } @@ -5905,7 +5865,7 @@ public TypeSpecContext typeSpec() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1343; + State = 1295; _localctx.signatureType = type(); _localctx.Value = Actions.CreateSignatureTypeSpecification(_localctx.signatureType.Value); } @@ -5957,9 +5917,9 @@ public NativeTypeContext nativeType() { Actions.BeginNativeType(_localctx); try { int _alt; - State = 1359; + State = 1311; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,54,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,59,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -5968,25 +5928,25 @@ public NativeTypeContext nativeType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1349; + State = 1301; _localctx.element = nativeTypeElement(); Actions.SetNativeTypeElement(_localctx, _localctx.element.Value); - State = 1356; + State = 1308; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,53,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,58,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1351; + State = 1303; _localctx.info = nativeTypeArrayPointerInfo(); Actions.AddNativeTypeArrayPointerInfo(_localctx, _localctx.info.Value); } } } - State = 1358; + State = 1310; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,53,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,58,Context); } } break; @@ -6089,14 +6049,14 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { NativeTypeArrayPointerInfoContext _localctx = new NativeTypeArrayPointerInfoContext(Context, State); EnterRule(_localctx, 128, RULE_nativeTypeArrayPointerInfo); try { - State = 1383; + State = 1335; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,55,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,60,Context) ) { case 1: _localctx = new PointerNativeTypeContext(_localctx); EnterOuterAlt(_localctx, 1); { - State = 1361; + State = 1313; Match(PTR); _localctx.Value = Actions.CreatePointerNativeType(); } @@ -6105,7 +6065,7 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeNoSizeDataContext(_localctx); EnterOuterAlt(_localctx, 2); { - State = 1363; + State = 1315; Match(ARRAY_TYPE_NO_BOUNDS); _localctx.Value = Actions.CreatePointerArrayTypeNoSizeData(); } @@ -6114,11 +6074,11 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeSizeContext(_localctx); EnterOuterAlt(_localctx, 3); { - State = 1365; + State = 1317; Match(T__41); - State = 1366; + State = 1318; ((PointerArrayTypeSizeContext)_localctx).size = int32(); - State = 1367; + State = 1319; Match(T__42); _localctx.Value = Actions.CreatePointerArrayTypeSize((((PointerArrayTypeSizeContext)_localctx).size!=null?(((PointerArrayTypeSizeContext)_localctx).size.Start):null)); } @@ -6127,15 +6087,15 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeSizeParamIndexContext(_localctx); EnterOuterAlt(_localctx, 4); { - State = 1370; + State = 1322; Match(T__41); - State = 1371; + State = 1323; ((PointerArrayTypeSizeParamIndexContext)_localctx).size = int32(); - State = 1372; + State = 1324; Match(PLUS); - State = 1373; + State = 1325; ((PointerArrayTypeSizeParamIndexContext)_localctx).parameterIndex = int32(); - State = 1374; + State = 1326; Match(T__42); _localctx.Value = Actions.CreatePointerArrayTypeSizeParamIndex((((PointerArrayTypeSizeParamIndexContext)_localctx).size!=null?(((PointerArrayTypeSizeParamIndexContext)_localctx).size.Start):null), (((PointerArrayTypeSizeParamIndexContext)_localctx).parameterIndex!=null?(((PointerArrayTypeSizeParamIndexContext)_localctx).parameterIndex.Start):null)); } @@ -6144,13 +6104,13 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeParamIndexContext(_localctx); EnterOuterAlt(_localctx, 5); { - State = 1377; + State = 1329; Match(T__41); - State = 1378; + State = 1330; Match(PLUS); - State = 1379; + State = 1331; ((PointerArrayTypeParamIndexContext)_localctx).parameterIndex = int32(); - State = 1380; + State = 1332; Match(T__42); _localctx.Value = Actions.CreatePointerArrayTypeParamIndex((((PointerArrayTypeParamIndexContext)_localctx).parameterIndex!=null?(((PointerArrayTypeParamIndexContext)_localctx).parameterIndex.Start):null)); } @@ -6262,9 +6222,9 @@ public NativeTypeElementContext nativeTypeElement() { NativeTypeElementContext _localctx = new NativeTypeElementContext(Context, State); EnterRule(_localctx, 130, RULE_nativeTypeElement); try { - State = 1530; + State = 1482; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,56,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,61,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -6274,25 +6234,25 @@ public NativeTypeElementContext nativeTypeElement() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1386; + State = 1338; _localctx.marshalType = Match(CUSTOM); - State = 1387; + State = 1339; Match(T__29); - State = 1388; + State = 1340; _localctx.guid = compQstring(); - State = 1389; + State = 1341; Match(T__27); - State = 1390; + State = 1342; _localctx.nativeTypeName = compQstring(); - State = 1391; + State = 1343; Match(T__27); - State = 1392; + State = 1344; _localctx.marshallerType = compQstring(); - State = 1393; + State = 1345; Match(T__27); - State = 1394; + State = 1346; _localctx.cookie = compQstring(); - State = 1395; + State = 1347; Match(T__30); _localctx.Value = Actions.CreateDeprecatedCustomMarshallerNativeType( _localctx, _localctx.guid.Value, _localctx.nativeTypeName.Value, _localctx.marshallerType.Value, _localctx.cookie.Value); @@ -6301,17 +6261,17 @@ public NativeTypeElementContext nativeTypeElement() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1398; + State = 1350; _localctx.marshalType = Match(CUSTOM); - State = 1399; + State = 1351; Match(T__29); - State = 1400; + State = 1352; _localctx.marshallerType = compQstring(); - State = 1401; + State = 1353; Match(T__27); - State = 1402; + State = 1354; _localctx.cookie = compQstring(); - State = 1403; + State = 1355; Match(T__30); _localctx.Value = Actions.CreateCustomMarshallerNativeType(_localctx.marshallerType.Value, _localctx.cookie.Value); } @@ -6319,15 +6279,15 @@ public NativeTypeElementContext nativeTypeElement() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1406; + State = 1358; Match(FIXED); - State = 1407; + State = 1359; _localctx.marshalType = Match(SYSSTRING); - State = 1408; + State = 1360; Match(T__41); - State = 1409; + State = 1361; _localctx.size = int32(); - State = 1410; + State = 1362; Match(T__42); _localctx.Value = Actions.CreateFixedSysStringNativeType((_localctx.size!=null?(_localctx.size.Start):null)); } @@ -6335,17 +6295,17 @@ public NativeTypeElementContext nativeTypeElement() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1413; + State = 1365; Match(FIXED); - State = 1414; + State = 1366; _localctx.marshalType = Match(ARRAY); - State = 1415; + State = 1367; Match(T__41); - State = 1416; + State = 1368; _localctx.size = int32(); - State = 1417; + State = 1369; Match(T__42); - State = 1418; + State = 1370; _localctx.element = nativeType(); _localctx.Value = Actions.CreateFixedArrayNativeType((_localctx.size!=null?(_localctx.size.Start):null), _localctx.element.Value); } @@ -6353,7 +6313,7 @@ public NativeTypeElementContext nativeTypeElement() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1421; + State = 1373; _localctx.marshalType = Match(VARIANT); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6361,7 +6321,7 @@ public NativeTypeElementContext nativeTypeElement() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1423; + State = 1375; _localctx.marshalType = Match(CURRENCY); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6369,7 +6329,7 @@ public NativeTypeElementContext nativeTypeElement() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1425; + State = 1377; _localctx.marshalType = Match(SYSCHAR); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6377,7 +6337,7 @@ public NativeTypeElementContext nativeTypeElement() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1427; + State = 1379; _localctx.marshalType = Match(VOID); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6385,7 +6345,7 @@ public NativeTypeElementContext nativeTypeElement() { case 10: EnterOuterAlt(_localctx, 10); { - State = 1429; + State = 1381; _localctx.marshalType = Match(BOOL); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6393,7 +6353,7 @@ public NativeTypeElementContext nativeTypeElement() { case 11: EnterOuterAlt(_localctx, 11); { - State = 1431; + State = 1383; _localctx.marshalType = Match(INT8); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6401,7 +6361,7 @@ public NativeTypeElementContext nativeTypeElement() { case 12: EnterOuterAlt(_localctx, 12); { - State = 1433; + State = 1385; _localctx.marshalType = Match(INT16); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6409,7 +6369,7 @@ public NativeTypeElementContext nativeTypeElement() { case 13: EnterOuterAlt(_localctx, 13); { - State = 1435; + State = 1387; _localctx.marshalType = Match(INT32_); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6417,7 +6377,7 @@ public NativeTypeElementContext nativeTypeElement() { case 14: EnterOuterAlt(_localctx, 14); { - State = 1437; + State = 1389; _localctx.marshalType = Match(INT64_); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6425,7 +6385,7 @@ public NativeTypeElementContext nativeTypeElement() { case 15: EnterOuterAlt(_localctx, 15); { - State = 1439; + State = 1391; _localctx.marshalType = Match(FLOAT32); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6433,7 +6393,7 @@ public NativeTypeElementContext nativeTypeElement() { case 16: EnterOuterAlt(_localctx, 16); { - State = 1441; + State = 1393; _localctx.marshalType = Match(FLOAT64_); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6441,7 +6401,7 @@ public NativeTypeElementContext nativeTypeElement() { case 17: EnterOuterAlt(_localctx, 17); { - State = 1443; + State = 1395; _localctx.marshalType = Match(ERROR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6449,7 +6409,7 @@ public NativeTypeElementContext nativeTypeElement() { case 18: EnterOuterAlt(_localctx, 18); { - State = 1445; + State = 1397; _localctx.marshalType = Match(UINT8); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6457,7 +6417,7 @@ public NativeTypeElementContext nativeTypeElement() { case 19: EnterOuterAlt(_localctx, 19); { - State = 1447; + State = 1399; _localctx.marshalType = Match(UINT16); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6465,7 +6425,7 @@ public NativeTypeElementContext nativeTypeElement() { case 20: EnterOuterAlt(_localctx, 20); { - State = 1449; + State = 1401; _localctx.marshalType = Match(UINT32); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6473,7 +6433,7 @@ public NativeTypeElementContext nativeTypeElement() { case 21: EnterOuterAlt(_localctx, 21); { - State = 1451; + State = 1403; _localctx.marshalType = Match(UINT64); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6481,7 +6441,7 @@ public NativeTypeElementContext nativeTypeElement() { case 22: EnterOuterAlt(_localctx, 22); { - State = 1453; + State = 1405; _localctx.marshalType = Match(DECIMAL); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6489,7 +6449,7 @@ public NativeTypeElementContext nativeTypeElement() { case 23: EnterOuterAlt(_localctx, 23); { - State = 1455; + State = 1407; _localctx.marshalType = Match(DATE); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6497,7 +6457,7 @@ public NativeTypeElementContext nativeTypeElement() { case 24: EnterOuterAlt(_localctx, 24); { - State = 1457; + State = 1409; _localctx.marshalType = Match(BSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6505,7 +6465,7 @@ public NativeTypeElementContext nativeTypeElement() { case 25: EnterOuterAlt(_localctx, 25); { - State = 1459; + State = 1411; _localctx.marshalType = Match(LPSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6513,7 +6473,7 @@ public NativeTypeElementContext nativeTypeElement() { case 26: EnterOuterAlt(_localctx, 26); { - State = 1461; + State = 1413; _localctx.marshalType = Match(LPWSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6521,7 +6481,7 @@ public NativeTypeElementContext nativeTypeElement() { case 27: EnterOuterAlt(_localctx, 27); { - State = 1463; + State = 1415; _localctx.marshalType = Match(LPTSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6529,7 +6489,7 @@ public NativeTypeElementContext nativeTypeElement() { case 28: EnterOuterAlt(_localctx, 28); { - State = 1465; + State = 1417; _localctx.marshalType = Match(OBJECTREF); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6537,9 +6497,9 @@ public NativeTypeElementContext nativeTypeElement() { case 29: EnterOuterAlt(_localctx, 29); { - State = 1467; + State = 1419; _localctx.marshalType = Match(IUNKNOWN); - State = 1468; + State = 1420; _localctx.index = iidParamIndex(); _localctx.Value = Actions.CreateIidNativeType(_localctx.marshalType, _localctx.index.Value); } @@ -6547,9 +6507,9 @@ public NativeTypeElementContext nativeTypeElement() { case 30: EnterOuterAlt(_localctx, 30); { - State = 1471; + State = 1423; _localctx.marshalType = Match(IDISPATCH); - State = 1472; + State = 1424; _localctx.index = iidParamIndex(); _localctx.Value = Actions.CreateIidNativeType(_localctx.marshalType, _localctx.index.Value); } @@ -6557,7 +6517,7 @@ public NativeTypeElementContext nativeTypeElement() { case 31: EnterOuterAlt(_localctx, 31); { - State = 1475; + State = 1427; _localctx.marshalType = Match(STRUCT); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6565,9 +6525,9 @@ public NativeTypeElementContext nativeTypeElement() { case 32: EnterOuterAlt(_localctx, 32); { - State = 1477; + State = 1429; _localctx.marshalType = Match(INTERFACE); - State = 1478; + State = 1430; _localctx.index = iidParamIndex(); _localctx.Value = Actions.CreateIidNativeType(_localctx.marshalType, _localctx.index.Value); } @@ -6575,9 +6535,9 @@ public NativeTypeElementContext nativeTypeElement() { case 33: EnterOuterAlt(_localctx, 33); { - State = 1481; + State = 1433; _localctx.marshalType = Match(SAFEARRAY); - State = 1482; + State = 1434; _localctx.variant = variantType(); _localctx.Value = Actions.CreateSafeArrayNativeType(_localctx.variant.Value, null); } @@ -6585,13 +6545,13 @@ public NativeTypeElementContext nativeTypeElement() { case 34: EnterOuterAlt(_localctx, 34); { - State = 1485; + State = 1437; _localctx.marshalType = Match(SAFEARRAY); - State = 1486; + State = 1438; _localctx.variant = variantType(); - State = 1487; + State = 1439; Match(T__27); - State = 1488; + State = 1440; _localctx.userDefinedType = compQstring(); _localctx.Value = Actions.CreateSafeArrayNativeType(_localctx.variant.Value, _localctx.userDefinedType.Value); } @@ -6599,7 +6559,7 @@ public NativeTypeElementContext nativeTypeElement() { case 35: EnterOuterAlt(_localctx, 35); { - State = 1491; + State = 1443; _localctx.marshalType = Match(INT); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6607,7 +6567,7 @@ public NativeTypeElementContext nativeTypeElement() { case 36: EnterOuterAlt(_localctx, 36); { - State = 1493; + State = 1445; _localctx.marshalType = Match(UINT); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6615,9 +6575,9 @@ public NativeTypeElementContext nativeTypeElement() { case 37: EnterOuterAlt(_localctx, 37); { - State = 1495; + State = 1447; Match(T__89); - State = 1496; + State = 1448; _localctx.unsignedMarshalType = Match(INT8); _localctx.Value = Actions.CreateUnsignedNativeType(_localctx.unsignedMarshalType); } @@ -6625,9 +6585,9 @@ public NativeTypeElementContext nativeTypeElement() { case 38: EnterOuterAlt(_localctx, 38); { - State = 1498; + State = 1450; Match(T__89); - State = 1499; + State = 1451; _localctx.unsignedMarshalType = Match(INT16); _localctx.Value = Actions.CreateUnsignedNativeType(_localctx.unsignedMarshalType); } @@ -6635,9 +6595,9 @@ public NativeTypeElementContext nativeTypeElement() { case 39: EnterOuterAlt(_localctx, 39); { - State = 1501; + State = 1453; Match(T__89); - State = 1502; + State = 1454; _localctx.unsignedMarshalType = Match(INT32_); _localctx.Value = Actions.CreateUnsignedNativeType(_localctx.unsignedMarshalType); } @@ -6645,9 +6605,9 @@ public NativeTypeElementContext nativeTypeElement() { case 40: EnterOuterAlt(_localctx, 40); { - State = 1504; + State = 1456; Match(T__89); - State = 1505; + State = 1457; _localctx.unsignedMarshalType = Match(INT64_); _localctx.Value = Actions.CreateUnsignedNativeType(_localctx.unsignedMarshalType); } @@ -6655,9 +6615,9 @@ public NativeTypeElementContext nativeTypeElement() { case 41: EnterOuterAlt(_localctx, 41); { - State = 1507; + State = 1459; Match(T__61); - State = 1508; + State = 1460; _localctx.marshalType = Match(STRUCT); _localctx.Value = Actions.CreateNestedStructNativeType(_localctx); } @@ -6665,7 +6625,7 @@ public NativeTypeElementContext nativeTypeElement() { case 42: EnterOuterAlt(_localctx, 42); { - State = 1510; + State = 1462; _localctx.marshalType = Match(BYVALSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6673,9 +6633,9 @@ public NativeTypeElementContext nativeTypeElement() { case 43: EnterOuterAlt(_localctx, 43); { - State = 1512; + State = 1464; Match(ANSI); - State = 1513; + State = 1465; _localctx.marshalType = Match(BSTR); _localctx.Value = Actions.CreateAnsiBstrNativeType(); } @@ -6683,7 +6643,7 @@ public NativeTypeElementContext nativeTypeElement() { case 44: EnterOuterAlt(_localctx, 44); { - State = 1515; + State = 1467; _localctx.marshalType = Match(TBSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6691,9 +6651,9 @@ public NativeTypeElementContext nativeTypeElement() { case 45: EnterOuterAlt(_localctx, 45); { - State = 1517; + State = 1469; Match(VARIANT); - State = 1518; + State = 1470; _localctx.marshalBool = Match(BOOL); _localctx.Value = Actions.CreateVariantBoolNativeType(); } @@ -6701,7 +6661,7 @@ public NativeTypeElementContext nativeTypeElement() { case 46: EnterOuterAlt(_localctx, 46); { - State = 1520; + State = 1472; _localctx.marshalType = Match(METHOD); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6709,7 +6669,7 @@ public NativeTypeElementContext nativeTypeElement() { case 47: EnterOuterAlt(_localctx, 47); { - State = 1522; + State = 1474; _localctx.marshalType = Match(LPSTRUCT); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6717,9 +6677,9 @@ public NativeTypeElementContext nativeTypeElement() { case 48: EnterOuterAlt(_localctx, 48); { - State = 1524; + State = 1476; Match(T__33); - State = 1525; + State = 1477; _localctx.marshalType = Match(ANY); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6727,7 +6687,7 @@ public NativeTypeElementContext nativeTypeElement() { case 49: EnterOuterAlt(_localctx, 49); { - State = 1527; + State = 1479; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateNativeTypeTypedef(_localctx, _localctx.alias.Value); } @@ -6769,7 +6729,7 @@ public IidParamIndexContext iidParamIndex() { IidParamIndexContext _localctx = new IidParamIndexContext(Context, State); EnterRule(_localctx, 132, RULE_iidParamIndex); try { - State = 1540; + State = 1492; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__30: @@ -6783,15 +6743,15 @@ public IidParamIndexContext iidParamIndex() { case T__29: EnterOuterAlt(_localctx, 2); { - State = 1533; + State = 1485; Match(T__29); - State = 1534; + State = 1486; Match(T__90); - State = 1535; + State = 1487; Match(T__35); - State = 1536; + State = 1488; _localctx.index = int32(); - State = 1537; + State = 1489; Match(T__30); _localctx.Value = Actions.GetIidParamIndex((_localctx.index!=null?(_localctx.index.Start):null)); } @@ -6851,9 +6811,9 @@ public VariantTypeContext variantType() { int _la; try { int _alt; - State = 1552; + State = 1504; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,59,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,64,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -6862,17 +6822,17 @@ public VariantTypeContext variantType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1543; + State = 1495; _localctx.element = variantTypeElement(); Actions.SetVariantTypeElement(_localctx, _localctx.element.Value); - State = 1549; + State = 1501; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,58,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,63,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1545; + State = 1497; _localctx.modifier = TokenStream.LT(1); _la = TokenStream.LA(1); if ( !(((((_la - 229)) & ~0x3f) == 0 && ((1L << (_la - 229)) & 6442450945L) != 0)) ) { @@ -6886,9 +6846,9 @@ public VariantTypeContext variantType() { } } } - State = 1551; + State = 1503; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,58,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,63,Context); } } break; @@ -6967,13 +6927,13 @@ public VariantTypeElementContext variantTypeElement() { VariantTypeElementContext _localctx = new VariantTypeElementContext(Context, State); EnterRule(_localctx, 136, RULE_variantTypeElement); try { - State = 1634; + State = 1586; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case NULL: EnterOuterAlt(_localctx, 1); { - State = 1554; + State = 1506; _localctx.value = Match(NULL); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6981,7 +6941,7 @@ public VariantTypeElementContext variantTypeElement() { case VARIANT: EnterOuterAlt(_localctx, 2); { - State = 1556; + State = 1508; _localctx.value = Match(VARIANT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6989,7 +6949,7 @@ public VariantTypeElementContext variantTypeElement() { case CURRENCY: EnterOuterAlt(_localctx, 3); { - State = 1558; + State = 1510; _localctx.value = Match(CURRENCY); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6997,7 +6957,7 @@ public VariantTypeElementContext variantTypeElement() { case VOID: EnterOuterAlt(_localctx, 4); { - State = 1560; + State = 1512; _localctx.value = Match(VOID); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7005,7 +6965,7 @@ public VariantTypeElementContext variantTypeElement() { case BOOL: EnterOuterAlt(_localctx, 5); { - State = 1562; + State = 1514; _localctx.value = Match(BOOL); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7013,7 +6973,7 @@ public VariantTypeElementContext variantTypeElement() { case INT8: EnterOuterAlt(_localctx, 6); { - State = 1564; + State = 1516; _localctx.value = Match(INT8); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7021,7 +6981,7 @@ public VariantTypeElementContext variantTypeElement() { case INT16: EnterOuterAlt(_localctx, 7); { - State = 1566; + State = 1518; _localctx.value = Match(INT16); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7029,7 +6989,7 @@ public VariantTypeElementContext variantTypeElement() { case INT32_: EnterOuterAlt(_localctx, 8); { - State = 1568; + State = 1520; _localctx.value = Match(INT32_); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7037,7 +6997,7 @@ public VariantTypeElementContext variantTypeElement() { case INT64_: EnterOuterAlt(_localctx, 9); { - State = 1570; + State = 1522; _localctx.value = Match(INT64_); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7045,7 +7005,7 @@ public VariantTypeElementContext variantTypeElement() { case FLOAT32: EnterOuterAlt(_localctx, 10); { - State = 1572; + State = 1524; _localctx.value = Match(FLOAT32); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7053,7 +7013,7 @@ public VariantTypeElementContext variantTypeElement() { case FLOAT64_: EnterOuterAlt(_localctx, 11); { - State = 1574; + State = 1526; _localctx.value = Match(FLOAT64_); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7061,7 +7021,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT8: EnterOuterAlt(_localctx, 12); { - State = 1576; + State = 1528; _localctx.value = Match(UINT8); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7069,7 +7029,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT16: EnterOuterAlt(_localctx, 13); { - State = 1578; + State = 1530; _localctx.value = Match(UINT16); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7077,7 +7037,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT32: EnterOuterAlt(_localctx, 14); { - State = 1580; + State = 1532; _localctx.value = Match(UINT32); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7085,7 +7045,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT64: EnterOuterAlt(_localctx, 15); { - State = 1582; + State = 1534; _localctx.value = Match(UINT64); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7093,7 +7053,7 @@ public VariantTypeElementContext variantTypeElement() { case PTR: EnterOuterAlt(_localctx, 16); { - State = 1584; + State = 1536; _localctx.value = Match(PTR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7101,7 +7061,7 @@ public VariantTypeElementContext variantTypeElement() { case DECIMAL: EnterOuterAlt(_localctx, 17); { - State = 1586; + State = 1538; _localctx.value = Match(DECIMAL); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7109,7 +7069,7 @@ public VariantTypeElementContext variantTypeElement() { case DATE: EnterOuterAlt(_localctx, 18); { - State = 1588; + State = 1540; _localctx.value = Match(DATE); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7117,7 +7077,7 @@ public VariantTypeElementContext variantTypeElement() { case BSTR: EnterOuterAlt(_localctx, 19); { - State = 1590; + State = 1542; _localctx.value = Match(BSTR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7125,7 +7085,7 @@ public VariantTypeElementContext variantTypeElement() { case LPSTR: EnterOuterAlt(_localctx, 20); { - State = 1592; + State = 1544; _localctx.value = Match(LPSTR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7133,7 +7093,7 @@ public VariantTypeElementContext variantTypeElement() { case LPWSTR: EnterOuterAlt(_localctx, 21); { - State = 1594; + State = 1546; _localctx.value = Match(LPWSTR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7141,7 +7101,7 @@ public VariantTypeElementContext variantTypeElement() { case IUNKNOWN: EnterOuterAlt(_localctx, 22); { - State = 1596; + State = 1548; _localctx.value = Match(IUNKNOWN); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7149,7 +7109,7 @@ public VariantTypeElementContext variantTypeElement() { case IDISPATCH: EnterOuterAlt(_localctx, 23); { - State = 1598; + State = 1550; _localctx.value = Match(IDISPATCH); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7157,7 +7117,7 @@ public VariantTypeElementContext variantTypeElement() { case SAFEARRAY: EnterOuterAlt(_localctx, 24); { - State = 1600; + State = 1552; _localctx.value = Match(SAFEARRAY); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7165,7 +7125,7 @@ public VariantTypeElementContext variantTypeElement() { case INT: EnterOuterAlt(_localctx, 25); { - State = 1602; + State = 1554; _localctx.value = Match(INT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7173,7 +7133,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT: EnterOuterAlt(_localctx, 26); { - State = 1604; + State = 1556; _localctx.value = Match(UINT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7181,7 +7141,7 @@ public VariantTypeElementContext variantTypeElement() { case ERROR: EnterOuterAlt(_localctx, 27); { - State = 1606; + State = 1558; _localctx.value = Match(ERROR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7189,7 +7149,7 @@ public VariantTypeElementContext variantTypeElement() { case HRESULT: EnterOuterAlt(_localctx, 28); { - State = 1608; + State = 1560; _localctx.value = Match(HRESULT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7197,7 +7157,7 @@ public VariantTypeElementContext variantTypeElement() { case CARRAY: EnterOuterAlt(_localctx, 29); { - State = 1610; + State = 1562; _localctx.value = Match(CARRAY); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7205,7 +7165,7 @@ public VariantTypeElementContext variantTypeElement() { case USERDEFINED: EnterOuterAlt(_localctx, 30); { - State = 1612; + State = 1564; _localctx.value = Match(USERDEFINED); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7213,7 +7173,7 @@ public VariantTypeElementContext variantTypeElement() { case RECORD: EnterOuterAlt(_localctx, 31); { - State = 1614; + State = 1566; _localctx.value = Match(RECORD); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7221,7 +7181,7 @@ public VariantTypeElementContext variantTypeElement() { case FILETIME: EnterOuterAlt(_localctx, 32); { - State = 1616; + State = 1568; _localctx.value = Match(FILETIME); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7229,7 +7189,7 @@ public VariantTypeElementContext variantTypeElement() { case BLOB: EnterOuterAlt(_localctx, 33); { - State = 1618; + State = 1570; _localctx.value = Match(BLOB); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7237,7 +7197,7 @@ public VariantTypeElementContext variantTypeElement() { case STREAM: EnterOuterAlt(_localctx, 34); { - State = 1620; + State = 1572; _localctx.value = Match(STREAM); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7245,7 +7205,7 @@ public VariantTypeElementContext variantTypeElement() { case STORAGE: EnterOuterAlt(_localctx, 35); { - State = 1622; + State = 1574; _localctx.value = Match(STORAGE); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7253,7 +7213,7 @@ public VariantTypeElementContext variantTypeElement() { case STREAMED_OBJECT: EnterOuterAlt(_localctx, 36); { - State = 1624; + State = 1576; _localctx.value = Match(STREAMED_OBJECT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7261,7 +7221,7 @@ public VariantTypeElementContext variantTypeElement() { case STORED_OBJECT: EnterOuterAlt(_localctx, 37); { - State = 1626; + State = 1578; _localctx.value = Match(STORED_OBJECT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7269,7 +7229,7 @@ public VariantTypeElementContext variantTypeElement() { case BLOB_OBJECT: EnterOuterAlt(_localctx, 38); { - State = 1628; + State = 1580; _localctx.value = Match(BLOB_OBJECT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7277,7 +7237,7 @@ public VariantTypeElementContext variantTypeElement() { case CF: EnterOuterAlt(_localctx, 39); { - State = 1630; + State = 1582; _localctx.value = Match(CF); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7285,7 +7245,7 @@ public VariantTypeElementContext variantTypeElement() { case CLSID: EnterOuterAlt(_localctx, 40); { - State = 1632; + State = 1584; _localctx.value = Match(CLSID); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7340,25 +7300,25 @@ public TypeContext type() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1636; + State = 1588; _localctx.element = elementType(); Actions.SetTypeSignatureElement(_localctx, _localctx.element.Value); - State = 1643; + State = 1595; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,61,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,66,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1638; + State = 1590; _localctx.modifier = typeModifiers(); Actions.AddTypeSignatureModifier(_localctx, _localctx.modifier.Value); } } } - State = 1645; + State = 1597; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,61,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,66,Context); } } } @@ -7485,14 +7445,14 @@ public TypeModifiersContext typeModifiers() { TypeModifiersContext _localctx = new TypeModifiersContext(Context, State); EnterRule(_localctx, 140, RULE_typeModifiers); try { - State = 1675; + State = 1627; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,62,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,67,Context) ) { case 1: _localctx = new SZArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 1); { - State = 1646; + State = 1598; Match(ARRAY_TYPE_NO_BOUNDS); _localctx.Value = Actions.CreateSzArrayTypeModifier(); } @@ -7501,9 +7461,9 @@ public TypeModifiersContext typeModifiers() { _localctx = new SZArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 2); { - State = 1648; + State = 1600; Match(T__41); - State = 1649; + State = 1601; Match(T__42); _localctx.Value = Actions.CreateSzArrayTypeModifier(); } @@ -7512,7 +7472,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new ArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 3); { - State = 1651; + State = 1603; ((ArrayModifierContext)_localctx).arrayBounds = bounds(); _localctx.Value = Actions.CreateArrayTypeModifier(((ArrayModifierContext)_localctx).arrayBounds.Value); } @@ -7521,7 +7481,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new ByRefModifierContext(_localctx); EnterOuterAlt(_localctx, 4); { - State = 1654; + State = 1606; Match(REF); _localctx.Value = Actions.CreateByReferenceTypeModifier(); } @@ -7530,7 +7490,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new PtrModifierContext(_localctx); EnterOuterAlt(_localctx, 5); { - State = 1656; + State = 1608; Match(PTR); _localctx.Value = Actions.CreatePointerTypeModifier(); } @@ -7539,7 +7499,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new PinnedModifierContext(_localctx); EnterOuterAlt(_localctx, 6); { - State = 1658; + State = 1610; Match(T__91); _localctx.Value = Actions.CreatePinnedTypeModifier(); } @@ -7548,13 +7508,13 @@ public TypeModifiersContext typeModifiers() { _localctx = new RequiredModifierContext(_localctx); EnterOuterAlt(_localctx, 7); { - State = 1660; + State = 1612; Match(T__92); - State = 1661; + State = 1613; Match(T__29); - State = 1662; + State = 1614; ((RequiredModifierContext)_localctx).modifierType = typeSpec(); - State = 1663; + State = 1615; Match(T__30); _localctx.Value = Actions.CreateCustomTypeModifier(((RequiredModifierContext)_localctx).modifierType.Value, true); } @@ -7563,13 +7523,13 @@ public TypeModifiersContext typeModifiers() { _localctx = new OptionalModifierContext(_localctx); EnterOuterAlt(_localctx, 8); { - State = 1666; + State = 1618; Match(T__93); - State = 1667; + State = 1619; Match(T__29); - State = 1668; + State = 1620; ((OptionalModifierContext)_localctx).modifierType = typeSpec(); - State = 1669; + State = 1621; Match(T__30); _localctx.Value = Actions.CreateCustomTypeModifier(((OptionalModifierContext)_localctx).modifierType.Value, false); } @@ -7578,7 +7538,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new GenericArgumentsModifierContext(_localctx); EnterOuterAlt(_localctx, 9); { - State = 1672; + State = 1624; ((GenericArgumentsModifierContext)_localctx).arguments = typeArgs(); _localctx.Value = Actions.CreateGenericArgumentsModifier(((GenericArgumentsModifierContext)_localctx).arguments.Value); } @@ -7666,15 +7626,15 @@ public ElementTypeContext elementType() { ElementTypeContext _localctx = new ElementTypeContext(Context, State); EnterRule(_localctx, 142, RULE_elementType); try { - State = 1735; + State = 1687; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,63,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,68,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1677; + State = 1629; Match(T__38); - State = 1678; + State = 1630; _localctx.classType = className(); _localctx.Value = Actions.CreateClassElementType(_localctx.classType.Value, false); } @@ -7682,7 +7642,7 @@ public ElementTypeContext elementType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1681; + State = 1633; Match(OBJECT); _localctx.Value = Actions.CreateObjectElementType(); } @@ -7690,11 +7650,11 @@ public ElementTypeContext elementType() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1683; + State = 1635; Match(VALUE); - State = 1684; + State = 1636; Match(T__38); - State = 1685; + State = 1637; _localctx.valueClassType = className(); _localctx.Value = Actions.CreateClassElementType(_localctx.valueClassType.Value, true); } @@ -7702,9 +7662,9 @@ public ElementTypeContext elementType() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1688; + State = 1640; Match(VALUETYPE); - State = 1689; + State = 1641; _localctx.valueType = className(); _localctx.Value = Actions.CreateClassElementType(_localctx.valueType.Value, true); } @@ -7712,15 +7672,15 @@ public ElementTypeContext elementType() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1692; + State = 1644; Match(METHOD); - State = 1693; + State = 1645; _localctx.convention = callConv(); - State = 1694; + State = 1646; _localctx.returnType = type(); - State = 1695; + State = 1647; Match(PTR); - State = 1696; + State = 1648; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateFunctionPointerElementType(_localctx.convention.Value, _localctx.returnType.Value, _localctx.arguments.Value); } @@ -7728,9 +7688,9 @@ public ElementTypeContext elementType() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1699; + State = 1651; Match(METHOD_TYPE_PARAMETER); - State = 1700; + State = 1652; _localctx.parameterIndex = int32(); _localctx.Value = Actions.CreateIndexedGenericParameterElementType(true, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null)); } @@ -7738,9 +7698,9 @@ public ElementTypeContext elementType() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1703; + State = 1655; Match(TYPE_PARAMETER); - State = 1704; + State = 1656; _localctx.parameterIndex = int32(); _localctx.Value = Actions.CreateIndexedGenericParameterElementType(false, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null)); } @@ -7748,9 +7708,9 @@ public ElementTypeContext elementType() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1707; + State = 1659; Match(METHOD_TYPE_PARAMETER); - State = 1708; + State = 1660; _localctx.parameterName = dottedName(); _localctx.Value = Actions.CreateNamedGenericParameterElementType(_localctx.Start, true, _localctx.parameterName.Value); } @@ -7758,9 +7718,9 @@ public ElementTypeContext elementType() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1711; + State = 1663; Match(TYPE_PARAMETER); - State = 1712; + State = 1664; _localctx.parameterName = dottedName(); _localctx.Value = Actions.CreateNamedGenericParameterElementType(_localctx.Start, false, _localctx.parameterName.Value); } @@ -7768,7 +7728,7 @@ public ElementTypeContext elementType() { case 10: EnterOuterAlt(_localctx, 10); { - State = 1715; + State = 1667; Match(TYPEDREF); _localctx.Value = Actions.CreateTypedReferenceElementType(); } @@ -7776,7 +7736,7 @@ public ElementTypeContext elementType() { case 11: EnterOuterAlt(_localctx, 11); { - State = 1717; + State = 1669; Match(VOID); _localctx.Value = Actions.CreateVoidElementType(); } @@ -7784,7 +7744,7 @@ public ElementTypeContext elementType() { case 12: EnterOuterAlt(_localctx, 12); { - State = 1719; + State = 1671; _localctx.signedNative = nativeInt(); _localctx.Value = Actions.CreatePrimitiveElementType(_localctx.signedNative.Value); } @@ -7792,7 +7752,7 @@ public ElementTypeContext elementType() { case 13: EnterOuterAlt(_localctx, 13); { - State = 1722; + State = 1674; _localctx.unsignedNative = nativeUint(); _localctx.Value = Actions.CreatePrimitiveElementType(_localctx.unsignedNative.Value); } @@ -7800,7 +7760,7 @@ public ElementTypeContext elementType() { case 14: EnterOuterAlt(_localctx, 14); { - State = 1725; + State = 1677; _localctx.primitive = simpleType(); _localctx.Value = Actions.CreatePrimitiveElementType(_localctx.primitive.Value); } @@ -7808,7 +7768,7 @@ public ElementTypeContext elementType() { case 15: EnterOuterAlt(_localctx, 15); { - State = 1728; + State = 1680; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateTypedefElementType(_localctx.Start, _localctx.alias.Value); } @@ -7816,9 +7776,9 @@ public ElementTypeContext elementType() { case 16: EnterOuterAlt(_localctx, 16); { - State = 1731; + State = 1683; Match(ELLIPSIS); - State = 1732; + State = 1684; _localctx.sentinelType = type(); _localctx.Value = Actions.CreateSentinelElementType(_localctx.sentinelType.Value); } @@ -7870,13 +7830,13 @@ public SimpleTypeContext simpleType() { SimpleTypeContext _localctx = new SimpleTypeContext(Context, State); EnterRule(_localctx, 144, RULE_simpleType); try { - State = 1775; + State = 1727; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,64,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,69,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1737; + State = 1689; _localctx.value = Match(CHAR); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7884,7 +7844,7 @@ public SimpleTypeContext simpleType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1739; + State = 1691; _localctx.value = Match(STRING); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7892,7 +7852,7 @@ public SimpleTypeContext simpleType() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1741; + State = 1693; _localctx.value = Match(BOOL); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7900,7 +7860,7 @@ public SimpleTypeContext simpleType() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1743; + State = 1695; _localctx.value = Match(INT8); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7908,7 +7868,7 @@ public SimpleTypeContext simpleType() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1745; + State = 1697; _localctx.value = Match(INT16); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7916,7 +7876,7 @@ public SimpleTypeContext simpleType() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1747; + State = 1699; _localctx.value = Match(INT32_); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7924,7 +7884,7 @@ public SimpleTypeContext simpleType() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1749; + State = 1701; _localctx.value = Match(INT64_); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7932,7 +7892,7 @@ public SimpleTypeContext simpleType() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1751; + State = 1703; _localctx.value = Match(FLOAT32); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7940,7 +7900,7 @@ public SimpleTypeContext simpleType() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1753; + State = 1705; _localctx.value = Match(FLOAT64_); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7948,7 +7908,7 @@ public SimpleTypeContext simpleType() { case 10: EnterOuterAlt(_localctx, 10); { - State = 1755; + State = 1707; _localctx.value = Match(UINT8); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7956,7 +7916,7 @@ public SimpleTypeContext simpleType() { case 11: EnterOuterAlt(_localctx, 11); { - State = 1757; + State = 1709; _localctx.value = Match(UINT16); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7964,7 +7924,7 @@ public SimpleTypeContext simpleType() { case 12: EnterOuterAlt(_localctx, 12); { - State = 1759; + State = 1711; _localctx.value = Match(UINT32); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7972,7 +7932,7 @@ public SimpleTypeContext simpleType() { case 13: EnterOuterAlt(_localctx, 13); { - State = 1761; + State = 1713; _localctx.value = Match(UINT64); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7980,9 +7940,9 @@ public SimpleTypeContext simpleType() { case 14: EnterOuterAlt(_localctx, 14); { - State = 1763; + State = 1715; Match(T__89); - State = 1764; + State = 1716; _localctx.value = Match(INT8); _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } @@ -7990,9 +7950,9 @@ public SimpleTypeContext simpleType() { case 15: EnterOuterAlt(_localctx, 15); { - State = 1766; + State = 1718; Match(T__89); - State = 1767; + State = 1719; _localctx.value = Match(INT16); _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } @@ -8000,9 +7960,9 @@ public SimpleTypeContext simpleType() { case 16: EnterOuterAlt(_localctx, 16); { - State = 1769; + State = 1721; Match(T__89); - State = 1770; + State = 1722; _localctx.value = Match(INT32_); _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } @@ -8010,9 +7970,9 @@ public SimpleTypeContext simpleType() { case 17: EnterOuterAlt(_localctx, 17); { - State = 1772; + State = 1724; Match(T__89); - State = 1773; + State = 1725; _localctx.value = Match(INT64_); _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } @@ -8064,9 +8024,9 @@ public BoundContext bound() { EnterRule(_localctx, 146, RULE_bound); Actions.InitializeBound(_localctx); try { - State = 1791; + State = 1743; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,65,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,70,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -8075,14 +8035,14 @@ public BoundContext bound() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1778; + State = 1730; Match(ELLIPSIS); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1779; + State = 1731; _localctx.size = int32(); Actions.SetBoundSize(_localctx, (_localctx.size!=null?(_localctx.size.Start):null)); } @@ -8090,11 +8050,11 @@ public BoundContext bound() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1782; + State = 1734; _localctx.lower = int32(); - State = 1783; + State = 1735; Match(ELLIPSIS); - State = 1784; + State = 1736; _localctx.upper = int32(); Actions.SetBoundRange(_localctx, (_localctx.lower!=null?(_localctx.lower.Start):null), (_localctx.upper!=null?(_localctx.upper.Start):null)); } @@ -8102,9 +8062,9 @@ public BoundContext bound() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1787; + State = 1739; _localctx.lower = int32(); - State = 1788; + State = 1740; Match(ELLIPSIS); Actions.SetBoundLower(_localctx, (_localctx.lower!=null?(_localctx.lower.Start):null)); } @@ -8145,9 +8105,9 @@ public NativeIntContext nativeInt() { try { EnterOuterAlt(_localctx, 1); { - State = 1793; + State = 1745; Match(T__0); - State = 1794; + State = 1746; Match(INT); _localctx.Value = Actions.GetNativeIntType(); } @@ -8187,22 +8147,22 @@ public NativeUintContext nativeUint() { try { EnterOuterAlt(_localctx, 1); { - State = 1797; + State = 1749; Match(T__0); - State = 1801; + State = 1753; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__89: { - State = 1798; + State = 1750; Match(T__89); - State = 1799; + State = 1751; Match(INT); } break; case UINT: { - State = 1800; + State = 1752; Match(UINT); } break; @@ -8224,7 +8184,15 @@ public NativeUintContext nativeUint() { } public partial class SecDeclContext : ParserRuleContext { + public object Value; public bool HasSyntaxError; + public SecActionContext action; + public TypeSpecContext permissionType; + public NameValPairsContext pairs; + public CustomBlobDescrContext structuredValue; + public BytesContext rawValue; + public CompQstringContext textValue; + public SecAttrSetBlobContext attributes; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PERMISSION() { return GetToken(CILParser.PERMISSION, 0); } [System.Diagnostics.DebuggerNonUserCode] public SecActionContext secAction() { return GetRuleContext(0); @@ -8265,129 +8233,142 @@ public override TResult Accept(IParseTreeVisitor visitor) { public SecDeclContext secDecl() { SecDeclContext _localctx = new SecDeclContext(Context, State); EnterRule(_localctx, 152, RULE_secDecl); - BeginSubtree(); Actions.BeginSemanticRoot(_localctx); + BeginStreaming(); Actions.BeginSemanticRoot(_localctx); int _la; try { - State = 1852; + State = 1811; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,68,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,73,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1805; + State = 1757; Match(PERMISSION); - State = 1806; - secAction(); - State = 1807; - typeSpec(); - State = 1808; + State = 1758; + _localctx.action = secAction(); + State = 1759; + _localctx.permissionType = typeSpec(); + State = 1760; Match(T__29); - State = 1809; - nameValPairs(); - State = 1810; + State = 1761; + _localctx.pairs = nameValPairs(); + State = 1762; Match(T__30); + _localctx.Value = Actions.CreateNamedPermissionDeclaration( + _localctx.action.Value, + _localctx.permissionType.Value, + _localctx.pairs.Value); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1812; + State = 1765; Match(PERMISSION); - State = 1813; - secAction(); - State = 1814; - typeSpec(); - State = 1815; + State = 1766; + _localctx.action = secAction(); + State = 1767; + _localctx.permissionType = typeSpec(); + State = 1768; Match(T__35); - State = 1816; + State = 1769; Match(T__16); - State = 1817; - customBlobDescr(); - State = 1818; + State = 1770; + _localctx.structuredValue = customBlobDescr(); + State = 1771; Match(T__17); + _localctx.Value = Actions.CreateStructuredPermissionDeclaration( + _localctx.action.Value, + _localctx.permissionType.Value, + _localctx.structuredValue.Value); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1820; + State = 1774; Match(PERMISSION); - State = 1821; - secAction(); - State = 1822; - typeSpec(); + State = 1775; + _localctx.action = secAction(); + State = 1776; + _localctx.permissionType = typeSpec(); + _localctx.Value = Actions.CreateEmptyPermissionDeclaration(_localctx.action.Value, _localctx.permissionType.Value); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1824; + State = 1779; Match(PERMISSIONSET); - State = 1825; - secAction(); - State = 1826; + State = 1780; + _localctx.action = secAction(); + State = 1781; Match(T__35); - State = 1828; + State = 1783; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__83) { { - State = 1827; + State = 1782; Match(T__83); } } - State = 1830; + State = 1785; Match(T__29); - State = 1831; - bytes(); - State = 1832; + State = 1786; + _localctx.rawValue = bytes(); + State = 1787; Match(T__30); + _localctx.Value = Actions.CreateRawPermissionSetDeclaration(_localctx.action.Value, _localctx.rawValue.Value); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1834; + State = 1790; Match(PERMISSIONSET); - State = 1835; - secAction(); - State = 1836; + State = 1791; + _localctx.action = secAction(); + State = 1792; Match(T__83); - State = 1837; + State = 1793; Match(T__29); - State = 1838; - bytes(); - State = 1839; + State = 1794; + _localctx.rawValue = bytes(); + State = 1795; Match(T__30); + _localctx.Value = Actions.CreateRawPermissionSetDeclaration(_localctx.action.Value, _localctx.rawValue.Value); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1841; + State = 1798; Match(PERMISSIONSET); - State = 1842; - secAction(); - State = 1843; - compQstring(); + State = 1799; + _localctx.action = secAction(); + State = 1800; + _localctx.textValue = compQstring(); + _localctx.Value = Actions.CreateStringPermissionSetDeclaration(_localctx.action.Value, _localctx.textValue.Value); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1845; + State = 1803; Match(PERMISSIONSET); - State = 1846; - secAction(); - State = 1847; + State = 1804; + _localctx.action = secAction(); + State = 1805; Match(T__35); - State = 1848; + State = 1806; Match(T__16); - State = 1849; - secAttrSetBlob(); - State = 1850; + State = 1807; + _localctx.attributes = secAttrSetBlob(); + State = 1808; Match(T__17); + _localctx.Value = Actions.CreateAttributePermissionSetDeclaration(_localctx.action.Value, _localctx.attributes.Value); } break; } @@ -8398,13 +8379,16 @@ public SecDeclContext secDecl() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); + Actions.EndSecurityDeclaration(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; } public partial class SecAttrSetBlobContext : ParserRuleContext { + public object Value; + public SecAttrBlobContext attribute; + public SecAttrBlobContext tail; [System.Diagnostics.DebuggerNonUserCode] public SecAttrBlobContext[] secAttrBlob() { return GetRuleContexts(); } @@ -8428,9 +8412,10 @@ public override TResult Accept(IParseTreeVisitor visitor) { public SecAttrSetBlobContext secAttrSetBlob() { SecAttrSetBlobContext _localctx = new SecAttrSetBlobContext(Context, State); EnterRule(_localctx, 154, RULE_secAttrSetBlob); + Actions.BeginSecurityAttributeSet(_localctx); try { int _alt; - State = 1864; + State = 1826; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__17: @@ -8475,26 +8460,28 @@ public SecAttrSetBlobContext secAttrSetBlob() { case ID: EnterOuterAlt(_localctx, 2); { - State = 1860; + State = 1820; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,69,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,74,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1855; - secAttrBlob(); - State = 1856; + State = 1814; + _localctx.attribute = secAttrBlob(); + Actions.AddSecurityAttribute(_localctx, _localctx.attribute.Value); + State = 1816; Match(T__27); } } } - State = 1862; + State = 1822; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,69,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,74,Context); } - State = 1863; - secAttrBlob(); + State = 1823; + _localctx.tail = secAttrBlob(); + Actions.AddSecurityAttribute(_localctx, _localctx.tail.Value); } break; default: @@ -8507,12 +8494,17 @@ public SecAttrSetBlobContext secAttrSetBlob() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndSecurityAttributeSet(_localctx); ExitRule(); } return _localctx; } public partial class SecAttrBlobContext : ParserRuleContext { + public object Value; + public IToken name; + public CustomBlobNVPairsContext arguments; + public TypeSpecContext securityType; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SQSTRING() { return GetToken(CILParser.SQSTRING, 0); } [System.Diagnostics.DebuggerNonUserCode] public CustomBlobNVPairsContext customBlobNVPairs() { return GetRuleContext(0); @@ -8538,39 +8530,41 @@ public SecAttrBlobContext secAttrBlob() { SecAttrBlobContext _localctx = new SecAttrBlobContext(Context, State); EnterRule(_localctx, 156, RULE_secAttrBlob); try { - State = 1879; + State = 1843; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,71,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,76,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1866; + State = 1828; Match(T__38); - State = 1867; - Match(SQSTRING); - State = 1868; + State = 1829; + _localctx.name = Match(SQSTRING); + State = 1830; Match(T__35); - State = 1869; + State = 1831; Match(T__16); - State = 1870; - customBlobNVPairs(); - State = 1871; + State = 1832; + _localctx.arguments = customBlobNVPairs(); + State = 1833; Match(T__17); + _localctx.Value = Actions.CreateNamedSecurityAttribute(_localctx.name, _localctx.arguments.Value); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1873; - typeSpec(); - State = 1874; + State = 1836; + _localctx.securityType = typeSpec(); + State = 1837; Match(T__35); - State = 1875; + State = 1838; Match(T__16); - State = 1876; - customBlobNVPairs(); - State = 1877; + State = 1839; + _localctx.arguments = customBlobNVPairs(); + State = 1840; Match(T__17); + _localctx.Value = Actions.CreateTypedSecurityAttribute(_localctx.securityType.Value, _localctx.arguments.Value); } break; } @@ -8587,6 +8581,9 @@ public SecAttrBlobContext secAttrBlob() { } public partial class NameValPairsContext : ParserRuleContext { + public object Value; + public NameValPairContext pair; + public NameValPairContext tail; [System.Diagnostics.DebuggerNonUserCode] public NameValPairContext[] nameValPair() { return GetRuleContexts(); } @@ -8610,30 +8607,33 @@ public override TResult Accept(IParseTreeVisitor visitor) { public NameValPairsContext nameValPairs() { NameValPairsContext _localctx = new NameValPairsContext(Context, State); EnterRule(_localctx, 158, RULE_nameValPairs); + Actions.BeginSecurityNameValuePairs(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1886; + State = 1851; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,72,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,77,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1881; - nameValPair(); - State = 1882; + State = 1845; + _localctx.pair = nameValPair(); + Actions.AddSecurityNameValuePair(_localctx, _localctx.pair.Value); + State = 1847; Match(T__27); } } } - State = 1888; + State = 1853; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,72,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,77,Context); } - State = 1889; - nameValPair(); + State = 1854; + _localctx.tail = nameValPair(); + Actions.AddSecurityNameValuePair(_localctx, _localctx.tail.Value); } } catch (RecognitionException re) { @@ -8642,12 +8642,16 @@ public NameValPairsContext nameValPairs() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndSecurityNameValuePairs(_localctx); ExitRule(); } return _localctx; } public partial class NameValPairContext : ParserRuleContext { + public object Value; + public CompQstringContext name; + public CaValueContext value; [System.Diagnostics.DebuggerNonUserCode] public CompQstringContext compQstring() { return GetRuleContext(0); } @@ -8674,12 +8678,13 @@ public NameValPairContext nameValPair() { try { EnterOuterAlt(_localctx, 1); { - State = 1891; - compQstring(); - State = 1892; + State = 1857; + _localctx.name = compQstring(); + State = 1858; Match(T__35); - State = 1893; - caValue(); + State = 1859; + _localctx.value = caValue(); + _localctx.Value = Actions.CreateSecurityNameValuePair(_localctx.name.Value, _localctx.value.Value); } } catch (RecognitionException re) { @@ -8716,7 +8721,7 @@ public TruefalseContext truefalse() { try { EnterOuterAlt(_localctx, 1); { - State = 1895; + State = 1862; _la = TokenStream.LA(1); if ( !(_la==T__94 || _la==T__95) ) { ErrorHandler.RecoverInline(this); @@ -8741,6 +8746,13 @@ public TruefalseContext truefalse() { } public partial class CaValueContext : ParserRuleContext { + public object Value; + public TruefalseContext booleanValue; + public Int32Context integerValue; + public CompQstringContext textValue; + public ClassNameContext enumType; + public IToken kind; + public Int32Context enumValue; [System.Diagnostics.DebuggerNonUserCode] public TruefalseContext truefalse() { return GetRuleContext(0); } @@ -8774,105 +8786,113 @@ public CaValueContext caValue() { CaValueContext _localctx = new CaValueContext(Context, State); EnterRule(_localctx, 164, RULE_caValue); try { - State = 1931; + State = 1909; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,73,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,78,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1897; - truefalse(); + State = 1864; + _localctx.booleanValue = truefalse(); + _localctx.Value = Actions.CreateSecurityBooleanValue(_localctx.booleanValue.Value); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1898; - int32(); + State = 1867; + _localctx.integerValue = int32(); + _localctx.Value = Actions.CreateSecurityInt32Value((_localctx.integerValue!=null?(_localctx.integerValue.Start):null)); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1899; + State = 1870; Match(INT32_); - State = 1900; + State = 1871; Match(T__29); - State = 1901; - int32(); - State = 1902; + State = 1872; + _localctx.integerValue = int32(); + State = 1873; Match(T__30); + _localctx.Value = Actions.CreateSecurityInt32Value((_localctx.integerValue!=null?(_localctx.integerValue.Start):null)); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 1904; - compQstring(); + State = 1876; + _localctx.textValue = compQstring(); + _localctx.Value = Actions.CreateSecurityStringValue(_localctx.textValue.Value); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 1905; - className(); - State = 1906; + State = 1879; + _localctx.enumType = className(); + State = 1880; Match(T__29); - State = 1907; - Match(INT8); - State = 1908; + State = 1881; + _localctx.kind = Match(INT8); + State = 1882; Match(T__74); - State = 1909; - int32(); - State = 1910; + State = 1883; + _localctx.enumValue = int32(); + State = 1884; Match(T__30); + _localctx.Value = Actions.CreateSecurityEnumValue(_localctx.enumType.Value, _localctx.kind, (_localctx.enumValue!=null?(_localctx.enumValue.Start):null)); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 1912; - className(); - State = 1913; + State = 1887; + _localctx.enumType = className(); + State = 1888; Match(T__29); - State = 1914; - Match(INT16); - State = 1915; + State = 1889; + _localctx.kind = Match(INT16); + State = 1890; Match(T__74); - State = 1916; - int32(); - State = 1917; + State = 1891; + _localctx.enumValue = int32(); + State = 1892; Match(T__30); + _localctx.Value = Actions.CreateSecurityEnumValue(_localctx.enumType.Value, _localctx.kind, (_localctx.enumValue!=null?(_localctx.enumValue.Start):null)); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 1919; - className(); - State = 1920; + State = 1895; + _localctx.enumType = className(); + State = 1896; Match(T__29); - State = 1921; - Match(INT32_); - State = 1922; + State = 1897; + _localctx.kind = Match(INT32_); + State = 1898; Match(T__74); - State = 1923; - int32(); - State = 1924; + State = 1899; + _localctx.enumValue = int32(); + State = 1900; Match(T__30); + _localctx.Value = Actions.CreateSecurityEnumValue(_localctx.enumType.Value, _localctx.kind, (_localctx.enumValue!=null?(_localctx.enumValue.Start):null)); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 1926; - className(); - State = 1927; + State = 1903; + _localctx.enumType = className(); + State = 1904; Match(T__29); - State = 1928; - int32(); - State = 1929; + State = 1905; + _localctx.enumValue = int32(); + State = 1906; Match(T__30); + _localctx.Value = Actions.CreateSecurityEnumValue(_localctx.enumType.Value, (_localctx.enumValue!=null?(_localctx.enumValue.Start):null)); } break; } @@ -8889,6 +8909,7 @@ public CaValueContext caValue() { } public partial class SecActionContext : ParserRuleContext { + public System.Reflection.DeclarativeSecurityAction Value; public SecActionContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { @@ -8910,7 +8931,7 @@ public SecActionContext secAction() { try { EnterOuterAlt(_localctx, 1); { - State = 1933; + State = 1911; _la = TokenStream.LA(1); if ( !(((((_la - 97)) & ~0x3f) == 0 && ((1L << (_la - 97)) & 32767L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -8920,6 +8941,8 @@ public SecActionContext secAction() { Consume(); } } + Context.Stop = TokenStream.LT(-1); + _localctx.Value = Actions.ParseSecurityAction(_localctx.Start); } catch (RecognitionException re) { _localctx.exception = re; @@ -8992,33 +9015,33 @@ public MethodRefContext methodRef() { Actions.BeginSemanticRoot(_localctx); int _la; try { - State = 1977; + State = 1955; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,76,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,81,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1935; + State = 1913; _localctx.convention = callConv(); - State = 1936; + State = 1914; _localctx.returnType = type(); - State = 1937; + State = 1915; _localctx.owner = typeSpec(); - State = 1938; + State = 1916; Match(DCOLON); - State = 1939; + State = 1917; _localctx.name = methodName(); - State = 1941; + State = 1919; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 1940; + State = 1918; _localctx.genericArguments = typeArgs(); } } - State = 1943; + State = 1921; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, _localctx.owner.Value, _localctx.name.Value, _localctx.genericArguments, null, _localctx.arguments.Value); } @@ -9026,19 +9049,19 @@ public MethodRefContext methodRef() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1946; + State = 1924; _localctx.convention = callConv(); - State = 1947; + State = 1925; _localctx.returnType = type(); - State = 1948; + State = 1926; _localctx.owner = typeSpec(); - State = 1949; + State = 1927; Match(DCOLON); - State = 1950; + State = 1928; _localctx.name = methodName(); - State = 1951; + State = 1929; _localctx.genericArity = genArityNotEmpty(); - State = 1952; + State = 1930; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, _localctx.owner.Value, _localctx.name.Value, null, _localctx.genericArity.Value, _localctx.arguments.Value); } @@ -9046,23 +9069,23 @@ public MethodRefContext methodRef() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1955; + State = 1933; _localctx.convention = callConv(); - State = 1956; + State = 1934; _localctx.returnType = type(); - State = 1957; + State = 1935; _localctx.name = methodName(); - State = 1959; + State = 1937; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 1958; + State = 1936; _localctx.genericArguments = typeArgs(); } } - State = 1961; + State = 1939; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, null, _localctx.name.Value, _localctx.genericArguments, null, _localctx.arguments.Value); } @@ -9070,15 +9093,15 @@ public MethodRefContext methodRef() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1964; + State = 1942; _localctx.convention = callConv(); - State = 1965; + State = 1943; _localctx.returnType = type(); - State = 1966; + State = 1944; _localctx.name = methodName(); - State = 1967; + State = 1945; _localctx.genericArity = genArityNotEmpty(); - State = 1968; + State = 1946; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, null, _localctx.name.Value, null, _localctx.genericArity.Value, _localctx.arguments.Value); } @@ -9086,7 +9109,7 @@ public MethodRefContext methodRef() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1971; + State = 1949; _localctx.token = mdtoken(); _localctx.Value = Actions.CreateTokenMethodReference(_localctx.token.Value); } @@ -9094,7 +9117,7 @@ public MethodRefContext methodRef() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1974; + State = 1952; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateTypedefMethodReference(_localctx.Start, _localctx.alias.Value); } @@ -9147,15 +9170,15 @@ public CallConvContext callConv() { CallConvContext _localctx = new CallConvContext(Context, State); EnterRule(_localctx, 170, RULE_callConv); try { - State = 1996; + State = 1974; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,77,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,82,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1979; + State = 1957; Match(INSTANCE); - State = 1980; + State = 1958; _localctx.inner = callConv(); _localctx.Value = Actions.AddInstanceCallingConvention(_localctx.inner.Value); } @@ -9163,9 +9186,9 @@ public CallConvContext callConv() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1983; + State = 1961; Match(EXPLICIT); - State = 1984; + State = 1962; _localctx.inner = callConv(); _localctx.Value = Actions.AddExplicitCallingConvention(_localctx.inner.Value); } @@ -9173,7 +9196,7 @@ public CallConvContext callConv() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1987; + State = 1965; _localctx.kind = callKind(); _localctx.Value = _localctx.kind.Value; } @@ -9181,13 +9204,13 @@ public CallConvContext callConv() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1990; + State = 1968; Match(T__111); - State = 1991; + State = 1969; Match(T__29); - State = 1992; + State = 1970; _localctx.raw = int32(); - State = 1993; + State = 1971; Match(T__30); _localctx.Value = Actions.GetRawCallingConvention((_localctx.raw!=null?(_localctx.raw.Start):null)); } @@ -9234,9 +9257,9 @@ public CallKindContext callKind() { EnterRule(_localctx, 172, RULE_callKind); _localctx.Value = Actions.GetDefaultCallingConvention(); try { - State = 2017; + State = 1995; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,78,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,83,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -9245,7 +9268,7 @@ public CallKindContext callKind() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1999; + State = 1977; _localctx.kind = Match(DEFAULT); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9253,7 +9276,7 @@ public CallKindContext callKind() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2001; + State = 1979; _localctx.kind = Match(VARARG); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9261,9 +9284,9 @@ public CallKindContext callKind() { case 4: EnterOuterAlt(_localctx, 4); { - State = 2003; + State = 1981; Match(UNMANAGED); - State = 2004; + State = 1982; _localctx.kind = Match(CDECL); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9271,9 +9294,9 @@ public CallKindContext callKind() { case 5: EnterOuterAlt(_localctx, 5); { - State = 2006; + State = 1984; Match(UNMANAGED); - State = 2007; + State = 1985; _localctx.kind = Match(STDCALL); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9281,9 +9304,9 @@ public CallKindContext callKind() { case 6: EnterOuterAlt(_localctx, 6); { - State = 2009; + State = 1987; Match(UNMANAGED); - State = 2010; + State = 1988; _localctx.kind = Match(THISCALL); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9291,9 +9314,9 @@ public CallKindContext callKind() { case 7: EnterOuterAlt(_localctx, 7); { - State = 2012; + State = 1990; Match(UNMANAGED); - State = 2013; + State = 1991; _localctx.kind = Match(FASTCALL); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9301,7 +9324,7 @@ public CallKindContext callKind() { case 8: EnterOuterAlt(_localctx, 8); { - State = 2015; + State = 1993; _localctx.kind = Match(UNMANAGED); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9347,13 +9370,13 @@ public MdtokenContext mdtoken() { try { EnterOuterAlt(_localctx, 1); { - State = 2019; + State = 1997; Match(T__112); - State = 2020; + State = 1998; Match(T__29); - State = 2021; + State = 1999; _localctx.token = int32(); - State = 2022; + State = 2000; Match(T__30); _localctx.Value = Actions.ParseInt32((_localctx.token!=null?(_localctx.token.Start):null)); } @@ -9403,15 +9426,15 @@ public MemberRefContext memberRef() { MemberRefContext _localctx = new MemberRefContext(Context, State); EnterRule(_localctx, 176, RULE_memberRef); try { - State = 2036; + State = 2014; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case METHOD: EnterOuterAlt(_localctx, 1); { - State = 2025; + State = 2003; Match(METHOD); - State = 2026; + State = 2004; _localctx.method = methodRef(); _localctx.Value = Actions.CreateMethodMemberReference(_localctx.method.Value); } @@ -9419,9 +9442,9 @@ public MemberRefContext memberRef() { case T__36: EnterOuterAlt(_localctx, 2); { - State = 2029; + State = 2007; Match(T__36); - State = 2030; + State = 2008; _localctx.field = fieldRef(); _localctx.Value = Actions.CreateFieldMemberReference(_localctx.field.Value); } @@ -9429,7 +9452,7 @@ public MemberRefContext memberRef() { case T__112: EnterOuterAlt(_localctx, 3); { - State = 2033; + State = 2011; _localctx.token = mdtoken(); _localctx.Value = Actions.CreateTokenMemberReference(_localctx.token.Value); } @@ -9485,19 +9508,19 @@ public FieldRefContext fieldRef() { EnterRule(_localctx, 178, RULE_fieldRef); Actions.BeginSemanticRoot(_localctx); try { - State = 2051; + State = 2029; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,80,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,85,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2038; + State = 2016; _localctx.fieldType = type(); - State = 2039; + State = 2017; _localctx.owner = typeSpec(); - State = 2040; + State = 2018; Match(DCOLON); - State = 2041; + State = 2019; _localctx.name = dottedName(); _localctx.Value = Actions.CreateFieldReference(_localctx.fieldType.Value, _localctx.owner.Value, _localctx.name.Value); } @@ -9505,9 +9528,9 @@ public FieldRefContext fieldRef() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2044; + State = 2022; _localctx.fieldType = type(); - State = 2045; + State = 2023; _localctx.name = dottedName(); _localctx.Value = Actions.CreateFieldReference(_localctx.fieldType.Value, null, _localctx.name.Value); } @@ -9515,7 +9538,7 @@ public FieldRefContext fieldRef() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2048; + State = 2026; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateTypedefFieldReference(_localctx.Start, _localctx.alias.Value); } @@ -9566,26 +9589,26 @@ public TypeListContext typeList() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 2059; + State = 2037; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,81,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,86,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2053; + State = 2031; _localctx.item = typeSpec(); Actions.AddGenericType(_localctx, _localctx.item.Value); - State = 2055; + State = 2033; Match(T__27); } } } - State = 2061; + State = 2039; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,81,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,86,Context); } - State = 2062; + State = 2040; _localctx.tail = typeSpec(); Actions.AddGenericType(_localctx, _localctx.tail.Value); } @@ -9627,7 +9650,7 @@ public TyparsClauseContext typarsClause() { EnterRule(_localctx, 182, RULE_typarsClause); _localctx.Value = Actions.CreateEmptyGenericParameterList(); try { - State = 2071; + State = 2049; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -9642,11 +9665,11 @@ public TyparsClauseContext typarsClause() { case T__85: EnterOuterAlt(_localctx, 2); { - State = 2066; + State = 2044; Match(T__85); - State = 2067; + State = 2045; _localctx.parameters = typars(); - State = 2068; + State = 2046; Match(T__86); _localctx.Value = _localctx.parameters.Value; } @@ -9698,13 +9721,13 @@ public TyparAttribContext typarAttrib() { TyparAttribContext _localctx = new TyparAttribContext(Context, State); EnterRule(_localctx, 184, RULE_typarAttrib); try { - State = 2091; + State = 2069; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case PLUS: EnterOuterAlt(_localctx, 1); { - State = 2073; + State = 2051; _localctx.covariant = Match(PLUS); _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.covariant); } @@ -9712,7 +9735,7 @@ public TyparAttribContext typarAttrib() { case T__113: EnterOuterAlt(_localctx, 2); { - State = 2075; + State = 2053; _localctx.contravariant = Match(T__113); _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.contravariant); } @@ -9720,7 +9743,7 @@ public TyparAttribContext typarAttrib() { case T__38: EnterOuterAlt(_localctx, 3); { - State = 2077; + State = 2055; _localctx.@class = Match(T__38); _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.@class); } @@ -9728,7 +9751,7 @@ public TyparAttribContext typarAttrib() { case VALUETYPE: EnterOuterAlt(_localctx, 4); { - State = 2079; + State = 2057; _localctx.valuetype = Match(VALUETYPE); _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.valuetype); } @@ -9736,7 +9759,7 @@ public TyparAttribContext typarAttrib() { case T__114: EnterOuterAlt(_localctx, 5); { - State = 2081; + State = 2059; _localctx.byrefLike = Match(T__114); _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.byrefLike); } @@ -9744,7 +9767,7 @@ public TyparAttribContext typarAttrib() { case T__115: EnterOuterAlt(_localctx, 6); { - State = 2083; + State = 2061; _localctx.ctor = Match(T__115); _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.ctor); } @@ -9752,13 +9775,13 @@ public TyparAttribContext typarAttrib() { case T__69: EnterOuterAlt(_localctx, 7); { - State = 2085; + State = 2063; Match(T__69); - State = 2086; + State = 2064; Match(T__29); - State = 2087; + State = 2065; _localctx.flags = int32(); - State = 2088; + State = 2066; Match(T__30); _localctx.Value = Actions.CreateRawGenericParameterAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } @@ -9809,18 +9832,18 @@ public TyparAttribsContext typarAttribs() { try { EnterOuterAlt(_localctx, 1); { - State = 2098; + State = 2076; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__38 || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & 123145302310913L) != 0) || _la==VALUETYPE || _la==PLUS) { { { - State = 2093; + State = 2071; _localctx.attribute = typarAttrib(); Actions.AddGenericParameterAttribute(_localctx, _localctx.attribute.Value); } } - State = 2100; + State = 2078; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -9873,19 +9896,19 @@ public TyparContext typar() { try { EnterOuterAlt(_localctx, 1); { - State = 2101; + State = 2079; _localctx.attributes = typarAttribs(); - State = 2103; + State = 2081; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__29) { { - State = 2102; + State = 2080; _localctx.constraints = tyBound(); } } - State = 2105; + State = 2083; _localctx.name = dottedName(); _localctx.Value = Actions.CreateGenericParameterDeclaration(_localctx.attributes.Value, _localctx.constraints, _localctx.name.Value); } @@ -9933,26 +9956,26 @@ public TyparsContext typars() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 2114; + State = 2092; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,86,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2108; + State = 2086; _localctx.parameter = typar(); Actions.AddGenericParameter(_localctx, _localctx.parameter.Value); - State = 2110; + State = 2088; Match(T__27); } } } - State = 2116; + State = 2094; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,86,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); } - State = 2117; + State = 2095; _localctx.tail = typar(); Actions.AddGenericParameter(_localctx, _localctx.tail.Value); } @@ -9995,11 +10018,11 @@ public TyBoundContext tyBound() { try { EnterOuterAlt(_localctx, 1); { - State = 2120; + State = 2098; Match(T__29); - State = 2121; + State = 2099; _localctx.constraints = typeList(); - State = 2122; + State = 2100; Match(T__30); _localctx.Value = _localctx.constraints.Value; } @@ -10042,12 +10065,12 @@ public GenArityContext genArity() { try { EnterOuterAlt(_localctx, 1); { - State = 2126; + State = 2104; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 2125; + State = 2103; _localctx.value = genArityNotEmpty(); } } @@ -10092,15 +10115,15 @@ public GenArityNotEmptyContext genArityNotEmpty() { try { EnterOuterAlt(_localctx, 1); { - State = 2130; + State = 2108; Match(T__85); - State = 2131; + State = 2109; Match(T__41); - State = 2132; + State = 2110; _localctx.value = int32(); - State = 2133; + State = 2111; Match(T__42); - State = 2134; + State = 2112; Match(T__86); _localctx.Value = Actions.ParseInt32((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -10276,74 +10299,74 @@ public ClassDeclContext classDecl() { BeginStreaming(); try { int _alt; - State = 2287; + State = 2265; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,92,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,97,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2137; + State = 2115; methodHead(); - State = 2138; + State = 2116; Match(T__16); - State = 2139; + State = 2117; methodDecls(); - State = 2140; + State = 2118; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2142; + State = 2120; classHead(); - State = 2143; + State = 2121; Match(T__16); - State = 2144; + State = 2122; classDecls(); - State = 2145; + State = 2123; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2147; + State = 2125; _localctx.eventHeader = eventHead(); Actions.BeginEvent(_localctx, _localctx.eventHeader.Value); - State = 2149; + State = 2127; Match(T__16); - State = 2150; + State = 2128; eventDecls(); - State = 2151; + State = 2129; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2153; + State = 2131; _localctx.property = propHead(); Actions.BeginProperty(_localctx, _localctx.property.Value); - State = 2155; + State = 2133; Match(T__16); - State = 2156; + State = 2134; propDecls(); - State = 2157; + State = 2135; Match(T__17); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2159; + State = 2137; fieldDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2160; + State = 2138; _localctx.data = dataDecl(); Actions.ProcessClassDataDeclaration(_localctx.data); } @@ -10351,7 +10374,7 @@ public ClassDeclContext classDecl() { case 7: EnterOuterAlt(_localctx, 7); { - State = 2163; + State = 2141; _localctx.security = secDecl(); Actions.ProcessClassSecurityDeclaration(_localctx.security); } @@ -10359,7 +10382,7 @@ public ClassDeclContext classDecl() { case 8: EnterOuterAlt(_localctx, 8); { - State = 2166; + State = 2144; _localctx.source = extSourceSpec(); Actions.ProcessClassSourceDirective(_localctx.source); } @@ -10367,7 +10390,7 @@ public ClassDeclContext classDecl() { case 9: EnterOuterAlt(_localctx, 9); { - State = 2169; + State = 2147; _localctx.attribute = customAttrDecl(); Actions.ProcessClassCustomAttribute(_localctx.attribute); } @@ -10375,9 +10398,9 @@ public ClassDeclContext classDecl() { case 10: EnterOuterAlt(_localctx, 10); { - State = 2172; + State = 2150; Match(T__116); - State = 2173; + State = 2151; _localctx.size = int32(); Actions.SetClassSize((_localctx.size!=null?(_localctx.size.Start):null)); } @@ -10385,9 +10408,9 @@ public ClassDeclContext classDecl() { case 11: EnterOuterAlt(_localctx, 11); { - State = 2176; + State = 2154; Match(T__117); - State = 2177; + State = 2155; _localctx.packing = int32(); Actions.SetClassPackingSize((_localctx.packing!=null?(_localctx.packing.Start):null)); } @@ -10395,13 +10418,13 @@ public ClassDeclContext classDecl() { case 12: EnterOuterAlt(_localctx, 12); { - State = 2180; + State = 2158; _localctx.export = exportHead(); - State = 2181; + State = 2159; Match(T__16); - State = 2182; + State = 2160; _localctx.exportDeclarations = exptypeDecls(); - State = 2183; + State = 2161; Match(T__17); Actions.ProcessClassExport(_localctx.export, _localctx.exportDeclarations); } @@ -10409,27 +10432,27 @@ public ClassDeclContext classDecl() { case 13: EnterOuterAlt(_localctx, 13); { - State = 2186; + State = 2164; Match(OVERRIDE); - State = 2187; + State = 2165; _localctx.declarationOwner = typeSpec(); - State = 2188; + State = 2166; Match(DCOLON); - State = 2189; + State = 2167; _localctx.declarationName = methodName(); - State = 2190; + State = 2168; Match(T__118); - State = 2191; + State = 2169; _localctx.bodyConvention = callConv(); - State = 2192; + State = 2170; _localctx.bodyReturnType = type(); - State = 2193; + State = 2171; _localctx.bodyOwner = typeSpec(); - State = 2194; + State = 2172; Match(DCOLON); - State = 2195; + State = 2173; _localctx.bodyName = methodName(); - State = 2196; + State = 2174; _localctx.bodyArguments = sigArgs(); Actions.AddClassMethodOverride( _localctx, @@ -10445,41 +10468,41 @@ public ClassDeclContext classDecl() { case 14: EnterOuterAlt(_localctx, 14); { - State = 2199; + State = 2177; Match(OVERRIDE); - State = 2200; + State = 2178; Match(METHOD); - State = 2201; + State = 2179; _localctx.declarationConvention = callConv(); - State = 2202; + State = 2180; _localctx.declarationReturnType = type(); - State = 2203; + State = 2181; _localctx.declarationOwner = typeSpec(); - State = 2204; + State = 2182; Match(DCOLON); - State = 2205; + State = 2183; _localctx.declarationName = methodName(); - State = 2206; + State = 2184; _localctx.declarationArity = genArity(); - State = 2207; + State = 2185; _localctx.declarationArguments = sigArgs(); - State = 2208; + State = 2186; Match(T__118); - State = 2209; + State = 2187; Match(METHOD); - State = 2210; + State = 2188; _localctx.bodyConvention = callConv(); - State = 2211; + State = 2189; _localctx.bodyReturnType = type(); - State = 2212; + State = 2190; _localctx.bodyOwner = typeSpec(); - State = 2213; + State = 2191; Match(DCOLON); - State = 2214; + State = 2192; _localctx.bodyName = methodName(); - State = 2215; + State = 2193; _localctx.bodyArity = genArity(); - State = 2216; + State = 2194; _localctx.bodyArguments = sigArgs(); Actions.AddClassMethodOverride( _localctx, @@ -10500,7 +10523,7 @@ public ClassDeclContext classDecl() { case 15: EnterOuterAlt(_localctx, 15); { - State = 2219; + State = 2197; _localctx.language = languageDecl(); Actions.ProcessClassLanguageDirective(_localctx.language); } @@ -10508,7 +10531,7 @@ public ClassDeclContext classDecl() { case 16: EnterOuterAlt(_localctx, 16); { - State = 2222; + State = 2200; compControl(); Actions.ProcessClassCompilerControl(); } @@ -10516,145 +10539,145 @@ public ClassDeclContext classDecl() { case 17: EnterOuterAlt(_localctx, 17); { - State = 2225; + State = 2203; Match(PARAM); - State = 2226; + State = 2204; Match(TYPE); - State = 2227; + State = 2205; Match(T__41); - State = 2228; + State = 2206; _localctx.parameterIndex = int32(); - State = 2229; + State = 2207; Match(T__42); Actions.BeginClassGenericParameterDirective(_localctx, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null)); - State = 2236; + State = 2214; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,93,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2231; + State = 2209; _localctx.attribute = customAttrDecl(); Actions.AddClassGenericDirectiveAttribute(_localctx, _localctx.attribute); } } } - State = 2238; + State = 2216; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,88,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,93,Context); } } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 2239; + State = 2217; Match(PARAM); - State = 2240; + State = 2218; Match(TYPE); - State = 2241; + State = 2219; _localctx.parameterName = dottedName(); Actions.BeginClassGenericParameterDirective(_localctx, _localctx.parameterName.Value); - State = 2248; + State = 2226; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,94,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2243; + State = 2221; _localctx.attribute = customAttrDecl(); Actions.AddClassGenericDirectiveAttribute(_localctx, _localctx.attribute); } } } - State = 2250; + State = 2228; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,94,Context); } } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 2251; + State = 2229; Match(PARAM); - State = 2252; + State = 2230; Match(CONSTRAINT); - State = 2253; + State = 2231; Match(T__41); - State = 2254; + State = 2232; _localctx.parameterIndex = int32(); - State = 2255; + State = 2233; Match(T__42); - State = 2256; + State = 2234; Match(T__27); - State = 2257; + State = 2235; _localctx.constraintType = typeSpec(); Actions.BeginClassGenericConstraintDirective(_localctx, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null), _localctx.constraintType.Value); - State = 2264; + State = 2242; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,95,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2259; + State = 2237; _localctx.attribute = customAttrDecl(); Actions.AddClassGenericDirectiveAttribute(_localctx, _localctx.attribute); } } } - State = 2266; + State = 2244; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,90,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,95,Context); } } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 2267; + State = 2245; Match(PARAM); - State = 2268; + State = 2246; Match(CONSTRAINT); - State = 2269; + State = 2247; _localctx.parameterName = dottedName(); - State = 2270; + State = 2248; Match(T__27); - State = 2271; + State = 2249; _localctx.constraintType = typeSpec(); Actions.BeginClassGenericConstraintDirective(_localctx, _localctx.parameterName.Value, _localctx.constraintType.Value); - State = 2278; + State = 2256; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,96,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2273; + State = 2251; _localctx.attribute = customAttrDecl(); Actions.AddClassGenericDirectiveAttribute(_localctx, _localctx.attribute); } } } - State = 2280; + State = 2258; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,96,Context); } } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 2281; + State = 2259; Match(T__119); - State = 2282; + State = 2260; Match(TYPE); - State = 2283; + State = 2261; _localctx.interfaceType = typeSpec(); - State = 2284; + State = 2262; _localctx.interfaceAttribute = customDescr(); Actions.AddInterfaceImplementationAttribute(_localctx, _localctx.interfaceType.Value, _localctx.interfaceAttribute); } @@ -10731,17 +10754,17 @@ public FieldDeclContext fieldDecl() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 2289; + State = 2267; Match(T__120); - State = 2290; + State = 2268; _localctx.offset = repeatOpt(); - State = 2302; + State = 2280; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,94,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,99,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { - State = 2300; + State = 2278; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -10760,20 +10783,20 @@ public FieldDeclContext fieldDecl() { case T__125: case T__126: { - State = 2291; + State = 2269; _localctx.attribute = fieldAttr(); Actions.AddFieldAttribute(_localctx, _localctx.attribute.Value); } break; case T__121: { - State = 2294; + State = 2272; Match(T__121); - State = 2295; + State = 2273; Match(T__29); - State = 2296; + State = 2274; _localctx.marshalling = marshalBlob(); - State = 2297; + State = 2275; Match(T__30); Actions.SetFieldMarshalling(_localctx, _localctx.marshalling.Value); } @@ -10783,17 +10806,17 @@ public FieldDeclContext fieldDecl() { } } } - State = 2304; + State = 2282; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,94,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,99,Context); } - State = 2305; + State = 2283; _localctx.fieldType = type(); - State = 2306; + State = 2284; _localctx.name = dottedName(); - State = 2307; + State = 2285; _localctx.data = atOpt(); - State = 2308; + State = 2286; _localctx.initializer = initOpt(); _localctx.Value = Actions.CreateFieldDeclaration( _localctx, @@ -10843,13 +10866,13 @@ public FieldAttrContext fieldAttr() { FieldAttrContext _localctx = new FieldAttrContext(Context, State); EnterRule(_localctx, 202, RULE_fieldAttr); try { - State = 2345; + State = 2323; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__122: EnterOuterAlt(_localctx, 1); { - State = 2311; + State = 2289; _localctx.attribute = Match(T__122); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10857,7 +10880,7 @@ public FieldAttrContext fieldAttr() { case T__50: EnterOuterAlt(_localctx, 2); { - State = 2313; + State = 2291; _localctx.attribute = Match(T__50); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10865,7 +10888,7 @@ public FieldAttrContext fieldAttr() { case T__51: EnterOuterAlt(_localctx, 3); { - State = 2315; + State = 2293; _localctx.attribute = Match(T__51); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10873,7 +10896,7 @@ public FieldAttrContext fieldAttr() { case T__62: EnterOuterAlt(_localctx, 4); { - State = 2317; + State = 2295; _localctx.attribute = Match(T__62); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10881,7 +10904,7 @@ public FieldAttrContext fieldAttr() { case T__123: EnterOuterAlt(_localctx, 5); { - State = 2319; + State = 2297; _localctx.attribute = Match(T__123); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10889,7 +10912,7 @@ public FieldAttrContext fieldAttr() { case T__68: EnterOuterAlt(_localctx, 6); { - State = 2321; + State = 2299; _localctx.attribute = Match(T__68); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10897,7 +10920,7 @@ public FieldAttrContext fieldAttr() { case T__67: EnterOuterAlt(_localctx, 7); { - State = 2323; + State = 2301; _localctx.attribute = Match(T__67); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10905,7 +10928,7 @@ public FieldAttrContext fieldAttr() { case T__63: EnterOuterAlt(_localctx, 8); { - State = 2325; + State = 2303; _localctx.attribute = Match(T__63); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10913,7 +10936,7 @@ public FieldAttrContext fieldAttr() { case T__64: EnterOuterAlt(_localctx, 9); { - State = 2327; + State = 2305; _localctx.attribute = Match(T__64); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10921,7 +10944,7 @@ public FieldAttrContext fieldAttr() { case T__65: EnterOuterAlt(_localctx, 10); { - State = 2329; + State = 2307; _localctx.attribute = Match(T__65); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10929,7 +10952,7 @@ public FieldAttrContext fieldAttr() { case T__124: EnterOuterAlt(_localctx, 11); { - State = 2331; + State = 2309; _localctx.attribute = Match(T__124); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10937,7 +10960,7 @@ public FieldAttrContext fieldAttr() { case T__125: EnterOuterAlt(_localctx, 12); { - State = 2333; + State = 2311; _localctx.attribute = Match(T__125); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10945,7 +10968,7 @@ public FieldAttrContext fieldAttr() { case T__126: EnterOuterAlt(_localctx, 13); { - State = 2335; + State = 2313; _localctx.attribute = Match(T__126); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10953,7 +10976,7 @@ public FieldAttrContext fieldAttr() { case T__15: EnterOuterAlt(_localctx, 14); { - State = 2337; + State = 2315; _localctx.attribute = Match(T__15); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10961,13 +10984,13 @@ public FieldAttrContext fieldAttr() { case T__69: EnterOuterAlt(_localctx, 15); { - State = 2339; + State = 2317; Match(T__69); - State = 2340; + State = 2318; Match(T__29); - State = 2341; + State = 2319; _localctx.flags = int32(); - State = 2342; + State = 2320; Match(T__30); _localctx.Value = Actions.CreateRawFieldAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } @@ -11015,9 +11038,9 @@ public AtOptContext atOpt() { AtOptContext _localctx = new AtOptContext(Context, State); EnterRule(_localctx, 204, RULE_atOpt); try { - State = 2356; + State = 2334; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,96,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,101,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -11026,9 +11049,9 @@ public AtOptContext atOpt() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2348; + State = 2326; Match(T__43); - State = 2349; + State = 2327; _localctx.name = id(); _localctx.Value = Actions.GetFieldDataName((_localctx.name!=null?(_localctx.name.Start):null)); } @@ -11036,9 +11059,9 @@ public AtOptContext atOpt() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2352; + State = 2330; Match(T__43); - State = 2353; + State = 2331; _localctx.offset = int32(); _localctx.Value = Actions.GetFieldDataOffset((_localctx.offset!=null?(_localctx.offset.Start):null)); } @@ -11082,7 +11105,7 @@ public InitOptContext initOpt() { EnterRule(_localctx, 206, RULE_initOpt); Actions.BeginFieldInitializer(_localctx); try { - State = 2363; + State = 2341; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -11176,9 +11199,9 @@ public InitOptContext initOpt() { case T__35: EnterOuterAlt(_localctx, 2); { - State = 2359; + State = 2337; Match(T__35); - State = 2360; + State = 2338; _localctx.initializer = fieldInit(); Actions.SetFieldInitializer(_localctx, _localctx.initializer.Value); } @@ -11224,7 +11247,7 @@ public RepeatOptContext repeatOpt() { RepeatOptContext _localctx = new RepeatOptContext(Context, State); EnterRule(_localctx, 208, RULE_repeatOpt); try { - State = 2371; + State = 2349; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -11279,11 +11302,11 @@ public RepeatOptContext repeatOpt() { case T__41: EnterOuterAlt(_localctx, 2); { - State = 2366; + State = 2344; Match(T__41); - State = 2367; + State = 2345; _localctx.offset = int32(); - State = 2368; + State = 2346; Match(T__42); Actions.SetFieldOffset(_localctx, (_localctx.offset!=null?(_localctx.offset.Start):null)); } @@ -11340,32 +11363,32 @@ public EventHeadContext eventHead() { Actions.BeginEventHeader(_localctx); int _la; try { - State = 2398; + State = 2376; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,101,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,106,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2373; + State = 2351; Match(T__127); - State = 2379; + State = 2357; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 2374; + State = 2352; _localctx.attribute = eventAttr(); Actions.AddEventAttribute(_localctx, _localctx.attribute.Value); } } - State = 2381; + State = 2359; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2382; + State = 2360; _localctx.eventType = typeSpec(); - State = 2383; + State = 2361; _localctx.name = dottedName(); _localctx.Value = Actions.CreateEventHeader(_localctx, _localctx.eventType.Value, _localctx.name.Value); } @@ -11373,24 +11396,24 @@ public EventHeadContext eventHead() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2386; + State = 2364; Match(T__127); - State = 2392; + State = 2370; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 2387; + State = 2365; _localctx.attribute = eventAttr(); Actions.AddEventAttribute(_localctx, _localctx.attribute.Value); } } - State = 2394; + State = 2372; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2395; + State = 2373; _localctx.name = dottedName(); _localctx.Value = Actions.CreateEventHeader(_localctx, null, _localctx.name.Value); } @@ -11430,13 +11453,13 @@ public EventAttrContext eventAttr() { EventAttrContext _localctx = new EventAttrContext(Context, State); EnterRule(_localctx, 212, RULE_eventAttr); try { - State = 2404; + State = 2382; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__68: EnterOuterAlt(_localctx, 1); { - State = 2400; + State = 2378; _localctx.attribute = Match(T__68); _localctx.Value = Actions.CreateEventAttribute(_localctx.attribute); } @@ -11444,7 +11467,7 @@ public EventAttrContext eventAttr() { case T__67: EnterOuterAlt(_localctx, 2); { - State = 2402; + State = 2380; _localctx.attribute = Match(T__67); _localctx.Value = Actions.CreateEventAttribute(_localctx.attribute); } @@ -11492,17 +11515,17 @@ public EventDeclsContext eventDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2409; + State = 2387; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38788988928L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 1080863910568919043L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 2406; + State = 2384; eventDecl(); } } - State = 2411; + State = 2389; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11557,15 +11580,15 @@ public EventDeclContext eventDecl() { EventDeclContext _localctx = new EventDeclContext(Context, State); EnterRule(_localctx, 216, RULE_eventDecl); try { - State = 2438; + State = 2416; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__128: EnterOuterAlt(_localctx, 1); { - State = 2412; + State = 2390; Match(T__128); - State = 2413; + State = 2391; _localctx.accessor = methodRef(); Actions.AddEventAdder(_localctx, _localctx.accessor.Value); } @@ -11573,9 +11596,9 @@ public EventDeclContext eventDecl() { case T__129: EnterOuterAlt(_localctx, 2); { - State = 2416; + State = 2394; Match(T__129); - State = 2417; + State = 2395; _localctx.accessor = methodRef(); Actions.AddEventRemover(_localctx, _localctx.accessor.Value); } @@ -11583,9 +11606,9 @@ public EventDeclContext eventDecl() { case T__130: EnterOuterAlt(_localctx, 3); { - State = 2420; + State = 2398; Match(T__130); - State = 2421; + State = 2399; _localctx.accessor = methodRef(); Actions.AddEventRaiser(_localctx, _localctx.accessor.Value); } @@ -11593,9 +11616,9 @@ public EventDeclContext eventDecl() { case T__131: EnterOuterAlt(_localctx, 4); { - State = 2424; + State = 2402; Match(T__131); - State = 2425; + State = 2403; _localctx.accessor = methodRef(); Actions.AddEventOther(_localctx, _localctx.accessor.Value); } @@ -11604,7 +11627,7 @@ public EventDeclContext eventDecl() { case T__73: EnterOuterAlt(_localctx, 5); { - State = 2428; + State = 2406; _localctx.source = extSourceSpec(); Actions.ProcessEventSourceDirective(_localctx.source); } @@ -11618,7 +11641,7 @@ public EventDeclContext eventDecl() { case ID: EnterOuterAlt(_localctx, 6); { - State = 2431; + State = 2409; _localctx.attribute = customAttrDecl(); Actions.AddEventCustomAttribute(_localctx, _localctx.attribute); } @@ -11626,7 +11649,7 @@ public EventDeclContext eventDecl() { case T__26: EnterOuterAlt(_localctx, 7); { - State = 2434; + State = 2412; _localctx.language = languageDecl(); Actions.ProcessEventLanguageDirective(_localctx.language); } @@ -11641,7 +11664,7 @@ public EventDeclContext eventDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 8); { - State = 2437; + State = 2415; compControl(); } break; @@ -11711,32 +11734,32 @@ public PropHeadContext propHead() { try { EnterOuterAlt(_localctx, 1); { - State = 2440; + State = 2418; Match(T__132); - State = 2446; + State = 2424; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 2441; + State = 2419; _localctx.attribute = propAttr(); Actions.AddPropertyAttribute(_localctx, _localctx.attribute.Value); } } - State = 2448; + State = 2426; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2449; + State = 2427; _localctx.convention = callConv(); - State = 2450; + State = 2428; _localctx.propertyType = type(); - State = 2451; + State = 2429; _localctx.name = dottedName(); - State = 2452; + State = 2430; _localctx.arguments = sigArgs(); - State = 2453; + State = 2431; _localctx.initializer = initOpt(); _localctx.Value = Actions.CreatePropertyHeader( _localctx, @@ -11780,13 +11803,13 @@ public PropAttrContext propAttr() { PropAttrContext _localctx = new PropAttrContext(Context, State); EnterRule(_localctx, 220, RULE_propAttr); try { - State = 2460; + State = 2438; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__68: EnterOuterAlt(_localctx, 1); { - State = 2456; + State = 2434; _localctx.attribute = Match(T__68); _localctx.Value = Actions.CreatePropertyAttribute(_localctx.attribute); } @@ -11794,7 +11817,7 @@ public PropAttrContext propAttr() { case T__67: EnterOuterAlt(_localctx, 2); { - State = 2458; + State = 2436; _localctx.attribute = Match(T__67); _localctx.Value = Actions.CreatePropertyAttribute(_localctx.attribute); } @@ -11842,17 +11865,17 @@ public PropDeclsContext propDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2465; + State = 2443; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38788988928L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 7493989779944505347L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 2462; + State = 2440; propDecl(); } } - State = 2467; + State = 2445; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11907,15 +11930,15 @@ public PropDeclContext propDecl() { PropDeclContext _localctx = new PropDeclContext(Context, State); EnterRule(_localctx, 224, RULE_propDecl); try { - State = 2490; + State = 2468; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__133: EnterOuterAlt(_localctx, 1); { - State = 2468; + State = 2446; Match(T__133); - State = 2469; + State = 2447; _localctx.accessor = methodRef(); Actions.AddPropertySetter(_localctx, _localctx.accessor.Value); } @@ -11923,9 +11946,9 @@ public PropDeclContext propDecl() { case T__134: EnterOuterAlt(_localctx, 2); { - State = 2472; + State = 2450; Match(T__134); - State = 2473; + State = 2451; _localctx.accessor = methodRef(); Actions.AddPropertyGetter(_localctx, _localctx.accessor.Value); } @@ -11933,9 +11956,9 @@ public PropDeclContext propDecl() { case T__131: EnterOuterAlt(_localctx, 3); { - State = 2476; + State = 2454; Match(T__131); - State = 2477; + State = 2455; _localctx.accessor = methodRef(); Actions.AddPropertyOther(_localctx, _localctx.accessor.Value); } @@ -11949,7 +11972,7 @@ public PropDeclContext propDecl() { case ID: EnterOuterAlt(_localctx, 4); { - State = 2480; + State = 2458; _localctx.attribute = customAttrDecl(); Actions.AddPropertyCustomAttribute(_localctx, _localctx.attribute); } @@ -11958,7 +11981,7 @@ public PropDeclContext propDecl() { case T__73: EnterOuterAlt(_localctx, 5); { - State = 2483; + State = 2461; _localctx.source = extSourceSpec(); Actions.ProcessPropertySourceDirective(_localctx.source); } @@ -11966,7 +11989,7 @@ public PropDeclContext propDecl() { case T__26: EnterOuterAlt(_localctx, 6); { - State = 2486; + State = 2464; _localctx.language = languageDecl(); Actions.ProcessPropertyLanguageDirective(_localctx.language); } @@ -11981,7 +12004,7 @@ public PropDeclContext propDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 7); { - State = 2489; + State = 2467; compControl(); } break; @@ -12024,7 +12047,7 @@ public MarshalClauseContext marshalClause() { MarshalClauseContext _localctx = new MarshalClauseContext(Context, State); EnterRule(_localctx, 226, RULE_marshalClause); try { - State = 2499; + State = 2477; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -12061,13 +12084,13 @@ public MarshalClauseContext marshalClause() { case T__121: EnterOuterAlt(_localctx, 2); { - State = 2493; + State = 2471; Match(T__121); - State = 2494; + State = 2472; Match(T__29); - State = 2495; + State = 2473; _localctx.value = marshalBlob(); - State = 2496; + State = 2474; Match(T__30); _localctx.Value = Actions.CompleteMarshalClause(_localctx.value.Value); } @@ -12120,7 +12143,7 @@ public MarshalBlobContext marshalBlob() { Actions.BeginMarshalBlob(_localctx); int _la; try { - State = 2514; + State = 2492; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -12175,7 +12198,7 @@ public MarshalBlobContext marshalBlob() { case ID: EnterOuterAlt(_localctx, 1); { - State = 2501; + State = 2479; _localctx.nativeValue = nativeType(); Actions.SetMarshalBlobNativeType(_localctx, _localctx.nativeValue.Value); } @@ -12183,24 +12206,24 @@ public MarshalBlobContext marshalBlob() { case T__16: EnterOuterAlt(_localctx, 2); { - State = 2504; + State = 2482; Match(T__16); - State = 2508; + State = 2486; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2505; + State = 2483; _localctx.rawByte = hexbyte(); Actions.AddMarshalBlobByte(_localctx, _localctx.rawByte.Value); } } - State = 2510; + State = 2488; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( _la==INT32 || _la==ID || _la==HEXBYTE ); - State = 2512; + State = 2490; Match(T__17); } break; @@ -12251,18 +12274,18 @@ public ParamAttrContext paramAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 2521; + State = 2499; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__41) { { { - State = 2516; + State = 2494; _localctx.element = paramAttrElement(); Actions.AddParameterAttribute(_localctx, _localctx.element); } } - State = 2523; + State = 2501; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -12306,17 +12329,17 @@ public ParamAttrElementContext paramAttrElement() { ParamAttrElementContext _localctx = new ParamAttrElementContext(Context, State); EnterRule(_localctx, 232, RULE_paramAttrElement); try { - State = 2541; + State = 2519; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,113,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,118,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2524; + State = 2502; Match(T__41); - State = 2525; + State = 2503; _localctx.attribute = Match(T__135); - State = 2526; + State = 2504; Match(T__42); Actions.SetParameterAttributeElement(_localctx, _localctx.attribute); } @@ -12324,11 +12347,11 @@ public ParamAttrElementContext paramAttrElement() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2528; + State = 2506; Match(T__41); - State = 2529; + State = 2507; _localctx.attribute = Match(T__136); - State = 2530; + State = 2508; Match(T__42); Actions.SetParameterAttributeElement(_localctx, _localctx.attribute); } @@ -12336,11 +12359,11 @@ public ParamAttrElementContext paramAttrElement() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2532; + State = 2510; Match(T__41); - State = 2533; + State = 2511; _localctx.attribute = Match(T__137); - State = 2534; + State = 2512; Match(T__42); Actions.SetParameterAttributeElement(_localctx, _localctx.attribute); } @@ -12348,11 +12371,11 @@ public ParamAttrElementContext paramAttrElement() { case 4: EnterOuterAlt(_localctx, 4); { - State = 2536; + State = 2514; Match(T__41); - State = 2537; + State = 2515; _localctx.raw = int32(); - State = 2538; + State = 2516; Match(T__42); Actions.SetRawParameterAttributeElement(_localctx, (_localctx.raw!=null?(_localctx.raw.Start):null)); } @@ -12443,14 +12466,14 @@ public MethodHeadContext methodHead() { try { EnterOuterAlt(_localctx, 1); { - State = 2543; + State = 2521; Match(T__138); - State = 2552; + State = 2530; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & 978955L) != 0) || ((((_la - 123)) & ~0x3f) == 0 && ((1L << (_la - 123)) & 33423365L) != 0)) { { - State = 2550; + State = 2528; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__50: @@ -12473,14 +12496,14 @@ public MethodHeadContext methodHead() { case T__144: case T__145: { - State = 2544; + State = 2522; _localctx.attribute = methAttr(); Actions.AddMethodAttribute(_localctx, _localctx.attribute.Value); } break; case T__146: { - State = 2547; + State = 2525; _localctx.pInvoke = pinvImpl(); Actions.AddPInvoke(_localctx, _localctx.pInvoke.Value); } @@ -12489,36 +12512,36 @@ public MethodHeadContext methodHead() { throw new NoViableAltException(this); } } - State = 2554; + State = 2532; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2555; + State = 2533; _localctx.convention = callConv(); - State = 2556; + State = 2534; _localctx.returnAttributes = paramAttr(); - State = 2557; + State = 2535; _localctx.returnType = type(); - State = 2558; + State = 2536; _localctx.returnMarshalling = marshalClause(); - State = 2559; + State = 2537; _localctx.name = methodName(); - State = 2560; + State = 2538; _localctx.genericParameters = typarsClause(); - State = 2561; + State = 2539; _localctx.arguments = sigArgs(); - State = 2567; + State = 2545; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 32766L) != 0) || _la==T__69 || _la==T__155 || _la==UNMANAGED) { { { - State = 2562; + State = 2540; _localctx.implementation = implAttr(); Actions.AddMethodImplementationAttribute(_localctx, _localctx.implementation.Value); } } - State = 2569; + State = 2547; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -12572,13 +12595,13 @@ public MethAttrContext methAttr() { MethAttrContext _localctx = new MethAttrContext(Context, State); EnterRule(_localctx, 236, RULE_methAttr); try { - State = 2614; + State = 2592; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__122: EnterOuterAlt(_localctx, 1); { - State = 2572; + State = 2550; _localctx.attribute = Match(T__122); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12586,7 +12609,7 @@ public MethAttrContext methAttr() { case T__50: EnterOuterAlt(_localctx, 2); { - State = 2574; + State = 2552; _localctx.attribute = Match(T__50); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12594,7 +12617,7 @@ public MethAttrContext methAttr() { case T__51: EnterOuterAlt(_localctx, 3); { - State = 2576; + State = 2554; _localctx.attribute = Match(T__51); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12602,7 +12625,7 @@ public MethAttrContext methAttr() { case T__62: EnterOuterAlt(_localctx, 4); { - State = 2578; + State = 2556; _localctx.attribute = Match(T__62); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12610,7 +12633,7 @@ public MethAttrContext methAttr() { case T__139: EnterOuterAlt(_localctx, 5); { - State = 2580; + State = 2558; _localctx.attribute = Match(T__139); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12618,7 +12641,7 @@ public MethAttrContext methAttr() { case T__67: EnterOuterAlt(_localctx, 6); { - State = 2582; + State = 2560; _localctx.attribute = Match(T__67); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12626,7 +12649,7 @@ public MethAttrContext methAttr() { case T__140: EnterOuterAlt(_localctx, 7); { - State = 2584; + State = 2562; _localctx.attribute = Match(T__140); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12634,7 +12657,7 @@ public MethAttrContext methAttr() { case T__141: EnterOuterAlt(_localctx, 8); { - State = 2586; + State = 2564; _localctx.attribute = Match(T__141); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12642,7 +12665,7 @@ public MethAttrContext methAttr() { case T__53: EnterOuterAlt(_localctx, 9); { - State = 2588; + State = 2566; _localctx.attribute = Match(T__53); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12650,7 +12673,7 @@ public MethAttrContext methAttr() { case T__63: EnterOuterAlt(_localctx, 10); { - State = 2590; + State = 2568; _localctx.attribute = Match(T__63); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12658,7 +12681,7 @@ public MethAttrContext methAttr() { case T__64: EnterOuterAlt(_localctx, 11); { - State = 2592; + State = 2570; _localctx.attribute = Match(T__64); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12666,7 +12689,7 @@ public MethAttrContext methAttr() { case T__65: EnterOuterAlt(_localctx, 12); { - State = 2594; + State = 2572; _localctx.attribute = Match(T__65); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12674,7 +12697,7 @@ public MethAttrContext methAttr() { case T__124: EnterOuterAlt(_localctx, 13); { - State = 2596; + State = 2574; _localctx.attribute = Match(T__124); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12682,7 +12705,7 @@ public MethAttrContext methAttr() { case T__142: EnterOuterAlt(_localctx, 14); { - State = 2598; + State = 2576; _localctx.attribute = Match(T__142); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12690,7 +12713,7 @@ public MethAttrContext methAttr() { case T__143: EnterOuterAlt(_localctx, 15); { - State = 2600; + State = 2578; _localctx.attribute = Match(T__143); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12698,7 +12721,7 @@ public MethAttrContext methAttr() { case T__68: EnterOuterAlt(_localctx, 16); { - State = 2602; + State = 2580; _localctx.attribute = Match(T__68); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12706,7 +12729,7 @@ public MethAttrContext methAttr() { case T__144: EnterOuterAlt(_localctx, 17); { - State = 2604; + State = 2582; _localctx.attribute = Match(T__144); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12714,7 +12737,7 @@ public MethAttrContext methAttr() { case T__145: EnterOuterAlt(_localctx, 18); { - State = 2606; + State = 2584; _localctx.attribute = Match(T__145); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12722,13 +12745,13 @@ public MethAttrContext methAttr() { case T__69: EnterOuterAlt(_localctx, 19); { - State = 2608; + State = 2586; Match(T__69); - State = 2609; + State = 2587; Match(T__29); - State = 2610; + State = 2588; _localctx.flags = int32(); - State = 2611; + State = 2589; Match(T__30); _localctx.Value = Actions.CreateRawMethodAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } @@ -12785,32 +12808,32 @@ public PinvImplContext pinvImpl() { Actions.BeginPInvoke(_localctx); int _la; try { - State = 2639; + State = 2617; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,121,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,126,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2616; + State = 2594; Match(T__146); - State = 2617; + State = 2595; Match(T__29); - State = 2626; + State = 2604; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==QSTRING) { { - State = 2618; + State = 2596; _localctx.module = compQstring(); Actions.SetPInvokeModule(_localctx, _localctx.module.Value); - State = 2624; + State = 2602; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__33) { { - State = 2620; + State = 2598; Match(T__33); - State = 2621; + State = 2599; _localctx.entryPoint = compQstring(); Actions.SetPInvokeEntryPoint(_localctx, _localctx.entryPoint.Value); } @@ -12819,31 +12842,31 @@ public PinvImplContext pinvImpl() { } } - State = 2633; + State = 2611; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 57)) & ~0x3f) == 0 && ((1L << (_la - 57)) & 8195L) != 0) || ((((_la - 148)) & ~0x3f) == 0 && ((1L << (_la - 148)) & 79L) != 0) || ((((_la - 224)) & ~0x3f) == 0 && ((1L << (_la - 224)) & 251658241L) != 0)) { { { - State = 2628; + State = 2606; _localctx.attribute = pinvAttr(); Actions.AddPInvokeAttribute(_localctx, _localctx.attribute.Value); } } - State = 2635; + State = 2613; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2636; + State = 2614; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2637; + State = 2615; Match(T__146); - State = 2638; + State = 2616; Match(T__84); } break; @@ -12892,13 +12915,13 @@ public PinvAttrContext pinvAttr() { PinvAttrContext _localctx = new PinvAttrContext(Context, State); EnterRule(_localctx, 240, RULE_pinvAttr); try { - State = 2683; + State = 2661; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,122,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,127,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2641; + State = 2619; _localctx.attribute = Match(T__147); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12906,7 +12929,7 @@ public PinvAttrContext pinvAttr() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2643; + State = 2621; _localctx.attribute = Match(ANSI); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12914,7 +12937,7 @@ public PinvAttrContext pinvAttr() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2645; + State = 2623; _localctx.attribute = Match(T__56); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12922,7 +12945,7 @@ public PinvAttrContext pinvAttr() { case 4: EnterOuterAlt(_localctx, 4); { - State = 2647; + State = 2625; _localctx.attribute = Match(T__57); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12930,7 +12953,7 @@ public PinvAttrContext pinvAttr() { case 5: EnterOuterAlt(_localctx, 5); { - State = 2649; + State = 2627; _localctx.attribute = Match(T__148); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12938,7 +12961,7 @@ public PinvAttrContext pinvAttr() { case 6: EnterOuterAlt(_localctx, 6); { - State = 2651; + State = 2629; _localctx.attribute = Match(T__149); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12946,7 +12969,7 @@ public PinvAttrContext pinvAttr() { case 7: EnterOuterAlt(_localctx, 7); { - State = 2653; + State = 2631; _localctx.attribute = Match(CDECL); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12954,7 +12977,7 @@ public PinvAttrContext pinvAttr() { case 8: EnterOuterAlt(_localctx, 8); { - State = 2655; + State = 2633; _localctx.attribute = Match(STDCALL); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12962,7 +12985,7 @@ public PinvAttrContext pinvAttr() { case 9: EnterOuterAlt(_localctx, 9); { - State = 2657; + State = 2635; _localctx.attribute = Match(THISCALL); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12970,7 +12993,7 @@ public PinvAttrContext pinvAttr() { case 10: EnterOuterAlt(_localctx, 10); { - State = 2659; + State = 2637; _localctx.attribute = Match(FASTCALL); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12978,11 +13001,11 @@ public PinvAttrContext pinvAttr() { case 11: EnterOuterAlt(_localctx, 11); { - State = 2661; + State = 2639; Match(T__150); - State = 2662; + State = 2640; Match(T__74); - State = 2663; + State = 2641; _localctx.setting = Match(T__151); _localctx.Value = Actions.CreateBestFitPInvokeAttribute(_localctx.setting); } @@ -12990,11 +13013,11 @@ public PinvAttrContext pinvAttr() { case 12: EnterOuterAlt(_localctx, 12); { - State = 2665; + State = 2643; Match(T__150); - State = 2666; + State = 2644; Match(T__74); - State = 2667; + State = 2645; _localctx.setting = Match(T__152); _localctx.Value = Actions.CreateBestFitPInvokeAttribute(_localctx.setting); } @@ -13002,11 +13025,11 @@ public PinvAttrContext pinvAttr() { case 13: EnterOuterAlt(_localctx, 13); { - State = 2669; + State = 2647; Match(T__153); - State = 2670; + State = 2648; Match(T__74); - State = 2671; + State = 2649; _localctx.setting = Match(T__151); _localctx.Value = Actions.CreateCharMapErrorPInvokeAttribute(_localctx.setting); } @@ -13014,11 +13037,11 @@ public PinvAttrContext pinvAttr() { case 14: EnterOuterAlt(_localctx, 14); { - State = 2673; + State = 2651; Match(T__153); - State = 2674; + State = 2652; Match(T__74); - State = 2675; + State = 2653; _localctx.setting = Match(T__152); _localctx.Value = Actions.CreateCharMapErrorPInvokeAttribute(_localctx.setting); } @@ -13026,13 +13049,13 @@ public PinvAttrContext pinvAttr() { case 15: EnterOuterAlt(_localctx, 15); { - State = 2677; + State = 2655; Match(T__69); - State = 2678; + State = 2656; Match(T__29); - State = 2679; + State = 2657; _localctx.flags = int32(); - State = 2680; + State = 2658; Match(T__30); _localctx.Value = Actions.CreateRawPInvokeAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } @@ -13076,13 +13099,13 @@ public MethodNameContext methodName() { MethodNameContext _localctx = new MethodNameContext(Context, State); EnterRule(_localctx, 242, RULE_methodName); try { - State = 2692; + State = 2670; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__115: EnterOuterAlt(_localctx, 1); { - State = 2685; + State = 2663; _localctx.ctorName = Match(T__115); _localctx.Value = Actions.GetMethodName(_localctx.ctorName); } @@ -13090,7 +13113,7 @@ public MethodNameContext methodName() { case T__154: EnterOuterAlt(_localctx, 2); { - State = 2687; + State = 2665; _localctx.cctorName = Match(T__154); _localctx.Value = Actions.GetMethodName(_localctx.cctorName); } @@ -13103,7 +13126,7 @@ public MethodNameContext methodName() { case ID: EnterOuterAlt(_localctx, 3); { - State = 2689; + State = 2667; _localctx.dotted = dottedName(); _localctx.Value = _localctx.dotted.Value; } @@ -13149,13 +13172,13 @@ public ImplAttrContext implAttr() { ImplAttrContext _localctx = new ImplAttrContext(Context, State); EnterRule(_localctx, 244, RULE_implAttr); try { - State = 2732; + State = 2710; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: EnterOuterAlt(_localctx, 1); { - State = 2694; + State = 2672; _localctx.attribute = Match(T__0); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13163,7 +13186,7 @@ public ImplAttrContext implAttr() { case T__1: EnterOuterAlt(_localctx, 2); { - State = 2696; + State = 2674; _localctx.attribute = Match(T__1); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13171,7 +13194,7 @@ public ImplAttrContext implAttr() { case T__155: EnterOuterAlt(_localctx, 3); { - State = 2698; + State = 2676; _localctx.attribute = Match(T__155); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13179,7 +13202,7 @@ public ImplAttrContext implAttr() { case T__2: EnterOuterAlt(_localctx, 4); { - State = 2700; + State = 2678; _localctx.attribute = Match(T__2); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13187,7 +13210,7 @@ public ImplAttrContext implAttr() { case T__3: EnterOuterAlt(_localctx, 5); { - State = 2702; + State = 2680; _localctx.attribute = Match(T__3); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13195,7 +13218,7 @@ public ImplAttrContext implAttr() { case UNMANAGED: EnterOuterAlt(_localctx, 6); { - State = 2704; + State = 2682; _localctx.attribute = Match(UNMANAGED); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13203,7 +13226,7 @@ public ImplAttrContext implAttr() { case T__4: EnterOuterAlt(_localctx, 7); { - State = 2706; + State = 2684; _localctx.attribute = Match(T__4); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13211,7 +13234,7 @@ public ImplAttrContext implAttr() { case T__5: EnterOuterAlt(_localctx, 8); { - State = 2708; + State = 2686; _localctx.attribute = Match(T__5); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13219,7 +13242,7 @@ public ImplAttrContext implAttr() { case T__6: EnterOuterAlt(_localctx, 9); { - State = 2710; + State = 2688; _localctx.attribute = Match(T__6); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13227,7 +13250,7 @@ public ImplAttrContext implAttr() { case T__7: EnterOuterAlt(_localctx, 10); { - State = 2712; + State = 2690; _localctx.attribute = Match(T__7); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13235,7 +13258,7 @@ public ImplAttrContext implAttr() { case T__8: EnterOuterAlt(_localctx, 11); { - State = 2714; + State = 2692; _localctx.attribute = Match(T__8); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13243,7 +13266,7 @@ public ImplAttrContext implAttr() { case T__9: EnterOuterAlt(_localctx, 12); { - State = 2716; + State = 2694; _localctx.attribute = Match(T__9); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13251,7 +13274,7 @@ public ImplAttrContext implAttr() { case T__10: EnterOuterAlt(_localctx, 13); { - State = 2718; + State = 2696; _localctx.attribute = Match(T__10); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13259,7 +13282,7 @@ public ImplAttrContext implAttr() { case T__11: EnterOuterAlt(_localctx, 14); { - State = 2720; + State = 2698; _localctx.attribute = Match(T__11); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13267,7 +13290,7 @@ public ImplAttrContext implAttr() { case T__12: EnterOuterAlt(_localctx, 15); { - State = 2722; + State = 2700; _localctx.attribute = Match(T__12); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13275,7 +13298,7 @@ public ImplAttrContext implAttr() { case T__13: EnterOuterAlt(_localctx, 16); { - State = 2724; + State = 2702; _localctx.attribute = Match(T__13); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13283,13 +13306,13 @@ public ImplAttrContext implAttr() { case T__69: EnterOuterAlt(_localctx, 17); { - State = 2726; + State = 2704; Match(T__69); - State = 2727; + State = 2705; Match(T__29); - State = 2728; + State = 2706; _localctx.flags = int32(); - State = 2729; + State = 2707; Match(T__30); _localctx.Value = Actions.CreateRawMethodImplementationAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } @@ -13338,17 +13361,17 @@ public MethodDeclsContext methodDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 2737; + State = 2715; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38789119998L) != 0) || _la==T__72 || _la==T__73 || ((((_la - 158)) & ~0x3f) == 0 && ((1L << (_la - 158)) & 2199023255681L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 2303696760354115601L) != 0)) { { { - State = 2734; + State = 2712; methodDecl(); } } - State = 2739; + State = 2717; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -13443,7 +13466,7 @@ public MethodDeclContext methodDecl() { MethodDeclContext _localctx = new MethodDeclContext(Context, State); EnterRule(_localctx, 248, RULE_methodDecl); try { - State = 2777; + State = 2755; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case INSTR_NONE: @@ -13461,16 +13484,16 @@ public MethodDeclContext methodDecl() { case INSTR_TOK: EnterOuterAlt(_localctx, 1); { - State = 2740; + State = 2718; instr(); } break; case EMITBYTE: EnterOuterAlt(_localctx, 2); { - State = 2741; + State = 2719; Match(EMITBYTE); - State = 2742; + State = 2720; _localctx.value = int32(); Actions.EmitByte((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -13478,16 +13501,16 @@ public MethodDeclContext methodDecl() { case T__157: EnterOuterAlt(_localctx, 3); { - State = 2745; + State = 2723; sehBlock(); } break; case MAXSTACK: EnterOuterAlt(_localctx, 4); { - State = 2746; + State = 2724; Match(MAXSTACK); - State = 2747; + State = 2725; _localctx.value = int32(); Actions.SetMaxStack((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -13495,7 +13518,7 @@ public MethodDeclContext methodDecl() { case ENTRYPOINT: EnterOuterAlt(_localctx, 5); { - State = 2750; + State = 2728; Match(ENTRYPOINT); Actions.SetEntryPoint(); } @@ -13503,7 +13526,7 @@ public MethodDeclContext methodDecl() { case ZEROINIT: EnterOuterAlt(_localctx, 6); { - State = 2752; + State = 2730; Match(ZEROINIT); Actions.SetZeroInit(); } @@ -13530,28 +13553,28 @@ public MethodDeclContext methodDecl() { case ID: EnterOuterAlt(_localctx, 7); { - State = 2754; + State = 2732; labelDecl(); } break; case T__16: EnterOuterAlt(_localctx, 8); { - State = 2755; + State = 2733; scopeBlock(); } break; case LOCALS: EnterOuterAlt(_localctx, 9); { - State = 2756; + State = 2734; localsDecl(); } break; case T__164: EnterOuterAlt(_localctx, 10); { - State = 2757; + State = 2735; _localctx.declaration = dataDecl(); Actions.ProcessMethodDataDeclaration(_localctx.declaration); } @@ -13560,7 +13583,7 @@ public MethodDeclContext methodDecl() { case PERMISSIONSET: EnterOuterAlt(_localctx, 11); { - State = 2760; + State = 2738; _localctx.security = secDecl(); Actions.ProcessMethodSecurityDeclaration(_localctx.security); } @@ -13569,7 +13592,7 @@ public MethodDeclContext methodDecl() { case T__73: EnterOuterAlt(_localctx, 12); { - State = 2763; + State = 2741; _localctx.source = extSourceSpec(); Actions.ProcessMethodSourceDirective(_localctx.source); } @@ -13577,7 +13600,7 @@ public MethodDeclContext methodDecl() { case T__26: EnterOuterAlt(_localctx, 13); { - State = 2766; + State = 2744; _localctx.language = languageDecl(); Actions.ProcessMethodLanguageDirective(_localctx.language); } @@ -13585,7 +13608,7 @@ public MethodDeclContext methodDecl() { case T__34: EnterOuterAlt(_localctx, 14); { - State = 2769; + State = 2747; _localctx.attribute = customDescrInMethodBody(); Actions.ProcessMethodCustomAttribute(_localctx.attribute); } @@ -13600,35 +13623,35 @@ public MethodDeclContext methodDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 15); { - State = 2772; + State = 2750; compControl(); } break; case EXPORT: EnterOuterAlt(_localctx, 16); { - State = 2773; + State = 2751; exportDecl(); } break; case VTENTRY: EnterOuterAlt(_localctx, 17); { - State = 2774; + State = 2752; vtentryDecl(); } break; case OVERRIDE: EnterOuterAlt(_localctx, 18); { - State = 2775; + State = 2753; overrideDecl(); } break; case PARAM: EnterOuterAlt(_localctx, 19); { - State = 2776; + State = 2754; parameterDecl(); } break; @@ -13676,19 +13699,19 @@ public LocalsDeclContext localsDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2779; + State = 2757; Match(LOCALS); - State = 2781; + State = 2759; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__156) { { - State = 2780; + State = 2758; _localctx.initialize = Match(T__156); } } - State = 2783; + State = 2761; _localctx.arguments = sigArgs(); } } @@ -13736,22 +13759,22 @@ public ExportDeclContext exportDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2785; + State = 2763; Match(EXPORT); - State = 2786; + State = 2764; Match(T__41); - State = 2787; + State = 2765; _localctx.ordinal = int32(); - State = 2788; + State = 2766; Match(T__42); - State = 2791; + State = 2769; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__33) { { - State = 2789; + State = 2767; Match(T__33); - State = 2790; + State = 2768; _localctx.alias = id(); } } @@ -13801,13 +13824,13 @@ public VtentryDeclContext vtentryDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2793; + State = 2771; Match(VTENTRY); - State = 2794; + State = 2772; _localctx.table = int32(); - State = 2795; + State = 2773; Match(T__74); - State = 2796; + State = 2774; _localctx.slot = int32(); } } @@ -13870,42 +13893,42 @@ public OverrideDeclContext overrideDecl() { EnterRule(_localctx, 256, RULE_overrideDecl); Actions.BeginSemanticRoot(_localctx); try { - State = 2813; + State = 2791; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,129,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,134,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2798; + State = 2776; Match(OVERRIDE); - State = 2799; + State = 2777; _localctx.owner = typeSpec(); - State = 2800; + State = 2778; Match(DCOLON); - State = 2801; + State = 2779; _localctx.name = methodName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2803; + State = 2781; Match(OVERRIDE); - State = 2804; + State = 2782; Match(METHOD); - State = 2805; + State = 2783; _localctx.convention = callConv(); - State = 2806; + State = 2784; _localctx.returnType = type(); - State = 2807; + State = 2785; _localctx.owner = typeSpec(); - State = 2808; + State = 2786; Match(DCOLON); - State = 2809; + State = 2787; _localctx.name = methodName(); - State = 2810; + State = 2788; _localctx.arity = genArity(); - State = 2811; + State = 2789; _localctx.arguments = sigArgs(); } break; @@ -13973,166 +13996,166 @@ public ParameterDeclContext parameterDecl() { Actions.BeginParameterDirective(_localctx); try { int _alt; - State = 2880; + State = 2858; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,135,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,140,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2815; + State = 2793; Match(PARAM); - State = 2816; + State = 2794; Match(TYPE); - State = 2817; + State = 2795; Match(T__41); - State = 2818; + State = 2796; _localctx.genericIndex = int32(); - State = 2819; + State = 2797; Match(T__42); - State = 2825; + State = 2803; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,130,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,135,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2820; + State = 2798; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2827; + State = 2805; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,130,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,135,Context); } } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2828; + State = 2806; Match(PARAM); - State = 2829; + State = 2807; Match(TYPE); - State = 2830; + State = 2808; _localctx.genericName = dottedName(); - State = 2836; + State = 2814; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,131,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,136,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2831; + State = 2809; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2838; + State = 2816; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,131,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,136,Context); } } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2839; + State = 2817; Match(PARAM); - State = 2840; + State = 2818; Match(CONSTRAINT); - State = 2841; + State = 2819; Match(T__41); - State = 2842; + State = 2820; _localctx.constraintIndex = int32(); - State = 2843; + State = 2821; Match(T__42); - State = 2844; + State = 2822; Match(T__27); - State = 2845; + State = 2823; _localctx.constraintType = typeSpec(); - State = 2851; + State = 2829; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,132,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,137,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2846; + State = 2824; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2853; + State = 2831; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,132,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,137,Context); } } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2854; + State = 2832; Match(PARAM); - State = 2855; + State = 2833; Match(CONSTRAINT); - State = 2856; + State = 2834; _localctx.constraintName = dottedName(); - State = 2857; + State = 2835; Match(T__27); - State = 2858; + State = 2836; _localctx.constraintType = typeSpec(); - State = 2864; + State = 2842; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,133,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,138,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2859; + State = 2837; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2866; + State = 2844; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,133,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,138,Context); } } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2867; + State = 2845; Match(PARAM); - State = 2868; + State = 2846; Match(T__41); - State = 2869; + State = 2847; _localctx.parameterIndex = int32(); - State = 2870; + State = 2848; Match(T__42); - State = 2871; + State = 2849; _localctx.initializer = initOpt(); - State = 2877; + State = 2855; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,134,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,139,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2872; + State = 2850; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2879; + State = 2857; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,134,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,139,Context); } } break; @@ -14175,9 +14198,9 @@ public LabelDeclContext labelDecl() { try { EnterOuterAlt(_localctx, 1); { - State = 2882; + State = 2860; _localctx.name = id(); - State = 2883; + State = 2861; Match(T__74); Actions.DefineLabel((_localctx.name!=null?(_localctx.name.Start):null)); } @@ -14223,13 +14246,13 @@ public CustomDescrInMethodBodyContext customDescrInMethodBody() { EnterRule(_localctx, 262, RULE_customDescrInMethodBody); Actions.BeginSemanticRoot(_localctx); try { - State = 2892; + State = 2870; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,136,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,141,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2886; + State = 2864; _localctx.directAttribute = customDescr(); _localctx.Value = Actions.CreateCustomAttributeDeclaration(_localctx.directAttribute.Value); } @@ -14237,7 +14260,7 @@ public CustomDescrInMethodBodyContext customDescrInMethodBody() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2889; + State = 2867; _localctx.ownedAttribute = customDescrWithOwner(); _localctx.Value = Actions.CreateCustomAttributeDeclaration(_localctx.ownedAttribute.Value); } @@ -14281,11 +14304,11 @@ public ScopeBlockContext scopeBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 2894; + State = 2872; Match(T__16); - State = 2895; + State = 2873; methodDecls(); - State = 2896; + State = 2874; Match(T__17); } } @@ -14331,9 +14354,9 @@ public SehBlockContext sehBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 2898; + State = 2876; _localctx.tryRange = tryBlock(); - State = 2899; + State = 2877; _localctx.clauses = sehClauses(); } } @@ -14380,18 +14403,18 @@ public SehClausesContext sehClauses() { try { EnterOuterAlt(_localctx, 1); { - State = 2904; + State = 2882; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2901; + State = 2879; _localctx.clause = sehClause(); Actions.AddExceptionClause(_localctx, _localctx.clause.Value); } } - State = 2906; + State = 2884; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( ((((_la - 160)) & ~0x3f) == 0 && ((1L << (_la - 160)) & 15L) != 0) ); @@ -14449,15 +14472,15 @@ public TryBlockContext tryBlock() { TryBlockContext _localctx = new TryBlockContext(Context, State); EnterRule(_localctx, 270, RULE_tryBlock); try { - State = 2924; + State = 2902; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,138,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,143,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2908; + State = 2886; Match(T__157); - State = 2909; + State = 2887; _localctx.body = scopeBlock(); _localctx.Value = Actions.CreateScopeExceptionRange(_localctx.body); } @@ -14465,13 +14488,13 @@ public TryBlockContext tryBlock() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2912; + State = 2890; Match(T__157); - State = 2913; + State = 2891; _localctx.startLabel = id(); - State = 2914; + State = 2892; Match(T__158); - State = 2915; + State = 2893; _localctx.endLabel = id(); _localctx.Value = Actions.CreateLabelExceptionRange((_localctx.startLabel!=null?(_localctx.startLabel.Start):null), (_localctx.endLabel!=null?(_localctx.endLabel.Start):null)); } @@ -14479,13 +14502,13 @@ public TryBlockContext tryBlock() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2918; + State = 2896; Match(T__157); - State = 2919; + State = 2897; _localctx.startOffset = int32(); - State = 2920; + State = 2898; Match(T__158); - State = 2921; + State = 2899; _localctx.endOffset = int32(); _localctx.Value = Actions.CreateOffsetExceptionRange((_localctx.startOffset!=null?(_localctx.startOffset.Start):null), (_localctx.endOffset!=null?(_localctx.endOffset.Start):null)); } @@ -14541,15 +14564,15 @@ public SehClauseContext sehClause() { SehClauseContext _localctx = new SehClauseContext(Context, State); EnterRule(_localctx, 272, RULE_sehClause); try { - State = 2942; + State = 2920; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__160: EnterOuterAlt(_localctx, 1); { - State = 2926; + State = 2904; _localctx.caught = catchClause(); - State = 2927; + State = 2905; _localctx.handler = handlerBlock(); _localctx.Value = Actions.CreateCatchExceptionClause(_localctx.caught.Value, _localctx.handler.Value); } @@ -14557,9 +14580,9 @@ public SehClauseContext sehClause() { case T__159: EnterOuterAlt(_localctx, 2); { - State = 2930; + State = 2908; _localctx.filtered = filterClause(); - State = 2931; + State = 2909; _localctx.handler = handlerBlock(); _localctx.Value = Actions.CreateFilterExceptionClause(_localctx.filtered.Value, _localctx.handler.Value); } @@ -14567,9 +14590,9 @@ public SehClauseContext sehClause() { case T__161: EnterOuterAlt(_localctx, 3); { - State = 2934; + State = 2912; finallyClause(); - State = 2935; + State = 2913; _localctx.handler = handlerBlock(); _localctx.Value = Actions.CreateFinallyExceptionClause(_localctx.handler.Value); } @@ -14577,9 +14600,9 @@ public SehClauseContext sehClause() { case T__162: EnterOuterAlt(_localctx, 4); { - State = 2938; + State = 2916; faultClause(); - State = 2939; + State = 2917; _localctx.handler = handlerBlock(); _localctx.Value = Actions.CreateFaultExceptionClause(_localctx.handler.Value); } @@ -14631,15 +14654,15 @@ public FilterClauseContext filterClause() { FilterClauseContext _localctx = new FilterClauseContext(Context, State); EnterRule(_localctx, 274, RULE_filterClause); try { - State = 2956; + State = 2934; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,140,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,145,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2944; + State = 2922; Match(T__159); - State = 2945; + State = 2923; _localctx.body = scopeBlock(); _localctx.Value = Actions.CreateScopeFilter(_localctx.body); } @@ -14647,9 +14670,9 @@ public FilterClauseContext filterClause() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2948; + State = 2926; Match(T__159); - State = 2949; + State = 2927; _localctx.label = id(); _localctx.Value = Actions.CreateLabelFilter((_localctx.label!=null?(_localctx.label.Start):null)); } @@ -14657,9 +14680,9 @@ public FilterClauseContext filterClause() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2952; + State = 2930; Match(T__159); - State = 2953; + State = 2931; _localctx.offset = int32(); _localctx.Value = Actions.CreateOffsetFilter((_localctx.offset!=null?(_localctx.offset.Start):null)); } @@ -14704,9 +14727,9 @@ public CatchClauseContext catchClause() { try { EnterOuterAlt(_localctx, 1); { - State = 2958; + State = 2936; Match(T__160); - State = 2959; + State = 2937; _localctx.catchType = typeSpec(); } } @@ -14743,7 +14766,7 @@ public FinallyClauseContext finallyClause() { try { EnterOuterAlt(_localctx, 1); { - State = 2961; + State = 2939; Match(T__161); } } @@ -14779,7 +14802,7 @@ public FaultClauseContext faultClause() { try { EnterOuterAlt(_localctx, 1); { - State = 2963; + State = 2941; Match(T__162); } } @@ -14834,13 +14857,13 @@ public HandlerBlockContext handlerBlock() { HandlerBlockContext _localctx = new HandlerBlockContext(Context, State); EnterRule(_localctx, 282, RULE_handlerBlock); try { - State = 2980; + State = 2958; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,141,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,146,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2965; + State = 2943; _localctx.body = scopeBlock(); _localctx.Value = Actions.CreateScopeExceptionRange(_localctx.body); } @@ -14848,13 +14871,13 @@ public HandlerBlockContext handlerBlock() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2968; + State = 2946; Match(T__163); - State = 2969; + State = 2947; _localctx.startLabel = id(); - State = 2970; + State = 2948; Match(T__158); - State = 2971; + State = 2949; _localctx.endLabel = id(); _localctx.Value = Actions.CreateLabelExceptionRange((_localctx.startLabel!=null?(_localctx.startLabel.Start):null), (_localctx.endLabel!=null?(_localctx.endLabel.Start):null)); } @@ -14862,13 +14885,13 @@ public HandlerBlockContext handlerBlock() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2974; + State = 2952; Match(T__163); - State = 2975; + State = 2953; _localctx.startOffset = int32(); - State = 2976; + State = 2954; Match(T__158); - State = 2977; + State = 2955; _localctx.endOffset = int32(); _localctx.Value = Actions.CreateOffsetExceptionRange((_localctx.startOffset!=null?(_localctx.startOffset.Start):null), (_localctx.endOffset!=null?(_localctx.endOffset.Start):null)); } @@ -14911,13 +14934,13 @@ public override TResult Accept(IParseTreeVisitor visitor) { public DataDeclContext dataDecl() { DataDeclContext _localctx = new DataDeclContext(Context, State); EnterRule(_localctx, 284, RULE_dataDecl); - BeginSubtree(); Actions.BeginSemanticRoot(_localctx); + BeginStreaming(); Actions.BeginDataDeclaration(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 2982; + State = 2960; ddHead(); - State = 2983; + State = 2961; ddBody(); } } @@ -14927,13 +14950,15 @@ public DataDeclContext dataDecl() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); + Actions.EndDataDeclaration(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; } public partial class DdHeadContext : ParserRuleContext { + public TlsContext section; + public IdContext name; [System.Diagnostics.DebuggerNonUserCode] public TlsContext tls() { return GetRuleContext(0); } @@ -14958,29 +14983,31 @@ public DdHeadContext ddHead() { DdHeadContext _localctx = new DdHeadContext(Context, State); EnterRule(_localctx, 286, RULE_ddHead); try { - State = 2992; + State = 2973; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,142,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,147,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2985; + State = 2963; Match(T__164); - State = 2986; - tls(); - State = 2987; - id(); - State = 2988; + State = 2964; + _localctx.section = tls(); + State = 2965; + _localctx.name = id(); + State = 2966; Match(T__35); + Actions.SetDataDeclarationHeader(_localctx, _localctx.section.Value, (_localctx.name!=null?(_localctx.name.Start):null)); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2990; + State = 2969; Match(T__164); - State = 2991; - tls(); + State = 2970; + _localctx.section = tls(); + Actions.SetAnonymousDataDeclarationHeader(_localctx, _localctx.section.Value); } break; } @@ -14997,6 +15024,7 @@ public DdHeadContext ddHead() { } public partial class TlsContext : ParserRuleContext { + public byte Value; public TlsContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { @@ -15014,10 +15042,11 @@ public override TResult Accept(IParseTreeVisitor visitor) { public TlsContext tls() { TlsContext _localctx = new TlsContext(Context, State); EnterRule(_localctx, 288, RULE_tls); + _localctx.Value = Actions.GetMappedDataSection(); try { - State = 2997; + State = 2980; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,143,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,148,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -15026,15 +15055,17 @@ public TlsContext tls() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2995; + State = 2976; Match(T__165); + _localctx.Value = Actions.GetTlsDataSection(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2996; + State = 2978; Match(T__1); + _localctx.Value = Actions.GetCilDataSection(); } break; } @@ -15079,17 +15110,17 @@ public DdBodyContext ddBody() { EnterRule(_localctx, 290, RULE_ddBody); int _la; try { - State = 3008; + State = 2991; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: EnterOuterAlt(_localctx, 1); { - State = 2999; + State = 2982; Match(T__16); - State = 3000; + State = 2983; ddItemList(); - State = 3001; + State = 2984; Match(T__17); } break; @@ -15104,17 +15135,17 @@ public DdBodyContext ddBody() { case REF: EnterOuterAlt(_localctx, 2); { - State = 3004; + State = 2987; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 3003; + State = 2986; ddItem(); } } - State = 3006; + State = 2989; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( _la==T__83 || ((((_la - 181)) & ~0x3f) == 0 && ((1L << (_la - 181)) & 505L) != 0) || _la==REF ); @@ -15163,25 +15194,25 @@ public DdItemListContext ddItemList() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 3015; + State = 2998; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,146,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,151,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 3010; + State = 2993; ddItem(); - State = 3011; + State = 2994; Match(T__27); } } } - State = 3017; + State = 3000; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,146,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,151,Context); } - State = 3018; + State = 3001; ddItem(); } } @@ -15197,6 +15228,8 @@ public DdItemListContext ddItemList() { } public partial class DdItemCountContext : ParserRuleContext { + public int Value; + public Int32Context count; [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); } @@ -15217,8 +15250,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { public DdItemCountContext ddItemCount() { DdItemCountContext _localctx = new DdItemCountContext(Context, State); EnterRule(_localctx, 294, RULE_ddItemCount); + _localctx.Value = 1; try { - State = 3025; + State = 3009; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -15322,12 +15356,13 @@ public DdItemCountContext ddItemCount() { case T__41: EnterOuterAlt(_localctx, 2); { - State = 3021; + State = 3004; Match(T__41); - State = 3022; - int32(); - State = 3023; + State = 3005; + _localctx.count = int32(); + State = 3006; Match(T__42); + _localctx.Value = Actions.ParseDataItemCount((_localctx.count!=null?(_localctx.count.Start):null)); } break; default: @@ -15346,6 +15381,14 @@ public DdItemCountContext ddItemCount() { } public partial class DdItemContext : ParserRuleContext { + public CompQstringContext stringValue; + public IdContext target; + public BytesContext byteValue; + public IToken kind; + public Float64Context floatingValue; + public DdItemCountContext count; + public Int64Context int64Value; + public Int32Context integerValue; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CHAR() { return GetToken(CILParser.CHAR, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PTR() { return GetToken(CILParser.PTR, 0); } [System.Diagnostics.DebuggerNonUserCode] public CompQstringContext compQstring() { @@ -15358,22 +15401,22 @@ [System.Diagnostics.DebuggerNonUserCode] public IdContext id() { [System.Diagnostics.DebuggerNonUserCode] public BytesContext bytes() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT32() { return GetToken(CILParser.FLOAT32, 0); } [System.Diagnostics.DebuggerNonUserCode] public Float64Context float64() { return GetRuleContext(0); } [System.Diagnostics.DebuggerNonUserCode] public DdItemCountContext ddItemCount() { return GetRuleContext(0); } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT32() { return GetToken(CILParser.FLOAT32, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT64_() { return GetToken(CILParser.FLOAT64_, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT64_() { return GetToken(CILParser.INT64_, 0); } [System.Diagnostics.DebuggerNonUserCode] public Int64Context int64() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT32_() { return GetToken(CILParser.INT32_, 0); } [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT32_() { return GetToken(CILParser.INT32_, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT16() { return GetToken(CILParser.INT16, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT8() { return GetToken(CILParser.INT8, 0); } public DdItemContext(ParserRuleContext parent, int invokingState) @@ -15393,202 +15436,145 @@ public override TResult Accept(IParseTreeVisitor visitor) { public DdItemContext ddItem() { DdItemContext _localctx = new DdItemContext(Context, State); EnterRule(_localctx, 296, RULE_ddItem); + int _la; try { - State = 3093; + State = 3059; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,148,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,153,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3027; + State = 3011; Match(CHAR); - State = 3028; + State = 3012; Match(PTR); - State = 3029; + State = 3013; Match(T__29); - State = 3030; - compQstring(); - State = 3031; + State = 3014; + _localctx.stringValue = compQstring(); + State = 3015; Match(T__30); + Actions.AddDataString(_localctx, _localctx.stringValue.Value); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3033; + State = 3018; Match(REF); - State = 3034; + State = 3019; Match(T__29); - State = 3035; - id(); - State = 3036; + State = 3020; + _localctx.target = id(); + State = 3021; Match(T__30); + Actions.AddDataReference(_localctx, (_localctx.target!=null?(_localctx.target.Start):null)); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3038; + State = 3024; Match(REF); - State = 3039; - id(); + State = 3025; + _localctx.target = id(); + Actions.AddDataReference(_localctx, (_localctx.target!=null?(_localctx.target.Start):null)); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 3040; + State = 3028; Match(T__83); - State = 3041; + State = 3029; Match(T__29); - State = 3042; - bytes(); - State = 3043; + State = 3030; + _localctx.byteValue = bytes(); + State = 3031; Match(T__30); + Actions.AddDataBytes(_localctx, _localctx.byteValue.Value); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 3045; - Match(FLOAT32); - State = 3046; + State = 3034; + _localctx.kind = TokenStream.LT(1); + _la = TokenStream.LA(1); + if ( !(_la==FLOAT32 || _la==FLOAT64_) ) { + _localctx.kind = ErrorHandler.RecoverInline(this); + } + else { + ErrorHandler.ReportMatch(this); + Consume(); + } + State = 3035; Match(T__29); - State = 3047; - float64(); - State = 3048; + State = 3036; + _localctx.floatingValue = float64(); + State = 3037; Match(T__30); - State = 3049; - ddItemCount(); + State = 3038; + _localctx.count = ddItemCount(); + Actions.AddFloatingPointData(_localctx, _localctx.kind, _localctx.floatingValue.Value, _localctx.count.Value); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 3051; - Match(FLOAT64_); - State = 3052; + State = 3041; + _localctx.kind = Match(INT64_); + State = 3042; Match(T__29); - State = 3053; - float64(); - State = 3054; + State = 3043; + _localctx.int64Value = int64(); + State = 3044; Match(T__30); - State = 3055; - ddItemCount(); + State = 3045; + _localctx.count = ddItemCount(); + Actions.AddInt64Data(_localctx, _localctx.kind, (_localctx.int64Value!=null?(_localctx.int64Value.Start):null), _localctx.count.Value); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 3057; - Match(INT64_); - State = 3058; - Match(T__29); - State = 3059; - int64(); - State = 3060; - Match(T__30); - State = 3061; - ddItemCount(); - } - break; - case 8: - EnterOuterAlt(_localctx, 8); - { - State = 3063; - Match(INT32_); - State = 3064; - Match(T__29); - State = 3065; - int32(); - State = 3066; - Match(T__30); - State = 3067; - ddItemCount(); + State = 3048; + _localctx.kind = TokenStream.LT(1); + _la = TokenStream.LA(1); + if ( !(((((_la - 184)) & ~0x3f) == 0 && ((1L << (_la - 184)) & 7L) != 0)) ) { + _localctx.kind = ErrorHandler.RecoverInline(this); } - break; - case 9: - EnterOuterAlt(_localctx, 9); - { - State = 3069; - Match(INT16); - State = 3070; - Match(T__29); - State = 3071; - int32(); - State = 3072; - Match(T__30); - State = 3073; - ddItemCount(); + else { + ErrorHandler.ReportMatch(this); + Consume(); } - break; - case 10: - EnterOuterAlt(_localctx, 10); - { - State = 3075; - Match(INT8); - State = 3076; + State = 3049; Match(T__29); - State = 3077; - int32(); - State = 3078; + State = 3050; + _localctx.integerValue = int32(); + State = 3051; Match(T__30); - State = 3079; - ddItemCount(); - } - break; - case 11: - EnterOuterAlt(_localctx, 11); - { - State = 3081; - Match(FLOAT32); - State = 3082; - ddItemCount(); - } - break; - case 12: - EnterOuterAlt(_localctx, 12); - { - State = 3083; - Match(FLOAT64_); - State = 3084; - ddItemCount(); - } - break; - case 13: - EnterOuterAlt(_localctx, 13); - { - State = 3085; - Match(INT64_); - State = 3086; - ddItemCount(); + State = 3052; + _localctx.count = ddItemCount(); + Actions.AddIntegerData(_localctx, _localctx.kind, (_localctx.integerValue!=null?(_localctx.integerValue.Start):null), _localctx.count.Value); } break; - case 14: - EnterOuterAlt(_localctx, 14); + case 8: + EnterOuterAlt(_localctx, 8); { - State = 3087; - Match(INT32_); - State = 3088; - ddItemCount(); + State = 3055; + _localctx.kind = TokenStream.LT(1); + _la = TokenStream.LA(1); + if ( !(((((_la - 184)) & ~0x3f) == 0 && ((1L << (_la - 184)) & 63L) != 0)) ) { + _localctx.kind = ErrorHandler.RecoverInline(this); } - break; - case 15: - EnterOuterAlt(_localctx, 15); - { - State = 3089; - Match(INT16); - State = 3090; - ddItemCount(); + else { + ErrorHandler.ReportMatch(this); + Consume(); } - break; - case 16: - EnterOuterAlt(_localctx, 16); - { - State = 3091; - Match(INT8); - State = 3092; - ddItemCount(); + State = 3056; + _localctx.count = ddItemCount(); + Actions.AddZeroData(_localctx, _localctx.kind, _localctx.count.Value); } break; } @@ -15676,19 +15662,19 @@ public FieldSerInitContext fieldSerInit() { FieldSerInitContext _localctx = new FieldSerInitContext(Context, State); EnterRule(_localctx, 298, RULE_fieldSerInit); try { - State = 3185; + State = 3151; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,149,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,154,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3095; + State = 3061; Match(FLOAT32); - State = 3096; + State = 3062; Match(T__29); - State = 3097; + State = 3063; _localctx.float32Value = float64(); - State = 3098; + State = 3064; Match(T__30); _localctx.Value = Actions.CreateFloat32SerializedInitializer(_localctx.float32Value, _localctx.float32Value.Value); } @@ -15696,13 +15682,13 @@ public FieldSerInitContext fieldSerInit() { case 2: EnterOuterAlt(_localctx, 2); { - State = 3101; + State = 3067; Match(FLOAT64_); - State = 3102; + State = 3068; Match(T__29); - State = 3103; + State = 3069; _localctx.float64Value = float64(); - State = 3104; + State = 3070; Match(T__30); _localctx.Value = Actions.CreateFloat64SerializedInitializer(_localctx.float64Value, _localctx.float64Value.Value); } @@ -15710,13 +15696,13 @@ public FieldSerInitContext fieldSerInit() { case 3: EnterOuterAlt(_localctx, 3); { - State = 3107; + State = 3073; Match(FLOAT32); - State = 3108; + State = 3074; Match(T__29); - State = 3109; + State = 3075; _localctx.float32Bits = int32(); - State = 3110; + State = 3076; Match(T__30); _localctx.Value = Actions.CreateFloat32BitsSerializedInitializer((_localctx.float32Bits!=null?(_localctx.float32Bits.Start):null)); } @@ -15724,13 +15710,13 @@ public FieldSerInitContext fieldSerInit() { case 4: EnterOuterAlt(_localctx, 4); { - State = 3113; + State = 3079; Match(FLOAT64_); - State = 3114; + State = 3080; Match(T__29); - State = 3115; + State = 3081; _localctx.float64Bits = int64(); - State = 3116; + State = 3082; Match(T__30); _localctx.Value = Actions.CreateFloat64BitsSerializedInitializer((_localctx.float64Bits!=null?(_localctx.float64Bits.Start):null)); } @@ -15738,13 +15724,13 @@ public FieldSerInitContext fieldSerInit() { case 5: EnterOuterAlt(_localctx, 5); { - State = 3119; + State = 3085; _localctx.int64Type = Match(INT64_); - State = 3120; + State = 3086; Match(T__29); - State = 3121; + State = 3087; _localctx.int64Value = int64(); - State = 3122; + State = 3088; Match(T__30); _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.int64Type, (_localctx.int64Value!=null?(_localctx.int64Value.Start):null)); } @@ -15752,13 +15738,13 @@ public FieldSerInitContext fieldSerInit() { case 6: EnterOuterAlt(_localctx, 6); { - State = 3125; + State = 3091; _localctx.int32Type = Match(INT32_); - State = 3126; + State = 3092; Match(T__29); - State = 3127; + State = 3093; _localctx.int32Value = int32(); - State = 3128; + State = 3094; Match(T__30); _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.int32Type, (_localctx.int32Value!=null?(_localctx.int32Value.Start):null)); } @@ -15766,13 +15752,13 @@ public FieldSerInitContext fieldSerInit() { case 7: EnterOuterAlt(_localctx, 7); { - State = 3131; + State = 3097; _localctx.int16Type = Match(INT16); - State = 3132; + State = 3098; Match(T__29); - State = 3133; + State = 3099; _localctx.int16Value = int32(); - State = 3134; + State = 3100; Match(T__30); _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.int16Type, (_localctx.int16Value!=null?(_localctx.int16Value.Start):null)); } @@ -15780,13 +15766,13 @@ public FieldSerInitContext fieldSerInit() { case 8: EnterOuterAlt(_localctx, 8); { - State = 3137; + State = 3103; _localctx.int8Type = Match(INT8); - State = 3138; + State = 3104; Match(T__29); - State = 3139; + State = 3105; _localctx.int8Value = int32(); - State = 3140; + State = 3106; Match(T__30); _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.int8Type, (_localctx.int8Value!=null?(_localctx.int8Value.Start):null)); } @@ -15794,13 +15780,13 @@ public FieldSerInitContext fieldSerInit() { case 9: EnterOuterAlt(_localctx, 9); { - State = 3143; + State = 3109; _localctx.uint64Type = Match(UINT64); - State = 3144; + State = 3110; Match(T__29); - State = 3145; + State = 3111; _localctx.uint64Value = int64(); - State = 3146; + State = 3112; Match(T__30); _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.uint64Type, (_localctx.uint64Value!=null?(_localctx.uint64Value.Start):null)); } @@ -15808,13 +15794,13 @@ public FieldSerInitContext fieldSerInit() { case 10: EnterOuterAlt(_localctx, 10); { - State = 3149; + State = 3115; _localctx.uint32Type = Match(UINT32); - State = 3150; + State = 3116; Match(T__29); - State = 3151; + State = 3117; _localctx.uint32Value = int32(); - State = 3152; + State = 3118; Match(T__30); _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.uint32Type, (_localctx.uint32Value!=null?(_localctx.uint32Value.Start):null)); } @@ -15822,13 +15808,13 @@ public FieldSerInitContext fieldSerInit() { case 11: EnterOuterAlt(_localctx, 11); { - State = 3155; + State = 3121; _localctx.uint16Type = Match(UINT16); - State = 3156; + State = 3122; Match(T__29); - State = 3157; + State = 3123; _localctx.uint16Value = int32(); - State = 3158; + State = 3124; Match(T__30); _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.uint16Type, (_localctx.uint16Value!=null?(_localctx.uint16Value.Start):null)); } @@ -15836,13 +15822,13 @@ public FieldSerInitContext fieldSerInit() { case 12: EnterOuterAlt(_localctx, 12); { - State = 3161; + State = 3127; _localctx.uint8Type = Match(UINT8); - State = 3162; + State = 3128; Match(T__29); - State = 3163; + State = 3129; _localctx.uint8Value = int32(); - State = 3164; + State = 3130; Match(T__30); _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.uint8Type, (_localctx.uint8Value!=null?(_localctx.uint8Value.Start):null)); } @@ -15850,13 +15836,13 @@ public FieldSerInitContext fieldSerInit() { case 13: EnterOuterAlt(_localctx, 13); { - State = 3167; + State = 3133; _localctx.charType = Match(CHAR); - State = 3168; + State = 3134; Match(T__29); - State = 3169; + State = 3135; _localctx.charValue = int32(); - State = 3170; + State = 3136; Match(T__30); _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.charType, (_localctx.charValue!=null?(_localctx.charValue.Start):null)); } @@ -15864,13 +15850,13 @@ public FieldSerInitContext fieldSerInit() { case 14: EnterOuterAlt(_localctx, 14); { - State = 3173; + State = 3139; _localctx.boolType = Match(BOOL); - State = 3174; + State = 3140; Match(T__29); - State = 3175; + State = 3141; _localctx.boolValue = truefalse(); - State = 3176; + State = 3142; Match(T__30); _localctx.Value = Actions.CreateBooleanSerializedInitializer(_localctx.boolType, _localctx.boolValue.Value); } @@ -15878,13 +15864,13 @@ public FieldSerInitContext fieldSerInit() { case 15: EnterOuterAlt(_localctx, 15); { - State = 3179; + State = 3145; Match(T__83); - State = 3180; + State = 3146; Match(T__29); - State = 3181; + State = 3147; _localctx.byteArrayValue = bytes(); - State = 3182; + State = 3148; Match(T__30); _localctx.Value = Actions.CreateByteArraySerializedInitializer(_localctx.byteArrayValue.Value); } @@ -15934,18 +15920,18 @@ public BytesContext bytes() { try { EnterOuterAlt(_localctx, 1); { - State = 3192; + State = 3158; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32 || _la==ID || _la==HEXBYTE) { { { - State = 3187; + State = 3153; _localctx.b = hexbyte(); Actions.AddByte(_localctx.b.Value); } } - State = 3194; + State = 3160; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15989,7 +15975,7 @@ public HexbyteContext hexbyte() { try { EnterOuterAlt(_localctx, 1); { - State = 3195; + State = 3161; _la = TokenStream.LA(1); if ( !(_la==INT32 || _la==ID || _la==HEXBYTE) ) { ErrorHandler.RecoverInline(this); @@ -16042,7 +16028,7 @@ public FieldInitContext fieldInit() { FieldInitContext _localctx = new FieldInitContext(Context, State); EnterRule(_localctx, 304, RULE_fieldInit); try { - State = 3205; + State = 3171; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__83: @@ -16060,7 +16046,7 @@ public FieldInitContext fieldInit() { case UINT64: EnterOuterAlt(_localctx, 1); { - State = 3197; + State = 3163; _localctx.serializedValue = fieldSerInit(); _localctx.Value = Actions.CreateFieldInitializer(_localctx.serializedValue.Value); } @@ -16068,7 +16054,7 @@ public FieldInitContext fieldInit() { case QSTRING: EnterOuterAlt(_localctx, 2); { - State = 3200; + State = 3166; _localctx.stringValue = compQstring(); _localctx.Value = Actions.CreateFieldInitializer(_localctx.stringValue.Value); } @@ -16076,7 +16062,7 @@ public FieldInitContext fieldInit() { case NULLREF: EnterOuterAlt(_localctx, 3); { - State = 3203; + State = 3169; Match(NULLREF); _localctx.Value = Actions.CreateNullFieldInitializer(); } @@ -16225,13 +16211,13 @@ public SerInitContext serInit() { SerInitContext _localctx = new SerInitContext(Context, State); EnterRule(_localctx, 306, RULE_serInit); try { - State = 3378; + State = 3344; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,152,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,157,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3207; + State = 3173; _localctx.scalarValue = fieldSerInit(); _localctx.Value = Actions.CreateScalarSerializedValue(_localctx, _localctx.scalarValue, _localctx.scalarValue.Value); } @@ -16239,13 +16225,13 @@ public SerInitContext serInit() { case 2: EnterOuterAlt(_localctx, 2); { - State = 3210; + State = 3176; Match(STRING); - State = 3211; + State = 3177; Match(T__29); - State = 3212; + State = 3178; Match(NULLREF); - State = 3213; + State = 3179; Match(T__30); _localctx.Value = Actions.CreateStringSerializedValue(); } @@ -16253,13 +16239,13 @@ public SerInitContext serInit() { case 3: EnterOuterAlt(_localctx, 3); { - State = 3215; + State = 3181; Match(STRING); - State = 3216; + State = 3182; Match(T__29); - State = 3217; + State = 3183; _localctx.stringToken = Match(SQSTRING); - State = 3218; + State = 3184; Match(T__30); _localctx.Value = Actions.CreateStringSerializedValue(_localctx.stringToken); } @@ -16267,15 +16253,15 @@ public SerInitContext serInit() { case 4: EnterOuterAlt(_localctx, 4); { - State = 3220; + State = 3186; Match(TYPE); - State = 3221; + State = 3187; Match(T__29); - State = 3222; + State = 3188; Match(T__38); - State = 3223; + State = 3189; _localctx.typeToken = Match(SQSTRING); - State = 3224; + State = 3190; Match(T__30); _localctx.Value = Actions.CreateTypeSerializedValue(_localctx.typeToken); } @@ -16283,13 +16269,13 @@ public SerInitContext serInit() { case 5: EnterOuterAlt(_localctx, 5); { - State = 3226; + State = 3192; Match(TYPE); - State = 3227; + State = 3193; Match(T__29); - State = 3228; + State = 3194; _localctx.typeName = className(); - State = 3229; + State = 3195; Match(T__30); _localctx.Value = Actions.CreateTypeSerializedValue(_localctx.typeName.Value); } @@ -16297,13 +16283,13 @@ public SerInitContext serInit() { case 6: EnterOuterAlt(_localctx, 6); { - State = 3232; + State = 3198; Match(TYPE); - State = 3233; + State = 3199; Match(T__29); - State = 3234; + State = 3200; Match(NULLREF); - State = 3235; + State = 3201; Match(T__30); _localctx.Value = Actions.CreateNullTypeSerializedValue(); } @@ -16311,13 +16297,13 @@ public SerInitContext serInit() { case 7: EnterOuterAlt(_localctx, 7); { - State = 3237; + State = 3203; Match(OBJECT); - State = 3238; + State = 3204; Match(T__29); - State = 3239; + State = 3205; _localctx.objectValue = serInit(); - State = 3240; + State = 3206; Match(T__30); _localctx.Value = Actions.CreateObjectSerializedValue(_localctx.objectValue.Value); } @@ -16325,19 +16311,19 @@ public SerInitContext serInit() { case 8: EnterOuterAlt(_localctx, 8); { - State = 3243; + State = 3209; _localctx.f32ElementToken = Match(FLOAT32); - State = 3244; + State = 3210; Match(T__41); - State = 3245; + State = 3211; _localctx.f32Length = int32(); - State = 3246; + State = 3212; Match(T__42); - State = 3247; + State = 3213; Match(T__29); - State = 3248; + State = 3214; _localctx.f32Values = f32seq(); - State = 3249; + State = 3215; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.f32ElementToken, (_localctx.f32Length!=null?(_localctx.f32Length.Start):null), _localctx.f32Values.Value); } @@ -16345,19 +16331,19 @@ public SerInitContext serInit() { case 9: EnterOuterAlt(_localctx, 9); { - State = 3252; + State = 3218; _localctx.f64ElementToken = Match(FLOAT64_); - State = 3253; + State = 3219; Match(T__41); - State = 3254; + State = 3220; _localctx.f64Length = int32(); - State = 3255; + State = 3221; Match(T__42); - State = 3256; + State = 3222; Match(T__29); - State = 3257; + State = 3223; _localctx.f64Values = f64seq(); - State = 3258; + State = 3224; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.f64ElementToken, (_localctx.f64Length!=null?(_localctx.f64Length.Start):null), _localctx.f64Values.Value); } @@ -16365,19 +16351,19 @@ public SerInitContext serInit() { case 10: EnterOuterAlt(_localctx, 10); { - State = 3261; + State = 3227; _localctx.i64ElementToken = Match(INT64_); - State = 3262; + State = 3228; Match(T__41); - State = 3263; + State = 3229; _localctx.i64Length = int32(); - State = 3264; + State = 3230; Match(T__42); - State = 3265; + State = 3231; Match(T__29); - State = 3266; + State = 3232; _localctx.i64Values = i64seq(); - State = 3267; + State = 3233; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.i64ElementToken, (_localctx.i64Length!=null?(_localctx.i64Length.Start):null), _localctx.i64Values.Value); } @@ -16385,19 +16371,19 @@ public SerInitContext serInit() { case 11: EnterOuterAlt(_localctx, 11); { - State = 3270; + State = 3236; _localctx.i32ElementToken = Match(INT32_); - State = 3271; + State = 3237; Match(T__41); - State = 3272; + State = 3238; _localctx.i32Length = int32(); - State = 3273; + State = 3239; Match(T__42); - State = 3274; + State = 3240; Match(T__29); - State = 3275; + State = 3241; _localctx.i32Values = i32seq(); - State = 3276; + State = 3242; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.i32ElementToken, (_localctx.i32Length!=null?(_localctx.i32Length.Start):null), _localctx.i32Values.Value); } @@ -16405,19 +16391,19 @@ public SerInitContext serInit() { case 12: EnterOuterAlt(_localctx, 12); { - State = 3279; + State = 3245; _localctx.i16ElementToken = Match(INT16); - State = 3280; + State = 3246; Match(T__41); - State = 3281; + State = 3247; _localctx.i16Length = int32(); - State = 3282; + State = 3248; Match(T__42); - State = 3283; + State = 3249; Match(T__29); - State = 3284; + State = 3250; _localctx.i16Values = i16seq(); - State = 3285; + State = 3251; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.i16ElementToken, (_localctx.i16Length!=null?(_localctx.i16Length.Start):null), _localctx.i16Values.Value); } @@ -16425,19 +16411,19 @@ public SerInitContext serInit() { case 13: EnterOuterAlt(_localctx, 13); { - State = 3288; + State = 3254; _localctx.i8ElementToken = Match(INT8); - State = 3289; + State = 3255; Match(T__41); - State = 3290; + State = 3256; _localctx.i8Length = int32(); - State = 3291; + State = 3257; Match(T__42); - State = 3292; + State = 3258; Match(T__29); - State = 3293; + State = 3259; _localctx.i8Values = i8seq(); - State = 3294; + State = 3260; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.i8ElementToken, (_localctx.i8Length!=null?(_localctx.i8Length.Start):null), _localctx.i8Values.Value); } @@ -16445,19 +16431,19 @@ public SerInitContext serInit() { case 14: EnterOuterAlt(_localctx, 14); { - State = 3297; + State = 3263; _localctx.u64ElementToken = Match(UINT64); - State = 3298; + State = 3264; Match(T__41); - State = 3299; + State = 3265; _localctx.u64Length = int32(); - State = 3300; + State = 3266; Match(T__42); - State = 3301; + State = 3267; Match(T__29); - State = 3302; + State = 3268; _localctx.u64Values = i64seq(); - State = 3303; + State = 3269; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.u64ElementToken, (_localctx.u64Length!=null?(_localctx.u64Length.Start):null), _localctx.u64Values.Value); } @@ -16465,19 +16451,19 @@ public SerInitContext serInit() { case 15: EnterOuterAlt(_localctx, 15); { - State = 3306; + State = 3272; _localctx.u32ElementToken = Match(UINT32); - State = 3307; + State = 3273; Match(T__41); - State = 3308; + State = 3274; _localctx.u32Length = int32(); - State = 3309; + State = 3275; Match(T__42); - State = 3310; + State = 3276; Match(T__29); - State = 3311; + State = 3277; _localctx.u32Values = i32seq(); - State = 3312; + State = 3278; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.u32ElementToken, (_localctx.u32Length!=null?(_localctx.u32Length.Start):null), _localctx.u32Values.Value); } @@ -16485,19 +16471,19 @@ public SerInitContext serInit() { case 16: EnterOuterAlt(_localctx, 16); { - State = 3315; + State = 3281; _localctx.u16ElementToken = Match(UINT16); - State = 3316; + State = 3282; Match(T__41); - State = 3317; + State = 3283; _localctx.u16Length = int32(); - State = 3318; + State = 3284; Match(T__42); - State = 3319; + State = 3285; Match(T__29); - State = 3320; + State = 3286; _localctx.u16Values = i16seq(); - State = 3321; + State = 3287; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.u16ElementToken, (_localctx.u16Length!=null?(_localctx.u16Length.Start):null), _localctx.u16Values.Value); } @@ -16505,19 +16491,19 @@ public SerInitContext serInit() { case 17: EnterOuterAlt(_localctx, 17); { - State = 3324; + State = 3290; _localctx.u8ElementToken = Match(UINT8); - State = 3325; + State = 3291; Match(T__41); - State = 3326; + State = 3292; _localctx.u8Length = int32(); - State = 3327; + State = 3293; Match(T__42); - State = 3328; + State = 3294; Match(T__29); - State = 3329; + State = 3295; _localctx.u8Values = i8seq(); - State = 3330; + State = 3296; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.u8ElementToken, (_localctx.u8Length!=null?(_localctx.u8Length.Start):null), _localctx.u8Values.Value); } @@ -16525,19 +16511,19 @@ public SerInitContext serInit() { case 18: EnterOuterAlt(_localctx, 18); { - State = 3333; + State = 3299; _localctx.charElementToken = Match(CHAR); - State = 3334; + State = 3300; Match(T__41); - State = 3335; + State = 3301; _localctx.charLength = int32(); - State = 3336; + State = 3302; Match(T__42); - State = 3337; + State = 3303; Match(T__29); - State = 3338; + State = 3304; _localctx.charValues = i16seq(); - State = 3339; + State = 3305; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.charElementToken, (_localctx.charLength!=null?(_localctx.charLength.Start):null), _localctx.charValues.Value); } @@ -16545,19 +16531,19 @@ public SerInitContext serInit() { case 19: EnterOuterAlt(_localctx, 19); { - State = 3342; + State = 3308; _localctx.boolElementToken = Match(BOOL); - State = 3343; + State = 3309; Match(T__41); - State = 3344; + State = 3310; _localctx.boolLength = int32(); - State = 3345; + State = 3311; Match(T__42); - State = 3346; + State = 3312; Match(T__29); - State = 3347; + State = 3313; _localctx.boolValues = boolSeq(); - State = 3348; + State = 3314; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.boolElementToken, (_localctx.boolLength!=null?(_localctx.boolLength.Start):null), _localctx.boolValues.Value); } @@ -16565,19 +16551,19 @@ public SerInitContext serInit() { case 20: EnterOuterAlt(_localctx, 20); { - State = 3351; + State = 3317; _localctx.stringElementToken = Match(STRING); - State = 3352; + State = 3318; Match(T__41); - State = 3353; + State = 3319; _localctx.stringLength = int32(); - State = 3354; + State = 3320; Match(T__42); - State = 3355; + State = 3321; Match(T__29); - State = 3356; + State = 3322; _localctx.stringValues = sqstringSeq(); - State = 3357; + State = 3323; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.stringElementToken, (_localctx.stringLength!=null?(_localctx.stringLength.Start):null), _localctx.stringValues.Value); } @@ -16585,19 +16571,19 @@ public SerInitContext serInit() { case 21: EnterOuterAlt(_localctx, 21); { - State = 3360; + State = 3326; _localctx.typeElementToken = Match(TYPE); - State = 3361; + State = 3327; Match(T__41); - State = 3362; + State = 3328; _localctx.typeLength = int32(); - State = 3363; + State = 3329; Match(T__42); - State = 3364; + State = 3330; Match(T__29); - State = 3365; + State = 3331; _localctx.typeValues = classSeq(); - State = 3366; + State = 3332; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.typeElementToken, (_localctx.typeLength!=null?(_localctx.typeLength.Start):null), _localctx.typeValues.Value); } @@ -16605,19 +16591,19 @@ public SerInitContext serInit() { case 22: EnterOuterAlt(_localctx, 22); { - State = 3369; + State = 3335; _localctx.objectElementToken = Match(OBJECT); - State = 3370; + State = 3336; Match(T__41); - State = 3371; + State = 3337; _localctx.objectLength = int32(); - State = 3372; + State = 3338; Match(T__42); - State = 3373; + State = 3339; Match(T__29); - State = 3374; + State = 3340; _localctx.objectValues = objSeq(); - State = 3375; + State = 3341; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.objectElementToken, (_localctx.objectLength!=null?(_localctx.objectLength.Start):null), _localctx.objectValues.Value); } @@ -16673,31 +16659,31 @@ public F32seqContext f32seq() { try { EnterOuterAlt(_localctx, 1); { - State = 3388; + State = 3354; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 98309L) != 0)) { { - State = 3386; + State = 3352; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,153,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,158,Context) ) { case 1: { - State = 3380; + State = 3346; _localctx.floatingValue = float64(); Actions.AddFloat32SequenceValue(_localctx, _localctx.floatingValue.Value); } break; case 2: { - State = 3383; + State = 3349; _localctx.integerValue = int32(); Actions.AddFloat32SequenceValue(_localctx, (_localctx.integerValue!=null?(_localctx.integerValue.Start):null)); } break; } } - State = 3390; + State = 3356; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16753,31 +16739,31 @@ public F64seqContext f64seq() { try { EnterOuterAlt(_localctx, 1); { - State = 3399; + State = 3365; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 98311L) != 0)) { { - State = 3397; + State = 3363; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,155,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,160,Context) ) { case 1: { - State = 3391; + State = 3357; _localctx.floatingValue = float64(); Actions.AddFloat64SequenceValue(_localctx, _localctx.floatingValue.Value); } break; case 2: { - State = 3394; + State = 3360; _localctx.integerValue = int64(); Actions.AddFloat64SequenceValue(_localctx, (_localctx.integerValue!=null?(_localctx.integerValue.Start):null)); } break; } } - State = 3401; + State = 3367; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16826,18 +16812,18 @@ public I64seqContext i64seq() { try { EnterOuterAlt(_localctx, 1); { - State = 3407; + State = 3373; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32 || _la==INT64) { { { - State = 3402; + State = 3368; _localctx.value = int64(); Actions.AddInt64SequenceValue(_localctx, (_localctx.value!=null?(_localctx.value.Start):null)); } } - State = 3409; + State = 3375; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16886,18 +16872,18 @@ public I32seqContext i32seq() { try { EnterOuterAlt(_localctx, 1); { - State = 3415; + State = 3381; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 3410; + State = 3376; _localctx.value = int32(); Actions.AddInt32SequenceValue(_localctx, (_localctx.value!=null?(_localctx.value.Start):null)); } } - State = 3417; + State = 3383; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16946,18 +16932,18 @@ public I16seqContext i16seq() { try { EnterOuterAlt(_localctx, 1); { - State = 3423; + State = 3389; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 3418; + State = 3384; _localctx.value = int32(); Actions.AddInt16SequenceValue(_localctx, (_localctx.value!=null?(_localctx.value.Start):null)); } } - State = 3425; + State = 3391; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17006,18 +16992,18 @@ public I8seqContext i8seq() { try { EnterOuterAlt(_localctx, 1); { - State = 3431; + State = 3397; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 3426; + State = 3392; _localctx.value = int32(); Actions.AddInt8SequenceValue(_localctx, (_localctx.value!=null?(_localctx.value.Start):null)); } } - State = 3433; + State = 3399; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17066,18 +17052,18 @@ public BoolSeqContext boolSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 3439; + State = 3405; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__94 || _la==T__95) { { { - State = 3434; + State = 3400; _localctx.value = truefalse(); Actions.AddBooleanSequenceValue(_localctx, _localctx.value.Value); } } - State = 3441; + State = 3407; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17129,24 +17115,24 @@ public SqstringSeqContext sqstringSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 3448; + State = 3414; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==NULLREF || _la==SQSTRING) { { - State = 3446; + State = 3412; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case NULLREF: { - State = 3442; + State = 3408; _localctx.nullValue = Match(NULLREF); Actions.AddStringSequenceValue(_localctx, _localctx.nullValue); } break; case SQSTRING: { - State = 3444; + State = 3410; _localctx.stringValue = Match(SQSTRING); Actions.AddStringSequenceValue(_localctx, _localctx.stringValue); } @@ -17155,7 +17141,7 @@ public SqstringSeqContext sqstringSeq() { throw new NoViableAltException(this); } } - State = 3450; + State = 3416; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17204,18 +17190,18 @@ public ClassSeqContext classSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 3456; + State = 3422; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4947802390528L) != 0) || _la==T__112 || _la==NULLREF || _la==VALUE || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 105553118478337L) != 0)) { { { - State = 3451; + State = 3417; _localctx.value = classSeqElement(); Actions.AddClassSequenceValue(_localctx, _localctx.value.Value); } } - State = 3458; + State = 3424; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17260,13 +17246,13 @@ public ClassSeqElementContext classSeqElement() { ClassSeqElementContext _localctx = new ClassSeqElementContext(Context, State); EnterRule(_localctx, 326, RULE_classSeqElement); try { - State = 3467; + State = 3433; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case NULLREF: EnterOuterAlt(_localctx, 1); { - State = 3459; + State = 3425; Match(NULLREF); _localctx.Value = Actions.CreateNullClassSequenceValue(); } @@ -17274,9 +17260,9 @@ public ClassSeqElementContext classSeqElement() { case T__38: EnterOuterAlt(_localctx, 2); { - State = 3461; + State = 3427; Match(T__38); - State = 3462; + State = 3428; _localctx.quotedValue = Match(SQSTRING); _localctx.Value = Actions.CreateQuotedClassSequenceValue(_localctx.quotedValue); } @@ -17294,7 +17280,7 @@ public ClassSeqElementContext classSeqElement() { case ID: EnterOuterAlt(_localctx, 3); { - State = 3464; + State = 3430; _localctx.typeValue = className(); _localctx.Value = Actions.CreateClassSequenceValue(_localctx.typeValue.Value); } @@ -17345,18 +17331,18 @@ public ObjSeqContext objSeq() { try { EnterOuterAlt(_localctx, 1); { - State = 3474; + State = 3440; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__83 || ((((_la - 181)) & ~0x3f) == 0 && ((1L << (_la - 181)) & 106495L) != 0)) { { { - State = 3469; + State = 3435; _localctx.value = serInit(); Actions.AddObjectSequenceValue(_localctx, _localctx.value.Value); } } - State = 3476; + State = 3442; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17408,13 +17394,13 @@ public CustomAttrDeclContext customAttrDecl() { EnterRule(_localctx, 330, RULE_customAttrDecl); Actions.BeginSemanticRoot(_localctx); try { - State = 3486; + State = 3452; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,167,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,172,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3477; + State = 3443; _localctx.directAttribute = customDescr(); _localctx.Value = Actions.CreateCustomAttributeDeclaration(_localctx.directAttribute.Value); } @@ -17422,7 +17408,7 @@ public CustomAttrDeclContext customAttrDecl() { case 2: EnterOuterAlt(_localctx, 2); { - State = 3480; + State = 3446; _localctx.ownedAttribute = customDescrWithOwner(); _localctx.Value = Actions.CreateCustomAttributeDeclaration(_localctx.ownedAttribute.Value); } @@ -17430,7 +17416,7 @@ public CustomAttrDeclContext customAttrDecl() { case 3: EnterOuterAlt(_localctx, 3); { - State = 3483; + State = 3449; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateCustomAttributeTypedef(_localctx.alias.Value); } @@ -17487,13 +17473,13 @@ public AsmOrRefDeclContext asmOrRefDecl() { EnterRule(_localctx, 332, RULE_asmOrRefDecl); int _la; try { - State = 3513; + State = 3479; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,168,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,173,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3488; + State = 3454; _la = TokenStream.LA(1); if ( !(_la==T__166 || _la==T__167) ) { ErrorHandler.RecoverInline(this); @@ -17502,72 +17488,72 @@ public AsmOrRefDeclContext asmOrRefDecl() { ErrorHandler.ReportMatch(this); Consume(); } - State = 3489; + State = 3455; Match(T__35); - State = 3490; + State = 3456; Match(T__29); - State = 3491; + State = 3457; bytes(); - State = 3492; + State = 3458; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3494; + State = 3460; Match(T__168); - State = 3495; + State = 3461; intOrWildcard(); - State = 3496; + State = 3462; Match(T__74); - State = 3497; + State = 3463; intOrWildcard(); - State = 3498; + State = 3464; Match(T__74); - State = 3499; + State = 3465; intOrWildcard(); - State = 3500; + State = 3466; Match(T__74); - State = 3501; + State = 3467; intOrWildcard(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3503; + State = 3469; Match(T__169); - State = 3504; + State = 3470; compQstring(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 3505; + State = 3471; Match(T__169); - State = 3506; + State = 3472; Match(T__35); - State = 3507; + State = 3473; Match(T__29); - State = 3508; + State = 3474; bytes(); - State = 3509; + State = 3475; Match(T__30); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 3511; + State = 3477; customAttrDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 3512; + State = 3478; compControl(); } break; @@ -17613,13 +17599,13 @@ public AssemblyRefBlockContext assemblyRefBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 3515; + State = 3481; assemblyRefHead(); - State = 3516; + State = 3482; Match(T__16); - State = 3517; + State = 3483; assemblyRefDecls(); - State = 3518; + State = 3484; Match(T__17); } } @@ -17663,36 +17649,36 @@ public AssemblyRefHeadContext assemblyRefHead() { AssemblyRefHeadContext _localctx = new AssemblyRefHeadContext(Context, State); EnterRule(_localctx, 336, RULE_assemblyRefHead); try { - State = 3532; + State = 3498; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,169,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,174,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3520; + State = 3486; Match(T__24); - State = 3521; + State = 3487; Match(T__39); - State = 3522; + State = 3488; asmAttr(); - State = 3523; + State = 3489; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3525; + State = 3491; Match(T__24); - State = 3526; + State = 3492; Match(T__39); - State = 3527; + State = 3493; asmAttr(); - State = 3528; + State = 3494; dottedName(); - State = 3529; + State = 3495; Match(T__33); - State = 3530; + State = 3496; dottedName(); } break; @@ -17737,17 +17723,17 @@ public AssemblyRefDeclsContext assemblyRefDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 3537; + State = 3503; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 36028835673735168L) != 0) || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & 4294975519L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 105555249070081L) != 0)) { { { - State = 3534; + State = 3500; assemblyRefDecl(); } } - State = 3539; + State = 3505; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17790,21 +17776,21 @@ public AssemblyRefDeclContext assemblyRefDecl() { AssemblyRefDeclContext _localctx = new AssemblyRefDeclContext(Context, State); EnterRule(_localctx, 340, RULE_assemblyRefDecl); try { - State = 3554; + State = 3520; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case HASH: EnterOuterAlt(_localctx, 1); { - State = 3540; + State = 3506; Match(HASH); - State = 3541; + State = 3507; Match(T__35); - State = 3542; + State = 3508; Match(T__29); - State = 3543; + State = 3509; bytes(); - State = 3544; + State = 3510; Match(T__30); } break; @@ -17829,29 +17815,29 @@ public AssemblyRefDeclContext assemblyRefDecl() { case ID: EnterOuterAlt(_localctx, 2); { - State = 3546; + State = 3512; asmOrRefDecl(); } break; case T__170: EnterOuterAlt(_localctx, 3); { - State = 3547; + State = 3513; Match(T__170); - State = 3548; + State = 3514; Match(T__35); - State = 3549; + State = 3515; Match(T__29); - State = 3550; + State = 3516; bytes(); - State = 3551; + State = 3517; Match(T__30); } break; case T__54: EnterOuterAlt(_localctx, 4); { - State = 3553; + State = 3519; Match(T__54); } break; @@ -17899,13 +17885,13 @@ public ExptypeBlockContext exptypeBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 3556; + State = 3522; exptypeHead(); - State = 3557; + State = 3523; Match(T__16); - State = 3558; + State = 3524; exptypeDecls(); - State = 3559; + State = 3525; Match(T__17); } } @@ -17952,25 +17938,25 @@ public ExptypeHeadContext exptypeHead() { try { EnterOuterAlt(_localctx, 1); { - State = 3561; + State = 3527; Match(T__49); - State = 3562; + State = 3528; Match(T__39); - State = 3566; + State = 3532; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4618441417868443648L) != 0) || _la==T__171) { { { - State = 3563; + State = 3529; exptAttr(); } } - State = 3568; + State = 3534; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 3569; + State = 3535; dottedName(); } } @@ -18017,23 +18003,23 @@ public ExportHeadContext exportHead() { try { EnterOuterAlt(_localctx, 1); { - State = 3571; + State = 3537; Match(EXPORT); - State = 3575; + State = 3541; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4618441417868443648L) != 0) || _la==T__171) { { { - State = 3572; + State = 3538; exptAttr(); } } - State = 3577; + State = 3543; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 3578; + State = 3544; dottedName(); } } @@ -18067,81 +18053,81 @@ public ExptAttrContext exptAttr() { ExptAttrContext _localctx = new ExptAttrContext(Context, State); EnterRule(_localctx, 348, RULE_exptAttr); try { - State = 3595; + State = 3561; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,174,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,179,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3580; + State = 3546; Match(T__51); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3581; + State = 3547; Match(T__50); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3582; + State = 3548; Match(T__171); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 3583; + State = 3549; Match(T__61); - State = 3584; + State = 3550; Match(T__50); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 3585; + State = 3551; Match(T__61); - State = 3586; + State = 3552; Match(T__51); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 3587; + State = 3553; Match(T__61); - State = 3588; + State = 3554; Match(T__62); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 3589; + State = 3555; Match(T__61); - State = 3590; + State = 3556; Match(T__63); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 3591; + State = 3557; Match(T__61); - State = 3592; + State = 3558; Match(T__64); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 3593; + State = 3559; Match(T__61); - State = 3594; + State = 3560; Match(T__65); } break; @@ -18186,17 +18172,17 @@ public ExptypeDeclsContext exptypeDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 3600; + State = 3566; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1125938597265408L) != 0) || _la==T__112 || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 3597; + State = 3563; exptypeDecl(); } } - State = 3602; + State = 3568; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -18250,67 +18236,67 @@ public ExptypeDeclContext exptypeDecl() { ExptypeDeclContext _localctx = new ExptypeDeclContext(Context, State); EnterRule(_localctx, 352, RULE_exptypeDecl); try { - State = 3616; + State = 3582; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,176,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,181,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3603; + State = 3569; Match(T__20); - State = 3604; + State = 3570; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3605; + State = 3571; Match(T__49); - State = 3606; + State = 3572; Match(T__39); - State = 3607; + State = 3573; slashedName(); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3608; + State = 3574; Match(T__24); - State = 3609; + State = 3575; Match(T__39); - State = 3610; + State = 3576; dottedName(); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 3611; + State = 3577; mdtoken(); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 3612; + State = 3578; Match(T__49); - State = 3613; + State = 3579; int32(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 3614; + State = 3580; customAttrDecl(); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 3615; + State = 3581; compControl(); } break; @@ -18356,13 +18342,13 @@ public ManifestResBlockContext manifestResBlock() { try { EnterOuterAlt(_localctx, 1); { - State = 3618; + State = 3584; manifestResHead(); - State = 3619; + State = 3585; Match(T__16); - State = 3620; + State = 3586; manifestResDecls(); - State = 3621; + State = 3587; Match(T__17); } } @@ -18411,56 +18397,56 @@ public ManifestResHeadContext manifestResHead() { EnterRule(_localctx, 356, RULE_manifestResHead); int _la; try { - State = 3642; + State = 3608; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,179,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,184,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3623; + State = 3589; Match(MRESOURCE); - State = 3627; + State = 3593; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__50 || _la==T__51) { { { - State = 3624; + State = 3590; manresAttr(); } } - State = 3629; + State = 3595; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 3630; + State = 3596; dottedName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3631; + State = 3597; Match(MRESOURCE); - State = 3635; + State = 3601; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__50 || _la==T__51) { { { - State = 3632; + State = 3598; manresAttr(); } } - State = 3637; + State = 3603; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 3638; + State = 3604; dottedName(); - State = 3639; + State = 3605; Match(T__33); - State = 3640; + State = 3606; dottedName(); } break; @@ -18499,7 +18485,7 @@ public ManresAttrContext manresAttr() { try { EnterOuterAlt(_localctx, 1); { - State = 3644; + State = 3610; _la = TokenStream.LA(1); if ( !(_la==T__50 || _la==T__51) ) { ErrorHandler.RecoverInline(this); @@ -18549,17 +18535,17 @@ public ManifestResDeclsContext manifestResDecls() { try { EnterOuterAlt(_localctx, 1); { - State = 3649; + State = 3615; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38690422784L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 3646; + State = 3612; manifestResDecl(); } } - State = 3651; + State = 3617; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -18607,30 +18593,30 @@ public ManifestResDeclContext manifestResDecl() { ManifestResDeclContext _localctx = new ManifestResDeclContext(Context, State); EnterRule(_localctx, 362, RULE_manifestResDecl); try { - State = 3662; + State = 3628; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__20: EnterOuterAlt(_localctx, 1); { - State = 3652; + State = 3618; Match(T__20); - State = 3653; + State = 3619; dottedName(); - State = 3654; + State = 3620; Match(T__43); - State = 3655; + State = 3621; int32(); } break; case T__24: EnterOuterAlt(_localctx, 2); { - State = 3657; + State = 3623; Match(T__24); - State = 3658; + State = 3624; Match(T__39); - State = 3659; + State = 3625; dottedName(); } break; @@ -18643,7 +18629,7 @@ public ManifestResDeclContext manifestResDecl() { case ID: EnterOuterAlt(_localctx, 3); { - State = 3660; + State = 3626; customAttrDecl(); } break; @@ -18657,7 +18643,7 @@ public ManifestResDeclContext manifestResDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 4); { - State = 3661; + State = 3627; compControl(); } break; @@ -18694,7 +18680,7 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { } private static int[] _serializedATN = { - 4,1,305,3665,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, + 4,1,305,3631,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, @@ -18732,72 +18718,69 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,490,8,5,1,6,1,6,1,6,1,6,1,7,1,7, 1,7,1,7,1,8,1,8,1,8,1,8,1,8,1,9,1,9,1,9,1,9,1,10,1,10,1,10,1,10,1,11,1, 11,1,11,1,11,1,11,1,11,1,11,1,12,1,12,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,536,8,13,1,14,1,14,1,15,1,15, - 1,15,1,15,1,15,5,15,545,8,15,10,15,12,15,548,9,15,1,15,1,15,1,16,1,16, - 1,17,1,17,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18, - 1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,3,18,577,8,18,1,19,1,19,3, - 19,581,8,19,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20, - 1,20,1,20,1,20,1,20,3,20,599,8,20,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1, - 21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1, - 21,1,21,1,21,1,21,3,21,626,8,21,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22, - 1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22, - 1,22,1,22,1,22,1,22,3,22,654,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,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,694,8,23,1,24,1,24,1,24,1,25,1,25,1,25,1,25,1,25,1,25, - 3,25,705,8,25,1,26,1,26,1,26,1,26,1,27,1,27,1,27,1,27,5,27,715,8,27,10, - 27,12,27,718,9,27,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,5,28,728,8,28, - 10,28,12,28,731,9,28,1,29,1,29,1,29,1,30,1,30,3,30,738,8,30,1,30,1,30, - 1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31, - 1,31,1,31,1,31,1,31,3,31,760,8,31,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1, - 32,1,32,1,32,1,32,3,32,773,8,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,34,1,34,1,34,1,34,5,34,794,8,34,10, - 34,12,34,797,9,34,1,35,1,35,1,35,1,35,1,35,1,35,1,36,1,36,1,36,1,36,1, - 37,1,37,1,37,1,37,5,37,813,8,37,10,37,12,37,816,9,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,38,1,38,1,38,1,38,1, - 38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1, - 38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1, - 38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1, - 38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,3,38,888,8,38,1,39, - 1,39,1,39,1,39,1,39,3,39,895,8,39,1,40,1,40,1,40,1,40,1,40,3,40,902,8, - 40,1,41,5,41,905,8,41,10,41,12,41,908,9,41,1,42,1,42,1,42,1,42,5,42,914, - 8,42,10,42,12,42,917,9,42,1,42,1,42,1,42,1,43,1,43,1,44,1,44,1,44,1,44, - 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, - 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, - 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, - 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, - 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, - 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, - 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, - 1,44,3,44,1027,8,44,1,45,1,45,5,45,1031,8,45,10,45,12,45,1034,9,45,1,45, - 1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,5,45,1047,8,45,10,45, - 12,45,1050,9,45,1,45,1,45,1,45,3,45,1055,8,45,1,46,1,46,1,47,1,47,3,47, - 1061,8,47,1,48,1,48,1,49,5,49,1066,8,49,10,49,12,49,1069,9,49,1,50,1,50, + 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,540,8,13, + 1,14,1,14,1,15,1,15,1,15,1,15,1,15,5,15,549,8,15,10,15,12,15,552,9,15, + 1,15,1,15,1,16,1,16,1,17,1,17,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18, + 1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,3,18, + 581,8,18,1,19,1,19,3,19,585,8,19,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1, + 20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,3,20,603,8,20,1,21,1,21,1,21, + 1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21, + 1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,3,21,630,8,21,1,22,1,22,1,22,1, + 22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1, + 22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,3,22,658,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,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,698,8,23,1,24,1,24,1,24,1,25,1, + 25,1,25,1,25,1,25,1,25,3,25,709,8,25,1,26,1,26,1,26,1,26,1,27,1,27,1,27, + 1,27,5,27,719,8,27,10,27,12,27,722,9,27,1,28,1,28,1,28,1,28,1,28,1,28, + 1,28,1,28,5,28,732,8,28,10,28,12,28,735,9,28,1,29,1,29,1,29,1,30,1,30, + 3,30,742,8,30,1,30,1,30,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1, + 31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,3,31,764,8,31,1,32,1,32,1,32, + 1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,3,32,777,8,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,34,1,34,1, + 34,1,34,5,34,798,8,34,10,34,12,34,801,9,34,1,35,1,35,1,35,1,35,1,35,1, + 35,1,36,1,36,1,36,1,36,1,37,1,37,1,37,1,37,5,37,817,8,37,10,37,12,37,820, + 9,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,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38, + 1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38, + 1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38, + 1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38, + 1,38,3,38,892,8,38,1,39,1,39,1,39,1,39,1,39,3,39,899,8,39,1,40,1,40,1, + 40,1,40,1,40,3,40,906,8,40,1,41,5,41,909,8,41,10,41,12,41,912,9,41,1,42, + 1,42,1,42,1,42,5,42,918,8,42,10,42,12,42,921,9,42,1,42,1,42,1,42,1,43, + 1,43,1,44,1,44,1,44,3,44,931,8,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,3, + 44,940,8,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,3,44,951,8,44, + 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,3,44,962,8,44,1,44,1,44,1, + 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,3,44,975,8,44,1,44,1,44,3,44, + 979,8,44,1,45,1,45,5,45,983,8,45,10,45,12,45,986,9,45,1,45,1,45,1,45,1, + 45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,5,45,999,8,45,10,45,12,45,1002,9, + 45,1,45,1,45,1,45,3,45,1007,8,45,1,46,1,46,1,47,1,47,3,47,1013,8,47,1, + 48,1,48,1,49,5,49,1018,8,49,10,49,12,49,1021,9,49,1,50,1,50,1,50,1,50, 1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50, - 1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,3,50,1096,8,50,1,51,1,51, + 1,50,1,50,1,50,1,50,1,50,1,50,1,50,3,50,1048,8,50,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,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, 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,1174,8,51,3,51,1176,8,51,1,52,1,52,1,52,1,52, - 1,52,1,53,1,53,1,53,1,53,1,53,1,53,1,53,3,53,1190,8,53,1,53,1,53,5,53, - 1194,8,53,10,53,12,53,1197,9,53,1,53,1,53,1,53,1,53,1,53,1,53,3,53,1205, - 8,53,3,53,1207,8,53,1,54,1,54,1,54,1,54,1,54,5,54,1214,8,54,10,54,12,54, - 1217,9,54,1,54,1,54,1,54,1,54,1,55,1,55,1,55,1,55,1,55,5,55,1228,8,55, - 10,55,12,55,1231,9,55,1,55,1,55,1,55,1,55,1,56,1,56,1,56,1,56,1,56,5,56, - 1242,8,56,10,56,12,56,1245,9,56,1,56,1,56,1,56,1,56,1,56,3,56,1252,8,56, - 1,57,1,57,1,57,1,57,1,57,1,57,3,57,1260,8,57,1,57,1,57,3,57,1264,8,57, + 1,51,1,51,3,51,1126,8,51,3,51,1128,8,51,1,52,1,52,1,52,1,52,1,52,1,53, + 1,53,1,53,1,53,1,53,1,53,1,53,3,53,1142,8,53,1,53,1,53,5,53,1146,8,53, + 10,53,12,53,1149,9,53,1,53,1,53,1,53,1,53,1,53,1,53,3,53,1157,8,53,3,53, + 1159,8,53,1,54,1,54,1,54,1,54,1,54,5,54,1166,8,54,10,54,12,54,1169,9,54, + 1,54,1,54,1,54,1,54,1,55,1,55,1,55,1,55,1,55,5,55,1180,8,55,10,55,12,55, + 1183,9,55,1,55,1,55,1,55,1,55,1,56,1,56,1,56,1,56,1,56,5,56,1194,8,56, + 10,56,12,56,1197,9,56,1,56,1,56,1,56,1,56,1,56,3,56,1204,8,56,1,57,1,57, + 1,57,1,57,1,57,1,57,3,57,1212,8,57,1,57,1,57,3,57,1216,8,57,1,58,1,58, 1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58, 1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58, - 1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,3,58,1303,8,58,1,59,1,59, - 1,59,1,59,5,59,1309,8,59,10,59,12,59,1312,9,59,1,59,1,59,1,59,1,60,5,60, - 1318,8,60,10,60,12,60,1321,9,60,1,61,1,61,1,61,1,61,1,61,3,61,1328,8,61, + 1,58,1,58,1,58,1,58,1,58,1,58,1,58,3,58,1255,8,58,1,59,1,59,1,59,1,59, + 5,59,1261,8,59,10,59,12,59,1264,9,59,1,59,1,59,1,59,1,60,5,60,1270,8,60, + 10,60,12,60,1273,9,60,1,61,1,61,1,61,1,61,1,61,3,61,1280,8,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,3,62,1347,8,62,1,63,1,63,1,63,1,63,1,63,1,63,5,63,1355, - 8,63,10,63,12,63,1358,9,63,3,63,1360,8,63,1,64,1,64,1,64,1,64,1,64,1,64, + 1,62,3,62,1299,8,62,1,63,1,63,1,63,1,63,1,63,1,63,5,63,1307,8,63,10,63, + 12,63,1310,9,63,3,63,1312,8,63,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64, 1,64,1,64,1,64,1,64,1,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,1384,8,64,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, + 3,64,1336,8,64,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, @@ -18807,148 +18790,149 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, - 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,3,65,1531,8,65,1,66, - 1,66,1,66,1,66,1,66,1,66,1,66,1,66,3,66,1541,8,66,1,67,1,67,1,67,1,67, - 1,67,5,67,1548,8,67,10,67,12,67,1551,9,67,3,67,1553,8,67,1,68,1,68,1,68, + 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,3,65,1483,8,65,1,66,1,66,1,66, + 1,66,1,66,1,66,1,66,1,66,3,66,1493,8,66,1,67,1,67,1,67,1,67,1,67,5,67, + 1500,8,67,10,67,12,67,1503,9,67,3,67,1505,8,67,1,68,1,68,1,68,1,68,1,68, 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, - 1,68,1,68,1,68,1,68,1,68,1,68,1,68,3,68,1635,8,68,1,69,1,69,1,69,1,69, - 1,69,5,69,1642,8,69,10,69,12,69,1645,9,69,1,70,1,70,1,70,1,70,1,70,1,70, + 1,68,1,68,1,68,1,68,1,68,3,68,1587,8,68,1,69,1,69,1,69,1,69,1,69,5,69, + 1594,8,69,10,69,12,69,1597,9,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,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,1,70,3,70,1676,8,70,1,71,1,71, + 1,70,1,70,1,70,1,70,1,70,1,70,1,70,3,70,1628,8,70,1,71,1,71,1,71,1,71, 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, - 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, - 3,71,1736,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,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,3,71,1688, + 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,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,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,3,72, - 1776,8,72,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73, - 1,73,1,73,3,73,1792,8,73,1,74,1,74,1,74,1,74,1,75,1,75,1,75,1,75,3,75, - 1802,8,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,3,76, - 1829,8,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,1853,8,76,1,77, - 1,77,1,77,1,77,5,77,1859,8,77,10,77,12,77,1862,9,77,1,77,3,77,1865,8,77, - 1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,3,78, - 1880,8,78,1,79,1,79,1,79,5,79,1885,8,79,10,79,12,79,1888,9,79,1,79,1,79, - 1,80,1,80,1,80,1,80,1,81,1,81,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, + 1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,3,72,1728,8,72, + 1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73, + 3,73,1744,8,73,1,74,1,74,1,74,1,74,1,75,1,75,1,75,1,75,3,75,1754,8,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, + 3,76,1784,8,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,1812,8,76,1,77,1,77,1,77,1,77,1,77,5,77,1819,8,77,10,77,12,77, + 1822,9,77,1,77,1,77,1,77,3,77,1827,8,77,1,78,1,78,1,78,1,78,1,78,1,78, + 1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,3,78,1844,8,78,1,79,1,79, + 1,79,1,79,5,79,1850,8,79,10,79,12,79,1853,9,79,1,79,1,79,1,79,1,80,1,80, + 1,80,1,80,1,80,1,81,1,81,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, + 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, - 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,3,82,1932, - 8,82,1,83,1,83,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1942,8,84,1,84,1,84, + 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,3,82,1910,8,82,1,83,1,83,1,84, + 1,84,1,84,1,84,1,84,1,84,3,84,1920,8,84,1,84,1,84,1,84,1,84,1,84,1,84, + 1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1938,8,84,1,84, 1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84, - 3,84,1960,8,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84, - 1,84,1,84,1,84,1,84,1,84,3,84,1978,8,84,1,85,1,85,1,85,1,85,1,85,1,85, - 1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,3,85,1997,8,85, + 1,84,3,84,1956,8,84,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85, + 1,85,1,85,1,85,1,85,1,85,1,85,1,85,3,85,1975,8,85,1,86,1,86,1,86,1,86, 1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86, - 1,86,1,86,1,86,1,86,1,86,3,86,2018,8,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,88,1,88,1,88,1,88,1,88,3,88,2037,8,88, - 1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,3,89, - 2052,8,89,1,90,1,90,1,90,1,90,5,90,2058,8,90,10,90,12,90,2061,9,90,1,90, - 1,90,1,90,1,91,1,91,1,91,1,91,1,91,1,91,3,91,2072,8,91,1,92,1,92,1,92, - 1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92, - 1,92,3,92,2092,8,92,1,93,1,93,1,93,5,93,2097,8,93,10,93,12,93,2100,9,93, - 1,94,1,94,3,94,2104,8,94,1,94,1,94,1,94,1,95,1,95,1,95,1,95,5,95,2113, - 8,95,10,95,12,95,2116,9,95,1,95,1,95,1,95,1,96,1,96,1,96,1,96,1,96,1,97, - 3,97,2127,8,97,1,97,1,97,1,98,1,98,1,98,1,98,1,98,1,98,1,98,1,99,1,99, + 1,86,3,86,1996,8,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,88,1,88,1,88,1,88,1,88,3,88,2015,8,88,1,89,1,89,1,89,1,89, + 1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,3,89,2030,8,89,1,90,1,90, + 1,90,1,90,5,90,2036,8,90,10,90,12,90,2039,9,90,1,90,1,90,1,90,1,91,1,91, + 1,91,1,91,1,91,1,91,3,91,2050,8,91,1,92,1,92,1,92,1,92,1,92,1,92,1,92, + 1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,3,92,2070,8,92, + 1,93,1,93,1,93,5,93,2075,8,93,10,93,12,93,2078,9,93,1,94,1,94,3,94,2082, + 8,94,1,94,1,94,1,94,1,95,1,95,1,95,1,95,5,95,2091,8,95,10,95,12,95,2094, + 9,95,1,95,1,95,1,95,1,96,1,96,1,96,1,96,1,96,1,97,3,97,2105,8,97,1,97, + 1,97,1,98,1,98,1,98,1,98,1,98,1,98,1,98,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, - 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,2235,8,99, - 10,99,12,99,2238,9,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,2247,8,99, - 10,99,12,99,2250,9,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, - 1,99,5,99,2263,8,99,10,99,12,99,2266,9,99,1,99,1,99,1,99,1,99,1,99,1,99, - 1,99,1,99,1,99,5,99,2277,8,99,10,99,12,99,2280,9,99,1,99,1,99,1,99,1,99, - 1,99,1,99,3,99,2288,8,99,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100, - 1,100,1,100,1,100,5,100,2301,8,100,10,100,12,100,2304,9,100,1,100,1,100, - 1,100,1,100,1,100,1,100,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101, + 1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,2213,8,99,10,99,12,99,2216,9,99, + 1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,2225,8,99,10,99,12,99,2228,9,99, + 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,2241,8,99, + 10,99,12,99,2244,9,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99, + 2255,8,99,10,99,12,99,2258,9,99,1,99,1,99,1,99,1,99,1,99,1,99,3,99,2266, + 8,99,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100, + 5,100,2279,8,100,10,100,12,100,2282,9,100,1,100,1,100,1,100,1,100,1,100, + 1,100,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101, 1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101, - 1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101, - 1,101,1,101,3,101,2346,8,101,1,102,1,102,1,102,1,102,1,102,1,102,1,102, - 1,102,1,102,3,102,2357,8,102,1,103,1,103,1,103,1,103,1,103,3,103,2364, - 8,103,1,104,1,104,1,104,1,104,1,104,1,104,3,104,2372,8,104,1,105,1,105, - 1,105,1,105,5,105,2378,8,105,10,105,12,105,2381,9,105,1,105,1,105,1,105, - 1,105,1,105,1,105,1,105,1,105,5,105,2391,8,105,10,105,12,105,2394,9,105, - 1,105,1,105,1,105,3,105,2399,8,105,1,106,1,106,1,106,1,106,3,106,2405, - 8,106,1,107,5,107,2408,8,107,10,107,12,107,2411,9,107,1,108,1,108,1,108, + 1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,3,101, + 2324,8,101,1,102,1,102,1,102,1,102,1,102,1,102,1,102,1,102,1,102,3,102, + 2335,8,102,1,103,1,103,1,103,1,103,1,103,3,103,2342,8,103,1,104,1,104, + 1,104,1,104,1,104,1,104,3,104,2350,8,104,1,105,1,105,1,105,1,105,5,105, + 2356,8,105,10,105,12,105,2359,9,105,1,105,1,105,1,105,1,105,1,105,1,105, + 1,105,1,105,5,105,2369,8,105,10,105,12,105,2372,9,105,1,105,1,105,1,105, + 3,105,2377,8,105,1,106,1,106,1,106,1,106,3,106,2383,8,106,1,107,5,107, + 2386,8,107,10,107,12,107,2389,9,107,1,108,1,108,1,108,1,108,1,108,1,108, 1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108, - 1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,3,108, - 2439,8,108,1,109,1,109,1,109,1,109,5,109,2445,8,109,10,109,12,109,2448, - 9,109,1,109,1,109,1,109,1,109,1,109,1,109,1,109,1,110,1,110,1,110,1,110, - 3,110,2461,8,110,1,111,5,111,2464,8,111,10,111,12,111,2467,9,111,1,112, + 1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,3,108,2417,8,108,1,109, + 1,109,1,109,1,109,5,109,2423,8,109,10,109,12,109,2426,9,109,1,109,1,109, + 1,109,1,109,1,109,1,109,1,109,1,110,1,110,1,110,1,110,3,110,2439,8,110, + 1,111,5,111,2442,8,111,10,111,12,111,2445,9,111,1,112,1,112,1,112,1,112, 1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112, - 1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,3,112,2491,8,112, - 1,113,1,113,1,113,1,113,1,113,1,113,1,113,3,113,2500,8,113,1,114,1,114, - 1,114,1,114,1,114,1,114,1,114,4,114,2509,8,114,11,114,12,114,2510,1,114, - 1,114,3,114,2515,8,114,1,115,1,115,1,115,5,115,2520,8,115,10,115,12,115, - 2523,9,115,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116, - 1,116,1,116,1,116,1,116,1,116,1,116,1,116,3,116,2542,8,116,1,117,1,117, - 1,117,1,117,1,117,1,117,1,117,5,117,2551,8,117,10,117,12,117,2554,9,117, - 1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,5,117,2566, - 8,117,10,117,12,117,2569,9,117,1,117,1,117,1,118,1,118,1,118,1,118,1,118, - 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, + 1,112,1,112,1,112,1,112,1,112,1,112,3,112,2469,8,112,1,113,1,113,1,113, + 1,113,1,113,1,113,1,113,3,113,2478,8,113,1,114,1,114,1,114,1,114,1,114, + 1,114,1,114,4,114,2487,8,114,11,114,12,114,2488,1,114,1,114,3,114,2493, + 8,114,1,115,1,115,1,115,5,115,2498,8,115,10,115,12,115,2501,9,115,1,116, + 1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116, + 1,116,1,116,1,116,1,116,3,116,2520,8,116,1,117,1,117,1,117,1,117,1,117, + 1,117,1,117,5,117,2529,8,117,10,117,12,117,2532,9,117,1,117,1,117,1,117, + 1,117,1,117,1,117,1,117,1,117,1,117,1,117,5,117,2544,8,117,10,117,12,117, + 2547,9,117,1,117,1,117,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, - 1,118,3,118,2615,8,118,1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119, - 3,119,2625,8,119,3,119,2627,8,119,1,119,1,119,1,119,5,119,2632,8,119,10, - 119,12,119,2635,9,119,1,119,1,119,1,119,3,119,2640,8,119,1,120,1,120,1, - 120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, + 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,3,118,2593, + 8,118,1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119,3,119,2603,8,119, + 3,119,2605,8,119,1,119,1,119,1,119,5,119,2610,8,119,10,119,12,119,2613, + 9,119,1,119,1,119,1,119,3,119,2618,8,119,1,120,1,120,1,120,1,120,1,120, 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, - 1,120,1,120,1,120,1,120,3,120,2684,8,120,1,121,1,121,1,121,1,121,1,121, - 1,121,1,121,3,121,2693,8,121,1,122,1,122,1,122,1,122,1,122,1,122,1,122, + 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, + 1,120,3,120,2662,8,120,1,121,1,121,1,121,1,121,1,121,1,121,1,121,3,121, + 2671,8,121,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, - 1,122,1,122,1,122,1,122,1,122,1,122,1,122,3,122,2733,8,122,1,123,5,123, - 2736,8,123,10,123,12,123,2739,9,123,1,124,1,124,1,124,1,124,1,124,1,124, + 1,122,1,122,1,122,1,122,3,122,2711,8,122,1,123,5,123,2714,8,123,10,123, + 12,123,2717,9,123,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, - 1,124,1,124,1,124,1,124,1,124,1,124,1,124,3,124,2778,8,124,1,125,1,125, - 3,125,2782,8,125,1,125,1,125,1,126,1,126,1,126,1,126,1,126,1,126,3,126, - 2792,8,126,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,128,1,128,1,128,1,128,1,128,1,128,1,128,3,128,2814, - 8,128,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,5,129,2824,8,129, - 10,129,12,129,2827,9,129,1,129,1,129,1,129,1,129,1,129,1,129,5,129,2835, - 8,129,10,129,12,129,2838,9,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129, - 1,129,1,129,1,129,5,129,2850,8,129,10,129,12,129,2853,9,129,1,129,1,129, - 1,129,1,129,1,129,1,129,1,129,1,129,5,129,2863,8,129,10,129,12,129,2866, - 9,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,5,129,2876,8,129, - 10,129,12,129,2879,9,129,3,129,2881,8,129,1,130,1,130,1,130,1,130,1,131, - 1,131,1,131,1,131,1,131,1,131,3,131,2893,8,131,1,132,1,132,1,132,1,132, - 1,133,1,133,1,133,1,134,1,134,1,134,4,134,2905,8,134,11,134,12,134,2906, + 1,124,1,124,1,124,1,124,3,124,2756,8,124,1,125,1,125,3,125,2760,8,125, + 1,125,1,125,1,126,1,126,1,126,1,126,1,126,1,126,3,126,2770,8,126,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,128,1,128,1,128,1,128,1,128,1,128,1,128,3,128,2792,8,128,1,129,1,129, + 1,129,1,129,1,129,1,129,1,129,1,129,5,129,2802,8,129,10,129,12,129,2805, + 9,129,1,129,1,129,1,129,1,129,1,129,1,129,5,129,2813,8,129,10,129,12,129, + 2816,9,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129, + 5,129,2828,8,129,10,129,12,129,2831,9,129,1,129,1,129,1,129,1,129,1,129, + 1,129,1,129,1,129,5,129,2841,8,129,10,129,12,129,2844,9,129,1,129,1,129, + 1,129,1,129,1,129,1,129,1,129,1,129,5,129,2854,8,129,10,129,12,129,2857, + 9,129,3,129,2859,8,129,1,130,1,130,1,130,1,130,1,131,1,131,1,131,1,131, + 1,131,1,131,3,131,2871,8,131,1,132,1,132,1,132,1,132,1,133,1,133,1,133, + 1,134,1,134,1,134,4,134,2883,8,134,11,134,12,134,2884,1,135,1,135,1,135, 1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135, - 1,135,1,135,1,135,1,135,3,135,2925,8,135,1,136,1,136,1,136,1,136,1,136, - 1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,3,136, - 2943,8,136,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137, - 1,137,1,137,3,137,2957,8,137,1,138,1,138,1,138,1,139,1,139,1,140,1,140, + 1,135,3,135,2903,8,135,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136, + 1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,3,136,2921,8,136,1,137, + 1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,3,137, + 2935,8,137,1,138,1,138,1,138,1,139,1,139,1,140,1,140,1,141,1,141,1,141, 1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141, - 1,141,1,141,1,141,3,141,2981,8,141,1,142,1,142,1,142,1,143,1,143,1,143, - 1,143,1,143,1,143,1,143,3,143,2993,8,143,1,144,1,144,1,144,3,144,2998, - 8,144,1,145,1,145,1,145,1,145,1,145,4,145,3005,8,145,11,145,12,145,3006, - 3,145,3009,8,145,1,146,1,146,1,146,5,146,3014,8,146,10,146,12,146,3017, - 9,146,1,146,1,146,1,147,1,147,1,147,1,147,1,147,3,147,3026,8,147,1,148, - 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, + 3,141,2959,8,141,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,3,143,2974,8,143,1,144,1,144,1,144,1,144,1,144, + 3,144,2981,8,144,1,145,1,145,1,145,1,145,1,145,4,145,2988,8,145,11,145, + 12,145,2989,3,145,2992,8,145,1,146,1,146,1,146,5,146,2997,8,146,10,146, + 12,146,3000,9,146,1,146,1,146,1,147,1,147,1,147,1,147,1,147,1,147,3,147, + 3010,8,147,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, - 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, - 1,148,1,148,1,148,1,148,1,148,3,148,3094,8,148,1,149,1,149,1,149,1,149, - 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, + 1,148,1,148,3,148,3060,8,148,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, - 1,149,1,149,3,149,3186,8,149,1,150,1,150,1,150,5,150,3191,8,150,10,150, - 12,150,3194,9,150,1,151,1,151,1,152,1,152,1,152,1,152,1,152,1,152,1,152, - 1,152,3,152,3206,8,152,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, + 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,3,149, + 3152,8,149,1,150,1,150,1,150,5,150,3157,8,150,10,150,12,150,3160,9,150, + 1,151,1,151,1,152,1,152,1,152,1,152,1,152,1,152,1,152,1,152,3,152,3172, + 8,152,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, @@ -18962,1139 +18946,1126 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, - 1,153,1,153,1,153,1,153,1,153,1,153,1,153,3,153,3379,8,153,1,154,1,154, - 1,154,1,154,1,154,1,154,5,154,3387,8,154,10,154,12,154,3390,9,154,1,155, - 1,155,1,155,1,155,1,155,1,155,5,155,3398,8,155,10,155,12,155,3401,9,155, - 1,156,1,156,1,156,5,156,3406,8,156,10,156,12,156,3409,9,156,1,157,1,157, - 1,157,5,157,3414,8,157,10,157,12,157,3417,9,157,1,158,1,158,1,158,5,158, - 3422,8,158,10,158,12,158,3425,9,158,1,159,1,159,1,159,5,159,3430,8,159, - 10,159,12,159,3433,9,159,1,160,1,160,1,160,5,160,3438,8,160,10,160,12, - 160,3441,9,160,1,161,1,161,1,161,1,161,5,161,3447,8,161,10,161,12,161, - 3450,9,161,1,162,1,162,1,162,5,162,3455,8,162,10,162,12,162,3458,9,162, - 1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,3,163,3468,8,163,1,164, - 1,164,1,164,5,164,3473,8,164,10,164,12,164,3476,9,164,1,165,1,165,1,165, - 1,165,1,165,1,165,1,165,1,165,1,165,3,165,3487,8,165,1,166,1,166,1,166, + 1,153,1,153,1,153,1,153,3,153,3345,8,153,1,154,1,154,1,154,1,154,1,154, + 1,154,5,154,3353,8,154,10,154,12,154,3356,9,154,1,155,1,155,1,155,1,155, + 1,155,1,155,5,155,3364,8,155,10,155,12,155,3367,9,155,1,156,1,156,1,156, + 5,156,3372,8,156,10,156,12,156,3375,9,156,1,157,1,157,1,157,5,157,3380, + 8,157,10,157,12,157,3383,9,157,1,158,1,158,1,158,5,158,3388,8,158,10,158, + 12,158,3391,9,158,1,159,1,159,1,159,5,159,3396,8,159,10,159,12,159,3399, + 9,159,1,160,1,160,1,160,5,160,3404,8,160,10,160,12,160,3407,9,160,1,161, + 1,161,1,161,1,161,5,161,3413,8,161,10,161,12,161,3416,9,161,1,162,1,162, + 1,162,5,162,3421,8,162,10,162,12,162,3424,9,162,1,163,1,163,1,163,1,163, + 1,163,1,163,1,163,1,163,3,163,3434,8,163,1,164,1,164,1,164,5,164,3439, + 8,164,10,164,12,164,3442,9,164,1,165,1,165,1,165,1,165,1,165,1,165,1,165, + 1,165,1,165,3,165,3453,8,165,1,166,1,166,1,166,1,166,1,166,1,166,1,166, 1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166, - 1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,3,166,3514, - 8,166,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,168,3,168,3533,8,168,1,169,5,169,3536, - 8,169,10,169,12,169,3539,9,169,1,170,1,170,1,170,1,170,1,170,1,170,1,170, - 1,170,1,170,1,170,1,170,1,170,1,170,1,170,3,170,3555,8,170,1,171,1,171, - 1,171,1,171,1,171,1,172,1,172,1,172,5,172,3565,8,172,10,172,12,172,3568, - 9,172,1,172,1,172,1,173,1,173,5,173,3574,8,173,10,173,12,173,3577,9,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,3,174,3596,8,174,1,175,5,175,3599,8,175, - 10,175,12,175,3602,9,175,1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176, - 1,176,1,176,1,176,1,176,1,176,3,176,3617,8,176,1,177,1,177,1,177,1,177, - 1,177,1,178,1,178,5,178,3626,8,178,10,178,12,178,3629,9,178,1,178,1,178, - 1,178,5,178,3634,8,178,10,178,12,178,3637,9,178,1,178,1,178,1,178,1,178, - 3,178,3643,8,178,1,179,1,179,1,180,5,180,3648,8,180,10,180,12,180,3651, - 9,180,1,181,1,181,1,181,1,181,1,181,1,181,1,181,1,181,1,181,1,181,3,181, - 3663,8,181,1,181,0,1,68,182,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,0,13,6,0,1,15, - 199,199,243,243,247,247,264,264,289,289,5,0,16,16,199,199,243,243,264, - 264,288,289,1,0,263,264,1,0,173,174,1,0,37,38,1,0,73,74,3,0,2,2,61,61, - 77,83,2,0,229,229,260,261,1,0,95,96,1,0,97,111,2,0,173,173,289,290,1,0, - 167,168,1,0,51,52,4127,0,364,1,0,0,0,2,382,1,0,0,0,4,384,1,0,0,0,6,391, - 1,0,0,0,8,400,1,0,0,0,10,489,1,0,0,0,12,491,1,0,0,0,14,495,1,0,0,0,16, - 499,1,0,0,0,18,504,1,0,0,0,20,508,1,0,0,0,22,512,1,0,0,0,24,519,1,0,0, - 0,26,535,1,0,0,0,28,537,1,0,0,0,30,539,1,0,0,0,32,551,1,0,0,0,34,553,1, - 0,0,0,36,576,1,0,0,0,38,580,1,0,0,0,40,598,1,0,0,0,42,625,1,0,0,0,44,653, - 1,0,0,0,46,693,1,0,0,0,48,695,1,0,0,0,50,704,1,0,0,0,52,706,1,0,0,0,54, - 716,1,0,0,0,56,729,1,0,0,0,58,732,1,0,0,0,60,735,1,0,0,0,62,759,1,0,0, - 0,64,772,1,0,0,0,66,774,1,0,0,0,68,782,1,0,0,0,70,798,1,0,0,0,72,804,1, - 0,0,0,74,808,1,0,0,0,76,887,1,0,0,0,78,894,1,0,0,0,80,901,1,0,0,0,82,906, - 1,0,0,0,84,915,1,0,0,0,86,921,1,0,0,0,88,1026,1,0,0,0,90,1054,1,0,0,0, - 92,1056,1,0,0,0,94,1060,1,0,0,0,96,1062,1,0,0,0,98,1067,1,0,0,0,100,1095, - 1,0,0,0,102,1175,1,0,0,0,104,1177,1,0,0,0,106,1206,1,0,0,0,108,1208,1, - 0,0,0,110,1222,1,0,0,0,112,1251,1,0,0,0,114,1263,1,0,0,0,116,1302,1,0, - 0,0,118,1310,1,0,0,0,120,1319,1,0,0,0,122,1327,1,0,0,0,124,1346,1,0,0, - 0,126,1359,1,0,0,0,128,1383,1,0,0,0,130,1530,1,0,0,0,132,1540,1,0,0,0, - 134,1552,1,0,0,0,136,1634,1,0,0,0,138,1636,1,0,0,0,140,1675,1,0,0,0,142, - 1735,1,0,0,0,144,1775,1,0,0,0,146,1791,1,0,0,0,148,1793,1,0,0,0,150,1797, - 1,0,0,0,152,1852,1,0,0,0,154,1864,1,0,0,0,156,1879,1,0,0,0,158,1886,1, - 0,0,0,160,1891,1,0,0,0,162,1895,1,0,0,0,164,1931,1,0,0,0,166,1933,1,0, - 0,0,168,1977,1,0,0,0,170,1996,1,0,0,0,172,2017,1,0,0,0,174,2019,1,0,0, - 0,176,2036,1,0,0,0,178,2051,1,0,0,0,180,2059,1,0,0,0,182,2071,1,0,0,0, - 184,2091,1,0,0,0,186,2098,1,0,0,0,188,2101,1,0,0,0,190,2114,1,0,0,0,192, - 2120,1,0,0,0,194,2126,1,0,0,0,196,2130,1,0,0,0,198,2287,1,0,0,0,200,2289, - 1,0,0,0,202,2345,1,0,0,0,204,2356,1,0,0,0,206,2363,1,0,0,0,208,2371,1, - 0,0,0,210,2398,1,0,0,0,212,2404,1,0,0,0,214,2409,1,0,0,0,216,2438,1,0, - 0,0,218,2440,1,0,0,0,220,2460,1,0,0,0,222,2465,1,0,0,0,224,2490,1,0,0, - 0,226,2499,1,0,0,0,228,2514,1,0,0,0,230,2521,1,0,0,0,232,2541,1,0,0,0, - 234,2543,1,0,0,0,236,2614,1,0,0,0,238,2639,1,0,0,0,240,2683,1,0,0,0,242, - 2692,1,0,0,0,244,2732,1,0,0,0,246,2737,1,0,0,0,248,2777,1,0,0,0,250,2779, - 1,0,0,0,252,2785,1,0,0,0,254,2793,1,0,0,0,256,2813,1,0,0,0,258,2880,1, - 0,0,0,260,2882,1,0,0,0,262,2892,1,0,0,0,264,2894,1,0,0,0,266,2898,1,0, - 0,0,268,2904,1,0,0,0,270,2924,1,0,0,0,272,2942,1,0,0,0,274,2956,1,0,0, - 0,276,2958,1,0,0,0,278,2961,1,0,0,0,280,2963,1,0,0,0,282,2980,1,0,0,0, - 284,2982,1,0,0,0,286,2992,1,0,0,0,288,2997,1,0,0,0,290,3008,1,0,0,0,292, - 3015,1,0,0,0,294,3025,1,0,0,0,296,3093,1,0,0,0,298,3185,1,0,0,0,300,3192, - 1,0,0,0,302,3195,1,0,0,0,304,3205,1,0,0,0,306,3378,1,0,0,0,308,3388,1, - 0,0,0,310,3399,1,0,0,0,312,3407,1,0,0,0,314,3415,1,0,0,0,316,3423,1,0, - 0,0,318,3431,1,0,0,0,320,3439,1,0,0,0,322,3448,1,0,0,0,324,3456,1,0,0, - 0,326,3467,1,0,0,0,328,3474,1,0,0,0,330,3486,1,0,0,0,332,3513,1,0,0,0, - 334,3515,1,0,0,0,336,3532,1,0,0,0,338,3537,1,0,0,0,340,3554,1,0,0,0,342, - 3556,1,0,0,0,344,3561,1,0,0,0,346,3571,1,0,0,0,348,3595,1,0,0,0,350,3600, - 1,0,0,0,352,3616,1,0,0,0,354,3618,1,0,0,0,356,3642,1,0,0,0,358,3644,1, - 0,0,0,360,3649,1,0,0,0,362,3662,1,0,0,0,364,365,7,0,0,0,365,1,1,0,0,0, - 366,367,5,288,0,0,367,383,6,1,-1,0,368,369,3,4,2,0,369,370,6,1,-1,0,370, - 371,5,265,0,0,371,373,1,0,0,0,372,368,1,0,0,0,373,376,1,0,0,0,374,372, - 1,0,0,0,374,375,1,0,0,0,375,377,1,0,0,0,376,374,1,0,0,0,377,378,3,4,2, - 0,378,379,6,1,-1,0,379,383,1,0,0,0,380,381,5,264,0,0,381,383,6,1,-1,0, - 382,366,1,0,0,0,382,374,1,0,0,0,382,380,1,0,0,0,383,3,1,0,0,0,384,385, - 7,1,0,0,385,5,1,0,0,0,386,387,5,263,0,0,387,388,6,3,-1,0,388,390,5,266, - 0,0,389,386,1,0,0,0,390,393,1,0,0,0,391,389,1,0,0,0,391,392,1,0,0,0,392, - 394,1,0,0,0,393,391,1,0,0,0,394,395,5,263,0,0,395,396,6,3,-1,0,396,7,1, - 0,0,0,397,399,3,10,5,0,398,397,1,0,0,0,399,402,1,0,0,0,400,398,1,0,0,0, - 400,401,1,0,0,0,401,9,1,0,0,0,402,400,1,0,0,0,403,404,3,74,37,0,404,405, - 5,17,0,0,405,406,3,82,41,0,406,407,5,18,0,0,407,490,1,0,0,0,408,409,3, - 72,36,0,409,410,5,17,0,0,410,411,3,8,4,0,411,412,5,18,0,0,412,490,1,0, - 0,0,413,414,3,234,117,0,414,415,5,17,0,0,415,416,3,246,123,0,416,417,5, - 18,0,0,417,490,1,0,0,0,418,490,3,200,100,0,419,420,6,5,-1,0,420,421,3, - 284,142,0,421,422,6,5,-1,0,422,490,1,0,0,0,423,424,6,5,-1,0,424,425,3, - 70,35,0,425,426,6,5,-1,0,426,490,1,0,0,0,427,428,6,5,-1,0,428,429,3,66, - 33,0,429,430,6,5,-1,0,430,490,1,0,0,0,431,432,6,5,-1,0,432,433,3,88,44, - 0,433,434,6,5,-1,0,434,490,1,0,0,0,435,436,6,5,-1,0,436,437,3,90,45,0, - 437,438,6,5,-1,0,438,490,1,0,0,0,439,440,6,5,-1,0,440,441,3,22,11,0,441, - 442,6,5,-1,0,442,490,1,0,0,0,443,444,6,5,-1,0,444,445,3,334,167,0,445, - 446,6,5,-1,0,446,490,1,0,0,0,447,448,6,5,-1,0,448,449,3,342,171,0,449, - 450,6,5,-1,0,450,490,1,0,0,0,451,452,6,5,-1,0,452,453,3,354,177,0,453, - 454,6,5,-1,0,454,490,1,0,0,0,455,456,6,5,-1,0,456,457,3,64,32,0,457,458, - 6,5,-1,0,458,490,1,0,0,0,459,460,6,5,-1,0,460,461,3,152,76,0,461,462,6, - 5,-1,0,462,490,1,0,0,0,463,464,3,330,165,0,464,465,6,5,-1,0,465,490,1, - 0,0,0,466,467,6,5,-1,0,467,490,3,12,6,0,468,469,6,5,-1,0,469,490,3,14, - 7,0,470,471,6,5,-1,0,471,490,3,16,8,0,472,473,6,5,-1,0,473,490,3,18,9, - 0,474,475,6,5,-1,0,475,490,3,20,10,0,476,477,6,5,-1,0,477,478,3,26,13, - 0,478,479,6,5,-1,0,479,490,1,0,0,0,480,481,6,5,-1,0,481,482,3,42,21,0, - 482,483,6,5,-1,0,483,490,1,0,0,0,484,485,6,5,-1,0,485,490,3,40,20,0,486, - 490,3,30,15,0,487,488,6,5,-1,0,488,490,3,24,12,0,489,403,1,0,0,0,489,408, - 1,0,0,0,489,413,1,0,0,0,489,418,1,0,0,0,489,419,1,0,0,0,489,423,1,0,0, - 0,489,427,1,0,0,0,489,431,1,0,0,0,489,435,1,0,0,0,489,439,1,0,0,0,489, - 443,1,0,0,0,489,447,1,0,0,0,489,451,1,0,0,0,489,455,1,0,0,0,489,459,1, - 0,0,0,489,463,1,0,0,0,489,466,1,0,0,0,489,468,1,0,0,0,489,470,1,0,0,0, - 489,472,1,0,0,0,489,474,1,0,0,0,489,476,1,0,0,0,489,480,1,0,0,0,489,484, - 1,0,0,0,489,486,1,0,0,0,489,487,1,0,0,0,490,11,1,0,0,0,491,492,5,19,0, - 0,492,493,3,32,16,0,493,494,6,6,-1,0,494,13,1,0,0,0,495,496,5,20,0,0,496, - 497,3,32,16,0,497,498,6,7,-1,0,498,15,1,0,0,0,499,500,5,21,0,0,500,501, - 5,22,0,0,501,502,3,32,16,0,502,503,6,8,-1,0,503,17,1,0,0,0,504,505,5,23, - 0,0,505,506,3,34,17,0,506,507,6,9,-1,0,507,19,1,0,0,0,508,509,5,24,0,0, - 509,510,3,34,17,0,510,511,6,10,-1,0,511,21,1,0,0,0,512,513,5,25,0,0,513, - 514,3,98,49,0,514,515,3,2,1,0,515,516,5,17,0,0,516,517,3,120,60,0,517, - 518,5,18,0,0,518,23,1,0,0,0,519,520,5,26,0,0,520,25,1,0,0,0,521,522,5, - 27,0,0,522,536,3,28,14,0,523,524,5,27,0,0,524,525,3,28,14,0,525,526,5, - 28,0,0,526,527,3,28,14,0,527,536,1,0,0,0,528,529,5,27,0,0,529,530,3,28, - 14,0,530,531,5,28,0,0,531,532,3,28,14,0,532,533,5,28,0,0,533,534,3,28, - 14,0,534,536,1,0,0,0,535,521,1,0,0,0,535,523,1,0,0,0,535,528,1,0,0,0,536, - 27,1,0,0,0,537,538,7,2,0,0,538,29,1,0,0,0,539,540,5,29,0,0,540,546,5,17, - 0,0,541,542,3,116,58,0,542,543,6,15,-1,0,543,545,1,0,0,0,544,541,1,0,0, - 0,545,548,1,0,0,0,546,544,1,0,0,0,546,547,1,0,0,0,547,549,1,0,0,0,548, - 546,1,0,0,0,549,550,5,18,0,0,550,31,1,0,0,0,551,552,5,173,0,0,552,33,1, - 0,0,0,553,554,7,3,0,0,554,35,1,0,0,0,555,556,5,175,0,0,556,577,6,18,-1, - 0,557,558,3,32,16,0,558,559,5,265,0,0,559,560,6,18,-1,0,560,577,1,0,0, - 0,561,562,3,32,16,0,562,563,6,18,-1,0,563,577,1,0,0,0,564,565,5,188,0, - 0,565,566,5,30,0,0,566,567,3,32,16,0,567,568,5,31,0,0,568,569,6,18,-1, - 0,569,577,1,0,0,0,570,571,5,189,0,0,571,572,5,30,0,0,572,573,3,34,17,0, - 573,574,5,31,0,0,574,575,6,18,-1,0,575,577,1,0,0,0,576,555,1,0,0,0,576, - 557,1,0,0,0,576,561,1,0,0,0,576,564,1,0,0,0,576,570,1,0,0,0,577,37,1,0, - 0,0,578,581,3,32,16,0,579,581,5,262,0,0,580,578,1,0,0,0,580,579,1,0,0, - 0,581,39,1,0,0,0,582,583,5,267,0,0,583,599,5,289,0,0,584,585,5,267,0,0, - 585,586,5,289,0,0,586,599,5,263,0,0,587,588,5,268,0,0,588,599,5,289,0, - 0,589,590,5,269,0,0,590,599,5,289,0,0,591,592,5,270,0,0,592,599,5,289, - 0,0,593,599,5,271,0,0,594,599,5,272,0,0,595,596,5,273,0,0,596,599,5,263, - 0,0,597,599,5,32,0,0,598,582,1,0,0,0,598,584,1,0,0,0,598,587,1,0,0,0,598, - 589,1,0,0,0,598,591,1,0,0,0,598,593,1,0,0,0,598,594,1,0,0,0,598,595,1, - 0,0,0,598,597,1,0,0,0,599,41,1,0,0,0,600,601,5,33,0,0,601,602,3,138,69, - 0,602,603,5,34,0,0,603,604,3,2,1,0,604,626,1,0,0,0,605,606,5,33,0,0,606, - 607,3,116,58,0,607,608,5,34,0,0,608,609,3,2,1,0,609,626,1,0,0,0,610,611, - 5,33,0,0,611,612,3,176,88,0,612,613,5,34,0,0,613,614,3,2,1,0,614,626,1, - 0,0,0,615,616,5,33,0,0,616,617,3,44,22,0,617,618,5,34,0,0,618,619,3,2, - 1,0,619,626,1,0,0,0,620,621,5,33,0,0,621,622,3,46,23,0,622,623,5,34,0, - 0,623,624,3,2,1,0,624,626,1,0,0,0,625,600,1,0,0,0,625,605,1,0,0,0,625, - 610,1,0,0,0,625,615,1,0,0,0,625,620,1,0,0,0,626,43,1,0,0,0,627,628,5,35, - 0,0,628,629,3,48,24,0,629,630,6,22,-1,0,630,654,1,0,0,0,631,632,5,35,0, - 0,632,633,3,48,24,0,633,634,5,36,0,0,634,635,3,6,3,0,635,636,6,22,-1,0, - 636,654,1,0,0,0,637,638,5,35,0,0,638,639,3,48,24,0,639,640,5,36,0,0,640, - 641,5,17,0,0,641,642,3,52,26,0,642,643,5,18,0,0,643,644,6,22,-1,0,644, - 654,1,0,0,0,645,646,5,35,0,0,646,647,3,48,24,0,647,648,5,36,0,0,648,649, - 5,30,0,0,649,650,3,300,150,0,650,651,5,31,0,0,651,652,6,22,-1,0,652,654, - 1,0,0,0,653,627,1,0,0,0,653,631,1,0,0,0,653,637,1,0,0,0,653,645,1,0,0, - 0,654,45,1,0,0,0,655,656,5,35,0,0,656,657,5,30,0,0,657,658,3,50,25,0,658, - 659,5,31,0,0,659,660,3,48,24,0,660,661,6,23,-1,0,661,694,1,0,0,0,662,663, - 5,35,0,0,663,664,5,30,0,0,664,665,3,50,25,0,665,666,5,31,0,0,666,667,3, - 48,24,0,667,668,5,36,0,0,668,669,3,6,3,0,669,670,6,23,-1,0,670,694,1,0, - 0,0,671,672,5,35,0,0,672,673,5,30,0,0,673,674,3,50,25,0,674,675,5,31,0, - 0,675,676,3,48,24,0,676,677,5,36,0,0,677,678,5,17,0,0,678,679,3,52,26, - 0,679,680,5,18,0,0,680,681,6,23,-1,0,681,694,1,0,0,0,682,683,5,35,0,0, - 683,684,5,30,0,0,684,685,3,50,25,0,685,686,5,31,0,0,686,687,3,48,24,0, - 687,688,5,36,0,0,688,689,5,30,0,0,689,690,3,300,150,0,690,691,5,31,0,0, - 691,692,6,23,-1,0,692,694,1,0,0,0,693,655,1,0,0,0,693,662,1,0,0,0,693, - 671,1,0,0,0,693,682,1,0,0,0,694,47,1,0,0,0,695,696,3,168,84,0,696,697, - 6,24,-1,0,697,49,1,0,0,0,698,699,3,124,62,0,699,700,6,25,-1,0,700,705, - 1,0,0,0,701,702,3,176,88,0,702,703,6,25,-1,0,703,705,1,0,0,0,704,698,1, - 0,0,0,704,701,1,0,0,0,705,51,1,0,0,0,706,707,3,54,27,0,707,708,3,56,28, - 0,708,709,6,26,-1,0,709,53,1,0,0,0,710,711,3,306,153,0,711,712,6,27,-1, - 0,712,715,1,0,0,0,713,715,3,40,20,0,714,710,1,0,0,0,714,713,1,0,0,0,715, - 718,1,0,0,0,716,714,1,0,0,0,716,717,1,0,0,0,717,55,1,0,0,0,718,716,1,0, - 0,0,719,720,3,58,29,0,720,721,3,60,30,0,721,722,3,2,1,0,722,723,5,36,0, - 0,723,724,3,306,153,0,724,725,6,28,-1,0,725,728,1,0,0,0,726,728,3,40,20, - 0,727,719,1,0,0,0,727,726,1,0,0,0,728,731,1,0,0,0,729,727,1,0,0,0,729, - 730,1,0,0,0,730,57,1,0,0,0,731,729,1,0,0,0,732,733,7,4,0,0,733,734,6,29, - -1,0,734,59,1,0,0,0,735,737,3,62,31,0,736,738,5,261,0,0,737,736,1,0,0, - 0,737,738,1,0,0,0,738,739,1,0,0,0,739,740,6,30,-1,0,740,61,1,0,0,0,741, - 742,3,144,72,0,742,743,6,31,-1,0,743,760,1,0,0,0,744,745,3,2,1,0,745,746, - 6,31,-1,0,746,760,1,0,0,0,747,748,5,196,0,0,748,760,6,31,-1,0,749,750, - 5,197,0,0,750,760,6,31,-1,0,751,752,5,202,0,0,752,753,5,39,0,0,753,754, - 5,264,0,0,754,760,6,31,-1,0,755,756,5,202,0,0,756,757,3,116,58,0,757,758, - 6,31,-1,0,758,760,1,0,0,0,759,741,1,0,0,0,759,744,1,0,0,0,759,747,1,0, - 0,0,759,749,1,0,0,0,759,751,1,0,0,0,759,755,1,0,0,0,760,63,1,0,0,0,761, - 762,5,198,0,0,762,763,5,40,0,0,763,764,3,2,1,0,764,765,6,32,-1,0,765,773, - 1,0,0,0,766,767,5,198,0,0,767,768,3,2,1,0,768,769,6,32,-1,0,769,773,1, - 0,0,0,770,771,5,198,0,0,771,773,6,32,-1,0,772,761,1,0,0,0,772,766,1,0, - 0,0,772,770,1,0,0,0,773,65,1,0,0,0,774,775,5,41,0,0,775,776,5,42,0,0,776, - 777,3,32,16,0,777,778,5,43,0,0,778,779,3,68,34,0,779,780,5,44,0,0,780, - 781,3,0,0,0,781,67,1,0,0,0,782,795,6,34,-1,0,783,784,10,5,0,0,784,794, - 5,186,0,0,785,786,10,4,0,0,786,794,5,187,0,0,787,788,10,3,0,0,788,794, - 5,45,0,0,789,790,10,2,0,0,790,794,5,46,0,0,791,792,10,1,0,0,792,794,5, - 47,0,0,793,783,1,0,0,0,793,785,1,0,0,0,793,787,1,0,0,0,793,789,1,0,0,0, - 793,791,1,0,0,0,794,797,1,0,0,0,795,793,1,0,0,0,795,796,1,0,0,0,796,69, - 1,0,0,0,797,795,1,0,0,0,798,799,5,48,0,0,799,800,5,36,0,0,800,801,5,30, - 0,0,801,802,3,300,150,0,802,803,5,31,0,0,803,71,1,0,0,0,804,805,5,49,0, - 0,805,806,3,2,1,0,806,807,6,36,-1,0,807,73,1,0,0,0,808,814,5,50,0,0,809, - 810,3,76,38,0,810,811,6,37,-1,0,811,813,1,0,0,0,812,809,1,0,0,0,813,816, - 1,0,0,0,814,812,1,0,0,0,814,815,1,0,0,0,815,817,1,0,0,0,816,814,1,0,0, - 0,817,818,3,2,1,0,818,819,3,182,91,0,819,820,3,78,39,0,820,821,3,80,40, - 0,821,822,6,37,-1,0,822,75,1,0,0,0,823,824,5,51,0,0,824,888,6,38,-1,0, - 825,826,5,52,0,0,826,888,6,38,-1,0,827,828,5,199,0,0,828,888,6,38,-1,0, - 829,830,5,202,0,0,830,888,6,38,-1,0,831,832,5,221,0,0,832,888,6,38,-1, - 0,833,834,5,53,0,0,834,888,6,38,-1,0,835,836,5,54,0,0,836,888,6,38,-1, - 0,837,838,5,55,0,0,838,888,6,38,-1,0,839,840,5,56,0,0,840,888,6,38,-1, - 0,841,842,5,244,0,0,842,888,6,38,-1,0,843,844,5,15,0,0,844,888,6,38,-1, - 0,845,846,5,224,0,0,846,888,6,38,-1,0,847,848,5,57,0,0,848,888,6,38,-1, - 0,849,850,5,58,0,0,850,888,6,38,-1,0,851,852,5,59,0,0,852,888,6,38,-1, - 0,853,854,5,60,0,0,854,888,6,38,-1,0,855,856,5,61,0,0,856,888,6,38,-1, - 0,857,858,5,62,0,0,858,859,5,51,0,0,859,888,6,38,-1,0,860,861,5,62,0,0, - 861,862,5,52,0,0,862,888,6,38,-1,0,863,864,5,62,0,0,864,865,5,63,0,0,865, - 888,6,38,-1,0,866,867,5,62,0,0,867,868,5,64,0,0,868,888,6,38,-1,0,869, - 870,5,62,0,0,870,871,5,65,0,0,871,888,6,38,-1,0,872,873,5,62,0,0,873,874, - 5,66,0,0,874,888,6,38,-1,0,875,876,5,67,0,0,876,888,6,38,-1,0,877,878, - 5,68,0,0,878,888,6,38,-1,0,879,880,5,69,0,0,880,888,6,38,-1,0,881,882, - 5,70,0,0,882,883,5,30,0,0,883,884,3,32,16,0,884,885,5,31,0,0,885,886,6, - 38,-1,0,886,888,1,0,0,0,887,823,1,0,0,0,887,825,1,0,0,0,887,827,1,0,0, - 0,887,829,1,0,0,0,887,831,1,0,0,0,887,833,1,0,0,0,887,835,1,0,0,0,887, - 837,1,0,0,0,887,839,1,0,0,0,887,841,1,0,0,0,887,843,1,0,0,0,887,845,1, - 0,0,0,887,847,1,0,0,0,887,849,1,0,0,0,887,851,1,0,0,0,887,853,1,0,0,0, - 887,855,1,0,0,0,887,857,1,0,0,0,887,860,1,0,0,0,887,863,1,0,0,0,887,866, - 1,0,0,0,887,869,1,0,0,0,887,872,1,0,0,0,887,875,1,0,0,0,887,877,1,0,0, - 0,887,879,1,0,0,0,887,881,1,0,0,0,888,77,1,0,0,0,889,895,1,0,0,0,890,891, - 5,71,0,0,891,892,3,124,62,0,892,893,6,39,-1,0,893,895,1,0,0,0,894,889, - 1,0,0,0,894,890,1,0,0,0,895,79,1,0,0,0,896,902,1,0,0,0,897,898,5,72,0, - 0,898,899,3,84,42,0,899,900,6,40,-1,0,900,902,1,0,0,0,901,896,1,0,0,0, - 901,897,1,0,0,0,902,81,1,0,0,0,903,905,3,198,99,0,904,903,1,0,0,0,905, - 908,1,0,0,0,906,904,1,0,0,0,906,907,1,0,0,0,907,83,1,0,0,0,908,906,1,0, - 0,0,909,910,3,124,62,0,910,911,6,42,-1,0,911,912,5,28,0,0,912,914,1,0, - 0,0,913,909,1,0,0,0,914,917,1,0,0,0,915,913,1,0,0,0,915,916,1,0,0,0,916, - 918,1,0,0,0,917,915,1,0,0,0,918,919,3,124,62,0,919,920,6,42,-1,0,920,85, - 1,0,0,0,921,922,7,5,0,0,922,87,1,0,0,0,923,924,3,86,43,0,924,925,3,32, - 16,0,925,926,5,264,0,0,926,1027,1,0,0,0,927,928,3,86,43,0,928,929,3,32, - 16,0,929,1027,1,0,0,0,930,931,3,86,43,0,931,932,3,32,16,0,932,933,5,75, - 0,0,933,934,3,32,16,0,934,935,5,264,0,0,935,1027,1,0,0,0,936,937,3,86, - 43,0,937,938,3,32,16,0,938,939,5,75,0,0,939,940,3,32,16,0,940,1027,1,0, - 0,0,941,942,3,86,43,0,942,943,3,32,16,0,943,944,5,75,0,0,944,945,3,32, - 16,0,945,946,5,28,0,0,946,947,3,32,16,0,947,948,5,264,0,0,948,1027,1,0, - 0,0,949,950,3,86,43,0,950,951,3,32,16,0,951,952,5,75,0,0,952,953,3,32, - 16,0,953,954,5,28,0,0,954,955,3,32,16,0,955,1027,1,0,0,0,956,957,3,86, - 43,0,957,958,3,32,16,0,958,959,5,28,0,0,959,960,3,32,16,0,960,961,5,75, - 0,0,961,962,3,32,16,0,962,963,5,264,0,0,963,1027,1,0,0,0,964,965,3,86, - 43,0,965,966,3,32,16,0,966,967,5,28,0,0,967,968,3,32,16,0,968,969,5,75, - 0,0,969,970,3,32,16,0,970,1027,1,0,0,0,971,972,3,86,43,0,972,973,3,32, - 16,0,973,974,5,28,0,0,974,975,3,32,16,0,975,976,5,75,0,0,976,977,3,32, - 16,0,977,978,5,28,0,0,978,979,3,32,16,0,979,980,5,264,0,0,980,1027,1,0, - 0,0,981,982,3,86,43,0,982,983,3,32,16,0,983,984,5,28,0,0,984,985,3,32, - 16,0,985,986,5,75,0,0,986,987,3,32,16,0,987,988,5,28,0,0,988,989,3,32, - 16,0,989,1027,1,0,0,0,990,991,3,86,43,0,991,992,3,32,16,0,992,993,5,263, - 0,0,993,1027,1,0,0,0,994,995,3,86,43,0,995,996,3,32,16,0,996,997,5,75, - 0,0,997,998,3,32,16,0,998,999,5,263,0,0,999,1027,1,0,0,0,1000,1001,3,86, - 43,0,1001,1002,3,32,16,0,1002,1003,5,75,0,0,1003,1004,3,32,16,0,1004,1005, - 5,28,0,0,1005,1006,3,32,16,0,1006,1007,5,263,0,0,1007,1027,1,0,0,0,1008, - 1009,3,86,43,0,1009,1010,3,32,16,0,1010,1011,5,28,0,0,1011,1012,3,32,16, - 0,1012,1013,5,75,0,0,1013,1014,3,32,16,0,1014,1015,5,263,0,0,1015,1027, - 1,0,0,0,1016,1017,3,86,43,0,1017,1018,3,32,16,0,1018,1019,5,28,0,0,1019, - 1020,3,32,16,0,1020,1021,5,75,0,0,1021,1022,3,32,16,0,1022,1023,5,28,0, - 0,1023,1024,3,32,16,0,1024,1025,5,263,0,0,1025,1027,1,0,0,0,1026,923,1, - 0,0,0,1026,927,1,0,0,0,1026,930,1,0,0,0,1026,936,1,0,0,0,1026,941,1,0, - 0,0,1026,949,1,0,0,0,1026,956,1,0,0,0,1026,964,1,0,0,0,1026,971,1,0,0, - 0,1026,981,1,0,0,0,1026,990,1,0,0,0,1026,994,1,0,0,0,1026,1000,1,0,0,0, - 1026,1008,1,0,0,0,1026,1016,1,0,0,0,1027,89,1,0,0,0,1028,1032,5,21,0,0, - 1029,1031,3,92,46,0,1030,1029,1,0,0,0,1031,1034,1,0,0,0,1032,1030,1,0, - 0,0,1032,1033,1,0,0,0,1033,1035,1,0,0,0,1034,1032,1,0,0,0,1035,1036,3, - 2,1,0,1036,1037,3,94,47,0,1037,1038,5,180,0,0,1038,1039,5,36,0,0,1039, - 1040,5,30,0,0,1040,1041,3,300,150,0,1041,1042,5,31,0,0,1042,1043,3,94, - 47,0,1043,1055,1,0,0,0,1044,1048,5,21,0,0,1045,1047,3,92,46,0,1046,1045, - 1,0,0,0,1047,1050,1,0,0,0,1048,1046,1,0,0,0,1048,1049,1,0,0,0,1049,1051, - 1,0,0,0,1050,1048,1,0,0,0,1051,1052,3,2,1,0,1052,1053,3,94,47,0,1053,1055, - 1,0,0,0,1054,1028,1,0,0,0,1054,1044,1,0,0,0,1055,91,1,0,0,0,1056,1057, - 5,76,0,0,1057,93,1,0,0,0,1058,1061,1,0,0,0,1059,1061,5,298,0,0,1060,1058, - 1,0,0,0,1060,1059,1,0,0,0,1061,95,1,0,0,0,1062,1063,7,6,0,0,1063,97,1, - 0,0,0,1064,1066,3,96,48,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,99,1,0,0,0,1069,1067,1,0,0,0,1070,1096, - 3,102,51,0,1071,1072,5,280,0,0,1072,1073,3,168,84,0,1073,1074,6,50,-1, - 0,1074,1096,1,0,0,0,1075,1076,5,286,0,0,1076,1077,3,178,89,0,1077,1078, - 6,50,-1,0,1078,1096,1,0,0,0,1079,1080,5,286,0,0,1080,1081,3,174,87,0,1081, - 1082,6,50,-1,0,1082,1096,1,0,0,0,1083,1084,5,284,0,0,1084,1085,3,124,62, - 0,1085,1086,6,50,-1,0,1086,1096,1,0,0,0,1087,1088,5,281,0,0,1088,1089, - 3,104,52,0,1089,1090,6,50,-1,0,1090,1096,1,0,0,0,1091,1092,5,287,0,0,1092, - 1093,3,50,25,0,1093,1094,6,50,-1,0,1094,1096,1,0,0,0,1095,1070,1,0,0,0, - 1095,1071,1,0,0,0,1095,1075,1,0,0,0,1095,1079,1,0,0,0,1095,1083,1,0,0, - 0,1095,1087,1,0,0,0,1095,1091,1,0,0,0,1096,101,1,0,0,0,1097,1098,5,275, - 0,0,1098,1176,6,51,-1,0,1099,1100,5,276,0,0,1100,1101,3,32,16,0,1101,1102, - 6,51,-1,0,1102,1176,1,0,0,0,1103,1104,5,276,0,0,1104,1105,3,0,0,0,1105, - 1106,6,51,-1,0,1106,1176,1,0,0,0,1107,1108,5,277,0,0,1108,1109,3,32,16, - 0,1109,1110,6,51,-1,0,1110,1176,1,0,0,0,1111,1112,5,278,0,0,1112,1113, - 3,34,17,0,1113,1114,6,51,-1,0,1114,1176,1,0,0,0,1115,1116,5,279,0,0,1116, - 1117,3,36,18,0,1117,1118,6,51,-1,0,1118,1176,1,0,0,0,1119,1120,5,279,0, - 0,1120,1121,3,34,17,0,1121,1122,6,51,-1,0,1122,1176,1,0,0,0,1123,1124, - 5,279,0,0,1124,1125,5,30,0,0,1125,1126,3,300,150,0,1126,1127,5,31,0,0, - 1127,1128,6,51,-1,0,1128,1176,1,0,0,0,1129,1130,5,279,0,0,1130,1131,5, - 84,0,0,1131,1132,5,30,0,0,1132,1133,3,300,150,0,1133,1134,5,31,0,0,1134, - 1135,6,51,-1,0,1135,1176,1,0,0,0,1136,1137,5,282,0,0,1137,1138,3,32,16, - 0,1138,1139,6,51,-1,0,1139,1176,1,0,0,0,1140,1141,5,282,0,0,1141,1142, - 3,0,0,0,1142,1143,6,51,-1,0,1143,1176,1,0,0,0,1144,1145,5,285,0,0,1145, - 1146,3,6,3,0,1146,1147,6,51,-1,0,1147,1176,1,0,0,0,1148,1149,5,285,0,0, - 1149,1150,5,224,0,0,1150,1151,5,30,0,0,1151,1152,3,6,3,0,1152,1153,5,31, - 0,0,1153,1154,6,51,-1,0,1154,1176,1,0,0,0,1155,1156,5,285,0,0,1156,1157, - 5,84,0,0,1157,1158,5,30,0,0,1158,1159,3,300,150,0,1159,1160,5,31,0,0,1160, - 1161,6,51,-1,0,1161,1176,1,0,0,0,1162,1163,5,287,0,0,1163,1164,3,32,16, - 0,1164,1165,6,51,-1,0,1165,1176,1,0,0,0,1166,1167,5,283,0,0,1167,1173, - 6,51,-1,0,1168,1169,5,30,0,0,1169,1170,3,106,53,0,1170,1171,5,31,0,0,1171, - 1174,1,0,0,0,1172,1174,5,85,0,0,1173,1168,1,0,0,0,1173,1172,1,0,0,0,1174, - 1176,1,0,0,0,1175,1097,1,0,0,0,1175,1099,1,0,0,0,1175,1103,1,0,0,0,1175, - 1107,1,0,0,0,1175,1111,1,0,0,0,1175,1115,1,0,0,0,1175,1119,1,0,0,0,1175, - 1123,1,0,0,0,1175,1129,1,0,0,0,1175,1136,1,0,0,0,1175,1140,1,0,0,0,1175, - 1144,1,0,0,0,1175,1148,1,0,0,0,1175,1155,1,0,0,0,1175,1162,1,0,0,0,1175, - 1166,1,0,0,0,1176,103,1,0,0,0,1177,1178,3,170,85,0,1178,1179,3,138,69, - 0,1179,1180,3,112,56,0,1180,1181,6,52,-1,0,1181,105,1,0,0,0,1182,1207, - 1,0,0,0,1183,1184,3,0,0,0,1184,1185,6,53,-1,0,1185,1190,1,0,0,0,1186,1187, - 3,32,16,0,1187,1188,6,53,-1,0,1188,1190,1,0,0,0,1189,1183,1,0,0,0,1189, - 1186,1,0,0,0,1190,1191,1,0,0,0,1191,1192,5,28,0,0,1192,1194,1,0,0,0,1193, - 1189,1,0,0,0,1194,1197,1,0,0,0,1195,1193,1,0,0,0,1195,1196,1,0,0,0,1196, - 1204,1,0,0,0,1197,1195,1,0,0,0,1198,1199,3,0,0,0,1199,1200,6,53,-1,0,1200, - 1205,1,0,0,0,1201,1202,3,32,16,0,1202,1203,6,53,-1,0,1203,1205,1,0,0,0, - 1204,1198,1,0,0,0,1204,1201,1,0,0,0,1205,1207,1,0,0,0,1206,1182,1,0,0, - 0,1206,1195,1,0,0,0,1207,107,1,0,0,0,1208,1215,5,86,0,0,1209,1210,3,138, - 69,0,1210,1211,6,54,-1,0,1211,1212,5,28,0,0,1212,1214,1,0,0,0,1213,1209, - 1,0,0,0,1214,1217,1,0,0,0,1215,1213,1,0,0,0,1215,1216,1,0,0,0,1216,1218, - 1,0,0,0,1217,1215,1,0,0,0,1218,1219,3,138,69,0,1219,1220,6,54,-1,0,1220, - 1221,5,87,0,0,1221,109,1,0,0,0,1222,1229,5,42,0,0,1223,1224,3,146,73,0, - 1224,1225,6,55,-1,0,1225,1226,5,28,0,0,1226,1228,1,0,0,0,1227,1223,1,0, - 0,0,1228,1231,1,0,0,0,1229,1227,1,0,0,0,1229,1230,1,0,0,0,1230,1232,1, - 0,0,0,1231,1229,1,0,0,0,1232,1233,3,146,73,0,1233,1234,6,55,-1,0,1234, - 1235,5,43,0,0,1235,111,1,0,0,0,1236,1243,5,30,0,0,1237,1238,3,114,57,0, - 1238,1239,6,56,-1,0,1239,1240,5,28,0,0,1240,1242,1,0,0,0,1241,1237,1,0, - 0,0,1242,1245,1,0,0,0,1243,1241,1,0,0,0,1243,1244,1,0,0,0,1244,1246,1, - 0,0,0,1245,1243,1,0,0,0,1246,1247,3,114,57,0,1247,1248,6,56,-1,0,1248, - 1249,5,31,0,0,1249,1252,1,0,0,0,1250,1252,5,85,0,0,1251,1236,1,0,0,0,1251, - 1250,1,0,0,0,1252,113,1,0,0,0,1253,1254,5,177,0,0,1254,1264,6,57,-1,0, - 1255,1256,3,230,115,0,1256,1257,3,138,69,0,1257,1259,3,226,113,0,1258, - 1260,3,0,0,0,1259,1258,1,0,0,0,1259,1260,1,0,0,0,1260,1261,1,0,0,0,1261, - 1262,6,57,-1,0,1262,1264,1,0,0,0,1263,1253,1,0,0,0,1263,1255,1,0,0,0,1264, - 115,1,0,0,0,1265,1266,5,42,0,0,1266,1267,3,2,1,0,1267,1268,5,43,0,0,1268, - 1269,3,118,59,0,1269,1270,6,58,-1,0,1270,1303,1,0,0,0,1271,1272,5,42,0, - 0,1272,1273,3,174,87,0,1273,1274,5,43,0,0,1274,1275,3,118,59,0,1275,1276, - 6,58,-1,0,1276,1303,1,0,0,0,1277,1278,5,42,0,0,1278,1279,5,262,0,0,1279, - 1280,5,43,0,0,1280,1281,3,118,59,0,1281,1282,6,58,-1,0,1282,1303,1,0,0, - 0,1283,1284,5,42,0,0,1284,1285,5,198,0,0,1285,1286,3,2,1,0,1286,1287,5, - 43,0,0,1287,1288,3,118,59,0,1288,1289,6,58,-1,0,1289,1303,1,0,0,0,1290, - 1291,3,118,59,0,1291,1292,6,58,-1,0,1292,1303,1,0,0,0,1293,1294,3,174, - 87,0,1294,1295,6,58,-1,0,1295,1303,1,0,0,0,1296,1297,5,257,0,0,1297,1303, - 6,58,-1,0,1298,1299,5,258,0,0,1299,1303,6,58,-1,0,1300,1301,5,259,0,0, - 1301,1303,6,58,-1,0,1302,1265,1,0,0,0,1302,1271,1,0,0,0,1302,1277,1,0, - 0,0,1302,1283,1,0,0,0,1302,1290,1,0,0,0,1302,1293,1,0,0,0,1302,1296,1, - 0,0,0,1302,1298,1,0,0,0,1302,1300,1,0,0,0,1303,117,1,0,0,0,1304,1305,3, - 2,1,0,1305,1306,6,59,-1,0,1306,1307,5,88,0,0,1307,1309,1,0,0,0,1308,1304, - 1,0,0,0,1309,1312,1,0,0,0,1310,1308,1,0,0,0,1310,1311,1,0,0,0,1311,1313, - 1,0,0,0,1312,1310,1,0,0,0,1313,1314,3,2,1,0,1314,1315,6,59,-1,0,1315,119, - 1,0,0,0,1316,1318,3,122,61,0,1317,1316,1,0,0,0,1318,1321,1,0,0,0,1319, - 1317,1,0,0,0,1319,1320,1,0,0,0,1320,121,1,0,0,0,1321,1319,1,0,0,0,1322, - 1323,5,180,0,0,1323,1324,5,89,0,0,1324,1328,3,32,16,0,1325,1328,3,152, - 76,0,1326,1328,3,332,166,0,1327,1322,1,0,0,0,1327,1325,1,0,0,0,1327,1326, - 1,0,0,0,1328,123,1,0,0,0,1329,1330,3,116,58,0,1330,1331,6,62,-1,0,1331, - 1347,1,0,0,0,1332,1333,5,42,0,0,1333,1334,3,2,1,0,1334,1335,5,43,0,0,1335, - 1336,6,62,-1,0,1336,1347,1,0,0,0,1337,1338,5,42,0,0,1338,1339,5,198,0, - 0,1339,1340,3,2,1,0,1340,1341,5,43,0,0,1341,1342,6,62,-1,0,1342,1347,1, - 0,0,0,1343,1344,3,138,69,0,1344,1345,6,62,-1,0,1345,1347,1,0,0,0,1346, - 1329,1,0,0,0,1346,1332,1,0,0,0,1346,1337,1,0,0,0,1346,1343,1,0,0,0,1347, - 125,1,0,0,0,1348,1360,1,0,0,0,1349,1350,3,130,65,0,1350,1356,6,63,-1,0, - 1351,1352,3,128,64,0,1352,1353,6,63,-1,0,1353,1355,1,0,0,0,1354,1351,1, - 0,0,0,1355,1358,1,0,0,0,1356,1354,1,0,0,0,1356,1357,1,0,0,0,1357,1360, - 1,0,0,0,1358,1356,1,0,0,0,1359,1348,1,0,0,0,1359,1349,1,0,0,0,1360,127, - 1,0,0,0,1361,1362,5,262,0,0,1362,1384,6,64,-1,0,1363,1364,5,261,0,0,1364, - 1384,6,64,-1,0,1365,1366,5,42,0,0,1366,1367,3,32,16,0,1367,1368,5,43,0, - 0,1368,1369,6,64,-1,0,1369,1384,1,0,0,0,1370,1371,5,42,0,0,1371,1372,3, - 32,16,0,1372,1373,5,266,0,0,1373,1374,3,32,16,0,1374,1375,5,43,0,0,1375, - 1376,6,64,-1,0,1376,1384,1,0,0,0,1377,1378,5,42,0,0,1378,1379,5,266,0, - 0,1379,1380,3,32,16,0,1380,1381,5,43,0,0,1381,1382,6,64,-1,0,1382,1384, - 1,0,0,0,1383,1361,1,0,0,0,1383,1363,1,0,0,0,1383,1365,1,0,0,0,1383,1370, - 1,0,0,0,1383,1377,1,0,0,0,1384,129,1,0,0,0,1385,1531,6,65,-1,0,1386,1387, - 5,203,0,0,1387,1388,5,30,0,0,1388,1389,3,6,3,0,1389,1390,5,28,0,0,1390, - 1391,3,6,3,0,1391,1392,5,28,0,0,1392,1393,3,6,3,0,1393,1394,5,28,0,0,1394, - 1395,3,6,3,0,1395,1396,5,31,0,0,1396,1397,6,65,-1,0,1397,1531,1,0,0,0, - 1398,1399,5,203,0,0,1399,1400,5,30,0,0,1400,1401,3,6,3,0,1401,1402,5,28, - 0,0,1402,1403,3,6,3,0,1403,1404,5,31,0,0,1404,1405,6,65,-1,0,1405,1531, - 1,0,0,0,1406,1407,5,204,0,0,1407,1408,5,205,0,0,1408,1409,5,42,0,0,1409, - 1410,3,32,16,0,1410,1411,5,43,0,0,1411,1412,6,65,-1,0,1412,1531,1,0,0, - 0,1413,1414,5,204,0,0,1414,1415,5,206,0,0,1415,1416,5,42,0,0,1416,1417, - 3,32,16,0,1417,1418,5,43,0,0,1418,1419,3,126,63,0,1419,1420,6,65,-1,0, - 1420,1531,1,0,0,0,1421,1422,5,207,0,0,1422,1531,6,65,-1,0,1423,1424,5, - 208,0,0,1424,1531,6,65,-1,0,1425,1426,5,209,0,0,1426,1531,6,65,-1,0,1427, - 1428,5,201,0,0,1428,1531,6,65,-1,0,1429,1430,5,183,0,0,1430,1531,6,65, - -1,0,1431,1432,5,184,0,0,1432,1531,6,65,-1,0,1433,1434,5,185,0,0,1434, - 1531,6,65,-1,0,1435,1436,5,186,0,0,1436,1531,6,65,-1,0,1437,1438,5,187, - 0,0,1438,1531,6,65,-1,0,1439,1440,5,188,0,0,1440,1531,6,65,-1,0,1441,1442, - 5,189,0,0,1442,1531,6,65,-1,0,1443,1444,5,210,0,0,1444,1531,6,65,-1,0, - 1445,1446,5,190,0,0,1446,1531,6,65,-1,0,1447,1448,5,191,0,0,1448,1531, - 6,65,-1,0,1449,1450,5,192,0,0,1450,1531,6,65,-1,0,1451,1452,5,193,0,0, - 1452,1531,6,65,-1,0,1453,1454,5,211,0,0,1454,1531,6,65,-1,0,1455,1456, - 5,212,0,0,1456,1531,6,65,-1,0,1457,1458,5,213,0,0,1458,1531,6,65,-1,0, - 1459,1460,5,214,0,0,1460,1531,6,65,-1,0,1461,1462,5,215,0,0,1462,1531, - 6,65,-1,0,1463,1464,5,216,0,0,1464,1531,6,65,-1,0,1465,1466,5,217,0,0, - 1466,1531,6,65,-1,0,1467,1468,5,218,0,0,1468,1469,3,132,66,0,1469,1470, - 6,65,-1,0,1470,1531,1,0,0,0,1471,1472,5,219,0,0,1472,1473,3,132,66,0,1473, - 1474,6,65,-1,0,1474,1531,1,0,0,0,1475,1476,5,220,0,0,1476,1531,6,65,-1, - 0,1477,1478,5,221,0,0,1478,1479,3,132,66,0,1479,1480,6,65,-1,0,1480,1531, - 1,0,0,0,1481,1482,5,222,0,0,1482,1483,3,134,67,0,1483,1484,6,65,-1,0,1484, - 1531,1,0,0,0,1485,1486,5,222,0,0,1486,1487,3,134,67,0,1487,1488,5,28,0, - 0,1488,1489,3,6,3,0,1489,1490,6,65,-1,0,1490,1531,1,0,0,0,1491,1492,5, - 194,0,0,1492,1531,6,65,-1,0,1493,1494,5,195,0,0,1494,1531,6,65,-1,0,1495, - 1496,5,90,0,0,1496,1497,5,184,0,0,1497,1531,6,65,-1,0,1498,1499,5,90,0, - 0,1499,1500,5,185,0,0,1500,1531,6,65,-1,0,1501,1502,5,90,0,0,1502,1503, - 5,186,0,0,1503,1531,6,65,-1,0,1504,1505,5,90,0,0,1505,1506,5,187,0,0,1506, - 1531,6,65,-1,0,1507,1508,5,62,0,0,1508,1509,5,220,0,0,1509,1531,6,65,-1, - 0,1510,1511,5,223,0,0,1511,1531,6,65,-1,0,1512,1513,5,224,0,0,1513,1514, - 5,213,0,0,1514,1531,6,65,-1,0,1515,1516,5,225,0,0,1516,1531,6,65,-1,0, - 1517,1518,5,207,0,0,1518,1519,5,183,0,0,1519,1531,6,65,-1,0,1520,1521, - 5,226,0,0,1521,1531,6,65,-1,0,1522,1523,5,228,0,0,1523,1531,6,65,-1,0, - 1524,1525,5,34,0,0,1525,1526,5,227,0,0,1526,1531,6,65,-1,0,1527,1528,3, - 2,1,0,1528,1529,6,65,-1,0,1529,1531,1,0,0,0,1530,1385,1,0,0,0,1530,1386, - 1,0,0,0,1530,1398,1,0,0,0,1530,1406,1,0,0,0,1530,1413,1,0,0,0,1530,1421, - 1,0,0,0,1530,1423,1,0,0,0,1530,1425,1,0,0,0,1530,1427,1,0,0,0,1530,1429, - 1,0,0,0,1530,1431,1,0,0,0,1530,1433,1,0,0,0,1530,1435,1,0,0,0,1530,1437, - 1,0,0,0,1530,1439,1,0,0,0,1530,1441,1,0,0,0,1530,1443,1,0,0,0,1530,1445, - 1,0,0,0,1530,1447,1,0,0,0,1530,1449,1,0,0,0,1530,1451,1,0,0,0,1530,1453, - 1,0,0,0,1530,1455,1,0,0,0,1530,1457,1,0,0,0,1530,1459,1,0,0,0,1530,1461, - 1,0,0,0,1530,1463,1,0,0,0,1530,1465,1,0,0,0,1530,1467,1,0,0,0,1530,1471, - 1,0,0,0,1530,1475,1,0,0,0,1530,1477,1,0,0,0,1530,1481,1,0,0,0,1530,1485, - 1,0,0,0,1530,1491,1,0,0,0,1530,1493,1,0,0,0,1530,1495,1,0,0,0,1530,1498, - 1,0,0,0,1530,1501,1,0,0,0,1530,1504,1,0,0,0,1530,1507,1,0,0,0,1530,1510, - 1,0,0,0,1530,1512,1,0,0,0,1530,1515,1,0,0,0,1530,1517,1,0,0,0,1530,1520, - 1,0,0,0,1530,1522,1,0,0,0,1530,1524,1,0,0,0,1530,1527,1,0,0,0,1531,131, - 1,0,0,0,1532,1541,1,0,0,0,1533,1534,5,30,0,0,1534,1535,5,91,0,0,1535,1536, - 5,36,0,0,1536,1537,3,32,16,0,1537,1538,5,31,0,0,1538,1539,6,66,-1,0,1539, - 1541,1,0,0,0,1540,1532,1,0,0,0,1540,1533,1,0,0,0,1541,133,1,0,0,0,1542, - 1553,1,0,0,0,1543,1544,3,136,68,0,1544,1549,6,67,-1,0,1545,1546,7,7,0, - 0,1546,1548,6,67,-1,0,1547,1545,1,0,0,0,1548,1551,1,0,0,0,1549,1547,1, - 0,0,0,1549,1550,1,0,0,0,1550,1553,1,0,0,0,1551,1549,1,0,0,0,1552,1542, - 1,0,0,0,1552,1543,1,0,0,0,1553,135,1,0,0,0,1554,1555,5,178,0,0,1555,1635, - 6,68,-1,0,1556,1557,5,207,0,0,1557,1635,6,68,-1,0,1558,1559,5,208,0,0, - 1559,1635,6,68,-1,0,1560,1561,5,201,0,0,1561,1635,6,68,-1,0,1562,1563, - 5,183,0,0,1563,1635,6,68,-1,0,1564,1565,5,184,0,0,1565,1635,6,68,-1,0, - 1566,1567,5,185,0,0,1567,1635,6,68,-1,0,1568,1569,5,186,0,0,1569,1635, - 6,68,-1,0,1570,1571,5,187,0,0,1571,1635,6,68,-1,0,1572,1573,5,188,0,0, - 1573,1635,6,68,-1,0,1574,1575,5,189,0,0,1575,1635,6,68,-1,0,1576,1577, - 5,190,0,0,1577,1635,6,68,-1,0,1578,1579,5,191,0,0,1579,1635,6,68,-1,0, - 1580,1581,5,192,0,0,1581,1635,6,68,-1,0,1582,1583,5,193,0,0,1583,1635, - 6,68,-1,0,1584,1585,5,262,0,0,1585,1635,6,68,-1,0,1586,1587,5,211,0,0, - 1587,1635,6,68,-1,0,1588,1589,5,212,0,0,1589,1635,6,68,-1,0,1590,1591, - 5,213,0,0,1591,1635,6,68,-1,0,1592,1593,5,214,0,0,1593,1635,6,68,-1,0, - 1594,1595,5,215,0,0,1595,1635,6,68,-1,0,1596,1597,5,218,0,0,1597,1635, - 6,68,-1,0,1598,1599,5,219,0,0,1599,1635,6,68,-1,0,1600,1601,5,222,0,0, - 1601,1635,6,68,-1,0,1602,1603,5,194,0,0,1603,1635,6,68,-1,0,1604,1605, - 5,195,0,0,1605,1635,6,68,-1,0,1606,1607,5,210,0,0,1607,1635,6,68,-1,0, - 1608,1609,5,230,0,0,1609,1635,6,68,-1,0,1610,1611,5,231,0,0,1611,1635, - 6,68,-1,0,1612,1613,5,232,0,0,1613,1635,6,68,-1,0,1614,1615,5,233,0,0, - 1615,1635,6,68,-1,0,1616,1617,5,234,0,0,1617,1635,6,68,-1,0,1618,1619, - 5,235,0,0,1619,1635,6,68,-1,0,1620,1621,5,236,0,0,1621,1635,6,68,-1,0, - 1622,1623,5,237,0,0,1623,1635,6,68,-1,0,1624,1625,5,238,0,0,1625,1635, - 6,68,-1,0,1626,1627,5,239,0,0,1627,1635,6,68,-1,0,1628,1629,5,240,0,0, - 1629,1635,6,68,-1,0,1630,1631,5,241,0,0,1631,1635,6,68,-1,0,1632,1633, - 5,242,0,0,1633,1635,6,68,-1,0,1634,1554,1,0,0,0,1634,1556,1,0,0,0,1634, - 1558,1,0,0,0,1634,1560,1,0,0,0,1634,1562,1,0,0,0,1634,1564,1,0,0,0,1634, - 1566,1,0,0,0,1634,1568,1,0,0,0,1634,1570,1,0,0,0,1634,1572,1,0,0,0,1634, - 1574,1,0,0,0,1634,1576,1,0,0,0,1634,1578,1,0,0,0,1634,1580,1,0,0,0,1634, - 1582,1,0,0,0,1634,1584,1,0,0,0,1634,1586,1,0,0,0,1634,1588,1,0,0,0,1634, - 1590,1,0,0,0,1634,1592,1,0,0,0,1634,1594,1,0,0,0,1634,1596,1,0,0,0,1634, - 1598,1,0,0,0,1634,1600,1,0,0,0,1634,1602,1,0,0,0,1634,1604,1,0,0,0,1634, - 1606,1,0,0,0,1634,1608,1,0,0,0,1634,1610,1,0,0,0,1634,1612,1,0,0,0,1634, - 1614,1,0,0,0,1634,1616,1,0,0,0,1634,1618,1,0,0,0,1634,1620,1,0,0,0,1634, - 1622,1,0,0,0,1634,1624,1,0,0,0,1634,1626,1,0,0,0,1634,1628,1,0,0,0,1634, - 1630,1,0,0,0,1634,1632,1,0,0,0,1635,137,1,0,0,0,1636,1637,3,142,71,0,1637, - 1643,6,69,-1,0,1638,1639,3,140,70,0,1639,1640,6,69,-1,0,1640,1642,1,0, - 0,0,1641,1638,1,0,0,0,1642,1645,1,0,0,0,1643,1641,1,0,0,0,1643,1644,1, - 0,0,0,1644,139,1,0,0,0,1645,1643,1,0,0,0,1646,1647,5,261,0,0,1647,1676, - 6,70,-1,0,1648,1649,5,42,0,0,1649,1650,5,43,0,0,1650,1676,6,70,-1,0,1651, - 1652,3,110,55,0,1652,1653,6,70,-1,0,1653,1676,1,0,0,0,1654,1655,5,260, - 0,0,1655,1676,6,70,-1,0,1656,1657,5,262,0,0,1657,1676,6,70,-1,0,1658,1659, - 5,92,0,0,1659,1676,6,70,-1,0,1660,1661,5,93,0,0,1661,1662,5,30,0,0,1662, - 1663,3,124,62,0,1663,1664,5,31,0,0,1664,1665,6,70,-1,0,1665,1676,1,0,0, - 0,1666,1667,5,94,0,0,1667,1668,5,30,0,0,1668,1669,3,124,62,0,1669,1670, - 5,31,0,0,1670,1671,6,70,-1,0,1671,1676,1,0,0,0,1672,1673,3,108,54,0,1673, - 1674,6,70,-1,0,1674,1676,1,0,0,0,1675,1646,1,0,0,0,1675,1648,1,0,0,0,1675, - 1651,1,0,0,0,1675,1654,1,0,0,0,1675,1656,1,0,0,0,1675,1658,1,0,0,0,1675, - 1660,1,0,0,0,1675,1666,1,0,0,0,1675,1672,1,0,0,0,1676,141,1,0,0,0,1677, - 1678,5,39,0,0,1678,1679,3,116,58,0,1679,1680,6,71,-1,0,1680,1736,1,0,0, - 0,1681,1682,5,197,0,0,1682,1736,6,71,-1,0,1683,1684,5,199,0,0,1684,1685, - 5,39,0,0,1685,1686,3,116,58,0,1686,1687,6,71,-1,0,1687,1736,1,0,0,0,1688, - 1689,5,200,0,0,1689,1690,3,116,58,0,1690,1691,6,71,-1,0,1691,1736,1,0, - 0,0,1692,1693,5,226,0,0,1693,1694,3,170,85,0,1694,1695,3,138,69,0,1695, - 1696,5,262,0,0,1696,1697,3,112,56,0,1697,1698,6,71,-1,0,1698,1736,1,0, - 0,0,1699,1700,5,253,0,0,1700,1701,3,32,16,0,1701,1702,6,71,-1,0,1702,1736, - 1,0,0,0,1703,1704,5,252,0,0,1704,1705,3,32,16,0,1705,1706,6,71,-1,0,1706, - 1736,1,0,0,0,1707,1708,5,253,0,0,1708,1709,3,2,1,0,1709,1710,6,71,-1,0, - 1710,1736,1,0,0,0,1711,1712,5,252,0,0,1712,1713,3,2,1,0,1713,1714,6,71, - -1,0,1714,1736,1,0,0,0,1715,1716,5,254,0,0,1716,1736,6,71,-1,0,1717,1718, - 5,201,0,0,1718,1736,6,71,-1,0,1719,1720,3,148,74,0,1720,1721,6,71,-1,0, - 1721,1736,1,0,0,0,1722,1723,3,150,75,0,1723,1724,6,71,-1,0,1724,1736,1, - 0,0,0,1725,1726,3,144,72,0,1726,1727,6,71,-1,0,1727,1736,1,0,0,0,1728, - 1729,3,2,1,0,1729,1730,6,71,-1,0,1730,1736,1,0,0,0,1731,1732,5,177,0,0, - 1732,1733,3,138,69,0,1733,1734,6,71,-1,0,1734,1736,1,0,0,0,1735,1677,1, - 0,0,0,1735,1681,1,0,0,0,1735,1683,1,0,0,0,1735,1688,1,0,0,0,1735,1692, - 1,0,0,0,1735,1699,1,0,0,0,1735,1703,1,0,0,0,1735,1707,1,0,0,0,1735,1711, - 1,0,0,0,1735,1715,1,0,0,0,1735,1717,1,0,0,0,1735,1719,1,0,0,0,1735,1722, - 1,0,0,0,1735,1725,1,0,0,0,1735,1728,1,0,0,0,1735,1731,1,0,0,0,1736,143, - 1,0,0,0,1737,1738,5,181,0,0,1738,1776,6,72,-1,0,1739,1740,5,182,0,0,1740, - 1776,6,72,-1,0,1741,1742,5,183,0,0,1742,1776,6,72,-1,0,1743,1744,5,184, - 0,0,1744,1776,6,72,-1,0,1745,1746,5,185,0,0,1746,1776,6,72,-1,0,1747,1748, - 5,186,0,0,1748,1776,6,72,-1,0,1749,1750,5,187,0,0,1750,1776,6,72,-1,0, - 1751,1752,5,188,0,0,1752,1776,6,72,-1,0,1753,1754,5,189,0,0,1754,1776, - 6,72,-1,0,1755,1756,5,190,0,0,1756,1776,6,72,-1,0,1757,1758,5,191,0,0, - 1758,1776,6,72,-1,0,1759,1760,5,192,0,0,1760,1776,6,72,-1,0,1761,1762, - 5,193,0,0,1762,1776,6,72,-1,0,1763,1764,5,90,0,0,1764,1765,5,184,0,0,1765, - 1776,6,72,-1,0,1766,1767,5,90,0,0,1767,1768,5,185,0,0,1768,1776,6,72,-1, - 0,1769,1770,5,90,0,0,1770,1771,5,186,0,0,1771,1776,6,72,-1,0,1772,1773, - 5,90,0,0,1773,1774,5,187,0,0,1774,1776,6,72,-1,0,1775,1737,1,0,0,0,1775, - 1739,1,0,0,0,1775,1741,1,0,0,0,1775,1743,1,0,0,0,1775,1745,1,0,0,0,1775, - 1747,1,0,0,0,1775,1749,1,0,0,0,1775,1751,1,0,0,0,1775,1753,1,0,0,0,1775, - 1755,1,0,0,0,1775,1757,1,0,0,0,1775,1759,1,0,0,0,1775,1761,1,0,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, - 145,1,0,0,0,1777,1792,1,0,0,0,1778,1792,5,177,0,0,1779,1780,3,32,16,0, - 1780,1781,6,73,-1,0,1781,1792,1,0,0,0,1782,1783,3,32,16,0,1783,1784,5, - 177,0,0,1784,1785,3,32,16,0,1785,1786,6,73,-1,0,1786,1792,1,0,0,0,1787, - 1788,3,32,16,0,1788,1789,5,177,0,0,1789,1790,6,73,-1,0,1790,1792,1,0,0, - 0,1791,1777,1,0,0,0,1791,1778,1,0,0,0,1791,1779,1,0,0,0,1791,1782,1,0, - 0,0,1791,1787,1,0,0,0,1792,147,1,0,0,0,1793,1794,5,1,0,0,1794,1795,5,194, - 0,0,1795,1796,6,74,-1,0,1796,149,1,0,0,0,1797,1801,5,1,0,0,1798,1799,5, - 90,0,0,1799,1802,5,194,0,0,1800,1802,5,195,0,0,1801,1798,1,0,0,0,1801, - 1800,1,0,0,0,1802,1803,1,0,0,0,1803,1804,6,75,-1,0,1804,151,1,0,0,0,1805, - 1806,5,294,0,0,1806,1807,3,166,83,0,1807,1808,3,124,62,0,1808,1809,5,30, - 0,0,1809,1810,3,158,79,0,1810,1811,5,31,0,0,1811,1853,1,0,0,0,1812,1813, - 5,294,0,0,1813,1814,3,166,83,0,1814,1815,3,124,62,0,1815,1816,5,36,0,0, - 1816,1817,5,17,0,0,1817,1818,3,52,26,0,1818,1819,5,18,0,0,1819,1853,1, - 0,0,0,1820,1821,5,294,0,0,1821,1822,3,166,83,0,1822,1823,3,124,62,0,1823, - 1853,1,0,0,0,1824,1825,5,295,0,0,1825,1826,3,166,83,0,1826,1828,5,36,0, - 0,1827,1829,5,84,0,0,1828,1827,1,0,0,0,1828,1829,1,0,0,0,1829,1830,1,0, - 0,0,1830,1831,5,30,0,0,1831,1832,3,300,150,0,1832,1833,5,31,0,0,1833,1853, - 1,0,0,0,1834,1835,5,295,0,0,1835,1836,3,166,83,0,1836,1837,5,84,0,0,1837, - 1838,5,30,0,0,1838,1839,3,300,150,0,1839,1840,5,31,0,0,1840,1853,1,0,0, - 0,1841,1842,5,295,0,0,1842,1843,3,166,83,0,1843,1844,3,6,3,0,1844,1853, - 1,0,0,0,1845,1846,5,295,0,0,1846,1847,3,166,83,0,1847,1848,5,36,0,0,1848, - 1849,5,17,0,0,1849,1850,3,154,77,0,1850,1851,5,18,0,0,1851,1853,1,0,0, - 0,1852,1805,1,0,0,0,1852,1812,1,0,0,0,1852,1820,1,0,0,0,1852,1824,1,0, - 0,0,1852,1834,1,0,0,0,1852,1841,1,0,0,0,1852,1845,1,0,0,0,1853,153,1,0, - 0,0,1854,1865,1,0,0,0,1855,1856,3,156,78,0,1856,1857,5,28,0,0,1857,1859, - 1,0,0,0,1858,1855,1,0,0,0,1859,1862,1,0,0,0,1860,1858,1,0,0,0,1860,1861, - 1,0,0,0,1861,1863,1,0,0,0,1862,1860,1,0,0,0,1863,1865,3,156,78,0,1864, - 1854,1,0,0,0,1864,1860,1,0,0,0,1865,155,1,0,0,0,1866,1867,5,39,0,0,1867, - 1868,5,264,0,0,1868,1869,5,36,0,0,1869,1870,5,17,0,0,1870,1871,3,56,28, - 0,1871,1872,5,18,0,0,1872,1880,1,0,0,0,1873,1874,3,124,62,0,1874,1875, - 5,36,0,0,1875,1876,5,17,0,0,1876,1877,3,56,28,0,1877,1878,5,18,0,0,1878, - 1880,1,0,0,0,1879,1866,1,0,0,0,1879,1873,1,0,0,0,1880,157,1,0,0,0,1881, - 1882,3,160,80,0,1882,1883,5,28,0,0,1883,1885,1,0,0,0,1884,1881,1,0,0,0, - 1885,1888,1,0,0,0,1886,1884,1,0,0,0,1886,1887,1,0,0,0,1887,1889,1,0,0, - 0,1888,1886,1,0,0,0,1889,1890,3,160,80,0,1890,159,1,0,0,0,1891,1892,3, - 6,3,0,1892,1893,5,36,0,0,1893,1894,3,164,82,0,1894,161,1,0,0,0,1895,1896, - 7,8,0,0,1896,163,1,0,0,0,1897,1932,3,162,81,0,1898,1932,3,32,16,0,1899, - 1900,5,186,0,0,1900,1901,5,30,0,0,1901,1902,3,32,16,0,1902,1903,5,31,0, - 0,1903,1932,1,0,0,0,1904,1932,3,6,3,0,1905,1906,3,116,58,0,1906,1907,5, - 30,0,0,1907,1908,5,184,0,0,1908,1909,5,75,0,0,1909,1910,3,32,16,0,1910, - 1911,5,31,0,0,1911,1932,1,0,0,0,1912,1913,3,116,58,0,1913,1914,5,30,0, - 0,1914,1915,5,185,0,0,1915,1916,5,75,0,0,1916,1917,3,32,16,0,1917,1918, - 5,31,0,0,1918,1932,1,0,0,0,1919,1920,3,116,58,0,1920,1921,5,30,0,0,1921, - 1922,5,186,0,0,1922,1923,5,75,0,0,1923,1924,3,32,16,0,1924,1925,5,31,0, - 0,1925,1932,1,0,0,0,1926,1927,3,116,58,0,1927,1928,5,30,0,0,1928,1929, - 3,32,16,0,1929,1930,5,31,0,0,1930,1932,1,0,0,0,1931,1897,1,0,0,0,1931, - 1898,1,0,0,0,1931,1899,1,0,0,0,1931,1904,1,0,0,0,1931,1905,1,0,0,0,1931, - 1912,1,0,0,0,1931,1919,1,0,0,0,1931,1926,1,0,0,0,1932,165,1,0,0,0,1933, - 1934,7,9,0,0,1934,167,1,0,0,0,1935,1936,3,170,85,0,1936,1937,3,138,69, - 0,1937,1938,3,124,62,0,1938,1939,5,176,0,0,1939,1941,3,242,121,0,1940, - 1942,3,108,54,0,1941,1940,1,0,0,0,1941,1942,1,0,0,0,1942,1943,1,0,0,0, - 1943,1944,3,112,56,0,1944,1945,6,84,-1,0,1945,1978,1,0,0,0,1946,1947,3, - 170,85,0,1947,1948,3,138,69,0,1948,1949,3,124,62,0,1949,1950,5,176,0,0, - 1950,1951,3,242,121,0,1951,1952,3,196,98,0,1952,1953,3,112,56,0,1953,1954, - 6,84,-1,0,1954,1978,1,0,0,0,1955,1956,3,170,85,0,1956,1957,3,138,69,0, - 1957,1959,3,242,121,0,1958,1960,3,108,54,0,1959,1958,1,0,0,0,1959,1960, - 1,0,0,0,1960,1961,1,0,0,0,1961,1962,3,112,56,0,1962,1963,6,84,-1,0,1963, - 1978,1,0,0,0,1964,1965,3,170,85,0,1965,1966,3,138,69,0,1966,1967,3,242, - 121,0,1967,1968,3,196,98,0,1968,1969,3,112,56,0,1969,1970,6,84,-1,0,1970, - 1978,1,0,0,0,1971,1972,3,174,87,0,1972,1973,6,84,-1,0,1973,1978,1,0,0, - 0,1974,1975,3,2,1,0,1975,1976,6,84,-1,0,1976,1978,1,0,0,0,1977,1935,1, - 0,0,0,1977,1946,1,0,0,0,1977,1955,1,0,0,0,1977,1964,1,0,0,0,1977,1971, - 1,0,0,0,1977,1974,1,0,0,0,1978,169,1,0,0,0,1979,1980,5,243,0,0,1980,1981, - 3,170,85,0,1981,1982,6,85,-1,0,1982,1997,1,0,0,0,1983,1984,5,244,0,0,1984, - 1985,3,170,85,0,1985,1986,6,85,-1,0,1986,1997,1,0,0,0,1987,1988,3,172, - 86,0,1988,1989,6,85,-1,0,1989,1997,1,0,0,0,1990,1991,5,112,0,0,1991,1992, - 5,30,0,0,1992,1993,3,32,16,0,1993,1994,5,31,0,0,1994,1995,6,85,-1,0,1995, - 1997,1,0,0,0,1996,1979,1,0,0,0,1996,1983,1,0,0,0,1996,1987,1,0,0,0,1996, - 1990,1,0,0,0,1997,171,1,0,0,0,1998,2018,1,0,0,0,1999,2000,5,245,0,0,2000, - 2018,6,86,-1,0,2001,2002,5,246,0,0,2002,2018,6,86,-1,0,2003,2004,5,247, - 0,0,2004,2005,5,248,0,0,2005,2018,6,86,-1,0,2006,2007,5,247,0,0,2007,2008, - 5,249,0,0,2008,2018,6,86,-1,0,2009,2010,5,247,0,0,2010,2011,5,250,0,0, - 2011,2018,6,86,-1,0,2012,2013,5,247,0,0,2013,2014,5,251,0,0,2014,2018, - 6,86,-1,0,2015,2016,5,247,0,0,2016,2018,6,86,-1,0,2017,1998,1,0,0,0,2017, - 1999,1,0,0,0,2017,2001,1,0,0,0,2017,2003,1,0,0,0,2017,2006,1,0,0,0,2017, - 2009,1,0,0,0,2017,2012,1,0,0,0,2017,2015,1,0,0,0,2018,173,1,0,0,0,2019, - 2020,5,113,0,0,2020,2021,5,30,0,0,2021,2022,3,32,16,0,2022,2023,5,31,0, - 0,2023,2024,6,87,-1,0,2024,175,1,0,0,0,2025,2026,5,226,0,0,2026,2027,3, - 168,84,0,2027,2028,6,88,-1,0,2028,2037,1,0,0,0,2029,2030,5,37,0,0,2030, - 2031,3,178,89,0,2031,2032,6,88,-1,0,2032,2037,1,0,0,0,2033,2034,3,174, - 87,0,2034,2035,6,88,-1,0,2035,2037,1,0,0,0,2036,2025,1,0,0,0,2036,2029, - 1,0,0,0,2036,2033,1,0,0,0,2037,177,1,0,0,0,2038,2039,3,138,69,0,2039,2040, - 3,124,62,0,2040,2041,5,176,0,0,2041,2042,3,2,1,0,2042,2043,6,89,-1,0,2043, - 2052,1,0,0,0,2044,2045,3,138,69,0,2045,2046,3,2,1,0,2046,2047,6,89,-1, - 0,2047,2052,1,0,0,0,2048,2049,3,2,1,0,2049,2050,6,89,-1,0,2050,2052,1, - 0,0,0,2051,2038,1,0,0,0,2051,2044,1,0,0,0,2051,2048,1,0,0,0,2052,179,1, - 0,0,0,2053,2054,3,124,62,0,2054,2055,6,90,-1,0,2055,2056,5,28,0,0,2056, - 2058,1,0,0,0,2057,2053,1,0,0,0,2058,2061,1,0,0,0,2059,2057,1,0,0,0,2059, - 2060,1,0,0,0,2060,2062,1,0,0,0,2061,2059,1,0,0,0,2062,2063,3,124,62,0, - 2063,2064,6,90,-1,0,2064,181,1,0,0,0,2065,2072,1,0,0,0,2066,2067,5,86, - 0,0,2067,2068,3,190,95,0,2068,2069,5,87,0,0,2069,2070,6,91,-1,0,2070,2072, - 1,0,0,0,2071,2065,1,0,0,0,2071,2066,1,0,0,0,2072,183,1,0,0,0,2073,2074, - 5,266,0,0,2074,2092,6,92,-1,0,2075,2076,5,114,0,0,2076,2092,6,92,-1,0, - 2077,2078,5,39,0,0,2078,2092,6,92,-1,0,2079,2080,5,200,0,0,2080,2092,6, - 92,-1,0,2081,2082,5,115,0,0,2082,2092,6,92,-1,0,2083,2084,5,116,0,0,2084, - 2092,6,92,-1,0,2085,2086,5,70,0,0,2086,2087,5,30,0,0,2087,2088,3,32,16, - 0,2088,2089,5,31,0,0,2089,2090,6,92,-1,0,2090,2092,1,0,0,0,2091,2073,1, - 0,0,0,2091,2075,1,0,0,0,2091,2077,1,0,0,0,2091,2079,1,0,0,0,2091,2081, - 1,0,0,0,2091,2083,1,0,0,0,2091,2085,1,0,0,0,2092,185,1,0,0,0,2093,2094, - 3,184,92,0,2094,2095,6,93,-1,0,2095,2097,1,0,0,0,2096,2093,1,0,0,0,2097, - 2100,1,0,0,0,2098,2096,1,0,0,0,2098,2099,1,0,0,0,2099,187,1,0,0,0,2100, - 2098,1,0,0,0,2101,2103,3,186,93,0,2102,2104,3,192,96,0,2103,2102,1,0,0, - 0,2103,2104,1,0,0,0,2104,2105,1,0,0,0,2105,2106,3,2,1,0,2106,2107,6,94, - -1,0,2107,189,1,0,0,0,2108,2109,3,188,94,0,2109,2110,6,95,-1,0,2110,2111, - 5,28,0,0,2111,2113,1,0,0,0,2112,2108,1,0,0,0,2113,2116,1,0,0,0,2114,2112, - 1,0,0,0,2114,2115,1,0,0,0,2115,2117,1,0,0,0,2116,2114,1,0,0,0,2117,2118, - 3,188,94,0,2118,2119,6,95,-1,0,2119,191,1,0,0,0,2120,2121,5,30,0,0,2121, - 2122,3,180,90,0,2122,2123,5,31,0,0,2123,2124,6,96,-1,0,2124,193,1,0,0, - 0,2125,2127,3,196,98,0,2126,2125,1,0,0,0,2126,2127,1,0,0,0,2127,2128,1, - 0,0,0,2128,2129,6,97,-1,0,2129,195,1,0,0,0,2130,2131,5,86,0,0,2131,2132, - 5,42,0,0,2132,2133,3,32,16,0,2133,2134,5,43,0,0,2134,2135,5,87,0,0,2135, - 2136,6,98,-1,0,2136,197,1,0,0,0,2137,2138,3,234,117,0,2138,2139,5,17,0, - 0,2139,2140,3,246,123,0,2140,2141,5,18,0,0,2141,2288,1,0,0,0,2142,2143, - 3,74,37,0,2143,2144,5,17,0,0,2144,2145,3,82,41,0,2145,2146,5,18,0,0,2146, - 2288,1,0,0,0,2147,2148,3,210,105,0,2148,2149,6,99,-1,0,2149,2150,5,17, - 0,0,2150,2151,3,214,107,0,2151,2152,5,18,0,0,2152,2288,1,0,0,0,2153,2154, - 3,218,109,0,2154,2155,6,99,-1,0,2155,2156,5,17,0,0,2156,2157,3,222,111, - 0,2157,2158,5,18,0,0,2158,2288,1,0,0,0,2159,2288,3,200,100,0,2160,2161, - 3,284,142,0,2161,2162,6,99,-1,0,2162,2288,1,0,0,0,2163,2164,3,152,76,0, - 2164,2165,6,99,-1,0,2165,2288,1,0,0,0,2166,2167,3,88,44,0,2167,2168,6, - 99,-1,0,2168,2288,1,0,0,0,2169,2170,3,330,165,0,2170,2171,6,99,-1,0,2171, - 2288,1,0,0,0,2172,2173,5,117,0,0,2173,2174,3,32,16,0,2174,2175,6,99,-1, - 0,2175,2288,1,0,0,0,2176,2177,5,118,0,0,2177,2178,3,32,16,0,2178,2179, - 6,99,-1,0,2179,2288,1,0,0,0,2180,2181,3,346,173,0,2181,2182,5,17,0,0,2182, - 2183,3,350,175,0,2183,2184,5,18,0,0,2184,2185,6,99,-1,0,2185,2288,1,0, - 0,0,2186,2187,5,302,0,0,2187,2188,3,124,62,0,2188,2189,5,176,0,0,2189, - 2190,3,242,121,0,2190,2191,5,119,0,0,2191,2192,3,170,85,0,2192,2193,3, - 138,69,0,2193,2194,3,124,62,0,2194,2195,5,176,0,0,2195,2196,3,242,121, - 0,2196,2197,3,112,56,0,2197,2198,6,99,-1,0,2198,2288,1,0,0,0,2199,2200, - 5,302,0,0,2200,2201,5,226,0,0,2201,2202,3,170,85,0,2202,2203,3,138,69, - 0,2203,2204,3,124,62,0,2204,2205,5,176,0,0,2205,2206,3,242,121,0,2206, - 2207,3,194,97,0,2207,2208,3,112,56,0,2208,2209,5,119,0,0,2209,2210,5,226, - 0,0,2210,2211,3,170,85,0,2211,2212,3,138,69,0,2212,2213,3,124,62,0,2213, - 2214,5,176,0,0,2214,2215,3,242,121,0,2215,2216,3,194,97,0,2216,2217,3, - 112,56,0,2217,2218,6,99,-1,0,2218,2288,1,0,0,0,2219,2220,3,26,13,0,2220, - 2221,6,99,-1,0,2221,2288,1,0,0,0,2222,2223,3,40,20,0,2223,2224,6,99,-1, - 0,2224,2288,1,0,0,0,2225,2226,5,255,0,0,2226,2227,5,196,0,0,2227,2228, - 5,42,0,0,2228,2229,3,32,16,0,2229,2230,5,43,0,0,2230,2236,6,99,-1,0,2231, - 2232,3,330,165,0,2232,2233,6,99,-1,0,2233,2235,1,0,0,0,2234,2231,1,0,0, - 0,2235,2238,1,0,0,0,2236,2234,1,0,0,0,2236,2237,1,0,0,0,2237,2288,1,0, - 0,0,2238,2236,1,0,0,0,2239,2240,5,255,0,0,2240,2241,5,196,0,0,2241,2242, - 3,2,1,0,2242,2248,6,99,-1,0,2243,2244,3,330,165,0,2244,2245,6,99,-1,0, - 2245,2247,1,0,0,0,2246,2243,1,0,0,0,2247,2250,1,0,0,0,2248,2246,1,0,0, - 0,2248,2249,1,0,0,0,2249,2288,1,0,0,0,2250,2248,1,0,0,0,2251,2252,5,255, - 0,0,2252,2253,5,256,0,0,2253,2254,5,42,0,0,2254,2255,3,32,16,0,2255,2256, - 5,43,0,0,2256,2257,5,28,0,0,2257,2258,3,124,62,0,2258,2264,6,99,-1,0,2259, - 2260,3,330,165,0,2260,2261,6,99,-1,0,2261,2263,1,0,0,0,2262,2259,1,0,0, - 0,2263,2266,1,0,0,0,2264,2262,1,0,0,0,2264,2265,1,0,0,0,2265,2288,1,0, - 0,0,2266,2264,1,0,0,0,2267,2268,5,255,0,0,2268,2269,5,256,0,0,2269,2270, - 3,2,1,0,2270,2271,5,28,0,0,2271,2272,3,124,62,0,2272,2278,6,99,-1,0,2273, - 2274,3,330,165,0,2274,2275,6,99,-1,0,2275,2277,1,0,0,0,2276,2273,1,0,0, - 0,2277,2280,1,0,0,0,2278,2276,1,0,0,0,2278,2279,1,0,0,0,2279,2288,1,0, - 0,0,2280,2278,1,0,0,0,2281,2282,5,120,0,0,2282,2283,5,196,0,0,2283,2284, - 3,124,62,0,2284,2285,3,44,22,0,2285,2286,6,99,-1,0,2286,2288,1,0,0,0,2287, - 2137,1,0,0,0,2287,2142,1,0,0,0,2287,2147,1,0,0,0,2287,2153,1,0,0,0,2287, - 2159,1,0,0,0,2287,2160,1,0,0,0,2287,2163,1,0,0,0,2287,2166,1,0,0,0,2287, - 2169,1,0,0,0,2287,2172,1,0,0,0,2287,2176,1,0,0,0,2287,2180,1,0,0,0,2287, - 2186,1,0,0,0,2287,2199,1,0,0,0,2287,2219,1,0,0,0,2287,2222,1,0,0,0,2287, - 2225,1,0,0,0,2287,2239,1,0,0,0,2287,2251,1,0,0,0,2287,2267,1,0,0,0,2287, - 2281,1,0,0,0,2288,199,1,0,0,0,2289,2290,5,121,0,0,2290,2302,3,208,104, - 0,2291,2292,3,202,101,0,2292,2293,6,100,-1,0,2293,2301,1,0,0,0,2294,2295, - 5,122,0,0,2295,2296,5,30,0,0,2296,2297,3,228,114,0,2297,2298,5,31,0,0, - 2298,2299,6,100,-1,0,2299,2301,1,0,0,0,2300,2291,1,0,0,0,2300,2294,1,0, - 0,0,2301,2304,1,0,0,0,2302,2300,1,0,0,0,2302,2303,1,0,0,0,2303,2305,1, - 0,0,0,2304,2302,1,0,0,0,2305,2306,3,138,69,0,2306,2307,3,2,1,0,2307,2308, - 3,204,102,0,2308,2309,3,206,103,0,2309,2310,6,100,-1,0,2310,201,1,0,0, - 0,2311,2312,5,123,0,0,2312,2346,6,101,-1,0,2313,2314,5,51,0,0,2314,2346, - 6,101,-1,0,2315,2316,5,52,0,0,2316,2346,6,101,-1,0,2317,2318,5,63,0,0, - 2318,2346,6,101,-1,0,2319,2320,5,124,0,0,2320,2346,6,101,-1,0,2321,2322, - 5,69,0,0,2322,2346,6,101,-1,0,2323,2324,5,68,0,0,2324,2346,6,101,-1,0, - 2325,2326,5,64,0,0,2326,2346,6,101,-1,0,2327,2328,5,65,0,0,2328,2346,6, - 101,-1,0,2329,2330,5,66,0,0,2330,2346,6,101,-1,0,2331,2332,5,125,0,0,2332, - 2346,6,101,-1,0,2333,2334,5,126,0,0,2334,2346,6,101,-1,0,2335,2336,5,127, - 0,0,2336,2346,6,101,-1,0,2337,2338,5,16,0,0,2338,2346,6,101,-1,0,2339, - 2340,5,70,0,0,2340,2341,5,30,0,0,2341,2342,3,32,16,0,2342,2343,5,31,0, - 0,2343,2344,6,101,-1,0,2344,2346,1,0,0,0,2345,2311,1,0,0,0,2345,2313,1, - 0,0,0,2345,2315,1,0,0,0,2345,2317,1,0,0,0,2345,2319,1,0,0,0,2345,2321, - 1,0,0,0,2345,2323,1,0,0,0,2345,2325,1,0,0,0,2345,2327,1,0,0,0,2345,2329, - 1,0,0,0,2345,2331,1,0,0,0,2345,2333,1,0,0,0,2345,2335,1,0,0,0,2345,2337, - 1,0,0,0,2345,2339,1,0,0,0,2346,203,1,0,0,0,2347,2357,1,0,0,0,2348,2349, - 5,44,0,0,2349,2350,3,0,0,0,2350,2351,6,102,-1,0,2351,2357,1,0,0,0,2352, - 2353,5,44,0,0,2353,2354,3,32,16,0,2354,2355,6,102,-1,0,2355,2357,1,0,0, - 0,2356,2347,1,0,0,0,2356,2348,1,0,0,0,2356,2352,1,0,0,0,2357,205,1,0,0, - 0,2358,2364,1,0,0,0,2359,2360,5,36,0,0,2360,2361,3,304,152,0,2361,2362, - 6,103,-1,0,2362,2364,1,0,0,0,2363,2358,1,0,0,0,2363,2359,1,0,0,0,2364, - 207,1,0,0,0,2365,2372,1,0,0,0,2366,2367,5,42,0,0,2367,2368,3,32,16,0,2368, - 2369,5,43,0,0,2369,2370,6,104,-1,0,2370,2372,1,0,0,0,2371,2365,1,0,0,0, - 2371,2366,1,0,0,0,2372,209,1,0,0,0,2373,2379,5,128,0,0,2374,2375,3,212, - 106,0,2375,2376,6,105,-1,0,2376,2378,1,0,0,0,2377,2374,1,0,0,0,2378,2381, - 1,0,0,0,2379,2377,1,0,0,0,2379,2380,1,0,0,0,2380,2382,1,0,0,0,2381,2379, - 1,0,0,0,2382,2383,3,124,62,0,2383,2384,3,2,1,0,2384,2385,6,105,-1,0,2385, - 2399,1,0,0,0,2386,2392,5,128,0,0,2387,2388,3,212,106,0,2388,2389,6,105, - -1,0,2389,2391,1,0,0,0,2390,2387,1,0,0,0,2391,2394,1,0,0,0,2392,2390,1, - 0,0,0,2392,2393,1,0,0,0,2393,2395,1,0,0,0,2394,2392,1,0,0,0,2395,2396, - 3,2,1,0,2396,2397,6,105,-1,0,2397,2399,1,0,0,0,2398,2373,1,0,0,0,2398, - 2386,1,0,0,0,2399,211,1,0,0,0,2400,2401,5,69,0,0,2401,2405,6,106,-1,0, - 2402,2403,5,68,0,0,2403,2405,6,106,-1,0,2404,2400,1,0,0,0,2404,2402,1, - 0,0,0,2405,213,1,0,0,0,2406,2408,3,216,108,0,2407,2406,1,0,0,0,2408,2411, - 1,0,0,0,2409,2407,1,0,0,0,2409,2410,1,0,0,0,2410,215,1,0,0,0,2411,2409, - 1,0,0,0,2412,2413,5,129,0,0,2413,2414,3,168,84,0,2414,2415,6,108,-1,0, - 2415,2439,1,0,0,0,2416,2417,5,130,0,0,2417,2418,3,168,84,0,2418,2419,6, - 108,-1,0,2419,2439,1,0,0,0,2420,2421,5,131,0,0,2421,2422,3,168,84,0,2422, - 2423,6,108,-1,0,2423,2439,1,0,0,0,2424,2425,5,132,0,0,2425,2426,3,168, - 84,0,2426,2427,6,108,-1,0,2427,2439,1,0,0,0,2428,2429,3,88,44,0,2429,2430, - 6,108,-1,0,2430,2439,1,0,0,0,2431,2432,3,330,165,0,2432,2433,6,108,-1, - 0,2433,2439,1,0,0,0,2434,2435,3,26,13,0,2435,2436,6,108,-1,0,2436,2439, - 1,0,0,0,2437,2439,3,40,20,0,2438,2412,1,0,0,0,2438,2416,1,0,0,0,2438,2420, - 1,0,0,0,2438,2424,1,0,0,0,2438,2428,1,0,0,0,2438,2431,1,0,0,0,2438,2434, - 1,0,0,0,2438,2437,1,0,0,0,2439,217,1,0,0,0,2440,2446,5,133,0,0,2441,2442, - 3,220,110,0,2442,2443,6,109,-1,0,2443,2445,1,0,0,0,2444,2441,1,0,0,0,2445, - 2448,1,0,0,0,2446,2444,1,0,0,0,2446,2447,1,0,0,0,2447,2449,1,0,0,0,2448, - 2446,1,0,0,0,2449,2450,3,170,85,0,2450,2451,3,138,69,0,2451,2452,3,2,1, - 0,2452,2453,3,112,56,0,2453,2454,3,206,103,0,2454,2455,6,109,-1,0,2455, - 219,1,0,0,0,2456,2457,5,69,0,0,2457,2461,6,110,-1,0,2458,2459,5,68,0,0, - 2459,2461,6,110,-1,0,2460,2456,1,0,0,0,2460,2458,1,0,0,0,2461,221,1,0, - 0,0,2462,2464,3,224,112,0,2463,2462,1,0,0,0,2464,2467,1,0,0,0,2465,2463, - 1,0,0,0,2465,2466,1,0,0,0,2466,223,1,0,0,0,2467,2465,1,0,0,0,2468,2469, - 5,134,0,0,2469,2470,3,168,84,0,2470,2471,6,112,-1,0,2471,2491,1,0,0,0, - 2472,2473,5,135,0,0,2473,2474,3,168,84,0,2474,2475,6,112,-1,0,2475,2491, - 1,0,0,0,2476,2477,5,132,0,0,2477,2478,3,168,84,0,2478,2479,6,112,-1,0, - 2479,2491,1,0,0,0,2480,2481,3,330,165,0,2481,2482,6,112,-1,0,2482,2491, - 1,0,0,0,2483,2484,3,88,44,0,2484,2485,6,112,-1,0,2485,2491,1,0,0,0,2486, - 2487,3,26,13,0,2487,2488,6,112,-1,0,2488,2491,1,0,0,0,2489,2491,3,40,20, - 0,2490,2468,1,0,0,0,2490,2472,1,0,0,0,2490,2476,1,0,0,0,2490,2480,1,0, - 0,0,2490,2483,1,0,0,0,2490,2486,1,0,0,0,2490,2489,1,0,0,0,2491,225,1,0, - 0,0,2492,2500,6,113,-1,0,2493,2494,5,122,0,0,2494,2495,5,30,0,0,2495,2496, - 3,228,114,0,2496,2497,5,31,0,0,2497,2498,6,113,-1,0,2498,2500,1,0,0,0, - 2499,2492,1,0,0,0,2499,2493,1,0,0,0,2500,227,1,0,0,0,2501,2502,3,126,63, - 0,2502,2503,6,114,-1,0,2503,2515,1,0,0,0,2504,2508,5,17,0,0,2505,2506, - 3,302,151,0,2506,2507,6,114,-1,0,2507,2509,1,0,0,0,2508,2505,1,0,0,0,2509, - 2510,1,0,0,0,2510,2508,1,0,0,0,2510,2511,1,0,0,0,2511,2512,1,0,0,0,2512, - 2513,5,18,0,0,2513,2515,1,0,0,0,2514,2501,1,0,0,0,2514,2504,1,0,0,0,2515, - 229,1,0,0,0,2516,2517,3,232,116,0,2517,2518,6,115,-1,0,2518,2520,1,0,0, - 0,2519,2516,1,0,0,0,2520,2523,1,0,0,0,2521,2519,1,0,0,0,2521,2522,1,0, - 0,0,2522,231,1,0,0,0,2523,2521,1,0,0,0,2524,2525,5,42,0,0,2525,2526,5, - 136,0,0,2526,2527,5,43,0,0,2527,2542,6,116,-1,0,2528,2529,5,42,0,0,2529, - 2530,5,137,0,0,2530,2531,5,43,0,0,2531,2542,6,116,-1,0,2532,2533,5,42, - 0,0,2533,2534,5,138,0,0,2534,2535,5,43,0,0,2535,2542,6,116,-1,0,2536,2537, - 5,42,0,0,2537,2538,3,32,16,0,2538,2539,5,43,0,0,2539,2540,6,116,-1,0,2540, - 2542,1,0,0,0,2541,2524,1,0,0,0,2541,2528,1,0,0,0,2541,2532,1,0,0,0,2541, - 2536,1,0,0,0,2542,233,1,0,0,0,2543,2552,5,139,0,0,2544,2545,3,236,118, - 0,2545,2546,6,117,-1,0,2546,2551,1,0,0,0,2547,2548,3,238,119,0,2548,2549, - 6,117,-1,0,2549,2551,1,0,0,0,2550,2544,1,0,0,0,2550,2547,1,0,0,0,2551, - 2554,1,0,0,0,2552,2550,1,0,0,0,2552,2553,1,0,0,0,2553,2555,1,0,0,0,2554, - 2552,1,0,0,0,2555,2556,3,170,85,0,2556,2557,3,230,115,0,2557,2558,3,138, - 69,0,2558,2559,3,226,113,0,2559,2560,3,242,121,0,2560,2561,3,182,91,0, - 2561,2567,3,112,56,0,2562,2563,3,244,122,0,2563,2564,6,117,-1,0,2564,2566, - 1,0,0,0,2565,2562,1,0,0,0,2566,2569,1,0,0,0,2567,2565,1,0,0,0,2567,2568, - 1,0,0,0,2568,2570,1,0,0,0,2569,2567,1,0,0,0,2570,2571,6,117,-1,0,2571, - 235,1,0,0,0,2572,2573,5,123,0,0,2573,2615,6,118,-1,0,2574,2575,5,51,0, - 0,2575,2615,6,118,-1,0,2576,2577,5,52,0,0,2577,2615,6,118,-1,0,2578,2579, - 5,63,0,0,2579,2615,6,118,-1,0,2580,2581,5,140,0,0,2581,2615,6,118,-1,0, - 2582,2583,5,68,0,0,2583,2615,6,118,-1,0,2584,2585,5,141,0,0,2585,2615, - 6,118,-1,0,2586,2587,5,142,0,0,2587,2615,6,118,-1,0,2588,2589,5,54,0,0, - 2589,2615,6,118,-1,0,2590,2591,5,64,0,0,2591,2615,6,118,-1,0,2592,2593, - 5,65,0,0,2593,2615,6,118,-1,0,2594,2595,5,66,0,0,2595,2615,6,118,-1,0, - 2596,2597,5,125,0,0,2597,2615,6,118,-1,0,2598,2599,5,143,0,0,2599,2615, - 6,118,-1,0,2600,2601,5,144,0,0,2601,2615,6,118,-1,0,2602,2603,5,69,0,0, - 2603,2615,6,118,-1,0,2604,2605,5,145,0,0,2605,2615,6,118,-1,0,2606,2607, - 5,146,0,0,2607,2615,6,118,-1,0,2608,2609,5,70,0,0,2609,2610,5,30,0,0,2610, - 2611,3,32,16,0,2611,2612,5,31,0,0,2612,2613,6,118,-1,0,2613,2615,1,0,0, - 0,2614,2572,1,0,0,0,2614,2574,1,0,0,0,2614,2576,1,0,0,0,2614,2578,1,0, - 0,0,2614,2580,1,0,0,0,2614,2582,1,0,0,0,2614,2584,1,0,0,0,2614,2586,1, - 0,0,0,2614,2588,1,0,0,0,2614,2590,1,0,0,0,2614,2592,1,0,0,0,2614,2594, - 1,0,0,0,2614,2596,1,0,0,0,2614,2598,1,0,0,0,2614,2600,1,0,0,0,2614,2602, - 1,0,0,0,2614,2604,1,0,0,0,2614,2606,1,0,0,0,2614,2608,1,0,0,0,2615,237, - 1,0,0,0,2616,2617,5,147,0,0,2617,2626,5,30,0,0,2618,2619,3,6,3,0,2619, - 2624,6,119,-1,0,2620,2621,5,34,0,0,2621,2622,3,6,3,0,2622,2623,6,119,-1, - 0,2623,2625,1,0,0,0,2624,2620,1,0,0,0,2624,2625,1,0,0,0,2625,2627,1,0, - 0,0,2626,2618,1,0,0,0,2626,2627,1,0,0,0,2627,2633,1,0,0,0,2628,2629,3, - 240,120,0,2629,2630,6,119,-1,0,2630,2632,1,0,0,0,2631,2628,1,0,0,0,2632, - 2635,1,0,0,0,2633,2631,1,0,0,0,2633,2634,1,0,0,0,2634,2636,1,0,0,0,2635, - 2633,1,0,0,0,2636,2640,5,31,0,0,2637,2638,5,147,0,0,2638,2640,5,85,0,0, - 2639,2616,1,0,0,0,2639,2637,1,0,0,0,2640,239,1,0,0,0,2641,2642,5,148,0, - 0,2642,2684,6,120,-1,0,2643,2644,5,224,0,0,2644,2684,6,120,-1,0,2645,2646, - 5,57,0,0,2646,2684,6,120,-1,0,2647,2648,5,58,0,0,2648,2684,6,120,-1,0, - 2649,2650,5,149,0,0,2650,2684,6,120,-1,0,2651,2652,5,150,0,0,2652,2684, - 6,120,-1,0,2653,2654,5,248,0,0,2654,2684,6,120,-1,0,2655,2656,5,249,0, - 0,2656,2684,6,120,-1,0,2657,2658,5,250,0,0,2658,2684,6,120,-1,0,2659,2660, - 5,251,0,0,2660,2684,6,120,-1,0,2661,2662,5,151,0,0,2662,2663,5,75,0,0, - 2663,2664,5,152,0,0,2664,2684,6,120,-1,0,2665,2666,5,151,0,0,2666,2667, - 5,75,0,0,2667,2668,5,153,0,0,2668,2684,6,120,-1,0,2669,2670,5,154,0,0, - 2670,2671,5,75,0,0,2671,2672,5,152,0,0,2672,2684,6,120,-1,0,2673,2674, - 5,154,0,0,2674,2675,5,75,0,0,2675,2676,5,153,0,0,2676,2684,6,120,-1,0, - 2677,2678,5,70,0,0,2678,2679,5,30,0,0,2679,2680,3,32,16,0,2680,2681,5, - 31,0,0,2681,2682,6,120,-1,0,2682,2684,1,0,0,0,2683,2641,1,0,0,0,2683,2643, - 1,0,0,0,2683,2645,1,0,0,0,2683,2647,1,0,0,0,2683,2649,1,0,0,0,2683,2651, - 1,0,0,0,2683,2653,1,0,0,0,2683,2655,1,0,0,0,2683,2657,1,0,0,0,2683,2659, - 1,0,0,0,2683,2661,1,0,0,0,2683,2665,1,0,0,0,2683,2669,1,0,0,0,2683,2673, - 1,0,0,0,2683,2677,1,0,0,0,2684,241,1,0,0,0,2685,2686,5,116,0,0,2686,2693, - 6,121,-1,0,2687,2688,5,155,0,0,2688,2693,6,121,-1,0,2689,2690,3,2,1,0, - 2690,2691,6,121,-1,0,2691,2693,1,0,0,0,2692,2685,1,0,0,0,2692,2687,1,0, - 0,0,2692,2689,1,0,0,0,2693,243,1,0,0,0,2694,2695,5,1,0,0,2695,2733,6,122, - -1,0,2696,2697,5,2,0,0,2697,2733,6,122,-1,0,2698,2699,5,156,0,0,2699,2733, - 6,122,-1,0,2700,2701,5,3,0,0,2701,2733,6,122,-1,0,2702,2703,5,4,0,0,2703, - 2733,6,122,-1,0,2704,2705,5,247,0,0,2705,2733,6,122,-1,0,2706,2707,5,5, - 0,0,2707,2733,6,122,-1,0,2708,2709,5,6,0,0,2709,2733,6,122,-1,0,2710,2711, - 5,7,0,0,2711,2733,6,122,-1,0,2712,2713,5,8,0,0,2713,2733,6,122,-1,0,2714, - 2715,5,9,0,0,2715,2733,6,122,-1,0,2716,2717,5,10,0,0,2717,2733,6,122,-1, - 0,2718,2719,5,11,0,0,2719,2733,6,122,-1,0,2720,2721,5,12,0,0,2721,2733, - 6,122,-1,0,2722,2723,5,13,0,0,2723,2733,6,122,-1,0,2724,2725,5,14,0,0, - 2725,2733,6,122,-1,0,2726,2727,5,70,0,0,2727,2728,5,30,0,0,2728,2729,3, - 32,16,0,2729,2730,5,31,0,0,2730,2731,6,122,-1,0,2731,2733,1,0,0,0,2732, - 2694,1,0,0,0,2732,2696,1,0,0,0,2732,2698,1,0,0,0,2732,2700,1,0,0,0,2732, - 2702,1,0,0,0,2732,2704,1,0,0,0,2732,2706,1,0,0,0,2732,2708,1,0,0,0,2732, - 2710,1,0,0,0,2732,2712,1,0,0,0,2732,2714,1,0,0,0,2732,2716,1,0,0,0,2732, - 2718,1,0,0,0,2732,2720,1,0,0,0,2732,2722,1,0,0,0,2732,2724,1,0,0,0,2732, - 2726,1,0,0,0,2733,245,1,0,0,0,2734,2736,3,248,124,0,2735,2734,1,0,0,0, - 2736,2739,1,0,0,0,2737,2735,1,0,0,0,2737,2738,1,0,0,0,2738,247,1,0,0,0, - 2739,2737,1,0,0,0,2740,2778,3,100,50,0,2741,2742,5,296,0,0,2742,2743,3, - 32,16,0,2743,2744,6,124,-1,0,2744,2778,1,0,0,0,2745,2778,3,266,133,0,2746, - 2747,5,297,0,0,2747,2748,3,32,16,0,2748,2749,6,124,-1,0,2749,2778,1,0, - 0,0,2750,2751,5,298,0,0,2751,2778,6,124,-1,0,2752,2753,5,299,0,0,2753, - 2778,6,124,-1,0,2754,2778,3,260,130,0,2755,2778,3,264,132,0,2756,2778, - 3,250,125,0,2757,2758,3,284,142,0,2758,2759,6,124,-1,0,2759,2778,1,0,0, - 0,2760,2761,3,152,76,0,2761,2762,6,124,-1,0,2762,2778,1,0,0,0,2763,2764, - 3,88,44,0,2764,2765,6,124,-1,0,2765,2778,1,0,0,0,2766,2767,3,26,13,0,2767, - 2768,6,124,-1,0,2768,2778,1,0,0,0,2769,2770,3,262,131,0,2770,2771,6,124, - -1,0,2771,2778,1,0,0,0,2772,2778,3,40,20,0,2773,2778,3,252,126,0,2774, - 2778,3,254,127,0,2775,2778,3,256,128,0,2776,2778,3,258,129,0,2777,2740, - 1,0,0,0,2777,2741,1,0,0,0,2777,2745,1,0,0,0,2777,2746,1,0,0,0,2777,2750, - 1,0,0,0,2777,2752,1,0,0,0,2777,2754,1,0,0,0,2777,2755,1,0,0,0,2777,2756, - 1,0,0,0,2777,2757,1,0,0,0,2777,2760,1,0,0,0,2777,2763,1,0,0,0,2777,2766, - 1,0,0,0,2777,2769,1,0,0,0,2777,2772,1,0,0,0,2777,2773,1,0,0,0,2777,2774, - 1,0,0,0,2777,2775,1,0,0,0,2777,2776,1,0,0,0,2778,249,1,0,0,0,2779,2781, - 5,300,0,0,2780,2782,5,157,0,0,2781,2780,1,0,0,0,2781,2782,1,0,0,0,2782, - 2783,1,0,0,0,2783,2784,3,112,56,0,2784,251,1,0,0,0,2785,2786,5,301,0,0, - 2786,2787,5,42,0,0,2787,2788,3,32,16,0,2788,2791,5,43,0,0,2789,2790,5, - 34,0,0,2790,2792,3,0,0,0,2791,2789,1,0,0,0,2791,2792,1,0,0,0,2792,253, - 1,0,0,0,2793,2794,5,303,0,0,2794,2795,3,32,16,0,2795,2796,5,75,0,0,2796, - 2797,3,32,16,0,2797,255,1,0,0,0,2798,2799,5,302,0,0,2799,2800,3,124,62, - 0,2800,2801,5,176,0,0,2801,2802,3,242,121,0,2802,2814,1,0,0,0,2803,2804, - 5,302,0,0,2804,2805,5,226,0,0,2805,2806,3,170,85,0,2806,2807,3,138,69, - 0,2807,2808,3,124,62,0,2808,2809,5,176,0,0,2809,2810,3,242,121,0,2810, - 2811,3,194,97,0,2811,2812,3,112,56,0,2812,2814,1,0,0,0,2813,2798,1,0,0, - 0,2813,2803,1,0,0,0,2814,257,1,0,0,0,2815,2816,5,255,0,0,2816,2817,5,196, - 0,0,2817,2818,5,42,0,0,2818,2819,3,32,16,0,2819,2825,5,43,0,0,2820,2821, - 3,330,165,0,2821,2822,6,129,-1,0,2822,2824,1,0,0,0,2823,2820,1,0,0,0,2824, - 2827,1,0,0,0,2825,2823,1,0,0,0,2825,2826,1,0,0,0,2826,2881,1,0,0,0,2827, - 2825,1,0,0,0,2828,2829,5,255,0,0,2829,2830,5,196,0,0,2830,2836,3,2,1,0, - 2831,2832,3,330,165,0,2832,2833,6,129,-1,0,2833,2835,1,0,0,0,2834,2831, - 1,0,0,0,2835,2838,1,0,0,0,2836,2834,1,0,0,0,2836,2837,1,0,0,0,2837,2881, - 1,0,0,0,2838,2836,1,0,0,0,2839,2840,5,255,0,0,2840,2841,5,256,0,0,2841, - 2842,5,42,0,0,2842,2843,3,32,16,0,2843,2844,5,43,0,0,2844,2845,5,28,0, - 0,2845,2851,3,124,62,0,2846,2847,3,330,165,0,2847,2848,6,129,-1,0,2848, - 2850,1,0,0,0,2849,2846,1,0,0,0,2850,2853,1,0,0,0,2851,2849,1,0,0,0,2851, - 2852,1,0,0,0,2852,2881,1,0,0,0,2853,2851,1,0,0,0,2854,2855,5,255,0,0,2855, - 2856,5,256,0,0,2856,2857,3,2,1,0,2857,2858,5,28,0,0,2858,2864,3,124,62, - 0,2859,2860,3,330,165,0,2860,2861,6,129,-1,0,2861,2863,1,0,0,0,2862,2859, - 1,0,0,0,2863,2866,1,0,0,0,2864,2862,1,0,0,0,2864,2865,1,0,0,0,2865,2881, - 1,0,0,0,2866,2864,1,0,0,0,2867,2868,5,255,0,0,2868,2869,5,42,0,0,2869, - 2870,3,32,16,0,2870,2871,5,43,0,0,2871,2877,3,206,103,0,2872,2873,3,330, - 165,0,2873,2874,6,129,-1,0,2874,2876,1,0,0,0,2875,2872,1,0,0,0,2876,2879, - 1,0,0,0,2877,2875,1,0,0,0,2877,2878,1,0,0,0,2878,2881,1,0,0,0,2879,2877, - 1,0,0,0,2880,2815,1,0,0,0,2880,2828,1,0,0,0,2880,2839,1,0,0,0,2880,2854, - 1,0,0,0,2880,2867,1,0,0,0,2881,259,1,0,0,0,2882,2883,3,0,0,0,2883,2884, - 5,75,0,0,2884,2885,6,130,-1,0,2885,261,1,0,0,0,2886,2887,3,44,22,0,2887, - 2888,6,131,-1,0,2888,2893,1,0,0,0,2889,2890,3,46,23,0,2890,2891,6,131, - -1,0,2891,2893,1,0,0,0,2892,2886,1,0,0,0,2892,2889,1,0,0,0,2893,263,1, - 0,0,0,2894,2895,5,17,0,0,2895,2896,3,246,123,0,2896,2897,5,18,0,0,2897, - 265,1,0,0,0,2898,2899,3,270,135,0,2899,2900,3,268,134,0,2900,267,1,0,0, - 0,2901,2902,3,272,136,0,2902,2903,6,134,-1,0,2903,2905,1,0,0,0,2904,2901, - 1,0,0,0,2905,2906,1,0,0,0,2906,2904,1,0,0,0,2906,2907,1,0,0,0,2907,269, - 1,0,0,0,2908,2909,5,158,0,0,2909,2910,3,264,132,0,2910,2911,6,135,-1,0, - 2911,2925,1,0,0,0,2912,2913,5,158,0,0,2913,2914,3,0,0,0,2914,2915,5,159, - 0,0,2915,2916,3,0,0,0,2916,2917,6,135,-1,0,2917,2925,1,0,0,0,2918,2919, - 5,158,0,0,2919,2920,3,32,16,0,2920,2921,5,159,0,0,2921,2922,3,32,16,0, - 2922,2923,6,135,-1,0,2923,2925,1,0,0,0,2924,2908,1,0,0,0,2924,2912,1,0, - 0,0,2924,2918,1,0,0,0,2925,271,1,0,0,0,2926,2927,3,276,138,0,2927,2928, - 3,282,141,0,2928,2929,6,136,-1,0,2929,2943,1,0,0,0,2930,2931,3,274,137, - 0,2931,2932,3,282,141,0,2932,2933,6,136,-1,0,2933,2943,1,0,0,0,2934,2935, - 3,278,139,0,2935,2936,3,282,141,0,2936,2937,6,136,-1,0,2937,2943,1,0,0, - 0,2938,2939,3,280,140,0,2939,2940,3,282,141,0,2940,2941,6,136,-1,0,2941, - 2943,1,0,0,0,2942,2926,1,0,0,0,2942,2930,1,0,0,0,2942,2934,1,0,0,0,2942, - 2938,1,0,0,0,2943,273,1,0,0,0,2944,2945,5,160,0,0,2945,2946,3,264,132, - 0,2946,2947,6,137,-1,0,2947,2957,1,0,0,0,2948,2949,5,160,0,0,2949,2950, - 3,0,0,0,2950,2951,6,137,-1,0,2951,2957,1,0,0,0,2952,2953,5,160,0,0,2953, - 2954,3,32,16,0,2954,2955,6,137,-1,0,2955,2957,1,0,0,0,2956,2944,1,0,0, - 0,2956,2948,1,0,0,0,2956,2952,1,0,0,0,2957,275,1,0,0,0,2958,2959,5,161, - 0,0,2959,2960,3,124,62,0,2960,277,1,0,0,0,2961,2962,5,162,0,0,2962,279, - 1,0,0,0,2963,2964,5,163,0,0,2964,281,1,0,0,0,2965,2966,3,264,132,0,2966, - 2967,6,141,-1,0,2967,2981,1,0,0,0,2968,2969,5,164,0,0,2969,2970,3,0,0, - 0,2970,2971,5,159,0,0,2971,2972,3,0,0,0,2972,2973,6,141,-1,0,2973,2981, - 1,0,0,0,2974,2975,5,164,0,0,2975,2976,3,32,16,0,2976,2977,5,159,0,0,2977, - 2978,3,32,16,0,2978,2979,6,141,-1,0,2979,2981,1,0,0,0,2980,2965,1,0,0, - 0,2980,2968,1,0,0,0,2980,2974,1,0,0,0,2981,283,1,0,0,0,2982,2983,3,286, - 143,0,2983,2984,3,290,145,0,2984,285,1,0,0,0,2985,2986,5,165,0,0,2986, - 2987,3,288,144,0,2987,2988,3,0,0,0,2988,2989,5,36,0,0,2989,2993,1,0,0, - 0,2990,2991,5,165,0,0,2991,2993,3,288,144,0,2992,2985,1,0,0,0,2992,2990, - 1,0,0,0,2993,287,1,0,0,0,2994,2998,1,0,0,0,2995,2998,5,166,0,0,2996,2998, - 5,2,0,0,2997,2994,1,0,0,0,2997,2995,1,0,0,0,2997,2996,1,0,0,0,2998,289, - 1,0,0,0,2999,3000,5,17,0,0,3000,3001,3,292,146,0,3001,3002,5,18,0,0,3002, - 3009,1,0,0,0,3003,3005,3,296,148,0,3004,3003,1,0,0,0,3005,3006,1,0,0,0, - 3006,3004,1,0,0,0,3006,3007,1,0,0,0,3007,3009,1,0,0,0,3008,2999,1,0,0, - 0,3008,3004,1,0,0,0,3009,291,1,0,0,0,3010,3011,3,296,148,0,3011,3012,5, - 28,0,0,3012,3014,1,0,0,0,3013,3010,1,0,0,0,3014,3017,1,0,0,0,3015,3013, - 1,0,0,0,3015,3016,1,0,0,0,3016,3018,1,0,0,0,3017,3015,1,0,0,0,3018,3019, - 3,296,148,0,3019,293,1,0,0,0,3020,3026,1,0,0,0,3021,3022,5,42,0,0,3022, - 3023,3,32,16,0,3023,3024,5,43,0,0,3024,3026,1,0,0,0,3025,3020,1,0,0,0, - 3025,3021,1,0,0,0,3026,295,1,0,0,0,3027,3028,5,181,0,0,3028,3029,5,262, - 0,0,3029,3030,5,30,0,0,3030,3031,3,6,3,0,3031,3032,5,31,0,0,3032,3094, - 1,0,0,0,3033,3034,5,260,0,0,3034,3035,5,30,0,0,3035,3036,3,0,0,0,3036, - 3037,5,31,0,0,3037,3094,1,0,0,0,3038,3039,5,260,0,0,3039,3094,3,0,0,0, - 3040,3041,5,84,0,0,3041,3042,5,30,0,0,3042,3043,3,300,150,0,3043,3044, - 5,31,0,0,3044,3094,1,0,0,0,3045,3046,5,188,0,0,3046,3047,5,30,0,0,3047, - 3048,3,36,18,0,3048,3049,5,31,0,0,3049,3050,3,294,147,0,3050,3094,1,0, - 0,0,3051,3052,5,189,0,0,3052,3053,5,30,0,0,3053,3054,3,36,18,0,3054,3055, - 5,31,0,0,3055,3056,3,294,147,0,3056,3094,1,0,0,0,3057,3058,5,187,0,0,3058, - 3059,5,30,0,0,3059,3060,3,34,17,0,3060,3061,5,31,0,0,3061,3062,3,294,147, - 0,3062,3094,1,0,0,0,3063,3064,5,186,0,0,3064,3065,5,30,0,0,3065,3066,3, - 32,16,0,3066,3067,5,31,0,0,3067,3068,3,294,147,0,3068,3094,1,0,0,0,3069, - 3070,5,185,0,0,3070,3071,5,30,0,0,3071,3072,3,32,16,0,3072,3073,5,31,0, - 0,3073,3074,3,294,147,0,3074,3094,1,0,0,0,3075,3076,5,184,0,0,3076,3077, - 5,30,0,0,3077,3078,3,32,16,0,3078,3079,5,31,0,0,3079,3080,3,294,147,0, - 3080,3094,1,0,0,0,3081,3082,5,188,0,0,3082,3094,3,294,147,0,3083,3084, - 5,189,0,0,3084,3094,3,294,147,0,3085,3086,5,187,0,0,3086,3094,3,294,147, - 0,3087,3088,5,186,0,0,3088,3094,3,294,147,0,3089,3090,5,185,0,0,3090,3094, - 3,294,147,0,3091,3092,5,184,0,0,3092,3094,3,294,147,0,3093,3027,1,0,0, - 0,3093,3033,1,0,0,0,3093,3038,1,0,0,0,3093,3040,1,0,0,0,3093,3045,1,0, - 0,0,3093,3051,1,0,0,0,3093,3057,1,0,0,0,3093,3063,1,0,0,0,3093,3069,1, - 0,0,0,3093,3075,1,0,0,0,3093,3081,1,0,0,0,3093,3083,1,0,0,0,3093,3085, - 1,0,0,0,3093,3087,1,0,0,0,3093,3089,1,0,0,0,3093,3091,1,0,0,0,3094,297, - 1,0,0,0,3095,3096,5,188,0,0,3096,3097,5,30,0,0,3097,3098,3,36,18,0,3098, - 3099,5,31,0,0,3099,3100,6,149,-1,0,3100,3186,1,0,0,0,3101,3102,5,189,0, - 0,3102,3103,5,30,0,0,3103,3104,3,36,18,0,3104,3105,5,31,0,0,3105,3106, - 6,149,-1,0,3106,3186,1,0,0,0,3107,3108,5,188,0,0,3108,3109,5,30,0,0,3109, - 3110,3,32,16,0,3110,3111,5,31,0,0,3111,3112,6,149,-1,0,3112,3186,1,0,0, - 0,3113,3114,5,189,0,0,3114,3115,5,30,0,0,3115,3116,3,34,17,0,3116,3117, - 5,31,0,0,3117,3118,6,149,-1,0,3118,3186,1,0,0,0,3119,3120,5,187,0,0,3120, - 3121,5,30,0,0,3121,3122,3,34,17,0,3122,3123,5,31,0,0,3123,3124,6,149,-1, - 0,3124,3186,1,0,0,0,3125,3126,5,186,0,0,3126,3127,5,30,0,0,3127,3128,3, - 32,16,0,3128,3129,5,31,0,0,3129,3130,6,149,-1,0,3130,3186,1,0,0,0,3131, - 3132,5,185,0,0,3132,3133,5,30,0,0,3133,3134,3,32,16,0,3134,3135,5,31,0, - 0,3135,3136,6,149,-1,0,3136,3186,1,0,0,0,3137,3138,5,184,0,0,3138,3139, - 5,30,0,0,3139,3140,3,32,16,0,3140,3141,5,31,0,0,3141,3142,6,149,-1,0,3142, - 3186,1,0,0,0,3143,3144,5,193,0,0,3144,3145,5,30,0,0,3145,3146,3,34,17, - 0,3146,3147,5,31,0,0,3147,3148,6,149,-1,0,3148,3186,1,0,0,0,3149,3150, - 5,192,0,0,3150,3151,5,30,0,0,3151,3152,3,32,16,0,3152,3153,5,31,0,0,3153, - 3154,6,149,-1,0,3154,3186,1,0,0,0,3155,3156,5,191,0,0,3156,3157,5,30,0, - 0,3157,3158,3,32,16,0,3158,3159,5,31,0,0,3159,3160,6,149,-1,0,3160,3186, - 1,0,0,0,3161,3162,5,190,0,0,3162,3163,5,30,0,0,3163,3164,3,32,16,0,3164, - 3165,5,31,0,0,3165,3166,6,149,-1,0,3166,3186,1,0,0,0,3167,3168,5,181,0, - 0,3168,3169,5,30,0,0,3169,3170,3,32,16,0,3170,3171,5,31,0,0,3171,3172, - 6,149,-1,0,3172,3186,1,0,0,0,3173,3174,5,183,0,0,3174,3175,5,30,0,0,3175, - 3176,3,162,81,0,3176,3177,5,31,0,0,3177,3178,6,149,-1,0,3178,3186,1,0, - 0,0,3179,3180,5,84,0,0,3180,3181,5,30,0,0,3181,3182,3,300,150,0,3182,3183, - 5,31,0,0,3183,3184,6,149,-1,0,3184,3186,1,0,0,0,3185,3095,1,0,0,0,3185, - 3101,1,0,0,0,3185,3107,1,0,0,0,3185,3113,1,0,0,0,3185,3119,1,0,0,0,3185, - 3125,1,0,0,0,3185,3131,1,0,0,0,3185,3137,1,0,0,0,3185,3143,1,0,0,0,3185, - 3149,1,0,0,0,3185,3155,1,0,0,0,3185,3161,1,0,0,0,3185,3167,1,0,0,0,3185, - 3173,1,0,0,0,3185,3179,1,0,0,0,3186,299,1,0,0,0,3187,3188,3,302,151,0, - 3188,3189,6,150,-1,0,3189,3191,1,0,0,0,3190,3187,1,0,0,0,3191,3194,1,0, - 0,0,3192,3190,1,0,0,0,3192,3193,1,0,0,0,3193,301,1,0,0,0,3194,3192,1,0, - 0,0,3195,3196,7,10,0,0,3196,303,1,0,0,0,3197,3198,3,298,149,0,3198,3199, - 6,152,-1,0,3199,3206,1,0,0,0,3200,3201,3,6,3,0,3201,3202,6,152,-1,0,3202, - 3206,1,0,0,0,3203,3204,5,179,0,0,3204,3206,6,152,-1,0,3205,3197,1,0,0, - 0,3205,3200,1,0,0,0,3205,3203,1,0,0,0,3206,305,1,0,0,0,3207,3208,3,298, - 149,0,3208,3209,6,153,-1,0,3209,3379,1,0,0,0,3210,3211,5,182,0,0,3211, - 3212,5,30,0,0,3212,3213,5,179,0,0,3213,3214,5,31,0,0,3214,3379,6,153,-1, - 0,3215,3216,5,182,0,0,3216,3217,5,30,0,0,3217,3218,5,264,0,0,3218,3219, - 5,31,0,0,3219,3379,6,153,-1,0,3220,3221,5,196,0,0,3221,3222,5,30,0,0,3222, - 3223,5,39,0,0,3223,3224,5,264,0,0,3224,3225,5,31,0,0,3225,3379,6,153,-1, - 0,3226,3227,5,196,0,0,3227,3228,5,30,0,0,3228,3229,3,116,58,0,3229,3230, - 5,31,0,0,3230,3231,6,153,-1,0,3231,3379,1,0,0,0,3232,3233,5,196,0,0,3233, - 3234,5,30,0,0,3234,3235,5,179,0,0,3235,3236,5,31,0,0,3236,3379,6,153,-1, - 0,3237,3238,5,197,0,0,3238,3239,5,30,0,0,3239,3240,3,306,153,0,3240,3241, - 5,31,0,0,3241,3242,6,153,-1,0,3242,3379,1,0,0,0,3243,3244,5,188,0,0,3244, - 3245,5,42,0,0,3245,3246,3,32,16,0,3246,3247,5,43,0,0,3247,3248,5,30,0, - 0,3248,3249,3,308,154,0,3249,3250,5,31,0,0,3250,3251,6,153,-1,0,3251,3379, - 1,0,0,0,3252,3253,5,189,0,0,3253,3254,5,42,0,0,3254,3255,3,32,16,0,3255, - 3256,5,43,0,0,3256,3257,5,30,0,0,3257,3258,3,310,155,0,3258,3259,5,31, - 0,0,3259,3260,6,153,-1,0,3260,3379,1,0,0,0,3261,3262,5,187,0,0,3262,3263, - 5,42,0,0,3263,3264,3,32,16,0,3264,3265,5,43,0,0,3265,3266,5,30,0,0,3266, - 3267,3,312,156,0,3267,3268,5,31,0,0,3268,3269,6,153,-1,0,3269,3379,1,0, - 0,0,3270,3271,5,186,0,0,3271,3272,5,42,0,0,3272,3273,3,32,16,0,3273,3274, - 5,43,0,0,3274,3275,5,30,0,0,3275,3276,3,314,157,0,3276,3277,5,31,0,0,3277, - 3278,6,153,-1,0,3278,3379,1,0,0,0,3279,3280,5,185,0,0,3280,3281,5,42,0, - 0,3281,3282,3,32,16,0,3282,3283,5,43,0,0,3283,3284,5,30,0,0,3284,3285, - 3,316,158,0,3285,3286,5,31,0,0,3286,3287,6,153,-1,0,3287,3379,1,0,0,0, - 3288,3289,5,184,0,0,3289,3290,5,42,0,0,3290,3291,3,32,16,0,3291,3292,5, - 43,0,0,3292,3293,5,30,0,0,3293,3294,3,318,159,0,3294,3295,5,31,0,0,3295, - 3296,6,153,-1,0,3296,3379,1,0,0,0,3297,3298,5,193,0,0,3298,3299,5,42,0, - 0,3299,3300,3,32,16,0,3300,3301,5,43,0,0,3301,3302,5,30,0,0,3302,3303, - 3,312,156,0,3303,3304,5,31,0,0,3304,3305,6,153,-1,0,3305,3379,1,0,0,0, - 3306,3307,5,192,0,0,3307,3308,5,42,0,0,3308,3309,3,32,16,0,3309,3310,5, - 43,0,0,3310,3311,5,30,0,0,3311,3312,3,314,157,0,3312,3313,5,31,0,0,3313, - 3314,6,153,-1,0,3314,3379,1,0,0,0,3315,3316,5,191,0,0,3316,3317,5,42,0, - 0,3317,3318,3,32,16,0,3318,3319,5,43,0,0,3319,3320,5,30,0,0,3320,3321, - 3,316,158,0,3321,3322,5,31,0,0,3322,3323,6,153,-1,0,3323,3379,1,0,0,0, - 3324,3325,5,190,0,0,3325,3326,5,42,0,0,3326,3327,3,32,16,0,3327,3328,5, - 43,0,0,3328,3329,5,30,0,0,3329,3330,3,318,159,0,3330,3331,5,31,0,0,3331, - 3332,6,153,-1,0,3332,3379,1,0,0,0,3333,3334,5,181,0,0,3334,3335,5,42,0, - 0,3335,3336,3,32,16,0,3336,3337,5,43,0,0,3337,3338,5,30,0,0,3338,3339, - 3,316,158,0,3339,3340,5,31,0,0,3340,3341,6,153,-1,0,3341,3379,1,0,0,0, - 3342,3343,5,183,0,0,3343,3344,5,42,0,0,3344,3345,3,32,16,0,3345,3346,5, - 43,0,0,3346,3347,5,30,0,0,3347,3348,3,320,160,0,3348,3349,5,31,0,0,3349, - 3350,6,153,-1,0,3350,3379,1,0,0,0,3351,3352,5,182,0,0,3352,3353,5,42,0, - 0,3353,3354,3,32,16,0,3354,3355,5,43,0,0,3355,3356,5,30,0,0,3356,3357, - 3,322,161,0,3357,3358,5,31,0,0,3358,3359,6,153,-1,0,3359,3379,1,0,0,0, - 3360,3361,5,196,0,0,3361,3362,5,42,0,0,3362,3363,3,32,16,0,3363,3364,5, - 43,0,0,3364,3365,5,30,0,0,3365,3366,3,324,162,0,3366,3367,5,31,0,0,3367, - 3368,6,153,-1,0,3368,3379,1,0,0,0,3369,3370,5,197,0,0,3370,3371,5,42,0, - 0,3371,3372,3,32,16,0,3372,3373,5,43,0,0,3373,3374,5,30,0,0,3374,3375, - 3,328,164,0,3375,3376,5,31,0,0,3376,3377,6,153,-1,0,3377,3379,1,0,0,0, - 3378,3207,1,0,0,0,3378,3210,1,0,0,0,3378,3215,1,0,0,0,3378,3220,1,0,0, - 0,3378,3226,1,0,0,0,3378,3232,1,0,0,0,3378,3237,1,0,0,0,3378,3243,1,0, - 0,0,3378,3252,1,0,0,0,3378,3261,1,0,0,0,3378,3270,1,0,0,0,3378,3279,1, - 0,0,0,3378,3288,1,0,0,0,3378,3297,1,0,0,0,3378,3306,1,0,0,0,3378,3315, - 1,0,0,0,3378,3324,1,0,0,0,3378,3333,1,0,0,0,3378,3342,1,0,0,0,3378,3351, - 1,0,0,0,3378,3360,1,0,0,0,3378,3369,1,0,0,0,3379,307,1,0,0,0,3380,3381, - 3,36,18,0,3381,3382,6,154,-1,0,3382,3387,1,0,0,0,3383,3384,3,32,16,0,3384, - 3385,6,154,-1,0,3385,3387,1,0,0,0,3386,3380,1,0,0,0,3386,3383,1,0,0,0, - 3387,3390,1,0,0,0,3388,3386,1,0,0,0,3388,3389,1,0,0,0,3389,309,1,0,0,0, - 3390,3388,1,0,0,0,3391,3392,3,36,18,0,3392,3393,6,155,-1,0,3393,3398,1, - 0,0,0,3394,3395,3,34,17,0,3395,3396,6,155,-1,0,3396,3398,1,0,0,0,3397, - 3391,1,0,0,0,3397,3394,1,0,0,0,3398,3401,1,0,0,0,3399,3397,1,0,0,0,3399, - 3400,1,0,0,0,3400,311,1,0,0,0,3401,3399,1,0,0,0,3402,3403,3,34,17,0,3403, - 3404,6,156,-1,0,3404,3406,1,0,0,0,3405,3402,1,0,0,0,3406,3409,1,0,0,0, - 3407,3405,1,0,0,0,3407,3408,1,0,0,0,3408,313,1,0,0,0,3409,3407,1,0,0,0, - 3410,3411,3,32,16,0,3411,3412,6,157,-1,0,3412,3414,1,0,0,0,3413,3410,1, - 0,0,0,3414,3417,1,0,0,0,3415,3413,1,0,0,0,3415,3416,1,0,0,0,3416,315,1, - 0,0,0,3417,3415,1,0,0,0,3418,3419,3,32,16,0,3419,3420,6,158,-1,0,3420, - 3422,1,0,0,0,3421,3418,1,0,0,0,3422,3425,1,0,0,0,3423,3421,1,0,0,0,3423, - 3424,1,0,0,0,3424,317,1,0,0,0,3425,3423,1,0,0,0,3426,3427,3,32,16,0,3427, - 3428,6,159,-1,0,3428,3430,1,0,0,0,3429,3426,1,0,0,0,3430,3433,1,0,0,0, - 3431,3429,1,0,0,0,3431,3432,1,0,0,0,3432,319,1,0,0,0,3433,3431,1,0,0,0, - 3434,3435,3,162,81,0,3435,3436,6,160,-1,0,3436,3438,1,0,0,0,3437,3434, - 1,0,0,0,3438,3441,1,0,0,0,3439,3437,1,0,0,0,3439,3440,1,0,0,0,3440,321, - 1,0,0,0,3441,3439,1,0,0,0,3442,3443,5,179,0,0,3443,3447,6,161,-1,0,3444, - 3445,5,264,0,0,3445,3447,6,161,-1,0,3446,3442,1,0,0,0,3446,3444,1,0,0, - 0,3447,3450,1,0,0,0,3448,3446,1,0,0,0,3448,3449,1,0,0,0,3449,323,1,0,0, - 0,3450,3448,1,0,0,0,3451,3452,3,326,163,0,3452,3453,6,162,-1,0,3453,3455, - 1,0,0,0,3454,3451,1,0,0,0,3455,3458,1,0,0,0,3456,3454,1,0,0,0,3456,3457, - 1,0,0,0,3457,325,1,0,0,0,3458,3456,1,0,0,0,3459,3460,5,179,0,0,3460,3468, - 6,163,-1,0,3461,3462,5,39,0,0,3462,3463,5,264,0,0,3463,3468,6,163,-1,0, - 3464,3465,3,116,58,0,3465,3466,6,163,-1,0,3466,3468,1,0,0,0,3467,3459, - 1,0,0,0,3467,3461,1,0,0,0,3467,3464,1,0,0,0,3468,327,1,0,0,0,3469,3470, - 3,306,153,0,3470,3471,6,164,-1,0,3471,3473,1,0,0,0,3472,3469,1,0,0,0,3473, - 3476,1,0,0,0,3474,3472,1,0,0,0,3474,3475,1,0,0,0,3475,329,1,0,0,0,3476, - 3474,1,0,0,0,3477,3478,3,44,22,0,3478,3479,6,165,-1,0,3479,3487,1,0,0, - 0,3480,3481,3,46,23,0,3481,3482,6,165,-1,0,3482,3487,1,0,0,0,3483,3484, - 3,2,1,0,3484,3485,6,165,-1,0,3485,3487,1,0,0,0,3486,3477,1,0,0,0,3486, - 3480,1,0,0,0,3486,3483,1,0,0,0,3487,331,1,0,0,0,3488,3489,7,11,0,0,3489, - 3490,5,36,0,0,3490,3491,5,30,0,0,3491,3492,3,300,150,0,3492,3493,5,31, - 0,0,3493,3514,1,0,0,0,3494,3495,5,169,0,0,3495,3496,3,38,19,0,3496,3497, - 5,75,0,0,3497,3498,3,38,19,0,3498,3499,5,75,0,0,3499,3500,3,38,19,0,3500, - 3501,5,75,0,0,3501,3502,3,38,19,0,3502,3514,1,0,0,0,3503,3504,5,170,0, - 0,3504,3514,3,6,3,0,3505,3506,5,170,0,0,3506,3507,5,36,0,0,3507,3508,5, - 30,0,0,3508,3509,3,300,150,0,3509,3510,5,31,0,0,3510,3514,1,0,0,0,3511, - 3514,3,330,165,0,3512,3514,3,40,20,0,3513,3488,1,0,0,0,3513,3494,1,0,0, - 0,3513,3503,1,0,0,0,3513,3505,1,0,0,0,3513,3511,1,0,0,0,3513,3512,1,0, - 0,0,3514,333,1,0,0,0,3515,3516,3,336,168,0,3516,3517,5,17,0,0,3517,3518, - 3,338,169,0,3518,3519,5,18,0,0,3519,335,1,0,0,0,3520,3521,5,25,0,0,3521, - 3522,5,40,0,0,3522,3523,3,98,49,0,3523,3524,3,2,1,0,3524,3533,1,0,0,0, - 3525,3526,5,25,0,0,3526,3527,5,40,0,0,3527,3528,3,98,49,0,3528,3529,3, - 2,1,0,3529,3530,5,34,0,0,3530,3531,3,2,1,0,3531,3533,1,0,0,0,3532,3520, - 1,0,0,0,3532,3525,1,0,0,0,3533,337,1,0,0,0,3534,3536,3,340,170,0,3535, - 3534,1,0,0,0,3536,3539,1,0,0,0,3537,3535,1,0,0,0,3537,3538,1,0,0,0,3538, - 339,1,0,0,0,3539,3537,1,0,0,0,3540,3541,5,180,0,0,3541,3542,5,36,0,0,3542, - 3543,5,30,0,0,3543,3544,3,300,150,0,3544,3545,5,31,0,0,3545,3555,1,0,0, - 0,3546,3555,3,332,166,0,3547,3548,5,171,0,0,3548,3549,5,36,0,0,3549,3550, - 5,30,0,0,3550,3551,3,300,150,0,3551,3552,5,31,0,0,3552,3555,1,0,0,0,3553, - 3555,5,55,0,0,3554,3540,1,0,0,0,3554,3546,1,0,0,0,3554,3547,1,0,0,0,3554, - 3553,1,0,0,0,3555,341,1,0,0,0,3556,3557,3,344,172,0,3557,3558,5,17,0,0, - 3558,3559,3,350,175,0,3559,3560,5,18,0,0,3560,343,1,0,0,0,3561,3562,5, - 50,0,0,3562,3566,5,40,0,0,3563,3565,3,348,174,0,3564,3563,1,0,0,0,3565, - 3568,1,0,0,0,3566,3564,1,0,0,0,3566,3567,1,0,0,0,3567,3569,1,0,0,0,3568, - 3566,1,0,0,0,3569,3570,3,2,1,0,3570,345,1,0,0,0,3571,3575,5,301,0,0,3572, - 3574,3,348,174,0,3573,3572,1,0,0,0,3574,3577,1,0,0,0,3575,3573,1,0,0,0, - 3575,3576,1,0,0,0,3576,3578,1,0,0,0,3577,3575,1,0,0,0,3578,3579,3,2,1, - 0,3579,347,1,0,0,0,3580,3596,5,52,0,0,3581,3596,5,51,0,0,3582,3596,5,172, - 0,0,3583,3584,5,62,0,0,3584,3596,5,51,0,0,3585,3586,5,62,0,0,3586,3596, - 5,52,0,0,3587,3588,5,62,0,0,3588,3596,5,63,0,0,3589,3590,5,62,0,0,3590, - 3596,5,64,0,0,3591,3592,5,62,0,0,3592,3596,5,65,0,0,3593,3594,5,62,0,0, - 3594,3596,5,66,0,0,3595,3580,1,0,0,0,3595,3581,1,0,0,0,3595,3582,1,0,0, - 0,3595,3583,1,0,0,0,3595,3585,1,0,0,0,3595,3587,1,0,0,0,3595,3589,1,0, - 0,0,3595,3591,1,0,0,0,3595,3593,1,0,0,0,3596,349,1,0,0,0,3597,3599,3,352, - 176,0,3598,3597,1,0,0,0,3599,3602,1,0,0,0,3600,3598,1,0,0,0,3600,3601, - 1,0,0,0,3601,351,1,0,0,0,3602,3600,1,0,0,0,3603,3604,5,21,0,0,3604,3617, - 3,2,1,0,3605,3606,5,50,0,0,3606,3607,5,40,0,0,3607,3617,3,118,59,0,3608, - 3609,5,25,0,0,3609,3610,5,40,0,0,3610,3617,3,2,1,0,3611,3617,3,174,87, - 0,3612,3613,5,50,0,0,3613,3617,3,32,16,0,3614,3617,3,330,165,0,3615,3617, - 3,40,20,0,3616,3603,1,0,0,0,3616,3605,1,0,0,0,3616,3608,1,0,0,0,3616,3611, - 1,0,0,0,3616,3612,1,0,0,0,3616,3614,1,0,0,0,3616,3615,1,0,0,0,3617,353, - 1,0,0,0,3618,3619,3,356,178,0,3619,3620,5,17,0,0,3620,3621,3,360,180,0, - 3621,3622,5,18,0,0,3622,355,1,0,0,0,3623,3627,5,274,0,0,3624,3626,3,358, - 179,0,3625,3624,1,0,0,0,3626,3629,1,0,0,0,3627,3625,1,0,0,0,3627,3628, - 1,0,0,0,3628,3630,1,0,0,0,3629,3627,1,0,0,0,3630,3643,3,2,1,0,3631,3635, - 5,274,0,0,3632,3634,3,358,179,0,3633,3632,1,0,0,0,3634,3637,1,0,0,0,3635, - 3633,1,0,0,0,3635,3636,1,0,0,0,3636,3638,1,0,0,0,3637,3635,1,0,0,0,3638, - 3639,3,2,1,0,3639,3640,5,34,0,0,3640,3641,3,2,1,0,3641,3643,1,0,0,0,3642, - 3623,1,0,0,0,3642,3631,1,0,0,0,3643,357,1,0,0,0,3644,3645,7,12,0,0,3645, - 359,1,0,0,0,3646,3648,3,362,181,0,3647,3646,1,0,0,0,3648,3651,1,0,0,0, - 3649,3647,1,0,0,0,3649,3650,1,0,0,0,3650,361,1,0,0,0,3651,3649,1,0,0,0, - 3652,3653,5,21,0,0,3653,3654,3,2,1,0,3654,3655,5,44,0,0,3655,3656,3,32, - 16,0,3656,3663,1,0,0,0,3657,3658,5,25,0,0,3658,3659,5,40,0,0,3659,3663, - 3,2,1,0,3660,3663,3,330,165,0,3661,3663,3,40,20,0,3662,3652,1,0,0,0,3662, - 3657,1,0,0,0,3662,3660,1,0,0,0,3662,3661,1,0,0,0,3663,363,1,0,0,0,182, - 374,382,391,400,489,535,546,576,580,598,625,653,693,704,714,716,727,729, - 737,759,772,793,795,814,887,894,901,906,915,1026,1032,1048,1054,1060,1067, - 1095,1173,1175,1189,1195,1204,1206,1215,1229,1243,1251,1259,1263,1302, - 1310,1319,1327,1346,1356,1359,1383,1530,1540,1549,1552,1634,1643,1675, - 1735,1775,1791,1801,1828,1852,1860,1864,1879,1886,1931,1941,1959,1977, - 1996,2017,2036,2051,2059,2071,2091,2098,2103,2114,2126,2236,2248,2264, - 2278,2287,2300,2302,2345,2356,2363,2371,2379,2392,2398,2404,2409,2438, - 2446,2460,2465,2490,2499,2510,2514,2521,2541,2550,2552,2567,2614,2624, - 2626,2633,2639,2683,2692,2732,2737,2777,2781,2791,2813,2825,2836,2851, - 2864,2877,2880,2892,2906,2924,2942,2956,2980,2992,2997,3006,3008,3015, - 3025,3093,3185,3192,3205,3378,3386,3388,3397,3399,3407,3415,3423,3431, - 3439,3446,3448,3456,3467,3474,3486,3513,3532,3537,3554,3566,3575,3595, - 3600,3616,3627,3635,3642,3649,3662 + 1,166,1,166,1,166,1,166,1,166,1,166,3,166,3480,8,166,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,168,3,168,3499,8,168,1,169,5,169,3502,8,169,10,169,12,169,3505, + 9,169,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170, + 1,170,1,170,1,170,3,170,3521,8,170,1,171,1,171,1,171,1,171,1,171,1,172, + 1,172,1,172,5,172,3531,8,172,10,172,12,172,3534,9,172,1,172,1,172,1,173, + 1,173,5,173,3540,8,173,10,173,12,173,3543,9,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,3,174,3562,8,174,1,175,5,175,3565,8,175,10,175,12,175,3568,9,175, + 1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176, + 1,176,3,176,3583,8,176,1,177,1,177,1,177,1,177,1,177,1,178,1,178,5,178, + 3592,8,178,10,178,12,178,3595,9,178,1,178,1,178,1,178,5,178,3600,8,178, + 10,178,12,178,3603,9,178,1,178,1,178,1,178,1,178,3,178,3609,8,178,1,179, + 1,179,1,180,5,180,3614,8,180,10,180,12,180,3617,9,180,1,181,1,181,1,181, + 1,181,1,181,1,181,1,181,1,181,1,181,1,181,3,181,3629,8,181,1,181,0,1,68, + 182,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,0,16,6,0,1,15,199,199,243,243,247,247, + 264,264,289,289,5,0,16,16,199,199,243,243,264,264,288,289,1,0,263,264, + 1,0,173,174,1,0,37,38,1,0,73,74,3,0,2,2,61,61,77,83,2,0,229,229,260,261, + 1,0,95,96,1,0,97,111,1,0,188,189,1,0,184,186,1,0,184,189,2,0,173,173,289, + 290,1,0,167,168,1,0,51,52,4080,0,364,1,0,0,0,2,382,1,0,0,0,4,384,1,0,0, + 0,6,391,1,0,0,0,8,400,1,0,0,0,10,489,1,0,0,0,12,491,1,0,0,0,14,495,1,0, + 0,0,16,499,1,0,0,0,18,504,1,0,0,0,20,508,1,0,0,0,22,512,1,0,0,0,24,519, + 1,0,0,0,26,539,1,0,0,0,28,541,1,0,0,0,30,543,1,0,0,0,32,555,1,0,0,0,34, + 557,1,0,0,0,36,580,1,0,0,0,38,584,1,0,0,0,40,602,1,0,0,0,42,629,1,0,0, + 0,44,657,1,0,0,0,46,697,1,0,0,0,48,699,1,0,0,0,50,708,1,0,0,0,52,710,1, + 0,0,0,54,720,1,0,0,0,56,733,1,0,0,0,58,736,1,0,0,0,60,739,1,0,0,0,62,763, + 1,0,0,0,64,776,1,0,0,0,66,778,1,0,0,0,68,786,1,0,0,0,70,802,1,0,0,0,72, + 808,1,0,0,0,74,812,1,0,0,0,76,891,1,0,0,0,78,898,1,0,0,0,80,905,1,0,0, + 0,82,910,1,0,0,0,84,919,1,0,0,0,86,925,1,0,0,0,88,978,1,0,0,0,90,1006, + 1,0,0,0,92,1008,1,0,0,0,94,1012,1,0,0,0,96,1014,1,0,0,0,98,1019,1,0,0, + 0,100,1047,1,0,0,0,102,1127,1,0,0,0,104,1129,1,0,0,0,106,1158,1,0,0,0, + 108,1160,1,0,0,0,110,1174,1,0,0,0,112,1203,1,0,0,0,114,1215,1,0,0,0,116, + 1254,1,0,0,0,118,1262,1,0,0,0,120,1271,1,0,0,0,122,1279,1,0,0,0,124,1298, + 1,0,0,0,126,1311,1,0,0,0,128,1335,1,0,0,0,130,1482,1,0,0,0,132,1492,1, + 0,0,0,134,1504,1,0,0,0,136,1586,1,0,0,0,138,1588,1,0,0,0,140,1627,1,0, + 0,0,142,1687,1,0,0,0,144,1727,1,0,0,0,146,1743,1,0,0,0,148,1745,1,0,0, + 0,150,1749,1,0,0,0,152,1811,1,0,0,0,154,1826,1,0,0,0,156,1843,1,0,0,0, + 158,1851,1,0,0,0,160,1857,1,0,0,0,162,1862,1,0,0,0,164,1909,1,0,0,0,166, + 1911,1,0,0,0,168,1955,1,0,0,0,170,1974,1,0,0,0,172,1995,1,0,0,0,174,1997, + 1,0,0,0,176,2014,1,0,0,0,178,2029,1,0,0,0,180,2037,1,0,0,0,182,2049,1, + 0,0,0,184,2069,1,0,0,0,186,2076,1,0,0,0,188,2079,1,0,0,0,190,2092,1,0, + 0,0,192,2098,1,0,0,0,194,2104,1,0,0,0,196,2108,1,0,0,0,198,2265,1,0,0, + 0,200,2267,1,0,0,0,202,2323,1,0,0,0,204,2334,1,0,0,0,206,2341,1,0,0,0, + 208,2349,1,0,0,0,210,2376,1,0,0,0,212,2382,1,0,0,0,214,2387,1,0,0,0,216, + 2416,1,0,0,0,218,2418,1,0,0,0,220,2438,1,0,0,0,222,2443,1,0,0,0,224,2468, + 1,0,0,0,226,2477,1,0,0,0,228,2492,1,0,0,0,230,2499,1,0,0,0,232,2519,1, + 0,0,0,234,2521,1,0,0,0,236,2592,1,0,0,0,238,2617,1,0,0,0,240,2661,1,0, + 0,0,242,2670,1,0,0,0,244,2710,1,0,0,0,246,2715,1,0,0,0,248,2755,1,0,0, + 0,250,2757,1,0,0,0,252,2763,1,0,0,0,254,2771,1,0,0,0,256,2791,1,0,0,0, + 258,2858,1,0,0,0,260,2860,1,0,0,0,262,2870,1,0,0,0,264,2872,1,0,0,0,266, + 2876,1,0,0,0,268,2882,1,0,0,0,270,2902,1,0,0,0,272,2920,1,0,0,0,274,2934, + 1,0,0,0,276,2936,1,0,0,0,278,2939,1,0,0,0,280,2941,1,0,0,0,282,2958,1, + 0,0,0,284,2960,1,0,0,0,286,2973,1,0,0,0,288,2980,1,0,0,0,290,2991,1,0, + 0,0,292,2998,1,0,0,0,294,3009,1,0,0,0,296,3059,1,0,0,0,298,3151,1,0,0, + 0,300,3158,1,0,0,0,302,3161,1,0,0,0,304,3171,1,0,0,0,306,3344,1,0,0,0, + 308,3354,1,0,0,0,310,3365,1,0,0,0,312,3373,1,0,0,0,314,3381,1,0,0,0,316, + 3389,1,0,0,0,318,3397,1,0,0,0,320,3405,1,0,0,0,322,3414,1,0,0,0,324,3422, + 1,0,0,0,326,3433,1,0,0,0,328,3440,1,0,0,0,330,3452,1,0,0,0,332,3479,1, + 0,0,0,334,3481,1,0,0,0,336,3498,1,0,0,0,338,3503,1,0,0,0,340,3520,1,0, + 0,0,342,3522,1,0,0,0,344,3527,1,0,0,0,346,3537,1,0,0,0,348,3561,1,0,0, + 0,350,3566,1,0,0,0,352,3582,1,0,0,0,354,3584,1,0,0,0,356,3608,1,0,0,0, + 358,3610,1,0,0,0,360,3615,1,0,0,0,362,3628,1,0,0,0,364,365,7,0,0,0,365, + 1,1,0,0,0,366,367,5,288,0,0,367,383,6,1,-1,0,368,369,3,4,2,0,369,370,6, + 1,-1,0,370,371,5,265,0,0,371,373,1,0,0,0,372,368,1,0,0,0,373,376,1,0,0, + 0,374,372,1,0,0,0,374,375,1,0,0,0,375,377,1,0,0,0,376,374,1,0,0,0,377, + 378,3,4,2,0,378,379,6,1,-1,0,379,383,1,0,0,0,380,381,5,264,0,0,381,383, + 6,1,-1,0,382,366,1,0,0,0,382,374,1,0,0,0,382,380,1,0,0,0,383,3,1,0,0,0, + 384,385,7,1,0,0,385,5,1,0,0,0,386,387,5,263,0,0,387,388,6,3,-1,0,388,390, + 5,266,0,0,389,386,1,0,0,0,390,393,1,0,0,0,391,389,1,0,0,0,391,392,1,0, + 0,0,392,394,1,0,0,0,393,391,1,0,0,0,394,395,5,263,0,0,395,396,6,3,-1,0, + 396,7,1,0,0,0,397,399,3,10,5,0,398,397,1,0,0,0,399,402,1,0,0,0,400,398, + 1,0,0,0,400,401,1,0,0,0,401,9,1,0,0,0,402,400,1,0,0,0,403,404,3,74,37, + 0,404,405,5,17,0,0,405,406,3,82,41,0,406,407,5,18,0,0,407,490,1,0,0,0, + 408,409,3,72,36,0,409,410,5,17,0,0,410,411,3,8,4,0,411,412,5,18,0,0,412, + 490,1,0,0,0,413,414,3,234,117,0,414,415,5,17,0,0,415,416,3,246,123,0,416, + 417,5,18,0,0,417,490,1,0,0,0,418,490,3,200,100,0,419,420,6,5,-1,0,420, + 421,3,284,142,0,421,422,6,5,-1,0,422,490,1,0,0,0,423,424,6,5,-1,0,424, + 425,3,70,35,0,425,426,6,5,-1,0,426,490,1,0,0,0,427,428,6,5,-1,0,428,429, + 3,66,33,0,429,430,6,5,-1,0,430,490,1,0,0,0,431,432,6,5,-1,0,432,433,3, + 88,44,0,433,434,6,5,-1,0,434,490,1,0,0,0,435,436,6,5,-1,0,436,437,3,90, + 45,0,437,438,6,5,-1,0,438,490,1,0,0,0,439,440,6,5,-1,0,440,441,3,22,11, + 0,441,442,6,5,-1,0,442,490,1,0,0,0,443,444,6,5,-1,0,444,445,3,334,167, + 0,445,446,6,5,-1,0,446,490,1,0,0,0,447,448,6,5,-1,0,448,449,3,342,171, + 0,449,450,6,5,-1,0,450,490,1,0,0,0,451,452,6,5,-1,0,452,453,3,354,177, + 0,453,454,6,5,-1,0,454,490,1,0,0,0,455,456,6,5,-1,0,456,457,3,64,32,0, + 457,458,6,5,-1,0,458,490,1,0,0,0,459,460,6,5,-1,0,460,461,3,152,76,0,461, + 462,6,5,-1,0,462,490,1,0,0,0,463,464,3,330,165,0,464,465,6,5,-1,0,465, + 490,1,0,0,0,466,467,6,5,-1,0,467,490,3,12,6,0,468,469,6,5,-1,0,469,490, + 3,14,7,0,470,471,6,5,-1,0,471,490,3,16,8,0,472,473,6,5,-1,0,473,490,3, + 18,9,0,474,475,6,5,-1,0,475,490,3,20,10,0,476,477,6,5,-1,0,477,478,3,26, + 13,0,478,479,6,5,-1,0,479,490,1,0,0,0,480,481,6,5,-1,0,481,482,3,42,21, + 0,482,483,6,5,-1,0,483,490,1,0,0,0,484,485,6,5,-1,0,485,490,3,40,20,0, + 486,490,3,30,15,0,487,488,6,5,-1,0,488,490,3,24,12,0,489,403,1,0,0,0,489, + 408,1,0,0,0,489,413,1,0,0,0,489,418,1,0,0,0,489,419,1,0,0,0,489,423,1, + 0,0,0,489,427,1,0,0,0,489,431,1,0,0,0,489,435,1,0,0,0,489,439,1,0,0,0, + 489,443,1,0,0,0,489,447,1,0,0,0,489,451,1,0,0,0,489,455,1,0,0,0,489,459, + 1,0,0,0,489,463,1,0,0,0,489,466,1,0,0,0,489,468,1,0,0,0,489,470,1,0,0, + 0,489,472,1,0,0,0,489,474,1,0,0,0,489,476,1,0,0,0,489,480,1,0,0,0,489, + 484,1,0,0,0,489,486,1,0,0,0,489,487,1,0,0,0,490,11,1,0,0,0,491,492,5,19, + 0,0,492,493,3,32,16,0,493,494,6,6,-1,0,494,13,1,0,0,0,495,496,5,20,0,0, + 496,497,3,32,16,0,497,498,6,7,-1,0,498,15,1,0,0,0,499,500,5,21,0,0,500, + 501,5,22,0,0,501,502,3,32,16,0,502,503,6,8,-1,0,503,17,1,0,0,0,504,505, + 5,23,0,0,505,506,3,34,17,0,506,507,6,9,-1,0,507,19,1,0,0,0,508,509,5,24, + 0,0,509,510,3,34,17,0,510,511,6,10,-1,0,511,21,1,0,0,0,512,513,5,25,0, + 0,513,514,3,98,49,0,514,515,3,2,1,0,515,516,5,17,0,0,516,517,3,120,60, + 0,517,518,5,18,0,0,518,23,1,0,0,0,519,520,5,26,0,0,520,25,1,0,0,0,521, + 522,5,27,0,0,522,523,3,28,14,0,523,524,6,13,-1,0,524,540,1,0,0,0,525,526, + 5,27,0,0,526,527,3,28,14,0,527,528,5,28,0,0,528,529,3,28,14,0,529,530, + 6,13,-1,0,530,540,1,0,0,0,531,532,5,27,0,0,532,533,3,28,14,0,533,534,5, + 28,0,0,534,535,3,28,14,0,535,536,5,28,0,0,536,537,3,28,14,0,537,538,6, + 13,-1,0,538,540,1,0,0,0,539,521,1,0,0,0,539,525,1,0,0,0,539,531,1,0,0, + 0,540,27,1,0,0,0,541,542,7,2,0,0,542,29,1,0,0,0,543,544,5,29,0,0,544,550, + 5,17,0,0,545,546,3,116,58,0,546,547,6,15,-1,0,547,549,1,0,0,0,548,545, + 1,0,0,0,549,552,1,0,0,0,550,548,1,0,0,0,550,551,1,0,0,0,551,553,1,0,0, + 0,552,550,1,0,0,0,553,554,5,18,0,0,554,31,1,0,0,0,555,556,5,173,0,0,556, + 33,1,0,0,0,557,558,7,3,0,0,558,35,1,0,0,0,559,560,5,175,0,0,560,581,6, + 18,-1,0,561,562,3,32,16,0,562,563,5,265,0,0,563,564,6,18,-1,0,564,581, + 1,0,0,0,565,566,3,32,16,0,566,567,6,18,-1,0,567,581,1,0,0,0,568,569,5, + 188,0,0,569,570,5,30,0,0,570,571,3,32,16,0,571,572,5,31,0,0,572,573,6, + 18,-1,0,573,581,1,0,0,0,574,575,5,189,0,0,575,576,5,30,0,0,576,577,3,34, + 17,0,577,578,5,31,0,0,578,579,6,18,-1,0,579,581,1,0,0,0,580,559,1,0,0, + 0,580,561,1,0,0,0,580,565,1,0,0,0,580,568,1,0,0,0,580,574,1,0,0,0,581, + 37,1,0,0,0,582,585,3,32,16,0,583,585,5,262,0,0,584,582,1,0,0,0,584,583, + 1,0,0,0,585,39,1,0,0,0,586,587,5,267,0,0,587,603,5,289,0,0,588,589,5,267, + 0,0,589,590,5,289,0,0,590,603,5,263,0,0,591,592,5,268,0,0,592,603,5,289, + 0,0,593,594,5,269,0,0,594,603,5,289,0,0,595,596,5,270,0,0,596,603,5,289, + 0,0,597,603,5,271,0,0,598,603,5,272,0,0,599,600,5,273,0,0,600,603,5,263, + 0,0,601,603,5,32,0,0,602,586,1,0,0,0,602,588,1,0,0,0,602,591,1,0,0,0,602, + 593,1,0,0,0,602,595,1,0,0,0,602,597,1,0,0,0,602,598,1,0,0,0,602,599,1, + 0,0,0,602,601,1,0,0,0,603,41,1,0,0,0,604,605,5,33,0,0,605,606,3,138,69, + 0,606,607,5,34,0,0,607,608,3,2,1,0,608,630,1,0,0,0,609,610,5,33,0,0,610, + 611,3,116,58,0,611,612,5,34,0,0,612,613,3,2,1,0,613,630,1,0,0,0,614,615, + 5,33,0,0,615,616,3,176,88,0,616,617,5,34,0,0,617,618,3,2,1,0,618,630,1, + 0,0,0,619,620,5,33,0,0,620,621,3,44,22,0,621,622,5,34,0,0,622,623,3,2, + 1,0,623,630,1,0,0,0,624,625,5,33,0,0,625,626,3,46,23,0,626,627,5,34,0, + 0,627,628,3,2,1,0,628,630,1,0,0,0,629,604,1,0,0,0,629,609,1,0,0,0,629, + 614,1,0,0,0,629,619,1,0,0,0,629,624,1,0,0,0,630,43,1,0,0,0,631,632,5,35, + 0,0,632,633,3,48,24,0,633,634,6,22,-1,0,634,658,1,0,0,0,635,636,5,35,0, + 0,636,637,3,48,24,0,637,638,5,36,0,0,638,639,3,6,3,0,639,640,6,22,-1,0, + 640,658,1,0,0,0,641,642,5,35,0,0,642,643,3,48,24,0,643,644,5,36,0,0,644, + 645,5,17,0,0,645,646,3,52,26,0,646,647,5,18,0,0,647,648,6,22,-1,0,648, + 658,1,0,0,0,649,650,5,35,0,0,650,651,3,48,24,0,651,652,5,36,0,0,652,653, + 5,30,0,0,653,654,3,300,150,0,654,655,5,31,0,0,655,656,6,22,-1,0,656,658, + 1,0,0,0,657,631,1,0,0,0,657,635,1,0,0,0,657,641,1,0,0,0,657,649,1,0,0, + 0,658,45,1,0,0,0,659,660,5,35,0,0,660,661,5,30,0,0,661,662,3,50,25,0,662, + 663,5,31,0,0,663,664,3,48,24,0,664,665,6,23,-1,0,665,698,1,0,0,0,666,667, + 5,35,0,0,667,668,5,30,0,0,668,669,3,50,25,0,669,670,5,31,0,0,670,671,3, + 48,24,0,671,672,5,36,0,0,672,673,3,6,3,0,673,674,6,23,-1,0,674,698,1,0, + 0,0,675,676,5,35,0,0,676,677,5,30,0,0,677,678,3,50,25,0,678,679,5,31,0, + 0,679,680,3,48,24,0,680,681,5,36,0,0,681,682,5,17,0,0,682,683,3,52,26, + 0,683,684,5,18,0,0,684,685,6,23,-1,0,685,698,1,0,0,0,686,687,5,35,0,0, + 687,688,5,30,0,0,688,689,3,50,25,0,689,690,5,31,0,0,690,691,3,48,24,0, + 691,692,5,36,0,0,692,693,5,30,0,0,693,694,3,300,150,0,694,695,5,31,0,0, + 695,696,6,23,-1,0,696,698,1,0,0,0,697,659,1,0,0,0,697,666,1,0,0,0,697, + 675,1,0,0,0,697,686,1,0,0,0,698,47,1,0,0,0,699,700,3,168,84,0,700,701, + 6,24,-1,0,701,49,1,0,0,0,702,703,3,124,62,0,703,704,6,25,-1,0,704,709, + 1,0,0,0,705,706,3,176,88,0,706,707,6,25,-1,0,707,709,1,0,0,0,708,702,1, + 0,0,0,708,705,1,0,0,0,709,51,1,0,0,0,710,711,3,54,27,0,711,712,3,56,28, + 0,712,713,6,26,-1,0,713,53,1,0,0,0,714,715,3,306,153,0,715,716,6,27,-1, + 0,716,719,1,0,0,0,717,719,3,40,20,0,718,714,1,0,0,0,718,717,1,0,0,0,719, + 722,1,0,0,0,720,718,1,0,0,0,720,721,1,0,0,0,721,55,1,0,0,0,722,720,1,0, + 0,0,723,724,3,58,29,0,724,725,3,60,30,0,725,726,3,2,1,0,726,727,5,36,0, + 0,727,728,3,306,153,0,728,729,6,28,-1,0,729,732,1,0,0,0,730,732,3,40,20, + 0,731,723,1,0,0,0,731,730,1,0,0,0,732,735,1,0,0,0,733,731,1,0,0,0,733, + 734,1,0,0,0,734,57,1,0,0,0,735,733,1,0,0,0,736,737,7,4,0,0,737,738,6,29, + -1,0,738,59,1,0,0,0,739,741,3,62,31,0,740,742,5,261,0,0,741,740,1,0,0, + 0,741,742,1,0,0,0,742,743,1,0,0,0,743,744,6,30,-1,0,744,61,1,0,0,0,745, + 746,3,144,72,0,746,747,6,31,-1,0,747,764,1,0,0,0,748,749,3,2,1,0,749,750, + 6,31,-1,0,750,764,1,0,0,0,751,752,5,196,0,0,752,764,6,31,-1,0,753,754, + 5,197,0,0,754,764,6,31,-1,0,755,756,5,202,0,0,756,757,5,39,0,0,757,758, + 5,264,0,0,758,764,6,31,-1,0,759,760,5,202,0,0,760,761,3,116,58,0,761,762, + 6,31,-1,0,762,764,1,0,0,0,763,745,1,0,0,0,763,748,1,0,0,0,763,751,1,0, + 0,0,763,753,1,0,0,0,763,755,1,0,0,0,763,759,1,0,0,0,764,63,1,0,0,0,765, + 766,5,198,0,0,766,767,5,40,0,0,767,768,3,2,1,0,768,769,6,32,-1,0,769,777, + 1,0,0,0,770,771,5,198,0,0,771,772,3,2,1,0,772,773,6,32,-1,0,773,777,1, + 0,0,0,774,775,5,198,0,0,775,777,6,32,-1,0,776,765,1,0,0,0,776,770,1,0, + 0,0,776,774,1,0,0,0,777,65,1,0,0,0,778,779,5,41,0,0,779,780,5,42,0,0,780, + 781,3,32,16,0,781,782,5,43,0,0,782,783,3,68,34,0,783,784,5,44,0,0,784, + 785,3,0,0,0,785,67,1,0,0,0,786,799,6,34,-1,0,787,788,10,5,0,0,788,798, + 5,186,0,0,789,790,10,4,0,0,790,798,5,187,0,0,791,792,10,3,0,0,792,798, + 5,45,0,0,793,794,10,2,0,0,794,798,5,46,0,0,795,796,10,1,0,0,796,798,5, + 47,0,0,797,787,1,0,0,0,797,789,1,0,0,0,797,791,1,0,0,0,797,793,1,0,0,0, + 797,795,1,0,0,0,798,801,1,0,0,0,799,797,1,0,0,0,799,800,1,0,0,0,800,69, + 1,0,0,0,801,799,1,0,0,0,802,803,5,48,0,0,803,804,5,36,0,0,804,805,5,30, + 0,0,805,806,3,300,150,0,806,807,5,31,0,0,807,71,1,0,0,0,808,809,5,49,0, + 0,809,810,3,2,1,0,810,811,6,36,-1,0,811,73,1,0,0,0,812,818,5,50,0,0,813, + 814,3,76,38,0,814,815,6,37,-1,0,815,817,1,0,0,0,816,813,1,0,0,0,817,820, + 1,0,0,0,818,816,1,0,0,0,818,819,1,0,0,0,819,821,1,0,0,0,820,818,1,0,0, + 0,821,822,3,2,1,0,822,823,3,182,91,0,823,824,3,78,39,0,824,825,3,80,40, + 0,825,826,6,37,-1,0,826,75,1,0,0,0,827,828,5,51,0,0,828,892,6,38,-1,0, + 829,830,5,52,0,0,830,892,6,38,-1,0,831,832,5,199,0,0,832,892,6,38,-1,0, + 833,834,5,202,0,0,834,892,6,38,-1,0,835,836,5,221,0,0,836,892,6,38,-1, + 0,837,838,5,53,0,0,838,892,6,38,-1,0,839,840,5,54,0,0,840,892,6,38,-1, + 0,841,842,5,55,0,0,842,892,6,38,-1,0,843,844,5,56,0,0,844,892,6,38,-1, + 0,845,846,5,244,0,0,846,892,6,38,-1,0,847,848,5,15,0,0,848,892,6,38,-1, + 0,849,850,5,224,0,0,850,892,6,38,-1,0,851,852,5,57,0,0,852,892,6,38,-1, + 0,853,854,5,58,0,0,854,892,6,38,-1,0,855,856,5,59,0,0,856,892,6,38,-1, + 0,857,858,5,60,0,0,858,892,6,38,-1,0,859,860,5,61,0,0,860,892,6,38,-1, + 0,861,862,5,62,0,0,862,863,5,51,0,0,863,892,6,38,-1,0,864,865,5,62,0,0, + 865,866,5,52,0,0,866,892,6,38,-1,0,867,868,5,62,0,0,868,869,5,63,0,0,869, + 892,6,38,-1,0,870,871,5,62,0,0,871,872,5,64,0,0,872,892,6,38,-1,0,873, + 874,5,62,0,0,874,875,5,65,0,0,875,892,6,38,-1,0,876,877,5,62,0,0,877,878, + 5,66,0,0,878,892,6,38,-1,0,879,880,5,67,0,0,880,892,6,38,-1,0,881,882, + 5,68,0,0,882,892,6,38,-1,0,883,884,5,69,0,0,884,892,6,38,-1,0,885,886, + 5,70,0,0,886,887,5,30,0,0,887,888,3,32,16,0,888,889,5,31,0,0,889,890,6, + 38,-1,0,890,892,1,0,0,0,891,827,1,0,0,0,891,829,1,0,0,0,891,831,1,0,0, + 0,891,833,1,0,0,0,891,835,1,0,0,0,891,837,1,0,0,0,891,839,1,0,0,0,891, + 841,1,0,0,0,891,843,1,0,0,0,891,845,1,0,0,0,891,847,1,0,0,0,891,849,1, + 0,0,0,891,851,1,0,0,0,891,853,1,0,0,0,891,855,1,0,0,0,891,857,1,0,0,0, + 891,859,1,0,0,0,891,861,1,0,0,0,891,864,1,0,0,0,891,867,1,0,0,0,891,870, + 1,0,0,0,891,873,1,0,0,0,891,876,1,0,0,0,891,879,1,0,0,0,891,881,1,0,0, + 0,891,883,1,0,0,0,891,885,1,0,0,0,892,77,1,0,0,0,893,899,1,0,0,0,894,895, + 5,71,0,0,895,896,3,124,62,0,896,897,6,39,-1,0,897,899,1,0,0,0,898,893, + 1,0,0,0,898,894,1,0,0,0,899,79,1,0,0,0,900,906,1,0,0,0,901,902,5,72,0, + 0,902,903,3,84,42,0,903,904,6,40,-1,0,904,906,1,0,0,0,905,900,1,0,0,0, + 905,901,1,0,0,0,906,81,1,0,0,0,907,909,3,198,99,0,908,907,1,0,0,0,909, + 912,1,0,0,0,910,908,1,0,0,0,910,911,1,0,0,0,911,83,1,0,0,0,912,910,1,0, + 0,0,913,914,3,124,62,0,914,915,6,42,-1,0,915,916,5,28,0,0,916,918,1,0, + 0,0,917,913,1,0,0,0,918,921,1,0,0,0,919,917,1,0,0,0,919,920,1,0,0,0,920, + 922,1,0,0,0,921,919,1,0,0,0,922,923,3,124,62,0,923,924,6,42,-1,0,924,85, + 1,0,0,0,925,926,7,5,0,0,926,87,1,0,0,0,927,928,3,86,43,0,928,930,3,32, + 16,0,929,931,7,2,0,0,930,929,1,0,0,0,930,931,1,0,0,0,931,932,1,0,0,0,932, + 933,6,44,-1,0,933,979,1,0,0,0,934,935,3,86,43,0,935,936,3,32,16,0,936, + 937,5,75,0,0,937,939,3,32,16,0,938,940,7,2,0,0,939,938,1,0,0,0,939,940, + 1,0,0,0,940,941,1,0,0,0,941,942,6,44,-1,0,942,979,1,0,0,0,943,944,3,86, + 43,0,944,945,3,32,16,0,945,946,5,75,0,0,946,947,3,32,16,0,947,948,5,28, + 0,0,948,950,3,32,16,0,949,951,7,2,0,0,950,949,1,0,0,0,950,951,1,0,0,0, + 951,952,1,0,0,0,952,953,6,44,-1,0,953,979,1,0,0,0,954,955,3,86,43,0,955, + 956,3,32,16,0,956,957,5,28,0,0,957,958,3,32,16,0,958,959,5,75,0,0,959, + 961,3,32,16,0,960,962,7,2,0,0,961,960,1,0,0,0,961,962,1,0,0,0,962,963, + 1,0,0,0,963,964,6,44,-1,0,964,979,1,0,0,0,965,966,3,86,43,0,966,967,3, + 32,16,0,967,968,5,28,0,0,968,969,3,32,16,0,969,970,5,75,0,0,970,971,3, + 32,16,0,971,972,5,28,0,0,972,974,3,32,16,0,973,975,7,2,0,0,974,973,1,0, + 0,0,974,975,1,0,0,0,975,976,1,0,0,0,976,977,6,44,-1,0,977,979,1,0,0,0, + 978,927,1,0,0,0,978,934,1,0,0,0,978,943,1,0,0,0,978,954,1,0,0,0,978,965, + 1,0,0,0,979,89,1,0,0,0,980,984,5,21,0,0,981,983,3,92,46,0,982,981,1,0, + 0,0,983,986,1,0,0,0,984,982,1,0,0,0,984,985,1,0,0,0,985,987,1,0,0,0,986, + 984,1,0,0,0,987,988,3,2,1,0,988,989,3,94,47,0,989,990,5,180,0,0,990,991, + 5,36,0,0,991,992,5,30,0,0,992,993,3,300,150,0,993,994,5,31,0,0,994,995, + 3,94,47,0,995,1007,1,0,0,0,996,1000,5,21,0,0,997,999,3,92,46,0,998,997, + 1,0,0,0,999,1002,1,0,0,0,1000,998,1,0,0,0,1000,1001,1,0,0,0,1001,1003, + 1,0,0,0,1002,1000,1,0,0,0,1003,1004,3,2,1,0,1004,1005,3,94,47,0,1005,1007, + 1,0,0,0,1006,980,1,0,0,0,1006,996,1,0,0,0,1007,91,1,0,0,0,1008,1009,5, + 76,0,0,1009,93,1,0,0,0,1010,1013,1,0,0,0,1011,1013,5,298,0,0,1012,1010, + 1,0,0,0,1012,1011,1,0,0,0,1013,95,1,0,0,0,1014,1015,7,6,0,0,1015,97,1, + 0,0,0,1016,1018,3,96,48,0,1017,1016,1,0,0,0,1018,1021,1,0,0,0,1019,1017, + 1,0,0,0,1019,1020,1,0,0,0,1020,99,1,0,0,0,1021,1019,1,0,0,0,1022,1048, + 3,102,51,0,1023,1024,5,280,0,0,1024,1025,3,168,84,0,1025,1026,6,50,-1, + 0,1026,1048,1,0,0,0,1027,1028,5,286,0,0,1028,1029,3,178,89,0,1029,1030, + 6,50,-1,0,1030,1048,1,0,0,0,1031,1032,5,286,0,0,1032,1033,3,174,87,0,1033, + 1034,6,50,-1,0,1034,1048,1,0,0,0,1035,1036,5,284,0,0,1036,1037,3,124,62, + 0,1037,1038,6,50,-1,0,1038,1048,1,0,0,0,1039,1040,5,281,0,0,1040,1041, + 3,104,52,0,1041,1042,6,50,-1,0,1042,1048,1,0,0,0,1043,1044,5,287,0,0,1044, + 1045,3,50,25,0,1045,1046,6,50,-1,0,1046,1048,1,0,0,0,1047,1022,1,0,0,0, + 1047,1023,1,0,0,0,1047,1027,1,0,0,0,1047,1031,1,0,0,0,1047,1035,1,0,0, + 0,1047,1039,1,0,0,0,1047,1043,1,0,0,0,1048,101,1,0,0,0,1049,1050,5,275, + 0,0,1050,1128,6,51,-1,0,1051,1052,5,276,0,0,1052,1053,3,32,16,0,1053,1054, + 6,51,-1,0,1054,1128,1,0,0,0,1055,1056,5,276,0,0,1056,1057,3,0,0,0,1057, + 1058,6,51,-1,0,1058,1128,1,0,0,0,1059,1060,5,277,0,0,1060,1061,3,32,16, + 0,1061,1062,6,51,-1,0,1062,1128,1,0,0,0,1063,1064,5,278,0,0,1064,1065, + 3,34,17,0,1065,1066,6,51,-1,0,1066,1128,1,0,0,0,1067,1068,5,279,0,0,1068, + 1069,3,36,18,0,1069,1070,6,51,-1,0,1070,1128,1,0,0,0,1071,1072,5,279,0, + 0,1072,1073,3,34,17,0,1073,1074,6,51,-1,0,1074,1128,1,0,0,0,1075,1076, + 5,279,0,0,1076,1077,5,30,0,0,1077,1078,3,300,150,0,1078,1079,5,31,0,0, + 1079,1080,6,51,-1,0,1080,1128,1,0,0,0,1081,1082,5,279,0,0,1082,1083,5, + 84,0,0,1083,1084,5,30,0,0,1084,1085,3,300,150,0,1085,1086,5,31,0,0,1086, + 1087,6,51,-1,0,1087,1128,1,0,0,0,1088,1089,5,282,0,0,1089,1090,3,32,16, + 0,1090,1091,6,51,-1,0,1091,1128,1,0,0,0,1092,1093,5,282,0,0,1093,1094, + 3,0,0,0,1094,1095,6,51,-1,0,1095,1128,1,0,0,0,1096,1097,5,285,0,0,1097, + 1098,3,6,3,0,1098,1099,6,51,-1,0,1099,1128,1,0,0,0,1100,1101,5,285,0,0, + 1101,1102,5,224,0,0,1102,1103,5,30,0,0,1103,1104,3,6,3,0,1104,1105,5,31, + 0,0,1105,1106,6,51,-1,0,1106,1128,1,0,0,0,1107,1108,5,285,0,0,1108,1109, + 5,84,0,0,1109,1110,5,30,0,0,1110,1111,3,300,150,0,1111,1112,5,31,0,0,1112, + 1113,6,51,-1,0,1113,1128,1,0,0,0,1114,1115,5,287,0,0,1115,1116,3,32,16, + 0,1116,1117,6,51,-1,0,1117,1128,1,0,0,0,1118,1119,5,283,0,0,1119,1125, + 6,51,-1,0,1120,1121,5,30,0,0,1121,1122,3,106,53,0,1122,1123,5,31,0,0,1123, + 1126,1,0,0,0,1124,1126,5,85,0,0,1125,1120,1,0,0,0,1125,1124,1,0,0,0,1126, + 1128,1,0,0,0,1127,1049,1,0,0,0,1127,1051,1,0,0,0,1127,1055,1,0,0,0,1127, + 1059,1,0,0,0,1127,1063,1,0,0,0,1127,1067,1,0,0,0,1127,1071,1,0,0,0,1127, + 1075,1,0,0,0,1127,1081,1,0,0,0,1127,1088,1,0,0,0,1127,1092,1,0,0,0,1127, + 1096,1,0,0,0,1127,1100,1,0,0,0,1127,1107,1,0,0,0,1127,1114,1,0,0,0,1127, + 1118,1,0,0,0,1128,103,1,0,0,0,1129,1130,3,170,85,0,1130,1131,3,138,69, + 0,1131,1132,3,112,56,0,1132,1133,6,52,-1,0,1133,105,1,0,0,0,1134,1159, + 1,0,0,0,1135,1136,3,0,0,0,1136,1137,6,53,-1,0,1137,1142,1,0,0,0,1138,1139, + 3,32,16,0,1139,1140,6,53,-1,0,1140,1142,1,0,0,0,1141,1135,1,0,0,0,1141, + 1138,1,0,0,0,1142,1143,1,0,0,0,1143,1144,5,28,0,0,1144,1146,1,0,0,0,1145, + 1141,1,0,0,0,1146,1149,1,0,0,0,1147,1145,1,0,0,0,1147,1148,1,0,0,0,1148, + 1156,1,0,0,0,1149,1147,1,0,0,0,1150,1151,3,0,0,0,1151,1152,6,53,-1,0,1152, + 1157,1,0,0,0,1153,1154,3,32,16,0,1154,1155,6,53,-1,0,1155,1157,1,0,0,0, + 1156,1150,1,0,0,0,1156,1153,1,0,0,0,1157,1159,1,0,0,0,1158,1134,1,0,0, + 0,1158,1147,1,0,0,0,1159,107,1,0,0,0,1160,1167,5,86,0,0,1161,1162,3,138, + 69,0,1162,1163,6,54,-1,0,1163,1164,5,28,0,0,1164,1166,1,0,0,0,1165,1161, + 1,0,0,0,1166,1169,1,0,0,0,1167,1165,1,0,0,0,1167,1168,1,0,0,0,1168,1170, + 1,0,0,0,1169,1167,1,0,0,0,1170,1171,3,138,69,0,1171,1172,6,54,-1,0,1172, + 1173,5,87,0,0,1173,109,1,0,0,0,1174,1181,5,42,0,0,1175,1176,3,146,73,0, + 1176,1177,6,55,-1,0,1177,1178,5,28,0,0,1178,1180,1,0,0,0,1179,1175,1,0, + 0,0,1180,1183,1,0,0,0,1181,1179,1,0,0,0,1181,1182,1,0,0,0,1182,1184,1, + 0,0,0,1183,1181,1,0,0,0,1184,1185,3,146,73,0,1185,1186,6,55,-1,0,1186, + 1187,5,43,0,0,1187,111,1,0,0,0,1188,1195,5,30,0,0,1189,1190,3,114,57,0, + 1190,1191,6,56,-1,0,1191,1192,5,28,0,0,1192,1194,1,0,0,0,1193,1189,1,0, + 0,0,1194,1197,1,0,0,0,1195,1193,1,0,0,0,1195,1196,1,0,0,0,1196,1198,1, + 0,0,0,1197,1195,1,0,0,0,1198,1199,3,114,57,0,1199,1200,6,56,-1,0,1200, + 1201,5,31,0,0,1201,1204,1,0,0,0,1202,1204,5,85,0,0,1203,1188,1,0,0,0,1203, + 1202,1,0,0,0,1204,113,1,0,0,0,1205,1206,5,177,0,0,1206,1216,6,57,-1,0, + 1207,1208,3,230,115,0,1208,1209,3,138,69,0,1209,1211,3,226,113,0,1210, + 1212,3,0,0,0,1211,1210,1,0,0,0,1211,1212,1,0,0,0,1212,1213,1,0,0,0,1213, + 1214,6,57,-1,0,1214,1216,1,0,0,0,1215,1205,1,0,0,0,1215,1207,1,0,0,0,1216, + 115,1,0,0,0,1217,1218,5,42,0,0,1218,1219,3,2,1,0,1219,1220,5,43,0,0,1220, + 1221,3,118,59,0,1221,1222,6,58,-1,0,1222,1255,1,0,0,0,1223,1224,5,42,0, + 0,1224,1225,3,174,87,0,1225,1226,5,43,0,0,1226,1227,3,118,59,0,1227,1228, + 6,58,-1,0,1228,1255,1,0,0,0,1229,1230,5,42,0,0,1230,1231,5,262,0,0,1231, + 1232,5,43,0,0,1232,1233,3,118,59,0,1233,1234,6,58,-1,0,1234,1255,1,0,0, + 0,1235,1236,5,42,0,0,1236,1237,5,198,0,0,1237,1238,3,2,1,0,1238,1239,5, + 43,0,0,1239,1240,3,118,59,0,1240,1241,6,58,-1,0,1241,1255,1,0,0,0,1242, + 1243,3,118,59,0,1243,1244,6,58,-1,0,1244,1255,1,0,0,0,1245,1246,3,174, + 87,0,1246,1247,6,58,-1,0,1247,1255,1,0,0,0,1248,1249,5,257,0,0,1249,1255, + 6,58,-1,0,1250,1251,5,258,0,0,1251,1255,6,58,-1,0,1252,1253,5,259,0,0, + 1253,1255,6,58,-1,0,1254,1217,1,0,0,0,1254,1223,1,0,0,0,1254,1229,1,0, + 0,0,1254,1235,1,0,0,0,1254,1242,1,0,0,0,1254,1245,1,0,0,0,1254,1248,1, + 0,0,0,1254,1250,1,0,0,0,1254,1252,1,0,0,0,1255,117,1,0,0,0,1256,1257,3, + 2,1,0,1257,1258,6,59,-1,0,1258,1259,5,88,0,0,1259,1261,1,0,0,0,1260,1256, + 1,0,0,0,1261,1264,1,0,0,0,1262,1260,1,0,0,0,1262,1263,1,0,0,0,1263,1265, + 1,0,0,0,1264,1262,1,0,0,0,1265,1266,3,2,1,0,1266,1267,6,59,-1,0,1267,119, + 1,0,0,0,1268,1270,3,122,61,0,1269,1268,1,0,0,0,1270,1273,1,0,0,0,1271, + 1269,1,0,0,0,1271,1272,1,0,0,0,1272,121,1,0,0,0,1273,1271,1,0,0,0,1274, + 1275,5,180,0,0,1275,1276,5,89,0,0,1276,1280,3,32,16,0,1277,1280,3,152, + 76,0,1278,1280,3,332,166,0,1279,1274,1,0,0,0,1279,1277,1,0,0,0,1279,1278, + 1,0,0,0,1280,123,1,0,0,0,1281,1282,3,116,58,0,1282,1283,6,62,-1,0,1283, + 1299,1,0,0,0,1284,1285,5,42,0,0,1285,1286,3,2,1,0,1286,1287,5,43,0,0,1287, + 1288,6,62,-1,0,1288,1299,1,0,0,0,1289,1290,5,42,0,0,1290,1291,5,198,0, + 0,1291,1292,3,2,1,0,1292,1293,5,43,0,0,1293,1294,6,62,-1,0,1294,1299,1, + 0,0,0,1295,1296,3,138,69,0,1296,1297,6,62,-1,0,1297,1299,1,0,0,0,1298, + 1281,1,0,0,0,1298,1284,1,0,0,0,1298,1289,1,0,0,0,1298,1295,1,0,0,0,1299, + 125,1,0,0,0,1300,1312,1,0,0,0,1301,1302,3,130,65,0,1302,1308,6,63,-1,0, + 1303,1304,3,128,64,0,1304,1305,6,63,-1,0,1305,1307,1,0,0,0,1306,1303,1, + 0,0,0,1307,1310,1,0,0,0,1308,1306,1,0,0,0,1308,1309,1,0,0,0,1309,1312, + 1,0,0,0,1310,1308,1,0,0,0,1311,1300,1,0,0,0,1311,1301,1,0,0,0,1312,127, + 1,0,0,0,1313,1314,5,262,0,0,1314,1336,6,64,-1,0,1315,1316,5,261,0,0,1316, + 1336,6,64,-1,0,1317,1318,5,42,0,0,1318,1319,3,32,16,0,1319,1320,5,43,0, + 0,1320,1321,6,64,-1,0,1321,1336,1,0,0,0,1322,1323,5,42,0,0,1323,1324,3, + 32,16,0,1324,1325,5,266,0,0,1325,1326,3,32,16,0,1326,1327,5,43,0,0,1327, + 1328,6,64,-1,0,1328,1336,1,0,0,0,1329,1330,5,42,0,0,1330,1331,5,266,0, + 0,1331,1332,3,32,16,0,1332,1333,5,43,0,0,1333,1334,6,64,-1,0,1334,1336, + 1,0,0,0,1335,1313,1,0,0,0,1335,1315,1,0,0,0,1335,1317,1,0,0,0,1335,1322, + 1,0,0,0,1335,1329,1,0,0,0,1336,129,1,0,0,0,1337,1483,6,65,-1,0,1338,1339, + 5,203,0,0,1339,1340,5,30,0,0,1340,1341,3,6,3,0,1341,1342,5,28,0,0,1342, + 1343,3,6,3,0,1343,1344,5,28,0,0,1344,1345,3,6,3,0,1345,1346,5,28,0,0,1346, + 1347,3,6,3,0,1347,1348,5,31,0,0,1348,1349,6,65,-1,0,1349,1483,1,0,0,0, + 1350,1351,5,203,0,0,1351,1352,5,30,0,0,1352,1353,3,6,3,0,1353,1354,5,28, + 0,0,1354,1355,3,6,3,0,1355,1356,5,31,0,0,1356,1357,6,65,-1,0,1357,1483, + 1,0,0,0,1358,1359,5,204,0,0,1359,1360,5,205,0,0,1360,1361,5,42,0,0,1361, + 1362,3,32,16,0,1362,1363,5,43,0,0,1363,1364,6,65,-1,0,1364,1483,1,0,0, + 0,1365,1366,5,204,0,0,1366,1367,5,206,0,0,1367,1368,5,42,0,0,1368,1369, + 3,32,16,0,1369,1370,5,43,0,0,1370,1371,3,126,63,0,1371,1372,6,65,-1,0, + 1372,1483,1,0,0,0,1373,1374,5,207,0,0,1374,1483,6,65,-1,0,1375,1376,5, + 208,0,0,1376,1483,6,65,-1,0,1377,1378,5,209,0,0,1378,1483,6,65,-1,0,1379, + 1380,5,201,0,0,1380,1483,6,65,-1,0,1381,1382,5,183,0,0,1382,1483,6,65, + -1,0,1383,1384,5,184,0,0,1384,1483,6,65,-1,0,1385,1386,5,185,0,0,1386, + 1483,6,65,-1,0,1387,1388,5,186,0,0,1388,1483,6,65,-1,0,1389,1390,5,187, + 0,0,1390,1483,6,65,-1,0,1391,1392,5,188,0,0,1392,1483,6,65,-1,0,1393,1394, + 5,189,0,0,1394,1483,6,65,-1,0,1395,1396,5,210,0,0,1396,1483,6,65,-1,0, + 1397,1398,5,190,0,0,1398,1483,6,65,-1,0,1399,1400,5,191,0,0,1400,1483, + 6,65,-1,0,1401,1402,5,192,0,0,1402,1483,6,65,-1,0,1403,1404,5,193,0,0, + 1404,1483,6,65,-1,0,1405,1406,5,211,0,0,1406,1483,6,65,-1,0,1407,1408, + 5,212,0,0,1408,1483,6,65,-1,0,1409,1410,5,213,0,0,1410,1483,6,65,-1,0, + 1411,1412,5,214,0,0,1412,1483,6,65,-1,0,1413,1414,5,215,0,0,1414,1483, + 6,65,-1,0,1415,1416,5,216,0,0,1416,1483,6,65,-1,0,1417,1418,5,217,0,0, + 1418,1483,6,65,-1,0,1419,1420,5,218,0,0,1420,1421,3,132,66,0,1421,1422, + 6,65,-1,0,1422,1483,1,0,0,0,1423,1424,5,219,0,0,1424,1425,3,132,66,0,1425, + 1426,6,65,-1,0,1426,1483,1,0,0,0,1427,1428,5,220,0,0,1428,1483,6,65,-1, + 0,1429,1430,5,221,0,0,1430,1431,3,132,66,0,1431,1432,6,65,-1,0,1432,1483, + 1,0,0,0,1433,1434,5,222,0,0,1434,1435,3,134,67,0,1435,1436,6,65,-1,0,1436, + 1483,1,0,0,0,1437,1438,5,222,0,0,1438,1439,3,134,67,0,1439,1440,5,28,0, + 0,1440,1441,3,6,3,0,1441,1442,6,65,-1,0,1442,1483,1,0,0,0,1443,1444,5, + 194,0,0,1444,1483,6,65,-1,0,1445,1446,5,195,0,0,1446,1483,6,65,-1,0,1447, + 1448,5,90,0,0,1448,1449,5,184,0,0,1449,1483,6,65,-1,0,1450,1451,5,90,0, + 0,1451,1452,5,185,0,0,1452,1483,6,65,-1,0,1453,1454,5,90,0,0,1454,1455, + 5,186,0,0,1455,1483,6,65,-1,0,1456,1457,5,90,0,0,1457,1458,5,187,0,0,1458, + 1483,6,65,-1,0,1459,1460,5,62,0,0,1460,1461,5,220,0,0,1461,1483,6,65,-1, + 0,1462,1463,5,223,0,0,1463,1483,6,65,-1,0,1464,1465,5,224,0,0,1465,1466, + 5,213,0,0,1466,1483,6,65,-1,0,1467,1468,5,225,0,0,1468,1483,6,65,-1,0, + 1469,1470,5,207,0,0,1470,1471,5,183,0,0,1471,1483,6,65,-1,0,1472,1473, + 5,226,0,0,1473,1483,6,65,-1,0,1474,1475,5,228,0,0,1475,1483,6,65,-1,0, + 1476,1477,5,34,0,0,1477,1478,5,227,0,0,1478,1483,6,65,-1,0,1479,1480,3, + 2,1,0,1480,1481,6,65,-1,0,1481,1483,1,0,0,0,1482,1337,1,0,0,0,1482,1338, + 1,0,0,0,1482,1350,1,0,0,0,1482,1358,1,0,0,0,1482,1365,1,0,0,0,1482,1373, + 1,0,0,0,1482,1375,1,0,0,0,1482,1377,1,0,0,0,1482,1379,1,0,0,0,1482,1381, + 1,0,0,0,1482,1383,1,0,0,0,1482,1385,1,0,0,0,1482,1387,1,0,0,0,1482,1389, + 1,0,0,0,1482,1391,1,0,0,0,1482,1393,1,0,0,0,1482,1395,1,0,0,0,1482,1397, + 1,0,0,0,1482,1399,1,0,0,0,1482,1401,1,0,0,0,1482,1403,1,0,0,0,1482,1405, + 1,0,0,0,1482,1407,1,0,0,0,1482,1409,1,0,0,0,1482,1411,1,0,0,0,1482,1413, + 1,0,0,0,1482,1415,1,0,0,0,1482,1417,1,0,0,0,1482,1419,1,0,0,0,1482,1423, + 1,0,0,0,1482,1427,1,0,0,0,1482,1429,1,0,0,0,1482,1433,1,0,0,0,1482,1437, + 1,0,0,0,1482,1443,1,0,0,0,1482,1445,1,0,0,0,1482,1447,1,0,0,0,1482,1450, + 1,0,0,0,1482,1453,1,0,0,0,1482,1456,1,0,0,0,1482,1459,1,0,0,0,1482,1462, + 1,0,0,0,1482,1464,1,0,0,0,1482,1467,1,0,0,0,1482,1469,1,0,0,0,1482,1472, + 1,0,0,0,1482,1474,1,0,0,0,1482,1476,1,0,0,0,1482,1479,1,0,0,0,1483,131, + 1,0,0,0,1484,1493,1,0,0,0,1485,1486,5,30,0,0,1486,1487,5,91,0,0,1487,1488, + 5,36,0,0,1488,1489,3,32,16,0,1489,1490,5,31,0,0,1490,1491,6,66,-1,0,1491, + 1493,1,0,0,0,1492,1484,1,0,0,0,1492,1485,1,0,0,0,1493,133,1,0,0,0,1494, + 1505,1,0,0,0,1495,1496,3,136,68,0,1496,1501,6,67,-1,0,1497,1498,7,7,0, + 0,1498,1500,6,67,-1,0,1499,1497,1,0,0,0,1500,1503,1,0,0,0,1501,1499,1, + 0,0,0,1501,1502,1,0,0,0,1502,1505,1,0,0,0,1503,1501,1,0,0,0,1504,1494, + 1,0,0,0,1504,1495,1,0,0,0,1505,135,1,0,0,0,1506,1507,5,178,0,0,1507,1587, + 6,68,-1,0,1508,1509,5,207,0,0,1509,1587,6,68,-1,0,1510,1511,5,208,0,0, + 1511,1587,6,68,-1,0,1512,1513,5,201,0,0,1513,1587,6,68,-1,0,1514,1515, + 5,183,0,0,1515,1587,6,68,-1,0,1516,1517,5,184,0,0,1517,1587,6,68,-1,0, + 1518,1519,5,185,0,0,1519,1587,6,68,-1,0,1520,1521,5,186,0,0,1521,1587, + 6,68,-1,0,1522,1523,5,187,0,0,1523,1587,6,68,-1,0,1524,1525,5,188,0,0, + 1525,1587,6,68,-1,0,1526,1527,5,189,0,0,1527,1587,6,68,-1,0,1528,1529, + 5,190,0,0,1529,1587,6,68,-1,0,1530,1531,5,191,0,0,1531,1587,6,68,-1,0, + 1532,1533,5,192,0,0,1533,1587,6,68,-1,0,1534,1535,5,193,0,0,1535,1587, + 6,68,-1,0,1536,1537,5,262,0,0,1537,1587,6,68,-1,0,1538,1539,5,211,0,0, + 1539,1587,6,68,-1,0,1540,1541,5,212,0,0,1541,1587,6,68,-1,0,1542,1543, + 5,213,0,0,1543,1587,6,68,-1,0,1544,1545,5,214,0,0,1545,1587,6,68,-1,0, + 1546,1547,5,215,0,0,1547,1587,6,68,-1,0,1548,1549,5,218,0,0,1549,1587, + 6,68,-1,0,1550,1551,5,219,0,0,1551,1587,6,68,-1,0,1552,1553,5,222,0,0, + 1553,1587,6,68,-1,0,1554,1555,5,194,0,0,1555,1587,6,68,-1,0,1556,1557, + 5,195,0,0,1557,1587,6,68,-1,0,1558,1559,5,210,0,0,1559,1587,6,68,-1,0, + 1560,1561,5,230,0,0,1561,1587,6,68,-1,0,1562,1563,5,231,0,0,1563,1587, + 6,68,-1,0,1564,1565,5,232,0,0,1565,1587,6,68,-1,0,1566,1567,5,233,0,0, + 1567,1587,6,68,-1,0,1568,1569,5,234,0,0,1569,1587,6,68,-1,0,1570,1571, + 5,235,0,0,1571,1587,6,68,-1,0,1572,1573,5,236,0,0,1573,1587,6,68,-1,0, + 1574,1575,5,237,0,0,1575,1587,6,68,-1,0,1576,1577,5,238,0,0,1577,1587, + 6,68,-1,0,1578,1579,5,239,0,0,1579,1587,6,68,-1,0,1580,1581,5,240,0,0, + 1581,1587,6,68,-1,0,1582,1583,5,241,0,0,1583,1587,6,68,-1,0,1584,1585, + 5,242,0,0,1585,1587,6,68,-1,0,1586,1506,1,0,0,0,1586,1508,1,0,0,0,1586, + 1510,1,0,0,0,1586,1512,1,0,0,0,1586,1514,1,0,0,0,1586,1516,1,0,0,0,1586, + 1518,1,0,0,0,1586,1520,1,0,0,0,1586,1522,1,0,0,0,1586,1524,1,0,0,0,1586, + 1526,1,0,0,0,1586,1528,1,0,0,0,1586,1530,1,0,0,0,1586,1532,1,0,0,0,1586, + 1534,1,0,0,0,1586,1536,1,0,0,0,1586,1538,1,0,0,0,1586,1540,1,0,0,0,1586, + 1542,1,0,0,0,1586,1544,1,0,0,0,1586,1546,1,0,0,0,1586,1548,1,0,0,0,1586, + 1550,1,0,0,0,1586,1552,1,0,0,0,1586,1554,1,0,0,0,1586,1556,1,0,0,0,1586, + 1558,1,0,0,0,1586,1560,1,0,0,0,1586,1562,1,0,0,0,1586,1564,1,0,0,0,1586, + 1566,1,0,0,0,1586,1568,1,0,0,0,1586,1570,1,0,0,0,1586,1572,1,0,0,0,1586, + 1574,1,0,0,0,1586,1576,1,0,0,0,1586,1578,1,0,0,0,1586,1580,1,0,0,0,1586, + 1582,1,0,0,0,1586,1584,1,0,0,0,1587,137,1,0,0,0,1588,1589,3,142,71,0,1589, + 1595,6,69,-1,0,1590,1591,3,140,70,0,1591,1592,6,69,-1,0,1592,1594,1,0, + 0,0,1593,1590,1,0,0,0,1594,1597,1,0,0,0,1595,1593,1,0,0,0,1595,1596,1, + 0,0,0,1596,139,1,0,0,0,1597,1595,1,0,0,0,1598,1599,5,261,0,0,1599,1628, + 6,70,-1,0,1600,1601,5,42,0,0,1601,1602,5,43,0,0,1602,1628,6,70,-1,0,1603, + 1604,3,110,55,0,1604,1605,6,70,-1,0,1605,1628,1,0,0,0,1606,1607,5,260, + 0,0,1607,1628,6,70,-1,0,1608,1609,5,262,0,0,1609,1628,6,70,-1,0,1610,1611, + 5,92,0,0,1611,1628,6,70,-1,0,1612,1613,5,93,0,0,1613,1614,5,30,0,0,1614, + 1615,3,124,62,0,1615,1616,5,31,0,0,1616,1617,6,70,-1,0,1617,1628,1,0,0, + 0,1618,1619,5,94,0,0,1619,1620,5,30,0,0,1620,1621,3,124,62,0,1621,1622, + 5,31,0,0,1622,1623,6,70,-1,0,1623,1628,1,0,0,0,1624,1625,3,108,54,0,1625, + 1626,6,70,-1,0,1626,1628,1,0,0,0,1627,1598,1,0,0,0,1627,1600,1,0,0,0,1627, + 1603,1,0,0,0,1627,1606,1,0,0,0,1627,1608,1,0,0,0,1627,1610,1,0,0,0,1627, + 1612,1,0,0,0,1627,1618,1,0,0,0,1627,1624,1,0,0,0,1628,141,1,0,0,0,1629, + 1630,5,39,0,0,1630,1631,3,116,58,0,1631,1632,6,71,-1,0,1632,1688,1,0,0, + 0,1633,1634,5,197,0,0,1634,1688,6,71,-1,0,1635,1636,5,199,0,0,1636,1637, + 5,39,0,0,1637,1638,3,116,58,0,1638,1639,6,71,-1,0,1639,1688,1,0,0,0,1640, + 1641,5,200,0,0,1641,1642,3,116,58,0,1642,1643,6,71,-1,0,1643,1688,1,0, + 0,0,1644,1645,5,226,0,0,1645,1646,3,170,85,0,1646,1647,3,138,69,0,1647, + 1648,5,262,0,0,1648,1649,3,112,56,0,1649,1650,6,71,-1,0,1650,1688,1,0, + 0,0,1651,1652,5,253,0,0,1652,1653,3,32,16,0,1653,1654,6,71,-1,0,1654,1688, + 1,0,0,0,1655,1656,5,252,0,0,1656,1657,3,32,16,0,1657,1658,6,71,-1,0,1658, + 1688,1,0,0,0,1659,1660,5,253,0,0,1660,1661,3,2,1,0,1661,1662,6,71,-1,0, + 1662,1688,1,0,0,0,1663,1664,5,252,0,0,1664,1665,3,2,1,0,1665,1666,6,71, + -1,0,1666,1688,1,0,0,0,1667,1668,5,254,0,0,1668,1688,6,71,-1,0,1669,1670, + 5,201,0,0,1670,1688,6,71,-1,0,1671,1672,3,148,74,0,1672,1673,6,71,-1,0, + 1673,1688,1,0,0,0,1674,1675,3,150,75,0,1675,1676,6,71,-1,0,1676,1688,1, + 0,0,0,1677,1678,3,144,72,0,1678,1679,6,71,-1,0,1679,1688,1,0,0,0,1680, + 1681,3,2,1,0,1681,1682,6,71,-1,0,1682,1688,1,0,0,0,1683,1684,5,177,0,0, + 1684,1685,3,138,69,0,1685,1686,6,71,-1,0,1686,1688,1,0,0,0,1687,1629,1, + 0,0,0,1687,1633,1,0,0,0,1687,1635,1,0,0,0,1687,1640,1,0,0,0,1687,1644, + 1,0,0,0,1687,1651,1,0,0,0,1687,1655,1,0,0,0,1687,1659,1,0,0,0,1687,1663, + 1,0,0,0,1687,1667,1,0,0,0,1687,1669,1,0,0,0,1687,1671,1,0,0,0,1687,1674, + 1,0,0,0,1687,1677,1,0,0,0,1687,1680,1,0,0,0,1687,1683,1,0,0,0,1688,143, + 1,0,0,0,1689,1690,5,181,0,0,1690,1728,6,72,-1,0,1691,1692,5,182,0,0,1692, + 1728,6,72,-1,0,1693,1694,5,183,0,0,1694,1728,6,72,-1,0,1695,1696,5,184, + 0,0,1696,1728,6,72,-1,0,1697,1698,5,185,0,0,1698,1728,6,72,-1,0,1699,1700, + 5,186,0,0,1700,1728,6,72,-1,0,1701,1702,5,187,0,0,1702,1728,6,72,-1,0, + 1703,1704,5,188,0,0,1704,1728,6,72,-1,0,1705,1706,5,189,0,0,1706,1728, + 6,72,-1,0,1707,1708,5,190,0,0,1708,1728,6,72,-1,0,1709,1710,5,191,0,0, + 1710,1728,6,72,-1,0,1711,1712,5,192,0,0,1712,1728,6,72,-1,0,1713,1714, + 5,193,0,0,1714,1728,6,72,-1,0,1715,1716,5,90,0,0,1716,1717,5,184,0,0,1717, + 1728,6,72,-1,0,1718,1719,5,90,0,0,1719,1720,5,185,0,0,1720,1728,6,72,-1, + 0,1721,1722,5,90,0,0,1722,1723,5,186,0,0,1723,1728,6,72,-1,0,1724,1725, + 5,90,0,0,1725,1726,5,187,0,0,1726,1728,6,72,-1,0,1727,1689,1,0,0,0,1727, + 1691,1,0,0,0,1727,1693,1,0,0,0,1727,1695,1,0,0,0,1727,1697,1,0,0,0,1727, + 1699,1,0,0,0,1727,1701,1,0,0,0,1727,1703,1,0,0,0,1727,1705,1,0,0,0,1727, + 1707,1,0,0,0,1727,1709,1,0,0,0,1727,1711,1,0,0,0,1727,1713,1,0,0,0,1727, + 1715,1,0,0,0,1727,1718,1,0,0,0,1727,1721,1,0,0,0,1727,1724,1,0,0,0,1728, + 145,1,0,0,0,1729,1744,1,0,0,0,1730,1744,5,177,0,0,1731,1732,3,32,16,0, + 1732,1733,6,73,-1,0,1733,1744,1,0,0,0,1734,1735,3,32,16,0,1735,1736,5, + 177,0,0,1736,1737,3,32,16,0,1737,1738,6,73,-1,0,1738,1744,1,0,0,0,1739, + 1740,3,32,16,0,1740,1741,5,177,0,0,1741,1742,6,73,-1,0,1742,1744,1,0,0, + 0,1743,1729,1,0,0,0,1743,1730,1,0,0,0,1743,1731,1,0,0,0,1743,1734,1,0, + 0,0,1743,1739,1,0,0,0,1744,147,1,0,0,0,1745,1746,5,1,0,0,1746,1747,5,194, + 0,0,1747,1748,6,74,-1,0,1748,149,1,0,0,0,1749,1753,5,1,0,0,1750,1751,5, + 90,0,0,1751,1754,5,194,0,0,1752,1754,5,195,0,0,1753,1750,1,0,0,0,1753, + 1752,1,0,0,0,1754,1755,1,0,0,0,1755,1756,6,75,-1,0,1756,151,1,0,0,0,1757, + 1758,5,294,0,0,1758,1759,3,166,83,0,1759,1760,3,124,62,0,1760,1761,5,30, + 0,0,1761,1762,3,158,79,0,1762,1763,5,31,0,0,1763,1764,6,76,-1,0,1764,1812, + 1,0,0,0,1765,1766,5,294,0,0,1766,1767,3,166,83,0,1767,1768,3,124,62,0, + 1768,1769,5,36,0,0,1769,1770,5,17,0,0,1770,1771,3,52,26,0,1771,1772,5, + 18,0,0,1772,1773,6,76,-1,0,1773,1812,1,0,0,0,1774,1775,5,294,0,0,1775, + 1776,3,166,83,0,1776,1777,3,124,62,0,1777,1778,6,76,-1,0,1778,1812,1,0, + 0,0,1779,1780,5,295,0,0,1780,1781,3,166,83,0,1781,1783,5,36,0,0,1782,1784, + 5,84,0,0,1783,1782,1,0,0,0,1783,1784,1,0,0,0,1784,1785,1,0,0,0,1785,1786, + 5,30,0,0,1786,1787,3,300,150,0,1787,1788,5,31,0,0,1788,1789,6,76,-1,0, + 1789,1812,1,0,0,0,1790,1791,5,295,0,0,1791,1792,3,166,83,0,1792,1793,5, + 84,0,0,1793,1794,5,30,0,0,1794,1795,3,300,150,0,1795,1796,5,31,0,0,1796, + 1797,6,76,-1,0,1797,1812,1,0,0,0,1798,1799,5,295,0,0,1799,1800,3,166,83, + 0,1800,1801,3,6,3,0,1801,1802,6,76,-1,0,1802,1812,1,0,0,0,1803,1804,5, + 295,0,0,1804,1805,3,166,83,0,1805,1806,5,36,0,0,1806,1807,5,17,0,0,1807, + 1808,3,154,77,0,1808,1809,5,18,0,0,1809,1810,6,76,-1,0,1810,1812,1,0,0, + 0,1811,1757,1,0,0,0,1811,1765,1,0,0,0,1811,1774,1,0,0,0,1811,1779,1,0, + 0,0,1811,1790,1,0,0,0,1811,1798,1,0,0,0,1811,1803,1,0,0,0,1812,153,1,0, + 0,0,1813,1827,1,0,0,0,1814,1815,3,156,78,0,1815,1816,6,77,-1,0,1816,1817, + 5,28,0,0,1817,1819,1,0,0,0,1818,1814,1,0,0,0,1819,1822,1,0,0,0,1820,1818, + 1,0,0,0,1820,1821,1,0,0,0,1821,1823,1,0,0,0,1822,1820,1,0,0,0,1823,1824, + 3,156,78,0,1824,1825,6,77,-1,0,1825,1827,1,0,0,0,1826,1813,1,0,0,0,1826, + 1820,1,0,0,0,1827,155,1,0,0,0,1828,1829,5,39,0,0,1829,1830,5,264,0,0,1830, + 1831,5,36,0,0,1831,1832,5,17,0,0,1832,1833,3,56,28,0,1833,1834,5,18,0, + 0,1834,1835,6,78,-1,0,1835,1844,1,0,0,0,1836,1837,3,124,62,0,1837,1838, + 5,36,0,0,1838,1839,5,17,0,0,1839,1840,3,56,28,0,1840,1841,5,18,0,0,1841, + 1842,6,78,-1,0,1842,1844,1,0,0,0,1843,1828,1,0,0,0,1843,1836,1,0,0,0,1844, + 157,1,0,0,0,1845,1846,3,160,80,0,1846,1847,6,79,-1,0,1847,1848,5,28,0, + 0,1848,1850,1,0,0,0,1849,1845,1,0,0,0,1850,1853,1,0,0,0,1851,1849,1,0, + 0,0,1851,1852,1,0,0,0,1852,1854,1,0,0,0,1853,1851,1,0,0,0,1854,1855,3, + 160,80,0,1855,1856,6,79,-1,0,1856,159,1,0,0,0,1857,1858,3,6,3,0,1858,1859, + 5,36,0,0,1859,1860,3,164,82,0,1860,1861,6,80,-1,0,1861,161,1,0,0,0,1862, + 1863,7,8,0,0,1863,163,1,0,0,0,1864,1865,3,162,81,0,1865,1866,6,82,-1,0, + 1866,1910,1,0,0,0,1867,1868,3,32,16,0,1868,1869,6,82,-1,0,1869,1910,1, + 0,0,0,1870,1871,5,186,0,0,1871,1872,5,30,0,0,1872,1873,3,32,16,0,1873, + 1874,5,31,0,0,1874,1875,6,82,-1,0,1875,1910,1,0,0,0,1876,1877,3,6,3,0, + 1877,1878,6,82,-1,0,1878,1910,1,0,0,0,1879,1880,3,116,58,0,1880,1881,5, + 30,0,0,1881,1882,5,184,0,0,1882,1883,5,75,0,0,1883,1884,3,32,16,0,1884, + 1885,5,31,0,0,1885,1886,6,82,-1,0,1886,1910,1,0,0,0,1887,1888,3,116,58, + 0,1888,1889,5,30,0,0,1889,1890,5,185,0,0,1890,1891,5,75,0,0,1891,1892, + 3,32,16,0,1892,1893,5,31,0,0,1893,1894,6,82,-1,0,1894,1910,1,0,0,0,1895, + 1896,3,116,58,0,1896,1897,5,30,0,0,1897,1898,5,186,0,0,1898,1899,5,75, + 0,0,1899,1900,3,32,16,0,1900,1901,5,31,0,0,1901,1902,6,82,-1,0,1902,1910, + 1,0,0,0,1903,1904,3,116,58,0,1904,1905,5,30,0,0,1905,1906,3,32,16,0,1906, + 1907,5,31,0,0,1907,1908,6,82,-1,0,1908,1910,1,0,0,0,1909,1864,1,0,0,0, + 1909,1867,1,0,0,0,1909,1870,1,0,0,0,1909,1876,1,0,0,0,1909,1879,1,0,0, + 0,1909,1887,1,0,0,0,1909,1895,1,0,0,0,1909,1903,1,0,0,0,1910,165,1,0,0, + 0,1911,1912,7,9,0,0,1912,167,1,0,0,0,1913,1914,3,170,85,0,1914,1915,3, + 138,69,0,1915,1916,3,124,62,0,1916,1917,5,176,0,0,1917,1919,3,242,121, + 0,1918,1920,3,108,54,0,1919,1918,1,0,0,0,1919,1920,1,0,0,0,1920,1921,1, + 0,0,0,1921,1922,3,112,56,0,1922,1923,6,84,-1,0,1923,1956,1,0,0,0,1924, + 1925,3,170,85,0,1925,1926,3,138,69,0,1926,1927,3,124,62,0,1927,1928,5, + 176,0,0,1928,1929,3,242,121,0,1929,1930,3,196,98,0,1930,1931,3,112,56, + 0,1931,1932,6,84,-1,0,1932,1956,1,0,0,0,1933,1934,3,170,85,0,1934,1935, + 3,138,69,0,1935,1937,3,242,121,0,1936,1938,3,108,54,0,1937,1936,1,0,0, + 0,1937,1938,1,0,0,0,1938,1939,1,0,0,0,1939,1940,3,112,56,0,1940,1941,6, + 84,-1,0,1941,1956,1,0,0,0,1942,1943,3,170,85,0,1943,1944,3,138,69,0,1944, + 1945,3,242,121,0,1945,1946,3,196,98,0,1946,1947,3,112,56,0,1947,1948,6, + 84,-1,0,1948,1956,1,0,0,0,1949,1950,3,174,87,0,1950,1951,6,84,-1,0,1951, + 1956,1,0,0,0,1952,1953,3,2,1,0,1953,1954,6,84,-1,0,1954,1956,1,0,0,0,1955, + 1913,1,0,0,0,1955,1924,1,0,0,0,1955,1933,1,0,0,0,1955,1942,1,0,0,0,1955, + 1949,1,0,0,0,1955,1952,1,0,0,0,1956,169,1,0,0,0,1957,1958,5,243,0,0,1958, + 1959,3,170,85,0,1959,1960,6,85,-1,0,1960,1975,1,0,0,0,1961,1962,5,244, + 0,0,1962,1963,3,170,85,0,1963,1964,6,85,-1,0,1964,1975,1,0,0,0,1965,1966, + 3,172,86,0,1966,1967,6,85,-1,0,1967,1975,1,0,0,0,1968,1969,5,112,0,0,1969, + 1970,5,30,0,0,1970,1971,3,32,16,0,1971,1972,5,31,0,0,1972,1973,6,85,-1, + 0,1973,1975,1,0,0,0,1974,1957,1,0,0,0,1974,1961,1,0,0,0,1974,1965,1,0, + 0,0,1974,1968,1,0,0,0,1975,171,1,0,0,0,1976,1996,1,0,0,0,1977,1978,5,245, + 0,0,1978,1996,6,86,-1,0,1979,1980,5,246,0,0,1980,1996,6,86,-1,0,1981,1982, + 5,247,0,0,1982,1983,5,248,0,0,1983,1996,6,86,-1,0,1984,1985,5,247,0,0, + 1985,1986,5,249,0,0,1986,1996,6,86,-1,0,1987,1988,5,247,0,0,1988,1989, + 5,250,0,0,1989,1996,6,86,-1,0,1990,1991,5,247,0,0,1991,1992,5,251,0,0, + 1992,1996,6,86,-1,0,1993,1994,5,247,0,0,1994,1996,6,86,-1,0,1995,1976, + 1,0,0,0,1995,1977,1,0,0,0,1995,1979,1,0,0,0,1995,1981,1,0,0,0,1995,1984, + 1,0,0,0,1995,1987,1,0,0,0,1995,1990,1,0,0,0,1995,1993,1,0,0,0,1996,173, + 1,0,0,0,1997,1998,5,113,0,0,1998,1999,5,30,0,0,1999,2000,3,32,16,0,2000, + 2001,5,31,0,0,2001,2002,6,87,-1,0,2002,175,1,0,0,0,2003,2004,5,226,0,0, + 2004,2005,3,168,84,0,2005,2006,6,88,-1,0,2006,2015,1,0,0,0,2007,2008,5, + 37,0,0,2008,2009,3,178,89,0,2009,2010,6,88,-1,0,2010,2015,1,0,0,0,2011, + 2012,3,174,87,0,2012,2013,6,88,-1,0,2013,2015,1,0,0,0,2014,2003,1,0,0, + 0,2014,2007,1,0,0,0,2014,2011,1,0,0,0,2015,177,1,0,0,0,2016,2017,3,138, + 69,0,2017,2018,3,124,62,0,2018,2019,5,176,0,0,2019,2020,3,2,1,0,2020,2021, + 6,89,-1,0,2021,2030,1,0,0,0,2022,2023,3,138,69,0,2023,2024,3,2,1,0,2024, + 2025,6,89,-1,0,2025,2030,1,0,0,0,2026,2027,3,2,1,0,2027,2028,6,89,-1,0, + 2028,2030,1,0,0,0,2029,2016,1,0,0,0,2029,2022,1,0,0,0,2029,2026,1,0,0, + 0,2030,179,1,0,0,0,2031,2032,3,124,62,0,2032,2033,6,90,-1,0,2033,2034, + 5,28,0,0,2034,2036,1,0,0,0,2035,2031,1,0,0,0,2036,2039,1,0,0,0,2037,2035, + 1,0,0,0,2037,2038,1,0,0,0,2038,2040,1,0,0,0,2039,2037,1,0,0,0,2040,2041, + 3,124,62,0,2041,2042,6,90,-1,0,2042,181,1,0,0,0,2043,2050,1,0,0,0,2044, + 2045,5,86,0,0,2045,2046,3,190,95,0,2046,2047,5,87,0,0,2047,2048,6,91,-1, + 0,2048,2050,1,0,0,0,2049,2043,1,0,0,0,2049,2044,1,0,0,0,2050,183,1,0,0, + 0,2051,2052,5,266,0,0,2052,2070,6,92,-1,0,2053,2054,5,114,0,0,2054,2070, + 6,92,-1,0,2055,2056,5,39,0,0,2056,2070,6,92,-1,0,2057,2058,5,200,0,0,2058, + 2070,6,92,-1,0,2059,2060,5,115,0,0,2060,2070,6,92,-1,0,2061,2062,5,116, + 0,0,2062,2070,6,92,-1,0,2063,2064,5,70,0,0,2064,2065,5,30,0,0,2065,2066, + 3,32,16,0,2066,2067,5,31,0,0,2067,2068,6,92,-1,0,2068,2070,1,0,0,0,2069, + 2051,1,0,0,0,2069,2053,1,0,0,0,2069,2055,1,0,0,0,2069,2057,1,0,0,0,2069, + 2059,1,0,0,0,2069,2061,1,0,0,0,2069,2063,1,0,0,0,2070,185,1,0,0,0,2071, + 2072,3,184,92,0,2072,2073,6,93,-1,0,2073,2075,1,0,0,0,2074,2071,1,0,0, + 0,2075,2078,1,0,0,0,2076,2074,1,0,0,0,2076,2077,1,0,0,0,2077,187,1,0,0, + 0,2078,2076,1,0,0,0,2079,2081,3,186,93,0,2080,2082,3,192,96,0,2081,2080, + 1,0,0,0,2081,2082,1,0,0,0,2082,2083,1,0,0,0,2083,2084,3,2,1,0,2084,2085, + 6,94,-1,0,2085,189,1,0,0,0,2086,2087,3,188,94,0,2087,2088,6,95,-1,0,2088, + 2089,5,28,0,0,2089,2091,1,0,0,0,2090,2086,1,0,0,0,2091,2094,1,0,0,0,2092, + 2090,1,0,0,0,2092,2093,1,0,0,0,2093,2095,1,0,0,0,2094,2092,1,0,0,0,2095, + 2096,3,188,94,0,2096,2097,6,95,-1,0,2097,191,1,0,0,0,2098,2099,5,30,0, + 0,2099,2100,3,180,90,0,2100,2101,5,31,0,0,2101,2102,6,96,-1,0,2102,193, + 1,0,0,0,2103,2105,3,196,98,0,2104,2103,1,0,0,0,2104,2105,1,0,0,0,2105, + 2106,1,0,0,0,2106,2107,6,97,-1,0,2107,195,1,0,0,0,2108,2109,5,86,0,0,2109, + 2110,5,42,0,0,2110,2111,3,32,16,0,2111,2112,5,43,0,0,2112,2113,5,87,0, + 0,2113,2114,6,98,-1,0,2114,197,1,0,0,0,2115,2116,3,234,117,0,2116,2117, + 5,17,0,0,2117,2118,3,246,123,0,2118,2119,5,18,0,0,2119,2266,1,0,0,0,2120, + 2121,3,74,37,0,2121,2122,5,17,0,0,2122,2123,3,82,41,0,2123,2124,5,18,0, + 0,2124,2266,1,0,0,0,2125,2126,3,210,105,0,2126,2127,6,99,-1,0,2127,2128, + 5,17,0,0,2128,2129,3,214,107,0,2129,2130,5,18,0,0,2130,2266,1,0,0,0,2131, + 2132,3,218,109,0,2132,2133,6,99,-1,0,2133,2134,5,17,0,0,2134,2135,3,222, + 111,0,2135,2136,5,18,0,0,2136,2266,1,0,0,0,2137,2266,3,200,100,0,2138, + 2139,3,284,142,0,2139,2140,6,99,-1,0,2140,2266,1,0,0,0,2141,2142,3,152, + 76,0,2142,2143,6,99,-1,0,2143,2266,1,0,0,0,2144,2145,3,88,44,0,2145,2146, + 6,99,-1,0,2146,2266,1,0,0,0,2147,2148,3,330,165,0,2148,2149,6,99,-1,0, + 2149,2266,1,0,0,0,2150,2151,5,117,0,0,2151,2152,3,32,16,0,2152,2153,6, + 99,-1,0,2153,2266,1,0,0,0,2154,2155,5,118,0,0,2155,2156,3,32,16,0,2156, + 2157,6,99,-1,0,2157,2266,1,0,0,0,2158,2159,3,346,173,0,2159,2160,5,17, + 0,0,2160,2161,3,350,175,0,2161,2162,5,18,0,0,2162,2163,6,99,-1,0,2163, + 2266,1,0,0,0,2164,2165,5,302,0,0,2165,2166,3,124,62,0,2166,2167,5,176, + 0,0,2167,2168,3,242,121,0,2168,2169,5,119,0,0,2169,2170,3,170,85,0,2170, + 2171,3,138,69,0,2171,2172,3,124,62,0,2172,2173,5,176,0,0,2173,2174,3,242, + 121,0,2174,2175,3,112,56,0,2175,2176,6,99,-1,0,2176,2266,1,0,0,0,2177, + 2178,5,302,0,0,2178,2179,5,226,0,0,2179,2180,3,170,85,0,2180,2181,3,138, + 69,0,2181,2182,3,124,62,0,2182,2183,5,176,0,0,2183,2184,3,242,121,0,2184, + 2185,3,194,97,0,2185,2186,3,112,56,0,2186,2187,5,119,0,0,2187,2188,5,226, + 0,0,2188,2189,3,170,85,0,2189,2190,3,138,69,0,2190,2191,3,124,62,0,2191, + 2192,5,176,0,0,2192,2193,3,242,121,0,2193,2194,3,194,97,0,2194,2195,3, + 112,56,0,2195,2196,6,99,-1,0,2196,2266,1,0,0,0,2197,2198,3,26,13,0,2198, + 2199,6,99,-1,0,2199,2266,1,0,0,0,2200,2201,3,40,20,0,2201,2202,6,99,-1, + 0,2202,2266,1,0,0,0,2203,2204,5,255,0,0,2204,2205,5,196,0,0,2205,2206, + 5,42,0,0,2206,2207,3,32,16,0,2207,2208,5,43,0,0,2208,2214,6,99,-1,0,2209, + 2210,3,330,165,0,2210,2211,6,99,-1,0,2211,2213,1,0,0,0,2212,2209,1,0,0, + 0,2213,2216,1,0,0,0,2214,2212,1,0,0,0,2214,2215,1,0,0,0,2215,2266,1,0, + 0,0,2216,2214,1,0,0,0,2217,2218,5,255,0,0,2218,2219,5,196,0,0,2219,2220, + 3,2,1,0,2220,2226,6,99,-1,0,2221,2222,3,330,165,0,2222,2223,6,99,-1,0, + 2223,2225,1,0,0,0,2224,2221,1,0,0,0,2225,2228,1,0,0,0,2226,2224,1,0,0, + 0,2226,2227,1,0,0,0,2227,2266,1,0,0,0,2228,2226,1,0,0,0,2229,2230,5,255, + 0,0,2230,2231,5,256,0,0,2231,2232,5,42,0,0,2232,2233,3,32,16,0,2233,2234, + 5,43,0,0,2234,2235,5,28,0,0,2235,2236,3,124,62,0,2236,2242,6,99,-1,0,2237, + 2238,3,330,165,0,2238,2239,6,99,-1,0,2239,2241,1,0,0,0,2240,2237,1,0,0, + 0,2241,2244,1,0,0,0,2242,2240,1,0,0,0,2242,2243,1,0,0,0,2243,2266,1,0, + 0,0,2244,2242,1,0,0,0,2245,2246,5,255,0,0,2246,2247,5,256,0,0,2247,2248, + 3,2,1,0,2248,2249,5,28,0,0,2249,2250,3,124,62,0,2250,2256,6,99,-1,0,2251, + 2252,3,330,165,0,2252,2253,6,99,-1,0,2253,2255,1,0,0,0,2254,2251,1,0,0, + 0,2255,2258,1,0,0,0,2256,2254,1,0,0,0,2256,2257,1,0,0,0,2257,2266,1,0, + 0,0,2258,2256,1,0,0,0,2259,2260,5,120,0,0,2260,2261,5,196,0,0,2261,2262, + 3,124,62,0,2262,2263,3,44,22,0,2263,2264,6,99,-1,0,2264,2266,1,0,0,0,2265, + 2115,1,0,0,0,2265,2120,1,0,0,0,2265,2125,1,0,0,0,2265,2131,1,0,0,0,2265, + 2137,1,0,0,0,2265,2138,1,0,0,0,2265,2141,1,0,0,0,2265,2144,1,0,0,0,2265, + 2147,1,0,0,0,2265,2150,1,0,0,0,2265,2154,1,0,0,0,2265,2158,1,0,0,0,2265, + 2164,1,0,0,0,2265,2177,1,0,0,0,2265,2197,1,0,0,0,2265,2200,1,0,0,0,2265, + 2203,1,0,0,0,2265,2217,1,0,0,0,2265,2229,1,0,0,0,2265,2245,1,0,0,0,2265, + 2259,1,0,0,0,2266,199,1,0,0,0,2267,2268,5,121,0,0,2268,2280,3,208,104, + 0,2269,2270,3,202,101,0,2270,2271,6,100,-1,0,2271,2279,1,0,0,0,2272,2273, + 5,122,0,0,2273,2274,5,30,0,0,2274,2275,3,228,114,0,2275,2276,5,31,0,0, + 2276,2277,6,100,-1,0,2277,2279,1,0,0,0,2278,2269,1,0,0,0,2278,2272,1,0, + 0,0,2279,2282,1,0,0,0,2280,2278,1,0,0,0,2280,2281,1,0,0,0,2281,2283,1, + 0,0,0,2282,2280,1,0,0,0,2283,2284,3,138,69,0,2284,2285,3,2,1,0,2285,2286, + 3,204,102,0,2286,2287,3,206,103,0,2287,2288,6,100,-1,0,2288,201,1,0,0, + 0,2289,2290,5,123,0,0,2290,2324,6,101,-1,0,2291,2292,5,51,0,0,2292,2324, + 6,101,-1,0,2293,2294,5,52,0,0,2294,2324,6,101,-1,0,2295,2296,5,63,0,0, + 2296,2324,6,101,-1,0,2297,2298,5,124,0,0,2298,2324,6,101,-1,0,2299,2300, + 5,69,0,0,2300,2324,6,101,-1,0,2301,2302,5,68,0,0,2302,2324,6,101,-1,0, + 2303,2304,5,64,0,0,2304,2324,6,101,-1,0,2305,2306,5,65,0,0,2306,2324,6, + 101,-1,0,2307,2308,5,66,0,0,2308,2324,6,101,-1,0,2309,2310,5,125,0,0,2310, + 2324,6,101,-1,0,2311,2312,5,126,0,0,2312,2324,6,101,-1,0,2313,2314,5,127, + 0,0,2314,2324,6,101,-1,0,2315,2316,5,16,0,0,2316,2324,6,101,-1,0,2317, + 2318,5,70,0,0,2318,2319,5,30,0,0,2319,2320,3,32,16,0,2320,2321,5,31,0, + 0,2321,2322,6,101,-1,0,2322,2324,1,0,0,0,2323,2289,1,0,0,0,2323,2291,1, + 0,0,0,2323,2293,1,0,0,0,2323,2295,1,0,0,0,2323,2297,1,0,0,0,2323,2299, + 1,0,0,0,2323,2301,1,0,0,0,2323,2303,1,0,0,0,2323,2305,1,0,0,0,2323,2307, + 1,0,0,0,2323,2309,1,0,0,0,2323,2311,1,0,0,0,2323,2313,1,0,0,0,2323,2315, + 1,0,0,0,2323,2317,1,0,0,0,2324,203,1,0,0,0,2325,2335,1,0,0,0,2326,2327, + 5,44,0,0,2327,2328,3,0,0,0,2328,2329,6,102,-1,0,2329,2335,1,0,0,0,2330, + 2331,5,44,0,0,2331,2332,3,32,16,0,2332,2333,6,102,-1,0,2333,2335,1,0,0, + 0,2334,2325,1,0,0,0,2334,2326,1,0,0,0,2334,2330,1,0,0,0,2335,205,1,0,0, + 0,2336,2342,1,0,0,0,2337,2338,5,36,0,0,2338,2339,3,304,152,0,2339,2340, + 6,103,-1,0,2340,2342,1,0,0,0,2341,2336,1,0,0,0,2341,2337,1,0,0,0,2342, + 207,1,0,0,0,2343,2350,1,0,0,0,2344,2345,5,42,0,0,2345,2346,3,32,16,0,2346, + 2347,5,43,0,0,2347,2348,6,104,-1,0,2348,2350,1,0,0,0,2349,2343,1,0,0,0, + 2349,2344,1,0,0,0,2350,209,1,0,0,0,2351,2357,5,128,0,0,2352,2353,3,212, + 106,0,2353,2354,6,105,-1,0,2354,2356,1,0,0,0,2355,2352,1,0,0,0,2356,2359, + 1,0,0,0,2357,2355,1,0,0,0,2357,2358,1,0,0,0,2358,2360,1,0,0,0,2359,2357, + 1,0,0,0,2360,2361,3,124,62,0,2361,2362,3,2,1,0,2362,2363,6,105,-1,0,2363, + 2377,1,0,0,0,2364,2370,5,128,0,0,2365,2366,3,212,106,0,2366,2367,6,105, + -1,0,2367,2369,1,0,0,0,2368,2365,1,0,0,0,2369,2372,1,0,0,0,2370,2368,1, + 0,0,0,2370,2371,1,0,0,0,2371,2373,1,0,0,0,2372,2370,1,0,0,0,2373,2374, + 3,2,1,0,2374,2375,6,105,-1,0,2375,2377,1,0,0,0,2376,2351,1,0,0,0,2376, + 2364,1,0,0,0,2377,211,1,0,0,0,2378,2379,5,69,0,0,2379,2383,6,106,-1,0, + 2380,2381,5,68,0,0,2381,2383,6,106,-1,0,2382,2378,1,0,0,0,2382,2380,1, + 0,0,0,2383,213,1,0,0,0,2384,2386,3,216,108,0,2385,2384,1,0,0,0,2386,2389, + 1,0,0,0,2387,2385,1,0,0,0,2387,2388,1,0,0,0,2388,215,1,0,0,0,2389,2387, + 1,0,0,0,2390,2391,5,129,0,0,2391,2392,3,168,84,0,2392,2393,6,108,-1,0, + 2393,2417,1,0,0,0,2394,2395,5,130,0,0,2395,2396,3,168,84,0,2396,2397,6, + 108,-1,0,2397,2417,1,0,0,0,2398,2399,5,131,0,0,2399,2400,3,168,84,0,2400, + 2401,6,108,-1,0,2401,2417,1,0,0,0,2402,2403,5,132,0,0,2403,2404,3,168, + 84,0,2404,2405,6,108,-1,0,2405,2417,1,0,0,0,2406,2407,3,88,44,0,2407,2408, + 6,108,-1,0,2408,2417,1,0,0,0,2409,2410,3,330,165,0,2410,2411,6,108,-1, + 0,2411,2417,1,0,0,0,2412,2413,3,26,13,0,2413,2414,6,108,-1,0,2414,2417, + 1,0,0,0,2415,2417,3,40,20,0,2416,2390,1,0,0,0,2416,2394,1,0,0,0,2416,2398, + 1,0,0,0,2416,2402,1,0,0,0,2416,2406,1,0,0,0,2416,2409,1,0,0,0,2416,2412, + 1,0,0,0,2416,2415,1,0,0,0,2417,217,1,0,0,0,2418,2424,5,133,0,0,2419,2420, + 3,220,110,0,2420,2421,6,109,-1,0,2421,2423,1,0,0,0,2422,2419,1,0,0,0,2423, + 2426,1,0,0,0,2424,2422,1,0,0,0,2424,2425,1,0,0,0,2425,2427,1,0,0,0,2426, + 2424,1,0,0,0,2427,2428,3,170,85,0,2428,2429,3,138,69,0,2429,2430,3,2,1, + 0,2430,2431,3,112,56,0,2431,2432,3,206,103,0,2432,2433,6,109,-1,0,2433, + 219,1,0,0,0,2434,2435,5,69,0,0,2435,2439,6,110,-1,0,2436,2437,5,68,0,0, + 2437,2439,6,110,-1,0,2438,2434,1,0,0,0,2438,2436,1,0,0,0,2439,221,1,0, + 0,0,2440,2442,3,224,112,0,2441,2440,1,0,0,0,2442,2445,1,0,0,0,2443,2441, + 1,0,0,0,2443,2444,1,0,0,0,2444,223,1,0,0,0,2445,2443,1,0,0,0,2446,2447, + 5,134,0,0,2447,2448,3,168,84,0,2448,2449,6,112,-1,0,2449,2469,1,0,0,0, + 2450,2451,5,135,0,0,2451,2452,3,168,84,0,2452,2453,6,112,-1,0,2453,2469, + 1,0,0,0,2454,2455,5,132,0,0,2455,2456,3,168,84,0,2456,2457,6,112,-1,0, + 2457,2469,1,0,0,0,2458,2459,3,330,165,0,2459,2460,6,112,-1,0,2460,2469, + 1,0,0,0,2461,2462,3,88,44,0,2462,2463,6,112,-1,0,2463,2469,1,0,0,0,2464, + 2465,3,26,13,0,2465,2466,6,112,-1,0,2466,2469,1,0,0,0,2467,2469,3,40,20, + 0,2468,2446,1,0,0,0,2468,2450,1,0,0,0,2468,2454,1,0,0,0,2468,2458,1,0, + 0,0,2468,2461,1,0,0,0,2468,2464,1,0,0,0,2468,2467,1,0,0,0,2469,225,1,0, + 0,0,2470,2478,6,113,-1,0,2471,2472,5,122,0,0,2472,2473,5,30,0,0,2473,2474, + 3,228,114,0,2474,2475,5,31,0,0,2475,2476,6,113,-1,0,2476,2478,1,0,0,0, + 2477,2470,1,0,0,0,2477,2471,1,0,0,0,2478,227,1,0,0,0,2479,2480,3,126,63, + 0,2480,2481,6,114,-1,0,2481,2493,1,0,0,0,2482,2486,5,17,0,0,2483,2484, + 3,302,151,0,2484,2485,6,114,-1,0,2485,2487,1,0,0,0,2486,2483,1,0,0,0,2487, + 2488,1,0,0,0,2488,2486,1,0,0,0,2488,2489,1,0,0,0,2489,2490,1,0,0,0,2490, + 2491,5,18,0,0,2491,2493,1,0,0,0,2492,2479,1,0,0,0,2492,2482,1,0,0,0,2493, + 229,1,0,0,0,2494,2495,3,232,116,0,2495,2496,6,115,-1,0,2496,2498,1,0,0, + 0,2497,2494,1,0,0,0,2498,2501,1,0,0,0,2499,2497,1,0,0,0,2499,2500,1,0, + 0,0,2500,231,1,0,0,0,2501,2499,1,0,0,0,2502,2503,5,42,0,0,2503,2504,5, + 136,0,0,2504,2505,5,43,0,0,2505,2520,6,116,-1,0,2506,2507,5,42,0,0,2507, + 2508,5,137,0,0,2508,2509,5,43,0,0,2509,2520,6,116,-1,0,2510,2511,5,42, + 0,0,2511,2512,5,138,0,0,2512,2513,5,43,0,0,2513,2520,6,116,-1,0,2514,2515, + 5,42,0,0,2515,2516,3,32,16,0,2516,2517,5,43,0,0,2517,2518,6,116,-1,0,2518, + 2520,1,0,0,0,2519,2502,1,0,0,0,2519,2506,1,0,0,0,2519,2510,1,0,0,0,2519, + 2514,1,0,0,0,2520,233,1,0,0,0,2521,2530,5,139,0,0,2522,2523,3,236,118, + 0,2523,2524,6,117,-1,0,2524,2529,1,0,0,0,2525,2526,3,238,119,0,2526,2527, + 6,117,-1,0,2527,2529,1,0,0,0,2528,2522,1,0,0,0,2528,2525,1,0,0,0,2529, + 2532,1,0,0,0,2530,2528,1,0,0,0,2530,2531,1,0,0,0,2531,2533,1,0,0,0,2532, + 2530,1,0,0,0,2533,2534,3,170,85,0,2534,2535,3,230,115,0,2535,2536,3,138, + 69,0,2536,2537,3,226,113,0,2537,2538,3,242,121,0,2538,2539,3,182,91,0, + 2539,2545,3,112,56,0,2540,2541,3,244,122,0,2541,2542,6,117,-1,0,2542,2544, + 1,0,0,0,2543,2540,1,0,0,0,2544,2547,1,0,0,0,2545,2543,1,0,0,0,2545,2546, + 1,0,0,0,2546,2548,1,0,0,0,2547,2545,1,0,0,0,2548,2549,6,117,-1,0,2549, + 235,1,0,0,0,2550,2551,5,123,0,0,2551,2593,6,118,-1,0,2552,2553,5,51,0, + 0,2553,2593,6,118,-1,0,2554,2555,5,52,0,0,2555,2593,6,118,-1,0,2556,2557, + 5,63,0,0,2557,2593,6,118,-1,0,2558,2559,5,140,0,0,2559,2593,6,118,-1,0, + 2560,2561,5,68,0,0,2561,2593,6,118,-1,0,2562,2563,5,141,0,0,2563,2593, + 6,118,-1,0,2564,2565,5,142,0,0,2565,2593,6,118,-1,0,2566,2567,5,54,0,0, + 2567,2593,6,118,-1,0,2568,2569,5,64,0,0,2569,2593,6,118,-1,0,2570,2571, + 5,65,0,0,2571,2593,6,118,-1,0,2572,2573,5,66,0,0,2573,2593,6,118,-1,0, + 2574,2575,5,125,0,0,2575,2593,6,118,-1,0,2576,2577,5,143,0,0,2577,2593, + 6,118,-1,0,2578,2579,5,144,0,0,2579,2593,6,118,-1,0,2580,2581,5,69,0,0, + 2581,2593,6,118,-1,0,2582,2583,5,145,0,0,2583,2593,6,118,-1,0,2584,2585, + 5,146,0,0,2585,2593,6,118,-1,0,2586,2587,5,70,0,0,2587,2588,5,30,0,0,2588, + 2589,3,32,16,0,2589,2590,5,31,0,0,2590,2591,6,118,-1,0,2591,2593,1,0,0, + 0,2592,2550,1,0,0,0,2592,2552,1,0,0,0,2592,2554,1,0,0,0,2592,2556,1,0, + 0,0,2592,2558,1,0,0,0,2592,2560,1,0,0,0,2592,2562,1,0,0,0,2592,2564,1, + 0,0,0,2592,2566,1,0,0,0,2592,2568,1,0,0,0,2592,2570,1,0,0,0,2592,2572, + 1,0,0,0,2592,2574,1,0,0,0,2592,2576,1,0,0,0,2592,2578,1,0,0,0,2592,2580, + 1,0,0,0,2592,2582,1,0,0,0,2592,2584,1,0,0,0,2592,2586,1,0,0,0,2593,237, + 1,0,0,0,2594,2595,5,147,0,0,2595,2604,5,30,0,0,2596,2597,3,6,3,0,2597, + 2602,6,119,-1,0,2598,2599,5,34,0,0,2599,2600,3,6,3,0,2600,2601,6,119,-1, + 0,2601,2603,1,0,0,0,2602,2598,1,0,0,0,2602,2603,1,0,0,0,2603,2605,1,0, + 0,0,2604,2596,1,0,0,0,2604,2605,1,0,0,0,2605,2611,1,0,0,0,2606,2607,3, + 240,120,0,2607,2608,6,119,-1,0,2608,2610,1,0,0,0,2609,2606,1,0,0,0,2610, + 2613,1,0,0,0,2611,2609,1,0,0,0,2611,2612,1,0,0,0,2612,2614,1,0,0,0,2613, + 2611,1,0,0,0,2614,2618,5,31,0,0,2615,2616,5,147,0,0,2616,2618,5,85,0,0, + 2617,2594,1,0,0,0,2617,2615,1,0,0,0,2618,239,1,0,0,0,2619,2620,5,148,0, + 0,2620,2662,6,120,-1,0,2621,2622,5,224,0,0,2622,2662,6,120,-1,0,2623,2624, + 5,57,0,0,2624,2662,6,120,-1,0,2625,2626,5,58,0,0,2626,2662,6,120,-1,0, + 2627,2628,5,149,0,0,2628,2662,6,120,-1,0,2629,2630,5,150,0,0,2630,2662, + 6,120,-1,0,2631,2632,5,248,0,0,2632,2662,6,120,-1,0,2633,2634,5,249,0, + 0,2634,2662,6,120,-1,0,2635,2636,5,250,0,0,2636,2662,6,120,-1,0,2637,2638, + 5,251,0,0,2638,2662,6,120,-1,0,2639,2640,5,151,0,0,2640,2641,5,75,0,0, + 2641,2642,5,152,0,0,2642,2662,6,120,-1,0,2643,2644,5,151,0,0,2644,2645, + 5,75,0,0,2645,2646,5,153,0,0,2646,2662,6,120,-1,0,2647,2648,5,154,0,0, + 2648,2649,5,75,0,0,2649,2650,5,152,0,0,2650,2662,6,120,-1,0,2651,2652, + 5,154,0,0,2652,2653,5,75,0,0,2653,2654,5,153,0,0,2654,2662,6,120,-1,0, + 2655,2656,5,70,0,0,2656,2657,5,30,0,0,2657,2658,3,32,16,0,2658,2659,5, + 31,0,0,2659,2660,6,120,-1,0,2660,2662,1,0,0,0,2661,2619,1,0,0,0,2661,2621, + 1,0,0,0,2661,2623,1,0,0,0,2661,2625,1,0,0,0,2661,2627,1,0,0,0,2661,2629, + 1,0,0,0,2661,2631,1,0,0,0,2661,2633,1,0,0,0,2661,2635,1,0,0,0,2661,2637, + 1,0,0,0,2661,2639,1,0,0,0,2661,2643,1,0,0,0,2661,2647,1,0,0,0,2661,2651, + 1,0,0,0,2661,2655,1,0,0,0,2662,241,1,0,0,0,2663,2664,5,116,0,0,2664,2671, + 6,121,-1,0,2665,2666,5,155,0,0,2666,2671,6,121,-1,0,2667,2668,3,2,1,0, + 2668,2669,6,121,-1,0,2669,2671,1,0,0,0,2670,2663,1,0,0,0,2670,2665,1,0, + 0,0,2670,2667,1,0,0,0,2671,243,1,0,0,0,2672,2673,5,1,0,0,2673,2711,6,122, + -1,0,2674,2675,5,2,0,0,2675,2711,6,122,-1,0,2676,2677,5,156,0,0,2677,2711, + 6,122,-1,0,2678,2679,5,3,0,0,2679,2711,6,122,-1,0,2680,2681,5,4,0,0,2681, + 2711,6,122,-1,0,2682,2683,5,247,0,0,2683,2711,6,122,-1,0,2684,2685,5,5, + 0,0,2685,2711,6,122,-1,0,2686,2687,5,6,0,0,2687,2711,6,122,-1,0,2688,2689, + 5,7,0,0,2689,2711,6,122,-1,0,2690,2691,5,8,0,0,2691,2711,6,122,-1,0,2692, + 2693,5,9,0,0,2693,2711,6,122,-1,0,2694,2695,5,10,0,0,2695,2711,6,122,-1, + 0,2696,2697,5,11,0,0,2697,2711,6,122,-1,0,2698,2699,5,12,0,0,2699,2711, + 6,122,-1,0,2700,2701,5,13,0,0,2701,2711,6,122,-1,0,2702,2703,5,14,0,0, + 2703,2711,6,122,-1,0,2704,2705,5,70,0,0,2705,2706,5,30,0,0,2706,2707,3, + 32,16,0,2707,2708,5,31,0,0,2708,2709,6,122,-1,0,2709,2711,1,0,0,0,2710, + 2672,1,0,0,0,2710,2674,1,0,0,0,2710,2676,1,0,0,0,2710,2678,1,0,0,0,2710, + 2680,1,0,0,0,2710,2682,1,0,0,0,2710,2684,1,0,0,0,2710,2686,1,0,0,0,2710, + 2688,1,0,0,0,2710,2690,1,0,0,0,2710,2692,1,0,0,0,2710,2694,1,0,0,0,2710, + 2696,1,0,0,0,2710,2698,1,0,0,0,2710,2700,1,0,0,0,2710,2702,1,0,0,0,2710, + 2704,1,0,0,0,2711,245,1,0,0,0,2712,2714,3,248,124,0,2713,2712,1,0,0,0, + 2714,2717,1,0,0,0,2715,2713,1,0,0,0,2715,2716,1,0,0,0,2716,247,1,0,0,0, + 2717,2715,1,0,0,0,2718,2756,3,100,50,0,2719,2720,5,296,0,0,2720,2721,3, + 32,16,0,2721,2722,6,124,-1,0,2722,2756,1,0,0,0,2723,2756,3,266,133,0,2724, + 2725,5,297,0,0,2725,2726,3,32,16,0,2726,2727,6,124,-1,0,2727,2756,1,0, + 0,0,2728,2729,5,298,0,0,2729,2756,6,124,-1,0,2730,2731,5,299,0,0,2731, + 2756,6,124,-1,0,2732,2756,3,260,130,0,2733,2756,3,264,132,0,2734,2756, + 3,250,125,0,2735,2736,3,284,142,0,2736,2737,6,124,-1,0,2737,2756,1,0,0, + 0,2738,2739,3,152,76,0,2739,2740,6,124,-1,0,2740,2756,1,0,0,0,2741,2742, + 3,88,44,0,2742,2743,6,124,-1,0,2743,2756,1,0,0,0,2744,2745,3,26,13,0,2745, + 2746,6,124,-1,0,2746,2756,1,0,0,0,2747,2748,3,262,131,0,2748,2749,6,124, + -1,0,2749,2756,1,0,0,0,2750,2756,3,40,20,0,2751,2756,3,252,126,0,2752, + 2756,3,254,127,0,2753,2756,3,256,128,0,2754,2756,3,258,129,0,2755,2718, + 1,0,0,0,2755,2719,1,0,0,0,2755,2723,1,0,0,0,2755,2724,1,0,0,0,2755,2728, + 1,0,0,0,2755,2730,1,0,0,0,2755,2732,1,0,0,0,2755,2733,1,0,0,0,2755,2734, + 1,0,0,0,2755,2735,1,0,0,0,2755,2738,1,0,0,0,2755,2741,1,0,0,0,2755,2744, + 1,0,0,0,2755,2747,1,0,0,0,2755,2750,1,0,0,0,2755,2751,1,0,0,0,2755,2752, + 1,0,0,0,2755,2753,1,0,0,0,2755,2754,1,0,0,0,2756,249,1,0,0,0,2757,2759, + 5,300,0,0,2758,2760,5,157,0,0,2759,2758,1,0,0,0,2759,2760,1,0,0,0,2760, + 2761,1,0,0,0,2761,2762,3,112,56,0,2762,251,1,0,0,0,2763,2764,5,301,0,0, + 2764,2765,5,42,0,0,2765,2766,3,32,16,0,2766,2769,5,43,0,0,2767,2768,5, + 34,0,0,2768,2770,3,0,0,0,2769,2767,1,0,0,0,2769,2770,1,0,0,0,2770,253, + 1,0,0,0,2771,2772,5,303,0,0,2772,2773,3,32,16,0,2773,2774,5,75,0,0,2774, + 2775,3,32,16,0,2775,255,1,0,0,0,2776,2777,5,302,0,0,2777,2778,3,124,62, + 0,2778,2779,5,176,0,0,2779,2780,3,242,121,0,2780,2792,1,0,0,0,2781,2782, + 5,302,0,0,2782,2783,5,226,0,0,2783,2784,3,170,85,0,2784,2785,3,138,69, + 0,2785,2786,3,124,62,0,2786,2787,5,176,0,0,2787,2788,3,242,121,0,2788, + 2789,3,194,97,0,2789,2790,3,112,56,0,2790,2792,1,0,0,0,2791,2776,1,0,0, + 0,2791,2781,1,0,0,0,2792,257,1,0,0,0,2793,2794,5,255,0,0,2794,2795,5,196, + 0,0,2795,2796,5,42,0,0,2796,2797,3,32,16,0,2797,2803,5,43,0,0,2798,2799, + 3,330,165,0,2799,2800,6,129,-1,0,2800,2802,1,0,0,0,2801,2798,1,0,0,0,2802, + 2805,1,0,0,0,2803,2801,1,0,0,0,2803,2804,1,0,0,0,2804,2859,1,0,0,0,2805, + 2803,1,0,0,0,2806,2807,5,255,0,0,2807,2808,5,196,0,0,2808,2814,3,2,1,0, + 2809,2810,3,330,165,0,2810,2811,6,129,-1,0,2811,2813,1,0,0,0,2812,2809, + 1,0,0,0,2813,2816,1,0,0,0,2814,2812,1,0,0,0,2814,2815,1,0,0,0,2815,2859, + 1,0,0,0,2816,2814,1,0,0,0,2817,2818,5,255,0,0,2818,2819,5,256,0,0,2819, + 2820,5,42,0,0,2820,2821,3,32,16,0,2821,2822,5,43,0,0,2822,2823,5,28,0, + 0,2823,2829,3,124,62,0,2824,2825,3,330,165,0,2825,2826,6,129,-1,0,2826, + 2828,1,0,0,0,2827,2824,1,0,0,0,2828,2831,1,0,0,0,2829,2827,1,0,0,0,2829, + 2830,1,0,0,0,2830,2859,1,0,0,0,2831,2829,1,0,0,0,2832,2833,5,255,0,0,2833, + 2834,5,256,0,0,2834,2835,3,2,1,0,2835,2836,5,28,0,0,2836,2842,3,124,62, + 0,2837,2838,3,330,165,0,2838,2839,6,129,-1,0,2839,2841,1,0,0,0,2840,2837, + 1,0,0,0,2841,2844,1,0,0,0,2842,2840,1,0,0,0,2842,2843,1,0,0,0,2843,2859, + 1,0,0,0,2844,2842,1,0,0,0,2845,2846,5,255,0,0,2846,2847,5,42,0,0,2847, + 2848,3,32,16,0,2848,2849,5,43,0,0,2849,2855,3,206,103,0,2850,2851,3,330, + 165,0,2851,2852,6,129,-1,0,2852,2854,1,0,0,0,2853,2850,1,0,0,0,2854,2857, + 1,0,0,0,2855,2853,1,0,0,0,2855,2856,1,0,0,0,2856,2859,1,0,0,0,2857,2855, + 1,0,0,0,2858,2793,1,0,0,0,2858,2806,1,0,0,0,2858,2817,1,0,0,0,2858,2832, + 1,0,0,0,2858,2845,1,0,0,0,2859,259,1,0,0,0,2860,2861,3,0,0,0,2861,2862, + 5,75,0,0,2862,2863,6,130,-1,0,2863,261,1,0,0,0,2864,2865,3,44,22,0,2865, + 2866,6,131,-1,0,2866,2871,1,0,0,0,2867,2868,3,46,23,0,2868,2869,6,131, + -1,0,2869,2871,1,0,0,0,2870,2864,1,0,0,0,2870,2867,1,0,0,0,2871,263,1, + 0,0,0,2872,2873,5,17,0,0,2873,2874,3,246,123,0,2874,2875,5,18,0,0,2875, + 265,1,0,0,0,2876,2877,3,270,135,0,2877,2878,3,268,134,0,2878,267,1,0,0, + 0,2879,2880,3,272,136,0,2880,2881,6,134,-1,0,2881,2883,1,0,0,0,2882,2879, + 1,0,0,0,2883,2884,1,0,0,0,2884,2882,1,0,0,0,2884,2885,1,0,0,0,2885,269, + 1,0,0,0,2886,2887,5,158,0,0,2887,2888,3,264,132,0,2888,2889,6,135,-1,0, + 2889,2903,1,0,0,0,2890,2891,5,158,0,0,2891,2892,3,0,0,0,2892,2893,5,159, + 0,0,2893,2894,3,0,0,0,2894,2895,6,135,-1,0,2895,2903,1,0,0,0,2896,2897, + 5,158,0,0,2897,2898,3,32,16,0,2898,2899,5,159,0,0,2899,2900,3,32,16,0, + 2900,2901,6,135,-1,0,2901,2903,1,0,0,0,2902,2886,1,0,0,0,2902,2890,1,0, + 0,0,2902,2896,1,0,0,0,2903,271,1,0,0,0,2904,2905,3,276,138,0,2905,2906, + 3,282,141,0,2906,2907,6,136,-1,0,2907,2921,1,0,0,0,2908,2909,3,274,137, + 0,2909,2910,3,282,141,0,2910,2911,6,136,-1,0,2911,2921,1,0,0,0,2912,2913, + 3,278,139,0,2913,2914,3,282,141,0,2914,2915,6,136,-1,0,2915,2921,1,0,0, + 0,2916,2917,3,280,140,0,2917,2918,3,282,141,0,2918,2919,6,136,-1,0,2919, + 2921,1,0,0,0,2920,2904,1,0,0,0,2920,2908,1,0,0,0,2920,2912,1,0,0,0,2920, + 2916,1,0,0,0,2921,273,1,0,0,0,2922,2923,5,160,0,0,2923,2924,3,264,132, + 0,2924,2925,6,137,-1,0,2925,2935,1,0,0,0,2926,2927,5,160,0,0,2927,2928, + 3,0,0,0,2928,2929,6,137,-1,0,2929,2935,1,0,0,0,2930,2931,5,160,0,0,2931, + 2932,3,32,16,0,2932,2933,6,137,-1,0,2933,2935,1,0,0,0,2934,2922,1,0,0, + 0,2934,2926,1,0,0,0,2934,2930,1,0,0,0,2935,275,1,0,0,0,2936,2937,5,161, + 0,0,2937,2938,3,124,62,0,2938,277,1,0,0,0,2939,2940,5,162,0,0,2940,279, + 1,0,0,0,2941,2942,5,163,0,0,2942,281,1,0,0,0,2943,2944,3,264,132,0,2944, + 2945,6,141,-1,0,2945,2959,1,0,0,0,2946,2947,5,164,0,0,2947,2948,3,0,0, + 0,2948,2949,5,159,0,0,2949,2950,3,0,0,0,2950,2951,6,141,-1,0,2951,2959, + 1,0,0,0,2952,2953,5,164,0,0,2953,2954,3,32,16,0,2954,2955,5,159,0,0,2955, + 2956,3,32,16,0,2956,2957,6,141,-1,0,2957,2959,1,0,0,0,2958,2943,1,0,0, + 0,2958,2946,1,0,0,0,2958,2952,1,0,0,0,2959,283,1,0,0,0,2960,2961,3,286, + 143,0,2961,2962,3,290,145,0,2962,285,1,0,0,0,2963,2964,5,165,0,0,2964, + 2965,3,288,144,0,2965,2966,3,0,0,0,2966,2967,5,36,0,0,2967,2968,6,143, + -1,0,2968,2974,1,0,0,0,2969,2970,5,165,0,0,2970,2971,3,288,144,0,2971, + 2972,6,143,-1,0,2972,2974,1,0,0,0,2973,2963,1,0,0,0,2973,2969,1,0,0,0, + 2974,287,1,0,0,0,2975,2981,1,0,0,0,2976,2977,5,166,0,0,2977,2981,6,144, + -1,0,2978,2979,5,2,0,0,2979,2981,6,144,-1,0,2980,2975,1,0,0,0,2980,2976, + 1,0,0,0,2980,2978,1,0,0,0,2981,289,1,0,0,0,2982,2983,5,17,0,0,2983,2984, + 3,292,146,0,2984,2985,5,18,0,0,2985,2992,1,0,0,0,2986,2988,3,296,148,0, + 2987,2986,1,0,0,0,2988,2989,1,0,0,0,2989,2987,1,0,0,0,2989,2990,1,0,0, + 0,2990,2992,1,0,0,0,2991,2982,1,0,0,0,2991,2987,1,0,0,0,2992,291,1,0,0, + 0,2993,2994,3,296,148,0,2994,2995,5,28,0,0,2995,2997,1,0,0,0,2996,2993, + 1,0,0,0,2997,3000,1,0,0,0,2998,2996,1,0,0,0,2998,2999,1,0,0,0,2999,3001, + 1,0,0,0,3000,2998,1,0,0,0,3001,3002,3,296,148,0,3002,293,1,0,0,0,3003, + 3010,1,0,0,0,3004,3005,5,42,0,0,3005,3006,3,32,16,0,3006,3007,5,43,0,0, + 3007,3008,6,147,-1,0,3008,3010,1,0,0,0,3009,3003,1,0,0,0,3009,3004,1,0, + 0,0,3010,295,1,0,0,0,3011,3012,5,181,0,0,3012,3013,5,262,0,0,3013,3014, + 5,30,0,0,3014,3015,3,6,3,0,3015,3016,5,31,0,0,3016,3017,6,148,-1,0,3017, + 3060,1,0,0,0,3018,3019,5,260,0,0,3019,3020,5,30,0,0,3020,3021,3,0,0,0, + 3021,3022,5,31,0,0,3022,3023,6,148,-1,0,3023,3060,1,0,0,0,3024,3025,5, + 260,0,0,3025,3026,3,0,0,0,3026,3027,6,148,-1,0,3027,3060,1,0,0,0,3028, + 3029,5,84,0,0,3029,3030,5,30,0,0,3030,3031,3,300,150,0,3031,3032,5,31, + 0,0,3032,3033,6,148,-1,0,3033,3060,1,0,0,0,3034,3035,7,10,0,0,3035,3036, + 5,30,0,0,3036,3037,3,36,18,0,3037,3038,5,31,0,0,3038,3039,3,294,147,0, + 3039,3040,6,148,-1,0,3040,3060,1,0,0,0,3041,3042,5,187,0,0,3042,3043,5, + 30,0,0,3043,3044,3,34,17,0,3044,3045,5,31,0,0,3045,3046,3,294,147,0,3046, + 3047,6,148,-1,0,3047,3060,1,0,0,0,3048,3049,7,11,0,0,3049,3050,5,30,0, + 0,3050,3051,3,32,16,0,3051,3052,5,31,0,0,3052,3053,3,294,147,0,3053,3054, + 6,148,-1,0,3054,3060,1,0,0,0,3055,3056,7,12,0,0,3056,3057,3,294,147,0, + 3057,3058,6,148,-1,0,3058,3060,1,0,0,0,3059,3011,1,0,0,0,3059,3018,1,0, + 0,0,3059,3024,1,0,0,0,3059,3028,1,0,0,0,3059,3034,1,0,0,0,3059,3041,1, + 0,0,0,3059,3048,1,0,0,0,3059,3055,1,0,0,0,3060,297,1,0,0,0,3061,3062,5, + 188,0,0,3062,3063,5,30,0,0,3063,3064,3,36,18,0,3064,3065,5,31,0,0,3065, + 3066,6,149,-1,0,3066,3152,1,0,0,0,3067,3068,5,189,0,0,3068,3069,5,30,0, + 0,3069,3070,3,36,18,0,3070,3071,5,31,0,0,3071,3072,6,149,-1,0,3072,3152, + 1,0,0,0,3073,3074,5,188,0,0,3074,3075,5,30,0,0,3075,3076,3,32,16,0,3076, + 3077,5,31,0,0,3077,3078,6,149,-1,0,3078,3152,1,0,0,0,3079,3080,5,189,0, + 0,3080,3081,5,30,0,0,3081,3082,3,34,17,0,3082,3083,5,31,0,0,3083,3084, + 6,149,-1,0,3084,3152,1,0,0,0,3085,3086,5,187,0,0,3086,3087,5,30,0,0,3087, + 3088,3,34,17,0,3088,3089,5,31,0,0,3089,3090,6,149,-1,0,3090,3152,1,0,0, + 0,3091,3092,5,186,0,0,3092,3093,5,30,0,0,3093,3094,3,32,16,0,3094,3095, + 5,31,0,0,3095,3096,6,149,-1,0,3096,3152,1,0,0,0,3097,3098,5,185,0,0,3098, + 3099,5,30,0,0,3099,3100,3,32,16,0,3100,3101,5,31,0,0,3101,3102,6,149,-1, + 0,3102,3152,1,0,0,0,3103,3104,5,184,0,0,3104,3105,5,30,0,0,3105,3106,3, + 32,16,0,3106,3107,5,31,0,0,3107,3108,6,149,-1,0,3108,3152,1,0,0,0,3109, + 3110,5,193,0,0,3110,3111,5,30,0,0,3111,3112,3,34,17,0,3112,3113,5,31,0, + 0,3113,3114,6,149,-1,0,3114,3152,1,0,0,0,3115,3116,5,192,0,0,3116,3117, + 5,30,0,0,3117,3118,3,32,16,0,3118,3119,5,31,0,0,3119,3120,6,149,-1,0,3120, + 3152,1,0,0,0,3121,3122,5,191,0,0,3122,3123,5,30,0,0,3123,3124,3,32,16, + 0,3124,3125,5,31,0,0,3125,3126,6,149,-1,0,3126,3152,1,0,0,0,3127,3128, + 5,190,0,0,3128,3129,5,30,0,0,3129,3130,3,32,16,0,3130,3131,5,31,0,0,3131, + 3132,6,149,-1,0,3132,3152,1,0,0,0,3133,3134,5,181,0,0,3134,3135,5,30,0, + 0,3135,3136,3,32,16,0,3136,3137,5,31,0,0,3137,3138,6,149,-1,0,3138,3152, + 1,0,0,0,3139,3140,5,183,0,0,3140,3141,5,30,0,0,3141,3142,3,162,81,0,3142, + 3143,5,31,0,0,3143,3144,6,149,-1,0,3144,3152,1,0,0,0,3145,3146,5,84,0, + 0,3146,3147,5,30,0,0,3147,3148,3,300,150,0,3148,3149,5,31,0,0,3149,3150, + 6,149,-1,0,3150,3152,1,0,0,0,3151,3061,1,0,0,0,3151,3067,1,0,0,0,3151, + 3073,1,0,0,0,3151,3079,1,0,0,0,3151,3085,1,0,0,0,3151,3091,1,0,0,0,3151, + 3097,1,0,0,0,3151,3103,1,0,0,0,3151,3109,1,0,0,0,3151,3115,1,0,0,0,3151, + 3121,1,0,0,0,3151,3127,1,0,0,0,3151,3133,1,0,0,0,3151,3139,1,0,0,0,3151, + 3145,1,0,0,0,3152,299,1,0,0,0,3153,3154,3,302,151,0,3154,3155,6,150,-1, + 0,3155,3157,1,0,0,0,3156,3153,1,0,0,0,3157,3160,1,0,0,0,3158,3156,1,0, + 0,0,3158,3159,1,0,0,0,3159,301,1,0,0,0,3160,3158,1,0,0,0,3161,3162,7,13, + 0,0,3162,303,1,0,0,0,3163,3164,3,298,149,0,3164,3165,6,152,-1,0,3165,3172, + 1,0,0,0,3166,3167,3,6,3,0,3167,3168,6,152,-1,0,3168,3172,1,0,0,0,3169, + 3170,5,179,0,0,3170,3172,6,152,-1,0,3171,3163,1,0,0,0,3171,3166,1,0,0, + 0,3171,3169,1,0,0,0,3172,305,1,0,0,0,3173,3174,3,298,149,0,3174,3175,6, + 153,-1,0,3175,3345,1,0,0,0,3176,3177,5,182,0,0,3177,3178,5,30,0,0,3178, + 3179,5,179,0,0,3179,3180,5,31,0,0,3180,3345,6,153,-1,0,3181,3182,5,182, + 0,0,3182,3183,5,30,0,0,3183,3184,5,264,0,0,3184,3185,5,31,0,0,3185,3345, + 6,153,-1,0,3186,3187,5,196,0,0,3187,3188,5,30,0,0,3188,3189,5,39,0,0,3189, + 3190,5,264,0,0,3190,3191,5,31,0,0,3191,3345,6,153,-1,0,3192,3193,5,196, + 0,0,3193,3194,5,30,0,0,3194,3195,3,116,58,0,3195,3196,5,31,0,0,3196,3197, + 6,153,-1,0,3197,3345,1,0,0,0,3198,3199,5,196,0,0,3199,3200,5,30,0,0,3200, + 3201,5,179,0,0,3201,3202,5,31,0,0,3202,3345,6,153,-1,0,3203,3204,5,197, + 0,0,3204,3205,5,30,0,0,3205,3206,3,306,153,0,3206,3207,5,31,0,0,3207,3208, + 6,153,-1,0,3208,3345,1,0,0,0,3209,3210,5,188,0,0,3210,3211,5,42,0,0,3211, + 3212,3,32,16,0,3212,3213,5,43,0,0,3213,3214,5,30,0,0,3214,3215,3,308,154, + 0,3215,3216,5,31,0,0,3216,3217,6,153,-1,0,3217,3345,1,0,0,0,3218,3219, + 5,189,0,0,3219,3220,5,42,0,0,3220,3221,3,32,16,0,3221,3222,5,43,0,0,3222, + 3223,5,30,0,0,3223,3224,3,310,155,0,3224,3225,5,31,0,0,3225,3226,6,153, + -1,0,3226,3345,1,0,0,0,3227,3228,5,187,0,0,3228,3229,5,42,0,0,3229,3230, + 3,32,16,0,3230,3231,5,43,0,0,3231,3232,5,30,0,0,3232,3233,3,312,156,0, + 3233,3234,5,31,0,0,3234,3235,6,153,-1,0,3235,3345,1,0,0,0,3236,3237,5, + 186,0,0,3237,3238,5,42,0,0,3238,3239,3,32,16,0,3239,3240,5,43,0,0,3240, + 3241,5,30,0,0,3241,3242,3,314,157,0,3242,3243,5,31,0,0,3243,3244,6,153, + -1,0,3244,3345,1,0,0,0,3245,3246,5,185,0,0,3246,3247,5,42,0,0,3247,3248, + 3,32,16,0,3248,3249,5,43,0,0,3249,3250,5,30,0,0,3250,3251,3,316,158,0, + 3251,3252,5,31,0,0,3252,3253,6,153,-1,0,3253,3345,1,0,0,0,3254,3255,5, + 184,0,0,3255,3256,5,42,0,0,3256,3257,3,32,16,0,3257,3258,5,43,0,0,3258, + 3259,5,30,0,0,3259,3260,3,318,159,0,3260,3261,5,31,0,0,3261,3262,6,153, + -1,0,3262,3345,1,0,0,0,3263,3264,5,193,0,0,3264,3265,5,42,0,0,3265,3266, + 3,32,16,0,3266,3267,5,43,0,0,3267,3268,5,30,0,0,3268,3269,3,312,156,0, + 3269,3270,5,31,0,0,3270,3271,6,153,-1,0,3271,3345,1,0,0,0,3272,3273,5, + 192,0,0,3273,3274,5,42,0,0,3274,3275,3,32,16,0,3275,3276,5,43,0,0,3276, + 3277,5,30,0,0,3277,3278,3,314,157,0,3278,3279,5,31,0,0,3279,3280,6,153, + -1,0,3280,3345,1,0,0,0,3281,3282,5,191,0,0,3282,3283,5,42,0,0,3283,3284, + 3,32,16,0,3284,3285,5,43,0,0,3285,3286,5,30,0,0,3286,3287,3,316,158,0, + 3287,3288,5,31,0,0,3288,3289,6,153,-1,0,3289,3345,1,0,0,0,3290,3291,5, + 190,0,0,3291,3292,5,42,0,0,3292,3293,3,32,16,0,3293,3294,5,43,0,0,3294, + 3295,5,30,0,0,3295,3296,3,318,159,0,3296,3297,5,31,0,0,3297,3298,6,153, + -1,0,3298,3345,1,0,0,0,3299,3300,5,181,0,0,3300,3301,5,42,0,0,3301,3302, + 3,32,16,0,3302,3303,5,43,0,0,3303,3304,5,30,0,0,3304,3305,3,316,158,0, + 3305,3306,5,31,0,0,3306,3307,6,153,-1,0,3307,3345,1,0,0,0,3308,3309,5, + 183,0,0,3309,3310,5,42,0,0,3310,3311,3,32,16,0,3311,3312,5,43,0,0,3312, + 3313,5,30,0,0,3313,3314,3,320,160,0,3314,3315,5,31,0,0,3315,3316,6,153, + -1,0,3316,3345,1,0,0,0,3317,3318,5,182,0,0,3318,3319,5,42,0,0,3319,3320, + 3,32,16,0,3320,3321,5,43,0,0,3321,3322,5,30,0,0,3322,3323,3,322,161,0, + 3323,3324,5,31,0,0,3324,3325,6,153,-1,0,3325,3345,1,0,0,0,3326,3327,5, + 196,0,0,3327,3328,5,42,0,0,3328,3329,3,32,16,0,3329,3330,5,43,0,0,3330, + 3331,5,30,0,0,3331,3332,3,324,162,0,3332,3333,5,31,0,0,3333,3334,6,153, + -1,0,3334,3345,1,0,0,0,3335,3336,5,197,0,0,3336,3337,5,42,0,0,3337,3338, + 3,32,16,0,3338,3339,5,43,0,0,3339,3340,5,30,0,0,3340,3341,3,328,164,0, + 3341,3342,5,31,0,0,3342,3343,6,153,-1,0,3343,3345,1,0,0,0,3344,3173,1, + 0,0,0,3344,3176,1,0,0,0,3344,3181,1,0,0,0,3344,3186,1,0,0,0,3344,3192, + 1,0,0,0,3344,3198,1,0,0,0,3344,3203,1,0,0,0,3344,3209,1,0,0,0,3344,3218, + 1,0,0,0,3344,3227,1,0,0,0,3344,3236,1,0,0,0,3344,3245,1,0,0,0,3344,3254, + 1,0,0,0,3344,3263,1,0,0,0,3344,3272,1,0,0,0,3344,3281,1,0,0,0,3344,3290, + 1,0,0,0,3344,3299,1,0,0,0,3344,3308,1,0,0,0,3344,3317,1,0,0,0,3344,3326, + 1,0,0,0,3344,3335,1,0,0,0,3345,307,1,0,0,0,3346,3347,3,36,18,0,3347,3348, + 6,154,-1,0,3348,3353,1,0,0,0,3349,3350,3,32,16,0,3350,3351,6,154,-1,0, + 3351,3353,1,0,0,0,3352,3346,1,0,0,0,3352,3349,1,0,0,0,3353,3356,1,0,0, + 0,3354,3352,1,0,0,0,3354,3355,1,0,0,0,3355,309,1,0,0,0,3356,3354,1,0,0, + 0,3357,3358,3,36,18,0,3358,3359,6,155,-1,0,3359,3364,1,0,0,0,3360,3361, + 3,34,17,0,3361,3362,6,155,-1,0,3362,3364,1,0,0,0,3363,3357,1,0,0,0,3363, + 3360,1,0,0,0,3364,3367,1,0,0,0,3365,3363,1,0,0,0,3365,3366,1,0,0,0,3366, + 311,1,0,0,0,3367,3365,1,0,0,0,3368,3369,3,34,17,0,3369,3370,6,156,-1,0, + 3370,3372,1,0,0,0,3371,3368,1,0,0,0,3372,3375,1,0,0,0,3373,3371,1,0,0, + 0,3373,3374,1,0,0,0,3374,313,1,0,0,0,3375,3373,1,0,0,0,3376,3377,3,32, + 16,0,3377,3378,6,157,-1,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,315,1,0,0,0,3383,3381, + 1,0,0,0,3384,3385,3,32,16,0,3385,3386,6,158,-1,0,3386,3388,1,0,0,0,3387, + 3384,1,0,0,0,3388,3391,1,0,0,0,3389,3387,1,0,0,0,3389,3390,1,0,0,0,3390, + 317,1,0,0,0,3391,3389,1,0,0,0,3392,3393,3,32,16,0,3393,3394,6,159,-1,0, + 3394,3396,1,0,0,0,3395,3392,1,0,0,0,3396,3399,1,0,0,0,3397,3395,1,0,0, + 0,3397,3398,1,0,0,0,3398,319,1,0,0,0,3399,3397,1,0,0,0,3400,3401,3,162, + 81,0,3401,3402,6,160,-1,0,3402,3404,1,0,0,0,3403,3400,1,0,0,0,3404,3407, + 1,0,0,0,3405,3403,1,0,0,0,3405,3406,1,0,0,0,3406,321,1,0,0,0,3407,3405, + 1,0,0,0,3408,3409,5,179,0,0,3409,3413,6,161,-1,0,3410,3411,5,264,0,0,3411, + 3413,6,161,-1,0,3412,3408,1,0,0,0,3412,3410,1,0,0,0,3413,3416,1,0,0,0, + 3414,3412,1,0,0,0,3414,3415,1,0,0,0,3415,323,1,0,0,0,3416,3414,1,0,0,0, + 3417,3418,3,326,163,0,3418,3419,6,162,-1,0,3419,3421,1,0,0,0,3420,3417, + 1,0,0,0,3421,3424,1,0,0,0,3422,3420,1,0,0,0,3422,3423,1,0,0,0,3423,325, + 1,0,0,0,3424,3422,1,0,0,0,3425,3426,5,179,0,0,3426,3434,6,163,-1,0,3427, + 3428,5,39,0,0,3428,3429,5,264,0,0,3429,3434,6,163,-1,0,3430,3431,3,116, + 58,0,3431,3432,6,163,-1,0,3432,3434,1,0,0,0,3433,3425,1,0,0,0,3433,3427, + 1,0,0,0,3433,3430,1,0,0,0,3434,327,1,0,0,0,3435,3436,3,306,153,0,3436, + 3437,6,164,-1,0,3437,3439,1,0,0,0,3438,3435,1,0,0,0,3439,3442,1,0,0,0, + 3440,3438,1,0,0,0,3440,3441,1,0,0,0,3441,329,1,0,0,0,3442,3440,1,0,0,0, + 3443,3444,3,44,22,0,3444,3445,6,165,-1,0,3445,3453,1,0,0,0,3446,3447,3, + 46,23,0,3447,3448,6,165,-1,0,3448,3453,1,0,0,0,3449,3450,3,2,1,0,3450, + 3451,6,165,-1,0,3451,3453,1,0,0,0,3452,3443,1,0,0,0,3452,3446,1,0,0,0, + 3452,3449,1,0,0,0,3453,331,1,0,0,0,3454,3455,7,14,0,0,3455,3456,5,36,0, + 0,3456,3457,5,30,0,0,3457,3458,3,300,150,0,3458,3459,5,31,0,0,3459,3480, + 1,0,0,0,3460,3461,5,169,0,0,3461,3462,3,38,19,0,3462,3463,5,75,0,0,3463, + 3464,3,38,19,0,3464,3465,5,75,0,0,3465,3466,3,38,19,0,3466,3467,5,75,0, + 0,3467,3468,3,38,19,0,3468,3480,1,0,0,0,3469,3470,5,170,0,0,3470,3480, + 3,6,3,0,3471,3472,5,170,0,0,3472,3473,5,36,0,0,3473,3474,5,30,0,0,3474, + 3475,3,300,150,0,3475,3476,5,31,0,0,3476,3480,1,0,0,0,3477,3480,3,330, + 165,0,3478,3480,3,40,20,0,3479,3454,1,0,0,0,3479,3460,1,0,0,0,3479,3469, + 1,0,0,0,3479,3471,1,0,0,0,3479,3477,1,0,0,0,3479,3478,1,0,0,0,3480,333, + 1,0,0,0,3481,3482,3,336,168,0,3482,3483,5,17,0,0,3483,3484,3,338,169,0, + 3484,3485,5,18,0,0,3485,335,1,0,0,0,3486,3487,5,25,0,0,3487,3488,5,40, + 0,0,3488,3489,3,98,49,0,3489,3490,3,2,1,0,3490,3499,1,0,0,0,3491,3492, + 5,25,0,0,3492,3493,5,40,0,0,3493,3494,3,98,49,0,3494,3495,3,2,1,0,3495, + 3496,5,34,0,0,3496,3497,3,2,1,0,3497,3499,1,0,0,0,3498,3486,1,0,0,0,3498, + 3491,1,0,0,0,3499,337,1,0,0,0,3500,3502,3,340,170,0,3501,3500,1,0,0,0, + 3502,3505,1,0,0,0,3503,3501,1,0,0,0,3503,3504,1,0,0,0,3504,339,1,0,0,0, + 3505,3503,1,0,0,0,3506,3507,5,180,0,0,3507,3508,5,36,0,0,3508,3509,5,30, + 0,0,3509,3510,3,300,150,0,3510,3511,5,31,0,0,3511,3521,1,0,0,0,3512,3521, + 3,332,166,0,3513,3514,5,171,0,0,3514,3515,5,36,0,0,3515,3516,5,30,0,0, + 3516,3517,3,300,150,0,3517,3518,5,31,0,0,3518,3521,1,0,0,0,3519,3521,5, + 55,0,0,3520,3506,1,0,0,0,3520,3512,1,0,0,0,3520,3513,1,0,0,0,3520,3519, + 1,0,0,0,3521,341,1,0,0,0,3522,3523,3,344,172,0,3523,3524,5,17,0,0,3524, + 3525,3,350,175,0,3525,3526,5,18,0,0,3526,343,1,0,0,0,3527,3528,5,50,0, + 0,3528,3532,5,40,0,0,3529,3531,3,348,174,0,3530,3529,1,0,0,0,3531,3534, + 1,0,0,0,3532,3530,1,0,0,0,3532,3533,1,0,0,0,3533,3535,1,0,0,0,3534,3532, + 1,0,0,0,3535,3536,3,2,1,0,3536,345,1,0,0,0,3537,3541,5,301,0,0,3538,3540, + 3,348,174,0,3539,3538,1,0,0,0,3540,3543,1,0,0,0,3541,3539,1,0,0,0,3541, + 3542,1,0,0,0,3542,3544,1,0,0,0,3543,3541,1,0,0,0,3544,3545,3,2,1,0,3545, + 347,1,0,0,0,3546,3562,5,52,0,0,3547,3562,5,51,0,0,3548,3562,5,172,0,0, + 3549,3550,5,62,0,0,3550,3562,5,51,0,0,3551,3552,5,62,0,0,3552,3562,5,52, + 0,0,3553,3554,5,62,0,0,3554,3562,5,63,0,0,3555,3556,5,62,0,0,3556,3562, + 5,64,0,0,3557,3558,5,62,0,0,3558,3562,5,65,0,0,3559,3560,5,62,0,0,3560, + 3562,5,66,0,0,3561,3546,1,0,0,0,3561,3547,1,0,0,0,3561,3548,1,0,0,0,3561, + 3549,1,0,0,0,3561,3551,1,0,0,0,3561,3553,1,0,0,0,3561,3555,1,0,0,0,3561, + 3557,1,0,0,0,3561,3559,1,0,0,0,3562,349,1,0,0,0,3563,3565,3,352,176,0, + 3564,3563,1,0,0,0,3565,3568,1,0,0,0,3566,3564,1,0,0,0,3566,3567,1,0,0, + 0,3567,351,1,0,0,0,3568,3566,1,0,0,0,3569,3570,5,21,0,0,3570,3583,3,2, + 1,0,3571,3572,5,50,0,0,3572,3573,5,40,0,0,3573,3583,3,118,59,0,3574,3575, + 5,25,0,0,3575,3576,5,40,0,0,3576,3583,3,2,1,0,3577,3583,3,174,87,0,3578, + 3579,5,50,0,0,3579,3583,3,32,16,0,3580,3583,3,330,165,0,3581,3583,3,40, + 20,0,3582,3569,1,0,0,0,3582,3571,1,0,0,0,3582,3574,1,0,0,0,3582,3577,1, + 0,0,0,3582,3578,1,0,0,0,3582,3580,1,0,0,0,3582,3581,1,0,0,0,3583,353,1, + 0,0,0,3584,3585,3,356,178,0,3585,3586,5,17,0,0,3586,3587,3,360,180,0,3587, + 3588,5,18,0,0,3588,355,1,0,0,0,3589,3593,5,274,0,0,3590,3592,3,358,179, + 0,3591,3590,1,0,0,0,3592,3595,1,0,0,0,3593,3591,1,0,0,0,3593,3594,1,0, + 0,0,3594,3596,1,0,0,0,3595,3593,1,0,0,0,3596,3609,3,2,1,0,3597,3601,5, + 274,0,0,3598,3600,3,358,179,0,3599,3598,1,0,0,0,3600,3603,1,0,0,0,3601, + 3599,1,0,0,0,3601,3602,1,0,0,0,3602,3604,1,0,0,0,3603,3601,1,0,0,0,3604, + 3605,3,2,1,0,3605,3606,5,34,0,0,3606,3607,3,2,1,0,3607,3609,1,0,0,0,3608, + 3589,1,0,0,0,3608,3597,1,0,0,0,3609,357,1,0,0,0,3610,3611,7,15,0,0,3611, + 359,1,0,0,0,3612,3614,3,362,181,0,3613,3612,1,0,0,0,3614,3617,1,0,0,0, + 3615,3613,1,0,0,0,3615,3616,1,0,0,0,3616,361,1,0,0,0,3617,3615,1,0,0,0, + 3618,3619,5,21,0,0,3619,3620,3,2,1,0,3620,3621,5,44,0,0,3621,3622,3,32, + 16,0,3622,3629,1,0,0,0,3623,3624,5,25,0,0,3624,3625,5,40,0,0,3625,3629, + 3,2,1,0,3626,3629,3,330,165,0,3627,3629,3,40,20,0,3628,3618,1,0,0,0,3628, + 3623,1,0,0,0,3628,3626,1,0,0,0,3628,3627,1,0,0,0,3629,363,1,0,0,0,187, + 374,382,391,400,489,539,550,580,584,602,629,657,697,708,718,720,731,733, + 741,763,776,797,799,818,891,898,905,910,919,930,939,950,961,974,978,984, + 1000,1006,1012,1019,1047,1125,1127,1141,1147,1156,1158,1167,1181,1195, + 1203,1211,1215,1254,1262,1271,1279,1298,1308,1311,1335,1482,1492,1501, + 1504,1586,1595,1627,1687,1727,1743,1753,1783,1811,1820,1826,1843,1851, + 1909,1919,1937,1955,1974,1995,2014,2029,2037,2049,2069,2076,2081,2092, + 2104,2214,2226,2242,2256,2265,2278,2280,2323,2334,2341,2349,2357,2370, + 2376,2382,2387,2416,2424,2438,2443,2468,2477,2488,2492,2499,2519,2528, + 2530,2545,2592,2602,2604,2611,2617,2661,2670,2710,2715,2755,2759,2769, + 2791,2803,2814,2829,2842,2855,2858,2870,2884,2902,2920,2934,2958,2973, + 2980,2989,2991,2998,3009,3059,3151,3158,3171,3344,3352,3354,3363,3365, + 3373,3381,3389,3397,3405,3412,3414,3422,3433,3440,3452,3479,3498,3503, + 3520,3532,3541,3561,3566,3582,3593,3601,3608,3615,3628 }; public static readonly ATN _ATN = diff --git a/src/tools/ilasm/tests/ILAssembler.Tests/DataTests.cs b/src/tools/ilasm/tests/ILAssembler.Tests/DataTests.cs index 70dea69be5c691..d94d2274218dff 100644 --- a/src/tools/ilasm/tests/ILAssembler.Tests/DataTests.cs +++ b/src/tools/ilasm/tests/ILAssembler.Tests/DataTests.cs @@ -240,6 +240,94 @@ .field [0] public static int8 LargeData at D_LARGE Assert.Equal(expected, ReadData(pe, field, Length)); } + [Fact] + public void DataDeclaration_SyntaxVariantsPreserveOffsetsAndReferenceFixups() + { + string source = """ + .assembly test { } + .data int8(0xAA) + .data tls TlsData = int8(0x11) + .data cil CilData = int8(0x22) + .data TargetData = int32(0x12345678) + .data ParenthesizedReference = &(TargetData) + .data BareReference = &TargetData + + .class public explicit ansi sealed DataHolder + { + .field [0] public static int8 TlsValue at TlsData + .field [1] public static int8 CilValue at CilData + .field [2] public static int32 TargetValue at TargetData + .field [6] public static int32 ParenthesizedValue at ParenthesizedReference + .field [10] public static int32 BareValue at BareReference + } + """; + + using var pe = DocumentCompilerTestHelpers.CompileAndGetReader(source, new Options()); + MetadataReader reader = pe.GetMetadataReader(); + Dictionary fields = reader.FieldDefinitions + .Select(reader.GetFieldDefinition) + .ToDictionary(field => reader.GetString(field.Name)); + + int tlsRva = fields["TlsValue"].GetRelativeVirtualAddress(); + int cilRva = fields["CilValue"].GetRelativeVirtualAddress(); + int targetRva = fields["TargetValue"].GetRelativeVirtualAddress(); + int parenthesizedRva = fields["ParenthesizedValue"].GetRelativeVirtualAddress(); + int bareRva = fields["BareValue"].GetRelativeVirtualAddress(); + + Assert.Equal(tlsRva + 1, cilRva); + Assert.Equal(cilRva + 1, targetRva); + Assert.Equal(targetRva + sizeof(int), parenthesizedRva); + Assert.Equal(parenthesizedRva + sizeof(int), bareRva); + Assert.Equal(0x11, Assert.Single(ReadData(pe, fields["TlsValue"], 1))); + Assert.Equal(0x22, Assert.Single(ReadData(pe, fields["CilValue"], 1))); + Assert.Equal(0x12345678, BitConverter.ToInt32(ReadData(pe, fields["TargetValue"], sizeof(int)))); + Assert.Equal(targetRva, BitConverter.ToInt32(ReadData(pe, fields["ParenthesizedValue"], sizeof(int)))); + Assert.Equal(targetRva, BitConverter.ToInt32(ReadData(pe, fields["BareValue"], sizeof(int)))); + } + + [Fact] + public void MalformedDataDeclaration_DoesNotLeakBytesOrLabelIntoNextDocument() + { + ImmutableArray documents = + [ + new SourceText(""" + .assembly test { } + .data Broken = { int8(0xAA), } + """, "broken.il"), + new SourceText(""" + .data Good = int32(0x12345678) + .class public auto ansi DataHolder + { + .field public static int8 Missing at Broken + .field public static int32 Value at Good + } + """, "valid.il"), + ]; + + var compiler = new DocumentCompiler(); + (ImmutableArray diagnostics, CompilationResult? result) = compiler.Compile( + documents, + _ => throw new InvalidOperationException("Unexpected include"), + _ => throw new InvalidOperationException("Unexpected resource"), + new Options { ErrorTolerant = true }); + + Assert.Contains(diagnostics, diagnostic => diagnostic.Severity == DiagnosticSeverity.Error); + Assert.NotNull(result); + + var image = new BlobBuilder(); + result!.Serialize(image); + using var pe = new PEReader(image.ToImmutableArray()); + MetadataReader reader = pe.GetMetadataReader(); + Dictionary fields = reader.FieldDefinitions + .Select(reader.GetFieldDefinition) + .ToDictionary(field => reader.GetString(field.Name)); + + Assert.Equal(0, fields["Missing"].GetRelativeVirtualAddress()); + Assert.Equal( + 0x12345678, + BitConverter.ToInt32(ReadData(pe, fields["Value"], sizeof(int)))); + } + private static byte[] ReadData(PEReader pe, FieldDefinition field, int length) { int rva = field.GetRelativeVirtualAddress(); diff --git a/src/tools/ilasm/tests/ILAssembler.Tests/SecurityTests.cs b/src/tools/ilasm/tests/ILAssembler.Tests/SecurityTests.cs index a44d1c521cc6c7..4d84e16057d29c 100644 --- a/src/tools/ilasm/tests/ILAssembler.Tests/SecurityTests.cs +++ b/src/tools/ilasm/tests/ILAssembler.Tests/SecurityTests.cs @@ -1,6 +1,8 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System; +using System.Collections.Immutable; using System.Reflection; using System.Reflection.Metadata; using System.Reflection.Metadata.Ecma335; @@ -244,5 +246,95 @@ .method public static void M() cil managed security.Action == DeclarativeSecurityAction.Assert && reader.GetBlobBytes(security.PermissionSet).SequenceEqual((byte[])[0x2F])); } + + [Fact] + public void PermissionSet_VerbalAttributesPreserveNamesAndTypeReferenceOrder() + { + string source = """ + .assembly extern mscorlib { } + .assembly test + { + .permissionset demand = { + [mscorlib]Contoso.FirstPermission = { }, + class 'Contoso.QuotedPermission' = { + property bool Enabled = bool(true) + }, + [mscorlib]Contoso.SecondPermission = { } + } + } + """; + + using var pe = DocumentCompilerTestHelpers.CompileAndGetReader(source, new Options()); + MetadataReader reader = pe.GetMetadataReader(); + DeclarativeSecurityAttribute security = reader.GetDeclarativeSecurityAttribute( + Assert.Single(reader.GetAssemblyDefinition().GetDeclarativeSecurityAttributes())); + BlobReader permissionSet = reader.GetBlobReader(security.PermissionSet); + + Assert.Equal((byte)'.', permissionSet.ReadByte()); + Assert.Equal(3, permissionSet.ReadCompressedInteger()); + Assert.StartsWith( + "Contoso.FirstPermission, mscorlib", + permissionSet.ReadSerializedString(), + StringComparison.Ordinal); + Assert.Equal(0, permissionSet.ReadUInt16()); + Assert.Equal("Contoso.QuotedPermission", permissionSet.ReadSerializedString()); + Assert.Equal(1, permissionSet.ReadUInt16()); + Assert.Equal((byte)CustomAttributeNamedArgumentKind.Property, permissionSet.ReadByte()); + Assert.Equal((byte)SerializationTypeCode.Boolean, permissionSet.ReadByte()); + Assert.Equal("Enabled", permissionSet.ReadSerializedString()); + Assert.True(permissionSet.ReadBoolean()); + Assert.StartsWith( + "Contoso.SecondPermission, mscorlib", + permissionSet.ReadSerializedString(), + StringComparison.Ordinal); + Assert.Equal(0, permissionSet.ReadUInt16()); + Assert.Equal(0, permissionSet.RemainingBytes); + + Assert.Equal( + ["FirstPermission", "SecondPermission"], + reader.TypeReferences + .Select(handle => reader.GetString(reader.GetTypeReference(handle).Name)) + .ToArray()); + } + + [Fact] + public void MalformedPermissionSet_DoesNotLeakAttributesIntoNextDocument() + { + ImmutableArray documents = + [ + new SourceText(""" + .assembly test { } + .permissionset demand = { + class 'Broken.Permission' = { + property bool Enabled = bool(true) + }, + } + """, "broken.il"), + new SourceText(""" + .permissionset assert = (2F) + .class public auto ansi Test { } + """, "valid.il"), + ]; + + var compiler = new DocumentCompiler(); + (ImmutableArray diagnostics, CompilationResult? result) = compiler.Compile( + documents, + _ => throw new InvalidOperationException("Unexpected include"), + _ => throw new InvalidOperationException("Unexpected resource"), + new Options { ErrorTolerant = true }); + + Assert.Contains(diagnostics, diagnostic => diagnostic.Severity == DiagnosticSeverity.Error); + Assert.NotNull(result); + + var image = new BlobBuilder(); + result!.Serialize(image); + using var pe = new PEReader(image.ToImmutableArray()); + MetadataReader reader = pe.GetMetadataReader(); + DeclarativeSecurityAttribute security = reader.GetDeclarativeSecurityAttribute( + Assert.Single(reader.GetAssemblyDefinition().GetDeclarativeSecurityAttributes())); + + Assert.Equal(DeclarativeSecurityAction.Assert, security.Action); + Assert.Equal([0x2F], reader.GetBlobBytes(security.PermissionSet)); + } } } diff --git a/src/tools/ilasm/tests/ILAssembler.Tests/SourceDirectiveTests.cs b/src/tools/ilasm/tests/ILAssembler.Tests/SourceDirectiveTests.cs index cfa11aebdef362..7a2aa3a5ea3f2e 100644 --- a/src/tools/ilasm/tests/ILAssembler.Tests/SourceDirectiveTests.cs +++ b/src/tools/ilasm/tests/ILAssembler.Tests/SourceDirectiveTests.cs @@ -527,5 +527,117 @@ .line 20 "doc2.cs" Assert.Equal(pe.GetMetadataReader().MethodDefinitions.Count, pdbReader.MethodDebugInformation.Count); } + [Fact] + public void MultiDocumentCompile_DoesNotReusePreviousDocumentPath() + { + var documents = ImmutableArray.Create( + new SourceText(""" + .assembly test { } + .class public auto ansi First + { + .method public static void M1() cil managed + { + .line 10 "first.cs" + nop + ret + } + } + """, "first.il"), + new SourceText(""" + .class public auto ansi Second + { + .method public static void M2() cil managed + { + .line 20 + nop + ret + } + } + """, "second.il")); + + var compiler = new DocumentCompiler(); + (ImmutableArray diagnostics, CompilationResult? result) = compiler.Compile( + documents, + _ => throw new InvalidOperationException("Unexpected include"), + _ => throw new InvalidOperationException("Unexpected resource"), + new Options { Pdb = true }); + + Assert.Empty(diagnostics); + Assert.NotNull(result); + + var image = new BlobBuilder(); + result!.Serialize(image); + using var pe = new PEReader(image.ToImmutableArray()); + MetadataReader reader = pe.GetMetadataReader(); + MethodDefinitionHandle firstMethod = reader.MethodDefinitions + .Single(handle => reader.GetString(reader.GetMethodDefinition(handle).Name) == "M1"); + MethodDefinitionHandle secondMethod = reader.MethodDefinitions + .Single(handle => reader.GetString(reader.GetMethodDefinition(handle).Name) == "M2"); + DebugDirectoryEntry embeddedPdb = Assert.Single( + pe.ReadDebugDirectory(), + entry => entry.Type == DebugDirectoryEntryType.EmbeddedPortablePdb); + using MetadataReaderProvider pdbProvider = + pe.ReadEmbeddedPortablePdbDebugDirectoryData(embeddedPdb); + MetadataReader pdbReader = pdbProvider.GetMetadataReader(); + + MethodDebugInformation firstDebugInformation = pdbReader.GetMethodDebugInformation( + MetadataTokens.MethodDebugInformationHandle(MetadataTokens.GetRowNumber(firstMethod))); + MethodDebugInformation secondDebugInformation = pdbReader.GetMethodDebugInformation( + MetadataTokens.MethodDebugInformationHandle(MetadataTokens.GetRowNumber(secondMethod))); + + Assert.False(firstDebugInformation.SequencePointsBlob.IsNil); + Assert.True(secondDebugInformation.SequencePointsBlob.IsNil); + Assert.Contains( + "first.cs", + pdbReader.GetString(pdbReader.GetDocument(firstDebugInformation.Document).Name)); + } + + [Fact] + public void MalformedLanguageDirective_DoesNotPartiallyUpdateGuidState() + { + ImmutableArray documents = + [ + new SourceText($$""" + .assembly test { } + .language '{{CSharpLanguageGuid}}' + .language '{{DocumentTypeGuid}}', + """, "broken.il"), + new SourceText(""" + .class public auto ansi Test + { + .method public static void M() cil managed + { + .line 10 "document.cs" + nop + ret + } + } + """, "valid.il"), + ]; + + var compiler = new DocumentCompiler(); + (ImmutableArray diagnostics, CompilationResult? result) = compiler.Compile( + documents, + _ => throw new InvalidOperationException("Unexpected include"), + _ => throw new InvalidOperationException("Unexpected resource"), + new Options { ErrorTolerant = true, Pdb = true }); + + Assert.Contains(diagnostics, diagnostic => diagnostic.Severity == DiagnosticSeverity.Error); + Assert.NotNull(result); + + var image = new BlobBuilder(); + result!.Serialize(image); + using var pe = new PEReader(image.ToImmutableArray()); + DebugDirectoryEntry embeddedPdb = Assert.Single( + pe.ReadDebugDirectory(), + entry => entry.Type == DebugDirectoryEntryType.EmbeddedPortablePdb); + using MetadataReaderProvider pdbProvider = + pe.ReadEmbeddedPortablePdbDebugDirectoryData(embeddedPdb); + MetadataReader pdbReader = pdbProvider.GetMetadataReader(); + Document document = pdbReader.GetDocument(Assert.Single(pdbReader.Documents)); + + Assert.Equal(Guid.Parse(CSharpLanguageGuid), pdbReader.GetGuid(document.Language)); + } + } } From dd0f012e5ab2f371108eda0258c1ba2052369b04 Mon Sep 17 00:00:00 2001 From: Jeremy Koritzinsky Date: Thu, 13 Aug 2026 19:46:27 -0700 Subject: [PATCH 12/16] Compile assembly and manifest directives during parsing Synthesize assembly definitions and references, files, exported types, resources, vtable fixups, and typedefs. Remove the final parse-tree islands so BuildParseTree remains disabled for the complete parse. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: c986c103-8383-4db4-9b11-9be49dc68a05 --- src/tools/ilasm/README.md | 28 +- .../ILAssembler/Actions/CILParser.Actions.cs | 31 - .../Actions/GrammarActions.Conversions.cs | 19 - .../GrammarActions.Declarations.Actions.cs | 93 +- .../Actions/GrammarActions.Declarations.cs | 9 - .../Actions/GrammarActions.Literals.cs | 2 +- .../GrammarActions.Manifest.Assembly.cs | 242 + .../GrammarActions.Manifest.ExportedTypes.cs | 349 + .../Actions/GrammarActions.Manifest.Files.cs | 150 + .../GrammarActions.Manifest.References.cs | 110 + .../GrammarActions.Manifest.Resources.cs | 218 + .../GrammarActions.Manifest.Typedefs.cs | 127 + .../Actions/GrammarActions.Manifest.VTable.cs | 79 + .../Actions/GrammarActions.Manifest.Values.cs | 179 + .../Actions/GrammarActions.Manifest.cs | 668 +- .../Actions/GrammarActions.Security.cs | 6 +- .../src/ILAssembler/Actions/GrammarActions.cs | 13 +- src/tools/ilasm/src/ILAssembler/gen/CIL.g4 | 345 +- .../ilasm/src/ILAssembler/gen/CIL.interp | 5 +- .../src/ILAssembler/gen/CILBaseVisitor.cs | 30 + .../ilasm/src/ILAssembler/gen/CILParser.cs | 7942 +++++++++-------- .../ilasm/src/ILAssembler/gen/CILVisitor.cs | 18 + .../tests/ILAssembler.Tests/AssemblyTests.cs | 22 + .../tests/ILAssembler.Tests/TypedefTests.cs | 22 +- 24 files changed, 5970 insertions(+), 4737 deletions(-) create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Assembly.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.ExportedTypes.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Files.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.References.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Resources.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Typedefs.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.VTable.cs create mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Values.cs diff --git a/src/tools/ilasm/README.md b/src/tools/ilasm/README.md index 6fb69e052647cd..730a6312fd6f13 100644 --- a/src/tools/ilasm/README.md +++ b/src/tools/ilasm/README.md @@ -26,7 +26,15 @@ an accumulator instead of building a subtree at all. | `GrammarActions.Instructions.cs` | Tree-free value instruction and method-item actions. | | `GrammarActions.Instructions.References.cs` | Reference and signature instruction actions. | | `GrammarActions.Literals.cs` | Literals, names and strings. | -| `GrammarActions.Manifest.cs` | Assembly, module, resource, vtable and typedef directives. | +| `GrammarActions.Manifest.cs` | Module and image-header visitor guards. | +| `GrammarActions.Manifest.Assembly.cs` | Assembly definitions, identity, keys, security and attributes. | +| `GrammarActions.Manifest.ExportedTypes.cs` | Exported-type headers, implementations and attributes. | +| `GrammarActions.Manifest.Files.cs` | Assembly file declarations and entry points. | +| `GrammarActions.Manifest.References.cs` | Assembly references, identities, keys and hashes. | +| `GrammarActions.Manifest.Resources.cs` | Embedded and external manifest resources. | +| `GrammarActions.Manifest.Typedefs.cs` | Type, member and custom-attribute aliases. | +| `GrammarActions.Manifest.Values.cs` | Internal synthesized manifest value model and list frames. | +| `GrammarActions.Manifest.VTable.cs` | Vtable fixup declarations and flags. | | `GrammarActions.Marshalling.Actions.cs` | Synthesized native type and marshalling descriptor actions. | | `GrammarActions.Marshalling.cs` | Marshalling visitor wrappers and P/Invoke conversion. | | `GrammarActions.Members.cs` | Parser-driven class member visitor guards. | @@ -54,7 +62,7 @@ an accumulator instead of building a subtree at all. | `GrammarActions.Types.Headers.Values.cs` | Internal synthesized type-header value model. | | `GrammarActions.Types.References.cs` | Type-name synthesis and resolution. | -`CILParser.Actions.cs` holds the parse-tree mode helpers the grammar calls. +`CILParser.Actions.cs` holds the streaming parse-tree mode helper the grammar calls. ## Rules for grammar actions @@ -69,21 +77,19 @@ slots use `object` where an internal value or array crosses that boundary and `G provides the strongly typed accessors. All namespace, type-header, top-level, type, signature, reference, marshalling, class-member, -method-header, method-body directive, exception-handling, data, security, source and language -structure is action-driven. `scopeBlock` records offsets under its context key without inspecting -children. The remaining `BeginSubtree` islands are the manifest-family roots `assemblyBlock`, -`assemblyRefBlock`, `exptypeBlock`, `manifestResBlock`, `fileDecl`, `vtableDecl`, `vtfixupDecl` and -`typedefDecl`. +method-header, method-body directive, exception-handling, data, security, source, language, +assembly, manifest, vtable and typedef structure is action-driven. `scopeBlock` records offsets +under its context key without inspecting children. Normal parsing keeps `BuildParseTree` disabled; +there are no `BeginSubtree` islands. Semantic state that a rule pushes must be released from that rule's `finally` clause and be keyed on the owning context, because ANTLR skips `@after` actions and the remainder of an alternative once a rule reports a syntax error. Inline actions placed after a subrule reference are not a substitute: they run only when the alternative completes. -Only the parser actions walk the structural rules. The recursive `ICILVisitor` entry points for -`decl`, `decls`, `nameSpaceHead`, `classHead`, their synthesized dependency rules, `classDecls`, -`methodDecls`, `scopeBlock` and the SEH rules throw `UnreachableException` so that there is exactly -one live traversal algorithm. +Only parser actions walk structural rules. Their recursive `ICILVisitor` entry points either +materialize a synthesized value or throw `UnreachableException`, so there is exactly one live +algorithm and no child walker. ## Build diff --git a/src/tools/ilasm/src/ILAssembler/Actions/CILParser.Actions.cs b/src/tools/ilasm/src/ILAssembler/Actions/CILParser.Actions.cs index e0f12ccb9274a3..4e2dfefff77063 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/CILParser.Actions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/CILParser.Actions.cs @@ -3,25 +3,15 @@ using System.Collections.Generic; using System.Diagnostics; -using Antlr4.Runtime; namespace ILAssembler; public partial class CILParser { private readonly Stack _parseTreeModes = new(); - private bool _detachNextOuterAlternative; internal GrammarActions Actions { get; set; } = null!; - private void BeginSubtree() - { - bool previousMode = BuildParseTree; - _parseTreeModes.Push(previousMode); - BuildParseTree = true; - _detachNextOuterAlternative = !previousMode; - } - private void BeginStreaming() { _parseTreeModes.Push(BuildParseTree); @@ -31,29 +21,8 @@ private void BeginStreaming() private void EndParseTreeMode() { Debug.Assert(_parseTreeModes.Count > 0); - _detachNextOuterAlternative = false; BuildParseTree = _parseTreeModes.Pop(); } - public override void EnterOuterAlt(ParserRuleContext localContext, int alternativeNumber) - { - if (!_detachNextOuterAlternative) - { - base.EnterOuterAlt(localContext, alternativeNumber); - return; - } - - _detachNextOuterAlternative = false; - BuildParseTree = false; - try - { - base.EnterOuterAlt(localContext, alternativeNumber); - } - finally - { - BuildParseTree = true; - } - } - internal void VerifyParseTreeModesBalanced() => Debug.Assert(_parseTreeModes.Count == 0); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs index 5b9d4dbca985dc..fa8b2dfb7f6c66 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs @@ -94,9 +94,6 @@ internal sealed partial class GrammarActions : ICILVisitor private readonly Stack _semanticRootFrames = new(); private int _syntaxErrorCount; - // Typedef aliases - maps alias name to the resolved entity - private readonly Dictionary _typedefs = new(); - // Debug info tracking private Guid _currentLanguageGuid = Guid.Empty; private Guid _currentLanguageVendorGuid = Guid.Empty; @@ -105,26 +102,12 @@ internal sealed partial class GrammarActions : ICILVisitor private readonly Dictionary _documentHandles = new(); private readonly MetadataBuilder _pdbBuilder = new(); - // VTable fixup tracking - uses types from VTableFixupSupport - private readonly List _vtableFixups = new(); - internal GrammarActions(IReadOnlyDictionary documents, Options options, Func resourceLocator) { _documents = documents; _options = options; _resourceLocator = resourceLocator; } - /// - /// Represents a typedef alias entry. - /// - private abstract record TypedefEntry - { - public sealed record Type(EntityRegistry.TypeEntity Entity) : TypedefEntry; - public sealed record TypeBlob(BlobBuilder Blob) : TypedefEntry; - public sealed record Member(EntityRegistry.EntityBase Entity) : TypedefEntry; - public sealed record CustomAttribute(EntityRegistry.EntityBase Constructor, BlobBuilder Value) : TypedefEntry; - } - private void ReportDiagnostic(DiagnosticSeverity severity, string id, string message, Antlr4.Runtime.ParserRuleContext context) { var location = Location.From(context.Start, _documents); @@ -188,8 +171,6 @@ or DiagnosticIds.UnknownGenericParameter public GrammarResult Visit(IParseTree tree) => tree.Accept(this); - private EntityRegistry.AssemblyOrRefEntity? _currentAssemblyOrRef; - public GrammarResult VisitChildren(IRuleNode node) { for (int i = 0; i < node.ChildCount; i++) diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.Actions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.Actions.cs index 5df26ad62a55d5..7379381cfcd98d 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.Actions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.Actions.cs @@ -1,8 +1,6 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System.Collections.Immutable; -using System.Reflection; using System.Reflection.PortableExecutable; using Antlr4.Runtime; @@ -53,104 +51,25 @@ internal void ProcessTopLevelAssembly(CILParser.AssemblyBlockContext context) internal void ProcessTopLevelAssemblyReference(CILParser.AssemblyRefBlockContext context) { - if (context.HasSyntaxError) - { - return; - } - - _currentAssemblyOrRef = VisitAssemblyRefHead(context.assemblyRefHead()).Value; - try - { - foreach (CILParser.AssemblyRefDeclContext declaration in - context.assemblyRefDecls().assemblyRefDecl()) - { - _ = VisitAssemblyRefDecl(declaration); - } - } - finally + if (!context.HasSyntaxError) { - _currentAssemblyOrRef = null; + _ = VisitAssemblyRefBlock(context); } } internal void ProcessTopLevelExportedType(CILParser.ExptypeBlockContext context) { - if (context.HasSyntaxError) - { - return; - } - - (System.Reflection.TypeAttributes attributes, string dottedName) = - VisitExptypeHead(context.exptypeHead()).Value; - (string typeNamespace, string name) = - NameHelpers.SplitDottedNameToNamespaceAndName(dottedName); - (EntityRegistry.EntityBase? implementation, int typeDefinitionId, - ImmutableArray customAttributes) = - VisitExptypeDecls(context.exptypeDecls()).Value; - if (implementation is null) - { - ReportWarning( - DiagnosticIds.MissingExportedTypeImplementation, - string.Format( - DiagnosticMessageTemplates.MissingExportedTypeImplementation, - dottedName), - context.exptypeHead()); - return; - } - - EntityRegistry.ExportedTypeEntity exportedType = - _entityRegistry.GetOrCreateExportedType( - implementation, - typeNamespace, - name, - entity => - { - entity.Attributes = attributes; - entity.TypeDefinitionId = typeDefinitionId; - }); - foreach (EntityRegistry.CustomAttributeEntity attribute in customAttributes) + if (!context.HasSyntaxError) { - attribute.Owner = exportedType; + _ = VisitExptypeBlock(context); } } internal void ProcessTopLevelManifestResource(CILParser.ManifestResBlockContext context) { - if (context.HasSyntaxError) - { - return; - } - - (string name, string alias, ManifestResourceAttributes attributes) = - VisitManifestResHead(context.manifestResHead()).Value; - (EntityRegistry.EntityBase? implementation, uint offset, - ImmutableArray customAttributes) = - VisitManifestResDecls(context.manifestResDecls()).Value; - if (implementation is null) - { - offset = (uint)_manifestResources.Count; - byte[] resourceData = _resourceLocator(alias); - if (resourceData is null) - { - ReportError( - DiagnosticIds.FileNotFound, - string.Format(DiagnosticMessageTemplates.FileNotFound, alias), - context); - } - else - { - _manifestResources.WriteInt32(resourceData.Length); - _manifestResources.WriteBytes(resourceData); - } - } - - EntityRegistry.ManifestResourceEntity resource = - _entityRegistry.CreateManifestResource(name, offset); - resource.Attributes = attributes; - resource.Implementation = implementation; - foreach (EntityRegistry.CustomAttributeEntity attribute in customAttributes) + if (!context.HasSyntaxError) { - attribute.Owner = resource; + _ = VisitManifestResBlock(context); } } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.cs index 80b93c4ac99f00..6be424e348fecf 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.cs @@ -14,14 +14,5 @@ public GrammarResult VisitDecl(CILParser.DeclContext context) public GrammarResult VisitDecls(CILParser.DeclsContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - public GrammarResult VisitAssemblyRefBlock(CILParser.AssemblyRefBlockContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitExptypeBlock(CILParser.ExptypeBlockContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitManifestResBlock(CILParser.ManifestResBlockContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - #pragma warning restore CA1822 } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs index 7bd640eeaafa50..41888e754b378e 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs @@ -302,7 +302,7 @@ private void ReportLiteralOutOfRange(IToken token) } GrammarResult ICILVisitor.VisitIntOrWildcard(CILParser.IntOrWildcardContext context) => VisitIntOrWildcard(context); - public GrammarResult.Literal VisitIntOrWildcard(CILParser.IntOrWildcardContext context) => context.int32() is {} int32 ? new(VisitInt32(int32).Value) : new(null); + public static GrammarResult.Literal VisitIntOrWildcard(CILParser.IntOrWildcardContext context) => new(context.Value); GrammarResult ICILVisitor.VisitSlashedName(CILParser.SlashedNameContext context) { diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Assembly.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Assembly.cs new file mode 100644 index 00000000000000..24ea2d9c343fe4 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Assembly.cs @@ -0,0 +1,242 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Reflection.Metadata; +using System.Text; +using Antlr4.Runtime; + +namespace ILAssembler; + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. +internal sealed partial class GrammarActions +{ + private readonly Stack> + _assemblyDeclarationFrames = new(); + + internal void SetAssemblyAttribute(CILParser.AsmAttrAnyContext context) + { + (AssemblyFlags value, AssemblyFlags mask) = context.Start.Text switch + { + "retargetable" => (AssemblyFlags.Retargetable, (AssemblyFlags)0), + "windowsruntime" => (AssemblyFlags.WindowsRuntime, (AssemblyFlags)0), + "noplatform" => (AssemblyFlags.NoPlatform, (AssemblyFlags)0), + "legacy library" => ((AssemblyFlags)0, (AssemblyFlags)0), + "cil" => (GetFlagForArch(ProcessorArchitecture.MSIL), AssemblyFlags.ArchitectureMask), + "x86" => (GetFlagForArch(ProcessorArchitecture.X86), AssemblyFlags.ArchitectureMask), + "amd64" => (GetFlagForArch(ProcessorArchitecture.Amd64), AssemblyFlags.ArchitectureMask), + "arm" => (GetFlagForArch(ProcessorArchitecture.Arm), AssemblyFlags.ArchitectureMask), + "arm64" => (GetFlagForArch((ProcessorArchitecture)6), AssemblyFlags.ArchitectureMask), + _ => throw new UnreachableException() + }; + context.Value = value; + context.Mask = mask; + } + + internal AssemblyFlags AddAssemblyAttribute( + AssemblyFlags attributes, + AssemblyFlags value, + AssemblyFlags mask) + => mask == 0 ? attributes | value : (attributes & ~mask) | value; + + internal void BeginAssemblyDeclarations(CILParser.AssemblyDeclsContext context) + => _assemblyDeclarationFrames.Push(new(context)); + + internal void AddAssemblyDeclaration( + CILParser.AssemblyDeclsContext context, + object? value) + => AddManifestValue(_assemblyDeclarationFrames, context, value); + + internal object EndAssemblyDeclarations(CILParser.AssemblyDeclsContext context) + => EndManifestValues(_assemblyDeclarationFrames, context); + + internal object CreateAssemblyDefinition( + AssemblyFlags attributes, + string name, + object? declarations) + => new AssemblyDefinitionValue(attributes, name, GetManifestValues(declarations)); + + internal object CreateAssemblyHashAlgorithmDeclaration(IToken value) + => new AssemblyHashAlgorithmDirectiveValue((AssemblyHashAlgorithm)ParseInt32(value)); + + internal object CreateAssemblySecurityDeclaration(object? value, IToken location) + => new AssemblySecurityDirectiveValue(value, location); + + internal object CreateAssemblyPublicKeyDeclaration(ImmutableArray value) + => new AssemblyPublicKeyDirectiveValue(value); + + internal object CreateAssemblyVersionDeclaration( + int? major, + int? minor, + int? build, + int? revision) + => new AssemblyVersionDirectiveValue(new( + major ?? 0, + minor ?? 0, + build ?? 0, + revision ?? 0)); + + internal object CreateAssemblyLocaleDeclaration(string value) + => new AssemblyLocaleDirectiveValue(value); + + internal object CreateAssemblyLocaleDeclaration(ImmutableArray value) + => new AssemblyLocaleDirectiveValue(Encoding.Unicode.GetString(value.AsSpan())); + + internal object CreateAssemblyCustomAttributeDeclaration(object? value, IToken location) + => new AssemblyCustomAttributeDirectiveValue(value, location); + + private static AssemblyFlags GetFlagForArch(ProcessorArchitecture architecture) + => (AssemblyFlags)((int)architecture << 4); + + private static (ProcessorArchitecture Architecture, AssemblyFlags Flags) GetArchAndFlags( + AssemblyFlags flags) + { + ProcessorArchitecture architecture = + (ProcessorArchitecture)(((int)flags & 0xF0) >> 4); + return (architecture, flags & ~GetFlagForArch(architecture)); + } + + private void MaterializeAssemblyDefinition(AssemblyDefinitionValue definition) + { + string assemblyName = _options.AssemblyName ?? definition.Name; + _entityRegistry.Assembly ??= new EntityRegistry.AssemblyEntity(assemblyName); + EntityRegistry.AssemblyEntity assembly = _entityRegistry.Assembly; + (assembly.ProcessorArchitecture, assembly.Flags) = + GetArchAndFlags(definition.Attributes); + + foreach (object declaration in definition.Declarations) + { + switch (declaration) + { + case AssemblyHashAlgorithmDirectiveValue hashAlgorithm: + assembly.HashAlgorithm = hashAlgorithm.Value; + break; + case AssemblySecurityDirectiveValue security: + if (security.Value is SecurityDeclarationValue securityValue && + MaterializeSecurityDeclaration(securityValue, security.Location) is { } entity) + { + entity.Parent = assembly; + } + break; + default: + ApplyAssemblyOrReferenceDirective(assembly, declaration); + break; + } + } + + if (_options.KeyFile is not null) + { + ApplyKeyFile(_options.KeyFile); + } + } + + private void ApplyAssemblyOrReferenceDirective( + EntityRegistry.AssemblyOrRefEntity target, + object declaration) + { + switch (declaration) + { + case AssemblyPublicKeyDirectiveValue publicKey: + // COMPAT: A reference's public key token wins regardless of declaration order. + if (target is not EntityRegistry.AssemblyReferenceEntity assemblyReference || + assemblyReference.PublicKeyOrToken is null || + assemblyReference.Flags.HasFlag(AssemblyFlags.PublicKey)) + { + target.PublicKeyOrToken = CreateManifestBlob(publicKey.Value); + target.Flags |= AssemblyFlags.PublicKey; + } + break; + case AssemblyVersionDirectiveValue version: + target.Version = version.Value; + break; + case AssemblyLocaleDirectiveValue locale: + target.Culture = locale.Value; + break; + case AssemblyCustomAttributeDirectiveValue customAttribute: + MaterializeCustomAttributeDeclaration( + customAttribute.Value, + customAttribute.Location)?.Owner = target; + break; + } + } + + private static BlobBuilder CreateManifestBlob(ImmutableArray value) + { + BlobBuilder blob = new(value.Length); + blob.WriteBytes(value); + return blob; + } + + private void ApplyKeyFile(string keyFilePath) + { + if (_entityRegistry.Assembly is null) + { + return; + } + + try + { + byte[] keyBytes = File.ReadAllBytes(keyFilePath); + BlobBuilder blob = new(keyBytes.Length); + blob.WriteBytes(keyBytes); + _entityRegistry.Assembly.PublicKeyOrToken = blob; + _entityRegistry.Assembly.Flags |= AssemblyFlags.PublicKey; + } + catch (Exception ex) + { + SourceText? firstDocument = _documents.Values.FirstOrDefault(); + Location location = firstDocument is not null + ? new Location(new SourceSpan(0, 0), firstDocument) + : new Location(new SourceSpan(0, 0), new SourceText(string.Empty, keyFilePath)); + _diagnostics.Add(new Diagnostic( + DiagnosticIds.KeyFileError, + DiagnosticSeverity.Error, + $"Failed to read key file '{keyFilePath}': {ex.Message}", + location)); + } + } + + GrammarResult ICILVisitor.VisitAsmAttr(CILParser.AsmAttrContext context) + => VisitAsmAttr(context); + + public static GrammarResult.Literal VisitAsmAttr( + CILParser.AsmAttrContext context) + => new(context.Value); + + GrammarResult ICILVisitor.VisitAsmAttrAny( + CILParser.AsmAttrAnyContext context) + => VisitAsmAttrAny(context); + + public static GrammarResult.Flag VisitAsmAttrAny( + CILParser.AsmAttrAnyContext context) + => new(context.Value, context.Mask); + + public GrammarResult VisitAsmOrRefDecl(CILParser.AsmOrRefDeclContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitAssemblyBlock( + CILParser.AssemblyBlockContext context) + => VisitAssemblyBlock(context); + + public GrammarResult VisitAssemblyBlock(CILParser.AssemblyBlockContext context) + { + if (context.Value is AssemblyDefinitionValue definition) + { + MaterializeAssemblyDefinition(definition); + } + + return GrammarResult.SentinelValue.Result; + } + + public GrammarResult VisitAssemblyDecl(CILParser.AssemblyDeclContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + public GrammarResult VisitAssemblyDecls(CILParser.AssemblyDeclsContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.ExportedTypes.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.ExportedTypes.cs new file mode 100644 index 00000000000000..a68c3f5eca5e60 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.ExportedTypes.cs @@ -0,0 +1,349 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Reflection; +using Antlr4.Runtime; + +namespace ILAssembler; + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. +internal sealed partial class GrammarActions +{ + private readonly Stack> + _exportedTypeDeclarationFrames = new(); + + internal void SetExportedTypeAttribute(CILParser.ExptAttrContext context) + { + string attribute = context.Start.Text == "nested" + ? $"nested{context.Stop?.Text}" + : context.Start.Text; + (TypeAttributes value, TypeAttributes mask) = attribute switch + { + "private" => (TypeAttributes.NotPublic, TypeAttributes.VisibilityMask), + "public" => (TypeAttributes.Public, TypeAttributes.VisibilityMask), + "forwarder" => (TypeAttributes.Forwarder, (TypeAttributes)0), + "nestedpublic" => (TypeAttributes.NestedPublic, TypeAttributes.VisibilityMask), + "nestedprivate" => (TypeAttributes.NestedPrivate, TypeAttributes.VisibilityMask), + "nestedfamily" => (TypeAttributes.NestedFamily, TypeAttributes.VisibilityMask), + "nestedassembly" => (TypeAttributes.NestedAssembly, TypeAttributes.VisibilityMask), + "nestedfamandassem" => (TypeAttributes.NestedFamANDAssem, TypeAttributes.VisibilityMask), + "nestedfamorassem" => (TypeAttributes.NestedFamORAssem, TypeAttributes.VisibilityMask), + _ => throw new UnreachableException() + }; + context.Value = value; + context.Mask = mask; + } + + internal TypeAttributes AddExportedTypeAttribute( + TypeAttributes attributes, + TypeAttributes value, + TypeAttributes mask) + => mask == 0 ? attributes | value : (attributes & ~mask) | value; + + internal object CreateExportedTypeHeader( + TypeAttributes attributes, + string name, + IToken location) + => new ExportedTypeHeaderValue(attributes, name, location); + + internal void BeginExportedTypeDeclarations(CILParser.ExptypeDeclsContext context) + => _exportedTypeDeclarationFrames.Push(new(context)); + + internal void AddExportedTypeDeclaration( + CILParser.ExptypeDeclsContext context, + object? value) + => AddManifestValue(_exportedTypeDeclarationFrames, context, value); + + internal object EndExportedTypeDeclarations(CILParser.ExptypeDeclsContext context) + => EndManifestValues(_exportedTypeDeclarationFrames, context); + + internal object CreateExportedType( + object? header, + object? declarations, + IToken location) + => new ExportedTypeValue( + GetExportedTypeHeader(header, location), + GetManifestValues(declarations)); + + internal object CreateExportedTypeFileDeclaration(string name, IToken location) + => new ExportedTypeFileDirectiveValue(name, location); + + internal object CreateNestedExportedTypeDeclaration(object? name, IToken location) + => new NestedExportedTypeDirectiveValue(GetTypeNameValue(name), location); + + internal object CreateExportedTypeAssemblyDeclaration(string name, IToken location) + => new ExportedTypeAssemblyDirectiveValue(name, location); + + internal object CreateExportedTypeMetadataTokenDeclaration(int token, IToken location) + => new ExportedTypeMetadataTokenDirectiveValue(token, location); + + internal object CreateExportedTypeDefinitionIdDeclaration(IToken value) + => new ExportedTypeDefinitionIdDirectiveValue(ParseInt32(value)); + + internal object CreateExportedTypeCustomAttributeDeclaration(object? value, IToken location) + => new ExportedTypeCustomAttributeDirectiveValue(value, location); + + private static ExportedTypeHeaderValue GetExportedTypeHeader( + object? value, + IToken location) + => value as ExportedTypeHeaderValue ?? new(0, string.Empty, location); + + private void MaterializeExportedType(ExportedTypeValue value) + { + ExportedTypeHeaderValue header = value.Header; + (string typeNamespace, string name) = + NameHelpers.SplitDottedNameToNamespaceAndName(header.Name); + ( + EntityRegistry.EntityBase? implementation, + int typeDefinitionId, + ImmutableArray customAttributes + ) = MaterializeExportedTypeDeclarations(value.Declarations); + + if (implementation is null) + { + ReportWarning( + DiagnosticIds.MissingExportedTypeImplementation, + string.Format( + DiagnosticMessageTemplates.MissingExportedTypeImplementation, + header.Name), + header.Location); + return; + } + + EntityRegistry.ExportedTypeEntity exportedType = + _entityRegistry.GetOrCreateExportedType( + implementation, + typeNamespace, + name, + entity => + { + entity.Attributes = header.Attributes; + entity.TypeDefinitionId = typeDefinitionId; + }); + foreach (EntityRegistry.CustomAttributeEntity attribute in customAttributes) + { + attribute.Owner = exportedType; + } + } + + private ( + EntityRegistry.EntityBase? Implementation, + int TypeDefinitionId, + ImmutableArray CustomAttributes + ) MaterializeExportedTypeDeclarations(ImmutableArray declarations) + { + EntityRegistry.EntityBase? implementation = null; + int typeDefinitionId = 0; + ImmutableArray.Builder customAttributes = + ImmutableArray.CreateBuilder(); + + foreach (object declaration in declarations) + { + switch (declaration) + { + case ExportedTypeCustomAttributeDirectiveValue customAttribute: + if (MaterializeCustomAttributeDeclaration( + customAttribute.Value, + customAttribute.Location) is { } attribute) + { + customAttributes.Add(attribute); + } + break; + case ExportedTypeMetadataTokenDirectiveValue metadataToken: + EntityRegistry.EntityBase entity = ResolveMetadataToken(metadataToken.Token); + if (entity is EntityRegistry.FakeTypeEntity) + { + ReportError( + DiagnosticIds.InvalidMetadataToken, + DiagnosticMessageTemplates.InvalidMetadataToken, + metadataToken.Location); + } + implementation = ResolveBetterExportedTypeImplementation( + implementation, + entity); + break; + case ExportedTypeFileDirectiveValue file: + implementation = _entityRegistry.FindFile(file.Name); + if (implementation is null) + { + ReportError( + DiagnosticIds.FileNotFound, + string.Format(DiagnosticMessageTemplates.FileNotFound, file.Name), + file.Location); + } + break; + case ExportedTypeAssemblyDirectiveValue assembly: + implementation = _entityRegistry.FindAssemblyReference(assembly.Name); + if (implementation is null) + { + ReportError( + DiagnosticIds.AssemblyNotFound, + string.Format( + DiagnosticMessageTemplates.AssemblyNotFound, + assembly.Name), + assembly.Location); + } + break; + case NestedExportedTypeDirectiveValue nested: + EntityRegistry.ExportedTypeEntity? containingType = + ResolveExportedType(nested.Name, nested.Location); + if (containingType is null) + { + ReportError( + DiagnosticIds.ExportedTypeNotFound, + string.Format( + DiagnosticMessageTemplates.ExportedTypeNotFound, + GetExportedTypeDisplayName(nested.Name)), + nested.Location); + } + else + { + implementation = ResolveBetterExportedTypeImplementation( + implementation, + containingType); + } + break; + case ExportedTypeDefinitionIdDirectiveValue definitionId: + typeDefinitionId = definitionId.Value; + break; + } + } + + return (implementation, typeDefinitionId, customAttributes.ToImmutable()); + } + + private static EntityRegistry.EntityBase? ResolveBetterExportedTypeImplementation( + EntityRegistry.EntityBase? current, + EntityRegistry.EntityBase? candidate) + { + if (candidate is null) + { + return current; + } + + if (current is null) + { + return candidate; + } + + return GetImplementationPriority(candidate) >= GetImplementationPriority(current) + ? candidate + : current; + + static int GetImplementationPriority(EntityRegistry.EntityBase entity) + => entity switch + { + EntityRegistry.FileEntity => 4, + EntityRegistry.AssemblyReferenceEntity => 3, + EntityRegistry.ExportedTypeEntity => 2, + _ => 1 + }; + } + + private EntityRegistry.ExportedTypeEntity? ResolveExportedType( + TypeName typeName, + IToken location) + { + Stack containingTypes = new(); + for (TypeName? containingType = typeName; + containingType is not null; + containingType = containingType.ContainingTypeName) + { + containingTypes.Push(containingType); + } + + EntityRegistry.ExportedTypeEntity? exportedType = null; + while (containingTypes.Count != 0) + { + TypeName containingType = containingTypes.Pop(); + (string typeNamespace, string name) = + NameHelpers.SplitDottedNameToNamespaceAndName(containingType.DottedName); + exportedType = _entityRegistry.FindExportedType( + exportedType, + typeNamespace, + name); + if (exportedType is null) + { + ReportError( + DiagnosticIds.ExportedTypeNotFound, + string.Format( + DiagnosticMessageTemplates.ExportedTypeNotFound, + containingType.DottedName), + location); + return null; + } + } + + return exportedType; + } + + private static string GetExportedTypeDisplayName(TypeName typeName) + { + Stack names = new(); + for (TypeName? current = typeName; + current is not null; + current = current.ContainingTypeName) + { + names.Push(current.DottedName); + } + + return string.Join("/", names); + } + + public GrammarResult VisitExportHead(CILParser.ExportHeadContext context) + => throw new NotImplementedException("Obsolete syntax"); + + GrammarResult ICILVisitor.VisitExptAttr(CILParser.ExptAttrContext context) + => VisitExptAttr(context); + + public static GrammarResult.Flag VisitExptAttr( + CILParser.ExptAttrContext context) + => new(context.Value, context.Mask); + + GrammarResult ICILVisitor.VisitExptAttrs(CILParser.ExptAttrsContext context) + => VisitExptAttrs(context); + + public static GrammarResult.Literal VisitExptAttrs( + CILParser.ExptAttrsContext context) + => new(context.Value); + + public GrammarResult VisitExptypeBlock(CILParser.ExptypeBlockContext context) + { + if (context.Value is ExportedTypeValue value) + { + MaterializeExportedType(value); + } + + return GrammarResult.SentinelValue.Result; + } + + public GrammarResult VisitExptypeDecl(CILParser.ExptypeDeclContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitExptypeDecls( + CILParser.ExptypeDeclsContext context) + => VisitExptypeDecls(context); + + public GrammarResult.Literal<( + EntityRegistry.EntityBase? implementation, + int typedefId, + ImmutableArray attrs)> VisitExptypeDecls( + CILParser.ExptypeDeclsContext context) + => new(MaterializeExportedTypeDeclarations(GetManifestValues(context.Value))); + + GrammarResult ICILVisitor.VisitExptypeHead( + CILParser.ExptypeHeadContext context) + => VisitExptypeHead(context); + + public static GrammarResult.Literal<(TypeAttributes attrs, string dottedName)> + VisitExptypeHead(CILParser.ExptypeHeadContext context) + { + ExportedTypeHeaderValue header = + GetExportedTypeHeader(context.Value, context.Start); + return new((header.Attributes, header.Name)); + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Files.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Files.cs new file mode 100644 index 00000000000000..8a40ed738791fa --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Files.cs @@ -0,0 +1,150 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Reflection.Metadata; +using Antlr4.Runtime; + +namespace ILAssembler; + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. +internal sealed partial class GrammarActions +{ + private readonly Stack _fileDeclarationFrames = new(); + + private sealed class FileDeclarationFrame + { + public FileDeclarationFrame(CILParser.FileDeclContext owner) + { + Owner = owner; + } + + public CILParser.FileDeclContext Owner { get; } + + public string Name { get; set; } = string.Empty; + + public bool HasMetadata { get; set; } = true; + + public bool IsEntryPoint { get; set; } + + public ImmutableArray? Hash { get; set; } + } + + internal void BeginFileDeclaration(CILParser.FileDeclContext context) + { + BeginSemanticRoot(context); + _fileDeclarationFrames.Push(new(context)); + } + + internal bool ParseFileAttribute(IToken token) + { + Debug.Assert(token.Text == "nometadata"); + return false; + } + + internal bool ParseFileEntry(IToken token) + { + Debug.Assert(token.Text == ".entrypoint"); + return true; + } + + internal void AddFileAttribute(CILParser.FileDeclContext context, bool hasMetadata) + { + if (TryGetFileDeclarationFrame(context) is { } frame) + { + frame.HasMetadata &= hasMetadata; + } + } + + internal void SetFileName(CILParser.FileDeclContext context, string name) + { + if (TryGetFileDeclarationFrame(context) is { } frame) + { + frame.Name = name; + } + } + + internal void AddFileEntry(CILParser.FileDeclContext context, bool isEntryPoint) + { + if (TryGetFileDeclarationFrame(context) is { } frame) + { + frame.IsEntryPoint |= isEntryPoint; + } + } + + internal void SetFileHash(CILParser.FileDeclContext context, ImmutableArray hash) + { + if (TryGetFileDeclarationFrame(context) is { } frame) + { + frame.Hash = hash; + } + } + + internal void EndFileDeclaration(CILParser.FileDeclContext context) + { + context.HasSyntaxError = EndSemanticRoot(context); + FileDeclarationFrame? frame = TryGetFileDeclarationFrame(context); + if (frame is null) + { + context.Value = null; + return; + } + + _fileDeclarationFrames.Pop(); + context.Value = context.HasSyntaxError + ? null + : new FileDeclarationValue( + frame.Name, + frame.HasMetadata, + frame.IsEntryPoint, + frame.Hash); + } + + private FileDeclarationFrame? TryGetFileDeclarationFrame(CILParser.FileDeclContext context) + { + Debug.Assert(_fileDeclarationFrames.Count > 0); + FileDeclarationFrame? frame = + _fileDeclarationFrames.Count == 0 ? null : _fileDeclarationFrames.Peek(); + Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); + return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; + } + + private EntityRegistry.FileEntity MaterializeFileDeclaration(FileDeclarationValue declaration) + { + BlobBuilder? hash = declaration.Hash is { } value ? CreateManifestBlob(value) : null; + EntityRegistry.FileEntity entity = + _entityRegistry.GetOrCreateFile(declaration.Name, declaration.HasMetadata, hash); + if (declaration.IsEntryPoint) + { + _entityRegistry.EntryPoint = entity; + } + + return entity; + } + + GrammarResult ICILVisitor.VisitFileAttr(CILParser.FileAttrContext context) + => VisitFileAttr(context); + + public static GrammarResult.Literal VisitFileAttr(CILParser.FileAttrContext context) + => new(context.Value); + + GrammarResult ICILVisitor.VisitFileDecl(CILParser.FileDeclContext context) + => VisitFileDecl(context); + + public GrammarResult.Literal VisitFileDecl( + CILParser.FileDeclContext context) + { + Debug.Assert(context.Value is FileDeclarationValue); + FileDeclarationValue declaration = context.Value as FileDeclarationValue + ?? new(string.Empty, HasMetadata: true, IsEntryPoint: false, Hash: null); + return new(MaterializeFileDeclaration(declaration)); + } + + GrammarResult ICILVisitor.VisitFileEntry(CILParser.FileEntryContext context) + => VisitFileEntry(context); + + public static GrammarResult.Literal VisitFileEntry(CILParser.FileEntryContext context) + => new(context.Value); +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.References.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.References.cs new file mode 100644 index 00000000000000..8601111f5bb8ab --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.References.cs @@ -0,0 +1,110 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Reflection; + +namespace ILAssembler; + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. +internal sealed partial class GrammarActions +{ + private readonly Stack> + _assemblyReferenceDeclarationFrames = new(); + + internal object CreateAssemblyReferenceHeader( + AssemblyFlags attributes, + string name, + string alias) + => new AssemblyReferenceHeaderValue(attributes, name, alias); + + internal void BeginAssemblyReferenceDeclarations(CILParser.AssemblyRefDeclsContext context) + => _assemblyReferenceDeclarationFrames.Push(new(context)); + + internal void AddAssemblyReferenceDeclaration( + CILParser.AssemblyRefDeclsContext context, + object? value) + => AddManifestValue(_assemblyReferenceDeclarationFrames, context, value); + + internal object EndAssemblyReferenceDeclarations(CILParser.AssemblyRefDeclsContext context) + => EndManifestValues(_assemblyReferenceDeclarationFrames, context); + + internal object CreateAssemblyReference(object? header, object? declarations) + => new AssemblyReferenceValue( + GetAssemblyReferenceHeader(header), + GetManifestValues(declarations)); + + internal object CreateAssemblyReferenceHashDeclaration(ImmutableArray value) + => new AssemblyReferenceHashDirectiveValue(value); + + internal object CreateAssemblyReferencePublicKeyTokenDeclaration(ImmutableArray value) + => new AssemblyReferencePublicKeyTokenDirectiveValue(value); + + internal object? CreateAssemblyReferenceAutoDeclaration() => null; + + private EntityRegistry.AssemblyReferenceEntity MaterializeAssemblyReferenceHeader( + AssemblyReferenceHeaderValue header) + { + (ProcessorArchitecture architecture, AssemblyFlags flags) = + GetArchAndFlags(header.Attributes); + return _entityRegistry.GetOrCreateAssemblyReference( + header.Alias, + assemblyReference => + { + assemblyReference.Name = header.Name; + assemblyReference.Flags = flags; + assemblyReference.ProcessorArchitecture = architecture; + }); + } + + private void MaterializeAssemblyReference(AssemblyReferenceValue reference) + { + EntityRegistry.AssemblyReferenceEntity entity = + MaterializeAssemblyReferenceHeader(reference.Header); + foreach (object declaration in reference.Declarations) + { + switch (declaration) + { + case AssemblyReferenceHashDirectiveValue hash: + entity.Hash = CreateManifestBlob(hash.Value); + break; + case AssemblyReferencePublicKeyTokenDirectiveValue publicKeyToken: + entity.PublicKeyOrToken = CreateManifestBlob(publicKeyToken.Value); + entity.Flags &= ~AssemblyFlags.PublicKey; + break; + default: + ApplyAssemblyOrReferenceDirective(entity, declaration); + break; + } + } + } + + private static AssemblyReferenceHeaderValue GetAssemblyReferenceHeader(object? value) + => value as AssemblyReferenceHeaderValue ?? new(0, string.Empty, string.Empty); + + public GrammarResult VisitAssemblyRefBlock(CILParser.AssemblyRefBlockContext context) + { + if (context.Value is AssemblyReferenceValue reference) + { + MaterializeAssemblyReference(reference); + } + + return GrammarResult.SentinelValue.Result; + } + + public GrammarResult VisitAssemblyRefDecl(CILParser.AssemblyRefDeclContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + public GrammarResult VisitAssemblyRefDecls(CILParser.AssemblyRefDeclsContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitAssemblyRefHead( + CILParser.AssemblyRefHeadContext context) + => VisitAssemblyRefHead(context); + + public GrammarResult.Literal VisitAssemblyRefHead( + CILParser.AssemblyRefHeadContext context) + => new(MaterializeAssemblyReferenceHeader(GetAssemblyReferenceHeader(context.Value))); +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Resources.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Resources.cs new file mode 100644 index 00000000000000..937ebd8db72ca7 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Resources.cs @@ -0,0 +1,218 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Reflection; +using Antlr4.Runtime; + +namespace ILAssembler; + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. +internal sealed partial class GrammarActions +{ + private readonly Stack> + _manifestResourceDeclarationFrames = new(); + + internal ManifestResourceAttributes AddManifestResourceAttribute( + ManifestResourceAttributes attributes, + ManifestResourceAttributes value) + => attributes | value; + + internal ManifestResourceAttributes ParseManifestResourceAttribute(IToken token) + => token.Text switch + { + "public" => ManifestResourceAttributes.Public, + "private" => ManifestResourceAttributes.Private, + _ => throw new UnreachableException() + }; + + internal object CreateManifestResourceHeader( + ManifestResourceAttributes attributes, + string name, + string alias, + IToken location) + => new ManifestResourceHeaderValue(attributes, name, alias, location); + + internal void BeginManifestResourceDeclarations(CILParser.ManifestResDeclsContext context) + => _manifestResourceDeclarationFrames.Push(new(context)); + + internal void AddManifestResourceDeclaration( + CILParser.ManifestResDeclsContext context, + object? value) + => AddManifestValue(_manifestResourceDeclarationFrames, context, value); + + internal object EndManifestResourceDeclarations(CILParser.ManifestResDeclsContext context) + => EndManifestValues(_manifestResourceDeclarationFrames, context); + + internal object CreateManifestResource( + object? header, + object? declarations, + IToken location) + => new ManifestResourceValue( + GetManifestResourceHeader(header, location), + GetManifestValues(declarations)); + + internal object CreateManifestResourceFileDeclaration( + string name, + IToken offset, + IToken location) + => new ManifestResourceFileDirectiveValue(name, (uint)ParseInt32(offset), location); + + internal object CreateManifestResourceAssemblyDeclaration(string name) + => new ManifestResourceAssemblyDirectiveValue(name); + + internal object CreateManifestResourceCustomAttributeDeclaration( + object? value, + IToken location) + => new ManifestResourceCustomAttributeDirectiveValue(value, location); + + private static ManifestResourceHeaderValue GetManifestResourceHeader( + object? value, + IToken location) + => value as ManifestResourceHeaderValue + ?? new(0, string.Empty, string.Empty, location); + + private void MaterializeManifestResource(ManifestResourceValue value) + { + ( + EntityRegistry.EntityBase? implementation, + uint offset, + ImmutableArray customAttributes + ) = MaterializeManifestResourceDeclarations(value.Declarations); + + if (implementation is null) + { + offset = (uint)_manifestResources.Count; + byte[] resourceData = _resourceLocator(value.Header.Alias); + if (resourceData is null) + { + ReportError( + DiagnosticIds.FileNotFound, + string.Format( + DiagnosticMessageTemplates.FileNotFound, + value.Header.Alias), + value.Header.Location); + } + else + { + _manifestResources.WriteInt32(resourceData.Length); + _manifestResources.WriteBytes(resourceData); + } + } + + EntityRegistry.ManifestResourceEntity resource = + _entityRegistry.CreateManifestResource(value.Header.Name, offset); + resource.Attributes = value.Header.Attributes; + resource.Implementation = implementation; + foreach (EntityRegistry.CustomAttributeEntity customAttribute in customAttributes) + { + customAttribute.Owner = resource; + } + } + + private ( + EntityRegistry.EntityBase? Implementation, + uint Offset, + ImmutableArray CustomAttributes + ) MaterializeManifestResourceDeclarations(ImmutableArray declarations) + { + EntityRegistry.EntityBase? implementation = null; + uint offset = 0; + ImmutableArray.Builder customAttributes = + ImmutableArray.CreateBuilder(); + + foreach (object declaration in declarations) + { + switch (declaration) + { + case ManifestResourceCustomAttributeDirectiveValue customAttribute: + if (MaterializeCustomAttributeDeclaration( + customAttribute.Value, + customAttribute.Location) is { } attribute) + { + customAttributes.Add(attribute); + } + break; + case ManifestResourceFileDirectiveValue file + when implementation is not EntityRegistry.AssemblyReferenceEntity: + EntityRegistry.FileEntity? fileEntity = _entityRegistry.FindFile(file.Name); + if (fileEntity is null) + { + ReportError( + DiagnosticIds.FileNotFound, + string.Format(DiagnosticMessageTemplates.FileNotFound, file.Name), + file.Location); + } + else + { + implementation = fileEntity; + offset = file.Offset; + } + break; + case ManifestResourceAssemblyDirectiveValue assembly: + implementation = + _entityRegistry.GetOrCreateAssemblyReference(assembly.Name, _ => { }); + break; + } + } + + return (implementation, offset, customAttributes.ToImmutable()); + } + + public GrammarResult VisitManifestResBlock(CILParser.ManifestResBlockContext context) + { + if (context.Value is ManifestResourceValue value) + { + MaterializeManifestResource(value); + } + + return GrammarResult.SentinelValue.Result; + } + + public GrammarResult VisitManifestResDecl(CILParser.ManifestResDeclContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + + GrammarResult ICILVisitor.VisitManifestResDecls( + CILParser.ManifestResDeclsContext context) + => VisitManifestResDecls(context); + + public GrammarResult.Literal<( + EntityRegistry.EntityBase? implementation, + uint offset, + ImmutableArray attributes)> + VisitManifestResDecls(CILParser.ManifestResDeclsContext context) + => new(MaterializeManifestResourceDeclarations(GetManifestValues(context.Value))); + + GrammarResult ICILVisitor.VisitManifestResHead( + CILParser.ManifestResHeadContext context) + => VisitManifestResHead(context); + + public static GrammarResult.Literal<( + string name, + string alias, + ManifestResourceAttributes attr)> VisitManifestResHead( + CILParser.ManifestResHeadContext context) + { + ManifestResourceHeaderValue header = + GetManifestResourceHeader(context.Value, context.Start); + return new((header.Name, header.Alias, header.Attributes)); + } + + GrammarResult ICILVisitor.VisitManresAttr( + CILParser.ManresAttrContext context) + => VisitManresAttr(context); + + public static GrammarResult.Flag VisitManresAttr( + CILParser.ManresAttrContext context) + => new(context.Value); + + GrammarResult ICILVisitor.VisitManresAttrs( + CILParser.ManresAttrsContext context) + => VisitManresAttrs(context); + + public static GrammarResult.Literal VisitManresAttrs( + CILParser.ManresAttrsContext context) + => new(context.Value); +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Typedefs.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Typedefs.cs new file mode 100644 index 00000000000000..c6d81582c6d939 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Typedefs.cs @@ -0,0 +1,127 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Generic; +using System.Reflection.Metadata; +using Antlr4.Runtime; + +namespace ILAssembler; + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. +internal sealed partial class GrammarActions +{ + private readonly Dictionary _typedefs = new(); + + internal object CreateTypeSignatureTypedef(object? type, string alias) + => new TypeSignatureTypedefDeclarationValue(GetTypeValue(type), alias); + + internal object CreateClassTypedef(object? type, string alias) + => new ClassTypedefDeclarationValue(GetClassNameValue(type), alias); + + internal object CreateMemberTypedef(object? member, string alias) + => new MemberTypedefDeclarationValue(GetMemberReferenceValue(member), alias); + + internal object CreateCustomAttributeTypedefDeclaration( + object? attribute, + IToken location, + string alias) + => new CustomAttributeTypedefDeclarationValue( + GetCustomAttributeDescriptorValue(attribute), + location, + alias); + + private void MaterializeTypedef(TypedefDeclarationValue declaration) + { + switch (declaration) + { + case TypeSignatureTypedefDeclarationValue type: + BlobBuilder typeBlob = MaterializeType(type.Type); + BlobBuilder copy = new(typeBlob.Count); + typeBlob.WriteContentTo(copy); + _typedefs[type.Alias] = new TypedefEntry.TypeBlob(copy); + break; + case ClassTypedefDeclarationValue type: + _typedefs[type.Alias] = new TypedefEntry.Type(ResolveClassName(type.Type)); + break; + case MemberTypedefDeclarationValue member: + _typedefs[member.Alias] = + new TypedefEntry.Member(MaterializeMemberReference(member.Member)); + break; + case CustomAttributeTypedefDeclarationValue customAttribute: + EntityRegistry.CustomAttributeEntity attribute = + MaterializeCustomAttribute( + customAttribute.Attribute, + customAttribute.Location); + _typedefs[customAttribute.Alias] = + new TypedefEntry.CustomAttribute(attribute.Constructor, attribute.Value); + break; + } + } + + public GrammarResult VisitTypedefDecl(CILParser.TypedefDeclContext context) + { + if (context.Value is TypedefDeclarationValue declaration) + { + MaterializeTypedef(declaration); + } + + return GrammarResult.SentinelValue.Result; + } + + private EntityRegistry.TypeEntity? TryResolveTypedefAsType(string alias) + { + if (_typedefs.TryGetValue(alias, out TypedefEntry? entry) && + entry is TypedefEntry.Type type) + { + return type.Entity; + } + + return null; + } + + private BlobBuilder? TryResolveTypedefAsTypeBlob(string alias) + { + if (!_typedefs.TryGetValue(alias, out TypedefEntry? entry)) + { + return null; + } + + if (entry is TypedefEntry.TypeBlob blob) + { + return blob.Blob; + } + + if (entry is TypedefEntry.Type type) + { + BlobBuilder result = new(5); + result.WriteByte((byte)SignatureTypeKind.Class); + result.WriteTypeEntity(type.Entity); + return result; + } + + return null; + } + + private EntityRegistry.EntityBase? TryResolveTypedefAsMember(string alias) + { + if (_typedefs.TryGetValue(alias, out TypedefEntry? entry) && + entry is TypedefEntry.Member member) + { + return member.Entity; + } + + return null; + } + + private (EntityRegistry.EntityBase Constructor, BlobBuilder Value)? + TryResolveTypedefAsCustomAttribute(string alias) + { + if (_typedefs.TryGetValue(alias, out TypedefEntry? entry) && + entry is TypedefEntry.CustomAttribute customAttribute) + { + return (customAttribute.Constructor, customAttribute.Value); + } + + return null; + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.VTable.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.VTable.cs new file mode 100644 index 00000000000000..a2a2fb3a25ac08 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.VTable.cs @@ -0,0 +1,79 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using Antlr4.Runtime; + +namespace ILAssembler; + +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. +internal sealed partial class GrammarActions +{ + private readonly List _vtableFixups = new(); + + internal ushort ParseVTableFixupAttribute(IToken token) + => token.Text switch + { + "int32" => VTableFixupSupport.COR_VTABLE_32BIT, + "int64" => VTableFixupSupport.COR_VTABLE_64BIT, + "fromunmanaged" => VTableFixupSupport.COR_VTABLE_FROM_UNMANAGED, + "callmostderived" => VTableFixupSupport.COR_VTABLE_CALL_MOST_DERIVED, + "retainappdomain" => + VTableFixupSupport.COR_VTABLE_FROM_UNMANAGED_RETAIN_APPDOMAIN, + _ => throw new UnreachableException() + }; + + internal ushort AddVTableFixupAttribute(ushort attributes, ushort value) + => (ushort)(attributes | value); + + internal ushort CompleteVTableFixupAttributes(ushort attributes) + { + const ushort SlotSizeMask = + VTableFixupSupport.COR_VTABLE_32BIT | VTableFixupSupport.COR_VTABLE_64BIT; + return (attributes & SlotSizeMask) == 0 + ? (ushort)(attributes | VTableFixupSupport.COR_VTABLE_32BIT) + : attributes; + } + + internal object CreateVTableFixup(IToken slotCount, ushort flags, IToken dataLabel) + => new VTableFixupValue(ParseInt32(slotCount), flags, ParseIdentifier(dataLabel)); + + internal object CreateRawVTable(ImmutableArray value) => new RawVTableValue(value); + + public GrammarResult VisitVtableDecl(CILParser.VtableDeclContext context) + => throw new NotImplementedException( + "raw vtable fixups blob (.vtable) not supported - use .vtfixup instead"); + + GrammarResult ICILVisitor.VisitVtfixupAttr( + CILParser.VtfixupAttrContext context) + => VisitVtfixupAttr(context); + + public static GrammarResult.Literal VisitVtfixupAttr( + CILParser.VtfixupAttrContext context) + => new(context.Value); + + GrammarResult ICILVisitor.VisitVtfixupAttrElement( + CILParser.VtfixupAttrElementContext context) + => VisitVtfixupAttrElement(context); + + public static GrammarResult.Literal VisitVtfixupAttrElement( + CILParser.VtfixupAttrElementContext context) + => new(context.Value); + + GrammarResult ICILVisitor.VisitVtfixupDecl( + CILParser.VtfixupDeclContext context) + => VisitVtfixupDecl(context); + + public GrammarResult VisitVtfixupDecl(CILParser.VtfixupDeclContext context) + { + if (context.Value is VTableFixupValue value) + { + _vtableFixups.Add(new(value.SlotCount, value.Flags, value.DataLabel)); + } + + return GrammarResult.SentinelValue.Result; + } +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Values.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Values.cs new file mode 100644 index 00000000000000..eb992859a3517c --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Values.cs @@ -0,0 +1,179 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Reflection; +using Antlr4.Runtime; + +namespace ILAssembler; + +internal sealed partial class GrammarActions +{ + private sealed class ManifestValueListFrame + where TContext : ParserRuleContext + { + public ManifestValueListFrame(TContext owner) + { + Owner = owner; + } + + public TContext Owner { get; } + + public ImmutableArray.Builder? Values { get; set; } + } + + private sealed record AssemblyDefinitionValue( + AssemblyFlags Attributes, + string Name, + ImmutableArray Declarations); + + private sealed record AssemblyReferenceValue( + AssemblyReferenceHeaderValue Header, + ImmutableArray Declarations); + + private sealed record AssemblyReferenceHeaderValue( + AssemblyFlags Attributes, + string Name, + string Alias); + + private sealed record AssemblyPublicKeyDirectiveValue(ImmutableArray Value); + + private sealed record AssemblyVersionDirectiveValue(Version Value); + + private sealed record AssemblyLocaleDirectiveValue(string Value); + + private sealed record AssemblyCustomAttributeDirectiveValue(object? Value, IToken Location); + + private sealed record AssemblyHashAlgorithmDirectiveValue(AssemblyHashAlgorithm Value); + + private sealed record AssemblySecurityDirectiveValue(object? Value, IToken Location); + + private sealed record AssemblyReferenceHashDirectiveValue(ImmutableArray Value); + + private sealed record AssemblyReferencePublicKeyTokenDirectiveValue(ImmutableArray Value); + + private sealed record FileDeclarationValue( + string Name, + bool HasMetadata, + bool IsEntryPoint, + ImmutableArray? Hash); + + private sealed record ExportedTypeValue( + ExportedTypeHeaderValue Header, + ImmutableArray Declarations); + + private sealed record ExportedTypeHeaderValue( + TypeAttributes Attributes, + string Name, + IToken Location); + + private sealed record ExportedTypeFileDirectiveValue(string Name, IToken Location); + + private sealed record NestedExportedTypeDirectiveValue(TypeName Name, IToken Location); + + private sealed record ExportedTypeAssemblyDirectiveValue(string Name, IToken Location); + + private sealed record ExportedTypeMetadataTokenDirectiveValue(int Token, IToken Location); + + private sealed record ExportedTypeDefinitionIdDirectiveValue(int Value); + + private sealed record ExportedTypeCustomAttributeDirectiveValue(object? Value, IToken Location); + + private sealed record ManifestResourceValue( + ManifestResourceHeaderValue Header, + ImmutableArray Declarations); + + private sealed record ManifestResourceHeaderValue( + ManifestResourceAttributes Attributes, + string Name, + string Alias, + IToken Location); + + private sealed record ManifestResourceFileDirectiveValue( + string Name, + uint Offset, + IToken Location); + + private sealed record ManifestResourceAssemblyDirectiveValue(string Name); + + private sealed record ManifestResourceCustomAttributeDirectiveValue( + object? Value, + IToken Location); + + private sealed record RawVTableValue(ImmutableArray Value); + + private sealed record VTableFixupValue(int SlotCount, ushort Flags, string DataLabel); + + private abstract record TypedefDeclarationValue(string Alias); + + private sealed record TypeSignatureTypedefDeclarationValue(TypeValue Type, string Alias) + : TypedefDeclarationValue(Alias); + + private sealed record ClassTypedefDeclarationValue(ClassNameValue Type, string Alias) + : TypedefDeclarationValue(Alias); + + private sealed record MemberTypedefDeclarationValue(MemberReferenceValue Member, string Alias) + : TypedefDeclarationValue(Alias); + + private sealed record CustomAttributeTypedefDeclarationValue( + CustomAttributeDescriptorValue Attribute, + IToken Location, + string Alias) + : TypedefDeclarationValue(Alias); + + private abstract record TypedefEntry + { + public sealed record Type(EntityRegistry.TypeEntity Entity) : TypedefEntry; + + public sealed record TypeBlob(System.Reflection.Metadata.BlobBuilder Blob) : TypedefEntry; + + public sealed record Member(EntityRegistry.EntityBase Entity) : TypedefEntry; + + public sealed record CustomAttribute( + EntityRegistry.EntityBase Constructor, + System.Reflection.Metadata.BlobBuilder Value) : TypedefEntry; + } + + private static void AddManifestValue( + Stack> frames, + TContext context, + object? value) + where TContext : ParserRuleContext + { + if (value is not null && TryGetManifestValueListFrame(frames, context) is { } frame) + { + (frame.Values ??= ImmutableArray.CreateBuilder()).Add(value); + } + } + + private static ImmutableArray EndManifestValues( + Stack> frames, + TContext context) + where TContext : ParserRuleContext + { + if (TryGetManifestValueListFrame(frames, context) is not { } frame) + { + return []; + } + + frames.Pop(); + return frame.Values?.ToImmutable() ?? []; + } + + private static ManifestValueListFrame? TryGetManifestValueListFrame( + Stack> frames, + TContext context) + where TContext : ParserRuleContext + { + Debug.Assert(frames.Count > 0); + ManifestValueListFrame? frame = frames.Count == 0 ? null : frames.Peek(); + Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); + return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; + } + + private static ImmutableArray GetManifestValues(object? value) + => value is ImmutableArray values ? values : []; +} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.cs index 010b11c3514c31..29ef29b299319e 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.cs @@ -1,661 +1,35 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System; -using System.Buffers.Binary; -using System.Collections.Generic; -using System.Collections.Immutable; using System.Diagnostics; -using System.Globalization; -using System.IO; -using System.Linq; -using System.Reflection; -using System.Reflection.Metadata; -using System.Reflection.Metadata.Ecma335; -using System.Reflection.PortableExecutable; -using System.Runtime.InteropServices; -using System.Security.Cryptography; -using System.Text; -using Antlr4.Runtime; -using Antlr4.Runtime.Misc; -using Antlr4.Runtime.Tree; -namespace ILAssembler -{ -#pragma warning disable CA1822 // Mark members as static - internal sealed partial class GrammarActions : ICILVisitor - { - GrammarResult ICILVisitor.VisitAlignment(CILParser.AlignmentContext context) => VisitAlignment(context); - public GrammarResult VisitAlignment(CILParser.AlignmentContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitAsmAttr(CILParser.AsmAttrContext context) => VisitAsmAttr(context); - public GrammarResult.Literal VisitAsmAttr(CILParser.AsmAttrContext context) - => new(context.asmAttrAny().Select(VisitAsmAttrAny).Aggregate((AssemblyFlags)0, (lhs, rhs) => lhs | rhs)); - GrammarResult ICILVisitor.VisitAsmAttrAny(CILParser.AsmAttrAnyContext context) => VisitAsmAttrAny(context); - public GrammarResult.Flag VisitAsmAttrAny(CILParser.AsmAttrAnyContext context) - { - return context.GetText() switch - { - "retargetable" => new(AssemblyFlags.Retargetable), - "windowsruntime" => new(AssemblyFlags.WindowsRuntime), - "noplatform" => new(AssemblyFlags.NoPlatform), - "legacy library" => new(0), - "cil" => new(GetFlagForArch(ProcessorArchitecture.MSIL), AssemblyFlags.ArchitectureMask), - "x86" => new(GetFlagForArch(ProcessorArchitecture.X86), AssemblyFlags.ArchitectureMask), - "amd64" => new(GetFlagForArch(ProcessorArchitecture.Amd64), AssemblyFlags.ArchitectureMask), - "arm" => new(GetFlagForArch(ProcessorArchitecture.Arm), AssemblyFlags.ArchitectureMask), - "arm64" => new(GetFlagForArch((ProcessorArchitecture)6), AssemblyFlags.ArchitectureMask), - _ => throw new UnreachableException() - }; - } - - private static AssemblyFlags GetFlagForArch(ProcessorArchitecture arch) - { - return (AssemblyFlags)((int)arch << 4); - } - - private static (ProcessorArchitecture, AssemblyFlags) GetArchAndFlags(AssemblyFlags flags) - { - var arch = (ProcessorArchitecture)(((int)flags & 0xF0) >> 4); - var newFlags = flags & ~((AssemblyFlags)((int)arch << 4)); - return (arch, newFlags); - } - public GrammarResult VisitAsmOrRefDecl(CILParser.AsmOrRefDeclContext context) - { - Debug.Assert(_currentAssemblyOrRef is not null); - - if (context.customAttrDecl() is { } attr) - { - var customAttr = VisitCustomAttrDecl(attr).Value; - customAttr?.Owner = _currentAssemblyOrRef; - return GrammarResult.SentinelValue.Result; - } - - string decl = context.GetChild(0).GetText(); - if (decl is ".publickey" or ".publicKey") - { - BlobBuilder blob = new(); - blob.WriteBytes(VisitBytes(context.bytes())); - // COMPAT: Native ilasm gives a public key token precedence regardless of declaration order. - if (_currentAssemblyOrRef is not EntityRegistry.AssemblyReferenceEntity assemblyReference - || assemblyReference.PublicKeyOrToken is null - || assemblyReference.Flags.HasFlag(AssemblyFlags.PublicKey)) - { - _currentAssemblyOrRef!.PublicKeyOrToken = blob; - _currentAssemblyOrRef.Flags |= AssemblyFlags.PublicKey; - } - } - else if (decl == ".ver") - { - var versionComponents = context.intOrWildcard(); - _currentAssemblyOrRef!.Version = new Version( - VisitIntOrWildcard(versionComponents[0]).Value ?? 0, - VisitIntOrWildcard(versionComponents[1]).Value ?? 0, - VisitIntOrWildcard(versionComponents[2]).Value ?? 0, - VisitIntOrWildcard(versionComponents[3]).Value ?? 0); - } - else if (decl == ".locale") - { - _currentAssemblyOrRef!.Culture = context.compQstring() is { } compQstring - ? VisitCompQstring(compQstring).Value - : Encoding.Unicode.GetString([.. VisitBytes(context.bytes())]); - } - return GrammarResult.SentinelValue.Result; - } - - GrammarResult ICILVisitor.VisitAssemblyBlock(CILParser.AssemblyBlockContext context) => VisitAssemblyBlock(context); - public GrammarResult VisitAssemblyBlock(CILParser.AssemblyBlockContext context) - { - // Use command-line override if specified, otherwise use the name from the .assembly directive - string assemblyName = _options.AssemblyName ?? VisitDottedName(context.dottedName()).Value; - _entityRegistry.Assembly ??= new EntityRegistry.AssemblyEntity(assemblyName); - var attr = VisitAsmAttr(context.asmAttr()).Value; - (_entityRegistry.Assembly.ProcessorArchitecture, _entityRegistry.Assembly.Flags) = GetArchAndFlags(attr); - foreach (var decl in context.assemblyDecls().assemblyDecl()) - { - VisitAssemblyDecl(decl); - } - - // Apply command-line key file override (overrides .publickey directive) - if (_options.KeyFile is not null) - { - ApplyKeyFile(_options.KeyFile); - } - - // DebuggableAttribute is applied in BuildImage() after all source declarations - // have been processed, so the correct corelib assembly ref can be found. - - return GrammarResult.SentinelValue.Result; - } - - private void ApplyKeyFile(string keyFilePath) - { - if (_entityRegistry.Assembly is null) - { - return; - } - - try - { - byte[] keyBytes = File.ReadAllBytes(keyFilePath); - BlobBuilder blob = new(); - blob.WriteBytes(keyBytes); - _entityRegistry.Assembly.PublicKeyOrToken = blob; - _entityRegistry.Assembly.Flags |= AssemblyFlags.PublicKey; - } - catch (Exception ex) - { - // Create a location pointing to the first document (if available) - var firstDoc = _documents.Values.FirstOrDefault(); - var location = firstDoc is not null - ? new Location(new SourceSpan(0, 0), firstDoc) - : new Location(new SourceSpan(0, 0), new SourceText(string.Empty, keyFilePath)); - _diagnostics.Add(new Diagnostic(DiagnosticIds.KeyFileError, DiagnosticSeverity.Error, $"Failed to read key file '{keyFilePath}': {ex.Message}", location)); - } - } - - GrammarResult ICILVisitor.VisitAssemblyDecl(CILParser.AssemblyDeclContext context) => VisitAssemblyDecl(context); - public GrammarResult VisitAssemblyDecl(CILParser.AssemblyDeclContext context) - { - if (context.secDecl() is { } secDecl) - { - var declarativeSecurity = VisitSecDecl(secDecl); - if (declarativeSecurity.Value is { } sec) - { - sec.Parent = _entityRegistry.Assembly; - } - } - else if (context.int32() is { } hashAlg) - { - _entityRegistry.Assembly!.HashAlgorithm = (AssemblyHashAlgorithm)VisitInt32(hashAlg).Value; - } - else if (context.asmOrRefDecl() is { } asmOrRef) - { - _currentAssemblyOrRef = _entityRegistry.Assembly; - try - { - VisitAsmOrRefDecl(asmOrRef); - } - finally - { - _currentAssemblyOrRef = null; - } - } - return GrammarResult.SentinelValue.Result; - } - public GrammarResult VisitAssemblyDecls(CILParser.AssemblyDeclsContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - public GrammarResult VisitAssemblyRefDecl(CILParser.AssemblyRefDeclContext context) - { - if (context.asmOrRefDecl() is { } asmOrRef) - { - VisitAsmOrRefDecl(asmOrRef); - } - string decl = context.GetChild(0).GetText(); - if (decl == ".hash") - { - var blob = new BlobBuilder(); - blob.WriteBytes(VisitBytes(context.bytes())); - ((EntityRegistry.AssemblyReferenceEntity)_currentAssemblyOrRef!).Hash = blob; - } - if (decl == ".publickeytoken") - { - var blob = new BlobBuilder(); - blob.WriteBytes(VisitBytes(context.bytes())); - _currentAssemblyOrRef!.PublicKeyOrToken = blob; - _currentAssemblyOrRef.Flags &= ~AssemblyFlags.PublicKey; - } - return GrammarResult.SentinelValue.Result; - } - public GrammarResult VisitAssemblyRefDecls(CILParser.AssemblyRefDeclsContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - GrammarResult ICILVisitor.VisitAssemblyRefHead(CILParser.AssemblyRefHeadContext context) => VisitAssemblyRefHead(context); - public GrammarResult.Literal VisitAssemblyRefHead(CILParser.AssemblyRefHeadContext context) - { - var (arch, flags) = GetArchAndFlags(VisitAsmAttr(context.asmAttr()).Value); - var dottedNames = context.dottedName(); - string name = VisitDottedName(dottedNames[0]).Value; - string alias = name; - if (dottedNames.Length > 1) - { - alias = VisitDottedName(dottedNames[1]).Value; - } - return new(_entityRegistry.GetOrCreateAssemblyReference(alias, asmref => - { - asmref.Name = name; - asmref.Flags = flags; - asmref.ProcessorArchitecture = arch; - })); - } - - GrammarResult ICILVisitor.VisitCorflags(CILParser.CorflagsContext context) => VisitCorflags(context); - public GrammarResult VisitCorflags(CILParser.CorflagsContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitExportHead(CILParser.ExportHeadContext context) => throw new NotImplementedException("Obsolete syntax"); - GrammarResult ICILVisitor.VisitExptAttr(CILParser.ExptAttrContext context) => VisitExptAttr(context); - public static GrammarResult.Flag VisitExptAttr(CILParser.ExptAttrContext context) - { - return context.GetText() switch - { - "private" => new(TypeAttributes.NotPublic, TypeAttributes.VisibilityMask), - "public" => new(TypeAttributes.Public, TypeAttributes.VisibilityMask), - "forwarder" => new(TypeAttributes.Forwarder), - "nestedpublic" => new(TypeAttributes.NestedPublic, TypeAttributes.VisibilityMask), - "nestedprivate" => new(TypeAttributes.NestedPrivate, TypeAttributes.VisibilityMask), - "nestedfamily" => new(TypeAttributes.NestedFamily, TypeAttributes.VisibilityMask), - "nestedassembly" => new(TypeAttributes.NestedAssembly, TypeAttributes.VisibilityMask), - "nestedfamandassem" => new(TypeAttributes.NestedFamANDAssem, TypeAttributes.VisibilityMask), - "nestedfamorassem" => new(TypeAttributes.NestedFamORAssem, TypeAttributes.VisibilityMask), - _ => throw new UnreachableException(), - }; - } - - // Type exports and forwarders are implemented via VisitExptypeDecls - public GrammarResult VisitExptypeDecl(CILParser.ExptypeDeclContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - - GrammarResult ICILVisitor.VisitExptypeDecls(CILParser.ExptypeDeclsContext context) => VisitExptypeDecls(context); - public GrammarResult.Literal<(EntityRegistry.EntityBase? implementation, int typedefId, ImmutableArray attrs)> VisitExptypeDecls(CILParser.ExptypeDeclsContext context) - { - // COMPAT: The following order specifies the precedence of the various export kinds. - // File, Assembly, Class (enclosing type), invalid token. - // We'll process through all of the options here and then return the one that is valid. - // We'll also record custom attributes here. - EntityRegistry.EntityBase? implementationEntity = null; - int typedefId = 0; - var attrs = ImmutableArray.CreateBuilder(); - var declarations = context.exptypeDecl(); - for (int i = 0; i < declarations.Length; i++) - { - if (declarations[i].customAttrDecl() is { } attr) - { - if (VisitCustomAttrDecl(attr).Value is EntityRegistry.CustomAttributeEntity customAttribute) - { - attrs.Add(customAttribute); - } - continue; - } - if (declarations[i].mdtoken() is { } mdToken) - { - var entity = VisitMdtoken(mdToken).Value; - if (entity is null or EntityRegistry.FakeTypeEntity) - { - ReportError(DiagnosticIds.InvalidMetadataToken, DiagnosticMessageTemplates.InvalidMetadataToken, declarations[i]); - } - implementationEntity = ResolveBetterEntity(entity); - continue; - } - string kind = declarations[i].GetText(); - if (kind.StartsWith(".file")) - { - string fileName = VisitDottedName(declarations[i].dottedName()).Value; - implementationEntity = _entityRegistry.FindFile(fileName); - if (implementationEntity is null) - { - ReportError(DiagnosticIds.FileNotFound, string.Format(DiagnosticMessageTemplates.FileNotFound, fileName), declarations[i]); - } - } - else if (kind.StartsWith(".assembly")) - { - string assemblyName = VisitDottedName(declarations[i].dottedName()).Value; - implementationEntity = _entityRegistry.FindAssemblyReference(assemblyName); - if (implementationEntity is null) - { - ReportError(DiagnosticIds.AssemblyNotFound, string.Format(DiagnosticMessageTemplates.AssemblyNotFound, assemblyName), declarations[i]); - } - } - else if (kind.StartsWith(".class")) - { - if (declarations[i].int32() is CILParser.Int32Context int32) - { - typedefId = VisitInt32(int32).Value; - } - else - { - _ = VisitSlashedName(declarations[i].slashedName()); - var containing = ResolveExportedType(declarations[i].slashedName()); - if (containing is null) - { - ReportError(DiagnosticIds.ExportedTypeNotFound, string.Format(DiagnosticMessageTemplates.ExportedTypeNotFound, declarations[i].slashedName().GetText()), declarations[i]); - } - else - { - implementationEntity = ResolveBetterEntity(containing); - } - } - } - } - - return new((implementationEntity, typedefId, attrs.ToImmutable())); - - EntityRegistry.EntityBase? ResolveBetterEntity(EntityRegistry.EntityBase? newImplementation) - { - return (implementationEntity, newImplementation) switch - { - (null, _) => newImplementation, - (_, null) => implementationEntity, - (_, EntityRegistry.FileEntity) => newImplementation, - (EntityRegistry.FileEntity, _) => implementationEntity, - (_, EntityRegistry.AssemblyEntity) => newImplementation, - (EntityRegistry.AssemblyEntity, _) => implementationEntity, - (_, EntityRegistry.TypeEntity) => newImplementation, - (EntityRegistry.TypeEntity, _) => implementationEntity, - _ => throw new UnreachableException(), - }; - } - - // Resolve ExportedType reference - EntityRegistry.ExportedTypeEntity? ResolveExportedType(CILParser.SlashedNameContext slashedName) - { - TypeName typeName = VisitSlashedName(slashedName).Value; - if (typeName.ContainingTypeName is null) - { - // Check for typedef - typedefs resolve to TypeEntity, not ExportedTypeEntity - // so we skip the typedef check for exported type resolution - } - Stack containingTypes = new(); - for (TypeName? containingType = typeName; containingType is not null; containingType = containingType.ContainingTypeName) - { - containingTypes.Push(containingType); - } - EntityRegistry.ExportedTypeEntity? exportedType = null; - while (containingTypes.Count != 0) - { - TypeName containingType = containingTypes.Pop(); - - (string ns, string name) = NameHelpers.SplitDottedNameToNamespaceAndName(containingType.DottedName); - - exportedType = _entityRegistry.FindExportedType( - exportedType, - ns, - name); +namespace ILAssembler; - if (exportedType is null) - { - ReportError(DiagnosticIds.ExportedTypeNotFound, string.Format(DiagnosticMessageTemplates.ExportedTypeNotFound, containingType.DottedName), slashedName); - return null; - } - } - - return exportedType!; - } - } - GrammarResult ICILVisitor.VisitExptypeHead(CILParser.ExptypeHeadContext context) => VisitExptypeHead(context); - public GrammarResult.Literal<(TypeAttributes attrs, string dottedName)> VisitExptypeHead(CILParser.ExptypeHeadContext context) - { - var attrs = context.exptAttr().Select(VisitExptAttr).Aggregate((TypeAttributes)0, (a, b) => a | b); - return new((attrs, VisitDottedName(context.dottedName()).Value)); - } - - GrammarResult ICILVisitor.VisitFileAttr(CILParser.FileAttrContext context) => VisitFileAttr(context); - public GrammarResult.Literal VisitFileAttr(CILParser.FileAttrContext context) - => context.ChildCount != 0 ? new(false) : new(true); - GrammarResult ICILVisitor.VisitFileDecl(CILParser.FileDeclContext context) => VisitFileDecl(context); - public GrammarResult.Literal VisitFileDecl(CILParser.FileDeclContext context) - { - string dottedName = VisitDottedName(context.dottedName()).Value; - ImmutableArray? hash = context.HASH() is not null ? VisitBytes(context.bytes()) : null; - var hashBlob = hash is not null ? new BlobBuilder() : null; - hashBlob?.WriteBytes(hash!.Value); - - bool hasMetadata = context.fileAttr().Aggregate(true, (acc, attr) => acc && VisitFileAttr(attr).Value); - bool isEntrypoint = context.fileEntry().Aggregate(false, (acc, attr) => acc || VisitFileEntry(attr).Value); - var entity = _entityRegistry.GetOrCreateFile(dottedName, hasMetadata, hashBlob); - if (isEntrypoint) - { - _entityRegistry.EntryPoint = entity; - } - return new(entity); - } - GrammarResult ICILVisitor.VisitFileEntry(CILParser.FileEntryContext context) => VisitFileEntry(context); - public GrammarResult.Literal VisitFileEntry(CILParser.FileEntryContext context) - => context.ChildCount != 0 ? new(true) : new(false); - - GrammarResult ICILVisitor.VisitImagebase(CILParser.ImagebaseContext context) => VisitImagebase(context); - public GrammarResult VisitImagebase(CILParser.ImagebaseContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitManifestResDecl(CILParser.ManifestResDeclContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - GrammarResult ICILVisitor.VisitManifestResDecls(CILParser.ManifestResDeclsContext context) => VisitManifestResDecls(context); - public GrammarResult.Literal<(EntityRegistry.EntityBase? implementation, uint offset, ImmutableArray attributes)> VisitManifestResDecls(CILParser.ManifestResDeclsContext context) - { - EntityRegistry.EntityBase? implementation = null; - uint offset = 0; - var attributes = ImmutableArray.CreateBuilder(); - // COMPAT: Priority order for implementation is the following - // AssemblyRef, File, nil - foreach (var decl in context.manifestResDecl()) - { - if (decl.customAttrDecl() is CILParser.CustomAttrDeclContext customAttrDecl) - { - if (VisitCustomAttrDecl(customAttrDecl).Value is { } attr) - { - attributes.Add(attr); - } - } - string kind = decl.GetChild(0).GetText(); - if (kind == ".file" && implementation is not EntityRegistry.AssemblyReferenceEntity) - { - string fileName = VisitDottedName(decl.dottedName()).Value; - var file = _entityRegistry.FindFile(fileName); - if (file is null) - { - ReportError(DiagnosticIds.FileNotFound, string.Format(DiagnosticMessageTemplates.FileNotFound, fileName), decl); - } - else - { - implementation = file; - offset = (uint)VisitInt32(decl.int32()).Value; - } - } - else if (kind == ".assembly") - { - string assemblyName = VisitDottedName(decl.dottedName()).Value; - implementation = _entityRegistry.GetOrCreateAssemblyReference(assemblyName, _ => { }); - } - } - - return new((implementation, offset, attributes.ToImmutable())); - } - GrammarResult ICILVisitor.VisitManifestResHead(CILParser.ManifestResHeadContext context) => VisitManifestResHead(context); - public GrammarResult.Literal<(string name, string alias, ManifestResourceAttributes attr)> VisitManifestResHead(CILParser.ManifestResHeadContext context) - { - var dottedNames = context.dottedName(); - string name = VisitDottedName(dottedNames[0]).Value; - string alias = dottedNames.Length == 2 ? VisitDottedName(dottedNames[1]).Value : name; - ManifestResourceAttributes attr = 0; - foreach (var attrContext in context.manresAttr()) - { - attr |= VisitManresAttr(attrContext).Value; - } - - return new((name, alias, attr)); - } - - GrammarResult ICILVisitor.VisitManresAttr(CILParser.ManresAttrContext context) => VisitManresAttr(context); - public GrammarResult.Flag VisitManresAttr(CILParser.ManresAttrContext context) - { - return context.GetText() switch - { - "public" => new(ManifestResourceAttributes.Public), - "private" => new(ManifestResourceAttributes.Private), - _ => throw new UnreachableException() - }; - } - - public GrammarResult VisitModuleHead(CILParser.ModuleHeadContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - // .mscorlib directive indicates the assembly being compiled is mscorlib itself. - // This is currently a no-op; the flag would be used to affect type resolution - // when support for compiling mscorlib is added. - public GrammarResult VisitMscorlib(CILParser.MscorlibContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitStackreserve(CILParser.StackreserveContext context) => VisitStackreserve(context); - public GrammarResult VisitStackreserve(CILParser.StackreserveContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitSubsystem(CILParser.SubsystemContext context) => VisitSubsystem(context); - public GrammarResult VisitSubsystem(CILParser.SubsystemContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitTypedefDecl(CILParser.TypedefDeclContext context) - { - string alias = VisitDottedName(context.dottedName()).Value; - - if (context.type() is CILParser.TypeContext type) - { - // .typedef type as alias - // This creates an alias for a complete type signature (blob) - var typeBlob = VisitType(type).Value; - // Create a copy of the blob to avoid issues with linked BlobBuilders - var copy = new BlobBuilder(typeBlob.Count); - typeBlob.WriteContentTo(copy); - _typedefs[alias] = new TypedefEntry.TypeBlob(copy); - } - else if (context.className() is CILParser.ClassNameContext className) - { - // .typedef className as alias - var typeEntity = VisitClassName(className).Value; - _typedefs[alias] = new TypedefEntry.Type(typeEntity); - } - else if (context.memberRef() is CILParser.MemberRefContext memberRef) - { - // .typedef memberRef as alias - var member = VisitMemberRef(memberRef).Value; - _typedefs[alias] = new TypedefEntry.Member(member); - } - else if (context.customDescr() is CILParser.CustomDescrContext customDescr) - { - // .typedef customDescr as alias - var attr = VisitCustomDescr(customDescr).Value; - if (attr is not null) - { - _typedefs[alias] = new TypedefEntry.CustomAttribute(attr.Constructor, attr.Value); - } - } - else if (context.customDescrWithOwner() is CILParser.CustomDescrWithOwnerContext customDescrWithOwner) - { - // .typedef customDescrWithOwner as alias - var attr = VisitCustomDescrWithOwner(customDescrWithOwner).Value; - if (attr is not null) - { - _typedefs[alias] = new TypedefEntry.CustomAttribute(attr.Constructor, attr.Value); - } - } - - return GrammarResult.SentinelValue.Result; - } - - /// - /// Tries to resolve a typedef alias to a type entity. - /// - private EntityRegistry.TypeEntity? TryResolveTypedefAsType(string alias) - { - if (_typedefs.TryGetValue(alias, out var entry) && entry is TypedefEntry.Type typeEntry) - { - return typeEntry.Entity; - } - return null; - } - - /// - /// Tries to resolve a typedef alias to a type blob (complete type signature). - /// - private BlobBuilder? TryResolveTypedefAsTypeBlob(string alias) - { - if (_typedefs.TryGetValue(alias, out var entry)) - { - if (entry is TypedefEntry.TypeBlob blobEntry) - { - return blobEntry.Blob; - } - if (entry is TypedefEntry.Type typeEntry) - { - // Encode the type entity as a CLASS reference for the blob - var blob = new BlobBuilder(5); - blob.WriteByte((byte)SignatureTypeKind.Class); - blob.WriteTypeEntity(typeEntry.Entity); - return blob; - } - } - return null; - } - - /// - /// Tries to resolve a typedef alias to a member reference. - /// - private EntityRegistry.EntityBase? TryResolveTypedefAsMember(string alias) - { - if (_typedefs.TryGetValue(alias, out var entry) && entry is TypedefEntry.Member memberEntry) - { - return memberEntry.Entity; - } - return null; - } - - /// - /// Tries to resolve a typedef alias to a custom attribute. - /// - private (EntityRegistry.EntityBase Constructor, BlobBuilder Value)? TryResolveTypedefAsCustomAttribute(string alias) - { - if (_typedefs.TryGetValue(alias, out var entry) && entry is TypedefEntry.CustomAttribute attrEntry) - { - return (attrEntry.Constructor, attrEntry.Value); - } - return null; - } - - public GrammarResult VisitTypelist(CILParser.TypelistContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitVtableDecl(CILParser.VtableDeclContext context) - { - // Raw .vtable directive with bytes - not commonly used - // For now, we don't support this legacy syntax - throw new NotImplementedException("raw vtable fixups blob (.vtable) not supported - use .vtfixup instead"); - } +internal sealed partial class GrammarActions +{ +#pragma warning disable CA1822 // Structural rules are driven by parser actions. + public GrammarResult VisitAlignment(CILParser.AlignmentContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - GrammarResult ICILVisitor.VisitVtfixupAttr(CILParser.VtfixupAttrContext context) => VisitVtfixupAttr(context); - public GrammarResult.Literal VisitVtfixupAttr(CILParser.VtfixupAttrContext context) - { - // vtfixupAttr: | vtfixupAttr INT32_ | vtfixupAttr INT64_ | vtfixupAttr 'fromunmanaged' | vtfixupAttr 'callmostderived' | vtfixupAttr 'retainappdomain' - ushort flags = 0; - foreach (var child in context.children ?? []) - { - string text = child.GetText(); - flags |= text switch - { - "int32" => VTableFixupSupport.COR_VTABLE_32BIT, - "int64" => VTableFixupSupport.COR_VTABLE_64BIT, - "fromunmanaged" => VTableFixupSupport.COR_VTABLE_FROM_UNMANAGED, - "callmostderived" => VTableFixupSupport.COR_VTABLE_CALL_MOST_DERIVED, - "retainappdomain" => VTableFixupSupport.COR_VTABLE_FROM_UNMANAGED_RETAIN_APPDOMAIN, - _ => 0 - }; - } + public GrammarResult VisitCorflags(CILParser.CorflagsContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - // Default to 32-bit if neither 32 nor 64 is specified - if ((flags & (VTableFixupSupport.COR_VTABLE_32BIT | VTableFixupSupport.COR_VTABLE_64BIT)) == 0) - { - flags |= VTableFixupSupport.COR_VTABLE_32BIT; - } + public GrammarResult VisitImagebase(CILParser.ImagebaseContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - return new(flags); - } + public GrammarResult VisitModuleHead(CILParser.ModuleHeadContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - GrammarResult ICILVisitor.VisitVtfixupDecl(CILParser.VtfixupDeclContext context) => VisitVtfixupDecl(context); - public GrammarResult VisitVtfixupDecl(CILParser.VtfixupDeclContext context) - { - // vtfixupDecl: '.vtfixup' '[' int32 ']' vtfixupAttr 'at' id; - int slotCount = VisitInt32(context.int32()).Value; - ushort flags = VisitVtfixupAttr(context.vtfixupAttr()).Value; - string dataLabel = VisitId(context.id()).Value; + public GrammarResult VisitMscorlib(CILParser.MscorlibContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - _vtableFixups.Add(new VTableFixupSupport.VTableFixupEntry(slotCount, flags, dataLabel)); + public GrammarResult VisitStackreserve(CILParser.StackreserveContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - return GrammarResult.SentinelValue.Result; - } + public GrammarResult VisitSubsystem(CILParser.SubsystemContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - } + public GrammarResult VisitTypelist(CILParser.TypelistContext context) + => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); +#pragma warning restore CA1822 } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs index 35e8fc1e0897a8..9519d32da5ec21 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs @@ -239,14 +239,14 @@ internal object CreateSecurityEnumValue(object? type, IToken value) private EntityRegistry.DeclarativeSecurityAttributeEntity? MaterializeSecurityDeclaration( SecurityDeclarationValue value, - CILParser.SecDeclContext context) + IToken location) { if (value is PermissionDeclarationValue) { ReportError( DiagnosticIds.UnsupportedSecurityDeclaration, DiagnosticMessageTemplates.UnsupportedSecurityDeclaration, - context); + location); return null; } @@ -383,7 +383,7 @@ GrammarResult ICILVisitor.VisitSecDecl(CILParser.SecDeclContext c CILParser.SecDeclContext context) => new( context.Value is SecurityDeclarationValue value - ? MaterializeSecurityDeclaration(value, context) + ? MaterializeSecurityDeclaration(value, context.Start) : null); GrammarResult ICILVisitor.VisitSecAttrSetBlob( diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs index e6fa14032ce1d9..5df143453faee1 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs @@ -20,7 +20,6 @@ internal void BeginDocument() { Debug.Assert( _currentMethod is null - && _currentAssemblyOrRef is null && _typeOwners.Count == 0 && _namespaceOwners.Count == 0 && _scopeStack.Count == 0 @@ -57,13 +56,16 @@ _currentMethod is null && _customBlobNamedArgumentFrames.Count == 0 && _serializationSequenceFrames.Count == 0 && _dataDeclarationFrames.Count == 0 + && _assemblyDeclarationFrames.Count == 0 + && _assemblyReferenceDeclarationFrames.Count == 0 + && _fileDeclarationFrames.Count == 0 + && _exportedTypeDeclarationFrames.Count == 0 + && _manifestResourceDeclarationFrames.Count == 0 && _securityAttributeSetFrames.Count == 0 && _securityNameValuePairFrames.Count == 0 && _pendingClassMethodOverrides.Count == 0, "Per-document semantic state must be released by the owning rule's finally block."); - EndMethod(); - _currentAssemblyOrRef = null; ResetTypeScopes(); ClearPendingCustomAttributeOwners(); _semanticRootFrames.Clear(); @@ -95,6 +97,11 @@ _currentMethod is null _customBlobNamedArgumentFrames.Clear(); _serializationSequenceFrames.Clear(); _dataDeclarationFrames.Clear(); + _assemblyDeclarationFrames.Clear(); + _assemblyReferenceDeclarationFrames.Clear(); + _fileDeclarationFrames.Clear(); + _exportedTypeDeclarationFrames.Clear(); + _manifestResourceDeclarationFrames.Clear(); _securityAttributeSetFrames.Clear(); _securityNameValuePairFrames.Clear(); _pendingClassMethodOverrides.Clear(); diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 index 76ce82555f4ddd..708a359050be5b 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 @@ -512,10 +512,14 @@ imagebase: stackreserve: '.stackreserve' value = int64 {Actions.ProcessTopLevelStackReserve($value.start);}; -assemblyBlock returns [bool HasSyntaxError] -@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +assemblyBlock returns [object Value, bool HasSyntaxError] +@init {BeginStreaming(); Actions.BeginSemanticRoot(_localctx);} : - '.assembly' asmAttr dottedName '{' assemblyDecls '}'; + '.assembly' attributes = asmAttr name = dottedName '{' declarations = assemblyDecls '}' + {_localctx.Value = Actions.CreateAssemblyDefinition( + $attributes.Value, + $name.Value, + $declarations.Value);}; finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} mscorlib: '.mscorlib'; @@ -555,7 +559,9 @@ float64 returns [double Value]: | FLOAT32 '(' singleBits = int32 ')' {_localctx.Value = Actions.ParseFloat32Bits($singleBits.start);} | FLOAT64_ '(' doubleBits = int64 ')' {_localctx.Value = Actions.ParseFloat64Bits($doubleBits.start);}; -intOrWildcard: int32 | PTR; +intOrWildcard returns [int? Value]: + value = int32 {_localctx.Value = Actions.ParseInt32($value.start);} + | PTR {_localctx.Value = null;}; /* This is handled in the PreprocessedTokenSource lexer. We have this in the grammar just for completeness */ compControl: @@ -571,14 +577,25 @@ compControl: /* Aliasing of types, type specs, methods, fields and custom attributes */ -typedefDecl returns [bool HasSyntaxError] -@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} -: - '.typedef' type 'as' dottedName - | '.typedef' className 'as' dottedName - | '.typedef' memberRef 'as' dottedName - | '.typedef' customDescr 'as' dottedName - | '.typedef' customDescrWithOwner 'as' dottedName; +typedefDecl returns [object Value, bool HasSyntaxError] +@init {BeginStreaming(); Actions.BeginSemanticRoot(_localctx);} +: + '.typedef' signature = type 'as' alias = dottedName + {_localctx.Value = Actions.CreateTypeSignatureTypedef($signature.Value, $alias.Value);} + | '.typedef' classType = className 'as' alias = dottedName + {_localctx.Value = Actions.CreateClassTypedef($classType.Value, $alias.Value);} + | '.typedef' member = memberRef 'as' alias = dottedName + {_localctx.Value = Actions.CreateMemberTypedef($member.Value, $alias.Value);} + | '.typedef' attribute = customDescr 'as' alias = dottedName + {_localctx.Value = Actions.CreateCustomAttributeTypedefDeclaration( + $attribute.Value, + $attribute.start, + $alias.Value);} + | '.typedef' ownedAttribute = customDescrWithOwner 'as' alias = dottedName + {_localctx.Value = Actions.CreateCustomAttributeTypedefDeclaration( + $ownedAttribute.Value, + $ownedAttribute.start, + $alias.Value);}; finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} /* Custom attribute declarations */ @@ -673,25 +690,39 @@ moduleHead returns [string Value, bool HasName, bool IsExternal]: {Actions.SetEmptyModuleHeader(_localctx);}; /* VTable Fixup table declaration */ -vtfixupDecl returns [bool HasSyntaxError] -@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +vtfixupDecl returns [object Value, bool HasSyntaxError] +@init {BeginStreaming(); Actions.BeginSemanticRoot(_localctx);} : - '.vtfixup' '[' int32 ']' vtfixupAttr 'at' id + '.vtfixup' '[' count = int32 ']' attributes = vtfixupAttr 'at' label = id + {_localctx.Value = Actions.CreateVTableFixup( + $count.start, + $attributes.Value, + $label.start);} ; finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} -vtfixupAttr: - /* EMPTY */ - | vtfixupAttr INT32_ - | vtfixupAttr INT64_ - | vtfixupAttr 'fromunmanaged' - | vtfixupAttr 'callmostderived' - | vtfixupAttr 'retainappdomain'; +vtfixupAttr returns [ushort Value] +@init {_localctx.Value = 0;} +: + (attribute = vtfixupAttrElement + {_localctx.Value = Actions.AddVTableFixupAttribute(_localctx.Value, $attribute.Value);})* + {_localctx.Value = Actions.CompleteVTableFixupAttributes(_localctx.Value);} +; + +vtfixupAttrElement returns [ushort Value] +@after {_localctx.Value = Actions.ParseVTableFixupAttribute(_localctx.Start);} +: + INT32_ + | INT64_ + | 'fromunmanaged' + | 'callmostderived' + | 'retainappdomain'; -vtableDecl returns [bool HasSyntaxError] -@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +vtableDecl returns [object Value, bool HasSyntaxError] +@init {BeginStreaming(); Actions.BeginSemanticRoot(_localctx);} : - '.vtable' '=' '(' bytes ')' /* deprecated */ + '.vtable' '=' '(' value = bytes ')' + {_localctx.Value = Actions.CreateRawVTable($value.Value);} /* deprecated */ ; finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} @@ -820,18 +851,32 @@ extSourceSpec returns [object Value, bool HasSyntaxError] finally {Actions.EndSourceDirective(_localctx); EndParseTreeMode();} /* Manifest declarations */ -fileDecl returns [bool HasSyntaxError] -@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +fileDecl returns [object Value, bool HasSyntaxError] +@init {BeginStreaming(); Actions.BeginFileDeclaration(_localctx);} : - '.file' fileAttr* dottedName fileEntry HASH '=' '(' bytes ')' fileEntry - | '.file' fileAttr* dottedName fileEntry; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} + '.file' + (attribute = fileAttr {Actions.AddFileAttribute(_localctx, $attribute.Value);})* + name = dottedName {Actions.SetFileName(_localctx, $name.Value);} + entry = fileEntry {Actions.AddFileEntry(_localctx, $entry.Value);} + (HASH '=' '(' hash = bytes ')' {Actions.SetFileHash(_localctx, $hash.Value);} + trailingEntry = fileEntry {Actions.AddFileEntry(_localctx, $trailingEntry.Value);})? +; +finally {Actions.EndFileDeclaration(_localctx); EndParseTreeMode();} -fileAttr: 'nometadata'; +fileAttr returns [bool Value] +@after {_localctx.Value = Actions.ParseFileAttribute(_localctx.Start);} +: + 'nometadata'; -fileEntry: /* EMPTY */ | '.entrypoint'; +fileEntry returns [bool Value] +@init {_localctx.Value = false;} +: + /* EMPTY */ + | entry = '.entrypoint' {_localctx.Value = Actions.ParseFileEntry($entry);}; -asmAttrAny: +asmAttrAny returns [System.Reflection.AssemblyFlags Value, System.Reflection.AssemblyFlags Mask] +@after {Actions.SetAssemblyAttribute(_localctx);} +: 'retargetable' | 'windowsruntime' | 'noplatform' @@ -842,7 +887,14 @@ asmAttrAny: | 'arm' | 'arm64'; -asmAttr: asmAttrAny*; +asmAttr returns [System.Reflection.AssemblyFlags Value] +@init {_localctx.Value = 0;} +: + (attribute = asmAttrAny + {_localctx.Value = Actions.AddAssemblyAttribute( + _localctx.Value, + $attribute.Value, + $attribute.Mask);})*; /* IL instructions and associated definitions */ instr: @@ -946,9 +998,22 @@ slashedName returns [object Value] ; finally {_localctx.Value = Actions.EndSlashedName(_localctx);} -assemblyDecls: assemblyDecl*; +assemblyDecls returns [object Value] +@init {Actions.BeginAssemblyDeclarations(_localctx);} +: + (declaration = assemblyDecl + {Actions.AddAssemblyDeclaration(_localctx, $declaration.Value);})* +; +finally {_localctx.Value = Actions.EndAssemblyDeclarations(_localctx);} -assemblyDecl: (HASH 'algorithm' int32) | secDecl | asmOrRefDecl; +assemblyDecl returns [object Value]: + HASH 'algorithm' algorithm = int32 + {_localctx.Value = Actions.CreateAssemblyHashAlgorithmDeclaration($algorithm.start);} + | security = secDecl + {_localctx.Value = Actions.CreateAssemblySecurityDeclaration( + $security.Value, + $security.start);} + | shared = asmOrRefDecl {_localctx.Value = $shared.Value;}; typeSpec returns [object Value, bool HasSyntaxError] @@ -2074,45 +2139,101 @@ customAttrDecl returns [object Value, bool HasSyntaxError] finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} /* Assembly References */ -asmOrRefDecl: - ('.publickey' | '.publicKey') '=' '(' bytes ')' - | '.ver' intOrWildcard ':' intOrWildcard ':' intOrWildcard ':' intOrWildcard - | '.locale' compQstring - | '.locale' '=' '(' bytes ')' - | customAttrDecl +asmOrRefDecl returns [object Value]: + ('.publickey' | '.publicKey') '=' '(' key = bytes ')' + {_localctx.Value = Actions.CreateAssemblyPublicKeyDeclaration($key.Value);} + | '.ver' major = intOrWildcard ':' minor = intOrWildcard ':' build = intOrWildcard ':' revision = intOrWildcard + {_localctx.Value = Actions.CreateAssemblyVersionDeclaration( + $major.Value, + $minor.Value, + $build.Value, + $revision.Value);} + | '.locale' locale = compQstring + {_localctx.Value = Actions.CreateAssemblyLocaleDeclaration($locale.Value);} + | '.locale' '=' '(' localeBytes = bytes ')' + {_localctx.Value = Actions.CreateAssemblyLocaleDeclaration($localeBytes.Value);} + | attribute = customAttrDecl + {_localctx.Value = Actions.CreateAssemblyCustomAttributeDeclaration( + $attribute.Value, + $attribute.start);} | compControl; -assemblyRefBlock returns [bool HasSyntaxError] -@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +assemblyRefBlock returns [object Value, bool HasSyntaxError] +@init {BeginStreaming(); Actions.BeginSemanticRoot(_localctx);} : - assemblyRefHead '{' assemblyRefDecls '}' + header = assemblyRefHead '{' declarations = assemblyRefDecls '}' + {_localctx.Value = Actions.CreateAssemblyReference( + $header.Value, + $declarations.Value);} ; finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} -assemblyRefHead: - '.assembly' 'extern' asmAttr dottedName - | '.assembly' 'extern' asmAttr dottedName 'as' dottedName; +assemblyRefHead returns [object Value]: + '.assembly' 'extern' attributes = asmAttr name = dottedName + {_localctx.Value = Actions.CreateAssemblyReferenceHeader( + $attributes.Value, + $name.Value, + $name.Value);} + | '.assembly' 'extern' attributes = asmAttr name = dottedName 'as' alias = dottedName + {_localctx.Value = Actions.CreateAssemblyReferenceHeader( + $attributes.Value, + $name.Value, + $alias.Value);}; -assemblyRefDecls: assemblyRefDecl*; +assemblyRefDecls returns [object Value] +@init {Actions.BeginAssemblyReferenceDeclarations(_localctx);} +: + (declaration = assemblyRefDecl + {Actions.AddAssemblyReferenceDeclaration(_localctx, $declaration.Value);})* +; +finally {_localctx.Value = Actions.EndAssemblyReferenceDeclarations(_localctx);} -assemblyRefDecl: - '.hash' '=' '(' bytes ')' - | asmOrRefDecl - | '.publickeytoken' '=' '(' bytes ')' - | 'auto'; +assemblyRefDecl returns [object Value]: + '.hash' '=' '(' hash = bytes ')' + {_localctx.Value = Actions.CreateAssemblyReferenceHashDeclaration($hash.Value);} + | shared = asmOrRefDecl {_localctx.Value = $shared.Value;} + | '.publickeytoken' '=' '(' token = bytes ')' + {_localctx.Value = Actions.CreateAssemblyReferencePublicKeyTokenDeclaration($token.Value);} + | 'auto' {_localctx.Value = Actions.CreateAssemblyReferenceAutoDeclaration();}; -exptypeBlock returns [bool HasSyntaxError] -@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +exptypeBlock returns [object Value, bool HasSyntaxError] +@init {BeginStreaming(); Actions.BeginSemanticRoot(_localctx);} : - exptypeHead '{' exptypeDecls '}' + header = exptypeHead '{' declarations = exptypeDecls '}' + {_localctx.Value = Actions.CreateExportedType( + $header.Value, + $declarations.Value, + $header.start);} ; finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} -exptypeHead: '.class' 'extern' exptAttr* dottedName; +exptypeHead returns [object Value]: + head = '.class' 'extern' attributes = exptAttrs name = dottedName + {_localctx.Value = Actions.CreateExportedTypeHeader( + $attributes.Value, + $name.Value, + $head);}; + +exportHead returns [object Value]: + head = '.export' attributes = exptAttrs name = dottedName + {_localctx.Value = Actions.CreateExportedTypeHeader( + $attributes.Value, + $name.Value, + $head);}; -exportHead: '.export' exptAttr* dottedName; +exptAttrs returns [System.Reflection.TypeAttributes Value] +@init {_localctx.Value = 0;} +: + (attribute = exptAttr + {_localctx.Value = Actions.AddExportedTypeAttribute( + _localctx.Value, + $attribute.Value, + $attribute.Mask);})* +; -exptAttr: +exptAttr returns [System.Reflection.TypeAttributes Value, System.Reflection.TypeAttributes Mask] +@after {Actions.SetExportedTypeAttribute(_localctx);} +: 'private' | 'public' | 'forwarder' @@ -2123,34 +2244,98 @@ exptAttr: | 'nested' 'famandassem' | 'nested' 'famorassem'; -exptypeDecls: exptypeDecl*; +exptypeDecls returns [object Value] +@init {Actions.BeginExportedTypeDeclarations(_localctx);} +: + (declaration = exptypeDecl + {Actions.AddExportedTypeDeclaration(_localctx, $declaration.Value);})* +; +finally {_localctx.Value = Actions.EndExportedTypeDeclarations(_localctx);} -exptypeDecl: - '.file' dottedName - | '.class' 'extern' slashedName - | '.assembly' 'extern' dottedName - | mdtoken - | '.class' int32 - | customAttrDecl +exptypeDecl returns [object Value]: + location = '.file' name = dottedName + {_localctx.Value = Actions.CreateExportedTypeFileDeclaration( + $name.Value, + $location);} + | location = '.class' 'extern' nestedName = slashedName + {_localctx.Value = Actions.CreateNestedExportedTypeDeclaration( + $nestedName.Value, + $location);} + | location = '.assembly' 'extern' assemblyName = dottedName + {_localctx.Value = Actions.CreateExportedTypeAssemblyDeclaration( + $assemblyName.Value, + $location);} + | token = mdtoken + {_localctx.Value = Actions.CreateExportedTypeMetadataTokenDeclaration( + $token.Value, + $token.start);} + | '.class' typeDefinitionId = int32 + {_localctx.Value = Actions.CreateExportedTypeDefinitionIdDeclaration( + $typeDefinitionId.start);} + | attribute = customAttrDecl + {_localctx.Value = Actions.CreateExportedTypeCustomAttributeDeclaration( + $attribute.Value, + $attribute.start);} | compControl; -manifestResBlock returns [bool HasSyntaxError] -@init {BeginSubtree(); Actions.BeginSemanticRoot(_localctx);} +manifestResBlock returns [object Value, bool HasSyntaxError] +@init {BeginStreaming(); Actions.BeginSemanticRoot(_localctx);} : - manifestResHead '{' manifestResDecls '}' + header = manifestResHead '{' declarations = manifestResDecls '}' + {_localctx.Value = Actions.CreateManifestResource( + $header.Value, + $declarations.Value, + $header.start);} ; finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} -manifestResHead: - MRESOURCE manresAttr* dottedName - | MRESOURCE manresAttr* dottedName 'as' dottedName; +manifestResHead returns [object Value]: + head = MRESOURCE attributes = manresAttrs name = dottedName + {_localctx.Value = Actions.CreateManifestResourceHeader( + $attributes.Value, + $name.Value, + $name.Value, + $head);} + | head = MRESOURCE attributes = manresAttrs name = dottedName 'as' alias = dottedName + {_localctx.Value = Actions.CreateManifestResourceHeader( + $attributes.Value, + $name.Value, + $alias.Value, + $head);}; -manresAttr: 'public' | 'private'; +manresAttrs returns [System.Reflection.ManifestResourceAttributes Value] +@init {_localctx.Value = 0;} +: + (attribute = manresAttr + {_localctx.Value = Actions.AddManifestResourceAttribute( + _localctx.Value, + $attribute.Value);})* +; -manifestResDecls: manifestResDecl*; +manresAttr returns [System.Reflection.ManifestResourceAttributes Value] +@after {_localctx.Value = Actions.ParseManifestResourceAttribute(_localctx.Start);} +: + 'public' + | 'private'; -manifestResDecl: - '.file' dottedName 'at' int32 - | '.assembly' 'extern' dottedName - | customAttrDecl +manifestResDecls returns [object Value] +@init {Actions.BeginManifestResourceDeclarations(_localctx);} +: + (declaration = manifestResDecl + {Actions.AddManifestResourceDeclaration(_localctx, $declaration.Value);})* +; +finally {_localctx.Value = Actions.EndManifestResourceDeclarations(_localctx);} + +manifestResDecl returns [object Value]: + location = '.file' name = dottedName 'at' offset = int32 + {_localctx.Value = Actions.CreateManifestResourceFileDeclaration( + $name.Value, + $offset.start, + $location);} + | '.assembly' 'extern' name = dottedName + {_localctx.Value = Actions.CreateManifestResourceAssemblyDeclaration($name.Value);} + | attribute = customAttrDecl + {_localctx.Value = Actions.CreateManifestResourceCustomAttributeDeclaration( + $attribute.Value, + $attribute.start);} | compControl; diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.interp b/src/tools/ilasm/src/ILAssembler/gen/CIL.interp index 0755f16acc7c1f..d188d340c27b70 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.interp +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.interp @@ -650,6 +650,7 @@ serializTypeElement moduleHead vtfixupDecl vtfixupAttr +vtfixupAttrElement vtableDecl nameSpaceHead classHead @@ -789,15 +790,17 @@ assemblyRefDecl exptypeBlock exptypeHead exportHead +exptAttrs exptAttr exptypeDecls exptypeDecl manifestResBlock manifestResHead +manresAttrs manresAttr manifestResDecls manifestResDecl atn: -[4, 1, 305, 3631, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 373, 8, 1, 10, 1, 12, 1, 376, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 383, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 5, 3, 390, 8, 3, 10, 3, 12, 3, 393, 9, 3, 1, 3, 1, 3, 1, 3, 1, 4, 5, 4, 399, 8, 4, 10, 4, 12, 4, 402, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 490, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 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, 540, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 5, 15, 549, 8, 15, 10, 15, 12, 15, 552, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 581, 8, 18, 1, 19, 1, 19, 3, 19, 585, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 603, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 630, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 658, 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, 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, 698, 8, 23, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 709, 8, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 5, 27, 719, 8, 27, 10, 27, 12, 27, 722, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 732, 8, 28, 10, 28, 12, 28, 735, 9, 28, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 3, 30, 742, 8, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 764, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 777, 8, 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, 34, 1, 34, 1, 34, 1, 34, 5, 34, 798, 8, 34, 10, 34, 12, 34, 801, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 5, 37, 817, 8, 37, 10, 37, 12, 37, 820, 9, 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, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 892, 8, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 899, 8, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 906, 8, 40, 1, 41, 5, 41, 909, 8, 41, 10, 41, 12, 41, 912, 9, 41, 1, 42, 1, 42, 1, 42, 1, 42, 5, 42, 918, 8, 42, 10, 42, 12, 42, 921, 9, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 3, 44, 931, 8, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 940, 8, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 951, 8, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 962, 8, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 975, 8, 44, 1, 44, 1, 44, 3, 44, 979, 8, 44, 1, 45, 1, 45, 5, 45, 983, 8, 45, 10, 45, 12, 45, 986, 9, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 5, 45, 999, 8, 45, 10, 45, 12, 45, 1002, 9, 45, 1, 45, 1, 45, 1, 45, 3, 45, 1007, 8, 45, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 1013, 8, 47, 1, 48, 1, 48, 1, 49, 5, 49, 1018, 8, 49, 10, 49, 12, 49, 1021, 9, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 1048, 8, 50, 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, 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, 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, 1126, 8, 51, 3, 51, 1128, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1142, 8, 53, 1, 53, 1, 53, 5, 53, 1146, 8, 53, 10, 53, 12, 53, 1149, 9, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1157, 8, 53, 3, 53, 1159, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1166, 8, 54, 10, 54, 12, 54, 1169, 9, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1180, 8, 55, 10, 55, 12, 55, 1183, 9, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 5, 56, 1194, 8, 56, 10, 56, 12, 56, 1197, 9, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1204, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 1212, 8, 57, 1, 57, 1, 57, 3, 57, 1216, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1255, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 1261, 8, 59, 10, 59, 12, 59, 1264, 9, 59, 1, 59, 1, 59, 1, 59, 1, 60, 5, 60, 1270, 8, 60, 10, 60, 12, 60, 1273, 9, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1280, 8, 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, 3, 62, 1299, 8, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 5, 63, 1307, 8, 63, 10, 63, 12, 63, 1310, 9, 63, 3, 63, 1312, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 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, 1336, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1483, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1493, 8, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 5, 67, 1500, 8, 67, 10, 67, 12, 67, 1503, 9, 67, 3, 67, 1505, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1587, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 5, 69, 1594, 8, 69, 10, 69, 12, 69, 1597, 9, 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, 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, 1628, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1688, 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, 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, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1728, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1744, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1754, 8, 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, 3, 76, 1784, 8, 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, 1812, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 5, 77, 1819, 8, 77, 10, 77, 12, 77, 1822, 9, 77, 1, 77, 1, 77, 1, 77, 3, 77, 1827, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1844, 8, 78, 1, 79, 1, 79, 1, 79, 1, 79, 5, 79, 1850, 8, 79, 10, 79, 12, 79, 1853, 9, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1910, 8, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1920, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1938, 8, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 1956, 8, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1975, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1996, 8, 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, 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 2015, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 2030, 8, 89, 1, 90, 1, 90, 1, 90, 1, 90, 5, 90, 2036, 8, 90, 10, 90, 12, 90, 2039, 9, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 2050, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 2070, 8, 92, 1, 93, 1, 93, 1, 93, 5, 93, 2075, 8, 93, 10, 93, 12, 93, 2078, 9, 93, 1, 94, 1, 94, 3, 94, 2082, 8, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 5, 95, 2091, 8, 95, 10, 95, 12, 95, 2094, 9, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 3, 97, 2105, 8, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2213, 8, 99, 10, 99, 12, 99, 2216, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2225, 8, 99, 10, 99, 12, 99, 2228, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2241, 8, 99, 10, 99, 12, 99, 2244, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 5, 99, 2255, 8, 99, 10, 99, 12, 99, 2258, 9, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 3, 99, 2266, 8, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 2279, 8, 100, 10, 100, 12, 100, 2282, 9, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 2324, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 2335, 8, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 3, 103, 2342, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 2350, 8, 104, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2356, 8, 105, 10, 105, 12, 105, 2359, 9, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2369, 8, 105, 10, 105, 12, 105, 2372, 9, 105, 1, 105, 1, 105, 1, 105, 3, 105, 2377, 8, 105, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 2383, 8, 106, 1, 107, 5, 107, 2386, 8, 107, 10, 107, 12, 107, 2389, 9, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 2417, 8, 108, 1, 109, 1, 109, 1, 109, 1, 109, 5, 109, 2423, 8, 109, 10, 109, 12, 109, 2426, 9, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 2439, 8, 110, 1, 111, 5, 111, 2442, 8, 111, 10, 111, 12, 111, 2445, 9, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 2469, 8, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 2478, 8, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 4, 114, 2487, 8, 114, 11, 114, 12, 114, 2488, 1, 114, 1, 114, 3, 114, 2493, 8, 114, 1, 115, 1, 115, 1, 115, 5, 115, 2498, 8, 115, 10, 115, 12, 115, 2501, 9, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 2520, 8, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2529, 8, 117, 10, 117, 12, 117, 2532, 9, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 2544, 8, 117, 10, 117, 12, 117, 2547, 9, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 2593, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2603, 8, 119, 3, 119, 2605, 8, 119, 1, 119, 1, 119, 1, 119, 5, 119, 2610, 8, 119, 10, 119, 12, 119, 2613, 9, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2618, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2662, 8, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 2671, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2711, 8, 122, 1, 123, 5, 123, 2714, 8, 123, 10, 123, 12, 123, 2717, 9, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2756, 8, 124, 1, 125, 1, 125, 3, 125, 2760, 8, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, 2770, 8, 126, 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, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 2792, 8, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2802, 8, 129, 10, 129, 12, 129, 2805, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2813, 8, 129, 10, 129, 12, 129, 2816, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2828, 8, 129, 10, 129, 12, 129, 2831, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2841, 8, 129, 10, 129, 12, 129, 2844, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2854, 8, 129, 10, 129, 12, 129, 2857, 9, 129, 3, 129, 2859, 8, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 2871, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 4, 134, 2883, 8, 134, 11, 134, 12, 134, 2884, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 3, 135, 2903, 8, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 3, 136, 2921, 8, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 2935, 8, 137, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 2959, 8, 141, 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, 3, 143, 2974, 8, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 3, 144, 2981, 8, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 4, 145, 2988, 8, 145, 11, 145, 12, 145, 2989, 3, 145, 2992, 8, 145, 1, 146, 1, 146, 1, 146, 5, 146, 2997, 8, 146, 10, 146, 12, 146, 3000, 9, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 3010, 8, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 3, 148, 3060, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 3152, 8, 149, 1, 150, 1, 150, 1, 150, 5, 150, 3157, 8, 150, 10, 150, 12, 150, 3160, 9, 150, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 3, 152, 3172, 8, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 3, 153, 3345, 8, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 5, 154, 3353, 8, 154, 10, 154, 12, 154, 3356, 9, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 5, 155, 3364, 8, 155, 10, 155, 12, 155, 3367, 9, 155, 1, 156, 1, 156, 1, 156, 5, 156, 3372, 8, 156, 10, 156, 12, 156, 3375, 9, 156, 1, 157, 1, 157, 1, 157, 5, 157, 3380, 8, 157, 10, 157, 12, 157, 3383, 9, 157, 1, 158, 1, 158, 1, 158, 5, 158, 3388, 8, 158, 10, 158, 12, 158, 3391, 9, 158, 1, 159, 1, 159, 1, 159, 5, 159, 3396, 8, 159, 10, 159, 12, 159, 3399, 9, 159, 1, 160, 1, 160, 1, 160, 5, 160, 3404, 8, 160, 10, 160, 12, 160, 3407, 9, 160, 1, 161, 1, 161, 1, 161, 1, 161, 5, 161, 3413, 8, 161, 10, 161, 12, 161, 3416, 9, 161, 1, 162, 1, 162, 1, 162, 5, 162, 3421, 8, 162, 10, 162, 12, 162, 3424, 9, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 3434, 8, 163, 1, 164, 1, 164, 1, 164, 5, 164, 3439, 8, 164, 10, 164, 12, 164, 3442, 9, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 3, 165, 3453, 8, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 3, 166, 3480, 8, 166, 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, 168, 3, 168, 3499, 8, 168, 1, 169, 5, 169, 3502, 8, 169, 10, 169, 12, 169, 3505, 9, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 3521, 8, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 5, 172, 3531, 8, 172, 10, 172, 12, 172, 3534, 9, 172, 1, 172, 1, 172, 1, 173, 1, 173, 5, 173, 3540, 8, 173, 10, 173, 12, 173, 3543, 9, 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, 3, 174, 3562, 8, 174, 1, 175, 5, 175, 3565, 8, 175, 10, 175, 12, 175, 3568, 9, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 3, 176, 3583, 8, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 178, 1, 178, 5, 178, 3592, 8, 178, 10, 178, 12, 178, 3595, 9, 178, 1, 178, 1, 178, 1, 178, 5, 178, 3600, 8, 178, 10, 178, 12, 178, 3603, 9, 178, 1, 178, 1, 178, 1, 178, 1, 178, 3, 178, 3609, 8, 178, 1, 179, 1, 179, 1, 180, 5, 180, 3614, 8, 180, 10, 180, 12, 180, 3617, 9, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 3, 181, 3629, 8, 181, 1, 181, 0, 1, 68, 182, 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, 0, 16, 6, 0, 1, 15, 199, 199, 243, 243, 247, 247, 264, 264, 289, 289, 5, 0, 16, 16, 199, 199, 243, 243, 264, 264, 288, 289, 1, 0, 263, 264, 1, 0, 173, 174, 1, 0, 37, 38, 1, 0, 73, 74, 3, 0, 2, 2, 61, 61, 77, 83, 2, 0, 229, 229, 260, 261, 1, 0, 95, 96, 1, 0, 97, 111, 1, 0, 188, 189, 1, 0, 184, 186, 1, 0, 184, 189, 2, 0, 173, 173, 289, 290, 1, 0, 167, 168, 1, 0, 51, 52, 4080, 0, 364, 1, 0, 0, 0, 2, 382, 1, 0, 0, 0, 4, 384, 1, 0, 0, 0, 6, 391, 1, 0, 0, 0, 8, 400, 1, 0, 0, 0, 10, 489, 1, 0, 0, 0, 12, 491, 1, 0, 0, 0, 14, 495, 1, 0, 0, 0, 16, 499, 1, 0, 0, 0, 18, 504, 1, 0, 0, 0, 20, 508, 1, 0, 0, 0, 22, 512, 1, 0, 0, 0, 24, 519, 1, 0, 0, 0, 26, 539, 1, 0, 0, 0, 28, 541, 1, 0, 0, 0, 30, 543, 1, 0, 0, 0, 32, 555, 1, 0, 0, 0, 34, 557, 1, 0, 0, 0, 36, 580, 1, 0, 0, 0, 38, 584, 1, 0, 0, 0, 40, 602, 1, 0, 0, 0, 42, 629, 1, 0, 0, 0, 44, 657, 1, 0, 0, 0, 46, 697, 1, 0, 0, 0, 48, 699, 1, 0, 0, 0, 50, 708, 1, 0, 0, 0, 52, 710, 1, 0, 0, 0, 54, 720, 1, 0, 0, 0, 56, 733, 1, 0, 0, 0, 58, 736, 1, 0, 0, 0, 60, 739, 1, 0, 0, 0, 62, 763, 1, 0, 0, 0, 64, 776, 1, 0, 0, 0, 66, 778, 1, 0, 0, 0, 68, 786, 1, 0, 0, 0, 70, 802, 1, 0, 0, 0, 72, 808, 1, 0, 0, 0, 74, 812, 1, 0, 0, 0, 76, 891, 1, 0, 0, 0, 78, 898, 1, 0, 0, 0, 80, 905, 1, 0, 0, 0, 82, 910, 1, 0, 0, 0, 84, 919, 1, 0, 0, 0, 86, 925, 1, 0, 0, 0, 88, 978, 1, 0, 0, 0, 90, 1006, 1, 0, 0, 0, 92, 1008, 1, 0, 0, 0, 94, 1012, 1, 0, 0, 0, 96, 1014, 1, 0, 0, 0, 98, 1019, 1, 0, 0, 0, 100, 1047, 1, 0, 0, 0, 102, 1127, 1, 0, 0, 0, 104, 1129, 1, 0, 0, 0, 106, 1158, 1, 0, 0, 0, 108, 1160, 1, 0, 0, 0, 110, 1174, 1, 0, 0, 0, 112, 1203, 1, 0, 0, 0, 114, 1215, 1, 0, 0, 0, 116, 1254, 1, 0, 0, 0, 118, 1262, 1, 0, 0, 0, 120, 1271, 1, 0, 0, 0, 122, 1279, 1, 0, 0, 0, 124, 1298, 1, 0, 0, 0, 126, 1311, 1, 0, 0, 0, 128, 1335, 1, 0, 0, 0, 130, 1482, 1, 0, 0, 0, 132, 1492, 1, 0, 0, 0, 134, 1504, 1, 0, 0, 0, 136, 1586, 1, 0, 0, 0, 138, 1588, 1, 0, 0, 0, 140, 1627, 1, 0, 0, 0, 142, 1687, 1, 0, 0, 0, 144, 1727, 1, 0, 0, 0, 146, 1743, 1, 0, 0, 0, 148, 1745, 1, 0, 0, 0, 150, 1749, 1, 0, 0, 0, 152, 1811, 1, 0, 0, 0, 154, 1826, 1, 0, 0, 0, 156, 1843, 1, 0, 0, 0, 158, 1851, 1, 0, 0, 0, 160, 1857, 1, 0, 0, 0, 162, 1862, 1, 0, 0, 0, 164, 1909, 1, 0, 0, 0, 166, 1911, 1, 0, 0, 0, 168, 1955, 1, 0, 0, 0, 170, 1974, 1, 0, 0, 0, 172, 1995, 1, 0, 0, 0, 174, 1997, 1, 0, 0, 0, 176, 2014, 1, 0, 0, 0, 178, 2029, 1, 0, 0, 0, 180, 2037, 1, 0, 0, 0, 182, 2049, 1, 0, 0, 0, 184, 2069, 1, 0, 0, 0, 186, 2076, 1, 0, 0, 0, 188, 2079, 1, 0, 0, 0, 190, 2092, 1, 0, 0, 0, 192, 2098, 1, 0, 0, 0, 194, 2104, 1, 0, 0, 0, 196, 2108, 1, 0, 0, 0, 198, 2265, 1, 0, 0, 0, 200, 2267, 1, 0, 0, 0, 202, 2323, 1, 0, 0, 0, 204, 2334, 1, 0, 0, 0, 206, 2341, 1, 0, 0, 0, 208, 2349, 1, 0, 0, 0, 210, 2376, 1, 0, 0, 0, 212, 2382, 1, 0, 0, 0, 214, 2387, 1, 0, 0, 0, 216, 2416, 1, 0, 0, 0, 218, 2418, 1, 0, 0, 0, 220, 2438, 1, 0, 0, 0, 222, 2443, 1, 0, 0, 0, 224, 2468, 1, 0, 0, 0, 226, 2477, 1, 0, 0, 0, 228, 2492, 1, 0, 0, 0, 230, 2499, 1, 0, 0, 0, 232, 2519, 1, 0, 0, 0, 234, 2521, 1, 0, 0, 0, 236, 2592, 1, 0, 0, 0, 238, 2617, 1, 0, 0, 0, 240, 2661, 1, 0, 0, 0, 242, 2670, 1, 0, 0, 0, 244, 2710, 1, 0, 0, 0, 246, 2715, 1, 0, 0, 0, 248, 2755, 1, 0, 0, 0, 250, 2757, 1, 0, 0, 0, 252, 2763, 1, 0, 0, 0, 254, 2771, 1, 0, 0, 0, 256, 2791, 1, 0, 0, 0, 258, 2858, 1, 0, 0, 0, 260, 2860, 1, 0, 0, 0, 262, 2870, 1, 0, 0, 0, 264, 2872, 1, 0, 0, 0, 266, 2876, 1, 0, 0, 0, 268, 2882, 1, 0, 0, 0, 270, 2902, 1, 0, 0, 0, 272, 2920, 1, 0, 0, 0, 274, 2934, 1, 0, 0, 0, 276, 2936, 1, 0, 0, 0, 278, 2939, 1, 0, 0, 0, 280, 2941, 1, 0, 0, 0, 282, 2958, 1, 0, 0, 0, 284, 2960, 1, 0, 0, 0, 286, 2973, 1, 0, 0, 0, 288, 2980, 1, 0, 0, 0, 290, 2991, 1, 0, 0, 0, 292, 2998, 1, 0, 0, 0, 294, 3009, 1, 0, 0, 0, 296, 3059, 1, 0, 0, 0, 298, 3151, 1, 0, 0, 0, 300, 3158, 1, 0, 0, 0, 302, 3161, 1, 0, 0, 0, 304, 3171, 1, 0, 0, 0, 306, 3344, 1, 0, 0, 0, 308, 3354, 1, 0, 0, 0, 310, 3365, 1, 0, 0, 0, 312, 3373, 1, 0, 0, 0, 314, 3381, 1, 0, 0, 0, 316, 3389, 1, 0, 0, 0, 318, 3397, 1, 0, 0, 0, 320, 3405, 1, 0, 0, 0, 322, 3414, 1, 0, 0, 0, 324, 3422, 1, 0, 0, 0, 326, 3433, 1, 0, 0, 0, 328, 3440, 1, 0, 0, 0, 330, 3452, 1, 0, 0, 0, 332, 3479, 1, 0, 0, 0, 334, 3481, 1, 0, 0, 0, 336, 3498, 1, 0, 0, 0, 338, 3503, 1, 0, 0, 0, 340, 3520, 1, 0, 0, 0, 342, 3522, 1, 0, 0, 0, 344, 3527, 1, 0, 0, 0, 346, 3537, 1, 0, 0, 0, 348, 3561, 1, 0, 0, 0, 350, 3566, 1, 0, 0, 0, 352, 3582, 1, 0, 0, 0, 354, 3584, 1, 0, 0, 0, 356, 3608, 1, 0, 0, 0, 358, 3610, 1, 0, 0, 0, 360, 3615, 1, 0, 0, 0, 362, 3628, 1, 0, 0, 0, 364, 365, 7, 0, 0, 0, 365, 1, 1, 0, 0, 0, 366, 367, 5, 288, 0, 0, 367, 383, 6, 1, -1, 0, 368, 369, 3, 4, 2, 0, 369, 370, 6, 1, -1, 0, 370, 371, 5, 265, 0, 0, 371, 373, 1, 0, 0, 0, 372, 368, 1, 0, 0, 0, 373, 376, 1, 0, 0, 0, 374, 372, 1, 0, 0, 0, 374, 375, 1, 0, 0, 0, 375, 377, 1, 0, 0, 0, 376, 374, 1, 0, 0, 0, 377, 378, 3, 4, 2, 0, 378, 379, 6, 1, -1, 0, 379, 383, 1, 0, 0, 0, 380, 381, 5, 264, 0, 0, 381, 383, 6, 1, -1, 0, 382, 366, 1, 0, 0, 0, 382, 374, 1, 0, 0, 0, 382, 380, 1, 0, 0, 0, 383, 3, 1, 0, 0, 0, 384, 385, 7, 1, 0, 0, 385, 5, 1, 0, 0, 0, 386, 387, 5, 263, 0, 0, 387, 388, 6, 3, -1, 0, 388, 390, 5, 266, 0, 0, 389, 386, 1, 0, 0, 0, 390, 393, 1, 0, 0, 0, 391, 389, 1, 0, 0, 0, 391, 392, 1, 0, 0, 0, 392, 394, 1, 0, 0, 0, 393, 391, 1, 0, 0, 0, 394, 395, 5, 263, 0, 0, 395, 396, 6, 3, -1, 0, 396, 7, 1, 0, 0, 0, 397, 399, 3, 10, 5, 0, 398, 397, 1, 0, 0, 0, 399, 402, 1, 0, 0, 0, 400, 398, 1, 0, 0, 0, 400, 401, 1, 0, 0, 0, 401, 9, 1, 0, 0, 0, 402, 400, 1, 0, 0, 0, 403, 404, 3, 74, 37, 0, 404, 405, 5, 17, 0, 0, 405, 406, 3, 82, 41, 0, 406, 407, 5, 18, 0, 0, 407, 490, 1, 0, 0, 0, 408, 409, 3, 72, 36, 0, 409, 410, 5, 17, 0, 0, 410, 411, 3, 8, 4, 0, 411, 412, 5, 18, 0, 0, 412, 490, 1, 0, 0, 0, 413, 414, 3, 234, 117, 0, 414, 415, 5, 17, 0, 0, 415, 416, 3, 246, 123, 0, 416, 417, 5, 18, 0, 0, 417, 490, 1, 0, 0, 0, 418, 490, 3, 200, 100, 0, 419, 420, 6, 5, -1, 0, 420, 421, 3, 284, 142, 0, 421, 422, 6, 5, -1, 0, 422, 490, 1, 0, 0, 0, 423, 424, 6, 5, -1, 0, 424, 425, 3, 70, 35, 0, 425, 426, 6, 5, -1, 0, 426, 490, 1, 0, 0, 0, 427, 428, 6, 5, -1, 0, 428, 429, 3, 66, 33, 0, 429, 430, 6, 5, -1, 0, 430, 490, 1, 0, 0, 0, 431, 432, 6, 5, -1, 0, 432, 433, 3, 88, 44, 0, 433, 434, 6, 5, -1, 0, 434, 490, 1, 0, 0, 0, 435, 436, 6, 5, -1, 0, 436, 437, 3, 90, 45, 0, 437, 438, 6, 5, -1, 0, 438, 490, 1, 0, 0, 0, 439, 440, 6, 5, -1, 0, 440, 441, 3, 22, 11, 0, 441, 442, 6, 5, -1, 0, 442, 490, 1, 0, 0, 0, 443, 444, 6, 5, -1, 0, 444, 445, 3, 334, 167, 0, 445, 446, 6, 5, -1, 0, 446, 490, 1, 0, 0, 0, 447, 448, 6, 5, -1, 0, 448, 449, 3, 342, 171, 0, 449, 450, 6, 5, -1, 0, 450, 490, 1, 0, 0, 0, 451, 452, 6, 5, -1, 0, 452, 453, 3, 354, 177, 0, 453, 454, 6, 5, -1, 0, 454, 490, 1, 0, 0, 0, 455, 456, 6, 5, -1, 0, 456, 457, 3, 64, 32, 0, 457, 458, 6, 5, -1, 0, 458, 490, 1, 0, 0, 0, 459, 460, 6, 5, -1, 0, 460, 461, 3, 152, 76, 0, 461, 462, 6, 5, -1, 0, 462, 490, 1, 0, 0, 0, 463, 464, 3, 330, 165, 0, 464, 465, 6, 5, -1, 0, 465, 490, 1, 0, 0, 0, 466, 467, 6, 5, -1, 0, 467, 490, 3, 12, 6, 0, 468, 469, 6, 5, -1, 0, 469, 490, 3, 14, 7, 0, 470, 471, 6, 5, -1, 0, 471, 490, 3, 16, 8, 0, 472, 473, 6, 5, -1, 0, 473, 490, 3, 18, 9, 0, 474, 475, 6, 5, -1, 0, 475, 490, 3, 20, 10, 0, 476, 477, 6, 5, -1, 0, 477, 478, 3, 26, 13, 0, 478, 479, 6, 5, -1, 0, 479, 490, 1, 0, 0, 0, 480, 481, 6, 5, -1, 0, 481, 482, 3, 42, 21, 0, 482, 483, 6, 5, -1, 0, 483, 490, 1, 0, 0, 0, 484, 485, 6, 5, -1, 0, 485, 490, 3, 40, 20, 0, 486, 490, 3, 30, 15, 0, 487, 488, 6, 5, -1, 0, 488, 490, 3, 24, 12, 0, 489, 403, 1, 0, 0, 0, 489, 408, 1, 0, 0, 0, 489, 413, 1, 0, 0, 0, 489, 418, 1, 0, 0, 0, 489, 419, 1, 0, 0, 0, 489, 423, 1, 0, 0, 0, 489, 427, 1, 0, 0, 0, 489, 431, 1, 0, 0, 0, 489, 435, 1, 0, 0, 0, 489, 439, 1, 0, 0, 0, 489, 443, 1, 0, 0, 0, 489, 447, 1, 0, 0, 0, 489, 451, 1, 0, 0, 0, 489, 455, 1, 0, 0, 0, 489, 459, 1, 0, 0, 0, 489, 463, 1, 0, 0, 0, 489, 466, 1, 0, 0, 0, 489, 468, 1, 0, 0, 0, 489, 470, 1, 0, 0, 0, 489, 472, 1, 0, 0, 0, 489, 474, 1, 0, 0, 0, 489, 476, 1, 0, 0, 0, 489, 480, 1, 0, 0, 0, 489, 484, 1, 0, 0, 0, 489, 486, 1, 0, 0, 0, 489, 487, 1, 0, 0, 0, 490, 11, 1, 0, 0, 0, 491, 492, 5, 19, 0, 0, 492, 493, 3, 32, 16, 0, 493, 494, 6, 6, -1, 0, 494, 13, 1, 0, 0, 0, 495, 496, 5, 20, 0, 0, 496, 497, 3, 32, 16, 0, 497, 498, 6, 7, -1, 0, 498, 15, 1, 0, 0, 0, 499, 500, 5, 21, 0, 0, 500, 501, 5, 22, 0, 0, 501, 502, 3, 32, 16, 0, 502, 503, 6, 8, -1, 0, 503, 17, 1, 0, 0, 0, 504, 505, 5, 23, 0, 0, 505, 506, 3, 34, 17, 0, 506, 507, 6, 9, -1, 0, 507, 19, 1, 0, 0, 0, 508, 509, 5, 24, 0, 0, 509, 510, 3, 34, 17, 0, 510, 511, 6, 10, -1, 0, 511, 21, 1, 0, 0, 0, 512, 513, 5, 25, 0, 0, 513, 514, 3, 98, 49, 0, 514, 515, 3, 2, 1, 0, 515, 516, 5, 17, 0, 0, 516, 517, 3, 120, 60, 0, 517, 518, 5, 18, 0, 0, 518, 23, 1, 0, 0, 0, 519, 520, 5, 26, 0, 0, 520, 25, 1, 0, 0, 0, 521, 522, 5, 27, 0, 0, 522, 523, 3, 28, 14, 0, 523, 524, 6, 13, -1, 0, 524, 540, 1, 0, 0, 0, 525, 526, 5, 27, 0, 0, 526, 527, 3, 28, 14, 0, 527, 528, 5, 28, 0, 0, 528, 529, 3, 28, 14, 0, 529, 530, 6, 13, -1, 0, 530, 540, 1, 0, 0, 0, 531, 532, 5, 27, 0, 0, 532, 533, 3, 28, 14, 0, 533, 534, 5, 28, 0, 0, 534, 535, 3, 28, 14, 0, 535, 536, 5, 28, 0, 0, 536, 537, 3, 28, 14, 0, 537, 538, 6, 13, -1, 0, 538, 540, 1, 0, 0, 0, 539, 521, 1, 0, 0, 0, 539, 525, 1, 0, 0, 0, 539, 531, 1, 0, 0, 0, 540, 27, 1, 0, 0, 0, 541, 542, 7, 2, 0, 0, 542, 29, 1, 0, 0, 0, 543, 544, 5, 29, 0, 0, 544, 550, 5, 17, 0, 0, 545, 546, 3, 116, 58, 0, 546, 547, 6, 15, -1, 0, 547, 549, 1, 0, 0, 0, 548, 545, 1, 0, 0, 0, 549, 552, 1, 0, 0, 0, 550, 548, 1, 0, 0, 0, 550, 551, 1, 0, 0, 0, 551, 553, 1, 0, 0, 0, 552, 550, 1, 0, 0, 0, 553, 554, 5, 18, 0, 0, 554, 31, 1, 0, 0, 0, 555, 556, 5, 173, 0, 0, 556, 33, 1, 0, 0, 0, 557, 558, 7, 3, 0, 0, 558, 35, 1, 0, 0, 0, 559, 560, 5, 175, 0, 0, 560, 581, 6, 18, -1, 0, 561, 562, 3, 32, 16, 0, 562, 563, 5, 265, 0, 0, 563, 564, 6, 18, -1, 0, 564, 581, 1, 0, 0, 0, 565, 566, 3, 32, 16, 0, 566, 567, 6, 18, -1, 0, 567, 581, 1, 0, 0, 0, 568, 569, 5, 188, 0, 0, 569, 570, 5, 30, 0, 0, 570, 571, 3, 32, 16, 0, 571, 572, 5, 31, 0, 0, 572, 573, 6, 18, -1, 0, 573, 581, 1, 0, 0, 0, 574, 575, 5, 189, 0, 0, 575, 576, 5, 30, 0, 0, 576, 577, 3, 34, 17, 0, 577, 578, 5, 31, 0, 0, 578, 579, 6, 18, -1, 0, 579, 581, 1, 0, 0, 0, 580, 559, 1, 0, 0, 0, 580, 561, 1, 0, 0, 0, 580, 565, 1, 0, 0, 0, 580, 568, 1, 0, 0, 0, 580, 574, 1, 0, 0, 0, 581, 37, 1, 0, 0, 0, 582, 585, 3, 32, 16, 0, 583, 585, 5, 262, 0, 0, 584, 582, 1, 0, 0, 0, 584, 583, 1, 0, 0, 0, 585, 39, 1, 0, 0, 0, 586, 587, 5, 267, 0, 0, 587, 603, 5, 289, 0, 0, 588, 589, 5, 267, 0, 0, 589, 590, 5, 289, 0, 0, 590, 603, 5, 263, 0, 0, 591, 592, 5, 268, 0, 0, 592, 603, 5, 289, 0, 0, 593, 594, 5, 269, 0, 0, 594, 603, 5, 289, 0, 0, 595, 596, 5, 270, 0, 0, 596, 603, 5, 289, 0, 0, 597, 603, 5, 271, 0, 0, 598, 603, 5, 272, 0, 0, 599, 600, 5, 273, 0, 0, 600, 603, 5, 263, 0, 0, 601, 603, 5, 32, 0, 0, 602, 586, 1, 0, 0, 0, 602, 588, 1, 0, 0, 0, 602, 591, 1, 0, 0, 0, 602, 593, 1, 0, 0, 0, 602, 595, 1, 0, 0, 0, 602, 597, 1, 0, 0, 0, 602, 598, 1, 0, 0, 0, 602, 599, 1, 0, 0, 0, 602, 601, 1, 0, 0, 0, 603, 41, 1, 0, 0, 0, 604, 605, 5, 33, 0, 0, 605, 606, 3, 138, 69, 0, 606, 607, 5, 34, 0, 0, 607, 608, 3, 2, 1, 0, 608, 630, 1, 0, 0, 0, 609, 610, 5, 33, 0, 0, 610, 611, 3, 116, 58, 0, 611, 612, 5, 34, 0, 0, 612, 613, 3, 2, 1, 0, 613, 630, 1, 0, 0, 0, 614, 615, 5, 33, 0, 0, 615, 616, 3, 176, 88, 0, 616, 617, 5, 34, 0, 0, 617, 618, 3, 2, 1, 0, 618, 630, 1, 0, 0, 0, 619, 620, 5, 33, 0, 0, 620, 621, 3, 44, 22, 0, 621, 622, 5, 34, 0, 0, 622, 623, 3, 2, 1, 0, 623, 630, 1, 0, 0, 0, 624, 625, 5, 33, 0, 0, 625, 626, 3, 46, 23, 0, 626, 627, 5, 34, 0, 0, 627, 628, 3, 2, 1, 0, 628, 630, 1, 0, 0, 0, 629, 604, 1, 0, 0, 0, 629, 609, 1, 0, 0, 0, 629, 614, 1, 0, 0, 0, 629, 619, 1, 0, 0, 0, 629, 624, 1, 0, 0, 0, 630, 43, 1, 0, 0, 0, 631, 632, 5, 35, 0, 0, 632, 633, 3, 48, 24, 0, 633, 634, 6, 22, -1, 0, 634, 658, 1, 0, 0, 0, 635, 636, 5, 35, 0, 0, 636, 637, 3, 48, 24, 0, 637, 638, 5, 36, 0, 0, 638, 639, 3, 6, 3, 0, 639, 640, 6, 22, -1, 0, 640, 658, 1, 0, 0, 0, 641, 642, 5, 35, 0, 0, 642, 643, 3, 48, 24, 0, 643, 644, 5, 36, 0, 0, 644, 645, 5, 17, 0, 0, 645, 646, 3, 52, 26, 0, 646, 647, 5, 18, 0, 0, 647, 648, 6, 22, -1, 0, 648, 658, 1, 0, 0, 0, 649, 650, 5, 35, 0, 0, 650, 651, 3, 48, 24, 0, 651, 652, 5, 36, 0, 0, 652, 653, 5, 30, 0, 0, 653, 654, 3, 300, 150, 0, 654, 655, 5, 31, 0, 0, 655, 656, 6, 22, -1, 0, 656, 658, 1, 0, 0, 0, 657, 631, 1, 0, 0, 0, 657, 635, 1, 0, 0, 0, 657, 641, 1, 0, 0, 0, 657, 649, 1, 0, 0, 0, 658, 45, 1, 0, 0, 0, 659, 660, 5, 35, 0, 0, 660, 661, 5, 30, 0, 0, 661, 662, 3, 50, 25, 0, 662, 663, 5, 31, 0, 0, 663, 664, 3, 48, 24, 0, 664, 665, 6, 23, -1, 0, 665, 698, 1, 0, 0, 0, 666, 667, 5, 35, 0, 0, 667, 668, 5, 30, 0, 0, 668, 669, 3, 50, 25, 0, 669, 670, 5, 31, 0, 0, 670, 671, 3, 48, 24, 0, 671, 672, 5, 36, 0, 0, 672, 673, 3, 6, 3, 0, 673, 674, 6, 23, -1, 0, 674, 698, 1, 0, 0, 0, 675, 676, 5, 35, 0, 0, 676, 677, 5, 30, 0, 0, 677, 678, 3, 50, 25, 0, 678, 679, 5, 31, 0, 0, 679, 680, 3, 48, 24, 0, 680, 681, 5, 36, 0, 0, 681, 682, 5, 17, 0, 0, 682, 683, 3, 52, 26, 0, 683, 684, 5, 18, 0, 0, 684, 685, 6, 23, -1, 0, 685, 698, 1, 0, 0, 0, 686, 687, 5, 35, 0, 0, 687, 688, 5, 30, 0, 0, 688, 689, 3, 50, 25, 0, 689, 690, 5, 31, 0, 0, 690, 691, 3, 48, 24, 0, 691, 692, 5, 36, 0, 0, 692, 693, 5, 30, 0, 0, 693, 694, 3, 300, 150, 0, 694, 695, 5, 31, 0, 0, 695, 696, 6, 23, -1, 0, 696, 698, 1, 0, 0, 0, 697, 659, 1, 0, 0, 0, 697, 666, 1, 0, 0, 0, 697, 675, 1, 0, 0, 0, 697, 686, 1, 0, 0, 0, 698, 47, 1, 0, 0, 0, 699, 700, 3, 168, 84, 0, 700, 701, 6, 24, -1, 0, 701, 49, 1, 0, 0, 0, 702, 703, 3, 124, 62, 0, 703, 704, 6, 25, -1, 0, 704, 709, 1, 0, 0, 0, 705, 706, 3, 176, 88, 0, 706, 707, 6, 25, -1, 0, 707, 709, 1, 0, 0, 0, 708, 702, 1, 0, 0, 0, 708, 705, 1, 0, 0, 0, 709, 51, 1, 0, 0, 0, 710, 711, 3, 54, 27, 0, 711, 712, 3, 56, 28, 0, 712, 713, 6, 26, -1, 0, 713, 53, 1, 0, 0, 0, 714, 715, 3, 306, 153, 0, 715, 716, 6, 27, -1, 0, 716, 719, 1, 0, 0, 0, 717, 719, 3, 40, 20, 0, 718, 714, 1, 0, 0, 0, 718, 717, 1, 0, 0, 0, 719, 722, 1, 0, 0, 0, 720, 718, 1, 0, 0, 0, 720, 721, 1, 0, 0, 0, 721, 55, 1, 0, 0, 0, 722, 720, 1, 0, 0, 0, 723, 724, 3, 58, 29, 0, 724, 725, 3, 60, 30, 0, 725, 726, 3, 2, 1, 0, 726, 727, 5, 36, 0, 0, 727, 728, 3, 306, 153, 0, 728, 729, 6, 28, -1, 0, 729, 732, 1, 0, 0, 0, 730, 732, 3, 40, 20, 0, 731, 723, 1, 0, 0, 0, 731, 730, 1, 0, 0, 0, 732, 735, 1, 0, 0, 0, 733, 731, 1, 0, 0, 0, 733, 734, 1, 0, 0, 0, 734, 57, 1, 0, 0, 0, 735, 733, 1, 0, 0, 0, 736, 737, 7, 4, 0, 0, 737, 738, 6, 29, -1, 0, 738, 59, 1, 0, 0, 0, 739, 741, 3, 62, 31, 0, 740, 742, 5, 261, 0, 0, 741, 740, 1, 0, 0, 0, 741, 742, 1, 0, 0, 0, 742, 743, 1, 0, 0, 0, 743, 744, 6, 30, -1, 0, 744, 61, 1, 0, 0, 0, 745, 746, 3, 144, 72, 0, 746, 747, 6, 31, -1, 0, 747, 764, 1, 0, 0, 0, 748, 749, 3, 2, 1, 0, 749, 750, 6, 31, -1, 0, 750, 764, 1, 0, 0, 0, 751, 752, 5, 196, 0, 0, 752, 764, 6, 31, -1, 0, 753, 754, 5, 197, 0, 0, 754, 764, 6, 31, -1, 0, 755, 756, 5, 202, 0, 0, 756, 757, 5, 39, 0, 0, 757, 758, 5, 264, 0, 0, 758, 764, 6, 31, -1, 0, 759, 760, 5, 202, 0, 0, 760, 761, 3, 116, 58, 0, 761, 762, 6, 31, -1, 0, 762, 764, 1, 0, 0, 0, 763, 745, 1, 0, 0, 0, 763, 748, 1, 0, 0, 0, 763, 751, 1, 0, 0, 0, 763, 753, 1, 0, 0, 0, 763, 755, 1, 0, 0, 0, 763, 759, 1, 0, 0, 0, 764, 63, 1, 0, 0, 0, 765, 766, 5, 198, 0, 0, 766, 767, 5, 40, 0, 0, 767, 768, 3, 2, 1, 0, 768, 769, 6, 32, -1, 0, 769, 777, 1, 0, 0, 0, 770, 771, 5, 198, 0, 0, 771, 772, 3, 2, 1, 0, 772, 773, 6, 32, -1, 0, 773, 777, 1, 0, 0, 0, 774, 775, 5, 198, 0, 0, 775, 777, 6, 32, -1, 0, 776, 765, 1, 0, 0, 0, 776, 770, 1, 0, 0, 0, 776, 774, 1, 0, 0, 0, 777, 65, 1, 0, 0, 0, 778, 779, 5, 41, 0, 0, 779, 780, 5, 42, 0, 0, 780, 781, 3, 32, 16, 0, 781, 782, 5, 43, 0, 0, 782, 783, 3, 68, 34, 0, 783, 784, 5, 44, 0, 0, 784, 785, 3, 0, 0, 0, 785, 67, 1, 0, 0, 0, 786, 799, 6, 34, -1, 0, 787, 788, 10, 5, 0, 0, 788, 798, 5, 186, 0, 0, 789, 790, 10, 4, 0, 0, 790, 798, 5, 187, 0, 0, 791, 792, 10, 3, 0, 0, 792, 798, 5, 45, 0, 0, 793, 794, 10, 2, 0, 0, 794, 798, 5, 46, 0, 0, 795, 796, 10, 1, 0, 0, 796, 798, 5, 47, 0, 0, 797, 787, 1, 0, 0, 0, 797, 789, 1, 0, 0, 0, 797, 791, 1, 0, 0, 0, 797, 793, 1, 0, 0, 0, 797, 795, 1, 0, 0, 0, 798, 801, 1, 0, 0, 0, 799, 797, 1, 0, 0, 0, 799, 800, 1, 0, 0, 0, 800, 69, 1, 0, 0, 0, 801, 799, 1, 0, 0, 0, 802, 803, 5, 48, 0, 0, 803, 804, 5, 36, 0, 0, 804, 805, 5, 30, 0, 0, 805, 806, 3, 300, 150, 0, 806, 807, 5, 31, 0, 0, 807, 71, 1, 0, 0, 0, 808, 809, 5, 49, 0, 0, 809, 810, 3, 2, 1, 0, 810, 811, 6, 36, -1, 0, 811, 73, 1, 0, 0, 0, 812, 818, 5, 50, 0, 0, 813, 814, 3, 76, 38, 0, 814, 815, 6, 37, -1, 0, 815, 817, 1, 0, 0, 0, 816, 813, 1, 0, 0, 0, 817, 820, 1, 0, 0, 0, 818, 816, 1, 0, 0, 0, 818, 819, 1, 0, 0, 0, 819, 821, 1, 0, 0, 0, 820, 818, 1, 0, 0, 0, 821, 822, 3, 2, 1, 0, 822, 823, 3, 182, 91, 0, 823, 824, 3, 78, 39, 0, 824, 825, 3, 80, 40, 0, 825, 826, 6, 37, -1, 0, 826, 75, 1, 0, 0, 0, 827, 828, 5, 51, 0, 0, 828, 892, 6, 38, -1, 0, 829, 830, 5, 52, 0, 0, 830, 892, 6, 38, -1, 0, 831, 832, 5, 199, 0, 0, 832, 892, 6, 38, -1, 0, 833, 834, 5, 202, 0, 0, 834, 892, 6, 38, -1, 0, 835, 836, 5, 221, 0, 0, 836, 892, 6, 38, -1, 0, 837, 838, 5, 53, 0, 0, 838, 892, 6, 38, -1, 0, 839, 840, 5, 54, 0, 0, 840, 892, 6, 38, -1, 0, 841, 842, 5, 55, 0, 0, 842, 892, 6, 38, -1, 0, 843, 844, 5, 56, 0, 0, 844, 892, 6, 38, -1, 0, 845, 846, 5, 244, 0, 0, 846, 892, 6, 38, -1, 0, 847, 848, 5, 15, 0, 0, 848, 892, 6, 38, -1, 0, 849, 850, 5, 224, 0, 0, 850, 892, 6, 38, -1, 0, 851, 852, 5, 57, 0, 0, 852, 892, 6, 38, -1, 0, 853, 854, 5, 58, 0, 0, 854, 892, 6, 38, -1, 0, 855, 856, 5, 59, 0, 0, 856, 892, 6, 38, -1, 0, 857, 858, 5, 60, 0, 0, 858, 892, 6, 38, -1, 0, 859, 860, 5, 61, 0, 0, 860, 892, 6, 38, -1, 0, 861, 862, 5, 62, 0, 0, 862, 863, 5, 51, 0, 0, 863, 892, 6, 38, -1, 0, 864, 865, 5, 62, 0, 0, 865, 866, 5, 52, 0, 0, 866, 892, 6, 38, -1, 0, 867, 868, 5, 62, 0, 0, 868, 869, 5, 63, 0, 0, 869, 892, 6, 38, -1, 0, 870, 871, 5, 62, 0, 0, 871, 872, 5, 64, 0, 0, 872, 892, 6, 38, -1, 0, 873, 874, 5, 62, 0, 0, 874, 875, 5, 65, 0, 0, 875, 892, 6, 38, -1, 0, 876, 877, 5, 62, 0, 0, 877, 878, 5, 66, 0, 0, 878, 892, 6, 38, -1, 0, 879, 880, 5, 67, 0, 0, 880, 892, 6, 38, -1, 0, 881, 882, 5, 68, 0, 0, 882, 892, 6, 38, -1, 0, 883, 884, 5, 69, 0, 0, 884, 892, 6, 38, -1, 0, 885, 886, 5, 70, 0, 0, 886, 887, 5, 30, 0, 0, 887, 888, 3, 32, 16, 0, 888, 889, 5, 31, 0, 0, 889, 890, 6, 38, -1, 0, 890, 892, 1, 0, 0, 0, 891, 827, 1, 0, 0, 0, 891, 829, 1, 0, 0, 0, 891, 831, 1, 0, 0, 0, 891, 833, 1, 0, 0, 0, 891, 835, 1, 0, 0, 0, 891, 837, 1, 0, 0, 0, 891, 839, 1, 0, 0, 0, 891, 841, 1, 0, 0, 0, 891, 843, 1, 0, 0, 0, 891, 845, 1, 0, 0, 0, 891, 847, 1, 0, 0, 0, 891, 849, 1, 0, 0, 0, 891, 851, 1, 0, 0, 0, 891, 853, 1, 0, 0, 0, 891, 855, 1, 0, 0, 0, 891, 857, 1, 0, 0, 0, 891, 859, 1, 0, 0, 0, 891, 861, 1, 0, 0, 0, 891, 864, 1, 0, 0, 0, 891, 867, 1, 0, 0, 0, 891, 870, 1, 0, 0, 0, 891, 873, 1, 0, 0, 0, 891, 876, 1, 0, 0, 0, 891, 879, 1, 0, 0, 0, 891, 881, 1, 0, 0, 0, 891, 883, 1, 0, 0, 0, 891, 885, 1, 0, 0, 0, 892, 77, 1, 0, 0, 0, 893, 899, 1, 0, 0, 0, 894, 895, 5, 71, 0, 0, 895, 896, 3, 124, 62, 0, 896, 897, 6, 39, -1, 0, 897, 899, 1, 0, 0, 0, 898, 893, 1, 0, 0, 0, 898, 894, 1, 0, 0, 0, 899, 79, 1, 0, 0, 0, 900, 906, 1, 0, 0, 0, 901, 902, 5, 72, 0, 0, 902, 903, 3, 84, 42, 0, 903, 904, 6, 40, -1, 0, 904, 906, 1, 0, 0, 0, 905, 900, 1, 0, 0, 0, 905, 901, 1, 0, 0, 0, 906, 81, 1, 0, 0, 0, 907, 909, 3, 198, 99, 0, 908, 907, 1, 0, 0, 0, 909, 912, 1, 0, 0, 0, 910, 908, 1, 0, 0, 0, 910, 911, 1, 0, 0, 0, 911, 83, 1, 0, 0, 0, 912, 910, 1, 0, 0, 0, 913, 914, 3, 124, 62, 0, 914, 915, 6, 42, -1, 0, 915, 916, 5, 28, 0, 0, 916, 918, 1, 0, 0, 0, 917, 913, 1, 0, 0, 0, 918, 921, 1, 0, 0, 0, 919, 917, 1, 0, 0, 0, 919, 920, 1, 0, 0, 0, 920, 922, 1, 0, 0, 0, 921, 919, 1, 0, 0, 0, 922, 923, 3, 124, 62, 0, 923, 924, 6, 42, -1, 0, 924, 85, 1, 0, 0, 0, 925, 926, 7, 5, 0, 0, 926, 87, 1, 0, 0, 0, 927, 928, 3, 86, 43, 0, 928, 930, 3, 32, 16, 0, 929, 931, 7, 2, 0, 0, 930, 929, 1, 0, 0, 0, 930, 931, 1, 0, 0, 0, 931, 932, 1, 0, 0, 0, 932, 933, 6, 44, -1, 0, 933, 979, 1, 0, 0, 0, 934, 935, 3, 86, 43, 0, 935, 936, 3, 32, 16, 0, 936, 937, 5, 75, 0, 0, 937, 939, 3, 32, 16, 0, 938, 940, 7, 2, 0, 0, 939, 938, 1, 0, 0, 0, 939, 940, 1, 0, 0, 0, 940, 941, 1, 0, 0, 0, 941, 942, 6, 44, -1, 0, 942, 979, 1, 0, 0, 0, 943, 944, 3, 86, 43, 0, 944, 945, 3, 32, 16, 0, 945, 946, 5, 75, 0, 0, 946, 947, 3, 32, 16, 0, 947, 948, 5, 28, 0, 0, 948, 950, 3, 32, 16, 0, 949, 951, 7, 2, 0, 0, 950, 949, 1, 0, 0, 0, 950, 951, 1, 0, 0, 0, 951, 952, 1, 0, 0, 0, 952, 953, 6, 44, -1, 0, 953, 979, 1, 0, 0, 0, 954, 955, 3, 86, 43, 0, 955, 956, 3, 32, 16, 0, 956, 957, 5, 28, 0, 0, 957, 958, 3, 32, 16, 0, 958, 959, 5, 75, 0, 0, 959, 961, 3, 32, 16, 0, 960, 962, 7, 2, 0, 0, 961, 960, 1, 0, 0, 0, 961, 962, 1, 0, 0, 0, 962, 963, 1, 0, 0, 0, 963, 964, 6, 44, -1, 0, 964, 979, 1, 0, 0, 0, 965, 966, 3, 86, 43, 0, 966, 967, 3, 32, 16, 0, 967, 968, 5, 28, 0, 0, 968, 969, 3, 32, 16, 0, 969, 970, 5, 75, 0, 0, 970, 971, 3, 32, 16, 0, 971, 972, 5, 28, 0, 0, 972, 974, 3, 32, 16, 0, 973, 975, 7, 2, 0, 0, 974, 973, 1, 0, 0, 0, 974, 975, 1, 0, 0, 0, 975, 976, 1, 0, 0, 0, 976, 977, 6, 44, -1, 0, 977, 979, 1, 0, 0, 0, 978, 927, 1, 0, 0, 0, 978, 934, 1, 0, 0, 0, 978, 943, 1, 0, 0, 0, 978, 954, 1, 0, 0, 0, 978, 965, 1, 0, 0, 0, 979, 89, 1, 0, 0, 0, 980, 984, 5, 21, 0, 0, 981, 983, 3, 92, 46, 0, 982, 981, 1, 0, 0, 0, 983, 986, 1, 0, 0, 0, 984, 982, 1, 0, 0, 0, 984, 985, 1, 0, 0, 0, 985, 987, 1, 0, 0, 0, 986, 984, 1, 0, 0, 0, 987, 988, 3, 2, 1, 0, 988, 989, 3, 94, 47, 0, 989, 990, 5, 180, 0, 0, 990, 991, 5, 36, 0, 0, 991, 992, 5, 30, 0, 0, 992, 993, 3, 300, 150, 0, 993, 994, 5, 31, 0, 0, 994, 995, 3, 94, 47, 0, 995, 1007, 1, 0, 0, 0, 996, 1000, 5, 21, 0, 0, 997, 999, 3, 92, 46, 0, 998, 997, 1, 0, 0, 0, 999, 1002, 1, 0, 0, 0, 1000, 998, 1, 0, 0, 0, 1000, 1001, 1, 0, 0, 0, 1001, 1003, 1, 0, 0, 0, 1002, 1000, 1, 0, 0, 0, 1003, 1004, 3, 2, 1, 0, 1004, 1005, 3, 94, 47, 0, 1005, 1007, 1, 0, 0, 0, 1006, 980, 1, 0, 0, 0, 1006, 996, 1, 0, 0, 0, 1007, 91, 1, 0, 0, 0, 1008, 1009, 5, 76, 0, 0, 1009, 93, 1, 0, 0, 0, 1010, 1013, 1, 0, 0, 0, 1011, 1013, 5, 298, 0, 0, 1012, 1010, 1, 0, 0, 0, 1012, 1011, 1, 0, 0, 0, 1013, 95, 1, 0, 0, 0, 1014, 1015, 7, 6, 0, 0, 1015, 97, 1, 0, 0, 0, 1016, 1018, 3, 96, 48, 0, 1017, 1016, 1, 0, 0, 0, 1018, 1021, 1, 0, 0, 0, 1019, 1017, 1, 0, 0, 0, 1019, 1020, 1, 0, 0, 0, 1020, 99, 1, 0, 0, 0, 1021, 1019, 1, 0, 0, 0, 1022, 1048, 3, 102, 51, 0, 1023, 1024, 5, 280, 0, 0, 1024, 1025, 3, 168, 84, 0, 1025, 1026, 6, 50, -1, 0, 1026, 1048, 1, 0, 0, 0, 1027, 1028, 5, 286, 0, 0, 1028, 1029, 3, 178, 89, 0, 1029, 1030, 6, 50, -1, 0, 1030, 1048, 1, 0, 0, 0, 1031, 1032, 5, 286, 0, 0, 1032, 1033, 3, 174, 87, 0, 1033, 1034, 6, 50, -1, 0, 1034, 1048, 1, 0, 0, 0, 1035, 1036, 5, 284, 0, 0, 1036, 1037, 3, 124, 62, 0, 1037, 1038, 6, 50, -1, 0, 1038, 1048, 1, 0, 0, 0, 1039, 1040, 5, 281, 0, 0, 1040, 1041, 3, 104, 52, 0, 1041, 1042, 6, 50, -1, 0, 1042, 1048, 1, 0, 0, 0, 1043, 1044, 5, 287, 0, 0, 1044, 1045, 3, 50, 25, 0, 1045, 1046, 6, 50, -1, 0, 1046, 1048, 1, 0, 0, 0, 1047, 1022, 1, 0, 0, 0, 1047, 1023, 1, 0, 0, 0, 1047, 1027, 1, 0, 0, 0, 1047, 1031, 1, 0, 0, 0, 1047, 1035, 1, 0, 0, 0, 1047, 1039, 1, 0, 0, 0, 1047, 1043, 1, 0, 0, 0, 1048, 101, 1, 0, 0, 0, 1049, 1050, 5, 275, 0, 0, 1050, 1128, 6, 51, -1, 0, 1051, 1052, 5, 276, 0, 0, 1052, 1053, 3, 32, 16, 0, 1053, 1054, 6, 51, -1, 0, 1054, 1128, 1, 0, 0, 0, 1055, 1056, 5, 276, 0, 0, 1056, 1057, 3, 0, 0, 0, 1057, 1058, 6, 51, -1, 0, 1058, 1128, 1, 0, 0, 0, 1059, 1060, 5, 277, 0, 0, 1060, 1061, 3, 32, 16, 0, 1061, 1062, 6, 51, -1, 0, 1062, 1128, 1, 0, 0, 0, 1063, 1064, 5, 278, 0, 0, 1064, 1065, 3, 34, 17, 0, 1065, 1066, 6, 51, -1, 0, 1066, 1128, 1, 0, 0, 0, 1067, 1068, 5, 279, 0, 0, 1068, 1069, 3, 36, 18, 0, 1069, 1070, 6, 51, -1, 0, 1070, 1128, 1, 0, 0, 0, 1071, 1072, 5, 279, 0, 0, 1072, 1073, 3, 34, 17, 0, 1073, 1074, 6, 51, -1, 0, 1074, 1128, 1, 0, 0, 0, 1075, 1076, 5, 279, 0, 0, 1076, 1077, 5, 30, 0, 0, 1077, 1078, 3, 300, 150, 0, 1078, 1079, 5, 31, 0, 0, 1079, 1080, 6, 51, -1, 0, 1080, 1128, 1, 0, 0, 0, 1081, 1082, 5, 279, 0, 0, 1082, 1083, 5, 84, 0, 0, 1083, 1084, 5, 30, 0, 0, 1084, 1085, 3, 300, 150, 0, 1085, 1086, 5, 31, 0, 0, 1086, 1087, 6, 51, -1, 0, 1087, 1128, 1, 0, 0, 0, 1088, 1089, 5, 282, 0, 0, 1089, 1090, 3, 32, 16, 0, 1090, 1091, 6, 51, -1, 0, 1091, 1128, 1, 0, 0, 0, 1092, 1093, 5, 282, 0, 0, 1093, 1094, 3, 0, 0, 0, 1094, 1095, 6, 51, -1, 0, 1095, 1128, 1, 0, 0, 0, 1096, 1097, 5, 285, 0, 0, 1097, 1098, 3, 6, 3, 0, 1098, 1099, 6, 51, -1, 0, 1099, 1128, 1, 0, 0, 0, 1100, 1101, 5, 285, 0, 0, 1101, 1102, 5, 224, 0, 0, 1102, 1103, 5, 30, 0, 0, 1103, 1104, 3, 6, 3, 0, 1104, 1105, 5, 31, 0, 0, 1105, 1106, 6, 51, -1, 0, 1106, 1128, 1, 0, 0, 0, 1107, 1108, 5, 285, 0, 0, 1108, 1109, 5, 84, 0, 0, 1109, 1110, 5, 30, 0, 0, 1110, 1111, 3, 300, 150, 0, 1111, 1112, 5, 31, 0, 0, 1112, 1113, 6, 51, -1, 0, 1113, 1128, 1, 0, 0, 0, 1114, 1115, 5, 287, 0, 0, 1115, 1116, 3, 32, 16, 0, 1116, 1117, 6, 51, -1, 0, 1117, 1128, 1, 0, 0, 0, 1118, 1119, 5, 283, 0, 0, 1119, 1125, 6, 51, -1, 0, 1120, 1121, 5, 30, 0, 0, 1121, 1122, 3, 106, 53, 0, 1122, 1123, 5, 31, 0, 0, 1123, 1126, 1, 0, 0, 0, 1124, 1126, 5, 85, 0, 0, 1125, 1120, 1, 0, 0, 0, 1125, 1124, 1, 0, 0, 0, 1126, 1128, 1, 0, 0, 0, 1127, 1049, 1, 0, 0, 0, 1127, 1051, 1, 0, 0, 0, 1127, 1055, 1, 0, 0, 0, 1127, 1059, 1, 0, 0, 0, 1127, 1063, 1, 0, 0, 0, 1127, 1067, 1, 0, 0, 0, 1127, 1071, 1, 0, 0, 0, 1127, 1075, 1, 0, 0, 0, 1127, 1081, 1, 0, 0, 0, 1127, 1088, 1, 0, 0, 0, 1127, 1092, 1, 0, 0, 0, 1127, 1096, 1, 0, 0, 0, 1127, 1100, 1, 0, 0, 0, 1127, 1107, 1, 0, 0, 0, 1127, 1114, 1, 0, 0, 0, 1127, 1118, 1, 0, 0, 0, 1128, 103, 1, 0, 0, 0, 1129, 1130, 3, 170, 85, 0, 1130, 1131, 3, 138, 69, 0, 1131, 1132, 3, 112, 56, 0, 1132, 1133, 6, 52, -1, 0, 1133, 105, 1, 0, 0, 0, 1134, 1159, 1, 0, 0, 0, 1135, 1136, 3, 0, 0, 0, 1136, 1137, 6, 53, -1, 0, 1137, 1142, 1, 0, 0, 0, 1138, 1139, 3, 32, 16, 0, 1139, 1140, 6, 53, -1, 0, 1140, 1142, 1, 0, 0, 0, 1141, 1135, 1, 0, 0, 0, 1141, 1138, 1, 0, 0, 0, 1142, 1143, 1, 0, 0, 0, 1143, 1144, 5, 28, 0, 0, 1144, 1146, 1, 0, 0, 0, 1145, 1141, 1, 0, 0, 0, 1146, 1149, 1, 0, 0, 0, 1147, 1145, 1, 0, 0, 0, 1147, 1148, 1, 0, 0, 0, 1148, 1156, 1, 0, 0, 0, 1149, 1147, 1, 0, 0, 0, 1150, 1151, 3, 0, 0, 0, 1151, 1152, 6, 53, -1, 0, 1152, 1157, 1, 0, 0, 0, 1153, 1154, 3, 32, 16, 0, 1154, 1155, 6, 53, -1, 0, 1155, 1157, 1, 0, 0, 0, 1156, 1150, 1, 0, 0, 0, 1156, 1153, 1, 0, 0, 0, 1157, 1159, 1, 0, 0, 0, 1158, 1134, 1, 0, 0, 0, 1158, 1147, 1, 0, 0, 0, 1159, 107, 1, 0, 0, 0, 1160, 1167, 5, 86, 0, 0, 1161, 1162, 3, 138, 69, 0, 1162, 1163, 6, 54, -1, 0, 1163, 1164, 5, 28, 0, 0, 1164, 1166, 1, 0, 0, 0, 1165, 1161, 1, 0, 0, 0, 1166, 1169, 1, 0, 0, 0, 1167, 1165, 1, 0, 0, 0, 1167, 1168, 1, 0, 0, 0, 1168, 1170, 1, 0, 0, 0, 1169, 1167, 1, 0, 0, 0, 1170, 1171, 3, 138, 69, 0, 1171, 1172, 6, 54, -1, 0, 1172, 1173, 5, 87, 0, 0, 1173, 109, 1, 0, 0, 0, 1174, 1181, 5, 42, 0, 0, 1175, 1176, 3, 146, 73, 0, 1176, 1177, 6, 55, -1, 0, 1177, 1178, 5, 28, 0, 0, 1178, 1180, 1, 0, 0, 0, 1179, 1175, 1, 0, 0, 0, 1180, 1183, 1, 0, 0, 0, 1181, 1179, 1, 0, 0, 0, 1181, 1182, 1, 0, 0, 0, 1182, 1184, 1, 0, 0, 0, 1183, 1181, 1, 0, 0, 0, 1184, 1185, 3, 146, 73, 0, 1185, 1186, 6, 55, -1, 0, 1186, 1187, 5, 43, 0, 0, 1187, 111, 1, 0, 0, 0, 1188, 1195, 5, 30, 0, 0, 1189, 1190, 3, 114, 57, 0, 1190, 1191, 6, 56, -1, 0, 1191, 1192, 5, 28, 0, 0, 1192, 1194, 1, 0, 0, 0, 1193, 1189, 1, 0, 0, 0, 1194, 1197, 1, 0, 0, 0, 1195, 1193, 1, 0, 0, 0, 1195, 1196, 1, 0, 0, 0, 1196, 1198, 1, 0, 0, 0, 1197, 1195, 1, 0, 0, 0, 1198, 1199, 3, 114, 57, 0, 1199, 1200, 6, 56, -1, 0, 1200, 1201, 5, 31, 0, 0, 1201, 1204, 1, 0, 0, 0, 1202, 1204, 5, 85, 0, 0, 1203, 1188, 1, 0, 0, 0, 1203, 1202, 1, 0, 0, 0, 1204, 113, 1, 0, 0, 0, 1205, 1206, 5, 177, 0, 0, 1206, 1216, 6, 57, -1, 0, 1207, 1208, 3, 230, 115, 0, 1208, 1209, 3, 138, 69, 0, 1209, 1211, 3, 226, 113, 0, 1210, 1212, 3, 0, 0, 0, 1211, 1210, 1, 0, 0, 0, 1211, 1212, 1, 0, 0, 0, 1212, 1213, 1, 0, 0, 0, 1213, 1214, 6, 57, -1, 0, 1214, 1216, 1, 0, 0, 0, 1215, 1205, 1, 0, 0, 0, 1215, 1207, 1, 0, 0, 0, 1216, 115, 1, 0, 0, 0, 1217, 1218, 5, 42, 0, 0, 1218, 1219, 3, 2, 1, 0, 1219, 1220, 5, 43, 0, 0, 1220, 1221, 3, 118, 59, 0, 1221, 1222, 6, 58, -1, 0, 1222, 1255, 1, 0, 0, 0, 1223, 1224, 5, 42, 0, 0, 1224, 1225, 3, 174, 87, 0, 1225, 1226, 5, 43, 0, 0, 1226, 1227, 3, 118, 59, 0, 1227, 1228, 6, 58, -1, 0, 1228, 1255, 1, 0, 0, 0, 1229, 1230, 5, 42, 0, 0, 1230, 1231, 5, 262, 0, 0, 1231, 1232, 5, 43, 0, 0, 1232, 1233, 3, 118, 59, 0, 1233, 1234, 6, 58, -1, 0, 1234, 1255, 1, 0, 0, 0, 1235, 1236, 5, 42, 0, 0, 1236, 1237, 5, 198, 0, 0, 1237, 1238, 3, 2, 1, 0, 1238, 1239, 5, 43, 0, 0, 1239, 1240, 3, 118, 59, 0, 1240, 1241, 6, 58, -1, 0, 1241, 1255, 1, 0, 0, 0, 1242, 1243, 3, 118, 59, 0, 1243, 1244, 6, 58, -1, 0, 1244, 1255, 1, 0, 0, 0, 1245, 1246, 3, 174, 87, 0, 1246, 1247, 6, 58, -1, 0, 1247, 1255, 1, 0, 0, 0, 1248, 1249, 5, 257, 0, 0, 1249, 1255, 6, 58, -1, 0, 1250, 1251, 5, 258, 0, 0, 1251, 1255, 6, 58, -1, 0, 1252, 1253, 5, 259, 0, 0, 1253, 1255, 6, 58, -1, 0, 1254, 1217, 1, 0, 0, 0, 1254, 1223, 1, 0, 0, 0, 1254, 1229, 1, 0, 0, 0, 1254, 1235, 1, 0, 0, 0, 1254, 1242, 1, 0, 0, 0, 1254, 1245, 1, 0, 0, 0, 1254, 1248, 1, 0, 0, 0, 1254, 1250, 1, 0, 0, 0, 1254, 1252, 1, 0, 0, 0, 1255, 117, 1, 0, 0, 0, 1256, 1257, 3, 2, 1, 0, 1257, 1258, 6, 59, -1, 0, 1258, 1259, 5, 88, 0, 0, 1259, 1261, 1, 0, 0, 0, 1260, 1256, 1, 0, 0, 0, 1261, 1264, 1, 0, 0, 0, 1262, 1260, 1, 0, 0, 0, 1262, 1263, 1, 0, 0, 0, 1263, 1265, 1, 0, 0, 0, 1264, 1262, 1, 0, 0, 0, 1265, 1266, 3, 2, 1, 0, 1266, 1267, 6, 59, -1, 0, 1267, 119, 1, 0, 0, 0, 1268, 1270, 3, 122, 61, 0, 1269, 1268, 1, 0, 0, 0, 1270, 1273, 1, 0, 0, 0, 1271, 1269, 1, 0, 0, 0, 1271, 1272, 1, 0, 0, 0, 1272, 121, 1, 0, 0, 0, 1273, 1271, 1, 0, 0, 0, 1274, 1275, 5, 180, 0, 0, 1275, 1276, 5, 89, 0, 0, 1276, 1280, 3, 32, 16, 0, 1277, 1280, 3, 152, 76, 0, 1278, 1280, 3, 332, 166, 0, 1279, 1274, 1, 0, 0, 0, 1279, 1277, 1, 0, 0, 0, 1279, 1278, 1, 0, 0, 0, 1280, 123, 1, 0, 0, 0, 1281, 1282, 3, 116, 58, 0, 1282, 1283, 6, 62, -1, 0, 1283, 1299, 1, 0, 0, 0, 1284, 1285, 5, 42, 0, 0, 1285, 1286, 3, 2, 1, 0, 1286, 1287, 5, 43, 0, 0, 1287, 1288, 6, 62, -1, 0, 1288, 1299, 1, 0, 0, 0, 1289, 1290, 5, 42, 0, 0, 1290, 1291, 5, 198, 0, 0, 1291, 1292, 3, 2, 1, 0, 1292, 1293, 5, 43, 0, 0, 1293, 1294, 6, 62, -1, 0, 1294, 1299, 1, 0, 0, 0, 1295, 1296, 3, 138, 69, 0, 1296, 1297, 6, 62, -1, 0, 1297, 1299, 1, 0, 0, 0, 1298, 1281, 1, 0, 0, 0, 1298, 1284, 1, 0, 0, 0, 1298, 1289, 1, 0, 0, 0, 1298, 1295, 1, 0, 0, 0, 1299, 125, 1, 0, 0, 0, 1300, 1312, 1, 0, 0, 0, 1301, 1302, 3, 130, 65, 0, 1302, 1308, 6, 63, -1, 0, 1303, 1304, 3, 128, 64, 0, 1304, 1305, 6, 63, -1, 0, 1305, 1307, 1, 0, 0, 0, 1306, 1303, 1, 0, 0, 0, 1307, 1310, 1, 0, 0, 0, 1308, 1306, 1, 0, 0, 0, 1308, 1309, 1, 0, 0, 0, 1309, 1312, 1, 0, 0, 0, 1310, 1308, 1, 0, 0, 0, 1311, 1300, 1, 0, 0, 0, 1311, 1301, 1, 0, 0, 0, 1312, 127, 1, 0, 0, 0, 1313, 1314, 5, 262, 0, 0, 1314, 1336, 6, 64, -1, 0, 1315, 1316, 5, 261, 0, 0, 1316, 1336, 6, 64, -1, 0, 1317, 1318, 5, 42, 0, 0, 1318, 1319, 3, 32, 16, 0, 1319, 1320, 5, 43, 0, 0, 1320, 1321, 6, 64, -1, 0, 1321, 1336, 1, 0, 0, 0, 1322, 1323, 5, 42, 0, 0, 1323, 1324, 3, 32, 16, 0, 1324, 1325, 5, 266, 0, 0, 1325, 1326, 3, 32, 16, 0, 1326, 1327, 5, 43, 0, 0, 1327, 1328, 6, 64, -1, 0, 1328, 1336, 1, 0, 0, 0, 1329, 1330, 5, 42, 0, 0, 1330, 1331, 5, 266, 0, 0, 1331, 1332, 3, 32, 16, 0, 1332, 1333, 5, 43, 0, 0, 1333, 1334, 6, 64, -1, 0, 1334, 1336, 1, 0, 0, 0, 1335, 1313, 1, 0, 0, 0, 1335, 1315, 1, 0, 0, 0, 1335, 1317, 1, 0, 0, 0, 1335, 1322, 1, 0, 0, 0, 1335, 1329, 1, 0, 0, 0, 1336, 129, 1, 0, 0, 0, 1337, 1483, 6, 65, -1, 0, 1338, 1339, 5, 203, 0, 0, 1339, 1340, 5, 30, 0, 0, 1340, 1341, 3, 6, 3, 0, 1341, 1342, 5, 28, 0, 0, 1342, 1343, 3, 6, 3, 0, 1343, 1344, 5, 28, 0, 0, 1344, 1345, 3, 6, 3, 0, 1345, 1346, 5, 28, 0, 0, 1346, 1347, 3, 6, 3, 0, 1347, 1348, 5, 31, 0, 0, 1348, 1349, 6, 65, -1, 0, 1349, 1483, 1, 0, 0, 0, 1350, 1351, 5, 203, 0, 0, 1351, 1352, 5, 30, 0, 0, 1352, 1353, 3, 6, 3, 0, 1353, 1354, 5, 28, 0, 0, 1354, 1355, 3, 6, 3, 0, 1355, 1356, 5, 31, 0, 0, 1356, 1357, 6, 65, -1, 0, 1357, 1483, 1, 0, 0, 0, 1358, 1359, 5, 204, 0, 0, 1359, 1360, 5, 205, 0, 0, 1360, 1361, 5, 42, 0, 0, 1361, 1362, 3, 32, 16, 0, 1362, 1363, 5, 43, 0, 0, 1363, 1364, 6, 65, -1, 0, 1364, 1483, 1, 0, 0, 0, 1365, 1366, 5, 204, 0, 0, 1366, 1367, 5, 206, 0, 0, 1367, 1368, 5, 42, 0, 0, 1368, 1369, 3, 32, 16, 0, 1369, 1370, 5, 43, 0, 0, 1370, 1371, 3, 126, 63, 0, 1371, 1372, 6, 65, -1, 0, 1372, 1483, 1, 0, 0, 0, 1373, 1374, 5, 207, 0, 0, 1374, 1483, 6, 65, -1, 0, 1375, 1376, 5, 208, 0, 0, 1376, 1483, 6, 65, -1, 0, 1377, 1378, 5, 209, 0, 0, 1378, 1483, 6, 65, -1, 0, 1379, 1380, 5, 201, 0, 0, 1380, 1483, 6, 65, -1, 0, 1381, 1382, 5, 183, 0, 0, 1382, 1483, 6, 65, -1, 0, 1383, 1384, 5, 184, 0, 0, 1384, 1483, 6, 65, -1, 0, 1385, 1386, 5, 185, 0, 0, 1386, 1483, 6, 65, -1, 0, 1387, 1388, 5, 186, 0, 0, 1388, 1483, 6, 65, -1, 0, 1389, 1390, 5, 187, 0, 0, 1390, 1483, 6, 65, -1, 0, 1391, 1392, 5, 188, 0, 0, 1392, 1483, 6, 65, -1, 0, 1393, 1394, 5, 189, 0, 0, 1394, 1483, 6, 65, -1, 0, 1395, 1396, 5, 210, 0, 0, 1396, 1483, 6, 65, -1, 0, 1397, 1398, 5, 190, 0, 0, 1398, 1483, 6, 65, -1, 0, 1399, 1400, 5, 191, 0, 0, 1400, 1483, 6, 65, -1, 0, 1401, 1402, 5, 192, 0, 0, 1402, 1483, 6, 65, -1, 0, 1403, 1404, 5, 193, 0, 0, 1404, 1483, 6, 65, -1, 0, 1405, 1406, 5, 211, 0, 0, 1406, 1483, 6, 65, -1, 0, 1407, 1408, 5, 212, 0, 0, 1408, 1483, 6, 65, -1, 0, 1409, 1410, 5, 213, 0, 0, 1410, 1483, 6, 65, -1, 0, 1411, 1412, 5, 214, 0, 0, 1412, 1483, 6, 65, -1, 0, 1413, 1414, 5, 215, 0, 0, 1414, 1483, 6, 65, -1, 0, 1415, 1416, 5, 216, 0, 0, 1416, 1483, 6, 65, -1, 0, 1417, 1418, 5, 217, 0, 0, 1418, 1483, 6, 65, -1, 0, 1419, 1420, 5, 218, 0, 0, 1420, 1421, 3, 132, 66, 0, 1421, 1422, 6, 65, -1, 0, 1422, 1483, 1, 0, 0, 0, 1423, 1424, 5, 219, 0, 0, 1424, 1425, 3, 132, 66, 0, 1425, 1426, 6, 65, -1, 0, 1426, 1483, 1, 0, 0, 0, 1427, 1428, 5, 220, 0, 0, 1428, 1483, 6, 65, -1, 0, 1429, 1430, 5, 221, 0, 0, 1430, 1431, 3, 132, 66, 0, 1431, 1432, 6, 65, -1, 0, 1432, 1483, 1, 0, 0, 0, 1433, 1434, 5, 222, 0, 0, 1434, 1435, 3, 134, 67, 0, 1435, 1436, 6, 65, -1, 0, 1436, 1483, 1, 0, 0, 0, 1437, 1438, 5, 222, 0, 0, 1438, 1439, 3, 134, 67, 0, 1439, 1440, 5, 28, 0, 0, 1440, 1441, 3, 6, 3, 0, 1441, 1442, 6, 65, -1, 0, 1442, 1483, 1, 0, 0, 0, 1443, 1444, 5, 194, 0, 0, 1444, 1483, 6, 65, -1, 0, 1445, 1446, 5, 195, 0, 0, 1446, 1483, 6, 65, -1, 0, 1447, 1448, 5, 90, 0, 0, 1448, 1449, 5, 184, 0, 0, 1449, 1483, 6, 65, -1, 0, 1450, 1451, 5, 90, 0, 0, 1451, 1452, 5, 185, 0, 0, 1452, 1483, 6, 65, -1, 0, 1453, 1454, 5, 90, 0, 0, 1454, 1455, 5, 186, 0, 0, 1455, 1483, 6, 65, -1, 0, 1456, 1457, 5, 90, 0, 0, 1457, 1458, 5, 187, 0, 0, 1458, 1483, 6, 65, -1, 0, 1459, 1460, 5, 62, 0, 0, 1460, 1461, 5, 220, 0, 0, 1461, 1483, 6, 65, -1, 0, 1462, 1463, 5, 223, 0, 0, 1463, 1483, 6, 65, -1, 0, 1464, 1465, 5, 224, 0, 0, 1465, 1466, 5, 213, 0, 0, 1466, 1483, 6, 65, -1, 0, 1467, 1468, 5, 225, 0, 0, 1468, 1483, 6, 65, -1, 0, 1469, 1470, 5, 207, 0, 0, 1470, 1471, 5, 183, 0, 0, 1471, 1483, 6, 65, -1, 0, 1472, 1473, 5, 226, 0, 0, 1473, 1483, 6, 65, -1, 0, 1474, 1475, 5, 228, 0, 0, 1475, 1483, 6, 65, -1, 0, 1476, 1477, 5, 34, 0, 0, 1477, 1478, 5, 227, 0, 0, 1478, 1483, 6, 65, -1, 0, 1479, 1480, 3, 2, 1, 0, 1480, 1481, 6, 65, -1, 0, 1481, 1483, 1, 0, 0, 0, 1482, 1337, 1, 0, 0, 0, 1482, 1338, 1, 0, 0, 0, 1482, 1350, 1, 0, 0, 0, 1482, 1358, 1, 0, 0, 0, 1482, 1365, 1, 0, 0, 0, 1482, 1373, 1, 0, 0, 0, 1482, 1375, 1, 0, 0, 0, 1482, 1377, 1, 0, 0, 0, 1482, 1379, 1, 0, 0, 0, 1482, 1381, 1, 0, 0, 0, 1482, 1383, 1, 0, 0, 0, 1482, 1385, 1, 0, 0, 0, 1482, 1387, 1, 0, 0, 0, 1482, 1389, 1, 0, 0, 0, 1482, 1391, 1, 0, 0, 0, 1482, 1393, 1, 0, 0, 0, 1482, 1395, 1, 0, 0, 0, 1482, 1397, 1, 0, 0, 0, 1482, 1399, 1, 0, 0, 0, 1482, 1401, 1, 0, 0, 0, 1482, 1403, 1, 0, 0, 0, 1482, 1405, 1, 0, 0, 0, 1482, 1407, 1, 0, 0, 0, 1482, 1409, 1, 0, 0, 0, 1482, 1411, 1, 0, 0, 0, 1482, 1413, 1, 0, 0, 0, 1482, 1415, 1, 0, 0, 0, 1482, 1417, 1, 0, 0, 0, 1482, 1419, 1, 0, 0, 0, 1482, 1423, 1, 0, 0, 0, 1482, 1427, 1, 0, 0, 0, 1482, 1429, 1, 0, 0, 0, 1482, 1433, 1, 0, 0, 0, 1482, 1437, 1, 0, 0, 0, 1482, 1443, 1, 0, 0, 0, 1482, 1445, 1, 0, 0, 0, 1482, 1447, 1, 0, 0, 0, 1482, 1450, 1, 0, 0, 0, 1482, 1453, 1, 0, 0, 0, 1482, 1456, 1, 0, 0, 0, 1482, 1459, 1, 0, 0, 0, 1482, 1462, 1, 0, 0, 0, 1482, 1464, 1, 0, 0, 0, 1482, 1467, 1, 0, 0, 0, 1482, 1469, 1, 0, 0, 0, 1482, 1472, 1, 0, 0, 0, 1482, 1474, 1, 0, 0, 0, 1482, 1476, 1, 0, 0, 0, 1482, 1479, 1, 0, 0, 0, 1483, 131, 1, 0, 0, 0, 1484, 1493, 1, 0, 0, 0, 1485, 1486, 5, 30, 0, 0, 1486, 1487, 5, 91, 0, 0, 1487, 1488, 5, 36, 0, 0, 1488, 1489, 3, 32, 16, 0, 1489, 1490, 5, 31, 0, 0, 1490, 1491, 6, 66, -1, 0, 1491, 1493, 1, 0, 0, 0, 1492, 1484, 1, 0, 0, 0, 1492, 1485, 1, 0, 0, 0, 1493, 133, 1, 0, 0, 0, 1494, 1505, 1, 0, 0, 0, 1495, 1496, 3, 136, 68, 0, 1496, 1501, 6, 67, -1, 0, 1497, 1498, 7, 7, 0, 0, 1498, 1500, 6, 67, -1, 0, 1499, 1497, 1, 0, 0, 0, 1500, 1503, 1, 0, 0, 0, 1501, 1499, 1, 0, 0, 0, 1501, 1502, 1, 0, 0, 0, 1502, 1505, 1, 0, 0, 0, 1503, 1501, 1, 0, 0, 0, 1504, 1494, 1, 0, 0, 0, 1504, 1495, 1, 0, 0, 0, 1505, 135, 1, 0, 0, 0, 1506, 1507, 5, 178, 0, 0, 1507, 1587, 6, 68, -1, 0, 1508, 1509, 5, 207, 0, 0, 1509, 1587, 6, 68, -1, 0, 1510, 1511, 5, 208, 0, 0, 1511, 1587, 6, 68, -1, 0, 1512, 1513, 5, 201, 0, 0, 1513, 1587, 6, 68, -1, 0, 1514, 1515, 5, 183, 0, 0, 1515, 1587, 6, 68, -1, 0, 1516, 1517, 5, 184, 0, 0, 1517, 1587, 6, 68, -1, 0, 1518, 1519, 5, 185, 0, 0, 1519, 1587, 6, 68, -1, 0, 1520, 1521, 5, 186, 0, 0, 1521, 1587, 6, 68, -1, 0, 1522, 1523, 5, 187, 0, 0, 1523, 1587, 6, 68, -1, 0, 1524, 1525, 5, 188, 0, 0, 1525, 1587, 6, 68, -1, 0, 1526, 1527, 5, 189, 0, 0, 1527, 1587, 6, 68, -1, 0, 1528, 1529, 5, 190, 0, 0, 1529, 1587, 6, 68, -1, 0, 1530, 1531, 5, 191, 0, 0, 1531, 1587, 6, 68, -1, 0, 1532, 1533, 5, 192, 0, 0, 1533, 1587, 6, 68, -1, 0, 1534, 1535, 5, 193, 0, 0, 1535, 1587, 6, 68, -1, 0, 1536, 1537, 5, 262, 0, 0, 1537, 1587, 6, 68, -1, 0, 1538, 1539, 5, 211, 0, 0, 1539, 1587, 6, 68, -1, 0, 1540, 1541, 5, 212, 0, 0, 1541, 1587, 6, 68, -1, 0, 1542, 1543, 5, 213, 0, 0, 1543, 1587, 6, 68, -1, 0, 1544, 1545, 5, 214, 0, 0, 1545, 1587, 6, 68, -1, 0, 1546, 1547, 5, 215, 0, 0, 1547, 1587, 6, 68, -1, 0, 1548, 1549, 5, 218, 0, 0, 1549, 1587, 6, 68, -1, 0, 1550, 1551, 5, 219, 0, 0, 1551, 1587, 6, 68, -1, 0, 1552, 1553, 5, 222, 0, 0, 1553, 1587, 6, 68, -1, 0, 1554, 1555, 5, 194, 0, 0, 1555, 1587, 6, 68, -1, 0, 1556, 1557, 5, 195, 0, 0, 1557, 1587, 6, 68, -1, 0, 1558, 1559, 5, 210, 0, 0, 1559, 1587, 6, 68, -1, 0, 1560, 1561, 5, 230, 0, 0, 1561, 1587, 6, 68, -1, 0, 1562, 1563, 5, 231, 0, 0, 1563, 1587, 6, 68, -1, 0, 1564, 1565, 5, 232, 0, 0, 1565, 1587, 6, 68, -1, 0, 1566, 1567, 5, 233, 0, 0, 1567, 1587, 6, 68, -1, 0, 1568, 1569, 5, 234, 0, 0, 1569, 1587, 6, 68, -1, 0, 1570, 1571, 5, 235, 0, 0, 1571, 1587, 6, 68, -1, 0, 1572, 1573, 5, 236, 0, 0, 1573, 1587, 6, 68, -1, 0, 1574, 1575, 5, 237, 0, 0, 1575, 1587, 6, 68, -1, 0, 1576, 1577, 5, 238, 0, 0, 1577, 1587, 6, 68, -1, 0, 1578, 1579, 5, 239, 0, 0, 1579, 1587, 6, 68, -1, 0, 1580, 1581, 5, 240, 0, 0, 1581, 1587, 6, 68, -1, 0, 1582, 1583, 5, 241, 0, 0, 1583, 1587, 6, 68, -1, 0, 1584, 1585, 5, 242, 0, 0, 1585, 1587, 6, 68, -1, 0, 1586, 1506, 1, 0, 0, 0, 1586, 1508, 1, 0, 0, 0, 1586, 1510, 1, 0, 0, 0, 1586, 1512, 1, 0, 0, 0, 1586, 1514, 1, 0, 0, 0, 1586, 1516, 1, 0, 0, 0, 1586, 1518, 1, 0, 0, 0, 1586, 1520, 1, 0, 0, 0, 1586, 1522, 1, 0, 0, 0, 1586, 1524, 1, 0, 0, 0, 1586, 1526, 1, 0, 0, 0, 1586, 1528, 1, 0, 0, 0, 1586, 1530, 1, 0, 0, 0, 1586, 1532, 1, 0, 0, 0, 1586, 1534, 1, 0, 0, 0, 1586, 1536, 1, 0, 0, 0, 1586, 1538, 1, 0, 0, 0, 1586, 1540, 1, 0, 0, 0, 1586, 1542, 1, 0, 0, 0, 1586, 1544, 1, 0, 0, 0, 1586, 1546, 1, 0, 0, 0, 1586, 1548, 1, 0, 0, 0, 1586, 1550, 1, 0, 0, 0, 1586, 1552, 1, 0, 0, 0, 1586, 1554, 1, 0, 0, 0, 1586, 1556, 1, 0, 0, 0, 1586, 1558, 1, 0, 0, 0, 1586, 1560, 1, 0, 0, 0, 1586, 1562, 1, 0, 0, 0, 1586, 1564, 1, 0, 0, 0, 1586, 1566, 1, 0, 0, 0, 1586, 1568, 1, 0, 0, 0, 1586, 1570, 1, 0, 0, 0, 1586, 1572, 1, 0, 0, 0, 1586, 1574, 1, 0, 0, 0, 1586, 1576, 1, 0, 0, 0, 1586, 1578, 1, 0, 0, 0, 1586, 1580, 1, 0, 0, 0, 1586, 1582, 1, 0, 0, 0, 1586, 1584, 1, 0, 0, 0, 1587, 137, 1, 0, 0, 0, 1588, 1589, 3, 142, 71, 0, 1589, 1595, 6, 69, -1, 0, 1590, 1591, 3, 140, 70, 0, 1591, 1592, 6, 69, -1, 0, 1592, 1594, 1, 0, 0, 0, 1593, 1590, 1, 0, 0, 0, 1594, 1597, 1, 0, 0, 0, 1595, 1593, 1, 0, 0, 0, 1595, 1596, 1, 0, 0, 0, 1596, 139, 1, 0, 0, 0, 1597, 1595, 1, 0, 0, 0, 1598, 1599, 5, 261, 0, 0, 1599, 1628, 6, 70, -1, 0, 1600, 1601, 5, 42, 0, 0, 1601, 1602, 5, 43, 0, 0, 1602, 1628, 6, 70, -1, 0, 1603, 1604, 3, 110, 55, 0, 1604, 1605, 6, 70, -1, 0, 1605, 1628, 1, 0, 0, 0, 1606, 1607, 5, 260, 0, 0, 1607, 1628, 6, 70, -1, 0, 1608, 1609, 5, 262, 0, 0, 1609, 1628, 6, 70, -1, 0, 1610, 1611, 5, 92, 0, 0, 1611, 1628, 6, 70, -1, 0, 1612, 1613, 5, 93, 0, 0, 1613, 1614, 5, 30, 0, 0, 1614, 1615, 3, 124, 62, 0, 1615, 1616, 5, 31, 0, 0, 1616, 1617, 6, 70, -1, 0, 1617, 1628, 1, 0, 0, 0, 1618, 1619, 5, 94, 0, 0, 1619, 1620, 5, 30, 0, 0, 1620, 1621, 3, 124, 62, 0, 1621, 1622, 5, 31, 0, 0, 1622, 1623, 6, 70, -1, 0, 1623, 1628, 1, 0, 0, 0, 1624, 1625, 3, 108, 54, 0, 1625, 1626, 6, 70, -1, 0, 1626, 1628, 1, 0, 0, 0, 1627, 1598, 1, 0, 0, 0, 1627, 1600, 1, 0, 0, 0, 1627, 1603, 1, 0, 0, 0, 1627, 1606, 1, 0, 0, 0, 1627, 1608, 1, 0, 0, 0, 1627, 1610, 1, 0, 0, 0, 1627, 1612, 1, 0, 0, 0, 1627, 1618, 1, 0, 0, 0, 1627, 1624, 1, 0, 0, 0, 1628, 141, 1, 0, 0, 0, 1629, 1630, 5, 39, 0, 0, 1630, 1631, 3, 116, 58, 0, 1631, 1632, 6, 71, -1, 0, 1632, 1688, 1, 0, 0, 0, 1633, 1634, 5, 197, 0, 0, 1634, 1688, 6, 71, -1, 0, 1635, 1636, 5, 199, 0, 0, 1636, 1637, 5, 39, 0, 0, 1637, 1638, 3, 116, 58, 0, 1638, 1639, 6, 71, -1, 0, 1639, 1688, 1, 0, 0, 0, 1640, 1641, 5, 200, 0, 0, 1641, 1642, 3, 116, 58, 0, 1642, 1643, 6, 71, -1, 0, 1643, 1688, 1, 0, 0, 0, 1644, 1645, 5, 226, 0, 0, 1645, 1646, 3, 170, 85, 0, 1646, 1647, 3, 138, 69, 0, 1647, 1648, 5, 262, 0, 0, 1648, 1649, 3, 112, 56, 0, 1649, 1650, 6, 71, -1, 0, 1650, 1688, 1, 0, 0, 0, 1651, 1652, 5, 253, 0, 0, 1652, 1653, 3, 32, 16, 0, 1653, 1654, 6, 71, -1, 0, 1654, 1688, 1, 0, 0, 0, 1655, 1656, 5, 252, 0, 0, 1656, 1657, 3, 32, 16, 0, 1657, 1658, 6, 71, -1, 0, 1658, 1688, 1, 0, 0, 0, 1659, 1660, 5, 253, 0, 0, 1660, 1661, 3, 2, 1, 0, 1661, 1662, 6, 71, -1, 0, 1662, 1688, 1, 0, 0, 0, 1663, 1664, 5, 252, 0, 0, 1664, 1665, 3, 2, 1, 0, 1665, 1666, 6, 71, -1, 0, 1666, 1688, 1, 0, 0, 0, 1667, 1668, 5, 254, 0, 0, 1668, 1688, 6, 71, -1, 0, 1669, 1670, 5, 201, 0, 0, 1670, 1688, 6, 71, -1, 0, 1671, 1672, 3, 148, 74, 0, 1672, 1673, 6, 71, -1, 0, 1673, 1688, 1, 0, 0, 0, 1674, 1675, 3, 150, 75, 0, 1675, 1676, 6, 71, -1, 0, 1676, 1688, 1, 0, 0, 0, 1677, 1678, 3, 144, 72, 0, 1678, 1679, 6, 71, -1, 0, 1679, 1688, 1, 0, 0, 0, 1680, 1681, 3, 2, 1, 0, 1681, 1682, 6, 71, -1, 0, 1682, 1688, 1, 0, 0, 0, 1683, 1684, 5, 177, 0, 0, 1684, 1685, 3, 138, 69, 0, 1685, 1686, 6, 71, -1, 0, 1686, 1688, 1, 0, 0, 0, 1687, 1629, 1, 0, 0, 0, 1687, 1633, 1, 0, 0, 0, 1687, 1635, 1, 0, 0, 0, 1687, 1640, 1, 0, 0, 0, 1687, 1644, 1, 0, 0, 0, 1687, 1651, 1, 0, 0, 0, 1687, 1655, 1, 0, 0, 0, 1687, 1659, 1, 0, 0, 0, 1687, 1663, 1, 0, 0, 0, 1687, 1667, 1, 0, 0, 0, 1687, 1669, 1, 0, 0, 0, 1687, 1671, 1, 0, 0, 0, 1687, 1674, 1, 0, 0, 0, 1687, 1677, 1, 0, 0, 0, 1687, 1680, 1, 0, 0, 0, 1687, 1683, 1, 0, 0, 0, 1688, 143, 1, 0, 0, 0, 1689, 1690, 5, 181, 0, 0, 1690, 1728, 6, 72, -1, 0, 1691, 1692, 5, 182, 0, 0, 1692, 1728, 6, 72, -1, 0, 1693, 1694, 5, 183, 0, 0, 1694, 1728, 6, 72, -1, 0, 1695, 1696, 5, 184, 0, 0, 1696, 1728, 6, 72, -1, 0, 1697, 1698, 5, 185, 0, 0, 1698, 1728, 6, 72, -1, 0, 1699, 1700, 5, 186, 0, 0, 1700, 1728, 6, 72, -1, 0, 1701, 1702, 5, 187, 0, 0, 1702, 1728, 6, 72, -1, 0, 1703, 1704, 5, 188, 0, 0, 1704, 1728, 6, 72, -1, 0, 1705, 1706, 5, 189, 0, 0, 1706, 1728, 6, 72, -1, 0, 1707, 1708, 5, 190, 0, 0, 1708, 1728, 6, 72, -1, 0, 1709, 1710, 5, 191, 0, 0, 1710, 1728, 6, 72, -1, 0, 1711, 1712, 5, 192, 0, 0, 1712, 1728, 6, 72, -1, 0, 1713, 1714, 5, 193, 0, 0, 1714, 1728, 6, 72, -1, 0, 1715, 1716, 5, 90, 0, 0, 1716, 1717, 5, 184, 0, 0, 1717, 1728, 6, 72, -1, 0, 1718, 1719, 5, 90, 0, 0, 1719, 1720, 5, 185, 0, 0, 1720, 1728, 6, 72, -1, 0, 1721, 1722, 5, 90, 0, 0, 1722, 1723, 5, 186, 0, 0, 1723, 1728, 6, 72, -1, 0, 1724, 1725, 5, 90, 0, 0, 1725, 1726, 5, 187, 0, 0, 1726, 1728, 6, 72, -1, 0, 1727, 1689, 1, 0, 0, 0, 1727, 1691, 1, 0, 0, 0, 1727, 1693, 1, 0, 0, 0, 1727, 1695, 1, 0, 0, 0, 1727, 1697, 1, 0, 0, 0, 1727, 1699, 1, 0, 0, 0, 1727, 1701, 1, 0, 0, 0, 1727, 1703, 1, 0, 0, 0, 1727, 1705, 1, 0, 0, 0, 1727, 1707, 1, 0, 0, 0, 1727, 1709, 1, 0, 0, 0, 1727, 1711, 1, 0, 0, 0, 1727, 1713, 1, 0, 0, 0, 1727, 1715, 1, 0, 0, 0, 1727, 1718, 1, 0, 0, 0, 1727, 1721, 1, 0, 0, 0, 1727, 1724, 1, 0, 0, 0, 1728, 145, 1, 0, 0, 0, 1729, 1744, 1, 0, 0, 0, 1730, 1744, 5, 177, 0, 0, 1731, 1732, 3, 32, 16, 0, 1732, 1733, 6, 73, -1, 0, 1733, 1744, 1, 0, 0, 0, 1734, 1735, 3, 32, 16, 0, 1735, 1736, 5, 177, 0, 0, 1736, 1737, 3, 32, 16, 0, 1737, 1738, 6, 73, -1, 0, 1738, 1744, 1, 0, 0, 0, 1739, 1740, 3, 32, 16, 0, 1740, 1741, 5, 177, 0, 0, 1741, 1742, 6, 73, -1, 0, 1742, 1744, 1, 0, 0, 0, 1743, 1729, 1, 0, 0, 0, 1743, 1730, 1, 0, 0, 0, 1743, 1731, 1, 0, 0, 0, 1743, 1734, 1, 0, 0, 0, 1743, 1739, 1, 0, 0, 0, 1744, 147, 1, 0, 0, 0, 1745, 1746, 5, 1, 0, 0, 1746, 1747, 5, 194, 0, 0, 1747, 1748, 6, 74, -1, 0, 1748, 149, 1, 0, 0, 0, 1749, 1753, 5, 1, 0, 0, 1750, 1751, 5, 90, 0, 0, 1751, 1754, 5, 194, 0, 0, 1752, 1754, 5, 195, 0, 0, 1753, 1750, 1, 0, 0, 0, 1753, 1752, 1, 0, 0, 0, 1754, 1755, 1, 0, 0, 0, 1755, 1756, 6, 75, -1, 0, 1756, 151, 1, 0, 0, 0, 1757, 1758, 5, 294, 0, 0, 1758, 1759, 3, 166, 83, 0, 1759, 1760, 3, 124, 62, 0, 1760, 1761, 5, 30, 0, 0, 1761, 1762, 3, 158, 79, 0, 1762, 1763, 5, 31, 0, 0, 1763, 1764, 6, 76, -1, 0, 1764, 1812, 1, 0, 0, 0, 1765, 1766, 5, 294, 0, 0, 1766, 1767, 3, 166, 83, 0, 1767, 1768, 3, 124, 62, 0, 1768, 1769, 5, 36, 0, 0, 1769, 1770, 5, 17, 0, 0, 1770, 1771, 3, 52, 26, 0, 1771, 1772, 5, 18, 0, 0, 1772, 1773, 6, 76, -1, 0, 1773, 1812, 1, 0, 0, 0, 1774, 1775, 5, 294, 0, 0, 1775, 1776, 3, 166, 83, 0, 1776, 1777, 3, 124, 62, 0, 1777, 1778, 6, 76, -1, 0, 1778, 1812, 1, 0, 0, 0, 1779, 1780, 5, 295, 0, 0, 1780, 1781, 3, 166, 83, 0, 1781, 1783, 5, 36, 0, 0, 1782, 1784, 5, 84, 0, 0, 1783, 1782, 1, 0, 0, 0, 1783, 1784, 1, 0, 0, 0, 1784, 1785, 1, 0, 0, 0, 1785, 1786, 5, 30, 0, 0, 1786, 1787, 3, 300, 150, 0, 1787, 1788, 5, 31, 0, 0, 1788, 1789, 6, 76, -1, 0, 1789, 1812, 1, 0, 0, 0, 1790, 1791, 5, 295, 0, 0, 1791, 1792, 3, 166, 83, 0, 1792, 1793, 5, 84, 0, 0, 1793, 1794, 5, 30, 0, 0, 1794, 1795, 3, 300, 150, 0, 1795, 1796, 5, 31, 0, 0, 1796, 1797, 6, 76, -1, 0, 1797, 1812, 1, 0, 0, 0, 1798, 1799, 5, 295, 0, 0, 1799, 1800, 3, 166, 83, 0, 1800, 1801, 3, 6, 3, 0, 1801, 1802, 6, 76, -1, 0, 1802, 1812, 1, 0, 0, 0, 1803, 1804, 5, 295, 0, 0, 1804, 1805, 3, 166, 83, 0, 1805, 1806, 5, 36, 0, 0, 1806, 1807, 5, 17, 0, 0, 1807, 1808, 3, 154, 77, 0, 1808, 1809, 5, 18, 0, 0, 1809, 1810, 6, 76, -1, 0, 1810, 1812, 1, 0, 0, 0, 1811, 1757, 1, 0, 0, 0, 1811, 1765, 1, 0, 0, 0, 1811, 1774, 1, 0, 0, 0, 1811, 1779, 1, 0, 0, 0, 1811, 1790, 1, 0, 0, 0, 1811, 1798, 1, 0, 0, 0, 1811, 1803, 1, 0, 0, 0, 1812, 153, 1, 0, 0, 0, 1813, 1827, 1, 0, 0, 0, 1814, 1815, 3, 156, 78, 0, 1815, 1816, 6, 77, -1, 0, 1816, 1817, 5, 28, 0, 0, 1817, 1819, 1, 0, 0, 0, 1818, 1814, 1, 0, 0, 0, 1819, 1822, 1, 0, 0, 0, 1820, 1818, 1, 0, 0, 0, 1820, 1821, 1, 0, 0, 0, 1821, 1823, 1, 0, 0, 0, 1822, 1820, 1, 0, 0, 0, 1823, 1824, 3, 156, 78, 0, 1824, 1825, 6, 77, -1, 0, 1825, 1827, 1, 0, 0, 0, 1826, 1813, 1, 0, 0, 0, 1826, 1820, 1, 0, 0, 0, 1827, 155, 1, 0, 0, 0, 1828, 1829, 5, 39, 0, 0, 1829, 1830, 5, 264, 0, 0, 1830, 1831, 5, 36, 0, 0, 1831, 1832, 5, 17, 0, 0, 1832, 1833, 3, 56, 28, 0, 1833, 1834, 5, 18, 0, 0, 1834, 1835, 6, 78, -1, 0, 1835, 1844, 1, 0, 0, 0, 1836, 1837, 3, 124, 62, 0, 1837, 1838, 5, 36, 0, 0, 1838, 1839, 5, 17, 0, 0, 1839, 1840, 3, 56, 28, 0, 1840, 1841, 5, 18, 0, 0, 1841, 1842, 6, 78, -1, 0, 1842, 1844, 1, 0, 0, 0, 1843, 1828, 1, 0, 0, 0, 1843, 1836, 1, 0, 0, 0, 1844, 157, 1, 0, 0, 0, 1845, 1846, 3, 160, 80, 0, 1846, 1847, 6, 79, -1, 0, 1847, 1848, 5, 28, 0, 0, 1848, 1850, 1, 0, 0, 0, 1849, 1845, 1, 0, 0, 0, 1850, 1853, 1, 0, 0, 0, 1851, 1849, 1, 0, 0, 0, 1851, 1852, 1, 0, 0, 0, 1852, 1854, 1, 0, 0, 0, 1853, 1851, 1, 0, 0, 0, 1854, 1855, 3, 160, 80, 0, 1855, 1856, 6, 79, -1, 0, 1856, 159, 1, 0, 0, 0, 1857, 1858, 3, 6, 3, 0, 1858, 1859, 5, 36, 0, 0, 1859, 1860, 3, 164, 82, 0, 1860, 1861, 6, 80, -1, 0, 1861, 161, 1, 0, 0, 0, 1862, 1863, 7, 8, 0, 0, 1863, 163, 1, 0, 0, 0, 1864, 1865, 3, 162, 81, 0, 1865, 1866, 6, 82, -1, 0, 1866, 1910, 1, 0, 0, 0, 1867, 1868, 3, 32, 16, 0, 1868, 1869, 6, 82, -1, 0, 1869, 1910, 1, 0, 0, 0, 1870, 1871, 5, 186, 0, 0, 1871, 1872, 5, 30, 0, 0, 1872, 1873, 3, 32, 16, 0, 1873, 1874, 5, 31, 0, 0, 1874, 1875, 6, 82, -1, 0, 1875, 1910, 1, 0, 0, 0, 1876, 1877, 3, 6, 3, 0, 1877, 1878, 6, 82, -1, 0, 1878, 1910, 1, 0, 0, 0, 1879, 1880, 3, 116, 58, 0, 1880, 1881, 5, 30, 0, 0, 1881, 1882, 5, 184, 0, 0, 1882, 1883, 5, 75, 0, 0, 1883, 1884, 3, 32, 16, 0, 1884, 1885, 5, 31, 0, 0, 1885, 1886, 6, 82, -1, 0, 1886, 1910, 1, 0, 0, 0, 1887, 1888, 3, 116, 58, 0, 1888, 1889, 5, 30, 0, 0, 1889, 1890, 5, 185, 0, 0, 1890, 1891, 5, 75, 0, 0, 1891, 1892, 3, 32, 16, 0, 1892, 1893, 5, 31, 0, 0, 1893, 1894, 6, 82, -1, 0, 1894, 1910, 1, 0, 0, 0, 1895, 1896, 3, 116, 58, 0, 1896, 1897, 5, 30, 0, 0, 1897, 1898, 5, 186, 0, 0, 1898, 1899, 5, 75, 0, 0, 1899, 1900, 3, 32, 16, 0, 1900, 1901, 5, 31, 0, 0, 1901, 1902, 6, 82, -1, 0, 1902, 1910, 1, 0, 0, 0, 1903, 1904, 3, 116, 58, 0, 1904, 1905, 5, 30, 0, 0, 1905, 1906, 3, 32, 16, 0, 1906, 1907, 5, 31, 0, 0, 1907, 1908, 6, 82, -1, 0, 1908, 1910, 1, 0, 0, 0, 1909, 1864, 1, 0, 0, 0, 1909, 1867, 1, 0, 0, 0, 1909, 1870, 1, 0, 0, 0, 1909, 1876, 1, 0, 0, 0, 1909, 1879, 1, 0, 0, 0, 1909, 1887, 1, 0, 0, 0, 1909, 1895, 1, 0, 0, 0, 1909, 1903, 1, 0, 0, 0, 1910, 165, 1, 0, 0, 0, 1911, 1912, 7, 9, 0, 0, 1912, 167, 1, 0, 0, 0, 1913, 1914, 3, 170, 85, 0, 1914, 1915, 3, 138, 69, 0, 1915, 1916, 3, 124, 62, 0, 1916, 1917, 5, 176, 0, 0, 1917, 1919, 3, 242, 121, 0, 1918, 1920, 3, 108, 54, 0, 1919, 1918, 1, 0, 0, 0, 1919, 1920, 1, 0, 0, 0, 1920, 1921, 1, 0, 0, 0, 1921, 1922, 3, 112, 56, 0, 1922, 1923, 6, 84, -1, 0, 1923, 1956, 1, 0, 0, 0, 1924, 1925, 3, 170, 85, 0, 1925, 1926, 3, 138, 69, 0, 1926, 1927, 3, 124, 62, 0, 1927, 1928, 5, 176, 0, 0, 1928, 1929, 3, 242, 121, 0, 1929, 1930, 3, 196, 98, 0, 1930, 1931, 3, 112, 56, 0, 1931, 1932, 6, 84, -1, 0, 1932, 1956, 1, 0, 0, 0, 1933, 1934, 3, 170, 85, 0, 1934, 1935, 3, 138, 69, 0, 1935, 1937, 3, 242, 121, 0, 1936, 1938, 3, 108, 54, 0, 1937, 1936, 1, 0, 0, 0, 1937, 1938, 1, 0, 0, 0, 1938, 1939, 1, 0, 0, 0, 1939, 1940, 3, 112, 56, 0, 1940, 1941, 6, 84, -1, 0, 1941, 1956, 1, 0, 0, 0, 1942, 1943, 3, 170, 85, 0, 1943, 1944, 3, 138, 69, 0, 1944, 1945, 3, 242, 121, 0, 1945, 1946, 3, 196, 98, 0, 1946, 1947, 3, 112, 56, 0, 1947, 1948, 6, 84, -1, 0, 1948, 1956, 1, 0, 0, 0, 1949, 1950, 3, 174, 87, 0, 1950, 1951, 6, 84, -1, 0, 1951, 1956, 1, 0, 0, 0, 1952, 1953, 3, 2, 1, 0, 1953, 1954, 6, 84, -1, 0, 1954, 1956, 1, 0, 0, 0, 1955, 1913, 1, 0, 0, 0, 1955, 1924, 1, 0, 0, 0, 1955, 1933, 1, 0, 0, 0, 1955, 1942, 1, 0, 0, 0, 1955, 1949, 1, 0, 0, 0, 1955, 1952, 1, 0, 0, 0, 1956, 169, 1, 0, 0, 0, 1957, 1958, 5, 243, 0, 0, 1958, 1959, 3, 170, 85, 0, 1959, 1960, 6, 85, -1, 0, 1960, 1975, 1, 0, 0, 0, 1961, 1962, 5, 244, 0, 0, 1962, 1963, 3, 170, 85, 0, 1963, 1964, 6, 85, -1, 0, 1964, 1975, 1, 0, 0, 0, 1965, 1966, 3, 172, 86, 0, 1966, 1967, 6, 85, -1, 0, 1967, 1975, 1, 0, 0, 0, 1968, 1969, 5, 112, 0, 0, 1969, 1970, 5, 30, 0, 0, 1970, 1971, 3, 32, 16, 0, 1971, 1972, 5, 31, 0, 0, 1972, 1973, 6, 85, -1, 0, 1973, 1975, 1, 0, 0, 0, 1974, 1957, 1, 0, 0, 0, 1974, 1961, 1, 0, 0, 0, 1974, 1965, 1, 0, 0, 0, 1974, 1968, 1, 0, 0, 0, 1975, 171, 1, 0, 0, 0, 1976, 1996, 1, 0, 0, 0, 1977, 1978, 5, 245, 0, 0, 1978, 1996, 6, 86, -1, 0, 1979, 1980, 5, 246, 0, 0, 1980, 1996, 6, 86, -1, 0, 1981, 1982, 5, 247, 0, 0, 1982, 1983, 5, 248, 0, 0, 1983, 1996, 6, 86, -1, 0, 1984, 1985, 5, 247, 0, 0, 1985, 1986, 5, 249, 0, 0, 1986, 1996, 6, 86, -1, 0, 1987, 1988, 5, 247, 0, 0, 1988, 1989, 5, 250, 0, 0, 1989, 1996, 6, 86, -1, 0, 1990, 1991, 5, 247, 0, 0, 1991, 1992, 5, 251, 0, 0, 1992, 1996, 6, 86, -1, 0, 1993, 1994, 5, 247, 0, 0, 1994, 1996, 6, 86, -1, 0, 1995, 1976, 1, 0, 0, 0, 1995, 1977, 1, 0, 0, 0, 1995, 1979, 1, 0, 0, 0, 1995, 1981, 1, 0, 0, 0, 1995, 1984, 1, 0, 0, 0, 1995, 1987, 1, 0, 0, 0, 1995, 1990, 1, 0, 0, 0, 1995, 1993, 1, 0, 0, 0, 1996, 173, 1, 0, 0, 0, 1997, 1998, 5, 113, 0, 0, 1998, 1999, 5, 30, 0, 0, 1999, 2000, 3, 32, 16, 0, 2000, 2001, 5, 31, 0, 0, 2001, 2002, 6, 87, -1, 0, 2002, 175, 1, 0, 0, 0, 2003, 2004, 5, 226, 0, 0, 2004, 2005, 3, 168, 84, 0, 2005, 2006, 6, 88, -1, 0, 2006, 2015, 1, 0, 0, 0, 2007, 2008, 5, 37, 0, 0, 2008, 2009, 3, 178, 89, 0, 2009, 2010, 6, 88, -1, 0, 2010, 2015, 1, 0, 0, 0, 2011, 2012, 3, 174, 87, 0, 2012, 2013, 6, 88, -1, 0, 2013, 2015, 1, 0, 0, 0, 2014, 2003, 1, 0, 0, 0, 2014, 2007, 1, 0, 0, 0, 2014, 2011, 1, 0, 0, 0, 2015, 177, 1, 0, 0, 0, 2016, 2017, 3, 138, 69, 0, 2017, 2018, 3, 124, 62, 0, 2018, 2019, 5, 176, 0, 0, 2019, 2020, 3, 2, 1, 0, 2020, 2021, 6, 89, -1, 0, 2021, 2030, 1, 0, 0, 0, 2022, 2023, 3, 138, 69, 0, 2023, 2024, 3, 2, 1, 0, 2024, 2025, 6, 89, -1, 0, 2025, 2030, 1, 0, 0, 0, 2026, 2027, 3, 2, 1, 0, 2027, 2028, 6, 89, -1, 0, 2028, 2030, 1, 0, 0, 0, 2029, 2016, 1, 0, 0, 0, 2029, 2022, 1, 0, 0, 0, 2029, 2026, 1, 0, 0, 0, 2030, 179, 1, 0, 0, 0, 2031, 2032, 3, 124, 62, 0, 2032, 2033, 6, 90, -1, 0, 2033, 2034, 5, 28, 0, 0, 2034, 2036, 1, 0, 0, 0, 2035, 2031, 1, 0, 0, 0, 2036, 2039, 1, 0, 0, 0, 2037, 2035, 1, 0, 0, 0, 2037, 2038, 1, 0, 0, 0, 2038, 2040, 1, 0, 0, 0, 2039, 2037, 1, 0, 0, 0, 2040, 2041, 3, 124, 62, 0, 2041, 2042, 6, 90, -1, 0, 2042, 181, 1, 0, 0, 0, 2043, 2050, 1, 0, 0, 0, 2044, 2045, 5, 86, 0, 0, 2045, 2046, 3, 190, 95, 0, 2046, 2047, 5, 87, 0, 0, 2047, 2048, 6, 91, -1, 0, 2048, 2050, 1, 0, 0, 0, 2049, 2043, 1, 0, 0, 0, 2049, 2044, 1, 0, 0, 0, 2050, 183, 1, 0, 0, 0, 2051, 2052, 5, 266, 0, 0, 2052, 2070, 6, 92, -1, 0, 2053, 2054, 5, 114, 0, 0, 2054, 2070, 6, 92, -1, 0, 2055, 2056, 5, 39, 0, 0, 2056, 2070, 6, 92, -1, 0, 2057, 2058, 5, 200, 0, 0, 2058, 2070, 6, 92, -1, 0, 2059, 2060, 5, 115, 0, 0, 2060, 2070, 6, 92, -1, 0, 2061, 2062, 5, 116, 0, 0, 2062, 2070, 6, 92, -1, 0, 2063, 2064, 5, 70, 0, 0, 2064, 2065, 5, 30, 0, 0, 2065, 2066, 3, 32, 16, 0, 2066, 2067, 5, 31, 0, 0, 2067, 2068, 6, 92, -1, 0, 2068, 2070, 1, 0, 0, 0, 2069, 2051, 1, 0, 0, 0, 2069, 2053, 1, 0, 0, 0, 2069, 2055, 1, 0, 0, 0, 2069, 2057, 1, 0, 0, 0, 2069, 2059, 1, 0, 0, 0, 2069, 2061, 1, 0, 0, 0, 2069, 2063, 1, 0, 0, 0, 2070, 185, 1, 0, 0, 0, 2071, 2072, 3, 184, 92, 0, 2072, 2073, 6, 93, -1, 0, 2073, 2075, 1, 0, 0, 0, 2074, 2071, 1, 0, 0, 0, 2075, 2078, 1, 0, 0, 0, 2076, 2074, 1, 0, 0, 0, 2076, 2077, 1, 0, 0, 0, 2077, 187, 1, 0, 0, 0, 2078, 2076, 1, 0, 0, 0, 2079, 2081, 3, 186, 93, 0, 2080, 2082, 3, 192, 96, 0, 2081, 2080, 1, 0, 0, 0, 2081, 2082, 1, 0, 0, 0, 2082, 2083, 1, 0, 0, 0, 2083, 2084, 3, 2, 1, 0, 2084, 2085, 6, 94, -1, 0, 2085, 189, 1, 0, 0, 0, 2086, 2087, 3, 188, 94, 0, 2087, 2088, 6, 95, -1, 0, 2088, 2089, 5, 28, 0, 0, 2089, 2091, 1, 0, 0, 0, 2090, 2086, 1, 0, 0, 0, 2091, 2094, 1, 0, 0, 0, 2092, 2090, 1, 0, 0, 0, 2092, 2093, 1, 0, 0, 0, 2093, 2095, 1, 0, 0, 0, 2094, 2092, 1, 0, 0, 0, 2095, 2096, 3, 188, 94, 0, 2096, 2097, 6, 95, -1, 0, 2097, 191, 1, 0, 0, 0, 2098, 2099, 5, 30, 0, 0, 2099, 2100, 3, 180, 90, 0, 2100, 2101, 5, 31, 0, 0, 2101, 2102, 6, 96, -1, 0, 2102, 193, 1, 0, 0, 0, 2103, 2105, 3, 196, 98, 0, 2104, 2103, 1, 0, 0, 0, 2104, 2105, 1, 0, 0, 0, 2105, 2106, 1, 0, 0, 0, 2106, 2107, 6, 97, -1, 0, 2107, 195, 1, 0, 0, 0, 2108, 2109, 5, 86, 0, 0, 2109, 2110, 5, 42, 0, 0, 2110, 2111, 3, 32, 16, 0, 2111, 2112, 5, 43, 0, 0, 2112, 2113, 5, 87, 0, 0, 2113, 2114, 6, 98, -1, 0, 2114, 197, 1, 0, 0, 0, 2115, 2116, 3, 234, 117, 0, 2116, 2117, 5, 17, 0, 0, 2117, 2118, 3, 246, 123, 0, 2118, 2119, 5, 18, 0, 0, 2119, 2266, 1, 0, 0, 0, 2120, 2121, 3, 74, 37, 0, 2121, 2122, 5, 17, 0, 0, 2122, 2123, 3, 82, 41, 0, 2123, 2124, 5, 18, 0, 0, 2124, 2266, 1, 0, 0, 0, 2125, 2126, 3, 210, 105, 0, 2126, 2127, 6, 99, -1, 0, 2127, 2128, 5, 17, 0, 0, 2128, 2129, 3, 214, 107, 0, 2129, 2130, 5, 18, 0, 0, 2130, 2266, 1, 0, 0, 0, 2131, 2132, 3, 218, 109, 0, 2132, 2133, 6, 99, -1, 0, 2133, 2134, 5, 17, 0, 0, 2134, 2135, 3, 222, 111, 0, 2135, 2136, 5, 18, 0, 0, 2136, 2266, 1, 0, 0, 0, 2137, 2266, 3, 200, 100, 0, 2138, 2139, 3, 284, 142, 0, 2139, 2140, 6, 99, -1, 0, 2140, 2266, 1, 0, 0, 0, 2141, 2142, 3, 152, 76, 0, 2142, 2143, 6, 99, -1, 0, 2143, 2266, 1, 0, 0, 0, 2144, 2145, 3, 88, 44, 0, 2145, 2146, 6, 99, -1, 0, 2146, 2266, 1, 0, 0, 0, 2147, 2148, 3, 330, 165, 0, 2148, 2149, 6, 99, -1, 0, 2149, 2266, 1, 0, 0, 0, 2150, 2151, 5, 117, 0, 0, 2151, 2152, 3, 32, 16, 0, 2152, 2153, 6, 99, -1, 0, 2153, 2266, 1, 0, 0, 0, 2154, 2155, 5, 118, 0, 0, 2155, 2156, 3, 32, 16, 0, 2156, 2157, 6, 99, -1, 0, 2157, 2266, 1, 0, 0, 0, 2158, 2159, 3, 346, 173, 0, 2159, 2160, 5, 17, 0, 0, 2160, 2161, 3, 350, 175, 0, 2161, 2162, 5, 18, 0, 0, 2162, 2163, 6, 99, -1, 0, 2163, 2266, 1, 0, 0, 0, 2164, 2165, 5, 302, 0, 0, 2165, 2166, 3, 124, 62, 0, 2166, 2167, 5, 176, 0, 0, 2167, 2168, 3, 242, 121, 0, 2168, 2169, 5, 119, 0, 0, 2169, 2170, 3, 170, 85, 0, 2170, 2171, 3, 138, 69, 0, 2171, 2172, 3, 124, 62, 0, 2172, 2173, 5, 176, 0, 0, 2173, 2174, 3, 242, 121, 0, 2174, 2175, 3, 112, 56, 0, 2175, 2176, 6, 99, -1, 0, 2176, 2266, 1, 0, 0, 0, 2177, 2178, 5, 302, 0, 0, 2178, 2179, 5, 226, 0, 0, 2179, 2180, 3, 170, 85, 0, 2180, 2181, 3, 138, 69, 0, 2181, 2182, 3, 124, 62, 0, 2182, 2183, 5, 176, 0, 0, 2183, 2184, 3, 242, 121, 0, 2184, 2185, 3, 194, 97, 0, 2185, 2186, 3, 112, 56, 0, 2186, 2187, 5, 119, 0, 0, 2187, 2188, 5, 226, 0, 0, 2188, 2189, 3, 170, 85, 0, 2189, 2190, 3, 138, 69, 0, 2190, 2191, 3, 124, 62, 0, 2191, 2192, 5, 176, 0, 0, 2192, 2193, 3, 242, 121, 0, 2193, 2194, 3, 194, 97, 0, 2194, 2195, 3, 112, 56, 0, 2195, 2196, 6, 99, -1, 0, 2196, 2266, 1, 0, 0, 0, 2197, 2198, 3, 26, 13, 0, 2198, 2199, 6, 99, -1, 0, 2199, 2266, 1, 0, 0, 0, 2200, 2201, 3, 40, 20, 0, 2201, 2202, 6, 99, -1, 0, 2202, 2266, 1, 0, 0, 0, 2203, 2204, 5, 255, 0, 0, 2204, 2205, 5, 196, 0, 0, 2205, 2206, 5, 42, 0, 0, 2206, 2207, 3, 32, 16, 0, 2207, 2208, 5, 43, 0, 0, 2208, 2214, 6, 99, -1, 0, 2209, 2210, 3, 330, 165, 0, 2210, 2211, 6, 99, -1, 0, 2211, 2213, 1, 0, 0, 0, 2212, 2209, 1, 0, 0, 0, 2213, 2216, 1, 0, 0, 0, 2214, 2212, 1, 0, 0, 0, 2214, 2215, 1, 0, 0, 0, 2215, 2266, 1, 0, 0, 0, 2216, 2214, 1, 0, 0, 0, 2217, 2218, 5, 255, 0, 0, 2218, 2219, 5, 196, 0, 0, 2219, 2220, 3, 2, 1, 0, 2220, 2226, 6, 99, -1, 0, 2221, 2222, 3, 330, 165, 0, 2222, 2223, 6, 99, -1, 0, 2223, 2225, 1, 0, 0, 0, 2224, 2221, 1, 0, 0, 0, 2225, 2228, 1, 0, 0, 0, 2226, 2224, 1, 0, 0, 0, 2226, 2227, 1, 0, 0, 0, 2227, 2266, 1, 0, 0, 0, 2228, 2226, 1, 0, 0, 0, 2229, 2230, 5, 255, 0, 0, 2230, 2231, 5, 256, 0, 0, 2231, 2232, 5, 42, 0, 0, 2232, 2233, 3, 32, 16, 0, 2233, 2234, 5, 43, 0, 0, 2234, 2235, 5, 28, 0, 0, 2235, 2236, 3, 124, 62, 0, 2236, 2242, 6, 99, -1, 0, 2237, 2238, 3, 330, 165, 0, 2238, 2239, 6, 99, -1, 0, 2239, 2241, 1, 0, 0, 0, 2240, 2237, 1, 0, 0, 0, 2241, 2244, 1, 0, 0, 0, 2242, 2240, 1, 0, 0, 0, 2242, 2243, 1, 0, 0, 0, 2243, 2266, 1, 0, 0, 0, 2244, 2242, 1, 0, 0, 0, 2245, 2246, 5, 255, 0, 0, 2246, 2247, 5, 256, 0, 0, 2247, 2248, 3, 2, 1, 0, 2248, 2249, 5, 28, 0, 0, 2249, 2250, 3, 124, 62, 0, 2250, 2256, 6, 99, -1, 0, 2251, 2252, 3, 330, 165, 0, 2252, 2253, 6, 99, -1, 0, 2253, 2255, 1, 0, 0, 0, 2254, 2251, 1, 0, 0, 0, 2255, 2258, 1, 0, 0, 0, 2256, 2254, 1, 0, 0, 0, 2256, 2257, 1, 0, 0, 0, 2257, 2266, 1, 0, 0, 0, 2258, 2256, 1, 0, 0, 0, 2259, 2260, 5, 120, 0, 0, 2260, 2261, 5, 196, 0, 0, 2261, 2262, 3, 124, 62, 0, 2262, 2263, 3, 44, 22, 0, 2263, 2264, 6, 99, -1, 0, 2264, 2266, 1, 0, 0, 0, 2265, 2115, 1, 0, 0, 0, 2265, 2120, 1, 0, 0, 0, 2265, 2125, 1, 0, 0, 0, 2265, 2131, 1, 0, 0, 0, 2265, 2137, 1, 0, 0, 0, 2265, 2138, 1, 0, 0, 0, 2265, 2141, 1, 0, 0, 0, 2265, 2144, 1, 0, 0, 0, 2265, 2147, 1, 0, 0, 0, 2265, 2150, 1, 0, 0, 0, 2265, 2154, 1, 0, 0, 0, 2265, 2158, 1, 0, 0, 0, 2265, 2164, 1, 0, 0, 0, 2265, 2177, 1, 0, 0, 0, 2265, 2197, 1, 0, 0, 0, 2265, 2200, 1, 0, 0, 0, 2265, 2203, 1, 0, 0, 0, 2265, 2217, 1, 0, 0, 0, 2265, 2229, 1, 0, 0, 0, 2265, 2245, 1, 0, 0, 0, 2265, 2259, 1, 0, 0, 0, 2266, 199, 1, 0, 0, 0, 2267, 2268, 5, 121, 0, 0, 2268, 2280, 3, 208, 104, 0, 2269, 2270, 3, 202, 101, 0, 2270, 2271, 6, 100, -1, 0, 2271, 2279, 1, 0, 0, 0, 2272, 2273, 5, 122, 0, 0, 2273, 2274, 5, 30, 0, 0, 2274, 2275, 3, 228, 114, 0, 2275, 2276, 5, 31, 0, 0, 2276, 2277, 6, 100, -1, 0, 2277, 2279, 1, 0, 0, 0, 2278, 2269, 1, 0, 0, 0, 2278, 2272, 1, 0, 0, 0, 2279, 2282, 1, 0, 0, 0, 2280, 2278, 1, 0, 0, 0, 2280, 2281, 1, 0, 0, 0, 2281, 2283, 1, 0, 0, 0, 2282, 2280, 1, 0, 0, 0, 2283, 2284, 3, 138, 69, 0, 2284, 2285, 3, 2, 1, 0, 2285, 2286, 3, 204, 102, 0, 2286, 2287, 3, 206, 103, 0, 2287, 2288, 6, 100, -1, 0, 2288, 201, 1, 0, 0, 0, 2289, 2290, 5, 123, 0, 0, 2290, 2324, 6, 101, -1, 0, 2291, 2292, 5, 51, 0, 0, 2292, 2324, 6, 101, -1, 0, 2293, 2294, 5, 52, 0, 0, 2294, 2324, 6, 101, -1, 0, 2295, 2296, 5, 63, 0, 0, 2296, 2324, 6, 101, -1, 0, 2297, 2298, 5, 124, 0, 0, 2298, 2324, 6, 101, -1, 0, 2299, 2300, 5, 69, 0, 0, 2300, 2324, 6, 101, -1, 0, 2301, 2302, 5, 68, 0, 0, 2302, 2324, 6, 101, -1, 0, 2303, 2304, 5, 64, 0, 0, 2304, 2324, 6, 101, -1, 0, 2305, 2306, 5, 65, 0, 0, 2306, 2324, 6, 101, -1, 0, 2307, 2308, 5, 66, 0, 0, 2308, 2324, 6, 101, -1, 0, 2309, 2310, 5, 125, 0, 0, 2310, 2324, 6, 101, -1, 0, 2311, 2312, 5, 126, 0, 0, 2312, 2324, 6, 101, -1, 0, 2313, 2314, 5, 127, 0, 0, 2314, 2324, 6, 101, -1, 0, 2315, 2316, 5, 16, 0, 0, 2316, 2324, 6, 101, -1, 0, 2317, 2318, 5, 70, 0, 0, 2318, 2319, 5, 30, 0, 0, 2319, 2320, 3, 32, 16, 0, 2320, 2321, 5, 31, 0, 0, 2321, 2322, 6, 101, -1, 0, 2322, 2324, 1, 0, 0, 0, 2323, 2289, 1, 0, 0, 0, 2323, 2291, 1, 0, 0, 0, 2323, 2293, 1, 0, 0, 0, 2323, 2295, 1, 0, 0, 0, 2323, 2297, 1, 0, 0, 0, 2323, 2299, 1, 0, 0, 0, 2323, 2301, 1, 0, 0, 0, 2323, 2303, 1, 0, 0, 0, 2323, 2305, 1, 0, 0, 0, 2323, 2307, 1, 0, 0, 0, 2323, 2309, 1, 0, 0, 0, 2323, 2311, 1, 0, 0, 0, 2323, 2313, 1, 0, 0, 0, 2323, 2315, 1, 0, 0, 0, 2323, 2317, 1, 0, 0, 0, 2324, 203, 1, 0, 0, 0, 2325, 2335, 1, 0, 0, 0, 2326, 2327, 5, 44, 0, 0, 2327, 2328, 3, 0, 0, 0, 2328, 2329, 6, 102, -1, 0, 2329, 2335, 1, 0, 0, 0, 2330, 2331, 5, 44, 0, 0, 2331, 2332, 3, 32, 16, 0, 2332, 2333, 6, 102, -1, 0, 2333, 2335, 1, 0, 0, 0, 2334, 2325, 1, 0, 0, 0, 2334, 2326, 1, 0, 0, 0, 2334, 2330, 1, 0, 0, 0, 2335, 205, 1, 0, 0, 0, 2336, 2342, 1, 0, 0, 0, 2337, 2338, 5, 36, 0, 0, 2338, 2339, 3, 304, 152, 0, 2339, 2340, 6, 103, -1, 0, 2340, 2342, 1, 0, 0, 0, 2341, 2336, 1, 0, 0, 0, 2341, 2337, 1, 0, 0, 0, 2342, 207, 1, 0, 0, 0, 2343, 2350, 1, 0, 0, 0, 2344, 2345, 5, 42, 0, 0, 2345, 2346, 3, 32, 16, 0, 2346, 2347, 5, 43, 0, 0, 2347, 2348, 6, 104, -1, 0, 2348, 2350, 1, 0, 0, 0, 2349, 2343, 1, 0, 0, 0, 2349, 2344, 1, 0, 0, 0, 2350, 209, 1, 0, 0, 0, 2351, 2357, 5, 128, 0, 0, 2352, 2353, 3, 212, 106, 0, 2353, 2354, 6, 105, -1, 0, 2354, 2356, 1, 0, 0, 0, 2355, 2352, 1, 0, 0, 0, 2356, 2359, 1, 0, 0, 0, 2357, 2355, 1, 0, 0, 0, 2357, 2358, 1, 0, 0, 0, 2358, 2360, 1, 0, 0, 0, 2359, 2357, 1, 0, 0, 0, 2360, 2361, 3, 124, 62, 0, 2361, 2362, 3, 2, 1, 0, 2362, 2363, 6, 105, -1, 0, 2363, 2377, 1, 0, 0, 0, 2364, 2370, 5, 128, 0, 0, 2365, 2366, 3, 212, 106, 0, 2366, 2367, 6, 105, -1, 0, 2367, 2369, 1, 0, 0, 0, 2368, 2365, 1, 0, 0, 0, 2369, 2372, 1, 0, 0, 0, 2370, 2368, 1, 0, 0, 0, 2370, 2371, 1, 0, 0, 0, 2371, 2373, 1, 0, 0, 0, 2372, 2370, 1, 0, 0, 0, 2373, 2374, 3, 2, 1, 0, 2374, 2375, 6, 105, -1, 0, 2375, 2377, 1, 0, 0, 0, 2376, 2351, 1, 0, 0, 0, 2376, 2364, 1, 0, 0, 0, 2377, 211, 1, 0, 0, 0, 2378, 2379, 5, 69, 0, 0, 2379, 2383, 6, 106, -1, 0, 2380, 2381, 5, 68, 0, 0, 2381, 2383, 6, 106, -1, 0, 2382, 2378, 1, 0, 0, 0, 2382, 2380, 1, 0, 0, 0, 2383, 213, 1, 0, 0, 0, 2384, 2386, 3, 216, 108, 0, 2385, 2384, 1, 0, 0, 0, 2386, 2389, 1, 0, 0, 0, 2387, 2385, 1, 0, 0, 0, 2387, 2388, 1, 0, 0, 0, 2388, 215, 1, 0, 0, 0, 2389, 2387, 1, 0, 0, 0, 2390, 2391, 5, 129, 0, 0, 2391, 2392, 3, 168, 84, 0, 2392, 2393, 6, 108, -1, 0, 2393, 2417, 1, 0, 0, 0, 2394, 2395, 5, 130, 0, 0, 2395, 2396, 3, 168, 84, 0, 2396, 2397, 6, 108, -1, 0, 2397, 2417, 1, 0, 0, 0, 2398, 2399, 5, 131, 0, 0, 2399, 2400, 3, 168, 84, 0, 2400, 2401, 6, 108, -1, 0, 2401, 2417, 1, 0, 0, 0, 2402, 2403, 5, 132, 0, 0, 2403, 2404, 3, 168, 84, 0, 2404, 2405, 6, 108, -1, 0, 2405, 2417, 1, 0, 0, 0, 2406, 2407, 3, 88, 44, 0, 2407, 2408, 6, 108, -1, 0, 2408, 2417, 1, 0, 0, 0, 2409, 2410, 3, 330, 165, 0, 2410, 2411, 6, 108, -1, 0, 2411, 2417, 1, 0, 0, 0, 2412, 2413, 3, 26, 13, 0, 2413, 2414, 6, 108, -1, 0, 2414, 2417, 1, 0, 0, 0, 2415, 2417, 3, 40, 20, 0, 2416, 2390, 1, 0, 0, 0, 2416, 2394, 1, 0, 0, 0, 2416, 2398, 1, 0, 0, 0, 2416, 2402, 1, 0, 0, 0, 2416, 2406, 1, 0, 0, 0, 2416, 2409, 1, 0, 0, 0, 2416, 2412, 1, 0, 0, 0, 2416, 2415, 1, 0, 0, 0, 2417, 217, 1, 0, 0, 0, 2418, 2424, 5, 133, 0, 0, 2419, 2420, 3, 220, 110, 0, 2420, 2421, 6, 109, -1, 0, 2421, 2423, 1, 0, 0, 0, 2422, 2419, 1, 0, 0, 0, 2423, 2426, 1, 0, 0, 0, 2424, 2422, 1, 0, 0, 0, 2424, 2425, 1, 0, 0, 0, 2425, 2427, 1, 0, 0, 0, 2426, 2424, 1, 0, 0, 0, 2427, 2428, 3, 170, 85, 0, 2428, 2429, 3, 138, 69, 0, 2429, 2430, 3, 2, 1, 0, 2430, 2431, 3, 112, 56, 0, 2431, 2432, 3, 206, 103, 0, 2432, 2433, 6, 109, -1, 0, 2433, 219, 1, 0, 0, 0, 2434, 2435, 5, 69, 0, 0, 2435, 2439, 6, 110, -1, 0, 2436, 2437, 5, 68, 0, 0, 2437, 2439, 6, 110, -1, 0, 2438, 2434, 1, 0, 0, 0, 2438, 2436, 1, 0, 0, 0, 2439, 221, 1, 0, 0, 0, 2440, 2442, 3, 224, 112, 0, 2441, 2440, 1, 0, 0, 0, 2442, 2445, 1, 0, 0, 0, 2443, 2441, 1, 0, 0, 0, 2443, 2444, 1, 0, 0, 0, 2444, 223, 1, 0, 0, 0, 2445, 2443, 1, 0, 0, 0, 2446, 2447, 5, 134, 0, 0, 2447, 2448, 3, 168, 84, 0, 2448, 2449, 6, 112, -1, 0, 2449, 2469, 1, 0, 0, 0, 2450, 2451, 5, 135, 0, 0, 2451, 2452, 3, 168, 84, 0, 2452, 2453, 6, 112, -1, 0, 2453, 2469, 1, 0, 0, 0, 2454, 2455, 5, 132, 0, 0, 2455, 2456, 3, 168, 84, 0, 2456, 2457, 6, 112, -1, 0, 2457, 2469, 1, 0, 0, 0, 2458, 2459, 3, 330, 165, 0, 2459, 2460, 6, 112, -1, 0, 2460, 2469, 1, 0, 0, 0, 2461, 2462, 3, 88, 44, 0, 2462, 2463, 6, 112, -1, 0, 2463, 2469, 1, 0, 0, 0, 2464, 2465, 3, 26, 13, 0, 2465, 2466, 6, 112, -1, 0, 2466, 2469, 1, 0, 0, 0, 2467, 2469, 3, 40, 20, 0, 2468, 2446, 1, 0, 0, 0, 2468, 2450, 1, 0, 0, 0, 2468, 2454, 1, 0, 0, 0, 2468, 2458, 1, 0, 0, 0, 2468, 2461, 1, 0, 0, 0, 2468, 2464, 1, 0, 0, 0, 2468, 2467, 1, 0, 0, 0, 2469, 225, 1, 0, 0, 0, 2470, 2478, 6, 113, -1, 0, 2471, 2472, 5, 122, 0, 0, 2472, 2473, 5, 30, 0, 0, 2473, 2474, 3, 228, 114, 0, 2474, 2475, 5, 31, 0, 0, 2475, 2476, 6, 113, -1, 0, 2476, 2478, 1, 0, 0, 0, 2477, 2470, 1, 0, 0, 0, 2477, 2471, 1, 0, 0, 0, 2478, 227, 1, 0, 0, 0, 2479, 2480, 3, 126, 63, 0, 2480, 2481, 6, 114, -1, 0, 2481, 2493, 1, 0, 0, 0, 2482, 2486, 5, 17, 0, 0, 2483, 2484, 3, 302, 151, 0, 2484, 2485, 6, 114, -1, 0, 2485, 2487, 1, 0, 0, 0, 2486, 2483, 1, 0, 0, 0, 2487, 2488, 1, 0, 0, 0, 2488, 2486, 1, 0, 0, 0, 2488, 2489, 1, 0, 0, 0, 2489, 2490, 1, 0, 0, 0, 2490, 2491, 5, 18, 0, 0, 2491, 2493, 1, 0, 0, 0, 2492, 2479, 1, 0, 0, 0, 2492, 2482, 1, 0, 0, 0, 2493, 229, 1, 0, 0, 0, 2494, 2495, 3, 232, 116, 0, 2495, 2496, 6, 115, -1, 0, 2496, 2498, 1, 0, 0, 0, 2497, 2494, 1, 0, 0, 0, 2498, 2501, 1, 0, 0, 0, 2499, 2497, 1, 0, 0, 0, 2499, 2500, 1, 0, 0, 0, 2500, 231, 1, 0, 0, 0, 2501, 2499, 1, 0, 0, 0, 2502, 2503, 5, 42, 0, 0, 2503, 2504, 5, 136, 0, 0, 2504, 2505, 5, 43, 0, 0, 2505, 2520, 6, 116, -1, 0, 2506, 2507, 5, 42, 0, 0, 2507, 2508, 5, 137, 0, 0, 2508, 2509, 5, 43, 0, 0, 2509, 2520, 6, 116, -1, 0, 2510, 2511, 5, 42, 0, 0, 2511, 2512, 5, 138, 0, 0, 2512, 2513, 5, 43, 0, 0, 2513, 2520, 6, 116, -1, 0, 2514, 2515, 5, 42, 0, 0, 2515, 2516, 3, 32, 16, 0, 2516, 2517, 5, 43, 0, 0, 2517, 2518, 6, 116, -1, 0, 2518, 2520, 1, 0, 0, 0, 2519, 2502, 1, 0, 0, 0, 2519, 2506, 1, 0, 0, 0, 2519, 2510, 1, 0, 0, 0, 2519, 2514, 1, 0, 0, 0, 2520, 233, 1, 0, 0, 0, 2521, 2530, 5, 139, 0, 0, 2522, 2523, 3, 236, 118, 0, 2523, 2524, 6, 117, -1, 0, 2524, 2529, 1, 0, 0, 0, 2525, 2526, 3, 238, 119, 0, 2526, 2527, 6, 117, -1, 0, 2527, 2529, 1, 0, 0, 0, 2528, 2522, 1, 0, 0, 0, 2528, 2525, 1, 0, 0, 0, 2529, 2532, 1, 0, 0, 0, 2530, 2528, 1, 0, 0, 0, 2530, 2531, 1, 0, 0, 0, 2531, 2533, 1, 0, 0, 0, 2532, 2530, 1, 0, 0, 0, 2533, 2534, 3, 170, 85, 0, 2534, 2535, 3, 230, 115, 0, 2535, 2536, 3, 138, 69, 0, 2536, 2537, 3, 226, 113, 0, 2537, 2538, 3, 242, 121, 0, 2538, 2539, 3, 182, 91, 0, 2539, 2545, 3, 112, 56, 0, 2540, 2541, 3, 244, 122, 0, 2541, 2542, 6, 117, -1, 0, 2542, 2544, 1, 0, 0, 0, 2543, 2540, 1, 0, 0, 0, 2544, 2547, 1, 0, 0, 0, 2545, 2543, 1, 0, 0, 0, 2545, 2546, 1, 0, 0, 0, 2546, 2548, 1, 0, 0, 0, 2547, 2545, 1, 0, 0, 0, 2548, 2549, 6, 117, -1, 0, 2549, 235, 1, 0, 0, 0, 2550, 2551, 5, 123, 0, 0, 2551, 2593, 6, 118, -1, 0, 2552, 2553, 5, 51, 0, 0, 2553, 2593, 6, 118, -1, 0, 2554, 2555, 5, 52, 0, 0, 2555, 2593, 6, 118, -1, 0, 2556, 2557, 5, 63, 0, 0, 2557, 2593, 6, 118, -1, 0, 2558, 2559, 5, 140, 0, 0, 2559, 2593, 6, 118, -1, 0, 2560, 2561, 5, 68, 0, 0, 2561, 2593, 6, 118, -1, 0, 2562, 2563, 5, 141, 0, 0, 2563, 2593, 6, 118, -1, 0, 2564, 2565, 5, 142, 0, 0, 2565, 2593, 6, 118, -1, 0, 2566, 2567, 5, 54, 0, 0, 2567, 2593, 6, 118, -1, 0, 2568, 2569, 5, 64, 0, 0, 2569, 2593, 6, 118, -1, 0, 2570, 2571, 5, 65, 0, 0, 2571, 2593, 6, 118, -1, 0, 2572, 2573, 5, 66, 0, 0, 2573, 2593, 6, 118, -1, 0, 2574, 2575, 5, 125, 0, 0, 2575, 2593, 6, 118, -1, 0, 2576, 2577, 5, 143, 0, 0, 2577, 2593, 6, 118, -1, 0, 2578, 2579, 5, 144, 0, 0, 2579, 2593, 6, 118, -1, 0, 2580, 2581, 5, 69, 0, 0, 2581, 2593, 6, 118, -1, 0, 2582, 2583, 5, 145, 0, 0, 2583, 2593, 6, 118, -1, 0, 2584, 2585, 5, 146, 0, 0, 2585, 2593, 6, 118, -1, 0, 2586, 2587, 5, 70, 0, 0, 2587, 2588, 5, 30, 0, 0, 2588, 2589, 3, 32, 16, 0, 2589, 2590, 5, 31, 0, 0, 2590, 2591, 6, 118, -1, 0, 2591, 2593, 1, 0, 0, 0, 2592, 2550, 1, 0, 0, 0, 2592, 2552, 1, 0, 0, 0, 2592, 2554, 1, 0, 0, 0, 2592, 2556, 1, 0, 0, 0, 2592, 2558, 1, 0, 0, 0, 2592, 2560, 1, 0, 0, 0, 2592, 2562, 1, 0, 0, 0, 2592, 2564, 1, 0, 0, 0, 2592, 2566, 1, 0, 0, 0, 2592, 2568, 1, 0, 0, 0, 2592, 2570, 1, 0, 0, 0, 2592, 2572, 1, 0, 0, 0, 2592, 2574, 1, 0, 0, 0, 2592, 2576, 1, 0, 0, 0, 2592, 2578, 1, 0, 0, 0, 2592, 2580, 1, 0, 0, 0, 2592, 2582, 1, 0, 0, 0, 2592, 2584, 1, 0, 0, 0, 2592, 2586, 1, 0, 0, 0, 2593, 237, 1, 0, 0, 0, 2594, 2595, 5, 147, 0, 0, 2595, 2604, 5, 30, 0, 0, 2596, 2597, 3, 6, 3, 0, 2597, 2602, 6, 119, -1, 0, 2598, 2599, 5, 34, 0, 0, 2599, 2600, 3, 6, 3, 0, 2600, 2601, 6, 119, -1, 0, 2601, 2603, 1, 0, 0, 0, 2602, 2598, 1, 0, 0, 0, 2602, 2603, 1, 0, 0, 0, 2603, 2605, 1, 0, 0, 0, 2604, 2596, 1, 0, 0, 0, 2604, 2605, 1, 0, 0, 0, 2605, 2611, 1, 0, 0, 0, 2606, 2607, 3, 240, 120, 0, 2607, 2608, 6, 119, -1, 0, 2608, 2610, 1, 0, 0, 0, 2609, 2606, 1, 0, 0, 0, 2610, 2613, 1, 0, 0, 0, 2611, 2609, 1, 0, 0, 0, 2611, 2612, 1, 0, 0, 0, 2612, 2614, 1, 0, 0, 0, 2613, 2611, 1, 0, 0, 0, 2614, 2618, 5, 31, 0, 0, 2615, 2616, 5, 147, 0, 0, 2616, 2618, 5, 85, 0, 0, 2617, 2594, 1, 0, 0, 0, 2617, 2615, 1, 0, 0, 0, 2618, 239, 1, 0, 0, 0, 2619, 2620, 5, 148, 0, 0, 2620, 2662, 6, 120, -1, 0, 2621, 2622, 5, 224, 0, 0, 2622, 2662, 6, 120, -1, 0, 2623, 2624, 5, 57, 0, 0, 2624, 2662, 6, 120, -1, 0, 2625, 2626, 5, 58, 0, 0, 2626, 2662, 6, 120, -1, 0, 2627, 2628, 5, 149, 0, 0, 2628, 2662, 6, 120, -1, 0, 2629, 2630, 5, 150, 0, 0, 2630, 2662, 6, 120, -1, 0, 2631, 2632, 5, 248, 0, 0, 2632, 2662, 6, 120, -1, 0, 2633, 2634, 5, 249, 0, 0, 2634, 2662, 6, 120, -1, 0, 2635, 2636, 5, 250, 0, 0, 2636, 2662, 6, 120, -1, 0, 2637, 2638, 5, 251, 0, 0, 2638, 2662, 6, 120, -1, 0, 2639, 2640, 5, 151, 0, 0, 2640, 2641, 5, 75, 0, 0, 2641, 2642, 5, 152, 0, 0, 2642, 2662, 6, 120, -1, 0, 2643, 2644, 5, 151, 0, 0, 2644, 2645, 5, 75, 0, 0, 2645, 2646, 5, 153, 0, 0, 2646, 2662, 6, 120, -1, 0, 2647, 2648, 5, 154, 0, 0, 2648, 2649, 5, 75, 0, 0, 2649, 2650, 5, 152, 0, 0, 2650, 2662, 6, 120, -1, 0, 2651, 2652, 5, 154, 0, 0, 2652, 2653, 5, 75, 0, 0, 2653, 2654, 5, 153, 0, 0, 2654, 2662, 6, 120, -1, 0, 2655, 2656, 5, 70, 0, 0, 2656, 2657, 5, 30, 0, 0, 2657, 2658, 3, 32, 16, 0, 2658, 2659, 5, 31, 0, 0, 2659, 2660, 6, 120, -1, 0, 2660, 2662, 1, 0, 0, 0, 2661, 2619, 1, 0, 0, 0, 2661, 2621, 1, 0, 0, 0, 2661, 2623, 1, 0, 0, 0, 2661, 2625, 1, 0, 0, 0, 2661, 2627, 1, 0, 0, 0, 2661, 2629, 1, 0, 0, 0, 2661, 2631, 1, 0, 0, 0, 2661, 2633, 1, 0, 0, 0, 2661, 2635, 1, 0, 0, 0, 2661, 2637, 1, 0, 0, 0, 2661, 2639, 1, 0, 0, 0, 2661, 2643, 1, 0, 0, 0, 2661, 2647, 1, 0, 0, 0, 2661, 2651, 1, 0, 0, 0, 2661, 2655, 1, 0, 0, 0, 2662, 241, 1, 0, 0, 0, 2663, 2664, 5, 116, 0, 0, 2664, 2671, 6, 121, -1, 0, 2665, 2666, 5, 155, 0, 0, 2666, 2671, 6, 121, -1, 0, 2667, 2668, 3, 2, 1, 0, 2668, 2669, 6, 121, -1, 0, 2669, 2671, 1, 0, 0, 0, 2670, 2663, 1, 0, 0, 0, 2670, 2665, 1, 0, 0, 0, 2670, 2667, 1, 0, 0, 0, 2671, 243, 1, 0, 0, 0, 2672, 2673, 5, 1, 0, 0, 2673, 2711, 6, 122, -1, 0, 2674, 2675, 5, 2, 0, 0, 2675, 2711, 6, 122, -1, 0, 2676, 2677, 5, 156, 0, 0, 2677, 2711, 6, 122, -1, 0, 2678, 2679, 5, 3, 0, 0, 2679, 2711, 6, 122, -1, 0, 2680, 2681, 5, 4, 0, 0, 2681, 2711, 6, 122, -1, 0, 2682, 2683, 5, 247, 0, 0, 2683, 2711, 6, 122, -1, 0, 2684, 2685, 5, 5, 0, 0, 2685, 2711, 6, 122, -1, 0, 2686, 2687, 5, 6, 0, 0, 2687, 2711, 6, 122, -1, 0, 2688, 2689, 5, 7, 0, 0, 2689, 2711, 6, 122, -1, 0, 2690, 2691, 5, 8, 0, 0, 2691, 2711, 6, 122, -1, 0, 2692, 2693, 5, 9, 0, 0, 2693, 2711, 6, 122, -1, 0, 2694, 2695, 5, 10, 0, 0, 2695, 2711, 6, 122, -1, 0, 2696, 2697, 5, 11, 0, 0, 2697, 2711, 6, 122, -1, 0, 2698, 2699, 5, 12, 0, 0, 2699, 2711, 6, 122, -1, 0, 2700, 2701, 5, 13, 0, 0, 2701, 2711, 6, 122, -1, 0, 2702, 2703, 5, 14, 0, 0, 2703, 2711, 6, 122, -1, 0, 2704, 2705, 5, 70, 0, 0, 2705, 2706, 5, 30, 0, 0, 2706, 2707, 3, 32, 16, 0, 2707, 2708, 5, 31, 0, 0, 2708, 2709, 6, 122, -1, 0, 2709, 2711, 1, 0, 0, 0, 2710, 2672, 1, 0, 0, 0, 2710, 2674, 1, 0, 0, 0, 2710, 2676, 1, 0, 0, 0, 2710, 2678, 1, 0, 0, 0, 2710, 2680, 1, 0, 0, 0, 2710, 2682, 1, 0, 0, 0, 2710, 2684, 1, 0, 0, 0, 2710, 2686, 1, 0, 0, 0, 2710, 2688, 1, 0, 0, 0, 2710, 2690, 1, 0, 0, 0, 2710, 2692, 1, 0, 0, 0, 2710, 2694, 1, 0, 0, 0, 2710, 2696, 1, 0, 0, 0, 2710, 2698, 1, 0, 0, 0, 2710, 2700, 1, 0, 0, 0, 2710, 2702, 1, 0, 0, 0, 2710, 2704, 1, 0, 0, 0, 2711, 245, 1, 0, 0, 0, 2712, 2714, 3, 248, 124, 0, 2713, 2712, 1, 0, 0, 0, 2714, 2717, 1, 0, 0, 0, 2715, 2713, 1, 0, 0, 0, 2715, 2716, 1, 0, 0, 0, 2716, 247, 1, 0, 0, 0, 2717, 2715, 1, 0, 0, 0, 2718, 2756, 3, 100, 50, 0, 2719, 2720, 5, 296, 0, 0, 2720, 2721, 3, 32, 16, 0, 2721, 2722, 6, 124, -1, 0, 2722, 2756, 1, 0, 0, 0, 2723, 2756, 3, 266, 133, 0, 2724, 2725, 5, 297, 0, 0, 2725, 2726, 3, 32, 16, 0, 2726, 2727, 6, 124, -1, 0, 2727, 2756, 1, 0, 0, 0, 2728, 2729, 5, 298, 0, 0, 2729, 2756, 6, 124, -1, 0, 2730, 2731, 5, 299, 0, 0, 2731, 2756, 6, 124, -1, 0, 2732, 2756, 3, 260, 130, 0, 2733, 2756, 3, 264, 132, 0, 2734, 2756, 3, 250, 125, 0, 2735, 2736, 3, 284, 142, 0, 2736, 2737, 6, 124, -1, 0, 2737, 2756, 1, 0, 0, 0, 2738, 2739, 3, 152, 76, 0, 2739, 2740, 6, 124, -1, 0, 2740, 2756, 1, 0, 0, 0, 2741, 2742, 3, 88, 44, 0, 2742, 2743, 6, 124, -1, 0, 2743, 2756, 1, 0, 0, 0, 2744, 2745, 3, 26, 13, 0, 2745, 2746, 6, 124, -1, 0, 2746, 2756, 1, 0, 0, 0, 2747, 2748, 3, 262, 131, 0, 2748, 2749, 6, 124, -1, 0, 2749, 2756, 1, 0, 0, 0, 2750, 2756, 3, 40, 20, 0, 2751, 2756, 3, 252, 126, 0, 2752, 2756, 3, 254, 127, 0, 2753, 2756, 3, 256, 128, 0, 2754, 2756, 3, 258, 129, 0, 2755, 2718, 1, 0, 0, 0, 2755, 2719, 1, 0, 0, 0, 2755, 2723, 1, 0, 0, 0, 2755, 2724, 1, 0, 0, 0, 2755, 2728, 1, 0, 0, 0, 2755, 2730, 1, 0, 0, 0, 2755, 2732, 1, 0, 0, 0, 2755, 2733, 1, 0, 0, 0, 2755, 2734, 1, 0, 0, 0, 2755, 2735, 1, 0, 0, 0, 2755, 2738, 1, 0, 0, 0, 2755, 2741, 1, 0, 0, 0, 2755, 2744, 1, 0, 0, 0, 2755, 2747, 1, 0, 0, 0, 2755, 2750, 1, 0, 0, 0, 2755, 2751, 1, 0, 0, 0, 2755, 2752, 1, 0, 0, 0, 2755, 2753, 1, 0, 0, 0, 2755, 2754, 1, 0, 0, 0, 2756, 249, 1, 0, 0, 0, 2757, 2759, 5, 300, 0, 0, 2758, 2760, 5, 157, 0, 0, 2759, 2758, 1, 0, 0, 0, 2759, 2760, 1, 0, 0, 0, 2760, 2761, 1, 0, 0, 0, 2761, 2762, 3, 112, 56, 0, 2762, 251, 1, 0, 0, 0, 2763, 2764, 5, 301, 0, 0, 2764, 2765, 5, 42, 0, 0, 2765, 2766, 3, 32, 16, 0, 2766, 2769, 5, 43, 0, 0, 2767, 2768, 5, 34, 0, 0, 2768, 2770, 3, 0, 0, 0, 2769, 2767, 1, 0, 0, 0, 2769, 2770, 1, 0, 0, 0, 2770, 253, 1, 0, 0, 0, 2771, 2772, 5, 303, 0, 0, 2772, 2773, 3, 32, 16, 0, 2773, 2774, 5, 75, 0, 0, 2774, 2775, 3, 32, 16, 0, 2775, 255, 1, 0, 0, 0, 2776, 2777, 5, 302, 0, 0, 2777, 2778, 3, 124, 62, 0, 2778, 2779, 5, 176, 0, 0, 2779, 2780, 3, 242, 121, 0, 2780, 2792, 1, 0, 0, 0, 2781, 2782, 5, 302, 0, 0, 2782, 2783, 5, 226, 0, 0, 2783, 2784, 3, 170, 85, 0, 2784, 2785, 3, 138, 69, 0, 2785, 2786, 3, 124, 62, 0, 2786, 2787, 5, 176, 0, 0, 2787, 2788, 3, 242, 121, 0, 2788, 2789, 3, 194, 97, 0, 2789, 2790, 3, 112, 56, 0, 2790, 2792, 1, 0, 0, 0, 2791, 2776, 1, 0, 0, 0, 2791, 2781, 1, 0, 0, 0, 2792, 257, 1, 0, 0, 0, 2793, 2794, 5, 255, 0, 0, 2794, 2795, 5, 196, 0, 0, 2795, 2796, 5, 42, 0, 0, 2796, 2797, 3, 32, 16, 0, 2797, 2803, 5, 43, 0, 0, 2798, 2799, 3, 330, 165, 0, 2799, 2800, 6, 129, -1, 0, 2800, 2802, 1, 0, 0, 0, 2801, 2798, 1, 0, 0, 0, 2802, 2805, 1, 0, 0, 0, 2803, 2801, 1, 0, 0, 0, 2803, 2804, 1, 0, 0, 0, 2804, 2859, 1, 0, 0, 0, 2805, 2803, 1, 0, 0, 0, 2806, 2807, 5, 255, 0, 0, 2807, 2808, 5, 196, 0, 0, 2808, 2814, 3, 2, 1, 0, 2809, 2810, 3, 330, 165, 0, 2810, 2811, 6, 129, -1, 0, 2811, 2813, 1, 0, 0, 0, 2812, 2809, 1, 0, 0, 0, 2813, 2816, 1, 0, 0, 0, 2814, 2812, 1, 0, 0, 0, 2814, 2815, 1, 0, 0, 0, 2815, 2859, 1, 0, 0, 0, 2816, 2814, 1, 0, 0, 0, 2817, 2818, 5, 255, 0, 0, 2818, 2819, 5, 256, 0, 0, 2819, 2820, 5, 42, 0, 0, 2820, 2821, 3, 32, 16, 0, 2821, 2822, 5, 43, 0, 0, 2822, 2823, 5, 28, 0, 0, 2823, 2829, 3, 124, 62, 0, 2824, 2825, 3, 330, 165, 0, 2825, 2826, 6, 129, -1, 0, 2826, 2828, 1, 0, 0, 0, 2827, 2824, 1, 0, 0, 0, 2828, 2831, 1, 0, 0, 0, 2829, 2827, 1, 0, 0, 0, 2829, 2830, 1, 0, 0, 0, 2830, 2859, 1, 0, 0, 0, 2831, 2829, 1, 0, 0, 0, 2832, 2833, 5, 255, 0, 0, 2833, 2834, 5, 256, 0, 0, 2834, 2835, 3, 2, 1, 0, 2835, 2836, 5, 28, 0, 0, 2836, 2842, 3, 124, 62, 0, 2837, 2838, 3, 330, 165, 0, 2838, 2839, 6, 129, -1, 0, 2839, 2841, 1, 0, 0, 0, 2840, 2837, 1, 0, 0, 0, 2841, 2844, 1, 0, 0, 0, 2842, 2840, 1, 0, 0, 0, 2842, 2843, 1, 0, 0, 0, 2843, 2859, 1, 0, 0, 0, 2844, 2842, 1, 0, 0, 0, 2845, 2846, 5, 255, 0, 0, 2846, 2847, 5, 42, 0, 0, 2847, 2848, 3, 32, 16, 0, 2848, 2849, 5, 43, 0, 0, 2849, 2855, 3, 206, 103, 0, 2850, 2851, 3, 330, 165, 0, 2851, 2852, 6, 129, -1, 0, 2852, 2854, 1, 0, 0, 0, 2853, 2850, 1, 0, 0, 0, 2854, 2857, 1, 0, 0, 0, 2855, 2853, 1, 0, 0, 0, 2855, 2856, 1, 0, 0, 0, 2856, 2859, 1, 0, 0, 0, 2857, 2855, 1, 0, 0, 0, 2858, 2793, 1, 0, 0, 0, 2858, 2806, 1, 0, 0, 0, 2858, 2817, 1, 0, 0, 0, 2858, 2832, 1, 0, 0, 0, 2858, 2845, 1, 0, 0, 0, 2859, 259, 1, 0, 0, 0, 2860, 2861, 3, 0, 0, 0, 2861, 2862, 5, 75, 0, 0, 2862, 2863, 6, 130, -1, 0, 2863, 261, 1, 0, 0, 0, 2864, 2865, 3, 44, 22, 0, 2865, 2866, 6, 131, -1, 0, 2866, 2871, 1, 0, 0, 0, 2867, 2868, 3, 46, 23, 0, 2868, 2869, 6, 131, -1, 0, 2869, 2871, 1, 0, 0, 0, 2870, 2864, 1, 0, 0, 0, 2870, 2867, 1, 0, 0, 0, 2871, 263, 1, 0, 0, 0, 2872, 2873, 5, 17, 0, 0, 2873, 2874, 3, 246, 123, 0, 2874, 2875, 5, 18, 0, 0, 2875, 265, 1, 0, 0, 0, 2876, 2877, 3, 270, 135, 0, 2877, 2878, 3, 268, 134, 0, 2878, 267, 1, 0, 0, 0, 2879, 2880, 3, 272, 136, 0, 2880, 2881, 6, 134, -1, 0, 2881, 2883, 1, 0, 0, 0, 2882, 2879, 1, 0, 0, 0, 2883, 2884, 1, 0, 0, 0, 2884, 2882, 1, 0, 0, 0, 2884, 2885, 1, 0, 0, 0, 2885, 269, 1, 0, 0, 0, 2886, 2887, 5, 158, 0, 0, 2887, 2888, 3, 264, 132, 0, 2888, 2889, 6, 135, -1, 0, 2889, 2903, 1, 0, 0, 0, 2890, 2891, 5, 158, 0, 0, 2891, 2892, 3, 0, 0, 0, 2892, 2893, 5, 159, 0, 0, 2893, 2894, 3, 0, 0, 0, 2894, 2895, 6, 135, -1, 0, 2895, 2903, 1, 0, 0, 0, 2896, 2897, 5, 158, 0, 0, 2897, 2898, 3, 32, 16, 0, 2898, 2899, 5, 159, 0, 0, 2899, 2900, 3, 32, 16, 0, 2900, 2901, 6, 135, -1, 0, 2901, 2903, 1, 0, 0, 0, 2902, 2886, 1, 0, 0, 0, 2902, 2890, 1, 0, 0, 0, 2902, 2896, 1, 0, 0, 0, 2903, 271, 1, 0, 0, 0, 2904, 2905, 3, 276, 138, 0, 2905, 2906, 3, 282, 141, 0, 2906, 2907, 6, 136, -1, 0, 2907, 2921, 1, 0, 0, 0, 2908, 2909, 3, 274, 137, 0, 2909, 2910, 3, 282, 141, 0, 2910, 2911, 6, 136, -1, 0, 2911, 2921, 1, 0, 0, 0, 2912, 2913, 3, 278, 139, 0, 2913, 2914, 3, 282, 141, 0, 2914, 2915, 6, 136, -1, 0, 2915, 2921, 1, 0, 0, 0, 2916, 2917, 3, 280, 140, 0, 2917, 2918, 3, 282, 141, 0, 2918, 2919, 6, 136, -1, 0, 2919, 2921, 1, 0, 0, 0, 2920, 2904, 1, 0, 0, 0, 2920, 2908, 1, 0, 0, 0, 2920, 2912, 1, 0, 0, 0, 2920, 2916, 1, 0, 0, 0, 2921, 273, 1, 0, 0, 0, 2922, 2923, 5, 160, 0, 0, 2923, 2924, 3, 264, 132, 0, 2924, 2925, 6, 137, -1, 0, 2925, 2935, 1, 0, 0, 0, 2926, 2927, 5, 160, 0, 0, 2927, 2928, 3, 0, 0, 0, 2928, 2929, 6, 137, -1, 0, 2929, 2935, 1, 0, 0, 0, 2930, 2931, 5, 160, 0, 0, 2931, 2932, 3, 32, 16, 0, 2932, 2933, 6, 137, -1, 0, 2933, 2935, 1, 0, 0, 0, 2934, 2922, 1, 0, 0, 0, 2934, 2926, 1, 0, 0, 0, 2934, 2930, 1, 0, 0, 0, 2935, 275, 1, 0, 0, 0, 2936, 2937, 5, 161, 0, 0, 2937, 2938, 3, 124, 62, 0, 2938, 277, 1, 0, 0, 0, 2939, 2940, 5, 162, 0, 0, 2940, 279, 1, 0, 0, 0, 2941, 2942, 5, 163, 0, 0, 2942, 281, 1, 0, 0, 0, 2943, 2944, 3, 264, 132, 0, 2944, 2945, 6, 141, -1, 0, 2945, 2959, 1, 0, 0, 0, 2946, 2947, 5, 164, 0, 0, 2947, 2948, 3, 0, 0, 0, 2948, 2949, 5, 159, 0, 0, 2949, 2950, 3, 0, 0, 0, 2950, 2951, 6, 141, -1, 0, 2951, 2959, 1, 0, 0, 0, 2952, 2953, 5, 164, 0, 0, 2953, 2954, 3, 32, 16, 0, 2954, 2955, 5, 159, 0, 0, 2955, 2956, 3, 32, 16, 0, 2956, 2957, 6, 141, -1, 0, 2957, 2959, 1, 0, 0, 0, 2958, 2943, 1, 0, 0, 0, 2958, 2946, 1, 0, 0, 0, 2958, 2952, 1, 0, 0, 0, 2959, 283, 1, 0, 0, 0, 2960, 2961, 3, 286, 143, 0, 2961, 2962, 3, 290, 145, 0, 2962, 285, 1, 0, 0, 0, 2963, 2964, 5, 165, 0, 0, 2964, 2965, 3, 288, 144, 0, 2965, 2966, 3, 0, 0, 0, 2966, 2967, 5, 36, 0, 0, 2967, 2968, 6, 143, -1, 0, 2968, 2974, 1, 0, 0, 0, 2969, 2970, 5, 165, 0, 0, 2970, 2971, 3, 288, 144, 0, 2971, 2972, 6, 143, -1, 0, 2972, 2974, 1, 0, 0, 0, 2973, 2963, 1, 0, 0, 0, 2973, 2969, 1, 0, 0, 0, 2974, 287, 1, 0, 0, 0, 2975, 2981, 1, 0, 0, 0, 2976, 2977, 5, 166, 0, 0, 2977, 2981, 6, 144, -1, 0, 2978, 2979, 5, 2, 0, 0, 2979, 2981, 6, 144, -1, 0, 2980, 2975, 1, 0, 0, 0, 2980, 2976, 1, 0, 0, 0, 2980, 2978, 1, 0, 0, 0, 2981, 289, 1, 0, 0, 0, 2982, 2983, 5, 17, 0, 0, 2983, 2984, 3, 292, 146, 0, 2984, 2985, 5, 18, 0, 0, 2985, 2992, 1, 0, 0, 0, 2986, 2988, 3, 296, 148, 0, 2987, 2986, 1, 0, 0, 0, 2988, 2989, 1, 0, 0, 0, 2989, 2987, 1, 0, 0, 0, 2989, 2990, 1, 0, 0, 0, 2990, 2992, 1, 0, 0, 0, 2991, 2982, 1, 0, 0, 0, 2991, 2987, 1, 0, 0, 0, 2992, 291, 1, 0, 0, 0, 2993, 2994, 3, 296, 148, 0, 2994, 2995, 5, 28, 0, 0, 2995, 2997, 1, 0, 0, 0, 2996, 2993, 1, 0, 0, 0, 2997, 3000, 1, 0, 0, 0, 2998, 2996, 1, 0, 0, 0, 2998, 2999, 1, 0, 0, 0, 2999, 3001, 1, 0, 0, 0, 3000, 2998, 1, 0, 0, 0, 3001, 3002, 3, 296, 148, 0, 3002, 293, 1, 0, 0, 0, 3003, 3010, 1, 0, 0, 0, 3004, 3005, 5, 42, 0, 0, 3005, 3006, 3, 32, 16, 0, 3006, 3007, 5, 43, 0, 0, 3007, 3008, 6, 147, -1, 0, 3008, 3010, 1, 0, 0, 0, 3009, 3003, 1, 0, 0, 0, 3009, 3004, 1, 0, 0, 0, 3010, 295, 1, 0, 0, 0, 3011, 3012, 5, 181, 0, 0, 3012, 3013, 5, 262, 0, 0, 3013, 3014, 5, 30, 0, 0, 3014, 3015, 3, 6, 3, 0, 3015, 3016, 5, 31, 0, 0, 3016, 3017, 6, 148, -1, 0, 3017, 3060, 1, 0, 0, 0, 3018, 3019, 5, 260, 0, 0, 3019, 3020, 5, 30, 0, 0, 3020, 3021, 3, 0, 0, 0, 3021, 3022, 5, 31, 0, 0, 3022, 3023, 6, 148, -1, 0, 3023, 3060, 1, 0, 0, 0, 3024, 3025, 5, 260, 0, 0, 3025, 3026, 3, 0, 0, 0, 3026, 3027, 6, 148, -1, 0, 3027, 3060, 1, 0, 0, 0, 3028, 3029, 5, 84, 0, 0, 3029, 3030, 5, 30, 0, 0, 3030, 3031, 3, 300, 150, 0, 3031, 3032, 5, 31, 0, 0, 3032, 3033, 6, 148, -1, 0, 3033, 3060, 1, 0, 0, 0, 3034, 3035, 7, 10, 0, 0, 3035, 3036, 5, 30, 0, 0, 3036, 3037, 3, 36, 18, 0, 3037, 3038, 5, 31, 0, 0, 3038, 3039, 3, 294, 147, 0, 3039, 3040, 6, 148, -1, 0, 3040, 3060, 1, 0, 0, 0, 3041, 3042, 5, 187, 0, 0, 3042, 3043, 5, 30, 0, 0, 3043, 3044, 3, 34, 17, 0, 3044, 3045, 5, 31, 0, 0, 3045, 3046, 3, 294, 147, 0, 3046, 3047, 6, 148, -1, 0, 3047, 3060, 1, 0, 0, 0, 3048, 3049, 7, 11, 0, 0, 3049, 3050, 5, 30, 0, 0, 3050, 3051, 3, 32, 16, 0, 3051, 3052, 5, 31, 0, 0, 3052, 3053, 3, 294, 147, 0, 3053, 3054, 6, 148, -1, 0, 3054, 3060, 1, 0, 0, 0, 3055, 3056, 7, 12, 0, 0, 3056, 3057, 3, 294, 147, 0, 3057, 3058, 6, 148, -1, 0, 3058, 3060, 1, 0, 0, 0, 3059, 3011, 1, 0, 0, 0, 3059, 3018, 1, 0, 0, 0, 3059, 3024, 1, 0, 0, 0, 3059, 3028, 1, 0, 0, 0, 3059, 3034, 1, 0, 0, 0, 3059, 3041, 1, 0, 0, 0, 3059, 3048, 1, 0, 0, 0, 3059, 3055, 1, 0, 0, 0, 3060, 297, 1, 0, 0, 0, 3061, 3062, 5, 188, 0, 0, 3062, 3063, 5, 30, 0, 0, 3063, 3064, 3, 36, 18, 0, 3064, 3065, 5, 31, 0, 0, 3065, 3066, 6, 149, -1, 0, 3066, 3152, 1, 0, 0, 0, 3067, 3068, 5, 189, 0, 0, 3068, 3069, 5, 30, 0, 0, 3069, 3070, 3, 36, 18, 0, 3070, 3071, 5, 31, 0, 0, 3071, 3072, 6, 149, -1, 0, 3072, 3152, 1, 0, 0, 0, 3073, 3074, 5, 188, 0, 0, 3074, 3075, 5, 30, 0, 0, 3075, 3076, 3, 32, 16, 0, 3076, 3077, 5, 31, 0, 0, 3077, 3078, 6, 149, -1, 0, 3078, 3152, 1, 0, 0, 0, 3079, 3080, 5, 189, 0, 0, 3080, 3081, 5, 30, 0, 0, 3081, 3082, 3, 34, 17, 0, 3082, 3083, 5, 31, 0, 0, 3083, 3084, 6, 149, -1, 0, 3084, 3152, 1, 0, 0, 0, 3085, 3086, 5, 187, 0, 0, 3086, 3087, 5, 30, 0, 0, 3087, 3088, 3, 34, 17, 0, 3088, 3089, 5, 31, 0, 0, 3089, 3090, 6, 149, -1, 0, 3090, 3152, 1, 0, 0, 0, 3091, 3092, 5, 186, 0, 0, 3092, 3093, 5, 30, 0, 0, 3093, 3094, 3, 32, 16, 0, 3094, 3095, 5, 31, 0, 0, 3095, 3096, 6, 149, -1, 0, 3096, 3152, 1, 0, 0, 0, 3097, 3098, 5, 185, 0, 0, 3098, 3099, 5, 30, 0, 0, 3099, 3100, 3, 32, 16, 0, 3100, 3101, 5, 31, 0, 0, 3101, 3102, 6, 149, -1, 0, 3102, 3152, 1, 0, 0, 0, 3103, 3104, 5, 184, 0, 0, 3104, 3105, 5, 30, 0, 0, 3105, 3106, 3, 32, 16, 0, 3106, 3107, 5, 31, 0, 0, 3107, 3108, 6, 149, -1, 0, 3108, 3152, 1, 0, 0, 0, 3109, 3110, 5, 193, 0, 0, 3110, 3111, 5, 30, 0, 0, 3111, 3112, 3, 34, 17, 0, 3112, 3113, 5, 31, 0, 0, 3113, 3114, 6, 149, -1, 0, 3114, 3152, 1, 0, 0, 0, 3115, 3116, 5, 192, 0, 0, 3116, 3117, 5, 30, 0, 0, 3117, 3118, 3, 32, 16, 0, 3118, 3119, 5, 31, 0, 0, 3119, 3120, 6, 149, -1, 0, 3120, 3152, 1, 0, 0, 0, 3121, 3122, 5, 191, 0, 0, 3122, 3123, 5, 30, 0, 0, 3123, 3124, 3, 32, 16, 0, 3124, 3125, 5, 31, 0, 0, 3125, 3126, 6, 149, -1, 0, 3126, 3152, 1, 0, 0, 0, 3127, 3128, 5, 190, 0, 0, 3128, 3129, 5, 30, 0, 0, 3129, 3130, 3, 32, 16, 0, 3130, 3131, 5, 31, 0, 0, 3131, 3132, 6, 149, -1, 0, 3132, 3152, 1, 0, 0, 0, 3133, 3134, 5, 181, 0, 0, 3134, 3135, 5, 30, 0, 0, 3135, 3136, 3, 32, 16, 0, 3136, 3137, 5, 31, 0, 0, 3137, 3138, 6, 149, -1, 0, 3138, 3152, 1, 0, 0, 0, 3139, 3140, 5, 183, 0, 0, 3140, 3141, 5, 30, 0, 0, 3141, 3142, 3, 162, 81, 0, 3142, 3143, 5, 31, 0, 0, 3143, 3144, 6, 149, -1, 0, 3144, 3152, 1, 0, 0, 0, 3145, 3146, 5, 84, 0, 0, 3146, 3147, 5, 30, 0, 0, 3147, 3148, 3, 300, 150, 0, 3148, 3149, 5, 31, 0, 0, 3149, 3150, 6, 149, -1, 0, 3150, 3152, 1, 0, 0, 0, 3151, 3061, 1, 0, 0, 0, 3151, 3067, 1, 0, 0, 0, 3151, 3073, 1, 0, 0, 0, 3151, 3079, 1, 0, 0, 0, 3151, 3085, 1, 0, 0, 0, 3151, 3091, 1, 0, 0, 0, 3151, 3097, 1, 0, 0, 0, 3151, 3103, 1, 0, 0, 0, 3151, 3109, 1, 0, 0, 0, 3151, 3115, 1, 0, 0, 0, 3151, 3121, 1, 0, 0, 0, 3151, 3127, 1, 0, 0, 0, 3151, 3133, 1, 0, 0, 0, 3151, 3139, 1, 0, 0, 0, 3151, 3145, 1, 0, 0, 0, 3152, 299, 1, 0, 0, 0, 3153, 3154, 3, 302, 151, 0, 3154, 3155, 6, 150, -1, 0, 3155, 3157, 1, 0, 0, 0, 3156, 3153, 1, 0, 0, 0, 3157, 3160, 1, 0, 0, 0, 3158, 3156, 1, 0, 0, 0, 3158, 3159, 1, 0, 0, 0, 3159, 301, 1, 0, 0, 0, 3160, 3158, 1, 0, 0, 0, 3161, 3162, 7, 13, 0, 0, 3162, 303, 1, 0, 0, 0, 3163, 3164, 3, 298, 149, 0, 3164, 3165, 6, 152, -1, 0, 3165, 3172, 1, 0, 0, 0, 3166, 3167, 3, 6, 3, 0, 3167, 3168, 6, 152, -1, 0, 3168, 3172, 1, 0, 0, 0, 3169, 3170, 5, 179, 0, 0, 3170, 3172, 6, 152, -1, 0, 3171, 3163, 1, 0, 0, 0, 3171, 3166, 1, 0, 0, 0, 3171, 3169, 1, 0, 0, 0, 3172, 305, 1, 0, 0, 0, 3173, 3174, 3, 298, 149, 0, 3174, 3175, 6, 153, -1, 0, 3175, 3345, 1, 0, 0, 0, 3176, 3177, 5, 182, 0, 0, 3177, 3178, 5, 30, 0, 0, 3178, 3179, 5, 179, 0, 0, 3179, 3180, 5, 31, 0, 0, 3180, 3345, 6, 153, -1, 0, 3181, 3182, 5, 182, 0, 0, 3182, 3183, 5, 30, 0, 0, 3183, 3184, 5, 264, 0, 0, 3184, 3185, 5, 31, 0, 0, 3185, 3345, 6, 153, -1, 0, 3186, 3187, 5, 196, 0, 0, 3187, 3188, 5, 30, 0, 0, 3188, 3189, 5, 39, 0, 0, 3189, 3190, 5, 264, 0, 0, 3190, 3191, 5, 31, 0, 0, 3191, 3345, 6, 153, -1, 0, 3192, 3193, 5, 196, 0, 0, 3193, 3194, 5, 30, 0, 0, 3194, 3195, 3, 116, 58, 0, 3195, 3196, 5, 31, 0, 0, 3196, 3197, 6, 153, -1, 0, 3197, 3345, 1, 0, 0, 0, 3198, 3199, 5, 196, 0, 0, 3199, 3200, 5, 30, 0, 0, 3200, 3201, 5, 179, 0, 0, 3201, 3202, 5, 31, 0, 0, 3202, 3345, 6, 153, -1, 0, 3203, 3204, 5, 197, 0, 0, 3204, 3205, 5, 30, 0, 0, 3205, 3206, 3, 306, 153, 0, 3206, 3207, 5, 31, 0, 0, 3207, 3208, 6, 153, -1, 0, 3208, 3345, 1, 0, 0, 0, 3209, 3210, 5, 188, 0, 0, 3210, 3211, 5, 42, 0, 0, 3211, 3212, 3, 32, 16, 0, 3212, 3213, 5, 43, 0, 0, 3213, 3214, 5, 30, 0, 0, 3214, 3215, 3, 308, 154, 0, 3215, 3216, 5, 31, 0, 0, 3216, 3217, 6, 153, -1, 0, 3217, 3345, 1, 0, 0, 0, 3218, 3219, 5, 189, 0, 0, 3219, 3220, 5, 42, 0, 0, 3220, 3221, 3, 32, 16, 0, 3221, 3222, 5, 43, 0, 0, 3222, 3223, 5, 30, 0, 0, 3223, 3224, 3, 310, 155, 0, 3224, 3225, 5, 31, 0, 0, 3225, 3226, 6, 153, -1, 0, 3226, 3345, 1, 0, 0, 0, 3227, 3228, 5, 187, 0, 0, 3228, 3229, 5, 42, 0, 0, 3229, 3230, 3, 32, 16, 0, 3230, 3231, 5, 43, 0, 0, 3231, 3232, 5, 30, 0, 0, 3232, 3233, 3, 312, 156, 0, 3233, 3234, 5, 31, 0, 0, 3234, 3235, 6, 153, -1, 0, 3235, 3345, 1, 0, 0, 0, 3236, 3237, 5, 186, 0, 0, 3237, 3238, 5, 42, 0, 0, 3238, 3239, 3, 32, 16, 0, 3239, 3240, 5, 43, 0, 0, 3240, 3241, 5, 30, 0, 0, 3241, 3242, 3, 314, 157, 0, 3242, 3243, 5, 31, 0, 0, 3243, 3244, 6, 153, -1, 0, 3244, 3345, 1, 0, 0, 0, 3245, 3246, 5, 185, 0, 0, 3246, 3247, 5, 42, 0, 0, 3247, 3248, 3, 32, 16, 0, 3248, 3249, 5, 43, 0, 0, 3249, 3250, 5, 30, 0, 0, 3250, 3251, 3, 316, 158, 0, 3251, 3252, 5, 31, 0, 0, 3252, 3253, 6, 153, -1, 0, 3253, 3345, 1, 0, 0, 0, 3254, 3255, 5, 184, 0, 0, 3255, 3256, 5, 42, 0, 0, 3256, 3257, 3, 32, 16, 0, 3257, 3258, 5, 43, 0, 0, 3258, 3259, 5, 30, 0, 0, 3259, 3260, 3, 318, 159, 0, 3260, 3261, 5, 31, 0, 0, 3261, 3262, 6, 153, -1, 0, 3262, 3345, 1, 0, 0, 0, 3263, 3264, 5, 193, 0, 0, 3264, 3265, 5, 42, 0, 0, 3265, 3266, 3, 32, 16, 0, 3266, 3267, 5, 43, 0, 0, 3267, 3268, 5, 30, 0, 0, 3268, 3269, 3, 312, 156, 0, 3269, 3270, 5, 31, 0, 0, 3270, 3271, 6, 153, -1, 0, 3271, 3345, 1, 0, 0, 0, 3272, 3273, 5, 192, 0, 0, 3273, 3274, 5, 42, 0, 0, 3274, 3275, 3, 32, 16, 0, 3275, 3276, 5, 43, 0, 0, 3276, 3277, 5, 30, 0, 0, 3277, 3278, 3, 314, 157, 0, 3278, 3279, 5, 31, 0, 0, 3279, 3280, 6, 153, -1, 0, 3280, 3345, 1, 0, 0, 0, 3281, 3282, 5, 191, 0, 0, 3282, 3283, 5, 42, 0, 0, 3283, 3284, 3, 32, 16, 0, 3284, 3285, 5, 43, 0, 0, 3285, 3286, 5, 30, 0, 0, 3286, 3287, 3, 316, 158, 0, 3287, 3288, 5, 31, 0, 0, 3288, 3289, 6, 153, -1, 0, 3289, 3345, 1, 0, 0, 0, 3290, 3291, 5, 190, 0, 0, 3291, 3292, 5, 42, 0, 0, 3292, 3293, 3, 32, 16, 0, 3293, 3294, 5, 43, 0, 0, 3294, 3295, 5, 30, 0, 0, 3295, 3296, 3, 318, 159, 0, 3296, 3297, 5, 31, 0, 0, 3297, 3298, 6, 153, -1, 0, 3298, 3345, 1, 0, 0, 0, 3299, 3300, 5, 181, 0, 0, 3300, 3301, 5, 42, 0, 0, 3301, 3302, 3, 32, 16, 0, 3302, 3303, 5, 43, 0, 0, 3303, 3304, 5, 30, 0, 0, 3304, 3305, 3, 316, 158, 0, 3305, 3306, 5, 31, 0, 0, 3306, 3307, 6, 153, -1, 0, 3307, 3345, 1, 0, 0, 0, 3308, 3309, 5, 183, 0, 0, 3309, 3310, 5, 42, 0, 0, 3310, 3311, 3, 32, 16, 0, 3311, 3312, 5, 43, 0, 0, 3312, 3313, 5, 30, 0, 0, 3313, 3314, 3, 320, 160, 0, 3314, 3315, 5, 31, 0, 0, 3315, 3316, 6, 153, -1, 0, 3316, 3345, 1, 0, 0, 0, 3317, 3318, 5, 182, 0, 0, 3318, 3319, 5, 42, 0, 0, 3319, 3320, 3, 32, 16, 0, 3320, 3321, 5, 43, 0, 0, 3321, 3322, 5, 30, 0, 0, 3322, 3323, 3, 322, 161, 0, 3323, 3324, 5, 31, 0, 0, 3324, 3325, 6, 153, -1, 0, 3325, 3345, 1, 0, 0, 0, 3326, 3327, 5, 196, 0, 0, 3327, 3328, 5, 42, 0, 0, 3328, 3329, 3, 32, 16, 0, 3329, 3330, 5, 43, 0, 0, 3330, 3331, 5, 30, 0, 0, 3331, 3332, 3, 324, 162, 0, 3332, 3333, 5, 31, 0, 0, 3333, 3334, 6, 153, -1, 0, 3334, 3345, 1, 0, 0, 0, 3335, 3336, 5, 197, 0, 0, 3336, 3337, 5, 42, 0, 0, 3337, 3338, 3, 32, 16, 0, 3338, 3339, 5, 43, 0, 0, 3339, 3340, 5, 30, 0, 0, 3340, 3341, 3, 328, 164, 0, 3341, 3342, 5, 31, 0, 0, 3342, 3343, 6, 153, -1, 0, 3343, 3345, 1, 0, 0, 0, 3344, 3173, 1, 0, 0, 0, 3344, 3176, 1, 0, 0, 0, 3344, 3181, 1, 0, 0, 0, 3344, 3186, 1, 0, 0, 0, 3344, 3192, 1, 0, 0, 0, 3344, 3198, 1, 0, 0, 0, 3344, 3203, 1, 0, 0, 0, 3344, 3209, 1, 0, 0, 0, 3344, 3218, 1, 0, 0, 0, 3344, 3227, 1, 0, 0, 0, 3344, 3236, 1, 0, 0, 0, 3344, 3245, 1, 0, 0, 0, 3344, 3254, 1, 0, 0, 0, 3344, 3263, 1, 0, 0, 0, 3344, 3272, 1, 0, 0, 0, 3344, 3281, 1, 0, 0, 0, 3344, 3290, 1, 0, 0, 0, 3344, 3299, 1, 0, 0, 0, 3344, 3308, 1, 0, 0, 0, 3344, 3317, 1, 0, 0, 0, 3344, 3326, 1, 0, 0, 0, 3344, 3335, 1, 0, 0, 0, 3345, 307, 1, 0, 0, 0, 3346, 3347, 3, 36, 18, 0, 3347, 3348, 6, 154, -1, 0, 3348, 3353, 1, 0, 0, 0, 3349, 3350, 3, 32, 16, 0, 3350, 3351, 6, 154, -1, 0, 3351, 3353, 1, 0, 0, 0, 3352, 3346, 1, 0, 0, 0, 3352, 3349, 1, 0, 0, 0, 3353, 3356, 1, 0, 0, 0, 3354, 3352, 1, 0, 0, 0, 3354, 3355, 1, 0, 0, 0, 3355, 309, 1, 0, 0, 0, 3356, 3354, 1, 0, 0, 0, 3357, 3358, 3, 36, 18, 0, 3358, 3359, 6, 155, -1, 0, 3359, 3364, 1, 0, 0, 0, 3360, 3361, 3, 34, 17, 0, 3361, 3362, 6, 155, -1, 0, 3362, 3364, 1, 0, 0, 0, 3363, 3357, 1, 0, 0, 0, 3363, 3360, 1, 0, 0, 0, 3364, 3367, 1, 0, 0, 0, 3365, 3363, 1, 0, 0, 0, 3365, 3366, 1, 0, 0, 0, 3366, 311, 1, 0, 0, 0, 3367, 3365, 1, 0, 0, 0, 3368, 3369, 3, 34, 17, 0, 3369, 3370, 6, 156, -1, 0, 3370, 3372, 1, 0, 0, 0, 3371, 3368, 1, 0, 0, 0, 3372, 3375, 1, 0, 0, 0, 3373, 3371, 1, 0, 0, 0, 3373, 3374, 1, 0, 0, 0, 3374, 313, 1, 0, 0, 0, 3375, 3373, 1, 0, 0, 0, 3376, 3377, 3, 32, 16, 0, 3377, 3378, 6, 157, -1, 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, 315, 1, 0, 0, 0, 3383, 3381, 1, 0, 0, 0, 3384, 3385, 3, 32, 16, 0, 3385, 3386, 6, 158, -1, 0, 3386, 3388, 1, 0, 0, 0, 3387, 3384, 1, 0, 0, 0, 3388, 3391, 1, 0, 0, 0, 3389, 3387, 1, 0, 0, 0, 3389, 3390, 1, 0, 0, 0, 3390, 317, 1, 0, 0, 0, 3391, 3389, 1, 0, 0, 0, 3392, 3393, 3, 32, 16, 0, 3393, 3394, 6, 159, -1, 0, 3394, 3396, 1, 0, 0, 0, 3395, 3392, 1, 0, 0, 0, 3396, 3399, 1, 0, 0, 0, 3397, 3395, 1, 0, 0, 0, 3397, 3398, 1, 0, 0, 0, 3398, 319, 1, 0, 0, 0, 3399, 3397, 1, 0, 0, 0, 3400, 3401, 3, 162, 81, 0, 3401, 3402, 6, 160, -1, 0, 3402, 3404, 1, 0, 0, 0, 3403, 3400, 1, 0, 0, 0, 3404, 3407, 1, 0, 0, 0, 3405, 3403, 1, 0, 0, 0, 3405, 3406, 1, 0, 0, 0, 3406, 321, 1, 0, 0, 0, 3407, 3405, 1, 0, 0, 0, 3408, 3409, 5, 179, 0, 0, 3409, 3413, 6, 161, -1, 0, 3410, 3411, 5, 264, 0, 0, 3411, 3413, 6, 161, -1, 0, 3412, 3408, 1, 0, 0, 0, 3412, 3410, 1, 0, 0, 0, 3413, 3416, 1, 0, 0, 0, 3414, 3412, 1, 0, 0, 0, 3414, 3415, 1, 0, 0, 0, 3415, 323, 1, 0, 0, 0, 3416, 3414, 1, 0, 0, 0, 3417, 3418, 3, 326, 163, 0, 3418, 3419, 6, 162, -1, 0, 3419, 3421, 1, 0, 0, 0, 3420, 3417, 1, 0, 0, 0, 3421, 3424, 1, 0, 0, 0, 3422, 3420, 1, 0, 0, 0, 3422, 3423, 1, 0, 0, 0, 3423, 325, 1, 0, 0, 0, 3424, 3422, 1, 0, 0, 0, 3425, 3426, 5, 179, 0, 0, 3426, 3434, 6, 163, -1, 0, 3427, 3428, 5, 39, 0, 0, 3428, 3429, 5, 264, 0, 0, 3429, 3434, 6, 163, -1, 0, 3430, 3431, 3, 116, 58, 0, 3431, 3432, 6, 163, -1, 0, 3432, 3434, 1, 0, 0, 0, 3433, 3425, 1, 0, 0, 0, 3433, 3427, 1, 0, 0, 0, 3433, 3430, 1, 0, 0, 0, 3434, 327, 1, 0, 0, 0, 3435, 3436, 3, 306, 153, 0, 3436, 3437, 6, 164, -1, 0, 3437, 3439, 1, 0, 0, 0, 3438, 3435, 1, 0, 0, 0, 3439, 3442, 1, 0, 0, 0, 3440, 3438, 1, 0, 0, 0, 3440, 3441, 1, 0, 0, 0, 3441, 329, 1, 0, 0, 0, 3442, 3440, 1, 0, 0, 0, 3443, 3444, 3, 44, 22, 0, 3444, 3445, 6, 165, -1, 0, 3445, 3453, 1, 0, 0, 0, 3446, 3447, 3, 46, 23, 0, 3447, 3448, 6, 165, -1, 0, 3448, 3453, 1, 0, 0, 0, 3449, 3450, 3, 2, 1, 0, 3450, 3451, 6, 165, -1, 0, 3451, 3453, 1, 0, 0, 0, 3452, 3443, 1, 0, 0, 0, 3452, 3446, 1, 0, 0, 0, 3452, 3449, 1, 0, 0, 0, 3453, 331, 1, 0, 0, 0, 3454, 3455, 7, 14, 0, 0, 3455, 3456, 5, 36, 0, 0, 3456, 3457, 5, 30, 0, 0, 3457, 3458, 3, 300, 150, 0, 3458, 3459, 5, 31, 0, 0, 3459, 3480, 1, 0, 0, 0, 3460, 3461, 5, 169, 0, 0, 3461, 3462, 3, 38, 19, 0, 3462, 3463, 5, 75, 0, 0, 3463, 3464, 3, 38, 19, 0, 3464, 3465, 5, 75, 0, 0, 3465, 3466, 3, 38, 19, 0, 3466, 3467, 5, 75, 0, 0, 3467, 3468, 3, 38, 19, 0, 3468, 3480, 1, 0, 0, 0, 3469, 3470, 5, 170, 0, 0, 3470, 3480, 3, 6, 3, 0, 3471, 3472, 5, 170, 0, 0, 3472, 3473, 5, 36, 0, 0, 3473, 3474, 5, 30, 0, 0, 3474, 3475, 3, 300, 150, 0, 3475, 3476, 5, 31, 0, 0, 3476, 3480, 1, 0, 0, 0, 3477, 3480, 3, 330, 165, 0, 3478, 3480, 3, 40, 20, 0, 3479, 3454, 1, 0, 0, 0, 3479, 3460, 1, 0, 0, 0, 3479, 3469, 1, 0, 0, 0, 3479, 3471, 1, 0, 0, 0, 3479, 3477, 1, 0, 0, 0, 3479, 3478, 1, 0, 0, 0, 3480, 333, 1, 0, 0, 0, 3481, 3482, 3, 336, 168, 0, 3482, 3483, 5, 17, 0, 0, 3483, 3484, 3, 338, 169, 0, 3484, 3485, 5, 18, 0, 0, 3485, 335, 1, 0, 0, 0, 3486, 3487, 5, 25, 0, 0, 3487, 3488, 5, 40, 0, 0, 3488, 3489, 3, 98, 49, 0, 3489, 3490, 3, 2, 1, 0, 3490, 3499, 1, 0, 0, 0, 3491, 3492, 5, 25, 0, 0, 3492, 3493, 5, 40, 0, 0, 3493, 3494, 3, 98, 49, 0, 3494, 3495, 3, 2, 1, 0, 3495, 3496, 5, 34, 0, 0, 3496, 3497, 3, 2, 1, 0, 3497, 3499, 1, 0, 0, 0, 3498, 3486, 1, 0, 0, 0, 3498, 3491, 1, 0, 0, 0, 3499, 337, 1, 0, 0, 0, 3500, 3502, 3, 340, 170, 0, 3501, 3500, 1, 0, 0, 0, 3502, 3505, 1, 0, 0, 0, 3503, 3501, 1, 0, 0, 0, 3503, 3504, 1, 0, 0, 0, 3504, 339, 1, 0, 0, 0, 3505, 3503, 1, 0, 0, 0, 3506, 3507, 5, 180, 0, 0, 3507, 3508, 5, 36, 0, 0, 3508, 3509, 5, 30, 0, 0, 3509, 3510, 3, 300, 150, 0, 3510, 3511, 5, 31, 0, 0, 3511, 3521, 1, 0, 0, 0, 3512, 3521, 3, 332, 166, 0, 3513, 3514, 5, 171, 0, 0, 3514, 3515, 5, 36, 0, 0, 3515, 3516, 5, 30, 0, 0, 3516, 3517, 3, 300, 150, 0, 3517, 3518, 5, 31, 0, 0, 3518, 3521, 1, 0, 0, 0, 3519, 3521, 5, 55, 0, 0, 3520, 3506, 1, 0, 0, 0, 3520, 3512, 1, 0, 0, 0, 3520, 3513, 1, 0, 0, 0, 3520, 3519, 1, 0, 0, 0, 3521, 341, 1, 0, 0, 0, 3522, 3523, 3, 344, 172, 0, 3523, 3524, 5, 17, 0, 0, 3524, 3525, 3, 350, 175, 0, 3525, 3526, 5, 18, 0, 0, 3526, 343, 1, 0, 0, 0, 3527, 3528, 5, 50, 0, 0, 3528, 3532, 5, 40, 0, 0, 3529, 3531, 3, 348, 174, 0, 3530, 3529, 1, 0, 0, 0, 3531, 3534, 1, 0, 0, 0, 3532, 3530, 1, 0, 0, 0, 3532, 3533, 1, 0, 0, 0, 3533, 3535, 1, 0, 0, 0, 3534, 3532, 1, 0, 0, 0, 3535, 3536, 3, 2, 1, 0, 3536, 345, 1, 0, 0, 0, 3537, 3541, 5, 301, 0, 0, 3538, 3540, 3, 348, 174, 0, 3539, 3538, 1, 0, 0, 0, 3540, 3543, 1, 0, 0, 0, 3541, 3539, 1, 0, 0, 0, 3541, 3542, 1, 0, 0, 0, 3542, 3544, 1, 0, 0, 0, 3543, 3541, 1, 0, 0, 0, 3544, 3545, 3, 2, 1, 0, 3545, 347, 1, 0, 0, 0, 3546, 3562, 5, 52, 0, 0, 3547, 3562, 5, 51, 0, 0, 3548, 3562, 5, 172, 0, 0, 3549, 3550, 5, 62, 0, 0, 3550, 3562, 5, 51, 0, 0, 3551, 3552, 5, 62, 0, 0, 3552, 3562, 5, 52, 0, 0, 3553, 3554, 5, 62, 0, 0, 3554, 3562, 5, 63, 0, 0, 3555, 3556, 5, 62, 0, 0, 3556, 3562, 5, 64, 0, 0, 3557, 3558, 5, 62, 0, 0, 3558, 3562, 5, 65, 0, 0, 3559, 3560, 5, 62, 0, 0, 3560, 3562, 5, 66, 0, 0, 3561, 3546, 1, 0, 0, 0, 3561, 3547, 1, 0, 0, 0, 3561, 3548, 1, 0, 0, 0, 3561, 3549, 1, 0, 0, 0, 3561, 3551, 1, 0, 0, 0, 3561, 3553, 1, 0, 0, 0, 3561, 3555, 1, 0, 0, 0, 3561, 3557, 1, 0, 0, 0, 3561, 3559, 1, 0, 0, 0, 3562, 349, 1, 0, 0, 0, 3563, 3565, 3, 352, 176, 0, 3564, 3563, 1, 0, 0, 0, 3565, 3568, 1, 0, 0, 0, 3566, 3564, 1, 0, 0, 0, 3566, 3567, 1, 0, 0, 0, 3567, 351, 1, 0, 0, 0, 3568, 3566, 1, 0, 0, 0, 3569, 3570, 5, 21, 0, 0, 3570, 3583, 3, 2, 1, 0, 3571, 3572, 5, 50, 0, 0, 3572, 3573, 5, 40, 0, 0, 3573, 3583, 3, 118, 59, 0, 3574, 3575, 5, 25, 0, 0, 3575, 3576, 5, 40, 0, 0, 3576, 3583, 3, 2, 1, 0, 3577, 3583, 3, 174, 87, 0, 3578, 3579, 5, 50, 0, 0, 3579, 3583, 3, 32, 16, 0, 3580, 3583, 3, 330, 165, 0, 3581, 3583, 3, 40, 20, 0, 3582, 3569, 1, 0, 0, 0, 3582, 3571, 1, 0, 0, 0, 3582, 3574, 1, 0, 0, 0, 3582, 3577, 1, 0, 0, 0, 3582, 3578, 1, 0, 0, 0, 3582, 3580, 1, 0, 0, 0, 3582, 3581, 1, 0, 0, 0, 3583, 353, 1, 0, 0, 0, 3584, 3585, 3, 356, 178, 0, 3585, 3586, 5, 17, 0, 0, 3586, 3587, 3, 360, 180, 0, 3587, 3588, 5, 18, 0, 0, 3588, 355, 1, 0, 0, 0, 3589, 3593, 5, 274, 0, 0, 3590, 3592, 3, 358, 179, 0, 3591, 3590, 1, 0, 0, 0, 3592, 3595, 1, 0, 0, 0, 3593, 3591, 1, 0, 0, 0, 3593, 3594, 1, 0, 0, 0, 3594, 3596, 1, 0, 0, 0, 3595, 3593, 1, 0, 0, 0, 3596, 3609, 3, 2, 1, 0, 3597, 3601, 5, 274, 0, 0, 3598, 3600, 3, 358, 179, 0, 3599, 3598, 1, 0, 0, 0, 3600, 3603, 1, 0, 0, 0, 3601, 3599, 1, 0, 0, 0, 3601, 3602, 1, 0, 0, 0, 3602, 3604, 1, 0, 0, 0, 3603, 3601, 1, 0, 0, 0, 3604, 3605, 3, 2, 1, 0, 3605, 3606, 5, 34, 0, 0, 3606, 3607, 3, 2, 1, 0, 3607, 3609, 1, 0, 0, 0, 3608, 3589, 1, 0, 0, 0, 3608, 3597, 1, 0, 0, 0, 3609, 357, 1, 0, 0, 0, 3610, 3611, 7, 15, 0, 0, 3611, 359, 1, 0, 0, 0, 3612, 3614, 3, 362, 181, 0, 3613, 3612, 1, 0, 0, 0, 3614, 3617, 1, 0, 0, 0, 3615, 3613, 1, 0, 0, 0, 3615, 3616, 1, 0, 0, 0, 3616, 361, 1, 0, 0, 0, 3617, 3615, 1, 0, 0, 0, 3618, 3619, 5, 21, 0, 0, 3619, 3620, 3, 2, 1, 0, 3620, 3621, 5, 44, 0, 0, 3621, 3622, 3, 32, 16, 0, 3622, 3629, 1, 0, 0, 0, 3623, 3624, 5, 25, 0, 0, 3624, 3625, 5, 40, 0, 0, 3625, 3629, 3, 2, 1, 0, 3626, 3629, 3, 330, 165, 0, 3627, 3629, 3, 40, 20, 0, 3628, 3618, 1, 0, 0, 0, 3628, 3623, 1, 0, 0, 0, 3628, 3626, 1, 0, 0, 0, 3628, 3627, 1, 0, 0, 0, 3629, 363, 1, 0, 0, 0, 187, 374, 382, 391, 400, 489, 539, 550, 580, 584, 602, 629, 657, 697, 708, 718, 720, 731, 733, 741, 763, 776, 797, 799, 818, 891, 898, 905, 910, 919, 930, 939, 950, 961, 974, 978, 984, 1000, 1006, 1012, 1019, 1047, 1125, 1127, 1141, 1147, 1156, 1158, 1167, 1181, 1195, 1203, 1211, 1215, 1254, 1262, 1271, 1279, 1298, 1308, 1311, 1335, 1482, 1492, 1501, 1504, 1586, 1595, 1627, 1687, 1727, 1743, 1753, 1783, 1811, 1820, 1826, 1843, 1851, 1909, 1919, 1937, 1955, 1974, 1995, 2014, 2029, 2037, 2049, 2069, 2076, 2081, 2092, 2104, 2214, 2226, 2242, 2256, 2265, 2278, 2280, 2323, 2334, 2341, 2349, 2357, 2370, 2376, 2382, 2387, 2416, 2424, 2438, 2443, 2468, 2477, 2488, 2492, 2499, 2519, 2528, 2530, 2545, 2592, 2602, 2604, 2611, 2617, 2661, 2670, 2710, 2715, 2755, 2759, 2769, 2791, 2803, 2814, 2829, 2842, 2855, 2858, 2870, 2884, 2902, 2920, 2934, 2958, 2973, 2980, 2989, 2991, 2998, 3009, 3059, 3151, 3158, 3171, 3344, 3352, 3354, 3363, 3365, 3373, 3381, 3389, 3397, 3405, 3412, 3414, 3422, 3433, 3440, 3452, 3479, 3498, 3503, 3520, 3532, 3541, 3561, 3566, 3582, 3593, 3601, 3608, 3615, 3628] \ No newline at end of file +[4, 1, 305, 3692, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 379, 8, 1, 10, 1, 12, 1, 382, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 389, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 5, 3, 396, 8, 3, 10, 3, 12, 3, 399, 9, 3, 1, 3, 1, 3, 1, 3, 1, 4, 5, 4, 405, 8, 4, 10, 4, 12, 4, 408, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 496, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 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, 12, 1, 12, 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, 547, 8, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 5, 15, 556, 8, 15, 10, 15, 12, 15, 559, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 588, 8, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 595, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 613, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 645, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 673, 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, 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, 713, 8, 23, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 724, 8, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 5, 27, 734, 8, 27, 10, 27, 12, 27, 737, 9, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, 28, 747, 8, 28, 10, 28, 12, 28, 750, 9, 28, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 3, 30, 757, 8, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 779, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 792, 8, 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, 5, 34, 806, 8, 34, 10, 34, 12, 34, 809, 9, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 5, 38, 830, 8, 38, 10, 38, 12, 38, 833, 9, 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, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 905, 8, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 912, 8, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 3, 41, 919, 8, 41, 1, 42, 5, 42, 922, 8, 42, 10, 42, 12, 42, 925, 9, 42, 1, 43, 1, 43, 1, 43, 1, 43, 5, 43, 931, 8, 43, 10, 43, 12, 43, 934, 9, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 3, 45, 944, 8, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 3, 45, 953, 8, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 3, 45, 964, 8, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 3, 45, 975, 8, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 3, 45, 988, 8, 45, 1, 45, 1, 45, 3, 45, 992, 8, 45, 1, 46, 1, 46, 1, 46, 1, 46, 5, 46, 998, 8, 46, 10, 46, 12, 46, 1001, 9, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1016, 8, 46, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 3, 48, 1023, 8, 48, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 5, 50, 1030, 8, 50, 10, 50, 12, 50, 1033, 9, 50, 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, 1060, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 1138, 8, 52, 3, 52, 1140, 8, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 1154, 8, 54, 1, 54, 1, 54, 5, 54, 1158, 8, 54, 10, 54, 12, 54, 1161, 9, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 1169, 8, 54, 3, 54, 1171, 8, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1178, 8, 55, 10, 55, 12, 55, 1181, 9, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 5, 56, 1192, 8, 56, 10, 56, 12, 56, 1195, 9, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 5, 57, 1206, 8, 57, 10, 57, 12, 57, 1209, 9, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 1216, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1224, 8, 58, 1, 58, 1, 58, 3, 58, 1228, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 3, 59, 1267, 8, 59, 1, 60, 1, 60, 1, 60, 1, 60, 5, 60, 1273, 8, 60, 10, 60, 12, 60, 1276, 9, 60, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 5, 61, 1284, 8, 61, 10, 61, 12, 61, 1287, 9, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 3, 62, 1300, 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, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 3, 63, 1319, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 5, 64, 1327, 8, 64, 10, 64, 12, 64, 1330, 9, 64, 3, 64, 1332, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1356, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1503, 8, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 3, 67, 1513, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 5, 68, 1520, 8, 68, 10, 68, 12, 68, 1523, 9, 68, 3, 68, 1525, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 3, 69, 1607, 8, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 5, 70, 1614, 8, 70, 10, 70, 12, 70, 1617, 9, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1648, 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, 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, 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, 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, 1708, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1748, 8, 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, 3, 74, 1764, 8, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 3, 76, 1774, 8, 76, 1, 76, 1, 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, 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, 1804, 8, 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, 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, 1, 77, 3, 77, 1832, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 5, 78, 1839, 8, 78, 10, 78, 12, 78, 1842, 9, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1847, 8, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 3, 79, 1864, 8, 79, 1, 80, 1, 80, 1, 80, 1, 80, 5, 80, 1870, 8, 80, 10, 80, 12, 80, 1873, 9, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 3, 83, 1930, 8, 83, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1940, 8, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1958, 8, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1976, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 1995, 8, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 2016, 8, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 2035, 8, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 3, 90, 2050, 8, 90, 1, 91, 1, 91, 1, 91, 1, 91, 5, 91, 2056, 8, 91, 10, 91, 12, 91, 2059, 9, 91, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 2070, 8, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 3, 93, 2090, 8, 93, 1, 94, 1, 94, 1, 94, 5, 94, 2095, 8, 94, 10, 94, 12, 94, 2098, 9, 94, 1, 95, 1, 95, 3, 95, 2102, 8, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 5, 96, 2111, 8, 96, 10, 96, 12, 96, 2114, 9, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 98, 3, 98, 2125, 8, 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, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 2233, 8, 100, 10, 100, 12, 100, 2236, 9, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 2245, 8, 100, 10, 100, 12, 100, 2248, 9, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 2261, 8, 100, 10, 100, 12, 100, 2264, 9, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 5, 100, 2275, 8, 100, 10, 100, 12, 100, 2278, 9, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 3, 100, 2286, 8, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 5, 101, 2299, 8, 101, 10, 101, 12, 101, 2302, 9, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 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, 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, 2344, 8, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 3, 103, 2355, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 2362, 8, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 3, 105, 2370, 8, 105, 1, 106, 1, 106, 1, 106, 1, 106, 5, 106, 2376, 8, 106, 10, 106, 12, 106, 2379, 9, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 5, 106, 2389, 8, 106, 10, 106, 12, 106, 2392, 9, 106, 1, 106, 1, 106, 1, 106, 3, 106, 2397, 8, 106, 1, 107, 1, 107, 1, 107, 1, 107, 3, 107, 2403, 8, 107, 1, 108, 5, 108, 2406, 8, 108, 10, 108, 12, 108, 2409, 9, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 3, 109, 2437, 8, 109, 1, 110, 1, 110, 1, 110, 1, 110, 5, 110, 2443, 8, 110, 10, 110, 12, 110, 2446, 9, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 111, 3, 111, 2459, 8, 111, 1, 112, 5, 112, 2462, 8, 112, 10, 112, 12, 112, 2465, 9, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 2489, 8, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 3, 114, 2498, 8, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 4, 115, 2507, 8, 115, 11, 115, 12, 115, 2508, 1, 115, 1, 115, 3, 115, 2513, 8, 115, 1, 116, 1, 116, 1, 116, 5, 116, 2518, 8, 116, 10, 116, 12, 116, 2521, 9, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, 2540, 8, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 5, 118, 2549, 8, 118, 10, 118, 12, 118, 2552, 9, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 5, 118, 2564, 8, 118, 10, 118, 12, 118, 2567, 9, 118, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 2613, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2623, 8, 120, 3, 120, 2625, 8, 120, 1, 120, 1, 120, 1, 120, 5, 120, 2630, 8, 120, 10, 120, 12, 120, 2633, 9, 120, 1, 120, 1, 120, 1, 120, 3, 120, 2638, 8, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 2682, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 2691, 8, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 3, 123, 2731, 8, 123, 1, 124, 5, 124, 2734, 8, 124, 10, 124, 12, 124, 2737, 9, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 3, 125, 2776, 8, 125, 1, 126, 1, 126, 3, 126, 2780, 8, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 3, 127, 2790, 8, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 3, 129, 2812, 8, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 5, 130, 2822, 8, 130, 10, 130, 12, 130, 2825, 9, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 5, 130, 2833, 8, 130, 10, 130, 12, 130, 2836, 9, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 5, 130, 2848, 8, 130, 10, 130, 12, 130, 2851, 9, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 5, 130, 2861, 8, 130, 10, 130, 12, 130, 2864, 9, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 5, 130, 2874, 8, 130, 10, 130, 12, 130, 2877, 9, 130, 3, 130, 2879, 8, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 3, 132, 2891, 8, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 135, 4, 135, 2903, 8, 135, 11, 135, 12, 135, 2904, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 3, 136, 2923, 8, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 2941, 8, 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, 3, 138, 2955, 8, 138, 1, 139, 1, 139, 1, 139, 1, 140, 1, 140, 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, 3, 142, 2979, 8, 142, 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, 3, 144, 2994, 8, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 3, 145, 3001, 8, 145, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 4, 146, 3008, 8, 146, 11, 146, 12, 146, 3009, 3, 146, 3012, 8, 146, 1, 147, 1, 147, 1, 147, 5, 147, 3017, 8, 147, 10, 147, 12, 147, 3020, 9, 147, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 3, 148, 3030, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 3080, 8, 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 3, 150, 3172, 8, 150, 1, 151, 1, 151, 1, 151, 5, 151, 3177, 8, 151, 10, 151, 12, 151, 3180, 9, 151, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 3, 153, 3192, 8, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3365, 8, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 5, 155, 3373, 8, 155, 10, 155, 12, 155, 3376, 9, 155, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 5, 156, 3384, 8, 156, 10, 156, 12, 156, 3387, 9, 156, 1, 157, 1, 157, 1, 157, 5, 157, 3392, 8, 157, 10, 157, 12, 157, 3395, 9, 157, 1, 158, 1, 158, 1, 158, 5, 158, 3400, 8, 158, 10, 158, 12, 158, 3403, 9, 158, 1, 159, 1, 159, 1, 159, 5, 159, 3408, 8, 159, 10, 159, 12, 159, 3411, 9, 159, 1, 160, 1, 160, 1, 160, 5, 160, 3416, 8, 160, 10, 160, 12, 160, 3419, 9, 160, 1, 161, 1, 161, 1, 161, 5, 161, 3424, 8, 161, 10, 161, 12, 161, 3427, 9, 161, 1, 162, 1, 162, 1, 162, 1, 162, 5, 162, 3433, 8, 162, 10, 162, 12, 162, 3436, 9, 162, 1, 163, 1, 163, 1, 163, 5, 163, 3441, 8, 163, 10, 163, 12, 163, 3444, 9, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 3, 164, 3454, 8, 164, 1, 165, 1, 165, 1, 165, 5, 165, 3459, 8, 165, 10, 165, 12, 165, 3462, 9, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 3, 166, 3473, 8, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 3, 167, 3507, 8, 167, 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, 169, 3, 169, 3529, 8, 169, 1, 170, 1, 170, 1, 170, 5, 170, 3534, 8, 170, 10, 170, 12, 170, 3537, 9, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 3, 171, 3558, 8, 171, 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, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 175, 1, 175, 1, 175, 5, 175, 3580, 8, 175, 10, 175, 12, 175, 3583, 9, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 3, 176, 3600, 8, 176, 1, 177, 1, 177, 1, 177, 5, 177, 3605, 8, 177, 10, 177, 12, 177, 3608, 9, 177, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 3, 178, 3635, 8, 178, 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, 3, 180, 3655, 8, 180, 1, 181, 1, 181, 1, 181, 5, 181, 3660, 8, 181, 10, 181, 12, 181, 3663, 9, 181, 1, 182, 1, 182, 1, 183, 1, 183, 1, 183, 5, 183, 3670, 8, 183, 10, 183, 12, 183, 3673, 9, 183, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 3, 184, 3690, 8, 184, 1, 184, 0, 0, 185, 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, 0, 17, 6, 0, 1, 15, 199, 199, 243, 243, 247, 247, 264, 264, 289, 289, 5, 0, 16, 16, 199, 199, 243, 243, 264, 264, 288, 289, 1, 0, 263, 264, 1, 0, 173, 174, 1, 0, 37, 38, 2, 0, 45, 47, 186, 187, 1, 0, 73, 74, 3, 0, 2, 2, 61, 61, 77, 83, 2, 0, 229, 229, 260, 261, 1, 0, 95, 96, 1, 0, 97, 111, 1, 0, 188, 189, 1, 0, 184, 186, 1, 0, 184, 189, 2, 0, 173, 173, 289, 290, 1, 0, 167, 168, 1, 0, 51, 52, 4131, 0, 370, 1, 0, 0, 0, 2, 388, 1, 0, 0, 0, 4, 390, 1, 0, 0, 0, 6, 397, 1, 0, 0, 0, 8, 406, 1, 0, 0, 0, 10, 495, 1, 0, 0, 0, 12, 497, 1, 0, 0, 0, 14, 501, 1, 0, 0, 0, 16, 505, 1, 0, 0, 0, 18, 510, 1, 0, 0, 0, 20, 514, 1, 0, 0, 0, 22, 518, 1, 0, 0, 0, 24, 526, 1, 0, 0, 0, 26, 546, 1, 0, 0, 0, 28, 548, 1, 0, 0, 0, 30, 550, 1, 0, 0, 0, 32, 562, 1, 0, 0, 0, 34, 564, 1, 0, 0, 0, 36, 587, 1, 0, 0, 0, 38, 594, 1, 0, 0, 0, 40, 612, 1, 0, 0, 0, 42, 644, 1, 0, 0, 0, 44, 672, 1, 0, 0, 0, 46, 712, 1, 0, 0, 0, 48, 714, 1, 0, 0, 0, 50, 723, 1, 0, 0, 0, 52, 725, 1, 0, 0, 0, 54, 735, 1, 0, 0, 0, 56, 748, 1, 0, 0, 0, 58, 751, 1, 0, 0, 0, 60, 754, 1, 0, 0, 0, 62, 778, 1, 0, 0, 0, 64, 791, 1, 0, 0, 0, 66, 793, 1, 0, 0, 0, 68, 807, 1, 0, 0, 0, 70, 812, 1, 0, 0, 0, 72, 814, 1, 0, 0, 0, 74, 821, 1, 0, 0, 0, 76, 825, 1, 0, 0, 0, 78, 904, 1, 0, 0, 0, 80, 911, 1, 0, 0, 0, 82, 918, 1, 0, 0, 0, 84, 923, 1, 0, 0, 0, 86, 932, 1, 0, 0, 0, 88, 938, 1, 0, 0, 0, 90, 991, 1, 0, 0, 0, 92, 993, 1, 0, 0, 0, 94, 1017, 1, 0, 0, 0, 96, 1022, 1, 0, 0, 0, 98, 1024, 1, 0, 0, 0, 100, 1031, 1, 0, 0, 0, 102, 1059, 1, 0, 0, 0, 104, 1139, 1, 0, 0, 0, 106, 1141, 1, 0, 0, 0, 108, 1170, 1, 0, 0, 0, 110, 1172, 1, 0, 0, 0, 112, 1186, 1, 0, 0, 0, 114, 1215, 1, 0, 0, 0, 116, 1227, 1, 0, 0, 0, 118, 1266, 1, 0, 0, 0, 120, 1274, 1, 0, 0, 0, 122, 1285, 1, 0, 0, 0, 124, 1299, 1, 0, 0, 0, 126, 1318, 1, 0, 0, 0, 128, 1331, 1, 0, 0, 0, 130, 1355, 1, 0, 0, 0, 132, 1502, 1, 0, 0, 0, 134, 1512, 1, 0, 0, 0, 136, 1524, 1, 0, 0, 0, 138, 1606, 1, 0, 0, 0, 140, 1608, 1, 0, 0, 0, 142, 1647, 1, 0, 0, 0, 144, 1707, 1, 0, 0, 0, 146, 1747, 1, 0, 0, 0, 148, 1763, 1, 0, 0, 0, 150, 1765, 1, 0, 0, 0, 152, 1769, 1, 0, 0, 0, 154, 1831, 1, 0, 0, 0, 156, 1846, 1, 0, 0, 0, 158, 1863, 1, 0, 0, 0, 160, 1871, 1, 0, 0, 0, 162, 1877, 1, 0, 0, 0, 164, 1882, 1, 0, 0, 0, 166, 1929, 1, 0, 0, 0, 168, 1931, 1, 0, 0, 0, 170, 1975, 1, 0, 0, 0, 172, 1994, 1, 0, 0, 0, 174, 2015, 1, 0, 0, 0, 176, 2017, 1, 0, 0, 0, 178, 2034, 1, 0, 0, 0, 180, 2049, 1, 0, 0, 0, 182, 2057, 1, 0, 0, 0, 184, 2069, 1, 0, 0, 0, 186, 2089, 1, 0, 0, 0, 188, 2096, 1, 0, 0, 0, 190, 2099, 1, 0, 0, 0, 192, 2112, 1, 0, 0, 0, 194, 2118, 1, 0, 0, 0, 196, 2124, 1, 0, 0, 0, 198, 2128, 1, 0, 0, 0, 200, 2285, 1, 0, 0, 0, 202, 2287, 1, 0, 0, 0, 204, 2343, 1, 0, 0, 0, 206, 2354, 1, 0, 0, 0, 208, 2361, 1, 0, 0, 0, 210, 2369, 1, 0, 0, 0, 212, 2396, 1, 0, 0, 0, 214, 2402, 1, 0, 0, 0, 216, 2407, 1, 0, 0, 0, 218, 2436, 1, 0, 0, 0, 220, 2438, 1, 0, 0, 0, 222, 2458, 1, 0, 0, 0, 224, 2463, 1, 0, 0, 0, 226, 2488, 1, 0, 0, 0, 228, 2497, 1, 0, 0, 0, 230, 2512, 1, 0, 0, 0, 232, 2519, 1, 0, 0, 0, 234, 2539, 1, 0, 0, 0, 236, 2541, 1, 0, 0, 0, 238, 2612, 1, 0, 0, 0, 240, 2637, 1, 0, 0, 0, 242, 2681, 1, 0, 0, 0, 244, 2690, 1, 0, 0, 0, 246, 2730, 1, 0, 0, 0, 248, 2735, 1, 0, 0, 0, 250, 2775, 1, 0, 0, 0, 252, 2777, 1, 0, 0, 0, 254, 2783, 1, 0, 0, 0, 256, 2791, 1, 0, 0, 0, 258, 2811, 1, 0, 0, 0, 260, 2878, 1, 0, 0, 0, 262, 2880, 1, 0, 0, 0, 264, 2890, 1, 0, 0, 0, 266, 2892, 1, 0, 0, 0, 268, 2896, 1, 0, 0, 0, 270, 2902, 1, 0, 0, 0, 272, 2922, 1, 0, 0, 0, 274, 2940, 1, 0, 0, 0, 276, 2954, 1, 0, 0, 0, 278, 2956, 1, 0, 0, 0, 280, 2959, 1, 0, 0, 0, 282, 2961, 1, 0, 0, 0, 284, 2978, 1, 0, 0, 0, 286, 2980, 1, 0, 0, 0, 288, 2993, 1, 0, 0, 0, 290, 3000, 1, 0, 0, 0, 292, 3011, 1, 0, 0, 0, 294, 3018, 1, 0, 0, 0, 296, 3029, 1, 0, 0, 0, 298, 3079, 1, 0, 0, 0, 300, 3171, 1, 0, 0, 0, 302, 3178, 1, 0, 0, 0, 304, 3181, 1, 0, 0, 0, 306, 3191, 1, 0, 0, 0, 308, 3364, 1, 0, 0, 0, 310, 3374, 1, 0, 0, 0, 312, 3385, 1, 0, 0, 0, 314, 3393, 1, 0, 0, 0, 316, 3401, 1, 0, 0, 0, 318, 3409, 1, 0, 0, 0, 320, 3417, 1, 0, 0, 0, 322, 3425, 1, 0, 0, 0, 324, 3434, 1, 0, 0, 0, 326, 3442, 1, 0, 0, 0, 328, 3453, 1, 0, 0, 0, 330, 3460, 1, 0, 0, 0, 332, 3472, 1, 0, 0, 0, 334, 3506, 1, 0, 0, 0, 336, 3508, 1, 0, 0, 0, 338, 3528, 1, 0, 0, 0, 340, 3535, 1, 0, 0, 0, 342, 3557, 1, 0, 0, 0, 344, 3559, 1, 0, 0, 0, 346, 3565, 1, 0, 0, 0, 348, 3571, 1, 0, 0, 0, 350, 3581, 1, 0, 0, 0, 352, 3599, 1, 0, 0, 0, 354, 3606, 1, 0, 0, 0, 356, 3634, 1, 0, 0, 0, 358, 3636, 1, 0, 0, 0, 360, 3654, 1, 0, 0, 0, 362, 3661, 1, 0, 0, 0, 364, 3664, 1, 0, 0, 0, 366, 3671, 1, 0, 0, 0, 368, 3689, 1, 0, 0, 0, 370, 371, 7, 0, 0, 0, 371, 1, 1, 0, 0, 0, 372, 373, 5, 288, 0, 0, 373, 389, 6, 1, -1, 0, 374, 375, 3, 4, 2, 0, 375, 376, 6, 1, -1, 0, 376, 377, 5, 265, 0, 0, 377, 379, 1, 0, 0, 0, 378, 374, 1, 0, 0, 0, 379, 382, 1, 0, 0, 0, 380, 378, 1, 0, 0, 0, 380, 381, 1, 0, 0, 0, 381, 383, 1, 0, 0, 0, 382, 380, 1, 0, 0, 0, 383, 384, 3, 4, 2, 0, 384, 385, 6, 1, -1, 0, 385, 389, 1, 0, 0, 0, 386, 387, 5, 264, 0, 0, 387, 389, 6, 1, -1, 0, 388, 372, 1, 0, 0, 0, 388, 380, 1, 0, 0, 0, 388, 386, 1, 0, 0, 0, 389, 3, 1, 0, 0, 0, 390, 391, 7, 1, 0, 0, 391, 5, 1, 0, 0, 0, 392, 393, 5, 263, 0, 0, 393, 394, 6, 3, -1, 0, 394, 396, 5, 266, 0, 0, 395, 392, 1, 0, 0, 0, 396, 399, 1, 0, 0, 0, 397, 395, 1, 0, 0, 0, 397, 398, 1, 0, 0, 0, 398, 400, 1, 0, 0, 0, 399, 397, 1, 0, 0, 0, 400, 401, 5, 263, 0, 0, 401, 402, 6, 3, -1, 0, 402, 7, 1, 0, 0, 0, 403, 405, 3, 10, 5, 0, 404, 403, 1, 0, 0, 0, 405, 408, 1, 0, 0, 0, 406, 404, 1, 0, 0, 0, 406, 407, 1, 0, 0, 0, 407, 9, 1, 0, 0, 0, 408, 406, 1, 0, 0, 0, 409, 410, 3, 76, 38, 0, 410, 411, 5, 17, 0, 0, 411, 412, 3, 84, 42, 0, 412, 413, 5, 18, 0, 0, 413, 496, 1, 0, 0, 0, 414, 415, 3, 74, 37, 0, 415, 416, 5, 17, 0, 0, 416, 417, 3, 8, 4, 0, 417, 418, 5, 18, 0, 0, 418, 496, 1, 0, 0, 0, 419, 420, 3, 236, 118, 0, 420, 421, 5, 17, 0, 0, 421, 422, 3, 248, 124, 0, 422, 423, 5, 18, 0, 0, 423, 496, 1, 0, 0, 0, 424, 496, 3, 202, 101, 0, 425, 426, 6, 5, -1, 0, 426, 427, 3, 286, 143, 0, 427, 428, 6, 5, -1, 0, 428, 496, 1, 0, 0, 0, 429, 430, 6, 5, -1, 0, 430, 431, 3, 72, 36, 0, 431, 432, 6, 5, -1, 0, 432, 496, 1, 0, 0, 0, 433, 434, 6, 5, -1, 0, 434, 435, 3, 66, 33, 0, 435, 436, 6, 5, -1, 0, 436, 496, 1, 0, 0, 0, 437, 438, 6, 5, -1, 0, 438, 439, 3, 90, 45, 0, 439, 440, 6, 5, -1, 0, 440, 496, 1, 0, 0, 0, 441, 442, 6, 5, -1, 0, 442, 443, 3, 92, 46, 0, 443, 444, 6, 5, -1, 0, 444, 496, 1, 0, 0, 0, 445, 446, 6, 5, -1, 0, 446, 447, 3, 22, 11, 0, 447, 448, 6, 5, -1, 0, 448, 496, 1, 0, 0, 0, 449, 450, 6, 5, -1, 0, 450, 451, 3, 336, 168, 0, 451, 452, 6, 5, -1, 0, 452, 496, 1, 0, 0, 0, 453, 454, 6, 5, -1, 0, 454, 455, 3, 344, 172, 0, 455, 456, 6, 5, -1, 0, 456, 496, 1, 0, 0, 0, 457, 458, 6, 5, -1, 0, 458, 459, 3, 358, 179, 0, 459, 460, 6, 5, -1, 0, 460, 496, 1, 0, 0, 0, 461, 462, 6, 5, -1, 0, 462, 463, 3, 64, 32, 0, 463, 464, 6, 5, -1, 0, 464, 496, 1, 0, 0, 0, 465, 466, 6, 5, -1, 0, 466, 467, 3, 154, 77, 0, 467, 468, 6, 5, -1, 0, 468, 496, 1, 0, 0, 0, 469, 470, 3, 332, 166, 0, 470, 471, 6, 5, -1, 0, 471, 496, 1, 0, 0, 0, 472, 473, 6, 5, -1, 0, 473, 496, 3, 12, 6, 0, 474, 475, 6, 5, -1, 0, 475, 496, 3, 14, 7, 0, 476, 477, 6, 5, -1, 0, 477, 496, 3, 16, 8, 0, 478, 479, 6, 5, -1, 0, 479, 496, 3, 18, 9, 0, 480, 481, 6, 5, -1, 0, 481, 496, 3, 20, 10, 0, 482, 483, 6, 5, -1, 0, 483, 484, 3, 26, 13, 0, 484, 485, 6, 5, -1, 0, 485, 496, 1, 0, 0, 0, 486, 487, 6, 5, -1, 0, 487, 488, 3, 42, 21, 0, 488, 489, 6, 5, -1, 0, 489, 496, 1, 0, 0, 0, 490, 491, 6, 5, -1, 0, 491, 496, 3, 40, 20, 0, 492, 496, 3, 30, 15, 0, 493, 494, 6, 5, -1, 0, 494, 496, 3, 24, 12, 0, 495, 409, 1, 0, 0, 0, 495, 414, 1, 0, 0, 0, 495, 419, 1, 0, 0, 0, 495, 424, 1, 0, 0, 0, 495, 425, 1, 0, 0, 0, 495, 429, 1, 0, 0, 0, 495, 433, 1, 0, 0, 0, 495, 437, 1, 0, 0, 0, 495, 441, 1, 0, 0, 0, 495, 445, 1, 0, 0, 0, 495, 449, 1, 0, 0, 0, 495, 453, 1, 0, 0, 0, 495, 457, 1, 0, 0, 0, 495, 461, 1, 0, 0, 0, 495, 465, 1, 0, 0, 0, 495, 469, 1, 0, 0, 0, 495, 472, 1, 0, 0, 0, 495, 474, 1, 0, 0, 0, 495, 476, 1, 0, 0, 0, 495, 478, 1, 0, 0, 0, 495, 480, 1, 0, 0, 0, 495, 482, 1, 0, 0, 0, 495, 486, 1, 0, 0, 0, 495, 490, 1, 0, 0, 0, 495, 492, 1, 0, 0, 0, 495, 493, 1, 0, 0, 0, 496, 11, 1, 0, 0, 0, 497, 498, 5, 19, 0, 0, 498, 499, 3, 32, 16, 0, 499, 500, 6, 6, -1, 0, 500, 13, 1, 0, 0, 0, 501, 502, 5, 20, 0, 0, 502, 503, 3, 32, 16, 0, 503, 504, 6, 7, -1, 0, 504, 15, 1, 0, 0, 0, 505, 506, 5, 21, 0, 0, 506, 507, 5, 22, 0, 0, 507, 508, 3, 32, 16, 0, 508, 509, 6, 8, -1, 0, 509, 17, 1, 0, 0, 0, 510, 511, 5, 23, 0, 0, 511, 512, 3, 34, 17, 0, 512, 513, 6, 9, -1, 0, 513, 19, 1, 0, 0, 0, 514, 515, 5, 24, 0, 0, 515, 516, 3, 34, 17, 0, 516, 517, 6, 10, -1, 0, 517, 21, 1, 0, 0, 0, 518, 519, 5, 25, 0, 0, 519, 520, 3, 100, 50, 0, 520, 521, 3, 2, 1, 0, 521, 522, 5, 17, 0, 0, 522, 523, 3, 122, 61, 0, 523, 524, 5, 18, 0, 0, 524, 525, 6, 11, -1, 0, 525, 23, 1, 0, 0, 0, 526, 527, 5, 26, 0, 0, 527, 25, 1, 0, 0, 0, 528, 529, 5, 27, 0, 0, 529, 530, 3, 28, 14, 0, 530, 531, 6, 13, -1, 0, 531, 547, 1, 0, 0, 0, 532, 533, 5, 27, 0, 0, 533, 534, 3, 28, 14, 0, 534, 535, 5, 28, 0, 0, 535, 536, 3, 28, 14, 0, 536, 537, 6, 13, -1, 0, 537, 547, 1, 0, 0, 0, 538, 539, 5, 27, 0, 0, 539, 540, 3, 28, 14, 0, 540, 541, 5, 28, 0, 0, 541, 542, 3, 28, 14, 0, 542, 543, 5, 28, 0, 0, 543, 544, 3, 28, 14, 0, 544, 545, 6, 13, -1, 0, 545, 547, 1, 0, 0, 0, 546, 528, 1, 0, 0, 0, 546, 532, 1, 0, 0, 0, 546, 538, 1, 0, 0, 0, 547, 27, 1, 0, 0, 0, 548, 549, 7, 2, 0, 0, 549, 29, 1, 0, 0, 0, 550, 551, 5, 29, 0, 0, 551, 557, 5, 17, 0, 0, 552, 553, 3, 118, 59, 0, 553, 554, 6, 15, -1, 0, 554, 556, 1, 0, 0, 0, 555, 552, 1, 0, 0, 0, 556, 559, 1, 0, 0, 0, 557, 555, 1, 0, 0, 0, 557, 558, 1, 0, 0, 0, 558, 560, 1, 0, 0, 0, 559, 557, 1, 0, 0, 0, 560, 561, 5, 18, 0, 0, 561, 31, 1, 0, 0, 0, 562, 563, 5, 173, 0, 0, 563, 33, 1, 0, 0, 0, 564, 565, 7, 3, 0, 0, 565, 35, 1, 0, 0, 0, 566, 567, 5, 175, 0, 0, 567, 588, 6, 18, -1, 0, 568, 569, 3, 32, 16, 0, 569, 570, 5, 265, 0, 0, 570, 571, 6, 18, -1, 0, 571, 588, 1, 0, 0, 0, 572, 573, 3, 32, 16, 0, 573, 574, 6, 18, -1, 0, 574, 588, 1, 0, 0, 0, 575, 576, 5, 188, 0, 0, 576, 577, 5, 30, 0, 0, 577, 578, 3, 32, 16, 0, 578, 579, 5, 31, 0, 0, 579, 580, 6, 18, -1, 0, 580, 588, 1, 0, 0, 0, 581, 582, 5, 189, 0, 0, 582, 583, 5, 30, 0, 0, 583, 584, 3, 34, 17, 0, 584, 585, 5, 31, 0, 0, 585, 586, 6, 18, -1, 0, 586, 588, 1, 0, 0, 0, 587, 566, 1, 0, 0, 0, 587, 568, 1, 0, 0, 0, 587, 572, 1, 0, 0, 0, 587, 575, 1, 0, 0, 0, 587, 581, 1, 0, 0, 0, 588, 37, 1, 0, 0, 0, 589, 590, 3, 32, 16, 0, 590, 591, 6, 19, -1, 0, 591, 595, 1, 0, 0, 0, 592, 593, 5, 262, 0, 0, 593, 595, 6, 19, -1, 0, 594, 589, 1, 0, 0, 0, 594, 592, 1, 0, 0, 0, 595, 39, 1, 0, 0, 0, 596, 597, 5, 267, 0, 0, 597, 613, 5, 289, 0, 0, 598, 599, 5, 267, 0, 0, 599, 600, 5, 289, 0, 0, 600, 613, 5, 263, 0, 0, 601, 602, 5, 268, 0, 0, 602, 613, 5, 289, 0, 0, 603, 604, 5, 269, 0, 0, 604, 613, 5, 289, 0, 0, 605, 606, 5, 270, 0, 0, 606, 613, 5, 289, 0, 0, 607, 613, 5, 271, 0, 0, 608, 613, 5, 272, 0, 0, 609, 610, 5, 273, 0, 0, 610, 613, 5, 263, 0, 0, 611, 613, 5, 32, 0, 0, 612, 596, 1, 0, 0, 0, 612, 598, 1, 0, 0, 0, 612, 601, 1, 0, 0, 0, 612, 603, 1, 0, 0, 0, 612, 605, 1, 0, 0, 0, 612, 607, 1, 0, 0, 0, 612, 608, 1, 0, 0, 0, 612, 609, 1, 0, 0, 0, 612, 611, 1, 0, 0, 0, 613, 41, 1, 0, 0, 0, 614, 615, 5, 33, 0, 0, 615, 616, 3, 140, 70, 0, 616, 617, 5, 34, 0, 0, 617, 618, 3, 2, 1, 0, 618, 619, 6, 21, -1, 0, 619, 645, 1, 0, 0, 0, 620, 621, 5, 33, 0, 0, 621, 622, 3, 118, 59, 0, 622, 623, 5, 34, 0, 0, 623, 624, 3, 2, 1, 0, 624, 625, 6, 21, -1, 0, 625, 645, 1, 0, 0, 0, 626, 627, 5, 33, 0, 0, 627, 628, 3, 178, 89, 0, 628, 629, 5, 34, 0, 0, 629, 630, 3, 2, 1, 0, 630, 631, 6, 21, -1, 0, 631, 645, 1, 0, 0, 0, 632, 633, 5, 33, 0, 0, 633, 634, 3, 44, 22, 0, 634, 635, 5, 34, 0, 0, 635, 636, 3, 2, 1, 0, 636, 637, 6, 21, -1, 0, 637, 645, 1, 0, 0, 0, 638, 639, 5, 33, 0, 0, 639, 640, 3, 46, 23, 0, 640, 641, 5, 34, 0, 0, 641, 642, 3, 2, 1, 0, 642, 643, 6, 21, -1, 0, 643, 645, 1, 0, 0, 0, 644, 614, 1, 0, 0, 0, 644, 620, 1, 0, 0, 0, 644, 626, 1, 0, 0, 0, 644, 632, 1, 0, 0, 0, 644, 638, 1, 0, 0, 0, 645, 43, 1, 0, 0, 0, 646, 647, 5, 35, 0, 0, 647, 648, 3, 48, 24, 0, 648, 649, 6, 22, -1, 0, 649, 673, 1, 0, 0, 0, 650, 651, 5, 35, 0, 0, 651, 652, 3, 48, 24, 0, 652, 653, 5, 36, 0, 0, 653, 654, 3, 6, 3, 0, 654, 655, 6, 22, -1, 0, 655, 673, 1, 0, 0, 0, 656, 657, 5, 35, 0, 0, 657, 658, 3, 48, 24, 0, 658, 659, 5, 36, 0, 0, 659, 660, 5, 17, 0, 0, 660, 661, 3, 52, 26, 0, 661, 662, 5, 18, 0, 0, 662, 663, 6, 22, -1, 0, 663, 673, 1, 0, 0, 0, 664, 665, 5, 35, 0, 0, 665, 666, 3, 48, 24, 0, 666, 667, 5, 36, 0, 0, 667, 668, 5, 30, 0, 0, 668, 669, 3, 302, 151, 0, 669, 670, 5, 31, 0, 0, 670, 671, 6, 22, -1, 0, 671, 673, 1, 0, 0, 0, 672, 646, 1, 0, 0, 0, 672, 650, 1, 0, 0, 0, 672, 656, 1, 0, 0, 0, 672, 664, 1, 0, 0, 0, 673, 45, 1, 0, 0, 0, 674, 675, 5, 35, 0, 0, 675, 676, 5, 30, 0, 0, 676, 677, 3, 50, 25, 0, 677, 678, 5, 31, 0, 0, 678, 679, 3, 48, 24, 0, 679, 680, 6, 23, -1, 0, 680, 713, 1, 0, 0, 0, 681, 682, 5, 35, 0, 0, 682, 683, 5, 30, 0, 0, 683, 684, 3, 50, 25, 0, 684, 685, 5, 31, 0, 0, 685, 686, 3, 48, 24, 0, 686, 687, 5, 36, 0, 0, 687, 688, 3, 6, 3, 0, 688, 689, 6, 23, -1, 0, 689, 713, 1, 0, 0, 0, 690, 691, 5, 35, 0, 0, 691, 692, 5, 30, 0, 0, 692, 693, 3, 50, 25, 0, 693, 694, 5, 31, 0, 0, 694, 695, 3, 48, 24, 0, 695, 696, 5, 36, 0, 0, 696, 697, 5, 17, 0, 0, 697, 698, 3, 52, 26, 0, 698, 699, 5, 18, 0, 0, 699, 700, 6, 23, -1, 0, 700, 713, 1, 0, 0, 0, 701, 702, 5, 35, 0, 0, 702, 703, 5, 30, 0, 0, 703, 704, 3, 50, 25, 0, 704, 705, 5, 31, 0, 0, 705, 706, 3, 48, 24, 0, 706, 707, 5, 36, 0, 0, 707, 708, 5, 30, 0, 0, 708, 709, 3, 302, 151, 0, 709, 710, 5, 31, 0, 0, 710, 711, 6, 23, -1, 0, 711, 713, 1, 0, 0, 0, 712, 674, 1, 0, 0, 0, 712, 681, 1, 0, 0, 0, 712, 690, 1, 0, 0, 0, 712, 701, 1, 0, 0, 0, 713, 47, 1, 0, 0, 0, 714, 715, 3, 170, 85, 0, 715, 716, 6, 24, -1, 0, 716, 49, 1, 0, 0, 0, 717, 718, 3, 126, 63, 0, 718, 719, 6, 25, -1, 0, 719, 724, 1, 0, 0, 0, 720, 721, 3, 178, 89, 0, 721, 722, 6, 25, -1, 0, 722, 724, 1, 0, 0, 0, 723, 717, 1, 0, 0, 0, 723, 720, 1, 0, 0, 0, 724, 51, 1, 0, 0, 0, 725, 726, 3, 54, 27, 0, 726, 727, 3, 56, 28, 0, 727, 728, 6, 26, -1, 0, 728, 53, 1, 0, 0, 0, 729, 730, 3, 308, 154, 0, 730, 731, 6, 27, -1, 0, 731, 734, 1, 0, 0, 0, 732, 734, 3, 40, 20, 0, 733, 729, 1, 0, 0, 0, 733, 732, 1, 0, 0, 0, 734, 737, 1, 0, 0, 0, 735, 733, 1, 0, 0, 0, 735, 736, 1, 0, 0, 0, 736, 55, 1, 0, 0, 0, 737, 735, 1, 0, 0, 0, 738, 739, 3, 58, 29, 0, 739, 740, 3, 60, 30, 0, 740, 741, 3, 2, 1, 0, 741, 742, 5, 36, 0, 0, 742, 743, 3, 308, 154, 0, 743, 744, 6, 28, -1, 0, 744, 747, 1, 0, 0, 0, 745, 747, 3, 40, 20, 0, 746, 738, 1, 0, 0, 0, 746, 745, 1, 0, 0, 0, 747, 750, 1, 0, 0, 0, 748, 746, 1, 0, 0, 0, 748, 749, 1, 0, 0, 0, 749, 57, 1, 0, 0, 0, 750, 748, 1, 0, 0, 0, 751, 752, 7, 4, 0, 0, 752, 753, 6, 29, -1, 0, 753, 59, 1, 0, 0, 0, 754, 756, 3, 62, 31, 0, 755, 757, 5, 261, 0, 0, 756, 755, 1, 0, 0, 0, 756, 757, 1, 0, 0, 0, 757, 758, 1, 0, 0, 0, 758, 759, 6, 30, -1, 0, 759, 61, 1, 0, 0, 0, 760, 761, 3, 146, 73, 0, 761, 762, 6, 31, -1, 0, 762, 779, 1, 0, 0, 0, 763, 764, 3, 2, 1, 0, 764, 765, 6, 31, -1, 0, 765, 779, 1, 0, 0, 0, 766, 767, 5, 196, 0, 0, 767, 779, 6, 31, -1, 0, 768, 769, 5, 197, 0, 0, 769, 779, 6, 31, -1, 0, 770, 771, 5, 202, 0, 0, 771, 772, 5, 39, 0, 0, 772, 773, 5, 264, 0, 0, 773, 779, 6, 31, -1, 0, 774, 775, 5, 202, 0, 0, 775, 776, 3, 118, 59, 0, 776, 777, 6, 31, -1, 0, 777, 779, 1, 0, 0, 0, 778, 760, 1, 0, 0, 0, 778, 763, 1, 0, 0, 0, 778, 766, 1, 0, 0, 0, 778, 768, 1, 0, 0, 0, 778, 770, 1, 0, 0, 0, 778, 774, 1, 0, 0, 0, 779, 63, 1, 0, 0, 0, 780, 781, 5, 198, 0, 0, 781, 782, 5, 40, 0, 0, 782, 783, 3, 2, 1, 0, 783, 784, 6, 32, -1, 0, 784, 792, 1, 0, 0, 0, 785, 786, 5, 198, 0, 0, 786, 787, 3, 2, 1, 0, 787, 788, 6, 32, -1, 0, 788, 792, 1, 0, 0, 0, 789, 790, 5, 198, 0, 0, 790, 792, 6, 32, -1, 0, 791, 780, 1, 0, 0, 0, 791, 785, 1, 0, 0, 0, 791, 789, 1, 0, 0, 0, 792, 65, 1, 0, 0, 0, 793, 794, 5, 41, 0, 0, 794, 795, 5, 42, 0, 0, 795, 796, 3, 32, 16, 0, 796, 797, 5, 43, 0, 0, 797, 798, 3, 68, 34, 0, 798, 799, 5, 44, 0, 0, 799, 800, 3, 0, 0, 0, 800, 801, 6, 33, -1, 0, 801, 67, 1, 0, 0, 0, 802, 803, 3, 70, 35, 0, 803, 804, 6, 34, -1, 0, 804, 806, 1, 0, 0, 0, 805, 802, 1, 0, 0, 0, 806, 809, 1, 0, 0, 0, 807, 805, 1, 0, 0, 0, 807, 808, 1, 0, 0, 0, 808, 810, 1, 0, 0, 0, 809, 807, 1, 0, 0, 0, 810, 811, 6, 34, -1, 0, 811, 69, 1, 0, 0, 0, 812, 813, 7, 5, 0, 0, 813, 71, 1, 0, 0, 0, 814, 815, 5, 48, 0, 0, 815, 816, 5, 36, 0, 0, 816, 817, 5, 30, 0, 0, 817, 818, 3, 302, 151, 0, 818, 819, 5, 31, 0, 0, 819, 820, 6, 36, -1, 0, 820, 73, 1, 0, 0, 0, 821, 822, 5, 49, 0, 0, 822, 823, 3, 2, 1, 0, 823, 824, 6, 37, -1, 0, 824, 75, 1, 0, 0, 0, 825, 831, 5, 50, 0, 0, 826, 827, 3, 78, 39, 0, 827, 828, 6, 38, -1, 0, 828, 830, 1, 0, 0, 0, 829, 826, 1, 0, 0, 0, 830, 833, 1, 0, 0, 0, 831, 829, 1, 0, 0, 0, 831, 832, 1, 0, 0, 0, 832, 834, 1, 0, 0, 0, 833, 831, 1, 0, 0, 0, 834, 835, 3, 2, 1, 0, 835, 836, 3, 184, 92, 0, 836, 837, 3, 80, 40, 0, 837, 838, 3, 82, 41, 0, 838, 839, 6, 38, -1, 0, 839, 77, 1, 0, 0, 0, 840, 841, 5, 51, 0, 0, 841, 905, 6, 39, -1, 0, 842, 843, 5, 52, 0, 0, 843, 905, 6, 39, -1, 0, 844, 845, 5, 199, 0, 0, 845, 905, 6, 39, -1, 0, 846, 847, 5, 202, 0, 0, 847, 905, 6, 39, -1, 0, 848, 849, 5, 221, 0, 0, 849, 905, 6, 39, -1, 0, 850, 851, 5, 53, 0, 0, 851, 905, 6, 39, -1, 0, 852, 853, 5, 54, 0, 0, 853, 905, 6, 39, -1, 0, 854, 855, 5, 55, 0, 0, 855, 905, 6, 39, -1, 0, 856, 857, 5, 56, 0, 0, 857, 905, 6, 39, -1, 0, 858, 859, 5, 244, 0, 0, 859, 905, 6, 39, -1, 0, 860, 861, 5, 15, 0, 0, 861, 905, 6, 39, -1, 0, 862, 863, 5, 224, 0, 0, 863, 905, 6, 39, -1, 0, 864, 865, 5, 57, 0, 0, 865, 905, 6, 39, -1, 0, 866, 867, 5, 58, 0, 0, 867, 905, 6, 39, -1, 0, 868, 869, 5, 59, 0, 0, 869, 905, 6, 39, -1, 0, 870, 871, 5, 60, 0, 0, 871, 905, 6, 39, -1, 0, 872, 873, 5, 61, 0, 0, 873, 905, 6, 39, -1, 0, 874, 875, 5, 62, 0, 0, 875, 876, 5, 51, 0, 0, 876, 905, 6, 39, -1, 0, 877, 878, 5, 62, 0, 0, 878, 879, 5, 52, 0, 0, 879, 905, 6, 39, -1, 0, 880, 881, 5, 62, 0, 0, 881, 882, 5, 63, 0, 0, 882, 905, 6, 39, -1, 0, 883, 884, 5, 62, 0, 0, 884, 885, 5, 64, 0, 0, 885, 905, 6, 39, -1, 0, 886, 887, 5, 62, 0, 0, 887, 888, 5, 65, 0, 0, 888, 905, 6, 39, -1, 0, 889, 890, 5, 62, 0, 0, 890, 891, 5, 66, 0, 0, 891, 905, 6, 39, -1, 0, 892, 893, 5, 67, 0, 0, 893, 905, 6, 39, -1, 0, 894, 895, 5, 68, 0, 0, 895, 905, 6, 39, -1, 0, 896, 897, 5, 69, 0, 0, 897, 905, 6, 39, -1, 0, 898, 899, 5, 70, 0, 0, 899, 900, 5, 30, 0, 0, 900, 901, 3, 32, 16, 0, 901, 902, 5, 31, 0, 0, 902, 903, 6, 39, -1, 0, 903, 905, 1, 0, 0, 0, 904, 840, 1, 0, 0, 0, 904, 842, 1, 0, 0, 0, 904, 844, 1, 0, 0, 0, 904, 846, 1, 0, 0, 0, 904, 848, 1, 0, 0, 0, 904, 850, 1, 0, 0, 0, 904, 852, 1, 0, 0, 0, 904, 854, 1, 0, 0, 0, 904, 856, 1, 0, 0, 0, 904, 858, 1, 0, 0, 0, 904, 860, 1, 0, 0, 0, 904, 862, 1, 0, 0, 0, 904, 864, 1, 0, 0, 0, 904, 866, 1, 0, 0, 0, 904, 868, 1, 0, 0, 0, 904, 870, 1, 0, 0, 0, 904, 872, 1, 0, 0, 0, 904, 874, 1, 0, 0, 0, 904, 877, 1, 0, 0, 0, 904, 880, 1, 0, 0, 0, 904, 883, 1, 0, 0, 0, 904, 886, 1, 0, 0, 0, 904, 889, 1, 0, 0, 0, 904, 892, 1, 0, 0, 0, 904, 894, 1, 0, 0, 0, 904, 896, 1, 0, 0, 0, 904, 898, 1, 0, 0, 0, 905, 79, 1, 0, 0, 0, 906, 912, 1, 0, 0, 0, 907, 908, 5, 71, 0, 0, 908, 909, 3, 126, 63, 0, 909, 910, 6, 40, -1, 0, 910, 912, 1, 0, 0, 0, 911, 906, 1, 0, 0, 0, 911, 907, 1, 0, 0, 0, 912, 81, 1, 0, 0, 0, 913, 919, 1, 0, 0, 0, 914, 915, 5, 72, 0, 0, 915, 916, 3, 86, 43, 0, 916, 917, 6, 41, -1, 0, 917, 919, 1, 0, 0, 0, 918, 913, 1, 0, 0, 0, 918, 914, 1, 0, 0, 0, 919, 83, 1, 0, 0, 0, 920, 922, 3, 200, 100, 0, 921, 920, 1, 0, 0, 0, 922, 925, 1, 0, 0, 0, 923, 921, 1, 0, 0, 0, 923, 924, 1, 0, 0, 0, 924, 85, 1, 0, 0, 0, 925, 923, 1, 0, 0, 0, 926, 927, 3, 126, 63, 0, 927, 928, 6, 43, -1, 0, 928, 929, 5, 28, 0, 0, 929, 931, 1, 0, 0, 0, 930, 926, 1, 0, 0, 0, 931, 934, 1, 0, 0, 0, 932, 930, 1, 0, 0, 0, 932, 933, 1, 0, 0, 0, 933, 935, 1, 0, 0, 0, 934, 932, 1, 0, 0, 0, 935, 936, 3, 126, 63, 0, 936, 937, 6, 43, -1, 0, 937, 87, 1, 0, 0, 0, 938, 939, 7, 6, 0, 0, 939, 89, 1, 0, 0, 0, 940, 941, 3, 88, 44, 0, 941, 943, 3, 32, 16, 0, 942, 944, 7, 2, 0, 0, 943, 942, 1, 0, 0, 0, 943, 944, 1, 0, 0, 0, 944, 945, 1, 0, 0, 0, 945, 946, 6, 45, -1, 0, 946, 992, 1, 0, 0, 0, 947, 948, 3, 88, 44, 0, 948, 949, 3, 32, 16, 0, 949, 950, 5, 75, 0, 0, 950, 952, 3, 32, 16, 0, 951, 953, 7, 2, 0, 0, 952, 951, 1, 0, 0, 0, 952, 953, 1, 0, 0, 0, 953, 954, 1, 0, 0, 0, 954, 955, 6, 45, -1, 0, 955, 992, 1, 0, 0, 0, 956, 957, 3, 88, 44, 0, 957, 958, 3, 32, 16, 0, 958, 959, 5, 75, 0, 0, 959, 960, 3, 32, 16, 0, 960, 961, 5, 28, 0, 0, 961, 963, 3, 32, 16, 0, 962, 964, 7, 2, 0, 0, 963, 962, 1, 0, 0, 0, 963, 964, 1, 0, 0, 0, 964, 965, 1, 0, 0, 0, 965, 966, 6, 45, -1, 0, 966, 992, 1, 0, 0, 0, 967, 968, 3, 88, 44, 0, 968, 969, 3, 32, 16, 0, 969, 970, 5, 28, 0, 0, 970, 971, 3, 32, 16, 0, 971, 972, 5, 75, 0, 0, 972, 974, 3, 32, 16, 0, 973, 975, 7, 2, 0, 0, 974, 973, 1, 0, 0, 0, 974, 975, 1, 0, 0, 0, 975, 976, 1, 0, 0, 0, 976, 977, 6, 45, -1, 0, 977, 992, 1, 0, 0, 0, 978, 979, 3, 88, 44, 0, 979, 980, 3, 32, 16, 0, 980, 981, 5, 28, 0, 0, 981, 982, 3, 32, 16, 0, 982, 983, 5, 75, 0, 0, 983, 984, 3, 32, 16, 0, 984, 985, 5, 28, 0, 0, 985, 987, 3, 32, 16, 0, 986, 988, 7, 2, 0, 0, 987, 986, 1, 0, 0, 0, 987, 988, 1, 0, 0, 0, 988, 989, 1, 0, 0, 0, 989, 990, 6, 45, -1, 0, 990, 992, 1, 0, 0, 0, 991, 940, 1, 0, 0, 0, 991, 947, 1, 0, 0, 0, 991, 956, 1, 0, 0, 0, 991, 967, 1, 0, 0, 0, 991, 978, 1, 0, 0, 0, 992, 91, 1, 0, 0, 0, 993, 999, 5, 21, 0, 0, 994, 995, 3, 94, 47, 0, 995, 996, 6, 46, -1, 0, 996, 998, 1, 0, 0, 0, 997, 994, 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, 1003, 3, 2, 1, 0, 1003, 1004, 6, 46, -1, 0, 1004, 1005, 3, 96, 48, 0, 1005, 1015, 6, 46, -1, 0, 1006, 1007, 5, 180, 0, 0, 1007, 1008, 5, 36, 0, 0, 1008, 1009, 5, 30, 0, 0, 1009, 1010, 3, 302, 151, 0, 1010, 1011, 5, 31, 0, 0, 1011, 1012, 6, 46, -1, 0, 1012, 1013, 3, 96, 48, 0, 1013, 1014, 6, 46, -1, 0, 1014, 1016, 1, 0, 0, 0, 1015, 1006, 1, 0, 0, 0, 1015, 1016, 1, 0, 0, 0, 1016, 93, 1, 0, 0, 0, 1017, 1018, 5, 76, 0, 0, 1018, 95, 1, 0, 0, 0, 1019, 1023, 1, 0, 0, 0, 1020, 1021, 5, 298, 0, 0, 1021, 1023, 6, 48, -1, 0, 1022, 1019, 1, 0, 0, 0, 1022, 1020, 1, 0, 0, 0, 1023, 97, 1, 0, 0, 0, 1024, 1025, 7, 7, 0, 0, 1025, 99, 1, 0, 0, 0, 1026, 1027, 3, 98, 49, 0, 1027, 1028, 6, 50, -1, 0, 1028, 1030, 1, 0, 0, 0, 1029, 1026, 1, 0, 0, 0, 1030, 1033, 1, 0, 0, 0, 1031, 1029, 1, 0, 0, 0, 1031, 1032, 1, 0, 0, 0, 1032, 101, 1, 0, 0, 0, 1033, 1031, 1, 0, 0, 0, 1034, 1060, 3, 104, 52, 0, 1035, 1036, 5, 280, 0, 0, 1036, 1037, 3, 170, 85, 0, 1037, 1038, 6, 51, -1, 0, 1038, 1060, 1, 0, 0, 0, 1039, 1040, 5, 286, 0, 0, 1040, 1041, 3, 180, 90, 0, 1041, 1042, 6, 51, -1, 0, 1042, 1060, 1, 0, 0, 0, 1043, 1044, 5, 286, 0, 0, 1044, 1045, 3, 176, 88, 0, 1045, 1046, 6, 51, -1, 0, 1046, 1060, 1, 0, 0, 0, 1047, 1048, 5, 284, 0, 0, 1048, 1049, 3, 126, 63, 0, 1049, 1050, 6, 51, -1, 0, 1050, 1060, 1, 0, 0, 0, 1051, 1052, 5, 281, 0, 0, 1052, 1053, 3, 106, 53, 0, 1053, 1054, 6, 51, -1, 0, 1054, 1060, 1, 0, 0, 0, 1055, 1056, 5, 287, 0, 0, 1056, 1057, 3, 50, 25, 0, 1057, 1058, 6, 51, -1, 0, 1058, 1060, 1, 0, 0, 0, 1059, 1034, 1, 0, 0, 0, 1059, 1035, 1, 0, 0, 0, 1059, 1039, 1, 0, 0, 0, 1059, 1043, 1, 0, 0, 0, 1059, 1047, 1, 0, 0, 0, 1059, 1051, 1, 0, 0, 0, 1059, 1055, 1, 0, 0, 0, 1060, 103, 1, 0, 0, 0, 1061, 1062, 5, 275, 0, 0, 1062, 1140, 6, 52, -1, 0, 1063, 1064, 5, 276, 0, 0, 1064, 1065, 3, 32, 16, 0, 1065, 1066, 6, 52, -1, 0, 1066, 1140, 1, 0, 0, 0, 1067, 1068, 5, 276, 0, 0, 1068, 1069, 3, 0, 0, 0, 1069, 1070, 6, 52, -1, 0, 1070, 1140, 1, 0, 0, 0, 1071, 1072, 5, 277, 0, 0, 1072, 1073, 3, 32, 16, 0, 1073, 1074, 6, 52, -1, 0, 1074, 1140, 1, 0, 0, 0, 1075, 1076, 5, 278, 0, 0, 1076, 1077, 3, 34, 17, 0, 1077, 1078, 6, 52, -1, 0, 1078, 1140, 1, 0, 0, 0, 1079, 1080, 5, 279, 0, 0, 1080, 1081, 3, 36, 18, 0, 1081, 1082, 6, 52, -1, 0, 1082, 1140, 1, 0, 0, 0, 1083, 1084, 5, 279, 0, 0, 1084, 1085, 3, 34, 17, 0, 1085, 1086, 6, 52, -1, 0, 1086, 1140, 1, 0, 0, 0, 1087, 1088, 5, 279, 0, 0, 1088, 1089, 5, 30, 0, 0, 1089, 1090, 3, 302, 151, 0, 1090, 1091, 5, 31, 0, 0, 1091, 1092, 6, 52, -1, 0, 1092, 1140, 1, 0, 0, 0, 1093, 1094, 5, 279, 0, 0, 1094, 1095, 5, 84, 0, 0, 1095, 1096, 5, 30, 0, 0, 1096, 1097, 3, 302, 151, 0, 1097, 1098, 5, 31, 0, 0, 1098, 1099, 6, 52, -1, 0, 1099, 1140, 1, 0, 0, 0, 1100, 1101, 5, 282, 0, 0, 1101, 1102, 3, 32, 16, 0, 1102, 1103, 6, 52, -1, 0, 1103, 1140, 1, 0, 0, 0, 1104, 1105, 5, 282, 0, 0, 1105, 1106, 3, 0, 0, 0, 1106, 1107, 6, 52, -1, 0, 1107, 1140, 1, 0, 0, 0, 1108, 1109, 5, 285, 0, 0, 1109, 1110, 3, 6, 3, 0, 1110, 1111, 6, 52, -1, 0, 1111, 1140, 1, 0, 0, 0, 1112, 1113, 5, 285, 0, 0, 1113, 1114, 5, 224, 0, 0, 1114, 1115, 5, 30, 0, 0, 1115, 1116, 3, 6, 3, 0, 1116, 1117, 5, 31, 0, 0, 1117, 1118, 6, 52, -1, 0, 1118, 1140, 1, 0, 0, 0, 1119, 1120, 5, 285, 0, 0, 1120, 1121, 5, 84, 0, 0, 1121, 1122, 5, 30, 0, 0, 1122, 1123, 3, 302, 151, 0, 1123, 1124, 5, 31, 0, 0, 1124, 1125, 6, 52, -1, 0, 1125, 1140, 1, 0, 0, 0, 1126, 1127, 5, 287, 0, 0, 1127, 1128, 3, 32, 16, 0, 1128, 1129, 6, 52, -1, 0, 1129, 1140, 1, 0, 0, 0, 1130, 1131, 5, 283, 0, 0, 1131, 1137, 6, 52, -1, 0, 1132, 1133, 5, 30, 0, 0, 1133, 1134, 3, 108, 54, 0, 1134, 1135, 5, 31, 0, 0, 1135, 1138, 1, 0, 0, 0, 1136, 1138, 5, 85, 0, 0, 1137, 1132, 1, 0, 0, 0, 1137, 1136, 1, 0, 0, 0, 1138, 1140, 1, 0, 0, 0, 1139, 1061, 1, 0, 0, 0, 1139, 1063, 1, 0, 0, 0, 1139, 1067, 1, 0, 0, 0, 1139, 1071, 1, 0, 0, 0, 1139, 1075, 1, 0, 0, 0, 1139, 1079, 1, 0, 0, 0, 1139, 1083, 1, 0, 0, 0, 1139, 1087, 1, 0, 0, 0, 1139, 1093, 1, 0, 0, 0, 1139, 1100, 1, 0, 0, 0, 1139, 1104, 1, 0, 0, 0, 1139, 1108, 1, 0, 0, 0, 1139, 1112, 1, 0, 0, 0, 1139, 1119, 1, 0, 0, 0, 1139, 1126, 1, 0, 0, 0, 1139, 1130, 1, 0, 0, 0, 1140, 105, 1, 0, 0, 0, 1141, 1142, 3, 172, 86, 0, 1142, 1143, 3, 140, 70, 0, 1143, 1144, 3, 114, 57, 0, 1144, 1145, 6, 53, -1, 0, 1145, 107, 1, 0, 0, 0, 1146, 1171, 1, 0, 0, 0, 1147, 1148, 3, 0, 0, 0, 1148, 1149, 6, 54, -1, 0, 1149, 1154, 1, 0, 0, 0, 1150, 1151, 3, 32, 16, 0, 1151, 1152, 6, 54, -1, 0, 1152, 1154, 1, 0, 0, 0, 1153, 1147, 1, 0, 0, 0, 1153, 1150, 1, 0, 0, 0, 1154, 1155, 1, 0, 0, 0, 1155, 1156, 5, 28, 0, 0, 1156, 1158, 1, 0, 0, 0, 1157, 1153, 1, 0, 0, 0, 1158, 1161, 1, 0, 0, 0, 1159, 1157, 1, 0, 0, 0, 1159, 1160, 1, 0, 0, 0, 1160, 1168, 1, 0, 0, 0, 1161, 1159, 1, 0, 0, 0, 1162, 1163, 3, 0, 0, 0, 1163, 1164, 6, 54, -1, 0, 1164, 1169, 1, 0, 0, 0, 1165, 1166, 3, 32, 16, 0, 1166, 1167, 6, 54, -1, 0, 1167, 1169, 1, 0, 0, 0, 1168, 1162, 1, 0, 0, 0, 1168, 1165, 1, 0, 0, 0, 1169, 1171, 1, 0, 0, 0, 1170, 1146, 1, 0, 0, 0, 1170, 1159, 1, 0, 0, 0, 1171, 109, 1, 0, 0, 0, 1172, 1179, 5, 86, 0, 0, 1173, 1174, 3, 140, 70, 0, 1174, 1175, 6, 55, -1, 0, 1175, 1176, 5, 28, 0, 0, 1176, 1178, 1, 0, 0, 0, 1177, 1173, 1, 0, 0, 0, 1178, 1181, 1, 0, 0, 0, 1179, 1177, 1, 0, 0, 0, 1179, 1180, 1, 0, 0, 0, 1180, 1182, 1, 0, 0, 0, 1181, 1179, 1, 0, 0, 0, 1182, 1183, 3, 140, 70, 0, 1183, 1184, 6, 55, -1, 0, 1184, 1185, 5, 87, 0, 0, 1185, 111, 1, 0, 0, 0, 1186, 1193, 5, 42, 0, 0, 1187, 1188, 3, 148, 74, 0, 1188, 1189, 6, 56, -1, 0, 1189, 1190, 5, 28, 0, 0, 1190, 1192, 1, 0, 0, 0, 1191, 1187, 1, 0, 0, 0, 1192, 1195, 1, 0, 0, 0, 1193, 1191, 1, 0, 0, 0, 1193, 1194, 1, 0, 0, 0, 1194, 1196, 1, 0, 0, 0, 1195, 1193, 1, 0, 0, 0, 1196, 1197, 3, 148, 74, 0, 1197, 1198, 6, 56, -1, 0, 1198, 1199, 5, 43, 0, 0, 1199, 113, 1, 0, 0, 0, 1200, 1207, 5, 30, 0, 0, 1201, 1202, 3, 116, 58, 0, 1202, 1203, 6, 57, -1, 0, 1203, 1204, 5, 28, 0, 0, 1204, 1206, 1, 0, 0, 0, 1205, 1201, 1, 0, 0, 0, 1206, 1209, 1, 0, 0, 0, 1207, 1205, 1, 0, 0, 0, 1207, 1208, 1, 0, 0, 0, 1208, 1210, 1, 0, 0, 0, 1209, 1207, 1, 0, 0, 0, 1210, 1211, 3, 116, 58, 0, 1211, 1212, 6, 57, -1, 0, 1212, 1213, 5, 31, 0, 0, 1213, 1216, 1, 0, 0, 0, 1214, 1216, 5, 85, 0, 0, 1215, 1200, 1, 0, 0, 0, 1215, 1214, 1, 0, 0, 0, 1216, 115, 1, 0, 0, 0, 1217, 1218, 5, 177, 0, 0, 1218, 1228, 6, 58, -1, 0, 1219, 1220, 3, 232, 116, 0, 1220, 1221, 3, 140, 70, 0, 1221, 1223, 3, 228, 114, 0, 1222, 1224, 3, 0, 0, 0, 1223, 1222, 1, 0, 0, 0, 1223, 1224, 1, 0, 0, 0, 1224, 1225, 1, 0, 0, 0, 1225, 1226, 6, 58, -1, 0, 1226, 1228, 1, 0, 0, 0, 1227, 1217, 1, 0, 0, 0, 1227, 1219, 1, 0, 0, 0, 1228, 117, 1, 0, 0, 0, 1229, 1230, 5, 42, 0, 0, 1230, 1231, 3, 2, 1, 0, 1231, 1232, 5, 43, 0, 0, 1232, 1233, 3, 120, 60, 0, 1233, 1234, 6, 59, -1, 0, 1234, 1267, 1, 0, 0, 0, 1235, 1236, 5, 42, 0, 0, 1236, 1237, 3, 176, 88, 0, 1237, 1238, 5, 43, 0, 0, 1238, 1239, 3, 120, 60, 0, 1239, 1240, 6, 59, -1, 0, 1240, 1267, 1, 0, 0, 0, 1241, 1242, 5, 42, 0, 0, 1242, 1243, 5, 262, 0, 0, 1243, 1244, 5, 43, 0, 0, 1244, 1245, 3, 120, 60, 0, 1245, 1246, 6, 59, -1, 0, 1246, 1267, 1, 0, 0, 0, 1247, 1248, 5, 42, 0, 0, 1248, 1249, 5, 198, 0, 0, 1249, 1250, 3, 2, 1, 0, 1250, 1251, 5, 43, 0, 0, 1251, 1252, 3, 120, 60, 0, 1252, 1253, 6, 59, -1, 0, 1253, 1267, 1, 0, 0, 0, 1254, 1255, 3, 120, 60, 0, 1255, 1256, 6, 59, -1, 0, 1256, 1267, 1, 0, 0, 0, 1257, 1258, 3, 176, 88, 0, 1258, 1259, 6, 59, -1, 0, 1259, 1267, 1, 0, 0, 0, 1260, 1261, 5, 257, 0, 0, 1261, 1267, 6, 59, -1, 0, 1262, 1263, 5, 258, 0, 0, 1263, 1267, 6, 59, -1, 0, 1264, 1265, 5, 259, 0, 0, 1265, 1267, 6, 59, -1, 0, 1266, 1229, 1, 0, 0, 0, 1266, 1235, 1, 0, 0, 0, 1266, 1241, 1, 0, 0, 0, 1266, 1247, 1, 0, 0, 0, 1266, 1254, 1, 0, 0, 0, 1266, 1257, 1, 0, 0, 0, 1266, 1260, 1, 0, 0, 0, 1266, 1262, 1, 0, 0, 0, 1266, 1264, 1, 0, 0, 0, 1267, 119, 1, 0, 0, 0, 1268, 1269, 3, 2, 1, 0, 1269, 1270, 6, 60, -1, 0, 1270, 1271, 5, 88, 0, 0, 1271, 1273, 1, 0, 0, 0, 1272, 1268, 1, 0, 0, 0, 1273, 1276, 1, 0, 0, 0, 1274, 1272, 1, 0, 0, 0, 1274, 1275, 1, 0, 0, 0, 1275, 1277, 1, 0, 0, 0, 1276, 1274, 1, 0, 0, 0, 1277, 1278, 3, 2, 1, 0, 1278, 1279, 6, 60, -1, 0, 1279, 121, 1, 0, 0, 0, 1280, 1281, 3, 124, 62, 0, 1281, 1282, 6, 61, -1, 0, 1282, 1284, 1, 0, 0, 0, 1283, 1280, 1, 0, 0, 0, 1284, 1287, 1, 0, 0, 0, 1285, 1283, 1, 0, 0, 0, 1285, 1286, 1, 0, 0, 0, 1286, 123, 1, 0, 0, 0, 1287, 1285, 1, 0, 0, 0, 1288, 1289, 5, 180, 0, 0, 1289, 1290, 5, 89, 0, 0, 1290, 1291, 3, 32, 16, 0, 1291, 1292, 6, 62, -1, 0, 1292, 1300, 1, 0, 0, 0, 1293, 1294, 3, 154, 77, 0, 1294, 1295, 6, 62, -1, 0, 1295, 1300, 1, 0, 0, 0, 1296, 1297, 3, 334, 167, 0, 1297, 1298, 6, 62, -1, 0, 1298, 1300, 1, 0, 0, 0, 1299, 1288, 1, 0, 0, 0, 1299, 1293, 1, 0, 0, 0, 1299, 1296, 1, 0, 0, 0, 1300, 125, 1, 0, 0, 0, 1301, 1302, 3, 118, 59, 0, 1302, 1303, 6, 63, -1, 0, 1303, 1319, 1, 0, 0, 0, 1304, 1305, 5, 42, 0, 0, 1305, 1306, 3, 2, 1, 0, 1306, 1307, 5, 43, 0, 0, 1307, 1308, 6, 63, -1, 0, 1308, 1319, 1, 0, 0, 0, 1309, 1310, 5, 42, 0, 0, 1310, 1311, 5, 198, 0, 0, 1311, 1312, 3, 2, 1, 0, 1312, 1313, 5, 43, 0, 0, 1313, 1314, 6, 63, -1, 0, 1314, 1319, 1, 0, 0, 0, 1315, 1316, 3, 140, 70, 0, 1316, 1317, 6, 63, -1, 0, 1317, 1319, 1, 0, 0, 0, 1318, 1301, 1, 0, 0, 0, 1318, 1304, 1, 0, 0, 0, 1318, 1309, 1, 0, 0, 0, 1318, 1315, 1, 0, 0, 0, 1319, 127, 1, 0, 0, 0, 1320, 1332, 1, 0, 0, 0, 1321, 1322, 3, 132, 66, 0, 1322, 1328, 6, 64, -1, 0, 1323, 1324, 3, 130, 65, 0, 1324, 1325, 6, 64, -1, 0, 1325, 1327, 1, 0, 0, 0, 1326, 1323, 1, 0, 0, 0, 1327, 1330, 1, 0, 0, 0, 1328, 1326, 1, 0, 0, 0, 1328, 1329, 1, 0, 0, 0, 1329, 1332, 1, 0, 0, 0, 1330, 1328, 1, 0, 0, 0, 1331, 1320, 1, 0, 0, 0, 1331, 1321, 1, 0, 0, 0, 1332, 129, 1, 0, 0, 0, 1333, 1334, 5, 262, 0, 0, 1334, 1356, 6, 65, -1, 0, 1335, 1336, 5, 261, 0, 0, 1336, 1356, 6, 65, -1, 0, 1337, 1338, 5, 42, 0, 0, 1338, 1339, 3, 32, 16, 0, 1339, 1340, 5, 43, 0, 0, 1340, 1341, 6, 65, -1, 0, 1341, 1356, 1, 0, 0, 0, 1342, 1343, 5, 42, 0, 0, 1343, 1344, 3, 32, 16, 0, 1344, 1345, 5, 266, 0, 0, 1345, 1346, 3, 32, 16, 0, 1346, 1347, 5, 43, 0, 0, 1347, 1348, 6, 65, -1, 0, 1348, 1356, 1, 0, 0, 0, 1349, 1350, 5, 42, 0, 0, 1350, 1351, 5, 266, 0, 0, 1351, 1352, 3, 32, 16, 0, 1352, 1353, 5, 43, 0, 0, 1353, 1354, 6, 65, -1, 0, 1354, 1356, 1, 0, 0, 0, 1355, 1333, 1, 0, 0, 0, 1355, 1335, 1, 0, 0, 0, 1355, 1337, 1, 0, 0, 0, 1355, 1342, 1, 0, 0, 0, 1355, 1349, 1, 0, 0, 0, 1356, 131, 1, 0, 0, 0, 1357, 1503, 6, 66, -1, 0, 1358, 1359, 5, 203, 0, 0, 1359, 1360, 5, 30, 0, 0, 1360, 1361, 3, 6, 3, 0, 1361, 1362, 5, 28, 0, 0, 1362, 1363, 3, 6, 3, 0, 1363, 1364, 5, 28, 0, 0, 1364, 1365, 3, 6, 3, 0, 1365, 1366, 5, 28, 0, 0, 1366, 1367, 3, 6, 3, 0, 1367, 1368, 5, 31, 0, 0, 1368, 1369, 6, 66, -1, 0, 1369, 1503, 1, 0, 0, 0, 1370, 1371, 5, 203, 0, 0, 1371, 1372, 5, 30, 0, 0, 1372, 1373, 3, 6, 3, 0, 1373, 1374, 5, 28, 0, 0, 1374, 1375, 3, 6, 3, 0, 1375, 1376, 5, 31, 0, 0, 1376, 1377, 6, 66, -1, 0, 1377, 1503, 1, 0, 0, 0, 1378, 1379, 5, 204, 0, 0, 1379, 1380, 5, 205, 0, 0, 1380, 1381, 5, 42, 0, 0, 1381, 1382, 3, 32, 16, 0, 1382, 1383, 5, 43, 0, 0, 1383, 1384, 6, 66, -1, 0, 1384, 1503, 1, 0, 0, 0, 1385, 1386, 5, 204, 0, 0, 1386, 1387, 5, 206, 0, 0, 1387, 1388, 5, 42, 0, 0, 1388, 1389, 3, 32, 16, 0, 1389, 1390, 5, 43, 0, 0, 1390, 1391, 3, 128, 64, 0, 1391, 1392, 6, 66, -1, 0, 1392, 1503, 1, 0, 0, 0, 1393, 1394, 5, 207, 0, 0, 1394, 1503, 6, 66, -1, 0, 1395, 1396, 5, 208, 0, 0, 1396, 1503, 6, 66, -1, 0, 1397, 1398, 5, 209, 0, 0, 1398, 1503, 6, 66, -1, 0, 1399, 1400, 5, 201, 0, 0, 1400, 1503, 6, 66, -1, 0, 1401, 1402, 5, 183, 0, 0, 1402, 1503, 6, 66, -1, 0, 1403, 1404, 5, 184, 0, 0, 1404, 1503, 6, 66, -1, 0, 1405, 1406, 5, 185, 0, 0, 1406, 1503, 6, 66, -1, 0, 1407, 1408, 5, 186, 0, 0, 1408, 1503, 6, 66, -1, 0, 1409, 1410, 5, 187, 0, 0, 1410, 1503, 6, 66, -1, 0, 1411, 1412, 5, 188, 0, 0, 1412, 1503, 6, 66, -1, 0, 1413, 1414, 5, 189, 0, 0, 1414, 1503, 6, 66, -1, 0, 1415, 1416, 5, 210, 0, 0, 1416, 1503, 6, 66, -1, 0, 1417, 1418, 5, 190, 0, 0, 1418, 1503, 6, 66, -1, 0, 1419, 1420, 5, 191, 0, 0, 1420, 1503, 6, 66, -1, 0, 1421, 1422, 5, 192, 0, 0, 1422, 1503, 6, 66, -1, 0, 1423, 1424, 5, 193, 0, 0, 1424, 1503, 6, 66, -1, 0, 1425, 1426, 5, 211, 0, 0, 1426, 1503, 6, 66, -1, 0, 1427, 1428, 5, 212, 0, 0, 1428, 1503, 6, 66, -1, 0, 1429, 1430, 5, 213, 0, 0, 1430, 1503, 6, 66, -1, 0, 1431, 1432, 5, 214, 0, 0, 1432, 1503, 6, 66, -1, 0, 1433, 1434, 5, 215, 0, 0, 1434, 1503, 6, 66, -1, 0, 1435, 1436, 5, 216, 0, 0, 1436, 1503, 6, 66, -1, 0, 1437, 1438, 5, 217, 0, 0, 1438, 1503, 6, 66, -1, 0, 1439, 1440, 5, 218, 0, 0, 1440, 1441, 3, 134, 67, 0, 1441, 1442, 6, 66, -1, 0, 1442, 1503, 1, 0, 0, 0, 1443, 1444, 5, 219, 0, 0, 1444, 1445, 3, 134, 67, 0, 1445, 1446, 6, 66, -1, 0, 1446, 1503, 1, 0, 0, 0, 1447, 1448, 5, 220, 0, 0, 1448, 1503, 6, 66, -1, 0, 1449, 1450, 5, 221, 0, 0, 1450, 1451, 3, 134, 67, 0, 1451, 1452, 6, 66, -1, 0, 1452, 1503, 1, 0, 0, 0, 1453, 1454, 5, 222, 0, 0, 1454, 1455, 3, 136, 68, 0, 1455, 1456, 6, 66, -1, 0, 1456, 1503, 1, 0, 0, 0, 1457, 1458, 5, 222, 0, 0, 1458, 1459, 3, 136, 68, 0, 1459, 1460, 5, 28, 0, 0, 1460, 1461, 3, 6, 3, 0, 1461, 1462, 6, 66, -1, 0, 1462, 1503, 1, 0, 0, 0, 1463, 1464, 5, 194, 0, 0, 1464, 1503, 6, 66, -1, 0, 1465, 1466, 5, 195, 0, 0, 1466, 1503, 6, 66, -1, 0, 1467, 1468, 5, 90, 0, 0, 1468, 1469, 5, 184, 0, 0, 1469, 1503, 6, 66, -1, 0, 1470, 1471, 5, 90, 0, 0, 1471, 1472, 5, 185, 0, 0, 1472, 1503, 6, 66, -1, 0, 1473, 1474, 5, 90, 0, 0, 1474, 1475, 5, 186, 0, 0, 1475, 1503, 6, 66, -1, 0, 1476, 1477, 5, 90, 0, 0, 1477, 1478, 5, 187, 0, 0, 1478, 1503, 6, 66, -1, 0, 1479, 1480, 5, 62, 0, 0, 1480, 1481, 5, 220, 0, 0, 1481, 1503, 6, 66, -1, 0, 1482, 1483, 5, 223, 0, 0, 1483, 1503, 6, 66, -1, 0, 1484, 1485, 5, 224, 0, 0, 1485, 1486, 5, 213, 0, 0, 1486, 1503, 6, 66, -1, 0, 1487, 1488, 5, 225, 0, 0, 1488, 1503, 6, 66, -1, 0, 1489, 1490, 5, 207, 0, 0, 1490, 1491, 5, 183, 0, 0, 1491, 1503, 6, 66, -1, 0, 1492, 1493, 5, 226, 0, 0, 1493, 1503, 6, 66, -1, 0, 1494, 1495, 5, 228, 0, 0, 1495, 1503, 6, 66, -1, 0, 1496, 1497, 5, 34, 0, 0, 1497, 1498, 5, 227, 0, 0, 1498, 1503, 6, 66, -1, 0, 1499, 1500, 3, 2, 1, 0, 1500, 1501, 6, 66, -1, 0, 1501, 1503, 1, 0, 0, 0, 1502, 1357, 1, 0, 0, 0, 1502, 1358, 1, 0, 0, 0, 1502, 1370, 1, 0, 0, 0, 1502, 1378, 1, 0, 0, 0, 1502, 1385, 1, 0, 0, 0, 1502, 1393, 1, 0, 0, 0, 1502, 1395, 1, 0, 0, 0, 1502, 1397, 1, 0, 0, 0, 1502, 1399, 1, 0, 0, 0, 1502, 1401, 1, 0, 0, 0, 1502, 1403, 1, 0, 0, 0, 1502, 1405, 1, 0, 0, 0, 1502, 1407, 1, 0, 0, 0, 1502, 1409, 1, 0, 0, 0, 1502, 1411, 1, 0, 0, 0, 1502, 1413, 1, 0, 0, 0, 1502, 1415, 1, 0, 0, 0, 1502, 1417, 1, 0, 0, 0, 1502, 1419, 1, 0, 0, 0, 1502, 1421, 1, 0, 0, 0, 1502, 1423, 1, 0, 0, 0, 1502, 1425, 1, 0, 0, 0, 1502, 1427, 1, 0, 0, 0, 1502, 1429, 1, 0, 0, 0, 1502, 1431, 1, 0, 0, 0, 1502, 1433, 1, 0, 0, 0, 1502, 1435, 1, 0, 0, 0, 1502, 1437, 1, 0, 0, 0, 1502, 1439, 1, 0, 0, 0, 1502, 1443, 1, 0, 0, 0, 1502, 1447, 1, 0, 0, 0, 1502, 1449, 1, 0, 0, 0, 1502, 1453, 1, 0, 0, 0, 1502, 1457, 1, 0, 0, 0, 1502, 1463, 1, 0, 0, 0, 1502, 1465, 1, 0, 0, 0, 1502, 1467, 1, 0, 0, 0, 1502, 1470, 1, 0, 0, 0, 1502, 1473, 1, 0, 0, 0, 1502, 1476, 1, 0, 0, 0, 1502, 1479, 1, 0, 0, 0, 1502, 1482, 1, 0, 0, 0, 1502, 1484, 1, 0, 0, 0, 1502, 1487, 1, 0, 0, 0, 1502, 1489, 1, 0, 0, 0, 1502, 1492, 1, 0, 0, 0, 1502, 1494, 1, 0, 0, 0, 1502, 1496, 1, 0, 0, 0, 1502, 1499, 1, 0, 0, 0, 1503, 133, 1, 0, 0, 0, 1504, 1513, 1, 0, 0, 0, 1505, 1506, 5, 30, 0, 0, 1506, 1507, 5, 91, 0, 0, 1507, 1508, 5, 36, 0, 0, 1508, 1509, 3, 32, 16, 0, 1509, 1510, 5, 31, 0, 0, 1510, 1511, 6, 67, -1, 0, 1511, 1513, 1, 0, 0, 0, 1512, 1504, 1, 0, 0, 0, 1512, 1505, 1, 0, 0, 0, 1513, 135, 1, 0, 0, 0, 1514, 1525, 1, 0, 0, 0, 1515, 1516, 3, 138, 69, 0, 1516, 1521, 6, 68, -1, 0, 1517, 1518, 7, 8, 0, 0, 1518, 1520, 6, 68, -1, 0, 1519, 1517, 1, 0, 0, 0, 1520, 1523, 1, 0, 0, 0, 1521, 1519, 1, 0, 0, 0, 1521, 1522, 1, 0, 0, 0, 1522, 1525, 1, 0, 0, 0, 1523, 1521, 1, 0, 0, 0, 1524, 1514, 1, 0, 0, 0, 1524, 1515, 1, 0, 0, 0, 1525, 137, 1, 0, 0, 0, 1526, 1527, 5, 178, 0, 0, 1527, 1607, 6, 69, -1, 0, 1528, 1529, 5, 207, 0, 0, 1529, 1607, 6, 69, -1, 0, 1530, 1531, 5, 208, 0, 0, 1531, 1607, 6, 69, -1, 0, 1532, 1533, 5, 201, 0, 0, 1533, 1607, 6, 69, -1, 0, 1534, 1535, 5, 183, 0, 0, 1535, 1607, 6, 69, -1, 0, 1536, 1537, 5, 184, 0, 0, 1537, 1607, 6, 69, -1, 0, 1538, 1539, 5, 185, 0, 0, 1539, 1607, 6, 69, -1, 0, 1540, 1541, 5, 186, 0, 0, 1541, 1607, 6, 69, -1, 0, 1542, 1543, 5, 187, 0, 0, 1543, 1607, 6, 69, -1, 0, 1544, 1545, 5, 188, 0, 0, 1545, 1607, 6, 69, -1, 0, 1546, 1547, 5, 189, 0, 0, 1547, 1607, 6, 69, -1, 0, 1548, 1549, 5, 190, 0, 0, 1549, 1607, 6, 69, -1, 0, 1550, 1551, 5, 191, 0, 0, 1551, 1607, 6, 69, -1, 0, 1552, 1553, 5, 192, 0, 0, 1553, 1607, 6, 69, -1, 0, 1554, 1555, 5, 193, 0, 0, 1555, 1607, 6, 69, -1, 0, 1556, 1557, 5, 262, 0, 0, 1557, 1607, 6, 69, -1, 0, 1558, 1559, 5, 211, 0, 0, 1559, 1607, 6, 69, -1, 0, 1560, 1561, 5, 212, 0, 0, 1561, 1607, 6, 69, -1, 0, 1562, 1563, 5, 213, 0, 0, 1563, 1607, 6, 69, -1, 0, 1564, 1565, 5, 214, 0, 0, 1565, 1607, 6, 69, -1, 0, 1566, 1567, 5, 215, 0, 0, 1567, 1607, 6, 69, -1, 0, 1568, 1569, 5, 218, 0, 0, 1569, 1607, 6, 69, -1, 0, 1570, 1571, 5, 219, 0, 0, 1571, 1607, 6, 69, -1, 0, 1572, 1573, 5, 222, 0, 0, 1573, 1607, 6, 69, -1, 0, 1574, 1575, 5, 194, 0, 0, 1575, 1607, 6, 69, -1, 0, 1576, 1577, 5, 195, 0, 0, 1577, 1607, 6, 69, -1, 0, 1578, 1579, 5, 210, 0, 0, 1579, 1607, 6, 69, -1, 0, 1580, 1581, 5, 230, 0, 0, 1581, 1607, 6, 69, -1, 0, 1582, 1583, 5, 231, 0, 0, 1583, 1607, 6, 69, -1, 0, 1584, 1585, 5, 232, 0, 0, 1585, 1607, 6, 69, -1, 0, 1586, 1587, 5, 233, 0, 0, 1587, 1607, 6, 69, -1, 0, 1588, 1589, 5, 234, 0, 0, 1589, 1607, 6, 69, -1, 0, 1590, 1591, 5, 235, 0, 0, 1591, 1607, 6, 69, -1, 0, 1592, 1593, 5, 236, 0, 0, 1593, 1607, 6, 69, -1, 0, 1594, 1595, 5, 237, 0, 0, 1595, 1607, 6, 69, -1, 0, 1596, 1597, 5, 238, 0, 0, 1597, 1607, 6, 69, -1, 0, 1598, 1599, 5, 239, 0, 0, 1599, 1607, 6, 69, -1, 0, 1600, 1601, 5, 240, 0, 0, 1601, 1607, 6, 69, -1, 0, 1602, 1603, 5, 241, 0, 0, 1603, 1607, 6, 69, -1, 0, 1604, 1605, 5, 242, 0, 0, 1605, 1607, 6, 69, -1, 0, 1606, 1526, 1, 0, 0, 0, 1606, 1528, 1, 0, 0, 0, 1606, 1530, 1, 0, 0, 0, 1606, 1532, 1, 0, 0, 0, 1606, 1534, 1, 0, 0, 0, 1606, 1536, 1, 0, 0, 0, 1606, 1538, 1, 0, 0, 0, 1606, 1540, 1, 0, 0, 0, 1606, 1542, 1, 0, 0, 0, 1606, 1544, 1, 0, 0, 0, 1606, 1546, 1, 0, 0, 0, 1606, 1548, 1, 0, 0, 0, 1606, 1550, 1, 0, 0, 0, 1606, 1552, 1, 0, 0, 0, 1606, 1554, 1, 0, 0, 0, 1606, 1556, 1, 0, 0, 0, 1606, 1558, 1, 0, 0, 0, 1606, 1560, 1, 0, 0, 0, 1606, 1562, 1, 0, 0, 0, 1606, 1564, 1, 0, 0, 0, 1606, 1566, 1, 0, 0, 0, 1606, 1568, 1, 0, 0, 0, 1606, 1570, 1, 0, 0, 0, 1606, 1572, 1, 0, 0, 0, 1606, 1574, 1, 0, 0, 0, 1606, 1576, 1, 0, 0, 0, 1606, 1578, 1, 0, 0, 0, 1606, 1580, 1, 0, 0, 0, 1606, 1582, 1, 0, 0, 0, 1606, 1584, 1, 0, 0, 0, 1606, 1586, 1, 0, 0, 0, 1606, 1588, 1, 0, 0, 0, 1606, 1590, 1, 0, 0, 0, 1606, 1592, 1, 0, 0, 0, 1606, 1594, 1, 0, 0, 0, 1606, 1596, 1, 0, 0, 0, 1606, 1598, 1, 0, 0, 0, 1606, 1600, 1, 0, 0, 0, 1606, 1602, 1, 0, 0, 0, 1606, 1604, 1, 0, 0, 0, 1607, 139, 1, 0, 0, 0, 1608, 1609, 3, 144, 72, 0, 1609, 1615, 6, 70, -1, 0, 1610, 1611, 3, 142, 71, 0, 1611, 1612, 6, 70, -1, 0, 1612, 1614, 1, 0, 0, 0, 1613, 1610, 1, 0, 0, 0, 1614, 1617, 1, 0, 0, 0, 1615, 1613, 1, 0, 0, 0, 1615, 1616, 1, 0, 0, 0, 1616, 141, 1, 0, 0, 0, 1617, 1615, 1, 0, 0, 0, 1618, 1619, 5, 261, 0, 0, 1619, 1648, 6, 71, -1, 0, 1620, 1621, 5, 42, 0, 0, 1621, 1622, 5, 43, 0, 0, 1622, 1648, 6, 71, -1, 0, 1623, 1624, 3, 112, 56, 0, 1624, 1625, 6, 71, -1, 0, 1625, 1648, 1, 0, 0, 0, 1626, 1627, 5, 260, 0, 0, 1627, 1648, 6, 71, -1, 0, 1628, 1629, 5, 262, 0, 0, 1629, 1648, 6, 71, -1, 0, 1630, 1631, 5, 92, 0, 0, 1631, 1648, 6, 71, -1, 0, 1632, 1633, 5, 93, 0, 0, 1633, 1634, 5, 30, 0, 0, 1634, 1635, 3, 126, 63, 0, 1635, 1636, 5, 31, 0, 0, 1636, 1637, 6, 71, -1, 0, 1637, 1648, 1, 0, 0, 0, 1638, 1639, 5, 94, 0, 0, 1639, 1640, 5, 30, 0, 0, 1640, 1641, 3, 126, 63, 0, 1641, 1642, 5, 31, 0, 0, 1642, 1643, 6, 71, -1, 0, 1643, 1648, 1, 0, 0, 0, 1644, 1645, 3, 110, 55, 0, 1645, 1646, 6, 71, -1, 0, 1646, 1648, 1, 0, 0, 0, 1647, 1618, 1, 0, 0, 0, 1647, 1620, 1, 0, 0, 0, 1647, 1623, 1, 0, 0, 0, 1647, 1626, 1, 0, 0, 0, 1647, 1628, 1, 0, 0, 0, 1647, 1630, 1, 0, 0, 0, 1647, 1632, 1, 0, 0, 0, 1647, 1638, 1, 0, 0, 0, 1647, 1644, 1, 0, 0, 0, 1648, 143, 1, 0, 0, 0, 1649, 1650, 5, 39, 0, 0, 1650, 1651, 3, 118, 59, 0, 1651, 1652, 6, 72, -1, 0, 1652, 1708, 1, 0, 0, 0, 1653, 1654, 5, 197, 0, 0, 1654, 1708, 6, 72, -1, 0, 1655, 1656, 5, 199, 0, 0, 1656, 1657, 5, 39, 0, 0, 1657, 1658, 3, 118, 59, 0, 1658, 1659, 6, 72, -1, 0, 1659, 1708, 1, 0, 0, 0, 1660, 1661, 5, 200, 0, 0, 1661, 1662, 3, 118, 59, 0, 1662, 1663, 6, 72, -1, 0, 1663, 1708, 1, 0, 0, 0, 1664, 1665, 5, 226, 0, 0, 1665, 1666, 3, 172, 86, 0, 1666, 1667, 3, 140, 70, 0, 1667, 1668, 5, 262, 0, 0, 1668, 1669, 3, 114, 57, 0, 1669, 1670, 6, 72, -1, 0, 1670, 1708, 1, 0, 0, 0, 1671, 1672, 5, 253, 0, 0, 1672, 1673, 3, 32, 16, 0, 1673, 1674, 6, 72, -1, 0, 1674, 1708, 1, 0, 0, 0, 1675, 1676, 5, 252, 0, 0, 1676, 1677, 3, 32, 16, 0, 1677, 1678, 6, 72, -1, 0, 1678, 1708, 1, 0, 0, 0, 1679, 1680, 5, 253, 0, 0, 1680, 1681, 3, 2, 1, 0, 1681, 1682, 6, 72, -1, 0, 1682, 1708, 1, 0, 0, 0, 1683, 1684, 5, 252, 0, 0, 1684, 1685, 3, 2, 1, 0, 1685, 1686, 6, 72, -1, 0, 1686, 1708, 1, 0, 0, 0, 1687, 1688, 5, 254, 0, 0, 1688, 1708, 6, 72, -1, 0, 1689, 1690, 5, 201, 0, 0, 1690, 1708, 6, 72, -1, 0, 1691, 1692, 3, 150, 75, 0, 1692, 1693, 6, 72, -1, 0, 1693, 1708, 1, 0, 0, 0, 1694, 1695, 3, 152, 76, 0, 1695, 1696, 6, 72, -1, 0, 1696, 1708, 1, 0, 0, 0, 1697, 1698, 3, 146, 73, 0, 1698, 1699, 6, 72, -1, 0, 1699, 1708, 1, 0, 0, 0, 1700, 1701, 3, 2, 1, 0, 1701, 1702, 6, 72, -1, 0, 1702, 1708, 1, 0, 0, 0, 1703, 1704, 5, 177, 0, 0, 1704, 1705, 3, 140, 70, 0, 1705, 1706, 6, 72, -1, 0, 1706, 1708, 1, 0, 0, 0, 1707, 1649, 1, 0, 0, 0, 1707, 1653, 1, 0, 0, 0, 1707, 1655, 1, 0, 0, 0, 1707, 1660, 1, 0, 0, 0, 1707, 1664, 1, 0, 0, 0, 1707, 1671, 1, 0, 0, 0, 1707, 1675, 1, 0, 0, 0, 1707, 1679, 1, 0, 0, 0, 1707, 1683, 1, 0, 0, 0, 1707, 1687, 1, 0, 0, 0, 1707, 1689, 1, 0, 0, 0, 1707, 1691, 1, 0, 0, 0, 1707, 1694, 1, 0, 0, 0, 1707, 1697, 1, 0, 0, 0, 1707, 1700, 1, 0, 0, 0, 1707, 1703, 1, 0, 0, 0, 1708, 145, 1, 0, 0, 0, 1709, 1710, 5, 181, 0, 0, 1710, 1748, 6, 73, -1, 0, 1711, 1712, 5, 182, 0, 0, 1712, 1748, 6, 73, -1, 0, 1713, 1714, 5, 183, 0, 0, 1714, 1748, 6, 73, -1, 0, 1715, 1716, 5, 184, 0, 0, 1716, 1748, 6, 73, -1, 0, 1717, 1718, 5, 185, 0, 0, 1718, 1748, 6, 73, -1, 0, 1719, 1720, 5, 186, 0, 0, 1720, 1748, 6, 73, -1, 0, 1721, 1722, 5, 187, 0, 0, 1722, 1748, 6, 73, -1, 0, 1723, 1724, 5, 188, 0, 0, 1724, 1748, 6, 73, -1, 0, 1725, 1726, 5, 189, 0, 0, 1726, 1748, 6, 73, -1, 0, 1727, 1728, 5, 190, 0, 0, 1728, 1748, 6, 73, -1, 0, 1729, 1730, 5, 191, 0, 0, 1730, 1748, 6, 73, -1, 0, 1731, 1732, 5, 192, 0, 0, 1732, 1748, 6, 73, -1, 0, 1733, 1734, 5, 193, 0, 0, 1734, 1748, 6, 73, -1, 0, 1735, 1736, 5, 90, 0, 0, 1736, 1737, 5, 184, 0, 0, 1737, 1748, 6, 73, -1, 0, 1738, 1739, 5, 90, 0, 0, 1739, 1740, 5, 185, 0, 0, 1740, 1748, 6, 73, -1, 0, 1741, 1742, 5, 90, 0, 0, 1742, 1743, 5, 186, 0, 0, 1743, 1748, 6, 73, -1, 0, 1744, 1745, 5, 90, 0, 0, 1745, 1746, 5, 187, 0, 0, 1746, 1748, 6, 73, -1, 0, 1747, 1709, 1, 0, 0, 0, 1747, 1711, 1, 0, 0, 0, 1747, 1713, 1, 0, 0, 0, 1747, 1715, 1, 0, 0, 0, 1747, 1717, 1, 0, 0, 0, 1747, 1719, 1, 0, 0, 0, 1747, 1721, 1, 0, 0, 0, 1747, 1723, 1, 0, 0, 0, 1747, 1725, 1, 0, 0, 0, 1747, 1727, 1, 0, 0, 0, 1747, 1729, 1, 0, 0, 0, 1747, 1731, 1, 0, 0, 0, 1747, 1733, 1, 0, 0, 0, 1747, 1735, 1, 0, 0, 0, 1747, 1738, 1, 0, 0, 0, 1747, 1741, 1, 0, 0, 0, 1747, 1744, 1, 0, 0, 0, 1748, 147, 1, 0, 0, 0, 1749, 1764, 1, 0, 0, 0, 1750, 1764, 5, 177, 0, 0, 1751, 1752, 3, 32, 16, 0, 1752, 1753, 6, 74, -1, 0, 1753, 1764, 1, 0, 0, 0, 1754, 1755, 3, 32, 16, 0, 1755, 1756, 5, 177, 0, 0, 1756, 1757, 3, 32, 16, 0, 1757, 1758, 6, 74, -1, 0, 1758, 1764, 1, 0, 0, 0, 1759, 1760, 3, 32, 16, 0, 1760, 1761, 5, 177, 0, 0, 1761, 1762, 6, 74, -1, 0, 1762, 1764, 1, 0, 0, 0, 1763, 1749, 1, 0, 0, 0, 1763, 1750, 1, 0, 0, 0, 1763, 1751, 1, 0, 0, 0, 1763, 1754, 1, 0, 0, 0, 1763, 1759, 1, 0, 0, 0, 1764, 149, 1, 0, 0, 0, 1765, 1766, 5, 1, 0, 0, 1766, 1767, 5, 194, 0, 0, 1767, 1768, 6, 75, -1, 0, 1768, 151, 1, 0, 0, 0, 1769, 1773, 5, 1, 0, 0, 1770, 1771, 5, 90, 0, 0, 1771, 1774, 5, 194, 0, 0, 1772, 1774, 5, 195, 0, 0, 1773, 1770, 1, 0, 0, 0, 1773, 1772, 1, 0, 0, 0, 1774, 1775, 1, 0, 0, 0, 1775, 1776, 6, 76, -1, 0, 1776, 153, 1, 0, 0, 0, 1777, 1778, 5, 294, 0, 0, 1778, 1779, 3, 168, 84, 0, 1779, 1780, 3, 126, 63, 0, 1780, 1781, 5, 30, 0, 0, 1781, 1782, 3, 160, 80, 0, 1782, 1783, 5, 31, 0, 0, 1783, 1784, 6, 77, -1, 0, 1784, 1832, 1, 0, 0, 0, 1785, 1786, 5, 294, 0, 0, 1786, 1787, 3, 168, 84, 0, 1787, 1788, 3, 126, 63, 0, 1788, 1789, 5, 36, 0, 0, 1789, 1790, 5, 17, 0, 0, 1790, 1791, 3, 52, 26, 0, 1791, 1792, 5, 18, 0, 0, 1792, 1793, 6, 77, -1, 0, 1793, 1832, 1, 0, 0, 0, 1794, 1795, 5, 294, 0, 0, 1795, 1796, 3, 168, 84, 0, 1796, 1797, 3, 126, 63, 0, 1797, 1798, 6, 77, -1, 0, 1798, 1832, 1, 0, 0, 0, 1799, 1800, 5, 295, 0, 0, 1800, 1801, 3, 168, 84, 0, 1801, 1803, 5, 36, 0, 0, 1802, 1804, 5, 84, 0, 0, 1803, 1802, 1, 0, 0, 0, 1803, 1804, 1, 0, 0, 0, 1804, 1805, 1, 0, 0, 0, 1805, 1806, 5, 30, 0, 0, 1806, 1807, 3, 302, 151, 0, 1807, 1808, 5, 31, 0, 0, 1808, 1809, 6, 77, -1, 0, 1809, 1832, 1, 0, 0, 0, 1810, 1811, 5, 295, 0, 0, 1811, 1812, 3, 168, 84, 0, 1812, 1813, 5, 84, 0, 0, 1813, 1814, 5, 30, 0, 0, 1814, 1815, 3, 302, 151, 0, 1815, 1816, 5, 31, 0, 0, 1816, 1817, 6, 77, -1, 0, 1817, 1832, 1, 0, 0, 0, 1818, 1819, 5, 295, 0, 0, 1819, 1820, 3, 168, 84, 0, 1820, 1821, 3, 6, 3, 0, 1821, 1822, 6, 77, -1, 0, 1822, 1832, 1, 0, 0, 0, 1823, 1824, 5, 295, 0, 0, 1824, 1825, 3, 168, 84, 0, 1825, 1826, 5, 36, 0, 0, 1826, 1827, 5, 17, 0, 0, 1827, 1828, 3, 156, 78, 0, 1828, 1829, 5, 18, 0, 0, 1829, 1830, 6, 77, -1, 0, 1830, 1832, 1, 0, 0, 0, 1831, 1777, 1, 0, 0, 0, 1831, 1785, 1, 0, 0, 0, 1831, 1794, 1, 0, 0, 0, 1831, 1799, 1, 0, 0, 0, 1831, 1810, 1, 0, 0, 0, 1831, 1818, 1, 0, 0, 0, 1831, 1823, 1, 0, 0, 0, 1832, 155, 1, 0, 0, 0, 1833, 1847, 1, 0, 0, 0, 1834, 1835, 3, 158, 79, 0, 1835, 1836, 6, 78, -1, 0, 1836, 1837, 5, 28, 0, 0, 1837, 1839, 1, 0, 0, 0, 1838, 1834, 1, 0, 0, 0, 1839, 1842, 1, 0, 0, 0, 1840, 1838, 1, 0, 0, 0, 1840, 1841, 1, 0, 0, 0, 1841, 1843, 1, 0, 0, 0, 1842, 1840, 1, 0, 0, 0, 1843, 1844, 3, 158, 79, 0, 1844, 1845, 6, 78, -1, 0, 1845, 1847, 1, 0, 0, 0, 1846, 1833, 1, 0, 0, 0, 1846, 1840, 1, 0, 0, 0, 1847, 157, 1, 0, 0, 0, 1848, 1849, 5, 39, 0, 0, 1849, 1850, 5, 264, 0, 0, 1850, 1851, 5, 36, 0, 0, 1851, 1852, 5, 17, 0, 0, 1852, 1853, 3, 56, 28, 0, 1853, 1854, 5, 18, 0, 0, 1854, 1855, 6, 79, -1, 0, 1855, 1864, 1, 0, 0, 0, 1856, 1857, 3, 126, 63, 0, 1857, 1858, 5, 36, 0, 0, 1858, 1859, 5, 17, 0, 0, 1859, 1860, 3, 56, 28, 0, 1860, 1861, 5, 18, 0, 0, 1861, 1862, 6, 79, -1, 0, 1862, 1864, 1, 0, 0, 0, 1863, 1848, 1, 0, 0, 0, 1863, 1856, 1, 0, 0, 0, 1864, 159, 1, 0, 0, 0, 1865, 1866, 3, 162, 81, 0, 1866, 1867, 6, 80, -1, 0, 1867, 1868, 5, 28, 0, 0, 1868, 1870, 1, 0, 0, 0, 1869, 1865, 1, 0, 0, 0, 1870, 1873, 1, 0, 0, 0, 1871, 1869, 1, 0, 0, 0, 1871, 1872, 1, 0, 0, 0, 1872, 1874, 1, 0, 0, 0, 1873, 1871, 1, 0, 0, 0, 1874, 1875, 3, 162, 81, 0, 1875, 1876, 6, 80, -1, 0, 1876, 161, 1, 0, 0, 0, 1877, 1878, 3, 6, 3, 0, 1878, 1879, 5, 36, 0, 0, 1879, 1880, 3, 166, 83, 0, 1880, 1881, 6, 81, -1, 0, 1881, 163, 1, 0, 0, 0, 1882, 1883, 7, 9, 0, 0, 1883, 165, 1, 0, 0, 0, 1884, 1885, 3, 164, 82, 0, 1885, 1886, 6, 83, -1, 0, 1886, 1930, 1, 0, 0, 0, 1887, 1888, 3, 32, 16, 0, 1888, 1889, 6, 83, -1, 0, 1889, 1930, 1, 0, 0, 0, 1890, 1891, 5, 186, 0, 0, 1891, 1892, 5, 30, 0, 0, 1892, 1893, 3, 32, 16, 0, 1893, 1894, 5, 31, 0, 0, 1894, 1895, 6, 83, -1, 0, 1895, 1930, 1, 0, 0, 0, 1896, 1897, 3, 6, 3, 0, 1897, 1898, 6, 83, -1, 0, 1898, 1930, 1, 0, 0, 0, 1899, 1900, 3, 118, 59, 0, 1900, 1901, 5, 30, 0, 0, 1901, 1902, 5, 184, 0, 0, 1902, 1903, 5, 75, 0, 0, 1903, 1904, 3, 32, 16, 0, 1904, 1905, 5, 31, 0, 0, 1905, 1906, 6, 83, -1, 0, 1906, 1930, 1, 0, 0, 0, 1907, 1908, 3, 118, 59, 0, 1908, 1909, 5, 30, 0, 0, 1909, 1910, 5, 185, 0, 0, 1910, 1911, 5, 75, 0, 0, 1911, 1912, 3, 32, 16, 0, 1912, 1913, 5, 31, 0, 0, 1913, 1914, 6, 83, -1, 0, 1914, 1930, 1, 0, 0, 0, 1915, 1916, 3, 118, 59, 0, 1916, 1917, 5, 30, 0, 0, 1917, 1918, 5, 186, 0, 0, 1918, 1919, 5, 75, 0, 0, 1919, 1920, 3, 32, 16, 0, 1920, 1921, 5, 31, 0, 0, 1921, 1922, 6, 83, -1, 0, 1922, 1930, 1, 0, 0, 0, 1923, 1924, 3, 118, 59, 0, 1924, 1925, 5, 30, 0, 0, 1925, 1926, 3, 32, 16, 0, 1926, 1927, 5, 31, 0, 0, 1927, 1928, 6, 83, -1, 0, 1928, 1930, 1, 0, 0, 0, 1929, 1884, 1, 0, 0, 0, 1929, 1887, 1, 0, 0, 0, 1929, 1890, 1, 0, 0, 0, 1929, 1896, 1, 0, 0, 0, 1929, 1899, 1, 0, 0, 0, 1929, 1907, 1, 0, 0, 0, 1929, 1915, 1, 0, 0, 0, 1929, 1923, 1, 0, 0, 0, 1930, 167, 1, 0, 0, 0, 1931, 1932, 7, 10, 0, 0, 1932, 169, 1, 0, 0, 0, 1933, 1934, 3, 172, 86, 0, 1934, 1935, 3, 140, 70, 0, 1935, 1936, 3, 126, 63, 0, 1936, 1937, 5, 176, 0, 0, 1937, 1939, 3, 244, 122, 0, 1938, 1940, 3, 110, 55, 0, 1939, 1938, 1, 0, 0, 0, 1939, 1940, 1, 0, 0, 0, 1940, 1941, 1, 0, 0, 0, 1941, 1942, 3, 114, 57, 0, 1942, 1943, 6, 85, -1, 0, 1943, 1976, 1, 0, 0, 0, 1944, 1945, 3, 172, 86, 0, 1945, 1946, 3, 140, 70, 0, 1946, 1947, 3, 126, 63, 0, 1947, 1948, 5, 176, 0, 0, 1948, 1949, 3, 244, 122, 0, 1949, 1950, 3, 198, 99, 0, 1950, 1951, 3, 114, 57, 0, 1951, 1952, 6, 85, -1, 0, 1952, 1976, 1, 0, 0, 0, 1953, 1954, 3, 172, 86, 0, 1954, 1955, 3, 140, 70, 0, 1955, 1957, 3, 244, 122, 0, 1956, 1958, 3, 110, 55, 0, 1957, 1956, 1, 0, 0, 0, 1957, 1958, 1, 0, 0, 0, 1958, 1959, 1, 0, 0, 0, 1959, 1960, 3, 114, 57, 0, 1960, 1961, 6, 85, -1, 0, 1961, 1976, 1, 0, 0, 0, 1962, 1963, 3, 172, 86, 0, 1963, 1964, 3, 140, 70, 0, 1964, 1965, 3, 244, 122, 0, 1965, 1966, 3, 198, 99, 0, 1966, 1967, 3, 114, 57, 0, 1967, 1968, 6, 85, -1, 0, 1968, 1976, 1, 0, 0, 0, 1969, 1970, 3, 176, 88, 0, 1970, 1971, 6, 85, -1, 0, 1971, 1976, 1, 0, 0, 0, 1972, 1973, 3, 2, 1, 0, 1973, 1974, 6, 85, -1, 0, 1974, 1976, 1, 0, 0, 0, 1975, 1933, 1, 0, 0, 0, 1975, 1944, 1, 0, 0, 0, 1975, 1953, 1, 0, 0, 0, 1975, 1962, 1, 0, 0, 0, 1975, 1969, 1, 0, 0, 0, 1975, 1972, 1, 0, 0, 0, 1976, 171, 1, 0, 0, 0, 1977, 1978, 5, 243, 0, 0, 1978, 1979, 3, 172, 86, 0, 1979, 1980, 6, 86, -1, 0, 1980, 1995, 1, 0, 0, 0, 1981, 1982, 5, 244, 0, 0, 1982, 1983, 3, 172, 86, 0, 1983, 1984, 6, 86, -1, 0, 1984, 1995, 1, 0, 0, 0, 1985, 1986, 3, 174, 87, 0, 1986, 1987, 6, 86, -1, 0, 1987, 1995, 1, 0, 0, 0, 1988, 1989, 5, 112, 0, 0, 1989, 1990, 5, 30, 0, 0, 1990, 1991, 3, 32, 16, 0, 1991, 1992, 5, 31, 0, 0, 1992, 1993, 6, 86, -1, 0, 1993, 1995, 1, 0, 0, 0, 1994, 1977, 1, 0, 0, 0, 1994, 1981, 1, 0, 0, 0, 1994, 1985, 1, 0, 0, 0, 1994, 1988, 1, 0, 0, 0, 1995, 173, 1, 0, 0, 0, 1996, 2016, 1, 0, 0, 0, 1997, 1998, 5, 245, 0, 0, 1998, 2016, 6, 87, -1, 0, 1999, 2000, 5, 246, 0, 0, 2000, 2016, 6, 87, -1, 0, 2001, 2002, 5, 247, 0, 0, 2002, 2003, 5, 248, 0, 0, 2003, 2016, 6, 87, -1, 0, 2004, 2005, 5, 247, 0, 0, 2005, 2006, 5, 249, 0, 0, 2006, 2016, 6, 87, -1, 0, 2007, 2008, 5, 247, 0, 0, 2008, 2009, 5, 250, 0, 0, 2009, 2016, 6, 87, -1, 0, 2010, 2011, 5, 247, 0, 0, 2011, 2012, 5, 251, 0, 0, 2012, 2016, 6, 87, -1, 0, 2013, 2014, 5, 247, 0, 0, 2014, 2016, 6, 87, -1, 0, 2015, 1996, 1, 0, 0, 0, 2015, 1997, 1, 0, 0, 0, 2015, 1999, 1, 0, 0, 0, 2015, 2001, 1, 0, 0, 0, 2015, 2004, 1, 0, 0, 0, 2015, 2007, 1, 0, 0, 0, 2015, 2010, 1, 0, 0, 0, 2015, 2013, 1, 0, 0, 0, 2016, 175, 1, 0, 0, 0, 2017, 2018, 5, 113, 0, 0, 2018, 2019, 5, 30, 0, 0, 2019, 2020, 3, 32, 16, 0, 2020, 2021, 5, 31, 0, 0, 2021, 2022, 6, 88, -1, 0, 2022, 177, 1, 0, 0, 0, 2023, 2024, 5, 226, 0, 0, 2024, 2025, 3, 170, 85, 0, 2025, 2026, 6, 89, -1, 0, 2026, 2035, 1, 0, 0, 0, 2027, 2028, 5, 37, 0, 0, 2028, 2029, 3, 180, 90, 0, 2029, 2030, 6, 89, -1, 0, 2030, 2035, 1, 0, 0, 0, 2031, 2032, 3, 176, 88, 0, 2032, 2033, 6, 89, -1, 0, 2033, 2035, 1, 0, 0, 0, 2034, 2023, 1, 0, 0, 0, 2034, 2027, 1, 0, 0, 0, 2034, 2031, 1, 0, 0, 0, 2035, 179, 1, 0, 0, 0, 2036, 2037, 3, 140, 70, 0, 2037, 2038, 3, 126, 63, 0, 2038, 2039, 5, 176, 0, 0, 2039, 2040, 3, 2, 1, 0, 2040, 2041, 6, 90, -1, 0, 2041, 2050, 1, 0, 0, 0, 2042, 2043, 3, 140, 70, 0, 2043, 2044, 3, 2, 1, 0, 2044, 2045, 6, 90, -1, 0, 2045, 2050, 1, 0, 0, 0, 2046, 2047, 3, 2, 1, 0, 2047, 2048, 6, 90, -1, 0, 2048, 2050, 1, 0, 0, 0, 2049, 2036, 1, 0, 0, 0, 2049, 2042, 1, 0, 0, 0, 2049, 2046, 1, 0, 0, 0, 2050, 181, 1, 0, 0, 0, 2051, 2052, 3, 126, 63, 0, 2052, 2053, 6, 91, -1, 0, 2053, 2054, 5, 28, 0, 0, 2054, 2056, 1, 0, 0, 0, 2055, 2051, 1, 0, 0, 0, 2056, 2059, 1, 0, 0, 0, 2057, 2055, 1, 0, 0, 0, 2057, 2058, 1, 0, 0, 0, 2058, 2060, 1, 0, 0, 0, 2059, 2057, 1, 0, 0, 0, 2060, 2061, 3, 126, 63, 0, 2061, 2062, 6, 91, -1, 0, 2062, 183, 1, 0, 0, 0, 2063, 2070, 1, 0, 0, 0, 2064, 2065, 5, 86, 0, 0, 2065, 2066, 3, 192, 96, 0, 2066, 2067, 5, 87, 0, 0, 2067, 2068, 6, 92, -1, 0, 2068, 2070, 1, 0, 0, 0, 2069, 2063, 1, 0, 0, 0, 2069, 2064, 1, 0, 0, 0, 2070, 185, 1, 0, 0, 0, 2071, 2072, 5, 266, 0, 0, 2072, 2090, 6, 93, -1, 0, 2073, 2074, 5, 114, 0, 0, 2074, 2090, 6, 93, -1, 0, 2075, 2076, 5, 39, 0, 0, 2076, 2090, 6, 93, -1, 0, 2077, 2078, 5, 200, 0, 0, 2078, 2090, 6, 93, -1, 0, 2079, 2080, 5, 115, 0, 0, 2080, 2090, 6, 93, -1, 0, 2081, 2082, 5, 116, 0, 0, 2082, 2090, 6, 93, -1, 0, 2083, 2084, 5, 70, 0, 0, 2084, 2085, 5, 30, 0, 0, 2085, 2086, 3, 32, 16, 0, 2086, 2087, 5, 31, 0, 0, 2087, 2088, 6, 93, -1, 0, 2088, 2090, 1, 0, 0, 0, 2089, 2071, 1, 0, 0, 0, 2089, 2073, 1, 0, 0, 0, 2089, 2075, 1, 0, 0, 0, 2089, 2077, 1, 0, 0, 0, 2089, 2079, 1, 0, 0, 0, 2089, 2081, 1, 0, 0, 0, 2089, 2083, 1, 0, 0, 0, 2090, 187, 1, 0, 0, 0, 2091, 2092, 3, 186, 93, 0, 2092, 2093, 6, 94, -1, 0, 2093, 2095, 1, 0, 0, 0, 2094, 2091, 1, 0, 0, 0, 2095, 2098, 1, 0, 0, 0, 2096, 2094, 1, 0, 0, 0, 2096, 2097, 1, 0, 0, 0, 2097, 189, 1, 0, 0, 0, 2098, 2096, 1, 0, 0, 0, 2099, 2101, 3, 188, 94, 0, 2100, 2102, 3, 194, 97, 0, 2101, 2100, 1, 0, 0, 0, 2101, 2102, 1, 0, 0, 0, 2102, 2103, 1, 0, 0, 0, 2103, 2104, 3, 2, 1, 0, 2104, 2105, 6, 95, -1, 0, 2105, 191, 1, 0, 0, 0, 2106, 2107, 3, 190, 95, 0, 2107, 2108, 6, 96, -1, 0, 2108, 2109, 5, 28, 0, 0, 2109, 2111, 1, 0, 0, 0, 2110, 2106, 1, 0, 0, 0, 2111, 2114, 1, 0, 0, 0, 2112, 2110, 1, 0, 0, 0, 2112, 2113, 1, 0, 0, 0, 2113, 2115, 1, 0, 0, 0, 2114, 2112, 1, 0, 0, 0, 2115, 2116, 3, 190, 95, 0, 2116, 2117, 6, 96, -1, 0, 2117, 193, 1, 0, 0, 0, 2118, 2119, 5, 30, 0, 0, 2119, 2120, 3, 182, 91, 0, 2120, 2121, 5, 31, 0, 0, 2121, 2122, 6, 97, -1, 0, 2122, 195, 1, 0, 0, 0, 2123, 2125, 3, 198, 99, 0, 2124, 2123, 1, 0, 0, 0, 2124, 2125, 1, 0, 0, 0, 2125, 2126, 1, 0, 0, 0, 2126, 2127, 6, 98, -1, 0, 2127, 197, 1, 0, 0, 0, 2128, 2129, 5, 86, 0, 0, 2129, 2130, 5, 42, 0, 0, 2130, 2131, 3, 32, 16, 0, 2131, 2132, 5, 43, 0, 0, 2132, 2133, 5, 87, 0, 0, 2133, 2134, 6, 99, -1, 0, 2134, 199, 1, 0, 0, 0, 2135, 2136, 3, 236, 118, 0, 2136, 2137, 5, 17, 0, 0, 2137, 2138, 3, 248, 124, 0, 2138, 2139, 5, 18, 0, 0, 2139, 2286, 1, 0, 0, 0, 2140, 2141, 3, 76, 38, 0, 2141, 2142, 5, 17, 0, 0, 2142, 2143, 3, 84, 42, 0, 2143, 2144, 5, 18, 0, 0, 2144, 2286, 1, 0, 0, 0, 2145, 2146, 3, 212, 106, 0, 2146, 2147, 6, 100, -1, 0, 2147, 2148, 5, 17, 0, 0, 2148, 2149, 3, 216, 108, 0, 2149, 2150, 5, 18, 0, 0, 2150, 2286, 1, 0, 0, 0, 2151, 2152, 3, 220, 110, 0, 2152, 2153, 6, 100, -1, 0, 2153, 2154, 5, 17, 0, 0, 2154, 2155, 3, 224, 112, 0, 2155, 2156, 5, 18, 0, 0, 2156, 2286, 1, 0, 0, 0, 2157, 2286, 3, 202, 101, 0, 2158, 2159, 3, 286, 143, 0, 2159, 2160, 6, 100, -1, 0, 2160, 2286, 1, 0, 0, 0, 2161, 2162, 3, 154, 77, 0, 2162, 2163, 6, 100, -1, 0, 2163, 2286, 1, 0, 0, 0, 2164, 2165, 3, 90, 45, 0, 2165, 2166, 6, 100, -1, 0, 2166, 2286, 1, 0, 0, 0, 2167, 2168, 3, 332, 166, 0, 2168, 2169, 6, 100, -1, 0, 2169, 2286, 1, 0, 0, 0, 2170, 2171, 5, 117, 0, 0, 2171, 2172, 3, 32, 16, 0, 2172, 2173, 6, 100, -1, 0, 2173, 2286, 1, 0, 0, 0, 2174, 2175, 5, 118, 0, 0, 2175, 2176, 3, 32, 16, 0, 2176, 2177, 6, 100, -1, 0, 2177, 2286, 1, 0, 0, 0, 2178, 2179, 3, 348, 174, 0, 2179, 2180, 5, 17, 0, 0, 2180, 2181, 3, 354, 177, 0, 2181, 2182, 5, 18, 0, 0, 2182, 2183, 6, 100, -1, 0, 2183, 2286, 1, 0, 0, 0, 2184, 2185, 5, 302, 0, 0, 2185, 2186, 3, 126, 63, 0, 2186, 2187, 5, 176, 0, 0, 2187, 2188, 3, 244, 122, 0, 2188, 2189, 5, 119, 0, 0, 2189, 2190, 3, 172, 86, 0, 2190, 2191, 3, 140, 70, 0, 2191, 2192, 3, 126, 63, 0, 2192, 2193, 5, 176, 0, 0, 2193, 2194, 3, 244, 122, 0, 2194, 2195, 3, 114, 57, 0, 2195, 2196, 6, 100, -1, 0, 2196, 2286, 1, 0, 0, 0, 2197, 2198, 5, 302, 0, 0, 2198, 2199, 5, 226, 0, 0, 2199, 2200, 3, 172, 86, 0, 2200, 2201, 3, 140, 70, 0, 2201, 2202, 3, 126, 63, 0, 2202, 2203, 5, 176, 0, 0, 2203, 2204, 3, 244, 122, 0, 2204, 2205, 3, 196, 98, 0, 2205, 2206, 3, 114, 57, 0, 2206, 2207, 5, 119, 0, 0, 2207, 2208, 5, 226, 0, 0, 2208, 2209, 3, 172, 86, 0, 2209, 2210, 3, 140, 70, 0, 2210, 2211, 3, 126, 63, 0, 2211, 2212, 5, 176, 0, 0, 2212, 2213, 3, 244, 122, 0, 2213, 2214, 3, 196, 98, 0, 2214, 2215, 3, 114, 57, 0, 2215, 2216, 6, 100, -1, 0, 2216, 2286, 1, 0, 0, 0, 2217, 2218, 3, 26, 13, 0, 2218, 2219, 6, 100, -1, 0, 2219, 2286, 1, 0, 0, 0, 2220, 2221, 3, 40, 20, 0, 2221, 2222, 6, 100, -1, 0, 2222, 2286, 1, 0, 0, 0, 2223, 2224, 5, 255, 0, 0, 2224, 2225, 5, 196, 0, 0, 2225, 2226, 5, 42, 0, 0, 2226, 2227, 3, 32, 16, 0, 2227, 2228, 5, 43, 0, 0, 2228, 2234, 6, 100, -1, 0, 2229, 2230, 3, 332, 166, 0, 2230, 2231, 6, 100, -1, 0, 2231, 2233, 1, 0, 0, 0, 2232, 2229, 1, 0, 0, 0, 2233, 2236, 1, 0, 0, 0, 2234, 2232, 1, 0, 0, 0, 2234, 2235, 1, 0, 0, 0, 2235, 2286, 1, 0, 0, 0, 2236, 2234, 1, 0, 0, 0, 2237, 2238, 5, 255, 0, 0, 2238, 2239, 5, 196, 0, 0, 2239, 2240, 3, 2, 1, 0, 2240, 2246, 6, 100, -1, 0, 2241, 2242, 3, 332, 166, 0, 2242, 2243, 6, 100, -1, 0, 2243, 2245, 1, 0, 0, 0, 2244, 2241, 1, 0, 0, 0, 2245, 2248, 1, 0, 0, 0, 2246, 2244, 1, 0, 0, 0, 2246, 2247, 1, 0, 0, 0, 2247, 2286, 1, 0, 0, 0, 2248, 2246, 1, 0, 0, 0, 2249, 2250, 5, 255, 0, 0, 2250, 2251, 5, 256, 0, 0, 2251, 2252, 5, 42, 0, 0, 2252, 2253, 3, 32, 16, 0, 2253, 2254, 5, 43, 0, 0, 2254, 2255, 5, 28, 0, 0, 2255, 2256, 3, 126, 63, 0, 2256, 2262, 6, 100, -1, 0, 2257, 2258, 3, 332, 166, 0, 2258, 2259, 6, 100, -1, 0, 2259, 2261, 1, 0, 0, 0, 2260, 2257, 1, 0, 0, 0, 2261, 2264, 1, 0, 0, 0, 2262, 2260, 1, 0, 0, 0, 2262, 2263, 1, 0, 0, 0, 2263, 2286, 1, 0, 0, 0, 2264, 2262, 1, 0, 0, 0, 2265, 2266, 5, 255, 0, 0, 2266, 2267, 5, 256, 0, 0, 2267, 2268, 3, 2, 1, 0, 2268, 2269, 5, 28, 0, 0, 2269, 2270, 3, 126, 63, 0, 2270, 2276, 6, 100, -1, 0, 2271, 2272, 3, 332, 166, 0, 2272, 2273, 6, 100, -1, 0, 2273, 2275, 1, 0, 0, 0, 2274, 2271, 1, 0, 0, 0, 2275, 2278, 1, 0, 0, 0, 2276, 2274, 1, 0, 0, 0, 2276, 2277, 1, 0, 0, 0, 2277, 2286, 1, 0, 0, 0, 2278, 2276, 1, 0, 0, 0, 2279, 2280, 5, 120, 0, 0, 2280, 2281, 5, 196, 0, 0, 2281, 2282, 3, 126, 63, 0, 2282, 2283, 3, 44, 22, 0, 2283, 2284, 6, 100, -1, 0, 2284, 2286, 1, 0, 0, 0, 2285, 2135, 1, 0, 0, 0, 2285, 2140, 1, 0, 0, 0, 2285, 2145, 1, 0, 0, 0, 2285, 2151, 1, 0, 0, 0, 2285, 2157, 1, 0, 0, 0, 2285, 2158, 1, 0, 0, 0, 2285, 2161, 1, 0, 0, 0, 2285, 2164, 1, 0, 0, 0, 2285, 2167, 1, 0, 0, 0, 2285, 2170, 1, 0, 0, 0, 2285, 2174, 1, 0, 0, 0, 2285, 2178, 1, 0, 0, 0, 2285, 2184, 1, 0, 0, 0, 2285, 2197, 1, 0, 0, 0, 2285, 2217, 1, 0, 0, 0, 2285, 2220, 1, 0, 0, 0, 2285, 2223, 1, 0, 0, 0, 2285, 2237, 1, 0, 0, 0, 2285, 2249, 1, 0, 0, 0, 2285, 2265, 1, 0, 0, 0, 2285, 2279, 1, 0, 0, 0, 2286, 201, 1, 0, 0, 0, 2287, 2288, 5, 121, 0, 0, 2288, 2300, 3, 210, 105, 0, 2289, 2290, 3, 204, 102, 0, 2290, 2291, 6, 101, -1, 0, 2291, 2299, 1, 0, 0, 0, 2292, 2293, 5, 122, 0, 0, 2293, 2294, 5, 30, 0, 0, 2294, 2295, 3, 230, 115, 0, 2295, 2296, 5, 31, 0, 0, 2296, 2297, 6, 101, -1, 0, 2297, 2299, 1, 0, 0, 0, 2298, 2289, 1, 0, 0, 0, 2298, 2292, 1, 0, 0, 0, 2299, 2302, 1, 0, 0, 0, 2300, 2298, 1, 0, 0, 0, 2300, 2301, 1, 0, 0, 0, 2301, 2303, 1, 0, 0, 0, 2302, 2300, 1, 0, 0, 0, 2303, 2304, 3, 140, 70, 0, 2304, 2305, 3, 2, 1, 0, 2305, 2306, 3, 206, 103, 0, 2306, 2307, 3, 208, 104, 0, 2307, 2308, 6, 101, -1, 0, 2308, 203, 1, 0, 0, 0, 2309, 2310, 5, 123, 0, 0, 2310, 2344, 6, 102, -1, 0, 2311, 2312, 5, 51, 0, 0, 2312, 2344, 6, 102, -1, 0, 2313, 2314, 5, 52, 0, 0, 2314, 2344, 6, 102, -1, 0, 2315, 2316, 5, 63, 0, 0, 2316, 2344, 6, 102, -1, 0, 2317, 2318, 5, 124, 0, 0, 2318, 2344, 6, 102, -1, 0, 2319, 2320, 5, 69, 0, 0, 2320, 2344, 6, 102, -1, 0, 2321, 2322, 5, 68, 0, 0, 2322, 2344, 6, 102, -1, 0, 2323, 2324, 5, 64, 0, 0, 2324, 2344, 6, 102, -1, 0, 2325, 2326, 5, 65, 0, 0, 2326, 2344, 6, 102, -1, 0, 2327, 2328, 5, 66, 0, 0, 2328, 2344, 6, 102, -1, 0, 2329, 2330, 5, 125, 0, 0, 2330, 2344, 6, 102, -1, 0, 2331, 2332, 5, 126, 0, 0, 2332, 2344, 6, 102, -1, 0, 2333, 2334, 5, 127, 0, 0, 2334, 2344, 6, 102, -1, 0, 2335, 2336, 5, 16, 0, 0, 2336, 2344, 6, 102, -1, 0, 2337, 2338, 5, 70, 0, 0, 2338, 2339, 5, 30, 0, 0, 2339, 2340, 3, 32, 16, 0, 2340, 2341, 5, 31, 0, 0, 2341, 2342, 6, 102, -1, 0, 2342, 2344, 1, 0, 0, 0, 2343, 2309, 1, 0, 0, 0, 2343, 2311, 1, 0, 0, 0, 2343, 2313, 1, 0, 0, 0, 2343, 2315, 1, 0, 0, 0, 2343, 2317, 1, 0, 0, 0, 2343, 2319, 1, 0, 0, 0, 2343, 2321, 1, 0, 0, 0, 2343, 2323, 1, 0, 0, 0, 2343, 2325, 1, 0, 0, 0, 2343, 2327, 1, 0, 0, 0, 2343, 2329, 1, 0, 0, 0, 2343, 2331, 1, 0, 0, 0, 2343, 2333, 1, 0, 0, 0, 2343, 2335, 1, 0, 0, 0, 2343, 2337, 1, 0, 0, 0, 2344, 205, 1, 0, 0, 0, 2345, 2355, 1, 0, 0, 0, 2346, 2347, 5, 44, 0, 0, 2347, 2348, 3, 0, 0, 0, 2348, 2349, 6, 103, -1, 0, 2349, 2355, 1, 0, 0, 0, 2350, 2351, 5, 44, 0, 0, 2351, 2352, 3, 32, 16, 0, 2352, 2353, 6, 103, -1, 0, 2353, 2355, 1, 0, 0, 0, 2354, 2345, 1, 0, 0, 0, 2354, 2346, 1, 0, 0, 0, 2354, 2350, 1, 0, 0, 0, 2355, 207, 1, 0, 0, 0, 2356, 2362, 1, 0, 0, 0, 2357, 2358, 5, 36, 0, 0, 2358, 2359, 3, 306, 153, 0, 2359, 2360, 6, 104, -1, 0, 2360, 2362, 1, 0, 0, 0, 2361, 2356, 1, 0, 0, 0, 2361, 2357, 1, 0, 0, 0, 2362, 209, 1, 0, 0, 0, 2363, 2370, 1, 0, 0, 0, 2364, 2365, 5, 42, 0, 0, 2365, 2366, 3, 32, 16, 0, 2366, 2367, 5, 43, 0, 0, 2367, 2368, 6, 105, -1, 0, 2368, 2370, 1, 0, 0, 0, 2369, 2363, 1, 0, 0, 0, 2369, 2364, 1, 0, 0, 0, 2370, 211, 1, 0, 0, 0, 2371, 2377, 5, 128, 0, 0, 2372, 2373, 3, 214, 107, 0, 2373, 2374, 6, 106, -1, 0, 2374, 2376, 1, 0, 0, 0, 2375, 2372, 1, 0, 0, 0, 2376, 2379, 1, 0, 0, 0, 2377, 2375, 1, 0, 0, 0, 2377, 2378, 1, 0, 0, 0, 2378, 2380, 1, 0, 0, 0, 2379, 2377, 1, 0, 0, 0, 2380, 2381, 3, 126, 63, 0, 2381, 2382, 3, 2, 1, 0, 2382, 2383, 6, 106, -1, 0, 2383, 2397, 1, 0, 0, 0, 2384, 2390, 5, 128, 0, 0, 2385, 2386, 3, 214, 107, 0, 2386, 2387, 6, 106, -1, 0, 2387, 2389, 1, 0, 0, 0, 2388, 2385, 1, 0, 0, 0, 2389, 2392, 1, 0, 0, 0, 2390, 2388, 1, 0, 0, 0, 2390, 2391, 1, 0, 0, 0, 2391, 2393, 1, 0, 0, 0, 2392, 2390, 1, 0, 0, 0, 2393, 2394, 3, 2, 1, 0, 2394, 2395, 6, 106, -1, 0, 2395, 2397, 1, 0, 0, 0, 2396, 2371, 1, 0, 0, 0, 2396, 2384, 1, 0, 0, 0, 2397, 213, 1, 0, 0, 0, 2398, 2399, 5, 69, 0, 0, 2399, 2403, 6, 107, -1, 0, 2400, 2401, 5, 68, 0, 0, 2401, 2403, 6, 107, -1, 0, 2402, 2398, 1, 0, 0, 0, 2402, 2400, 1, 0, 0, 0, 2403, 215, 1, 0, 0, 0, 2404, 2406, 3, 218, 109, 0, 2405, 2404, 1, 0, 0, 0, 2406, 2409, 1, 0, 0, 0, 2407, 2405, 1, 0, 0, 0, 2407, 2408, 1, 0, 0, 0, 2408, 217, 1, 0, 0, 0, 2409, 2407, 1, 0, 0, 0, 2410, 2411, 5, 129, 0, 0, 2411, 2412, 3, 170, 85, 0, 2412, 2413, 6, 109, -1, 0, 2413, 2437, 1, 0, 0, 0, 2414, 2415, 5, 130, 0, 0, 2415, 2416, 3, 170, 85, 0, 2416, 2417, 6, 109, -1, 0, 2417, 2437, 1, 0, 0, 0, 2418, 2419, 5, 131, 0, 0, 2419, 2420, 3, 170, 85, 0, 2420, 2421, 6, 109, -1, 0, 2421, 2437, 1, 0, 0, 0, 2422, 2423, 5, 132, 0, 0, 2423, 2424, 3, 170, 85, 0, 2424, 2425, 6, 109, -1, 0, 2425, 2437, 1, 0, 0, 0, 2426, 2427, 3, 90, 45, 0, 2427, 2428, 6, 109, -1, 0, 2428, 2437, 1, 0, 0, 0, 2429, 2430, 3, 332, 166, 0, 2430, 2431, 6, 109, -1, 0, 2431, 2437, 1, 0, 0, 0, 2432, 2433, 3, 26, 13, 0, 2433, 2434, 6, 109, -1, 0, 2434, 2437, 1, 0, 0, 0, 2435, 2437, 3, 40, 20, 0, 2436, 2410, 1, 0, 0, 0, 2436, 2414, 1, 0, 0, 0, 2436, 2418, 1, 0, 0, 0, 2436, 2422, 1, 0, 0, 0, 2436, 2426, 1, 0, 0, 0, 2436, 2429, 1, 0, 0, 0, 2436, 2432, 1, 0, 0, 0, 2436, 2435, 1, 0, 0, 0, 2437, 219, 1, 0, 0, 0, 2438, 2444, 5, 133, 0, 0, 2439, 2440, 3, 222, 111, 0, 2440, 2441, 6, 110, -1, 0, 2441, 2443, 1, 0, 0, 0, 2442, 2439, 1, 0, 0, 0, 2443, 2446, 1, 0, 0, 0, 2444, 2442, 1, 0, 0, 0, 2444, 2445, 1, 0, 0, 0, 2445, 2447, 1, 0, 0, 0, 2446, 2444, 1, 0, 0, 0, 2447, 2448, 3, 172, 86, 0, 2448, 2449, 3, 140, 70, 0, 2449, 2450, 3, 2, 1, 0, 2450, 2451, 3, 114, 57, 0, 2451, 2452, 3, 208, 104, 0, 2452, 2453, 6, 110, -1, 0, 2453, 221, 1, 0, 0, 0, 2454, 2455, 5, 69, 0, 0, 2455, 2459, 6, 111, -1, 0, 2456, 2457, 5, 68, 0, 0, 2457, 2459, 6, 111, -1, 0, 2458, 2454, 1, 0, 0, 0, 2458, 2456, 1, 0, 0, 0, 2459, 223, 1, 0, 0, 0, 2460, 2462, 3, 226, 113, 0, 2461, 2460, 1, 0, 0, 0, 2462, 2465, 1, 0, 0, 0, 2463, 2461, 1, 0, 0, 0, 2463, 2464, 1, 0, 0, 0, 2464, 225, 1, 0, 0, 0, 2465, 2463, 1, 0, 0, 0, 2466, 2467, 5, 134, 0, 0, 2467, 2468, 3, 170, 85, 0, 2468, 2469, 6, 113, -1, 0, 2469, 2489, 1, 0, 0, 0, 2470, 2471, 5, 135, 0, 0, 2471, 2472, 3, 170, 85, 0, 2472, 2473, 6, 113, -1, 0, 2473, 2489, 1, 0, 0, 0, 2474, 2475, 5, 132, 0, 0, 2475, 2476, 3, 170, 85, 0, 2476, 2477, 6, 113, -1, 0, 2477, 2489, 1, 0, 0, 0, 2478, 2479, 3, 332, 166, 0, 2479, 2480, 6, 113, -1, 0, 2480, 2489, 1, 0, 0, 0, 2481, 2482, 3, 90, 45, 0, 2482, 2483, 6, 113, -1, 0, 2483, 2489, 1, 0, 0, 0, 2484, 2485, 3, 26, 13, 0, 2485, 2486, 6, 113, -1, 0, 2486, 2489, 1, 0, 0, 0, 2487, 2489, 3, 40, 20, 0, 2488, 2466, 1, 0, 0, 0, 2488, 2470, 1, 0, 0, 0, 2488, 2474, 1, 0, 0, 0, 2488, 2478, 1, 0, 0, 0, 2488, 2481, 1, 0, 0, 0, 2488, 2484, 1, 0, 0, 0, 2488, 2487, 1, 0, 0, 0, 2489, 227, 1, 0, 0, 0, 2490, 2498, 6, 114, -1, 0, 2491, 2492, 5, 122, 0, 0, 2492, 2493, 5, 30, 0, 0, 2493, 2494, 3, 230, 115, 0, 2494, 2495, 5, 31, 0, 0, 2495, 2496, 6, 114, -1, 0, 2496, 2498, 1, 0, 0, 0, 2497, 2490, 1, 0, 0, 0, 2497, 2491, 1, 0, 0, 0, 2498, 229, 1, 0, 0, 0, 2499, 2500, 3, 128, 64, 0, 2500, 2501, 6, 115, -1, 0, 2501, 2513, 1, 0, 0, 0, 2502, 2506, 5, 17, 0, 0, 2503, 2504, 3, 304, 152, 0, 2504, 2505, 6, 115, -1, 0, 2505, 2507, 1, 0, 0, 0, 2506, 2503, 1, 0, 0, 0, 2507, 2508, 1, 0, 0, 0, 2508, 2506, 1, 0, 0, 0, 2508, 2509, 1, 0, 0, 0, 2509, 2510, 1, 0, 0, 0, 2510, 2511, 5, 18, 0, 0, 2511, 2513, 1, 0, 0, 0, 2512, 2499, 1, 0, 0, 0, 2512, 2502, 1, 0, 0, 0, 2513, 231, 1, 0, 0, 0, 2514, 2515, 3, 234, 117, 0, 2515, 2516, 6, 116, -1, 0, 2516, 2518, 1, 0, 0, 0, 2517, 2514, 1, 0, 0, 0, 2518, 2521, 1, 0, 0, 0, 2519, 2517, 1, 0, 0, 0, 2519, 2520, 1, 0, 0, 0, 2520, 233, 1, 0, 0, 0, 2521, 2519, 1, 0, 0, 0, 2522, 2523, 5, 42, 0, 0, 2523, 2524, 5, 136, 0, 0, 2524, 2525, 5, 43, 0, 0, 2525, 2540, 6, 117, -1, 0, 2526, 2527, 5, 42, 0, 0, 2527, 2528, 5, 137, 0, 0, 2528, 2529, 5, 43, 0, 0, 2529, 2540, 6, 117, -1, 0, 2530, 2531, 5, 42, 0, 0, 2531, 2532, 5, 138, 0, 0, 2532, 2533, 5, 43, 0, 0, 2533, 2540, 6, 117, -1, 0, 2534, 2535, 5, 42, 0, 0, 2535, 2536, 3, 32, 16, 0, 2536, 2537, 5, 43, 0, 0, 2537, 2538, 6, 117, -1, 0, 2538, 2540, 1, 0, 0, 0, 2539, 2522, 1, 0, 0, 0, 2539, 2526, 1, 0, 0, 0, 2539, 2530, 1, 0, 0, 0, 2539, 2534, 1, 0, 0, 0, 2540, 235, 1, 0, 0, 0, 2541, 2550, 5, 139, 0, 0, 2542, 2543, 3, 238, 119, 0, 2543, 2544, 6, 118, -1, 0, 2544, 2549, 1, 0, 0, 0, 2545, 2546, 3, 240, 120, 0, 2546, 2547, 6, 118, -1, 0, 2547, 2549, 1, 0, 0, 0, 2548, 2542, 1, 0, 0, 0, 2548, 2545, 1, 0, 0, 0, 2549, 2552, 1, 0, 0, 0, 2550, 2548, 1, 0, 0, 0, 2550, 2551, 1, 0, 0, 0, 2551, 2553, 1, 0, 0, 0, 2552, 2550, 1, 0, 0, 0, 2553, 2554, 3, 172, 86, 0, 2554, 2555, 3, 232, 116, 0, 2555, 2556, 3, 140, 70, 0, 2556, 2557, 3, 228, 114, 0, 2557, 2558, 3, 244, 122, 0, 2558, 2559, 3, 184, 92, 0, 2559, 2565, 3, 114, 57, 0, 2560, 2561, 3, 246, 123, 0, 2561, 2562, 6, 118, -1, 0, 2562, 2564, 1, 0, 0, 0, 2563, 2560, 1, 0, 0, 0, 2564, 2567, 1, 0, 0, 0, 2565, 2563, 1, 0, 0, 0, 2565, 2566, 1, 0, 0, 0, 2566, 2568, 1, 0, 0, 0, 2567, 2565, 1, 0, 0, 0, 2568, 2569, 6, 118, -1, 0, 2569, 237, 1, 0, 0, 0, 2570, 2571, 5, 123, 0, 0, 2571, 2613, 6, 119, -1, 0, 2572, 2573, 5, 51, 0, 0, 2573, 2613, 6, 119, -1, 0, 2574, 2575, 5, 52, 0, 0, 2575, 2613, 6, 119, -1, 0, 2576, 2577, 5, 63, 0, 0, 2577, 2613, 6, 119, -1, 0, 2578, 2579, 5, 140, 0, 0, 2579, 2613, 6, 119, -1, 0, 2580, 2581, 5, 68, 0, 0, 2581, 2613, 6, 119, -1, 0, 2582, 2583, 5, 141, 0, 0, 2583, 2613, 6, 119, -1, 0, 2584, 2585, 5, 142, 0, 0, 2585, 2613, 6, 119, -1, 0, 2586, 2587, 5, 54, 0, 0, 2587, 2613, 6, 119, -1, 0, 2588, 2589, 5, 64, 0, 0, 2589, 2613, 6, 119, -1, 0, 2590, 2591, 5, 65, 0, 0, 2591, 2613, 6, 119, -1, 0, 2592, 2593, 5, 66, 0, 0, 2593, 2613, 6, 119, -1, 0, 2594, 2595, 5, 125, 0, 0, 2595, 2613, 6, 119, -1, 0, 2596, 2597, 5, 143, 0, 0, 2597, 2613, 6, 119, -1, 0, 2598, 2599, 5, 144, 0, 0, 2599, 2613, 6, 119, -1, 0, 2600, 2601, 5, 69, 0, 0, 2601, 2613, 6, 119, -1, 0, 2602, 2603, 5, 145, 0, 0, 2603, 2613, 6, 119, -1, 0, 2604, 2605, 5, 146, 0, 0, 2605, 2613, 6, 119, -1, 0, 2606, 2607, 5, 70, 0, 0, 2607, 2608, 5, 30, 0, 0, 2608, 2609, 3, 32, 16, 0, 2609, 2610, 5, 31, 0, 0, 2610, 2611, 6, 119, -1, 0, 2611, 2613, 1, 0, 0, 0, 2612, 2570, 1, 0, 0, 0, 2612, 2572, 1, 0, 0, 0, 2612, 2574, 1, 0, 0, 0, 2612, 2576, 1, 0, 0, 0, 2612, 2578, 1, 0, 0, 0, 2612, 2580, 1, 0, 0, 0, 2612, 2582, 1, 0, 0, 0, 2612, 2584, 1, 0, 0, 0, 2612, 2586, 1, 0, 0, 0, 2612, 2588, 1, 0, 0, 0, 2612, 2590, 1, 0, 0, 0, 2612, 2592, 1, 0, 0, 0, 2612, 2594, 1, 0, 0, 0, 2612, 2596, 1, 0, 0, 0, 2612, 2598, 1, 0, 0, 0, 2612, 2600, 1, 0, 0, 0, 2612, 2602, 1, 0, 0, 0, 2612, 2604, 1, 0, 0, 0, 2612, 2606, 1, 0, 0, 0, 2613, 239, 1, 0, 0, 0, 2614, 2615, 5, 147, 0, 0, 2615, 2624, 5, 30, 0, 0, 2616, 2617, 3, 6, 3, 0, 2617, 2622, 6, 120, -1, 0, 2618, 2619, 5, 34, 0, 0, 2619, 2620, 3, 6, 3, 0, 2620, 2621, 6, 120, -1, 0, 2621, 2623, 1, 0, 0, 0, 2622, 2618, 1, 0, 0, 0, 2622, 2623, 1, 0, 0, 0, 2623, 2625, 1, 0, 0, 0, 2624, 2616, 1, 0, 0, 0, 2624, 2625, 1, 0, 0, 0, 2625, 2631, 1, 0, 0, 0, 2626, 2627, 3, 242, 121, 0, 2627, 2628, 6, 120, -1, 0, 2628, 2630, 1, 0, 0, 0, 2629, 2626, 1, 0, 0, 0, 2630, 2633, 1, 0, 0, 0, 2631, 2629, 1, 0, 0, 0, 2631, 2632, 1, 0, 0, 0, 2632, 2634, 1, 0, 0, 0, 2633, 2631, 1, 0, 0, 0, 2634, 2638, 5, 31, 0, 0, 2635, 2636, 5, 147, 0, 0, 2636, 2638, 5, 85, 0, 0, 2637, 2614, 1, 0, 0, 0, 2637, 2635, 1, 0, 0, 0, 2638, 241, 1, 0, 0, 0, 2639, 2640, 5, 148, 0, 0, 2640, 2682, 6, 121, -1, 0, 2641, 2642, 5, 224, 0, 0, 2642, 2682, 6, 121, -1, 0, 2643, 2644, 5, 57, 0, 0, 2644, 2682, 6, 121, -1, 0, 2645, 2646, 5, 58, 0, 0, 2646, 2682, 6, 121, -1, 0, 2647, 2648, 5, 149, 0, 0, 2648, 2682, 6, 121, -1, 0, 2649, 2650, 5, 150, 0, 0, 2650, 2682, 6, 121, -1, 0, 2651, 2652, 5, 248, 0, 0, 2652, 2682, 6, 121, -1, 0, 2653, 2654, 5, 249, 0, 0, 2654, 2682, 6, 121, -1, 0, 2655, 2656, 5, 250, 0, 0, 2656, 2682, 6, 121, -1, 0, 2657, 2658, 5, 251, 0, 0, 2658, 2682, 6, 121, -1, 0, 2659, 2660, 5, 151, 0, 0, 2660, 2661, 5, 75, 0, 0, 2661, 2662, 5, 152, 0, 0, 2662, 2682, 6, 121, -1, 0, 2663, 2664, 5, 151, 0, 0, 2664, 2665, 5, 75, 0, 0, 2665, 2666, 5, 153, 0, 0, 2666, 2682, 6, 121, -1, 0, 2667, 2668, 5, 154, 0, 0, 2668, 2669, 5, 75, 0, 0, 2669, 2670, 5, 152, 0, 0, 2670, 2682, 6, 121, -1, 0, 2671, 2672, 5, 154, 0, 0, 2672, 2673, 5, 75, 0, 0, 2673, 2674, 5, 153, 0, 0, 2674, 2682, 6, 121, -1, 0, 2675, 2676, 5, 70, 0, 0, 2676, 2677, 5, 30, 0, 0, 2677, 2678, 3, 32, 16, 0, 2678, 2679, 5, 31, 0, 0, 2679, 2680, 6, 121, -1, 0, 2680, 2682, 1, 0, 0, 0, 2681, 2639, 1, 0, 0, 0, 2681, 2641, 1, 0, 0, 0, 2681, 2643, 1, 0, 0, 0, 2681, 2645, 1, 0, 0, 0, 2681, 2647, 1, 0, 0, 0, 2681, 2649, 1, 0, 0, 0, 2681, 2651, 1, 0, 0, 0, 2681, 2653, 1, 0, 0, 0, 2681, 2655, 1, 0, 0, 0, 2681, 2657, 1, 0, 0, 0, 2681, 2659, 1, 0, 0, 0, 2681, 2663, 1, 0, 0, 0, 2681, 2667, 1, 0, 0, 0, 2681, 2671, 1, 0, 0, 0, 2681, 2675, 1, 0, 0, 0, 2682, 243, 1, 0, 0, 0, 2683, 2684, 5, 116, 0, 0, 2684, 2691, 6, 122, -1, 0, 2685, 2686, 5, 155, 0, 0, 2686, 2691, 6, 122, -1, 0, 2687, 2688, 3, 2, 1, 0, 2688, 2689, 6, 122, -1, 0, 2689, 2691, 1, 0, 0, 0, 2690, 2683, 1, 0, 0, 0, 2690, 2685, 1, 0, 0, 0, 2690, 2687, 1, 0, 0, 0, 2691, 245, 1, 0, 0, 0, 2692, 2693, 5, 1, 0, 0, 2693, 2731, 6, 123, -1, 0, 2694, 2695, 5, 2, 0, 0, 2695, 2731, 6, 123, -1, 0, 2696, 2697, 5, 156, 0, 0, 2697, 2731, 6, 123, -1, 0, 2698, 2699, 5, 3, 0, 0, 2699, 2731, 6, 123, -1, 0, 2700, 2701, 5, 4, 0, 0, 2701, 2731, 6, 123, -1, 0, 2702, 2703, 5, 247, 0, 0, 2703, 2731, 6, 123, -1, 0, 2704, 2705, 5, 5, 0, 0, 2705, 2731, 6, 123, -1, 0, 2706, 2707, 5, 6, 0, 0, 2707, 2731, 6, 123, -1, 0, 2708, 2709, 5, 7, 0, 0, 2709, 2731, 6, 123, -1, 0, 2710, 2711, 5, 8, 0, 0, 2711, 2731, 6, 123, -1, 0, 2712, 2713, 5, 9, 0, 0, 2713, 2731, 6, 123, -1, 0, 2714, 2715, 5, 10, 0, 0, 2715, 2731, 6, 123, -1, 0, 2716, 2717, 5, 11, 0, 0, 2717, 2731, 6, 123, -1, 0, 2718, 2719, 5, 12, 0, 0, 2719, 2731, 6, 123, -1, 0, 2720, 2721, 5, 13, 0, 0, 2721, 2731, 6, 123, -1, 0, 2722, 2723, 5, 14, 0, 0, 2723, 2731, 6, 123, -1, 0, 2724, 2725, 5, 70, 0, 0, 2725, 2726, 5, 30, 0, 0, 2726, 2727, 3, 32, 16, 0, 2727, 2728, 5, 31, 0, 0, 2728, 2729, 6, 123, -1, 0, 2729, 2731, 1, 0, 0, 0, 2730, 2692, 1, 0, 0, 0, 2730, 2694, 1, 0, 0, 0, 2730, 2696, 1, 0, 0, 0, 2730, 2698, 1, 0, 0, 0, 2730, 2700, 1, 0, 0, 0, 2730, 2702, 1, 0, 0, 0, 2730, 2704, 1, 0, 0, 0, 2730, 2706, 1, 0, 0, 0, 2730, 2708, 1, 0, 0, 0, 2730, 2710, 1, 0, 0, 0, 2730, 2712, 1, 0, 0, 0, 2730, 2714, 1, 0, 0, 0, 2730, 2716, 1, 0, 0, 0, 2730, 2718, 1, 0, 0, 0, 2730, 2720, 1, 0, 0, 0, 2730, 2722, 1, 0, 0, 0, 2730, 2724, 1, 0, 0, 0, 2731, 247, 1, 0, 0, 0, 2732, 2734, 3, 250, 125, 0, 2733, 2732, 1, 0, 0, 0, 2734, 2737, 1, 0, 0, 0, 2735, 2733, 1, 0, 0, 0, 2735, 2736, 1, 0, 0, 0, 2736, 249, 1, 0, 0, 0, 2737, 2735, 1, 0, 0, 0, 2738, 2776, 3, 102, 51, 0, 2739, 2740, 5, 296, 0, 0, 2740, 2741, 3, 32, 16, 0, 2741, 2742, 6, 125, -1, 0, 2742, 2776, 1, 0, 0, 0, 2743, 2776, 3, 268, 134, 0, 2744, 2745, 5, 297, 0, 0, 2745, 2746, 3, 32, 16, 0, 2746, 2747, 6, 125, -1, 0, 2747, 2776, 1, 0, 0, 0, 2748, 2749, 5, 298, 0, 0, 2749, 2776, 6, 125, -1, 0, 2750, 2751, 5, 299, 0, 0, 2751, 2776, 6, 125, -1, 0, 2752, 2776, 3, 262, 131, 0, 2753, 2776, 3, 266, 133, 0, 2754, 2776, 3, 252, 126, 0, 2755, 2756, 3, 286, 143, 0, 2756, 2757, 6, 125, -1, 0, 2757, 2776, 1, 0, 0, 0, 2758, 2759, 3, 154, 77, 0, 2759, 2760, 6, 125, -1, 0, 2760, 2776, 1, 0, 0, 0, 2761, 2762, 3, 90, 45, 0, 2762, 2763, 6, 125, -1, 0, 2763, 2776, 1, 0, 0, 0, 2764, 2765, 3, 26, 13, 0, 2765, 2766, 6, 125, -1, 0, 2766, 2776, 1, 0, 0, 0, 2767, 2768, 3, 264, 132, 0, 2768, 2769, 6, 125, -1, 0, 2769, 2776, 1, 0, 0, 0, 2770, 2776, 3, 40, 20, 0, 2771, 2776, 3, 254, 127, 0, 2772, 2776, 3, 256, 128, 0, 2773, 2776, 3, 258, 129, 0, 2774, 2776, 3, 260, 130, 0, 2775, 2738, 1, 0, 0, 0, 2775, 2739, 1, 0, 0, 0, 2775, 2743, 1, 0, 0, 0, 2775, 2744, 1, 0, 0, 0, 2775, 2748, 1, 0, 0, 0, 2775, 2750, 1, 0, 0, 0, 2775, 2752, 1, 0, 0, 0, 2775, 2753, 1, 0, 0, 0, 2775, 2754, 1, 0, 0, 0, 2775, 2755, 1, 0, 0, 0, 2775, 2758, 1, 0, 0, 0, 2775, 2761, 1, 0, 0, 0, 2775, 2764, 1, 0, 0, 0, 2775, 2767, 1, 0, 0, 0, 2775, 2770, 1, 0, 0, 0, 2775, 2771, 1, 0, 0, 0, 2775, 2772, 1, 0, 0, 0, 2775, 2773, 1, 0, 0, 0, 2775, 2774, 1, 0, 0, 0, 2776, 251, 1, 0, 0, 0, 2777, 2779, 5, 300, 0, 0, 2778, 2780, 5, 157, 0, 0, 2779, 2778, 1, 0, 0, 0, 2779, 2780, 1, 0, 0, 0, 2780, 2781, 1, 0, 0, 0, 2781, 2782, 3, 114, 57, 0, 2782, 253, 1, 0, 0, 0, 2783, 2784, 5, 301, 0, 0, 2784, 2785, 5, 42, 0, 0, 2785, 2786, 3, 32, 16, 0, 2786, 2789, 5, 43, 0, 0, 2787, 2788, 5, 34, 0, 0, 2788, 2790, 3, 0, 0, 0, 2789, 2787, 1, 0, 0, 0, 2789, 2790, 1, 0, 0, 0, 2790, 255, 1, 0, 0, 0, 2791, 2792, 5, 303, 0, 0, 2792, 2793, 3, 32, 16, 0, 2793, 2794, 5, 75, 0, 0, 2794, 2795, 3, 32, 16, 0, 2795, 257, 1, 0, 0, 0, 2796, 2797, 5, 302, 0, 0, 2797, 2798, 3, 126, 63, 0, 2798, 2799, 5, 176, 0, 0, 2799, 2800, 3, 244, 122, 0, 2800, 2812, 1, 0, 0, 0, 2801, 2802, 5, 302, 0, 0, 2802, 2803, 5, 226, 0, 0, 2803, 2804, 3, 172, 86, 0, 2804, 2805, 3, 140, 70, 0, 2805, 2806, 3, 126, 63, 0, 2806, 2807, 5, 176, 0, 0, 2807, 2808, 3, 244, 122, 0, 2808, 2809, 3, 196, 98, 0, 2809, 2810, 3, 114, 57, 0, 2810, 2812, 1, 0, 0, 0, 2811, 2796, 1, 0, 0, 0, 2811, 2801, 1, 0, 0, 0, 2812, 259, 1, 0, 0, 0, 2813, 2814, 5, 255, 0, 0, 2814, 2815, 5, 196, 0, 0, 2815, 2816, 5, 42, 0, 0, 2816, 2817, 3, 32, 16, 0, 2817, 2823, 5, 43, 0, 0, 2818, 2819, 3, 332, 166, 0, 2819, 2820, 6, 130, -1, 0, 2820, 2822, 1, 0, 0, 0, 2821, 2818, 1, 0, 0, 0, 2822, 2825, 1, 0, 0, 0, 2823, 2821, 1, 0, 0, 0, 2823, 2824, 1, 0, 0, 0, 2824, 2879, 1, 0, 0, 0, 2825, 2823, 1, 0, 0, 0, 2826, 2827, 5, 255, 0, 0, 2827, 2828, 5, 196, 0, 0, 2828, 2834, 3, 2, 1, 0, 2829, 2830, 3, 332, 166, 0, 2830, 2831, 6, 130, -1, 0, 2831, 2833, 1, 0, 0, 0, 2832, 2829, 1, 0, 0, 0, 2833, 2836, 1, 0, 0, 0, 2834, 2832, 1, 0, 0, 0, 2834, 2835, 1, 0, 0, 0, 2835, 2879, 1, 0, 0, 0, 2836, 2834, 1, 0, 0, 0, 2837, 2838, 5, 255, 0, 0, 2838, 2839, 5, 256, 0, 0, 2839, 2840, 5, 42, 0, 0, 2840, 2841, 3, 32, 16, 0, 2841, 2842, 5, 43, 0, 0, 2842, 2843, 5, 28, 0, 0, 2843, 2849, 3, 126, 63, 0, 2844, 2845, 3, 332, 166, 0, 2845, 2846, 6, 130, -1, 0, 2846, 2848, 1, 0, 0, 0, 2847, 2844, 1, 0, 0, 0, 2848, 2851, 1, 0, 0, 0, 2849, 2847, 1, 0, 0, 0, 2849, 2850, 1, 0, 0, 0, 2850, 2879, 1, 0, 0, 0, 2851, 2849, 1, 0, 0, 0, 2852, 2853, 5, 255, 0, 0, 2853, 2854, 5, 256, 0, 0, 2854, 2855, 3, 2, 1, 0, 2855, 2856, 5, 28, 0, 0, 2856, 2862, 3, 126, 63, 0, 2857, 2858, 3, 332, 166, 0, 2858, 2859, 6, 130, -1, 0, 2859, 2861, 1, 0, 0, 0, 2860, 2857, 1, 0, 0, 0, 2861, 2864, 1, 0, 0, 0, 2862, 2860, 1, 0, 0, 0, 2862, 2863, 1, 0, 0, 0, 2863, 2879, 1, 0, 0, 0, 2864, 2862, 1, 0, 0, 0, 2865, 2866, 5, 255, 0, 0, 2866, 2867, 5, 42, 0, 0, 2867, 2868, 3, 32, 16, 0, 2868, 2869, 5, 43, 0, 0, 2869, 2875, 3, 208, 104, 0, 2870, 2871, 3, 332, 166, 0, 2871, 2872, 6, 130, -1, 0, 2872, 2874, 1, 0, 0, 0, 2873, 2870, 1, 0, 0, 0, 2874, 2877, 1, 0, 0, 0, 2875, 2873, 1, 0, 0, 0, 2875, 2876, 1, 0, 0, 0, 2876, 2879, 1, 0, 0, 0, 2877, 2875, 1, 0, 0, 0, 2878, 2813, 1, 0, 0, 0, 2878, 2826, 1, 0, 0, 0, 2878, 2837, 1, 0, 0, 0, 2878, 2852, 1, 0, 0, 0, 2878, 2865, 1, 0, 0, 0, 2879, 261, 1, 0, 0, 0, 2880, 2881, 3, 0, 0, 0, 2881, 2882, 5, 75, 0, 0, 2882, 2883, 6, 131, -1, 0, 2883, 263, 1, 0, 0, 0, 2884, 2885, 3, 44, 22, 0, 2885, 2886, 6, 132, -1, 0, 2886, 2891, 1, 0, 0, 0, 2887, 2888, 3, 46, 23, 0, 2888, 2889, 6, 132, -1, 0, 2889, 2891, 1, 0, 0, 0, 2890, 2884, 1, 0, 0, 0, 2890, 2887, 1, 0, 0, 0, 2891, 265, 1, 0, 0, 0, 2892, 2893, 5, 17, 0, 0, 2893, 2894, 3, 248, 124, 0, 2894, 2895, 5, 18, 0, 0, 2895, 267, 1, 0, 0, 0, 2896, 2897, 3, 272, 136, 0, 2897, 2898, 3, 270, 135, 0, 2898, 269, 1, 0, 0, 0, 2899, 2900, 3, 274, 137, 0, 2900, 2901, 6, 135, -1, 0, 2901, 2903, 1, 0, 0, 0, 2902, 2899, 1, 0, 0, 0, 2903, 2904, 1, 0, 0, 0, 2904, 2902, 1, 0, 0, 0, 2904, 2905, 1, 0, 0, 0, 2905, 271, 1, 0, 0, 0, 2906, 2907, 5, 158, 0, 0, 2907, 2908, 3, 266, 133, 0, 2908, 2909, 6, 136, -1, 0, 2909, 2923, 1, 0, 0, 0, 2910, 2911, 5, 158, 0, 0, 2911, 2912, 3, 0, 0, 0, 2912, 2913, 5, 159, 0, 0, 2913, 2914, 3, 0, 0, 0, 2914, 2915, 6, 136, -1, 0, 2915, 2923, 1, 0, 0, 0, 2916, 2917, 5, 158, 0, 0, 2917, 2918, 3, 32, 16, 0, 2918, 2919, 5, 159, 0, 0, 2919, 2920, 3, 32, 16, 0, 2920, 2921, 6, 136, -1, 0, 2921, 2923, 1, 0, 0, 0, 2922, 2906, 1, 0, 0, 0, 2922, 2910, 1, 0, 0, 0, 2922, 2916, 1, 0, 0, 0, 2923, 273, 1, 0, 0, 0, 2924, 2925, 3, 278, 139, 0, 2925, 2926, 3, 284, 142, 0, 2926, 2927, 6, 137, -1, 0, 2927, 2941, 1, 0, 0, 0, 2928, 2929, 3, 276, 138, 0, 2929, 2930, 3, 284, 142, 0, 2930, 2931, 6, 137, -1, 0, 2931, 2941, 1, 0, 0, 0, 2932, 2933, 3, 280, 140, 0, 2933, 2934, 3, 284, 142, 0, 2934, 2935, 6, 137, -1, 0, 2935, 2941, 1, 0, 0, 0, 2936, 2937, 3, 282, 141, 0, 2937, 2938, 3, 284, 142, 0, 2938, 2939, 6, 137, -1, 0, 2939, 2941, 1, 0, 0, 0, 2940, 2924, 1, 0, 0, 0, 2940, 2928, 1, 0, 0, 0, 2940, 2932, 1, 0, 0, 0, 2940, 2936, 1, 0, 0, 0, 2941, 275, 1, 0, 0, 0, 2942, 2943, 5, 160, 0, 0, 2943, 2944, 3, 266, 133, 0, 2944, 2945, 6, 138, -1, 0, 2945, 2955, 1, 0, 0, 0, 2946, 2947, 5, 160, 0, 0, 2947, 2948, 3, 0, 0, 0, 2948, 2949, 6, 138, -1, 0, 2949, 2955, 1, 0, 0, 0, 2950, 2951, 5, 160, 0, 0, 2951, 2952, 3, 32, 16, 0, 2952, 2953, 6, 138, -1, 0, 2953, 2955, 1, 0, 0, 0, 2954, 2942, 1, 0, 0, 0, 2954, 2946, 1, 0, 0, 0, 2954, 2950, 1, 0, 0, 0, 2955, 277, 1, 0, 0, 0, 2956, 2957, 5, 161, 0, 0, 2957, 2958, 3, 126, 63, 0, 2958, 279, 1, 0, 0, 0, 2959, 2960, 5, 162, 0, 0, 2960, 281, 1, 0, 0, 0, 2961, 2962, 5, 163, 0, 0, 2962, 283, 1, 0, 0, 0, 2963, 2964, 3, 266, 133, 0, 2964, 2965, 6, 142, -1, 0, 2965, 2979, 1, 0, 0, 0, 2966, 2967, 5, 164, 0, 0, 2967, 2968, 3, 0, 0, 0, 2968, 2969, 5, 159, 0, 0, 2969, 2970, 3, 0, 0, 0, 2970, 2971, 6, 142, -1, 0, 2971, 2979, 1, 0, 0, 0, 2972, 2973, 5, 164, 0, 0, 2973, 2974, 3, 32, 16, 0, 2974, 2975, 5, 159, 0, 0, 2975, 2976, 3, 32, 16, 0, 2976, 2977, 6, 142, -1, 0, 2977, 2979, 1, 0, 0, 0, 2978, 2963, 1, 0, 0, 0, 2978, 2966, 1, 0, 0, 0, 2978, 2972, 1, 0, 0, 0, 2979, 285, 1, 0, 0, 0, 2980, 2981, 3, 288, 144, 0, 2981, 2982, 3, 292, 146, 0, 2982, 287, 1, 0, 0, 0, 2983, 2984, 5, 165, 0, 0, 2984, 2985, 3, 290, 145, 0, 2985, 2986, 3, 0, 0, 0, 2986, 2987, 5, 36, 0, 0, 2987, 2988, 6, 144, -1, 0, 2988, 2994, 1, 0, 0, 0, 2989, 2990, 5, 165, 0, 0, 2990, 2991, 3, 290, 145, 0, 2991, 2992, 6, 144, -1, 0, 2992, 2994, 1, 0, 0, 0, 2993, 2983, 1, 0, 0, 0, 2993, 2989, 1, 0, 0, 0, 2994, 289, 1, 0, 0, 0, 2995, 3001, 1, 0, 0, 0, 2996, 2997, 5, 166, 0, 0, 2997, 3001, 6, 145, -1, 0, 2998, 2999, 5, 2, 0, 0, 2999, 3001, 6, 145, -1, 0, 3000, 2995, 1, 0, 0, 0, 3000, 2996, 1, 0, 0, 0, 3000, 2998, 1, 0, 0, 0, 3001, 291, 1, 0, 0, 0, 3002, 3003, 5, 17, 0, 0, 3003, 3004, 3, 294, 147, 0, 3004, 3005, 5, 18, 0, 0, 3005, 3012, 1, 0, 0, 0, 3006, 3008, 3, 298, 149, 0, 3007, 3006, 1, 0, 0, 0, 3008, 3009, 1, 0, 0, 0, 3009, 3007, 1, 0, 0, 0, 3009, 3010, 1, 0, 0, 0, 3010, 3012, 1, 0, 0, 0, 3011, 3002, 1, 0, 0, 0, 3011, 3007, 1, 0, 0, 0, 3012, 293, 1, 0, 0, 0, 3013, 3014, 3, 298, 149, 0, 3014, 3015, 5, 28, 0, 0, 3015, 3017, 1, 0, 0, 0, 3016, 3013, 1, 0, 0, 0, 3017, 3020, 1, 0, 0, 0, 3018, 3016, 1, 0, 0, 0, 3018, 3019, 1, 0, 0, 0, 3019, 3021, 1, 0, 0, 0, 3020, 3018, 1, 0, 0, 0, 3021, 3022, 3, 298, 149, 0, 3022, 295, 1, 0, 0, 0, 3023, 3030, 1, 0, 0, 0, 3024, 3025, 5, 42, 0, 0, 3025, 3026, 3, 32, 16, 0, 3026, 3027, 5, 43, 0, 0, 3027, 3028, 6, 148, -1, 0, 3028, 3030, 1, 0, 0, 0, 3029, 3023, 1, 0, 0, 0, 3029, 3024, 1, 0, 0, 0, 3030, 297, 1, 0, 0, 0, 3031, 3032, 5, 181, 0, 0, 3032, 3033, 5, 262, 0, 0, 3033, 3034, 5, 30, 0, 0, 3034, 3035, 3, 6, 3, 0, 3035, 3036, 5, 31, 0, 0, 3036, 3037, 6, 149, -1, 0, 3037, 3080, 1, 0, 0, 0, 3038, 3039, 5, 260, 0, 0, 3039, 3040, 5, 30, 0, 0, 3040, 3041, 3, 0, 0, 0, 3041, 3042, 5, 31, 0, 0, 3042, 3043, 6, 149, -1, 0, 3043, 3080, 1, 0, 0, 0, 3044, 3045, 5, 260, 0, 0, 3045, 3046, 3, 0, 0, 0, 3046, 3047, 6, 149, -1, 0, 3047, 3080, 1, 0, 0, 0, 3048, 3049, 5, 84, 0, 0, 3049, 3050, 5, 30, 0, 0, 3050, 3051, 3, 302, 151, 0, 3051, 3052, 5, 31, 0, 0, 3052, 3053, 6, 149, -1, 0, 3053, 3080, 1, 0, 0, 0, 3054, 3055, 7, 11, 0, 0, 3055, 3056, 5, 30, 0, 0, 3056, 3057, 3, 36, 18, 0, 3057, 3058, 5, 31, 0, 0, 3058, 3059, 3, 296, 148, 0, 3059, 3060, 6, 149, -1, 0, 3060, 3080, 1, 0, 0, 0, 3061, 3062, 5, 187, 0, 0, 3062, 3063, 5, 30, 0, 0, 3063, 3064, 3, 34, 17, 0, 3064, 3065, 5, 31, 0, 0, 3065, 3066, 3, 296, 148, 0, 3066, 3067, 6, 149, -1, 0, 3067, 3080, 1, 0, 0, 0, 3068, 3069, 7, 12, 0, 0, 3069, 3070, 5, 30, 0, 0, 3070, 3071, 3, 32, 16, 0, 3071, 3072, 5, 31, 0, 0, 3072, 3073, 3, 296, 148, 0, 3073, 3074, 6, 149, -1, 0, 3074, 3080, 1, 0, 0, 0, 3075, 3076, 7, 13, 0, 0, 3076, 3077, 3, 296, 148, 0, 3077, 3078, 6, 149, -1, 0, 3078, 3080, 1, 0, 0, 0, 3079, 3031, 1, 0, 0, 0, 3079, 3038, 1, 0, 0, 0, 3079, 3044, 1, 0, 0, 0, 3079, 3048, 1, 0, 0, 0, 3079, 3054, 1, 0, 0, 0, 3079, 3061, 1, 0, 0, 0, 3079, 3068, 1, 0, 0, 0, 3079, 3075, 1, 0, 0, 0, 3080, 299, 1, 0, 0, 0, 3081, 3082, 5, 188, 0, 0, 3082, 3083, 5, 30, 0, 0, 3083, 3084, 3, 36, 18, 0, 3084, 3085, 5, 31, 0, 0, 3085, 3086, 6, 150, -1, 0, 3086, 3172, 1, 0, 0, 0, 3087, 3088, 5, 189, 0, 0, 3088, 3089, 5, 30, 0, 0, 3089, 3090, 3, 36, 18, 0, 3090, 3091, 5, 31, 0, 0, 3091, 3092, 6, 150, -1, 0, 3092, 3172, 1, 0, 0, 0, 3093, 3094, 5, 188, 0, 0, 3094, 3095, 5, 30, 0, 0, 3095, 3096, 3, 32, 16, 0, 3096, 3097, 5, 31, 0, 0, 3097, 3098, 6, 150, -1, 0, 3098, 3172, 1, 0, 0, 0, 3099, 3100, 5, 189, 0, 0, 3100, 3101, 5, 30, 0, 0, 3101, 3102, 3, 34, 17, 0, 3102, 3103, 5, 31, 0, 0, 3103, 3104, 6, 150, -1, 0, 3104, 3172, 1, 0, 0, 0, 3105, 3106, 5, 187, 0, 0, 3106, 3107, 5, 30, 0, 0, 3107, 3108, 3, 34, 17, 0, 3108, 3109, 5, 31, 0, 0, 3109, 3110, 6, 150, -1, 0, 3110, 3172, 1, 0, 0, 0, 3111, 3112, 5, 186, 0, 0, 3112, 3113, 5, 30, 0, 0, 3113, 3114, 3, 32, 16, 0, 3114, 3115, 5, 31, 0, 0, 3115, 3116, 6, 150, -1, 0, 3116, 3172, 1, 0, 0, 0, 3117, 3118, 5, 185, 0, 0, 3118, 3119, 5, 30, 0, 0, 3119, 3120, 3, 32, 16, 0, 3120, 3121, 5, 31, 0, 0, 3121, 3122, 6, 150, -1, 0, 3122, 3172, 1, 0, 0, 0, 3123, 3124, 5, 184, 0, 0, 3124, 3125, 5, 30, 0, 0, 3125, 3126, 3, 32, 16, 0, 3126, 3127, 5, 31, 0, 0, 3127, 3128, 6, 150, -1, 0, 3128, 3172, 1, 0, 0, 0, 3129, 3130, 5, 193, 0, 0, 3130, 3131, 5, 30, 0, 0, 3131, 3132, 3, 34, 17, 0, 3132, 3133, 5, 31, 0, 0, 3133, 3134, 6, 150, -1, 0, 3134, 3172, 1, 0, 0, 0, 3135, 3136, 5, 192, 0, 0, 3136, 3137, 5, 30, 0, 0, 3137, 3138, 3, 32, 16, 0, 3138, 3139, 5, 31, 0, 0, 3139, 3140, 6, 150, -1, 0, 3140, 3172, 1, 0, 0, 0, 3141, 3142, 5, 191, 0, 0, 3142, 3143, 5, 30, 0, 0, 3143, 3144, 3, 32, 16, 0, 3144, 3145, 5, 31, 0, 0, 3145, 3146, 6, 150, -1, 0, 3146, 3172, 1, 0, 0, 0, 3147, 3148, 5, 190, 0, 0, 3148, 3149, 5, 30, 0, 0, 3149, 3150, 3, 32, 16, 0, 3150, 3151, 5, 31, 0, 0, 3151, 3152, 6, 150, -1, 0, 3152, 3172, 1, 0, 0, 0, 3153, 3154, 5, 181, 0, 0, 3154, 3155, 5, 30, 0, 0, 3155, 3156, 3, 32, 16, 0, 3156, 3157, 5, 31, 0, 0, 3157, 3158, 6, 150, -1, 0, 3158, 3172, 1, 0, 0, 0, 3159, 3160, 5, 183, 0, 0, 3160, 3161, 5, 30, 0, 0, 3161, 3162, 3, 164, 82, 0, 3162, 3163, 5, 31, 0, 0, 3163, 3164, 6, 150, -1, 0, 3164, 3172, 1, 0, 0, 0, 3165, 3166, 5, 84, 0, 0, 3166, 3167, 5, 30, 0, 0, 3167, 3168, 3, 302, 151, 0, 3168, 3169, 5, 31, 0, 0, 3169, 3170, 6, 150, -1, 0, 3170, 3172, 1, 0, 0, 0, 3171, 3081, 1, 0, 0, 0, 3171, 3087, 1, 0, 0, 0, 3171, 3093, 1, 0, 0, 0, 3171, 3099, 1, 0, 0, 0, 3171, 3105, 1, 0, 0, 0, 3171, 3111, 1, 0, 0, 0, 3171, 3117, 1, 0, 0, 0, 3171, 3123, 1, 0, 0, 0, 3171, 3129, 1, 0, 0, 0, 3171, 3135, 1, 0, 0, 0, 3171, 3141, 1, 0, 0, 0, 3171, 3147, 1, 0, 0, 0, 3171, 3153, 1, 0, 0, 0, 3171, 3159, 1, 0, 0, 0, 3171, 3165, 1, 0, 0, 0, 3172, 301, 1, 0, 0, 0, 3173, 3174, 3, 304, 152, 0, 3174, 3175, 6, 151, -1, 0, 3175, 3177, 1, 0, 0, 0, 3176, 3173, 1, 0, 0, 0, 3177, 3180, 1, 0, 0, 0, 3178, 3176, 1, 0, 0, 0, 3178, 3179, 1, 0, 0, 0, 3179, 303, 1, 0, 0, 0, 3180, 3178, 1, 0, 0, 0, 3181, 3182, 7, 14, 0, 0, 3182, 305, 1, 0, 0, 0, 3183, 3184, 3, 300, 150, 0, 3184, 3185, 6, 153, -1, 0, 3185, 3192, 1, 0, 0, 0, 3186, 3187, 3, 6, 3, 0, 3187, 3188, 6, 153, -1, 0, 3188, 3192, 1, 0, 0, 0, 3189, 3190, 5, 179, 0, 0, 3190, 3192, 6, 153, -1, 0, 3191, 3183, 1, 0, 0, 0, 3191, 3186, 1, 0, 0, 0, 3191, 3189, 1, 0, 0, 0, 3192, 307, 1, 0, 0, 0, 3193, 3194, 3, 300, 150, 0, 3194, 3195, 6, 154, -1, 0, 3195, 3365, 1, 0, 0, 0, 3196, 3197, 5, 182, 0, 0, 3197, 3198, 5, 30, 0, 0, 3198, 3199, 5, 179, 0, 0, 3199, 3200, 5, 31, 0, 0, 3200, 3365, 6, 154, -1, 0, 3201, 3202, 5, 182, 0, 0, 3202, 3203, 5, 30, 0, 0, 3203, 3204, 5, 264, 0, 0, 3204, 3205, 5, 31, 0, 0, 3205, 3365, 6, 154, -1, 0, 3206, 3207, 5, 196, 0, 0, 3207, 3208, 5, 30, 0, 0, 3208, 3209, 5, 39, 0, 0, 3209, 3210, 5, 264, 0, 0, 3210, 3211, 5, 31, 0, 0, 3211, 3365, 6, 154, -1, 0, 3212, 3213, 5, 196, 0, 0, 3213, 3214, 5, 30, 0, 0, 3214, 3215, 3, 118, 59, 0, 3215, 3216, 5, 31, 0, 0, 3216, 3217, 6, 154, -1, 0, 3217, 3365, 1, 0, 0, 0, 3218, 3219, 5, 196, 0, 0, 3219, 3220, 5, 30, 0, 0, 3220, 3221, 5, 179, 0, 0, 3221, 3222, 5, 31, 0, 0, 3222, 3365, 6, 154, -1, 0, 3223, 3224, 5, 197, 0, 0, 3224, 3225, 5, 30, 0, 0, 3225, 3226, 3, 308, 154, 0, 3226, 3227, 5, 31, 0, 0, 3227, 3228, 6, 154, -1, 0, 3228, 3365, 1, 0, 0, 0, 3229, 3230, 5, 188, 0, 0, 3230, 3231, 5, 42, 0, 0, 3231, 3232, 3, 32, 16, 0, 3232, 3233, 5, 43, 0, 0, 3233, 3234, 5, 30, 0, 0, 3234, 3235, 3, 310, 155, 0, 3235, 3236, 5, 31, 0, 0, 3236, 3237, 6, 154, -1, 0, 3237, 3365, 1, 0, 0, 0, 3238, 3239, 5, 189, 0, 0, 3239, 3240, 5, 42, 0, 0, 3240, 3241, 3, 32, 16, 0, 3241, 3242, 5, 43, 0, 0, 3242, 3243, 5, 30, 0, 0, 3243, 3244, 3, 312, 156, 0, 3244, 3245, 5, 31, 0, 0, 3245, 3246, 6, 154, -1, 0, 3246, 3365, 1, 0, 0, 0, 3247, 3248, 5, 187, 0, 0, 3248, 3249, 5, 42, 0, 0, 3249, 3250, 3, 32, 16, 0, 3250, 3251, 5, 43, 0, 0, 3251, 3252, 5, 30, 0, 0, 3252, 3253, 3, 314, 157, 0, 3253, 3254, 5, 31, 0, 0, 3254, 3255, 6, 154, -1, 0, 3255, 3365, 1, 0, 0, 0, 3256, 3257, 5, 186, 0, 0, 3257, 3258, 5, 42, 0, 0, 3258, 3259, 3, 32, 16, 0, 3259, 3260, 5, 43, 0, 0, 3260, 3261, 5, 30, 0, 0, 3261, 3262, 3, 316, 158, 0, 3262, 3263, 5, 31, 0, 0, 3263, 3264, 6, 154, -1, 0, 3264, 3365, 1, 0, 0, 0, 3265, 3266, 5, 185, 0, 0, 3266, 3267, 5, 42, 0, 0, 3267, 3268, 3, 32, 16, 0, 3268, 3269, 5, 43, 0, 0, 3269, 3270, 5, 30, 0, 0, 3270, 3271, 3, 318, 159, 0, 3271, 3272, 5, 31, 0, 0, 3272, 3273, 6, 154, -1, 0, 3273, 3365, 1, 0, 0, 0, 3274, 3275, 5, 184, 0, 0, 3275, 3276, 5, 42, 0, 0, 3276, 3277, 3, 32, 16, 0, 3277, 3278, 5, 43, 0, 0, 3278, 3279, 5, 30, 0, 0, 3279, 3280, 3, 320, 160, 0, 3280, 3281, 5, 31, 0, 0, 3281, 3282, 6, 154, -1, 0, 3282, 3365, 1, 0, 0, 0, 3283, 3284, 5, 193, 0, 0, 3284, 3285, 5, 42, 0, 0, 3285, 3286, 3, 32, 16, 0, 3286, 3287, 5, 43, 0, 0, 3287, 3288, 5, 30, 0, 0, 3288, 3289, 3, 314, 157, 0, 3289, 3290, 5, 31, 0, 0, 3290, 3291, 6, 154, -1, 0, 3291, 3365, 1, 0, 0, 0, 3292, 3293, 5, 192, 0, 0, 3293, 3294, 5, 42, 0, 0, 3294, 3295, 3, 32, 16, 0, 3295, 3296, 5, 43, 0, 0, 3296, 3297, 5, 30, 0, 0, 3297, 3298, 3, 316, 158, 0, 3298, 3299, 5, 31, 0, 0, 3299, 3300, 6, 154, -1, 0, 3300, 3365, 1, 0, 0, 0, 3301, 3302, 5, 191, 0, 0, 3302, 3303, 5, 42, 0, 0, 3303, 3304, 3, 32, 16, 0, 3304, 3305, 5, 43, 0, 0, 3305, 3306, 5, 30, 0, 0, 3306, 3307, 3, 318, 159, 0, 3307, 3308, 5, 31, 0, 0, 3308, 3309, 6, 154, -1, 0, 3309, 3365, 1, 0, 0, 0, 3310, 3311, 5, 190, 0, 0, 3311, 3312, 5, 42, 0, 0, 3312, 3313, 3, 32, 16, 0, 3313, 3314, 5, 43, 0, 0, 3314, 3315, 5, 30, 0, 0, 3315, 3316, 3, 320, 160, 0, 3316, 3317, 5, 31, 0, 0, 3317, 3318, 6, 154, -1, 0, 3318, 3365, 1, 0, 0, 0, 3319, 3320, 5, 181, 0, 0, 3320, 3321, 5, 42, 0, 0, 3321, 3322, 3, 32, 16, 0, 3322, 3323, 5, 43, 0, 0, 3323, 3324, 5, 30, 0, 0, 3324, 3325, 3, 318, 159, 0, 3325, 3326, 5, 31, 0, 0, 3326, 3327, 6, 154, -1, 0, 3327, 3365, 1, 0, 0, 0, 3328, 3329, 5, 183, 0, 0, 3329, 3330, 5, 42, 0, 0, 3330, 3331, 3, 32, 16, 0, 3331, 3332, 5, 43, 0, 0, 3332, 3333, 5, 30, 0, 0, 3333, 3334, 3, 322, 161, 0, 3334, 3335, 5, 31, 0, 0, 3335, 3336, 6, 154, -1, 0, 3336, 3365, 1, 0, 0, 0, 3337, 3338, 5, 182, 0, 0, 3338, 3339, 5, 42, 0, 0, 3339, 3340, 3, 32, 16, 0, 3340, 3341, 5, 43, 0, 0, 3341, 3342, 5, 30, 0, 0, 3342, 3343, 3, 324, 162, 0, 3343, 3344, 5, 31, 0, 0, 3344, 3345, 6, 154, -1, 0, 3345, 3365, 1, 0, 0, 0, 3346, 3347, 5, 196, 0, 0, 3347, 3348, 5, 42, 0, 0, 3348, 3349, 3, 32, 16, 0, 3349, 3350, 5, 43, 0, 0, 3350, 3351, 5, 30, 0, 0, 3351, 3352, 3, 326, 163, 0, 3352, 3353, 5, 31, 0, 0, 3353, 3354, 6, 154, -1, 0, 3354, 3365, 1, 0, 0, 0, 3355, 3356, 5, 197, 0, 0, 3356, 3357, 5, 42, 0, 0, 3357, 3358, 3, 32, 16, 0, 3358, 3359, 5, 43, 0, 0, 3359, 3360, 5, 30, 0, 0, 3360, 3361, 3, 330, 165, 0, 3361, 3362, 5, 31, 0, 0, 3362, 3363, 6, 154, -1, 0, 3363, 3365, 1, 0, 0, 0, 3364, 3193, 1, 0, 0, 0, 3364, 3196, 1, 0, 0, 0, 3364, 3201, 1, 0, 0, 0, 3364, 3206, 1, 0, 0, 0, 3364, 3212, 1, 0, 0, 0, 3364, 3218, 1, 0, 0, 0, 3364, 3223, 1, 0, 0, 0, 3364, 3229, 1, 0, 0, 0, 3364, 3238, 1, 0, 0, 0, 3364, 3247, 1, 0, 0, 0, 3364, 3256, 1, 0, 0, 0, 3364, 3265, 1, 0, 0, 0, 3364, 3274, 1, 0, 0, 0, 3364, 3283, 1, 0, 0, 0, 3364, 3292, 1, 0, 0, 0, 3364, 3301, 1, 0, 0, 0, 3364, 3310, 1, 0, 0, 0, 3364, 3319, 1, 0, 0, 0, 3364, 3328, 1, 0, 0, 0, 3364, 3337, 1, 0, 0, 0, 3364, 3346, 1, 0, 0, 0, 3364, 3355, 1, 0, 0, 0, 3365, 309, 1, 0, 0, 0, 3366, 3367, 3, 36, 18, 0, 3367, 3368, 6, 155, -1, 0, 3368, 3373, 1, 0, 0, 0, 3369, 3370, 3, 32, 16, 0, 3370, 3371, 6, 155, -1, 0, 3371, 3373, 1, 0, 0, 0, 3372, 3366, 1, 0, 0, 0, 3372, 3369, 1, 0, 0, 0, 3373, 3376, 1, 0, 0, 0, 3374, 3372, 1, 0, 0, 0, 3374, 3375, 1, 0, 0, 0, 3375, 311, 1, 0, 0, 0, 3376, 3374, 1, 0, 0, 0, 3377, 3378, 3, 36, 18, 0, 3378, 3379, 6, 156, -1, 0, 3379, 3384, 1, 0, 0, 0, 3380, 3381, 3, 34, 17, 0, 3381, 3382, 6, 156, -1, 0, 3382, 3384, 1, 0, 0, 0, 3383, 3377, 1, 0, 0, 0, 3383, 3380, 1, 0, 0, 0, 3384, 3387, 1, 0, 0, 0, 3385, 3383, 1, 0, 0, 0, 3385, 3386, 1, 0, 0, 0, 3386, 313, 1, 0, 0, 0, 3387, 3385, 1, 0, 0, 0, 3388, 3389, 3, 34, 17, 0, 3389, 3390, 6, 157, -1, 0, 3390, 3392, 1, 0, 0, 0, 3391, 3388, 1, 0, 0, 0, 3392, 3395, 1, 0, 0, 0, 3393, 3391, 1, 0, 0, 0, 3393, 3394, 1, 0, 0, 0, 3394, 315, 1, 0, 0, 0, 3395, 3393, 1, 0, 0, 0, 3396, 3397, 3, 32, 16, 0, 3397, 3398, 6, 158, -1, 0, 3398, 3400, 1, 0, 0, 0, 3399, 3396, 1, 0, 0, 0, 3400, 3403, 1, 0, 0, 0, 3401, 3399, 1, 0, 0, 0, 3401, 3402, 1, 0, 0, 0, 3402, 317, 1, 0, 0, 0, 3403, 3401, 1, 0, 0, 0, 3404, 3405, 3, 32, 16, 0, 3405, 3406, 6, 159, -1, 0, 3406, 3408, 1, 0, 0, 0, 3407, 3404, 1, 0, 0, 0, 3408, 3411, 1, 0, 0, 0, 3409, 3407, 1, 0, 0, 0, 3409, 3410, 1, 0, 0, 0, 3410, 319, 1, 0, 0, 0, 3411, 3409, 1, 0, 0, 0, 3412, 3413, 3, 32, 16, 0, 3413, 3414, 6, 160, -1, 0, 3414, 3416, 1, 0, 0, 0, 3415, 3412, 1, 0, 0, 0, 3416, 3419, 1, 0, 0, 0, 3417, 3415, 1, 0, 0, 0, 3417, 3418, 1, 0, 0, 0, 3418, 321, 1, 0, 0, 0, 3419, 3417, 1, 0, 0, 0, 3420, 3421, 3, 164, 82, 0, 3421, 3422, 6, 161, -1, 0, 3422, 3424, 1, 0, 0, 0, 3423, 3420, 1, 0, 0, 0, 3424, 3427, 1, 0, 0, 0, 3425, 3423, 1, 0, 0, 0, 3425, 3426, 1, 0, 0, 0, 3426, 323, 1, 0, 0, 0, 3427, 3425, 1, 0, 0, 0, 3428, 3429, 5, 179, 0, 0, 3429, 3433, 6, 162, -1, 0, 3430, 3431, 5, 264, 0, 0, 3431, 3433, 6, 162, -1, 0, 3432, 3428, 1, 0, 0, 0, 3432, 3430, 1, 0, 0, 0, 3433, 3436, 1, 0, 0, 0, 3434, 3432, 1, 0, 0, 0, 3434, 3435, 1, 0, 0, 0, 3435, 325, 1, 0, 0, 0, 3436, 3434, 1, 0, 0, 0, 3437, 3438, 3, 328, 164, 0, 3438, 3439, 6, 163, -1, 0, 3439, 3441, 1, 0, 0, 0, 3440, 3437, 1, 0, 0, 0, 3441, 3444, 1, 0, 0, 0, 3442, 3440, 1, 0, 0, 0, 3442, 3443, 1, 0, 0, 0, 3443, 327, 1, 0, 0, 0, 3444, 3442, 1, 0, 0, 0, 3445, 3446, 5, 179, 0, 0, 3446, 3454, 6, 164, -1, 0, 3447, 3448, 5, 39, 0, 0, 3448, 3449, 5, 264, 0, 0, 3449, 3454, 6, 164, -1, 0, 3450, 3451, 3, 118, 59, 0, 3451, 3452, 6, 164, -1, 0, 3452, 3454, 1, 0, 0, 0, 3453, 3445, 1, 0, 0, 0, 3453, 3447, 1, 0, 0, 0, 3453, 3450, 1, 0, 0, 0, 3454, 329, 1, 0, 0, 0, 3455, 3456, 3, 308, 154, 0, 3456, 3457, 6, 165, -1, 0, 3457, 3459, 1, 0, 0, 0, 3458, 3455, 1, 0, 0, 0, 3459, 3462, 1, 0, 0, 0, 3460, 3458, 1, 0, 0, 0, 3460, 3461, 1, 0, 0, 0, 3461, 331, 1, 0, 0, 0, 3462, 3460, 1, 0, 0, 0, 3463, 3464, 3, 44, 22, 0, 3464, 3465, 6, 166, -1, 0, 3465, 3473, 1, 0, 0, 0, 3466, 3467, 3, 46, 23, 0, 3467, 3468, 6, 166, -1, 0, 3468, 3473, 1, 0, 0, 0, 3469, 3470, 3, 2, 1, 0, 3470, 3471, 6, 166, -1, 0, 3471, 3473, 1, 0, 0, 0, 3472, 3463, 1, 0, 0, 0, 3472, 3466, 1, 0, 0, 0, 3472, 3469, 1, 0, 0, 0, 3473, 333, 1, 0, 0, 0, 3474, 3475, 7, 15, 0, 0, 3475, 3476, 5, 36, 0, 0, 3476, 3477, 5, 30, 0, 0, 3477, 3478, 3, 302, 151, 0, 3478, 3479, 5, 31, 0, 0, 3479, 3480, 6, 167, -1, 0, 3480, 3507, 1, 0, 0, 0, 3481, 3482, 5, 169, 0, 0, 3482, 3483, 3, 38, 19, 0, 3483, 3484, 5, 75, 0, 0, 3484, 3485, 3, 38, 19, 0, 3485, 3486, 5, 75, 0, 0, 3486, 3487, 3, 38, 19, 0, 3487, 3488, 5, 75, 0, 0, 3488, 3489, 3, 38, 19, 0, 3489, 3490, 6, 167, -1, 0, 3490, 3507, 1, 0, 0, 0, 3491, 3492, 5, 170, 0, 0, 3492, 3493, 3, 6, 3, 0, 3493, 3494, 6, 167, -1, 0, 3494, 3507, 1, 0, 0, 0, 3495, 3496, 5, 170, 0, 0, 3496, 3497, 5, 36, 0, 0, 3497, 3498, 5, 30, 0, 0, 3498, 3499, 3, 302, 151, 0, 3499, 3500, 5, 31, 0, 0, 3500, 3501, 6, 167, -1, 0, 3501, 3507, 1, 0, 0, 0, 3502, 3503, 3, 332, 166, 0, 3503, 3504, 6, 167, -1, 0, 3504, 3507, 1, 0, 0, 0, 3505, 3507, 3, 40, 20, 0, 3506, 3474, 1, 0, 0, 0, 3506, 3481, 1, 0, 0, 0, 3506, 3491, 1, 0, 0, 0, 3506, 3495, 1, 0, 0, 0, 3506, 3502, 1, 0, 0, 0, 3506, 3505, 1, 0, 0, 0, 3507, 335, 1, 0, 0, 0, 3508, 3509, 3, 338, 169, 0, 3509, 3510, 5, 17, 0, 0, 3510, 3511, 3, 340, 170, 0, 3511, 3512, 5, 18, 0, 0, 3512, 3513, 6, 168, -1, 0, 3513, 337, 1, 0, 0, 0, 3514, 3515, 5, 25, 0, 0, 3515, 3516, 5, 40, 0, 0, 3516, 3517, 3, 100, 50, 0, 3517, 3518, 3, 2, 1, 0, 3518, 3519, 6, 169, -1, 0, 3519, 3529, 1, 0, 0, 0, 3520, 3521, 5, 25, 0, 0, 3521, 3522, 5, 40, 0, 0, 3522, 3523, 3, 100, 50, 0, 3523, 3524, 3, 2, 1, 0, 3524, 3525, 5, 34, 0, 0, 3525, 3526, 3, 2, 1, 0, 3526, 3527, 6, 169, -1, 0, 3527, 3529, 1, 0, 0, 0, 3528, 3514, 1, 0, 0, 0, 3528, 3520, 1, 0, 0, 0, 3529, 339, 1, 0, 0, 0, 3530, 3531, 3, 342, 171, 0, 3531, 3532, 6, 170, -1, 0, 3532, 3534, 1, 0, 0, 0, 3533, 3530, 1, 0, 0, 0, 3534, 3537, 1, 0, 0, 0, 3535, 3533, 1, 0, 0, 0, 3535, 3536, 1, 0, 0, 0, 3536, 341, 1, 0, 0, 0, 3537, 3535, 1, 0, 0, 0, 3538, 3539, 5, 180, 0, 0, 3539, 3540, 5, 36, 0, 0, 3540, 3541, 5, 30, 0, 0, 3541, 3542, 3, 302, 151, 0, 3542, 3543, 5, 31, 0, 0, 3543, 3544, 6, 171, -1, 0, 3544, 3558, 1, 0, 0, 0, 3545, 3546, 3, 334, 167, 0, 3546, 3547, 6, 171, -1, 0, 3547, 3558, 1, 0, 0, 0, 3548, 3549, 5, 171, 0, 0, 3549, 3550, 5, 36, 0, 0, 3550, 3551, 5, 30, 0, 0, 3551, 3552, 3, 302, 151, 0, 3552, 3553, 5, 31, 0, 0, 3553, 3554, 6, 171, -1, 0, 3554, 3558, 1, 0, 0, 0, 3555, 3556, 5, 55, 0, 0, 3556, 3558, 6, 171, -1, 0, 3557, 3538, 1, 0, 0, 0, 3557, 3545, 1, 0, 0, 0, 3557, 3548, 1, 0, 0, 0, 3557, 3555, 1, 0, 0, 0, 3558, 343, 1, 0, 0, 0, 3559, 3560, 3, 346, 173, 0, 3560, 3561, 5, 17, 0, 0, 3561, 3562, 3, 354, 177, 0, 3562, 3563, 5, 18, 0, 0, 3563, 3564, 6, 172, -1, 0, 3564, 345, 1, 0, 0, 0, 3565, 3566, 5, 50, 0, 0, 3566, 3567, 5, 40, 0, 0, 3567, 3568, 3, 350, 175, 0, 3568, 3569, 3, 2, 1, 0, 3569, 3570, 6, 173, -1, 0, 3570, 347, 1, 0, 0, 0, 3571, 3572, 5, 301, 0, 0, 3572, 3573, 3, 350, 175, 0, 3573, 3574, 3, 2, 1, 0, 3574, 3575, 6, 174, -1, 0, 3575, 349, 1, 0, 0, 0, 3576, 3577, 3, 352, 176, 0, 3577, 3578, 6, 175, -1, 0, 3578, 3580, 1, 0, 0, 0, 3579, 3576, 1, 0, 0, 0, 3580, 3583, 1, 0, 0, 0, 3581, 3579, 1, 0, 0, 0, 3581, 3582, 1, 0, 0, 0, 3582, 351, 1, 0, 0, 0, 3583, 3581, 1, 0, 0, 0, 3584, 3600, 5, 52, 0, 0, 3585, 3600, 5, 51, 0, 0, 3586, 3600, 5, 172, 0, 0, 3587, 3588, 5, 62, 0, 0, 3588, 3600, 5, 51, 0, 0, 3589, 3590, 5, 62, 0, 0, 3590, 3600, 5, 52, 0, 0, 3591, 3592, 5, 62, 0, 0, 3592, 3600, 5, 63, 0, 0, 3593, 3594, 5, 62, 0, 0, 3594, 3600, 5, 64, 0, 0, 3595, 3596, 5, 62, 0, 0, 3596, 3600, 5, 65, 0, 0, 3597, 3598, 5, 62, 0, 0, 3598, 3600, 5, 66, 0, 0, 3599, 3584, 1, 0, 0, 0, 3599, 3585, 1, 0, 0, 0, 3599, 3586, 1, 0, 0, 0, 3599, 3587, 1, 0, 0, 0, 3599, 3589, 1, 0, 0, 0, 3599, 3591, 1, 0, 0, 0, 3599, 3593, 1, 0, 0, 0, 3599, 3595, 1, 0, 0, 0, 3599, 3597, 1, 0, 0, 0, 3600, 353, 1, 0, 0, 0, 3601, 3602, 3, 356, 178, 0, 3602, 3603, 6, 177, -1, 0, 3603, 3605, 1, 0, 0, 0, 3604, 3601, 1, 0, 0, 0, 3605, 3608, 1, 0, 0, 0, 3606, 3604, 1, 0, 0, 0, 3606, 3607, 1, 0, 0, 0, 3607, 355, 1, 0, 0, 0, 3608, 3606, 1, 0, 0, 0, 3609, 3610, 5, 21, 0, 0, 3610, 3611, 3, 2, 1, 0, 3611, 3612, 6, 178, -1, 0, 3612, 3635, 1, 0, 0, 0, 3613, 3614, 5, 50, 0, 0, 3614, 3615, 5, 40, 0, 0, 3615, 3616, 3, 120, 60, 0, 3616, 3617, 6, 178, -1, 0, 3617, 3635, 1, 0, 0, 0, 3618, 3619, 5, 25, 0, 0, 3619, 3620, 5, 40, 0, 0, 3620, 3621, 3, 2, 1, 0, 3621, 3622, 6, 178, -1, 0, 3622, 3635, 1, 0, 0, 0, 3623, 3624, 3, 176, 88, 0, 3624, 3625, 6, 178, -1, 0, 3625, 3635, 1, 0, 0, 0, 3626, 3627, 5, 50, 0, 0, 3627, 3628, 3, 32, 16, 0, 3628, 3629, 6, 178, -1, 0, 3629, 3635, 1, 0, 0, 0, 3630, 3631, 3, 332, 166, 0, 3631, 3632, 6, 178, -1, 0, 3632, 3635, 1, 0, 0, 0, 3633, 3635, 3, 40, 20, 0, 3634, 3609, 1, 0, 0, 0, 3634, 3613, 1, 0, 0, 0, 3634, 3618, 1, 0, 0, 0, 3634, 3623, 1, 0, 0, 0, 3634, 3626, 1, 0, 0, 0, 3634, 3630, 1, 0, 0, 0, 3634, 3633, 1, 0, 0, 0, 3635, 357, 1, 0, 0, 0, 3636, 3637, 3, 360, 180, 0, 3637, 3638, 5, 17, 0, 0, 3638, 3639, 3, 366, 183, 0, 3639, 3640, 5, 18, 0, 0, 3640, 3641, 6, 179, -1, 0, 3641, 359, 1, 0, 0, 0, 3642, 3643, 5, 274, 0, 0, 3643, 3644, 3, 362, 181, 0, 3644, 3645, 3, 2, 1, 0, 3645, 3646, 6, 180, -1, 0, 3646, 3655, 1, 0, 0, 0, 3647, 3648, 5, 274, 0, 0, 3648, 3649, 3, 362, 181, 0, 3649, 3650, 3, 2, 1, 0, 3650, 3651, 5, 34, 0, 0, 3651, 3652, 3, 2, 1, 0, 3652, 3653, 6, 180, -1, 0, 3653, 3655, 1, 0, 0, 0, 3654, 3642, 1, 0, 0, 0, 3654, 3647, 1, 0, 0, 0, 3655, 361, 1, 0, 0, 0, 3656, 3657, 3, 364, 182, 0, 3657, 3658, 6, 181, -1, 0, 3658, 3660, 1, 0, 0, 0, 3659, 3656, 1, 0, 0, 0, 3660, 3663, 1, 0, 0, 0, 3661, 3659, 1, 0, 0, 0, 3661, 3662, 1, 0, 0, 0, 3662, 363, 1, 0, 0, 0, 3663, 3661, 1, 0, 0, 0, 3664, 3665, 7, 16, 0, 0, 3665, 365, 1, 0, 0, 0, 3666, 3667, 3, 368, 184, 0, 3667, 3668, 6, 183, -1, 0, 3668, 3670, 1, 0, 0, 0, 3669, 3666, 1, 0, 0, 0, 3670, 3673, 1, 0, 0, 0, 3671, 3669, 1, 0, 0, 0, 3671, 3672, 1, 0, 0, 0, 3672, 367, 1, 0, 0, 0, 3673, 3671, 1, 0, 0, 0, 3674, 3675, 5, 21, 0, 0, 3675, 3676, 3, 2, 1, 0, 3676, 3677, 5, 44, 0, 0, 3677, 3678, 3, 32, 16, 0, 3678, 3679, 6, 184, -1, 0, 3679, 3690, 1, 0, 0, 0, 3680, 3681, 5, 25, 0, 0, 3681, 3682, 5, 40, 0, 0, 3682, 3683, 3, 2, 1, 0, 3683, 3684, 6, 184, -1, 0, 3684, 3690, 1, 0, 0, 0, 3685, 3686, 3, 332, 166, 0, 3686, 3687, 6, 184, -1, 0, 3687, 3690, 1, 0, 0, 0, 3688, 3690, 3, 40, 20, 0, 3689, 3674, 1, 0, 0, 0, 3689, 3680, 1, 0, 0, 0, 3689, 3685, 1, 0, 0, 0, 3689, 3688, 1, 0, 0, 0, 3690, 369, 1, 0, 0, 0, 183, 380, 388, 397, 406, 495, 546, 557, 587, 594, 612, 644, 672, 712, 723, 733, 735, 746, 748, 756, 778, 791, 807, 831, 904, 911, 918, 923, 932, 943, 952, 963, 974, 987, 991, 999, 1015, 1022, 1031, 1059, 1137, 1139, 1153, 1159, 1168, 1170, 1179, 1193, 1207, 1215, 1223, 1227, 1266, 1274, 1285, 1299, 1318, 1328, 1331, 1355, 1502, 1512, 1521, 1524, 1606, 1615, 1647, 1707, 1747, 1763, 1773, 1803, 1831, 1840, 1846, 1863, 1871, 1929, 1939, 1957, 1975, 1994, 2015, 2034, 2049, 2057, 2069, 2089, 2096, 2101, 2112, 2124, 2234, 2246, 2262, 2276, 2285, 2298, 2300, 2343, 2354, 2361, 2369, 2377, 2390, 2396, 2402, 2407, 2436, 2444, 2458, 2463, 2488, 2497, 2508, 2512, 2519, 2539, 2548, 2550, 2565, 2612, 2622, 2624, 2631, 2637, 2681, 2690, 2730, 2735, 2775, 2779, 2789, 2811, 2823, 2834, 2849, 2862, 2875, 2878, 2890, 2904, 2922, 2940, 2954, 2978, 2993, 3000, 3009, 3011, 3018, 3029, 3079, 3171, 3178, 3191, 3364, 3372, 3374, 3383, 3385, 3393, 3401, 3409, 3417, 3425, 3432, 3434, 3442, 3453, 3460, 3472, 3506, 3528, 3535, 3557, 3581, 3599, 3606, 3634, 3654, 3661, 3671, 3689] \ No newline at end of file diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILBaseVisitor.cs b/src/tools/ilasm/src/ILAssembler/gen/CILBaseVisitor.cs index 3f53a66a969763..aeee13c5953153 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILBaseVisitor.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILBaseVisitor.cs @@ -386,6 +386,16 @@ public partial class CILBaseVisitor : AbstractParseTreeVisitor, /// The visitor result. public virtual Result VisitVtfixupAttr([NotNull] CILParser.VtfixupAttrContext context) { return VisitChildren(context); } /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitVtfixupAttrElement([NotNull] CILParser.VtfixupAttrElementContext context) { return VisitChildren(context); } + /// /// Visit a parse tree produced by . /// /// The default implementation returns the result of calling @@ -1899,6 +1909,16 @@ public partial class CILBaseVisitor : AbstractParseTreeVisitor, /// The visitor result. public virtual Result VisitExportHead([NotNull] CILParser.ExportHeadContext context) { return VisitChildren(context); } /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitExptAttrs([NotNull] CILParser.ExptAttrsContext context) { return VisitChildren(context); } + /// /// Visit a parse tree produced by . /// /// The default implementation returns the result of calling @@ -1949,6 +1969,16 @@ public partial class CILBaseVisitor : AbstractParseTreeVisitor, /// The visitor result. public virtual Result VisitManifestResHead([NotNull] CILParser.ManifestResHeadContext context) { return VisitChildren(context); } /// + /// Visit a parse tree produced by . + /// + /// The default implementation returns the result of calling + /// on . + /// + /// + /// The parse tree. + /// The visitor result. + public virtual Result VisitManresAttrs([NotNull] CILParser.ManresAttrsContext context) { return VisitChildren(context); } + /// /// Visit a parse tree produced by . /// /// The default implementation returns the result of calling diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs index 36d6dea038c269..8dd04e4ab6e1ce 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs @@ -98,47 +98,48 @@ public const int RULE_ownerType = 25, RULE_customBlobDescr = 26, RULE_customBlobArgs = 27, RULE_customBlobNVPairs = 28, RULE_fieldOrProp = 29, RULE_serializType = 30, RULE_serializTypeElement = 31, RULE_moduleHead = 32, RULE_vtfixupDecl = 33, - RULE_vtfixupAttr = 34, RULE_vtableDecl = 35, RULE_nameSpaceHead = 36, - RULE_classHead = 37, RULE_classAttr = 38, RULE_extendsClause = 39, RULE_implClause = 40, - RULE_classDecls = 41, RULE_implList = 42, RULE_esHead = 43, RULE_extSourceSpec = 44, - RULE_fileDecl = 45, RULE_fileAttr = 46, RULE_fileEntry = 47, RULE_asmAttrAny = 48, - RULE_asmAttr = 49, RULE_instr = 50, RULE_simpleInstr = 51, RULE_calliSignature = 52, - RULE_labels = 53, RULE_typeArgs = 54, RULE_bounds = 55, RULE_sigArgs = 56, - RULE_sigArg = 57, RULE_className = 58, RULE_slashedName = 59, RULE_assemblyDecls = 60, - RULE_assemblyDecl = 61, RULE_typeSpec = 62, RULE_nativeType = 63, RULE_nativeTypeArrayPointerInfo = 64, - RULE_nativeTypeElement = 65, RULE_iidParamIndex = 66, RULE_variantType = 67, - RULE_variantTypeElement = 68, RULE_type = 69, RULE_typeModifiers = 70, - RULE_elementType = 71, RULE_simpleType = 72, RULE_bound = 73, RULE_nativeInt = 74, - RULE_nativeUint = 75, RULE_secDecl = 76, RULE_secAttrSetBlob = 77, RULE_secAttrBlob = 78, - RULE_nameValPairs = 79, RULE_nameValPair = 80, RULE_truefalse = 81, RULE_caValue = 82, - RULE_secAction = 83, RULE_methodRef = 84, RULE_callConv = 85, RULE_callKind = 86, - RULE_mdtoken = 87, RULE_memberRef = 88, RULE_fieldRef = 89, RULE_typeList = 90, - RULE_typarsClause = 91, RULE_typarAttrib = 92, RULE_typarAttribs = 93, - RULE_typar = 94, RULE_typars = 95, RULE_tyBound = 96, RULE_genArity = 97, - RULE_genArityNotEmpty = 98, RULE_classDecl = 99, RULE_fieldDecl = 100, - RULE_fieldAttr = 101, RULE_atOpt = 102, RULE_initOpt = 103, RULE_repeatOpt = 104, - RULE_eventHead = 105, RULE_eventAttr = 106, RULE_eventDecls = 107, RULE_eventDecl = 108, - RULE_propHead = 109, RULE_propAttr = 110, RULE_propDecls = 111, RULE_propDecl = 112, - RULE_marshalClause = 113, RULE_marshalBlob = 114, RULE_paramAttr = 115, - RULE_paramAttrElement = 116, RULE_methodHead = 117, RULE_methAttr = 118, - RULE_pinvImpl = 119, RULE_pinvAttr = 120, RULE_methodName = 121, RULE_implAttr = 122, - RULE_methodDecls = 123, RULE_methodDecl = 124, RULE_localsDecl = 125, - RULE_exportDecl = 126, RULE_vtentryDecl = 127, RULE_overrideDecl = 128, - RULE_parameterDecl = 129, RULE_labelDecl = 130, RULE_customDescrInMethodBody = 131, - RULE_scopeBlock = 132, RULE_sehBlock = 133, RULE_sehClauses = 134, RULE_tryBlock = 135, - RULE_sehClause = 136, RULE_filterClause = 137, RULE_catchClause = 138, - RULE_finallyClause = 139, RULE_faultClause = 140, RULE_handlerBlock = 141, - RULE_dataDecl = 142, RULE_ddHead = 143, RULE_tls = 144, RULE_ddBody = 145, - RULE_ddItemList = 146, RULE_ddItemCount = 147, RULE_ddItem = 148, RULE_fieldSerInit = 149, - RULE_bytes = 150, RULE_hexbyte = 151, RULE_fieldInit = 152, RULE_serInit = 153, - RULE_f32seq = 154, RULE_f64seq = 155, RULE_i64seq = 156, RULE_i32seq = 157, - RULE_i16seq = 158, RULE_i8seq = 159, RULE_boolSeq = 160, RULE_sqstringSeq = 161, - RULE_classSeq = 162, RULE_classSeqElement = 163, RULE_objSeq = 164, RULE_customAttrDecl = 165, - RULE_asmOrRefDecl = 166, RULE_assemblyRefBlock = 167, RULE_assemblyRefHead = 168, - RULE_assemblyRefDecls = 169, RULE_assemblyRefDecl = 170, RULE_exptypeBlock = 171, - RULE_exptypeHead = 172, RULE_exportHead = 173, RULE_exptAttr = 174, RULE_exptypeDecls = 175, - RULE_exptypeDecl = 176, RULE_manifestResBlock = 177, RULE_manifestResHead = 178, - RULE_manresAttr = 179, RULE_manifestResDecls = 180, RULE_manifestResDecl = 181; + RULE_vtfixupAttr = 34, RULE_vtfixupAttrElement = 35, RULE_vtableDecl = 36, + RULE_nameSpaceHead = 37, RULE_classHead = 38, RULE_classAttr = 39, RULE_extendsClause = 40, + RULE_implClause = 41, RULE_classDecls = 42, RULE_implList = 43, RULE_esHead = 44, + RULE_extSourceSpec = 45, RULE_fileDecl = 46, RULE_fileAttr = 47, RULE_fileEntry = 48, + RULE_asmAttrAny = 49, RULE_asmAttr = 50, RULE_instr = 51, RULE_simpleInstr = 52, + RULE_calliSignature = 53, RULE_labels = 54, RULE_typeArgs = 55, RULE_bounds = 56, + RULE_sigArgs = 57, RULE_sigArg = 58, RULE_className = 59, RULE_slashedName = 60, + RULE_assemblyDecls = 61, RULE_assemblyDecl = 62, RULE_typeSpec = 63, RULE_nativeType = 64, + RULE_nativeTypeArrayPointerInfo = 65, RULE_nativeTypeElement = 66, RULE_iidParamIndex = 67, + RULE_variantType = 68, RULE_variantTypeElement = 69, RULE_type = 70, RULE_typeModifiers = 71, + RULE_elementType = 72, RULE_simpleType = 73, RULE_bound = 74, RULE_nativeInt = 75, + RULE_nativeUint = 76, RULE_secDecl = 77, RULE_secAttrSetBlob = 78, RULE_secAttrBlob = 79, + RULE_nameValPairs = 80, RULE_nameValPair = 81, RULE_truefalse = 82, RULE_caValue = 83, + RULE_secAction = 84, RULE_methodRef = 85, RULE_callConv = 86, RULE_callKind = 87, + RULE_mdtoken = 88, RULE_memberRef = 89, RULE_fieldRef = 90, RULE_typeList = 91, + RULE_typarsClause = 92, RULE_typarAttrib = 93, RULE_typarAttribs = 94, + RULE_typar = 95, RULE_typars = 96, RULE_tyBound = 97, RULE_genArity = 98, + RULE_genArityNotEmpty = 99, RULE_classDecl = 100, RULE_fieldDecl = 101, + RULE_fieldAttr = 102, RULE_atOpt = 103, RULE_initOpt = 104, RULE_repeatOpt = 105, + RULE_eventHead = 106, RULE_eventAttr = 107, RULE_eventDecls = 108, RULE_eventDecl = 109, + RULE_propHead = 110, RULE_propAttr = 111, RULE_propDecls = 112, RULE_propDecl = 113, + RULE_marshalClause = 114, RULE_marshalBlob = 115, RULE_paramAttr = 116, + RULE_paramAttrElement = 117, RULE_methodHead = 118, RULE_methAttr = 119, + RULE_pinvImpl = 120, RULE_pinvAttr = 121, RULE_methodName = 122, RULE_implAttr = 123, + RULE_methodDecls = 124, RULE_methodDecl = 125, RULE_localsDecl = 126, + RULE_exportDecl = 127, RULE_vtentryDecl = 128, RULE_overrideDecl = 129, + RULE_parameterDecl = 130, RULE_labelDecl = 131, RULE_customDescrInMethodBody = 132, + RULE_scopeBlock = 133, RULE_sehBlock = 134, RULE_sehClauses = 135, RULE_tryBlock = 136, + RULE_sehClause = 137, RULE_filterClause = 138, RULE_catchClause = 139, + RULE_finallyClause = 140, RULE_faultClause = 141, RULE_handlerBlock = 142, + RULE_dataDecl = 143, RULE_ddHead = 144, RULE_tls = 145, RULE_ddBody = 146, + RULE_ddItemList = 147, RULE_ddItemCount = 148, RULE_ddItem = 149, RULE_fieldSerInit = 150, + RULE_bytes = 151, RULE_hexbyte = 152, RULE_fieldInit = 153, RULE_serInit = 154, + RULE_f32seq = 155, RULE_f64seq = 156, RULE_i64seq = 157, RULE_i32seq = 158, + RULE_i16seq = 159, RULE_i8seq = 160, RULE_boolSeq = 161, RULE_sqstringSeq = 162, + RULE_classSeq = 163, RULE_classSeqElement = 164, RULE_objSeq = 165, RULE_customAttrDecl = 166, + RULE_asmOrRefDecl = 167, RULE_assemblyRefBlock = 168, RULE_assemblyRefHead = 169, + RULE_assemblyRefDecls = 170, RULE_assemblyRefDecl = 171, RULE_exptypeBlock = 172, + RULE_exptypeHead = 173, RULE_exportHead = 174, RULE_exptAttrs = 175, RULE_exptAttr = 176, + RULE_exptypeDecls = 177, RULE_exptypeDecl = 178, RULE_manifestResBlock = 179, + RULE_manifestResHead = 180, RULE_manresAttrs = 181, RULE_manresAttr = 182, + RULE_manifestResDecls = 183, RULE_manifestResDecl = 184; public static readonly string[] ruleNames = { "id", "dottedName", "dottedNamePart", "compQstring", "decls", "decl", "subsystem", "corflags", "alignment", "imagebase", "stackreserve", "assemblyBlock", @@ -146,24 +147,25 @@ public const int "float64", "intOrWildcard", "compControl", "typedefDecl", "customDescr", "customDescrWithOwner", "customType", "ownerType", "customBlobDescr", "customBlobArgs", "customBlobNVPairs", "fieldOrProp", "serializType", - "serializTypeElement", "moduleHead", "vtfixupDecl", "vtfixupAttr", "vtableDecl", - "nameSpaceHead", "classHead", "classAttr", "extendsClause", "implClause", - "classDecls", "implList", "esHead", "extSourceSpec", "fileDecl", "fileAttr", - "fileEntry", "asmAttrAny", "asmAttr", "instr", "simpleInstr", "calliSignature", - "labels", "typeArgs", "bounds", "sigArgs", "sigArg", "className", "slashedName", - "assemblyDecls", "assemblyDecl", "typeSpec", "nativeType", "nativeTypeArrayPointerInfo", - "nativeTypeElement", "iidParamIndex", "variantType", "variantTypeElement", - "type", "typeModifiers", "elementType", "simpleType", "bound", "nativeInt", - "nativeUint", "secDecl", "secAttrSetBlob", "secAttrBlob", "nameValPairs", - "nameValPair", "truefalse", "caValue", "secAction", "methodRef", "callConv", - "callKind", "mdtoken", "memberRef", "fieldRef", "typeList", "typarsClause", - "typarAttrib", "typarAttribs", "typar", "typars", "tyBound", "genArity", - "genArityNotEmpty", "classDecl", "fieldDecl", "fieldAttr", "atOpt", "initOpt", - "repeatOpt", "eventHead", "eventAttr", "eventDecls", "eventDecl", "propHead", - "propAttr", "propDecls", "propDecl", "marshalClause", "marshalBlob", "paramAttr", - "paramAttrElement", "methodHead", "methAttr", "pinvImpl", "pinvAttr", - "methodName", "implAttr", "methodDecls", "methodDecl", "localsDecl", "exportDecl", - "vtentryDecl", "overrideDecl", "parameterDecl", "labelDecl", "customDescrInMethodBody", + "serializTypeElement", "moduleHead", "vtfixupDecl", "vtfixupAttr", "vtfixupAttrElement", + "vtableDecl", "nameSpaceHead", "classHead", "classAttr", "extendsClause", + "implClause", "classDecls", "implList", "esHead", "extSourceSpec", "fileDecl", + "fileAttr", "fileEntry", "asmAttrAny", "asmAttr", "instr", "simpleInstr", + "calliSignature", "labels", "typeArgs", "bounds", "sigArgs", "sigArg", + "className", "slashedName", "assemblyDecls", "assemblyDecl", "typeSpec", + "nativeType", "nativeTypeArrayPointerInfo", "nativeTypeElement", "iidParamIndex", + "variantType", "variantTypeElement", "type", "typeModifiers", "elementType", + "simpleType", "bound", "nativeInt", "nativeUint", "secDecl", "secAttrSetBlob", + "secAttrBlob", "nameValPairs", "nameValPair", "truefalse", "caValue", + "secAction", "methodRef", "callConv", "callKind", "mdtoken", "memberRef", + "fieldRef", "typeList", "typarsClause", "typarAttrib", "typarAttribs", + "typar", "typars", "tyBound", "genArity", "genArityNotEmpty", "classDecl", + "fieldDecl", "fieldAttr", "atOpt", "initOpt", "repeatOpt", "eventHead", + "eventAttr", "eventDecls", "eventDecl", "propHead", "propAttr", "propDecls", + "propDecl", "marshalClause", "marshalBlob", "paramAttr", "paramAttrElement", + "methodHead", "methAttr", "pinvImpl", "pinvAttr", "methodName", "implAttr", + "methodDecls", "methodDecl", "localsDecl", "exportDecl", "vtentryDecl", + "overrideDecl", "parameterDecl", "labelDecl", "customDescrInMethodBody", "scopeBlock", "sehBlock", "sehClauses", "tryBlock", "sehClause", "filterClause", "catchClause", "finallyClause", "faultClause", "handlerBlock", "dataDecl", "ddHead", "tls", "ddBody", "ddItemList", "ddItemCount", "ddItem", "fieldSerInit", @@ -171,8 +173,9 @@ public const int "i32seq", "i16seq", "i8seq", "boolSeq", "sqstringSeq", "classSeq", "classSeqElement", "objSeq", "customAttrDecl", "asmOrRefDecl", "assemblyRefBlock", "assemblyRefHead", "assemblyRefDecls", "assemblyRefDecl", "exptypeBlock", "exptypeHead", - "exportHead", "exptAttr", "exptypeDecls", "exptypeDecl", "manifestResBlock", - "manifestResHead", "manresAttr", "manifestResDecls", "manifestResDecl" + "exportHead", "exptAttrs", "exptAttr", "exptypeDecls", "exptypeDecl", + "manifestResBlock", "manifestResHead", "manresAttrs", "manresAttr", "manifestResDecls", + "manifestResDecl" }; private static readonly string[] _LiteralNames = { @@ -323,7 +326,7 @@ public IdContext id() { try { EnterOuterAlt(_localctx, 1); { - State = 364; + State = 370; _la = TokenStream.LA(1); if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 65534L) != 0) || ((((_la - 199)) & ~0x3f) == 0 && ((1L << (_la - 199)) & 299067162755073L) != 0) || _la==SQSTRING || _la==ID) ) { ErrorHandler.RecoverInline(this); @@ -383,13 +386,13 @@ public DottedNameContext dottedName() { Actions.BeginDottedName(_localctx); try { int _alt; - State = 382; + State = 388; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,1,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 366; + State = 372; _localctx.direct = Match(DOTTEDNAME); Actions.AddDottedNameToken(_localctx, _localctx.direct); } @@ -398,26 +401,26 @@ public DottedNameContext dottedName() { EnterOuterAlt(_localctx, 2); { { - State = 374; + State = 380; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,0,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 368; + State = 374; _localctx.part = dottedNamePart(); Actions.AddDottedNamePart(_localctx, _localctx.part.Value); - State = 370; + State = 376; Match(DOT); } } } - State = 376; + State = 382; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,0,Context); } - State = 377; + State = 383; _localctx.tail = dottedNamePart(); Actions.AddDottedNamePart(_localctx, _localctx.tail.Value); } @@ -426,7 +429,7 @@ public DottedNameContext dottedName() { case 3: EnterOuterAlt(_localctx, 3); { - State = 380; + State = 386; _localctx.quoted = Match(SQSTRING); Actions.AddDottedNameToken(_localctx, _localctx.quoted); } @@ -473,7 +476,7 @@ public DottedNamePartContext dottedNamePart() { try { EnterOuterAlt(_localctx, 1); { - State = 384; + State = 390; _la = TokenStream.LA(1); if ( !(_la==T__15 || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50331649L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -531,26 +534,26 @@ public CompQstringContext compQstring() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 391; + State = 397; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,2,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 386; + State = 392; _localctx.head = Match(QSTRING); Actions.AddComposedStringPart(_localctx, _localctx.head); - State = 388; + State = 394; Match(PLUS); } } } - State = 393; + State = 399; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,2,Context); } - State = 394; + State = 400; _localctx.tail = Match(QSTRING); Actions.AddComposedStringPart(_localctx, _localctx.tail); } @@ -596,17 +599,17 @@ public DeclsContext decls() { try { EnterOuterAlt(_localctx, 1); { - State = 400; + State = 406; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1972571905523712L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 281474976710659L) != 0) || ((((_la - 139)) & ~0x3f) == 0 && ((1L << (_la - 139)) & 1729382256977379329L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 6860956837609473L) != 0)) { { { - State = 397; + State = 403; decl(); } } - State = 402; + State = 408; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -745,52 +748,52 @@ public DeclContext decl() { EnterRule(_localctx, 10, RULE_decl); BeginStreaming(); try { - State = 489; + State = 495; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,4,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 403; + State = 409; classHead(); - State = 404; + State = 410; Match(T__16); - State = 405; + State = 411; classDecls(); - State = 406; + State = 412; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 408; + State = 414; nameSpaceHead(); - State = 409; + State = 415; Match(T__16); - State = 410; + State = 416; decls(); - State = 411; + State = 417; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 413; + State = 419; methodHead(); - State = 414; + State = 420; Match(T__16); - State = 415; + State = 421; methodDecls(); - State = 416; + State = 422; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 418; + State = 424; fieldDecl(); } break; @@ -798,7 +801,7 @@ public DeclContext decl() { EnterOuterAlt(_localctx, 5); { Actions.BeginTopLevelDirective(); - State = 420; + State = 426; _localctx.data = dataDecl(); Actions.ProcessTopLevelDataDeclaration(_localctx.data); } @@ -807,7 +810,7 @@ public DeclContext decl() { EnterOuterAlt(_localctx, 6); { Actions.BeginTopLevelDirective(); - State = 424; + State = 430; _localctx.vtable = vtableDecl(); Actions.ProcessTopLevelVTableDeclaration(_localctx.vtable); } @@ -816,7 +819,7 @@ public DeclContext decl() { EnterOuterAlt(_localctx, 7); { Actions.BeginTopLevelDirective(); - State = 428; + State = 434; _localctx.vtfixup = vtfixupDecl(); Actions.ProcessTopLevelVTableFixupDeclaration(_localctx.vtfixup); } @@ -825,7 +828,7 @@ public DeclContext decl() { EnterOuterAlt(_localctx, 8); { Actions.BeginTopLevelDirective(); - State = 432; + State = 438; _localctx.source = extSourceSpec(); Actions.ProcessTopLevelSourceDirective(_localctx.source); } @@ -834,7 +837,7 @@ public DeclContext decl() { EnterOuterAlt(_localctx, 9); { Actions.BeginTopLevelDirective(); - State = 436; + State = 442; _localctx.file = fileDecl(); Actions.ProcessTopLevelFileDeclaration(_localctx.file); } @@ -843,7 +846,7 @@ public DeclContext decl() { EnterOuterAlt(_localctx, 10); { Actions.BeginTopLevelDirective(); - State = 440; + State = 446; _localctx.assembly = assemblyBlock(); Actions.ProcessTopLevelAssembly(_localctx.assembly); } @@ -852,7 +855,7 @@ public DeclContext decl() { EnterOuterAlt(_localctx, 11); { Actions.BeginTopLevelDirective(); - State = 444; + State = 450; _localctx.assemblyReference = assemblyRefBlock(); Actions.ProcessTopLevelAssemblyReference(_localctx.assemblyReference); } @@ -861,7 +864,7 @@ public DeclContext decl() { EnterOuterAlt(_localctx, 12); { Actions.BeginTopLevelDirective(); - State = 448; + State = 454; _localctx.exportedType = exptypeBlock(); Actions.ProcessTopLevelExportedType(_localctx.exportedType); } @@ -870,7 +873,7 @@ public DeclContext decl() { EnterOuterAlt(_localctx, 13); { Actions.BeginTopLevelDirective(); - State = 452; + State = 458; _localctx.resource = manifestResBlock(); Actions.ProcessTopLevelManifestResource(_localctx.resource); } @@ -879,7 +882,7 @@ public DeclContext decl() { EnterOuterAlt(_localctx, 14); { Actions.BeginTopLevelDirective(); - State = 456; + State = 462; _localctx.module = moduleHead(); Actions.ProcessTopLevelModule(_localctx.module.Value, _localctx.module.HasName, _localctx.module.IsExternal); } @@ -888,7 +891,7 @@ public DeclContext decl() { EnterOuterAlt(_localctx, 15); { Actions.BeginTopLevelDirective(); - State = 460; + State = 466; _localctx.security = secDecl(); Actions.ProcessTopLevelSecurityDeclaration(_localctx.security); } @@ -896,7 +899,7 @@ public DeclContext decl() { case 16: EnterOuterAlt(_localctx, 16); { - State = 463; + State = 469; _localctx.attribute = customAttrDecl(); Actions.ProcessTopLevelCustomAttribute(_localctx.attribute); } @@ -905,7 +908,7 @@ public DeclContext decl() { EnterOuterAlt(_localctx, 17); { Actions.BeginTopLevelDirective(); - State = 467; + State = 473; subsystem(); } break; @@ -913,7 +916,7 @@ public DeclContext decl() { EnterOuterAlt(_localctx, 18); { Actions.BeginTopLevelDirective(); - State = 469; + State = 475; corflags(); } break; @@ -921,7 +924,7 @@ public DeclContext decl() { EnterOuterAlt(_localctx, 19); { Actions.BeginTopLevelDirective(); - State = 471; + State = 477; alignment(); } break; @@ -929,7 +932,7 @@ public DeclContext decl() { EnterOuterAlt(_localctx, 20); { Actions.BeginTopLevelDirective(); - State = 473; + State = 479; imagebase(); } break; @@ -937,7 +940,7 @@ public DeclContext decl() { EnterOuterAlt(_localctx, 21); { Actions.BeginTopLevelDirective(); - State = 475; + State = 481; stackreserve(); } break; @@ -945,7 +948,7 @@ public DeclContext decl() { EnterOuterAlt(_localctx, 22); { Actions.BeginTopLevelDirective(); - State = 477; + State = 483; _localctx.language = languageDecl(); Actions.ProcessTopLevelLanguageDirective(_localctx.language); } @@ -954,7 +957,7 @@ public DeclContext decl() { EnterOuterAlt(_localctx, 23); { Actions.BeginTopLevelDirective(); - State = 481; + State = 487; _localctx.typedef = typedefDecl(); Actions.ProcessTopLevelTypedef(_localctx.typedef); } @@ -963,14 +966,14 @@ public DeclContext decl() { EnterOuterAlt(_localctx, 24); { Actions.BeginTopLevelDirective(); - State = 485; + State = 491; compControl(); } break; case 25: EnterOuterAlt(_localctx, 25); { - State = 486; + State = 492; typelist(); } break; @@ -978,7 +981,7 @@ public DeclContext decl() { EnterOuterAlt(_localctx, 26); { Actions.BeginTopLevelDirective(); - State = 488; + State = 494; mscorlib(); } break; @@ -1021,9 +1024,9 @@ public SubsystemContext subsystem() { try { EnterOuterAlt(_localctx, 1); { - State = 491; + State = 497; Match(T__18); - State = 492; + State = 498; _localctx.value = int32(); Actions.ProcessTopLevelSubsystem((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -1064,9 +1067,9 @@ public CorflagsContext corflags() { try { EnterOuterAlt(_localctx, 1); { - State = 495; + State = 501; Match(T__19); - State = 496; + State = 502; _localctx.value = int32(); Actions.ProcessTopLevelCorFlags((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -1107,11 +1110,11 @@ public AlignmentContext alignment() { try { EnterOuterAlt(_localctx, 1); { - State = 499; + State = 505; Match(T__20); - State = 500; + State = 506; Match(T__21); - State = 501; + State = 507; _localctx.value = int32(); Actions.ProcessTopLevelAlignment((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -1152,9 +1155,9 @@ public ImagebaseContext imagebase() { try { EnterOuterAlt(_localctx, 1); { - State = 504; + State = 510; Match(T__22); - State = 505; + State = 511; _localctx.value = int64(); Actions.ProcessTopLevelImageBase((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -1195,9 +1198,9 @@ public StackreserveContext stackreserve() { try { EnterOuterAlt(_localctx, 1); { - State = 508; + State = 514; Match(T__23); - State = 509; + State = 515; _localctx.value = int64(); Actions.ProcessTopLevelStackReserve((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -1214,7 +1217,11 @@ public StackreserveContext stackreserve() { } public partial class AssemblyBlockContext : ParserRuleContext { + public object Value; public bool HasSyntaxError; + public AsmAttrContext attributes; + public DottedNameContext name; + public AssemblyDeclsContext declarations; [System.Diagnostics.DebuggerNonUserCode] public AsmAttrContext asmAttr() { return GetRuleContext(0); } @@ -1241,22 +1248,26 @@ public override TResult Accept(IParseTreeVisitor visitor) { public AssemblyBlockContext assemblyBlock() { AssemblyBlockContext _localctx = new AssemblyBlockContext(Context, State); EnterRule(_localctx, 22, RULE_assemblyBlock); - BeginSubtree(); Actions.BeginSemanticRoot(_localctx); + BeginStreaming(); Actions.BeginSemanticRoot(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 512; + State = 518; Match(T__24); - State = 513; - asmAttr(); - State = 514; - dottedName(); - State = 515; + State = 519; + _localctx.attributes = asmAttr(); + State = 520; + _localctx.name = dottedName(); + State = 521; Match(T__16); - State = 516; - assemblyDecls(); - State = 517; + State = 522; + _localctx.declarations = assemblyDecls(); + State = 523; Match(T__17); + _localctx.Value = Actions.CreateAssemblyDefinition( + _localctx.attributes.Value, + _localctx.name.Value, + _localctx.declarations.Value); } } catch (RecognitionException re) { @@ -1292,7 +1303,7 @@ public MscorlibContext mscorlib() { try { EnterOuterAlt(_localctx, 1); { - State = 519; + State = 526; Match(T__25); } } @@ -1338,15 +1349,15 @@ public LanguageDeclContext languageDecl() { EnterRule(_localctx, 26, RULE_languageDecl); BeginStreaming(); Actions.BeginSemanticRoot(_localctx); try { - State = 539; + State = 546; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,5,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 521; + State = 528; Match(T__26); - State = 522; + State = 529; _localctx.language = languageString(); _localctx.Value = Actions.CreateLanguageDirective(_localctx.language.Value); } @@ -1354,13 +1365,13 @@ public LanguageDeclContext languageDecl() { case 2: EnterOuterAlt(_localctx, 2); { - State = 525; + State = 532; Match(T__26); - State = 526; + State = 533; _localctx.language = languageString(); - State = 527; + State = 534; Match(T__27); - State = 528; + State = 535; _localctx.vendor = languageString(); _localctx.Value = Actions.CreateLanguageDirective(_localctx.language.Value, _localctx.vendor.Value); } @@ -1368,17 +1379,17 @@ public LanguageDeclContext languageDecl() { case 3: EnterOuterAlt(_localctx, 3); { - State = 531; + State = 538; Match(T__26); - State = 532; + State = 539; _localctx.language = languageString(); - State = 533; + State = 540; Match(T__27); - State = 534; + State = 541; _localctx.vendor = languageString(); - State = 535; + State = 542; Match(T__27); - State = 536; + State = 543; _localctx.documentType = languageString(); _localctx.Value = Actions.CreateLanguageDirective(_localctx.language.Value, _localctx.vendor.Value, _localctx.documentType.Value); } @@ -1422,7 +1433,7 @@ public LanguageStringContext languageString() { try { EnterOuterAlt(_localctx, 1); { - State = 541; + State = 548; _la = TokenStream.LA(1); if ( !(_la==QSTRING || _la==SQSTRING) ) { ErrorHandler.RecoverInline(this); @@ -1476,26 +1487,26 @@ public TypelistContext typelist() { try { EnterOuterAlt(_localctx, 1); { - State = 543; + State = 550; Match(T__28); - State = 544; + State = 551; Match(T__16); - State = 550; + State = 557; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__15 || _la==T__41 || _la==T__112 || ((((_la - 199)) & ~0x3f) == 0 && ((1L << (_la - 199)) & 2017630225248026625L) != 0) || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50331649L) != 0)) { { { - State = 545; + State = 552; _localctx.name = className(); Actions.ProcessTopLevelTypeListEntry(_localctx.name.Value); } } - State = 552; + State = 559; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 553; + State = 560; Match(T__17); } } @@ -1532,7 +1543,7 @@ public Int32Context int32() { try { EnterOuterAlt(_localctx, 1); { - State = 555; + State = 562; Match(INT32); } } @@ -1571,7 +1582,7 @@ public Int64Context int64() { try { EnterOuterAlt(_localctx, 1); { - State = 557; + State = 564; _la = TokenStream.LA(1); if ( !(_la==INT32 || _la==INT64) ) { ErrorHandler.RecoverInline(this); @@ -1628,13 +1639,13 @@ public Float64Context float64() { Float64Context _localctx = new Float64Context(Context, State); EnterRule(_localctx, 36, RULE_float64); try { - State = 580; + State = 587; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,7,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 559; + State = 566; _localctx.@decimal = Match(FLOAT64); _localctx.Value = Actions.ParseFloatingLiteral(_localctx.@decimal); } @@ -1642,9 +1653,9 @@ public Float64Context float64() { case 2: EnterOuterAlt(_localctx, 2); { - State = 561; + State = 568; _localctx.trailing = int32(); - State = 562; + State = 569; Match(DOT); _localctx.Value = Actions.ParseFloatingInteger((_localctx.trailing!=null?(_localctx.trailing.Start):null)); } @@ -1652,7 +1663,7 @@ public Float64Context float64() { case 3: EnterOuterAlt(_localctx, 3); { - State = 565; + State = 572; _localctx.integer = int32(); _localctx.Value = Actions.ParseFloatingInteger((_localctx.integer!=null?(_localctx.integer.Start):null)); } @@ -1660,13 +1671,13 @@ public Float64Context float64() { case 4: EnterOuterAlt(_localctx, 4); { - State = 568; + State = 575; Match(FLOAT32); - State = 569; + State = 576; Match(T__29); - State = 570; + State = 577; _localctx.singleBits = int32(); - State = 571; + State = 578; Match(T__30); _localctx.Value = Actions.ParseFloat32Bits((_localctx.singleBits!=null?(_localctx.singleBits.Start):null)); } @@ -1674,13 +1685,13 @@ public Float64Context float64() { case 5: EnterOuterAlt(_localctx, 5); { - State = 574; + State = 581; Match(FLOAT64_); - State = 575; + State = 582; Match(T__29); - State = 576; + State = 583; _localctx.doubleBits = int64(); - State = 577; + State = 584; Match(T__30); _localctx.Value = Actions.ParseFloat64Bits((_localctx.doubleBits!=null?(_localctx.doubleBits.Start):null)); } @@ -1699,6 +1710,8 @@ public Float64Context float64() { } public partial class IntOrWildcardContext : ParserRuleContext { + public int? Value; + public Int32Context value; [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); } @@ -1721,21 +1734,23 @@ public IntOrWildcardContext intOrWildcard() { IntOrWildcardContext _localctx = new IntOrWildcardContext(Context, State); EnterRule(_localctx, 38, RULE_intOrWildcard); try { - State = 584; + State = 594; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case INT32: EnterOuterAlt(_localctx, 1); { - State = 582; - int32(); + State = 589; + _localctx.value = int32(); + _localctx.Value = Actions.ParseInt32((_localctx.value!=null?(_localctx.value.Start):null)); } break; case PTR: EnterOuterAlt(_localctx, 2); { - State = 583; + State = 592; Match(PTR); + _localctx.Value = null; } break; default: @@ -1781,83 +1796,83 @@ public CompControlContext compControl() { CompControlContext _localctx = new CompControlContext(Context, State); EnterRule(_localctx, 40, RULE_compControl); try { - State = 602; + State = 612; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,9,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 586; + State = 596; Match(PP_DEFINE); - State = 587; + State = 597; Match(ID); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 588; + State = 598; Match(PP_DEFINE); - State = 589; + State = 599; Match(ID); - State = 590; + State = 600; Match(QSTRING); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 591; + State = 601; Match(PP_UNDEF); - State = 592; + State = 602; Match(ID); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 593; + State = 603; Match(PP_IFDEF); - State = 594; + State = 604; Match(ID); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 595; + State = 605; Match(PP_IFNDEF); - State = 596; + State = 606; Match(ID); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 597; + State = 607; Match(PP_ELSE); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 598; + State = 608; Match(PP_ENDIF); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 599; + State = 609; Match(PP_INCLUDE); - State = 600; + State = 610; Match(QSTRING); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 601; + State = 611; Match(T__31); } break; @@ -1875,7 +1890,14 @@ public CompControlContext compControl() { } public partial class TypedefDeclContext : ParserRuleContext { + public object Value; public bool HasSyntaxError; + public TypeContext signature; + public DottedNameContext alias; + public ClassNameContext classType; + public MemberRefContext member; + public CustomDescrContext attribute; + public CustomDescrWithOwnerContext ownedAttribute; [System.Diagnostics.DebuggerNonUserCode] public TypeContext type() { return GetRuleContext(0); } @@ -1911,74 +1933,85 @@ public override TResult Accept(IParseTreeVisitor visitor) { public TypedefDeclContext typedefDecl() { TypedefDeclContext _localctx = new TypedefDeclContext(Context, State); EnterRule(_localctx, 42, RULE_typedefDecl); - BeginSubtree(); Actions.BeginSemanticRoot(_localctx); + BeginStreaming(); Actions.BeginSemanticRoot(_localctx); try { - State = 629; + State = 644; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,10,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 604; + State = 614; Match(T__32); - State = 605; - type(); - State = 606; + State = 615; + _localctx.signature = type(); + State = 616; Match(T__33); - State = 607; - dottedName(); + State = 617; + _localctx.alias = dottedName(); + _localctx.Value = Actions.CreateTypeSignatureTypedef(_localctx.signature.Value, _localctx.alias.Value); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 609; + State = 620; Match(T__32); - State = 610; - className(); - State = 611; + State = 621; + _localctx.classType = className(); + State = 622; Match(T__33); - State = 612; - dottedName(); + State = 623; + _localctx.alias = dottedName(); + _localctx.Value = Actions.CreateClassTypedef(_localctx.classType.Value, _localctx.alias.Value); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 614; + State = 626; Match(T__32); - State = 615; - memberRef(); - State = 616; + State = 627; + _localctx.member = memberRef(); + State = 628; Match(T__33); - State = 617; - dottedName(); + State = 629; + _localctx.alias = dottedName(); + _localctx.Value = Actions.CreateMemberTypedef(_localctx.member.Value, _localctx.alias.Value); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 619; + State = 632; Match(T__32); - State = 620; - customDescr(); - State = 621; + State = 633; + _localctx.attribute = customDescr(); + State = 634; Match(T__33); - State = 622; - dottedName(); + State = 635; + _localctx.alias = dottedName(); + _localctx.Value = Actions.CreateCustomAttributeTypedefDeclaration( + _localctx.attribute.Value, + (_localctx.attribute!=null?(_localctx.attribute.Start):null), + _localctx.alias.Value); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 624; + State = 638; Match(T__32); - State = 625; - customDescrWithOwner(); - State = 626; + State = 639; + _localctx.ownedAttribute = customDescrWithOwner(); + State = 640; Match(T__33); - State = 627; - dottedName(); + State = 641; + _localctx.alias = dottedName(); + _localctx.Value = Actions.CreateCustomAttributeTypedefDeclaration( + _localctx.ownedAttribute.Value, + (_localctx.ownedAttribute!=null?(_localctx.ownedAttribute.Start):null), + _localctx.alias.Value); } break; } @@ -2033,15 +2066,15 @@ public CustomDescrContext customDescr() { EnterRule(_localctx, 44, RULE_customDescr); Actions.BeginSemanticRoot(_localctx); try { - State = 657; + State = 672; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,11,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 631; + State = 646; Match(T__34); - State = 632; + State = 647; _localctx.constructor = customType(); _localctx.Value = Actions.CreateDefaultCustomAttribute(_localctx.constructor.Value); } @@ -2049,13 +2082,13 @@ public CustomDescrContext customDescr() { case 2: EnterOuterAlt(_localctx, 2); { - State = 635; + State = 650; Match(T__34); - State = 636; + State = 651; _localctx.constructor = customType(); - State = 637; + State = 652; Match(T__35); - State = 638; + State = 653; _localctx.stringValue = compQstring(); _localctx.Value = Actions.CreateStringCustomAttribute(_localctx.constructor.Value, _localctx.stringValue.Value); } @@ -2063,17 +2096,17 @@ public CustomDescrContext customDescr() { case 3: EnterOuterAlt(_localctx, 3); { - State = 641; + State = 656; Match(T__34); - State = 642; + State = 657; _localctx.constructor = customType(); - State = 643; + State = 658; Match(T__35); - State = 644; + State = 659; Match(T__16); - State = 645; + State = 660; _localctx.structuredValue = customBlobDescr(); - State = 646; + State = 661; Match(T__17); _localctx.Value = Actions.CreateStructuredCustomAttribute(_localctx.constructor.Value, _localctx.structuredValue.Value); } @@ -2081,17 +2114,17 @@ public CustomDescrContext customDescr() { case 4: EnterOuterAlt(_localctx, 4); { - State = 649; + State = 664; Match(T__34); - State = 650; + State = 665; _localctx.constructor = customType(); - State = 651; + State = 666; Match(T__35); - State = 652; + State = 667; Match(T__29); - State = 653; + State = 668; _localctx.rawValue = bytes(); - State = 654; + State = 669; Match(T__30); _localctx.Value = Actions.CreateRawCustomAttribute(_localctx.constructor.Value, _localctx.rawValue.Value); } @@ -2152,21 +2185,21 @@ public CustomDescrWithOwnerContext customDescrWithOwner() { EnterRule(_localctx, 46, RULE_customDescrWithOwner); Actions.BeginSemanticRoot(_localctx); try { - State = 697; + State = 712; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,12,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 659; + State = 674; Match(T__34); - State = 660; + State = 675; Match(T__29); - State = 661; + State = 676; _localctx.owner = ownerType(); - State = 662; + State = 677; Match(T__30); - State = 663; + State = 678; _localctx.constructor = customType(); _localctx.Value = Actions.CreateDefaultOwnedCustomAttribute(_localctx.owner.Value, _localctx.constructor.Value); } @@ -2174,19 +2207,19 @@ public CustomDescrWithOwnerContext customDescrWithOwner() { case 2: EnterOuterAlt(_localctx, 2); { - State = 666; + State = 681; Match(T__34); - State = 667; + State = 682; Match(T__29); - State = 668; + State = 683; _localctx.owner = ownerType(); - State = 669; + State = 684; Match(T__30); - State = 670; + State = 685; _localctx.constructor = customType(); - State = 671; + State = 686; Match(T__35); - State = 672; + State = 687; _localctx.stringValue = compQstring(); _localctx.Value = Actions.CreateStringOwnedCustomAttribute(_localctx.owner.Value, _localctx.constructor.Value, _localctx.stringValue.Value); } @@ -2194,23 +2227,23 @@ public CustomDescrWithOwnerContext customDescrWithOwner() { case 3: EnterOuterAlt(_localctx, 3); { - State = 675; + State = 690; Match(T__34); - State = 676; + State = 691; Match(T__29); - State = 677; + State = 692; _localctx.owner = ownerType(); - State = 678; + State = 693; Match(T__30); - State = 679; + State = 694; _localctx.constructor = customType(); - State = 680; + State = 695; Match(T__35); - State = 681; + State = 696; Match(T__16); - State = 682; + State = 697; _localctx.structuredValue = customBlobDescr(); - State = 683; + State = 698; Match(T__17); _localctx.Value = Actions.CreateStructuredOwnedCustomAttribute(_localctx.owner.Value, _localctx.constructor.Value, _localctx.structuredValue.Value); } @@ -2218,23 +2251,23 @@ public CustomDescrWithOwnerContext customDescrWithOwner() { case 4: EnterOuterAlt(_localctx, 4); { - State = 686; + State = 701; Match(T__34); - State = 687; + State = 702; Match(T__29); - State = 688; + State = 703; _localctx.owner = ownerType(); - State = 689; + State = 704; Match(T__30); - State = 690; + State = 705; _localctx.constructor = customType(); - State = 691; + State = 706; Match(T__35); - State = 692; + State = 707; Match(T__29); - State = 693; + State = 708; _localctx.rawValue = bytes(); - State = 694; + State = 709; Match(T__30); _localctx.Value = Actions.CreateRawOwnedCustomAttribute(_localctx.owner.Value, _localctx.constructor.Value, _localctx.rawValue.Value); } @@ -2279,7 +2312,7 @@ public CustomTypeContext customType() { try { EnterOuterAlt(_localctx, 1); { - State = 699; + State = 714; _localctx.constructor = methodRef(); _localctx.Value = Actions.CreateCustomAttributeType(_localctx.constructor.Value); } @@ -2325,13 +2358,13 @@ public OwnerTypeContext ownerType() { EnterRule(_localctx, 50, RULE_ownerType); Actions.BeginSemanticRoot(_localctx); try { - State = 708; + State = 723; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,13,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 702; + State = 717; _localctx.typeValue = typeSpec(); _localctx.Value = Actions.CreateTypeOwner(_localctx.typeValue.Value); } @@ -2339,7 +2372,7 @@ public OwnerTypeContext ownerType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 705; + State = 720; _localctx.member = memberRef(); _localctx.Value = Actions.CreateMemberOwner(_localctx.member.Value); } @@ -2388,9 +2421,9 @@ public CustomBlobDescrContext customBlobDescr() { try { EnterOuterAlt(_localctx, 1); { - State = 710; + State = 725; _localctx.arguments = customBlobArgs(); - State = 711; + State = 726; _localctx.namedArguments = customBlobNVPairs(); _localctx.Value = Actions.CreateCustomAttributeBlob(_localctx.arguments.Value, _localctx.namedArguments.Value); } @@ -2443,13 +2476,13 @@ public CustomBlobArgsContext customBlobArgs() { int _alt; EnterOuterAlt(_localctx, 1); { - State = 720; + State = 735; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,15,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { - State = 718; + State = 733; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__83: @@ -2469,7 +2502,7 @@ public CustomBlobArgsContext customBlobArgs() { case TYPE: case OBJECT: { - State = 714; + State = 729; _localctx.argument = serInit(); Actions.AddCustomBlobArgument(_localctx, _localctx.argument.Value); } @@ -2483,7 +2516,7 @@ public CustomBlobArgsContext customBlobArgs() { case PP_ENDIF: case PP_INCLUDE: { - State = 717; + State = 732; compControl(); } break; @@ -2492,7 +2525,7 @@ public CustomBlobArgsContext customBlobArgs() { } } } - State = 722; + State = 737; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,15,Context); } @@ -2568,26 +2601,26 @@ public CustomBlobNVPairsContext customBlobNVPairs() { try { EnterOuterAlt(_localctx, 1); { - State = 733; + State = 748; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 416611827712L) != 0) || ((((_la - 267)) & ~0x3f) == 0 && ((1L << (_la - 267)) & 127L) != 0)) { { - State = 731; + State = 746; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__36: case T__37: { - State = 723; + State = 738; _localctx.kind = fieldOrProp(); - State = 724; + State = 739; _localctx.argumentType = serializType(); - State = 725; + State = 740; _localctx.name = dottedName(); - State = 726; + State = 741; Match(T__35); - State = 727; + State = 742; _localctx.value = serInit(); Actions.AddCustomBlobNamedArgument( _localctx, @@ -2606,7 +2639,7 @@ public CustomBlobNVPairsContext customBlobNVPairs() { case PP_ENDIF: case PP_INCLUDE: { - State = 730; + State = 745; compControl(); } break; @@ -2614,7 +2647,7 @@ public CustomBlobNVPairsContext customBlobNVPairs() { throw new NoViableAltException(this); } } - State = 735; + State = 750; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -2656,7 +2689,7 @@ public FieldOrPropContext fieldOrProp() { try { EnterOuterAlt(_localctx, 1); { - State = 736; + State = 751; _localctx.kind = TokenStream.LT(1); _la = TokenStream.LA(1); if ( !(_la==T__36 || _la==T__37) ) { @@ -2709,14 +2742,14 @@ public SerializTypeContext serializType() { try { EnterOuterAlt(_localctx, 1); { - State = 739; + State = 754; _localctx.element = serializTypeElement(); - State = 741; + State = 756; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==ARRAY_TYPE_NO_BOUNDS) { { - State = 740; + State = 755; _localctx.array = Match(ARRAY_TYPE_NO_BOUNDS); } } @@ -2773,13 +2806,13 @@ public SerializTypeElementContext serializTypeElement() { SerializTypeElementContext _localctx = new SerializTypeElementContext(Context, State); EnterRule(_localctx, 62, RULE_serializTypeElement); try { - State = 763; + State = 778; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,19,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 745; + State = 760; _localctx.primitive = simpleType(); _localctx.Value = Actions.CreatePrimitiveSerializationType(_localctx.primitive.Value); } @@ -2787,7 +2820,7 @@ public SerializTypeElementContext serializTypeElement() { case 2: EnterOuterAlt(_localctx, 2); { - State = 748; + State = 763; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateSerializationTypeTypedef(_localctx, _localctx.alias.Value); } @@ -2795,7 +2828,7 @@ public SerializTypeElementContext serializTypeElement() { case 3: EnterOuterAlt(_localctx, 3); { - State = 751; + State = 766; _localctx.simpleTypeToken = Match(TYPE); _localctx.Value = Actions.CreateSimpleSerializationType(_localctx.simpleTypeToken); } @@ -2803,7 +2836,7 @@ public SerializTypeElementContext serializTypeElement() { case 4: EnterOuterAlt(_localctx, 4); { - State = 753; + State = 768; _localctx.simpleTypeToken = Match(OBJECT); _localctx.Value = Actions.CreateSimpleSerializationType(_localctx.simpleTypeToken); } @@ -2811,11 +2844,11 @@ public SerializTypeElementContext serializTypeElement() { case 5: EnterOuterAlt(_localctx, 5); { - State = 755; + State = 770; Match(ENUM); - State = 756; + State = 771; Match(T__38); - State = 757; + State = 772; _localctx.quotedName = Match(SQSTRING); _localctx.Value = Actions.CreateEnumSerializationType(_localctx.quotedName); } @@ -2823,9 +2856,9 @@ public SerializTypeElementContext serializTypeElement() { case 6: EnterOuterAlt(_localctx, 6); { - State = 759; + State = 774; Match(ENUM); - State = 760; + State = 775; _localctx.classNameValue = className(); _localctx.Value = Actions.CreateEnumSerializationType(_localctx.classNameValue.Value); } @@ -2870,17 +2903,17 @@ public ModuleHeadContext moduleHead() { ModuleHeadContext _localctx = new ModuleHeadContext(Context, State); EnterRule(_localctx, 64, RULE_moduleHead); try { - State = 776; + State = 791; ErrorHandler.Sync(this); switch ( Interpreter.AdaptivePredict(TokenStream,20,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 765; + State = 780; Match(MODULE); - State = 766; + State = 781; Match(T__39); - State = 767; + State = 782; _localctx.name = dottedName(); Actions.SetModuleHeader(_localctx, _localctx.name.Value, true); } @@ -2888,9 +2921,9 @@ public ModuleHeadContext moduleHead() { case 2: EnterOuterAlt(_localctx, 2); { - State = 770; + State = 785; Match(MODULE); - State = 771; + State = 786; _localctx.name = dottedName(); Actions.SetModuleHeader(_localctx, _localctx.name.Value, false); } @@ -2898,7 +2931,7 @@ public ModuleHeadContext moduleHead() { case 3: EnterOuterAlt(_localctx, 3); { - State = 774; + State = 789; Match(MODULE); Actions.SetEmptyModuleHeader(_localctx); } @@ -2917,7 +2950,11 @@ public ModuleHeadContext moduleHead() { } public partial class VtfixupDeclContext : ParserRuleContext { + public object Value; public bool HasSyntaxError; + public Int32Context count; + public VtfixupAttrContext attributes; + public IdContext label; [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); } @@ -2944,24 +2981,28 @@ public override TResult Accept(IParseTreeVisitor visitor) { public VtfixupDeclContext vtfixupDecl() { VtfixupDeclContext _localctx = new VtfixupDeclContext(Context, State); EnterRule(_localctx, 66, RULE_vtfixupDecl); - BeginSubtree(); Actions.BeginSemanticRoot(_localctx); + BeginStreaming(); Actions.BeginSemanticRoot(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 778; + State = 793; Match(T__40); - State = 779; + State = 794; Match(T__41); - State = 780; - int32(); - State = 781; + State = 795; + _localctx.count = int32(); + State = 796; Match(T__42); - State = 782; - vtfixupAttr(0); - State = 783; + State = 797; + _localctx.attributes = vtfixupAttr(); + State = 798; Match(T__43); - State = 784; - id(); + State = 799; + _localctx.label = id(); + _localctx.Value = Actions.CreateVTableFixup( + (_localctx.count!=null?(_localctx.count.Start):null), + _localctx.attributes.Value, + (_localctx.label!=null?(_localctx.label.Start):null)); } } catch (RecognitionException re) { @@ -2977,11 +3018,14 @@ public VtfixupDeclContext vtfixupDecl() { } public partial class VtfixupAttrContext : ParserRuleContext { - [System.Diagnostics.DebuggerNonUserCode] public VtfixupAttrContext vtfixupAttr() { - return GetRuleContext(0); + public ushort Value; + public VtfixupAttrElementContext attribute; + [System.Diagnostics.DebuggerNonUserCode] public VtfixupAttrElementContext[] vtfixupAttrElement() { + return GetRuleContexts(); + } + [System.Diagnostics.DebuggerNonUserCode] public VtfixupAttrElementContext vtfixupAttrElement(int i) { + return GetRuleContext(i); } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT32_() { return GetToken(CILParser.INT32_, 0); } - [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT64_() { return GetToken(CILParser.INT64_, 0); } public VtfixupAttrContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { @@ -2997,93 +3041,79 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public VtfixupAttrContext vtfixupAttr() { - return vtfixupAttr(0); - } - - private VtfixupAttrContext vtfixupAttr(int _p) { - ParserRuleContext _parentctx = Context; - int _parentState = State; - VtfixupAttrContext _localctx = new VtfixupAttrContext(Context, _parentState); - VtfixupAttrContext _prevctx = _localctx; - int _startState = 68; - EnterRecursionRule(_localctx, 68, RULE_vtfixupAttr, _p); + VtfixupAttrContext _localctx = new VtfixupAttrContext(Context, State); + EnterRule(_localctx, 68, RULE_vtfixupAttr); + _localctx.Value = 0; + int _la; try { - int _alt; EnterOuterAlt(_localctx, 1); { - { - } - Context.Stop = TokenStream.LT(-1); - State = 799; + State = 807; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,22,Context); - while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - if ( ParseListeners!=null ) - TriggerExitRuleEvent(); - _prevctx = _localctx; - { - State = 797; - ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,21,Context) ) { - case 1: - { - _localctx = new VtfixupAttrContext(_parentctx, _parentState); - PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 787; - if (!(Precpred(Context, 5))) throw new FailedPredicateException(this, "Precpred(Context, 5)"); - State = 788; - Match(INT32_); - } - break; - case 2: - { - _localctx = new VtfixupAttrContext(_parentctx, _parentState); - PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 789; - if (!(Precpred(Context, 4))) throw new FailedPredicateException(this, "Precpred(Context, 4)"); - State = 790; - Match(INT64_); - } - break; - case 3: - { - _localctx = new VtfixupAttrContext(_parentctx, _parentState); - PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 791; - if (!(Precpred(Context, 3))) throw new FailedPredicateException(this, "Precpred(Context, 3)"); - State = 792; - Match(T__44); - } - break; - case 4: - { - _localctx = new VtfixupAttrContext(_parentctx, _parentState); - PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 793; - if (!(Precpred(Context, 2))) throw new FailedPredicateException(this, "Precpred(Context, 2)"); - State = 794; - Match(T__45); - } - break; - case 5: - { - _localctx = new VtfixupAttrContext(_parentctx, _parentState); - PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr); - State = 795; - if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)"); - State = 796; - Match(T__46); - } - break; - } - } + _la = TokenStream.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 246290604621824L) != 0) || _la==INT32_ || _la==INT64_) { + { + { + State = 802; + _localctx.attribute = vtfixupAttrElement(); + _localctx.Value = Actions.AddVTableFixupAttribute(_localctx.Value, _localctx.attribute.Value); } - State = 801; + } + State = 809; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,22,Context); + _la = TokenStream.LA(1); + } + _localctx.Value = Actions.CompleteVTableFixupAttributes(_localctx.Value); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class VtfixupAttrElementContext : ParserRuleContext { + public ushort Value; + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT32_() { return GetToken(CILParser.INT32_, 0); } + [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT64_() { return GetToken(CILParser.INT64_, 0); } + public VtfixupAttrElementContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_vtfixupAttrElement; } } + [System.Diagnostics.DebuggerNonUserCode] + public override TResult Accept(IParseTreeVisitor visitor) { + ICILVisitor typedVisitor = visitor as ICILVisitor; + if (typedVisitor != null) return typedVisitor.VisitVtfixupAttrElement(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public VtfixupAttrElementContext vtfixupAttrElement() { + VtfixupAttrElementContext _localctx = new VtfixupAttrElementContext(Context, State); + EnterRule(_localctx, 70, RULE_vtfixupAttrElement); + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 812; + _la = TokenStream.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 246290604621824L) != 0) || _la==INT32_ || _la==INT64_) ) { + ErrorHandler.RecoverInline(this); + } + else { + ErrorHandler.ReportMatch(this); + Consume(); } } + Context.Stop = TokenStream.LT(-1); + _localctx.Value = Actions.ParseVTableFixupAttribute(_localctx.Start); } catch (RecognitionException re) { _localctx.exception = re; @@ -3091,13 +3121,15 @@ private VtfixupAttrContext vtfixupAttr(int _p) { ErrorHandler.Recover(this, re); } finally { - UnrollRecursionContexts(_parentctx); + ExitRule(); } return _localctx; } public partial class VtableDeclContext : ParserRuleContext { + public object Value; public bool HasSyntaxError; + public BytesContext value; [System.Diagnostics.DebuggerNonUserCode] public BytesContext bytes() { return GetRuleContext(0); } @@ -3117,21 +3149,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public VtableDeclContext vtableDecl() { VtableDeclContext _localctx = new VtableDeclContext(Context, State); - EnterRule(_localctx, 70, RULE_vtableDecl); - BeginSubtree(); Actions.BeginSemanticRoot(_localctx); + EnterRule(_localctx, 72, RULE_vtableDecl); + BeginStreaming(); Actions.BeginSemanticRoot(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 802; + State = 814; Match(T__47); - State = 803; + State = 815; Match(T__35); - State = 804; + State = 816; Match(T__29); - State = 805; - bytes(); - State = 806; + State = 817; + _localctx.value = bytes(); + State = 818; Match(T__30); + _localctx.Value = Actions.CreateRawVTable(_localctx.value.Value); } } catch (RecognitionException re) { @@ -3168,14 +3201,14 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public NameSpaceHeadContext nameSpaceHead() { NameSpaceHeadContext _localctx = new NameSpaceHeadContext(Context, State); - EnterRule(_localctx, 72, RULE_nameSpaceHead); + EnterRule(_localctx, 74, RULE_nameSpaceHead); BeginStreaming(); Actions.BeginNamespaceHeader(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 808; + State = 821; Match(T__48); - State = 809; + State = 822; _localctx.name = dottedName(); _localctx.Value = _localctx.name.Value; } @@ -3235,38 +3268,38 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ClassHeadContext classHead() { ClassHeadContext _localctx = new ClassHeadContext(Context, State); - EnterRule(_localctx, 74, RULE_classHead); + EnterRule(_localctx, 76, RULE_classHead); BeginStreaming(); Actions.BeginClassHeader(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 812; + State = 825; Match(T__49); - State = 818; + State = 831; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,23,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,22,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 813; + State = 826; _localctx.attribute = classAttr(); Actions.AddClassHeaderAttribute(_localctx, _localctx.attribute.Value); } } } - State = 820; + State = 833; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,23,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,22,Context); } - State = 821; + State = 834; _localctx.name = dottedName(); - State = 822; + State = 835; _localctx.genericParameters = typarsClause(); - State = 823; + State = 836; _localctx.baseType = extendsClause(); - State = 824; + State = 837; _localctx.interfaces = implClause(); _localctx.Value = Actions.CreateClassHeader( _localctx, @@ -3320,15 +3353,15 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ClassAttrContext classAttr() { ClassAttrContext _localctx = new ClassAttrContext(Context, State); - EnterRule(_localctx, 76, RULE_classAttr); + EnterRule(_localctx, 78, RULE_classAttr); try { - State = 891; + State = 904; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,24,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,23,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 827; + State = 840; _localctx.attribute = Match(T__50); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3336,7 +3369,7 @@ public ClassAttrContext classAttr() { case 2: EnterOuterAlt(_localctx, 2); { - State = 829; + State = 842; _localctx.attribute = Match(T__51); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3344,7 +3377,7 @@ public ClassAttrContext classAttr() { case 3: EnterOuterAlt(_localctx, 3); { - State = 831; + State = 844; _localctx.attribute = Match(VALUE); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3352,7 +3385,7 @@ public ClassAttrContext classAttr() { case 4: EnterOuterAlt(_localctx, 4); { - State = 833; + State = 846; _localctx.attribute = Match(ENUM); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3360,7 +3393,7 @@ public ClassAttrContext classAttr() { case 5: EnterOuterAlt(_localctx, 5); { - State = 835; + State = 848; _localctx.attribute = Match(INTERFACE); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3368,7 +3401,7 @@ public ClassAttrContext classAttr() { case 6: EnterOuterAlt(_localctx, 6); { - State = 837; + State = 850; _localctx.attribute = Match(T__52); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3376,7 +3409,7 @@ public ClassAttrContext classAttr() { case 7: EnterOuterAlt(_localctx, 7); { - State = 839; + State = 852; _localctx.attribute = Match(T__53); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3384,7 +3417,7 @@ public ClassAttrContext classAttr() { case 8: EnterOuterAlt(_localctx, 8); { - State = 841; + State = 854; _localctx.attribute = Match(T__54); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3392,7 +3425,7 @@ public ClassAttrContext classAttr() { case 9: EnterOuterAlt(_localctx, 9); { - State = 843; + State = 856; _localctx.attribute = Match(T__55); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3400,7 +3433,7 @@ public ClassAttrContext classAttr() { case 10: EnterOuterAlt(_localctx, 10); { - State = 845; + State = 858; _localctx.attribute = Match(EXPLICIT); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3408,7 +3441,7 @@ public ClassAttrContext classAttr() { case 11: EnterOuterAlt(_localctx, 11); { - State = 847; + State = 860; _localctx.attribute = Match(T__14); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3416,7 +3449,7 @@ public ClassAttrContext classAttr() { case 12: EnterOuterAlt(_localctx, 12); { - State = 849; + State = 862; _localctx.attribute = Match(ANSI); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3424,7 +3457,7 @@ public ClassAttrContext classAttr() { case 13: EnterOuterAlt(_localctx, 13); { - State = 851; + State = 864; _localctx.attribute = Match(T__56); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3432,7 +3465,7 @@ public ClassAttrContext classAttr() { case 14: EnterOuterAlt(_localctx, 14); { - State = 853; + State = 866; _localctx.attribute = Match(T__57); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3440,7 +3473,7 @@ public ClassAttrContext classAttr() { case 15: EnterOuterAlt(_localctx, 15); { - State = 855; + State = 868; _localctx.attribute = Match(T__58); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3448,7 +3481,7 @@ public ClassAttrContext classAttr() { case 16: EnterOuterAlt(_localctx, 16); { - State = 857; + State = 870; _localctx.attribute = Match(T__59); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3456,7 +3489,7 @@ public ClassAttrContext classAttr() { case 17: EnterOuterAlt(_localctx, 17); { - State = 859; + State = 872; _localctx.attribute = Match(T__60); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3464,9 +3497,9 @@ public ClassAttrContext classAttr() { case 18: EnterOuterAlt(_localctx, 18); { - State = 861; + State = 874; Match(T__61); - State = 862; + State = 875; _localctx.visibility = Match(T__50); _localctx.Value = Actions.CreateNestedClassAttribute(_localctx.visibility); } @@ -3474,9 +3507,9 @@ public ClassAttrContext classAttr() { case 19: EnterOuterAlt(_localctx, 19); { - State = 864; + State = 877; Match(T__61); - State = 865; + State = 878; _localctx.visibility = Match(T__51); _localctx.Value = Actions.CreateNestedClassAttribute(_localctx.visibility); } @@ -3484,9 +3517,9 @@ public ClassAttrContext classAttr() { case 20: EnterOuterAlt(_localctx, 20); { - State = 867; + State = 880; Match(T__61); - State = 868; + State = 881; _localctx.visibility = Match(T__62); _localctx.Value = Actions.CreateNestedClassAttribute(_localctx.visibility); } @@ -3494,9 +3527,9 @@ public ClassAttrContext classAttr() { case 21: EnterOuterAlt(_localctx, 21); { - State = 870; + State = 883; Match(T__61); - State = 871; + State = 884; _localctx.visibility = Match(T__63); _localctx.Value = Actions.CreateNestedClassAttribute(_localctx.visibility); } @@ -3504,9 +3537,9 @@ public ClassAttrContext classAttr() { case 22: EnterOuterAlt(_localctx, 22); { - State = 873; + State = 886; Match(T__61); - State = 874; + State = 887; _localctx.visibility = Match(T__64); _localctx.Value = Actions.CreateNestedClassAttribute(_localctx.visibility); } @@ -3514,9 +3547,9 @@ public ClassAttrContext classAttr() { case 23: EnterOuterAlt(_localctx, 23); { - State = 876; + State = 889; Match(T__61); - State = 877; + State = 890; _localctx.visibility = Match(T__65); _localctx.Value = Actions.CreateNestedClassAttribute(_localctx.visibility); } @@ -3524,7 +3557,7 @@ public ClassAttrContext classAttr() { case 24: EnterOuterAlt(_localctx, 24); { - State = 879; + State = 892; _localctx.attribute = Match(T__66); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3532,7 +3565,7 @@ public ClassAttrContext classAttr() { case 25: EnterOuterAlt(_localctx, 25); { - State = 881; + State = 894; _localctx.attribute = Match(T__67); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3540,7 +3573,7 @@ public ClassAttrContext classAttr() { case 26: EnterOuterAlt(_localctx, 26); { - State = 883; + State = 896; _localctx.attribute = Match(T__68); _localctx.Value = Actions.CreateClassAttribute(_localctx.attribute); } @@ -3548,13 +3581,13 @@ public ClassAttrContext classAttr() { case 27: EnterOuterAlt(_localctx, 27); { - State = 885; + State = 898; Match(T__69); - State = 886; + State = 899; Match(T__29); - State = 887; + State = 900; _localctx.flags = int32(); - State = 888; + State = 901; Match(T__30); _localctx.Value = Actions.CreateRawClassAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } @@ -3594,10 +3627,10 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ExtendsClauseContext extendsClause() { ExtendsClauseContext _localctx = new ExtendsClauseContext(Context, State); - EnterRule(_localctx, 78, RULE_extendsClause); + EnterRule(_localctx, 80, RULE_extendsClause); _localctx.Value = Actions.CreateEmptyClassBase(); try { - State = 898; + State = 911; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -3609,9 +3642,9 @@ public ExtendsClauseContext extendsClause() { case T__70: EnterOuterAlt(_localctx, 2); { - State = 894; + State = 907; Match(T__70); - State = 895; + State = 908; _localctx.baseType = typeSpec(); _localctx.Value = Actions.CreateClassBase(_localctx.baseType.Value); } @@ -3653,10 +3686,10 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ImplClauseContext implClause() { ImplClauseContext _localctx = new ImplClauseContext(Context, State); - EnterRule(_localctx, 80, RULE_implClause); + EnterRule(_localctx, 82, RULE_implClause); _localctx.Value = Actions.CreateEmptyInterfaceList(); try { - State = 905; + State = 918; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -3667,9 +3700,9 @@ public ImplClauseContext implClause() { case T__71: EnterOuterAlt(_localctx, 2); { - State = 901; + State = 914; Match(T__71); - State = 902; + State = 915; _localctx.interfaces = implList(); _localctx.Value = _localctx.interfaces.Value; } @@ -3712,23 +3745,23 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ClassDeclsContext classDecls() { ClassDeclsContext _localctx = new ClassDeclsContext(Context, State); - EnterRule(_localctx, 82, RULE_classDecls); + EnterRule(_localctx, 84, RULE_classDecls); BeginStreaming(); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 910; + State = 923; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1125938695831552L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 1189425290649010179L) != 0) || ((((_la - 139)) & ~0x3f) == 0 && ((1L << (_la - 139)) & 1152921504673955841L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 871552083145265153L) != 0)) { { { - State = 907; + State = 920; classDecl(); } } - State = 912; + State = 925; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -3772,32 +3805,32 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ImplListContext implList() { ImplListContext _localctx = new ImplListContext(Context, State); - EnterRule(_localctx, 84, RULE_implList); + EnterRule(_localctx, 86, RULE_implList); Actions.BeginInterfaceList(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 919; + State = 932; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,28,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,27,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 913; + State = 926; _localctx.interfaceType = typeSpec(); Actions.AddInterfaceType(_localctx, _localctx.interfaceType.Value); - State = 915; + State = 928; Match(T__27); } } } - State = 921; + State = 934; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,28,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,27,Context); } - State = 922; + State = 935; _localctx.lastInterfaceType = typeSpec(); Actions.AddInterfaceType(_localctx, _localctx.lastInterfaceType.Value); } @@ -3832,12 +3865,12 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public EsHeadContext esHead() { EsHeadContext _localctx = new EsHeadContext(Context, State); - EnterRule(_localctx, 86, RULE_esHead); + EnterRule(_localctx, 88, RULE_esHead); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 925; + State = 938; _la = TokenStream.LA(1); if ( !(_la==T__72 || _la==T__73) ) { ErrorHandler.RecoverInline(this); @@ -3899,26 +3932,26 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ExtSourceSpecContext extSourceSpec() { ExtSourceSpecContext _localctx = new ExtSourceSpecContext(Context, State); - EnterRule(_localctx, 88, RULE_extSourceSpec); + EnterRule(_localctx, 90, RULE_extSourceSpec); BeginStreaming(); Actions.BeginSemanticRoot(_localctx); int _la; try { - State = 978; + State = 991; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,34,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,33,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 927; + State = 940; _localctx.head = esHead(); - State = 928; + State = 941; _localctx.line = int32(); - State = 930; + State = 943; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,29,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,28,Context) ) { case 1: { - State = 929; + State = 942; _localctx.path = TokenStream.LT(1); _la = TokenStream.LA(1); if ( !(_la==QSTRING || _la==SQSTRING) ) { @@ -3937,20 +3970,20 @@ public ExtSourceSpecContext extSourceSpec() { case 2: EnterOuterAlt(_localctx, 2); { - State = 934; + State = 947; _localctx.head = esHead(); - State = 935; + State = 948; _localctx.line = int32(); - State = 936; + State = 949; Match(T__74); - State = 937; + State = 950; _localctx.column = int32(); - State = 939; + State = 952; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,30,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,29,Context) ) { case 1: { - State = 938; + State = 951; _localctx.path = TokenStream.LT(1); _la = TokenStream.LA(1); if ( !(_la==QSTRING || _la==SQSTRING) ) { @@ -3969,24 +4002,24 @@ public ExtSourceSpecContext extSourceSpec() { case 3: EnterOuterAlt(_localctx, 3); { - State = 943; + State = 956; _localctx.head = esHead(); - State = 944; + State = 957; _localctx.line = int32(); - State = 945; + State = 958; Match(T__74); - State = 946; + State = 959; _localctx.startColumn = int32(); - State = 947; + State = 960; Match(T__27); - State = 948; + State = 961; _localctx.endColumn = int32(); - State = 950; + State = 963; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,31,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,30,Context) ) { case 1: { - State = 949; + State = 962; _localctx.path = TokenStream.LT(1); _la = TokenStream.LA(1); if ( !(_la==QSTRING || _la==SQSTRING) ) { @@ -4010,24 +4043,24 @@ public ExtSourceSpecContext extSourceSpec() { case 4: EnterOuterAlt(_localctx, 4); { - State = 954; + State = 967; _localctx.head = esHead(); - State = 955; + State = 968; _localctx.startLine = int32(); - State = 956; + State = 969; Match(T__27); - State = 957; + State = 970; _localctx.endLine = int32(); - State = 958; + State = 971; Match(T__74); - State = 959; + State = 972; _localctx.column = int32(); - State = 961; + State = 974; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,32,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,31,Context) ) { case 1: { - State = 960; + State = 973; _localctx.path = TokenStream.LT(1); _la = TokenStream.LA(1); if ( !(_la==QSTRING || _la==SQSTRING) ) { @@ -4051,28 +4084,28 @@ public ExtSourceSpecContext extSourceSpec() { case 5: EnterOuterAlt(_localctx, 5); { - State = 965; + State = 978; _localctx.head = esHead(); - State = 966; + State = 979; _localctx.startLine = int32(); - State = 967; + State = 980; Match(T__27); - State = 968; + State = 981; _localctx.endLine = int32(); - State = 969; + State = 982; Match(T__74); - State = 970; + State = 983; _localctx.startColumn = int32(); - State = 971; + State = 984; Match(T__27); - State = 972; + State = 985; _localctx.endColumn = int32(); - State = 974; + State = 987; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,33,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,32,Context) ) { case 1: { - State = 973; + State = 986; _localctx.path = TokenStream.LT(1); _la = TokenStream.LA(1); if ( !(_la==QSTRING || _la==SQSTRING) ) { @@ -4109,7 +4142,13 @@ public ExtSourceSpecContext extSourceSpec() { } public partial class FileDeclContext : ParserRuleContext { + public object Value; public bool HasSyntaxError; + public FileAttrContext attribute; + public DottedNameContext name; + public FileEntryContext entry; + public BytesContext hash; + public FileEntryContext trailingEntry; [System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() { return GetRuleContext(0); } @@ -4120,15 +4159,15 @@ [System.Diagnostics.DebuggerNonUserCode] public FileEntryContext fileEntry(int i return GetRuleContext(i); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode HASH() { return GetToken(CILParser.HASH, 0); } - [System.Diagnostics.DebuggerNonUserCode] public BytesContext bytes() { - return GetRuleContext(0); - } [System.Diagnostics.DebuggerNonUserCode] public FileAttrContext[] fileAttr() { return GetRuleContexts(); } [System.Diagnostics.DebuggerNonUserCode] public FileAttrContext fileAttr(int i) { return GetRuleContext(i); } + [System.Diagnostics.DebuggerNonUserCode] public BytesContext bytes() { + return GetRuleContext(0); + } public FileDeclContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { @@ -4145,75 +4184,57 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public FileDeclContext fileDecl() { FileDeclContext _localctx = new FileDeclContext(Context, State); - EnterRule(_localctx, 90, RULE_fileDecl); - BeginSubtree(); Actions.BeginSemanticRoot(_localctx); + EnterRule(_localctx, 92, RULE_fileDecl); + BeginStreaming(); Actions.BeginFileDeclaration(_localctx); int _la; try { - State = 1006; + EnterOuterAlt(_localctx, 1); + { + State = 993; + Match(T__20); + State = 999; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,37,Context) ) { - case 1: - EnterOuterAlt(_localctx, 1); + _la = TokenStream.LA(1); + while (_la==T__75) { { - State = 980; - Match(T__20); - State = 984; + { + State = 994; + _localctx.attribute = fileAttr(); + Actions.AddFileAttribute(_localctx, _localctx.attribute.Value); + } + } + State = 1001; ErrorHandler.Sync(this); _la = TokenStream.LA(1); - while (_la==T__75) { - { - { - State = 981; - fileAttr(); - } - } - State = 986; - ErrorHandler.Sync(this); - _la = TokenStream.LA(1); - } - State = 987; - dottedName(); - State = 988; - fileEntry(); - State = 989; + } + State = 1002; + _localctx.name = dottedName(); + Actions.SetFileName(_localctx, _localctx.name.Value); + State = 1004; + _localctx.entry = fileEntry(); + Actions.AddFileEntry(_localctx, _localctx.entry.Value); + State = 1015; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + if (_la==HASH) { + { + State = 1006; Match(HASH); - State = 990; + State = 1007; Match(T__35); - State = 991; + State = 1008; Match(T__29); - State = 992; - bytes(); - State = 993; + State = 1009; + _localctx.hash = bytes(); + State = 1010; Match(T__30); - State = 994; - fileEntry(); - } - break; - case 2: - EnterOuterAlt(_localctx, 2); - { - State = 996; - Match(T__20); - State = 1000; - ErrorHandler.Sync(this); - _la = TokenStream.LA(1); - while (_la==T__75) { - { - { - State = 997; - fileAttr(); - } - } - State = 1002; - ErrorHandler.Sync(this); - _la = TokenStream.LA(1); + Actions.SetFileHash(_localctx, _localctx.hash.Value); + State = 1012; + _localctx.trailingEntry = fileEntry(); + Actions.AddFileEntry(_localctx, _localctx.trailingEntry.Value); } - State = 1003; - dottedName(); - State = 1004; - fileEntry(); - } - break; + } + } } catch (RecognitionException re) { @@ -4222,13 +4243,14 @@ public FileDeclContext fileDecl() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); + Actions.EndFileDeclaration(_localctx); EndParseTreeMode(); ExitRule(); } return _localctx; } public partial class FileAttrContext : ParserRuleContext { + public bool Value; public FileAttrContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { @@ -4245,13 +4267,15 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public FileAttrContext fileAttr() { FileAttrContext _localctx = new FileAttrContext(Context, State); - EnterRule(_localctx, 92, RULE_fileAttr); + EnterRule(_localctx, 94, RULE_fileAttr); try { EnterOuterAlt(_localctx, 1); { - State = 1008; + State = 1017; Match(T__75); } + Context.Stop = TokenStream.LT(-1); + _localctx.Value = Actions.ParseFileAttribute(_localctx.Start); } catch (RecognitionException re) { _localctx.exception = re; @@ -4265,6 +4289,8 @@ public FileAttrContext fileAttr() { } public partial class FileEntryContext : ParserRuleContext { + public bool Value; + public IToken entry; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ENTRYPOINT() { return GetToken(CILParser.ENTRYPOINT, 0); } public FileEntryContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) @@ -4282,9 +4308,10 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public FileEntryContext fileEntry() { FileEntryContext _localctx = new FileEntryContext(Context, State); - EnterRule(_localctx, 94, RULE_fileEntry); + EnterRule(_localctx, 96, RULE_fileEntry); + _localctx.Value = false; try { - State = 1012; + State = 1022; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -4334,8 +4361,9 @@ public FileEntryContext fileEntry() { case ENTRYPOINT: EnterOuterAlt(_localctx, 2); { - State = 1011; - Match(ENTRYPOINT); + State = 1020; + _localctx.entry = Match(ENTRYPOINT); + _localctx.Value = Actions.ParseFileEntry(_localctx.entry); } break; default: @@ -4354,6 +4382,8 @@ public FileEntryContext fileEntry() { } public partial class AsmAttrAnyContext : ParserRuleContext { + public System.Reflection.AssemblyFlags Value; + public System.Reflection.AssemblyFlags Mask; public AsmAttrAnyContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { @@ -4370,12 +4400,12 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public AsmAttrAnyContext asmAttrAny() { AsmAttrAnyContext _localctx = new AsmAttrAnyContext(Context, State); - EnterRule(_localctx, 96, RULE_asmAttrAny); + EnterRule(_localctx, 98, RULE_asmAttrAny); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 1014; + State = 1024; _la = TokenStream.LA(1); if ( !(_la==T__1 || _la==T__60 || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 127L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -4385,6 +4415,8 @@ public AsmAttrAnyContext asmAttrAny() { Consume(); } } + Context.Stop = TokenStream.LT(-1); + Actions.SetAssemblyAttribute(_localctx); } catch (RecognitionException re) { _localctx.exception = re; @@ -4398,6 +4430,8 @@ public AsmAttrAnyContext asmAttrAny() { } public partial class AsmAttrContext : ParserRuleContext { + public System.Reflection.AssemblyFlags Value; + public AsmAttrAnyContext attribute; [System.Diagnostics.DebuggerNonUserCode] public AsmAttrAnyContext[] asmAttrAny() { return GetRuleContexts(); } @@ -4420,22 +4454,27 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public AsmAttrContext asmAttr() { AsmAttrContext _localctx = new AsmAttrContext(Context, State); - EnterRule(_localctx, 98, RULE_asmAttr); + EnterRule(_localctx, 100, RULE_asmAttr); + _localctx.Value = 0; int _la; try { EnterOuterAlt(_localctx, 1); { - State = 1019; + State = 1031; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__1 || _la==T__60 || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 127L) != 0)) { { { - State = 1016; - asmAttrAny(); + State = 1026; + _localctx.attribute = asmAttrAny(); + _localctx.Value = Actions.AddAssemblyAttribute( + _localctx.Value, + _localctx.attribute.Value, + _localctx.attribute.Mask); } } - State = 1021; + State = 1033; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -4502,24 +4541,24 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public InstrContext instr() { InstrContext _localctx = new InstrContext(Context, State); - EnterRule(_localctx, 100, RULE_instr); + EnterRule(_localctx, 102, RULE_instr); try { - State = 1047; + State = 1059; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,40,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,38,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1022; + State = 1034; simpleInstr(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 1023; + State = 1035; _localctx.op = Match(INSTR_METHOD); - State = 1024; + State = 1036; _localctx.methodOperand = methodRef(); Actions.EmitMethodReferenceInstruction(_localctx.op, _localctx.methodOperand); } @@ -4527,9 +4566,9 @@ public InstrContext instr() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1027; + State = 1039; _localctx.op = Match(INSTR_FIELD); - State = 1028; + State = 1040; _localctx.fieldOperand = fieldRef(); Actions.EmitFieldReferenceInstruction(_localctx.op, _localctx.fieldOperand); } @@ -4537,9 +4576,9 @@ public InstrContext instr() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1031; + State = 1043; _localctx.op = Match(INSTR_FIELD); - State = 1032; + State = 1044; _localctx.metadataOperand = mdtoken(); Actions.EmitMetadataTokenInstruction(_localctx.op, _localctx.metadataOperand); } @@ -4547,9 +4586,9 @@ public InstrContext instr() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1035; + State = 1047; _localctx.op = Match(INSTR_TYPE); - State = 1036; + State = 1048; _localctx.typeOperand = typeSpec(); Actions.EmitTypeReferenceInstruction(_localctx.op, _localctx.typeOperand); } @@ -4557,9 +4596,9 @@ public InstrContext instr() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1039; + State = 1051; _localctx.op = Match(INSTR_SIG); - State = 1040; + State = 1052; _localctx.signatureOperand = calliSignature(); Actions.EmitCalliInstruction(_localctx.op, _localctx.signatureOperand); } @@ -4567,9 +4606,9 @@ public InstrContext instr() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1043; + State = 1055; _localctx.op = Match(INSTR_TOK); - State = 1044; + State = 1056; _localctx.ownerOperand = ownerType(); Actions.EmitOwnerTokenInstruction(_localctx.op, _localctx.ownerOperand); } @@ -4649,15 +4688,15 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SimpleInstrContext simpleInstr() { SimpleInstrContext _localctx = new SimpleInstrContext(Context, State); - EnterRule(_localctx, 102, RULE_simpleInstr); + EnterRule(_localctx, 104, RULE_simpleInstr); try { - State = 1127; + State = 1139; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,42,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,40,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1049; + State = 1061; _localctx.op = Match(INSTR_NONE); Actions.EmitNoOperandInstruction(_localctx.op); } @@ -4665,9 +4704,9 @@ public SimpleInstrContext simpleInstr() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1051; + State = 1063; _localctx.op = Match(INSTR_VAR); - State = 1052; + State = 1064; _localctx.index = int32(); Actions.EmitVariableIndexInstruction(_localctx.op, (_localctx.index!=null?(_localctx.index.Start):null)); } @@ -4675,9 +4714,9 @@ public SimpleInstrContext simpleInstr() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1055; + State = 1067; _localctx.op = Match(INSTR_VAR); - State = 1056; + State = 1068; _localctx.name = id(); Actions.EmitVariableNameInstruction(_localctx.op, (_localctx.name!=null?(_localctx.name.Start):null)); } @@ -4685,9 +4724,9 @@ public SimpleInstrContext simpleInstr() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1059; + State = 1071; _localctx.op = Match(INSTR_I); - State = 1060; + State = 1072; _localctx.value32 = int32(); Actions.EmitInt32Instruction(_localctx.op, (_localctx.value32!=null?(_localctx.value32.Start):null)); } @@ -4695,9 +4734,9 @@ public SimpleInstrContext simpleInstr() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1063; + State = 1075; _localctx.op = Match(INSTR_I8); - State = 1064; + State = 1076; _localctx.value64 = int64(); Actions.EmitInt64Instruction(_localctx.op, (_localctx.value64!=null?(_localctx.value64.Start):null)); } @@ -4705,9 +4744,9 @@ public SimpleInstrContext simpleInstr() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1067; + State = 1079; _localctx.op = Match(INSTR_R); - State = 1068; + State = 1080; _localctx.value = float64(); Actions.EmitFloatingInstruction(_localctx.op, _localctx.value.Value); } @@ -4715,9 +4754,9 @@ public SimpleInstrContext simpleInstr() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1071; + State = 1083; _localctx.op = Match(INSTR_R); - State = 1072; + State = 1084; _localctx.integerValue = int64(); Actions.EmitFloatingInstruction(_localctx.op, (_localctx.integerValue!=null?(_localctx.integerValue.Start):null)); } @@ -4725,13 +4764,13 @@ public SimpleInstrContext simpleInstr() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1075; + State = 1087; _localctx.op = Match(INSTR_R); - State = 1076; + State = 1088; Match(T__29); - State = 1077; + State = 1089; _localctx.rawFloat = bytes(); - State = 1078; + State = 1090; Match(T__30); Actions.EmitRawFloatingInstruction(_localctx.op, _localctx.rawFloat.Value, (_localctx.rawFloat!=null?(_localctx.rawFloat.Start):null)); } @@ -4739,15 +4778,15 @@ public SimpleInstrContext simpleInstr() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1081; + State = 1093; _localctx.op = Match(INSTR_R); - State = 1082; + State = 1094; Match(T__83); - State = 1083; + State = 1095; Match(T__29); - State = 1084; + State = 1096; _localctx.rawFloat = bytes(); - State = 1085; + State = 1097; Match(T__30); Actions.EmitRawFloatingInstruction(_localctx.op, _localctx.rawFloat.Value, (_localctx.rawFloat!=null?(_localctx.rawFloat.Start):null)); } @@ -4755,9 +4794,9 @@ public SimpleInstrContext simpleInstr() { case 10: EnterOuterAlt(_localctx, 10); { - State = 1088; + State = 1100; _localctx.op = Match(INSTR_BRTARGET); - State = 1089; + State = 1101; _localctx.offset = int32(); Actions.EmitBranchOffsetInstruction(_localctx.op, (_localctx.offset!=null?(_localctx.offset.Start):null)); } @@ -4765,9 +4804,9 @@ public SimpleInstrContext simpleInstr() { case 11: EnterOuterAlt(_localctx, 11); { - State = 1092; + State = 1104; _localctx.op = Match(INSTR_BRTARGET); - State = 1093; + State = 1105; _localctx.label = id(); Actions.EmitBranchLabelInstruction(_localctx.op, (_localctx.label!=null?(_localctx.label.Start):null)); } @@ -4775,9 +4814,9 @@ public SimpleInstrContext simpleInstr() { case 12: EnterOuterAlt(_localctx, 12); { - State = 1096; + State = 1108; _localctx.op = Match(INSTR_STRING); - State = 1097; + State = 1109; _localctx.userString = compQstring(); Actions.EmitStringInstruction(_localctx.op, _localctx.userString.Value); } @@ -4785,15 +4824,15 @@ public SimpleInstrContext simpleInstr() { case 13: EnterOuterAlt(_localctx, 13); { - State = 1100; + State = 1112; _localctx.op = Match(INSTR_STRING); - State = 1101; + State = 1113; Match(ANSI); - State = 1102; + State = 1114; Match(T__29); - State = 1103; + State = 1115; _localctx.ansiString = compQstring(); - State = 1104; + State = 1116; Match(T__30); Actions.EmitAnsiStringInstruction(_localctx.op, _localctx.ansiString.Value); } @@ -4801,15 +4840,15 @@ public SimpleInstrContext simpleInstr() { case 14: EnterOuterAlt(_localctx, 14); { - State = 1107; + State = 1119; _localctx.op = Match(INSTR_STRING); - State = 1108; + State = 1120; Match(T__83); - State = 1109; + State = 1121; Match(T__29); - State = 1110; + State = 1122; _localctx.rawString = bytes(); - State = 1111; + State = 1123; Match(T__30); Actions.EmitRawStringInstruction(_localctx.op, _localctx.rawString.Value); } @@ -4817,9 +4856,9 @@ public SimpleInstrContext simpleInstr() { case 15: EnterOuterAlt(_localctx, 15); { - State = 1114; + State = 1126; _localctx.op = Match(INSTR_TOK); - State = 1115; + State = 1127; _localctx.rawToken = int32(); Actions.EmitRawTokenInstruction(_localctx.op, (_localctx.rawToken!=null?(_localctx.rawToken.Start):null)); } @@ -4827,25 +4866,25 @@ public SimpleInstrContext simpleInstr() { case 16: EnterOuterAlt(_localctx, 16); { - State = 1118; + State = 1130; _localctx.op = Match(INSTR_SWITCH); Actions.BeginSwitchInstruction(_localctx, _localctx.op); - State = 1125; + State = 1137; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__29: { - State = 1120; + State = 1132; Match(T__29); - State = 1121; + State = 1133; labels(); - State = 1122; + State = 1134; Match(T__30); } break; case T__84: { - State = 1124; + State = 1136; Match(T__84); } break; @@ -4901,16 +4940,16 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public CalliSignatureContext calliSignature() { CalliSignatureContext _localctx = new CalliSignatureContext(Context, State); - EnterRule(_localctx, 104, RULE_calliSignature); + EnterRule(_localctx, 106, RULE_calliSignature); Actions.BeginSemanticRoot(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 1129; + State = 1141; _localctx.convention = callConv(); - State = 1130; + State = 1142; _localctx.returnType = type(); - State = 1131; + State = 1143; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateCalliSignature(_localctx.convention.Value, _localctx.returnType.Value, _localctx.arguments.Value); } @@ -4960,10 +4999,10 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public LabelsContext labels() { LabelsContext _localctx = new LabelsContext(Context, State); - EnterRule(_localctx, 106, RULE_labels); + EnterRule(_localctx, 108, RULE_labels); try { int _alt; - State = 1158; + State = 1170; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__30: @@ -4994,14 +5033,14 @@ public LabelsContext labels() { case ID: EnterOuterAlt(_localctx, 2); { - State = 1147; + State = 1159; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,44,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,42,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1141; + State = 1153; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -5025,14 +5064,14 @@ public LabelsContext labels() { case SQSTRING: case ID: { - State = 1135; + State = 1147; _localctx.headLabel = id(); Actions.AddSwitchLabel((_localctx.headLabel!=null?(_localctx.headLabel.Start):null)); } break; case INT32: { - State = 1138; + State = 1150; _localctx.headOffset = int32(); Actions.AddSwitchOffset((_localctx.headOffset!=null?(_localctx.headOffset.Start):null)); } @@ -5040,16 +5079,16 @@ public LabelsContext labels() { default: throw new NoViableAltException(this); } - State = 1143; + State = 1155; Match(T__27); } } } - State = 1149; + State = 1161; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,44,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,42,Context); } - State = 1156; + State = 1168; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -5073,14 +5112,14 @@ public LabelsContext labels() { case SQSTRING: case ID: { - State = 1150; + State = 1162; _localctx.tailLabel = id(); Actions.AddSwitchLabel((_localctx.tailLabel!=null?(_localctx.tailLabel.Start):null)); } break; case INT32: { - State = 1153; + State = 1165; _localctx.tailOffset = int32(); Actions.AddSwitchOffset((_localctx.tailOffset!=null?(_localctx.tailOffset.Start):null)); } @@ -5131,37 +5170,37 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TypeArgsContext typeArgs() { TypeArgsContext _localctx = new TypeArgsContext(Context, State); - EnterRule(_localctx, 108, RULE_typeArgs); + EnterRule(_localctx, 110, RULE_typeArgs); Actions.BeginTypeArguments(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1160; + State = 1172; Match(T__85); - State = 1167; + State = 1179; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,47,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,45,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1161; + State = 1173; _localctx.argument = type(); Actions.AddTypeArgument(_localctx, _localctx.argument.Value); - State = 1163; + State = 1175; Match(T__27); } } } - State = 1169; + State = 1181; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,47,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,45,Context); } - State = 1170; + State = 1182; _localctx.lastArgument = type(); Actions.AddTypeArgument(_localctx, _localctx.lastArgument.Value); - State = 1172; + State = 1184; Match(T__86); } } @@ -5203,37 +5242,37 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public BoundsContext bounds() { BoundsContext _localctx = new BoundsContext(Context, State); - EnterRule(_localctx, 110, RULE_bounds); + EnterRule(_localctx, 112, RULE_bounds); Actions.BeginBounds(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1174; + State = 1186; Match(T__41); - State = 1181; + State = 1193; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,48,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,46,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1175; + State = 1187; _localctx.item = bound(); Actions.AddBound(_localctx, _localctx.item); - State = 1177; + State = 1189; Match(T__27); } } } - State = 1183; + State = 1195; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,48,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,46,Context); } - State = 1184; + State = 1196; _localctx.lastItem = bound(); Actions.AddBound(_localctx, _localctx.lastItem); - State = 1186; + State = 1198; Match(T__42); } } @@ -5275,48 +5314,48 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SigArgsContext sigArgs() { SigArgsContext _localctx = new SigArgsContext(Context, State); - EnterRule(_localctx, 112, RULE_sigArgs); + EnterRule(_localctx, 114, RULE_sigArgs); Actions.BeginSignatureArguments(_localctx); try { int _alt; - State = 1203; + State = 1215; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__29: EnterOuterAlt(_localctx, 1); { - State = 1188; + State = 1200; Match(T__29); - State = 1195; + State = 1207; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,49,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,47,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1189; + State = 1201; _localctx.argument = sigArg(); Actions.AddSignatureArgument(_localctx, _localctx.argument.Value); - State = 1191; + State = 1203; Match(T__27); } } } - State = 1197; + State = 1209; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,49,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,47,Context); } - State = 1198; + State = 1210; _localctx.lastArgument = sigArg(); Actions.AddSignatureArgument(_localctx, _localctx.lastArgument.Value); - State = 1200; + State = 1212; Match(T__30); } break; case T__84: EnterOuterAlt(_localctx, 2); { - State = 1202; + State = 1214; Match(T__84); } break; @@ -5371,16 +5410,16 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SigArgContext sigArg() { SigArgContext _localctx = new SigArgContext(Context, State); - EnterRule(_localctx, 114, RULE_sigArg); + EnterRule(_localctx, 116, RULE_sigArg); int _la; try { - State = 1215; + State = 1227; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,52,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,50,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1205; + State = 1217; Match(ELLIPSIS); _localctx.Value = Actions.CreateSentinelSignatureArgument(); } @@ -5388,18 +5427,18 @@ public SigArgContext sigArg() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1207; + State = 1219; _localctx.attributes = paramAttr(); - State = 1208; + State = 1220; _localctx.argumentType = type(); - State = 1209; + State = 1221; _localctx.marshalling = marshalClause(); - State = 1211; + State = 1223; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 65534L) != 0) || ((((_la - 199)) & ~0x3f) == 0 && ((1L << (_la - 199)) & 299067162755073L) != 0) || _la==SQSTRING || _la==ID) { { - State = 1210; + State = 1222; _localctx.name = id(); } } @@ -5457,21 +5496,21 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ClassNameContext className() { ClassNameContext _localctx = new ClassNameContext(Context, State); - EnterRule(_localctx, 116, RULE_className); + EnterRule(_localctx, 118, RULE_className); try { - State = 1254; + State = 1266; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,53,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,51,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1217; + State = 1229; Match(T__41); - State = 1218; + State = 1230; _localctx.assemblyName = dottedName(); - State = 1219; + State = 1231; Match(T__42); - State = 1220; + State = 1232; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreateAssemblyQualifiedClassName(_localctx.assemblyName.Value, _localctx.typeName.Value); } @@ -5479,13 +5518,13 @@ public ClassNameContext className() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1223; + State = 1235; Match(T__41); - State = 1224; + State = 1236; _localctx.scopeToken = mdtoken(); - State = 1225; + State = 1237; Match(T__42); - State = 1226; + State = 1238; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreateTokenQualifiedClassName(_localctx.scopeToken.Value, _localctx.typeName.Value); } @@ -5493,13 +5532,13 @@ public ClassNameContext className() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1229; + State = 1241; Match(T__41); - State = 1230; + State = 1242; Match(PTR); - State = 1231; + State = 1243; Match(T__42); - State = 1232; + State = 1244; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreatePointerQualifiedClassName(_localctx.typeName.Value); } @@ -5507,15 +5546,15 @@ public ClassNameContext className() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1235; + State = 1247; Match(T__41); - State = 1236; + State = 1248; Match(MODULE); - State = 1237; + State = 1249; _localctx.moduleName = dottedName(); - State = 1238; + State = 1250; Match(T__42); - State = 1239; + State = 1251; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreateModuleQualifiedClassName(_localctx.Start, _localctx.moduleName.Value, _localctx.typeName.Value); } @@ -5523,7 +5562,7 @@ public ClassNameContext className() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1242; + State = 1254; _localctx.typeName = slashedName(); _localctx.Value = Actions.CreateUnqualifiedClassName(_localctx.typeName.Value); } @@ -5531,7 +5570,7 @@ public ClassNameContext className() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1245; + State = 1257; _localctx.typeToken = mdtoken(); _localctx.Value = Actions.CreateTokenClassName(_localctx.typeToken.Value); } @@ -5539,7 +5578,7 @@ public ClassNameContext className() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1248; + State = 1260; Match(THIS); _localctx.Value = Actions.CreateThisClassName(_localctx.Start); } @@ -5547,7 +5586,7 @@ public ClassNameContext className() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1250; + State = 1262; Match(BASE); _localctx.Value = Actions.CreateBaseClassName(_localctx.Start); } @@ -5555,7 +5594,7 @@ public ClassNameContext className() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1252; + State = 1264; Match(NESTER); _localctx.Value = Actions.CreateNesterClassName(_localctx.Start); } @@ -5599,32 +5638,32 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SlashedNameContext slashedName() { SlashedNameContext _localctx = new SlashedNameContext(Context, State); - EnterRule(_localctx, 118, RULE_slashedName); + EnterRule(_localctx, 120, RULE_slashedName); Actions.BeginSlashedName(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1262; + State = 1274; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,54,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,52,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1256; + State = 1268; _localctx.part = dottedName(); Actions.AddSlashedNamePart(_localctx, _localctx.part.Value); - State = 1258; + State = 1270; Match(T__87); } } } - State = 1264; + State = 1276; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,54,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,52,Context); } - State = 1265; + State = 1277; _localctx.lastPart = dottedName(); Actions.AddSlashedNamePart(_localctx, _localctx.lastPart.Value); } @@ -5642,6 +5681,8 @@ public SlashedNameContext slashedName() { } public partial class AssemblyDeclsContext : ParserRuleContext { + public object Value; + public AssemblyDeclContext declaration; [System.Diagnostics.DebuggerNonUserCode] public AssemblyDeclContext[] assemblyDecl() { return GetRuleContexts(); } @@ -5664,22 +5705,24 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public AssemblyDeclsContext assemblyDecls() { AssemblyDeclsContext _localctx = new AssemblyDeclsContext(Context, State); - EnterRule(_localctx, 120, RULE_assemblyDecls); + EnterRule(_localctx, 122, RULE_assemblyDecls); + Actions.BeginAssemblyDeclarations(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 1271; + State = 1285; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38654771200L) != 0) || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & 4294975503L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 6860954690125825L) != 0)) { { { - State = 1268; - assemblyDecl(); + State = 1280; + _localctx.declaration = assemblyDecl(); + Actions.AddAssemblyDeclaration(_localctx, _localctx.declaration.Value); } } - State = 1273; + State = 1287; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -5691,12 +5734,17 @@ public AssemblyDeclsContext assemblyDecls() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndAssemblyDeclarations(_localctx); ExitRule(); } return _localctx; } public partial class AssemblyDeclContext : ParserRuleContext { + public object Value; + public Int32Context algorithm; + public SecDeclContext security; + public AsmOrRefDeclContext shared; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode HASH() { return GetToken(CILParser.HASH, 0); } [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); @@ -5723,30 +5771,32 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public AssemblyDeclContext assemblyDecl() { AssemblyDeclContext _localctx = new AssemblyDeclContext(Context, State); - EnterRule(_localctx, 122, RULE_assemblyDecl); + EnterRule(_localctx, 124, RULE_assemblyDecl); try { - State = 1279; + State = 1299; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case HASH: EnterOuterAlt(_localctx, 1); { - { - State = 1274; + State = 1288; Match(HASH); - State = 1275; + State = 1289; Match(T__88); - State = 1276; - int32(); - } + State = 1290; + _localctx.algorithm = int32(); + _localctx.Value = Actions.CreateAssemblyHashAlgorithmDeclaration((_localctx.algorithm!=null?(_localctx.algorithm.Start):null)); } break; case PERMISSION: case PERMISSIONSET: EnterOuterAlt(_localctx, 2); { - State = 1277; - secDecl(); + State = 1293; + _localctx.security = secDecl(); + _localctx.Value = Actions.CreateAssemblySecurityDeclaration( + _localctx.security.Value, + (_localctx.security!=null?(_localctx.security.Start):null)); } break; case T__15: @@ -5770,8 +5820,9 @@ public AssemblyDeclContext assemblyDecl() { case ID: EnterOuterAlt(_localctx, 3); { - State = 1278; - asmOrRefDecl(); + State = 1296; + _localctx.shared = asmOrRefDecl(); + _localctx.Value = _localctx.shared.Value; } break; default: @@ -5822,16 +5873,16 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TypeSpecContext typeSpec() { TypeSpecContext _localctx = new TypeSpecContext(Context, State); - EnterRule(_localctx, 124, RULE_typeSpec); + EnterRule(_localctx, 126, RULE_typeSpec); Actions.BeginSemanticRoot(_localctx); try { - State = 1298; + State = 1318; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,57,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,55,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1281; + State = 1301; _localctx.classType = className(); _localctx.Value = Actions.CreateClassTypeSpecification(_localctx.classType.Value); } @@ -5839,11 +5890,11 @@ public TypeSpecContext typeSpec() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1284; + State = 1304; Match(T__41); - State = 1285; + State = 1305; _localctx.assemblyName = dottedName(); - State = 1286; + State = 1306; Match(T__42); _localctx.Value = Actions.CreateAssemblyTypeSpecification(_localctx.assemblyName.Value); } @@ -5851,13 +5902,13 @@ public TypeSpecContext typeSpec() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1289; + State = 1309; Match(T__41); - State = 1290; + State = 1310; Match(MODULE); - State = 1291; + State = 1311; _localctx.moduleName = dottedName(); - State = 1292; + State = 1312; Match(T__42); _localctx.Value = Actions.CreateModuleTypeSpecification(_localctx.moduleName.Value); } @@ -5865,7 +5916,7 @@ public TypeSpecContext typeSpec() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1295; + State = 1315; _localctx.signatureType = type(); _localctx.Value = Actions.CreateSignatureTypeSpecification(_localctx.signatureType.Value); } @@ -5913,13 +5964,13 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public NativeTypeContext nativeType() { NativeTypeContext _localctx = new NativeTypeContext(Context, State); - EnterRule(_localctx, 126, RULE_nativeType); + EnterRule(_localctx, 128, RULE_nativeType); Actions.BeginNativeType(_localctx); try { int _alt; - State = 1311; + State = 1331; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,59,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,57,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -5928,25 +5979,25 @@ public NativeTypeContext nativeType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1301; + State = 1321; _localctx.element = nativeTypeElement(); Actions.SetNativeTypeElement(_localctx, _localctx.element.Value); - State = 1308; + State = 1328; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,58,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,56,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1303; + State = 1323; _localctx.info = nativeTypeArrayPointerInfo(); Actions.AddNativeTypeArrayPointerInfo(_localctx, _localctx.info.Value); } } } - State = 1310; + State = 1330; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,58,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,56,Context); } } break; @@ -6047,16 +6098,16 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { NativeTypeArrayPointerInfoContext _localctx = new NativeTypeArrayPointerInfoContext(Context, State); - EnterRule(_localctx, 128, RULE_nativeTypeArrayPointerInfo); + EnterRule(_localctx, 130, RULE_nativeTypeArrayPointerInfo); try { - State = 1335; + State = 1355; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,60,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,58,Context) ) { case 1: _localctx = new PointerNativeTypeContext(_localctx); EnterOuterAlt(_localctx, 1); { - State = 1313; + State = 1333; Match(PTR); _localctx.Value = Actions.CreatePointerNativeType(); } @@ -6065,7 +6116,7 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeNoSizeDataContext(_localctx); EnterOuterAlt(_localctx, 2); { - State = 1315; + State = 1335; Match(ARRAY_TYPE_NO_BOUNDS); _localctx.Value = Actions.CreatePointerArrayTypeNoSizeData(); } @@ -6074,11 +6125,11 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeSizeContext(_localctx); EnterOuterAlt(_localctx, 3); { - State = 1317; + State = 1337; Match(T__41); - State = 1318; + State = 1338; ((PointerArrayTypeSizeContext)_localctx).size = int32(); - State = 1319; + State = 1339; Match(T__42); _localctx.Value = Actions.CreatePointerArrayTypeSize((((PointerArrayTypeSizeContext)_localctx).size!=null?(((PointerArrayTypeSizeContext)_localctx).size.Start):null)); } @@ -6087,15 +6138,15 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeSizeParamIndexContext(_localctx); EnterOuterAlt(_localctx, 4); { - State = 1322; + State = 1342; Match(T__41); - State = 1323; + State = 1343; ((PointerArrayTypeSizeParamIndexContext)_localctx).size = int32(); - State = 1324; + State = 1344; Match(PLUS); - State = 1325; + State = 1345; ((PointerArrayTypeSizeParamIndexContext)_localctx).parameterIndex = int32(); - State = 1326; + State = 1346; Match(T__42); _localctx.Value = Actions.CreatePointerArrayTypeSizeParamIndex((((PointerArrayTypeSizeParamIndexContext)_localctx).size!=null?(((PointerArrayTypeSizeParamIndexContext)_localctx).size.Start):null), (((PointerArrayTypeSizeParamIndexContext)_localctx).parameterIndex!=null?(((PointerArrayTypeSizeParamIndexContext)_localctx).parameterIndex.Start):null)); } @@ -6104,13 +6155,13 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { _localctx = new PointerArrayTypeParamIndexContext(_localctx); EnterOuterAlt(_localctx, 5); { - State = 1329; + State = 1349; Match(T__41); - State = 1330; + State = 1350; Match(PLUS); - State = 1331; + State = 1351; ((PointerArrayTypeParamIndexContext)_localctx).parameterIndex = int32(); - State = 1332; + State = 1352; Match(T__42); _localctx.Value = Actions.CreatePointerArrayTypeParamIndex((((PointerArrayTypeParamIndexContext)_localctx).parameterIndex!=null?(((PointerArrayTypeParamIndexContext)_localctx).parameterIndex.Start):null)); } @@ -6220,11 +6271,11 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public NativeTypeElementContext nativeTypeElement() { NativeTypeElementContext _localctx = new NativeTypeElementContext(Context, State); - EnterRule(_localctx, 130, RULE_nativeTypeElement); + EnterRule(_localctx, 132, RULE_nativeTypeElement); try { - State = 1482; + State = 1502; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,61,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,59,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -6234,25 +6285,25 @@ public NativeTypeElementContext nativeTypeElement() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1338; + State = 1358; _localctx.marshalType = Match(CUSTOM); - State = 1339; + State = 1359; Match(T__29); - State = 1340; + State = 1360; _localctx.guid = compQstring(); - State = 1341; + State = 1361; Match(T__27); - State = 1342; + State = 1362; _localctx.nativeTypeName = compQstring(); - State = 1343; + State = 1363; Match(T__27); - State = 1344; + State = 1364; _localctx.marshallerType = compQstring(); - State = 1345; + State = 1365; Match(T__27); - State = 1346; + State = 1366; _localctx.cookie = compQstring(); - State = 1347; + State = 1367; Match(T__30); _localctx.Value = Actions.CreateDeprecatedCustomMarshallerNativeType( _localctx, _localctx.guid.Value, _localctx.nativeTypeName.Value, _localctx.marshallerType.Value, _localctx.cookie.Value); @@ -6261,17 +6312,17 @@ public NativeTypeElementContext nativeTypeElement() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1350; + State = 1370; _localctx.marshalType = Match(CUSTOM); - State = 1351; + State = 1371; Match(T__29); - State = 1352; + State = 1372; _localctx.marshallerType = compQstring(); - State = 1353; + State = 1373; Match(T__27); - State = 1354; + State = 1374; _localctx.cookie = compQstring(); - State = 1355; + State = 1375; Match(T__30); _localctx.Value = Actions.CreateCustomMarshallerNativeType(_localctx.marshallerType.Value, _localctx.cookie.Value); } @@ -6279,15 +6330,15 @@ public NativeTypeElementContext nativeTypeElement() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1358; + State = 1378; Match(FIXED); - State = 1359; + State = 1379; _localctx.marshalType = Match(SYSSTRING); - State = 1360; + State = 1380; Match(T__41); - State = 1361; + State = 1381; _localctx.size = int32(); - State = 1362; + State = 1382; Match(T__42); _localctx.Value = Actions.CreateFixedSysStringNativeType((_localctx.size!=null?(_localctx.size.Start):null)); } @@ -6295,17 +6346,17 @@ public NativeTypeElementContext nativeTypeElement() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1365; + State = 1385; Match(FIXED); - State = 1366; + State = 1386; _localctx.marshalType = Match(ARRAY); - State = 1367; + State = 1387; Match(T__41); - State = 1368; + State = 1388; _localctx.size = int32(); - State = 1369; + State = 1389; Match(T__42); - State = 1370; + State = 1390; _localctx.element = nativeType(); _localctx.Value = Actions.CreateFixedArrayNativeType((_localctx.size!=null?(_localctx.size.Start):null), _localctx.element.Value); } @@ -6313,7 +6364,7 @@ public NativeTypeElementContext nativeTypeElement() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1373; + State = 1393; _localctx.marshalType = Match(VARIANT); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6321,7 +6372,7 @@ public NativeTypeElementContext nativeTypeElement() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1375; + State = 1395; _localctx.marshalType = Match(CURRENCY); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6329,7 +6380,7 @@ public NativeTypeElementContext nativeTypeElement() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1377; + State = 1397; _localctx.marshalType = Match(SYSCHAR); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6337,7 +6388,7 @@ public NativeTypeElementContext nativeTypeElement() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1379; + State = 1399; _localctx.marshalType = Match(VOID); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6345,7 +6396,7 @@ public NativeTypeElementContext nativeTypeElement() { case 10: EnterOuterAlt(_localctx, 10); { - State = 1381; + State = 1401; _localctx.marshalType = Match(BOOL); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6353,7 +6404,7 @@ public NativeTypeElementContext nativeTypeElement() { case 11: EnterOuterAlt(_localctx, 11); { - State = 1383; + State = 1403; _localctx.marshalType = Match(INT8); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6361,7 +6412,7 @@ public NativeTypeElementContext nativeTypeElement() { case 12: EnterOuterAlt(_localctx, 12); { - State = 1385; + State = 1405; _localctx.marshalType = Match(INT16); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6369,7 +6420,7 @@ public NativeTypeElementContext nativeTypeElement() { case 13: EnterOuterAlt(_localctx, 13); { - State = 1387; + State = 1407; _localctx.marshalType = Match(INT32_); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6377,7 +6428,7 @@ public NativeTypeElementContext nativeTypeElement() { case 14: EnterOuterAlt(_localctx, 14); { - State = 1389; + State = 1409; _localctx.marshalType = Match(INT64_); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6385,7 +6436,7 @@ public NativeTypeElementContext nativeTypeElement() { case 15: EnterOuterAlt(_localctx, 15); { - State = 1391; + State = 1411; _localctx.marshalType = Match(FLOAT32); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6393,7 +6444,7 @@ public NativeTypeElementContext nativeTypeElement() { case 16: EnterOuterAlt(_localctx, 16); { - State = 1393; + State = 1413; _localctx.marshalType = Match(FLOAT64_); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6401,7 +6452,7 @@ public NativeTypeElementContext nativeTypeElement() { case 17: EnterOuterAlt(_localctx, 17); { - State = 1395; + State = 1415; _localctx.marshalType = Match(ERROR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6409,7 +6460,7 @@ public NativeTypeElementContext nativeTypeElement() { case 18: EnterOuterAlt(_localctx, 18); { - State = 1397; + State = 1417; _localctx.marshalType = Match(UINT8); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6417,7 +6468,7 @@ public NativeTypeElementContext nativeTypeElement() { case 19: EnterOuterAlt(_localctx, 19); { - State = 1399; + State = 1419; _localctx.marshalType = Match(UINT16); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6425,7 +6476,7 @@ public NativeTypeElementContext nativeTypeElement() { case 20: EnterOuterAlt(_localctx, 20); { - State = 1401; + State = 1421; _localctx.marshalType = Match(UINT32); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6433,7 +6484,7 @@ public NativeTypeElementContext nativeTypeElement() { case 21: EnterOuterAlt(_localctx, 21); { - State = 1403; + State = 1423; _localctx.marshalType = Match(UINT64); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6441,7 +6492,7 @@ public NativeTypeElementContext nativeTypeElement() { case 22: EnterOuterAlt(_localctx, 22); { - State = 1405; + State = 1425; _localctx.marshalType = Match(DECIMAL); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6449,7 +6500,7 @@ public NativeTypeElementContext nativeTypeElement() { case 23: EnterOuterAlt(_localctx, 23); { - State = 1407; + State = 1427; _localctx.marshalType = Match(DATE); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6457,7 +6508,7 @@ public NativeTypeElementContext nativeTypeElement() { case 24: EnterOuterAlt(_localctx, 24); { - State = 1409; + State = 1429; _localctx.marshalType = Match(BSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6465,7 +6516,7 @@ public NativeTypeElementContext nativeTypeElement() { case 25: EnterOuterAlt(_localctx, 25); { - State = 1411; + State = 1431; _localctx.marshalType = Match(LPSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6473,7 +6524,7 @@ public NativeTypeElementContext nativeTypeElement() { case 26: EnterOuterAlt(_localctx, 26); { - State = 1413; + State = 1433; _localctx.marshalType = Match(LPWSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6481,7 +6532,7 @@ public NativeTypeElementContext nativeTypeElement() { case 27: EnterOuterAlt(_localctx, 27); { - State = 1415; + State = 1435; _localctx.marshalType = Match(LPTSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6489,7 +6540,7 @@ public NativeTypeElementContext nativeTypeElement() { case 28: EnterOuterAlt(_localctx, 28); { - State = 1417; + State = 1437; _localctx.marshalType = Match(OBJECTREF); _localctx.Value = Actions.CreateDeprecatedNativeType(_localctx, _localctx.marshalType); } @@ -6497,9 +6548,9 @@ public NativeTypeElementContext nativeTypeElement() { case 29: EnterOuterAlt(_localctx, 29); { - State = 1419; + State = 1439; _localctx.marshalType = Match(IUNKNOWN); - State = 1420; + State = 1440; _localctx.index = iidParamIndex(); _localctx.Value = Actions.CreateIidNativeType(_localctx.marshalType, _localctx.index.Value); } @@ -6507,9 +6558,9 @@ public NativeTypeElementContext nativeTypeElement() { case 30: EnterOuterAlt(_localctx, 30); { - State = 1423; + State = 1443; _localctx.marshalType = Match(IDISPATCH); - State = 1424; + State = 1444; _localctx.index = iidParamIndex(); _localctx.Value = Actions.CreateIidNativeType(_localctx.marshalType, _localctx.index.Value); } @@ -6517,7 +6568,7 @@ public NativeTypeElementContext nativeTypeElement() { case 31: EnterOuterAlt(_localctx, 31); { - State = 1427; + State = 1447; _localctx.marshalType = Match(STRUCT); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6525,9 +6576,9 @@ public NativeTypeElementContext nativeTypeElement() { case 32: EnterOuterAlt(_localctx, 32); { - State = 1429; + State = 1449; _localctx.marshalType = Match(INTERFACE); - State = 1430; + State = 1450; _localctx.index = iidParamIndex(); _localctx.Value = Actions.CreateIidNativeType(_localctx.marshalType, _localctx.index.Value); } @@ -6535,9 +6586,9 @@ public NativeTypeElementContext nativeTypeElement() { case 33: EnterOuterAlt(_localctx, 33); { - State = 1433; + State = 1453; _localctx.marshalType = Match(SAFEARRAY); - State = 1434; + State = 1454; _localctx.variant = variantType(); _localctx.Value = Actions.CreateSafeArrayNativeType(_localctx.variant.Value, null); } @@ -6545,13 +6596,13 @@ public NativeTypeElementContext nativeTypeElement() { case 34: EnterOuterAlt(_localctx, 34); { - State = 1437; + State = 1457; _localctx.marshalType = Match(SAFEARRAY); - State = 1438; + State = 1458; _localctx.variant = variantType(); - State = 1439; + State = 1459; Match(T__27); - State = 1440; + State = 1460; _localctx.userDefinedType = compQstring(); _localctx.Value = Actions.CreateSafeArrayNativeType(_localctx.variant.Value, _localctx.userDefinedType.Value); } @@ -6559,7 +6610,7 @@ public NativeTypeElementContext nativeTypeElement() { case 35: EnterOuterAlt(_localctx, 35); { - State = 1443; + State = 1463; _localctx.marshalType = Match(INT); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6567,7 +6618,7 @@ public NativeTypeElementContext nativeTypeElement() { case 36: EnterOuterAlt(_localctx, 36); { - State = 1445; + State = 1465; _localctx.marshalType = Match(UINT); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6575,9 +6626,9 @@ public NativeTypeElementContext nativeTypeElement() { case 37: EnterOuterAlt(_localctx, 37); { - State = 1447; + State = 1467; Match(T__89); - State = 1448; + State = 1468; _localctx.unsignedMarshalType = Match(INT8); _localctx.Value = Actions.CreateUnsignedNativeType(_localctx.unsignedMarshalType); } @@ -6585,9 +6636,9 @@ public NativeTypeElementContext nativeTypeElement() { case 38: EnterOuterAlt(_localctx, 38); { - State = 1450; + State = 1470; Match(T__89); - State = 1451; + State = 1471; _localctx.unsignedMarshalType = Match(INT16); _localctx.Value = Actions.CreateUnsignedNativeType(_localctx.unsignedMarshalType); } @@ -6595,9 +6646,9 @@ public NativeTypeElementContext nativeTypeElement() { case 39: EnterOuterAlt(_localctx, 39); { - State = 1453; + State = 1473; Match(T__89); - State = 1454; + State = 1474; _localctx.unsignedMarshalType = Match(INT32_); _localctx.Value = Actions.CreateUnsignedNativeType(_localctx.unsignedMarshalType); } @@ -6605,9 +6656,9 @@ public NativeTypeElementContext nativeTypeElement() { case 40: EnterOuterAlt(_localctx, 40); { - State = 1456; + State = 1476; Match(T__89); - State = 1457; + State = 1477; _localctx.unsignedMarshalType = Match(INT64_); _localctx.Value = Actions.CreateUnsignedNativeType(_localctx.unsignedMarshalType); } @@ -6615,9 +6666,9 @@ public NativeTypeElementContext nativeTypeElement() { case 41: EnterOuterAlt(_localctx, 41); { - State = 1459; + State = 1479; Match(T__61); - State = 1460; + State = 1480; _localctx.marshalType = Match(STRUCT); _localctx.Value = Actions.CreateNestedStructNativeType(_localctx); } @@ -6625,7 +6676,7 @@ public NativeTypeElementContext nativeTypeElement() { case 42: EnterOuterAlt(_localctx, 42); { - State = 1462; + State = 1482; _localctx.marshalType = Match(BYVALSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6633,9 +6684,9 @@ public NativeTypeElementContext nativeTypeElement() { case 43: EnterOuterAlt(_localctx, 43); { - State = 1464; + State = 1484; Match(ANSI); - State = 1465; + State = 1485; _localctx.marshalType = Match(BSTR); _localctx.Value = Actions.CreateAnsiBstrNativeType(); } @@ -6643,7 +6694,7 @@ public NativeTypeElementContext nativeTypeElement() { case 44: EnterOuterAlt(_localctx, 44); { - State = 1467; + State = 1487; _localctx.marshalType = Match(TBSTR); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6651,9 +6702,9 @@ public NativeTypeElementContext nativeTypeElement() { case 45: EnterOuterAlt(_localctx, 45); { - State = 1469; + State = 1489; Match(VARIANT); - State = 1470; + State = 1490; _localctx.marshalBool = Match(BOOL); _localctx.Value = Actions.CreateVariantBoolNativeType(); } @@ -6661,7 +6712,7 @@ public NativeTypeElementContext nativeTypeElement() { case 46: EnterOuterAlt(_localctx, 46); { - State = 1472; + State = 1492; _localctx.marshalType = Match(METHOD); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6669,7 +6720,7 @@ public NativeTypeElementContext nativeTypeElement() { case 47: EnterOuterAlt(_localctx, 47); { - State = 1474; + State = 1494; _localctx.marshalType = Match(LPSTRUCT); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6677,9 +6728,9 @@ public NativeTypeElementContext nativeTypeElement() { case 48: EnterOuterAlt(_localctx, 48); { - State = 1476; + State = 1496; Match(T__33); - State = 1477; + State = 1497; _localctx.marshalType = Match(ANY); _localctx.Value = Actions.CreateSimpleNativeType(_localctx.marshalType); } @@ -6687,7 +6738,7 @@ public NativeTypeElementContext nativeTypeElement() { case 49: EnterOuterAlt(_localctx, 49); { - State = 1479; + State = 1499; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateNativeTypeTypedef(_localctx, _localctx.alias.Value); } @@ -6727,9 +6778,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public IidParamIndexContext iidParamIndex() { IidParamIndexContext _localctx = new IidParamIndexContext(Context, State); - EnterRule(_localctx, 132, RULE_iidParamIndex); + EnterRule(_localctx, 134, RULE_iidParamIndex); try { - State = 1492; + State = 1512; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__30: @@ -6743,15 +6794,15 @@ public IidParamIndexContext iidParamIndex() { case T__29: EnterOuterAlt(_localctx, 2); { - State = 1485; + State = 1505; Match(T__29); - State = 1486; + State = 1506; Match(T__90); - State = 1487; + State = 1507; Match(T__35); - State = 1488; + State = 1508; _localctx.index = int32(); - State = 1489; + State = 1509; Match(T__30); _localctx.Value = Actions.GetIidParamIndex((_localctx.index!=null?(_localctx.index.Start):null)); } @@ -6806,14 +6857,14 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public VariantTypeContext variantType() { VariantTypeContext _localctx = new VariantTypeContext(Context, State); - EnterRule(_localctx, 134, RULE_variantType); + EnterRule(_localctx, 136, RULE_variantType); Actions.BeginVariantType(_localctx); int _la; try { int _alt; - State = 1504; + State = 1524; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,64,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,62,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -6822,17 +6873,17 @@ public VariantTypeContext variantType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1495; + State = 1515; _localctx.element = variantTypeElement(); Actions.SetVariantTypeElement(_localctx, _localctx.element.Value); - State = 1501; + State = 1521; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,63,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,61,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1497; + State = 1517; _localctx.modifier = TokenStream.LT(1); _la = TokenStream.LA(1); if ( !(((((_la - 229)) & ~0x3f) == 0 && ((1L << (_la - 229)) & 6442450945L) != 0)) ) { @@ -6846,9 +6897,9 @@ public VariantTypeContext variantType() { } } } - State = 1503; + State = 1523; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,63,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,61,Context); } } break; @@ -6925,15 +6976,15 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public VariantTypeElementContext variantTypeElement() { VariantTypeElementContext _localctx = new VariantTypeElementContext(Context, State); - EnterRule(_localctx, 136, RULE_variantTypeElement); + EnterRule(_localctx, 138, RULE_variantTypeElement); try { - State = 1586; + State = 1606; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case NULL: EnterOuterAlt(_localctx, 1); { - State = 1506; + State = 1526; _localctx.value = Match(NULL); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6941,7 +6992,7 @@ public VariantTypeElementContext variantTypeElement() { case VARIANT: EnterOuterAlt(_localctx, 2); { - State = 1508; + State = 1528; _localctx.value = Match(VARIANT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6949,7 +7000,7 @@ public VariantTypeElementContext variantTypeElement() { case CURRENCY: EnterOuterAlt(_localctx, 3); { - State = 1510; + State = 1530; _localctx.value = Match(CURRENCY); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6957,7 +7008,7 @@ public VariantTypeElementContext variantTypeElement() { case VOID: EnterOuterAlt(_localctx, 4); { - State = 1512; + State = 1532; _localctx.value = Match(VOID); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6965,7 +7016,7 @@ public VariantTypeElementContext variantTypeElement() { case BOOL: EnterOuterAlt(_localctx, 5); { - State = 1514; + State = 1534; _localctx.value = Match(BOOL); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6973,7 +7024,7 @@ public VariantTypeElementContext variantTypeElement() { case INT8: EnterOuterAlt(_localctx, 6); { - State = 1516; + State = 1536; _localctx.value = Match(INT8); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6981,7 +7032,7 @@ public VariantTypeElementContext variantTypeElement() { case INT16: EnterOuterAlt(_localctx, 7); { - State = 1518; + State = 1538; _localctx.value = Match(INT16); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6989,7 +7040,7 @@ public VariantTypeElementContext variantTypeElement() { case INT32_: EnterOuterAlt(_localctx, 8); { - State = 1520; + State = 1540; _localctx.value = Match(INT32_); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -6997,7 +7048,7 @@ public VariantTypeElementContext variantTypeElement() { case INT64_: EnterOuterAlt(_localctx, 9); { - State = 1522; + State = 1542; _localctx.value = Match(INT64_); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7005,7 +7056,7 @@ public VariantTypeElementContext variantTypeElement() { case FLOAT32: EnterOuterAlt(_localctx, 10); { - State = 1524; + State = 1544; _localctx.value = Match(FLOAT32); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7013,7 +7064,7 @@ public VariantTypeElementContext variantTypeElement() { case FLOAT64_: EnterOuterAlt(_localctx, 11); { - State = 1526; + State = 1546; _localctx.value = Match(FLOAT64_); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7021,7 +7072,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT8: EnterOuterAlt(_localctx, 12); { - State = 1528; + State = 1548; _localctx.value = Match(UINT8); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7029,7 +7080,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT16: EnterOuterAlt(_localctx, 13); { - State = 1530; + State = 1550; _localctx.value = Match(UINT16); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7037,7 +7088,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT32: EnterOuterAlt(_localctx, 14); { - State = 1532; + State = 1552; _localctx.value = Match(UINT32); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7045,7 +7096,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT64: EnterOuterAlt(_localctx, 15); { - State = 1534; + State = 1554; _localctx.value = Match(UINT64); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7053,7 +7104,7 @@ public VariantTypeElementContext variantTypeElement() { case PTR: EnterOuterAlt(_localctx, 16); { - State = 1536; + State = 1556; _localctx.value = Match(PTR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7061,7 +7112,7 @@ public VariantTypeElementContext variantTypeElement() { case DECIMAL: EnterOuterAlt(_localctx, 17); { - State = 1538; + State = 1558; _localctx.value = Match(DECIMAL); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7069,7 +7120,7 @@ public VariantTypeElementContext variantTypeElement() { case DATE: EnterOuterAlt(_localctx, 18); { - State = 1540; + State = 1560; _localctx.value = Match(DATE); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7077,7 +7128,7 @@ public VariantTypeElementContext variantTypeElement() { case BSTR: EnterOuterAlt(_localctx, 19); { - State = 1542; + State = 1562; _localctx.value = Match(BSTR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7085,7 +7136,7 @@ public VariantTypeElementContext variantTypeElement() { case LPSTR: EnterOuterAlt(_localctx, 20); { - State = 1544; + State = 1564; _localctx.value = Match(LPSTR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7093,7 +7144,7 @@ public VariantTypeElementContext variantTypeElement() { case LPWSTR: EnterOuterAlt(_localctx, 21); { - State = 1546; + State = 1566; _localctx.value = Match(LPWSTR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7101,7 +7152,7 @@ public VariantTypeElementContext variantTypeElement() { case IUNKNOWN: EnterOuterAlt(_localctx, 22); { - State = 1548; + State = 1568; _localctx.value = Match(IUNKNOWN); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7109,7 +7160,7 @@ public VariantTypeElementContext variantTypeElement() { case IDISPATCH: EnterOuterAlt(_localctx, 23); { - State = 1550; + State = 1570; _localctx.value = Match(IDISPATCH); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7117,7 +7168,7 @@ public VariantTypeElementContext variantTypeElement() { case SAFEARRAY: EnterOuterAlt(_localctx, 24); { - State = 1552; + State = 1572; _localctx.value = Match(SAFEARRAY); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7125,7 +7176,7 @@ public VariantTypeElementContext variantTypeElement() { case INT: EnterOuterAlt(_localctx, 25); { - State = 1554; + State = 1574; _localctx.value = Match(INT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7133,7 +7184,7 @@ public VariantTypeElementContext variantTypeElement() { case UINT: EnterOuterAlt(_localctx, 26); { - State = 1556; + State = 1576; _localctx.value = Match(UINT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7141,7 +7192,7 @@ public VariantTypeElementContext variantTypeElement() { case ERROR: EnterOuterAlt(_localctx, 27); { - State = 1558; + State = 1578; _localctx.value = Match(ERROR); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7149,7 +7200,7 @@ public VariantTypeElementContext variantTypeElement() { case HRESULT: EnterOuterAlt(_localctx, 28); { - State = 1560; + State = 1580; _localctx.value = Match(HRESULT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7157,7 +7208,7 @@ public VariantTypeElementContext variantTypeElement() { case CARRAY: EnterOuterAlt(_localctx, 29); { - State = 1562; + State = 1582; _localctx.value = Match(CARRAY); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7165,7 +7216,7 @@ public VariantTypeElementContext variantTypeElement() { case USERDEFINED: EnterOuterAlt(_localctx, 30); { - State = 1564; + State = 1584; _localctx.value = Match(USERDEFINED); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7173,7 +7224,7 @@ public VariantTypeElementContext variantTypeElement() { case RECORD: EnterOuterAlt(_localctx, 31); { - State = 1566; + State = 1586; _localctx.value = Match(RECORD); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7181,7 +7232,7 @@ public VariantTypeElementContext variantTypeElement() { case FILETIME: EnterOuterAlt(_localctx, 32); { - State = 1568; + State = 1588; _localctx.value = Match(FILETIME); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7189,7 +7240,7 @@ public VariantTypeElementContext variantTypeElement() { case BLOB: EnterOuterAlt(_localctx, 33); { - State = 1570; + State = 1590; _localctx.value = Match(BLOB); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7197,7 +7248,7 @@ public VariantTypeElementContext variantTypeElement() { case STREAM: EnterOuterAlt(_localctx, 34); { - State = 1572; + State = 1592; _localctx.value = Match(STREAM); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7205,7 +7256,7 @@ public VariantTypeElementContext variantTypeElement() { case STORAGE: EnterOuterAlt(_localctx, 35); { - State = 1574; + State = 1594; _localctx.value = Match(STORAGE); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7213,7 +7264,7 @@ public VariantTypeElementContext variantTypeElement() { case STREAMED_OBJECT: EnterOuterAlt(_localctx, 36); { - State = 1576; + State = 1596; _localctx.value = Match(STREAMED_OBJECT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7221,7 +7272,7 @@ public VariantTypeElementContext variantTypeElement() { case STORED_OBJECT: EnterOuterAlt(_localctx, 37); { - State = 1578; + State = 1598; _localctx.value = Match(STORED_OBJECT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7229,7 +7280,7 @@ public VariantTypeElementContext variantTypeElement() { case BLOB_OBJECT: EnterOuterAlt(_localctx, 38); { - State = 1580; + State = 1600; _localctx.value = Match(BLOB_OBJECT); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7237,7 +7288,7 @@ public VariantTypeElementContext variantTypeElement() { case CF: EnterOuterAlt(_localctx, 39); { - State = 1582; + State = 1602; _localctx.value = Match(CF); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7245,7 +7296,7 @@ public VariantTypeElementContext variantTypeElement() { case CLSID: EnterOuterAlt(_localctx, 40); { - State = 1584; + State = 1604; _localctx.value = Match(CLSID); _localctx.Value = Actions.GetVariantTypeElement(_localctx.value); } @@ -7294,31 +7345,31 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TypeContext type() { TypeContext _localctx = new TypeContext(Context, State); - EnterRule(_localctx, 138, RULE_type); + EnterRule(_localctx, 140, RULE_type); Actions.BeginTypeSignature(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1588; + State = 1608; _localctx.element = elementType(); Actions.SetTypeSignatureElement(_localctx, _localctx.element.Value); - State = 1595; + State = 1615; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,66,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,64,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1590; + State = 1610; _localctx.modifier = typeModifiers(); Actions.AddTypeSignatureModifier(_localctx, _localctx.modifier.Value); } } } - State = 1597; + State = 1617; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,66,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,64,Context); } } } @@ -7443,16 +7494,16 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TypeModifiersContext typeModifiers() { TypeModifiersContext _localctx = new TypeModifiersContext(Context, State); - EnterRule(_localctx, 140, RULE_typeModifiers); + EnterRule(_localctx, 142, RULE_typeModifiers); try { - State = 1627; + State = 1647; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,67,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,65,Context) ) { case 1: _localctx = new SZArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 1); { - State = 1598; + State = 1618; Match(ARRAY_TYPE_NO_BOUNDS); _localctx.Value = Actions.CreateSzArrayTypeModifier(); } @@ -7461,9 +7512,9 @@ public TypeModifiersContext typeModifiers() { _localctx = new SZArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 2); { - State = 1600; + State = 1620; Match(T__41); - State = 1601; + State = 1621; Match(T__42); _localctx.Value = Actions.CreateSzArrayTypeModifier(); } @@ -7472,7 +7523,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new ArrayModifierContext(_localctx); EnterOuterAlt(_localctx, 3); { - State = 1603; + State = 1623; ((ArrayModifierContext)_localctx).arrayBounds = bounds(); _localctx.Value = Actions.CreateArrayTypeModifier(((ArrayModifierContext)_localctx).arrayBounds.Value); } @@ -7481,7 +7532,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new ByRefModifierContext(_localctx); EnterOuterAlt(_localctx, 4); { - State = 1606; + State = 1626; Match(REF); _localctx.Value = Actions.CreateByReferenceTypeModifier(); } @@ -7490,7 +7541,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new PtrModifierContext(_localctx); EnterOuterAlt(_localctx, 5); { - State = 1608; + State = 1628; Match(PTR); _localctx.Value = Actions.CreatePointerTypeModifier(); } @@ -7499,7 +7550,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new PinnedModifierContext(_localctx); EnterOuterAlt(_localctx, 6); { - State = 1610; + State = 1630; Match(T__91); _localctx.Value = Actions.CreatePinnedTypeModifier(); } @@ -7508,13 +7559,13 @@ public TypeModifiersContext typeModifiers() { _localctx = new RequiredModifierContext(_localctx); EnterOuterAlt(_localctx, 7); { - State = 1612; + State = 1632; Match(T__92); - State = 1613; + State = 1633; Match(T__29); - State = 1614; + State = 1634; ((RequiredModifierContext)_localctx).modifierType = typeSpec(); - State = 1615; + State = 1635; Match(T__30); _localctx.Value = Actions.CreateCustomTypeModifier(((RequiredModifierContext)_localctx).modifierType.Value, true); } @@ -7523,13 +7574,13 @@ public TypeModifiersContext typeModifiers() { _localctx = new OptionalModifierContext(_localctx); EnterOuterAlt(_localctx, 8); { - State = 1618; + State = 1638; Match(T__93); - State = 1619; + State = 1639; Match(T__29); - State = 1620; + State = 1640; ((OptionalModifierContext)_localctx).modifierType = typeSpec(); - State = 1621; + State = 1641; Match(T__30); _localctx.Value = Actions.CreateCustomTypeModifier(((OptionalModifierContext)_localctx).modifierType.Value, false); } @@ -7538,7 +7589,7 @@ public TypeModifiersContext typeModifiers() { _localctx = new GenericArgumentsModifierContext(_localctx); EnterOuterAlt(_localctx, 9); { - State = 1624; + State = 1644; ((GenericArgumentsModifierContext)_localctx).arguments = typeArgs(); _localctx.Value = Actions.CreateGenericArgumentsModifier(((GenericArgumentsModifierContext)_localctx).arguments.Value); } @@ -7624,17 +7675,17 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ElementTypeContext elementType() { ElementTypeContext _localctx = new ElementTypeContext(Context, State); - EnterRule(_localctx, 142, RULE_elementType); + EnterRule(_localctx, 144, RULE_elementType); try { - State = 1687; + State = 1707; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,68,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,66,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1629; + State = 1649; Match(T__38); - State = 1630; + State = 1650; _localctx.classType = className(); _localctx.Value = Actions.CreateClassElementType(_localctx.classType.Value, false); } @@ -7642,7 +7693,7 @@ public ElementTypeContext elementType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1633; + State = 1653; Match(OBJECT); _localctx.Value = Actions.CreateObjectElementType(); } @@ -7650,11 +7701,11 @@ public ElementTypeContext elementType() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1635; + State = 1655; Match(VALUE); - State = 1636; + State = 1656; Match(T__38); - State = 1637; + State = 1657; _localctx.valueClassType = className(); _localctx.Value = Actions.CreateClassElementType(_localctx.valueClassType.Value, true); } @@ -7662,9 +7713,9 @@ public ElementTypeContext elementType() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1640; + State = 1660; Match(VALUETYPE); - State = 1641; + State = 1661; _localctx.valueType = className(); _localctx.Value = Actions.CreateClassElementType(_localctx.valueType.Value, true); } @@ -7672,15 +7723,15 @@ public ElementTypeContext elementType() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1644; + State = 1664; Match(METHOD); - State = 1645; + State = 1665; _localctx.convention = callConv(); - State = 1646; + State = 1666; _localctx.returnType = type(); - State = 1647; + State = 1667; Match(PTR); - State = 1648; + State = 1668; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateFunctionPointerElementType(_localctx.convention.Value, _localctx.returnType.Value, _localctx.arguments.Value); } @@ -7688,9 +7739,9 @@ public ElementTypeContext elementType() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1651; + State = 1671; Match(METHOD_TYPE_PARAMETER); - State = 1652; + State = 1672; _localctx.parameterIndex = int32(); _localctx.Value = Actions.CreateIndexedGenericParameterElementType(true, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null)); } @@ -7698,9 +7749,9 @@ public ElementTypeContext elementType() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1655; + State = 1675; Match(TYPE_PARAMETER); - State = 1656; + State = 1676; _localctx.parameterIndex = int32(); _localctx.Value = Actions.CreateIndexedGenericParameterElementType(false, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null)); } @@ -7708,9 +7759,9 @@ public ElementTypeContext elementType() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1659; + State = 1679; Match(METHOD_TYPE_PARAMETER); - State = 1660; + State = 1680; _localctx.parameterName = dottedName(); _localctx.Value = Actions.CreateNamedGenericParameterElementType(_localctx.Start, true, _localctx.parameterName.Value); } @@ -7718,9 +7769,9 @@ public ElementTypeContext elementType() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1663; + State = 1683; Match(TYPE_PARAMETER); - State = 1664; + State = 1684; _localctx.parameterName = dottedName(); _localctx.Value = Actions.CreateNamedGenericParameterElementType(_localctx.Start, false, _localctx.parameterName.Value); } @@ -7728,7 +7779,7 @@ public ElementTypeContext elementType() { case 10: EnterOuterAlt(_localctx, 10); { - State = 1667; + State = 1687; Match(TYPEDREF); _localctx.Value = Actions.CreateTypedReferenceElementType(); } @@ -7736,7 +7787,7 @@ public ElementTypeContext elementType() { case 11: EnterOuterAlt(_localctx, 11); { - State = 1669; + State = 1689; Match(VOID); _localctx.Value = Actions.CreateVoidElementType(); } @@ -7744,7 +7795,7 @@ public ElementTypeContext elementType() { case 12: EnterOuterAlt(_localctx, 12); { - State = 1671; + State = 1691; _localctx.signedNative = nativeInt(); _localctx.Value = Actions.CreatePrimitiveElementType(_localctx.signedNative.Value); } @@ -7752,7 +7803,7 @@ public ElementTypeContext elementType() { case 13: EnterOuterAlt(_localctx, 13); { - State = 1674; + State = 1694; _localctx.unsignedNative = nativeUint(); _localctx.Value = Actions.CreatePrimitiveElementType(_localctx.unsignedNative.Value); } @@ -7760,7 +7811,7 @@ public ElementTypeContext elementType() { case 14: EnterOuterAlt(_localctx, 14); { - State = 1677; + State = 1697; _localctx.primitive = simpleType(); _localctx.Value = Actions.CreatePrimitiveElementType(_localctx.primitive.Value); } @@ -7768,7 +7819,7 @@ public ElementTypeContext elementType() { case 15: EnterOuterAlt(_localctx, 15); { - State = 1680; + State = 1700; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateTypedefElementType(_localctx.Start, _localctx.alias.Value); } @@ -7776,9 +7827,9 @@ public ElementTypeContext elementType() { case 16: EnterOuterAlt(_localctx, 16); { - State = 1683; + State = 1703; Match(ELLIPSIS); - State = 1684; + State = 1704; _localctx.sentinelType = type(); _localctx.Value = Actions.CreateSentinelElementType(_localctx.sentinelType.Value); } @@ -7828,15 +7879,15 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SimpleTypeContext simpleType() { SimpleTypeContext _localctx = new SimpleTypeContext(Context, State); - EnterRule(_localctx, 144, RULE_simpleType); + EnterRule(_localctx, 146, RULE_simpleType); try { - State = 1727; + State = 1747; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,69,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,67,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1689; + State = 1709; _localctx.value = Match(CHAR); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7844,7 +7895,7 @@ public SimpleTypeContext simpleType() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1691; + State = 1711; _localctx.value = Match(STRING); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7852,7 +7903,7 @@ public SimpleTypeContext simpleType() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1693; + State = 1713; _localctx.value = Match(BOOL); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7860,7 +7911,7 @@ public SimpleTypeContext simpleType() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1695; + State = 1715; _localctx.value = Match(INT8); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7868,7 +7919,7 @@ public SimpleTypeContext simpleType() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1697; + State = 1717; _localctx.value = Match(INT16); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7876,7 +7927,7 @@ public SimpleTypeContext simpleType() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1699; + State = 1719; _localctx.value = Match(INT32_); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7884,7 +7935,7 @@ public SimpleTypeContext simpleType() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1701; + State = 1721; _localctx.value = Match(INT64_); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7892,7 +7943,7 @@ public SimpleTypeContext simpleType() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1703; + State = 1723; _localctx.value = Match(FLOAT32); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7900,7 +7951,7 @@ public SimpleTypeContext simpleType() { case 9: EnterOuterAlt(_localctx, 9); { - State = 1705; + State = 1725; _localctx.value = Match(FLOAT64_); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7908,7 +7959,7 @@ public SimpleTypeContext simpleType() { case 10: EnterOuterAlt(_localctx, 10); { - State = 1707; + State = 1727; _localctx.value = Match(UINT8); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7916,7 +7967,7 @@ public SimpleTypeContext simpleType() { case 11: EnterOuterAlt(_localctx, 11); { - State = 1709; + State = 1729; _localctx.value = Match(UINT16); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7924,7 +7975,7 @@ public SimpleTypeContext simpleType() { case 12: EnterOuterAlt(_localctx, 12); { - State = 1711; + State = 1731; _localctx.value = Match(UINT32); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7932,7 +7983,7 @@ public SimpleTypeContext simpleType() { case 13: EnterOuterAlt(_localctx, 13); { - State = 1713; + State = 1733; _localctx.value = Match(UINT64); _localctx.Value = Actions.GetSimpleType(_localctx.value, false); } @@ -7940,9 +7991,9 @@ public SimpleTypeContext simpleType() { case 14: EnterOuterAlt(_localctx, 14); { - State = 1715; + State = 1735; Match(T__89); - State = 1716; + State = 1736; _localctx.value = Match(INT8); _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } @@ -7950,9 +8001,9 @@ public SimpleTypeContext simpleType() { case 15: EnterOuterAlt(_localctx, 15); { - State = 1718; + State = 1738; Match(T__89); - State = 1719; + State = 1739; _localctx.value = Match(INT16); _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } @@ -7960,9 +8011,9 @@ public SimpleTypeContext simpleType() { case 16: EnterOuterAlt(_localctx, 16); { - State = 1721; + State = 1741; Match(T__89); - State = 1722; + State = 1742; _localctx.value = Match(INT32_); _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } @@ -7970,9 +8021,9 @@ public SimpleTypeContext simpleType() { case 17: EnterOuterAlt(_localctx, 17); { - State = 1724; + State = 1744; Match(T__89); - State = 1725; + State = 1745; _localctx.value = Match(INT64_); _localctx.Value = Actions.GetSimpleType(_localctx.value, true); } @@ -8021,12 +8072,12 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public BoundContext bound() { BoundContext _localctx = new BoundContext(Context, State); - EnterRule(_localctx, 146, RULE_bound); + EnterRule(_localctx, 148, RULE_bound); Actions.InitializeBound(_localctx); try { - State = 1743; + State = 1763; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,70,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,68,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -8035,14 +8086,14 @@ public BoundContext bound() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1730; + State = 1750; Match(ELLIPSIS); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 1731; + State = 1751; _localctx.size = int32(); Actions.SetBoundSize(_localctx, (_localctx.size!=null?(_localctx.size.Start):null)); } @@ -8050,11 +8101,11 @@ public BoundContext bound() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1734; + State = 1754; _localctx.lower = int32(); - State = 1735; + State = 1755; Match(ELLIPSIS); - State = 1736; + State = 1756; _localctx.upper = int32(); Actions.SetBoundRange(_localctx, (_localctx.lower!=null?(_localctx.lower.Start):null), (_localctx.upper!=null?(_localctx.upper.Start):null)); } @@ -8062,9 +8113,9 @@ public BoundContext bound() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1739; + State = 1759; _localctx.lower = int32(); - State = 1740; + State = 1760; Match(ELLIPSIS); Actions.SetBoundLower(_localctx, (_localctx.lower!=null?(_localctx.lower.Start):null)); } @@ -8101,13 +8152,13 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public NativeIntContext nativeInt() { NativeIntContext _localctx = new NativeIntContext(Context, State); - EnterRule(_localctx, 148, RULE_nativeInt); + EnterRule(_localctx, 150, RULE_nativeInt); try { EnterOuterAlt(_localctx, 1); { - State = 1745; + State = 1765; Match(T__0); - State = 1746; + State = 1766; Match(INT); _localctx.Value = Actions.GetNativeIntType(); } @@ -8143,26 +8194,26 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public NativeUintContext nativeUint() { NativeUintContext _localctx = new NativeUintContext(Context, State); - EnterRule(_localctx, 150, RULE_nativeUint); + EnterRule(_localctx, 152, RULE_nativeUint); try { EnterOuterAlt(_localctx, 1); { - State = 1749; + State = 1769; Match(T__0); - State = 1753; + State = 1773; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__89: { - State = 1750; + State = 1770; Match(T__89); - State = 1751; + State = 1771; Match(INT); } break; case UINT: { - State = 1752; + State = 1772; Match(UINT); } break; @@ -8232,27 +8283,27 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SecDeclContext secDecl() { SecDeclContext _localctx = new SecDeclContext(Context, State); - EnterRule(_localctx, 152, RULE_secDecl); + EnterRule(_localctx, 154, RULE_secDecl); BeginStreaming(); Actions.BeginSemanticRoot(_localctx); int _la; try { - State = 1811; + State = 1831; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,73,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,71,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1757; + State = 1777; Match(PERMISSION); - State = 1758; + State = 1778; _localctx.action = secAction(); - State = 1759; + State = 1779; _localctx.permissionType = typeSpec(); - State = 1760; + State = 1780; Match(T__29); - State = 1761; + State = 1781; _localctx.pairs = nameValPairs(); - State = 1762; + State = 1782; Match(T__30); _localctx.Value = Actions.CreateNamedPermissionDeclaration( _localctx.action.Value, @@ -8263,19 +8314,19 @@ public SecDeclContext secDecl() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1765; + State = 1785; Match(PERMISSION); - State = 1766; + State = 1786; _localctx.action = secAction(); - State = 1767; + State = 1787; _localctx.permissionType = typeSpec(); - State = 1768; + State = 1788; Match(T__35); - State = 1769; + State = 1789; Match(T__16); - State = 1770; + State = 1790; _localctx.structuredValue = customBlobDescr(); - State = 1771; + State = 1791; Match(T__17); _localctx.Value = Actions.CreateStructuredPermissionDeclaration( _localctx.action.Value, @@ -8286,11 +8337,11 @@ public SecDeclContext secDecl() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1774; + State = 1794; Match(PERMISSION); - State = 1775; + State = 1795; _localctx.action = secAction(); - State = 1776; + State = 1796; _localctx.permissionType = typeSpec(); _localctx.Value = Actions.CreateEmptyPermissionDeclaration(_localctx.action.Value, _localctx.permissionType.Value); } @@ -8298,27 +8349,27 @@ public SecDeclContext secDecl() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1779; + State = 1799; Match(PERMISSIONSET); - State = 1780; + State = 1800; _localctx.action = secAction(); - State = 1781; + State = 1801; Match(T__35); - State = 1783; + State = 1803; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__83) { { - State = 1782; + State = 1802; Match(T__83); } } - State = 1785; + State = 1805; Match(T__29); - State = 1786; + State = 1806; _localctx.rawValue = bytes(); - State = 1787; + State = 1807; Match(T__30); _localctx.Value = Actions.CreateRawPermissionSetDeclaration(_localctx.action.Value, _localctx.rawValue.Value); } @@ -8326,17 +8377,17 @@ public SecDeclContext secDecl() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1790; + State = 1810; Match(PERMISSIONSET); - State = 1791; + State = 1811; _localctx.action = secAction(); - State = 1792; + State = 1812; Match(T__83); - State = 1793; + State = 1813; Match(T__29); - State = 1794; + State = 1814; _localctx.rawValue = bytes(); - State = 1795; + State = 1815; Match(T__30); _localctx.Value = Actions.CreateRawPermissionSetDeclaration(_localctx.action.Value, _localctx.rawValue.Value); } @@ -8344,11 +8395,11 @@ public SecDeclContext secDecl() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1798; + State = 1818; Match(PERMISSIONSET); - State = 1799; + State = 1819; _localctx.action = secAction(); - State = 1800; + State = 1820; _localctx.textValue = compQstring(); _localctx.Value = Actions.CreateStringPermissionSetDeclaration(_localctx.action.Value, _localctx.textValue.Value); } @@ -8356,17 +8407,17 @@ public SecDeclContext secDecl() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1803; + State = 1823; Match(PERMISSIONSET); - State = 1804; + State = 1824; _localctx.action = secAction(); - State = 1805; + State = 1825; Match(T__35); - State = 1806; + State = 1826; Match(T__16); - State = 1807; + State = 1827; _localctx.attributes = secAttrSetBlob(); - State = 1808; + State = 1828; Match(T__17); _localctx.Value = Actions.CreateAttributePermissionSetDeclaration(_localctx.action.Value, _localctx.attributes.Value); } @@ -8411,11 +8462,11 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SecAttrSetBlobContext secAttrSetBlob() { SecAttrSetBlobContext _localctx = new SecAttrSetBlobContext(Context, State); - EnterRule(_localctx, 154, RULE_secAttrSetBlob); + EnterRule(_localctx, 156, RULE_secAttrSetBlob); Actions.BeginSecurityAttributeSet(_localctx); try { int _alt; - State = 1826; + State = 1846; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__17: @@ -8460,26 +8511,26 @@ public SecAttrSetBlobContext secAttrSetBlob() { case ID: EnterOuterAlt(_localctx, 2); { - State = 1820; + State = 1840; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,74,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,72,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1814; + State = 1834; _localctx.attribute = secAttrBlob(); Actions.AddSecurityAttribute(_localctx, _localctx.attribute.Value); - State = 1816; + State = 1836; Match(T__27); } } } - State = 1822; + State = 1842; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,74,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,72,Context); } - State = 1823; + State = 1843; _localctx.tail = secAttrBlob(); Actions.AddSecurityAttribute(_localctx, _localctx.tail.Value); } @@ -8528,25 +8579,25 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SecAttrBlobContext secAttrBlob() { SecAttrBlobContext _localctx = new SecAttrBlobContext(Context, State); - EnterRule(_localctx, 156, RULE_secAttrBlob); + EnterRule(_localctx, 158, RULE_secAttrBlob); try { - State = 1843; + State = 1863; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,76,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,74,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1828; + State = 1848; Match(T__38); - State = 1829; + State = 1849; _localctx.name = Match(SQSTRING); - State = 1830; + State = 1850; Match(T__35); - State = 1831; + State = 1851; Match(T__16); - State = 1832; + State = 1852; _localctx.arguments = customBlobNVPairs(); - State = 1833; + State = 1853; Match(T__17); _localctx.Value = Actions.CreateNamedSecurityAttribute(_localctx.name, _localctx.arguments.Value); } @@ -8554,15 +8605,15 @@ public SecAttrBlobContext secAttrBlob() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1836; + State = 1856; _localctx.securityType = typeSpec(); - State = 1837; + State = 1857; Match(T__35); - State = 1838; + State = 1858; Match(T__16); - State = 1839; + State = 1859; _localctx.arguments = customBlobNVPairs(); - State = 1840; + State = 1860; Match(T__17); _localctx.Value = Actions.CreateTypedSecurityAttribute(_localctx.securityType.Value, _localctx.arguments.Value); } @@ -8606,32 +8657,32 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public NameValPairsContext nameValPairs() { NameValPairsContext _localctx = new NameValPairsContext(Context, State); - EnterRule(_localctx, 158, RULE_nameValPairs); + EnterRule(_localctx, 160, RULE_nameValPairs); Actions.BeginSecurityNameValuePairs(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 1851; + State = 1871; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,77,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,75,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 1845; + State = 1865; _localctx.pair = nameValPair(); Actions.AddSecurityNameValuePair(_localctx, _localctx.pair.Value); - State = 1847; + State = 1867; Match(T__27); } } } - State = 1853; + State = 1873; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,77,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,75,Context); } - State = 1854; + State = 1874; _localctx.tail = nameValPair(); Actions.AddSecurityNameValuePair(_localctx, _localctx.tail.Value); } @@ -8674,15 +8725,15 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public NameValPairContext nameValPair() { NameValPairContext _localctx = new NameValPairContext(Context, State); - EnterRule(_localctx, 160, RULE_nameValPair); + EnterRule(_localctx, 162, RULE_nameValPair); try { EnterOuterAlt(_localctx, 1); { - State = 1857; + State = 1877; _localctx.name = compQstring(); - State = 1858; + State = 1878; Match(T__35); - State = 1859; + State = 1879; _localctx.value = caValue(); _localctx.Value = Actions.CreateSecurityNameValuePair(_localctx.name.Value, _localctx.value.Value); } @@ -8716,12 +8767,12 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TruefalseContext truefalse() { TruefalseContext _localctx = new TruefalseContext(Context, State); - EnterRule(_localctx, 162, RULE_truefalse); + EnterRule(_localctx, 164, RULE_truefalse); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 1862; + State = 1882; _la = TokenStream.LA(1); if ( !(_la==T__94 || _la==T__95) ) { ErrorHandler.RecoverInline(this); @@ -8784,15 +8835,15 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public CaValueContext caValue() { CaValueContext _localctx = new CaValueContext(Context, State); - EnterRule(_localctx, 164, RULE_caValue); + EnterRule(_localctx, 166, RULE_caValue); try { - State = 1909; + State = 1929; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,78,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,76,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1864; + State = 1884; _localctx.booleanValue = truefalse(); _localctx.Value = Actions.CreateSecurityBooleanValue(_localctx.booleanValue.Value); } @@ -8800,7 +8851,7 @@ public CaValueContext caValue() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1867; + State = 1887; _localctx.integerValue = int32(); _localctx.Value = Actions.CreateSecurityInt32Value((_localctx.integerValue!=null?(_localctx.integerValue.Start):null)); } @@ -8808,13 +8859,13 @@ public CaValueContext caValue() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1870; + State = 1890; Match(INT32_); - State = 1871; + State = 1891; Match(T__29); - State = 1872; + State = 1892; _localctx.integerValue = int32(); - State = 1873; + State = 1893; Match(T__30); _localctx.Value = Actions.CreateSecurityInt32Value((_localctx.integerValue!=null?(_localctx.integerValue.Start):null)); } @@ -8822,7 +8873,7 @@ public CaValueContext caValue() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1876; + State = 1896; _localctx.textValue = compQstring(); _localctx.Value = Actions.CreateSecurityStringValue(_localctx.textValue.Value); } @@ -8830,17 +8881,17 @@ public CaValueContext caValue() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1879; + State = 1899; _localctx.enumType = className(); - State = 1880; + State = 1900; Match(T__29); - State = 1881; + State = 1901; _localctx.kind = Match(INT8); - State = 1882; + State = 1902; Match(T__74); - State = 1883; + State = 1903; _localctx.enumValue = int32(); - State = 1884; + State = 1904; Match(T__30); _localctx.Value = Actions.CreateSecurityEnumValue(_localctx.enumType.Value, _localctx.kind, (_localctx.enumValue!=null?(_localctx.enumValue.Start):null)); } @@ -8848,17 +8899,17 @@ public CaValueContext caValue() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1887; + State = 1907; _localctx.enumType = className(); - State = 1888; + State = 1908; Match(T__29); - State = 1889; + State = 1909; _localctx.kind = Match(INT16); - State = 1890; + State = 1910; Match(T__74); - State = 1891; + State = 1911; _localctx.enumValue = int32(); - State = 1892; + State = 1912; Match(T__30); _localctx.Value = Actions.CreateSecurityEnumValue(_localctx.enumType.Value, _localctx.kind, (_localctx.enumValue!=null?(_localctx.enumValue.Start):null)); } @@ -8866,17 +8917,17 @@ public CaValueContext caValue() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1895; + State = 1915; _localctx.enumType = className(); - State = 1896; + State = 1916; Match(T__29); - State = 1897; + State = 1917; _localctx.kind = Match(INT32_); - State = 1898; + State = 1918; Match(T__74); - State = 1899; + State = 1919; _localctx.enumValue = int32(); - State = 1900; + State = 1920; Match(T__30); _localctx.Value = Actions.CreateSecurityEnumValue(_localctx.enumType.Value, _localctx.kind, (_localctx.enumValue!=null?(_localctx.enumValue.Start):null)); } @@ -8884,13 +8935,13 @@ public CaValueContext caValue() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1903; + State = 1923; _localctx.enumType = className(); - State = 1904; + State = 1924; Match(T__29); - State = 1905; + State = 1925; _localctx.enumValue = int32(); - State = 1906; + State = 1926; Match(T__30); _localctx.Value = Actions.CreateSecurityEnumValue(_localctx.enumType.Value, (_localctx.enumValue!=null?(_localctx.enumValue.Start):null)); } @@ -8926,12 +8977,12 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SecActionContext secAction() { SecActionContext _localctx = new SecActionContext(Context, State); - EnterRule(_localctx, 166, RULE_secAction); + EnterRule(_localctx, 168, RULE_secAction); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 1911; + State = 1931; _la = TokenStream.LA(1); if ( !(((((_la - 97)) & ~0x3f) == 0 && ((1L << (_la - 97)) & 32767L) != 0)) ) { ErrorHandler.RecoverInline(this); @@ -9011,37 +9062,37 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public MethodRefContext methodRef() { MethodRefContext _localctx = new MethodRefContext(Context, State); - EnterRule(_localctx, 168, RULE_methodRef); + EnterRule(_localctx, 170, RULE_methodRef); Actions.BeginSemanticRoot(_localctx); int _la; try { - State = 1955; + State = 1975; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,81,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,79,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1913; + State = 1933; _localctx.convention = callConv(); - State = 1914; + State = 1934; _localctx.returnType = type(); - State = 1915; + State = 1935; _localctx.owner = typeSpec(); - State = 1916; + State = 1936; Match(DCOLON); - State = 1917; + State = 1937; _localctx.name = methodName(); - State = 1919; + State = 1939; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 1918; + State = 1938; _localctx.genericArguments = typeArgs(); } } - State = 1921; + State = 1941; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, _localctx.owner.Value, _localctx.name.Value, _localctx.genericArguments, null, _localctx.arguments.Value); } @@ -9049,19 +9100,19 @@ public MethodRefContext methodRef() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1924; + State = 1944; _localctx.convention = callConv(); - State = 1925; + State = 1945; _localctx.returnType = type(); - State = 1926; + State = 1946; _localctx.owner = typeSpec(); - State = 1927; + State = 1947; Match(DCOLON); - State = 1928; + State = 1948; _localctx.name = methodName(); - State = 1929; + State = 1949; _localctx.genericArity = genArityNotEmpty(); - State = 1930; + State = 1950; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, _localctx.owner.Value, _localctx.name.Value, null, _localctx.genericArity.Value, _localctx.arguments.Value); } @@ -9069,23 +9120,23 @@ public MethodRefContext methodRef() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1933; + State = 1953; _localctx.convention = callConv(); - State = 1934; + State = 1954; _localctx.returnType = type(); - State = 1935; + State = 1955; _localctx.name = methodName(); - State = 1937; + State = 1957; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 1936; + State = 1956; _localctx.genericArguments = typeArgs(); } } - State = 1939; + State = 1959; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, null, _localctx.name.Value, _localctx.genericArguments, null, _localctx.arguments.Value); } @@ -9093,15 +9144,15 @@ public MethodRefContext methodRef() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1942; + State = 1962; _localctx.convention = callConv(); - State = 1943; + State = 1963; _localctx.returnType = type(); - State = 1944; + State = 1964; _localctx.name = methodName(); - State = 1945; + State = 1965; _localctx.genericArity = genArityNotEmpty(); - State = 1946; + State = 1966; _localctx.arguments = sigArgs(); _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, null, _localctx.name.Value, null, _localctx.genericArity.Value, _localctx.arguments.Value); } @@ -9109,7 +9160,7 @@ public MethodRefContext methodRef() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1949; + State = 1969; _localctx.token = mdtoken(); _localctx.Value = Actions.CreateTokenMethodReference(_localctx.token.Value); } @@ -9117,7 +9168,7 @@ public MethodRefContext methodRef() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1952; + State = 1972; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateTypedefMethodReference(_localctx.Start, _localctx.alias.Value); } @@ -9168,17 +9219,17 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public CallConvContext callConv() { CallConvContext _localctx = new CallConvContext(Context, State); - EnterRule(_localctx, 170, RULE_callConv); + EnterRule(_localctx, 172, RULE_callConv); try { - State = 1974; + State = 1994; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,82,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,80,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 1957; + State = 1977; Match(INSTANCE); - State = 1958; + State = 1978; _localctx.inner = callConv(); _localctx.Value = Actions.AddInstanceCallingConvention(_localctx.inner.Value); } @@ -9186,9 +9237,9 @@ public CallConvContext callConv() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1961; + State = 1981; Match(EXPLICIT); - State = 1962; + State = 1982; _localctx.inner = callConv(); _localctx.Value = Actions.AddExplicitCallingConvention(_localctx.inner.Value); } @@ -9196,7 +9247,7 @@ public CallConvContext callConv() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1965; + State = 1985; _localctx.kind = callKind(); _localctx.Value = _localctx.kind.Value; } @@ -9204,13 +9255,13 @@ public CallConvContext callConv() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1968; + State = 1988; Match(T__111); - State = 1969; + State = 1989; Match(T__29); - State = 1970; + State = 1990; _localctx.raw = int32(); - State = 1971; + State = 1991; Match(T__30); _localctx.Value = Actions.GetRawCallingConvention((_localctx.raw!=null?(_localctx.raw.Start):null)); } @@ -9254,12 +9305,12 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public CallKindContext callKind() { CallKindContext _localctx = new CallKindContext(Context, State); - EnterRule(_localctx, 172, RULE_callKind); + EnterRule(_localctx, 174, RULE_callKind); _localctx.Value = Actions.GetDefaultCallingConvention(); try { - State = 1995; + State = 2015; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,83,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,81,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -9268,7 +9319,7 @@ public CallKindContext callKind() { case 2: EnterOuterAlt(_localctx, 2); { - State = 1977; + State = 1997; _localctx.kind = Match(DEFAULT); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9276,7 +9327,7 @@ public CallKindContext callKind() { case 3: EnterOuterAlt(_localctx, 3); { - State = 1979; + State = 1999; _localctx.kind = Match(VARARG); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9284,9 +9335,9 @@ public CallKindContext callKind() { case 4: EnterOuterAlt(_localctx, 4); { - State = 1981; + State = 2001; Match(UNMANAGED); - State = 1982; + State = 2002; _localctx.kind = Match(CDECL); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9294,9 +9345,9 @@ public CallKindContext callKind() { case 5: EnterOuterAlt(_localctx, 5); { - State = 1984; + State = 2004; Match(UNMANAGED); - State = 1985; + State = 2005; _localctx.kind = Match(STDCALL); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9304,9 +9355,9 @@ public CallKindContext callKind() { case 6: EnterOuterAlt(_localctx, 6); { - State = 1987; + State = 2007; Match(UNMANAGED); - State = 1988; + State = 2008; _localctx.kind = Match(THISCALL); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9314,9 +9365,9 @@ public CallKindContext callKind() { case 7: EnterOuterAlt(_localctx, 7); { - State = 1990; + State = 2010; Match(UNMANAGED); - State = 1991; + State = 2011; _localctx.kind = Match(FASTCALL); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9324,7 +9375,7 @@ public CallKindContext callKind() { case 8: EnterOuterAlt(_localctx, 8); { - State = 1993; + State = 2013; _localctx.kind = Match(UNMANAGED); _localctx.Value = Actions.GetCallingConvention(_localctx.kind); } @@ -9365,18 +9416,18 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public MdtokenContext mdtoken() { MdtokenContext _localctx = new MdtokenContext(Context, State); - EnterRule(_localctx, 174, RULE_mdtoken); + EnterRule(_localctx, 176, RULE_mdtoken); Actions.BeginSemanticRoot(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 1997; + State = 2017; Match(T__112); - State = 1998; + State = 2018; Match(T__29); - State = 1999; + State = 2019; _localctx.token = int32(); - State = 2000; + State = 2020; Match(T__30); _localctx.Value = Actions.ParseInt32((_localctx.token!=null?(_localctx.token.Start):null)); } @@ -9424,17 +9475,17 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public MemberRefContext memberRef() { MemberRefContext _localctx = new MemberRefContext(Context, State); - EnterRule(_localctx, 176, RULE_memberRef); + EnterRule(_localctx, 178, RULE_memberRef); try { - State = 2014; + State = 2034; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case METHOD: EnterOuterAlt(_localctx, 1); { - State = 2003; + State = 2023; Match(METHOD); - State = 2004; + State = 2024; _localctx.method = methodRef(); _localctx.Value = Actions.CreateMethodMemberReference(_localctx.method.Value); } @@ -9442,9 +9493,9 @@ public MemberRefContext memberRef() { case T__36: EnterOuterAlt(_localctx, 2); { - State = 2007; + State = 2027; Match(T__36); - State = 2008; + State = 2028; _localctx.field = fieldRef(); _localctx.Value = Actions.CreateFieldMemberReference(_localctx.field.Value); } @@ -9452,7 +9503,7 @@ public MemberRefContext memberRef() { case T__112: EnterOuterAlt(_localctx, 3); { - State = 2011; + State = 2031; _localctx.token = mdtoken(); _localctx.Value = Actions.CreateTokenMemberReference(_localctx.token.Value); } @@ -9505,22 +9556,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public FieldRefContext fieldRef() { FieldRefContext _localctx = new FieldRefContext(Context, State); - EnterRule(_localctx, 178, RULE_fieldRef); + EnterRule(_localctx, 180, RULE_fieldRef); Actions.BeginSemanticRoot(_localctx); try { - State = 2029; + State = 2049; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,85,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,83,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2016; + State = 2036; _localctx.fieldType = type(); - State = 2017; + State = 2037; _localctx.owner = typeSpec(); - State = 2018; + State = 2038; Match(DCOLON); - State = 2019; + State = 2039; _localctx.name = dottedName(); _localctx.Value = Actions.CreateFieldReference(_localctx.fieldType.Value, _localctx.owner.Value, _localctx.name.Value); } @@ -9528,9 +9579,9 @@ public FieldRefContext fieldRef() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2022; + State = 2042; _localctx.fieldType = type(); - State = 2023; + State = 2043; _localctx.name = dottedName(); _localctx.Value = Actions.CreateFieldReference(_localctx.fieldType.Value, null, _localctx.name.Value); } @@ -9538,7 +9589,7 @@ public FieldRefContext fieldRef() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2026; + State = 2046; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateTypedefFieldReference(_localctx.Start, _localctx.alias.Value); } @@ -9583,32 +9634,32 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TypeListContext typeList() { TypeListContext _localctx = new TypeListContext(Context, State); - EnterRule(_localctx, 180, RULE_typeList); + EnterRule(_localctx, 182, RULE_typeList); Actions.BeginGenericTypeList(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 2037; + State = 2057; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,86,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,84,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2031; + State = 2051; _localctx.item = typeSpec(); Actions.AddGenericType(_localctx, _localctx.item.Value); - State = 2033; + State = 2053; Match(T__27); } } } - State = 2039; + State = 2059; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,86,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,84,Context); } - State = 2040; + State = 2060; _localctx.tail = typeSpec(); Actions.AddGenericType(_localctx, _localctx.tail.Value); } @@ -9647,10 +9698,10 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TyparsClauseContext typarsClause() { TyparsClauseContext _localctx = new TyparsClauseContext(Context, State); - EnterRule(_localctx, 182, RULE_typarsClause); + EnterRule(_localctx, 184, RULE_typarsClause); _localctx.Value = Actions.CreateEmptyGenericParameterList(); try { - State = 2049; + State = 2069; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: @@ -9665,11 +9716,11 @@ public TyparsClauseContext typarsClause() { case T__85: EnterOuterAlt(_localctx, 2); { - State = 2044; + State = 2064; Match(T__85); - State = 2045; + State = 2065; _localctx.parameters = typars(); - State = 2046; + State = 2066; Match(T__86); _localctx.Value = _localctx.parameters.Value; } @@ -9719,15 +9770,15 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TyparAttribContext typarAttrib() { TyparAttribContext _localctx = new TyparAttribContext(Context, State); - EnterRule(_localctx, 184, RULE_typarAttrib); + EnterRule(_localctx, 186, RULE_typarAttrib); try { - State = 2069; + State = 2089; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case PLUS: EnterOuterAlt(_localctx, 1); { - State = 2051; + State = 2071; _localctx.covariant = Match(PLUS); _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.covariant); } @@ -9735,7 +9786,7 @@ public TyparAttribContext typarAttrib() { case T__113: EnterOuterAlt(_localctx, 2); { - State = 2053; + State = 2073; _localctx.contravariant = Match(T__113); _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.contravariant); } @@ -9743,7 +9794,7 @@ public TyparAttribContext typarAttrib() { case T__38: EnterOuterAlt(_localctx, 3); { - State = 2055; + State = 2075; _localctx.@class = Match(T__38); _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.@class); } @@ -9751,7 +9802,7 @@ public TyparAttribContext typarAttrib() { case VALUETYPE: EnterOuterAlt(_localctx, 4); { - State = 2057; + State = 2077; _localctx.valuetype = Match(VALUETYPE); _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.valuetype); } @@ -9759,7 +9810,7 @@ public TyparAttribContext typarAttrib() { case T__114: EnterOuterAlt(_localctx, 5); { - State = 2059; + State = 2079; _localctx.byrefLike = Match(T__114); _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.byrefLike); } @@ -9767,7 +9818,7 @@ public TyparAttribContext typarAttrib() { case T__115: EnterOuterAlt(_localctx, 6); { - State = 2061; + State = 2081; _localctx.ctor = Match(T__115); _localctx.Value = Actions.CreateGenericParameterAttribute(_localctx.ctor); } @@ -9775,13 +9826,13 @@ public TyparAttribContext typarAttrib() { case T__69: EnterOuterAlt(_localctx, 7); { - State = 2063; + State = 2083; Match(T__69); - State = 2064; + State = 2084; Match(T__29); - State = 2065; + State = 2085; _localctx.flags = int32(); - State = 2066; + State = 2086; Match(T__30); _localctx.Value = Actions.CreateRawGenericParameterAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } @@ -9826,24 +9877,24 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TyparAttribsContext typarAttribs() { TyparAttribsContext _localctx = new TyparAttribsContext(Context, State); - EnterRule(_localctx, 186, RULE_typarAttribs); + EnterRule(_localctx, 188, RULE_typarAttribs); Actions.BeginGenericParameterAttributes(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2076; + State = 2096; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__38 || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & 123145302310913L) != 0) || _la==VALUETYPE || _la==PLUS) { { { - State = 2071; + State = 2091; _localctx.attribute = typarAttrib(); Actions.AddGenericParameterAttribute(_localctx, _localctx.attribute.Value); } } - State = 2078; + State = 2098; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -9891,24 +9942,24 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TyparContext typar() { TyparContext _localctx = new TyparContext(Context, State); - EnterRule(_localctx, 188, RULE_typar); + EnterRule(_localctx, 190, RULE_typar); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2079; + State = 2099; _localctx.attributes = typarAttribs(); - State = 2081; + State = 2101; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__29) { { - State = 2080; + State = 2100; _localctx.constraints = tyBound(); } } - State = 2083; + State = 2103; _localctx.name = dottedName(); _localctx.Value = Actions.CreateGenericParameterDeclaration(_localctx.attributes.Value, _localctx.constraints, _localctx.name.Value); } @@ -9950,32 +10001,32 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TyparsContext typars() { TyparsContext _localctx = new TyparsContext(Context, State); - EnterRule(_localctx, 190, RULE_typars); + EnterRule(_localctx, 192, RULE_typars); Actions.BeginGenericParameters(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 2092; + State = 2112; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2086; + State = 2106; _localctx.parameter = typar(); Actions.AddGenericParameter(_localctx, _localctx.parameter.Value); - State = 2088; + State = 2108; Match(T__27); } } } - State = 2094; + State = 2114; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,89,Context); } - State = 2095; + State = 2115; _localctx.tail = typar(); Actions.AddGenericParameter(_localctx, _localctx.tail.Value); } @@ -10014,15 +10065,15 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TyBoundContext tyBound() { TyBoundContext _localctx = new TyBoundContext(Context, State); - EnterRule(_localctx, 192, RULE_tyBound); + EnterRule(_localctx, 194, RULE_tyBound); try { EnterOuterAlt(_localctx, 1); { - State = 2098; + State = 2118; Match(T__29); - State = 2099; + State = 2119; _localctx.constraints = typeList(); - State = 2100; + State = 2120; Match(T__30); _localctx.Value = _localctx.constraints.Value; } @@ -10060,17 +10111,17 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public GenArityContext genArity() { GenArityContext _localctx = new GenArityContext(Context, State); - EnterRule(_localctx, 194, RULE_genArity); + EnterRule(_localctx, 196, RULE_genArity); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2104; + State = 2124; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__85) { { - State = 2103; + State = 2123; _localctx.value = genArityNotEmpty(); } } @@ -10111,19 +10162,19 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public GenArityNotEmptyContext genArityNotEmpty() { GenArityNotEmptyContext _localctx = new GenArityNotEmptyContext(Context, State); - EnterRule(_localctx, 196, RULE_genArityNotEmpty); + EnterRule(_localctx, 198, RULE_genArityNotEmpty); try { EnterOuterAlt(_localctx, 1); { - State = 2108; + State = 2128; Match(T__85); - State = 2109; + State = 2129; Match(T__41); - State = 2110; + State = 2130; _localctx.value = int32(); - State = 2111; + State = 2131; Match(T__42); - State = 2112; + State = 2132; Match(T__86); _localctx.Value = Actions.ParseInt32((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -10295,78 +10346,78 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ClassDeclContext classDecl() { ClassDeclContext _localctx = new ClassDeclContext(Context, State); - EnterRule(_localctx, 198, RULE_classDecl); + EnterRule(_localctx, 200, RULE_classDecl); BeginStreaming(); try { int _alt; - State = 2265; + State = 2285; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,97,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,95,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2115; + State = 2135; methodHead(); - State = 2116; + State = 2136; Match(T__16); - State = 2117; + State = 2137; methodDecls(); - State = 2118; + State = 2138; Match(T__17); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2120; + State = 2140; classHead(); - State = 2121; + State = 2141; Match(T__16); - State = 2122; + State = 2142; classDecls(); - State = 2123; + State = 2143; Match(T__17); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2125; + State = 2145; _localctx.eventHeader = eventHead(); Actions.BeginEvent(_localctx, _localctx.eventHeader.Value); - State = 2127; + State = 2147; Match(T__16); - State = 2128; + State = 2148; eventDecls(); - State = 2129; + State = 2149; Match(T__17); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2131; + State = 2151; _localctx.property = propHead(); Actions.BeginProperty(_localctx, _localctx.property.Value); - State = 2133; + State = 2153; Match(T__16); - State = 2134; + State = 2154; propDecls(); - State = 2135; + State = 2155; Match(T__17); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2137; + State = 2157; fieldDecl(); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 2138; + State = 2158; _localctx.data = dataDecl(); Actions.ProcessClassDataDeclaration(_localctx.data); } @@ -10374,7 +10425,7 @@ public ClassDeclContext classDecl() { case 7: EnterOuterAlt(_localctx, 7); { - State = 2141; + State = 2161; _localctx.security = secDecl(); Actions.ProcessClassSecurityDeclaration(_localctx.security); } @@ -10382,7 +10433,7 @@ public ClassDeclContext classDecl() { case 8: EnterOuterAlt(_localctx, 8); { - State = 2144; + State = 2164; _localctx.source = extSourceSpec(); Actions.ProcessClassSourceDirective(_localctx.source); } @@ -10390,7 +10441,7 @@ public ClassDeclContext classDecl() { case 9: EnterOuterAlt(_localctx, 9); { - State = 2147; + State = 2167; _localctx.attribute = customAttrDecl(); Actions.ProcessClassCustomAttribute(_localctx.attribute); } @@ -10398,9 +10449,9 @@ public ClassDeclContext classDecl() { case 10: EnterOuterAlt(_localctx, 10); { - State = 2150; + State = 2170; Match(T__116); - State = 2151; + State = 2171; _localctx.size = int32(); Actions.SetClassSize((_localctx.size!=null?(_localctx.size.Start):null)); } @@ -10408,9 +10459,9 @@ public ClassDeclContext classDecl() { case 11: EnterOuterAlt(_localctx, 11); { - State = 2154; + State = 2174; Match(T__117); - State = 2155; + State = 2175; _localctx.packing = int32(); Actions.SetClassPackingSize((_localctx.packing!=null?(_localctx.packing.Start):null)); } @@ -10418,13 +10469,13 @@ public ClassDeclContext classDecl() { case 12: EnterOuterAlt(_localctx, 12); { - State = 2158; + State = 2178; _localctx.export = exportHead(); - State = 2159; + State = 2179; Match(T__16); - State = 2160; + State = 2180; _localctx.exportDeclarations = exptypeDecls(); - State = 2161; + State = 2181; Match(T__17); Actions.ProcessClassExport(_localctx.export, _localctx.exportDeclarations); } @@ -10432,27 +10483,27 @@ public ClassDeclContext classDecl() { case 13: EnterOuterAlt(_localctx, 13); { - State = 2164; + State = 2184; Match(OVERRIDE); - State = 2165; + State = 2185; _localctx.declarationOwner = typeSpec(); - State = 2166; + State = 2186; Match(DCOLON); - State = 2167; + State = 2187; _localctx.declarationName = methodName(); - State = 2168; + State = 2188; Match(T__118); - State = 2169; + State = 2189; _localctx.bodyConvention = callConv(); - State = 2170; + State = 2190; _localctx.bodyReturnType = type(); - State = 2171; + State = 2191; _localctx.bodyOwner = typeSpec(); - State = 2172; + State = 2192; Match(DCOLON); - State = 2173; + State = 2193; _localctx.bodyName = methodName(); - State = 2174; + State = 2194; _localctx.bodyArguments = sigArgs(); Actions.AddClassMethodOverride( _localctx, @@ -10468,41 +10519,41 @@ public ClassDeclContext classDecl() { case 14: EnterOuterAlt(_localctx, 14); { - State = 2177; + State = 2197; Match(OVERRIDE); - State = 2178; + State = 2198; Match(METHOD); - State = 2179; + State = 2199; _localctx.declarationConvention = callConv(); - State = 2180; + State = 2200; _localctx.declarationReturnType = type(); - State = 2181; + State = 2201; _localctx.declarationOwner = typeSpec(); - State = 2182; + State = 2202; Match(DCOLON); - State = 2183; + State = 2203; _localctx.declarationName = methodName(); - State = 2184; + State = 2204; _localctx.declarationArity = genArity(); - State = 2185; + State = 2205; _localctx.declarationArguments = sigArgs(); - State = 2186; + State = 2206; Match(T__118); - State = 2187; + State = 2207; Match(METHOD); - State = 2188; + State = 2208; _localctx.bodyConvention = callConv(); - State = 2189; + State = 2209; _localctx.bodyReturnType = type(); - State = 2190; + State = 2210; _localctx.bodyOwner = typeSpec(); - State = 2191; + State = 2211; Match(DCOLON); - State = 2192; + State = 2212; _localctx.bodyName = methodName(); - State = 2193; + State = 2213; _localctx.bodyArity = genArity(); - State = 2194; + State = 2214; _localctx.bodyArguments = sigArgs(); Actions.AddClassMethodOverride( _localctx, @@ -10523,7 +10574,7 @@ public ClassDeclContext classDecl() { case 15: EnterOuterAlt(_localctx, 15); { - State = 2197; + State = 2217; _localctx.language = languageDecl(); Actions.ProcessClassLanguageDirective(_localctx.language); } @@ -10531,7 +10582,7 @@ public ClassDeclContext classDecl() { case 16: EnterOuterAlt(_localctx, 16); { - State = 2200; + State = 2220; compControl(); Actions.ProcessClassCompilerControl(); } @@ -10539,145 +10590,145 @@ public ClassDeclContext classDecl() { case 17: EnterOuterAlt(_localctx, 17); { - State = 2203; + State = 2223; Match(PARAM); - State = 2204; + State = 2224; Match(TYPE); - State = 2205; + State = 2225; Match(T__41); - State = 2206; + State = 2226; _localctx.parameterIndex = int32(); - State = 2207; + State = 2227; Match(T__42); Actions.BeginClassGenericParameterDirective(_localctx, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null)); - State = 2214; + State = 2234; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,93,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2209; + State = 2229; _localctx.attribute = customAttrDecl(); Actions.AddClassGenericDirectiveAttribute(_localctx, _localctx.attribute); } } } - State = 2216; + State = 2236; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,93,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); } } break; case 18: EnterOuterAlt(_localctx, 18); { - State = 2217; + State = 2237; Match(PARAM); - State = 2218; + State = 2238; Match(TYPE); - State = 2219; + State = 2239; _localctx.parameterName = dottedName(); Actions.BeginClassGenericParameterDirective(_localctx, _localctx.parameterName.Value); - State = 2226; + State = 2246; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,94,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,92,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2221; + State = 2241; _localctx.attribute = customAttrDecl(); Actions.AddClassGenericDirectiveAttribute(_localctx, _localctx.attribute); } } } - State = 2228; + State = 2248; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,94,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,92,Context); } } break; case 19: EnterOuterAlt(_localctx, 19); { - State = 2229; + State = 2249; Match(PARAM); - State = 2230; + State = 2250; Match(CONSTRAINT); - State = 2231; + State = 2251; Match(T__41); - State = 2232; + State = 2252; _localctx.parameterIndex = int32(); - State = 2233; + State = 2253; Match(T__42); - State = 2234; + State = 2254; Match(T__27); - State = 2235; + State = 2255; _localctx.constraintType = typeSpec(); Actions.BeginClassGenericConstraintDirective(_localctx, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null), _localctx.constraintType.Value); - State = 2242; + State = 2262; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,95,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,93,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2237; + State = 2257; _localctx.attribute = customAttrDecl(); Actions.AddClassGenericDirectiveAttribute(_localctx, _localctx.attribute); } } } - State = 2244; + State = 2264; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,95,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,93,Context); } } break; case 20: EnterOuterAlt(_localctx, 20); { - State = 2245; + State = 2265; Match(PARAM); - State = 2246; + State = 2266; Match(CONSTRAINT); - State = 2247; + State = 2267; _localctx.parameterName = dottedName(); - State = 2248; + State = 2268; Match(T__27); - State = 2249; + State = 2269; _localctx.constraintType = typeSpec(); Actions.BeginClassGenericConstraintDirective(_localctx, _localctx.parameterName.Value, _localctx.constraintType.Value); - State = 2256; + State = 2276; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,96,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,94,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2251; + State = 2271; _localctx.attribute = customAttrDecl(); Actions.AddClassGenericDirectiveAttribute(_localctx, _localctx.attribute); } } } - State = 2258; + State = 2278; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,96,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,94,Context); } } break; case 21: EnterOuterAlt(_localctx, 21); { - State = 2259; + State = 2279; Match(T__119); - State = 2260; + State = 2280; Match(TYPE); - State = 2261; + State = 2281; _localctx.interfaceType = typeSpec(); - State = 2262; + State = 2282; _localctx.interfaceAttribute = customDescr(); Actions.AddInterfaceImplementationAttribute(_localctx, _localctx.interfaceType.Value, _localctx.interfaceAttribute); } @@ -10748,23 +10799,23 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public FieldDeclContext fieldDecl() { FieldDeclContext _localctx = new FieldDeclContext(Context, State); - EnterRule(_localctx, 200, RULE_fieldDecl); + EnterRule(_localctx, 202, RULE_fieldDecl); BeginStreaming(); Actions.BeginFieldDeclaration(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 2267; + State = 2287; Match(T__120); - State = 2268; + State = 2288; _localctx.offset = repeatOpt(); - State = 2280; + State = 2300; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,99,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,97,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { - State = 2278; + State = 2298; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -10783,20 +10834,20 @@ public FieldDeclContext fieldDecl() { case T__125: case T__126: { - State = 2269; + State = 2289; _localctx.attribute = fieldAttr(); Actions.AddFieldAttribute(_localctx, _localctx.attribute.Value); } break; case T__121: { - State = 2272; + State = 2292; Match(T__121); - State = 2273; + State = 2293; Match(T__29); - State = 2274; + State = 2294; _localctx.marshalling = marshalBlob(); - State = 2275; + State = 2295; Match(T__30); Actions.SetFieldMarshalling(_localctx, _localctx.marshalling.Value); } @@ -10806,17 +10857,17 @@ public FieldDeclContext fieldDecl() { } } } - State = 2282; + State = 2302; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,99,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,97,Context); } - State = 2283; + State = 2303; _localctx.fieldType = type(); - State = 2284; + State = 2304; _localctx.name = dottedName(); - State = 2285; + State = 2305; _localctx.data = atOpt(); - State = 2286; + State = 2306; _localctx.initializer = initOpt(); _localctx.Value = Actions.CreateFieldDeclaration( _localctx, @@ -10864,15 +10915,15 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public FieldAttrContext fieldAttr() { FieldAttrContext _localctx = new FieldAttrContext(Context, State); - EnterRule(_localctx, 202, RULE_fieldAttr); + EnterRule(_localctx, 204, RULE_fieldAttr); try { - State = 2323; + State = 2343; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__122: EnterOuterAlt(_localctx, 1); { - State = 2289; + State = 2309; _localctx.attribute = Match(T__122); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10880,7 +10931,7 @@ public FieldAttrContext fieldAttr() { case T__50: EnterOuterAlt(_localctx, 2); { - State = 2291; + State = 2311; _localctx.attribute = Match(T__50); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10888,7 +10939,7 @@ public FieldAttrContext fieldAttr() { case T__51: EnterOuterAlt(_localctx, 3); { - State = 2293; + State = 2313; _localctx.attribute = Match(T__51); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10896,7 +10947,7 @@ public FieldAttrContext fieldAttr() { case T__62: EnterOuterAlt(_localctx, 4); { - State = 2295; + State = 2315; _localctx.attribute = Match(T__62); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10904,7 +10955,7 @@ public FieldAttrContext fieldAttr() { case T__123: EnterOuterAlt(_localctx, 5); { - State = 2297; + State = 2317; _localctx.attribute = Match(T__123); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10912,7 +10963,7 @@ public FieldAttrContext fieldAttr() { case T__68: EnterOuterAlt(_localctx, 6); { - State = 2299; + State = 2319; _localctx.attribute = Match(T__68); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10920,7 +10971,7 @@ public FieldAttrContext fieldAttr() { case T__67: EnterOuterAlt(_localctx, 7); { - State = 2301; + State = 2321; _localctx.attribute = Match(T__67); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10928,7 +10979,7 @@ public FieldAttrContext fieldAttr() { case T__63: EnterOuterAlt(_localctx, 8); { - State = 2303; + State = 2323; _localctx.attribute = Match(T__63); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10936,7 +10987,7 @@ public FieldAttrContext fieldAttr() { case T__64: EnterOuterAlt(_localctx, 9); { - State = 2305; + State = 2325; _localctx.attribute = Match(T__64); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10944,7 +10995,7 @@ public FieldAttrContext fieldAttr() { case T__65: EnterOuterAlt(_localctx, 10); { - State = 2307; + State = 2327; _localctx.attribute = Match(T__65); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10952,7 +11003,7 @@ public FieldAttrContext fieldAttr() { case T__124: EnterOuterAlt(_localctx, 11); { - State = 2309; + State = 2329; _localctx.attribute = Match(T__124); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10960,7 +11011,7 @@ public FieldAttrContext fieldAttr() { case T__125: EnterOuterAlt(_localctx, 12); { - State = 2311; + State = 2331; _localctx.attribute = Match(T__125); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10968,7 +11019,7 @@ public FieldAttrContext fieldAttr() { case T__126: EnterOuterAlt(_localctx, 13); { - State = 2313; + State = 2333; _localctx.attribute = Match(T__126); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10976,7 +11027,7 @@ public FieldAttrContext fieldAttr() { case T__15: EnterOuterAlt(_localctx, 14); { - State = 2315; + State = 2335; _localctx.attribute = Match(T__15); _localctx.Value = Actions.CreateFieldAttribute(_localctx.attribute); } @@ -10984,13 +11035,13 @@ public FieldAttrContext fieldAttr() { case T__69: EnterOuterAlt(_localctx, 15); { - State = 2317; + State = 2337; Match(T__69); - State = 2318; + State = 2338; Match(T__29); - State = 2319; + State = 2339; _localctx.flags = int32(); - State = 2320; + State = 2340; Match(T__30); _localctx.Value = Actions.CreateRawFieldAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } @@ -11036,11 +11087,11 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public AtOptContext atOpt() { AtOptContext _localctx = new AtOptContext(Context, State); - EnterRule(_localctx, 204, RULE_atOpt); + EnterRule(_localctx, 206, RULE_atOpt); try { - State = 2334; + State = 2354; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,101,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,99,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -11049,9 +11100,9 @@ public AtOptContext atOpt() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2326; + State = 2346; Match(T__43); - State = 2327; + State = 2347; _localctx.name = id(); _localctx.Value = Actions.GetFieldDataName((_localctx.name!=null?(_localctx.name.Start):null)); } @@ -11059,9 +11110,9 @@ public AtOptContext atOpt() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2330; + State = 2350; Match(T__43); - State = 2331; + State = 2351; _localctx.offset = int32(); _localctx.Value = Actions.GetFieldDataOffset((_localctx.offset!=null?(_localctx.offset.Start):null)); } @@ -11102,10 +11153,10 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public InitOptContext initOpt() { InitOptContext _localctx = new InitOptContext(Context, State); - EnterRule(_localctx, 206, RULE_initOpt); + EnterRule(_localctx, 208, RULE_initOpt); Actions.BeginFieldInitializer(_localctx); try { - State = 2341; + State = 2361; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -11199,9 +11250,9 @@ public InitOptContext initOpt() { case T__35: EnterOuterAlt(_localctx, 2); { - State = 2337; + State = 2357; Match(T__35); - State = 2338; + State = 2358; _localctx.initializer = fieldInit(); Actions.SetFieldInitializer(_localctx, _localctx.initializer.Value); } @@ -11245,9 +11296,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public RepeatOptContext repeatOpt() { RepeatOptContext _localctx = new RepeatOptContext(Context, State); - EnterRule(_localctx, 208, RULE_repeatOpt); + EnterRule(_localctx, 210, RULE_repeatOpt); try { - State = 2349; + State = 2369; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -11302,11 +11353,11 @@ public RepeatOptContext repeatOpt() { case T__41: EnterOuterAlt(_localctx, 2); { - State = 2344; + State = 2364; Match(T__41); - State = 2345; + State = 2365; _localctx.offset = int32(); - State = 2346; + State = 2366; Match(T__42); Actions.SetFieldOffset(_localctx, (_localctx.offset!=null?(_localctx.offset.Start):null)); } @@ -11359,36 +11410,36 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public EventHeadContext eventHead() { EventHeadContext _localctx = new EventHeadContext(Context, State); - EnterRule(_localctx, 210, RULE_eventHead); + EnterRule(_localctx, 212, RULE_eventHead); Actions.BeginEventHeader(_localctx); int _la; try { - State = 2376; + State = 2396; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,106,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,104,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2351; + State = 2371; Match(T__127); - State = 2357; + State = 2377; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 2352; + State = 2372; _localctx.attribute = eventAttr(); Actions.AddEventAttribute(_localctx, _localctx.attribute.Value); } } - State = 2359; + State = 2379; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2360; + State = 2380; _localctx.eventType = typeSpec(); - State = 2361; + State = 2381; _localctx.name = dottedName(); _localctx.Value = Actions.CreateEventHeader(_localctx, _localctx.eventType.Value, _localctx.name.Value); } @@ -11396,24 +11447,24 @@ public EventHeadContext eventHead() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2364; + State = 2384; Match(T__127); - State = 2370; + State = 2390; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 2365; + State = 2385; _localctx.attribute = eventAttr(); Actions.AddEventAttribute(_localctx, _localctx.attribute.Value); } } - State = 2372; + State = 2392; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2373; + State = 2393; _localctx.name = dottedName(); _localctx.Value = Actions.CreateEventHeader(_localctx, null, _localctx.name.Value); } @@ -11451,15 +11502,15 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public EventAttrContext eventAttr() { EventAttrContext _localctx = new EventAttrContext(Context, State); - EnterRule(_localctx, 212, RULE_eventAttr); + EnterRule(_localctx, 214, RULE_eventAttr); try { - State = 2382; + State = 2402; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__68: EnterOuterAlt(_localctx, 1); { - State = 2378; + State = 2398; _localctx.attribute = Match(T__68); _localctx.Value = Actions.CreateEventAttribute(_localctx.attribute); } @@ -11467,7 +11518,7 @@ public EventAttrContext eventAttr() { case T__67: EnterOuterAlt(_localctx, 2); { - State = 2380; + State = 2400; _localctx.attribute = Match(T__67); _localctx.Value = Actions.CreateEventAttribute(_localctx.attribute); } @@ -11510,22 +11561,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public EventDeclsContext eventDecls() { EventDeclsContext _localctx = new EventDeclsContext(Context, State); - EnterRule(_localctx, 214, RULE_eventDecls); + EnterRule(_localctx, 216, RULE_eventDecls); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2387; + State = 2407; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38788988928L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 1080863910568919043L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 2384; + State = 2404; eventDecl(); } } - State = 2389; + State = 2409; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11578,17 +11629,17 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public EventDeclContext eventDecl() { EventDeclContext _localctx = new EventDeclContext(Context, State); - EnterRule(_localctx, 216, RULE_eventDecl); + EnterRule(_localctx, 218, RULE_eventDecl); try { - State = 2416; + State = 2436; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__128: EnterOuterAlt(_localctx, 1); { - State = 2390; + State = 2410; Match(T__128); - State = 2391; + State = 2411; _localctx.accessor = methodRef(); Actions.AddEventAdder(_localctx, _localctx.accessor.Value); } @@ -11596,9 +11647,9 @@ public EventDeclContext eventDecl() { case T__129: EnterOuterAlt(_localctx, 2); { - State = 2394; + State = 2414; Match(T__129); - State = 2395; + State = 2415; _localctx.accessor = methodRef(); Actions.AddEventRemover(_localctx, _localctx.accessor.Value); } @@ -11606,9 +11657,9 @@ public EventDeclContext eventDecl() { case T__130: EnterOuterAlt(_localctx, 3); { - State = 2398; + State = 2418; Match(T__130); - State = 2399; + State = 2419; _localctx.accessor = methodRef(); Actions.AddEventRaiser(_localctx, _localctx.accessor.Value); } @@ -11616,9 +11667,9 @@ public EventDeclContext eventDecl() { case T__131: EnterOuterAlt(_localctx, 4); { - State = 2402; + State = 2422; Match(T__131); - State = 2403; + State = 2423; _localctx.accessor = methodRef(); Actions.AddEventOther(_localctx, _localctx.accessor.Value); } @@ -11627,7 +11678,7 @@ public EventDeclContext eventDecl() { case T__73: EnterOuterAlt(_localctx, 5); { - State = 2406; + State = 2426; _localctx.source = extSourceSpec(); Actions.ProcessEventSourceDirective(_localctx.source); } @@ -11641,7 +11692,7 @@ public EventDeclContext eventDecl() { case ID: EnterOuterAlt(_localctx, 6); { - State = 2409; + State = 2429; _localctx.attribute = customAttrDecl(); Actions.AddEventCustomAttribute(_localctx, _localctx.attribute); } @@ -11649,7 +11700,7 @@ public EventDeclContext eventDecl() { case T__26: EnterOuterAlt(_localctx, 7); { - State = 2412; + State = 2432; _localctx.language = languageDecl(); Actions.ProcessEventLanguageDirective(_localctx.language); } @@ -11664,7 +11715,7 @@ public EventDeclContext eventDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 8); { - State = 2415; + State = 2435; compControl(); } break; @@ -11728,38 +11779,38 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public PropHeadContext propHead() { PropHeadContext _localctx = new PropHeadContext(Context, State); - EnterRule(_localctx, 218, RULE_propHead); + EnterRule(_localctx, 220, RULE_propHead); Actions.BeginPropertyHeader(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2418; + State = 2438; Match(T__132); - State = 2424; + State = 2444; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__67 || _la==T__68) { { { - State = 2419; + State = 2439; _localctx.attribute = propAttr(); Actions.AddPropertyAttribute(_localctx, _localctx.attribute.Value); } } - State = 2426; + State = 2446; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2427; + State = 2447; _localctx.convention = callConv(); - State = 2428; + State = 2448; _localctx.propertyType = type(); - State = 2429; + State = 2449; _localctx.name = dottedName(); - State = 2430; + State = 2450; _localctx.arguments = sigArgs(); - State = 2431; + State = 2451; _localctx.initializer = initOpt(); _localctx.Value = Actions.CreatePropertyHeader( _localctx, @@ -11801,15 +11852,15 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public PropAttrContext propAttr() { PropAttrContext _localctx = new PropAttrContext(Context, State); - EnterRule(_localctx, 220, RULE_propAttr); + EnterRule(_localctx, 222, RULE_propAttr); try { - State = 2438; + State = 2458; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__68: EnterOuterAlt(_localctx, 1); { - State = 2434; + State = 2454; _localctx.attribute = Match(T__68); _localctx.Value = Actions.CreatePropertyAttribute(_localctx.attribute); } @@ -11817,7 +11868,7 @@ public PropAttrContext propAttr() { case T__67: EnterOuterAlt(_localctx, 2); { - State = 2436; + State = 2456; _localctx.attribute = Match(T__67); _localctx.Value = Actions.CreatePropertyAttribute(_localctx.attribute); } @@ -11860,22 +11911,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public PropDeclsContext propDecls() { PropDeclsContext _localctx = new PropDeclsContext(Context, State); - EnterRule(_localctx, 222, RULE_propDecls); + EnterRule(_localctx, 224, RULE_propDecls); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2443; + State = 2463; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38788988928L) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 7493989779944505347L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 2440; + State = 2460; propDecl(); } } - State = 2445; + State = 2465; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -11928,17 +11979,17 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public PropDeclContext propDecl() { PropDeclContext _localctx = new PropDeclContext(Context, State); - EnterRule(_localctx, 224, RULE_propDecl); + EnterRule(_localctx, 226, RULE_propDecl); try { - State = 2468; + State = 2488; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__133: EnterOuterAlt(_localctx, 1); { - State = 2446; + State = 2466; Match(T__133); - State = 2447; + State = 2467; _localctx.accessor = methodRef(); Actions.AddPropertySetter(_localctx, _localctx.accessor.Value); } @@ -11946,9 +11997,9 @@ public PropDeclContext propDecl() { case T__134: EnterOuterAlt(_localctx, 2); { - State = 2450; + State = 2470; Match(T__134); - State = 2451; + State = 2471; _localctx.accessor = methodRef(); Actions.AddPropertyGetter(_localctx, _localctx.accessor.Value); } @@ -11956,9 +12007,9 @@ public PropDeclContext propDecl() { case T__131: EnterOuterAlt(_localctx, 3); { - State = 2454; + State = 2474; Match(T__131); - State = 2455; + State = 2475; _localctx.accessor = methodRef(); Actions.AddPropertyOther(_localctx, _localctx.accessor.Value); } @@ -11972,7 +12023,7 @@ public PropDeclContext propDecl() { case ID: EnterOuterAlt(_localctx, 4); { - State = 2458; + State = 2478; _localctx.attribute = customAttrDecl(); Actions.AddPropertyCustomAttribute(_localctx, _localctx.attribute); } @@ -11981,7 +12032,7 @@ public PropDeclContext propDecl() { case T__73: EnterOuterAlt(_localctx, 5); { - State = 2461; + State = 2481; _localctx.source = extSourceSpec(); Actions.ProcessPropertySourceDirective(_localctx.source); } @@ -11989,7 +12040,7 @@ public PropDeclContext propDecl() { case T__26: EnterOuterAlt(_localctx, 6); { - State = 2464; + State = 2484; _localctx.language = languageDecl(); Actions.ProcessPropertyLanguageDirective(_localctx.language); } @@ -12004,7 +12055,7 @@ public PropDeclContext propDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 7); { - State = 2467; + State = 2487; compControl(); } break; @@ -12045,9 +12096,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public MarshalClauseContext marshalClause() { MarshalClauseContext _localctx = new MarshalClauseContext(Context, State); - EnterRule(_localctx, 226, RULE_marshalClause); + EnterRule(_localctx, 228, RULE_marshalClause); try { - State = 2477; + State = 2497; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -12084,13 +12135,13 @@ public MarshalClauseContext marshalClause() { case T__121: EnterOuterAlt(_localctx, 2); { - State = 2471; + State = 2491; Match(T__121); - State = 2472; + State = 2492; Match(T__29); - State = 2473; + State = 2493; _localctx.value = marshalBlob(); - State = 2474; + State = 2494; Match(T__30); _localctx.Value = Actions.CompleteMarshalClause(_localctx.value.Value); } @@ -12139,11 +12190,11 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public MarshalBlobContext marshalBlob() { MarshalBlobContext _localctx = new MarshalBlobContext(Context, State); - EnterRule(_localctx, 228, RULE_marshalBlob); + EnterRule(_localctx, 230, RULE_marshalBlob); Actions.BeginMarshalBlob(_localctx); int _la; try { - State = 2492; + State = 2512; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__15: @@ -12198,7 +12249,7 @@ public MarshalBlobContext marshalBlob() { case ID: EnterOuterAlt(_localctx, 1); { - State = 2479; + State = 2499; _localctx.nativeValue = nativeType(); Actions.SetMarshalBlobNativeType(_localctx, _localctx.nativeValue.Value); } @@ -12206,24 +12257,24 @@ public MarshalBlobContext marshalBlob() { case T__16: EnterOuterAlt(_localctx, 2); { - State = 2482; + State = 2502; Match(T__16); - State = 2486; + State = 2506; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2483; + State = 2503; _localctx.rawByte = hexbyte(); Actions.AddMarshalBlobByte(_localctx, _localctx.rawByte.Value); } } - State = 2488; + State = 2508; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( _la==INT32 || _la==ID || _la==HEXBYTE ); - State = 2490; + State = 2510; Match(T__17); } break; @@ -12268,24 +12319,24 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ParamAttrContext paramAttr() { ParamAttrContext _localctx = new ParamAttrContext(Context, State); - EnterRule(_localctx, 230, RULE_paramAttr); + EnterRule(_localctx, 232, RULE_paramAttr); Actions.BeginParameterAttributes(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2499; + State = 2519; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__41) { { { - State = 2494; + State = 2514; _localctx.element = paramAttrElement(); Actions.AddParameterAttribute(_localctx, _localctx.element); } } - State = 2501; + State = 2521; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -12327,19 +12378,19 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ParamAttrElementContext paramAttrElement() { ParamAttrElementContext _localctx = new ParamAttrElementContext(Context, State); - EnterRule(_localctx, 232, RULE_paramAttrElement); + EnterRule(_localctx, 234, RULE_paramAttrElement); try { - State = 2519; + State = 2539; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,118,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,116,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2502; + State = 2522; Match(T__41); - State = 2503; + State = 2523; _localctx.attribute = Match(T__135); - State = 2504; + State = 2524; Match(T__42); Actions.SetParameterAttributeElement(_localctx, _localctx.attribute); } @@ -12347,11 +12398,11 @@ public ParamAttrElementContext paramAttrElement() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2506; + State = 2526; Match(T__41); - State = 2507; + State = 2527; _localctx.attribute = Match(T__136); - State = 2508; + State = 2528; Match(T__42); Actions.SetParameterAttributeElement(_localctx, _localctx.attribute); } @@ -12359,11 +12410,11 @@ public ParamAttrElementContext paramAttrElement() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2510; + State = 2530; Match(T__41); - State = 2511; + State = 2531; _localctx.attribute = Match(T__137); - State = 2512; + State = 2532; Match(T__42); Actions.SetParameterAttributeElement(_localctx, _localctx.attribute); } @@ -12371,11 +12422,11 @@ public ParamAttrElementContext paramAttrElement() { case 4: EnterOuterAlt(_localctx, 4); { - State = 2514; + State = 2534; Match(T__41); - State = 2515; + State = 2535; _localctx.raw = int32(); - State = 2516; + State = 2536; Match(T__42); Actions.SetRawParameterAttributeElement(_localctx, (_localctx.raw!=null?(_localctx.raw.Start):null)); } @@ -12460,20 +12511,20 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public MethodHeadContext methodHead() { MethodHeadContext _localctx = new MethodHeadContext(Context, State); - EnterRule(_localctx, 234, RULE_methodHead); + EnterRule(_localctx, 236, RULE_methodHead); BeginStreaming(); Actions.BeginMethodHeader(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2521; + State = 2541; Match(T__138); - State = 2530; + State = 2550; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & 978955L) != 0) || ((((_la - 123)) & ~0x3f) == 0 && ((1L << (_la - 123)) & 33423365L) != 0)) { { - State = 2528; + State = 2548; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__50: @@ -12496,14 +12547,14 @@ public MethodHeadContext methodHead() { case T__144: case T__145: { - State = 2522; + State = 2542; _localctx.attribute = methAttr(); Actions.AddMethodAttribute(_localctx, _localctx.attribute.Value); } break; case T__146: { - State = 2525; + State = 2545; _localctx.pInvoke = pinvImpl(); Actions.AddPInvoke(_localctx, _localctx.pInvoke.Value); } @@ -12512,36 +12563,36 @@ public MethodHeadContext methodHead() { throw new NoViableAltException(this); } } - State = 2532; + State = 2552; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2533; + State = 2553; _localctx.convention = callConv(); - State = 2534; + State = 2554; _localctx.returnAttributes = paramAttr(); - State = 2535; + State = 2555; _localctx.returnType = type(); - State = 2536; + State = 2556; _localctx.returnMarshalling = marshalClause(); - State = 2537; + State = 2557; _localctx.name = methodName(); - State = 2538; + State = 2558; _localctx.genericParameters = typarsClause(); - State = 2539; + State = 2559; _localctx.arguments = sigArgs(); - State = 2545; + State = 2565; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 32766L) != 0) || _la==T__69 || _la==T__155 || _la==UNMANAGED) { { { - State = 2540; + State = 2560; _localctx.implementation = implAttr(); Actions.AddMethodImplementationAttribute(_localctx, _localctx.implementation.Value); } } - State = 2547; + State = 2567; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -12593,15 +12644,15 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public MethAttrContext methAttr() { MethAttrContext _localctx = new MethAttrContext(Context, State); - EnterRule(_localctx, 236, RULE_methAttr); + EnterRule(_localctx, 238, RULE_methAttr); try { - State = 2592; + State = 2612; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__122: EnterOuterAlt(_localctx, 1); { - State = 2550; + State = 2570; _localctx.attribute = Match(T__122); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12609,7 +12660,7 @@ public MethAttrContext methAttr() { case T__50: EnterOuterAlt(_localctx, 2); { - State = 2552; + State = 2572; _localctx.attribute = Match(T__50); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12617,7 +12668,7 @@ public MethAttrContext methAttr() { case T__51: EnterOuterAlt(_localctx, 3); { - State = 2554; + State = 2574; _localctx.attribute = Match(T__51); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12625,7 +12676,7 @@ public MethAttrContext methAttr() { case T__62: EnterOuterAlt(_localctx, 4); { - State = 2556; + State = 2576; _localctx.attribute = Match(T__62); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12633,7 +12684,7 @@ public MethAttrContext methAttr() { case T__139: EnterOuterAlt(_localctx, 5); { - State = 2558; + State = 2578; _localctx.attribute = Match(T__139); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12641,7 +12692,7 @@ public MethAttrContext methAttr() { case T__67: EnterOuterAlt(_localctx, 6); { - State = 2560; + State = 2580; _localctx.attribute = Match(T__67); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12649,7 +12700,7 @@ public MethAttrContext methAttr() { case T__140: EnterOuterAlt(_localctx, 7); { - State = 2562; + State = 2582; _localctx.attribute = Match(T__140); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12657,7 +12708,7 @@ public MethAttrContext methAttr() { case T__141: EnterOuterAlt(_localctx, 8); { - State = 2564; + State = 2584; _localctx.attribute = Match(T__141); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12665,7 +12716,7 @@ public MethAttrContext methAttr() { case T__53: EnterOuterAlt(_localctx, 9); { - State = 2566; + State = 2586; _localctx.attribute = Match(T__53); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12673,7 +12724,7 @@ public MethAttrContext methAttr() { case T__63: EnterOuterAlt(_localctx, 10); { - State = 2568; + State = 2588; _localctx.attribute = Match(T__63); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12681,7 +12732,7 @@ public MethAttrContext methAttr() { case T__64: EnterOuterAlt(_localctx, 11); { - State = 2570; + State = 2590; _localctx.attribute = Match(T__64); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12689,7 +12740,7 @@ public MethAttrContext methAttr() { case T__65: EnterOuterAlt(_localctx, 12); { - State = 2572; + State = 2592; _localctx.attribute = Match(T__65); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12697,7 +12748,7 @@ public MethAttrContext methAttr() { case T__124: EnterOuterAlt(_localctx, 13); { - State = 2574; + State = 2594; _localctx.attribute = Match(T__124); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12705,7 +12756,7 @@ public MethAttrContext methAttr() { case T__142: EnterOuterAlt(_localctx, 14); { - State = 2576; + State = 2596; _localctx.attribute = Match(T__142); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12713,7 +12764,7 @@ public MethAttrContext methAttr() { case T__143: EnterOuterAlt(_localctx, 15); { - State = 2578; + State = 2598; _localctx.attribute = Match(T__143); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12721,7 +12772,7 @@ public MethAttrContext methAttr() { case T__68: EnterOuterAlt(_localctx, 16); { - State = 2580; + State = 2600; _localctx.attribute = Match(T__68); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12729,7 +12780,7 @@ public MethAttrContext methAttr() { case T__144: EnterOuterAlt(_localctx, 17); { - State = 2582; + State = 2602; _localctx.attribute = Match(T__144); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12737,7 +12788,7 @@ public MethAttrContext methAttr() { case T__145: EnterOuterAlt(_localctx, 18); { - State = 2584; + State = 2604; _localctx.attribute = Match(T__145); _localctx.Value = Actions.CreateMethodAttribute(_localctx.attribute); } @@ -12745,13 +12796,13 @@ public MethAttrContext methAttr() { case T__69: EnterOuterAlt(_localctx, 19); { - State = 2586; + State = 2606; Match(T__69); - State = 2587; + State = 2607; Match(T__29); - State = 2588; + State = 2608; _localctx.flags = int32(); - State = 2589; + State = 2609; Match(T__30); _localctx.Value = Actions.CreateRawMethodAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } @@ -12804,36 +12855,36 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public PinvImplContext pinvImpl() { PinvImplContext _localctx = new PinvImplContext(Context, State); - EnterRule(_localctx, 238, RULE_pinvImpl); + EnterRule(_localctx, 240, RULE_pinvImpl); Actions.BeginPInvoke(_localctx); int _la; try { - State = 2617; + State = 2637; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,126,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,124,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2594; + State = 2614; Match(T__146); - State = 2595; + State = 2615; Match(T__29); - State = 2604; + State = 2624; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==QSTRING) { { - State = 2596; + State = 2616; _localctx.module = compQstring(); Actions.SetPInvokeModule(_localctx, _localctx.module.Value); - State = 2602; + State = 2622; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__33) { { - State = 2598; + State = 2618; Match(T__33); - State = 2599; + State = 2619; _localctx.entryPoint = compQstring(); Actions.SetPInvokeEntryPoint(_localctx, _localctx.entryPoint.Value); } @@ -12842,31 +12893,31 @@ public PinvImplContext pinvImpl() { } } - State = 2611; + State = 2631; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 57)) & ~0x3f) == 0 && ((1L << (_la - 57)) & 8195L) != 0) || ((((_la - 148)) & ~0x3f) == 0 && ((1L << (_la - 148)) & 79L) != 0) || ((((_la - 224)) & ~0x3f) == 0 && ((1L << (_la - 224)) & 251658241L) != 0)) { { { - State = 2606; + State = 2626; _localctx.attribute = pinvAttr(); Actions.AddPInvokeAttribute(_localctx, _localctx.attribute.Value); } } - State = 2613; + State = 2633; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 2614; + State = 2634; Match(T__30); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2615; + State = 2635; Match(T__146); - State = 2616; + State = 2636; Match(T__84); } break; @@ -12913,15 +12964,15 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public PinvAttrContext pinvAttr() { PinvAttrContext _localctx = new PinvAttrContext(Context, State); - EnterRule(_localctx, 240, RULE_pinvAttr); + EnterRule(_localctx, 242, RULE_pinvAttr); try { - State = 2661; + State = 2681; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,127,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,125,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2619; + State = 2639; _localctx.attribute = Match(T__147); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12929,7 +12980,7 @@ public PinvAttrContext pinvAttr() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2621; + State = 2641; _localctx.attribute = Match(ANSI); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12937,7 +12988,7 @@ public PinvAttrContext pinvAttr() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2623; + State = 2643; _localctx.attribute = Match(T__56); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12945,7 +12996,7 @@ public PinvAttrContext pinvAttr() { case 4: EnterOuterAlt(_localctx, 4); { - State = 2625; + State = 2645; _localctx.attribute = Match(T__57); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12953,7 +13004,7 @@ public PinvAttrContext pinvAttr() { case 5: EnterOuterAlt(_localctx, 5); { - State = 2627; + State = 2647; _localctx.attribute = Match(T__148); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12961,7 +13012,7 @@ public PinvAttrContext pinvAttr() { case 6: EnterOuterAlt(_localctx, 6); { - State = 2629; + State = 2649; _localctx.attribute = Match(T__149); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12969,7 +13020,7 @@ public PinvAttrContext pinvAttr() { case 7: EnterOuterAlt(_localctx, 7); { - State = 2631; + State = 2651; _localctx.attribute = Match(CDECL); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12977,7 +13028,7 @@ public PinvAttrContext pinvAttr() { case 8: EnterOuterAlt(_localctx, 8); { - State = 2633; + State = 2653; _localctx.attribute = Match(STDCALL); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12985,7 +13036,7 @@ public PinvAttrContext pinvAttr() { case 9: EnterOuterAlt(_localctx, 9); { - State = 2635; + State = 2655; _localctx.attribute = Match(THISCALL); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -12993,7 +13044,7 @@ public PinvAttrContext pinvAttr() { case 10: EnterOuterAlt(_localctx, 10); { - State = 2637; + State = 2657; _localctx.attribute = Match(FASTCALL); _localctx.Value = Actions.CreatePInvokeAttribute(_localctx.attribute); } @@ -13001,11 +13052,11 @@ public PinvAttrContext pinvAttr() { case 11: EnterOuterAlt(_localctx, 11); { - State = 2639; + State = 2659; Match(T__150); - State = 2640; + State = 2660; Match(T__74); - State = 2641; + State = 2661; _localctx.setting = Match(T__151); _localctx.Value = Actions.CreateBestFitPInvokeAttribute(_localctx.setting); } @@ -13013,11 +13064,11 @@ public PinvAttrContext pinvAttr() { case 12: EnterOuterAlt(_localctx, 12); { - State = 2643; + State = 2663; Match(T__150); - State = 2644; + State = 2664; Match(T__74); - State = 2645; + State = 2665; _localctx.setting = Match(T__152); _localctx.Value = Actions.CreateBestFitPInvokeAttribute(_localctx.setting); } @@ -13025,11 +13076,11 @@ public PinvAttrContext pinvAttr() { case 13: EnterOuterAlt(_localctx, 13); { - State = 2647; + State = 2667; Match(T__153); - State = 2648; + State = 2668; Match(T__74); - State = 2649; + State = 2669; _localctx.setting = Match(T__151); _localctx.Value = Actions.CreateCharMapErrorPInvokeAttribute(_localctx.setting); } @@ -13037,11 +13088,11 @@ public PinvAttrContext pinvAttr() { case 14: EnterOuterAlt(_localctx, 14); { - State = 2651; + State = 2671; Match(T__153); - State = 2652; + State = 2672; Match(T__74); - State = 2653; + State = 2673; _localctx.setting = Match(T__152); _localctx.Value = Actions.CreateCharMapErrorPInvokeAttribute(_localctx.setting); } @@ -13049,13 +13100,13 @@ public PinvAttrContext pinvAttr() { case 15: EnterOuterAlt(_localctx, 15); { - State = 2655; + State = 2675; Match(T__69); - State = 2656; + State = 2676; Match(T__29); - State = 2657; + State = 2677; _localctx.flags = int32(); - State = 2658; + State = 2678; Match(T__30); _localctx.Value = Actions.CreateRawPInvokeAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } @@ -13097,15 +13148,15 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public MethodNameContext methodName() { MethodNameContext _localctx = new MethodNameContext(Context, State); - EnterRule(_localctx, 242, RULE_methodName); + EnterRule(_localctx, 244, RULE_methodName); try { - State = 2670; + State = 2690; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__115: EnterOuterAlt(_localctx, 1); { - State = 2663; + State = 2683; _localctx.ctorName = Match(T__115); _localctx.Value = Actions.GetMethodName(_localctx.ctorName); } @@ -13113,7 +13164,7 @@ public MethodNameContext methodName() { case T__154: EnterOuterAlt(_localctx, 2); { - State = 2665; + State = 2685; _localctx.cctorName = Match(T__154); _localctx.Value = Actions.GetMethodName(_localctx.cctorName); } @@ -13126,7 +13177,7 @@ public MethodNameContext methodName() { case ID: EnterOuterAlt(_localctx, 3); { - State = 2667; + State = 2687; _localctx.dotted = dottedName(); _localctx.Value = _localctx.dotted.Value; } @@ -13170,15 +13221,15 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ImplAttrContext implAttr() { ImplAttrContext _localctx = new ImplAttrContext(Context, State); - EnterRule(_localctx, 244, RULE_implAttr); + EnterRule(_localctx, 246, RULE_implAttr); try { - State = 2710; + State = 2730; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: EnterOuterAlt(_localctx, 1); { - State = 2672; + State = 2692; _localctx.attribute = Match(T__0); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13186,7 +13237,7 @@ public ImplAttrContext implAttr() { case T__1: EnterOuterAlt(_localctx, 2); { - State = 2674; + State = 2694; _localctx.attribute = Match(T__1); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13194,7 +13245,7 @@ public ImplAttrContext implAttr() { case T__155: EnterOuterAlt(_localctx, 3); { - State = 2676; + State = 2696; _localctx.attribute = Match(T__155); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13202,7 +13253,7 @@ public ImplAttrContext implAttr() { case T__2: EnterOuterAlt(_localctx, 4); { - State = 2678; + State = 2698; _localctx.attribute = Match(T__2); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13210,7 +13261,7 @@ public ImplAttrContext implAttr() { case T__3: EnterOuterAlt(_localctx, 5); { - State = 2680; + State = 2700; _localctx.attribute = Match(T__3); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13218,7 +13269,7 @@ public ImplAttrContext implAttr() { case UNMANAGED: EnterOuterAlt(_localctx, 6); { - State = 2682; + State = 2702; _localctx.attribute = Match(UNMANAGED); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13226,7 +13277,7 @@ public ImplAttrContext implAttr() { case T__4: EnterOuterAlt(_localctx, 7); { - State = 2684; + State = 2704; _localctx.attribute = Match(T__4); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13234,7 +13285,7 @@ public ImplAttrContext implAttr() { case T__5: EnterOuterAlt(_localctx, 8); { - State = 2686; + State = 2706; _localctx.attribute = Match(T__5); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13242,7 +13293,7 @@ public ImplAttrContext implAttr() { case T__6: EnterOuterAlt(_localctx, 9); { - State = 2688; + State = 2708; _localctx.attribute = Match(T__6); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13250,7 +13301,7 @@ public ImplAttrContext implAttr() { case T__7: EnterOuterAlt(_localctx, 10); { - State = 2690; + State = 2710; _localctx.attribute = Match(T__7); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13258,7 +13309,7 @@ public ImplAttrContext implAttr() { case T__8: EnterOuterAlt(_localctx, 11); { - State = 2692; + State = 2712; _localctx.attribute = Match(T__8); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13266,7 +13317,7 @@ public ImplAttrContext implAttr() { case T__9: EnterOuterAlt(_localctx, 12); { - State = 2694; + State = 2714; _localctx.attribute = Match(T__9); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13274,7 +13325,7 @@ public ImplAttrContext implAttr() { case T__10: EnterOuterAlt(_localctx, 13); { - State = 2696; + State = 2716; _localctx.attribute = Match(T__10); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13282,7 +13333,7 @@ public ImplAttrContext implAttr() { case T__11: EnterOuterAlt(_localctx, 14); { - State = 2698; + State = 2718; _localctx.attribute = Match(T__11); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13290,7 +13341,7 @@ public ImplAttrContext implAttr() { case T__12: EnterOuterAlt(_localctx, 15); { - State = 2700; + State = 2720; _localctx.attribute = Match(T__12); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13298,7 +13349,7 @@ public ImplAttrContext implAttr() { case T__13: EnterOuterAlt(_localctx, 16); { - State = 2702; + State = 2722; _localctx.attribute = Match(T__13); _localctx.Value = Actions.CreateMethodImplementationAttribute(_localctx.attribute); } @@ -13306,13 +13357,13 @@ public ImplAttrContext implAttr() { case T__69: EnterOuterAlt(_localctx, 17); { - State = 2704; + State = 2724; Match(T__69); - State = 2705; + State = 2725; Match(T__29); - State = 2706; + State = 2726; _localctx.flags = int32(); - State = 2707; + State = 2727; Match(T__30); _localctx.Value = Actions.CreateRawMethodImplementationAttribute((_localctx.flags!=null?(_localctx.flags.Start):null)); } @@ -13355,23 +13406,23 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public MethodDeclsContext methodDecls() { MethodDeclsContext _localctx = new MethodDeclsContext(Context, State); - EnterRule(_localctx, 246, RULE_methodDecls); + EnterRule(_localctx, 248, RULE_methodDecls); BeginStreaming(); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2715; + State = 2735; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38789119998L) != 0) || _la==T__72 || _la==T__73 || ((((_la - 158)) & ~0x3f) == 0 && ((1L << (_la - 158)) & 2199023255681L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 2303696760354115601L) != 0)) { { { - State = 2712; + State = 2732; methodDecl(); } } - State = 2717; + State = 2737; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -13464,9 +13515,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public MethodDeclContext methodDecl() { MethodDeclContext _localctx = new MethodDeclContext(Context, State); - EnterRule(_localctx, 248, RULE_methodDecl); + EnterRule(_localctx, 250, RULE_methodDecl); try { - State = 2755; + State = 2775; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case INSTR_NONE: @@ -13484,16 +13535,16 @@ public MethodDeclContext methodDecl() { case INSTR_TOK: EnterOuterAlt(_localctx, 1); { - State = 2718; + State = 2738; instr(); } break; case EMITBYTE: EnterOuterAlt(_localctx, 2); { - State = 2719; + State = 2739; Match(EMITBYTE); - State = 2720; + State = 2740; _localctx.value = int32(); Actions.EmitByte((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -13501,16 +13552,16 @@ public MethodDeclContext methodDecl() { case T__157: EnterOuterAlt(_localctx, 3); { - State = 2723; + State = 2743; sehBlock(); } break; case MAXSTACK: EnterOuterAlt(_localctx, 4); { - State = 2724; + State = 2744; Match(MAXSTACK); - State = 2725; + State = 2745; _localctx.value = int32(); Actions.SetMaxStack((_localctx.value!=null?(_localctx.value.Start):null)); } @@ -13518,7 +13569,7 @@ public MethodDeclContext methodDecl() { case ENTRYPOINT: EnterOuterAlt(_localctx, 5); { - State = 2728; + State = 2748; Match(ENTRYPOINT); Actions.SetEntryPoint(); } @@ -13526,7 +13577,7 @@ public MethodDeclContext methodDecl() { case ZEROINIT: EnterOuterAlt(_localctx, 6); { - State = 2730; + State = 2750; Match(ZEROINIT); Actions.SetZeroInit(); } @@ -13553,28 +13604,28 @@ public MethodDeclContext methodDecl() { case ID: EnterOuterAlt(_localctx, 7); { - State = 2732; + State = 2752; labelDecl(); } break; case T__16: EnterOuterAlt(_localctx, 8); { - State = 2733; + State = 2753; scopeBlock(); } break; case LOCALS: EnterOuterAlt(_localctx, 9); { - State = 2734; + State = 2754; localsDecl(); } break; case T__164: EnterOuterAlt(_localctx, 10); { - State = 2735; + State = 2755; _localctx.declaration = dataDecl(); Actions.ProcessMethodDataDeclaration(_localctx.declaration); } @@ -13583,7 +13634,7 @@ public MethodDeclContext methodDecl() { case PERMISSIONSET: EnterOuterAlt(_localctx, 11); { - State = 2738; + State = 2758; _localctx.security = secDecl(); Actions.ProcessMethodSecurityDeclaration(_localctx.security); } @@ -13592,7 +13643,7 @@ public MethodDeclContext methodDecl() { case T__73: EnterOuterAlt(_localctx, 12); { - State = 2741; + State = 2761; _localctx.source = extSourceSpec(); Actions.ProcessMethodSourceDirective(_localctx.source); } @@ -13600,7 +13651,7 @@ public MethodDeclContext methodDecl() { case T__26: EnterOuterAlt(_localctx, 13); { - State = 2744; + State = 2764; _localctx.language = languageDecl(); Actions.ProcessMethodLanguageDirective(_localctx.language); } @@ -13608,7 +13659,7 @@ public MethodDeclContext methodDecl() { case T__34: EnterOuterAlt(_localctx, 14); { - State = 2747; + State = 2767; _localctx.attribute = customDescrInMethodBody(); Actions.ProcessMethodCustomAttribute(_localctx.attribute); } @@ -13623,35 +13674,35 @@ public MethodDeclContext methodDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 15); { - State = 2750; + State = 2770; compControl(); } break; case EXPORT: EnterOuterAlt(_localctx, 16); { - State = 2751; + State = 2771; exportDecl(); } break; case VTENTRY: EnterOuterAlt(_localctx, 17); { - State = 2752; + State = 2772; vtentryDecl(); } break; case OVERRIDE: EnterOuterAlt(_localctx, 18); { - State = 2753; + State = 2773; overrideDecl(); } break; case PARAM: EnterOuterAlt(_localctx, 19); { - State = 2754; + State = 2774; parameterDecl(); } break; @@ -13693,25 +13744,25 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public LocalsDeclContext localsDecl() { LocalsDeclContext _localctx = new LocalsDeclContext(Context, State); - EnterRule(_localctx, 250, RULE_localsDecl); + EnterRule(_localctx, 252, RULE_localsDecl); Actions.BeginSemanticRoot(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2757; + State = 2777; Match(LOCALS); - State = 2759; + State = 2779; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__156) { { - State = 2758; + State = 2778; _localctx.initialize = Match(T__156); } } - State = 2761; + State = 2781; _localctx.arguments = sigArgs(); } } @@ -13753,28 +13804,28 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ExportDeclContext exportDecl() { ExportDeclContext _localctx = new ExportDeclContext(Context, State); - EnterRule(_localctx, 252, RULE_exportDecl); + EnterRule(_localctx, 254, RULE_exportDecl); Actions.BeginSemanticRoot(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2763; + State = 2783; Match(EXPORT); - State = 2764; + State = 2784; Match(T__41); - State = 2765; + State = 2785; _localctx.ordinal = int32(); - State = 2766; + State = 2786; Match(T__42); - State = 2769; + State = 2789; ErrorHandler.Sync(this); _la = TokenStream.LA(1); if (_la==T__33) { { - State = 2767; + State = 2787; Match(T__33); - State = 2768; + State = 2788; _localctx.alias = id(); } } @@ -13819,18 +13870,18 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public VtentryDeclContext vtentryDecl() { VtentryDeclContext _localctx = new VtentryDeclContext(Context, State); - EnterRule(_localctx, 254, RULE_vtentryDecl); + EnterRule(_localctx, 256, RULE_vtentryDecl); Actions.BeginSemanticRoot(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 2771; + State = 2791; Match(VTENTRY); - State = 2772; + State = 2792; _localctx.table = int32(); - State = 2773; + State = 2793; Match(T__74); - State = 2774; + State = 2794; _localctx.slot = int32(); } } @@ -13890,45 +13941,45 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public OverrideDeclContext overrideDecl() { OverrideDeclContext _localctx = new OverrideDeclContext(Context, State); - EnterRule(_localctx, 256, RULE_overrideDecl); + EnterRule(_localctx, 258, RULE_overrideDecl); Actions.BeginSemanticRoot(_localctx); try { - State = 2791; + State = 2811; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,134,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,132,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2776; + State = 2796; Match(OVERRIDE); - State = 2777; + State = 2797; _localctx.owner = typeSpec(); - State = 2778; + State = 2798; Match(DCOLON); - State = 2779; + State = 2799; _localctx.name = methodName(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2781; + State = 2801; Match(OVERRIDE); - State = 2782; + State = 2802; Match(METHOD); - State = 2783; + State = 2803; _localctx.convention = callConv(); - State = 2784; + State = 2804; _localctx.returnType = type(); - State = 2785; + State = 2805; _localctx.owner = typeSpec(); - State = 2786; + State = 2806; Match(DCOLON); - State = 2787; + State = 2807; _localctx.name = methodName(); - State = 2788; + State = 2808; _localctx.arity = genArity(); - State = 2789; + State = 2809; _localctx.arguments = sigArgs(); } break; @@ -13992,170 +14043,170 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ParameterDeclContext parameterDecl() { ParameterDeclContext _localctx = new ParameterDeclContext(Context, State); - EnterRule(_localctx, 258, RULE_parameterDecl); + EnterRule(_localctx, 260, RULE_parameterDecl); Actions.BeginParameterDirective(_localctx); try { int _alt; - State = 2858; + State = 2878; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,140,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,138,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2793; + State = 2813; Match(PARAM); - State = 2794; + State = 2814; Match(TYPE); - State = 2795; + State = 2815; Match(T__41); - State = 2796; + State = 2816; _localctx.genericIndex = int32(); - State = 2797; + State = 2817; Match(T__42); - State = 2803; + State = 2823; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,135,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,133,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2798; + State = 2818; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2805; + State = 2825; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,135,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,133,Context); } } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2806; + State = 2826; Match(PARAM); - State = 2807; + State = 2827; Match(TYPE); - State = 2808; + State = 2828; _localctx.genericName = dottedName(); - State = 2814; + State = 2834; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,136,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,134,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2809; + State = 2829; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2816; + State = 2836; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,136,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,134,Context); } } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 2817; + State = 2837; Match(PARAM); - State = 2818; + State = 2838; Match(CONSTRAINT); - State = 2819; + State = 2839; Match(T__41); - State = 2820; + State = 2840; _localctx.constraintIndex = int32(); - State = 2821; + State = 2841; Match(T__42); - State = 2822; + State = 2842; Match(T__27); - State = 2823; + State = 2843; _localctx.constraintType = typeSpec(); - State = 2829; + State = 2849; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,137,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,135,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2824; + State = 2844; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2831; + State = 2851; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,137,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,135,Context); } } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 2832; + State = 2852; Match(PARAM); - State = 2833; + State = 2853; Match(CONSTRAINT); - State = 2834; + State = 2854; _localctx.constraintName = dottedName(); - State = 2835; + State = 2855; Match(T__27); - State = 2836; + State = 2856; _localctx.constraintType = typeSpec(); - State = 2842; + State = 2862; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,138,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,136,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2837; + State = 2857; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2844; + State = 2864; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,138,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,136,Context); } } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 2845; + State = 2865; Match(PARAM); - State = 2846; + State = 2866; Match(T__41); - State = 2847; + State = 2867; _localctx.parameterIndex = int32(); - State = 2848; + State = 2868; Match(T__42); - State = 2849; + State = 2869; _localctx.initializer = initOpt(); - State = 2855; + State = 2875; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,139,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,137,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2850; + State = 2870; _localctx.attribute = customAttrDecl(); Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); } } } - State = 2857; + State = 2877; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,139,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,137,Context); } } break; @@ -14194,13 +14245,13 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public LabelDeclContext labelDecl() { LabelDeclContext _localctx = new LabelDeclContext(Context, State); - EnterRule(_localctx, 260, RULE_labelDecl); + EnterRule(_localctx, 262, RULE_labelDecl); try { EnterOuterAlt(_localctx, 1); { - State = 2860; + State = 2880; _localctx.name = id(); - State = 2861; + State = 2881; Match(T__74); Actions.DefineLabel((_localctx.name!=null?(_localctx.name.Start):null)); } @@ -14243,16 +14294,16 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public CustomDescrInMethodBodyContext customDescrInMethodBody() { CustomDescrInMethodBodyContext _localctx = new CustomDescrInMethodBodyContext(Context, State); - EnterRule(_localctx, 262, RULE_customDescrInMethodBody); + EnterRule(_localctx, 264, RULE_customDescrInMethodBody); Actions.BeginSemanticRoot(_localctx); try { - State = 2870; + State = 2890; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,141,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,139,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2864; + State = 2884; _localctx.directAttribute = customDescr(); _localctx.Value = Actions.CreateCustomAttributeDeclaration(_localctx.directAttribute.Value); } @@ -14260,7 +14311,7 @@ public CustomDescrInMethodBodyContext customDescrInMethodBody() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2867; + State = 2887; _localctx.ownedAttribute = customDescrWithOwner(); _localctx.Value = Actions.CreateCustomAttributeDeclaration(_localctx.ownedAttribute.Value); } @@ -14299,16 +14350,16 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ScopeBlockContext scopeBlock() { ScopeBlockContext _localctx = new ScopeBlockContext(Context, State); - EnterRule(_localctx, 264, RULE_scopeBlock); + EnterRule(_localctx, 266, RULE_scopeBlock); Actions.BeginScope(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 2872; + State = 2892; Match(T__16); - State = 2873; + State = 2893; methodDecls(); - State = 2874; + State = 2894; Match(T__17); } } @@ -14349,14 +14400,14 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SehBlockContext sehBlock() { SehBlockContext _localctx = new SehBlockContext(Context, State); - EnterRule(_localctx, 266, RULE_sehBlock); + EnterRule(_localctx, 268, RULE_sehBlock); Actions.BeginExceptionBlock(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 2876; + State = 2896; _localctx.tryRange = tryBlock(); - State = 2877; + State = 2897; _localctx.clauses = sehClauses(); } } @@ -14397,24 +14448,24 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SehClausesContext sehClauses() { SehClausesContext _localctx = new SehClausesContext(Context, State); - EnterRule(_localctx, 268, RULE_sehClauses); + EnterRule(_localctx, 270, RULE_sehClauses); Actions.BeginExceptionClauses(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 2882; + State = 2902; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2879; + State = 2899; _localctx.clause = sehClause(); Actions.AddExceptionClause(_localctx, _localctx.clause.Value); } } - State = 2884; + State = 2904; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( ((((_la - 160)) & ~0x3f) == 0 && ((1L << (_la - 160)) & 15L) != 0) ); @@ -14470,17 +14521,17 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TryBlockContext tryBlock() { TryBlockContext _localctx = new TryBlockContext(Context, State); - EnterRule(_localctx, 270, RULE_tryBlock); + EnterRule(_localctx, 272, RULE_tryBlock); try { - State = 2902; + State = 2922; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,143,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,141,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2886; + State = 2906; Match(T__157); - State = 2887; + State = 2907; _localctx.body = scopeBlock(); _localctx.Value = Actions.CreateScopeExceptionRange(_localctx.body); } @@ -14488,13 +14539,13 @@ public TryBlockContext tryBlock() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2890; + State = 2910; Match(T__157); - State = 2891; + State = 2911; _localctx.startLabel = id(); - State = 2892; + State = 2912; Match(T__158); - State = 2893; + State = 2913; _localctx.endLabel = id(); _localctx.Value = Actions.CreateLabelExceptionRange((_localctx.startLabel!=null?(_localctx.startLabel.Start):null), (_localctx.endLabel!=null?(_localctx.endLabel.Start):null)); } @@ -14502,13 +14553,13 @@ public TryBlockContext tryBlock() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2896; + State = 2916; Match(T__157); - State = 2897; + State = 2917; _localctx.startOffset = int32(); - State = 2898; + State = 2918; Match(T__158); - State = 2899; + State = 2919; _localctx.endOffset = int32(); _localctx.Value = Actions.CreateOffsetExceptionRange((_localctx.startOffset!=null?(_localctx.startOffset.Start):null), (_localctx.endOffset!=null?(_localctx.endOffset.Start):null)); } @@ -14562,17 +14613,17 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SehClauseContext sehClause() { SehClauseContext _localctx = new SehClauseContext(Context, State); - EnterRule(_localctx, 272, RULE_sehClause); + EnterRule(_localctx, 274, RULE_sehClause); try { - State = 2920; + State = 2940; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__160: EnterOuterAlt(_localctx, 1); { - State = 2904; + State = 2924; _localctx.caught = catchClause(); - State = 2905; + State = 2925; _localctx.handler = handlerBlock(); _localctx.Value = Actions.CreateCatchExceptionClause(_localctx.caught.Value, _localctx.handler.Value); } @@ -14580,9 +14631,9 @@ public SehClauseContext sehClause() { case T__159: EnterOuterAlt(_localctx, 2); { - State = 2908; + State = 2928; _localctx.filtered = filterClause(); - State = 2909; + State = 2929; _localctx.handler = handlerBlock(); _localctx.Value = Actions.CreateFilterExceptionClause(_localctx.filtered.Value, _localctx.handler.Value); } @@ -14590,9 +14641,9 @@ public SehClauseContext sehClause() { case T__161: EnterOuterAlt(_localctx, 3); { - State = 2912; + State = 2932; finallyClause(); - State = 2913; + State = 2933; _localctx.handler = handlerBlock(); _localctx.Value = Actions.CreateFinallyExceptionClause(_localctx.handler.Value); } @@ -14600,9 +14651,9 @@ public SehClauseContext sehClause() { case T__162: EnterOuterAlt(_localctx, 4); { - State = 2916; + State = 2936; faultClause(); - State = 2917; + State = 2937; _localctx.handler = handlerBlock(); _localctx.Value = Actions.CreateFaultExceptionClause(_localctx.handler.Value); } @@ -14652,17 +14703,17 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public FilterClauseContext filterClause() { FilterClauseContext _localctx = new FilterClauseContext(Context, State); - EnterRule(_localctx, 274, RULE_filterClause); + EnterRule(_localctx, 276, RULE_filterClause); try { - State = 2934; + State = 2954; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,145,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,143,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2922; + State = 2942; Match(T__159); - State = 2923; + State = 2943; _localctx.body = scopeBlock(); _localctx.Value = Actions.CreateScopeFilter(_localctx.body); } @@ -14670,9 +14721,9 @@ public FilterClauseContext filterClause() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2926; + State = 2946; Match(T__159); - State = 2927; + State = 2947; _localctx.label = id(); _localctx.Value = Actions.CreateLabelFilter((_localctx.label!=null?(_localctx.label.Start):null)); } @@ -14680,9 +14731,9 @@ public FilterClauseContext filterClause() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2930; + State = 2950; Match(T__159); - State = 2931; + State = 2951; _localctx.offset = int32(); _localctx.Value = Actions.CreateOffsetFilter((_localctx.offset!=null?(_localctx.offset.Start):null)); } @@ -14722,14 +14773,14 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public CatchClauseContext catchClause() { CatchClauseContext _localctx = new CatchClauseContext(Context, State); - EnterRule(_localctx, 276, RULE_catchClause); + EnterRule(_localctx, 278, RULE_catchClause); Actions.BeginCatchClause(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 2936; + State = 2956; Match(T__160); - State = 2937; + State = 2957; _localctx.catchType = typeSpec(); } } @@ -14762,11 +14813,11 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public FinallyClauseContext finallyClause() { FinallyClauseContext _localctx = new FinallyClauseContext(Context, State); - EnterRule(_localctx, 278, RULE_finallyClause); + EnterRule(_localctx, 280, RULE_finallyClause); try { EnterOuterAlt(_localctx, 1); { - State = 2939; + State = 2959; Match(T__161); } } @@ -14798,11 +14849,11 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public FaultClauseContext faultClause() { FaultClauseContext _localctx = new FaultClauseContext(Context, State); - EnterRule(_localctx, 280, RULE_faultClause); + EnterRule(_localctx, 282, RULE_faultClause); try { EnterOuterAlt(_localctx, 1); { - State = 2941; + State = 2961; Match(T__162); } } @@ -14855,15 +14906,15 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public HandlerBlockContext handlerBlock() { HandlerBlockContext _localctx = new HandlerBlockContext(Context, State); - EnterRule(_localctx, 282, RULE_handlerBlock); + EnterRule(_localctx, 284, RULE_handlerBlock); try { - State = 2958; + State = 2978; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,146,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,144,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2943; + State = 2963; _localctx.body = scopeBlock(); _localctx.Value = Actions.CreateScopeExceptionRange(_localctx.body); } @@ -14871,13 +14922,13 @@ public HandlerBlockContext handlerBlock() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2946; + State = 2966; Match(T__163); - State = 2947; + State = 2967; _localctx.startLabel = id(); - State = 2948; + State = 2968; Match(T__158); - State = 2949; + State = 2969; _localctx.endLabel = id(); _localctx.Value = Actions.CreateLabelExceptionRange((_localctx.startLabel!=null?(_localctx.startLabel.Start):null), (_localctx.endLabel!=null?(_localctx.endLabel.Start):null)); } @@ -14885,13 +14936,13 @@ public HandlerBlockContext handlerBlock() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2952; + State = 2972; Match(T__163); - State = 2953; + State = 2973; _localctx.startOffset = int32(); - State = 2954; + State = 2974; Match(T__158); - State = 2955; + State = 2975; _localctx.endOffset = int32(); _localctx.Value = Actions.CreateOffsetExceptionRange((_localctx.startOffset!=null?(_localctx.startOffset.Start):null), (_localctx.endOffset!=null?(_localctx.endOffset.Start):null)); } @@ -14933,14 +14984,14 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public DataDeclContext dataDecl() { DataDeclContext _localctx = new DataDeclContext(Context, State); - EnterRule(_localctx, 284, RULE_dataDecl); + EnterRule(_localctx, 286, RULE_dataDecl); BeginStreaming(); Actions.BeginDataDeclaration(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 2960; + State = 2980; ddHead(); - State = 2961; + State = 2981; ddBody(); } } @@ -14981,21 +15032,21 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public DdHeadContext ddHead() { DdHeadContext _localctx = new DdHeadContext(Context, State); - EnterRule(_localctx, 286, RULE_ddHead); + EnterRule(_localctx, 288, RULE_ddHead); try { - State = 2973; + State = 2993; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,147,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,145,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 2963; + State = 2983; Match(T__164); - State = 2964; + State = 2984; _localctx.section = tls(); - State = 2965; + State = 2985; _localctx.name = id(); - State = 2966; + State = 2986; Match(T__35); Actions.SetDataDeclarationHeader(_localctx, _localctx.section.Value, (_localctx.name!=null?(_localctx.name.Start):null)); } @@ -15003,9 +15054,9 @@ public DdHeadContext ddHead() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2969; + State = 2989; Match(T__164); - State = 2970; + State = 2990; _localctx.section = tls(); Actions.SetAnonymousDataDeclarationHeader(_localctx, _localctx.section.Value); } @@ -15041,12 +15092,12 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public TlsContext tls() { TlsContext _localctx = new TlsContext(Context, State); - EnterRule(_localctx, 288, RULE_tls); + EnterRule(_localctx, 290, RULE_tls); _localctx.Value = Actions.GetMappedDataSection(); try { - State = 2980; + State = 3000; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,148,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,146,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { @@ -15055,7 +15106,7 @@ public TlsContext tls() { case 2: EnterOuterAlt(_localctx, 2); { - State = 2976; + State = 2996; Match(T__165); _localctx.Value = Actions.GetTlsDataSection(); } @@ -15063,7 +15114,7 @@ public TlsContext tls() { case 3: EnterOuterAlt(_localctx, 3); { - State = 2978; + State = 2998; Match(T__1); _localctx.Value = Actions.GetCilDataSection(); } @@ -15107,20 +15158,20 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public DdBodyContext ddBody() { DdBodyContext _localctx = new DdBodyContext(Context, State); - EnterRule(_localctx, 290, RULE_ddBody); + EnterRule(_localctx, 292, RULE_ddBody); int _la; try { - State = 2991; + State = 3011; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__16: EnterOuterAlt(_localctx, 1); { - State = 2982; + State = 3002; Match(T__16); - State = 2983; + State = 3003; ddItemList(); - State = 2984; + State = 3004; Match(T__17); } break; @@ -15135,17 +15186,17 @@ public DdBodyContext ddBody() { case REF: EnterOuterAlt(_localctx, 2); { - State = 2987; + State = 3007; ErrorHandler.Sync(this); _la = TokenStream.LA(1); do { { { - State = 2986; + State = 3006; ddItem(); } } - State = 2989; + State = 3009; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } while ( _la==T__83 || ((((_la - 181)) & ~0x3f) == 0 && ((1L << (_la - 181)) & 505L) != 0) || _la==REF ); @@ -15189,30 +15240,30 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public DdItemListContext ddItemList() { DdItemListContext _localctx = new DdItemListContext(Context, State); - EnterRule(_localctx, 292, RULE_ddItemList); + EnterRule(_localctx, 294, RULE_ddItemList); try { int _alt; EnterOuterAlt(_localctx, 1); { - State = 2998; + State = 3018; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,151,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,149,Context); while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - State = 2993; + State = 3013; ddItem(); - State = 2994; + State = 3014; Match(T__27); } } } - State = 3000; + State = 3020; ErrorHandler.Sync(this); - _alt = Interpreter.AdaptivePredict(TokenStream,151,Context); + _alt = Interpreter.AdaptivePredict(TokenStream,149,Context); } - State = 3001; + State = 3021; ddItem(); } } @@ -15249,10 +15300,10 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public DdItemCountContext ddItemCount() { DdItemCountContext _localctx = new DdItemCountContext(Context, State); - EnterRule(_localctx, 294, RULE_ddItemCount); + EnterRule(_localctx, 296, RULE_ddItemCount); _localctx.Value = 1; try { - State = 3009; + State = 3029; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__0: @@ -15356,11 +15407,11 @@ public DdItemCountContext ddItemCount() { case T__41: EnterOuterAlt(_localctx, 2); { - State = 3004; + State = 3024; Match(T__41); - State = 3005; + State = 3025; _localctx.count = int32(); - State = 3006; + State = 3026; Match(T__42); _localctx.Value = Actions.ParseDataItemCount((_localctx.count!=null?(_localctx.count.Start):null)); } @@ -15435,24 +15486,24 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public DdItemContext ddItem() { DdItemContext _localctx = new DdItemContext(Context, State); - EnterRule(_localctx, 296, RULE_ddItem); + EnterRule(_localctx, 298, RULE_ddItem); int _la; try { - State = 3059; + State = 3079; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,153,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,151,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3011; + State = 3031; Match(CHAR); - State = 3012; + State = 3032; Match(PTR); - State = 3013; + State = 3033; Match(T__29); - State = 3014; + State = 3034; _localctx.stringValue = compQstring(); - State = 3015; + State = 3035; Match(T__30); Actions.AddDataString(_localctx, _localctx.stringValue.Value); } @@ -15460,13 +15511,13 @@ public DdItemContext ddItem() { case 2: EnterOuterAlt(_localctx, 2); { - State = 3018; + State = 3038; Match(REF); - State = 3019; + State = 3039; Match(T__29); - State = 3020; + State = 3040; _localctx.target = id(); - State = 3021; + State = 3041; Match(T__30); Actions.AddDataReference(_localctx, (_localctx.target!=null?(_localctx.target.Start):null)); } @@ -15474,9 +15525,9 @@ public DdItemContext ddItem() { case 3: EnterOuterAlt(_localctx, 3); { - State = 3024; + State = 3044; Match(REF); - State = 3025; + State = 3045; _localctx.target = id(); Actions.AddDataReference(_localctx, (_localctx.target!=null?(_localctx.target.Start):null)); } @@ -15484,13 +15535,13 @@ public DdItemContext ddItem() { case 4: EnterOuterAlt(_localctx, 4); { - State = 3028; + State = 3048; Match(T__83); - State = 3029; + State = 3049; Match(T__29); - State = 3030; + State = 3050; _localctx.byteValue = bytes(); - State = 3031; + State = 3051; Match(T__30); Actions.AddDataBytes(_localctx, _localctx.byteValue.Value); } @@ -15498,7 +15549,7 @@ public DdItemContext ddItem() { case 5: EnterOuterAlt(_localctx, 5); { - State = 3034; + State = 3054; _localctx.kind = TokenStream.LT(1); _la = TokenStream.LA(1); if ( !(_la==FLOAT32 || _la==FLOAT64_) ) { @@ -15508,13 +15559,13 @@ public DdItemContext ddItem() { ErrorHandler.ReportMatch(this); Consume(); } - State = 3035; + State = 3055; Match(T__29); - State = 3036; + State = 3056; _localctx.floatingValue = float64(); - State = 3037; + State = 3057; Match(T__30); - State = 3038; + State = 3058; _localctx.count = ddItemCount(); Actions.AddFloatingPointData(_localctx, _localctx.kind, _localctx.floatingValue.Value, _localctx.count.Value); } @@ -15522,15 +15573,15 @@ public DdItemContext ddItem() { case 6: EnterOuterAlt(_localctx, 6); { - State = 3041; + State = 3061; _localctx.kind = Match(INT64_); - State = 3042; + State = 3062; Match(T__29); - State = 3043; + State = 3063; _localctx.int64Value = int64(); - State = 3044; + State = 3064; Match(T__30); - State = 3045; + State = 3065; _localctx.count = ddItemCount(); Actions.AddInt64Data(_localctx, _localctx.kind, (_localctx.int64Value!=null?(_localctx.int64Value.Start):null), _localctx.count.Value); } @@ -15538,7 +15589,7 @@ public DdItemContext ddItem() { case 7: EnterOuterAlt(_localctx, 7); { - State = 3048; + State = 3068; _localctx.kind = TokenStream.LT(1); _la = TokenStream.LA(1); if ( !(((((_la - 184)) & ~0x3f) == 0 && ((1L << (_la - 184)) & 7L) != 0)) ) { @@ -15548,13 +15599,13 @@ public DdItemContext ddItem() { ErrorHandler.ReportMatch(this); Consume(); } - State = 3049; + State = 3069; Match(T__29); - State = 3050; + State = 3070; _localctx.integerValue = int32(); - State = 3051; + State = 3071; Match(T__30); - State = 3052; + State = 3072; _localctx.count = ddItemCount(); Actions.AddIntegerData(_localctx, _localctx.kind, (_localctx.integerValue!=null?(_localctx.integerValue.Start):null), _localctx.count.Value); } @@ -15562,7 +15613,7 @@ public DdItemContext ddItem() { case 8: EnterOuterAlt(_localctx, 8); { - State = 3055; + State = 3075; _localctx.kind = TokenStream.LT(1); _la = TokenStream.LA(1); if ( !(((((_la - 184)) & ~0x3f) == 0 && ((1L << (_la - 184)) & 63L) != 0)) ) { @@ -15572,7 +15623,7 @@ public DdItemContext ddItem() { ErrorHandler.ReportMatch(this); Consume(); } - State = 3056; + State = 3076; _localctx.count = ddItemCount(); Actions.AddZeroData(_localctx, _localctx.kind, _localctx.count.Value); } @@ -15660,21 +15711,21 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public FieldSerInitContext fieldSerInit() { FieldSerInitContext _localctx = new FieldSerInitContext(Context, State); - EnterRule(_localctx, 298, RULE_fieldSerInit); + EnterRule(_localctx, 300, RULE_fieldSerInit); try { - State = 3151; + State = 3171; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,154,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,152,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3061; + State = 3081; Match(FLOAT32); - State = 3062; + State = 3082; Match(T__29); - State = 3063; + State = 3083; _localctx.float32Value = float64(); - State = 3064; + State = 3084; Match(T__30); _localctx.Value = Actions.CreateFloat32SerializedInitializer(_localctx.float32Value, _localctx.float32Value.Value); } @@ -15682,13 +15733,13 @@ public FieldSerInitContext fieldSerInit() { case 2: EnterOuterAlt(_localctx, 2); { - State = 3067; + State = 3087; Match(FLOAT64_); - State = 3068; + State = 3088; Match(T__29); - State = 3069; + State = 3089; _localctx.float64Value = float64(); - State = 3070; + State = 3090; Match(T__30); _localctx.Value = Actions.CreateFloat64SerializedInitializer(_localctx.float64Value, _localctx.float64Value.Value); } @@ -15696,13 +15747,13 @@ public FieldSerInitContext fieldSerInit() { case 3: EnterOuterAlt(_localctx, 3); { - State = 3073; + State = 3093; Match(FLOAT32); - State = 3074; + State = 3094; Match(T__29); - State = 3075; + State = 3095; _localctx.float32Bits = int32(); - State = 3076; + State = 3096; Match(T__30); _localctx.Value = Actions.CreateFloat32BitsSerializedInitializer((_localctx.float32Bits!=null?(_localctx.float32Bits.Start):null)); } @@ -15710,13 +15761,13 @@ public FieldSerInitContext fieldSerInit() { case 4: EnterOuterAlt(_localctx, 4); { - State = 3079; + State = 3099; Match(FLOAT64_); - State = 3080; + State = 3100; Match(T__29); - State = 3081; + State = 3101; _localctx.float64Bits = int64(); - State = 3082; + State = 3102; Match(T__30); _localctx.Value = Actions.CreateFloat64BitsSerializedInitializer((_localctx.float64Bits!=null?(_localctx.float64Bits.Start):null)); } @@ -15724,13 +15775,13 @@ public FieldSerInitContext fieldSerInit() { case 5: EnterOuterAlt(_localctx, 5); { - State = 3085; + State = 3105; _localctx.int64Type = Match(INT64_); - State = 3086; + State = 3106; Match(T__29); - State = 3087; + State = 3107; _localctx.int64Value = int64(); - State = 3088; + State = 3108; Match(T__30); _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.int64Type, (_localctx.int64Value!=null?(_localctx.int64Value.Start):null)); } @@ -15738,13 +15789,13 @@ public FieldSerInitContext fieldSerInit() { case 6: EnterOuterAlt(_localctx, 6); { - State = 3091; + State = 3111; _localctx.int32Type = Match(INT32_); - State = 3092; + State = 3112; Match(T__29); - State = 3093; + State = 3113; _localctx.int32Value = int32(); - State = 3094; + State = 3114; Match(T__30); _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.int32Type, (_localctx.int32Value!=null?(_localctx.int32Value.Start):null)); } @@ -15752,13 +15803,13 @@ public FieldSerInitContext fieldSerInit() { case 7: EnterOuterAlt(_localctx, 7); { - State = 3097; + State = 3117; _localctx.int16Type = Match(INT16); - State = 3098; + State = 3118; Match(T__29); - State = 3099; + State = 3119; _localctx.int16Value = int32(); - State = 3100; + State = 3120; Match(T__30); _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.int16Type, (_localctx.int16Value!=null?(_localctx.int16Value.Start):null)); } @@ -15766,13 +15817,13 @@ public FieldSerInitContext fieldSerInit() { case 8: EnterOuterAlt(_localctx, 8); { - State = 3103; + State = 3123; _localctx.int8Type = Match(INT8); - State = 3104; + State = 3124; Match(T__29); - State = 3105; + State = 3125; _localctx.int8Value = int32(); - State = 3106; + State = 3126; Match(T__30); _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.int8Type, (_localctx.int8Value!=null?(_localctx.int8Value.Start):null)); } @@ -15780,13 +15831,13 @@ public FieldSerInitContext fieldSerInit() { case 9: EnterOuterAlt(_localctx, 9); { - State = 3109; + State = 3129; _localctx.uint64Type = Match(UINT64); - State = 3110; + State = 3130; Match(T__29); - State = 3111; + State = 3131; _localctx.uint64Value = int64(); - State = 3112; + State = 3132; Match(T__30); _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.uint64Type, (_localctx.uint64Value!=null?(_localctx.uint64Value.Start):null)); } @@ -15794,13 +15845,13 @@ public FieldSerInitContext fieldSerInit() { case 10: EnterOuterAlt(_localctx, 10); { - State = 3115; + State = 3135; _localctx.uint32Type = Match(UINT32); - State = 3116; + State = 3136; Match(T__29); - State = 3117; + State = 3137; _localctx.uint32Value = int32(); - State = 3118; + State = 3138; Match(T__30); _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.uint32Type, (_localctx.uint32Value!=null?(_localctx.uint32Value.Start):null)); } @@ -15808,13 +15859,13 @@ public FieldSerInitContext fieldSerInit() { case 11: EnterOuterAlt(_localctx, 11); { - State = 3121; + State = 3141; _localctx.uint16Type = Match(UINT16); - State = 3122; + State = 3142; Match(T__29); - State = 3123; + State = 3143; _localctx.uint16Value = int32(); - State = 3124; + State = 3144; Match(T__30); _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.uint16Type, (_localctx.uint16Value!=null?(_localctx.uint16Value.Start):null)); } @@ -15822,13 +15873,13 @@ public FieldSerInitContext fieldSerInit() { case 12: EnterOuterAlt(_localctx, 12); { - State = 3127; + State = 3147; _localctx.uint8Type = Match(UINT8); - State = 3128; + State = 3148; Match(T__29); - State = 3129; + State = 3149; _localctx.uint8Value = int32(); - State = 3130; + State = 3150; Match(T__30); _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.uint8Type, (_localctx.uint8Value!=null?(_localctx.uint8Value.Start):null)); } @@ -15836,13 +15887,13 @@ public FieldSerInitContext fieldSerInit() { case 13: EnterOuterAlt(_localctx, 13); { - State = 3133; + State = 3153; _localctx.charType = Match(CHAR); - State = 3134; + State = 3154; Match(T__29); - State = 3135; + State = 3155; _localctx.charValue = int32(); - State = 3136; + State = 3156; Match(T__30); _localctx.Value = Actions.CreateIntegerSerializedInitializer(_localctx.charType, (_localctx.charValue!=null?(_localctx.charValue.Start):null)); } @@ -15850,13 +15901,13 @@ public FieldSerInitContext fieldSerInit() { case 14: EnterOuterAlt(_localctx, 14); { - State = 3139; + State = 3159; _localctx.boolType = Match(BOOL); - State = 3140; + State = 3160; Match(T__29); - State = 3141; + State = 3161; _localctx.boolValue = truefalse(); - State = 3142; + State = 3162; Match(T__30); _localctx.Value = Actions.CreateBooleanSerializedInitializer(_localctx.boolType, _localctx.boolValue.Value); } @@ -15864,13 +15915,13 @@ public FieldSerInitContext fieldSerInit() { case 15: EnterOuterAlt(_localctx, 15); { - State = 3145; + State = 3165; Match(T__83); - State = 3146; + State = 3166; Match(T__29); - State = 3147; + State = 3167; _localctx.byteArrayValue = bytes(); - State = 3148; + State = 3168; Match(T__30); _localctx.Value = Actions.CreateByteArraySerializedInitializer(_localctx.byteArrayValue.Value); } @@ -15914,24 +15965,24 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public BytesContext bytes() { BytesContext _localctx = new BytesContext(Context, State); - EnterRule(_localctx, 300, RULE_bytes); + EnterRule(_localctx, 302, RULE_bytes); BeginStreaming(); Actions.BeginBytes(); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3158; + State = 3178; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32 || _la==ID || _la==HEXBYTE) { { { - State = 3153; + State = 3173; _localctx.b = hexbyte(); Actions.AddByte(_localctx.b.Value); } } - State = 3160; + State = 3180; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -15970,12 +16021,12 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public HexbyteContext hexbyte() { HexbyteContext _localctx = new HexbyteContext(Context, State); - EnterRule(_localctx, 302, RULE_hexbyte); + EnterRule(_localctx, 304, RULE_hexbyte); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3161; + State = 3181; _la = TokenStream.LA(1); if ( !(_la==INT32 || _la==ID || _la==HEXBYTE) ) { ErrorHandler.RecoverInline(this); @@ -16026,9 +16077,9 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public FieldInitContext fieldInit() { FieldInitContext _localctx = new FieldInitContext(Context, State); - EnterRule(_localctx, 304, RULE_fieldInit); + EnterRule(_localctx, 306, RULE_fieldInit); try { - State = 3171; + State = 3191; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__83: @@ -16046,7 +16097,7 @@ public FieldInitContext fieldInit() { case UINT64: EnterOuterAlt(_localctx, 1); { - State = 3163; + State = 3183; _localctx.serializedValue = fieldSerInit(); _localctx.Value = Actions.CreateFieldInitializer(_localctx.serializedValue.Value); } @@ -16054,7 +16105,7 @@ public FieldInitContext fieldInit() { case QSTRING: EnterOuterAlt(_localctx, 2); { - State = 3166; + State = 3186; _localctx.stringValue = compQstring(); _localctx.Value = Actions.CreateFieldInitializer(_localctx.stringValue.Value); } @@ -16062,7 +16113,7 @@ public FieldInitContext fieldInit() { case NULLREF: EnterOuterAlt(_localctx, 3); { - State = 3169; + State = 3189; Match(NULLREF); _localctx.Value = Actions.CreateNullFieldInitializer(); } @@ -16209,15 +16260,15 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SerInitContext serInit() { SerInitContext _localctx = new SerInitContext(Context, State); - EnterRule(_localctx, 306, RULE_serInit); + EnterRule(_localctx, 308, RULE_serInit); try { - State = 3344; + State = 3364; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,157,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,155,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3173; + State = 3193; _localctx.scalarValue = fieldSerInit(); _localctx.Value = Actions.CreateScalarSerializedValue(_localctx, _localctx.scalarValue, _localctx.scalarValue.Value); } @@ -16225,13 +16276,13 @@ public SerInitContext serInit() { case 2: EnterOuterAlt(_localctx, 2); { - State = 3176; + State = 3196; Match(STRING); - State = 3177; + State = 3197; Match(T__29); - State = 3178; + State = 3198; Match(NULLREF); - State = 3179; + State = 3199; Match(T__30); _localctx.Value = Actions.CreateStringSerializedValue(); } @@ -16239,13 +16290,13 @@ public SerInitContext serInit() { case 3: EnterOuterAlt(_localctx, 3); { - State = 3181; + State = 3201; Match(STRING); - State = 3182; + State = 3202; Match(T__29); - State = 3183; + State = 3203; _localctx.stringToken = Match(SQSTRING); - State = 3184; + State = 3204; Match(T__30); _localctx.Value = Actions.CreateStringSerializedValue(_localctx.stringToken); } @@ -16253,15 +16304,15 @@ public SerInitContext serInit() { case 4: EnterOuterAlt(_localctx, 4); { - State = 3186; + State = 3206; Match(TYPE); - State = 3187; + State = 3207; Match(T__29); - State = 3188; + State = 3208; Match(T__38); - State = 3189; + State = 3209; _localctx.typeToken = Match(SQSTRING); - State = 3190; + State = 3210; Match(T__30); _localctx.Value = Actions.CreateTypeSerializedValue(_localctx.typeToken); } @@ -16269,13 +16320,13 @@ public SerInitContext serInit() { case 5: EnterOuterAlt(_localctx, 5); { - State = 3192; + State = 3212; Match(TYPE); - State = 3193; + State = 3213; Match(T__29); - State = 3194; + State = 3214; _localctx.typeName = className(); - State = 3195; + State = 3215; Match(T__30); _localctx.Value = Actions.CreateTypeSerializedValue(_localctx.typeName.Value); } @@ -16283,13 +16334,13 @@ public SerInitContext serInit() { case 6: EnterOuterAlt(_localctx, 6); { - State = 3198; + State = 3218; Match(TYPE); - State = 3199; + State = 3219; Match(T__29); - State = 3200; + State = 3220; Match(NULLREF); - State = 3201; + State = 3221; Match(T__30); _localctx.Value = Actions.CreateNullTypeSerializedValue(); } @@ -16297,13 +16348,13 @@ public SerInitContext serInit() { case 7: EnterOuterAlt(_localctx, 7); { - State = 3203; + State = 3223; Match(OBJECT); - State = 3204; + State = 3224; Match(T__29); - State = 3205; + State = 3225; _localctx.objectValue = serInit(); - State = 3206; + State = 3226; Match(T__30); _localctx.Value = Actions.CreateObjectSerializedValue(_localctx.objectValue.Value); } @@ -16311,19 +16362,19 @@ public SerInitContext serInit() { case 8: EnterOuterAlt(_localctx, 8); { - State = 3209; + State = 3229; _localctx.f32ElementToken = Match(FLOAT32); - State = 3210; + State = 3230; Match(T__41); - State = 3211; + State = 3231; _localctx.f32Length = int32(); - State = 3212; + State = 3232; Match(T__42); - State = 3213; + State = 3233; Match(T__29); - State = 3214; + State = 3234; _localctx.f32Values = f32seq(); - State = 3215; + State = 3235; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.f32ElementToken, (_localctx.f32Length!=null?(_localctx.f32Length.Start):null), _localctx.f32Values.Value); } @@ -16331,19 +16382,19 @@ public SerInitContext serInit() { case 9: EnterOuterAlt(_localctx, 9); { - State = 3218; + State = 3238; _localctx.f64ElementToken = Match(FLOAT64_); - State = 3219; + State = 3239; Match(T__41); - State = 3220; + State = 3240; _localctx.f64Length = int32(); - State = 3221; + State = 3241; Match(T__42); - State = 3222; + State = 3242; Match(T__29); - State = 3223; + State = 3243; _localctx.f64Values = f64seq(); - State = 3224; + State = 3244; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.f64ElementToken, (_localctx.f64Length!=null?(_localctx.f64Length.Start):null), _localctx.f64Values.Value); } @@ -16351,19 +16402,19 @@ public SerInitContext serInit() { case 10: EnterOuterAlt(_localctx, 10); { - State = 3227; + State = 3247; _localctx.i64ElementToken = Match(INT64_); - State = 3228; + State = 3248; Match(T__41); - State = 3229; + State = 3249; _localctx.i64Length = int32(); - State = 3230; + State = 3250; Match(T__42); - State = 3231; + State = 3251; Match(T__29); - State = 3232; + State = 3252; _localctx.i64Values = i64seq(); - State = 3233; + State = 3253; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.i64ElementToken, (_localctx.i64Length!=null?(_localctx.i64Length.Start):null), _localctx.i64Values.Value); } @@ -16371,19 +16422,19 @@ public SerInitContext serInit() { case 11: EnterOuterAlt(_localctx, 11); { - State = 3236; + State = 3256; _localctx.i32ElementToken = Match(INT32_); - State = 3237; + State = 3257; Match(T__41); - State = 3238; + State = 3258; _localctx.i32Length = int32(); - State = 3239; + State = 3259; Match(T__42); - State = 3240; + State = 3260; Match(T__29); - State = 3241; + State = 3261; _localctx.i32Values = i32seq(); - State = 3242; + State = 3262; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.i32ElementToken, (_localctx.i32Length!=null?(_localctx.i32Length.Start):null), _localctx.i32Values.Value); } @@ -16391,19 +16442,19 @@ public SerInitContext serInit() { case 12: EnterOuterAlt(_localctx, 12); { - State = 3245; + State = 3265; _localctx.i16ElementToken = Match(INT16); - State = 3246; + State = 3266; Match(T__41); - State = 3247; + State = 3267; _localctx.i16Length = int32(); - State = 3248; + State = 3268; Match(T__42); - State = 3249; + State = 3269; Match(T__29); - State = 3250; + State = 3270; _localctx.i16Values = i16seq(); - State = 3251; + State = 3271; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.i16ElementToken, (_localctx.i16Length!=null?(_localctx.i16Length.Start):null), _localctx.i16Values.Value); } @@ -16411,19 +16462,19 @@ public SerInitContext serInit() { case 13: EnterOuterAlt(_localctx, 13); { - State = 3254; + State = 3274; _localctx.i8ElementToken = Match(INT8); - State = 3255; + State = 3275; Match(T__41); - State = 3256; + State = 3276; _localctx.i8Length = int32(); - State = 3257; + State = 3277; Match(T__42); - State = 3258; + State = 3278; Match(T__29); - State = 3259; + State = 3279; _localctx.i8Values = i8seq(); - State = 3260; + State = 3280; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.i8ElementToken, (_localctx.i8Length!=null?(_localctx.i8Length.Start):null), _localctx.i8Values.Value); } @@ -16431,19 +16482,19 @@ public SerInitContext serInit() { case 14: EnterOuterAlt(_localctx, 14); { - State = 3263; + State = 3283; _localctx.u64ElementToken = Match(UINT64); - State = 3264; + State = 3284; Match(T__41); - State = 3265; + State = 3285; _localctx.u64Length = int32(); - State = 3266; + State = 3286; Match(T__42); - State = 3267; + State = 3287; Match(T__29); - State = 3268; + State = 3288; _localctx.u64Values = i64seq(); - State = 3269; + State = 3289; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.u64ElementToken, (_localctx.u64Length!=null?(_localctx.u64Length.Start):null), _localctx.u64Values.Value); } @@ -16451,19 +16502,19 @@ public SerInitContext serInit() { case 15: EnterOuterAlt(_localctx, 15); { - State = 3272; + State = 3292; _localctx.u32ElementToken = Match(UINT32); - State = 3273; + State = 3293; Match(T__41); - State = 3274; + State = 3294; _localctx.u32Length = int32(); - State = 3275; + State = 3295; Match(T__42); - State = 3276; + State = 3296; Match(T__29); - State = 3277; + State = 3297; _localctx.u32Values = i32seq(); - State = 3278; + State = 3298; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.u32ElementToken, (_localctx.u32Length!=null?(_localctx.u32Length.Start):null), _localctx.u32Values.Value); } @@ -16471,19 +16522,19 @@ public SerInitContext serInit() { case 16: EnterOuterAlt(_localctx, 16); { - State = 3281; + State = 3301; _localctx.u16ElementToken = Match(UINT16); - State = 3282; + State = 3302; Match(T__41); - State = 3283; + State = 3303; _localctx.u16Length = int32(); - State = 3284; + State = 3304; Match(T__42); - State = 3285; + State = 3305; Match(T__29); - State = 3286; + State = 3306; _localctx.u16Values = i16seq(); - State = 3287; + State = 3307; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.u16ElementToken, (_localctx.u16Length!=null?(_localctx.u16Length.Start):null), _localctx.u16Values.Value); } @@ -16491,19 +16542,19 @@ public SerInitContext serInit() { case 17: EnterOuterAlt(_localctx, 17); { - State = 3290; + State = 3310; _localctx.u8ElementToken = Match(UINT8); - State = 3291; + State = 3311; Match(T__41); - State = 3292; + State = 3312; _localctx.u8Length = int32(); - State = 3293; + State = 3313; Match(T__42); - State = 3294; + State = 3314; Match(T__29); - State = 3295; + State = 3315; _localctx.u8Values = i8seq(); - State = 3296; + State = 3316; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.u8ElementToken, (_localctx.u8Length!=null?(_localctx.u8Length.Start):null), _localctx.u8Values.Value); } @@ -16511,19 +16562,19 @@ public SerInitContext serInit() { case 18: EnterOuterAlt(_localctx, 18); { - State = 3299; + State = 3319; _localctx.charElementToken = Match(CHAR); - State = 3300; + State = 3320; Match(T__41); - State = 3301; + State = 3321; _localctx.charLength = int32(); - State = 3302; + State = 3322; Match(T__42); - State = 3303; + State = 3323; Match(T__29); - State = 3304; + State = 3324; _localctx.charValues = i16seq(); - State = 3305; + State = 3325; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.charElementToken, (_localctx.charLength!=null?(_localctx.charLength.Start):null), _localctx.charValues.Value); } @@ -16531,19 +16582,19 @@ public SerInitContext serInit() { case 19: EnterOuterAlt(_localctx, 19); { - State = 3308; + State = 3328; _localctx.boolElementToken = Match(BOOL); - State = 3309; + State = 3329; Match(T__41); - State = 3310; + State = 3330; _localctx.boolLength = int32(); - State = 3311; + State = 3331; Match(T__42); - State = 3312; + State = 3332; Match(T__29); - State = 3313; + State = 3333; _localctx.boolValues = boolSeq(); - State = 3314; + State = 3334; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.boolElementToken, (_localctx.boolLength!=null?(_localctx.boolLength.Start):null), _localctx.boolValues.Value); } @@ -16551,19 +16602,19 @@ public SerInitContext serInit() { case 20: EnterOuterAlt(_localctx, 20); { - State = 3317; + State = 3337; _localctx.stringElementToken = Match(STRING); - State = 3318; + State = 3338; Match(T__41); - State = 3319; + State = 3339; _localctx.stringLength = int32(); - State = 3320; + State = 3340; Match(T__42); - State = 3321; + State = 3341; Match(T__29); - State = 3322; + State = 3342; _localctx.stringValues = sqstringSeq(); - State = 3323; + State = 3343; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.stringElementToken, (_localctx.stringLength!=null?(_localctx.stringLength.Start):null), _localctx.stringValues.Value); } @@ -16571,19 +16622,19 @@ public SerInitContext serInit() { case 21: EnterOuterAlt(_localctx, 21); { - State = 3326; + State = 3346; _localctx.typeElementToken = Match(TYPE); - State = 3327; + State = 3347; Match(T__41); - State = 3328; + State = 3348; _localctx.typeLength = int32(); - State = 3329; + State = 3349; Match(T__42); - State = 3330; + State = 3350; Match(T__29); - State = 3331; + State = 3351; _localctx.typeValues = classSeq(); - State = 3332; + State = 3352; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.typeElementToken, (_localctx.typeLength!=null?(_localctx.typeLength.Start):null), _localctx.typeValues.Value); } @@ -16591,19 +16642,19 @@ public SerInitContext serInit() { case 22: EnterOuterAlt(_localctx, 22); { - State = 3335; + State = 3355; _localctx.objectElementToken = Match(OBJECT); - State = 3336; + State = 3356; Match(T__41); - State = 3337; + State = 3357; _localctx.objectLength = int32(); - State = 3338; + State = 3358; Match(T__42); - State = 3339; + State = 3359; Match(T__29); - State = 3340; + State = 3360; _localctx.objectValues = objSeq(); - State = 3341; + State = 3361; Match(T__30); _localctx.Value = Actions.CreateArraySerializedValue(_localctx.objectElementToken, (_localctx.objectLength!=null?(_localctx.objectLength.Start):null), _localctx.objectValues.Value); } @@ -16653,37 +16704,37 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public F32seqContext f32seq() { F32seqContext _localctx = new F32seqContext(Context, State); - EnterRule(_localctx, 308, RULE_f32seq); + EnterRule(_localctx, 310, RULE_f32seq); Actions.BeginSerializationSequence(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3354; + State = 3374; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 98309L) != 0)) { { - State = 3352; + State = 3372; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,158,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,156,Context) ) { case 1: { - State = 3346; + State = 3366; _localctx.floatingValue = float64(); Actions.AddFloat32SequenceValue(_localctx, _localctx.floatingValue.Value); } break; case 2: { - State = 3349; + State = 3369; _localctx.integerValue = int32(); Actions.AddFloat32SequenceValue(_localctx, (_localctx.integerValue!=null?(_localctx.integerValue.Start):null)); } break; } } - State = 3356; + State = 3376; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16733,37 +16784,37 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public F64seqContext f64seq() { F64seqContext _localctx = new F64seqContext(Context, State); - EnterRule(_localctx, 310, RULE_f64seq); + EnterRule(_localctx, 312, RULE_f64seq); Actions.BeginSerializationSequence(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3365; + State = 3385; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & 98311L) != 0)) { { - State = 3363; + State = 3383; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,160,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,158,Context) ) { case 1: { - State = 3357; + State = 3377; _localctx.floatingValue = float64(); Actions.AddFloat64SequenceValue(_localctx, _localctx.floatingValue.Value); } break; case 2: { - State = 3360; + State = 3380; _localctx.integerValue = int64(); Actions.AddFloat64SequenceValue(_localctx, (_localctx.integerValue!=null?(_localctx.integerValue.Start):null)); } break; } } - State = 3367; + State = 3387; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16806,24 +16857,24 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public I64seqContext i64seq() { I64seqContext _localctx = new I64seqContext(Context, State); - EnterRule(_localctx, 312, RULE_i64seq); + EnterRule(_localctx, 314, RULE_i64seq); Actions.BeginSerializationSequence(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3373; + State = 3393; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32 || _la==INT64) { { { - State = 3368; + State = 3388; _localctx.value = int64(); Actions.AddInt64SequenceValue(_localctx, (_localctx.value!=null?(_localctx.value.Start):null)); } } - State = 3375; + State = 3395; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16866,24 +16917,24 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public I32seqContext i32seq() { I32seqContext _localctx = new I32seqContext(Context, State); - EnterRule(_localctx, 314, RULE_i32seq); + EnterRule(_localctx, 316, RULE_i32seq); Actions.BeginSerializationSequence(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3381; + State = 3401; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 3376; + State = 3396; _localctx.value = int32(); Actions.AddInt32SequenceValue(_localctx, (_localctx.value!=null?(_localctx.value.Start):null)); } } - State = 3383; + State = 3403; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16926,24 +16977,24 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public I16seqContext i16seq() { I16seqContext _localctx = new I16seqContext(Context, State); - EnterRule(_localctx, 316, RULE_i16seq); + EnterRule(_localctx, 318, RULE_i16seq); Actions.BeginSerializationSequence(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3389; + State = 3409; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 3384; + State = 3404; _localctx.value = int32(); Actions.AddInt16SequenceValue(_localctx, (_localctx.value!=null?(_localctx.value.Start):null)); } } - State = 3391; + State = 3411; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -16986,24 +17037,24 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public I8seqContext i8seq() { I8seqContext _localctx = new I8seqContext(Context, State); - EnterRule(_localctx, 318, RULE_i8seq); + EnterRule(_localctx, 320, RULE_i8seq); Actions.BeginSerializationSequence(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3397; + State = 3417; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==INT32) { { { - State = 3392; + State = 3412; _localctx.value = int32(); Actions.AddInt8SequenceValue(_localctx, (_localctx.value!=null?(_localctx.value.Start):null)); } } - State = 3399; + State = 3419; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17046,24 +17097,24 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public BoolSeqContext boolSeq() { BoolSeqContext _localctx = new BoolSeqContext(Context, State); - EnterRule(_localctx, 320, RULE_boolSeq); + EnterRule(_localctx, 322, RULE_boolSeq); Actions.BeginSerializationSequence(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3405; + State = 3425; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__94 || _la==T__95) { { { - State = 3400; + State = 3420; _localctx.value = truefalse(); Actions.AddBooleanSequenceValue(_localctx, _localctx.value.Value); } } - State = 3407; + State = 3427; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17109,30 +17160,30 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public SqstringSeqContext sqstringSeq() { SqstringSeqContext _localctx = new SqstringSeqContext(Context, State); - EnterRule(_localctx, 322, RULE_sqstringSeq); + EnterRule(_localctx, 324, RULE_sqstringSeq); Actions.BeginSerializationSequence(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3414; + State = 3434; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==NULLREF || _la==SQSTRING) { { - State = 3412; + State = 3432; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case NULLREF: { - State = 3408; + State = 3428; _localctx.nullValue = Match(NULLREF); Actions.AddStringSequenceValue(_localctx, _localctx.nullValue); } break; case SQSTRING: { - State = 3410; + State = 3430; _localctx.stringValue = Match(SQSTRING); Actions.AddStringSequenceValue(_localctx, _localctx.stringValue); } @@ -17141,7 +17192,7 @@ public SqstringSeqContext sqstringSeq() { throw new NoViableAltException(this); } } - State = 3416; + State = 3436; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17184,24 +17235,24 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ClassSeqContext classSeq() { ClassSeqContext _localctx = new ClassSeqContext(Context, State); - EnterRule(_localctx, 324, RULE_classSeq); + EnterRule(_localctx, 326, RULE_classSeq); Actions.BeginSerializationSequence(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3422; + State = 3442; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4947802390528L) != 0) || _la==T__112 || _la==NULLREF || _la==VALUE || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 105553118478337L) != 0)) { { { - State = 3417; + State = 3437; _localctx.value = classSeqElement(); Actions.AddClassSequenceValue(_localctx, _localctx.value.Value); } } - State = 3424; + State = 3444; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17244,15 +17295,15 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ClassSeqElementContext classSeqElement() { ClassSeqElementContext _localctx = new ClassSeqElementContext(Context, State); - EnterRule(_localctx, 326, RULE_classSeqElement); + EnterRule(_localctx, 328, RULE_classSeqElement); try { - State = 3433; + State = 3453; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case NULLREF: EnterOuterAlt(_localctx, 1); { - State = 3425; + State = 3445; Match(NULLREF); _localctx.Value = Actions.CreateNullClassSequenceValue(); } @@ -17260,9 +17311,9 @@ public ClassSeqElementContext classSeqElement() { case T__38: EnterOuterAlt(_localctx, 2); { - State = 3427; + State = 3447; Match(T__38); - State = 3428; + State = 3448; _localctx.quotedValue = Match(SQSTRING); _localctx.Value = Actions.CreateQuotedClassSequenceValue(_localctx.quotedValue); } @@ -17280,7 +17331,7 @@ public ClassSeqElementContext classSeqElement() { case ID: EnterOuterAlt(_localctx, 3); { - State = 3430; + State = 3450; _localctx.typeValue = className(); _localctx.Value = Actions.CreateClassSequenceValue(_localctx.typeValue.Value); } @@ -17325,24 +17376,24 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ObjSeqContext objSeq() { ObjSeqContext _localctx = new ObjSeqContext(Context, State); - EnterRule(_localctx, 328, RULE_objSeq); + EnterRule(_localctx, 330, RULE_objSeq); Actions.BeginSerializationSequence(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3440; + State = 3460; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while (_la==T__83 || ((((_la - 181)) & ~0x3f) == 0 && ((1L << (_la - 181)) & 106495L) != 0)) { { { - State = 3435; + State = 3455; _localctx.value = serInit(); Actions.AddObjectSequenceValue(_localctx, _localctx.value.Value); } } - State = 3442; + State = 3462; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17391,16 +17442,16 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public CustomAttrDeclContext customAttrDecl() { CustomAttrDeclContext _localctx = new CustomAttrDeclContext(Context, State); - EnterRule(_localctx, 330, RULE_customAttrDecl); + EnterRule(_localctx, 332, RULE_customAttrDecl); Actions.BeginSemanticRoot(_localctx); try { - State = 3452; + State = 3472; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,172,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,170,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3443; + State = 3463; _localctx.directAttribute = customDescr(); _localctx.Value = Actions.CreateCustomAttributeDeclaration(_localctx.directAttribute.Value); } @@ -17408,7 +17459,7 @@ public CustomAttrDeclContext customAttrDecl() { case 2: EnterOuterAlt(_localctx, 2); { - State = 3446; + State = 3466; _localctx.ownedAttribute = customDescrWithOwner(); _localctx.Value = Actions.CreateCustomAttributeDeclaration(_localctx.ownedAttribute.Value); } @@ -17416,7 +17467,7 @@ public CustomAttrDeclContext customAttrDecl() { case 3: EnterOuterAlt(_localctx, 3); { - State = 3449; + State = 3469; _localctx.alias = dottedName(); _localctx.Value = Actions.CreateCustomAttributeTypedef(_localctx.alias.Value); } @@ -17436,6 +17487,15 @@ public CustomAttrDeclContext customAttrDecl() { } public partial class AsmOrRefDeclContext : ParserRuleContext { + public object Value; + public BytesContext key; + public IntOrWildcardContext major; + public IntOrWildcardContext minor; + public IntOrWildcardContext build; + public IntOrWildcardContext revision; + public CompQstringContext locale; + public BytesContext localeBytes; + public CustomAttrDeclContext attribute; [System.Diagnostics.DebuggerNonUserCode] public BytesContext bytes() { return GetRuleContext(0); } @@ -17470,16 +17530,16 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public AsmOrRefDeclContext asmOrRefDecl() { AsmOrRefDeclContext _localctx = new AsmOrRefDeclContext(Context, State); - EnterRule(_localctx, 332, RULE_asmOrRefDecl); + EnterRule(_localctx, 334, RULE_asmOrRefDecl); int _la; try { - State = 3479; + State = 3506; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,173,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,171,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3454; + State = 3474; _la = TokenStream.LA(1); if ( !(_la==T__166 || _la==T__167) ) { ErrorHandler.RecoverInline(this); @@ -17488,72 +17548,83 @@ public AsmOrRefDeclContext asmOrRefDecl() { ErrorHandler.ReportMatch(this); Consume(); } - State = 3455; + State = 3475; Match(T__35); - State = 3456; + State = 3476; Match(T__29); - State = 3457; - bytes(); - State = 3458; + State = 3477; + _localctx.key = bytes(); + State = 3478; Match(T__30); + _localctx.Value = Actions.CreateAssemblyPublicKeyDeclaration(_localctx.key.Value); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3460; + State = 3481; Match(T__168); - State = 3461; - intOrWildcard(); - State = 3462; + State = 3482; + _localctx.major = intOrWildcard(); + State = 3483; Match(T__74); - State = 3463; - intOrWildcard(); - State = 3464; + State = 3484; + _localctx.minor = intOrWildcard(); + State = 3485; Match(T__74); - State = 3465; - intOrWildcard(); - State = 3466; + State = 3486; + _localctx.build = intOrWildcard(); + State = 3487; Match(T__74); - State = 3467; - intOrWildcard(); + State = 3488; + _localctx.revision = intOrWildcard(); + _localctx.Value = Actions.CreateAssemblyVersionDeclaration( + _localctx.major.Value, + _localctx.minor.Value, + _localctx.build.Value, + _localctx.revision.Value); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3469; + State = 3491; Match(T__169); - State = 3470; - compQstring(); + State = 3492; + _localctx.locale = compQstring(); + _localctx.Value = Actions.CreateAssemblyLocaleDeclaration(_localctx.locale.Value); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 3471; + State = 3495; Match(T__169); - State = 3472; + State = 3496; Match(T__35); - State = 3473; + State = 3497; Match(T__29); - State = 3474; - bytes(); - State = 3475; + State = 3498; + _localctx.localeBytes = bytes(); + State = 3499; Match(T__30); + _localctx.Value = Actions.CreateAssemblyLocaleDeclaration(_localctx.localeBytes.Value); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 3477; - customAttrDecl(); + State = 3502; + _localctx.attribute = customAttrDecl(); + _localctx.Value = Actions.CreateAssemblyCustomAttributeDeclaration( + _localctx.attribute.Value, + (_localctx.attribute!=null?(_localctx.attribute.Start):null)); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 3478; + State = 3505; compControl(); } break; @@ -17571,7 +17642,10 @@ public AsmOrRefDeclContext asmOrRefDecl() { } public partial class AssemblyRefBlockContext : ParserRuleContext { + public object Value; public bool HasSyntaxError; + public AssemblyRefHeadContext header; + public AssemblyRefDeclsContext declarations; [System.Diagnostics.DebuggerNonUserCode] public AssemblyRefHeadContext assemblyRefHead() { return GetRuleContext(0); } @@ -17594,19 +17668,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public AssemblyRefBlockContext assemblyRefBlock() { AssemblyRefBlockContext _localctx = new AssemblyRefBlockContext(Context, State); - EnterRule(_localctx, 334, RULE_assemblyRefBlock); - BeginSubtree(); Actions.BeginSemanticRoot(_localctx); + EnterRule(_localctx, 336, RULE_assemblyRefBlock); + BeginStreaming(); Actions.BeginSemanticRoot(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 3481; - assemblyRefHead(); - State = 3482; + State = 3508; + _localctx.header = assemblyRefHead(); + State = 3509; Match(T__16); - State = 3483; - assemblyRefDecls(); - State = 3484; + State = 3510; + _localctx.declarations = assemblyRefDecls(); + State = 3511; Match(T__17); + _localctx.Value = Actions.CreateAssemblyReference( + _localctx.header.Value, + _localctx.declarations.Value); } } catch (RecognitionException re) { @@ -17622,6 +17699,10 @@ public AssemblyRefBlockContext assemblyRefBlock() { } public partial class AssemblyRefHeadContext : ParserRuleContext { + public object Value; + public AsmAttrContext attributes; + public DottedNameContext name; + public DottedNameContext alias; [System.Diagnostics.DebuggerNonUserCode] public AsmAttrContext asmAttr() { return GetRuleContext(0); } @@ -17647,39 +17728,47 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public AssemblyRefHeadContext assemblyRefHead() { AssemblyRefHeadContext _localctx = new AssemblyRefHeadContext(Context, State); - EnterRule(_localctx, 336, RULE_assemblyRefHead); + EnterRule(_localctx, 338, RULE_assemblyRefHead); try { - State = 3498; + State = 3528; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,174,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,172,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3486; + State = 3514; Match(T__24); - State = 3487; + State = 3515; Match(T__39); - State = 3488; - asmAttr(); - State = 3489; - dottedName(); + State = 3516; + _localctx.attributes = asmAttr(); + State = 3517; + _localctx.name = dottedName(); + _localctx.Value = Actions.CreateAssemblyReferenceHeader( + _localctx.attributes.Value, + _localctx.name.Value, + _localctx.name.Value); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3491; + State = 3520; Match(T__24); - State = 3492; + State = 3521; Match(T__39); - State = 3493; - asmAttr(); - State = 3494; - dottedName(); - State = 3495; + State = 3522; + _localctx.attributes = asmAttr(); + State = 3523; + _localctx.name = dottedName(); + State = 3524; Match(T__33); - State = 3496; - dottedName(); + State = 3525; + _localctx.alias = dottedName(); + _localctx.Value = Actions.CreateAssemblyReferenceHeader( + _localctx.attributes.Value, + _localctx.name.Value, + _localctx.alias.Value); } break; } @@ -17696,6 +17785,8 @@ public AssemblyRefHeadContext assemblyRefHead() { } public partial class AssemblyRefDeclsContext : ParserRuleContext { + public object Value; + public AssemblyRefDeclContext declaration; [System.Diagnostics.DebuggerNonUserCode] public AssemblyRefDeclContext[] assemblyRefDecl() { return GetRuleContexts(); } @@ -17718,22 +17809,24 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public AssemblyRefDeclsContext assemblyRefDecls() { AssemblyRefDeclsContext _localctx = new AssemblyRefDeclsContext(Context, State); - EnterRule(_localctx, 338, RULE_assemblyRefDecls); + EnterRule(_localctx, 340, RULE_assemblyRefDecls); + Actions.BeginAssemblyReferenceDeclarations(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3503; + State = 3535; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 36028835673735168L) != 0) || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & 4294975519L) != 0) || ((((_la - 243)) & ~0x3f) == 0 && ((1L << (_la - 243)) & 105555249070081L) != 0)) { { { - State = 3500; - assemblyRefDecl(); + State = 3530; + _localctx.declaration = assemblyRefDecl(); + Actions.AddAssemblyReferenceDeclaration(_localctx, _localctx.declaration.Value); } } - State = 3505; + State = 3537; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -17745,12 +17838,17 @@ public AssemblyRefDeclsContext assemblyRefDecls() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndAssemblyReferenceDeclarations(_localctx); ExitRule(); } return _localctx; } public partial class AssemblyRefDeclContext : ParserRuleContext { + public object Value; + public BytesContext hash; + public AsmOrRefDeclContext shared; + public BytesContext token; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode HASH() { return GetToken(CILParser.HASH, 0); } [System.Diagnostics.DebuggerNonUserCode] public BytesContext bytes() { return GetRuleContext(0); @@ -17774,24 +17872,25 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public AssemblyRefDeclContext assemblyRefDecl() { AssemblyRefDeclContext _localctx = new AssemblyRefDeclContext(Context, State); - EnterRule(_localctx, 340, RULE_assemblyRefDecl); + EnterRule(_localctx, 342, RULE_assemblyRefDecl); try { - State = 3520; + State = 3557; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case HASH: EnterOuterAlt(_localctx, 1); { - State = 3506; + State = 3538; Match(HASH); - State = 3507; + State = 3539; Match(T__35); - State = 3508; + State = 3540; Match(T__29); - State = 3509; - bytes(); - State = 3510; + State = 3541; + _localctx.hash = bytes(); + State = 3542; Match(T__30); + _localctx.Value = Actions.CreateAssemblyReferenceHashDeclaration(_localctx.hash.Value); } break; case T__15: @@ -17815,30 +17914,33 @@ public AssemblyRefDeclContext assemblyRefDecl() { case ID: EnterOuterAlt(_localctx, 2); { - State = 3512; - asmOrRefDecl(); + State = 3545; + _localctx.shared = asmOrRefDecl(); + _localctx.Value = _localctx.shared.Value; } break; case T__170: EnterOuterAlt(_localctx, 3); { - State = 3513; + State = 3548; Match(T__170); - State = 3514; + State = 3549; Match(T__35); - State = 3515; + State = 3550; Match(T__29); - State = 3516; - bytes(); - State = 3517; + State = 3551; + _localctx.token = bytes(); + State = 3552; Match(T__30); + _localctx.Value = Actions.CreateAssemblyReferencePublicKeyTokenDeclaration(_localctx.token.Value); } break; case T__54: EnterOuterAlt(_localctx, 4); { - State = 3519; + State = 3555; Match(T__54); + _localctx.Value = Actions.CreateAssemblyReferenceAutoDeclaration(); } break; default: @@ -17857,7 +17959,10 @@ public AssemblyRefDeclContext assemblyRefDecl() { } public partial class ExptypeBlockContext : ParserRuleContext { + public object Value; public bool HasSyntaxError; + public ExptypeHeadContext header; + public ExptypeDeclsContext declarations; [System.Diagnostics.DebuggerNonUserCode] public ExptypeHeadContext exptypeHead() { return GetRuleContext(0); } @@ -17880,19 +17985,23 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ExptypeBlockContext exptypeBlock() { ExptypeBlockContext _localctx = new ExptypeBlockContext(Context, State); - EnterRule(_localctx, 342, RULE_exptypeBlock); - BeginSubtree(); Actions.BeginSemanticRoot(_localctx); + EnterRule(_localctx, 344, RULE_exptypeBlock); + BeginStreaming(); Actions.BeginSemanticRoot(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 3522; - exptypeHead(); - State = 3523; + State = 3559; + _localctx.header = exptypeHead(); + State = 3560; Match(T__16); - State = 3524; - exptypeDecls(); - State = 3525; + State = 3561; + _localctx.declarations = exptypeDecls(); + State = 3562; Match(T__17); + _localctx.Value = Actions.CreateExportedType( + _localctx.header.Value, + _localctx.declarations.Value, + (_localctx.header!=null?(_localctx.header.Start):null)); } } catch (RecognitionException re) { @@ -17908,15 +18017,16 @@ public ExptypeBlockContext exptypeBlock() { } public partial class ExptypeHeadContext : ParserRuleContext { + public object Value; + public IToken head; + public ExptAttrsContext attributes; + public DottedNameContext name; + [System.Diagnostics.DebuggerNonUserCode] public ExptAttrsContext exptAttrs() { + return GetRuleContext(0); + } [System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() { return GetRuleContext(0); } - [System.Diagnostics.DebuggerNonUserCode] public ExptAttrContext[] exptAttr() { - return GetRuleContexts(); - } - [System.Diagnostics.DebuggerNonUserCode] public ExptAttrContext exptAttr(int i) { - return GetRuleContext(i); - } public ExptypeHeadContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { @@ -17933,31 +18043,22 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ExptypeHeadContext exptypeHead() { ExptypeHeadContext _localctx = new ExptypeHeadContext(Context, State); - EnterRule(_localctx, 344, RULE_exptypeHead); - int _la; + EnterRule(_localctx, 346, RULE_exptypeHead); try { EnterOuterAlt(_localctx, 1); { - State = 3527; - Match(T__49); - State = 3528; + State = 3565; + _localctx.head = Match(T__49); + State = 3566; Match(T__39); - State = 3532; - ErrorHandler.Sync(this); - _la = TokenStream.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4618441417868443648L) != 0) || _la==T__171) { - { - { - State = 3529; - exptAttr(); - } - } - State = 3534; - ErrorHandler.Sync(this); - _la = TokenStream.LA(1); - } - State = 3535; - dottedName(); + State = 3567; + _localctx.attributes = exptAttrs(); + State = 3568; + _localctx.name = dottedName(); + _localctx.Value = Actions.CreateExportedTypeHeader( + _localctx.attributes.Value, + _localctx.name.Value, + _localctx.head); } } catch (RecognitionException re) { @@ -17972,55 +18073,109 @@ public ExptypeHeadContext exptypeHead() { } public partial class ExportHeadContext : ParserRuleContext { + public object Value; + public IToken head; + public ExptAttrsContext attributes; + public DottedNameContext name; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode EXPORT() { return GetToken(CILParser.EXPORT, 0); } + [System.Diagnostics.DebuggerNonUserCode] public ExptAttrsContext exptAttrs() { + return GetRuleContext(0); + } [System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() { return GetRuleContext(0); } + public ExportHeadContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_exportHead; } } + [System.Diagnostics.DebuggerNonUserCode] + public override TResult Accept(IParseTreeVisitor visitor) { + ICILVisitor typedVisitor = visitor as ICILVisitor; + if (typedVisitor != null) return typedVisitor.VisitExportHead(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ExportHeadContext exportHead() { + ExportHeadContext _localctx = new ExportHeadContext(Context, State); + EnterRule(_localctx, 348, RULE_exportHead); + try { + EnterOuterAlt(_localctx, 1); + { + State = 3571; + _localctx.head = Match(EXPORT); + State = 3572; + _localctx.attributes = exptAttrs(); + State = 3573; + _localctx.name = dottedName(); + _localctx.Value = Actions.CreateExportedTypeHeader( + _localctx.attributes.Value, + _localctx.name.Value, + _localctx.head); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + + public partial class ExptAttrsContext : ParserRuleContext { + public System.Reflection.TypeAttributes Value; + public ExptAttrContext attribute; [System.Diagnostics.DebuggerNonUserCode] public ExptAttrContext[] exptAttr() { return GetRuleContexts(); } [System.Diagnostics.DebuggerNonUserCode] public ExptAttrContext exptAttr(int i) { return GetRuleContext(i); } - public ExportHeadContext(ParserRuleContext parent, int invokingState) + public ExptAttrsContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { } - public override int RuleIndex { get { return RULE_exportHead; } } + public override int RuleIndex { get { return RULE_exptAttrs; } } [System.Diagnostics.DebuggerNonUserCode] public override TResult Accept(IParseTreeVisitor visitor) { ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitExportHead(this); + if (typedVisitor != null) return typedVisitor.VisitExptAttrs(this); else return visitor.VisitChildren(this); } } [RuleVersion(0)] - public ExportHeadContext exportHead() { - ExportHeadContext _localctx = new ExportHeadContext(Context, State); - EnterRule(_localctx, 346, RULE_exportHead); + public ExptAttrsContext exptAttrs() { + ExptAttrsContext _localctx = new ExptAttrsContext(Context, State); + EnterRule(_localctx, 350, RULE_exptAttrs); + _localctx.Value = 0; int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3537; - Match(EXPORT); - State = 3541; + State = 3581; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4618441417868443648L) != 0) || _la==T__171) { { { - State = 3538; - exptAttr(); + State = 3576; + _localctx.attribute = exptAttr(); + _localctx.Value = Actions.AddExportedTypeAttribute( + _localctx.Value, + _localctx.attribute.Value, + _localctx.attribute.Mask); } } - State = 3543; + State = 3583; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } - State = 3544; - dottedName(); } } catch (RecognitionException re) { @@ -18035,6 +18190,8 @@ public ExportHeadContext exportHead() { } public partial class ExptAttrContext : ParserRuleContext { + public System.Reflection.TypeAttributes Value; + public System.Reflection.TypeAttributes Mask; public ExptAttrContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { @@ -18051,87 +18208,89 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ExptAttrContext exptAttr() { ExptAttrContext _localctx = new ExptAttrContext(Context, State); - EnterRule(_localctx, 348, RULE_exptAttr); + EnterRule(_localctx, 352, RULE_exptAttr); try { - State = 3561; + State = 3599; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,179,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,176,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3546; + State = 3584; Match(T__51); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3547; + State = 3585; Match(T__50); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3548; + State = 3586; Match(T__171); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 3549; + State = 3587; Match(T__61); - State = 3550; + State = 3588; Match(T__50); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 3551; + State = 3589; Match(T__61); - State = 3552; + State = 3590; Match(T__51); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 3553; + State = 3591; Match(T__61); - State = 3554; + State = 3592; Match(T__62); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 3555; + State = 3593; Match(T__61); - State = 3556; + State = 3594; Match(T__63); } break; case 8: EnterOuterAlt(_localctx, 8); { - State = 3557; + State = 3595; Match(T__61); - State = 3558; + State = 3596; Match(T__64); } break; case 9: EnterOuterAlt(_localctx, 9); { - State = 3559; + State = 3597; Match(T__61); - State = 3560; + State = 3598; Match(T__65); } break; } + Context.Stop = TokenStream.LT(-1); + Actions.SetExportedTypeAttribute(_localctx); } catch (RecognitionException re) { _localctx.exception = re; @@ -18145,6 +18304,8 @@ public ExptAttrContext exptAttr() { } public partial class ExptypeDeclsContext : ParserRuleContext { + public object Value; + public ExptypeDeclContext declaration; [System.Diagnostics.DebuggerNonUserCode] public ExptypeDeclContext[] exptypeDecl() { return GetRuleContexts(); } @@ -18167,22 +18328,24 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ExptypeDeclsContext exptypeDecls() { ExptypeDeclsContext _localctx = new ExptypeDeclsContext(Context, State); - EnterRule(_localctx, 350, RULE_exptypeDecls); + EnterRule(_localctx, 354, RULE_exptypeDecls); + Actions.BeginExportedTypeDeclarations(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3566; + State = 3606; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1125938597265408L) != 0) || _la==T__112 || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 3563; - exptypeDecl(); + State = 3601; + _localctx.declaration = exptypeDecl(); + Actions.AddExportedTypeDeclaration(_localctx, _localctx.declaration.Value); } } - State = 3568; + State = 3608; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -18194,12 +18357,21 @@ public ExptypeDeclsContext exptypeDecls() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndExportedTypeDeclarations(_localctx); ExitRule(); } return _localctx; } public partial class ExptypeDeclContext : ParserRuleContext { + public object Value; + public IToken location; + public DottedNameContext name; + public SlashedNameContext nestedName; + public DottedNameContext assemblyName; + public MdtokenContext token; + public Int32Context typeDefinitionId; + public CustomAttrDeclContext attribute; [System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() { return GetRuleContext(0); } @@ -18234,69 +18406,86 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ExptypeDeclContext exptypeDecl() { ExptypeDeclContext _localctx = new ExptypeDeclContext(Context, State); - EnterRule(_localctx, 352, RULE_exptypeDecl); + EnterRule(_localctx, 356, RULE_exptypeDecl); try { - State = 3582; + State = 3634; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,181,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,178,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3569; - Match(T__20); - State = 3570; - dottedName(); + State = 3609; + _localctx.location = Match(T__20); + State = 3610; + _localctx.name = dottedName(); + _localctx.Value = Actions.CreateExportedTypeFileDeclaration( + _localctx.name.Value, + _localctx.location); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3571; - Match(T__49); - State = 3572; + State = 3613; + _localctx.location = Match(T__49); + State = 3614; Match(T__39); - State = 3573; - slashedName(); + State = 3615; + _localctx.nestedName = slashedName(); + _localctx.Value = Actions.CreateNestedExportedTypeDeclaration( + _localctx.nestedName.Value, + _localctx.location); } break; case 3: EnterOuterAlt(_localctx, 3); { - State = 3574; - Match(T__24); - State = 3575; + State = 3618; + _localctx.location = Match(T__24); + State = 3619; Match(T__39); - State = 3576; - dottedName(); + State = 3620; + _localctx.assemblyName = dottedName(); + _localctx.Value = Actions.CreateExportedTypeAssemblyDeclaration( + _localctx.assemblyName.Value, + _localctx.location); } break; case 4: EnterOuterAlt(_localctx, 4); { - State = 3577; - mdtoken(); + State = 3623; + _localctx.token = mdtoken(); + _localctx.Value = Actions.CreateExportedTypeMetadataTokenDeclaration( + _localctx.token.Value, + (_localctx.token!=null?(_localctx.token.Start):null)); } break; case 5: EnterOuterAlt(_localctx, 5); { - State = 3578; + State = 3626; Match(T__49); - State = 3579; - int32(); + State = 3627; + _localctx.typeDefinitionId = int32(); + _localctx.Value = Actions.CreateExportedTypeDefinitionIdDeclaration( + (_localctx.typeDefinitionId!=null?(_localctx.typeDefinitionId.Start):null)); } break; case 6: EnterOuterAlt(_localctx, 6); { - State = 3580; - customAttrDecl(); + State = 3630; + _localctx.attribute = customAttrDecl(); + _localctx.Value = Actions.CreateExportedTypeCustomAttributeDeclaration( + _localctx.attribute.Value, + (_localctx.attribute!=null?(_localctx.attribute.Start):null)); } break; case 7: EnterOuterAlt(_localctx, 7); { - State = 3581; + State = 3633; compControl(); } break; @@ -18314,7 +18503,10 @@ public ExptypeDeclContext exptypeDecl() { } public partial class ManifestResBlockContext : ParserRuleContext { + public object Value; public bool HasSyntaxError; + public ManifestResHeadContext header; + public ManifestResDeclsContext declarations; [System.Diagnostics.DebuggerNonUserCode] public ManifestResHeadContext manifestResHead() { return GetRuleContext(0); } @@ -18337,19 +18529,23 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ManifestResBlockContext manifestResBlock() { ManifestResBlockContext _localctx = new ManifestResBlockContext(Context, State); - EnterRule(_localctx, 354, RULE_manifestResBlock); - BeginSubtree(); Actions.BeginSemanticRoot(_localctx); + EnterRule(_localctx, 358, RULE_manifestResBlock); + BeginStreaming(); Actions.BeginSemanticRoot(_localctx); try { EnterOuterAlt(_localctx, 1); { - State = 3584; - manifestResHead(); - State = 3585; + State = 3636; + _localctx.header = manifestResHead(); + State = 3637; Match(T__16); - State = 3586; - manifestResDecls(); - State = 3587; + State = 3638; + _localctx.declarations = manifestResDecls(); + State = 3639; Match(T__17); + _localctx.Value = Actions.CreateManifestResource( + _localctx.header.Value, + _localctx.declarations.Value, + (_localctx.header!=null?(_localctx.header.Start):null)); } } catch (RecognitionException re) { @@ -18365,19 +18561,21 @@ public ManifestResBlockContext manifestResBlock() { } public partial class ManifestResHeadContext : ParserRuleContext { + public object Value; + public IToken head; + public ManresAttrsContext attributes; + public DottedNameContext name; + public DottedNameContext alias; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode MRESOURCE() { return GetToken(CILParser.MRESOURCE, 0); } + [System.Diagnostics.DebuggerNonUserCode] public ManresAttrsContext manresAttrs() { + return GetRuleContext(0); + } [System.Diagnostics.DebuggerNonUserCode] public DottedNameContext[] dottedName() { return GetRuleContexts(); } [System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName(int i) { return GetRuleContext(i); } - [System.Diagnostics.DebuggerNonUserCode] public ManresAttrContext[] manresAttr() { - return GetRuleContexts(); - } - [System.Diagnostics.DebuggerNonUserCode] public ManresAttrContext manresAttr(int i) { - return GetRuleContext(i); - } public ManifestResHeadContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { @@ -18394,60 +18592,45 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ManifestResHeadContext manifestResHead() { ManifestResHeadContext _localctx = new ManifestResHeadContext(Context, State); - EnterRule(_localctx, 356, RULE_manifestResHead); - int _la; + EnterRule(_localctx, 360, RULE_manifestResHead); try { - State = 3608; + State = 3654; ErrorHandler.Sync(this); - switch ( Interpreter.AdaptivePredict(TokenStream,184,Context) ) { + switch ( Interpreter.AdaptivePredict(TokenStream,179,Context) ) { case 1: EnterOuterAlt(_localctx, 1); { - State = 3589; - Match(MRESOURCE); - State = 3593; - ErrorHandler.Sync(this); - _la = TokenStream.LA(1); - while (_la==T__50 || _la==T__51) { - { - { - State = 3590; - manresAttr(); - } - } - State = 3595; - ErrorHandler.Sync(this); - _la = TokenStream.LA(1); - } - State = 3596; - dottedName(); + State = 3642; + _localctx.head = Match(MRESOURCE); + State = 3643; + _localctx.attributes = manresAttrs(); + State = 3644; + _localctx.name = dottedName(); + _localctx.Value = Actions.CreateManifestResourceHeader( + _localctx.attributes.Value, + _localctx.name.Value, + _localctx.name.Value, + _localctx.head); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 3597; - Match(MRESOURCE); - State = 3601; - ErrorHandler.Sync(this); - _la = TokenStream.LA(1); - while (_la==T__50 || _la==T__51) { - { - { - State = 3598; - manresAttr(); - } - } - State = 3603; - ErrorHandler.Sync(this); - _la = TokenStream.LA(1); - } - State = 3604; - dottedName(); - State = 3605; + State = 3647; + _localctx.head = Match(MRESOURCE); + State = 3648; + _localctx.attributes = manresAttrs(); + State = 3649; + _localctx.name = dottedName(); + State = 3650; Match(T__33); - State = 3606; - dottedName(); + State = 3651; + _localctx.alias = dottedName(); + _localctx.Value = Actions.CreateManifestResourceHeader( + _localctx.attributes.Value, + _localctx.name.Value, + _localctx.alias.Value, + _localctx.head); } break; } @@ -18463,7 +18646,69 @@ public ManifestResHeadContext manifestResHead() { return _localctx; } + public partial class ManresAttrsContext : ParserRuleContext { + public System.Reflection.ManifestResourceAttributes Value; + public ManresAttrContext attribute; + [System.Diagnostics.DebuggerNonUserCode] public ManresAttrContext[] manresAttr() { + return GetRuleContexts(); + } + [System.Diagnostics.DebuggerNonUserCode] public ManresAttrContext manresAttr(int i) { + return GetRuleContext(i); + } + public ManresAttrsContext(ParserRuleContext parent, int invokingState) + : base(parent, invokingState) + { + } + public override int RuleIndex { get { return RULE_manresAttrs; } } + [System.Diagnostics.DebuggerNonUserCode] + public override TResult Accept(IParseTreeVisitor visitor) { + ICILVisitor typedVisitor = visitor as ICILVisitor; + if (typedVisitor != null) return typedVisitor.VisitManresAttrs(this); + else return visitor.VisitChildren(this); + } + } + + [RuleVersion(0)] + public ManresAttrsContext manresAttrs() { + ManresAttrsContext _localctx = new ManresAttrsContext(Context, State); + EnterRule(_localctx, 362, RULE_manresAttrs); + _localctx.Value = 0; + int _la; + try { + EnterOuterAlt(_localctx, 1); + { + State = 3661; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + while (_la==T__50 || _la==T__51) { + { + { + State = 3656; + _localctx.attribute = manresAttr(); + _localctx.Value = Actions.AddManifestResourceAttribute( + _localctx.Value, + _localctx.attribute.Value); + } + } + State = 3663; + ErrorHandler.Sync(this); + _la = TokenStream.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + ErrorHandler.ReportError(this, re); + ErrorHandler.Recover(this, re); + } + finally { + ExitRule(); + } + return _localctx; + } + public partial class ManresAttrContext : ParserRuleContext { + public System.Reflection.ManifestResourceAttributes Value; public ManresAttrContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { @@ -18480,12 +18725,12 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ManresAttrContext manresAttr() { ManresAttrContext _localctx = new ManresAttrContext(Context, State); - EnterRule(_localctx, 358, RULE_manresAttr); + EnterRule(_localctx, 364, RULE_manresAttr); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3610; + State = 3664; _la = TokenStream.LA(1); if ( !(_la==T__50 || _la==T__51) ) { ErrorHandler.RecoverInline(this); @@ -18495,6 +18740,8 @@ public ManresAttrContext manresAttr() { Consume(); } } + Context.Stop = TokenStream.LT(-1); + _localctx.Value = Actions.ParseManifestResourceAttribute(_localctx.Start); } catch (RecognitionException re) { _localctx.exception = re; @@ -18508,6 +18755,8 @@ public ManresAttrContext manresAttr() { } public partial class ManifestResDeclsContext : ParserRuleContext { + public object Value; + public ManifestResDeclContext declaration; [System.Diagnostics.DebuggerNonUserCode] public ManifestResDeclContext[] manifestResDecl() { return GetRuleContexts(); } @@ -18530,22 +18779,24 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ManifestResDeclsContext manifestResDecls() { ManifestResDeclsContext _localctx = new ManifestResDeclsContext(Context, State); - EnterRule(_localctx, 360, RULE_manifestResDecls); + EnterRule(_localctx, 366, RULE_manifestResDecls); + Actions.BeginManifestResourceDeclarations(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); { - State = 3615; + State = 3671; ErrorHandler.Sync(this); _la = TokenStream.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 38690422784L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 264)) & ~0x3f) == 0 && ((1L << (_la - 264)) & 50332665L) != 0)) { { { - State = 3612; - manifestResDecl(); + State = 3666; + _localctx.declaration = manifestResDecl(); + Actions.AddManifestResourceDeclaration(_localctx, _localctx.declaration.Value); } } - State = 3617; + State = 3673; ErrorHandler.Sync(this); _la = TokenStream.LA(1); } @@ -18557,12 +18808,18 @@ public ManifestResDeclsContext manifestResDecls() { ErrorHandler.Recover(this, re); } finally { + _localctx.Value = Actions.EndManifestResourceDeclarations(_localctx); ExitRule(); } return _localctx; } public partial class ManifestResDeclContext : ParserRuleContext { + public object Value; + public IToken location; + public DottedNameContext name; + public Int32Context offset; + public CustomAttrDeclContext attribute; [System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() { return GetRuleContext(0); } @@ -18591,33 +18848,38 @@ public override TResult Accept(IParseTreeVisitor visitor) { [RuleVersion(0)] public ManifestResDeclContext manifestResDecl() { ManifestResDeclContext _localctx = new ManifestResDeclContext(Context, State); - EnterRule(_localctx, 362, RULE_manifestResDecl); + EnterRule(_localctx, 368, RULE_manifestResDecl); try { - State = 3628; + State = 3689; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case T__20: EnterOuterAlt(_localctx, 1); { - State = 3618; - Match(T__20); - State = 3619; - dottedName(); - State = 3620; + State = 3674; + _localctx.location = Match(T__20); + State = 3675; + _localctx.name = dottedName(); + State = 3676; Match(T__43); - State = 3621; - int32(); + State = 3677; + _localctx.offset = int32(); + _localctx.Value = Actions.CreateManifestResourceFileDeclaration( + _localctx.name.Value, + (_localctx.offset!=null?(_localctx.offset.Start):null), + _localctx.location); } break; case T__24: EnterOuterAlt(_localctx, 2); { - State = 3623; + State = 3680; Match(T__24); - State = 3624; + State = 3681; Match(T__39); - State = 3625; - dottedName(); + State = 3682; + _localctx.name = dottedName(); + _localctx.Value = Actions.CreateManifestResourceAssemblyDeclaration(_localctx.name.Value); } break; case T__15: @@ -18629,8 +18891,11 @@ public ManifestResDeclContext manifestResDecl() { case ID: EnterOuterAlt(_localctx, 3); { - State = 3626; - customAttrDecl(); + State = 3685; + _localctx.attribute = customAttrDecl(); + _localctx.Value = Actions.CreateManifestResourceCustomAttributeDeclaration( + _localctx.attribute.Value, + (_localctx.attribute!=null?(_localctx.attribute.Start):null)); } break; case T__31: @@ -18643,7 +18908,7 @@ public ManifestResDeclContext manifestResDecl() { case PP_INCLUDE: EnterOuterAlt(_localctx, 4); { - State = 3627; + State = 3688; compControl(); } break; @@ -18662,25 +18927,8 @@ public ManifestResDeclContext manifestResDecl() { return _localctx; } - public override bool Sempred(RuleContext _localctx, int ruleIndex, int predIndex) { - switch (ruleIndex) { - case 34: return vtfixupAttr_sempred((VtfixupAttrContext)_localctx, predIndex); - } - return true; - } - private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { - switch (predIndex) { - case 0: return Precpred(Context, 5); - case 1: return Precpred(Context, 4); - case 2: return Precpred(Context, 3); - case 3: return Precpred(Context, 2); - case 4: return Precpred(Context, 1); - } - return true; - } - private static int[] _serializedATN = { - 4,1,305,3631,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, + 4,1,305,3692,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, @@ -18707,1365 +18955,1387 @@ private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) { 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,1,0,1,0,1, - 1,1,1,1,1,1,1,1,1,1,1,5,1,373,8,1,10,1,12,1,376,9,1,1,1,1,1,1,1,1,1,1, - 1,3,1,383,8,1,1,2,1,2,1,3,1,3,1,3,5,3,390,8,3,10,3,12,3,393,9,3,1,3,1, - 3,1,3,1,4,5,4,399,8,4,10,4,12,4,402,9,4,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1, - 5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5, + 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,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,5,1,379,8,1,10, + 1,12,1,382,9,1,1,1,1,1,1,1,1,1,1,1,3,1,389,8,1,1,2,1,2,1,3,1,3,1,3,5,3, + 396,8,3,10,3,12,3,399,9,3,1,3,1,3,1,3,1,4,5,4,405,8,4,10,4,12,4,408,9, + 4,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5, 1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1, 5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5, 1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1, - 5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,490,8,5,1,6,1,6,1,6,1,6,1,7,1,7, - 1,7,1,7,1,8,1,8,1,8,1,8,1,8,1,9,1,9,1,9,1,9,1,10,1,10,1,10,1,10,1,11,1, - 11,1,11,1,11,1,11,1,11,1,11,1,12,1,12,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,540,8,13, - 1,14,1,14,1,15,1,15,1,15,1,15,1,15,5,15,549,8,15,10,15,12,15,552,9,15, - 1,15,1,15,1,16,1,16,1,17,1,17,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18, - 1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,3,18, - 581,8,18,1,19,1,19,3,19,585,8,19,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1, - 20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,3,20,603,8,20,1,21,1,21,1,21, + 5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5, + 496,8,5,1,6,1,6,1,6,1,6,1,7,1,7,1,7,1,7,1,8,1,8,1,8,1,8,1,8,1,9,1,9,1, + 9,1,9,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,12, + 1,12,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,547,8,13,1,14,1,14,1,15,1,15,1,15,1,15,1, + 15,5,15,556,8,15,10,15,12,15,559,9,15,1,15,1,15,1,16,1,16,1,17,1,17,1, + 18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1, + 18,1,18,1,18,1,18,1,18,1,18,1,18,3,18,588,8,18,1,19,1,19,1,19,1,19,1,19, + 3,19,595,8,19,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1, + 20,1,20,1,20,1,20,1,20,3,20,613,8,20,1,21,1,21,1,21,1,21,1,21,1,21,1,21, 1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21, - 1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,3,21,630,8,21,1,22,1,22,1,22,1, + 1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,3,21,645,8,21,1,22,1,22,1, 22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1, - 22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,3,22,658,8,22,1,23,1,23,1,23, + 22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,3,22,673,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,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,698,8,23,1,24,1,24,1,24,1,25,1, - 25,1,25,1,25,1,25,1,25,3,25,709,8,25,1,26,1,26,1,26,1,26,1,27,1,27,1,27, - 1,27,5,27,719,8,27,10,27,12,27,722,9,27,1,28,1,28,1,28,1,28,1,28,1,28, - 1,28,1,28,5,28,732,8,28,10,28,12,28,735,9,28,1,29,1,29,1,29,1,30,1,30, - 3,30,742,8,30,1,30,1,30,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1, - 31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,3,31,764,8,31,1,32,1,32,1,32, - 1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,3,32,777,8,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,34,1,34,1, - 34,1,34,5,34,798,8,34,10,34,12,34,801,9,34,1,35,1,35,1,35,1,35,1,35,1, - 35,1,36,1,36,1,36,1,36,1,37,1,37,1,37,1,37,5,37,817,8,37,10,37,12,37,820, - 9,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,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38, - 1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38, - 1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38, - 1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38, - 1,38,3,38,892,8,38,1,39,1,39,1,39,1,39,1,39,3,39,899,8,39,1,40,1,40,1, - 40,1,40,1,40,3,40,906,8,40,1,41,5,41,909,8,41,10,41,12,41,912,9,41,1,42, - 1,42,1,42,1,42,5,42,918,8,42,10,42,12,42,921,9,42,1,42,1,42,1,42,1,43, - 1,43,1,44,1,44,1,44,3,44,931,8,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,3, - 44,940,8,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,3,44,951,8,44, - 1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,3,44,962,8,44,1,44,1,44,1, - 44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,3,44,975,8,44,1,44,1,44,3,44, - 979,8,44,1,45,1,45,5,45,983,8,45,10,45,12,45,986,9,45,1,45,1,45,1,45,1, - 45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,5,45,999,8,45,10,45,12,45,1002,9, - 45,1,45,1,45,1,45,3,45,1007,8,45,1,46,1,46,1,47,1,47,3,47,1013,8,47,1, - 48,1,48,1,49,5,49,1018,8,49,10,49,12,49,1021,9,49,1,50,1,50,1,50,1,50, - 1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50, - 1,50,1,50,1,50,1,50,1,50,1,50,1,50,3,50,1048,8,50,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,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,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,3,23,713,8,23,1,24,1,24,1,24,1, + 25,1,25,1,25,1,25,1,25,1,25,3,25,724,8,25,1,26,1,26,1,26,1,26,1,27,1,27, + 1,27,1,27,5,27,734,8,27,10,27,12,27,737,9,27,1,28,1,28,1,28,1,28,1,28, + 1,28,1,28,1,28,5,28,747,8,28,10,28,12,28,750,9,28,1,29,1,29,1,29,1,30, + 1,30,3,30,757,8,30,1,30,1,30,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1, + 31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,3,31,779,8,31,1,32,1,32, + 1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,3,32,792,8,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,5,34,806,8,34,10,34,12, + 34,809,9,34,1,34,1,34,1,35,1,35,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,37, + 1,37,1,37,1,37,1,38,1,38,1,38,1,38,5,38,830,8,38,10,38,12,38,833,9,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,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39, + 1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39, + 1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39, + 1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39, + 3,39,905,8,39,1,40,1,40,1,40,1,40,1,40,3,40,912,8,40,1,41,1,41,1,41,1, + 41,1,41,3,41,919,8,41,1,42,5,42,922,8,42,10,42,12,42,925,9,42,1,43,1,43, + 1,43,1,43,5,43,931,8,43,10,43,12,43,934,9,43,1,43,1,43,1,43,1,44,1,44, + 1,45,1,45,1,45,3,45,944,8,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,3,45,953, + 8,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,3,45,964,8,45,1,45,1, + 45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,3,45,975,8,45,1,45,1,45,1,45,1,45, + 1,45,1,45,1,45,1,45,1,45,1,45,1,45,3,45,988,8,45,1,45,1,45,3,45,992,8, + 45,1,46,1,46,1,46,1,46,5,46,998,8,46,10,46,12,46,1001,9,46,1,46,1,46,1, + 46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,3,46,1016,8,46,1, + 47,1,47,1,48,1,48,1,48,3,48,1023,8,48,1,49,1,49,1,50,1,50,1,50,5,50,1030, + 8,50,10,50,12,50,1033,9,50,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,1,51,1,51,1,51,1,51,1,51,1,51,1,51, - 1,51,1,51,3,51,1126,8,51,3,51,1128,8,51,1,52,1,52,1,52,1,52,1,52,1,53, - 1,53,1,53,1,53,1,53,1,53,1,53,3,53,1142,8,53,1,53,1,53,5,53,1146,8,53, - 10,53,12,53,1149,9,53,1,53,1,53,1,53,1,53,1,53,1,53,3,53,1157,8,53,3,53, - 1159,8,53,1,54,1,54,1,54,1,54,1,54,5,54,1166,8,54,10,54,12,54,1169,9,54, - 1,54,1,54,1,54,1,54,1,55,1,55,1,55,1,55,1,55,5,55,1180,8,55,10,55,12,55, - 1183,9,55,1,55,1,55,1,55,1,55,1,56,1,56,1,56,1,56,1,56,5,56,1194,8,56, - 10,56,12,56,1197,9,56,1,56,1,56,1,56,1,56,1,56,3,56,1204,8,56,1,57,1,57, - 1,57,1,57,1,57,1,57,3,57,1212,8,57,1,57,1,57,3,57,1216,8,57,1,58,1,58, - 1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58, - 1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58, - 1,58,1,58,1,58,1,58,1,58,1,58,1,58,3,58,1255,8,58,1,59,1,59,1,59,1,59, - 5,59,1261,8,59,10,59,12,59,1264,9,59,1,59,1,59,1,59,1,60,5,60,1270,8,60, - 10,60,12,60,1273,9,60,1,61,1,61,1,61,1,61,1,61,3,61,1280,8,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,3,62,1299,8,62,1,63,1,63,1,63,1,63,1,63,1,63,5,63,1307,8,63,10,63, - 12,63,1310,9,63,3,63,1312,8,63,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64, - 1,64,1,64,1,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,1336,8,64,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, - 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, - 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, + 1,51,1,51,3,51,1060,8,51,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52, + 1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52, + 1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52, + 1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52, + 1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52, + 1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,3,52,1138,8,52, + 3,52,1140,8,52,1,53,1,53,1,53,1,53,1,53,1,54,1,54,1,54,1,54,1,54,1,54, + 1,54,3,54,1154,8,54,1,54,1,54,5,54,1158,8,54,10,54,12,54,1161,9,54,1,54, + 1,54,1,54,1,54,1,54,1,54,3,54,1169,8,54,3,54,1171,8,54,1,55,1,55,1,55, + 1,55,1,55,5,55,1178,8,55,10,55,12,55,1181,9,55,1,55,1,55,1,55,1,55,1,56, + 1,56,1,56,1,56,1,56,5,56,1192,8,56,10,56,12,56,1195,9,56,1,56,1,56,1,56, + 1,56,1,57,1,57,1,57,1,57,1,57,5,57,1206,8,57,10,57,12,57,1209,9,57,1,57, + 1,57,1,57,1,57,1,57,3,57,1216,8,57,1,58,1,58,1,58,1,58,1,58,1,58,3,58, + 1224,8,58,1,58,1,58,3,58,1228,8,58,1,59,1,59,1,59,1,59,1,59,1,59,1,59, + 1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59, + 1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59, + 1,59,1,59,3,59,1267,8,59,1,60,1,60,1,60,1,60,5,60,1273,8,60,10,60,12,60, + 1276,9,60,1,60,1,60,1,60,1,61,1,61,1,61,5,61,1284,8,61,10,61,12,61,1287, + 9,61,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,3,62,1300, + 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,1,63, + 1,63,1,63,1,63,1,63,3,63,1319,8,63,1,64,1,64,1,64,1,64,1,64,1,64,5,64, + 1327,8,64,10,64,12,64,1330,9,64,3,64,1332,8,64,1,65,1,65,1,65,1,65,1,65, 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, - 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, - 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, - 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, - 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, - 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, - 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65, - 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,3,65,1483,8,65,1,66,1,66,1,66, - 1,66,1,66,1,66,1,66,1,66,3,66,1493,8,66,1,67,1,67,1,67,1,67,1,67,5,67, - 1500,8,67,10,67,12,67,1503,9,67,3,67,1505,8,67,1,68,1,68,1,68,1,68,1,68, - 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, - 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, - 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, - 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, - 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68, - 1,68,1,68,1,68,1,68,1,68,3,68,1587,8,68,1,69,1,69,1,69,1,69,1,69,5,69, - 1594,8,69,10,69,12,69,1597,9,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,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,1628,8,70,1,71,1,71,1,71,1,71, - 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, - 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, + 1,65,1,65,1,65,3,65,1356,8,65,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66, + 1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66, + 1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66, + 1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66, + 1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66, + 1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66, + 1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66, + 1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66, + 1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66, + 1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66, + 1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,3,66,1503,8,66, + 1,67,1,67,1,67,1,67,1,67,1,67,1,67,1,67,3,67,1513,8,67,1,68,1,68,1,68, + 1,68,1,68,5,68,1520,8,68,10,68,12,68,1523,9,68,3,68,1525,8,68,1,69,1,69, + 1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69, + 1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69, + 1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69, + 1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69, + 1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69, + 1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,3,69,1607,8,69,1,70,1,70,1,70, + 1,70,1,70,5,70,1614,8,70,10,70,12,70,1617,9,70,1,71,1,71,1,71,1,71,1,71, 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71, - 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,3,71,1688, - 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,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,3,71,1648,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, - 1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,3,72,1728,8,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, + 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,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,1708,8,72,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73, 1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73, - 3,73,1744,8,73,1,74,1,74,1,74,1,74,1,75,1,75,1,75,1,75,3,75,1754,8,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, - 3,76,1784,8,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,1812,8,76,1,77,1,77,1,77,1,77,1,77,5,77,1819,8,77,10,77,12,77, - 1822,9,77,1,77,1,77,1,77,3,77,1827,8,77,1,78,1,78,1,78,1,78,1,78,1,78, - 1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,3,78,1844,8,78,1,79,1,79, - 1,79,1,79,5,79,1850,8,79,10,79,12,79,1853,9,79,1,79,1,79,1,79,1,80,1,80, - 1,80,1,80,1,80,1,81,1,81,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, - 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, - 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82, - 1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,3,82,1910,8,82,1,83,1,83,1,84, - 1,84,1,84,1,84,1,84,1,84,3,84,1920,8,84,1,84,1,84,1,84,1,84,1,84,1,84, - 1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1938,8,84,1,84, - 1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84, - 1,84,3,84,1956,8,84,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85, - 1,85,1,85,1,85,1,85,1,85,1,85,1,85,3,85,1975,8,85,1,86,1,86,1,86,1,86, - 1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86, - 1,86,3,86,1996,8,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,88,1,88,1,88,1,88,1,88,3,88,2015,8,88,1,89,1,89,1,89,1,89, - 1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,3,89,2030,8,89,1,90,1,90, - 1,90,1,90,5,90,2036,8,90,10,90,12,90,2039,9,90,1,90,1,90,1,90,1,91,1,91, - 1,91,1,91,1,91,1,91,3,91,2050,8,91,1,92,1,92,1,92,1,92,1,92,1,92,1,92, - 1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,92,3,92,2070,8,92, - 1,93,1,93,1,93,5,93,2075,8,93,10,93,12,93,2078,9,93,1,94,1,94,3,94,2082, - 8,94,1,94,1,94,1,94,1,95,1,95,1,95,1,95,5,95,2091,8,95,10,95,12,95,2094, - 9,95,1,95,1,95,1,95,1,96,1,96,1,96,1,96,1,96,1,97,3,97,2105,8,97,1,97, - 1,97,1,98,1,98,1,98,1,98,1,98,1,98,1,98,1,99,1,99,1,99,1,99,1,99,1,99, - 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, - 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, - 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, - 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, - 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, - 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99, - 1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,2213,8,99,10,99,12,99,2216,9,99, - 1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,2225,8,99,10,99,12,99,2228,9,99, - 1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99,2241,8,99, - 10,99,12,99,2244,9,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,5,99, - 2255,8,99,10,99,12,99,2258,9,99,1,99,1,99,1,99,1,99,1,99,1,99,3,99,2266, - 8,99,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100, - 5,100,2279,8,100,10,100,12,100,2282,9,100,1,100,1,100,1,100,1,100,1,100, - 1,100,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101, - 1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101, - 1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,3,101, - 2324,8,101,1,102,1,102,1,102,1,102,1,102,1,102,1,102,1,102,1,102,3,102, - 2335,8,102,1,103,1,103,1,103,1,103,1,103,3,103,2342,8,103,1,104,1,104, - 1,104,1,104,1,104,1,104,3,104,2350,8,104,1,105,1,105,1,105,1,105,5,105, - 2356,8,105,10,105,12,105,2359,9,105,1,105,1,105,1,105,1,105,1,105,1,105, - 1,105,1,105,5,105,2369,8,105,10,105,12,105,2372,9,105,1,105,1,105,1,105, - 3,105,2377,8,105,1,106,1,106,1,106,1,106,3,106,2383,8,106,1,107,5,107, - 2386,8,107,10,107,12,107,2389,9,107,1,108,1,108,1,108,1,108,1,108,1,108, - 1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108, - 1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,3,108,2417,8,108,1,109, - 1,109,1,109,1,109,5,109,2423,8,109,10,109,12,109,2426,9,109,1,109,1,109, - 1,109,1,109,1,109,1,109,1,109,1,110,1,110,1,110,1,110,3,110,2439,8,110, - 1,111,5,111,2442,8,111,10,111,12,111,2445,9,111,1,112,1,112,1,112,1,112, - 1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112, - 1,112,1,112,1,112,1,112,1,112,1,112,3,112,2469,8,112,1,113,1,113,1,113, - 1,113,1,113,1,113,1,113,3,113,2478,8,113,1,114,1,114,1,114,1,114,1,114, - 1,114,1,114,4,114,2487,8,114,11,114,12,114,2488,1,114,1,114,3,114,2493, - 8,114,1,115,1,115,1,115,5,115,2498,8,115,10,115,12,115,2501,9,115,1,116, - 1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116, - 1,116,1,116,1,116,1,116,3,116,2520,8,116,1,117,1,117,1,117,1,117,1,117, - 1,117,1,117,5,117,2529,8,117,10,117,12,117,2532,9,117,1,117,1,117,1,117, - 1,117,1,117,1,117,1,117,1,117,1,117,1,117,5,117,2544,8,117,10,117,12,117, - 2547,9,117,1,117,1,117,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, - 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, - 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, - 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,3,118,2593, - 8,118,1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119,3,119,2603,8,119, - 3,119,2605,8,119,1,119,1,119,1,119,5,119,2610,8,119,10,119,12,119,2613, - 9,119,1,119,1,119,1,119,3,119,2618,8,119,1,120,1,120,1,120,1,120,1,120, - 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, - 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, - 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120, - 1,120,3,120,2662,8,120,1,121,1,121,1,121,1,121,1,121,1,121,1,121,3,121, - 2671,8,121,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, - 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, - 1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, - 1,122,1,122,1,122,1,122,3,122,2711,8,122,1,123,5,123,2714,8,123,10,123, - 12,123,2717,9,123,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, - 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, - 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, - 1,124,1,124,1,124,1,124,3,124,2756,8,124,1,125,1,125,3,125,2760,8,125, - 1,125,1,125,1,126,1,126,1,126,1,126,1,126,1,126,3,126,2770,8,126,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,128,1,128,1,128,1,128,1,128,1,128,1,128,3,128,2792,8,128,1,129,1,129, - 1,129,1,129,1,129,1,129,1,129,1,129,5,129,2802,8,129,10,129,12,129,2805, - 9,129,1,129,1,129,1,129,1,129,1,129,1,129,5,129,2813,8,129,10,129,12,129, - 2816,9,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129, - 5,129,2828,8,129,10,129,12,129,2831,9,129,1,129,1,129,1,129,1,129,1,129, - 1,129,1,129,1,129,5,129,2841,8,129,10,129,12,129,2844,9,129,1,129,1,129, - 1,129,1,129,1,129,1,129,1,129,1,129,5,129,2854,8,129,10,129,12,129,2857, - 9,129,3,129,2859,8,129,1,130,1,130,1,130,1,130,1,131,1,131,1,131,1,131, - 1,131,1,131,3,131,2871,8,131,1,132,1,132,1,132,1,132,1,133,1,133,1,133, - 1,134,1,134,1,134,4,134,2883,8,134,11,134,12,134,2884,1,135,1,135,1,135, - 1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135, - 1,135,3,135,2903,8,135,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136, - 1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,3,136,2921,8,136,1,137, - 1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,3,137, - 2935,8,137,1,138,1,138,1,138,1,139,1,139,1,140,1,140,1,141,1,141,1,141, - 1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141, - 3,141,2959,8,141,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,3,143,2974,8,143,1,144,1,144,1,144,1,144,1,144, - 3,144,2981,8,144,1,145,1,145,1,145,1,145,1,145,4,145,2988,8,145,11,145, - 12,145,2989,3,145,2992,8,145,1,146,1,146,1,146,5,146,2997,8,146,10,146, - 12,146,3000,9,146,1,146,1,146,1,147,1,147,1,147,1,147,1,147,1,147,3,147, - 3010,8,147,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, - 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, - 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, - 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, - 1,148,1,148,3,148,3060,8,148,1,149,1,149,1,149,1,149,1,149,1,149,1,149, - 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, - 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, - 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, + 1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73, + 3,73,1748,8,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,3,74,1764,8,74,1,75,1,75,1,75,1,75,1,76,1,76,1,76,1,76, + 3,76,1774,8,76,1,76,1,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,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,1804,8,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,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,1,77,3,77,1832,8,77,1,78,1,78,1,78,1,78,1,78,5,78,1839, + 8,78,10,78,12,78,1842,9,78,1,78,1,78,1,78,3,78,1847,8,78,1,79,1,79,1,79, + 1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,3,79,1864, + 8,79,1,80,1,80,1,80,1,80,5,80,1870,8,80,10,80,12,80,1873,9,80,1,80,1,80, + 1,80,1,81,1,81,1,81,1,81,1,81,1,82,1,82,1,83,1,83,1,83,1,83,1,83,1,83, + 1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83, + 1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83, + 1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,3,83,1930,8,83, + 1,84,1,84,1,85,1,85,1,85,1,85,1,85,1,85,3,85,1940,8,85,1,85,1,85,1,85, + 1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,3,85, + 1958,8,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85, + 1,85,1,85,1,85,1,85,3,85,1976,8,85,1,86,1,86,1,86,1,86,1,86,1,86,1,86, + 1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,3,86,1995,8,86,1,87, + 1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87, + 1,87,1,87,1,87,1,87,3,87,2016,8,87,1,88,1,88,1,88,1,88,1,88,1,88,1,89, + 1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,3,89,2035,8,89,1,90, + 1,90,1,90,1,90,1,90,1,90,1,90,1,90,1,90,1,90,1,90,1,90,1,90,3,90,2050, + 8,90,1,91,1,91,1,91,1,91,5,91,2056,8,91,10,91,12,91,2059,9,91,1,91,1,91, + 1,91,1,92,1,92,1,92,1,92,1,92,1,92,3,92,2070,8,92,1,93,1,93,1,93,1,93, + 1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93, + 3,93,2090,8,93,1,94,1,94,1,94,5,94,2095,8,94,10,94,12,94,2098,9,94,1,95, + 1,95,3,95,2102,8,95,1,95,1,95,1,95,1,96,1,96,1,96,1,96,5,96,2111,8,96, + 10,96,12,96,2114,9,96,1,96,1,96,1,96,1,97,1,97,1,97,1,97,1,97,1,98,3,98, + 2125,8,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,100,1,100,1,100,1,100,1,100,1,100, + 1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100, + 1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100, + 1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100, + 1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100, + 1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100, + 1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100, + 1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,5,100,2233, + 8,100,10,100,12,100,2236,9,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100, + 5,100,2245,8,100,10,100,12,100,2248,9,100,1,100,1,100,1,100,1,100,1,100, + 1,100,1,100,1,100,1,100,1,100,1,100,5,100,2261,8,100,10,100,12,100,2264, + 9,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,5,100,2275, + 8,100,10,100,12,100,2278,9,100,1,100,1,100,1,100,1,100,1,100,1,100,3,100, + 2286,8,100,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101, + 1,101,5,101,2299,8,101,10,101,12,101,2302,9,101,1,101,1,101,1,101,1,101, + 1,101,1,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,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,2344,8,102,1,103,1,103,1,103,1,103,1,103,1,103,1,103,1,103,1,103, + 3,103,2355,8,103,1,104,1,104,1,104,1,104,1,104,3,104,2362,8,104,1,105, + 1,105,1,105,1,105,1,105,1,105,3,105,2370,8,105,1,106,1,106,1,106,1,106, + 5,106,2376,8,106,10,106,12,106,2379,9,106,1,106,1,106,1,106,1,106,1,106, + 1,106,1,106,1,106,5,106,2389,8,106,10,106,12,106,2392,9,106,1,106,1,106, + 1,106,3,106,2397,8,106,1,107,1,107,1,107,1,107,3,107,2403,8,107,1,108, + 5,108,2406,8,108,10,108,12,108,2409,9,108,1,109,1,109,1,109,1,109,1,109, + 1,109,1,109,1,109,1,109,1,109,1,109,1,109,1,109,1,109,1,109,1,109,1,109, + 1,109,1,109,1,109,1,109,1,109,1,109,1,109,1,109,1,109,3,109,2437,8,109, + 1,110,1,110,1,110,1,110,5,110,2443,8,110,10,110,12,110,2446,9,110,1,110, + 1,110,1,110,1,110,1,110,1,110,1,110,1,111,1,111,1,111,1,111,3,111,2459, + 8,111,1,112,5,112,2462,8,112,10,112,12,112,2465,9,112,1,113,1,113,1,113, + 1,113,1,113,1,113,1,113,1,113,1,113,1,113,1,113,1,113,1,113,1,113,1,113, + 1,113,1,113,1,113,1,113,1,113,1,113,1,113,3,113,2489,8,113,1,114,1,114, + 1,114,1,114,1,114,1,114,1,114,3,114,2498,8,114,1,115,1,115,1,115,1,115, + 1,115,1,115,1,115,4,115,2507,8,115,11,115,12,115,2508,1,115,1,115,3,115, + 2513,8,115,1,116,1,116,1,116,5,116,2518,8,116,10,116,12,116,2521,9,116, + 1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117, + 1,117,1,117,1,117,1,117,1,117,3,117,2540,8,117,1,118,1,118,1,118,1,118, + 1,118,1,118,1,118,5,118,2549,8,118,10,118,12,118,2552,9,118,1,118,1,118, + 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,5,118,2564,8,118,10,118, + 12,118,2567,9,118,1,118,1,118,1,119,1,119,1,119,1,119,1,119,1,119,1,119, + 1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119, + 1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119, + 1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119,3,119, + 2613,8,119,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,3,120,2623, + 8,120,3,120,2625,8,120,1,120,1,120,1,120,5,120,2630,8,120,10,120,12,120, + 2633,9,120,1,120,1,120,1,120,3,120,2638,8,120,1,121,1,121,1,121,1,121, + 1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121, + 1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121, + 1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121, + 1,121,1,121,3,121,2682,8,121,1,122,1,122,1,122,1,122,1,122,1,122,1,122, + 3,122,2691,8,122,1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,123, + 1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,123, + 1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,123, + 1,123,1,123,1,123,1,123,1,123,3,123,2731,8,123,1,124,5,124,2734,8,124, + 10,124,12,124,2737,9,124,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, + 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, + 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, + 1,125,1,125,1,125,1,125,1,125,3,125,2776,8,125,1,126,1,126,3,126,2780, + 8,126,1,126,1,126,1,127,1,127,1,127,1,127,1,127,1,127,3,127,2790,8,127, + 1,128,1,128,1,128,1,128,1,128,1,129,1,129,1,129,1,129,1,129,1,129,1,129, + 1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,3,129,2812,8,129,1,130, + 1,130,1,130,1,130,1,130,1,130,1,130,1,130,5,130,2822,8,130,10,130,12,130, + 2825,9,130,1,130,1,130,1,130,1,130,1,130,1,130,5,130,2833,8,130,10,130, + 12,130,2836,9,130,1,130,1,130,1,130,1,130,1,130,1,130,1,130,1,130,1,130, + 1,130,5,130,2848,8,130,10,130,12,130,2851,9,130,1,130,1,130,1,130,1,130, + 1,130,1,130,1,130,1,130,5,130,2861,8,130,10,130,12,130,2864,9,130,1,130, + 1,130,1,130,1,130,1,130,1,130,1,130,1,130,5,130,2874,8,130,10,130,12,130, + 2877,9,130,3,130,2879,8,130,1,131,1,131,1,131,1,131,1,132,1,132,1,132, + 1,132,1,132,1,132,3,132,2891,8,132,1,133,1,133,1,133,1,133,1,134,1,134, + 1,134,1,135,1,135,1,135,4,135,2903,8,135,11,135,12,135,2904,1,136,1,136, + 1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136, + 1,136,1,136,3,136,2923,8,136,1,137,1,137,1,137,1,137,1,137,1,137,1,137, + 1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,3,137,2941,8,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, + 3,138,2955,8,138,1,139,1,139,1,139,1,140,1,140,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,3,142,2979,8,142,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,3,144,2994,8,144,1,145,1,145,1,145,1,145, + 1,145,3,145,3001,8,145,1,146,1,146,1,146,1,146,1,146,4,146,3008,8,146, + 11,146,12,146,3009,3,146,3012,8,146,1,147,1,147,1,147,5,147,3017,8,147, + 10,147,12,147,3020,9,147,1,147,1,147,1,148,1,148,1,148,1,148,1,148,1,148, + 3,148,3030,8,148,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149, - 1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,3,149, - 3152,8,149,1,150,1,150,1,150,5,150,3157,8,150,10,150,12,150,3160,9,150, - 1,151,1,151,1,152,1,152,1,152,1,152,1,152,1,152,1,152,1,152,3,152,3172, - 8,152,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, - 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, - 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, - 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, - 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, - 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, - 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, - 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, - 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, - 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, - 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, - 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, - 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, - 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153, - 1,153,1,153,1,153,1,153,3,153,3345,8,153,1,154,1,154,1,154,1,154,1,154, - 1,154,5,154,3353,8,154,10,154,12,154,3356,9,154,1,155,1,155,1,155,1,155, - 1,155,1,155,5,155,3364,8,155,10,155,12,155,3367,9,155,1,156,1,156,1,156, - 5,156,3372,8,156,10,156,12,156,3375,9,156,1,157,1,157,1,157,5,157,3380, - 8,157,10,157,12,157,3383,9,157,1,158,1,158,1,158,5,158,3388,8,158,10,158, - 12,158,3391,9,158,1,159,1,159,1,159,5,159,3396,8,159,10,159,12,159,3399, - 9,159,1,160,1,160,1,160,5,160,3404,8,160,10,160,12,160,3407,9,160,1,161, - 1,161,1,161,1,161,5,161,3413,8,161,10,161,12,161,3416,9,161,1,162,1,162, - 1,162,5,162,3421,8,162,10,162,12,162,3424,9,162,1,163,1,163,1,163,1,163, - 1,163,1,163,1,163,1,163,3,163,3434,8,163,1,164,1,164,1,164,5,164,3439, - 8,164,10,164,12,164,3442,9,164,1,165,1,165,1,165,1,165,1,165,1,165,1,165, - 1,165,1,165,3,165,3453,8,165,1,166,1,166,1,166,1,166,1,166,1,166,1,166, - 1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166, - 1,166,1,166,1,166,1,166,1,166,1,166,3,166,3480,8,166,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,168,3,168,3499,8,168,1,169,5,169,3502,8,169,10,169,12,169,3505, - 9,169,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170, - 1,170,1,170,1,170,3,170,3521,8,170,1,171,1,171,1,171,1,171,1,171,1,172, - 1,172,1,172,5,172,3531,8,172,10,172,12,172,3534,9,172,1,172,1,172,1,173, - 1,173,5,173,3540,8,173,10,173,12,173,3543,9,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,3,174,3562,8,174,1,175,5,175,3565,8,175,10,175,12,175,3568,9,175, - 1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176, - 1,176,3,176,3583,8,176,1,177,1,177,1,177,1,177,1,177,1,178,1,178,5,178, - 3592,8,178,10,178,12,178,3595,9,178,1,178,1,178,1,178,5,178,3600,8,178, - 10,178,12,178,3603,9,178,1,178,1,178,1,178,1,178,3,178,3609,8,178,1,179, - 1,179,1,180,5,180,3614,8,180,10,180,12,180,3617,9,180,1,181,1,181,1,181, - 1,181,1,181,1,181,1,181,1,181,1,181,1,181,3,181,3629,8,181,1,181,0,1,68, - 182,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,0,16,6,0,1,15,199,199,243,243,247,247, - 264,264,289,289,5,0,16,16,199,199,243,243,264,264,288,289,1,0,263,264, - 1,0,173,174,1,0,37,38,1,0,73,74,3,0,2,2,61,61,77,83,2,0,229,229,260,261, - 1,0,95,96,1,0,97,111,1,0,188,189,1,0,184,186,1,0,184,189,2,0,173,173,289, - 290,1,0,167,168,1,0,51,52,4080,0,364,1,0,0,0,2,382,1,0,0,0,4,384,1,0,0, - 0,6,391,1,0,0,0,8,400,1,0,0,0,10,489,1,0,0,0,12,491,1,0,0,0,14,495,1,0, - 0,0,16,499,1,0,0,0,18,504,1,0,0,0,20,508,1,0,0,0,22,512,1,0,0,0,24,519, - 1,0,0,0,26,539,1,0,0,0,28,541,1,0,0,0,30,543,1,0,0,0,32,555,1,0,0,0,34, - 557,1,0,0,0,36,580,1,0,0,0,38,584,1,0,0,0,40,602,1,0,0,0,42,629,1,0,0, - 0,44,657,1,0,0,0,46,697,1,0,0,0,48,699,1,0,0,0,50,708,1,0,0,0,52,710,1, - 0,0,0,54,720,1,0,0,0,56,733,1,0,0,0,58,736,1,0,0,0,60,739,1,0,0,0,62,763, - 1,0,0,0,64,776,1,0,0,0,66,778,1,0,0,0,68,786,1,0,0,0,70,802,1,0,0,0,72, - 808,1,0,0,0,74,812,1,0,0,0,76,891,1,0,0,0,78,898,1,0,0,0,80,905,1,0,0, - 0,82,910,1,0,0,0,84,919,1,0,0,0,86,925,1,0,0,0,88,978,1,0,0,0,90,1006, - 1,0,0,0,92,1008,1,0,0,0,94,1012,1,0,0,0,96,1014,1,0,0,0,98,1019,1,0,0, - 0,100,1047,1,0,0,0,102,1127,1,0,0,0,104,1129,1,0,0,0,106,1158,1,0,0,0, - 108,1160,1,0,0,0,110,1174,1,0,0,0,112,1203,1,0,0,0,114,1215,1,0,0,0,116, - 1254,1,0,0,0,118,1262,1,0,0,0,120,1271,1,0,0,0,122,1279,1,0,0,0,124,1298, - 1,0,0,0,126,1311,1,0,0,0,128,1335,1,0,0,0,130,1482,1,0,0,0,132,1492,1, - 0,0,0,134,1504,1,0,0,0,136,1586,1,0,0,0,138,1588,1,0,0,0,140,1627,1,0, - 0,0,142,1687,1,0,0,0,144,1727,1,0,0,0,146,1743,1,0,0,0,148,1745,1,0,0, - 0,150,1749,1,0,0,0,152,1811,1,0,0,0,154,1826,1,0,0,0,156,1843,1,0,0,0, - 158,1851,1,0,0,0,160,1857,1,0,0,0,162,1862,1,0,0,0,164,1909,1,0,0,0,166, - 1911,1,0,0,0,168,1955,1,0,0,0,170,1974,1,0,0,0,172,1995,1,0,0,0,174,1997, - 1,0,0,0,176,2014,1,0,0,0,178,2029,1,0,0,0,180,2037,1,0,0,0,182,2049,1, - 0,0,0,184,2069,1,0,0,0,186,2076,1,0,0,0,188,2079,1,0,0,0,190,2092,1,0, - 0,0,192,2098,1,0,0,0,194,2104,1,0,0,0,196,2108,1,0,0,0,198,2265,1,0,0, - 0,200,2267,1,0,0,0,202,2323,1,0,0,0,204,2334,1,0,0,0,206,2341,1,0,0,0, - 208,2349,1,0,0,0,210,2376,1,0,0,0,212,2382,1,0,0,0,214,2387,1,0,0,0,216, - 2416,1,0,0,0,218,2418,1,0,0,0,220,2438,1,0,0,0,222,2443,1,0,0,0,224,2468, - 1,0,0,0,226,2477,1,0,0,0,228,2492,1,0,0,0,230,2499,1,0,0,0,232,2519,1, - 0,0,0,234,2521,1,0,0,0,236,2592,1,0,0,0,238,2617,1,0,0,0,240,2661,1,0, - 0,0,242,2670,1,0,0,0,244,2710,1,0,0,0,246,2715,1,0,0,0,248,2755,1,0,0, - 0,250,2757,1,0,0,0,252,2763,1,0,0,0,254,2771,1,0,0,0,256,2791,1,0,0,0, - 258,2858,1,0,0,0,260,2860,1,0,0,0,262,2870,1,0,0,0,264,2872,1,0,0,0,266, - 2876,1,0,0,0,268,2882,1,0,0,0,270,2902,1,0,0,0,272,2920,1,0,0,0,274,2934, - 1,0,0,0,276,2936,1,0,0,0,278,2939,1,0,0,0,280,2941,1,0,0,0,282,2958,1, - 0,0,0,284,2960,1,0,0,0,286,2973,1,0,0,0,288,2980,1,0,0,0,290,2991,1,0, - 0,0,292,2998,1,0,0,0,294,3009,1,0,0,0,296,3059,1,0,0,0,298,3151,1,0,0, - 0,300,3158,1,0,0,0,302,3161,1,0,0,0,304,3171,1,0,0,0,306,3344,1,0,0,0, - 308,3354,1,0,0,0,310,3365,1,0,0,0,312,3373,1,0,0,0,314,3381,1,0,0,0,316, - 3389,1,0,0,0,318,3397,1,0,0,0,320,3405,1,0,0,0,322,3414,1,0,0,0,324,3422, - 1,0,0,0,326,3433,1,0,0,0,328,3440,1,0,0,0,330,3452,1,0,0,0,332,3479,1, - 0,0,0,334,3481,1,0,0,0,336,3498,1,0,0,0,338,3503,1,0,0,0,340,3520,1,0, - 0,0,342,3522,1,0,0,0,344,3527,1,0,0,0,346,3537,1,0,0,0,348,3561,1,0,0, - 0,350,3566,1,0,0,0,352,3582,1,0,0,0,354,3584,1,0,0,0,356,3608,1,0,0,0, - 358,3610,1,0,0,0,360,3615,1,0,0,0,362,3628,1,0,0,0,364,365,7,0,0,0,365, - 1,1,0,0,0,366,367,5,288,0,0,367,383,6,1,-1,0,368,369,3,4,2,0,369,370,6, - 1,-1,0,370,371,5,265,0,0,371,373,1,0,0,0,372,368,1,0,0,0,373,376,1,0,0, - 0,374,372,1,0,0,0,374,375,1,0,0,0,375,377,1,0,0,0,376,374,1,0,0,0,377, - 378,3,4,2,0,378,379,6,1,-1,0,379,383,1,0,0,0,380,381,5,264,0,0,381,383, - 6,1,-1,0,382,366,1,0,0,0,382,374,1,0,0,0,382,380,1,0,0,0,383,3,1,0,0,0, - 384,385,7,1,0,0,385,5,1,0,0,0,386,387,5,263,0,0,387,388,6,3,-1,0,388,390, - 5,266,0,0,389,386,1,0,0,0,390,393,1,0,0,0,391,389,1,0,0,0,391,392,1,0, - 0,0,392,394,1,0,0,0,393,391,1,0,0,0,394,395,5,263,0,0,395,396,6,3,-1,0, - 396,7,1,0,0,0,397,399,3,10,5,0,398,397,1,0,0,0,399,402,1,0,0,0,400,398, - 1,0,0,0,400,401,1,0,0,0,401,9,1,0,0,0,402,400,1,0,0,0,403,404,3,74,37, - 0,404,405,5,17,0,0,405,406,3,82,41,0,406,407,5,18,0,0,407,490,1,0,0,0, - 408,409,3,72,36,0,409,410,5,17,0,0,410,411,3,8,4,0,411,412,5,18,0,0,412, - 490,1,0,0,0,413,414,3,234,117,0,414,415,5,17,0,0,415,416,3,246,123,0,416, - 417,5,18,0,0,417,490,1,0,0,0,418,490,3,200,100,0,419,420,6,5,-1,0,420, - 421,3,284,142,0,421,422,6,5,-1,0,422,490,1,0,0,0,423,424,6,5,-1,0,424, - 425,3,70,35,0,425,426,6,5,-1,0,426,490,1,0,0,0,427,428,6,5,-1,0,428,429, - 3,66,33,0,429,430,6,5,-1,0,430,490,1,0,0,0,431,432,6,5,-1,0,432,433,3, - 88,44,0,433,434,6,5,-1,0,434,490,1,0,0,0,435,436,6,5,-1,0,436,437,3,90, - 45,0,437,438,6,5,-1,0,438,490,1,0,0,0,439,440,6,5,-1,0,440,441,3,22,11, - 0,441,442,6,5,-1,0,442,490,1,0,0,0,443,444,6,5,-1,0,444,445,3,334,167, - 0,445,446,6,5,-1,0,446,490,1,0,0,0,447,448,6,5,-1,0,448,449,3,342,171, - 0,449,450,6,5,-1,0,450,490,1,0,0,0,451,452,6,5,-1,0,452,453,3,354,177, - 0,453,454,6,5,-1,0,454,490,1,0,0,0,455,456,6,5,-1,0,456,457,3,64,32,0, - 457,458,6,5,-1,0,458,490,1,0,0,0,459,460,6,5,-1,0,460,461,3,152,76,0,461, - 462,6,5,-1,0,462,490,1,0,0,0,463,464,3,330,165,0,464,465,6,5,-1,0,465, - 490,1,0,0,0,466,467,6,5,-1,0,467,490,3,12,6,0,468,469,6,5,-1,0,469,490, - 3,14,7,0,470,471,6,5,-1,0,471,490,3,16,8,0,472,473,6,5,-1,0,473,490,3, - 18,9,0,474,475,6,5,-1,0,475,490,3,20,10,0,476,477,6,5,-1,0,477,478,3,26, - 13,0,478,479,6,5,-1,0,479,490,1,0,0,0,480,481,6,5,-1,0,481,482,3,42,21, - 0,482,483,6,5,-1,0,483,490,1,0,0,0,484,485,6,5,-1,0,485,490,3,40,20,0, - 486,490,3,30,15,0,487,488,6,5,-1,0,488,490,3,24,12,0,489,403,1,0,0,0,489, - 408,1,0,0,0,489,413,1,0,0,0,489,418,1,0,0,0,489,419,1,0,0,0,489,423,1, - 0,0,0,489,427,1,0,0,0,489,431,1,0,0,0,489,435,1,0,0,0,489,439,1,0,0,0, - 489,443,1,0,0,0,489,447,1,0,0,0,489,451,1,0,0,0,489,455,1,0,0,0,489,459, - 1,0,0,0,489,463,1,0,0,0,489,466,1,0,0,0,489,468,1,0,0,0,489,470,1,0,0, - 0,489,472,1,0,0,0,489,474,1,0,0,0,489,476,1,0,0,0,489,480,1,0,0,0,489, - 484,1,0,0,0,489,486,1,0,0,0,489,487,1,0,0,0,490,11,1,0,0,0,491,492,5,19, - 0,0,492,493,3,32,16,0,493,494,6,6,-1,0,494,13,1,0,0,0,495,496,5,20,0,0, - 496,497,3,32,16,0,497,498,6,7,-1,0,498,15,1,0,0,0,499,500,5,21,0,0,500, - 501,5,22,0,0,501,502,3,32,16,0,502,503,6,8,-1,0,503,17,1,0,0,0,504,505, - 5,23,0,0,505,506,3,34,17,0,506,507,6,9,-1,0,507,19,1,0,0,0,508,509,5,24, - 0,0,509,510,3,34,17,0,510,511,6,10,-1,0,511,21,1,0,0,0,512,513,5,25,0, - 0,513,514,3,98,49,0,514,515,3,2,1,0,515,516,5,17,0,0,516,517,3,120,60, - 0,517,518,5,18,0,0,518,23,1,0,0,0,519,520,5,26,0,0,520,25,1,0,0,0,521, - 522,5,27,0,0,522,523,3,28,14,0,523,524,6,13,-1,0,524,540,1,0,0,0,525,526, - 5,27,0,0,526,527,3,28,14,0,527,528,5,28,0,0,528,529,3,28,14,0,529,530, - 6,13,-1,0,530,540,1,0,0,0,531,532,5,27,0,0,532,533,3,28,14,0,533,534,5, - 28,0,0,534,535,3,28,14,0,535,536,5,28,0,0,536,537,3,28,14,0,537,538,6, - 13,-1,0,538,540,1,0,0,0,539,521,1,0,0,0,539,525,1,0,0,0,539,531,1,0,0, - 0,540,27,1,0,0,0,541,542,7,2,0,0,542,29,1,0,0,0,543,544,5,29,0,0,544,550, - 5,17,0,0,545,546,3,116,58,0,546,547,6,15,-1,0,547,549,1,0,0,0,548,545, - 1,0,0,0,549,552,1,0,0,0,550,548,1,0,0,0,550,551,1,0,0,0,551,553,1,0,0, - 0,552,550,1,0,0,0,553,554,5,18,0,0,554,31,1,0,0,0,555,556,5,173,0,0,556, - 33,1,0,0,0,557,558,7,3,0,0,558,35,1,0,0,0,559,560,5,175,0,0,560,581,6, - 18,-1,0,561,562,3,32,16,0,562,563,5,265,0,0,563,564,6,18,-1,0,564,581, - 1,0,0,0,565,566,3,32,16,0,566,567,6,18,-1,0,567,581,1,0,0,0,568,569,5, - 188,0,0,569,570,5,30,0,0,570,571,3,32,16,0,571,572,5,31,0,0,572,573,6, - 18,-1,0,573,581,1,0,0,0,574,575,5,189,0,0,575,576,5,30,0,0,576,577,3,34, - 17,0,577,578,5,31,0,0,578,579,6,18,-1,0,579,581,1,0,0,0,580,559,1,0,0, - 0,580,561,1,0,0,0,580,565,1,0,0,0,580,568,1,0,0,0,580,574,1,0,0,0,581, - 37,1,0,0,0,582,585,3,32,16,0,583,585,5,262,0,0,584,582,1,0,0,0,584,583, - 1,0,0,0,585,39,1,0,0,0,586,587,5,267,0,0,587,603,5,289,0,0,588,589,5,267, - 0,0,589,590,5,289,0,0,590,603,5,263,0,0,591,592,5,268,0,0,592,603,5,289, - 0,0,593,594,5,269,0,0,594,603,5,289,0,0,595,596,5,270,0,0,596,603,5,289, - 0,0,597,603,5,271,0,0,598,603,5,272,0,0,599,600,5,273,0,0,600,603,5,263, - 0,0,601,603,5,32,0,0,602,586,1,0,0,0,602,588,1,0,0,0,602,591,1,0,0,0,602, - 593,1,0,0,0,602,595,1,0,0,0,602,597,1,0,0,0,602,598,1,0,0,0,602,599,1, - 0,0,0,602,601,1,0,0,0,603,41,1,0,0,0,604,605,5,33,0,0,605,606,3,138,69, - 0,606,607,5,34,0,0,607,608,3,2,1,0,608,630,1,0,0,0,609,610,5,33,0,0,610, - 611,3,116,58,0,611,612,5,34,0,0,612,613,3,2,1,0,613,630,1,0,0,0,614,615, - 5,33,0,0,615,616,3,176,88,0,616,617,5,34,0,0,617,618,3,2,1,0,618,630,1, - 0,0,0,619,620,5,33,0,0,620,621,3,44,22,0,621,622,5,34,0,0,622,623,3,2, - 1,0,623,630,1,0,0,0,624,625,5,33,0,0,625,626,3,46,23,0,626,627,5,34,0, - 0,627,628,3,2,1,0,628,630,1,0,0,0,629,604,1,0,0,0,629,609,1,0,0,0,629, - 614,1,0,0,0,629,619,1,0,0,0,629,624,1,0,0,0,630,43,1,0,0,0,631,632,5,35, - 0,0,632,633,3,48,24,0,633,634,6,22,-1,0,634,658,1,0,0,0,635,636,5,35,0, - 0,636,637,3,48,24,0,637,638,5,36,0,0,638,639,3,6,3,0,639,640,6,22,-1,0, - 640,658,1,0,0,0,641,642,5,35,0,0,642,643,3,48,24,0,643,644,5,36,0,0,644, - 645,5,17,0,0,645,646,3,52,26,0,646,647,5,18,0,0,647,648,6,22,-1,0,648, - 658,1,0,0,0,649,650,5,35,0,0,650,651,3,48,24,0,651,652,5,36,0,0,652,653, - 5,30,0,0,653,654,3,300,150,0,654,655,5,31,0,0,655,656,6,22,-1,0,656,658, - 1,0,0,0,657,631,1,0,0,0,657,635,1,0,0,0,657,641,1,0,0,0,657,649,1,0,0, - 0,658,45,1,0,0,0,659,660,5,35,0,0,660,661,5,30,0,0,661,662,3,50,25,0,662, - 663,5,31,0,0,663,664,3,48,24,0,664,665,6,23,-1,0,665,698,1,0,0,0,666,667, - 5,35,0,0,667,668,5,30,0,0,668,669,3,50,25,0,669,670,5,31,0,0,670,671,3, - 48,24,0,671,672,5,36,0,0,672,673,3,6,3,0,673,674,6,23,-1,0,674,698,1,0, - 0,0,675,676,5,35,0,0,676,677,5,30,0,0,677,678,3,50,25,0,678,679,5,31,0, - 0,679,680,3,48,24,0,680,681,5,36,0,0,681,682,5,17,0,0,682,683,3,52,26, - 0,683,684,5,18,0,0,684,685,6,23,-1,0,685,698,1,0,0,0,686,687,5,35,0,0, - 687,688,5,30,0,0,688,689,3,50,25,0,689,690,5,31,0,0,690,691,3,48,24,0, - 691,692,5,36,0,0,692,693,5,30,0,0,693,694,3,300,150,0,694,695,5,31,0,0, - 695,696,6,23,-1,0,696,698,1,0,0,0,697,659,1,0,0,0,697,666,1,0,0,0,697, - 675,1,0,0,0,697,686,1,0,0,0,698,47,1,0,0,0,699,700,3,168,84,0,700,701, - 6,24,-1,0,701,49,1,0,0,0,702,703,3,124,62,0,703,704,6,25,-1,0,704,709, - 1,0,0,0,705,706,3,176,88,0,706,707,6,25,-1,0,707,709,1,0,0,0,708,702,1, - 0,0,0,708,705,1,0,0,0,709,51,1,0,0,0,710,711,3,54,27,0,711,712,3,56,28, - 0,712,713,6,26,-1,0,713,53,1,0,0,0,714,715,3,306,153,0,715,716,6,27,-1, - 0,716,719,1,0,0,0,717,719,3,40,20,0,718,714,1,0,0,0,718,717,1,0,0,0,719, - 722,1,0,0,0,720,718,1,0,0,0,720,721,1,0,0,0,721,55,1,0,0,0,722,720,1,0, - 0,0,723,724,3,58,29,0,724,725,3,60,30,0,725,726,3,2,1,0,726,727,5,36,0, - 0,727,728,3,306,153,0,728,729,6,28,-1,0,729,732,1,0,0,0,730,732,3,40,20, - 0,731,723,1,0,0,0,731,730,1,0,0,0,732,735,1,0,0,0,733,731,1,0,0,0,733, - 734,1,0,0,0,734,57,1,0,0,0,735,733,1,0,0,0,736,737,7,4,0,0,737,738,6,29, - -1,0,738,59,1,0,0,0,739,741,3,62,31,0,740,742,5,261,0,0,741,740,1,0,0, - 0,741,742,1,0,0,0,742,743,1,0,0,0,743,744,6,30,-1,0,744,61,1,0,0,0,745, - 746,3,144,72,0,746,747,6,31,-1,0,747,764,1,0,0,0,748,749,3,2,1,0,749,750, - 6,31,-1,0,750,764,1,0,0,0,751,752,5,196,0,0,752,764,6,31,-1,0,753,754, - 5,197,0,0,754,764,6,31,-1,0,755,756,5,202,0,0,756,757,5,39,0,0,757,758, - 5,264,0,0,758,764,6,31,-1,0,759,760,5,202,0,0,760,761,3,116,58,0,761,762, - 6,31,-1,0,762,764,1,0,0,0,763,745,1,0,0,0,763,748,1,0,0,0,763,751,1,0, - 0,0,763,753,1,0,0,0,763,755,1,0,0,0,763,759,1,0,0,0,764,63,1,0,0,0,765, - 766,5,198,0,0,766,767,5,40,0,0,767,768,3,2,1,0,768,769,6,32,-1,0,769,777, - 1,0,0,0,770,771,5,198,0,0,771,772,3,2,1,0,772,773,6,32,-1,0,773,777,1, - 0,0,0,774,775,5,198,0,0,775,777,6,32,-1,0,776,765,1,0,0,0,776,770,1,0, - 0,0,776,774,1,0,0,0,777,65,1,0,0,0,778,779,5,41,0,0,779,780,5,42,0,0,780, - 781,3,32,16,0,781,782,5,43,0,0,782,783,3,68,34,0,783,784,5,44,0,0,784, - 785,3,0,0,0,785,67,1,0,0,0,786,799,6,34,-1,0,787,788,10,5,0,0,788,798, - 5,186,0,0,789,790,10,4,0,0,790,798,5,187,0,0,791,792,10,3,0,0,792,798, - 5,45,0,0,793,794,10,2,0,0,794,798,5,46,0,0,795,796,10,1,0,0,796,798,5, - 47,0,0,797,787,1,0,0,0,797,789,1,0,0,0,797,791,1,0,0,0,797,793,1,0,0,0, - 797,795,1,0,0,0,798,801,1,0,0,0,799,797,1,0,0,0,799,800,1,0,0,0,800,69, - 1,0,0,0,801,799,1,0,0,0,802,803,5,48,0,0,803,804,5,36,0,0,804,805,5,30, - 0,0,805,806,3,300,150,0,806,807,5,31,0,0,807,71,1,0,0,0,808,809,5,49,0, - 0,809,810,3,2,1,0,810,811,6,36,-1,0,811,73,1,0,0,0,812,818,5,50,0,0,813, - 814,3,76,38,0,814,815,6,37,-1,0,815,817,1,0,0,0,816,813,1,0,0,0,817,820, - 1,0,0,0,818,816,1,0,0,0,818,819,1,0,0,0,819,821,1,0,0,0,820,818,1,0,0, - 0,821,822,3,2,1,0,822,823,3,182,91,0,823,824,3,78,39,0,824,825,3,80,40, - 0,825,826,6,37,-1,0,826,75,1,0,0,0,827,828,5,51,0,0,828,892,6,38,-1,0, - 829,830,5,52,0,0,830,892,6,38,-1,0,831,832,5,199,0,0,832,892,6,38,-1,0, - 833,834,5,202,0,0,834,892,6,38,-1,0,835,836,5,221,0,0,836,892,6,38,-1, - 0,837,838,5,53,0,0,838,892,6,38,-1,0,839,840,5,54,0,0,840,892,6,38,-1, - 0,841,842,5,55,0,0,842,892,6,38,-1,0,843,844,5,56,0,0,844,892,6,38,-1, - 0,845,846,5,244,0,0,846,892,6,38,-1,0,847,848,5,15,0,0,848,892,6,38,-1, - 0,849,850,5,224,0,0,850,892,6,38,-1,0,851,852,5,57,0,0,852,892,6,38,-1, - 0,853,854,5,58,0,0,854,892,6,38,-1,0,855,856,5,59,0,0,856,892,6,38,-1, - 0,857,858,5,60,0,0,858,892,6,38,-1,0,859,860,5,61,0,0,860,892,6,38,-1, - 0,861,862,5,62,0,0,862,863,5,51,0,0,863,892,6,38,-1,0,864,865,5,62,0,0, - 865,866,5,52,0,0,866,892,6,38,-1,0,867,868,5,62,0,0,868,869,5,63,0,0,869, - 892,6,38,-1,0,870,871,5,62,0,0,871,872,5,64,0,0,872,892,6,38,-1,0,873, - 874,5,62,0,0,874,875,5,65,0,0,875,892,6,38,-1,0,876,877,5,62,0,0,877,878, - 5,66,0,0,878,892,6,38,-1,0,879,880,5,67,0,0,880,892,6,38,-1,0,881,882, - 5,68,0,0,882,892,6,38,-1,0,883,884,5,69,0,0,884,892,6,38,-1,0,885,886, - 5,70,0,0,886,887,5,30,0,0,887,888,3,32,16,0,888,889,5,31,0,0,889,890,6, - 38,-1,0,890,892,1,0,0,0,891,827,1,0,0,0,891,829,1,0,0,0,891,831,1,0,0, - 0,891,833,1,0,0,0,891,835,1,0,0,0,891,837,1,0,0,0,891,839,1,0,0,0,891, - 841,1,0,0,0,891,843,1,0,0,0,891,845,1,0,0,0,891,847,1,0,0,0,891,849,1, - 0,0,0,891,851,1,0,0,0,891,853,1,0,0,0,891,855,1,0,0,0,891,857,1,0,0,0, - 891,859,1,0,0,0,891,861,1,0,0,0,891,864,1,0,0,0,891,867,1,0,0,0,891,870, - 1,0,0,0,891,873,1,0,0,0,891,876,1,0,0,0,891,879,1,0,0,0,891,881,1,0,0, - 0,891,883,1,0,0,0,891,885,1,0,0,0,892,77,1,0,0,0,893,899,1,0,0,0,894,895, - 5,71,0,0,895,896,3,124,62,0,896,897,6,39,-1,0,897,899,1,0,0,0,898,893, - 1,0,0,0,898,894,1,0,0,0,899,79,1,0,0,0,900,906,1,0,0,0,901,902,5,72,0, - 0,902,903,3,84,42,0,903,904,6,40,-1,0,904,906,1,0,0,0,905,900,1,0,0,0, - 905,901,1,0,0,0,906,81,1,0,0,0,907,909,3,198,99,0,908,907,1,0,0,0,909, - 912,1,0,0,0,910,908,1,0,0,0,910,911,1,0,0,0,911,83,1,0,0,0,912,910,1,0, - 0,0,913,914,3,124,62,0,914,915,6,42,-1,0,915,916,5,28,0,0,916,918,1,0, - 0,0,917,913,1,0,0,0,918,921,1,0,0,0,919,917,1,0,0,0,919,920,1,0,0,0,920, - 922,1,0,0,0,921,919,1,0,0,0,922,923,3,124,62,0,923,924,6,42,-1,0,924,85, - 1,0,0,0,925,926,7,5,0,0,926,87,1,0,0,0,927,928,3,86,43,0,928,930,3,32, - 16,0,929,931,7,2,0,0,930,929,1,0,0,0,930,931,1,0,0,0,931,932,1,0,0,0,932, - 933,6,44,-1,0,933,979,1,0,0,0,934,935,3,86,43,0,935,936,3,32,16,0,936, - 937,5,75,0,0,937,939,3,32,16,0,938,940,7,2,0,0,939,938,1,0,0,0,939,940, - 1,0,0,0,940,941,1,0,0,0,941,942,6,44,-1,0,942,979,1,0,0,0,943,944,3,86, - 43,0,944,945,3,32,16,0,945,946,5,75,0,0,946,947,3,32,16,0,947,948,5,28, - 0,0,948,950,3,32,16,0,949,951,7,2,0,0,950,949,1,0,0,0,950,951,1,0,0,0, - 951,952,1,0,0,0,952,953,6,44,-1,0,953,979,1,0,0,0,954,955,3,86,43,0,955, - 956,3,32,16,0,956,957,5,28,0,0,957,958,3,32,16,0,958,959,5,75,0,0,959, - 961,3,32,16,0,960,962,7,2,0,0,961,960,1,0,0,0,961,962,1,0,0,0,962,963, - 1,0,0,0,963,964,6,44,-1,0,964,979,1,0,0,0,965,966,3,86,43,0,966,967,3, - 32,16,0,967,968,5,28,0,0,968,969,3,32,16,0,969,970,5,75,0,0,970,971,3, - 32,16,0,971,972,5,28,0,0,972,974,3,32,16,0,973,975,7,2,0,0,974,973,1,0, - 0,0,974,975,1,0,0,0,975,976,1,0,0,0,976,977,6,44,-1,0,977,979,1,0,0,0, - 978,927,1,0,0,0,978,934,1,0,0,0,978,943,1,0,0,0,978,954,1,0,0,0,978,965, - 1,0,0,0,979,89,1,0,0,0,980,984,5,21,0,0,981,983,3,92,46,0,982,981,1,0, - 0,0,983,986,1,0,0,0,984,982,1,0,0,0,984,985,1,0,0,0,985,987,1,0,0,0,986, - 984,1,0,0,0,987,988,3,2,1,0,988,989,3,94,47,0,989,990,5,180,0,0,990,991, - 5,36,0,0,991,992,5,30,0,0,992,993,3,300,150,0,993,994,5,31,0,0,994,995, - 3,94,47,0,995,1007,1,0,0,0,996,1000,5,21,0,0,997,999,3,92,46,0,998,997, - 1,0,0,0,999,1002,1,0,0,0,1000,998,1,0,0,0,1000,1001,1,0,0,0,1001,1003, - 1,0,0,0,1002,1000,1,0,0,0,1003,1004,3,2,1,0,1004,1005,3,94,47,0,1005,1007, - 1,0,0,0,1006,980,1,0,0,0,1006,996,1,0,0,0,1007,91,1,0,0,0,1008,1009,5, - 76,0,0,1009,93,1,0,0,0,1010,1013,1,0,0,0,1011,1013,5,298,0,0,1012,1010, - 1,0,0,0,1012,1011,1,0,0,0,1013,95,1,0,0,0,1014,1015,7,6,0,0,1015,97,1, - 0,0,0,1016,1018,3,96,48,0,1017,1016,1,0,0,0,1018,1021,1,0,0,0,1019,1017, - 1,0,0,0,1019,1020,1,0,0,0,1020,99,1,0,0,0,1021,1019,1,0,0,0,1022,1048, - 3,102,51,0,1023,1024,5,280,0,0,1024,1025,3,168,84,0,1025,1026,6,50,-1, - 0,1026,1048,1,0,0,0,1027,1028,5,286,0,0,1028,1029,3,178,89,0,1029,1030, - 6,50,-1,0,1030,1048,1,0,0,0,1031,1032,5,286,0,0,1032,1033,3,174,87,0,1033, - 1034,6,50,-1,0,1034,1048,1,0,0,0,1035,1036,5,284,0,0,1036,1037,3,124,62, - 0,1037,1038,6,50,-1,0,1038,1048,1,0,0,0,1039,1040,5,281,0,0,1040,1041, - 3,104,52,0,1041,1042,6,50,-1,0,1042,1048,1,0,0,0,1043,1044,5,287,0,0,1044, - 1045,3,50,25,0,1045,1046,6,50,-1,0,1046,1048,1,0,0,0,1047,1022,1,0,0,0, - 1047,1023,1,0,0,0,1047,1027,1,0,0,0,1047,1031,1,0,0,0,1047,1035,1,0,0, - 0,1047,1039,1,0,0,0,1047,1043,1,0,0,0,1048,101,1,0,0,0,1049,1050,5,275, - 0,0,1050,1128,6,51,-1,0,1051,1052,5,276,0,0,1052,1053,3,32,16,0,1053,1054, - 6,51,-1,0,1054,1128,1,0,0,0,1055,1056,5,276,0,0,1056,1057,3,0,0,0,1057, - 1058,6,51,-1,0,1058,1128,1,0,0,0,1059,1060,5,277,0,0,1060,1061,3,32,16, - 0,1061,1062,6,51,-1,0,1062,1128,1,0,0,0,1063,1064,5,278,0,0,1064,1065, - 3,34,17,0,1065,1066,6,51,-1,0,1066,1128,1,0,0,0,1067,1068,5,279,0,0,1068, - 1069,3,36,18,0,1069,1070,6,51,-1,0,1070,1128,1,0,0,0,1071,1072,5,279,0, - 0,1072,1073,3,34,17,0,1073,1074,6,51,-1,0,1074,1128,1,0,0,0,1075,1076, - 5,279,0,0,1076,1077,5,30,0,0,1077,1078,3,300,150,0,1078,1079,5,31,0,0, - 1079,1080,6,51,-1,0,1080,1128,1,0,0,0,1081,1082,5,279,0,0,1082,1083,5, - 84,0,0,1083,1084,5,30,0,0,1084,1085,3,300,150,0,1085,1086,5,31,0,0,1086, - 1087,6,51,-1,0,1087,1128,1,0,0,0,1088,1089,5,282,0,0,1089,1090,3,32,16, - 0,1090,1091,6,51,-1,0,1091,1128,1,0,0,0,1092,1093,5,282,0,0,1093,1094, - 3,0,0,0,1094,1095,6,51,-1,0,1095,1128,1,0,0,0,1096,1097,5,285,0,0,1097, - 1098,3,6,3,0,1098,1099,6,51,-1,0,1099,1128,1,0,0,0,1100,1101,5,285,0,0, - 1101,1102,5,224,0,0,1102,1103,5,30,0,0,1103,1104,3,6,3,0,1104,1105,5,31, - 0,0,1105,1106,6,51,-1,0,1106,1128,1,0,0,0,1107,1108,5,285,0,0,1108,1109, - 5,84,0,0,1109,1110,5,30,0,0,1110,1111,3,300,150,0,1111,1112,5,31,0,0,1112, - 1113,6,51,-1,0,1113,1128,1,0,0,0,1114,1115,5,287,0,0,1115,1116,3,32,16, - 0,1116,1117,6,51,-1,0,1117,1128,1,0,0,0,1118,1119,5,283,0,0,1119,1125, - 6,51,-1,0,1120,1121,5,30,0,0,1121,1122,3,106,53,0,1122,1123,5,31,0,0,1123, - 1126,1,0,0,0,1124,1126,5,85,0,0,1125,1120,1,0,0,0,1125,1124,1,0,0,0,1126, - 1128,1,0,0,0,1127,1049,1,0,0,0,1127,1051,1,0,0,0,1127,1055,1,0,0,0,1127, - 1059,1,0,0,0,1127,1063,1,0,0,0,1127,1067,1,0,0,0,1127,1071,1,0,0,0,1127, - 1075,1,0,0,0,1127,1081,1,0,0,0,1127,1088,1,0,0,0,1127,1092,1,0,0,0,1127, - 1096,1,0,0,0,1127,1100,1,0,0,0,1127,1107,1,0,0,0,1127,1114,1,0,0,0,1127, - 1118,1,0,0,0,1128,103,1,0,0,0,1129,1130,3,170,85,0,1130,1131,3,138,69, - 0,1131,1132,3,112,56,0,1132,1133,6,52,-1,0,1133,105,1,0,0,0,1134,1159, - 1,0,0,0,1135,1136,3,0,0,0,1136,1137,6,53,-1,0,1137,1142,1,0,0,0,1138,1139, - 3,32,16,0,1139,1140,6,53,-1,0,1140,1142,1,0,0,0,1141,1135,1,0,0,0,1141, - 1138,1,0,0,0,1142,1143,1,0,0,0,1143,1144,5,28,0,0,1144,1146,1,0,0,0,1145, - 1141,1,0,0,0,1146,1149,1,0,0,0,1147,1145,1,0,0,0,1147,1148,1,0,0,0,1148, - 1156,1,0,0,0,1149,1147,1,0,0,0,1150,1151,3,0,0,0,1151,1152,6,53,-1,0,1152, - 1157,1,0,0,0,1153,1154,3,32,16,0,1154,1155,6,53,-1,0,1155,1157,1,0,0,0, - 1156,1150,1,0,0,0,1156,1153,1,0,0,0,1157,1159,1,0,0,0,1158,1134,1,0,0, - 0,1158,1147,1,0,0,0,1159,107,1,0,0,0,1160,1167,5,86,0,0,1161,1162,3,138, - 69,0,1162,1163,6,54,-1,0,1163,1164,5,28,0,0,1164,1166,1,0,0,0,1165,1161, - 1,0,0,0,1166,1169,1,0,0,0,1167,1165,1,0,0,0,1167,1168,1,0,0,0,1168,1170, - 1,0,0,0,1169,1167,1,0,0,0,1170,1171,3,138,69,0,1171,1172,6,54,-1,0,1172, - 1173,5,87,0,0,1173,109,1,0,0,0,1174,1181,5,42,0,0,1175,1176,3,146,73,0, - 1176,1177,6,55,-1,0,1177,1178,5,28,0,0,1178,1180,1,0,0,0,1179,1175,1,0, - 0,0,1180,1183,1,0,0,0,1181,1179,1,0,0,0,1181,1182,1,0,0,0,1182,1184,1, - 0,0,0,1183,1181,1,0,0,0,1184,1185,3,146,73,0,1185,1186,6,55,-1,0,1186, - 1187,5,43,0,0,1187,111,1,0,0,0,1188,1195,5,30,0,0,1189,1190,3,114,57,0, - 1190,1191,6,56,-1,0,1191,1192,5,28,0,0,1192,1194,1,0,0,0,1193,1189,1,0, - 0,0,1194,1197,1,0,0,0,1195,1193,1,0,0,0,1195,1196,1,0,0,0,1196,1198,1, - 0,0,0,1197,1195,1,0,0,0,1198,1199,3,114,57,0,1199,1200,6,56,-1,0,1200, - 1201,5,31,0,0,1201,1204,1,0,0,0,1202,1204,5,85,0,0,1203,1188,1,0,0,0,1203, - 1202,1,0,0,0,1204,113,1,0,0,0,1205,1206,5,177,0,0,1206,1216,6,57,-1,0, - 1207,1208,3,230,115,0,1208,1209,3,138,69,0,1209,1211,3,226,113,0,1210, - 1212,3,0,0,0,1211,1210,1,0,0,0,1211,1212,1,0,0,0,1212,1213,1,0,0,0,1213, - 1214,6,57,-1,0,1214,1216,1,0,0,0,1215,1205,1,0,0,0,1215,1207,1,0,0,0,1216, - 115,1,0,0,0,1217,1218,5,42,0,0,1218,1219,3,2,1,0,1219,1220,5,43,0,0,1220, - 1221,3,118,59,0,1221,1222,6,58,-1,0,1222,1255,1,0,0,0,1223,1224,5,42,0, - 0,1224,1225,3,174,87,0,1225,1226,5,43,0,0,1226,1227,3,118,59,0,1227,1228, - 6,58,-1,0,1228,1255,1,0,0,0,1229,1230,5,42,0,0,1230,1231,5,262,0,0,1231, - 1232,5,43,0,0,1232,1233,3,118,59,0,1233,1234,6,58,-1,0,1234,1255,1,0,0, - 0,1235,1236,5,42,0,0,1236,1237,5,198,0,0,1237,1238,3,2,1,0,1238,1239,5, - 43,0,0,1239,1240,3,118,59,0,1240,1241,6,58,-1,0,1241,1255,1,0,0,0,1242, - 1243,3,118,59,0,1243,1244,6,58,-1,0,1244,1255,1,0,0,0,1245,1246,3,174, - 87,0,1246,1247,6,58,-1,0,1247,1255,1,0,0,0,1248,1249,5,257,0,0,1249,1255, - 6,58,-1,0,1250,1251,5,258,0,0,1251,1255,6,58,-1,0,1252,1253,5,259,0,0, - 1253,1255,6,58,-1,0,1254,1217,1,0,0,0,1254,1223,1,0,0,0,1254,1229,1,0, - 0,0,1254,1235,1,0,0,0,1254,1242,1,0,0,0,1254,1245,1,0,0,0,1254,1248,1, - 0,0,0,1254,1250,1,0,0,0,1254,1252,1,0,0,0,1255,117,1,0,0,0,1256,1257,3, - 2,1,0,1257,1258,6,59,-1,0,1258,1259,5,88,0,0,1259,1261,1,0,0,0,1260,1256, - 1,0,0,0,1261,1264,1,0,0,0,1262,1260,1,0,0,0,1262,1263,1,0,0,0,1263,1265, - 1,0,0,0,1264,1262,1,0,0,0,1265,1266,3,2,1,0,1266,1267,6,59,-1,0,1267,119, - 1,0,0,0,1268,1270,3,122,61,0,1269,1268,1,0,0,0,1270,1273,1,0,0,0,1271, - 1269,1,0,0,0,1271,1272,1,0,0,0,1272,121,1,0,0,0,1273,1271,1,0,0,0,1274, - 1275,5,180,0,0,1275,1276,5,89,0,0,1276,1280,3,32,16,0,1277,1280,3,152, - 76,0,1278,1280,3,332,166,0,1279,1274,1,0,0,0,1279,1277,1,0,0,0,1279,1278, - 1,0,0,0,1280,123,1,0,0,0,1281,1282,3,116,58,0,1282,1283,6,62,-1,0,1283, - 1299,1,0,0,0,1284,1285,5,42,0,0,1285,1286,3,2,1,0,1286,1287,5,43,0,0,1287, - 1288,6,62,-1,0,1288,1299,1,0,0,0,1289,1290,5,42,0,0,1290,1291,5,198,0, - 0,1291,1292,3,2,1,0,1292,1293,5,43,0,0,1293,1294,6,62,-1,0,1294,1299,1, - 0,0,0,1295,1296,3,138,69,0,1296,1297,6,62,-1,0,1297,1299,1,0,0,0,1298, - 1281,1,0,0,0,1298,1284,1,0,0,0,1298,1289,1,0,0,0,1298,1295,1,0,0,0,1299, - 125,1,0,0,0,1300,1312,1,0,0,0,1301,1302,3,130,65,0,1302,1308,6,63,-1,0, - 1303,1304,3,128,64,0,1304,1305,6,63,-1,0,1305,1307,1,0,0,0,1306,1303,1, - 0,0,0,1307,1310,1,0,0,0,1308,1306,1,0,0,0,1308,1309,1,0,0,0,1309,1312, - 1,0,0,0,1310,1308,1,0,0,0,1311,1300,1,0,0,0,1311,1301,1,0,0,0,1312,127, - 1,0,0,0,1313,1314,5,262,0,0,1314,1336,6,64,-1,0,1315,1316,5,261,0,0,1316, - 1336,6,64,-1,0,1317,1318,5,42,0,0,1318,1319,3,32,16,0,1319,1320,5,43,0, - 0,1320,1321,6,64,-1,0,1321,1336,1,0,0,0,1322,1323,5,42,0,0,1323,1324,3, - 32,16,0,1324,1325,5,266,0,0,1325,1326,3,32,16,0,1326,1327,5,43,0,0,1327, - 1328,6,64,-1,0,1328,1336,1,0,0,0,1329,1330,5,42,0,0,1330,1331,5,266,0, - 0,1331,1332,3,32,16,0,1332,1333,5,43,0,0,1333,1334,6,64,-1,0,1334,1336, - 1,0,0,0,1335,1313,1,0,0,0,1335,1315,1,0,0,0,1335,1317,1,0,0,0,1335,1322, - 1,0,0,0,1335,1329,1,0,0,0,1336,129,1,0,0,0,1337,1483,6,65,-1,0,1338,1339, - 5,203,0,0,1339,1340,5,30,0,0,1340,1341,3,6,3,0,1341,1342,5,28,0,0,1342, - 1343,3,6,3,0,1343,1344,5,28,0,0,1344,1345,3,6,3,0,1345,1346,5,28,0,0,1346, - 1347,3,6,3,0,1347,1348,5,31,0,0,1348,1349,6,65,-1,0,1349,1483,1,0,0,0, - 1350,1351,5,203,0,0,1351,1352,5,30,0,0,1352,1353,3,6,3,0,1353,1354,5,28, - 0,0,1354,1355,3,6,3,0,1355,1356,5,31,0,0,1356,1357,6,65,-1,0,1357,1483, - 1,0,0,0,1358,1359,5,204,0,0,1359,1360,5,205,0,0,1360,1361,5,42,0,0,1361, - 1362,3,32,16,0,1362,1363,5,43,0,0,1363,1364,6,65,-1,0,1364,1483,1,0,0, - 0,1365,1366,5,204,0,0,1366,1367,5,206,0,0,1367,1368,5,42,0,0,1368,1369, - 3,32,16,0,1369,1370,5,43,0,0,1370,1371,3,126,63,0,1371,1372,6,65,-1,0, - 1372,1483,1,0,0,0,1373,1374,5,207,0,0,1374,1483,6,65,-1,0,1375,1376,5, - 208,0,0,1376,1483,6,65,-1,0,1377,1378,5,209,0,0,1378,1483,6,65,-1,0,1379, - 1380,5,201,0,0,1380,1483,6,65,-1,0,1381,1382,5,183,0,0,1382,1483,6,65, - -1,0,1383,1384,5,184,0,0,1384,1483,6,65,-1,0,1385,1386,5,185,0,0,1386, - 1483,6,65,-1,0,1387,1388,5,186,0,0,1388,1483,6,65,-1,0,1389,1390,5,187, - 0,0,1390,1483,6,65,-1,0,1391,1392,5,188,0,0,1392,1483,6,65,-1,0,1393,1394, - 5,189,0,0,1394,1483,6,65,-1,0,1395,1396,5,210,0,0,1396,1483,6,65,-1,0, - 1397,1398,5,190,0,0,1398,1483,6,65,-1,0,1399,1400,5,191,0,0,1400,1483, - 6,65,-1,0,1401,1402,5,192,0,0,1402,1483,6,65,-1,0,1403,1404,5,193,0,0, - 1404,1483,6,65,-1,0,1405,1406,5,211,0,0,1406,1483,6,65,-1,0,1407,1408, - 5,212,0,0,1408,1483,6,65,-1,0,1409,1410,5,213,0,0,1410,1483,6,65,-1,0, - 1411,1412,5,214,0,0,1412,1483,6,65,-1,0,1413,1414,5,215,0,0,1414,1483, - 6,65,-1,0,1415,1416,5,216,0,0,1416,1483,6,65,-1,0,1417,1418,5,217,0,0, - 1418,1483,6,65,-1,0,1419,1420,5,218,0,0,1420,1421,3,132,66,0,1421,1422, - 6,65,-1,0,1422,1483,1,0,0,0,1423,1424,5,219,0,0,1424,1425,3,132,66,0,1425, - 1426,6,65,-1,0,1426,1483,1,0,0,0,1427,1428,5,220,0,0,1428,1483,6,65,-1, - 0,1429,1430,5,221,0,0,1430,1431,3,132,66,0,1431,1432,6,65,-1,0,1432,1483, - 1,0,0,0,1433,1434,5,222,0,0,1434,1435,3,134,67,0,1435,1436,6,65,-1,0,1436, - 1483,1,0,0,0,1437,1438,5,222,0,0,1438,1439,3,134,67,0,1439,1440,5,28,0, - 0,1440,1441,3,6,3,0,1441,1442,6,65,-1,0,1442,1483,1,0,0,0,1443,1444,5, - 194,0,0,1444,1483,6,65,-1,0,1445,1446,5,195,0,0,1446,1483,6,65,-1,0,1447, - 1448,5,90,0,0,1448,1449,5,184,0,0,1449,1483,6,65,-1,0,1450,1451,5,90,0, - 0,1451,1452,5,185,0,0,1452,1483,6,65,-1,0,1453,1454,5,90,0,0,1454,1455, - 5,186,0,0,1455,1483,6,65,-1,0,1456,1457,5,90,0,0,1457,1458,5,187,0,0,1458, - 1483,6,65,-1,0,1459,1460,5,62,0,0,1460,1461,5,220,0,0,1461,1483,6,65,-1, - 0,1462,1463,5,223,0,0,1463,1483,6,65,-1,0,1464,1465,5,224,0,0,1465,1466, - 5,213,0,0,1466,1483,6,65,-1,0,1467,1468,5,225,0,0,1468,1483,6,65,-1,0, - 1469,1470,5,207,0,0,1470,1471,5,183,0,0,1471,1483,6,65,-1,0,1472,1473, - 5,226,0,0,1473,1483,6,65,-1,0,1474,1475,5,228,0,0,1475,1483,6,65,-1,0, - 1476,1477,5,34,0,0,1477,1478,5,227,0,0,1478,1483,6,65,-1,0,1479,1480,3, - 2,1,0,1480,1481,6,65,-1,0,1481,1483,1,0,0,0,1482,1337,1,0,0,0,1482,1338, - 1,0,0,0,1482,1350,1,0,0,0,1482,1358,1,0,0,0,1482,1365,1,0,0,0,1482,1373, - 1,0,0,0,1482,1375,1,0,0,0,1482,1377,1,0,0,0,1482,1379,1,0,0,0,1482,1381, - 1,0,0,0,1482,1383,1,0,0,0,1482,1385,1,0,0,0,1482,1387,1,0,0,0,1482,1389, - 1,0,0,0,1482,1391,1,0,0,0,1482,1393,1,0,0,0,1482,1395,1,0,0,0,1482,1397, - 1,0,0,0,1482,1399,1,0,0,0,1482,1401,1,0,0,0,1482,1403,1,0,0,0,1482,1405, - 1,0,0,0,1482,1407,1,0,0,0,1482,1409,1,0,0,0,1482,1411,1,0,0,0,1482,1413, - 1,0,0,0,1482,1415,1,0,0,0,1482,1417,1,0,0,0,1482,1419,1,0,0,0,1482,1423, - 1,0,0,0,1482,1427,1,0,0,0,1482,1429,1,0,0,0,1482,1433,1,0,0,0,1482,1437, - 1,0,0,0,1482,1443,1,0,0,0,1482,1445,1,0,0,0,1482,1447,1,0,0,0,1482,1450, - 1,0,0,0,1482,1453,1,0,0,0,1482,1456,1,0,0,0,1482,1459,1,0,0,0,1482,1462, - 1,0,0,0,1482,1464,1,0,0,0,1482,1467,1,0,0,0,1482,1469,1,0,0,0,1482,1472, - 1,0,0,0,1482,1474,1,0,0,0,1482,1476,1,0,0,0,1482,1479,1,0,0,0,1483,131, - 1,0,0,0,1484,1493,1,0,0,0,1485,1486,5,30,0,0,1486,1487,5,91,0,0,1487,1488, - 5,36,0,0,1488,1489,3,32,16,0,1489,1490,5,31,0,0,1490,1491,6,66,-1,0,1491, - 1493,1,0,0,0,1492,1484,1,0,0,0,1492,1485,1,0,0,0,1493,133,1,0,0,0,1494, - 1505,1,0,0,0,1495,1496,3,136,68,0,1496,1501,6,67,-1,0,1497,1498,7,7,0, - 0,1498,1500,6,67,-1,0,1499,1497,1,0,0,0,1500,1503,1,0,0,0,1501,1499,1, - 0,0,0,1501,1502,1,0,0,0,1502,1505,1,0,0,0,1503,1501,1,0,0,0,1504,1494, - 1,0,0,0,1504,1495,1,0,0,0,1505,135,1,0,0,0,1506,1507,5,178,0,0,1507,1587, - 6,68,-1,0,1508,1509,5,207,0,0,1509,1587,6,68,-1,0,1510,1511,5,208,0,0, - 1511,1587,6,68,-1,0,1512,1513,5,201,0,0,1513,1587,6,68,-1,0,1514,1515, - 5,183,0,0,1515,1587,6,68,-1,0,1516,1517,5,184,0,0,1517,1587,6,68,-1,0, - 1518,1519,5,185,0,0,1519,1587,6,68,-1,0,1520,1521,5,186,0,0,1521,1587, - 6,68,-1,0,1522,1523,5,187,0,0,1523,1587,6,68,-1,0,1524,1525,5,188,0,0, - 1525,1587,6,68,-1,0,1526,1527,5,189,0,0,1527,1587,6,68,-1,0,1528,1529, - 5,190,0,0,1529,1587,6,68,-1,0,1530,1531,5,191,0,0,1531,1587,6,68,-1,0, - 1532,1533,5,192,0,0,1533,1587,6,68,-1,0,1534,1535,5,193,0,0,1535,1587, - 6,68,-1,0,1536,1537,5,262,0,0,1537,1587,6,68,-1,0,1538,1539,5,211,0,0, - 1539,1587,6,68,-1,0,1540,1541,5,212,0,0,1541,1587,6,68,-1,0,1542,1543, - 5,213,0,0,1543,1587,6,68,-1,0,1544,1545,5,214,0,0,1545,1587,6,68,-1,0, - 1546,1547,5,215,0,0,1547,1587,6,68,-1,0,1548,1549,5,218,0,0,1549,1587, - 6,68,-1,0,1550,1551,5,219,0,0,1551,1587,6,68,-1,0,1552,1553,5,222,0,0, - 1553,1587,6,68,-1,0,1554,1555,5,194,0,0,1555,1587,6,68,-1,0,1556,1557, - 5,195,0,0,1557,1587,6,68,-1,0,1558,1559,5,210,0,0,1559,1587,6,68,-1,0, - 1560,1561,5,230,0,0,1561,1587,6,68,-1,0,1562,1563,5,231,0,0,1563,1587, - 6,68,-1,0,1564,1565,5,232,0,0,1565,1587,6,68,-1,0,1566,1567,5,233,0,0, - 1567,1587,6,68,-1,0,1568,1569,5,234,0,0,1569,1587,6,68,-1,0,1570,1571, - 5,235,0,0,1571,1587,6,68,-1,0,1572,1573,5,236,0,0,1573,1587,6,68,-1,0, - 1574,1575,5,237,0,0,1575,1587,6,68,-1,0,1576,1577,5,238,0,0,1577,1587, - 6,68,-1,0,1578,1579,5,239,0,0,1579,1587,6,68,-1,0,1580,1581,5,240,0,0, - 1581,1587,6,68,-1,0,1582,1583,5,241,0,0,1583,1587,6,68,-1,0,1584,1585, - 5,242,0,0,1585,1587,6,68,-1,0,1586,1506,1,0,0,0,1586,1508,1,0,0,0,1586, - 1510,1,0,0,0,1586,1512,1,0,0,0,1586,1514,1,0,0,0,1586,1516,1,0,0,0,1586, - 1518,1,0,0,0,1586,1520,1,0,0,0,1586,1522,1,0,0,0,1586,1524,1,0,0,0,1586, - 1526,1,0,0,0,1586,1528,1,0,0,0,1586,1530,1,0,0,0,1586,1532,1,0,0,0,1586, - 1534,1,0,0,0,1586,1536,1,0,0,0,1586,1538,1,0,0,0,1586,1540,1,0,0,0,1586, - 1542,1,0,0,0,1586,1544,1,0,0,0,1586,1546,1,0,0,0,1586,1548,1,0,0,0,1586, - 1550,1,0,0,0,1586,1552,1,0,0,0,1586,1554,1,0,0,0,1586,1556,1,0,0,0,1586, - 1558,1,0,0,0,1586,1560,1,0,0,0,1586,1562,1,0,0,0,1586,1564,1,0,0,0,1586, - 1566,1,0,0,0,1586,1568,1,0,0,0,1586,1570,1,0,0,0,1586,1572,1,0,0,0,1586, - 1574,1,0,0,0,1586,1576,1,0,0,0,1586,1578,1,0,0,0,1586,1580,1,0,0,0,1586, - 1582,1,0,0,0,1586,1584,1,0,0,0,1587,137,1,0,0,0,1588,1589,3,142,71,0,1589, - 1595,6,69,-1,0,1590,1591,3,140,70,0,1591,1592,6,69,-1,0,1592,1594,1,0, - 0,0,1593,1590,1,0,0,0,1594,1597,1,0,0,0,1595,1593,1,0,0,0,1595,1596,1, - 0,0,0,1596,139,1,0,0,0,1597,1595,1,0,0,0,1598,1599,5,261,0,0,1599,1628, - 6,70,-1,0,1600,1601,5,42,0,0,1601,1602,5,43,0,0,1602,1628,6,70,-1,0,1603, - 1604,3,110,55,0,1604,1605,6,70,-1,0,1605,1628,1,0,0,0,1606,1607,5,260, - 0,0,1607,1628,6,70,-1,0,1608,1609,5,262,0,0,1609,1628,6,70,-1,0,1610,1611, - 5,92,0,0,1611,1628,6,70,-1,0,1612,1613,5,93,0,0,1613,1614,5,30,0,0,1614, - 1615,3,124,62,0,1615,1616,5,31,0,0,1616,1617,6,70,-1,0,1617,1628,1,0,0, - 0,1618,1619,5,94,0,0,1619,1620,5,30,0,0,1620,1621,3,124,62,0,1621,1622, - 5,31,0,0,1622,1623,6,70,-1,0,1623,1628,1,0,0,0,1624,1625,3,108,54,0,1625, - 1626,6,70,-1,0,1626,1628,1,0,0,0,1627,1598,1,0,0,0,1627,1600,1,0,0,0,1627, - 1603,1,0,0,0,1627,1606,1,0,0,0,1627,1608,1,0,0,0,1627,1610,1,0,0,0,1627, - 1612,1,0,0,0,1627,1618,1,0,0,0,1627,1624,1,0,0,0,1628,141,1,0,0,0,1629, - 1630,5,39,0,0,1630,1631,3,116,58,0,1631,1632,6,71,-1,0,1632,1688,1,0,0, - 0,1633,1634,5,197,0,0,1634,1688,6,71,-1,0,1635,1636,5,199,0,0,1636,1637, - 5,39,0,0,1637,1638,3,116,58,0,1638,1639,6,71,-1,0,1639,1688,1,0,0,0,1640, - 1641,5,200,0,0,1641,1642,3,116,58,0,1642,1643,6,71,-1,0,1643,1688,1,0, - 0,0,1644,1645,5,226,0,0,1645,1646,3,170,85,0,1646,1647,3,138,69,0,1647, - 1648,5,262,0,0,1648,1649,3,112,56,0,1649,1650,6,71,-1,0,1650,1688,1,0, - 0,0,1651,1652,5,253,0,0,1652,1653,3,32,16,0,1653,1654,6,71,-1,0,1654,1688, - 1,0,0,0,1655,1656,5,252,0,0,1656,1657,3,32,16,0,1657,1658,6,71,-1,0,1658, - 1688,1,0,0,0,1659,1660,5,253,0,0,1660,1661,3,2,1,0,1661,1662,6,71,-1,0, - 1662,1688,1,0,0,0,1663,1664,5,252,0,0,1664,1665,3,2,1,0,1665,1666,6,71, - -1,0,1666,1688,1,0,0,0,1667,1668,5,254,0,0,1668,1688,6,71,-1,0,1669,1670, - 5,201,0,0,1670,1688,6,71,-1,0,1671,1672,3,148,74,0,1672,1673,6,71,-1,0, - 1673,1688,1,0,0,0,1674,1675,3,150,75,0,1675,1676,6,71,-1,0,1676,1688,1, - 0,0,0,1677,1678,3,144,72,0,1678,1679,6,71,-1,0,1679,1688,1,0,0,0,1680, - 1681,3,2,1,0,1681,1682,6,71,-1,0,1682,1688,1,0,0,0,1683,1684,5,177,0,0, - 1684,1685,3,138,69,0,1685,1686,6,71,-1,0,1686,1688,1,0,0,0,1687,1629,1, - 0,0,0,1687,1633,1,0,0,0,1687,1635,1,0,0,0,1687,1640,1,0,0,0,1687,1644, - 1,0,0,0,1687,1651,1,0,0,0,1687,1655,1,0,0,0,1687,1659,1,0,0,0,1687,1663, - 1,0,0,0,1687,1667,1,0,0,0,1687,1669,1,0,0,0,1687,1671,1,0,0,0,1687,1674, - 1,0,0,0,1687,1677,1,0,0,0,1687,1680,1,0,0,0,1687,1683,1,0,0,0,1688,143, - 1,0,0,0,1689,1690,5,181,0,0,1690,1728,6,72,-1,0,1691,1692,5,182,0,0,1692, - 1728,6,72,-1,0,1693,1694,5,183,0,0,1694,1728,6,72,-1,0,1695,1696,5,184, - 0,0,1696,1728,6,72,-1,0,1697,1698,5,185,0,0,1698,1728,6,72,-1,0,1699,1700, - 5,186,0,0,1700,1728,6,72,-1,0,1701,1702,5,187,0,0,1702,1728,6,72,-1,0, - 1703,1704,5,188,0,0,1704,1728,6,72,-1,0,1705,1706,5,189,0,0,1706,1728, - 6,72,-1,0,1707,1708,5,190,0,0,1708,1728,6,72,-1,0,1709,1710,5,191,0,0, - 1710,1728,6,72,-1,0,1711,1712,5,192,0,0,1712,1728,6,72,-1,0,1713,1714, - 5,193,0,0,1714,1728,6,72,-1,0,1715,1716,5,90,0,0,1716,1717,5,184,0,0,1717, - 1728,6,72,-1,0,1718,1719,5,90,0,0,1719,1720,5,185,0,0,1720,1728,6,72,-1, - 0,1721,1722,5,90,0,0,1722,1723,5,186,0,0,1723,1728,6,72,-1,0,1724,1725, - 5,90,0,0,1725,1726,5,187,0,0,1726,1728,6,72,-1,0,1727,1689,1,0,0,0,1727, - 1691,1,0,0,0,1727,1693,1,0,0,0,1727,1695,1,0,0,0,1727,1697,1,0,0,0,1727, - 1699,1,0,0,0,1727,1701,1,0,0,0,1727,1703,1,0,0,0,1727,1705,1,0,0,0,1727, - 1707,1,0,0,0,1727,1709,1,0,0,0,1727,1711,1,0,0,0,1727,1713,1,0,0,0,1727, - 1715,1,0,0,0,1727,1718,1,0,0,0,1727,1721,1,0,0,0,1727,1724,1,0,0,0,1728, - 145,1,0,0,0,1729,1744,1,0,0,0,1730,1744,5,177,0,0,1731,1732,3,32,16,0, - 1732,1733,6,73,-1,0,1733,1744,1,0,0,0,1734,1735,3,32,16,0,1735,1736,5, - 177,0,0,1736,1737,3,32,16,0,1737,1738,6,73,-1,0,1738,1744,1,0,0,0,1739, - 1740,3,32,16,0,1740,1741,5,177,0,0,1741,1742,6,73,-1,0,1742,1744,1,0,0, - 0,1743,1729,1,0,0,0,1743,1730,1,0,0,0,1743,1731,1,0,0,0,1743,1734,1,0, - 0,0,1743,1739,1,0,0,0,1744,147,1,0,0,0,1745,1746,5,1,0,0,1746,1747,5,194, - 0,0,1747,1748,6,74,-1,0,1748,149,1,0,0,0,1749,1753,5,1,0,0,1750,1751,5, - 90,0,0,1751,1754,5,194,0,0,1752,1754,5,195,0,0,1753,1750,1,0,0,0,1753, - 1752,1,0,0,0,1754,1755,1,0,0,0,1755,1756,6,75,-1,0,1756,151,1,0,0,0,1757, - 1758,5,294,0,0,1758,1759,3,166,83,0,1759,1760,3,124,62,0,1760,1761,5,30, - 0,0,1761,1762,3,158,79,0,1762,1763,5,31,0,0,1763,1764,6,76,-1,0,1764,1812, - 1,0,0,0,1765,1766,5,294,0,0,1766,1767,3,166,83,0,1767,1768,3,124,62,0, - 1768,1769,5,36,0,0,1769,1770,5,17,0,0,1770,1771,3,52,26,0,1771,1772,5, - 18,0,0,1772,1773,6,76,-1,0,1773,1812,1,0,0,0,1774,1775,5,294,0,0,1775, - 1776,3,166,83,0,1776,1777,3,124,62,0,1777,1778,6,76,-1,0,1778,1812,1,0, - 0,0,1779,1780,5,295,0,0,1780,1781,3,166,83,0,1781,1783,5,36,0,0,1782,1784, - 5,84,0,0,1783,1782,1,0,0,0,1783,1784,1,0,0,0,1784,1785,1,0,0,0,1785,1786, - 5,30,0,0,1786,1787,3,300,150,0,1787,1788,5,31,0,0,1788,1789,6,76,-1,0, - 1789,1812,1,0,0,0,1790,1791,5,295,0,0,1791,1792,3,166,83,0,1792,1793,5, - 84,0,0,1793,1794,5,30,0,0,1794,1795,3,300,150,0,1795,1796,5,31,0,0,1796, - 1797,6,76,-1,0,1797,1812,1,0,0,0,1798,1799,5,295,0,0,1799,1800,3,166,83, - 0,1800,1801,3,6,3,0,1801,1802,6,76,-1,0,1802,1812,1,0,0,0,1803,1804,5, - 295,0,0,1804,1805,3,166,83,0,1805,1806,5,36,0,0,1806,1807,5,17,0,0,1807, - 1808,3,154,77,0,1808,1809,5,18,0,0,1809,1810,6,76,-1,0,1810,1812,1,0,0, - 0,1811,1757,1,0,0,0,1811,1765,1,0,0,0,1811,1774,1,0,0,0,1811,1779,1,0, - 0,0,1811,1790,1,0,0,0,1811,1798,1,0,0,0,1811,1803,1,0,0,0,1812,153,1,0, - 0,0,1813,1827,1,0,0,0,1814,1815,3,156,78,0,1815,1816,6,77,-1,0,1816,1817, - 5,28,0,0,1817,1819,1,0,0,0,1818,1814,1,0,0,0,1819,1822,1,0,0,0,1820,1818, - 1,0,0,0,1820,1821,1,0,0,0,1821,1823,1,0,0,0,1822,1820,1,0,0,0,1823,1824, - 3,156,78,0,1824,1825,6,77,-1,0,1825,1827,1,0,0,0,1826,1813,1,0,0,0,1826, - 1820,1,0,0,0,1827,155,1,0,0,0,1828,1829,5,39,0,0,1829,1830,5,264,0,0,1830, - 1831,5,36,0,0,1831,1832,5,17,0,0,1832,1833,3,56,28,0,1833,1834,5,18,0, - 0,1834,1835,6,78,-1,0,1835,1844,1,0,0,0,1836,1837,3,124,62,0,1837,1838, - 5,36,0,0,1838,1839,5,17,0,0,1839,1840,3,56,28,0,1840,1841,5,18,0,0,1841, - 1842,6,78,-1,0,1842,1844,1,0,0,0,1843,1828,1,0,0,0,1843,1836,1,0,0,0,1844, - 157,1,0,0,0,1845,1846,3,160,80,0,1846,1847,6,79,-1,0,1847,1848,5,28,0, - 0,1848,1850,1,0,0,0,1849,1845,1,0,0,0,1850,1853,1,0,0,0,1851,1849,1,0, - 0,0,1851,1852,1,0,0,0,1852,1854,1,0,0,0,1853,1851,1,0,0,0,1854,1855,3, - 160,80,0,1855,1856,6,79,-1,0,1856,159,1,0,0,0,1857,1858,3,6,3,0,1858,1859, - 5,36,0,0,1859,1860,3,164,82,0,1860,1861,6,80,-1,0,1861,161,1,0,0,0,1862, - 1863,7,8,0,0,1863,163,1,0,0,0,1864,1865,3,162,81,0,1865,1866,6,82,-1,0, - 1866,1910,1,0,0,0,1867,1868,3,32,16,0,1868,1869,6,82,-1,0,1869,1910,1, - 0,0,0,1870,1871,5,186,0,0,1871,1872,5,30,0,0,1872,1873,3,32,16,0,1873, - 1874,5,31,0,0,1874,1875,6,82,-1,0,1875,1910,1,0,0,0,1876,1877,3,6,3,0, - 1877,1878,6,82,-1,0,1878,1910,1,0,0,0,1879,1880,3,116,58,0,1880,1881,5, - 30,0,0,1881,1882,5,184,0,0,1882,1883,5,75,0,0,1883,1884,3,32,16,0,1884, - 1885,5,31,0,0,1885,1886,6,82,-1,0,1886,1910,1,0,0,0,1887,1888,3,116,58, - 0,1888,1889,5,30,0,0,1889,1890,5,185,0,0,1890,1891,5,75,0,0,1891,1892, - 3,32,16,0,1892,1893,5,31,0,0,1893,1894,6,82,-1,0,1894,1910,1,0,0,0,1895, - 1896,3,116,58,0,1896,1897,5,30,0,0,1897,1898,5,186,0,0,1898,1899,5,75, - 0,0,1899,1900,3,32,16,0,1900,1901,5,31,0,0,1901,1902,6,82,-1,0,1902,1910, - 1,0,0,0,1903,1904,3,116,58,0,1904,1905,5,30,0,0,1905,1906,3,32,16,0,1906, - 1907,5,31,0,0,1907,1908,6,82,-1,0,1908,1910,1,0,0,0,1909,1864,1,0,0,0, - 1909,1867,1,0,0,0,1909,1870,1,0,0,0,1909,1876,1,0,0,0,1909,1879,1,0,0, - 0,1909,1887,1,0,0,0,1909,1895,1,0,0,0,1909,1903,1,0,0,0,1910,165,1,0,0, - 0,1911,1912,7,9,0,0,1912,167,1,0,0,0,1913,1914,3,170,85,0,1914,1915,3, - 138,69,0,1915,1916,3,124,62,0,1916,1917,5,176,0,0,1917,1919,3,242,121, - 0,1918,1920,3,108,54,0,1919,1918,1,0,0,0,1919,1920,1,0,0,0,1920,1921,1, - 0,0,0,1921,1922,3,112,56,0,1922,1923,6,84,-1,0,1923,1956,1,0,0,0,1924, - 1925,3,170,85,0,1925,1926,3,138,69,0,1926,1927,3,124,62,0,1927,1928,5, - 176,0,0,1928,1929,3,242,121,0,1929,1930,3,196,98,0,1930,1931,3,112,56, - 0,1931,1932,6,84,-1,0,1932,1956,1,0,0,0,1933,1934,3,170,85,0,1934,1935, - 3,138,69,0,1935,1937,3,242,121,0,1936,1938,3,108,54,0,1937,1936,1,0,0, - 0,1937,1938,1,0,0,0,1938,1939,1,0,0,0,1939,1940,3,112,56,0,1940,1941,6, - 84,-1,0,1941,1956,1,0,0,0,1942,1943,3,170,85,0,1943,1944,3,138,69,0,1944, - 1945,3,242,121,0,1945,1946,3,196,98,0,1946,1947,3,112,56,0,1947,1948,6, - 84,-1,0,1948,1956,1,0,0,0,1949,1950,3,174,87,0,1950,1951,6,84,-1,0,1951, - 1956,1,0,0,0,1952,1953,3,2,1,0,1953,1954,6,84,-1,0,1954,1956,1,0,0,0,1955, - 1913,1,0,0,0,1955,1924,1,0,0,0,1955,1933,1,0,0,0,1955,1942,1,0,0,0,1955, - 1949,1,0,0,0,1955,1952,1,0,0,0,1956,169,1,0,0,0,1957,1958,5,243,0,0,1958, - 1959,3,170,85,0,1959,1960,6,85,-1,0,1960,1975,1,0,0,0,1961,1962,5,244, - 0,0,1962,1963,3,170,85,0,1963,1964,6,85,-1,0,1964,1975,1,0,0,0,1965,1966, - 3,172,86,0,1966,1967,6,85,-1,0,1967,1975,1,0,0,0,1968,1969,5,112,0,0,1969, - 1970,5,30,0,0,1970,1971,3,32,16,0,1971,1972,5,31,0,0,1972,1973,6,85,-1, - 0,1973,1975,1,0,0,0,1974,1957,1,0,0,0,1974,1961,1,0,0,0,1974,1965,1,0, - 0,0,1974,1968,1,0,0,0,1975,171,1,0,0,0,1976,1996,1,0,0,0,1977,1978,5,245, - 0,0,1978,1996,6,86,-1,0,1979,1980,5,246,0,0,1980,1996,6,86,-1,0,1981,1982, - 5,247,0,0,1982,1983,5,248,0,0,1983,1996,6,86,-1,0,1984,1985,5,247,0,0, - 1985,1986,5,249,0,0,1986,1996,6,86,-1,0,1987,1988,5,247,0,0,1988,1989, - 5,250,0,0,1989,1996,6,86,-1,0,1990,1991,5,247,0,0,1991,1992,5,251,0,0, - 1992,1996,6,86,-1,0,1993,1994,5,247,0,0,1994,1996,6,86,-1,0,1995,1976, - 1,0,0,0,1995,1977,1,0,0,0,1995,1979,1,0,0,0,1995,1981,1,0,0,0,1995,1984, - 1,0,0,0,1995,1987,1,0,0,0,1995,1990,1,0,0,0,1995,1993,1,0,0,0,1996,173, - 1,0,0,0,1997,1998,5,113,0,0,1998,1999,5,30,0,0,1999,2000,3,32,16,0,2000, - 2001,5,31,0,0,2001,2002,6,87,-1,0,2002,175,1,0,0,0,2003,2004,5,226,0,0, - 2004,2005,3,168,84,0,2005,2006,6,88,-1,0,2006,2015,1,0,0,0,2007,2008,5, - 37,0,0,2008,2009,3,178,89,0,2009,2010,6,88,-1,0,2010,2015,1,0,0,0,2011, - 2012,3,174,87,0,2012,2013,6,88,-1,0,2013,2015,1,0,0,0,2014,2003,1,0,0, - 0,2014,2007,1,0,0,0,2014,2011,1,0,0,0,2015,177,1,0,0,0,2016,2017,3,138, - 69,0,2017,2018,3,124,62,0,2018,2019,5,176,0,0,2019,2020,3,2,1,0,2020,2021, - 6,89,-1,0,2021,2030,1,0,0,0,2022,2023,3,138,69,0,2023,2024,3,2,1,0,2024, - 2025,6,89,-1,0,2025,2030,1,0,0,0,2026,2027,3,2,1,0,2027,2028,6,89,-1,0, - 2028,2030,1,0,0,0,2029,2016,1,0,0,0,2029,2022,1,0,0,0,2029,2026,1,0,0, - 0,2030,179,1,0,0,0,2031,2032,3,124,62,0,2032,2033,6,90,-1,0,2033,2034, - 5,28,0,0,2034,2036,1,0,0,0,2035,2031,1,0,0,0,2036,2039,1,0,0,0,2037,2035, - 1,0,0,0,2037,2038,1,0,0,0,2038,2040,1,0,0,0,2039,2037,1,0,0,0,2040,2041, - 3,124,62,0,2041,2042,6,90,-1,0,2042,181,1,0,0,0,2043,2050,1,0,0,0,2044, - 2045,5,86,0,0,2045,2046,3,190,95,0,2046,2047,5,87,0,0,2047,2048,6,91,-1, - 0,2048,2050,1,0,0,0,2049,2043,1,0,0,0,2049,2044,1,0,0,0,2050,183,1,0,0, - 0,2051,2052,5,266,0,0,2052,2070,6,92,-1,0,2053,2054,5,114,0,0,2054,2070, - 6,92,-1,0,2055,2056,5,39,0,0,2056,2070,6,92,-1,0,2057,2058,5,200,0,0,2058, - 2070,6,92,-1,0,2059,2060,5,115,0,0,2060,2070,6,92,-1,0,2061,2062,5,116, - 0,0,2062,2070,6,92,-1,0,2063,2064,5,70,0,0,2064,2065,5,30,0,0,2065,2066, - 3,32,16,0,2066,2067,5,31,0,0,2067,2068,6,92,-1,0,2068,2070,1,0,0,0,2069, - 2051,1,0,0,0,2069,2053,1,0,0,0,2069,2055,1,0,0,0,2069,2057,1,0,0,0,2069, - 2059,1,0,0,0,2069,2061,1,0,0,0,2069,2063,1,0,0,0,2070,185,1,0,0,0,2071, - 2072,3,184,92,0,2072,2073,6,93,-1,0,2073,2075,1,0,0,0,2074,2071,1,0,0, - 0,2075,2078,1,0,0,0,2076,2074,1,0,0,0,2076,2077,1,0,0,0,2077,187,1,0,0, - 0,2078,2076,1,0,0,0,2079,2081,3,186,93,0,2080,2082,3,192,96,0,2081,2080, - 1,0,0,0,2081,2082,1,0,0,0,2082,2083,1,0,0,0,2083,2084,3,2,1,0,2084,2085, - 6,94,-1,0,2085,189,1,0,0,0,2086,2087,3,188,94,0,2087,2088,6,95,-1,0,2088, - 2089,5,28,0,0,2089,2091,1,0,0,0,2090,2086,1,0,0,0,2091,2094,1,0,0,0,2092, - 2090,1,0,0,0,2092,2093,1,0,0,0,2093,2095,1,0,0,0,2094,2092,1,0,0,0,2095, - 2096,3,188,94,0,2096,2097,6,95,-1,0,2097,191,1,0,0,0,2098,2099,5,30,0, - 0,2099,2100,3,180,90,0,2100,2101,5,31,0,0,2101,2102,6,96,-1,0,2102,193, - 1,0,0,0,2103,2105,3,196,98,0,2104,2103,1,0,0,0,2104,2105,1,0,0,0,2105, - 2106,1,0,0,0,2106,2107,6,97,-1,0,2107,195,1,0,0,0,2108,2109,5,86,0,0,2109, - 2110,5,42,0,0,2110,2111,3,32,16,0,2111,2112,5,43,0,0,2112,2113,5,87,0, - 0,2113,2114,6,98,-1,0,2114,197,1,0,0,0,2115,2116,3,234,117,0,2116,2117, - 5,17,0,0,2117,2118,3,246,123,0,2118,2119,5,18,0,0,2119,2266,1,0,0,0,2120, - 2121,3,74,37,0,2121,2122,5,17,0,0,2122,2123,3,82,41,0,2123,2124,5,18,0, - 0,2124,2266,1,0,0,0,2125,2126,3,210,105,0,2126,2127,6,99,-1,0,2127,2128, - 5,17,0,0,2128,2129,3,214,107,0,2129,2130,5,18,0,0,2130,2266,1,0,0,0,2131, - 2132,3,218,109,0,2132,2133,6,99,-1,0,2133,2134,5,17,0,0,2134,2135,3,222, - 111,0,2135,2136,5,18,0,0,2136,2266,1,0,0,0,2137,2266,3,200,100,0,2138, - 2139,3,284,142,0,2139,2140,6,99,-1,0,2140,2266,1,0,0,0,2141,2142,3,152, - 76,0,2142,2143,6,99,-1,0,2143,2266,1,0,0,0,2144,2145,3,88,44,0,2145,2146, - 6,99,-1,0,2146,2266,1,0,0,0,2147,2148,3,330,165,0,2148,2149,6,99,-1,0, - 2149,2266,1,0,0,0,2150,2151,5,117,0,0,2151,2152,3,32,16,0,2152,2153,6, - 99,-1,0,2153,2266,1,0,0,0,2154,2155,5,118,0,0,2155,2156,3,32,16,0,2156, - 2157,6,99,-1,0,2157,2266,1,0,0,0,2158,2159,3,346,173,0,2159,2160,5,17, - 0,0,2160,2161,3,350,175,0,2161,2162,5,18,0,0,2162,2163,6,99,-1,0,2163, - 2266,1,0,0,0,2164,2165,5,302,0,0,2165,2166,3,124,62,0,2166,2167,5,176, - 0,0,2167,2168,3,242,121,0,2168,2169,5,119,0,0,2169,2170,3,170,85,0,2170, - 2171,3,138,69,0,2171,2172,3,124,62,0,2172,2173,5,176,0,0,2173,2174,3,242, - 121,0,2174,2175,3,112,56,0,2175,2176,6,99,-1,0,2176,2266,1,0,0,0,2177, - 2178,5,302,0,0,2178,2179,5,226,0,0,2179,2180,3,170,85,0,2180,2181,3,138, - 69,0,2181,2182,3,124,62,0,2182,2183,5,176,0,0,2183,2184,3,242,121,0,2184, - 2185,3,194,97,0,2185,2186,3,112,56,0,2186,2187,5,119,0,0,2187,2188,5,226, - 0,0,2188,2189,3,170,85,0,2189,2190,3,138,69,0,2190,2191,3,124,62,0,2191, - 2192,5,176,0,0,2192,2193,3,242,121,0,2193,2194,3,194,97,0,2194,2195,3, - 112,56,0,2195,2196,6,99,-1,0,2196,2266,1,0,0,0,2197,2198,3,26,13,0,2198, - 2199,6,99,-1,0,2199,2266,1,0,0,0,2200,2201,3,40,20,0,2201,2202,6,99,-1, - 0,2202,2266,1,0,0,0,2203,2204,5,255,0,0,2204,2205,5,196,0,0,2205,2206, - 5,42,0,0,2206,2207,3,32,16,0,2207,2208,5,43,0,0,2208,2214,6,99,-1,0,2209, - 2210,3,330,165,0,2210,2211,6,99,-1,0,2211,2213,1,0,0,0,2212,2209,1,0,0, - 0,2213,2216,1,0,0,0,2214,2212,1,0,0,0,2214,2215,1,0,0,0,2215,2266,1,0, - 0,0,2216,2214,1,0,0,0,2217,2218,5,255,0,0,2218,2219,5,196,0,0,2219,2220, - 3,2,1,0,2220,2226,6,99,-1,0,2221,2222,3,330,165,0,2222,2223,6,99,-1,0, - 2223,2225,1,0,0,0,2224,2221,1,0,0,0,2225,2228,1,0,0,0,2226,2224,1,0,0, - 0,2226,2227,1,0,0,0,2227,2266,1,0,0,0,2228,2226,1,0,0,0,2229,2230,5,255, - 0,0,2230,2231,5,256,0,0,2231,2232,5,42,0,0,2232,2233,3,32,16,0,2233,2234, - 5,43,0,0,2234,2235,5,28,0,0,2235,2236,3,124,62,0,2236,2242,6,99,-1,0,2237, - 2238,3,330,165,0,2238,2239,6,99,-1,0,2239,2241,1,0,0,0,2240,2237,1,0,0, - 0,2241,2244,1,0,0,0,2242,2240,1,0,0,0,2242,2243,1,0,0,0,2243,2266,1,0, - 0,0,2244,2242,1,0,0,0,2245,2246,5,255,0,0,2246,2247,5,256,0,0,2247,2248, - 3,2,1,0,2248,2249,5,28,0,0,2249,2250,3,124,62,0,2250,2256,6,99,-1,0,2251, - 2252,3,330,165,0,2252,2253,6,99,-1,0,2253,2255,1,0,0,0,2254,2251,1,0,0, - 0,2255,2258,1,0,0,0,2256,2254,1,0,0,0,2256,2257,1,0,0,0,2257,2266,1,0, - 0,0,2258,2256,1,0,0,0,2259,2260,5,120,0,0,2260,2261,5,196,0,0,2261,2262, - 3,124,62,0,2262,2263,3,44,22,0,2263,2264,6,99,-1,0,2264,2266,1,0,0,0,2265, - 2115,1,0,0,0,2265,2120,1,0,0,0,2265,2125,1,0,0,0,2265,2131,1,0,0,0,2265, - 2137,1,0,0,0,2265,2138,1,0,0,0,2265,2141,1,0,0,0,2265,2144,1,0,0,0,2265, - 2147,1,0,0,0,2265,2150,1,0,0,0,2265,2154,1,0,0,0,2265,2158,1,0,0,0,2265, - 2164,1,0,0,0,2265,2177,1,0,0,0,2265,2197,1,0,0,0,2265,2200,1,0,0,0,2265, - 2203,1,0,0,0,2265,2217,1,0,0,0,2265,2229,1,0,0,0,2265,2245,1,0,0,0,2265, - 2259,1,0,0,0,2266,199,1,0,0,0,2267,2268,5,121,0,0,2268,2280,3,208,104, - 0,2269,2270,3,202,101,0,2270,2271,6,100,-1,0,2271,2279,1,0,0,0,2272,2273, - 5,122,0,0,2273,2274,5,30,0,0,2274,2275,3,228,114,0,2275,2276,5,31,0,0, - 2276,2277,6,100,-1,0,2277,2279,1,0,0,0,2278,2269,1,0,0,0,2278,2272,1,0, - 0,0,2279,2282,1,0,0,0,2280,2278,1,0,0,0,2280,2281,1,0,0,0,2281,2283,1, - 0,0,0,2282,2280,1,0,0,0,2283,2284,3,138,69,0,2284,2285,3,2,1,0,2285,2286, - 3,204,102,0,2286,2287,3,206,103,0,2287,2288,6,100,-1,0,2288,201,1,0,0, - 0,2289,2290,5,123,0,0,2290,2324,6,101,-1,0,2291,2292,5,51,0,0,2292,2324, - 6,101,-1,0,2293,2294,5,52,0,0,2294,2324,6,101,-1,0,2295,2296,5,63,0,0, - 2296,2324,6,101,-1,0,2297,2298,5,124,0,0,2298,2324,6,101,-1,0,2299,2300, - 5,69,0,0,2300,2324,6,101,-1,0,2301,2302,5,68,0,0,2302,2324,6,101,-1,0, - 2303,2304,5,64,0,0,2304,2324,6,101,-1,0,2305,2306,5,65,0,0,2306,2324,6, - 101,-1,0,2307,2308,5,66,0,0,2308,2324,6,101,-1,0,2309,2310,5,125,0,0,2310, - 2324,6,101,-1,0,2311,2312,5,126,0,0,2312,2324,6,101,-1,0,2313,2314,5,127, - 0,0,2314,2324,6,101,-1,0,2315,2316,5,16,0,0,2316,2324,6,101,-1,0,2317, - 2318,5,70,0,0,2318,2319,5,30,0,0,2319,2320,3,32,16,0,2320,2321,5,31,0, - 0,2321,2322,6,101,-1,0,2322,2324,1,0,0,0,2323,2289,1,0,0,0,2323,2291,1, - 0,0,0,2323,2293,1,0,0,0,2323,2295,1,0,0,0,2323,2297,1,0,0,0,2323,2299, - 1,0,0,0,2323,2301,1,0,0,0,2323,2303,1,0,0,0,2323,2305,1,0,0,0,2323,2307, - 1,0,0,0,2323,2309,1,0,0,0,2323,2311,1,0,0,0,2323,2313,1,0,0,0,2323,2315, - 1,0,0,0,2323,2317,1,0,0,0,2324,203,1,0,0,0,2325,2335,1,0,0,0,2326,2327, - 5,44,0,0,2327,2328,3,0,0,0,2328,2329,6,102,-1,0,2329,2335,1,0,0,0,2330, - 2331,5,44,0,0,2331,2332,3,32,16,0,2332,2333,6,102,-1,0,2333,2335,1,0,0, - 0,2334,2325,1,0,0,0,2334,2326,1,0,0,0,2334,2330,1,0,0,0,2335,205,1,0,0, - 0,2336,2342,1,0,0,0,2337,2338,5,36,0,0,2338,2339,3,304,152,0,2339,2340, - 6,103,-1,0,2340,2342,1,0,0,0,2341,2336,1,0,0,0,2341,2337,1,0,0,0,2342, - 207,1,0,0,0,2343,2350,1,0,0,0,2344,2345,5,42,0,0,2345,2346,3,32,16,0,2346, - 2347,5,43,0,0,2347,2348,6,104,-1,0,2348,2350,1,0,0,0,2349,2343,1,0,0,0, - 2349,2344,1,0,0,0,2350,209,1,0,0,0,2351,2357,5,128,0,0,2352,2353,3,212, - 106,0,2353,2354,6,105,-1,0,2354,2356,1,0,0,0,2355,2352,1,0,0,0,2356,2359, - 1,0,0,0,2357,2355,1,0,0,0,2357,2358,1,0,0,0,2358,2360,1,0,0,0,2359,2357, - 1,0,0,0,2360,2361,3,124,62,0,2361,2362,3,2,1,0,2362,2363,6,105,-1,0,2363, - 2377,1,0,0,0,2364,2370,5,128,0,0,2365,2366,3,212,106,0,2366,2367,6,105, - -1,0,2367,2369,1,0,0,0,2368,2365,1,0,0,0,2369,2372,1,0,0,0,2370,2368,1, - 0,0,0,2370,2371,1,0,0,0,2371,2373,1,0,0,0,2372,2370,1,0,0,0,2373,2374, - 3,2,1,0,2374,2375,6,105,-1,0,2375,2377,1,0,0,0,2376,2351,1,0,0,0,2376, - 2364,1,0,0,0,2377,211,1,0,0,0,2378,2379,5,69,0,0,2379,2383,6,106,-1,0, - 2380,2381,5,68,0,0,2381,2383,6,106,-1,0,2382,2378,1,0,0,0,2382,2380,1, - 0,0,0,2383,213,1,0,0,0,2384,2386,3,216,108,0,2385,2384,1,0,0,0,2386,2389, - 1,0,0,0,2387,2385,1,0,0,0,2387,2388,1,0,0,0,2388,215,1,0,0,0,2389,2387, - 1,0,0,0,2390,2391,5,129,0,0,2391,2392,3,168,84,0,2392,2393,6,108,-1,0, - 2393,2417,1,0,0,0,2394,2395,5,130,0,0,2395,2396,3,168,84,0,2396,2397,6, - 108,-1,0,2397,2417,1,0,0,0,2398,2399,5,131,0,0,2399,2400,3,168,84,0,2400, - 2401,6,108,-1,0,2401,2417,1,0,0,0,2402,2403,5,132,0,0,2403,2404,3,168, - 84,0,2404,2405,6,108,-1,0,2405,2417,1,0,0,0,2406,2407,3,88,44,0,2407,2408, - 6,108,-1,0,2408,2417,1,0,0,0,2409,2410,3,330,165,0,2410,2411,6,108,-1, - 0,2411,2417,1,0,0,0,2412,2413,3,26,13,0,2413,2414,6,108,-1,0,2414,2417, - 1,0,0,0,2415,2417,3,40,20,0,2416,2390,1,0,0,0,2416,2394,1,0,0,0,2416,2398, - 1,0,0,0,2416,2402,1,0,0,0,2416,2406,1,0,0,0,2416,2409,1,0,0,0,2416,2412, - 1,0,0,0,2416,2415,1,0,0,0,2417,217,1,0,0,0,2418,2424,5,133,0,0,2419,2420, - 3,220,110,0,2420,2421,6,109,-1,0,2421,2423,1,0,0,0,2422,2419,1,0,0,0,2423, - 2426,1,0,0,0,2424,2422,1,0,0,0,2424,2425,1,0,0,0,2425,2427,1,0,0,0,2426, - 2424,1,0,0,0,2427,2428,3,170,85,0,2428,2429,3,138,69,0,2429,2430,3,2,1, - 0,2430,2431,3,112,56,0,2431,2432,3,206,103,0,2432,2433,6,109,-1,0,2433, - 219,1,0,0,0,2434,2435,5,69,0,0,2435,2439,6,110,-1,0,2436,2437,5,68,0,0, - 2437,2439,6,110,-1,0,2438,2434,1,0,0,0,2438,2436,1,0,0,0,2439,221,1,0, - 0,0,2440,2442,3,224,112,0,2441,2440,1,0,0,0,2442,2445,1,0,0,0,2443,2441, - 1,0,0,0,2443,2444,1,0,0,0,2444,223,1,0,0,0,2445,2443,1,0,0,0,2446,2447, - 5,134,0,0,2447,2448,3,168,84,0,2448,2449,6,112,-1,0,2449,2469,1,0,0,0, - 2450,2451,5,135,0,0,2451,2452,3,168,84,0,2452,2453,6,112,-1,0,2453,2469, - 1,0,0,0,2454,2455,5,132,0,0,2455,2456,3,168,84,0,2456,2457,6,112,-1,0, - 2457,2469,1,0,0,0,2458,2459,3,330,165,0,2459,2460,6,112,-1,0,2460,2469, - 1,0,0,0,2461,2462,3,88,44,0,2462,2463,6,112,-1,0,2463,2469,1,0,0,0,2464, - 2465,3,26,13,0,2465,2466,6,112,-1,0,2466,2469,1,0,0,0,2467,2469,3,40,20, - 0,2468,2446,1,0,0,0,2468,2450,1,0,0,0,2468,2454,1,0,0,0,2468,2458,1,0, - 0,0,2468,2461,1,0,0,0,2468,2464,1,0,0,0,2468,2467,1,0,0,0,2469,225,1,0, - 0,0,2470,2478,6,113,-1,0,2471,2472,5,122,0,0,2472,2473,5,30,0,0,2473,2474, - 3,228,114,0,2474,2475,5,31,0,0,2475,2476,6,113,-1,0,2476,2478,1,0,0,0, - 2477,2470,1,0,0,0,2477,2471,1,0,0,0,2478,227,1,0,0,0,2479,2480,3,126,63, - 0,2480,2481,6,114,-1,0,2481,2493,1,0,0,0,2482,2486,5,17,0,0,2483,2484, - 3,302,151,0,2484,2485,6,114,-1,0,2485,2487,1,0,0,0,2486,2483,1,0,0,0,2487, - 2488,1,0,0,0,2488,2486,1,0,0,0,2488,2489,1,0,0,0,2489,2490,1,0,0,0,2490, - 2491,5,18,0,0,2491,2493,1,0,0,0,2492,2479,1,0,0,0,2492,2482,1,0,0,0,2493, - 229,1,0,0,0,2494,2495,3,232,116,0,2495,2496,6,115,-1,0,2496,2498,1,0,0, - 0,2497,2494,1,0,0,0,2498,2501,1,0,0,0,2499,2497,1,0,0,0,2499,2500,1,0, - 0,0,2500,231,1,0,0,0,2501,2499,1,0,0,0,2502,2503,5,42,0,0,2503,2504,5, - 136,0,0,2504,2505,5,43,0,0,2505,2520,6,116,-1,0,2506,2507,5,42,0,0,2507, - 2508,5,137,0,0,2508,2509,5,43,0,0,2509,2520,6,116,-1,0,2510,2511,5,42, - 0,0,2511,2512,5,138,0,0,2512,2513,5,43,0,0,2513,2520,6,116,-1,0,2514,2515, - 5,42,0,0,2515,2516,3,32,16,0,2516,2517,5,43,0,0,2517,2518,6,116,-1,0,2518, - 2520,1,0,0,0,2519,2502,1,0,0,0,2519,2506,1,0,0,0,2519,2510,1,0,0,0,2519, - 2514,1,0,0,0,2520,233,1,0,0,0,2521,2530,5,139,0,0,2522,2523,3,236,118, - 0,2523,2524,6,117,-1,0,2524,2529,1,0,0,0,2525,2526,3,238,119,0,2526,2527, - 6,117,-1,0,2527,2529,1,0,0,0,2528,2522,1,0,0,0,2528,2525,1,0,0,0,2529, - 2532,1,0,0,0,2530,2528,1,0,0,0,2530,2531,1,0,0,0,2531,2533,1,0,0,0,2532, - 2530,1,0,0,0,2533,2534,3,170,85,0,2534,2535,3,230,115,0,2535,2536,3,138, - 69,0,2536,2537,3,226,113,0,2537,2538,3,242,121,0,2538,2539,3,182,91,0, - 2539,2545,3,112,56,0,2540,2541,3,244,122,0,2541,2542,6,117,-1,0,2542,2544, - 1,0,0,0,2543,2540,1,0,0,0,2544,2547,1,0,0,0,2545,2543,1,0,0,0,2545,2546, - 1,0,0,0,2546,2548,1,0,0,0,2547,2545,1,0,0,0,2548,2549,6,117,-1,0,2549, - 235,1,0,0,0,2550,2551,5,123,0,0,2551,2593,6,118,-1,0,2552,2553,5,51,0, - 0,2553,2593,6,118,-1,0,2554,2555,5,52,0,0,2555,2593,6,118,-1,0,2556,2557, - 5,63,0,0,2557,2593,6,118,-1,0,2558,2559,5,140,0,0,2559,2593,6,118,-1,0, - 2560,2561,5,68,0,0,2561,2593,6,118,-1,0,2562,2563,5,141,0,0,2563,2593, - 6,118,-1,0,2564,2565,5,142,0,0,2565,2593,6,118,-1,0,2566,2567,5,54,0,0, - 2567,2593,6,118,-1,0,2568,2569,5,64,0,0,2569,2593,6,118,-1,0,2570,2571, - 5,65,0,0,2571,2593,6,118,-1,0,2572,2573,5,66,0,0,2573,2593,6,118,-1,0, - 2574,2575,5,125,0,0,2575,2593,6,118,-1,0,2576,2577,5,143,0,0,2577,2593, - 6,118,-1,0,2578,2579,5,144,0,0,2579,2593,6,118,-1,0,2580,2581,5,69,0,0, - 2581,2593,6,118,-1,0,2582,2583,5,145,0,0,2583,2593,6,118,-1,0,2584,2585, - 5,146,0,0,2585,2593,6,118,-1,0,2586,2587,5,70,0,0,2587,2588,5,30,0,0,2588, - 2589,3,32,16,0,2589,2590,5,31,0,0,2590,2591,6,118,-1,0,2591,2593,1,0,0, - 0,2592,2550,1,0,0,0,2592,2552,1,0,0,0,2592,2554,1,0,0,0,2592,2556,1,0, - 0,0,2592,2558,1,0,0,0,2592,2560,1,0,0,0,2592,2562,1,0,0,0,2592,2564,1, - 0,0,0,2592,2566,1,0,0,0,2592,2568,1,0,0,0,2592,2570,1,0,0,0,2592,2572, - 1,0,0,0,2592,2574,1,0,0,0,2592,2576,1,0,0,0,2592,2578,1,0,0,0,2592,2580, - 1,0,0,0,2592,2582,1,0,0,0,2592,2584,1,0,0,0,2592,2586,1,0,0,0,2593,237, - 1,0,0,0,2594,2595,5,147,0,0,2595,2604,5,30,0,0,2596,2597,3,6,3,0,2597, - 2602,6,119,-1,0,2598,2599,5,34,0,0,2599,2600,3,6,3,0,2600,2601,6,119,-1, - 0,2601,2603,1,0,0,0,2602,2598,1,0,0,0,2602,2603,1,0,0,0,2603,2605,1,0, - 0,0,2604,2596,1,0,0,0,2604,2605,1,0,0,0,2605,2611,1,0,0,0,2606,2607,3, - 240,120,0,2607,2608,6,119,-1,0,2608,2610,1,0,0,0,2609,2606,1,0,0,0,2610, - 2613,1,0,0,0,2611,2609,1,0,0,0,2611,2612,1,0,0,0,2612,2614,1,0,0,0,2613, - 2611,1,0,0,0,2614,2618,5,31,0,0,2615,2616,5,147,0,0,2616,2618,5,85,0,0, - 2617,2594,1,0,0,0,2617,2615,1,0,0,0,2618,239,1,0,0,0,2619,2620,5,148,0, - 0,2620,2662,6,120,-1,0,2621,2622,5,224,0,0,2622,2662,6,120,-1,0,2623,2624, - 5,57,0,0,2624,2662,6,120,-1,0,2625,2626,5,58,0,0,2626,2662,6,120,-1,0, - 2627,2628,5,149,0,0,2628,2662,6,120,-1,0,2629,2630,5,150,0,0,2630,2662, - 6,120,-1,0,2631,2632,5,248,0,0,2632,2662,6,120,-1,0,2633,2634,5,249,0, - 0,2634,2662,6,120,-1,0,2635,2636,5,250,0,0,2636,2662,6,120,-1,0,2637,2638, - 5,251,0,0,2638,2662,6,120,-1,0,2639,2640,5,151,0,0,2640,2641,5,75,0,0, - 2641,2642,5,152,0,0,2642,2662,6,120,-1,0,2643,2644,5,151,0,0,2644,2645, - 5,75,0,0,2645,2646,5,153,0,0,2646,2662,6,120,-1,0,2647,2648,5,154,0,0, - 2648,2649,5,75,0,0,2649,2650,5,152,0,0,2650,2662,6,120,-1,0,2651,2652, - 5,154,0,0,2652,2653,5,75,0,0,2653,2654,5,153,0,0,2654,2662,6,120,-1,0, - 2655,2656,5,70,0,0,2656,2657,5,30,0,0,2657,2658,3,32,16,0,2658,2659,5, - 31,0,0,2659,2660,6,120,-1,0,2660,2662,1,0,0,0,2661,2619,1,0,0,0,2661,2621, - 1,0,0,0,2661,2623,1,0,0,0,2661,2625,1,0,0,0,2661,2627,1,0,0,0,2661,2629, - 1,0,0,0,2661,2631,1,0,0,0,2661,2633,1,0,0,0,2661,2635,1,0,0,0,2661,2637, - 1,0,0,0,2661,2639,1,0,0,0,2661,2643,1,0,0,0,2661,2647,1,0,0,0,2661,2651, - 1,0,0,0,2661,2655,1,0,0,0,2662,241,1,0,0,0,2663,2664,5,116,0,0,2664,2671, - 6,121,-1,0,2665,2666,5,155,0,0,2666,2671,6,121,-1,0,2667,2668,3,2,1,0, - 2668,2669,6,121,-1,0,2669,2671,1,0,0,0,2670,2663,1,0,0,0,2670,2665,1,0, - 0,0,2670,2667,1,0,0,0,2671,243,1,0,0,0,2672,2673,5,1,0,0,2673,2711,6,122, - -1,0,2674,2675,5,2,0,0,2675,2711,6,122,-1,0,2676,2677,5,156,0,0,2677,2711, - 6,122,-1,0,2678,2679,5,3,0,0,2679,2711,6,122,-1,0,2680,2681,5,4,0,0,2681, - 2711,6,122,-1,0,2682,2683,5,247,0,0,2683,2711,6,122,-1,0,2684,2685,5,5, - 0,0,2685,2711,6,122,-1,0,2686,2687,5,6,0,0,2687,2711,6,122,-1,0,2688,2689, - 5,7,0,0,2689,2711,6,122,-1,0,2690,2691,5,8,0,0,2691,2711,6,122,-1,0,2692, - 2693,5,9,0,0,2693,2711,6,122,-1,0,2694,2695,5,10,0,0,2695,2711,6,122,-1, - 0,2696,2697,5,11,0,0,2697,2711,6,122,-1,0,2698,2699,5,12,0,0,2699,2711, - 6,122,-1,0,2700,2701,5,13,0,0,2701,2711,6,122,-1,0,2702,2703,5,14,0,0, - 2703,2711,6,122,-1,0,2704,2705,5,70,0,0,2705,2706,5,30,0,0,2706,2707,3, - 32,16,0,2707,2708,5,31,0,0,2708,2709,6,122,-1,0,2709,2711,1,0,0,0,2710, - 2672,1,0,0,0,2710,2674,1,0,0,0,2710,2676,1,0,0,0,2710,2678,1,0,0,0,2710, - 2680,1,0,0,0,2710,2682,1,0,0,0,2710,2684,1,0,0,0,2710,2686,1,0,0,0,2710, - 2688,1,0,0,0,2710,2690,1,0,0,0,2710,2692,1,0,0,0,2710,2694,1,0,0,0,2710, - 2696,1,0,0,0,2710,2698,1,0,0,0,2710,2700,1,0,0,0,2710,2702,1,0,0,0,2710, - 2704,1,0,0,0,2711,245,1,0,0,0,2712,2714,3,248,124,0,2713,2712,1,0,0,0, - 2714,2717,1,0,0,0,2715,2713,1,0,0,0,2715,2716,1,0,0,0,2716,247,1,0,0,0, - 2717,2715,1,0,0,0,2718,2756,3,100,50,0,2719,2720,5,296,0,0,2720,2721,3, - 32,16,0,2721,2722,6,124,-1,0,2722,2756,1,0,0,0,2723,2756,3,266,133,0,2724, - 2725,5,297,0,0,2725,2726,3,32,16,0,2726,2727,6,124,-1,0,2727,2756,1,0, - 0,0,2728,2729,5,298,0,0,2729,2756,6,124,-1,0,2730,2731,5,299,0,0,2731, - 2756,6,124,-1,0,2732,2756,3,260,130,0,2733,2756,3,264,132,0,2734,2756, - 3,250,125,0,2735,2736,3,284,142,0,2736,2737,6,124,-1,0,2737,2756,1,0,0, - 0,2738,2739,3,152,76,0,2739,2740,6,124,-1,0,2740,2756,1,0,0,0,2741,2742, - 3,88,44,0,2742,2743,6,124,-1,0,2743,2756,1,0,0,0,2744,2745,3,26,13,0,2745, - 2746,6,124,-1,0,2746,2756,1,0,0,0,2747,2748,3,262,131,0,2748,2749,6,124, - -1,0,2749,2756,1,0,0,0,2750,2756,3,40,20,0,2751,2756,3,252,126,0,2752, - 2756,3,254,127,0,2753,2756,3,256,128,0,2754,2756,3,258,129,0,2755,2718, - 1,0,0,0,2755,2719,1,0,0,0,2755,2723,1,0,0,0,2755,2724,1,0,0,0,2755,2728, - 1,0,0,0,2755,2730,1,0,0,0,2755,2732,1,0,0,0,2755,2733,1,0,0,0,2755,2734, - 1,0,0,0,2755,2735,1,0,0,0,2755,2738,1,0,0,0,2755,2741,1,0,0,0,2755,2744, - 1,0,0,0,2755,2747,1,0,0,0,2755,2750,1,0,0,0,2755,2751,1,0,0,0,2755,2752, - 1,0,0,0,2755,2753,1,0,0,0,2755,2754,1,0,0,0,2756,249,1,0,0,0,2757,2759, - 5,300,0,0,2758,2760,5,157,0,0,2759,2758,1,0,0,0,2759,2760,1,0,0,0,2760, - 2761,1,0,0,0,2761,2762,3,112,56,0,2762,251,1,0,0,0,2763,2764,5,301,0,0, - 2764,2765,5,42,0,0,2765,2766,3,32,16,0,2766,2769,5,43,0,0,2767,2768,5, - 34,0,0,2768,2770,3,0,0,0,2769,2767,1,0,0,0,2769,2770,1,0,0,0,2770,253, - 1,0,0,0,2771,2772,5,303,0,0,2772,2773,3,32,16,0,2773,2774,5,75,0,0,2774, - 2775,3,32,16,0,2775,255,1,0,0,0,2776,2777,5,302,0,0,2777,2778,3,124,62, - 0,2778,2779,5,176,0,0,2779,2780,3,242,121,0,2780,2792,1,0,0,0,2781,2782, - 5,302,0,0,2782,2783,5,226,0,0,2783,2784,3,170,85,0,2784,2785,3,138,69, - 0,2785,2786,3,124,62,0,2786,2787,5,176,0,0,2787,2788,3,242,121,0,2788, - 2789,3,194,97,0,2789,2790,3,112,56,0,2790,2792,1,0,0,0,2791,2776,1,0,0, - 0,2791,2781,1,0,0,0,2792,257,1,0,0,0,2793,2794,5,255,0,0,2794,2795,5,196, - 0,0,2795,2796,5,42,0,0,2796,2797,3,32,16,0,2797,2803,5,43,0,0,2798,2799, - 3,330,165,0,2799,2800,6,129,-1,0,2800,2802,1,0,0,0,2801,2798,1,0,0,0,2802, - 2805,1,0,0,0,2803,2801,1,0,0,0,2803,2804,1,0,0,0,2804,2859,1,0,0,0,2805, - 2803,1,0,0,0,2806,2807,5,255,0,0,2807,2808,5,196,0,0,2808,2814,3,2,1,0, - 2809,2810,3,330,165,0,2810,2811,6,129,-1,0,2811,2813,1,0,0,0,2812,2809, - 1,0,0,0,2813,2816,1,0,0,0,2814,2812,1,0,0,0,2814,2815,1,0,0,0,2815,2859, - 1,0,0,0,2816,2814,1,0,0,0,2817,2818,5,255,0,0,2818,2819,5,256,0,0,2819, - 2820,5,42,0,0,2820,2821,3,32,16,0,2821,2822,5,43,0,0,2822,2823,5,28,0, - 0,2823,2829,3,124,62,0,2824,2825,3,330,165,0,2825,2826,6,129,-1,0,2826, - 2828,1,0,0,0,2827,2824,1,0,0,0,2828,2831,1,0,0,0,2829,2827,1,0,0,0,2829, - 2830,1,0,0,0,2830,2859,1,0,0,0,2831,2829,1,0,0,0,2832,2833,5,255,0,0,2833, - 2834,5,256,0,0,2834,2835,3,2,1,0,2835,2836,5,28,0,0,2836,2842,3,124,62, - 0,2837,2838,3,330,165,0,2838,2839,6,129,-1,0,2839,2841,1,0,0,0,2840,2837, - 1,0,0,0,2841,2844,1,0,0,0,2842,2840,1,0,0,0,2842,2843,1,0,0,0,2843,2859, - 1,0,0,0,2844,2842,1,0,0,0,2845,2846,5,255,0,0,2846,2847,5,42,0,0,2847, - 2848,3,32,16,0,2848,2849,5,43,0,0,2849,2855,3,206,103,0,2850,2851,3,330, - 165,0,2851,2852,6,129,-1,0,2852,2854,1,0,0,0,2853,2850,1,0,0,0,2854,2857, - 1,0,0,0,2855,2853,1,0,0,0,2855,2856,1,0,0,0,2856,2859,1,0,0,0,2857,2855, - 1,0,0,0,2858,2793,1,0,0,0,2858,2806,1,0,0,0,2858,2817,1,0,0,0,2858,2832, - 1,0,0,0,2858,2845,1,0,0,0,2859,259,1,0,0,0,2860,2861,3,0,0,0,2861,2862, - 5,75,0,0,2862,2863,6,130,-1,0,2863,261,1,0,0,0,2864,2865,3,44,22,0,2865, - 2866,6,131,-1,0,2866,2871,1,0,0,0,2867,2868,3,46,23,0,2868,2869,6,131, - -1,0,2869,2871,1,0,0,0,2870,2864,1,0,0,0,2870,2867,1,0,0,0,2871,263,1, - 0,0,0,2872,2873,5,17,0,0,2873,2874,3,246,123,0,2874,2875,5,18,0,0,2875, - 265,1,0,0,0,2876,2877,3,270,135,0,2877,2878,3,268,134,0,2878,267,1,0,0, - 0,2879,2880,3,272,136,0,2880,2881,6,134,-1,0,2881,2883,1,0,0,0,2882,2879, - 1,0,0,0,2883,2884,1,0,0,0,2884,2882,1,0,0,0,2884,2885,1,0,0,0,2885,269, - 1,0,0,0,2886,2887,5,158,0,0,2887,2888,3,264,132,0,2888,2889,6,135,-1,0, - 2889,2903,1,0,0,0,2890,2891,5,158,0,0,2891,2892,3,0,0,0,2892,2893,5,159, - 0,0,2893,2894,3,0,0,0,2894,2895,6,135,-1,0,2895,2903,1,0,0,0,2896,2897, - 5,158,0,0,2897,2898,3,32,16,0,2898,2899,5,159,0,0,2899,2900,3,32,16,0, - 2900,2901,6,135,-1,0,2901,2903,1,0,0,0,2902,2886,1,0,0,0,2902,2890,1,0, - 0,0,2902,2896,1,0,0,0,2903,271,1,0,0,0,2904,2905,3,276,138,0,2905,2906, - 3,282,141,0,2906,2907,6,136,-1,0,2907,2921,1,0,0,0,2908,2909,3,274,137, - 0,2909,2910,3,282,141,0,2910,2911,6,136,-1,0,2911,2921,1,0,0,0,2912,2913, - 3,278,139,0,2913,2914,3,282,141,0,2914,2915,6,136,-1,0,2915,2921,1,0,0, - 0,2916,2917,3,280,140,0,2917,2918,3,282,141,0,2918,2919,6,136,-1,0,2919, - 2921,1,0,0,0,2920,2904,1,0,0,0,2920,2908,1,0,0,0,2920,2912,1,0,0,0,2920, - 2916,1,0,0,0,2921,273,1,0,0,0,2922,2923,5,160,0,0,2923,2924,3,264,132, - 0,2924,2925,6,137,-1,0,2925,2935,1,0,0,0,2926,2927,5,160,0,0,2927,2928, - 3,0,0,0,2928,2929,6,137,-1,0,2929,2935,1,0,0,0,2930,2931,5,160,0,0,2931, - 2932,3,32,16,0,2932,2933,6,137,-1,0,2933,2935,1,0,0,0,2934,2922,1,0,0, - 0,2934,2926,1,0,0,0,2934,2930,1,0,0,0,2935,275,1,0,0,0,2936,2937,5,161, - 0,0,2937,2938,3,124,62,0,2938,277,1,0,0,0,2939,2940,5,162,0,0,2940,279, - 1,0,0,0,2941,2942,5,163,0,0,2942,281,1,0,0,0,2943,2944,3,264,132,0,2944, - 2945,6,141,-1,0,2945,2959,1,0,0,0,2946,2947,5,164,0,0,2947,2948,3,0,0, - 0,2948,2949,5,159,0,0,2949,2950,3,0,0,0,2950,2951,6,141,-1,0,2951,2959, - 1,0,0,0,2952,2953,5,164,0,0,2953,2954,3,32,16,0,2954,2955,5,159,0,0,2955, - 2956,3,32,16,0,2956,2957,6,141,-1,0,2957,2959,1,0,0,0,2958,2943,1,0,0, - 0,2958,2946,1,0,0,0,2958,2952,1,0,0,0,2959,283,1,0,0,0,2960,2961,3,286, - 143,0,2961,2962,3,290,145,0,2962,285,1,0,0,0,2963,2964,5,165,0,0,2964, - 2965,3,288,144,0,2965,2966,3,0,0,0,2966,2967,5,36,0,0,2967,2968,6,143, - -1,0,2968,2974,1,0,0,0,2969,2970,5,165,0,0,2970,2971,3,288,144,0,2971, - 2972,6,143,-1,0,2972,2974,1,0,0,0,2973,2963,1,0,0,0,2973,2969,1,0,0,0, - 2974,287,1,0,0,0,2975,2981,1,0,0,0,2976,2977,5,166,0,0,2977,2981,6,144, - -1,0,2978,2979,5,2,0,0,2979,2981,6,144,-1,0,2980,2975,1,0,0,0,2980,2976, - 1,0,0,0,2980,2978,1,0,0,0,2981,289,1,0,0,0,2982,2983,5,17,0,0,2983,2984, - 3,292,146,0,2984,2985,5,18,0,0,2985,2992,1,0,0,0,2986,2988,3,296,148,0, - 2987,2986,1,0,0,0,2988,2989,1,0,0,0,2989,2987,1,0,0,0,2989,2990,1,0,0, - 0,2990,2992,1,0,0,0,2991,2982,1,0,0,0,2991,2987,1,0,0,0,2992,291,1,0,0, - 0,2993,2994,3,296,148,0,2994,2995,5,28,0,0,2995,2997,1,0,0,0,2996,2993, - 1,0,0,0,2997,3000,1,0,0,0,2998,2996,1,0,0,0,2998,2999,1,0,0,0,2999,3001, - 1,0,0,0,3000,2998,1,0,0,0,3001,3002,3,296,148,0,3002,293,1,0,0,0,3003, - 3010,1,0,0,0,3004,3005,5,42,0,0,3005,3006,3,32,16,0,3006,3007,5,43,0,0, - 3007,3008,6,147,-1,0,3008,3010,1,0,0,0,3009,3003,1,0,0,0,3009,3004,1,0, - 0,0,3010,295,1,0,0,0,3011,3012,5,181,0,0,3012,3013,5,262,0,0,3013,3014, - 5,30,0,0,3014,3015,3,6,3,0,3015,3016,5,31,0,0,3016,3017,6,148,-1,0,3017, - 3060,1,0,0,0,3018,3019,5,260,0,0,3019,3020,5,30,0,0,3020,3021,3,0,0,0, - 3021,3022,5,31,0,0,3022,3023,6,148,-1,0,3023,3060,1,0,0,0,3024,3025,5, - 260,0,0,3025,3026,3,0,0,0,3026,3027,6,148,-1,0,3027,3060,1,0,0,0,3028, - 3029,5,84,0,0,3029,3030,5,30,0,0,3030,3031,3,300,150,0,3031,3032,5,31, - 0,0,3032,3033,6,148,-1,0,3033,3060,1,0,0,0,3034,3035,7,10,0,0,3035,3036, - 5,30,0,0,3036,3037,3,36,18,0,3037,3038,5,31,0,0,3038,3039,3,294,147,0, - 3039,3040,6,148,-1,0,3040,3060,1,0,0,0,3041,3042,5,187,0,0,3042,3043,5, - 30,0,0,3043,3044,3,34,17,0,3044,3045,5,31,0,0,3045,3046,3,294,147,0,3046, - 3047,6,148,-1,0,3047,3060,1,0,0,0,3048,3049,7,11,0,0,3049,3050,5,30,0, - 0,3050,3051,3,32,16,0,3051,3052,5,31,0,0,3052,3053,3,294,147,0,3053,3054, - 6,148,-1,0,3054,3060,1,0,0,0,3055,3056,7,12,0,0,3056,3057,3,294,147,0, - 3057,3058,6,148,-1,0,3058,3060,1,0,0,0,3059,3011,1,0,0,0,3059,3018,1,0, - 0,0,3059,3024,1,0,0,0,3059,3028,1,0,0,0,3059,3034,1,0,0,0,3059,3041,1, - 0,0,0,3059,3048,1,0,0,0,3059,3055,1,0,0,0,3060,297,1,0,0,0,3061,3062,5, - 188,0,0,3062,3063,5,30,0,0,3063,3064,3,36,18,0,3064,3065,5,31,0,0,3065, - 3066,6,149,-1,0,3066,3152,1,0,0,0,3067,3068,5,189,0,0,3068,3069,5,30,0, - 0,3069,3070,3,36,18,0,3070,3071,5,31,0,0,3071,3072,6,149,-1,0,3072,3152, - 1,0,0,0,3073,3074,5,188,0,0,3074,3075,5,30,0,0,3075,3076,3,32,16,0,3076, - 3077,5,31,0,0,3077,3078,6,149,-1,0,3078,3152,1,0,0,0,3079,3080,5,189,0, - 0,3080,3081,5,30,0,0,3081,3082,3,34,17,0,3082,3083,5,31,0,0,3083,3084, - 6,149,-1,0,3084,3152,1,0,0,0,3085,3086,5,187,0,0,3086,3087,5,30,0,0,3087, - 3088,3,34,17,0,3088,3089,5,31,0,0,3089,3090,6,149,-1,0,3090,3152,1,0,0, - 0,3091,3092,5,186,0,0,3092,3093,5,30,0,0,3093,3094,3,32,16,0,3094,3095, - 5,31,0,0,3095,3096,6,149,-1,0,3096,3152,1,0,0,0,3097,3098,5,185,0,0,3098, - 3099,5,30,0,0,3099,3100,3,32,16,0,3100,3101,5,31,0,0,3101,3102,6,149,-1, - 0,3102,3152,1,0,0,0,3103,3104,5,184,0,0,3104,3105,5,30,0,0,3105,3106,3, - 32,16,0,3106,3107,5,31,0,0,3107,3108,6,149,-1,0,3108,3152,1,0,0,0,3109, - 3110,5,193,0,0,3110,3111,5,30,0,0,3111,3112,3,34,17,0,3112,3113,5,31,0, - 0,3113,3114,6,149,-1,0,3114,3152,1,0,0,0,3115,3116,5,192,0,0,3116,3117, - 5,30,0,0,3117,3118,3,32,16,0,3118,3119,5,31,0,0,3119,3120,6,149,-1,0,3120, - 3152,1,0,0,0,3121,3122,5,191,0,0,3122,3123,5,30,0,0,3123,3124,3,32,16, - 0,3124,3125,5,31,0,0,3125,3126,6,149,-1,0,3126,3152,1,0,0,0,3127,3128, - 5,190,0,0,3128,3129,5,30,0,0,3129,3130,3,32,16,0,3130,3131,5,31,0,0,3131, - 3132,6,149,-1,0,3132,3152,1,0,0,0,3133,3134,5,181,0,0,3134,3135,5,30,0, - 0,3135,3136,3,32,16,0,3136,3137,5,31,0,0,3137,3138,6,149,-1,0,3138,3152, - 1,0,0,0,3139,3140,5,183,0,0,3140,3141,5,30,0,0,3141,3142,3,162,81,0,3142, - 3143,5,31,0,0,3143,3144,6,149,-1,0,3144,3152,1,0,0,0,3145,3146,5,84,0, - 0,3146,3147,5,30,0,0,3147,3148,3,300,150,0,3148,3149,5,31,0,0,3149,3150, - 6,149,-1,0,3150,3152,1,0,0,0,3151,3061,1,0,0,0,3151,3067,1,0,0,0,3151, - 3073,1,0,0,0,3151,3079,1,0,0,0,3151,3085,1,0,0,0,3151,3091,1,0,0,0,3151, - 3097,1,0,0,0,3151,3103,1,0,0,0,3151,3109,1,0,0,0,3151,3115,1,0,0,0,3151, - 3121,1,0,0,0,3151,3127,1,0,0,0,3151,3133,1,0,0,0,3151,3139,1,0,0,0,3151, - 3145,1,0,0,0,3152,299,1,0,0,0,3153,3154,3,302,151,0,3154,3155,6,150,-1, - 0,3155,3157,1,0,0,0,3156,3153,1,0,0,0,3157,3160,1,0,0,0,3158,3156,1,0, - 0,0,3158,3159,1,0,0,0,3159,301,1,0,0,0,3160,3158,1,0,0,0,3161,3162,7,13, - 0,0,3162,303,1,0,0,0,3163,3164,3,298,149,0,3164,3165,6,152,-1,0,3165,3172, - 1,0,0,0,3166,3167,3,6,3,0,3167,3168,6,152,-1,0,3168,3172,1,0,0,0,3169, - 3170,5,179,0,0,3170,3172,6,152,-1,0,3171,3163,1,0,0,0,3171,3166,1,0,0, - 0,3171,3169,1,0,0,0,3172,305,1,0,0,0,3173,3174,3,298,149,0,3174,3175,6, - 153,-1,0,3175,3345,1,0,0,0,3176,3177,5,182,0,0,3177,3178,5,30,0,0,3178, - 3179,5,179,0,0,3179,3180,5,31,0,0,3180,3345,6,153,-1,0,3181,3182,5,182, - 0,0,3182,3183,5,30,0,0,3183,3184,5,264,0,0,3184,3185,5,31,0,0,3185,3345, - 6,153,-1,0,3186,3187,5,196,0,0,3187,3188,5,30,0,0,3188,3189,5,39,0,0,3189, - 3190,5,264,0,0,3190,3191,5,31,0,0,3191,3345,6,153,-1,0,3192,3193,5,196, - 0,0,3193,3194,5,30,0,0,3194,3195,3,116,58,0,3195,3196,5,31,0,0,3196,3197, - 6,153,-1,0,3197,3345,1,0,0,0,3198,3199,5,196,0,0,3199,3200,5,30,0,0,3200, - 3201,5,179,0,0,3201,3202,5,31,0,0,3202,3345,6,153,-1,0,3203,3204,5,197, - 0,0,3204,3205,5,30,0,0,3205,3206,3,306,153,0,3206,3207,5,31,0,0,3207,3208, - 6,153,-1,0,3208,3345,1,0,0,0,3209,3210,5,188,0,0,3210,3211,5,42,0,0,3211, - 3212,3,32,16,0,3212,3213,5,43,0,0,3213,3214,5,30,0,0,3214,3215,3,308,154, - 0,3215,3216,5,31,0,0,3216,3217,6,153,-1,0,3217,3345,1,0,0,0,3218,3219, - 5,189,0,0,3219,3220,5,42,0,0,3220,3221,3,32,16,0,3221,3222,5,43,0,0,3222, - 3223,5,30,0,0,3223,3224,3,310,155,0,3224,3225,5,31,0,0,3225,3226,6,153, - -1,0,3226,3345,1,0,0,0,3227,3228,5,187,0,0,3228,3229,5,42,0,0,3229,3230, - 3,32,16,0,3230,3231,5,43,0,0,3231,3232,5,30,0,0,3232,3233,3,312,156,0, - 3233,3234,5,31,0,0,3234,3235,6,153,-1,0,3235,3345,1,0,0,0,3236,3237,5, - 186,0,0,3237,3238,5,42,0,0,3238,3239,3,32,16,0,3239,3240,5,43,0,0,3240, - 3241,5,30,0,0,3241,3242,3,314,157,0,3242,3243,5,31,0,0,3243,3244,6,153, - -1,0,3244,3345,1,0,0,0,3245,3246,5,185,0,0,3246,3247,5,42,0,0,3247,3248, - 3,32,16,0,3248,3249,5,43,0,0,3249,3250,5,30,0,0,3250,3251,3,316,158,0, - 3251,3252,5,31,0,0,3252,3253,6,153,-1,0,3253,3345,1,0,0,0,3254,3255,5, - 184,0,0,3255,3256,5,42,0,0,3256,3257,3,32,16,0,3257,3258,5,43,0,0,3258, - 3259,5,30,0,0,3259,3260,3,318,159,0,3260,3261,5,31,0,0,3261,3262,6,153, - -1,0,3262,3345,1,0,0,0,3263,3264,5,193,0,0,3264,3265,5,42,0,0,3265,3266, - 3,32,16,0,3266,3267,5,43,0,0,3267,3268,5,30,0,0,3268,3269,3,312,156,0, - 3269,3270,5,31,0,0,3270,3271,6,153,-1,0,3271,3345,1,0,0,0,3272,3273,5, - 192,0,0,3273,3274,5,42,0,0,3274,3275,3,32,16,0,3275,3276,5,43,0,0,3276, - 3277,5,30,0,0,3277,3278,3,314,157,0,3278,3279,5,31,0,0,3279,3280,6,153, - -1,0,3280,3345,1,0,0,0,3281,3282,5,191,0,0,3282,3283,5,42,0,0,3283,3284, - 3,32,16,0,3284,3285,5,43,0,0,3285,3286,5,30,0,0,3286,3287,3,316,158,0, - 3287,3288,5,31,0,0,3288,3289,6,153,-1,0,3289,3345,1,0,0,0,3290,3291,5, - 190,0,0,3291,3292,5,42,0,0,3292,3293,3,32,16,0,3293,3294,5,43,0,0,3294, - 3295,5,30,0,0,3295,3296,3,318,159,0,3296,3297,5,31,0,0,3297,3298,6,153, - -1,0,3298,3345,1,0,0,0,3299,3300,5,181,0,0,3300,3301,5,42,0,0,3301,3302, - 3,32,16,0,3302,3303,5,43,0,0,3303,3304,5,30,0,0,3304,3305,3,316,158,0, - 3305,3306,5,31,0,0,3306,3307,6,153,-1,0,3307,3345,1,0,0,0,3308,3309,5, - 183,0,0,3309,3310,5,42,0,0,3310,3311,3,32,16,0,3311,3312,5,43,0,0,3312, - 3313,5,30,0,0,3313,3314,3,320,160,0,3314,3315,5,31,0,0,3315,3316,6,153, - -1,0,3316,3345,1,0,0,0,3317,3318,5,182,0,0,3318,3319,5,42,0,0,3319,3320, - 3,32,16,0,3320,3321,5,43,0,0,3321,3322,5,30,0,0,3322,3323,3,322,161,0, - 3323,3324,5,31,0,0,3324,3325,6,153,-1,0,3325,3345,1,0,0,0,3326,3327,5, - 196,0,0,3327,3328,5,42,0,0,3328,3329,3,32,16,0,3329,3330,5,43,0,0,3330, - 3331,5,30,0,0,3331,3332,3,324,162,0,3332,3333,5,31,0,0,3333,3334,6,153, - -1,0,3334,3345,1,0,0,0,3335,3336,5,197,0,0,3336,3337,5,42,0,0,3337,3338, - 3,32,16,0,3338,3339,5,43,0,0,3339,3340,5,30,0,0,3340,3341,3,328,164,0, - 3341,3342,5,31,0,0,3342,3343,6,153,-1,0,3343,3345,1,0,0,0,3344,3173,1, - 0,0,0,3344,3176,1,0,0,0,3344,3181,1,0,0,0,3344,3186,1,0,0,0,3344,3192, - 1,0,0,0,3344,3198,1,0,0,0,3344,3203,1,0,0,0,3344,3209,1,0,0,0,3344,3218, - 1,0,0,0,3344,3227,1,0,0,0,3344,3236,1,0,0,0,3344,3245,1,0,0,0,3344,3254, - 1,0,0,0,3344,3263,1,0,0,0,3344,3272,1,0,0,0,3344,3281,1,0,0,0,3344,3290, - 1,0,0,0,3344,3299,1,0,0,0,3344,3308,1,0,0,0,3344,3317,1,0,0,0,3344,3326, - 1,0,0,0,3344,3335,1,0,0,0,3345,307,1,0,0,0,3346,3347,3,36,18,0,3347,3348, - 6,154,-1,0,3348,3353,1,0,0,0,3349,3350,3,32,16,0,3350,3351,6,154,-1,0, - 3351,3353,1,0,0,0,3352,3346,1,0,0,0,3352,3349,1,0,0,0,3353,3356,1,0,0, - 0,3354,3352,1,0,0,0,3354,3355,1,0,0,0,3355,309,1,0,0,0,3356,3354,1,0,0, - 0,3357,3358,3,36,18,0,3358,3359,6,155,-1,0,3359,3364,1,0,0,0,3360,3361, - 3,34,17,0,3361,3362,6,155,-1,0,3362,3364,1,0,0,0,3363,3357,1,0,0,0,3363, - 3360,1,0,0,0,3364,3367,1,0,0,0,3365,3363,1,0,0,0,3365,3366,1,0,0,0,3366, - 311,1,0,0,0,3367,3365,1,0,0,0,3368,3369,3,34,17,0,3369,3370,6,156,-1,0, - 3370,3372,1,0,0,0,3371,3368,1,0,0,0,3372,3375,1,0,0,0,3373,3371,1,0,0, - 0,3373,3374,1,0,0,0,3374,313,1,0,0,0,3375,3373,1,0,0,0,3376,3377,3,32, - 16,0,3377,3378,6,157,-1,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,315,1,0,0,0,3383,3381, - 1,0,0,0,3384,3385,3,32,16,0,3385,3386,6,158,-1,0,3386,3388,1,0,0,0,3387, - 3384,1,0,0,0,3388,3391,1,0,0,0,3389,3387,1,0,0,0,3389,3390,1,0,0,0,3390, - 317,1,0,0,0,3391,3389,1,0,0,0,3392,3393,3,32,16,0,3393,3394,6,159,-1,0, - 3394,3396,1,0,0,0,3395,3392,1,0,0,0,3396,3399,1,0,0,0,3397,3395,1,0,0, - 0,3397,3398,1,0,0,0,3398,319,1,0,0,0,3399,3397,1,0,0,0,3400,3401,3,162, - 81,0,3401,3402,6,160,-1,0,3402,3404,1,0,0,0,3403,3400,1,0,0,0,3404,3407, - 1,0,0,0,3405,3403,1,0,0,0,3405,3406,1,0,0,0,3406,321,1,0,0,0,3407,3405, - 1,0,0,0,3408,3409,5,179,0,0,3409,3413,6,161,-1,0,3410,3411,5,264,0,0,3411, - 3413,6,161,-1,0,3412,3408,1,0,0,0,3412,3410,1,0,0,0,3413,3416,1,0,0,0, - 3414,3412,1,0,0,0,3414,3415,1,0,0,0,3415,323,1,0,0,0,3416,3414,1,0,0,0, - 3417,3418,3,326,163,0,3418,3419,6,162,-1,0,3419,3421,1,0,0,0,3420,3417, - 1,0,0,0,3421,3424,1,0,0,0,3422,3420,1,0,0,0,3422,3423,1,0,0,0,3423,325, - 1,0,0,0,3424,3422,1,0,0,0,3425,3426,5,179,0,0,3426,3434,6,163,-1,0,3427, - 3428,5,39,0,0,3428,3429,5,264,0,0,3429,3434,6,163,-1,0,3430,3431,3,116, - 58,0,3431,3432,6,163,-1,0,3432,3434,1,0,0,0,3433,3425,1,0,0,0,3433,3427, - 1,0,0,0,3433,3430,1,0,0,0,3434,327,1,0,0,0,3435,3436,3,306,153,0,3436, - 3437,6,164,-1,0,3437,3439,1,0,0,0,3438,3435,1,0,0,0,3439,3442,1,0,0,0, - 3440,3438,1,0,0,0,3440,3441,1,0,0,0,3441,329,1,0,0,0,3442,3440,1,0,0,0, - 3443,3444,3,44,22,0,3444,3445,6,165,-1,0,3445,3453,1,0,0,0,3446,3447,3, - 46,23,0,3447,3448,6,165,-1,0,3448,3453,1,0,0,0,3449,3450,3,2,1,0,3450, - 3451,6,165,-1,0,3451,3453,1,0,0,0,3452,3443,1,0,0,0,3452,3446,1,0,0,0, - 3452,3449,1,0,0,0,3453,331,1,0,0,0,3454,3455,7,14,0,0,3455,3456,5,36,0, - 0,3456,3457,5,30,0,0,3457,3458,3,300,150,0,3458,3459,5,31,0,0,3459,3480, - 1,0,0,0,3460,3461,5,169,0,0,3461,3462,3,38,19,0,3462,3463,5,75,0,0,3463, - 3464,3,38,19,0,3464,3465,5,75,0,0,3465,3466,3,38,19,0,3466,3467,5,75,0, - 0,3467,3468,3,38,19,0,3468,3480,1,0,0,0,3469,3470,5,170,0,0,3470,3480, - 3,6,3,0,3471,3472,5,170,0,0,3472,3473,5,36,0,0,3473,3474,5,30,0,0,3474, - 3475,3,300,150,0,3475,3476,5,31,0,0,3476,3480,1,0,0,0,3477,3480,3,330, - 165,0,3478,3480,3,40,20,0,3479,3454,1,0,0,0,3479,3460,1,0,0,0,3479,3469, - 1,0,0,0,3479,3471,1,0,0,0,3479,3477,1,0,0,0,3479,3478,1,0,0,0,3480,333, - 1,0,0,0,3481,3482,3,336,168,0,3482,3483,5,17,0,0,3483,3484,3,338,169,0, - 3484,3485,5,18,0,0,3485,335,1,0,0,0,3486,3487,5,25,0,0,3487,3488,5,40, - 0,0,3488,3489,3,98,49,0,3489,3490,3,2,1,0,3490,3499,1,0,0,0,3491,3492, - 5,25,0,0,3492,3493,5,40,0,0,3493,3494,3,98,49,0,3494,3495,3,2,1,0,3495, - 3496,5,34,0,0,3496,3497,3,2,1,0,3497,3499,1,0,0,0,3498,3486,1,0,0,0,3498, - 3491,1,0,0,0,3499,337,1,0,0,0,3500,3502,3,340,170,0,3501,3500,1,0,0,0, - 3502,3505,1,0,0,0,3503,3501,1,0,0,0,3503,3504,1,0,0,0,3504,339,1,0,0,0, - 3505,3503,1,0,0,0,3506,3507,5,180,0,0,3507,3508,5,36,0,0,3508,3509,5,30, - 0,0,3509,3510,3,300,150,0,3510,3511,5,31,0,0,3511,3521,1,0,0,0,3512,3521, - 3,332,166,0,3513,3514,5,171,0,0,3514,3515,5,36,0,0,3515,3516,5,30,0,0, - 3516,3517,3,300,150,0,3517,3518,5,31,0,0,3518,3521,1,0,0,0,3519,3521,5, - 55,0,0,3520,3506,1,0,0,0,3520,3512,1,0,0,0,3520,3513,1,0,0,0,3520,3519, - 1,0,0,0,3521,341,1,0,0,0,3522,3523,3,344,172,0,3523,3524,5,17,0,0,3524, - 3525,3,350,175,0,3525,3526,5,18,0,0,3526,343,1,0,0,0,3527,3528,5,50,0, - 0,3528,3532,5,40,0,0,3529,3531,3,348,174,0,3530,3529,1,0,0,0,3531,3534, - 1,0,0,0,3532,3530,1,0,0,0,3532,3533,1,0,0,0,3533,3535,1,0,0,0,3534,3532, - 1,0,0,0,3535,3536,3,2,1,0,3536,345,1,0,0,0,3537,3541,5,301,0,0,3538,3540, - 3,348,174,0,3539,3538,1,0,0,0,3540,3543,1,0,0,0,3541,3539,1,0,0,0,3541, - 3542,1,0,0,0,3542,3544,1,0,0,0,3543,3541,1,0,0,0,3544,3545,3,2,1,0,3545, - 347,1,0,0,0,3546,3562,5,52,0,0,3547,3562,5,51,0,0,3548,3562,5,172,0,0, - 3549,3550,5,62,0,0,3550,3562,5,51,0,0,3551,3552,5,62,0,0,3552,3562,5,52, - 0,0,3553,3554,5,62,0,0,3554,3562,5,63,0,0,3555,3556,5,62,0,0,3556,3562, - 5,64,0,0,3557,3558,5,62,0,0,3558,3562,5,65,0,0,3559,3560,5,62,0,0,3560, - 3562,5,66,0,0,3561,3546,1,0,0,0,3561,3547,1,0,0,0,3561,3548,1,0,0,0,3561, - 3549,1,0,0,0,3561,3551,1,0,0,0,3561,3553,1,0,0,0,3561,3555,1,0,0,0,3561, - 3557,1,0,0,0,3561,3559,1,0,0,0,3562,349,1,0,0,0,3563,3565,3,352,176,0, - 3564,3563,1,0,0,0,3565,3568,1,0,0,0,3566,3564,1,0,0,0,3566,3567,1,0,0, - 0,3567,351,1,0,0,0,3568,3566,1,0,0,0,3569,3570,5,21,0,0,3570,3583,3,2, - 1,0,3571,3572,5,50,0,0,3572,3573,5,40,0,0,3573,3583,3,118,59,0,3574,3575, - 5,25,0,0,3575,3576,5,40,0,0,3576,3583,3,2,1,0,3577,3583,3,174,87,0,3578, - 3579,5,50,0,0,3579,3583,3,32,16,0,3580,3583,3,330,165,0,3581,3583,3,40, - 20,0,3582,3569,1,0,0,0,3582,3571,1,0,0,0,3582,3574,1,0,0,0,3582,3577,1, - 0,0,0,3582,3578,1,0,0,0,3582,3580,1,0,0,0,3582,3581,1,0,0,0,3583,353,1, - 0,0,0,3584,3585,3,356,178,0,3585,3586,5,17,0,0,3586,3587,3,360,180,0,3587, - 3588,5,18,0,0,3588,355,1,0,0,0,3589,3593,5,274,0,0,3590,3592,3,358,179, - 0,3591,3590,1,0,0,0,3592,3595,1,0,0,0,3593,3591,1,0,0,0,3593,3594,1,0, - 0,0,3594,3596,1,0,0,0,3595,3593,1,0,0,0,3596,3609,3,2,1,0,3597,3601,5, - 274,0,0,3598,3600,3,358,179,0,3599,3598,1,0,0,0,3600,3603,1,0,0,0,3601, - 3599,1,0,0,0,3601,3602,1,0,0,0,3602,3604,1,0,0,0,3603,3601,1,0,0,0,3604, - 3605,3,2,1,0,3605,3606,5,34,0,0,3606,3607,3,2,1,0,3607,3609,1,0,0,0,3608, - 3589,1,0,0,0,3608,3597,1,0,0,0,3609,357,1,0,0,0,3610,3611,7,15,0,0,3611, - 359,1,0,0,0,3612,3614,3,362,181,0,3613,3612,1,0,0,0,3614,3617,1,0,0,0, - 3615,3613,1,0,0,0,3615,3616,1,0,0,0,3616,361,1,0,0,0,3617,3615,1,0,0,0, - 3618,3619,5,21,0,0,3619,3620,3,2,1,0,3620,3621,5,44,0,0,3621,3622,3,32, - 16,0,3622,3629,1,0,0,0,3623,3624,5,25,0,0,3624,3625,5,40,0,0,3625,3629, - 3,2,1,0,3626,3629,3,330,165,0,3627,3629,3,40,20,0,3628,3618,1,0,0,0,3628, - 3623,1,0,0,0,3628,3626,1,0,0,0,3628,3627,1,0,0,0,3629,363,1,0,0,0,187, - 374,382,391,400,489,539,550,580,584,602,629,657,697,708,718,720,731,733, - 741,763,776,797,799,818,891,898,905,910,919,930,939,950,961,974,978,984, - 1000,1006,1012,1019,1047,1125,1127,1141,1147,1156,1158,1167,1181,1195, - 1203,1211,1215,1254,1262,1271,1279,1298,1308,1311,1335,1482,1492,1501, - 1504,1586,1595,1627,1687,1727,1743,1753,1783,1811,1820,1826,1843,1851, - 1909,1919,1937,1955,1974,1995,2014,2029,2037,2049,2069,2076,2081,2092, - 2104,2214,2226,2242,2256,2265,2278,2280,2323,2334,2341,2349,2357,2370, - 2376,2382,2387,2416,2424,2438,2443,2468,2477,2488,2492,2499,2519,2528, - 2530,2545,2592,2602,2604,2611,2617,2661,2670,2710,2715,2755,2759,2769, - 2791,2803,2814,2829,2842,2855,2858,2870,2884,2902,2920,2934,2958,2973, - 2980,2989,2991,2998,3009,3059,3151,3158,3171,3344,3352,3354,3363,3365, - 3373,3381,3389,3397,3405,3412,3414,3422,3433,3440,3452,3479,3498,3503, - 3520,3532,3541,3561,3566,3582,3593,3601,3608,3615,3628 + 1,149,1,149,1,149,3,149,3080,8,149,1,150,1,150,1,150,1,150,1,150,1,150, + 1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150, + 1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150, + 1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150, + 1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150, + 1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150, + 1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150, + 1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150,1,150, + 3,150,3172,8,150,1,151,1,151,1,151,5,151,3177,8,151,10,151,12,151,3180, + 9,151,1,152,1,152,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,3,153, + 3192,8,153,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154, + 1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154, + 1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154, + 1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154, + 1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154, + 1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154, + 1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154, + 1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154, + 1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154, + 1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154, + 1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154, + 1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154, + 1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154, + 1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154, + 1,154,1,154,1,154,1,154,1,154,3,154,3365,8,154,1,155,1,155,1,155,1,155, + 1,155,1,155,5,155,3373,8,155,10,155,12,155,3376,9,155,1,156,1,156,1,156, + 1,156,1,156,1,156,5,156,3384,8,156,10,156,12,156,3387,9,156,1,157,1,157, + 1,157,5,157,3392,8,157,10,157,12,157,3395,9,157,1,158,1,158,1,158,5,158, + 3400,8,158,10,158,12,158,3403,9,158,1,159,1,159,1,159,5,159,3408,8,159, + 10,159,12,159,3411,9,159,1,160,1,160,1,160,5,160,3416,8,160,10,160,12, + 160,3419,9,160,1,161,1,161,1,161,5,161,3424,8,161,10,161,12,161,3427,9, + 161,1,162,1,162,1,162,1,162,5,162,3433,8,162,10,162,12,162,3436,9,162, + 1,163,1,163,1,163,5,163,3441,8,163,10,163,12,163,3444,9,163,1,164,1,164, + 1,164,1,164,1,164,1,164,1,164,1,164,3,164,3454,8,164,1,165,1,165,1,165, + 5,165,3459,8,165,10,165,12,165,3462,9,165,1,166,1,166,1,166,1,166,1,166, + 1,166,1,166,1,166,1,166,3,166,3473,8,166,1,167,1,167,1,167,1,167,1,167, + 1,167,1,167,1,167,1,167,1,167,1,167,1,167,1,167,1,167,1,167,1,167,1,167, + 1,167,1,167,1,167,1,167,1,167,1,167,1,167,1,167,1,167,1,167,1,167,1,167, + 1,167,1,167,1,167,3,167,3507,8,167,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,169,3,169,3529,8,169,1,170,1,170,1,170,5,170,3534,8,170,10,170, + 12,170,3537,9,170,1,171,1,171,1,171,1,171,1,171,1,171,1,171,1,171,1,171, + 1,171,1,171,1,171,1,171,1,171,1,171,1,171,1,171,1,171,1,171,3,171,3558, + 8,171,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,174,1,174,1,174,1,174,1,174,1,175,1,175,1,175,5,175,3580,8,175, + 10,175,12,175,3583,9,175,1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176, + 1,176,1,176,1,176,1,176,1,176,1,176,1,176,3,176,3600,8,176,1,177,1,177, + 1,177,5,177,3605,8,177,10,177,12,177,3608,9,177,1,178,1,178,1,178,1,178, + 1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178, + 1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,3,178,3635,8,178, + 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,3,180,3655,8,180,1,181,1,181,1,181, + 5,181,3660,8,181,10,181,12,181,3663,9,181,1,182,1,182,1,183,1,183,1,183, + 5,183,3670,8,183,10,183,12,183,3673,9,183,1,184,1,184,1,184,1,184,1,184, + 1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,1,184,3,184,3690, + 8,184,1,184,0,0,185,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,0,17,6,0,1,15, + 199,199,243,243,247,247,264,264,289,289,5,0,16,16,199,199,243,243,264, + 264,288,289,1,0,263,264,1,0,173,174,1,0,37,38,2,0,45,47,186,187,1,0,73, + 74,3,0,2,2,61,61,77,83,2,0,229,229,260,261,1,0,95,96,1,0,97,111,1,0,188, + 189,1,0,184,186,1,0,184,189,2,0,173,173,289,290,1,0,167,168,1,0,51,52, + 4131,0,370,1,0,0,0,2,388,1,0,0,0,4,390,1,0,0,0,6,397,1,0,0,0,8,406,1,0, + 0,0,10,495,1,0,0,0,12,497,1,0,0,0,14,501,1,0,0,0,16,505,1,0,0,0,18,510, + 1,0,0,0,20,514,1,0,0,0,22,518,1,0,0,0,24,526,1,0,0,0,26,546,1,0,0,0,28, + 548,1,0,0,0,30,550,1,0,0,0,32,562,1,0,0,0,34,564,1,0,0,0,36,587,1,0,0, + 0,38,594,1,0,0,0,40,612,1,0,0,0,42,644,1,0,0,0,44,672,1,0,0,0,46,712,1, + 0,0,0,48,714,1,0,0,0,50,723,1,0,0,0,52,725,1,0,0,0,54,735,1,0,0,0,56,748, + 1,0,0,0,58,751,1,0,0,0,60,754,1,0,0,0,62,778,1,0,0,0,64,791,1,0,0,0,66, + 793,1,0,0,0,68,807,1,0,0,0,70,812,1,0,0,0,72,814,1,0,0,0,74,821,1,0,0, + 0,76,825,1,0,0,0,78,904,1,0,0,0,80,911,1,0,0,0,82,918,1,0,0,0,84,923,1, + 0,0,0,86,932,1,0,0,0,88,938,1,0,0,0,90,991,1,0,0,0,92,993,1,0,0,0,94,1017, + 1,0,0,0,96,1022,1,0,0,0,98,1024,1,0,0,0,100,1031,1,0,0,0,102,1059,1,0, + 0,0,104,1139,1,0,0,0,106,1141,1,0,0,0,108,1170,1,0,0,0,110,1172,1,0,0, + 0,112,1186,1,0,0,0,114,1215,1,0,0,0,116,1227,1,0,0,0,118,1266,1,0,0,0, + 120,1274,1,0,0,0,122,1285,1,0,0,0,124,1299,1,0,0,0,126,1318,1,0,0,0,128, + 1331,1,0,0,0,130,1355,1,0,0,0,132,1502,1,0,0,0,134,1512,1,0,0,0,136,1524, + 1,0,0,0,138,1606,1,0,0,0,140,1608,1,0,0,0,142,1647,1,0,0,0,144,1707,1, + 0,0,0,146,1747,1,0,0,0,148,1763,1,0,0,0,150,1765,1,0,0,0,152,1769,1,0, + 0,0,154,1831,1,0,0,0,156,1846,1,0,0,0,158,1863,1,0,0,0,160,1871,1,0,0, + 0,162,1877,1,0,0,0,164,1882,1,0,0,0,166,1929,1,0,0,0,168,1931,1,0,0,0, + 170,1975,1,0,0,0,172,1994,1,0,0,0,174,2015,1,0,0,0,176,2017,1,0,0,0,178, + 2034,1,0,0,0,180,2049,1,0,0,0,182,2057,1,0,0,0,184,2069,1,0,0,0,186,2089, + 1,0,0,0,188,2096,1,0,0,0,190,2099,1,0,0,0,192,2112,1,0,0,0,194,2118,1, + 0,0,0,196,2124,1,0,0,0,198,2128,1,0,0,0,200,2285,1,0,0,0,202,2287,1,0, + 0,0,204,2343,1,0,0,0,206,2354,1,0,0,0,208,2361,1,0,0,0,210,2369,1,0,0, + 0,212,2396,1,0,0,0,214,2402,1,0,0,0,216,2407,1,0,0,0,218,2436,1,0,0,0, + 220,2438,1,0,0,0,222,2458,1,0,0,0,224,2463,1,0,0,0,226,2488,1,0,0,0,228, + 2497,1,0,0,0,230,2512,1,0,0,0,232,2519,1,0,0,0,234,2539,1,0,0,0,236,2541, + 1,0,0,0,238,2612,1,0,0,0,240,2637,1,0,0,0,242,2681,1,0,0,0,244,2690,1, + 0,0,0,246,2730,1,0,0,0,248,2735,1,0,0,0,250,2775,1,0,0,0,252,2777,1,0, + 0,0,254,2783,1,0,0,0,256,2791,1,0,0,0,258,2811,1,0,0,0,260,2878,1,0,0, + 0,262,2880,1,0,0,0,264,2890,1,0,0,0,266,2892,1,0,0,0,268,2896,1,0,0,0, + 270,2902,1,0,0,0,272,2922,1,0,0,0,274,2940,1,0,0,0,276,2954,1,0,0,0,278, + 2956,1,0,0,0,280,2959,1,0,0,0,282,2961,1,0,0,0,284,2978,1,0,0,0,286,2980, + 1,0,0,0,288,2993,1,0,0,0,290,3000,1,0,0,0,292,3011,1,0,0,0,294,3018,1, + 0,0,0,296,3029,1,0,0,0,298,3079,1,0,0,0,300,3171,1,0,0,0,302,3178,1,0, + 0,0,304,3181,1,0,0,0,306,3191,1,0,0,0,308,3364,1,0,0,0,310,3374,1,0,0, + 0,312,3385,1,0,0,0,314,3393,1,0,0,0,316,3401,1,0,0,0,318,3409,1,0,0,0, + 320,3417,1,0,0,0,322,3425,1,0,0,0,324,3434,1,0,0,0,326,3442,1,0,0,0,328, + 3453,1,0,0,0,330,3460,1,0,0,0,332,3472,1,0,0,0,334,3506,1,0,0,0,336,3508, + 1,0,0,0,338,3528,1,0,0,0,340,3535,1,0,0,0,342,3557,1,0,0,0,344,3559,1, + 0,0,0,346,3565,1,0,0,0,348,3571,1,0,0,0,350,3581,1,0,0,0,352,3599,1,0, + 0,0,354,3606,1,0,0,0,356,3634,1,0,0,0,358,3636,1,0,0,0,360,3654,1,0,0, + 0,362,3661,1,0,0,0,364,3664,1,0,0,0,366,3671,1,0,0,0,368,3689,1,0,0,0, + 370,371,7,0,0,0,371,1,1,0,0,0,372,373,5,288,0,0,373,389,6,1,-1,0,374,375, + 3,4,2,0,375,376,6,1,-1,0,376,377,5,265,0,0,377,379,1,0,0,0,378,374,1,0, + 0,0,379,382,1,0,0,0,380,378,1,0,0,0,380,381,1,0,0,0,381,383,1,0,0,0,382, + 380,1,0,0,0,383,384,3,4,2,0,384,385,6,1,-1,0,385,389,1,0,0,0,386,387,5, + 264,0,0,387,389,6,1,-1,0,388,372,1,0,0,0,388,380,1,0,0,0,388,386,1,0,0, + 0,389,3,1,0,0,0,390,391,7,1,0,0,391,5,1,0,0,0,392,393,5,263,0,0,393,394, + 6,3,-1,0,394,396,5,266,0,0,395,392,1,0,0,0,396,399,1,0,0,0,397,395,1,0, + 0,0,397,398,1,0,0,0,398,400,1,0,0,0,399,397,1,0,0,0,400,401,5,263,0,0, + 401,402,6,3,-1,0,402,7,1,0,0,0,403,405,3,10,5,0,404,403,1,0,0,0,405,408, + 1,0,0,0,406,404,1,0,0,0,406,407,1,0,0,0,407,9,1,0,0,0,408,406,1,0,0,0, + 409,410,3,76,38,0,410,411,5,17,0,0,411,412,3,84,42,0,412,413,5,18,0,0, + 413,496,1,0,0,0,414,415,3,74,37,0,415,416,5,17,0,0,416,417,3,8,4,0,417, + 418,5,18,0,0,418,496,1,0,0,0,419,420,3,236,118,0,420,421,5,17,0,0,421, + 422,3,248,124,0,422,423,5,18,0,0,423,496,1,0,0,0,424,496,3,202,101,0,425, + 426,6,5,-1,0,426,427,3,286,143,0,427,428,6,5,-1,0,428,496,1,0,0,0,429, + 430,6,5,-1,0,430,431,3,72,36,0,431,432,6,5,-1,0,432,496,1,0,0,0,433,434, + 6,5,-1,0,434,435,3,66,33,0,435,436,6,5,-1,0,436,496,1,0,0,0,437,438,6, + 5,-1,0,438,439,3,90,45,0,439,440,6,5,-1,0,440,496,1,0,0,0,441,442,6,5, + -1,0,442,443,3,92,46,0,443,444,6,5,-1,0,444,496,1,0,0,0,445,446,6,5,-1, + 0,446,447,3,22,11,0,447,448,6,5,-1,0,448,496,1,0,0,0,449,450,6,5,-1,0, + 450,451,3,336,168,0,451,452,6,5,-1,0,452,496,1,0,0,0,453,454,6,5,-1,0, + 454,455,3,344,172,0,455,456,6,5,-1,0,456,496,1,0,0,0,457,458,6,5,-1,0, + 458,459,3,358,179,0,459,460,6,5,-1,0,460,496,1,0,0,0,461,462,6,5,-1,0, + 462,463,3,64,32,0,463,464,6,5,-1,0,464,496,1,0,0,0,465,466,6,5,-1,0,466, + 467,3,154,77,0,467,468,6,5,-1,0,468,496,1,0,0,0,469,470,3,332,166,0,470, + 471,6,5,-1,0,471,496,1,0,0,0,472,473,6,5,-1,0,473,496,3,12,6,0,474,475, + 6,5,-1,0,475,496,3,14,7,0,476,477,6,5,-1,0,477,496,3,16,8,0,478,479,6, + 5,-1,0,479,496,3,18,9,0,480,481,6,5,-1,0,481,496,3,20,10,0,482,483,6,5, + -1,0,483,484,3,26,13,0,484,485,6,5,-1,0,485,496,1,0,0,0,486,487,6,5,-1, + 0,487,488,3,42,21,0,488,489,6,5,-1,0,489,496,1,0,0,0,490,491,6,5,-1,0, + 491,496,3,40,20,0,492,496,3,30,15,0,493,494,6,5,-1,0,494,496,3,24,12,0, + 495,409,1,0,0,0,495,414,1,0,0,0,495,419,1,0,0,0,495,424,1,0,0,0,495,425, + 1,0,0,0,495,429,1,0,0,0,495,433,1,0,0,0,495,437,1,0,0,0,495,441,1,0,0, + 0,495,445,1,0,0,0,495,449,1,0,0,0,495,453,1,0,0,0,495,457,1,0,0,0,495, + 461,1,0,0,0,495,465,1,0,0,0,495,469,1,0,0,0,495,472,1,0,0,0,495,474,1, + 0,0,0,495,476,1,0,0,0,495,478,1,0,0,0,495,480,1,0,0,0,495,482,1,0,0,0, + 495,486,1,0,0,0,495,490,1,0,0,0,495,492,1,0,0,0,495,493,1,0,0,0,496,11, + 1,0,0,0,497,498,5,19,0,0,498,499,3,32,16,0,499,500,6,6,-1,0,500,13,1,0, + 0,0,501,502,5,20,0,0,502,503,3,32,16,0,503,504,6,7,-1,0,504,15,1,0,0,0, + 505,506,5,21,0,0,506,507,5,22,0,0,507,508,3,32,16,0,508,509,6,8,-1,0,509, + 17,1,0,0,0,510,511,5,23,0,0,511,512,3,34,17,0,512,513,6,9,-1,0,513,19, + 1,0,0,0,514,515,5,24,0,0,515,516,3,34,17,0,516,517,6,10,-1,0,517,21,1, + 0,0,0,518,519,5,25,0,0,519,520,3,100,50,0,520,521,3,2,1,0,521,522,5,17, + 0,0,522,523,3,122,61,0,523,524,5,18,0,0,524,525,6,11,-1,0,525,23,1,0,0, + 0,526,527,5,26,0,0,527,25,1,0,0,0,528,529,5,27,0,0,529,530,3,28,14,0,530, + 531,6,13,-1,0,531,547,1,0,0,0,532,533,5,27,0,0,533,534,3,28,14,0,534,535, + 5,28,0,0,535,536,3,28,14,0,536,537,6,13,-1,0,537,547,1,0,0,0,538,539,5, + 27,0,0,539,540,3,28,14,0,540,541,5,28,0,0,541,542,3,28,14,0,542,543,5, + 28,0,0,543,544,3,28,14,0,544,545,6,13,-1,0,545,547,1,0,0,0,546,528,1,0, + 0,0,546,532,1,0,0,0,546,538,1,0,0,0,547,27,1,0,0,0,548,549,7,2,0,0,549, + 29,1,0,0,0,550,551,5,29,0,0,551,557,5,17,0,0,552,553,3,118,59,0,553,554, + 6,15,-1,0,554,556,1,0,0,0,555,552,1,0,0,0,556,559,1,0,0,0,557,555,1,0, + 0,0,557,558,1,0,0,0,558,560,1,0,0,0,559,557,1,0,0,0,560,561,5,18,0,0,561, + 31,1,0,0,0,562,563,5,173,0,0,563,33,1,0,0,0,564,565,7,3,0,0,565,35,1,0, + 0,0,566,567,5,175,0,0,567,588,6,18,-1,0,568,569,3,32,16,0,569,570,5,265, + 0,0,570,571,6,18,-1,0,571,588,1,0,0,0,572,573,3,32,16,0,573,574,6,18,-1, + 0,574,588,1,0,0,0,575,576,5,188,0,0,576,577,5,30,0,0,577,578,3,32,16,0, + 578,579,5,31,0,0,579,580,6,18,-1,0,580,588,1,0,0,0,581,582,5,189,0,0,582, + 583,5,30,0,0,583,584,3,34,17,0,584,585,5,31,0,0,585,586,6,18,-1,0,586, + 588,1,0,0,0,587,566,1,0,0,0,587,568,1,0,0,0,587,572,1,0,0,0,587,575,1, + 0,0,0,587,581,1,0,0,0,588,37,1,0,0,0,589,590,3,32,16,0,590,591,6,19,-1, + 0,591,595,1,0,0,0,592,593,5,262,0,0,593,595,6,19,-1,0,594,589,1,0,0,0, + 594,592,1,0,0,0,595,39,1,0,0,0,596,597,5,267,0,0,597,613,5,289,0,0,598, + 599,5,267,0,0,599,600,5,289,0,0,600,613,5,263,0,0,601,602,5,268,0,0,602, + 613,5,289,0,0,603,604,5,269,0,0,604,613,5,289,0,0,605,606,5,270,0,0,606, + 613,5,289,0,0,607,613,5,271,0,0,608,613,5,272,0,0,609,610,5,273,0,0,610, + 613,5,263,0,0,611,613,5,32,0,0,612,596,1,0,0,0,612,598,1,0,0,0,612,601, + 1,0,0,0,612,603,1,0,0,0,612,605,1,0,0,0,612,607,1,0,0,0,612,608,1,0,0, + 0,612,609,1,0,0,0,612,611,1,0,0,0,613,41,1,0,0,0,614,615,5,33,0,0,615, + 616,3,140,70,0,616,617,5,34,0,0,617,618,3,2,1,0,618,619,6,21,-1,0,619, + 645,1,0,0,0,620,621,5,33,0,0,621,622,3,118,59,0,622,623,5,34,0,0,623,624, + 3,2,1,0,624,625,6,21,-1,0,625,645,1,0,0,0,626,627,5,33,0,0,627,628,3,178, + 89,0,628,629,5,34,0,0,629,630,3,2,1,0,630,631,6,21,-1,0,631,645,1,0,0, + 0,632,633,5,33,0,0,633,634,3,44,22,0,634,635,5,34,0,0,635,636,3,2,1,0, + 636,637,6,21,-1,0,637,645,1,0,0,0,638,639,5,33,0,0,639,640,3,46,23,0,640, + 641,5,34,0,0,641,642,3,2,1,0,642,643,6,21,-1,0,643,645,1,0,0,0,644,614, + 1,0,0,0,644,620,1,0,0,0,644,626,1,0,0,0,644,632,1,0,0,0,644,638,1,0,0, + 0,645,43,1,0,0,0,646,647,5,35,0,0,647,648,3,48,24,0,648,649,6,22,-1,0, + 649,673,1,0,0,0,650,651,5,35,0,0,651,652,3,48,24,0,652,653,5,36,0,0,653, + 654,3,6,3,0,654,655,6,22,-1,0,655,673,1,0,0,0,656,657,5,35,0,0,657,658, + 3,48,24,0,658,659,5,36,0,0,659,660,5,17,0,0,660,661,3,52,26,0,661,662, + 5,18,0,0,662,663,6,22,-1,0,663,673,1,0,0,0,664,665,5,35,0,0,665,666,3, + 48,24,0,666,667,5,36,0,0,667,668,5,30,0,0,668,669,3,302,151,0,669,670, + 5,31,0,0,670,671,6,22,-1,0,671,673,1,0,0,0,672,646,1,0,0,0,672,650,1,0, + 0,0,672,656,1,0,0,0,672,664,1,0,0,0,673,45,1,0,0,0,674,675,5,35,0,0,675, + 676,5,30,0,0,676,677,3,50,25,0,677,678,5,31,0,0,678,679,3,48,24,0,679, + 680,6,23,-1,0,680,713,1,0,0,0,681,682,5,35,0,0,682,683,5,30,0,0,683,684, + 3,50,25,0,684,685,5,31,0,0,685,686,3,48,24,0,686,687,5,36,0,0,687,688, + 3,6,3,0,688,689,6,23,-1,0,689,713,1,0,0,0,690,691,5,35,0,0,691,692,5,30, + 0,0,692,693,3,50,25,0,693,694,5,31,0,0,694,695,3,48,24,0,695,696,5,36, + 0,0,696,697,5,17,0,0,697,698,3,52,26,0,698,699,5,18,0,0,699,700,6,23,-1, + 0,700,713,1,0,0,0,701,702,5,35,0,0,702,703,5,30,0,0,703,704,3,50,25,0, + 704,705,5,31,0,0,705,706,3,48,24,0,706,707,5,36,0,0,707,708,5,30,0,0,708, + 709,3,302,151,0,709,710,5,31,0,0,710,711,6,23,-1,0,711,713,1,0,0,0,712, + 674,1,0,0,0,712,681,1,0,0,0,712,690,1,0,0,0,712,701,1,0,0,0,713,47,1,0, + 0,0,714,715,3,170,85,0,715,716,6,24,-1,0,716,49,1,0,0,0,717,718,3,126, + 63,0,718,719,6,25,-1,0,719,724,1,0,0,0,720,721,3,178,89,0,721,722,6,25, + -1,0,722,724,1,0,0,0,723,717,1,0,0,0,723,720,1,0,0,0,724,51,1,0,0,0,725, + 726,3,54,27,0,726,727,3,56,28,0,727,728,6,26,-1,0,728,53,1,0,0,0,729,730, + 3,308,154,0,730,731,6,27,-1,0,731,734,1,0,0,0,732,734,3,40,20,0,733,729, + 1,0,0,0,733,732,1,0,0,0,734,737,1,0,0,0,735,733,1,0,0,0,735,736,1,0,0, + 0,736,55,1,0,0,0,737,735,1,0,0,0,738,739,3,58,29,0,739,740,3,60,30,0,740, + 741,3,2,1,0,741,742,5,36,0,0,742,743,3,308,154,0,743,744,6,28,-1,0,744, + 747,1,0,0,0,745,747,3,40,20,0,746,738,1,0,0,0,746,745,1,0,0,0,747,750, + 1,0,0,0,748,746,1,0,0,0,748,749,1,0,0,0,749,57,1,0,0,0,750,748,1,0,0,0, + 751,752,7,4,0,0,752,753,6,29,-1,0,753,59,1,0,0,0,754,756,3,62,31,0,755, + 757,5,261,0,0,756,755,1,0,0,0,756,757,1,0,0,0,757,758,1,0,0,0,758,759, + 6,30,-1,0,759,61,1,0,0,0,760,761,3,146,73,0,761,762,6,31,-1,0,762,779, + 1,0,0,0,763,764,3,2,1,0,764,765,6,31,-1,0,765,779,1,0,0,0,766,767,5,196, + 0,0,767,779,6,31,-1,0,768,769,5,197,0,0,769,779,6,31,-1,0,770,771,5,202, + 0,0,771,772,5,39,0,0,772,773,5,264,0,0,773,779,6,31,-1,0,774,775,5,202, + 0,0,775,776,3,118,59,0,776,777,6,31,-1,0,777,779,1,0,0,0,778,760,1,0,0, + 0,778,763,1,0,0,0,778,766,1,0,0,0,778,768,1,0,0,0,778,770,1,0,0,0,778, + 774,1,0,0,0,779,63,1,0,0,0,780,781,5,198,0,0,781,782,5,40,0,0,782,783, + 3,2,1,0,783,784,6,32,-1,0,784,792,1,0,0,0,785,786,5,198,0,0,786,787,3, + 2,1,0,787,788,6,32,-1,0,788,792,1,0,0,0,789,790,5,198,0,0,790,792,6,32, + -1,0,791,780,1,0,0,0,791,785,1,0,0,0,791,789,1,0,0,0,792,65,1,0,0,0,793, + 794,5,41,0,0,794,795,5,42,0,0,795,796,3,32,16,0,796,797,5,43,0,0,797,798, + 3,68,34,0,798,799,5,44,0,0,799,800,3,0,0,0,800,801,6,33,-1,0,801,67,1, + 0,0,0,802,803,3,70,35,0,803,804,6,34,-1,0,804,806,1,0,0,0,805,802,1,0, + 0,0,806,809,1,0,0,0,807,805,1,0,0,0,807,808,1,0,0,0,808,810,1,0,0,0,809, + 807,1,0,0,0,810,811,6,34,-1,0,811,69,1,0,0,0,812,813,7,5,0,0,813,71,1, + 0,0,0,814,815,5,48,0,0,815,816,5,36,0,0,816,817,5,30,0,0,817,818,3,302, + 151,0,818,819,5,31,0,0,819,820,6,36,-1,0,820,73,1,0,0,0,821,822,5,49,0, + 0,822,823,3,2,1,0,823,824,6,37,-1,0,824,75,1,0,0,0,825,831,5,50,0,0,826, + 827,3,78,39,0,827,828,6,38,-1,0,828,830,1,0,0,0,829,826,1,0,0,0,830,833, + 1,0,0,0,831,829,1,0,0,0,831,832,1,0,0,0,832,834,1,0,0,0,833,831,1,0,0, + 0,834,835,3,2,1,0,835,836,3,184,92,0,836,837,3,80,40,0,837,838,3,82,41, + 0,838,839,6,38,-1,0,839,77,1,0,0,0,840,841,5,51,0,0,841,905,6,39,-1,0, + 842,843,5,52,0,0,843,905,6,39,-1,0,844,845,5,199,0,0,845,905,6,39,-1,0, + 846,847,5,202,0,0,847,905,6,39,-1,0,848,849,5,221,0,0,849,905,6,39,-1, + 0,850,851,5,53,0,0,851,905,6,39,-1,0,852,853,5,54,0,0,853,905,6,39,-1, + 0,854,855,5,55,0,0,855,905,6,39,-1,0,856,857,5,56,0,0,857,905,6,39,-1, + 0,858,859,5,244,0,0,859,905,6,39,-1,0,860,861,5,15,0,0,861,905,6,39,-1, + 0,862,863,5,224,0,0,863,905,6,39,-1,0,864,865,5,57,0,0,865,905,6,39,-1, + 0,866,867,5,58,0,0,867,905,6,39,-1,0,868,869,5,59,0,0,869,905,6,39,-1, + 0,870,871,5,60,0,0,871,905,6,39,-1,0,872,873,5,61,0,0,873,905,6,39,-1, + 0,874,875,5,62,0,0,875,876,5,51,0,0,876,905,6,39,-1,0,877,878,5,62,0,0, + 878,879,5,52,0,0,879,905,6,39,-1,0,880,881,5,62,0,0,881,882,5,63,0,0,882, + 905,6,39,-1,0,883,884,5,62,0,0,884,885,5,64,0,0,885,905,6,39,-1,0,886, + 887,5,62,0,0,887,888,5,65,0,0,888,905,6,39,-1,0,889,890,5,62,0,0,890,891, + 5,66,0,0,891,905,6,39,-1,0,892,893,5,67,0,0,893,905,6,39,-1,0,894,895, + 5,68,0,0,895,905,6,39,-1,0,896,897,5,69,0,0,897,905,6,39,-1,0,898,899, + 5,70,0,0,899,900,5,30,0,0,900,901,3,32,16,0,901,902,5,31,0,0,902,903,6, + 39,-1,0,903,905,1,0,0,0,904,840,1,0,0,0,904,842,1,0,0,0,904,844,1,0,0, + 0,904,846,1,0,0,0,904,848,1,0,0,0,904,850,1,0,0,0,904,852,1,0,0,0,904, + 854,1,0,0,0,904,856,1,0,0,0,904,858,1,0,0,0,904,860,1,0,0,0,904,862,1, + 0,0,0,904,864,1,0,0,0,904,866,1,0,0,0,904,868,1,0,0,0,904,870,1,0,0,0, + 904,872,1,0,0,0,904,874,1,0,0,0,904,877,1,0,0,0,904,880,1,0,0,0,904,883, + 1,0,0,0,904,886,1,0,0,0,904,889,1,0,0,0,904,892,1,0,0,0,904,894,1,0,0, + 0,904,896,1,0,0,0,904,898,1,0,0,0,905,79,1,0,0,0,906,912,1,0,0,0,907,908, + 5,71,0,0,908,909,3,126,63,0,909,910,6,40,-1,0,910,912,1,0,0,0,911,906, + 1,0,0,0,911,907,1,0,0,0,912,81,1,0,0,0,913,919,1,0,0,0,914,915,5,72,0, + 0,915,916,3,86,43,0,916,917,6,41,-1,0,917,919,1,0,0,0,918,913,1,0,0,0, + 918,914,1,0,0,0,919,83,1,0,0,0,920,922,3,200,100,0,921,920,1,0,0,0,922, + 925,1,0,0,0,923,921,1,0,0,0,923,924,1,0,0,0,924,85,1,0,0,0,925,923,1,0, + 0,0,926,927,3,126,63,0,927,928,6,43,-1,0,928,929,5,28,0,0,929,931,1,0, + 0,0,930,926,1,0,0,0,931,934,1,0,0,0,932,930,1,0,0,0,932,933,1,0,0,0,933, + 935,1,0,0,0,934,932,1,0,0,0,935,936,3,126,63,0,936,937,6,43,-1,0,937,87, + 1,0,0,0,938,939,7,6,0,0,939,89,1,0,0,0,940,941,3,88,44,0,941,943,3,32, + 16,0,942,944,7,2,0,0,943,942,1,0,0,0,943,944,1,0,0,0,944,945,1,0,0,0,945, + 946,6,45,-1,0,946,992,1,0,0,0,947,948,3,88,44,0,948,949,3,32,16,0,949, + 950,5,75,0,0,950,952,3,32,16,0,951,953,7,2,0,0,952,951,1,0,0,0,952,953, + 1,0,0,0,953,954,1,0,0,0,954,955,6,45,-1,0,955,992,1,0,0,0,956,957,3,88, + 44,0,957,958,3,32,16,0,958,959,5,75,0,0,959,960,3,32,16,0,960,961,5,28, + 0,0,961,963,3,32,16,0,962,964,7,2,0,0,963,962,1,0,0,0,963,964,1,0,0,0, + 964,965,1,0,0,0,965,966,6,45,-1,0,966,992,1,0,0,0,967,968,3,88,44,0,968, + 969,3,32,16,0,969,970,5,28,0,0,970,971,3,32,16,0,971,972,5,75,0,0,972, + 974,3,32,16,0,973,975,7,2,0,0,974,973,1,0,0,0,974,975,1,0,0,0,975,976, + 1,0,0,0,976,977,6,45,-1,0,977,992,1,0,0,0,978,979,3,88,44,0,979,980,3, + 32,16,0,980,981,5,28,0,0,981,982,3,32,16,0,982,983,5,75,0,0,983,984,3, + 32,16,0,984,985,5,28,0,0,985,987,3,32,16,0,986,988,7,2,0,0,987,986,1,0, + 0,0,987,988,1,0,0,0,988,989,1,0,0,0,989,990,6,45,-1,0,990,992,1,0,0,0, + 991,940,1,0,0,0,991,947,1,0,0,0,991,956,1,0,0,0,991,967,1,0,0,0,991,978, + 1,0,0,0,992,91,1,0,0,0,993,999,5,21,0,0,994,995,3,94,47,0,995,996,6,46, + -1,0,996,998,1,0,0,0,997,994,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,1003,3,2,1,0, + 1003,1004,6,46,-1,0,1004,1005,3,96,48,0,1005,1015,6,46,-1,0,1006,1007, + 5,180,0,0,1007,1008,5,36,0,0,1008,1009,5,30,0,0,1009,1010,3,302,151,0, + 1010,1011,5,31,0,0,1011,1012,6,46,-1,0,1012,1013,3,96,48,0,1013,1014,6, + 46,-1,0,1014,1016,1,0,0,0,1015,1006,1,0,0,0,1015,1016,1,0,0,0,1016,93, + 1,0,0,0,1017,1018,5,76,0,0,1018,95,1,0,0,0,1019,1023,1,0,0,0,1020,1021, + 5,298,0,0,1021,1023,6,48,-1,0,1022,1019,1,0,0,0,1022,1020,1,0,0,0,1023, + 97,1,0,0,0,1024,1025,7,7,0,0,1025,99,1,0,0,0,1026,1027,3,98,49,0,1027, + 1028,6,50,-1,0,1028,1030,1,0,0,0,1029,1026,1,0,0,0,1030,1033,1,0,0,0,1031, + 1029,1,0,0,0,1031,1032,1,0,0,0,1032,101,1,0,0,0,1033,1031,1,0,0,0,1034, + 1060,3,104,52,0,1035,1036,5,280,0,0,1036,1037,3,170,85,0,1037,1038,6,51, + -1,0,1038,1060,1,0,0,0,1039,1040,5,286,0,0,1040,1041,3,180,90,0,1041,1042, + 6,51,-1,0,1042,1060,1,0,0,0,1043,1044,5,286,0,0,1044,1045,3,176,88,0,1045, + 1046,6,51,-1,0,1046,1060,1,0,0,0,1047,1048,5,284,0,0,1048,1049,3,126,63, + 0,1049,1050,6,51,-1,0,1050,1060,1,0,0,0,1051,1052,5,281,0,0,1052,1053, + 3,106,53,0,1053,1054,6,51,-1,0,1054,1060,1,0,0,0,1055,1056,5,287,0,0,1056, + 1057,3,50,25,0,1057,1058,6,51,-1,0,1058,1060,1,0,0,0,1059,1034,1,0,0,0, + 1059,1035,1,0,0,0,1059,1039,1,0,0,0,1059,1043,1,0,0,0,1059,1047,1,0,0, + 0,1059,1051,1,0,0,0,1059,1055,1,0,0,0,1060,103,1,0,0,0,1061,1062,5,275, + 0,0,1062,1140,6,52,-1,0,1063,1064,5,276,0,0,1064,1065,3,32,16,0,1065,1066, + 6,52,-1,0,1066,1140,1,0,0,0,1067,1068,5,276,0,0,1068,1069,3,0,0,0,1069, + 1070,6,52,-1,0,1070,1140,1,0,0,0,1071,1072,5,277,0,0,1072,1073,3,32,16, + 0,1073,1074,6,52,-1,0,1074,1140,1,0,0,0,1075,1076,5,278,0,0,1076,1077, + 3,34,17,0,1077,1078,6,52,-1,0,1078,1140,1,0,0,0,1079,1080,5,279,0,0,1080, + 1081,3,36,18,0,1081,1082,6,52,-1,0,1082,1140,1,0,0,0,1083,1084,5,279,0, + 0,1084,1085,3,34,17,0,1085,1086,6,52,-1,0,1086,1140,1,0,0,0,1087,1088, + 5,279,0,0,1088,1089,5,30,0,0,1089,1090,3,302,151,0,1090,1091,5,31,0,0, + 1091,1092,6,52,-1,0,1092,1140,1,0,0,0,1093,1094,5,279,0,0,1094,1095,5, + 84,0,0,1095,1096,5,30,0,0,1096,1097,3,302,151,0,1097,1098,5,31,0,0,1098, + 1099,6,52,-1,0,1099,1140,1,0,0,0,1100,1101,5,282,0,0,1101,1102,3,32,16, + 0,1102,1103,6,52,-1,0,1103,1140,1,0,0,0,1104,1105,5,282,0,0,1105,1106, + 3,0,0,0,1106,1107,6,52,-1,0,1107,1140,1,0,0,0,1108,1109,5,285,0,0,1109, + 1110,3,6,3,0,1110,1111,6,52,-1,0,1111,1140,1,0,0,0,1112,1113,5,285,0,0, + 1113,1114,5,224,0,0,1114,1115,5,30,0,0,1115,1116,3,6,3,0,1116,1117,5,31, + 0,0,1117,1118,6,52,-1,0,1118,1140,1,0,0,0,1119,1120,5,285,0,0,1120,1121, + 5,84,0,0,1121,1122,5,30,0,0,1122,1123,3,302,151,0,1123,1124,5,31,0,0,1124, + 1125,6,52,-1,0,1125,1140,1,0,0,0,1126,1127,5,287,0,0,1127,1128,3,32,16, + 0,1128,1129,6,52,-1,0,1129,1140,1,0,0,0,1130,1131,5,283,0,0,1131,1137, + 6,52,-1,0,1132,1133,5,30,0,0,1133,1134,3,108,54,0,1134,1135,5,31,0,0,1135, + 1138,1,0,0,0,1136,1138,5,85,0,0,1137,1132,1,0,0,0,1137,1136,1,0,0,0,1138, + 1140,1,0,0,0,1139,1061,1,0,0,0,1139,1063,1,0,0,0,1139,1067,1,0,0,0,1139, + 1071,1,0,0,0,1139,1075,1,0,0,0,1139,1079,1,0,0,0,1139,1083,1,0,0,0,1139, + 1087,1,0,0,0,1139,1093,1,0,0,0,1139,1100,1,0,0,0,1139,1104,1,0,0,0,1139, + 1108,1,0,0,0,1139,1112,1,0,0,0,1139,1119,1,0,0,0,1139,1126,1,0,0,0,1139, + 1130,1,0,0,0,1140,105,1,0,0,0,1141,1142,3,172,86,0,1142,1143,3,140,70, + 0,1143,1144,3,114,57,0,1144,1145,6,53,-1,0,1145,107,1,0,0,0,1146,1171, + 1,0,0,0,1147,1148,3,0,0,0,1148,1149,6,54,-1,0,1149,1154,1,0,0,0,1150,1151, + 3,32,16,0,1151,1152,6,54,-1,0,1152,1154,1,0,0,0,1153,1147,1,0,0,0,1153, + 1150,1,0,0,0,1154,1155,1,0,0,0,1155,1156,5,28,0,0,1156,1158,1,0,0,0,1157, + 1153,1,0,0,0,1158,1161,1,0,0,0,1159,1157,1,0,0,0,1159,1160,1,0,0,0,1160, + 1168,1,0,0,0,1161,1159,1,0,0,0,1162,1163,3,0,0,0,1163,1164,6,54,-1,0,1164, + 1169,1,0,0,0,1165,1166,3,32,16,0,1166,1167,6,54,-1,0,1167,1169,1,0,0,0, + 1168,1162,1,0,0,0,1168,1165,1,0,0,0,1169,1171,1,0,0,0,1170,1146,1,0,0, + 0,1170,1159,1,0,0,0,1171,109,1,0,0,0,1172,1179,5,86,0,0,1173,1174,3,140, + 70,0,1174,1175,6,55,-1,0,1175,1176,5,28,0,0,1176,1178,1,0,0,0,1177,1173, + 1,0,0,0,1178,1181,1,0,0,0,1179,1177,1,0,0,0,1179,1180,1,0,0,0,1180,1182, + 1,0,0,0,1181,1179,1,0,0,0,1182,1183,3,140,70,0,1183,1184,6,55,-1,0,1184, + 1185,5,87,0,0,1185,111,1,0,0,0,1186,1193,5,42,0,0,1187,1188,3,148,74,0, + 1188,1189,6,56,-1,0,1189,1190,5,28,0,0,1190,1192,1,0,0,0,1191,1187,1,0, + 0,0,1192,1195,1,0,0,0,1193,1191,1,0,0,0,1193,1194,1,0,0,0,1194,1196,1, + 0,0,0,1195,1193,1,0,0,0,1196,1197,3,148,74,0,1197,1198,6,56,-1,0,1198, + 1199,5,43,0,0,1199,113,1,0,0,0,1200,1207,5,30,0,0,1201,1202,3,116,58,0, + 1202,1203,6,57,-1,0,1203,1204,5,28,0,0,1204,1206,1,0,0,0,1205,1201,1,0, + 0,0,1206,1209,1,0,0,0,1207,1205,1,0,0,0,1207,1208,1,0,0,0,1208,1210,1, + 0,0,0,1209,1207,1,0,0,0,1210,1211,3,116,58,0,1211,1212,6,57,-1,0,1212, + 1213,5,31,0,0,1213,1216,1,0,0,0,1214,1216,5,85,0,0,1215,1200,1,0,0,0,1215, + 1214,1,0,0,0,1216,115,1,0,0,0,1217,1218,5,177,0,0,1218,1228,6,58,-1,0, + 1219,1220,3,232,116,0,1220,1221,3,140,70,0,1221,1223,3,228,114,0,1222, + 1224,3,0,0,0,1223,1222,1,0,0,0,1223,1224,1,0,0,0,1224,1225,1,0,0,0,1225, + 1226,6,58,-1,0,1226,1228,1,0,0,0,1227,1217,1,0,0,0,1227,1219,1,0,0,0,1228, + 117,1,0,0,0,1229,1230,5,42,0,0,1230,1231,3,2,1,0,1231,1232,5,43,0,0,1232, + 1233,3,120,60,0,1233,1234,6,59,-1,0,1234,1267,1,0,0,0,1235,1236,5,42,0, + 0,1236,1237,3,176,88,0,1237,1238,5,43,0,0,1238,1239,3,120,60,0,1239,1240, + 6,59,-1,0,1240,1267,1,0,0,0,1241,1242,5,42,0,0,1242,1243,5,262,0,0,1243, + 1244,5,43,0,0,1244,1245,3,120,60,0,1245,1246,6,59,-1,0,1246,1267,1,0,0, + 0,1247,1248,5,42,0,0,1248,1249,5,198,0,0,1249,1250,3,2,1,0,1250,1251,5, + 43,0,0,1251,1252,3,120,60,0,1252,1253,6,59,-1,0,1253,1267,1,0,0,0,1254, + 1255,3,120,60,0,1255,1256,6,59,-1,0,1256,1267,1,0,0,0,1257,1258,3,176, + 88,0,1258,1259,6,59,-1,0,1259,1267,1,0,0,0,1260,1261,5,257,0,0,1261,1267, + 6,59,-1,0,1262,1263,5,258,0,0,1263,1267,6,59,-1,0,1264,1265,5,259,0,0, + 1265,1267,6,59,-1,0,1266,1229,1,0,0,0,1266,1235,1,0,0,0,1266,1241,1,0, + 0,0,1266,1247,1,0,0,0,1266,1254,1,0,0,0,1266,1257,1,0,0,0,1266,1260,1, + 0,0,0,1266,1262,1,0,0,0,1266,1264,1,0,0,0,1267,119,1,0,0,0,1268,1269,3, + 2,1,0,1269,1270,6,60,-1,0,1270,1271,5,88,0,0,1271,1273,1,0,0,0,1272,1268, + 1,0,0,0,1273,1276,1,0,0,0,1274,1272,1,0,0,0,1274,1275,1,0,0,0,1275,1277, + 1,0,0,0,1276,1274,1,0,0,0,1277,1278,3,2,1,0,1278,1279,6,60,-1,0,1279,121, + 1,0,0,0,1280,1281,3,124,62,0,1281,1282,6,61,-1,0,1282,1284,1,0,0,0,1283, + 1280,1,0,0,0,1284,1287,1,0,0,0,1285,1283,1,0,0,0,1285,1286,1,0,0,0,1286, + 123,1,0,0,0,1287,1285,1,0,0,0,1288,1289,5,180,0,0,1289,1290,5,89,0,0,1290, + 1291,3,32,16,0,1291,1292,6,62,-1,0,1292,1300,1,0,0,0,1293,1294,3,154,77, + 0,1294,1295,6,62,-1,0,1295,1300,1,0,0,0,1296,1297,3,334,167,0,1297,1298, + 6,62,-1,0,1298,1300,1,0,0,0,1299,1288,1,0,0,0,1299,1293,1,0,0,0,1299,1296, + 1,0,0,0,1300,125,1,0,0,0,1301,1302,3,118,59,0,1302,1303,6,63,-1,0,1303, + 1319,1,0,0,0,1304,1305,5,42,0,0,1305,1306,3,2,1,0,1306,1307,5,43,0,0,1307, + 1308,6,63,-1,0,1308,1319,1,0,0,0,1309,1310,5,42,0,0,1310,1311,5,198,0, + 0,1311,1312,3,2,1,0,1312,1313,5,43,0,0,1313,1314,6,63,-1,0,1314,1319,1, + 0,0,0,1315,1316,3,140,70,0,1316,1317,6,63,-1,0,1317,1319,1,0,0,0,1318, + 1301,1,0,0,0,1318,1304,1,0,0,0,1318,1309,1,0,0,0,1318,1315,1,0,0,0,1319, + 127,1,0,0,0,1320,1332,1,0,0,0,1321,1322,3,132,66,0,1322,1328,6,64,-1,0, + 1323,1324,3,130,65,0,1324,1325,6,64,-1,0,1325,1327,1,0,0,0,1326,1323,1, + 0,0,0,1327,1330,1,0,0,0,1328,1326,1,0,0,0,1328,1329,1,0,0,0,1329,1332, + 1,0,0,0,1330,1328,1,0,0,0,1331,1320,1,0,0,0,1331,1321,1,0,0,0,1332,129, + 1,0,0,0,1333,1334,5,262,0,0,1334,1356,6,65,-1,0,1335,1336,5,261,0,0,1336, + 1356,6,65,-1,0,1337,1338,5,42,0,0,1338,1339,3,32,16,0,1339,1340,5,43,0, + 0,1340,1341,6,65,-1,0,1341,1356,1,0,0,0,1342,1343,5,42,0,0,1343,1344,3, + 32,16,0,1344,1345,5,266,0,0,1345,1346,3,32,16,0,1346,1347,5,43,0,0,1347, + 1348,6,65,-1,0,1348,1356,1,0,0,0,1349,1350,5,42,0,0,1350,1351,5,266,0, + 0,1351,1352,3,32,16,0,1352,1353,5,43,0,0,1353,1354,6,65,-1,0,1354,1356, + 1,0,0,0,1355,1333,1,0,0,0,1355,1335,1,0,0,0,1355,1337,1,0,0,0,1355,1342, + 1,0,0,0,1355,1349,1,0,0,0,1356,131,1,0,0,0,1357,1503,6,66,-1,0,1358,1359, + 5,203,0,0,1359,1360,5,30,0,0,1360,1361,3,6,3,0,1361,1362,5,28,0,0,1362, + 1363,3,6,3,0,1363,1364,5,28,0,0,1364,1365,3,6,3,0,1365,1366,5,28,0,0,1366, + 1367,3,6,3,0,1367,1368,5,31,0,0,1368,1369,6,66,-1,0,1369,1503,1,0,0,0, + 1370,1371,5,203,0,0,1371,1372,5,30,0,0,1372,1373,3,6,3,0,1373,1374,5,28, + 0,0,1374,1375,3,6,3,0,1375,1376,5,31,0,0,1376,1377,6,66,-1,0,1377,1503, + 1,0,0,0,1378,1379,5,204,0,0,1379,1380,5,205,0,0,1380,1381,5,42,0,0,1381, + 1382,3,32,16,0,1382,1383,5,43,0,0,1383,1384,6,66,-1,0,1384,1503,1,0,0, + 0,1385,1386,5,204,0,0,1386,1387,5,206,0,0,1387,1388,5,42,0,0,1388,1389, + 3,32,16,0,1389,1390,5,43,0,0,1390,1391,3,128,64,0,1391,1392,6,66,-1,0, + 1392,1503,1,0,0,0,1393,1394,5,207,0,0,1394,1503,6,66,-1,0,1395,1396,5, + 208,0,0,1396,1503,6,66,-1,0,1397,1398,5,209,0,0,1398,1503,6,66,-1,0,1399, + 1400,5,201,0,0,1400,1503,6,66,-1,0,1401,1402,5,183,0,0,1402,1503,6,66, + -1,0,1403,1404,5,184,0,0,1404,1503,6,66,-1,0,1405,1406,5,185,0,0,1406, + 1503,6,66,-1,0,1407,1408,5,186,0,0,1408,1503,6,66,-1,0,1409,1410,5,187, + 0,0,1410,1503,6,66,-1,0,1411,1412,5,188,0,0,1412,1503,6,66,-1,0,1413,1414, + 5,189,0,0,1414,1503,6,66,-1,0,1415,1416,5,210,0,0,1416,1503,6,66,-1,0, + 1417,1418,5,190,0,0,1418,1503,6,66,-1,0,1419,1420,5,191,0,0,1420,1503, + 6,66,-1,0,1421,1422,5,192,0,0,1422,1503,6,66,-1,0,1423,1424,5,193,0,0, + 1424,1503,6,66,-1,0,1425,1426,5,211,0,0,1426,1503,6,66,-1,0,1427,1428, + 5,212,0,0,1428,1503,6,66,-1,0,1429,1430,5,213,0,0,1430,1503,6,66,-1,0, + 1431,1432,5,214,0,0,1432,1503,6,66,-1,0,1433,1434,5,215,0,0,1434,1503, + 6,66,-1,0,1435,1436,5,216,0,0,1436,1503,6,66,-1,0,1437,1438,5,217,0,0, + 1438,1503,6,66,-1,0,1439,1440,5,218,0,0,1440,1441,3,134,67,0,1441,1442, + 6,66,-1,0,1442,1503,1,0,0,0,1443,1444,5,219,0,0,1444,1445,3,134,67,0,1445, + 1446,6,66,-1,0,1446,1503,1,0,0,0,1447,1448,5,220,0,0,1448,1503,6,66,-1, + 0,1449,1450,5,221,0,0,1450,1451,3,134,67,0,1451,1452,6,66,-1,0,1452,1503, + 1,0,0,0,1453,1454,5,222,0,0,1454,1455,3,136,68,0,1455,1456,6,66,-1,0,1456, + 1503,1,0,0,0,1457,1458,5,222,0,0,1458,1459,3,136,68,0,1459,1460,5,28,0, + 0,1460,1461,3,6,3,0,1461,1462,6,66,-1,0,1462,1503,1,0,0,0,1463,1464,5, + 194,0,0,1464,1503,6,66,-1,0,1465,1466,5,195,0,0,1466,1503,6,66,-1,0,1467, + 1468,5,90,0,0,1468,1469,5,184,0,0,1469,1503,6,66,-1,0,1470,1471,5,90,0, + 0,1471,1472,5,185,0,0,1472,1503,6,66,-1,0,1473,1474,5,90,0,0,1474,1475, + 5,186,0,0,1475,1503,6,66,-1,0,1476,1477,5,90,0,0,1477,1478,5,187,0,0,1478, + 1503,6,66,-1,0,1479,1480,5,62,0,0,1480,1481,5,220,0,0,1481,1503,6,66,-1, + 0,1482,1483,5,223,0,0,1483,1503,6,66,-1,0,1484,1485,5,224,0,0,1485,1486, + 5,213,0,0,1486,1503,6,66,-1,0,1487,1488,5,225,0,0,1488,1503,6,66,-1,0, + 1489,1490,5,207,0,0,1490,1491,5,183,0,0,1491,1503,6,66,-1,0,1492,1493, + 5,226,0,0,1493,1503,6,66,-1,0,1494,1495,5,228,0,0,1495,1503,6,66,-1,0, + 1496,1497,5,34,0,0,1497,1498,5,227,0,0,1498,1503,6,66,-1,0,1499,1500,3, + 2,1,0,1500,1501,6,66,-1,0,1501,1503,1,0,0,0,1502,1357,1,0,0,0,1502,1358, + 1,0,0,0,1502,1370,1,0,0,0,1502,1378,1,0,0,0,1502,1385,1,0,0,0,1502,1393, + 1,0,0,0,1502,1395,1,0,0,0,1502,1397,1,0,0,0,1502,1399,1,0,0,0,1502,1401, + 1,0,0,0,1502,1403,1,0,0,0,1502,1405,1,0,0,0,1502,1407,1,0,0,0,1502,1409, + 1,0,0,0,1502,1411,1,0,0,0,1502,1413,1,0,0,0,1502,1415,1,0,0,0,1502,1417, + 1,0,0,0,1502,1419,1,0,0,0,1502,1421,1,0,0,0,1502,1423,1,0,0,0,1502,1425, + 1,0,0,0,1502,1427,1,0,0,0,1502,1429,1,0,0,0,1502,1431,1,0,0,0,1502,1433, + 1,0,0,0,1502,1435,1,0,0,0,1502,1437,1,0,0,0,1502,1439,1,0,0,0,1502,1443, + 1,0,0,0,1502,1447,1,0,0,0,1502,1449,1,0,0,0,1502,1453,1,0,0,0,1502,1457, + 1,0,0,0,1502,1463,1,0,0,0,1502,1465,1,0,0,0,1502,1467,1,0,0,0,1502,1470, + 1,0,0,0,1502,1473,1,0,0,0,1502,1476,1,0,0,0,1502,1479,1,0,0,0,1502,1482, + 1,0,0,0,1502,1484,1,0,0,0,1502,1487,1,0,0,0,1502,1489,1,0,0,0,1502,1492, + 1,0,0,0,1502,1494,1,0,0,0,1502,1496,1,0,0,0,1502,1499,1,0,0,0,1503,133, + 1,0,0,0,1504,1513,1,0,0,0,1505,1506,5,30,0,0,1506,1507,5,91,0,0,1507,1508, + 5,36,0,0,1508,1509,3,32,16,0,1509,1510,5,31,0,0,1510,1511,6,67,-1,0,1511, + 1513,1,0,0,0,1512,1504,1,0,0,0,1512,1505,1,0,0,0,1513,135,1,0,0,0,1514, + 1525,1,0,0,0,1515,1516,3,138,69,0,1516,1521,6,68,-1,0,1517,1518,7,8,0, + 0,1518,1520,6,68,-1,0,1519,1517,1,0,0,0,1520,1523,1,0,0,0,1521,1519,1, + 0,0,0,1521,1522,1,0,0,0,1522,1525,1,0,0,0,1523,1521,1,0,0,0,1524,1514, + 1,0,0,0,1524,1515,1,0,0,0,1525,137,1,0,0,0,1526,1527,5,178,0,0,1527,1607, + 6,69,-1,0,1528,1529,5,207,0,0,1529,1607,6,69,-1,0,1530,1531,5,208,0,0, + 1531,1607,6,69,-1,0,1532,1533,5,201,0,0,1533,1607,6,69,-1,0,1534,1535, + 5,183,0,0,1535,1607,6,69,-1,0,1536,1537,5,184,0,0,1537,1607,6,69,-1,0, + 1538,1539,5,185,0,0,1539,1607,6,69,-1,0,1540,1541,5,186,0,0,1541,1607, + 6,69,-1,0,1542,1543,5,187,0,0,1543,1607,6,69,-1,0,1544,1545,5,188,0,0, + 1545,1607,6,69,-1,0,1546,1547,5,189,0,0,1547,1607,6,69,-1,0,1548,1549, + 5,190,0,0,1549,1607,6,69,-1,0,1550,1551,5,191,0,0,1551,1607,6,69,-1,0, + 1552,1553,5,192,0,0,1553,1607,6,69,-1,0,1554,1555,5,193,0,0,1555,1607, + 6,69,-1,0,1556,1557,5,262,0,0,1557,1607,6,69,-1,0,1558,1559,5,211,0,0, + 1559,1607,6,69,-1,0,1560,1561,5,212,0,0,1561,1607,6,69,-1,0,1562,1563, + 5,213,0,0,1563,1607,6,69,-1,0,1564,1565,5,214,0,0,1565,1607,6,69,-1,0, + 1566,1567,5,215,0,0,1567,1607,6,69,-1,0,1568,1569,5,218,0,0,1569,1607, + 6,69,-1,0,1570,1571,5,219,0,0,1571,1607,6,69,-1,0,1572,1573,5,222,0,0, + 1573,1607,6,69,-1,0,1574,1575,5,194,0,0,1575,1607,6,69,-1,0,1576,1577, + 5,195,0,0,1577,1607,6,69,-1,0,1578,1579,5,210,0,0,1579,1607,6,69,-1,0, + 1580,1581,5,230,0,0,1581,1607,6,69,-1,0,1582,1583,5,231,0,0,1583,1607, + 6,69,-1,0,1584,1585,5,232,0,0,1585,1607,6,69,-1,0,1586,1587,5,233,0,0, + 1587,1607,6,69,-1,0,1588,1589,5,234,0,0,1589,1607,6,69,-1,0,1590,1591, + 5,235,0,0,1591,1607,6,69,-1,0,1592,1593,5,236,0,0,1593,1607,6,69,-1,0, + 1594,1595,5,237,0,0,1595,1607,6,69,-1,0,1596,1597,5,238,0,0,1597,1607, + 6,69,-1,0,1598,1599,5,239,0,0,1599,1607,6,69,-1,0,1600,1601,5,240,0,0, + 1601,1607,6,69,-1,0,1602,1603,5,241,0,0,1603,1607,6,69,-1,0,1604,1605, + 5,242,0,0,1605,1607,6,69,-1,0,1606,1526,1,0,0,0,1606,1528,1,0,0,0,1606, + 1530,1,0,0,0,1606,1532,1,0,0,0,1606,1534,1,0,0,0,1606,1536,1,0,0,0,1606, + 1538,1,0,0,0,1606,1540,1,0,0,0,1606,1542,1,0,0,0,1606,1544,1,0,0,0,1606, + 1546,1,0,0,0,1606,1548,1,0,0,0,1606,1550,1,0,0,0,1606,1552,1,0,0,0,1606, + 1554,1,0,0,0,1606,1556,1,0,0,0,1606,1558,1,0,0,0,1606,1560,1,0,0,0,1606, + 1562,1,0,0,0,1606,1564,1,0,0,0,1606,1566,1,0,0,0,1606,1568,1,0,0,0,1606, + 1570,1,0,0,0,1606,1572,1,0,0,0,1606,1574,1,0,0,0,1606,1576,1,0,0,0,1606, + 1578,1,0,0,0,1606,1580,1,0,0,0,1606,1582,1,0,0,0,1606,1584,1,0,0,0,1606, + 1586,1,0,0,0,1606,1588,1,0,0,0,1606,1590,1,0,0,0,1606,1592,1,0,0,0,1606, + 1594,1,0,0,0,1606,1596,1,0,0,0,1606,1598,1,0,0,0,1606,1600,1,0,0,0,1606, + 1602,1,0,0,0,1606,1604,1,0,0,0,1607,139,1,0,0,0,1608,1609,3,144,72,0,1609, + 1615,6,70,-1,0,1610,1611,3,142,71,0,1611,1612,6,70,-1,0,1612,1614,1,0, + 0,0,1613,1610,1,0,0,0,1614,1617,1,0,0,0,1615,1613,1,0,0,0,1615,1616,1, + 0,0,0,1616,141,1,0,0,0,1617,1615,1,0,0,0,1618,1619,5,261,0,0,1619,1648, + 6,71,-1,0,1620,1621,5,42,0,0,1621,1622,5,43,0,0,1622,1648,6,71,-1,0,1623, + 1624,3,112,56,0,1624,1625,6,71,-1,0,1625,1648,1,0,0,0,1626,1627,5,260, + 0,0,1627,1648,6,71,-1,0,1628,1629,5,262,0,0,1629,1648,6,71,-1,0,1630,1631, + 5,92,0,0,1631,1648,6,71,-1,0,1632,1633,5,93,0,0,1633,1634,5,30,0,0,1634, + 1635,3,126,63,0,1635,1636,5,31,0,0,1636,1637,6,71,-1,0,1637,1648,1,0,0, + 0,1638,1639,5,94,0,0,1639,1640,5,30,0,0,1640,1641,3,126,63,0,1641,1642, + 5,31,0,0,1642,1643,6,71,-1,0,1643,1648,1,0,0,0,1644,1645,3,110,55,0,1645, + 1646,6,71,-1,0,1646,1648,1,0,0,0,1647,1618,1,0,0,0,1647,1620,1,0,0,0,1647, + 1623,1,0,0,0,1647,1626,1,0,0,0,1647,1628,1,0,0,0,1647,1630,1,0,0,0,1647, + 1632,1,0,0,0,1647,1638,1,0,0,0,1647,1644,1,0,0,0,1648,143,1,0,0,0,1649, + 1650,5,39,0,0,1650,1651,3,118,59,0,1651,1652,6,72,-1,0,1652,1708,1,0,0, + 0,1653,1654,5,197,0,0,1654,1708,6,72,-1,0,1655,1656,5,199,0,0,1656,1657, + 5,39,0,0,1657,1658,3,118,59,0,1658,1659,6,72,-1,0,1659,1708,1,0,0,0,1660, + 1661,5,200,0,0,1661,1662,3,118,59,0,1662,1663,6,72,-1,0,1663,1708,1,0, + 0,0,1664,1665,5,226,0,0,1665,1666,3,172,86,0,1666,1667,3,140,70,0,1667, + 1668,5,262,0,0,1668,1669,3,114,57,0,1669,1670,6,72,-1,0,1670,1708,1,0, + 0,0,1671,1672,5,253,0,0,1672,1673,3,32,16,0,1673,1674,6,72,-1,0,1674,1708, + 1,0,0,0,1675,1676,5,252,0,0,1676,1677,3,32,16,0,1677,1678,6,72,-1,0,1678, + 1708,1,0,0,0,1679,1680,5,253,0,0,1680,1681,3,2,1,0,1681,1682,6,72,-1,0, + 1682,1708,1,0,0,0,1683,1684,5,252,0,0,1684,1685,3,2,1,0,1685,1686,6,72, + -1,0,1686,1708,1,0,0,0,1687,1688,5,254,0,0,1688,1708,6,72,-1,0,1689,1690, + 5,201,0,0,1690,1708,6,72,-1,0,1691,1692,3,150,75,0,1692,1693,6,72,-1,0, + 1693,1708,1,0,0,0,1694,1695,3,152,76,0,1695,1696,6,72,-1,0,1696,1708,1, + 0,0,0,1697,1698,3,146,73,0,1698,1699,6,72,-1,0,1699,1708,1,0,0,0,1700, + 1701,3,2,1,0,1701,1702,6,72,-1,0,1702,1708,1,0,0,0,1703,1704,5,177,0,0, + 1704,1705,3,140,70,0,1705,1706,6,72,-1,0,1706,1708,1,0,0,0,1707,1649,1, + 0,0,0,1707,1653,1,0,0,0,1707,1655,1,0,0,0,1707,1660,1,0,0,0,1707,1664, + 1,0,0,0,1707,1671,1,0,0,0,1707,1675,1,0,0,0,1707,1679,1,0,0,0,1707,1683, + 1,0,0,0,1707,1687,1,0,0,0,1707,1689,1,0,0,0,1707,1691,1,0,0,0,1707,1694, + 1,0,0,0,1707,1697,1,0,0,0,1707,1700,1,0,0,0,1707,1703,1,0,0,0,1708,145, + 1,0,0,0,1709,1710,5,181,0,0,1710,1748,6,73,-1,0,1711,1712,5,182,0,0,1712, + 1748,6,73,-1,0,1713,1714,5,183,0,0,1714,1748,6,73,-1,0,1715,1716,5,184, + 0,0,1716,1748,6,73,-1,0,1717,1718,5,185,0,0,1718,1748,6,73,-1,0,1719,1720, + 5,186,0,0,1720,1748,6,73,-1,0,1721,1722,5,187,0,0,1722,1748,6,73,-1,0, + 1723,1724,5,188,0,0,1724,1748,6,73,-1,0,1725,1726,5,189,0,0,1726,1748, + 6,73,-1,0,1727,1728,5,190,0,0,1728,1748,6,73,-1,0,1729,1730,5,191,0,0, + 1730,1748,6,73,-1,0,1731,1732,5,192,0,0,1732,1748,6,73,-1,0,1733,1734, + 5,193,0,0,1734,1748,6,73,-1,0,1735,1736,5,90,0,0,1736,1737,5,184,0,0,1737, + 1748,6,73,-1,0,1738,1739,5,90,0,0,1739,1740,5,185,0,0,1740,1748,6,73,-1, + 0,1741,1742,5,90,0,0,1742,1743,5,186,0,0,1743,1748,6,73,-1,0,1744,1745, + 5,90,0,0,1745,1746,5,187,0,0,1746,1748,6,73,-1,0,1747,1709,1,0,0,0,1747, + 1711,1,0,0,0,1747,1713,1,0,0,0,1747,1715,1,0,0,0,1747,1717,1,0,0,0,1747, + 1719,1,0,0,0,1747,1721,1,0,0,0,1747,1723,1,0,0,0,1747,1725,1,0,0,0,1747, + 1727,1,0,0,0,1747,1729,1,0,0,0,1747,1731,1,0,0,0,1747,1733,1,0,0,0,1747, + 1735,1,0,0,0,1747,1738,1,0,0,0,1747,1741,1,0,0,0,1747,1744,1,0,0,0,1748, + 147,1,0,0,0,1749,1764,1,0,0,0,1750,1764,5,177,0,0,1751,1752,3,32,16,0, + 1752,1753,6,74,-1,0,1753,1764,1,0,0,0,1754,1755,3,32,16,0,1755,1756,5, + 177,0,0,1756,1757,3,32,16,0,1757,1758,6,74,-1,0,1758,1764,1,0,0,0,1759, + 1760,3,32,16,0,1760,1761,5,177,0,0,1761,1762,6,74,-1,0,1762,1764,1,0,0, + 0,1763,1749,1,0,0,0,1763,1750,1,0,0,0,1763,1751,1,0,0,0,1763,1754,1,0, + 0,0,1763,1759,1,0,0,0,1764,149,1,0,0,0,1765,1766,5,1,0,0,1766,1767,5,194, + 0,0,1767,1768,6,75,-1,0,1768,151,1,0,0,0,1769,1773,5,1,0,0,1770,1771,5, + 90,0,0,1771,1774,5,194,0,0,1772,1774,5,195,0,0,1773,1770,1,0,0,0,1773, + 1772,1,0,0,0,1774,1775,1,0,0,0,1775,1776,6,76,-1,0,1776,153,1,0,0,0,1777, + 1778,5,294,0,0,1778,1779,3,168,84,0,1779,1780,3,126,63,0,1780,1781,5,30, + 0,0,1781,1782,3,160,80,0,1782,1783,5,31,0,0,1783,1784,6,77,-1,0,1784,1832, + 1,0,0,0,1785,1786,5,294,0,0,1786,1787,3,168,84,0,1787,1788,3,126,63,0, + 1788,1789,5,36,0,0,1789,1790,5,17,0,0,1790,1791,3,52,26,0,1791,1792,5, + 18,0,0,1792,1793,6,77,-1,0,1793,1832,1,0,0,0,1794,1795,5,294,0,0,1795, + 1796,3,168,84,0,1796,1797,3,126,63,0,1797,1798,6,77,-1,0,1798,1832,1,0, + 0,0,1799,1800,5,295,0,0,1800,1801,3,168,84,0,1801,1803,5,36,0,0,1802,1804, + 5,84,0,0,1803,1802,1,0,0,0,1803,1804,1,0,0,0,1804,1805,1,0,0,0,1805,1806, + 5,30,0,0,1806,1807,3,302,151,0,1807,1808,5,31,0,0,1808,1809,6,77,-1,0, + 1809,1832,1,0,0,0,1810,1811,5,295,0,0,1811,1812,3,168,84,0,1812,1813,5, + 84,0,0,1813,1814,5,30,0,0,1814,1815,3,302,151,0,1815,1816,5,31,0,0,1816, + 1817,6,77,-1,0,1817,1832,1,0,0,0,1818,1819,5,295,0,0,1819,1820,3,168,84, + 0,1820,1821,3,6,3,0,1821,1822,6,77,-1,0,1822,1832,1,0,0,0,1823,1824,5, + 295,0,0,1824,1825,3,168,84,0,1825,1826,5,36,0,0,1826,1827,5,17,0,0,1827, + 1828,3,156,78,0,1828,1829,5,18,0,0,1829,1830,6,77,-1,0,1830,1832,1,0,0, + 0,1831,1777,1,0,0,0,1831,1785,1,0,0,0,1831,1794,1,0,0,0,1831,1799,1,0, + 0,0,1831,1810,1,0,0,0,1831,1818,1,0,0,0,1831,1823,1,0,0,0,1832,155,1,0, + 0,0,1833,1847,1,0,0,0,1834,1835,3,158,79,0,1835,1836,6,78,-1,0,1836,1837, + 5,28,0,0,1837,1839,1,0,0,0,1838,1834,1,0,0,0,1839,1842,1,0,0,0,1840,1838, + 1,0,0,0,1840,1841,1,0,0,0,1841,1843,1,0,0,0,1842,1840,1,0,0,0,1843,1844, + 3,158,79,0,1844,1845,6,78,-1,0,1845,1847,1,0,0,0,1846,1833,1,0,0,0,1846, + 1840,1,0,0,0,1847,157,1,0,0,0,1848,1849,5,39,0,0,1849,1850,5,264,0,0,1850, + 1851,5,36,0,0,1851,1852,5,17,0,0,1852,1853,3,56,28,0,1853,1854,5,18,0, + 0,1854,1855,6,79,-1,0,1855,1864,1,0,0,0,1856,1857,3,126,63,0,1857,1858, + 5,36,0,0,1858,1859,5,17,0,0,1859,1860,3,56,28,0,1860,1861,5,18,0,0,1861, + 1862,6,79,-1,0,1862,1864,1,0,0,0,1863,1848,1,0,0,0,1863,1856,1,0,0,0,1864, + 159,1,0,0,0,1865,1866,3,162,81,0,1866,1867,6,80,-1,0,1867,1868,5,28,0, + 0,1868,1870,1,0,0,0,1869,1865,1,0,0,0,1870,1873,1,0,0,0,1871,1869,1,0, + 0,0,1871,1872,1,0,0,0,1872,1874,1,0,0,0,1873,1871,1,0,0,0,1874,1875,3, + 162,81,0,1875,1876,6,80,-1,0,1876,161,1,0,0,0,1877,1878,3,6,3,0,1878,1879, + 5,36,0,0,1879,1880,3,166,83,0,1880,1881,6,81,-1,0,1881,163,1,0,0,0,1882, + 1883,7,9,0,0,1883,165,1,0,0,0,1884,1885,3,164,82,0,1885,1886,6,83,-1,0, + 1886,1930,1,0,0,0,1887,1888,3,32,16,0,1888,1889,6,83,-1,0,1889,1930,1, + 0,0,0,1890,1891,5,186,0,0,1891,1892,5,30,0,0,1892,1893,3,32,16,0,1893, + 1894,5,31,0,0,1894,1895,6,83,-1,0,1895,1930,1,0,0,0,1896,1897,3,6,3,0, + 1897,1898,6,83,-1,0,1898,1930,1,0,0,0,1899,1900,3,118,59,0,1900,1901,5, + 30,0,0,1901,1902,5,184,0,0,1902,1903,5,75,0,0,1903,1904,3,32,16,0,1904, + 1905,5,31,0,0,1905,1906,6,83,-1,0,1906,1930,1,0,0,0,1907,1908,3,118,59, + 0,1908,1909,5,30,0,0,1909,1910,5,185,0,0,1910,1911,5,75,0,0,1911,1912, + 3,32,16,0,1912,1913,5,31,0,0,1913,1914,6,83,-1,0,1914,1930,1,0,0,0,1915, + 1916,3,118,59,0,1916,1917,5,30,0,0,1917,1918,5,186,0,0,1918,1919,5,75, + 0,0,1919,1920,3,32,16,0,1920,1921,5,31,0,0,1921,1922,6,83,-1,0,1922,1930, + 1,0,0,0,1923,1924,3,118,59,0,1924,1925,5,30,0,0,1925,1926,3,32,16,0,1926, + 1927,5,31,0,0,1927,1928,6,83,-1,0,1928,1930,1,0,0,0,1929,1884,1,0,0,0, + 1929,1887,1,0,0,0,1929,1890,1,0,0,0,1929,1896,1,0,0,0,1929,1899,1,0,0, + 0,1929,1907,1,0,0,0,1929,1915,1,0,0,0,1929,1923,1,0,0,0,1930,167,1,0,0, + 0,1931,1932,7,10,0,0,1932,169,1,0,0,0,1933,1934,3,172,86,0,1934,1935,3, + 140,70,0,1935,1936,3,126,63,0,1936,1937,5,176,0,0,1937,1939,3,244,122, + 0,1938,1940,3,110,55,0,1939,1938,1,0,0,0,1939,1940,1,0,0,0,1940,1941,1, + 0,0,0,1941,1942,3,114,57,0,1942,1943,6,85,-1,0,1943,1976,1,0,0,0,1944, + 1945,3,172,86,0,1945,1946,3,140,70,0,1946,1947,3,126,63,0,1947,1948,5, + 176,0,0,1948,1949,3,244,122,0,1949,1950,3,198,99,0,1950,1951,3,114,57, + 0,1951,1952,6,85,-1,0,1952,1976,1,0,0,0,1953,1954,3,172,86,0,1954,1955, + 3,140,70,0,1955,1957,3,244,122,0,1956,1958,3,110,55,0,1957,1956,1,0,0, + 0,1957,1958,1,0,0,0,1958,1959,1,0,0,0,1959,1960,3,114,57,0,1960,1961,6, + 85,-1,0,1961,1976,1,0,0,0,1962,1963,3,172,86,0,1963,1964,3,140,70,0,1964, + 1965,3,244,122,0,1965,1966,3,198,99,0,1966,1967,3,114,57,0,1967,1968,6, + 85,-1,0,1968,1976,1,0,0,0,1969,1970,3,176,88,0,1970,1971,6,85,-1,0,1971, + 1976,1,0,0,0,1972,1973,3,2,1,0,1973,1974,6,85,-1,0,1974,1976,1,0,0,0,1975, + 1933,1,0,0,0,1975,1944,1,0,0,0,1975,1953,1,0,0,0,1975,1962,1,0,0,0,1975, + 1969,1,0,0,0,1975,1972,1,0,0,0,1976,171,1,0,0,0,1977,1978,5,243,0,0,1978, + 1979,3,172,86,0,1979,1980,6,86,-1,0,1980,1995,1,0,0,0,1981,1982,5,244, + 0,0,1982,1983,3,172,86,0,1983,1984,6,86,-1,0,1984,1995,1,0,0,0,1985,1986, + 3,174,87,0,1986,1987,6,86,-1,0,1987,1995,1,0,0,0,1988,1989,5,112,0,0,1989, + 1990,5,30,0,0,1990,1991,3,32,16,0,1991,1992,5,31,0,0,1992,1993,6,86,-1, + 0,1993,1995,1,0,0,0,1994,1977,1,0,0,0,1994,1981,1,0,0,0,1994,1985,1,0, + 0,0,1994,1988,1,0,0,0,1995,173,1,0,0,0,1996,2016,1,0,0,0,1997,1998,5,245, + 0,0,1998,2016,6,87,-1,0,1999,2000,5,246,0,0,2000,2016,6,87,-1,0,2001,2002, + 5,247,0,0,2002,2003,5,248,0,0,2003,2016,6,87,-1,0,2004,2005,5,247,0,0, + 2005,2006,5,249,0,0,2006,2016,6,87,-1,0,2007,2008,5,247,0,0,2008,2009, + 5,250,0,0,2009,2016,6,87,-1,0,2010,2011,5,247,0,0,2011,2012,5,251,0,0, + 2012,2016,6,87,-1,0,2013,2014,5,247,0,0,2014,2016,6,87,-1,0,2015,1996, + 1,0,0,0,2015,1997,1,0,0,0,2015,1999,1,0,0,0,2015,2001,1,0,0,0,2015,2004, + 1,0,0,0,2015,2007,1,0,0,0,2015,2010,1,0,0,0,2015,2013,1,0,0,0,2016,175, + 1,0,0,0,2017,2018,5,113,0,0,2018,2019,5,30,0,0,2019,2020,3,32,16,0,2020, + 2021,5,31,0,0,2021,2022,6,88,-1,0,2022,177,1,0,0,0,2023,2024,5,226,0,0, + 2024,2025,3,170,85,0,2025,2026,6,89,-1,0,2026,2035,1,0,0,0,2027,2028,5, + 37,0,0,2028,2029,3,180,90,0,2029,2030,6,89,-1,0,2030,2035,1,0,0,0,2031, + 2032,3,176,88,0,2032,2033,6,89,-1,0,2033,2035,1,0,0,0,2034,2023,1,0,0, + 0,2034,2027,1,0,0,0,2034,2031,1,0,0,0,2035,179,1,0,0,0,2036,2037,3,140, + 70,0,2037,2038,3,126,63,0,2038,2039,5,176,0,0,2039,2040,3,2,1,0,2040,2041, + 6,90,-1,0,2041,2050,1,0,0,0,2042,2043,3,140,70,0,2043,2044,3,2,1,0,2044, + 2045,6,90,-1,0,2045,2050,1,0,0,0,2046,2047,3,2,1,0,2047,2048,6,90,-1,0, + 2048,2050,1,0,0,0,2049,2036,1,0,0,0,2049,2042,1,0,0,0,2049,2046,1,0,0, + 0,2050,181,1,0,0,0,2051,2052,3,126,63,0,2052,2053,6,91,-1,0,2053,2054, + 5,28,0,0,2054,2056,1,0,0,0,2055,2051,1,0,0,0,2056,2059,1,0,0,0,2057,2055, + 1,0,0,0,2057,2058,1,0,0,0,2058,2060,1,0,0,0,2059,2057,1,0,0,0,2060,2061, + 3,126,63,0,2061,2062,6,91,-1,0,2062,183,1,0,0,0,2063,2070,1,0,0,0,2064, + 2065,5,86,0,0,2065,2066,3,192,96,0,2066,2067,5,87,0,0,2067,2068,6,92,-1, + 0,2068,2070,1,0,0,0,2069,2063,1,0,0,0,2069,2064,1,0,0,0,2070,185,1,0,0, + 0,2071,2072,5,266,0,0,2072,2090,6,93,-1,0,2073,2074,5,114,0,0,2074,2090, + 6,93,-1,0,2075,2076,5,39,0,0,2076,2090,6,93,-1,0,2077,2078,5,200,0,0,2078, + 2090,6,93,-1,0,2079,2080,5,115,0,0,2080,2090,6,93,-1,0,2081,2082,5,116, + 0,0,2082,2090,6,93,-1,0,2083,2084,5,70,0,0,2084,2085,5,30,0,0,2085,2086, + 3,32,16,0,2086,2087,5,31,0,0,2087,2088,6,93,-1,0,2088,2090,1,0,0,0,2089, + 2071,1,0,0,0,2089,2073,1,0,0,0,2089,2075,1,0,0,0,2089,2077,1,0,0,0,2089, + 2079,1,0,0,0,2089,2081,1,0,0,0,2089,2083,1,0,0,0,2090,187,1,0,0,0,2091, + 2092,3,186,93,0,2092,2093,6,94,-1,0,2093,2095,1,0,0,0,2094,2091,1,0,0, + 0,2095,2098,1,0,0,0,2096,2094,1,0,0,0,2096,2097,1,0,0,0,2097,189,1,0,0, + 0,2098,2096,1,0,0,0,2099,2101,3,188,94,0,2100,2102,3,194,97,0,2101,2100, + 1,0,0,0,2101,2102,1,0,0,0,2102,2103,1,0,0,0,2103,2104,3,2,1,0,2104,2105, + 6,95,-1,0,2105,191,1,0,0,0,2106,2107,3,190,95,0,2107,2108,6,96,-1,0,2108, + 2109,5,28,0,0,2109,2111,1,0,0,0,2110,2106,1,0,0,0,2111,2114,1,0,0,0,2112, + 2110,1,0,0,0,2112,2113,1,0,0,0,2113,2115,1,0,0,0,2114,2112,1,0,0,0,2115, + 2116,3,190,95,0,2116,2117,6,96,-1,0,2117,193,1,0,0,0,2118,2119,5,30,0, + 0,2119,2120,3,182,91,0,2120,2121,5,31,0,0,2121,2122,6,97,-1,0,2122,195, + 1,0,0,0,2123,2125,3,198,99,0,2124,2123,1,0,0,0,2124,2125,1,0,0,0,2125, + 2126,1,0,0,0,2126,2127,6,98,-1,0,2127,197,1,0,0,0,2128,2129,5,86,0,0,2129, + 2130,5,42,0,0,2130,2131,3,32,16,0,2131,2132,5,43,0,0,2132,2133,5,87,0, + 0,2133,2134,6,99,-1,0,2134,199,1,0,0,0,2135,2136,3,236,118,0,2136,2137, + 5,17,0,0,2137,2138,3,248,124,0,2138,2139,5,18,0,0,2139,2286,1,0,0,0,2140, + 2141,3,76,38,0,2141,2142,5,17,0,0,2142,2143,3,84,42,0,2143,2144,5,18,0, + 0,2144,2286,1,0,0,0,2145,2146,3,212,106,0,2146,2147,6,100,-1,0,2147,2148, + 5,17,0,0,2148,2149,3,216,108,0,2149,2150,5,18,0,0,2150,2286,1,0,0,0,2151, + 2152,3,220,110,0,2152,2153,6,100,-1,0,2153,2154,5,17,0,0,2154,2155,3,224, + 112,0,2155,2156,5,18,0,0,2156,2286,1,0,0,0,2157,2286,3,202,101,0,2158, + 2159,3,286,143,0,2159,2160,6,100,-1,0,2160,2286,1,0,0,0,2161,2162,3,154, + 77,0,2162,2163,6,100,-1,0,2163,2286,1,0,0,0,2164,2165,3,90,45,0,2165,2166, + 6,100,-1,0,2166,2286,1,0,0,0,2167,2168,3,332,166,0,2168,2169,6,100,-1, + 0,2169,2286,1,0,0,0,2170,2171,5,117,0,0,2171,2172,3,32,16,0,2172,2173, + 6,100,-1,0,2173,2286,1,0,0,0,2174,2175,5,118,0,0,2175,2176,3,32,16,0,2176, + 2177,6,100,-1,0,2177,2286,1,0,0,0,2178,2179,3,348,174,0,2179,2180,5,17, + 0,0,2180,2181,3,354,177,0,2181,2182,5,18,0,0,2182,2183,6,100,-1,0,2183, + 2286,1,0,0,0,2184,2185,5,302,0,0,2185,2186,3,126,63,0,2186,2187,5,176, + 0,0,2187,2188,3,244,122,0,2188,2189,5,119,0,0,2189,2190,3,172,86,0,2190, + 2191,3,140,70,0,2191,2192,3,126,63,0,2192,2193,5,176,0,0,2193,2194,3,244, + 122,0,2194,2195,3,114,57,0,2195,2196,6,100,-1,0,2196,2286,1,0,0,0,2197, + 2198,5,302,0,0,2198,2199,5,226,0,0,2199,2200,3,172,86,0,2200,2201,3,140, + 70,0,2201,2202,3,126,63,0,2202,2203,5,176,0,0,2203,2204,3,244,122,0,2204, + 2205,3,196,98,0,2205,2206,3,114,57,0,2206,2207,5,119,0,0,2207,2208,5,226, + 0,0,2208,2209,3,172,86,0,2209,2210,3,140,70,0,2210,2211,3,126,63,0,2211, + 2212,5,176,0,0,2212,2213,3,244,122,0,2213,2214,3,196,98,0,2214,2215,3, + 114,57,0,2215,2216,6,100,-1,0,2216,2286,1,0,0,0,2217,2218,3,26,13,0,2218, + 2219,6,100,-1,0,2219,2286,1,0,0,0,2220,2221,3,40,20,0,2221,2222,6,100, + -1,0,2222,2286,1,0,0,0,2223,2224,5,255,0,0,2224,2225,5,196,0,0,2225,2226, + 5,42,0,0,2226,2227,3,32,16,0,2227,2228,5,43,0,0,2228,2234,6,100,-1,0,2229, + 2230,3,332,166,0,2230,2231,6,100,-1,0,2231,2233,1,0,0,0,2232,2229,1,0, + 0,0,2233,2236,1,0,0,0,2234,2232,1,0,0,0,2234,2235,1,0,0,0,2235,2286,1, + 0,0,0,2236,2234,1,0,0,0,2237,2238,5,255,0,0,2238,2239,5,196,0,0,2239,2240, + 3,2,1,0,2240,2246,6,100,-1,0,2241,2242,3,332,166,0,2242,2243,6,100,-1, + 0,2243,2245,1,0,0,0,2244,2241,1,0,0,0,2245,2248,1,0,0,0,2246,2244,1,0, + 0,0,2246,2247,1,0,0,0,2247,2286,1,0,0,0,2248,2246,1,0,0,0,2249,2250,5, + 255,0,0,2250,2251,5,256,0,0,2251,2252,5,42,0,0,2252,2253,3,32,16,0,2253, + 2254,5,43,0,0,2254,2255,5,28,0,0,2255,2256,3,126,63,0,2256,2262,6,100, + -1,0,2257,2258,3,332,166,0,2258,2259,6,100,-1,0,2259,2261,1,0,0,0,2260, + 2257,1,0,0,0,2261,2264,1,0,0,0,2262,2260,1,0,0,0,2262,2263,1,0,0,0,2263, + 2286,1,0,0,0,2264,2262,1,0,0,0,2265,2266,5,255,0,0,2266,2267,5,256,0,0, + 2267,2268,3,2,1,0,2268,2269,5,28,0,0,2269,2270,3,126,63,0,2270,2276,6, + 100,-1,0,2271,2272,3,332,166,0,2272,2273,6,100,-1,0,2273,2275,1,0,0,0, + 2274,2271,1,0,0,0,2275,2278,1,0,0,0,2276,2274,1,0,0,0,2276,2277,1,0,0, + 0,2277,2286,1,0,0,0,2278,2276,1,0,0,0,2279,2280,5,120,0,0,2280,2281,5, + 196,0,0,2281,2282,3,126,63,0,2282,2283,3,44,22,0,2283,2284,6,100,-1,0, + 2284,2286,1,0,0,0,2285,2135,1,0,0,0,2285,2140,1,0,0,0,2285,2145,1,0,0, + 0,2285,2151,1,0,0,0,2285,2157,1,0,0,0,2285,2158,1,0,0,0,2285,2161,1,0, + 0,0,2285,2164,1,0,0,0,2285,2167,1,0,0,0,2285,2170,1,0,0,0,2285,2174,1, + 0,0,0,2285,2178,1,0,0,0,2285,2184,1,0,0,0,2285,2197,1,0,0,0,2285,2217, + 1,0,0,0,2285,2220,1,0,0,0,2285,2223,1,0,0,0,2285,2237,1,0,0,0,2285,2249, + 1,0,0,0,2285,2265,1,0,0,0,2285,2279,1,0,0,0,2286,201,1,0,0,0,2287,2288, + 5,121,0,0,2288,2300,3,210,105,0,2289,2290,3,204,102,0,2290,2291,6,101, + -1,0,2291,2299,1,0,0,0,2292,2293,5,122,0,0,2293,2294,5,30,0,0,2294,2295, + 3,230,115,0,2295,2296,5,31,0,0,2296,2297,6,101,-1,0,2297,2299,1,0,0,0, + 2298,2289,1,0,0,0,2298,2292,1,0,0,0,2299,2302,1,0,0,0,2300,2298,1,0,0, + 0,2300,2301,1,0,0,0,2301,2303,1,0,0,0,2302,2300,1,0,0,0,2303,2304,3,140, + 70,0,2304,2305,3,2,1,0,2305,2306,3,206,103,0,2306,2307,3,208,104,0,2307, + 2308,6,101,-1,0,2308,203,1,0,0,0,2309,2310,5,123,0,0,2310,2344,6,102,-1, + 0,2311,2312,5,51,0,0,2312,2344,6,102,-1,0,2313,2314,5,52,0,0,2314,2344, + 6,102,-1,0,2315,2316,5,63,0,0,2316,2344,6,102,-1,0,2317,2318,5,124,0,0, + 2318,2344,6,102,-1,0,2319,2320,5,69,0,0,2320,2344,6,102,-1,0,2321,2322, + 5,68,0,0,2322,2344,6,102,-1,0,2323,2324,5,64,0,0,2324,2344,6,102,-1,0, + 2325,2326,5,65,0,0,2326,2344,6,102,-1,0,2327,2328,5,66,0,0,2328,2344,6, + 102,-1,0,2329,2330,5,125,0,0,2330,2344,6,102,-1,0,2331,2332,5,126,0,0, + 2332,2344,6,102,-1,0,2333,2334,5,127,0,0,2334,2344,6,102,-1,0,2335,2336, + 5,16,0,0,2336,2344,6,102,-1,0,2337,2338,5,70,0,0,2338,2339,5,30,0,0,2339, + 2340,3,32,16,0,2340,2341,5,31,0,0,2341,2342,6,102,-1,0,2342,2344,1,0,0, + 0,2343,2309,1,0,0,0,2343,2311,1,0,0,0,2343,2313,1,0,0,0,2343,2315,1,0, + 0,0,2343,2317,1,0,0,0,2343,2319,1,0,0,0,2343,2321,1,0,0,0,2343,2323,1, + 0,0,0,2343,2325,1,0,0,0,2343,2327,1,0,0,0,2343,2329,1,0,0,0,2343,2331, + 1,0,0,0,2343,2333,1,0,0,0,2343,2335,1,0,0,0,2343,2337,1,0,0,0,2344,205, + 1,0,0,0,2345,2355,1,0,0,0,2346,2347,5,44,0,0,2347,2348,3,0,0,0,2348,2349, + 6,103,-1,0,2349,2355,1,0,0,0,2350,2351,5,44,0,0,2351,2352,3,32,16,0,2352, + 2353,6,103,-1,0,2353,2355,1,0,0,0,2354,2345,1,0,0,0,2354,2346,1,0,0,0, + 2354,2350,1,0,0,0,2355,207,1,0,0,0,2356,2362,1,0,0,0,2357,2358,5,36,0, + 0,2358,2359,3,306,153,0,2359,2360,6,104,-1,0,2360,2362,1,0,0,0,2361,2356, + 1,0,0,0,2361,2357,1,0,0,0,2362,209,1,0,0,0,2363,2370,1,0,0,0,2364,2365, + 5,42,0,0,2365,2366,3,32,16,0,2366,2367,5,43,0,0,2367,2368,6,105,-1,0,2368, + 2370,1,0,0,0,2369,2363,1,0,0,0,2369,2364,1,0,0,0,2370,211,1,0,0,0,2371, + 2377,5,128,0,0,2372,2373,3,214,107,0,2373,2374,6,106,-1,0,2374,2376,1, + 0,0,0,2375,2372,1,0,0,0,2376,2379,1,0,0,0,2377,2375,1,0,0,0,2377,2378, + 1,0,0,0,2378,2380,1,0,0,0,2379,2377,1,0,0,0,2380,2381,3,126,63,0,2381, + 2382,3,2,1,0,2382,2383,6,106,-1,0,2383,2397,1,0,0,0,2384,2390,5,128,0, + 0,2385,2386,3,214,107,0,2386,2387,6,106,-1,0,2387,2389,1,0,0,0,2388,2385, + 1,0,0,0,2389,2392,1,0,0,0,2390,2388,1,0,0,0,2390,2391,1,0,0,0,2391,2393, + 1,0,0,0,2392,2390,1,0,0,0,2393,2394,3,2,1,0,2394,2395,6,106,-1,0,2395, + 2397,1,0,0,0,2396,2371,1,0,0,0,2396,2384,1,0,0,0,2397,213,1,0,0,0,2398, + 2399,5,69,0,0,2399,2403,6,107,-1,0,2400,2401,5,68,0,0,2401,2403,6,107, + -1,0,2402,2398,1,0,0,0,2402,2400,1,0,0,0,2403,215,1,0,0,0,2404,2406,3, + 218,109,0,2405,2404,1,0,0,0,2406,2409,1,0,0,0,2407,2405,1,0,0,0,2407,2408, + 1,0,0,0,2408,217,1,0,0,0,2409,2407,1,0,0,0,2410,2411,5,129,0,0,2411,2412, + 3,170,85,0,2412,2413,6,109,-1,0,2413,2437,1,0,0,0,2414,2415,5,130,0,0, + 2415,2416,3,170,85,0,2416,2417,6,109,-1,0,2417,2437,1,0,0,0,2418,2419, + 5,131,0,0,2419,2420,3,170,85,0,2420,2421,6,109,-1,0,2421,2437,1,0,0,0, + 2422,2423,5,132,0,0,2423,2424,3,170,85,0,2424,2425,6,109,-1,0,2425,2437, + 1,0,0,0,2426,2427,3,90,45,0,2427,2428,6,109,-1,0,2428,2437,1,0,0,0,2429, + 2430,3,332,166,0,2430,2431,6,109,-1,0,2431,2437,1,0,0,0,2432,2433,3,26, + 13,0,2433,2434,6,109,-1,0,2434,2437,1,0,0,0,2435,2437,3,40,20,0,2436,2410, + 1,0,0,0,2436,2414,1,0,0,0,2436,2418,1,0,0,0,2436,2422,1,0,0,0,2436,2426, + 1,0,0,0,2436,2429,1,0,0,0,2436,2432,1,0,0,0,2436,2435,1,0,0,0,2437,219, + 1,0,0,0,2438,2444,5,133,0,0,2439,2440,3,222,111,0,2440,2441,6,110,-1,0, + 2441,2443,1,0,0,0,2442,2439,1,0,0,0,2443,2446,1,0,0,0,2444,2442,1,0,0, + 0,2444,2445,1,0,0,0,2445,2447,1,0,0,0,2446,2444,1,0,0,0,2447,2448,3,172, + 86,0,2448,2449,3,140,70,0,2449,2450,3,2,1,0,2450,2451,3,114,57,0,2451, + 2452,3,208,104,0,2452,2453,6,110,-1,0,2453,221,1,0,0,0,2454,2455,5,69, + 0,0,2455,2459,6,111,-1,0,2456,2457,5,68,0,0,2457,2459,6,111,-1,0,2458, + 2454,1,0,0,0,2458,2456,1,0,0,0,2459,223,1,0,0,0,2460,2462,3,226,113,0, + 2461,2460,1,0,0,0,2462,2465,1,0,0,0,2463,2461,1,0,0,0,2463,2464,1,0,0, + 0,2464,225,1,0,0,0,2465,2463,1,0,0,0,2466,2467,5,134,0,0,2467,2468,3,170, + 85,0,2468,2469,6,113,-1,0,2469,2489,1,0,0,0,2470,2471,5,135,0,0,2471,2472, + 3,170,85,0,2472,2473,6,113,-1,0,2473,2489,1,0,0,0,2474,2475,5,132,0,0, + 2475,2476,3,170,85,0,2476,2477,6,113,-1,0,2477,2489,1,0,0,0,2478,2479, + 3,332,166,0,2479,2480,6,113,-1,0,2480,2489,1,0,0,0,2481,2482,3,90,45,0, + 2482,2483,6,113,-1,0,2483,2489,1,0,0,0,2484,2485,3,26,13,0,2485,2486,6, + 113,-1,0,2486,2489,1,0,0,0,2487,2489,3,40,20,0,2488,2466,1,0,0,0,2488, + 2470,1,0,0,0,2488,2474,1,0,0,0,2488,2478,1,0,0,0,2488,2481,1,0,0,0,2488, + 2484,1,0,0,0,2488,2487,1,0,0,0,2489,227,1,0,0,0,2490,2498,6,114,-1,0,2491, + 2492,5,122,0,0,2492,2493,5,30,0,0,2493,2494,3,230,115,0,2494,2495,5,31, + 0,0,2495,2496,6,114,-1,0,2496,2498,1,0,0,0,2497,2490,1,0,0,0,2497,2491, + 1,0,0,0,2498,229,1,0,0,0,2499,2500,3,128,64,0,2500,2501,6,115,-1,0,2501, + 2513,1,0,0,0,2502,2506,5,17,0,0,2503,2504,3,304,152,0,2504,2505,6,115, + -1,0,2505,2507,1,0,0,0,2506,2503,1,0,0,0,2507,2508,1,0,0,0,2508,2506,1, + 0,0,0,2508,2509,1,0,0,0,2509,2510,1,0,0,0,2510,2511,5,18,0,0,2511,2513, + 1,0,0,0,2512,2499,1,0,0,0,2512,2502,1,0,0,0,2513,231,1,0,0,0,2514,2515, + 3,234,117,0,2515,2516,6,116,-1,0,2516,2518,1,0,0,0,2517,2514,1,0,0,0,2518, + 2521,1,0,0,0,2519,2517,1,0,0,0,2519,2520,1,0,0,0,2520,233,1,0,0,0,2521, + 2519,1,0,0,0,2522,2523,5,42,0,0,2523,2524,5,136,0,0,2524,2525,5,43,0,0, + 2525,2540,6,117,-1,0,2526,2527,5,42,0,0,2527,2528,5,137,0,0,2528,2529, + 5,43,0,0,2529,2540,6,117,-1,0,2530,2531,5,42,0,0,2531,2532,5,138,0,0,2532, + 2533,5,43,0,0,2533,2540,6,117,-1,0,2534,2535,5,42,0,0,2535,2536,3,32,16, + 0,2536,2537,5,43,0,0,2537,2538,6,117,-1,0,2538,2540,1,0,0,0,2539,2522, + 1,0,0,0,2539,2526,1,0,0,0,2539,2530,1,0,0,0,2539,2534,1,0,0,0,2540,235, + 1,0,0,0,2541,2550,5,139,0,0,2542,2543,3,238,119,0,2543,2544,6,118,-1,0, + 2544,2549,1,0,0,0,2545,2546,3,240,120,0,2546,2547,6,118,-1,0,2547,2549, + 1,0,0,0,2548,2542,1,0,0,0,2548,2545,1,0,0,0,2549,2552,1,0,0,0,2550,2548, + 1,0,0,0,2550,2551,1,0,0,0,2551,2553,1,0,0,0,2552,2550,1,0,0,0,2553,2554, + 3,172,86,0,2554,2555,3,232,116,0,2555,2556,3,140,70,0,2556,2557,3,228, + 114,0,2557,2558,3,244,122,0,2558,2559,3,184,92,0,2559,2565,3,114,57,0, + 2560,2561,3,246,123,0,2561,2562,6,118,-1,0,2562,2564,1,0,0,0,2563,2560, + 1,0,0,0,2564,2567,1,0,0,0,2565,2563,1,0,0,0,2565,2566,1,0,0,0,2566,2568, + 1,0,0,0,2567,2565,1,0,0,0,2568,2569,6,118,-1,0,2569,237,1,0,0,0,2570,2571, + 5,123,0,0,2571,2613,6,119,-1,0,2572,2573,5,51,0,0,2573,2613,6,119,-1,0, + 2574,2575,5,52,0,0,2575,2613,6,119,-1,0,2576,2577,5,63,0,0,2577,2613,6, + 119,-1,0,2578,2579,5,140,0,0,2579,2613,6,119,-1,0,2580,2581,5,68,0,0,2581, + 2613,6,119,-1,0,2582,2583,5,141,0,0,2583,2613,6,119,-1,0,2584,2585,5,142, + 0,0,2585,2613,6,119,-1,0,2586,2587,5,54,0,0,2587,2613,6,119,-1,0,2588, + 2589,5,64,0,0,2589,2613,6,119,-1,0,2590,2591,5,65,0,0,2591,2613,6,119, + -1,0,2592,2593,5,66,0,0,2593,2613,6,119,-1,0,2594,2595,5,125,0,0,2595, + 2613,6,119,-1,0,2596,2597,5,143,0,0,2597,2613,6,119,-1,0,2598,2599,5,144, + 0,0,2599,2613,6,119,-1,0,2600,2601,5,69,0,0,2601,2613,6,119,-1,0,2602, + 2603,5,145,0,0,2603,2613,6,119,-1,0,2604,2605,5,146,0,0,2605,2613,6,119, + -1,0,2606,2607,5,70,0,0,2607,2608,5,30,0,0,2608,2609,3,32,16,0,2609,2610, + 5,31,0,0,2610,2611,6,119,-1,0,2611,2613,1,0,0,0,2612,2570,1,0,0,0,2612, + 2572,1,0,0,0,2612,2574,1,0,0,0,2612,2576,1,0,0,0,2612,2578,1,0,0,0,2612, + 2580,1,0,0,0,2612,2582,1,0,0,0,2612,2584,1,0,0,0,2612,2586,1,0,0,0,2612, + 2588,1,0,0,0,2612,2590,1,0,0,0,2612,2592,1,0,0,0,2612,2594,1,0,0,0,2612, + 2596,1,0,0,0,2612,2598,1,0,0,0,2612,2600,1,0,0,0,2612,2602,1,0,0,0,2612, + 2604,1,0,0,0,2612,2606,1,0,0,0,2613,239,1,0,0,0,2614,2615,5,147,0,0,2615, + 2624,5,30,0,0,2616,2617,3,6,3,0,2617,2622,6,120,-1,0,2618,2619,5,34,0, + 0,2619,2620,3,6,3,0,2620,2621,6,120,-1,0,2621,2623,1,0,0,0,2622,2618,1, + 0,0,0,2622,2623,1,0,0,0,2623,2625,1,0,0,0,2624,2616,1,0,0,0,2624,2625, + 1,0,0,0,2625,2631,1,0,0,0,2626,2627,3,242,121,0,2627,2628,6,120,-1,0,2628, + 2630,1,0,0,0,2629,2626,1,0,0,0,2630,2633,1,0,0,0,2631,2629,1,0,0,0,2631, + 2632,1,0,0,0,2632,2634,1,0,0,0,2633,2631,1,0,0,0,2634,2638,5,31,0,0,2635, + 2636,5,147,0,0,2636,2638,5,85,0,0,2637,2614,1,0,0,0,2637,2635,1,0,0,0, + 2638,241,1,0,0,0,2639,2640,5,148,0,0,2640,2682,6,121,-1,0,2641,2642,5, + 224,0,0,2642,2682,6,121,-1,0,2643,2644,5,57,0,0,2644,2682,6,121,-1,0,2645, + 2646,5,58,0,0,2646,2682,6,121,-1,0,2647,2648,5,149,0,0,2648,2682,6,121, + -1,0,2649,2650,5,150,0,0,2650,2682,6,121,-1,0,2651,2652,5,248,0,0,2652, + 2682,6,121,-1,0,2653,2654,5,249,0,0,2654,2682,6,121,-1,0,2655,2656,5,250, + 0,0,2656,2682,6,121,-1,0,2657,2658,5,251,0,0,2658,2682,6,121,-1,0,2659, + 2660,5,151,0,0,2660,2661,5,75,0,0,2661,2662,5,152,0,0,2662,2682,6,121, + -1,0,2663,2664,5,151,0,0,2664,2665,5,75,0,0,2665,2666,5,153,0,0,2666,2682, + 6,121,-1,0,2667,2668,5,154,0,0,2668,2669,5,75,0,0,2669,2670,5,152,0,0, + 2670,2682,6,121,-1,0,2671,2672,5,154,0,0,2672,2673,5,75,0,0,2673,2674, + 5,153,0,0,2674,2682,6,121,-1,0,2675,2676,5,70,0,0,2676,2677,5,30,0,0,2677, + 2678,3,32,16,0,2678,2679,5,31,0,0,2679,2680,6,121,-1,0,2680,2682,1,0,0, + 0,2681,2639,1,0,0,0,2681,2641,1,0,0,0,2681,2643,1,0,0,0,2681,2645,1,0, + 0,0,2681,2647,1,0,0,0,2681,2649,1,0,0,0,2681,2651,1,0,0,0,2681,2653,1, + 0,0,0,2681,2655,1,0,0,0,2681,2657,1,0,0,0,2681,2659,1,0,0,0,2681,2663, + 1,0,0,0,2681,2667,1,0,0,0,2681,2671,1,0,0,0,2681,2675,1,0,0,0,2682,243, + 1,0,0,0,2683,2684,5,116,0,0,2684,2691,6,122,-1,0,2685,2686,5,155,0,0,2686, + 2691,6,122,-1,0,2687,2688,3,2,1,0,2688,2689,6,122,-1,0,2689,2691,1,0,0, + 0,2690,2683,1,0,0,0,2690,2685,1,0,0,0,2690,2687,1,0,0,0,2691,245,1,0,0, + 0,2692,2693,5,1,0,0,2693,2731,6,123,-1,0,2694,2695,5,2,0,0,2695,2731,6, + 123,-1,0,2696,2697,5,156,0,0,2697,2731,6,123,-1,0,2698,2699,5,3,0,0,2699, + 2731,6,123,-1,0,2700,2701,5,4,0,0,2701,2731,6,123,-1,0,2702,2703,5,247, + 0,0,2703,2731,6,123,-1,0,2704,2705,5,5,0,0,2705,2731,6,123,-1,0,2706,2707, + 5,6,0,0,2707,2731,6,123,-1,0,2708,2709,5,7,0,0,2709,2731,6,123,-1,0,2710, + 2711,5,8,0,0,2711,2731,6,123,-1,0,2712,2713,5,9,0,0,2713,2731,6,123,-1, + 0,2714,2715,5,10,0,0,2715,2731,6,123,-1,0,2716,2717,5,11,0,0,2717,2731, + 6,123,-1,0,2718,2719,5,12,0,0,2719,2731,6,123,-1,0,2720,2721,5,13,0,0, + 2721,2731,6,123,-1,0,2722,2723,5,14,0,0,2723,2731,6,123,-1,0,2724,2725, + 5,70,0,0,2725,2726,5,30,0,0,2726,2727,3,32,16,0,2727,2728,5,31,0,0,2728, + 2729,6,123,-1,0,2729,2731,1,0,0,0,2730,2692,1,0,0,0,2730,2694,1,0,0,0, + 2730,2696,1,0,0,0,2730,2698,1,0,0,0,2730,2700,1,0,0,0,2730,2702,1,0,0, + 0,2730,2704,1,0,0,0,2730,2706,1,0,0,0,2730,2708,1,0,0,0,2730,2710,1,0, + 0,0,2730,2712,1,0,0,0,2730,2714,1,0,0,0,2730,2716,1,0,0,0,2730,2718,1, + 0,0,0,2730,2720,1,0,0,0,2730,2722,1,0,0,0,2730,2724,1,0,0,0,2731,247,1, + 0,0,0,2732,2734,3,250,125,0,2733,2732,1,0,0,0,2734,2737,1,0,0,0,2735,2733, + 1,0,0,0,2735,2736,1,0,0,0,2736,249,1,0,0,0,2737,2735,1,0,0,0,2738,2776, + 3,102,51,0,2739,2740,5,296,0,0,2740,2741,3,32,16,0,2741,2742,6,125,-1, + 0,2742,2776,1,0,0,0,2743,2776,3,268,134,0,2744,2745,5,297,0,0,2745,2746, + 3,32,16,0,2746,2747,6,125,-1,0,2747,2776,1,0,0,0,2748,2749,5,298,0,0,2749, + 2776,6,125,-1,0,2750,2751,5,299,0,0,2751,2776,6,125,-1,0,2752,2776,3,262, + 131,0,2753,2776,3,266,133,0,2754,2776,3,252,126,0,2755,2756,3,286,143, + 0,2756,2757,6,125,-1,0,2757,2776,1,0,0,0,2758,2759,3,154,77,0,2759,2760, + 6,125,-1,0,2760,2776,1,0,0,0,2761,2762,3,90,45,0,2762,2763,6,125,-1,0, + 2763,2776,1,0,0,0,2764,2765,3,26,13,0,2765,2766,6,125,-1,0,2766,2776,1, + 0,0,0,2767,2768,3,264,132,0,2768,2769,6,125,-1,0,2769,2776,1,0,0,0,2770, + 2776,3,40,20,0,2771,2776,3,254,127,0,2772,2776,3,256,128,0,2773,2776,3, + 258,129,0,2774,2776,3,260,130,0,2775,2738,1,0,0,0,2775,2739,1,0,0,0,2775, + 2743,1,0,0,0,2775,2744,1,0,0,0,2775,2748,1,0,0,0,2775,2750,1,0,0,0,2775, + 2752,1,0,0,0,2775,2753,1,0,0,0,2775,2754,1,0,0,0,2775,2755,1,0,0,0,2775, + 2758,1,0,0,0,2775,2761,1,0,0,0,2775,2764,1,0,0,0,2775,2767,1,0,0,0,2775, + 2770,1,0,0,0,2775,2771,1,0,0,0,2775,2772,1,0,0,0,2775,2773,1,0,0,0,2775, + 2774,1,0,0,0,2776,251,1,0,0,0,2777,2779,5,300,0,0,2778,2780,5,157,0,0, + 2779,2778,1,0,0,0,2779,2780,1,0,0,0,2780,2781,1,0,0,0,2781,2782,3,114, + 57,0,2782,253,1,0,0,0,2783,2784,5,301,0,0,2784,2785,5,42,0,0,2785,2786, + 3,32,16,0,2786,2789,5,43,0,0,2787,2788,5,34,0,0,2788,2790,3,0,0,0,2789, + 2787,1,0,0,0,2789,2790,1,0,0,0,2790,255,1,0,0,0,2791,2792,5,303,0,0,2792, + 2793,3,32,16,0,2793,2794,5,75,0,0,2794,2795,3,32,16,0,2795,257,1,0,0,0, + 2796,2797,5,302,0,0,2797,2798,3,126,63,0,2798,2799,5,176,0,0,2799,2800, + 3,244,122,0,2800,2812,1,0,0,0,2801,2802,5,302,0,0,2802,2803,5,226,0,0, + 2803,2804,3,172,86,0,2804,2805,3,140,70,0,2805,2806,3,126,63,0,2806,2807, + 5,176,0,0,2807,2808,3,244,122,0,2808,2809,3,196,98,0,2809,2810,3,114,57, + 0,2810,2812,1,0,0,0,2811,2796,1,0,0,0,2811,2801,1,0,0,0,2812,259,1,0,0, + 0,2813,2814,5,255,0,0,2814,2815,5,196,0,0,2815,2816,5,42,0,0,2816,2817, + 3,32,16,0,2817,2823,5,43,0,0,2818,2819,3,332,166,0,2819,2820,6,130,-1, + 0,2820,2822,1,0,0,0,2821,2818,1,0,0,0,2822,2825,1,0,0,0,2823,2821,1,0, + 0,0,2823,2824,1,0,0,0,2824,2879,1,0,0,0,2825,2823,1,0,0,0,2826,2827,5, + 255,0,0,2827,2828,5,196,0,0,2828,2834,3,2,1,0,2829,2830,3,332,166,0,2830, + 2831,6,130,-1,0,2831,2833,1,0,0,0,2832,2829,1,0,0,0,2833,2836,1,0,0,0, + 2834,2832,1,0,0,0,2834,2835,1,0,0,0,2835,2879,1,0,0,0,2836,2834,1,0,0, + 0,2837,2838,5,255,0,0,2838,2839,5,256,0,0,2839,2840,5,42,0,0,2840,2841, + 3,32,16,0,2841,2842,5,43,0,0,2842,2843,5,28,0,0,2843,2849,3,126,63,0,2844, + 2845,3,332,166,0,2845,2846,6,130,-1,0,2846,2848,1,0,0,0,2847,2844,1,0, + 0,0,2848,2851,1,0,0,0,2849,2847,1,0,0,0,2849,2850,1,0,0,0,2850,2879,1, + 0,0,0,2851,2849,1,0,0,0,2852,2853,5,255,0,0,2853,2854,5,256,0,0,2854,2855, + 3,2,1,0,2855,2856,5,28,0,0,2856,2862,3,126,63,0,2857,2858,3,332,166,0, + 2858,2859,6,130,-1,0,2859,2861,1,0,0,0,2860,2857,1,0,0,0,2861,2864,1,0, + 0,0,2862,2860,1,0,0,0,2862,2863,1,0,0,0,2863,2879,1,0,0,0,2864,2862,1, + 0,0,0,2865,2866,5,255,0,0,2866,2867,5,42,0,0,2867,2868,3,32,16,0,2868, + 2869,5,43,0,0,2869,2875,3,208,104,0,2870,2871,3,332,166,0,2871,2872,6, + 130,-1,0,2872,2874,1,0,0,0,2873,2870,1,0,0,0,2874,2877,1,0,0,0,2875,2873, + 1,0,0,0,2875,2876,1,0,0,0,2876,2879,1,0,0,0,2877,2875,1,0,0,0,2878,2813, + 1,0,0,0,2878,2826,1,0,0,0,2878,2837,1,0,0,0,2878,2852,1,0,0,0,2878,2865, + 1,0,0,0,2879,261,1,0,0,0,2880,2881,3,0,0,0,2881,2882,5,75,0,0,2882,2883, + 6,131,-1,0,2883,263,1,0,0,0,2884,2885,3,44,22,0,2885,2886,6,132,-1,0,2886, + 2891,1,0,0,0,2887,2888,3,46,23,0,2888,2889,6,132,-1,0,2889,2891,1,0,0, + 0,2890,2884,1,0,0,0,2890,2887,1,0,0,0,2891,265,1,0,0,0,2892,2893,5,17, + 0,0,2893,2894,3,248,124,0,2894,2895,5,18,0,0,2895,267,1,0,0,0,2896,2897, + 3,272,136,0,2897,2898,3,270,135,0,2898,269,1,0,0,0,2899,2900,3,274,137, + 0,2900,2901,6,135,-1,0,2901,2903,1,0,0,0,2902,2899,1,0,0,0,2903,2904,1, + 0,0,0,2904,2902,1,0,0,0,2904,2905,1,0,0,0,2905,271,1,0,0,0,2906,2907,5, + 158,0,0,2907,2908,3,266,133,0,2908,2909,6,136,-1,0,2909,2923,1,0,0,0,2910, + 2911,5,158,0,0,2911,2912,3,0,0,0,2912,2913,5,159,0,0,2913,2914,3,0,0,0, + 2914,2915,6,136,-1,0,2915,2923,1,0,0,0,2916,2917,5,158,0,0,2917,2918,3, + 32,16,0,2918,2919,5,159,0,0,2919,2920,3,32,16,0,2920,2921,6,136,-1,0,2921, + 2923,1,0,0,0,2922,2906,1,0,0,0,2922,2910,1,0,0,0,2922,2916,1,0,0,0,2923, + 273,1,0,0,0,2924,2925,3,278,139,0,2925,2926,3,284,142,0,2926,2927,6,137, + -1,0,2927,2941,1,0,0,0,2928,2929,3,276,138,0,2929,2930,3,284,142,0,2930, + 2931,6,137,-1,0,2931,2941,1,0,0,0,2932,2933,3,280,140,0,2933,2934,3,284, + 142,0,2934,2935,6,137,-1,0,2935,2941,1,0,0,0,2936,2937,3,282,141,0,2937, + 2938,3,284,142,0,2938,2939,6,137,-1,0,2939,2941,1,0,0,0,2940,2924,1,0, + 0,0,2940,2928,1,0,0,0,2940,2932,1,0,0,0,2940,2936,1,0,0,0,2941,275,1,0, + 0,0,2942,2943,5,160,0,0,2943,2944,3,266,133,0,2944,2945,6,138,-1,0,2945, + 2955,1,0,0,0,2946,2947,5,160,0,0,2947,2948,3,0,0,0,2948,2949,6,138,-1, + 0,2949,2955,1,0,0,0,2950,2951,5,160,0,0,2951,2952,3,32,16,0,2952,2953, + 6,138,-1,0,2953,2955,1,0,0,0,2954,2942,1,0,0,0,2954,2946,1,0,0,0,2954, + 2950,1,0,0,0,2955,277,1,0,0,0,2956,2957,5,161,0,0,2957,2958,3,126,63,0, + 2958,279,1,0,0,0,2959,2960,5,162,0,0,2960,281,1,0,0,0,2961,2962,5,163, + 0,0,2962,283,1,0,0,0,2963,2964,3,266,133,0,2964,2965,6,142,-1,0,2965,2979, + 1,0,0,0,2966,2967,5,164,0,0,2967,2968,3,0,0,0,2968,2969,5,159,0,0,2969, + 2970,3,0,0,0,2970,2971,6,142,-1,0,2971,2979,1,0,0,0,2972,2973,5,164,0, + 0,2973,2974,3,32,16,0,2974,2975,5,159,0,0,2975,2976,3,32,16,0,2976,2977, + 6,142,-1,0,2977,2979,1,0,0,0,2978,2963,1,0,0,0,2978,2966,1,0,0,0,2978, + 2972,1,0,0,0,2979,285,1,0,0,0,2980,2981,3,288,144,0,2981,2982,3,292,146, + 0,2982,287,1,0,0,0,2983,2984,5,165,0,0,2984,2985,3,290,145,0,2985,2986, + 3,0,0,0,2986,2987,5,36,0,0,2987,2988,6,144,-1,0,2988,2994,1,0,0,0,2989, + 2990,5,165,0,0,2990,2991,3,290,145,0,2991,2992,6,144,-1,0,2992,2994,1, + 0,0,0,2993,2983,1,0,0,0,2993,2989,1,0,0,0,2994,289,1,0,0,0,2995,3001,1, + 0,0,0,2996,2997,5,166,0,0,2997,3001,6,145,-1,0,2998,2999,5,2,0,0,2999, + 3001,6,145,-1,0,3000,2995,1,0,0,0,3000,2996,1,0,0,0,3000,2998,1,0,0,0, + 3001,291,1,0,0,0,3002,3003,5,17,0,0,3003,3004,3,294,147,0,3004,3005,5, + 18,0,0,3005,3012,1,0,0,0,3006,3008,3,298,149,0,3007,3006,1,0,0,0,3008, + 3009,1,0,0,0,3009,3007,1,0,0,0,3009,3010,1,0,0,0,3010,3012,1,0,0,0,3011, + 3002,1,0,0,0,3011,3007,1,0,0,0,3012,293,1,0,0,0,3013,3014,3,298,149,0, + 3014,3015,5,28,0,0,3015,3017,1,0,0,0,3016,3013,1,0,0,0,3017,3020,1,0,0, + 0,3018,3016,1,0,0,0,3018,3019,1,0,0,0,3019,3021,1,0,0,0,3020,3018,1,0, + 0,0,3021,3022,3,298,149,0,3022,295,1,0,0,0,3023,3030,1,0,0,0,3024,3025, + 5,42,0,0,3025,3026,3,32,16,0,3026,3027,5,43,0,0,3027,3028,6,148,-1,0,3028, + 3030,1,0,0,0,3029,3023,1,0,0,0,3029,3024,1,0,0,0,3030,297,1,0,0,0,3031, + 3032,5,181,0,0,3032,3033,5,262,0,0,3033,3034,5,30,0,0,3034,3035,3,6,3, + 0,3035,3036,5,31,0,0,3036,3037,6,149,-1,0,3037,3080,1,0,0,0,3038,3039, + 5,260,0,0,3039,3040,5,30,0,0,3040,3041,3,0,0,0,3041,3042,5,31,0,0,3042, + 3043,6,149,-1,0,3043,3080,1,0,0,0,3044,3045,5,260,0,0,3045,3046,3,0,0, + 0,3046,3047,6,149,-1,0,3047,3080,1,0,0,0,3048,3049,5,84,0,0,3049,3050, + 5,30,0,0,3050,3051,3,302,151,0,3051,3052,5,31,0,0,3052,3053,6,149,-1,0, + 3053,3080,1,0,0,0,3054,3055,7,11,0,0,3055,3056,5,30,0,0,3056,3057,3,36, + 18,0,3057,3058,5,31,0,0,3058,3059,3,296,148,0,3059,3060,6,149,-1,0,3060, + 3080,1,0,0,0,3061,3062,5,187,0,0,3062,3063,5,30,0,0,3063,3064,3,34,17, + 0,3064,3065,5,31,0,0,3065,3066,3,296,148,0,3066,3067,6,149,-1,0,3067,3080, + 1,0,0,0,3068,3069,7,12,0,0,3069,3070,5,30,0,0,3070,3071,3,32,16,0,3071, + 3072,5,31,0,0,3072,3073,3,296,148,0,3073,3074,6,149,-1,0,3074,3080,1,0, + 0,0,3075,3076,7,13,0,0,3076,3077,3,296,148,0,3077,3078,6,149,-1,0,3078, + 3080,1,0,0,0,3079,3031,1,0,0,0,3079,3038,1,0,0,0,3079,3044,1,0,0,0,3079, + 3048,1,0,0,0,3079,3054,1,0,0,0,3079,3061,1,0,0,0,3079,3068,1,0,0,0,3079, + 3075,1,0,0,0,3080,299,1,0,0,0,3081,3082,5,188,0,0,3082,3083,5,30,0,0,3083, + 3084,3,36,18,0,3084,3085,5,31,0,0,3085,3086,6,150,-1,0,3086,3172,1,0,0, + 0,3087,3088,5,189,0,0,3088,3089,5,30,0,0,3089,3090,3,36,18,0,3090,3091, + 5,31,0,0,3091,3092,6,150,-1,0,3092,3172,1,0,0,0,3093,3094,5,188,0,0,3094, + 3095,5,30,0,0,3095,3096,3,32,16,0,3096,3097,5,31,0,0,3097,3098,6,150,-1, + 0,3098,3172,1,0,0,0,3099,3100,5,189,0,0,3100,3101,5,30,0,0,3101,3102,3, + 34,17,0,3102,3103,5,31,0,0,3103,3104,6,150,-1,0,3104,3172,1,0,0,0,3105, + 3106,5,187,0,0,3106,3107,5,30,0,0,3107,3108,3,34,17,0,3108,3109,5,31,0, + 0,3109,3110,6,150,-1,0,3110,3172,1,0,0,0,3111,3112,5,186,0,0,3112,3113, + 5,30,0,0,3113,3114,3,32,16,0,3114,3115,5,31,0,0,3115,3116,6,150,-1,0,3116, + 3172,1,0,0,0,3117,3118,5,185,0,0,3118,3119,5,30,0,0,3119,3120,3,32,16, + 0,3120,3121,5,31,0,0,3121,3122,6,150,-1,0,3122,3172,1,0,0,0,3123,3124, + 5,184,0,0,3124,3125,5,30,0,0,3125,3126,3,32,16,0,3126,3127,5,31,0,0,3127, + 3128,6,150,-1,0,3128,3172,1,0,0,0,3129,3130,5,193,0,0,3130,3131,5,30,0, + 0,3131,3132,3,34,17,0,3132,3133,5,31,0,0,3133,3134,6,150,-1,0,3134,3172, + 1,0,0,0,3135,3136,5,192,0,0,3136,3137,5,30,0,0,3137,3138,3,32,16,0,3138, + 3139,5,31,0,0,3139,3140,6,150,-1,0,3140,3172,1,0,0,0,3141,3142,5,191,0, + 0,3142,3143,5,30,0,0,3143,3144,3,32,16,0,3144,3145,5,31,0,0,3145,3146, + 6,150,-1,0,3146,3172,1,0,0,0,3147,3148,5,190,0,0,3148,3149,5,30,0,0,3149, + 3150,3,32,16,0,3150,3151,5,31,0,0,3151,3152,6,150,-1,0,3152,3172,1,0,0, + 0,3153,3154,5,181,0,0,3154,3155,5,30,0,0,3155,3156,3,32,16,0,3156,3157, + 5,31,0,0,3157,3158,6,150,-1,0,3158,3172,1,0,0,0,3159,3160,5,183,0,0,3160, + 3161,5,30,0,0,3161,3162,3,164,82,0,3162,3163,5,31,0,0,3163,3164,6,150, + -1,0,3164,3172,1,0,0,0,3165,3166,5,84,0,0,3166,3167,5,30,0,0,3167,3168, + 3,302,151,0,3168,3169,5,31,0,0,3169,3170,6,150,-1,0,3170,3172,1,0,0,0, + 3171,3081,1,0,0,0,3171,3087,1,0,0,0,3171,3093,1,0,0,0,3171,3099,1,0,0, + 0,3171,3105,1,0,0,0,3171,3111,1,0,0,0,3171,3117,1,0,0,0,3171,3123,1,0, + 0,0,3171,3129,1,0,0,0,3171,3135,1,0,0,0,3171,3141,1,0,0,0,3171,3147,1, + 0,0,0,3171,3153,1,0,0,0,3171,3159,1,0,0,0,3171,3165,1,0,0,0,3172,301,1, + 0,0,0,3173,3174,3,304,152,0,3174,3175,6,151,-1,0,3175,3177,1,0,0,0,3176, + 3173,1,0,0,0,3177,3180,1,0,0,0,3178,3176,1,0,0,0,3178,3179,1,0,0,0,3179, + 303,1,0,0,0,3180,3178,1,0,0,0,3181,3182,7,14,0,0,3182,305,1,0,0,0,3183, + 3184,3,300,150,0,3184,3185,6,153,-1,0,3185,3192,1,0,0,0,3186,3187,3,6, + 3,0,3187,3188,6,153,-1,0,3188,3192,1,0,0,0,3189,3190,5,179,0,0,3190,3192, + 6,153,-1,0,3191,3183,1,0,0,0,3191,3186,1,0,0,0,3191,3189,1,0,0,0,3192, + 307,1,0,0,0,3193,3194,3,300,150,0,3194,3195,6,154,-1,0,3195,3365,1,0,0, + 0,3196,3197,5,182,0,0,3197,3198,5,30,0,0,3198,3199,5,179,0,0,3199,3200, + 5,31,0,0,3200,3365,6,154,-1,0,3201,3202,5,182,0,0,3202,3203,5,30,0,0,3203, + 3204,5,264,0,0,3204,3205,5,31,0,0,3205,3365,6,154,-1,0,3206,3207,5,196, + 0,0,3207,3208,5,30,0,0,3208,3209,5,39,0,0,3209,3210,5,264,0,0,3210,3211, + 5,31,0,0,3211,3365,6,154,-1,0,3212,3213,5,196,0,0,3213,3214,5,30,0,0,3214, + 3215,3,118,59,0,3215,3216,5,31,0,0,3216,3217,6,154,-1,0,3217,3365,1,0, + 0,0,3218,3219,5,196,0,0,3219,3220,5,30,0,0,3220,3221,5,179,0,0,3221,3222, + 5,31,0,0,3222,3365,6,154,-1,0,3223,3224,5,197,0,0,3224,3225,5,30,0,0,3225, + 3226,3,308,154,0,3226,3227,5,31,0,0,3227,3228,6,154,-1,0,3228,3365,1,0, + 0,0,3229,3230,5,188,0,0,3230,3231,5,42,0,0,3231,3232,3,32,16,0,3232,3233, + 5,43,0,0,3233,3234,5,30,0,0,3234,3235,3,310,155,0,3235,3236,5,31,0,0,3236, + 3237,6,154,-1,0,3237,3365,1,0,0,0,3238,3239,5,189,0,0,3239,3240,5,42,0, + 0,3240,3241,3,32,16,0,3241,3242,5,43,0,0,3242,3243,5,30,0,0,3243,3244, + 3,312,156,0,3244,3245,5,31,0,0,3245,3246,6,154,-1,0,3246,3365,1,0,0,0, + 3247,3248,5,187,0,0,3248,3249,5,42,0,0,3249,3250,3,32,16,0,3250,3251,5, + 43,0,0,3251,3252,5,30,0,0,3252,3253,3,314,157,0,3253,3254,5,31,0,0,3254, + 3255,6,154,-1,0,3255,3365,1,0,0,0,3256,3257,5,186,0,0,3257,3258,5,42,0, + 0,3258,3259,3,32,16,0,3259,3260,5,43,0,0,3260,3261,5,30,0,0,3261,3262, + 3,316,158,0,3262,3263,5,31,0,0,3263,3264,6,154,-1,0,3264,3365,1,0,0,0, + 3265,3266,5,185,0,0,3266,3267,5,42,0,0,3267,3268,3,32,16,0,3268,3269,5, + 43,0,0,3269,3270,5,30,0,0,3270,3271,3,318,159,0,3271,3272,5,31,0,0,3272, + 3273,6,154,-1,0,3273,3365,1,0,0,0,3274,3275,5,184,0,0,3275,3276,5,42,0, + 0,3276,3277,3,32,16,0,3277,3278,5,43,0,0,3278,3279,5,30,0,0,3279,3280, + 3,320,160,0,3280,3281,5,31,0,0,3281,3282,6,154,-1,0,3282,3365,1,0,0,0, + 3283,3284,5,193,0,0,3284,3285,5,42,0,0,3285,3286,3,32,16,0,3286,3287,5, + 43,0,0,3287,3288,5,30,0,0,3288,3289,3,314,157,0,3289,3290,5,31,0,0,3290, + 3291,6,154,-1,0,3291,3365,1,0,0,0,3292,3293,5,192,0,0,3293,3294,5,42,0, + 0,3294,3295,3,32,16,0,3295,3296,5,43,0,0,3296,3297,5,30,0,0,3297,3298, + 3,316,158,0,3298,3299,5,31,0,0,3299,3300,6,154,-1,0,3300,3365,1,0,0,0, + 3301,3302,5,191,0,0,3302,3303,5,42,0,0,3303,3304,3,32,16,0,3304,3305,5, + 43,0,0,3305,3306,5,30,0,0,3306,3307,3,318,159,0,3307,3308,5,31,0,0,3308, + 3309,6,154,-1,0,3309,3365,1,0,0,0,3310,3311,5,190,0,0,3311,3312,5,42,0, + 0,3312,3313,3,32,16,0,3313,3314,5,43,0,0,3314,3315,5,30,0,0,3315,3316, + 3,320,160,0,3316,3317,5,31,0,0,3317,3318,6,154,-1,0,3318,3365,1,0,0,0, + 3319,3320,5,181,0,0,3320,3321,5,42,0,0,3321,3322,3,32,16,0,3322,3323,5, + 43,0,0,3323,3324,5,30,0,0,3324,3325,3,318,159,0,3325,3326,5,31,0,0,3326, + 3327,6,154,-1,0,3327,3365,1,0,0,0,3328,3329,5,183,0,0,3329,3330,5,42,0, + 0,3330,3331,3,32,16,0,3331,3332,5,43,0,0,3332,3333,5,30,0,0,3333,3334, + 3,322,161,0,3334,3335,5,31,0,0,3335,3336,6,154,-1,0,3336,3365,1,0,0,0, + 3337,3338,5,182,0,0,3338,3339,5,42,0,0,3339,3340,3,32,16,0,3340,3341,5, + 43,0,0,3341,3342,5,30,0,0,3342,3343,3,324,162,0,3343,3344,5,31,0,0,3344, + 3345,6,154,-1,0,3345,3365,1,0,0,0,3346,3347,5,196,0,0,3347,3348,5,42,0, + 0,3348,3349,3,32,16,0,3349,3350,5,43,0,0,3350,3351,5,30,0,0,3351,3352, + 3,326,163,0,3352,3353,5,31,0,0,3353,3354,6,154,-1,0,3354,3365,1,0,0,0, + 3355,3356,5,197,0,0,3356,3357,5,42,0,0,3357,3358,3,32,16,0,3358,3359,5, + 43,0,0,3359,3360,5,30,0,0,3360,3361,3,330,165,0,3361,3362,5,31,0,0,3362, + 3363,6,154,-1,0,3363,3365,1,0,0,0,3364,3193,1,0,0,0,3364,3196,1,0,0,0, + 3364,3201,1,0,0,0,3364,3206,1,0,0,0,3364,3212,1,0,0,0,3364,3218,1,0,0, + 0,3364,3223,1,0,0,0,3364,3229,1,0,0,0,3364,3238,1,0,0,0,3364,3247,1,0, + 0,0,3364,3256,1,0,0,0,3364,3265,1,0,0,0,3364,3274,1,0,0,0,3364,3283,1, + 0,0,0,3364,3292,1,0,0,0,3364,3301,1,0,0,0,3364,3310,1,0,0,0,3364,3319, + 1,0,0,0,3364,3328,1,0,0,0,3364,3337,1,0,0,0,3364,3346,1,0,0,0,3364,3355, + 1,0,0,0,3365,309,1,0,0,0,3366,3367,3,36,18,0,3367,3368,6,155,-1,0,3368, + 3373,1,0,0,0,3369,3370,3,32,16,0,3370,3371,6,155,-1,0,3371,3373,1,0,0, + 0,3372,3366,1,0,0,0,3372,3369,1,0,0,0,3373,3376,1,0,0,0,3374,3372,1,0, + 0,0,3374,3375,1,0,0,0,3375,311,1,0,0,0,3376,3374,1,0,0,0,3377,3378,3,36, + 18,0,3378,3379,6,156,-1,0,3379,3384,1,0,0,0,3380,3381,3,34,17,0,3381,3382, + 6,156,-1,0,3382,3384,1,0,0,0,3383,3377,1,0,0,0,3383,3380,1,0,0,0,3384, + 3387,1,0,0,0,3385,3383,1,0,0,0,3385,3386,1,0,0,0,3386,313,1,0,0,0,3387, + 3385,1,0,0,0,3388,3389,3,34,17,0,3389,3390,6,157,-1,0,3390,3392,1,0,0, + 0,3391,3388,1,0,0,0,3392,3395,1,0,0,0,3393,3391,1,0,0,0,3393,3394,1,0, + 0,0,3394,315,1,0,0,0,3395,3393,1,0,0,0,3396,3397,3,32,16,0,3397,3398,6, + 158,-1,0,3398,3400,1,0,0,0,3399,3396,1,0,0,0,3400,3403,1,0,0,0,3401,3399, + 1,0,0,0,3401,3402,1,0,0,0,3402,317,1,0,0,0,3403,3401,1,0,0,0,3404,3405, + 3,32,16,0,3405,3406,6,159,-1,0,3406,3408,1,0,0,0,3407,3404,1,0,0,0,3408, + 3411,1,0,0,0,3409,3407,1,0,0,0,3409,3410,1,0,0,0,3410,319,1,0,0,0,3411, + 3409,1,0,0,0,3412,3413,3,32,16,0,3413,3414,6,160,-1,0,3414,3416,1,0,0, + 0,3415,3412,1,0,0,0,3416,3419,1,0,0,0,3417,3415,1,0,0,0,3417,3418,1,0, + 0,0,3418,321,1,0,0,0,3419,3417,1,0,0,0,3420,3421,3,164,82,0,3421,3422, + 6,161,-1,0,3422,3424,1,0,0,0,3423,3420,1,0,0,0,3424,3427,1,0,0,0,3425, + 3423,1,0,0,0,3425,3426,1,0,0,0,3426,323,1,0,0,0,3427,3425,1,0,0,0,3428, + 3429,5,179,0,0,3429,3433,6,162,-1,0,3430,3431,5,264,0,0,3431,3433,6,162, + -1,0,3432,3428,1,0,0,0,3432,3430,1,0,0,0,3433,3436,1,0,0,0,3434,3432,1, + 0,0,0,3434,3435,1,0,0,0,3435,325,1,0,0,0,3436,3434,1,0,0,0,3437,3438,3, + 328,164,0,3438,3439,6,163,-1,0,3439,3441,1,0,0,0,3440,3437,1,0,0,0,3441, + 3444,1,0,0,0,3442,3440,1,0,0,0,3442,3443,1,0,0,0,3443,327,1,0,0,0,3444, + 3442,1,0,0,0,3445,3446,5,179,0,0,3446,3454,6,164,-1,0,3447,3448,5,39,0, + 0,3448,3449,5,264,0,0,3449,3454,6,164,-1,0,3450,3451,3,118,59,0,3451,3452, + 6,164,-1,0,3452,3454,1,0,0,0,3453,3445,1,0,0,0,3453,3447,1,0,0,0,3453, + 3450,1,0,0,0,3454,329,1,0,0,0,3455,3456,3,308,154,0,3456,3457,6,165,-1, + 0,3457,3459,1,0,0,0,3458,3455,1,0,0,0,3459,3462,1,0,0,0,3460,3458,1,0, + 0,0,3460,3461,1,0,0,0,3461,331,1,0,0,0,3462,3460,1,0,0,0,3463,3464,3,44, + 22,0,3464,3465,6,166,-1,0,3465,3473,1,0,0,0,3466,3467,3,46,23,0,3467,3468, + 6,166,-1,0,3468,3473,1,0,0,0,3469,3470,3,2,1,0,3470,3471,6,166,-1,0,3471, + 3473,1,0,0,0,3472,3463,1,0,0,0,3472,3466,1,0,0,0,3472,3469,1,0,0,0,3473, + 333,1,0,0,0,3474,3475,7,15,0,0,3475,3476,5,36,0,0,3476,3477,5,30,0,0,3477, + 3478,3,302,151,0,3478,3479,5,31,0,0,3479,3480,6,167,-1,0,3480,3507,1,0, + 0,0,3481,3482,5,169,0,0,3482,3483,3,38,19,0,3483,3484,5,75,0,0,3484,3485, + 3,38,19,0,3485,3486,5,75,0,0,3486,3487,3,38,19,0,3487,3488,5,75,0,0,3488, + 3489,3,38,19,0,3489,3490,6,167,-1,0,3490,3507,1,0,0,0,3491,3492,5,170, + 0,0,3492,3493,3,6,3,0,3493,3494,6,167,-1,0,3494,3507,1,0,0,0,3495,3496, + 5,170,0,0,3496,3497,5,36,0,0,3497,3498,5,30,0,0,3498,3499,3,302,151,0, + 3499,3500,5,31,0,0,3500,3501,6,167,-1,0,3501,3507,1,0,0,0,3502,3503,3, + 332,166,0,3503,3504,6,167,-1,0,3504,3507,1,0,0,0,3505,3507,3,40,20,0,3506, + 3474,1,0,0,0,3506,3481,1,0,0,0,3506,3491,1,0,0,0,3506,3495,1,0,0,0,3506, + 3502,1,0,0,0,3506,3505,1,0,0,0,3507,335,1,0,0,0,3508,3509,3,338,169,0, + 3509,3510,5,17,0,0,3510,3511,3,340,170,0,3511,3512,5,18,0,0,3512,3513, + 6,168,-1,0,3513,337,1,0,0,0,3514,3515,5,25,0,0,3515,3516,5,40,0,0,3516, + 3517,3,100,50,0,3517,3518,3,2,1,0,3518,3519,6,169,-1,0,3519,3529,1,0,0, + 0,3520,3521,5,25,0,0,3521,3522,5,40,0,0,3522,3523,3,100,50,0,3523,3524, + 3,2,1,0,3524,3525,5,34,0,0,3525,3526,3,2,1,0,3526,3527,6,169,-1,0,3527, + 3529,1,0,0,0,3528,3514,1,0,0,0,3528,3520,1,0,0,0,3529,339,1,0,0,0,3530, + 3531,3,342,171,0,3531,3532,6,170,-1,0,3532,3534,1,0,0,0,3533,3530,1,0, + 0,0,3534,3537,1,0,0,0,3535,3533,1,0,0,0,3535,3536,1,0,0,0,3536,341,1,0, + 0,0,3537,3535,1,0,0,0,3538,3539,5,180,0,0,3539,3540,5,36,0,0,3540,3541, + 5,30,0,0,3541,3542,3,302,151,0,3542,3543,5,31,0,0,3543,3544,6,171,-1,0, + 3544,3558,1,0,0,0,3545,3546,3,334,167,0,3546,3547,6,171,-1,0,3547,3558, + 1,0,0,0,3548,3549,5,171,0,0,3549,3550,5,36,0,0,3550,3551,5,30,0,0,3551, + 3552,3,302,151,0,3552,3553,5,31,0,0,3553,3554,6,171,-1,0,3554,3558,1,0, + 0,0,3555,3556,5,55,0,0,3556,3558,6,171,-1,0,3557,3538,1,0,0,0,3557,3545, + 1,0,0,0,3557,3548,1,0,0,0,3557,3555,1,0,0,0,3558,343,1,0,0,0,3559,3560, + 3,346,173,0,3560,3561,5,17,0,0,3561,3562,3,354,177,0,3562,3563,5,18,0, + 0,3563,3564,6,172,-1,0,3564,345,1,0,0,0,3565,3566,5,50,0,0,3566,3567,5, + 40,0,0,3567,3568,3,350,175,0,3568,3569,3,2,1,0,3569,3570,6,173,-1,0,3570, + 347,1,0,0,0,3571,3572,5,301,0,0,3572,3573,3,350,175,0,3573,3574,3,2,1, + 0,3574,3575,6,174,-1,0,3575,349,1,0,0,0,3576,3577,3,352,176,0,3577,3578, + 6,175,-1,0,3578,3580,1,0,0,0,3579,3576,1,0,0,0,3580,3583,1,0,0,0,3581, + 3579,1,0,0,0,3581,3582,1,0,0,0,3582,351,1,0,0,0,3583,3581,1,0,0,0,3584, + 3600,5,52,0,0,3585,3600,5,51,0,0,3586,3600,5,172,0,0,3587,3588,5,62,0, + 0,3588,3600,5,51,0,0,3589,3590,5,62,0,0,3590,3600,5,52,0,0,3591,3592,5, + 62,0,0,3592,3600,5,63,0,0,3593,3594,5,62,0,0,3594,3600,5,64,0,0,3595,3596, + 5,62,0,0,3596,3600,5,65,0,0,3597,3598,5,62,0,0,3598,3600,5,66,0,0,3599, + 3584,1,0,0,0,3599,3585,1,0,0,0,3599,3586,1,0,0,0,3599,3587,1,0,0,0,3599, + 3589,1,0,0,0,3599,3591,1,0,0,0,3599,3593,1,0,0,0,3599,3595,1,0,0,0,3599, + 3597,1,0,0,0,3600,353,1,0,0,0,3601,3602,3,356,178,0,3602,3603,6,177,-1, + 0,3603,3605,1,0,0,0,3604,3601,1,0,0,0,3605,3608,1,0,0,0,3606,3604,1,0, + 0,0,3606,3607,1,0,0,0,3607,355,1,0,0,0,3608,3606,1,0,0,0,3609,3610,5,21, + 0,0,3610,3611,3,2,1,0,3611,3612,6,178,-1,0,3612,3635,1,0,0,0,3613,3614, + 5,50,0,0,3614,3615,5,40,0,0,3615,3616,3,120,60,0,3616,3617,6,178,-1,0, + 3617,3635,1,0,0,0,3618,3619,5,25,0,0,3619,3620,5,40,0,0,3620,3621,3,2, + 1,0,3621,3622,6,178,-1,0,3622,3635,1,0,0,0,3623,3624,3,176,88,0,3624,3625, + 6,178,-1,0,3625,3635,1,0,0,0,3626,3627,5,50,0,0,3627,3628,3,32,16,0,3628, + 3629,6,178,-1,0,3629,3635,1,0,0,0,3630,3631,3,332,166,0,3631,3632,6,178, + -1,0,3632,3635,1,0,0,0,3633,3635,3,40,20,0,3634,3609,1,0,0,0,3634,3613, + 1,0,0,0,3634,3618,1,0,0,0,3634,3623,1,0,0,0,3634,3626,1,0,0,0,3634,3630, + 1,0,0,0,3634,3633,1,0,0,0,3635,357,1,0,0,0,3636,3637,3,360,180,0,3637, + 3638,5,17,0,0,3638,3639,3,366,183,0,3639,3640,5,18,0,0,3640,3641,6,179, + -1,0,3641,359,1,0,0,0,3642,3643,5,274,0,0,3643,3644,3,362,181,0,3644,3645, + 3,2,1,0,3645,3646,6,180,-1,0,3646,3655,1,0,0,0,3647,3648,5,274,0,0,3648, + 3649,3,362,181,0,3649,3650,3,2,1,0,3650,3651,5,34,0,0,3651,3652,3,2,1, + 0,3652,3653,6,180,-1,0,3653,3655,1,0,0,0,3654,3642,1,0,0,0,3654,3647,1, + 0,0,0,3655,361,1,0,0,0,3656,3657,3,364,182,0,3657,3658,6,181,-1,0,3658, + 3660,1,0,0,0,3659,3656,1,0,0,0,3660,3663,1,0,0,0,3661,3659,1,0,0,0,3661, + 3662,1,0,0,0,3662,363,1,0,0,0,3663,3661,1,0,0,0,3664,3665,7,16,0,0,3665, + 365,1,0,0,0,3666,3667,3,368,184,0,3667,3668,6,183,-1,0,3668,3670,1,0,0, + 0,3669,3666,1,0,0,0,3670,3673,1,0,0,0,3671,3669,1,0,0,0,3671,3672,1,0, + 0,0,3672,367,1,0,0,0,3673,3671,1,0,0,0,3674,3675,5,21,0,0,3675,3676,3, + 2,1,0,3676,3677,5,44,0,0,3677,3678,3,32,16,0,3678,3679,6,184,-1,0,3679, + 3690,1,0,0,0,3680,3681,5,25,0,0,3681,3682,5,40,0,0,3682,3683,3,2,1,0,3683, + 3684,6,184,-1,0,3684,3690,1,0,0,0,3685,3686,3,332,166,0,3686,3687,6,184, + -1,0,3687,3690,1,0,0,0,3688,3690,3,40,20,0,3689,3674,1,0,0,0,3689,3680, + 1,0,0,0,3689,3685,1,0,0,0,3689,3688,1,0,0,0,3690,369,1,0,0,0,183,380,388, + 397,406,495,546,557,587,594,612,644,672,712,723,733,735,746,748,756,778, + 791,807,831,904,911,918,923,932,943,952,963,974,987,991,999,1015,1022, + 1031,1059,1137,1139,1153,1159,1168,1170,1179,1193,1207,1215,1223,1227, + 1266,1274,1285,1299,1318,1328,1331,1355,1502,1512,1521,1524,1606,1615, + 1647,1707,1747,1763,1773,1803,1831,1840,1846,1863,1871,1929,1939,1957, + 1975,1994,2015,2034,2049,2057,2069,2089,2096,2101,2112,2124,2234,2246, + 2262,2276,2285,2298,2300,2343,2354,2361,2369,2377,2390,2396,2402,2407, + 2436,2444,2458,2463,2488,2497,2508,2512,2519,2539,2548,2550,2565,2612, + 2622,2624,2631,2637,2681,2690,2730,2735,2775,2779,2789,2811,2823,2834, + 2849,2862,2875,2878,2890,2904,2922,2940,2954,2978,2993,3000,3009,3011, + 3018,3029,3079,3171,3178,3191,3364,3372,3374,3383,3385,3393,3401,3409, + 3417,3425,3432,3434,3442,3453,3460,3472,3506,3528,3535,3557,3581,3599, + 3606,3634,3654,3661,3671,3689 }; public static readonly ATN _ATN = diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILVisitor.cs b/src/tools/ilasm/src/ILAssembler/gen/CILVisitor.cs index f7acff204efcf9..ea16aa74a30944 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILVisitor.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILVisitor.cs @@ -243,6 +243,12 @@ public interface ICILVisitor : IParseTreeVisitor { /// The visitor result. Result VisitVtfixupAttr([NotNull] CILParser.VtfixupAttrContext context); /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitVtfixupAttrElement([NotNull] CILParser.VtfixupAttrElementContext context); + /// /// Visit a parse tree produced by . /// /// The parse tree. @@ -1156,6 +1162,12 @@ public interface ICILVisitor : IParseTreeVisitor { /// The visitor result. Result VisitExportHead([NotNull] CILParser.ExportHeadContext context); /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitExptAttrs([NotNull] CILParser.ExptAttrsContext context); + /// /// Visit a parse tree produced by . /// /// The parse tree. @@ -1186,6 +1198,12 @@ public interface ICILVisitor : IParseTreeVisitor { /// The visitor result. Result VisitManifestResHead([NotNull] CILParser.ManifestResHeadContext context); /// + /// Visit a parse tree produced by . + /// + /// The parse tree. + /// The visitor result. + Result VisitManresAttrs([NotNull] CILParser.ManresAttrsContext context); + /// /// Visit a parse tree produced by . /// /// The parse tree. diff --git a/src/tools/ilasm/tests/ILAssembler.Tests/AssemblyTests.cs b/src/tools/ilasm/tests/ILAssembler.Tests/AssemblyTests.cs index e49294241a6d21..91756cb6315b67 100644 --- a/src/tools/ilasm/tests/ILAssembler.Tests/AssemblyTests.cs +++ b/src/tools/ilasm/tests/ILAssembler.Tests/AssemblyTests.cs @@ -305,6 +305,28 @@ .class public auto ansi Test { } } + [Fact] + public void AssemblyLegacyLibraryAttribute_IsAccepted() + { + string source = """ + .assembly extern legacy library dependency { } + .assembly legacy library test { } + .class public auto ansi Test { } + """; + + using var pe = DocumentCompilerTestHelpers.CompileAndGetReader(source, new Options()); + MetadataReader reader = pe.GetMetadataReader(); + + Assert.Equal("test", reader.GetString(reader.GetAssemblyDefinition().Name)); + Assert.Equal( + "dependency", + reader.AssemblyReferences + .Select(reader.GetAssemblyReference) + .Select(reference => reader.GetString(reference.Name)) + .Single(name => name == "dependency")); + } + + [Fact] public void AssemblyArchitecture_SetsArchitectureFlags() { diff --git a/src/tools/ilasm/tests/ILAssembler.Tests/TypedefTests.cs b/src/tools/ilasm/tests/ILAssembler.Tests/TypedefTests.cs index 5f4f3b8fc37d29..e06dacb225d0c5 100644 --- a/src/tools/ilasm/tests/ILAssembler.Tests/TypedefTests.cs +++ b/src/tools/ilasm/tests/ILAssembler.Tests/TypedefTests.cs @@ -175,18 +175,22 @@ ldsfld ValueAlias Assert.Equal(MetadataTokens.GetToken(fieldHandle), fieldToken); - var attributes = reader.GetCustomAttributes(testTypeHandle) + var fieldAttributes = reader.GetCustomAttributes(fieldHandle) .Select(reader.GetCustomAttribute) .Select(attribute => attribute.DecodeValue(DocumentCompilerTestHelpers.Decoder)) .ToArray(); - Assert.Equal(2, attributes.Length); - Assert.Contains(attributes, attribute => attribute.FixedArguments.Length == 0); - Assert.Contains( - attributes, - attribute => - attribute.FixedArguments.Length == 1 && - attribute.FixedArguments[0].Type == "bool" && - Equals(attribute.FixedArguments[0].Value, true)); + CustomAttributeValue fieldAttribute = Assert.Single(fieldAttributes); + Assert.Empty(fieldAttribute.FixedArguments); + + var typeAttributes = reader.GetCustomAttributes(testTypeHandle) + .Select(reader.GetCustomAttribute) + .Select(attribute => attribute.DecodeValue(DocumentCompilerTestHelpers.Decoder)) + .ToArray(); + CustomAttributeValue typeAttribute = Assert.Single(typeAttributes); + CustomAttributeTypedArgument argument = + Assert.Single(typeAttribute.FixedArguments); + Assert.Equal("bool", argument.Type); + Assert.Equal(true, argument.Value); } } From fd2a41300c16b47b9468394c0351403a0c4af9c6 Mon Sep 17 00:00:00 2001 From: Jeremy Koritzinsky Date: Thu, 13 Aug 2026 19:46:27 -0700 Subject: [PATCH 13/16] Compile assembly and manifest directives during parsing Synthesize assembly definitions and references, files, exported types, resources, vtable fixups, and typedefs. Remove the final parse-tree islands so BuildParseTree remains disabled for the complete parse. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: c986c103-8383-4db4-9b11-9be49dc68a05 From 7a676681075ed5bc3fe8edfbdff05c363aafa11d Mon Sep 17 00:00:00 2001 From: Jeremy Koritzinsky Date: Thu, 13 Aug 2026 20:09:53 -0700 Subject: [PATCH 14/16] Stop generating ANTLR visitors for ILAssembler Disable visitor generation and remove the generated visitor interfaces, parser Accept overrides, explicit forwarding methods, and visitor-only dead code. The parser action pipeline now owns all semantic traversal. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: c986c103-8383-4db4-9b11-9be49dc68a05 --- src/tools/ilasm/README.md | 23 +- .../Actions/GrammarActions.BuildImage.cs | 3 +- .../Actions/GrammarActions.Bytes.cs | 20 - .../Actions/GrammarActions.Conversions.cs | 55 +- ...GrammarActions.CustomAttributes.Actions.cs | 76 - ...ammarActions.CustomAttributes.Sequences.cs | 71 - ...rActions.CustomAttributes.Serialization.cs | 47 - .../Actions/GrammarActions.Data.cs | 28 - .../Actions/GrammarActions.Debug.cs | 28 - .../Actions/GrammarActions.Declarations.cs | 18 - .../GrammarActions.Instructions.References.cs | 2 - .../Actions/GrammarActions.Instructions.cs | 8 - .../Actions/GrammarActions.Literals.cs | 64 +- .../GrammarActions.Manifest.Assembly.cs | 28 - .../GrammarActions.Manifest.ExportedTypes.cs | 42 - .../Actions/GrammarActions.Manifest.Files.cs | 15 - .../GrammarActions.Manifest.References.cs | 14 - .../GrammarActions.Manifest.Resources.cs | 44 - .../Actions/GrammarActions.Manifest.VTable.cs | 20 - .../Actions/GrammarActions.Manifest.cs | 35 - .../Actions/GrammarActions.Marshalling.cs | 74 - .../Actions/GrammarActions.Members.Fields.cs | 36 - ...GrammarActions.Members.PropertiesEvents.cs | 40 - .../Actions/GrammarActions.Members.cs | 12 - .../Actions/GrammarActions.MethodBodies.cs | 92 +- .../GrammarActions.MethodHeaders.Generics.cs | 104 - .../Actions/GrammarActions.MethodHeaders.cs | 44 - .../Actions/GrammarActions.Security.cs | 96 - .../GrammarActions.Signatures.Values.cs | 3 - .../Actions/GrammarActions.Signatures.cs | 133 -- .../Actions/GrammarActions.Types.Headers.cs | 40 - .../Actions/GrammarActions.Types.cs | 10 - .../src/ILAssembler/gen/CILBaseVisitor.cs | 2012 ----------------- .../ilasm/src/ILAssembler/gen/CILParser.cs | 1176 ---------- .../ilasm/src/ILAssembler/gen/CILVisitor.cs | 1225 ---------- .../ILAssembler/gen/ilasm-generator.csproj | 1 + 36 files changed, 31 insertions(+), 5708 deletions(-) delete mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.cs delete mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.cs delete mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Marshalling.cs delete mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.cs delete mode 100644 src/tools/ilasm/src/ILAssembler/gen/CILBaseVisitor.cs delete mode 100644 src/tools/ilasm/src/ILAssembler/gen/CILVisitor.cs diff --git a/src/tools/ilasm/README.md b/src/tools/ilasm/README.md index 730a6312fd6f13..c0c381a9e4beae 100644 --- a/src/tools/ilasm/README.md +++ b/src/tools/ilasm/README.md @@ -4,7 +4,8 @@ ILAssembler compiles declarations while ANTLR parses the input. The parser uses `UnbufferedTokenStream` with parse-tree construction disabled. Namespace, type, top-level, class-member, method-body and shared-directive structure is action-driven. A complete document, declaration body or method body is never retained. Rules such as `bytes` stream their content into -an accumulator instead of building a subtree at all. +an accumulator instead of building a subtree at all. The generator emits neither listeners nor +visitors; parser actions own traversal. `GrammarActions` is a single `internal sealed partial class` split across `src/ILAssembler/Actions/GrammarActions.*.cs`: @@ -14,19 +15,17 @@ an accumulator instead of building a subtree at all. | `GrammarActions.cs` | Per-document lifecycle. | | `GrammarActions.BuildImage.cs` | PE and portable PDB construction. | | `GrammarActions.Bytes.cs` | `bytearray` accumulation. | -| `GrammarActions.Conversions.cs` | `GrammarResult`, shared state and core visitor plumbing. | +| `GrammarActions.Conversions.cs` | `GrammarResult`, diagnostics and shared state. | | `GrammarActions.CustomAttributes.Actions.cs` | Custom attribute descriptors, declarations and blob lists. | | `GrammarActions.CustomAttributes.Sequences.cs` | Custom attribute scalar-array sequence synthesis. | | `GrammarActions.CustomAttributes.Serialization.cs` | Serialized attribute values and field/parameter initializers. | | `GrammarActions.CustomAttributes.Values.cs` | Internal synthesized custom attribute value model. | | `GrammarActions.Data.cs` | Streaming mapped-data declarations, labels and reference fixups. | | `GrammarActions.Debug.cs` | Direct source-location, document and language directives. | -| `GrammarActions.Declarations.cs` | Parser-driven top-level declaration visitor guards. | | `GrammarActions.Declarations.Actions.cs` | Direct top-level declarations and shared-directive dispatch. | | `GrammarActions.Instructions.cs` | Tree-free value instruction and method-item actions. | | `GrammarActions.Instructions.References.cs` | Reference and signature instruction actions. | | `GrammarActions.Literals.cs` | Literals, names and strings. | -| `GrammarActions.Manifest.cs` | Module and image-header visitor guards. | | `GrammarActions.Manifest.Assembly.cs` | Assembly definitions, identity, keys, security and attributes. | | `GrammarActions.Manifest.ExportedTypes.cs` | Exported-type headers, implementations and attributes. | | `GrammarActions.Manifest.Files.cs` | Assembly file declarations and entry points. | @@ -36,8 +35,6 @@ an accumulator instead of building a subtree at all. | `GrammarActions.Manifest.Values.cs` | Internal synthesized manifest value model and list frames. | | `GrammarActions.Manifest.VTable.cs` | Vtable fixup declarations and flags. | | `GrammarActions.Marshalling.Actions.cs` | Synthesized native type and marshalling descriptor actions. | -| `GrammarActions.Marshalling.cs` | Marshalling visitor wrappers and P/Invoke conversion. | -| `GrammarActions.Members.cs` | Parser-driven class member visitor guards. | | `GrammarActions.Members.Class.cs` | Class directives, generic parameter annotations and method overrides. | | `GrammarActions.Members.Fields.cs` | Field declarations, attributes, layout, constants, marshalling and RVA data. | | `GrammarActions.Members.PropertiesEvents.cs` | Property and event headers, bodies and accessors. | @@ -46,18 +43,18 @@ an accumulator instead of building a subtree at all. | `GrammarActions.MethodHeaders.Actions.cs` | Method header, attribute, P/Invoke and generic parser actions. | | `GrammarActions.MethodHeaders.Generics.cs` | Generic parameter and constraint synthesis and materialization. | | `GrammarActions.MethodHeaders.Values.cs` | Internal synthesized method-header value model. | -| `GrammarActions.MethodBodies.cs` | Parser-driven method-body visitor guards. | +| `GrammarActions.MethodBodies.cs` | Label validation and method-name parsing. | | `GrammarActions.MethodBodies.Directives.cs` | Direct method-body directives and parameter ownership. | | `GrammarActions.MethodBodies.ExceptionHandling.cs` | Lexical scopes and synthesized exception regions. | | `GrammarActions.MethodBodies.Values.cs` | Internal method-body directive and exception-region values. | | `GrammarActions.Security.cs` | Synthesized declarative-security values and permission sets. | -| `GrammarActions.Signatures.cs` | Signature visitor compatibility wrappers. | +| `GrammarActions.Signatures.cs` | Member and type signature materialization helpers. | | `GrammarActions.Signatures.Actions.cs` | Signature grammar actions and repetition frames. | | `GrammarActions.Signatures.References.cs` | Member-reference synthesis and materialization. | | `GrammarActions.Signatures.Types.cs` | Type-signature materialization and encoding. | | `GrammarActions.Signatures.Values.cs` | Internal synthesized signature value model. | | `GrammarActions.Types.cs` | Namespace and type scope ownership and shared type conversion. | -| `GrammarActions.Types.Headers.cs` | Namespace and type-header materialization and visitor guards. | +| `GrammarActions.Types.Headers.cs` | Namespace and type-header materialization. | | `GrammarActions.Types.Headers.Actions.cs` | Namespace, type attribute, base and interface parser actions. | | `GrammarActions.Types.Headers.Values.cs` | Internal synthesized type-header value model. | | `GrammarActions.Types.References.cs` | Type-name synthesis and resolution. | @@ -87,9 +84,9 @@ the owning context, because ANTLR skips `@after` actions and the remainder of an rule reports a syntax error. Inline actions placed after a subrule reference are not a substitute: they run only when the alternative completes. -Only parser actions walk structural rules. Their recursive `ICILVisitor` entry points either -materialize a synthesized value or throw `UnreachableException`, so there is exactly one live -algorithm and no child walker. +Only parser actions walk structural rules. ANTLR visitors and listeners are not generated. +Ordinary `VisitX` methods are semantic helpers called directly by actions or materializers, not +parse-tree visitor entry points. There is no child walker. ## Build @@ -109,3 +106,5 @@ After modifying `CIL.g4`, regenerate the checked-in ANTLR output before building ``` Do not edit generated `CIL*.cs` or `.interp` files manually. +Regeneration produces `CILLexer.cs` and `CILParser.cs`; it does not produce visitor or listener +types. diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.BuildImage.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.BuildImage.cs index 25988748f5794b..c531ef377a90b8 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.BuildImage.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.BuildImage.cs @@ -18,12 +18,11 @@ using System.Text; using Antlr4.Runtime; using Antlr4.Runtime.Misc; -using Antlr4.Runtime.Tree; namespace ILAssembler { #pragma warning disable CA1822 // Mark members as static - internal sealed partial class GrammarActions : ICILVisitor + internal sealed partial class GrammarActions { public (ImmutableArray Diagnostics, CompilationResult? Image) BuildImage() { diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Bytes.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Bytes.cs index dec3f6b41e252c..2a49a0ec55ab2e 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Bytes.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Bytes.cs @@ -18,7 +18,6 @@ using System.Text; using Antlr4.Runtime; using Antlr4.Runtime.Misc; -using Antlr4.Runtime.Tree; namespace ILAssembler; @@ -66,23 +65,4 @@ internal static byte ParseHexbyte(IToken token) : (byte)0; } -#pragma warning disable CA1822 // Mark members as static - GrammarResult ICILVisitor.VisitBytes(CILParser.BytesContext context) => new GrammarResult.Sequence(VisitBytes(context)); - - /// - /// Returns the bytes the parser accumulated while matching . - /// - /// - /// The bytes rule streams its content into an accumulator instead of building a - /// parse subtree, so the value is read off the context rather than recomputed from children. - /// - public static ImmutableArray VisitBytes(CILParser.BytesContext context) - => context.Value.IsDefault ? ImmutableArray.Empty : context.Value; - - GrammarResult ICILVisitor.VisitHexbyte(CILParser.HexbyteContext context) - { - return new GrammarResult.Literal(context.Value); - } - -#pragma warning restore CA1822 // Mark members as static } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs index fa8b2dfb7f6c66..ce7dfb0245708a 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs @@ -18,7 +18,6 @@ using System.Text; using Antlr4.Runtime; using Antlr4.Runtime.Misc; -using Antlr4.Runtime.Tree; namespace ILAssembler { @@ -30,55 +29,17 @@ public sealed record String(string Value) : GrammarResult; public sealed record Literal(T Value) : GrammarResult; - public sealed record Sequence(ImmutableArray Value) : GrammarResult; - - /// - /// A formatted blob of bytes. - /// - /// The bytes of the blob. - public sealed record FormattedBlob(BlobBuilder Value) : GrammarResult; - public sealed record SentinelValue { public static SentinelValue Instance { get; } = new(); public static Literal Result { get; } = new(Instance); } - - public sealed record Flag(T Value, bool ShouldAppend = true) : GrammarResult - where T : struct, Enum - { - private readonly T _groupMask; - public Flag(T value, bool shouldAppend, T groupMask) - : this(value, shouldAppend) - { - _groupMask = groupMask; - } - public Flag(T value, T groupMask) - : this(value) - { - _groupMask = groupMask; - } - - public static T operator |(T lhs, Flag rhs) - { - if (!rhs.ShouldAppend) - { - return rhs.Value; - } - int lhsInt = Convert.ToInt32(lhs); - int maskInt = Convert.ToInt32(rhs._groupMask); - int valueInt = Convert.ToInt32(rhs.Value); - return (T)Enum.ToObject(typeof(T), (lhsInt & ~maskInt) | valueInt); - } - } } #pragma warning disable CA1822 // Mark members as static - internal sealed partial class GrammarActions : ICILVisitor + internal sealed partial class GrammarActions { - private const string NodeShouldNeverBeDirectlyVisited = "This node should never be directly visited. It should be directly processed by its parent node."; - private const string StructuralNodeIsDrivenByParserActions = "This node is processed incrementally by the parser semantic actions and must never be visited recursively."; private readonly ImmutableArray.Builder _diagnostics = ImmutableArray.CreateBuilder(); private readonly EntityRegistry _entityRegistry = new(); private readonly IReadOnlyDictionary _documents; @@ -169,17 +130,6 @@ or DiagnosticIds.UnknownGenericParameter or DiagnosticIds.MissingInstanceCallConv; } - public GrammarResult Visit(IParseTree tree) => tree.Accept(this); - - public GrammarResult VisitChildren(IRuleNode node) - { - for (int i = 0; i < node.ChildCount; i++) - { - node.GetChild(i).Accept(this); - } - return GrammarResult.SentinelValue.Result; - } - private sealed class CurrentMethodContext { public CurrentMethodContext(EntityRegistry.MethodDefinitionEntity definition) @@ -218,8 +168,6 @@ public CurrentMethodContext(EntityRegistry.MethodDefinitionEntity definition) private readonly Stack _currentTypeDefinition = new(); - public GrammarResult VisitErrorNode(IErrorNode node) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - // Sentinel to distinguish "no constant" from "constant is null" private sealed class NoConstantSentinel { @@ -234,6 +182,5 @@ private NoConstantSentinel() { } private long _imageBase = 0x00400000; private long _stackReserve; - public GrammarResult VisitTerminal(ITerminalNode node) => throw new UnreachableException(); } } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Actions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Actions.cs index cc52485eac84e9..9b10716dc71dd1 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Actions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Actions.cs @@ -290,96 +290,20 @@ private EntityRegistry.CustomAttributeEntity MaterializeCustomAttribute( return descriptor.Owner is null ? attribute : null; } - GrammarResult ICILVisitor.VisitCustomAttrDecl( - CILParser.CustomAttrDeclContext context) - => VisitCustomAttrDecl(context); - public GrammarResult.Literal VisitCustomAttrDecl( CILParser.CustomAttrDeclContext context) => new(MaterializeCustomAttributeDeclaration(context.Value, context.Start)); - GrammarResult ICILVisitor.VisitCustomBlobArgs( - CILParser.CustomBlobArgsContext context) - => VisitCustomBlobArgs(context); - - public GrammarResult.FormattedBlob VisitCustomBlobArgs( - CILParser.CustomBlobArgsContext context) - { - BlobBuilder result = new(); - if (context.Value is ImmutableArray arguments) - { - foreach (SerializedInitializerValue argument in arguments) - { - MaterializeSerializedInitializer(argument).WriteContentTo(result); - } - } - - return new(result); - } - - GrammarResult ICILVisitor.VisitCustomBlobDescr( - CILParser.CustomBlobDescrContext context) - => VisitCustomBlobDescr(context); - - public GrammarResult.FormattedBlob VisitCustomBlobDescr( - CILParser.CustomBlobDescrContext context) - => new(MaterializeCustomAttributeBlob( - context.Value as CustomAttributeBlobValue - ?? new RawCustomAttributeBlobValue(new BlobBuilder()))); - - GrammarResult ICILVisitor.VisitCustomBlobNVPairs( - CILParser.CustomBlobNVPairsContext context) - => VisitCustomBlobNVPairs(context); - - public GrammarResult.FormattedBlob VisitCustomBlobNVPairs( - CILParser.CustomBlobNVPairsContext context) - { - BlobBuilder result = new(); - WriteCustomBlobNamedArguments( - result, - context.Value is ImmutableArray values - ? values - : []); - return new(result); - } - - GrammarResult ICILVisitor.VisitCustomDescr(CILParser.CustomDescrContext context) - => VisitCustomDescr(context); - public GrammarResult.Literal VisitCustomDescr( CILParser.CustomDescrContext context) => new(MaterializeCustomAttribute( GetCustomAttributeDescriptorValue(context.Value), context.Start)); - GrammarResult ICILVisitor.VisitCustomDescrInMethodBody( - CILParser.CustomDescrInMethodBodyContext context) - => VisitCustomDescrInMethodBody(context); - public GrammarResult.Literal VisitCustomDescrInMethodBody( CILParser.CustomDescrInMethodBodyContext context) => new(MaterializeCustomAttributeDeclaration(context.Value, context.Start)); - GrammarResult ICILVisitor.VisitCustomDescrWithOwner( - CILParser.CustomDescrWithOwnerContext context) - => VisitCustomDescrWithOwner(context); - - public GrammarResult.Literal VisitCustomDescrWithOwner( - CILParser.CustomDescrWithOwnerContext context) - => new(MaterializeCustomAttribute( - GetCustomAttributeDescriptorValue(context.Value), - context.Start)); - - GrammarResult ICILVisitor.VisitCustomType(CILParser.CustomTypeContext context) - => VisitCustomType(context); - - public GrammarResult.Literal VisitCustomType( - CILParser.CustomTypeContext context) - => new(MaterializeMethodReference(GetMethodReferenceValue(context.Value))); - - GrammarResult ICILVisitor.VisitOwnerType(CILParser.OwnerTypeContext context) - => VisitOwnerType(context); - public GrammarResult.Literal VisitOwnerType( CILParser.OwnerTypeContext context) => new(MaterializeOwnerType(GetOwnerTypeValue(context.Value))); diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Sequences.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Sequences.cs index 630dfa58baa262..0ae4f6e7f67400 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Sequences.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Sequences.cs @@ -233,75 +233,4 @@ private BlobBuilder MaterializeClassSequenceElement(ClassSequenceElementValue va return blob; } - GrammarResult ICILVisitor.VisitBoolSeq(CILParser.BoolSeqContext context) - => VisitBoolSeq(context); - - public static GrammarResult.FormattedBlob VisitBoolSeq(CILParser.BoolSeqContext context) - => new(context.Value ?? new BlobBuilder()); - - GrammarResult ICILVisitor.VisitClassSeq(CILParser.ClassSeqContext context) - => VisitClassSeq(context); - - public GrammarResult.FormattedBlob VisitClassSeq(CILParser.ClassSeqContext context) - => new(MaterializeSerializedSequence(GetSerializedSequenceValue(context.Value))); - - GrammarResult ICILVisitor.VisitClassSeqElement( - CILParser.ClassSeqElementContext context) - => VisitClassSeqElement(context); - - public GrammarResult.FormattedBlob VisitClassSeqElement( - CILParser.ClassSeqElementContext context) - => new(MaterializeClassSequenceElement( - context.Value as ClassSequenceElementValue - ?? new StringClassSequenceElementValue(null))); - - GrammarResult ICILVisitor.VisitF32seq(CILParser.F32seqContext context) - => VisitF32seq(context); - - public static GrammarResult.FormattedBlob VisitF32seq(CILParser.F32seqContext context) - => new(context.Value ?? new BlobBuilder()); - - GrammarResult ICILVisitor.VisitF64seq(CILParser.F64seqContext context) - => VisitF64seq(context); - - public static GrammarResult.FormattedBlob VisitF64seq(CILParser.F64seqContext context) - => new(context.Value ?? new BlobBuilder()); - - GrammarResult ICILVisitor.VisitI16seq(CILParser.I16seqContext context) - => VisitI16seq(context); - - public static GrammarResult.FormattedBlob VisitI16seq(CILParser.I16seqContext context) - => new(context.Value ?? new BlobBuilder()); - - GrammarResult ICILVisitor.VisitI32seq(CILParser.I32seqContext context) - => VisitI32seq(context); - - public static GrammarResult.FormattedBlob VisitI32seq(CILParser.I32seqContext context) - => new(context.Value ?? new BlobBuilder()); - - GrammarResult ICILVisitor.VisitI64seq(CILParser.I64seqContext context) - => VisitI64seq(context); - - public static GrammarResult.FormattedBlob VisitI64seq(CILParser.I64seqContext context) - => new(context.Value ?? new BlobBuilder()); - - GrammarResult ICILVisitor.VisitI8seq(CILParser.I8seqContext context) - => VisitI8seq(context); - - public static GrammarResult.FormattedBlob VisitI8seq(CILParser.I8seqContext context) - => new(context.Value ?? new BlobBuilder()); - - GrammarResult ICILVisitor.VisitObjSeq(CILParser.ObjSeqContext context) - => VisitObjSeq(context); - - public GrammarResult.FormattedBlob VisitObjSeq(CILParser.ObjSeqContext context) - => new(MaterializeSerializedSequence(GetSerializedSequenceValue(context.Value))); - - GrammarResult ICILVisitor.VisitSqstringSeq( - CILParser.SqstringSeqContext context) - => VisitSqstringSeq(context); - - public static GrammarResult.FormattedBlob VisitSqstringSeq( - CILParser.SqstringSeqContext context) - => new(context.Value ?? new BlobBuilder()); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Serialization.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Serialization.cs index 693b96b32349aa..bf78aedf2939e3 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Serialization.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Serialization.cs @@ -397,53 +397,6 @@ private static SerializationTypeCode GetSerializationTypeCode(int tokenType) : Encoding.UTF8.GetString(bytes.Slice(bytesRead, length)); } - GrammarResult ICILVisitor.VisitFieldInit(CILParser.FieldInitContext context) - => VisitFieldInit(context); - - public static GrammarResult.Literal VisitFieldInit( - CILParser.FieldInitContext context) - => new(context.Value); - - GrammarResult ICILVisitor.VisitFieldOrProp(CILParser.FieldOrPropContext context) - => VisitFieldOrProp(context); - - public static GrammarResult.Literal VisitFieldOrProp( - CILParser.FieldOrPropContext context) - => new((CustomAttributeNamedArgumentKind)context.Value); - - GrammarResult ICILVisitor.VisitFieldSerInit( - CILParser.FieldSerInitContext context) - => VisitFieldSerInit(context); - - public static GrammarResult.FormattedBlob VisitFieldSerInit( - CILParser.FieldSerInitContext context) - => new(context.Value ?? new BlobBuilder()); - - GrammarResult ICILVisitor.VisitInitOpt(CILParser.InitOptContext context) - => VisitInitOpt(context); - public static GrammarResult.Literal VisitInitOpt(CILParser.InitOptContext context) => new(context.Value); - - GrammarResult ICILVisitor.VisitSerializType( - CILParser.SerializTypeContext context) - => VisitSerializType(context); - - public GrammarResult.FormattedBlob VisitSerializType( - CILParser.SerializTypeContext context) - => new(MaterializeSerializationType(GetSerializationTypeValue(context.Value))); - - GrammarResult ICILVisitor.VisitSerializTypeElement( - CILParser.SerializTypeElementContext context) - => VisitSerializTypeElement(context); - - public GrammarResult.FormattedBlob VisitSerializTypeElement( - CILParser.SerializTypeElementContext context) - => new(MaterializeSerializationType(GetSerializationTypeValue(context.Value))); - - GrammarResult ICILVisitor.VisitSerInit(CILParser.SerInitContext context) - => VisitSerInit(context); - - public GrammarResult.FormattedBlob VisitSerInit(CILParser.SerInitContext context) - => new(MaterializeSerializedInitializer(GetSerializedInitializerValue(context.Value))); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Data.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Data.cs index 7facba615efca1..ff88d424f5012f 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Data.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Data.cs @@ -264,32 +264,4 @@ internal void AddZeroData(CILParser.DdItemContext context, IToken kind, int coun return null; } -#pragma warning disable CA1822 // Structural rules are driven by parser actions. - public GrammarResult VisitDataDecl(CILParser.DataDeclContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitDdHead(CILParser.DdHeadContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitDdBody(CILParser.DdBodyContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitDdItemList(CILParser.DdItemListContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitDdItem(CILParser.DdItemContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitDdItemCount(CILParser.DdItemCountContext context) - => VisitDdItemCount(context); - - public static GrammarResult.Literal VisitDdItemCount(CILParser.DdItemCountContext context) - => new(context.Value); - - GrammarResult ICILVisitor.VisitTls(CILParser.TlsContext context) - => VisitTls(context); - - public static GrammarResult.Literal VisitTls(CILParser.TlsContext context) - => new(context.Value); -#pragma warning restore CA1822 } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Debug.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Debug.cs index aec271e76ddf2c..6f23cb963248ac 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Debug.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Debug.cs @@ -3,7 +3,6 @@ using System; using System.Collections.Generic; -using System.Diagnostics; using Antlr4.Runtime; namespace ILAssembler; @@ -222,31 +221,4 @@ context.Value is not LanguageDirectiveValue value || private bool CanApplySharedDirective(ParserRuleContext context) => context.Parent is not CILParser.MethodDeclContext || _currentMethod is not null; - public GrammarResult VisitCompControl(CILParser.CompControlContext context) - { - // Compilation control directives that require handling are consumed by the preprocessor. - return GrammarResult.SentinelValue.Result; - } - -#pragma warning disable CA1822 // Parser actions own these directive side effects. - GrammarResult ICILVisitor.VisitEsHead(CILParser.EsHeadContext context) - => VisitEsHead(context); - - public static GrammarResult.Literal VisitEsHead(CILParser.EsHeadContext context) - => new(context.AutoIncrement); - - public GrammarResult VisitExtSourceSpec(CILParser.ExtSourceSpecContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitLanguageDecl(CILParser.LanguageDeclContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitLanguageString( - CILParser.LanguageStringContext context) - => VisitLanguageString(context); - - public static GrammarResult.String VisitLanguageString( - CILParser.LanguageStringContext context) - => new(context.Value ?? string.Empty); -#pragma warning restore CA1822 } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.cs deleted file mode 100644 index 6be424e348fecf..00000000000000 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.cs +++ /dev/null @@ -1,18 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Diagnostics; - -namespace ILAssembler; - -internal sealed partial class GrammarActions -{ -#pragma warning disable CA1822 // Structural rules are driven by parser actions. - public GrammarResult VisitDecl(CILParser.DeclContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitDecls(CILParser.DeclsContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - -#pragma warning restore CA1822 -} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.References.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.References.cs index b75c2c32c3ba88..b790097ae98665 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.References.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.References.cs @@ -111,6 +111,4 @@ private static void WriteInstructionToken(CurrentMethodContext method, EntityReg } } - GrammarResult ICILVisitor.VisitCalliSignature(CILParser.CalliSignatureContext context) - => new GrammarResult.FormattedBlob(MaterializeCalliSignature(GetCalliSignatureValue(context.Value))); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs index 9744578fdb18f0..6fee8d64103bcc 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs @@ -442,14 +442,6 @@ private static ILOpCode ParseOpCodeFromToken(IToken token) return (ILOpCode)Enum.Parse(typeof(ILOpCode), normalized, ignoreCase: true); } - GrammarResult ICILVisitor.VisitInstr(CILParser.InstrContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitSimpleInstr(CILParser.SimpleInstrContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitMdtoken(CILParser.MdtokenContext context) => VisitMdtoken(context); - public GrammarResult.Literal VisitMdtoken(CILParser.MdtokenContext context) => new(ResolveMetadataToken(context.Value)); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs index 41888e754b378e..69b404f343485c 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs @@ -18,12 +18,11 @@ using System.Text; using Antlr4.Runtime; using Antlr4.Runtime.Misc; -using Antlr4.Runtime.Tree; namespace ILAssembler { #pragma warning disable CA1822 // Mark members as static - internal sealed partial class GrammarActions : ICILVisitor + internal sealed partial class GrammarActions { private CILParser.CompQstringContext? _composedStringOwner; private StringBuilder? _composedStringAccumulator; @@ -43,11 +42,6 @@ public DottedNameFrame(CILParser.DottedNameContext owner) public StringBuilder? Builder { get; set; } } - GrammarResult ICILVisitor.VisitCompQstring(CILParser.CompQstringContext context) - { - return VisitCompQstring(context); - } - internal void BeginComposedString(CILParser.CompQstringContext context) { Debug.Assert(_composedStringOwner is null); @@ -79,14 +73,6 @@ internal string EndComposedString(CILParser.CompQstringContext context) return value; } - private static GrammarResult.String VisitCompQstring(CILParser.CompQstringContext context) - => new(context.Value ?? string.Empty); - - GrammarResult ICILVisitor.VisitDottedName(CILParser.DottedNameContext context) - { - return VisitDottedName(context); - } - internal void BeginDottedName(CILParser.DottedNameContext context) => _dottedNameFrames.Push(new(context)); @@ -124,12 +110,6 @@ internal string EndDottedName(CILParser.DottedNameContext context) : string.Empty; } - public static GrammarResult.String VisitDottedName(CILParser.DottedNameContext context) - => new(context.Value ?? string.Empty); - - GrammarResult ICILVisitor.VisitDottedNamePart(CILParser.DottedNamePartContext context) - => new GrammarResult.String(context.Value ?? string.Empty); - internal string ParseDottedNamePart(IToken token) => token.Text.Length >= 2 && token.Text[0] == '\'' ? StringHelpers.ParseQuotedString(token.Text) @@ -164,12 +144,6 @@ internal double ParseFloat32Bits(IToken token) internal double ParseFloat64Bits(IToken token) => BitConverter.Int64BitsToDouble(ParseInt64(token)); - GrammarResult ICILVisitor.VisitFloat64(CILParser.Float64Context context) => VisitFloat64(context); - - public static GrammarResult.Literal VisitFloat64(CILParser.Float64Context context) - => new(context.Value); - - GrammarResult ICILVisitor.VisitId(CILParser.IdContext context) => VisitId(context); public static GrammarResult.String VisitId(CILParser.IdContext context) { return new GrammarResult.String(ParseIdentifier(context.Start)); @@ -247,16 +221,6 @@ private static bool ParseIntegerValue(ReadOnlySpan value, out long result) return true; } - GrammarResult ICILVisitor.VisitInt32(CILParser.Int32Context context) - { - return VisitInt32(context); - } - - public GrammarResult.Literal VisitInt32(CILParser.Int32Context context) - { - return new(ParseInt32(context.INT32().Symbol)); - } - internal int ParseInt32(IToken token) { ReadOnlySpan value = token.Text.AsSpan(); @@ -270,16 +234,6 @@ internal int ParseInt32(IToken token) } - GrammarResult ICILVisitor.VisitInt64(CILParser.Int64Context context) - { - return VisitInt64(context); - } - - public GrammarResult.Literal VisitInt64(CILParser.Int64Context context) - { - return new(ParseInt64(context.Start)); - } - private long ParseInt64(IToken token) { ReadOnlySpan value = token.Text.AsSpan(); @@ -301,23 +255,7 @@ private void ReportLiteralOutOfRange(IToken token) Location.From(token, _documents))); } - GrammarResult ICILVisitor.VisitIntOrWildcard(CILParser.IntOrWildcardContext context) => VisitIntOrWildcard(context); - public static GrammarResult.Literal VisitIntOrWildcard(CILParser.IntOrWildcardContext context) => new(context.Value); - - GrammarResult ICILVisitor.VisitSlashedName(CILParser.SlashedNameContext context) - { - return VisitSlashedName(context); - } - - public static GrammarResult.Literal VisitSlashedName(CILParser.SlashedNameContext context) - => new(GetSlashedNameValue(context)); - - GrammarResult ICILVisitor.VisitTruefalse(CILParser.TruefalseContext context) => VisitTruefalse(context); - internal bool ParseBoolean(IToken token) => bool.Parse(token.Text); - public static GrammarResult.Literal VisitTruefalse(CILParser.TruefalseContext context) - => new(context.Value); - } } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Assembly.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Assembly.cs index 24ea2d9c343fe4..91006b69c1caae 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Assembly.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Assembly.cs @@ -202,28 +202,6 @@ private void ApplyKeyFile(string keyFilePath) } } - GrammarResult ICILVisitor.VisitAsmAttr(CILParser.AsmAttrContext context) - => VisitAsmAttr(context); - - public static GrammarResult.Literal VisitAsmAttr( - CILParser.AsmAttrContext context) - => new(context.Value); - - GrammarResult ICILVisitor.VisitAsmAttrAny( - CILParser.AsmAttrAnyContext context) - => VisitAsmAttrAny(context); - - public static GrammarResult.Flag VisitAsmAttrAny( - CILParser.AsmAttrAnyContext context) - => new(context.Value, context.Mask); - - public GrammarResult VisitAsmOrRefDecl(CILParser.AsmOrRefDeclContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitAssemblyBlock( - CILParser.AssemblyBlockContext context) - => VisitAssemblyBlock(context); - public GrammarResult VisitAssemblyBlock(CILParser.AssemblyBlockContext context) { if (context.Value is AssemblyDefinitionValue definition) @@ -233,10 +211,4 @@ public GrammarResult VisitAssemblyBlock(CILParser.AssemblyBlockContext context) return GrammarResult.SentinelValue.Result; } - - public GrammarResult VisitAssemblyDecl(CILParser.AssemblyDeclContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitAssemblyDecls(CILParser.AssemblyDeclsContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.ExportedTypes.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.ExportedTypes.cs index a68c3f5eca5e60..a7a23a884b46d7 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.ExportedTypes.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.ExportedTypes.cs @@ -294,23 +294,6 @@ private static string GetExportedTypeDisplayName(TypeName typeName) return string.Join("/", names); } - public GrammarResult VisitExportHead(CILParser.ExportHeadContext context) - => throw new NotImplementedException("Obsolete syntax"); - - GrammarResult ICILVisitor.VisitExptAttr(CILParser.ExptAttrContext context) - => VisitExptAttr(context); - - public static GrammarResult.Flag VisitExptAttr( - CILParser.ExptAttrContext context) - => new(context.Value, context.Mask); - - GrammarResult ICILVisitor.VisitExptAttrs(CILParser.ExptAttrsContext context) - => VisitExptAttrs(context); - - public static GrammarResult.Literal VisitExptAttrs( - CILParser.ExptAttrsContext context) - => new(context.Value); - public GrammarResult VisitExptypeBlock(CILParser.ExptypeBlockContext context) { if (context.Value is ExportedTypeValue value) @@ -321,29 +304,4 @@ public GrammarResult VisitExptypeBlock(CILParser.ExptypeBlockContext context) return GrammarResult.SentinelValue.Result; } - public GrammarResult VisitExptypeDecl(CILParser.ExptypeDeclContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitExptypeDecls( - CILParser.ExptypeDeclsContext context) - => VisitExptypeDecls(context); - - public GrammarResult.Literal<( - EntityRegistry.EntityBase? implementation, - int typedefId, - ImmutableArray attrs)> VisitExptypeDecls( - CILParser.ExptypeDeclsContext context) - => new(MaterializeExportedTypeDeclarations(GetManifestValues(context.Value))); - - GrammarResult ICILVisitor.VisitExptypeHead( - CILParser.ExptypeHeadContext context) - => VisitExptypeHead(context); - - public static GrammarResult.Literal<(TypeAttributes attrs, string dottedName)> - VisitExptypeHead(CILParser.ExptypeHeadContext context) - { - ExportedTypeHeaderValue header = - GetExportedTypeHeader(context.Value, context.Start); - return new((header.Attributes, header.Name)); - } } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Files.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Files.cs index 8a40ed738791fa..0fb19ef784f0c9 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Files.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Files.cs @@ -124,15 +124,6 @@ private EntityRegistry.FileEntity MaterializeFileDeclaration(FileDeclarationValu return entity; } - GrammarResult ICILVisitor.VisitFileAttr(CILParser.FileAttrContext context) - => VisitFileAttr(context); - - public static GrammarResult.Literal VisitFileAttr(CILParser.FileAttrContext context) - => new(context.Value); - - GrammarResult ICILVisitor.VisitFileDecl(CILParser.FileDeclContext context) - => VisitFileDecl(context); - public GrammarResult.Literal VisitFileDecl( CILParser.FileDeclContext context) { @@ -141,10 +132,4 @@ GrammarResult ICILVisitor.VisitFileDecl(CILParser.FileDeclContext ?? new(string.Empty, HasMetadata: true, IsEntryPoint: false, Hash: null); return new(MaterializeFileDeclaration(declaration)); } - - GrammarResult ICILVisitor.VisitFileEntry(CILParser.FileEntryContext context) - => VisitFileEntry(context); - - public static GrammarResult.Literal VisitFileEntry(CILParser.FileEntryContext context) - => new(context.Value); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.References.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.References.cs index 8601111f5bb8ab..1ada95ee54ec89 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.References.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.References.cs @@ -3,7 +3,6 @@ using System.Collections.Generic; using System.Collections.Immutable; -using System.Diagnostics; using System.Reflection; namespace ILAssembler; @@ -94,17 +93,4 @@ public GrammarResult VisitAssemblyRefBlock(CILParser.AssemblyRefBlockContext con return GrammarResult.SentinelValue.Result; } - public GrammarResult VisitAssemblyRefDecl(CILParser.AssemblyRefDeclContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitAssemblyRefDecls(CILParser.AssemblyRefDeclsContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitAssemblyRefHead( - CILParser.AssemblyRefHeadContext context) - => VisitAssemblyRefHead(context); - - public GrammarResult.Literal VisitAssemblyRefHead( - CILParser.AssemblyRefHeadContext context) - => new(MaterializeAssemblyReferenceHeader(GetAssemblyReferenceHeader(context.Value))); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Resources.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Resources.cs index 937ebd8db72ca7..d6cc2bffc5133b 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Resources.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Resources.cs @@ -171,48 +171,4 @@ public GrammarResult VisitManifestResBlock(CILParser.ManifestResBlockContext con return GrammarResult.SentinelValue.Result; } - public GrammarResult VisitManifestResDecl(CILParser.ManifestResDeclContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitManifestResDecls( - CILParser.ManifestResDeclsContext context) - => VisitManifestResDecls(context); - - public GrammarResult.Literal<( - EntityRegistry.EntityBase? implementation, - uint offset, - ImmutableArray attributes)> - VisitManifestResDecls(CILParser.ManifestResDeclsContext context) - => new(MaterializeManifestResourceDeclarations(GetManifestValues(context.Value))); - - GrammarResult ICILVisitor.VisitManifestResHead( - CILParser.ManifestResHeadContext context) - => VisitManifestResHead(context); - - public static GrammarResult.Literal<( - string name, - string alias, - ManifestResourceAttributes attr)> VisitManifestResHead( - CILParser.ManifestResHeadContext context) - { - ManifestResourceHeaderValue header = - GetManifestResourceHeader(context.Value, context.Start); - return new((header.Name, header.Alias, header.Attributes)); - } - - GrammarResult ICILVisitor.VisitManresAttr( - CILParser.ManresAttrContext context) - => VisitManresAttr(context); - - public static GrammarResult.Flag VisitManresAttr( - CILParser.ManresAttrContext context) - => new(context.Value); - - GrammarResult ICILVisitor.VisitManresAttrs( - CILParser.ManresAttrsContext context) - => VisitManresAttrs(context); - - public static GrammarResult.Literal VisitManresAttrs( - CILParser.ManresAttrsContext context) - => new(context.Value); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.VTable.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.VTable.cs index a2a2fb3a25ac08..6fa45f6b4bc975 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.VTable.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.VTable.cs @@ -47,26 +47,6 @@ public GrammarResult VisitVtableDecl(CILParser.VtableDeclContext context) => throw new NotImplementedException( "raw vtable fixups blob (.vtable) not supported - use .vtfixup instead"); - GrammarResult ICILVisitor.VisitVtfixupAttr( - CILParser.VtfixupAttrContext context) - => VisitVtfixupAttr(context); - - public static GrammarResult.Literal VisitVtfixupAttr( - CILParser.VtfixupAttrContext context) - => new(context.Value); - - GrammarResult ICILVisitor.VisitVtfixupAttrElement( - CILParser.VtfixupAttrElementContext context) - => VisitVtfixupAttrElement(context); - - public static GrammarResult.Literal VisitVtfixupAttrElement( - CILParser.VtfixupAttrElementContext context) - => new(context.Value); - - GrammarResult ICILVisitor.VisitVtfixupDecl( - CILParser.VtfixupDeclContext context) - => VisitVtfixupDecl(context); - public GrammarResult VisitVtfixupDecl(CILParser.VtfixupDeclContext context) { if (context.Value is VTableFixupValue value) diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.cs deleted file mode 100644 index 29ef29b299319e..00000000000000 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.cs +++ /dev/null @@ -1,35 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Diagnostics; - -namespace ILAssembler; - -internal sealed partial class GrammarActions -{ -#pragma warning disable CA1822 // Structural rules are driven by parser actions. - public GrammarResult VisitAlignment(CILParser.AlignmentContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitCorflags(CILParser.CorflagsContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitImagebase(CILParser.ImagebaseContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitModuleHead(CILParser.ModuleHeadContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitMscorlib(CILParser.MscorlibContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitStackreserve(CILParser.StackreserveContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitSubsystem(CILParser.SubsystemContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitTypelist(CILParser.TypelistContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); -#pragma warning restore CA1822 -} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Marshalling.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Marshalling.cs deleted file mode 100644 index 19ea28b975861d..00000000000000 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Marshalling.cs +++ /dev/null @@ -1,74 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Diagnostics; -using System.Reflection; -using System.Reflection.Metadata; -using System.Runtime.InteropServices; - -namespace ILAssembler; - -#pragma warning disable CA1822 // Visitor wrappers intentionally preserve the existing instance API. -internal sealed partial class GrammarActions -{ - GrammarResult ICILVisitor.VisitIidParamIndex(CILParser.IidParamIndexContext context) - => VisitIidParamIndex(context); - - public GrammarResult.Literal VisitIidParamIndex(CILParser.IidParamIndexContext context) - => new(MaterializeIidParamIndex(GetIidParamIndexValue(context.Value))); - - GrammarResult ICILVisitor.VisitMarshalBlob(CILParser.MarshalBlobContext context) - => VisitMarshalBlob(context); - - public GrammarResult.FormattedBlob VisitMarshalBlob(CILParser.MarshalBlobContext context) - => new(MaterializeMarshallingDescriptor(GetMarshallingDescriptorValue(context.Value))); - - GrammarResult ICILVisitor.VisitMarshalClause(CILParser.MarshalClauseContext context) - => VisitMarshalClause(context); - - public GrammarResult.FormattedBlob VisitMarshalClause(CILParser.MarshalClauseContext context) - => new(MaterializeMarshallingDescriptor(GetMarshallingDescriptorValue(context.Value))); - - GrammarResult ICILVisitor.VisitNativeType(CILParser.NativeTypeContext context) - => VisitNativeType(context); - - public GrammarResult.FormattedBlob VisitNativeType(CILParser.NativeTypeContext context) - => new(MaterializeNativeType(GetNativeTypeValue(context.Value))); - - GrammarResult ICILVisitor.VisitNativeTypeElement(CILParser.NativeTypeElementContext context) - => VisitNativeTypeElement(context); - - public GrammarResult.FormattedBlob VisitNativeTypeElement(CILParser.NativeTypeElementContext context) - => new(MaterializeNativeTypeElement(GetNativeTypeElementValue(context.Value))); - - GrammarResult ICILVisitor.VisitVariantType(CILParser.VariantTypeContext context) - => VisitVariantType(context); - - public GrammarResult.Literal VisitVariantType(CILParser.VariantTypeContext context) - => new(MaterializeVariantType(GetVariantTypeValue(context.Value))); - - GrammarResult ICILVisitor.VisitVariantTypeElement(CILParser.VariantTypeElementContext context) - => VisitVariantTypeElement(context); - - public GrammarResult.Literal VisitVariantTypeElement(CILParser.VariantTypeElementContext context) - => new(MaterializeVariantTypeElement( - context.Value as VariantTypeElementValue ?? new VariantTypeElementValue(0))); - - public GrammarResult VisitNativeTypeArrayPointerInfo(CILParser.NativeTypeArrayPointerInfoContext context) - => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - - public GrammarResult VisitPointerArrayTypeSize(CILParser.PointerArrayTypeSizeContext context) - => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - - public GrammarResult VisitPointerArrayTypeParamIndex(CILParser.PointerArrayTypeParamIndexContext context) - => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - - public GrammarResult VisitPointerNativeType(CILParser.PointerNativeTypeContext context) - => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - - public GrammarResult VisitPointerArrayTypeSizeParamIndex(CILParser.PointerArrayTypeSizeParamIndexContext context) - => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - - public GrammarResult VisitPointerArrayTypeNoSizeData(CILParser.PointerArrayTypeNoSizeDataContext context) - => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); -} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Fields.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Fields.cs index eb70ed5b12e11a..8c0da1cfdf18d7 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Fields.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Fields.cs @@ -200,46 +200,10 @@ internal void SetFieldOffset(CILParser.RepeatOptContext context, IToken token) context.HasValue = true; } - GrammarResult ICILVisitor.VisitAtOpt(CILParser.AtOptContext context) - => VisitAtOpt(context); - - public static GrammarResult.Literal VisitAtOpt(CILParser.AtOptContext context) - => new(context.Value); - - GrammarResult ICILVisitor.VisitFieldAttr(CILParser.FieldAttrContext context) - => VisitFieldAttr(context); - - public static GrammarResult.Flag VisitFieldAttr( - CILParser.FieldAttrContext context) - { - AttributeValue attribute = - GetAttributeValue(context.Value); - return new(attribute.Value, attribute.ShouldAppend, attribute.GroupMask); - } - - GrammarResult ICILVisitor.VisitFieldDecl(CILParser.FieldDeclContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitFieldRef(CILParser.FieldRefContext context) - => VisitFieldRef(context); - public GrammarResult.Literal VisitFieldRef( CILParser.FieldRefContext context) => new(MaterializeFieldReference(GetFieldReferenceValue(context.Value))); - GrammarResult ICILVisitor.VisitMemberRef(CILParser.MemberRefContext context) - => VisitMemberRef(context); - - public GrammarResult.Literal VisitMemberRef( - CILParser.MemberRefContext context) - => new(MaterializeMemberReference(GetMemberReferenceValue(context.Value))); - - GrammarResult ICILVisitor.VisitRepeatOpt(CILParser.RepeatOptContext context) - => VisitRepeatOpt(context); - - public static GrammarResult.Literal VisitRepeatOpt(CILParser.RepeatOptContext context) - => new(context.HasValue ? context.Value : null); - private FieldDeclarationFrame? TryGetFieldDeclarationFrame(CILParser.FieldDeclContext context) { Debug.Assert(_fieldDeclarationFrames.Count > 0); diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.PropertiesEvents.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.PropertiesEvents.cs index e9a32ddac182c8..ffc1a53a8e0d91 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.PropertiesEvents.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.PropertiesEvents.cs @@ -332,46 +332,6 @@ private void EndPropertyAndEventBodies(CILParser.ClassDeclContext context) } } - GrammarResult ICILVisitor.VisitEventAttr(CILParser.EventAttrContext context) - => VisitEventAttr(context); - - public static GrammarResult.Flag VisitEventAttr( - CILParser.EventAttrContext context) - { - AttributeValue attribute = - GetAttributeValue(context.Value); - return new(attribute.Value, attribute.ShouldAppend, attribute.GroupMask); - } - - GrammarResult ICILVisitor.VisitEventDecl(CILParser.EventDeclContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitEventDecls(CILParser.EventDeclsContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitEventHead(CILParser.EventHeadContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitPropAttr(CILParser.PropAttrContext context) - => VisitPropAttr(context); - - public static GrammarResult.Flag VisitPropAttr( - CILParser.PropAttrContext context) - { - AttributeValue attribute = - GetAttributeValue(context.Value); - return new(attribute.Value, attribute.ShouldAppend, attribute.GroupMask); - } - - GrammarResult ICILVisitor.VisitPropDecl(CILParser.PropDeclContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitPropDecls(CILParser.PropDeclsContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitPropHead(CILParser.PropHeadContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - private PropertyHeaderFrame? TryGetPropertyHeaderFrame(CILParser.PropHeadContext context) { Debug.Assert(_propertyHeaderFrames.Count > 0); diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.cs deleted file mode 100644 index 61607c7663aa67..00000000000000 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.cs +++ /dev/null @@ -1,12 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Diagnostics; - -namespace ILAssembler; - -internal sealed partial class GrammarActions -{ - public GrammarResult VisitClassDecl(CILParser.ClassDeclContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); -} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs index cc1baba827f03d..d5476341f2b4f9 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.cs @@ -2,90 +2,30 @@ // The .NET Foundation licenses this file to you under the MIT license. using System; -using System.Buffers.Binary; -using System.Collections.Generic; -using System.Collections.Immutable; -using System.Diagnostics; -using System.Globalization; -using System.IO; -using System.Linq; -using System.Reflection; -using System.Reflection.Metadata; -using System.Reflection.Metadata.Ecma335; -using System.Reflection.PortableExecutable; -using System.Runtime.InteropServices; -using System.Security.Cryptography; -using System.Text; using Antlr4.Runtime; -using Antlr4.Runtime.Misc; -using Antlr4.Runtime.Tree; namespace ILAssembler; -#pragma warning disable CA1822 // Mark members as static internal sealed partial class GrammarActions { - GrammarResult ICILVisitor.VisitCatchClause(CILParser.CatchClauseContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitExportDecl(CILParser.ExportDeclContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitFaultClause(CILParser.FaultClauseContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - - GrammarResult ICILVisitor.VisitFilterClause(CILParser.FilterClauseContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitFinallyClause(CILParser.FinallyClauseContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - - GrammarResult ICILVisitor.VisitHandlerBlock(CILParser.HandlerBlockContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - private void ValidateLabelReferences() + private void ValidateLabelReferences() + { + if (_currentMethod is null) { - if (_currentMethod is null) - { - return; - } - - // Report errors for any labels that were referenced but never declared - foreach (var undefinedLabel in _currentMethod.UndefinedLabelReferences) - { - ReportError( - DiagnosticIds.LabelNotFound, - string.Format(DiagnosticMessageTemplates.LabelNotFound, undefinedLabel.Key), - undefinedLabel.Value); - } + return; } - public GrammarResult VisitLabels(CILParser.LabelsContext context) => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - - GrammarResult ICILVisitor.VisitLabelDecl(CILParser.LabelDeclContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitLocalsDecl(CILParser.LocalsDeclContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitMethodDecls(CILParser.MethodDeclsContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitMethodDecl(CILParser.MethodDeclContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitMethodName(CILParser.MethodNameContext context) => VisitMethodName(context); - - public static GrammarResult.String VisitMethodName(CILParser.MethodNameContext context) - => new(context.Value ?? string.Empty); - - internal string GetMethodName(IToken token) => token.Text; - - GrammarResult ICILVisitor.VisitOverrideDecl(CILParser.OverrideDeclContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitParameterDecl(CILParser.ParameterDeclContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitScopeBlock(CILParser.ScopeBlockContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitSehBlock(CILParser.SehBlockContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitSehClause(CILParser.SehClauseContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitSehClauses(CILParser.SehClausesContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitTryBlock(CILParser.TryBlockContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitVtentryDecl(CILParser.VtentryDeclContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); + // Report errors for any labels that were referenced but never declared + foreach (var undefinedLabel in _currentMethod.UndefinedLabelReferences) + { + ReportError( + DiagnosticIds.LabelNotFound, + string.Format(DiagnosticMessageTemplates.LabelNotFound, undefinedLabel.Key), + undefinedLabel.Value); + } + } -#pragma warning restore CA1822 // Mark members as static +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. + internal string GetMethodName(IToken token) => token.Text; +#pragma warning restore CA1822 } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.Generics.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.Generics.cs index 1c8baa34d48c7b..9a08cd78532d69 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.Generics.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.Generics.cs @@ -8,7 +8,6 @@ namespace ILAssembler; -#pragma warning disable CA1822 // Visitor wrappers intentionally preserve the existing instance API. internal sealed partial class GrammarActions { private static void RegisterGenericParameterNames( @@ -47,107 +46,4 @@ private void MaterializeGenericParameterConstraints( } } - GrammarResult ICILVisitor.VisitTyBound(CILParser.TyBoundContext context) - => VisitTyBound(context); - - public GrammarResult.Sequence VisitTyBound( - CILParser.TyBoundContext? context) - { - if (context?.Value is not ImmutableArray constraintTypes) - { - return new([]); - } - - ImmutableArray.Builder constraints = - ImmutableArray.CreateBuilder( - constraintTypes.Length); - foreach (TypeSpecificationValue constraintType in constraintTypes) - { - constraints.Add( - EntityRegistry.CreateGenericConstraint(ResolveTypeSpecification(constraintType))); - } - - return new(constraints.MoveToImmutable()); - } - - GrammarResult ICILVisitor.VisitTypar(CILParser.TyparContext context) - => VisitTypar(context); - - public GrammarResult.Literal VisitTypar( - CILParser.TyparContext context) - { - GenericParameterDeclarationValue declaration = - GetGenericParameterDeclaration(context.Value); - EntityRegistry.GenericParameterEntity parameter = - EntityRegistry.CreateGenericParameter(declaration.Attributes, declaration.Name); - foreach (TypeSpecificationValue constraintType in declaration.Constraints) - { - parameter.Constraints.Add( - EntityRegistry.CreateGenericConstraint(ResolveTypeSpecification(constraintType))); - } - - return new(parameter); - } - - GrammarResult ICILVisitor.VisitTyparAttrib(CILParser.TyparAttribContext context) - => VisitTyparAttrib(context); - - public static GrammarResult.Flag VisitTyparAttrib( - CILParser.TyparAttribContext context) - { - AttributeValue attribute = - GetAttributeValue(context.Value); - return new(attribute.Value, attribute.ShouldAppend, attribute.GroupMask); - } - - GrammarResult ICILVisitor.VisitTyparAttribs(CILParser.TyparAttribsContext context) - => VisitTyparAttribs(context); - - public static GrammarResult.Literal VisitTyparAttribs( - CILParser.TyparAttribsContext context) - => new(GetAttributeValue(context.Value).Value); - - GrammarResult ICILVisitor.VisitTypars(CILParser.TyparsContext context) - => VisitTypars(context); - - public GrammarResult.Sequence VisitTypars( - CILParser.TyparsContext context) - { - ImmutableArray declarations = - GetGenericParameterDeclarations(context.Value); - ImmutableArray.Builder parameters = - ImmutableArray.CreateBuilder(declarations.Length); - foreach (GenericParameterDeclarationValue declaration in declarations) - { - EntityRegistry.GenericParameterEntity parameter = - EntityRegistry.CreateGenericParameter(declaration.Attributes, declaration.Name); - foreach (TypeSpecificationValue constraintType in declaration.Constraints) - { - parameter.Constraints.Add( - EntityRegistry.CreateGenericConstraint(ResolveTypeSpecification(constraintType))); - } - parameters.Add(parameter); - } - - return new(parameters.MoveToImmutable()); - } - - GrammarResult ICILVisitor.VisitTyparsClause(CILParser.TyparsClauseContext context) - => VisitTyparsClause(context); - - public GrammarResult.Sequence VisitTyparsClause( - CILParser.TyparsClauseContext context) - { - ImmutableArray declarations = - GetGenericParameterDeclarations(context.Value); - ImmutableArray.Builder parameters = - ImmutableArray.CreateBuilder(declarations.Length); - foreach (GenericParameterDeclarationValue declaration in declarations) - { - parameters.Add( - EntityRegistry.CreateGenericParameter(declaration.Attributes, declaration.Name)); - } - - return new(parameters.MoveToImmutable()); - } } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.cs index ce412f1a3b41d0..f8e7bafc9e5ada 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.cs @@ -2,7 +2,6 @@ // The .NET Foundation licenses this file to you under the MIT license. using System.Collections.Immutable; -using System.Diagnostics; using System.Reflection; using System.Reflection.Metadata; @@ -173,47 +172,4 @@ private void ApplyPInvokeInformation( method.MethodImportInformation = pInvokeInformation; } - GrammarResult ICILVisitor.VisitImplAttr(CILParser.ImplAttrContext context) - => VisitImplAttr(context); - - public static GrammarResult.Flag VisitImplAttr(CILParser.ImplAttrContext context) - { - AttributeValue attribute = - GetAttributeValue(context.Value); - return new(attribute.Value, attribute.ShouldAppend, attribute.GroupMask); - } - - GrammarResult ICILVisitor.VisitMethAttr(CILParser.MethAttrContext context) - => VisitMethAttr(context); - - public static GrammarResult.Flag VisitMethAttr(CILParser.MethAttrContext context) - { - AttributeValue attribute = GetAttributeValue(context.Value); - return new(attribute.Value, attribute.ShouldAppend, attribute.GroupMask); - } - - GrammarResult ICILVisitor.VisitMethodHead(CILParser.MethodHeadContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitPinvAttr(CILParser.PinvAttrContext context) - => VisitPinvAttr(context); - - public static GrammarResult.Flag VisitPinvAttr(CILParser.PinvAttrContext context) - { - AttributeValue attribute = - GetAttributeValue(context.Value); - return new(attribute.Value, attribute.ShouldAppend, attribute.GroupMask); - } - - GrammarResult ICILVisitor.VisitPinvImpl(CILParser.PinvImplContext context) - => VisitPinvImpl(context); - - public static GrammarResult.Literal<( - string? ModuleName, - string? EntryPointName, - MethodImportAttributes Attributes)> VisitPinvImpl(CILParser.PinvImplContext context) - { - PInvokeValue value = GetPInvokeValue(context.Value); - return new((value.ModuleName, value.EntryPointName, value.Attributes)); - } } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs index 9519d32da5ec21..8160d4748d8795 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs @@ -305,40 +305,6 @@ private BlobBuilder MaterializeSecurityAttribute(SecurityAttributeValue attribut return blob; } - private BlobBuilder MaterializeSecurityCaValue(SecurityCaValue value) - { - BlobBuilder blob = new(); - switch (value) - { - case SecurityBooleanValue boolean: - blob.WriteByte((byte)SerializationTypeCode.Boolean); - blob.WriteBoolean(boolean.Value); - break; - case SecurityInt32Value integer: - blob.WriteByte((byte)SerializationTypeCode.Int32); - blob.WriteInt32(integer.Value); - break; - case SecurityStringValue text: - blob.WriteUTF8(text.Value); - blob.WriteByte(0); - break; - case SecurityEnumValue enumeration: - blob.WriteByte((byte)SerializationTypeCode.Enum); - EntityRegistry.TypeEntity enumType = ResolveClassName(enumeration.Type); - blob.WriteUTF8( - (enumType as EntityRegistry.IHasReflectionNotation)?.ReflectionNotation - ?? string.Empty); - blob.WriteByte(0); - blob.WriteByte(enumeration.Size); - blob.WriteInt32(enumeration.Value); - break; - default: - throw new UnreachableException(); - } - - return blob; - } - private static ImmutableArray GetSecurityAttributes(object? value) => value is ImmutableArray attributes ? attributes : []; @@ -369,16 +335,6 @@ private static SecurityCaValue GetSecurityCaValue(object? value) return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; } - GrammarResult ICILVisitor.VisitSecAction(CILParser.SecActionContext context) - => VisitSecAction(context); - - public static GrammarResult.Literal VisitSecAction( - CILParser.SecActionContext context) - => new(context.Value); - - GrammarResult ICILVisitor.VisitSecDecl(CILParser.SecDeclContext context) - => VisitSecDecl(context); - public GrammarResult.Literal VisitSecDecl( CILParser.SecDeclContext context) => new( @@ -386,57 +342,5 @@ context.Value is SecurityDeclarationValue value ? MaterializeSecurityDeclaration(value, context.Start) : null); - GrammarResult ICILVisitor.VisitSecAttrSetBlob( - CILParser.SecAttrSetBlobContext context) - => VisitSecAttrSetBlob(context); - - public GrammarResult.FormattedBlob VisitSecAttrSetBlob( - CILParser.SecAttrSetBlobContext context) - => new(MaterializeSecurityAttributeSet(GetSecurityAttributes(context.Value))); - - GrammarResult ICILVisitor.VisitSecAttrBlob(CILParser.SecAttrBlobContext context) - => VisitSecAttrBlob(context); - - public GrammarResult.FormattedBlob VisitSecAttrBlob(CILParser.SecAttrBlobContext context) - => new( - MaterializeSecurityAttribute( - context.Value as SecurityAttributeValue - ?? new SecurityAttributeValue(string.Empty, null, []))); - - GrammarResult ICILVisitor.VisitNameValPairs(CILParser.NameValPairsContext context) - => VisitNameValPairs(context); - - public GrammarResult.Sequence> VisitNameValPairs( - CILParser.NameValPairsContext context) - { - ImmutableArray values = - context.Value is ImmutableArray pairs ? pairs : []; - ImmutableArray>.Builder result = - ImmutableArray.CreateBuilder>(values.Length); - foreach (SecurityNameValuePairValue pair in values) - { - result.Add(new(pair.Name, MaterializeSecurityCaValue(pair.Value))); - } - - return new(result.MoveToImmutable()); - } - - GrammarResult ICILVisitor.VisitNameValPair(CILParser.NameValPairContext context) - => VisitNameValPair(context); - - public GrammarResult.Literal> VisitNameValPair( - CILParser.NameValPairContext context) - { - SecurityNameValuePairValue value = - context.Value as SecurityNameValuePairValue - ?? new SecurityNameValuePairValue(string.Empty, new SecurityInt32Value(0)); - return new(new(value.Name, MaterializeSecurityCaValue(value.Value))); - } - - GrammarResult ICILVisitor.VisitCaValue(CILParser.CaValueContext context) - => VisitCaValue(context); - - public GrammarResult.FormattedBlob VisitCaValue(CILParser.CaValueContext context) - => new(MaterializeSecurityCaValue(GetSecurityCaValue(context.Value))); } #pragma warning restore CA1822 diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Values.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Values.cs index cd902835315e01..a6fd148942d47e 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Values.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Values.cs @@ -38,9 +38,6 @@ private static ImmutableArray GetSignatureArgumentsValue private static TypeName GetTypeNameValue(object? value) => value as TypeName ?? new TypeName(null, string.Empty); - private static TypeName GetSlashedNameValue(CILParser.SlashedNameContext context) - => GetTypeNameValue(context.Value); - private static ClassNameValue GetClassNameValue(object? value) => GetSemanticValue(value, ClassNameValue.Error); diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.cs index a8c4b1ef766018..342dd008f54ab7 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.cs @@ -1,146 +1,13 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System; -using System.Collections.Immutable; -using System.Diagnostics; -using System.Linq; -using System.Reflection; -using System.Reflection.Metadata; - namespace ILAssembler; -#pragma warning disable CA1822 // Visitor wrappers intentionally preserve the existing instance API. internal sealed partial class GrammarActions { - GrammarResult ICILVisitor.VisitBound(CILParser.BoundContext context) => VisitBound(context); - - public GrammarResult.Literal<(int? Lower, int? Upper)> VisitBound(CILParser.BoundContext context) - => new(( - context.HasLower ? context.Lower : null, - context.HasUpper ? context.Upper : null)); - - GrammarResult ICILVisitor.VisitBounds(CILParser.BoundsContext context) => VisitBounds(context); - - public GrammarResult.Sequence<(int? Lower, int? Upper)> VisitBounds(CILParser.BoundsContext context) - => new(GetBoundsValue(context.Value) - .Select(bound => (bound.Lower, bound.Upper)) - .ToImmutableArray()); - - GrammarResult ICILVisitor.VisitCallConv(CILParser.CallConvContext context) => VisitCallConv(context); - - public static GrammarResult.Literal VisitCallConv(CILParser.CallConvContext context) - => new(context.Value); - - GrammarResult ICILVisitor.VisitCallKind(CILParser.CallKindContext context) => VisitCallKind(context); - - public static GrammarResult.Literal VisitCallKind(CILParser.CallKindContext context) - => new((SignatureCallingConvention)context.Value); - - GrammarResult ICILVisitor.VisitElementType(CILParser.ElementTypeContext context) => VisitElementType(context); - - public GrammarResult.FormattedBlob VisitElementType(CILParser.ElementTypeContext context) - => new(MaterializeElementType(GetElementTypeValue(context.Value))); - - GrammarResult ICILVisitor.VisitGenArity(CILParser.GenArityContext context) => VisitGenArity(context); - - public static GrammarResult.Literal VisitGenArity(CILParser.GenArityContext context) - => new(context.Value); - - GrammarResult ICILVisitor.VisitGenArityNotEmpty(CILParser.GenArityNotEmptyContext context) - => VisitGenArityNotEmpty(context); - - public static GrammarResult.Literal VisitGenArityNotEmpty(CILParser.GenArityNotEmptyContext context) - => new(context.Value); - - GrammarResult ICILVisitor.VisitNativeInt(CILParser.NativeIntContext context) - => new GrammarResult.Literal((SignatureTypeCode)context.Value); - - GrammarResult ICILVisitor.VisitNativeUint(CILParser.NativeUintContext context) - => new GrammarResult.Literal((SignatureTypeCode)context.Value); - - GrammarResult ICILVisitor.VisitMethodRef(CILParser.MethodRefContext context) => VisitMethodRef(context); - public GrammarResult.Literal VisitMethodRef(CILParser.MethodRefContext context) => new(MaterializeMethodReference(GetMethodReferenceValue(context.Value))); - GrammarResult ICILVisitor.VisitParamAttr(CILParser.ParamAttrContext context) => VisitParamAttr(context); - - public static GrammarResult.Literal VisitParamAttr(CILParser.ParamAttrContext context) - => new((ParameterAttributes)context.Value); - - GrammarResult ICILVisitor.VisitParamAttrElement(CILParser.ParamAttrElementContext context) - => VisitParamAttrElement(context); - - public static GrammarResult.Flag VisitParamAttrElement(CILParser.ParamAttrElementContext context) - => new((ParameterAttributes)context.Value, context.ShouldAppend); - - GrammarResult ICILVisitor.VisitSigArg(CILParser.SigArgContext context) => VisitSigArg(context); - - public GrammarResult.Literal VisitSigArg(CILParser.SigArgContext context) - => new(MaterializeSignatureArgument(GetSignatureArgumentValue(context.Value))); - - GrammarResult ICILVisitor.VisitSigArgs(CILParser.SigArgsContext context) => VisitSigArgs(context); - - public GrammarResult.Sequence VisitSigArgs(CILParser.SigArgsContext context) - => new(MaterializeSignatureArguments(GetSignatureArgumentsValue(context.Value))); - - GrammarResult ICILVisitor.VisitSimpleType(CILParser.SimpleTypeContext context) => VisitSimpleType(context); - - public static GrammarResult.Literal VisitSimpleType(CILParser.SimpleTypeContext context) - => new((SignatureTypeCode)context.Value); - - GrammarResult ICILVisitor.VisitType(CILParser.TypeContext context) => VisitType(context); - - public GrammarResult.FormattedBlob VisitType(CILParser.TypeContext context) - => new(MaterializeType(GetTypeValue(context.Value))); - - GrammarResult ICILVisitor.VisitTypeArgs(CILParser.TypeArgsContext context) => VisitTypeArgs(context); - - public GrammarResult.FormattedBlob VisitTypeArgs(CILParser.TypeArgsContext context) - => new(MaterializeTypeArguments(GetTypeArgumentsValue(context.Value))); - - GrammarResult ICILVisitor.VisitTypeList(CILParser.TypeListContext context) => VisitTypeList(context); - - public GrammarResult.Sequence VisitTypeList(CILParser.TypeListContext context) - { - ImmutableArray bounds = - context.Value is ImmutableArray value ? value : []; - ImmutableArray.Builder builder = - ImmutableArray.CreateBuilder(bounds.Length); - foreach (TypeSpecificationValue typeSpec in bounds) - { - builder.Add(ResolveTypeSpecification(typeSpec)); - } - return new(builder.MoveToImmutable()); - } - - GrammarResult ICILVisitor.VisitTypeSpec(CILParser.TypeSpecContext context) => VisitTypeSpec(context); - public GrammarResult.Literal VisitTypeSpec(CILParser.TypeSpecContext context) => new(ResolveTypeSpecification(GetTypeSpecificationValue(context.Value))); - - GrammarResult ICILVisitor.VisitOptionalModifier(CILParser.OptionalModifierContext context) - => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - - GrammarResult ICILVisitor.VisitSZArrayModifier(CILParser.SZArrayModifierContext context) - => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - - GrammarResult ICILVisitor.VisitRequiredModifier(CILParser.RequiredModifierContext context) - => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - - GrammarResult ICILVisitor.VisitPtrModifier(CILParser.PtrModifierContext context) - => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - - GrammarResult ICILVisitor.VisitPinnedModifier(CILParser.PinnedModifierContext context) - => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - - GrammarResult ICILVisitor.VisitGenericArgumentsModifier(CILParser.GenericArgumentsModifierContext context) - => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - - GrammarResult ICILVisitor.VisitByRefModifier(CILParser.ByRefModifierContext context) - => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); - - GrammarResult ICILVisitor.VisitArrayModifier(CILParser.ArrayModifierContext context) - => throw new UnreachableException(NodeShouldNeverBeDirectlyVisited); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.cs index 82e303645956a4..4248757a56627c 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.cs @@ -2,7 +2,6 @@ // The .NET Foundation licenses this file to you under the MIT license. using System.Collections.Immutable; -using System.Diagnostics; using System.Reflection; using Antlr4.Runtime; @@ -242,43 +241,4 @@ private void AddInterfaceImplementations( ResolveTypeSpecification(interfaceType))); } } - -#pragma warning disable CA1822 // Structural rules are driven by parser actions. - GrammarResult ICILVisitor.VisitClassAttr(CILParser.ClassAttrContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitClassAttr(CILParser.ClassAttrContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitClassHead(CILParser.ClassHeadContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitClassHead(CILParser.ClassHeadContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitExtendsClause(CILParser.ExtendsClauseContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitExtendsClause(CILParser.ExtendsClauseContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitImplClause(CILParser.ImplClauseContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitImplClause(CILParser.ImplClauseContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitImplList(CILParser.ImplListContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitImplList(CILParser.ImplListContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitNameSpaceHead( - CILParser.NameSpaceHeadContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - public GrammarResult VisitNameSpaceHead(CILParser.NameSpaceHeadContext context) - => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); -#pragma warning restore CA1822 } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs index 0d0abc664a955d..b6a005c8a5990c 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs @@ -2,7 +2,6 @@ // The .NET Foundation licenses this file to you under the MIT license. using System.Collections.Generic; -using System.Diagnostics; using System.Reflection.Metadata; using Antlr4.Runtime; @@ -90,13 +89,4 @@ private void ClearPendingCustomAttributeOwners() _pendingClassCustomAttributeOwner = null; } -#pragma warning disable CA1822 // Mark members as static - public GrammarResult VisitClassDecls(CILParser.ClassDeclsContext context) => throw new UnreachableException(StructuralNodeIsDrivenByParserActions); - - GrammarResult ICILVisitor.VisitClassName(CILParser.ClassNameContext context) => VisitClassName(context); - - public GrammarResult.Literal VisitClassName(CILParser.ClassNameContext context) - => new(ResolveClassName(GetClassNameValue(context.Value))); - -#pragma warning restore CA1822 // Mark members as static } diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILBaseVisitor.cs b/src/tools/ilasm/src/ILAssembler/gen/CILBaseVisitor.cs deleted file mode 100644 index aeee13c5953153..00000000000000 --- a/src/tools/ilasm/src/ILAssembler/gen/CILBaseVisitor.cs +++ /dev/null @@ -1,2012 +0,0 @@ -//------------------------------------------------------------------------------ -// -// This code was generated by a tool. -// ANTLR Version: 4.13.1 -// -// Changes to this file may cause incorrect behavior and will be lost if -// the code is regenerated. -// -//------------------------------------------------------------------------------ - -// Generated from CIL.g4 by ANTLR 4.13.1 - -// Unreachable code detected -#pragma warning disable 0162 -// The variable '...' is assigned but its value is never used -#pragma warning disable 0219 -// Missing XML comment for publicly visible type or member '...' -#pragma warning disable 1591 -// Ambiguous reference in cref attribute -#pragma warning disable 419 - -namespace ILAssembler { -using Antlr4.Runtime.Misc; -using Antlr4.Runtime.Tree; -using IToken = Antlr4.Runtime.IToken; -using ParserRuleContext = Antlr4.Runtime.ParserRuleContext; - -/// -/// This class provides an empty implementation of , -/// which can be extended to create a visitor which only needs to handle a subset -/// of the available methods. -/// -/// The return type of the visit operation. -[System.CodeDom.Compiler.GeneratedCode("ANTLR", "4.13.1")] -[System.Diagnostics.DebuggerNonUserCode] -[System.CLSCompliant(false)] -public partial class CILBaseVisitor : AbstractParseTreeVisitor, ICILVisitor { - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitId([NotNull] CILParser.IdContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitDottedName([NotNull] CILParser.DottedNameContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitDottedNamePart([NotNull] CILParser.DottedNamePartContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitCompQstring([NotNull] CILParser.CompQstringContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitDecls([NotNull] CILParser.DeclsContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitDecl([NotNull] CILParser.DeclContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitSubsystem([NotNull] CILParser.SubsystemContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitCorflags([NotNull] CILParser.CorflagsContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitAlignment([NotNull] CILParser.AlignmentContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitImagebase([NotNull] CILParser.ImagebaseContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitStackreserve([NotNull] CILParser.StackreserveContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitAssemblyBlock([NotNull] CILParser.AssemblyBlockContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitMscorlib([NotNull] CILParser.MscorlibContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitLanguageDecl([NotNull] CILParser.LanguageDeclContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitLanguageString([NotNull] CILParser.LanguageStringContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitTypelist([NotNull] CILParser.TypelistContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitInt32([NotNull] CILParser.Int32Context context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitInt64([NotNull] CILParser.Int64Context context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitFloat64([NotNull] CILParser.Float64Context context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitIntOrWildcard([NotNull] CILParser.IntOrWildcardContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitCompControl([NotNull] CILParser.CompControlContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitTypedefDecl([NotNull] CILParser.TypedefDeclContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitCustomDescr([NotNull] CILParser.CustomDescrContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitCustomDescrWithOwner([NotNull] CILParser.CustomDescrWithOwnerContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitCustomType([NotNull] CILParser.CustomTypeContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitOwnerType([NotNull] CILParser.OwnerTypeContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitCustomBlobDescr([NotNull] CILParser.CustomBlobDescrContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitCustomBlobArgs([NotNull] CILParser.CustomBlobArgsContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitCustomBlobNVPairs([NotNull] CILParser.CustomBlobNVPairsContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitFieldOrProp([NotNull] CILParser.FieldOrPropContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitSerializType([NotNull] CILParser.SerializTypeContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitSerializTypeElement([NotNull] CILParser.SerializTypeElementContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitModuleHead([NotNull] CILParser.ModuleHeadContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitVtfixupDecl([NotNull] CILParser.VtfixupDeclContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitVtfixupAttr([NotNull] CILParser.VtfixupAttrContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitVtfixupAttrElement([NotNull] CILParser.VtfixupAttrElementContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitVtableDecl([NotNull] CILParser.VtableDeclContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitNameSpaceHead([NotNull] CILParser.NameSpaceHeadContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitClassHead([NotNull] CILParser.ClassHeadContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitClassAttr([NotNull] CILParser.ClassAttrContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitExtendsClause([NotNull] CILParser.ExtendsClauseContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitImplClause([NotNull] CILParser.ImplClauseContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitClassDecls([NotNull] CILParser.ClassDeclsContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitImplList([NotNull] CILParser.ImplListContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitEsHead([NotNull] CILParser.EsHeadContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitExtSourceSpec([NotNull] CILParser.ExtSourceSpecContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitFileDecl([NotNull] CILParser.FileDeclContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitFileAttr([NotNull] CILParser.FileAttrContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitFileEntry([NotNull] CILParser.FileEntryContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitAsmAttrAny([NotNull] CILParser.AsmAttrAnyContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitAsmAttr([NotNull] CILParser.AsmAttrContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitInstr([NotNull] CILParser.InstrContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitSimpleInstr([NotNull] CILParser.SimpleInstrContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitCalliSignature([NotNull] CILParser.CalliSignatureContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitLabels([NotNull] CILParser.LabelsContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitTypeArgs([NotNull] CILParser.TypeArgsContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitBounds([NotNull] CILParser.BoundsContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitSigArgs([NotNull] CILParser.SigArgsContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitSigArg([NotNull] CILParser.SigArgContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitClassName([NotNull] CILParser.ClassNameContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitSlashedName([NotNull] CILParser.SlashedNameContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitAssemblyDecls([NotNull] CILParser.AssemblyDeclsContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitAssemblyDecl([NotNull] CILParser.AssemblyDeclContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitTypeSpec([NotNull] CILParser.TypeSpecContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitNativeType([NotNull] CILParser.NativeTypeContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by the PointerNativeType - /// labeled alternative in . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitPointerNativeType([NotNull] CILParser.PointerNativeTypeContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by the PointerArrayTypeNoSizeData - /// labeled alternative in . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitPointerArrayTypeNoSizeData([NotNull] CILParser.PointerArrayTypeNoSizeDataContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by the PointerArrayTypeSize - /// labeled alternative in . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitPointerArrayTypeSize([NotNull] CILParser.PointerArrayTypeSizeContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by the PointerArrayTypeSizeParamIndex - /// labeled alternative in . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitPointerArrayTypeSizeParamIndex([NotNull] CILParser.PointerArrayTypeSizeParamIndexContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by the PointerArrayTypeParamIndex - /// labeled alternative in . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitPointerArrayTypeParamIndex([NotNull] CILParser.PointerArrayTypeParamIndexContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitNativeTypeElement([NotNull] CILParser.NativeTypeElementContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitIidParamIndex([NotNull] CILParser.IidParamIndexContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitVariantType([NotNull] CILParser.VariantTypeContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitVariantTypeElement([NotNull] CILParser.VariantTypeElementContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitType([NotNull] CILParser.TypeContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by the SZArrayModifier - /// labeled alternative in . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitSZArrayModifier([NotNull] CILParser.SZArrayModifierContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by the ArrayModifier - /// labeled alternative in . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitArrayModifier([NotNull] CILParser.ArrayModifierContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by the ByRefModifier - /// labeled alternative in . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitByRefModifier([NotNull] CILParser.ByRefModifierContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by the PtrModifier - /// labeled alternative in . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitPtrModifier([NotNull] CILParser.PtrModifierContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by the PinnedModifier - /// labeled alternative in . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitPinnedModifier([NotNull] CILParser.PinnedModifierContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by the RequiredModifier - /// labeled alternative in . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitRequiredModifier([NotNull] CILParser.RequiredModifierContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by the OptionalModifier - /// labeled alternative in . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitOptionalModifier([NotNull] CILParser.OptionalModifierContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by the GenericArgumentsModifier - /// labeled alternative in . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitGenericArgumentsModifier([NotNull] CILParser.GenericArgumentsModifierContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitElementType([NotNull] CILParser.ElementTypeContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitSimpleType([NotNull] CILParser.SimpleTypeContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitBound([NotNull] CILParser.BoundContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitNativeInt([NotNull] CILParser.NativeIntContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitNativeUint([NotNull] CILParser.NativeUintContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitSecDecl([NotNull] CILParser.SecDeclContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitSecAttrSetBlob([NotNull] CILParser.SecAttrSetBlobContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitSecAttrBlob([NotNull] CILParser.SecAttrBlobContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitNameValPairs([NotNull] CILParser.NameValPairsContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitNameValPair([NotNull] CILParser.NameValPairContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitTruefalse([NotNull] CILParser.TruefalseContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitCaValue([NotNull] CILParser.CaValueContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitSecAction([NotNull] CILParser.SecActionContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitMethodRef([NotNull] CILParser.MethodRefContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitCallConv([NotNull] CILParser.CallConvContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitCallKind([NotNull] CILParser.CallKindContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitMdtoken([NotNull] CILParser.MdtokenContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitMemberRef([NotNull] CILParser.MemberRefContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitFieldRef([NotNull] CILParser.FieldRefContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitTypeList([NotNull] CILParser.TypeListContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitTyparsClause([NotNull] CILParser.TyparsClauseContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitTyparAttrib([NotNull] CILParser.TyparAttribContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitTyparAttribs([NotNull] CILParser.TyparAttribsContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitTypar([NotNull] CILParser.TyparContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitTypars([NotNull] CILParser.TyparsContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitTyBound([NotNull] CILParser.TyBoundContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitGenArity([NotNull] CILParser.GenArityContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitGenArityNotEmpty([NotNull] CILParser.GenArityNotEmptyContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitClassDecl([NotNull] CILParser.ClassDeclContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitFieldDecl([NotNull] CILParser.FieldDeclContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitFieldAttr([NotNull] CILParser.FieldAttrContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitAtOpt([NotNull] CILParser.AtOptContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitInitOpt([NotNull] CILParser.InitOptContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitRepeatOpt([NotNull] CILParser.RepeatOptContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitEventHead([NotNull] CILParser.EventHeadContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitEventAttr([NotNull] CILParser.EventAttrContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitEventDecls([NotNull] CILParser.EventDeclsContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitEventDecl([NotNull] CILParser.EventDeclContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitPropHead([NotNull] CILParser.PropHeadContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitPropAttr([NotNull] CILParser.PropAttrContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitPropDecls([NotNull] CILParser.PropDeclsContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitPropDecl([NotNull] CILParser.PropDeclContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitMarshalClause([NotNull] CILParser.MarshalClauseContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitMarshalBlob([NotNull] CILParser.MarshalBlobContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitParamAttr([NotNull] CILParser.ParamAttrContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitParamAttrElement([NotNull] CILParser.ParamAttrElementContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitMethodHead([NotNull] CILParser.MethodHeadContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitMethAttr([NotNull] CILParser.MethAttrContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitPinvImpl([NotNull] CILParser.PinvImplContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitPinvAttr([NotNull] CILParser.PinvAttrContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitMethodName([NotNull] CILParser.MethodNameContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitImplAttr([NotNull] CILParser.ImplAttrContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitMethodDecls([NotNull] CILParser.MethodDeclsContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitMethodDecl([NotNull] CILParser.MethodDeclContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitLocalsDecl([NotNull] CILParser.LocalsDeclContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitExportDecl([NotNull] CILParser.ExportDeclContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitVtentryDecl([NotNull] CILParser.VtentryDeclContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitOverrideDecl([NotNull] CILParser.OverrideDeclContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitParameterDecl([NotNull] CILParser.ParameterDeclContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitLabelDecl([NotNull] CILParser.LabelDeclContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitCustomDescrInMethodBody([NotNull] CILParser.CustomDescrInMethodBodyContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitScopeBlock([NotNull] CILParser.ScopeBlockContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitSehBlock([NotNull] CILParser.SehBlockContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitSehClauses([NotNull] CILParser.SehClausesContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitTryBlock([NotNull] CILParser.TryBlockContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitSehClause([NotNull] CILParser.SehClauseContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitFilterClause([NotNull] CILParser.FilterClauseContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitCatchClause([NotNull] CILParser.CatchClauseContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitFinallyClause([NotNull] CILParser.FinallyClauseContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitFaultClause([NotNull] CILParser.FaultClauseContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitHandlerBlock([NotNull] CILParser.HandlerBlockContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitDataDecl([NotNull] CILParser.DataDeclContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitDdHead([NotNull] CILParser.DdHeadContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitTls([NotNull] CILParser.TlsContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitDdBody([NotNull] CILParser.DdBodyContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitDdItemList([NotNull] CILParser.DdItemListContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitDdItemCount([NotNull] CILParser.DdItemCountContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitDdItem([NotNull] CILParser.DdItemContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitFieldSerInit([NotNull] CILParser.FieldSerInitContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitBytes([NotNull] CILParser.BytesContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitHexbyte([NotNull] CILParser.HexbyteContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitFieldInit([NotNull] CILParser.FieldInitContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitSerInit([NotNull] CILParser.SerInitContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitF32seq([NotNull] CILParser.F32seqContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitF64seq([NotNull] CILParser.F64seqContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitI64seq([NotNull] CILParser.I64seqContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitI32seq([NotNull] CILParser.I32seqContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitI16seq([NotNull] CILParser.I16seqContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitI8seq([NotNull] CILParser.I8seqContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitBoolSeq([NotNull] CILParser.BoolSeqContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitSqstringSeq([NotNull] CILParser.SqstringSeqContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitClassSeq([NotNull] CILParser.ClassSeqContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitClassSeqElement([NotNull] CILParser.ClassSeqElementContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitObjSeq([NotNull] CILParser.ObjSeqContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitCustomAttrDecl([NotNull] CILParser.CustomAttrDeclContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitAsmOrRefDecl([NotNull] CILParser.AsmOrRefDeclContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitAssemblyRefBlock([NotNull] CILParser.AssemblyRefBlockContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitAssemblyRefHead([NotNull] CILParser.AssemblyRefHeadContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitAssemblyRefDecls([NotNull] CILParser.AssemblyRefDeclsContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitAssemblyRefDecl([NotNull] CILParser.AssemblyRefDeclContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitExptypeBlock([NotNull] CILParser.ExptypeBlockContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitExptypeHead([NotNull] CILParser.ExptypeHeadContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitExportHead([NotNull] CILParser.ExportHeadContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitExptAttrs([NotNull] CILParser.ExptAttrsContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitExptAttr([NotNull] CILParser.ExptAttrContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitExptypeDecls([NotNull] CILParser.ExptypeDeclsContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitExptypeDecl([NotNull] CILParser.ExptypeDeclContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitManifestResBlock([NotNull] CILParser.ManifestResBlockContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitManifestResHead([NotNull] CILParser.ManifestResHeadContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitManresAttrs([NotNull] CILParser.ManresAttrsContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitManresAttr([NotNull] CILParser.ManresAttrContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitManifestResDecls([NotNull] CILParser.ManifestResDeclsContext context) { return VisitChildren(context); } - /// - /// Visit a parse tree produced by . - /// - /// The default implementation returns the result of calling - /// on . - /// - /// - /// The parse tree. - /// The visitor result. - public virtual Result VisitManifestResDecl([NotNull] CILParser.ManifestResDeclContext context) { return VisitChildren(context); } -} -} // namespace ILAssembler diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs index 8dd04e4ab6e1ce..bb1c6a677011f3 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs @@ -310,12 +310,6 @@ public IdContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_id; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitId(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -371,12 +365,6 @@ public DottedNameContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_dottedName; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitDottedName(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -460,12 +448,6 @@ public DottedNamePartContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_dottedNamePart; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitDottedNamePart(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -517,12 +499,6 @@ public CompQstringContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_compQstring; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitCompQstring(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -582,12 +558,6 @@ public DeclsContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_decls; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitDecls(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -734,12 +704,6 @@ public DeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_decl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -1009,12 +973,6 @@ public SubsystemContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_subsystem; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitSubsystem(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -1052,12 +1010,6 @@ public CorflagsContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_corflags; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitCorflags(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -1095,12 +1047,6 @@ public AlignmentContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_alignment; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitAlignment(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -1140,12 +1086,6 @@ public ImagebaseContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_imagebase; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitImagebase(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -1183,12 +1123,6 @@ public StackreserveContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_stackreserve; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitStackreserve(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -1236,12 +1170,6 @@ public AssemblyBlockContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_assemblyBlock; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitAssemblyBlock(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -1288,12 +1216,6 @@ public MscorlibContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_mscorlib; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitMscorlib(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -1335,12 +1257,6 @@ public LanguageDeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_languageDecl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitLanguageDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -1417,12 +1333,6 @@ public LanguageStringContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_languageString; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitLanguageString(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -1470,12 +1380,6 @@ public TypelistContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_typelist; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitTypelist(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -1528,12 +1432,6 @@ public Int32Context(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_int32; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitInt32(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -1566,12 +1464,6 @@ public Int64Context(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_int64; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitInt64(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -1626,12 +1518,6 @@ public Float64Context(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_float64; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitFloat64(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -1721,12 +1607,6 @@ public IntOrWildcardContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_intOrWildcard; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitIntOrWildcard(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -1783,12 +1663,6 @@ public CompControlContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_compControl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitCompControl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -1921,12 +1795,6 @@ public TypedefDeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_typedefDecl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitTypedefDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -2052,12 +1920,6 @@ public CustomDescrContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_customDescr; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitCustomDescr(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -2171,12 +2033,6 @@ public CustomDescrWithOwnerContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_customDescrWithOwner; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitCustomDescrWithOwner(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -2297,12 +2153,6 @@ public CustomTypeContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_customType; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitCustomType(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -2344,12 +2194,6 @@ public OwnerTypeContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_ownerType; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitOwnerType(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -2406,12 +2250,6 @@ public CustomBlobDescrContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_customBlobDescr; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitCustomBlobDescr(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -2459,12 +2297,6 @@ public CustomBlobArgsContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_customBlobArgs; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitCustomBlobArgs(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -2584,12 +2416,6 @@ public CustomBlobNVPairsContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_customBlobNVPairs; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitCustomBlobNVPairs(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -2673,12 +2499,6 @@ public FieldOrPropContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_fieldOrProp; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitFieldOrProp(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -2726,12 +2546,6 @@ public SerializTypeContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_serializType; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitSerializType(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -2793,12 +2607,6 @@ public SerializTypeElementContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_serializTypeElement; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitSerializTypeElement(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -2890,12 +2698,6 @@ public ModuleHeadContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_moduleHead; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitModuleHead(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -2969,12 +2771,6 @@ public VtfixupDeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_vtfixupDecl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitVtfixupDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -3031,12 +2827,6 @@ public VtfixupAttrContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_vtfixupAttr; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitVtfixupAttr(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -3086,12 +2876,6 @@ public VtfixupAttrElementContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_vtfixupAttrElement; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitVtfixupAttrElement(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -3138,12 +2922,6 @@ public VtableDeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_vtableDecl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitVtableDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -3190,12 +2968,6 @@ public NameSpaceHeadContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_nameSpaceHead; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitNameSpaceHead(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -3257,12 +3029,6 @@ public ClassHeadContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_classHead; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitClassHead(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -3342,12 +3108,6 @@ public ClassAttrContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_classAttr; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitClassAttr(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -3616,12 +3376,6 @@ public ExtendsClauseContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_extendsClause; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitExtendsClause(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -3675,12 +3429,6 @@ public ImplClauseContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_implClause; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitImplClause(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -3734,12 +3482,6 @@ public ClassDeclsContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_classDecls; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitClassDecls(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -3794,12 +3536,6 @@ public ImplListContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_implList; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitImplList(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -3854,12 +3590,6 @@ public EsHeadContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_esHead; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitEsHead(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -3921,12 +3651,6 @@ public ExtSourceSpecContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_extSourceSpec; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitExtSourceSpec(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -4173,12 +3897,6 @@ public FileDeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_fileDecl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitFileDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -4256,12 +3974,6 @@ public FileAttrContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_fileAttr; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitFileAttr(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -4297,12 +4009,6 @@ public FileEntryContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_fileEntry; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitFileEntry(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -4389,12 +4095,6 @@ public AsmAttrAnyContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_asmAttrAny; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitAsmAttrAny(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -4443,12 +4143,6 @@ public AsmAttrContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_asmAttr; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitAsmAttr(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -4530,12 +4224,6 @@ public InstrContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_instr; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitInstr(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -4677,12 +4365,6 @@ public SimpleInstrContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_simpleInstr; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitSimpleInstr(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -4929,12 +4611,6 @@ public CalliSignatureContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_calliSignature; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitCalliSignature(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -4988,12 +4664,6 @@ public LabelsContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_labels; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitLabels(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -5159,12 +4829,6 @@ public TypeArgsContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_typeArgs; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitTypeArgs(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -5231,12 +4895,6 @@ public BoundsContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_bounds; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitBounds(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -5303,12 +4961,6 @@ public SigArgsContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_sigArgs; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitSigArgs(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -5399,12 +5051,6 @@ public SigArgContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_sigArg; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitSigArg(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -5485,12 +5131,6 @@ public ClassNameContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_className; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitClassName(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -5627,12 +5267,6 @@ public SlashedNameContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_slashedName; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitSlashedName(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -5694,12 +5328,6 @@ public AssemblyDeclsContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_assemblyDecls; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitAssemblyDecls(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -5760,12 +5388,6 @@ public AssemblyDeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_assemblyDecl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitAssemblyDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -5862,12 +5484,6 @@ public TypeSpecContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_typeSpec; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitTypeSpec(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -5953,12 +5569,6 @@ public NativeTypeContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_nativeType; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitNativeType(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -6035,12 +5645,6 @@ [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); } public PointerArrayTypeSizeContext(NativeTypeArrayPointerInfoContext context) { CopyFrom(context); } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitPointerArrayTypeSize(this); - else return visitor.VisitChildren(this); - } } public partial class PointerArrayTypeParamIndexContext : NativeTypeArrayPointerInfoContext { public Int32Context parameterIndex; @@ -6049,22 +5653,10 @@ [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); } public PointerArrayTypeParamIndexContext(NativeTypeArrayPointerInfoContext context) { CopyFrom(context); } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitPointerArrayTypeParamIndex(this); - else return visitor.VisitChildren(this); - } } public partial class PointerNativeTypeContext : NativeTypeArrayPointerInfoContext { [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PTR() { return GetToken(CILParser.PTR, 0); } public PointerNativeTypeContext(NativeTypeArrayPointerInfoContext context) { CopyFrom(context); } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitPointerNativeType(this); - else return visitor.VisitChildren(this); - } } public partial class PointerArrayTypeSizeParamIndexContext : NativeTypeArrayPointerInfoContext { public Int32Context size; @@ -6077,22 +5669,10 @@ [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32(int i) { return GetRuleContext(i); } public PointerArrayTypeSizeParamIndexContext(NativeTypeArrayPointerInfoContext context) { CopyFrom(context); } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitPointerArrayTypeSizeParamIndex(this); - else return visitor.VisitChildren(this); - } } public partial class PointerArrayTypeNoSizeDataContext : NativeTypeArrayPointerInfoContext { [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ARRAY_TYPE_NO_BOUNDS() { return GetToken(CILParser.ARRAY_TYPE_NO_BOUNDS, 0); } public PointerArrayTypeNoSizeDataContext(NativeTypeArrayPointerInfoContext context) { CopyFrom(context); } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitPointerArrayTypeNoSizeData(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -6260,12 +5840,6 @@ public NativeTypeElementContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_nativeTypeElement; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitNativeTypeElement(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -6767,12 +6341,6 @@ public IidParamIndexContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_iidParamIndex; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitIidParamIndex(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -6846,12 +6414,6 @@ public VariantTypeContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_variantType; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitVariantType(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -6965,12 +6527,6 @@ public VariantTypeElementContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_variantTypeElement; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitVariantTypeElement(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -7334,12 +6890,6 @@ public TypeContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_type; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitType(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -7405,22 +6955,10 @@ [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() { return GetRuleContext(0); } public OptionalModifierContext(TypeModifiersContext context) { CopyFrom(context); } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitOptionalModifier(this); - else return visitor.VisitChildren(this); - } } public partial class SZArrayModifierContext : TypeModifiersContext { [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ARRAY_TYPE_NO_BOUNDS() { return GetToken(CILParser.ARRAY_TYPE_NO_BOUNDS, 0); } public SZArrayModifierContext(TypeModifiersContext context) { CopyFrom(context); } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitSZArrayModifier(this); - else return visitor.VisitChildren(this); - } } public partial class RequiredModifierContext : TypeModifiersContext { public TypeSpecContext modifierType; @@ -7428,31 +6966,13 @@ [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() { return GetRuleContext(0); } public RequiredModifierContext(TypeModifiersContext context) { CopyFrom(context); } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitRequiredModifier(this); - else return visitor.VisitChildren(this); - } } public partial class PtrModifierContext : TypeModifiersContext { [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PTR() { return GetToken(CILParser.PTR, 0); } public PtrModifierContext(TypeModifiersContext context) { CopyFrom(context); } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitPtrModifier(this); - else return visitor.VisitChildren(this); - } } public partial class PinnedModifierContext : TypeModifiersContext { public PinnedModifierContext(TypeModifiersContext context) { CopyFrom(context); } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitPinnedModifier(this); - else return visitor.VisitChildren(this); - } } public partial class GenericArgumentsModifierContext : TypeModifiersContext { public TypeArgsContext arguments; @@ -7460,22 +6980,10 @@ [System.Diagnostics.DebuggerNonUserCode] public TypeArgsContext typeArgs() { return GetRuleContext(0); } public GenericArgumentsModifierContext(TypeModifiersContext context) { CopyFrom(context); } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitGenericArgumentsModifier(this); - else return visitor.VisitChildren(this); - } } public partial class ByRefModifierContext : TypeModifiersContext { [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode REF() { return GetToken(CILParser.REF, 0); } public ByRefModifierContext(TypeModifiersContext context) { CopyFrom(context); } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitByRefModifier(this); - else return visitor.VisitChildren(this); - } } public partial class ArrayModifierContext : TypeModifiersContext { public BoundsContext arrayBounds; @@ -7483,12 +6991,6 @@ [System.Diagnostics.DebuggerNonUserCode] public BoundsContext bounds() { return GetRuleContext(0); } public ArrayModifierContext(TypeModifiersContext context) { CopyFrom(context); } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitArrayModifier(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -7664,12 +7166,6 @@ public ElementTypeContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_elementType; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitElementType(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -7868,12 +7364,6 @@ public SimpleTypeContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_simpleType; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitSimpleType(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -8061,12 +7551,6 @@ public BoundContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_bound; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitBound(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -8141,12 +7625,6 @@ public NativeIntContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_nativeInt; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitNativeInt(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -8183,12 +7661,6 @@ public NativeUintContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_nativeUint; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitNativeUint(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -8272,12 +7744,6 @@ public SecDeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_secDecl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitSecDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -8451,12 +7917,6 @@ public SecAttrSetBlobContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_secAttrSetBlob; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitSecAttrSetBlob(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -8568,12 +8028,6 @@ public SecAttrBlobContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_secAttrBlob; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitSecAttrBlob(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -8646,12 +8100,6 @@ public NameValPairsContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_nameValPairs; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitNameValPairs(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -8714,12 +8162,6 @@ public NameValPairContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_nameValPair; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitNameValPair(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -8756,12 +8198,6 @@ public TruefalseContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_truefalse; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitTruefalse(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -8824,12 +8260,6 @@ public CaValueContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_caValue; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitCaValue(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -8966,12 +8396,6 @@ public SecActionContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_secAction; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitSecAction(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -9051,12 +8475,6 @@ public MethodRefContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_methodRef; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitMethodRef(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -9208,12 +8626,6 @@ public CallConvContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_callConv; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitCallConv(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -9294,12 +8706,6 @@ public CallKindContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_callKind; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitCallKind(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -9405,12 +8811,6 @@ public MdtokenContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_mdtoken; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitMdtoken(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -9464,12 +8864,6 @@ public MemberRefContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_memberRef; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitMemberRef(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -9545,12 +8939,6 @@ public FieldRefContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_fieldRef; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitFieldRef(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -9623,12 +9011,6 @@ public TypeListContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_typeList; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitTypeList(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -9687,12 +9069,6 @@ public TyparsClauseContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_typarsClause; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitTyparsClause(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -9759,12 +9135,6 @@ public TyparAttribContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_typarAttrib; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitTyparAttrib(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -9866,12 +9236,6 @@ public TyparAttribsContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_typarAttribs; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitTyparAttribs(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -9931,12 +9295,6 @@ public TyparContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_typar; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitTypar(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -9990,12 +9348,6 @@ public TyparsContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_typars; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitTypars(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -10054,12 +9406,6 @@ public TyBoundContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_tyBound; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitTyBound(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -10100,12 +9446,6 @@ public GenArityContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_genArity; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitGenArity(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -10151,12 +9491,6 @@ public GenArityNotEmptyContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_genArityNotEmpty; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitGenArityNotEmpty(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -10335,12 +9669,6 @@ public ClassDeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_classDecl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitClassDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -10788,12 +10116,6 @@ public FieldDeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_fieldDecl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitFieldDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -10904,12 +10226,6 @@ public FieldAttrContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_fieldAttr; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitFieldAttr(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -11076,12 +10392,6 @@ public AtOptContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_atOpt; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitAtOpt(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -11142,12 +10452,6 @@ public InitOptContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_initOpt; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitInitOpt(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -11285,12 +10589,6 @@ public RepeatOptContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_repeatOpt; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitRepeatOpt(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -11399,12 +10697,6 @@ public EventHeadContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_eventHead; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitEventHead(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -11491,12 +10783,6 @@ public EventAttrContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_eventAttr; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitEventAttr(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -11550,12 +10836,6 @@ public EventDeclsContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_eventDecls; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitEventDecls(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -11618,12 +10898,6 @@ public EventDeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_eventDecl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitEventDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -11768,12 +11042,6 @@ public PropHeadContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_propHead; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitPropHead(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -11841,12 +11109,6 @@ public PropAttrContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_propAttr; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitPropAttr(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -11900,12 +11162,6 @@ public PropDeclsContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_propDecls; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitPropDecls(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -11968,12 +11224,6 @@ public PropDeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_propDecl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitPropDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -12085,12 +11335,6 @@ public MarshalClauseContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_marshalClause; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitMarshalClause(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -12179,12 +11423,6 @@ public MarshalBlobContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_marshalBlob; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitMarshalBlob(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -12308,12 +11546,6 @@ public ParamAttrContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_paramAttr; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitParamAttr(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -12367,12 +11599,6 @@ public ParamAttrElementContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_paramAttrElement; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitParamAttrElement(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -12500,12 +11726,6 @@ public MethodHeadContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_methodHead; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitMethodHead(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -12633,12 +11853,6 @@ public MethAttrContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_methAttr; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitMethAttr(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -12844,12 +12058,6 @@ public PinvImplContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_pinvImpl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitPinvImpl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -12953,12 +12161,6 @@ public PinvAttrContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_pinvAttr; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitPinvAttr(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -13137,12 +12339,6 @@ public MethodNameContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_methodName; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitMethodName(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -13210,12 +12406,6 @@ public ImplAttrContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_implAttr; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitImplAttr(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -13395,12 +12585,6 @@ public MethodDeclsContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_methodDecls; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitMethodDecls(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -13504,12 +12688,6 @@ public MethodDeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_methodDecl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitMethodDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -13733,12 +12911,6 @@ public LocalsDeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_localsDecl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitLocalsDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -13793,12 +12965,6 @@ public ExportDeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_exportDecl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitExportDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -13859,12 +13025,6 @@ public VtentryDeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_vtentryDecl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitVtentryDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -13930,12 +13090,6 @@ public OverrideDeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_overrideDecl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitOverrideDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -14032,12 +13186,6 @@ public ParameterDeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_parameterDecl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitParameterDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -14234,12 +13382,6 @@ public LabelDeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_labelDecl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitLabelDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -14283,12 +13425,6 @@ public CustomDescrInMethodBodyContext(ParserRuleContext parent, int invokingStat { } public override int RuleIndex { get { return RULE_customDescrInMethodBody; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitCustomDescrInMethodBody(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -14339,12 +13475,6 @@ public ScopeBlockContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_scopeBlock; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitScopeBlock(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -14389,12 +13519,6 @@ public SehBlockContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_sehBlock; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitSehBlock(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -14437,12 +13561,6 @@ public SehClausesContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_sehClauses; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitSehClauses(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -14510,12 +13628,6 @@ public TryBlockContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_tryBlock; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitTryBlock(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -14602,12 +13714,6 @@ public SehClauseContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_sehClause; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitSehClause(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -14692,12 +13798,6 @@ public FilterClauseContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_filterClause; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitFilterClause(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -14762,12 +13862,6 @@ public CatchClauseContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_catchClause; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitCatchClause(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -14802,12 +13896,6 @@ public FinallyClauseContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_finallyClause; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitFinallyClause(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -14838,12 +13926,6 @@ public FaultClauseContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_faultClause; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitFaultClause(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -14895,12 +13977,6 @@ public HandlerBlockContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_handlerBlock; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitHandlerBlock(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -14973,12 +14049,6 @@ public DataDeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_dataDecl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitDataDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -15021,12 +14091,6 @@ public DdHeadContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_ddHead; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitDdHead(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -15081,12 +14145,6 @@ public TlsContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_tls; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitTls(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -15147,12 +14205,6 @@ public DdBodyContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_ddBody; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitDdBody(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -15229,12 +14281,6 @@ public DdItemListContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_ddItemList; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitDdItemList(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -15289,12 +14335,6 @@ public DdItemCountContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_ddItemCount; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitDdItemCount(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -15475,12 +14515,6 @@ public DdItemContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_ddItem; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitDdItem(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -15700,12 +14734,6 @@ public FieldSerInitContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_fieldSerInit; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitFieldSerInit(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -15954,12 +14982,6 @@ public BytesContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_bytes; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitBytes(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -16010,12 +15032,6 @@ public HexbyteContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_hexbyte; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitHexbyte(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -16066,12 +15082,6 @@ public FieldInitContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_fieldInit; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitFieldInit(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -16249,12 +15259,6 @@ public SerInitContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_serInit; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitSerInit(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -16693,12 +15697,6 @@ public F32seqContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_f32seq; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitF32seq(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -16773,12 +15771,6 @@ public F64seqContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_f64seq; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitF64seq(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -16846,12 +15838,6 @@ public I64seqContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_i64seq; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitI64seq(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -16906,12 +15892,6 @@ public I32seqContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_i32seq; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitI32seq(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -16966,12 +15946,6 @@ public I16seqContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_i16seq; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitI16seq(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -17026,12 +16000,6 @@ public I8seqContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_i8seq; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitI8seq(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -17086,12 +16054,6 @@ public BoolSeqContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_boolSeq; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitBoolSeq(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -17149,12 +16111,6 @@ public SqstringSeqContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_sqstringSeq; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitSqstringSeq(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -17224,12 +16180,6 @@ public ClassSeqContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_classSeq; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitClassSeq(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -17284,12 +16234,6 @@ public ClassSeqElementContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_classSeqElement; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitClassSeqElement(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -17365,12 +16309,6 @@ public ObjSeqContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_objSeq; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitObjSeq(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -17431,12 +16369,6 @@ public CustomAttrDeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_customAttrDecl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitCustomAttrDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -17519,12 +16451,6 @@ public AsmOrRefDeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_asmOrRefDecl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitAsmOrRefDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -17657,12 +16583,6 @@ public AssemblyRefBlockContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_assemblyRefBlock; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitAssemblyRefBlock(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -17717,12 +16637,6 @@ public AssemblyRefHeadContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_assemblyRefHead; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitAssemblyRefHead(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -17798,12 +16712,6 @@ public AssemblyRefDeclsContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_assemblyRefDecls; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitAssemblyRefDecls(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -17861,12 +16769,6 @@ public AssemblyRefDeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_assemblyRefDecl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitAssemblyRefDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -17974,12 +16876,6 @@ public ExptypeBlockContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_exptypeBlock; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitExptypeBlock(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -18032,12 +16928,6 @@ public ExptypeHeadContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_exptypeHead; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitExptypeHead(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -18089,12 +16979,6 @@ public ExportHeadContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_exportHead; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitExportHead(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -18141,12 +17025,6 @@ public ExptAttrsContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_exptAttrs; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitExptAttrs(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -18197,12 +17075,6 @@ public ExptAttrContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_exptAttr; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitExptAttr(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -18317,12 +17189,6 @@ public ExptypeDeclsContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_exptypeDecls; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitExptypeDecls(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -18395,12 +17261,6 @@ public ExptypeDeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_exptypeDecl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitExptypeDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -18518,12 +17378,6 @@ public ManifestResBlockContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_manifestResBlock; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitManifestResBlock(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -18581,12 +17435,6 @@ public ManifestResHeadContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_manifestResHead; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitManifestResHead(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -18660,12 +17508,6 @@ public ManresAttrsContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_manresAttrs; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitManresAttrs(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -18714,12 +17556,6 @@ public ManresAttrContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_manresAttr; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitManresAttr(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -18768,12 +17604,6 @@ public ManifestResDeclsContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_manifestResDecls; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitManifestResDecls(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] @@ -18837,12 +17667,6 @@ public ManifestResDeclContext(ParserRuleContext parent, int invokingState) { } public override int RuleIndex { get { return RULE_manifestResDecl; } } - [System.Diagnostics.DebuggerNonUserCode] - public override TResult Accept(IParseTreeVisitor visitor) { - ICILVisitor typedVisitor = visitor as ICILVisitor; - if (typedVisitor != null) return typedVisitor.VisitManifestResDecl(this); - else return visitor.VisitChildren(this); - } } [RuleVersion(0)] diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILVisitor.cs b/src/tools/ilasm/src/ILAssembler/gen/CILVisitor.cs deleted file mode 100644 index ea16aa74a30944..00000000000000 --- a/src/tools/ilasm/src/ILAssembler/gen/CILVisitor.cs +++ /dev/null @@ -1,1225 +0,0 @@ -//------------------------------------------------------------------------------ -// -// This code was generated by a tool. -// ANTLR Version: 4.13.1 -// -// Changes to this file may cause incorrect behavior and will be lost if -// the code is regenerated. -// -//------------------------------------------------------------------------------ - -// Generated from CIL.g4 by ANTLR 4.13.1 - -// Unreachable code detected -#pragma warning disable 0162 -// The variable '...' is assigned but its value is never used -#pragma warning disable 0219 -// Missing XML comment for publicly visible type or member '...' -#pragma warning disable 1591 -// Ambiguous reference in cref attribute -#pragma warning disable 419 - -namespace ILAssembler { -using Antlr4.Runtime.Misc; -using Antlr4.Runtime.Tree; -using IToken = Antlr4.Runtime.IToken; - -/// -/// This interface defines a complete generic visitor for a parse tree produced -/// by . -/// -/// The return type of the visit operation. -[System.CodeDom.Compiler.GeneratedCode("ANTLR", "4.13.1")] -[System.CLSCompliant(false)] -public interface ICILVisitor : IParseTreeVisitor { - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitId([NotNull] CILParser.IdContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitDottedName([NotNull] CILParser.DottedNameContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitDottedNamePart([NotNull] CILParser.DottedNamePartContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitCompQstring([NotNull] CILParser.CompQstringContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitDecls([NotNull] CILParser.DeclsContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitDecl([NotNull] CILParser.DeclContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitSubsystem([NotNull] CILParser.SubsystemContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitCorflags([NotNull] CILParser.CorflagsContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitAlignment([NotNull] CILParser.AlignmentContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitImagebase([NotNull] CILParser.ImagebaseContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitStackreserve([NotNull] CILParser.StackreserveContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitAssemblyBlock([NotNull] CILParser.AssemblyBlockContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitMscorlib([NotNull] CILParser.MscorlibContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitLanguageDecl([NotNull] CILParser.LanguageDeclContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitLanguageString([NotNull] CILParser.LanguageStringContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitTypelist([NotNull] CILParser.TypelistContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitInt32([NotNull] CILParser.Int32Context context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitInt64([NotNull] CILParser.Int64Context context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitFloat64([NotNull] CILParser.Float64Context context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitIntOrWildcard([NotNull] CILParser.IntOrWildcardContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitCompControl([NotNull] CILParser.CompControlContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitTypedefDecl([NotNull] CILParser.TypedefDeclContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitCustomDescr([NotNull] CILParser.CustomDescrContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitCustomDescrWithOwner([NotNull] CILParser.CustomDescrWithOwnerContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitCustomType([NotNull] CILParser.CustomTypeContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitOwnerType([NotNull] CILParser.OwnerTypeContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitCustomBlobDescr([NotNull] CILParser.CustomBlobDescrContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitCustomBlobArgs([NotNull] CILParser.CustomBlobArgsContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitCustomBlobNVPairs([NotNull] CILParser.CustomBlobNVPairsContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitFieldOrProp([NotNull] CILParser.FieldOrPropContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitSerializType([NotNull] CILParser.SerializTypeContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitSerializTypeElement([NotNull] CILParser.SerializTypeElementContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitModuleHead([NotNull] CILParser.ModuleHeadContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitVtfixupDecl([NotNull] CILParser.VtfixupDeclContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitVtfixupAttr([NotNull] CILParser.VtfixupAttrContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitVtfixupAttrElement([NotNull] CILParser.VtfixupAttrElementContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitVtableDecl([NotNull] CILParser.VtableDeclContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitNameSpaceHead([NotNull] CILParser.NameSpaceHeadContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitClassHead([NotNull] CILParser.ClassHeadContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitClassAttr([NotNull] CILParser.ClassAttrContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitExtendsClause([NotNull] CILParser.ExtendsClauseContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitImplClause([NotNull] CILParser.ImplClauseContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitClassDecls([NotNull] CILParser.ClassDeclsContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitImplList([NotNull] CILParser.ImplListContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitEsHead([NotNull] CILParser.EsHeadContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitExtSourceSpec([NotNull] CILParser.ExtSourceSpecContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitFileDecl([NotNull] CILParser.FileDeclContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitFileAttr([NotNull] CILParser.FileAttrContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitFileEntry([NotNull] CILParser.FileEntryContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitAsmAttrAny([NotNull] CILParser.AsmAttrAnyContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitAsmAttr([NotNull] CILParser.AsmAttrContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitInstr([NotNull] CILParser.InstrContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitSimpleInstr([NotNull] CILParser.SimpleInstrContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitCalliSignature([NotNull] CILParser.CalliSignatureContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitLabels([NotNull] CILParser.LabelsContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitTypeArgs([NotNull] CILParser.TypeArgsContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitBounds([NotNull] CILParser.BoundsContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitSigArgs([NotNull] CILParser.SigArgsContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitSigArg([NotNull] CILParser.SigArgContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitClassName([NotNull] CILParser.ClassNameContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitSlashedName([NotNull] CILParser.SlashedNameContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitAssemblyDecls([NotNull] CILParser.AssemblyDeclsContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitAssemblyDecl([NotNull] CILParser.AssemblyDeclContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitTypeSpec([NotNull] CILParser.TypeSpecContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitNativeType([NotNull] CILParser.NativeTypeContext context); - /// - /// Visit a parse tree produced by the PointerNativeType - /// labeled alternative in . - /// - /// The parse tree. - /// The visitor result. - Result VisitPointerNativeType([NotNull] CILParser.PointerNativeTypeContext context); - /// - /// Visit a parse tree produced by the PointerArrayTypeNoSizeData - /// labeled alternative in . - /// - /// The parse tree. - /// The visitor result. - Result VisitPointerArrayTypeNoSizeData([NotNull] CILParser.PointerArrayTypeNoSizeDataContext context); - /// - /// Visit a parse tree produced by the PointerArrayTypeSize - /// labeled alternative in . - /// - /// The parse tree. - /// The visitor result. - Result VisitPointerArrayTypeSize([NotNull] CILParser.PointerArrayTypeSizeContext context); - /// - /// Visit a parse tree produced by the PointerArrayTypeSizeParamIndex - /// labeled alternative in . - /// - /// The parse tree. - /// The visitor result. - Result VisitPointerArrayTypeSizeParamIndex([NotNull] CILParser.PointerArrayTypeSizeParamIndexContext context); - /// - /// Visit a parse tree produced by the PointerArrayTypeParamIndex - /// labeled alternative in . - /// - /// The parse tree. - /// The visitor result. - Result VisitPointerArrayTypeParamIndex([NotNull] CILParser.PointerArrayTypeParamIndexContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitNativeTypeElement([NotNull] CILParser.NativeTypeElementContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitIidParamIndex([NotNull] CILParser.IidParamIndexContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitVariantType([NotNull] CILParser.VariantTypeContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitVariantTypeElement([NotNull] CILParser.VariantTypeElementContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitType([NotNull] CILParser.TypeContext context); - /// - /// Visit a parse tree produced by the SZArrayModifier - /// labeled alternative in . - /// - /// The parse tree. - /// The visitor result. - Result VisitSZArrayModifier([NotNull] CILParser.SZArrayModifierContext context); - /// - /// Visit a parse tree produced by the ArrayModifier - /// labeled alternative in . - /// - /// The parse tree. - /// The visitor result. - Result VisitArrayModifier([NotNull] CILParser.ArrayModifierContext context); - /// - /// Visit a parse tree produced by the ByRefModifier - /// labeled alternative in . - /// - /// The parse tree. - /// The visitor result. - Result VisitByRefModifier([NotNull] CILParser.ByRefModifierContext context); - /// - /// Visit a parse tree produced by the PtrModifier - /// labeled alternative in . - /// - /// The parse tree. - /// The visitor result. - Result VisitPtrModifier([NotNull] CILParser.PtrModifierContext context); - /// - /// Visit a parse tree produced by the PinnedModifier - /// labeled alternative in . - /// - /// The parse tree. - /// The visitor result. - Result VisitPinnedModifier([NotNull] CILParser.PinnedModifierContext context); - /// - /// Visit a parse tree produced by the RequiredModifier - /// labeled alternative in . - /// - /// The parse tree. - /// The visitor result. - Result VisitRequiredModifier([NotNull] CILParser.RequiredModifierContext context); - /// - /// Visit a parse tree produced by the OptionalModifier - /// labeled alternative in . - /// - /// The parse tree. - /// The visitor result. - Result VisitOptionalModifier([NotNull] CILParser.OptionalModifierContext context); - /// - /// Visit a parse tree produced by the GenericArgumentsModifier - /// labeled alternative in . - /// - /// The parse tree. - /// The visitor result. - Result VisitGenericArgumentsModifier([NotNull] CILParser.GenericArgumentsModifierContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitElementType([NotNull] CILParser.ElementTypeContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitSimpleType([NotNull] CILParser.SimpleTypeContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitBound([NotNull] CILParser.BoundContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitNativeInt([NotNull] CILParser.NativeIntContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitNativeUint([NotNull] CILParser.NativeUintContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitSecDecl([NotNull] CILParser.SecDeclContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitSecAttrSetBlob([NotNull] CILParser.SecAttrSetBlobContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitSecAttrBlob([NotNull] CILParser.SecAttrBlobContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitNameValPairs([NotNull] CILParser.NameValPairsContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitNameValPair([NotNull] CILParser.NameValPairContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitTruefalse([NotNull] CILParser.TruefalseContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitCaValue([NotNull] CILParser.CaValueContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitSecAction([NotNull] CILParser.SecActionContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitMethodRef([NotNull] CILParser.MethodRefContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitCallConv([NotNull] CILParser.CallConvContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitCallKind([NotNull] CILParser.CallKindContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitMdtoken([NotNull] CILParser.MdtokenContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitMemberRef([NotNull] CILParser.MemberRefContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitFieldRef([NotNull] CILParser.FieldRefContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitTypeList([NotNull] CILParser.TypeListContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitTyparsClause([NotNull] CILParser.TyparsClauseContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitTyparAttrib([NotNull] CILParser.TyparAttribContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitTyparAttribs([NotNull] CILParser.TyparAttribsContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitTypar([NotNull] CILParser.TyparContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitTypars([NotNull] CILParser.TyparsContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitTyBound([NotNull] CILParser.TyBoundContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitGenArity([NotNull] CILParser.GenArityContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitGenArityNotEmpty([NotNull] CILParser.GenArityNotEmptyContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitClassDecl([NotNull] CILParser.ClassDeclContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitFieldDecl([NotNull] CILParser.FieldDeclContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitFieldAttr([NotNull] CILParser.FieldAttrContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitAtOpt([NotNull] CILParser.AtOptContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitInitOpt([NotNull] CILParser.InitOptContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitRepeatOpt([NotNull] CILParser.RepeatOptContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitEventHead([NotNull] CILParser.EventHeadContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitEventAttr([NotNull] CILParser.EventAttrContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitEventDecls([NotNull] CILParser.EventDeclsContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitEventDecl([NotNull] CILParser.EventDeclContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitPropHead([NotNull] CILParser.PropHeadContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitPropAttr([NotNull] CILParser.PropAttrContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitPropDecls([NotNull] CILParser.PropDeclsContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitPropDecl([NotNull] CILParser.PropDeclContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitMarshalClause([NotNull] CILParser.MarshalClauseContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitMarshalBlob([NotNull] CILParser.MarshalBlobContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitParamAttr([NotNull] CILParser.ParamAttrContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitParamAttrElement([NotNull] CILParser.ParamAttrElementContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitMethodHead([NotNull] CILParser.MethodHeadContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitMethAttr([NotNull] CILParser.MethAttrContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitPinvImpl([NotNull] CILParser.PinvImplContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitPinvAttr([NotNull] CILParser.PinvAttrContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitMethodName([NotNull] CILParser.MethodNameContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitImplAttr([NotNull] CILParser.ImplAttrContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitMethodDecls([NotNull] CILParser.MethodDeclsContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitMethodDecl([NotNull] CILParser.MethodDeclContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitLocalsDecl([NotNull] CILParser.LocalsDeclContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitExportDecl([NotNull] CILParser.ExportDeclContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitVtentryDecl([NotNull] CILParser.VtentryDeclContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitOverrideDecl([NotNull] CILParser.OverrideDeclContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitParameterDecl([NotNull] CILParser.ParameterDeclContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitLabelDecl([NotNull] CILParser.LabelDeclContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitCustomDescrInMethodBody([NotNull] CILParser.CustomDescrInMethodBodyContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitScopeBlock([NotNull] CILParser.ScopeBlockContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitSehBlock([NotNull] CILParser.SehBlockContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitSehClauses([NotNull] CILParser.SehClausesContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitTryBlock([NotNull] CILParser.TryBlockContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitSehClause([NotNull] CILParser.SehClauseContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitFilterClause([NotNull] CILParser.FilterClauseContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitCatchClause([NotNull] CILParser.CatchClauseContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitFinallyClause([NotNull] CILParser.FinallyClauseContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitFaultClause([NotNull] CILParser.FaultClauseContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitHandlerBlock([NotNull] CILParser.HandlerBlockContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitDataDecl([NotNull] CILParser.DataDeclContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitDdHead([NotNull] CILParser.DdHeadContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitTls([NotNull] CILParser.TlsContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitDdBody([NotNull] CILParser.DdBodyContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitDdItemList([NotNull] CILParser.DdItemListContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitDdItemCount([NotNull] CILParser.DdItemCountContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitDdItem([NotNull] CILParser.DdItemContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitFieldSerInit([NotNull] CILParser.FieldSerInitContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitBytes([NotNull] CILParser.BytesContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitHexbyte([NotNull] CILParser.HexbyteContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitFieldInit([NotNull] CILParser.FieldInitContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitSerInit([NotNull] CILParser.SerInitContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitF32seq([NotNull] CILParser.F32seqContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitF64seq([NotNull] CILParser.F64seqContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitI64seq([NotNull] CILParser.I64seqContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitI32seq([NotNull] CILParser.I32seqContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitI16seq([NotNull] CILParser.I16seqContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitI8seq([NotNull] CILParser.I8seqContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitBoolSeq([NotNull] CILParser.BoolSeqContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitSqstringSeq([NotNull] CILParser.SqstringSeqContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitClassSeq([NotNull] CILParser.ClassSeqContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitClassSeqElement([NotNull] CILParser.ClassSeqElementContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitObjSeq([NotNull] CILParser.ObjSeqContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitCustomAttrDecl([NotNull] CILParser.CustomAttrDeclContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitAsmOrRefDecl([NotNull] CILParser.AsmOrRefDeclContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitAssemblyRefBlock([NotNull] CILParser.AssemblyRefBlockContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitAssemblyRefHead([NotNull] CILParser.AssemblyRefHeadContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitAssemblyRefDecls([NotNull] CILParser.AssemblyRefDeclsContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitAssemblyRefDecl([NotNull] CILParser.AssemblyRefDeclContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitExptypeBlock([NotNull] CILParser.ExptypeBlockContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitExptypeHead([NotNull] CILParser.ExptypeHeadContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitExportHead([NotNull] CILParser.ExportHeadContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitExptAttrs([NotNull] CILParser.ExptAttrsContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitExptAttr([NotNull] CILParser.ExptAttrContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitExptypeDecls([NotNull] CILParser.ExptypeDeclsContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitExptypeDecl([NotNull] CILParser.ExptypeDeclContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitManifestResBlock([NotNull] CILParser.ManifestResBlockContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitManifestResHead([NotNull] CILParser.ManifestResHeadContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitManresAttrs([NotNull] CILParser.ManresAttrsContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitManresAttr([NotNull] CILParser.ManresAttrContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitManifestResDecls([NotNull] CILParser.ManifestResDeclsContext context); - /// - /// Visit a parse tree produced by . - /// - /// The parse tree. - /// The visitor result. - Result VisitManifestResDecl([NotNull] CILParser.ManifestResDeclContext context); -} -} // namespace ILAssembler diff --git a/src/tools/ilasm/src/ILAssembler/gen/ilasm-generator.csproj b/src/tools/ilasm/src/ILAssembler/gen/ilasm-generator.csproj index 1b0d358d59b2d0..48f73dbd39a46e 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/ilasm-generator.csproj +++ b/src/tools/ilasm/src/ILAssembler/gen/ilasm-generator.csproj @@ -21,6 +21,7 @@ false + false false ILAssembler $(ProjectDir) From dd2d9c309552f6a1a729d123d7c1026ffe2368bf Mon Sep 17 00:00:00 2001 From: Jeremy Koritzinsky Date: Thu, 13 Aug 2026 20:47:47 -0700 Subject: [PATCH 15/16] Remove obsolete parser-action scaffolding Replace the remaining GrammarResult wrappers with direct semantic return values and remove the parse-tree mode stack, which became redundant once tree construction stayed disabled for the entire parse. Inject the action object directly through the generated parser. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: c986c103-8383-4db4-9b11-9be49dc68a05 --- src/tools/ilasm/README.md | 23 ++--- .../ILAssembler/Actions/CILParser.Actions.cs | 28 ------ .../Actions/GrammarActions.BuildImage.cs | 1 - .../Actions/GrammarActions.Bytes.cs | 8 +- .../Actions/GrammarActions.Conversions.cs | 17 ---- ...GrammarActions.CustomAttributes.Actions.cs | 18 ++-- ...rActions.CustomAttributes.Serialization.cs | 4 +- .../GrammarActions.Declarations.Actions.cs | 20 ++--- .../GrammarActions.Instructions.References.cs | 10 +-- .../Actions/GrammarActions.Instructions.cs | 4 +- .../Actions/GrammarActions.Literals.cs | 6 +- .../GrammarActions.Manifest.Assembly.cs | 4 +- .../GrammarActions.Manifest.ExportedTypes.cs | 4 +- .../Actions/GrammarActions.Manifest.Files.cs | 4 +- .../GrammarActions.Manifest.References.cs | 4 +- .../GrammarActions.Manifest.Resources.cs | 4 +- .../GrammarActions.Manifest.Typedefs.cs | 4 +- .../Actions/GrammarActions.Manifest.VTable.cs | 6 +- .../Actions/GrammarActions.Members.Class.cs | 8 +- .../Actions/GrammarActions.Members.Fields.cs | 4 +- ...GrammarActions.Members.PropertiesEvents.cs | 4 +- .../GrammarActions.MethodBodies.Directives.cs | 10 +-- .../Actions/GrammarActions.Security.cs | 9 +- .../GrammarActions.Signatures.Actions.cs | 2 +- .../Actions/GrammarActions.Signatures.cs | 8 +- .../ilasm/src/ILAssembler/DocumentCompiler.cs | 1 - src/tools/ilasm/src/ILAssembler/gen/CIL.g4 | 88 +++++++++---------- .../ilasm/src/ILAssembler/gen/CILParser.cs | 87 +++++++++--------- 28 files changed, 157 insertions(+), 233 deletions(-) delete mode 100644 src/tools/ilasm/src/ILAssembler/Actions/CILParser.Actions.cs diff --git a/src/tools/ilasm/README.md b/src/tools/ilasm/README.md index c0c381a9e4beae..ca42c5c7187c60 100644 --- a/src/tools/ilasm/README.md +++ b/src/tools/ilasm/README.md @@ -15,7 +15,7 @@ visitors; parser actions own traversal. | `GrammarActions.cs` | Per-document lifecycle. | | `GrammarActions.BuildImage.cs` | PE and portable PDB construction. | | `GrammarActions.Bytes.cs` | `bytearray` accumulation. | -| `GrammarActions.Conversions.cs` | `GrammarResult`, diagnostics and shared state. | +| `GrammarActions.Conversions.cs` | Diagnostics and shared state. | | `GrammarActions.CustomAttributes.Actions.cs` | Custom attribute descriptors, declarations and blob lists. | | `GrammarActions.CustomAttributes.Sequences.cs` | Custom attribute scalar-array sequence synthesis. | | `GrammarActions.CustomAttributes.Serialization.cs` | Serialized attribute values and field/parameter initializers. | @@ -59,34 +59,29 @@ visitors; parser actions own traversal. | `GrammarActions.Types.Headers.Values.cs` | Internal synthesized type-header value model. | | `GrammarActions.Types.References.cs` | Type-name synthesis and resolution. | -`CILParser.Actions.cs` holds the streaming parse-tree mode helper the grammar calls. - ## Rules for grammar actions Parser actions in `src/ILAssembler/gen/CIL.g4` must remain thin; they call a single `Actions` method and nothing else. Compilation orchestration belongs in the `GrammarActions` partial-class files. -Instruction dispatch and every operand root run with parse-tree construction disabled. -Type, signature and reference rules synthesize compact semantic values that their existing -`VisitX(context).Value` wrappers materialize. The generated ANTLR context classes are public, while -ILAssembler entities and signature implementation values remain internal, so generated return -slots use `object` where an internal value or array crosses that boundary and `GrammarActions` -provides the strongly typed accessors. +`DocumentCompiler` disables parse-tree construction when it creates the parser, and no parser action +changes that setting. ANTLR generates neither listeners nor visitors. All semantics come from parser +actions and compact synthesized values. The generated ANTLR context classes are public, while +ILAssembler entities and signature implementation values remain internal, so generated return slots +use `object` where an internal value or array crosses that boundary and `GrammarActions` provides the +strongly typed accessors and materializers. All namespace, type-header, top-level, type, signature, reference, marshalling, class-member, method-header, method-body directive, exception-handling, data, security, source, language, assembly, manifest, vtable and typedef structure is action-driven. `scopeBlock` records offsets -under its context key without inspecting children. Normal parsing keeps `BuildParseTree` disabled; -there are no `BeginSubtree` islands. +under its context key without inspecting children. `BuildParseTree` remains disabled throughout. Semantic state that a rule pushes must be released from that rule's `finally` clause and be keyed on the owning context, because ANTLR skips `@after` actions and the remainder of an alternative once a rule reports a syntax error. Inline actions placed after a subrule reference are not a substitute: they run only when the alternative completes. -Only parser actions walk structural rules. ANTLR visitors and listeners are not generated. -Ordinary `VisitX` methods are semantic helpers called directly by actions or materializers, not -parse-tree visitor entry points. There is no child walker. +Only parser actions process structural rules. There is no parse-tree walker or mode toggling. ## Build diff --git a/src/tools/ilasm/src/ILAssembler/Actions/CILParser.Actions.cs b/src/tools/ilasm/src/ILAssembler/Actions/CILParser.Actions.cs deleted file mode 100644 index 4e2dfefff77063..00000000000000 --- a/src/tools/ilasm/src/ILAssembler/Actions/CILParser.Actions.cs +++ /dev/null @@ -1,28 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Collections.Generic; -using System.Diagnostics; - -namespace ILAssembler; - -public partial class CILParser -{ - private readonly Stack _parseTreeModes = new(); - - internal GrammarActions Actions { get; set; } = null!; - - private void BeginStreaming() - { - _parseTreeModes.Push(BuildParseTree); - BuildParseTree = false; - } - - private void EndParseTreeMode() - { - Debug.Assert(_parseTreeModes.Count > 0); - BuildParseTree = _parseTreeModes.Pop(); - } - - internal void VerifyParseTreeModesBalanced() => Debug.Assert(_parseTreeModes.Count == 0); -} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.BuildImage.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.BuildImage.cs index c531ef377a90b8..8747f8175447e3 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.BuildImage.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.BuildImage.cs @@ -21,7 +21,6 @@ namespace ILAssembler { -#pragma warning disable CA1822 // Mark members as static internal sealed partial class GrammarActions { public (ImmutableArray Diagnostics, CompilationResult? Image) BuildImage() diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Bytes.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Bytes.cs index 2a49a0ec55ab2e..aefb926552e8c8 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Bytes.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Bytes.cs @@ -29,10 +29,10 @@ internal sealed partial class GrammarActions /// Starts accumulating the bytes of a bytearray literal. /// /// - /// The bytes rule disables parse-tree construction for its children, so the individual - /// hexbyte contexts and terminals are collectable as soon as they are matched. The bytes - /// themselves stream into this accumulator, which keeps a single byte array alive instead of a - /// context and a terminal node per byte. + /// Parse-tree construction is disabled for the entire parse, so the individual hexbyte + /// contexts and terminals are collectable as soon as they are matched. The bytes themselves + /// stream into this accumulator, which keeps a single byte array alive instead of a context and + /// a terminal node per byte. /// internal void BeginBytes() => _byteAccumulator = ImmutableArray.CreateBuilder(); diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs index ce7dfb0245708a..6170dba026bc8e 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs @@ -21,23 +21,6 @@ namespace ILAssembler { - internal abstract record GrammarResult - { - protected GrammarResult() { } - - public sealed record String(string Value) : GrammarResult; - - public sealed record Literal(T Value) : GrammarResult; - - public sealed record SentinelValue - { - public static SentinelValue Instance { get; } = new(); - - public static Literal Result { get; } = new(Instance); - } - } - -#pragma warning disable CA1822 // Mark members as static internal sealed partial class GrammarActions { private readonly ImmutableArray.Builder _diagnostics = ImmutableArray.CreateBuilder(); diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Actions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Actions.cs index 9b10716dc71dd1..5e36c20dc55f79 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Actions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Actions.cs @@ -290,21 +290,21 @@ private EntityRegistry.CustomAttributeEntity MaterializeCustomAttribute( return descriptor.Owner is null ? attribute : null; } - public GrammarResult.Literal VisitCustomAttrDecl( + internal EntityRegistry.CustomAttributeEntity? MaterializeCustomAttributeDeclaration( CILParser.CustomAttrDeclContext context) - => new(MaterializeCustomAttributeDeclaration(context.Value, context.Start)); + => MaterializeCustomAttributeDeclaration(context.Value, context.Start); - public GrammarResult.Literal VisitCustomDescr( + internal EntityRegistry.CustomAttributeEntity MaterializeCustomAttributeDescriptor( CILParser.CustomDescrContext context) - => new(MaterializeCustomAttribute( + => MaterializeCustomAttribute( GetCustomAttributeDescriptorValue(context.Value), - context.Start)); + context.Start); - public GrammarResult.Literal VisitCustomDescrInMethodBody( + internal EntityRegistry.CustomAttributeEntity? MaterializeMethodBodyCustomAttributeDeclaration( CILParser.CustomDescrInMethodBodyContext context) - => new(MaterializeCustomAttributeDeclaration(context.Value, context.Start)); + => MaterializeCustomAttributeDeclaration(context.Value, context.Start); - public GrammarResult.Literal VisitOwnerType( + internal EntityRegistry.EntityBase MaterializeOwnerType( CILParser.OwnerTypeContext context) - => new(MaterializeOwnerType(GetOwnerTypeValue(context.Value))); + => MaterializeOwnerType(GetOwnerTypeValue(context.Value)); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Serialization.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Serialization.cs index bf78aedf2939e3..8309af8d063773 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Serialization.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Serialization.cs @@ -397,6 +397,6 @@ private static SerializationTypeCode GetSerializationTypeCode(int tokenType) : Encoding.UTF8.GetString(bytes.Slice(bytesRead, length)); } - public static GrammarResult.Literal VisitInitOpt(CILParser.InitOptContext context) - => new(context.Value); + internal static object? GetInitializerValue(CILParser.InitOptContext context) + => context.Value; } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.Actions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.Actions.cs index 7379381cfcd98d..b811478b7fcf4d 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.Actions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.Actions.cs @@ -18,7 +18,7 @@ internal void ProcessTopLevelVTableDeclaration(CILParser.VtableDeclContext conte { if (!context.HasSyntaxError) { - _ = VisitVtableDecl(context); + MaterializeVTable(context); } } @@ -26,7 +26,7 @@ internal void ProcessTopLevelVTableFixupDeclaration(CILParser.VtfixupDeclContext { if (!context.HasSyntaxError) { - _ = VisitVtfixupDecl(context); + MaterializeVTableFixup(context); } } @@ -37,7 +37,7 @@ internal void ProcessTopLevelFileDeclaration(CILParser.FileDeclContext context) { if (!context.HasSyntaxError) { - _ = VisitFileDecl(context); + _ = MaterializeFileDeclaration(context); } } @@ -45,7 +45,7 @@ internal void ProcessTopLevelAssembly(CILParser.AssemblyBlockContext context) { if (!context.HasSyntaxError) { - _ = VisitAssemblyBlock(context); + MaterializeAssemblyDefinition(context); } } @@ -53,7 +53,7 @@ internal void ProcessTopLevelAssemblyReference(CILParser.AssemblyRefBlockContext { if (!context.HasSyntaxError) { - _ = VisitAssemblyRefBlock(context); + MaterializeAssemblyReference(context); } } @@ -61,7 +61,7 @@ internal void ProcessTopLevelExportedType(CILParser.ExptypeBlockContext context) { if (!context.HasSyntaxError) { - _ = VisitExptypeBlock(context); + MaterializeExportedType(context); } } @@ -69,7 +69,7 @@ internal void ProcessTopLevelManifestResource(CILParser.ManifestResBlockContext { if (!context.HasSyntaxError) { - _ = VisitManifestResBlock(context); + MaterializeManifestResource(context); } } @@ -111,7 +111,7 @@ internal void ProcessTopLevelSecurityDeclaration(CILParser.SecDeclContext contex if (!context.HasSyntaxError) { EntityRegistry.DeclarativeSecurityAttributeEntity? security = - VisitSecDecl(context).Value; + MaterializeSecurityDeclaration(context); security?.Parent = _entityRegistry.Assembly; } } @@ -119,7 +119,7 @@ internal void ProcessTopLevelSecurityDeclaration(CILParser.SecDeclContext contex internal void ProcessTopLevelCustomAttribute(CILParser.CustomAttrDeclContext context) { if (!context.HasSyntaxError && - VisitCustomAttrDecl(context).Value is { } customAttribute) + MaterializeCustomAttributeDeclaration(context) is { } customAttribute) { customAttribute.Owner = (EntityRegistry.EntityBase?)_lastFieldDefinition ?? _entityRegistry.Module; @@ -158,7 +158,7 @@ internal void ProcessTopLevelTypedef(CILParser.TypedefDeclContext context) { if (!context.HasSyntaxError) { - _ = VisitTypedefDecl(context); + MaterializeTypedef(context); } } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.References.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.References.cs index b790097ae98665..63e656931079bd 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.References.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.References.cs @@ -24,7 +24,7 @@ internal void EmitMethodReferenceInstruction(IToken opcodeToken, CILParser.Metho try { method.Definition.MethodBody.OpCode(opcode); - WriteInstructionToken(method, VisitMethodRef(context).Value); + WriteInstructionToken(method, MaterializeMethodReference(context)); } finally { @@ -43,7 +43,7 @@ internal void EmitFieldReferenceInstruction(IToken opcodeToken, CILParser.FieldR } instruction.Method.Definition.MethodBody.OpCode(instruction.OpCode); - WriteInstructionToken(instruction.Method, VisitFieldRef(context).Value); + WriteInstructionToken(instruction.Method, MaterializeFieldReference(context)); } internal void EmitMetadataTokenInstruction(IToken opcodeToken, CILParser.MdtokenContext context) @@ -54,7 +54,7 @@ internal void EmitMetadataTokenInstruction(IToken opcodeToken, CILParser.Mdtoken } instruction.Method.Definition.MethodBody.OpCode(instruction.OpCode); - WriteInstructionToken(instruction.Method, VisitMdtoken(context).Value); + WriteInstructionToken(instruction.Method, ResolveMetadataToken(context)); } internal void EmitTypeReferenceInstruction(IToken opcodeToken, CILParser.TypeSpecContext context) @@ -65,7 +65,7 @@ internal void EmitTypeReferenceInstruction(IToken opcodeToken, CILParser.TypeSpe } instruction.Method.Definition.MethodBody.OpCode(instruction.OpCode); - WriteInstructionToken(instruction.Method, VisitTypeSpec(context).Value); + WriteInstructionToken(instruction.Method, ResolveTypeSpecification(context)); } internal void EmitCalliInstruction(IToken opcodeToken, CILParser.CalliSignatureContext context) @@ -90,7 +90,7 @@ internal void EmitOwnerTokenInstruction(IToken opcodeToken, CILParser.OwnerTypeC } instruction.Method.Definition.MethodBody.OpCode(instruction.OpCode); - WriteInstructionToken(instruction.Method, VisitOwnerType(context).Value); + WriteInstructionToken(instruction.Method, MaterializeOwnerType(context)); } private static void WriteInstructionToken(CurrentMethodContext method, EntityRegistry.EntityBase entity) diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs index 6fee8d64103bcc..7ee5a57b3378ab 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs @@ -442,6 +442,6 @@ private static ILOpCode ParseOpCodeFromToken(IToken token) return (ILOpCode)Enum.Parse(typeof(ILOpCode), normalized, ignoreCase: true); } - public GrammarResult.Literal VisitMdtoken(CILParser.MdtokenContext context) - => new(ResolveMetadataToken(context.Value)); + internal EntityRegistry.EntityBase ResolveMetadataToken(CILParser.MdtokenContext context) + => ResolveMetadataToken(context.Value); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs index 69b404f343485c..5283815755a5d5 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs @@ -144,10 +144,8 @@ internal double ParseFloat32Bits(IToken token) internal double ParseFloat64Bits(IToken token) => BitConverter.Int64BitsToDouble(ParseInt64(token)); - public static GrammarResult.String VisitId(CILParser.IdContext context) - { - return new GrammarResult.String(ParseIdentifier(context.Start)); - } + internal static string GetIdentifier(CILParser.IdContext context) + => ParseIdentifier(context.Start); private static string ParseIdentifier(IToken token) { diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Assembly.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Assembly.cs index 91006b69c1caae..147c038276675d 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Assembly.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Assembly.cs @@ -202,13 +202,11 @@ private void ApplyKeyFile(string keyFilePath) } } - public GrammarResult VisitAssemblyBlock(CILParser.AssemblyBlockContext context) + internal void MaterializeAssemblyDefinition(CILParser.AssemblyBlockContext context) { if (context.Value is AssemblyDefinitionValue definition) { MaterializeAssemblyDefinition(definition); } - - return GrammarResult.SentinelValue.Result; } } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.ExportedTypes.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.ExportedTypes.cs index a7a23a884b46d7..ab04de46dcb461 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.ExportedTypes.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.ExportedTypes.cs @@ -294,14 +294,12 @@ private static string GetExportedTypeDisplayName(TypeName typeName) return string.Join("/", names); } - public GrammarResult VisitExptypeBlock(CILParser.ExptypeBlockContext context) + internal void MaterializeExportedType(CILParser.ExptypeBlockContext context) { if (context.Value is ExportedTypeValue value) { MaterializeExportedType(value); } - - return GrammarResult.SentinelValue.Result; } } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Files.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Files.cs index 0fb19ef784f0c9..5bd94c2683e981 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Files.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Files.cs @@ -124,12 +124,12 @@ private EntityRegistry.FileEntity MaterializeFileDeclaration(FileDeclarationValu return entity; } - public GrammarResult.Literal VisitFileDecl( + internal EntityRegistry.FileEntity MaterializeFileDeclaration( CILParser.FileDeclContext context) { Debug.Assert(context.Value is FileDeclarationValue); FileDeclarationValue declaration = context.Value as FileDeclarationValue ?? new(string.Empty, HasMetadata: true, IsEntryPoint: false, Hash: null); - return new(MaterializeFileDeclaration(declaration)); + return MaterializeFileDeclaration(declaration); } } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.References.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.References.cs index 1ada95ee54ec89..b9837e7a3efc85 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.References.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.References.cs @@ -83,14 +83,12 @@ private void MaterializeAssemblyReference(AssemblyReferenceValue reference) private static AssemblyReferenceHeaderValue GetAssemblyReferenceHeader(object? value) => value as AssemblyReferenceHeaderValue ?? new(0, string.Empty, string.Empty); - public GrammarResult VisitAssemblyRefBlock(CILParser.AssemblyRefBlockContext context) + internal void MaterializeAssemblyReference(CILParser.AssemblyRefBlockContext context) { if (context.Value is AssemblyReferenceValue reference) { MaterializeAssemblyReference(reference); } - - return GrammarResult.SentinelValue.Result; } } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Resources.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Resources.cs index d6cc2bffc5133b..4be34cc77c21ca 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Resources.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Resources.cs @@ -161,14 +161,12 @@ private void MaterializeManifestResource(ManifestResourceValue value) return (implementation, offset, customAttributes.ToImmutable()); } - public GrammarResult VisitManifestResBlock(CILParser.ManifestResBlockContext context) + internal void MaterializeManifestResource(CILParser.ManifestResBlockContext context) { if (context.Value is ManifestResourceValue value) { MaterializeManifestResource(value); } - - return GrammarResult.SentinelValue.Result; } } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Typedefs.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Typedefs.cs index c6d81582c6d939..48ec355bd32d92 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Typedefs.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Typedefs.cs @@ -58,14 +58,12 @@ private void MaterializeTypedef(TypedefDeclarationValue declaration) } } - public GrammarResult VisitTypedefDecl(CILParser.TypedefDeclContext context) + internal void MaterializeTypedef(CILParser.TypedefDeclContext context) { if (context.Value is TypedefDeclarationValue declaration) { MaterializeTypedef(declaration); } - - return GrammarResult.SentinelValue.Result; } private EntityRegistry.TypeEntity? TryResolveTypedefAsType(string alias) diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.VTable.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.VTable.cs index 6fa45f6b4bc975..dbc49614eb5dac 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.VTable.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.VTable.cs @@ -43,17 +43,15 @@ internal object CreateVTableFixup(IToken slotCount, ushort flags, IToken dataLab internal object CreateRawVTable(ImmutableArray value) => new RawVTableValue(value); - public GrammarResult VisitVtableDecl(CILParser.VtableDeclContext context) + internal void MaterializeVTable(CILParser.VtableDeclContext context) => throw new NotImplementedException( "raw vtable fixups blob (.vtable) not supported - use .vtfixup instead"); - public GrammarResult VisitVtfixupDecl(CILParser.VtfixupDeclContext context) + internal void MaterializeVTableFixup(CILParser.VtfixupDeclContext context) { if (context.Value is VTableFixupValue value) { _vtableFixups.Add(new(value.SlotCount, value.Flags, value.DataLabel)); } - - return GrammarResult.SentinelValue.Result; } } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Class.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Class.cs index 602fb45b37f6d1..5d3326b50fa608 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Class.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Class.cs @@ -47,7 +47,7 @@ internal void ProcessClassSecurityDeclaration(CILParser.SecDeclContext context) return; } - EntityRegistry.DeclarativeSecurityAttributeEntity? security = VisitSecDecl(context).Value; + EntityRegistry.DeclarativeSecurityAttributeEntity? security = MaterializeSecurityDeclaration(context); security?.Parent = _currentTypeDefinition.PeekOrDefault(); } @@ -70,7 +70,7 @@ internal void ProcessClassCustomAttribute(CILParser.CustomAttrDeclContext contex return; } - if (VisitCustomAttrDecl(context).Value is { } customAttribute) + if (MaterializeCustomAttributeDeclaration(context) is { } customAttribute) { customAttribute.Owner = _pendingClassCustomAttributeOwner ?? @@ -391,7 +391,7 @@ internal void AddClassGenericDirectiveAttribute( return; } - if (VisitCustomAttrDecl(attribute).Value is { } customAttribute) + if (MaterializeCustomAttributeDeclaration(attribute) is { } customAttribute) { customAttribute.Owner = owner; } @@ -494,7 +494,7 @@ internal void AddInterfaceImplementationAttribute( currentType.InterfaceImplementations.Add(implementation); } - VisitCustomDescr(attribute).Value.Owner = implementation; + MaterializeCustomAttributeDescriptor(attribute).Owner = implementation; _ = context; } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Fields.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Fields.cs index 8c0da1cfdf18d7..420e13aae6b2c8 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Fields.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Fields.cs @@ -200,9 +200,9 @@ internal void SetFieldOffset(CILParser.RepeatOptContext context, IToken token) context.HasValue = true; } - public GrammarResult.Literal VisitFieldRef( + internal EntityRegistry.EntityBase MaterializeFieldReference( CILParser.FieldRefContext context) - => new(MaterializeFieldReference(GetFieldReferenceValue(context.Value))); + => MaterializeFieldReference(GetFieldReferenceValue(context.Value)); private FieldDeclarationFrame? TryGetFieldDeclarationFrame(CILParser.FieldDeclContext context) { diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.PropertiesEvents.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.PropertiesEvents.cs index ffc1a53a8e0d91..c2af6e8df2df0f 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.PropertiesEvents.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.PropertiesEvents.cs @@ -181,7 +181,7 @@ internal void AddPropertyCustomAttribute( return; } - if (VisitCustomAttrDecl(attribute).Value is { } customAttribute) + if (MaterializeCustomAttributeDeclaration(attribute) is { } customAttribute) { customAttribute.Owner = property; } @@ -305,7 +305,7 @@ internal void AddEventCustomAttribute( return; } - if (VisitCustomAttrDecl(attribute).Value is { } customAttribute) + if (MaterializeCustomAttributeDeclaration(attribute) is { } customAttribute) { customAttribute.Owner = @event; } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.Directives.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.Directives.cs index 742827814f1cc5..6d44da9a3e4b00 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.Directives.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.Directives.cs @@ -238,7 +238,7 @@ internal void EndParameterDirective(CILParser.ParameterDeclContext context) } EntityRegistry.ParameterEntity parameterEntity = _currentMethod.Definition.Parameters[index]; - object? constantValue = VisitInitOpt(context.initializer).Value; + object? constantValue = GetInitializerValue(context.initializer); if (constantValue is not NoConstantSentinel) { parameterEntity.ConstantValue = constantValue; @@ -247,7 +247,7 @@ internal void EndParameterDirective(CILParser.ParameterDeclContext context) foreach (CILParser.CustomAttrDeclContext attributeContext in frame.CustomAttributes) { - EntityRegistry.CustomAttributeEntity? attribute = VisitCustomAttrDecl(attributeContext).Value; + EntityRegistry.CustomAttributeEntity? attribute = MaterializeCustomAttributeDeclaration(attributeContext); if (attribute is not null) { attribute.Owner = parameterEntity; @@ -296,7 +296,7 @@ private void ApplyCustomAttributes( { foreach (CILParser.CustomAttrDeclContext attributeContext in attributeContexts) { - EntityRegistry.CustomAttributeEntity? attribute = VisitCustomAttrDecl(attributeContext).Value; + EntityRegistry.CustomAttributeEntity? attribute = MaterializeCustomAttributeDeclaration(attributeContext); if (attribute is not null) { attribute.Owner = owner; @@ -316,7 +316,7 @@ internal void ProcessMethodSecurityDeclaration(CILParser.SecDeclContext context) return; } - EntityRegistry.DeclarativeSecurityAttributeEntity? security = VisitSecDecl(context).Value; + EntityRegistry.DeclarativeSecurityAttributeEntity? security = MaterializeSecurityDeclaration(context); security?.Parent = _currentMethod.Definition; } @@ -335,7 +335,7 @@ internal void ProcessMethodCustomAttribute(CILParser.CustomDescrInMethodBodyCont return; } - EntityRegistry.CustomAttributeEntity? attribute = VisitCustomDescrInMethodBody(context).Value; + EntityRegistry.CustomAttributeEntity? attribute = MaterializeMethodBodyCustomAttributeDeclaration(context); if (attribute is not null) { attribute.Owner = _currentMethod.Definition; diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs index 8160d4748d8795..1048eb495b95a0 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs @@ -335,12 +335,11 @@ private static SecurityCaValue GetSecurityCaValue(object? value) return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; } - public GrammarResult.Literal VisitSecDecl( + internal EntityRegistry.DeclarativeSecurityAttributeEntity? MaterializeSecurityDeclaration( CILParser.SecDeclContext context) - => new( - context.Value is SecurityDeclarationValue value - ? MaterializeSecurityDeclaration(value, context.Start) - : null); + => context.Value is SecurityDeclarationValue value + ? MaterializeSecurityDeclaration(value, context.Start) + : null; } #pragma warning restore CA1822 diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Actions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Actions.cs index 6e40b53eecc030..20cad732f361f9 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Actions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Actions.cs @@ -253,7 +253,7 @@ internal object CreateSignatureArgument( attributes, GetTypeValue(type), GetMarshallingDescriptorValue(marshalling), - name is null ? null : VisitId(name).Value); + name is null ? null : GetIdentifier(name)); internal void BeginParameterAttributes(CILParser.ParamAttrContext context) => _parameterAttributesFrames.Push(new(context)); diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.cs index 342dd008f54ab7..2b6eb244905434 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.cs @@ -5,9 +5,9 @@ namespace ILAssembler; internal sealed partial class GrammarActions { - public GrammarResult.Literal VisitMethodRef(CILParser.MethodRefContext context) - => new(MaterializeMethodReference(GetMethodReferenceValue(context.Value))); + internal EntityRegistry.EntityBase MaterializeMethodReference(CILParser.MethodRefContext context) + => MaterializeMethodReference(GetMethodReferenceValue(context.Value)); - public GrammarResult.Literal VisitTypeSpec(CILParser.TypeSpecContext context) - => new(ResolveTypeSpecification(GetTypeSpecificationValue(context.Value))); + internal EntityRegistry.TypeEntity ResolveTypeSpecification(CILParser.TypeSpecContext context) + => ResolveTypeSpecification(GetTypeSpecificationValue(context.Value)); } diff --git a/src/tools/ilasm/src/ILAssembler/DocumentCompiler.cs b/src/tools/ilasm/src/ILAssembler/DocumentCompiler.cs index e4ed8d20bf7d85..2ee8588cd425f8 100644 --- a/src/tools/ilasm/src/ILAssembler/DocumentCompiler.cs +++ b/src/tools/ilasm/src/ILAssembler/DocumentCompiler.cs @@ -63,7 +63,6 @@ public sealed class DocumentCompiler ImmutableArray.Builder parserDiagnostics = ImmutableArray.CreateBuilder(); parser.AddErrorListener(new ParserErrorListener(parserDiagnostics, loadedDocuments, actions.RecordSyntaxError)); _ = parser.decls(); - parser.VerifyParseTreeModesBalanced(); // Add parser diagnostics to the main list diagnostics.AddRange(parserDiagnostics); diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 index 708a359050be5b..223dc9c67e4038 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 @@ -5,6 +5,10 @@ The .NET Foundation licenses this file to you under the MIT license. grammar CIL; +@parser::members { + internal GrammarActions Actions { get; set; } = null!; +} + tokens { IncludedFileEof, SyntheticIncludedFileEof } INT32: '-'? ('0x' [0-9A-Fa-f]+ | [0-9]+); @@ -430,12 +434,12 @@ dottedNamePart returns [string Value] | 'volatile' ; compQstring returns [string Value] -@init {BeginStreaming(); Actions.BeginComposedString(_localctx);} +@init {Actions.BeginComposedString(_localctx);} : (head = QSTRING {Actions.AddComposedStringPart(_localctx, $head);} PLUS)* tail = QSTRING {Actions.AddComposedStringPart(_localctx, $tail);} ; -finally {_localctx.Value = Actions.EndComposedString(_localctx); EndParseTreeMode();} +finally {_localctx.Value = Actions.EndComposedString(_localctx);} WS: [ \t\r\n] -> skip; @@ -445,14 +449,11 @@ PERMISSION: '.permission'; PERMISSIONSET: '.permissionset'; decls -@init {BeginStreaming();} : decl* ; -finally {EndParseTreeMode();} decl -@init {BeginStreaming();} : classHead '{' classDecls '}' | nameSpaceHead '{' decls '}' @@ -495,7 +496,7 @@ decl | {Actions.BeginTopLevelDirective();} compControl | typelist | {Actions.BeginTopLevelDirective();} mscorlib; -finally {EndParseTreeMode(); Actions.EndDeclaration(_localctx);} +finally {Actions.EndDeclaration(_localctx);} subsystem: '.subsystem' value = int32 {Actions.ProcessTopLevelSubsystem($value.start);}; @@ -513,19 +514,19 @@ stackreserve: '.stackreserve' value = int64 {Actions.ProcessTopLevelStackReserve($value.start);}; assemblyBlock returns [object Value, bool HasSyntaxError] -@init {BeginStreaming(); Actions.BeginSemanticRoot(_localctx);} +@init {Actions.BeginSemanticRoot(_localctx);} : '.assembly' attributes = asmAttr name = dottedName '{' declarations = assemblyDecls '}' {_localctx.Value = Actions.CreateAssemblyDefinition( $attributes.Value, $name.Value, $declarations.Value);}; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} mscorlib: '.mscorlib'; languageDecl returns [object Value, bool HasSyntaxError] -@init {BeginStreaming(); Actions.BeginSemanticRoot(_localctx);} +@init {Actions.BeginSemanticRoot(_localctx);} : '.language' language = languageString {_localctx.Value = Actions.CreateLanguageDirective($language.Value);} @@ -533,7 +534,7 @@ languageDecl returns [object Value, bool HasSyntaxError] {_localctx.Value = Actions.CreateLanguageDirective($language.Value, $vendor.Value);} | '.language' language = languageString ',' vendor = languageString ',' documentType = languageString {_localctx.Value = Actions.CreateLanguageDirective($language.Value, $vendor.Value, $documentType.Value);}; -finally {Actions.EndLanguageDirective(_localctx); EndParseTreeMode();} +finally {Actions.EndLanguageDirective(_localctx);} languageString returns [string Value] @after {_localctx.Value = Actions.ParseLanguageString(_localctx.Start);} @@ -578,7 +579,7 @@ compControl: /* Aliasing of types, type specs, methods, fields and custom attributes */ typedefDecl returns [object Value, bool HasSyntaxError] -@init {BeginStreaming(); Actions.BeginSemanticRoot(_localctx);} +@init {Actions.BeginSemanticRoot(_localctx);} : '.typedef' signature = type 'as' alias = dottedName {_localctx.Value = Actions.CreateTypeSignatureTypedef($signature.Value, $alias.Value);} @@ -596,7 +597,7 @@ typedefDecl returns [object Value, bool HasSyntaxError] $ownedAttribute.Value, $ownedAttribute.start, $alias.Value);}; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} /* Custom attribute declarations */ customDescr returns [object Value, bool HasSyntaxError] @@ -691,7 +692,7 @@ moduleHead returns [string Value, bool HasName, bool IsExternal]: /* VTable Fixup table declaration */ vtfixupDecl returns [object Value, bool HasSyntaxError] -@init {BeginStreaming(); Actions.BeginSemanticRoot(_localctx);} +@init {Actions.BeginSemanticRoot(_localctx);} : '.vtfixup' '[' count = int32 ']' attributes = vtfixupAttr 'at' label = id {_localctx.Value = Actions.CreateVTableFixup( @@ -699,7 +700,7 @@ vtfixupDecl returns [object Value, bool HasSyntaxError] $attributes.Value, $label.start);} ; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} vtfixupAttr returns [ushort Value] @init {_localctx.Value = 0;} @@ -719,24 +720,24 @@ vtfixupAttrElement returns [ushort Value] | 'retainappdomain'; vtableDecl returns [object Value, bool HasSyntaxError] -@init {BeginStreaming(); Actions.BeginSemanticRoot(_localctx);} +@init {Actions.BeginSemanticRoot(_localctx);} : '.vtable' '=' '(' value = bytes ')' {_localctx.Value = Actions.CreateRawVTable($value.Value);} /* deprecated */ ; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} /* Namespace and class declaration */ nameSpaceHead returns [string Value] -@init {BeginStreaming(); Actions.BeginNamespaceHeader(_localctx);} +@init {Actions.BeginNamespaceHeader(_localctx);} @after {Actions.BeginNamespace(_localctx, _localctx.Value);} : '.namespace' name = dottedName {_localctx.Value = $name.Value;} ; -finally {Actions.EndNamespaceHeader(_localctx); EndParseTreeMode();} +finally {Actions.EndNamespaceHeader(_localctx);} classHead returns [object Value] -@init {BeginStreaming(); Actions.BeginClassHeader(_localctx);} +@init {Actions.BeginClassHeader(_localctx);} @after {Actions.BeginType(_localctx, _localctx.Value);} : '.class' @@ -750,7 +751,7 @@ classHead returns [object Value] $baseType.Value, $interfaces.Value);} ; -finally {Actions.EndClassHeader(_localctx); EndParseTreeMode();} +finally {Actions.EndClassHeader(_localctx);} classAttr returns [object Value]: @@ -797,11 +798,9 @@ implClause returns [object Value] ; classDecls -@init {BeginStreaming();} : classDecl* ; -finally {EndParseTreeMode();} implList returns [object Value] @init {Actions.BeginInterfaceList(_localctx);} @@ -819,7 +818,7 @@ esHead returns [bool AutoIncrement] | '#line'; extSourceSpec returns [object Value, bool HasSyntaxError] -@init {BeginStreaming(); Actions.BeginSemanticRoot(_localctx);} +@init {Actions.BeginSemanticRoot(_localctx);} : head = esHead line = int32 path = (SQSTRING | QSTRING)? {_localctx.Value = Actions.CreateSourceLine($head.AutoIncrement, $line.start, $path);} @@ -848,11 +847,11 @@ extSourceSpec returns [object Value, bool HasSyntaxError] $startColumn.start, $endColumn.start, $path);}; -finally {Actions.EndSourceDirective(_localctx); EndParseTreeMode();} +finally {Actions.EndSourceDirective(_localctx);} /* Manifest declarations */ fileDecl returns [object Value, bool HasSyntaxError] -@init {BeginStreaming(); Actions.BeginFileDeclaration(_localctx);} +@init {Actions.BeginFileDeclaration(_localctx);} : '.file' (attribute = fileAttr {Actions.AddFileAttribute(_localctx, $attribute.Value);})* @@ -861,7 +860,7 @@ fileDecl returns [object Value, bool HasSyntaxError] (HASH '=' '(' hash = bytes ')' {Actions.SetFileHash(_localctx, $hash.Value);} trailingEntry = fileEntry {Actions.AddFileEntry(_localctx, $trailingEntry.Value);})? ; -finally {Actions.EndFileDeclaration(_localctx); EndParseTreeMode();} +finally {Actions.EndFileDeclaration(_localctx);} fileAttr returns [bool Value] @after {_localctx.Value = Actions.ParseFileAttribute(_localctx.Start);} @@ -1237,7 +1236,7 @@ nativeUint returns [byte Value]: /* Security declarations */ secDecl returns [object Value, bool HasSyntaxError] -@init {BeginStreaming(); Actions.BeginSemanticRoot(_localctx);} +@init {Actions.BeginSemanticRoot(_localctx);} : PERMISSION action = secAction permissionType = typeSpec '(' pairs = nameValPairs ')' {_localctx.Value = Actions.CreateNamedPermissionDeclaration( @@ -1259,7 +1258,7 @@ secDecl returns [object Value, bool HasSyntaxError] {_localctx.Value = Actions.CreateStringPermissionSetDeclaration($action.Value, $textValue.Value);} | PERMISSIONSET action = secAction '=' '{' attributes = secAttrSetBlob '}' {_localctx.Value = Actions.CreateAttributePermissionSetDeclaration($action.Value, $attributes.Value);}; -finally {Actions.EndSecurityDeclaration(_localctx); EndParseTreeMode();} +finally {Actions.EndSecurityDeclaration(_localctx);} secAttrSetBlob returns [object Value] @init {Actions.BeginSecurityAttributeSet(_localctx);} @@ -1444,7 +1443,6 @@ genArityNotEmpty returns [int Value]: /* Class body declarations */ classDecl -@init {BeginStreaming();} : methodHead '{' methodDecls '}' | classHead '{' classDecls '}' @@ -1508,11 +1506,11 @@ classDecl | '.interfaceimpl' TYPE interfaceType = typeSpec interfaceAttribute = customDescr {Actions.AddInterfaceImplementationAttribute(_localctx, $interfaceType.Value, $interfaceAttribute.ctx);} ; -finally {EndParseTreeMode(); Actions.EndClassDeclaration(_localctx);} +finally {Actions.EndClassDeclaration(_localctx);} /* Field declaration */ fieldDecl returns [object Value] -@init {BeginStreaming(); Actions.BeginFieldDeclaration(_localctx);} +@init {Actions.BeginFieldDeclaration(_localctx);} @after {Actions.DefineField(_localctx, _localctx.Value);} : '.field' offset = repeatOpt @@ -1529,7 +1527,7 @@ fieldDecl returns [object Value] $data.Value, $initializer.Value);} ; -finally {Actions.EndFieldDeclaration(_localctx); EndParseTreeMode();} +finally {Actions.EndFieldDeclaration(_localctx);} fieldAttr returns [object Value]: attribute = 'static' {_localctx.Value = Actions.CreateFieldAttribute($attribute);} @@ -1658,7 +1656,7 @@ paramAttrElement returns [int Value, bool ShouldAppend]: methodHead returns [object Value] -@init {BeginStreaming(); Actions.BeginMethodHeader(_localctx);} +@init {Actions.BeginMethodHeader(_localctx);} @after {Actions.BeginMethod(_localctx, _localctx.Value);} : '.method' @@ -1679,7 +1677,7 @@ returns [object Value] $genericParameters.Value, $arguments.Value);} ; -finally {Actions.EndMethodHeader(_localctx); EndParseTreeMode();} +finally {Actions.EndMethodHeader(_localctx);} methAttr returns [object Value]: attribute = 'static' {_localctx.Value = Actions.CreateMethodAttribute($attribute);} @@ -1765,11 +1763,9 @@ OVERRIDE: '.override'; VTENTRY: '.vtentry'; methodDecls -@init {BeginStreaming();} : methodDecl* ; -finally {EndParseTreeMode();} methodDecl: instr @@ -1912,11 +1908,11 @@ handlerBlock returns [object Value]: /* Data declaration */ dataDecl returns [bool HasSyntaxError] -@init {BeginStreaming(); Actions.BeginDataDeclaration(_localctx);} +@init {Actions.BeginDataDeclaration(_localctx);} : ddHead ddBody ; -finally {Actions.EndDataDeclaration(_localctx); EndParseTreeMode();} +finally {Actions.EndDataDeclaration(_localctx);} ddHead: '.data' section = tls name = id '=' @@ -1991,11 +1987,11 @@ finally {_localctx.Value ??= new System.Reflection.Metadata.BlobBuilder();} bytes returns [System.Collections.Immutable.ImmutableArray Value] -@init {BeginStreaming(); Actions.BeginBytes();} +@init {Actions.BeginBytes();} : (b = hexbyte {Actions.AddByte($b.Value);})* ; -finally {_localctx.Value = Actions.EndBytes(); EndParseTreeMode();} +finally {_localctx.Value = Actions.EndBytes();} hexbyte returns [byte Value] @@ -2159,14 +2155,14 @@ asmOrRefDecl returns [object Value]: | compControl; assemblyRefBlock returns [object Value, bool HasSyntaxError] -@init {BeginStreaming(); Actions.BeginSemanticRoot(_localctx);} +@init {Actions.BeginSemanticRoot(_localctx);} : header = assemblyRefHead '{' declarations = assemblyRefDecls '}' {_localctx.Value = Actions.CreateAssemblyReference( $header.Value, $declarations.Value);} ; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} assemblyRefHead returns [object Value]: '.assembly' 'extern' attributes = asmAttr name = dottedName @@ -2197,7 +2193,7 @@ assemblyRefDecl returns [object Value]: | 'auto' {_localctx.Value = Actions.CreateAssemblyReferenceAutoDeclaration();}; exptypeBlock returns [object Value, bool HasSyntaxError] -@init {BeginStreaming(); Actions.BeginSemanticRoot(_localctx);} +@init {Actions.BeginSemanticRoot(_localctx);} : header = exptypeHead '{' declarations = exptypeDecls '}' {_localctx.Value = Actions.CreateExportedType( @@ -2205,7 +2201,7 @@ exptypeBlock returns [object Value, bool HasSyntaxError] $declarations.Value, $header.start);} ; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} exptypeHead returns [object Value]: head = '.class' 'extern' attributes = exptAttrs name = dottedName @@ -2279,7 +2275,7 @@ exptypeDecl returns [object Value]: | compControl; manifestResBlock returns [object Value, bool HasSyntaxError] -@init {BeginStreaming(); Actions.BeginSemanticRoot(_localctx);} +@init {Actions.BeginSemanticRoot(_localctx);} : header = manifestResHead '{' declarations = manifestResDecls '}' {_localctx.Value = Actions.CreateManifestResource( @@ -2287,7 +2283,7 @@ manifestResBlock returns [object Value, bool HasSyntaxError] $declarations.Value, $header.start);} ; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode();} +finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} manifestResHead returns [object Value]: head = MRESOURCE attributes = manresAttrs name = dottedName diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs index bb1c6a677011f3..530e18e002eb1d 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs @@ -291,6 +291,9 @@ static CILParser() { } } + + internal GrammarActions Actions { get; set; } = null!; + public CILParser(ITokenStream input) : this(input, Console.Out, Console.Error) { } public CILParser(ITokenStream input, TextWriter output, TextWriter errorOutput) @@ -505,7 +508,7 @@ public CompQstringContext(ParserRuleContext parent, int invokingState) public CompQstringContext compQstring() { CompQstringContext _localctx = new CompQstringContext(Context, State); EnterRule(_localctx, 6, RULE_compQstring); - BeginStreaming(); Actions.BeginComposedString(_localctx); + Actions.BeginComposedString(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); @@ -540,7 +543,7 @@ public CompQstringContext compQstring() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndComposedString(_localctx); EndParseTreeMode(); + _localctx.Value = Actions.EndComposedString(_localctx); ExitRule(); } return _localctx; @@ -564,7 +567,6 @@ public DeclsContext(ParserRuleContext parent, int invokingState) public DeclsContext decls() { DeclsContext _localctx = new DeclsContext(Context, State); EnterRule(_localctx, 8, RULE_decls); - BeginStreaming(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -591,7 +593,6 @@ public DeclsContext decls() { ErrorHandler.Recover(this, re); } finally { - EndParseTreeMode(); ExitRule(); } return _localctx; @@ -710,7 +711,6 @@ public DeclContext(ParserRuleContext parent, int invokingState) public DeclContext decl() { DeclContext _localctx = new DeclContext(Context, State); EnterRule(_localctx, 10, RULE_decl); - BeginStreaming(); try { State = 495; ErrorHandler.Sync(this); @@ -957,7 +957,7 @@ public DeclContext decl() { ErrorHandler.Recover(this, re); } finally { - EndParseTreeMode(); Actions.EndDeclaration(_localctx); + Actions.EndDeclaration(_localctx); ExitRule(); } return _localctx; @@ -1176,7 +1176,7 @@ public AssemblyBlockContext(ParserRuleContext parent, int invokingState) public AssemblyBlockContext assemblyBlock() { AssemblyBlockContext _localctx = new AssemblyBlockContext(Context, State); EnterRule(_localctx, 22, RULE_assemblyBlock); - BeginStreaming(); Actions.BeginSemanticRoot(_localctx); + Actions.BeginSemanticRoot(_localctx); try { EnterOuterAlt(_localctx, 1); { @@ -1204,7 +1204,7 @@ public AssemblyBlockContext assemblyBlock() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); ExitRule(); } return _localctx; @@ -1263,7 +1263,7 @@ public LanguageDeclContext(ParserRuleContext parent, int invokingState) public LanguageDeclContext languageDecl() { LanguageDeclContext _localctx = new LanguageDeclContext(Context, State); EnterRule(_localctx, 26, RULE_languageDecl); - BeginStreaming(); Actions.BeginSemanticRoot(_localctx); + Actions.BeginSemanticRoot(_localctx); try { State = 546; ErrorHandler.Sync(this); @@ -1318,7 +1318,7 @@ public LanguageDeclContext languageDecl() { ErrorHandler.Recover(this, re); } finally { - Actions.EndLanguageDirective(_localctx); EndParseTreeMode(); + Actions.EndLanguageDirective(_localctx); ExitRule(); } return _localctx; @@ -1801,7 +1801,7 @@ public TypedefDeclContext(ParserRuleContext parent, int invokingState) public TypedefDeclContext typedefDecl() { TypedefDeclContext _localctx = new TypedefDeclContext(Context, State); EnterRule(_localctx, 42, RULE_typedefDecl); - BeginStreaming(); Actions.BeginSemanticRoot(_localctx); + Actions.BeginSemanticRoot(_localctx); try { State = 644; ErrorHandler.Sync(this); @@ -1890,7 +1890,7 @@ public TypedefDeclContext typedefDecl() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); ExitRule(); } return _localctx; @@ -2777,7 +2777,7 @@ public VtfixupDeclContext(ParserRuleContext parent, int invokingState) public VtfixupDeclContext vtfixupDecl() { VtfixupDeclContext _localctx = new VtfixupDeclContext(Context, State); EnterRule(_localctx, 66, RULE_vtfixupDecl); - BeginStreaming(); Actions.BeginSemanticRoot(_localctx); + Actions.BeginSemanticRoot(_localctx); try { EnterOuterAlt(_localctx, 1); { @@ -2807,7 +2807,7 @@ public VtfixupDeclContext vtfixupDecl() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); ExitRule(); } return _localctx; @@ -2928,7 +2928,7 @@ public VtableDeclContext(ParserRuleContext parent, int invokingState) public VtableDeclContext vtableDecl() { VtableDeclContext _localctx = new VtableDeclContext(Context, State); EnterRule(_localctx, 72, RULE_vtableDecl); - BeginStreaming(); Actions.BeginSemanticRoot(_localctx); + Actions.BeginSemanticRoot(_localctx); try { EnterOuterAlt(_localctx, 1); { @@ -2951,7 +2951,7 @@ public VtableDeclContext vtableDecl() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); ExitRule(); } return _localctx; @@ -2974,7 +2974,7 @@ public NameSpaceHeadContext(ParserRuleContext parent, int invokingState) public NameSpaceHeadContext nameSpaceHead() { NameSpaceHeadContext _localctx = new NameSpaceHeadContext(Context, State); EnterRule(_localctx, 74, RULE_nameSpaceHead); - BeginStreaming(); Actions.BeginNamespaceHeader(_localctx); + Actions.BeginNamespaceHeader(_localctx); try { EnterOuterAlt(_localctx, 1); { @@ -2993,7 +2993,7 @@ public NameSpaceHeadContext nameSpaceHead() { ErrorHandler.Recover(this, re); } finally { - Actions.EndNamespaceHeader(_localctx); EndParseTreeMode(); + Actions.EndNamespaceHeader(_localctx); ExitRule(); } return _localctx; @@ -3035,7 +3035,7 @@ public ClassHeadContext(ParserRuleContext parent, int invokingState) public ClassHeadContext classHead() { ClassHeadContext _localctx = new ClassHeadContext(Context, State); EnterRule(_localctx, 76, RULE_classHead); - BeginStreaming(); Actions.BeginClassHeader(_localctx); + Actions.BeginClassHeader(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); @@ -3084,7 +3084,7 @@ public ClassHeadContext classHead() { ErrorHandler.Recover(this, re); } finally { - Actions.EndClassHeader(_localctx); EndParseTreeMode(); + Actions.EndClassHeader(_localctx); ExitRule(); } return _localctx; @@ -3488,7 +3488,6 @@ public ClassDeclsContext(ParserRuleContext parent, int invokingState) public ClassDeclsContext classDecls() { ClassDeclsContext _localctx = new ClassDeclsContext(Context, State); EnterRule(_localctx, 84, RULE_classDecls); - BeginStreaming(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -3515,7 +3514,6 @@ public ClassDeclsContext classDecls() { ErrorHandler.Recover(this, re); } finally { - EndParseTreeMode(); ExitRule(); } return _localctx; @@ -3657,7 +3655,7 @@ public ExtSourceSpecContext(ParserRuleContext parent, int invokingState) public ExtSourceSpecContext extSourceSpec() { ExtSourceSpecContext _localctx = new ExtSourceSpecContext(Context, State); EnterRule(_localctx, 90, RULE_extSourceSpec); - BeginStreaming(); Actions.BeginSemanticRoot(_localctx); + Actions.BeginSemanticRoot(_localctx); int _la; try { State = 991; @@ -3859,7 +3857,7 @@ public ExtSourceSpecContext extSourceSpec() { ErrorHandler.Recover(this, re); } finally { - Actions.EndSourceDirective(_localctx); EndParseTreeMode(); + Actions.EndSourceDirective(_localctx); ExitRule(); } return _localctx; @@ -3903,7 +3901,7 @@ public FileDeclContext(ParserRuleContext parent, int invokingState) public FileDeclContext fileDecl() { FileDeclContext _localctx = new FileDeclContext(Context, State); EnterRule(_localctx, 92, RULE_fileDecl); - BeginStreaming(); Actions.BeginFileDeclaration(_localctx); + Actions.BeginFileDeclaration(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); @@ -3961,7 +3959,7 @@ public FileDeclContext fileDecl() { ErrorHandler.Recover(this, re); } finally { - Actions.EndFileDeclaration(_localctx); EndParseTreeMode(); + Actions.EndFileDeclaration(_localctx); ExitRule(); } return _localctx; @@ -7750,7 +7748,7 @@ public SecDeclContext(ParserRuleContext parent, int invokingState) public SecDeclContext secDecl() { SecDeclContext _localctx = new SecDeclContext(Context, State); EnterRule(_localctx, 154, RULE_secDecl); - BeginStreaming(); Actions.BeginSemanticRoot(_localctx); + Actions.BeginSemanticRoot(_localctx); int _la; try { State = 1831; @@ -7896,7 +7894,7 @@ public SecDeclContext secDecl() { ErrorHandler.Recover(this, re); } finally { - Actions.EndSecurityDeclaration(_localctx); EndParseTreeMode(); + Actions.EndSecurityDeclaration(_localctx); ExitRule(); } return _localctx; @@ -9675,7 +9673,6 @@ public ClassDeclContext(ParserRuleContext parent, int invokingState) public ClassDeclContext classDecl() { ClassDeclContext _localctx = new ClassDeclContext(Context, State); EnterRule(_localctx, 200, RULE_classDecl); - BeginStreaming(); try { int _alt; State = 2285; @@ -10069,7 +10066,7 @@ public ClassDeclContext classDecl() { ErrorHandler.Recover(this, re); } finally { - EndParseTreeMode(); Actions.EndClassDeclaration(_localctx); + Actions.EndClassDeclaration(_localctx); ExitRule(); } return _localctx; @@ -10122,7 +10119,7 @@ public FieldDeclContext(ParserRuleContext parent, int invokingState) public FieldDeclContext fieldDecl() { FieldDeclContext _localctx = new FieldDeclContext(Context, State); EnterRule(_localctx, 202, RULE_fieldDecl); - BeginStreaming(); Actions.BeginFieldDeclaration(_localctx); + Actions.BeginFieldDeclaration(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); @@ -10208,7 +10205,7 @@ public FieldDeclContext fieldDecl() { ErrorHandler.Recover(this, re); } finally { - Actions.EndFieldDeclaration(_localctx); EndParseTreeMode(); + Actions.EndFieldDeclaration(_localctx); ExitRule(); } return _localctx; @@ -11732,7 +11729,7 @@ public MethodHeadContext(ParserRuleContext parent, int invokingState) public MethodHeadContext methodHead() { MethodHeadContext _localctx = new MethodHeadContext(Context, State); EnterRule(_localctx, 236, RULE_methodHead); - BeginStreaming(); Actions.BeginMethodHeader(_localctx); + Actions.BeginMethodHeader(_localctx); int _la; try { EnterOuterAlt(_localctx, 1); @@ -11835,7 +11832,7 @@ public MethodHeadContext methodHead() { ErrorHandler.Recover(this, re); } finally { - Actions.EndMethodHeader(_localctx); EndParseTreeMode(); + Actions.EndMethodHeader(_localctx); ExitRule(); } return _localctx; @@ -12591,7 +12588,6 @@ public MethodDeclsContext(ParserRuleContext parent, int invokingState) public MethodDeclsContext methodDecls() { MethodDeclsContext _localctx = new MethodDeclsContext(Context, State); EnterRule(_localctx, 248, RULE_methodDecls); - BeginStreaming(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -12618,7 +12614,6 @@ public MethodDeclsContext methodDecls() { ErrorHandler.Recover(this, re); } finally { - EndParseTreeMode(); ExitRule(); } return _localctx; @@ -14055,7 +14050,7 @@ public DataDeclContext(ParserRuleContext parent, int invokingState) public DataDeclContext dataDecl() { DataDeclContext _localctx = new DataDeclContext(Context, State); EnterRule(_localctx, 286, RULE_dataDecl); - BeginStreaming(); Actions.BeginDataDeclaration(_localctx); + Actions.BeginDataDeclaration(_localctx); try { EnterOuterAlt(_localctx, 1); { @@ -14071,7 +14066,7 @@ public DataDeclContext dataDecl() { ErrorHandler.Recover(this, re); } finally { - Actions.EndDataDeclaration(_localctx); EndParseTreeMode(); + Actions.EndDataDeclaration(_localctx); ExitRule(); } return _localctx; @@ -14988,7 +14983,7 @@ public BytesContext(ParserRuleContext parent, int invokingState) public BytesContext bytes() { BytesContext _localctx = new BytesContext(Context, State); EnterRule(_localctx, 302, RULE_bytes); - BeginStreaming(); Actions.BeginBytes(); + Actions.BeginBytes(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -15016,7 +15011,7 @@ public BytesContext bytes() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndBytes(); EndParseTreeMode(); + _localctx.Value = Actions.EndBytes(); ExitRule(); } return _localctx; @@ -16589,7 +16584,7 @@ public AssemblyRefBlockContext(ParserRuleContext parent, int invokingState) public AssemblyRefBlockContext assemblyRefBlock() { AssemblyRefBlockContext _localctx = new AssemblyRefBlockContext(Context, State); EnterRule(_localctx, 336, RULE_assemblyRefBlock); - BeginStreaming(); Actions.BeginSemanticRoot(_localctx); + Actions.BeginSemanticRoot(_localctx); try { EnterOuterAlt(_localctx, 1); { @@ -16612,7 +16607,7 @@ public AssemblyRefBlockContext assemblyRefBlock() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); ExitRule(); } return _localctx; @@ -16882,7 +16877,7 @@ public ExptypeBlockContext(ParserRuleContext parent, int invokingState) public ExptypeBlockContext exptypeBlock() { ExptypeBlockContext _localctx = new ExptypeBlockContext(Context, State); EnterRule(_localctx, 344, RULE_exptypeBlock); - BeginStreaming(); Actions.BeginSemanticRoot(_localctx); + Actions.BeginSemanticRoot(_localctx); try { EnterOuterAlt(_localctx, 1); { @@ -16906,7 +16901,7 @@ public ExptypeBlockContext exptypeBlock() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); ExitRule(); } return _localctx; @@ -17384,7 +17379,7 @@ public ManifestResBlockContext(ParserRuleContext parent, int invokingState) public ManifestResBlockContext manifestResBlock() { ManifestResBlockContext _localctx = new ManifestResBlockContext(Context, State); EnterRule(_localctx, 358, RULE_manifestResBlock); - BeginStreaming(); Actions.BeginSemanticRoot(_localctx); + Actions.BeginSemanticRoot(_localctx); try { EnterOuterAlt(_localctx, 1); { @@ -17408,7 +17403,7 @@ public ManifestResBlockContext manifestResBlock() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); EndParseTreeMode(); + _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); ExitRule(); } return _localctx; From 0fc40421d02e5bc9adf2b7facf8e273d6f3ad995 Mon Sep 17 00:00:00 2001 From: Jeremy Koritzinsky Date: Fri, 14 Aug 2026 14:55:51 -0700 Subject: [PATCH 16/16] Use typed semantic values in the IL parser Add an explicit ILAssembler reference contract so generated parser and implementation-only types do not define the supported API. Replace object-typed grammar returns and parser accumulation stacks with concrete CILParser semantic values and rule-local builders. Harden every typed return against ANTLR error recovery and add malformed input mutation coverage. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: c986c103-8383-4db4-9b11-9be49dc68a05 --- src/tools/ilasm/README.md | 54 +- src/tools/ilasm/ilasm.slnx | 3 + .../Actions/GrammarActions.Bytes.cs | 41 +- .../Actions/GrammarActions.Conversions.cs | 38 +- ...GrammarActions.CustomAttributes.Actions.cs | 206 +-- ...ammarActions.CustomAttributes.Sequences.cs | 190 +-- ...rActions.CustomAttributes.Serialization.cs | 77 +- .../GrammarActions.CustomAttributes.Values.cs | 132 -- .../Actions/GrammarActions.Data.cs | 169 +-- .../Actions/GrammarActions.Debug.cs | 52 +- .../GrammarActions.Declarations.Actions.cs | 4 +- .../GrammarActions.Instructions.References.cs | 2 +- .../Actions/GrammarActions.Instructions.cs | 55 +- .../Actions/GrammarActions.Literals.cs | 89 +- .../GrammarActions.Manifest.Assembly.cs | 47 +- .../GrammarActions.Manifest.ExportedTypes.cs | 72 +- .../Actions/GrammarActions.Manifest.Files.cs | 109 +- .../GrammarActions.Manifest.References.cs | 45 +- .../GrammarActions.Manifest.Resources.cs | 67 +- .../GrammarActions.Manifest.Typedefs.cs | 24 +- .../Actions/GrammarActions.Manifest.VTable.cs | 8 +- .../Actions/GrammarActions.Manifest.Values.cs | 179 --- .../GrammarActions.Marshalling.Actions.cs | 405 ++---- .../Actions/GrammarActions.Members.Class.cs | 103 +- .../Actions/GrammarActions.Members.Fields.cs | 139 +- ...GrammarActions.Members.PropertiesEvents.cs | 320 ++--- .../Actions/GrammarActions.Members.Values.cs | 68 - .../GrammarActions.MethodBodies.Directives.cs | 127 +- ...rActions.MethodBodies.ExceptionHandling.cs | 124 +- .../GrammarActions.MethodBodies.Values.cs | 121 -- .../GrammarActions.MethodHeaders.Actions.cs | 505 ++----- .../GrammarActions.MethodHeaders.Values.cs | 80 -- .../Actions/GrammarActions.MethodHeaders.cs | 7 +- .../Actions/GrammarActions.Security.cs | 235 +--- .../GrammarActions.Signatures.Actions.cs | 292 +---- .../GrammarActions.Signatures.References.cs | 99 +- .../GrammarActions.Signatures.Types.cs | 3 + .../GrammarActions.Signatures.Values.cs | 239 ---- .../Actions/GrammarActions.Signatures.cs | 4 +- .../GrammarActions.Types.Headers.Actions.cs | 174 +-- .../GrammarActions.Types.Headers.Values.cs | 44 - .../Actions/GrammarActions.Types.Headers.cs | 20 +- .../GrammarActions.Types.References.cs | 70 +- .../Actions/GrammarActions.Types.cs | 4 +- .../src/ILAssembler/Actions/GrammarActions.cs | 78 +- .../CILParser.SemanticValueAliases.cs | 176 +++ ...LParser.SemanticValues.CustomAttributes.cs | 148 +++ .../CILParser.SemanticValues.Declarations.cs | 222 ++++ .../CILParser.SemanticValues.Manifest.cs | 223 ++++ .../CILParser.SemanticValues.Marshalling.cs | 138 ++ .../CILParser.SemanticValues.MethodBodies.cs | 206 +++ .../CILParser.SemanticValues.Signatures.cs | 218 ++++ .../ILAssembler/CompatibilitySuppressions.xml | 23 + .../ilasm/src/ILAssembler/ILAssembler.csproj | 5 + src/tools/ilasm/src/ILAssembler/TypeName.cs | 11 - src/tools/ilasm/src/ILAssembler/gen/CIL.g4 | 1120 ++++++++++------ .../ilasm/src/ILAssembler/gen/CILParser.cs | 1157 +++++++++++------ .../ILAssembler/gen/ilasm-generator.csproj | 6 +- .../src/ILAssembler/ref/ILAssembler.csproj | 11 + .../ref/ILAssembler/CompilationResult.cs | 12 + .../ILAssembler/ref/ILAssembler/Diagnostic.cs | 57 + .../ref/ILAssembler/DocumentCompiler.cs | 20 + .../ILAssembler/ref/ILAssembler/Location.cs | 7 + .../ILAssembler/ref/ILAssembler/Options.cs | 39 + .../ILAssembler/ref/ILAssembler/SourceSpan.cs | 7 + .../ILAssembler/ref/ILAssembler/SourceText.cs | 7 + .../ILAssembler.Tests.csproj | 2 +- .../tests/ILAssembler.Tests/SyntaxTests.cs | 131 ++ 68 files changed, 4334 insertions(+), 4536 deletions(-) delete mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Values.cs delete mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Values.cs delete mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Values.cs delete mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.Values.cs delete mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.Values.cs delete mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Values.cs delete mode 100644 src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.Values.cs create mode 100644 src/tools/ilasm/src/ILAssembler/CILParser.SemanticValueAliases.cs create mode 100644 src/tools/ilasm/src/ILAssembler/CILParser.SemanticValues.CustomAttributes.cs create mode 100644 src/tools/ilasm/src/ILAssembler/CILParser.SemanticValues.Declarations.cs create mode 100644 src/tools/ilasm/src/ILAssembler/CILParser.SemanticValues.Manifest.cs create mode 100644 src/tools/ilasm/src/ILAssembler/CILParser.SemanticValues.Marshalling.cs create mode 100644 src/tools/ilasm/src/ILAssembler/CILParser.SemanticValues.MethodBodies.cs create mode 100644 src/tools/ilasm/src/ILAssembler/CILParser.SemanticValues.Signatures.cs create mode 100644 src/tools/ilasm/src/ILAssembler/CompatibilitySuppressions.xml delete mode 100644 src/tools/ilasm/src/ILAssembler/TypeName.cs create mode 100644 src/tools/ilasm/src/ILAssembler/ref/ILAssembler.csproj create mode 100644 src/tools/ilasm/src/ILAssembler/ref/ILAssembler/CompilationResult.cs create mode 100644 src/tools/ilasm/src/ILAssembler/ref/ILAssembler/Diagnostic.cs create mode 100644 src/tools/ilasm/src/ILAssembler/ref/ILAssembler/DocumentCompiler.cs create mode 100644 src/tools/ilasm/src/ILAssembler/ref/ILAssembler/Location.cs create mode 100644 src/tools/ilasm/src/ILAssembler/ref/ILAssembler/Options.cs create mode 100644 src/tools/ilasm/src/ILAssembler/ref/ILAssembler/SourceSpan.cs create mode 100644 src/tools/ilasm/src/ILAssembler/ref/ILAssembler/SourceText.cs diff --git a/src/tools/ilasm/README.md b/src/tools/ilasm/README.md index ca42c5c7187c60..50431f8124e04c 100644 --- a/src/tools/ilasm/README.md +++ b/src/tools/ilasm/README.md @@ -7,6 +7,16 @@ declaration body or method body is never retained. Rules such as `bytes` stream an accumulator instead of building a subtree at all. The generator emits neither listeners nor visitors; parser actions own traversal. +## Public contract + +`src/ILAssembler/ref/ILAssembler.csproj` defines the supported compiler API as a custom reference +assembly, following the same pattern as Mono.Linker. Project references compile against this +contract by default, while the implementation assembly remains the runtime asset. + +ANTLR-generated parser types and the preprocessing/string helpers used by implementation tests are +intentionally absent from the contract. Tests opt into the implementation assembly with +`SkipUseReferenceAssembly`. + `GrammarActions` is a single `internal sealed partial class` split across `src/ILAssembler/Actions/GrammarActions.*.cs`: @@ -19,7 +29,6 @@ visitors; parser actions own traversal. | `GrammarActions.CustomAttributes.Actions.cs` | Custom attribute descriptors, declarations and blob lists. | | `GrammarActions.CustomAttributes.Sequences.cs` | Custom attribute scalar-array sequence synthesis. | | `GrammarActions.CustomAttributes.Serialization.cs` | Serialized attribute values and field/parameter initializers. | -| `GrammarActions.CustomAttributes.Values.cs` | Internal synthesized custom attribute value model. | | `GrammarActions.Data.cs` | Streaming mapped-data declarations, labels and reference fixups. | | `GrammarActions.Debug.cs` | Direct source-location, document and language directives. | | `GrammarActions.Declarations.Actions.cs` | Direct top-level declarations and shared-directive dispatch. | @@ -32,54 +41,63 @@ visitors; parser actions own traversal. | `GrammarActions.Manifest.References.cs` | Assembly references, identities, keys and hashes. | | `GrammarActions.Manifest.Resources.cs` | Embedded and external manifest resources. | | `GrammarActions.Manifest.Typedefs.cs` | Type, member and custom-attribute aliases. | -| `GrammarActions.Manifest.Values.cs` | Internal synthesized manifest value model and list frames. | | `GrammarActions.Manifest.VTable.cs` | Vtable fixup declarations and flags. | | `GrammarActions.Marshalling.Actions.cs` | Synthesized native type and marshalling descriptor actions. | | `GrammarActions.Members.Class.cs` | Class directives, generic parameter annotations and method overrides. | | `GrammarActions.Members.Fields.cs` | Field declarations, attributes, layout, constants, marshalling and RVA data. | | `GrammarActions.Members.PropertiesEvents.cs` | Property and event headers, bodies and accessors. | -| `GrammarActions.Members.Values.cs` | Internal synthesized member value model. | | `GrammarActions.MethodHeaders.cs` | Method definition and signature materialization. | | `GrammarActions.MethodHeaders.Actions.cs` | Method header, attribute, P/Invoke and generic parser actions. | | `GrammarActions.MethodHeaders.Generics.cs` | Generic parameter and constraint synthesis and materialization. | -| `GrammarActions.MethodHeaders.Values.cs` | Internal synthesized method-header value model. | | `GrammarActions.MethodBodies.cs` | Label validation and method-name parsing. | | `GrammarActions.MethodBodies.Directives.cs` | Direct method-body directives and parameter ownership. | | `GrammarActions.MethodBodies.ExceptionHandling.cs` | Lexical scopes and synthesized exception regions. | -| `GrammarActions.MethodBodies.Values.cs` | Internal method-body directive and exception-region values. | | `GrammarActions.Security.cs` | Synthesized declarative-security values and permission sets. | | `GrammarActions.Signatures.cs` | Member and type signature materialization helpers. | -| `GrammarActions.Signatures.Actions.cs` | Signature grammar actions and repetition frames. | +| `GrammarActions.Signatures.Actions.cs` | Signature grammar actions and typed aggregation helpers. | | `GrammarActions.Signatures.References.cs` | Member-reference synthesis and materialization. | | `GrammarActions.Signatures.Types.cs` | Type-signature materialization and encoding. | -| `GrammarActions.Signatures.Values.cs` | Internal synthesized signature value model. | | `GrammarActions.Types.cs` | Namespace and type scope ownership and shared type conversion. | | `GrammarActions.Types.Headers.cs` | Namespace and type-header materialization. | | `GrammarActions.Types.Headers.Actions.cs` | Namespace, type attribute, base and interface parser actions. | -| `GrammarActions.Types.Headers.Values.cs` | Internal synthesized type-header value model. | | `GrammarActions.Types.References.cs` | Type-name synthesis and resolution. | +The hand-written `public partial CILParser` semantic model is split by feature: + +| File | Contents | +| ---- | -------- | +| `CILParser.SemanticValues.CustomAttributes.cs` | Custom attribute, serialization and initializer values. | +| `CILParser.SemanticValues.Declarations.cs` | Type/member headers and their context-owned builders. | +| `CILParser.SemanticValues.Manifest.cs` | Assembly, file, exported-type, resource and typedef values. | +| `CILParser.SemanticValues.Marshalling.cs` | Native, variant and marshalling values and builders. | +| `CILParser.SemanticValues.MethodBodies.cs` | Debug, data, security, exception and instruction values. | +| `CILParser.SemanticValues.Signatures.cs` | Managed types, signatures, names, owners and member references. | + +These types are public because ANTLR emits public rule-context return and local fields. They are +implementation-only: the explicit reference assembly omits `CILParser`, and its existing CP0001 +suppression covers the nested semantic types as part of that excluded surface. + ## Rules for grammar actions -Parser actions in `src/ILAssembler/gen/CIL.g4` must remain thin; they call a single `Actions` method -and nothing else. Compilation orchestration belongs in the `GrammarActions` partial-class files. +Parser actions in `src/ILAssembler/gen/CIL.g4` must remain thin. They pass concrete child-rule +values to `GrammarActions`; mechanical assignments and typed builder additions may happen directly +in the grammar. Compilation orchestration belongs in the `GrammarActions` partial-class files. `DocumentCompiler` disables parse-tree construction when it creates the parser, and no parser action changes that setting. ANTLR generates neither listeners nor visitors. All semantics come from parser -actions and compact synthesized values. The generated ANTLR context classes are public, while -ILAssembler entities and signature implementation values remain internal, so generated return slots -use `object` where an internal value or array crosses that boundary and `GrammarActions` provides the -strongly typed accessors and materializers. +actions and concrete synthesized values. Rule contexts own their typed builders and pass finalized +child values to their parents; parser semantic data is never erased to `object`. All namespace, type-header, top-level, type, signature, reference, marshalling, class-member, method-header, method-body directive, exception-handling, data, security, source, language, assembly, manifest, vtable and typedef structure is action-driven. `scopeBlock` records offsets under its context key without inspecting children. `BuildParseTree` remains disabled throughout. -Semantic state that a rule pushes must be released from that rule's `finally` clause and be keyed on -the owning context, because ANTLR skips `@after` actions and the remainder of an alternative once a -rule reports a syntax error. Inline actions placed after a subrule reference are not a substitute: -they run only when the alternative completes. +Rule-local builders are finalized from that rule's `finally` clause when error recovery requires a +value. Semantic roots capture the initial syntax-error count in a context local instead of a global +frame stack. The remaining stacks model active compiler nesting: namespaces, types, declaration +owners and lexical method scopes. Their owning declaration or scope releases them from `finally` +because ANTLR skips `@after` actions after a syntax error. Only parser actions process structural rules. There is no parse-tree walker or mode toggling. diff --git a/src/tools/ilasm/ilasm.slnx b/src/tools/ilasm/ilasm.slnx index fc6b5afa291976..fba31c6ccf0595 100644 --- a/src/tools/ilasm/ilasm.slnx +++ b/src/tools/ilasm/ilasm.slnx @@ -1,4 +1,7 @@ + + + diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Bytes.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Bytes.cs index aefb926552e8c8..42537cf919e7f7 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Bytes.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Bytes.cs @@ -1,49 +1,24 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System; -using System.Buffers.Binary; -using System.Collections.Generic; using System.Collections.Immutable; -using System.Diagnostics; using System.Globalization; -using System.IO; -using System.Linq; -using System.Reflection; -using System.Reflection.Metadata; -using System.Reflection.Metadata.Ecma335; -using System.Reflection.PortableExecutable; -using System.Runtime.InteropServices; -using System.Security.Cryptography; -using System.Text; using Antlr4.Runtime; -using Antlr4.Runtime.Misc; namespace ILAssembler; internal sealed partial class GrammarActions { - private ImmutableArray.Builder? _byteAccumulator; +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. + internal ImmutableArray.Builder CreateByteAccumulator() + => ImmutableArray.CreateBuilder(); - /// - /// Starts accumulating the bytes of a bytearray literal. - /// - /// - /// Parse-tree construction is disabled for the entire parse, so the individual hexbyte - /// contexts and terminals are collectable as soon as they are matched. The bytes themselves - /// stream into this accumulator, which keeps a single byte array alive instead of a context and - /// a terminal node per byte. - /// - internal void BeginBytes() => _byteAccumulator = ImmutableArray.CreateBuilder(); - - internal void AddByte(byte value) => _byteAccumulator?.Add(value); + internal void AddByte(ImmutableArray.Builder accumulator, byte value) + => accumulator.Add(value); - internal ImmutableArray EndBytes() - { - ImmutableArray.Builder? accumulator = _byteAccumulator; - _byteAccumulator = null; - return accumulator?.DrainToImmutable() ?? ImmutableArray.Empty; - } + internal ImmutableArray EndBytes(ImmutableArray.Builder accumulator) + => accumulator.DrainToImmutable(); +#pragma warning restore CA1822 /// /// Parses a single hexbyte token. diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs index 6170dba026bc8e..06111b64304b78 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Conversions.cs @@ -35,7 +35,6 @@ internal sealed partial class GrammarActions private readonly Dictionary _mappedFieldDataNames = new(); private readonly Dictionary> _mappedFieldDataReferenceFixups = new(); private readonly BlobBuilder _manifestResources = new(); - private readonly Stack _semanticRootFrames = new(); private int _syntaxErrorCount; // Debug info tracking @@ -82,19 +81,29 @@ private void ReportWarning(string id, string message, IToken token) Location.From(token, _documents))); } - private sealed record SemanticRootFrame(ParserRuleContext Owner, int InitialSyntaxErrorCount); - internal void RecordSyntaxError() => _syntaxErrorCount++; - internal void BeginSemanticRoot(ParserRuleContext context) - => _semanticRootFrames.Push(new(context, _syntaxErrorCount)); + internal int SyntaxErrorCount => _syntaxErrorCount; + + internal bool HasSyntaxErrorsSince(int initialSyntaxErrorCount) + => initialSyntaxErrorCount != _syntaxErrorCount; - internal bool EndSemanticRoot(ParserRuleContext context) + private static T ApplyAttribute( + T current, + CILParser.AttributeValue attribute) + where T : struct, Enum { - Debug.Assert(_semanticRootFrames.Count > 0); - SemanticRootFrame frame = _semanticRootFrames.Pop(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - return frame.InitialSyntaxErrorCount != _syntaxErrorCount || context.exception is not null; + if (!attribute.ShouldAppend) + { + return attribute.Value; + } + + int currentValue = Convert.ToInt32(current); + int groupMask = Convert.ToInt32(attribute.GroupMask); + int attributeValue = Convert.ToInt32(attribute.Value); + return (T)Enum.ToObject( + typeof(T), + (currentValue & ~groupMask) | attributeValue); } private static bool IsRecoverableError(string diagnosticId) @@ -147,17 +156,10 @@ public CurrentMethodContext(EntityRegistry.MethodDefinitionEntity definition) private const ushort CustomAttributeBlobFormatVersion = 1; + // These stacks are the active nested compiler scopes, not parser-value accumulators. private readonly Stack _currentNamespace = new(); - private readonly Stack _currentTypeDefinition = new(); - // Sentinel to distinguish "no constant" from "constant is null" - private sealed class NoConstantSentinel - { - public static readonly NoConstantSentinel Instance = new(); - private NoConstantSentinel() { } - } - private bool _expectInstance; private Subsystem _subsystem = Subsystem.WindowsCui; private CorFlags _corflags = CorFlags.ILOnly; diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Actions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Actions.cs index 5e36c20dc55f79..a7293be4da92bf 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Actions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Actions.cs @@ -1,9 +1,7 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System.Collections.Generic; using System.Collections.Immutable; -using System.Diagnostics; using System.Reflection.Metadata; using Antlr4.Runtime; @@ -12,103 +10,87 @@ namespace ILAssembler; #pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. internal sealed partial class GrammarActions { - private readonly Stack _customBlobArgumentFrames = new(); - private readonly Stack _customBlobNamedArgumentFrames = new(); + internal MethodReferenceValue CreateCustomAttributeType(MethodReferenceValue constructor) + => constructor; - private sealed class CustomBlobArgumentsFrame - { - public CustomBlobArgumentsFrame(CILParser.CustomBlobArgsContext owner) - { - Owner = owner; - } - - public CILParser.CustomBlobArgsContext Owner { get; } - - public ImmutableArray.Builder? Values { get; set; } - } - - private sealed class CustomBlobNamedArgumentsFrame - { - public CustomBlobNamedArgumentsFrame(CILParser.CustomBlobNVPairsContext owner) - { - Owner = owner; - } - - public CILParser.CustomBlobNVPairsContext Owner { get; } - - public ImmutableArray.Builder? Values { get; set; } - } - - internal object CreateCustomAttributeType(object? constructor) - => GetMethodReferenceValue(constructor); - - internal object CreateDefaultCustomAttribute(object? constructor) + internal CustomAttributeDescriptorValue CreateDefaultCustomAttribute( + MethodReferenceValue constructor) => CreateCustomAttributeDescriptor( constructor, new RawCustomAttributeBlobValue(CreateDefaultCustomAttributeBlob()), null); - internal object CreateStringCustomAttribute(object? constructor, string value) + internal CustomAttributeDescriptorValue CreateStringCustomAttribute( + MethodReferenceValue constructor, + string value) => CreateCustomAttributeDescriptor( constructor, new RawCustomAttributeBlobValue(CreateStringBlob(value)), null); - internal object CreateStructuredCustomAttribute(object? constructor, object? value) + internal CustomAttributeDescriptorValue CreateStructuredCustomAttribute( + MethodReferenceValue constructor, + CustomAttributeBlobValue value) => CreateCustomAttributeDescriptor( constructor, - value as CustomAttributeBlobValue - ?? new RawCustomAttributeBlobValue(new BlobBuilder()), + value, null); - internal object CreateRawCustomAttribute(object? constructor, ImmutableArray value) + internal CustomAttributeDescriptorValue CreateRawCustomAttribute( + MethodReferenceValue constructor, + ImmutableArray value) => CreateCustomAttributeDescriptor( constructor, new RawCustomAttributeBlobValue(CreateRawBlob(value)), null); - internal object CreateDefaultOwnedCustomAttribute(object? owner, object? constructor) + internal CustomAttributeDescriptorValue CreateDefaultOwnedCustomAttribute( + OwnerTypeValue owner, + MethodReferenceValue constructor) => CreateCustomAttributeDescriptor( constructor, new RawCustomAttributeBlobValue(CreateDefaultCustomAttributeBlob()), - GetOwnerTypeValue(owner)); + owner); - internal object CreateStringOwnedCustomAttribute(object? owner, object? constructor, string value) + internal CustomAttributeDescriptorValue CreateStringOwnedCustomAttribute( + OwnerTypeValue owner, + MethodReferenceValue constructor, + string value) => CreateCustomAttributeDescriptor( constructor, new RawCustomAttributeBlobValue(CreateStringBlob(value)), - GetOwnerTypeValue(owner)); + owner); - internal object CreateStructuredOwnedCustomAttribute( - object? owner, - object? constructor, - object? value) + internal CustomAttributeDescriptorValue CreateStructuredOwnedCustomAttribute( + OwnerTypeValue owner, + MethodReferenceValue constructor, + CustomAttributeBlobValue value) => CreateCustomAttributeDescriptor( constructor, - value as CustomAttributeBlobValue - ?? new RawCustomAttributeBlobValue(new BlobBuilder()), - GetOwnerTypeValue(owner)); + value, + owner); - internal object CreateRawOwnedCustomAttribute( - object? owner, - object? constructor, + internal CustomAttributeDescriptorValue CreateRawOwnedCustomAttribute( + OwnerTypeValue owner, + MethodReferenceValue constructor, ImmutableArray value) => CreateCustomAttributeDescriptor( constructor, new RawCustomAttributeBlobValue(CreateRawBlob(value)), - GetOwnerTypeValue(owner)); + owner); - internal object CreateCustomAttributeDeclaration(object? value) - => GetCustomAttributeDescriptorValue(value); + internal CustomAttributeDeclarationValue CreateCustomAttributeDeclaration( + CustomAttributeDescriptorValue value) + => value; - internal object CreateCustomAttributeTypedef(string alias) + internal CustomAttributeDeclarationValue CreateCustomAttributeTypedef(string alias) => new CustomAttributeTypedefValue(alias); private static CustomAttributeDescriptorValue CreateCustomAttributeDescriptor( - object? constructor, + MethodReferenceValue constructor, CustomAttributeBlobValue value, OwnerTypeValue? owner) - => new(GetMethodReferenceValue(constructor), value, owner); + => new(constructor, value, owner); private static BlobBuilder CreateStringBlob(string value) { @@ -124,94 +106,25 @@ private static BlobBuilder CreateRawBlob(ImmutableArray value) return blob; } - internal object CreateCustomAttributeBlob(object? arguments, object? namedArguments) - => new StructuredCustomAttributeBlobValue( - arguments is ImmutableArray argumentValues - ? argumentValues - : [], - namedArguments is ImmutableArray namedArgumentValues - ? namedArgumentValues - : []); - - internal void BeginCustomBlobArguments(CILParser.CustomBlobArgsContext context) - => _customBlobArgumentFrames.Push(new(context)); - - internal void AddCustomBlobArgument(CILParser.CustomBlobArgsContext context, object? value) + private static BlobBuilder CreateDefaultCustomAttributeBlob() { - if (TryGetCustomBlobArgumentsFrame(context) is { } frame) - { - (frame.Values ??= - ImmutableArray.CreateBuilder()) - .Add(GetSerializedInitializerValue(value)); - } + BlobBuilder value = new(); + value.WriteUInt16(CustomAttributeBlobFormatVersion); + value.WriteUInt16(0); + return value; } - internal object EndCustomBlobArguments(CILParser.CustomBlobArgsContext context) - { - if (TryGetCustomBlobArgumentsFrame(context) is not { } frame) - { - return ImmutableArray.Empty; - } - - _customBlobArgumentFrames.Pop(); - return frame.Values?.ToImmutable() ?? ImmutableArray.Empty; - } - - internal void BeginCustomBlobNamedArguments(CILParser.CustomBlobNVPairsContext context) - => _customBlobNamedArgumentFrames.Push(new(context)); + internal CustomAttributeBlobValue CreateCustomAttributeBlob( + ImmutableArray arguments, + ImmutableArray namedArguments) + => new StructuredCustomAttributeBlobValue(arguments, namedArguments); - internal void AddCustomBlobNamedArgument( - CILParser.CustomBlobNVPairsContext context, + internal CustomAttributeNamedArgumentValue CreateCustomBlobNamedArgument( byte kind, - object? type, + SerializationTypeValue type, string name, - object? value) - { - if (TryGetCustomBlobNamedArgumentsFrame(context) is not { } frame) - { - return; - } - - (frame.Values ??= - ImmutableArray.CreateBuilder()) - .Add(new( - kind, - GetSerializationTypeValue(type), - name, - GetSerializedInitializerValue(value))); - } - - internal object EndCustomBlobNamedArguments(CILParser.CustomBlobNVPairsContext context) - { - if (TryGetCustomBlobNamedArgumentsFrame(context) is not { } frame) - { - return ImmutableArray.Empty; - } - - _customBlobNamedArgumentFrames.Pop(); - return frame.Values?.ToImmutable() - ?? ImmutableArray.Empty; - } - - private CustomBlobArgumentsFrame? TryGetCustomBlobArgumentsFrame( - CILParser.CustomBlobArgsContext context) - { - Debug.Assert(_customBlobArgumentFrames.Count > 0); - CustomBlobArgumentsFrame? frame = - _customBlobArgumentFrames.Count == 0 ? null : _customBlobArgumentFrames.Peek(); - Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); - return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; - } - - private CustomBlobNamedArgumentsFrame? TryGetCustomBlobNamedArgumentsFrame( - CILParser.CustomBlobNVPairsContext context) - { - Debug.Assert(_customBlobNamedArgumentFrames.Count > 0); - CustomBlobNamedArgumentsFrame? frame = - _customBlobNamedArgumentFrames.Count == 0 ? null : _customBlobNamedArgumentFrames.Peek(); - Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); - return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; - } + SerializedInitializerValue value) + => new(kind, type, name, value); private BlobBuilder MaterializeCustomAttributeBlob(CustomAttributeBlobValue value) { @@ -220,8 +133,11 @@ private BlobBuilder MaterializeCustomAttributeBlob(CustomAttributeBlobValue valu return raw.Value; } - StructuredCustomAttributeBlobValue structured = - (StructuredCustomAttributeBlobValue)value; + if (value is not StructuredCustomAttributeBlobValue structured) + { + return new BlobBuilder(); + } + BlobBuilder result = new(); result.WriteUInt16(CustomAttributeBlobFormatVersion); foreach (SerializedInitializerValue argument in structured.Arguments) @@ -265,7 +181,7 @@ private EntityRegistry.CustomAttributeEntity MaterializeCustomAttribute( } private EntityRegistry.CustomAttributeEntity? MaterializeCustomAttributeDeclaration( - object? value, + CustomAttributeDeclarationValue? value, IToken location) { if (value is CustomAttributeTypedefValue typedef) @@ -296,9 +212,7 @@ private EntityRegistry.CustomAttributeEntity MaterializeCustomAttribute( internal EntityRegistry.CustomAttributeEntity MaterializeCustomAttributeDescriptor( CILParser.CustomDescrContext context) - => MaterializeCustomAttribute( - GetCustomAttributeDescriptorValue(context.Value), - context.Start); + => MaterializeCustomAttribute(context.Value, context.Start); internal EntityRegistry.CustomAttributeEntity? MaterializeMethodBodyCustomAttributeDeclaration( CILParser.CustomDescrInMethodBodyContext context) @@ -306,5 +220,5 @@ internal EntityRegistry.CustomAttributeEntity MaterializeCustomAttributeDescript internal EntityRegistry.EntityBase MaterializeOwnerType( CILParser.OwnerTypeContext context) - => MaterializeOwnerType(GetOwnerTypeValue(context.Value)); + => MaterializeOwnerType(context.Value); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Sequences.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Sequences.cs index 0ae4f6e7f67400..06c356deb44c33 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Sequences.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Sequences.cs @@ -1,9 +1,6 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System.Collections.Generic; -using System.Collections.Immutable; -using System.Diagnostics; using System.Reflection.Metadata; using Antlr4.Runtime; @@ -12,180 +9,47 @@ namespace ILAssembler; #pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. internal sealed partial class GrammarActions { - private readonly Stack _serializationSequenceFrames = new(); + internal void AddFloat32SequenceValue(BlobBuilder builder, double value) + => builder.WriteSingle((float)value); - private sealed class SerializationSequenceFrame - { - public SerializationSequenceFrame(ParserRuleContext owner) - { - Owner = owner; - } - - public ParserRuleContext Owner { get; } - - public BlobBuilder? Value { get; set; } - - public ImmutableArray.Builder? ClassValues { get; set; } - - public ImmutableArray.Builder? ObjectValues { get; set; } - } - - internal void BeginSerializationSequence(ParserRuleContext context) - => _serializationSequenceFrames.Push(new(context)); - - internal void AddFloat32SequenceValue(ParserRuleContext context, double value) - { - if (TryGetSerializationSequenceFrame(context) is { } frame) - { - (frame.Value ??= new BlobBuilder()).WriteSingle((float)value); - } - } - - internal void AddFloat32SequenceValue(ParserRuleContext context, IToken value) - { - if (TryGetSerializationSequenceFrame(context) is { } frame) - { - (frame.Value ??= new BlobBuilder()).WriteSingle(ParseInt32(value)); - } - } - - internal void AddFloat64SequenceValue(ParserRuleContext context, double value) - { - if (TryGetSerializationSequenceFrame(context) is { } frame) - { - (frame.Value ??= new BlobBuilder()).WriteDouble(value); - } - } - - internal void AddFloat64SequenceValue(ParserRuleContext context, IToken value) - { - if (TryGetSerializationSequenceFrame(context) is { } frame) - { - (frame.Value ??= new BlobBuilder()).WriteDouble(ParseInt64(value)); - } - } - - internal void AddInt64SequenceValue(ParserRuleContext context, IToken value) - { - if (TryGetSerializationSequenceFrame(context) is { } frame) - { - (frame.Value ??= new BlobBuilder()).WriteInt64(ParseInt64(value)); - } - } - - internal void AddInt32SequenceValue(ParserRuleContext context, IToken value) - { - if (TryGetSerializationSequenceFrame(context) is { } frame) - { - (frame.Value ??= new BlobBuilder()).WriteInt32(ParseInt32(value)); - } - } - - internal void AddInt16SequenceValue(ParserRuleContext context, IToken value) - { - if (TryGetSerializationSequenceFrame(context) is { } frame) - { - (frame.Value ??= new BlobBuilder()).WriteInt16((short)ParseInt32(value)); - } - } + internal void AddFloat32SequenceValue(BlobBuilder builder, IToken value) + => builder.WriteSingle(ParseInt32(value)); - internal void AddInt8SequenceValue(ParserRuleContext context, IToken value) - { - if (TryGetSerializationSequenceFrame(context) is { } frame) - { - (frame.Value ??= new BlobBuilder()).WriteByte((byte)ParseInt32(value)); - } - } + internal void AddFloat64SequenceValue(BlobBuilder builder, double value) + => builder.WriteDouble(value); - internal void AddBooleanSequenceValue(ParserRuleContext context, bool value) - { - if (TryGetSerializationSequenceFrame(context) is { } frame) - { - (frame.Value ??= new BlobBuilder()).WriteBoolean(value); - } - } + internal void AddFloat64SequenceValue(BlobBuilder builder, IToken value) + => builder.WriteDouble(ParseInt64(value)); - internal void AddStringSequenceValue(ParserRuleContext context, IToken value) - { - if (TryGetSerializationSequenceFrame(context) is { } frame) - { - (frame.Value ??= new BlobBuilder()).WriteSerializedString( - value.Type == CILParser.NULLREF - ? null - : StringHelpers.ParseQuotedString(value.Text)); - } - } + internal void AddInt64SequenceValue(BlobBuilder builder, IToken value) + => builder.WriteInt64(ParseInt64(value)); - internal void AddClassSequenceValue(ParserRuleContext context, object? value) - { - if (TryGetSerializationSequenceFrame(context) is { } frame && - value is ClassSequenceElementValue element) - { - (frame.ClassValues ??= - ImmutableArray.CreateBuilder()).Add(element); - } - } + internal void AddInt32SequenceValue(BlobBuilder builder, IToken value) + => builder.WriteInt32(ParseInt32(value)); - internal void AddObjectSequenceValue(ParserRuleContext context, object? value) - { - if (TryGetSerializationSequenceFrame(context) is { } frame) - { - (frame.ObjectValues ??= - ImmutableArray.CreateBuilder()) - .Add(GetSerializedInitializerValue(value)); - } - } - - internal BlobBuilder EndSerializationSequence(ParserRuleContext context) - { - if (TryGetSerializationSequenceFrame(context) is not { } frame) - { - return new BlobBuilder(); - } - - _serializationSequenceFrames.Pop(); - return frame.Value ?? new BlobBuilder(); - } - - internal object EndClassSerializationSequence(ParserRuleContext context) - { - if (TryGetSerializationSequenceFrame(context) is not { } frame) - { - return new ClassSerializedSequenceValue([]); - } + internal void AddInt16SequenceValue(BlobBuilder builder, IToken value) + => builder.WriteInt16((short)ParseInt32(value)); - _serializationSequenceFrames.Pop(); - return new ClassSerializedSequenceValue(frame.ClassValues?.ToImmutable() ?? []); - } - - internal object EndObjectSerializationSequence(ParserRuleContext context) - { - if (TryGetSerializationSequenceFrame(context) is not { } frame) - { - return new ObjectSerializedSequenceValue([]); - } + internal void AddInt8SequenceValue(BlobBuilder builder, IToken value) + => builder.WriteByte((byte)ParseInt32(value)); - _serializationSequenceFrames.Pop(); - return new ObjectSerializedSequenceValue(frame.ObjectValues?.ToImmutable() ?? []); - } + internal void AddBooleanSequenceValue(BlobBuilder builder, bool value) + => builder.WriteBoolean(value); - private SerializationSequenceFrame? TryGetSerializationSequenceFrame(ParserRuleContext context) - { - Debug.Assert(_serializationSequenceFrames.Count > 0); - SerializationSequenceFrame? frame = - _serializationSequenceFrames.Count == 0 ? null : _serializationSequenceFrames.Peek(); - Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); - return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; - } + internal void AddStringSequenceValue(BlobBuilder builder, IToken value) + => builder.WriteSerializedString( + value.Type == CILParser.NULLREF + ? null + : StringHelpers.ParseQuotedString(value.Text)); - internal object CreateNullClassSequenceValue() + internal ClassSequenceElementValue CreateNullClassSequenceValue() => new StringClassSequenceElementValue(null); - internal object CreateQuotedClassSequenceValue(IToken value) + internal ClassSequenceElementValue CreateQuotedClassSequenceValue(IToken value) => new StringClassSequenceElementValue(StringHelpers.ParseQuotedString(value.Text)); - internal object CreateClassSequenceValue(object? className) - => new TypeClassSequenceElementValue(GetClassNameValue(className)); + internal ClassSequenceElementValue CreateClassSequenceValue(ClassNameValue className) + => new TypeClassSequenceElementValue(className); private BlobBuilder MaterializeSerializedSequence(SerializedSequenceValue sequence) { diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Serialization.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Serialization.cs index 8309af8d063773..415ed45e2d0a11 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Serialization.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Serialization.cs @@ -18,28 +18,29 @@ internal byte GetCustomAttributeNamedArgumentKind(IToken token) ? CustomAttributeNamedArgumentKind.Field : CustomAttributeNamedArgumentKind.Property); - internal object CreateSerializationType(object? element, IToken? array) + internal SerializationTypeValue CreateSerializationType( + SerializationTypeValue element, + IToken? array) { - SerializationTypeValue value = GetSerializationTypeValue(element); - return array is null ? value : new ArraySerializationTypeValue(value); + return array is null ? element : new ArraySerializationTypeValue(element); } - internal object CreatePrimitiveSerializationType(byte type) + internal SerializationTypeValue CreatePrimitiveSerializationType(byte type) => new SimpleSerializationTypeValue((SerializationTypeCode)type); - internal object CreateSerializationTypeTypedef( + internal SerializationTypeValue CreateSerializationTypeTypedef( CILParser.SerializTypeElementContext context, string alias) => new TypedefSerializationTypeValue(context.Start, alias); - internal object CreateSimpleSerializationType(IToken type) + internal SerializationTypeValue CreateSimpleSerializationType(IToken type) => new SimpleSerializationTypeValue(GetSerializationTypeCode(type.Type)); - internal object CreateEnumSerializationType(IToken name) + internal SerializationTypeValue CreateEnumSerializationType(IToken name) => new StringEnumSerializationTypeValue(StringHelpers.ParseQuotedString(name.Text)); - internal object CreateEnumSerializationType(object? className) - => new ClassEnumSerializationTypeValue(GetClassNameValue(className)); + internal SerializationTypeValue CreateEnumSerializationType(ClassNameValue className) + => new ClassEnumSerializationTypeValue(className); internal BlobBuilder CreateFloat32SerializedInitializer( CILParser.Float64Context context, @@ -140,26 +141,16 @@ private static BlobBuilder CreateSerializedInitializer( return blob; } - internal object? CreateFieldInitializer(BlobBuilder value) - => ExtractConstantFromSerInit(value); + internal FieldInitializerValue CreateFieldInitializer(BlobBuilder value) + => new(true, ExtractConstantFromSerInit(value)); - internal object CreateFieldInitializer(string value) => value; + internal FieldInitializerValue CreateFieldInitializer(string value) + => new(true, value); - internal object? CreateNullFieldInitializer() => null; + internal FieldInitializerValue CreateNullFieldInitializer() + => new(true, null); - internal void BeginFieldInitializer(CILParser.InitOptContext context) - { - BeginSemanticRoot(context); - context.Value = NoConstantSentinel.Instance; - } - - internal void SetFieldInitializer(CILParser.InitOptContext context, object? value) - => context.Value = value; - - internal bool EndFieldInitializer(CILParser.InitOptContext context) - => EndSemanticRoot(context); - - internal object CreateScalarSerializedValue( + internal SerializedInitializerValue CreateScalarSerializedValue( CILParser.SerInitContext context, CILParser.FieldSerInitContext initializer, BlobBuilder value) @@ -182,23 +173,23 @@ internal object CreateScalarSerializedValue( return new RawSerializedInitializerValue(type, serializedValue); } - internal object CreateStringSerializedValue() + internal SerializedInitializerValue CreateStringSerializedValue() => CreateSerializedStringValue(SerializationTypeCode.String, null); - internal object CreateStringSerializedValue(IToken value) + internal SerializedInitializerValue CreateStringSerializedValue(IToken value) => CreateSerializedStringValue( SerializationTypeCode.String, StringHelpers.ParseQuotedString(value.Text)); - internal object CreateTypeSerializedValue(IToken value) + internal SerializedInitializerValue CreateTypeSerializedValue(IToken value) => CreateSerializedStringValue( SerializationTypeCode.Type, StringHelpers.ParseQuotedString(value.Text)); - internal object CreateTypeSerializedValue(object? className) - => new ClassNameSerializedInitializerValue(GetClassNameValue(className)); + internal SerializedInitializerValue CreateTypeSerializedValue(ClassNameValue className) + => new ClassNameSerializedInitializerValue(className); - internal object CreateNullTypeSerializedValue() + internal SerializedInitializerValue CreateNullTypeSerializedValue() => CreateSerializedStringValue(SerializationTypeCode.Type, null); private static RawSerializedInitializerValue CreateSerializedStringValue( @@ -212,18 +203,28 @@ private static RawSerializedInitializerValue CreateSerializedStringValue( serializedValue); } - internal object CreateObjectSerializedValue(object? value) - => new ObjectSerializedInitializerValue(GetSerializedInitializerValue(value)); + internal SerializedInitializerValue CreateObjectSerializedValue( + SerializedInitializerValue value) + => new ObjectSerializedInitializerValue(value); - internal object CreateArraySerializedValue( + internal SerializedInitializerValue CreateArraySerializedValue( IToken elementType, IToken length, - object? values) + SerializedSequenceValue values) => new ArraySerializedInitializerValue( new ArraySerializationTypeValue( new SimpleSerializationTypeValue(GetSerializationTypeCode(elementType.Type))), ParseInt32(length), - GetSerializedSequenceValue(values)); + values); + + internal SerializedInitializerValue CreateArraySerializedValue( + IToken elementType, + IToken length, + BlobBuilder values) + => CreateArraySerializedValue( + elementType, + length, + new RawSerializedSequenceValue(values)); private BlobBuilder MaterializeSerializationType(SerializationTypeValue value) { @@ -397,6 +398,6 @@ private static SerializationTypeCode GetSerializationTypeCode(int tokenType) : Encoding.UTF8.GetString(bytes.Slice(bytesRead, length)); } - internal static object? GetInitializerValue(CILParser.InitOptContext context) + internal static FieldInitializerValue GetInitializerValue(CILParser.InitOptContext context) => context.Value; } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Values.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Values.cs deleted file mode 100644 index 2fa2a399783539..00000000000000 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.CustomAttributes.Values.cs +++ /dev/null @@ -1,132 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Collections.Immutable; -using System.Reflection.Metadata; -using Antlr4.Runtime; - -namespace ILAssembler; - -internal sealed partial class GrammarActions -{ - private sealed record CustomAttributeDescriptorValue( - MethodReferenceValue Constructor, - CustomAttributeBlobValue Value, - OwnerTypeValue? Owner); - - private sealed record CustomAttributeTypedefValue(string Alias); - - private abstract record CustomAttributeBlobValue; - - private sealed record RawCustomAttributeBlobValue(BlobBuilder Value) - : CustomAttributeBlobValue; - - private sealed record StructuredCustomAttributeBlobValue( - ImmutableArray Arguments, - ImmutableArray NamedArguments) - : CustomAttributeBlobValue; - - private sealed record CustomAttributeNamedArgumentValue( - byte Kind, - SerializationTypeValue Type, - string Name, - SerializedInitializerValue Value); - - private abstract record SerializationTypeValue; - - private sealed record RawSerializationTypeValue(BlobBuilder Value) - : SerializationTypeValue; - - private sealed record SimpleSerializationTypeValue(SerializationTypeCode Type) - : SerializationTypeValue; - - private sealed record ArraySerializationTypeValue(SerializationTypeValue ElementType) - : SerializationTypeValue; - - private sealed record StringEnumSerializationTypeValue(string Name) - : SerializationTypeValue; - - private sealed record ClassEnumSerializationTypeValue(ClassNameValue ClassName) - : SerializationTypeValue; - - private sealed record TypedefSerializationTypeValue(IToken Token, string Alias) - : SerializationTypeValue; - - private abstract record SerializedInitializerValue(SerializationTypeValue Type); - - private sealed record RawSerializedInitializerValue( - SerializationTypeValue Type, - BlobBuilder Value) - : SerializedInitializerValue(Type); - - private sealed record ClassNameSerializedInitializerValue(ClassNameValue ClassName) - : SerializedInitializerValue(new SimpleSerializationTypeValue(SerializationTypeCode.Type)); - - private sealed record ObjectSerializedInitializerValue(SerializedInitializerValue Value) - : SerializedInitializerValue( - new SimpleSerializationTypeValue(SerializationTypeCode.TaggedObject)); - - private sealed record InvalidByteArraySerializedInitializerValue(IToken Token) - : SerializedInitializerValue( - new SimpleSerializationTypeValue(SerializationTypeCode.String)); - - private sealed record ArraySerializedInitializerValue( - SerializationTypeValue Type, - int Length, - SerializedSequenceValue Values) - : SerializedInitializerValue(Type); - - private abstract record SerializedSequenceValue; - - private sealed record RawSerializedSequenceValue(BlobBuilder Value) - : SerializedSequenceValue; - - private sealed record ClassSerializedSequenceValue( - ImmutableArray Values) - : SerializedSequenceValue; - - private sealed record ObjectSerializedSequenceValue( - ImmutableArray Values) - : SerializedSequenceValue; - - private abstract record ClassSequenceElementValue; - - private sealed record StringClassSequenceElementValue(string? Value) - : ClassSequenceElementValue; - - private sealed record TypeClassSequenceElementValue(ClassNameValue ClassName) - : ClassSequenceElementValue; - - private static CustomAttributeDescriptorValue GetCustomAttributeDescriptorValue(object? value) - => value as CustomAttributeDescriptorValue - ?? new( - MethodReferenceValue.Error, - new RawCustomAttributeBlobValue(CreateDefaultCustomAttributeBlob()), - null); - - private static SerializedInitializerValue GetSerializedInitializerValue(object? value) - => value as SerializedInitializerValue - ?? new RawSerializedInitializerValue( - new RawSerializationTypeValue(new BlobBuilder()), - new BlobBuilder()); - - private static SerializationTypeValue GetSerializationTypeValue(object? value) - => value as SerializationTypeValue - ?? new RawSerializationTypeValue(new BlobBuilder()); - - private static SerializedSequenceValue GetSerializedSequenceValue(object? value) - => value switch - { - SerializedSequenceValue sequence => sequence, - BlobBuilder blob => new RawSerializedSequenceValue(blob), - _ => new RawSerializedSequenceValue(new BlobBuilder()) - }; - - private static BlobBuilder CreateDefaultCustomAttributeBlob() - { - BlobBuilder value = new(); - value.WriteUInt16(CustomAttributeBlobFormatVersion); - value.WriteUInt16(0); - return value; - } -} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Data.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Data.cs index ff88d424f5012f..7d56bb23122772 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Data.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Data.cs @@ -11,67 +11,40 @@ namespace ILAssembler; internal sealed partial class GrammarActions { - private readonly Stack _dataDeclarationFrames = new(); - - private sealed class DataDeclarationFrame - { - public DataDeclarationFrame(CILParser.DataDeclContext owner, bool shouldCommit) - { - Owner = owner; - ShouldCommit = shouldCommit; - } - - public CILParser.DataDeclContext Owner { get; } - - public bool ShouldCommit { get; } - - public BlobBuilder Data { get; } = new(); - - public Dictionary>? ReferenceFixups { get; set; } - - public string? Name { get; set; } - - public byte Section { get; set; } - } - - internal void BeginDataDeclaration(CILParser.DataDeclContext context) + internal CILParser.DataDeclarationBuilder CreateDataDeclaration( + CILParser.DataDeclContext context) + => new( + context.Parent is not CILParser.MethodDeclContext || + _currentMethod is not null); + + internal void EndDataDeclaration( + CILParser.DataDeclContext context, + CILParser.DataDeclarationBuilder builder, + int initialSyntaxErrorCount) { - BeginSemanticRoot(context); - _dataDeclarationFrames.Push(new( - context, - context.Parent is not CILParser.MethodDeclContext || _currentMethod is not null)); - } - - internal void EndDataDeclaration(CILParser.DataDeclContext context) - { - bool hasSyntaxError = EndSemanticRoot(context); + bool hasSyntaxError = + HasSyntaxErrorsSince(initialSyntaxErrorCount) || + context.exception is not null; context.HasSyntaxError = hasSyntaxError; - DataDeclarationFrame? frame = TryGetDataDeclarationFrame(context); - if (frame is null) - { - return; - } - - _dataDeclarationFrames.Pop(); - if (hasSyntaxError || !frame.ShouldCommit) + if (hasSyntaxError || !builder.ShouldCommit) { return; } int declarationOffset = _mappedFieldData.Count; - if (frame.Name is not null && !_mappedFieldDataNames.ContainsKey(frame.Name)) + if (builder.Name is not null && !_mappedFieldDataNames.ContainsKey(builder.Name)) { - _mappedFieldDataNames.Add(frame.Name, declarationOffset); + _mappedFieldDataNames.Add(builder.Name, declarationOffset); } - _mappedFieldData.LinkSuffix(frame.Data); - if (frame.ReferenceFixups is null) + _mappedFieldData.LinkSuffix(builder.Data); + if (builder.ReferenceFixups is null) { return; } - foreach ((string target, List declarationFixups) in frame.ReferenceFixups) + foreach ((string target, List declarationFixups) in builder.ReferenceFixups) { if (!_mappedFieldDataReferenceFixups.TryGetValue(target, out List? fixups)) { @@ -82,73 +55,61 @@ internal void EndDataDeclaration(CILParser.DataDeclContext context) } } +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. internal void SetDataDeclarationHeader( - CILParser.DdHeadContext context, + CILParser.DataDeclarationBuilder builder, byte section, IToken name) { - if (TryGetDataDeclarationFrame(context) is { } frame) - { - frame.Section = section; - frame.Name = ParseIdentifier(name); - } + _ = section; + builder.Name = ParseIdentifier(name); } - internal void SetAnonymousDataDeclarationHeader(CILParser.DdHeadContext context, byte section) + internal void SetAnonymousDataDeclarationHeader( + CILParser.DataDeclarationBuilder builder, + byte section) { - if (TryGetDataDeclarationFrame(context) is { } frame) - { - frame.Section = section; - } + _ = builder; + _ = section; } -#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. internal byte GetMappedDataSection() => 0; internal byte GetTlsDataSection() => 1; internal byte GetCilDataSection() => 2; -#pragma warning restore CA1822 - internal int ParseDataItemCount(IToken token) => ParseInt32(token); - internal void AddDataString(CILParser.DdItemContext context, string value) - { - TryGetDataDeclarationFrame(context)?.Data.WriteUTF16(value); - } + internal void AddDataString(CILParser.DataDeclarationBuilder builder, string value) + => builder.Data.WriteUTF16(value); - internal void AddDataReference(CILParser.DdItemContext context, IToken targetToken) + internal void AddDataReference( + CILParser.DataDeclarationBuilder builder, + IToken targetToken) { - if (TryGetDataDeclarationFrame(context) is not { } frame) - { - return; - } - string target = ParseIdentifier(targetToken); Dictionary> fixups = - frame.ReferenceFixups ??= new Dictionary>(); + builder.ReferenceFixups ??= new Dictionary>(); if (!fixups.TryGetValue(target, out List? targetFixups)) { fixups.Add(target, targetFixups = new()); } - targetFixups.Add(frame.Data.ReserveBytes(sizeof(int))); + targetFixups.Add(builder.Data.ReserveBytes(sizeof(int))); } internal void AddDataBytes( - CILParser.DdItemContext context, + CILParser.DataDeclarationBuilder builder, ImmutableArray value) - { - TryGetDataDeclarationFrame(context)?.Data.WriteBytes(value); - } + => builder.Data.WriteBytes(value); internal void AddFloatingPointData( - CILParser.DdItemContext context, + CILParser.DataDeclarationBuilder builder, IToken kind, double value, int count) { - if (count <= 0 || TryGetDataDeclarationFrame(context) is not { } frame) + if (count <= 0) { return; } @@ -158,7 +119,7 @@ internal void AddFloatingPointData( float single = (float)value; for (int i = 0; i < count; i++) { - frame.Data.WriteSingle(single); + builder.Data.WriteSingle(single); } } else @@ -166,19 +127,19 @@ internal void AddFloatingPointData( Debug.Assert(kind.Text == "float64"); for (int i = 0; i < count; i++) { - frame.Data.WriteDouble(value); + builder.Data.WriteDouble(value); } } } internal void AddInt64Data( - CILParser.DdItemContext context, + CILParser.DataDeclarationBuilder builder, IToken kind, IToken value, int count) { Debug.Assert(kind.Text == "int64"); - if (count <= 0 || TryGetDataDeclarationFrame(context) is not { } frame) + if (count <= 0) { return; } @@ -186,17 +147,17 @@ internal void AddInt64Data( long parsedValue = ParseInt64(value); for (int i = 0; i < count; i++) { - frame.Data.WriteInt64(parsedValue); + builder.Data.WriteInt64(parsedValue); } } internal void AddIntegerData( - CILParser.DdItemContext context, + CILParser.DataDeclarationBuilder builder, IToken kind, IToken value, int count) { - if (count <= 0 || TryGetDataDeclarationFrame(context) is not { } frame) + if (count <= 0) { return; } @@ -205,27 +166,30 @@ internal void AddIntegerData( switch (kind.Text) { case "int8": - frame.Data.WriteBytes((byte)parsedValue, count); + builder.Data.WriteBytes((byte)parsedValue, count); break; case "int16": for (int i = 0; i < count; i++) { - frame.Data.WriteInt16((short)parsedValue); + builder.Data.WriteInt16((short)parsedValue); } break; default: Debug.Assert(kind.Text == "int32"); for (int i = 0; i < count; i++) { - frame.Data.WriteInt32(parsedValue); + builder.Data.WriteInt32(parsedValue); } break; } } - internal void AddZeroData(CILParser.DdItemContext context, IToken kind, int count) + internal void AddZeroData( + CILParser.DataDeclarationBuilder builder, + IToken kind, + int count) { - if (count <= 0 || TryGetDataDeclarationFrame(context) is not { } frame) + if (count <= 0) { return; } @@ -238,30 +202,9 @@ internal void AddZeroData(CILParser.DdItemContext context, IToken kind, int coun "int64" or "float64" => sizeof(long), _ => throw new UnreachableException(), }; - frame.Data.WriteBytes(0, checked(elementSize * count)); - } - - private DataDeclarationFrame? TryGetDataDeclarationFrame(ParserRuleContext context) - { - Debug.Assert(_dataDeclarationFrames.Count > 0); - DataDeclarationFrame? frame = - _dataDeclarationFrames.Count == 0 ? null : _dataDeclarationFrames.Peek(); - CILParser.DataDeclContext? owner = FindDataDeclarationOwner(context); - Debug.Assert(frame is null || ReferenceEquals(frame.Owner, owner)); - return frame is not null && ReferenceEquals(frame.Owner, owner) ? frame : null; + builder.Data.WriteBytes(0, checked(elementSize * count)); } +#pragma warning restore CA1822 - private static CILParser.DataDeclContext? FindDataDeclarationOwner(RuleContext context) - { - for (RuleContext? current = context; current is not null; current = current.Parent) - { - if (current is CILParser.DataDeclContext declaration) - { - return declaration; - } - } - - return null; - } } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Debug.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Debug.cs index 6f23cb963248ac..7f86131b9dd8ab 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Debug.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Debug.cs @@ -9,30 +9,20 @@ namespace ILAssembler; internal sealed partial class GrammarActions { - private sealed record SourceDirectiveValue( - bool AutoIncrement, - int StartLine, - int StartColumn, - int EndLine, - int EndColumn, - string? DocumentPath); - - private sealed record LanguageDirectiveValue( - string Language, - string? Vendor, - string? DocumentType); - #pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. internal bool IsAutoIncrementSourceDirective(IToken token) => token.Text == "#line"; #pragma warning restore CA1822 - internal object CreateSourceLine(bool autoIncrement, IToken line, IToken? path) + internal SourceDirectiveValue CreateSourceLine( + bool autoIncrement, + IToken line, + IToken? path) { int lineNumber = ParseInt32(line); return CreateSourceDirective(autoIncrement, lineNumber, 0, lineNumber, 0, path); } - internal object CreateSourceColumn( + internal SourceDirectiveValue CreateSourceColumn( bool autoIncrement, IToken line, IToken column, @@ -49,7 +39,7 @@ internal object CreateSourceColumn( path); } - internal object CreateSourceColumnRange( + internal SourceDirectiveValue CreateSourceColumnRange( bool autoIncrement, IToken line, IToken startColumn, @@ -66,7 +56,7 @@ internal object CreateSourceColumnRange( path); } - internal object CreateSourceLineRange( + internal SourceDirectiveValue CreateSourceLineRange( bool autoIncrement, IToken startLine, IToken endLine, @@ -83,7 +73,7 @@ internal object CreateSourceLineRange( path); } - internal object CreateSourceRange( + internal SourceDirectiveValue CreateSourceRange( bool autoIncrement, IToken startLine, IToken endLine, @@ -113,11 +103,15 @@ private static SourceDirectiveValue CreateSourceDirective( endColumn, path is null ? null : StringHelpers.ParseQuotedString(path.Text)); - internal void EndSourceDirective(CILParser.ExtSourceSpecContext context) + internal void EndSourceDirective( + CILParser.ExtSourceSpecContext context, + int initialSyntaxErrorCount) { - context.HasSyntaxError = EndSemanticRoot(context); + context.HasSyntaxError = + HasSyntaxErrorsSince(initialSyntaxErrorCount) || + context.exception is not null; if (context.HasSyntaxError || - context.Value is not SourceDirectiveValue value || + context.Value is not { } value || !CanApplySharedDirective(context)) { context.Value = null; @@ -179,24 +173,28 @@ private void ApplySourceDirective(SourceDirectiveValue value) internal string ParseLanguageString(IToken token) => StringHelpers.ParseQuotedString(token.Text); - internal object CreateLanguageDirective(string language) + internal LanguageDirectiveValue CreateLanguageDirective(string language) => new LanguageDirectiveValue(language, null, null); - internal object CreateLanguageDirective(string language, string vendor) + internal LanguageDirectiveValue CreateLanguageDirective(string language, string vendor) => new LanguageDirectiveValue(language, vendor, null); - internal object CreateLanguageDirective( + internal LanguageDirectiveValue CreateLanguageDirective( string language, string vendor, string documentType) => new LanguageDirectiveValue(language, vendor, documentType); #pragma warning restore CA1822 - internal void EndLanguageDirective(CILParser.LanguageDeclContext context) + internal void EndLanguageDirective( + CILParser.LanguageDeclContext context, + int initialSyntaxErrorCount) { - context.HasSyntaxError = EndSemanticRoot(context); + context.HasSyntaxError = + HasSyntaxErrorsSince(initialSyntaxErrorCount) || + context.exception is not null; if (context.HasSyntaxError || - context.Value is not LanguageDirectiveValue value || + context.Value is not { } value || !CanApplySharedDirective(context)) { context.Value = null; diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.Actions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.Actions.cs index b811478b7fcf4d..6759a7fa40ce42 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.Actions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Declarations.Actions.cs @@ -164,8 +164,8 @@ internal void ProcessTopLevelTypedef(CILParser.TypedefDeclContext context) internal void BeginTopLevelTypeList() => PrepareTopLevelDeclaration(); - internal void ProcessTopLevelTypeListEntry(object? value) - => _ = ResolveClassName(GetClassNameValue(value)); + internal void ProcessTopLevelTypeListEntry(ClassNameValue value) + => _ = ResolveClassName(value); private void PrepareTopLevelDeclaration() => ClearPendingCustomAttributeOwners(); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.References.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.References.cs index 63e656931079bd..5bda6c6db7710b 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.References.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.References.cs @@ -79,7 +79,7 @@ internal void EmitCalliInstruction(IToken opcodeToken, CILParser.CalliSignatureC instruction.Method.Definition.MethodBody.OpCode(instruction.OpCode); instruction.Method.Definition.MethodBody.Token( _entityRegistry.GetOrCreateStandaloneSignature( - MaterializeCalliSignature(GetCalliSignatureValue(context.Value))).Handle); + MaterializeCalliSignature(context.Value)).Handle); } internal void EmitOwnerTokenInstruction(IToken opcodeToken, CILParser.OwnerTypeContext context) diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs index 7ee5a57b3378ab..1d2d368a92034c 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Instructions.cs @@ -15,23 +15,6 @@ namespace ILAssembler; internal sealed partial class GrammarActions { - private sealed class SwitchInstructionAccumulator - { - internal SwitchInstructionAccumulator(CILParser.SimpleInstrContext owner, IToken opcodeToken) - { - Owner = owner; - OpcodeToken = opcodeToken; - } - - internal CILParser.SimpleInstrContext Owner { get; } - - internal IToken OpcodeToken { get; } - - internal List<(IToken Token, bool IsOffset)> Operands { get; } = new(); - } - - private SwitchInstructionAccumulator? _switchInstructionAccumulator; - internal void EmitNoOperandInstruction(IToken opcodeToken) { if (StartInstruction(opcodeToken) is not { } instruction) @@ -307,31 +290,29 @@ internal void DefineLabel(IToken nameToken) method.Definition.MethodBody.MarkLabel(label); } - internal void BeginSwitchInstruction(CILParser.SimpleInstrContext context, IToken opcodeToken) - { - Debug.Assert(_switchInstructionAccumulator is null); - _switchInstructionAccumulator = new SwitchInstructionAccumulator(context, opcodeToken); - } +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. + internal CILParser.SwitchInstructionBuilder CreateSwitchInstruction(IToken opcodeToken) + => new(opcodeToken); - internal void AddSwitchLabel(IToken labelToken) - => _switchInstructionAccumulator?.Operands.Add((labelToken, false)); + internal void AddSwitchLabel(CILParser.SwitchInstructionBuilder builder, IToken labelToken) + => builder.Operands.Add((labelToken, false)); - internal void AddSwitchOffset(IToken offsetToken) - => _switchInstructionAccumulator?.Operands.Add((offsetToken, true)); + internal void AddSwitchOffset(CILParser.SwitchInstructionBuilder builder, IToken offsetToken) + => builder.Operands.Add((offsetToken, true)); +#pragma warning restore CA1822 - internal void CompleteSimpleInstruction(CILParser.SimpleInstrContext context) + internal void CompleteSwitchInstruction(CILParser.SwitchInstructionBuilder? builder) { - if (_switchInstructionAccumulator is not { } accumulator || - !ReferenceEquals(accumulator.Owner, context) || - StartInstruction(accumulator.OpcodeToken) is not { } instruction) + if (builder is null || + StartInstruction(builder.OpcodeToken) is not { } instruction) { return; } Debug.Assert(instruction.OpCode == ILOpCode.Switch); CurrentMethodContext method = instruction.Method; - List<(LabelHandle Label, int? Offset)> labels = new(accumulator.Operands.Count); - foreach ((IToken token, bool isOffset) in accumulator.Operands) + List<(LabelHandle Label, int? Offset)> labels = new(builder.Operands.Count); + foreach ((IToken token, bool isOffset) in builder.Operands) { if (isOffset) { @@ -344,7 +325,7 @@ internal void CompleteSimpleInstruction(CILParser.SimpleInstrContext context) { label = method.Definition.MethodBody.DefineLabel(); method.Labels[labelName] = label; - method.UndefinedLabelReferences.TryAdd(labelName, accumulator.OpcodeToken); + method.UndefinedLabelReferences.TryAdd(labelName, builder.OpcodeToken); } labels.Add((label, null)); @@ -373,14 +354,6 @@ internal void CompleteSimpleInstruction(CILParser.SimpleInstrContext context) } } - internal void EndSwitchInstruction(CILParser.SimpleInstrContext context) - { - if (ReferenceEquals(_switchInstructionAccumulator?.Owner, context)) - { - _switchInstructionAccumulator = null; - } - } - private (CurrentMethodContext Method, ILOpCode OpCode)? StartInstruction(IToken opcodeToken) { if (_currentMethod is not { } method) diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs index 5283815755a5d5..e6e2ad26cfd172 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Literals.cs @@ -24,91 +24,28 @@ namespace ILAssembler #pragma warning disable CA1822 // Mark members as static internal sealed partial class GrammarActions { - private CILParser.CompQstringContext? _composedStringOwner; - private StringBuilder? _composedStringAccumulator; - private readonly Stack _dottedNameFrames = new(); + internal void AddComposedStringPart(StringBuilder builder, IToken token) + => builder.Append(StringHelpers.ParseQuotedString(token.Text)); - private sealed class DottedNameFrame - { - public DottedNameFrame(CILParser.DottedNameContext owner) - { - Owner = owner; - } - - public CILParser.DottedNameContext Owner { get; } - - public string? FirstPart { get; set; } - - public StringBuilder? Builder { get; set; } - } - - internal void BeginComposedString(CILParser.CompQstringContext context) - { - Debug.Assert(_composedStringOwner is null); - Debug.Assert(_composedStringAccumulator is null); - _composedStringOwner = context; - _composedStringAccumulator = new StringBuilder(); - } - - internal void AddComposedStringPart(CILParser.CompQstringContext context, IToken token) - { - if (ReferenceEquals(_composedStringOwner, context) && - _composedStringAccumulator is { } accumulator) - { - accumulator.Append(StringHelpers.ParseQuotedString(token.Text)); - } - } + internal string EndComposedString(StringBuilder builder) + => builder.ToString(); - internal string EndComposedString(CILParser.CompQstringContext context) + internal void AddDottedNamePart(CILParser.DottedNameBuilder builder, string value) { - if (!ReferenceEquals(_composedStringOwner, context)) + if (builder.HasPart) { - return string.Empty; + builder.Value.Append('.'); } - string value = _composedStringAccumulator?.ToString() ?? string.Empty; - _composedStringOwner = null; - _composedStringAccumulator = null; - - return value; - } - - internal void BeginDottedName(CILParser.DottedNameContext context) - => _dottedNameFrames.Push(new(context)); - - internal void AddDottedNamePart(CILParser.DottedNameContext context, string value) - { - Debug.Assert(_dottedNameFrames.Count > 0); - DottedNameFrame frame = _dottedNameFrames.Peek(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - if (!ReferenceEquals(frame.Owner, context)) - { - return; - } - - if (frame.FirstPart is null) - { - frame.FirstPart = value; - return; - } - - frame.Builder ??= new StringBuilder(frame.FirstPart); - frame.Builder.Append('.'); - frame.Builder.Append(value); + builder.Value.Append(value); + builder.HasPart = true; } - internal void AddDottedNameToken(CILParser.DottedNameContext context, IToken token) - => AddDottedNamePart(context, ParseIdentifier(token)); + internal void AddDottedNameToken(CILParser.DottedNameBuilder builder, IToken token) + => AddDottedNamePart(builder, ParseIdentifier(token)); - internal string EndDottedName(CILParser.DottedNameContext context) - { - Debug.Assert(_dottedNameFrames.Count > 0); - DottedNameFrame frame = _dottedNameFrames.Pop(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - return ReferenceEquals(frame.Owner, context) - ? frame.Builder?.ToString() ?? frame.FirstPart ?? string.Empty - : string.Empty; - } + internal string EndDottedName(CILParser.DottedNameBuilder builder) + => builder.Value.ToString(); internal string ParseDottedNamePart(IToken token) => token.Text.Length >= 2 && token.Text[0] == '\'' diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Assembly.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Assembly.cs index 147c038276675d..ddd730e2e7014b 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Assembly.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Assembly.cs @@ -2,7 +2,6 @@ // The .NET Foundation licenses this file to you under the MIT license. using System; -using System.Collections.Generic; using System.Collections.Immutable; using System.Diagnostics; using System.IO; @@ -17,9 +16,6 @@ namespace ILAssembler; #pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. internal sealed partial class GrammarActions { - private readonly Stack> - _assemblyDeclarationFrames = new(); - internal void SetAssemblyAttribute(CILParser.AsmAttrAnyContext context) { (AssemblyFlags value, AssemblyFlags mask) = context.Start.Text switch @@ -45,33 +41,25 @@ internal AssemblyFlags AddAssemblyAttribute( AssemblyFlags mask) => mask == 0 ? attributes | value : (attributes & ~mask) | value; - internal void BeginAssemblyDeclarations(CILParser.AssemblyDeclsContext context) - => _assemblyDeclarationFrames.Push(new(context)); - - internal void AddAssemblyDeclaration( - CILParser.AssemblyDeclsContext context, - object? value) - => AddManifestValue(_assemblyDeclarationFrames, context, value); - - internal object EndAssemblyDeclarations(CILParser.AssemblyDeclsContext context) - => EndManifestValues(_assemblyDeclarationFrames, context); - - internal object CreateAssemblyDefinition( + internal AssemblyDefinitionValue CreateAssemblyDefinition( AssemblyFlags attributes, string name, - object? declarations) - => new AssemblyDefinitionValue(attributes, name, GetManifestValues(declarations)); + ImmutableArray declarations) + => new(attributes, name, declarations); - internal object CreateAssemblyHashAlgorithmDeclaration(IToken value) + internal AssemblyDeclarationValue CreateAssemblyHashAlgorithmDeclaration(IToken value) => new AssemblyHashAlgorithmDirectiveValue((AssemblyHashAlgorithm)ParseInt32(value)); - internal object CreateAssemblySecurityDeclaration(object? value, IToken location) + internal AssemblyDeclarationValue CreateAssemblySecurityDeclaration( + SecurityDeclarationValue? value, + IToken location) => new AssemblySecurityDirectiveValue(value, location); - internal object CreateAssemblyPublicKeyDeclaration(ImmutableArray value) + internal AssemblyDeclarationValue CreateAssemblyPublicKeyDeclaration( + ImmutableArray value) => new AssemblyPublicKeyDirectiveValue(value); - internal object CreateAssemblyVersionDeclaration( + internal AssemblyDeclarationValue CreateAssemblyVersionDeclaration( int? major, int? minor, int? build, @@ -82,13 +70,16 @@ internal object CreateAssemblyVersionDeclaration( build ?? 0, revision ?? 0)); - internal object CreateAssemblyLocaleDeclaration(string value) + internal AssemblyDeclarationValue CreateAssemblyLocaleDeclaration(string value) => new AssemblyLocaleDirectiveValue(value); - internal object CreateAssemblyLocaleDeclaration(ImmutableArray value) + internal AssemblyDeclarationValue CreateAssemblyLocaleDeclaration( + ImmutableArray value) => new AssemblyLocaleDirectiveValue(Encoding.Unicode.GetString(value.AsSpan())); - internal object CreateAssemblyCustomAttributeDeclaration(object? value, IToken location) + internal AssemblyDeclarationValue CreateAssemblyCustomAttributeDeclaration( + CustomAttributeDeclarationValue? value, + IToken location) => new AssemblyCustomAttributeDirectiveValue(value, location); private static AssemblyFlags GetFlagForArch(ProcessorArchitecture architecture) @@ -110,7 +101,7 @@ private void MaterializeAssemblyDefinition(AssemblyDefinitionValue definition) (assembly.ProcessorArchitecture, assembly.Flags) = GetArchAndFlags(definition.Attributes); - foreach (object declaration in definition.Declarations) + foreach (AssemblyDeclarationValue declaration in definition.Declarations) { switch (declaration) { @@ -118,7 +109,7 @@ private void MaterializeAssemblyDefinition(AssemblyDefinitionValue definition) assembly.HashAlgorithm = hashAlgorithm.Value; break; case AssemblySecurityDirectiveValue security: - if (security.Value is SecurityDeclarationValue securityValue && + if (security.Value is { } securityValue && MaterializeSecurityDeclaration(securityValue, security.Location) is { } entity) { entity.Parent = assembly; @@ -138,7 +129,7 @@ private void MaterializeAssemblyDefinition(AssemblyDefinitionValue definition) private void ApplyAssemblyOrReferenceDirective( EntityRegistry.AssemblyOrRefEntity target, - object declaration) + AssemblyDeclarationValue declaration) { switch (declaration) { diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.ExportedTypes.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.ExportedTypes.cs index ab04de46dcb461..16e78893c63015 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.ExportedTypes.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.ExportedTypes.cs @@ -13,9 +13,6 @@ namespace ILAssembler; #pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. internal sealed partial class GrammarActions { - private readonly Stack> - _exportedTypeDeclarationFrames = new(); - internal void SetExportedTypeAttribute(CILParser.ExptAttrContext context) { string attribute = context.Start.Text == "nested" @@ -44,57 +41,57 @@ internal TypeAttributes AddExportedTypeAttribute( TypeAttributes mask) => mask == 0 ? attributes | value : (attributes & ~mask) | value; - internal object CreateExportedTypeHeader( + internal ExportedTypeHeaderValue CreateExportedTypeHeader( TypeAttributes attributes, string name, IToken location) - => new ExportedTypeHeaderValue(attributes, name, location); - - internal void BeginExportedTypeDeclarations(CILParser.ExptypeDeclsContext context) - => _exportedTypeDeclarationFrames.Push(new(context)); - - internal void AddExportedTypeDeclaration( - CILParser.ExptypeDeclsContext context, - object? value) - => AddManifestValue(_exportedTypeDeclarationFrames, context, value); + => new ExportedTypeHeaderValue(true, attributes, name, location); - internal object EndExportedTypeDeclarations(CILParser.ExptypeDeclsContext context) - => EndManifestValues(_exportedTypeDeclarationFrames, context); - - internal object CreateExportedType( - object? header, - object? declarations, - IToken location) + internal ExportedTypeValue CreateExportedType( + ExportedTypeHeaderValue header, + ImmutableArray declarations) => new ExportedTypeValue( - GetExportedTypeHeader(header, location), - GetManifestValues(declarations)); + header, + declarations); - internal object CreateExportedTypeFileDeclaration(string name, IToken location) + internal ExportedTypeDeclarationValue CreateExportedTypeFileDeclaration( + string name, + IToken location) => new ExportedTypeFileDirectiveValue(name, location); - internal object CreateNestedExportedTypeDeclaration(object? name, IToken location) - => new NestedExportedTypeDirectiveValue(GetTypeNameValue(name), location); + internal ExportedTypeDeclarationValue CreateNestedExportedTypeDeclaration( + TypeName name, + IToken location) + => new NestedExportedTypeDirectiveValue(name, location); - internal object CreateExportedTypeAssemblyDeclaration(string name, IToken location) + internal ExportedTypeDeclarationValue CreateExportedTypeAssemblyDeclaration( + string name, + IToken location) => new ExportedTypeAssemblyDirectiveValue(name, location); - internal object CreateExportedTypeMetadataTokenDeclaration(int token, IToken location) + internal ExportedTypeDeclarationValue CreateExportedTypeMetadataTokenDeclaration( + int token, + IToken location) => new ExportedTypeMetadataTokenDirectiveValue(token, location); - internal object CreateExportedTypeDefinitionIdDeclaration(IToken value) + internal ExportedTypeDeclarationValue CreateExportedTypeDefinitionIdDeclaration( + IToken value) => new ExportedTypeDefinitionIdDirectiveValue(ParseInt32(value)); - internal object CreateExportedTypeCustomAttributeDeclaration(object? value, IToken location) - => new ExportedTypeCustomAttributeDirectiveValue(value, location); - - private static ExportedTypeHeaderValue GetExportedTypeHeader( - object? value, + internal ExportedTypeDeclarationValue CreateExportedTypeCustomAttributeDeclaration( + CustomAttributeDeclarationValue? value, IToken location) - => value as ExportedTypeHeaderValue ?? new(0, string.Empty, location); + => new ExportedTypeCustomAttributeDirectiveValue(value, location); private void MaterializeExportedType(ExportedTypeValue value) { ExportedTypeHeaderValue header = value.Header; + if (!header.IsValid || + header.Location is not IToken location) + { + return; + } + (string typeNamespace, string name) = NameHelpers.SplitDottedNameToNamespaceAndName(header.Name); ( @@ -110,7 +107,7 @@ private void MaterializeExportedType(ExportedTypeValue value) string.Format( DiagnosticMessageTemplates.MissingExportedTypeImplementation, header.Name), - header.Location); + location); return; } @@ -134,14 +131,15 @@ private void MaterializeExportedType(ExportedTypeValue value) EntityRegistry.EntityBase? Implementation, int TypeDefinitionId, ImmutableArray CustomAttributes - ) MaterializeExportedTypeDeclarations(ImmutableArray declarations) + ) MaterializeExportedTypeDeclarations( + ImmutableArray declarations) { EntityRegistry.EntityBase? implementation = null; int typeDefinitionId = 0; ImmutableArray.Builder customAttributes = ImmutableArray.CreateBuilder(); - foreach (object declaration in declarations) + foreach (ExportedTypeDeclarationValue declaration in declarations) { switch (declaration) { diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Files.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Files.cs index 5bd94c2683e981..f2bc370670b12a 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Files.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Files.cs @@ -1,7 +1,6 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System.Collections.Generic; using System.Collections.Immutable; using System.Diagnostics; using System.Reflection.Metadata; @@ -12,32 +11,6 @@ namespace ILAssembler; #pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. internal sealed partial class GrammarActions { - private readonly Stack _fileDeclarationFrames = new(); - - private sealed class FileDeclarationFrame - { - public FileDeclarationFrame(CILParser.FileDeclContext owner) - { - Owner = owner; - } - - public CILParser.FileDeclContext Owner { get; } - - public string Name { get; set; } = string.Empty; - - public bool HasMetadata { get; set; } = true; - - public bool IsEntryPoint { get; set; } - - public ImmutableArray? Hash { get; set; } - } - - internal void BeginFileDeclaration(CILParser.FileDeclContext context) - { - BeginSemanticRoot(context); - _fileDeclarationFrames.Push(new(context)); - } - internal bool ParseFileAttribute(IToken token) { Debug.Assert(token.Text == "nometadata"); @@ -50,65 +23,39 @@ internal bool ParseFileEntry(IToken token) return true; } - internal void AddFileAttribute(CILParser.FileDeclContext context, bool hasMetadata) - { - if (TryGetFileDeclarationFrame(context) is { } frame) - { - frame.HasMetadata &= hasMetadata; - } - } + internal void AddFileAttribute( + CILParser.FileDeclarationBuilder builder, + bool hasMetadata) + => builder.HasMetadata &= hasMetadata; - internal void SetFileName(CILParser.FileDeclContext context, string name) - { - if (TryGetFileDeclarationFrame(context) is { } frame) - { - frame.Name = name; - } - } + internal void SetFileName(CILParser.FileDeclarationBuilder builder, string name) + => builder.Name = name; - internal void AddFileEntry(CILParser.FileDeclContext context, bool isEntryPoint) - { - if (TryGetFileDeclarationFrame(context) is { } frame) - { - frame.IsEntryPoint |= isEntryPoint; - } - } + internal void AddFileEntry( + CILParser.FileDeclarationBuilder builder, + bool isEntryPoint) + => builder.IsEntryPoint |= isEntryPoint; - internal void SetFileHash(CILParser.FileDeclContext context, ImmutableArray hash) - { - if (TryGetFileDeclarationFrame(context) is { } frame) - { - frame.Hash = hash; - } - } + internal void SetFileHash( + CILParser.FileDeclarationBuilder builder, + ImmutableArray hash) + => builder.Hash = hash; - internal void EndFileDeclaration(CILParser.FileDeclContext context) + internal void EndFileDeclaration( + CILParser.FileDeclContext context, + CILParser.FileDeclarationBuilder builder, + int initialSyntaxErrorCount) { - context.HasSyntaxError = EndSemanticRoot(context); - FileDeclarationFrame? frame = TryGetFileDeclarationFrame(context); - if (frame is null) - { - context.Value = null; - return; - } - - _fileDeclarationFrames.Pop(); + context.HasSyntaxError = + HasSyntaxErrorsSince(initialSyntaxErrorCount) || + context.exception is not null; context.Value = context.HasSyntaxError ? null : new FileDeclarationValue( - frame.Name, - frame.HasMetadata, - frame.IsEntryPoint, - frame.Hash); - } - - private FileDeclarationFrame? TryGetFileDeclarationFrame(CILParser.FileDeclContext context) - { - Debug.Assert(_fileDeclarationFrames.Count > 0); - FileDeclarationFrame? frame = - _fileDeclarationFrames.Count == 0 ? null : _fileDeclarationFrames.Peek(); - Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); - return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; + builder.Name, + builder.HasMetadata, + builder.IsEntryPoint, + builder.Hash); } private EntityRegistry.FileEntity MaterializeFileDeclaration(FileDeclarationValue declaration) @@ -127,9 +74,9 @@ private EntityRegistry.FileEntity MaterializeFileDeclaration(FileDeclarationValu internal EntityRegistry.FileEntity MaterializeFileDeclaration( CILParser.FileDeclContext context) { - Debug.Assert(context.Value is FileDeclarationValue); - FileDeclarationValue declaration = context.Value as FileDeclarationValue - ?? new(string.Empty, HasMetadata: true, IsEntryPoint: false, Hash: null); + Debug.Assert(context.Value is not null); + FileDeclarationValue declaration = + context.Value ?? new(string.Empty, HasMetadata: true, IsEntryPoint: false, Hash: null); return MaterializeFileDeclaration(declaration); } } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.References.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.References.cs index b9837e7a3efc85..3e9ecb258284ef 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.References.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.References.cs @@ -1,7 +1,6 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System.Collections.Generic; using System.Collections.Immutable; using System.Reflection; @@ -10,38 +9,28 @@ namespace ILAssembler; #pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. internal sealed partial class GrammarActions { - private readonly Stack> - _assemblyReferenceDeclarationFrames = new(); - - internal object CreateAssemblyReferenceHeader( + internal AssemblyReferenceHeaderValue CreateAssemblyReferenceHeader( AssemblyFlags attributes, string name, string alias) - => new AssemblyReferenceHeaderValue(attributes, name, alias); - - internal void BeginAssemblyReferenceDeclarations(CILParser.AssemblyRefDeclsContext context) - => _assemblyReferenceDeclarationFrames.Push(new(context)); - - internal void AddAssemblyReferenceDeclaration( - CILParser.AssemblyRefDeclsContext context, - object? value) - => AddManifestValue(_assemblyReferenceDeclarationFrames, context, value); - - internal object EndAssemblyReferenceDeclarations(CILParser.AssemblyRefDeclsContext context) - => EndManifestValues(_assemblyReferenceDeclarationFrames, context); + => new AssemblyReferenceHeaderValue(true, attributes, name, alias); - internal object CreateAssemblyReference(object? header, object? declarations) + internal AssemblyReferenceValue CreateAssemblyReference( + AssemblyReferenceHeaderValue header, + ImmutableArray declarations) => new AssemblyReferenceValue( - GetAssemblyReferenceHeader(header), - GetManifestValues(declarations)); + header, + declarations); - internal object CreateAssemblyReferenceHashDeclaration(ImmutableArray value) + internal AssemblyDeclarationValue CreateAssemblyReferenceHashDeclaration( + ImmutableArray value) => new AssemblyReferenceHashDirectiveValue(value); - internal object CreateAssemblyReferencePublicKeyTokenDeclaration(ImmutableArray value) + internal AssemblyDeclarationValue CreateAssemblyReferencePublicKeyTokenDeclaration( + ImmutableArray value) => new AssemblyReferencePublicKeyTokenDirectiveValue(value); - internal object? CreateAssemblyReferenceAutoDeclaration() => null; + internal AssemblyDeclarationValue? CreateAssemblyReferenceAutoDeclaration() => null; private EntityRegistry.AssemblyReferenceEntity MaterializeAssemblyReferenceHeader( AssemblyReferenceHeaderValue header) @@ -60,9 +49,14 @@ private EntityRegistry.AssemblyReferenceEntity MaterializeAssemblyReferenceHeade private void MaterializeAssemblyReference(AssemblyReferenceValue reference) { + if (!reference.Header.IsValid) + { + return; + } + EntityRegistry.AssemblyReferenceEntity entity = MaterializeAssemblyReferenceHeader(reference.Header); - foreach (object declaration in reference.Declarations) + foreach (AssemblyDeclarationValue declaration in reference.Declarations) { switch (declaration) { @@ -80,9 +74,6 @@ private void MaterializeAssemblyReference(AssemblyReferenceValue reference) } } - private static AssemblyReferenceHeaderValue GetAssemblyReferenceHeader(object? value) - => value as AssemblyReferenceHeaderValue ?? new(0, string.Empty, string.Empty); - internal void MaterializeAssemblyReference(CILParser.AssemblyRefBlockContext context) { if (context.Value is AssemblyReferenceValue reference) diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Resources.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Resources.cs index 4be34cc77c21ca..b4b87d6503c6c6 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Resources.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Resources.cs @@ -1,7 +1,6 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System.Collections.Generic; using System.Collections.Immutable; using System.Diagnostics; using System.Reflection; @@ -12,9 +11,6 @@ namespace ILAssembler; #pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. internal sealed partial class GrammarActions { - private readonly Stack> - _manifestResourceDeclarationFrames = new(); - internal ManifestResourceAttributes AddManifestResourceAttribute( ManifestResourceAttributes attributes, ManifestResourceAttributes value) @@ -28,54 +24,44 @@ internal ManifestResourceAttributes ParseManifestResourceAttribute(IToken token) _ => throw new UnreachableException() }; - internal object CreateManifestResourceHeader( + internal ManifestResourceHeaderValue CreateManifestResourceHeader( ManifestResourceAttributes attributes, string name, string alias, IToken location) - => new ManifestResourceHeaderValue(attributes, name, alias, location); - - internal void BeginManifestResourceDeclarations(CILParser.ManifestResDeclsContext context) - => _manifestResourceDeclarationFrames.Push(new(context)); - - internal void AddManifestResourceDeclaration( - CILParser.ManifestResDeclsContext context, - object? value) - => AddManifestValue(_manifestResourceDeclarationFrames, context, value); + => new ManifestResourceHeaderValue(true, attributes, name, alias, location); - internal object EndManifestResourceDeclarations(CILParser.ManifestResDeclsContext context) - => EndManifestValues(_manifestResourceDeclarationFrames, context); - - internal object CreateManifestResource( - object? header, - object? declarations, - IToken location) + internal ManifestResourceValue CreateManifestResource( + ManifestResourceHeaderValue header, + ImmutableArray declarations) => new ManifestResourceValue( - GetManifestResourceHeader(header, location), - GetManifestValues(declarations)); + header, + declarations); - internal object CreateManifestResourceFileDeclaration( + internal ManifestResourceDeclarationValue CreateManifestResourceFileDeclaration( string name, IToken offset, IToken location) => new ManifestResourceFileDirectiveValue(name, (uint)ParseInt32(offset), location); - internal object CreateManifestResourceAssemblyDeclaration(string name) + internal ManifestResourceDeclarationValue CreateManifestResourceAssemblyDeclaration( + string name) => new ManifestResourceAssemblyDirectiveValue(name); - internal object CreateManifestResourceCustomAttributeDeclaration( - object? value, + internal ManifestResourceDeclarationValue CreateManifestResourceCustomAttributeDeclaration( + CustomAttributeDeclarationValue? value, IToken location) => new ManifestResourceCustomAttributeDirectiveValue(value, location); - private static ManifestResourceHeaderValue GetManifestResourceHeader( - object? value, - IToken location) - => value as ManifestResourceHeaderValue - ?? new(0, string.Empty, string.Empty, location); - private void MaterializeManifestResource(ManifestResourceValue value) { + ManifestResourceHeaderValue header = value.Header; + if (!header.IsValid || + header.Location is not IToken location) + { + return; + } + ( EntityRegistry.EntityBase? implementation, uint offset, @@ -85,15 +71,15 @@ private void MaterializeManifestResource(ManifestResourceValue value) if (implementation is null) { offset = (uint)_manifestResources.Count; - byte[] resourceData = _resourceLocator(value.Header.Alias); + byte[] resourceData = _resourceLocator(header.Alias); if (resourceData is null) { ReportError( DiagnosticIds.FileNotFound, string.Format( DiagnosticMessageTemplates.FileNotFound, - value.Header.Alias), - value.Header.Location); + header.Alias), + location); } else { @@ -103,8 +89,8 @@ private void MaterializeManifestResource(ManifestResourceValue value) } EntityRegistry.ManifestResourceEntity resource = - _entityRegistry.CreateManifestResource(value.Header.Name, offset); - resource.Attributes = value.Header.Attributes; + _entityRegistry.CreateManifestResource(header.Name, offset); + resource.Attributes = header.Attributes; resource.Implementation = implementation; foreach (EntityRegistry.CustomAttributeEntity customAttribute in customAttributes) { @@ -116,14 +102,15 @@ private void MaterializeManifestResource(ManifestResourceValue value) EntityRegistry.EntityBase? Implementation, uint Offset, ImmutableArray CustomAttributes - ) MaterializeManifestResourceDeclarations(ImmutableArray declarations) + ) MaterializeManifestResourceDeclarations( + ImmutableArray declarations) { EntityRegistry.EntityBase? implementation = null; uint offset = 0; ImmutableArray.Builder customAttributes = ImmutableArray.CreateBuilder(); - foreach (object declaration in declarations) + foreach (ManifestResourceDeclarationValue declaration in declarations) { switch (declaration) { diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Typedefs.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Typedefs.cs index 48ec355bd32d92..1aa54aee176ba9 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Typedefs.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Typedefs.cs @@ -12,21 +12,27 @@ internal sealed partial class GrammarActions { private readonly Dictionary _typedefs = new(); - internal object CreateTypeSignatureTypedef(object? type, string alias) - => new TypeSignatureTypedefDeclarationValue(GetTypeValue(type), alias); + internal TypedefDeclarationValue CreateTypeSignatureTypedef( + TypeValue type, + string alias) + => new TypeSignatureTypedefDeclarationValue(type, alias); - internal object CreateClassTypedef(object? type, string alias) - => new ClassTypedefDeclarationValue(GetClassNameValue(type), alias); + internal TypedefDeclarationValue CreateClassTypedef( + ClassNameValue type, + string alias) + => new ClassTypedefDeclarationValue(type, alias); - internal object CreateMemberTypedef(object? member, string alias) - => new MemberTypedefDeclarationValue(GetMemberReferenceValue(member), alias); + internal TypedefDeclarationValue CreateMemberTypedef( + MemberReferenceValue member, + string alias) + => new MemberTypedefDeclarationValue(member, alias); - internal object CreateCustomAttributeTypedefDeclaration( - object? attribute, + internal TypedefDeclarationValue CreateCustomAttributeTypedefDeclaration( + CustomAttributeDescriptorValue attribute, IToken location, string alias) => new CustomAttributeTypedefDeclarationValue( - GetCustomAttributeDescriptorValue(attribute), + attribute, location, alias); diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.VTable.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.VTable.cs index dbc49614eb5dac..8a4f00dba47e65 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.VTable.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.VTable.cs @@ -38,10 +38,14 @@ internal ushort CompleteVTableFixupAttributes(ushort attributes) : attributes; } - internal object CreateVTableFixup(IToken slotCount, ushort flags, IToken dataLabel) + internal VTableFixupValue CreateVTableFixup( + IToken slotCount, + ushort flags, + IToken dataLabel) => new VTableFixupValue(ParseInt32(slotCount), flags, ParseIdentifier(dataLabel)); - internal object CreateRawVTable(ImmutableArray value) => new RawVTableValue(value); + internal RawVTableValue CreateRawVTable(ImmutableArray value) + => new(value); internal void MaterializeVTable(CILParser.VtableDeclContext context) => throw new NotImplementedException( diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Values.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Values.cs deleted file mode 100644 index eb992859a3517c..00000000000000 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Manifest.Values.cs +++ /dev/null @@ -1,179 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System; -using System.Collections.Generic; -using System.Collections.Immutable; -using System.Diagnostics; -using System.Reflection; -using Antlr4.Runtime; - -namespace ILAssembler; - -internal sealed partial class GrammarActions -{ - private sealed class ManifestValueListFrame - where TContext : ParserRuleContext - { - public ManifestValueListFrame(TContext owner) - { - Owner = owner; - } - - public TContext Owner { get; } - - public ImmutableArray.Builder? Values { get; set; } - } - - private sealed record AssemblyDefinitionValue( - AssemblyFlags Attributes, - string Name, - ImmutableArray Declarations); - - private sealed record AssemblyReferenceValue( - AssemblyReferenceHeaderValue Header, - ImmutableArray Declarations); - - private sealed record AssemblyReferenceHeaderValue( - AssemblyFlags Attributes, - string Name, - string Alias); - - private sealed record AssemblyPublicKeyDirectiveValue(ImmutableArray Value); - - private sealed record AssemblyVersionDirectiveValue(Version Value); - - private sealed record AssemblyLocaleDirectiveValue(string Value); - - private sealed record AssemblyCustomAttributeDirectiveValue(object? Value, IToken Location); - - private sealed record AssemblyHashAlgorithmDirectiveValue(AssemblyHashAlgorithm Value); - - private sealed record AssemblySecurityDirectiveValue(object? Value, IToken Location); - - private sealed record AssemblyReferenceHashDirectiveValue(ImmutableArray Value); - - private sealed record AssemblyReferencePublicKeyTokenDirectiveValue(ImmutableArray Value); - - private sealed record FileDeclarationValue( - string Name, - bool HasMetadata, - bool IsEntryPoint, - ImmutableArray? Hash); - - private sealed record ExportedTypeValue( - ExportedTypeHeaderValue Header, - ImmutableArray Declarations); - - private sealed record ExportedTypeHeaderValue( - TypeAttributes Attributes, - string Name, - IToken Location); - - private sealed record ExportedTypeFileDirectiveValue(string Name, IToken Location); - - private sealed record NestedExportedTypeDirectiveValue(TypeName Name, IToken Location); - - private sealed record ExportedTypeAssemblyDirectiveValue(string Name, IToken Location); - - private sealed record ExportedTypeMetadataTokenDirectiveValue(int Token, IToken Location); - - private sealed record ExportedTypeDefinitionIdDirectiveValue(int Value); - - private sealed record ExportedTypeCustomAttributeDirectiveValue(object? Value, IToken Location); - - private sealed record ManifestResourceValue( - ManifestResourceHeaderValue Header, - ImmutableArray Declarations); - - private sealed record ManifestResourceHeaderValue( - ManifestResourceAttributes Attributes, - string Name, - string Alias, - IToken Location); - - private sealed record ManifestResourceFileDirectiveValue( - string Name, - uint Offset, - IToken Location); - - private sealed record ManifestResourceAssemblyDirectiveValue(string Name); - - private sealed record ManifestResourceCustomAttributeDirectiveValue( - object? Value, - IToken Location); - - private sealed record RawVTableValue(ImmutableArray Value); - - private sealed record VTableFixupValue(int SlotCount, ushort Flags, string DataLabel); - - private abstract record TypedefDeclarationValue(string Alias); - - private sealed record TypeSignatureTypedefDeclarationValue(TypeValue Type, string Alias) - : TypedefDeclarationValue(Alias); - - private sealed record ClassTypedefDeclarationValue(ClassNameValue Type, string Alias) - : TypedefDeclarationValue(Alias); - - private sealed record MemberTypedefDeclarationValue(MemberReferenceValue Member, string Alias) - : TypedefDeclarationValue(Alias); - - private sealed record CustomAttributeTypedefDeclarationValue( - CustomAttributeDescriptorValue Attribute, - IToken Location, - string Alias) - : TypedefDeclarationValue(Alias); - - private abstract record TypedefEntry - { - public sealed record Type(EntityRegistry.TypeEntity Entity) : TypedefEntry; - - public sealed record TypeBlob(System.Reflection.Metadata.BlobBuilder Blob) : TypedefEntry; - - public sealed record Member(EntityRegistry.EntityBase Entity) : TypedefEntry; - - public sealed record CustomAttribute( - EntityRegistry.EntityBase Constructor, - System.Reflection.Metadata.BlobBuilder Value) : TypedefEntry; - } - - private static void AddManifestValue( - Stack> frames, - TContext context, - object? value) - where TContext : ParserRuleContext - { - if (value is not null && TryGetManifestValueListFrame(frames, context) is { } frame) - { - (frame.Values ??= ImmutableArray.CreateBuilder()).Add(value); - } - } - - private static ImmutableArray EndManifestValues( - Stack> frames, - TContext context) - where TContext : ParserRuleContext - { - if (TryGetManifestValueListFrame(frames, context) is not { } frame) - { - return []; - } - - frames.Pop(); - return frame.Values?.ToImmutable() ?? []; - } - - private static ManifestValueListFrame? TryGetManifestValueListFrame( - Stack> frames, - TContext context) - where TContext : ParserRuleContext - { - Debug.Assert(frames.Count > 0); - ManifestValueListFrame? frame = frames.Count == 0 ? null : frames.Peek(); - Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); - return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; - } - - private static ImmutableArray GetManifestValues(object? value) - => value is ImmutableArray values ? values : []; -} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Marshalling.Actions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Marshalling.Actions.cs index 91054df8d9defc..f14eccb0e66788 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Marshalling.Actions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Marshalling.Actions.cs @@ -5,7 +5,6 @@ using System.Collections.Generic; using System.Collections.Immutable; using System.Diagnostics; -using System.Diagnostics.CodeAnalysis; using System.Reflection.Metadata; using System.Runtime.InteropServices; using Antlr4.Runtime; @@ -25,241 +24,71 @@ internal sealed partial class GrammarActions private const byte NativeTypeNestedStruct = 0x21; private const byte NativeTypeMax = 0x50; - private readonly Stack _marshalBlobFrames = new(); - private readonly Stack _nativeTypeFrames = new(); - private readonly Stack _variantTypeFrames = new(); - - private sealed class MarshalBlobFrame - { - public MarshalBlobFrame(CILParser.MarshalBlobContext owner) - { - Owner = owner; - } - - public CILParser.MarshalBlobContext Owner { get; } - - public NativeTypeValue? NativeType { get; set; } - - public BlobBuilder? RawBytes { get; set; } - } - - private sealed class NativeTypeFrame - { - public NativeTypeFrame(CILParser.NativeTypeContext owner) - { - Owner = owner; - } - - public CILParser.NativeTypeContext Owner { get; } - - public NativeTypeElementValue? Element { get; set; } - - public List? ArrayPointerInfo { get; set; } - } - - private sealed class VariantTypeFrame - { - public VariantTypeFrame(CILParser.VariantTypeContext owner) - { - Owner = owner; - } - - public CILParser.VariantTypeContext Owner { get; } - - public VariantTypeElementValue? Element { get; set; } - - public VarEnum Modifiers { get; set; } - } - - private sealed record MarshallingDescriptorValue(BlobBuilder? RawBytes, NativeTypeValue? NativeType); - - private sealed record NativeTypeValue( - IToken? Token, - NativeTypeElementValue? Element, - ImmutableArray ArrayPointerInfo) - { - public static NativeTypeValue Empty { get; } = new(null, null, []); - } - - private abstract record NativeTypeElementValue; - - private sealed record EmptyNativeTypeElementValue : NativeTypeElementValue - { - public static EmptyNativeTypeElementValue Instance { get; } = new(); - } - - private sealed record CustomMarshallerNativeTypeElementValue( - IToken? Token, - string? Guid, - string? NativeTypeName, - string MarshallerType, - string Cookie) : NativeTypeElementValue; - - private sealed record FixedSysStringNativeTypeElementValue(IToken Size) : NativeTypeElementValue; - - private sealed record FixedArrayNativeTypeElementValue(IToken Size, NativeTypeValue Element) : NativeTypeElementValue; - - private sealed record DeprecatedNativeTypeElementValue(IToken Token, int TokenType) : NativeTypeElementValue; - - private sealed record SimpleNativeTypeElementValue(int TokenType) : NativeTypeElementValue; - - private sealed record IidNativeTypeElementValue( - int TokenType, - IidParamIndexValue IidParamIndex) : NativeTypeElementValue; - - private sealed record SafeArrayNativeTypeElementValue( - VariantTypeValue VariantType, - string? UserDefinedType) : NativeTypeElementValue; - - private sealed record UnsignedNativeTypeElementValue(int TokenType) : NativeTypeElementValue; - - private sealed record NestedStructNativeTypeElementValue(IToken Token) : NativeTypeElementValue; - - private sealed record AnsiBstrNativeTypeElementValue : NativeTypeElementValue - { - public static AnsiBstrNativeTypeElementValue Instance { get; } = new(); - } - - private sealed record VariantBoolNativeTypeElementValue : NativeTypeElementValue - { - public static VariantBoolNativeTypeElementValue Instance { get; } = new(); - } - - private sealed record NativeTypeTypedefValue(IToken Token, string Alias) : NativeTypeElementValue; - - private enum NativeTypeArrayPointerInfoKind - { - Pointer, - ArrayNoSizeData, - ArraySize, - ArraySizeParamIndex, - ArrayParamIndex - } - - private sealed record NativeTypeArrayPointerInfoValue( - NativeTypeArrayPointerInfoKind Kind, - IToken? Size = null, - IToken? ParameterIndex = null); - - private sealed record IidParamIndexValue(IToken? Index) - { - public static IidParamIndexValue Empty { get; } = new((IToken?)null); - } - - private sealed record VariantTypeValue(VariantTypeElementValue? Element, VarEnum Modifiers) - { - public static VariantTypeValue Empty { get; } = new(null, 0); - } - - private sealed record VariantTypeElementValue(int TokenType); - - internal object CreateEmptyMarshallingDescriptor() - => new MarshallingDescriptorValue(new BlobBuilder(0), null); - - internal object CompleteMarshalClause(object? value) - => GetMarshallingDescriptorValue(value); - - internal void BeginMarshalBlob(CILParser.MarshalBlobContext context) - => _marshalBlobFrames.Push(new(context)); - - internal void SetMarshalBlobNativeType(CILParser.MarshalBlobContext context, object? value) - { - if (TryGetMarshalBlobFrame(context, out MarshalBlobFrame? frame)) - { - frame.NativeType = GetNativeTypeValue(value); - } - } - - internal void AddMarshalBlobByte(CILParser.MarshalBlobContext context, byte value) - { - if (TryGetMarshalBlobFrame(context, out MarshalBlobFrame? frame)) - { - (frame.RawBytes ??= new BlobBuilder()).WriteByte(value); - } - } - - internal object EndMarshalBlob(CILParser.MarshalBlobContext context) - { - Debug.Assert(_marshalBlobFrames.Count > 0); - if (_marshalBlobFrames.Count == 0) - { - return CreateEmptyMarshallingDescriptor(); - } - - MarshalBlobFrame frame = _marshalBlobFrames.Pop(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - if (!ReferenceEquals(frame.Owner, context)) - { - return CreateEmptyMarshallingDescriptor(); - } - - return new MarshallingDescriptorValue(frame.RawBytes, frame.NativeType); - } - - internal void BeginNativeType(CILParser.NativeTypeContext context) - => _nativeTypeFrames.Push(new(context)); - - internal void SetNativeTypeElement(CILParser.NativeTypeContext context, object? value) - { - if (TryGetNativeTypeFrame(context, out NativeTypeFrame? frame)) - { - frame.Element = GetNativeTypeElementValue(value); - } - } - - internal void AddNativeTypeArrayPointerInfo(CILParser.NativeTypeContext context, object? value) - { - if (TryGetNativeTypeFrame(context, out NativeTypeFrame? frame) && - value is NativeTypeArrayPointerInfoValue arrayPointerInfo) - { - (frame.ArrayPointerInfo ??= new List()).Add(arrayPointerInfo); - } - } - - internal object EndNativeType(CILParser.NativeTypeContext context) - { - Debug.Assert(_nativeTypeFrames.Count > 0); - if (_nativeTypeFrames.Count == 0) - { - return NativeTypeValue.Empty; - } - - NativeTypeFrame frame = _nativeTypeFrames.Pop(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - if (!ReferenceEquals(frame.Owner, context)) - { - return NativeTypeValue.Empty; - } - - return new NativeTypeValue( - context.Start, - frame.Element, - frame.ArrayPointerInfo?.ToImmutableArray() ?? []); - } - - internal object CreatePointerNativeType() + internal MarshallingDescriptorValue CreateEmptyMarshallingDescriptor() + => MarshallingDescriptorValue.Empty; + + internal MarshallingDescriptorValue CompleteMarshalClause( + MarshallingDescriptorValue value) + => value; + + internal void SetMarshalBlobNativeType( + CILParser.MarshalBlobBuilder builder, + NativeTypeValue value) + => builder.NativeType = value; + + internal void AddMarshalBlobByte(CILParser.MarshalBlobBuilder builder, byte value) + => (builder.RawBytes ??= new BlobBuilder()).WriteByte(value); + + internal MarshallingDescriptorValue CreateMarshallingDescriptor( + CILParser.MarshalBlobBuilder builder) + => new(builder.RawBytes, builder.NativeType); + + internal void SetNativeTypeElement( + CILParser.NativeTypeBuilder builder, + NativeTypeElementValue value) + => builder.Element = value; + + internal void AddNativeTypeArrayPointerInfo( + CILParser.NativeTypeBuilder builder, + NativeTypeArrayPointerInfoValue value) + => (builder.ArrayPointerInfo ??= new List()) + .Add(value); + + internal NativeTypeValue CreateNativeType( + IToken token, + CILParser.NativeTypeBuilder builder) + => new( + token, + builder.Element, + builder.ArrayPointerInfo?.ToImmutableArray() ?? []); + + internal NativeTypeArrayPointerInfoValue CreatePointerNativeType() => new NativeTypeArrayPointerInfoValue(NativeTypeArrayPointerInfoKind.Pointer); - internal object CreatePointerArrayTypeNoSizeData() + internal NativeTypeArrayPointerInfoValue CreatePointerArrayTypeNoSizeData() => new NativeTypeArrayPointerInfoValue(NativeTypeArrayPointerInfoKind.ArrayNoSizeData); - internal object CreatePointerArrayTypeSize(IToken size) + internal NativeTypeArrayPointerInfoValue CreatePointerArrayTypeSize(IToken size) => new NativeTypeArrayPointerInfoValue(NativeTypeArrayPointerInfoKind.ArraySize, Size: size); - internal object CreatePointerArrayTypeSizeParamIndex(IToken size, IToken parameterIndex) + internal NativeTypeArrayPointerInfoValue CreatePointerArrayTypeSizeParamIndex( + IToken size, + IToken parameterIndex) => new NativeTypeArrayPointerInfoValue( NativeTypeArrayPointerInfoKind.ArraySizeParamIndex, size, parameterIndex); - internal object CreatePointerArrayTypeParamIndex(IToken parameterIndex) + internal NativeTypeArrayPointerInfoValue CreatePointerArrayTypeParamIndex( + IToken parameterIndex) => new NativeTypeArrayPointerInfoValue( NativeTypeArrayPointerInfoKind.ArrayParamIndex, ParameterIndex: parameterIndex); - internal object CreateEmptyNativeType() => EmptyNativeTypeElementValue.Instance; + internal NativeTypeElementValue CreateEmptyNativeType() + => EmptyNativeTypeElementValue.Instance; - internal object CreateDeprecatedCustomMarshallerNativeType( + internal NativeTypeElementValue CreateDeprecatedCustomMarshallerNativeType( CILParser.NativeTypeElementContext context, string guid, string nativeTypeName, @@ -272,7 +101,9 @@ internal object CreateDeprecatedCustomMarshallerNativeType( marshallerType, cookie); - internal object CreateCustomMarshallerNativeType(string marshallerType, string cookie) + internal NativeTypeElementValue CreateCustomMarshallerNativeType( + string marshallerType, + string cookie) => new CustomMarshallerNativeTypeElementValue( null, null, @@ -280,65 +111,63 @@ internal object CreateCustomMarshallerNativeType(string marshallerType, string c marshallerType, cookie); - internal object CreateFixedSysStringNativeType(IToken size) + internal NativeTypeElementValue CreateFixedSysStringNativeType(IToken size) => new FixedSysStringNativeTypeElementValue(size); - internal object CreateFixedArrayNativeType(IToken size, object? element) - => new FixedArrayNativeTypeElementValue(size, GetNativeTypeValue(element)); + internal NativeTypeElementValue CreateFixedArrayNativeType( + IToken size, + NativeTypeValue element) + => new FixedArrayNativeTypeElementValue(size, element); - internal object CreateDeprecatedNativeType( + internal NativeTypeElementValue CreateDeprecatedNativeType( CILParser.NativeTypeElementContext context, IToken nativeType) => new DeprecatedNativeTypeElementValue(context.Start, nativeType.Type); - internal object CreateSimpleNativeType(IToken nativeType) + internal NativeTypeElementValue CreateSimpleNativeType(IToken nativeType) => new SimpleNativeTypeElementValue(nativeType.Type); - internal object CreateIidNativeType(IToken nativeType, object? index) - => new IidNativeTypeElementValue(nativeType.Type, GetIidParamIndexValue(index)); + internal NativeTypeElementValue CreateIidNativeType( + IToken nativeType, + IidParamIndexValue index) + => new IidNativeTypeElementValue(nativeType.Type, index); - internal object CreateSafeArrayNativeType(object? variantType, string? userDefinedType) - => new SafeArrayNativeTypeElementValue( - GetVariantTypeValue(variantType), - userDefinedType); + internal NativeTypeElementValue CreateSafeArrayNativeType( + VariantTypeValue variantType, + string? userDefinedType) + => new SafeArrayNativeTypeElementValue(variantType, userDefinedType); - internal object CreateUnsignedNativeType(IToken nativeType) + internal NativeTypeElementValue CreateUnsignedNativeType(IToken nativeType) => new UnsignedNativeTypeElementValue(nativeType.Type); - internal object CreateNestedStructNativeType(CILParser.NativeTypeElementContext context) + internal NativeTypeElementValue CreateNestedStructNativeType( + CILParser.NativeTypeElementContext context) => new NestedStructNativeTypeElementValue(context.Start); - internal object CreateAnsiBstrNativeType() => AnsiBstrNativeTypeElementValue.Instance; + internal NativeTypeElementValue CreateAnsiBstrNativeType() + => AnsiBstrNativeTypeElementValue.Instance; - internal object CreateVariantBoolNativeType() => VariantBoolNativeTypeElementValue.Instance; + internal NativeTypeElementValue CreateVariantBoolNativeType() + => VariantBoolNativeTypeElementValue.Instance; - internal object CreateNativeTypeTypedef( + internal NativeTypeElementValue CreateNativeTypeTypedef( CILParser.NativeTypeElementContext context, string alias) => new NativeTypeTypedefValue(context.Start, alias); - internal object GetIidParamIndex(IToken index) => new IidParamIndexValue(index); + internal IidParamIndexValue GetIidParamIndex(IToken index) + => new(index); - internal void BeginVariantType(CILParser.VariantTypeContext context) - => _variantTypeFrames.Push(new(context)); - - internal void SetVariantTypeElement(CILParser.VariantTypeContext context, object? value) - { - if (TryGetVariantTypeFrame(context, out VariantTypeFrame? frame) && - value is VariantTypeElementValue element) - { - frame.Element = element; - } - } + internal void SetVariantTypeElement( + CILParser.VariantTypeBuilder builder, + VariantTypeElementValue value) + => builder.Element = value; - internal void AddVariantTypeModifier(CILParser.VariantTypeContext context, IToken modifier) + internal void AddVariantTypeModifier( + CILParser.VariantTypeBuilder builder, + IToken modifier) { - if (!TryGetVariantTypeFrame(context, out VariantTypeFrame? frame)) - { - return; - } - - frame.Modifiers |= modifier.Type switch + builder.Modifiers |= modifier.Type switch { CILParser.ARRAY_TYPE_NO_BOUNDS => VarEnum.VT_ARRAY, CILParser.VECTOR => VarEnum.VT_VECTOR, @@ -347,22 +176,10 @@ internal void AddVariantTypeModifier(CILParser.VariantTypeContext context, IToke }; } - internal object EndVariantType(CILParser.VariantTypeContext context) - { - Debug.Assert(_variantTypeFrames.Count > 0); - if (_variantTypeFrames.Count == 0) - { - return VariantTypeValue.Empty; - } - - VariantTypeFrame frame = _variantTypeFrames.Pop(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - return ReferenceEquals(frame.Owner, context) - ? new VariantTypeValue(frame.Element, frame.Modifiers) - : VariantTypeValue.Empty; - } + internal VariantTypeValue CreateVariantType(CILParser.VariantTypeBuilder builder) + => new(builder.Element, builder.Modifiers); - internal object GetVariantTypeElement(IToken variantType) + internal VariantTypeElementValue GetVariantTypeElement(IToken variantType) => new VariantTypeElementValue(variantType.Type); private BlobBuilder MaterializeMarshallingDescriptor(MarshallingDescriptorValue? value) @@ -585,6 +402,7 @@ private VarEnum MaterializeVariantType(VariantTypeValue value) private static VarEnum MaterializeVariantTypeElement(VariantTypeElementValue value) => value.TokenType switch { + CILParser.NULL => VarEnum.VT_EMPTY, CILParser.VARIANT => VarEnum.VT_VARIANT, CILParser.CURRENCY => VarEnum.VT_CY, CILParser.VOID => VarEnum.VT_VOID, @@ -624,6 +442,7 @@ private static VarEnum MaterializeVariantTypeElement(VariantTypeElementValue val CILParser.BLOB_OBJECT => VarEnum.VT_BLOB_OBJECT, CILParser.CF => VarEnum.VT_CF, CILParser.CLSID => VarEnum.VT_CLSID, + TokenConstants.InvalidType => VarEnum.VT_EMPTY, _ => throw new UnreachableException() }; @@ -685,48 +504,4 @@ private static BlobBuilder CreateNativeTypeBlob(byte value) private int ParseMarshallingInt32(IToken? token) => token is null ? 0 : ParseInt32(token); - private static MarshallingDescriptorValue GetMarshallingDescriptorValue(object? value) - => value as MarshallingDescriptorValue ?? new MarshallingDescriptorValue(new BlobBuilder(), null); - - private static NativeTypeValue GetNativeTypeValue(object? value) - => value as NativeTypeValue ?? NativeTypeValue.Empty; - - private static NativeTypeElementValue GetNativeTypeElementValue(object? value) - => value as NativeTypeElementValue ?? EmptyNativeTypeElementValue.Instance; - - private static IidParamIndexValue GetIidParamIndexValue(object? value) - => value as IidParamIndexValue ?? IidParamIndexValue.Empty; - - private static VariantTypeValue GetVariantTypeValue(object? value) - => value as VariantTypeValue ?? VariantTypeValue.Empty; - - private bool TryGetMarshalBlobFrame( - CILParser.MarshalBlobContext context, - [NotNullWhen(true)] out MarshalBlobFrame? frame) - { - Debug.Assert(_marshalBlobFrames.Count > 0); - frame = _marshalBlobFrames.Count == 0 ? null : _marshalBlobFrames.Peek(); - Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); - return frame is not null && ReferenceEquals(frame.Owner, context); - } - - private bool TryGetNativeTypeFrame( - CILParser.NativeTypeContext context, - [NotNullWhen(true)] out NativeTypeFrame? frame) - { - Debug.Assert(_nativeTypeFrames.Count > 0); - frame = _nativeTypeFrames.Count == 0 ? null : _nativeTypeFrames.Peek(); - Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); - return frame is not null && ReferenceEquals(frame.Owner, context); - } - - private bool TryGetVariantTypeFrame( - CILParser.VariantTypeContext context, - [NotNullWhen(true)] out VariantTypeFrame? frame) - { - Debug.Assert(_variantTypeFrames.Count > 0); - frame = _variantTypeFrames.Count == 0 ? null : _variantTypeFrames.Peek(); - Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); - return frame is not null && ReferenceEquals(frame.Owner, context); - } } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Class.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Class.cs index 5d3326b50fa608..f236a40839d786 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Class.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Class.cs @@ -12,15 +12,10 @@ namespace ILAssembler; internal sealed partial class GrammarActions { - private readonly Stack _classGenericDirectiveFrames = new(); private readonly Dictionary< EntityRegistry.TypeDefinitionEntity, List> _pendingClassMethodOverrides = new(); - private sealed record ClassGenericDirectiveFrame( - CILParser.ClassDeclContext Owner, - EntityRegistry.EntityBase? AttributeOwner); - private sealed record PendingClassMethodOverride( EntityRegistry.MemberReferenceEntity Declaration, EntityRegistry.MemberReferenceEntity? ReferencedBody, @@ -112,13 +107,13 @@ internal void ProcessClassCompilerControl() internal void AddClassMethodOverride( CILParser.ClassDeclContext context, - object? declarationOwner, + TypeSpecificationValue declarationOwner, string declarationName, byte bodyCallingConvention, - object? bodyReturnType, - object? bodyOwner, + TypeValue bodyReturnType, + TypeSpecificationValue bodyOwner, string bodyName, - object? bodyArguments) + ImmutableArray bodyArguments) { PrepareClassMember(); AddClassMethodOverrideCore( @@ -140,17 +135,17 @@ internal void AddClassMethodOverride( internal void AddClassMethodOverride( CILParser.ClassDeclContext context, byte declarationCallingConvention, - object? declarationReturnType, - object? declarationOwner, + TypeValue declarationReturnType, + TypeSpecificationValue declarationOwner, string declarationName, int declarationArity, - object? declarationArguments, + ImmutableArray declarationArguments, byte bodyCallingConvention, - object? bodyReturnType, - object? bodyOwner, + TypeValue bodyReturnType, + TypeSpecificationValue bodyOwner, string bodyName, int bodyArity, - object? bodyArguments) + ImmutableArray bodyArguments) { PrepareClassMember(); AddClassMethodOverrideCore( @@ -172,17 +167,17 @@ internal void AddClassMethodOverride( private void AddClassMethodOverrideCore( CILParser.ClassDeclContext context, byte declarationCallingConvention, - object? declarationReturnType, - object? declarationOwner, + TypeValue declarationReturnType, + TypeSpecificationValue declarationOwner, string declarationName, int declarationArity, - object? declarationArguments, + ImmutableArray declarationArguments, byte bodyCallingConvention, - object? bodyReturnType, - object? bodyOwner, + TypeValue bodyReturnType, + TypeSpecificationValue bodyOwner, string bodyName, int bodyArity, - object? bodyArguments) + ImmutableArray bodyArguments) { if (_currentTypeDefinition.PeekOrDefault() is not { } currentType) { @@ -202,11 +197,11 @@ private void AddClassMethodOverrideCore( EntityRegistry.MemberReferenceEntity declaration = _entityRegistry.CreateLazilyRecordedMemberReference( - ResolveTypeSpecification(GetTypeSpecificationValue(declarationOwner)), + ResolveTypeSpecification(declarationOwner), declarationName, declarationSignature); EntityRegistry.TypeEntity resolvedBodyOwner = - ResolveTypeSpecification(GetTypeSpecificationValue(bodyOwner)); + ResolveTypeSpecification(bodyOwner); EntityRegistry.MemberReferenceEntity? referencedBody = ReferenceEquals(resolvedBodyOwner, currentType) ? null @@ -291,8 +286,8 @@ candidate.MethodSignature is null || private BlobBuilder BuildClassMethodOverrideSignature( byte callingConvention, - object? returnType, - object? arguments, + TypeValue returnType, + ImmutableArray arguments, int genericArity) { BlobBuilder signature = new(); @@ -307,10 +302,8 @@ private BlobBuilder BuildClassMethodOverrideSignature( signature.WriteCompressedInteger(genericArity); } - ImmutableArray argumentValues = - GetSignatureArgumentsValue(arguments); ImmutableArray materializedArguments = - MaterializeSignatureArguments(argumentValues); + MaterializeSignatureArguments(arguments); int parameterCount = 0; foreach (SignatureArg argument in materializedArguments) { @@ -320,7 +313,7 @@ private BlobBuilder BuildClassMethodOverrideSignature( } } signature.WriteCompressedInteger(parameterCount); - MaterializeType(GetTypeValue(returnType)).WriteContentTo(signature); + MaterializeType(returnType).WriteContentTo(signature); foreach (SignatureArg argument in materializedArguments) { argument.SignatureBlob.WriteContentTo(signature); @@ -329,64 +322,58 @@ private BlobBuilder BuildClassMethodOverrideSignature( return signature; } - internal void BeginClassGenericParameterDirective( + internal CILParser.CustomAttributeOwnerValue BeginClassGenericParameterDirective( CILParser.ClassDeclContext context, IToken index) { PrepareClassMember(); - BeginClassGenericDirective(context, FindClassGenericParameter(context, ParseInt32(index))); + return BeginClassGenericDirective( + FindClassGenericParameter(context, ParseInt32(index))); } - internal void BeginClassGenericParameterDirective( - CILParser.ClassDeclContext context, + internal CILParser.CustomAttributeOwnerValue BeginClassGenericParameterDirective( string name) { PrepareClassMember(); - BeginClassGenericDirective(context, FindClassGenericParameter(name)); + return BeginClassGenericDirective(FindClassGenericParameter(name)); } - internal void BeginClassGenericConstraintDirective( + internal CILParser.CustomAttributeOwnerValue BeginClassGenericConstraintDirective( CILParser.ClassDeclContext context, IToken index, - object? constraintType) + TypeSpecificationValue constraintType) { PrepareClassMember(); - BeginClassGenericDirective( - context, + return BeginClassGenericDirective( FindOrCreateClassGenericConstraint( FindClassGenericParameter(context, ParseInt32(index)), constraintType)); } - internal void BeginClassGenericConstraintDirective( - CILParser.ClassDeclContext context, + internal CILParser.CustomAttributeOwnerValue BeginClassGenericConstraintDirective( string name, - object? constraintType) + TypeSpecificationValue constraintType) { PrepareClassMember(); - BeginClassGenericDirective( - context, + return BeginClassGenericDirective( FindOrCreateClassGenericConstraint( FindClassGenericParameter(name), constraintType)); } - private void BeginClassGenericDirective( - CILParser.ClassDeclContext context, + private CILParser.CustomAttributeOwnerValue BeginClassGenericDirective( EntityRegistry.EntityBase? owner) { _pendingClassCustomAttributeOwner = owner; - _classGenericDirectiveFrames.Push(new(context, owner)); + return new CILParser.CustomAttributeOwnerValue(owner); } internal void AddClassGenericDirectiveAttribute( - CILParser.ClassDeclContext context, + CILParser.CustomAttributeOwnerValue ownerValue, CILParser.CustomAttrDeclContext attribute) { if (attribute.HasSyntaxError || - _classGenericDirectiveFrames.Count == 0 || - !ReferenceEquals(_classGenericDirectiveFrames.Peek().Owner, context) || - _classGenericDirectiveFrames.Peek().AttributeOwner is not { } owner) + ownerValue.Owner is not { } owner) { return; } @@ -437,7 +424,7 @@ internal void AddClassGenericDirectiveAttribute( private EntityRegistry.GenericParameterConstraintEntity? FindOrCreateClassGenericConstraint( EntityRegistry.GenericParameterEntity? parameter, - object? constraintType) + TypeSpecificationValue constraintType) { if (parameter is null || _currentTypeDefinition.PeekOrDefault() is not { } currentType) @@ -446,7 +433,7 @@ internal void AddClassGenericDirectiveAttribute( } EntityRegistry.TypeEntity baseType = - ResolveTypeSpecification(GetTypeSpecificationValue(constraintType)); + ResolveTypeSpecification(constraintType); foreach (EntityRegistry.GenericParameterConstraintEntity constraint in parameter.Constraints) { if (constraint.BaseType == baseType) @@ -465,7 +452,7 @@ internal void AddClassGenericDirectiveAttribute( internal void AddInterfaceImplementationAttribute( CILParser.ClassDeclContext context, - object? interfaceType, + TypeSpecificationValue interfaceType, CILParser.CustomDescrContext attribute) { PrepareClassMember(); @@ -476,7 +463,7 @@ internal void AddInterfaceImplementationAttribute( } EntityRegistry.TypeEntity resolvedInterface = - ResolveTypeSpecification(GetTypeSpecificationValue(interfaceType)); + ResolveTypeSpecification(interfaceType); EntityRegistry.InterfaceImplementationEntity? implementation = null; foreach (EntityRegistry.InterfaceImplementationEntity candidate in currentType.InterfaceImplementations) { @@ -498,12 +485,4 @@ internal void AddInterfaceImplementationAttribute( _ = context; } - private void EndClassGenericDirective(CILParser.ClassDeclContext context) - { - if (_classGenericDirectiveFrames.Count > 0 && - ReferenceEquals(_classGenericDirectiveFrames.Peek().Owner, context)) - { - _classGenericDirectiveFrames.Pop(); - } - } } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Fields.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Fields.cs index 420e13aae6b2c8..9324ac304efb38 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Fields.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Fields.cs @@ -1,7 +1,6 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System.Collections.Generic; using System.Diagnostics; using System.Globalization; using System.Reflection; @@ -14,67 +13,39 @@ namespace ILAssembler; #pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. internal sealed partial class GrammarActions { - private readonly Stack _fieldDeclarationFrames = new(); - - private sealed class FieldDeclarationFrame - { - public FieldDeclarationFrame(CILParser.FieldDeclContext owner, int initialSyntaxErrorCount) - { - Owner = owner; - InitialSyntaxErrorCount = initialSyntaxErrorCount; - } - - public CILParser.FieldDeclContext Owner { get; } - - public int InitialSyntaxErrorCount { get; } - - public FieldAttributes Attributes { get; set; } - - public MarshallingDescriptorValue Marshalling { get; set; } = - GetMarshallingDescriptorValue(null); - } - - internal void BeginFieldDeclaration(CILParser.FieldDeclContext context) + internal CILParser.FieldDeclarationBuilder PrepareFieldDeclaration() { ClearPendingCustomAttributeOwners(); - _fieldDeclarationFrames.Push(new(context, _syntaxErrorCount)); + return new CILParser.FieldDeclarationBuilder(); } - internal void AddFieldAttribute(CILParser.FieldDeclContext context, object? value) - { - if (TryGetFieldDeclarationFrame(context) is { } frame) - { - frame.Attributes = ApplyAttribute( - frame.Attributes, - GetAttributeValue(value)); - } - } + internal void AddFieldAttribute( + CILParser.FieldDeclarationBuilder builder, + CILParser.AttributeValue value) + => builder.Attributes = ApplyAttribute(builder.Attributes, value); - internal void SetFieldMarshalling(CILParser.FieldDeclContext context, object? value) - { - if (TryGetFieldDeclarationFrame(context) is { } frame) - { - frame.Marshalling = GetMarshallingDescriptorValue(value); - } - } + internal void SetFieldMarshalling( + CILParser.FieldDeclarationBuilder builder, + MarshallingDescriptorValue value) + => builder.Marshalling = value; - internal object CreateFieldDeclaration( + internal FieldDeclarationValue CreateFieldDeclaration( CILParser.FieldDeclContext context, + CILParser.FieldDeclarationBuilder builder, + int initialSyntaxErrorCount, CILParser.RepeatOptContext offset, - object? fieldType, + TypeValue fieldType, string name, string? dataDeclarationName, - object? initializer) + FieldInitializerValue initializer) { - FieldDeclarationFrame? frame = TryGetFieldDeclarationFrame(context); - if (frame is null || - frame.InitialSyntaxErrorCount != _syntaxErrorCount || + if (HasSyntaxErrorsSince(initialSyntaxErrorCount) || context.exception is not null) { return FieldDeclarationValue.Error; } - FieldAttributes attributes = frame.Attributes; + FieldAttributes attributes = builder.Attributes; if (attributes.HasFlag(FieldAttributes.RTSpecialName)) { attributes |= FieldAttributes.SpecialName; @@ -83,23 +54,26 @@ internal object CreateFieldDeclaration( return new FieldDeclarationValue( true, attributes, - GetTypeValue(fieldType), + fieldType, name, - frame.Marshalling, + builder.Marshalling, dataDeclarationName, offset.HasValue ? offset.Value : null, initializer); } - internal void DefineField(CILParser.FieldDeclContext context, object? value) + internal void DefineField( + CILParser.FieldDeclContext context, + FieldDeclarationValue value) { _ = context; - FieldDeclarationValue declaration = GetFieldDeclarationValue(value); - if (!declaration.IsValid) + if (!value.IsValid) { return; } + FieldDeclarationValue declaration = value; + BlobBuilder signature = new(); _ = new BlobEncoder(signature).Field(); MaterializeType(declaration.FieldType).WriteContentTo(signature); @@ -121,72 +95,58 @@ internal void DefineField(CILParser.FieldDeclContext context, object? value) field.MarshallingDescriptor = MaterializeMarshallingDescriptor(declaration.Marshalling); field.DataDeclarationName = declaration.DataDeclarationName; field.Offset = declaration.Offset; - if (declaration.ConstantValue is not NoConstantSentinel) + if (declaration.Initializer.HasValue) { - field.ConstantValue = declaration.ConstantValue; + field.ConstantValue = declaration.Initializer.ConstantValue; field.HasConstant = true; } } - internal void EndFieldDeclaration(CILParser.FieldDeclContext context) - { - if (_fieldDeclarationFrames.Count == 0) - { - return; - } - FieldDeclarationFrame frame = _fieldDeclarationFrames.Peek(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - if (ReferenceEquals(frame.Owner, context)) - { - _fieldDeclarationFrames.Pop(); - } - } - - internal object CreateFieldAttribute(IToken token) + internal CILParser.AttributeValue CreateFieldAttribute(IToken token) => token.Text switch { - "static" => new AttributeValue(FieldAttributes.Static, 0, true), - "public" => new AttributeValue( + "static" => new CILParser.AttributeValue(FieldAttributes.Static, 0, true), + "public" => new CILParser.AttributeValue( FieldAttributes.Public, FieldAttributes.FieldAccessMask, true), - "private" => new AttributeValue( + "private" => new CILParser.AttributeValue( FieldAttributes.Private, FieldAttributes.FieldAccessMask, true), - "family" => new AttributeValue( + "family" => new CILParser.AttributeValue( FieldAttributes.Family, FieldAttributes.FieldAccessMask, true), - "initonly" => new AttributeValue(FieldAttributes.InitOnly, 0, true), - "rtspecialname" => new AttributeValue(FieldAttributes.RTSpecialName, 0, true), - "specialname" => new AttributeValue(FieldAttributes.SpecialName, 0, true), - "assembly" => new AttributeValue( + "initonly" => new CILParser.AttributeValue(FieldAttributes.InitOnly, 0, true), + "rtspecialname" => new CILParser.AttributeValue(FieldAttributes.RTSpecialName, 0, true), + "specialname" => new CILParser.AttributeValue(FieldAttributes.SpecialName, 0, true), + "assembly" => new CILParser.AttributeValue( FieldAttributes.Assembly, FieldAttributes.FieldAccessMask, true), - "famandassem" => new AttributeValue( + "famandassem" => new CILParser.AttributeValue( FieldAttributes.FamANDAssem, FieldAttributes.FieldAccessMask, true), - "famorassem" => new AttributeValue( + "famorassem" => new CILParser.AttributeValue( FieldAttributes.FamORAssem, FieldAttributes.FieldAccessMask, true), - "privatescope" => new AttributeValue( + "privatescope" => new CILParser.AttributeValue( FieldAttributes.PrivateScope, FieldAttributes.FieldAccessMask, true), - "literal" => new AttributeValue(FieldAttributes.Literal, 0, true), + "literal" => new CILParser.AttributeValue(FieldAttributes.Literal, 0, true), #pragma warning disable SYSLIB0050 - "notserialized" => new AttributeValue(FieldAttributes.NotSerialized, 0, true), + "notserialized" => new CILParser.AttributeValue(FieldAttributes.NotSerialized, 0, true), #pragma warning restore SYSLIB0050 - "volatile" => new AttributeValue(0, 0, true), + "volatile" => new CILParser.AttributeValue(0, 0, true), _ => throw new UnreachableException(), }; - internal object CreateRawFieldAttribute(IToken token) - => new AttributeValue((FieldAttributes)ParseInt32(token), 0, false); + internal CILParser.AttributeValue CreateRawFieldAttribute(IToken token) + => new((FieldAttributes)ParseInt32(token), 0, false); internal string GetFieldDataName(IToken token) => ParseIdentifier(token); @@ -202,14 +162,5 @@ internal void SetFieldOffset(CILParser.RepeatOptContext context, IToken token) internal EntityRegistry.EntityBase MaterializeFieldReference( CILParser.FieldRefContext context) - => MaterializeFieldReference(GetFieldReferenceValue(context.Value)); - - private FieldDeclarationFrame? TryGetFieldDeclarationFrame(CILParser.FieldDeclContext context) - { - Debug.Assert(_fieldDeclarationFrames.Count > 0); - FieldDeclarationFrame? frame = - _fieldDeclarationFrames.Count == 0 ? null : _fieldDeclarationFrames.Peek(); - Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); - return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; - } + => MaterializeFieldReference(context.Value); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.PropertiesEvents.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.PropertiesEvents.cs index c2af6e8df2df0f..a86b8e78b80803 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.PropertiesEvents.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.PropertiesEvents.cs @@ -1,7 +1,6 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System.Collections.Generic; using System.Diagnostics; using System.Reflection; using System.Reflection.Metadata; @@ -12,72 +11,22 @@ namespace ILAssembler; #pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. internal sealed partial class GrammarActions { - private readonly Stack _propertyHeaderFrames = new(); - private readonly Stack _eventHeaderFrames = new(); - private readonly Stack _propertyBodyFrames = new(); - private readonly Stack _eventBodyFrames = new(); + internal void AddPropertyAttribute( + CILParser.PropertyHeaderBuilder builder, + CILParser.AttributeValue value) + => builder.Attributes = ApplyAttribute(builder.Attributes, value); - private sealed class PropertyHeaderFrame - { - public PropertyHeaderFrame(CILParser.PropHeadContext owner, int initialSyntaxErrorCount) - { - Owner = owner; - InitialSyntaxErrorCount = initialSyntaxErrorCount; - } - - public CILParser.PropHeadContext Owner { get; } - - public int InitialSyntaxErrorCount { get; } - - public PropertyAttributes Attributes { get; set; } - } - - private sealed class EventHeaderFrame - { - public EventHeaderFrame(CILParser.EventHeadContext owner, int initialSyntaxErrorCount) - { - Owner = owner; - InitialSyntaxErrorCount = initialSyntaxErrorCount; - } - - public CILParser.EventHeadContext Owner { get; } - - public int InitialSyntaxErrorCount { get; } - - public EventAttributes Attributes { get; set; } - } - - private sealed record PropertyBodyFrame( - CILParser.ClassDeclContext Owner, - EntityRegistry.PropertyEntity? Property); - - private sealed record EventBodyFrame( - CILParser.ClassDeclContext Owner, - EntityRegistry.EventEntity? Event); - - internal void BeginPropertyHeader(CILParser.PropHeadContext context) - => _propertyHeaderFrames.Push(new(context, _syntaxErrorCount)); - - internal void AddPropertyAttribute(CILParser.PropHeadContext context, object? value) - { - if (TryGetPropertyHeaderFrame(context) is { } frame) - { - frame.Attributes = ApplyAttribute( - frame.Attributes, - GetAttributeValue(value)); - } - } - internal object CreatePropertyHeader( + internal PropertyHeaderValue CreatePropertyHeader( CILParser.PropHeadContext context, + CILParser.PropertyHeaderBuilder builder, + int initialSyntaxErrorCount, byte callingConvention, - object? propertyType, + TypeValue propertyType, string name, - object? arguments, - object? initializer) + System.Collections.Immutable.ImmutableArray arguments, + FieldInitializerValue initializer) { - PropertyHeaderFrame? frame = TryGetPropertyHeaderFrame(context); - if (frame is null || - frame.InitialSyntaxErrorCount != _syntaxErrorCount || + if (HasSyntaxErrorsSince(initialSyntaxErrorCount) || context.exception is not null) { return PropertyHeaderValue.Error; @@ -85,61 +34,45 @@ internal object CreatePropertyHeader( return new PropertyHeaderValue( true, - frame.Attributes, + builder.Attributes, callingConvention, - GetTypeValue(propertyType), + propertyType, name, - GetSignatureArgumentsValue(arguments), + arguments, initializer); } - internal void EndPropertyHeader(CILParser.PropHeadContext context) - { - if (_propertyHeaderFrames.Count == 0) - { - return; - } - - PropertyHeaderFrame frame = _propertyHeaderFrames.Peek(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - if (ReferenceEquals(frame.Owner, context)) - { - _propertyHeaderFrames.Pop(); - } - } - - internal object CreatePropertyAttribute(IToken token) + internal CILParser.AttributeValue CreatePropertyAttribute(IToken token) => token.Text switch { - "specialname" => new AttributeValue( + "specialname" => new CILParser.AttributeValue( PropertyAttributes.SpecialName, 0, true), - "rtspecialname" => new AttributeValue(0, 0, true), + "rtspecialname" => new CILParser.AttributeValue(0, 0, true), _ => throw new UnreachableException(), }; - internal void BeginProperty(CILParser.ClassDeclContext context, object? value) + internal CILParser.PropertyBodyValue BeginProperty(PropertyHeaderValue value) { PrepareClassMember(); - PropertyHeaderValue header = GetPropertyHeaderValue(value); EntityRegistry.PropertyEntity? property = null; - if (header.IsValid && _currentTypeDefinition.PeekOrDefault() is { } currentType) + if (value.IsValid && _currentTypeDefinition.PeekOrDefault() is { } currentType) { BlobBuilder signature = new(); signature.WriteByte( - (byte)(header.CallingConvention | (byte)SignatureKind.Property)); - signature.WriteCompressedInteger(header.Arguments.Length); - MaterializeType(header.PropertyType).WriteContentTo(signature); - foreach (SignatureArgumentValue argument in header.Arguments) + (byte)(value.CallingConvention | (byte)SignatureKind.Property)); + signature.WriteCompressedInteger(value.Arguments.Length); + MaterializeType(value.PropertyType).WriteContentTo(signature); + foreach (SignatureArgumentValue argument in value.Arguments) { MaterializeSignatureArgument(argument).SignatureBlob.WriteContentTo(signature); } - property = new EntityRegistry.PropertyEntity(header.Attributes, signature, header.Name); - if (header.ConstantValue is not NoConstantSentinel) + property = new EntityRegistry.PropertyEntity(value.Attributes, signature, value.Name); + if (value.Initializer.HasValue) { - property.ConstantValue = header.ConstantValue; + property.ConstantValue = value.Initializer.ConstantValue; property.HasConstant = true; property.Attributes |= PropertyAttributes.HasDefault; } @@ -147,36 +80,42 @@ internal void BeginProperty(CILParser.ClassDeclContext context, object? value) currentType.Properties.Add(property); } - _propertyBodyFrames.Push(new(context, property)); + return new CILParser.PropertyBodyValue(property); } - internal void AddPropertySetter(CILParser.PropDeclContext context, object? value) - => AddPropertyAccessor(context, MethodSemanticsAttributes.Setter, value); + internal void AddPropertySetter( + CILParser.PropertyBodyValue body, + MethodReferenceValue value) + => AddPropertyAccessor(body, MethodSemanticsAttributes.Setter, value); - internal void AddPropertyGetter(CILParser.PropDeclContext context, object? value) - => AddPropertyAccessor(context, MethodSemanticsAttributes.Getter, value); + internal void AddPropertyGetter( + CILParser.PropertyBodyValue body, + MethodReferenceValue value) + => AddPropertyAccessor(body, MethodSemanticsAttributes.Getter, value); - internal void AddPropertyOther(CILParser.PropDeclContext context, object? value) - => AddPropertyAccessor(context, MethodSemanticsAttributes.Other, value); + internal void AddPropertyOther( + CILParser.PropertyBodyValue body, + MethodReferenceValue value) + => AddPropertyAccessor(body, MethodSemanticsAttributes.Other, value); private void AddPropertyAccessor( - CILParser.PropDeclContext context, + CILParser.PropertyBodyValue body, MethodSemanticsAttributes semantics, - object? value) + MethodReferenceValue value) { - if (TryGetPropertyBodyFrame(context) is { Property: { } property }) + if (body.Property is { } property) { property.Accessors.Add( - (semantics, MaterializeMethodReference(GetMethodReferenceValue(value)))); + (semantics, MaterializeMethodReference(value))); } } internal void AddPropertyCustomAttribute( - CILParser.PropDeclContext context, + CILParser.PropertyBodyValue body, CILParser.CustomAttrDeclContext attribute) { if (attribute.HasSyntaxError || - TryGetPropertyBodyFrame(context) is not { Property: { } property }) + body.Property is not { } property) { return; } @@ -187,33 +126,35 @@ internal void AddPropertyCustomAttribute( } } - internal void ProcessPropertySourceDirective(CILParser.ExtSourceSpecContext context) - => _ = context; - - internal void ProcessPropertyLanguageDirective(CILParser.LanguageDeclContext context) - => _ = context; - - internal void BeginEventHeader(CILParser.EventHeadContext context) - => _eventHeaderFrames.Push(new(context, _syntaxErrorCount)); + internal void ProcessPropertySourceDirective( + CILParser.PropertyBodyValue body, + CILParser.ExtSourceSpecContext context) + { + _ = body; + _ = context; + } - internal void AddEventAttribute(CILParser.EventHeadContext context, object? value) + internal void ProcessPropertyLanguageDirective( + CILParser.PropertyBodyValue body, + CILParser.LanguageDeclContext context) { - if (TryGetEventHeaderFrame(context) is { } frame) - { - frame.Attributes = ApplyAttribute( - frame.Attributes, - GetAttributeValue(value)); - } + _ = body; + _ = context; } - internal object CreateEventHeader( + internal void AddEventAttribute( + CILParser.EventHeaderBuilder builder, + CILParser.AttributeValue value) + => builder.Attributes = ApplyAttribute(builder.Attributes, value); + + internal EventHeaderValue CreateEventHeader( CILParser.EventHeadContext context, - object? eventType, + CILParser.EventHeaderBuilder builder, + int initialSyntaxErrorCount, + TypeSpecificationValue? eventType, string name) { - EventHeaderFrame? frame = TryGetEventHeaderFrame(context); - if (frame is null || - frame.InitialSyntaxErrorCount != _syntaxErrorCount || + if (HasSyntaxErrorsSince(initialSyntaxErrorCount) || context.exception is not null) { return EventHeaderValue.Error; @@ -221,86 +162,70 @@ internal object CreateEventHeader( return new EventHeaderValue( true, - frame.Attributes, - eventType is null ? null : GetTypeSpecificationValue(eventType), + builder.Attributes, + eventType, name); } - internal void EndEventHeader(CILParser.EventHeadContext context) - { - if (_eventHeaderFrames.Count == 0) - { - return; - } - - EventHeaderFrame frame = _eventHeaderFrames.Peek(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - if (ReferenceEquals(frame.Owner, context)) - { - _eventHeaderFrames.Pop(); - } - } - - internal object CreateEventAttribute(IToken token) + internal CILParser.AttributeValue CreateEventAttribute(IToken token) => token.Text switch { - "specialname" => new AttributeValue( + "specialname" => new CILParser.AttributeValue( EventAttributes.SpecialName, 0, true), - "rtspecialname" => new AttributeValue(0, 0, true), + "rtspecialname" => new CILParser.AttributeValue(0, 0, true), _ => throw new UnreachableException(), }; - internal void BeginEvent(CILParser.ClassDeclContext context, object? value) + internal CILParser.EventBodyValue BeginEvent(EventHeaderValue value) { PrepareClassMember(); - EventHeaderValue header = GetEventHeaderValue(value); EntityRegistry.EventEntity? @event = null; - if (header.IsValid && _currentTypeDefinition.PeekOrDefault() is { } currentType) + if (value.IsValid && _currentTypeDefinition.PeekOrDefault() is { } currentType) { @event = new EntityRegistry.EventEntity( - header.Attributes, - header.EventType is null + value.Attributes, + value.EventType is null ? null - : ResolveTypeSpecification(header.EventType), - header.Name); + : ResolveTypeSpecification(value.EventType), + value.Name); currentType.Events.Add(@event); } - _eventBodyFrames.Push(new(context, @event)); + return new CILParser.EventBodyValue(@event); } - internal void AddEventAdder(CILParser.EventDeclContext context, object? value) - => AddEventAccessor(context, MethodSemanticsAttributes.Adder, value); + internal void AddEventAdder(CILParser.EventBodyValue body, MethodReferenceValue value) + => AddEventAccessor(body, MethodSemanticsAttributes.Adder, value); - internal void AddEventRemover(CILParser.EventDeclContext context, object? value) - => AddEventAccessor(context, MethodSemanticsAttributes.Remover, value); + internal void AddEventRemover(CILParser.EventBodyValue body, MethodReferenceValue value) + => AddEventAccessor(body, MethodSemanticsAttributes.Remover, value); - internal void AddEventRaiser(CILParser.EventDeclContext context, object? value) - => AddEventAccessor(context, MethodSemanticsAttributes.Raiser, value); + internal void AddEventRaiser(CILParser.EventBodyValue body, MethodReferenceValue value) + => AddEventAccessor(body, MethodSemanticsAttributes.Raiser, value); - internal void AddEventOther(CILParser.EventDeclContext context, object? value) - => AddEventAccessor(context, MethodSemanticsAttributes.Other, value); + internal void AddEventOther(CILParser.EventBodyValue body, MethodReferenceValue value) + => AddEventAccessor(body, MethodSemanticsAttributes.Other, value); private void AddEventAccessor( - CILParser.EventDeclContext context, + CILParser.EventBodyValue body, MethodSemanticsAttributes semantics, - object? value) + MethodReferenceValue value) { - if (TryGetEventBodyFrame(context) is { Event: { } @event }) + if (body.Event is { } @event) { @event.Accessors.Add( - (semantics, MaterializeMethodReference(GetMethodReferenceValue(value)))); + (semantics, MaterializeMethodReference(value))); } } internal void AddEventCustomAttribute( - CILParser.EventDeclContext context, + CILParser.EventBodyValue body, CILParser.CustomAttrDeclContext attribute) { if (attribute.HasSyntaxError || - TryGetEventBodyFrame(context) is not { Event: { } @event }) + body.Event is not { } @event) { return; } @@ -311,58 +236,19 @@ internal void AddEventCustomAttribute( } } - internal void ProcessEventSourceDirective(CILParser.ExtSourceSpecContext context) - => _ = context; - - internal void ProcessEventLanguageDirective(CILParser.LanguageDeclContext context) - => _ = context; - - private void EndPropertyAndEventBodies(CILParser.ClassDeclContext context) - { - if (_propertyBodyFrames.Count > 0 && - ReferenceEquals(_propertyBodyFrames.Peek().Owner, context)) - { - _propertyBodyFrames.Pop(); - } - - if (_eventBodyFrames.Count > 0 && - ReferenceEquals(_eventBodyFrames.Peek().Owner, context)) - { - _eventBodyFrames.Pop(); - } - } - - private PropertyHeaderFrame? TryGetPropertyHeaderFrame(CILParser.PropHeadContext context) - { - Debug.Assert(_propertyHeaderFrames.Count > 0); - PropertyHeaderFrame? frame = - _propertyHeaderFrames.Count == 0 ? null : _propertyHeaderFrames.Peek(); - Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); - return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; - } - - private EventHeaderFrame? TryGetEventHeaderFrame(CILParser.EventHeadContext context) - { - Debug.Assert(_eventHeaderFrames.Count > 0); - EventHeaderFrame? frame = - _eventHeaderFrames.Count == 0 ? null : _eventHeaderFrames.Peek(); - Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); - return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; - } - - private PropertyBodyFrame? TryGetPropertyBodyFrame(CILParser.PropDeclContext context) + internal void ProcessEventSourceDirective( + CILParser.EventBodyValue body, + CILParser.ExtSourceSpecContext context) { - PropertyBodyFrame? frame = - _propertyBodyFrames.Count == 0 ? null : _propertyBodyFrames.Peek(); - Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context.Parent?.Parent)); - return frame is not null && ReferenceEquals(frame.Owner, context.Parent?.Parent) ? frame : null; + _ = body; + _ = context; } - private EventBodyFrame? TryGetEventBodyFrame(CILParser.EventDeclContext context) + internal void ProcessEventLanguageDirective( + CILParser.EventBodyValue body, + CILParser.LanguageDeclContext context) { - EventBodyFrame? frame = - _eventBodyFrames.Count == 0 ? null : _eventBodyFrames.Peek(); - Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context.Parent?.Parent)); - return frame is not null && ReferenceEquals(frame.Owner, context.Parent?.Parent) ? frame : null; + _ = body; + _ = context; } } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Values.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Values.cs deleted file mode 100644 index 2897d8ea4e1115..00000000000000 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Members.Values.cs +++ /dev/null @@ -1,68 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Collections.Immutable; -using System.Reflection; - -namespace ILAssembler; - -internal sealed partial class GrammarActions -{ - private sealed record FieldDeclarationValue( - bool IsValid, - FieldAttributes Attributes, - TypeValue FieldType, - string Name, - MarshallingDescriptorValue Marshalling, - string? DataDeclarationName, - int? Offset, - object? ConstantValue) - { - public static FieldDeclarationValue Error { get; } = new( - false, - 0, - TypeValue.Error, - string.Empty, - GetMarshallingDescriptorValue(null), - null, - null, - NoConstantSentinel.Instance); - } - - private sealed record PropertyHeaderValue( - bool IsValid, - PropertyAttributes Attributes, - byte CallingConvention, - TypeValue PropertyType, - string Name, - ImmutableArray Arguments, - object? ConstantValue) - { - public static PropertyHeaderValue Error { get; } = new( - false, - 0, - 0, - TypeValue.Error, - string.Empty, - [], - NoConstantSentinel.Instance); - } - - private sealed record EventHeaderValue( - bool IsValid, - EventAttributes Attributes, - TypeSpecificationValue? EventType, - string Name) - { - public static EventHeaderValue Error { get; } = new(false, 0, null, string.Empty); - } - - private static FieldDeclarationValue GetFieldDeclarationValue(object? value) - => value as FieldDeclarationValue ?? FieldDeclarationValue.Error; - - private static PropertyHeaderValue GetPropertyHeaderValue(object? value) - => value as PropertyHeaderValue ?? PropertyHeaderValue.Error; - - private static EventHeaderValue GetEventHeaderValue(object? value) - => value as EventHeaderValue ?? EventHeaderValue.Error; -} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.Directives.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.Directives.cs index 6d44da9a3e4b00..f6a3e764b447f1 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.Directives.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.Directives.cs @@ -13,9 +13,13 @@ namespace ILAssembler; internal sealed partial class GrammarActions { - internal void EndLocalsDirective(CILParser.LocalsDeclContext context) + internal void EndLocalsDirective( + CILParser.LocalsDeclContext context, + int initialSyntaxErrorCount) { - bool hasSyntaxError = EndSemanticRoot(context); + bool hasSyntaxError = + HasSyntaxErrorsSince(initialSyntaxErrorCount) || + context.exception is not null; if (hasSyntaxError || _currentMethod is null || context.arguments is null) { return; @@ -38,7 +42,7 @@ internal void EndLocalsDirective(CILParser.LocalsDeclContext context) } ImmutableArray locals = - MaterializeSignatureArguments(GetSignatureArgumentsValue(context.arguments.Value)); + MaterializeSignatureArguments(context.arguments.Value); foreach (SignatureArg local in locals) { if (local.Name is not null) @@ -50,9 +54,13 @@ internal void EndLocalsDirective(CILParser.LocalsDeclContext context) } } - internal void EndExportDirective(CILParser.ExportDeclContext context) + internal void EndExportDirective( + CILParser.ExportDeclContext context, + int initialSyntaxErrorCount) { - bool hasSyntaxError = EndSemanticRoot(context); + bool hasSyntaxError = + HasSyntaxErrorsSince(initialSyntaxErrorCount) || + context.exception is not null; if (hasSyntaxError || _currentMethod is null || context.ordinal is null) { return; @@ -63,9 +71,13 @@ internal void EndExportDirective(CILParser.ExportDeclContext context) context.alias is null ? null : ParseIdentifier(context.alias.Start); } - internal void EndVTableEntryDirective(CILParser.VtentryDeclContext context) + internal void EndVTableEntryDirective( + CILParser.VtentryDeclContext context, + int initialSyntaxErrorCount) { - bool hasSyntaxError = EndSemanticRoot(context); + bool hasSyntaxError = + HasSyntaxErrorsSince(initialSyntaxErrorCount) || + context.exception is not null; if (hasSyntaxError || _currentMethod is null || context.table is null || context.slot is null) { return; @@ -75,9 +87,13 @@ internal void EndVTableEntryDirective(CILParser.VtentryDeclContext context) _currentMethod.Definition.VTableSlot = ParseInt32(context.slot.Start); } - internal void EndOverrideDirective(CILParser.OverrideDeclContext context) + internal void EndOverrideDirective( + CILParser.OverrideDeclContext context, + int initialSyntaxErrorCount) { - bool hasSyntaxError = EndSemanticRoot(context); + bool hasSyntaxError = + HasSyntaxErrorsSince(initialSyntaxErrorCount) || + context.exception is not null; if (hasSyntaxError || _currentMethod is null || context.owner is null || @@ -103,7 +119,7 @@ context.name is null || } EntityRegistry.TypeEntity owner = - ResolveTypeSpecification(GetTypeSpecificationValue(context.owner.Value)); + ResolveTypeSpecification(context.owner.Value); EntityRegistry.MemberReferenceEntity declaration = _entityRegistry.CreateLazilyRecordedMemberReference(owner, context.name.Value, signature); currentType.MethodImplementations.Add( @@ -112,9 +128,9 @@ context.name is null || private BlobBuilder BuildOverrideSignature( byte callingConvention, - object? returnType, + TypeValue returnType, int genericArity, - object? signatureArguments) + ImmutableArray signatureArguments) { BlobBuilder signature = new(); byte header = callingConvention; @@ -130,9 +146,9 @@ private BlobBuilder BuildOverrideSignature( } ImmutableArray arguments = - MaterializeSignatureArguments(GetSignatureArgumentsValue(signatureArguments)); + MaterializeSignatureArguments(signatureArguments); signature.WriteCompressedInteger(arguments.Length); - MaterializeType(GetTypeValue(returnType)).WriteContentTo(signature); + MaterializeType(returnType).WriteContentTo(signature); foreach (SignatureArg argument in arguments) { argument.SignatureBlob.WriteContentTo(signature); @@ -141,42 +157,25 @@ private BlobBuilder BuildOverrideSignature( return signature; } - internal void BeginParameterDirective(CILParser.ParameterDeclContext context) - { - BeginSemanticRoot(context); - _parameterDirectiveFrames.Push(new(context)); - } - - internal void AddParameterCustomAttribute( - CILParser.ParameterDeclContext context, +#pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. + internal void AddCustomAttributeApplication( + ImmutableArray.Builder attributes, CILParser.CustomAttrDeclContext attribute) - { - Debug.Assert(_parameterDirectiveFrames.Count > 0); - if (_parameterDirectiveFrames.Count == 0) - { - return; - } - - ParameterDirectiveFrame frame = _parameterDirectiveFrames.Peek(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - if (ReferenceEquals(frame.Owner, context)) - { - frame.CustomAttributes.Add(attribute); - } - } + => attributes.Add(new( + attribute.Value, + attribute.Start, + attribute.HasSyntaxError)); +#pragma warning restore CA1822 - internal void EndParameterDirective(CILParser.ParameterDeclContext context) + internal void EndParameterDirective( + CILParser.ParameterDeclContext context, + ImmutableArray attributes, + int initialSyntaxErrorCount) { - ParameterDirectiveFrame? frame = null; - Debug.Assert(_parameterDirectiveFrames.Count > 0); - if (_parameterDirectiveFrames.Count > 0 && - ReferenceEquals(_parameterDirectiveFrames.Peek().Owner, context)) - { - frame = _parameterDirectiveFrames.Pop(); - } - - bool hasSyntaxError = EndSemanticRoot(context); - if (hasSyntaxError || frame is null || _currentMethod is null) + bool hasSyntaxError = + HasSyntaxErrorsSince(initialSyntaxErrorCount) || + context.exception is not null; + if (hasSyntaxError || _currentMethod is null) { return; } @@ -189,7 +188,7 @@ internal void EndParameterDirective(CILParser.ParameterDeclContext context) context); if (parameter is not null) { - ApplyCustomAttributes(frame.CustomAttributes, parameter); + ApplyCustomAttributes(attributes, parameter); } return; @@ -207,7 +206,7 @@ internal void EndParameterDirective(CILParser.ParameterDeclContext context) } EntityRegistry.TypeEntity baseType = - ResolveTypeSpecification(GetTypeSpecificationValue(context.constraintType.Value)); + ResolveTypeSpecification(context.constraintType.Value); EntityRegistry.GenericParameterConstraintEntity? constraint = parameter.Constraints.FirstOrDefault(candidate => candidate.BaseType == baseType); if (constraint is null) @@ -218,7 +217,7 @@ internal void EndParameterDirective(CILParser.ParameterDeclContext context) _currentMethod.Definition.GenericParameterConstraints.Add(constraint); } - ApplyCustomAttributes(frame.CustomAttributes, constraint); + ApplyCustomAttributes(attributes, constraint); return; } @@ -238,16 +237,22 @@ internal void EndParameterDirective(CILParser.ParameterDeclContext context) } EntityRegistry.ParameterEntity parameterEntity = _currentMethod.Definition.Parameters[index]; - object? constantValue = GetInitializerValue(context.initializer); - if (constantValue is not NoConstantSentinel) + FieldInitializerValue initializer = GetInitializerValue(context.initializer); + if (initializer.HasValue) { - parameterEntity.ConstantValue = constantValue; + parameterEntity.ConstantValue = initializer.ConstantValue; parameterEntity.HasConstant = true; } - foreach (CILParser.CustomAttrDeclContext attributeContext in frame.CustomAttributes) + foreach (CustomAttributeApplicationValue application in attributes) { - EntityRegistry.CustomAttributeEntity? attribute = MaterializeCustomAttributeDeclaration(attributeContext); + if (application.HasSyntaxError) + { + continue; + } + + EntityRegistry.CustomAttributeEntity? attribute = + MaterializeCustomAttributeDeclaration(application.Value, application.Location); if (attribute is not null) { attribute.Owner = parameterEntity; @@ -291,12 +296,18 @@ internal void EndParameterDirective(CILParser.ParameterDeclContext context) } private void ApplyCustomAttributes( - List attributeContexts, + ImmutableArray attributes, EntityRegistry.EntityBase owner) { - foreach (CILParser.CustomAttrDeclContext attributeContext in attributeContexts) + foreach (CustomAttributeApplicationValue application in attributes) { - EntityRegistry.CustomAttributeEntity? attribute = MaterializeCustomAttributeDeclaration(attributeContext); + if (application.HasSyntaxError) + { + continue; + } + + EntityRegistry.CustomAttributeEntity? attribute = + MaterializeCustomAttributeDeclaration(application.Value, application.Location); if (attribute is not null) { attribute.Owner = owner; diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.ExceptionHandling.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.ExceptionHandling.cs index 601a1cf32e1752..0eae6e73499c88 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.ExceptionHandling.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.ExceptionHandling.cs @@ -15,19 +15,16 @@ namespace ILAssembler; internal sealed partial class GrammarActions { private readonly Dictionary _scopeRanges = new(); + // Method scopes nest while IL and local declarations are emitted, so their live offsets and + // local-scope depth must be restored when each lexical scope exits. private readonly Stack _scopeStack = new(); private RuleContext? _methodOwner; private void EndMethod() { Debug.Assert( - _scopeStack.Count == 0 && - _parameterDirectiveFrames.Count == 0 && - _exceptionBlockFrames.Count == 0 && - _exceptionClauseListFrames.Count == 0 && - _catchClauseFrames.Count == 0 && - _semanticRootFrames.Count == 0, - "Method-body frames must be released by their owning rules."); + _scopeStack.Count == 0, + "Lexical scope state must be released by its owning rule."); _methodOwner = null; if (_currentMethod is not null) @@ -59,10 +56,6 @@ private void ResetMethodBodyState() { _scopeRanges.Clear(); _scopeStack.Clear(); - _parameterDirectiveFrames.Clear(); - _exceptionBlockFrames.Clear(); - _exceptionClauseListFrames.Clear(); - _catchClauseFrames.Clear(); } internal void BeginScope(CILParser.ScopeBlockContext context) @@ -92,21 +85,12 @@ internal void EndScope(CILParser.ScopeBlockContext context) _scopeRanges[context] = (frame.Start, CurrentMethodBodyOffset); } - internal void BeginExceptionBlock(CILParser.SehBlockContext context) - => _exceptionBlockFrames.Push(new(context, _syntaxErrorCount)); - - internal void EndExceptionBlock(CILParser.SehBlockContext context) + internal void EndExceptionBlock( + CILParser.SehBlockContext context, + int initialSyntaxErrorCount) { - Debug.Assert(_exceptionBlockFrames.Count > 0); - if (_exceptionBlockFrames.Count == 0 || - !ReferenceEquals(_exceptionBlockFrames.Peek().Owner, context)) - { - return; - } - - ExceptionBlockFrame frame = _exceptionBlockFrames.Pop(); if (_currentMethod is null || - frame.InitialSyntaxErrorCount != _syntaxErrorCount || + HasSyntaxErrorsSince(initialSyntaxErrorCount) || context.exception is not null || context.tryRange is null || context.clauses is null) @@ -114,14 +98,14 @@ context.tryRange is null || return; } - ExceptionRangeValue tryRangeValue = GetExceptionRangeValue(context.tryRange.Value); + ExceptionRangeValue tryRangeValue = context.tryRange.Value; (LabelHandle Start, LabelHandle End)? tryRange = ResolveExceptionRange(tryRangeValue); if (tryRange is null) { return; } - foreach (ExceptionClauseValue clause in GetExceptionClausesValue(context.clauses.Value)) + foreach (ExceptionClauseValue clause in context.clauses.Value) { (LabelHandle Start, LabelHandle End)? handlerRange = ResolveExceptionRange(clause.Handler); if (handlerRange is null) @@ -166,52 +150,12 @@ when ResolveExceptionFilter(filterClause.Filter) is LabelHandle filterStart: } } - internal void BeginExceptionClauses(CILParser.SehClausesContext context) - => _exceptionClauseListFrames.Push(new(context)); - - internal void AddExceptionClause(CILParser.SehClausesContext context, object? clause) - { - Debug.Assert(_exceptionClauseListFrames.Count > 0); - if (_exceptionClauseListFrames.Count == 0) - { - return; - } - - ExceptionClauseListFrame frame = _exceptionClauseListFrames.Peek(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - if (ReferenceEquals(frame.Owner, context)) - { - frame.Clauses.Add(GetExceptionClauseValue(clause)); - } - } - - internal object EndExceptionClauses(CILParser.SehClausesContext context) + internal CatchTypeValue EndCatchClause( + CILParser.CatchClauseContext context, + int initialSyntaxErrorCount) { - Debug.Assert(_exceptionClauseListFrames.Count > 0); - if (_exceptionClauseListFrames.Count == 0 || - !ReferenceEquals(_exceptionClauseListFrames.Peek().Owner, context)) - { - return ImmutableArray.Empty; - } - - return _exceptionClauseListFrames.Pop().Clauses.ToImmutable(); - } - - internal void BeginCatchClause(CILParser.CatchClauseContext context) - => _catchClauseFrames.Push(new(context, _syntaxErrorCount)); - - internal object EndCatchClause(CILParser.CatchClauseContext context) - { - Debug.Assert(_catchClauseFrames.Count > 0); - if (_catchClauseFrames.Count == 0 || - !ReferenceEquals(_catchClauseFrames.Peek().Owner, context)) - { - return CatchTypeValue.Invalid; - } - - CatchClauseFrame frame = _catchClauseFrames.Pop(); if (_currentMethod is null || - frame.InitialSyntaxErrorCount != _syntaxErrorCount || + HasSyntaxErrorsSince(initialSyntaxErrorCount) || context.exception is not null || context.catchType is null || context.catchType.HasSyntaxError) @@ -220,43 +164,47 @@ context.catchType is null || } EntityRegistry.TypeEntity catchType = - ResolveTypeSpecification(GetTypeSpecificationValue(context.catchType.Value)); - return new CatchTypeValue(catchType, IsValid: true); + ResolveTypeSpecification(context.catchType.Value); + return new CatchTypeValue(catchType, isValid: true); } - internal object CreateScopeExceptionRange(CILParser.ScopeBlockContext scope) + internal ExceptionRangeValue CreateScopeExceptionRange(CILParser.ScopeBlockContext scope) => new ScopeExceptionRangeValue(scope); - internal object CreateLabelExceptionRange(IToken start, IToken end) + internal ExceptionRangeValue CreateLabelExceptionRange(IToken start, IToken end) => new LabelExceptionRangeValue(ParseIdentifier(start), ParseIdentifier(end)); - internal object CreateOffsetExceptionRange(IToken start, IToken end) + internal ExceptionRangeValue CreateOffsetExceptionRange(IToken start, IToken end) => new OffsetExceptionRangeValue(ParseInt32(start), ParseInt32(end)); - internal object CreateScopeFilter(CILParser.ScopeBlockContext scope) + internal ExceptionFilterValue CreateScopeFilter(CILParser.ScopeBlockContext scope) => new ScopeExceptionFilterValue(scope); - internal object CreateLabelFilter(IToken label) + internal ExceptionFilterValue CreateLabelFilter(IToken label) => new LabelExceptionFilterValue(ParseIdentifier(label)); - internal object CreateOffsetFilter(IToken offset) + internal ExceptionFilterValue CreateOffsetFilter(IToken offset) => new OffsetExceptionFilterValue(ParseInt32(offset)); - internal object CreateCatchExceptionClause(object? catchType, object? handler) + internal ExceptionClauseValue CreateCatchExceptionClause( + CatchTypeValue catchType, + ExceptionRangeValue handler) => new CatchExceptionClauseValue( - GetCatchTypeValue(catchType), - GetExceptionRangeValue(handler)); + catchType, + handler); - internal object CreateFilterExceptionClause(object? filter, object? handler) + internal ExceptionClauseValue CreateFilterExceptionClause( + ExceptionFilterValue filter, + ExceptionRangeValue handler) => new FilterExceptionClauseValue( - GetExceptionFilterValue(filter), - GetExceptionRangeValue(handler)); + filter, + handler); - internal object CreateFinallyExceptionClause(object? handler) - => new FinallyExceptionClauseValue(GetExceptionRangeValue(handler)); + internal ExceptionClauseValue CreateFinallyExceptionClause(ExceptionRangeValue handler) + => new FinallyExceptionClauseValue(handler); - internal object CreateFaultExceptionClause(object? handler) - => new FaultExceptionClauseValue(GetExceptionRangeValue(handler)); + internal ExceptionClauseValue CreateFaultExceptionClause(ExceptionRangeValue handler) + => new FaultExceptionClauseValue(handler); private void AddExceptionRegion(EntityRegistry.ExceptionRegion region) { diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.Values.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.Values.cs deleted file mode 100644 index 680d94cbb8f8e0..00000000000000 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodBodies.Values.cs +++ /dev/null @@ -1,121 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Collections.Generic; -using System.Collections.Immutable; - -namespace ILAssembler; - -internal sealed partial class GrammarActions -{ - private readonly Stack _parameterDirectiveFrames = new(); - private readonly Stack _exceptionBlockFrames = new(); - private readonly Stack _exceptionClauseListFrames = new(); - private readonly Stack _catchClauseFrames = new(); - - private sealed class ParameterDirectiveFrame - { - public ParameterDirectiveFrame(CILParser.ParameterDeclContext owner) - { - Owner = owner; - } - - public CILParser.ParameterDeclContext Owner { get; } - - public List CustomAttributes { get; } = new(); - } - - private abstract record ExceptionRangeValue - { - public static ExceptionRangeValue Invalid { get; } = new InvalidExceptionRangeValue(); - } - - private sealed record InvalidExceptionRangeValue : ExceptionRangeValue; - - private sealed record ScopeExceptionRangeValue(CILParser.ScopeBlockContext Scope) : ExceptionRangeValue; - - private sealed record LabelExceptionRangeValue(string Start, string End) : ExceptionRangeValue; - - private sealed record OffsetExceptionRangeValue(int Start, int End) : ExceptionRangeValue; - - private abstract record ExceptionFilterValue - { - public static ExceptionFilterValue Invalid { get; } = new InvalidExceptionFilterValue(); - } - - private sealed record InvalidExceptionFilterValue : ExceptionFilterValue; - - private sealed record ScopeExceptionFilterValue(CILParser.ScopeBlockContext Scope) : ExceptionFilterValue; - - private sealed record LabelExceptionFilterValue(string Label) : ExceptionFilterValue; - - private sealed record OffsetExceptionFilterValue(int Offset) : ExceptionFilterValue; - - private sealed record CatchTypeValue(EntityRegistry.TypeEntity? Type, bool IsValid) - { - public static CatchTypeValue Invalid { get; } = new(null, IsValid: false); - } - - private abstract record ExceptionClauseValue(ExceptionRangeValue Handler) - { - public static ExceptionClauseValue Invalid { get; } = - new InvalidExceptionClauseValue(ExceptionRangeValue.Invalid); - } - - private sealed record InvalidExceptionClauseValue(ExceptionRangeValue Handler) - : ExceptionClauseValue(Handler); - - private sealed record CatchExceptionClauseValue( - CatchTypeValue CatchType, - ExceptionRangeValue Handler) - : ExceptionClauseValue(Handler); - - private sealed record FilterExceptionClauseValue( - ExceptionFilterValue Filter, - ExceptionRangeValue Handler) - : ExceptionClauseValue(Handler); - - private sealed record FinallyExceptionClauseValue(ExceptionRangeValue Handler) - : ExceptionClauseValue(Handler); - - private sealed record FaultExceptionClauseValue(ExceptionRangeValue Handler) - : ExceptionClauseValue(Handler); - - private sealed record ExceptionBlockFrame( - CILParser.SehBlockContext Owner, - int InitialSyntaxErrorCount); - - private sealed class ExceptionClauseListFrame - { - public ExceptionClauseListFrame(CILParser.SehClausesContext owner) - { - Owner = owner; - } - - public CILParser.SehClausesContext Owner { get; } - - public ImmutableArray.Builder Clauses { get; } = - ImmutableArray.CreateBuilder(); - } - - private sealed record CatchClauseFrame( - CILParser.CatchClauseContext Owner, - int InitialSyntaxErrorCount); - - private static ExceptionRangeValue GetExceptionRangeValue(object? value) - => value as ExceptionRangeValue ?? ExceptionRangeValue.Invalid; - - private static ExceptionFilterValue GetExceptionFilterValue(object? value) - => value as ExceptionFilterValue ?? ExceptionFilterValue.Invalid; - - private static CatchTypeValue GetCatchTypeValue(object? value) - => value as CatchTypeValue ?? CatchTypeValue.Invalid; - - private static ExceptionClauseValue GetExceptionClauseValue(object? value) - => value as ExceptionClauseValue ?? ExceptionClauseValue.Invalid; - - private static ImmutableArray GetExceptionClausesValue(object? value) - => value is ImmutableArray clauses - ? clauses - : ImmutableArray.Empty; -} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.Actions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.Actions.cs index ec4e8ae65163f6..f991564482e2be 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.Actions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.Actions.cs @@ -1,7 +1,6 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System.Collections.Generic; using System.Collections.Immutable; using System.Diagnostics; using System.Reflection; @@ -12,130 +11,40 @@ namespace ILAssembler; #pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. internal sealed partial class GrammarActions { - private readonly Stack _methodHeaderFrames = new(); - private readonly Stack _pInvokeFrames = new(); - private readonly Stack _genericTypeListFrames = new(); - private readonly Stack _genericParameterAttributesFrames = new(); - private readonly Stack _genericParametersFrames = new(); - - private sealed class MethodHeaderFrame - { - public MethodHeaderFrame(CILParser.MethodHeadContext owner, int initialSyntaxErrorCount) - { - Owner = owner; - InitialSyntaxErrorCount = initialSyntaxErrorCount; - } - - public CILParser.MethodHeadContext Owner { get; } - - public int InitialSyntaxErrorCount { get; } - - public MethodAttributes Attributes { get; set; } - - public ImmutableArray.Builder PInvokes { get; } = - ImmutableArray.CreateBuilder(); - - public MethodImplAttributes ImplementationAttributes { get; set; } - } - - private sealed class PInvokeFrame - { - public PInvokeFrame(CILParser.PinvImplContext owner) - { - Owner = owner; - } - - public CILParser.PinvImplContext Owner { get; } - - public string? ModuleName { get; set; } - - public string? EntryPointName { get; set; } - - public MethodImportAttributes Attributes { get; set; } - } - - private sealed class GenericTypeListFrame - { - public GenericTypeListFrame(CILParser.TypeListContext owner) - { - Owner = owner; - } - - public CILParser.TypeListContext Owner { get; } - - public ImmutableArray.Builder Types { get; } = - ImmutableArray.CreateBuilder(); - } - - private sealed class GenericParameterAttributesFrame - { - public GenericParameterAttributesFrame(CILParser.TyparAttribsContext owner) - { - Owner = owner; - } - - public CILParser.TyparAttribsContext Owner { get; } - - public GenericParameterAttributes Attributes { get; set; } - } - - private sealed class GenericParametersFrame - { - public GenericParametersFrame(CILParser.TyparsContext owner) - { - Owner = owner; - } - - public CILParser.TyparsContext Owner { get; } - - public ImmutableArray.Builder Parameters { get; } = - ImmutableArray.CreateBuilder(); - } - - internal void BeginMethodHeader(CILParser.MethodHeadContext context) + internal CILParser.MethodHeaderBuilder PrepareMethodHeader() { ClearPendingCustomAttributeOwners(); - _methodHeaderFrames.Push(new(context, _syntaxErrorCount)); + return new CILParser.MethodHeaderBuilder(); } - internal void AddMethodAttribute(CILParser.MethodHeadContext context, object? value) - { - if (TryGetMethodHeaderFrame(context) is { } frame) - { - frame.Attributes = ApplyAttribute(frame.Attributes, GetAttributeValue(value)); - } - } - internal void AddPInvoke(CILParser.MethodHeadContext context, object? value) - { - if (TryGetMethodHeaderFrame(context) is { } frame) - { - frame.PInvokes.Add(GetPInvokeValue(value)); - } - } + internal void AddMethodAttribute( + CILParser.MethodHeaderBuilder builder, + CILParser.AttributeValue value) + => builder.Attributes = ApplyAttribute(builder.Attributes, value); - internal void AddMethodImplementationAttribute(CILParser.MethodHeadContext context, object? value) - { - if (TryGetMethodHeaderFrame(context) is { } frame) - { - frame.ImplementationAttributes = ApplyAttribute( - frame.ImplementationAttributes, - GetAttributeValue(value)); - } - } + internal void AddPInvoke(CILParser.MethodHeaderBuilder builder, PInvokeValue value) + => builder.PInvokes.Add(value); + + internal void AddMethodImplementationAttribute( + CILParser.MethodHeaderBuilder builder, + CILParser.AttributeValue value) + => builder.ImplementationAttributes = ApplyAttribute( + builder.ImplementationAttributes, + value); - internal object CreateMethodHeader( + internal MethodHeaderValue CreateMethodHeader( CILParser.MethodHeadContext context, + CILParser.MethodHeaderBuilder builder, + int initialSyntaxErrorCount, byte callingConvention, int returnAttributes, - object? returnType, - object? returnMarshalling, + TypeValue returnType, + MarshallingDescriptorValue returnMarshalling, string name, - object? genericParameters, - object? arguments) + ImmutableArray genericParameters, + ImmutableArray arguments) { - MethodHeaderFrame? frame = TryGetMethodHeaderFrame(context); - if (frame is null || - frame.InitialSyntaxErrorCount != _syntaxErrorCount || + if (HasSyntaxErrorsSince(initialSyntaxErrorCount) || context.exception is not null) { return MethodHeaderValue.Error; @@ -143,424 +52,256 @@ internal object CreateMethodHeader( return new MethodHeaderValue( true, - frame.Attributes, - frame.PInvokes.ToImmutable(), + builder.Attributes, + builder.PInvokes.ToImmutable(), callingConvention, returnAttributes, - GetTypeValue(returnType), - GetMarshallingDescriptorValue(returnMarshalling), + returnType, + returnMarshalling, name, - GetGenericParameterDeclarations(genericParameters), - GetSignatureArgumentsValue(arguments), - frame.ImplementationAttributes); + genericParameters, + arguments, + builder.ImplementationAttributes); } - internal void EndMethodHeader(CILParser.MethodHeadContext context) - { - if (_methodHeaderFrames.Count == 0) - { - return; - } - - MethodHeaderFrame frame = _methodHeaderFrames.Peek(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - if (ReferenceEquals(frame.Owner, context)) - { - _methodHeaderFrames.Pop(); - } - } - - internal object CreateMethodAttribute(IToken token) + internal CILParser.AttributeValue CreateMethodAttribute(IToken token) => token.Text switch { - "static" => new AttributeValue(MethodAttributes.Static, 0, true), - "public" => new AttributeValue( + "static" => new CILParser.AttributeValue(MethodAttributes.Static, 0, true), + "public" => new CILParser.AttributeValue( MethodAttributes.Public, MethodAttributes.MemberAccessMask, true), - "private" => new AttributeValue( + "private" => new CILParser.AttributeValue( MethodAttributes.Private, MethodAttributes.MemberAccessMask, true), - "family" => new AttributeValue( + "family" => new CILParser.AttributeValue( MethodAttributes.Family, MethodAttributes.MemberAccessMask, true), - "final" => new AttributeValue(MethodAttributes.Final, 0, true), - "specialname" => new AttributeValue(MethodAttributes.SpecialName, 0, true), - "virtual" => new AttributeValue(MethodAttributes.Virtual, 0, true), - "strict" => new AttributeValue( + "final" => new CILParser.AttributeValue(MethodAttributes.Final, 0, true), + "specialname" => new CILParser.AttributeValue(MethodAttributes.SpecialName, 0, true), + "virtual" => new CILParser.AttributeValue(MethodAttributes.Virtual, 0, true), + "strict" => new CILParser.AttributeValue( MethodAttributes.CheckAccessOnOverride, 0, true), - "abstract" => new AttributeValue(MethodAttributes.Abstract, 0, true), - "assembly" => new AttributeValue( + "abstract" => new CILParser.AttributeValue(MethodAttributes.Abstract, 0, true), + "assembly" => new CILParser.AttributeValue( MethodAttributes.Assembly, MethodAttributes.MemberAccessMask, true), - "famandassem" => new AttributeValue( + "famandassem" => new CILParser.AttributeValue( MethodAttributes.FamANDAssem, MethodAttributes.MemberAccessMask, true), - "famorassem" => new AttributeValue( + "famorassem" => new CILParser.AttributeValue( MethodAttributes.FamORAssem, MethodAttributes.MemberAccessMask, true), - "privatescope" => new AttributeValue( + "privatescope" => new CILParser.AttributeValue( MethodAttributes.PrivateScope, MethodAttributes.MemberAccessMask, true), - "hidebysig" => new AttributeValue(MethodAttributes.HideBySig, 0, true), - "newslot" => new AttributeValue(MethodAttributes.NewSlot, 0, true), - "rtspecialname" => new AttributeValue(MethodAttributes.RTSpecialName, 0, true), - "unmanagedexp" => new AttributeValue(MethodAttributes.UnmanagedExport, 0, true), - "reqsecobj" => new AttributeValue(MethodAttributes.RequireSecObject, 0, true), + "hidebysig" => new CILParser.AttributeValue(MethodAttributes.HideBySig, 0, true), + "newslot" => new CILParser.AttributeValue(MethodAttributes.NewSlot, 0, true), + "rtspecialname" => new CILParser.AttributeValue(MethodAttributes.RTSpecialName, 0, true), + "unmanagedexp" => new CILParser.AttributeValue(MethodAttributes.UnmanagedExport, 0, true), + "reqsecobj" => new CILParser.AttributeValue(MethodAttributes.RequireSecObject, 0, true), _ => throw new UnreachableException(), }; - internal object CreateRawMethodAttribute(IToken token) - => new AttributeValue((MethodAttributes)ParseInt32(token), 0, false); + internal CILParser.AttributeValue CreateRawMethodAttribute(IToken token) + => new((MethodAttributes)ParseInt32(token), 0, false); - internal object CreateMethodImplementationAttribute(IToken token) + internal CILParser.AttributeValue + CreateMethodImplementationAttribute(IToken token) => token.Text switch { - "native" => new AttributeValue( + "native" => new CILParser.AttributeValue( MethodImplAttributes.Native, MethodImplAttributes.CodeTypeMask, true), - "cil" or "il" => new AttributeValue( + "cil" or "il" => new CILParser.AttributeValue( MethodImplAttributes.IL, MethodImplAttributes.CodeTypeMask, true), - "optil" => new AttributeValue( + "optil" => new CILParser.AttributeValue( MethodImplAttributes.OPTIL, MethodImplAttributes.CodeTypeMask, true), - "managed" => new AttributeValue( + "managed" => new CILParser.AttributeValue( MethodImplAttributes.Managed, MethodImplAttributes.ManagedMask, true), - "unmanaged" => new AttributeValue( + "unmanaged" => new CILParser.AttributeValue( MethodImplAttributes.Unmanaged, MethodImplAttributes.ManagedMask, true), - "forwardref" => new AttributeValue(MethodImplAttributes.ForwardRef, 0, true), - "preservesig" => new AttributeValue(MethodImplAttributes.PreserveSig, 0, true), - "runtime" => new AttributeValue( + "forwardref" => new CILParser.AttributeValue(MethodImplAttributes.ForwardRef, 0, true), + "preservesig" => new CILParser.AttributeValue(MethodImplAttributes.PreserveSig, 0, true), + "runtime" => new CILParser.AttributeValue( MethodImplAttributes.Runtime, MethodImplAttributes.CodeTypeMask, true), - "internalcall" => new AttributeValue(MethodImplAttributes.InternalCall, 0, true), - "synchronized" => new AttributeValue(MethodImplAttributes.Synchronized, 0, true), - "noinlining" => new AttributeValue(MethodImplAttributes.NoInlining, 0, true), - "aggressiveinlining" => new AttributeValue( + "internalcall" => new CILParser.AttributeValue(MethodImplAttributes.InternalCall, 0, true), + "synchronized" => new CILParser.AttributeValue(MethodImplAttributes.Synchronized, 0, true), + "noinlining" => new CILParser.AttributeValue(MethodImplAttributes.NoInlining, 0, true), + "aggressiveinlining" => new CILParser.AttributeValue( MethodImplAttributes.AggressiveInlining, 0, true), - "nooptimization" => new AttributeValue(MethodImplAttributes.NoOptimization, 0, true), - "aggressiveoptimization" => new AttributeValue( + "nooptimization" => new CILParser.AttributeValue(MethodImplAttributes.NoOptimization, 0, true), + "aggressiveoptimization" => new CILParser.AttributeValue( MethodImplAttributes.AggressiveOptimization, 0, true), - "async" => new AttributeValue(MethodImplAttributes.Async, 0, true), + "async" => new CILParser.AttributeValue(MethodImplAttributes.Async, 0, true), _ => throw new UnreachableException(), }; - internal object CreateRawMethodImplementationAttribute(IToken token) - => new AttributeValue((MethodImplAttributes)ParseInt32(token), 0, false); + internal CILParser.AttributeValue + CreateRawMethodImplementationAttribute(IToken token) + => new((MethodImplAttributes)ParseInt32(token), 0, false); - internal void BeginPInvoke(CILParser.PinvImplContext context) - => _pInvokeFrames.Push(new(context)); + internal void SetPInvokeModule(CILParser.PInvokeBuilder builder, string moduleName) + => builder.ModuleName = moduleName; - internal void SetPInvokeModule(CILParser.PinvImplContext context, string moduleName) - { - if (TryGetPInvokeFrame(context) is { } frame) - { - frame.ModuleName = moduleName; - } - } + internal void SetPInvokeEntryPoint( + CILParser.PInvokeBuilder builder, + string entryPointName) + => builder.EntryPointName = entryPointName; - internal void SetPInvokeEntryPoint(CILParser.PinvImplContext context, string entryPointName) - { - if (TryGetPInvokeFrame(context) is { } frame) - { - frame.EntryPointName = entryPointName; - } - } + internal void AddPInvokeAttribute( + CILParser.PInvokeBuilder builder, + CILParser.AttributeValue value) + => builder.Attributes = ApplyAttribute(builder.Attributes, value); - internal void AddPInvokeAttribute(CILParser.PinvImplContext context, object? value) - { - if (TryGetPInvokeFrame(context) is { } frame) - { - frame.Attributes = ApplyAttribute( - frame.Attributes, - GetAttributeValue(value)); - } - } - - internal object EndPInvoke(CILParser.PinvImplContext context) - { - if (_pInvokeFrames.Count == 0) - { - return new PInvokeValue(null, null, 0); - } - - PInvokeFrame frame = _pInvokeFrames.Peek(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - if (!ReferenceEquals(frame.Owner, context)) - { - return new PInvokeValue(null, null, 0); - } + internal PInvokeValue CreatePInvoke(CILParser.PInvokeBuilder builder) + => new(builder.ModuleName, builder.EntryPointName, builder.Attributes); - _pInvokeFrames.Pop(); - return new PInvokeValue(frame.ModuleName, frame.EntryPointName, frame.Attributes); - } - - internal object CreatePInvokeAttribute(IToken token) + internal CILParser.AttributeValue + CreatePInvokeAttribute(IToken token) => token.Text switch { - "nomangle" => new AttributeValue( + "nomangle" => new CILParser.AttributeValue( MethodImportAttributes.ExactSpelling, 0, true), - "ansi" => new AttributeValue( + "ansi" => new CILParser.AttributeValue( MethodImportAttributes.CharSetAnsi, 0, true), - "unicode" => new AttributeValue( + "unicode" => new CILParser.AttributeValue( MethodImportAttributes.CharSetUnicode, 0, true), - "autochar" => new AttributeValue( + "autochar" => new CILParser.AttributeValue( MethodImportAttributes.CharSetAuto, 0, true), - "lasterr" => new AttributeValue( + "lasterr" => new CILParser.AttributeValue( MethodImportAttributes.SetLastError, 0, true), - "winapi" => new AttributeValue( + "winapi" => new CILParser.AttributeValue( MethodImportAttributes.CallingConventionWinApi, 0, true), - "cdecl" => new AttributeValue( + "cdecl" => new CILParser.AttributeValue( MethodImportAttributes.CallingConventionCDecl, 0, true), - "stdcall" => new AttributeValue( + "stdcall" => new CILParser.AttributeValue( MethodImportAttributes.CallingConventionStdCall, 0, true), - "thiscall" => new AttributeValue( + "thiscall" => new CILParser.AttributeValue( MethodImportAttributes.CallingConventionThisCall, 0, true), - "fastcall" => new AttributeValue( + "fastcall" => new CILParser.AttributeValue( MethodImportAttributes.CallingConventionFastCall, 0, true), _ => throw new UnreachableException(), }; - internal object CreateBestFitPInvokeAttribute(IToken setting) - => new AttributeValue( + internal CILParser.AttributeValue + CreateBestFitPInvokeAttribute(IToken setting) + => new( setting.Text == "on" ? MethodImportAttributes.BestFitMappingEnable : MethodImportAttributes.BestFitMappingDisable, 0, true); - internal object CreateCharMapErrorPInvokeAttribute(IToken setting) - => new AttributeValue( + internal CILParser.AttributeValue + CreateCharMapErrorPInvokeAttribute(IToken setting) + => new( setting.Text == "on" ? MethodImportAttributes.ThrowOnUnmappableCharEnable : MethodImportAttributes.ThrowOnUnmappableCharDisable, 0, true); - internal object CreateRawPInvokeAttribute(IToken token) - => new AttributeValue( + internal CILParser.AttributeValue + CreateRawPInvokeAttribute(IToken token) + => new( (MethodImportAttributes)ParseInt32(token), 0, false); - internal void BeginGenericTypeList(CILParser.TypeListContext context) - => _genericTypeListFrames.Push(new(context)); - - internal void AddGenericType(CILParser.TypeListContext context, object? value) - { - if (TryGetGenericTypeListFrame(context) is { } frame) - { - frame.Types.Add(GetTypeSpecificationValue(value)); - } - } - - internal object EndGenericTypeList(CILParser.TypeListContext context) - { - if (_genericTypeListFrames.Count == 0) - { - return ImmutableArray.Empty; - } - - GenericTypeListFrame frame = _genericTypeListFrames.Peek(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - if (!ReferenceEquals(frame.Owner, context)) - { - return ImmutableArray.Empty; - } - - _genericTypeListFrames.Pop(); - return frame.Types.ToImmutable(); - } - - internal object CreateEmptyGenericParameterList() - => ImmutableArray.Empty; - - internal object CreateGenericParameterAttribute(IToken token) + internal CILParser.AttributeValue + CreateGenericParameterAttribute(IToken token) => token.Text switch { - "+" => new AttributeValue( + "+" => new CILParser.AttributeValue( GenericParameterAttributes.Covariant, 0, true), - "-" => new AttributeValue( + "-" => new CILParser.AttributeValue( GenericParameterAttributes.Contravariant, 0, true), - "class" => new AttributeValue( + "class" => new CILParser.AttributeValue( GenericParameterAttributes.ReferenceTypeConstraint, 0, true), - "valuetype" => new AttributeValue( + "valuetype" => new CILParser.AttributeValue( GenericParameterAttributes.NotNullableValueTypeConstraint, 0, true), - "byreflike" => new AttributeValue( + "byreflike" => new CILParser.AttributeValue( GenericParameterAttributes.AllowByRefLike, 0, true), - ".ctor" => new AttributeValue( + ".ctor" => new CILParser.AttributeValue( GenericParameterAttributes.DefaultConstructorConstraint, 0, true), _ => throw new UnreachableException(), }; - internal object CreateRawGenericParameterAttribute(IToken token) - => new AttributeValue( + internal CILParser.AttributeValue + CreateRawGenericParameterAttribute(IToken token) + => new( (GenericParameterAttributes)ParseInt32(token), 0, true); - internal void BeginGenericParameterAttributes(CILParser.TyparAttribsContext context) - => _genericParameterAttributesFrames.Push(new(context)); - - internal void AddGenericParameterAttribute(CILParser.TyparAttribsContext context, object? value) - { - if (TryGetGenericParameterAttributesFrame(context) is { } frame) - { - frame.Attributes = ApplyAttribute( - frame.Attributes, - GetAttributeValue(value)); - } - } - - internal object EndGenericParameterAttributes(CILParser.TyparAttribsContext context) - { - if (_genericParameterAttributesFrames.Count == 0) - { - return new AttributeValue(0, 0, true); - } + internal GenericParameterAttributes AddGenericParameterAttribute( + GenericParameterAttributes attributes, + CILParser.AttributeValue value) + => ApplyAttribute(attributes, value); - GenericParameterAttributesFrame frame = _genericParameterAttributesFrames.Peek(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - if (!ReferenceEquals(frame.Owner, context)) - { - return new AttributeValue(0, 0, true); - } - - _genericParameterAttributesFrames.Pop(); - return new AttributeValue(frame.Attributes, 0, true); - } - - internal object CreateGenericParameterDeclaration( - object? attributes, + internal GenericParameterDeclarationValue CreateGenericParameterDeclaration( + GenericParameterAttributes attributes, CILParser.TyBoundContext? constraints, string name) => new GenericParameterDeclarationValue( - GetAttributeValue(attributes).Value, + attributes, name, - constraints?.Value is ImmutableArray types ? types : []); - - internal void BeginGenericParameters(CILParser.TyparsContext context) - => _genericParametersFrames.Push(new(context)); - - internal void AddGenericParameter(CILParser.TyparsContext context, object? value) - { - if (TryGetGenericParametersFrame(context) is { } frame) - { - frame.Parameters.Add(GetGenericParameterDeclaration(value)); - } - } - - internal object EndGenericParameters(CILParser.TyparsContext context) - { - if (_genericParametersFrames.Count == 0) - { - return ImmutableArray.Empty; - } - - GenericParametersFrame frame = _genericParametersFrames.Peek(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - if (!ReferenceEquals(frame.Owner, context)) - { - return ImmutableArray.Empty; - } - - _genericParametersFrames.Pop(); - return frame.Parameters.ToImmutable(); - } - - private MethodHeaderFrame? TryGetMethodHeaderFrame(CILParser.MethodHeadContext context) - { - Debug.Assert(_methodHeaderFrames.Count > 0); - MethodHeaderFrame? frame = _methodHeaderFrames.Count == 0 ? null : _methodHeaderFrames.Peek(); - Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); - return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; - } - - private PInvokeFrame? TryGetPInvokeFrame(CILParser.PinvImplContext context) - { - Debug.Assert(_pInvokeFrames.Count > 0); - PInvokeFrame? frame = _pInvokeFrames.Count == 0 ? null : _pInvokeFrames.Peek(); - Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); - return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; - } - - private GenericTypeListFrame? TryGetGenericTypeListFrame(CILParser.TypeListContext context) - { - Debug.Assert(_genericTypeListFrames.Count > 0); - GenericTypeListFrame? frame = _genericTypeListFrames.Count == 0 ? null : _genericTypeListFrames.Peek(); - Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); - return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; - } - - private GenericParameterAttributesFrame? TryGetGenericParameterAttributesFrame( - CILParser.TyparAttribsContext context) - { - Debug.Assert(_genericParameterAttributesFrames.Count > 0); - GenericParameterAttributesFrame? frame = - _genericParameterAttributesFrames.Count == 0 ? null : _genericParameterAttributesFrames.Peek(); - Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); - return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; - } - - private GenericParametersFrame? TryGetGenericParametersFrame(CILParser.TyparsContext context) - { - Debug.Assert(_genericParametersFrames.Count > 0); - GenericParametersFrame? frame = - _genericParametersFrames.Count == 0 ? null : _genericParametersFrames.Peek(); - Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); - return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; - } + constraints?.Value ?? []); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.Values.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.Values.cs deleted file mode 100644 index 243f5e4f36556e..00000000000000 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.Values.cs +++ /dev/null @@ -1,80 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Collections.Immutable; -using System.Reflection; - -namespace ILAssembler; - -internal sealed partial class GrammarActions -{ - private sealed record AttributeValue(T Value, T GroupMask, bool ShouldAppend) - where T : struct, System.Enum; - - private sealed record PInvokeValue( - string? ModuleName, - string? EntryPointName, - MethodImportAttributes Attributes); - - private sealed record GenericParameterDeclarationValue( - GenericParameterAttributes Attributes, - string Name, - ImmutableArray Constraints); - - private sealed record MethodHeaderValue( - bool IsValid, - MethodAttributes Attributes, - ImmutableArray PInvokes, - byte CallingConvention, - int ReturnAttributes, - TypeValue ReturnType, - MarshallingDescriptorValue ReturnMarshalling, - string Name, - ImmutableArray GenericParameters, - ImmutableArray Arguments, - MethodImplAttributes ImplementationAttributes) - { - public static MethodHeaderValue Error { get; } = new( - false, - 0, - [], - 0, - 0, - TypeValue.Error, - GetMarshallingDescriptorValue(null), - string.Empty, - [], - [], - 0); - } - - private static AttributeValue GetAttributeValue(object? value) - where T : struct, System.Enum - => value as AttributeValue ?? new(default, default, true); - - private static T ApplyAttribute(T current, AttributeValue attribute) - where T : struct, System.Enum - { - if (!attribute.ShouldAppend) - { - return attribute.Value; - } - - int currentValue = System.Convert.ToInt32(current); - int groupMask = System.Convert.ToInt32(attribute.GroupMask); - int attributeValue = System.Convert.ToInt32(attribute.Value); - return (T)System.Enum.ToObject(typeof(T), (currentValue & ~groupMask) | attributeValue); - } - - private static ImmutableArray GetGenericParameterDeclarations(object? value) - => value is ImmutableArray parameters ? parameters : []; - - private static GenericParameterDeclarationValue GetGenericParameterDeclaration(object? value) - => value as GenericParameterDeclarationValue ?? new(0, string.Empty, []); - - private static MethodHeaderValue GetMethodHeaderValue(object? value) - => value as MethodHeaderValue ?? MethodHeaderValue.Error; - - private static PInvokeValue GetPInvokeValue(object? value) - => value as PInvokeValue ?? new(null, null, 0); -} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.cs index f8e7bafc9e5ada..0139a20ae29a97 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.MethodHeaders.cs @@ -9,15 +9,16 @@ namespace ILAssembler; internal sealed partial class GrammarActions { - internal void BeginMethod(CILParser.MethodHeadContext context, object? value) + internal void BeginMethod(CILParser.MethodHeadContext context, MethodHeaderValue value) { - MethodHeaderValue header = GetMethodHeaderValue(value); ResetMethodBodyState(); - if (!header.IsValid) + if (!value.IsValid) { return; } + MethodHeaderValue header = value; + EntityRegistry.TypeDefinitionEntity containingType = _currentTypeDefinition.PeekOrDefault() ?? _entityRegistry.ModuleType; EntityRegistry.MethodDefinitionEntity methodDefinition = diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs index 1048eb495b95a0..ae744749d7459b 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Security.cs @@ -1,7 +1,6 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System.Collections.Generic; using System.Collections.Immutable; using System.Diagnostics; using System.Reflection; @@ -13,72 +12,6 @@ namespace ILAssembler; #pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. internal sealed partial class GrammarActions { - private readonly Stack _securityAttributeSetFrames = new(); - private readonly Stack _securityNameValuePairFrames = new(); - - private abstract record SecurityDeclarationValue(DeclarativeSecurityAction Action); - - private sealed record PermissionDeclarationValue( - DeclarativeSecurityAction Action, - object PermissionType, - object? Value) : SecurityDeclarationValue(Action); - - private sealed record RawPermissionSetValue( - DeclarativeSecurityAction Action, - ImmutableArray Value) : SecurityDeclarationValue(Action); - - private sealed record StringPermissionSetValue( - DeclarativeSecurityAction Action, - string Value) : SecurityDeclarationValue(Action); - - private sealed record AttributePermissionSetValue( - DeclarativeSecurityAction Action, - ImmutableArray Attributes) : SecurityDeclarationValue(Action); - - private sealed record SecurityAttributeValue( - string? Name, - TypeSpecificationValue? Type, - ImmutableArray Arguments); - - private sealed record SecurityNameValuePairValue(string Name, SecurityCaValue Value); - - private abstract record SecurityCaValue; - - private sealed record SecurityBooleanValue(bool Value) : SecurityCaValue; - - private sealed record SecurityInt32Value(int Value) : SecurityCaValue; - - private sealed record SecurityStringValue(string Value) : SecurityCaValue; - - private sealed record SecurityEnumValue( - ClassNameValue Type, - byte Size, - int Value) : SecurityCaValue; - - private sealed class SecurityAttributeSetFrame - { - public SecurityAttributeSetFrame(CILParser.SecAttrSetBlobContext owner) - { - Owner = owner; - } - - public CILParser.SecAttrSetBlobContext Owner { get; } - - public ImmutableArray.Builder? Attributes { get; set; } - } - - private sealed class SecurityNameValuePairsFrame - { - public SecurityNameValuePairsFrame(CILParser.NameValPairsContext owner) - { - Owner = owner; - } - - public CILParser.NameValPairsContext Owner { get; } - - public ImmutableArray.Builder? Pairs { get; set; } - } - internal DeclarativeSecurityAction ParseSecurityAction(IToken token) => token.Text switch { @@ -100,131 +33,95 @@ internal DeclarativeSecurityAction ParseSecurityAction(IToken token) _ => throw new UnreachableException(), }; - internal object CreateNamedPermissionDeclaration( + internal SecurityDeclarationValue CreateNamedPermissionDeclaration( DeclarativeSecurityAction action, - object? permissionType, - object? pairs) - => new PermissionDeclarationValue( + TypeSpecificationValue permissionType, + ImmutableArray pairs) + => new NamedPermissionDeclarationValue( action, - GetTypeSpecificationValue(permissionType), + permissionType, pairs); - internal object CreateStructuredPermissionDeclaration( + internal SecurityDeclarationValue CreateStructuredPermissionDeclaration( DeclarativeSecurityAction action, - object? permissionType, - object? value) - => new PermissionDeclarationValue( + TypeSpecificationValue permissionType, + CustomAttributeBlobValue value) + => new StructuredPermissionDeclarationValue( action, - GetTypeSpecificationValue(permissionType), + permissionType, value); - internal object CreateEmptyPermissionDeclaration( + internal SecurityDeclarationValue CreateEmptyPermissionDeclaration( DeclarativeSecurityAction action, - object? permissionType) - => new PermissionDeclarationValue( + TypeSpecificationValue permissionType) + => new EmptyPermissionDeclarationValue( action, - GetTypeSpecificationValue(permissionType), - null); + permissionType); - internal object CreateRawPermissionSetDeclaration( + internal SecurityDeclarationValue CreateRawPermissionSetDeclaration( DeclarativeSecurityAction action, ImmutableArray value) => new RawPermissionSetValue(action, value); - internal object CreateStringPermissionSetDeclaration( + internal SecurityDeclarationValue CreateStringPermissionSetDeclaration( DeclarativeSecurityAction action, string value) => new StringPermissionSetValue(action, value); - internal object CreateAttributePermissionSetDeclaration( + internal SecurityDeclarationValue CreateAttributePermissionSetDeclaration( DeclarativeSecurityAction action, - object? value) - => new AttributePermissionSetValue(action, GetSecurityAttributes(value)); + ImmutableArray value) + => new AttributePermissionSetValue(action, value); - internal void EndSecurityDeclaration(CILParser.SecDeclContext context) + internal void EndSecurityDeclaration( + CILParser.SecDeclContext context, + int initialSyntaxErrorCount) { - context.HasSyntaxError = EndSemanticRoot(context); + context.HasSyntaxError = + HasSyntaxErrorsSince(initialSyntaxErrorCount) || + context.exception is not null; if (context.HasSyntaxError) { context.Value = null; } } - internal void BeginSecurityAttributeSet(CILParser.SecAttrSetBlobContext context) - => _securityAttributeSetFrames.Push(new(context)); - - internal void AddSecurityAttribute( - CILParser.SecAttrSetBlobContext context, - object? value) - { - if (TryGetSecurityAttributeSetFrame(context) is { } frame && - value is SecurityAttributeValue attribute) - { - (frame.Attributes ??= ImmutableArray.CreateBuilder()) - .Add(attribute); - } - } - - internal object EndSecurityAttributeSet(CILParser.SecAttrSetBlobContext context) - { - if (TryGetSecurityAttributeSetFrame(context) is not { } frame) - { - return ImmutableArray.Empty; - } - - _securityAttributeSetFrames.Pop(); - return frame.Attributes?.ToImmutable() ?? ImmutableArray.Empty; - } - - internal object CreateNamedSecurityAttribute(IToken name, object? arguments) + internal SecurityAttributeValue CreateNamedSecurityAttribute( + IToken name, + ImmutableArray arguments) => new SecurityAttributeValue( StringHelpers.ParseQuotedString(name.Text), null, - GetSecurityAttributeArguments(arguments)); + arguments); - internal object CreateTypedSecurityAttribute(object? type, object? arguments) + internal SecurityAttributeValue CreateTypedSecurityAttribute( + TypeSpecificationValue type, + ImmutableArray arguments) => new SecurityAttributeValue( null, - GetTypeSpecificationValue(type), - GetSecurityAttributeArguments(arguments)); - - internal void BeginSecurityNameValuePairs(CILParser.NameValPairsContext context) - => _securityNameValuePairFrames.Push(new(context)); - - internal void AddSecurityNameValuePair(CILParser.NameValPairsContext context, object? value) - { - if (TryGetSecurityNameValuePairsFrame(context) is { } frame && - value is SecurityNameValuePairValue pair) - { - (frame.Pairs ??= ImmutableArray.CreateBuilder()) - .Add(pair); - } - } + type, + arguments); - internal object EndSecurityNameValuePairs(CILParser.NameValPairsContext context) - { - if (TryGetSecurityNameValuePairsFrame(context) is not { } frame) - { - return ImmutableArray.Empty; - } - - _securityNameValuePairFrames.Pop(); - return frame.Pairs?.ToImmutable() ?? ImmutableArray.Empty; - } - - internal object CreateSecurityNameValuePair(string name, object? value) - => new SecurityNameValuePairValue(name, GetSecurityCaValue(value)); + internal SecurityNameValuePairValue CreateSecurityNameValuePair( + string name, + SecurityCaValue value) + => new(name, value); - internal object CreateSecurityBooleanValue(bool value) => new SecurityBooleanValue(value); + internal SecurityCaValue CreateSecurityBooleanValue(bool value) + => new SecurityBooleanValue(value); - internal object CreateSecurityInt32Value(IToken value) + internal SecurityCaValue CreateSecurityInt32Value(IToken value) => new SecurityInt32Value(ParseInt32(value)); - internal object CreateSecurityStringValue(string value) => new SecurityStringValue(value); + internal SecurityCaValue CreateSecurityStringValue(string value) + => new SecurityStringValue(value); - internal object CreateSecurityEnumValue(object? type, IToken kind, IToken value) + internal SecurityCaValue CreateSecurityEnumValue( + ClassNameValue type, + IToken kind, + IToken value) => new SecurityEnumValue( - GetClassNameValue(type), + type, kind.Text switch { "int8" => 1, @@ -234,8 +131,10 @@ internal object CreateSecurityEnumValue(object? type, IToken kind, IToken value) }, ParseInt32(value)); - internal object CreateSecurityEnumValue(object? type, IToken value) - => new SecurityEnumValue(GetClassNameValue(type), 4, ParseInt32(value)); + internal SecurityCaValue CreateSecurityEnumValue( + ClassNameValue type, + IToken value) + => new SecurityEnumValue(type, 4, ParseInt32(value)); private EntityRegistry.DeclarativeSecurityAttributeEntity? MaterializeSecurityDeclaration( SecurityDeclarationValue value, @@ -305,36 +204,6 @@ private BlobBuilder MaterializeSecurityAttribute(SecurityAttributeValue attribut return blob; } - private static ImmutableArray GetSecurityAttributes(object? value) - => value is ImmutableArray attributes ? attributes : []; - - private static ImmutableArray GetSecurityAttributeArguments( - object? value) - => value is ImmutableArray arguments ? arguments : []; - - private static SecurityCaValue GetSecurityCaValue(object? value) - => value as SecurityCaValue ?? new SecurityInt32Value(0); - - private SecurityAttributeSetFrame? TryGetSecurityAttributeSetFrame( - CILParser.SecAttrSetBlobContext context) - { - Debug.Assert(_securityAttributeSetFrames.Count > 0); - SecurityAttributeSetFrame? frame = - _securityAttributeSetFrames.Count == 0 ? null : _securityAttributeSetFrames.Peek(); - Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); - return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; - } - - private SecurityNameValuePairsFrame? TryGetSecurityNameValuePairsFrame( - CILParser.NameValPairsContext context) - { - Debug.Assert(_securityNameValuePairFrames.Count > 0); - SecurityNameValuePairsFrame? frame = - _securityNameValuePairFrames.Count == 0 ? null : _securityNameValuePairFrames.Peek(); - Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); - return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; - } - internal EntityRegistry.DeclarativeSecurityAttributeEntity? MaterializeSecurityDeclaration( CILParser.SecDeclContext context) => context.Value is SecurityDeclarationValue value diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Actions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Actions.cs index 20cad732f361f9..229b47ae2637f3 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Actions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Actions.cs @@ -2,7 +2,6 @@ // The .NET Foundation licenses this file to you under the MIT license. using System; -using System.Collections.Generic; using System.Collections.Immutable; using System.Diagnostics; using System.Linq; @@ -15,74 +14,6 @@ namespace ILAssembler; #pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. internal sealed partial class GrammarActions { - private readonly Stack _typeSignatureFrames = new(); - private readonly Stack _typeArgumentsFrames = new(); - private readonly Stack _boundsFrames = new(); - private readonly Stack _signatureArgumentsFrames = new(); - private readonly Stack _parameterAttributesFrames = new(); - - private sealed class TypeSignatureFrame - { - public TypeSignatureFrame(CILParser.TypeContext owner) - { - Owner = owner; - } - - public CILParser.TypeContext Owner { get; } - - public ElementTypeValue ElementType { get; set; } = ElementTypeValue.Error; - - public ImmutableArray.Builder Modifiers { get; } = ImmutableArray.CreateBuilder(); - } - - private sealed class TypeArgumentsFrame - { - public TypeArgumentsFrame(CILParser.TypeArgsContext owner) - { - Owner = owner; - } - - public CILParser.TypeArgsContext Owner { get; } - - public ImmutableArray.Builder Arguments { get; } = ImmutableArray.CreateBuilder(); - } - - private sealed class BoundsFrame - { - public BoundsFrame(CILParser.BoundsContext owner) - { - Owner = owner; - } - - public CILParser.BoundsContext Owner { get; } - - public ImmutableArray.Builder Bounds { get; } = ImmutableArray.CreateBuilder(); - } - - private sealed class SignatureArgumentsFrame - { - public SignatureArgumentsFrame(CILParser.SigArgsContext owner) - { - Owner = owner; - } - - public CILParser.SigArgsContext Owner { get; } - - public ImmutableArray.Builder Arguments { get; } = ImmutableArray.CreateBuilder(); - } - - private sealed class ParameterAttributesFrame - { - public ParameterAttributesFrame(CILParser.ParamAttrContext owner) - { - Owner = owner; - } - - public CILParser.ParamAttrContext Owner { get; } - - public int Attributes { get; set; } - } - internal byte AddInstanceCallingConvention(byte callingConvention) => (byte)(callingConvention | (byte)SignatureAttributes.Instance); @@ -106,63 +37,6 @@ internal byte GetCallingConvention(IToken token) _ => throw new UnreachableException() }); - internal void BeginTypeSignature(CILParser.TypeContext context) - => _typeSignatureFrames.Push(new(context)); - - internal void SetTypeSignatureElement(CILParser.TypeContext context, object? value) - { - Debug.Assert(_typeSignatureFrames.Count > 0); - TypeSignatureFrame frame = _typeSignatureFrames.Peek(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - if (ReferenceEquals(frame.Owner, context)) - { - frame.ElementType = GetElementTypeValue(value); - } - } - - internal void AddTypeSignatureModifier(CILParser.TypeContext context, object? value) - { - Debug.Assert(_typeSignatureFrames.Count > 0); - TypeSignatureFrame frame = _typeSignatureFrames.Peek(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - if (ReferenceEquals(frame.Owner, context)) - { - frame.Modifiers.Add(GetTypeModifierValue(value)); - } - } - - internal object EndTypeSignature(CILParser.TypeContext context) - { - Debug.Assert(_typeSignatureFrames.Count > 0); - TypeSignatureFrame frame = _typeSignatureFrames.Pop(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - return ReferenceEquals(frame.Owner, context) - ? new TypeValue(frame.ElementType, frame.Modifiers.ToImmutable()) - : TypeValue.Error; - } - - internal void BeginTypeArguments(CILParser.TypeArgsContext context) - => _typeArgumentsFrames.Push(new(context)); - - internal void AddTypeArgument(CILParser.TypeArgsContext context, object? value) - { - Debug.Assert(_typeArgumentsFrames.Count > 0); - TypeArgumentsFrame frame = _typeArgumentsFrames.Peek(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - if (ReferenceEquals(frame.Owner, context)) - { - frame.Arguments.Add(GetTypeValue(value)); - } - } - - internal object EndTypeArguments(CILParser.TypeArgsContext context) - { - Debug.Assert(_typeArgumentsFrames.Count > 0); - TypeArgumentsFrame frame = _typeArgumentsFrames.Pop(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - return ReferenceEquals(frame.Owner, context) ? frame.Arguments.ToImmutable() : ImmutableArray.Empty; - } - internal void InitializeBound(CILParser.BoundContext context) { context.Lower = 0; @@ -194,70 +68,26 @@ internal void SetBoundLower(CILParser.BoundContext context, IToken lowerToken) context.HasLower = true; } - internal void BeginBounds(CILParser.BoundsContext context) - => _boundsFrames.Push(new(context)); - - internal void AddBound(CILParser.BoundsContext context, CILParser.BoundContext bound) - { - Debug.Assert(_boundsFrames.Count > 0); - BoundsFrame frame = _boundsFrames.Peek(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - if (ReferenceEquals(frame.Owner, context)) - { - frame.Bounds.Add(new( - bound.HasLower ? bound.Lower : null, - bound.HasUpper ? bound.Upper : null)); - } - } - - internal object EndBounds(CILParser.BoundsContext context) - { - Debug.Assert(_boundsFrames.Count > 0); - BoundsFrame frame = _boundsFrames.Pop(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - return ReferenceEquals(frame.Owner, context) ? frame.Bounds.ToImmutable() : ImmutableArray.Empty; - } - - internal void BeginSignatureArguments(CILParser.SigArgsContext context) - => _signatureArgumentsFrames.Push(new(context)); + internal ArrayBoundValue CreateArrayBound(CILParser.BoundContext bound) + => new( + bound.HasLower ? bound.Lower : null, + bound.HasUpper ? bound.Upper : null); - internal void AddSignatureArgument(CILParser.SigArgsContext context, object? value) - { - Debug.Assert(_signatureArgumentsFrames.Count > 0); - SignatureArgumentsFrame frame = _signatureArgumentsFrames.Peek(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - if (ReferenceEquals(frame.Owner, context)) - { - frame.Arguments.Add(GetSignatureArgumentValue(value)); - } - } - - internal object EndSignatureArguments(CILParser.SigArgsContext context) - { - Debug.Assert(_signatureArgumentsFrames.Count > 0); - SignatureArgumentsFrame frame = _signatureArgumentsFrames.Pop(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - return ReferenceEquals(frame.Owner, context) ? frame.Arguments.ToImmutable() : ImmutableArray.Empty; - } - - internal object CreateSentinelSignatureArgument() + internal SignatureArgumentValue CreateSentinelSignatureArgument() => new SignatureArgumentValue(true, 0, null, null, null); - internal object CreateSignatureArgument( + internal SignatureArgumentValue CreateSignatureArgument( int attributes, - object? type, - object? marshalling, + TypeValue type, + MarshallingDescriptorValue marshalling, CILParser.IdContext? name) => new SignatureArgumentValue( false, attributes, - GetTypeValue(type), - GetMarshallingDescriptorValue(marshalling), + type, + marshalling, name is null ? null : GetIdentifier(name)); - internal void BeginParameterAttributes(CILParser.ParamAttrContext context) - => _parameterAttributesFrames.Push(new(context)); - internal void SetParameterAttributeElement(CILParser.ParamAttrElementContext context, IToken attribute) { context.Value = attribute.Text switch @@ -276,80 +106,73 @@ internal void SetRawParameterAttributeElement(CILParser.ParamAttrElementContext context.ShouldAppend = false; } - internal void AddParameterAttribute(CILParser.ParamAttrContext context, CILParser.ParamAttrElementContext element) - { - Debug.Assert(_parameterAttributesFrames.Count > 0); - ParameterAttributesFrame frame = _parameterAttributesFrames.Peek(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - if (ReferenceEquals(frame.Owner, context)) - { - frame.Attributes = element.ShouldAppend - ? frame.Attributes | element.Value - : element.Value; - } - } - - internal int EndParameterAttributes(CILParser.ParamAttrContext context) - { - Debug.Assert(_parameterAttributesFrames.Count > 0); - ParameterAttributesFrame frame = _parameterAttributesFrames.Pop(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - return ReferenceEquals(frame.Owner, context) ? frame.Attributes : 0; - } + internal int AddParameterAttribute(int attributes, int value, bool shouldAppend) + => shouldAppend ? attributes | value : value; - internal object CreateClassElementType(object? className, bool isValueType) - => new ClassElementTypeValue(GetClassNameValue(className), isValueType); + internal ElementTypeValue CreateClassElementType(ClassNameValue className, bool isValueType) + => new ClassElementTypeValue(className, isValueType); - internal object CreateObjectElementType() + internal ElementTypeValue CreateObjectElementType() => new PrimitiveElementTypeValue((byte)SignatureTypeCode.Object); - internal object CreateTypedReferenceElementType() + internal ElementTypeValue CreateTypedReferenceElementType() => new PrimitiveElementTypeValue((byte)SignatureTypeCode.TypedReference); - internal object CreateVoidElementType() + internal ElementTypeValue CreateVoidElementType() => new PrimitiveElementTypeValue((byte)SignatureTypeCode.Void); - internal object CreatePrimitiveElementType(byte typeCode) + internal ElementTypeValue CreatePrimitiveElementType(byte typeCode) => new PrimitiveElementTypeValue(typeCode); - internal object CreateFunctionPointerElementType(byte callingConvention, object? returnType, object? arguments) + internal ElementTypeValue CreateFunctionPointerElementType( + byte callingConvention, + TypeValue returnType, + ImmutableArray arguments) => new FunctionPointerElementTypeValue( callingConvention, - GetTypeValue(returnType), - GetSignatureArgumentsValue(arguments)); + returnType, + arguments); - internal object CreateIndexedGenericParameterElementType(bool isMethodParameter, IToken token) + internal ElementTypeValue CreateIndexedGenericParameterElementType( + bool isMethodParameter, + IToken token) => new IndexedGenericParameterElementTypeValue(isMethodParameter, ParseInt32(token)); - internal object CreateNamedGenericParameterElementType(IToken token, bool isMethodParameter, string name) + internal ElementTypeValue CreateNamedGenericParameterElementType( + IToken token, + bool isMethodParameter, + string name) => new NamedGenericParameterElementTypeValue(token, isMethodParameter, name); - internal object CreateTypedefElementType(IToken token, string alias) + internal ElementTypeValue CreateTypedefElementType(IToken token, string alias) => new TypedefElementTypeValue(token, alias); - internal object CreateSentinelElementType(object? type) - => new SentinelElementTypeValue(GetTypeValue(type)); + internal ElementTypeValue CreateSentinelElementType(TypeValue type) + => new SentinelElementTypeValue(type); - internal object CreateSzArrayTypeModifier() + internal TypeModifierValue CreateSzArrayTypeModifier() => new SimpleTypeModifierValue(SimpleTypeModifierKind.SzArray); - internal object CreateByReferenceTypeModifier() + internal TypeModifierValue CreateByReferenceTypeModifier() => new SimpleTypeModifierValue(SimpleTypeModifierKind.ByReference); - internal object CreatePointerTypeModifier() + internal TypeModifierValue CreatePointerTypeModifier() => new SimpleTypeModifierValue(SimpleTypeModifierKind.Pointer); - internal object CreatePinnedTypeModifier() + internal TypeModifierValue CreatePinnedTypeModifier() => new SimpleTypeModifierValue(SimpleTypeModifierKind.Pinned); - internal object CreateArrayTypeModifier(object? bounds) - => new ArrayTypeModifierValue(GetBoundsValue(bounds)); + internal TypeModifierValue CreateArrayTypeModifier(ImmutableArray bounds) + => new ArrayTypeModifierValue(bounds); - internal object CreateCustomTypeModifier(object? type, bool isRequired) - => new CustomTypeModifierValue(GetTypeSpecificationValue(type), isRequired); + internal TypeModifierValue CreateCustomTypeModifier( + TypeSpecificationValue type, + bool isRequired) + => new CustomTypeModifierValue(type, isRequired); - internal object CreateGenericArgumentsModifier(object? arguments) - => new GenericArgumentsTypeModifierValue(GetTypeArgumentsValue(arguments)); + internal TypeModifierValue CreateGenericArgumentsModifier( + ImmutableArray arguments) + => new GenericArgumentsTypeModifierValue(arguments); internal byte GetSimpleType(IToken token, bool isUnsigned) { @@ -382,26 +205,29 @@ internal byte GetSimpleType(IToken token, bool isUnsigned) internal byte GetNativeUIntType() => (byte)SignatureTypeCode.UIntPtr; - internal object CreateClassTypeSpecification(object? className) - => new ClassTypeSpecificationValue(GetClassNameValue(className)); + internal TypeSpecificationValue CreateClassTypeSpecification(ClassNameValue className) + => new ClassTypeSpecificationValue(className); - internal object CreateAssemblyTypeSpecification(string assemblyName) + internal TypeSpecificationValue CreateAssemblyTypeSpecification(string assemblyName) => new AssemblyTypeSpecificationValue(assemblyName); - internal object CreateModuleTypeSpecification(string moduleName) + internal TypeSpecificationValue CreateModuleTypeSpecification(string moduleName) => new ModuleTypeSpecificationValue(moduleName); - internal object CreateSignatureTypeSpecification(object? type) - => new SignatureTypeSpecificationValue(GetTypeValue(type)); + internal TypeSpecificationValue CreateSignatureTypeSpecification(TypeValue type) + => new SignatureTypeSpecificationValue(type); internal int GetGenericArity(CILParser.GenArityNotEmptyContext? context) => context?.Value ?? 0; - internal object CreateCalliSignature(byte callingConvention, object? returnType, object? arguments) + internal CalliSignatureValue CreateCalliSignature( + byte callingConvention, + TypeValue returnType, + ImmutableArray arguments) => new CalliSignatureValue( callingConvention, - GetTypeValue(returnType), - GetSignatureArgumentsValue(arguments)); + returnType, + arguments); private BlobBuilder MaterializeCalliSignature(CalliSignatureValue calliSignature) { diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.References.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.References.cs index 05a40ceb13a5ae..2080f0721e640d 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.References.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.References.cs @@ -11,54 +11,57 @@ namespace ILAssembler; #pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. internal sealed partial class GrammarActions { - internal object CreateMethodReference( + internal MethodReferenceValue CreateMethodReference( IToken token, byte callingConvention, - object? returnType, - object? owner, + TypeValue returnType, + TypeSpecificationValue? owner, string name, - CILParser.TypeArgsContext? genericArguments, + ImmutableArray? genericArguments, int? genericArity, - object? arguments) + ImmutableArray arguments) => new ParsedMethodReferenceValue( token, callingConvention, - GetTypeValue(returnType), - owner is null ? null : GetTypeSpecificationValue(owner), + returnType, + owner, name, - genericArguments is null ? null : GetTypeArgumentsValue(genericArguments.Value), + genericArguments, genericArity.GetValueOrDefault(), - GetSignatureArgumentsValue(arguments)); + arguments); - internal object CreateTokenMethodReference(int token) + internal MethodReferenceValue CreateTokenMethodReference(int token) => new TokenMethodReferenceValue(token); - internal object CreateTypedefMethodReference(IToken token, string alias) + internal MethodReferenceValue CreateTypedefMethodReference(IToken token, string alias) => new TypedefMethodReferenceValue(token, alias); - internal object CreateFieldReference(object? fieldType, object? owner, string name) + internal FieldReferenceValue CreateFieldReference( + TypeValue fieldType, + TypeSpecificationValue? owner, + string name) => new ParsedFieldReferenceValue( - GetTypeValue(fieldType), - owner is null ? null : GetTypeSpecificationValue(owner), + fieldType, + owner, name); - internal object CreateTypedefFieldReference(IToken token, string alias) + internal FieldReferenceValue CreateTypedefFieldReference(IToken token, string alias) => new TypedefFieldReferenceValue(token, alias); - internal object CreateMethodMemberReference(object? method) - => new MethodMemberReferenceValue(GetMethodReferenceValue(method)); + internal MemberReferenceValue CreateMethodMemberReference(MethodReferenceValue method) + => new MethodMemberReferenceValue(method); - internal object CreateFieldMemberReference(object? field) - => new FieldMemberReferenceValue(GetFieldReferenceValue(field)); + internal MemberReferenceValue CreateFieldMemberReference(FieldReferenceValue field) + => new FieldMemberReferenceValue(field); - internal object CreateTokenMemberReference(int token) + internal MemberReferenceValue CreateTokenMemberReference(int token) => new TokenMemberReferenceValue(token); - internal object CreateTypeOwner(object? type) - => new TypeOwnerValue(GetTypeSpecificationValue(type)); + internal OwnerTypeValue CreateTypeOwner(TypeSpecificationValue type) + => new TypeOwnerValue(type); - internal object CreateMemberOwner(object? member) - => new MemberOwnerValue(GetMemberReferenceValue(member)); + internal OwnerTypeValue CreateMemberOwner(MemberReferenceValue member) + => new MemberOwnerValue(member); private EntityRegistry.EntityBase MaterializeMethodReference(MethodReferenceValue methodReference) { @@ -75,17 +78,11 @@ private EntityRegistry.EntityBase MaterializeMethodReference(MethodReferenceValu DiagnosticIds.TypedefNotFound, string.Format(DiagnosticMessageTemplates.TypedefNotFound, typedef.Alias), typedef.Token); - return _entityRegistry.CreateLazilyRecordedMemberReference( - _entityRegistry.ModuleType, - typedef.Alias, - new BlobBuilder()); + return CreateErrorMethodReference(typedef.Alias); case ParsedMethodReferenceValue parsed: return MaterializeParsedMethodReference(parsed); default: - return _entityRegistry.CreateLazilyRecordedMemberReference( - _entityRegistry.ModuleType, - "", - new BlobBuilder()); + return CreateErrorMethodReference(""); } } @@ -158,10 +155,7 @@ private EntityRegistry.EntityBase MaterializeFieldReference(FieldReferenceValue DiagnosticIds.TypedefNotFound, string.Format(DiagnosticMessageTemplates.TypedefNotFound, typedef.Alias), typedef.Token); - return _entityRegistry.CreateLazilyRecordedMemberReference( - _entityRegistry.ModuleType, - typedef.Alias, - new BlobBuilder()); + return CreateErrorFieldReference(typedef.Alias); case ParsedFieldReferenceValue parsed: BlobBuilder fieldType = MaterializeType(parsed.FieldType); EntityRegistry.TypeEntity owner = parsed.Owner is null @@ -172,10 +166,7 @@ private EntityRegistry.EntityBase MaterializeFieldReference(FieldReferenceValue fieldType.WriteContentTo(signature); return _entityRegistry.CreateLazilyRecordedMemberReference(owner, parsed.Name, signature); default: - return _entityRegistry.CreateLazilyRecordedMemberReference( - _entityRegistry.ModuleType, - "", - new BlobBuilder()); + return CreateErrorFieldReference(""); } } @@ -185,12 +176,32 @@ private EntityRegistry.EntityBase MaterializeMemberReference(MemberReferenceValu MethodMemberReferenceValue method => MaterializeMethodReference(method.Method), FieldMemberReferenceValue field => MaterializeFieldReference(field.Field), TokenMemberReferenceValue token => ResolveMetadataToken(token.Token), - _ => _entityRegistry.CreateLazilyRecordedMemberReference( - _entityRegistry.ModuleType, - "", - new BlobBuilder()) + _ => CreateErrorMethodReference("") }; + private EntityRegistry.MemberReferenceEntity CreateErrorMethodReference(string name) + { + BlobBuilder signature = new(3); + signature.WriteByte((byte)SignatureCallingConvention.Default); + signature.WriteCompressedInteger(0); + signature.WriteByte((byte)SignatureTypeCode.Void); + return _entityRegistry.CreateLazilyRecordedMemberReference( + _entityRegistry.ModuleType, + name, + signature); + } + + private EntityRegistry.MemberReferenceEntity CreateErrorFieldReference(string name) + { + BlobBuilder signature = new(2); + signature.WriteByte((byte)SignatureKind.Field); + signature.WriteByte((byte)SignatureTypeCode.Object); + return _entityRegistry.CreateLazilyRecordedMemberReference( + _entityRegistry.ModuleType, + name, + signature); + } + private EntityRegistry.EntityBase MaterializeOwnerType(OwnerTypeValue owner) => owner switch { diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Types.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Types.cs index fd7a323ca09fe8..ca8e52ed1cd849 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Types.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Types.cs @@ -76,6 +76,9 @@ private BlobBuilder MaterializeElementType(ElementTypeValue elementType) BlobBuilder blob = new(5); switch (elementType) { + case CILParser.ErrorElementTypeValue: + blob.WriteByte((byte)SignatureTypeCode.Object); + break; case PrimitiveElementTypeValue primitive: blob.WriteByte(primitive.TypeCode); break; diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Values.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Values.cs deleted file mode 100644 index a6fd148942d47e..00000000000000 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.Values.cs +++ /dev/null @@ -1,239 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Collections.Immutable; -using Antlr4.Runtime; - -namespace ILAssembler; - -internal sealed partial class GrammarActions -{ - // ANTLR context classes are public, but these implementation values must remain internal. - // Grammar return slots therefore use object and are unwrapped only by these strongly typed helpers. - private static T GetSemanticValue(object? value, T fallback) - where T : class - => value as T ?? fallback; - - private static TypeValue GetTypeValue(object? value) - => GetSemanticValue(value, TypeValue.Error); - - private static ElementTypeValue GetElementTypeValue(object? value) - => GetSemanticValue(value, ElementTypeValue.Error); - - private static TypeModifierValue GetTypeModifierValue(object? value) - => GetSemanticValue(value, TypeModifierValue.Error); - - private static ImmutableArray GetTypeArgumentsValue(object? value) - => value is ImmutableArray arguments ? arguments : []; - - private static ImmutableArray GetBoundsValue(object? value) - => value is ImmutableArray bounds ? bounds : []; - - private static SignatureArgumentValue GetSignatureArgumentValue(object? value) - => GetSemanticValue(value, SignatureArgumentValue.Error); - - private static ImmutableArray GetSignatureArgumentsValue(object? value) - => value is ImmutableArray arguments ? arguments : []; - - private static TypeName GetTypeNameValue(object? value) - => value as TypeName ?? new TypeName(null, string.Empty); - - private static ClassNameValue GetClassNameValue(object? value) - => GetSemanticValue(value, ClassNameValue.Error); - - private static TypeSpecificationValue GetTypeSpecificationValue(object? value) - => GetSemanticValue(value, TypeSpecificationValue.Error); - - private static MethodReferenceValue GetMethodReferenceValue(object? value) - => GetSemanticValue(value, MethodReferenceValue.Error); - - private static FieldReferenceValue GetFieldReferenceValue(object? value) - => GetSemanticValue(value, FieldReferenceValue.Error); - - private static MemberReferenceValue GetMemberReferenceValue(object? value) - => GetSemanticValue(value, MemberReferenceValue.Error); - - private static OwnerTypeValue GetOwnerTypeValue(object? value) - => GetSemanticValue(value, OwnerTypeValue.Error); - - private static CalliSignatureValue GetCalliSignatureValue(object? value) - => GetSemanticValue(value, CalliSignatureValue.Error); - - private sealed record ArrayBoundValue(int? Lower, int? Upper); - - private abstract record ElementTypeValue - { - public static ElementTypeValue Error { get; } = new ErrorElementTypeValue(); - } - - private sealed record ErrorElementTypeValue : ElementTypeValue; - - private sealed record PrimitiveElementTypeValue(byte TypeCode) : ElementTypeValue; - - private sealed record ClassElementTypeValue(ClassNameValue ClassName, bool IsValueType) : ElementTypeValue; - - private sealed record FunctionPointerElementTypeValue( - byte CallingConvention, - TypeValue ReturnType, - ImmutableArray Arguments) : ElementTypeValue; - - private abstract record GenericParameterElementTypeValue(bool IsMethodParameter) : ElementTypeValue; - - private sealed record IndexedGenericParameterElementTypeValue(bool IsMethodParameter, int Index) - : GenericParameterElementTypeValue(IsMethodParameter); - - private sealed record NamedGenericParameterElementTypeValue(IToken Token, bool IsMethodParameter, string Name) - : GenericParameterElementTypeValue(IsMethodParameter); - - private sealed record TypedefElementTypeValue(IToken Token, string Alias) : ElementTypeValue; - - private sealed record SentinelElementTypeValue(TypeValue Type) : ElementTypeValue; - - private sealed record TypeValue(ElementTypeValue ElementType, ImmutableArray Modifiers) - { - public static TypeValue Error { get; } = new(ElementTypeValue.Error, []); - } - - private abstract record TypeModifierValue - { - public static TypeModifierValue Error { get; } = new ErrorTypeModifierValue(); - } - - private sealed record ErrorTypeModifierValue : TypeModifierValue; - - private enum SimpleTypeModifierKind - { - SzArray, - ByReference, - Pointer, - Pinned - } - - private sealed record SimpleTypeModifierValue(SimpleTypeModifierKind Kind) : TypeModifierValue; - - private sealed record ArrayTypeModifierValue(ImmutableArray Bounds) : TypeModifierValue; - - private sealed record CustomTypeModifierValue(TypeSpecificationValue Type, bool IsRequired) : TypeModifierValue; - - private sealed record GenericArgumentsTypeModifierValue(ImmutableArray Arguments) : TypeModifierValue; - - private sealed record SignatureArgumentValue( - bool IsSentinel, - int Attributes, - TypeValue? Type, - MarshallingDescriptorValue? Marshalling, - string? Name) - { - public static SignatureArgumentValue Error { get; } = new(false, 0, TypeValue.Error, null, null); - } - - private sealed record CalliSignatureValue( - byte CallingConvention, - TypeValue ReturnType, - ImmutableArray Arguments) - { - public static CalliSignatureValue Error { get; } = new(0, TypeValue.Error, []); - } - - private abstract record ClassNameValue - { - public static ClassNameValue Error { get; } = new ErrorClassNameValue(); - } - - private sealed record ErrorClassNameValue : ClassNameValue; - - private sealed record UnqualifiedClassNameValue(TypeName Name) : ClassNameValue; - - private sealed record AssemblyQualifiedClassNameValue(string AssemblyName, TypeName Name) : ClassNameValue; - - private sealed record ModuleQualifiedClassNameValue(IToken Token, string ModuleName, TypeName Name) : ClassNameValue; - - private sealed record TokenQualifiedClassNameValue(int Token, TypeName Name) : ClassNameValue; - - private sealed record PointerQualifiedClassNameValue(TypeName Name) : ClassNameValue; - - private sealed record TokenClassNameValue(int Token) : ClassNameValue; - - private enum SpecialClassNameKind - { - This, - Base, - Nester - } - - private sealed record SpecialClassNameValue(IToken Token, SpecialClassNameKind Kind) : ClassNameValue; - - private abstract record TypeSpecificationValue - { - public static TypeSpecificationValue Error { get; } = new ErrorTypeSpecificationValue(); - } - - private sealed record ErrorTypeSpecificationValue : TypeSpecificationValue; - - private sealed record ClassTypeSpecificationValue(ClassNameValue ClassName) : TypeSpecificationValue; - - private sealed record AssemblyTypeSpecificationValue(string AssemblyName) : TypeSpecificationValue; - - private sealed record ModuleTypeSpecificationValue(string ModuleName) : TypeSpecificationValue; - - private sealed record SignatureTypeSpecificationValue(TypeValue Type) : TypeSpecificationValue; - - private abstract record MethodReferenceValue - { - public static MethodReferenceValue Error { get; } = new ErrorMethodReferenceValue(); - } - - private sealed record ErrorMethodReferenceValue : MethodReferenceValue; - - private sealed record TokenMethodReferenceValue(int Token) : MethodReferenceValue; - - private sealed record TypedefMethodReferenceValue(IToken Token, string Alias) : MethodReferenceValue; - - private sealed record ParsedMethodReferenceValue( - IToken Token, - byte CallingConvention, - TypeValue ReturnType, - TypeSpecificationValue? Owner, - string Name, - ImmutableArray? GenericArguments, - int GenericArity, - ImmutableArray Arguments) : MethodReferenceValue; - - private abstract record FieldReferenceValue - { - public static FieldReferenceValue Error { get; } = new ErrorFieldReferenceValue(); - } - - private sealed record ErrorFieldReferenceValue : FieldReferenceValue; - - private sealed record TypedefFieldReferenceValue(IToken Token, string Alias) : FieldReferenceValue; - - private sealed record ParsedFieldReferenceValue( - TypeValue FieldType, - TypeSpecificationValue? Owner, - string Name) : FieldReferenceValue; - - private abstract record MemberReferenceValue - { - public static MemberReferenceValue Error { get; } = new ErrorMemberReferenceValue(); - } - - private sealed record ErrorMemberReferenceValue : MemberReferenceValue; - - private sealed record MethodMemberReferenceValue(MethodReferenceValue Method) : MemberReferenceValue; - - private sealed record FieldMemberReferenceValue(FieldReferenceValue Field) : MemberReferenceValue; - - private sealed record TokenMemberReferenceValue(int Token) : MemberReferenceValue; - - private abstract record OwnerTypeValue - { - public static OwnerTypeValue Error { get; } = new ErrorOwnerTypeValue(); - } - - private sealed record ErrorOwnerTypeValue : OwnerTypeValue; - - private sealed record TypeOwnerValue(TypeSpecificationValue Type) : OwnerTypeValue; - - private sealed record MemberOwnerValue(MemberReferenceValue Member) : OwnerTypeValue; -} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.cs index 2b6eb244905434..15fa76626d8694 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Signatures.cs @@ -6,8 +6,8 @@ namespace ILAssembler; internal sealed partial class GrammarActions { internal EntityRegistry.EntityBase MaterializeMethodReference(CILParser.MethodRefContext context) - => MaterializeMethodReference(GetMethodReferenceValue(context.Value)); + => MaterializeMethodReference(context.Value); internal EntityRegistry.TypeEntity ResolveTypeSpecification(CILParser.TypeSpecContext context) - => ResolveTypeSpecification(GetTypeSpecificationValue(context.Value)); + => ResolveTypeSpecification(context.Value); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.Actions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.Actions.cs index 1d9685f036c2f0..e066a53daddb23 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.Actions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.Actions.cs @@ -1,7 +1,6 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System.Collections.Generic; using System.Collections.Immutable; using System.Diagnostics; using System.Reflection; @@ -12,89 +11,31 @@ namespace ILAssembler; #pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. internal sealed partial class GrammarActions { - private readonly Stack _namespaceHeaderFrames = new(); - private readonly Stack _classHeaderFrames = new(); - private readonly Stack _interfaceListFrames = new(); + internal void PrepareNamespaceHeader() + => ClearPendingCustomAttributeOwners(); - private sealed record NamespaceHeaderFrame( - CILParser.NameSpaceHeadContext Owner, - int InitialSyntaxErrorCount); - - private sealed class ClassHeaderFrame - { - public ClassHeaderFrame(CILParser.ClassHeadContext owner, int initialSyntaxErrorCount) - { - Owner = owner; - InitialSyntaxErrorCount = initialSyntaxErrorCount; - } - - public CILParser.ClassHeadContext Owner { get; } - - public int InitialSyntaxErrorCount { get; } - - public ImmutableArray.Builder Attributes { get; } = - ImmutableArray.CreateBuilder(); - } - - private sealed class InterfaceListFrame - { - public InterfaceListFrame(CILParser.ImplListContext owner) - { - Owner = owner; - } - - public CILParser.ImplListContext Owner { get; } - - public ImmutableArray.Builder Interfaces { get; } = - ImmutableArray.CreateBuilder(); - } - - internal void BeginNamespaceHeader(CILParser.NameSpaceHeadContext context) + internal CILParser.ClassHeaderBuilder PrepareClassHeader() { ClearPendingCustomAttributeOwners(); - _namespaceHeaderFrames.Push(new(context, _syntaxErrorCount)); + return new CILParser.ClassHeaderBuilder(); } - internal void EndNamespaceHeader(CILParser.NameSpaceHeadContext context) - { - if (_namespaceHeaderFrames.Count == 0) - { - return; - } - - NamespaceHeaderFrame frame = _namespaceHeaderFrames.Peek(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - if (ReferenceEquals(frame.Owner, context)) - { - _namespaceHeaderFrames.Pop(); - } - } + internal void AddClassHeaderAttribute( + CILParser.ClassHeaderBuilder builder, + ClassAttributeValue value) + => builder.Attributes.Add(value); - internal void BeginClassHeader(CILParser.ClassHeadContext context) - { - ClearPendingCustomAttributeOwners(); - _classHeaderFrames.Push(new(context, _syntaxErrorCount)); - } - - internal void AddClassHeaderAttribute(CILParser.ClassHeadContext context, object? value) - { - if (TryGetClassHeaderFrame(context) is { } frame) - { - frame.Attributes.Add(GetClassAttributeValue(value)); - } - } - - internal object CreateClassHeader( + internal ClassHeaderValue CreateClassHeader( CILParser.ClassHeadContext context, + CILParser.ClassHeaderBuilder builder, + int initialSyntaxErrorCount, IToken nameToken, string fullName, - object? genericParameters, - object? baseType, - object? interfaces) + ImmutableArray genericParameters, + TypeSpecificationValue? baseType, + ImmutableArray interfaces) { - ClassHeaderFrame? frame = TryGetClassHeaderFrame(context); - if (frame is null || - frame.InitialSyntaxErrorCount != _syntaxErrorCount || + if (HasSyntaxErrorsSince(initialSyntaxErrorCount) || context.exception is not null) { return ClassHeaderValue.Error; @@ -104,28 +45,13 @@ internal object CreateClassHeader( true, nameToken, fullName, - frame.Attributes.ToImmutable(), - GetGenericParameterDeclarations(genericParameters), - baseType as TypeSpecificationValue, - GetInterfaceTypes(interfaces)); + builder.Attributes.ToImmutable(), + genericParameters, + baseType, + interfaces); } - internal void EndClassHeader(CILParser.ClassHeadContext context) - { - if (_classHeaderFrames.Count == 0) - { - return; - } - - ClassHeaderFrame frame = _classHeaderFrames.Peek(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - if (ReferenceEquals(frame.Owner, context)) - { - _classHeaderFrames.Pop(); - } - } - - internal object CreateClassAttribute(IToken token) + internal ClassAttributeValue CreateClassAttribute(IToken token) { return token.Text switch { @@ -170,7 +96,7 @@ internal object CreateClassAttribute(IToken token) }; } - internal object CreateNestedClassAttribute(IToken visibility) + internal ClassAttributeValue CreateNestedClassAttribute(IToken visibility) { TypeAttributes attribute = visibility.Text switch { @@ -185,7 +111,7 @@ internal object CreateNestedClassAttribute(IToken visibility) return CreateClassAttribute(attribute, TypeAttributes.VisibilityMask); } - internal object CreateRawClassAttribute(IToken token) + internal ClassAttributeValue CreateRawClassAttribute(IToken token) { int value = ParseInt32(token); bool requireSealed = false; @@ -207,63 +133,19 @@ internal object CreateRawClassAttribute(IToken token) requireSealed); } - internal object? CreateEmptyClassBase() => null; - - internal object CreateClassBase(object? value) => GetTypeSpecificationValue(value); - - internal object CreateEmptyInterfaceList() => ImmutableArray.Empty; - - internal void BeginInterfaceList(CILParser.ImplListContext context) - => _interfaceListFrames.Push(new(context)); - - internal void AddInterfaceType(CILParser.ImplListContext context, object? value) - { - if (TryGetInterfaceListFrame(context) is { } frame) - { - frame.Interfaces.Add(GetTypeSpecificationValue(value)); - } - } - - internal object EndInterfaceList(CILParser.ImplListContext context) - { - if (_interfaceListFrames.Count == 0) - { - return ImmutableArray.Empty; - } + internal TypeSpecificationValue? CreateEmptyClassBase() => null; - InterfaceListFrame frame = _interfaceListFrames.Peek(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - if (!ReferenceEquals(frame.Owner, context)) - { - return ImmutableArray.Empty; - } + internal TypeSpecificationValue CreateClassBase(TypeSpecificationValue value) + => value; - _interfaceListFrames.Pop(); - return frame.Interfaces.ToImmutable(); - } + internal ImmutableArray CreateEmptyInterfaceList() + => []; private static ClassAttributeValue CreateClassAttribute( TypeAttributes value, TypeAttributes groupMask = 0, EntityRegistry.WellKnownBaseType? fallbackBase = null, bool requireSealed = false) - => new(new(value, groupMask, true), fallbackBase, requireSealed); - - private ClassHeaderFrame? TryGetClassHeaderFrame(CILParser.ClassHeadContext context) - { - Debug.Assert(_classHeaderFrames.Count > 0); - ClassHeaderFrame? frame = _classHeaderFrames.Count == 0 ? null : _classHeaderFrames.Peek(); - Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); - return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; - } - - private InterfaceListFrame? TryGetInterfaceListFrame(CILParser.ImplListContext context) - { - Debug.Assert(_interfaceListFrames.Count > 0); - InterfaceListFrame? frame = - _interfaceListFrames.Count == 0 ? null : _interfaceListFrames.Peek(); - Debug.Assert(frame is null || ReferenceEquals(frame.Owner, context)); - return frame is not null && ReferenceEquals(frame.Owner, context) ? frame : null; - } + => new(new CILParser.AttributeValue(value, groupMask, true), fallbackBase, requireSealed); } #pragma warning restore CA1822 diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.Values.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.Values.cs deleted file mode 100644 index 35d18c2ac75ee6..00000000000000 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.Values.cs +++ /dev/null @@ -1,44 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Collections.Immutable; -using System.Reflection; -using Antlr4.Runtime; - -namespace ILAssembler; - -internal sealed partial class GrammarActions -{ - private sealed record ClassAttributeValue( - AttributeValue Attribute, - EntityRegistry.WellKnownBaseType? FallbackBase, - bool RequireSealed); - - private sealed record ClassHeaderValue( - bool IsValid, - IToken? NameToken, - string FullName, - ImmutableArray Attributes, - ImmutableArray GenericParameters, - TypeSpecificationValue? BaseType, - ImmutableArray Interfaces) - { - public static ClassHeaderValue Error { get; } = new( - false, - null, - string.Empty, - [], - [], - null, - []); - } - - private static ClassAttributeValue GetClassAttributeValue(object? value) - => value as ClassAttributeValue ?? new(new(0, 0, true), null, false); - - private static ClassHeaderValue GetClassHeaderValue(object? value) - => value as ClassHeaderValue ?? ClassHeaderValue.Error; - - private static ImmutableArray GetInterfaceTypes(object? value) - => value is ImmutableArray interfaces ? interfaces : []; -} diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.cs index 4248757a56627c..edb5e2b03079f0 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.Headers.cs @@ -9,11 +9,12 @@ namespace ILAssembler; internal sealed partial class GrammarActions { - internal void BeginNamespace(CILParser.NameSpaceHeadContext context, string? namespaceName) + internal void BeginNamespace( + CILParser.NameSpaceHeadContext context, + string? namespaceName, + int initialSyntaxErrorCount) { - if (_namespaceHeaderFrames.Count == 0 || - !ReferenceEquals(_namespaceHeaderFrames.Peek().Owner, context) || - _namespaceHeaderFrames.Peek().InitialSyntaxErrorCount != _syntaxErrorCount || + if (HasSyntaxErrorsSince(initialSyntaxErrorCount) || context.exception is not null || namespaceName is null) { @@ -28,15 +29,14 @@ context.exception is not null || _namespaceOwners.Push(context.Parent); } - internal void BeginType(CILParser.ClassHeadContext context, object? value) + internal void BeginType(CILParser.ClassHeadContext context, ClassHeaderValue value) { - ClassHeaderValue header = GetClassHeaderValue(value); - if (!header.IsValid) + if (!value.IsValid) { return; } - EntityRegistry.TypeDefinitionEntity typeDefinition = MaterializeClassHeader(context, header); + EntityRegistry.TypeDefinitionEntity typeDefinition = MaterializeClassHeader(context, value); _currentTypeDefinition.Push(typeDefinition); _typeOwners.Push(context.Parent); } @@ -110,7 +110,7 @@ private void InitializeTypeDefinition( fallbackBase = classAttribute.FallbackBase; } - AttributeValue attribute = classAttribute.Attribute; + CILParser.AttributeValue attribute = classAttribute.Attribute; if (!attribute.ShouldAppend) { attributes = attribute.Value; @@ -179,7 +179,7 @@ private void MergeTypeDefinition( TypeAttributes attributes = typeDefinition.Attributes; foreach (ClassAttributeValue classAttribute in header.Attributes) { - AttributeValue attribute = classAttribute.Attribute; + CILParser.AttributeValue attribute = classAttribute.Attribute; if (!attribute.ShouldAppend) { attributes = attribute.Value; diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.References.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.References.cs index 83b673ebbf8af3..021711a9dd2911 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.References.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.References.cs @@ -12,69 +12,37 @@ namespace ILAssembler; #pragma warning disable CA1822 // Parser actions are invoked through the per-parser GrammarActions instance. internal sealed partial class GrammarActions { - private readonly Stack _slashedNameFrames = new(); + internal TypeName AddSlashedNamePart(TypeName? containingTypeName, string name) + => new(containingTypeName, name); - private sealed class SlashedNameFrame - { - public SlashedNameFrame(CILParser.SlashedNameContext owner) - { - Owner = owner; - } - - public CILParser.SlashedNameContext Owner { get; } - - public TypeName? Name { get; set; } - } - - internal void BeginSlashedName(CILParser.SlashedNameContext context) - => _slashedNameFrames.Push(new(context)); - - internal void AddSlashedNamePart(CILParser.SlashedNameContext context, string name) - { - Debug.Assert(_slashedNameFrames.Count > 0); - SlashedNameFrame frame = _slashedNameFrames.Peek(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - if (ReferenceEquals(frame.Owner, context)) - { - frame.Name = new TypeName(frame.Name, name); - } - } - - internal object EndSlashedName(CILParser.SlashedNameContext context) - { - Debug.Assert(_slashedNameFrames.Count > 0); - SlashedNameFrame frame = _slashedNameFrames.Pop(); - Debug.Assert(ReferenceEquals(frame.Owner, context)); - return ReferenceEquals(frame.Owner, context) && frame.Name is not null - ? frame.Name - : new TypeName(null, string.Empty); - } - - internal object CreateUnqualifiedClassName(object? name) - => new UnqualifiedClassNameValue(GetTypeNameValue(name)); + internal ClassNameValue CreateUnqualifiedClassName(TypeName name) + => new UnqualifiedClassNameValue(name); - internal object CreateAssemblyQualifiedClassName(string assemblyName, object? name) - => new AssemblyQualifiedClassNameValue(assemblyName, GetTypeNameValue(name)); + internal ClassNameValue CreateAssemblyQualifiedClassName(string assemblyName, TypeName name) + => new AssemblyQualifiedClassNameValue(assemblyName, name); - internal object CreateModuleQualifiedClassName(IToken token, string moduleName, object? name) - => new ModuleQualifiedClassNameValue(token, moduleName, GetTypeNameValue(name)); + internal ClassNameValue CreateModuleQualifiedClassName( + IToken token, + string moduleName, + TypeName name) + => new ModuleQualifiedClassNameValue(token, moduleName, name); - internal object CreateTokenQualifiedClassName(int scopeToken, object? name) - => new TokenQualifiedClassNameValue(scopeToken, GetTypeNameValue(name)); + internal ClassNameValue CreateTokenQualifiedClassName(int scopeToken, TypeName name) + => new TokenQualifiedClassNameValue(scopeToken, name); - internal object CreatePointerQualifiedClassName(object? name) - => new PointerQualifiedClassNameValue(GetTypeNameValue(name)); + internal ClassNameValue CreatePointerQualifiedClassName(TypeName name) + => new PointerQualifiedClassNameValue(name); - internal object CreateTokenClassName(int typeToken) + internal ClassNameValue CreateTokenClassName(int typeToken) => new TokenClassNameValue(typeToken); - internal object CreateThisClassName(IToken token) + internal ClassNameValue CreateThisClassName(IToken token) => new SpecialClassNameValue(token, SpecialClassNameKind.This); - internal object CreateBaseClassName(IToken token) + internal ClassNameValue CreateBaseClassName(IToken token) => new SpecialClassNameValue(token, SpecialClassNameKind.Base); - internal object CreateNesterClassName(IToken token) + internal ClassNameValue CreateNesterClassName(IToken token) => new SpecialClassNameValue(token, SpecialClassNameKind.Nester); private EntityRegistry.TypeEntity ResolveClassName(ClassNameValue className) diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs index b6a005c8a5990c..ed3d3e731a11c7 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.Types.cs @@ -9,6 +9,8 @@ namespace ILAssembler; internal sealed partial class GrammarActions { + // Active namespace and type scopes are paired with their owning declaration so a rule's + // finally block can unwind real compiler state after syntax-error recovery. private readonly Stack _namespaceOwners = new(); private readonly Stack _typeOwners = new(); @@ -29,8 +31,6 @@ internal void EndDeclaration(CILParser.DeclContext context) /// internal void EndClassDeclaration(CILParser.ClassDeclContext context) { - EndClassGenericDirective(context); - EndPropertyAndEventBodies(context); EndScopesOwnedBy(context); } diff --git a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs index 5df143453faee1..e3283f496e8258 100644 --- a/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs +++ b/src/tools/ilasm/src/ILAssembler/Actions/GrammarActions.cs @@ -23,87 +23,11 @@ _currentMethod is null && _typeOwners.Count == 0 && _namespaceOwners.Count == 0 && _scopeStack.Count == 0 - && _parameterDirectiveFrames.Count == 0 - && _exceptionBlockFrames.Count == 0 - && _exceptionClauseListFrames.Count == 0 - && _catchClauseFrames.Count == 0 - && _semanticRootFrames.Count == 0 - && _dottedNameFrames.Count == 0 - && _slashedNameFrames.Count == 0 - && _typeSignatureFrames.Count == 0 - && _typeArgumentsFrames.Count == 0 - && _boundsFrames.Count == 0 - && _signatureArgumentsFrames.Count == 0 - && _parameterAttributesFrames.Count == 0 - && _marshalBlobFrames.Count == 0 - && _nativeTypeFrames.Count == 0 - && _variantTypeFrames.Count == 0 - && _methodHeaderFrames.Count == 0 - && _pInvokeFrames.Count == 0 - && _genericTypeListFrames.Count == 0 - && _genericParameterAttributesFrames.Count == 0 - && _genericParametersFrames.Count == 0 - && _fieldDeclarationFrames.Count == 0 - && _propertyHeaderFrames.Count == 0 - && _eventHeaderFrames.Count == 0 - && _propertyBodyFrames.Count == 0 - && _eventBodyFrames.Count == 0 - && _classGenericDirectiveFrames.Count == 0 - && _namespaceHeaderFrames.Count == 0 - && _classHeaderFrames.Count == 0 - && _interfaceListFrames.Count == 0 - && _customBlobArgumentFrames.Count == 0 - && _customBlobNamedArgumentFrames.Count == 0 - && _serializationSequenceFrames.Count == 0 - && _dataDeclarationFrames.Count == 0 - && _assemblyDeclarationFrames.Count == 0 - && _assemblyReferenceDeclarationFrames.Count == 0 - && _fileDeclarationFrames.Count == 0 - && _exportedTypeDeclarationFrames.Count == 0 - && _manifestResourceDeclarationFrames.Count == 0 - && _securityAttributeSetFrames.Count == 0 - && _securityNameValuePairFrames.Count == 0 && _pendingClassMethodOverrides.Count == 0, - "Per-document semantic state must be released by the owning rule's finally block."); + "Nested compiler state must be released by its owning declaration."); EndMethod(); ResetTypeScopes(); ClearPendingCustomAttributeOwners(); - _semanticRootFrames.Clear(); - _dottedNameFrames.Clear(); - _slashedNameFrames.Clear(); - _typeSignatureFrames.Clear(); - _typeArgumentsFrames.Clear(); - _boundsFrames.Clear(); - _signatureArgumentsFrames.Clear(); - _parameterAttributesFrames.Clear(); - _marshalBlobFrames.Clear(); - _nativeTypeFrames.Clear(); - _variantTypeFrames.Clear(); - _methodHeaderFrames.Clear(); - _pInvokeFrames.Clear(); - _genericTypeListFrames.Clear(); - _genericParameterAttributesFrames.Clear(); - _genericParametersFrames.Clear(); - _fieldDeclarationFrames.Clear(); - _propertyHeaderFrames.Clear(); - _eventHeaderFrames.Clear(); - _propertyBodyFrames.Clear(); - _eventBodyFrames.Clear(); - _classGenericDirectiveFrames.Clear(); - _namespaceHeaderFrames.Clear(); - _classHeaderFrames.Clear(); - _interfaceListFrames.Clear(); - _customBlobArgumentFrames.Clear(); - _customBlobNamedArgumentFrames.Clear(); - _serializationSequenceFrames.Clear(); - _dataDeclarationFrames.Clear(); - _assemblyDeclarationFrames.Clear(); - _assemblyReferenceDeclarationFrames.Clear(); - _fileDeclarationFrames.Clear(); - _exportedTypeDeclarationFrames.Clear(); - _manifestResourceDeclarationFrames.Clear(); - _securityAttributeSetFrames.Clear(); - _securityNameValuePairFrames.Clear(); _pendingClassMethodOverrides.Clear(); _currentDocumentPath = null; _syntaxErrorCount = 0; diff --git a/src/tools/ilasm/src/ILAssembler/CILParser.SemanticValueAliases.cs b/src/tools/ilasm/src/ILAssembler/CILParser.SemanticValueAliases.cs new file mode 100644 index 00000000000000..973abd2df5be75 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/CILParser.SemanticValueAliases.cs @@ -0,0 +1,176 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +global using AnsiBstrNativeTypeElementValue = ILAssembler.CILParser.AnsiBstrNativeTypeElementValue; +global using ArrayBoundValue = ILAssembler.CILParser.ArrayBoundValue; +global using ArraySerializationTypeValue = ILAssembler.CILParser.ArraySerializationTypeValue; +global using ArraySerializedInitializerValue = ILAssembler.CILParser.ArraySerializedInitializerValue; +global using ArrayTypeModifierValue = ILAssembler.CILParser.ArrayTypeModifierValue; +global using AssemblyCustomAttributeDirectiveValue = ILAssembler.CILParser.AssemblyCustomAttributeDirectiveValue; +global using AssemblyQualifiedClassNameValue = ILAssembler.CILParser.AssemblyQualifiedClassNameValue; +global using AssemblyDeclarationValue = ILAssembler.CILParser.AssemblyDeclarationValue; +global using AssemblyDefinitionValue = ILAssembler.CILParser.AssemblyDefinitionValue; +global using AssemblyHashAlgorithmDirectiveValue = ILAssembler.CILParser.AssemblyHashAlgorithmDirectiveValue; +global using AssemblyLocaleDirectiveValue = ILAssembler.CILParser.AssemblyLocaleDirectiveValue; +global using AssemblyPublicKeyDirectiveValue = ILAssembler.CILParser.AssemblyPublicKeyDirectiveValue; +global using AssemblyReferenceHashDirectiveValue = ILAssembler.CILParser.AssemblyReferenceHashDirectiveValue; +global using AssemblyReferenceHeaderValue = ILAssembler.CILParser.AssemblyReferenceHeaderValue; +global using AssemblyReferencePublicKeyTokenDirectiveValue = ILAssembler.CILParser.AssemblyReferencePublicKeyTokenDirectiveValue; +global using AssemblyReferenceValue = ILAssembler.CILParser.AssemblyReferenceValue; +global using AssemblySecurityDirectiveValue = ILAssembler.CILParser.AssemblySecurityDirectiveValue; +global using AssemblyTypeSpecificationValue = ILAssembler.CILParser.AssemblyTypeSpecificationValue; +global using AssemblyVersionDirectiveValue = ILAssembler.CILParser.AssemblyVersionDirectiveValue; +global using AttributePermissionSetValue = ILAssembler.CILParser.AttributePermissionSetValue; +global using CalliSignatureValue = ILAssembler.CILParser.CalliSignatureValue; +global using CatchExceptionClauseValue = ILAssembler.CILParser.CatchExceptionClauseValue; +global using CatchTypeValue = ILAssembler.CILParser.CatchTypeValue; +global using ClassAttributeValue = ILAssembler.CILParser.ClassAttributeValue; +global using ClassElementTypeValue = ILAssembler.CILParser.ClassElementTypeValue; +global using ClassEnumSerializationTypeValue = ILAssembler.CILParser.ClassEnumSerializationTypeValue; +global using ClassHeaderValue = ILAssembler.CILParser.ClassHeaderValue; +global using ClassNameSerializedInitializerValue = ILAssembler.CILParser.ClassNameSerializedInitializerValue; +global using ClassNameValue = ILAssembler.CILParser.ClassNameValue; +global using ClassSerializedSequenceValue = ILAssembler.CILParser.ClassSerializedSequenceValue; +global using ClassSequenceElementValue = ILAssembler.CILParser.ClassSequenceElementValue; +global using ClassTypeSpecificationValue = ILAssembler.CILParser.ClassTypeSpecificationValue; +global using ClassTypedefDeclarationValue = ILAssembler.CILParser.ClassTypedefDeclarationValue; +global using CustomAttributeApplicationValue = ILAssembler.CILParser.CustomAttributeApplicationValue; +global using CustomAttributeBlobValue = ILAssembler.CILParser.CustomAttributeBlobValue; +global using CustomAttributeDeclarationValue = ILAssembler.CILParser.CustomAttributeDeclarationValue; +global using CustomAttributeDescriptorValue = ILAssembler.CILParser.CustomAttributeDescriptorValue; +global using CustomAttributeNamedArgumentValue = ILAssembler.CILParser.CustomAttributeNamedArgumentValue; +global using CustomAttributeTypedefDeclarationValue = ILAssembler.CILParser.CustomAttributeTypedefDeclarationValue; +global using CustomAttributeTypedefValue = ILAssembler.CILParser.CustomAttributeTypedefValue; +global using CustomMarshallerNativeTypeElementValue = ILAssembler.CILParser.CustomMarshallerNativeTypeElementValue; +global using CustomTypeModifierValue = ILAssembler.CILParser.CustomTypeModifierValue; +global using DataDeclarationBuilder = ILAssembler.CILParser.DataDeclarationBuilder; +global using DeprecatedNativeTypeElementValue = ILAssembler.CILParser.DeprecatedNativeTypeElementValue; +global using ElementTypeValue = ILAssembler.CILParser.ElementTypeValue; +global using EmptyNativeTypeElementValue = ILAssembler.CILParser.EmptyNativeTypeElementValue; +global using EmptyPermissionDeclarationValue = ILAssembler.CILParser.EmptyPermissionDeclarationValue; +global using EventHeaderValue = ILAssembler.CILParser.EventHeaderValue; +global using ExceptionClauseValue = ILAssembler.CILParser.ExceptionClauseValue; +global using ExceptionFilterValue = ILAssembler.CILParser.ExceptionFilterValue; +global using ExceptionRangeValue = ILAssembler.CILParser.ExceptionRangeValue; +global using ExportedTypeAssemblyDirectiveValue = ILAssembler.CILParser.ExportedTypeAssemblyDirectiveValue; +global using ExportedTypeCustomAttributeDirectiveValue = ILAssembler.CILParser.ExportedTypeCustomAttributeDirectiveValue; +global using ExportedTypeDeclarationValue = ILAssembler.CILParser.ExportedTypeDeclarationValue; +global using ExportedTypeDefinitionIdDirectiveValue = ILAssembler.CILParser.ExportedTypeDefinitionIdDirectiveValue; +global using ExportedTypeFileDirectiveValue = ILAssembler.CILParser.ExportedTypeFileDirectiveValue; +global using ExportedTypeHeaderValue = ILAssembler.CILParser.ExportedTypeHeaderValue; +global using ExportedTypeMetadataTokenDirectiveValue = ILAssembler.CILParser.ExportedTypeMetadataTokenDirectiveValue; +global using ExportedTypeValue = ILAssembler.CILParser.ExportedTypeValue; +global using FaultExceptionClauseValue = ILAssembler.CILParser.FaultExceptionClauseValue; +global using FieldDeclarationValue = ILAssembler.CILParser.FieldDeclarationValue; +global using FileDeclarationValue = ILAssembler.CILParser.FileDeclarationValue; +global using FieldInitializerValue = ILAssembler.CILParser.FieldInitializerValue; +global using FieldMemberReferenceValue = ILAssembler.CILParser.FieldMemberReferenceValue; +global using FieldReferenceValue = ILAssembler.CILParser.FieldReferenceValue; +global using FilterExceptionClauseValue = ILAssembler.CILParser.FilterExceptionClauseValue; +global using FinallyExceptionClauseValue = ILAssembler.CILParser.FinallyExceptionClauseValue; +global using FixedArrayNativeTypeElementValue = ILAssembler.CILParser.FixedArrayNativeTypeElementValue; +global using FixedSysStringNativeTypeElementValue = ILAssembler.CILParser.FixedSysStringNativeTypeElementValue; +global using FunctionPointerElementTypeValue = ILAssembler.CILParser.FunctionPointerElementTypeValue; +global using GenericArgumentsTypeModifierValue = ILAssembler.CILParser.GenericArgumentsTypeModifierValue; +global using GenericParameterDeclarationValue = ILAssembler.CILParser.GenericParameterDeclarationValue; +global using IidNativeTypeElementValue = ILAssembler.CILParser.IidNativeTypeElementValue; +global using IidParamIndexValue = ILAssembler.CILParser.IidParamIndexValue; +global using IndexedGenericParameterElementTypeValue = ILAssembler.CILParser.IndexedGenericParameterElementTypeValue; +global using InvalidByteArraySerializedInitializerValue = ILAssembler.CILParser.InvalidByteArraySerializedInitializerValue; +global using LabelExceptionFilterValue = ILAssembler.CILParser.LabelExceptionFilterValue; +global using LabelExceptionRangeValue = ILAssembler.CILParser.LabelExceptionRangeValue; +global using LanguageDirectiveValue = ILAssembler.CILParser.LanguageDirectiveValue; +global using ManifestResourceAssemblyDirectiveValue = ILAssembler.CILParser.ManifestResourceAssemblyDirectiveValue; +global using ManifestResourceCustomAttributeDirectiveValue = ILAssembler.CILParser.ManifestResourceCustomAttributeDirectiveValue; +global using ManifestResourceDeclarationValue = ILAssembler.CILParser.ManifestResourceDeclarationValue; +global using ManifestResourceFileDirectiveValue = ILAssembler.CILParser.ManifestResourceFileDirectiveValue; +global using ManifestResourceHeaderValue = ILAssembler.CILParser.ManifestResourceHeaderValue; +global using ManifestResourceValue = ILAssembler.CILParser.ManifestResourceValue; +global using MarshallingDescriptorValue = ILAssembler.CILParser.MarshallingDescriptorValue; +global using MemberOwnerValue = ILAssembler.CILParser.MemberOwnerValue; +global using MemberReferenceValue = ILAssembler.CILParser.MemberReferenceValue; +global using MemberTypedefDeclarationValue = ILAssembler.CILParser.MemberTypedefDeclarationValue; +global using MethodHeaderValue = ILAssembler.CILParser.MethodHeaderValue; +global using MethodMemberReferenceValue = ILAssembler.CILParser.MethodMemberReferenceValue; +global using MethodReferenceValue = ILAssembler.CILParser.MethodReferenceValue; +global using ModuleQualifiedClassNameValue = ILAssembler.CILParser.ModuleQualifiedClassNameValue; +global using ModuleTypeSpecificationValue = ILAssembler.CILParser.ModuleTypeSpecificationValue; +global using NamedGenericParameterElementTypeValue = ILAssembler.CILParser.NamedGenericParameterElementTypeValue; +global using NamedPermissionDeclarationValue = ILAssembler.CILParser.NamedPermissionDeclarationValue; +global using NativeTypeArrayPointerInfoKind = ILAssembler.CILParser.NativeTypeArrayPointerInfoKind; +global using NativeTypeArrayPointerInfoValue = ILAssembler.CILParser.NativeTypeArrayPointerInfoValue; +global using NativeTypeElementValue = ILAssembler.CILParser.NativeTypeElementValue; +global using NativeTypeTypedefValue = ILAssembler.CILParser.NativeTypeTypedefValue; +global using NativeTypeValue = ILAssembler.CILParser.NativeTypeValue; +global using NestedExportedTypeDirectiveValue = ILAssembler.CILParser.NestedExportedTypeDirectiveValue; +global using NestedStructNativeTypeElementValue = ILAssembler.CILParser.NestedStructNativeTypeElementValue; +global using ObjectSerializedInitializerValue = ILAssembler.CILParser.ObjectSerializedInitializerValue; +global using ObjectSerializedSequenceValue = ILAssembler.CILParser.ObjectSerializedSequenceValue; +global using OffsetExceptionFilterValue = ILAssembler.CILParser.OffsetExceptionFilterValue; +global using OffsetExceptionRangeValue = ILAssembler.CILParser.OffsetExceptionRangeValue; +global using OwnerTypeValue = ILAssembler.CILParser.OwnerTypeValue; +global using ParsedFieldReferenceValue = ILAssembler.CILParser.ParsedFieldReferenceValue; +global using ParsedMethodReferenceValue = ILAssembler.CILParser.ParsedMethodReferenceValue; +global using PermissionDeclarationValue = ILAssembler.CILParser.PermissionDeclarationValue; +global using PInvokeValue = ILAssembler.CILParser.PInvokeValue; +global using PointerQualifiedClassNameValue = ILAssembler.CILParser.PointerQualifiedClassNameValue; +global using PrimitiveElementTypeValue = ILAssembler.CILParser.PrimitiveElementTypeValue; +global using PropertyHeaderValue = ILAssembler.CILParser.PropertyHeaderValue; +global using RawCustomAttributeBlobValue = ILAssembler.CILParser.RawCustomAttributeBlobValue; +global using RawPermissionSetValue = ILAssembler.CILParser.RawPermissionSetValue; +global using RawSerializationTypeValue = ILAssembler.CILParser.RawSerializationTypeValue; +global using RawSerializedInitializerValue = ILAssembler.CILParser.RawSerializedInitializerValue; +global using RawSerializedSequenceValue = ILAssembler.CILParser.RawSerializedSequenceValue; +global using RawVTableValue = ILAssembler.CILParser.RawVTableValue; +global using SafeArrayNativeTypeElementValue = ILAssembler.CILParser.SafeArrayNativeTypeElementValue; +global using ScopeExceptionFilterValue = ILAssembler.CILParser.ScopeExceptionFilterValue; +global using ScopeExceptionRangeValue = ILAssembler.CILParser.ScopeExceptionRangeValue; +global using SecurityAttributeValue = ILAssembler.CILParser.SecurityAttributeValue; +global using SecurityBooleanValue = ILAssembler.CILParser.SecurityBooleanValue; +global using SecurityCaValue = ILAssembler.CILParser.SecurityCaValue; +global using SecurityDeclarationValue = ILAssembler.CILParser.SecurityDeclarationValue; +global using SecurityEnumValue = ILAssembler.CILParser.SecurityEnumValue; +global using SecurityInt32Value = ILAssembler.CILParser.SecurityInt32Value; +global using SecurityNameValuePairValue = ILAssembler.CILParser.SecurityNameValuePairValue; +global using SecurityStringValue = ILAssembler.CILParser.SecurityStringValue; +global using SentinelElementTypeValue = ILAssembler.CILParser.SentinelElementTypeValue; +global using SerializationTypeValue = ILAssembler.CILParser.SerializationTypeValue; +global using SerializedInitializerValue = ILAssembler.CILParser.SerializedInitializerValue; +global using SerializedSequenceValue = ILAssembler.CILParser.SerializedSequenceValue; +global using SignatureArgumentValue = ILAssembler.CILParser.SignatureArgumentValue; +global using SignatureTypeSpecificationValue = ILAssembler.CILParser.SignatureTypeSpecificationValue; +global using SimpleNativeTypeElementValue = ILAssembler.CILParser.SimpleNativeTypeElementValue; +global using SimpleSerializationTypeValue = ILAssembler.CILParser.SimpleSerializationTypeValue; +global using SimpleTypeModifierKind = ILAssembler.CILParser.SimpleTypeModifierKind; +global using SimpleTypeModifierValue = ILAssembler.CILParser.SimpleTypeModifierValue; +global using SourceDirectiveValue = ILAssembler.CILParser.SourceDirectiveValue; +global using SpecialClassNameKind = ILAssembler.CILParser.SpecialClassNameKind; +global using SpecialClassNameValue = ILAssembler.CILParser.SpecialClassNameValue; +global using StringClassSequenceElementValue = ILAssembler.CILParser.StringClassSequenceElementValue; +global using StringEnumSerializationTypeValue = ILAssembler.CILParser.StringEnumSerializationTypeValue; +global using StringPermissionSetValue = ILAssembler.CILParser.StringPermissionSetValue; +global using StructuredCustomAttributeBlobValue = ILAssembler.CILParser.StructuredCustomAttributeBlobValue; +global using StructuredPermissionDeclarationValue = ILAssembler.CILParser.StructuredPermissionDeclarationValue; +global using TokenClassNameValue = ILAssembler.CILParser.TokenClassNameValue; +global using TokenMemberReferenceValue = ILAssembler.CILParser.TokenMemberReferenceValue; +global using TokenMethodReferenceValue = ILAssembler.CILParser.TokenMethodReferenceValue; +global using TokenQualifiedClassNameValue = ILAssembler.CILParser.TokenQualifiedClassNameValue; +global using TypeClassSequenceElementValue = ILAssembler.CILParser.TypeClassSequenceElementValue; +global using TypeModifierValue = ILAssembler.CILParser.TypeModifierValue; +global using TypeName = ILAssembler.CILParser.TypeName; +global using TypeOwnerValue = ILAssembler.CILParser.TypeOwnerValue; +global using TypeSignatureTypedefDeclarationValue = ILAssembler.CILParser.TypeSignatureTypedefDeclarationValue; +global using TypeSpecificationValue = ILAssembler.CILParser.TypeSpecificationValue; +global using TypeValue = ILAssembler.CILParser.TypeValue; +global using TypedefDeclarationValue = ILAssembler.CILParser.TypedefDeclarationValue; +global using TypedefElementTypeValue = ILAssembler.CILParser.TypedefElementTypeValue; +global using TypedefEntry = ILAssembler.CILParser.TypedefEntry; +global using TypedefFieldReferenceValue = ILAssembler.CILParser.TypedefFieldReferenceValue; +global using TypedefMethodReferenceValue = ILAssembler.CILParser.TypedefMethodReferenceValue; +global using TypedefSerializationTypeValue = ILAssembler.CILParser.TypedefSerializationTypeValue; +global using UnqualifiedClassNameValue = ILAssembler.CILParser.UnqualifiedClassNameValue; +global using UnsignedNativeTypeElementValue = ILAssembler.CILParser.UnsignedNativeTypeElementValue; +global using VariantBoolNativeTypeElementValue = ILAssembler.CILParser.VariantBoolNativeTypeElementValue; +global using VariantTypeElementValue = ILAssembler.CILParser.VariantTypeElementValue; +global using VariantTypeValue = ILAssembler.CILParser.VariantTypeValue; +global using VTableFixupValue = ILAssembler.CILParser.VTableFixupValue; diff --git a/src/tools/ilasm/src/ILAssembler/CILParser.SemanticValues.CustomAttributes.cs b/src/tools/ilasm/src/ILAssembler/CILParser.SemanticValues.CustomAttributes.cs new file mode 100644 index 00000000000000..75c72a98e4f2ff --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/CILParser.SemanticValues.CustomAttributes.cs @@ -0,0 +1,148 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Immutable; +using System.Reflection.Metadata; +using Antlr4.Runtime; + +namespace ILAssembler; + +public partial class CILParser +{ + public abstract record CustomAttributeDeclarationValue + { + public static CustomAttributeDeclarationValue Error { get; } = + new ErrorCustomAttributeDeclarationValue(); + } + + public sealed record ErrorCustomAttributeDeclarationValue : CustomAttributeDeclarationValue; + + public sealed record CustomAttributeDescriptorValue( + MethodReferenceValue Constructor, + CustomAttributeBlobValue Value, + OwnerTypeValue? Owner) : CustomAttributeDeclarationValue + { + public static new CustomAttributeDescriptorValue Error { get; } = + new(MethodReferenceValue.Error, CustomAttributeBlobValue.Error, null); + } + + public sealed record CustomAttributeTypedefValue( + string Alias) : CustomAttributeDeclarationValue; + + public sealed record CustomAttributeApplicationValue( + CustomAttributeDeclarationValue? Value, + IToken Location, + bool HasSyntaxError); + + public abstract record CustomAttributeBlobValue + { + public static CustomAttributeBlobValue Error { get; } = + new ErrorCustomAttributeBlobValue(); + } + + public sealed record ErrorCustomAttributeBlobValue : CustomAttributeBlobValue; + + public sealed record RawCustomAttributeBlobValue( + BlobBuilder Value) : CustomAttributeBlobValue; + + public sealed record StructuredCustomAttributeBlobValue( + ImmutableArray Arguments, + ImmutableArray NamedArguments) + : CustomAttributeBlobValue; + + public sealed record CustomAttributeNamedArgumentValue( + byte Kind, + SerializationTypeValue Type, + string Name, + SerializedInitializerValue Value); + + public abstract record SerializationTypeValue + { + public static SerializationTypeValue Error { get; } = + new ErrorSerializationTypeValue(); + } + + public sealed record ErrorSerializationTypeValue : SerializationTypeValue; + + public sealed record RawSerializationTypeValue( + BlobBuilder Value) : SerializationTypeValue; + + public sealed record SimpleSerializationTypeValue( + SerializationTypeCode Type) : SerializationTypeValue; + + public sealed record ArraySerializationTypeValue( + SerializationTypeValue ElementType) : SerializationTypeValue; + + public sealed record StringEnumSerializationTypeValue( + string Name) : SerializationTypeValue; + + public sealed record ClassEnumSerializationTypeValue( + ClassNameValue ClassName) : SerializationTypeValue; + + public sealed record TypedefSerializationTypeValue( + IToken Token, + string Alias) : SerializationTypeValue; + + public abstract record SerializedInitializerValue(SerializationTypeValue Type) + { + public static SerializedInitializerValue Error { get; } = + new ErrorSerializedInitializerValue(); + } + + public sealed record ErrorSerializedInitializerValue() + : SerializedInitializerValue(SerializationTypeValue.Error); + + public sealed record RawSerializedInitializerValue( + SerializationTypeValue Type, + BlobBuilder Value) : SerializedInitializerValue(Type); + + public sealed record ClassNameSerializedInitializerValue( + ClassNameValue ClassName) + : SerializedInitializerValue( + new SimpleSerializationTypeValue(SerializationTypeCode.Type)); + + public sealed record ObjectSerializedInitializerValue( + SerializedInitializerValue Value) + : SerializedInitializerValue( + new SimpleSerializationTypeValue(SerializationTypeCode.TaggedObject)); + + public sealed record InvalidByteArraySerializedInitializerValue( + IToken Token) + : SerializedInitializerValue( + new SimpleSerializationTypeValue(SerializationTypeCode.String)); + + public sealed record ArraySerializedInitializerValue( + SerializationTypeValue Type, + int Length, + SerializedSequenceValue Values) : SerializedInitializerValue(Type); + + public abstract record SerializedSequenceValue; + + public sealed record RawSerializedSequenceValue( + BlobBuilder Value) : SerializedSequenceValue; + + public sealed record ClassSerializedSequenceValue( + ImmutableArray Values) : SerializedSequenceValue; + + public sealed record ObjectSerializedSequenceValue( + ImmutableArray Values) : SerializedSequenceValue; + + public abstract record ClassSequenceElementValue + { + public static ClassSequenceElementValue Error { get; } = + new ErrorClassSequenceElementValue(); + } + + public sealed record ErrorClassSequenceElementValue : ClassSequenceElementValue; + + public sealed record StringClassSequenceElementValue( + string? Value) : ClassSequenceElementValue; + + public sealed record TypeClassSequenceElementValue( + ClassNameValue ClassName) : ClassSequenceElementValue; + + public sealed record FieldInitializerValue(bool HasValue, object? ConstantValue) + { + public static FieldInitializerValue Empty { get; } = new(false, null); + } +} diff --git a/src/tools/ilasm/src/ILAssembler/CILParser.SemanticValues.Declarations.cs b/src/tools/ilasm/src/ILAssembler/CILParser.SemanticValues.Declarations.cs new file mode 100644 index 00000000000000..f8249369b6a00d --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/CILParser.SemanticValues.Declarations.cs @@ -0,0 +1,222 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Immutable; +using System.Reflection; +using Antlr4.Runtime; + +namespace ILAssembler; + +public partial class CILParser +{ + public sealed record AttributeValue(T Value, T GroupMask, bool ShouldAppend) + where T : struct, System.Enum + { + public static AttributeValue Empty { get; } = new(default, default, true); + } + + public sealed record PInvokeValue( + string? ModuleName, + string? EntryPointName, + MethodImportAttributes Attributes); + + public sealed record GenericParameterDeclarationValue( + GenericParameterAttributes Attributes, + string Name, + ImmutableArray Constraints) + { + public static GenericParameterDeclarationValue Error { get; } = + new(0, string.Empty, []); + } + + public sealed record MethodHeaderValue( + bool IsValid, + MethodAttributes Attributes, + ImmutableArray PInvokes, + byte CallingConvention, + int ReturnAttributes, + TypeValue ReturnType, + MarshallingDescriptorValue ReturnMarshalling, + string Name, + ImmutableArray GenericParameters, + ImmutableArray Arguments, + MethodImplAttributes ImplementationAttributes) + { + public static MethodHeaderValue Error { get; } = new( + false, + 0, + [], + 0, + 0, + TypeValue.Error, + MarshallingDescriptorValue.Empty, + string.Empty, + [], + [], + 0); + } + + public sealed record FieldDeclarationValue( + bool IsValid, + FieldAttributes Attributes, + TypeValue FieldType, + string Name, + MarshallingDescriptorValue Marshalling, + string? DataDeclarationName, + int? Offset, + FieldInitializerValue Initializer) + { + public static FieldDeclarationValue Error { get; } = new( + false, + 0, + TypeValue.Error, + string.Empty, + MarshallingDescriptorValue.Empty, + null, + null, + FieldInitializerValue.Empty); + } + + public sealed record PropertyHeaderValue( + bool IsValid, + PropertyAttributes Attributes, + byte CallingConvention, + TypeValue PropertyType, + string Name, + ImmutableArray Arguments, + FieldInitializerValue Initializer) + { + public static PropertyHeaderValue Error { get; } = new( + false, + 0, + 0, + TypeValue.Error, + string.Empty, + [], + FieldInitializerValue.Empty); + } + + public sealed record EventHeaderValue( + bool IsValid, + EventAttributes Attributes, + TypeSpecificationValue? EventType, + string Name) + { + public static EventHeaderValue Error { get; } = + new(false, 0, null, string.Empty); + } + + public sealed class ClassAttributeValue + { + public static ClassAttributeValue Empty { get; } = + new(AttributeValue.Empty, null, false); + + internal ClassAttributeValue( + AttributeValue attribute, + EntityRegistry.WellKnownBaseType? fallbackBase, + bool requireSealed) + { + Attribute = attribute; + FallbackBase = fallbackBase; + RequireSealed = requireSealed; + } + + internal AttributeValue Attribute { get; } + + internal EntityRegistry.WellKnownBaseType? FallbackBase { get; } + + internal bool RequireSealed { get; } + } + + public sealed record ClassHeaderValue( + bool IsValid, + IToken? NameToken, + string FullName, + ImmutableArray Attributes, + ImmutableArray GenericParameters, + TypeSpecificationValue? BaseType, + ImmutableArray Interfaces) + { + public static ClassHeaderValue Error { get; } = new( + false, + null, + string.Empty, + [], + [], + null, + []); + } + + public sealed class MethodHeaderBuilder + { + internal MethodAttributes Attributes { get; set; } + + internal ImmutableArray.Builder PInvokes { get; } = + ImmutableArray.CreateBuilder(); + + internal MethodImplAttributes ImplementationAttributes { get; set; } + } + + public sealed class PInvokeBuilder + { + internal string? ModuleName { get; set; } + + internal string? EntryPointName { get; set; } + + internal MethodImportAttributes Attributes { get; set; } + } + + public sealed class FieldDeclarationBuilder + { + internal FieldAttributes Attributes { get; set; } + + internal MarshallingDescriptorValue Marshalling { get; set; } = + MarshallingDescriptorValue.Empty; + } + + public sealed class PropertyHeaderBuilder + { + internal PropertyAttributes Attributes { get; set; } + } + + public sealed class EventHeaderBuilder + { + internal EventAttributes Attributes { get; set; } + } + + public sealed class ClassHeaderBuilder + { + internal ImmutableArray.Builder Attributes { get; } = + ImmutableArray.CreateBuilder(); + } + + public sealed class PropertyBodyValue + { + internal PropertyBodyValue(EntityRegistry.PropertyEntity? property) + { + Property = property; + } + + internal EntityRegistry.PropertyEntity? Property { get; } + } + + public sealed class EventBodyValue + { + internal EventBodyValue(EntityRegistry.EventEntity? @event) + { + Event = @event; + } + + internal EntityRegistry.EventEntity? Event { get; } + } + + public sealed class CustomAttributeOwnerValue + { + internal CustomAttributeOwnerValue(EntityRegistry.EntityBase? owner) + { + Owner = owner; + } + + internal EntityRegistry.EntityBase? Owner { get; } + } +} diff --git a/src/tools/ilasm/src/ILAssembler/CILParser.SemanticValues.Manifest.cs b/src/tools/ilasm/src/ILAssembler/CILParser.SemanticValues.Manifest.cs new file mode 100644 index 00000000000000..b3e11f6226c8b5 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/CILParser.SemanticValues.Manifest.cs @@ -0,0 +1,223 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Immutable; +using System.Reflection; +using System.Reflection.Metadata; +using Antlr4.Runtime; + +namespace ILAssembler; + +public partial class CILParser +{ + public abstract record AssemblyDeclarationValue; + + public sealed record AssemblyDefinitionValue( + AssemblyFlags Attributes, + string Name, + ImmutableArray Declarations); + + public sealed record AssemblyReferenceValue( + AssemblyReferenceHeaderValue Header, + ImmutableArray Declarations); + + public sealed record AssemblyReferenceHeaderValue( + bool IsValid, + AssemblyFlags Attributes, + string Name, + string Alias) + { + public static AssemblyReferenceHeaderValue Error { get; } = + new(false, 0, string.Empty, string.Empty); + } + + public sealed record AssemblyPublicKeyDirectiveValue( + ImmutableArray Value) : AssemblyDeclarationValue; + + public sealed record AssemblyVersionDirectiveValue( + Version Value) : AssemblyDeclarationValue; + + public sealed record AssemblyLocaleDirectiveValue( + string Value) : AssemblyDeclarationValue; + + public sealed record AssemblyCustomAttributeDirectiveValue( + CustomAttributeDeclarationValue? Value, + IToken Location) : AssemblyDeclarationValue; + + public sealed record AssemblyHashAlgorithmDirectiveValue( + AssemblyHashAlgorithm Value) : AssemblyDeclarationValue; + + public sealed record AssemblySecurityDirectiveValue( + SecurityDeclarationValue? Value, + IToken Location) : AssemblyDeclarationValue; + + public sealed record AssemblyReferenceHashDirectiveValue( + ImmutableArray Value) : AssemblyDeclarationValue; + + public sealed record AssemblyReferencePublicKeyTokenDirectiveValue( + ImmutableArray Value) : AssemblyDeclarationValue; + + public sealed record FileDeclarationValue( + string Name, + bool HasMetadata, + bool IsEntryPoint, + ImmutableArray? Hash); + + public sealed class FileDeclarationBuilder + { + internal string Name { get; set; } = string.Empty; + + internal bool HasMetadata { get; set; } = true; + + internal bool IsEntryPoint { get; set; } + + internal ImmutableArray? Hash { get; set; } + } + + public abstract record ExportedTypeDeclarationValue; + + public sealed record ExportedTypeValue( + ExportedTypeHeaderValue Header, + ImmutableArray Declarations); + + public sealed record ExportedTypeHeaderValue( + bool IsValid, + TypeAttributes Attributes, + string Name, + IToken? Location) + { + public static ExportedTypeHeaderValue Error { get; } = + new(false, 0, string.Empty, null); + } + + public sealed record ExportedTypeFileDirectiveValue( + string Name, + IToken Location) : ExportedTypeDeclarationValue; + + public sealed record NestedExportedTypeDirectiveValue( + TypeName Name, + IToken Location) : ExportedTypeDeclarationValue; + + public sealed record ExportedTypeAssemblyDirectiveValue( + string Name, + IToken Location) : ExportedTypeDeclarationValue; + + public sealed record ExportedTypeMetadataTokenDirectiveValue( + int Token, + IToken Location) : ExportedTypeDeclarationValue; + + public sealed record ExportedTypeDefinitionIdDirectiveValue( + int Value) : ExportedTypeDeclarationValue; + + public sealed record ExportedTypeCustomAttributeDirectiveValue( + CustomAttributeDeclarationValue? Value, + IToken Location) : ExportedTypeDeclarationValue; + + public abstract record ManifestResourceDeclarationValue; + + public sealed record ManifestResourceValue( + ManifestResourceHeaderValue Header, + ImmutableArray Declarations); + + public sealed record ManifestResourceHeaderValue( + bool IsValid, + ManifestResourceAttributes Attributes, + string Name, + string Alias, + IToken? Location) + { + public static ManifestResourceHeaderValue Error { get; } = + new(false, 0, string.Empty, string.Empty, null); + } + + public sealed record ManifestResourceFileDirectiveValue( + string Name, + uint Offset, + IToken Location) : ManifestResourceDeclarationValue; + + public sealed record ManifestResourceAssemblyDirectiveValue( + string Name) : ManifestResourceDeclarationValue; + + public sealed record ManifestResourceCustomAttributeDirectiveValue( + CustomAttributeDeclarationValue? Value, + IToken Location) : ManifestResourceDeclarationValue; + + public sealed record RawVTableValue(ImmutableArray Value); + + public sealed record VTableFixupValue(int SlotCount, ushort Flags, string DataLabel); + + public abstract record TypedefDeclarationValue(string Alias) + { + public static TypedefDeclarationValue Error { get; } = + new ErrorTypedefDeclarationValue(); + } + + public sealed record ErrorTypedefDeclarationValue() + : TypedefDeclarationValue(string.Empty); + + public sealed record TypeSignatureTypedefDeclarationValue( + TypeValue Type, + string Alias) : TypedefDeclarationValue(Alias); + + public sealed record ClassTypedefDeclarationValue( + ClassNameValue Type, + string Alias) : TypedefDeclarationValue(Alias); + + public sealed record MemberTypedefDeclarationValue( + MemberReferenceValue Member, + string Alias) : TypedefDeclarationValue(Alias); + + public sealed record CustomAttributeTypedefDeclarationValue( + CustomAttributeDescriptorValue Attribute, + IToken Location, + string Alias) : TypedefDeclarationValue(Alias); + + public abstract class TypedefEntry + { + public sealed class Type : TypedefEntry + { + internal Type(EntityRegistry.TypeEntity entity) + { + Entity = entity; + } + + internal EntityRegistry.TypeEntity Entity { get; } + } + + public sealed class TypeBlob : TypedefEntry + { + internal TypeBlob(BlobBuilder blob) + { + Blob = blob; + } + + internal BlobBuilder Blob { get; } + } + + public sealed class Member : TypedefEntry + { + internal Member(EntityRegistry.EntityBase entity) + { + Entity = entity; + } + + internal EntityRegistry.EntityBase Entity { get; } + } + + public sealed class CustomAttribute : TypedefEntry + { + internal CustomAttribute( + EntityRegistry.EntityBase constructor, + BlobBuilder value) + { + Constructor = constructor; + Value = value; + } + + internal EntityRegistry.EntityBase Constructor { get; } + + internal BlobBuilder Value { get; } + } + } +} diff --git a/src/tools/ilasm/src/ILAssembler/CILParser.SemanticValues.Marshalling.cs b/src/tools/ilasm/src/ILAssembler/CILParser.SemanticValues.Marshalling.cs new file mode 100644 index 00000000000000..fa0e57c974a4e7 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/CILParser.SemanticValues.Marshalling.cs @@ -0,0 +1,138 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Reflection.Metadata; +using System.Runtime.InteropServices; +using Antlr4.Runtime; + +namespace ILAssembler; + +public partial class CILParser +{ + public sealed record MarshallingDescriptorValue( + BlobBuilder? RawBytes, + NativeTypeValue? NativeType) + { + public static MarshallingDescriptorValue Empty { get; } = + new(new BlobBuilder(0), null); + } + + public sealed record NativeTypeValue( + IToken? Token, + NativeTypeElementValue? Element, + ImmutableArray ArrayPointerInfo) + { + public static NativeTypeValue Empty { get; } = new(null, null, []); + } + + public abstract record NativeTypeElementValue; + + public sealed record EmptyNativeTypeElementValue : NativeTypeElementValue + { + public static EmptyNativeTypeElementValue Instance { get; } = new(); + } + + public sealed record CustomMarshallerNativeTypeElementValue( + IToken? Token, + string? Guid, + string? NativeTypeName, + string MarshallerType, + string Cookie) : NativeTypeElementValue; + + public sealed record FixedSysStringNativeTypeElementValue( + IToken Size) : NativeTypeElementValue; + + public sealed record FixedArrayNativeTypeElementValue( + IToken Size, + NativeTypeValue Element) : NativeTypeElementValue; + + public sealed record DeprecatedNativeTypeElementValue( + IToken Token, + int TokenType) : NativeTypeElementValue; + + public sealed record SimpleNativeTypeElementValue( + int TokenType) : NativeTypeElementValue; + + public sealed record IidNativeTypeElementValue( + int TokenType, + IidParamIndexValue IidParamIndex) : NativeTypeElementValue; + + public sealed record SafeArrayNativeTypeElementValue( + VariantTypeValue VariantType, + string? UserDefinedType) : NativeTypeElementValue; + + public sealed record UnsignedNativeTypeElementValue( + int TokenType) : NativeTypeElementValue; + + public sealed record NestedStructNativeTypeElementValue( + IToken Token) : NativeTypeElementValue; + + public sealed record AnsiBstrNativeTypeElementValue : NativeTypeElementValue + { + public static AnsiBstrNativeTypeElementValue Instance { get; } = new(); + } + + public sealed record VariantBoolNativeTypeElementValue : NativeTypeElementValue + { + public static VariantBoolNativeTypeElementValue Instance { get; } = new(); + } + + public sealed record NativeTypeTypedefValue( + IToken Token, + string Alias) : NativeTypeElementValue; + + public enum NativeTypeArrayPointerInfoKind + { + Pointer, + ArrayNoSizeData, + ArraySize, + ArraySizeParamIndex, + ArrayParamIndex + } + + public sealed record NativeTypeArrayPointerInfoValue( + NativeTypeArrayPointerInfoKind Kind, + IToken? Size = null, + IToken? ParameterIndex = null); + + public sealed record IidParamIndexValue(IToken? Index) + { + public static IidParamIndexValue Empty { get; } = new((IToken?)null); + } + + public sealed record VariantTypeValue( + VariantTypeElementValue? Element, + VarEnum Modifiers) + { + public static VariantTypeValue Empty { get; } = new(null, 0); + } + + public sealed record VariantTypeElementValue(int TokenType) + { + public static VariantTypeElementValue Error { get; } = + new(TokenConstants.InvalidType); + } + + public sealed class MarshalBlobBuilder + { + internal NativeTypeValue? NativeType { get; set; } + + internal BlobBuilder? RawBytes { get; set; } + } + + public sealed class NativeTypeBuilder + { + internal NativeTypeElementValue? Element { get; set; } + + internal List? ArrayPointerInfo { get; set; } + } + + public sealed class VariantTypeBuilder + { + internal VariantTypeElementValue? Element { get; set; } + + internal VarEnum Modifiers { get; set; } + } +} diff --git a/src/tools/ilasm/src/ILAssembler/CILParser.SemanticValues.MethodBodies.cs b/src/tools/ilasm/src/ILAssembler/CILParser.SemanticValues.MethodBodies.cs new file mode 100644 index 00000000000000..b11c1c0363797a --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/CILParser.SemanticValues.MethodBodies.cs @@ -0,0 +1,206 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Reflection; +using System.Reflection.Metadata; +using System.Text; +using Antlr4.Runtime; + +namespace ILAssembler; + +public partial class CILParser +{ + public sealed class DottedNameBuilder + { + internal StringBuilder Value { get; } = new(); + + internal bool HasPart { get; set; } + } + + public sealed record SourceDirectiveValue( + bool AutoIncrement, + int StartLine, + int StartColumn, + int EndLine, + int EndColumn, + string? DocumentPath); + + public sealed record LanguageDirectiveValue( + string Language, + string? Vendor, + string? DocumentType); + + public abstract record ExceptionRangeValue + { + public static ExceptionRangeValue Invalid { get; } = + new InvalidExceptionRangeValue(); + } + + public sealed record InvalidExceptionRangeValue : ExceptionRangeValue; + + public sealed record ScopeExceptionRangeValue( + ScopeBlockContext Scope) : ExceptionRangeValue; + + public sealed record LabelExceptionRangeValue( + string Start, + string End) : ExceptionRangeValue; + + public sealed record OffsetExceptionRangeValue( + int Start, + int End) : ExceptionRangeValue; + + public abstract record ExceptionFilterValue + { + public static ExceptionFilterValue Invalid { get; } = + new InvalidExceptionFilterValue(); + } + + public sealed record InvalidExceptionFilterValue : ExceptionFilterValue; + + public sealed record ScopeExceptionFilterValue( + ScopeBlockContext Scope) : ExceptionFilterValue; + + public sealed record LabelExceptionFilterValue( + string Label) : ExceptionFilterValue; + + public sealed record OffsetExceptionFilterValue( + int Offset) : ExceptionFilterValue; + + public sealed class CatchTypeValue + { + internal CatchTypeValue(EntityRegistry.TypeEntity? type, bool isValid) + { + Type = type; + IsValid = isValid; + } + + public static CatchTypeValue Invalid { get; } = new(null, isValid: false); + + internal EntityRegistry.TypeEntity? Type { get; } + + public bool IsValid { get; } + } + + public abstract record ExceptionClauseValue(ExceptionRangeValue Handler) + { + public static ExceptionClauseValue Invalid { get; } = + new InvalidExceptionClauseValue(ExceptionRangeValue.Invalid); + } + + public sealed record InvalidExceptionClauseValue( + ExceptionRangeValue Handler) : ExceptionClauseValue(Handler); + + public sealed record CatchExceptionClauseValue( + CatchTypeValue CatchType, + ExceptionRangeValue Handler) : ExceptionClauseValue(Handler); + + public sealed record FilterExceptionClauseValue( + ExceptionFilterValue Filter, + ExceptionRangeValue Handler) : ExceptionClauseValue(Handler); + + public sealed record FinallyExceptionClauseValue( + ExceptionRangeValue Handler) : ExceptionClauseValue(Handler); + + public sealed record FaultExceptionClauseValue( + ExceptionRangeValue Handler) : ExceptionClauseValue(Handler); + + public abstract record SecurityDeclarationValue(DeclarativeSecurityAction Action); + + public abstract record PermissionDeclarationValue( + DeclarativeSecurityAction Action, + TypeSpecificationValue PermissionType) : SecurityDeclarationValue(Action); + + public sealed record NamedPermissionDeclarationValue( + DeclarativeSecurityAction Action, + TypeSpecificationValue PermissionType, + ImmutableArray Pairs) + : PermissionDeclarationValue(Action, PermissionType); + + public sealed record StructuredPermissionDeclarationValue( + DeclarativeSecurityAction Action, + TypeSpecificationValue PermissionType, + CustomAttributeBlobValue Value) + : PermissionDeclarationValue(Action, PermissionType); + + public sealed record EmptyPermissionDeclarationValue( + DeclarativeSecurityAction Action, + TypeSpecificationValue PermissionType) + : PermissionDeclarationValue(Action, PermissionType); + + public sealed record RawPermissionSetValue( + DeclarativeSecurityAction Action, + ImmutableArray Value) : SecurityDeclarationValue(Action); + + public sealed record StringPermissionSetValue( + DeclarativeSecurityAction Action, + string Value) : SecurityDeclarationValue(Action); + + public sealed record AttributePermissionSetValue( + DeclarativeSecurityAction Action, + ImmutableArray Attributes) : SecurityDeclarationValue(Action); + + public sealed record SecurityAttributeValue( + string? Name, + TypeSpecificationValue? Type, + ImmutableArray Arguments) + { + public static SecurityAttributeValue Error { get; } = + new(null, null, []); + } + + public sealed record SecurityNameValuePairValue( + string Name, + SecurityCaValue Value) + { + public static SecurityNameValuePairValue Error { get; } = + new(string.Empty, SecurityCaValue.Error); + } + + public abstract record SecurityCaValue + { + public static SecurityCaValue Error { get; } = new ErrorSecurityCaValue(); + } + + public sealed record ErrorSecurityCaValue : SecurityCaValue; + + public sealed record SecurityBooleanValue(bool Value) : SecurityCaValue; + + public sealed record SecurityInt32Value(int Value) : SecurityCaValue; + + public sealed record SecurityStringValue(string Value) : SecurityCaValue; + + public sealed record SecurityEnumValue( + ClassNameValue Type, + byte Size, + int Value) : SecurityCaValue; + + public sealed class DataDeclarationBuilder + { + internal DataDeclarationBuilder(bool shouldCommit) + { + ShouldCommit = shouldCommit; + } + + internal bool ShouldCommit { get; } + + internal BlobBuilder Data { get; } = new(); + + internal Dictionary>? ReferenceFixups { get; set; } + + internal string? Name { get; set; } + } + + public sealed class SwitchInstructionBuilder + { + internal SwitchInstructionBuilder(IToken opcodeToken) + { + OpcodeToken = opcodeToken; + } + + internal IToken OpcodeToken { get; } + + internal List<(IToken Token, bool IsOffset)> Operands { get; } = new(); + } +} diff --git a/src/tools/ilasm/src/ILAssembler/CILParser.SemanticValues.Signatures.cs b/src/tools/ilasm/src/ILAssembler/CILParser.SemanticValues.Signatures.cs new file mode 100644 index 00000000000000..d5b0b627a2fff7 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/CILParser.SemanticValues.Signatures.cs @@ -0,0 +1,218 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Immutable; +using Antlr4.Runtime; + +namespace ILAssembler; + +public partial class CILParser +{ + public sealed record TypeName(TypeName? ContainingTypeName, string DottedName); + + public sealed record ArrayBoundValue(int? Lower, int? Upper); + + public abstract record ElementTypeValue + { + public static ElementTypeValue Error { get; } = new ErrorElementTypeValue(); + } + + public sealed record ErrorElementTypeValue : ElementTypeValue; + + public sealed record PrimitiveElementTypeValue(byte TypeCode) : ElementTypeValue; + + public sealed record ClassElementTypeValue(ClassNameValue ClassName, bool IsValueType) : ElementTypeValue; + + public sealed record FunctionPointerElementTypeValue( + byte CallingConvention, + TypeValue ReturnType, + ImmutableArray Arguments) : ElementTypeValue; + + public abstract record GenericParameterElementTypeValue(bool IsMethodParameter) : ElementTypeValue; + + public sealed record IndexedGenericParameterElementTypeValue(bool IsMethodParameter, int Index) + : GenericParameterElementTypeValue(IsMethodParameter); + + public sealed record NamedGenericParameterElementTypeValue( + IToken Token, + bool IsMethodParameter, + string Name) : GenericParameterElementTypeValue(IsMethodParameter); + + public sealed record TypedefElementTypeValue(IToken Token, string Alias) : ElementTypeValue; + + public sealed record SentinelElementTypeValue(TypeValue Type) : ElementTypeValue; + + public sealed record TypeValue( + ElementTypeValue ElementType, + ImmutableArray Modifiers) + { + public static TypeValue Error { get; } = new(ElementTypeValue.Error, []); + } + + public abstract record TypeModifierValue + { + public static TypeModifierValue Error { get; } = new ErrorTypeModifierValue(); + } + + public sealed record ErrorTypeModifierValue : TypeModifierValue; + + public enum SimpleTypeModifierKind + { + SzArray, + ByReference, + Pointer, + Pinned + } + + public sealed record SimpleTypeModifierValue(SimpleTypeModifierKind Kind) : TypeModifierValue; + + public sealed record ArrayTypeModifierValue(ImmutableArray Bounds) : TypeModifierValue; + + public sealed record CustomTypeModifierValue( + TypeSpecificationValue Type, + bool IsRequired) : TypeModifierValue; + + public sealed record GenericArgumentsTypeModifierValue( + ImmutableArray Arguments) : TypeModifierValue; + + public sealed record SignatureArgumentValue( + bool IsSentinel, + int Attributes, + TypeValue? Type, + MarshallingDescriptorValue? Marshalling, + string? Name) + { + public static SignatureArgumentValue Error { get; } = + new(false, 0, TypeValue.Error, null, null); + } + + public sealed record CalliSignatureValue( + byte CallingConvention, + TypeValue ReturnType, + ImmutableArray Arguments) + { + public static CalliSignatureValue Error { get; } = new(0, TypeValue.Error, []); + } + + public abstract record ClassNameValue + { + public static ClassNameValue Error { get; } = new ErrorClassNameValue(); + } + + public sealed record ErrorClassNameValue : ClassNameValue; + + public sealed record UnqualifiedClassNameValue(TypeName Name) : ClassNameValue; + + public sealed record AssemblyQualifiedClassNameValue( + string AssemblyName, + TypeName Name) : ClassNameValue; + + public sealed record ModuleQualifiedClassNameValue( + IToken Token, + string ModuleName, + TypeName Name) : ClassNameValue; + + public sealed record TokenQualifiedClassNameValue( + int Token, + TypeName Name) : ClassNameValue; + + public sealed record PointerQualifiedClassNameValue(TypeName Name) : ClassNameValue; + + public sealed record TokenClassNameValue(int Token) : ClassNameValue; + + public enum SpecialClassNameKind + { + This, + Base, + Nester + } + + public sealed record SpecialClassNameValue( + IToken Token, + SpecialClassNameKind Kind) : ClassNameValue; + + public abstract record TypeSpecificationValue + { + public static TypeSpecificationValue Error { get; } = + new ErrorTypeSpecificationValue(); + } + + public sealed record ErrorTypeSpecificationValue : TypeSpecificationValue; + + public sealed record ClassTypeSpecificationValue( + ClassNameValue ClassName) : TypeSpecificationValue; + + public sealed record AssemblyTypeSpecificationValue( + string AssemblyName) : TypeSpecificationValue; + + public sealed record ModuleTypeSpecificationValue( + string ModuleName) : TypeSpecificationValue; + + public sealed record SignatureTypeSpecificationValue( + TypeValue Type) : TypeSpecificationValue; + + public abstract record MethodReferenceValue + { + public static MethodReferenceValue Error { get; } = new ErrorMethodReferenceValue(); + } + + public sealed record ErrorMethodReferenceValue : MethodReferenceValue; + + public sealed record TokenMethodReferenceValue(int Token) : MethodReferenceValue; + + public sealed record TypedefMethodReferenceValue( + IToken Token, + string Alias) : MethodReferenceValue; + + public sealed record ParsedMethodReferenceValue( + IToken Token, + byte CallingConvention, + TypeValue ReturnType, + TypeSpecificationValue? Owner, + string Name, + ImmutableArray? GenericArguments, + int GenericArity, + ImmutableArray Arguments) : MethodReferenceValue; + + public abstract record FieldReferenceValue + { + public static FieldReferenceValue Error { get; } = new ErrorFieldReferenceValue(); + } + + public sealed record ErrorFieldReferenceValue : FieldReferenceValue; + + public sealed record TypedefFieldReferenceValue( + IToken Token, + string Alias) : FieldReferenceValue; + + public sealed record ParsedFieldReferenceValue( + TypeValue FieldType, + TypeSpecificationValue? Owner, + string Name) : FieldReferenceValue; + + public abstract record MemberReferenceValue + { + public static MemberReferenceValue Error { get; } = new ErrorMemberReferenceValue(); + } + + public sealed record ErrorMemberReferenceValue : MemberReferenceValue; + + public sealed record MethodMemberReferenceValue( + MethodReferenceValue Method) : MemberReferenceValue; + + public sealed record FieldMemberReferenceValue( + FieldReferenceValue Field) : MemberReferenceValue; + + public sealed record TokenMemberReferenceValue(int Token) : MemberReferenceValue; + + public abstract record OwnerTypeValue + { + public static OwnerTypeValue Error { get; } = new ErrorOwnerTypeValue(); + } + + public sealed record ErrorOwnerTypeValue : OwnerTypeValue; + + public sealed record TypeOwnerValue(TypeSpecificationValue Type) : OwnerTypeValue; + + public sealed record MemberOwnerValue(MemberReferenceValue Member) : OwnerTypeValue; +} diff --git a/src/tools/ilasm/src/ILAssembler/CompatibilitySuppressions.xml b/src/tools/ilasm/src/ILAssembler/CompatibilitySuppressions.xml new file mode 100644 index 00000000000000..5b82f9b865e369 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/CompatibilitySuppressions.xml @@ -0,0 +1,23 @@ + + + + + + CP0001 + T:ILAssembler.CILLexer + + + CP0001 + T:ILAssembler.CILParser + + + + CP0001 + T:ILAssembler.PreprocessedTokenSource + + + + CP0001 + T:ILAssembler.StringHelpers + + diff --git a/src/tools/ilasm/src/ILAssembler/ILAssembler.csproj b/src/tools/ilasm/src/ILAssembler/ILAssembler.csproj index 26de5f183c9417..24735966a30333 100644 --- a/src/tools/ilasm/src/ILAssembler/ILAssembler.csproj +++ b/src/tools/ilasm/src/ILAssembler/ILAssembler.csproj @@ -8,10 +8,15 @@ true true false + $(MSBuildThisFileDirectory)ref\ILAssembler.csproj + + + + diff --git a/src/tools/ilasm/src/ILAssembler/TypeName.cs b/src/tools/ilasm/src/ILAssembler/TypeName.cs deleted file mode 100644 index a4b1a11ddae119..00000000000000 --- a/src/tools/ilasm/src/ILAssembler/TypeName.cs +++ /dev/null @@ -1,11 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System; -using System.Collections.Generic; -using System.Text; - -namespace ILAssembler -{ - internal sealed record TypeName(TypeName? ContainingTypeName, string DottedName); -} diff --git a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 index 223dc9c67e4038..e8ac73ebbdf80c 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 +++ b/src/tools/ilasm/src/ILAssembler/gen/CIL.g4 @@ -5,6 +5,10 @@ The .NET Foundation licenses this file to you under the MIT license. grammar CIL; +@parser::header { +#nullable enable annotations +} + @parser::members { internal GrammarActions Actions { get; set; } = null!; } @@ -414,16 +418,18 @@ id: | INSTANCE | SQSTRING; dottedName returns [string Value] -@init {Actions.BeginDottedName(_localctx);} +locals [CILParser.DottedNameBuilder Builder] +@init {_localctx.Builder = new CILParser.DottedNameBuilder();} : - direct = DOTTEDNAME {Actions.AddDottedNameToken(_localctx, $direct);} - | ((part = dottedNamePart {Actions.AddDottedNamePart(_localctx, $part.Value);} '.')* - tail = dottedNamePart {Actions.AddDottedNamePart(_localctx, $tail.Value);}) - | quoted = SQSTRING {Actions.AddDottedNameToken(_localctx, $quoted);} + direct = DOTTEDNAME {Actions.AddDottedNameToken(_localctx.Builder, $direct);} + | ((part = dottedNamePart {Actions.AddDottedNamePart(_localctx.Builder, $part.Value);} '.')* + tail = dottedNamePart {Actions.AddDottedNamePart(_localctx.Builder, $tail.Value);}) + | quoted = SQSTRING {Actions.AddDottedNameToken(_localctx.Builder, $quoted);} ; -finally {_localctx.Value = Actions.EndDottedName(_localctx);} +finally {_localctx.Value = Actions.EndDottedName(_localctx.Builder);} dottedNamePart returns [string Value] +@init {_localctx.Value = string.Empty;} @after {_localctx.Value = Actions.ParseDottedNamePart(_localctx.Start);} : ID @@ -434,12 +440,13 @@ dottedNamePart returns [string Value] | 'volatile' ; compQstring returns [string Value] -@init {Actions.BeginComposedString(_localctx);} +locals [System.Text.StringBuilder Builder] +@init {_localctx.Builder = new System.Text.StringBuilder();} : - (head = QSTRING {Actions.AddComposedStringPart(_localctx, $head);} PLUS)* - tail = QSTRING {Actions.AddComposedStringPart(_localctx, $tail);} + (head = QSTRING {Actions.AddComposedStringPart(_localctx.Builder, $head);} PLUS)* + tail = QSTRING {Actions.AddComposedStringPart(_localctx.Builder, $tail);} ; -finally {_localctx.Value = Actions.EndComposedString(_localctx);} +finally {_localctx.Value = Actions.EndComposedString(_localctx.Builder);} WS: [ \t\r\n] -> skip; @@ -513,20 +520,30 @@ imagebase: stackreserve: '.stackreserve' value = int64 {Actions.ProcessTopLevelStackReserve($value.start);}; -assemblyBlock returns [object Value, bool HasSyntaxError] -@init {Actions.BeginSemanticRoot(_localctx);} +assemblyBlock returns [CILParser.AssemblyDefinitionValue? Value, bool HasSyntaxError] +locals [int InitialSyntaxErrorCount] +@init {_localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount;} : '.assembly' attributes = asmAttr name = dottedName '{' declarations = assemblyDecls '}' {_localctx.Value = Actions.CreateAssemblyDefinition( $attributes.Value, $name.Value, $declarations.Value);}; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} +finally { + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; + if (_localctx.HasSyntaxError) + { + _localctx.Value = null; + } +} mscorlib: '.mscorlib'; -languageDecl returns [object Value, bool HasSyntaxError] -@init {Actions.BeginSemanticRoot(_localctx);} +languageDecl returns [CILParser.LanguageDirectiveValue? Value, bool HasSyntaxError] +locals [int InitialSyntaxErrorCount] +@init {_localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount;} : '.language' language = languageString {_localctx.Value = Actions.CreateLanguageDirective($language.Value);} @@ -534,9 +551,10 @@ languageDecl returns [object Value, bool HasSyntaxError] {_localctx.Value = Actions.CreateLanguageDirective($language.Value, $vendor.Value);} | '.language' language = languageString ',' vendor = languageString ',' documentType = languageString {_localctx.Value = Actions.CreateLanguageDirective($language.Value, $vendor.Value, $documentType.Value);}; -finally {Actions.EndLanguageDirective(_localctx);} +finally {Actions.EndLanguageDirective(_localctx, _localctx.InitialSyntaxErrorCount);} languageString returns [string Value] +@init {_localctx.Value = string.Empty;} @after {_localctx.Value = Actions.ParseLanguageString(_localctx.Start);} : SQSTRING @@ -578,8 +596,12 @@ compControl: /* Aliasing of types, type specs, methods, fields and custom attributes */ -typedefDecl returns [object Value, bool HasSyntaxError] -@init {Actions.BeginSemanticRoot(_localctx);} +typedefDecl returns [CILParser.TypedefDeclarationValue Value, bool HasSyntaxError] +locals [int InitialSyntaxErrorCount] +@init { + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.TypedefDeclarationValue.Error; +} : '.typedef' signature = type 'as' alias = dottedName {_localctx.Value = Actions.CreateTypeSignatureTypedef($signature.Value, $alias.Value);} @@ -597,11 +619,19 @@ typedefDecl returns [object Value, bool HasSyntaxError] $ownedAttribute.Value, $ownedAttribute.start, $alias.Value);}; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} +finally { + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; +} /* Custom attribute declarations */ -customDescr returns [object Value, bool HasSyntaxError] -@init {Actions.BeginSemanticRoot(_localctx);} +customDescr returns [CILParser.CustomAttributeDescriptorValue Value, bool HasSyntaxError] +locals [int InitialSyntaxErrorCount] +@init { + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.CustomAttributeDescriptorValue.Error; +} : '.custom' constructor = customType {_localctx.Value = Actions.CreateDefaultCustomAttribute($constructor.Value);} @@ -611,10 +641,18 @@ customDescr returns [object Value, bool HasSyntaxError] {_localctx.Value = Actions.CreateStructuredCustomAttribute($constructor.Value, $structuredValue.Value);} | '.custom' constructor = customType '=' '(' rawValue = bytes ')' {_localctx.Value = Actions.CreateRawCustomAttribute($constructor.Value, $rawValue.Value);}; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} +finally { + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; +} -customDescrWithOwner returns [object Value, bool HasSyntaxError] -@init {Actions.BeginSemanticRoot(_localctx);} +customDescrWithOwner returns [CILParser.CustomAttributeDescriptorValue Value, bool HasSyntaxError] +locals [int InitialSyntaxErrorCount] +@init { + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.CustomAttributeDescriptorValue.Error; +} : '.custom' '(' owner = ownerType ')' constructor = customType {_localctx.Value = Actions.CreateDefaultOwnedCustomAttribute($owner.Value, $constructor.Value);} @@ -624,56 +662,77 @@ customDescrWithOwner returns [object Value, bool HasSyntaxError] {_localctx.Value = Actions.CreateStructuredOwnedCustomAttribute($owner.Value, $constructor.Value, $structuredValue.Value);} | '.custom' '(' owner = ownerType ')' constructor = customType '=' '(' rawValue = bytes ')' {_localctx.Value = Actions.CreateRawOwnedCustomAttribute($owner.Value, $constructor.Value, $rawValue.Value);}; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} +finally { + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; +} -customType returns [object Value]: +customType returns [CILParser.MethodReferenceValue Value] +@init {_localctx.Value = CILParser.MethodReferenceValue.Error;} +: constructor = methodRef {_localctx.Value = Actions.CreateCustomAttributeType($constructor.Value);}; ownerType -returns [object Value, bool HasSyntaxError] -@init {Actions.BeginSemanticRoot(_localctx);} +returns [CILParser.OwnerTypeValue Value, bool HasSyntaxError] +locals [int InitialSyntaxErrorCount] +@init { + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.OwnerTypeValue.Error; +} : typeValue = typeSpec {_localctx.Value = Actions.CreateTypeOwner($typeValue.Value);} | member = memberRef {_localctx.Value = Actions.CreateMemberOwner($member.Value);} ; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} +finally { + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; +} /* Verbal description of custom attribute initialization blob */ -customBlobDescr returns [object Value]: +customBlobDescr returns [CILParser.CustomAttributeBlobValue Value] +@init {_localctx.Value = CILParser.CustomAttributeBlobValue.Error;} +: arguments = customBlobArgs namedArguments = customBlobNVPairs {_localctx.Value = Actions.CreateCustomAttributeBlob($arguments.Value, $namedArguments.Value);}; -customBlobArgs returns [object Value] -@init {Actions.BeginCustomBlobArguments(_localctx);} +customBlobArgs returns [System.Collections.Immutable.ImmutableArray Value] +locals [System.Collections.Immutable.ImmutableArray.Builder Builder] +@init {_localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder();} : - (argument = serInit {Actions.AddCustomBlobArgument(_localctx, $argument.Value);} | compControl)* + (argument = serInit {_localctx.Builder.Add($argument.Value);} | compControl)* ; -finally {_localctx.Value = Actions.EndCustomBlobArguments(_localctx);} +finally {_localctx.Value = _localctx.Builder.ToImmutable();} -customBlobNVPairs returns [object Value] -@init {Actions.BeginCustomBlobNamedArguments(_localctx);} +customBlobNVPairs returns [System.Collections.Immutable.ImmutableArray Value] +locals [System.Collections.Immutable.ImmutableArray.Builder Builder] +@init {_localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder();} : ( kind = fieldOrProp argumentType = serializType name = dottedName '=' value = serInit - {Actions.AddCustomBlobNamedArgument( - _localctx, + {_localctx.Builder.Add(Actions.CreateCustomBlobNamedArgument( $kind.Value, $argumentType.Value, $name.Value, - $value.Value);} + $value.Value));} | compControl )* ; -finally {_localctx.Value = Actions.EndCustomBlobNamedArguments(_localctx);} +finally {_localctx.Value = _localctx.Builder.ToImmutable();} fieldOrProp returns [byte Value]: kind = ('field' | 'property') {_localctx.Value = Actions.GetCustomAttributeNamedArgumentKind($kind);}; -serializType returns [object Value]: +serializType returns [CILParser.SerializationTypeValue Value] +@init {_localctx.Value = CILParser.SerializationTypeValue.Error;} +: element = serializTypeElement array = ARRAY_TYPE_NO_BOUNDS? {_localctx.Value = Actions.CreateSerializationType($element.Value, $array);}; -serializTypeElement returns [object Value]: +serializTypeElement returns [CILParser.SerializationTypeValue Value] +@init {_localctx.Value = CILParser.SerializationTypeValue.Error;} +: primitive = simpleType {_localctx.Value = Actions.CreatePrimitiveSerializationType($primitive.Value);} | alias = dottedName {_localctx.Value = Actions.CreateSerializationTypeTypedef(_localctx, $alias.Value);} /* typedef */ | simpleTypeToken = TYPE {_localctx.Value = Actions.CreateSimpleSerializationType($simpleTypeToken);} @@ -682,7 +741,9 @@ serializTypeElement returns [object Value]: | ENUM classNameValue = className {_localctx.Value = Actions.CreateEnumSerializationType($classNameValue.Value);}; /* Module declaration */ -moduleHead returns [string Value, bool HasName, bool IsExternal]: +moduleHead returns [string? Value, bool HasName, bool IsExternal] +@init {_localctx.Value = null;} +: MODULE 'extern' name = dottedName {Actions.SetModuleHeader(_localctx, $name.Value, true);} | MODULE name = dottedName @@ -691,8 +752,9 @@ moduleHead returns [string Value, bool HasName, bool IsExternal]: {Actions.SetEmptyModuleHeader(_localctx);}; /* VTable Fixup table declaration */ -vtfixupDecl returns [object Value, bool HasSyntaxError] -@init {Actions.BeginSemanticRoot(_localctx);} +vtfixupDecl returns [CILParser.VTableFixupValue? Value, bool HasSyntaxError] +locals [int InitialSyntaxErrorCount] +@init {_localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount;} : '.vtfixup' '[' count = int32 ']' attributes = vtfixupAttr 'at' label = id {_localctx.Value = Actions.CreateVTableFixup( @@ -700,7 +762,15 @@ vtfixupDecl returns [object Value, bool HasSyntaxError] $attributes.Value, $label.start);} ; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} +finally { + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; + if (_localctx.HasSyntaxError) + { + _localctx.Value = null; + } +} vtfixupAttr returns [ushort Value] @init {_localctx.Value = 0;} @@ -719,42 +789,63 @@ vtfixupAttrElement returns [ushort Value] | 'callmostderived' | 'retainappdomain'; -vtableDecl returns [object Value, bool HasSyntaxError] -@init {Actions.BeginSemanticRoot(_localctx);} +vtableDecl returns [CILParser.RawVTableValue? Value, bool HasSyntaxError] +locals [int InitialSyntaxErrorCount] +@init {_localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount;} : '.vtable' '=' '(' value = bytes ')' {_localctx.Value = Actions.CreateRawVTable($value.Value);} /* deprecated */ ; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} +finally { + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; + if (_localctx.HasSyntaxError) + { + _localctx.Value = null; + } +} /* Namespace and class declaration */ nameSpaceHead returns [string Value] -@init {Actions.BeginNamespaceHeader(_localctx);} -@after {Actions.BeginNamespace(_localctx, _localctx.Value);} +locals [int InitialSyntaxErrorCount] +@init { + Actions.PrepareNamespaceHeader(); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = string.Empty; +} +@after {Actions.BeginNamespace(_localctx, _localctx.Value, _localctx.InitialSyntaxErrorCount);} : '.namespace' name = dottedName {_localctx.Value = $name.Value;} ; -finally {Actions.EndNamespaceHeader(_localctx);} -classHead returns [object Value] -@init {Actions.BeginClassHeader(_localctx);} +classHead returns [CILParser.ClassHeaderValue Value] +locals [int InitialSyntaxErrorCount, CILParser.ClassHeaderBuilder Builder] +@init { + _localctx.Builder = Actions.PrepareClassHeader(); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.ClassHeaderValue.Error; +} @after {Actions.BeginType(_localctx, _localctx.Value);} : '.class' - (attribute = classAttr {Actions.AddClassHeaderAttribute(_localctx, $attribute.Value);})* + (attribute = classAttr {Actions.AddClassHeaderAttribute(_localctx.Builder, $attribute.Value);})* name = dottedName genericParameters = typarsClause baseType = extendsClause interfaces = implClause {_localctx.Value = Actions.CreateClassHeader( _localctx, + _localctx.Builder, + _localctx.InitialSyntaxErrorCount, $name.stop, $name.Value, $genericParameters.Value, $baseType.Value, $interfaces.Value);} ; -finally {Actions.EndClassHeader(_localctx);} -classAttr returns [object Value]: +classAttr returns [CILParser.ClassAttributeValue Value] +@init {_localctx.Value = CILParser.ClassAttributeValue.Empty;} +: attribute = 'public' {_localctx.Value = Actions.CreateClassAttribute($attribute);} | attribute = 'private' {_localctx.Value = Actions.CreateClassAttribute($attribute);} | attribute = VALUE {_localctx.Value = Actions.CreateClassAttribute($attribute);} @@ -783,14 +874,14 @@ classAttr returns [object Value]: | attribute = 'rtspecialname' {_localctx.Value = Actions.CreateClassAttribute($attribute);} | 'flags' '(' flags = int32 ')' {_localctx.Value = Actions.CreateRawClassAttribute($flags.start);}; -extendsClause returns [object Value] +extendsClause returns [CILParser.TypeSpecificationValue? Value] @init {_localctx.Value = Actions.CreateEmptyClassBase();} : /* EMPTY */ | 'extends' baseType = typeSpec {_localctx.Value = Actions.CreateClassBase($baseType.Value);} ; -implClause returns [object Value] +implClause returns [System.Collections.Immutable.ImmutableArray Value] @init {_localctx.Value = Actions.CreateEmptyInterfaceList();} : /* EMPTY */ @@ -802,13 +893,14 @@ classDecls classDecl* ; -implList returns [object Value] -@init {Actions.BeginInterfaceList(_localctx);} +implList returns [System.Collections.Immutable.ImmutableArray Value] +locals [System.Collections.Immutable.ImmutableArray.Builder Builder] +@init {_localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder();} : - (interfaceType = typeSpec {Actions.AddInterfaceType(_localctx, $interfaceType.Value);} ',')* - lastInterfaceType = typeSpec {Actions.AddInterfaceType(_localctx, $lastInterfaceType.Value);} + (interfaceType = typeSpec {_localctx.Builder.Add($interfaceType.Value);} ',')* + lastInterfaceType = typeSpec {_localctx.Builder.Add($lastInterfaceType.Value);} ; -finally {_localctx.Value = Actions.EndInterfaceList(_localctx);} +finally {_localctx.Value = _localctx.Builder.ToImmutable();} /* External source declarations */ esHead returns [bool AutoIncrement] @@ -817,8 +909,9 @@ esHead returns [bool AutoIncrement] '.line' | '#line'; -extSourceSpec returns [object Value, bool HasSyntaxError] -@init {Actions.BeginSemanticRoot(_localctx);} +extSourceSpec returns [CILParser.SourceDirectiveValue? Value, bool HasSyntaxError] +locals [int InitialSyntaxErrorCount] +@init {_localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount;} : head = esHead line = int32 path = (SQSTRING | QSTRING)? {_localctx.Value = Actions.CreateSourceLine($head.AutoIncrement, $line.start, $path);} @@ -847,20 +940,24 @@ extSourceSpec returns [object Value, bool HasSyntaxError] $startColumn.start, $endColumn.start, $path);}; -finally {Actions.EndSourceDirective(_localctx);} +finally {Actions.EndSourceDirective(_localctx, _localctx.InitialSyntaxErrorCount);} /* Manifest declarations */ -fileDecl returns [object Value, bool HasSyntaxError] -@init {Actions.BeginFileDeclaration(_localctx);} +fileDecl returns [CILParser.FileDeclarationValue? Value, bool HasSyntaxError] +locals [int InitialSyntaxErrorCount, CILParser.FileDeclarationBuilder Builder] +@init { + _localctx.Builder = new CILParser.FileDeclarationBuilder(); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; +} : '.file' - (attribute = fileAttr {Actions.AddFileAttribute(_localctx, $attribute.Value);})* - name = dottedName {Actions.SetFileName(_localctx, $name.Value);} - entry = fileEntry {Actions.AddFileEntry(_localctx, $entry.Value);} - (HASH '=' '(' hash = bytes ')' {Actions.SetFileHash(_localctx, $hash.Value);} - trailingEntry = fileEntry {Actions.AddFileEntry(_localctx, $trailingEntry.Value);})? + (attribute = fileAttr {Actions.AddFileAttribute(_localctx.Builder, $attribute.Value);})* + name = dottedName {Actions.SetFileName(_localctx.Builder, $name.Value);} + entry = fileEntry {Actions.AddFileEntry(_localctx.Builder, $entry.Value);} + (HASH '=' '(' hash = bytes ')' {Actions.SetFileHash(_localctx.Builder, $hash.Value);} + trailingEntry = fileEntry {Actions.AddFileEntry(_localctx.Builder, $trailingEntry.Value);})? ; -finally {Actions.EndFileDeclaration(_localctx);} +finally {Actions.EndFileDeclaration(_localctx, _localctx.Builder, _localctx.InitialSyntaxErrorCount);} fileAttr returns [bool Value] @after {_localctx.Value = Actions.ParseFileAttribute(_localctx.Start);} @@ -907,7 +1004,8 @@ instr: ; simpleInstr -@after {Actions.CompleteSimpleInstruction(_localctx);} +locals [CILParser.SwitchInstructionBuilder SwitchBuilder] +@after {Actions.CompleteSwitchInstruction(_localctx.SwitchBuilder);} : op = INSTR_NONE {Actions.EmitNoOperandInstruction($op);} | op = INSTR_VAR index = int32 {Actions.EmitVariableIndexInstruction($op, $index.start);} @@ -924,57 +1022,72 @@ simpleInstr | op = INSTR_STRING ANSI '(' ansiString = compQstring ')' {Actions.EmitAnsiStringInstruction($op, $ansiString.Value);} | op = INSTR_STRING 'bytearray' '(' rawString = bytes ')' {Actions.EmitRawStringInstruction($op, $rawString.Value);} | op = INSTR_TOK rawToken = int32 {Actions.EmitRawTokenInstruction($op, $rawToken.start);} - | op = INSTR_SWITCH {Actions.BeginSwitchInstruction(_localctx, $op);} ('(' labels ')' | '()') + | op = INSTR_SWITCH {_localctx.SwitchBuilder = Actions.CreateSwitchInstruction($op);} + ('(' labels[_localctx.SwitchBuilder] ')' | '()') ; -finally {Actions.EndSwitchInstruction(_localctx);} calliSignature -returns [object Value, bool HasSyntaxError] -@init {Actions.BeginSemanticRoot(_localctx);} +returns [CILParser.CalliSignatureValue Value, bool HasSyntaxError] +locals [int InitialSyntaxErrorCount] +@init { + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.CalliSignatureValue.Error; +} : convention = callConv returnType = type arguments = sigArgs {_localctx.Value = Actions.CreateCalliSignature($convention.Value, $returnType.Value, $arguments.Value);} ; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} +finally { + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; +} -labels: +labels [CILParser.SwitchInstructionBuilder Builder]: /* empty */ - | ((headLabel = id {Actions.AddSwitchLabel($headLabel.start);} | headOffset = int32 {Actions.AddSwitchOffset($headOffset.start);}) ',')* - (tailLabel = id {Actions.AddSwitchLabel($tailLabel.start);} | tailOffset = int32 {Actions.AddSwitchOffset($tailOffset.start);}); + | ((headLabel = id {Actions.AddSwitchLabel($Builder, $headLabel.start);} | headOffset = int32 {Actions.AddSwitchOffset($Builder, $headOffset.start);}) ',')* + (tailLabel = id {Actions.AddSwitchLabel($Builder, $tailLabel.start);} | tailOffset = int32 {Actions.AddSwitchOffset($Builder, $tailOffset.start);}); -typeArgs returns [object Value] -@init {Actions.BeginTypeArguments(_localctx);} +typeArgs returns [System.Collections.Immutable.ImmutableArray Value] +locals [System.Collections.Immutable.ImmutableArray.Builder Builder] +@init {_localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder();} : - '<' (argument = type {Actions.AddTypeArgument(_localctx, $argument.Value);} ',')* - lastArgument = type {Actions.AddTypeArgument(_localctx, $lastArgument.Value);} '>' + '<' (argument = type {_localctx.Builder.Add($argument.Value);} ',')* + lastArgument = type {_localctx.Builder.Add($lastArgument.Value);} '>' ; -finally {_localctx.Value = Actions.EndTypeArguments(_localctx);} +finally {_localctx.Value = _localctx.Builder.ToImmutable();} -bounds returns [object Value] -@init {Actions.BeginBounds(_localctx);} +bounds returns [System.Collections.Immutable.ImmutableArray Value] +locals [System.Collections.Immutable.ImmutableArray.Builder Builder] +@init {_localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder();} : - '[' (item = bound {Actions.AddBound(_localctx, $item.ctx);} ',')* - lastItem = bound {Actions.AddBound(_localctx, $lastItem.ctx);} ']' + '[' (item = bound {_localctx.Builder.Add(Actions.CreateArrayBound($item.ctx));} ',')* + lastItem = bound {_localctx.Builder.Add(Actions.CreateArrayBound($lastItem.ctx));} ']' ; -finally {_localctx.Value = Actions.EndBounds(_localctx);} +finally {_localctx.Value = _localctx.Builder.ToImmutable();} -sigArgs returns [object Value] -@init {Actions.BeginSignatureArguments(_localctx);} +sigArgs returns [System.Collections.Immutable.ImmutableArray Value] +locals [System.Collections.Immutable.ImmutableArray.Builder Builder] +@init {_localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder();} : - '(' (argument = sigArg {Actions.AddSignatureArgument(_localctx, $argument.Value);} ',')* - lastArgument = sigArg {Actions.AddSignatureArgument(_localctx, $lastArgument.Value);} ')' + '(' (argument = sigArg {_localctx.Builder.Add($argument.Value);} ',')* + lastArgument = sigArg {_localctx.Builder.Add($lastArgument.Value);} ')' | '()' ; -finally {_localctx.Value = Actions.EndSignatureArguments(_localctx);} +finally {_localctx.Value = _localctx.Builder.ToImmutable();} -sigArg returns [object Value]: +sigArg returns [CILParser.SignatureArgumentValue Value] +@init {_localctx.Value = CILParser.SignatureArgumentValue.Error;} +: ELLIPSIS {_localctx.Value = Actions.CreateSentinelSignatureArgument();} | attributes = paramAttr argumentType = type marshalling = marshalClause name = id? {_localctx.Value = Actions.CreateSignatureArgument($attributes.Value, $argumentType.Value, $marshalling.Value, $name.ctx);}; /* Class referencing */ -className returns [object Value]: +className returns [CILParser.ClassNameValue Value] +@init {_localctx.Value = CILParser.ClassNameValue.Error;} +: '[' assemblyName = dottedName ']' typeName = slashedName {_localctx.Value = Actions.CreateAssemblyQualifiedClassName($assemblyName.Value, $typeName.Value);} | '[' scopeToken = mdtoken ']' typeName = slashedName @@ -989,23 +1102,24 @@ className returns [object Value]: | BASE {_localctx.Value = Actions.CreateBaseClassName(_localctx.Start);} | NESTER {_localctx.Value = Actions.CreateNesterClassName(_localctx.Start);}; -slashedName returns [object Value] -@init {Actions.BeginSlashedName(_localctx);} +slashedName returns [CILParser.TypeName Value] +locals [CILParser.TypeName CurrentName] : - (part = dottedName {Actions.AddSlashedNamePart(_localctx, $part.Value);} '/')* - lastPart = dottedName {Actions.AddSlashedNamePart(_localctx, $lastPart.Value);} + (part = dottedName {_localctx.CurrentName = Actions.AddSlashedNamePart(_localctx.CurrentName, $part.Value);} '/')* + lastPart = dottedName {_localctx.CurrentName = Actions.AddSlashedNamePart(_localctx.CurrentName, $lastPart.Value);} ; -finally {_localctx.Value = Actions.EndSlashedName(_localctx);} +finally {_localctx.Value = _localctx.CurrentName ?? new CILParser.TypeName(null, string.Empty);} -assemblyDecls returns [object Value] -@init {Actions.BeginAssemblyDeclarations(_localctx);} +assemblyDecls returns [System.Collections.Immutable.ImmutableArray Value] +locals [System.Collections.Immutable.ImmutableArray.Builder Builder] +@init {_localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder();} : (declaration = assemblyDecl - {Actions.AddAssemblyDeclaration(_localctx, $declaration.Value);})* + {if ($declaration.Value is not null) _localctx.Builder.Add($declaration.Value);})* ; -finally {_localctx.Value = Actions.EndAssemblyDeclarations(_localctx);} +finally {_localctx.Value = _localctx.Builder.ToImmutable();} -assemblyDecl returns [object Value]: +assemblyDecl returns [CILParser.AssemblyDeclarationValue? Value]: HASH 'algorithm' algorithm = int32 {_localctx.Value = Actions.CreateAssemblyHashAlgorithmDeclaration($algorithm.start);} | security = secDecl @@ -1015,27 +1129,38 @@ assemblyDecl returns [object Value]: | shared = asmOrRefDecl {_localctx.Value = $shared.Value;}; typeSpec -returns [object Value, bool HasSyntaxError] -@init {Actions.BeginSemanticRoot(_localctx);} +returns [CILParser.TypeSpecificationValue Value, bool HasSyntaxError] +locals [int InitialSyntaxErrorCount] +@init { + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.TypeSpecificationValue.Error; +} : classType = className {_localctx.Value = Actions.CreateClassTypeSpecification($classType.Value);} | '[' assemblyName = dottedName ']' {_localctx.Value = Actions.CreateAssemblyTypeSpecification($assemblyName.Value);} | '[' MODULE moduleName = dottedName ']' {_localctx.Value = Actions.CreateModuleTypeSpecification($moduleName.Value);} | signatureType = type {_localctx.Value = Actions.CreateSignatureTypeSpecification($signatureType.Value);} ; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} +finally { + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; +} /* Native types for marshaling signatures */ -nativeType returns [object Value] -@init {Actions.BeginNativeType(_localctx);} +nativeType returns [CILParser.NativeTypeValue Value] +locals [CILParser.NativeTypeBuilder Builder] +@init {_localctx.Builder = new CILParser.NativeTypeBuilder();} : /* EMPTY */ - | element = nativeTypeElement {Actions.SetNativeTypeElement(_localctx, $element.Value);} - (info = nativeTypeArrayPointerInfo {Actions.AddNativeTypeArrayPointerInfo(_localctx, $info.Value);})* + | element = nativeTypeElement {Actions.SetNativeTypeElement(_localctx.Builder, $element.Value);} + (info = nativeTypeArrayPointerInfo {Actions.AddNativeTypeArrayPointerInfo(_localctx.Builder, $info.Value);})* ; -finally {_localctx.Value = Actions.EndNativeType(_localctx);} +finally {_localctx.Value = Actions.CreateNativeType(_localctx.Start, _localctx.Builder);} -nativeTypeArrayPointerInfo returns [object Value]: +nativeTypeArrayPointerInfo returns [CILParser.NativeTypeArrayPointerInfoValue Value] +@init {_localctx.Value = Actions.CreatePointerNativeType();} +: PTR {_localctx.Value = Actions.CreatePointerNativeType();} # PointerNativeType | ARRAY_TYPE_NO_BOUNDS {_localctx.Value = Actions.CreatePointerArrayTypeNoSizeData();} # PointerArrayTypeNoSizeData | '[' size = int32 ']' {_localctx.Value = Actions.CreatePointerArrayTypeSize($size.start);} # PointerArrayTypeSize @@ -1045,7 +1170,9 @@ nativeTypeArrayPointerInfo returns [object Value]: {_localctx.Value = Actions.CreatePointerArrayTypeParamIndex($parameterIndex.start);} # PointerArrayTypeParamIndex ; -nativeTypeElement returns [object Value]: +nativeTypeElement returns [CILParser.NativeTypeElementValue Value] +@init {_localctx.Value = CILParser.EmptyNativeTypeElementValue.Instance;} +: /* EMPTY */ {_localctx.Value = Actions.CreateEmptyNativeType();} | marshalType = CUSTOM '(' guid = compQstring ',' nativeTypeName = compQstring ',' marshallerType = compQstring ',' cookie = compQstring ')' @@ -1104,20 +1231,25 @@ nativeTypeElement returns [object Value]: | 'as' marshalType = ANY {_localctx.Value = Actions.CreateSimpleNativeType($marshalType);} | alias = dottedName {_localctx.Value = Actions.CreateNativeTypeTypedef(_localctx, $alias.Value);} /* typedef */; -iidParamIndex returns [object Value]: +iidParamIndex returns [CILParser.IidParamIndexValue Value] +@init {_localctx.Value = CILParser.IidParamIndexValue.Empty;} +: /* EMPTY */ | '(' 'iidparam' '=' index = int32 ')' {_localctx.Value = Actions.GetIidParamIndex($index.start);}; -variantType returns [object Value] -@init {Actions.BeginVariantType(_localctx);} +variantType returns [CILParser.VariantTypeValue Value] +locals [CILParser.VariantTypeBuilder Builder] +@init {_localctx.Builder = new CILParser.VariantTypeBuilder();} : /*EMPTY */ - | element = variantTypeElement {Actions.SetVariantTypeElement(_localctx, $element.Value);} - (modifier = (ARRAY_TYPE_NO_BOUNDS | VECTOR | REF) {Actions.AddVariantTypeModifier(_localctx, $modifier);})* + | element = variantTypeElement {Actions.SetVariantTypeElement(_localctx.Builder, $element.Value);} + (modifier = (ARRAY_TYPE_NO_BOUNDS | VECTOR | REF) {Actions.AddVariantTypeModifier(_localctx.Builder, $modifier);})* ; -finally {_localctx.Value = Actions.EndVariantType(_localctx);} +finally {_localctx.Value = Actions.CreateVariantType(_localctx.Builder);} -variantTypeElement returns [object Value]: +variantTypeElement returns [CILParser.VariantTypeElementValue Value] +@init {_localctx.Value = CILParser.VariantTypeElementValue.Error;} +: value = NULL {_localctx.Value = Actions.GetVariantTypeElement($value);} | value = VARIANT {_localctx.Value = Actions.GetVariantTypeElement($value);} | value = CURRENCY {_localctx.Value = Actions.GetVariantTypeElement($value);} @@ -1160,15 +1292,24 @@ variantTypeElement returns [object Value]: | value = CLSID {_localctx.Value = Actions.GetVariantTypeElement($value);}; /* Managed types for signatures */ -type returns [object Value] -@init {Actions.BeginTypeSignature(_localctx);} +type returns [CILParser.TypeValue Value] +locals [ + CILParser.ElementTypeValue ElementType, + System.Collections.Immutable.ImmutableArray.Builder Modifiers +] +@init { + _localctx.ElementType = CILParser.ElementTypeValue.Error; + _localctx.Modifiers = System.Collections.Immutable.ImmutableArray.CreateBuilder(); +} : - element = elementType {Actions.SetTypeSignatureElement(_localctx, $element.Value);} - (modifier = typeModifiers {Actions.AddTypeSignatureModifier(_localctx, $modifier.Value);})* + element = elementType {_localctx.ElementType = $element.Value;} + (modifier = typeModifiers {_localctx.Modifiers.Add($modifier.Value);})* ; -finally {_localctx.Value = Actions.EndTypeSignature(_localctx);} +finally {_localctx.Value = new CILParser.TypeValue(_localctx.ElementType, _localctx.Modifiers.ToImmutable());} -typeModifiers returns [object Value]: +typeModifiers returns [CILParser.TypeModifierValue Value] +@init {_localctx.Value = CILParser.TypeModifierValue.Error;} +: ARRAY_TYPE_NO_BOUNDS {_localctx.Value = Actions.CreateSzArrayTypeModifier();} # SZArrayModifier | '[' ']' {_localctx.Value = Actions.CreateSzArrayTypeModifier();} # SZArrayModifier | arrayBounds = bounds {_localctx.Value = Actions.CreateArrayTypeModifier($arrayBounds.Value);} # ArrayModifier @@ -1179,7 +1320,9 @@ typeModifiers returns [object Value]: | 'modopt' '(' modifierType = typeSpec ')' {_localctx.Value = Actions.CreateCustomTypeModifier($modifierType.Value, false);} # OptionalModifier | arguments = typeArgs {_localctx.Value = Actions.CreateGenericArgumentsModifier($arguments.Value);} # GenericArgumentsModifier; -elementType returns [object Value]: +elementType returns [CILParser.ElementTypeValue Value] +@init {_localctx.Value = CILParser.ElementTypeValue.Error;} +: 'class' classType = className {_localctx.Value = Actions.CreateClassElementType($classType.Value, false);} | OBJECT {_localctx.Value = Actions.CreateObjectElementType();} | VALUE 'class' valueClassType = className {_localctx.Value = Actions.CreateClassElementType($valueClassType.Value, true);} @@ -1235,8 +1378,9 @@ nativeUint returns [byte Value]: 'native' ('unsigned' INT | UINT) {_localctx.Value = Actions.GetNativeUIntType();}; /* Security declarations */ -secDecl returns [object Value, bool HasSyntaxError] -@init {Actions.BeginSemanticRoot(_localctx);} +secDecl returns [CILParser.SecurityDeclarationValue? Value, bool HasSyntaxError] +locals [int InitialSyntaxErrorCount] +@init {_localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount;} : PERMISSION action = secAction permissionType = typeSpec '(' pairs = nameValPairs ')' {_localctx.Value = Actions.CreateNamedPermissionDeclaration( @@ -1258,32 +1402,38 @@ secDecl returns [object Value, bool HasSyntaxError] {_localctx.Value = Actions.CreateStringPermissionSetDeclaration($action.Value, $textValue.Value);} | PERMISSIONSET action = secAction '=' '{' attributes = secAttrSetBlob '}' {_localctx.Value = Actions.CreateAttributePermissionSetDeclaration($action.Value, $attributes.Value);}; -finally {Actions.EndSecurityDeclaration(_localctx);} +finally {Actions.EndSecurityDeclaration(_localctx, _localctx.InitialSyntaxErrorCount);} -secAttrSetBlob returns [object Value] -@init {Actions.BeginSecurityAttributeSet(_localctx);} +secAttrSetBlob returns [System.Collections.Immutable.ImmutableArray Value] +locals [System.Collections.Immutable.ImmutableArray.Builder Builder] +@init {_localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder();} : /* EMPTY */ - | (attribute = secAttrBlob {Actions.AddSecurityAttribute(_localctx, $attribute.Value);} ',')* - tail = secAttrBlob {Actions.AddSecurityAttribute(_localctx, $tail.Value);} + | (attribute = secAttrBlob {_localctx.Builder.Add($attribute.Value);} ',')* + tail = secAttrBlob {_localctx.Builder.Add($tail.Value);} ; -finally {_localctx.Value = Actions.EndSecurityAttributeSet(_localctx);} +finally {_localctx.Value = _localctx.Builder.ToImmutable();} -secAttrBlob returns [object Value]: +secAttrBlob returns [CILParser.SecurityAttributeValue Value] +@init {_localctx.Value = CILParser.SecurityAttributeValue.Error;} +: 'class' name = SQSTRING '=' '{' arguments = customBlobNVPairs '}' {_localctx.Value = Actions.CreateNamedSecurityAttribute($name, $arguments.Value);} | securityType = typeSpec '=' '{' arguments = customBlobNVPairs '}' {_localctx.Value = Actions.CreateTypedSecurityAttribute($securityType.Value, $arguments.Value);}; -nameValPairs returns [object Value] -@init {Actions.BeginSecurityNameValuePairs(_localctx);} +nameValPairs returns [System.Collections.Immutable.ImmutableArray Value] +locals [System.Collections.Immutable.ImmutableArray.Builder Builder] +@init {_localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder();} : - (pair = nameValPair {Actions.AddSecurityNameValuePair(_localctx, $pair.Value);} ',')* - tail = nameValPair {Actions.AddSecurityNameValuePair(_localctx, $tail.Value);} + (pair = nameValPair {_localctx.Builder.Add($pair.Value);} ',')* + tail = nameValPair {_localctx.Builder.Add($tail.Value);} ; -finally {_localctx.Value = Actions.EndSecurityNameValuePairs(_localctx);} +finally {_localctx.Value = _localctx.Builder.ToImmutable();} -nameValPair returns [object Value]: +nameValPair returns [CILParser.SecurityNameValuePairValue Value] +@init {_localctx.Value = CILParser.SecurityNameValuePairValue.Error;} +: name = compQstring '=' value = caValue {_localctx.Value = Actions.CreateSecurityNameValuePair($name.Value, $value.Value);}; @@ -1293,7 +1443,9 @@ truefalse returns [bool Value] 'true' | 'false'; -caValue returns [object Value]: +caValue returns [CILParser.SecurityCaValue Value] +@init {_localctx.Value = CILParser.SecurityCaValue.Error;} +: booleanValue = truefalse {_localctx.Value = Actions.CreateSecurityBooleanValue($booleanValue.Value);} | integerValue = int32 {_localctx.Value = Actions.CreateSecurityInt32Value($integerValue.start);} | INT32_ '(' integerValue = int32 ')' {_localctx.Value = Actions.CreateSecurityInt32Value($integerValue.start);} @@ -1328,21 +1480,29 @@ secAction returns [System.Reflection.DeclarativeSecurityAction Value] /* Method referencing */ methodRef -returns [object Value, bool HasSyntaxError] -@init {Actions.BeginSemanticRoot(_localctx);} +returns [CILParser.MethodReferenceValue Value, bool HasSyntaxError] +locals [int InitialSyntaxErrorCount] +@init { + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.MethodReferenceValue.Error; +} : convention = callConv returnType = type owner = typeSpec '::' name = methodName genericArguments = typeArgs? arguments = sigArgs - {_localctx.Value = Actions.CreateMethodReference(_localctx.Start, $convention.Value, $returnType.Value, $owner.Value, $name.Value, $genericArguments.ctx, null, $arguments.Value);} + {_localctx.Value = Actions.CreateMethodReference(_localctx.Start, $convention.Value, $returnType.Value, $owner.Value, $name.Value, $genericArguments.ctx is null ? null : $genericArguments.Value, null, $arguments.Value);} | convention = callConv returnType = type owner = typeSpec '::' name = methodName genericArity = genArityNotEmpty arguments = sigArgs {_localctx.Value = Actions.CreateMethodReference(_localctx.Start, $convention.Value, $returnType.Value, $owner.Value, $name.Value, null, $genericArity.Value, $arguments.Value);} | convention = callConv returnType = type name = methodName genericArguments = typeArgs? arguments = sigArgs - {_localctx.Value = Actions.CreateMethodReference(_localctx.Start, $convention.Value, $returnType.Value, null, $name.Value, $genericArguments.ctx, null, $arguments.Value);} + {_localctx.Value = Actions.CreateMethodReference(_localctx.Start, $convention.Value, $returnType.Value, null, $name.Value, $genericArguments.ctx is null ? null : $genericArguments.Value, null, $arguments.Value);} | convention = callConv returnType = type name = methodName genericArity = genArityNotEmpty arguments = sigArgs {_localctx.Value = Actions.CreateMethodReference(_localctx.Start, $convention.Value, $returnType.Value, null, $name.Value, null, $genericArity.Value, $arguments.Value);} | token = mdtoken {_localctx.Value = Actions.CreateTokenMethodReference($token.Value);} | alias = dottedName {_localctx.Value = Actions.CreateTypedefMethodReference(_localctx.Start, $alias.Value);} /* typeDef */ ; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} +finally { + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; +} callConv returns [byte Value]: INSTANCE inner = callConv {_localctx.Value = Actions.AddInstanceCallingConvention($inner.Value);} @@ -1365,20 +1525,31 @@ callKind returns [byte Value] mdtoken returns [int Value, bool HasSyntaxError] -@init {Actions.BeginSemanticRoot(_localctx);} +locals [int InitialSyntaxErrorCount] +@init {_localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount;} : 'mdtoken' '(' token = int32 ')' {_localctx.Value = Actions.ParseInt32($token.start);} ; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} +finally { + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; +} -memberRef returns [object Value]: +memberRef returns [CILParser.MemberReferenceValue Value] +@init {_localctx.Value = CILParser.MemberReferenceValue.Error;} +: 'method' method = methodRef {_localctx.Value = Actions.CreateMethodMemberReference($method.Value);} | 'field' field = fieldRef {_localctx.Value = Actions.CreateFieldMemberReference($field.Value);} | token = mdtoken {_localctx.Value = Actions.CreateTokenMemberReference($token.Value);}; fieldRef -returns [object Value, bool HasSyntaxError] -@init {Actions.BeginSemanticRoot(_localctx);} +returns [CILParser.FieldReferenceValue Value, bool HasSyntaxError] +locals [int InitialSyntaxErrorCount] +@init { + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.FieldReferenceValue.Error; +} : fieldType = type owner = typeSpec '::' name = dottedName {_localctx.Value = Actions.CreateFieldReference($fieldType.Value, $owner.Value, $name.Value);} @@ -1386,25 +1557,32 @@ returns [object Value, bool HasSyntaxError] {_localctx.Value = Actions.CreateFieldReference($fieldType.Value, null, $name.Value);} | alias = dottedName {_localctx.Value = Actions.CreateTypedefFieldReference(_localctx.Start, $alias.Value);} // typedef ; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} +finally { + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; +} /* Generic type parameters declaration */ -typeList returns [object Value] -@init {Actions.BeginGenericTypeList(_localctx);} +typeList returns [System.Collections.Immutable.ImmutableArray Value] +locals [System.Collections.Immutable.ImmutableArray.Builder Builder] +@init {_localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder();} : - (item = typeSpec {Actions.AddGenericType(_localctx, $item.Value);} ',')* - tail = typeSpec {Actions.AddGenericType(_localctx, $tail.Value);} + (item = typeSpec {_localctx.Builder.Add($item.Value);} ',')* + tail = typeSpec {_localctx.Builder.Add($tail.Value);} ; -finally {_localctx.Value = Actions.EndGenericTypeList(_localctx);} +finally {_localctx.Value = _localctx.Builder.ToImmutable();} -typarsClause returns [object Value] -@init {_localctx.Value = Actions.CreateEmptyGenericParameterList();} +typarsClause returns [System.Collections.Immutable.ImmutableArray Value] +@init {_localctx.Value = System.Collections.Immutable.ImmutableArray.Empty;} : /* EMPTY */ | '<' parameters = typars '>' {_localctx.Value = $parameters.Value;} ; -typarAttrib returns [object Value]: +typarAttrib returns [CILParser.AttributeValue Value] +@init {_localctx.Value = CILParser.AttributeValue.Empty;} +: covariant = PLUS {_localctx.Value = Actions.CreateGenericParameterAttribute($covariant);} | contravariant = '-' {_localctx.Value = Actions.CreateGenericParameterAttribute($contravariant);} | class = 'class' {_localctx.Value = Actions.CreateGenericParameterAttribute($class);} @@ -1413,26 +1591,31 @@ typarAttrib returns [object Value]: | ctor = '.ctor' {_localctx.Value = Actions.CreateGenericParameterAttribute($ctor);} | 'flags' '(' flags = int32 ')' {_localctx.Value = Actions.CreateRawGenericParameterAttribute($flags.start);}; -typarAttribs returns [object Value] -@init {Actions.BeginGenericParameterAttributes(_localctx);} +typarAttribs returns [System.Reflection.GenericParameterAttributes Value] +@init {_localctx.Value = 0;} : - (attribute = typarAttrib {Actions.AddGenericParameterAttribute(_localctx, $attribute.Value);})* + (attribute = typarAttrib + {_localctx.Value = Actions.AddGenericParameterAttribute(_localctx.Value, $attribute.Value);})* ; -finally {_localctx.Value = Actions.EndGenericParameterAttributes(_localctx);} -typar returns [object Value]: +typar returns [CILParser.GenericParameterDeclarationValue Value] +@init {_localctx.Value = CILParser.GenericParameterDeclarationValue.Error;} +: attributes = typarAttribs constraints = tyBound? name = dottedName {_localctx.Value = Actions.CreateGenericParameterDeclaration($attributes.Value, $constraints.ctx, $name.Value);}; -typars returns [object Value] -@init {Actions.BeginGenericParameters(_localctx);} +typars returns [System.Collections.Immutable.ImmutableArray Value] +locals [System.Collections.Immutable.ImmutableArray.Builder Builder] +@init {_localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder();} : - (parameter = typar {Actions.AddGenericParameter(_localctx, $parameter.Value);} ',')* - tail = typar {Actions.AddGenericParameter(_localctx, $tail.Value);} + (parameter = typar {_localctx.Builder.Add($parameter.Value);} ',')* + tail = typar {_localctx.Builder.Add($tail.Value);} ; -finally {_localctx.Value = Actions.EndGenericParameters(_localctx);} +finally {_localctx.Value = _localctx.Builder.ToImmutable();} -tyBound returns [object Value]: +tyBound returns [System.Collections.Immutable.ImmutableArray Value] +@init {_localctx.Value = System.Collections.Immutable.ImmutableArray.Empty;} +: '(' constraints = typeList ')' {_localctx.Value = $constraints.Value;}; genArity returns [int Value]: @@ -1443,11 +1626,18 @@ genArityNotEmpty returns [int Value]: /* Class body declarations */ classDecl +locals [ + CILParser.PropertyBodyValue PropertyBody, + CILParser.EventBodyValue EventBody, + CILParser.CustomAttributeOwnerValue AttributeOwner +] : methodHead '{' methodDecls '}' | classHead '{' classDecls '}' - | eventHeader = eventHead {Actions.BeginEvent(_localctx, $eventHeader.Value);} '{' eventDecls '}' - | property = propHead {Actions.BeginProperty(_localctx, $property.Value);} '{' propDecls '}' + | eventHeader = eventHead {_localctx.EventBody = Actions.BeginEvent($eventHeader.Value);} + '{' eventDecls[_localctx.EventBody] '}' + | property = propHead {_localctx.PropertyBody = Actions.BeginProperty($property.Value);} + '{' propDecls[_localctx.PropertyBody] '}' | fieldDecl | data = dataDecl {Actions.ProcessClassDataDeclaration($data.ctx);} | security = secDecl {Actions.ProcessClassSecurityDeclaration($security.ctx);} @@ -1492,44 +1682,52 @@ classDecl | language = languageDecl {Actions.ProcessClassLanguageDirective($language.ctx);} | compControl {Actions.ProcessClassCompilerControl();} | PARAM TYPE '[' parameterIndex = int32 ']' - {Actions.BeginClassGenericParameterDirective(_localctx, $parameterIndex.start);} - (attribute = customAttrDecl {Actions.AddClassGenericDirectiveAttribute(_localctx, $attribute.ctx);})* + {_localctx.AttributeOwner = Actions.BeginClassGenericParameterDirective(_localctx, $parameterIndex.start);} + (attribute = customAttrDecl {Actions.AddClassGenericDirectiveAttribute(_localctx.AttributeOwner, $attribute.ctx);})* | PARAM TYPE parameterName = dottedName - {Actions.BeginClassGenericParameterDirective(_localctx, $parameterName.Value);} - (attribute = customAttrDecl {Actions.AddClassGenericDirectiveAttribute(_localctx, $attribute.ctx);})* + {_localctx.AttributeOwner = Actions.BeginClassGenericParameterDirective($parameterName.Value);} + (attribute = customAttrDecl {Actions.AddClassGenericDirectiveAttribute(_localctx.AttributeOwner, $attribute.ctx);})* | PARAM CONSTRAINT '[' parameterIndex = int32 ']' ',' constraintType = typeSpec - {Actions.BeginClassGenericConstraintDirective(_localctx, $parameterIndex.start, $constraintType.Value);} - (attribute = customAttrDecl {Actions.AddClassGenericDirectiveAttribute(_localctx, $attribute.ctx);})* + {_localctx.AttributeOwner = Actions.BeginClassGenericConstraintDirective(_localctx, $parameterIndex.start, $constraintType.Value);} + (attribute = customAttrDecl {Actions.AddClassGenericDirectiveAttribute(_localctx.AttributeOwner, $attribute.ctx);})* | PARAM CONSTRAINT parameterName = dottedName ',' constraintType = typeSpec - {Actions.BeginClassGenericConstraintDirective(_localctx, $parameterName.Value, $constraintType.Value);} - (attribute = customAttrDecl {Actions.AddClassGenericDirectiveAttribute(_localctx, $attribute.ctx);})* + {_localctx.AttributeOwner = Actions.BeginClassGenericConstraintDirective($parameterName.Value, $constraintType.Value);} + (attribute = customAttrDecl {Actions.AddClassGenericDirectiveAttribute(_localctx.AttributeOwner, $attribute.ctx);})* | '.interfaceimpl' TYPE interfaceType = typeSpec interfaceAttribute = customDescr {Actions.AddInterfaceImplementationAttribute(_localctx, $interfaceType.Value, $interfaceAttribute.ctx);} ; finally {Actions.EndClassDeclaration(_localctx);} /* Field declaration */ -fieldDecl returns [object Value] -@init {Actions.BeginFieldDeclaration(_localctx);} +fieldDecl returns [CILParser.FieldDeclarationValue Value] +locals [int InitialSyntaxErrorCount, CILParser.FieldDeclarationBuilder Builder] +@init { + _localctx.Builder = Actions.PrepareFieldDeclaration(); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.FieldDeclarationValue.Error; +} @after {Actions.DefineField(_localctx, _localctx.Value);} : '.field' offset = repeatOpt ( - attribute = fieldAttr {Actions.AddFieldAttribute(_localctx, $attribute.Value);} - | 'marshal' '(' marshalling = marshalBlob ')' {Actions.SetFieldMarshalling(_localctx, $marshalling.Value);} + attribute = fieldAttr {Actions.AddFieldAttribute(_localctx.Builder, $attribute.Value);} + | 'marshal' '(' marshalling = marshalBlob ')' {Actions.SetFieldMarshalling(_localctx.Builder, $marshalling.Value);} )* fieldType = type name = dottedName data = atOpt initializer = initOpt {_localctx.Value = Actions.CreateFieldDeclaration( _localctx, + _localctx.Builder, + _localctx.InitialSyntaxErrorCount, $offset.ctx, $fieldType.Value, $name.Value, $data.Value, $initializer.Value);} ; -finally {Actions.EndFieldDeclaration(_localctx);} -fieldAttr returns [object Value]: +fieldAttr returns [CILParser.AttributeValue Value] +@init {_localctx.Value = CILParser.AttributeValue.Empty;} +: attribute = 'static' {_localctx.Value = Actions.CreateFieldAttribute($attribute);} | attribute = 'public' {_localctx.Value = Actions.CreateFieldAttribute($attribute);} | attribute = 'private' {_localctx.Value = Actions.CreateFieldAttribute($attribute);} @@ -1546,107 +1744,147 @@ fieldAttr returns [object Value]: | attribute = 'volatile' {_localctx.Value = Actions.CreateFieldAttribute($attribute);} | 'flags' '(' flags = int32 ')' {_localctx.Value = Actions.CreateRawFieldAttribute($flags.start);}; -atOpt returns [string Value]: +atOpt returns [string? Value] +@init {_localctx.Value = null;} +: /* EMPTY */ | 'at' name = id {_localctx.Value = Actions.GetFieldDataName($name.start);} | 'at' offset = int32 {_localctx.Value = Actions.GetFieldDataOffset($offset.start);}; -initOpt returns [object Value, bool HasSyntaxError] -@init {Actions.BeginFieldInitializer(_localctx);} +initOpt returns [CILParser.FieldInitializerValue Value, bool HasSyntaxError] +locals [int InitialSyntaxErrorCount] +@init { + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.FieldInitializerValue.Empty; +} : /* EMPTY */ - | '=' initializer = fieldInit {Actions.SetFieldInitializer(_localctx, $initializer.Value);} + | '=' initializer = fieldInit {_localctx.Value = $initializer.Value;} ; -finally {_localctx.HasSyntaxError = Actions.EndFieldInitializer(_localctx);} +finally { + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; +} repeatOpt returns [int Value, bool HasValue]: /* EMPTY */ | '[' offset = int32 ']' {Actions.SetFieldOffset(_localctx, $offset.start);}; /* Event declaration */ -eventHead returns [object Value] -@init {Actions.BeginEventHeader(_localctx);} +eventHead returns [CILParser.EventHeaderValue Value] +locals [int InitialSyntaxErrorCount, CILParser.EventHeaderBuilder Builder] +@init { + _localctx.Builder = new CILParser.EventHeaderBuilder(); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.EventHeaderValue.Error; +} : '.event' - (attribute = eventAttr {Actions.AddEventAttribute(_localctx, $attribute.Value);})* + (attribute = eventAttr {Actions.AddEventAttribute(_localctx.Builder, $attribute.Value);})* eventType = typeSpec name = dottedName - {_localctx.Value = Actions.CreateEventHeader(_localctx, $eventType.Value, $name.Value);} + {_localctx.Value = Actions.CreateEventHeader( + _localctx, + _localctx.Builder, + _localctx.InitialSyntaxErrorCount, + $eventType.Value, + $name.Value);} | '.event' - (attribute = eventAttr {Actions.AddEventAttribute(_localctx, $attribute.Value);})* + (attribute = eventAttr {Actions.AddEventAttribute(_localctx.Builder, $attribute.Value);})* name = dottedName - {_localctx.Value = Actions.CreateEventHeader(_localctx, null, $name.Value);} + {_localctx.Value = Actions.CreateEventHeader( + _localctx, + _localctx.Builder, + _localctx.InitialSyntaxErrorCount, + null, + $name.Value);} ; -finally {Actions.EndEventHeader(_localctx);} -eventAttr returns [object Value]: +eventAttr returns [CILParser.AttributeValue Value] +@init {_localctx.Value = CILParser.AttributeValue.Empty;} +: attribute = 'rtspecialname' {_localctx.Value = Actions.CreateEventAttribute($attribute);} | attribute = 'specialname' {_localctx.Value = Actions.CreateEventAttribute($attribute);}; -eventDecls: eventDecl*; +eventDecls [CILParser.EventBodyValue Body]: eventDecl[$Body]*; -eventDecl: - '.addon' accessor = methodRef {Actions.AddEventAdder(_localctx, $accessor.Value);} - | '.removeon' accessor = methodRef {Actions.AddEventRemover(_localctx, $accessor.Value);} - | '.fire' accessor = methodRef {Actions.AddEventRaiser(_localctx, $accessor.Value);} - | '.other' accessor = methodRef {Actions.AddEventOther(_localctx, $accessor.Value);} - | source = extSourceSpec {Actions.ProcessEventSourceDirective($source.ctx);} - | attribute = customAttrDecl {Actions.AddEventCustomAttribute(_localctx, $attribute.ctx);} - | language = languageDecl {Actions.ProcessEventLanguageDirective($language.ctx);} +eventDecl [CILParser.EventBodyValue Body]: + '.addon' accessor = methodRef {Actions.AddEventAdder($Body, $accessor.Value);} + | '.removeon' accessor = methodRef {Actions.AddEventRemover($Body, $accessor.Value);} + | '.fire' accessor = methodRef {Actions.AddEventRaiser($Body, $accessor.Value);} + | '.other' accessor = methodRef {Actions.AddEventOther($Body, $accessor.Value);} + | source = extSourceSpec {Actions.ProcessEventSourceDirective($Body, $source.ctx);} + | attribute = customAttrDecl {Actions.AddEventCustomAttribute($Body, $attribute.ctx);} + | language = languageDecl {Actions.ProcessEventLanguageDirective($Body, $language.ctx);} | compControl; /* Property declaration */ -propHead returns [object Value] -@init {Actions.BeginPropertyHeader(_localctx);} +propHead returns [CILParser.PropertyHeaderValue Value] +locals [int InitialSyntaxErrorCount, CILParser.PropertyHeaderBuilder Builder] +@init { + _localctx.Builder = new CILParser.PropertyHeaderBuilder(); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.PropertyHeaderValue.Error; +} : '.property' - (attribute = propAttr {Actions.AddPropertyAttribute(_localctx, $attribute.Value);})* + (attribute = propAttr {Actions.AddPropertyAttribute(_localctx.Builder, $attribute.Value);})* convention = callConv propertyType = type name = dottedName arguments = sigArgs initializer = initOpt {_localctx.Value = Actions.CreatePropertyHeader( _localctx, + _localctx.Builder, + _localctx.InitialSyntaxErrorCount, $convention.Value, $propertyType.Value, $name.Value, $arguments.Value, $initializer.Value);} ; -finally {Actions.EndPropertyHeader(_localctx);} -propAttr returns [object Value]: +propAttr returns [CILParser.AttributeValue Value] +@init {_localctx.Value = CILParser.AttributeValue.Empty;} +: attribute = 'rtspecialname' {_localctx.Value = Actions.CreatePropertyAttribute($attribute);} | attribute = 'specialname' {_localctx.Value = Actions.CreatePropertyAttribute($attribute);}; -propDecls: propDecl*; +propDecls [CILParser.PropertyBodyValue Body]: propDecl[$Body]*; -propDecl: - '.set' accessor = methodRef {Actions.AddPropertySetter(_localctx, $accessor.Value);} - | '.get' accessor = methodRef {Actions.AddPropertyGetter(_localctx, $accessor.Value);} - | '.other' accessor = methodRef {Actions.AddPropertyOther(_localctx, $accessor.Value);} - | attribute = customAttrDecl {Actions.AddPropertyCustomAttribute(_localctx, $attribute.ctx);} - | source = extSourceSpec {Actions.ProcessPropertySourceDirective($source.ctx);} - | language = languageDecl {Actions.ProcessPropertyLanguageDirective($language.ctx);} +propDecl [CILParser.PropertyBodyValue Body]: + '.set' accessor = methodRef {Actions.AddPropertySetter($Body, $accessor.Value);} + | '.get' accessor = methodRef {Actions.AddPropertyGetter($Body, $accessor.Value);} + | '.other' accessor = methodRef {Actions.AddPropertyOther($Body, $accessor.Value);} + | attribute = customAttrDecl {Actions.AddPropertyCustomAttribute($Body, $attribute.ctx);} + | source = extSourceSpec {Actions.ProcessPropertySourceDirective($Body, $source.ctx);} + | language = languageDecl {Actions.ProcessPropertyLanguageDirective($Body, $language.ctx);} | compControl; /* Method declaration */ -marshalClause returns [object Value]: +marshalClause returns [CILParser.MarshallingDescriptorValue Value] +@init {_localctx.Value = CILParser.MarshallingDescriptorValue.Empty;} +: /* EMPTY */ {_localctx.Value = Actions.CreateEmptyMarshallingDescriptor();} | 'marshal' '(' value = marshalBlob ')' {_localctx.Value = Actions.CompleteMarshalClause($value.Value);} ; -marshalBlob returns [object Value] -@init {Actions.BeginMarshalBlob(_localctx);} +marshalBlob returns [CILParser.MarshallingDescriptorValue Value] +locals [CILParser.MarshalBlobBuilder Builder] +@init {_localctx.Builder = new CILParser.MarshalBlobBuilder();} : - nativeValue = nativeType {Actions.SetMarshalBlobNativeType(_localctx, $nativeValue.Value);} - | '{' (rawByte = hexbyte {Actions.AddMarshalBlobByte(_localctx, $rawByte.Value);})+ '}' + nativeValue = nativeType {Actions.SetMarshalBlobNativeType(_localctx.Builder, $nativeValue.Value);} + | '{' (rawByte = hexbyte {Actions.AddMarshalBlobByte(_localctx.Builder, $rawByte.Value);})+ '}' ; -finally {_localctx.Value = Actions.EndMarshalBlob(_localctx);} +finally {_localctx.Value = Actions.CreateMarshallingDescriptor(_localctx.Builder);} paramAttr returns [int Value] -@init {Actions.BeginParameterAttributes(_localctx);} +@init {_localctx.Value = 0;} : - (element = paramAttrElement {Actions.AddParameterAttribute(_localctx, $element.ctx);})* + (element = paramAttrElement + {_localctx.Value = Actions.AddParameterAttribute( + _localctx.Value, + $element.Value, + $element.ShouldAppend);})* ; -finally {_localctx.Value = Actions.EndParameterAttributes(_localctx);} paramAttrElement returns [int Value, bool ShouldAppend]: '[' attribute = 'in' ']' {Actions.SetParameterAttributeElement(_localctx, $attribute);} @@ -1655,20 +1893,27 @@ paramAttrElement returns [int Value, bool ShouldAppend]: | '[' raw = int32 ']' {Actions.SetRawParameterAttributeElement(_localctx, $raw.start);}; methodHead -returns [object Value] -@init {Actions.BeginMethodHeader(_localctx);} +returns [CILParser.MethodHeaderValue Value] +locals [int InitialSyntaxErrorCount, CILParser.MethodHeaderBuilder Builder] +@init { + _localctx.Builder = Actions.PrepareMethodHeader(); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.MethodHeaderValue.Error; +} @after {Actions.BeginMethod(_localctx, _localctx.Value);} : '.method' ( - attribute = methAttr {Actions.AddMethodAttribute(_localctx, $attribute.Value);} - | pInvoke = pinvImpl {Actions.AddPInvoke(_localctx, $pInvoke.Value);} + attribute = methAttr {Actions.AddMethodAttribute(_localctx.Builder, $attribute.Value);} + | pInvoke = pinvImpl {Actions.AddPInvoke(_localctx.Builder, $pInvoke.Value);} )* convention = callConv returnAttributes = paramAttr returnType = type returnMarshalling = marshalClause name = methodName genericParameters = typarsClause arguments = sigArgs - (implementation = implAttr {Actions.AddMethodImplementationAttribute(_localctx, $implementation.Value);})* + (implementation = implAttr {Actions.AddMethodImplementationAttribute(_localctx.Builder, $implementation.Value);})* {_localctx.Value = Actions.CreateMethodHeader( _localctx, + _localctx.Builder, + _localctx.InitialSyntaxErrorCount, $convention.Value, $returnAttributes.Value, $returnType.Value, @@ -1677,9 +1922,10 @@ returns [object Value] $genericParameters.Value, $arguments.Value);} ; -finally {Actions.EndMethodHeader(_localctx);} -methAttr returns [object Value]: +methAttr returns [CILParser.AttributeValue Value] +@init {_localctx.Value = CILParser.AttributeValue.Empty;} +: attribute = 'static' {_localctx.Value = Actions.CreateMethodAttribute($attribute);} | attribute = 'public' {_localctx.Value = Actions.CreateMethodAttribute($attribute);} | attribute = 'private' {_localctx.Value = Actions.CreateMethodAttribute($attribute);} @@ -1700,19 +1946,22 @@ methAttr returns [object Value]: | attribute = 'reqsecobj' {_localctx.Value = Actions.CreateMethodAttribute($attribute);} | 'flags' '(' flags = int32 ')' {_localctx.Value = Actions.CreateRawMethodAttribute($flags.start);}; -pinvImpl returns [object Value] -@init {Actions.BeginPInvoke(_localctx);} +pinvImpl returns [CILParser.PInvokeValue Value] +locals [CILParser.PInvokeBuilder Builder] +@init {_localctx.Builder = new CILParser.PInvokeBuilder();} : 'pinvokeimpl' '(' - (module = compQstring {Actions.SetPInvokeModule(_localctx, $module.Value);} - ('as' entryPoint = compQstring {Actions.SetPInvokeEntryPoint(_localctx, $entryPoint.Value);})?)? - (attribute = pinvAttr {Actions.AddPInvokeAttribute(_localctx, $attribute.Value);})* + (module = compQstring {Actions.SetPInvokeModule(_localctx.Builder, $module.Value);} + ('as' entryPoint = compQstring {Actions.SetPInvokeEntryPoint(_localctx.Builder, $entryPoint.Value);})?)? + (attribute = pinvAttr {Actions.AddPInvokeAttribute(_localctx.Builder, $attribute.Value);})* ')' | 'pinvokeimpl' '()' ; -finally {_localctx.Value = Actions.EndPInvoke(_localctx);} +finally {_localctx.Value = Actions.CreatePInvoke(_localctx.Builder);} -pinvAttr returns [object Value]: +pinvAttr returns [CILParser.AttributeValue Value] +@init {_localctx.Value = CILParser.AttributeValue.Empty;} +: attribute = 'nomangle' {_localctx.Value = Actions.CreatePInvokeAttribute($attribute);} | attribute = 'ansi' {_localctx.Value = Actions.CreatePInvokeAttribute($attribute);} | attribute = 'unicode' {_localctx.Value = Actions.CreatePInvokeAttribute($attribute);} @@ -1729,12 +1978,16 @@ pinvAttr returns [object Value]: | 'charmaperror' ':' setting = 'off' {_localctx.Value = Actions.CreateCharMapErrorPInvokeAttribute($setting);} | 'flags' '(' flags = int32 ')' {_localctx.Value = Actions.CreateRawPInvokeAttribute($flags.start);}; -methodName returns [string Value]: +methodName returns [string Value] +@init {_localctx.Value = string.Empty;} +: ctorName = '.ctor' {_localctx.Value = Actions.GetMethodName($ctorName);} | cctorName = '.cctor' {_localctx.Value = Actions.GetMethodName($cctorName);} | dotted = dottedName {_localctx.Value = $dotted.Value;}; -implAttr returns [object Value]: +implAttr returns [CILParser.AttributeValue Value] +@init {_localctx.Value = CILParser.AttributeValue.Empty;} +: attribute = 'native' {_localctx.Value = Actions.CreateMethodImplementationAttribute($attribute);} | attribute = 'cil' {_localctx.Value = Actions.CreateMethodImplementationAttribute($attribute);} | attribute = 'il' {_localctx.Value = Actions.CreateMethodImplementationAttribute($attribute);} @@ -1790,58 +2043,80 @@ methodDecl: ; localsDecl -@init {Actions.BeginSemanticRoot(_localctx);} +locals [int InitialSyntaxErrorCount] +@init {_localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount;} : LOCALS initialize = 'init'? arguments = sigArgs ; -finally {Actions.EndLocalsDirective(_localctx);} +finally {Actions.EndLocalsDirective(_localctx, _localctx.InitialSyntaxErrorCount);} exportDecl -@init {Actions.BeginSemanticRoot(_localctx);} +locals [int InitialSyntaxErrorCount] +@init {_localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount;} : EXPORT '[' ordinal = int32 ']' ('as' alias = id)? ; -finally {Actions.EndExportDirective(_localctx);} +finally {Actions.EndExportDirective(_localctx, _localctx.InitialSyntaxErrorCount);} vtentryDecl -@init {Actions.BeginSemanticRoot(_localctx);} +locals [int InitialSyntaxErrorCount] +@init {_localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount;} : VTENTRY table = int32 ':' slot = int32 ; -finally {Actions.EndVTableEntryDirective(_localctx);} +finally {Actions.EndVTableEntryDirective(_localctx, _localctx.InitialSyntaxErrorCount);} overrideDecl -@init {Actions.BeginSemanticRoot(_localctx);} +locals [int InitialSyntaxErrorCount] +@init {_localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount;} : OVERRIDE owner = typeSpec '::' name = methodName | OVERRIDE 'method' convention = callConv returnType = type owner = typeSpec '::' name = methodName arity = genArity arguments = sigArgs ; -finally {Actions.EndOverrideDirective(_localctx);} +finally {Actions.EndOverrideDirective(_localctx, _localctx.InitialSyntaxErrorCount);} parameterDecl -@init {Actions.BeginParameterDirective(_localctx);} +locals [ + int InitialSyntaxErrorCount, + System.Collections.Immutable.ImmutableArray.Builder Attributes +] +@init { + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Attributes = System.Collections.Immutable.ImmutableArray.CreateBuilder(); +} : - PARAM TYPE '[' genericIndex = int32 ']' (attribute = customAttrDecl {Actions.AddParameterCustomAttribute(_localctx, $attribute.ctx);})* - | PARAM TYPE genericName = dottedName (attribute = customAttrDecl {Actions.AddParameterCustomAttribute(_localctx, $attribute.ctx);})* + PARAM TYPE '[' genericIndex = int32 ']' (attribute = customAttrDecl {Actions.AddCustomAttributeApplication(_localctx.Attributes, $attribute.ctx);})* + | PARAM TYPE genericName = dottedName (attribute = customAttrDecl {Actions.AddCustomAttributeApplication(_localctx.Attributes, $attribute.ctx);})* | PARAM CONSTRAINT '[' constraintIndex = int32 ']' ',' constraintType = typeSpec - (attribute = customAttrDecl {Actions.AddParameterCustomAttribute(_localctx, $attribute.ctx);})* + (attribute = customAttrDecl {Actions.AddCustomAttributeApplication(_localctx.Attributes, $attribute.ctx);})* | PARAM CONSTRAINT constraintName = dottedName ',' constraintType = typeSpec - (attribute = customAttrDecl {Actions.AddParameterCustomAttribute(_localctx, $attribute.ctx);})* + (attribute = customAttrDecl {Actions.AddCustomAttributeApplication(_localctx.Attributes, $attribute.ctx);})* | PARAM '[' parameterIndex = int32 ']' initializer = initOpt - (attribute = customAttrDecl {Actions.AddParameterCustomAttribute(_localctx, $attribute.ctx);})* + (attribute = customAttrDecl {Actions.AddCustomAttributeApplication(_localctx.Attributes, $attribute.ctx);})* ; -finally {Actions.EndParameterDirective(_localctx);} +finally {Actions.EndParameterDirective( + _localctx, + _localctx.Attributes.ToImmutable(), + _localctx.InitialSyntaxErrorCount);} labelDecl: name = id ':' {Actions.DefineLabel($name.start);}; -customDescrInMethodBody returns [object Value, bool HasSyntaxError] -@init {Actions.BeginSemanticRoot(_localctx);} +customDescrInMethodBody returns [CILParser.CustomAttributeDeclarationValue Value, bool HasSyntaxError] +locals [int InitialSyntaxErrorCount] +@init { + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.CustomAttributeDeclarationValue.Error; +} : directAttribute = customDescr {_localctx.Value = Actions.CreateCustomAttributeDeclaration($directAttribute.Value);} | ownedAttribute = customDescrWithOwner {_localctx.Value = Actions.CreateCustomAttributeDeclaration($ownedAttribute.Value);}; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} +finally { + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; +} scopeBlock @init {Actions.BeginScope(_localctx);} @@ -1852,27 +2127,33 @@ finally {Actions.EndScope(_localctx);} /* Structured exception handling directives */ sehBlock -@init {Actions.BeginExceptionBlock(_localctx);} +locals [int InitialSyntaxErrorCount] +@init {_localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount;} : tryRange = tryBlock clauses = sehClauses ; -finally {Actions.EndExceptionBlock(_localctx);} +finally {Actions.EndExceptionBlock(_localctx, _localctx.InitialSyntaxErrorCount);} -sehClauses returns [object Value] -@init {Actions.BeginExceptionClauses(_localctx);} +sehClauses returns [System.Collections.Immutable.ImmutableArray Value] +locals [System.Collections.Immutable.ImmutableArray.Builder Builder] +@init {_localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder();} : - (clause = sehClause {Actions.AddExceptionClause(_localctx, $clause.Value);})+ + (clause = sehClause {_localctx.Builder.Add($clause.Value);})+ ; -finally {_localctx.Value = Actions.EndExceptionClauses(_localctx);} +finally {_localctx.Value = _localctx.Builder.ToImmutable();} -tryBlock returns [object Value]: +tryBlock returns [CILParser.ExceptionRangeValue Value] +@init {_localctx.Value = CILParser.ExceptionRangeValue.Invalid;} +: '.try' body = scopeBlock {_localctx.Value = Actions.CreateScopeExceptionRange($body.ctx);} | '.try' startLabel = id 'to' endLabel = id {_localctx.Value = Actions.CreateLabelExceptionRange($startLabel.start, $endLabel.start);} | '.try' startOffset = int32 'to' endOffset = int32 {_localctx.Value = Actions.CreateOffsetExceptionRange($startOffset.start, $endOffset.start);}; -sehClause returns [object Value]: +sehClause returns [CILParser.ExceptionClauseValue Value] +@init {_localctx.Value = CILParser.ExceptionClauseValue.Invalid;} +: caught = catchClause handler = handlerBlock {_localctx.Value = Actions.CreateCatchExceptionClause($caught.Value, $handler.Value);} | filtered = filterClause handler = handlerBlock @@ -1882,24 +2163,32 @@ sehClause returns [object Value]: | faultClause handler = handlerBlock {_localctx.Value = Actions.CreateFaultExceptionClause($handler.Value);}; -filterClause returns [object Value]: +filterClause returns [CILParser.ExceptionFilterValue Value] +@init {_localctx.Value = CILParser.ExceptionFilterValue.Invalid;} +: 'filter' body = scopeBlock {_localctx.Value = Actions.CreateScopeFilter($body.ctx);} | 'filter' label = id {_localctx.Value = Actions.CreateLabelFilter($label.start);} | 'filter' offset = int32 {_localctx.Value = Actions.CreateOffsetFilter($offset.start);}; catchClause -returns [object Value] -@init {Actions.BeginCatchClause(_localctx);} +returns [CILParser.CatchTypeValue Value] +locals [int InitialSyntaxErrorCount] +@init { + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.CatchTypeValue.Invalid; +} : 'catch' catchType = typeSpec ; -finally {_localctx.Value = Actions.EndCatchClause(_localctx);} +finally {_localctx.Value = Actions.EndCatchClause(_localctx, _localctx.InitialSyntaxErrorCount);} finallyClause: 'finally'; faultClause: 'fault'; -handlerBlock returns [object Value]: +handlerBlock returns [CILParser.ExceptionRangeValue Value] +@init {_localctx.Value = CILParser.ExceptionRangeValue.Invalid;} +: body = scopeBlock {_localctx.Value = Actions.CreateScopeExceptionRange($body.ctx);} | 'handler' startLabel = id 'to' endLabel = id {_localctx.Value = Actions.CreateLabelExceptionRange($startLabel.start, $endLabel.start);} @@ -1908,17 +2197,21 @@ handlerBlock returns [object Value]: /* Data declaration */ dataDecl returns [bool HasSyntaxError] -@init {Actions.BeginDataDeclaration(_localctx);} +locals [int InitialSyntaxErrorCount, CILParser.DataDeclarationBuilder Builder] +@init { + _localctx.Builder = Actions.CreateDataDeclaration(_localctx); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; +} : - ddHead ddBody + ddHead[_localctx.Builder] ddBody[_localctx.Builder] ; -finally {Actions.EndDataDeclaration(_localctx);} +finally {Actions.EndDataDeclaration(_localctx, _localctx.Builder, _localctx.InitialSyntaxErrorCount);} -ddHead: +ddHead [CILParser.DataDeclarationBuilder Builder]: '.data' section = tls name = id '=' - {Actions.SetDataDeclarationHeader(_localctx, $section.Value, $name.start);} + {Actions.SetDataDeclarationHeader($Builder, $section.Value, $name.start);} | '.data' section = tls - {Actions.SetAnonymousDataDeclarationHeader(_localctx, $section.Value);}; + {Actions.SetAnonymousDataDeclarationHeader($Builder, $section.Value);}; tls returns [byte Value] @init {_localctx.Value = Actions.GetMappedDataSection();} @@ -1927,9 +2220,11 @@ tls returns [byte Value] | 'tls' {_localctx.Value = Actions.GetTlsDataSection();} | 'cil' {_localctx.Value = Actions.GetCilDataSection();}; -ddBody: '{' ddItemList '}' | ddItem+; +ddBody [CILParser.DataDeclarationBuilder Builder]: + '{' ddItemList[$Builder] '}' | ddItem[$Builder]+; -ddItemList: (ddItem ',')* ddItem; +ddItemList [CILParser.DataDeclarationBuilder Builder]: + (ddItem[$Builder] ',')* ddItem[$Builder]; ddItemCount returns [int Value] @init {_localctx.Value = 1;} @@ -1937,19 +2232,19 @@ ddItemCount returns [int Value] /* EMPTY */ | '[' count = int32 ']' {_localctx.Value = Actions.ParseDataItemCount($count.start);}; -ddItem: - CHAR PTR '(' stringValue = compQstring ')' {Actions.AddDataString(_localctx, $stringValue.Value);} - | REF '(' target = id ')' {Actions.AddDataReference(_localctx, $target.start);} - | REF target = id {Actions.AddDataReference(_localctx, $target.start);} - | 'bytearray' '(' byteValue = bytes ')' {Actions.AddDataBytes(_localctx, $byteValue.Value);} +ddItem [CILParser.DataDeclarationBuilder Builder]: + CHAR PTR '(' stringValue = compQstring ')' {Actions.AddDataString($Builder, $stringValue.Value);} + | REF '(' target = id ')' {Actions.AddDataReference($Builder, $target.start);} + | REF target = id {Actions.AddDataReference($Builder, $target.start);} + | 'bytearray' '(' byteValue = bytes ')' {Actions.AddDataBytes($Builder, $byteValue.Value);} | kind = (FLOAT32 | FLOAT64_) '(' floatingValue = float64 ')' count = ddItemCount - {Actions.AddFloatingPointData(_localctx, $kind, $floatingValue.Value, $count.Value);} + {Actions.AddFloatingPointData($Builder, $kind, $floatingValue.Value, $count.Value);} | kind = INT64_ '(' int64Value = int64 ')' count = ddItemCount - {Actions.AddInt64Data(_localctx, $kind, $int64Value.start, $count.Value);} + {Actions.AddInt64Data($Builder, $kind, $int64Value.start, $count.Value);} | kind = (INT32_ | INT16 | INT8) '(' integerValue = int32 ')' count = ddItemCount - {Actions.AddIntegerData(_localctx, $kind, $integerValue.start, $count.Value);} + {Actions.AddIntegerData($Builder, $kind, $integerValue.start, $count.Value);} | kind = (FLOAT32 | FLOAT64_ | INT64_ | INT32_ | INT16 | INT8) count = ddItemCount - {Actions.AddZeroData(_localctx, $kind, $count.Value);}; + {Actions.AddZeroData($Builder, $kind, $count.Value);}; /* Default values declaration for fields, parameters and verbal form of CA blob description */ fieldSerInit returns [System.Reflection.Metadata.BlobBuilder Value]: @@ -1987,11 +2282,12 @@ finally {_localctx.Value ??= new System.Reflection.Metadata.BlobBuilder();} bytes returns [System.Collections.Immutable.ImmutableArray Value] -@init {Actions.BeginBytes();} +locals [System.Collections.Immutable.ImmutableArray.Builder Builder] +@init {_localctx.Builder = Actions.CreateByteAccumulator();} : - (b = hexbyte {Actions.AddByte($b.Value);})* + (b = hexbyte {Actions.AddByte(_localctx.Builder, $b.Value);})* ; -finally {_localctx.Value = Actions.EndBytes();} +finally {_localctx.Value = Actions.EndBytes(_localctx.Builder);} hexbyte returns [byte Value] @@ -2002,13 +2298,17 @@ returns [byte Value] | HEXBYTE ; /* Field/parameter initialization */ -fieldInit returns [object Value]: +fieldInit returns [CILParser.FieldInitializerValue Value] +@init {_localctx.Value = CILParser.FieldInitializerValue.Empty;} +: serializedValue = fieldSerInit {_localctx.Value = Actions.CreateFieldInitializer($serializedValue.Value);} | stringValue = compQstring {_localctx.Value = Actions.CreateFieldInitializer($stringValue.Value);} | NULLREF {_localctx.Value = Actions.CreateNullFieldInitializer();}; /* Values for verbal form of CA blob description */ -serInit returns [object Value]: +serInit returns [CILParser.SerializedInitializerValue Value] +@init {_localctx.Value = CILParser.SerializedInitializerValue.Error;} +: scalarValue = fieldSerInit {_localctx.Value = Actions.CreateScalarSerializedValue(_localctx, $scalarValue.ctx, $scalarValue.Value);} | STRING '(' NULLREF ')' {_localctx.Value = Actions.CreateStringSerializedValue();} @@ -2049,93 +2349,113 @@ serInit returns [object Value]: {_localctx.Value = Actions.CreateArraySerializedValue($objectElementToken, $objectLength.start, $objectValues.Value);}; f32seq returns [System.Reflection.Metadata.BlobBuilder Value] -@init {Actions.BeginSerializationSequence(_localctx);} +locals [System.Reflection.Metadata.BlobBuilder Builder] +@init {_localctx.Builder = new System.Reflection.Metadata.BlobBuilder();} : - (floatingValue = float64 {Actions.AddFloat32SequenceValue(_localctx, $floatingValue.Value);} - | integerValue = int32 {Actions.AddFloat32SequenceValue(_localctx, $integerValue.start);})* + (floatingValue = float64 {Actions.AddFloat32SequenceValue(_localctx.Builder, $floatingValue.Value);} + | integerValue = int32 {Actions.AddFloat32SequenceValue(_localctx.Builder, $integerValue.start);})* ; -finally {_localctx.Value = Actions.EndSerializationSequence(_localctx);} +finally {_localctx.Value = _localctx.Builder;} f64seq returns [System.Reflection.Metadata.BlobBuilder Value] -@init {Actions.BeginSerializationSequence(_localctx);} +locals [System.Reflection.Metadata.BlobBuilder Builder] +@init {_localctx.Builder = new System.Reflection.Metadata.BlobBuilder();} : - (floatingValue = float64 {Actions.AddFloat64SequenceValue(_localctx, $floatingValue.Value);} - | integerValue = int64 {Actions.AddFloat64SequenceValue(_localctx, $integerValue.start);})* + (floatingValue = float64 {Actions.AddFloat64SequenceValue(_localctx.Builder, $floatingValue.Value);} + | integerValue = int64 {Actions.AddFloat64SequenceValue(_localctx.Builder, $integerValue.start);})* ; -finally {_localctx.Value = Actions.EndSerializationSequence(_localctx);} +finally {_localctx.Value = _localctx.Builder;} i64seq returns [System.Reflection.Metadata.BlobBuilder Value] -@init {Actions.BeginSerializationSequence(_localctx);} +locals [System.Reflection.Metadata.BlobBuilder Builder] +@init {_localctx.Builder = new System.Reflection.Metadata.BlobBuilder();} : - (value = int64 {Actions.AddInt64SequenceValue(_localctx, $value.start);})* + (value = int64 {Actions.AddInt64SequenceValue(_localctx.Builder, $value.start);})* ; -finally {_localctx.Value = Actions.EndSerializationSequence(_localctx);} +finally {_localctx.Value = _localctx.Builder;} i32seq returns [System.Reflection.Metadata.BlobBuilder Value] -@init {Actions.BeginSerializationSequence(_localctx);} +locals [System.Reflection.Metadata.BlobBuilder Builder] +@init {_localctx.Builder = new System.Reflection.Metadata.BlobBuilder();} : - (value = int32 {Actions.AddInt32SequenceValue(_localctx, $value.start);})* + (value = int32 {Actions.AddInt32SequenceValue(_localctx.Builder, $value.start);})* ; -finally {_localctx.Value = Actions.EndSerializationSequence(_localctx);} +finally {_localctx.Value = _localctx.Builder;} i16seq returns [System.Reflection.Metadata.BlobBuilder Value] -@init {Actions.BeginSerializationSequence(_localctx);} +locals [System.Reflection.Metadata.BlobBuilder Builder] +@init {_localctx.Builder = new System.Reflection.Metadata.BlobBuilder();} : - (value = int32 {Actions.AddInt16SequenceValue(_localctx, $value.start);})* + (value = int32 {Actions.AddInt16SequenceValue(_localctx.Builder, $value.start);})* ; -finally {_localctx.Value = Actions.EndSerializationSequence(_localctx);} +finally {_localctx.Value = _localctx.Builder;} i8seq returns [System.Reflection.Metadata.BlobBuilder Value] -@init {Actions.BeginSerializationSequence(_localctx);} +locals [System.Reflection.Metadata.BlobBuilder Builder] +@init {_localctx.Builder = new System.Reflection.Metadata.BlobBuilder();} : - (value = int32 {Actions.AddInt8SequenceValue(_localctx, $value.start);})* + (value = int32 {Actions.AddInt8SequenceValue(_localctx.Builder, $value.start);})* ; -finally {_localctx.Value = Actions.EndSerializationSequence(_localctx);} +finally {_localctx.Value = _localctx.Builder;} boolSeq returns [System.Reflection.Metadata.BlobBuilder Value] -@init {Actions.BeginSerializationSequence(_localctx);} +locals [System.Reflection.Metadata.BlobBuilder Builder] +@init {_localctx.Builder = new System.Reflection.Metadata.BlobBuilder();} : - (value = truefalse {Actions.AddBooleanSequenceValue(_localctx, $value.Value);})* + (value = truefalse {Actions.AddBooleanSequenceValue(_localctx.Builder, $value.Value);})* ; -finally {_localctx.Value = Actions.EndSerializationSequence(_localctx);} +finally {_localctx.Value = _localctx.Builder;} sqstringSeq returns [System.Reflection.Metadata.BlobBuilder Value] -@init {Actions.BeginSerializationSequence(_localctx);} +locals [System.Reflection.Metadata.BlobBuilder Builder] +@init {_localctx.Builder = new System.Reflection.Metadata.BlobBuilder();} : - (nullValue = NULLREF {Actions.AddStringSequenceValue(_localctx, $nullValue);} - | stringValue = SQSTRING {Actions.AddStringSequenceValue(_localctx, $stringValue);})* + (nullValue = NULLREF {Actions.AddStringSequenceValue(_localctx.Builder, $nullValue);} + | stringValue = SQSTRING {Actions.AddStringSequenceValue(_localctx.Builder, $stringValue);})* ; -finally {_localctx.Value = Actions.EndSerializationSequence(_localctx);} +finally {_localctx.Value = _localctx.Builder;} -classSeq returns [object Value] -@init {Actions.BeginSerializationSequence(_localctx);} +classSeq returns [CILParser.SerializedSequenceValue Value] +locals [System.Collections.Immutable.ImmutableArray.Builder Builder] +@init {_localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder();} : - (value = classSeqElement {Actions.AddClassSequenceValue(_localctx, $value.Value);})* + (value = classSeqElement {_localctx.Builder.Add($value.Value);})* ; -finally {_localctx.Value = Actions.EndClassSerializationSequence(_localctx);} +finally {_localctx.Value = new CILParser.ClassSerializedSequenceValue(_localctx.Builder.ToImmutable());} -classSeqElement returns [object Value]: +classSeqElement returns [CILParser.ClassSequenceElementValue Value] +@init {_localctx.Value = CILParser.ClassSequenceElementValue.Error;} +: NULLREF {_localctx.Value = Actions.CreateNullClassSequenceValue();} | 'class' quotedValue = SQSTRING {_localctx.Value = Actions.CreateQuotedClassSequenceValue($quotedValue);} | typeValue = className {_localctx.Value = Actions.CreateClassSequenceValue($typeValue.Value);}; -objSeq returns [object Value] -@init {Actions.BeginSerializationSequence(_localctx);} +objSeq returns [CILParser.SerializedSequenceValue Value] +locals [System.Collections.Immutable.ImmutableArray.Builder Builder] +@init {_localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder();} : - (value = serInit {Actions.AddObjectSequenceValue(_localctx, $value.Value);})* + (value = serInit {_localctx.Builder.Add($value.Value);})* ; -finally {_localctx.Value = Actions.EndObjectSerializationSequence(_localctx);} +finally {_localctx.Value = new CILParser.ObjectSerializedSequenceValue(_localctx.Builder.ToImmutable());} -customAttrDecl returns [object Value, bool HasSyntaxError] -@init {Actions.BeginSemanticRoot(_localctx);} +customAttrDecl returns [CILParser.CustomAttributeDeclarationValue Value, bool HasSyntaxError] +locals [int InitialSyntaxErrorCount] +@init { + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.CustomAttributeDeclarationValue.Error; +} : directAttribute = customDescr {_localctx.Value = Actions.CreateCustomAttributeDeclaration($directAttribute.Value);} | ownedAttribute = customDescrWithOwner {_localctx.Value = Actions.CreateCustomAttributeDeclaration($ownedAttribute.Value);} | alias = dottedName {_localctx.Value = Actions.CreateCustomAttributeTypedef($alias.Value);}; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} +finally { + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; +} /* Assembly References */ -asmOrRefDecl returns [object Value]: +asmOrRefDecl returns [CILParser.AssemblyDeclarationValue? Value]: ('.publickey' | '.publicKey') '=' '(' key = bytes ')' {_localctx.Value = Actions.CreateAssemblyPublicKeyDeclaration($key.Value);} | '.ver' major = intOrWildcard ':' minor = intOrWildcard ':' build = intOrWildcard ':' revision = intOrWildcard @@ -2154,17 +2474,28 @@ asmOrRefDecl returns [object Value]: $attribute.start);} | compControl; -assemblyRefBlock returns [object Value, bool HasSyntaxError] -@init {Actions.BeginSemanticRoot(_localctx);} +assemblyRefBlock returns [CILParser.AssemblyReferenceValue? Value, bool HasSyntaxError] +locals [int InitialSyntaxErrorCount] +@init {_localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount;} : header = assemblyRefHead '{' declarations = assemblyRefDecls '}' {_localctx.Value = Actions.CreateAssemblyReference( $header.Value, $declarations.Value);} ; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} +finally { + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; + if (_localctx.HasSyntaxError) + { + _localctx.Value = null; + } +} -assemblyRefHead returns [object Value]: +assemblyRefHead returns [CILParser.AssemblyReferenceHeaderValue Value] +@init {_localctx.Value = CILParser.AssemblyReferenceHeaderValue.Error;} +: '.assembly' 'extern' attributes = asmAttr name = dottedName {_localctx.Value = Actions.CreateAssemblyReferenceHeader( $attributes.Value, @@ -2176,15 +2507,16 @@ assemblyRefHead returns [object Value]: $name.Value, $alias.Value);}; -assemblyRefDecls returns [object Value] -@init {Actions.BeginAssemblyReferenceDeclarations(_localctx);} +assemblyRefDecls returns [System.Collections.Immutable.ImmutableArray Value] +locals [System.Collections.Immutable.ImmutableArray.Builder Builder] +@init {_localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder();} : (declaration = assemblyRefDecl - {Actions.AddAssemblyReferenceDeclaration(_localctx, $declaration.Value);})* + {if ($declaration.Value is not null) _localctx.Builder.Add($declaration.Value);})* ; -finally {_localctx.Value = Actions.EndAssemblyReferenceDeclarations(_localctx);} +finally {_localctx.Value = _localctx.Builder.ToImmutable();} -assemblyRefDecl returns [object Value]: +assemblyRefDecl returns [CILParser.AssemblyDeclarationValue? Value]: '.hash' '=' '(' hash = bytes ')' {_localctx.Value = Actions.CreateAssemblyReferenceHashDeclaration($hash.Value);} | shared = asmOrRefDecl {_localctx.Value = $shared.Value;} @@ -2192,25 +2524,37 @@ assemblyRefDecl returns [object Value]: {_localctx.Value = Actions.CreateAssemblyReferencePublicKeyTokenDeclaration($token.Value);} | 'auto' {_localctx.Value = Actions.CreateAssemblyReferenceAutoDeclaration();}; -exptypeBlock returns [object Value, bool HasSyntaxError] -@init {Actions.BeginSemanticRoot(_localctx);} +exptypeBlock returns [CILParser.ExportedTypeValue? Value, bool HasSyntaxError] +locals [int InitialSyntaxErrorCount] +@init {_localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount;} : header = exptypeHead '{' declarations = exptypeDecls '}' {_localctx.Value = Actions.CreateExportedType( $header.Value, - $declarations.Value, - $header.start);} + $declarations.Value);} ; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} +finally { + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; + if (_localctx.HasSyntaxError) + { + _localctx.Value = null; + } +} -exptypeHead returns [object Value]: +exptypeHead returns [CILParser.ExportedTypeHeaderValue Value] +@init {_localctx.Value = CILParser.ExportedTypeHeaderValue.Error;} +: head = '.class' 'extern' attributes = exptAttrs name = dottedName {_localctx.Value = Actions.CreateExportedTypeHeader( $attributes.Value, $name.Value, $head);}; -exportHead returns [object Value]: +exportHead returns [CILParser.ExportedTypeHeaderValue Value] +@init {_localctx.Value = CILParser.ExportedTypeHeaderValue.Error;} +: head = '.export' attributes = exptAttrs name = dottedName {_localctx.Value = Actions.CreateExportedTypeHeader( $attributes.Value, @@ -2240,15 +2584,16 @@ exptAttr returns [System.Reflection.TypeAttributes Value, System.Reflection.Type | 'nested' 'famandassem' | 'nested' 'famorassem'; -exptypeDecls returns [object Value] -@init {Actions.BeginExportedTypeDeclarations(_localctx);} +exptypeDecls returns [System.Collections.Immutable.ImmutableArray Value] +locals [System.Collections.Immutable.ImmutableArray.Builder Builder] +@init {_localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder();} : (declaration = exptypeDecl - {Actions.AddExportedTypeDeclaration(_localctx, $declaration.Value);})* + {if ($declaration.Value is not null) _localctx.Builder.Add($declaration.Value);})* ; -finally {_localctx.Value = Actions.EndExportedTypeDeclarations(_localctx);} +finally {_localctx.Value = _localctx.Builder.ToImmutable();} -exptypeDecl returns [object Value]: +exptypeDecl returns [CILParser.ExportedTypeDeclarationValue? Value]: location = '.file' name = dottedName {_localctx.Value = Actions.CreateExportedTypeFileDeclaration( $name.Value, @@ -2274,18 +2619,28 @@ exptypeDecl returns [object Value]: $attribute.start);} | compControl; -manifestResBlock returns [object Value, bool HasSyntaxError] -@init {Actions.BeginSemanticRoot(_localctx);} +manifestResBlock returns [CILParser.ManifestResourceValue? Value, bool HasSyntaxError] +locals [int InitialSyntaxErrorCount] +@init {_localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount;} : header = manifestResHead '{' declarations = manifestResDecls '}' {_localctx.Value = Actions.CreateManifestResource( $header.Value, - $declarations.Value, - $header.start);} + $declarations.Value);} ; -finally {_localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx);} +finally { + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; + if (_localctx.HasSyntaxError) + { + _localctx.Value = null; + } +} -manifestResHead returns [object Value]: +manifestResHead returns [CILParser.ManifestResourceHeaderValue Value] +@init {_localctx.Value = CILParser.ManifestResourceHeaderValue.Error;} +: head = MRESOURCE attributes = manresAttrs name = dottedName {_localctx.Value = Actions.CreateManifestResourceHeader( $attributes.Value, @@ -2314,15 +2669,16 @@ manresAttr returns [System.Reflection.ManifestResourceAttributes Value] 'public' | 'private'; -manifestResDecls returns [object Value] -@init {Actions.BeginManifestResourceDeclarations(_localctx);} +manifestResDecls returns [System.Collections.Immutable.ImmutableArray Value] +locals [System.Collections.Immutable.ImmutableArray.Builder Builder] +@init {_localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder();} : (declaration = manifestResDecl - {Actions.AddManifestResourceDeclaration(_localctx, $declaration.Value);})* + {if ($declaration.Value is not null) _localctx.Builder.Add($declaration.Value);})* ; -finally {_localctx.Value = Actions.EndManifestResourceDeclarations(_localctx);} +finally {_localctx.Value = _localctx.Builder.ToImmutable();} -manifestResDecl returns [object Value]: +manifestResDecl returns [CILParser.ManifestResourceDeclarationValue? Value]: location = '.file' name = dottedName 'at' offset = int32 {_localctx.Value = Actions.CreateManifestResourceFileDeclaration( $name.Value, diff --git a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs index 530e18e002eb1d..defd58f42a67ed 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs +++ b/src/tools/ilasm/src/ILAssembler/gen/CILParser.cs @@ -20,6 +20,9 @@ #pragma warning disable 419 namespace ILAssembler { + +#nullable enable annotations + using System; using System.IO; using System.Text; @@ -347,6 +350,7 @@ public IdContext id() { public partial class DottedNameContext : ParserRuleContext { public string Value; + public CILParser.DottedNameBuilder Builder; public IToken direct; public DottedNamePartContext part; public DottedNamePartContext tail; @@ -374,7 +378,7 @@ public DottedNameContext(ParserRuleContext parent, int invokingState) public DottedNameContext dottedName() { DottedNameContext _localctx = new DottedNameContext(Context, State); EnterRule(_localctx, 2, RULE_dottedName); - Actions.BeginDottedName(_localctx); + _localctx.Builder = new CILParser.DottedNameBuilder(); try { int _alt; State = 388; @@ -385,7 +389,7 @@ public DottedNameContext dottedName() { { State = 372; _localctx.direct = Match(DOTTEDNAME); - Actions.AddDottedNameToken(_localctx, _localctx.direct); + Actions.AddDottedNameToken(_localctx.Builder, _localctx.direct); } break; case 2: @@ -401,7 +405,7 @@ public DottedNameContext dottedName() { { State = 374; _localctx.part = dottedNamePart(); - Actions.AddDottedNamePart(_localctx, _localctx.part.Value); + Actions.AddDottedNamePart(_localctx.Builder, _localctx.part.Value); State = 376; Match(DOT); } @@ -413,7 +417,7 @@ public DottedNameContext dottedName() { } State = 383; _localctx.tail = dottedNamePart(); - Actions.AddDottedNamePart(_localctx, _localctx.tail.Value); + Actions.AddDottedNamePart(_localctx.Builder, _localctx.tail.Value); } } break; @@ -422,7 +426,7 @@ public DottedNameContext dottedName() { { State = 386; _localctx.quoted = Match(SQSTRING); - Actions.AddDottedNameToken(_localctx, _localctx.quoted); + Actions.AddDottedNameToken(_localctx.Builder, _localctx.quoted); } break; } @@ -433,7 +437,7 @@ public DottedNameContext dottedName() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndDottedName(_localctx); + _localctx.Value = Actions.EndDottedName(_localctx.Builder); ExitRule(); } return _localctx; @@ -457,6 +461,7 @@ public DottedNamePartContext(ParserRuleContext parent, int invokingState) public DottedNamePartContext dottedNamePart() { DottedNamePartContext _localctx = new DottedNamePartContext(Context, State); EnterRule(_localctx, 4, RULE_dottedNamePart); + _localctx.Value = string.Empty; int _la; try { EnterOuterAlt(_localctx, 1); @@ -487,6 +492,7 @@ public DottedNamePartContext dottedNamePart() { public partial class CompQstringContext : ParserRuleContext { public string Value; + public System.Text.StringBuilder Builder; public IToken head; public IToken tail; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] QSTRING() { return GetTokens(CILParser.QSTRING); } @@ -508,7 +514,7 @@ public CompQstringContext(ParserRuleContext parent, int invokingState) public CompQstringContext compQstring() { CompQstringContext _localctx = new CompQstringContext(Context, State); EnterRule(_localctx, 6, RULE_compQstring); - Actions.BeginComposedString(_localctx); + _localctx.Builder = new System.Text.StringBuilder(); try { int _alt; EnterOuterAlt(_localctx, 1); @@ -522,7 +528,7 @@ public CompQstringContext compQstring() { { State = 392; _localctx.head = Match(QSTRING); - Actions.AddComposedStringPart(_localctx, _localctx.head); + Actions.AddComposedStringPart(_localctx.Builder, _localctx.head); State = 394; Match(PLUS); } @@ -534,7 +540,7 @@ public CompQstringContext compQstring() { } State = 400; _localctx.tail = Match(QSTRING); - Actions.AddComposedStringPart(_localctx, _localctx.tail); + Actions.AddComposedStringPart(_localctx.Builder, _localctx.tail); } } catch (RecognitionException re) { @@ -543,7 +549,7 @@ public CompQstringContext compQstring() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndComposedString(_localctx); + _localctx.Value = Actions.EndComposedString(_localctx.Builder); ExitRule(); } return _localctx; @@ -1151,8 +1157,9 @@ public StackreserveContext stackreserve() { } public partial class AssemblyBlockContext : ParserRuleContext { - public object Value; + public CILParser.AssemblyDefinitionValue? Value; public bool HasSyntaxError; + public int InitialSyntaxErrorCount; public AsmAttrContext attributes; public DottedNameContext name; public AssemblyDeclsContext declarations; @@ -1176,7 +1183,7 @@ public AssemblyBlockContext(ParserRuleContext parent, int invokingState) public AssemblyBlockContext assemblyBlock() { AssemblyBlockContext _localctx = new AssemblyBlockContext(Context, State); EnterRule(_localctx, 22, RULE_assemblyBlock); - Actions.BeginSemanticRoot(_localctx); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; try { EnterOuterAlt(_localctx, 1); { @@ -1204,7 +1211,15 @@ public AssemblyBlockContext assemblyBlock() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); + + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; + if (_localctx.HasSyntaxError) + { + _localctx.Value = null; + } + ExitRule(); } return _localctx; @@ -1241,8 +1256,9 @@ public MscorlibContext mscorlib() { } public partial class LanguageDeclContext : ParserRuleContext { - public object Value; + public CILParser.LanguageDirectiveValue? Value; public bool HasSyntaxError; + public int InitialSyntaxErrorCount; public LanguageStringContext language; public LanguageStringContext vendor; public LanguageStringContext documentType; @@ -1263,7 +1279,7 @@ public LanguageDeclContext(ParserRuleContext parent, int invokingState) public LanguageDeclContext languageDecl() { LanguageDeclContext _localctx = new LanguageDeclContext(Context, State); EnterRule(_localctx, 26, RULE_languageDecl); - Actions.BeginSemanticRoot(_localctx); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; try { State = 546; ErrorHandler.Sync(this); @@ -1318,7 +1334,7 @@ public LanguageDeclContext languageDecl() { ErrorHandler.Recover(this, re); } finally { - Actions.EndLanguageDirective(_localctx); + Actions.EndLanguageDirective(_localctx, _localctx.InitialSyntaxErrorCount); ExitRule(); } return _localctx; @@ -1339,6 +1355,7 @@ public LanguageStringContext(ParserRuleContext parent, int invokingState) public LanguageStringContext languageString() { LanguageStringContext _localctx = new LanguageStringContext(Context, State); EnterRule(_localctx, 28, RULE_languageString); + _localctx.Value = string.Empty; int _la; try { EnterOuterAlt(_localctx, 1); @@ -1764,8 +1781,9 @@ public CompControlContext compControl() { } public partial class TypedefDeclContext : ParserRuleContext { - public object Value; + public CILParser.TypedefDeclarationValue Value; public bool HasSyntaxError; + public int InitialSyntaxErrorCount; public TypeContext signature; public DottedNameContext alias; public ClassNameContext classType; @@ -1801,7 +1819,10 @@ public TypedefDeclContext(ParserRuleContext parent, int invokingState) public TypedefDeclContext typedefDecl() { TypedefDeclContext _localctx = new TypedefDeclContext(Context, State); EnterRule(_localctx, 42, RULE_typedefDecl); - Actions.BeginSemanticRoot(_localctx); + + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.TypedefDeclarationValue.Error; + try { State = 644; ErrorHandler.Sync(this); @@ -1890,15 +1911,20 @@ public TypedefDeclContext typedefDecl() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); + + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; + ExitRule(); } return _localctx; } public partial class CustomDescrContext : ParserRuleContext { - public object Value; + public CILParser.CustomAttributeDescriptorValue Value; public bool HasSyntaxError; + public int InitialSyntaxErrorCount; public CustomTypeContext constructor; public CompQstringContext stringValue; public CustomBlobDescrContext structuredValue; @@ -1926,7 +1952,10 @@ public CustomDescrContext(ParserRuleContext parent, int invokingState) public CustomDescrContext customDescr() { CustomDescrContext _localctx = new CustomDescrContext(Context, State); EnterRule(_localctx, 44, RULE_customDescr); - Actions.BeginSemanticRoot(_localctx); + + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.CustomAttributeDescriptorValue.Error; + try { State = 672; ErrorHandler.Sync(this); @@ -1999,15 +2028,20 @@ public CustomDescrContext customDescr() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); + + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; + ExitRule(); } return _localctx; } public partial class CustomDescrWithOwnerContext : ParserRuleContext { - public object Value; + public CILParser.CustomAttributeDescriptorValue Value; public bool HasSyntaxError; + public int InitialSyntaxErrorCount; public OwnerTypeContext owner; public CustomTypeContext constructor; public CompQstringContext stringValue; @@ -2039,7 +2073,10 @@ public CustomDescrWithOwnerContext(ParserRuleContext parent, int invokingState) public CustomDescrWithOwnerContext customDescrWithOwner() { CustomDescrWithOwnerContext _localctx = new CustomDescrWithOwnerContext(Context, State); EnterRule(_localctx, 46, RULE_customDescrWithOwner); - Actions.BeginSemanticRoot(_localctx); + + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.CustomAttributeDescriptorValue.Error; + try { State = 712; ErrorHandler.Sync(this); @@ -2136,14 +2173,18 @@ public CustomDescrWithOwnerContext customDescrWithOwner() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); + + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; + ExitRule(); } return _localctx; } public partial class CustomTypeContext : ParserRuleContext { - public object Value; + public CILParser.MethodReferenceValue Value; public MethodRefContext constructor; [System.Diagnostics.DebuggerNonUserCode] public MethodRefContext methodRef() { return GetRuleContext(0); @@ -2159,6 +2200,7 @@ public CustomTypeContext(ParserRuleContext parent, int invokingState) public CustomTypeContext customType() { CustomTypeContext _localctx = new CustomTypeContext(Context, State); EnterRule(_localctx, 48, RULE_customType); + _localctx.Value = CILParser.MethodReferenceValue.Error; try { EnterOuterAlt(_localctx, 1); { @@ -2179,8 +2221,9 @@ public CustomTypeContext customType() { } public partial class OwnerTypeContext : ParserRuleContext { - public object Value; + public CILParser.OwnerTypeValue Value; public bool HasSyntaxError; + public int InitialSyntaxErrorCount; public TypeSpecContext typeValue; public MemberRefContext member; [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() { @@ -2200,7 +2243,10 @@ public OwnerTypeContext(ParserRuleContext parent, int invokingState) public OwnerTypeContext ownerType() { OwnerTypeContext _localctx = new OwnerTypeContext(Context, State); EnterRule(_localctx, 50, RULE_ownerType); - Actions.BeginSemanticRoot(_localctx); + + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.OwnerTypeValue.Error; + try { State = 723; ErrorHandler.Sync(this); @@ -2229,14 +2275,18 @@ public OwnerTypeContext ownerType() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); + + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; + ExitRule(); } return _localctx; } public partial class CustomBlobDescrContext : ParserRuleContext { - public object Value; + public CILParser.CustomAttributeBlobValue Value; public CustomBlobArgsContext arguments; public CustomBlobNVPairsContext namedArguments; [System.Diagnostics.DebuggerNonUserCode] public CustomBlobArgsContext customBlobArgs() { @@ -2256,6 +2306,7 @@ public CustomBlobDescrContext(ParserRuleContext parent, int invokingState) public CustomBlobDescrContext customBlobDescr() { CustomBlobDescrContext _localctx = new CustomBlobDescrContext(Context, State); EnterRule(_localctx, 52, RULE_customBlobDescr); + _localctx.Value = CILParser.CustomAttributeBlobValue.Error; try { EnterOuterAlt(_localctx, 1); { @@ -2278,7 +2329,8 @@ public CustomBlobDescrContext customBlobDescr() { } public partial class CustomBlobArgsContext : ParserRuleContext { - public object Value; + public System.Collections.Immutable.ImmutableArray Value; + public System.Collections.Immutable.ImmutableArray.Builder Builder; public SerInitContext argument; [System.Diagnostics.DebuggerNonUserCode] public CompControlContext[] compControl() { return GetRuleContexts(); @@ -2303,7 +2355,7 @@ public CustomBlobArgsContext(ParserRuleContext parent, int invokingState) public CustomBlobArgsContext customBlobArgs() { CustomBlobArgsContext _localctx = new CustomBlobArgsContext(Context, State); EnterRule(_localctx, 54, RULE_customBlobArgs); - Actions.BeginCustomBlobArguments(_localctx); + _localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder(); try { int _alt; EnterOuterAlt(_localctx, 1); @@ -2336,7 +2388,7 @@ public CustomBlobArgsContext customBlobArgs() { { State = 729; _localctx.argument = serInit(); - Actions.AddCustomBlobArgument(_localctx, _localctx.argument.Value); + _localctx.Builder.Add(_localctx.argument.Value); } break; case T__31: @@ -2369,14 +2421,15 @@ public CustomBlobArgsContext customBlobArgs() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndCustomBlobArguments(_localctx); + _localctx.Value = _localctx.Builder.ToImmutable(); ExitRule(); } return _localctx; } public partial class CustomBlobNVPairsContext : ParserRuleContext { - public object Value; + public System.Collections.Immutable.ImmutableArray Value; + public System.Collections.Immutable.ImmutableArray.Builder Builder; public FieldOrPropContext kind; public SerializTypeContext argumentType; public DottedNameContext name; @@ -2422,7 +2475,7 @@ public CustomBlobNVPairsContext(ParserRuleContext parent, int invokingState) public CustomBlobNVPairsContext customBlobNVPairs() { CustomBlobNVPairsContext _localctx = new CustomBlobNVPairsContext(Context, State); EnterRule(_localctx, 56, RULE_customBlobNVPairs); - Actions.BeginCustomBlobNamedArguments(_localctx); + _localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -2448,12 +2501,11 @@ public CustomBlobNVPairsContext customBlobNVPairs() { Match(T__35); State = 742; _localctx.value = serInit(); - Actions.AddCustomBlobNamedArgument( - _localctx, + _localctx.Builder.Add(Actions.CreateCustomBlobNamedArgument( _localctx.kind.Value, _localctx.argumentType.Value, _localctx.name.Value, - _localctx.value.Value); + _localctx.value.Value)); } break; case T__31: @@ -2485,7 +2537,7 @@ public CustomBlobNVPairsContext customBlobNVPairs() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndCustomBlobNamedArguments(_localctx); + _localctx.Value = _localctx.Builder.ToImmutable(); ExitRule(); } return _localctx; @@ -2534,7 +2586,7 @@ public FieldOrPropContext fieldOrProp() { } public partial class SerializTypeContext : ParserRuleContext { - public object Value; + public CILParser.SerializationTypeValue Value; public SerializTypeElementContext element; public IToken array; [System.Diagnostics.DebuggerNonUserCode] public SerializTypeElementContext serializTypeElement() { @@ -2552,6 +2604,7 @@ public SerializTypeContext(ParserRuleContext parent, int invokingState) public SerializTypeContext serializType() { SerializTypeContext _localctx = new SerializTypeContext(Context, State); EnterRule(_localctx, 60, RULE_serializType); + _localctx.Value = CILParser.SerializationTypeValue.Error; int _la; try { EnterOuterAlt(_localctx, 1); @@ -2583,7 +2636,7 @@ public SerializTypeContext serializType() { } public partial class SerializTypeElementContext : ParserRuleContext { - public object Value; + public CILParser.SerializationTypeValue Value; public SimpleTypeContext primitive; public DottedNameContext alias; public IToken simpleTypeToken; @@ -2613,6 +2666,7 @@ public SerializTypeElementContext(ParserRuleContext parent, int invokingState) public SerializTypeElementContext serializTypeElement() { SerializTypeElementContext _localctx = new SerializTypeElementContext(Context, State); EnterRule(_localctx, 62, RULE_serializTypeElement); + _localctx.Value = CILParser.SerializationTypeValue.Error; try { State = 778; ErrorHandler.Sync(this); @@ -2685,7 +2739,7 @@ public SerializTypeElementContext serializTypeElement() { } public partial class ModuleHeadContext : ParserRuleContext { - public string Value; + public string? Value; public bool HasName; public bool IsExternal; public DottedNameContext name; @@ -2704,6 +2758,7 @@ public ModuleHeadContext(ParserRuleContext parent, int invokingState) public ModuleHeadContext moduleHead() { ModuleHeadContext _localctx = new ModuleHeadContext(Context, State); EnterRule(_localctx, 64, RULE_moduleHead); + _localctx.Value = null; try { State = 791; ErrorHandler.Sync(this); @@ -2752,8 +2807,9 @@ public ModuleHeadContext moduleHead() { } public partial class VtfixupDeclContext : ParserRuleContext { - public object Value; + public CILParser.VTableFixupValue? Value; public bool HasSyntaxError; + public int InitialSyntaxErrorCount; public Int32Context count; public VtfixupAttrContext attributes; public IdContext label; @@ -2777,7 +2833,7 @@ public VtfixupDeclContext(ParserRuleContext parent, int invokingState) public VtfixupDeclContext vtfixupDecl() { VtfixupDeclContext _localctx = new VtfixupDeclContext(Context, State); EnterRule(_localctx, 66, RULE_vtfixupDecl); - Actions.BeginSemanticRoot(_localctx); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; try { EnterOuterAlt(_localctx, 1); { @@ -2807,7 +2863,15 @@ public VtfixupDeclContext vtfixupDecl() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); + + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; + if (_localctx.HasSyntaxError) + { + _localctx.Value = null; + } + ExitRule(); } return _localctx; @@ -2911,8 +2975,9 @@ public VtfixupAttrElementContext vtfixupAttrElement() { } public partial class VtableDeclContext : ParserRuleContext { - public object Value; + public CILParser.RawVTableValue? Value; public bool HasSyntaxError; + public int InitialSyntaxErrorCount; public BytesContext value; [System.Diagnostics.DebuggerNonUserCode] public BytesContext bytes() { return GetRuleContext(0); @@ -2928,7 +2993,7 @@ public VtableDeclContext(ParserRuleContext parent, int invokingState) public VtableDeclContext vtableDecl() { VtableDeclContext _localctx = new VtableDeclContext(Context, State); EnterRule(_localctx, 72, RULE_vtableDecl); - Actions.BeginSemanticRoot(_localctx); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; try { EnterOuterAlt(_localctx, 1); { @@ -2951,7 +3016,15 @@ public VtableDeclContext vtableDecl() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); + + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; + if (_localctx.HasSyntaxError) + { + _localctx.Value = null; + } + ExitRule(); } return _localctx; @@ -2959,6 +3032,7 @@ public VtableDeclContext vtableDecl() { public partial class NameSpaceHeadContext : ParserRuleContext { public string Value; + public int InitialSyntaxErrorCount; public DottedNameContext name; [System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() { return GetRuleContext(0); @@ -2974,7 +3048,11 @@ public NameSpaceHeadContext(ParserRuleContext parent, int invokingState) public NameSpaceHeadContext nameSpaceHead() { NameSpaceHeadContext _localctx = new NameSpaceHeadContext(Context, State); EnterRule(_localctx, 74, RULE_nameSpaceHead); - Actions.BeginNamespaceHeader(_localctx); + + Actions.PrepareNamespaceHeader(); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = string.Empty; + try { EnterOuterAlt(_localctx, 1); { @@ -2985,7 +3063,7 @@ public NameSpaceHeadContext nameSpaceHead() { _localctx.Value = _localctx.name.Value; } Context.Stop = TokenStream.LT(-1); - Actions.BeginNamespace(_localctx, _localctx.Value); + Actions.BeginNamespace(_localctx, _localctx.Value, _localctx.InitialSyntaxErrorCount); } catch (RecognitionException re) { _localctx.exception = re; @@ -2993,14 +3071,15 @@ public NameSpaceHeadContext nameSpaceHead() { ErrorHandler.Recover(this, re); } finally { - Actions.EndNamespaceHeader(_localctx); ExitRule(); } return _localctx; } public partial class ClassHeadContext : ParserRuleContext { - public object Value; + public CILParser.ClassHeaderValue Value; + public int InitialSyntaxErrorCount; + public CILParser.ClassHeaderBuilder Builder; public ClassAttrContext attribute; public DottedNameContext name; public TyparsClauseContext genericParameters; @@ -3035,7 +3114,11 @@ public ClassHeadContext(ParserRuleContext parent, int invokingState) public ClassHeadContext classHead() { ClassHeadContext _localctx = new ClassHeadContext(Context, State); EnterRule(_localctx, 76, RULE_classHead); - Actions.BeginClassHeader(_localctx); + + _localctx.Builder = Actions.PrepareClassHeader(); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.ClassHeaderValue.Error; + try { int _alt; EnterOuterAlt(_localctx, 1); @@ -3051,7 +3134,7 @@ public ClassHeadContext classHead() { { State = 826; _localctx.attribute = classAttr(); - Actions.AddClassHeaderAttribute(_localctx, _localctx.attribute.Value); + Actions.AddClassHeaderAttribute(_localctx.Builder, _localctx.attribute.Value); } } } @@ -3069,6 +3152,8 @@ public ClassHeadContext classHead() { _localctx.interfaces = implClause(); _localctx.Value = Actions.CreateClassHeader( _localctx, + _localctx.Builder, + _localctx.InitialSyntaxErrorCount, (_localctx.name!=null?(_localctx.name.Stop):null), _localctx.name.Value, _localctx.genericParameters.Value, @@ -3084,14 +3169,13 @@ public ClassHeadContext classHead() { ErrorHandler.Recover(this, re); } finally { - Actions.EndClassHeader(_localctx); ExitRule(); } return _localctx; } public partial class ClassAttrContext : ParserRuleContext { - public object Value; + public CILParser.ClassAttributeValue Value; public IToken attribute; public IToken visibility; public Int32Context flags; @@ -3114,6 +3198,7 @@ public ClassAttrContext(ParserRuleContext parent, int invokingState) public ClassAttrContext classAttr() { ClassAttrContext _localctx = new ClassAttrContext(Context, State); EnterRule(_localctx, 78, RULE_classAttr); + _localctx.Value = CILParser.ClassAttributeValue.Empty; try { State = 904; ErrorHandler.Sync(this); @@ -3366,7 +3451,7 @@ public ClassAttrContext classAttr() { } public partial class ExtendsClauseContext : ParserRuleContext { - public object Value; + public CILParser.TypeSpecificationValue? Value; public TypeSpecContext baseType; [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() { return GetRuleContext(0); @@ -3419,7 +3504,7 @@ public ExtendsClauseContext extendsClause() { } public partial class ImplClauseContext : ParserRuleContext { - public object Value; + public System.Collections.Immutable.ImmutableArray Value; public ImplListContext interfaces; [System.Diagnostics.DebuggerNonUserCode] public ImplListContext implList() { return GetRuleContext(0); @@ -3520,7 +3605,8 @@ public ClassDeclsContext classDecls() { } public partial class ImplListContext : ParserRuleContext { - public object Value; + public System.Collections.Immutable.ImmutableArray Value; + public System.Collections.Immutable.ImmutableArray.Builder Builder; public TypeSpecContext interfaceType; public TypeSpecContext lastInterfaceType; [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext[] typeSpec() { @@ -3540,7 +3626,7 @@ public ImplListContext(ParserRuleContext parent, int invokingState) public ImplListContext implList() { ImplListContext _localctx = new ImplListContext(Context, State); EnterRule(_localctx, 86, RULE_implList); - Actions.BeginInterfaceList(_localctx); + _localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder(); try { int _alt; EnterOuterAlt(_localctx, 1); @@ -3554,7 +3640,7 @@ public ImplListContext implList() { { State = 926; _localctx.interfaceType = typeSpec(); - Actions.AddInterfaceType(_localctx, _localctx.interfaceType.Value); + _localctx.Builder.Add(_localctx.interfaceType.Value); State = 928; Match(T__27); } @@ -3566,7 +3652,7 @@ public ImplListContext implList() { } State = 935; _localctx.lastInterfaceType = typeSpec(); - Actions.AddInterfaceType(_localctx, _localctx.lastInterfaceType.Value); + _localctx.Builder.Add(_localctx.lastInterfaceType.Value); } } catch (RecognitionException re) { @@ -3575,7 +3661,7 @@ public ImplListContext implList() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndInterfaceList(_localctx); + _localctx.Value = _localctx.Builder.ToImmutable(); ExitRule(); } return _localctx; @@ -3623,8 +3709,9 @@ public EsHeadContext esHead() { } public partial class ExtSourceSpecContext : ParserRuleContext { - public object Value; + public CILParser.SourceDirectiveValue? Value; public bool HasSyntaxError; + public int InitialSyntaxErrorCount; public EsHeadContext head; public Int32Context line; public IToken path; @@ -3655,7 +3742,7 @@ public ExtSourceSpecContext(ParserRuleContext parent, int invokingState) public ExtSourceSpecContext extSourceSpec() { ExtSourceSpecContext _localctx = new ExtSourceSpecContext(Context, State); EnterRule(_localctx, 90, RULE_extSourceSpec); - Actions.BeginSemanticRoot(_localctx); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; int _la; try { State = 991; @@ -3857,15 +3944,17 @@ public ExtSourceSpecContext extSourceSpec() { ErrorHandler.Recover(this, re); } finally { - Actions.EndSourceDirective(_localctx); + Actions.EndSourceDirective(_localctx, _localctx.InitialSyntaxErrorCount); ExitRule(); } return _localctx; } public partial class FileDeclContext : ParserRuleContext { - public object Value; + public CILParser.FileDeclarationValue? Value; public bool HasSyntaxError; + public int InitialSyntaxErrorCount; + public CILParser.FileDeclarationBuilder Builder; public FileAttrContext attribute; public DottedNameContext name; public FileEntryContext entry; @@ -3901,7 +3990,10 @@ public FileDeclContext(ParserRuleContext parent, int invokingState) public FileDeclContext fileDecl() { FileDeclContext _localctx = new FileDeclContext(Context, State); EnterRule(_localctx, 92, RULE_fileDecl); - Actions.BeginFileDeclaration(_localctx); + + _localctx.Builder = new CILParser.FileDeclarationBuilder(); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + int _la; try { EnterOuterAlt(_localctx, 1); @@ -3916,7 +4008,7 @@ public FileDeclContext fileDecl() { { State = 994; _localctx.attribute = fileAttr(); - Actions.AddFileAttribute(_localctx, _localctx.attribute.Value); + Actions.AddFileAttribute(_localctx.Builder, _localctx.attribute.Value); } } State = 1001; @@ -3925,10 +4017,10 @@ public FileDeclContext fileDecl() { } State = 1002; _localctx.name = dottedName(); - Actions.SetFileName(_localctx, _localctx.name.Value); + Actions.SetFileName(_localctx.Builder, _localctx.name.Value); State = 1004; _localctx.entry = fileEntry(); - Actions.AddFileEntry(_localctx, _localctx.entry.Value); + Actions.AddFileEntry(_localctx.Builder, _localctx.entry.Value); State = 1015; ErrorHandler.Sync(this); _la = TokenStream.LA(1); @@ -3944,10 +4036,10 @@ public FileDeclContext fileDecl() { _localctx.hash = bytes(); State = 1010; Match(T__30); - Actions.SetFileHash(_localctx, _localctx.hash.Value); + Actions.SetFileHash(_localctx.Builder, _localctx.hash.Value); State = 1012; _localctx.trailingEntry = fileEntry(); - Actions.AddFileEntry(_localctx, _localctx.trailingEntry.Value); + Actions.AddFileEntry(_localctx.Builder, _localctx.trailingEntry.Value); } } @@ -3959,7 +4051,7 @@ public FileDeclContext fileDecl() { ErrorHandler.Recover(this, re); } finally { - Actions.EndFileDeclaration(_localctx); + Actions.EndFileDeclaration(_localctx, _localctx.Builder, _localctx.InitialSyntaxErrorCount); ExitRule(); } return _localctx; @@ -4313,6 +4405,7 @@ public InstrContext instr() { } public partial class SimpleInstrContext : ParserRuleContext { + public CILParser.SwitchInstructionBuilder SwitchBuilder; public IToken op; public Int32Context index; public IdContext name; @@ -4548,7 +4641,7 @@ public SimpleInstrContext simpleInstr() { { State = 1130; _localctx.op = Match(INSTR_SWITCH); - Actions.BeginSwitchInstruction(_localctx, _localctx.op); + _localctx.SwitchBuilder = Actions.CreateSwitchInstruction(_localctx.op); State = 1137; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { @@ -4557,7 +4650,7 @@ public SimpleInstrContext simpleInstr() { State = 1132; Match(T__29); State = 1133; - labels(); + labels(_localctx.SwitchBuilder); State = 1134; Match(T__30); } @@ -4575,7 +4668,7 @@ public SimpleInstrContext simpleInstr() { break; } Context.Stop = TokenStream.LT(-1); - Actions.CompleteSimpleInstruction(_localctx); + Actions.CompleteSwitchInstruction(_localctx.SwitchBuilder); } catch (RecognitionException re) { _localctx.exception = re; @@ -4583,15 +4676,15 @@ public SimpleInstrContext simpleInstr() { ErrorHandler.Recover(this, re); } finally { - Actions.EndSwitchInstruction(_localctx); ExitRule(); } return _localctx; } public partial class CalliSignatureContext : ParserRuleContext { - public object Value; + public CILParser.CalliSignatureValue Value; public bool HasSyntaxError; + public int InitialSyntaxErrorCount; public CallConvContext convention; public TypeContext returnType; public SigArgsContext arguments; @@ -4615,7 +4708,10 @@ public CalliSignatureContext(ParserRuleContext parent, int invokingState) public CalliSignatureContext calliSignature() { CalliSignatureContext _localctx = new CalliSignatureContext(Context, State); EnterRule(_localctx, 106, RULE_calliSignature); - Actions.BeginSemanticRoot(_localctx); + + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.CalliSignatureValue.Error; + try { EnterOuterAlt(_localctx, 1); { @@ -4634,13 +4730,18 @@ public CalliSignatureContext calliSignature() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); + + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; + ExitRule(); } return _localctx; } public partial class LabelsContext : ParserRuleContext { + public CILParser.SwitchInstructionBuilder Builder; public IdContext headLabel; public Int32Context headOffset; public IdContext tailLabel; @@ -4657,16 +4758,18 @@ [System.Diagnostics.DebuggerNonUserCode] public Int32Context[] int32() { [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32(int i) { return GetRuleContext(i); } - public LabelsContext(ParserRuleContext parent, int invokingState) + public LabelsContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { } + public LabelsContext(ParserRuleContext parent, int invokingState, CILParser.SwitchInstructionBuilder Builder) : base(parent, invokingState) { + this.Builder = Builder; } public override int RuleIndex { get { return RULE_labels; } } } [RuleVersion(0)] - public LabelsContext labels() { - LabelsContext _localctx = new LabelsContext(Context, State); + public LabelsContext labels(CILParser.SwitchInstructionBuilder Builder) { + LabelsContext _localctx = new LabelsContext(Context, State, Builder); EnterRule(_localctx, 108, RULE_labels); try { int _alt; @@ -4734,14 +4837,14 @@ public LabelsContext labels() { { State = 1147; _localctx.headLabel = id(); - Actions.AddSwitchLabel((_localctx.headLabel!=null?(_localctx.headLabel.Start):null)); + Actions.AddSwitchLabel(_localctx.Builder, (_localctx.headLabel!=null?(_localctx.headLabel.Start):null)); } break; case INT32: { State = 1150; _localctx.headOffset = int32(); - Actions.AddSwitchOffset((_localctx.headOffset!=null?(_localctx.headOffset.Start):null)); + Actions.AddSwitchOffset(_localctx.Builder, (_localctx.headOffset!=null?(_localctx.headOffset.Start):null)); } break; default: @@ -4782,14 +4885,14 @@ public LabelsContext labels() { { State = 1162; _localctx.tailLabel = id(); - Actions.AddSwitchLabel((_localctx.tailLabel!=null?(_localctx.tailLabel.Start):null)); + Actions.AddSwitchLabel(_localctx.Builder, (_localctx.tailLabel!=null?(_localctx.tailLabel.Start):null)); } break; case INT32: { State = 1165; _localctx.tailOffset = int32(); - Actions.AddSwitchOffset((_localctx.tailOffset!=null?(_localctx.tailOffset.Start):null)); + Actions.AddSwitchOffset(_localctx.Builder, (_localctx.tailOffset!=null?(_localctx.tailOffset.Start):null)); } break; default: @@ -4813,7 +4916,8 @@ public LabelsContext labels() { } public partial class TypeArgsContext : ParserRuleContext { - public object Value; + public System.Collections.Immutable.ImmutableArray Value; + public System.Collections.Immutable.ImmutableArray.Builder Builder; public TypeContext argument; public TypeContext lastArgument; [System.Diagnostics.DebuggerNonUserCode] public TypeContext[] type() { @@ -4833,7 +4937,7 @@ public TypeArgsContext(ParserRuleContext parent, int invokingState) public TypeArgsContext typeArgs() { TypeArgsContext _localctx = new TypeArgsContext(Context, State); EnterRule(_localctx, 110, RULE_typeArgs); - Actions.BeginTypeArguments(_localctx); + _localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder(); try { int _alt; EnterOuterAlt(_localctx, 1); @@ -4849,7 +4953,7 @@ public TypeArgsContext typeArgs() { { State = 1173; _localctx.argument = type(); - Actions.AddTypeArgument(_localctx, _localctx.argument.Value); + _localctx.Builder.Add(_localctx.argument.Value); State = 1175; Match(T__27); } @@ -4861,7 +4965,7 @@ public TypeArgsContext typeArgs() { } State = 1182; _localctx.lastArgument = type(); - Actions.AddTypeArgument(_localctx, _localctx.lastArgument.Value); + _localctx.Builder.Add(_localctx.lastArgument.Value); State = 1184; Match(T__86); } @@ -4872,14 +4976,15 @@ public TypeArgsContext typeArgs() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndTypeArguments(_localctx); + _localctx.Value = _localctx.Builder.ToImmutable(); ExitRule(); } return _localctx; } public partial class BoundsContext : ParserRuleContext { - public object Value; + public System.Collections.Immutable.ImmutableArray Value; + public System.Collections.Immutable.ImmutableArray.Builder Builder; public BoundContext item; public BoundContext lastItem; [System.Diagnostics.DebuggerNonUserCode] public BoundContext[] bound() { @@ -4899,7 +5004,7 @@ public BoundsContext(ParserRuleContext parent, int invokingState) public BoundsContext bounds() { BoundsContext _localctx = new BoundsContext(Context, State); EnterRule(_localctx, 112, RULE_bounds); - Actions.BeginBounds(_localctx); + _localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder(); try { int _alt; EnterOuterAlt(_localctx, 1); @@ -4915,7 +5020,7 @@ public BoundsContext bounds() { { State = 1187; _localctx.item = bound(); - Actions.AddBound(_localctx, _localctx.item); + _localctx.Builder.Add(Actions.CreateArrayBound(_localctx.item)); State = 1189; Match(T__27); } @@ -4927,7 +5032,7 @@ public BoundsContext bounds() { } State = 1196; _localctx.lastItem = bound(); - Actions.AddBound(_localctx, _localctx.lastItem); + _localctx.Builder.Add(Actions.CreateArrayBound(_localctx.lastItem)); State = 1198; Match(T__42); } @@ -4938,14 +5043,15 @@ public BoundsContext bounds() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndBounds(_localctx); + _localctx.Value = _localctx.Builder.ToImmutable(); ExitRule(); } return _localctx; } public partial class SigArgsContext : ParserRuleContext { - public object Value; + public System.Collections.Immutable.ImmutableArray Value; + public System.Collections.Immutable.ImmutableArray.Builder Builder; public SigArgContext argument; public SigArgContext lastArgument; [System.Diagnostics.DebuggerNonUserCode] public SigArgContext[] sigArg() { @@ -4965,7 +5071,7 @@ public SigArgsContext(ParserRuleContext parent, int invokingState) public SigArgsContext sigArgs() { SigArgsContext _localctx = new SigArgsContext(Context, State); EnterRule(_localctx, 114, RULE_sigArgs); - Actions.BeginSignatureArguments(_localctx); + _localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder(); try { int _alt; State = 1215; @@ -4985,7 +5091,7 @@ public SigArgsContext sigArgs() { { State = 1201; _localctx.argument = sigArg(); - Actions.AddSignatureArgument(_localctx, _localctx.argument.Value); + _localctx.Builder.Add(_localctx.argument.Value); State = 1203; Match(T__27); } @@ -4997,7 +5103,7 @@ public SigArgsContext sigArgs() { } State = 1210; _localctx.lastArgument = sigArg(); - Actions.AddSignatureArgument(_localctx, _localctx.lastArgument.Value); + _localctx.Builder.Add(_localctx.lastArgument.Value); State = 1212; Match(T__30); } @@ -5019,14 +5125,14 @@ public SigArgsContext sigArgs() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndSignatureArguments(_localctx); + _localctx.Value = _localctx.Builder.ToImmutable(); ExitRule(); } return _localctx; } public partial class SigArgContext : ParserRuleContext { - public object Value; + public CILParser.SignatureArgumentValue Value; public ParamAttrContext attributes; public TypeContext argumentType; public MarshalClauseContext marshalling; @@ -5055,6 +5161,7 @@ public SigArgContext(ParserRuleContext parent, int invokingState) public SigArgContext sigArg() { SigArgContext _localctx = new SigArgContext(Context, State); EnterRule(_localctx, 116, RULE_sigArg); + _localctx.Value = CILParser.SignatureArgumentValue.Error; int _la; try { State = 1227; @@ -5104,7 +5211,7 @@ public SigArgContext sigArg() { } public partial class ClassNameContext : ParserRuleContext { - public object Value; + public CILParser.ClassNameValue Value; public DottedNameContext assemblyName; public SlashedNameContext typeName; public MdtokenContext scopeToken; @@ -5135,6 +5242,7 @@ public ClassNameContext(ParserRuleContext parent, int invokingState) public ClassNameContext className() { ClassNameContext _localctx = new ClassNameContext(Context, State); EnterRule(_localctx, 118, RULE_className); + _localctx.Value = CILParser.ClassNameValue.Error; try { State = 1266; ErrorHandler.Sync(this); @@ -5251,7 +5359,8 @@ public ClassNameContext className() { } public partial class SlashedNameContext : ParserRuleContext { - public object Value; + public CILParser.TypeName Value; + public CILParser.TypeName CurrentName; public DottedNameContext part; public DottedNameContext lastPart; [System.Diagnostics.DebuggerNonUserCode] public DottedNameContext[] dottedName() { @@ -5271,7 +5380,6 @@ public SlashedNameContext(ParserRuleContext parent, int invokingState) public SlashedNameContext slashedName() { SlashedNameContext _localctx = new SlashedNameContext(Context, State); EnterRule(_localctx, 120, RULE_slashedName); - Actions.BeginSlashedName(_localctx); try { int _alt; EnterOuterAlt(_localctx, 1); @@ -5285,7 +5393,7 @@ public SlashedNameContext slashedName() { { State = 1268; _localctx.part = dottedName(); - Actions.AddSlashedNamePart(_localctx, _localctx.part.Value); + _localctx.CurrentName = Actions.AddSlashedNamePart(_localctx.CurrentName, _localctx.part.Value); State = 1270; Match(T__87); } @@ -5297,7 +5405,7 @@ public SlashedNameContext slashedName() { } State = 1277; _localctx.lastPart = dottedName(); - Actions.AddSlashedNamePart(_localctx, _localctx.lastPart.Value); + _localctx.CurrentName = Actions.AddSlashedNamePart(_localctx.CurrentName, _localctx.lastPart.Value); } } catch (RecognitionException re) { @@ -5306,14 +5414,15 @@ public SlashedNameContext slashedName() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndSlashedName(_localctx); + _localctx.Value = _localctx.CurrentName ?? new CILParser.TypeName(null, string.Empty); ExitRule(); } return _localctx; } public partial class AssemblyDeclsContext : ParserRuleContext { - public object Value; + public System.Collections.Immutable.ImmutableArray Value; + public System.Collections.Immutable.ImmutableArray.Builder Builder; public AssemblyDeclContext declaration; [System.Diagnostics.DebuggerNonUserCode] public AssemblyDeclContext[] assemblyDecl() { return GetRuleContexts(); @@ -5332,7 +5441,7 @@ public AssemblyDeclsContext(ParserRuleContext parent, int invokingState) public AssemblyDeclsContext assemblyDecls() { AssemblyDeclsContext _localctx = new AssemblyDeclsContext(Context, State); EnterRule(_localctx, 122, RULE_assemblyDecls); - Actions.BeginAssemblyDeclarations(_localctx); + _localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -5345,7 +5454,7 @@ public AssemblyDeclsContext assemblyDecls() { { State = 1280; _localctx.declaration = assemblyDecl(); - Actions.AddAssemblyDeclaration(_localctx, _localctx.declaration.Value); + if (_localctx.declaration.Value is not null) _localctx.Builder.Add(_localctx.declaration.Value); } } State = 1287; @@ -5360,14 +5469,14 @@ public AssemblyDeclsContext assemblyDecls() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndAssemblyDeclarations(_localctx); + _localctx.Value = _localctx.Builder.ToImmutable(); ExitRule(); } return _localctx; } public partial class AssemblyDeclContext : ParserRuleContext { - public object Value; + public CILParser.AssemblyDeclarationValue? Value; public Int32Context algorithm; public SecDeclContext security; public AsmOrRefDeclContext shared; @@ -5461,8 +5570,9 @@ public AssemblyDeclContext assemblyDecl() { } public partial class TypeSpecContext : ParserRuleContext { - public object Value; + public CILParser.TypeSpecificationValue Value; public bool HasSyntaxError; + public int InitialSyntaxErrorCount; public ClassNameContext classType; public DottedNameContext assemblyName; public DottedNameContext moduleName; @@ -5488,7 +5598,10 @@ public TypeSpecContext(ParserRuleContext parent, int invokingState) public TypeSpecContext typeSpec() { TypeSpecContext _localctx = new TypeSpecContext(Context, State); EnterRule(_localctx, 126, RULE_typeSpec); - Actions.BeginSemanticRoot(_localctx); + + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.TypeSpecificationValue.Error; + try { State = 1318; ErrorHandler.Sync(this); @@ -5543,14 +5656,19 @@ public TypeSpecContext typeSpec() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); + + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; + ExitRule(); } return _localctx; } public partial class NativeTypeContext : ParserRuleContext { - public object Value; + public CILParser.NativeTypeValue Value; + public CILParser.NativeTypeBuilder Builder; public NativeTypeElementContext element; public NativeTypeArrayPointerInfoContext info; [System.Diagnostics.DebuggerNonUserCode] public NativeTypeElementContext nativeTypeElement() { @@ -5573,7 +5691,7 @@ public NativeTypeContext(ParserRuleContext parent, int invokingState) public NativeTypeContext nativeType() { NativeTypeContext _localctx = new NativeTypeContext(Context, State); EnterRule(_localctx, 128, RULE_nativeType); - Actions.BeginNativeType(_localctx); + _localctx.Builder = new CILParser.NativeTypeBuilder(); try { int _alt; State = 1331; @@ -5589,7 +5707,7 @@ public NativeTypeContext nativeType() { { State = 1321; _localctx.element = nativeTypeElement(); - Actions.SetNativeTypeElement(_localctx, _localctx.element.Value); + Actions.SetNativeTypeElement(_localctx.Builder, _localctx.element.Value); State = 1328; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,56,Context); @@ -5599,7 +5717,7 @@ public NativeTypeContext nativeType() { { State = 1323; _localctx.info = nativeTypeArrayPointerInfo(); - Actions.AddNativeTypeArrayPointerInfo(_localctx, _localctx.info.Value); + Actions.AddNativeTypeArrayPointerInfo(_localctx.Builder, _localctx.info.Value); } } } @@ -5617,14 +5735,14 @@ public NativeTypeContext nativeType() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndNativeType(_localctx); + _localctx.Value = Actions.CreateNativeType(_localctx.Start, _localctx.Builder); ExitRule(); } return _localctx; } public partial class NativeTypeArrayPointerInfoContext : ParserRuleContext { - public object Value; + public CILParser.NativeTypeArrayPointerInfoValue Value; public NativeTypeArrayPointerInfoContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { @@ -5677,6 +5795,7 @@ public partial class PointerArrayTypeNoSizeDataContext : NativeTypeArrayPointerI public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { NativeTypeArrayPointerInfoContext _localctx = new NativeTypeArrayPointerInfoContext(Context, State); EnterRule(_localctx, 130, RULE_nativeTypeArrayPointerInfo); + _localctx.Value = Actions.CreatePointerNativeType(); try { State = 1355; ErrorHandler.Sync(this); @@ -5758,7 +5877,7 @@ public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() { } public partial class NativeTypeElementContext : ParserRuleContext { - public object Value; + public CILParser.NativeTypeElementValue Value; public IToken marshalType; public CompQstringContext guid; public CompQstringContext nativeTypeName; @@ -5844,6 +5963,7 @@ public NativeTypeElementContext(ParserRuleContext parent, int invokingState) public NativeTypeElementContext nativeTypeElement() { NativeTypeElementContext _localctx = new NativeTypeElementContext(Context, State); EnterRule(_localctx, 132, RULE_nativeTypeElement); + _localctx.Value = CILParser.EmptyNativeTypeElementValue.Instance; try { State = 1502; ErrorHandler.Sync(this); @@ -6329,7 +6449,7 @@ public NativeTypeElementContext nativeTypeElement() { } public partial class IidParamIndexContext : ParserRuleContext { - public object Value; + public CILParser.IidParamIndexValue Value; public Int32Context index; [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); @@ -6345,6 +6465,7 @@ public IidParamIndexContext(ParserRuleContext parent, int invokingState) public IidParamIndexContext iidParamIndex() { IidParamIndexContext _localctx = new IidParamIndexContext(Context, State); EnterRule(_localctx, 134, RULE_iidParamIndex); + _localctx.Value = CILParser.IidParamIndexValue.Empty; try { State = 1512; ErrorHandler.Sync(this); @@ -6389,7 +6510,8 @@ public IidParamIndexContext iidParamIndex() { } public partial class VariantTypeContext : ParserRuleContext { - public object Value; + public CILParser.VariantTypeValue Value; + public CILParser.VariantTypeBuilder Builder; public VariantTypeElementContext element; public IToken modifier; [System.Diagnostics.DebuggerNonUserCode] public VariantTypeElementContext variantTypeElement() { @@ -6418,7 +6540,7 @@ public VariantTypeContext(ParserRuleContext parent, int invokingState) public VariantTypeContext variantType() { VariantTypeContext _localctx = new VariantTypeContext(Context, State); EnterRule(_localctx, 136, RULE_variantType); - Actions.BeginVariantType(_localctx); + _localctx.Builder = new CILParser.VariantTypeBuilder(); int _la; try { int _alt; @@ -6435,7 +6557,7 @@ public VariantTypeContext variantType() { { State = 1515; _localctx.element = variantTypeElement(); - Actions.SetVariantTypeElement(_localctx, _localctx.element.Value); + Actions.SetVariantTypeElement(_localctx.Builder, _localctx.element.Value); State = 1521; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,61,Context); @@ -6453,7 +6575,7 @@ public VariantTypeContext variantType() { ErrorHandler.ReportMatch(this); Consume(); } - Actions.AddVariantTypeModifier(_localctx, _localctx.modifier); + Actions.AddVariantTypeModifier(_localctx.Builder, _localctx.modifier); } } } @@ -6471,14 +6593,14 @@ public VariantTypeContext variantType() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndVariantType(_localctx); + _localctx.Value = Actions.CreateVariantType(_localctx.Builder); ExitRule(); } return _localctx; } public partial class VariantTypeElementContext : ParserRuleContext { - public object Value; + public CILParser.VariantTypeElementValue Value; public IToken value; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode NULL() { return GetToken(CILParser.NULL, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VARIANT() { return GetToken(CILParser.VARIANT, 0); } @@ -6531,6 +6653,7 @@ public VariantTypeElementContext(ParserRuleContext parent, int invokingState) public VariantTypeElementContext variantTypeElement() { VariantTypeElementContext _localctx = new VariantTypeElementContext(Context, State); EnterRule(_localctx, 138, RULE_variantTypeElement); + _localctx.Value = CILParser.VariantTypeElementValue.Error; try { State = 1606; ErrorHandler.Sync(this); @@ -6871,7 +6994,9 @@ public VariantTypeElementContext variantTypeElement() { } public partial class TypeContext : ParserRuleContext { - public object Value; + public CILParser.TypeValue Value; + public CILParser.ElementTypeValue ElementType; + public System.Collections.Immutable.ImmutableArray.Builder Modifiers; public ElementTypeContext element; public TypeModifiersContext modifier; [System.Diagnostics.DebuggerNonUserCode] public ElementTypeContext elementType() { @@ -6894,14 +7019,17 @@ public TypeContext(ParserRuleContext parent, int invokingState) public TypeContext type() { TypeContext _localctx = new TypeContext(Context, State); EnterRule(_localctx, 140, RULE_type); - Actions.BeginTypeSignature(_localctx); + + _localctx.ElementType = CILParser.ElementTypeValue.Error; + _localctx.Modifiers = System.Collections.Immutable.ImmutableArray.CreateBuilder(); + try { int _alt; EnterOuterAlt(_localctx, 1); { State = 1608; _localctx.element = elementType(); - Actions.SetTypeSignatureElement(_localctx, _localctx.element.Value); + _localctx.ElementType = _localctx.element.Value; State = 1615; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,64,Context); @@ -6911,7 +7039,7 @@ public TypeContext type() { { State = 1610; _localctx.modifier = typeModifiers(); - Actions.AddTypeSignatureModifier(_localctx, _localctx.modifier.Value); + _localctx.Modifiers.Add(_localctx.modifier.Value); } } } @@ -6927,14 +7055,14 @@ public TypeContext type() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndTypeSignature(_localctx); + _localctx.Value = new CILParser.TypeValue(_localctx.ElementType, _localctx.Modifiers.ToImmutable()); ExitRule(); } return _localctx; } public partial class TypeModifiersContext : ParserRuleContext { - public object Value; + public CILParser.TypeModifierValue Value; public TypeModifiersContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { @@ -6995,6 +7123,7 @@ [System.Diagnostics.DebuggerNonUserCode] public BoundsContext bounds() { public TypeModifiersContext typeModifiers() { TypeModifiersContext _localctx = new TypeModifiersContext(Context, State); EnterRule(_localctx, 142, RULE_typeModifiers); + _localctx.Value = CILParser.TypeModifierValue.Error; try { State = 1647; ErrorHandler.Sync(this); @@ -7108,7 +7237,7 @@ public TypeModifiersContext typeModifiers() { } public partial class ElementTypeContext : ParserRuleContext { - public object Value; + public CILParser.ElementTypeValue Value; public ClassNameContext classType; public ClassNameContext valueClassType; public ClassNameContext valueType; @@ -7170,6 +7299,7 @@ public ElementTypeContext(ParserRuleContext parent, int invokingState) public ElementTypeContext elementType() { ElementTypeContext _localctx = new ElementTypeContext(Context, State); EnterRule(_localctx, 144, RULE_elementType); + _localctx.Value = CILParser.ElementTypeValue.Error; try { State = 1707; ErrorHandler.Sync(this); @@ -7705,8 +7835,9 @@ public NativeUintContext nativeUint() { } public partial class SecDeclContext : ParserRuleContext { - public object Value; + public CILParser.SecurityDeclarationValue? Value; public bool HasSyntaxError; + public int InitialSyntaxErrorCount; public SecActionContext action; public TypeSpecContext permissionType; public NameValPairsContext pairs; @@ -7748,7 +7879,7 @@ public SecDeclContext(ParserRuleContext parent, int invokingState) public SecDeclContext secDecl() { SecDeclContext _localctx = new SecDeclContext(Context, State); EnterRule(_localctx, 154, RULE_secDecl); - Actions.BeginSemanticRoot(_localctx); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; int _la; try { State = 1831; @@ -7894,14 +8025,15 @@ public SecDeclContext secDecl() { ErrorHandler.Recover(this, re); } finally { - Actions.EndSecurityDeclaration(_localctx); + Actions.EndSecurityDeclaration(_localctx, _localctx.InitialSyntaxErrorCount); ExitRule(); } return _localctx; } public partial class SecAttrSetBlobContext : ParserRuleContext { - public object Value; + public System.Collections.Immutable.ImmutableArray Value; + public System.Collections.Immutable.ImmutableArray.Builder Builder; public SecAttrBlobContext attribute; public SecAttrBlobContext tail; [System.Diagnostics.DebuggerNonUserCode] public SecAttrBlobContext[] secAttrBlob() { @@ -7921,7 +8053,7 @@ public SecAttrSetBlobContext(ParserRuleContext parent, int invokingState) public SecAttrSetBlobContext secAttrSetBlob() { SecAttrSetBlobContext _localctx = new SecAttrSetBlobContext(Context, State); EnterRule(_localctx, 156, RULE_secAttrSetBlob); - Actions.BeginSecurityAttributeSet(_localctx); + _localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder(); try { int _alt; State = 1846; @@ -7978,7 +8110,7 @@ public SecAttrSetBlobContext secAttrSetBlob() { { State = 1834; _localctx.attribute = secAttrBlob(); - Actions.AddSecurityAttribute(_localctx, _localctx.attribute.Value); + _localctx.Builder.Add(_localctx.attribute.Value); State = 1836; Match(T__27); } @@ -7990,7 +8122,7 @@ public SecAttrSetBlobContext secAttrSetBlob() { } State = 1843; _localctx.tail = secAttrBlob(); - Actions.AddSecurityAttribute(_localctx, _localctx.tail.Value); + _localctx.Builder.Add(_localctx.tail.Value); } break; default: @@ -8003,14 +8135,14 @@ public SecAttrSetBlobContext secAttrSetBlob() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndSecurityAttributeSet(_localctx); + _localctx.Value = _localctx.Builder.ToImmutable(); ExitRule(); } return _localctx; } public partial class SecAttrBlobContext : ParserRuleContext { - public object Value; + public CILParser.SecurityAttributeValue Value; public IToken name; public CustomBlobNVPairsContext arguments; public TypeSpecContext securityType; @@ -8032,6 +8164,7 @@ public SecAttrBlobContext(ParserRuleContext parent, int invokingState) public SecAttrBlobContext secAttrBlob() { SecAttrBlobContext _localctx = new SecAttrBlobContext(Context, State); EnterRule(_localctx, 158, RULE_secAttrBlob); + _localctx.Value = CILParser.SecurityAttributeValue.Error; try { State = 1863; ErrorHandler.Sync(this); @@ -8084,7 +8217,8 @@ public SecAttrBlobContext secAttrBlob() { } public partial class NameValPairsContext : ParserRuleContext { - public object Value; + public System.Collections.Immutable.ImmutableArray Value; + public System.Collections.Immutable.ImmutableArray.Builder Builder; public NameValPairContext pair; public NameValPairContext tail; [System.Diagnostics.DebuggerNonUserCode] public NameValPairContext[] nameValPair() { @@ -8104,7 +8238,7 @@ public NameValPairsContext(ParserRuleContext parent, int invokingState) public NameValPairsContext nameValPairs() { NameValPairsContext _localctx = new NameValPairsContext(Context, State); EnterRule(_localctx, 160, RULE_nameValPairs); - Actions.BeginSecurityNameValuePairs(_localctx); + _localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder(); try { int _alt; EnterOuterAlt(_localctx, 1); @@ -8118,7 +8252,7 @@ public NameValPairsContext nameValPairs() { { State = 1865; _localctx.pair = nameValPair(); - Actions.AddSecurityNameValuePair(_localctx, _localctx.pair.Value); + _localctx.Builder.Add(_localctx.pair.Value); State = 1867; Match(T__27); } @@ -8130,7 +8264,7 @@ public NameValPairsContext nameValPairs() { } State = 1874; _localctx.tail = nameValPair(); - Actions.AddSecurityNameValuePair(_localctx, _localctx.tail.Value); + _localctx.Builder.Add(_localctx.tail.Value); } } catch (RecognitionException re) { @@ -8139,14 +8273,14 @@ public NameValPairsContext nameValPairs() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndSecurityNameValuePairs(_localctx); + _localctx.Value = _localctx.Builder.ToImmutable(); ExitRule(); } return _localctx; } public partial class NameValPairContext : ParserRuleContext { - public object Value; + public CILParser.SecurityNameValuePairValue Value; public CompQstringContext name; public CaValueContext value; [System.Diagnostics.DebuggerNonUserCode] public CompQstringContext compQstring() { @@ -8166,6 +8300,7 @@ public NameValPairContext(ParserRuleContext parent, int invokingState) public NameValPairContext nameValPair() { NameValPairContext _localctx = new NameValPairContext(Context, State); EnterRule(_localctx, 162, RULE_nameValPair); + _localctx.Value = CILParser.SecurityNameValuePairValue.Error; try { EnterOuterAlt(_localctx, 1); { @@ -8231,7 +8366,7 @@ public TruefalseContext truefalse() { } public partial class CaValueContext : ParserRuleContext { - public object Value; + public CILParser.SecurityCaValue Value; public TruefalseContext booleanValue; public Int32Context integerValue; public CompQstringContext textValue; @@ -8264,6 +8399,7 @@ public CaValueContext(ParserRuleContext parent, int invokingState) public CaValueContext caValue() { CaValueContext _localctx = new CaValueContext(Context, State); EnterRule(_localctx, 166, RULE_caValue); + _localctx.Value = CILParser.SecurityCaValue.Error; try { State = 1929; ErrorHandler.Sync(this); @@ -8429,8 +8565,9 @@ public SecActionContext secAction() { } public partial class MethodRefContext : ParserRuleContext { - public object Value; + public CILParser.MethodReferenceValue Value; public bool HasSyntaxError; + public int InitialSyntaxErrorCount; public CallConvContext convention; public TypeContext returnType; public TypeSpecContext owner; @@ -8479,7 +8616,10 @@ public MethodRefContext(ParserRuleContext parent, int invokingState) public MethodRefContext methodRef() { MethodRefContext _localctx = new MethodRefContext(Context, State); EnterRule(_localctx, 170, RULE_methodRef); - Actions.BeginSemanticRoot(_localctx); + + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.MethodReferenceValue.Error; + int _la; try { State = 1975; @@ -8510,7 +8650,7 @@ public MethodRefContext methodRef() { State = 1941; _localctx.arguments = sigArgs(); - _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, _localctx.owner.Value, _localctx.name.Value, _localctx.genericArguments, null, _localctx.arguments.Value); + _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, _localctx.owner.Value, _localctx.name.Value, _localctx.genericArguments is null ? null : _localctx.genericArguments.Value, null, _localctx.arguments.Value); } break; case 2: @@ -8554,7 +8694,7 @@ public MethodRefContext methodRef() { State = 1959; _localctx.arguments = sigArgs(); - _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, null, _localctx.name.Value, _localctx.genericArguments, null, _localctx.arguments.Value); + _localctx.Value = Actions.CreateMethodReference(_localctx.Start, _localctx.convention.Value, _localctx.returnType.Value, null, _localctx.name.Value, _localctx.genericArguments is null ? null : _localctx.genericArguments.Value, null, _localctx.arguments.Value); } break; case 4: @@ -8597,7 +8737,11 @@ public MethodRefContext methodRef() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); + + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; + ExitRule(); } return _localctx; @@ -8800,6 +8944,7 @@ public CallKindContext callKind() { public partial class MdtokenContext : ParserRuleContext { public int Value; public bool HasSyntaxError; + public int InitialSyntaxErrorCount; public Int32Context token; [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { return GetRuleContext(0); @@ -8815,7 +8960,7 @@ public MdtokenContext(ParserRuleContext parent, int invokingState) public MdtokenContext mdtoken() { MdtokenContext _localctx = new MdtokenContext(Context, State); EnterRule(_localctx, 176, RULE_mdtoken); - Actions.BeginSemanticRoot(_localctx); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; try { EnterOuterAlt(_localctx, 1); { @@ -8836,14 +8981,18 @@ public MdtokenContext mdtoken() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); + + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; + ExitRule(); } return _localctx; } public partial class MemberRefContext : ParserRuleContext { - public object Value; + public CILParser.MemberReferenceValue Value; public MethodRefContext method; public FieldRefContext field; public MdtokenContext token; @@ -8868,6 +9017,7 @@ public MemberRefContext(ParserRuleContext parent, int invokingState) public MemberRefContext memberRef() { MemberRefContext _localctx = new MemberRefContext(Context, State); EnterRule(_localctx, 178, RULE_memberRef); + _localctx.Value = CILParser.MemberReferenceValue.Error; try { State = 2034; ErrorHandler.Sync(this); @@ -8916,8 +9066,9 @@ public MemberRefContext memberRef() { } public partial class FieldRefContext : ParserRuleContext { - public object Value; + public CILParser.FieldReferenceValue Value; public bool HasSyntaxError; + public int InitialSyntaxErrorCount; public TypeContext fieldType; public TypeSpecContext owner; public DottedNameContext name; @@ -8943,7 +9094,10 @@ public FieldRefContext(ParserRuleContext parent, int invokingState) public FieldRefContext fieldRef() { FieldRefContext _localctx = new FieldRefContext(Context, State); EnterRule(_localctx, 180, RULE_fieldRef); - Actions.BeginSemanticRoot(_localctx); + + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.FieldReferenceValue.Error; + try { State = 2049; ErrorHandler.Sync(this); @@ -8988,14 +9142,19 @@ public FieldRefContext fieldRef() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); + + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; + ExitRule(); } return _localctx; } public partial class TypeListContext : ParserRuleContext { - public object Value; + public System.Collections.Immutable.ImmutableArray Value; + public System.Collections.Immutable.ImmutableArray.Builder Builder; public TypeSpecContext item; public TypeSpecContext tail; [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext[] typeSpec() { @@ -9015,7 +9174,7 @@ public TypeListContext(ParserRuleContext parent, int invokingState) public TypeListContext typeList() { TypeListContext _localctx = new TypeListContext(Context, State); EnterRule(_localctx, 182, RULE_typeList); - Actions.BeginGenericTypeList(_localctx); + _localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder(); try { int _alt; EnterOuterAlt(_localctx, 1); @@ -9029,7 +9188,7 @@ public TypeListContext typeList() { { State = 2051; _localctx.item = typeSpec(); - Actions.AddGenericType(_localctx, _localctx.item.Value); + _localctx.Builder.Add(_localctx.item.Value); State = 2053; Match(T__27); } @@ -9041,7 +9200,7 @@ public TypeListContext typeList() { } State = 2060; _localctx.tail = typeSpec(); - Actions.AddGenericType(_localctx, _localctx.tail.Value); + _localctx.Builder.Add(_localctx.tail.Value); } } catch (RecognitionException re) { @@ -9050,14 +9209,14 @@ public TypeListContext typeList() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndGenericTypeList(_localctx); + _localctx.Value = _localctx.Builder.ToImmutable(); ExitRule(); } return _localctx; } public partial class TyparsClauseContext : ParserRuleContext { - public object Value; + public System.Collections.Immutable.ImmutableArray Value; public TyparsContext parameters; [System.Diagnostics.DebuggerNonUserCode] public TyparsContext typars() { return GetRuleContext(0); @@ -9073,7 +9232,7 @@ public TyparsClauseContext(ParserRuleContext parent, int invokingState) public TyparsClauseContext typarsClause() { TyparsClauseContext _localctx = new TyparsClauseContext(Context, State); EnterRule(_localctx, 184, RULE_typarsClause); - _localctx.Value = Actions.CreateEmptyGenericParameterList(); + _localctx.Value = System.Collections.Immutable.ImmutableArray.Empty; try { State = 2069; ErrorHandler.Sync(this); @@ -9115,7 +9274,7 @@ public TyparsClauseContext typarsClause() { } public partial class TyparAttribContext : ParserRuleContext { - public object Value; + public CILParser.AttributeValue Value; public IToken covariant; public IToken contravariant; public IToken @class; @@ -9139,6 +9298,7 @@ public TyparAttribContext(ParserRuleContext parent, int invokingState) public TyparAttribContext typarAttrib() { TyparAttribContext _localctx = new TyparAttribContext(Context, State); EnterRule(_localctx, 186, RULE_typarAttrib); + _localctx.Value = CILParser.AttributeValue.Empty; try { State = 2089; ErrorHandler.Sync(this); @@ -9221,7 +9381,7 @@ public TyparAttribContext typarAttrib() { } public partial class TyparAttribsContext : ParserRuleContext { - public object Value; + public System.Reflection.GenericParameterAttributes Value; public TyparAttribContext attribute; [System.Diagnostics.DebuggerNonUserCode] public TyparAttribContext[] typarAttrib() { return GetRuleContexts(); @@ -9240,7 +9400,7 @@ public TyparAttribsContext(ParserRuleContext parent, int invokingState) public TyparAttribsContext typarAttribs() { TyparAttribsContext _localctx = new TyparAttribsContext(Context, State); EnterRule(_localctx, 188, RULE_typarAttribs); - Actions.BeginGenericParameterAttributes(_localctx); + _localctx.Value = 0; int _la; try { EnterOuterAlt(_localctx, 1); @@ -9253,7 +9413,7 @@ public TyparAttribsContext typarAttribs() { { State = 2091; _localctx.attribute = typarAttrib(); - Actions.AddGenericParameterAttribute(_localctx, _localctx.attribute.Value); + _localctx.Value = Actions.AddGenericParameterAttribute(_localctx.Value, _localctx.attribute.Value); } } State = 2098; @@ -9268,14 +9428,13 @@ public TyparAttribsContext typarAttribs() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndGenericParameterAttributes(_localctx); ExitRule(); } return _localctx; } public partial class TyparContext : ParserRuleContext { - public object Value; + public CILParser.GenericParameterDeclarationValue Value; public TyparAttribsContext attributes; public TyBoundContext constraints; public DottedNameContext name; @@ -9299,6 +9458,7 @@ public TyparContext(ParserRuleContext parent, int invokingState) public TyparContext typar() { TyparContext _localctx = new TyparContext(Context, State); EnterRule(_localctx, 190, RULE_typar); + _localctx.Value = CILParser.GenericParameterDeclarationValue.Error; int _la; try { EnterOuterAlt(_localctx, 1); @@ -9332,7 +9492,8 @@ public TyparContext typar() { } public partial class TyparsContext : ParserRuleContext { - public object Value; + public System.Collections.Immutable.ImmutableArray Value; + public System.Collections.Immutable.ImmutableArray.Builder Builder; public TyparContext parameter; public TyparContext tail; [System.Diagnostics.DebuggerNonUserCode] public TyparContext[] typar() { @@ -9352,7 +9513,7 @@ public TyparsContext(ParserRuleContext parent, int invokingState) public TyparsContext typars() { TyparsContext _localctx = new TyparsContext(Context, State); EnterRule(_localctx, 192, RULE_typars); - Actions.BeginGenericParameters(_localctx); + _localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder(); try { int _alt; EnterOuterAlt(_localctx, 1); @@ -9366,7 +9527,7 @@ public TyparsContext typars() { { State = 2106; _localctx.parameter = typar(); - Actions.AddGenericParameter(_localctx, _localctx.parameter.Value); + _localctx.Builder.Add(_localctx.parameter.Value); State = 2108; Match(T__27); } @@ -9378,7 +9539,7 @@ public TyparsContext typars() { } State = 2115; _localctx.tail = typar(); - Actions.AddGenericParameter(_localctx, _localctx.tail.Value); + _localctx.Builder.Add(_localctx.tail.Value); } } catch (RecognitionException re) { @@ -9387,14 +9548,14 @@ public TyparsContext typars() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndGenericParameters(_localctx); + _localctx.Value = _localctx.Builder.ToImmutable(); ExitRule(); } return _localctx; } public partial class TyBoundContext : ParserRuleContext { - public object Value; + public System.Collections.Immutable.ImmutableArray Value; public TypeListContext constraints; [System.Diagnostics.DebuggerNonUserCode] public TypeListContext typeList() { return GetRuleContext(0); @@ -9410,6 +9571,7 @@ public TyBoundContext(ParserRuleContext parent, int invokingState) public TyBoundContext tyBound() { TyBoundContext _localctx = new TyBoundContext(Context, State); EnterRule(_localctx, 194, RULE_tyBound); + _localctx.Value = System.Collections.Immutable.ImmutableArray.Empty; try { EnterOuterAlt(_localctx, 1); { @@ -9523,6 +9685,9 @@ public GenArityNotEmptyContext genArityNotEmpty() { } public partial class ClassDeclContext : ParserRuleContext { + public CILParser.PropertyBodyValue PropertyBody; + public CILParser.EventBodyValue EventBody; + public CILParser.CustomAttributeOwnerValue AttributeOwner; public EventHeadContext eventHeader; public PropHeadContext property; public DataDeclContext data; @@ -9709,11 +9874,11 @@ public ClassDeclContext classDecl() { { State = 2145; _localctx.eventHeader = eventHead(); - Actions.BeginEvent(_localctx, _localctx.eventHeader.Value); + _localctx.EventBody = Actions.BeginEvent(_localctx.eventHeader.Value); State = 2147; Match(T__16); State = 2148; - eventDecls(); + eventDecls(_localctx.EventBody); State = 2149; Match(T__17); } @@ -9723,11 +9888,11 @@ public ClassDeclContext classDecl() { { State = 2151; _localctx.property = propHead(); - Actions.BeginProperty(_localctx, _localctx.property.Value); + _localctx.PropertyBody = Actions.BeginProperty(_localctx.property.Value); State = 2153; Match(T__16); State = 2154; - propDecls(); + propDecls(_localctx.PropertyBody); State = 2155; Match(T__17); } @@ -9925,7 +10090,7 @@ public ClassDeclContext classDecl() { _localctx.parameterIndex = int32(); State = 2227; Match(T__42); - Actions.BeginClassGenericParameterDirective(_localctx, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null)); + _localctx.AttributeOwner = Actions.BeginClassGenericParameterDirective(_localctx, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null)); State = 2234; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,91,Context); @@ -9935,7 +10100,7 @@ public ClassDeclContext classDecl() { { State = 2229; _localctx.attribute = customAttrDecl(); - Actions.AddClassGenericDirectiveAttribute(_localctx, _localctx.attribute); + Actions.AddClassGenericDirectiveAttribute(_localctx.AttributeOwner, _localctx.attribute); } } } @@ -9954,7 +10119,7 @@ public ClassDeclContext classDecl() { Match(TYPE); State = 2239; _localctx.parameterName = dottedName(); - Actions.BeginClassGenericParameterDirective(_localctx, _localctx.parameterName.Value); + _localctx.AttributeOwner = Actions.BeginClassGenericParameterDirective(_localctx.parameterName.Value); State = 2246; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,92,Context); @@ -9964,7 +10129,7 @@ public ClassDeclContext classDecl() { { State = 2241; _localctx.attribute = customAttrDecl(); - Actions.AddClassGenericDirectiveAttribute(_localctx, _localctx.attribute); + Actions.AddClassGenericDirectiveAttribute(_localctx.AttributeOwner, _localctx.attribute); } } } @@ -9991,7 +10156,7 @@ public ClassDeclContext classDecl() { Match(T__27); State = 2255; _localctx.constraintType = typeSpec(); - Actions.BeginClassGenericConstraintDirective(_localctx, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null), _localctx.constraintType.Value); + _localctx.AttributeOwner = Actions.BeginClassGenericConstraintDirective(_localctx, (_localctx.parameterIndex!=null?(_localctx.parameterIndex.Start):null), _localctx.constraintType.Value); State = 2262; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,93,Context); @@ -10001,7 +10166,7 @@ public ClassDeclContext classDecl() { { State = 2257; _localctx.attribute = customAttrDecl(); - Actions.AddClassGenericDirectiveAttribute(_localctx, _localctx.attribute); + Actions.AddClassGenericDirectiveAttribute(_localctx.AttributeOwner, _localctx.attribute); } } } @@ -10024,7 +10189,7 @@ public ClassDeclContext classDecl() { Match(T__27); State = 2269; _localctx.constraintType = typeSpec(); - Actions.BeginClassGenericConstraintDirective(_localctx, _localctx.parameterName.Value, _localctx.constraintType.Value); + _localctx.AttributeOwner = Actions.BeginClassGenericConstraintDirective(_localctx.parameterName.Value, _localctx.constraintType.Value); State = 2276; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream,94,Context); @@ -10034,7 +10199,7 @@ public ClassDeclContext classDecl() { { State = 2271; _localctx.attribute = customAttrDecl(); - Actions.AddClassGenericDirectiveAttribute(_localctx, _localctx.attribute); + Actions.AddClassGenericDirectiveAttribute(_localctx.AttributeOwner, _localctx.attribute); } } } @@ -10073,7 +10238,9 @@ public ClassDeclContext classDecl() { } public partial class FieldDeclContext : ParserRuleContext { - public object Value; + public CILParser.FieldDeclarationValue Value; + public int InitialSyntaxErrorCount; + public CILParser.FieldDeclarationBuilder Builder; public RepeatOptContext offset; public FieldAttrContext attribute; public MarshalBlobContext marshalling; @@ -10119,7 +10286,11 @@ public FieldDeclContext(ParserRuleContext parent, int invokingState) public FieldDeclContext fieldDecl() { FieldDeclContext _localctx = new FieldDeclContext(Context, State); EnterRule(_localctx, 202, RULE_fieldDecl); - Actions.BeginFieldDeclaration(_localctx); + + _localctx.Builder = Actions.PrepareFieldDeclaration(); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.FieldDeclarationValue.Error; + try { int _alt; EnterOuterAlt(_localctx, 1); @@ -10155,7 +10326,7 @@ public FieldDeclContext fieldDecl() { { State = 2289; _localctx.attribute = fieldAttr(); - Actions.AddFieldAttribute(_localctx, _localctx.attribute.Value); + Actions.AddFieldAttribute(_localctx.Builder, _localctx.attribute.Value); } break; case T__121: @@ -10168,7 +10339,7 @@ public FieldDeclContext fieldDecl() { _localctx.marshalling = marshalBlob(); State = 2295; Match(T__30); - Actions.SetFieldMarshalling(_localctx, _localctx.marshalling.Value); + Actions.SetFieldMarshalling(_localctx.Builder, _localctx.marshalling.Value); } break; default: @@ -10190,6 +10361,8 @@ public FieldDeclContext fieldDecl() { _localctx.initializer = initOpt(); _localctx.Value = Actions.CreateFieldDeclaration( _localctx, + _localctx.Builder, + _localctx.InitialSyntaxErrorCount, _localctx.offset, _localctx.fieldType.Value, _localctx.name.Value, @@ -10205,14 +10378,13 @@ public FieldDeclContext fieldDecl() { ErrorHandler.Recover(this, re); } finally { - Actions.EndFieldDeclaration(_localctx); ExitRule(); } return _localctx; } public partial class FieldAttrContext : ParserRuleContext { - public object Value; + public CILParser.AttributeValue Value; public IToken attribute; public Int32Context flags; [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { @@ -10229,6 +10401,7 @@ public FieldAttrContext(ParserRuleContext parent, int invokingState) public FieldAttrContext fieldAttr() { FieldAttrContext _localctx = new FieldAttrContext(Context, State); EnterRule(_localctx, 204, RULE_fieldAttr); + _localctx.Value = CILParser.AttributeValue.Empty; try { State = 2343; ErrorHandler.Sync(this); @@ -10375,7 +10548,7 @@ public FieldAttrContext fieldAttr() { } public partial class AtOptContext : ParserRuleContext { - public string Value; + public string? Value; public IdContext name; public Int32Context offset; [System.Diagnostics.DebuggerNonUserCode] public IdContext id() { @@ -10395,6 +10568,7 @@ public AtOptContext(ParserRuleContext parent, int invokingState) public AtOptContext atOpt() { AtOptContext _localctx = new AtOptContext(Context, State); EnterRule(_localctx, 206, RULE_atOpt); + _localctx.Value = null; try { State = 2354; ErrorHandler.Sync(this); @@ -10438,8 +10612,9 @@ public AtOptContext atOpt() { } public partial class InitOptContext : ParserRuleContext { - public object Value; + public CILParser.FieldInitializerValue Value; public bool HasSyntaxError; + public int InitialSyntaxErrorCount; public FieldInitContext initializer; [System.Diagnostics.DebuggerNonUserCode] public FieldInitContext fieldInit() { return GetRuleContext(0); @@ -10455,7 +10630,10 @@ public InitOptContext(ParserRuleContext parent, int invokingState) public InitOptContext initOpt() { InitOptContext _localctx = new InitOptContext(Context, State); EnterRule(_localctx, 208, RULE_initOpt); - Actions.BeginFieldInitializer(_localctx); + + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.FieldInitializerValue.Empty; + try { State = 2361; ErrorHandler.Sync(this); @@ -10555,7 +10733,7 @@ public InitOptContext initOpt() { Match(T__35); State = 2358; _localctx.initializer = fieldInit(); - Actions.SetFieldInitializer(_localctx, _localctx.initializer.Value); + _localctx.Value = _localctx.initializer.Value; } break; default: @@ -10568,7 +10746,11 @@ public InitOptContext initOpt() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndFieldInitializer(_localctx); + + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; + ExitRule(); } return _localctx; @@ -10673,7 +10855,9 @@ public RepeatOptContext repeatOpt() { } public partial class EventHeadContext : ParserRuleContext { - public object Value; + public CILParser.EventHeaderValue Value; + public int InitialSyntaxErrorCount; + public CILParser.EventHeaderBuilder Builder; public EventAttrContext attribute; public TypeSpecContext eventType; public DottedNameContext name; @@ -10700,7 +10884,11 @@ public EventHeadContext(ParserRuleContext parent, int invokingState) public EventHeadContext eventHead() { EventHeadContext _localctx = new EventHeadContext(Context, State); EnterRule(_localctx, 212, RULE_eventHead); - Actions.BeginEventHeader(_localctx); + + _localctx.Builder = new CILParser.EventHeaderBuilder(); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.EventHeaderValue.Error; + int _la; try { State = 2396; @@ -10719,7 +10907,7 @@ public EventHeadContext eventHead() { { State = 2372; _localctx.attribute = eventAttr(); - Actions.AddEventAttribute(_localctx, _localctx.attribute.Value); + Actions.AddEventAttribute(_localctx.Builder, _localctx.attribute.Value); } } State = 2379; @@ -10730,7 +10918,12 @@ public EventHeadContext eventHead() { _localctx.eventType = typeSpec(); State = 2381; _localctx.name = dottedName(); - _localctx.Value = Actions.CreateEventHeader(_localctx, _localctx.eventType.Value, _localctx.name.Value); + _localctx.Value = Actions.CreateEventHeader( + _localctx, + _localctx.Builder, + _localctx.InitialSyntaxErrorCount, + _localctx.eventType.Value, + _localctx.name.Value); } break; case 2: @@ -10746,7 +10939,7 @@ public EventHeadContext eventHead() { { State = 2385; _localctx.attribute = eventAttr(); - Actions.AddEventAttribute(_localctx, _localctx.attribute.Value); + Actions.AddEventAttribute(_localctx.Builder, _localctx.attribute.Value); } } State = 2392; @@ -10755,7 +10948,12 @@ public EventHeadContext eventHead() { } State = 2393; _localctx.name = dottedName(); - _localctx.Value = Actions.CreateEventHeader(_localctx, null, _localctx.name.Value); + _localctx.Value = Actions.CreateEventHeader( + _localctx, + _localctx.Builder, + _localctx.InitialSyntaxErrorCount, + null, + _localctx.name.Value); } break; } @@ -10766,14 +10964,13 @@ public EventHeadContext eventHead() { ErrorHandler.Recover(this, re); } finally { - Actions.EndEventHeader(_localctx); ExitRule(); } return _localctx; } public partial class EventAttrContext : ParserRuleContext { - public object Value; + public CILParser.AttributeValue Value; public IToken attribute; public EventAttrContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) @@ -10786,6 +10983,7 @@ public EventAttrContext(ParserRuleContext parent, int invokingState) public EventAttrContext eventAttr() { EventAttrContext _localctx = new EventAttrContext(Context, State); EnterRule(_localctx, 214, RULE_eventAttr); + _localctx.Value = CILParser.AttributeValue.Empty; try { State = 2402; ErrorHandler.Sync(this); @@ -10822,22 +11020,25 @@ public EventAttrContext eventAttr() { } public partial class EventDeclsContext : ParserRuleContext { + public CILParser.EventBodyValue Body; [System.Diagnostics.DebuggerNonUserCode] public EventDeclContext[] eventDecl() { return GetRuleContexts(); } [System.Diagnostics.DebuggerNonUserCode] public EventDeclContext eventDecl(int i) { return GetRuleContext(i); } - public EventDeclsContext(ParserRuleContext parent, int invokingState) + public EventDeclsContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { } + public EventDeclsContext(ParserRuleContext parent, int invokingState, CILParser.EventBodyValue Body) : base(parent, invokingState) { + this.Body = Body; } public override int RuleIndex { get { return RULE_eventDecls; } } } [RuleVersion(0)] - public EventDeclsContext eventDecls() { - EventDeclsContext _localctx = new EventDeclsContext(Context, State); + public EventDeclsContext eventDecls(CILParser.EventBodyValue Body) { + EventDeclsContext _localctx = new EventDeclsContext(Context, State, Body); EnterRule(_localctx, 216, RULE_eventDecls); int _la; try { @@ -10850,7 +11051,7 @@ public EventDeclsContext eventDecls() { { { State = 2404; - eventDecl(); + eventDecl(_localctx.Body); } } State = 2409; @@ -10871,6 +11072,7 @@ public EventDeclsContext eventDecls() { } public partial class EventDeclContext : ParserRuleContext { + public CILParser.EventBodyValue Body; public MethodRefContext accessor; public ExtSourceSpecContext source; public CustomAttrDeclContext attribute; @@ -10890,16 +11092,18 @@ [System.Diagnostics.DebuggerNonUserCode] public LanguageDeclContext languageDecl [System.Diagnostics.DebuggerNonUserCode] public CompControlContext compControl() { return GetRuleContext(0); } - public EventDeclContext(ParserRuleContext parent, int invokingState) + public EventDeclContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { } + public EventDeclContext(ParserRuleContext parent, int invokingState, CILParser.EventBodyValue Body) : base(parent, invokingState) { + this.Body = Body; } public override int RuleIndex { get { return RULE_eventDecl; } } } [RuleVersion(0)] - public EventDeclContext eventDecl() { - EventDeclContext _localctx = new EventDeclContext(Context, State); + public EventDeclContext eventDecl(CILParser.EventBodyValue Body) { + EventDeclContext _localctx = new EventDeclContext(Context, State, Body); EnterRule(_localctx, 218, RULE_eventDecl); try { State = 2436; @@ -10912,7 +11116,7 @@ public EventDeclContext eventDecl() { Match(T__128); State = 2411; _localctx.accessor = methodRef(); - Actions.AddEventAdder(_localctx, _localctx.accessor.Value); + Actions.AddEventAdder(_localctx.Body, _localctx.accessor.Value); } break; case T__129: @@ -10922,7 +11126,7 @@ public EventDeclContext eventDecl() { Match(T__129); State = 2415; _localctx.accessor = methodRef(); - Actions.AddEventRemover(_localctx, _localctx.accessor.Value); + Actions.AddEventRemover(_localctx.Body, _localctx.accessor.Value); } break; case T__130: @@ -10932,7 +11136,7 @@ public EventDeclContext eventDecl() { Match(T__130); State = 2419; _localctx.accessor = methodRef(); - Actions.AddEventRaiser(_localctx, _localctx.accessor.Value); + Actions.AddEventRaiser(_localctx.Body, _localctx.accessor.Value); } break; case T__131: @@ -10942,7 +11146,7 @@ public EventDeclContext eventDecl() { Match(T__131); State = 2423; _localctx.accessor = methodRef(); - Actions.AddEventOther(_localctx, _localctx.accessor.Value); + Actions.AddEventOther(_localctx.Body, _localctx.accessor.Value); } break; case T__72: @@ -10951,7 +11155,7 @@ public EventDeclContext eventDecl() { { State = 2426; _localctx.source = extSourceSpec(); - Actions.ProcessEventSourceDirective(_localctx.source); + Actions.ProcessEventSourceDirective(_localctx.Body, _localctx.source); } break; case T__15: @@ -10965,7 +11169,7 @@ public EventDeclContext eventDecl() { { State = 2429; _localctx.attribute = customAttrDecl(); - Actions.AddEventCustomAttribute(_localctx, _localctx.attribute); + Actions.AddEventCustomAttribute(_localctx.Body, _localctx.attribute); } break; case T__26: @@ -10973,7 +11177,7 @@ public EventDeclContext eventDecl() { { State = 2432; _localctx.language = languageDecl(); - Actions.ProcessEventLanguageDirective(_localctx.language); + Actions.ProcessEventLanguageDirective(_localctx.Body, _localctx.language); } break; case T__31: @@ -11006,7 +11210,9 @@ public EventDeclContext eventDecl() { } public partial class PropHeadContext : ParserRuleContext { - public object Value; + public CILParser.PropertyHeaderValue Value; + public int InitialSyntaxErrorCount; + public CILParser.PropertyHeaderBuilder Builder; public PropAttrContext attribute; public CallConvContext convention; public TypeContext propertyType; @@ -11045,7 +11251,11 @@ public PropHeadContext(ParserRuleContext parent, int invokingState) public PropHeadContext propHead() { PropHeadContext _localctx = new PropHeadContext(Context, State); EnterRule(_localctx, 220, RULE_propHead); - Actions.BeginPropertyHeader(_localctx); + + _localctx.Builder = new CILParser.PropertyHeaderBuilder(); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.PropertyHeaderValue.Error; + int _la; try { EnterOuterAlt(_localctx, 1); @@ -11060,7 +11270,7 @@ public PropHeadContext propHead() { { State = 2439; _localctx.attribute = propAttr(); - Actions.AddPropertyAttribute(_localctx, _localctx.attribute.Value); + Actions.AddPropertyAttribute(_localctx.Builder, _localctx.attribute.Value); } } State = 2446; @@ -11079,6 +11289,8 @@ public PropHeadContext propHead() { _localctx.initializer = initOpt(); _localctx.Value = Actions.CreatePropertyHeader( _localctx, + _localctx.Builder, + _localctx.InitialSyntaxErrorCount, _localctx.convention.Value, _localctx.propertyType.Value, _localctx.name.Value, @@ -11092,14 +11304,13 @@ public PropHeadContext propHead() { ErrorHandler.Recover(this, re); } finally { - Actions.EndPropertyHeader(_localctx); ExitRule(); } return _localctx; } public partial class PropAttrContext : ParserRuleContext { - public object Value; + public CILParser.AttributeValue Value; public IToken attribute; public PropAttrContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) @@ -11112,6 +11323,7 @@ public PropAttrContext(ParserRuleContext parent, int invokingState) public PropAttrContext propAttr() { PropAttrContext _localctx = new PropAttrContext(Context, State); EnterRule(_localctx, 222, RULE_propAttr); + _localctx.Value = CILParser.AttributeValue.Empty; try { State = 2458; ErrorHandler.Sync(this); @@ -11148,22 +11360,25 @@ public PropAttrContext propAttr() { } public partial class PropDeclsContext : ParserRuleContext { + public CILParser.PropertyBodyValue Body; [System.Diagnostics.DebuggerNonUserCode] public PropDeclContext[] propDecl() { return GetRuleContexts(); } [System.Diagnostics.DebuggerNonUserCode] public PropDeclContext propDecl(int i) { return GetRuleContext(i); } - public PropDeclsContext(ParserRuleContext parent, int invokingState) + public PropDeclsContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { } + public PropDeclsContext(ParserRuleContext parent, int invokingState, CILParser.PropertyBodyValue Body) : base(parent, invokingState) { + this.Body = Body; } public override int RuleIndex { get { return RULE_propDecls; } } } [RuleVersion(0)] - public PropDeclsContext propDecls() { - PropDeclsContext _localctx = new PropDeclsContext(Context, State); + public PropDeclsContext propDecls(CILParser.PropertyBodyValue Body) { + PropDeclsContext _localctx = new PropDeclsContext(Context, State, Body); EnterRule(_localctx, 224, RULE_propDecls); int _la; try { @@ -11176,7 +11391,7 @@ public PropDeclsContext propDecls() { { { State = 2460; - propDecl(); + propDecl(_localctx.Body); } } State = 2465; @@ -11197,6 +11412,7 @@ public PropDeclsContext propDecls() { } public partial class PropDeclContext : ParserRuleContext { + public CILParser.PropertyBodyValue Body; public MethodRefContext accessor; public CustomAttrDeclContext attribute; public ExtSourceSpecContext source; @@ -11216,16 +11432,18 @@ [System.Diagnostics.DebuggerNonUserCode] public LanguageDeclContext languageDecl [System.Diagnostics.DebuggerNonUserCode] public CompControlContext compControl() { return GetRuleContext(0); } - public PropDeclContext(ParserRuleContext parent, int invokingState) + public PropDeclContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { } + public PropDeclContext(ParserRuleContext parent, int invokingState, CILParser.PropertyBodyValue Body) : base(parent, invokingState) { + this.Body = Body; } public override int RuleIndex { get { return RULE_propDecl; } } } [RuleVersion(0)] - public PropDeclContext propDecl() { - PropDeclContext _localctx = new PropDeclContext(Context, State); + public PropDeclContext propDecl(CILParser.PropertyBodyValue Body) { + PropDeclContext _localctx = new PropDeclContext(Context, State, Body); EnterRule(_localctx, 226, RULE_propDecl); try { State = 2488; @@ -11238,7 +11456,7 @@ public PropDeclContext propDecl() { Match(T__133); State = 2467; _localctx.accessor = methodRef(); - Actions.AddPropertySetter(_localctx, _localctx.accessor.Value); + Actions.AddPropertySetter(_localctx.Body, _localctx.accessor.Value); } break; case T__134: @@ -11248,7 +11466,7 @@ public PropDeclContext propDecl() { Match(T__134); State = 2471; _localctx.accessor = methodRef(); - Actions.AddPropertyGetter(_localctx, _localctx.accessor.Value); + Actions.AddPropertyGetter(_localctx.Body, _localctx.accessor.Value); } break; case T__131: @@ -11258,7 +11476,7 @@ public PropDeclContext propDecl() { Match(T__131); State = 2475; _localctx.accessor = methodRef(); - Actions.AddPropertyOther(_localctx, _localctx.accessor.Value); + Actions.AddPropertyOther(_localctx.Body, _localctx.accessor.Value); } break; case T__15: @@ -11272,7 +11490,7 @@ public PropDeclContext propDecl() { { State = 2478; _localctx.attribute = customAttrDecl(); - Actions.AddPropertyCustomAttribute(_localctx, _localctx.attribute); + Actions.AddPropertyCustomAttribute(_localctx.Body, _localctx.attribute); } break; case T__72: @@ -11281,7 +11499,7 @@ public PropDeclContext propDecl() { { State = 2481; _localctx.source = extSourceSpec(); - Actions.ProcessPropertySourceDirective(_localctx.source); + Actions.ProcessPropertySourceDirective(_localctx.Body, _localctx.source); } break; case T__26: @@ -11289,7 +11507,7 @@ public PropDeclContext propDecl() { { State = 2484; _localctx.language = languageDecl(); - Actions.ProcessPropertyLanguageDirective(_localctx.language); + Actions.ProcessPropertyLanguageDirective(_localctx.Body, _localctx.language); } break; case T__31: @@ -11322,7 +11540,7 @@ public PropDeclContext propDecl() { } public partial class MarshalClauseContext : ParserRuleContext { - public object Value; + public CILParser.MarshallingDescriptorValue Value; public MarshalBlobContext value; [System.Diagnostics.DebuggerNonUserCode] public MarshalBlobContext marshalBlob() { return GetRuleContext(0); @@ -11338,6 +11556,7 @@ public MarshalClauseContext(ParserRuleContext parent, int invokingState) public MarshalClauseContext marshalClause() { MarshalClauseContext _localctx = new MarshalClauseContext(Context, State); EnterRule(_localctx, 228, RULE_marshalClause); + _localctx.Value = CILParser.MarshallingDescriptorValue.Empty; try { State = 2497; ErrorHandler.Sync(this); @@ -11403,7 +11622,8 @@ public MarshalClauseContext marshalClause() { } public partial class MarshalBlobContext : ParserRuleContext { - public object Value; + public CILParser.MarshallingDescriptorValue Value; + public CILParser.MarshalBlobBuilder Builder; public NativeTypeContext nativeValue; public HexbyteContext rawByte; [System.Diagnostics.DebuggerNonUserCode] public NativeTypeContext nativeType() { @@ -11426,7 +11646,7 @@ public MarshalBlobContext(ParserRuleContext parent, int invokingState) public MarshalBlobContext marshalBlob() { MarshalBlobContext _localctx = new MarshalBlobContext(Context, State); EnterRule(_localctx, 230, RULE_marshalBlob); - Actions.BeginMarshalBlob(_localctx); + _localctx.Builder = new CILParser.MarshalBlobBuilder(); int _la; try { State = 2512; @@ -11486,7 +11706,7 @@ public MarshalBlobContext marshalBlob() { { State = 2499; _localctx.nativeValue = nativeType(); - Actions.SetMarshalBlobNativeType(_localctx, _localctx.nativeValue.Value); + Actions.SetMarshalBlobNativeType(_localctx.Builder, _localctx.nativeValue.Value); } break; case T__16: @@ -11502,7 +11722,7 @@ public MarshalBlobContext marshalBlob() { { State = 2503; _localctx.rawByte = hexbyte(); - Actions.AddMarshalBlobByte(_localctx, _localctx.rawByte.Value); + Actions.AddMarshalBlobByte(_localctx.Builder, _localctx.rawByte.Value); } } State = 2508; @@ -11523,7 +11743,7 @@ public MarshalBlobContext marshalBlob() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndMarshalBlob(_localctx); + _localctx.Value = Actions.CreateMarshallingDescriptor(_localctx.Builder); ExitRule(); } return _localctx; @@ -11549,7 +11769,7 @@ public ParamAttrContext(ParserRuleContext parent, int invokingState) public ParamAttrContext paramAttr() { ParamAttrContext _localctx = new ParamAttrContext(Context, State); EnterRule(_localctx, 232, RULE_paramAttr); - Actions.BeginParameterAttributes(_localctx); + _localctx.Value = 0; int _la; try { EnterOuterAlt(_localctx, 1); @@ -11562,7 +11782,10 @@ public ParamAttrContext paramAttr() { { State = 2514; _localctx.element = paramAttrElement(); - Actions.AddParameterAttribute(_localctx, _localctx.element); + _localctx.Value = Actions.AddParameterAttribute( + _localctx.Value, + _localctx.element.Value, + _localctx.element.ShouldAppend); } } State = 2521; @@ -11577,7 +11800,6 @@ public ParamAttrContext paramAttr() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndParameterAttributes(_localctx); ExitRule(); } return _localctx; @@ -11668,7 +11890,9 @@ public ParamAttrElementContext paramAttrElement() { } public partial class MethodHeadContext : ParserRuleContext { - public object Value; + public CILParser.MethodHeaderValue Value; + public int InitialSyntaxErrorCount; + public CILParser.MethodHeaderBuilder Builder; public MethAttrContext attribute; public PinvImplContext pInvoke; public CallConvContext convention; @@ -11729,7 +11953,11 @@ public MethodHeadContext(ParserRuleContext parent, int invokingState) public MethodHeadContext methodHead() { MethodHeadContext _localctx = new MethodHeadContext(Context, State); EnterRule(_localctx, 236, RULE_methodHead); - Actions.BeginMethodHeader(_localctx); + + _localctx.Builder = Actions.PrepareMethodHeader(); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.MethodHeaderValue.Error; + int _la; try { EnterOuterAlt(_localctx, 1); @@ -11766,14 +11994,14 @@ public MethodHeadContext methodHead() { { State = 2542; _localctx.attribute = methAttr(); - Actions.AddMethodAttribute(_localctx, _localctx.attribute.Value); + Actions.AddMethodAttribute(_localctx.Builder, _localctx.attribute.Value); } break; case T__146: { State = 2545; _localctx.pInvoke = pinvImpl(); - Actions.AddPInvoke(_localctx, _localctx.pInvoke.Value); + Actions.AddPInvoke(_localctx.Builder, _localctx.pInvoke.Value); } break; default: @@ -11806,7 +12034,7 @@ public MethodHeadContext methodHead() { { State = 2560; _localctx.implementation = implAttr(); - Actions.AddMethodImplementationAttribute(_localctx, _localctx.implementation.Value); + Actions.AddMethodImplementationAttribute(_localctx.Builder, _localctx.implementation.Value); } } State = 2567; @@ -11815,6 +12043,8 @@ public MethodHeadContext methodHead() { } _localctx.Value = Actions.CreateMethodHeader( _localctx, + _localctx.Builder, + _localctx.InitialSyntaxErrorCount, _localctx.convention.Value, _localctx.returnAttributes.Value, _localctx.returnType.Value, @@ -11832,14 +12062,13 @@ public MethodHeadContext methodHead() { ErrorHandler.Recover(this, re); } finally { - Actions.EndMethodHeader(_localctx); ExitRule(); } return _localctx; } public partial class MethAttrContext : ParserRuleContext { - public object Value; + public CILParser.AttributeValue Value; public IToken attribute; public Int32Context flags; [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { @@ -11856,6 +12085,7 @@ public MethAttrContext(ParserRuleContext parent, int invokingState) public MethAttrContext methAttr() { MethAttrContext _localctx = new MethAttrContext(Context, State); EnterRule(_localctx, 238, RULE_methAttr); + _localctx.Value = CILParser.AttributeValue.Empty; try { State = 2612; ErrorHandler.Sync(this); @@ -12034,7 +12264,8 @@ public MethAttrContext methAttr() { } public partial class PinvImplContext : ParserRuleContext { - public object Value; + public CILParser.PInvokeValue Value; + public CILParser.PInvokeBuilder Builder; public CompQstringContext module; public CompQstringContext entryPoint; public PinvAttrContext attribute; @@ -12061,7 +12292,7 @@ public PinvImplContext(ParserRuleContext parent, int invokingState) public PinvImplContext pinvImpl() { PinvImplContext _localctx = new PinvImplContext(Context, State); EnterRule(_localctx, 240, RULE_pinvImpl); - Actions.BeginPInvoke(_localctx); + _localctx.Builder = new CILParser.PInvokeBuilder(); int _la; try { State = 2637; @@ -12081,7 +12312,7 @@ public PinvImplContext pinvImpl() { { State = 2616; _localctx.module = compQstring(); - Actions.SetPInvokeModule(_localctx, _localctx.module.Value); + Actions.SetPInvokeModule(_localctx.Builder, _localctx.module.Value); State = 2622; ErrorHandler.Sync(this); _la = TokenStream.LA(1); @@ -12091,7 +12322,7 @@ public PinvImplContext pinvImpl() { Match(T__33); State = 2619; _localctx.entryPoint = compQstring(); - Actions.SetPInvokeEntryPoint(_localctx, _localctx.entryPoint.Value); + Actions.SetPInvokeEntryPoint(_localctx.Builder, _localctx.entryPoint.Value); } } @@ -12106,7 +12337,7 @@ public PinvImplContext pinvImpl() { { State = 2626; _localctx.attribute = pinvAttr(); - Actions.AddPInvokeAttribute(_localctx, _localctx.attribute.Value); + Actions.AddPInvokeAttribute(_localctx.Builder, _localctx.attribute.Value); } } State = 2633; @@ -12134,14 +12365,14 @@ public PinvImplContext pinvImpl() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndPInvoke(_localctx); + _localctx.Value = Actions.CreatePInvoke(_localctx.Builder); ExitRule(); } return _localctx; } public partial class PinvAttrContext : ParserRuleContext { - public object Value; + public CILParser.AttributeValue Value; public IToken attribute; public IToken setting; public Int32Context flags; @@ -12164,6 +12395,7 @@ public PinvAttrContext(ParserRuleContext parent, int invokingState) public PinvAttrContext pinvAttr() { PinvAttrContext _localctx = new PinvAttrContext(Context, State); EnterRule(_localctx, 242, RULE_pinvAttr); + _localctx.Value = CILParser.AttributeValue.Empty; try { State = 2681; ErrorHandler.Sync(this); @@ -12342,6 +12574,7 @@ public MethodNameContext(ParserRuleContext parent, int invokingState) public MethodNameContext methodName() { MethodNameContext _localctx = new MethodNameContext(Context, State); EnterRule(_localctx, 244, RULE_methodName); + _localctx.Value = string.Empty; try { State = 2690; ErrorHandler.Sync(this); @@ -12391,7 +12624,7 @@ public MethodNameContext methodName() { } public partial class ImplAttrContext : ParserRuleContext { - public object Value; + public CILParser.AttributeValue Value; public IToken attribute; public Int32Context flags; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UNMANAGED() { return GetToken(CILParser.UNMANAGED, 0); } @@ -12409,6 +12642,7 @@ public ImplAttrContext(ParserRuleContext parent, int invokingState) public ImplAttrContext implAttr() { ImplAttrContext _localctx = new ImplAttrContext(Context, State); EnterRule(_localctx, 246, RULE_implAttr); + _localctx.Value = CILParser.AttributeValue.Empty; try { State = 2730; ErrorHandler.Sync(this); @@ -12895,6 +13129,7 @@ public MethodDeclContext methodDecl() { } public partial class LocalsDeclContext : ParserRuleContext { + public int InitialSyntaxErrorCount; public IToken initialize; public SigArgsContext arguments; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LOCALS() { return GetToken(CILParser.LOCALS, 0); } @@ -12912,7 +13147,7 @@ public LocalsDeclContext(ParserRuleContext parent, int invokingState) public LocalsDeclContext localsDecl() { LocalsDeclContext _localctx = new LocalsDeclContext(Context, State); EnterRule(_localctx, 252, RULE_localsDecl); - Actions.BeginSemanticRoot(_localctx); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; int _la; try { EnterOuterAlt(_localctx, 1); @@ -12939,13 +13174,14 @@ public LocalsDeclContext localsDecl() { ErrorHandler.Recover(this, re); } finally { - Actions.EndLocalsDirective(_localctx); + Actions.EndLocalsDirective(_localctx, _localctx.InitialSyntaxErrorCount); ExitRule(); } return _localctx; } public partial class ExportDeclContext : ParserRuleContext { + public int InitialSyntaxErrorCount; public Int32Context ordinal; public IdContext alias; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode EXPORT() { return GetToken(CILParser.EXPORT, 0); } @@ -12966,7 +13202,7 @@ public ExportDeclContext(ParserRuleContext parent, int invokingState) public ExportDeclContext exportDecl() { ExportDeclContext _localctx = new ExportDeclContext(Context, State); EnterRule(_localctx, 254, RULE_exportDecl); - Actions.BeginSemanticRoot(_localctx); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; int _la; try { EnterOuterAlt(_localctx, 1); @@ -12999,13 +13235,14 @@ public ExportDeclContext exportDecl() { ErrorHandler.Recover(this, re); } finally { - Actions.EndExportDirective(_localctx); + Actions.EndExportDirective(_localctx, _localctx.InitialSyntaxErrorCount); ExitRule(); } return _localctx; } public partial class VtentryDeclContext : ParserRuleContext { + public int InitialSyntaxErrorCount; public Int32Context table; public Int32Context slot; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VTENTRY() { return GetToken(CILParser.VTENTRY, 0); } @@ -13026,7 +13263,7 @@ public VtentryDeclContext(ParserRuleContext parent, int invokingState) public VtentryDeclContext vtentryDecl() { VtentryDeclContext _localctx = new VtentryDeclContext(Context, State); EnterRule(_localctx, 256, RULE_vtentryDecl); - Actions.BeginSemanticRoot(_localctx); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; try { EnterOuterAlt(_localctx, 1); { @@ -13046,13 +13283,14 @@ public VtentryDeclContext vtentryDecl() { ErrorHandler.Recover(this, re); } finally { - Actions.EndVTableEntryDirective(_localctx); + Actions.EndVTableEntryDirective(_localctx, _localctx.InitialSyntaxErrorCount); ExitRule(); } return _localctx; } public partial class OverrideDeclContext : ParserRuleContext { + public int InitialSyntaxErrorCount; public TypeSpecContext owner; public MethodNameContext name; public CallConvContext convention; @@ -13091,7 +13329,7 @@ public OverrideDeclContext(ParserRuleContext parent, int invokingState) public OverrideDeclContext overrideDecl() { OverrideDeclContext _localctx = new OverrideDeclContext(Context, State); EnterRule(_localctx, 258, RULE_overrideDecl); - Actions.BeginSemanticRoot(_localctx); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; try { State = 2811; ErrorHandler.Sync(this); @@ -13140,13 +13378,15 @@ public OverrideDeclContext overrideDecl() { ErrorHandler.Recover(this, re); } finally { - Actions.EndOverrideDirective(_localctx); + Actions.EndOverrideDirective(_localctx, _localctx.InitialSyntaxErrorCount); ExitRule(); } return _localctx; } public partial class ParameterDeclContext : ParserRuleContext { + public int InitialSyntaxErrorCount; + public System.Collections.Immutable.ImmutableArray.Builder Attributes; public Int32Context genericIndex; public CustomAttrDeclContext attribute; public DottedNameContext genericName; @@ -13187,7 +13427,10 @@ public ParameterDeclContext(ParserRuleContext parent, int invokingState) public ParameterDeclContext parameterDecl() { ParameterDeclContext _localctx = new ParameterDeclContext(Context, State); EnterRule(_localctx, 260, RULE_parameterDecl); - Actions.BeginParameterDirective(_localctx); + + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Attributes = System.Collections.Immutable.ImmutableArray.CreateBuilder(); + try { int _alt; State = 2878; @@ -13215,7 +13458,7 @@ public ParameterDeclContext parameterDecl() { { State = 2818; _localctx.attribute = customAttrDecl(); - Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); + Actions.AddCustomAttributeApplication(_localctx.Attributes, _localctx.attribute); } } } @@ -13243,7 +13486,7 @@ public ParameterDeclContext parameterDecl() { { State = 2829; _localctx.attribute = customAttrDecl(); - Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); + Actions.AddCustomAttributeApplication(_localctx.Attributes, _localctx.attribute); } } } @@ -13279,7 +13522,7 @@ public ParameterDeclContext parameterDecl() { { State = 2844; _localctx.attribute = customAttrDecl(); - Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); + Actions.AddCustomAttributeApplication(_localctx.Attributes, _localctx.attribute); } } } @@ -13311,7 +13554,7 @@ public ParameterDeclContext parameterDecl() { { State = 2857; _localctx.attribute = customAttrDecl(); - Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); + Actions.AddCustomAttributeApplication(_localctx.Attributes, _localctx.attribute); } } } @@ -13343,7 +13586,7 @@ public ParameterDeclContext parameterDecl() { { State = 2870; _localctx.attribute = customAttrDecl(); - Actions.AddParameterCustomAttribute(_localctx, _localctx.attribute); + Actions.AddCustomAttributeApplication(_localctx.Attributes, _localctx.attribute); } } } @@ -13361,7 +13604,10 @@ public ParameterDeclContext parameterDecl() { ErrorHandler.Recover(this, re); } finally { - Actions.EndParameterDirective(_localctx); + Actions.EndParameterDirective( + _localctx, + _localctx.Attributes.ToImmutable(), + _localctx.InitialSyntaxErrorCount); ExitRule(); } return _localctx; @@ -13405,8 +13651,9 @@ public LabelDeclContext labelDecl() { } public partial class CustomDescrInMethodBodyContext : ParserRuleContext { - public object Value; + public CILParser.CustomAttributeDeclarationValue Value; public bool HasSyntaxError; + public int InitialSyntaxErrorCount; public CustomDescrContext directAttribute; public CustomDescrWithOwnerContext ownedAttribute; [System.Diagnostics.DebuggerNonUserCode] public CustomDescrContext customDescr() { @@ -13426,7 +13673,10 @@ public CustomDescrInMethodBodyContext(ParserRuleContext parent, int invokingStat public CustomDescrInMethodBodyContext customDescrInMethodBody() { CustomDescrInMethodBodyContext _localctx = new CustomDescrInMethodBodyContext(Context, State); EnterRule(_localctx, 264, RULE_customDescrInMethodBody); - Actions.BeginSemanticRoot(_localctx); + + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.CustomAttributeDeclarationValue.Error; + try { State = 2890; ErrorHandler.Sync(this); @@ -13455,7 +13705,11 @@ public CustomDescrInMethodBodyContext customDescrInMethodBody() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); + + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; + ExitRule(); } return _localctx; @@ -13501,6 +13755,7 @@ public ScopeBlockContext scopeBlock() { } public partial class SehBlockContext : ParserRuleContext { + public int InitialSyntaxErrorCount; public TryBlockContext tryRange; public SehClausesContext clauses; [System.Diagnostics.DebuggerNonUserCode] public TryBlockContext tryBlock() { @@ -13520,7 +13775,7 @@ public SehBlockContext(ParserRuleContext parent, int invokingState) public SehBlockContext sehBlock() { SehBlockContext _localctx = new SehBlockContext(Context, State); EnterRule(_localctx, 268, RULE_sehBlock); - Actions.BeginExceptionBlock(_localctx); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; try { EnterOuterAlt(_localctx, 1); { @@ -13536,14 +13791,15 @@ public SehBlockContext sehBlock() { ErrorHandler.Recover(this, re); } finally { - Actions.EndExceptionBlock(_localctx); + Actions.EndExceptionBlock(_localctx, _localctx.InitialSyntaxErrorCount); ExitRule(); } return _localctx; } public partial class SehClausesContext : ParserRuleContext { - public object Value; + public System.Collections.Immutable.ImmutableArray Value; + public System.Collections.Immutable.ImmutableArray.Builder Builder; public SehClauseContext clause; [System.Diagnostics.DebuggerNonUserCode] public SehClauseContext[] sehClause() { return GetRuleContexts(); @@ -13562,7 +13818,7 @@ public SehClausesContext(ParserRuleContext parent, int invokingState) public SehClausesContext sehClauses() { SehClausesContext _localctx = new SehClausesContext(Context, State); EnterRule(_localctx, 270, RULE_sehClauses); - Actions.BeginExceptionClauses(_localctx); + _localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -13575,7 +13831,7 @@ public SehClausesContext sehClauses() { { State = 2899; _localctx.clause = sehClause(); - Actions.AddExceptionClause(_localctx, _localctx.clause.Value); + _localctx.Builder.Add(_localctx.clause.Value); } } State = 2904; @@ -13590,14 +13846,14 @@ public SehClausesContext sehClauses() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndExceptionClauses(_localctx); + _localctx.Value = _localctx.Builder.ToImmutable(); ExitRule(); } return _localctx; } public partial class TryBlockContext : ParserRuleContext { - public object Value; + public CILParser.ExceptionRangeValue Value; public ScopeBlockContext body; public IdContext startLabel; public IdContext endLabel; @@ -13629,6 +13885,7 @@ public TryBlockContext(ParserRuleContext parent, int invokingState) public TryBlockContext tryBlock() { TryBlockContext _localctx = new TryBlockContext(Context, State); EnterRule(_localctx, 272, RULE_tryBlock); + _localctx.Value = CILParser.ExceptionRangeValue.Invalid; try { State = 2922; ErrorHandler.Sync(this); @@ -13685,7 +13942,7 @@ public TryBlockContext tryBlock() { } public partial class SehClauseContext : ParserRuleContext { - public object Value; + public CILParser.ExceptionClauseValue Value; public CatchClauseContext caught; public HandlerBlockContext handler; public FilterClauseContext filtered; @@ -13715,6 +13972,7 @@ public SehClauseContext(ParserRuleContext parent, int invokingState) public SehClauseContext sehClause() { SehClauseContext _localctx = new SehClauseContext(Context, State); EnterRule(_localctx, 274, RULE_sehClause); + _localctx.Value = CILParser.ExceptionClauseValue.Invalid; try { State = 2940; ErrorHandler.Sync(this); @@ -13775,7 +14033,7 @@ public SehClauseContext sehClause() { } public partial class FilterClauseContext : ParserRuleContext { - public object Value; + public CILParser.ExceptionFilterValue Value; public ScopeBlockContext body; public IdContext label; public Int32Context offset; @@ -13799,6 +14057,7 @@ public FilterClauseContext(ParserRuleContext parent, int invokingState) public FilterClauseContext filterClause() { FilterClauseContext _localctx = new FilterClauseContext(Context, State); EnterRule(_localctx, 276, RULE_filterClause); + _localctx.Value = CILParser.ExceptionFilterValue.Invalid; try { State = 2954; ErrorHandler.Sync(this); @@ -13847,7 +14106,8 @@ public FilterClauseContext filterClause() { } public partial class CatchClauseContext : ParserRuleContext { - public object Value; + public CILParser.CatchTypeValue Value; + public int InitialSyntaxErrorCount; public TypeSpecContext catchType; [System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() { return GetRuleContext(0); @@ -13863,7 +14123,10 @@ public CatchClauseContext(ParserRuleContext parent, int invokingState) public CatchClauseContext catchClause() { CatchClauseContext _localctx = new CatchClauseContext(Context, State); EnterRule(_localctx, 278, RULE_catchClause); - Actions.BeginCatchClause(_localctx); + + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.CatchTypeValue.Invalid; + try { EnterOuterAlt(_localctx, 1); { @@ -13879,7 +14142,7 @@ public CatchClauseContext catchClause() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndCatchClause(_localctx); + _localctx.Value = Actions.EndCatchClause(_localctx, _localctx.InitialSyntaxErrorCount); ExitRule(); } return _localctx; @@ -13946,7 +14209,7 @@ public FaultClauseContext faultClause() { } public partial class HandlerBlockContext : ParserRuleContext { - public object Value; + public CILParser.ExceptionRangeValue Value; public ScopeBlockContext body; public IdContext startLabel; public IdContext endLabel; @@ -13978,6 +14241,7 @@ public HandlerBlockContext(ParserRuleContext parent, int invokingState) public HandlerBlockContext handlerBlock() { HandlerBlockContext _localctx = new HandlerBlockContext(Context, State); EnterRule(_localctx, 284, RULE_handlerBlock); + _localctx.Value = CILParser.ExceptionRangeValue.Invalid; try { State = 2978; ErrorHandler.Sync(this); @@ -14033,6 +14297,8 @@ public HandlerBlockContext handlerBlock() { public partial class DataDeclContext : ParserRuleContext { public bool HasSyntaxError; + public int InitialSyntaxErrorCount; + public CILParser.DataDeclarationBuilder Builder; [System.Diagnostics.DebuggerNonUserCode] public DdHeadContext ddHead() { return GetRuleContext(0); } @@ -14050,14 +14316,17 @@ public DataDeclContext(ParserRuleContext parent, int invokingState) public DataDeclContext dataDecl() { DataDeclContext _localctx = new DataDeclContext(Context, State); EnterRule(_localctx, 286, RULE_dataDecl); - Actions.BeginDataDeclaration(_localctx); + + _localctx.Builder = Actions.CreateDataDeclaration(_localctx); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + try { EnterOuterAlt(_localctx, 1); { State = 2980; - ddHead(); + ddHead(_localctx.Builder); State = 2981; - ddBody(); + ddBody(_localctx.Builder); } } catch (RecognitionException re) { @@ -14066,13 +14335,14 @@ public DataDeclContext dataDecl() { ErrorHandler.Recover(this, re); } finally { - Actions.EndDataDeclaration(_localctx); + Actions.EndDataDeclaration(_localctx, _localctx.Builder, _localctx.InitialSyntaxErrorCount); ExitRule(); } return _localctx; } public partial class DdHeadContext : ParserRuleContext { + public CILParser.DataDeclarationBuilder Builder; public TlsContext section; public IdContext name; [System.Diagnostics.DebuggerNonUserCode] public TlsContext tls() { @@ -14081,16 +14351,18 @@ [System.Diagnostics.DebuggerNonUserCode] public TlsContext tls() { [System.Diagnostics.DebuggerNonUserCode] public IdContext id() { return GetRuleContext(0); } - public DdHeadContext(ParserRuleContext parent, int invokingState) + public DdHeadContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { } + public DdHeadContext(ParserRuleContext parent, int invokingState, CILParser.DataDeclarationBuilder Builder) : base(parent, invokingState) { + this.Builder = Builder; } public override int RuleIndex { get { return RULE_ddHead; } } } [RuleVersion(0)] - public DdHeadContext ddHead() { - DdHeadContext _localctx = new DdHeadContext(Context, State); + public DdHeadContext ddHead(CILParser.DataDeclarationBuilder Builder) { + DdHeadContext _localctx = new DdHeadContext(Context, State, Builder); EnterRule(_localctx, 288, RULE_ddHead); try { State = 2993; @@ -14107,7 +14379,7 @@ public DdHeadContext ddHead() { _localctx.name = id(); State = 2986; Match(T__35); - Actions.SetDataDeclarationHeader(_localctx, _localctx.section.Value, (_localctx.name!=null?(_localctx.name.Start):null)); + Actions.SetDataDeclarationHeader(_localctx.Builder, _localctx.section.Value, (_localctx.name!=null?(_localctx.name.Start):null)); } break; case 2: @@ -14117,7 +14389,7 @@ public DdHeadContext ddHead() { Match(T__164); State = 2990; _localctx.section = tls(); - Actions.SetAnonymousDataDeclarationHeader(_localctx, _localctx.section.Value); + Actions.SetAnonymousDataDeclarationHeader(_localctx.Builder, _localctx.section.Value); } break; } @@ -14186,6 +14458,7 @@ public TlsContext tls() { } public partial class DdBodyContext : ParserRuleContext { + public CILParser.DataDeclarationBuilder Builder; [System.Diagnostics.DebuggerNonUserCode] public DdItemListContext ddItemList() { return GetRuleContext(0); } @@ -14195,16 +14468,18 @@ [System.Diagnostics.DebuggerNonUserCode] public DdItemContext[] ddItem() { [System.Diagnostics.DebuggerNonUserCode] public DdItemContext ddItem(int i) { return GetRuleContext(i); } - public DdBodyContext(ParserRuleContext parent, int invokingState) + public DdBodyContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { } + public DdBodyContext(ParserRuleContext parent, int invokingState, CILParser.DataDeclarationBuilder Builder) : base(parent, invokingState) { + this.Builder = Builder; } public override int RuleIndex { get { return RULE_ddBody; } } } [RuleVersion(0)] - public DdBodyContext ddBody() { - DdBodyContext _localctx = new DdBodyContext(Context, State); + public DdBodyContext ddBody(CILParser.DataDeclarationBuilder Builder) { + DdBodyContext _localctx = new DdBodyContext(Context, State, Builder); EnterRule(_localctx, 292, RULE_ddBody); int _la; try { @@ -14217,7 +14492,7 @@ public DdBodyContext ddBody() { State = 3002; Match(T__16); State = 3003; - ddItemList(); + ddItemList(_localctx.Builder); State = 3004; Match(T__17); } @@ -14240,7 +14515,7 @@ public DdBodyContext ddBody() { { { State = 3006; - ddItem(); + ddItem(_localctx.Builder); } } State = 3009; @@ -14265,22 +14540,25 @@ public DdBodyContext ddBody() { } public partial class DdItemListContext : ParserRuleContext { + public CILParser.DataDeclarationBuilder Builder; [System.Diagnostics.DebuggerNonUserCode] public DdItemContext[] ddItem() { return GetRuleContexts(); } [System.Diagnostics.DebuggerNonUserCode] public DdItemContext ddItem(int i) { return GetRuleContext(i); } - public DdItemListContext(ParserRuleContext parent, int invokingState) + public DdItemListContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { } + public DdItemListContext(ParserRuleContext parent, int invokingState, CILParser.DataDeclarationBuilder Builder) : base(parent, invokingState) { + this.Builder = Builder; } public override int RuleIndex { get { return RULE_ddItemList; } } } [RuleVersion(0)] - public DdItemListContext ddItemList() { - DdItemListContext _localctx = new DdItemListContext(Context, State); + public DdItemListContext ddItemList(CILParser.DataDeclarationBuilder Builder) { + DdItemListContext _localctx = new DdItemListContext(Context, State, Builder); EnterRule(_localctx, 294, RULE_ddItemList); try { int _alt; @@ -14294,7 +14572,7 @@ public DdItemListContext ddItemList() { { { State = 3013; - ddItem(); + ddItem(_localctx.Builder); State = 3014; Match(T__27); } @@ -14305,7 +14583,7 @@ public DdItemListContext ddItemList() { _alt = Interpreter.AdaptivePredict(TokenStream,149,Context); } State = 3021; - ddItem(); + ddItem(_localctx.Builder); } } catch (RecognitionException re) { @@ -14467,6 +14745,7 @@ public DdItemCountContext ddItemCount() { } public partial class DdItemContext : ParserRuleContext { + public CILParser.DataDeclarationBuilder Builder; public CompQstringContext stringValue; public IdContext target; public BytesContext byteValue; @@ -14505,16 +14784,18 @@ [System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() { [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT32_() { return GetToken(CILParser.INT32_, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT16() { return GetToken(CILParser.INT16, 0); } [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT8() { return GetToken(CILParser.INT8, 0); } - public DdItemContext(ParserRuleContext parent, int invokingState) + public DdItemContext(ParserRuleContext parent, int invokingState) : base(parent, invokingState) { } + public DdItemContext(ParserRuleContext parent, int invokingState, CILParser.DataDeclarationBuilder Builder) : base(parent, invokingState) { + this.Builder = Builder; } public override int RuleIndex { get { return RULE_ddItem; } } } [RuleVersion(0)] - public DdItemContext ddItem() { - DdItemContext _localctx = new DdItemContext(Context, State); + public DdItemContext ddItem(CILParser.DataDeclarationBuilder Builder) { + DdItemContext _localctx = new DdItemContext(Context, State, Builder); EnterRule(_localctx, 298, RULE_ddItem); int _la; try { @@ -14534,7 +14815,7 @@ public DdItemContext ddItem() { _localctx.stringValue = compQstring(); State = 3035; Match(T__30); - Actions.AddDataString(_localctx, _localctx.stringValue.Value); + Actions.AddDataString(_localctx.Builder, _localctx.stringValue.Value); } break; case 2: @@ -14548,7 +14829,7 @@ public DdItemContext ddItem() { _localctx.target = id(); State = 3041; Match(T__30); - Actions.AddDataReference(_localctx, (_localctx.target!=null?(_localctx.target.Start):null)); + Actions.AddDataReference(_localctx.Builder, (_localctx.target!=null?(_localctx.target.Start):null)); } break; case 3: @@ -14558,7 +14839,7 @@ public DdItemContext ddItem() { Match(REF); State = 3045; _localctx.target = id(); - Actions.AddDataReference(_localctx, (_localctx.target!=null?(_localctx.target.Start):null)); + Actions.AddDataReference(_localctx.Builder, (_localctx.target!=null?(_localctx.target.Start):null)); } break; case 4: @@ -14572,7 +14853,7 @@ public DdItemContext ddItem() { _localctx.byteValue = bytes(); State = 3051; Match(T__30); - Actions.AddDataBytes(_localctx, _localctx.byteValue.Value); + Actions.AddDataBytes(_localctx.Builder, _localctx.byteValue.Value); } break; case 5: @@ -14596,7 +14877,7 @@ public DdItemContext ddItem() { Match(T__30); State = 3058; _localctx.count = ddItemCount(); - Actions.AddFloatingPointData(_localctx, _localctx.kind, _localctx.floatingValue.Value, _localctx.count.Value); + Actions.AddFloatingPointData(_localctx.Builder, _localctx.kind, _localctx.floatingValue.Value, _localctx.count.Value); } break; case 6: @@ -14612,7 +14893,7 @@ public DdItemContext ddItem() { Match(T__30); State = 3065; _localctx.count = ddItemCount(); - Actions.AddInt64Data(_localctx, _localctx.kind, (_localctx.int64Value!=null?(_localctx.int64Value.Start):null), _localctx.count.Value); + Actions.AddInt64Data(_localctx.Builder, _localctx.kind, (_localctx.int64Value!=null?(_localctx.int64Value.Start):null), _localctx.count.Value); } break; case 7: @@ -14636,7 +14917,7 @@ public DdItemContext ddItem() { Match(T__30); State = 3072; _localctx.count = ddItemCount(); - Actions.AddIntegerData(_localctx, _localctx.kind, (_localctx.integerValue!=null?(_localctx.integerValue.Start):null), _localctx.count.Value); + Actions.AddIntegerData(_localctx.Builder, _localctx.kind, (_localctx.integerValue!=null?(_localctx.integerValue.Start):null), _localctx.count.Value); } break; case 8: @@ -14654,7 +14935,7 @@ public DdItemContext ddItem() { } State = 3076; _localctx.count = ddItemCount(); - Actions.AddZeroData(_localctx, _localctx.kind, _localctx.count.Value); + Actions.AddZeroData(_localctx.Builder, _localctx.kind, _localctx.count.Value); } break; } @@ -14965,6 +15246,7 @@ public FieldSerInitContext fieldSerInit() { public partial class BytesContext : ParserRuleContext { public System.Collections.Immutable.ImmutableArray Value; + public System.Collections.Immutable.ImmutableArray.Builder Builder; public HexbyteContext b; [System.Diagnostics.DebuggerNonUserCode] public HexbyteContext[] hexbyte() { return GetRuleContexts(); @@ -14983,7 +15265,7 @@ public BytesContext(ParserRuleContext parent, int invokingState) public BytesContext bytes() { BytesContext _localctx = new BytesContext(Context, State); EnterRule(_localctx, 302, RULE_bytes); - Actions.BeginBytes(); + _localctx.Builder = Actions.CreateByteAccumulator(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -14996,7 +15278,7 @@ public BytesContext bytes() { { State = 3173; _localctx.b = hexbyte(); - Actions.AddByte(_localctx.b.Value); + Actions.AddByte(_localctx.Builder, _localctx.b.Value); } } State = 3180; @@ -15011,7 +15293,7 @@ public BytesContext bytes() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndBytes(); + _localctx.Value = Actions.EndBytes(_localctx.Builder); ExitRule(); } return _localctx; @@ -15062,7 +15344,7 @@ public HexbyteContext hexbyte() { } public partial class FieldInitContext : ParserRuleContext { - public object Value; + public CILParser.FieldInitializerValue Value; public FieldSerInitContext serializedValue; public CompQstringContext stringValue; [System.Diagnostics.DebuggerNonUserCode] public FieldSerInitContext fieldSerInit() { @@ -15083,6 +15365,7 @@ public FieldInitContext(ParserRuleContext parent, int invokingState) public FieldInitContext fieldInit() { FieldInitContext _localctx = new FieldInitContext(Context, State); EnterRule(_localctx, 306, RULE_fieldInit); + _localctx.Value = CILParser.FieldInitializerValue.Empty; try { State = 3191; ErrorHandler.Sync(this); @@ -15139,7 +15422,7 @@ public FieldInitContext fieldInit() { } public partial class SerInitContext : ParserRuleContext { - public object Value; + public CILParser.SerializedInitializerValue Value; public FieldSerInitContext scalarValue; public IToken stringToken; public IToken typeToken; @@ -15260,6 +15543,7 @@ public SerInitContext(ParserRuleContext parent, int invokingState) public SerInitContext serInit() { SerInitContext _localctx = new SerInitContext(Context, State); EnterRule(_localctx, 308, RULE_serInit); + _localctx.Value = CILParser.SerializedInitializerValue.Error; try { State = 3364; ErrorHandler.Sync(this); @@ -15673,6 +15957,7 @@ public SerInitContext serInit() { public partial class F32seqContext : ParserRuleContext { public System.Reflection.Metadata.BlobBuilder Value; + public System.Reflection.Metadata.BlobBuilder Builder; public Float64Context floatingValue; public Int32Context integerValue; [System.Diagnostics.DebuggerNonUserCode] public Float64Context[] float64() { @@ -15698,7 +15983,7 @@ public F32seqContext(ParserRuleContext parent, int invokingState) public F32seqContext f32seq() { F32seqContext _localctx = new F32seqContext(Context, State); EnterRule(_localctx, 310, RULE_f32seq); - Actions.BeginSerializationSequence(_localctx); + _localctx.Builder = new System.Reflection.Metadata.BlobBuilder(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -15715,14 +16000,14 @@ public F32seqContext f32seq() { { State = 3366; _localctx.floatingValue = float64(); - Actions.AddFloat32SequenceValue(_localctx, _localctx.floatingValue.Value); + Actions.AddFloat32SequenceValue(_localctx.Builder, _localctx.floatingValue.Value); } break; case 2: { State = 3369; _localctx.integerValue = int32(); - Actions.AddFloat32SequenceValue(_localctx, (_localctx.integerValue!=null?(_localctx.integerValue.Start):null)); + Actions.AddFloat32SequenceValue(_localctx.Builder, (_localctx.integerValue!=null?(_localctx.integerValue.Start):null)); } break; } @@ -15739,7 +16024,7 @@ public F32seqContext f32seq() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndSerializationSequence(_localctx); + _localctx.Value = _localctx.Builder; ExitRule(); } return _localctx; @@ -15747,6 +16032,7 @@ public F32seqContext f32seq() { public partial class F64seqContext : ParserRuleContext { public System.Reflection.Metadata.BlobBuilder Value; + public System.Reflection.Metadata.BlobBuilder Builder; public Float64Context floatingValue; public Int64Context integerValue; [System.Diagnostics.DebuggerNonUserCode] public Float64Context[] float64() { @@ -15772,7 +16058,7 @@ public F64seqContext(ParserRuleContext parent, int invokingState) public F64seqContext f64seq() { F64seqContext _localctx = new F64seqContext(Context, State); EnterRule(_localctx, 312, RULE_f64seq); - Actions.BeginSerializationSequence(_localctx); + _localctx.Builder = new System.Reflection.Metadata.BlobBuilder(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -15789,14 +16075,14 @@ public F64seqContext f64seq() { { State = 3377; _localctx.floatingValue = float64(); - Actions.AddFloat64SequenceValue(_localctx, _localctx.floatingValue.Value); + Actions.AddFloat64SequenceValue(_localctx.Builder, _localctx.floatingValue.Value); } break; case 2: { State = 3380; _localctx.integerValue = int64(); - Actions.AddFloat64SequenceValue(_localctx, (_localctx.integerValue!=null?(_localctx.integerValue.Start):null)); + Actions.AddFloat64SequenceValue(_localctx.Builder, (_localctx.integerValue!=null?(_localctx.integerValue.Start):null)); } break; } @@ -15813,7 +16099,7 @@ public F64seqContext f64seq() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndSerializationSequence(_localctx); + _localctx.Value = _localctx.Builder; ExitRule(); } return _localctx; @@ -15821,6 +16107,7 @@ public F64seqContext f64seq() { public partial class I64seqContext : ParserRuleContext { public System.Reflection.Metadata.BlobBuilder Value; + public System.Reflection.Metadata.BlobBuilder Builder; public Int64Context value; [System.Diagnostics.DebuggerNonUserCode] public Int64Context[] int64() { return GetRuleContexts(); @@ -15839,7 +16126,7 @@ public I64seqContext(ParserRuleContext parent, int invokingState) public I64seqContext i64seq() { I64seqContext _localctx = new I64seqContext(Context, State); EnterRule(_localctx, 314, RULE_i64seq); - Actions.BeginSerializationSequence(_localctx); + _localctx.Builder = new System.Reflection.Metadata.BlobBuilder(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -15852,7 +16139,7 @@ public I64seqContext i64seq() { { State = 3388; _localctx.value = int64(); - Actions.AddInt64SequenceValue(_localctx, (_localctx.value!=null?(_localctx.value.Start):null)); + Actions.AddInt64SequenceValue(_localctx.Builder, (_localctx.value!=null?(_localctx.value.Start):null)); } } State = 3395; @@ -15867,7 +16154,7 @@ public I64seqContext i64seq() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndSerializationSequence(_localctx); + _localctx.Value = _localctx.Builder; ExitRule(); } return _localctx; @@ -15875,6 +16162,7 @@ public I64seqContext i64seq() { public partial class I32seqContext : ParserRuleContext { public System.Reflection.Metadata.BlobBuilder Value; + public System.Reflection.Metadata.BlobBuilder Builder; public Int32Context value; [System.Diagnostics.DebuggerNonUserCode] public Int32Context[] int32() { return GetRuleContexts(); @@ -15893,7 +16181,7 @@ public I32seqContext(ParserRuleContext parent, int invokingState) public I32seqContext i32seq() { I32seqContext _localctx = new I32seqContext(Context, State); EnterRule(_localctx, 316, RULE_i32seq); - Actions.BeginSerializationSequence(_localctx); + _localctx.Builder = new System.Reflection.Metadata.BlobBuilder(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -15906,7 +16194,7 @@ public I32seqContext i32seq() { { State = 3396; _localctx.value = int32(); - Actions.AddInt32SequenceValue(_localctx, (_localctx.value!=null?(_localctx.value.Start):null)); + Actions.AddInt32SequenceValue(_localctx.Builder, (_localctx.value!=null?(_localctx.value.Start):null)); } } State = 3403; @@ -15921,7 +16209,7 @@ public I32seqContext i32seq() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndSerializationSequence(_localctx); + _localctx.Value = _localctx.Builder; ExitRule(); } return _localctx; @@ -15929,6 +16217,7 @@ public I32seqContext i32seq() { public partial class I16seqContext : ParserRuleContext { public System.Reflection.Metadata.BlobBuilder Value; + public System.Reflection.Metadata.BlobBuilder Builder; public Int32Context value; [System.Diagnostics.DebuggerNonUserCode] public Int32Context[] int32() { return GetRuleContexts(); @@ -15947,7 +16236,7 @@ public I16seqContext(ParserRuleContext parent, int invokingState) public I16seqContext i16seq() { I16seqContext _localctx = new I16seqContext(Context, State); EnterRule(_localctx, 318, RULE_i16seq); - Actions.BeginSerializationSequence(_localctx); + _localctx.Builder = new System.Reflection.Metadata.BlobBuilder(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -15960,7 +16249,7 @@ public I16seqContext i16seq() { { State = 3404; _localctx.value = int32(); - Actions.AddInt16SequenceValue(_localctx, (_localctx.value!=null?(_localctx.value.Start):null)); + Actions.AddInt16SequenceValue(_localctx.Builder, (_localctx.value!=null?(_localctx.value.Start):null)); } } State = 3411; @@ -15975,7 +16264,7 @@ public I16seqContext i16seq() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndSerializationSequence(_localctx); + _localctx.Value = _localctx.Builder; ExitRule(); } return _localctx; @@ -15983,6 +16272,7 @@ public I16seqContext i16seq() { public partial class I8seqContext : ParserRuleContext { public System.Reflection.Metadata.BlobBuilder Value; + public System.Reflection.Metadata.BlobBuilder Builder; public Int32Context value; [System.Diagnostics.DebuggerNonUserCode] public Int32Context[] int32() { return GetRuleContexts(); @@ -16001,7 +16291,7 @@ public I8seqContext(ParserRuleContext parent, int invokingState) public I8seqContext i8seq() { I8seqContext _localctx = new I8seqContext(Context, State); EnterRule(_localctx, 320, RULE_i8seq); - Actions.BeginSerializationSequence(_localctx); + _localctx.Builder = new System.Reflection.Metadata.BlobBuilder(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -16014,7 +16304,7 @@ public I8seqContext i8seq() { { State = 3412; _localctx.value = int32(); - Actions.AddInt8SequenceValue(_localctx, (_localctx.value!=null?(_localctx.value.Start):null)); + Actions.AddInt8SequenceValue(_localctx.Builder, (_localctx.value!=null?(_localctx.value.Start):null)); } } State = 3419; @@ -16029,7 +16319,7 @@ public I8seqContext i8seq() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndSerializationSequence(_localctx); + _localctx.Value = _localctx.Builder; ExitRule(); } return _localctx; @@ -16037,6 +16327,7 @@ public I8seqContext i8seq() { public partial class BoolSeqContext : ParserRuleContext { public System.Reflection.Metadata.BlobBuilder Value; + public System.Reflection.Metadata.BlobBuilder Builder; public TruefalseContext value; [System.Diagnostics.DebuggerNonUserCode] public TruefalseContext[] truefalse() { return GetRuleContexts(); @@ -16055,7 +16346,7 @@ public BoolSeqContext(ParserRuleContext parent, int invokingState) public BoolSeqContext boolSeq() { BoolSeqContext _localctx = new BoolSeqContext(Context, State); EnterRule(_localctx, 322, RULE_boolSeq); - Actions.BeginSerializationSequence(_localctx); + _localctx.Builder = new System.Reflection.Metadata.BlobBuilder(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -16068,7 +16359,7 @@ public BoolSeqContext boolSeq() { { State = 3420; _localctx.value = truefalse(); - Actions.AddBooleanSequenceValue(_localctx, _localctx.value.Value); + Actions.AddBooleanSequenceValue(_localctx.Builder, _localctx.value.Value); } } State = 3427; @@ -16083,7 +16374,7 @@ public BoolSeqContext boolSeq() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndSerializationSequence(_localctx); + _localctx.Value = _localctx.Builder; ExitRule(); } return _localctx; @@ -16091,6 +16382,7 @@ public BoolSeqContext boolSeq() { public partial class SqstringSeqContext : ParserRuleContext { public System.Reflection.Metadata.BlobBuilder Value; + public System.Reflection.Metadata.BlobBuilder Builder; public IToken nullValue; public IToken stringValue; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] NULLREF() { return GetTokens(CILParser.NULLREF); } @@ -16112,7 +16404,7 @@ public SqstringSeqContext(ParserRuleContext parent, int invokingState) public SqstringSeqContext sqstringSeq() { SqstringSeqContext _localctx = new SqstringSeqContext(Context, State); EnterRule(_localctx, 324, RULE_sqstringSeq); - Actions.BeginSerializationSequence(_localctx); + _localctx.Builder = new System.Reflection.Metadata.BlobBuilder(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -16129,14 +16421,14 @@ public SqstringSeqContext sqstringSeq() { { State = 3428; _localctx.nullValue = Match(NULLREF); - Actions.AddStringSequenceValue(_localctx, _localctx.nullValue); + Actions.AddStringSequenceValue(_localctx.Builder, _localctx.nullValue); } break; case SQSTRING: { State = 3430; _localctx.stringValue = Match(SQSTRING); - Actions.AddStringSequenceValue(_localctx, _localctx.stringValue); + Actions.AddStringSequenceValue(_localctx.Builder, _localctx.stringValue); } break; default: @@ -16155,14 +16447,15 @@ public SqstringSeqContext sqstringSeq() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndSerializationSequence(_localctx); + _localctx.Value = _localctx.Builder; ExitRule(); } return _localctx; } public partial class ClassSeqContext : ParserRuleContext { - public object Value; + public CILParser.SerializedSequenceValue Value; + public System.Collections.Immutable.ImmutableArray.Builder Builder; public ClassSeqElementContext value; [System.Diagnostics.DebuggerNonUserCode] public ClassSeqElementContext[] classSeqElement() { return GetRuleContexts(); @@ -16181,7 +16474,7 @@ public ClassSeqContext(ParserRuleContext parent, int invokingState) public ClassSeqContext classSeq() { ClassSeqContext _localctx = new ClassSeqContext(Context, State); EnterRule(_localctx, 326, RULE_classSeq); - Actions.BeginSerializationSequence(_localctx); + _localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -16194,7 +16487,7 @@ public ClassSeqContext classSeq() { { State = 3437; _localctx.value = classSeqElement(); - Actions.AddClassSequenceValue(_localctx, _localctx.value.Value); + _localctx.Builder.Add(_localctx.value.Value); } } State = 3444; @@ -16209,14 +16502,14 @@ public ClassSeqContext classSeq() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndClassSerializationSequence(_localctx); + _localctx.Value = new CILParser.ClassSerializedSequenceValue(_localctx.Builder.ToImmutable()); ExitRule(); } return _localctx; } public partial class ClassSeqElementContext : ParserRuleContext { - public object Value; + public CILParser.ClassSequenceElementValue Value; public IToken quotedValue; public ClassNameContext typeValue; [System.Diagnostics.DebuggerNonUserCode] public ITerminalNode NULLREF() { return GetToken(CILParser.NULLREF, 0); } @@ -16235,6 +16528,7 @@ public ClassSeqElementContext(ParserRuleContext parent, int invokingState) public ClassSeqElementContext classSeqElement() { ClassSeqElementContext _localctx = new ClassSeqElementContext(Context, State); EnterRule(_localctx, 328, RULE_classSeqElement); + _localctx.Value = CILParser.ClassSequenceElementValue.Error; try { State = 3453; ErrorHandler.Sync(this); @@ -16291,7 +16585,8 @@ public ClassSeqElementContext classSeqElement() { } public partial class ObjSeqContext : ParserRuleContext { - public object Value; + public CILParser.SerializedSequenceValue Value; + public System.Collections.Immutable.ImmutableArray.Builder Builder; public SerInitContext value; [System.Diagnostics.DebuggerNonUserCode] public SerInitContext[] serInit() { return GetRuleContexts(); @@ -16310,7 +16605,7 @@ public ObjSeqContext(ParserRuleContext parent, int invokingState) public ObjSeqContext objSeq() { ObjSeqContext _localctx = new ObjSeqContext(Context, State); EnterRule(_localctx, 330, RULE_objSeq); - Actions.BeginSerializationSequence(_localctx); + _localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -16323,7 +16618,7 @@ public ObjSeqContext objSeq() { { State = 3455; _localctx.value = serInit(); - Actions.AddObjectSequenceValue(_localctx, _localctx.value.Value); + _localctx.Builder.Add(_localctx.value.Value); } } State = 3462; @@ -16338,15 +16633,16 @@ public ObjSeqContext objSeq() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndObjectSerializationSequence(_localctx); + _localctx.Value = new CILParser.ObjectSerializedSequenceValue(_localctx.Builder.ToImmutable()); ExitRule(); } return _localctx; } public partial class CustomAttrDeclContext : ParserRuleContext { - public object Value; + public CILParser.CustomAttributeDeclarationValue Value; public bool HasSyntaxError; + public int InitialSyntaxErrorCount; public CustomDescrContext directAttribute; public CustomDescrWithOwnerContext ownedAttribute; public DottedNameContext alias; @@ -16370,7 +16666,10 @@ public CustomAttrDeclContext(ParserRuleContext parent, int invokingState) public CustomAttrDeclContext customAttrDecl() { CustomAttrDeclContext _localctx = new CustomAttrDeclContext(Context, State); EnterRule(_localctx, 332, RULE_customAttrDecl); - Actions.BeginSemanticRoot(_localctx); + + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; + _localctx.Value = CILParser.CustomAttributeDeclarationValue.Error; + try { State = 3472; ErrorHandler.Sync(this); @@ -16407,14 +16706,18 @@ public CustomAttrDeclContext customAttrDecl() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); + + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; + ExitRule(); } return _localctx; } public partial class AsmOrRefDeclContext : ParserRuleContext { - public object Value; + public CILParser.AssemblyDeclarationValue? Value; public BytesContext key; public IntOrWildcardContext major; public IntOrWildcardContext minor; @@ -16563,8 +16866,9 @@ public AsmOrRefDeclContext asmOrRefDecl() { } public partial class AssemblyRefBlockContext : ParserRuleContext { - public object Value; + public CILParser.AssemblyReferenceValue? Value; public bool HasSyntaxError; + public int InitialSyntaxErrorCount; public AssemblyRefHeadContext header; public AssemblyRefDeclsContext declarations; [System.Diagnostics.DebuggerNonUserCode] public AssemblyRefHeadContext assemblyRefHead() { @@ -16584,7 +16888,7 @@ public AssemblyRefBlockContext(ParserRuleContext parent, int invokingState) public AssemblyRefBlockContext assemblyRefBlock() { AssemblyRefBlockContext _localctx = new AssemblyRefBlockContext(Context, State); EnterRule(_localctx, 336, RULE_assemblyRefBlock); - Actions.BeginSemanticRoot(_localctx); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; try { EnterOuterAlt(_localctx, 1); { @@ -16607,14 +16911,22 @@ public AssemblyRefBlockContext assemblyRefBlock() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); + + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; + if (_localctx.HasSyntaxError) + { + _localctx.Value = null; + } + ExitRule(); } return _localctx; } public partial class AssemblyRefHeadContext : ParserRuleContext { - public object Value; + public CILParser.AssemblyReferenceHeaderValue Value; public AsmAttrContext attributes; public DottedNameContext name; public DottedNameContext alias; @@ -16638,6 +16950,7 @@ public AssemblyRefHeadContext(ParserRuleContext parent, int invokingState) public AssemblyRefHeadContext assemblyRefHead() { AssemblyRefHeadContext _localctx = new AssemblyRefHeadContext(Context, State); EnterRule(_localctx, 338, RULE_assemblyRefHead); + _localctx.Value = CILParser.AssemblyReferenceHeaderValue.Error; try { State = 3528; ErrorHandler.Sync(this); @@ -16694,7 +17007,8 @@ public AssemblyRefHeadContext assemblyRefHead() { } public partial class AssemblyRefDeclsContext : ParserRuleContext { - public object Value; + public System.Collections.Immutable.ImmutableArray Value; + public System.Collections.Immutable.ImmutableArray.Builder Builder; public AssemblyRefDeclContext declaration; [System.Diagnostics.DebuggerNonUserCode] public AssemblyRefDeclContext[] assemblyRefDecl() { return GetRuleContexts(); @@ -16713,7 +17027,7 @@ public AssemblyRefDeclsContext(ParserRuleContext parent, int invokingState) public AssemblyRefDeclsContext assemblyRefDecls() { AssemblyRefDeclsContext _localctx = new AssemblyRefDeclsContext(Context, State); EnterRule(_localctx, 340, RULE_assemblyRefDecls); - Actions.BeginAssemblyReferenceDeclarations(_localctx); + _localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -16726,7 +17040,7 @@ public AssemblyRefDeclsContext assemblyRefDecls() { { State = 3530; _localctx.declaration = assemblyRefDecl(); - Actions.AddAssemblyReferenceDeclaration(_localctx, _localctx.declaration.Value); + if (_localctx.declaration.Value is not null) _localctx.Builder.Add(_localctx.declaration.Value); } } State = 3537; @@ -16741,14 +17055,14 @@ public AssemblyRefDeclsContext assemblyRefDecls() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndAssemblyReferenceDeclarations(_localctx); + _localctx.Value = _localctx.Builder.ToImmutable(); ExitRule(); } return _localctx; } public partial class AssemblyRefDeclContext : ParserRuleContext { - public object Value; + public CILParser.AssemblyDeclarationValue? Value; public BytesContext hash; public AsmOrRefDeclContext shared; public BytesContext token; @@ -16856,8 +17170,9 @@ public AssemblyRefDeclContext assemblyRefDecl() { } public partial class ExptypeBlockContext : ParserRuleContext { - public object Value; + public CILParser.ExportedTypeValue? Value; public bool HasSyntaxError; + public int InitialSyntaxErrorCount; public ExptypeHeadContext header; public ExptypeDeclsContext declarations; [System.Diagnostics.DebuggerNonUserCode] public ExptypeHeadContext exptypeHead() { @@ -16877,7 +17192,7 @@ public ExptypeBlockContext(ParserRuleContext parent, int invokingState) public ExptypeBlockContext exptypeBlock() { ExptypeBlockContext _localctx = new ExptypeBlockContext(Context, State); EnterRule(_localctx, 344, RULE_exptypeBlock); - Actions.BeginSemanticRoot(_localctx); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; try { EnterOuterAlt(_localctx, 1); { @@ -16891,8 +17206,7 @@ public ExptypeBlockContext exptypeBlock() { Match(T__17); _localctx.Value = Actions.CreateExportedType( _localctx.header.Value, - _localctx.declarations.Value, - (_localctx.header!=null?(_localctx.header.Start):null)); + _localctx.declarations.Value); } } catch (RecognitionException re) { @@ -16901,14 +17215,22 @@ public ExptypeBlockContext exptypeBlock() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); + + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; + if (_localctx.HasSyntaxError) + { + _localctx.Value = null; + } + ExitRule(); } return _localctx; } public partial class ExptypeHeadContext : ParserRuleContext { - public object Value; + public CILParser.ExportedTypeHeaderValue Value; public IToken head; public ExptAttrsContext attributes; public DottedNameContext name; @@ -16929,6 +17251,7 @@ public ExptypeHeadContext(ParserRuleContext parent, int invokingState) public ExptypeHeadContext exptypeHead() { ExptypeHeadContext _localctx = new ExptypeHeadContext(Context, State); EnterRule(_localctx, 346, RULE_exptypeHead); + _localctx.Value = CILParser.ExportedTypeHeaderValue.Error; try { EnterOuterAlt(_localctx, 1); { @@ -16958,7 +17281,7 @@ public ExptypeHeadContext exptypeHead() { } public partial class ExportHeadContext : ParserRuleContext { - public object Value; + public CILParser.ExportedTypeHeaderValue Value; public IToken head; public ExptAttrsContext attributes; public DottedNameContext name; @@ -16980,6 +17303,7 @@ public ExportHeadContext(ParserRuleContext parent, int invokingState) public ExportHeadContext exportHead() { ExportHeadContext _localctx = new ExportHeadContext(Context, State); EnterRule(_localctx, 348, RULE_exportHead); + _localctx.Value = CILParser.ExportedTypeHeaderValue.Error; try { EnterOuterAlt(_localctx, 1); { @@ -17171,7 +17495,8 @@ public ExptAttrContext exptAttr() { } public partial class ExptypeDeclsContext : ParserRuleContext { - public object Value; + public System.Collections.Immutable.ImmutableArray Value; + public System.Collections.Immutable.ImmutableArray.Builder Builder; public ExptypeDeclContext declaration; [System.Diagnostics.DebuggerNonUserCode] public ExptypeDeclContext[] exptypeDecl() { return GetRuleContexts(); @@ -17190,7 +17515,7 @@ public ExptypeDeclsContext(ParserRuleContext parent, int invokingState) public ExptypeDeclsContext exptypeDecls() { ExptypeDeclsContext _localctx = new ExptypeDeclsContext(Context, State); EnterRule(_localctx, 354, RULE_exptypeDecls); - Actions.BeginExportedTypeDeclarations(_localctx); + _localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -17203,7 +17528,7 @@ public ExptypeDeclsContext exptypeDecls() { { State = 3601; _localctx.declaration = exptypeDecl(); - Actions.AddExportedTypeDeclaration(_localctx, _localctx.declaration.Value); + if (_localctx.declaration.Value is not null) _localctx.Builder.Add(_localctx.declaration.Value); } } State = 3608; @@ -17218,14 +17543,14 @@ public ExptypeDeclsContext exptypeDecls() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndExportedTypeDeclarations(_localctx); + _localctx.Value = _localctx.Builder.ToImmutable(); ExitRule(); } return _localctx; } public partial class ExptypeDeclContext : ParserRuleContext { - public object Value; + public CILParser.ExportedTypeDeclarationValue? Value; public IToken location; public DottedNameContext name; public SlashedNameContext nestedName; @@ -17358,8 +17683,9 @@ public ExptypeDeclContext exptypeDecl() { } public partial class ManifestResBlockContext : ParserRuleContext { - public object Value; + public CILParser.ManifestResourceValue? Value; public bool HasSyntaxError; + public int InitialSyntaxErrorCount; public ManifestResHeadContext header; public ManifestResDeclsContext declarations; [System.Diagnostics.DebuggerNonUserCode] public ManifestResHeadContext manifestResHead() { @@ -17379,7 +17705,7 @@ public ManifestResBlockContext(ParserRuleContext parent, int invokingState) public ManifestResBlockContext manifestResBlock() { ManifestResBlockContext _localctx = new ManifestResBlockContext(Context, State); EnterRule(_localctx, 358, RULE_manifestResBlock); - Actions.BeginSemanticRoot(_localctx); + _localctx.InitialSyntaxErrorCount = Actions.SyntaxErrorCount; try { EnterOuterAlt(_localctx, 1); { @@ -17393,8 +17719,7 @@ public ManifestResBlockContext manifestResBlock() { Match(T__17); _localctx.Value = Actions.CreateManifestResource( _localctx.header.Value, - _localctx.declarations.Value, - (_localctx.header!=null?(_localctx.header.Start):null)); + _localctx.declarations.Value); } } catch (RecognitionException re) { @@ -17403,14 +17728,22 @@ public ManifestResBlockContext manifestResBlock() { ErrorHandler.Recover(this, re); } finally { - _localctx.HasSyntaxError = Actions.EndSemanticRoot(_localctx); + + _localctx.HasSyntaxError = + Actions.HasSyntaxErrorsSince(_localctx.InitialSyntaxErrorCount) || + _localctx.exception is not null; + if (_localctx.HasSyntaxError) + { + _localctx.Value = null; + } + ExitRule(); } return _localctx; } public partial class ManifestResHeadContext : ParserRuleContext { - public object Value; + public CILParser.ManifestResourceHeaderValue Value; public IToken head; public ManresAttrsContext attributes; public DottedNameContext name; @@ -17436,6 +17769,7 @@ public ManifestResHeadContext(ParserRuleContext parent, int invokingState) public ManifestResHeadContext manifestResHead() { ManifestResHeadContext _localctx = new ManifestResHeadContext(Context, State); EnterRule(_localctx, 360, RULE_manifestResHead); + _localctx.Value = CILParser.ManifestResourceHeaderValue.Error; try { State = 3654; ErrorHandler.Sync(this); @@ -17586,7 +17920,8 @@ public ManresAttrContext manresAttr() { } public partial class ManifestResDeclsContext : ParserRuleContext { - public object Value; + public System.Collections.Immutable.ImmutableArray Value; + public System.Collections.Immutable.ImmutableArray.Builder Builder; public ManifestResDeclContext declaration; [System.Diagnostics.DebuggerNonUserCode] public ManifestResDeclContext[] manifestResDecl() { return GetRuleContexts(); @@ -17605,7 +17940,7 @@ public ManifestResDeclsContext(ParserRuleContext parent, int invokingState) public ManifestResDeclsContext manifestResDecls() { ManifestResDeclsContext _localctx = new ManifestResDeclsContext(Context, State); EnterRule(_localctx, 366, RULE_manifestResDecls); - Actions.BeginManifestResourceDeclarations(_localctx); + _localctx.Builder = System.Collections.Immutable.ImmutableArray.CreateBuilder(); int _la; try { EnterOuterAlt(_localctx, 1); @@ -17618,7 +17953,7 @@ public ManifestResDeclsContext manifestResDecls() { { State = 3666; _localctx.declaration = manifestResDecl(); - Actions.AddManifestResourceDeclaration(_localctx, _localctx.declaration.Value); + if (_localctx.declaration.Value is not null) _localctx.Builder.Add(_localctx.declaration.Value); } } State = 3673; @@ -17633,14 +17968,14 @@ public ManifestResDeclsContext manifestResDecls() { ErrorHandler.Recover(this, re); } finally { - _localctx.Value = Actions.EndManifestResourceDeclarations(_localctx); + _localctx.Value = _localctx.Builder.ToImmutable(); ExitRule(); } return _localctx; } public partial class ManifestResDeclContext : ParserRuleContext { - public object Value; + public CILParser.ManifestResourceDeclarationValue? Value; public IToken location; public DottedNameContext name; public Int32Context offset; diff --git a/src/tools/ilasm/src/ILAssembler/gen/ilasm-generator.csproj b/src/tools/ilasm/src/ILAssembler/gen/ilasm-generator.csproj index 48f73dbd39a46e..9d5efdadea9022 100644 --- a/src/tools/ilasm/src/ILAssembler/gen/ilasm-generator.csproj +++ b/src/tools/ilasm/src/ILAssembler/gen/ilasm-generator.csproj @@ -45,9 +45,13 @@ - + + diff --git a/src/tools/ilasm/src/ILAssembler/ref/ILAssembler.csproj b/src/tools/ilasm/src/ILAssembler/ref/ILAssembler.csproj new file mode 100644 index 00000000000000..d5a9549b600108 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/ref/ILAssembler.csproj @@ -0,0 +1,11 @@ + + + + ILAssembler + ref + enable + ILAssembler + $(NetCoreAppToolCurrent) + + + diff --git a/src/tools/ilasm/src/ILAssembler/ref/ILAssembler/CompilationResult.cs b/src/tools/ilasm/src/ILAssembler/ref/ILAssembler/CompilationResult.cs new file mode 100644 index 00000000000000..ce87f9d898c1b8 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/ref/ILAssembler/CompilationResult.cs @@ -0,0 +1,12 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace ILAssembler +{ + public sealed class CompilationResult + { + internal CompilationResult() { } + + public System.Reflection.Metadata.BlobContentId Serialize(System.Reflection.Metadata.BlobBuilder builder) { throw null; } + } +} diff --git a/src/tools/ilasm/src/ILAssembler/ref/ILAssembler/Diagnostic.cs b/src/tools/ilasm/src/ILAssembler/ref/ILAssembler/Diagnostic.cs new file mode 100644 index 00000000000000..f1d97027369858 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/ref/ILAssembler/Diagnostic.cs @@ -0,0 +1,57 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace ILAssembler +{ + public record Diagnostic(string Id, DiagnosticSeverity Severity, string Message, Location Location); + + public static class DiagnosticIds + { + public const string AbstractMethodNotInAbstractType = "ILA0021"; + public const string ArgumentNotFound = "ILA0018"; + public const string AssemblyNotFound = "ILA0014"; + public const string BaseOutsideClass = "ILA0004"; + public const string ByteArrayTooShort = "ILA0016"; + public const string DeprecatedCustomMarshaller = "ILA0025"; + public const string DeprecatedNativeType = "ILA0024"; + public const string DuplicateMethod = "ILA0030"; + public const string ExportedTypeNotFound = "ILA0015"; + public const string FileNotFound = "ILA0013"; + public const string GenericParameterIndexOutOfRange = "ILA0027"; + public const string GenericParameterNotFound = "ILA0011"; + public const string InvalidMetadataToken = "ILA0012"; + public const string InvalidPInvokeSignature = "ILA0022"; + public const string KeyFileError = "ILA0032"; + public const string LabelNotFound = "ILA0017"; + public const string LiteralOutOfRange = "ILA0001"; + public const string LocalNotFound = "ILA0019"; + public const string MethodTypeParameterOutsideMethod = "ILA0009"; + public const string MissingExportedTypeImplementation = "ILA0031"; + public const string MissingInstanceCallConv = "ILA0023"; + public const string ModuleNotFound = "ILA0007"; + public const string NesterOutsideNestedClass = "ILA0006"; + public const string NoBaseType = "ILA0005"; + public const string ParameterIndexOutOfRange = "ILA0029"; + public const string PseudoCustomAttributeInvalidBlob = "ILA0036"; + public const string PseudoCustomAttributeInvalidGuid = "ILA0037"; + public const string PseudoCustomAttributeInvalidTarget = "ILA0034"; + public const string PseudoCustomAttributeInvalidValue = "ILA0035"; + public const string PseudoCustomAttributeRepeatedArgument = "ILA0039"; + public const string PseudoCustomAttributeUnknownArgument = "ILA0038"; + public const string ThisOutsideClass = "ILA0003"; + public const string TypeNotFound = "ILA0008"; + public const string TypeParameterOutsideType = "ILA0010"; + public const string TypedefNotFound = "ILA0020"; + public const string UnknownGenericParameter = "ILA0028"; + public const string UnsealedValueType = "ILA0002"; + public const string UnsupportedSecurityDeclaration = "ILA0026"; + } + + public enum DiagnosticSeverity + { + Error, + Warning, + Info, + Hidden + } +} diff --git a/src/tools/ilasm/src/ILAssembler/ref/ILAssembler/DocumentCompiler.cs b/src/tools/ilasm/src/ILAssembler/ref/ILAssembler/DocumentCompiler.cs new file mode 100644 index 00000000000000..523df3022e7efc --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/ref/ILAssembler/DocumentCompiler.cs @@ -0,0 +1,20 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace ILAssembler +{ + public sealed class DocumentCompiler + { + public (System.Collections.Immutable.ImmutableArray, CompilationResult?) Compile( + System.Collections.Immutable.ImmutableArray documents, + System.Func includedDocumentLoader, + System.Func resourceLocator, + Options options) { throw null; } + + public (System.Collections.Immutable.ImmutableArray, CompilationResult?) Compile( + SourceText document, + System.Func includedDocumentLoader, + System.Func resourceLocator, + Options options) { throw null; } + } +} diff --git a/src/tools/ilasm/src/ILAssembler/ref/ILAssembler/Location.cs b/src/tools/ilasm/src/ILAssembler/ref/ILAssembler/Location.cs new file mode 100644 index 00000000000000..73e456f5385d13 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/ref/ILAssembler/Location.cs @@ -0,0 +1,7 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace ILAssembler +{ + public record Location(SourceSpan Span, SourceText Source); +} diff --git a/src/tools/ilasm/src/ILAssembler/ref/ILAssembler/Options.cs b/src/tools/ilasm/src/ILAssembler/ref/ILAssembler/Options.cs new file mode 100644 index 00000000000000..8a5c54d0500efe --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/ref/ILAssembler/Options.cs @@ -0,0 +1,39 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace ILAssembler +{ + public enum DebugMode + { + Impl, + Opt + } + + public sealed class Options + { + public bool AppContainer { get; set; } + public string? AssemblyName { get; set; } + public System.Reflection.PortableExecutable.CorFlags? CorFlags { get; set; } + public bool Debug { get; set; } + public DebugMode? DebugMode { get; set; } + public bool Deterministic { get; set; } + public bool Dll { get; set; } + public bool ErrorTolerant { get; set; } + public int? FileAlignment { get; set; } + public bool Fold { get; set; } + public bool HighEntropyVA { get; set; } + public long? ImageBase { get; set; } + public string? KeyFile { get; set; } + public System.Reflection.PortableExecutable.Machine? Machine { get; set; } + public string? MetadataVersion { get; set; } + public bool NoAutoInherit { get; set; } + public bool Optimize { get; set; } + public string? OutputFileName { get; set; } + public bool Pdb { get; set; } + public bool Prefer32Bit { get; set; } + public long? StackReserve { get; set; } + public bool StripReloc { get; set; } + public System.Reflection.PortableExecutable.Subsystem? Subsystem { get; set; } + public (ushort Major, ushort Minor)? SubsystemVersion { get; set; } + } +} diff --git a/src/tools/ilasm/src/ILAssembler/ref/ILAssembler/SourceSpan.cs b/src/tools/ilasm/src/ILAssembler/ref/ILAssembler/SourceSpan.cs new file mode 100644 index 00000000000000..fc2a97e1f12d7d --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/ref/ILAssembler/SourceSpan.cs @@ -0,0 +1,7 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace ILAssembler +{ + public record SourceSpan(int Start, int Length); +} diff --git a/src/tools/ilasm/src/ILAssembler/ref/ILAssembler/SourceText.cs b/src/tools/ilasm/src/ILAssembler/ref/ILAssembler/SourceText.cs new file mode 100644 index 00000000000000..3ce53fec7d4d88 --- /dev/null +++ b/src/tools/ilasm/src/ILAssembler/ref/ILAssembler/SourceText.cs @@ -0,0 +1,7 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace ILAssembler +{ + public record SourceText(string Text, string Path); +} diff --git a/src/tools/ilasm/tests/ILAssembler.Tests/ILAssembler.Tests.csproj b/src/tools/ilasm/tests/ILAssembler.Tests/ILAssembler.Tests.csproj index f621b0e97351f3..4532515e27b6fb 100644 --- a/src/tools/ilasm/tests/ILAssembler.Tests/ILAssembler.Tests.csproj +++ b/src/tools/ilasm/tests/ILAssembler.Tests/ILAssembler.Tests.csproj @@ -10,7 +10,7 @@ - + diff --git a/src/tools/ilasm/tests/ILAssembler.Tests/SyntaxTests.cs b/src/tools/ilasm/tests/ILAssembler.Tests/SyntaxTests.cs index 979f69200ca730..b4bbe433189d3e 100644 --- a/src/tools/ilasm/tests/ILAssembler.Tests/SyntaxTests.cs +++ b/src/tools/ilasm/tests/ILAssembler.Tests/SyntaxTests.cs @@ -250,6 +250,137 @@ public void TruncatedDocument_ReportsDiagnosticsInsteadOfThrowing(string source) Assert.Contains(diagnostics, diagnostic => diagnostic.Severity == DiagnosticSeverity.Error); } + [Theory] + [InlineData(".assembly extern { }")] + [InlineData(".mresource public { }")] + [InlineData(".class public auto ansi Test { .event { } }")] + [InlineData(".class public auto ansi Test { .property { } }")] + [InlineData(""" + .class public auto ansi Test + { + .custom instance void [mscorlib]System.ObsoleteAttribute::.ctor(string) = { string( } + } + """)] + [InlineData(""" + .class public auto ansi Test + { + .method public static void M(int32,) cil managed + { + ret + } + } + """)] + [InlineData(".class public auto ansi Test { .field public }")] + [InlineData(".typedef")] + [InlineData(".custom")] + [InlineData(".class flags( public Test { }")] + [InlineData(".class public auto ansi Test<+> { }")] + [InlineData(".class public auto ansi Test { .field marshal( int32 F }")] + [InlineData(".class public auto ansi Test { .field public int32 F = bytearray( }")] + [InlineData(""" + .class public auto ansi Test + { + .method pinvokeimpl( public static void M() cil managed + { + ret + } + } + """)] + [InlineData(""" + .class public auto ansi Test + { + .method public static void M(,) cil managed + { + ret + } + } + """)] + [InlineData(""" + .class public auto ansi Test + { + .method public static void M() cil managed + { + .custom + ret + } + } + """)] + [InlineData(".permission demand class X (Name = )")] + [InlineData(".class extern { }")] + [InlineData(".class public auto ansi Test { .export public { } }")] + [InlineData(".assembly extern Name { .ver : }")] + public void MalformedTypedGrammarValues_ReportParserDiagnosticsInsteadOfThrowing(string source) + { + var diagnostics = DocumentCompilerTestHelpers.CompileAndGetDiagnostics(source, new Options()); + + Assert.Contains(diagnostics, diagnostic => diagnostic.Id == "Parser"); + } + + public static TheoryData TruncatedDirectiveMutations + { + get + { + string[] sources = + [ + ".assembly extern Dependency { .publickeytoken = (01 02 03 04) .ver 1:2:3:4 }", + ".mresource public Resource { .assembly extern Dependency }", + ".class extern public Exported { .assembly extern Dependency }", + ".typedef method instance void [mscorlib]System.Object::.ctor() as Constructor", + ".permission demand [mscorlib]System.Security.Permissions.SecurityPermissionAttribute = { }", + """ + .class public auto ansi Test extends [mscorlib]System.Object implements [mscorlib]System.IDisposable + { + .field public marshal(int32) int32 F = int32(1) + .event specialname [mscorlib]System.EventHandler E { } + .property specialname int32 P() { } + .method public static void M(int32 value) cil managed + { + .custom instance void [mscorlib]System.ObsoleteAttribute::.ctor() = (01 00 00 00) + ret + } + } + """ + ]; + + HashSet uniqueMutations = new(StringComparer.Ordinal); + TheoryData mutations = new(); + foreach (string source in sources) + { + for (int i = 1; i < source.Length; i++) + { + if (!char.IsWhiteSpace(source[i - 1]) && + char.IsWhiteSpace(source[i])) + { + string mutation = source.Substring(0, i); + if (uniqueMutations.Add(mutation)) + { + mutations.Add(mutation, false); + mutations.Add(mutation, true); + } + } + } + } + + return mutations; + } + } + + [Theory] + [MemberData(nameof(TruncatedDirectiveMutations))] + public void TruncatedDirectiveMutationCorpus_ReportsDiagnosticsInsteadOfThrowing( + string source, + bool errorTolerant) + { + ImmutableArray diagnostics = + DocumentCompilerTestHelpers.CompileAndGetDiagnostics( + source, + new Options { ErrorTolerant = errorTolerant }); + + Assert.Contains( + diagnostics, + diagnostic => diagnostic.Severity == DiagnosticSeverity.Error); + } + [Fact] public void ParserErrorListener_ReportsSyntaxErrors() {